diff --git a/aom_dsp/aom_dsp.cmake b/aom_dsp/aom_dsp.cmake
index 1ec9101..3685d76 100644
--- a/aom_dsp/aom_dsp.cmake
+++ b/aom_dsp/aom_dsp.cmake
@@ -35,6 +35,7 @@
             "${AOM_ROOT}/aom_dsp/intrapred_common.h"
             "${AOM_ROOT}/aom_dsp/loopfilter.c"
             "${AOM_ROOT}/aom_dsp/prob.h"
+            "${AOM_ROOT}/aom_dsp/recenter.h"
             "${AOM_ROOT}/aom_dsp/simd/v128_intrinsics.h"
             "${AOM_ROOT}/aom_dsp/simd/v128_intrinsics_c.h"
             "${AOM_ROOT}/aom_dsp/simd/v256_intrinsics.h"
diff --git a/aom_dsp/binary_codes_reader.c b/aom_dsp/binary_codes_reader.c
index 0108801..7cd903d 100644
--- a/aom_dsp/binary_codes_reader.c
+++ b/aom_dsp/binary_codes_reader.c
@@ -10,29 +10,9 @@
  */
 
 #include "aom_dsp/binary_codes_reader.h"
-
+#include "aom_dsp/recenter.h"
 #include "av1/common/common.h"
 
-// Inverse recenters a non-negative literal v around a reference r
-static uint16_t inv_recenter_nonneg(uint16_t r, uint16_t v) {
-  if (v > (r << 1))
-    return v;
-  else if ((v & 1) == 0)
-    return (v >> 1) + r;
-  else
-    return r - ((v + 1) >> 1);
-}
-
-// Inverse recenters a non-negative literal v in [0, n-1] around a
-// reference r also in [0, n-1]
-static uint16_t inv_recenter_finite_nonneg(uint16_t n, uint16_t r, uint16_t v) {
-  if ((r << 1) <= n) {
-    return inv_recenter_nonneg(r, v);
-  } else {
-    return n - 1 - inv_recenter_nonneg(n - 1 - r, v);
-  }
-}
-
 uint16_t aom_read_primitive_quniform_(aom_reader *r,
                                       uint16_t n ACCT_STR_PARAM) {
   if (n <= 1) return 0;
@@ -42,15 +22,6 @@
   return v < m ? v : (v << 1) - m + aom_read_bit(r, ACCT_STR_NAME);
 }
 
-static uint16_t aom_rb_read_primitive_quniform(struct aom_read_bit_buffer *rb,
-                                               uint16_t n) {
-  if (n <= 1) return 0;
-  const int l = get_msb(n) + 1;
-  const int m = (1 << l) - n;
-  const int v = aom_rb_read_literal(rb, l - 1);
-  return v < m ? v : (v << 1) - m + aom_rb_read_bit(rb);
-}
-
 // Decode finite subexponential code that for a symbol v in [0, n-1] with
 // parameter k
 uint16_t aom_read_primitive_subexpfin_(aom_reader *r, uint16_t n,
@@ -78,46 +49,8 @@
   return 0;
 }
 
-static uint16_t aom_rb_read_primitive_subexpfin(struct aom_read_bit_buffer *rb,
-                                                uint16_t n, uint16_t k) {
-  int i = 0;
-  int mk = 0;
-
-  while (1) {
-    int b = (i ? k + i - 1 : k);
-    int a = (1 << b);
-
-    if (n <= mk + 3 * a) {
-      return aom_rb_read_primitive_quniform(rb, n - mk) + mk;
-    }
-
-    if (!aom_rb_read_bit(rb)) {
-      return aom_rb_read_literal(rb, b) + mk;
-    }
-
-    i = i + 1;
-    mk += a;
-  }
-
-  assert(0);
-  return 0;
-}
-
 uint16_t aom_read_primitive_refsubexpfin_(aom_reader *r, uint16_t n, uint16_t k,
                                           uint16_t ref ACCT_STR_PARAM) {
   return inv_recenter_finite_nonneg(
       n, ref, aom_read_primitive_subexpfin(r, n, k, ACCT_STR_NAME));
 }
-
-static uint16_t aom_rb_read_primitive_refsubexpfin(
-    struct aom_read_bit_buffer *rb, uint16_t n, uint16_t k, uint16_t ref) {
-  return inv_recenter_finite_nonneg(n, ref,
-                                    aom_rb_read_primitive_subexpfin(rb, n, k));
-}
-
-int16_t aom_rb_read_signed_primitive_refsubexpfin(
-    struct aom_read_bit_buffer *rb, uint16_t n, uint16_t k, int16_t ref) {
-  ref += n - 1;
-  const uint16_t scaled_n = (n << 1) - 1;
-  return aom_rb_read_primitive_refsubexpfin(rb, scaled_n, k, ref) - n + 1;
-}
diff --git a/aom_dsp/binary_codes_reader.h b/aom_dsp/binary_codes_reader.h
index 364a674..d218f06 100644
--- a/aom_dsp/binary_codes_reader.h
+++ b/aom_dsp/binary_codes_reader.h
@@ -37,9 +37,6 @@
 uint16_t aom_read_primitive_refsubexpfin_(aom_reader *r, uint16_t n, uint16_t k,
                                           uint16_t ref ACCT_STR_PARAM);
 
-int16_t aom_rb_read_signed_primitive_refsubexpfin(
-    struct aom_read_bit_buffer *rb, uint16_t n, uint16_t k, int16_t ref);
-
 #ifdef __cplusplus
 }  // extern "C"
 #endif
diff --git a/aom_dsp/binary_codes_writer.c b/aom_dsp/binary_codes_writer.c
index ee7a9f5..adf1c13 100644
--- a/aom_dsp/binary_codes_writer.c
+++ b/aom_dsp/binary_codes_writer.c
@@ -11,29 +11,10 @@
 
 #include "aom_dsp/bitwriter.h"
 #include "aom_dsp/binary_codes_writer.h"
-
+#include "aom_dsp/recenter.h"
+#include "aom_ports/bitops.h"
 #include "av1/common/common.h"
 
-// Recenters a non-negative literal v around a reference r
-static uint16_t recenter_nonneg(uint16_t r, uint16_t v) {
-  if (v > (r << 1))
-    return v;
-  else if (v >= r)
-    return ((v - r) << 1);
-  else
-    return ((r - v) << 1) - 1;
-}
-
-// Recenters a non-negative literal v in [0, n-1] around a
-// reference r also in [0, n-1]
-static uint16_t recenter_finite_nonneg(uint16_t n, uint16_t r, uint16_t v) {
-  if ((r << 1) <= n) {
-    return recenter_nonneg(r, v);
-  } else {
-    return recenter_nonneg(n - 1 - r, n - 1 - v);
-  }
-}
-
 // Codes a symbol v in [-2^mag_bits, 2^mag_bits].
 // mag_bits is number of bits for magnitude. The alphabet is of size
 // 2 * 2^mag_bits + 1, symmetric around 0, where one bit is used to
@@ -69,19 +50,6 @@
   }
 }
 
-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;
-  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;
@@ -114,31 +82,6 @@
   }
 }
 
-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;
@@ -172,12 +115,6 @@
   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, int16_t ref,
                                              int16_t v) {
@@ -187,15 +124,6 @@
   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));
diff --git a/aom_dsp/binary_codes_writer.h b/aom_dsp/binary_codes_writer.h
index c360e0e..5ec8662 100644
--- a/aom_dsp/binary_codes_writer.h
+++ b/aom_dsp/binary_codes_writer.h
@@ -49,10 +49,6 @@
                                              uint16_t k, int16_t ref,
                                              int16_t 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);
-
 // Functions that counts bits for the above primitives
 int aom_count_primitive_symmetric(int16_t v, unsigned int mag_bits);
 int aom_count_primitive_quniform(uint16_t n, uint16_t v);
@@ -61,6 +57,7 @@
                                      uint16_t v);
 int aom_count_signed_primitive_refsubexpfin(uint16_t n, uint16_t k, int16_t ref,
                                             int16_t v);
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif
diff --git a/aom_dsp/bitreader_buffer.c b/aom_dsp/bitreader_buffer.c
index b532117..984b217 100644
--- a/aom_dsp/bitreader_buffer.c
+++ b/aom_dsp/bitreader_buffer.c
@@ -14,6 +14,8 @@
 #include "config/aom_config.h"
 
 #include "aom_dsp/bitreader_buffer.h"
+#include "aom_dsp/recenter.h"
+#include "aom_ports/bitops.h"
 
 size_t aom_rb_bytes_read(const struct aom_read_bit_buffer *rb) {
   return (rb->bit_offset + 7) >> 3;
@@ -65,3 +67,50 @@
   const uint32_t value = aom_rb_read_literal(rb, leading_zeros);
   return base + value;
 }
+
+static uint16_t aom_rb_read_primitive_quniform(struct aom_read_bit_buffer *rb,
+                                               uint16_t n) {
+  if (n <= 1) return 0;
+  const int l = get_msb(n) + 1;
+  const int m = (1 << l) - n;
+  const int v = aom_rb_read_literal(rb, l - 1);
+  return v < m ? v : (v << 1) - m + aom_rb_read_bit(rb);
+}
+
+static uint16_t aom_rb_read_primitive_subexpfin(struct aom_read_bit_buffer *rb,
+                                                uint16_t n, uint16_t k) {
+  int i = 0;
+  int mk = 0;
+
+  while (1) {
+    int b = (i ? k + i - 1 : k);
+    int a = (1 << b);
+
+    if (n <= mk + 3 * a) {
+      return aom_rb_read_primitive_quniform(rb, n - mk) + mk;
+    }
+
+    if (!aom_rb_read_bit(rb)) {
+      return aom_rb_read_literal(rb, b) + mk;
+    }
+
+    i = i + 1;
+    mk += a;
+  }
+
+  assert(0);
+  return 0;
+}
+
+static uint16_t aom_rb_read_primitive_refsubexpfin(
+    struct aom_read_bit_buffer *rb, uint16_t n, uint16_t k, uint16_t ref) {
+  return inv_recenter_finite_nonneg(n, ref,
+                                    aom_rb_read_primitive_subexpfin(rb, n, k));
+}
+
+int16_t aom_rb_read_signed_primitive_refsubexpfin(
+    struct aom_read_bit_buffer *rb, uint16_t n, uint16_t k, int16_t ref) {
+  ref += n - 1;
+  const uint16_t scaled_n = (n << 1) - 1;
+  return aom_rb_read_primitive_refsubexpfin(rb, scaled_n, k, ref) - n + 1;
+}
diff --git a/aom_dsp/bitreader_buffer.h b/aom_dsp/bitreader_buffer.h
index 725ca1e..359fbe5 100644
--- a/aom_dsp/bitreader_buffer.h
+++ b/aom_dsp/bitreader_buffer.h
@@ -43,6 +43,9 @@
 
 uint32_t aom_rb_read_uvlc(struct aom_read_bit_buffer *rb);
 
+int16_t aom_rb_read_signed_primitive_refsubexpfin(
+    struct aom_read_bit_buffer *rb, uint16_t n, uint16_t k, int16_t ref);
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif
diff --git a/aom_dsp/bitwriter_buffer.c b/aom_dsp/bitwriter_buffer.c
index 596246d..c08cc9d 100644
--- a/aom_dsp/bitwriter_buffer.c
+++ b/aom_dsp/bitwriter_buffer.c
@@ -16,6 +16,8 @@
 #include "config/aom_config.h"
 
 #include "aom_dsp/bitwriter_buffer.h"
+#include "aom_dsp/recenter.h"
+#include "aom_ports/bitops.h"
 
 int aom_wb_is_byte_aligned(const struct aom_write_bit_buffer *wb) {
   return (wb->bit_offset % CHAR_BIT == 0);
@@ -85,3 +87,56 @@
   aom_wb_write_literal(wb, 0, leading_zeroes >> 1);
   aom_wb_write_unsigned_literal(wb, v, (leading_zeroes + 1) >> 1);
 }
+
+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;
+  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);
+  }
+}
+
+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;
+      }
+    }
+  }
+}
+
+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_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);
+}
diff --git a/aom_dsp/bitwriter_buffer.h b/aom_dsp/bitwriter_buffer.h
index d031128..fd10e01 100644
--- a/aom_dsp/bitwriter_buffer.h
+++ b/aom_dsp/bitwriter_buffer.h
@@ -44,6 +44,10 @@
 
 void aom_wb_write_uvlc(struct aom_write_bit_buffer *wb, uint32_t 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);
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif
diff --git a/aom_dsp/recenter.h b/aom_dsp/recenter.h
new file mode 100644
index 0000000..b3fd412
--- /dev/null
+++ b/aom_dsp/recenter.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2018, Alliance for Open Media. All rights reserved
+ *
+ * This source code is subject to the terms of the BSD 2 Clause License and
+ * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
+ * was not distributed with this source code in the LICENSE file, you can
+ * obtain it at www.aomedia.org/license/software. If the Alliance for Open
+ * Media Patent License 1.0 was not distributed with this source code in the
+ * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
+ */
+
+#ifndef AOM_AOM_DSP_RECENTER_H_
+#define AOM_AOM_DSP_RECENTER_H_
+
+#include "config/aom_config.h"
+
+#include "aom/aom_integer.h"
+
+// Inverse recenters a non-negative literal v around a reference r
+static INLINE uint16_t inv_recenter_nonneg(uint16_t r, uint16_t v) {
+  if (v > (r << 1))
+    return v;
+  else if ((v & 1) == 0)
+    return (v >> 1) + r;
+  else
+    return r - ((v + 1) >> 1);
+}
+
+// Inverse recenters a non-negative literal v in [0, n-1] around a
+// reference r also in [0, n-1]
+static INLINE uint16_t inv_recenter_finite_nonneg(uint16_t n, uint16_t r,
+                                                  uint16_t v) {
+  if ((r << 1) <= n) {
+    return inv_recenter_nonneg(r, v);
+  } else {
+    return n - 1 - inv_recenter_nonneg(n - 1 - r, v);
+  }
+}
+
+// Recenters a non-negative literal v around a reference r
+static INLINE uint16_t recenter_nonneg(uint16_t r, uint16_t v) {
+  if (v > (r << 1))
+    return v;
+  else if (v >= r)
+    return ((v - r) << 1);
+  else
+    return ((r - v) << 1) - 1;
+}
+
+// Recenters a non-negative literal v in [0, n-1] around a
+// reference r also in [0, n-1]
+static INLINE uint16_t recenter_finite_nonneg(uint16_t n, uint16_t r,
+                                              uint16_t v) {
+  if ((r << 1) <= n) {
+    return recenter_nonneg(r, v);
+  } else {
+    return recenter_nonneg(n - 1 - r, n - 1 - v);
+  }
+}
+
+#endif  // AOM_AOM_DSP_RECENTER_H_