diff --git a/av1/av1.cmake b/av1/av1.cmake
index 6ea0cfd..804941a 100644
--- a/av1/av1.cmake
+++ b/av1/av1.cmake
@@ -254,7 +254,8 @@
 
 set(AOM_AV1_COMMON_INTRIN_SSE2
     ${AOM_AV1_COMMON_INTRIN_SSE2}
-    "${AOM_ROOT}/av1/common/cdef_block_sse2.c")
+    "${AOM_ROOT}/av1/common/cdef_block_sse2.c"
+    "${AOM_ROOT}/av1/common/x86/mem_sse2.h")
 
 set(AOM_AV1_COMMON_INTRIN_SSSE3
     ${AOM_AV1_COMMON_INTRIN_SSSE3}
@@ -384,6 +385,10 @@
       "${AOM_ROOT}/av1/common/txb_common.c"
       "${AOM_ROOT}/av1/common/txb_common.h")
 
+  set(AOM_AV1_COMMON_INTRIN_SSE2
+      ${AOM_AV1_COMMON_INTRIN_SSE2}
+      "${AOM_ROOT}/av1/common/x86/txb_sse2.c")
+
   set(AOM_AV1_DECODER_SOURCES
       ${AOM_AV1_DECODER_SOURCES}
       "${AOM_ROOT}/av1/decoder/decodetxb.c"
diff --git a/av1/av1_common.mk b/av1/av1_common.mk
index f0c65c2..ed5a7ec 100644
--- a/av1/av1_common.mk
+++ b/av1/av1_common.mk
@@ -76,6 +76,7 @@
 AV1_COMMON_SRCS-yes += common/av1_inv_txfm2d.c
 AV1_COMMON_SRCS-yes += common/av1_inv_txfm1d_cfg.h
 AV1_COMMON_SRCS-$(HAVE_AVX2) += common/x86/convolve_avx2.c
+AV1_COMMON_SRCS-$(HAVE_SSE2) += common/x86/mem_sse2.h
 AV1_COMMON_SRCS-$(HAVE_SSSE3) += common/x86/av1_convolve_ssse3.c
 ifeq ($(CONFIG_CONVOLVE_ROUND)x$(CONFIG_COMPOUND_ROUND),yesx)
 AV1_COMMON_SRCS-$(HAVE_SSE4_1) += common/x86/av1_convolve_scale_sse4.c
@@ -167,6 +168,10 @@
 endif
 endif
 
+ifeq ($(CONFIG_LV_MAP),yes)
+AV1_COMMON_SRCS-$(HAVE_SSE2) += common/x86/txb_sse2.c
+endif
+
 ifeq ($(CONFIG_Q_ADAPT_PROBS),yes)
 AV1_COMMON_SRCS-yes += common/token_cdfs.h
 endif
diff --git a/av1/common/av1_rtcd_defs.pl b/av1/common/av1_rtcd_defs.pl
index ab0fa48..6b2f1ed 100755
--- a/av1/common/av1_rtcd_defs.pl
+++ b/av1/common/av1_rtcd_defs.pl
@@ -67,6 +67,14 @@
 }
 
 #
+# txb
+#
+if (aom_config("CONFIG_LV_MAP") eq "yes") {
+  add_proto qw/void av1_get_br_level_counts/, "const uint8_t *const levels, const int width, const int height, uint8_t *const level_counts";
+  specialize qw/av1_get_br_level_counts sse2/;
+}
+
+#
 # Inverse dct
 #
 add_proto qw/void av1_iht4x4_16_add/, "const tran_low_t *input, uint8_t *dest, int dest_stride, const struct txfm_param *param";
diff --git a/av1/common/txb_common.c b/av1/common/txb_common.c
index 38ac984..4607428 100644
--- a/av1/common/txb_common.c
+++ b/av1/common/txb_common.c
@@ -333,8 +333,8 @@
   }
 }
 
-void av1_get_br_level_counts(const uint8_t *const levels, const int width,
-                             const int height, uint8_t *const level_counts) {
+void av1_get_br_level_counts_c(const uint8_t *const levels, const int width,
+                               const int height, uint8_t *const level_counts) {
   const int stride = width + TX_PAD_HOR;
   const int level_minus_1 = NUM_BASE_LEVELS;
 
diff --git a/av1/common/txb_common.h b/av1/common/txb_common.h
index c609f29..edae7f7 100644
--- a/av1/common/txb_common.h
+++ b/av1/common/txb_common.h
@@ -391,7 +391,7 @@
   const int width = 1 << bwl;
 
   int ctx = 0;
-  int tx_class = get_tx_class(tx_type);
+  const TX_CLASS tx_class = get_tx_class(tx_type);
   int offset;
   if (tx_class == TX_CLASS_2D)
     offset = 0;
@@ -455,7 +455,7 @@
   const int row = coeff_idx >> bwl;
   const int col = coeff_idx - (row << bwl);
 
-  int tx_class = get_tx_class(tx_type);
+  const TX_CLASS tx_class = get_tx_class(tx_type);
 #if USE_CAUSAL_BASE_CTX
   int mag = 0;
   int count = get_nz_count_mag(levels, bwl, row, col, tx_class, &mag);
@@ -578,7 +578,4 @@
                                const int level_minus_1, const int width,
                                const int height, uint8_t *const level_counts);
 
-void av1_get_br_level_counts(const uint8_t *const levels, const int width,
-                             const int height, uint8_t *const level_counts);
-
 #endif  // AV1_COMMON_TXB_COMMON_H_
diff --git a/av1/common/x86/mem_sse2.h b/av1/common/x86/mem_sse2.h
new file mode 100644
index 0000000..432fd99
--- /dev/null
+++ b/av1/common/x86/mem_sse2.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2017, 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 AV1_COMMON_X86_MEM_SSE2_H_
+#define AV1_COMMON_X86_MEM_SSE2_H_
+
+#include <emmintrin.h>  // SSE2
+
+#include "./aom_config.h"
+#include "aom/aom_integer.h"
+
+static INLINE __m128i loadh_epi64(const void *const src, const __m128i s) {
+  return _mm_castps_si128(
+      _mm_loadh_pi(_mm_castsi128_ps(s), (const __m64 *)src));
+}
+
+#endif  // AV1_COMMON_X86_MEM_SSE2_H_
diff --git a/av1/common/x86/txb_sse2.c b/av1/common/x86/txb_sse2.c
new file mode 100644
index 0000000..ebe4e8c
--- /dev/null
+++ b/av1/common/x86/txb_sse2.c
@@ -0,0 +1,248 @@
+/*
+ * Copyright (c) 2017, 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.
+ */
+
+#include <assert.h>
+#include <emmintrin.h>  // SSE2
+
+#include "aom/aom_integer.h"
+#include "av1/common/onyxc_int.h"
+#include "av1/common/txb_common.h"
+#include "av1/common/x86/mem_sse2.h"
+
+static INLINE __m128i load_8bit_4x4_sse2(const void *const s0,
+                                         const void *const s1,
+                                         const void *const s2,
+                                         const void *const s3) {
+  return _mm_setr_epi32(*(const uint32_t *)s0, *(const uint32_t *)s1,
+                        *(const uint32_t *)s2, *(const uint32_t *)s3);
+}
+
+static INLINE void load_levels_4x4x3_sse2(const uint8_t *const s0,
+                                          const uint8_t *const s1,
+                                          const uint8_t *const s2,
+                                          const uint8_t *const s3,
+                                          __m128i *const level) {
+  level[0] = load_8bit_4x4_sse2(s0 - 1, s1 - 1, s2 - 1, s3 - 1);
+  level[1] = load_8bit_4x4_sse2(s0 + 0, s1 + 0, s2 + 0, s3 + 0);
+  level[2] = load_8bit_4x4_sse2(s0 + 1, s1 + 1, s2 + 1, s3 + 1);
+}
+
+static INLINE __m128i get_level_counts_kernel_sse2(__m128i *const level) {
+  const __m128i level_minus_1 = _mm_set1_epi8(NUM_BASE_LEVELS);
+  __m128i count;
+
+  level[6] = _mm_cmpgt_epi8(level[6], level_minus_1);
+  level[7] = _mm_cmpgt_epi8(level[7], level_minus_1);
+  level[8] = _mm_cmpgt_epi8(level[8], level_minus_1);
+  count = _mm_setzero_si128();
+  count = _mm_sub_epi8(count, level[0]);
+  count = _mm_sub_epi8(count, level[1]);
+  count = _mm_sub_epi8(count, level[2]);
+  count = _mm_sub_epi8(count, level[3]);
+  count = _mm_sub_epi8(count, level[5]);
+  count = _mm_sub_epi8(count, level[6]);
+  count = _mm_sub_epi8(count, level[7]);
+  count = _mm_sub_epi8(count, level[8]);
+  level[0] = level[3];
+  level[1] = level[4];
+  level[2] = level[5];
+  level[3] = level[6];
+  level[4] = level[7];
+  level[5] = level[8];
+
+  return count;
+}
+
+static INLINE void get_4_level_counts_sse2(const uint8_t *const levels,
+                                           const int height,
+                                           uint8_t *const level_counts) {
+  const int stride = 4 + TX_PAD_HOR;
+  const __m128i level_minus_1 = _mm_set1_epi8(NUM_BASE_LEVELS);
+  int row = height;
+  __m128i count;
+  __m128i level[9];
+
+  /* level_counts must be 16 byte aligned. */
+  assert(!((intptr_t)level_counts & 0xf));
+  assert(!(height % 4));
+
+  if (height == 4) {
+    load_levels_4x4x3_sse2(levels - 1 * stride, levels + 0 * stride,
+                           levels + 1 * stride, levels + 2 * stride, &level[0]);
+    load_levels_4x4x3_sse2(levels + 0 * stride, levels + 1 * stride,
+                           levels + 2 * stride, levels + 3 * stride, &level[3]);
+    load_levels_4x4x3_sse2(levels + 1 * stride, levels + 2 * stride,
+                           levels + 3 * stride, levels + 4 * stride, &level[6]);
+    level[0] = _mm_cmpgt_epi8(level[0], level_minus_1);
+    level[1] = _mm_cmpgt_epi8(level[1], level_minus_1);
+    level[2] = _mm_cmpgt_epi8(level[2], level_minus_1);
+    level[3] = _mm_cmpgt_epi8(level[3], level_minus_1);
+    level[4] = _mm_cmpgt_epi8(level[4], level_minus_1);
+    level[5] = _mm_cmpgt_epi8(level[5], level_minus_1);
+    count = get_level_counts_kernel_sse2(level);
+    _mm_store_si128((__m128i *)level_counts, count);
+  } else {
+    const uint8_t *ls[4];
+    uint8_t *lcs[4];
+
+    ls[0] = levels + 0 * stride * height / 4;
+    ls[1] = levels + 1 * stride * height / 4;
+    ls[2] = levels + 2 * stride * height / 4;
+    ls[3] = levels + 3 * stride * height / 4;
+    lcs[0] = level_counts + 0 * 4 * height / 4;
+    lcs[1] = level_counts + 1 * 4 * height / 4;
+    lcs[2] = level_counts + 2 * 4 * height / 4;
+    lcs[3] = level_counts + 3 * 4 * height / 4;
+
+    load_levels_4x4x3_sse2(ls[0] - 1 * stride, ls[1] - 1 * stride,
+                           ls[2] - 1 * stride, ls[3] - 1 * stride, &level[0]);
+    load_levels_4x4x3_sse2(ls[0] + 0 * stride, ls[1] + 0 * stride,
+                           ls[2] + 0 * stride, ls[3] + 0 * stride, &level[3]);
+    level[0] = _mm_cmpgt_epi8(level[0], level_minus_1);
+    level[1] = _mm_cmpgt_epi8(level[1], level_minus_1);
+    level[2] = _mm_cmpgt_epi8(level[2], level_minus_1);
+    level[3] = _mm_cmpgt_epi8(level[3], level_minus_1);
+    level[4] = _mm_cmpgt_epi8(level[4], level_minus_1);
+    level[5] = _mm_cmpgt_epi8(level[5], level_minus_1);
+
+    do {
+      load_levels_4x4x3_sse2(ls[0] + 1 * stride, ls[1] + 1 * stride,
+                             ls[2] + 1 * stride, ls[3] + 1 * stride, &level[6]);
+
+      count = get_level_counts_kernel_sse2(level);
+      *(int *)(lcs[0]) = _mm_cvtsi128_si32(count);
+      *(int *)(lcs[1]) = _mm_cvtsi128_si32(_mm_srli_si128(count, 4));
+      *(int *)(lcs[2]) = _mm_cvtsi128_si32(_mm_srli_si128(count, 8));
+      *(int *)(lcs[3]) = _mm_cvtsi128_si32(_mm_srli_si128(count, 12));
+      ls[0] += stride;
+      ls[1] += stride;
+      ls[2] += stride;
+      ls[3] += stride;
+      lcs[0] += 4;
+      lcs[1] += 4;
+      lcs[2] += 4;
+      lcs[3] += 4;
+      row -= 4;
+    } while (row);
+  }
+}
+
+static INLINE void get_8_level_counts_sse2(const uint8_t *const levels,
+                                           const int height,
+                                           uint8_t *const level_counts) {
+  const int stride = 8 + TX_PAD_HOR;
+  const __m128i level_minus_1 = _mm_set1_epi8(NUM_BASE_LEVELS);
+  int row = height;
+  __m128i count;
+  __m128i level[9];
+  const uint8_t *ls[2];
+  uint8_t *lcs[2];
+
+  assert(!(height % 2));
+
+  ls[0] = levels;
+  ls[1] = levels + stride * height / 2;
+  lcs[0] = level_counts;
+  lcs[1] = level_counts + 8 * height / 2;
+
+  level[0] = _mm_loadl_epi64((__m128i *)(ls[0] - 1 * stride - 1));
+  level[1] = _mm_loadl_epi64((__m128i *)(ls[0] - 1 * stride + 0));
+  level[2] = _mm_loadl_epi64((__m128i *)(ls[0] - 1 * stride + 1));
+  level[3] = _mm_loadl_epi64((__m128i *)(ls[0] + 0 * stride - 1));
+  level[4] = _mm_loadl_epi64((__m128i *)(ls[0] + 0 * stride + 0));
+  level[5] = _mm_loadl_epi64((__m128i *)(ls[0] + 0 * stride + 1));
+  level[0] = loadh_epi64(ls[1] - 1 * stride - 1, level[0]);
+  level[1] = loadh_epi64(ls[1] - 1 * stride + 0, level[1]);
+  level[2] = loadh_epi64(ls[1] - 1 * stride + 1, level[2]);
+  level[3] = loadh_epi64(ls[1] + 0 * stride - 1, level[3]);
+  level[4] = loadh_epi64(ls[1] + 0 * stride + 0, level[4]);
+  level[5] = loadh_epi64(ls[1] + 0 * stride + 1, level[5]);
+  level[0] = _mm_cmpgt_epi8(level[0], level_minus_1);
+  level[1] = _mm_cmpgt_epi8(level[1], level_minus_1);
+  level[2] = _mm_cmpgt_epi8(level[2], level_minus_1);
+  level[3] = _mm_cmpgt_epi8(level[3], level_minus_1);
+  level[4] = _mm_cmpgt_epi8(level[4], level_minus_1);
+  level[5] = _mm_cmpgt_epi8(level[5], level_minus_1);
+
+  do {
+    level[6] = _mm_loadl_epi64((__m128i *)(ls[0] + 1 * stride - 1));
+    level[7] = _mm_loadl_epi64((__m128i *)(ls[0] + 1 * stride + 0));
+    level[8] = _mm_loadl_epi64((__m128i *)(ls[0] + 1 * stride + 1));
+    level[6] = loadh_epi64(ls[1] + 1 * stride - 1, level[6]);
+    level[7] = loadh_epi64(ls[1] + 1 * stride + 0, level[7]);
+    level[8] = loadh_epi64(ls[1] + 1 * stride + 1, level[8]);
+
+    count = get_level_counts_kernel_sse2(level);
+    _mm_storel_epi64((__m128i *)(lcs[0]), count);
+    _mm_storeh_pi((__m64 *)(lcs[1]), _mm_castsi128_ps(count));
+    ls[0] += stride;
+    ls[1] += stride;
+    lcs[0] += 8;
+    lcs[1] += 8;
+    row -= 2;
+  } while (row);
+}
+
+static INLINE void get_16x_level_counts_sse2(const uint8_t *levels,
+                                             const int width, const int height,
+                                             uint8_t *level_counts) {
+  const int stride = width + TX_PAD_HOR;
+  const __m128i level_minus_1 = _mm_set1_epi8(NUM_BASE_LEVELS);
+  __m128i count;
+  __m128i level[9];
+
+  /* level_counts must be 16 byte aligned. */
+  assert(!((intptr_t)level_counts & 0xf));
+  assert(!(width % 16));
+
+  for (int i = 0; i < width; i += 16) {
+    int row = height;
+
+    level[0] = _mm_loadu_si128((__m128i *)(levels + i - 1 * stride - 1));
+    level[1] = _mm_loadu_si128((__m128i *)(levels + i - 1 * stride + 0));
+    level[2] = _mm_loadu_si128((__m128i *)(levels + i - 1 * stride + 1));
+    level[3] = _mm_loadu_si128((__m128i *)(levels + i + 0 * stride - 1));
+    level[4] = _mm_loadu_si128((__m128i *)(levels + i + 0 * stride + 0));
+    level[5] = _mm_loadu_si128((__m128i *)(levels + i + 0 * stride + 1));
+    level[0] = _mm_cmpgt_epi8(level[0], level_minus_1);
+    level[1] = _mm_cmpgt_epi8(level[1], level_minus_1);
+    level[2] = _mm_cmpgt_epi8(level[2], level_minus_1);
+    level[3] = _mm_cmpgt_epi8(level[3], level_minus_1);
+    level[4] = _mm_cmpgt_epi8(level[4], level_minus_1);
+    level[5] = _mm_cmpgt_epi8(level[5], level_minus_1);
+
+    do {
+      level[6] = _mm_loadu_si128((__m128i *)(levels + i + 1 * stride - 1));
+      level[7] = _mm_loadu_si128((__m128i *)(levels + i + 1 * stride + 0));
+      level[8] = _mm_loadu_si128((__m128i *)(levels + i + 1 * stride + 1));
+
+      count = get_level_counts_kernel_sse2(level);
+      _mm_store_si128((__m128i *)(level_counts + i), count);
+      levels += stride;
+      level_counts += width;
+    } while (--row);
+
+    levels -= stride * height;
+    level_counts -= width * height;
+  }
+}
+
+void av1_get_br_level_counts_sse2(const uint8_t *const levels, const int width,
+                                  const int height,
+                                  uint8_t *const level_counts) {
+  if (width == 4) {
+    get_4_level_counts_sse2(levels, height, level_counts);
+  } else if (width == 8) {
+    get_8_level_counts_sse2(levels, height, level_counts);
+  } else {
+    get_16x_level_counts_sse2(levels, width, height, level_counts);
+  }
+}
diff --git a/av1/decoder/decodetxb.c b/av1/decoder/decodetxb.c
index edcb0aa..ff19776 100644
--- a/av1/decoder/decodetxb.c
+++ b/av1/decoder/decodetxb.c
@@ -9,6 +9,7 @@
  * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
  */
 
+#include "aom_ports/mem.h"
 #include "av1/common/scan.h"
 #include "av1/common/idct.h"
 #include "av1/common/txb_common.h"
@@ -74,7 +75,7 @@
   int cul_level = 0;
   uint8_t levels_buf[TX_PAD_2D];
   uint8_t *const levels = set_levels(levels_buf, width);
-  uint8_t level_counts[MAX_TX_SQUARE];
+  DECLARE_ALIGNED(16, uint8_t, level_counts[MAX_TX_SQUARE]);
   int8_t signs[MAX_TX_SQUARE];
 
   memset(tcoeffs, 0, sizeof(*tcoeffs) * seg_eob);
diff --git a/av1/encoder/encodetxb.c b/av1/encoder/encodetxb.c
index d459f89..21d4a1d 100644
--- a/av1/encoder/encodetxb.c
+++ b/av1/encoder/encodetxb.c
@@ -9,6 +9,7 @@
  * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
  */
 
+#include "aom_ports/mem.h"
 #include "av1/common/scan.h"
 #include "av1/common/blockd.h"
 #include "av1/common/idct.h"
@@ -321,7 +322,7 @@
   FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
   uint8_t levels_buf[TX_PAD_2D];
   uint8_t *const levels = set_levels(levels_buf, width);
-  uint8_t level_counts[MAX_TX_SQUARE];
+  DECLARE_ALIGNED(16, uint8_t, level_counts[MAX_TX_SQUARE]);
 
   (void)blk_row;
   (void)blk_col;
@@ -635,7 +636,7 @@
   const int16_t *scan = scan_order->scan;
   uint8_t levels_buf[TX_PAD_2D];
   uint8_t *const levels = set_levels(levels_buf, width);
-  uint8_t level_counts[MAX_TX_SQUARE];
+  DECLARE_ALIGNED(16, uint8_t, level_counts[MAX_TX_SQUARE]);
 
   LV_MAP_COEFF_COST *coeff_costs = &x->coeff_costs[txs_ctx][plane_type];
 
@@ -2144,7 +2145,7 @@
   const int height = tx_size_high[tx_size];
   uint8_t levels_buf[TX_PAD_2D];
   uint8_t *const levels = set_levels(levels_buf, width);
-  uint8_t level_counts[MAX_TX_SQUARE];
+  DECLARE_ALIGNED(16, uint8_t, level_counts[MAX_TX_SQUARE]);
   const uint8_t allow_update_cdf = args->allow_update_cdf;
 
   TX_SIZE txsize_ctx = get_txsize_context(tx_size);
diff --git a/test/test.cmake b/test/test.cmake
index df6ed85..7a0d09a 100644
--- a/test/test.cmake
+++ b/test/test.cmake
@@ -169,6 +169,12 @@
       endif ()
     endif ()
 
+    if (CONFIG_LV_MAP)
+      set(AOM_UNIT_TEST_COMMON_SOURCES
+          ${AOM_UNIT_TEST_COMMON_SOURCES}
+          "${AOM_ROOT}/test/txb_test.cc")
+    endif ()
+
     set(AOM_UNIT_TEST_COMMON_INTRIN_NEON
         ${AOM_UNIT_TEST_COMMON_INTRIN_NEON}
         "${AOM_ROOT}/test/simd_cmp_neon.cc")
diff --git a/test/test.mk b/test/test.mk
index 17bdb81..c2191b3 100644
--- a/test/test.mk
+++ b/test/test.mk
@@ -154,6 +154,7 @@
 LIBAOM_TEST_SRCS-$(HAVE_AVX2)          += simd_avx2_test.cc
 LIBAOM_TEST_SRCS-$(HAVE_NEON)          += simd_neon_test.cc
 LIBAOM_TEST_SRCS-yes                   += intrapred_test.cc
+LIBAOM_TEST_SRCS-$(CONFIG_LV_MAP)      += txb_test.cc
 LIBAOM_TEST_SRCS-$(CONFIG_INTRABC)     += intrabc_test.cc
 #LIBAOM_TEST_SRCS-$(CONFIG_AV1_DECODER) += av1_thread_test.cc
 LIBAOM_TEST_SRCS-$(CONFIG_AV1_ENCODER) += dct16x16_test.cc
diff --git a/test/txb_test.cc b/test/txb_test.cc
new file mode 100644
index 0000000..83bba51
--- /dev/null
+++ b/test/txb_test.cc
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2017, 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.
+ */
+
+#include "third_party/googletest/src/googletest/include/gtest/gtest.h"
+
+#include "./aom_config.h"
+#include "./av1_rtcd.h"
+#include "aom_ports/aom_timer.h"
+#include "aom_ports/mem.h"
+#include "av1/common/onyxc_int.h"
+#include "av1/common/txb_common.h"
+#include "test/acm_random.h"
+#include "test/clear_system_state.h"
+#include "test/register_state_check.h"
+#include "test/util.h"
+
+namespace {
+using libaom_test::ACMRandom;
+
+typedef void (*GetLevelCountsFunc)(const uint8_t *const levels, const int width,
+                                   const int height,
+                                   uint8_t *const level_counts);
+
+class TxbTest : public ::testing::TestWithParam<GetLevelCountsFunc> {
+ public:
+  TxbTest() : get_br_level_counts_func_(GetParam()) {}
+
+  virtual ~TxbTest() {}
+
+  virtual void SetUp() {
+    level_counts_ref_ = reinterpret_cast<uint8_t *>(
+        aom_memalign(16, sizeof(*level_counts_ref_) * MAX_TX_SQUARE));
+    ASSERT_TRUE(level_counts_ref_ != NULL);
+    level_counts_ = reinterpret_cast<uint8_t *>(
+        aom_memalign(16, sizeof(*level_counts_) * MAX_TX_SQUARE));
+    ASSERT_TRUE(level_counts_ != NULL);
+  }
+
+  virtual void TearDown() {
+    aom_free(level_counts_ref_);
+    aom_free(level_counts_);
+    libaom_test::ClearSystemState();
+  }
+
+  void GetLevelCountsRun() {
+    const int kNumTests = 10000;
+    int result = 0;
+
+    for (int tx_size = TX_4X4; tx_size < TX_SIZES_ALL; ++tx_size) {
+      const int width = tx_size_wide[tx_size];
+      const int height = tx_size_high[tx_size];
+      levels_ = set_levels(levels_buf_, width);
+      memset(levels_buf_, 0, sizeof(*levels_buf_) * MAX_TX_SQUARE);
+
+      for (int i = 0; i < kNumTests && !result; ++i) {
+        InitLevels(width, height);
+
+        av1_get_br_level_counts_c(levels_, width, height, level_counts_ref_);
+        get_br_level_counts_func_(levels_, width, height, level_counts_);
+
+        PrintDiff(width, height);
+
+        result = memcmp(level_counts_, level_counts_ref_,
+                        sizeof(*level_counts_ref_) * MAX_TX_SQUARE);
+
+        EXPECT_EQ(result, 0) << " width " << width << " height " << height;
+      }
+    }
+  }
+
+  void SpeedTestGetLevelCountsRun() {
+    const int kNumTests = 10000000;
+    aom_usec_timer timer;
+
+    for (int tx_size = TX_4X4; tx_size < TX_SIZES_ALL; ++tx_size) {
+      const int width = tx_size_wide[tx_size];
+      const int height = tx_size_high[tx_size];
+      levels_ = set_levels(levels_buf_, width);
+      memset(levels_buf_, 0, sizeof(*levels_buf_) * MAX_TX_SQUARE);
+      InitLevels(width, height);
+
+      aom_usec_timer_start(&timer);
+      for (int i = 0; i < kNumTests; ++i) {
+        get_br_level_counts_func_(levels_, width, height, level_counts_);
+      }
+      aom_usec_timer_mark(&timer);
+
+      const int elapsed_time = static_cast<int>(aom_usec_timer_elapsed(&timer));
+      printf("get_br_level_counts_%2dx%2d: %7.1f ms\n", width, height,
+             elapsed_time / 1000.0);
+    }
+  }
+
+  void InitLevels(const int width, const int height) {
+    const int stride = width + TX_PAD_HOR;
+
+    for (int i = 0; i < height; ++i) {
+      for (int j = 0; j < width; ++j) {
+        levels_[i * stride + j] = rnd_.Rand8() % (NUM_BASE_LEVELS + 2);
+      }
+    }
+    for (int i = 0; i < MAX_TX_SQUARE; ++i) {
+      level_counts_ref_[i] = level_counts_[i] = 255;
+    }
+  }
+
+  void PrintDiff(const int width, const int height) const {
+    if (memcmp(level_counts_, level_counts_ref_,
+               sizeof(*level_counts_ref_) * MAX_TX_SQUARE)) {
+      for (int y = 0; y < height; y++) {
+        for (int x = 0; x < width; x++) {
+          if (level_counts_ref_[y * width + x] !=
+              level_counts_[y * width + x]) {
+            printf("count[%d][%d] diff:%6d (ref),%6d (opt)\n", y, x,
+                   level_counts_ref_[y * width + x],
+                   level_counts_[y * width + x]);
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  GetLevelCountsFunc get_br_level_counts_func_;
+  ACMRandom rnd_;
+  tran_low_t *coeff_;
+  uint8_t levels_buf_[TX_PAD_2D];
+  uint8_t *levels_;
+  uint8_t *level_counts_ref_;
+  uint8_t *level_counts_;
+};
+
+TEST_P(TxbTest, BitExact) { GetLevelCountsRun(); }
+
+TEST_P(TxbTest, DISABLED_Speed) { SpeedTestGetLevelCountsRun(); }
+
+#if HAVE_SSE2
+INSTANTIATE_TEST_CASE_P(SSE2, TxbTest,
+                        ::testing::Values(av1_get_br_level_counts_sse2));
+#endif
+}  // namespace