Move av1_ceil_log2() to aom_ports/bitops.h

get_msb() and av1_ceil_log2() are the FloorLog2() and CeilLog2()
functions in the AV1 specification, so declare them in the same header
file, aom_ports/bitops.h. Change the prefix to aom: aom_ceil_log2().

Change-Id: If8cbb8a3d45110b8f8ca26388d52020867ee77c7

aom_ports/bitops.h

diff --git a/aom_ports/bitops.h b/aom_ports/bitops.h
index cac529e..cbcfe5f 100644
--- a/aom_ports/bitops.h
+++ b/aom_ports/bitops.h
@@ -70,6 +70,12 @@
 }
 #endif
 
+// Returns (int)ceil(log2(n)).
+static inline int aom_ceil_log2(int n) {
+  if (n < 2) return 0;
+  return get_msb(n - 1) + 1;
+}
+
 #if defined(__GNUC__) && \
     ((__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || __GNUC__ >= 4)
 static inline int aom_clzll(uint64_t n) { return __builtin_clzll(n); }

av1/common/entropymode.h

diff --git a/av1/common/entropymode.h b/av1/common/entropymode.h
index 0783af0..b507eb1 100644
--- a/av1/common/entropymode.h
+++ b/av1/common/entropymode.h
@@ -190,12 +190,6 @@
 void av1_setup_frame_contexts(struct AV1Common *cm);
 void av1_setup_past_independence(struct AV1Common *cm);
 
-// Returns (int)ceil(log2(n)).
-static inline int av1_ceil_log2(int n) {
-  if (n < 2) return 0;
-  return get_msb(n - 1) + 1;
-}
-
 // Returns the context for palette color index at row 'r' and column 'c',
 // along with the 'color_order' of neighbors and the 'color_idx'.
 // The 'color_map' is a 2D array with the given 'stride'.

av1/decoder/decodemv.c

diff --git a/av1/decoder/decodemv.c b/av1/decoder/decodemv.c
index 7d8971d..d3a2281 100644
--- a/av1/decoder/decodemv.c
+++ b/av1/decoder/decodemv.c
@@ -27,6 +27,7 @@
 #include "av1/decoder/decodemv.h"
 
 #include "aom_dsp/aom_dsp_common.h"
+#include "aom_ports/bitops.h"
 
 #define ACCT_STR __func__
 
@@ -496,7 +497,7 @@
         pmi->palette_colors[idx] = clamp(pmi->palette_colors[idx - 1] + delta,
                                          0, (1 << bit_depth) - 1);
         range -= (pmi->palette_colors[idx] - pmi->palette_colors[idx - 1]);
-        bits = AOMMIN(bits, av1_ceil_log2(range));
+        bits = AOMMIN(bits, aom_ceil_log2(range));
       }
     }
     merge_colors(pmi->palette_colors, cached_colors, n, n_cached_colors);
@@ -530,7 +531,7 @@
         pmi->palette_colors[idx] = clamp(pmi->palette_colors[idx - 1] + delta,
                                          0, (1 << bit_depth) - 1);
         range -= (pmi->palette_colors[idx] - pmi->palette_colors[idx - 1]);
-        bits = AOMMIN(bits, av1_ceil_log2(range));
+        bits = AOMMIN(bits, aom_ceil_log2(range));
       }
     }
     merge_colors(pmi->palette_colors + PALETTE_MAX_SIZE, cached_colors, n,

av1/encoder/bitstream.c

diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index 99c89a7..178a84a 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -670,14 +670,14 @@
     if (delta > max_delta) max_delta = delta;
   }
   const int min_bits = bit_depth - 3;
-  int bits = AOMMAX(av1_ceil_log2(max_delta + 1 - min_val), min_bits);
+  int bits = AOMMAX(aom_ceil_log2(max_delta + 1 - min_val), min_bits);
   assert(bits <= bit_depth);
   int range = (1 << bit_depth) - colors[0] - min_val;
   aom_write_literal(w, bits - min_bits, 2);
   for (int i = 0; i < num - 1; ++i) {
     aom_write_literal(w, deltas[i] - min_val, bits);
     range -= deltas[i];
-    bits = AOMMIN(bits, av1_ceil_log2(range));
+    bits = AOMMIN(bits, aom_ceil_log2(range));
   }
 }
 

av1/encoder/palette.c

diff --git a/av1/encoder/palette.c b/av1/encoder/palette.c
index c1ceb8c..838bf90 100644
--- a/av1/encoder/palette.c
+++ b/av1/encoder/palette.c
@@ -14,6 +14,7 @@
 
 #include "av1/common/pred_common.h"
 
+#include "aom_ports/bitops.h"
 #include "av1/encoder/block.h"
 #include "av1/encoder/cost.h"
 #include "av1/encoder/encoder.h"
@@ -76,13 +77,13 @@
     assert(delta >= min_val);
     if (delta > max_delta) max_delta = delta;
   }
-  int bits_per_delta = AOMMAX(av1_ceil_log2(max_delta + 1 - min_val), min_bits);
+  int bits_per_delta = AOMMAX(aom_ceil_log2(max_delta + 1 - min_val), min_bits);
   assert(bits_per_delta <= bit_depth);
   int range = (1 << bit_depth) - colors[0] - min_val;
   for (int i = 0; i < num - 1; ++i) {
     bits_cost += bits_per_delta;
     range -= deltas[i];
-    bits_per_delta = AOMMIN(bits_per_delta, av1_ceil_log2(range));
+    bits_per_delta = AOMMIN(bits_per_delta, aom_ceil_log2(range));
   }
   return bits_cost;
 }
@@ -131,7 +132,7 @@
     if (d > max_d) max_d = d;
     if (d == 0) ++(*zero_count);
   }
-  return AOMMAX(av1_ceil_log2(max_d + 1), *min_bits);
+  return AOMMAX(aom_ceil_log2(max_d + 1), *min_bits);
 }
 
 int av1_palette_color_cost_y(const PALETTE_MODE_INFO *const pmi,

test/log2_test.cc

diff --git a/test/log2_test.cc b/test/log2_test.cc
index 59b0423..1ef9eca 100644
--- a/test/log2_test.cc
+++ b/test/log2_test.cc
@@ -13,7 +13,6 @@
 #include <math.h>
 
 #include "aom_ports/bitops.h"
-#include "av1/common/entropymode.h"
 #include "gtest/gtest.h"
 
 TEST(Log2Test, GetMsb) {
@@ -31,21 +30,21 @@
   }
 }
 
-TEST(Log2Test, Av1CeilLog2) {
+TEST(Log2Test, AomCeilLog2) {
   // Test small numbers exhaustively.
-  EXPECT_EQ(av1_ceil_log2(0), 0);
+  EXPECT_EQ(aom_ceil_log2(0), 0);
   for (int n = 1; n < 10000; n++) {
-    EXPECT_EQ(av1_ceil_log2(n), static_cast<int>(ceil(log2(n))));
+    EXPECT_EQ(aom_ceil_log2(n), static_cast<int>(ceil(log2(n))));
   }
 
   // Test every power of 2 and the two adjacent numbers.
   for (int exponent = 2; exponent < 31; exponent++) {
     const int power_of_2 = 1 << exponent;
-    EXPECT_EQ(av1_ceil_log2(power_of_2 - 1), exponent);
-    EXPECT_EQ(av1_ceil_log2(power_of_2), exponent);
-    EXPECT_EQ(av1_ceil_log2(power_of_2 + 1), exponent + 1);
+    EXPECT_EQ(aom_ceil_log2(power_of_2 - 1), exponent);
+    EXPECT_EQ(aom_ceil_log2(power_of_2), exponent);
+    EXPECT_EQ(aom_ceil_log2(power_of_2 + 1), exponent + 1);
   }
 
   // INT_MAX = 2^31 - 1
-  EXPECT_EQ(av1_ceil_log2(INT_MAX), 31);
+  EXPECT_EQ(aom_ceil_log2(INT_MAX), 31);
 }