diff --git a/av1/common/av1_rtcd_defs.pl b/av1/common/av1_rtcd_defs.pl
index 620d500..0b6e96c 100644
--- a/av1/common/av1_rtcd_defs.pl
+++ b/av1/common/av1_rtcd_defs.pl
@@ -282,8 +282,8 @@
   }
 
   if (aom_config("CONFIG_REALTIME_ONLY") ne "yes") {
-    add_proto qw/void av1_temporal_filter_plane/, "uint8_t *frame1, unsigned int stride, uint8_t *frame2, unsigned int stride2, int block_width, int block_height, int strength, double sigma, int decay_control, const int *blk_fw, int use_32x32, unsigned int *accumulator, uint16_t *count";
-    specialize qw/av1_temporal_filter_plane sse2 avx2/;
+    add_proto qw/void av1_apply_temporal_filter_planewise/, "const struct yv12_buffer_config *ref_frame, const struct macroblockd *mbd, const BLOCK_SIZE block_size, const int mb_row, const int mb_col, const int num_planes, const double noise_level, const uint8_t *pred, uint32_t *accum, uint16_t *count";
+    specialize qw/av1_apply_temporal_filter_planewise sse2 avx2/;
   }
   add_proto qw/void av1_quantize_b/, "const tran_low_t *coeff_ptr, intptr_t n_coeffs, const int16_t *zbin_ptr, const int16_t *round_ptr, const int16_t *quant_ptr, const int16_t *quant_shift_ptr, tran_low_t *qcoeff_ptr, tran_low_t *dqcoeff_ptr, const int16_t *dequant_ptr, uint16_t *eob_ptr, const int16_t *scan, const int16_t *iscan, const qm_val_t * qm_ptr, const qm_val_t * iqm_ptr, int log_scale";
 
diff --git a/av1/encoder/temporal_filter.c b/av1/encoder/temporal_filter.c
index f0519cf..59f218d 100644
--- a/av1/encoder/temporal_filter.c
+++ b/av1/encoder/temporal_filter.c
@@ -129,40 +129,50 @@
   }
 }
 
-static void apply_temporal_filter_self(const uint8_t *pred, int buf_stride,
-                                       unsigned int block_width,
-                                       unsigned int block_height,
-                                       int filter_weight, uint32_t *accumulator,
-                                       uint16_t *count,
-                                       int use_new_temporal_mode) {
-  const int modifier = use_new_temporal_mode ? SCALE : filter_weight * 16;
-  unsigned int i, j, k = 0;
+// Computes temporal filter weights and accumulators for the reference frame.
+// More concretely, the filter weights for all pixels are the same.
+// Inputs:
+//   mbd: Pointer to the block for filtering.
+//   block_size: Size of the block.
+//   num_planes: Number of planes in the frame.
+//   filter_weight: Weight used for filtering.
+//   pred: Pointer to the well-built predictors.
+//   accum: Pointer to the pixel-wise accumulator for filtering.
+//   count: Pointer to the pixel-wise counter fot filtering.
+// Returns:
+//   Nothing will be returned. But the content to which `accum` and `pred`
+//   point will be modified.
+void av1_apply_temporal_filter_self(const MACROBLOCKD *mbd,
+                                    const BLOCK_SIZE block_size,
+                                    const int num_planes,
+                                    const int filter_weight,
+                                    const uint8_t *pred, uint32_t *accum,
+                                    uint16_t *count) {
+  // Block information.
+  const int mb_height = block_size_high[block_size];
+  const int mb_width = block_size_wide[block_size];
+  const int mb_pels = mb_height * mb_width;
+  const int is_high_bitdepth = is_cur_buf_hbd(mbd);
+  const uint16_t *pred16 = CONVERT_TO_SHORTPTR(pred);
 
-  for (i = 0; i < block_height; i++) {
-    for (j = 0; j < block_width; j++) {
-      const int pixel_value = pred[i * buf_stride + j];
-      count[k] += modifier;
-      accumulator[k] += modifier * pixel_value;
-      ++k;
+  int plane_offset = 0;
+  for (int plane = 0; plane < num_planes; ++plane) {
+    const int subsampling_y = mbd->plane[plane].subsampling_y;
+    const int subsampling_x = mbd->plane[plane].subsampling_x;
+    const int h = mb_height >> subsampling_y;  // Plane height.
+    const int w = mb_width >> subsampling_x;   // Plane width.
+
+    int pred_idx = 0;
+    for (int i = 0; i < h; ++i) {
+      for (int j = 0; j < w; ++j) {
+        const int idx = plane_offset + pred_idx;  // Index with plane shift.
+        const int pred_value = is_high_bitdepth ? pred16[idx] : pred[idx];
+        accum[idx] += filter_weight * pred_value;
+        count[idx] += filter_weight;
+        ++pred_idx;
+      }
     }
-  }
-}
-
-static void highbd_apply_temporal_filter_self(
-    const uint8_t *pred8, int buf_stride, unsigned int block_width,
-    unsigned int block_height, int filter_weight, uint32_t *accumulator,
-    uint16_t *count, int use_new_temporal_mode) {
-  const int modifier = use_new_temporal_mode ? SCALE : filter_weight * 16;
-  const uint16_t *pred = CONVERT_TO_SHORTPTR(pred8);
-  unsigned int i, j, k = 0;
-
-  for (i = 0; i < block_height; i++) {
-    for (j = 0; j < block_width; j++) {
-      const int pixel_value = pred[i * buf_stride + j];
-      count[k] += modifier;
-      accumulator[k] += modifier * pixel_value;
-      ++k;
-    }
+    plane_offset += mb_pels;
   }
 }
 
@@ -401,15 +411,13 @@
           }
         }
 
+        const int idx = plane_offset + pred_idx;  // Index with plane shift.
+        const int pred_value = is_high_bitdepth ? pred16[idx] : pred[idx];
         const int adjusted_weight = adjust_filter_weight_yuv(
             filter_weight, sum_square_diff, num_ref_pixels, strength,
             is_high_bitdepth);
-
-        const int pred_value = is_high_bitdepth
-                                   ? pred16[plane_offset + pred_idx]
-                                   : pred[plane_offset + pred_idx];
-        accum[plane_offset + pred_idx] += adjusted_weight * pred_value;
-        count[plane_offset + pred_idx] += adjusted_weight;
+        accum[idx] += adjusted_weight * pred_value;
+        count[idx] += adjusted_weight;
 
         ++pred_idx;
       }
@@ -420,325 +428,287 @@
   aom_free(square_diff);
 }
 
-// Only used in single plane case
-void av1_temporal_filter_apply_c(uint8_t *frame1, unsigned int stride,
-                                 uint8_t *frame2, unsigned int block_width,
-                                 unsigned int block_height, int strength,
-                                 const int *blk_fw, int use_32x32,
-                                 unsigned int *accumulator, uint16_t *count) {
-  unsigned int i, j, k;
-  int modifier;
-  int byte = 0;
-  const int rounding = strength > 0 ? 1 << (strength - 1) : 0;
+// Function to adjust the filter weight when applying filter to Y-plane only.
+// Inputs:
+//   filter_weight: Original filter weight.
+//   sum_square_diff: Sum of squared difference between input frame and
+//                    prediction. This field is computed pixel by pixel, and
+//                    is used as a reference for the filter weight adjustment.
+//   num_ref_pixels: Number of pixels used to compute the `sum_square_diff`.
+//   strength: Strength for filter weight adjustment.
+// Returns:
+//   Adjusted filter weight which will finally be used for filtering.
+static INLINE int adjust_filter_weight_yonly(const int filter_weight,
+                                             const uint64_t sum_square_diff,
+                                             const int num_ref_pixels,
+                                             const int strength) {
+  assert(YONLY_FILTER_WINDOW_LENGTH == 3);
 
-  for (i = 0, k = 0; i < block_height; i++) {
-    for (j = 0; j < block_width; j++, k++) {
-      int pixel_value = *frame2;
+  int modifier = (int)(AOMMIN(sum_square_diff * 3, INT32_MAX));
+  modifier /= num_ref_pixels;
+
+  const int rounding = (1 << strength) >> 1;
+  modifier = (modifier + rounding) >> strength;
+  return (modifier >= 16) ? 0 : (16 - modifier) * filter_weight;
+}
+
+// Applies temporal filter to Y-plane ONLY.
+// Different from the function `av1_apply_temporal_filter_yuv_c()`, this
+// function only applies temporal filter to Y-plane. This should be used when
+// the input video frame only has one plane.
+// Inputs:
+//   ref_frame: Pointer to the frame for filtering.
+//   mbd: Pointer to the block for filtering.
+//   block_size: Size of the block.
+//   mb_row: Row index of the block in the entire frame.
+//   mb_col: Column index of the block in the entire frame.
+//   strength: Strength for filter weight adjustment.
+//   use_subblock: Whether to use four sub-blocks to replace the original block.
+//   subblock_filter_weights: The filter weights for each sub-block (row-major
+//                            order). If `use_subblock` is set as 0, the first
+//                            weight will be applied to the entire block.
+//   pred: Pointer to the well-built predictors.
+//   accum: Pointer to the pixel-wise accumulator for filtering.
+//   count: Pointer to the pixel-wise counter fot filtering.
+// Returns:
+//   Nothing will be returned. But the content to which `accum` and `pred`
+//   point will be modified.
+void av1_apply_temporal_filter_yonly(const YV12_BUFFER_CONFIG *ref_frame,
+                                     const MACROBLOCKD *mbd,
+                                     const BLOCK_SIZE block_size,
+                                     const int mb_row, const int mb_col,
+                                     const int strength, const int use_subblock,
+                                     const int *subblock_filter_weights,
+                                     const uint8_t *pred, uint32_t *accum,
+                                     uint16_t *count) {
+  // Block information.
+  const int mb_height = block_size_high[block_size];
+  const int mb_width = block_size_wide[block_size];
+  const int mb_pels = mb_height * mb_width;
+  const int is_high_bitdepth = ref_frame->flags & YV12_FLAG_HIGHBITDEPTH;
+  const uint16_t *pred16 = CONVERT_TO_SHORTPTR(pred);
+
+  // Y-plane information.
+  const int subsampling_y = mbd->plane[0].subsampling_y;
+  const int subsampling_x = mbd->plane[0].subsampling_x;
+  const int h = mb_height >> subsampling_y;
+  const int w = mb_width >> subsampling_x;
+
+  // Pre-compute squared difference before filtering.
+  const int frame_stride = ref_frame->strides[0];
+  const int frame_offset = mb_row * h * frame_stride + mb_col * w;
+  const uint8_t *ref = ref_frame->buffers[0];
+  uint32_t *square_diff = aom_memalign(16, mb_pels * sizeof(uint32_t));
+  memset(square_diff, 0, mb_pels * sizeof(uint32_t));
+  compute_square_diff(ref, frame_offset, frame_stride, pred, 0, w, h, w,
+                      is_high_bitdepth, square_diff);
+
+  // Get window size for pixel-wise filtering.
+  assert(YONLY_FILTER_WINDOW_LENGTH % 2 == 1);
+  const int half_window = YONLY_FILTER_WINDOW_LENGTH >> 1;
+
+  // Perform filtering.
+  int idx = 0;
+  for (int i = 0; i < h; ++i) {
+    for (int j = 0; j < w; ++j) {
       const int subblock_idx =
-          use_32x32 ? 0 : (i >= block_height / 2) * 2 + (j >= block_width / 2);
-      const int filter_weight = blk_fw[subblock_idx];
+          use_subblock ? (i >= h / 2) * 2 + (j >= w / 2) : 0;
+      const int filter_weight = subblock_filter_weights[subblock_idx];
 
       // non-local mean approach
-      int diff_sse[9] = { 0 };
-      int idx, idy, index = 0;
+      uint64_t sum_square_diff = 0;
+      int num_ref_pixels = 0;
 
-      for (idy = -1; idy <= 1; ++idy) {
-        for (idx = -1; idx <= 1; ++idx) {
-          int row = (int)i + idy;
-          int col = (int)j + idx;
-
-          if (row >= 0 && row < (int)block_height && col >= 0 &&
-              col < (int)block_width) {
-            int diff = frame1[byte + idy * (int)stride + idx] -
-                       frame2[idy * (int)block_width + idx];
-            diff_sse[index] = diff * diff;
-            ++index;
+      for (int wi = -half_window; wi <= half_window; ++wi) {
+        for (int wj = -half_window; wj <= half_window; ++wj) {
+          const int y = i + wi;  // Y-coord on the current plane.
+          const int x = j + wj;  // X-coord on the current plane.
+          if (y >= 0 && y < h && x >= 0 && x < w) {
+            sum_square_diff += square_diff[y * w + x];
+            ++num_ref_pixels;
           }
         }
       }
 
-      assert(index > 0);
+      const int pred_value = is_high_bitdepth ? pred16[idx] : pred[idx];
+      const int adjusted_weight = adjust_filter_weight_yonly(
+          filter_weight, sum_square_diff, num_ref_pixels, strength);
+      accum[idx] += adjusted_weight * pred_value;
+      count[idx] += adjusted_weight;
 
-      modifier = 0;
-      for (idx = 0; idx < 9; ++idx) modifier += diff_sse[idx];
-
-      modifier *= 3;
-      modifier /= index;
-
-      ++frame2;
-
-      modifier += rounding;
-      modifier >>= strength;
-
-      if (modifier > 16) modifier = 16;
-
-      modifier = 16 - modifier;
-      modifier *= filter_weight;
-
-      count[k] += modifier;
-      accumulator[k] += modifier * pixel_value;
-
-      byte++;
+      ++idx;
     }
-
-    byte += stride - block_width;
   }
+
+  aom_free(square_diff);
 }
 
-// Only used in single plane case
-void av1_highbd_temporal_filter_apply_c(
-    uint8_t *frame1_8, unsigned int stride, uint8_t *frame2_8,
-    unsigned int block_width, unsigned int block_height, int strength,
-    int *blk_fw, int use_32x32, unsigned int *accumulator, uint16_t *count) {
-  uint16_t *frame1 = CONVERT_TO_SHORTPTR(frame1_8);
-  uint16_t *frame2 = CONVERT_TO_SHORTPTR(frame2_8);
-  unsigned int i, j, k;
-  int modifier;
-  int byte = 0;
-  const int rounding = strength > 0 ? 1 << (strength - 1) : 0;
+// Applies temporal filter plane by plane.
+// Different from the function `av1_apply_temporal_filter_yuv_c()` and the
+// function `av1_apply_temporal_filter_yonly()`, this function applies temporal
+// filter to each plane independently. Besides, the strategy of filter weight
+// adjustment is different from the other two functions.
+// Inputs:
+//   ref_frame: Pointer to the frame for filtering.
+//   mbd: Pointer to the block for filtering.
+//   block_size: Size of the block.
+//   mb_row: Row index of the block in the entire frame.
+//   mb_col: Column index of the block in the entire frame.
+//   num_planes: Number of planes in the frame.
+//   noise_level: Estimated noise level for the current block.
+//   pred: Pointer to the well-built predictors.
+//   accum: Pointer to the pixel-wise accumulator for filtering.
+//   count: Pointer to the pixel-wise counter fot filtering.
+// Returns:
+//   Nothing will be returned. But the content to which `accum` and `pred`
+//   point will be modified.
+void av1_apply_temporal_filter_planewise_c(
+    const YV12_BUFFER_CONFIG *ref_frame, const MACROBLOCKD *mbd,
+    const BLOCK_SIZE block_size, const int mb_row, const int mb_col,
+    const int num_planes, const double noise_level, const uint8_t *pred,
+    uint32_t *accum, uint16_t *count) {
+  // Hyper-parameter for filter weight adjustment.
+  const int frame_height = ref_frame->heights[0] << mbd->plane[0].subsampling_y;
+  const int decay_control = frame_height >= 480 ? 4 : 3;
+  // Control factor for non-local mean approach.
+  const double r = (double)decay_control * (0.7 + log(noise_level + 0.5));
 
-  for (i = 0, k = 0; i < block_height; i++) {
-    for (j = 0; j < block_width; j++, k++) {
-      int pixel_value = *frame2;
-      const int subblock_idx =
-          use_32x32 ? 0 : (i >= block_height / 2) * 2 + (j >= block_width / 2);
-      const int filter_weight = blk_fw[subblock_idx];
+  // Block information.
+  const int mb_height = block_size_high[block_size];
+  const int mb_width = block_size_wide[block_size];
+  const int mb_pels = mb_height * mb_width;
+  const int is_high_bitdepth = ref_frame->flags & YV12_FLAG_HIGHBITDEPTH;
+  const uint16_t *pred16 = CONVERT_TO_SHORTPTR(pred);
 
-      // non-local mean approach
-      int diff_sse[9] = { 0 };
-      int idx, idy, index = 0;
+  // Allocate memory for pixel-wise squared differences for all planes. They,
+  // regardless of the subsampling, are assigned with memory of size `mb_pels`.
+  uint32_t *square_diff =
+      aom_memalign(16, num_planes * mb_pels * sizeof(uint32_t));
+  memset(square_diff, 0, num_planes * mb_pels * sizeof(uint32_t));
 
-      for (idy = -1; idy <= 1; ++idy) {
-        for (idx = -1; idx <= 1; ++idx) {
-          int row = (int)i + idy;
-          int col = (int)j + idx;
+  int plane_offset = 0;
+  for (int plane = 0; plane < num_planes; ++plane) {
+    // Locate pixel on reference frame.
+    const int plane_h = mb_height >> mbd->plane[plane].subsampling_y;
+    const int plane_w = mb_width >> mbd->plane[plane].subsampling_x;
+    const int frame_stride = ref_frame->strides[plane == 0 ? 0 : 1];
+    const int frame_offset = mb_row * plane_h * frame_stride + mb_col * plane_w;
+    const uint8_t *ref = ref_frame->buffers[plane];
+    compute_square_diff(ref, frame_offset, frame_stride, pred, plane_offset,
+                        plane_w, plane_h, plane_w, is_high_bitdepth,
+                        square_diff + plane_offset);
+    plane_offset += mb_pels;
+  }
 
-          if (row >= 0 && row < (int)block_height && col >= 0 &&
-              col < (int)block_width) {
-            int diff = frame1[byte + idy * (int)stride + idx] -
-                       frame2[idy * (int)block_width + idx];
-            diff_sse[index] = diff * diff;
-            ++index;
+  // Get window size for pixel-wise filtering.
+  assert(PLANEWISE_FILTER_WINDOW_LENGTH % 2 == 1);
+  const int half_window = PLANEWISE_FILTER_WINDOW_LENGTH >> 1;
+
+  // Handle planes in sequence.
+  plane_offset = 0;
+  for (int plane = 0; plane < num_planes; ++plane) {
+    const int subsampling_y = mbd->plane[plane].subsampling_y;
+    const int subsampling_x = mbd->plane[plane].subsampling_x;
+    const int h = mb_height >> subsampling_y;  // Plane height.
+    const int w = mb_width >> subsampling_x;   // Plane width.
+
+    // Perform filtering.
+    int pred_idx = 0;
+    for (int i = 0; i < h; ++i) {
+      for (int j = 0; j < w; ++j) {
+        // non-local mean approach
+        uint64_t sum_square_diff = 0;
+        int num_ref_pixels = 0;
+
+        for (int wi = -half_window; wi <= half_window; ++wi) {
+          for (int wj = -half_window; wj <= half_window; ++wj) {
+            const int y = CLIP(i + wi, 0, h - 1);  // Y-coord on current plane.
+            const int x = CLIP(j + wj, 0, w - 1);  // X-coord on current plane.
+            sum_square_diff += square_diff[plane_offset + y * w + x];
+            ++num_ref_pixels;
           }
         }
+
+        const int idx = plane_offset + pred_idx;  // Index with plane shift.
+        const int pred_value = is_high_bitdepth ? pred16[idx] : pred[idx];
+        const double scaled_diff = AOMMAX(
+            -(double)(sum_square_diff / num_ref_pixels) / (2 * r * r), -15.0);
+        const int adjusted_weight =
+            (int)(exp(scaled_diff) * PLANEWISE_FILTER_WEIGHT_SCALE);
+        accum[idx] += adjusted_weight * pred_value;
+        count[idx] += adjusted_weight;
+
+        ++pred_idx;
       }
-
-      assert(index > 0);
-
-      modifier = 0;
-      for (idx = 0; idx < 9; ++idx) modifier += diff_sse[idx];
-
-      modifier *= 3;
-      modifier /= index;
-
-      ++frame2;
-
-      modifier += rounding;
-      modifier >>= strength;
-
-      if (modifier > 16) modifier = 16;
-
-      modifier = 16 - modifier;
-      modifier *= filter_weight;
-
-      count[k] += modifier;
-      accumulator[k] += modifier * pixel_value;
-
-      byte++;
     }
-
-    byte += stride - block_width;
+    plane_offset += mb_pels;
   }
+
+  aom_free(square_diff);
 }
 
-#if EXPERIMENT_TEMPORAL_FILTER
-void av1_temporal_filter_plane_c(uint8_t *frame1, unsigned int stride,
-                                 uint8_t *frame2, unsigned int stride2,
-                                 int block_width, int block_height,
-                                 int strength, double sigma, int decay_control,
-                                 const int *blk_fw, int use_32x32,
-                                 unsigned int *accumulator, uint16_t *count) {
-  (void)strength;
-  (void)blk_fw;
-  (void)use_32x32;
-  const double h = decay_control * (0.7 + log(sigma + 0.5));
-  const double beta = 1.0;
-  for (int i = 0, k = 0; i < block_height; i++) {
-    for (int j = 0; j < block_width; j++, k++) {
-      const int pixel_value = frame2[i * stride2 + j];
-
-      int diff_sse = 0;
-      for (int idy = -WINDOW_LENGTH; idy <= WINDOW_LENGTH; ++idy) {
-        for (int idx = -WINDOW_LENGTH; idx <= WINDOW_LENGTH; ++idx) {
-          int row = i + idy;
-          int col = j + idx;
-          if (row < 0) row = 0;
-          if (row >= block_height) row = block_height - 1;
-          if (col < 0) col = 0;
-          if (col >= block_width) col = block_width - 1;
-
-          int diff = frame1[row * (int)stride + col] -
-                     frame2[row * (int)stride2 + col];
-          diff_sse += diff * diff;
-        }
-      }
-      diff_sse /= WINDOW_SIZE;
-
-      double scaled_diff = -diff_sse / (2 * beta * h * h);
-      // clamp the value to avoid underflow in exp()
-      if (scaled_diff < -15) scaled_diff = -15;
-      double w = exp(scaled_diff);
-      const int weight = (int)(w * SCALE);
-
-      count[k] += weight;
-      accumulator[k] += weight * pixel_value;
-    }
-  }
-}
-
-void av1_highbd_temporal_filter_plane_c(
-    uint8_t *frame1_8bit, unsigned int stride, uint8_t *frame2_8bit,
-    unsigned int stride2, int block_width, int block_height, int strength,
-    double sigma, int decay_control, const int *blk_fw, int use_32x32,
-    unsigned int *accumulator, uint16_t *count) {
-  (void)strength;
-  (void)blk_fw;
-  (void)use_32x32;
-  uint16_t *frame1 = CONVERT_TO_SHORTPTR(frame1_8bit);
-  uint16_t *frame2 = CONVERT_TO_SHORTPTR(frame2_8bit);
-  const double h = decay_control * (0.7 + log(sigma + 0.5));
-  const double beta = 1.0;
-  for (int i = 0, k = 0; i < block_height; i++) {
-    for (int j = 0; j < block_width; j++, k++) {
-      const int pixel_value = frame2[i * stride2 + j];
-
-      int diff_sse = 0;
-      for (int idy = -WINDOW_LENGTH; idy <= WINDOW_LENGTH; ++idy) {
-        for (int idx = -WINDOW_LENGTH; idx <= WINDOW_LENGTH; ++idx) {
-          int row = i + idy;
-          int col = j + idx;
-          if (row < 0) row = 0;
-          if (row >= block_height) row = block_height - 1;
-          if (col < 0) col = 0;
-          if (col >= block_width) col = block_width - 1;
-
-          int diff = frame1[row * (int)stride + col] -
-                     frame2[row * (int)stride2 + col];
-          diff_sse += diff * diff;
-        }
-      }
-      diff_sse /= WINDOW_SIZE;
-
-      double scaled_diff = -diff_sse / (2 * beta * h * h);
-      // clamp the value to avoid underflow in exp()
-      if (scaled_diff < -20) scaled_diff = -20;
-      double w = exp(scaled_diff);
-      const int weight = (int)(w * SCALE);
-
-      count[k] += weight;
-      accumulator[k] += weight * pixel_value;
-    }
-  }
-}
-
-void apply_temporal_filter_block(
-    YV12_BUFFER_CONFIG *frame, MACROBLOCKD *mbd, int mb_y_src_offset,
-    int mb_uv_src_offset, int mb_uv_width, int mb_uv_height, int num_planes,
-    uint8_t *predictor, int frame_height, int strength, double sigma,
-    int *blk_fw, int use_32x32, unsigned int *accumulator, uint16_t *count,
-    int use_new_temporal_mode, int mb_row, int mb_col) {
-  const int is_hbd = is_cur_buf_hbd(mbd);
-  // High bitdepth
-  if (is_hbd) {
-    if (use_new_temporal_mode) {
-      // Apply frame size dependent non-local means filtering.
-      int decay_control;
-      // The decay is obtained empirically, subject to better tuning.
-      if (frame_height >= 720) {
-        decay_control = 4;
-      } else if (frame_height >= 480) {
-        decay_control = 4;
-      } else {
-        decay_control = 3;
-      }
-      av1_highbd_temporal_filter_plane_c(frame->y_buffer + mb_y_src_offset,
-                                         frame->y_stride, predictor, BW, BW, BH,
-                                         strength, sigma, decay_control, blk_fw,
-                                         use_32x32, accumulator, count);
-      if (num_planes > 1) {
-        av1_highbd_temporal_filter_plane_c(
-            frame->u_buffer + mb_uv_src_offset, frame->uv_stride,
-            predictor + BLK_PELS, mb_uv_width, mb_uv_width, mb_uv_height,
-            strength, sigma, decay_control, blk_fw, use_32x32,
-            accumulator + BLK_PELS, count + BLK_PELS);
-        av1_highbd_temporal_filter_plane_c(
-            frame->v_buffer + mb_uv_src_offset, frame->uv_stride,
-            predictor + (BLK_PELS << 1), mb_uv_width, mb_uv_width, mb_uv_height,
-            strength, sigma, decay_control, blk_fw, use_32x32,
-            accumulator + (BLK_PELS << 1), count + (BLK_PELS << 1));
-      }
+// Computes temporal filter weights and accumulators from other frames excluding
+// the reference frame.
+// Inputs:
+//   ref_frame: Pointer to the frame for filtering.
+//   mbd: Pointer to the block for filtering.
+//   block_size: Size of the block.
+//   mb_row: Row index of the block in the entire frame.
+//   mb_col: Column index of the block in the entire frame.
+//   num_planes: Number of planes in the frame.
+//   use_new_strategy: Whether to use new temporal filtering strategy. If set as
+//                     1, Plane-wise filtering will be used, otherwise, YUV or
+//                     YONLY filtering will be used (depending on number of
+//                     planes).
+//   strength: Strength for filter weight adjustment. (Used in YUV filtering and
+//             YONLY filtering.)
+//   use_subblock: Whether to use four sub-blocks to replace the original block.
+//                 (Used in YUV filtering and YONLY filtering.)
+//   subblock_filter_weights: The filter weights for each sub-block (row-major
+//                            order). If `use_subblock` is set as 0, the first
+//                            weight will be applied to the entire block. (Used
+//                            in YUV filtering and YONLY filtering.)
+//   noise_level: Estimated noise level for the current block. (Used in
+//                Plane-wise filtering.)
+//   pred: Pointer to the well-built predictors.
+//   accum: Pointer to the pixel-wise accumulator for filtering.
+//   count: Pointer to the pixel-wise counter fot filtering.
+// Returns:
+//   Nothing will be returned. But the content to which `accum` and `pred`
+//   point will be modified.
+void av1_apply_temporal_filter_others(
+    const YV12_BUFFER_CONFIG *ref_frame, const MACROBLOCKD *mbd,
+    const BLOCK_SIZE block_size, const int mb_row, const int mb_col,
+    const int num_planes, const int use_planewise_strategy, const int strength,
+    const int use_subblock, const int *subblock_filter_weights,
+    const double noise_level, const uint8_t *pred, uint32_t *accum,
+    uint16_t *count) {
+  if (use_planewise_strategy) {  // Commonly used for high-resolution video.
+    const int is_high_bitdepth = ref_frame->flags & YV12_FLAG_HIGHBITDEPTH;
+    if (is_high_bitdepth) {
+      av1_apply_temporal_filter_planewise_c(ref_frame, mbd, block_size, mb_row,
+                                            mb_col, num_planes, noise_level,
+                                            pred, accum, count);
     } else {
-      // Apply original non-local means filtering for small resolution
-      const int adj_strength = strength + 2 * (mbd->bd - 8);
-      if (num_planes <= 1) {
-        // Single plane case
-        av1_highbd_temporal_filter_apply_c(
-            frame->y_buffer + mb_y_src_offset, frame->y_stride, predictor, BW,
-            BH, adj_strength, blk_fw, use_32x32, accumulator, count);
-      } else {
-        // Process 3 planes together.
-        av1_apply_temporal_filter_yuv(frame, mbd, TF_BLOCK, mb_row, mb_col,
-                                      adj_strength, !(use_32x32), blk_fw,
-                                      predictor, accumulator, count);
-      }
+      av1_apply_temporal_filter_planewise(ref_frame, mbd, block_size, mb_row,
+                                          mb_col, num_planes, noise_level, pred,
+                                          accum, count);
     }
-    return;
-  }
-
-  // Low bitdepth
-  if (use_new_temporal_mode) {
-    // Apply frame size dependent non-local means filtering.
-    int decay_control;
-    // The decay is obtained empirically, subject to better tuning.
-    if (frame_height >= 720) {
-      decay_control = 4;
-    } else if (frame_height >= 480) {
-      decay_control = 4;
+  } else {  // Commonly used for low-resolution video.
+    const int adj_strength = strength + 2 * (mbd->bd - 8);
+    if (num_planes == 1) {
+      av1_apply_temporal_filter_yonly(
+          ref_frame, mbd, block_size, mb_row, mb_col, adj_strength,
+          use_subblock, subblock_filter_weights, pred, accum, count);
+    } else if (num_planes == 3) {
+      av1_apply_temporal_filter_yuv(
+          ref_frame, mbd, block_size, mb_row, mb_col, adj_strength,
+          use_subblock, subblock_filter_weights, pred, accum, count);
     } else {
-      decay_control = 3;
-    }
-    av1_temporal_filter_plane(frame->y_buffer + mb_y_src_offset,
-                              frame->y_stride, predictor, BW, BW, BH, strength,
-                              sigma, decay_control, blk_fw, use_32x32,
-                              accumulator, count);
-    if (num_planes > 1) {
-      av1_temporal_filter_plane(
-          frame->u_buffer + mb_uv_src_offset, frame->uv_stride,
-          predictor + BLK_PELS, mb_uv_width, mb_uv_width, mb_uv_height,
-          strength, sigma, decay_control, blk_fw, use_32x32,
-          accumulator + BLK_PELS, count + BLK_PELS);
-      av1_temporal_filter_plane(
-          frame->v_buffer + mb_uv_src_offset, frame->uv_stride,
-          predictor + (BLK_PELS << 1), mb_uv_width, mb_uv_width, mb_uv_height,
-          strength, sigma, decay_control, blk_fw, use_32x32,
-          accumulator + (BLK_PELS << 1), count + (BLK_PELS << 1));
-    }
-  } else {
-    // Apply original non-local means filtering for small resolution
-    if (num_planes <= 1) {
-      // Single plane case
-      av1_temporal_filter_apply_c(frame->y_buffer + mb_y_src_offset,
-                                  frame->y_stride, predictor, BW, BH, strength,
-                                  blk_fw, use_32x32, accumulator, count);
-    } else {
-      // Process 3 planes together.
-      av1_apply_temporal_filter_yuv(frame, mbd, TF_BLOCK, mb_row, mb_col,
-                                    strength, !(use_32x32), blk_fw, predictor,
-                                    accumulator, count);
+      assert(0 && "Only support Y-plane and YUV-plane modes.");
     }
   }
 }
-#endif  // EXPERIMENT_TEMPORAL_FILTER
 
 static int temporal_filter_find_matching_mb_c(
     AV1_COMP *cpi, uint8_t *arf_frame_buf, uint8_t *frame_ptr_buf, int stride,
@@ -1034,73 +1004,17 @@
 
           // Apply the filter (YUV)
           if (frame == alt_ref_index) {
-            uint8_t *pred = predictor;
-            uint32_t *accum = accumulator;
-            uint16_t *cnt = count;
-            int plane;
-
-            // All 4 blk_fws are equal to 2.
-            for (plane = 0; plane < num_planes; ++plane) {
-              const int pred_stride = plane ? mb_uv_width : BW;
-              const unsigned int w = plane ? mb_uv_width : BW;
-              const unsigned int h = plane ? mb_uv_height : BH;
-
-              if (is_hbd) {
-                highbd_apply_temporal_filter_self(pred, pred_stride, w, h,
-                                                  blk_fw[0], accum, cnt,
-                                                  use_new_temporal_mode);
-              } else {
-                apply_temporal_filter_self(pred, pred_stride, w, h, blk_fw[0],
-                                           accum, cnt, use_new_temporal_mode);
-              }
-
-              pred += BLK_PELS;
-              accum += BLK_PELS;
-              cnt += BLK_PELS;
-            }
+            const int filter_weight = use_new_temporal_mode
+                                          ? PLANEWISE_FILTER_WEIGHT_SCALE
+                                          : blk_fw[0] * 16;
+            av1_apply_temporal_filter_self(mbd, TF_BLOCK, num_planes,
+                                           filter_weight, predictor,
+                                           accumulator, count);
           } else {
-            if (is_hbd) {
-#if EXPERIMENT_TEMPORAL_FILTER
-              apply_temporal_filter_block(
-                  f, mbd, mb_y_src_offset, mb_uv_src_offset, mb_uv_width,
-                  mb_uv_height, num_planes, predictor, cm->height, strength,
-                  sigma, blk_fw, use_32x32, accumulator, count,
-                  use_new_temporal_mode, mb_row, mb_col);
-#else
-              const int adj_strength = strength + 2 * (mbd->bd - 8);
-              if (num_planes <= 1) {
-                // Single plane case
-                av1_highbd_temporal_filter_apply_c(
-                    f->y_buffer + mb_y_src_offset, f->y_stride, predictor, BW,
-                    BH, adj_strength, blk_fw, use_32x32, accumulator, count);
-              } else {
-                // Process 3 planes together.
-                av1_apply_temporal_filter_yuv(
-                    frame, mbd, TF_BLOCK, mb_row, mb_col, adj_strength,
-                    !(use_32x32), blk_fw, predictor, accumulator, count);
-              }
-#endif  // EXPERIMENT_TEMPORAL_FILTER
-            } else {
-#if EXPERIMENT_TEMPORAL_FILTER
-              apply_temporal_filter_block(
-                  f, mbd, mb_y_src_offset, mb_uv_src_offset, mb_uv_width,
-                  mb_uv_height, num_planes, predictor, cm->height, strength,
-                  sigma, blk_fw, use_32x32, accumulator, count,
-                  use_new_temporal_mode, mb_row, mb_col);
-#else
-              if (num_planes <= 1) {
-                // Single plane case
-                av1_temporal_filter_apply_c(
-                    f->y_buffer + mb_y_src_offset, f->y_stride, predictor, BW,
-                    BH, strength, blk_fw, use_32x32, accumulator, count);
-              } else {
-                // Process 3 planes together.
-                av1_apply_temporal_filter_yuv(
-                    frame, mbd, TF_BLOCK, mb_row, mb_col, strength,
-                    !(use_32x32), blk_fw, predictor, accumulator, count);
-              }
-#endif  // EXPERIMENT_TEMPORAL_FILTER
-            }
+            av1_apply_temporal_filter_others(
+                f, mbd, TF_BLOCK, mb_row, mb_col, num_planes,
+                use_new_temporal_mode, strength, !(use_32x32), blk_fw, sigma,
+                predictor, accumulator, count);
           }
         }
       }
diff --git a/av1/encoder/temporal_filter.h b/av1/encoder/temporal_filter.h
index d7bbd66..b64e947 100644
--- a/av1/encoder/temporal_filter.h
+++ b/av1/encoder/temporal_filter.h
@@ -35,14 +35,22 @@
 #define SQRT_PI_BY_2 1.25331413732
 
 #define EXPERIMENT_TEMPORAL_FILTER 1
-#define WINDOW_LENGTH 2
-#define WINDOW_SIZE 25
-#define SCALE 1000
 
 // Window size for temporal filtering on YUV planes.
-// This is particually used for function `av1_apply_temporal_filter_yuv_c()`.
+// This is particually used for function `av1_apply_temporal_filter_yuv()`.
 static const int YUV_FILTER_WINDOW_LENGTH = 3;
 
+// Window size for temporal filtering on Y planes.
+// This is particually used for function `av1_apply_temporal_filter_yonly()`.
+static const int YONLY_FILTER_WINDOW_LENGTH = 3;
+
+// Window size for plane-wise temporal filtering.
+// This is particually used for function `av1_apply_temporal_filter_planewise()`
+static const int PLANEWISE_FILTER_WINDOW_LENGTH = 5;
+// A scale factor used in plane-wise temporal filtering to raise the filter
+// weight from `double` with range [0, 1] to `int` with range [0, 1000].
+static const int PLANEWISE_FILTER_WEIGHT_SCALE = 1000;
+
 static INLINE BLOCK_SIZE dims_to_size(int w, int h) {
   if (w != h) return -1;
   switch (w) {
diff --git a/av1/encoder/x86/temporal_filter_avx2.c b/av1/encoder/x86/temporal_filter_avx2.c
index 09325aa..af39913 100644
--- a/av1/encoder/x86/temporal_filter_avx2.c
+++ b/av1/encoder/x86/temporal_filter_avx2.c
@@ -18,7 +18,6 @@
 
 #define SSE_STRIDE (BW + 2)
 
-#if EXPERIMENT_TEMPORAL_FILTER
 DECLARE_ALIGNED(32, static const uint32_t, sse_bytemask[4][8]) = {
   { 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000, 0x0000 },
   { 0x0000, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0x0000, 0x0000 },
@@ -32,12 +31,12 @@
 };
 
 static AOM_FORCE_INLINE void get_squared_error_16x16_avx2(
-    uint8_t *frame1, unsigned int stride, uint8_t *frame2, unsigned int stride2,
-    int block_width, int block_height, uint16_t *frame_sse,
-    unsigned int sse_stride) {
+    const uint8_t *frame1, const unsigned int stride, const uint8_t *frame2,
+    const unsigned int stride2, const int block_width, const int block_height,
+    uint16_t *frame_sse, const unsigned int sse_stride) {
   (void)block_width;
-  uint8_t *src1 = frame1;
-  uint8_t *src2 = frame2;
+  const uint8_t *src1 = frame1;
+  const uint8_t *src2 = frame2;
   uint16_t *dst = frame_sse;
   for (int i = 0; i < block_height; i++) {
     __m128i vf1_128, vf2_128;
@@ -60,12 +59,12 @@
 }
 
 static AOM_FORCE_INLINE void get_squared_error_32x32_avx2(
-    uint8_t *frame1, unsigned int stride, uint8_t *frame2, unsigned int stride2,
-    int block_width, int block_height, uint16_t *frame_sse,
-    unsigned int sse_stride) {
+    const uint8_t *frame1, const unsigned int stride, const uint8_t *frame2,
+    const unsigned int stride2, const int block_width, const int block_height,
+    uint16_t *frame_sse, const unsigned int sse_stride) {
   (void)block_width;
-  uint8_t *src1 = frame1;
-  uint8_t *src2 = frame2;
+  const uint8_t *src1 = frame1;
+  const uint8_t *src2 = frame2;
   uint16_t *dst = frame_sse;
   for (int i = 0; i < block_height; i++) {
     __m256i vsrc1, vsrc2, vmin, vmax, vdiff, vdiff1, vdiff2, vres1, vres2;
@@ -128,22 +127,18 @@
   return _mm_extract_epi32(v128a, 0);
 }
 
-void av1_temporal_filter_plane_avx2(uint8_t *frame1, unsigned int stride,
-                                    uint8_t *frame2, unsigned int stride2,
-                                    int block_width, int block_height,
-                                    int strength, double sigma,
-                                    int decay_control, const int *blk_fw,
-                                    int use_32x32, unsigned int *accumulator,
-                                    uint16_t *count) {
-  (void)strength;
-  (void)blk_fw;
-  (void)use_32x32;
+static void apply_temporal_filter_planewise(
+    const uint8_t *frame1, const unsigned int stride, const uint8_t *frame2,
+    const unsigned int stride2, const int block_width, const int block_height,
+    const double sigma, const int decay_control, unsigned int *accumulator,
+    uint16_t *count) {
   const double h = decay_control * (0.7 + log(sigma + 0.5));
   const double beta = 1.0;
 
   uint16_t frame_sse[SSE_STRIDE * BH];
   uint32_t acc_5x5_sse[BH][BW];
 
+  assert(PLANEWISE_FILTER_WINDOW_LENGTH == 5);
   assert(((block_width == 32) && (block_height == 32)) ||
          ((block_width == 16) && (block_height == 16)));
 
@@ -205,17 +200,47 @@
       const int pixel_value = frame2[i * stride2 + j];
 
       int diff_sse = acc_5x5_sse[i][j];
-      diff_sse /= WINDOW_SIZE;
+      diff_sse /=
+          (PLANEWISE_FILTER_WINDOW_LENGTH * PLANEWISE_FILTER_WINDOW_LENGTH);
 
       double scaled_diff = -diff_sse / (2 * beta * h * h);
       // clamp the value to avoid underflow in exp()
       if (scaled_diff < -15) scaled_diff = -15;
       double w = exp(scaled_diff);
-      const int weight = (int)(w * SCALE);
+      const int weight = (int)(w * PLANEWISE_FILTER_WEIGHT_SCALE);
 
       count[k] += weight;
       accumulator[k] += weight * pixel_value;
     }
   }
 }
-#endif
+
+void av1_apply_temporal_filter_planewise_avx2(
+    const YV12_BUFFER_CONFIG *ref_frame, const MACROBLOCKD *mbd,
+    const BLOCK_SIZE block_size, const int mb_row, const int mb_col,
+    const int num_planes, const double noise_level, const uint8_t *pred,
+    uint32_t *accum, uint16_t *count) {
+  const int is_high_bitdepth = ref_frame->flags & YV12_FLAG_HIGHBITDEPTH;
+  if (is_high_bitdepth) {
+    assert(0 && "Only support low bit-depth with avx2!");
+  }
+
+  const int frame_height = ref_frame->heights[0] << mbd->plane[0].subsampling_y;
+  const int decay_control = frame_height >= 480 ? 4 : 3;
+
+  const int mb_height = block_size_high[block_size];
+  const int mb_width = block_size_wide[block_size];
+  const int mb_pels = mb_height * mb_width;
+  for (int plane = 0; plane < num_planes; ++plane) {
+    const uint32_t plane_h = mb_height >> mbd->plane[plane].subsampling_y;
+    const uint32_t plane_w = mb_width >> mbd->plane[plane].subsampling_x;
+    const uint32_t frame_stride = ref_frame->strides[plane == 0 ? 0 : 1];
+    const int frame_offset = mb_row * plane_h * frame_stride + mb_col * plane_w;
+
+    const uint8_t *ref = ref_frame->buffers[plane] + frame_offset;
+    apply_temporal_filter_planewise(ref, frame_stride, pred + mb_pels * plane,
+                                    plane_w, plane_w, plane_h, noise_level,
+                                    decay_control, accum + mb_pels * plane,
+                                    count + mb_pels * plane);
+  }
+}
diff --git a/av1/encoder/x86/temporal_filter_sse2.c b/av1/encoder/x86/temporal_filter_sse2.c
index bc0dd51..4baa724 100644
--- a/av1/encoder/x86/temporal_filter_sse2.c
+++ b/av1/encoder/x86/temporal_filter_sse2.c
@@ -19,8 +19,6 @@
 // For the squared error buffer, keep a padding for 4 samples
 #define SSE_STRIDE (BW + 4)
 
-#if EXPERIMENT_TEMPORAL_FILTER
-
 DECLARE_ALIGNED(32, static const uint32_t, sse_bytemask_2x4[4][2][4]) = {
   { { 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF }, { 0xFFFF, 0x0000, 0x0000, 0x0000 } },
   { { 0x0000, 0xFFFF, 0xFFFF, 0xFFFF }, { 0xFFFF, 0xFFFF, 0x0000, 0x0000 } },
@@ -28,12 +26,13 @@
   { { 0x0000, 0x0000, 0x0000, 0xFFFF }, { 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF } }
 };
 
-static void get_squared_error(uint8_t *frame1, unsigned int stride,
-                              uint8_t *frame2, unsigned int stride2,
-                              int block_width, int block_height,
-                              uint16_t *frame_sse, unsigned int dst_stride) {
-  uint8_t *src1 = frame1;
-  uint8_t *src2 = frame2;
+static void get_squared_error(const uint8_t *frame1, const unsigned int stride,
+                              const uint8_t *frame2, const unsigned int stride2,
+                              const int block_width, const int block_height,
+                              uint16_t *frame_sse,
+                              const unsigned int dst_stride) {
+  const uint8_t *src1 = frame1;
+  const uint8_t *src2 = frame2;
   uint16_t *dst = frame_sse;
 
   for (int i = 0; i < block_height; i++) {
@@ -99,23 +98,18 @@
   return _mm_cvtsi128_si32(veca);
 }
 
-void av1_temporal_filter_plane_sse2(uint8_t *frame1, unsigned int stride,
-                                    uint8_t *frame2, unsigned int stride2,
-                                    int block_width, int block_height,
-                                    int strength, double sigma,
-                                    int decay_control, const int *blk_fw,
-                                    int use_32x32, unsigned int *accumulator,
-                                    uint16_t *count) {
-  (void)strength;
-  (void)blk_fw;
-  (void)use_32x32;
+static void apply_temporal_filter_planewise(
+    const uint8_t *frame1, const unsigned int stride, const uint8_t *frame2,
+    const unsigned int stride2, const int block_width, const int block_height,
+    const double sigma, const int decay_control, unsigned int *accumulator,
+    uint16_t *count) {
   const double h = decay_control * (0.7 + log(sigma + 0.5));
   const double beta = 1.0;
 
   uint16_t frame_sse[SSE_STRIDE * BH];
   uint32_t acc_5x5_sse[BH][BW];
 
-  assert(WINDOW_LENGTH == 2);
+  assert(PLANEWISE_FILTER_WINDOW_LENGTH == 5);
   assert(((block_width == 32) && (block_height == 32)) ||
          ((block_width == 16) && (block_height == 16)));
 
@@ -179,17 +173,47 @@
       const int pixel_value = frame2[i * stride2 + j];
 
       int diff_sse = acc_5x5_sse[i][j];
-      diff_sse /= WINDOW_SIZE;
+      diff_sse /=
+          (PLANEWISE_FILTER_WINDOW_LENGTH * PLANEWISE_FILTER_WINDOW_LENGTH);
 
       double scaled_diff = -diff_sse / (2 * beta * h * h);
       // clamp the value to avoid underflow in exp()
       if (scaled_diff < -15) scaled_diff = -15;
       double w = exp(scaled_diff);
-      const int weight = (int)(w * SCALE);
+      const int weight = (int)(w * PLANEWISE_FILTER_WEIGHT_SCALE);
 
       count[k] += weight;
       accumulator[k] += weight * pixel_value;
     }
   }
 }
-#endif
+
+void av1_apply_temporal_filter_planewise_sse2(
+    const YV12_BUFFER_CONFIG *ref_frame, const MACROBLOCKD *mbd,
+    const BLOCK_SIZE block_size, const int mb_row, const int mb_col,
+    const int num_planes, const double noise_level, const uint8_t *pred,
+    uint32_t *accum, uint16_t *count) {
+  const int is_high_bitdepth = ref_frame->flags & YV12_FLAG_HIGHBITDEPTH;
+  if (is_high_bitdepth) {
+    assert(0 && "Only support low bit-depth with sse2!");
+  }
+
+  const int frame_height = ref_frame->heights[0] << mbd->plane[0].subsampling_y;
+  const int decay_control = frame_height >= 480 ? 4 : 3;
+
+  const int mb_height = block_size_high[block_size];
+  const int mb_width = block_size_wide[block_size];
+  const int mb_pels = mb_height * mb_width;
+  for (int plane = 0; plane < num_planes; ++plane) {
+    const uint32_t plane_h = mb_height >> mbd->plane[plane].subsampling_y;
+    const uint32_t plane_w = mb_width >> mbd->plane[plane].subsampling_x;
+    const uint32_t frame_stride = ref_frame->strides[plane == 0 ? 0 : 1];
+    const int frame_offset = mb_row * plane_h * frame_stride + mb_col * plane_w;
+
+    const uint8_t *ref = ref_frame->buffers[plane] + frame_offset;
+    apply_temporal_filter_planewise(ref, frame_stride, pred + mb_pels * plane,
+                                    plane_w, plane_w, plane_h, noise_level,
+                                    decay_control, accum + mb_pels * plane,
+                                    count + mb_pels * plane);
+  }
+}
diff --git a/test/temporal_filter_plane_test.cc b/test/temporal_filter_plane_test.cc
deleted file mode 100644
index 513cfc5..0000000
--- a/test/temporal_filter_plane_test.cc
+++ /dev/null
@@ -1,221 +0,0 @@
-/*
- * Copyright (c) 2019, Alliance for Open Media. All rights reserved
- *
- * This source code is subject to the terms of the BSD 2 Clause License and
- * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
- * was not distributed with this source code in the LICENSE file, you can
- * obtain it at www.aomedia.org/license/software. If the Alliance for Open
- * Media Patent License 1.0 was not distributed with this source code in the
- * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
- */
-
-#include <cmath>
-#include <cstdlib>
-#include <string>
-
-#include "third_party/googletest/src/googletest/include/gtest/gtest.h"
-
-#include "config/aom_config.h"
-#include "config/aom_dsp_rtcd.h"
-#include "config/av1_rtcd.h"
-
-#include "aom_ports/mem.h"
-#include "test/acm_random.h"
-#include "test/clear_system_state.h"
-#include "test/register_state_check.h"
-#include "test/util.h"
-#include "test/function_equivalence_test.h"
-
-using libaom_test::ACMRandom;
-using libaom_test::FunctionEquivalenceTest;
-using ::testing::Combine;
-using ::testing::Range;
-using ::testing::Values;
-using ::testing::ValuesIn;
-
-#if !CONFIG_REALTIME_ONLY
-namespace {
-
-typedef void (*temporal_filter_plane_func)(
-    uint8_t *frame1, unsigned int stride, uint8_t *frame2, unsigned int stride2,
-    int block_width, int block_height, int strength, double sigma,
-    int decay_control, const int *blk_fw, int use_32x32,
-    unsigned int *accumulator, uint16_t *count);
-typedef libaom_test::FuncParam<temporal_filter_plane_func>
-    TestTemporal_FilterPlane;
-
-typedef ::testing::tuple<TestTemporal_FilterPlane, int> TemporalFilter_Params;
-
-class TemporalFilterTest
-    : public ::testing::TestWithParam<TemporalFilter_Params> {
- public:
-  virtual ~TemporalFilterTest() {}
-  virtual void SetUp() {
-    params_ = GET_PARAM(0);
-    rnd_.Reset(ACMRandom::DeterministicSeed());
-    src1_ = reinterpret_cast<uint8_t *>(aom_memalign(8, 256 * 256));
-    src2_ = reinterpret_cast<uint8_t *>(aom_memalign(8, 256 * 256));
-
-    ASSERT_TRUE(src1_ != NULL);
-    ASSERT_TRUE(src2_ != NULL);
-  }
-
-  virtual void TearDown() {
-    libaom_test::ClearSystemState();
-    aom_free(src1_);
-    aom_free(src2_);
-  }
-  void RunTest(int isRandom, int width, int height, int run_times);
-
-  void GenRandomData(int width, int height, int stride, int stride2) {
-    for (int ii = 0; ii < height; ii++) {
-      for (int jj = 0; jj < width; jj++) {
-        src1_[ii * stride + jj] = rnd_.Rand8();
-        src2_[ii * stride2 + jj] = rnd_.Rand8();
-      }
-    }
-  }
-
-  void GenExtremeData(int width, int height, int stride, uint8_t *data,
-                      int stride2, uint8_t *data2, uint8_t val) {
-    for (int ii = 0; ii < height; ii++) {
-      for (int jj = 0; jj < width; jj++) {
-        data[ii * stride + jj] = val;
-        data2[ii * stride2 + jj] = (255 - val);
-      }
-    }
-  }
-
- protected:
-  TestTemporal_FilterPlane params_;
-  uint8_t *src1_;
-  uint8_t *src2_;
-  ACMRandom rnd_;
-};
-
-void TemporalFilterTest::RunTest(int isRandom, int width, int height,
-                                 int run_times) {
-  aom_usec_timer ref_timer, test_timer;
-  for (int k = 0; k < 3; k++) {
-    int stride = 5 << rnd_(6);  // Up to 256 stride
-    int stride2 = 5 << rnd_(6);
-
-    while (stride < width) {  // Make sure it's valid
-      stride = 5 << rnd_(6);
-      stride2 = 5 << rnd_(6);
-    }
-    if (isRandom) {
-      GenRandomData(width, height, stride, stride2);
-    } else {
-      const int msb = 8;  // Up to 12 bit input
-      const int limit = (1 << msb) - 1;
-      if (k == 0) {
-        GenExtremeData(width, height, stride, src1_, stride2, src2_, limit);
-      } else {
-        GenExtremeData(width, height, stride, src1_, stride2, src2_, 0);
-      }
-    }
-    int use32X32 = 1;
-    int strength = rnd_(16);
-    double sigma = 2.1002103677063437;
-    int decay_control = 5;
-    int blk_fw = rnd_(16);
-    DECLARE_ALIGNED(16, unsigned int, accumulator_ref[1024 * 3]);
-    DECLARE_ALIGNED(16, uint16_t, count_ref[1024 * 3]);
-    memset(accumulator_ref, 0, 1024 * 3 * sizeof(accumulator_ref[0]));
-    memset(count_ref, 0, 1024 * 3 * sizeof(count_ref[0]));
-    DECLARE_ALIGNED(16, unsigned int, accumulator_mod[1024 * 3]);
-    DECLARE_ALIGNED(16, uint16_t, count_mod[1024 * 3]);
-    memset(accumulator_mod, 0, 1024 * 3 * sizeof(accumulator_mod[0]));
-    memset(count_mod, 0, 1024 * 3 * sizeof(count_mod[0]));
-
-    params_.ref_func(src1_, stride, src2_, stride2, width, height, strength,
-                     sigma, decay_control, &blk_fw, use32X32, accumulator_ref,
-                     count_ref);
-    params_.tst_func(src1_, stride, src2_, stride2, width, height, strength,
-                     sigma, decay_control, &blk_fw, use32X32, accumulator_mod,
-                     count_mod);
-
-    if (run_times > 1) {
-      aom_usec_timer_start(&ref_timer);
-      for (int j = 0; j < run_times; j++) {
-        params_.ref_func(src1_, stride, src2_, stride2, width, height, strength,
-                         sigma, decay_control, &blk_fw, use32X32,
-                         accumulator_ref, count_ref);
-      }
-      aom_usec_timer_mark(&ref_timer);
-      const int elapsed_time_c =
-          static_cast<int>(aom_usec_timer_elapsed(&ref_timer));
-
-      aom_usec_timer_start(&test_timer);
-      for (int j = 0; j < run_times; j++) {
-        params_.tst_func(src1_, stride, src2_, stride2, width, height, strength,
-                         sigma, decay_control, &blk_fw, use32X32,
-                         accumulator_mod, count_mod);
-      }
-      aom_usec_timer_mark(&test_timer);
-      const int elapsed_time_simd =
-          static_cast<int>(aom_usec_timer_elapsed(&test_timer));
-
-      printf(
-          "c_time=%d \t simd_time=%d \t "
-          "gain=%f\t width=%d\t height=%d \n",
-          elapsed_time_c, elapsed_time_simd,
-          (float)((float)elapsed_time_c / (float)elapsed_time_simd), width,
-          height);
-
-    } else {
-      for (int i = 0, l = 0; i < height; i++) {
-        for (int j = 0; j < width; j++, l++) {
-          EXPECT_EQ(accumulator_ref[l], accumulator_mod[l])
-              << "Error:" << k << " SSE Sum Test [" << width << "x" << height
-              << "] C accumulator does not match optimized accumulator.";
-          EXPECT_EQ(count_ref[l], count_mod[l])
-              << "Error:" << k << " SSE Sum Test [" << width << "x" << height
-              << "] C count does not match optimized count.";
-        }
-      }
-    }
-  }
-}
-
-TEST_P(TemporalFilterTest, OperationCheck) {
-  for (int height = 16; height <= 32; height = height * 2) {
-    RunTest(1, height, height, 1);  // GenRandomData
-  }
-}
-
-TEST_P(TemporalFilterTest, ExtremeValues) {
-  for (int height = 16; height <= 32; height = height * 2) {
-    RunTest(0, height, height, 1);
-  }
-}
-
-TEST_P(TemporalFilterTest, DISABLED_Speed) {
-  for (int height = 16; height <= 32; height = height * 2) {
-    RunTest(1, height, height, 100000);
-  }
-}
-
-#if HAVE_AVX2
-TestTemporal_FilterPlane Temporal_filter_test_avx2[] = {
-  TestTemporal_FilterPlane(&av1_temporal_filter_plane_c,
-                           &av1_temporal_filter_plane_avx2)
-};
-INSTANTIATE_TEST_CASE_P(AVX2, TemporalFilterTest,
-                        Combine(ValuesIn(Temporal_filter_test_avx2),
-                                Range(64, 65, 4)));
-#endif  // HAVE_AVX2
-
-#if HAVE_SSE2
-TestTemporal_FilterPlane Temporal_filter_test_sse2[] = {
-  TestTemporal_FilterPlane(&av1_temporal_filter_plane_c,
-                           &av1_temporal_filter_plane_sse2)
-};
-INSTANTIATE_TEST_CASE_P(SSE2, TemporalFilterTest,
-                        Combine(ValuesIn(Temporal_filter_test_sse2),
-                                Range(64, 65, 4)));
-#endif  // HAVE_SSE2
-
-}  // namespace
-#endif
diff --git a/test/temporal_filter_planewise_test.cc b/test/temporal_filter_planewise_test.cc
new file mode 100644
index 0000000..947ffde
--- /dev/null
+++ b/test/temporal_filter_planewise_test.cc
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) 2019, Alliance for Open Media. All rights reserved
+ *
+ * This source code is subject to the terms of the BSD 2 Clause License and
+ * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
+ * was not distributed with this source code in the LICENSE file, you can
+ * obtain it at www.aomedia.org/license/software. If the Alliance for Open
+ * Media Patent License 1.0 was not distributed with this source code in the
+ * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
+ */
+
+#include <cmath>
+#include <cstdlib>
+#include <string>
+
+#include "third_party/googletest/src/googletest/include/gtest/gtest.h"
+
+#include "config/aom_config.h"
+#include "config/aom_dsp_rtcd.h"
+#include "config/av1_rtcd.h"
+
+#include "aom_ports/mem.h"
+#include "test/acm_random.h"
+#include "test/clear_system_state.h"
+#include "test/register_state_check.h"
+#include "test/util.h"
+#include "test/function_equivalence_test.h"
+
+using libaom_test::ACMRandom;
+using libaom_test::FunctionEquivalenceTest;
+using ::testing::Combine;
+using ::testing::Range;
+using ::testing::Values;
+using ::testing::ValuesIn;
+
+#if !CONFIG_REALTIME_ONLY
+namespace {
+
+typedef void (*TemporalFilterPlanewiseFunc)(
+    const YV12_BUFFER_CONFIG *ref_frame, const MACROBLOCKD *mbd,
+    const BLOCK_SIZE block_size, const int mb_row, const int mb_col,
+    const int num_planes, const double noise_level, const uint8_t *pred,
+    uint32_t *accum, uint16_t *count);
+typedef libaom_test::FuncParam<TemporalFilterPlanewiseFunc>
+    TemporalFilterPlanewiseFuncParam;
+
+typedef ::testing::tuple<TemporalFilterPlanewiseFuncParam, int>
+    TemporalFilterPlanewiseWithParam;
+
+class TemporalFilterPlanewiseTest
+    : public ::testing::TestWithParam<TemporalFilterPlanewiseWithParam> {
+ public:
+  virtual ~TemporalFilterPlanewiseTest() {}
+  virtual void SetUp() {
+    params_ = GET_PARAM(0);
+    rnd_.Reset(ACMRandom::DeterministicSeed());
+    src1_ = reinterpret_cast<uint8_t *>(aom_memalign(8, 256 * 256));
+    src2_ = reinterpret_cast<uint8_t *>(aom_memalign(8, 256 * 256));
+
+    ASSERT_TRUE(src1_ != NULL);
+    ASSERT_TRUE(src2_ != NULL);
+  }
+
+  virtual void TearDown() {
+    libaom_test::ClearSystemState();
+    aom_free(src1_);
+    aom_free(src2_);
+  }
+  void RunTest(int isRandom, int width, int height, int run_times);
+
+  void GenRandomData(int width, int height, int stride, int stride2) {
+    for (int ii = 0; ii < height; ii++) {
+      for (int jj = 0; jj < width; jj++) {
+        src1_[ii * stride + jj] = rnd_.Rand8();
+        src2_[ii * stride2 + jj] = rnd_.Rand8();
+      }
+    }
+  }
+
+  void GenExtremeData(int width, int height, int stride, uint8_t *data,
+                      int stride2, uint8_t *data2, uint8_t val) {
+    for (int ii = 0; ii < height; ii++) {
+      for (int jj = 0; jj < width; jj++) {
+        data[ii * stride + jj] = val;
+        data2[ii * stride2 + jj] = (255 - val);
+      }
+    }
+  }
+
+ protected:
+  TemporalFilterPlanewiseFuncParam params_;
+  uint8_t *src1_;
+  uint8_t *src2_;
+  ACMRandom rnd_;
+};
+
+void TemporalFilterPlanewiseTest::RunTest(int isRandom, int width, int height,
+                                          int run_times) {
+  aom_usec_timer ref_timer, test_timer;
+  for (int k = 0; k < 3; k++) {
+    const int stride = width;
+    const int stride2 = width;
+    if (isRandom) {
+      GenRandomData(width, height, stride, stride2);
+    } else {
+      const int msb = 8;  // Up to 8 bit input
+      const int limit = (1 << msb) - 1;
+      if (k == 0) {
+        GenExtremeData(width, height, stride, src1_, stride2, src2_, limit);
+      } else {
+        GenExtremeData(width, height, stride, src1_, stride2, src2_, 0);
+      }
+    }
+    double sigma = 2.1002103677063437;
+    DECLARE_ALIGNED(16, unsigned int, accumulator_ref[1024 * 3]);
+    DECLARE_ALIGNED(16, uint16_t, count_ref[1024 * 3]);
+    memset(accumulator_ref, 0, 1024 * 3 * sizeof(accumulator_ref[0]));
+    memset(count_ref, 0, 1024 * 3 * sizeof(count_ref[0]));
+    DECLARE_ALIGNED(16, unsigned int, accumulator_mod[1024 * 3]);
+    DECLARE_ALIGNED(16, uint16_t, count_mod[1024 * 3]);
+    memset(accumulator_mod, 0, 1024 * 3 * sizeof(accumulator_mod[0]));
+    memset(count_mod, 0, 1024 * 3 * sizeof(count_mod[0]));
+
+    assert(width == 32 && height == 32);
+    const BLOCK_SIZE block_size = BLOCK_32X32;
+    const int mb_row = 0;
+    const int mb_col = 0;
+    const int num_planes = 1;
+    YV12_BUFFER_CONFIG *ref_frame =
+        (YV12_BUFFER_CONFIG *)malloc(sizeof(YV12_BUFFER_CONFIG));
+    ref_frame->heights[0] = height;
+    ref_frame->strides[0] = stride;
+    DECLARE_ALIGNED(16, uint8_t, src[1024 * 3]);
+    ref_frame->buffer_alloc = src;
+    ref_frame->buffers[0] = ref_frame->buffer_alloc;
+    ref_frame->flags = 0;  // Only support low bit-depth test.
+    memcpy(src, src1_, 1024 * 3 * sizeof(uint8_t));
+
+    MACROBLOCKD *mbd = (MACROBLOCKD *)malloc(sizeof(MACROBLOCKD));
+    mbd->plane[0].subsampling_y = 0;
+    mbd->plane[0].subsampling_x = 0;
+
+    params_.ref_func(ref_frame, mbd, block_size, mb_row, mb_col, num_planes,
+                     sigma, src2_, accumulator_ref, count_ref);
+    params_.tst_func(ref_frame, mbd, block_size, mb_row, mb_col, num_planes,
+                     sigma, src2_, accumulator_mod, count_mod);
+
+    if (run_times > 1) {
+      aom_usec_timer_start(&ref_timer);
+      for (int j = 0; j < run_times; j++) {
+        params_.ref_func(ref_frame, mbd, block_size, mb_row, mb_col, num_planes,
+                         sigma, src2_, accumulator_ref, count_ref);
+      }
+      aom_usec_timer_mark(&ref_timer);
+      const int elapsed_time_c =
+          static_cast<int>(aom_usec_timer_elapsed(&ref_timer));
+
+      aom_usec_timer_start(&test_timer);
+      for (int j = 0; j < run_times; j++) {
+        params_.tst_func(ref_frame, mbd, block_size, mb_row, mb_col, num_planes,
+                         sigma, src2_, accumulator_mod, count_mod);
+      }
+      aom_usec_timer_mark(&test_timer);
+      const int elapsed_time_simd =
+          static_cast<int>(aom_usec_timer_elapsed(&test_timer));
+
+      printf(
+          "c_time=%d \t simd_time=%d \t "
+          "gain=%f\t width=%d\t height=%d \n",
+          elapsed_time_c, elapsed_time_simd,
+          (float)((float)elapsed_time_c / (float)elapsed_time_simd), width,
+          height);
+
+    } else {
+      for (int i = 0, l = 0; i < height; i++) {
+        for (int j = 0; j < width; j++, l++) {
+          EXPECT_EQ(accumulator_ref[l], accumulator_mod[l])
+              << "Error:" << k << " SSE Sum Test [" << width << "x" << height
+              << "] C accumulator does not match optimized accumulator.";
+          EXPECT_EQ(count_ref[l], count_mod[l])
+              << "Error:" << k << " SSE Sum Test [" << width << "x" << height
+              << "] C count does not match optimized count.";
+        }
+      }
+    }
+
+    free(ref_frame);
+    free(mbd);
+  }
+}
+
+TEST_P(TemporalFilterPlanewiseTest, OperationCheck) {
+  for (int height = 32; height <= 32; height = height * 2) {
+    RunTest(1, height, height, 1);  // GenRandomData
+  }
+}
+
+TEST_P(TemporalFilterPlanewiseTest, ExtremeValues) {
+  for (int height = 32; height <= 32; height = height * 2) {
+    RunTest(0, height, height, 1);
+  }
+}
+
+TEST_P(TemporalFilterPlanewiseTest, DISABLED_Speed) {
+  for (int height = 32; height <= 32; height = height * 2) {
+    RunTest(1, height, height, 100000);
+  }
+}
+
+#if HAVE_AVX2
+TemporalFilterPlanewiseFuncParam temporal_filter_planewise_test_avx2[] = {
+  TemporalFilterPlanewiseFuncParam(&av1_apply_temporal_filter_planewise_c,
+                                   &av1_apply_temporal_filter_planewise_avx2)
+};
+INSTANTIATE_TEST_CASE_P(AVX2, TemporalFilterPlanewiseTest,
+                        Combine(ValuesIn(temporal_filter_planewise_test_avx2),
+                                Range(64, 65, 4)));
+#endif  // HAVE_AVX2
+
+#if HAVE_SSE2
+TemporalFilterPlanewiseFuncParam temporal_filter_planewise_test_sse2[] = {
+  TemporalFilterPlanewiseFuncParam(&av1_apply_temporal_filter_planewise_c,
+                                   &av1_apply_temporal_filter_planewise_sse2)
+};
+INSTANTIATE_TEST_CASE_P(SSE2, TemporalFilterPlanewiseTest,
+                        Combine(ValuesIn(temporal_filter_planewise_test_sse2),
+                                Range(64, 65, 4)));
+#endif  // HAVE_SSE2
+
+}  // namespace
+#endif
diff --git a/test/test.cmake b/test/test.cmake
index 05f0864..b66159b 100644
--- a/test/test.cmake
+++ b/test/test.cmake
@@ -131,7 +131,7 @@
                 "${AOM_ROOT}/test/segment_binarization_sync.cc"
                 "${AOM_ROOT}/test/superframe_test.cc"
                 "${AOM_ROOT}/test/tile_independence_test.cc"
-                "${AOM_ROOT}/test/temporal_filter_plane_test.cc"
+                "${AOM_ROOT}/test/temporal_filter_planewise_test.cc"
                 "${AOM_ROOT}/test/temporal_filter_yuv_test.cc")
     if(CONFIG_REALTIME_ONLY)
       list(REMOVE_ITEM AOM_UNIT_TEST_COMMON_SOURCES