diff --git a/aom_dsp/aom_dsp.mk b/aom_dsp/aom_dsp.mk
index 4735199..eebdc0c 100644
--- a/aom_dsp/aom_dsp.mk
+++ b/aom_dsp/aom_dsp.mk
@@ -191,6 +191,7 @@
 endif  # CONFIG_AOM_HIGHBITDEPTH
 
 DSP_SRCS-yes            += txfm_common.h
+DSP_SRCS-yes            += x86/txfm_common_intrin.h
 DSP_SRCS-$(HAVE_SSE2)   += x86/txfm_common_sse2.h
 DSP_SRCS-$(HAVE_MSA)    += mips/txfm_macros_msa.h
 # forward transform
diff --git a/aom_dsp/aom_dsp_rtcd_defs.pl b/aom_dsp/aom_dsp_rtcd_defs.pl
index 6d873bc..d6fa90b 100644
--- a/aom_dsp/aom_dsp_rtcd_defs.pl
+++ b/aom_dsp/aom_dsp_rtcd_defs.pl
@@ -701,6 +701,34 @@
 #
 if (aom_config("CONFIG_AV1_ENCODER") eq "yes") {
   if (aom_config("CONFIG_AOM_HIGHBITDEPTH") eq "yes") {
+    add_proto qw/void aom_fdct4x4/, "const int16_t *input, tran_low_t *output, int stride";
+    specialize qw/aom_fdct4x4 sse2/;
+
+    add_proto qw/void aom_fdct4x4_1/, "const int16_t *input, tran_low_t *output, int stride";
+    specialize qw/aom_fdct4x4_1 sse2/;
+
+    add_proto qw/void aom_fdct8x8/, "const int16_t *input, tran_low_t *output, int stride";
+    specialize qw/aom_fdct8x8 sse2/;
+
+    add_proto qw/void aom_fdct8x8_1/, "const int16_t *input, tran_low_t *output, int stride";
+    specialize qw/aom_fdct8x8_1 sse2/;
+
+    add_proto qw/void aom_fdct16x16/, "const int16_t *input, tran_low_t *output, int stride";
+    specialize qw/aom_fdct16x16 sse2/;
+
+    add_proto qw/void aom_fdct16x16_1/, "const int16_t *input, tran_low_t *output, int stride";
+    specialize qw/aom_fdct16x16_1 sse2 avx2/;
+
+    add_proto qw/void aom_fdct32x32/, "const int16_t *input, tran_low_t *output, int stride";
+    specialize qw/aom_fdct32x32 sse2 avx2/;
+
+    add_proto qw/void aom_fdct32x32_rd/, "const int16_t *input, tran_low_t *output, int stride";
+    specialize qw/aom_fdct32x32_rd sse2 avx2/;
+
+    add_proto qw/void aom_fdct32x32_1/, "const int16_t *input, tran_low_t *output, int stride";
+    specialize qw/aom_fdct32x32_1 sse2 avx2/;
+
+    # High bit depth
     add_proto qw/void aom_highbd_fdct4x4/, "const int16_t *input, tran_low_t *output, int stride";
     specialize qw/aom_highbd_fdct4x4 sse2/;
 
@@ -724,33 +752,34 @@
 
     add_proto qw/void aom_highbd_fdct32x32_1/, "const int16_t *input, tran_low_t *output, int stride";
     specialize qw/aom_highbd_fdct32x32_1/;
-  }   # CONFIG_AOM_HIGHBITDEPTH
-  add_proto qw/void aom_fdct4x4/, "const int16_t *input, tran_low_t *output, int stride";
-  specialize qw/aom_fdct4x4 sse2 msa/;
+  } else {
+    add_proto qw/void aom_fdct4x4/, "const int16_t *input, tran_low_t *output, int stride";
+    specialize qw/aom_fdct4x4 sse2 msa/;
 
-  add_proto qw/void aom_fdct4x4_1/, "const int16_t *input, tran_low_t *output, int stride";
-  specialize qw/aom_fdct4x4_1 sse2/;
+    add_proto qw/void aom_fdct4x4_1/, "const int16_t *input, tran_low_t *output, int stride";
+    specialize qw/aom_fdct4x4_1 sse2/;
 
-  add_proto qw/void aom_fdct8x8/, "const int16_t *input, tran_low_t *output, int stride";
-  specialize qw/aom_fdct8x8 sse2 neon msa/, "$ssse3_x86_64";
+    add_proto qw/void aom_fdct8x8/, "const int16_t *input, tran_low_t *output, int stride";
+    specialize qw/aom_fdct8x8 sse2 neon msa/, "$ssse3_x86_64";
 
-  add_proto qw/void aom_fdct8x8_1/, "const int16_t *input, tran_low_t *output, int stride";
-  specialize qw/aom_fdct8x8_1 sse2 neon msa/;
+    add_proto qw/void aom_fdct8x8_1/, "const int16_t *input, tran_low_t *output, int stride";
+    specialize qw/aom_fdct8x8_1 sse2 neon msa/;
 
-  add_proto qw/void aom_fdct16x16/, "const int16_t *input, tran_low_t *output, int stride";
-  specialize qw/aom_fdct16x16 sse2 msa/;
+    add_proto qw/void aom_fdct16x16/, "const int16_t *input, tran_low_t *output, int stride";
+    specialize qw/aom_fdct16x16 sse2 msa/;
 
-  add_proto qw/void aom_fdct16x16_1/, "const int16_t *input, tran_low_t *output, int stride";
-  specialize qw/aom_fdct16x16_1 sse2 avx2 msa/;
+    add_proto qw/void aom_fdct16x16_1/, "const int16_t *input, tran_low_t *output, int stride";
+    specialize qw/aom_fdct16x16_1 sse2 avx2 msa/;
 
-  add_proto qw/void aom_fdct32x32/, "const int16_t *input, tran_low_t *output, int stride";
-  specialize qw/aom_fdct32x32 sse2 avx2 msa/;
+    add_proto qw/void aom_fdct32x32/, "const int16_t *input, tran_low_t *output, int stride";
+    specialize qw/aom_fdct32x32 sse2 avx2 msa/;
 
-  add_proto qw/void aom_fdct32x32_rd/, "const int16_t *input, tran_low_t *output, int stride";
-  specialize qw/aom_fdct32x32_rd sse2 avx2 msa/;
+    add_proto qw/void aom_fdct32x32_rd/, "const int16_t *input, tran_low_t *output, int stride";
+    specialize qw/aom_fdct32x32_rd sse2 avx2 msa/;
 
-  add_proto qw/void aom_fdct32x32_1/, "const int16_t *input, tran_low_t *output, int stride";
-  specialize qw/aom_fdct32x32_1 sse2 avx2 msa/;
+    add_proto qw/void aom_fdct32x32_1/, "const int16_t *input, tran_low_t *output, int stride";
+    specialize qw/aom_fdct32x32_1 sse2 avx2 msa/;
+  }  # CONFIG_AOM_HIGHBITDEPTH
 }  # CONFIG_AV1_ENCODER
 
 #
diff --git a/aom_dsp/x86/fwd_dct32x32_impl_avx2.h b/aom_dsp/x86/fwd_dct32x32_impl_avx2.h
index 8b136e7..2167395 100644
--- a/aom_dsp/x86/fwd_dct32x32_impl_avx2.h
+++ b/aom_dsp/x86/fwd_dct32x32_impl_avx2.h
@@ -12,6 +12,7 @@
 #include <immintrin.h>  // AVX2
 
 #include "aom_dsp/txfm_common.h"
+#include "aom_dsp/x86/txfm_common_intrin.h"
 #include "aom_dsp/x86/txfm_common_avx2.h"
 
 #if FDCT32x32_HIGH_PRECISION
@@ -31,7 +32,19 @@
 }
 #endif
 
-void FDCT32x32_2D_AVX2(const int16_t *input, int16_t *output_org, int stride) {
+#ifndef STORE_COEFF_FUNC
+#define STORE_COEFF_FUNC
+static void store_coeff(const __m256i *coeff, tran_low_t *curr,
+                        tran_low_t *next) {
+  __m128i u = _mm256_castsi256_si128(*coeff);
+  storeu_output(&u, curr);
+  u = _mm256_extractf128_si256(*coeff, 1);
+  storeu_output(&u, next);
+}
+#endif
+
+void FDCT32x32_2D_AVX2(const int16_t *input, tran_low_t *output_org,
+                       int stride) {
   // Calculate pre-multiplied strides
   const int str1 = stride;
   const int str2 = 2 * stride;
@@ -2842,13 +2855,14 @@
       {
         int transpose_block;
         int16_t *output_currStep, *output_nextStep;
-        if (0 == pass) {
-          output_currStep = &intermediate[column_start * 32];
-          output_nextStep = &intermediate[(column_start + 8) * 32];
-        } else {
-          output_currStep = &output_org[column_start * 32];
-          output_nextStep = &output_org[(column_start + 8) * 32];
-        }
+        tran_low_t *curr_out, *next_out;
+        // Pass 0
+        output_currStep = &intermediate[column_start * 32];
+        output_nextStep = &intermediate[(column_start + 8) * 32];
+        // Pass 1
+        curr_out = &output_org[column_start * 32];
+        next_out = &output_org[(column_start + 8) * 32];
+
         for (transpose_block = 0; transpose_block < 4; ++transpose_block) {
           __m256i *this_out = &out[8 * transpose_block];
           // 00  01  02  03  04  05  06  07  08  09  10  11  12  13  14  15
@@ -2948,44 +2962,58 @@
             tr2_6 = _mm256_srai_epi16(tr2_6, 2);
             tr2_7 = _mm256_srai_epi16(tr2_7, 2);
           }
-          // Note: even though all these stores are aligned, using the aligned
-          //       intrinsic make the code slightly slower.
-          _mm_storeu_si128((__m128i *)(output_currStep + 0 * 32),
-                           _mm256_castsi256_si128(tr2_0));
-          _mm_storeu_si128((__m128i *)(output_currStep + 1 * 32),
-                           _mm256_castsi256_si128(tr2_1));
-          _mm_storeu_si128((__m128i *)(output_currStep + 2 * 32),
-                           _mm256_castsi256_si128(tr2_2));
-          _mm_storeu_si128((__m128i *)(output_currStep + 3 * 32),
-                           _mm256_castsi256_si128(tr2_3));
-          _mm_storeu_si128((__m128i *)(output_currStep + 4 * 32),
-                           _mm256_castsi256_si128(tr2_4));
-          _mm_storeu_si128((__m128i *)(output_currStep + 5 * 32),
-                           _mm256_castsi256_si128(tr2_5));
-          _mm_storeu_si128((__m128i *)(output_currStep + 6 * 32),
-                           _mm256_castsi256_si128(tr2_6));
-          _mm_storeu_si128((__m128i *)(output_currStep + 7 * 32),
-                           _mm256_castsi256_si128(tr2_7));
+          if (0 == pass) {
+            // Note: even though all these stores are aligned, using the aligned
+            //       intrinsic make the code slightly slower.
+            _mm_storeu_si128((__m128i *)(output_currStep + 0 * 32),
+                             _mm256_castsi256_si128(tr2_0));
+            _mm_storeu_si128((__m128i *)(output_currStep + 1 * 32),
+                             _mm256_castsi256_si128(tr2_1));
+            _mm_storeu_si128((__m128i *)(output_currStep + 2 * 32),
+                             _mm256_castsi256_si128(tr2_2));
+            _mm_storeu_si128((__m128i *)(output_currStep + 3 * 32),
+                             _mm256_castsi256_si128(tr2_3));
+            _mm_storeu_si128((__m128i *)(output_currStep + 4 * 32),
+                             _mm256_castsi256_si128(tr2_4));
+            _mm_storeu_si128((__m128i *)(output_currStep + 5 * 32),
+                             _mm256_castsi256_si128(tr2_5));
+            _mm_storeu_si128((__m128i *)(output_currStep + 6 * 32),
+                             _mm256_castsi256_si128(tr2_6));
+            _mm_storeu_si128((__m128i *)(output_currStep + 7 * 32),
+                             _mm256_castsi256_si128(tr2_7));
 
-          _mm_storeu_si128((__m128i *)(output_nextStep + 0 * 32),
-                           _mm256_extractf128_si256(tr2_0, 1));
-          _mm_storeu_si128((__m128i *)(output_nextStep + 1 * 32),
-                           _mm256_extractf128_si256(tr2_1, 1));
-          _mm_storeu_si128((__m128i *)(output_nextStep + 2 * 32),
-                           _mm256_extractf128_si256(tr2_2, 1));
-          _mm_storeu_si128((__m128i *)(output_nextStep + 3 * 32),
-                           _mm256_extractf128_si256(tr2_3, 1));
-          _mm_storeu_si128((__m128i *)(output_nextStep + 4 * 32),
-                           _mm256_extractf128_si256(tr2_4, 1));
-          _mm_storeu_si128((__m128i *)(output_nextStep + 5 * 32),
-                           _mm256_extractf128_si256(tr2_5, 1));
-          _mm_storeu_si128((__m128i *)(output_nextStep + 6 * 32),
-                           _mm256_extractf128_si256(tr2_6, 1));
-          _mm_storeu_si128((__m128i *)(output_nextStep + 7 * 32),
-                           _mm256_extractf128_si256(tr2_7, 1));
-          // Process next 8x8
-          output_currStep += 8;
-          output_nextStep += 8;
+            _mm_storeu_si128((__m128i *)(output_nextStep + 0 * 32),
+                             _mm256_extractf128_si256(tr2_0, 1));
+            _mm_storeu_si128((__m128i *)(output_nextStep + 1 * 32),
+                             _mm256_extractf128_si256(tr2_1, 1));
+            _mm_storeu_si128((__m128i *)(output_nextStep + 2 * 32),
+                             _mm256_extractf128_si256(tr2_2, 1));
+            _mm_storeu_si128((__m128i *)(output_nextStep + 3 * 32),
+                             _mm256_extractf128_si256(tr2_3, 1));
+            _mm_storeu_si128((__m128i *)(output_nextStep + 4 * 32),
+                             _mm256_extractf128_si256(tr2_4, 1));
+            _mm_storeu_si128((__m128i *)(output_nextStep + 5 * 32),
+                             _mm256_extractf128_si256(tr2_5, 1));
+            _mm_storeu_si128((__m128i *)(output_nextStep + 6 * 32),
+                             _mm256_extractf128_si256(tr2_6, 1));
+            _mm_storeu_si128((__m128i *)(output_nextStep + 7 * 32),
+                             _mm256_extractf128_si256(tr2_7, 1));
+            // Process next 8x8
+            output_currStep += 8;
+            output_nextStep += 8;
+          }
+          if (1 == pass) {
+            store_coeff(&tr2_0, curr_out + 0 * 32, next_out + 0 * 32);
+            store_coeff(&tr2_1, curr_out + 1 * 32, next_out + 1 * 32);
+            store_coeff(&tr2_2, curr_out + 2 * 32, next_out + 2 * 32);
+            store_coeff(&tr2_3, curr_out + 3 * 32, next_out + 3 * 32);
+            store_coeff(&tr2_4, curr_out + 4 * 32, next_out + 4 * 32);
+            store_coeff(&tr2_5, curr_out + 5 * 32, next_out + 5 * 32);
+            store_coeff(&tr2_6, curr_out + 6 * 32, next_out + 6 * 32);
+            store_coeff(&tr2_7, curr_out + 7 * 32, next_out + 7 * 32);
+            curr_out += 8;
+            next_out += 8;
+          }
         }
       }
     }
diff --git a/aom_dsp/x86/fwd_txfm_avx2.c b/aom_dsp/x86/fwd_txfm_avx2.c
index d381a6e..670f864 100644
--- a/aom_dsp/x86/fwd_txfm_avx2.c
+++ b/aom_dsp/x86/fwd_txfm_avx2.c
@@ -17,14 +17,6 @@
 #undef FDCT32x32_2D_AVX2
 #undef FDCT32x32_HIGH_PRECISION
 
-// TODO(luoyi): The following macro hides an error. The second parameter type of
-// function,
-//   void FDCT32x32_2D_AVX2(const int16_t *, int16_t*, int);
-// is different from the one in,
-//   void aom_fdct32x32_avx2(const int16_t *, tran_low_t*, int);
-// In CONFIG_AOM_HIGHBITDEPTH=1 build, the second parameter type should be
-// int32_t.
-// This function should be removed after av1_fht32x32 scaling/rounding fix.
 #define FDCT32x32_2D_AVX2 aom_fdct32x32_avx2
 #define FDCT32x32_HIGH_PRECISION 1
 #include "aom_dsp/x86/fwd_dct32x32_impl_avx2.h"  // NOLINT
diff --git a/aom_dsp/x86/fwd_txfm_sse2.h b/aom_dsp/x86/fwd_txfm_sse2.h
index 3261584..fe3e446 100644
--- a/aom_dsp/x86/fwd_txfm_sse2.h
+++ b/aom_dsp/x86/fwd_txfm_sse2.h
@@ -12,6 +12,8 @@
 #ifndef AOM_DSP_X86_FWD_TXFM_SSE2_H_
 #define AOM_DSP_X86_FWD_TXFM_SSE2_H_
 
+#include "aom_dsp/x86/txfm_common_intrin.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -257,19 +259,6 @@
 #endif  // CONFIG_AOM_HIGHBITDEPTH
 }
 
-static INLINE void storeu_output(const __m128i *poutput, tran_low_t *dst_ptr) {
-#if CONFIG_AOM_HIGHBITDEPTH
-  const __m128i zero = _mm_setzero_si128();
-  const __m128i sign_bits = _mm_cmplt_epi16(*poutput, zero);
-  __m128i out0 = _mm_unpacklo_epi16(*poutput, sign_bits);
-  __m128i out1 = _mm_unpackhi_epi16(*poutput, sign_bits);
-  _mm_storeu_si128((__m128i *)(dst_ptr), out0);
-  _mm_storeu_si128((__m128i *)(dst_ptr + 4), out1);
-#else
-  _mm_storeu_si128((__m128i *)(dst_ptr), *poutput);
-#endif  // CONFIG_AOM_HIGHBITDEPTH
-}
-
 static INLINE __m128i mult_round_shift(const __m128i *pin0, const __m128i *pin1,
                                        const __m128i *pmultiplier,
                                        const __m128i *prounding,
diff --git a/aom_dsp/x86/txfm_common_intrin.h b/aom_dsp/x86/txfm_common_intrin.h
new file mode 100644
index 0000000..890e048
--- /dev/null
+++ b/aom_dsp/x86/txfm_common_intrin.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2016, 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_DSP_X86_TXFM_COMMON_INTRIN_H_
+#define _AOM_DSP_X86_TXFM_COMMON_INTRIN_H_
+
+// Note:
+//  This header file should be put below any x86 intrinsics head file
+
+static INLINE void storeu_output(const __m128i *poutput, tran_low_t *dst_ptr) {
+#if CONFIG_AOM_HIGHBITDEPTH
+  const __m128i zero = _mm_setzero_si128();
+  const __m128i sign_bits = _mm_cmplt_epi16(*poutput, zero);
+  __m128i out0 = _mm_unpacklo_epi16(*poutput, sign_bits);
+  __m128i out1 = _mm_unpackhi_epi16(*poutput, sign_bits);
+  _mm_storeu_si128((__m128i *)(dst_ptr), out0);
+  _mm_storeu_si128((__m128i *)(dst_ptr + 4), out1);
+#else
+  _mm_storeu_si128((__m128i *)(dst_ptr), *poutput);
+#endif  // CONFIG_AOM_HIGHBITDEPTH
+}
+
+#endif  // _AOM_DSP_X86_TXFM_COMMON_INTRIN_H_
diff --git a/av1/common/av1_convolve.c b/av1/common/av1_convolve.c
index 1f8d623..270ab70 100644
--- a/av1/common/av1_convolve.c
+++ b/av1/common/av1_convolve.c
@@ -1,3 +1,14 @@
+/*
+ * Copyright (c) 2016, 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 <string.h>
 
diff --git a/av1/common/av1_convolve.h b/av1/common/av1_convolve.h
index 804c102..dafa032 100644
--- a/av1/common/av1_convolve.h
+++ b/av1/common/av1_convolve.h
@@ -1,3 +1,14 @@
+/*
+ * Copyright (c) 2016, 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_AV1_CONVOLVE_H_
 #define AV1_COMMON_AV1_CONVOLVE_H_
 #include "av1/common/filter.h"
diff --git a/av1/common/blockd.h b/av1/common/blockd.h
index 8d7c7f8..65f7440 100644
--- a/av1/common/blockd.h
+++ b/av1/common/blockd.h
@@ -712,6 +712,14 @@
 
 void av1_setup_block_planes(MACROBLOCKD *xd, int ss_x, int ss_y);
 
+static INLINE int tx_size_to_depth(const TX_SIZE tx_size) {
+  return (int)(tx_size - TX_4X4);
+}
+
+static INLINE TX_SIZE depth_to_tx_size(const int depth) {
+  return (TX_SIZE)(depth + TX_4X4);
+}
+
 static INLINE TX_SIZE get_uv_tx_size(const MB_MODE_INFO *mbmi,
                                      const struct macroblockd_plane *pd) {
   TX_SIZE uv_txsize;
diff --git a/av1/common/common_data.h b/av1/common/common_data.h
index 9d851e2..3acb58e 100644
--- a/av1/common/common_data.h
+++ b/av1/common/common_data.h
@@ -68,18 +68,27 @@
 };
 
 static const uint8_t num_4x4_blocks_txsize_lookup[TX_SIZES_ALL] = {
+#if CONFIG_CB4X4
+  1,
+#endif
   1, 4, 16, 64,
 #if CONFIG_EXT_TX
   2, 2, 8,  8,  32, 32
 #endif  // CONFIG_EXT_TX
 };
 static const uint8_t num_4x4_blocks_wide_txsize_lookup[TX_SIZES_ALL] = {
+#if CONFIG_CB4X4
+  1,
+#endif
   1, 2, 4, 8,
 #if CONFIG_EXT_TX
   1, 2, 2, 4, 4, 8
 #endif  // CONFIG_EXT_TX
 };
 static const uint8_t num_4x4_blocks_high_txsize_lookup[TX_SIZES_ALL] = {
+#if CONFIG_CB4X4
+  1,
+#endif
   1, 2, 4, 8,
 #if CONFIG_EXT_TX
   2, 1, 4, 2, 8, 4
@@ -87,18 +96,27 @@
 };
 
 static const uint8_t num_4x4_blocks_txsize_log2_lookup[TX_SIZES_ALL] = {
+#if CONFIG_CB4X4
+  0,
+#endif
   0, 2, 4, 6,
 #if CONFIG_EXT_TX
   1, 1, 3, 3, 5, 5
 #endif  // CONFIG_EXT_TX
 };
 static const uint8_t num_4x4_blocks_wide_txsize_log2_lookup[TX_SIZES_ALL] = {
+#if CONFIG_CB4X4
+  0,
+#endif
   0, 1, 2, 3,
 #if CONFIG_EXT_TX
   0, 1, 1, 2, 2, 3
 #endif  // CONFIG_EXT_TX
 };
 static const uint8_t num_4x4_blocks_high_txsize_log2_lookup[TX_SIZES_ALL] = {
+#if CONFIG_CB4X4
+  0,
+#endif
   0, 1, 2, 3,
 #if CONFIG_EXT_TX
   1, 0, 2, 1, 3, 2
@@ -419,6 +437,9 @@
 /* clang-format on */
 
 static const TX_SIZE txsize_horz_map[TX_SIZES_ALL] = {
+#if CONFIG_CB4X4
+  TX_2X2,  // TX_2X2
+#endif
   TX_4X4,    // TX_4X4
   TX_8X8,    // TX_8X8
   TX_16X16,  // TX_16X16
@@ -434,6 +455,9 @@
 };
 
 static const TX_SIZE txsize_vert_map[TX_SIZES_ALL] = {
+#if CONFIG_CB4X4
+  TX_2X2,  // TX_2X2
+#endif
   TX_4X4,    // TX_4X4
   TX_8X8,    // TX_8X8
   TX_16X16,  // TX_16X16
@@ -450,6 +474,9 @@
 
 // Transform block width in pixels
 static const int tx_size_wide[TX_SIZES_ALL] = {
+#if CONFIG_CB4X4
+  2,
+#endif
   4, 8, 16, 32,
 #if CONFIG_EXT_TX
   4, 8, 8,  16, 16, 32,
@@ -458,6 +485,9 @@
 
 // Transform block height in pixels
 static const int tx_size_high[TX_SIZES_ALL] = {
+#if CONFIG_CB4X4
+  2,
+#endif
   4, 8, 16, 32,
 #if CONFIG_EXT_TX
   8, 4, 16, 8,  32, 16,
@@ -466,6 +496,9 @@
 
 // Transform block width in unit
 static const int tx_size_wide_unit[TX_SIZES_ALL] = {
+#if CONFIG_CB4X4
+  1,
+#endif
   1, 2, 4, 8,
 #if CONFIG_EXT_TX
   1, 2, 2, 4, 4, 8,
@@ -474,6 +507,9 @@
 
 // Transform block height in unit
 static const int tx_size_high_unit[TX_SIZES_ALL] = {
+#if CONFIG_CB4X4
+  1,
+#endif
   1, 2, 4, 8,
 #if CONFIG_EXT_TX
   2, 1, 4, 2, 8, 4,
@@ -482,6 +518,9 @@
 
 // Transform block width in log2
 static const int tx_size_wide_log2[TX_SIZES_ALL] = {
+#if CONFIG_CB4X4
+  2,
+#endif
   2, 3, 4, 5,
 #if CONFIG_EXT_TX
   2, 3, 3, 4, 4, 5,
@@ -490,6 +529,9 @@
 
 // Transform block height in log2
 static const int tx_size_high_log2[TX_SIZES_ALL] = {
+#if CONFIG_CB4X4
+  2,
+#endif
   2, 3, 4, 5,
 #if CONFIG_EXT_TX
   3, 2, 4, 3, 5, 4,
@@ -497,6 +539,9 @@
 };
 
 static const int tx_size_2d[TX_SIZES_ALL] = {
+#if CONFIG_CB4X4
+  4,
+#endif
   16, 64, 256, 1024,
 #if CONFIG_EXT_TX
   32, 32, 128, 128,  512, 512,
@@ -509,6 +554,9 @@
 static const int tx_size_1d_in_unit_log2[TX_SIZES] = { 0, 1, 2, 3 };
 
 static const BLOCK_SIZE txsize_to_bsize[TX_SIZES_ALL] = {
+#if CONFIG_CB4X4
+  BLOCK_4X4,  // TX_2X2
+#endif
   BLOCK_4X4,    // TX_4X4
   BLOCK_8X8,    // TX_8X8
   BLOCK_16X16,  // TX_16X16
@@ -524,6 +572,9 @@
 };
 
 static const TX_SIZE txsize_sqr_map[TX_SIZES_ALL] = {
+#if CONFIG_CB4X4
+  TX_2X2,  // TX_2X2
+#endif
   TX_4X4,    // TX_4X4
   TX_8X8,    // TX_8X8
   TX_16X16,  // TX_16X16
@@ -539,6 +590,9 @@
 };
 
 static const TX_SIZE txsize_sqr_up_map[TX_SIZES_ALL] = {
+#if CONFIG_CB4X4
+  TX_2X2,  // TX_2X2
+#endif
   TX_4X4,    // TX_4X4
   TX_8X8,    // TX_8X8
   TX_16X16,  // TX_16X16
@@ -589,7 +643,10 @@
   //  ss_x == 0    ss_x == 0        ss_x == 1      ss_x == 1
   //  ss_y == 0    ss_y == 1        ss_y == 0      ss_y == 1
   {
-      // BLOCK_4X4
+// BLOCK_4X4
+#if CONFIG_CB4X4
+      { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
+#endif
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
@@ -604,7 +661,10 @@
 #endif  // CONFIG_EXT_TX
   },
   {
-      // BLOCK_4X8
+// BLOCK_4X8
+#if CONFIG_CB4X4
+      { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
+#endif
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
@@ -623,7 +683,10 @@
 #endif  // CONFIG_EXT_TX
   },
   {
-      // BLOCK_8X4
+// BLOCK_8X4
+#if CONFIG_CB4X4
+      { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
+#endif
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
@@ -642,7 +705,10 @@
 #endif  // CONFIG_EXT_TX
   },
   {
-      // BLOCK_8X8
+// BLOCK_8X8
+#if CONFIG_CB4X4
+      { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
+#endif
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
       { { TX_8X8, TX_4X4 }, { TX_4X4, TX_4X4 } },
       { { TX_8X8, TX_8X8 }, { TX_4X4, TX_4X4 } },
@@ -657,7 +723,10 @@
 #endif  // CONFIG_EXT_TX
   },
   {
-      // BLOCK_8X16
+// BLOCK_8X16
+#if CONFIG_CB4X4
+      { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
+#endif
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
       { { TX_8X8, TX_8X8 }, { TX_4X4, TX_4X4 } },
       { { TX_8X8, TX_8X8 }, { TX_4X4, TX_4X4 } },
@@ -676,7 +745,10 @@
 #endif  // CONFIG_EXT_TX
   },
   {
-      // BLOCK_16X8
+// BLOCK_16X8
+#if CONFIG_CB4X4
+      { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
+#endif
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
       { { TX_8X8, TX_4X4 }, { TX_8X8, TX_4X4 } },
       { { TX_8X8, TX_4X4 }, { TX_8X8, TX_8X8 } },
@@ -695,7 +767,10 @@
 #endif  // CONFIG_EXT_TX
   },
   {
-      // BLOCK_16X16
+// BLOCK_16X16
+#if CONFIG_CB4X4
+      { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
+#endif
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
       { { TX_8X8, TX_8X8 }, { TX_8X8, TX_8X8 } },
       { { TX_16X16, TX_8X8 }, { TX_8X8, TX_8X8 } },
@@ -710,7 +785,10 @@
 #endif  // CONFIG_EXT_TX
   },
   {
-      // BLOCK_16X32
+// BLOCK_16X32
+#if CONFIG_CB4X4
+      { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
+#endif
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
       { { TX_8X8, TX_8X8 }, { TX_8X8, TX_8X8 } },
       { { TX_16X16, TX_16X16 }, { TX_8X8, TX_8X8 } },
@@ -729,7 +807,10 @@
 #endif  // CONFIG_EXT_TX
   },
   {
-      // BLOCK_32X16
+// BLOCK_32X16
+#if CONFIG_CB4X4
+      { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
+#endif
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
       { { TX_8X8, TX_8X8 }, { TX_8X8, TX_8X8 } },
       { { TX_16X16, TX_8X8 }, { TX_16X16, TX_8X8 } },
@@ -748,7 +829,10 @@
 #endif  // CONFIG_EXT_TX
   },
   {
-      // BLOCK_32X32
+// BLOCK_32X32
+#if CONFIG_CB4X4
+      { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
+#endif
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
       { { TX_8X8, TX_8X8 }, { TX_8X8, TX_8X8 } },
       { { TX_16X16, TX_16X16 }, { TX_16X16, TX_16X16 } },
@@ -763,7 +847,10 @@
 #endif  // CONFIG_EXT_TX
   },
   {
-      // BLOCK_32X64
+// BLOCK_32X64
+#if CONFIG_CB4X4
+      { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
+#endif
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
       { { TX_8X8, TX_8X8 }, { TX_8X8, TX_8X8 } },
       { { TX_16X16, TX_16X16 }, { TX_16X16, TX_16X16 } },
@@ -778,7 +865,10 @@
 #endif  // CONFIG_EXT_TX
   },
   {
-      // BLOCK_64X32
+// BLOCK_64X32
+#if CONFIG_CB4X4
+      { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
+#endif
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
       { { TX_8X8, TX_8X8 }, { TX_8X8, TX_8X8 } },
       { { TX_16X16, TX_16X16 }, { TX_16X16, TX_16X16 } },
@@ -793,7 +883,10 @@
 #endif  // CONFIG_EXT_TX
   },
   {
-      // BLOCK_64X64
+// BLOCK_64X64
+#if CONFIG_CB4X4
+      { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
+#endif
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
       { { TX_8X8, TX_8X8 }, { TX_8X8, TX_8X8 } },
       { { TX_16X16, TX_16X16 }, { TX_16X16, TX_16X16 } },
@@ -801,7 +894,10 @@
 #if CONFIG_EXT_PARTITION
   },
   {
-      // BLOCK_64X128
+// BLOCK_64X128
+#if CONFIG_CB4X4
+      { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
+#endif
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
       { { TX_8X8, TX_8X8 }, { TX_8X8, TX_8X8 } },
       { { TX_16X16, TX_16X16 }, { TX_16X16, TX_16X16 } },
@@ -816,7 +912,10 @@
 #endif  // CONFIG_EXT_TX
   },
   {
-      // BLOCK_128X64
+// BLOCK_128X64
+#if CONFIG_CB4X4
+      { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
+#endif
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
       { { TX_8X8, TX_8X8 }, { TX_8X8, TX_8X8 } },
       { { TX_16X16, TX_16X16 }, { TX_16X16, TX_16X16 } },
@@ -831,7 +930,10 @@
 #endif  // CONFIG_EXT_TX
   },
   {
-      // BLOCK_128X128
+// BLOCK_128X128
+#if CONFIG_CB4X4
+      { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
+#endif
       { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
       { { TX_8X8, TX_8X8 }, { TX_8X8, TX_8X8 } },
       { { TX_16X16, TX_16X16 }, { TX_16X16, TX_16X16 } },
@@ -891,8 +993,11 @@
 
 #if CONFIG_SUPERTX
 static const TX_SIZE uvsupertx_size_lookup[TX_SIZES][2][2] = {
-  //  ss_x == 0 ss_x == 0   ss_x == 1 ss_x == 1
-  //  ss_y == 0 ss_y == 1   ss_y == 0 ss_y == 1
+//  ss_x == 0 ss_x == 0   ss_x == 1 ss_x == 1
+//  ss_y == 0 ss_y == 1   ss_y == 0 ss_y == 1
+#if CONFIG_CB4X4
+  { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
+#endif
   { { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
   { { TX_8X8, TX_4X4 }, { TX_4X4, TX_4X4 } },
   { { TX_16X16, TX_8X8 }, { TX_8X8, TX_8X8 } },
diff --git a/av1/common/entropy.c b/av1/common/entropy.c
index 870632d..049c6ef 100644
--- a/av1/common/entropy.c
+++ b/av1/common/entropy.c
@@ -58,6 +58,9 @@
 #endif
 
 const uint16_t band_count_table[TX_SIZES_ALL][8] = {
+#if CONFIG_CB4X4
+  { 1, 2, 2, 3, 0, 0, 0 },
+#endif
   { 1, 2, 3, 4, 3, 16 - 13, 0 },   { 1, 2, 3, 4, 11, 64 - 21, 0 },
   { 1, 2, 3, 4, 11, 256 - 21, 0 }, { 1, 2, 3, 4, 11, 1024 - 21, 0 },
 #if CONFIG_EXT_TX
@@ -68,6 +71,9 @@
 };
 
 const uint16_t band_cum_count_table[TX_SIZES_ALL][8] = {
+#if CONFIG_CB4X4
+  { 0, 1, 3, 6, 10, 13, 16, 0 },
+#endif
   { 0, 1, 3, 6, 10, 13, 16, 0 },  { 0, 1, 3, 6, 10, 21, 64, 0 },
   { 0, 1, 3, 6, 10, 21, 256, 0 }, { 0, 1, 3, 6, 10, 21, 1024, 0 },
 #if CONFIG_EXT_TX
@@ -2833,6 +2839,9 @@
       ROUND_POWER_OF_TWO(cm->base_qindex, 8 - QCTX_BIN_BITS), QCTX_BINS - 1);
   av1_copy(cm->fc->coef_probs, default_qctx_coef_probs[index]);
 #else
+#if CONFIG_CB4X4
+  av1_copy(cm->fc->coef_probs[TX_2X2], default_coef_probs_4x4);
+#endif
   av1_copy(cm->fc->coef_probs[TX_4X4], default_coef_probs_4x4);
   av1_copy(cm->fc->coef_probs[TX_8X8], default_coef_probs_8x8);
   av1_copy(cm->fc->coef_probs[TX_16X16], default_coef_probs_16x16);
@@ -2913,7 +2922,7 @@
     count_sat = COEF_COUNT_SAT;
   }
 #endif  // CONFIG_ENTROPY
-  for (tx_size = TX_4X4; tx_size <= TX_32X32; tx_size++)
+  for (tx_size = 0; tx_size < TX_SIZES; tx_size++)
     adapt_coef_probs(cm, tx_size, count_sat, update_factor);
 #if CONFIG_RANS
   av1_coef_pareto_cdfs(cm->fc);
diff --git a/av1/common/entropymode.c b/av1/common/entropymode.c
index e25dcf8..52dc8f1 100644
--- a/av1/common/entropymode.c
+++ b/av1/common/entropymode.c
@@ -567,117 +567,117 @@
                                     [PALETTE_COLORS - 1] = {
                                       {
                                           // 2 colors
-                                          { 230, 255, 128, 128, 128, 128, 128 },
-                                          { 214, 255, 128, 128, 128, 128, 128 },
-                                          { 128, 128, 128, 128, 128, 128, 128 },
-                                          { 128, 128, 128, 128, 128, 128, 128 },
-                                          { 128, 128, 128, 128, 128, 128, 128 },
-                                          { 240, 255, 128, 128, 128, 128, 128 },
-                                          { 73, 255, 128, 128, 128, 128, 128 },
-                                          { 128, 128, 128, 128, 128, 128, 128 },
-                                          { 130, 255, 128, 128, 128, 128, 128 },
-                                          { 227, 255, 128, 128, 128, 128, 128 },
-                                          { 128, 128, 128, 128, 128, 128, 128 },
-                                          { 188, 255, 128, 128, 128, 128, 128 },
-                                          { 75, 255, 128, 128, 128, 128, 128 },
-                                          { 250, 255, 128, 128, 128, 128, 128 },
-                                          { 223, 255, 128, 128, 128, 128, 128 },
-                                          { 252, 255, 128, 128, 128, 128, 128 },
+                                          { 230, 0, 0, 0, 0, 0, 0 },
+                                          { 214, 0, 0, 0, 0, 0, 0 },
+                                          { 0, 0, 0, 0, 0, 0, 0 },
+                                          { 0, 0, 0, 0, 0, 0, 0 },
+                                          { 0, 0, 0, 0, 0, 0, 0 },
+                                          { 240, 0, 0, 0, 0, 0, 0 },
+                                          { 73, 0, 0, 0, 0, 0, 0 },
+                                          { 0, 0, 0, 0, 0, 0, 0 },
+                                          { 130, 0, 0, 0, 0, 0, 0 },
+                                          { 227, 0, 0, 0, 0, 0, 0 },
+                                          { 0, 0, 0, 0, 0, 0, 0 },
+                                          { 188, 0, 0, 0, 0, 0, 0 },
+                                          { 75, 0, 0, 0, 0, 0, 0 },
+                                          { 250, 0, 0, 0, 0, 0, 0 },
+                                          { 223, 0, 0, 0, 0, 0, 0 },
+                                          { 252, 0, 0, 0, 0, 0, 0 },
                                       },
                                       {
                                           // 3 colors
-                                          { 229, 137, 255, 128, 128, 128, 128 },
-                                          { 197, 120, 255, 128, 128, 128, 128 },
-                                          { 107, 195, 255, 128, 128, 128, 128 },
-                                          { 128, 128, 128, 128, 128, 128, 128 },
-                                          { 27, 151, 255, 128, 128, 128, 128 },
-                                          { 230, 130, 255, 128, 128, 128, 128 },
-                                          { 37, 230, 255, 128, 128, 128, 128 },
-                                          { 67, 221, 255, 128, 128, 128, 128 },
-                                          { 124, 230, 255, 128, 128, 128, 128 },
-                                          { 195, 109, 255, 128, 128, 128, 128 },
-                                          { 99, 122, 255, 128, 128, 128, 128 },
-                                          { 205, 208, 255, 128, 128, 128, 128 },
-                                          { 40, 235, 255, 128, 128, 128, 128 },
-                                          { 251, 132, 255, 128, 128, 128, 128 },
-                                          { 237, 186, 255, 128, 128, 128, 128 },
-                                          { 253, 112, 255, 128, 128, 128, 128 },
+                                          { 229, 137, 0, 0, 0, 0, 0 },
+                                          { 197, 120, 0, 0, 0, 0, 0 },
+                                          { 107, 195, 0, 0, 0, 0, 0 },
+                                          { 0, 0, 0, 0, 0, 0, 0 },
+                                          { 27, 151, 0, 0, 0, 0, 0 },
+                                          { 230, 130, 0, 0, 0, 0, 0 },
+                                          { 37, 230, 0, 0, 0, 0, 0 },
+                                          { 67, 221, 0, 0, 0, 0, 0 },
+                                          { 124, 230, 0, 0, 0, 0, 0 },
+                                          { 195, 109, 0, 0, 0, 0, 0 },
+                                          { 99, 122, 0, 0, 0, 0, 0 },
+                                          { 205, 208, 0, 0, 0, 0, 0 },
+                                          { 40, 235, 0, 0, 0, 0, 0 },
+                                          { 251, 132, 0, 0, 0, 0, 0 },
+                                          { 237, 186, 0, 0, 0, 0, 0 },
+                                          { 253, 112, 0, 0, 0, 0, 0 },
                                       },
                                       {
                                           // 4 colors
-                                          { 195, 87, 128, 255, 128, 128, 128 },
-                                          { 143, 100, 123, 255, 128, 128, 128 },
-                                          { 94, 124, 119, 255, 128, 128, 128 },
-                                          { 77, 91, 130, 255, 128, 128, 128 },
-                                          { 39, 114, 178, 255, 128, 128, 128 },
-                                          { 222, 94, 125, 255, 128, 128, 128 },
-                                          { 44, 203, 132, 255, 128, 128, 128 },
-                                          { 68, 175, 122, 255, 128, 128, 128 },
-                                          { 110, 187, 124, 255, 128, 128, 128 },
-                                          { 152, 91, 128, 255, 128, 128, 128 },
-                                          { 70, 109, 181, 255, 128, 128, 128 },
-                                          { 133, 113, 164, 255, 128, 128, 128 },
-                                          { 47, 205, 133, 255, 128, 128, 128 },
-                                          { 247, 94, 136, 255, 128, 128, 128 },
-                                          { 205, 122, 146, 255, 128, 128, 128 },
-                                          { 251, 100, 141, 255, 128, 128, 128 },
+                                          { 195, 87, 128, 0, 0, 0, 0 },
+                                          { 143, 100, 123, 0, 0, 0, 0 },
+                                          { 94, 124, 119, 0, 0, 0, 0 },
+                                          { 77, 91, 130, 0, 0, 0, 0 },
+                                          { 39, 114, 178, 0, 0, 0, 0 },
+                                          { 222, 94, 125, 0, 0, 0, 0 },
+                                          { 44, 203, 132, 0, 0, 0, 0 },
+                                          { 68, 175, 122, 0, 0, 0, 0 },
+                                          { 110, 187, 124, 0, 0, 0, 0 },
+                                          { 152, 91, 128, 0, 0, 0, 0 },
+                                          { 70, 109, 181, 0, 0, 0, 0 },
+                                          { 133, 113, 164, 0, 0, 0, 0 },
+                                          { 47, 205, 133, 0, 0, 0, 0 },
+                                          { 247, 94, 136, 0, 0, 0, 0 },
+                                          { 205, 122, 146, 0, 0, 0, 0 },
+                                          { 251, 100, 141, 0, 0, 0, 0 },
                                       },
                                       {
                                           // 5 colors
-                                          { 195, 65, 84, 125, 255, 128, 128 },
-                                          { 150, 76, 84, 121, 255, 128, 128 },
-                                          { 94, 110, 81, 117, 255, 128, 128 },
-                                          { 79, 85, 91, 139, 255, 128, 128 },
-                                          { 26, 102, 139, 127, 255, 128, 128 },
-                                          { 220, 73, 91, 119, 255, 128, 128 },
-                                          { 38, 203, 86, 127, 255, 128, 128 },
-                                          { 61, 186, 72, 124, 255, 128, 128 },
-                                          { 132, 199, 84, 128, 255, 128, 128 },
-                                          { 172, 52, 62, 120, 255, 128, 128 },
-                                          { 102, 89, 121, 122, 255, 128, 128 },
-                                          { 182, 48, 69, 186, 255, 128, 128 },
-                                          { 36, 206, 87, 126, 255, 128, 128 },
-                                          { 249, 55, 67, 122, 255, 128, 128 },
-                                          { 218, 88, 75, 122, 255, 128, 128 },
-                                          { 253, 64, 80, 119, 255, 128, 128 },
+                                          { 195, 65, 84, 125, 0, 0, 0 },
+                                          { 150, 76, 84, 121, 0, 0, 0 },
+                                          { 94, 110, 81, 117, 0, 0, 0 },
+                                          { 79, 85, 91, 139, 0, 0, 0 },
+                                          { 26, 102, 139, 127, 0, 0, 0 },
+                                          { 220, 73, 91, 119, 0, 0, 0 },
+                                          { 38, 203, 86, 127, 0, 0, 0 },
+                                          { 61, 186, 72, 124, 0, 0, 0 },
+                                          { 132, 199, 84, 128, 0, 0, 0 },
+                                          { 172, 52, 62, 120, 0, 0, 0 },
+                                          { 102, 89, 121, 122, 0, 0, 0 },
+                                          { 182, 48, 69, 186, 0, 0, 0 },
+                                          { 36, 206, 87, 126, 0, 0, 0 },
+                                          { 249, 55, 67, 122, 0, 0, 0 },
+                                          { 218, 88, 75, 122, 0, 0, 0 },
+                                          { 253, 64, 80, 119, 0, 0, 0 },
                                       },
                                       {
                                           // 6 colors
-                                          { 182, 54, 64, 75, 118, 255, 128 },
-                                          { 126, 67, 70, 76, 116, 255, 128 },
-                                          { 79, 92, 67, 85, 120, 255, 128 },
-                                          { 63, 61, 81, 118, 132, 255, 128 },
-                                          { 21, 80, 105, 83, 119, 255, 128 },
-                                          { 215, 72, 74, 74, 111, 255, 128 },
-                                          { 50, 176, 63, 79, 120, 255, 128 },
-                                          { 72, 148, 66, 77, 120, 255, 128 },
-                                          { 105, 177, 57, 78, 130, 255, 128 },
-                                          { 150, 66, 66, 80, 127, 255, 128 },
-                                          { 81, 76, 109, 85, 116, 255, 128 },
-                                          { 113, 81, 62, 96, 148, 255, 128 },
-                                          { 54, 179, 69, 82, 121, 255, 128 },
-                                          { 244, 47, 48, 67, 118, 255, 128 },
-                                          { 198, 83, 53, 65, 121, 255, 128 },
-                                          { 250, 42, 51, 69, 110, 255, 128 },
+                                          { 182, 54, 64, 75, 118, 0, 0 },
+                                          { 126, 67, 70, 76, 116, 0, 0 },
+                                          { 79, 92, 67, 85, 120, 0, 0 },
+                                          { 63, 61, 81, 118, 132, 0, 0 },
+                                          { 21, 80, 105, 83, 119, 0, 0 },
+                                          { 215, 72, 74, 74, 111, 0, 0 },
+                                          { 50, 176, 63, 79, 120, 0, 0 },
+                                          { 72, 148, 66, 77, 120, 0, 0 },
+                                          { 105, 177, 57, 78, 130, 0, 0 },
+                                          { 150, 66, 66, 80, 127, 0, 0 },
+                                          { 81, 76, 109, 85, 116, 0, 0 },
+                                          { 113, 81, 62, 96, 148, 0, 0 },
+                                          { 54, 179, 69, 82, 121, 0, 0 },
+                                          { 244, 47, 48, 67, 118, 0, 0 },
+                                          { 198, 83, 53, 65, 121, 0, 0 },
+                                          { 250, 42, 51, 69, 110, 0, 0 },
                                       },
                                       {
                                           // 7 colors
-                                          { 182, 45, 54, 62, 74, 113, 255 },
-                                          { 124, 63, 57, 62, 77, 114, 255 },
-                                          { 77, 80, 56, 66, 76, 117, 255 },
-                                          { 63, 57, 69, 98, 85, 131, 255 },
-                                          { 19, 81, 98, 63, 80, 116, 255 },
-                                          { 215, 56, 60, 63, 68, 105, 255 },
-                                          { 50, 174, 50, 60, 79, 118, 255 },
-                                          { 68, 151, 50, 58, 73, 117, 255 },
-                                          { 104, 182, 53, 57, 79, 127, 255 },
-                                          { 156, 50, 51, 63, 77, 111, 255 },
-                                          { 88, 67, 97, 59, 82, 120, 255 },
-                                          { 114, 81, 46, 65, 103, 132, 255 },
-                                          { 55, 166, 57, 66, 82, 120, 255 },
-                                          { 245, 34, 38, 43, 63, 114, 255 },
-                                          { 203, 68, 45, 47, 60, 118, 255 },
-                                          { 250, 35, 37, 47, 66, 110, 255 },
+                                          { 182, 45, 54, 62, 74, 113, 0 },
+                                          { 124, 63, 57, 62, 77, 114, 0 },
+                                          { 77, 80, 56, 66, 76, 117, 0 },
+                                          { 63, 57, 69, 98, 85, 131, 0 },
+                                          { 19, 81, 98, 63, 80, 116, 0 },
+                                          { 215, 56, 60, 63, 68, 105, 0 },
+                                          { 50, 174, 50, 60, 79, 118, 0 },
+                                          { 68, 151, 50, 58, 73, 117, 0 },
+                                          { 104, 182, 53, 57, 79, 127, 0 },
+                                          { 156, 50, 51, 63, 77, 111, 0 },
+                                          { 88, 67, 97, 59, 82, 120, 0 },
+                                          { 114, 81, 46, 65, 103, 132, 0 },
+                                          { 55, 166, 57, 66, 82, 120, 0 },
+                                          { 245, 34, 38, 43, 63, 114, 0 },
+                                          { 203, 68, 45, 47, 60, 118, 0 },
+                                          { 250, 35, 37, 47, 66, 110, 0 },
                                       },
                                       {
                                           // 8 colors
@@ -700,141 +700,144 @@
                                       }
                                     };
 
-const aom_prob av1_default_palette_uv_color_prob
-    [PALETTE_MAX_SIZE - 1][PALETTE_COLOR_CONTEXTS]
-    [PALETTE_COLORS - 1] = { {
-                                 // 2 colors
-                                 { 228, 255, 128, 128, 128, 128, 128 },
-                                 { 195, 255, 128, 128, 128, 128, 128 },
-                                 { 128, 128, 128, 128, 128, 128, 128 },
-                                 { 128, 128, 128, 128, 128, 128, 128 },
-                                 { 128, 128, 128, 128, 128, 128, 128 },
-                                 { 228, 255, 128, 128, 128, 128, 128 },
-                                 { 71, 255, 128, 128, 128, 128, 128 },
-                                 { 128, 128, 128, 128, 128, 128, 128 },
-                                 { 129, 255, 128, 128, 128, 128, 128 },
-                                 { 206, 255, 128, 128, 128, 128, 128 },
-                                 { 128, 128, 128, 128, 128, 128, 128 },
-                                 { 136, 255, 128, 128, 128, 128, 128 },
-                                 { 98, 255, 128, 128, 128, 128, 128 },
-                                 { 236, 255, 128, 128, 128, 128, 128 },
-                                 { 222, 255, 128, 128, 128, 128, 128 },
-                                 { 249, 255, 128, 128, 128, 128, 128 },
-                             },
-                             {
-                                 // 3 colors
-                                 { 198, 136, 255, 128, 128, 128, 128 },
-                                 { 178, 105, 255, 128, 128, 128, 128 },
-                                 { 100, 206, 255, 128, 128, 128, 128 },
-                                 { 128, 128, 128, 128, 128, 128, 128 },
-                                 { 12, 136, 255, 128, 128, 128, 128 },
-                                 { 219, 134, 255, 128, 128, 128, 128 },
-                                 { 50, 198, 255, 128, 128, 128, 128 },
-                                 { 61, 231, 255, 128, 128, 128, 128 },
-                                 { 110, 209, 255, 128, 128, 128, 128 },
-                                 { 173, 106, 255, 128, 128, 128, 128 },
-                                 { 145, 166, 255, 128, 128, 128, 128 },
-                                 { 156, 175, 255, 128, 128, 128, 128 },
-                                 { 69, 183, 255, 128, 128, 128, 128 },
-                                 { 241, 163, 255, 128, 128, 128, 128 },
-                                 { 224, 160, 255, 128, 128, 128, 128 },
-                                 { 246, 154, 255, 128, 128, 128, 128 },
-                             },
-                             {
-                                 // 4 colors
-                                 { 173, 88, 143, 255, 128, 128, 128 },
-                                 { 146, 81, 127, 255, 128, 128, 128 },
-                                 { 84, 134, 102, 255, 128, 128, 128 },
-                                 { 69, 138, 140, 255, 128, 128, 128 },
-                                 { 31, 103, 200, 255, 128, 128, 128 },
-                                 { 217, 101, 139, 255, 128, 128, 128 },
-                                 { 51, 174, 121, 255, 128, 128, 128 },
-                                 { 64, 177, 109, 255, 128, 128, 128 },
-                                 { 96, 179, 145, 255, 128, 128, 128 },
-                                 { 164, 77, 114, 255, 128, 128, 128 },
-                                 { 87, 94, 156, 255, 128, 128, 128 },
-                                 { 105, 57, 173, 255, 128, 128, 128 },
-                                 { 63, 158, 137, 255, 128, 128, 128 },
-                                 { 236, 102, 156, 255, 128, 128, 128 },
-                                 { 197, 115, 153, 255, 128, 128, 128 },
-                                 { 245, 106, 154, 255, 128, 128, 128 },
-                             },
-                             {
-                                 // 5 colors
-                                 { 179, 64, 97, 129, 255, 128, 128 },
-                                 { 137, 56, 88, 125, 255, 128, 128 },
-                                 { 82, 107, 61, 118, 255, 128, 128 },
-                                 { 59, 113, 86, 115, 255, 128, 128 },
-                                 { 23, 88, 118, 130, 255, 128, 128 },
-                                 { 213, 66, 90, 125, 255, 128, 128 },
-                                 { 37, 181, 103, 121, 255, 128, 128 },
-                                 { 47, 188, 61, 131, 255, 128, 128 },
-                                 { 104, 185, 103, 144, 255, 128, 128 },
-                                 { 163, 39, 76, 112, 255, 128, 128 },
-                                 { 94, 74, 131, 126, 255, 128, 128 },
-                                 { 142, 42, 103, 163, 255, 128, 128 },
-                                 { 53, 162, 99, 149, 255, 128, 128 },
-                                 { 239, 54, 84, 108, 255, 128, 128 },
-                                 { 203, 84, 110, 147, 255, 128, 128 },
-                                 { 248, 70, 105, 151, 255, 128, 128 },
-                             },
-                             {
-                                 // 6 colors
-                                 { 189, 50, 67, 90, 130, 255, 128 },
-                                 { 114, 50, 55, 90, 123, 255, 128 },
-                                 { 66, 76, 54, 82, 128, 255, 128 },
-                                 { 43, 69, 69, 80, 129, 255, 128 },
-                                 { 22, 59, 87, 88, 141, 255, 128 },
-                                 { 203, 49, 68, 87, 122, 255, 128 },
-                                 { 43, 157, 74, 104, 146, 255, 128 },
-                                 { 54, 138, 51, 95, 138, 255, 128 },
-                                 { 82, 171, 58, 102, 146, 255, 128 },
-                                 { 129, 38, 59, 64, 168, 255, 128 },
-                                 { 56, 67, 119, 92, 112, 255, 128 },
-                                 { 96, 62, 53, 132, 82, 255, 128 },
-                                 { 60, 147, 77, 108, 145, 255, 128 },
-                                 { 238, 76, 73, 93, 148, 255, 128 },
-                                 { 189, 86, 73, 103, 157, 255, 128 },
-                                 { 246, 62, 75, 83, 167, 255, 128 },
-                             },
-                             {
-                                 // 7 colors
-                                 { 179, 42, 51, 73, 99, 134, 255 },
-                                 { 119, 52, 52, 61, 64, 114, 255 },
-                                 { 53, 77, 35, 65, 71, 131, 255 },
-                                 { 38, 70, 51, 68, 89, 144, 255 },
-                                 { 23, 65, 128, 73, 97, 131, 255 },
-                                 { 210, 47, 52, 63, 81, 143, 255 },
-                                 { 42, 159, 57, 68, 98, 143, 255 },
-                                 { 49, 153, 45, 82, 93, 143, 255 },
-                                 { 81, 169, 52, 72, 113, 151, 255 },
-                                 { 136, 46, 35, 56, 75, 96, 255 },
-                                 { 57, 84, 109, 47, 107, 131, 255 },
-                                 { 128, 78, 57, 36, 128, 85, 255 },
-                                 { 54, 149, 68, 77, 94, 153, 255 },
-                                 { 243, 58, 50, 71, 81, 167, 255 },
-                                 { 189, 92, 64, 70, 121, 173, 255 },
-                                 { 248, 35, 38, 51, 82, 201, 255 },
-                             },
-                             {
-                                 // 8 colors
-                                 { 201, 40, 36, 42, 64, 92, 123 },
-                                 { 116, 43, 33, 43, 73, 102, 128 },
-                                 { 46, 77, 37, 69, 62, 78, 150 },
-                                 { 40, 65, 52, 50, 76, 89, 133 },
-                                 { 28, 48, 91, 17, 64, 77, 133 },
-                                 { 218, 43, 43, 37, 56, 72, 163 },
-                                 { 41, 155, 44, 83, 82, 129, 180 },
-                                 { 44, 141, 29, 55, 64, 89, 147 },
-                                 { 92, 166, 48, 45, 59, 126, 179 },
-                                 { 169, 35, 49, 41, 36, 99, 139 },
-                                 { 55, 77, 77, 56, 60, 75, 156 },
-                                 { 155, 81, 51, 64, 57, 182, 255 },
-                                 { 60, 134, 49, 49, 93, 128, 174 },
-                                 { 244, 98, 51, 46, 22, 73, 238 },
-                                 { 189, 70, 40, 87, 93, 79, 201 },
-                                 { 248, 54, 49, 40, 29, 42, 227 },
-                             } };
+const aom_prob
+    av1_default_palette_uv_color_prob[PALETTE_MAX_SIZE - 1]
+                                     [PALETTE_COLOR_CONTEXTS]
+                                     [PALETTE_COLORS - 1] = {
+                                       {
+                                           // 2 colors
+                                           { 228, 0, 0, 0, 0, 0, 0 },
+                                           { 195, 0, 0, 0, 0, 0, 0 },
+                                           { 0, 0, 0, 0, 0, 0, 0 },
+                                           { 0, 0, 0, 0, 0, 0, 0 },
+                                           { 0, 0, 0, 0, 0, 0, 0 },
+                                           { 228, 0, 0, 0, 0, 0, 0 },
+                                           { 71, 0, 0, 0, 0, 0, 0 },
+                                           { 0, 0, 0, 0, 0, 0, 0 },
+                                           { 129, 0, 0, 0, 0, 0, 0 },
+                                           { 206, 0, 0, 0, 0, 0, 0 },
+                                           { 0, 0, 0, 0, 0, 0, 0 },
+                                           { 136, 0, 0, 0, 0, 0, 0 },
+                                           { 98, 0, 0, 0, 0, 0, 0 },
+                                           { 236, 0, 0, 0, 0, 0, 0 },
+                                           { 222, 0, 0, 0, 0, 0, 0 },
+                                           { 249, 0, 0, 0, 0, 0, 0 },
+                                       },
+                                       {
+                                           // 3 colors
+                                           { 198, 136, 0, 0, 0, 0, 0 },
+                                           { 178, 105, 0, 0, 0, 0, 0 },
+                                           { 100, 206, 0, 0, 0, 0, 0 },
+                                           { 0, 0, 0, 0, 0, 0, 0 },
+                                           { 12, 136, 0, 0, 0, 0, 0 },
+                                           { 219, 134, 0, 0, 0, 0, 0 },
+                                           { 50, 198, 0, 0, 0, 0, 0 },
+                                           { 61, 231, 0, 0, 0, 0, 0 },
+                                           { 110, 209, 0, 0, 0, 0, 0 },
+                                           { 173, 106, 0, 0, 0, 0, 0 },
+                                           { 145, 166, 0, 0, 0, 0, 0 },
+                                           { 156, 175, 0, 0, 0, 0, 0 },
+                                           { 69, 183, 0, 0, 0, 0, 0 },
+                                           { 241, 163, 0, 0, 0, 0, 0 },
+                                           { 224, 160, 0, 0, 0, 0, 0 },
+                                           { 246, 154, 0, 0, 0, 0, 0 },
+                                       },
+                                       {
+                                           // 4 colors
+                                           { 173, 88, 143, 0, 0, 0, 0 },
+                                           { 146, 81, 127, 0, 0, 0, 0 },
+                                           { 84, 134, 102, 0, 0, 0, 0 },
+                                           { 69, 138, 140, 0, 0, 0, 0 },
+                                           { 31, 103, 200, 0, 0, 0, 0 },
+                                           { 217, 101, 139, 0, 0, 0, 0 },
+                                           { 51, 174, 121, 0, 0, 0, 0 },
+                                           { 64, 177, 109, 0, 0, 0, 0 },
+                                           { 96, 179, 145, 0, 0, 0, 0 },
+                                           { 164, 77, 114, 0, 0, 0, 0 },
+                                           { 87, 94, 156, 0, 0, 0, 0 },
+                                           { 105, 57, 173, 0, 0, 0, 0 },
+                                           { 63, 158, 137, 0, 0, 0, 0 },
+                                           { 236, 102, 156, 0, 0, 0, 0 },
+                                           { 197, 115, 153, 0, 0, 0, 0 },
+                                           { 245, 106, 154, 0, 0, 0, 0 },
+                                       },
+                                       {
+                                           // 5 colors
+                                           { 179, 64, 97, 129, 0, 0, 0 },
+                                           { 137, 56, 88, 125, 0, 0, 0 },
+                                           { 82, 107, 61, 118, 0, 0, 0 },
+                                           { 59, 113, 86, 115, 0, 0, 0 },
+                                           { 23, 88, 118, 130, 0, 0, 0 },
+                                           { 213, 66, 90, 125, 0, 0, 0 },
+                                           { 37, 181, 103, 121, 0, 0, 0 },
+                                           { 47, 188, 61, 131, 0, 0, 0 },
+                                           { 104, 185, 103, 144, 0, 0, 0 },
+                                           { 163, 39, 76, 112, 0, 0, 0 },
+                                           { 94, 74, 131, 126, 0, 0, 0 },
+                                           { 142, 42, 103, 163, 0, 0, 0 },
+                                           { 53, 162, 99, 149, 0, 0, 0 },
+                                           { 239, 54, 84, 108, 0, 0, 0 },
+                                           { 203, 84, 110, 147, 0, 0, 0 },
+                                           { 248, 70, 105, 151, 0, 0, 0 },
+                                       },
+                                       {
+                                           // 6 colors
+                                           { 189, 50, 67, 90, 130, 0, 0 },
+                                           { 114, 50, 55, 90, 123, 0, 0 },
+                                           { 66, 76, 54, 82, 128, 0, 0 },
+                                           { 43, 69, 69, 80, 129, 0, 0 },
+                                           { 22, 59, 87, 88, 141, 0, 0 },
+                                           { 203, 49, 68, 87, 122, 0, 0 },
+                                           { 43, 157, 74, 104, 146, 0, 0 },
+                                           { 54, 138, 51, 95, 138, 0, 0 },
+                                           { 82, 171, 58, 102, 146, 0, 0 },
+                                           { 129, 38, 59, 64, 168, 0, 0 },
+                                           { 56, 67, 119, 92, 112, 0, 0 },
+                                           { 96, 62, 53, 132, 82, 0, 0 },
+                                           { 60, 147, 77, 108, 145, 0, 0 },
+                                           { 238, 76, 73, 93, 148, 0, 0 },
+                                           { 189, 86, 73, 103, 157, 0, 0 },
+                                           { 246, 62, 75, 83, 167, 0, 0 },
+                                       },
+                                       {
+                                           // 7 colors
+                                           { 179, 42, 51, 73, 99, 134, 0 },
+                                           { 119, 52, 52, 61, 64, 114, 0 },
+                                           { 53, 77, 35, 65, 71, 131, 0 },
+                                           { 38, 70, 51, 68, 89, 144, 0 },
+                                           { 23, 65, 128, 73, 97, 131, 0 },
+                                           { 210, 47, 52, 63, 81, 143, 0 },
+                                           { 42, 159, 57, 68, 98, 143, 0 },
+                                           { 49, 153, 45, 82, 93, 143, 0 },
+                                           { 81, 169, 52, 72, 113, 151, 0 },
+                                           { 136, 46, 35, 56, 75, 96, 0 },
+                                           { 57, 84, 109, 47, 107, 131, 0 },
+                                           { 128, 78, 57, 36, 128, 85, 0 },
+                                           { 54, 149, 68, 77, 94, 153, 0 },
+                                           { 243, 58, 50, 71, 81, 167, 0 },
+                                           { 189, 92, 64, 70, 121, 173, 0 },
+                                           { 248, 35, 38, 51, 82, 201, 0 },
+                                       },
+                                       {
+                                           // 8 colors
+                                           { 201, 40, 36, 42, 64, 92, 123 },
+                                           { 116, 43, 33, 43, 73, 102, 128 },
+                                           { 46, 77, 37, 69, 62, 78, 150 },
+                                           { 40, 65, 52, 50, 76, 89, 133 },
+                                           { 28, 48, 91, 17, 64, 77, 133 },
+                                           { 218, 43, 43, 37, 56, 72, 163 },
+                                           { 41, 155, 44, 83, 82, 129, 180 },
+                                           { 44, 141, 29, 55, 64, 89, 147 },
+                                           { 92, 166, 48, 45, 59, 126, 179 },
+                                           { 169, 35, 49, 41, 36, 99, 139 },
+                                           { 55, 77, 77, 56, 60, 75, 156 },
+                                           { 155, 81, 51, 64, 57, 182, 255 },
+                                           { 60, 134, 49, 49, 93, 128, 174 },
+                                           { 244, 98, 51, 46, 22, 73, 238 },
+                                           { 189, 70, 40, 87, 93, 79, 201 },
+                                           { 248, 54, 49, 40, 29, 42, 227 },
+                                       }
+                                     };
 
 static const int palette_color_context_lookup[PALETTE_COLOR_CONTEXTS] = {
   // (3, 0, 0, 0), (3, 2, 0, 0), (3, 3, 2, 0), (3, 3, 2, 2),
@@ -848,23 +851,23 @@
 };
 #endif  // CONFIG_PALETTE
 
-const aom_tree_index av1_tx_size_tree[TX_SIZES - 1][TREE_SIZE(TX_SIZES)] = {
+const aom_tree_index av1_tx_size_tree[MAX_TX_DEPTH][TREE_SIZE(TX_SIZES)] = {
   {
       // Max tx_size is 8X8
-      -TX_4X4, -TX_8X8,
+      -0, -1,
   },
   {
       // Max tx_size is 16X16
-      -TX_4X4, 2, -TX_8X8, -TX_16X16,
+      -0, 2, -1, -2,
   },
   {
       // Max tx_size is 32X32
-      -TX_4X4, 2, -TX_8X8, 4, -TX_16X16, -TX_32X32,
+      -0, 2, -1, 4, -2, -3,
   },
 };
 
-static const aom_prob default_tx_size_prob[TX_SIZES - 1][TX_SIZE_CONTEXTS]
-                                          [TX_SIZES - 1] = {
+static const aom_prob default_tx_size_prob[MAX_TX_DEPTH][TX_SIZE_CONTEXTS]
+                                          [MAX_TX_DEPTH] = {
                                             {
                                                 // Max tx_size is 8X8
                                                 { 100 },
@@ -902,30 +905,24 @@
 int av1_get_palette_color_context(const uint8_t *color_map, int cols, int r,
                                   int c, int n, uint8_t *color_order,
                                   int *color_idx) {
-  int i, j, max, max_idx, temp;
+  int i;
+  // The +10 below should not be needed. But we get a warning "array subscript
+  // is above array bounds [-Werror=array-bounds]" without it, possibly due to
+  // this (or similar) bug: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59124
   int scores[PALETTE_MAX_SIZE + 10];
-  int weights[4] = { 3, 2, 3, 2 };
+  const int weights[4] = { 3, 2, 3, 2 };
   int color_ctx = 0;
   int color_neighbors[4];
   int inverse_color_order[PALETTE_MAX_SIZE];
   assert(n <= PALETTE_MAX_SIZE);
 
-  if (c - 1 >= 0)
-    color_neighbors[0] = color_map[r * cols + c - 1];
-  else
-    color_neighbors[0] = -1;
-  if (c - 1 >= 0 && r - 1 >= 0)
-    color_neighbors[1] = color_map[(r - 1) * cols + c - 1];
-  else
-    color_neighbors[1] = -1;
-  if (r - 1 >= 0)
-    color_neighbors[2] = color_map[(r - 1) * cols + c];
-  else
-    color_neighbors[2] = -1;
-  if (r - 1 >= 0 && c + 1 <= cols - 1)
-    color_neighbors[3] = color_map[(r - 1) * cols + c + 1];
-  else
-    color_neighbors[3] = -1;
+  color_neighbors[0] = (c - 1 >= 0) ? color_map[r * cols + c - 1] : -1;
+  color_neighbors[1] =
+      (c - 1 >= 0 && r - 1 >= 0) ? color_map[(r - 1) * cols + c - 1] : -1;
+  color_neighbors[2] = (r - 1 >= 0) ? color_map[(r - 1) * cols + c] : -1;
+  color_neighbors[3] = (r - 1 >= 0 && c + 1 <= cols - 1)
+                           ? color_map[(r - 1) * cols + c + 1]
+                           : -1;
 
   for (i = 0; i < PALETTE_MAX_SIZE; ++i) {
     color_order[i] = i;
@@ -933,23 +930,25 @@
   }
   memset(scores, 0, PALETTE_MAX_SIZE * sizeof(scores[0]));
   for (i = 0; i < 4; ++i) {
-    if (color_neighbors[i] >= 0) scores[color_neighbors[i]] += weights[i];
+    if (color_neighbors[i] >= 0) {
+      scores[color_neighbors[i]] += weights[i];
+    }
   }
 
+  // Get the top 4 scores (sorted from large to small).
   for (i = 0; i < 4; ++i) {
-    max = scores[i];
-    max_idx = i;
-    j = i + 1;
-    while (j < n) {
+    int max = scores[i];
+    int max_idx = i;
+    int j;
+    for (j = i + 1; j < n; ++j) {
       if (scores[j] > max) {
         max = scores[j];
         max_idx = j;
       }
-      ++j;
     }
 
     if (max_idx != i) {
-      temp = scores[i];
+      int temp = scores[i];
       scores[i] = scores[max_idx];
       scores[max_idx] = temp;
 
@@ -1310,13 +1309,21 @@
 
 static const aom_prob
     default_intra_ext_tx_prob[EXT_TX_SIZES][TX_TYPES][TX_TYPES - 1] = {
+#if CONFIG_CB4X4
+      { { 240, 85, 128 }, { 4, 1, 248 }, { 4, 1, 8 }, { 4, 248, 128 } },
+#endif
       { { 240, 85, 128 }, { 4, 1, 248 }, { 4, 1, 8 }, { 4, 248, 128 } },
       { { 244, 85, 128 }, { 8, 2, 248 }, { 8, 2, 8 }, { 8, 248, 128 } },
       { { 248, 85, 128 }, { 16, 4, 248 }, { 16, 4, 8 }, { 16, 248, 128 } },
     };
 
 static const aom_prob default_inter_ext_tx_prob[EXT_TX_SIZES][TX_TYPES - 1] = {
-  { 160, 85, 128 }, { 176, 85, 128 }, { 192, 85, 128 },
+#if CONFIG_CB4X4
+  { 160, 85, 128 },
+#endif
+  { 160, 85, 128 },
+  { 176, 85, 128 },
+  { 192, 85, 128 },
 };
 #endif  // CONFIG_EXT_TX
 
@@ -1561,7 +1568,7 @@
 
 #if CONFIG_VAR_TX && CONFIG_EXT_TX && CONFIG_RECT_TX
   if (cm->tx_mode == TX_MODE_SELECT) {
-    for (i = 0; i < TX_SIZES - 1; ++i) {
+    for (i = 0; i < MAX_TX_DEPTH; ++i) {
       fc->rect_tx_prob[i] =
           av1_mode_mv_merge_probs(pre_fc->rect_tx_prob[i], counts->rect_tx[i]);
     }
@@ -1593,7 +1600,7 @@
   const FRAME_COUNTS *counts = &cm->counts;
 
   if (cm->tx_mode == TX_MODE_SELECT) {
-    for (i = 0; i < TX_SIZES - 1; ++i) {
+    for (i = 0; i < MAX_TX_DEPTH; ++i) {
       for (j = 0; j < TX_SIZE_CONTEXTS; ++j)
         aom_tree_merge_probs(av1_tx_size_tree[i], pre_fc->tx_size_probs[i][j],
                              counts->tx_size[i][j], fc->tx_size_probs[i][j]);
diff --git a/av1/common/entropymode.h b/av1/common/entropymode.h
index 3043114..79b27da 100644
--- a/av1/common/entropymode.h
+++ b/av1/common/entropymode.h
@@ -125,7 +125,7 @@
 #else
   aom_prob comp_ref_prob[REF_CONTEXTS][COMP_REFS - 1];
 #endif  // CONFIG_EXT_REFS
-  aom_prob tx_size_probs[TX_SIZES - 1][TX_SIZE_CONTEXTS][TX_SIZES - 1];
+  aom_prob tx_size_probs[MAX_TX_DEPTH][TX_SIZE_CONTEXTS][MAX_TX_DEPTH];
 #if CONFIG_VAR_TX
   aom_prob txfm_partition_prob[TXFM_PARTITION_CONTEXTS];
 #if CONFIG_EXT_TX && CONFIG_RECT_TX
@@ -237,7 +237,7 @@
   // to use forward updates for the coeff probs, and as such it does not really
   // belong into this structure.
   unsigned int tx_size_totals[TX_SIZES];
-  unsigned int tx_size[TX_SIZES - 1][TX_SIZE_CONTEXTS][TX_SIZES];
+  unsigned int tx_size[MAX_TX_DEPTH][TX_SIZE_CONTEXTS][TX_SIZES];
 #if CONFIG_VAR_TX
   unsigned int txfm_partition[TXFM_PARTITION_CONTEXTS][2];
 #if CONFIG_EXT_TX && CONFIG_RECT_TX
@@ -324,7 +324,7 @@
 extern const aom_tree_index av1_palette_color_tree[PALETTE_MAX_SIZE - 1]
                                                   [TREE_SIZE(PALETTE_COLORS)];
 #endif  // CONFIG_PALETTE
-extern const aom_tree_index av1_tx_size_tree[TX_SIZES - 1][TREE_SIZE(TX_SIZES)];
+extern const aom_tree_index av1_tx_size_tree[MAX_TX_DEPTH][TREE_SIZE(TX_SIZES)];
 #if CONFIG_EXT_INTRA
 extern const aom_tree_index av1_intra_filter_tree[TREE_SIZE(INTRA_FILTERS)];
 #endif  // CONFIG_EXT_INTRA
diff --git a/av1/common/enums.h b/av1/common/enums.h
index 0a1f7a3..a684eed 100644
--- a/av1/common/enums.h
+++ b/av1/common/enums.h
@@ -131,6 +131,9 @@
 
 // block transform size
 typedef enum ATTRIBUTE_PACKED {
+#if CONFIG_CB4X4
+  TX_2X2,  // 2x2 transform
+#endif
   TX_4X4,    // 4x4 transform
   TX_8X8,    // 8x8 transform
   TX_16X16,  // 16x16 transform
@@ -148,6 +151,8 @@
   TX_INVALID = 255          // Invalid transform size
 } TX_SIZE;
 
+#define MAX_TX_DEPTH (TX_32X32 - TX_4X4)
+
 #define MAX_TX_SIZE_LOG2 5
 #define MAX_TX_SIZE (1 << MAX_TX_SIZE_LOG2)
 #define MIN_TX_SIZE_LOG2 2
@@ -206,8 +211,12 @@
 #define EXT_TX_SETS_INTER 4  // Sets of transform selections for INTER
 #define EXT_TX_SETS_INTRA 3  // Sets of transform selections for INTRA
 #else
+#if CONFIG_CB4X4
+#define EXT_TX_SIZES 4  // number of sizes that use extended transforms
+#else
 #define EXT_TX_SIZES 3  // number of sizes that use extended transforms
-#endif                  // CONFIG_EXT_TX
+#endif
+#endif  // CONFIG_EXT_TX
 
 typedef enum {
   AOM_LAST_FLAG = 1 << 0,
diff --git a/av1/common/loopfilter.c b/av1/common/loopfilter.c
index dc7ee18..dec5514 100644
--- a/av1/common/loopfilter.c
+++ b/av1/common/loopfilter.c
@@ -40,6 +40,9 @@
 //
 // A loopfilter should be applied to every other 8x8 horizontally.
 static const uint64_t left_64x64_txform_mask[TX_SIZES] = {
+#if CONFIG_CB4X4
+  0xffffffffffffffffULL,  // TX_2X2
+#endif
   0xffffffffffffffffULL,  // TX_4X4
   0xffffffffffffffffULL,  // TX_8x8
   0x5555555555555555ULL,  // TX_16x16
@@ -64,6 +67,9 @@
 //
 // A loopfilter should be applied to every other 4 the row vertically.
 static const uint64_t above_64x64_txform_mask[TX_SIZES] = {
+#if CONFIG_CB4X4
+  0xffffffffffffffffULL,  // TX_4X4
+#endif
   0xffffffffffffffffULL,  // TX_4X4
   0xffffffffffffffffULL,  // TX_8x8
   0x00ff00ff00ff00ffULL,  // TX_16x16
@@ -142,6 +148,9 @@
 
 // 16 bit masks for uv transform sizes.
 static const uint16_t left_64x64_txform_mask_uv[TX_SIZES] = {
+#if CONFIG_CB4X4
+  0xffff,  // TX_2X2
+#endif
   0xffff,  // TX_4X4
   0xffff,  // TX_8x8
   0x5555,  // TX_16x16
@@ -149,6 +158,9 @@
 };
 
 static const uint16_t above_64x64_txform_mask_uv[TX_SIZES] = {
+#if CONFIG_CB4X4
+  0xffff,  // TX_2X2
+#endif
   0xffff,  // TX_4X4
   0xffff,  // TX_8x8
   0x0f0f,  // TX_16x16
diff --git a/av1/common/onyxc_int.h b/av1/common/onyxc_int.h
index be1cbc1..f9b51aa 100644
--- a/av1/common/onyxc_int.h
+++ b/av1/common/onyxc_int.h
@@ -733,7 +733,8 @@
                                          TX_SIZE tx_size) {
   int above = *above_ctx < tx_size;
   int left = *left_ctx < tx_size;
-  return (tx_size - 1) * 3 + above + left;
+
+  return (tx_size - TX_8X8) * 3 + above + left;
 }
 #endif
 
diff --git a/av1/common/pred_common.h b/av1/common/pred_common.h
index b3ef1c4..b906749 100644
--- a/av1/common/pred_common.h
+++ b/av1/common/pred_common.h
@@ -186,8 +186,13 @@
   if (!has_left) left_ctx = above_ctx;
 
   if (!has_above) above_ctx = left_ctx;
-
+#if CONFIG_CB4X4
+  // TODO(jingning): Temporary setup. Will rework this after the cb4x4
+  // framework is up running.
+  return (above_ctx + left_ctx) > max_tx_size + 1;
+#else
   return (above_ctx + left_ctx) > max_tx_size;
+#endif
 }
 
 #if CONFIG_VAR_TX
diff --git a/av1/common/reconinter.h b/av1/common/reconinter.h
index 3eec384..5082d7b 100644
--- a/av1/common/reconinter.h
+++ b/av1/common/reconinter.h
@@ -418,7 +418,6 @@
                           const YV12_BUFFER_CONFIG *src, int mi_row, int mi_col,
                           const struct scale_factors *sf);
 
-#if CONFIG_DUAL_FILTER
 // Detect if the block have sub-pixel level motion vectors
 // per component.
 static INLINE int has_subpel_mv_component(const MODE_INFO *const mi,
@@ -460,60 +459,22 @@
 
   return 0;
 }
-#endif
 
-#if CONFIG_EXT_INTERP
 static INLINE int av1_is_interp_needed(const MACROBLOCKD *const xd) {
   MODE_INFO *const mi = xd->mi[0];
-  MB_MODE_INFO *const mbmi = &mi->mbmi;
-  const BLOCK_SIZE bsize = mbmi->sb_type;
-  const int is_compound = has_second_ref(mbmi);
-  int intpel_mv = 1;
-  int plane;
-
-#if SUPPORT_NONINTERPOLATING_FILTERS
-  // TODO(debargha): This is is currently only for experimentation
-  // with non-interpolating filters. Remove later.
-  // If any of the filters are non-interpolating, then indicate the
-  // interpolation filter always.
-  int i;
-  for (i = 0; i < SWITCHABLE_FILTERS; ++i) {
-    if (!IsInterpolatingFilter(i)) return 1;
-  }
-#endif
-
-  // For scaled references, interpolation filter is indicated all the time.
-  if (av1_is_scaled(&xd->block_refs[0]->sf)) return 1;
-  if (is_compound && av1_is_scaled(&xd->block_refs[1]->sf)) return 1;
-
-  if (bsize < BLOCK_8X8) {
-    for (plane = 0; plane < MAX_MB_PLANE; ++plane) {
-      const PARTITION_TYPE bp = BLOCK_8X8 - bsize;
-      const struct macroblockd_plane *const pd = &xd->plane[plane];
-      const int have_vsplit = bp != PARTITION_HORZ;
-      const int have_hsplit = bp != PARTITION_VERT;
-      const int num_4x4_w = 2 >> ((!have_vsplit) | pd->subsampling_x);
-      const int num_4x4_h = 2 >> ((!have_hsplit) | pd->subsampling_y);
-      int ref;
-      for (ref = 0; ref < 1 + is_compound; ++ref) {
-        int x, y;
-        for (y = 0; y < num_4x4_h; ++y)
-          for (x = 0; x < num_4x4_w; ++x) {
-            const MV mv = average_split_mvs(pd, mi, ref, y * 2 + x);
-            if (mv_has_subpel(&mv)) return 1;
-          }
+  const int is_compound = has_second_ref(&mi->mbmi);
+  int ref;
+  for (ref = 0; ref < 1 + is_compound; ++ref) {
+    int row_col;
+    for (row_col = 0; row_col < 2; ++row_col) {
+      const int dir = (ref << 1) + row_col;
+      if (has_subpel_mv_component(mi, xd, dir)) {
+        return 1;
       }
     }
-    return 0;
-  } else {
-    intpel_mv = !mv_has_subpel(&mbmi->mv[0].as_mv);
-    if (is_compound && intpel_mv) {
-      intpel_mv &= !mv_has_subpel(&mbmi->mv[1].as_mv);
-    }
   }
-  return !intpel_mv;
+  return 0;
 }
-#endif  // CONFIG_EXT_INTERP
 
 #if CONFIG_MOTION_VAR
 const uint8_t *av1_get_obmc_mask(int length);
diff --git a/av1/common/scan.c b/av1/common/scan.c
index 1281843..693386f 100644
--- a/av1/common/scan.c
+++ b/av1/common/scan.c
@@ -3801,6 +3801,9 @@
 #endif  // CONFIG_EXT_TX
 
 const SCAN_ORDER av1_default_scan_orders[TX_SIZES] = {
+#if CONFIG_CB4X4
+  { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors },
+#endif
   { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors },
   { default_scan_8x8, av1_default_iscan_8x8, default_scan_8x8_neighbors },
   { default_scan_16x16, av1_default_iscan_16x16, default_scan_16x16_neighbors },
@@ -3809,6 +3812,27 @@
 
 #if CONFIG_EXT_TX
 const SCAN_ORDER av1_intra_scan_orders[TX_SIZES][TX_TYPES] = {
+#if CONFIG_CB4X4
+  {
+      // TX_2X2
+      { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors },
+      { row_scan_4x4, av1_row_iscan_4x4, row_scan_4x4_neighbors },
+      { col_scan_4x4, av1_col_iscan_4x4, col_scan_4x4_neighbors },
+      { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors },
+      { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors },
+      { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors },
+      { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors },
+      { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors },
+      { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors },
+      { mrow_scan_4x4, av1_mrow_iscan_4x4, mrow_scan_4x4_neighbors },
+      { row_scan_4x4, av1_row_iscan_4x4, row_scan_4x4_neighbors },
+      { col_scan_4x4, av1_col_iscan_4x4, col_scan_4x4_neighbors },
+      { row_scan_4x4, av1_row_iscan_4x4, row_scan_4x4_neighbors },
+      { col_scan_4x4, av1_col_iscan_4x4, col_scan_4x4_neighbors },
+      { row_scan_4x4, av1_row_iscan_4x4, row_scan_4x4_neighbors },
+      { col_scan_4x4, av1_col_iscan_4x4, col_scan_4x4_neighbors },
+  },
+#endif
   {
       // TX_4X4
       { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors },
@@ -3896,6 +3920,27 @@
 };
 
 const SCAN_ORDER av1_inter_scan_orders[TX_SIZES_ALL][TX_TYPES] = {
+#if CONFIG_CB4X4
+  {
+      // TX_2X2
+      { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors },
+      { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors },
+      { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors },
+      { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors },
+      { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors },
+      { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors },
+      { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors },
+      { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors },
+      { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors },
+      { mrow_scan_4x4, av1_mrow_iscan_4x4, mrow_scan_4x4_neighbors },
+      { mrow_scan_4x4, av1_mrow_iscan_4x4, mrow_scan_4x4_neighbors },
+      { mcol_scan_4x4, av1_mcol_iscan_4x4, mcol_scan_4x4_neighbors },
+      { mrow_scan_4x4, av1_mrow_iscan_4x4, mrow_scan_4x4_neighbors },
+      { mcol_scan_4x4, av1_mcol_iscan_4x4, mcol_scan_4x4_neighbors },
+      { mrow_scan_4x4, av1_mrow_iscan_4x4, mrow_scan_4x4_neighbors },
+      { mcol_scan_4x4, av1_mcol_iscan_4x4, mcol_scan_4x4_neighbors },
+  },
+#endif
   {
       // TX_4X4
       { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors },
@@ -4134,9 +4179,16 @@
   }
 };
 
-#else   // CONFIG_EXT_TX
+#else  // CONFIG_EXT_TX
 
 const SCAN_ORDER av1_intra_scan_orders[TX_SIZES][TX_TYPES] = {
+#if CONFIG_CB4X4
+  { // TX_2X2
+    { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors },
+    { row_scan_4x4, av1_row_iscan_4x4, row_scan_4x4_neighbors },
+    { col_scan_4x4, av1_col_iscan_4x4, col_scan_4x4_neighbors },
+    { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors } },
+#endif
   { // TX_4X4
     { default_scan_4x4, av1_default_iscan_4x4, default_scan_4x4_neighbors },
     { row_scan_4x4, av1_row_iscan_4x4, row_scan_4x4_neighbors },
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index 8ab549b..b3617d1 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -3661,7 +3661,7 @@
 #endif
 
   if (cm->tx_mode == TX_MODE_SELECT) {
-    for (i = 0; i < TX_SIZES - 1; ++i)
+    for (i = 0; i < MAX_TX_DEPTH; ++i)
       for (j = 0; j < TX_SIZE_CONTEXTS; ++j)
         for (k = 0; k < i + 1; ++k)
           av1_diff_update_prob(&r, &fc->tx_size_probs[i][j][k], ACCT_STR);
@@ -3674,7 +3674,7 @@
     av1_diff_update_prob(&r, &fc->txfm_partition_prob[k], ACCT_STR);
 #if CONFIG_EXT_TX && CONFIG_RECT_TX
   if (cm->tx_mode == TX_MODE_SELECT) {
-    for (i = 1; i < TX_SIZES - 1; ++i)
+    for (i = 1; i < MAX_TX_DEPTH; ++i)
       av1_diff_update_prob(&r, &fc->rect_tx_prob[i], ACCT_STR);
   }
 #endif  // CONFIG_EXT_TX && CONFIG_RECT_TX
diff --git a/av1/decoder/decodemv.c b/av1/decoder/decodemv.c
index 3993e72..31183c0 100644
--- a/av1/decoder/decodemv.c
+++ b/av1/decoder/decodemv.c
@@ -350,11 +350,11 @@
                                      int tx_size_cat, aom_reader *r) {
   FRAME_COUNTS *counts = xd->counts;
   const int ctx = get_tx_size_context(xd);
-  int tx_size =
-      aom_read_tree(r, av1_tx_size_tree[tx_size_cat],
-                    cm->fc->tx_size_probs[tx_size_cat][ctx], ACCT_STR);
-  if (counts) ++counts->tx_size[tx_size_cat][ctx][tx_size];
-  return (TX_SIZE)tx_size;
+  int depth = aom_read_tree(r, av1_tx_size_tree[tx_size_cat],
+                            cm->fc->tx_size_probs[tx_size_cat][ctx], ACCT_STR);
+  TX_SIZE tx_size = depth_to_tx_size(depth);
+  if (counts) ++counts->tx_size[tx_size_cat][ctx][depth];
+  return tx_size;
 }
 
 static TX_SIZE read_tx_size_intra(AV1_COMMON *cm, MACROBLOCKD *xd,
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index 377af50..899aa81 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -74,7 +74,7 @@
 static struct av1_token palette_color_encodings[PALETTE_MAX_SIZE - 1]
                                                [PALETTE_MAX_SIZE];
 #endif  // CONFIG_PALETTE
-static const struct av1_token tx_size_encodings[TX_SIZES - 1][TX_SIZES] = {
+static const struct av1_token tx_size_encodings[MAX_TX_DEPTH][TX_SIZES] = {
   { { 0, 1 }, { 1, 1 } },                      // Max tx_size is 8X8
   { { 0, 1 }, { 2, 2 }, { 3, 2 } },            // Max tx_size is 16X16
   { { 0, 1 }, { 2, 2 }, { 6, 3 }, { 7, 3 } },  // Max tx_size is 32X32
@@ -414,6 +414,7 @@
     const int tx_size_cat = is_inter ? inter_tx_size_cat_lookup[bsize]
                                      : intra_tx_size_cat_lookup[bsize];
     const TX_SIZE coded_tx_size = txsize_sqr_up_map[tx_size];
+    const int depth = tx_size_to_depth(coded_tx_size);
 
 #if CONFIG_EXT_TX && CONFIG_RECT_TX
     assert(IMPLIES(is_rect_tx(tx_size), is_rect_tx_allowed(xd, mbmi)));
@@ -423,7 +424,7 @@
 
     av1_write_token(w, av1_tx_size_tree[tx_size_cat],
                     cm->fc->tx_size_probs[tx_size_cat][tx_size_ctx],
-                    &tx_size_encodings[tx_size_cat][coded_tx_size]);
+                    &tx_size_encodings[tx_size_cat][depth]);
   }
 }
 
@@ -2873,7 +2874,7 @@
                               FRAME_COUNTS *counts) {
   if (cm->tx_mode == TX_MODE_SELECT) {
     int i, j;
-    for (i = 0; i < TX_SIZES - 1; ++i)
+    for (i = 0; i < MAX_TX_DEPTH; ++i)
       for (j = 0; j < TX_SIZE_CONTEXTS; ++j)
         prob_diff_update(av1_tx_size_tree[i], cm->fc->tx_size_probs[i][j],
                          counts->tx_size[i][j], i + 2, w);
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index 3733efc..c94c1d8 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -4442,8 +4442,10 @@
   av1_zero_above_context(cm, tile_info->mi_col_start, tile_info->mi_col_end);
 
   // Set up pointers to per thread motion search counters.
-  td->mb.m_search_count_ptr = &td->rd_counts.m_search_count;
-  td->mb.ex_search_count_ptr = &td->rd_counts.ex_search_count;
+  this_tile->m_search_count = 0;   // Count of motion search hits.
+  this_tile->ex_search_count = 0;  // Exhaustive mesh search hits.
+  td->mb.m_search_count_ptr = &this_tile->m_search_count;
+  td->mb.ex_search_count_ptr = &this_tile->ex_search_count;
 
   for (mi_row = tile_info->mi_row_start; mi_row < tile_info->mi_row_end;
        mi_row += cm->mib_size) {
@@ -4484,10 +4486,35 @@
 #define MIN_TRANS_THRESH 8
 #define GLOBAL_MOTION_ADVANTAGE_THRESH 0.60
 #define GLOBAL_MOTION_MODEL ROTZOOM
-// TODO(sarahparker) This function needs to be adjusted
-// to accomodate changes in the paraemter integerization.
-// Commenting it out until the fix is made.
-/*
+
+// Adds some offset to a global motion parameter and handles
+// all of the necessary precision shifts, clamping, and
+// zero-centering.
+static int16_t add_param_offset(int param_index, int16_t param_value,
+                                int16_t offset) {
+  int scale_vals[2] = { GM_ALPHA_PREC_DIFF, GM_TRANS_PREC_DIFF };
+  int clamp_vals[2] = { GM_ALPHA_MAX, GM_TRANS_MAX };
+  int is_trans_param = param_index < 2;
+  int is_one_centered = (!is_trans_param) && (param_index & 1);
+
+  // Make parameter zero-centered and offset the shift that was done to make
+  // it compatible with the warped model
+  param_value = (param_value - (is_one_centered << WARPEDMODEL_PREC_BITS)) >>
+                scale_vals[is_trans_param];
+  // Add desired offset to the rescaled/zero-centered parameter
+  param_value += offset;
+  // Clamp the parameter so it does not overflow the number of bits allotted
+  // to it in the bitstream
+  param_value = (int16_t)clamp(param_value, -clamp_vals[is_trans_param],
+                               clamp_vals[is_trans_param]);
+  // Rescale the parameter to WARPEDMODEL_PRECIION_BITS so it is compatible
+  // with the warped motion library
+  param_value *= (1 << scale_vals[is_trans_param]);
+
+  // Undo the zero-centring step if necessary
+  return param_value + (is_one_centered << WARPEDMODEL_PREC_BITS);
+}
+
 static void refine_integerized_param(WarpedMotionParams *wm,
 #if CONFIG_AOM_HIGHBITDEPTH
                                      int use_hbd, int bd,
@@ -4500,7 +4527,7 @@
   int n_params = n_trans_model_params[wm->wmtype];
   int16_t *param_mat = (int16_t *)wm->wmmat;
   double step_error;
-  int step;
+  int16_t step;
   int16_t *param;
   int16_t curr_param;
   int16_t best_param;
@@ -4519,9 +4546,7 @@
     best_param = curr_param;
     for (i = 0; i < n_refinements; i++) {
       // look to the left
-      *param =
-          (int16_t)clamp(curr_param - step, p < 2 ? GM_TRANS_MIN : GM_ALPHA_MIN,
-                         p < 2 ? GM_TRANS_MAX : GM_ALPHA_MAX);
+      *param = add_param_offset(p, curr_param, -step);
       step_error =
           av1_warp_erroradv(wm,
 #if CONFIG_AOM_HIGHBITDEPTH
@@ -4538,9 +4563,7 @@
       }
 
       // look to the right
-      *param =
-          (int16_t)clamp(curr_param + step, p < 2 ? GM_TRANS_MIN : GM_ALPHA_MIN,
-                         p < 2 ? GM_TRANS_MAX : GM_ALPHA_MAX);
+      *param = add_param_offset(p, curr_param, step);
       step_error =
           av1_warp_erroradv(wm,
 #if CONFIG_AOM_HIGHBITDEPTH
@@ -4564,7 +4587,6 @@
     *param = best_param;
   }
 }
-*/
 
 static void convert_to_params(const double *params, TransformationType type,
                               int16_t *model) {
@@ -4624,8 +4646,6 @@
   av1_zero(*td->counts);
   av1_zero(rdc->coef_counts);
   av1_zero(rdc->comp_pred_diff);
-  rdc->m_search_count = 0;   // Count of motion search hits.
-  rdc->ex_search_count = 0;  // Exhaustive mesh search hits.
 
 #if CONFIG_GLOBAL_MOTION
   aom_clear_system_state();
@@ -4643,6 +4663,14 @@
           convert_model_to_params(params, GLOBAL_MOTION_MODEL,
                                   &cm->global_motion[frame]);
           if (get_gmtype(&cm->global_motion[frame]) > GLOBAL_ZERO) {
+            refine_integerized_param(
+                &cm->global_motion[frame].motion_params,
+#if CONFIG_AOM_HIGHBITDEPTH
+                xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH, xd->bd,
+#endif  // CONFIG_AOM_HIGHBITDEPTH
+                ref_buf->y_buffer, ref_buf->y_width, ref_buf->y_height,
+                ref_buf->y_stride, cpi->Source->y_buffer, cpi->Source->y_width,
+                cpi->Source->y_height, cpi->Source->y_stride, 3);
             // compute the advantage of using gm parameters over 0 motion
             erroradvantage = av1_warp_erroradv(
                 &cm->global_motion[frame].motion_params,
@@ -5206,6 +5234,7 @@
       const int tx_size_cat = is_inter ? inter_tx_size_cat_lookup[bsize]
                                        : intra_tx_size_cat_lookup[bsize];
       const TX_SIZE coded_tx_size = txsize_sqr_up_map[mbmi->tx_size];
+      const int depth = tx_size_to_depth(coded_tx_size);
 #if CONFIG_EXT_TX && CONFIG_RECT_TX
       assert(IMPLIES(is_rect_tx(mbmi->tx_size), is_rect_tx_allowed(xd, mbmi)));
 #endif  // CONFIG_EXT_TX && CONFIG_RECT_TX
@@ -5219,7 +5248,7 @@
         if (is_inter) {
           tx_partition_count_update(cm, x, bsize, mi_row, mi_col, td->counts);
         } else {
-          ++td->counts->tx_size[tx_size_cat][tx_size_ctx][coded_tx_size];
+          ++td->counts->tx_size[tx_size_cat][tx_size_ctx][depth];
           if (mbmi->tx_size != max_txsize_lookup[bsize]) ++x->txb_split_count;
         }
 #if CONFIG_EXT_TX && CONFIG_RECT_TX
@@ -5227,7 +5256,7 @@
 #endif
 #endif
 #if !CONFIG_VAR_TX
-      ++td->counts->tx_size[tx_size_cat][tx_size_ctx][coded_tx_size];
+      ++td->counts->tx_size[tx_size_cat][tx_size_ctx][depth];
 #endif
     } else {
       int i, j;
diff --git a/av1/encoder/encodemb.c b/av1/encoder/encodemb.c
index 6b7e72c..c5459dc 100644
--- a/av1/encoder/encodemb.c
+++ b/av1/encoder/encodemb.c
@@ -81,7 +81,7 @@
   tran_low_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
   const int eob = p->eobs[block];
   const PLANE_TYPE plane_type = pd->plane_type;
-  const int default_eob = get_tx2d_size(tx_size);
+  const int default_eob = tx_size_2d[tx_size];
   const int16_t *const dequant_ptr = pd->dequant;
   const uint8_t *const band_translate = get_band_translate(tx_size);
   TX_TYPE tx_type = get_tx_type(plane_type, xd, block, tx_size);
@@ -826,12 +826,9 @@
   }
 
 #if CONFIG_VAR_TX
-  for (i = 0; i < num_4x4_blocks_wide_txsize_lookup[tx_size]; ++i) {
-    a[i] = a[0];
-  }
-  for (i = 0; i < num_4x4_blocks_high_txsize_lookup[tx_size]; ++i) {
-    l[i] = l[0];
-  }
+  for (i = 0; i < tx_size_wide_unit[tx_size]; ++i) a[i] = a[0];
+
+  for (i = 0; i < tx_size_high_unit[tx_size]; ++i) l[i] = l[0];
 #endif
 
   if (p->eobs[block]) *(args->skip) = 0;
@@ -885,25 +882,23 @@
   if (tx_size == plane_tx_size) {
     encode_block(plane, block, blk_row, blk_col, plane_bsize, tx_size, arg);
   } else {
-    int bsl = b_width_log2_lookup[bsize];
+    int bsl = block_size_wide[bsize] >> (tx_size_wide_log2[0] + 1);
     int i;
-
     assert(bsl > 0);
-    --bsl;
-
 #if CONFIG_EXT_TX
     assert(tx_size < TX_SIZES);
 #endif  // CONFIG_EXT_TX
 
     for (i = 0; i < 4; ++i) {
-      const int offsetr = blk_row + ((i >> 1) << bsl);
-      const int offsetc = blk_col + ((i & 0x01) << bsl);
-      int step = num_4x4_blocks_txsize_lookup[tx_size - 1];
+      const int offsetr = blk_row + ((i >> 1) * bsl);
+      const int offsetc = blk_col + ((i & 0x01) * bsl);
+      const TX_SIZE sub_txs = tx_size - 1;
+      int step = tx_size_wide_unit[sub_txs] * tx_size_high_unit[sub_txs];
 
       if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue;
 
       encode_block_inter(plane, block + i * step, offsetr, offsetc, plane_bsize,
-                         tx_size - 1, arg);
+                         sub_txs, arg);
     }
   }
 }
@@ -983,14 +978,15 @@
     // TODO(jingning): Clean this up.
     const struct macroblockd_plane *const pd = &xd->plane[plane];
     const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-    const int mi_width = num_4x4_blocks_wide_lookup[plane_bsize];
-    const int mi_height = num_4x4_blocks_high_lookup[plane_bsize];
+    const int mi_width = block_size_wide[plane_bsize] >> tx_size_wide_log2[0];
+    const int mi_height = block_size_high[plane_bsize] >> tx_size_wide_log2[0];
     const TX_SIZE max_tx_size = max_txsize_lookup[plane_bsize];
     const BLOCK_SIZE txb_size = txsize_to_bsize[max_tx_size];
-    const int bh = num_4x4_blocks_wide_lookup[txb_size];
+    const int bw = block_size_wide[txb_size] >> tx_size_wide_log2[0];
+    const int bh = block_size_high[txb_size] >> tx_size_wide_log2[0];
     int idx, idy;
     int block = 0;
-    int step = num_4x4_blocks_txsize_lookup[max_tx_size];
+    int step = tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size];
     av1_get_entropy_contexts(bsize, TX_4X4, pd, ctx.ta[plane], ctx.tl[plane]);
 #else
     const struct macroblockd_plane *const pd = &xd->plane[plane];
@@ -1009,7 +1005,7 @@
     } else {
 #endif
       for (idy = 0; idy < mi_height; idy += bh) {
-        for (idx = 0; idx < mi_width; idx += bh) {
+        for (idx = 0; idx < mi_width; idx += bw) {
           encode_block_inter(plane, block, idy, idx, plane_bsize, max_tx_size,
                              &arg);
           block += step;
diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index 629eb46..03f6ffd 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -3596,7 +3596,7 @@
   recon_err = aom_get_y_sse(cpi->Source, get_frame_new_buffer(cm));
 
   if (cpi->twopass.total_left_stats.coded_error != 0.0)
-    fprintf(f, "%10u %dx%d  %10d %10d %d %d %10d %10d %10d %10d"
+    fprintf(f, "%10u %dx%d %d %d %10d %10d %10d %10d"
        "%10"PRId64" %10"PRId64" %5d %5d %10"PRId64" "
        "%10"PRId64" %10"PRId64" %10d "
        "%7.2lf %7.2lf %7.2lf %7.2lf %7.2lf"
@@ -3605,8 +3605,6 @@
         "%10lf %8u %10"PRId64" %10d %10d %10d\n",
         cpi->common.current_video_frame,
         cm->width, cm->height,
-        cpi->td.rd_counts.m_search_count,
-        cpi->td.rd_counts.ex_search_count,
         cpi->rc.source_alt_ref_pending,
         cpi->rc.source_alt_ref_active,
         cpi->rc.this_frame_target,
diff --git a/av1/encoder/encoder.h b/av1/encoder/encoder.h
index 8738609..00abc71 100644
--- a/av1/encoder/encoder.h
+++ b/av1/encoder/encoder.h
@@ -268,13 +268,13 @@
   TileInfo tile_info;
   int thresh_freq_fact[BLOCK_SIZES][MAX_MODES];
   int mode_map[BLOCK_SIZES][MAX_MODES];
+  int m_search_count;
+  int ex_search_count;
 } TileDataEnc;
 
 typedef struct RD_COUNTS {
   av1_coeff_count coef_counts[TX_SIZES][PLANE_TYPES];
   int64_t comp_pred_diff[REFERENCE_MODES];
-  int m_search_count;
-  int ex_search_count;
 } RD_COUNTS;
 
 typedef struct ThreadData {
diff --git a/av1/encoder/ethread.c b/av1/encoder/ethread.c
index 117d0ed..5876d15 100644
--- a/av1/encoder/ethread.c
+++ b/av1/encoder/ethread.c
@@ -27,10 +27,6 @@
             for (n = 0; n < ENTROPY_TOKENS; n++)
               td->rd_counts.coef_counts[i][j][k][l][m][n] +=
                   td_t->rd_counts.coef_counts[i][j][k][l][m][n];
-
-  // Counts of all motion searches and exhuastive mesh searches.
-  td->rd_counts.m_search_count += td_t->rd_counts.m_search_count;
-  td->rd_counts.ex_search_count += td_t->rd_counts.ex_search_count;
 }
 
 static int enc_worker_hook(EncWorkerData *const thread_data, void *unused) {
diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c
index 5015837..cfc8cb3 100644
--- a/av1/encoder/rd.c
+++ b/av1/encoder/rd.c
@@ -110,7 +110,7 @@
   }
 #endif  // CONFIG_PALETTE
 
-  for (i = 0; i < TX_SIZES - 1; ++i)
+  for (i = 0; i < MAX_TX_DEPTH; ++i)
     for (j = 0; j < TX_SIZE_CONTEXTS; ++j)
       av1_cost_tokens(cpi->tx_size_cost[i][j], fc->tx_size_probs[i][j],
                       av1_tx_size_tree[i]);
@@ -720,30 +720,41 @@
 
 #if CONFIG_DUAL_FILTER
 int av1_get_switchable_rate(const AV1_COMP *cpi, const MACROBLOCKD *const xd) {
-  const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
-  int inter_filter_cost = 0;
-  int dir;
+  const AV1_COMMON *const cm = &cpi->common;
+  if (cm->interp_filter == SWITCHABLE) {
+    const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
+    int inter_filter_cost = 0;
+    int dir;
 
-  for (dir = 0; dir < 2; ++dir) {
-    if (has_subpel_mv_component(xd->mi[0], xd, dir) ||
-        (mbmi->ref_frame[1] > INTRA_FRAME &&
-         has_subpel_mv_component(xd->mi[0], xd, dir + 2))) {
-      const int ctx = av1_get_pred_context_switchable_interp(xd, dir);
-      inter_filter_cost +=
-          cpi->switchable_interp_costs[ctx][mbmi->interp_filter[dir]];
+    for (dir = 0; dir < 2; ++dir) {
+      if (has_subpel_mv_component(xd->mi[0], xd, dir) ||
+          (mbmi->ref_frame[1] > INTRA_FRAME &&
+           has_subpel_mv_component(xd->mi[0], xd, dir + 2))) {
+        const int ctx = av1_get_pred_context_switchable_interp(xd, dir);
+        inter_filter_cost +=
+            cpi->switchable_interp_costs[ctx][mbmi->interp_filter[dir]];
+      }
     }
+    return SWITCHABLE_INTERP_RATE_FACTOR * inter_filter_cost;
+  } else {
+    return 0;
   }
-  return SWITCHABLE_INTERP_RATE_FACTOR * inter_filter_cost;
 }
 #else
 int av1_get_switchable_rate(const AV1_COMP *cpi, const MACROBLOCKD *const xd) {
-  const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
-  const int ctx = av1_get_pred_context_switchable_interp(xd);
+  const AV1_COMMON *const cm = &cpi->common;
+  if (cm->interp_filter == SWITCHABLE) {
 #if CONFIG_EXT_INTERP
-  if (!av1_is_interp_needed(xd)) return 0;
-#endif  // CONFIG_EXT_INTERP
-  return SWITCHABLE_INTERP_RATE_FACTOR *
-         cpi->switchable_interp_costs[ctx][mbmi->interp_filter];
+    if (av1_is_interp_needed(xd))
+#endif
+    {
+      const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
+      const int ctx = av1_get_pred_context_switchable_interp(xd);
+      return SWITCHABLE_INTERP_RATE_FACTOR *
+             cpi->switchable_interp_costs[ctx][mbmi->interp_filter];
+    }
+  }
+  return 0;
 }
 #endif
 
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index 76d471e..c6b9979 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -1318,9 +1318,9 @@
   const int tx_size_cat =
       is_inter ? inter_tx_size_cat_lookup[bs] : intra_tx_size_cat_lookup[bs];
   const TX_SIZE coded_tx_size = txsize_sqr_up_map[tx_size];
+  const int depth = tx_size_to_depth(coded_tx_size);
   const int tx_select = cm->tx_mode == TX_MODE_SELECT;
-  const int r_tx_size =
-      cpi->tx_size_cost[tx_size_cat][tx_size_ctx][coded_tx_size];
+  const int r_tx_size = cpi->tx_size_cost[tx_size_cat][tx_size_ctx][depth];
 
   assert(skip_prob > 0);
 #if CONFIG_EXT_TX && CONFIG_RECT_TX
@@ -2746,7 +2746,7 @@
       // not the tokenonly rate.
       this_rate_tokenonly -=
           cpi->tx_size_cost[max_tx_size - TX_8X8][get_tx_size_context(xd)]
-                           [mic->mbmi.tx_size];
+                           [tx_size_to_depth(mic->mbmi.tx_size)];
     }
 #if CONFIG_PALETTE
     if (cpi->common.allow_screen_content_tools && mic->mbmi.mode == DC_PRED)
@@ -3222,7 +3222,8 @@
     int bh = num_4x4_blocks_wide_lookup[txb_size];
     int idx, idy;
     int block = 0;
-    int step = 1 << (max_txsize_lookup[plane_bsize] * 2);
+    int step = tx_size_wide_unit[max_txsize_lookup[plane_bsize]] *
+               tx_size_high_unit[max_txsize_lookup[plane_bsize]];
     ENTROPY_CONTEXT ctxa[2 * MAX_MIB_SIZE];
     ENTROPY_CONTEXT ctxl[2 * MAX_MIB_SIZE];
     TXFM_CONTEXT tx_above[MAX_MIB_SIZE];
@@ -3519,6 +3520,7 @@
     coeff_ctx = combine_entropy_contexts(ta[0], tl[0]);
     av1_tx_block_rd_b(cpi, x, tx_size, blk_row, blk_col, plane, block,
                       plane_bsize, coeff_ctx, rate, dist, bsse, skip);
+
     for (i = 0; i < num_4x4_blocks_wide_txsize_lookup[tx_size]; ++i)
       ta[i] = !(p->eobs[block] == 0);
     for (i = 0; i < num_4x4_blocks_high_txsize_lookup[tx_size]; ++i)
@@ -6367,10 +6369,6 @@
   const int this_mode = mbmi->mode;
   int refs[2] = { mbmi->ref_frame[0],
                   (mbmi->ref_frame[1] < 0 ? 0 : mbmi->ref_frame[1]) };
-#if CONFIG_DUAL_FILTER
-  (void)pred_filter_search;
-  return SWITCHABLE;
-#else
   if (pred_filter_search) {
     InterpFilter af = SWITCHABLE, lf = SWITCHABLE;
     if (xd->up_available) af = xd->mi[-xd->mi_stride]->mbmi.interp_filter;
@@ -6385,7 +6383,6 @@
 #endif  // CONFIG_EXT_INTER
       best_filter = af;
   }
-#endif
   if (is_comp_pred) {
     if (cpi->sf.adaptive_mode_search) {
 #if CONFIG_EXT_INTER
@@ -6448,15 +6445,8 @@
 #endif  // CONFIG_EXT_INTER
     }
   }
-  if (cm->interp_filter != BILINEAR) {
-    if (x->source_variance < cpi->sf.disable_filter_search_var_thresh) {
-      best_filter = EIGHTTAP_REGULAR;
-    }
-#if CONFIG_EXT_INTERP
-    else if (!av1_is_interp_needed(xd) && cm->interp_filter == SWITCHABLE) {
-      best_filter = EIGHTTAP_REGULAR;
-    }
-#endif
+  if (x->source_variance < cpi->sf.disable_filter_search_var_thresh) {
+    best_filter = EIGHTTAP_REGULAR;
   }
   return best_filter;
 }
@@ -6676,6 +6666,7 @@
   int_mv cur_mv[2];
   int rate_mv = 0;
 #if CONFIG_EXT_INTER
+  int pred_exists = 1;
   const int bw = 4 * num_4x4_blocks_wide_lookup[bsize];
   int mv_idx = (this_mode == NEWFROMNEARMV) ? 1 : 0;
   int_mv single_newmv[TOTAL_REFS_PER_FRAME];
@@ -6706,6 +6697,7 @@
   uint8_t best_blk_skip[MAX_MB_PLANE][MAX_MIB_SIZE * MAX_MIB_SIZE * 4];
 #endif  // CONFIG_VAR_TX
   int64_t best_distortion = INT64_MAX;
+  int64_t best_rd = INT64_MAX;
   MB_MODE_INFO best_mbmi;
 #if CONFIG_EXT_INTER
   int rate2_bmc_nocoeff;
@@ -6713,24 +6705,14 @@
   MB_MODE_INFO best_bmc_mbmi;
 #endif  // CONFIG_EXT_INTER
 #endif  // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
-
-  int pred_exists = 0;
-  int intpel_mv;
-  int64_t rd, tmp_rd, best_rd = INT64_MAX;
-  int best_needs_copy = 0;
+  int64_t rd = INT64_MAX;
+  int64_t tmp_rd = INT64_MAX;
   uint8_t *orig_dst[MAX_MB_PLANE];
   int orig_dst_stride[MAX_MB_PLANE];
+  uint8_t *tmp_dst[MAX_MB_PLANE];
+  int tmp_dst_stride[MAX_MB_PLANE];
   int rs = 0;
-#if CONFIG_DUAL_FILTER
-  // Index use case:
-  // {0, 1} -> (vertical, horizontal) filter types for the first ref frame
-  // {2, 3} -> (vertical, horizontal) filter types for the second ref frame
-  InterpFilter best_filter[4] = {
-    SWITCHABLE, SWITCHABLE, SWITCHABLE, SWITCHABLE,
-  };
-#else
-  InterpFilter best_filter = SWITCHABLE;
-#endif
+  InterpFilter assign_filter = SWITCHABLE;
 
   int skip_txfm_sb = 0;
   int64_t skip_sse_sb = INT64_MAX;
@@ -6966,6 +6948,10 @@
   // one for future predictions. In the end, copy from tmp_buf to
   // dst if necessary.
   for (i = 0; i < MAX_MB_PLANE; i++) {
+    tmp_dst[i] = tmp_buf + i * MAX_SB_SQUARE;
+    tmp_dst_stride[i] = MAX_SB_SIZE;
+  }
+  for (i = 0; i < MAX_MB_PLANE; i++) {
     orig_dst[i] = xd->plane[i].dst.buf;
     orig_dst_stride[i] = xd->plane[i].dst.stride;
   }
@@ -7003,135 +6989,125 @@
       )
     return INT64_MAX;
 
-  pred_exists = 0;
-  // Are all MVs integer pel for Y and UV
-  intpel_mv = !mv_has_subpel(&mbmi->mv[0].as_mv);
-  if (is_comp_pred) intpel_mv &= !mv_has_subpel(&mbmi->mv[1].as_mv);
-
+  if (cm->interp_filter == SWITCHABLE) {
 #if !CONFIG_DUAL_FILTER
-  best_filter =
-      predict_interp_filter(cpi, x, bsize, mi_row, mi_col, single_filter);
+    assign_filter =
+        predict_interp_filter(cpi, x, bsize, mi_row, mi_col, single_filter);
 #endif
+#if CONFIG_EXT_INTERP || CONFIG_DUAL_FILTER
+    if (!av1_is_interp_needed(xd)) assign_filter = EIGHTTAP_REGULAR;
+#endif
+  } else {
+    assign_filter = cm->interp_filter;
+  }
 
-  if (cm->interp_filter != BILINEAR) {
-    int newbest;
-    int tmp_rate_sum = 0;
-    int64_t tmp_dist_sum = 0;
-
+  {  // Do interpolation filter search in the parentheses
+    int tmp_rate;
+    int64_t tmp_dist;
 #if CONFIG_DUAL_FILTER
-    for (i = 0; i < SWITCHABLE_FILTERS * SWITCHABLE_FILTERS; ++i)
+    mbmi->interp_filter[0] =
+        assign_filter == SWITCHABLE ? EIGHTTAP_REGULAR : assign_filter;
+    mbmi->interp_filter[1] =
+        assign_filter == SWITCHABLE ? EIGHTTAP_REGULAR : assign_filter;
+    mbmi->interp_filter[2] =
+        assign_filter == SWITCHABLE ? EIGHTTAP_REGULAR : assign_filter;
+    mbmi->interp_filter[3] =
+        assign_filter == SWITCHABLE ? EIGHTTAP_REGULAR : assign_filter;
 #else
-    for (i = 0; i < SWITCHABLE_FILTERS; ++i)
+    mbmi->interp_filter =
+        assign_filter == SWITCHABLE ? EIGHTTAP_REGULAR : assign_filter;
 #endif
-    {
-      int j;
-      int64_t rs_rd;
-      int tmp_skip_sb = 0;
-      int64_t tmp_skip_sse = INT64_MAX;
+    rs = av1_get_switchable_rate(cpi, xd);
+    av1_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
+    model_rd_for_sb(cpi, bsize, x, xd, 0, MAX_MB_PLANE - 1, &tmp_rate,
+                    &tmp_dist, &skip_txfm_sb, &skip_sse_sb);
+    rd = RDCOST(x->rdmult, x->rddiv, rs + tmp_rate, tmp_dist);
 
+    if (assign_filter == SWITCHABLE) {
+      // do interp_filter search
+      if (av1_is_interp_needed(xd)) {
+        int best_in_temp = 0;
 #if CONFIG_DUAL_FILTER
-      mbmi->interp_filter[0] = filter_sets[i][0];
-      mbmi->interp_filter[1] = filter_sets[i][1];
-      mbmi->interp_filter[2] = filter_sets[i][0];
-      mbmi->interp_filter[3] = filter_sets[i][1];
+        InterpFilter best_filter[4];
+        av1_copy(best_filter, mbmi->interp_filter);
 #else
-      mbmi->interp_filter = i;
+        InterpFilter best_filter = mbmi->interp_filter;
 #endif
-      rs = av1_get_switchable_rate(cpi, xd);
-      rs_rd = RDCOST(x->rdmult, x->rddiv, rs, 0);
+        restore_dst_buf(xd, tmp_dst, tmp_dst_stride);
+#if CONFIG_DUAL_FILTER
+        // EIGHTTAP_REGULAR mode is calculated beforehand
+        for (i = 1; i < SWITCHABLE_FILTERS * SWITCHABLE_FILTERS; ++i)
+#else
+        // EIGHTTAP_REGULAR mode is calculated beforehand
+        for (i = 1; i < SWITCHABLE_FILTERS; ++i)
+#endif
+        {
+          int tmp_skip_sb = 0;
+          int64_t tmp_skip_sse = INT64_MAX;
+          int tmp_rs;
+#if CONFIG_DUAL_FILTER
+          mbmi->interp_filter[0] = filter_sets[i][0];
+          mbmi->interp_filter[1] = filter_sets[i][1];
+          mbmi->interp_filter[2] = filter_sets[i][0];
+          mbmi->interp_filter[3] = filter_sets[i][1];
+#else
+          mbmi->interp_filter = i;
+#endif
+          tmp_rs = av1_get_switchable_rate(cpi, xd);
+          av1_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
+          model_rd_for_sb(cpi, bsize, x, xd, 0, MAX_MB_PLANE - 1, &tmp_rate,
+                          &tmp_dist, &tmp_skip_sb, &tmp_skip_sse);
+          tmp_rd = RDCOST(x->rdmult, x->rddiv, tmp_rs + tmp_rate, tmp_dist);
 
-      if (i > 0 && intpel_mv && IsInterpolatingFilter(i)) {
-        rd = RDCOST(x->rdmult, x->rddiv, tmp_rate_sum, tmp_dist_sum);
-        if (cm->interp_filter == SWITCHABLE) rd += rs_rd;
-      } else {
-        int rate_sum = 0;
-        int64_t dist_sum = 0;
-        if ((cm->interp_filter == SWITCHABLE && (!i || best_needs_copy)) ||
-#if CONFIG_EXT_INTER
-            is_comp_interintra_pred ||
-#endif  // CONFIG_EXT_INTER
-            (cm->interp_filter != SWITCHABLE &&
-             (
+          if (tmp_rd < rd) {
+            rd = tmp_rd;
+            rs = av1_get_switchable_rate(cpi, xd);
 #if CONFIG_DUAL_FILTER
-                 cm->interp_filter == mbmi->interp_filter[0]
+            av1_copy(best_filter, mbmi->interp_filter);
 #else
-                 cm->interp_filter == mbmi->interp_filter
+            best_filter = mbmi->interp_filter;
 #endif
-                 || (i == 0 && intpel_mv && IsInterpolatingFilter(i))))) {
-          restore_dst_buf(xd, orig_dst, orig_dst_stride);
-        } else {
-          for (j = 0; j < MAX_MB_PLANE; j++) {
-            xd->plane[j].dst.buf = tmp_buf + j * MAX_SB_SQUARE;
-            xd->plane[j].dst.stride = MAX_SB_SIZE;
+            skip_txfm_sb = tmp_skip_sb;
+            skip_sse_sb = tmp_skip_sse;
+            best_in_temp = !best_in_temp;
+            if (best_in_temp) {
+              restore_dst_buf(xd, orig_dst, orig_dst_stride);
+            } else {
+              restore_dst_buf(xd, tmp_dst, tmp_dst_stride);
+            }
           }
         }
-        av1_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
-        model_rd_for_sb(cpi, bsize, x, xd, 0, MAX_MB_PLANE - 1, &rate_sum,
-                        &dist_sum, &tmp_skip_sb, &tmp_skip_sse);
-
-        rd = RDCOST(x->rdmult, x->rddiv, rate_sum, dist_sum);
-        if (cm->interp_filter == SWITCHABLE) rd += rs_rd;
-
-        if (i == 0 && intpel_mv && IsInterpolatingFilter(i)) {
-          tmp_rate_sum = rate_sum;
-          tmp_dist_sum = dist_sum;
+        if (best_in_temp) {
+          restore_dst_buf(xd, tmp_dst, tmp_dst_stride);
+        } else {
+          restore_dst_buf(xd, orig_dst, orig_dst_stride);
         }
-      }
-      newbest = i == 0 || rd < best_rd;
-
-      if (newbest) {
-        best_rd = rd;
 #if CONFIG_DUAL_FILTER
-        best_filter[0] = mbmi->interp_filter[0];
-        best_filter[1] = mbmi->interp_filter[1];
-        best_filter[2] = mbmi->interp_filter[2];
-        best_filter[3] = mbmi->interp_filter[3];
+        av1_copy(mbmi->interp_filter, best_filter);
 #else
-        best_filter = mbmi->interp_filter;
+        mbmi->interp_filter = best_filter;
 #endif
-        if (cm->interp_filter == SWITCHABLE && i &&
-            !(intpel_mv && IsInterpolatingFilter(i)))
-          best_needs_copy = !best_needs_copy;
-      }
-
-      if ((cm->interp_filter == SWITCHABLE && newbest) ||
-          (cm->interp_filter != SWITCHABLE &&
-#if CONFIG_DUAL_FILTER
-           cm->interp_filter == mbmi->interp_filter[0]
-#else
-           cm->interp_filter == mbmi->interp_filter
-#endif
-           )) {
-        pred_exists = 1;
-        tmp_rd = best_rd;
-
-        skip_txfm_sb = tmp_skip_sb;
-        skip_sse_sb = tmp_skip_sse;
       } else {
-        pred_exists = 0;
+#if !CONFIG_EXT_INTERP && !CONFIG_DUAL_FILTER
+        int tmp_rs;
+        InterpFilter best_filter = mbmi->interp_filter;
+        rs = av1_get_switchable_rate(cpi, xd);
+        for (i = 1; i < SWITCHABLE_FILTERS; ++i) {
+          mbmi->interp_filter = i;
+          tmp_rs = av1_get_switchable_rate(cpi, xd);
+          if (tmp_rs < rs) {
+            rs = tmp_rs;
+            best_filter = i;
+          }
+        }
+        mbmi->interp_filter = best_filter;
+#else
+        assert(0);
+#endif
       }
     }
-    restore_dst_buf(xd, orig_dst, orig_dst_stride);
   }
 
-// Set the appropriate filter
-#if CONFIG_DUAL_FILTER
-  mbmi->interp_filter[0] =
-      cm->interp_filter != SWITCHABLE ? cm->interp_filter : best_filter[0];
-  mbmi->interp_filter[1] =
-      cm->interp_filter != SWITCHABLE ? cm->interp_filter : best_filter[1];
-  if (mbmi->ref_frame[1] > INTRA_FRAME) {
-    mbmi->interp_filter[2] =
-        cm->interp_filter != SWITCHABLE ? cm->interp_filter : best_filter[2];
-    mbmi->interp_filter[3] =
-        cm->interp_filter != SWITCHABLE ? cm->interp_filter : best_filter[3];
-  }
-#else
-  mbmi->interp_filter =
-      cm->interp_filter != SWITCHABLE ? cm->interp_filter : best_filter;
-#endif
-  rs = cm->interp_filter == SWITCHABLE ? av1_get_switchable_rate(cpi, xd) : 0;
-
 #if CONFIG_EXT_INTER
 #if CONFIG_MOTION_VAR
   best_bmc_mbmi = *mbmi;
@@ -7432,29 +7408,15 @@
     pred_exists = 0;
   }
 #endif  // CONFIG_EXT_INTERP
-#endif  // CONFIG_EXT_INTER
-
-  if (pred_exists) {
-    if (best_needs_copy) {
-      // again temporarily set the buffers to local memory to prevent a memcpy
-      for (i = 0; i < MAX_MB_PLANE; i++) {
-        xd->plane[i].dst.buf = tmp_buf + i * MAX_SB_SQUARE;
-        xd->plane[i].dst.stride = MAX_SB_SIZE;
-      }
-    }
-    rd = tmp_rd;
-  } else {
+  if (pred_exists == 0) {
     int tmp_rate;
     int64_t tmp_dist;
-
-    // Handles the special case when a filter that is not in the
-    // switchable list (ex. bilinear) is indicated at the frame level, or
-    // skip condition holds.
     av1_build_inter_predictors_sb(xd, mi_row, mi_col, bsize);
     model_rd_for_sb(cpi, bsize, x, xd, 0, MAX_MB_PLANE - 1, &tmp_rate,
                     &tmp_dist, &skip_txfm_sb, &skip_sse_sb);
     rd = RDCOST(x->rdmult, x->rddiv, rs + tmp_rate, tmp_dist);
   }
+#endif  // CONFIG_EXT_INTER
 
 #if CONFIG_DUAL_FILTER
   if (!is_comp_pred) single_filter[this_mode][refs[0]] = mbmi->interp_filter[0];
@@ -8054,7 +8016,7 @@
     // (prediction granularity), so we account for it in the full rate,
     // not the tokenonly rate.
     rate_y -= cpi->tx_size_cost[max_tx_size - TX_8X8][get_tx_size_context(xd)]
-                               [mbmi->tx_size];
+                               [tx_size_to_depth(mbmi->tx_size)];
   }
 
   rate2 += av1_cost_bit(cm->fc->filter_intra_probs[0],
@@ -8811,8 +8773,9 @@
         // tokenonly rate, but for intra blocks, tx_size is always coded
         // (prediction granularity), so we account for it in the full rate,
         // not the tokenonly rate.
-        rate_y -= cpi->tx_size_cost[max_tx_size - TX_8X8]
-                                   [get_tx_size_context(xd)][mbmi->tx_size];
+        rate_y -=
+            cpi->tx_size_cost[max_tx_size - TX_8X8][get_tx_size_context(xd)]
+                             [tx_size_to_depth(mbmi->tx_size)];
       }
 #if CONFIG_EXT_INTRA
       if (is_directional_mode) {
diff --git a/av1/encoder/tokenize.c b/av1/encoder/tokenize.c
index 43ed837..47cc02a 100644
--- a/av1/encoder/tokenize.c
+++ b/av1/encoder/tokenize.c
@@ -375,7 +375,7 @@
 
 static INLINE int get_tx_eob(const struct segmentation *seg, int segment_id,
                              TX_SIZE tx_size) {
-  const int eob_max = num_4x4_blocks_txsize_lookup[tx_size] << 4;
+  const int eob_max = tx_size_2d[tx_size];
   return segfeature_active(seg, segment_id, SEG_LVL_SKIP) ? 0 : eob_max;
 }
 
@@ -574,15 +574,19 @@
   const int tx_col = blk_col >> (1 - pd->subsampling_x);
   TX_SIZE plane_tx_size;
 
-  int max_blocks_high = num_4x4_blocks_high_lookup[plane_bsize];
-  int max_blocks_wide = num_4x4_blocks_wide_lookup[plane_bsize];
+  int max_blocks_high = block_size_high[plane_bsize];
+  int max_blocks_wide = block_size_wide[plane_bsize];
 
   assert(tx_size < TX_SIZES);
 
   if (xd->mb_to_bottom_edge < 0)
-    max_blocks_high += xd->mb_to_bottom_edge >> (5 + pd->subsampling_y);
+    max_blocks_high += xd->mb_to_bottom_edge >> (3 + pd->subsampling_y);
   if (xd->mb_to_right_edge < 0)
-    max_blocks_wide += xd->mb_to_right_edge >> (5 + pd->subsampling_x);
+    max_blocks_wide += xd->mb_to_right_edge >> (3 + pd->subsampling_x);
+
+  // Scale to the transform block unit.
+  max_blocks_high >>= tx_size_wide_log2[0];
+  max_blocks_wide >>= tx_size_wide_log2[0];
 
   if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return;
 
@@ -600,20 +604,23 @@
     else if (dry_run == DRY_RUN_COSTCOEFFS)
       cost_coeffs_b(plane, block, blk_row, blk_col, plane_bsize, tx_size, arg);
   } else {
-    int bsl = b_width_log2_lookup[bsize];
+    // Half the block size in transform block unit.
+    int bsl = block_size_wide[bsize] >> (tx_size_wide_log2[0] + 1);
     int i;
 
     assert(bsl > 0);
-    --bsl;
 
     for (i = 0; i < 4; ++i) {
-      const int offsetr = blk_row + ((i >> 1) << bsl);
-      const int offsetc = blk_col + ((i & 0x01) << bsl);
-      int step = num_4x4_blocks_txsize_lookup[tx_size - 1];
+      const int offsetr = blk_row + ((i >> 1) * bsl);
+      const int offsetc = blk_col + ((i & 0x01) * bsl);
+
+      // TODO(jingning): Fix this tx_size transition.
+      const TX_SIZE sub_txs = tx_size - 1;
+      int step = tx_size_wide_unit[sub_txs] * tx_size_high_unit[sub_txs];
 
       if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue;
 
-      tokenize_vartx(td, t, dry_run, tx_size - 1, plane_bsize, offsetr, offsetc,
+      tokenize_vartx(td, t, dry_run, sub_txs, plane_bsize, offsetr, offsetc,
                      block + i * step, plane, arg);
     }
   }
@@ -649,16 +656,17 @@
   for (plane = 0; plane < MAX_MB_PLANE; ++plane) {
     const struct macroblockd_plane *const pd = &xd->plane[plane];
     const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-    const int mi_width = num_4x4_blocks_wide_lookup[plane_bsize];
-    const int mi_height = num_4x4_blocks_high_lookup[plane_bsize];
+    const int mi_width = block_size_wide[plane_bsize] >> tx_size_wide_log2[0];
+    const int mi_height = block_size_high[plane_bsize] >> tx_size_wide_log2[0];
     const TX_SIZE max_tx_size = max_txsize_lookup[plane_bsize];
     const BLOCK_SIZE txb_size = txsize_to_bsize[max_tx_size];
-    int bh = num_4x4_blocks_wide_lookup[txb_size];
+    int bw = block_size_wide[txb_size] >> tx_size_wide_log2[0];
+    int bh = block_size_high[txb_size] >> tx_size_wide_log2[0];
     int idx, idy;
     int block = 0;
-    int step = num_4x4_blocks_txsize_lookup[max_tx_size];
+    int step = tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size];
     for (idy = 0; idy < mi_height; idy += bh) {
-      for (idx = 0; idx < mi_width; idx += bh) {
+      for (idx = 0; idx < mi_width; idx += bw) {
         tokenize_vartx(td, t, dry_run, max_tx_size, plane_bsize, idy, idx,
                        block, plane, &arg);
         block += step;
diff --git a/test/dct32x32_test.cc b/test/dct32x32_test.cc
index e4179ef..cb2fbd5 100644
--- a/test/dct32x32_test.cc
+++ b/test/dct32x32_test.cc
@@ -436,6 +436,15 @@
                                  &aom_idct32x32_1024_add_sse2, 1, AOM_BITS_8)));
 #endif  // HAVE_AVX2 && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 
+#if HAVE_AVX2 && CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+INSTANTIATE_TEST_CASE_P(
+    AVX2, Trans32x32Test,
+    ::testing::Values(make_tuple(&aom_fdct32x32_avx2,
+                                 &aom_idct32x32_1024_add_sse2, 0, AOM_BITS_8),
+                      make_tuple(&aom_fdct32x32_rd_avx2,
+                                 &aom_idct32x32_1024_add_sse2, 1, AOM_BITS_8)));
+#endif  // HAVE_AVX2 && CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
+
 #if HAVE_MSA && !CONFIG_AOM_HIGHBITDEPTH && !CONFIG_EMULATE_HARDWARE
 INSTANTIATE_TEST_CASE_P(
     MSA, Trans32x32Test,
diff --git a/test/ethread_test.cc b/test/ethread_test.cc
index 6b2f1ea..c72f16d 100644
--- a/test/ethread_test.cc
+++ b/test/ethread_test.cc
@@ -89,6 +89,7 @@
         encoder->Control(AOME_SET_ARNR_MAXFRAMES, 7);
         encoder->Control(AOME_SET_ARNR_STRENGTH, 5);
         encoder->Control(AOME_SET_ARNR_TYPE, 3);
+        encoder->Control(AV1E_SET_FRAME_PARALLEL_DECODING, 0);
       } else {
         encoder->Control(AOME_SET_ENABLEAUTOALTREF, 0);
         encoder->Control(AV1E_SET_AQ_MODE, 3);
@@ -180,5 +181,5 @@
 AV1_INSTANTIATE_TEST_CASE(AVxEncoderThreadTestLarge,
                           ::testing::Values(::libaom_test::kTwoPassGood,
                                             ::libaom_test::kOnePassGood),
-                          ::testing::Range(1, 3));
+                          ::testing::Range(0, 3));
 }  // namespace
diff --git a/test/fht32x32_test.cc b/test/fht32x32_test.cc
index 1f85761..8545b2c 100644
--- a/test/fht32x32_test.cc
+++ b/test/fht32x32_test.cc
@@ -90,12 +90,11 @@
   IhtFunc inv_txfm_;
 };
 
-// TODO(luoyi): Owing to the range check in DCT_DCT of av1_fht32x32_avx2, as
-// input is out of the range, we use aom_fdct32x32_avx2. However this function
-// does not support CONFIG_AOM_HIGHBITDEPTH. I need to fix the scaling/rounding
-// of av1_fht32x32_avx2 then add this test on CONFIG_AOM_HIGHBITDEPTH.
-#if !CONFIG_AOM_HIGHBITDEPTH
 TEST_P(AV1Trans32x32HT, CoeffCheck) { RunCoeffCheck(); }
+// TODO(luoyi): As CONFIG_AOM_HIGHBITDEPTH = 1, our AVX2 implementation of
+// av1_fht32x32 does not support tran_low_t (int32_t) as intermediate result.
+// Therefore MemCheck test, tx_type=1,2,...,8 can't pass the test yet.
+#if !CONFIG_AOM_HIGHBITDEPTH
 TEST_P(AV1Trans32x32HT, MemCheck) { RunMemCheck(); }
 #endif