diff --git a/aom_dsp/aom_dsp.mk b/aom_dsp/aom_dsp.mk
index 0d0dc94..2adbef1 100644
--- a/aom_dsp/aom_dsp.mk
+++ b/aom_dsp/aom_dsp.mk
@@ -376,4 +376,6 @@
 DSP_SRCS-yes += aom_dsp_rtcd.c
 DSP_SRCS-yes += aom_dsp_rtcd_defs.pl
 
+DSP_SRCS-yes += aom_simd.c
+
 $(eval $(call rtcd_h_template,aom_dsp_rtcd,aom_dsp/aom_dsp_rtcd_defs.pl))
diff --git a/aom_dsp/aom_dsp_rtcd_defs.pl b/aom_dsp/aom_dsp_rtcd_defs.pl
index a2b9a75..ba4b40f 100644
--- a/aom_dsp/aom_dsp_rtcd_defs.pl
+++ b/aom_dsp/aom_dsp_rtcd_defs.pl
@@ -587,11 +587,19 @@
 specialize qw/aom_lpf_horizontal_4_dual sse2 neon dspr2 msa/;
 
 if (aom_config("CONFIG_CLPF") eq "yes") {
-  add_proto qw/void aom_clpf_block/, "const uint8_t *src, uint8_t *dst, int stride, int x0, int y0, int sizex, int sizey, int width, int height, unsigned int strength";
+  if (aom_config("CONFIG_AOM_HIGHBITDEPTH") eq "yes") {
+    add_proto qw/void aom_clpf_block_hbd/, "const uint16_t *src, uint16_t *dst, int sstride, int dstride, int x0, int y0, int sizex, int sizey, int width, int height, unsigned int strength";
+    specialize qw/aom_clpf_block_hbd sse2 ssse3 sse4_1 neon/;
+    add_proto qw/void aom_clpf_detect_hbd/, "const uint16_t *rec, const uint16_t *org, int rstride, int ostride, int x0, int y0, int width, int height, int *sum0, int *sum1, unsigned int strength, int shift, int size";
+    specialize qw/aom_clpf_detect_hbd sse2 ssse3 sse4_1 neon/;
+    add_proto qw/void aom_clpf_detect_multi_hbd/, "const uint16_t *rec, const uint16_t *org, int rstride, int ostride, int x0, int y0, int width, int height, int *sum, int shift, int size";
+    specialize qw/aom_clpf_detect_multi_hbd sse2 ssse3 sse4_1 neon/;
+  }
+  add_proto qw/void aom_clpf_block/, "const uint8_t *src, uint8_t *dst, int sstride, int dstride, int x0, int y0, int sizex, int sizey, int width, int height, unsigned int strength";
   specialize qw/aom_clpf_block sse2 ssse3 sse4_1 neon/;
-  add_proto qw/void aom_clpf_detect/, "const uint8_t *rec, const uint8_t *org, int rstride, int ostride, int x0, int y0, int width, int height, int *sum0, int *sum1, unsigned int strength";
+  add_proto qw/void aom_clpf_detect/, "const uint8_t *rec, const uint8_t *org, int rstride, int ostride, int x0, int y0, int width, int height, int *sum0, int *sum1, unsigned int strength, int size";
   specialize qw/aom_clpf_detect sse2 ssse3 sse4_1 neon/;
-  add_proto qw/void aom_clpf_detect_multi/, "const uint8_t *rec, const uint8_t *org, int rstride, int ostride, int x0, int y0, int width, int height, int *sum";
+  add_proto qw/void aom_clpf_detect_multi/, "const uint8_t *rec, const uint8_t *org, int rstride, int ostride, int x0, int y0, int width, int height, int *sum, int size";
   specialize qw/aom_clpf_detect_multi sse2 ssse3 sse4_1 neon/;
 }
 
diff --git a/aom_dsp/aom_simd.c b/aom_dsp/aom_simd.c
new file mode 100644
index 0000000..03f4ba9
--- /dev/null
+++ b/aom_dsp/aom_simd.c
@@ -0,0 +1,13 @@
+/*
+ * 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.
+ */
+
+// Set to 1 to add some sanity checks in the fallback C code
+const int simd_check = 1;
diff --git a/aom_dsp/bitreader.h b/aom_dsp/bitreader.h
index 611949a..d062e07 100644
--- a/aom_dsp/bitreader.h
+++ b/aom_dsp/bitreader.h
@@ -90,8 +90,8 @@
   return literal;
 }
 
-static INLINE int aom_read_tree(aom_reader *r, const aom_tree_index *tree,
-                                const aom_prob *probs) {
+static INLINE int aom_read_tree_bits(aom_reader *r, const aom_tree_index *tree,
+                                     const aom_prob *probs) {
   aom_tree_index i = 0;
 
   while ((i = tree[i + aom_read(r, probs[i >> 1])]) > 0) continue;
@@ -99,6 +99,11 @@
   return -i;
 }
 
+static INLINE int aom_read_tree(aom_reader *r, const aom_tree_index *tree,
+                                const aom_prob *probs) {
+  return aom_read_tree_bits(r, tree, probs);
+}
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif
diff --git a/aom_dsp/bitwriter.h b/aom_dsp/bitwriter.h
index d3e4ae9..5e34fd6 100644
--- a/aom_dsp/bitwriter.h
+++ b/aom_dsp/bitwriter.h
@@ -70,6 +70,22 @@
   for (bit = bits - 1; bit >= 0; bit--) aom_write_bit(w, 1 & (data >> bit));
 }
 
+static INLINE void aom_write_tree_bits(aom_writer *w, const aom_tree_index *tr,
+                                       const aom_prob *probs, int bits, int len,
+                                       aom_tree_index i) {
+  do {
+    const int bit = (bits >> --len) & 1;
+    aom_write(w, bit, probs[i >> 1]);
+    i = tr[i + bit];
+  } while (len);
+}
+
+static INLINE void aom_write_tree(aom_writer *w, const aom_tree_index *tree,
+                                  const aom_prob *probs, int bits, int len,
+                                  aom_tree_index i) {
+  aom_write_tree_bits(w, tree, probs, bits, len, i);
+}
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif
diff --git a/aom_dsp/simd/v128_intrinsics_arm.h b/aom_dsp/simd/v128_intrinsics_arm.h
index 13d1314..73549b8 100644
--- a/aom_dsp/simd/v128_intrinsics_arm.h
+++ b/aom_dsp/simd/v128_intrinsics_arm.h
@@ -28,7 +28,7 @@
 SIMD_INLINE v128 v128_from_v64(v64 a, v64 b) { return vcombine_s64(b, a); }
 
 SIMD_INLINE v128 v128_from_64(uint64_t a, uint64_t b) {
-  return vcombine_s64(b, a);
+  return vcombine_s64((uint64x1_t)b, (uint64x1_t)a);
 }
 
 SIMD_INLINE v128 v128_from_32(uint32_t a, uint32_t b, uint32_t c, uint32_t d) {
@@ -52,7 +52,9 @@
 }
 
 SIMD_INLINE v128 v128_align(v128 a, v128 b, const unsigned int c) {
-#if __OPTIMIZE__
+// The following functions require an immediate.
+// Some compilers will check this during optimisation, others wont.
+#if __OPTIMIZE__ && !__clang__
   return c ? vreinterpretq_s64_s8(
                  vextq_s8(vreinterpretq_s8_s64(b), vreinterpretq_s8_s64(a), c))
            : b;
@@ -122,7 +124,7 @@
 
 SIMD_INLINE ssd128_internal v128_ssd_u8_init() {
   ssd128_internal s;
-  s.hi = s.lo = 0;
+  s.hi = s.lo = (ssd64_internal)(uint64_t)0;
   return s;
 }
 
@@ -430,11 +432,11 @@
 
 SIMD_INLINE v128 v128_shuffle_8(v128 x, v128 pattern) {
   return v128_from_64(
-      vreinterpret_s64_u8(
+      (uint64_t)vreinterpret_s64_u8(
           vtbl2_u8((uint8x8x2_t){ { vget_low_u8(vreinterpretq_u8_s64(x)),
                                     vget_high_u8(vreinterpretq_u8_s64(x)) } },
                    vreinterpret_u8_s64(vget_high_s64(pattern)))),
-      vreinterpret_s64_u8(
+      (uint64_t)vreinterpret_s64_u8(
           vtbl2_u8((uint8x8x2_t){ { vget_low_u8(vreinterpretq_u8_s64(x)),
                                     vget_high_u8(vreinterpretq_u8_s64(x)) } },
                    vreinterpret_u8_s64(vget_low_s64(pattern)))));
@@ -521,21 +523,24 @@
                         vshlq_s32(vreinterpretq_s32_s64(a), vdupq_n_s32(-c)));
 }
 
-#if __OPTIMIZE__
+#if __OPTIMIZE__ && !__clang__
 
 SIMD_INLINE v128 v128_shl_n_byte(v128 a, const unsigned int n) {
   return n < 8
              ? v128_from_64(
-                   vorr_u64(vshl_n_u64(vreinterpret_u64_s64(vget_high_s64(a)),
-                                       n * 8),
-                            vshr_n_u64(vreinterpret_u64_s64(vget_low_s64(a)),
-                                       (8 - n) * 8)),
-                   vshl_n_u64(vreinterpret_u64_s64(vget_low_s64(a)), n * 8))
-             : (n == 8 ? v128_from_64(vreinterpret_u64_s64(vget_low_s64(a)), 0)
-                       : v128_from_64(
-                             vshl_n_u64(vreinterpret_u64_s64(vget_low_s64(a)),
-                                        (n - 8) * 8),
-                             0));
+                   (uint64_t)vorr_u64(
+                       vshl_n_u64(vreinterpret_u64_s64(vget_high_s64(a)),
+                                  n * 8),
+                       vshr_n_u64(vreinterpret_u64_s64(vget_low_s64(a)),
+                                  (8 - n) * 8)),
+                   (uint64_t)vshl_n_u64(vreinterpret_u64_s64(vget_low_s64(a)),
+                                        n * 8))
+             : (n == 8 ? v128_from_64(
+                             (uint64_t)vreinterpret_u64_s64(vget_low_s64(a)), 0)
+                       : v128_from_64((uint64_t)vshl_n_u64(
+                                          vreinterpret_u64_s64(vget_low_s64(a)),
+                                          (n - 8) * 8),
+                                      0));
 }
 
 SIMD_INLINE v128 v128_shr_n_byte(v128 a, const unsigned int n) {
diff --git a/aom_dsp/simd/v128_intrinsics_c.h b/aom_dsp/simd/v128_intrinsics_c.h
index 561ac86..34e312e 100644
--- a/aom_dsp/simd/v128_intrinsics_c.h
+++ b/aom_dsp/simd/v128_intrinsics_c.h
@@ -15,6 +15,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include "./v64_intrinsics_c.h"
+#include "./aom_config.h"
 
 typedef union {
   uint8_t u8[16];
@@ -406,11 +407,13 @@
 }
 
 SIMD_INLINE c_v128 c_v128_unziplo_8(c_v128 a, c_v128 b) {
-  return big_endian() ? _c_v128_unzip_8(a, b, 1) : _c_v128_unzip_8(a, b, 0);
+  return CONFIG_BIG_ENDIAN ? _c_v128_unzip_8(a, b, 1)
+                           : _c_v128_unzip_8(a, b, 0);
 }
 
 SIMD_INLINE c_v128 c_v128_unziphi_8(c_v128 a, c_v128 b) {
-  return big_endian() ? _c_v128_unzip_8(b, a, 0) : _c_v128_unzip_8(b, a, 1);
+  return CONFIG_BIG_ENDIAN ? _c_v128_unzip_8(b, a, 0)
+                           : _c_v128_unzip_8(b, a, 1);
 }
 
 SIMD_INLINE c_v128 _c_v128_unzip_16(c_v128 a, c_v128 b, int mode) {
@@ -438,11 +441,13 @@
 }
 
 SIMD_INLINE c_v128 c_v128_unziplo_16(c_v128 a, c_v128 b) {
-  return big_endian() ? _c_v128_unzip_16(a, b, 1) : _c_v128_unzip_16(a, b, 0);
+  return CONFIG_BIG_ENDIAN ? _c_v128_unzip_16(a, b, 1)
+                           : _c_v128_unzip_16(a, b, 0);
 }
 
 SIMD_INLINE c_v128 c_v128_unziphi_16(c_v128 a, c_v128 b) {
-  return big_endian() ? _c_v128_unzip_16(b, a, 0) : _c_v128_unzip_16(b, a, 1);
+  return CONFIG_BIG_ENDIAN ? _c_v128_unzip_16(b, a, 0)
+                           : _c_v128_unzip_16(b, a, 1);
 }
 
 SIMD_INLINE c_v128 _c_v128_unzip_32(c_v128 a, c_v128 b, int mode) {
@@ -462,11 +467,13 @@
 }
 
 SIMD_INLINE c_v128 c_v128_unziplo_32(c_v128 a, c_v128 b) {
-  return big_endian() ? _c_v128_unzip_32(a, b, 1) : _c_v128_unzip_32(a, b, 0);
+  return CONFIG_BIG_ENDIAN ? _c_v128_unzip_32(a, b, 1)
+                           : _c_v128_unzip_32(a, b, 0);
 }
 
 SIMD_INLINE c_v128 c_v128_unziphi_32(c_v128 a, c_v128 b) {
-  return big_endian() ? _c_v128_unzip_32(b, a, 0) : _c_v128_unzip_32(b, a, 1);
+  return CONFIG_BIG_ENDIAN ? _c_v128_unzip_32(b, a, 0)
+                           : _c_v128_unzip_32(b, a, 1);
 }
 
 SIMD_INLINE c_v128 c_v128_unpack_u8_s16(c_v64 a) {
@@ -535,8 +542,8 @@
               c);
       abort();
     }
-    t.u8[c] =
-        a.u8[big_endian() ? 15 - (pattern.u8[c] & 15) : pattern.u8[c] & 15];
+    t.u8[c] = a.u8[CONFIG_BIG_ENDIAN ? 15 - (pattern.u8[c] & 15)
+                                     : pattern.u8[c] & 15];
   }
   return t;
 }
diff --git a/aom_dsp/simd/v128_intrinsics_x86.h b/aom_dsp/simd/v128_intrinsics_x86.h
index e09cbb9..4504996 100644
--- a/aom_dsp/simd/v128_intrinsics_x86.h
+++ b/aom_dsp/simd/v128_intrinsics_x86.h
@@ -58,7 +58,9 @@
   _mm_storeu_si128((__m128i *)p, a);
 }
 
-#if defined(__OPTIMIZE__)
+// The following function requires an immediate.
+// Some compilers will check this during optimisation, others wont.
+#if __OPTIMIZE__ && !__clang__
 #if defined(__SSSE3__)
 SIMD_INLINE v128 v128_align(v128 a, v128 b, const unsigned int c) {
   return c ? _mm_alignr_epi8(a, b, c) : b;
@@ -418,26 +420,19 @@
 SIMD_INLINE v128 v128_cmpeq_16(v128 a, v128 b) { return _mm_cmpeq_epi16(a, b); }
 
 SIMD_INLINE v128 v128_shl_8(v128 a, unsigned int c) {
-  __m128i x = _mm_cvtsi32_si128(c);
-  return _mm_packus_epi16(
-      _mm_srli_epi16(
-          _mm_sll_epi16(_mm_unpacklo_epi8(_mm_setzero_si128(), a), x), 8),
-      _mm_srli_epi16(
-          _mm_sll_epi16(_mm_unpackhi_epi8(_mm_setzero_si128(), a), x), 8));
+  return _mm_and_si128(_mm_set1_epi8((uint8_t)(0xff << c)),
+                       _mm_sll_epi16(a, _mm_cvtsi32_si128(c)));
 }
 
 SIMD_INLINE v128 v128_shr_u8(v128 a, unsigned int c) {
-  __m128i x = _mm_cvtsi32_si128(c + 8);
-  return _mm_packus_epi16(
-      _mm_srl_epi16(_mm_unpacklo_epi8(_mm_setzero_si128(), a), x),
-      _mm_srl_epi16(_mm_unpackhi_epi8(_mm_setzero_si128(), a), x));
+  return _mm_and_si128(_mm_set1_epi8(0xff >> c),
+                       _mm_srl_epi16(a, _mm_cvtsi32_si128(c)));
 }
 
 SIMD_INLINE v128 v128_shr_s8(v128 a, unsigned int c) {
   __m128i x = _mm_cvtsi32_si128(c + 8);
-  return _mm_packs_epi16(
-      _mm_sra_epi16(_mm_unpacklo_epi8(_mm_setzero_si128(), a), x),
-      _mm_sra_epi16(_mm_unpackhi_epi8(_mm_setzero_si128(), a), x));
+  return _mm_packs_epi16(_mm_sra_epi16(_mm_unpacklo_epi8(a, a), x),
+                         _mm_sra_epi16(_mm_unpackhi_epi8(a, a), x));
 }
 
 SIMD_INLINE v128 v128_shl_16(v128 a, unsigned int c) {
@@ -468,20 +463,13 @@
    to enforce that. */
 #define v128_shl_n_byte(a, c) _mm_slli_si128(a, c)
 #define v128_shr_n_byte(a, c) _mm_srli_si128(a, c)
-#define v128_shl_n_8(a, c)                                                  \
-  _mm_packus_epi16(                                                         \
-      _mm_srli_epi16(                                                       \
-          _mm_slli_epi16(_mm_unpacklo_epi8(_mm_setzero_si128(), a), c), 8), \
-      _mm_srli_epi16(                                                       \
-          _mm_slli_epi16(_mm_unpackhi_epi8(_mm_setzero_si128(), a), c), 8))
-#define v128_shr_n_u8(a, c)                                             \
-  _mm_packus_epi16(                                                     \
-      _mm_srli_epi16(_mm_unpacklo_epi8(_mm_setzero_si128(), a), c + 8), \
-      _mm_srli_epi16(_mm_unpackhi_epi8(_mm_setzero_si128(), a), c + 8))
-#define v128_shr_n_s8(a, c)                                             \
-  _mm_packs_epi16(                                                      \
-      _mm_srai_epi16(_mm_unpacklo_epi8(_mm_setzero_si128(), a), c + 8), \
-      _mm_srai_epi16(_mm_unpackhi_epi8(_mm_setzero_si128(), a), c + 8))
+#define v128_shl_n_8(a, c) \
+  _mm_and_si128(_mm_set1_epi8((uint8_t)(0xff << (c))), _mm_slli_epi16(a, c))
+#define v128_shr_n_u8(a, c) \
+  _mm_and_si128(_mm_set1_epi8(0xff >> (c)), _mm_srli_epi16(a, c))
+#define v128_shr_n_s8(a, c)                                         \
+  _mm_packs_epi16(_mm_srai_epi16(_mm_unpacklo_epi8(a, a), (c) + 8), \
+                  _mm_srai_epi16(_mm_unpackhi_epi8(a, a), (c) + 8))
 #define v128_shl_n_16(a, c) _mm_slli_epi16(a, c)
 #define v128_shr_n_u16(a, c) _mm_srli_epi16(a, c)
 #define v128_shr_n_s16(a, c) _mm_srai_epi16(a, c)
diff --git a/aom_dsp/simd/v64_intrinsics_arm.h b/aom_dsp/simd/v64_intrinsics_arm.h
index b487303..bf92167 100644
--- a/aom_dsp/simd/v64_intrinsics_arm.h
+++ b/aom_dsp/simd/v64_intrinsics_arm.h
@@ -14,12 +14,10 @@
 
 #include <arm_neon.h>
 #include "./v64_intrinsics_arm.h"
+#include "aom_ports/arm.h"
 
-/* vzip in gcc is broken.  Fixed in 4.6.1? */
-#if __GNUC__ &&                                                       \
-    ((__GNUC__ << 16) + (__GNUC_MINOR__ << 8) + __GNUC_PATCHLEVEL__ < \
-     (4 << 16) + (6 << 8) + 1)
-#error vzip buggy in gcc.  Get at least gcc 4.6.1.
+#ifdef AOM_INCOMPATIBLE_GCC
+#error Incompatible gcc
 #endif
 
 typedef int64x1_t v64;
@@ -51,7 +49,7 @@
 
 SIMD_INLINE v64 v64_from_64(uint64_t x) { return vcreate_s64(x); }
 
-SIMD_INLINE uint64_t v64_u64(v64 x) { return x; }
+SIMD_INLINE uint64_t v64_u64(v64 x) { return (uint64_t)x; }
 
 SIMD_INLINE uint32_t u32_load_aligned(const void *p) {
   return *((uint32_t *)p);
@@ -66,12 +64,16 @@
 }
 
 SIMD_INLINE void u32_store_unaligned(void *p, uint32_t a) {
-#if __CC_ARM
+#if __clang__
+  vst1_lane_u32((uint32_t *)p, vreinterpret_u32_s64((uint64x1_t)(uint64_t)a),
+                0);
+#elif __CC_ARM
   *(__packed uint32_t *)p) = a;
 #elif __GNUC__
   *((__attribute((packed)) uint32_t *)p) = a;
 #else
-  vst1_lane_u32((uint32_t*)p, vreinterpret_u32_s64(a), 0);
+  vst1_lane_u32((uint32_t *)p, vreinterpret_u32_s64((uint64x1_t)(uint64_t)a),
+                0);
 #endif
 }
 
@@ -91,13 +93,16 @@
   vst1_u8((uint8_t *)p, vreinterpret_u8_s64(r));
 }
 
+// The following function requires an immediate.
+// Some compilers will check this if it's optimising, others wont.
 SIMD_INLINE v64 v64_align(v64 a, v64 b, const unsigned int c) {
-#if __OPTIMIZE__
+#if __OPTIMIZE__ && !__clang__
   return c ? vreinterpret_s64_s8(
                  vext_s8(vreinterpret_s8_s64(b), vreinterpret_s8_s64(a), c))
            : b;
 #else
-  return c ? v64_from_64(b >> c * 8) | (a << (8 - c) * 8) : b;
+  return c ? v64_from_64((uint64_t)b >> c * 8) | ((uint64_t)a << (8 - c) * 8)
+           : b;
 #endif
 }
 
@@ -121,21 +126,21 @@
   int64x2_t r = vpaddlq_s32(vpaddlq_s16(
       vmulq_s16(vmovl_s8(vreinterpret_s8_s64(x)),
                 vreinterpretq_s16_u16(vmovl_u8(vreinterpret_u8_s64(y))))));
-  return vadd_s64(vget_high_s64(r), vget_low_s64(r));
+  return (int64_t)vadd_s64(vget_high_s64(r), vget_low_s64(r));
 }
 
 SIMD_INLINE int64_t v64_dotp_s16(v64 x, v64 y) {
   int64x2_t r =
       vpaddlq_s32(vmull_s16(vreinterpret_s16_s64(x), vreinterpret_s16_s64(y)));
-  return vget_high_s64(r) + vget_low_s64(r);
+  return (int64_t)(vget_high_s64(r) + vget_low_s64(r));
 }
 
 SIMD_INLINE uint64_t v64_hadd_u8(v64 x) {
-  return vpaddl_u32(vpaddl_u16(vpaddl_u8(vreinterpret_u8_s64(x))));
+  return (uint64_t)vpaddl_u32(vpaddl_u16(vpaddl_u8(vreinterpret_u8_s64(x))));
 }
 
 SIMD_INLINE int64_t v64_hadd_s16(v64 a) {
-  return vpaddl_s32(vpaddl_s16(vreinterpret_s16_s64(a)));
+  return (int64_t)vpaddl_s32(vpaddl_s16(vreinterpret_s16_s64(a)));
 }
 
 typedef uint16x8_t sad64_internal;
@@ -151,12 +156,14 @@
 
 SIMD_INLINE uint32_t v64_sad_u8_sum(sad64_internal s) {
   uint64x2_t r = vpaddlq_u32(vpaddlq_u16(s));
-  return (uint32_t)(vget_high_u64(r) + vget_low_u64(r));
+  return (uint32_t)(uint64_t)(vget_high_u64(r) + vget_low_u64(r));
 }
 
 typedef int64x1_t ssd64_internal;
 
-SIMD_INLINE ssd64_internal v64_ssd_u8_init() { return 0; }
+SIMD_INLINE ssd64_internal v64_ssd_u8_init() {
+  return (ssd64_internal)(uint64_t)0;
+}
 
 /* Implementation dependent return value.  Result must be finalised with
  * v64_ssd_u8_sum(). */
@@ -166,7 +173,9 @@
   return vadd_u64(s, vadd_u64(vget_high_u64(r), vget_low_u64(r)));
 }
 
-SIMD_INLINE uint32_t v64_ssd_u8_sum(ssd64_internal s) { return (uint32_t)s; }
+SIMD_INLINE uint32_t v64_ssd_u8_sum(ssd64_internal s) {
+  return (uint32_t)(uint64_t)s;
+}
 
 SIMD_INLINE v64 v64_or(v64 x, v64 y) { return vorr_s64(x, y); }
 
@@ -470,7 +479,9 @@
       vshl_s32(vreinterpret_s32_s64(a), vdup_n_s32(-(int)c)));
 }
 
-#if __OPTIMIZE__
+// The following functions require an immediate.
+// Some compilers will check this during optimisation, others wont.
+#if __OPTIMIZE__ && !__clang__
 
 SIMD_INLINE v64 v64_shl_n_byte(v64 a, const unsigned int c) {
   return vshl_n_s64(a, c * 8);
diff --git a/aom_dsp/simd/v64_intrinsics_x86.h b/aom_dsp/simd/v64_intrinsics_x86.h
index 502df23..b951492 100644
--- a/aom_dsp/simd/v64_intrinsics_x86.h
+++ b/aom_dsp/simd/v64_intrinsics_x86.h
@@ -86,9 +86,10 @@
   _mm_storel_epi64((__m128i *)p, a);
 }
 
+// The following function requires an immediate.
 #if __OPTIMIZE__
 #define v64_align(a, b, c) \
-  (c) ? _mm_srli_si128(_mm_unpacklo_epi64(b, a), (c)) : b;
+  ((c) ? _mm_srli_si128(_mm_unpacklo_epi64(b, a), (c)) : b)
 #else
 #define v64_align(a, b, c)                                                  \
   ((c) ? v64_from_64((v64_u64(b) >> (c)*8) | (v64_u64(a) << (8 - (c)) * 8)) \
@@ -388,25 +389,18 @@
 SIMD_INLINE v64 v64_cmpeq_16(v64 a, v64 b) { return _mm_cmpeq_epi16(a, b); }
 
 SIMD_INLINE v64 v64_shl_8(v64 a, unsigned int c) {
-  return _mm_packus_epi16(
-      _mm_srli_epi16(_mm_sll_epi16(_mm_unpacklo_epi8(_mm_setzero_si128(), a),
-                                   _mm_cvtsi32_si128(c)),
-                     8),
-      _mm_setzero_si128());
+  return _mm_and_si128(_mm_set1_epi8((uint8_t)(0xff << c)),
+                       _mm_sll_epi16(a, _mm_cvtsi32_si128(c)));
 }
 
 SIMD_INLINE v64 v64_shr_u8(v64 a, unsigned int c) {
-  __m128i cp8 = _mm_cvtsi32_si128(c + 8);
-  return _mm_packus_epi16(
-      _mm_srl_epi16(_mm_unpacklo_epi8(_mm_setzero_si128(), a), cp8),
-      _mm_setzero_si128());
+  return _mm_and_si128(_mm_set1_epi8(0xff >> c),
+                       _mm_srl_epi16(a, _mm_cvtsi32_si128(c)));
 }
 
 SIMD_INLINE v64 v64_shr_s8(v64 a, unsigned int c) {
-  __m128i cp8 = _mm_cvtsi32_si128(c + 8);
   return _mm_packs_epi16(
-      _mm_sra_epi16(_mm_unpacklo_epi8(_mm_setzero_si128(), a), cp8),
-      _mm_setzero_si128());
+      _mm_sra_epi16(_mm_unpacklo_epi8(a, a), _mm_cvtsi32_si128(c + 8)), a);
 }
 
 SIMD_INLINE v64 v64_shl_16(v64 a, unsigned int c) {
@@ -437,19 +431,12 @@
    to enforce that. */
 #define v64_shl_n_byte(a, c) _mm_slli_si128(a, c)
 #define v64_shr_n_byte(a, c) _mm_srli_si128(_mm_unpacklo_epi64(a, a), c + 8)
-#define v64_shl_n_8(a, c)                                                  \
-  _mm_packus_epi16(                                                        \
-      _mm_srli_epi16(                                                      \
-          _mm_sll_epi16(_mm_unpacklo_epi8(_mm_setzero_si128(), a), c), 8), \
-      _mm_setzero_si128())
-#define v64_shr_n_u8(a, c)                                               \
-  _mm_packus_epi16(                                                      \
-      _mm_srl_epi16(_mm_unpacklo_epi8(_mm_setzero_si128(), a), (c) + 8), \
-      _mm_setzero_si128())
-#define v64_shr_n_s8(a, c)                                               \
-  _mm_packs_epi16(                                                       \
-      _mm_sra_epi16(_mm_unpacklo_epi8(_mm_setzero_si128(), a), (c) + 8), \
-      _mm_setzero_si128())
+#define v64_shl_n_8(a, c) \
+  _mm_and_si128(_mm_set1_epi8((uint8_t)(0xff << (c))), _mm_slli_epi16(a, c))
+#define v64_shr_n_u8(a, c) \
+  _mm_and_si128(_mm_set1_epi8(0xff >> (c)), _mm_srli_epi16(a, c))
+#define v64_shr_n_s8(a, c) \
+  _mm_packs_epi16(_mm_srai_epi16(_mm_unpacklo_epi8(a, a), (c) + 8), a)
 #define v64_shl_n_16(a, c) _mm_slli_epi16(a, c)
 #define v64_shr_n_u16(a, c) _mm_srli_epi16(a, c)
 #define v64_shr_n_s16(a, c) _mm_srai_epi16(a, c)
diff --git a/aom_util/aom_util.mk b/aom_util/aom_util.mk
index fcf0d70..14b484a 100644
--- a/aom_util/aom_util.mk
+++ b/aom_util/aom_util.mk
@@ -9,6 +9,7 @@
 ## PATENTS file, you can obtain it at www.aomedia.org/license/patent.
 ##
 
+
 UTIL_SRCS-yes += aom_util.mk
 UTIL_SRCS-yes += aom_thread.c
 UTIL_SRCS-yes += aom_thread.h
diff --git a/aom_util/debug_util.c b/aom_util/debug_util.c
index 0385df7..52389d0 100644
--- a/aom_util/debug_util.c
+++ b/aom_util/debug_util.c
@@ -1,17 +1,17 @@
 /*
- *  Copyright (c) 2016 The WebM project authors. All Rights Reserved.
+ * Copyright (c) 2016, Alliance for Open Media. All rights reserved
  *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
+ * 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 <stdio.h>
 #include "aom_util/debug_util.h"
-
 #define QUEUE_MAX_SIZE 2000000
 static int result_queue[QUEUE_MAX_SIZE];
 static int prob_queue[QUEUE_MAX_SIZE];
diff --git a/aom_util/debug_util.h b/aom_util/debug_util.h
index 7c2299a..c52e385 100644
--- a/aom_util/debug_util.h
+++ b/aom_util/debug_util.h
@@ -1,11 +1,12 @@
 /*
- *  Copyright (c) 2016 The WebM project authors. All Rights Reserved.
+ * Copyright (c) 2016, Alliance for Open Media. All rights reserved
  *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
+ * 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_UTIL_DEBUG_UTIL_H_
diff --git a/av1/common/clpf.c b/av1/common/clpf.c
index 668c75f..1cf5272 100644
--- a/av1/common/clpf.c
+++ b/av1/common/clpf.c
@@ -8,8 +8,10 @@
  * 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 "av1/common/clpf.h"
 #include "./aom_dsp_rtcd.h"
+#include "aom/aom_image.h"
 #include "aom_dsp/aom_dsp_common.h"
 
 int av1_clpf_maxbits(const AV1_COMMON *cm) {
@@ -27,58 +29,113 @@
   return (8 + delta - (delta < 0)) >> 4;
 }
 
-void aom_clpf_block_c(const uint8_t *src, uint8_t *dst, int stride, int x0,
-                      int y0, int sizex, int sizey, int width, int height,
-                      unsigned int strength) {
+void aom_clpf_block_c(const uint8_t *src, uint8_t *dst, int sstride,
+                      int dstride, int x0, int y0, int sizex, int sizey,
+                      int width, int height, unsigned int strength) {
   int x, y;
   for (y = y0; y < y0 + sizey; y++) {
     for (x = x0; x < x0 + sizex; x++) {
-      int X = src[y * stride + x];
-      int A = src[AOMMAX(0, y - 1) * stride + x];
-      int B = src[y * stride + AOMMAX(0, x - 2)];
-      int C = src[y * stride + AOMMAX(0, x - 1)];
-      int D = src[y * stride + AOMMIN(width - 1, x + 1)];
-      int E = src[y * stride + AOMMIN(width - 1, x + 2)];
-      int F = src[AOMMIN(height - 1, y + 1) * stride + x];
+      int X = src[y * sstride + x];
+      int A = src[AOMMAX(0, y - 1) * sstride + x];
+      int B = src[y * sstride + AOMMAX(0, x - 2)];
+      int C = src[y * sstride + AOMMAX(0, x - 1)];
+      int D = src[y * sstride + AOMMIN(width - 1, x + 1)];
+      int E = src[y * sstride + AOMMIN(width - 1, x + 2)];
+      int F = src[AOMMIN(height - 1, y + 1) * sstride + x];
       int delta;
       delta = av1_clpf_sample(X, A, B, C, D, E, F, strength);
-      dst[y * stride + x] = X + delta;
+      dst[y * dstride + x] = X + delta;
     }
   }
 }
 
+#if CONFIG_AOM_HIGHBITDEPTH
+// Identical to aom_clpf_block_c() apart from "src" and "dst".
+void aom_clpf_block_hbd_c(const uint16_t *src, uint16_t *dst, int sstride,
+                          int dstride, int x0, int y0, int sizex, int sizey,
+                          int width, int height, unsigned int strength) {
+  int x, y;
+  for (y = y0; y < y0 + sizey; y++) {
+    for (x = x0; x < x0 + sizex; x++) {
+      int X = src[y * sstride + x];
+      int A = src[AOMMAX(0, y - 1) * sstride + x];
+      int B = src[y * sstride + AOMMAX(0, x - 2)];
+      int C = src[y * sstride + AOMMAX(0, x - 1)];
+      int D = src[y * sstride + AOMMIN(width - 1, x + 1)];
+      int E = src[y * sstride + AOMMIN(width - 1, x + 2)];
+      int F = src[AOMMIN(height - 1, y + 1) * sstride + x];
+      int delta;
+      delta = av1_clpf_sample(X, A, B, C, D, E, F, strength);
+      dst[y * dstride + x] = X + delta;
+    }
+  }
+}
+#endif
+
 // Return number of filtered blocks
-int av1_clpf_frame(const YV12_BUFFER_CONFIG *dst, const YV12_BUFFER_CONFIG *rec,
-                   const YV12_BUFFER_CONFIG *org, const AV1_COMMON *cm,
+int av1_clpf_frame(const YV12_BUFFER_CONFIG *frame,
+                   const YV12_BUFFER_CONFIG *org, AV1_COMMON *cm,
                    int enable_fb_flag, unsigned int strength,
-                   unsigned int fb_size_log2, uint8_t *blocks,
+                   unsigned int fb_size_log2, uint8_t *blocks, int plane,
                    int (*decision)(int, int, const YV12_BUFFER_CONFIG *,
                                    const YV12_BUFFER_CONFIG *,
                                    const AV1_COMMON *cm, int, int, int,
                                    unsigned int, unsigned int, uint8_t *)) {
   /* Constrained low-pass filter (CLPF) */
   int c, k, l, m, n;
-  const int bs = MI_SIZE;
-  int width = cm->mi_cols * bs;
-  int height = cm->mi_rows * bs;
+  const int subx = plane != AOM_PLANE_Y && frame->subsampling_x;
+  const int suby = plane != AOM_PLANE_Y && frame->subsampling_y;
+  const int bs = (subx || suby) ? 4 : 8;
+  const int bslog = get_msb(bs);
+  int width = plane != AOM_PLANE_Y ? frame->uv_crop_width : frame->y_crop_width;
+  int height =
+      plane != AOM_PLANE_Y ? frame->uv_crop_height : frame->y_crop_height;
   int xpos, ypos;
-  int stride_y = rec->y_stride;
-  int num_fb_hor = (width + (1 << fb_size_log2) - bs) >> fb_size_log2;
-  int num_fb_ver = (height + (1 << fb_size_log2) - bs) >> fb_size_log2;
+  const int sstride = plane != AOM_PLANE_Y ? frame->uv_stride : frame->y_stride;
+  int dstride = bs;
+  const int num_fb_hor = (width + (1 << fb_size_log2) - 1) >> fb_size_log2;
+  const int num_fb_ver = (height + (1 << fb_size_log2) - 1) >> fb_size_log2;
   int block_index = 0;
+  uint8_t *cache = NULL;
+  uint8_t **cache_ptr = NULL;
+  uint8_t **cache_dst = NULL;
+  int cache_idx = 0;
+  const int cache_size = num_fb_hor << (2 * fb_size_log2);
+  const int cache_blocks = cache_size / (bs * bs);
+  uint8_t *src_buffer =
+      plane != AOM_PLANE_Y
+          ? (plane == AOM_PLANE_U ? frame->u_buffer : frame->v_buffer)
+          : frame->y_buffer;
+  uint8_t *dst_buffer;
+
+// Make buffer space for in-place filtering
+#if CONFIG_AOM_HIGHBITDEPTH
+  strength <<= (cm->bit_depth - 8);
+  CHECK_MEM_ERROR(cm, cache, aom_malloc(cache_size << !!cm->use_highbitdepth));
+  dst_buffer = cm->use_highbitdepth ? CONVERT_TO_BYTEPTR(cache) : cache;
+#else
+  CHECK_MEM_ERROR(cm, cache, aom_malloc(cache_size));
+  dst_buffer = cache;
+#endif
+  CHECK_MEM_ERROR(cm, cache_ptr, aom_malloc(cache_blocks * sizeof(*cache_ptr)));
+  CHECK_MEM_ERROR(cm, cache_dst, aom_malloc(cache_blocks * sizeof(*cache_dst)));
+  memset(cache_ptr, 0, cache_blocks * sizeof(*cache_dst));
 
   // Iterate over all filter blocks
   for (k = 0; k < num_fb_ver; k++) {
     for (l = 0; l < num_fb_hor; l++) {
       int h, w;
       int allskip = 1;
+      const int xoff = l << fb_size_log2;
+      const int yoff = k << fb_size_log2;
       for (m = 0; allskip && m < (1 << fb_size_log2) / bs; m++) {
         for (n = 0; allskip && n < (1 << fb_size_log2) / bs; n++) {
-          xpos = (l << fb_size_log2) + n * bs;
-          ypos = (k << fb_size_log2) + m * bs;
+          xpos = xoff + n * bs;
+          ypos = yoff + m * bs;
           if (xpos < width && ypos < height) {
             allskip &=
-                cm->mi_grid_visible[ypos / bs * cm->mi_stride + xpos / bs]
+                cm->mi_grid_visible[(ypos << suby) / MI_SIZE * cm->mi_stride +
+                                    (xpos << subx) / MI_SIZE]
                     ->mbmi.skip;
           }
         }
@@ -91,36 +148,145 @@
       w += !w << fb_size_log2;
       if (!allskip &&  // Do not filter the block if all is skip encoded
           (!enable_fb_flag ||
-           decision(k, l, rec, org, cm, bs, w / bs, h / bs, strength,
+           decision(k, l, frame, org, cm, bs, w / bs, h / bs, strength,
                     fb_size_log2, blocks + block_index))) {
         // Iterate over all smaller blocks inside the filter block
-        for (m = 0; m < (h + bs - 1) / bs; m++) {
-          for (n = 0; n < (w + bs - 1) / bs; n++) {
-            xpos = (l << fb_size_log2) + n * bs;
-            ypos = (k << fb_size_log2) + m * bs;
-            if (!cm->mi_grid_visible[ypos / bs * cm->mi_stride + xpos / bs]
-                     ->mbmi.skip) {
-              // Not skip block, apply the filter
-              aom_clpf_block(rec->y_buffer, dst->y_buffer, stride_y, xpos, ypos,
-                             bs, bs, width, height, strength);
-            } else {  // Skip block, copy instead
-              for (c = 0; c < bs; c++)
-                *(uint64_t *)(dst->y_buffer + (ypos + c) * stride_y + xpos) =
-                    *(uint64_t *)(rec->y_buffer + (ypos + c) * stride_y + xpos);
+        for (m = 0; m < ((h + bs - 1) >> bslog); m++) {
+          for (n = 0; n < ((w + bs - 1) >> bslog); n++) {
+            int sizex, sizey;
+            xpos = xoff + n * bs;
+            ypos = yoff + m * bs;
+            sizex = AOMMIN(width - xpos, bs);
+            sizey = AOMMIN(height - ypos, bs);
+            if (!cm->mi_grid_visible[(ypos << suby) / MI_SIZE * cm->mi_stride +
+                                     (xpos << subx) / MI_SIZE]
+                     ->mbmi.skip) {  // Not skip block
+              // Temporary buffering needed if filtering in-place
+              if (cache_ptr[cache_idx]) {
+// Copy filtered block back into the frame
+#if CONFIG_AOM_HIGHBITDEPTH
+                if (cm->use_highbitdepth) {
+                  uint16_t *const d = CONVERT_TO_SHORTPTR(cache_dst[cache_idx]);
+                  if (sizex == 8) {
+                    for (c = 0; c < sizey; c++) {
+                      *(uint64_t *)(d + c * sstride) =
+                          *(uint64_t *)(cache_ptr[cache_idx] + c * bs * 2);
+                      *(uint64_t *)(d + c * sstride + 4) =
+                          *(uint64_t *)(cache_ptr[cache_idx] + c * bs * 2 + 8);
+                    }
+                  } else if (sizex == 4) {
+                    for (c = 0; c < sizey; c++)
+                      *(uint64_t *)(d + c * sstride) =
+                          *(uint64_t *)(cache_ptr[cache_idx] + c * bs * 2);
+                  } else {
+                    for (c = 0; c < sizey; c++)
+                      memcpy(d + c * sstride, cache_ptr[cache_idx] + c * bs * 2,
+                             sizex);
+                  }
+                } else {
+                  if (sizex == 8)
+                    for (c = 0; c < sizey; c++)
+                      *(uint64_t *)(cache_dst[cache_idx] + c * sstride) =
+                          *(uint64_t *)(cache_ptr[cache_idx] + c * bs);
+                  else if (sizex == 4)
+                    for (c = 0; c < sizey; c++)
+                      *(uint32_t *)(cache_dst[cache_idx] + c * sstride) =
+                          *(uint32_t *)(cache_ptr[cache_idx] + c * bs);
+                  else
+                    for (c = 0; c < sizey; c++)
+                      memcpy(cache_dst[cache_idx] + c * sstride,
+                             cache_ptr[cache_idx] + c * bs, sizex);
+                }
+#else
+                if (sizex == 8)
+                  for (c = 0; c < sizey; c++)
+                    *(uint64_t *)(cache_dst[cache_idx] + c * sstride) =
+                        *(uint64_t *)(cache_ptr[cache_idx] + c * bs);
+                else if (sizex == 4)
+                  for (c = 0; c < sizey; c++)
+                    *(uint32_t *)(cache_dst[cache_idx] + c * sstride) =
+                        *(uint32_t *)(cache_ptr[cache_idx] + c * bs);
+                else
+                  for (c = 0; c < sizey; c++)
+                    memcpy(cache_dst[cache_idx] + c * sstride,
+                           cache_ptr[cache_idx] + c * bs, sizex);
+#endif
+              }
+#if CONFIG_AOM_HIGHBITDEPTH
+              if (cm->use_highbitdepth) {
+                cache_ptr[cache_idx] = cache + cache_idx * bs * bs * 2;
+                dst_buffer =
+                    CONVERT_TO_BYTEPTR(cache_ptr[cache_idx]) - ypos * bs - xpos;
+              } else {
+                cache_ptr[cache_idx] = cache + cache_idx * bs * bs;
+                dst_buffer = cache_ptr[cache_idx] - ypos * bs - xpos;
+              }
+#else
+              cache_ptr[cache_idx] = cache + cache_idx * bs * bs;
+              dst_buffer = cache_ptr[cache_idx] - ypos * bs - xpos;
+#endif
+              cache_dst[cache_idx] = src_buffer + ypos * sstride + xpos;
+              if (++cache_idx >= cache_blocks) cache_idx = 0;
+
+// Apply the filter
+#if CONFIG_AOM_HIGHBITDEPTH
+              if (cm->use_highbitdepth) {
+                aom_clpf_block_hbd(CONVERT_TO_SHORTPTR(src_buffer),
+                                   CONVERT_TO_SHORTPTR(dst_buffer), sstride,
+                                   dstride, xpos, ypos, sizex, sizey, width,
+                                   height, strength);
+              } else {
+                aom_clpf_block(src_buffer, dst_buffer, sstride, dstride, xpos,
+                               ypos, sizex, sizey, width, height, strength);
+              }
+#else
+              aom_clpf_block(src_buffer, dst_buffer, sstride, dstride, xpos,
+                             ypos, sizex, sizey, width, height, strength);
+#endif
             }
           }
         }
-      } else {  // Entire filter block is skip, copy
-        for (m = 0; m < h; m++)
-          memcpy(dst->y_buffer + ((k << fb_size_log2) + m) * stride_y +
-                     (l << fb_size_log2),
-                 rec->y_buffer + ((k << fb_size_log2) + m) * stride_y +
-                     (l << fb_size_log2),
-                 w);
       }
       block_index += !allskip;  // Count number of blocks filtered
     }
   }
 
+  // Copy remaining blocks into the frame
+  for (cache_idx = 0; cache_idx < cache_blocks && cache_ptr[cache_idx];
+       cache_idx++) {
+#if CONFIG_AOM_HIGHBITDEPTH
+    if (cm->use_highbitdepth) {
+      uint16_t *const d = CONVERT_TO_SHORTPTR(cache_dst[cache_idx]);
+      for (c = 0; c < bs; c++) {
+        *(uint64_t *)(d + c * sstride) =
+            *(uint64_t *)(cache_ptr[cache_idx] + c * bs * 2);
+        if (bs == 8)
+          *(uint64_t *)(d + c * sstride + 4) =
+              *(uint64_t *)(cache_ptr[cache_idx] + c * bs * 2 + 8);
+      }
+    } else {
+      for (c = 0; c < bs; c++)
+        if (bs == 4)
+          *(uint32_t *)(cache_dst[cache_idx] + c * sstride) =
+              *(uint32_t *)(cache_ptr[cache_idx] + c * bs);
+        else
+          *(uint64_t *)(cache_dst[cache_idx] + c * sstride) =
+              *(uint64_t *)(cache_ptr[cache_idx] + c * bs);
+    }
+#else
+    for (c = 0; c < bs; c++)
+      if (bs == 4)
+        *(uint32_t *)(cache_dst[cache_idx] + c * sstride) =
+            *(uint32_t *)(cache_ptr[cache_idx] + c * bs);
+      else
+        *(uint64_t *)(cache_dst[cache_idx] + c * sstride) =
+            *(uint64_t *)(cache_ptr[cache_idx] + c * bs);
+#endif
+  }
+
+  aom_free(cache);
+  aom_free(cache_ptr);
+  aom_free(cache_dst);
+
   return block_index;
 }
diff --git a/av1/common/clpf.h b/av1/common/clpf.h
index 21671a1..8e4213b 100644
--- a/av1/common/clpf.h
+++ b/av1/common/clpf.h
@@ -17,10 +17,10 @@
 
 int av1_clpf_maxbits(const AV1_COMMON *cm);
 int av1_clpf_sample(int X, int A, int B, int C, int D, int E, int F, int b);
-int av1_clpf_frame(const YV12_BUFFER_CONFIG *dst, const YV12_BUFFER_CONFIG *rec,
-                   const YV12_BUFFER_CONFIG *org, const AV1_COMMON *cm,
+int av1_clpf_frame(const YV12_BUFFER_CONFIG *frame,
+                   const YV12_BUFFER_CONFIG *org, AV1_COMMON *cm,
                    int enable_fb_flag, unsigned int strength,
-                   unsigned int fb_size_log2, uint8_t *blocks,
+                   unsigned int fb_size_log2, uint8_t *blocks, int plane,
                    int (*decision)(int, int, const YV12_BUFFER_CONFIG *,
                                    const YV12_BUFFER_CONFIG *,
                                    const AV1_COMMON *cm, int, int, int,
diff --git a/av1/common/clpf_simd.h b/av1/common/clpf_simd.h
index faaf8ea..6fef4b7 100644
--- a/av1/common/clpf_simd.h
+++ b/av1/common/clpf_simd.h
@@ -10,187 +10,350 @@
  */
 
 #include "./aom_dsp_rtcd.h"
+#include "aom_ports/mem.h"
 
-static void clpf_block(const uint8_t *src, uint8_t *dst, int stride, int x0,
-                       int y0, int sizey, int width, int height,
-                       unsigned int strength) {
-  dst += x0 + y0 * stride;
-  src += x0 + y0 * stride;
-  {
-    int bottom = height - 2 - y0;
-    const v128 sp = v128_dup_8(strength);
-    const v128 sm = v128_dup_8(-(int)strength);
-    const v128 c8 = v128_dup_8(8);
-    const v128 c128 = v128_dup_8(128);
+// delta = 4/16 * clamp(a - o, -s, s) + 1/16 * clamp(b - o, -s, s) +
+//         3/16 * clamp(c - o, -s, s) + 3/16 * clamp(d - o, -s, s) +
+//         1/16 * clamp(e - o, -s, s) + 4/16 * clamp(f - o, -s, s)
+SIMD_INLINE v128 calc_delta(v128 o, v128 a, v128 b, v128 c, v128 d, v128 e,
+                            v128 f, v128 sp, v128 sm) {
+  // The difference will be 9 bit, offset by 128 so we can use saturated
+  // sub to avoid going to 16 bit temporarily before "strength" clipping.
+  const v128 c128 = v128_dup_8(128);
+  const v128 x = v128_add_8(c128, o);
+  const v128 c8 = v128_dup_8(8);
+  const v128 tmp = v128_add_8(
+      v128_max_s8(v128_min_s8(v128_ssub_s8(v128_add_8(c128, c), x), sp), sm),
+      v128_max_s8(v128_min_s8(v128_ssub_s8(v128_add_8(c128, d), x), sp), sm));
+  const v128 delta = v128_add_8(
+      v128_add_8(
+          v128_shl_8(
+              v128_add_8(
+                  v128_max_s8(
+                      v128_min_s8(v128_ssub_s8(v128_add_8(c128, a), x), sp),
+                      sm),
+                  v128_max_s8(
+                      v128_min_s8(v128_ssub_s8(v128_add_8(c128, f), x), sp),
+                      sm)),
+              2),
+          v128_add_8(
+              v128_max_s8(v128_min_s8(v128_ssub_s8(v128_add_8(c128, b), x), sp),
+                          sm),
+              v128_max_s8(v128_min_s8(v128_ssub_s8(v128_add_8(c128, e), x), sp),
+                          sm))),
+      v128_add_8(v128_add_8(tmp, tmp), tmp));
+  return v128_add_8(
+      o,
+      v128_shr_s8(
+          v128_add_8(c8, v128_add_8(delta, v128_cmplt_s8(delta, v128_zero()))),
+          4));
+}
 
-    if (!x0) {  // Clip left
-      const v128 b_shuff = v128_from_v64(v64_from_64(0x0d0c0b0a09080808LL),
-                                         v64_from_64(0x0504030201000000LL));
-      const v128 c_shuff = v128_from_v64(v64_from_64(0x0e0d0c0b0a090808LL),
-                                         v64_from_64(0x0605040302010000LL));
-      int y;
+// Process blocks of width 8, two lines at a time, 8 bit.
+static void clpf_block8(const uint8_t *src, uint8_t *dst, int sstride,
+                        int dstride, int x0, int y0, int sizey, int width,
+                        int height, unsigned int strength) {
+  const int bottom = height - 2 - y0;
+  const int right = width - 8 - x0;
+  const v128 sp = v128_dup_8(strength);
+  const v128 sm = v128_dup_8(-(int)strength);
+  DECLARE_ALIGNED(16, static const uint64_t,
+                  b_shuff[]) = { 0x0504030201000000LL, 0x0d0c0b0a09080808LL };
+  DECLARE_ALIGNED(16, static const uint64_t,
+                  c_shuff[]) = { 0x0605040302010000LL, 0x0e0d0c0b0a090808LL };
+  DECLARE_ALIGNED(16, static const uint64_t,
+                  d_shuff[]) = { 0x0707060504030201LL, 0x0f0f0e0d0c0b0a09LL };
+  DECLARE_ALIGNED(16, static const uint64_t,
+                  e_shuff[]) = { 0x0707070605040302LL, 0x0f0f0f0e0d0c0b0aLL };
+  int y;
 
-      for (y = 0; y < sizey; y += 2) {
-        const v64 l1 = v64_load_aligned(src);
-        const v64 l2 = v64_load_aligned(src + stride);
-        v128 o = v128_from_v64(l1, l2);
-        const v128 x = v128_add_8(c128, o);
-        const v128 a = v128_add_8(
-            c128,
-            v128_from_v64(v64_load_aligned(src - (y != -y0) * stride), l1));
-        const v128 b = v128_shuffle_8(x, b_shuff);
-        const v128 c = v128_shuffle_8(x, c_shuff);
-        const v128 d = v128_add_8(
-            c128, v128_from_v64(v64_load_unaligned(src + 1),
-                                v64_load_unaligned(src + 1 + stride)));
-        const v128 e = v128_add_8(
-            c128, v128_from_v64(v64_load_unaligned(src + 2),
-                                v64_load_unaligned(src + 2 + stride)));
-        const v128 f = v128_add_8(
-            c128, v128_from_v64(l2, v64_load_aligned(
-                                        src + ((y != bottom) + 1) * stride)));
+  dst += x0 + y0 * dstride;
+  src += x0 + y0 * sstride;
 
-        const v128 tmp =
-            v128_add_8(v128_max_s8(v128_min_s8(v128_ssub_s8(c, x), sp), sm),
-                       v128_max_s8(v128_min_s8(v128_ssub_s8(d, x), sp), sm));
-        const v128 delta = v128_add_8(
-            v128_add_8(
-                v128_shl_8(
-                    v128_add_8(
-                        v128_max_s8(v128_min_s8(v128_ssub_s8(a, x), sp), sm),
-                        v128_max_s8(v128_min_s8(v128_ssub_s8(f, x), sp), sm)),
-                    2),
-                v128_add_8(
-                    v128_max_s8(v128_min_s8(v128_ssub_s8(b, x), sp), sm),
-                    v128_max_s8(v128_min_s8(v128_ssub_s8(e, x), sp), sm))),
-            v128_add_8(v128_add_8(tmp, tmp), tmp));
-        o = v128_add_8(
-            o, v128_shr_s8(
-                   v128_add_8(c8, v128_add_8(delta, v128_cmplt_s8(
-                                                        delta, v128_zero()))),
-                   4));
-        v64_store_aligned(dst, v128_high_v64(o));
-        v64_store_aligned(dst + stride, v128_low_v64(o));
-        src += stride * 2;
-        dst += stride * 2;
-      }
-    } else if (!(width - x0 - 8)) {  // Clip right
-      const v128 d_shuff = v128_from_v64(v64_from_64(0x0f0f0e0d0c0b0a09LL),
-                                         v64_from_64(0x0707060504030201LL));
-      const v128 e_shuff = v128_from_v64(v64_from_64(0x0f0f0f0e0d0c0b0aLL),
-                                         v64_from_64(0x0707070605040302LL));
-      int y;
+  for (y = 0; y < sizey; y += 2) {
+    const v64 l1 = v64_load_aligned(src);
+    const v64 l2 = v64_load_aligned(src + sstride);
+    v128 o = v128_from_v64(l1, l2);
+    const v128 a =
+        v128_from_v64(v64_load_aligned(src - (y != -y0) * sstride), l1);
+    const v128 f = v128_from_v64(
+        l2, v64_load_aligned(src + ((y != bottom) + 1) * sstride));
+    v128 b, c, d, e;
 
-      for (y = 0; y < sizey; y += 2) {
-        const v64 l1 = v64_load_aligned(src);
-        const v64 l2 = v64_load_aligned(src + stride);
-        v128 o = v128_from_v64(l1, l2);
-        const v128 x = v128_add_8(c128, o);
-        const v128 a = v128_add_8(
-            c128,
-            v128_from_v64(v64_load_aligned(src - (y != -y0) * stride), l1));
-        const v128 b = v128_add_8(
-            c128, v128_from_v64(v64_load_unaligned(src - 2),
-                                v64_load_unaligned(src - 2 + stride)));
-        const v128 c = v128_add_8(
-            c128, v128_from_v64(v64_load_unaligned(src - 1),
-                                v64_load_unaligned(src - 1 + stride)));
-        const v128 d = v128_shuffle_8(x, d_shuff);
-        const v128 e = v128_shuffle_8(x, e_shuff);
-        const v128 f = v128_add_8(
-            c128, v128_from_v64(l2, v64_load_aligned(
-                                        src + ((y != bottom) + 1) * stride)));
-
-        const v128 tmp =
-            v128_add_8(v128_max_s8(v128_min_s8(v128_ssub_s8(c, x), sp), sm),
-                       v128_max_s8(v128_min_s8(v128_ssub_s8(d, x), sp), sm));
-        const v128 delta = v128_add_8(
-            v128_add_8(
-                v128_shl_8(
-                    v128_add_8(
-                        v128_max_s8(v128_min_s8(v128_ssub_s8(a, x), sp), sm),
-                        v128_max_s8(v128_min_s8(v128_ssub_s8(f, x), sp), sm)),
-                    2),
-                v128_add_8(
-                    v128_max_s8(v128_min_s8(v128_ssub_s8(b, x), sp), sm),
-                    v128_max_s8(v128_min_s8(v128_ssub_s8(e, x), sp), sm))),
-            v128_add_8(v128_add_8(tmp, tmp), tmp));
-        o = v128_add_8(
-            o, v128_shr_s8(
-                   v128_add_8(c8, v128_add_8(delta, v128_cmplt_s8(
-                                                        delta, v128_zero()))),
-                   4));
-        v64_store_aligned(dst, v128_high_v64(o));
-        v64_store_aligned(dst + stride, v128_low_v64(o));
-        src += stride * 2;
-        dst += stride * 2;
-      }
-    } else {  // No left/right clipping
-      int y;
-      for (y = 0; y < sizey; y += 2) {
-        const v64 l1 = v64_load_aligned(src);
-        const v64 l2 = v64_load_aligned(src + stride);
-        v128 o = v128_from_v64(l1, l2);
-        const v128 x = v128_add_8(c128, o);
-        const v128 a = v128_add_8(
-            c128,
-            v128_from_v64(v64_load_aligned(src - (y != -y0) * stride), l1));
-        const v128 b = v128_add_8(
-            c128, v128_from_v64(v64_load_unaligned(src - 2),
-                                v64_load_unaligned(src - 2 + stride)));
-        const v128 c = v128_add_8(
-            c128, v128_from_v64(v64_load_unaligned(src - 1),
-                                v64_load_unaligned(src - 1 + stride)));
-        const v128 d = v128_add_8(
-            c128, v128_from_v64(v64_load_unaligned(src + 1),
-                                v64_load_unaligned(src + 1 + stride)));
-        const v128 e = v128_add_8(
-            c128, v128_from_v64(v64_load_unaligned(src + 2),
-                                v64_load_unaligned(src + 2 + stride)));
-        const v128 f = v128_add_8(
-            c128, v128_from_v64(l2, v64_load_aligned(
-                                        src + ((y != bottom) + 1) * stride)));
-
-        const v128 tmp =
-            v128_add_8(v128_max_s8(v128_min_s8(v128_ssub_s8(c, x), sp), sm),
-                       v128_max_s8(v128_min_s8(v128_ssub_s8(d, x), sp), sm));
-        const v128 delta = v128_add_8(
-            v128_add_8(
-                v128_shl_8(
-                    v128_add_8(
-                        v128_max_s8(v128_min_s8(v128_ssub_s8(a, x), sp), sm),
-                        v128_max_s8(v128_min_s8(v128_ssub_s8(f, x), sp), sm)),
-                    2),
-                v128_add_8(
-                    v128_max_s8(v128_min_s8(v128_ssub_s8(b, x), sp), sm),
-                    v128_max_s8(v128_min_s8(v128_ssub_s8(e, x), sp), sm))),
-            v128_add_8(v128_add_8(tmp, tmp), tmp));
-        o = v128_add_8(
-            o, v128_shr_s8(
-                   v128_add_8(c8, v128_add_8(delta, v128_cmplt_s8(
-                                                        delta, v128_zero()))),
-                   4));
-        v64_store_aligned(dst, v128_high_v64(o));
-        v64_store_aligned(dst + stride, v128_low_v64(o));
-        src += stride * 2;
-        dst += stride * 2;
-      }
+    if (x0) {
+      b = v128_from_v64(v64_load_unaligned(src - 2),
+                        v64_load_unaligned(src - 2 + sstride));
+      c = v128_from_v64(v64_load_unaligned(src - 1),
+                        v64_load_unaligned(src - 1 + sstride));
+    } else {  // Left clipping
+      b = v128_shuffle_8(o, v128_load_aligned(b_shuff));
+      c = v128_shuffle_8(o, v128_load_aligned(c_shuff));
     }
+    if (right) {
+      d = v128_from_v64(v64_load_unaligned(src + 1),
+                        v64_load_unaligned(src + 1 + sstride));
+      e = v128_from_v64(v64_load_unaligned(src + 2),
+                        v64_load_unaligned(src + 2 + sstride));
+    } else {  // Right clipping
+      d = v128_shuffle_8(o, v128_load_aligned(d_shuff));
+      e = v128_shuffle_8(o, v128_load_aligned(e_shuff));
+    }
+
+    o = calc_delta(o, a, b, c, d, e, f, sp, sm);
+    v64_store_aligned(dst, v128_high_v64(o));
+    v64_store_aligned(dst + dstride, v128_low_v64(o));
+    src += sstride * 2;
+    dst += dstride * 2;
   }
 }
 
-void SIMD_FUNC(aom_clpf_block)(const uint8_t *src, uint8_t *dst, int stride,
-                               int x0, int y0, int sizex, int sizey, int width,
-                               int height, unsigned int strength) {
-  // TODO(stemidts):
-  // A sizex different from 8 will only be needed if CLPF is extended to chroma.
-  // This will only be used if 4:2:0 and width not a multiple of 16 and along
-  // the right edge only, so we can fall back to the plain C implementation in
-  // this case.  If not extended to chroma, this test will be redundant.
-  if (sizex != 8 || width < 16) {  // Fallback to C if frame width < 16
-    aom_clpf_block_c(src, dst, stride, x0, y0, sizex, sizey, width, height,
-                     strength);
-  } else {
-    clpf_block(src, dst, stride, x0, y0, sizey, width, height, strength);
+// Process blocks of width 4, four lines at a time, 8 bit.
+static void clpf_block4(const uint8_t *src, uint8_t *dst, int sstride,
+                        int dstride, int x0, int y0, int sizey, int width,
+                        int height, unsigned int strength) {
+  const v128 sp = v128_dup_8(strength);
+  const v128 sm = v128_dup_8(-(int)strength);
+  const int right = width - 4 - x0;
+  const int bottom = height - 4 - y0;
+  DECLARE_ALIGNED(16, static const uint64_t,
+                  b_shuff[]) = { 0x0504040401000000LL, 0x0d0c0c0c09080808LL };
+  DECLARE_ALIGNED(16, static const uint64_t,
+                  c_shuff[]) = { 0x0605040402010000LL, 0x0e0d0c0c0a090808LL };
+  DECLARE_ALIGNED(16, static const uint64_t,
+                  d_shuff[]) = { 0x0707060503030201LL, 0x0f0f0e0d0b0b0a09LL };
+  DECLARE_ALIGNED(16, static const uint64_t,
+                  e_shuff[]) = { 0x0707070603030302LL, 0x0f0f0f0e0b0b0b0aLL };
+  int y;
+
+  dst += x0 + y0 * dstride;
+  src += x0 + y0 * sstride;
+
+  for (y = 0; y < sizey; y += 4) {
+    const uint32_t l0 = u32_load_aligned(src - (y != -y0) * sstride);
+    const uint32_t l1 = u32_load_aligned(src);
+    const uint32_t l2 = u32_load_aligned(src + sstride);
+    const uint32_t l3 = u32_load_aligned(src + 2 * sstride);
+    const uint32_t l4 = u32_load_aligned(src + 3 * sstride);
+    const uint32_t l5 = u32_load_aligned(src + ((y != bottom) + 3) * sstride);
+    v128 o = v128_from_32(l1, l2, l3, l4);
+    const v128 a = v128_from_32(l0, l1, l2, l3);
+    const v128 f = v128_from_32(l2, l3, l4, l5);
+    v128 b, c, d, e;
+
+    if (x0) {
+      b = v128_from_32(u32_load_unaligned(src - 2),
+                       u32_load_unaligned(src + sstride - 2),
+                       u32_load_unaligned(src + 2 * sstride - 2),
+                       u32_load_unaligned(src + 3 * sstride - 2));
+      c = v128_from_32(u32_load_unaligned(src - 1),
+                       u32_load_unaligned(src + sstride - 1),
+                       u32_load_unaligned(src + 2 * sstride - 1),
+                       u32_load_unaligned(src + 3 * sstride - 1));
+    } else {  // Left clipping
+      b = v128_shuffle_8(o, v128_load_aligned(b_shuff));
+      c = v128_shuffle_8(o, v128_load_aligned(c_shuff));
+    }
+    if (right) {
+      d = v128_from_32(u32_load_unaligned(src + 1),
+                       u32_load_unaligned(src + sstride + 1),
+                       u32_load_unaligned(src + 2 * sstride + 1),
+                       u32_load_unaligned(src + 3 * sstride + 1));
+      e = v128_from_32(u32_load_unaligned(src + 2 * !!right),
+                       u32_load_unaligned(src + sstride + 2),
+                       u32_load_unaligned(src + 2 * sstride + 2),
+                       u32_load_unaligned(src + 3 * sstride + 2));
+    } else {  // Right clipping
+      d = v128_shuffle_8(o, v128_load_aligned(d_shuff));
+      e = v128_shuffle_8(o, v128_load_aligned(e_shuff));
+    }
+
+    o = calc_delta(o, a, b, c, d, e, f, sp, sm);
+    u32_store_aligned(dst, v128_low_u32(v128_shr_n_byte(o, 12)));
+    u32_store_aligned(dst + dstride, v128_low_u32(v128_shr_n_byte(o, 8)));
+    u32_store_aligned(dst + 2 * dstride, v128_low_u32(v128_shr_n_byte(o, 4)));
+    u32_store_aligned(dst + 3 * dstride, v128_low_u32(o));
+
+    dst += 4 * dstride;
+    src += 4 * sstride;
   }
 }
+
+void SIMD_FUNC(aom_clpf_block)(const uint8_t *src, uint8_t *dst, int sstride,
+                               int dstride, int x0, int y0, int sizex,
+                               int sizey, int width, int height,
+                               unsigned int strength) {
+  if ((sizex != 4 && sizex != 8) || ((sizey & 3) && sizex == 4)) {
+    // Fallback to C for odd sizes:
+    // * block widths not 4 or 8
+    // * block heights not a multiple of 4 if the block width is 4
+    aom_clpf_block_c(src, dst, sstride, dstride, x0, y0, sizex, sizey, width,
+                     height, strength);
+  } else {
+    (sizex == 4 ? clpf_block4 : clpf_block8)(src, dst, sstride, dstride, x0, y0,
+                                             sizey, width, height, strength);
+  }
+}
+
+#if CONFIG_AOM_HIGHBITDEPTH
+// delta = 4/16 * clamp(a - o, -s, s) + 1/16 * clamp(b - o, -s, s) +
+//         3/16 * clamp(c - o, -s, s) + 3/16 * clamp(d - o, -s, s) +
+//         1/16 * clamp(e - o, -s, s) + 4/16 * clamp(f - o, -s, s)
+SIMD_INLINE v128 calc_delta_hbd(v128 o, v128 a, v128 b, v128 c, v128 d, v128 e,
+                                v128 f, v128 sp, v128 sm) {
+  const v128 c8 = v128_dup_16(8);
+  const v128 tmp =
+      v128_add_16(v128_max_s16(v128_min_s16(v128_sub_16(c, o), sp), sm),
+                  v128_max_s16(v128_min_s16(v128_sub_16(d, o), sp), sm));
+  const v128 delta = v128_add_16(
+      v128_add_16(
+          v128_shl_16(
+              v128_add_16(
+                  v128_max_s16(v128_min_s16(v128_sub_16(a, o), sp), sm),
+                  v128_max_s16(v128_min_s16(v128_sub_16(f, o), sp), sm)),
+              2),
+          v128_add_16(v128_max_s16(v128_min_s16(v128_sub_16(b, o), sp), sm),
+                      v128_max_s16(v128_min_s16(v128_sub_16(e, o), sp), sm))),
+      v128_add_16(v128_add_16(tmp, tmp), tmp));
+  return v128_add_16(
+      o, v128_shr_s16(
+             v128_add_16(
+                 c8, v128_add_16(delta, v128_cmplt_s16(delta, v128_zero()))),
+             4));
+}
+
+static void calc_delta_hbd4(v128 o, v128 a, v128 b, v128 c, v128 d, v128 e,
+                            v128 f, uint16_t *dst, v128 sp, v128 sm,
+                            int dstride) {
+  o = calc_delta_hbd(o, a, b, c, d, e, f, sp, sm);
+  v64_store_aligned(dst, v128_high_v64(o));
+  v64_store_aligned(dst + dstride, v128_low_v64(o));
+}
+
+static void calc_delta_hbd8(v128 o, v128 a, v128 b, v128 c, v128 d, v128 e,
+                            v128 f, uint16_t *dst, v128 sp, v128 sm) {
+  v128_store_aligned(dst, calc_delta_hbd(o, a, b, c, d, e, f, sp, sm));
+}
+
+// Process blocks of width 4, two lines at time.
+SIMD_INLINE void clpf_block_hbd4(const uint16_t *src, uint16_t *dst,
+                                 int sstride, int dstride, int x0, int y0,
+                                 int sizey, int width, int height,
+                                 unsigned int strength) {
+  const v128 sp = v128_dup_16(strength);
+  const v128 sm = v128_dup_16(-(int)strength);
+  const int right = width - 4 - x0;
+  const int bottom = height - 2 - y0;
+  DECLARE_ALIGNED(16, static const uint64_t,
+                  b_shuff[]) = { 0x0302010001000100LL, 0x0b0a090809080908LL };
+  DECLARE_ALIGNED(16, static const uint64_t,
+                  c_shuff[]) = { 0x0504030201000100LL, 0x0d0c0b0a09080908LL };
+  DECLARE_ALIGNED(16, static const uint64_t,
+                  d_shuff[]) = { 0x0706070605040302LL, 0x0f0e0f0e0d0c0b0aLL };
+  DECLARE_ALIGNED(16, static const uint64_t,
+                  e_shuff[]) = { 0x0706070607060504LL, 0x0f0e0f0e0f0e0d0cLL };
+  int y;
+
+  dst += x0 + y0 * dstride;
+  src += x0 + y0 * sstride;
+
+  for (y = 0; y < sizey; y += 2) {
+    const v64 l1 = v64_load_aligned(src);
+    const v64 l2 = v64_load_aligned(src + sstride);
+    v128 o = v128_from_v64(l1, l2);
+    const v128 a =
+        v128_from_v64(v64_load_aligned(src - (y != -y0) * sstride), l1);
+    const v128 f = v128_from_v64(
+        l2, v64_load_aligned(src + ((y != bottom) + 1) * sstride));
+    v128 b, c, d, e;
+
+    if (x0) {
+      b = v128_from_v64(v64_load_unaligned(src - 2),
+                        v64_load_unaligned(src - 2 + sstride));
+      c = v128_from_v64(v64_load_unaligned(src - 1),
+                        v64_load_unaligned(src - 1 + sstride));
+    } else {  // Left clipping
+      b = v128_shuffle_8(o, v128_load_aligned(b_shuff));
+      c = v128_shuffle_8(o, v128_load_aligned(c_shuff));
+    }
+    if (right) {
+      d = v128_from_v64(v64_load_unaligned(src + 1),
+                        v64_load_unaligned(src + 1 + sstride));
+      e = v128_from_v64(v64_load_unaligned(src + 2),
+                        v64_load_unaligned(src + 2 + sstride));
+    } else {  // Right clipping
+      d = v128_shuffle_8(o, v128_load_aligned(d_shuff));
+      e = v128_shuffle_8(o, v128_load_aligned(e_shuff));
+    }
+    calc_delta_hbd4(o, a, b, c, d, e, f, dst, sp, sm, dstride);
+    src += sstride * 2;
+    dst += dstride * 2;
+  }
+}
+
+// The most simple case.  Start here if you need to understand the functions.
+SIMD_INLINE void clpf_block_hbd(const uint16_t *src, uint16_t *dst, int sstride,
+                                int dstride, int x0, int y0, int sizey,
+                                int width, int height, unsigned int strength) {
+  const v128 sp = v128_dup_16(strength);
+  const v128 sm = v128_dup_16(-(int)strength);
+  const int right = width - 8 - x0;
+  const int bottom = height - 2 - y0;
+  DECLARE_ALIGNED(16, static const uint64_t,
+                  b_shuff[]) = { 0x0302010001000100LL, 0x0b0a090807060504LL };
+  DECLARE_ALIGNED(16, static const uint64_t,
+                  c_shuff[]) = { 0x0504030201000100LL, 0x0d0c0b0a09080706LL };
+  DECLARE_ALIGNED(16, static const uint64_t,
+                  d_shuff[]) = { 0x0908070605040302LL, 0x0f0e0f0e0d0c0b0aLL };
+  DECLARE_ALIGNED(16, static const uint64_t,
+                  e_shuff[]) = { 0x0b0a090807060504LL, 0x0f0e0f0e0f0e0d0cLL };
+  int y;
+
+  dst += x0 + y0 * dstride;
+  src += x0 + y0 * sstride;
+
+  // Read 8 set of pixels at a time.  Clipping along upper and lower
+  // edges is handled by reading the upper or lower line twice.
+  // Clipping along the left and right edges is handled by shuffle
+  // instructions doing shift and pad.
+  for (y = 0; y < sizey; y++) {
+    const v128 o = v128_load_aligned(src);
+    const v128 a = v128_load_aligned(src - (y != -y0) * sstride);
+    const v128 f = v128_load_aligned(src + (y - 1 != bottom) * sstride);
+    v128 b, c, d, e;
+
+    if (x0) {
+      b = v128_load_unaligned(src - 2);
+      c = v128_load_unaligned(src - 1);
+    } else {  // Left clipping
+      b = v128_shuffle_8(o, v128_load_aligned(b_shuff));
+      c = v128_shuffle_8(o, v128_load_aligned(c_shuff));
+    }
+    if (right) {
+      d = v128_load_unaligned(src + 1);
+      e = v128_load_unaligned(src + 2);
+    } else {  // Right clipping
+      d = v128_shuffle_8(o, v128_load_aligned(d_shuff));
+      e = v128_shuffle_8(o, v128_load_aligned(e_shuff));
+    }
+    calc_delta_hbd8(o, a, b, c, d, e, f, dst, sp, sm);
+    src += sstride;
+    dst += dstride;
+  }
+}
+
+void SIMD_FUNC(aom_clpf_block_hbd)(const uint16_t *src, uint16_t *dst,
+                                   int sstride, int dstride, int x0, int y0,
+                                   int sizex, int sizey, int width, int height,
+                                   unsigned int strength) {
+  if ((sizex != 4 && sizex != 8) || ((sizey & 1) && sizex == 4)) {
+    // Fallback to C for odd sizes:
+    // * block width not 4 or 8
+    // * block heights not a multiple of 2 if the block width is 4
+    aom_clpf_block_hbd_c(src, dst, sstride, dstride, x0, y0, sizex, sizey,
+                         width, height, strength);
+  } else {
+    (sizex == 4 ? clpf_block_hbd4 : clpf_block_hbd)(
+        src, dst, sstride, dstride, x0, y0, sizey, width, height, strength);
+  }
+}
+#endif
diff --git a/av1/common/onyxc_int.h b/av1/common/onyxc_int.h
index 2bb680a..98f4f51 100644
--- a/av1/common/onyxc_int.h
+++ b/av1/common/onyxc_int.h
@@ -153,7 +153,9 @@
 #if CONFIG_CLPF
   int clpf_numblocks;
   int clpf_size;
-  int clpf_strength;
+  int clpf_strength_y;
+  int clpf_strength_u;
+  int clpf_strength_v;
   uint8_t *clpf_blocks;
 #endif
 
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index dc18944..7daeb5d 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -29,6 +29,7 @@
 
 #include "av1/common/alloccommon.h"
 #if CONFIG_CLPF
+#include "aom/aom_image.h"
 #include "av1/common/clpf.h"
 #endif
 #include "av1/common/common.h"
@@ -2046,8 +2047,10 @@
 #if CONFIG_CLPF
 static void setup_clpf(AV1_COMMON *cm, struct aom_read_bit_buffer *rb) {
   cm->clpf_blocks = 0;
-  cm->clpf_strength = aom_rb_read_literal(rb, 2);
-  if (cm->clpf_strength) {
+  cm->clpf_strength_y = aom_rb_read_literal(rb, 2);
+  cm->clpf_strength_u = aom_rb_read_literal(rb, 2);
+  cm->clpf_strength_v = aom_rb_read_literal(rb, 2);
+  if (cm->clpf_strength_y) {
     cm->clpf_size = aom_rb_read_literal(rb, 2);
     if (cm->clpf_size) {
       int i;
@@ -3928,20 +3931,23 @@
 #endif  // CONFIG_LOOP_RESTORATION
 
 #if CONFIG_CLPF
-  if (cm->clpf_strength && !cm->skip_loop_filter) {
-    YV12_BUFFER_CONFIG dst;  // Buffer for the result
-
-    dst = pbi->cur_buf->buf;
-    CHECK_MEM_ERROR(cm, dst.y_buffer, aom_malloc(dst.y_stride * dst.y_height));
-
-    av1_clpf_frame(&dst, &pbi->cur_buf->buf, 0, cm, !!cm->clpf_size,
-                   cm->clpf_strength + (cm->clpf_strength == 3),
-                   4 + cm->clpf_size, cm->clpf_blocks, clpf_bit);
-
-    // Copy result
-    memcpy(pbi->cur_buf->buf.y_buffer, dst.y_buffer,
-           dst.y_height * dst.y_stride);
-    aom_free(dst.y_buffer);
+  if (!cm->skip_loop_filter) {
+    const YV12_BUFFER_CONFIG *const frame = &pbi->cur_buf->buf;
+    if (cm->clpf_strength_y) {
+      av1_clpf_frame(frame, NULL, cm, !!cm->clpf_size,
+                     cm->clpf_strength_y + (cm->clpf_strength_y == 3),
+                     4 + cm->clpf_size, cm->clpf_blocks, AOM_PLANE_Y, clpf_bit);
+    }
+    if (cm->clpf_strength_u) {
+      av1_clpf_frame(frame, NULL, cm, 0,
+                     cm->clpf_strength_u + (cm->clpf_strength_u == 3), 4, NULL,
+                     AOM_PLANE_U, NULL);
+    }
+    if (cm->clpf_strength_v) {
+      av1_clpf_frame(frame, NULL, cm, 0,
+                     cm->clpf_strength_v + (cm->clpf_strength_v == 3), 4, NULL,
+                     AOM_PLANE_V, NULL);
+    }
   }
   if (cm->clpf_blocks) aom_free(cm->clpf_blocks);
 #endif
diff --git a/av1/decoder/decodemv.c b/av1/decoder/decodemv.c
index dab1008..1438a56 100644
--- a/av1/decoder/decodemv.c
+++ b/av1/decoder/decodemv.c
@@ -1454,6 +1454,7 @@
         };
 
         mi->bmi[j].as_mv[0].as_int = block[0].as_int;
+        mi->bmi[j].as_mode = b_mode;
         if (is_compound) mi->bmi[j].as_mv[1].as_int = block[1].as_int;
 
         if (num_4x4_h == 2) mi->bmi[j + 2] = mi->bmi[j];
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index 2b846e8..6774bb2 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -662,7 +662,7 @@
 
         if (t != ONE_TOKEN) {
           int len = UNCONSTRAINED_NODES - p->skip_eob_node;
-          av1_write_tree(w, av1_coef_con_tree,
+          aom_write_tree(w, av1_coef_con_tree,
                          av1_pareto8_full[p->context_tree[PIVOT_NODE] - 1], v,
                          n - len, 0);
         }
@@ -836,7 +836,7 @@
                              const struct segmentation_probs *segp,
                              int segment_id) {
   if (seg->enabled && seg->update_map)
-    av1_write_tree(w, av1_segment_tree, segp->tree_probs, segment_id, 3, 0);
+    aom_write_tree(w, av1_segment_tree, segp->tree_probs, segment_id, 3, 0);
 }
 
 // This function encodes the reference frame
@@ -2590,8 +2590,10 @@
 
 #if CONFIG_CLPF
 static void encode_clpf(const AV1_COMMON *cm, struct aom_write_bit_buffer *wb) {
-  aom_wb_write_literal(wb, cm->clpf_strength, 2);
-  if (cm->clpf_strength) {
+  aom_wb_write_literal(wb, cm->clpf_strength_y, 2);
+  aom_wb_write_literal(wb, cm->clpf_strength_u, 2);
+  aom_wb_write_literal(wb, cm->clpf_strength_v, 2);
+  if (cm->clpf_strength_y) {
     aom_wb_write_literal(wb, cm->clpf_size, 2);
     if (cm->clpf_size) {
       int i;
diff --git a/av1/encoder/block.h b/av1/encoder/block.h
index 2156032..57b42a8 100644
--- a/av1/encoder/block.h
+++ b/av1/encoder/block.h
@@ -164,9 +164,6 @@
   // Store the second best motion vector during full-pixel motion search
   int_mv second_best_mv;
 
-  // Strong color activity detection. Used in RTC coding mode to enhance
-  // the visual quality at the boundary of moving color objects.
-  uint8_t color_sensitivity[2];
 
   // use default transform and skip transform type search for intra modes
   int use_default_intra_tx_type;
diff --git a/av1/encoder/clpf_rdo.c b/av1/encoder/clpf_rdo.c
index 4221505..1d498f1 100644
--- a/av1/encoder/clpf_rdo.c
+++ b/av1/encoder/clpf_rdo.c
@@ -11,16 +11,17 @@
 
 #include "av1/common/clpf.h"
 #include "./aom_dsp_rtcd.h"
+#include "aom/aom_image.h"
 #include "aom/aom_integer.h"
 #include "av1/common/quant_common.h"
 
 // Calculate the error of a filtered and unfiltered block
 void aom_clpf_detect_c(const uint8_t *rec, const uint8_t *org, int rstride,
                        int ostride, int x0, int y0, int width, int height,
-                       int *sum0, int *sum1, unsigned int strength) {
+                       int *sum0, int *sum1, unsigned int strength, int size) {
   int x, y;
-  for (y = y0; y < y0 + 8; y++) {
-    for (x = x0; x < x0 + 8; x++) {
+  for (y = y0; y < y0 + size; y++) {
+    for (x = x0; x < x0 + size; x++) {
       int O = org[y * ostride + x];
       int X = rec[y * rstride + x];
       int A = rec[AOMMAX(0, y - 1) * rstride + x];
@@ -39,11 +40,11 @@
 
 void aom_clpf_detect_multi_c(const uint8_t *rec, const uint8_t *org,
                              int rstride, int ostride, int x0, int y0,
-                             int width, int height, int *sum) {
+                             int width, int height, int *sum, int size) {
   int x, y;
 
-  for (y = y0; y < y0 + 8; y++) {
-    for (x = x0; x < x0 + 8; x++) {
+  for (y = y0; y < y0 + size; y++) {
+    for (x = x0; x < x0 + size; x++) {
       int O = org[y * ostride + x];
       int X = rec[y * rstride + x];
       int A = rec[AOMMAX(0, y - 1) * rstride + x];
@@ -66,21 +67,94 @@
   }
 }
 
+#if CONFIG_AOM_HIGHBITDEPTH
+// Identical to aom_clpf_detect_c() apart from "rec" and "org".
+void aom_clpf_detect_hbd_c(const uint16_t *rec, const uint16_t *org,
+                           int rstride, int ostride, int x0, int y0, int width,
+                           int height, int *sum0, int *sum1,
+                           unsigned int strength, int shift, int size) {
+  int x, y;
+  for (y = y0; y < y0 + size; y++) {
+    for (x = x0; x < x0 + size; x++) {
+      int O = org[y * ostride + x] >> shift;
+      int X = rec[y * rstride + x] >> shift;
+      int A = rec[AOMMAX(0, y - 1) * rstride + x] >> shift;
+      int B = rec[y * rstride + AOMMAX(0, x - 2)] >> shift;
+      int C = rec[y * rstride + AOMMAX(0, x - 1)] >> shift;
+      int D = rec[y * rstride + AOMMIN(width - 1, x + 1)] >> shift;
+      int E = rec[y * rstride + AOMMIN(width - 1, x + 2)] >> shift;
+      int F = rec[AOMMIN(height - 1, y + 1) * rstride + x] >> shift;
+      int delta = av1_clpf_sample(X, A, B, C, D, E, F, strength >> shift);
+      int Y = X + delta;
+      *sum0 += (O - X) * (O - X);
+      *sum1 += (O - Y) * (O - Y);
+    }
+  }
+}
+
+// aom_clpf_detect_multi_c() apart from "rec" and "org".
+void aom_clpf_detect_multi_hbd_c(const uint16_t *rec, const uint16_t *org,
+                                 int rstride, int ostride, int x0, int y0,
+                                 int width, int height, int *sum, int shift,
+                                 int size) {
+  int x, y;
+
+  for (y = y0; y < y0 + size; y++) {
+    for (x = x0; x < x0 + size; x++) {
+      int O = org[y * ostride + x] >> shift;
+      int X = rec[y * rstride + x] >> shift;
+      int A = rec[AOMMAX(0, y - 1) * rstride + x] >> shift;
+      int B = rec[y * rstride + AOMMAX(0, x - 2)] >> shift;
+      int C = rec[y * rstride + AOMMAX(0, x - 1)] >> shift;
+      int D = rec[y * rstride + AOMMIN(width - 1, x + 1)] >> shift;
+      int E = rec[y * rstride + AOMMIN(width - 1, x + 2)] >> shift;
+      int F = rec[AOMMIN(height - 1, y + 1) * rstride + x] >> shift;
+      int delta1 = av1_clpf_sample(X, A, B, C, D, E, F, 1);
+      int delta2 = av1_clpf_sample(X, A, B, C, D, E, F, 2);
+      int delta3 = av1_clpf_sample(X, A, B, C, D, E, F, 4);
+      int F1 = X + delta1;
+      int F2 = X + delta2;
+      int F3 = X + delta3;
+      sum[0] += (O - X) * (O - X);
+      sum[1] += (O - F1) * (O - F1);
+      sum[2] += (O - F2) * (O - F2);
+      sum[3] += (O - F3) * (O - F3);
+    }
+  }
+}
+#endif
+
 int av1_clpf_decision(int k, int l, const YV12_BUFFER_CONFIG *rec,
                       const YV12_BUFFER_CONFIG *org, const AV1_COMMON *cm,
                       int block_size, int w, int h, unsigned int strength,
                       unsigned int fb_size_log2, uint8_t *res) {
   int m, n, sum0 = 0, sum1 = 0;
+
   for (m = 0; m < h; m++) {
     for (n = 0; n < w; n++) {
       int xpos = (l << fb_size_log2) + n * block_size;
       int ypos = (k << fb_size_log2) + m * block_size;
-      const int bs = MAX_MIB_SIZE;
-      if (!cm->mi_grid_visible[ypos / bs * cm->mi_stride + xpos / bs]
-               ->mbmi.skip)
+      if (!cm->mi_grid_visible[ypos / MI_SIZE * cm->mi_stride + xpos / MI_SIZE]
+               ->mbmi.skip) {
+#if CONFIG_AOM_HIGHBITDEPTH
+        if (cm->use_highbitdepth) {
+          aom_clpf_detect_hbd(CONVERT_TO_SHORTPTR(rec->y_buffer),
+                              CONVERT_TO_SHORTPTR(org->y_buffer), rec->y_stride,
+                              org->y_stride, xpos, ypos, rec->y_crop_width,
+                              rec->y_crop_height, &sum0, &sum1, strength,
+                              cm->bit_depth - 8, block_size);
+        } else {
+          aom_clpf_detect(rec->y_buffer, org->y_buffer, rec->y_stride,
+                          org->y_stride, xpos, ypos, rec->y_crop_width,
+                          rec->y_crop_height, &sum0, &sum1, strength,
+                          block_size);
+        }
+#else
         aom_clpf_detect(rec->y_buffer, org->y_buffer, rec->y_stride,
                         org->y_stride, xpos, ypos, rec->y_crop_width,
-                        rec->y_crop_height, &sum0, &sum1, strength);
+                        rec->y_crop_height, &sum0, &sum1, strength, block_size);
+#endif
+      }
     }
   }
   *res = sum1 < sum0;
@@ -90,6 +164,7 @@
 // Calculate the square error of all filter settings.  Result:
 // res[0][0]   : unfiltered
 // res[0][1-3] : strength=1,2,4, no signals
+// (Only for luma:)
 // res[1][0]   : (bit count, fb size = 128)
 // res[1][1-3] : strength=1,2,4, fb size = 128
 // res[2][0]   : (bit count, fb size = 64)
@@ -99,12 +174,28 @@
 static int clpf_rdo(int y, int x, const YV12_BUFFER_CONFIG *rec,
                     const YV12_BUFFER_CONFIG *org, const AV1_COMMON *cm,
                     unsigned int block_size, unsigned int fb_size_log2, int w,
-                    int h, int64_t res[4][4]) {
+                    int h, int64_t res[4][4], int plane) {
   int c, m, n, filtered = 0;
   int sum[4];
+  const int subx = plane != AOM_PLANE_Y && rec->subsampling_x;
+  const int suby = plane != AOM_PLANE_Y && rec->subsampling_y;
   int bslog = get_msb(block_size);
+  uint8_t *rec_buffer =
+      plane != AOM_PLANE_Y
+          ? (plane == AOM_PLANE_U ? rec->u_buffer : rec->v_buffer)
+          : rec->y_buffer;
+  uint8_t *org_buffer =
+      plane != AOM_PLANE_Y
+          ? (plane == AOM_PLANE_U ? org->u_buffer : org->v_buffer)
+          : org->y_buffer;
+  int rec_width = plane != AOM_PLANE_Y ? rec->uv_crop_width : rec->y_crop_width;
+  int rec_height =
+      plane != AOM_PLANE_Y ? rec->uv_crop_height : rec->y_crop_height;
+  int rec_stride = plane != AOM_PLANE_Y ? rec->uv_stride : rec->y_stride;
+  int org_stride = plane != AOM_PLANE_Y ? org->uv_stride : org->y_stride;
   sum[0] = sum[1] = sum[2] = sum[3] = 0;
-  if (fb_size_log2 > (unsigned int)get_msb(MAX_FB_SIZE) - 3) {
+  if (plane == AOM_PLANE_Y &&
+      fb_size_log2 > (unsigned int)get_msb(MAX_FB_SIZE) - 3) {
     int w1, h1, w2, h2, i, sum1, sum2, sum3, oldfiltered;
 
     fb_size_log2--;
@@ -119,16 +210,17 @@
     oldfiltered = res[i][0];
     res[i][0] = 0;
 
-    filtered =
-        clpf_rdo(y, x, rec, org, cm, block_size, fb_size_log2, w1, h1, res);
+    filtered = clpf_rdo(y, x, rec, org, cm, block_size, fb_size_log2, w1, h1,
+                        res, plane);
     if (1 << (fb_size_log2 - bslog) < w)
       filtered |= clpf_rdo(y, x + (1 << fb_size_log2), rec, org, cm, block_size,
-                           fb_size_log2, w2, h1, res);
+                           fb_size_log2, w2, h1, res, plane);
     if (1 << (fb_size_log2 - bslog) < h) {
       filtered |= clpf_rdo(y + (1 << fb_size_log2), x, rec, org, cm, block_size,
-                           fb_size_log2, w1, h2, res);
-      filtered |= clpf_rdo(y + (1 << fb_size_log2), x + (1 << fb_size_log2),
-                           rec, org, cm, block_size, fb_size_log2, w2, h2, res);
+                           fb_size_log2, w1, h2, res, plane);
+      filtered |=
+          clpf_rdo(y + (1 << fb_size_log2), x + (1 << fb_size_log2), rec, org,
+                   cm, block_size, fb_size_log2, w2, h2, res, plane);
     }
 
     res[i][1] = AOMMIN(sum1 + res[i][0], res[i][1]);
@@ -142,18 +234,31 @@
     for (n = 0; n < w; n++) {
       int xpos = x + n * block_size;
       int ypos = y + m * block_size;
-      if (!cm->mi_grid_visible[ypos / MAX_MIB_SIZE * cm->mi_stride +
-                               xpos / MAX_MIB_SIZE]
+      if (!cm->mi_grid_visible[(ypos << suby) / MI_SIZE * cm->mi_stride +
+                               (xpos << subx) / MI_SIZE]
                ->mbmi.skip) {
-        aom_clpf_detect_multi(rec->y_buffer, org->y_buffer, rec->y_stride,
-                              org->y_stride, xpos, ypos, rec->y_crop_width,
-                              rec->y_crop_height, sum);
+#if CONFIG_AOM_HIGHBITDEPTH
+        if (cm->use_highbitdepth) {
+          aom_clpf_detect_multi_hbd(
+              CONVERT_TO_SHORTPTR(rec_buffer), CONVERT_TO_SHORTPTR(org_buffer),
+              rec_stride, org_stride, xpos, ypos, rec_width, rec_height, sum,
+              cm->bit_depth - 8, block_size);
+        } else {
+          aom_clpf_detect_multi(rec_buffer, org_buffer, rec_stride, org_stride,
+                                xpos, ypos, rec_width, rec_height, sum,
+                                block_size);
+        }
+#else
+        aom_clpf_detect_multi(rec_buffer, org_buffer, rec_stride, org_stride,
+                              xpos, ypos, rec_width, rec_height, sum,
+                              block_size);
+#endif
         filtered = 1;
       }
     }
   }
 
-  for (c = 0; c < 4; c++) {
+  for (c = 0; c < (plane == AOM_PLANE_Y ? 4 : 1); c++) {
     res[c][0] += sum[0];
     res[c][1] += sum[1];
     res[c][2] += sum[2];
@@ -164,59 +269,69 @@
 
 void av1_clpf_test_frame(const YV12_BUFFER_CONFIG *rec,
                          const YV12_BUFFER_CONFIG *org, const AV1_COMMON *cm,
-                         int *best_strength, int *best_bs) {
+                         int *best_strength, int *best_bs, int plane) {
   int c, j, k, l;
   int64_t best, sums[4][4];
-  int width = rec->y_crop_width, height = rec->y_crop_height;
-  const int bs = MAX_MIB_SIZE;
+  int width = plane != AOM_PLANE_Y ? rec->uv_crop_width : rec->y_crop_width;
+  int height = plane != AOM_PLANE_Y ? rec->uv_crop_height : rec->y_crop_height;
+  const int bs = MI_SIZE;
+  const int bslog = get_msb(bs);
   int fb_size_log2 = get_msb(MAX_FB_SIZE);
   int num_fb_ver = (height + (1 << fb_size_log2) - bs) >> fb_size_log2;
   int num_fb_hor = (width + (1 << fb_size_log2) - bs) >> fb_size_log2;
 
   memset(sums, 0, sizeof(sums));
 
-  for (k = 0; k < num_fb_ver; k++) {
-    for (l = 0; l < num_fb_hor; l++) {
-      // Calculate the block size after frame border clipping
-      int h =
-          AOMMIN(height, (k + 1) << fb_size_log2) & ((1 << fb_size_log2) - 1);
-      int w =
-          AOMMIN(width, (l + 1) << fb_size_log2) & ((1 << fb_size_log2) - 1);
-      h += !h << fb_size_log2;
-      w += !w << fb_size_log2;
-      clpf_rdo(k << fb_size_log2, l << fb_size_log2, rec, org, cm, bs,
-               fb_size_log2, w / bs, h / bs, sums);
+  if (plane != AOM_PLANE_Y)
+    // Use a block size of MI_SIZE regardless of the subsampling.  This
+    // This is accurate enough to determine the best strength and
+    // we don't need to add SIMD optimisations for 4x4 blocks.
+    clpf_rdo(0, 0, rec, org, cm, bs, fb_size_log2, width >> bslog,
+             height >> bslog, sums, plane);
+  else
+    for (k = 0; k < num_fb_ver; k++) {
+      for (l = 0; l < num_fb_hor; l++) {
+        // Calculate the block size after frame border clipping
+        int h =
+            AOMMIN(height, (k + 1) << fb_size_log2) & ((1 << fb_size_log2) - 1);
+        int w =
+            AOMMIN(width, (l + 1) << fb_size_log2) & ((1 << fb_size_log2) - 1);
+        h += !h << fb_size_log2;
+        w += !w << fb_size_log2;
+        clpf_rdo(k << fb_size_log2, l << fb_size_log2, rec, org, cm, MI_SIZE,
+                 fb_size_log2, w >> bslog, h >> bslog, sums, plane);
+      }
     }
-  }
+
+  if (plane != AOM_PLANE_Y)  // Slightly favour unfiltered chroma
+    sums[0][0] -= sums[0][0] >> 7;
 
   for (j = 0; j < 4; j++) {
     static const double lambda_square[] = {
-      // exp((i - 15.4244) / 8.4010)
-      0.159451, 0.179607, 0.202310, 0.227884, 0.256690, 0.289138, 0.325687,
-      0.366856, 0.413230, 0.465465, 0.524303, 0.590579, 0.665233, 0.749323,
-      0.844044, 0.950737, 1.070917, 1.206289, 1.358774, 1.530533, 1.724004,
-      1.941931, 2.187406, 2.463911, 2.775368, 3.126195, 3.521370, 3.966498,
-      4.467893, 5.032669, 5.668837, 6.385421, 7.192586, 8.101784, 9.125911,
-      10.27949, 11.57890, 13.04256, 14.69124, 16.54832, 18.64016, 20.99641,
-      23.65052, 26.64013, 30.00764, 33.80084, 38.07352, 42.88630, 48.30746,
-      54.41389, 61.29221, 69.04002, 77.76720, 87.59756, 98.67056, 111.1432,
-      125.1926, 141.0179, 158.8436, 178.9227, 201.5399, 227.0160, 255.7126,
-      288.0366
+      // exp(x / 8.5)
+      1.0000, 1.1248, 1.2653, 1.4232, 1.6009, 1.8008, 2.0256, 2.2785,
+      2.5630, 2.8830, 3.2429, 3.6478, 4.1032, 4.6155, 5.1917, 5.8399,
+      6.5689, 7.3891, 8.3116, 9.3492, 10.516, 11.829, 13.306, 14.967,
+      16.836, 18.938, 21.302, 23.962, 26.953, 30.318, 34.103, 38.361,
+      43.151, 48.538, 54.598, 61.414, 69.082, 77.706, 87.408, 98.320,
+      110.59, 124.40, 139.93, 157.40, 177.05, 199.16, 224.02, 251.99,
+      283.45, 318.84, 358.65, 403.42, 453.79, 510.45, 574.17, 645.86,
+      726.49, 817.19, 919.22, 1033.9, 1163.0, 1308.2, 1471.6, 1655.3
     };
 
     // Estimate the bit costs and adjust the square errors
     double lambda =
         lambda_square[av1_get_qindex(&cm->seg, 0, cm->base_qindex) >> 2];
-    int i, cost = (int)((1.2 * lambda * (sums[j][0] + 2 + 2 * (j > 0)) + 0.5));
+    int i, cost = (int)((lambda * (sums[j][0] + 6 + 2 * (j > 0)) + 0.5));
     for (i = 0; i < 4; i++)
       sums[j][i] = ((sums[j][i] + (i && j) * cost) << 4) + j * 4 + i;
   }
 
   best = (int64_t)1 << 62;
-  for (c = 0; c < 4; c++)
+  for (c = 0; c < (plane == AOM_PLANE_Y ? 4 : 1); c++)
     for (j = 0; j < 4; j++)
       if ((!c || j) && sums[c][j] < best) best = sums[c][j];
   best &= 15;
-  *best_bs = (best > 3) * (5 + (best < 12) + (best < 8));
+  if (best_bs) *best_bs = (best > 3) * (5 + (best < 12) + (best < 8));
   *best_strength = best ? 1 << ((best - 1) & 3) : 0;
 }
diff --git a/av1/encoder/clpf_rdo.h b/av1/encoder/clpf_rdo.h
index 3dd5478..bb85fbc 100644
--- a/av1/encoder/clpf_rdo.h
+++ b/av1/encoder/clpf_rdo.h
@@ -21,6 +21,6 @@
 
 void av1_clpf_test_frame(const YV12_BUFFER_CONFIG *rec,
                          const YV12_BUFFER_CONFIG *org, const AV1_COMMON *cm,
-                         int *best_strength, int *best_bs);
+                         int *best_strength, int *best_bs, int plane);
 
 #endif
diff --git a/av1/encoder/clpf_rdo_simd.h b/av1/encoder/clpf_rdo_simd.h
index abbbe7c..7c07329 100644
--- a/av1/encoder/clpf_rdo_simd.h
+++ b/av1/encoder/clpf_rdo_simd.h
@@ -9,496 +9,278 @@
  * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
  */
 
+#include "./aom_dsp_rtcd.h"
 #include "aom_dsp/aom_simd.h"
+#include "aom_ports/mem.h"
+
+SIMD_INLINE void calc_diff(v128 o, v128 *a, v128 *b, v128 *c, v128 *d, v128 *e,
+                           v128 *f) {
+  // The difference will be 9 bit, offset by 128 so we can use saturated
+  // sub to avoid going to 16 bit temporarily before "strength" clipping.
+  const v128 c128 = v128_dup_8(128);
+  v128 x = v128_add_8(c128, o);
+  *a = v128_ssub_s8(v128_add_8(c128, *a), x);
+  *b = v128_ssub_s8(v128_add_8(c128, *b), x);
+  *c = v128_ssub_s8(v128_add_8(c128, *c), x);
+  *d = v128_ssub_s8(v128_add_8(c128, *d), x);
+  *e = v128_ssub_s8(v128_add_8(c128, *e), x);
+  *f = v128_ssub_s8(v128_add_8(c128, *f), x);
+}
+
+SIMD_INLINE v128 delta_kernel(v128 o, v128 a, v128 b, v128 c, v128 d, v128 e,
+                              v128 f, v128 sp, v128 sm) {
+  const v128 tmp = v128_add_8(v128_max_s8(v128_min_s8(c, sp), sm),
+                              v128_max_s8(v128_min_s8(d, sp), sm));
+  const v128 delta = v128_add_8(
+      v128_add_8(v128_shl_8(v128_add_8(v128_max_s8(v128_min_s8(a, sp), sm),
+                                       v128_max_s8(v128_min_s8(f, sp), sm)),
+                            2),
+                 v128_add_8(v128_max_s8(v128_min_s8(b, sp), sm),
+                            v128_max_s8(v128_min_s8(e, sp), sm))),
+      v128_add_8(v128_add_8(tmp, tmp), tmp));
+
+  return v128_add_8(
+      o, v128_shr_s8(
+             v128_add_8(v128_dup_8(8),
+                        v128_add_8(delta, v128_cmplt_s8(delta, v128_zero()))),
+             4));
+}
+
+SIMD_INLINE v128 calc_delta(v128 o, v128 a, v128 b, v128 c, v128 d, v128 e,
+                            v128 f, v128 sp, v128 sm) {
+  calc_diff(o, &a, &b, &c, &d, &e, &f);
+  return delta_kernel(o, a, b, c, d, e, f, sp, sm);
+}
+
+SIMD_INLINE void clip_sides(v128 *b, v128 *c, v128 *d, v128 *e, int left,
+                            int right) {
+  DECLARE_ALIGNED(16, static const uint64_t,
+                  b_shuff[]) = { 0x0504030201000000LL, 0x0d0c0b0a09080808LL };
+  DECLARE_ALIGNED(16, static const uint64_t,
+                  c_shuff[]) = { 0x0605040302010000LL, 0x0e0d0c0b0a090808LL };
+  DECLARE_ALIGNED(16, static const uint64_t,
+                  d_shuff[]) = { 0x0707060504030201LL, 0x0f0f0e0d0c0b0a09LL };
+  DECLARE_ALIGNED(16, static const uint64_t,
+                  e_shuff[]) = { 0x0707070605040302LL, 0x0f0f0f0e0d0c0b0aLL };
+
+  if (!left) {  // Left clipping
+    *b = v128_shuffle_8(*b, v128_load_aligned(b_shuff));
+    *c = v128_shuffle_8(*c, v128_load_aligned(c_shuff));
+  }
+  if (!right) {  // Right clipping
+    *d = v128_shuffle_8(*d, v128_load_aligned(d_shuff));
+    *e = v128_shuffle_8(*e, v128_load_aligned(e_shuff));
+  }
+}
+
+SIMD_INLINE void read_two_lines(const uint8_t *rec, const uint8_t *org,
+                                int rstride, int ostride, int x0, int y0,
+                                int bottom, int right, int y, v128 *o, v128 *r,
+                                v128 *a, v128 *b, v128 *c, v128 *d, v128 *e,
+                                v128 *f) {
+  const v64 k1 = v64_load_aligned(org);
+  const v64 k2 = v64_load_aligned(org + ostride);
+  const v64 l1 = v64_load_aligned(rec);
+  const v64 l2 = v64_load_aligned(rec + rstride);
+  *o = v128_from_v64(k1, k2);
+  *r = v128_from_v64(l1, l2);
+  *a = v128_from_v64(v64_load_aligned(rec - (y != -y0) * rstride), l1);
+  *f = v128_from_v64(l2, v64_load_aligned(rec + ((y != bottom) + 1) * rstride));
+  *b = v128_from_v64(v64_load_unaligned(rec - 2 * !!x0),
+                     v64_load_unaligned(rec - 2 * !!x0 + rstride));
+  *c = v128_from_v64(v64_load_unaligned(rec - !!x0),
+                     v64_load_unaligned(rec - !!x0 + rstride));
+  *d = v128_from_v64(v64_load_unaligned(rec + !!right),
+                     v64_load_unaligned(rec + !!right + rstride));
+  *e = v128_from_v64(v64_load_unaligned(rec + 2 * !!right),
+                     v64_load_unaligned(rec + 2 * !!right + rstride));
+  clip_sides(b, c, d, e, x0, right);
+}
 
 void SIMD_FUNC(aom_clpf_detect)(const uint8_t *rec, const uint8_t *org,
                                 int rstride, int ostride, int x0, int y0,
                                 int width, int height, int *sum0, int *sum1,
-                                unsigned int strength) {
-  ssd128_internal ssd0 = v128_ssd_u8_init();
-  ssd128_internal ssd1 = v128_ssd_u8_init();
-  const v128 c128 = v128_dup_8(128);
+                                unsigned int strength, int size) {
   const v128 sp = v128_dup_8(strength);
   const v128 sm = v128_dup_8(-(int)strength);
+  const int right = width - 8 - x0;
   const int bottom = height - 2 - y0;
+  ssd128_internal ssd0 = v128_ssd_u8_init();
+  ssd128_internal ssd1 = v128_ssd_u8_init();
+  int y;
+
+  if (size != 8) {  // Fallback to plain C
+    aom_clpf_detect_c(rec, org, rstride, ostride, x0, y0, width, height, sum0,
+                      sum1, strength, size);
+    return;
+  }
 
   rec += x0 + y0 * rstride;
   org += x0 + y0 * ostride;
 
-  if (!x0) {  // Clip left
-    const v128 b_shuff = v128_from_v64(v64_from_64(0x0d0c0b0a09080808LL),
-                                       v64_from_64(0x0504030201000000LL));
-    const v128 c_shuff = v128_from_v64(v64_from_64(0x0e0d0c0b0a090808LL),
-                                       v64_from_64(0x0605040302010000LL));
-    int y;
-
-    for (y = 0; y < 8; y += 2) {
-      const v64 k1 = v64_load_aligned(org);
-      const v64 k2 = v64_load_aligned(org + ostride);
-      const v64 l1 = v64_load_aligned(rec);
-      const v64 l2 = v64_load_aligned(rec + rstride);
-      v128 o = v128_from_v64(k1, k2);
-      const v128 q = v128_from_v64(l1, l2);
-      const v128 x = v128_add_8(c128, q);
-      const v128 a = v128_add_8(
-          c128,
-          v128_from_v64(v64_load_aligned(rec - (y != -y0) * rstride), l1));
-      const v128 b = v128_shuffle_8(x, b_shuff);
-      const v128 c = v128_shuffle_8(x, c_shuff);
-      const v128 d = v128_add_8(
-          c128, v128_from_v64(v64_load_unaligned(rec + 1),
-                              v64_load_unaligned(rec + 1 + rstride)));
-      const v128 e = v128_add_8(
-          c128, v128_from_v64(v64_load_unaligned(rec + 2),
-                              v64_load_unaligned(rec + 2 + rstride)));
-      const v128 f = v128_add_8(
-          c128, v128_from_v64(
-                    l2, v64_load_aligned(rec + ((y != bottom) + 1) * rstride)));
-
-      const v128 tmp =
-          v128_add_8(v128_max_s8(v128_min_s8(v128_ssub_s8(c, x), sp), sm),
-                     v128_max_s8(v128_min_s8(v128_ssub_s8(d, x), sp), sm));
-      v128 delta = v128_add_8(
-          v128_add_8(
-              v128_shl_8(
-                  v128_add_8(
-                      v128_max_s8(v128_min_s8(v128_ssub_s8(a, x), sp), sm),
-                      v128_max_s8(v128_min_s8(v128_ssub_s8(f, x), sp), sm)),
-                  2),
-              v128_add_8(v128_max_s8(v128_min_s8(v128_ssub_s8(b, x), sp), sm),
-                         v128_max_s8(v128_min_s8(v128_ssub_s8(e, x), sp), sm))),
-          v128_add_8(v128_add_8(tmp, tmp), tmp));
-
-      delta = v128_shr_s8(
-          v128_add_8(v128_dup_8(8),
-                     v128_add_8(delta, v128_cmplt_s8(delta, v128_zero()))),
-          4);
-      ssd0 = v128_ssd_u8(ssd0, o, q);
-      ssd1 = v128_ssd_u8(ssd1, o, v128_add_8(q, delta));
-      rec += rstride * 2;
-      org += ostride * 2;
-    }
-  } else if (!(width - x0 - 8)) {  // Clip right
-    const v128 d_shuff = v128_from_v64(v64_from_64(0x0f0f0e0d0c0b0a09LL),
-                                       v64_from_64(0x0707060504030201LL));
-    const v128 e_shuff = v128_from_v64(v64_from_64(0x0f0f0f0e0d0c0b0aLL),
-                                       v64_from_64(0x0707070605040302LL));
-    int y;
-
-    for (y = 0; y < 8; y += 2) {
-      const v64 k1 = v64_load_aligned(org);
-      const v64 k2 = v64_load_aligned(org + ostride);
-      const v64 l1 = v64_load_aligned(rec);
-      const v64 l2 = v64_load_aligned(rec + rstride);
-      v128 o = v128_from_v64(k1, k2);
-      const v128 q = v128_from_v64(l1, l2);
-      const v128 x = v128_add_8(c128, q);
-      const v128 a = v128_add_8(
-          c128,
-          v128_from_v64(v64_load_aligned(rec - (y != -y0) * rstride), l1));
-      const v128 b = v128_add_8(
-          c128, v128_from_v64(v64_load_unaligned(rec - 2),
-                              v64_load_unaligned(rec - 2 + rstride)));
-      const v128 c = v128_add_8(
-          c128, v128_from_v64(v64_load_unaligned(rec - 1),
-                              v64_load_unaligned(rec - 1 + rstride)));
-      const v128 d = v128_shuffle_8(x, d_shuff);
-      const v128 e = v128_shuffle_8(x, e_shuff);
-      const v128 f = v128_add_8(
-          c128, v128_from_v64(
-                    l2, v64_load_aligned(rec + ((y != bottom) + 1) * rstride)));
-
-      const v128 tmp =
-          v128_add_8(v128_max_s8(v128_min_s8(v128_ssub_s8(c, x), sp), sm),
-                     v128_max_s8(v128_min_s8(v128_ssub_s8(d, x), sp), sm));
-      v128 delta = v128_add_8(
-          v128_add_8(
-              v128_shl_8(
-                  v128_add_8(
-                      v128_max_s8(v128_min_s8(v128_ssub_s8(a, x), sp), sm),
-                      v128_max_s8(v128_min_s8(v128_ssub_s8(f, x), sp), sm)),
-                  2),
-              v128_add_8(v128_max_s8(v128_min_s8(v128_ssub_s8(b, x), sp), sm),
-                         v128_max_s8(v128_min_s8(v128_ssub_s8(e, x), sp), sm))),
-          v128_add_8(v128_add_8(tmp, tmp), tmp));
-      delta = v128_shr_s8(
-          v128_add_8(v128_dup_8(8),
-                     v128_add_8(delta, v128_cmplt_s8(delta, v128_zero()))),
-          4);
-      ssd0 = v128_ssd_u8(ssd0, o, q);
-      ssd1 = v128_ssd_u8(ssd1, o, v128_add_8(q, delta));
-      rec += rstride * 2;
-      org += ostride * 2;
-    }
-  } else {  // No left/right clipping
-    int y;
-    for (y = 0; y < 8; y += 2) {
-      const v64 k1 = v64_load_aligned(org);
-      const v64 k2 = v64_load_aligned(org + ostride);
-      const v64 l1 = v64_load_aligned(rec);
-      const v64 l2 = v64_load_aligned(rec + rstride);
-      v128 o = v128_from_v64(k1, k2);
-      const v128 q = v128_from_v64(l1, l2);
-      const v128 x = v128_add_8(c128, q);
-      const v128 a = v128_add_8(
-          c128,
-          v128_from_v64(v64_load_aligned(rec - (y != -y0) * rstride), l1));
-      const v128 b = v128_add_8(
-          c128, v128_from_v64(v64_load_unaligned(rec - 2),
-                              v64_load_unaligned(rec - 2 + rstride)));
-      const v128 c = v128_add_8(
-          c128, v128_from_v64(v64_load_unaligned(rec - 1),
-                              v64_load_unaligned(rec - 1 + rstride)));
-      const v128 d = v128_add_8(
-          c128, v128_from_v64(v64_load_unaligned(rec + 1),
-                              v64_load_unaligned(rec + 1 + rstride)));
-      const v128 e = v128_add_8(
-          c128, v128_from_v64(v64_load_unaligned(rec + 2),
-                              v64_load_unaligned(rec + 2 + rstride)));
-      const v128 f = v128_add_8(
-          c128, v128_from_v64(
-                    l2, v64_load_aligned(rec + ((y != bottom) + 1) * rstride)));
-
-      const v128 tmp =
-          v128_add_8(v128_max_s8(v128_min_s8(v128_ssub_s8(c, x), sp), sm),
-                     v128_max_s8(v128_min_s8(v128_ssub_s8(d, x), sp), sm));
-      v128 delta = v128_add_8(
-          v128_add_8(
-              v128_shl_8(
-                  v128_add_8(
-                      v128_max_s8(v128_min_s8(v128_ssub_s8(a, x), sp), sm),
-                      v128_max_s8(v128_min_s8(v128_ssub_s8(f, x), sp), sm)),
-                  2),
-              v128_add_8(v128_max_s8(v128_min_s8(v128_ssub_s8(b, x), sp), sm),
-                         v128_max_s8(v128_min_s8(v128_ssub_s8(e, x), sp), sm))),
-          v128_add_8(v128_add_8(tmp, tmp), tmp));
-      delta = v128_shr_s8(
-          v128_add_8(v128_dup_8(8),
-                     v128_add_8(delta, v128_cmplt_s8(delta, v128_zero()))),
-          4);
-
-      ssd0 = v128_ssd_u8(ssd0, o, q);
-      ssd1 = v128_ssd_u8(ssd1, o, v128_add_8(q, delta));
-      rec += rstride * 2;
-      org += ostride * 2;
-    }
+  for (y = 0; y < 8; y += 2) {
+    v128 a, b, c, d, e, f, o, r;
+    read_two_lines(rec, org, rstride, ostride, x0, y0, bottom, right, y, &o, &r,
+                   &a, &b, &c, &d, &e, &f);
+    ssd0 = v128_ssd_u8(ssd0, o, r);
+    ssd1 = v128_ssd_u8(ssd1, o, calc_delta(r, a, b, c, d, e, f, sp, sm));
+    rec += rstride * 2;
+    org += ostride * 2;
   }
   *sum0 += v128_ssd_u8_sum(ssd0);
   *sum1 += v128_ssd_u8_sum(ssd1);
 }
 
-// Test multiple filter strengths at once.  Use a simpler filter (4 tap, every
-// second line).
+SIMD_INLINE void calc_delta_multi(v128 r, v128 o, v128 a, v128 b, v128 c,
+                                  v128 d, v128 e, v128 f, ssd128_internal *ssd1,
+                                  ssd128_internal *ssd2,
+                                  ssd128_internal *ssd3) {
+  calc_diff(r, &a, &b, &c, &d, &e, &f);
+  *ssd1 = v128_ssd_u8(*ssd1, o, delta_kernel(r, a, b, c, d, e, f, v128_dup_8(1),
+                                             v128_dup_8(-1)));
+  *ssd2 = v128_ssd_u8(*ssd2, o, delta_kernel(r, a, b, c, d, e, f, v128_dup_8(2),
+                                             v128_dup_8(-2)));
+  *ssd3 = v128_ssd_u8(*ssd3, o, delta_kernel(r, a, b, c, d, e, f, v128_dup_8(4),
+                                             v128_dup_8(-4)));
+}
+
+// Test multiple filter strengths at once.
 void SIMD_FUNC(aom_clpf_detect_multi)(const uint8_t *rec, const uint8_t *org,
                                       int rstride, int ostride, int x0, int y0,
-                                      int width, int height, int *sum) {
-  const v128 c128 = v128_dup_8(128);
-  const v128 cp1 = v128_dup_8(1);
-  const v128 cm1 = v128_dup_8(-1);
-  const v128 cp2 = v128_dup_8(2);
-  const v128 cm2 = v128_dup_8(-2);
-  const v128 cp4 = v128_dup_8(4);
-  const v128 cm4 = v128_dup_8(-4);
-  const v128 c8 = v128_dup_8(8);
+                                      int width, int height, int *sum,
+                                      int size) {
   const int bottom = height - 2 - y0;
+  const int right = width - 8 - x0;
   ssd128_internal ssd0 = v128_ssd_u8_init();
   ssd128_internal ssd1 = v128_ssd_u8_init();
   ssd128_internal ssd2 = v128_ssd_u8_init();
   ssd128_internal ssd3 = v128_ssd_u8_init();
+  int y;
+
+  if (size != 8) {  // Fallback to plain C
+    aom_clpf_detect_multi_c(rec, org, rstride, ostride, x0, y0, width, height,
+                            sum, size);
+    return;
+  }
 
   rec += x0 + y0 * rstride;
   org += x0 + y0 * ostride;
 
-  if (!x0) {  // Clip left
-    const v128 b_shuff = v128_from_v64(v64_from_64(0x0d0c0b0a09080808LL),
-                                       v64_from_64(0x0504030201000000LL));
-    const v128 c_shuff = v128_from_v64(v64_from_64(0x0e0d0c0b0a090808LL),
-                                       v64_from_64(0x0605040302010000LL));
-    int y;
-
-    for (y = 0; y < 8; y += 2) {
-      const v64 k1 = v64_load_aligned(org);
-      const v64 k2 = v64_load_aligned(org + ostride);
-      const v64 l1 = v64_load_aligned(rec);
-      const v64 l2 = v64_load_aligned(rec + rstride);
-      v128 o = v128_from_v64(k1, k2);
-      const v128 q = v128_from_v64(l1, l2);
-      const v128 x = v128_add_8(c128, q);
-      v128 a = v128_add_8(
-          c128,
-          v128_from_v64(v64_load_aligned(rec - (y != -y0) * rstride), l1));
-      v128 b = v128_shuffle_8(x, b_shuff);
-      v128 c = v128_shuffle_8(x, c_shuff);
-      v128 d = v128_add_8(c128,
-                          v128_from_v64(v64_load_unaligned(rec + 1),
-                                        v64_load_unaligned(rec + 1 + rstride)));
-      v128 e = v128_add_8(c128,
-                          v128_from_v64(v64_load_unaligned(rec + 2),
-                                        v64_load_unaligned(rec + 2 + rstride)));
-      v128 f = v128_add_8(
-          c128, v128_from_v64(
-                    l2, v64_load_aligned(rec + ((y != bottom) + 1) * rstride)));
-      v128 tmp, delta1, delta2, delta3;
-
-      a = v128_ssub_s8(a, x);
-      b = v128_ssub_s8(b, x);
-      c = v128_ssub_s8(c, x);
-      d = v128_ssub_s8(d, x);
-      e = v128_ssub_s8(e, x);
-      f = v128_ssub_s8(f, x);
-      tmp = v128_add_8(v128_max_s8(v128_min_s8(c, cp1), cm1),
-                       v128_max_s8(v128_min_s8(d, cp1), cm1));
-      delta1 = v128_add_8(
-          v128_add_8(
-              v128_shl_8(v128_add_8(v128_max_s8(v128_min_s8(a, cp1), cm1),
-                                    v128_max_s8(v128_min_s8(f, cp1), cm1)),
-                         2),
-              v128_add_8(v128_max_s8(v128_min_s8(b, cp1), cm1),
-                         v128_max_s8(v128_min_s8(e, cp1), cm1))),
-          v128_add_8(v128_add_8(tmp, tmp), tmp));
-      tmp = v128_add_8(v128_max_s8(v128_min_s8(c, cp2), cm2),
-                       v128_max_s8(v128_min_s8(d, cp2), cm2));
-      delta2 = v128_add_8(
-          v128_add_8(
-              v128_shl_8(v128_add_8(v128_max_s8(v128_min_s8(a, cp2), cm2),
-                                    v128_max_s8(v128_min_s8(f, cp2), cm2)),
-                         2),
-              v128_add_8(v128_max_s8(v128_min_s8(b, cp2), cm2),
-                         v128_max_s8(v128_min_s8(e, cp2), cm2))),
-          v128_add_8(v128_add_8(tmp, tmp), tmp));
-      tmp = v128_add_8(v128_max_s8(v128_min_s8(c, cp4), cm4),
-                       v128_max_s8(v128_min_s8(d, cp4), cm4));
-      delta3 = v128_add_8(
-          v128_add_8(
-              v128_shl_8(v128_add_8(v128_max_s8(v128_min_s8(a, cp4), cm4),
-                                    v128_max_s8(v128_min_s8(f, cp4), cm4)),
-                         2),
-              v128_add_8(v128_max_s8(v128_min_s8(b, cp4), cm4),
-                         v128_max_s8(v128_min_s8(e, cp4), cm4))),
-          v128_add_8(v128_add_8(tmp, tmp), tmp));
-
-      ssd0 = v128_ssd_u8(ssd0, o, q);
-      ssd1 = v128_ssd_u8(
-          ssd1, o,
-          v128_add_8(
-              q,
-              v128_shr_s8(
-                  v128_add_8(c8, v128_add_8(delta1, v128_cmplt_s8(
-                                                        delta1, v128_zero()))),
-                  4)));
-      ssd2 = v128_ssd_u8(
-          ssd2, o,
-          v128_add_8(
-              q,
-              v128_shr_s8(
-                  v128_add_8(c8, v128_add_8(delta2, v128_cmplt_s8(
-                                                        delta2, v128_zero()))),
-                  4)));
-      ssd3 = v128_ssd_u8(
-          ssd3, o,
-          v128_add_8(
-              q,
-              v128_shr_s8(
-                  v128_add_8(c8, v128_add_8(delta3, v128_cmplt_s8(
-                                                        delta3, v128_zero()))),
-                  4)));
-      rec += 2 * rstride;
-      org += 2 * ostride;
-    }
-  } else if (!(width - x0 - 8)) {  // Clip right
-    const v128 d_shuff = v128_from_v64(v64_from_64(0x0f0f0e0d0c0b0a09LL),
-                                       v64_from_64(0x0707060504030201LL));
-    const v128 e_shuff = v128_from_v64(v64_from_64(0x0f0f0f0e0d0c0b0aLL),
-                                       v64_from_64(0x0707070605040302LL));
-    int y;
-
-    for (y = 0; y < 8; y += 2) {
-      const v64 k1 = v64_load_aligned(org);
-      const v64 k2 = v64_load_aligned(org + ostride);
-      const v64 l1 = v64_load_aligned(rec);
-      const v64 l2 = v64_load_aligned(rec + rstride);
-      v128 o = v128_from_v64(k1, k2);
-      const v128 q = v128_from_v64(l1, l2);
-      const v128 x = v128_add_8(c128, q);
-      v128 a = v128_add_8(
-          c128,
-          v128_from_v64(v64_load_aligned(rec - (y != -y0) * rstride), l1));
-      v128 b = v128_add_8(c128,
-                          v128_from_v64(v64_load_unaligned(rec - 2),
-                                        v64_load_unaligned(rec - 2 + rstride)));
-      v128 c = v128_add_8(c128,
-                          v128_from_v64(v64_load_unaligned(rec - 1),
-                                        v64_load_unaligned(rec - 1 + rstride)));
-      v128 d = v128_shuffle_8(x, d_shuff);
-      v128 e = v128_shuffle_8(x, e_shuff);
-      v128 f = v128_add_8(
-          c128, v128_from_v64(
-                    l2, v64_load_aligned(rec + ((y != bottom) + 1) * rstride)));
-      v128 tmp, delta1, delta2, delta3;
-
-      a = v128_ssub_s8(a, x);
-      b = v128_ssub_s8(b, x);
-      c = v128_ssub_s8(c, x);
-      d = v128_ssub_s8(d, x);
-      e = v128_ssub_s8(e, x);
-      f = v128_ssub_s8(f, x);
-      tmp = v128_add_8(v128_max_s8(v128_min_s8(c, cp1), cm1),
-                       v128_max_s8(v128_min_s8(d, cp1), cm1));
-      delta1 = v128_add_8(
-          v128_add_8(
-              v128_shl_8(v128_add_8(v128_max_s8(v128_min_s8(a, cp1), cm1),
-                                    v128_max_s8(v128_min_s8(f, cp1), cm1)),
-                         2),
-              v128_add_8(v128_max_s8(v128_min_s8(b, cp1), cm1),
-                         v128_max_s8(v128_min_s8(e, cp1), cm1))),
-          v128_add_8(v128_add_8(tmp, tmp), tmp));
-      tmp = v128_add_8(v128_max_s8(v128_min_s8(c, cp2), cm2),
-                       v128_max_s8(v128_min_s8(d, cp2), cm2));
-      delta2 = v128_add_8(
-          v128_add_8(
-              v128_shl_8(v128_add_8(v128_max_s8(v128_min_s8(a, cp2), cm2),
-                                    v128_max_s8(v128_min_s8(f, cp2), cm2)),
-                         2),
-              v128_add_8(v128_max_s8(v128_min_s8(b, cp2), cm2),
-                         v128_max_s8(v128_min_s8(e, cp2), cm2))),
-          v128_add_8(v128_add_8(tmp, tmp), tmp));
-      tmp = v128_add_8(v128_max_s8(v128_min_s8(c, cp4), cm4),
-                       v128_max_s8(v128_min_s8(d, cp4), cm4));
-      delta3 = v128_add_8(
-          v128_add_8(
-              v128_shl_8(v128_add_8(v128_max_s8(v128_min_s8(a, cp4), cm4),
-                                    v128_max_s8(v128_min_s8(f, cp4), cm4)),
-                         2),
-              v128_add_8(v128_max_s8(v128_min_s8(b, cp4), cm4),
-                         v128_max_s8(v128_min_s8(e, cp4), cm4))),
-          v128_add_8(v128_add_8(tmp, tmp), tmp));
-
-      ssd0 = v128_ssd_u8(ssd0, o, q);
-      ssd1 = v128_ssd_u8(
-          ssd1, o,
-          v128_add_8(
-              q,
-              v128_shr_s8(
-                  v128_add_8(c8, v128_add_8(delta1, v128_cmplt_s8(
-                                                        delta1, v128_zero()))),
-                  4)));
-      ssd2 = v128_ssd_u8(
-          ssd2, o,
-          v128_add_8(
-              q,
-              v128_shr_s8(
-                  v128_add_8(c8, v128_add_8(delta2, v128_cmplt_s8(
-                                                        delta2, v128_zero()))),
-                  4)));
-      ssd3 = v128_ssd_u8(
-          ssd3, o,
-          v128_add_8(
-              q,
-              v128_shr_s8(
-                  v128_add_8(c8, v128_add_8(delta3, v128_cmplt_s8(
-                                                        delta3, v128_zero()))),
-                  4)));
-      rec += 2 * rstride;
-      org += 2 * ostride;
-    }
-  } else {  // No left/right clipping
-    int y;
-    for (y = 0; y < 8; y += 2) {
-      const v64 k1 = v64_load_aligned(org);
-      const v64 k2 = v64_load_aligned(org + ostride);
-      const v64 l1 = v64_load_aligned(rec);
-      const v64 l2 = v64_load_aligned(rec + rstride);
-      v128 o = v128_from_v64(k1, k2);
-      const v128 q = v128_from_v64(l1, l2);
-      const v128 x = v128_add_8(c128, q);
-      v128 a = v128_add_8(
-          c128,
-          v128_from_v64(v64_load_aligned(rec - (y != -y0) * rstride), l1));
-      v128 b = v128_add_8(c128,
-                          v128_from_v64(v64_load_unaligned(rec - 2),
-                                        v64_load_unaligned(rec - 2 + rstride)));
-      v128 c = v128_add_8(c128,
-                          v128_from_v64(v64_load_unaligned(rec - 1),
-                                        v64_load_unaligned(rec - 1 + rstride)));
-      v128 d = v128_add_8(c128,
-                          v128_from_v64(v64_load_unaligned(rec + 1),
-                                        v64_load_unaligned(rec + 1 + rstride)));
-      v128 e = v128_add_8(c128,
-                          v128_from_v64(v64_load_unaligned(rec + 2),
-                                        v64_load_unaligned(rec + 2 + rstride)));
-      v128 f = v128_add_8(
-          c128, v128_from_v64(
-                    l2, v64_load_aligned(rec + ((y != bottom) + 1) * rstride)));
-      v128 tmp, delta1, delta2, delta3;
-
-      a = v128_ssub_s8(a, x);
-      b = v128_ssub_s8(b, x);
-      c = v128_ssub_s8(c, x);
-      d = v128_ssub_s8(d, x);
-      e = v128_ssub_s8(e, x);
-      f = v128_ssub_s8(f, x);
-      tmp = v128_add_8(v128_max_s8(v128_min_s8(c, cp1), cm1),
-                       v128_max_s8(v128_min_s8(d, cp1), cm1));
-      delta1 = v128_add_8(
-          v128_add_8(
-              v128_shl_8(v128_add_8(v128_max_s8(v128_min_s8(a, cp1), cm1),
-                                    v128_max_s8(v128_min_s8(f, cp1), cm1)),
-                         2),
-              v128_add_8(v128_max_s8(v128_min_s8(b, cp1), cm1),
-                         v128_max_s8(v128_min_s8(e, cp1), cm1))),
-          v128_add_8(v128_add_8(tmp, tmp), tmp));
-      tmp = v128_add_8(v128_max_s8(v128_min_s8(c, cp2), cm2),
-                       v128_max_s8(v128_min_s8(d, cp2), cm2));
-      delta2 = v128_add_8(
-          v128_add_8(
-              v128_shl_8(v128_add_8(v128_max_s8(v128_min_s8(a, cp2), cm2),
-                                    v128_max_s8(v128_min_s8(f, cp2), cm2)),
-                         2),
-              v128_add_8(v128_max_s8(v128_min_s8(b, cp2), cm2),
-                         v128_max_s8(v128_min_s8(e, cp2), cm2))),
-          v128_add_8(v128_add_8(tmp, tmp), tmp));
-      tmp = v128_add_8(v128_max_s8(v128_min_s8(c, cp4), cm4),
-                       v128_max_s8(v128_min_s8(d, cp4), cm4));
-      delta3 = v128_add_8(
-          v128_add_8(
-              v128_shl_8(v128_add_8(v128_max_s8(v128_min_s8(a, cp4), cm4),
-                                    v128_max_s8(v128_min_s8(f, cp4), cm4)),
-                         2),
-              v128_add_8(v128_max_s8(v128_min_s8(b, cp4), cm4),
-                         v128_max_s8(v128_min_s8(e, cp4), cm4))),
-          v128_add_8(v128_add_8(tmp, tmp), tmp));
-
-      ssd0 = v128_ssd_u8(ssd0, o, q);
-      ssd1 = v128_ssd_u8(
-          ssd1, o,
-          v128_add_8(
-              q,
-              v128_shr_s8(
-                  v128_add_8(c8, v128_add_8(delta1, v128_cmplt_s8(
-                                                        delta1, v128_zero()))),
-                  4)));
-      ssd2 = v128_ssd_u8(
-          ssd2, o,
-          v128_add_8(
-              q,
-              v128_shr_s8(
-                  v128_add_8(c8, v128_add_8(delta2, v128_cmplt_s8(
-                                                        delta2, v128_zero()))),
-                  4)));
-      ssd3 = v128_ssd_u8(
-          ssd3, o,
-          v128_add_8(
-              q,
-              v128_shr_s8(
-                  v128_add_8(c8, v128_add_8(delta3, v128_cmplt_s8(
-                                                        delta3, v128_zero()))),
-                  4)));
-      rec += 2 * rstride;
-      org += 2 * ostride;
-    }
+  for (y = 0; y < 8; y += 2) {
+    v128 a, b, c, d, e, f, o, r;
+    read_two_lines(rec, org, rstride, ostride, x0, y0, bottom, right, y, &o, &r,
+                   &a, &b, &c, &d, &e, &f);
+    ssd0 = v128_ssd_u8(ssd0, o, r);
+    calc_delta_multi(r, o, a, b, c, d, e, f, &ssd1, &ssd2, &ssd3);
+    rec += 2 * rstride;
+    org += 2 * ostride;
   }
   sum[0] += v128_ssd_u8_sum(ssd0);
   sum[1] += v128_ssd_u8_sum(ssd1);
   sum[2] += v128_ssd_u8_sum(ssd2);
   sum[3] += v128_ssd_u8_sum(ssd3);
 }
+
+#if CONFIG_AOM_HIGHBITDEPTH
+SIMD_INLINE void read_two_lines_hbd(const uint16_t *rec, const uint16_t *org,
+                                    int rstride, int ostride, int x0, int y0,
+                                    int bottom, int right, int y, v128 *o,
+                                    v128 *r, v128 *a, v128 *b, v128 *c, v128 *d,
+                                    v128 *e, v128 *f, int shift) {
+  const v128 n1 = v128_shr_u16(v128_load_aligned(rec), shift);
+  const v128 n2 = v128_shr_u16(v128_load_aligned(rec + rstride), shift);
+  *o = v128_unziplo_8(v128_shr_u16(v128_load_aligned(org), shift),
+                      v128_shr_u16(v128_load_aligned(org + ostride), shift));
+  *r = v128_unziplo_8(n1, n2);
+  *a = v128_unziplo_8(
+      v128_shr_u16(v128_load_aligned(rec - (y != -y0) * rstride), shift), n1);
+  *f = v128_unziplo_8(
+      n2, v128_shr_u16(v128_load_unaligned(rec + ((y != bottom) + 1) * rstride),
+                       shift));
+  *b = v128_unziplo_8(
+      v128_shr_u16(v128_load_unaligned(rec - 2 * !!x0), shift),
+      v128_shr_u16(v128_load_unaligned(rec - 2 * !!x0 + rstride), shift));
+  *c = v128_unziplo_8(
+      v128_shr_u16(v128_load_unaligned(rec - !!x0), shift),
+      v128_shr_u16(v128_load_unaligned(rec - !!x0 + rstride), shift));
+  *d = v128_unziplo_8(
+      v128_shr_u16(v128_load_unaligned(rec + !!right), shift),
+      v128_shr_u16(v128_load_unaligned(rec + !!right + rstride), shift));
+  *e = v128_unziplo_8(
+      v128_shr_u16(v128_load_unaligned(rec + 2 * !!right), shift),
+      v128_shr_u16(v128_load_unaligned(rec + 2 * !!right + rstride), shift));
+  clip_sides(b, c, d, e, x0, right);
+}
+
+void SIMD_FUNC(aom_clpf_detect_hbd)(const uint16_t *rec, const uint16_t *org,
+                                    int rstride, int ostride, int x0, int y0,
+                                    int width, int height, int *sum0, int *sum1,
+                                    unsigned int strength, int shift,
+                                    int size) {
+  const v128 sp = v128_dup_8(strength >> shift);
+  const v128 sm = v128_dup_8(-(int)(strength >> shift));
+  const int bottom = height - 2 - y0;
+  const int right = width - 8 - x0;
+  ssd128_internal ssd0 = v128_ssd_u8_init();
+  ssd128_internal ssd1 = v128_ssd_u8_init();
+  int y;
+
+  if (size != 8) {  // Fallback to plain C
+    aom_clpf_detect_hbd_c(rec, org, rstride, ostride, x0, y0, width, height,
+                          sum0, sum1, strength, shift, size);
+    return;
+  }
+
+  rec += x0 + y0 * rstride;
+  org += x0 + y0 * ostride;
+
+  for (y = 0; y < 8; y += 2) {
+    v128 a, b, c, d, e, f, o, r;
+    read_two_lines_hbd(rec, org, rstride, ostride, x0, y0, bottom, right, y, &o,
+                       &r, &a, &b, &c, &d, &e, &f, shift);
+    ssd0 = v128_ssd_u8(ssd0, o, r);
+    ssd1 = v128_ssd_u8(ssd1, o, calc_delta(r, a, b, c, d, e, f, sp, sm));
+    rec += rstride * 2;
+    org += ostride * 2;
+  }
+  *sum0 += v128_ssd_u8_sum(ssd0);
+  *sum1 += v128_ssd_u8_sum(ssd1);
+}
+
+void SIMD_FUNC(aom_clpf_detect_multi_hbd)(const uint16_t *rec,
+                                          const uint16_t *org, int rstride,
+                                          int ostride, int x0, int y0,
+                                          int width, int height, int *sum,
+                                          int shift, int size) {
+  const int bottom = height - 2 - y0;
+  const int right = width - 8 - x0;
+  ssd128_internal ssd0 = v128_ssd_u8_init();
+  ssd128_internal ssd1 = v128_ssd_u8_init();
+  ssd128_internal ssd2 = v128_ssd_u8_init();
+  ssd128_internal ssd3 = v128_ssd_u8_init();
+  int y;
+
+  if (size != 8) {  // Fallback to plain C
+    aom_clpf_detect_multi_hbd_c(rec, org, rstride, ostride, x0, y0, width,
+                                height, sum, shift, size);
+    return;
+  }
+
+  rec += x0 + y0 * rstride;
+  org += x0 + y0 * ostride;
+
+  for (y = 0; y < 8; y += 2) {
+    v128 a, b, c, d, e, f, o, r;
+    read_two_lines_hbd(rec, org, rstride, ostride, x0, y0, bottom, right, y, &o,
+                       &r, &a, &b, &c, &d, &e, &f, shift);
+    ssd0 = v128_ssd_u8(ssd0, o, r);
+    calc_delta_multi(r, o, a, b, c, d, e, f, &ssd1, &ssd2, &ssd3);
+    rec += 2 * rstride;
+    org += 2 * ostride;
+  }
+  sum[0] += v128_ssd_u8_sum(ssd0);
+  sum[1] += v128_ssd_u8_sum(ssd1);
+  sum[2] += v128_ssd_u8_sum(ssd2);
+  sum[3] += v128_ssd_u8_sum(ssd3);
+}
+#endif
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index 87e7d51..2eecee4 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -815,7 +815,9 @@
   AV1_COMMON *const cm = &cpi->common;
   MACROBLOCKD *const xd = &x->e_mbd;
   VAR_TREE *const vt = td->var_root[cm->mib_size_log2 - MIN_MIB_SIZE_LOG2];
+#if CONFIG_DUAL_FILTER
   int i;
+#endif
   const uint8_t *src;
   const uint8_t *ref;
   int src_stride;
@@ -859,7 +861,6 @@
 
   if (!is_key_frame) {
     MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
-    unsigned int uv_sad;
     const YV12_BUFFER_CONFIG *yv12 = get_ref_frame_buffer(cpi, LAST_FRAME);
     const YV12_BUFFER_CONFIG *yv12_g = get_ref_frame_buffer(cpi, GOLDEN_FRAME);
     unsigned int y_sad, y_sad_g;
@@ -916,20 +917,6 @@
 
     av1_build_inter_predictors_sb(xd, mi_row, mi_col, cm->sb_size);
 
-    for (i = 1; i < MAX_MB_PLANE; ++i) {
-      struct macroblock_plane *p = &x->plane[i];
-      struct macroblockd_plane *pd = &xd->plane[i];
-      const BLOCK_SIZE bs = get_plane_block_size(bsize, pd);
-
-      if (bs == BLOCK_INVALID)
-        uv_sad = UINT_MAX;
-      else
-        uv_sad = cpi->fn_ptr[bs].sdf(p->src.buf, p->src.stride, pd->dst.buf,
-                                     pd->dst.stride);
-
-      x->color_sensitivity[i - 1] = uv_sad > (y_sad >> 2);
-    }
-
     ref = xd->plane[0].dst.buf;
     ref_stride = xd->plane[0].dst.stride;
 
diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index 69a7cf8..983f8cc 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -16,6 +16,7 @@
 
 #include "av1/common/alloccommon.h"
 #if CONFIG_CLPF
+#include "aom/aom_image.h"
 #include "av1/common/clpf.h"
 #include "av1/encoder/clpf_rdo.h"
 #endif
@@ -3423,7 +3424,7 @@
 #endif
   }
 #if CONFIG_CLPF
-  cm->clpf_strength = 0;
+  cm->clpf_strength_y = cm->clpf_strength_u = cm->clpf_strength_v = 0;
   cm->clpf_size = 2;
   CHECK_MEM_ERROR(
       cm, cm->clpf_blocks,
@@ -3431,35 +3432,33 @@
                      ((cm->frame_to_show->y_crop_height + 31) & ~31) >>
                  10));
   if (!is_lossless_requested(&cpi->oxcf)) {
-    // Test CLPF
-    int i, hq = 1;
-    // TODO(yaowu): investigate per-segment CLPF decision and
-    // an optimal threshold, use 80 for now.
-    for (i = 0; i < MAX_SEGMENTS; i++)
-      hq &= av1_get_qindex(&cm->seg, i, cm->base_qindex) < 80;
+    const YV12_BUFFER_CONFIG *const frame = cm->frame_to_show;
 
-    // Don't try filter if the entire image is nearly losslessly encoded
-    if (!hq) {
-      // Find the best strength and block size for the entire frame
-      int fb_size_log2, strength;
-      av1_clpf_test_frame(&cpi->last_frame_uf, cpi->Source, cm, &strength,
-                          &fb_size_log2);
+    // Find the best strength and block size for the entire frame
+    int fb_size_log2, strength_y, strength_u, strength_v;
+    av1_clpf_test_frame(frame, cpi->Source, cm, &strength_y, &fb_size_log2,
+                        AOM_PLANE_Y);
+    av1_clpf_test_frame(frame, cpi->Source, cm, &strength_u, 0, AOM_PLANE_U);
+    av1_clpf_test_frame(frame, cpi->Source, cm, &strength_v, 0, AOM_PLANE_V);
 
-      if (!fb_size_log2) fb_size_log2 = get_msb(MAX_FB_SIZE);
-
-      if (!strength) {  // Better to disable for the whole frame?
-        cm->clpf_strength = 0;
-      } else {
-        // Apply the filter using the chosen strength
-        cm->clpf_strength = strength - (strength == 4);
-        cm->clpf_size =
-            fb_size_log2 ? fb_size_log2 - get_msb(MAX_FB_SIZE) + 3 : 0;
-        aom_yv12_copy_frame(cm->frame_to_show, &cpi->last_frame_uf);
-        cm->clpf_numblocks =
-            av1_clpf_frame(cm->frame_to_show, &cpi->last_frame_uf, cpi->Source,
-                           cm, !!cm->clpf_size, strength, 4 + cm->clpf_size,
-                           cm->clpf_blocks, av1_clpf_decision);
-      }
+    if (strength_y) {
+      // Apply the filter using the chosen strength
+      cm->clpf_strength_y = strength_y - (strength_y == 4);
+      cm->clpf_size =
+          fb_size_log2 ? fb_size_log2 - get_msb(MAX_FB_SIZE) + 3 : 0;
+      cm->clpf_numblocks = av1_clpf_frame(
+          frame, cpi->Source, cm, !!cm->clpf_size, strength_y,
+          4 + cm->clpf_size, cm->clpf_blocks, AOM_PLANE_Y, av1_clpf_decision);
+    }
+    if (strength_u) {
+      cm->clpf_strength_u = strength_u - (strength_u == 4);
+      av1_clpf_frame(frame, NULL, cm, 0, strength_u, 4, NULL, AOM_PLANE_U,
+                     NULL);
+    }
+    if (strength_v) {
+      cm->clpf_strength_v = strength_v - (strength_v == 4);
+      av1_clpf_frame(frame, NULL, cm, 0, strength_v, 4, NULL, AOM_PLANE_V,
+                     NULL);
     }
   }
 #endif
diff --git a/av1/encoder/treewriter.h b/av1/encoder/treewriter.h
index 533e7d9..9a4cb86 100644
--- a/av1/encoder/treewriter.h
+++ b/av1/encoder/treewriter.h
@@ -29,20 +29,10 @@
 
 void av1_tokens_from_tree(struct av1_token *, const aom_tree_index *);
 
-static INLINE void av1_write_tree(aom_writer *w, const aom_tree_index *tree,
-                                  const aom_prob *probs, int bits, int len,
-                                  aom_tree_index i) {
-  do {
-    const int bit = (bits >> --len) & 1;
-    aom_write(w, bit, probs[i >> 1]);
-    i = tree[i + bit];
-  } while (len);
-}
-
 static INLINE void av1_write_token(aom_writer *w, const aom_tree_index *tree,
                                    const aom_prob *probs,
                                    const struct av1_token *token) {
-  av1_write_tree(w, tree, probs, token->value, token->len, 0);
+  aom_write_tree(w, tree, probs, token->value, token->len, 0);
 }
 
 #ifdef __cplusplus
diff --git a/configure b/configure
index c96691ba..1bc0863 100755
--- a/configure
+++ b/configure
@@ -606,12 +606,7 @@
         check_add_cflags -Wuninitialized
         check_add_cflags -Wunused-variable
         case ${CC} in
-          *clang*)
-              # libaom and/or clang have issues with aliasing:
-              # https://code.google.com/p/webm/issues/detail?id=603
-              # work around them until they are fixed
-              check_add_cflags -fno-strict-aliasing
-          ;;
+          *clang*) ;;
           *) check_add_cflags -Wunused-but-set-variable ;;
         esac
         if enabled mips || [ -z "${INLINE}" ]; then
diff --git a/examples/lossless_encoder.c b/examples/lossless_encoder.c
index 7676226..069e35e 100644
--- a/examples/lossless_encoder.c
+++ b/examples/lossless_encoder.c
@@ -1,11 +1,12 @@
 /*
- *  Copyright (c) 2014 The WebM project authors. All Rights Reserved.
+ * Copyright (c) 2016, Alliance for Open Media. All rights reserved
  *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
+ * 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 <stdio.h>
diff --git a/test/clpf_test.cc b/test/clpf_test.cc
index 786180b..24d7bb3 100644
--- a/test/clpf_test.cc
+++ b/test/clpf_test.cc
@@ -26,9 +26,9 @@
 
 namespace {
 
-typedef void (*clpf_block_t)(const uint8_t *src, uint8_t *dst, int stride,
-                             int x0, int y0, int sizex, int sizey, int width,
-                             int height, unsigned int strength);
+typedef void (*clpf_block_t)(const uint8_t *src, uint8_t *dst, int sstride,
+                             int dstride, int x0, int y0, int sizex, int sizey,
+                             int width, int height, unsigned int strength);
 
 typedef std::tr1::tuple<clpf_block_t, clpf_block_t, int, int>
     clpf_block_param_t;
@@ -54,44 +54,84 @@
 
 typedef ClpfBlockTest ClpfSpeedTest;
 
-TEST_P(ClpfBlockTest, TestSIMDNoMismatch) {
-  int w = sizex;
-  int h = sizey;
-  const int size = 32;
-  ACMRandom rnd(ACMRandom::DeterministicSeed());
-  DECLARE_ALIGNED(16, uint8_t, s[size * size]);
-  DECLARE_ALIGNED(16, uint8_t, d[size * size]);
-  DECLARE_ALIGNED(16, uint8_t, ref_d[size * size]);
-  memset(ref_d, 0, size * size);
-  memset(d, 0, size * size);
+#if CONFIG_AOM_HIGHBITDEPTH
+typedef void (*clpf_block_hbd_t)(const uint16_t *src, uint16_t *dst,
+                                 int sstride, int dstride, int x0, int y0,
+                                 int sizex, int sizey, int width, int height,
+                                 unsigned int strength);
 
-  int error = 0;
-  int pos = 0;
-  int strength = 0;
-  int xpos = 0, ypos = 0;
-  int bits;
-  int level;
+typedef std::tr1::tuple<clpf_block_hbd_t, clpf_block_hbd_t, int, int>
+    clpf_block_hbd_param_t;
+
+class ClpfBlockHbdTest
+    : public ::testing::TestWithParam<clpf_block_hbd_param_t> {
+ public:
+  virtual ~ClpfBlockHbdTest() {}
+  virtual void SetUp() {
+    clpf = GET_PARAM(0);
+    ref_clpf = GET_PARAM(1);
+    sizex = GET_PARAM(2);
+    sizey = GET_PARAM(3);
+  }
+
+  virtual void TearDown() { libaom_test::ClearSystemState(); }
+
+ protected:
+  int sizex;
+  int sizey;
+  clpf_block_hbd_t clpf;
+  clpf_block_hbd_t ref_clpf;
+};
+
+typedef ClpfBlockHbdTest ClpfHbdSpeedTest;
+#endif
+
+template <typename pixel>
+void test_clpf(int w, int h, int depth, int iterations,
+               void (*clpf)(const pixel *src, pixel *dst, int sstride,
+                            int dstride, int x0, int y0, int sizex, int sizey,
+                            int width, int height, unsigned int strength),
+               void (*ref_clpf)(const pixel *src, pixel *dst, int sstride,
+                                int dstride, int x0, int y0, int sizex,
+                                int sizey, int width, int height,
+                                unsigned int strength)) {
+  const int size = 24;
+  ACMRandom rnd(ACMRandom::DeterministicSeed());
+  DECLARE_ALIGNED(16, pixel, s[size * size]);
+  DECLARE_ALIGNED(16, pixel, d[size * size]);
+  DECLARE_ALIGNED(16, pixel, ref_d[size * size]);
+  memset(ref_d, 0, size * size * sizeof(*ref_d));
+  memset(d, 0, size * size * sizeof(*d));
+
+  int error = 0, pos = 0, strength = 0, xpos = 0, ypos = 0;
+  int bits, level, count;
 
   // Test every combination of:
-  // * Input with 1-8 bits of noise
-  // * Noise level around every value from 0 to 255
+  // * Input with up to <depth> bits of noise
+  // * Noise level around every value from 0 to (1<<depth)-1
   // * Blocks anywhere in the frame (along all egdes and also fully inside)
   // * All strengths
-  for (level = 0; level < 256 && !error; level++) {
-    for (bits = 1; bits < 9 && !error; bits++) {
-      for (int i = 0; i < size * size; i++)
-        s[i] = clamp((rnd.Rand8() & ((1 << bits) - 1)) + level, 0, 255);
+  // If clpf and ref_clpf are the same, we're just testing speed
+  for (count = 0; count < iterations; count++) {
+    for (level = 0; level < (1 << depth) && !error; level++) {
+      for (bits = 1; bits <= depth && !error; bits++) {
+        for (int i = 0; i < size * size; i++)
+          s[i] = clamp((rnd.Rand16() & ((1 << bits) - 1)) + level, 0,
+                       (1 << depth) - 1);
 
-      for (ypos = 0; ypos < size && !error; ypos += h * !error) {
-        for (xpos = 0; xpos < size && !error; xpos += w * !error) {
-          for (strength = 0; strength < 3 && !error; strength += !error) {
-            ref_clpf(s, ref_d, size, xpos, ypos, w, h, size, size,
-                     1 << strength);
-            ASM_REGISTER_STATE_CHECK(
-                clpf(s, d, size, xpos, ypos, w, h, size, size, 1 << strength));
-
-            for (pos = 0; pos < size * size && !error; pos++) {
-              error = ref_d[pos] != d[pos];
+        for (ypos = 0; ypos < size && !error; ypos += h * !error) {
+          for (xpos = 0; xpos < size && !error; xpos += w * !error) {
+            for (strength = depth - 8; strength < depth - 5 && !error;
+                 strength += !error) {
+              ref_clpf(s, ref_d, size, size, xpos, ypos, w, h, size, size,
+                       1 << strength);
+              if (clpf != ref_clpf)
+                ASM_REGISTER_STATE_CHECK(clpf(s, d, size, size, xpos, ypos, w,
+                                              h, size, size, 1 << strength));
+              if (ref_clpf != clpf)
+                for (pos = 0; pos < size * size && !error; pos++) {
+                  error = ref_d[pos] != d[pos];
+                }
             }
           }
         }
@@ -99,6 +139,7 @@
     }
   }
 
+  pos--;
   EXPECT_EQ(0, error)
       << "Error: ClpfBlockTest, SIMD and C mismatch." << std::endl
       << "First error at " << pos % size << "," << pos / size << " ("
@@ -106,6 +147,8 @@
       << "strength: " << (1 << strength) << std::endl
       << "xpos: " << xpos << std::endl
       << "ypos: " << ypos << std::endl
+      << "w: " << w << std::endl
+      << "h: " << h << std::endl
       << "A=" << (pos > size ? (int16_t)s[pos - size] : -1) << std::endl
       << "B=" << (pos % size - 2 >= 0 ? (int16_t)s[pos - 2] : -1) << std::endl
       << "C=" << (pos % size - 1 >= 0 ? (int16_t)s[pos - 1] : -1) << std::endl
@@ -116,45 +159,26 @@
       << std::endl;
 }
 
-TEST_P(ClpfSpeedTest, TestSpeed) {
-  int w = sizex;
-  int h = sizey;
-  const int size = 32;
-  ACMRandom rnd(ACMRandom::DeterministicSeed());
-  DECLARE_ALIGNED(16, uint8_t, s[size * size]);
-  DECLARE_ALIGNED(16, uint8_t, d[size * size]);
-
-  int strength;
-  int xpos, ypos;
-
-  for (int i = 0; i < size * size; i++) s[i] = rnd.Rand8();
-
+template <typename pixel>
+void test_clpf_speed(int w, int h, int depth, int iterations,
+                     void (*clpf)(const pixel *src, pixel *dst, int sstride,
+                                  int dstride, int x0, int y0, int sizex,
+                                  int sizey, int width, int height,
+                                  unsigned int strength),
+                     void (*ref_clpf)(const pixel *src, pixel *dst, int sstride,
+                                      int dstride, int x0, int y0, int sizex,
+                                      int sizey, int width, int height,
+                                      unsigned int strength)) {
   aom_usec_timer ref_timer;
   aom_usec_timer timer;
 
   aom_usec_timer_start(&ref_timer);
-  for (int c = 0; c < 65536; c++) {
-    for (ypos = 0; ypos < size; ypos += h) {
-      for (xpos = 0; xpos < size; xpos += w) {
-        for (strength = 0; strength < 3; strength++) {
-          ref_clpf(s, d, size, xpos, ypos, w, h, size, size, 1 << strength);
-        }
-      }
-    }
-  }
+  test_clpf(w, h, depth, iterations, ref_clpf, ref_clpf);
   aom_usec_timer_mark(&ref_timer);
   int ref_elapsed_time = aom_usec_timer_elapsed(&ref_timer);
 
   aom_usec_timer_start(&timer);
-  for (int c = 0; c < 65536; c++) {
-    for (ypos = 0; ypos < size; ypos += h) {
-      for (xpos = 0; xpos < size; xpos += w) {
-        for (strength = 0; strength < 3; strength++) {
-          clpf(s, d, size, xpos, ypos, w, h, size, size, 1 << strength);
-        }
-      }
-    }
-  }
+  test_clpf(w, h, depth, iterations, clpf, clpf);
   aom_usec_timer_mark(&timer);
   int elapsed_time = aom_usec_timer_elapsed(&timer);
 
@@ -165,10 +189,28 @@
 
   EXPECT_GT(ref_elapsed_time, elapsed_time)
       << "Error: ClpfSpeedTest, SIMD slower than C." << std::endl
-      << "C time: " << ref_elapsed_time << "ms" << std::endl
-      << "SIMD time: " << elapsed_time << "ms" << std::endl;
+      << "C time: " << ref_elapsed_time << " us" << std::endl
+      << "SIMD time: " << elapsed_time << " us" << std::endl;
 }
 
+TEST_P(ClpfBlockTest, TestSIMDNoMismatch) {
+  test_clpf(sizex, sizey, 8, 1, clpf, ref_clpf);
+}
+
+TEST_P(ClpfSpeedTest, TestSpeed) {
+  test_clpf_speed(sizex, sizey, 8, 16, clpf, ref_clpf);
+}
+
+#if CONFIG_AOM_HIGHBITDEPTH
+TEST_P(ClpfBlockHbdTest, TestSIMDNoMismatch) {
+  test_clpf(sizex, sizey, 12, 1, clpf, ref_clpf);
+}
+
+TEST_P(ClpfHbdSpeedTest, TestSpeed) {
+  test_clpf_speed(sizex, sizey, 12, 1, clpf, ref_clpf);
+}
+#endif
+
 using std::tr1::make_tuple;
 
 // Test all supported architectures and block sizes
@@ -212,6 +254,48 @@
                                  4)));
 #endif
 
+#if CONFIG_AOM_HIGHBITDEPTH
+#if HAVE_SSE2
+INSTANTIATE_TEST_CASE_P(
+    SSE2, ClpfBlockHbdTest,
+    ::testing::Values(
+        make_tuple(&aom_clpf_block_hbd_sse2, &aom_clpf_block_hbd_c, 8, 8),
+        make_tuple(&aom_clpf_block_hbd_sse2, &aom_clpf_block_hbd_c, 8, 4),
+        make_tuple(&aom_clpf_block_hbd_sse2, &aom_clpf_block_hbd_c, 4, 8),
+        make_tuple(&aom_clpf_block_hbd_sse2, &aom_clpf_block_hbd_c, 4, 4)));
+#endif
+
+#if HAVE_SSSE3
+INSTANTIATE_TEST_CASE_P(
+    SSSE3, ClpfBlockHbdTest,
+    ::testing::Values(
+        make_tuple(&aom_clpf_block_hbd_ssse3, &aom_clpf_block_hbd_c, 8, 8),
+        make_tuple(&aom_clpf_block_hbd_ssse3, &aom_clpf_block_hbd_c, 8, 4),
+        make_tuple(&aom_clpf_block_hbd_ssse3, &aom_clpf_block_hbd_c, 4, 8),
+        make_tuple(&aom_clpf_block_hbd_ssse3, &aom_clpf_block_hbd_c, 4, 4)));
+#endif
+
+#if HAVE_SSE4_1
+INSTANTIATE_TEST_CASE_P(
+    SSSE4_1, ClpfBlockHbdTest,
+    ::testing::Values(
+        make_tuple(&aom_clpf_block_hbd_sse4_1, &aom_clpf_block_hbd_c, 8, 8),
+        make_tuple(&aom_clpf_block_hbd_sse4_1, &aom_clpf_block_hbd_c, 8, 4),
+        make_tuple(&aom_clpf_block_hbd_sse4_1, &aom_clpf_block_hbd_c, 4, 8),
+        make_tuple(&aom_clpf_block_hbd_sse4_1, &aom_clpf_block_hbd_c, 4, 4)));
+#endif
+
+#if HAVE_NEON
+INSTANTIATE_TEST_CASE_P(
+    NEON, ClpfBlockHbdTest,
+    ::testing::Values(
+        make_tuple(&aom_clpf_block_hbd_neon, &aom_clpf_block_hbd_c, 8, 8),
+        make_tuple(&aom_clpf_block_hbd_neon, &aom_clpf_block_hbd_c, 8, 4),
+        make_tuple(&aom_clpf_block_hbd_neon, &aom_clpf_block_hbd_c, 4, 8),
+        make_tuple(&aom_clpf_block_hbd_neon, &aom_clpf_block_hbd_c, 4, 4)));
+#endif
+#endif
+
 // Test speed for all supported architectures
 #if HAVE_SSE2
 INSTANTIATE_TEST_CASE_P(SSE2, ClpfSpeedTest,
@@ -236,4 +320,35 @@
                         ::testing::Values(make_tuple(&aom_clpf_block_neon,
                                                      &aom_clpf_block_c, 8, 8)));
 #endif
+
+#if CONFIG_AOM_HIGHBITDEPTH
+#if HAVE_SSE2
+INSTANTIATE_TEST_CASE_P(SSE2, ClpfHbdSpeedTest,
+                        ::testing::Values(make_tuple(&aom_clpf_block_hbd_sse2,
+                                                     &aom_clpf_block_hbd_c, 8,
+                                                     8)));
+#endif
+
+#if HAVE_SSSE3
+INSTANTIATE_TEST_CASE_P(SSSE3, ClpfHbdSpeedTest,
+                        ::testing::Values(make_tuple(&aom_clpf_block_hbd_ssse3,
+                                                     &aom_clpf_block_hbd_c, 8,
+                                                     8)));
+#endif
+
+#if HAVE_SSE4_1
+INSTANTIATE_TEST_CASE_P(SSSE4_1, ClpfHbdSpeedTest,
+                        ::testing::Values(make_tuple(&aom_clpf_block_hbd_ssse3,
+                                                     &aom_clpf_block_hbd_c, 8,
+                                                     8)));
+#endif
+
+#if HAVE_NEON
+INSTANTIATE_TEST_CASE_P(NEON, ClpfHbdSpeedTest,
+                        ::testing::Values(make_tuple(&aom_clpf_block_hbd_neon,
+                                                     &aom_clpf_block_hbd_c, 8,
+                                                     8)));
+#endif
+#endif
+
 }  // namespace
diff --git a/test/cx_set_ref.sh b/test/cx_set_ref.sh
deleted file mode 100755
index dfba40d..0000000
--- a/test/cx_set_ref.sh
+++ /dev/null
@@ -1,61 +0,0 @@
-#!/bin/sh
-##
-##  Copyright (c) 2016 The WebM project authors. All Rights Reserved.
-##
-##  Use of this source code is governed by a BSD-style license
-##  that can be found in the LICENSE file in the root of the source
-##  tree. An additional intellectual property rights grant can be found
-##  in the file PATENTS.  All contributing project authors may
-##  be found in the AUTHORS file in the root of the source tree.
-##
-##  This file tests the libaom cx_set_ref example. To add new tests to this
-##  file, do the following:
-##    1. Write a shell function (this is your test).
-##    2. Add the function to cx_set_ref_tests (on a new line).
-##
-. $(dirname $0)/tools_common.sh
-
-# Environment check: $YUV_RAW_INPUT is required.
-cx_set_ref_verify_environment() {
-  if [ ! -e "${YUV_RAW_INPUT}" ]; then
-    echo "Libaom test data must exist in LIBVPX_TEST_DATA_PATH."
-    return 1
-  fi
-}
-
-# Runs cx_set_ref and updates the reference frame before encoding frame 90.
-# $1 is the codec name.
-aom_set_ref() {
-  local codec="$1"
-  local encoder="${LIBAOM_BIN_PATH}/aom_cx_set_ref${AOM_TEST_EXE_SUFFIX}"
-
-  local output_file="${AOM_TEST_OUTPUT_DIR}/${codec}cx_set_ref_${codec}.ivf"
-  local ref_frame_num=90
-
-  if [ ! -x "${encoder}" ]; then
-    elog "${encoder} does not exist or is not executable."
-    return 1
-  fi
-
-  if [ "$codec" = "vp8" ]; then
-    eval "${AOM_TEST_PREFIX}" "${encoder}" "${YUV_RAW_INPUT_WIDTH}" \
-        "${YUV_RAW_INPUT_HEIGHT}" "${YUV_RAW_INPUT}" "${output_file}" \
-        "${ref_frame_num}" ${devnull}
-  else
-    eval "${AOM_TEST_PREFIX}" "${encoder}" "${codec}" "${YUV_RAW_INPUT_WIDTH}" \
-        "${YUV_RAW_INPUT_HEIGHT}" "${YUV_RAW_INPUT}" "${output_file}" \
-        "${ref_frame_num}" ${devnull}
-  fi
-
-  [ -e "${output_file}" ] || return 1
-}
-
-cx_set_ref_av1() {
-  if [ "$(av1_encode_available)" = "yes" ]; then
-    aom_set_ref av1 || return 1
-  fi
-}
-
-cx_set_ref_tests="cx_set_ref_av1"
-
-run_tests cx_set_ref_verify_environment "${cx_set_ref_tests}"
diff --git a/test/vpxdec.sh b/test/vpxdec.sh
deleted file mode 100755
index 7c5169d..0000000
--- a/test/vpxdec.sh
+++ /dev/null
@@ -1,116 +0,0 @@
-#!/bin/sh
-##
-##  Copyright (c) 2014 The WebM project authors. All Rights Reserved.
-##
-##  Use of this source code is governed by a BSD-style license
-##  that can be found in the LICENSE file in the root of the source
-##  tree. An additional intellectual property rights grant can be found
-##  in the file PATENTS.  All contributing project authors may
-##  be found in the AUTHORS file in the root of the source tree.
-##
-##  This file tests aomdec. To add new tests to this file, do the following:
-##    1. Write a shell function (this is your test).
-##    2. Add the function to aomdec_tests (on a new line).
-##
-. $(dirname $0)/tools_common.sh
-
-# Environment check: Make sure input is available.
-aomdec_verify_environment() {
-  if [ ! -e "${VP8_IVF_FILE}" ] || [ ! -e "${AV1_WEBM_FILE}" ] || \
-    [ ! -e "${AV1_FPM_WEBM_FILE}" ] || \
-    [ ! -e "${AV1_LT_50_FRAMES_WEBM_FILE}" ] ; then
-    elog "Libaom test data must exist in LIBVPX_TEST_DATA_PATH."
-    return 1
-  fi
-  if [ -z "$(aom_tool_path aomdec)" ]; then
-    elog "aomdec not found. It must exist in LIBAOM_BIN_PATH or its parent."
-    return 1
-  fi
-}
-
-# Wrapper function for running aomdec with pipe input. Requires that
-# LIBAOM_BIN_PATH points to the directory containing aomdec. $1 is used as the
-# input file path and shifted away. All remaining parameters are passed through
-# to aomdec.
-aomdec_pipe() {
-  local readonly decoder="$(aom_tool_path aomdec)"
-  local readonly input="$1"
-  shift
-  cat "${input}" | eval "${AOM_TEST_PREFIX}" "${decoder}" - "$@" ${devnull}
-}
-
-# Wrapper function for running aomdec. Requires that LIBAOM_BIN_PATH points to
-# the directory containing aomdec. $1 one is used as the input file path and
-# shifted away. All remaining parameters are passed through to aomdec.
-aomdec() {
-  local readonly decoder="$(aom_tool_path aomdec)"
-  local readonly input="$1"
-  shift
-  eval "${AOM_TEST_PREFIX}" "${decoder}" "$input" "$@" ${devnull}
-}
-
-aomdec_can_decode_vp8() {
-  if [ "$(vp8_decode_available)" = "yes" ]; then
-    echo yes
-  fi
-}
-
-aomdec_can_decode_vp9() {
-  if [ "$(vp9_decode_available)" = "yes" ]; then
-    echo yes
-  fi
-}
-
-aomdec_vp8_ivf() {
-  if [ "$(aomdec_can_decode_vp8)" = "yes" ]; then
-    aomdec "${VP8_IVF_FILE}" --summary --noblit
-  fi
-}
-
-aomdec_vp8_ivf_pipe_input() {
-  if [ "$(aomdec_can_decode_vp8)" = "yes" ]; then
-    aomdec_pipe "${VP8_IVF_FILE}" --summary --noblit
-  fi
-}
-
-aomdec_vp9_webm() {
-  if [ "$(aomdec_can_decode_vp9)" = "yes" ] && \
-     [ "$(webm_io_available)" = "yes" ]; then
-    aomdec "${AV1_WEBM_FILE}" --summary --noblit
-  fi
-}
-
-aomdec_vp9_webm_frame_parallel() {
-  if [ "$(aomdec_can_decode_vp9)" = "yes" ] && \
-     [ "$(webm_io_available)" = "yes" ]; then
-    for threads in 2 3 4 5 6 7 8; do
-      aomdec "${AV1_FPM_WEBM_FILE}" --summary --noblit --threads=$threads \
-        --frame-parallel
-    done
-  fi
-}
-
-aomdec_vp9_webm_less_than_50_frames() {
-  # ensure that reaching eof in webm_guess_framerate doesn't result in invalid
-  # frames in actual webm_read_frame calls.
-  if [ "$(aomdec_can_decode_vp9)" = "yes" ] && \
-     [ "$(webm_io_available)" = "yes" ]; then
-    local readonly decoder="$(aom_tool_path aomdec)"
-    local readonly expected=10
-    local readonly num_frames=$(${AOM_TEST_PREFIX} "${decoder}" \
-      "${AV1_LT_50_FRAMES_WEBM_FILE}" --summary --noblit 2>&1 \
-      | awk '/^[0-9]+ decoded frames/ { print $1 }')
-    if [ "$num_frames" -ne "$expected" ]; then
-      elog "Output frames ($num_frames) != expected ($expected)"
-      return 1
-    fi
-  fi
-}
-
-aomdec_tests="aomdec_vp8_ivf
-              aomdec_vp8_ivf_pipe_input
-              aomdec_vp9_webm
-              aomdec_vp9_webm_frame_parallel
-              aomdec_vp9_webm_less_than_50_frames"
-
-run_tests aomdec_verify_environment "${aomdec_tests}"
diff --git a/test/y4m_test.cc b/test/y4m_test.cc
index c996655..c4755f7 100644
--- a/test/y4m_test.cc
+++ b/test/y4m_test.cc
@@ -139,7 +139,7 @@
 
 class Y4mVideoWriteTest : public Y4mVideoSourceTest {
  protected:
-  Y4mVideoWriteTest() {}
+  Y4mVideoWriteTest() : tmpfile_(NULL) {}
 
   virtual ~Y4mVideoWriteTest() {
     delete tmpfile_;