Remove global motion from compressed header

This requires making a temporary copy of the functions in
binary_codes_writer/reader to take in the aom_write_bit_buffer type.

Change-Id: Idb60b29cff69b45224535c6e6a4079a34a2c6871

aom_dsp/binary_codes_writer.c

diff --git a/aom_dsp/binary_codes_writer.c b/aom_dsp/binary_codes_writer.c
index 91e807b..e092b62 100644
--- a/aom_dsp/binary_codes_writer.c
+++ b/aom_dsp/binary_codes_writer.c
@@ -10,6 +10,7 @@
  */
 
 #include "aom_dsp/bitwriter.h"
+#include "aom_dsp/binary_codes_writer.h"
 
 #include "av1/common/common.h"
 
@@ -68,6 +69,19 @@
   }
 }
 
+static void aom_wb_write_primitive_quniform(struct aom_write_bit_buffer *wb,
+                                            uint16_t n, uint16_t v) {
+  if (n <= 1) return;
+  const int l = get_msb(n - 1) + 1;
+  const int m = (1 << l) - n;
+  if (v < m) {
+    aom_wb_write_literal(wb, v, l - 1);
+  } else {
+    aom_wb_write_literal(wb, m + ((v - m) >> 1), l - 1);
+    aom_wb_write_bit(wb, (v - m) & 1);
+  }
+}
+
 int aom_count_primitive_quniform(uint16_t n, uint16_t v) {
   if (n <= 1) return 0;
   const int l = get_msb(n - 1) + 1;
@@ -155,6 +169,31 @@
   }
 }
 
+static void aom_wb_write_primitive_subexpfin(struct aom_write_bit_buffer *wb,
+                                             uint16_t n, uint16_t k,
+                                             uint16_t v) {
+  int i = 0;
+  int mk = 0;
+  while (1) {
+    int b = (i ? k + i - 1 : k);
+    int a = (1 << b);
+    if (n <= mk + 3 * a) {
+      aom_wb_write_primitive_quniform(wb, n - mk, v - mk);
+      break;
+    } else {
+      int t = (v >= mk + a);
+      aom_wb_write_bit(wb, t);
+      if (t) {
+        i = i + 1;
+        mk += a;
+      } else {
+        aom_wb_write_literal(wb, v - mk, b);
+        break;
+      }
+    }
+  }
+}
+
 int aom_count_primitive_subexpfin(uint16_t n, uint16_t k, uint16_t v) {
   int count = 0;
   int i = 0;
@@ -184,19 +223,34 @@
 // based on a reference ref also in [0, n-1].
 // Recenters symbol around r first and then uses a finite subexponential code.
 void aom_write_primitive_refsubexpfin(aom_writer *w, uint16_t n, uint16_t k,
-                                      int16_t ref, int16_t v) {
+                                      uint16_t ref, uint16_t v) {
   aom_write_primitive_subexpfin(w, n, k, recenter_finite_nonneg(n, ref, v));
 }
 
+static void aom_wb_write_primitive_refsubexpfin(struct aom_write_bit_buffer *wb,
+                                                uint16_t n, uint16_t k,
+                                                uint16_t ref, uint16_t v) {
+  aom_wb_write_primitive_subexpfin(wb, n, k, recenter_finite_nonneg(n, ref, v));
+}
+
 void aom_write_signed_primitive_refsubexpfin(aom_writer *w, uint16_t n,
-                                             uint16_t k, uint16_t ref,
-                                             uint16_t v) {
+                                             uint16_t k, int16_t ref,
+                                             int16_t v) {
   ref += n - 1;
   v += n - 1;
   const uint16_t scaled_n = (n << 1) - 1;
   aom_write_primitive_refsubexpfin(w, scaled_n, k, ref, v);
 }
 
+void aom_wb_write_signed_primitive_refsubexpfin(struct aom_write_bit_buffer *wb,
+                                                uint16_t n, uint16_t k,
+                                                int16_t ref, int16_t v) {
+  ref += n - 1;
+  v += n - 1;
+  const uint16_t scaled_n = (n << 1) - 1;
+  aom_wb_write_primitive_refsubexpfin(wb, scaled_n, k, ref, v);
+}
+
 int aom_count_primitive_refsubexpfin(uint16_t n, uint16_t k, uint16_t ref,
                                      uint16_t v) {
   return aom_count_primitive_subexpfin(n, k, recenter_finite_nonneg(n, ref, v));