diff --git a/modules/audio_processing/aec3/adaptive_fir_filter.cc b/modules/audio_processing/aec3/adaptive_fir_filter.cc
index 00fa884..6a0f531 100644
--- a/modules/audio_processing/aec3/adaptive_fir_filter.cc
+++ b/modules/audio_processing/aec3/adaptive_fir_filter.cc
@@ -19,6 +19,8 @@
 #if defined(WEBRTC_ARCH_X86_FAMILY)
 #include <emmintrin.h>
 #endif
+#include <math.h>
+
 #include <algorithm>
 #include <functional>
 
@@ -30,207 +32,255 @@
 namespace aec3 {
 
 // Computes and stores the frequency response of the filter.
-void UpdateFrequencyResponse(
-    rtc::ArrayView<const FftData> H,
+void ComputeFrequencyResponse(
+    size_t num_partitions,
+    const std::vector<std::vector<FftData>>& H,
     std::vector<std::array<float, kFftLengthBy2Plus1>>* H2) {
-  RTC_DCHECK_EQ(H.size(), H2->size());
-  for (size_t k = 0; k < H.size(); ++k) {
-    std::transform(H[k].re.begin(), H[k].re.end(), H[k].im.begin(),
-                   (*H2)[k].begin(),
-                   [](float a, float b) { return a * a + b * b; });
+  for (auto& H2_ch : *H2) {
+    H2_ch.fill(0.f);
+  }
+
+  const size_t num_render_channels = H[0].size();
+  RTC_DCHECK_EQ(H.size(), H2->capacity());
+  for (size_t p = 0; p < num_partitions; ++p) {
+    RTC_DCHECK_EQ(kFftLengthBy2Plus1, (*H2)[p].size());
+    for (size_t ch = 0; ch < num_render_channels; ++ch) {
+      for (size_t j = 0; j < kFftLengthBy2Plus1; ++j) {
+        float tmp =
+            H[p][ch].re[j] * H[p][ch].re[j] + H[p][ch].im[j] * H[p][ch].im[j];
+        (*H2)[p][j] = std::max((*H2)[p][j], tmp);
+      }
+    }
   }
 }
 
 #if defined(WEBRTC_HAS_NEON)
 // Computes and stores the frequency response of the filter.
-void UpdateFrequencyResponse_NEON(
-    rtc::ArrayView<const FftData> H,
+void ComputeFrequencyResponse_Neon(
+    size_t num_partitions,
+    const std::vector<std::vector<FftData>>& H,
     std::vector<std::array<float, kFftLengthBy2Plus1>>* H2) {
-  RTC_DCHECK_EQ(H.size(), H2->size());
-  for (size_t k = 0; k < H.size(); ++k) {
-    for (size_t j = 0; j < kFftLengthBy2; j += 4) {
-      const float32x4_t re = vld1q_f32(&H[k].re[j]);
-      const float32x4_t im = vld1q_f32(&H[k].im[j]);
-      float32x4_t H2_k_j = vmulq_f32(re, re);
-      H2_k_j = vmlaq_f32(H2_k_j, im, im);
-      vst1q_f32(&(*H2)[k][j], H2_k_j);
+  for (auto& H2_ch : *H2) {
+    H2_ch.fill(0.f);
+  }
+
+  const size_t num_render_channels = H[0].size();
+  RTC_DCHECK_EQ(H.size(), H2->capacity());
+  for (size_t p = 0; p < num_partitions; ++p) {
+    RTC_DCHECK_EQ(kFftLengthBy2Plus1, (*H2)[p].size());
+    for (size_t ch = 0; ch < num_render_channels; ++ch) {
+      for (size_t j = 0; j < kFftLengthBy2; j += 4) {
+        const float32x4_t re = vld1q_f32(&H[p][ch].re[j]);
+        const float32x4_t im = vld1q_f32(&H[p][ch].im[j]);
+        float32x4_t H2_new = vmulq_f32(re, re);
+        H2_new = vmlaq_f32(H2_new, im, im);
+        float32x4_t H2_p_j = vld1q_f32(&(*H2)[p][j]);
+        H2_p_j = vmaxq_f32(H2_p_j, H2_new);
+        vst1q_f32(&(*H2)[p][j], H2_p_j);
+      }
+      float H2_new = H[p][ch].re[kFftLengthBy2] * H[p][ch].re[kFftLengthBy2] +
+                     H[p][ch].im[kFftLengthBy2] * H[p][ch].im[kFftLengthBy2];
+      (*H2)[p][kFftLengthBy2] = std::max((*H2)[p][kFftLengthBy2], H2_new);
     }
-    (*H2)[k][kFftLengthBy2] = H[k].re[kFftLengthBy2] * H[k].re[kFftLengthBy2] +
-                              H[k].im[kFftLengthBy2] * H[k].im[kFftLengthBy2];
   }
 }
 #endif
 
 #if defined(WEBRTC_ARCH_X86_FAMILY)
 // Computes and stores the frequency response of the filter.
-void UpdateFrequencyResponse_SSE2(
-    rtc::ArrayView<const FftData> H,
+void ComputeFrequencyResponse_Sse2(
+    size_t num_partitions,
+    const std::vector<std::vector<FftData>>& H,
     std::vector<std::array<float, kFftLengthBy2Plus1>>* H2) {
-  RTC_DCHECK_EQ(H.size(), H2->size());
-  for (size_t k = 0; k < H.size(); ++k) {
-    for (size_t j = 0; j < kFftLengthBy2; j += 4) {
-      const __m128 re = _mm_loadu_ps(&H[k].re[j]);
-      const __m128 re2 = _mm_mul_ps(re, re);
-      const __m128 im = _mm_loadu_ps(&H[k].im[j]);
-      const __m128 im2 = _mm_mul_ps(im, im);
-      const __m128 H2_k_j = _mm_add_ps(re2, im2);
-      _mm_storeu_ps(&(*H2)[k][j], H2_k_j);
+  for (auto& H2_ch : *H2) {
+    H2_ch.fill(0.f);
+  }
+
+  const size_t num_render_channels = H[0].size();
+  RTC_DCHECK_EQ(H.size(), H2->capacity());
+  // constexpr __mmmask8 kMaxMask = static_cast<__mmmask8>(256u);
+  for (size_t p = 0; p < num_partitions; ++p) {
+    RTC_DCHECK_EQ(kFftLengthBy2Plus1, (*H2)[p].size());
+    for (size_t ch = 0; ch < num_render_channels; ++ch) {
+      for (size_t j = 0; j < kFftLengthBy2; j += 4) {
+        const __m128 re = _mm_loadu_ps(&H[p][ch].re[j]);
+        const __m128 re2 = _mm_mul_ps(re, re);
+        const __m128 im = _mm_loadu_ps(&H[p][ch].im[j]);
+        const __m128 im2 = _mm_mul_ps(im, im);
+        const __m128 H2_new = _mm_add_ps(re2, im2);
+        __m128 H2_k_j = _mm_loadu_ps(&(*H2)[p][j]);
+        H2_k_j = _mm_max_ps(H2_k_j, H2_new);
+        _mm_storeu_ps(&(*H2)[p][j], H2_k_j);
+      }
+      float H2_new = H[p][ch].re[kFftLengthBy2] * H[p][ch].re[kFftLengthBy2] +
+                     H[p][ch].im[kFftLengthBy2] * H[p][ch].im[kFftLengthBy2];
+      (*H2)[p][kFftLengthBy2] = std::max((*H2)[p][kFftLengthBy2], H2_new);
     }
-    (*H2)[k][kFftLengthBy2] = H[k].re[kFftLengthBy2] * H[k].re[kFftLengthBy2] +
-                              H[k].im[kFftLengthBy2] * H[k].im[kFftLengthBy2];
   }
 }
 #endif
 
-
 // Adapts the filter partitions as H(t+1)=H(t)+G(t)*conj(X(t)).
 void AdaptPartitions(const RenderBuffer& render_buffer,
                      const FftData& G,
-                     rtc::ArrayView<FftData> H) {
+                     size_t num_partitions,
+                     std::vector<std::vector<FftData>>* H) {
   rtc::ArrayView<const std::vector<FftData>> render_buffer_data =
       render_buffer.GetFftBuffer();
   size_t index = render_buffer.Position();
-  for (auto& H_j : H) {
-    const FftData& X = render_buffer_data[index][/*channel=*/0];
-    for (size_t k = 0; k < kFftLengthBy2Plus1; ++k) {
-      H_j.re[k] += X.re[k] * G.re[k] + X.im[k] * G.im[k];
-      H_j.im[k] += X.re[k] * G.im[k] - X.im[k] * G.re[k];
+  const size_t num_render_channels = render_buffer_data[index].size();
+  for (size_t p = 0; p < num_partitions; ++p) {
+    for (size_t ch = 0; ch < num_render_channels; ++ch) {
+      const FftData& X_p_ch = render_buffer_data[index][ch];
+      FftData& H_p_ch = (*H)[p][ch];
+      for (size_t k = 0; k < kFftLengthBy2Plus1; ++k) {
+        H_p_ch.re[k] += X_p_ch.re[k] * G.re[k] + X_p_ch.im[k] * G.im[k];
+        H_p_ch.im[k] += X_p_ch.re[k] * G.im[k] - X_p_ch.im[k] * G.re[k];
+      }
     }
-
     index = index < (render_buffer_data.size() - 1) ? index + 1 : 0;
   }
 }
 
 #if defined(WEBRTC_HAS_NEON)
-// Adapts the filter partitions. (NEON variant)
-void AdaptPartitions_NEON(const RenderBuffer& render_buffer,
+// Adapts the filter partitions. (Neon variant)
+void AdaptPartitions_Neon(const RenderBuffer& render_buffer,
                           const FftData& G,
-                          rtc::ArrayView<FftData> H) {
+                          size_t num_partitions,
+                          std::vector<std::vector<FftData>>* H) {
   rtc::ArrayView<const std::vector<FftData>> render_buffer_data =
       render_buffer.GetFftBuffer();
-  const int lim1 =
-      std::min(render_buffer_data.size() - render_buffer.Position(), H.size());
-  const int lim2 = H.size();
-  constexpr int kNumFourBinBands = kFftLengthBy2 / 4;
-  FftData* H_j = &H[0];
-  const std::vector<FftData>* X_channels =
-      &render_buffer_data[render_buffer.Position()];
-  int limit = lim1;
-  int j = 0;
-  do {
-    for (; j < limit; ++j, ++H_j, ++X_channels) {
-      const FftData& X = (*X_channels)[/*channel=*/0];
-      for (int k = 0, n = 0; n < kNumFourBinBands; ++n, k += 4) {
-        const float32x4_t G_re = vld1q_f32(&G.re[k]);
-        const float32x4_t G_im = vld1q_f32(&G.im[k]);
-        const float32x4_t X_re = vld1q_f32(&X.re[k]);
-        const float32x4_t X_im = vld1q_f32(&X.im[k]);
-        const float32x4_t H_re = vld1q_f32(&H_j->re[k]);
-        const float32x4_t H_im = vld1q_f32(&H_j->im[k]);
-        const float32x4_t a = vmulq_f32(X_re, G_re);
-        const float32x4_t e = vmlaq_f32(a, X_im, G_im);
-        const float32x4_t c = vmulq_f32(X_re, G_im);
-        const float32x4_t f = vmlsq_f32(c, X_im, G_re);
-        const float32x4_t g = vaddq_f32(H_re, e);
-        const float32x4_t h = vaddq_f32(H_im, f);
+  const size_t num_render_channels = render_buffer_data[0].size();
+  const size_t lim1 = std::min(
+      render_buffer_data.size() - render_buffer.Position(), num_partitions);
+  const size_t lim2 = num_partitions;
+  constexpr size_t kNumFourBinBands = kFftLengthBy2 / 4;
 
-        vst1q_f32(&H_j->re[k], g);
-        vst1q_f32(&H_j->im[k], h);
+  size_t X_partition = render_buffer.Position();
+  size_t limit = lim1;
+  size_t p = 0;
+  do {
+    for (; p < limit; ++p, ++X_partition) {
+      for (size_t ch = 0; ch < num_render_channels; ++ch) {
+        FftData& H_p_ch = (*H)[p][ch];
+        const FftData& X = render_buffer_data[X_partition][ch];
+        for (size_t k = 0, n = 0; n < kNumFourBinBands; ++n, k += 4) {
+          const float32x4_t G_re = vld1q_f32(&G.re[k]);
+          const float32x4_t G_im = vld1q_f32(&G.im[k]);
+          const float32x4_t X_re = vld1q_f32(&X.re[k]);
+          const float32x4_t X_im = vld1q_f32(&X.im[k]);
+          const float32x4_t H_re = vld1q_f32(&H_p_ch.re[k]);
+          const float32x4_t H_im = vld1q_f32(&H_p_ch.im[k]);
+          const float32x4_t a = vmulq_f32(X_re, G_re);
+          const float32x4_t e = vmlaq_f32(a, X_im, G_im);
+          const float32x4_t c = vmulq_f32(X_re, G_im);
+          const float32x4_t f = vmlsq_f32(c, X_im, G_re);
+          const float32x4_t g = vaddq_f32(H_re, e);
+          const float32x4_t h = vaddq_f32(H_im, f);
+          vst1q_f32(&H_p_ch.re[k], g);
+          vst1q_f32(&H_p_ch.im[k], h);
+        }
       }
     }
 
-    X_channels = &render_buffer_data[0];
+    X_partition = 0;
     limit = lim2;
-  } while (j < lim2);
+  } while (p < lim2);
 
-  H_j = &H[0];
-  X_channels = &render_buffer_data[render_buffer.Position()];
+  X_partition = render_buffer.Position();
   limit = lim1;
-  j = 0;
+  p = 0;
   do {
-    for (; j < limit; ++j, ++H_j, ++X_channels) {
-      const FftData& X = (*X_channels)[/*channel=*/0];
-      H_j->re[kFftLengthBy2] += X.re[kFftLengthBy2] * G.re[kFftLengthBy2] +
-                                X.im[kFftLengthBy2] * G.im[kFftLengthBy2];
-      H_j->im[kFftLengthBy2] += X.re[kFftLengthBy2] * G.im[kFftLengthBy2] -
-                                X.im[kFftLengthBy2] * G.re[kFftLengthBy2];
-    }
+    for (; p < limit; ++p, ++X_partition) {
+      for (size_t ch = 0; ch < num_render_channels; ++ch) {
+        FftData& H_p_ch = (*H)[p][ch];
+        const FftData& X = render_buffer_data[X_partition][ch];
 
-    X_channels = &render_buffer_data[0];
+        H_p_ch.re[kFftLengthBy2] += X.re[kFftLengthBy2] * G.re[kFftLengthBy2] +
+                                    X.im[kFftLengthBy2] * G.im[kFftLengthBy2];
+        H_p_ch.im[kFftLengthBy2] += X.re[kFftLengthBy2] * G.im[kFftLengthBy2] -
+                                    X.im[kFftLengthBy2] * G.re[kFftLengthBy2];
+      }
+    }
+    X_partition = 0;
     limit = lim2;
-  } while (j < lim2);
+  } while (p < lim2);
 }
 #endif
 
 #if defined(WEBRTC_ARCH_X86_FAMILY)
 // Adapts the filter partitions. (SSE2 variant)
-void AdaptPartitions_SSE2(const RenderBuffer& render_buffer,
+void AdaptPartitions_Sse2(const RenderBuffer& render_buffer,
                           const FftData& G,
-                          rtc::ArrayView<FftData> H) {
+                          size_t num_partitions,
+                          std::vector<std::vector<FftData>>* H) {
   rtc::ArrayView<const std::vector<FftData>> render_buffer_data =
       render_buffer.GetFftBuffer();
-  const int lim1 =
-      std::min(render_buffer_data.size() - render_buffer.Position(), H.size());
-  const int lim2 = H.size();
-  constexpr int kNumFourBinBands = kFftLengthBy2 / 4;
-  FftData* H_j;
-  const std::vector<FftData>* X_channels;
-  int limit;
-  int j;
-  for (int k = 0, n = 0; n < kNumFourBinBands; ++n, k += 4) {
-    const __m128 G_re = _mm_loadu_ps(&G.re[k]);
-    const __m128 G_im = _mm_loadu_ps(&G.im[k]);
+  const size_t num_render_channels = render_buffer_data[0].size();
+  const size_t lim1 = std::min(
+      render_buffer_data.size() - render_buffer.Position(), num_partitions);
+  const size_t lim2 = num_partitions;
+  constexpr size_t kNumFourBinBands = kFftLengthBy2 / 4;
 
-    H_j = &H[0];
-    X_channels = &render_buffer_data[render_buffer.Position()];
-    limit = lim1;
-    j = 0;
-    do {
-      for (; j < limit; ++j, ++H_j, ++X_channels) {
-        const FftData& X = (*X_channels)[/*channel=*/0];
-        const __m128 X_re = _mm_loadu_ps(&X.re[k]);
-        const __m128 X_im = _mm_loadu_ps(&X.im[k]);
-        const __m128 H_re = _mm_loadu_ps(&H_j->re[k]);
-        const __m128 H_im = _mm_loadu_ps(&H_j->im[k]);
-        const __m128 a = _mm_mul_ps(X_re, G_re);
-        const __m128 b = _mm_mul_ps(X_im, G_im);
-        const __m128 c = _mm_mul_ps(X_re, G_im);
-        const __m128 d = _mm_mul_ps(X_im, G_re);
-        const __m128 e = _mm_add_ps(a, b);
-        const __m128 f = _mm_sub_ps(c, d);
-        const __m128 g = _mm_add_ps(H_re, e);
-        const __m128 h = _mm_add_ps(H_im, f);
-        _mm_storeu_ps(&H_j->re[k], g);
-        _mm_storeu_ps(&H_j->im[k], h);
-      }
-
-      X_channels = &render_buffer_data[0];
-      limit = lim2;
-    } while (j < lim2);
-  }
-
-  H_j = &H[0];
-  X_channels = &render_buffer_data[render_buffer.Position()];
-  limit = lim1;
-  j = 0;
+  size_t X_partition = render_buffer.Position();
+  size_t limit = lim1;
+  size_t p = 0;
   do {
-    for (; j < limit; ++j, ++H_j, ++X_channels) {
-      const FftData& X = (*X_channels)[/*channel=*/0];
-      H_j->re[kFftLengthBy2] += X.re[kFftLengthBy2] * G.re[kFftLengthBy2] +
-                                X.im[kFftLengthBy2] * G.im[kFftLengthBy2];
-      H_j->im[kFftLengthBy2] += X.re[kFftLengthBy2] * G.im[kFftLengthBy2] -
-                                X.im[kFftLengthBy2] * G.re[kFftLengthBy2];
+    for (; p < limit; ++p, ++X_partition) {
+      for (size_t ch = 0; ch < num_render_channels; ++ch) {
+        FftData& H_p_ch = (*H)[p][ch];
+        const FftData& X = render_buffer_data[X_partition][ch];
+
+        for (size_t k = 0, n = 0; n < kNumFourBinBands; ++n, k += 4) {
+          const __m128 G_re = _mm_loadu_ps(&G.re[k]);
+          const __m128 G_im = _mm_loadu_ps(&G.im[k]);
+          const __m128 X_re = _mm_loadu_ps(&X.re[k]);
+          const __m128 X_im = _mm_loadu_ps(&X.im[k]);
+          const __m128 H_re = _mm_loadu_ps(&H_p_ch.re[k]);
+          const __m128 H_im = _mm_loadu_ps(&H_p_ch.im[k]);
+          const __m128 a = _mm_mul_ps(X_re, G_re);
+          const __m128 b = _mm_mul_ps(X_im, G_im);
+          const __m128 c = _mm_mul_ps(X_re, G_im);
+          const __m128 d = _mm_mul_ps(X_im, G_re);
+          const __m128 e = _mm_add_ps(a, b);
+          const __m128 f = _mm_sub_ps(c, d);
+          const __m128 g = _mm_add_ps(H_re, e);
+          const __m128 h = _mm_add_ps(H_im, f);
+          _mm_storeu_ps(&H_p_ch.re[k], g);
+          _mm_storeu_ps(&H_p_ch.im[k], h);
+        }
+      }
+    }
+    X_partition = 0;
+    limit = lim2;
+  } while (p < lim2);
+
+  X_partition = render_buffer.Position();
+  limit = lim1;
+  p = 0;
+  do {
+    for (; p < limit; ++p, ++X_partition) {
+      for (size_t ch = 0; ch < num_render_channels; ++ch) {
+        FftData& H_p_ch = (*H)[p][ch];
+        const FftData& X = render_buffer_data[X_partition][ch];
+
+        H_p_ch.re[kFftLengthBy2] += X.re[kFftLengthBy2] * G.re[kFftLengthBy2] +
+                                    X.im[kFftLengthBy2] * G.im[kFftLengthBy2];
+        H_p_ch.im[kFftLengthBy2] += X.re[kFftLengthBy2] * G.im[kFftLengthBy2] -
+                                    X.im[kFftLengthBy2] * G.re[kFftLengthBy2];
+      }
     }
 
-    X_channels = &render_buffer_data[0];
+    X_partition = 0;
     limit = lim2;
-  } while (j < lim2);
+  } while (p < lim2);
 }
 #endif
 
 // Produces the filter output.
 void ApplyFilter(const RenderBuffer& render_buffer,
-                 rtc::ArrayView<const FftData> H,
+                 size_t num_partitions,
+                 const std::vector<std::vector<FftData>>& H,
                  FftData* S) {
   S->re.fill(0.f);
   S->im.fill(0.f);
@@ -238,184 +288,219 @@
   rtc::ArrayView<const std::vector<FftData>> render_buffer_data =
       render_buffer.GetFftBuffer();
   size_t index = render_buffer.Position();
-  for (auto& H_j : H) {
-    const FftData& X = render_buffer_data[index][0];
-    for (size_t k = 0; k < kFftLengthBy2Plus1; ++k) {
-      S->re[k] += X.re[k] * H_j.re[k] - X.im[k] * H_j.im[k];
-      S->im[k] += X.re[k] * H_j.im[k] + X.im[k] * H_j.re[k];
+  const size_t num_render_channels = render_buffer_data[index].size();
+  for (size_t p = 0; p < num_partitions; ++p) {
+    RTC_DCHECK_EQ(num_render_channels, H[p].size());
+    for (size_t ch = 0; ch < num_render_channels; ++ch) {
+      const FftData& X_p_ch = render_buffer_data[index][ch];
+      const FftData& H_p_ch = H[p][ch];
+      for (size_t k = 0; k < kFftLengthBy2Plus1; ++k) {
+        S->re[k] += X_p_ch.re[k] * H_p_ch.re[k] - X_p_ch.im[k] * H_p_ch.im[k];
+        S->im[k] += X_p_ch.re[k] * H_p_ch.im[k] + X_p_ch.im[k] * H_p_ch.re[k];
+      }
     }
     index = index < (render_buffer_data.size() - 1) ? index + 1 : 0;
   }
 }
 
 #if defined(WEBRTC_HAS_NEON)
-// Produces the filter output (NEON variant).
-void ApplyFilter_NEON(const RenderBuffer& render_buffer,
-                      rtc::ArrayView<const FftData> H,
+// Produces the filter output (Neon variant).
+void ApplyFilter_Neon(const RenderBuffer& render_buffer,
+                      size_t num_partitions,
+                      const std::vector<std::vector<FftData>>& H,
                       FftData* S) {
+  // const RenderBuffer& render_buffer,
+  //                     rtc::ArrayView<const FftData> H,
+  //                     FftData* S) {
   RTC_DCHECK_GE(H.size(), H.size() - 1);
   S->Clear();
 
   rtc::ArrayView<const std::vector<FftData>> render_buffer_data =
       render_buffer.GetFftBuffer();
-  const int lim1 =
-      std::min(render_buffer_data.size() - render_buffer.Position(), H.size());
-  const int lim2 = H.size();
-  constexpr int kNumFourBinBands = kFftLengthBy2 / 4;
-  const FftData* H_j = &H[0];
-  const std::vector<FftData>* X_channels =
-      &render_buffer_data[render_buffer.Position()];
+  const size_t num_render_channels = render_buffer_data[0].size();
+  const size_t lim1 = std::min(
+      render_buffer_data.size() - render_buffer.Position(), num_partitions);
+  const size_t lim2 = num_partitions;
+  constexpr size_t kNumFourBinBands = kFftLengthBy2 / 4;
 
-  int j = 0;
-  int limit = lim1;
+  size_t X_partition = render_buffer.Position();
+  size_t p = 0;
+  size_t limit = lim1;
   do {
-    for (; j < limit; ++j, ++H_j, ++X_channels) {
-      const FftData& X = (*X_channels)[/*channel=*/0];
-      for (int k = 0, n = 0; n < kNumFourBinBands; ++n, k += 4) {
-        const float32x4_t X_re = vld1q_f32(&X.re[k]);
-        const float32x4_t X_im = vld1q_f32(&X.im[k]);
-        const float32x4_t H_re = vld1q_f32(&H_j->re[k]);
-        const float32x4_t H_im = vld1q_f32(&H_j->im[k]);
-        const float32x4_t S_re = vld1q_f32(&S->re[k]);
-        const float32x4_t S_im = vld1q_f32(&S->im[k]);
-        const float32x4_t a = vmulq_f32(X_re, H_re);
-        const float32x4_t e = vmlsq_f32(a, X_im, H_im);
-        const float32x4_t c = vmulq_f32(X_re, H_im);
-        const float32x4_t f = vmlaq_f32(c, X_im, H_re);
-        const float32x4_t g = vaddq_f32(S_re, e);
-        const float32x4_t h = vaddq_f32(S_im, f);
-        vst1q_f32(&S->re[k], g);
-        vst1q_f32(&S->im[k], h);
+    for (; p < limit; ++p, ++X_partition) {
+      for (size_t ch = 0; ch < num_render_channels; ++ch) {
+        const FftData& H_p_ch = H[p][ch];
+        const FftData& X = render_buffer_data[X_partition][ch];
+        for (size_t k = 0, n = 0; n < kNumFourBinBands; ++n, k += 4) {
+          const float32x4_t X_re = vld1q_f32(&X.re[k]);
+          const float32x4_t X_im = vld1q_f32(&X.im[k]);
+          const float32x4_t H_re = vld1q_f32(&H_p_ch.re[k]);
+          const float32x4_t H_im = vld1q_f32(&H_p_ch.im[k]);
+          const float32x4_t S_re = vld1q_f32(&S->re[k]);
+          const float32x4_t S_im = vld1q_f32(&S->im[k]);
+          const float32x4_t a = vmulq_f32(X_re, H_re);
+          const float32x4_t e = vmlsq_f32(a, X_im, H_im);
+          const float32x4_t c = vmulq_f32(X_re, H_im);
+          const float32x4_t f = vmlaq_f32(c, X_im, H_re);
+          const float32x4_t g = vaddq_f32(S_re, e);
+          const float32x4_t h = vaddq_f32(S_im, f);
+          vst1q_f32(&S->re[k], g);
+          vst1q_f32(&S->im[k], h);
+        }
       }
     }
     limit = lim2;
-    X_channels = &render_buffer_data[0];
-  } while (j < lim2);
+    X_partition = 0;
+  } while (p < lim2);
 
-  H_j = &H[0];
-  X_channels = &render_buffer_data[render_buffer.Position()];
-  j = 0;
+  X_partition = render_buffer.Position();
+  p = 0;
   limit = lim1;
   do {
-    for (; j < limit; ++j, ++H_j, ++X_channels) {
-      const FftData& X = (*X_channels)[/*channel=*/0];
-      S->re[kFftLengthBy2] += X.re[kFftLengthBy2] * H_j->re[kFftLengthBy2] -
-                              X.im[kFftLengthBy2] * H_j->im[kFftLengthBy2];
-      S->im[kFftLengthBy2] += X.re[kFftLengthBy2] * H_j->im[kFftLengthBy2] +
-                              X.im[kFftLengthBy2] * H_j->re[kFftLengthBy2];
+    for (; p < limit; ++p, ++X_partition) {
+      for (size_t ch = 0; ch < num_render_channels; ++ch) {
+        const FftData& H_p_ch = H[p][ch];
+        const FftData& X = render_buffer_data[X_partition][ch];
+        S->re[kFftLengthBy2] += X.re[kFftLengthBy2] * H_p_ch.re[kFftLengthBy2] -
+                                X.im[kFftLengthBy2] * H_p_ch.im[kFftLengthBy2];
+        S->im[kFftLengthBy2] += X.re[kFftLengthBy2] * H_p_ch.im[kFftLengthBy2] +
+                                X.im[kFftLengthBy2] * H_p_ch.re[kFftLengthBy2];
+      }
     }
     limit = lim2;
-    X_channels = &render_buffer_data[0];
-  } while (j < lim2);
+    X_partition = 0;
+  } while (p < lim2);
 }
 #endif
 
 #if defined(WEBRTC_ARCH_X86_FAMILY)
 // Produces the filter output (SSE2 variant).
-void ApplyFilter_SSE2(const RenderBuffer& render_buffer,
-                      rtc::ArrayView<const FftData> H,
+void ApplyFilter_Sse2(const RenderBuffer& render_buffer,
+                      size_t num_partitions,
+                      const std::vector<std::vector<FftData>>& H,
                       FftData* S) {
+  // const RenderBuffer& render_buffer,
+  //                     rtc::ArrayView<const FftData> H,
+  //                     FftData* S) {
   RTC_DCHECK_GE(H.size(), H.size() - 1);
   S->re.fill(0.f);
   S->im.fill(0.f);
 
   rtc::ArrayView<const std::vector<FftData>> render_buffer_data =
       render_buffer.GetFftBuffer();
-  const int lim1 =
-      std::min(render_buffer_data.size() - render_buffer.Position(), H.size());
-  const int lim2 = H.size();
-  constexpr int kNumFourBinBands = kFftLengthBy2 / 4;
-  const FftData* H_j = &H[0];
-  const std::vector<FftData>* X_channels =
-      &render_buffer_data[render_buffer.Position()];
+  const size_t num_render_channels = render_buffer_data[0].size();
+  const size_t lim1 = std::min(
+      render_buffer_data.size() - render_buffer.Position(), num_partitions);
+  const size_t lim2 = num_partitions;
+  constexpr size_t kNumFourBinBands = kFftLengthBy2 / 4;
 
-  int j = 0;
-  int limit = lim1;
+  size_t X_partition = render_buffer.Position();
+  size_t p = 0;
+  size_t limit = lim1;
   do {
-    for (; j < limit; ++j, ++H_j, ++X_channels) {
-      const FftData& X = (*X_channels)[/*channel=*/0];
-      for (int k = 0, n = 0; n < kNumFourBinBands; ++n, k += 4) {
-        const __m128 X_re = _mm_loadu_ps(&X.re[k]);
-        const __m128 X_im = _mm_loadu_ps(&X.im[k]);
-        const __m128 H_re = _mm_loadu_ps(&H_j->re[k]);
-        const __m128 H_im = _mm_loadu_ps(&H_j->im[k]);
-        const __m128 S_re = _mm_loadu_ps(&S->re[k]);
-        const __m128 S_im = _mm_loadu_ps(&S->im[k]);
-        const __m128 a = _mm_mul_ps(X_re, H_re);
-        const __m128 b = _mm_mul_ps(X_im, H_im);
-        const __m128 c = _mm_mul_ps(X_re, H_im);
-        const __m128 d = _mm_mul_ps(X_im, H_re);
-        const __m128 e = _mm_sub_ps(a, b);
-        const __m128 f = _mm_add_ps(c, d);
-        const __m128 g = _mm_add_ps(S_re, e);
-        const __m128 h = _mm_add_ps(S_im, f);
-        _mm_storeu_ps(&S->re[k], g);
-        _mm_storeu_ps(&S->im[k], h);
+    for (; p < limit; ++p, ++X_partition) {
+      for (size_t ch = 0; ch < num_render_channels; ++ch) {
+        const FftData& H_p_ch = H[p][ch];
+        const FftData& X = render_buffer_data[X_partition][ch];
+        for (size_t k = 0, n = 0; n < kNumFourBinBands; ++n, k += 4) {
+          const __m128 X_re = _mm_loadu_ps(&X.re[k]);
+          const __m128 X_im = _mm_loadu_ps(&X.im[k]);
+          const __m128 H_re = _mm_loadu_ps(&H_p_ch.re[k]);
+          const __m128 H_im = _mm_loadu_ps(&H_p_ch.im[k]);
+          const __m128 S_re = _mm_loadu_ps(&S->re[k]);
+          const __m128 S_im = _mm_loadu_ps(&S->im[k]);
+          const __m128 a = _mm_mul_ps(X_re, H_re);
+          const __m128 b = _mm_mul_ps(X_im, H_im);
+          const __m128 c = _mm_mul_ps(X_re, H_im);
+          const __m128 d = _mm_mul_ps(X_im, H_re);
+          const __m128 e = _mm_sub_ps(a, b);
+          const __m128 f = _mm_add_ps(c, d);
+          const __m128 g = _mm_add_ps(S_re, e);
+          const __m128 h = _mm_add_ps(S_im, f);
+          _mm_storeu_ps(&S->re[k], g);
+          _mm_storeu_ps(&S->im[k], h);
+        }
       }
     }
     limit = lim2;
-    X_channels = &render_buffer_data[0];
-  } while (j < lim2);
+    X_partition = 0;
+  } while (p < lim2);
 
-  H_j = &H[0];
-  X_channels = &render_buffer_data[render_buffer.Position()];
-  j = 0;
+  X_partition = render_buffer.Position();
+  p = 0;
   limit = lim1;
   do {
-    for (; j < limit; ++j, ++H_j, ++X_channels) {
-      const FftData& X = (*X_channels)[/*channel=*/0];
-      S->re[kFftLengthBy2] += X.re[kFftLengthBy2] * H_j->re[kFftLengthBy2] -
-                              X.im[kFftLengthBy2] * H_j->im[kFftLengthBy2];
-      S->im[kFftLengthBy2] += X.re[kFftLengthBy2] * H_j->im[kFftLengthBy2] +
-                              X.im[kFftLengthBy2] * H_j->re[kFftLengthBy2];
+    for (; p < limit; ++p, ++X_partition) {
+      for (size_t ch = 0; ch < num_render_channels; ++ch) {
+        const FftData& H_p_ch = H[p][ch];
+        const FftData& X = render_buffer_data[X_partition][ch];
+        S->re[kFftLengthBy2] += X.re[kFftLengthBy2] * H_p_ch.re[kFftLengthBy2] -
+                                X.im[kFftLengthBy2] * H_p_ch.im[kFftLengthBy2];
+        S->im[kFftLengthBy2] += X.re[kFftLengthBy2] * H_p_ch.im[kFftLengthBy2] +
+                                X.im[kFftLengthBy2] * H_p_ch.re[kFftLengthBy2];
+      }
     }
     limit = lim2;
-    X_channels = &render_buffer_data[0];
-  } while (j < lim2);
+    X_partition = 0;
+  } while (p < lim2);
 }
 #endif
 
 }  // namespace aec3
 
+namespace {
+
+// Ensures that the newly added filter partitions after a size increase are set
+// to zero.
+void ZeroFilter(size_t old_size,
+                size_t new_size,
+                std::vector<std::vector<FftData>>* H) {
+  RTC_DCHECK_GE(H->size(), old_size);
+  RTC_DCHECK_GE(H->size(), new_size);
+
+  for (size_t p = old_size; p < new_size; ++p) {
+    RTC_DCHECK_EQ((*H)[p].size(), (*H)[0].size());
+    for (size_t ch = 0; ch < (*H)[0].size(); ++ch) {
+      (*H)[p][ch].Clear();
+    }
+  }
+}
+
+}  // namespace
+
 AdaptiveFirFilter::AdaptiveFirFilter(size_t max_size_partitions,
                                      size_t initial_size_partitions,
                                      size_t size_change_duration_blocks,
                                      size_t num_render_channels,
-                                     size_t num_capture_channels,
                                      Aec3Optimization optimization,
                                      ApmDataDumper* data_dumper)
     : data_dumper_(data_dumper),
       fft_(),
       optimization_(optimization),
+      num_render_channels_(num_render_channels),
       max_size_partitions_(max_size_partitions),
       size_change_duration_blocks_(
           static_cast<int>(size_change_duration_blocks)),
       current_size_partitions_(initial_size_partitions),
       target_size_partitions_(initial_size_partitions),
       old_target_size_partitions_(initial_size_partitions),
-      H_(max_size_partitions_) {
+      H_(max_size_partitions_, std::vector<FftData>(num_render_channels_)) {
   RTC_DCHECK(data_dumper_);
   RTC_DCHECK_GE(max_size_partitions, initial_size_partitions);
 
   RTC_DCHECK_LT(0, size_change_duration_blocks_);
   one_by_size_change_duration_blocks_ = 1.f / size_change_duration_blocks_;
 
-  for (auto& H_j : H_) {
-    H_j.Clear();
-  }
+  ZeroFilter(0, max_size_partitions_, &H_);
+
   SetSizePartitions(current_size_partitions_, true);
 }
 
 AdaptiveFirFilter::~AdaptiveFirFilter() = default;
 
 void AdaptiveFirFilter::HandleEchoPathChange() {
-  size_t current_size_partitions = H_.size();
-  H_.resize(max_size_partitions_);
-
-  for (size_t k = current_size_partitions; k < max_size_partitions_; ++k) {
-    H_[k].Clear();
-  }
-  H_.resize(current_size_partitions);
+  // TODO(peah): Check the value and purpose of the code below.
+  ZeroFilter(current_size_partitions_, max_size_partitions_, &H_);
 }
 
 void AdaptiveFirFilter::SetSizePartitions(size_t size, bool immediate_effect) {
@@ -424,24 +509,22 @@
 
   target_size_partitions_ = std::min(max_size_partitions_, size);
   if (immediate_effect) {
+    size_t old_size_partitions_ = current_size_partitions_;
     current_size_partitions_ = old_target_size_partitions_ =
         target_size_partitions_;
-    ResetFilterBuffersToCurrentSize();
+    ZeroFilter(old_size_partitions_, current_size_partitions_, &H_);
+
+    partition_to_constrain_ =
+        std::min(partition_to_constrain_, current_size_partitions_ - 1);
     size_change_counter_ = 0;
   } else {
     size_change_counter_ = size_change_duration_blocks_;
   }
 }
 
-void AdaptiveFirFilter::ResetFilterBuffersToCurrentSize() {
-  H_.resize(current_size_partitions_);
-  RTC_DCHECK_LT(0, current_size_partitions_);
-  partition_to_constrain_ =
-      std::min(partition_to_constrain_, current_size_partitions_ - 1);
-}
-
 void AdaptiveFirFilter::UpdateSize() {
   RTC_DCHECK_GE(size_change_duration_blocks_, size_change_counter_);
+  size_t old_size_partitions_ = current_size_partitions_;
   if (size_change_counter_ > 0) {
     --size_change_counter_;
 
@@ -455,11 +538,13 @@
     current_size_partitions_ = average(old_target_size_partitions_,
                                        target_size_partitions_, change_factor);
 
-    ResetFilterBuffersToCurrentSize();
+    partition_to_constrain_ =
+        std::min(partition_to_constrain_, current_size_partitions_ - 1);
   } else {
     current_size_partitions_ = old_target_size_partitions_ =
         target_size_partitions_;
   }
+  ZeroFilter(old_size_partitions_, current_size_partitions_, &H_);
   RTC_DCHECK_LE(0, size_change_counter_);
 }
 
@@ -469,16 +554,16 @@
   switch (optimization_) {
 #if defined(WEBRTC_ARCH_X86_FAMILY)
     case Aec3Optimization::kSse2:
-      aec3::ApplyFilter_SSE2(render_buffer, H_, S);
+      aec3::ApplyFilter_Sse2(render_buffer, current_size_partitions_, H_, S);
       break;
 #endif
 #if defined(WEBRTC_HAS_NEON)
     case Aec3Optimization::kNeon:
-      aec3::ApplyFilter_NEON(render_buffer, H_, S);
+      aec3::ApplyFilter_Neon(render_buffer, current_size_partitions_, H_, S);
       break;
 #endif
     default:
-      aec3::ApplyFilter(render_buffer, H_, S);
+      aec3::ApplyFilter(render_buffer, current_size_partitions_, H_, S);
   }
 }
 
@@ -503,28 +588,23 @@
 
 void AdaptiveFirFilter::ComputeFrequencyResponse(
     std::vector<std::array<float, kFftLengthBy2Plus1>>* H2) const {
-  RTC_DCHECK_EQ(max_size_partitions_, H2->capacity());
+  RTC_DCHECK_GE(max_size_partitions_, H2->capacity());
 
-  if (H2->size() > H_.size()) {
-    for (size_t k = H_.size(); k < H2->size(); ++k) {
-      (*H2)[k].fill(0.f);
-    }
-  }
-  H2->resize(H_.size());
+  H2->resize(current_size_partitions_);
 
   switch (optimization_) {
 #if defined(WEBRTC_ARCH_X86_FAMILY)
     case Aec3Optimization::kSse2:
-      aec3::UpdateFrequencyResponse_SSE2(H_, H2);
+      aec3::ComputeFrequencyResponse_Sse2(current_size_partitions_, H_, H2);
       break;
 #endif
 #if defined(WEBRTC_HAS_NEON)
     case Aec3Optimization::kNeon:
-      aec3::UpdateFrequencyResponse_NEON(H_, H2);
+      aec3::ComputeFrequencyResponse_Neon(current_size_partitions_, H_, H2);
       break;
 #endif
     default:
-      aec3::UpdateFrequencyResponse(H_, H2);
+      aec3::ComputeFrequencyResponse(current_size_partitions_, H_, H2);
   }
 }
 
@@ -537,16 +617,18 @@
   switch (optimization_) {
 #if defined(WEBRTC_ARCH_X86_FAMILY)
     case Aec3Optimization::kSse2:
-      aec3::AdaptPartitions_SSE2(render_buffer, G, H_);
+      aec3::AdaptPartitions_Sse2(render_buffer, G, current_size_partitions_,
+                                 &H_);
       break;
 #endif
 #if defined(WEBRTC_HAS_NEON)
     case Aec3Optimization::kNeon:
-      aec3::AdaptPartitions_NEON(render_buffer, G, H_);
+      aec3::AdaptPartitions_Neon(render_buffer, G, current_size_partitions_,
+                                 &H_);
       break;
 #endif
     default:
-      aec3::AdaptPartitions(render_buffer, G, H_);
+      aec3::AdaptPartitions(render_buffer, G, current_size_partitions_, &H_);
   }
 }
 
@@ -557,62 +639,91 @@
     std::vector<float>* impulse_response) {
   RTC_DCHECK_EQ(GetTimeDomainLength(max_size_partitions_),
                 impulse_response->capacity());
-
   impulse_response->resize(GetTimeDomainLength(current_size_partitions_));
   std::array<float, kFftLength> h;
-  fft_.Ifft(H_[partition_to_constrain_], &h);
+  impulse_response->resize(GetTimeDomainLength(current_size_partitions_));
+  std::fill(
+      impulse_response->begin() + partition_to_constrain_ * kFftLengthBy2,
+      impulse_response->begin() + (partition_to_constrain_ + 1) * kFftLengthBy2,
+      0.f);
 
-  static constexpr float kScale = 1.0f / kFftLengthBy2;
-  std::for_each(h.begin(), h.begin() + kFftLengthBy2,
-                [](float& a) { a *= kScale; });
-  std::fill(h.begin() + kFftLengthBy2, h.end(), 0.f);
+  for (size_t ch = 0; ch < num_render_channels_; ++ch) {
+    fft_.Ifft(H_[partition_to_constrain_][ch], &h);
 
-  std::copy(
-      h.begin(), h.begin() + kFftLengthBy2,
-      impulse_response->begin() + partition_to_constrain_ * kFftLengthBy2);
+    static constexpr float kScale = 1.0f / kFftLengthBy2;
+    std::for_each(h.begin(), h.begin() + kFftLengthBy2,
+                  [](float& a) { a *= kScale; });
+    std::fill(h.begin() + kFftLengthBy2, h.end(), 0.f);
 
-  fft_.Fft(&h, &H_[partition_to_constrain_]);
+    if (ch == 0) {
+      std::copy(
+          h.begin(), h.begin() + kFftLengthBy2,
+          impulse_response->begin() + partition_to_constrain_ * kFftLengthBy2);
+    } else {
+      for (size_t k = 0, j = partition_to_constrain_ * kFftLengthBy2;
+           k < kFftLengthBy2; ++k, ++j) {
+        if (fabsf((*impulse_response)[j]) < fabsf(h[k])) {
+          (*impulse_response)[j] = h[k];
+        }
+      }
+    }
 
-  partition_to_constrain_ = partition_to_constrain_ < (H_.size() - 1)
-                                ? partition_to_constrain_ + 1
-                                : 0;
+    fft_.Fft(&h, &H_[partition_to_constrain_][ch]);
+  }
+
+  partition_to_constrain_ =
+      partition_to_constrain_ < (current_size_partitions_ - 1)
+          ? partition_to_constrain_ + 1
+          : 0;
 }
 
 // Constrains the a partiton of the frequency domain filter to be limited in
 // time via setting the relevant time-domain coefficients to zero.
 void AdaptiveFirFilter::Constrain() {
   std::array<float, kFftLength> h;
-  fft_.Ifft(H_[partition_to_constrain_], &h);
+  for (size_t ch = 0; ch < num_render_channels_; ++ch) {
+    fft_.Ifft(H_[partition_to_constrain_][ch], &h);
 
-  static constexpr float kScale = 1.0f / kFftLengthBy2;
-  std::for_each(h.begin(), h.begin() + kFftLengthBy2,
-                [](float& a) { a *= kScale; });
-  std::fill(h.begin() + kFftLengthBy2, h.end(), 0.f);
+    static constexpr float kScale = 1.0f / kFftLengthBy2;
+    std::for_each(h.begin(), h.begin() + kFftLengthBy2,
+                  [](float& a) { a *= kScale; });
+    std::fill(h.begin() + kFftLengthBy2, h.end(), 0.f);
 
-  fft_.Fft(&h, &H_[partition_to_constrain_]);
+    fft_.Fft(&h, &H_[partition_to_constrain_][ch]);
+  }
 
-  partition_to_constrain_ = partition_to_constrain_ < (H_.size() - 1)
-                                ? partition_to_constrain_ + 1
-                                : 0;
+  partition_to_constrain_ =
+      partition_to_constrain_ < (current_size_partitions_ - 1)
+          ? partition_to_constrain_ + 1
+          : 0;
 }
 
 void AdaptiveFirFilter::ScaleFilter(float factor) {
-  for (auto& H : H_) {
-    for (auto& re : H.re) {
-      re *= factor;
-    }
-    for (auto& im : H.im) {
-      im *= factor;
+  for (auto& H_p : H_) {
+    for (auto& H_p_ch : H_p) {
+      for (auto& re : H_p_ch.re) {
+        re *= factor;
+      }
+      for (auto& im : H_p_ch.im) {
+        im *= factor;
+      }
     }
   }
 }
 
 // Set the filter coefficients.
-void AdaptiveFirFilter::SetFilter(const std::vector<FftData>& H) {
-  const size_t num_partitions = std::min(H_.size(), H.size());
-  for (size_t k = 0; k < num_partitions; ++k) {
-    std::copy(H[k].re.begin(), H[k].re.end(), H_[k].re.begin());
-    std::copy(H[k].im.begin(), H[k].im.end(), H_[k].im.begin());
+void AdaptiveFirFilter::SetFilter(size_t num_partitions,
+                                  const std::vector<std::vector<FftData>>& H) {
+  const size_t min_num_partitions =
+      std::min(current_size_partitions_, num_partitions);
+  for (size_t p = 0; p < min_num_partitions; ++p) {
+    RTC_DCHECK_EQ(H_[p].size(), H[p].size());
+    RTC_DCHECK_EQ(num_render_channels_, H_[p].size());
+
+    for (size_t ch = 0; ch < num_render_channels_; ++ch) {
+      std::copy(H[p][ch].re.begin(), H[p][ch].re.end(), H_[p][ch].re.begin());
+      std::copy(H[p][ch].im.begin(), H[p][ch].im.end(), H_[p][ch].im.begin());
+    }
   }
 }
 
diff --git a/modules/audio_processing/aec3/adaptive_fir_filter.h b/modules/audio_processing/aec3/adaptive_fir_filter.h
index aec83aa..2f64853 100644
--- a/modules/audio_processing/aec3/adaptive_fir_filter.h
+++ b/modules/audio_processing/aec3/adaptive_fir_filter.h
@@ -27,47 +27,56 @@
 namespace webrtc {
 namespace aec3 {
 // Computes and stores the frequency response of the filter.
-void UpdateFrequencyResponse(
-    rtc::ArrayView<const FftData> H,
+void ComputeFrequencyResponse(
+    size_t num_partitions,
+    const std::vector<std::vector<FftData>>& H,
     std::vector<std::array<float, kFftLengthBy2Plus1>>* H2);
 #if defined(WEBRTC_HAS_NEON)
-void UpdateFrequencyResponse_NEON(
-    rtc::ArrayView<const FftData> H,
+void ComputeFrequencyResponse_Neon(
+    size_t num_partitions,
+    const std::vector<std::vector<FftData>>& H,
     std::vector<std::array<float, kFftLengthBy2Plus1>>* H2);
 #endif
 #if defined(WEBRTC_ARCH_X86_FAMILY)
-void UpdateFrequencyResponse_SSE2(
-    rtc::ArrayView<const FftData> H,
+void ComputeFrequencyResponse_Sse2(
+    size_t num_partitions,
+    const std::vector<std::vector<FftData>>& H,
     std::vector<std::array<float, kFftLengthBy2Plus1>>* H2);
 #endif
 
 // Adapts the filter partitions.
 void AdaptPartitions(const RenderBuffer& render_buffer,
                      const FftData& G,
-                     rtc::ArrayView<FftData> H);
+                     size_t num_partitions,
+                     std::vector<std::vector<FftData>>* H);
 #if defined(WEBRTC_HAS_NEON)
-void AdaptPartitions_NEON(const RenderBuffer& render_buffer,
+void AdaptPartitions_Neon(const RenderBuffer& render_buffer,
                           const FftData& G,
-                          rtc::ArrayView<FftData> H);
+                          size_t num_partitions,
+                          std::vector<std::vector<FftData>>* H);
 #endif
 #if defined(WEBRTC_ARCH_X86_FAMILY)
-void AdaptPartitions_SSE2(const RenderBuffer& render_buffer,
+void AdaptPartitions_Sse2(const RenderBuffer& render_buffer,
                           const FftData& G,
-                          rtc::ArrayView<FftData> H);
+                          size_t num_partitions,
+                          std::vector<std::vector<FftData>>* H);
 #endif
 
 // Produces the filter output.
 void ApplyFilter(const RenderBuffer& render_buffer,
-                 rtc::ArrayView<const FftData> H,
+                 size_t num_partitions,
+                 const std::vector<std::vector<FftData>>& H,
                  FftData* S);
 #if defined(WEBRTC_HAS_NEON)
-void ApplyFilter_NEON(const RenderBuffer& render_buffer,
-                      rtc::ArrayView<const FftData> H,
+void ApplyFilter_Neon(const RenderBuffer& render_buffer,
+                      size_t num_partitions,
+                      const std::vector<std::vector<FftData>>& H,
                       FftData* S);
 #endif
 #if defined(WEBRTC_ARCH_X86_FAMILY)
-void ApplyFilter_SSE2(const RenderBuffer& render_buffer,
-                      rtc::ArrayView<const FftData> H,
+void ApplyFilter_Sse2(const RenderBuffer& render_buffer,
+                      size_t num_partitions,
+                      const std::vector<std::vector<FftData>>& H,
                       FftData* S);
 #endif
 
@@ -80,7 +89,6 @@
                     size_t initial_size_partitions,
                     size_t size_change_duration_blocks,
                     size_t num_render_channels,
-                    size_t num_capture_channels,
                     Aec3Optimization optimization,
                     ApmDataDumper* data_dumper);
 
@@ -106,7 +114,7 @@
   void HandleEchoPathChange();
 
   // Returns the filter size.
-  size_t SizePartitions() const { return H_.size(); }
+  size_t SizePartitions() const { return current_size_partitions_; }
 
   // Sets the filter size.
   void SetSizePartitions(size_t size, bool immediate_effect);
@@ -119,23 +127,21 @@
   size_t max_filter_size_partitions() const { return max_size_partitions_; }
 
   void DumpFilter(const char* name_frequency_domain) {
-    size_t current_size = H_.size();
-    H_.resize(max_size_partitions_);
-    for (auto& H : H_) {
-      data_dumper_->DumpRaw(name_frequency_domain, H.re);
-      data_dumper_->DumpRaw(name_frequency_domain, H.im);
+    for (size_t p = 0; p < max_size_partitions_; ++p) {
+      data_dumper_->DumpRaw(name_frequency_domain, H_[p][0].re);
+      data_dumper_->DumpRaw(name_frequency_domain, H_[p][0].im);
     }
-    H_.resize(current_size);
   }
 
   // Scale the filter impulse response and spectrum by a factor.
   void ScaleFilter(float factor);
 
   // Set the filter coefficients.
-  void SetFilter(const std::vector<FftData>& H);
+  void SetFilter(size_t num_partitions,
+                 const std::vector<std::vector<FftData>>& H);
 
   // Gets the filter coefficients.
-  const std::vector<FftData>& GetFilter() const { return H_; }
+  const std::vector<std::vector<FftData>>& GetFilter() const { return H_; }
 
  private:
   // Adapts the filter and updates the filter size.
@@ -147,15 +153,13 @@
   // values in the supplied impulse response.
   void ConstrainAndUpdateImpulseResponse(std::vector<float>* impulse_response);
 
-  // Resets the filter buffers to use the current size.
-  void ResetFilterBuffersToCurrentSize();
-
   // Gradually Updates the current filter size towards the target size.
   void UpdateSize();
 
   ApmDataDumper* const data_dumper_;
   const Aec3Fft fft_;
   const Aec3Optimization optimization_;
+  const size_t num_render_channels_;
   const size_t max_size_partitions_;
   const int size_change_duration_blocks_;
   float one_by_size_change_duration_blocks_;
@@ -163,7 +167,7 @@
   size_t target_size_partitions_;
   size_t old_target_size_partitions_;
   int size_change_counter_ = 0;
-  std::vector<FftData> H_;
+  std::vector<std::vector<FftData>> H_;
   size_t partition_to_constrain_ = 0;
 };
 
diff --git a/modules/audio_processing/aec3/adaptive_fir_filter_unittest.cc b/modules/audio_processing/aec3/adaptive_fir_filter_unittest.cc
index 36e31eb..6f1635f 100644
--- a/modules/audio_processing/aec3/adaptive_fir_filter_unittest.cc
+++ b/modules/audio_processing/aec3/adaptive_fir_filter_unittest.cc
@@ -42,9 +42,10 @@
 namespace aec3 {
 namespace {
 
-std::string ProduceDebugText(size_t delay) {
+std::string ProduceDebugText(size_t num_render_channels, size_t delay) {
   rtc::StringBuilder ss;
-  ss << ", Delay: " << delay;
+  ss << "delay: " << delay << ", ";
+  ss << "num_render_channels:" << num_render_channels;
   return ss.Release();
 }
 
@@ -54,163 +55,184 @@
 // Verifies that the optimized methods for filter adaptation are similar to
 // their reference counterparts.
 TEST(AdaptiveFirFilter, FilterAdaptationNeonOptimizations) {
-  constexpr size_t kNumRenderChannels = 1;
-  constexpr int kSampleRateHz = 48000;
-  constexpr size_t kNumBands = NumBandsForRate(kSampleRateHz);
+  for (size_t num_partitions : {2, 5, 12, 30, 50}) {
+    for (size_t num_render_channels : {1, 2, 4, 8}) {
+      constexpr int kSampleRateHz = 48000;
+      constexpr size_t kNumBands = NumBandsForRate(kSampleRateHz);
 
-  std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
-      RenderDelayBuffer::Create(EchoCanceller3Config(), kSampleRateHz,
-                                kNumRenderChannels));
-  Random random_generator(42U);
-  std::vector<std::vector<std::vector<float>>> x(
-      kNumBands, std::vector<std::vector<float>>(
-                     kNumRenderChannels, std::vector<float>(kBlockSize, 0.f)));
-  FftData S_C;
-  FftData S_NEON;
-  FftData G;
-  Aec3Fft fft;
-  std::vector<FftData> H_C(10);
-  std::vector<FftData> H_NEON(10);
-  for (auto& H_j : H_C) {
-    H_j.Clear();
-  }
-  for (auto& H_j : H_NEON) {
-    H_j.Clear();
-  }
+      std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
+          RenderDelayBuffer::Create(EchoCanceller3Config(), kSampleRateHz,
+                                    num_render_channels));
+      Random random_generator(42U);
+      std::vector<std::vector<std::vector<float>>> x(
+          kNumBands,
+          std::vector<std::vector<float>>(num_render_channels,
+                                          std::vector<float>(kBlockSize, 0.f)));
+      FftData S_C;
+      FftData S_Neon;
+      FftData G;
+      Aec3Fft fft;
+      std::vector<std::vector<FftData>> H_C(
+          num_partitions, std::vector<FftData>(num_render_channels));
+      std::vector<std::vector<FftData>> H_Neon(
+          num_partitions, std::vector<FftData>(num_render_channels));
+      for (size_t p = 0; p < num_partitions; ++p) {
+        for (size_t ch = 0; ch < num_render_channels; ++ch) {
+          H_C[p][ch].Clear();
+          H_Neon[p][ch].Clear();
+        }
+      }
 
-  for (size_t k = 0; k < 30; ++k) {
-    for (size_t band = 0; band < x.size(); ++band) {
-      for (size_t channel = 0; channel < x[band].size(); ++channel) {
-        RandomizeSampleVector(&random_generator, x[band][channel]);
+      for (size_t k = 0; k < 30; ++k) {
+        for (size_t band = 0; band < x.size(); ++band) {
+          for (size_t ch = 0; ch < x[band].size(); ++ch) {
+            RandomizeSampleVector(&random_generator, x[band][ch]);
+          }
+        }
+        render_delay_buffer->Insert(x);
+        if (k == 0) {
+          render_delay_buffer->Reset();
+        }
+        render_delay_buffer->PrepareCaptureProcessing();
+      }
+      auto* const render_buffer = render_delay_buffer->GetRenderBuffer();
+
+      for (size_t j = 0; j < G.re.size(); ++j) {
+        G.re[j] = j / 10001.f;
+      }
+      for (size_t j = 1; j < G.im.size() - 1; ++j) {
+        G.im[j] = j / 20001.f;
+      }
+      G.im[0] = 0.f;
+      G.im[G.im.size() - 1] = 0.f;
+
+      AdaptPartitions_Neon(*render_buffer, G, num_partitions, &H_Neon);
+      AdaptPartitions(*render_buffer, G, num_partitions, &H_C);
+      AdaptPartitions_Neon(*render_buffer, G, num_partitions, &H_Neon);
+      AdaptPartitions(*render_buffer, G, num_partitions, &H_C);
+
+      for (size_t p = 0; p < num_partitions; ++p) {
+        for (size_t ch = 0; ch < num_render_channels; ++ch) {
+          for (size_t j = 0; j < H_C[p][ch].re.size(); ++j) {
+            EXPECT_FLOAT_EQ(H_C[p][ch].re[j], H_Neon[p][ch].re[j]);
+            EXPECT_FLOAT_EQ(H_C[p][ch].im[j], H_Neon[p][ch].im[j]);
+          }
+        }
+      }
+
+      ApplyFilter_Neon(*render_buffer, num_partitions, H_Neon, &S_Neon);
+      ApplyFilter(*render_buffer, num_partitions, H_C, &S_C);
+      for (size_t j = 0; j < S_C.re.size(); ++j) {
+        EXPECT_NEAR(S_C.re[j], S_Neon.re[j], fabs(S_C.re[j] * 0.00001f));
+        EXPECT_NEAR(S_C.im[j], S_Neon.im[j], fabs(S_C.re[j] * 0.00001f));
       }
     }
-    render_delay_buffer->Insert(x);
-    if (k == 0) {
-      render_delay_buffer->Reset();
-    }
-    render_delay_buffer->PrepareCaptureProcessing();
-  }
-  auto* const render_buffer = render_delay_buffer->GetRenderBuffer();
-
-  for (size_t j = 0; j < G.re.size(); ++j) {
-    G.re[j] = j / 10001.f;
-  }
-  for (size_t j = 1; j < G.im.size() - 1; ++j) {
-    G.im[j] = j / 20001.f;
-  }
-  G.im[0] = 0.f;
-  G.im[G.im.size() - 1] = 0.f;
-
-  AdaptPartitions_NEON(*render_buffer, G, H_NEON);
-  AdaptPartitions(*render_buffer, G, H_C);
-  AdaptPartitions_NEON(*render_buffer, G, H_NEON);
-  AdaptPartitions(*render_buffer, G, H_C);
-
-  for (size_t l = 0; l < H_C.size(); ++l) {
-    for (size_t j = 0; j < H_C[l].im.size(); ++j) {
-      EXPECT_NEAR(H_C[l].re[j], H_NEON[l].re[j], fabs(H_C[l].re[j] * 0.00001f));
-      EXPECT_NEAR(H_C[l].im[j], H_NEON[l].im[j], fabs(H_C[l].im[j] * 0.00001f));
-    }
-  }
-
-  ApplyFilter_NEON(*render_buffer, H_NEON, &S_NEON);
-  ApplyFilter(*render_buffer, H_C, &S_C);
-  for (size_t j = 0; j < S_C.re.size(); ++j) {
-    EXPECT_NEAR(S_C.re[j], S_NEON.re[j], fabs(S_C.re[j] * 0.00001f));
-    EXPECT_NEAR(S_C.im[j], S_NEON.im[j], fabs(S_C.re[j] * 0.00001f));
   }
 }
 
 // Verifies that the optimized method for frequency response computation is
 // bitexact to the reference counterpart.
-TEST(AdaptiveFirFilter, UpdateFrequencyResponseNeonOptimization) {
-  const size_t kNumPartitions = 12;
-  std::vector<FftData> H(kNumPartitions);
-  std::vector<std::array<float, kFftLengthBy2Plus1>> H2(kNumPartitions);
-  std::vector<std::array<float, kFftLengthBy2Plus1>> H2_NEON(kNumPartitions);
+TEST(AdaptiveFirFilter, ComputeFrequencyResponseNeonOptimization) {
+  for (size_t num_partitions : {2, 5, 12, 30, 50}) {
+    for (size_t num_render_channels : {1, 2, 4, 8}) {
+      std::vector<std::vector<FftData>> H(
+          num_partitions, std::vector<FftData>(num_render_channels));
+      std::vector<std::array<float, kFftLengthBy2Plus1>> H2(num_partitions);
+      std::vector<std::array<float, kFftLengthBy2Plus1>> H2_Neon(
+          num_partitions);
 
-  for (size_t j = 0; j < H.size(); ++j) {
-    for (size_t k = 0; k < H[j].re.size(); ++k) {
-      H[j].re[k] = k + j / 3.f;
-      H[j].im[k] = j + k / 7.f;
-    }
-  }
+      for (size_t p = 0; p < num_partitions; ++p) {
+        for (size_t ch = 0; ch < num_render_channels; ++ch) {
+          for (size_t k = 0; k < H[p][ch].re.size(); ++k) {
+            H[p][ch].re[k] = k + p / 3.f + ch;
+            H[p][ch].im[k] = p + k / 7.f - ch;
+          }
+        }
+      }
 
-  UpdateFrequencyResponse(H, &H2);
-  UpdateFrequencyResponse_NEON(H, &H2_NEON);
+      ComputeFrequencyResponse(num_partitions, H, &H2);
+      ComputeFrequencyResponse_Neon(num_partitions, H, &H2_Neon);
 
-  for (size_t j = 0; j < H2.size(); ++j) {
-    for (size_t k = 0; k < H[j].re.size(); ++k) {
-      EXPECT_FLOAT_EQ(H2[j][k], H2_NEON[j][k]);
+      for (size_t p = 0; p < num_partitions; ++p) {
+        for (size_t k = 0; k < H2[p].size(); ++k) {
+          EXPECT_FLOAT_EQ(H2[p][k], H2_Neon[p][k]);
+        }
+      }
     }
   }
 }
-
 #endif
 
 #if defined(WEBRTC_ARCH_X86_FAMILY)
 // Verifies that the optimized methods for filter adaptation are bitexact to
 // their reference counterparts.
 TEST(AdaptiveFirFilter, FilterAdaptationSse2Optimizations) {
-  constexpr size_t kNumRenderChannels = 1;
   constexpr int kSampleRateHz = 48000;
   constexpr size_t kNumBands = NumBandsForRate(kSampleRateHz);
 
   bool use_sse2 = (WebRtc_GetCPUInfo(kSSE2) != 0);
   if (use_sse2) {
-    std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
-        RenderDelayBuffer::Create(EchoCanceller3Config(), kSampleRateHz,
-                                  kNumRenderChannels));
-    Random random_generator(42U);
-    std::vector<std::vector<std::vector<float>>> x(
-        kNumBands,
-        std::vector<std::vector<float>>(kNumRenderChannels,
-                                        std::vector<float>(kBlockSize, 0.f)));
-    FftData S_C;
-    FftData S_SSE2;
-    FftData G;
-    Aec3Fft fft;
-    std::vector<FftData> H_C(10);
-    std::vector<FftData> H_SSE2(10);
-    for (auto& H_j : H_C) {
-      H_j.Clear();
-    }
-    for (auto& H_j : H_SSE2) {
-      H_j.Clear();
-    }
-
-    for (size_t k = 0; k < 500; ++k) {
-      for (size_t band = 0; band < x.size(); ++band) {
-        for (size_t channel = 0; channel < x[band].size(); ++channel) {
-          RandomizeSampleVector(&random_generator, x[band][channel]);
+    for (size_t num_partitions : {2, 5, 12, 30, 50}) {
+      for (size_t num_render_channels : {1, 2, 4, 8}) {
+        std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
+            RenderDelayBuffer::Create(EchoCanceller3Config(), kSampleRateHz,
+                                      num_render_channels));
+        Random random_generator(42U);
+        std::vector<std::vector<std::vector<float>>> x(
+            kNumBands,
+            std::vector<std::vector<float>>(
+                num_render_channels, std::vector<float>(kBlockSize, 0.f)));
+        FftData S_C;
+        FftData S_Sse2;
+        FftData G;
+        Aec3Fft fft;
+        std::vector<std::vector<FftData>> H_C(
+            num_partitions, std::vector<FftData>(num_render_channels));
+        std::vector<std::vector<FftData>> H_Sse2(
+            num_partitions, std::vector<FftData>(num_render_channels));
+        for (size_t p = 0; p < num_partitions; ++p) {
+          for (size_t ch = 0; ch < num_render_channels; ++ch) {
+            H_C[p][ch].Clear();
+            H_Sse2[p][ch].Clear();
+          }
         }
-      }
-      render_delay_buffer->Insert(x);
-      if (k == 0) {
-        render_delay_buffer->Reset();
-      }
-      render_delay_buffer->PrepareCaptureProcessing();
-      auto* const render_buffer = render_delay_buffer->GetRenderBuffer();
 
-      ApplyFilter_SSE2(*render_buffer, H_SSE2, &S_SSE2);
-      ApplyFilter(*render_buffer, H_C, &S_C);
-      for (size_t j = 0; j < S_C.re.size(); ++j) {
-        EXPECT_FLOAT_EQ(S_C.re[j], S_SSE2.re[j]);
-        EXPECT_FLOAT_EQ(S_C.im[j], S_SSE2.im[j]);
-      }
+        for (size_t k = 0; k < 500; ++k) {
+          for (size_t band = 0; band < x.size(); ++band) {
+            for (size_t ch = 0; ch < x[band].size(); ++ch) {
+              RandomizeSampleVector(&random_generator, x[band][ch]);
+            }
+          }
+          render_delay_buffer->Insert(x);
+          if (k == 0) {
+            render_delay_buffer->Reset();
+          }
+          render_delay_buffer->PrepareCaptureProcessing();
+          auto* const render_buffer = render_delay_buffer->GetRenderBuffer();
 
-      std::for_each(G.re.begin(), G.re.end(),
-                    [&](float& a) { a = random_generator.Rand<float>(); });
-      std::for_each(G.im.begin(), G.im.end(),
-                    [&](float& a) { a = random_generator.Rand<float>(); });
+          ApplyFilter_Sse2(*render_buffer, num_partitions, H_Sse2, &S_Sse2);
+          ApplyFilter(*render_buffer, num_partitions, H_C, &S_C);
+          for (size_t j = 0; j < S_C.re.size(); ++j) {
+            EXPECT_FLOAT_EQ(S_C.re[j], S_Sse2.re[j]);
+            EXPECT_FLOAT_EQ(S_C.im[j], S_Sse2.im[j]);
+          }
 
-      AdaptPartitions_SSE2(*render_buffer, G, H_SSE2);
-      AdaptPartitions(*render_buffer, G, H_C);
+          std::for_each(G.re.begin(), G.re.end(),
+                        [&](float& a) { a = random_generator.Rand<float>(); });
+          std::for_each(G.im.begin(), G.im.end(),
+                        [&](float& a) { a = random_generator.Rand<float>(); });
 
-      for (size_t k = 0; k < H_C.size(); ++k) {
-        for (size_t j = 0; j < H_C[k].re.size(); ++j) {
-          EXPECT_FLOAT_EQ(H_C[k].re[j], H_SSE2[k].re[j]);
-          EXPECT_FLOAT_EQ(H_C[k].im[j], H_SSE2[k].im[j]);
+          AdaptPartitions_Sse2(*render_buffer, G, num_partitions, &H_Sse2);
+          AdaptPartitions(*render_buffer, G, num_partitions, &H_C);
+
+          for (size_t p = 0; p < num_partitions; ++p) {
+            for (size_t ch = 0; ch < num_render_channels; ++ch) {
+              for (size_t j = 0; j < H_C[p][ch].re.size(); ++j) {
+                EXPECT_FLOAT_EQ(H_C[p][ch].re[j], H_Sse2[p][ch].re[j]);
+                EXPECT_FLOAT_EQ(H_C[p][ch].im[j], H_Sse2[p][ch].im[j]);
+              }
+            }
+          }
         }
       }
     }
@@ -219,27 +241,34 @@
 
 // Verifies that the optimized method for frequency response computation is
 // bitexact to the reference counterpart.
-TEST(AdaptiveFirFilter, UpdateFrequencyResponseSse2Optimization) {
+TEST(AdaptiveFirFilter, ComputeFrequencyResponseSse2Optimization) {
   bool use_sse2 = (WebRtc_GetCPUInfo(kSSE2) != 0);
   if (use_sse2) {
-    const size_t kNumPartitions = 12;
-    std::vector<FftData> H(kNumPartitions);
-    std::vector<std::array<float, kFftLengthBy2Plus1>> H2(kNumPartitions);
-    std::vector<std::array<float, kFftLengthBy2Plus1>> H2_SSE2(kNumPartitions);
+    for (size_t num_partitions : {2, 5, 12, 30, 50}) {
+      for (size_t num_render_channels : {1, 2, 4, 8}) {
+        std::vector<std::vector<FftData>> H(
+            num_partitions, std::vector<FftData>(num_render_channels));
+        std::vector<std::array<float, kFftLengthBy2Plus1>> H2(num_partitions);
+        std::vector<std::array<float, kFftLengthBy2Plus1>> H2_Sse2(
+            num_partitions);
 
-    for (size_t j = 0; j < H.size(); ++j) {
-      for (size_t k = 0; k < H[j].re.size(); ++k) {
-        H[j].re[k] = k + j / 3.f;
-        H[j].im[k] = j + k / 7.f;
-      }
-    }
+        for (size_t p = 0; p < num_partitions; ++p) {
+          for (size_t ch = 0; ch < num_render_channels; ++ch) {
+            for (size_t k = 0; k < H[p][ch].re.size(); ++k) {
+              H[p][ch].re[k] = k + p / 3.f + ch;
+              H[p][ch].im[k] = p + k / 7.f - ch;
+            }
+          }
+        }
 
-    UpdateFrequencyResponse(H, &H2);
-    UpdateFrequencyResponse_SSE2(H, &H2_SSE2);
+        ComputeFrequencyResponse(num_partitions, H, &H2);
+        ComputeFrequencyResponse_Sse2(num_partitions, H, &H2_Sse2);
 
-    for (size_t j = 0; j < H2.size(); ++j) {
-      for (size_t k = 0; k < H[j].re.size(); ++k) {
-        EXPECT_FLOAT_EQ(H2[j][k], H2_SSE2[j][k]);
+        for (size_t p = 0; p < num_partitions; ++p) {
+          for (size_t k = 0; k < H2[p].size(); ++k) {
+            EXPECT_FLOAT_EQ(H2[p][k], H2_Sse2[p][k]);
+          }
+        }
       }
     }
   }
@@ -250,14 +279,14 @@
 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
 // Verifies that the check for non-null data dumper works.
 TEST(AdaptiveFirFilter, NullDataDumper) {
-  EXPECT_DEATH(
-      AdaptiveFirFilter(9, 9, 250, 1, 1, DetectOptimization(), nullptr), "");
+  EXPECT_DEATH(AdaptiveFirFilter(9, 9, 250, 1, DetectOptimization(), nullptr),
+               "");
 }
 
 // Verifies that the check for non-null filter output works.
 TEST(AdaptiveFirFilter, NullFilterOutput) {
   ApmDataDumper data_dumper(42);
-  AdaptiveFirFilter filter(9, 9, 250, 1, 1, DetectOptimization(), &data_dumper);
+  AdaptiveFirFilter filter(9, 9, 250, 1, DetectOptimization(), &data_dumper);
   std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
       RenderDelayBuffer::Create(EchoCanceller3Config(), 48000, 1));
   EXPECT_DEATH(filter.Filter(*render_delay_buffer->GetRenderBuffer(), nullptr),
@@ -271,7 +300,7 @@
 TEST(AdaptiveFirFilter, FilterStatisticsAccess) {
   ApmDataDumper data_dumper(42);
   Aec3Optimization optimization = DetectOptimization();
-  AdaptiveFirFilter filter(9, 9, 250, 1, 1, optimization, &data_dumper);
+  AdaptiveFirFilter filter(9, 9, 250, 1, optimization, &data_dumper);
   std::vector<std::array<float, kFftLengthBy2Plus1>> H2(
       filter.max_filter_size_partitions(),
       std::array<float, kFftLengthBy2Plus1>());
@@ -288,7 +317,7 @@
 TEST(AdaptiveFirFilter, FilterSize) {
   ApmDataDumper data_dumper(42);
   for (size_t filter_size = 1; filter_size < 5; ++filter_size) {
-    AdaptiveFirFilter filter(filter_size, filter_size, 250, 1, 1,
+    AdaptiveFirFilter filter(filter_size, filter_size, 250, 1,
                              DetectOptimization(), &data_dumper);
     EXPECT_EQ(filter_size, filter.SizePartitions());
   }
@@ -297,115 +326,146 @@
 // Verifies that the filter is being able to properly filter a signal and to
 // adapt its coefficients.
 TEST(AdaptiveFirFilter, FilterAndAdapt) {
-  constexpr size_t kNumRenderChannels = 1;
-  constexpr size_t kNumCaptureChannels = 1;
   constexpr int kSampleRateHz = 48000;
   constexpr size_t kNumBands = NumBandsForRate(kSampleRateHz);
+  constexpr size_t kNumBlocksToProcessPerRenderChannel = 1000;
+  constexpr size_t kNumCaptureChannels = 1;
 
-  constexpr size_t kNumBlocksToProcess = 1000;
-  ApmDataDumper data_dumper(42);
-  EchoCanceller3Config config;
-  AdaptiveFirFilter filter(config.filter.main.length_blocks,
-                           config.filter.main.length_blocks,
-                           config.filter.config_change_duration_blocks, 1, 1,
-                           DetectOptimization(), &data_dumper);
-  std::vector<std::array<float, kFftLengthBy2Plus1>> H2(
-      filter.max_filter_size_partitions(),
-      std::array<float, kFftLengthBy2Plus1>());
-  std::vector<float> h(GetTimeDomainLength(filter.max_filter_size_partitions()),
-                       0.f);
-  Aec3Fft fft;
-  config.delay.default_delay = 1;
-  std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
-      RenderDelayBuffer::Create(config, kSampleRateHz, kNumRenderChannels));
-  ShadowFilterUpdateGain gain(config.filter.shadow,
-                              config.filter.config_change_duration_blocks);
-  Random random_generator(42U);
-  std::vector<std::vector<std::vector<float>>> x(
-      kNumBands, std::vector<std::vector<float>>(
-                     kNumRenderChannels, std::vector<float>(kBlockSize, 0.f)));
-  std::vector<float> n(kBlockSize, 0.f);
-  std::vector<float> y(kBlockSize, 0.f);
-  AecState aec_state(EchoCanceller3Config{}, kNumCaptureChannels);
-  RenderSignalAnalyzer render_signal_analyzer(config);
-  absl::optional<DelayEstimate> delay_estimate;
-  std::vector<float> e(kBlockSize, 0.f);
-  std::array<float, kFftLength> s_scratch;
-  std::vector<SubtractorOutput> output(kNumCaptureChannels);
-  FftData S;
-  FftData G;
-  FftData E;
-  std::array<float, kFftLengthBy2Plus1> Y2;
-  std::array<float, kFftLengthBy2Plus1> E2_main;
-  std::array<float, kFftLengthBy2Plus1> E2_shadow;
-  // [B,A] = butter(2,100/8000,'high')
-  constexpr CascadedBiQuadFilter::BiQuadCoefficients
-      kHighPassFilterCoefficients = {{0.97261f, -1.94523f, 0.97261f},
-                                     {-1.94448f, 0.94598f}};
-  Y2.fill(0.f);
-  E2_main.fill(0.f);
-  E2_shadow.fill(0.f);
-  for (auto& subtractor_output : output) {
-    subtractor_output.Reset();
-  }
+  for (size_t num_render_channels : {1, 2, 3, 6, 8}) {
+    ApmDataDumper data_dumper(42);
+    EchoCanceller3Config config;
 
-  constexpr float kScale = 1.0f / kFftLengthBy2;
-
-  for (size_t delay_samples : {0, 64, 150, 200, 301}) {
-    DelayBuffer<float> delay_buffer(delay_samples);
-    CascadedBiQuadFilter x_hp_filter(kHighPassFilterCoefficients, 1);
-    CascadedBiQuadFilter y_hp_filter(kHighPassFilterCoefficients, 1);
-
-    SCOPED_TRACE(ProduceDebugText(delay_samples));
-    for (size_t j = 0; j < kNumBlocksToProcess; ++j) {
-      RandomizeSampleVector(&random_generator, x[0][0]);
-      delay_buffer.Delay(x[0][0], y);
-
-      RandomizeSampleVector(&random_generator, n);
-      static constexpr float kNoiseScaling = 1.f / 100.f;
-      std::transform(y.begin(), y.end(), n.begin(), y.begin(),
-                     [](float a, float b) { return a + b * kNoiseScaling; });
-
-      x_hp_filter.Process(x[0][0]);
-      y_hp_filter.Process(y);
-
-      render_delay_buffer->Insert(x);
-      if (j == 0) {
-        render_delay_buffer->Reset();
-      }
-      render_delay_buffer->PrepareCaptureProcessing();
-      auto* const render_buffer = render_delay_buffer->GetRenderBuffer();
-
-      render_signal_analyzer.Update(*render_buffer,
-                                    aec_state.FilterDelayBlocks());
-
-      filter.Filter(*render_buffer, &S);
-      fft.Ifft(S, &s_scratch);
-      std::transform(y.begin(), y.end(), s_scratch.begin() + kFftLengthBy2,
-                     e.begin(),
-                     [&](float a, float b) { return a - b * kScale; });
-      std::for_each(e.begin(), e.end(),
-                    [](float& a) { a = rtc::SafeClamp(a, -32768.f, 32767.f); });
-      fft.ZeroPaddedFft(e, Aec3Fft::Window::kRectangular, &E);
-      for (size_t k = 0; k < kBlockSize; ++k) {
-        output[0].s_main[k] = kScale * s_scratch[k + kFftLengthBy2];
-      }
-
-      std::array<float, kFftLengthBy2Plus1> render_power;
-      render_buffer->SpectralSum(filter.SizePartitions(), &render_power);
-      gain.Compute(render_power, render_signal_analyzer, E,
-                   filter.SizePartitions(), false, &G);
-      filter.Adapt(*render_buffer, G, &h);
-      aec_state.HandleEchoPathChange(EchoPathVariability(
-          false, EchoPathVariability::DelayAdjustment::kNone, false));
-
-      filter.ComputeFrequencyResponse(&H2);
-      aec_state.Update(delay_estimate, H2, h, *render_buffer, E2_main, Y2,
-                       output);
+    if (num_render_channels == 33) {
+      config.filter.main = {13, 0.00005f, 0.0005f, 0.0001f, 2.f, 20075344.f};
+      config.filter.shadow = {13, 0.1f, 20075344.f};
+      config.filter.main_initial = {12, 0.005f, 0.5f, 0.001f, 2.f, 20075344.f};
+      config.filter.shadow_initial = {12, 0.7f, 20075344.f};
     }
-    // Verify that the filter is able to perform well.
-    EXPECT_LT(1000 * std::inner_product(e.begin(), e.end(), e.begin(), 0.f),
-              std::inner_product(y.begin(), y.end(), y.begin(), 0.f));
+
+    AdaptiveFirFilter filter(
+        config.filter.main.length_blocks, config.filter.main.length_blocks,
+        config.filter.config_change_duration_blocks, num_render_channels,
+        DetectOptimization(), &data_dumper);
+    std::vector<std::array<float, kFftLengthBy2Plus1>> H2(
+        filter.max_filter_size_partitions(),
+        std::array<float, kFftLengthBy2Plus1>());
+    std::vector<float> h(
+        GetTimeDomainLength(filter.max_filter_size_partitions()), 0.f);
+    Aec3Fft fft;
+    config.delay.default_delay = 1;
+    std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
+        RenderDelayBuffer::Create(config, kSampleRateHz, num_render_channels));
+    ShadowFilterUpdateGain gain(config.filter.shadow,
+                                config.filter.config_change_duration_blocks);
+    Random random_generator(42U);
+    std::vector<std::vector<std::vector<float>>> x(
+        kNumBands,
+        std::vector<std::vector<float>>(num_render_channels,
+                                        std::vector<float>(kBlockSize, 0.f)));
+    std::vector<float> n(kBlockSize, 0.f);
+    std::vector<float> y(kBlockSize, 0.f);
+    AecState aec_state(EchoCanceller3Config{}, kNumCaptureChannels);
+    RenderSignalAnalyzer render_signal_analyzer(config);
+    absl::optional<DelayEstimate> delay_estimate;
+    std::vector<float> e(kBlockSize, 0.f);
+    std::array<float, kFftLength> s_scratch;
+    std::vector<SubtractorOutput> output(kNumCaptureChannels);
+    FftData S;
+    FftData G;
+    FftData E;
+    std::array<float, kFftLengthBy2Plus1> Y2;
+    std::array<float, kFftLengthBy2Plus1> E2_main;
+    std::array<float, kFftLengthBy2Plus1> E2_shadow;
+    // [B,A] = butter(2,100/8000,'high')
+    constexpr CascadedBiQuadFilter::BiQuadCoefficients
+        kHighPassFilterCoefficients = {{0.97261f, -1.94523f, 0.97261f},
+                                       {-1.94448f, 0.94598f}};
+    Y2.fill(0.f);
+    E2_main.fill(0.f);
+    E2_shadow.fill(0.f);
+    for (auto& subtractor_output : output) {
+      subtractor_output.Reset();
+    }
+
+    constexpr float kScale = 1.0f / kFftLengthBy2;
+
+    for (size_t delay_samples : {0, 64, 150, 200, 301}) {
+      std::vector<DelayBuffer<float>> delay_buffer(
+          num_render_channels, DelayBuffer<float>(delay_samples));
+      std::vector<std::unique_ptr<CascadedBiQuadFilter>> x_hp_filter(
+          num_render_channels);
+      for (size_t ch = 0; ch < num_render_channels; ++ch) {
+        x_hp_filter[ch] = std::make_unique<CascadedBiQuadFilter>(
+            kHighPassFilterCoefficients, 1);
+      }
+      CascadedBiQuadFilter y_hp_filter(kHighPassFilterCoefficients, 1);
+
+      SCOPED_TRACE(ProduceDebugText(num_render_channels, delay_samples));
+      const size_t num_blocks_to_process =
+          kNumBlocksToProcessPerRenderChannel * num_render_channels;
+      for (size_t j = 0; j < num_blocks_to_process; ++j) {
+        std::fill(y.begin(), y.end(), 0.f);
+        for (size_t ch = 0; ch < num_render_channels; ++ch) {
+          RandomizeSampleVector(&random_generator, x[0][ch]);
+          std::array<float, kBlockSize> y_channel;
+          delay_buffer[ch].Delay(x[0][ch], y_channel);
+          for (size_t k = 0; k < y.size(); ++k) {
+            y[k] += y_channel[k] / num_render_channels;
+          }
+        }
+
+        RandomizeSampleVector(&random_generator, n);
+        const float noise_scaling = 1.f / 100.f / num_render_channels;
+        for (size_t k = 0; k < y.size(); ++k) {
+          y[k] += n[k] * noise_scaling;
+        }
+
+        for (size_t ch = 0; ch < num_render_channels; ++ch) {
+          x_hp_filter[ch]->Process(x[0][ch]);
+        }
+        y_hp_filter.Process(y);
+
+        render_delay_buffer->Insert(x);
+        if (j == 0) {
+          render_delay_buffer->Reset();
+        }
+        render_delay_buffer->PrepareCaptureProcessing();
+        auto* const render_buffer = render_delay_buffer->GetRenderBuffer();
+
+        render_signal_analyzer.Update(*render_buffer,
+                                      aec_state.FilterDelayBlocks());
+
+        filter.Filter(*render_buffer, &S);
+        fft.Ifft(S, &s_scratch);
+        std::transform(y.begin(), y.end(), s_scratch.begin() + kFftLengthBy2,
+                       e.begin(),
+                       [&](float a, float b) { return a - b * kScale; });
+        std::for_each(e.begin(), e.end(), [](float& a) {
+          a = rtc::SafeClamp(a, -32768.f, 32767.f);
+        });
+        fft.ZeroPaddedFft(e, Aec3Fft::Window::kRectangular, &E);
+        for (auto& o : output) {
+          for (size_t k = 0; k < kBlockSize; ++k) {
+            o.s_main[k] = kScale * s_scratch[k + kFftLengthBy2];
+          }
+        }
+
+        std::array<float, kFftLengthBy2Plus1> render_power;
+        render_buffer->SpectralSum(filter.SizePartitions(), &render_power);
+        gain.Compute(render_power, render_signal_analyzer, E,
+                     filter.SizePartitions(), false, &G);
+        filter.Adapt(*render_buffer, G, &h);
+        aec_state.HandleEchoPathChange(EchoPathVariability(
+            false, EchoPathVariability::DelayAdjustment::kNone, false));
+
+        filter.ComputeFrequencyResponse(&H2);
+        aec_state.Update(delay_estimate, H2, h, *render_buffer, E2_main, Y2,
+                         output);
+      }
+      // Verify that the filter is able to perform well.
+      EXPECT_LT(1000 * std::inner_product(e.begin(), e.end(), e.begin(), 0.f),
+                std::inner_product(y.begin(), y.end(), y.begin(), 0.f));
+    }
   }
 }
 }  // namespace aec3
diff --git a/modules/audio_processing/aec3/comfort_noise_generator_unittest.cc b/modules/audio_processing/aec3/comfort_noise_generator_unittest.cc
index 94aa039..7abbb79 100644
--- a/modules/audio_processing/aec3/comfort_noise_generator_unittest.cc
+++ b/modules/audio_processing/aec3/comfort_noise_generator_unittest.cc
@@ -13,6 +13,7 @@
 #include <algorithm>
 #include <numeric>
 
+#include "modules/audio_processing/aec3/aec_state.h"
 #include "rtc_base/random.h"
 #include "rtc_base/system/arch.h"
 #include "system_wrappers/include/cpu_features_wrapper.h"
diff --git a/modules/audio_processing/aec3/echo_remover.cc b/modules/audio_processing/aec3/echo_remover.cc
index 2df9cfd..c33b39c 100644
--- a/modules/audio_processing/aec3/echo_remover.cc
+++ b/modules/audio_processing/aec3/echo_remover.cc
@@ -386,9 +386,9 @@
 
   // Update the AEC state information.
   // TODO(bugs.webrtc.org/10913): Take all subtractors into account.
-  aec_state_.Update(external_delay, subtractor_.FilterFrequencyResponse(),
-                    subtractor_.FilterImpulseResponse(), *render_buffer, E2[0],
-                    Y2[0], subtractor_output);
+  aec_state_.Update(external_delay, subtractor_.FilterFrequencyResponse()[0],
+                    subtractor_.FilterImpulseResponse()[0], *render_buffer,
+                    E2[0], Y2[0], subtractor_output);
 
   // Choose the linear output.
   const auto& Y_fft = aec_state_.UseLinearFilterOutput() ? E : Y;
diff --git a/modules/audio_processing/aec3/main_filter_update_gain.cc b/modules/audio_processing/aec3/main_filter_update_gain.cc
index c2cfd2c..43f37b0 100644
--- a/modules/audio_processing/aec3/main_filter_update_gain.cc
+++ b/modules/audio_processing/aec3/main_filter_update_gain.cc
@@ -80,7 +80,7 @@
   const auto& E2_main = subtractor_output.E2_main;
   const auto& E2_shadow = subtractor_output.E2_shadow;
   FftData* G = gain_fft;
-  auto X2 = render_power;
+  const auto& X2 = render_power;
 
   ++call_counter_;
 
@@ -100,43 +100,40 @@
     std::array<float, kFftLengthBy2Plus1> mu;
     // mu = H_error / (0.5* H_error* X2 + n * E2).
     for (size_t k = 0; k < kFftLengthBy2Plus1; ++k) {
-      mu[k] = X2[k] > current_config_.noise_gate
-                  ? H_error_[k] / (0.5f * H_error_[k] * X2[k] +
-                                   size_partitions * E2_main[k])
-                  : 0.f;
+      if (X2[k] >= current_config_.noise_gate) {
+        mu[k] = H_error_[k] /
+                (0.5f * H_error_[k] * X2[k] + size_partitions * E2_main[k]);
+      } else {
+        mu[k] = 0.f;
+      }
     }
 
     // Avoid updating the filter close to narrow bands in the render signals.
     render_signal_analyzer.MaskRegionsAroundNarrowBands(&mu);
 
     // H_error = H_error - 0.5 * mu * X2 * H_error.
-    for (size_t k = 0; k < H_error_.size(); ++k) {
+    for (size_t k = 0; k < kFftLengthBy2Plus1; ++k) {
       H_error_[k] -= 0.5f * mu[k] * X2[k] * H_error_[k];
     }
 
     // G = mu * E.
-    std::transform(mu.begin(), mu.end(), E_main.re.begin(), G->re.begin(),
-                   std::multiplies<float>());
-    std::transform(mu.begin(), mu.end(), E_main.im.begin(), G->im.begin(),
-                   std::multiplies<float>());
+    for (size_t k = 0; k < kFftLengthBy2Plus1; ++k) {
+      G->re[k] = mu[k] * E_main.re[k];
+      G->im[k] = mu[k] * E_main.im[k];
+    }
   }
 
   // H_error = H_error + factor * erl.
-  std::array<float, kFftLengthBy2Plus1> H_error_increase;
-  std::transform(E2_shadow.begin(), E2_shadow.end(), E2_main.begin(),
-                 H_error_increase.begin(), [&](float a, float b) {
-                   return a >= b ? current_config_.leakage_converged
-                                 : current_config_.leakage_diverged;
-                 });
-  std::transform(erl.begin(), erl.end(), H_error_increase.begin(),
-                 H_error_increase.begin(), std::multiplies<float>());
-  std::transform(H_error_.begin(), H_error_.end(), H_error_increase.begin(),
-                 H_error_.begin(), [&](float a, float b) {
-                   float error = a + b;
-                   error = std::max(error, current_config_.error_floor);
-                   error = std::min(error, current_config_.error_ceil);
-                   return error;
-                 });
+  for (size_t k = 0; k < kFftLengthBy2Plus1; ++k) {
+    if (E2_shadow[k] >= E2_main[k]) {
+      H_error_[k] += current_config_.leakage_converged * erl[k];
+    } else {
+      H_error_[k] += current_config_.leakage_diverged * erl[k];
+    }
+
+    H_error_[k] = std::max(H_error_[k], current_config_.error_floor);
+    H_error_[k] = std::min(H_error_[k], current_config_.error_ceil);
+  }
 
   data_dumper_->DumpRaw("aec3_main_gain_H_error", H_error_);
 }
diff --git a/modules/audio_processing/aec3/main_filter_update_gain_unittest.cc b/modules/audio_processing/aec3/main_filter_update_gain_unittest.cc
index 20714ce..1a9e792 100644
--- a/modules/audio_processing/aec3/main_filter_update_gain_unittest.cc
+++ b/modules/audio_processing/aec3/main_filter_update_gain_unittest.cc
@@ -54,11 +54,11 @@
   AdaptiveFirFilter main_filter(config.filter.main.length_blocks,
                                 config.filter.main.length_blocks,
                                 config.filter.config_change_duration_blocks, 1,
-                                1, optimization, &data_dumper);
+                                optimization, &data_dumper);
   AdaptiveFirFilter shadow_filter(config.filter.shadow.length_blocks,
                                   config.filter.shadow.length_blocks,
                                   config.filter.config_change_duration_blocks,
-                                  1, 1, optimization, &data_dumper);
+                                  1, optimization, &data_dumper);
   std::vector<std::array<float, kFftLengthBy2Plus1>> H2(
       main_filter.max_filter_size_partitions(),
       std::array<float, kFftLengthBy2Plus1>());
diff --git a/modules/audio_processing/aec3/shadow_filter_update_gain.cc b/modules/audio_processing/aec3/shadow_filter_update_gain.cc
index e27437a..51ead2e 100644
--- a/modules/audio_processing/aec3/shadow_filter_update_gain.cc
+++ b/modules/audio_processing/aec3/shadow_filter_update_gain.cc
@@ -28,8 +28,6 @@
 }
 
 void ShadowFilterUpdateGain::HandleEchoPathChange() {
-  // TODO(peah): Check whether this counter should instead be initialized to a
-  // large value.
   poor_signal_excitation_counter_ = 0;
   call_counter_ = 0;
 }
@@ -60,19 +58,23 @@
 
   // Compute mu.
   std::array<float, kFftLengthBy2Plus1> mu;
-  auto X2 = render_power;
-  std::transform(X2.begin(), X2.end(), mu.begin(), [&](float a) {
-    return a > current_config_.noise_gate ? current_config_.rate / a : 0.f;
-  });
+  const auto& X2 = render_power;
+  for (size_t k = 0; k < kFftLengthBy2Plus1; ++k) {
+    if (X2[k] > current_config_.noise_gate) {
+      mu[k] = current_config_.rate / X2[k];
+    } else {
+      mu[k] = 0.f;
+    }
+  }
 
   // Avoid updating the filter close to narrow bands in the render signals.
   render_signal_analyzer.MaskRegionsAroundNarrowBands(&mu);
 
   // G = mu * E * X2.
-  std::transform(mu.begin(), mu.end(), E_shadow.re.begin(), G->re.begin(),
-                 std::multiplies<float>());
-  std::transform(mu.begin(), mu.end(), E_shadow.im.begin(), G->im.begin(),
-                 std::multiplies<float>());
+  for (size_t k = 0; k < kFftLengthBy2Plus1; ++k) {
+    G->re[k] = mu[k] * E_shadow.re[k];
+    G->im[k] = mu[k] * E_shadow.im[k];
+  }
 }
 
 void ShadowFilterUpdateGain::UpdateCurrentConfig() {
diff --git a/modules/audio_processing/aec3/shadow_filter_update_gain_unittest.cc b/modules/audio_processing/aec3/shadow_filter_update_gain_unittest.cc
index 605f570..a73a539 100644
--- a/modules/audio_processing/aec3/shadow_filter_update_gain_unittest.cc
+++ b/modules/audio_processing/aec3/shadow_filter_update_gain_unittest.cc
@@ -44,11 +44,11 @@
   AdaptiveFirFilter main_filter(config.filter.main.length_blocks,
                                 config.filter.main.length_blocks,
                                 config.filter.config_change_duration_blocks, 1,
-                                1, DetectOptimization(), &data_dumper);
+                                DetectOptimization(), &data_dumper);
   AdaptiveFirFilter shadow_filter(config.filter.shadow.length_blocks,
                                   config.filter.shadow.length_blocks,
                                   config.filter.config_change_duration_blocks,
-                                  1, 1, DetectOptimization(), &data_dumper);
+                                  1, DetectOptimization(), &data_dumper);
   Aec3Fft fft;
 
   constexpr int kSampleRateHz = 48000;
diff --git a/modules/audio_processing/aec3/subtractor.cc b/modules/audio_processing/aec3/subtractor.cc
index 0c52ed6..5e99565 100644
--- a/modules/audio_processing/aec3/subtractor.cc
+++ b/modules/audio_processing/aec3/subtractor.cc
@@ -89,13 +89,13 @@
         config_.filter.main.length_blocks,
         config_.filter.main_initial.length_blocks,
         config.filter.config_change_duration_blocks, num_render_channels,
-        num_capture_channels, optimization, data_dumper_);
+        optimization, data_dumper_);
 
     shadow_filter_[ch] = std::make_unique<AdaptiveFirFilter>(
         config_.filter.shadow.length_blocks,
         config_.filter.shadow_initial.length_blocks,
         config.filter.config_change_duration_blocks, num_render_channels,
-        num_capture_channels, optimization, data_dumper_);
+        optimization, data_dumper_);
     G_main_[ch] = std::make_unique<MainFilterUpdateGain>(
         config_.filter.main_initial,
         config_.filter.config_change_duration_blocks);
@@ -162,14 +162,12 @@
   RTC_DCHECK_EQ(num_capture_channels_, capture.size());
 
   // Compute the render powers.
+  const bool same_filter_sizes =
+      main_filter_[0]->SizePartitions() == shadow_filter_[0]->SizePartitions();
   std::array<float, kFftLengthBy2Plus1> X2_main;
   std::array<float, kFftLengthBy2Plus1> X2_shadow_data;
-  std::array<float, kFftLengthBy2Plus1>& X2_shadow =
-      main_filter_[0]->SizePartitions() == shadow_filter_[0]->SizePartitions()
-          ? X2_main
-          : X2_shadow_data;
-  if (main_filter_[0]->SizePartitions() ==
-      shadow_filter_[0]->SizePartitions()) {
+  auto& X2_shadow = same_filter_sizes ? X2_main : X2_shadow_data;
+  if (same_filter_sizes) {
     render_buffer.SpectralSum(main_filter_[0]->SizePartitions(), &X2_main);
   } else if (main_filter_[0]->SizePartitions() >
              shadow_filter_[0]->SizePartitions()) {
@@ -256,7 +254,8 @@
                              aec_state.SaturatedCapture(), &G);
     } else {
       poor_shadow_filter_counter_[ch] = 0;
-      shadow_filter_[ch]->SetFilter(main_filter_[ch]->GetFilter());
+      shadow_filter_[ch]->SetFilter(main_filter_[ch]->SizePartitions(),
+                                    main_filter_[ch]->GetFilter());
       G_shadow_[ch]->Compute(X2_shadow, render_signal_analyzer, E_main,
                              shadow_filter_[ch]->SizePartitions(),
                              aec_state.SaturatedCapture(), &G);
diff --git a/modules/audio_processing/aec3/subtractor.h b/modules/audio_processing/aec3/subtractor.h
index c5fb765..01d2eef 100644
--- a/modules/audio_processing/aec3/subtractor.h
+++ b/modules/audio_processing/aec3/subtractor.h
@@ -59,26 +59,24 @@
   void ExitInitialState();
 
   // Returns the block-wise frequency responses for the main adaptive filters.
-  // TODO(bugs.webrtc.org/10913): Return the frequency responses for all capture
-  // channels.
-  const std::vector<std::array<float, kFftLengthBy2Plus1>>&
+  const std::vector<std::vector<std::array<float, kFftLengthBy2Plus1>>>&
   FilterFrequencyResponse() const {
-    return main_frequency_response_[0];
+    return main_frequency_response_;
   }
 
   // Returns the estimates of the impulse responses for the main adaptive
   // filters.
-  // TODO(bugs.webrtc.org/10913): Return the impulse responses for all capture
-  // channels.
-  const std::vector<float>& FilterImpulseResponse() const {
-    return main_impulse_response_[0];
+  const std::vector<std::vector<float>>& FilterImpulseResponse() const {
+    return main_impulse_response_;
   }
 
   void DumpFilters() {
-    size_t current_size = main_impulse_response_[0].size();
-    main_impulse_response_[0].resize(main_impulse_response_[0].capacity());
-    data_dumper_->DumpRaw("aec3_subtractor_h_main", main_impulse_response_[0]);
-    main_impulse_response_[0].resize(current_size);
+    data_dumper_->DumpRaw(
+        "aec3_subtractor_h_main",
+        rtc::ArrayView<const float>(
+            main_impulse_response_[0].data(),
+            GetTimeDomainLength(
+                main_filter_[0]->max_filter_size_partitions())));
 
     main_filter_[0]->DumpFilter("aec3_subtractor_H_main");
     shadow_filter_[0]->DumpFilter("aec3_subtractor_H_shadow");
diff --git a/modules/audio_processing/aec3/subtractor_unittest.cc b/modules/audio_processing/aec3/subtractor_unittest.cc
index b5635f4..23e7ead 100644
--- a/modules/audio_processing/aec3/subtractor_unittest.cc
+++ b/modules/audio_processing/aec3/subtractor_unittest.cc
@@ -11,12 +11,14 @@
 #include "modules/audio_processing/aec3/subtractor.h"
 
 #include <algorithm>
+#include <memory>
 #include <numeric>
 #include <string>
 
 #include "modules/audio_processing/aec3/aec_state.h"
 #include "modules/audio_processing/aec3/render_delay_buffer.h"
 #include "modules/audio_processing/test/echo_canceller_test_tools.h"
+#include "modules/audio_processing/utility/cascaded_biquad_filter.h"
 #include "rtc_base/random.h"
 #include "rtc_base/strings/string_builder.h"
 #include "test/gtest.h"
@@ -24,51 +26,104 @@
 namespace webrtc {
 namespace {
 
-float RunSubtractorTest(int num_blocks_to_process,
-                        int delay_samples,
-                        int main_filter_length_blocks,
-                        int shadow_filter_length_blocks,
-                        bool uncorrelated_inputs,
-                        const std::vector<int>& blocks_with_echo_path_changes) {
+std::vector<float> RunSubtractorTest(
+    size_t num_render_channels,
+    size_t num_capture_channels,
+    int num_blocks_to_process,
+    int delay_samples,
+    int main_filter_length_blocks,
+    int shadow_filter_length_blocks,
+    bool uncorrelated_inputs,
+    const std::vector<int>& blocks_with_echo_path_changes) {
   ApmDataDumper data_dumper(42);
-  constexpr size_t kNumChannels = 1;
   constexpr int kSampleRateHz = 48000;
   constexpr size_t kNumBands = NumBandsForRate(kSampleRateHz);
   EchoCanceller3Config config;
   config.filter.main.length_blocks = main_filter_length_blocks;
   config.filter.shadow.length_blocks = shadow_filter_length_blocks;
 
-  Subtractor subtractor(config, 1, 1, &data_dumper, DetectOptimization());
+  Subtractor subtractor(config, num_render_channels, num_capture_channels,
+                        &data_dumper, DetectOptimization());
   absl::optional<DelayEstimate> delay_estimate;
   std::vector<std::vector<std::vector<float>>> x(
       kNumBands, std::vector<std::vector<float>>(
-                     kNumChannels, std::vector<float>(kBlockSize, 0.f)));
-  std::vector<std::vector<float>> y(1, std::vector<float>(kBlockSize, 0.f));
+                     num_render_channels, std::vector<float>(kBlockSize, 0.f)));
+  std::vector<std::vector<float>> y(num_capture_channels,
+                                    std::vector<float>(kBlockSize, 0.f));
   std::array<float, kBlockSize> x_old;
-  std::array<SubtractorOutput, 1> output;
+  std::vector<SubtractorOutput> output(num_capture_channels);
   config.delay.default_delay = 1;
   std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
-      RenderDelayBuffer::Create(config, kSampleRateHz, kNumChannels));
+      RenderDelayBuffer::Create(config, kSampleRateHz, num_render_channels));
   RenderSignalAnalyzer render_signal_analyzer(config);
   Random random_generator(42U);
   Aec3Fft fft;
   std::array<float, kFftLengthBy2Plus1> Y2;
   std::array<float, kFftLengthBy2Plus1> E2_main;
   std::array<float, kFftLengthBy2Plus1> E2_shadow;
-  AecState aec_state(config, kNumChannels);
+  AecState aec_state(config, num_capture_channels);
   x_old.fill(0.f);
   Y2.fill(0.f);
   E2_main.fill(0.f);
   E2_shadow.fill(0.f);
 
-  DelayBuffer<float> delay_buffer(delay_samples);
-  for (int k = 0; k < num_blocks_to_process; ++k) {
-    RandomizeSampleVector(&random_generator, x[0][0]);
-    if (uncorrelated_inputs) {
-      RandomizeSampleVector(&random_generator, y[0]);
-    } else {
-      delay_buffer.Delay(x[0][0], y[0]);
+  std::vector<std::vector<std::unique_ptr<DelayBuffer<float>>>> delay_buffer(
+      num_capture_channels);
+  for (size_t capture_ch = 0; capture_ch < num_capture_channels; ++capture_ch) {
+    delay_buffer[capture_ch].resize(num_render_channels);
+    for (size_t render_ch = 0; render_ch < num_render_channels; ++render_ch) {
+      delay_buffer[capture_ch][render_ch] =
+          std::make_unique<DelayBuffer<float>>(delay_samples);
     }
+  }
+
+  // [B,A] = butter(2,100/8000,'high')
+  constexpr CascadedBiQuadFilter::BiQuadCoefficients
+      kHighPassFilterCoefficients = {{0.97261f, -1.94523f, 0.97261f},
+                                     {-1.94448f, 0.94598f}};
+  std::vector<std::unique_ptr<CascadedBiQuadFilter>> x_hp_filter(
+      num_render_channels);
+  for (size_t ch = 0; ch < num_render_channels; ++ch) {
+    x_hp_filter[ch] =
+        std::make_unique<CascadedBiQuadFilter>(kHighPassFilterCoefficients, 1);
+  }
+  std::vector<std::unique_ptr<CascadedBiQuadFilter>> y_hp_filter(
+      num_capture_channels);
+  for (size_t ch = 0; ch < num_capture_channels; ++ch) {
+    y_hp_filter[ch] =
+        std::make_unique<CascadedBiQuadFilter>(kHighPassFilterCoefficients, 1);
+  }
+
+  for (int k = 0; k < num_blocks_to_process; ++k) {
+    for (size_t render_ch = 0; render_ch < num_render_channels; ++render_ch) {
+      RandomizeSampleVector(&random_generator, x[0][render_ch]);
+    }
+    if (uncorrelated_inputs) {
+      for (size_t capture_ch = 0; capture_ch < num_capture_channels;
+           ++capture_ch) {
+        RandomizeSampleVector(&random_generator, y[capture_ch]);
+      }
+    } else {
+      for (size_t capture_ch = 0; capture_ch < num_capture_channels;
+           ++capture_ch) {
+        for (size_t render_ch = 0; render_ch < num_render_channels;
+             ++render_ch) {
+          std::array<float, kBlockSize> y_channel;
+          delay_buffer[capture_ch][render_ch]->Delay(x[0][render_ch],
+                                                     y_channel);
+          for (size_t k = 0; k < y.size(); ++k) {
+            y[capture_ch][k] += y_channel[k] / num_render_channels;
+          }
+        }
+      }
+    }
+    for (size_t ch = 0; ch < num_render_channels; ++ch) {
+      x_hp_filter[ch]->Process(x[0][ch]);
+    }
+    for (size_t ch = 0; ch < num_capture_channels; ++ch) {
+      y_hp_filter[ch]->Process(y[ch]);
+    }
+
     render_delay_buffer->Insert(x);
     if (k == 0) {
       render_delay_buffer->Reset();
@@ -90,28 +145,37 @@
 
     aec_state.HandleEchoPathChange(EchoPathVariability(
         false, EchoPathVariability::DelayAdjustment::kNone, false));
-    aec_state.Update(delay_estimate, subtractor.FilterFrequencyResponse(),
-                     subtractor.FilterImpulseResponse(),
+    aec_state.Update(delay_estimate, subtractor.FilterFrequencyResponse()[0],
+                     subtractor.FilterImpulseResponse()[0],
                      *render_delay_buffer->GetRenderBuffer(), E2_main, Y2,
                      output);
   }
 
-  const float output_power =
-      std::inner_product(output[0].e_main.begin(), output[0].e_main.end(),
-                         output[0].e_main.begin(), 0.f);
-  const float y_power =
-      std::inner_product(y[0].begin(), y[0].end(), y[0].begin(), 0.f);
-  if (y_power == 0.f) {
-    ADD_FAILURE();
-    return -1.0;
+  std::vector<float> results(num_capture_channels);
+  for (size_t ch = 0; ch < num_capture_channels; ++ch) {
+    const float output_power =
+        std::inner_product(output[ch].e_main.begin(), output[ch].e_main.end(),
+                           output[ch].e_main.begin(), 0.f);
+    const float y_power =
+        std::inner_product(y[ch].begin(), y[ch].end(), y[ch].begin(), 0.f);
+    if (y_power == 0.f) {
+      ADD_FAILURE();
+      results[ch] = -1.f;
+    }
+    results[ch] = output_power / y_power;
   }
-  return output_power / y_power;
+  return results;
 }
 
-std::string ProduceDebugText(size_t delay, int filter_length_blocks) {
+std::string ProduceDebugText(size_t num_render_channels,
+                             size_t num_capture_channels,
+                             size_t delay,
+                             int filter_length_blocks) {
   rtc::StringBuilder ss;
-  ss << "Delay: " << delay << ", ";
-  ss << "Length: " << filter_length_blocks;
+  ss << "delay: " << delay << ", ";
+  ss << "filter_length_blocks:" << filter_length_blocks << ", ";
+  ss << "num_render_channels:" << num_render_channels << ", ";
+  ss << "num_capture_channels:" << num_capture_channels;
   return ss.Release();
 }
 
@@ -150,17 +214,32 @@
   std::vector<int> blocks_with_echo_path_changes;
   for (size_t filter_length_blocks : {12, 20, 30}) {
     for (size_t delay_samples : {0, 64, 150, 200, 301}) {
-      SCOPED_TRACE(ProduceDebugText(delay_samples, filter_length_blocks));
+      SCOPED_TRACE(ProduceDebugText(1, 1, delay_samples, filter_length_blocks));
+      std::vector<float> echo_to_nearend_powers = RunSubtractorTest(
+          1, 1, 2500, delay_samples, filter_length_blocks, filter_length_blocks,
+          false, blocks_with_echo_path_changes);
 
-      float echo_to_nearend_power = RunSubtractorTest(
-          400, delay_samples, filter_length_blocks, filter_length_blocks, false,
-          blocks_with_echo_path_changes);
-
-      // Use different criteria to take overmodelling into account.
-      if (filter_length_blocks == 12) {
+      for (float echo_to_nearend_power : echo_to_nearend_powers) {
         EXPECT_GT(0.1f, echo_to_nearend_power);
-      } else {
-        EXPECT_GT(1.f, echo_to_nearend_power);
+      }
+    }
+  }
+}
+
+// Verifies that the subtractor is able to converge on correlated data.
+TEST(Subtractor, ConvergenceMultiChannel) {
+  std::vector<int> blocks_with_echo_path_changes;
+  for (size_t num_render_channels : {1, 2, 4, 8}) {
+    for (size_t num_capture_channels : {1, 2, 4}) {
+      SCOPED_TRACE(
+          ProduceDebugText(num_render_channels, num_render_channels, 64, 20));
+      size_t num_blocks_to_process = 2500 * num_render_channels;
+      std::vector<float> echo_to_nearend_powers = RunSubtractorTest(
+          num_render_channels, num_capture_channels, num_blocks_to_process, 64,
+          20, 20, false, blocks_with_echo_path_changes);
+
+      for (float echo_to_nearend_power : echo_to_nearend_powers) {
+        EXPECT_GT(0.1f, echo_to_nearend_power);
       }
     }
   }
@@ -170,18 +249,22 @@
 // is longer than the shadow filter.
 TEST(Subtractor, MainFilterLongerThanShadowFilter) {
   std::vector<int> blocks_with_echo_path_changes;
-  float echo_to_nearend_power =
-      RunSubtractorTest(400, 64, 20, 15, false, blocks_with_echo_path_changes);
-  EXPECT_GT(0.5f, echo_to_nearend_power);
+  std::vector<float> echo_to_nearend_powers = RunSubtractorTest(
+      1, 1, 400, 64, 20, 15, false, blocks_with_echo_path_changes);
+  for (float echo_to_nearend_power : echo_to_nearend_powers) {
+    EXPECT_GT(0.5f, echo_to_nearend_power);
+  }
 }
 
 // Verifies that the subtractor is able to handle the case when the shadow
 // filter is longer than the main filter.
 TEST(Subtractor, ShadowFilterLongerThanMainFilter) {
   std::vector<int> blocks_with_echo_path_changes;
-  float echo_to_nearend_power =
-      RunSubtractorTest(400, 64, 15, 20, false, blocks_with_echo_path_changes);
-  EXPECT_GT(0.5f, echo_to_nearend_power);
+  std::vector<float> echo_to_nearend_powers = RunSubtractorTest(
+      1, 1, 400, 64, 15, 20, false, blocks_with_echo_path_changes);
+  for (float echo_to_nearend_power : echo_to_nearend_powers) {
+    EXPECT_GT(0.5f, echo_to_nearend_power);
+  }
 }
 
 // Verifies that the subtractor does not converge on uncorrelated signals.
@@ -189,12 +272,33 @@
   std::vector<int> blocks_with_echo_path_changes;
   for (size_t filter_length_blocks : {12, 20, 30}) {
     for (size_t delay_samples : {0, 64, 150, 200, 301}) {
-      SCOPED_TRACE(ProduceDebugText(delay_samples, filter_length_blocks));
+      SCOPED_TRACE(ProduceDebugText(1, 1, delay_samples, filter_length_blocks));
 
-      float echo_to_nearend_power = RunSubtractorTest(
-          300, delay_samples, filter_length_blocks, filter_length_blocks, true,
-          blocks_with_echo_path_changes);
-      EXPECT_NEAR(1.f, echo_to_nearend_power, 0.1);
+      std::vector<float> echo_to_nearend_powers = RunSubtractorTest(
+          1, 1, 3000, delay_samples, filter_length_blocks, filter_length_blocks,
+          true, blocks_with_echo_path_changes);
+      for (float echo_to_nearend_power : echo_to_nearend_powers) {
+        EXPECT_NEAR(1.f, echo_to_nearend_power, 0.1);
+      }
+    }
+  }
+}
+
+// Verifies that the subtractor does not converge on uncorrelated signals.
+TEST(Subtractor, NonConvergenceOnUncorrelatedSignalsMultiChannel) {
+  std::vector<int> blocks_with_echo_path_changes;
+  for (size_t num_render_channels : {1, 2, 4}) {
+    for (size_t num_capture_channels : {1, 2, 4}) {
+      SCOPED_TRACE(
+          ProduceDebugText(num_render_channels, num_render_channels, 64, 20));
+      size_t num_blocks_to_process = 5000 * num_render_channels;
+      std::vector<float> echo_to_nearend_powers = RunSubtractorTest(
+          num_render_channels, num_capture_channels, num_blocks_to_process, 64,
+          20, 20, true, blocks_with_echo_path_changes);
+      for (float echo_to_nearend_power : echo_to_nearend_powers) {
+        EXPECT_LT(.8f, echo_to_nearend_power);
+        EXPECT_NEAR(1.f, echo_to_nearend_power, 0.25f);
+      }
     }
   }
 }
diff --git a/modules/audio_processing/aec3/suppression_gain_unittest.cc b/modules/audio_processing/aec3/suppression_gain_unittest.cc
index 490c7ec..465227c 100644
--- a/modules/audio_processing/aec3/suppression_gain_unittest.cc
+++ b/modules/audio_processing/aec3/suppression_gain_unittest.cc
@@ -97,14 +97,14 @@
 
   // Ensure that the gain is no longer forced to zero.
   for (int k = 0; k <= kNumBlocksPerSecond / 5 + 1; ++k) {
-    aec_state.Update(delay_estimate, subtractor.FilterFrequencyResponse(),
-                     subtractor.FilterImpulseResponse(),
+    aec_state.Update(delay_estimate, subtractor.FilterFrequencyResponse()[0],
+                     subtractor.FilterImpulseResponse()[0],
                      *render_delay_buffer->GetRenderBuffer(), E2, Y2, output);
   }
 
   for (int k = 0; k < 100; ++k) {
-    aec_state.Update(delay_estimate, subtractor.FilterFrequencyResponse(),
-                     subtractor.FilterImpulseResponse(),
+    aec_state.Update(delay_estimate, subtractor.FilterFrequencyResponse()[0],
+                     subtractor.FilterImpulseResponse()[0],
                      *render_delay_buffer->GetRenderBuffer(), E2, Y2, output);
     suppression_gain.GetGain(E2, S2, R2, N2, analyzer, aec_state, x,
                              &high_bands_gain, &g);
@@ -120,8 +120,8 @@
   N2.fill(0.f);
 
   for (int k = 0; k < 100; ++k) {
-    aec_state.Update(delay_estimate, subtractor.FilterFrequencyResponse(),
-                     subtractor.FilterImpulseResponse(),
+    aec_state.Update(delay_estimate, subtractor.FilterFrequencyResponse()[0],
+                     subtractor.FilterImpulseResponse()[0],
                      *render_delay_buffer->GetRenderBuffer(), E2, Y2, output);
     suppression_gain.GetGain(E2, S2, R2, N2, analyzer, aec_state, x,
                              &high_bands_gain, &g);
diff --git a/modules/audio_processing/test/echo_canceller_test_tools.h b/modules/audio_processing/test/echo_canceller_test_tools.h
index bab7f27..0d70cd3 100644
--- a/modules/audio_processing/test/echo_canceller_test_tools.h
+++ b/modules/audio_processing/test/echo_canceller_test_tools.h
@@ -15,7 +15,6 @@
 #include <vector>
 
 #include "api/array_view.h"
-#include "rtc_base/constructor_magic.h"
 #include "rtc_base/random.h"
 
 namespace webrtc {
@@ -41,7 +40,6 @@
  private:
   std::vector<T> buffer_;
   size_t next_insert_index_ = 0;
-  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(DelayBuffer);
 };
 
 }  // namespace webrtc