diff --git a/modules/audio_processing/aec3/block_delay_buffer.cc b/modules/audio_processing/aec3/block_delay_buffer.cc
index 0a242ee..6c1df7c 100644
--- a/modules/audio_processing/aec3/block_delay_buffer.cc
+++ b/modules/audio_processing/aec3/block_delay_buffer.cc
@@ -35,8 +35,8 @@
     i = i_start;
     for (size_t k = 0; k < frame_length_; ++k) {
       const float tmp = buf_[j][i];
-      buf_[j][i] = frame->split_bands_f(0)[j][k];
-      frame->split_bands_f(0)[j][k] = tmp;
+      buf_[j][i] = frame->split_bands(0)[j][k];
+      frame->split_bands(0)[j][k] = tmp;
       i = i < buf_[0].size() - 1 ? i + 1 : 0;
     }
   }
diff --git a/modules/audio_processing/aec3/block_delay_buffer_unittest.cc b/modules/audio_processing/aec3/block_delay_buffer_unittest.cc
index 778d43d..349cae6 100644
--- a/modules/audio_processing/aec3/block_delay_buffer_unittest.cc
+++ b/modules/audio_processing/aec3/block_delay_buffer_unittest.cc
@@ -53,7 +53,6 @@
     for (auto rate : {8000, 16000, 32000, 48000}) {
       SCOPED_TRACE(ProduceDebugText(rate, delay));
       size_t num_bands = NumBandsForRate(rate);
-      size_t fullband_frame_length = rate / 100;
       size_t subband_frame_length = rate == 8000 ? 80 : 160;
 
       BlockDelayBuffer delay_buffer(num_bands, subband_frame_length, delay);
@@ -61,25 +60,23 @@
       static constexpr size_t kNumFramesToProcess = 20;
       for (size_t frame_index = 0; frame_index < kNumFramesToProcess;
            ++frame_index) {
-        AudioBuffer audio_buffer(fullband_frame_length, 1,
-                                 fullband_frame_length, 1,
-                                 fullband_frame_length);
+        AudioBuffer audio_buffer(rate, 1, rate, 1, rate);
         if (rate > 16000) {
           audio_buffer.SplitIntoFrequencyBands();
         }
         size_t first_sample_index = frame_index * subband_frame_length;
         PopulateInputFrame(subband_frame_length, num_bands, first_sample_index,
-                           &audio_buffer.split_bands_f(0)[0]);
+                           &audio_buffer.split_bands(0)[0]);
         delay_buffer.DelaySignal(&audio_buffer);
 
         for (size_t k = 0; k < num_bands; ++k) {
           size_t sample_index = first_sample_index;
           for (size_t i = 0; i < subband_frame_length; ++i, ++sample_index) {
             if (sample_index < delay) {
-              EXPECT_EQ(0.f, audio_buffer.split_bands_f(0)[k][i]);
+              EXPECT_EQ(0.f, audio_buffer.split_bands(0)[k][i]);
             } else {
               EXPECT_EQ(SampleValue(sample_index - delay),
-                        audio_buffer.split_bands_f(0)[k][i]);
+                        audio_buffer.split_bands(0)[k][i]);
             }
           }
         }
diff --git a/modules/audio_processing/aec3/echo_canceller3.cc b/modules/audio_processing/aec3/echo_canceller3.cc
index 8a4d8c2..952f5e7 100644
--- a/modules/audio_processing/aec3/echo_canceller3.cc
+++ b/modules/audio_processing/aec3/echo_canceller3.cc
@@ -52,7 +52,7 @@
   RTC_DCHECK_EQ(frame->num_bands(), sub_frame_view->size());
   for (size_t k = 0; k < sub_frame_view->size(); ++k) {
     (*sub_frame_view)[k] = rtc::ArrayView<float>(
-        &frame->split_bands_f(0)[k][sub_frame_index * kSubFrameLength],
+        &frame->split_bands(0)[k][sub_frame_index * kSubFrameLength],
         kSubFrameLength);
   }
 }
@@ -131,7 +131,7 @@
   RTC_DCHECK_EQ(num_bands, frame->size());
   RTC_DCHECK_EQ(frame_length, (*frame)[0].size());
   for (size_t k = 0; k < num_bands; ++k) {
-    rtc::ArrayView<float> buffer_view(&buffer->split_bands_f(0)[k][0],
+    rtc::ArrayView<float> buffer_view(&buffer->split_bands(0)[k][0],
                                       frame_length);
     std::copy(buffer_view.begin(), buffer_view.end(), (*frame)[k].begin());
   }
@@ -206,7 +206,7 @@
     return;
 
   data_dumper_->DumpWav("aec3_render_input", frame_length_,
-                        &input->split_bands_f(0)[0][0],
+                        &input->split_bands(0)[0][0],
                         LowestBandRate(sample_rate_hz_), 1);
 
   CopyBufferIntoFrame(input, num_bands_, frame_length_,
@@ -297,12 +297,12 @@
   RTC_DCHECK_RUNS_SERIALIZED(&capture_race_checker_);
   RTC_DCHECK(capture);
   data_dumper_->DumpWav("aec3_capture_analyze_input", capture->num_frames(),
-                        capture->channels_f()[0], sample_rate_hz_, 1);
+                        capture->channels()[0], sample_rate_hz_, 1);
 
   saturated_microphone_signal_ = false;
   for (size_t k = 0; k < capture->num_channels(); ++k) {
     saturated_microphone_signal_ |=
-        DetectSaturation(rtc::ArrayView<const float>(capture->channels_f()[k],
+        DetectSaturation(rtc::ArrayView<const float>(capture->channels()[k],
                                                      capture->num_frames()));
     if (saturated_microphone_signal_) {
       break;
@@ -329,7 +329,7 @@
   }
 
   rtc::ArrayView<float> capture_lower_band =
-      rtc::ArrayView<float>(&capture->split_bands_f(0)[0][0], frame_length_);
+      rtc::ArrayView<float>(&capture->split_bands(0)[0][0], frame_length_);
 
   data_dumper_->DumpWav("aec3_capture_input", capture_lower_band,
                         LowestBandRate(sample_rate_hz_), 1);
@@ -356,7 +356,7 @@
       &output_framer_, block_processor_.get(), &block_);
 
   data_dumper_->DumpWav("aec3_capture_output", frame_length_,
-                        &capture->split_bands_f(0)[0][0],
+                        &capture->split_bands(0)[0][0],
                         LowestBandRate(sample_rate_hz_), 1);
 }
 
diff --git a/modules/audio_processing/aec3/echo_canceller3_unittest.cc b/modules/audio_processing/aec3/echo_canceller3_unittest.cc
index 6951597..fee3706 100644
--- a/modules/audio_processing/aec3/echo_canceller3_unittest.cc
+++ b/modules/audio_processing/aec3/echo_canceller3_unittest.cc
@@ -148,16 +148,16 @@
         num_bands_(NumBandsForRate(sample_rate_hz_)),
         frame_length_(sample_rate_hz_ == 8000 ? 80 : 160),
         fullband_frame_length_(rtc::CheckedDivExact(sample_rate_hz_, 100)),
-        capture_buffer_(fullband_frame_length_,
+        capture_buffer_(fullband_frame_length_ * 100,
                         1,
-                        fullband_frame_length_,
+                        fullband_frame_length_ * 100,
                         1,
-                        fullband_frame_length_),
-        render_buffer_(fullband_frame_length_,
+                        fullband_frame_length_ * 100),
+        render_buffer_(fullband_frame_length_ * 100,
                        1,
-                       fullband_frame_length_,
+                       fullband_frame_length_ * 100,
                        1,
-                       fullband_frame_length_) {}
+                       fullband_frame_length_ * 100) {}
 
   // Verifies that the capture data is properly received by the block processor
   // and that the processor data is properly passed to the EchoCanceller3
@@ -173,15 +173,15 @@
       aec3.AnalyzeCapture(&capture_buffer_);
       OptionalBandSplit();
       PopulateInputFrame(frame_length_, num_bands_, frame_index,
-                         &capture_buffer_.split_bands_f(0)[0], 0);
+                         &capture_buffer_.split_bands(0)[0], 0);
       PopulateInputFrame(frame_length_, frame_index,
-                         &render_buffer_.channels_f()[0][0], 0);
+                         &render_buffer_.channels()[0][0], 0);
 
       aec3.AnalyzeRender(&render_buffer_);
       aec3.ProcessCapture(&capture_buffer_, false);
       EXPECT_TRUE(VerifyOutputFrameBitexactness(
           frame_length_, num_bands_, frame_index,
-          &capture_buffer_.split_bands_f(0)[0], -64));
+          &capture_buffer_.split_bands(0)[0], -64));
     }
   }
 
@@ -198,15 +198,15 @@
       aec3.AnalyzeCapture(&capture_buffer_);
       OptionalBandSplit();
       PopulateInputFrame(frame_length_, num_bands_, frame_index,
-                         &capture_buffer_.split_bands_f(0)[0], 100);
+                         &capture_buffer_.split_bands(0)[0], 100);
       PopulateInputFrame(frame_length_, num_bands_, frame_index,
-                         &render_buffer_.split_bands_f(0)[0], 0);
+                         &render_buffer_.split_bands(0)[0], 0);
 
       aec3.AnalyzeRender(&render_buffer_);
       aec3.ProcessCapture(&capture_buffer_, false);
       EXPECT_TRUE(VerifyOutputFrameBitexactness(
           frame_length_, num_bands_, frame_index,
-          &capture_buffer_.split_bands_f(0)[0], -64));
+          &capture_buffer_.split_bands(0)[0], -64));
     }
   }
 
@@ -276,9 +276,9 @@
       OptionalBandSplit();
 
       PopulateInputFrame(frame_length_, num_bands_, frame_index,
-                         &capture_buffer_.split_bands_f(0)[0], 0);
+                         &capture_buffer_.split_bands(0)[0], 0);
       PopulateInputFrame(frame_length_, frame_index,
-                         &render_buffer_.channels_f()[0][0], 0);
+                         &render_buffer_.channels()[0][0], 0);
 
       aec3.AnalyzeRender(&render_buffer_);
       aec3.ProcessCapture(&capture_buffer_, echo_path_change);
@@ -366,9 +366,9 @@
       OptionalBandSplit();
 
       PopulateInputFrame(frame_length_, num_bands_, frame_index,
-                         &capture_buffer_.split_bands_f(0)[0], 0);
+                         &capture_buffer_.split_bands(0)[0], 0);
       PopulateInputFrame(frame_length_, frame_index,
-                         &render_buffer_.channels_f()[0][0], 0);
+                         &render_buffer_.channels()[0][0], 0);
 
       aec3.AnalyzeRender(&render_buffer_);
       aec3.ProcessCapture(&capture_buffer_, false);
@@ -429,19 +429,19 @@
     for (size_t frame_index = 0; frame_index < kNumFramesToProcess;
          ++frame_index) {
       for (int k = 0; k < fullband_frame_length_; ++k) {
-        capture_buffer_.channels_f()[0][k] = 0.f;
+        capture_buffer_.channels()[0][k] = 0.f;
       }
       switch (saturation_variant) {
         case SaturationTestVariant::kNone:
           break;
         case SaturationTestVariant::kOneNegative:
           if (frame_index == 0) {
-            capture_buffer_.channels_f()[0][10] = -32768.f;
+            capture_buffer_.channels()[0][10] = -32768.f;
           }
           break;
         case SaturationTestVariant::kOnePositive:
           if (frame_index == 0) {
-            capture_buffer_.channels_f()[0][10] = 32767.f;
+            capture_buffer_.channels()[0][10] = 32767.f;
           }
           break;
       }
@@ -450,9 +450,9 @@
       OptionalBandSplit();
 
       PopulateInputFrame(frame_length_, num_bands_, frame_index,
-                         &capture_buffer_.split_bands_f(0)[0], 0);
+                         &capture_buffer_.split_bands(0)[0], 0);
       PopulateInputFrame(frame_length_, num_bands_, frame_index,
-                         &render_buffer_.split_bands_f(0)[0], 0);
+                         &render_buffer_.split_bands(0)[0], 0);
 
       aec3.AnalyzeRender(&render_buffer_);
       aec3.ProcessCapture(&capture_buffer_, false);
@@ -474,7 +474,7 @@
         render_buffer_.SplitIntoFrequencyBands();
       }
       PopulateInputFrame(frame_length_, num_bands_, frame_index,
-                         &render_buffer_.split_bands_f(0)[0], 0);
+                         &render_buffer_.split_bands(0)[0], 0);
 
       if (sample_rate_hz_ > 16000) {
         render_buffer_.SplitIntoFrequencyBands();
@@ -491,12 +491,12 @@
       }
 
       PopulateInputFrame(frame_length_, num_bands_, frame_index,
-                         &capture_buffer_.split_bands_f(0)[0], 0);
+                         &capture_buffer_.split_bands(0)[0], 0);
 
       aec3.ProcessCapture(&capture_buffer_, false);
       EXPECT_TRUE(VerifyOutputFrameBitexactness(
           frame_length_, num_bands_, frame_index,
-          &capture_buffer_.split_bands_f(0)[0], -64));
+          &capture_buffer_.split_bands(0)[0], -64));
     }
   }
 
@@ -513,7 +513,7 @@
           render_buffer_.SplitIntoFrequencyBands();
         }
         PopulateInputFrame(frame_length_, frame_index,
-                           &render_buffer_.channels_f()[0][0], 0);
+                           &render_buffer_.channels()[0][0], 0);
 
         if (k == 0) {
           aec3.AnalyzeRender(&render_buffer_);
diff --git a/modules/audio_processing/audio_buffer.cc b/modules/audio_processing/audio_buffer.cc
index 32668fa..e1d5b3a 100644
--- a/modules/audio_processing/audio_buffer.cc
+++ b/modules/audio_processing/audio_buffer.cc
@@ -23,183 +23,169 @@
 namespace webrtc {
 namespace {
 
-const size_t kSamplesPer16kHzChannel = 160;
-const size_t kSamplesPer32kHzChannel = 320;
-const size_t kSamplesPer48kHzChannel = 480;
+constexpr size_t kSamplesPer32kHzChannel = 320;
+constexpr size_t kSamplesPer48kHzChannel = 480;
+constexpr size_t kSamplesPer192kHzChannel = 1920;
+constexpr size_t kMaxSamplesPerChannel = kSamplesPer192kHzChannel;
 
-size_t NumBandsFromSamplesPerChannel(size_t num_frames) {
-  size_t num_bands = 1;
-  if (num_frames == kSamplesPer32kHzChannel ||
-      num_frames == kSamplesPer48kHzChannel) {
-    num_bands = rtc::CheckedDivExact(num_frames, kSamplesPer16kHzChannel);
+size_t NumBandsFromFramesPerChannel(size_t num_frames) {
+  if (num_frames == kSamplesPer32kHzChannel) {
+    return 2;
   }
-  return num_bands;
+  if (num_frames == kSamplesPer48kHzChannel) {
+    return 3;
+  }
+  return 1;
 }
 
 }  // namespace
 
-AudioBuffer::AudioBuffer(size_t input_num_frames,
-                         size_t num_input_channels,
-                         size_t process_num_frames,
-                         size_t num_process_channels,
-                         size_t output_num_frames)
-    : input_num_frames_(input_num_frames),
-      num_input_channels_(num_input_channels),
-      proc_num_frames_(process_num_frames),
-      num_proc_channels_(num_process_channels),
-      output_num_frames_(output_num_frames),
-      num_channels_(num_process_channels),
-      num_bands_(NumBandsFromSamplesPerChannel(proc_num_frames_)),
-      num_split_frames_(rtc::CheckedDivExact(proc_num_frames_, num_bands_)),
-      data_(new IFChannelBuffer(proc_num_frames_, num_proc_channels_)),
-      output_buffer_(new IFChannelBuffer(output_num_frames_, num_channels_)) {
+AudioBuffer::AudioBuffer(size_t input_rate,
+                         size_t input_num_channels,
+                         size_t buffer_rate,
+                         size_t buffer_num_channels,
+                         size_t output_rate)
+    : input_num_frames_(
+          rtc::CheckedDivExact(static_cast<int>(input_rate), 100)),
+      input_num_channels_(input_num_channels),
+      buffer_num_frames_(
+          rtc::CheckedDivExact(static_cast<int>(buffer_rate), 100)),
+      buffer_num_channels_(buffer_num_channels),
+      output_num_frames_(
+          rtc::CheckedDivExact(static_cast<int>(output_rate), 100)),
+      num_channels_(buffer_num_channels),
+      num_bands_(NumBandsFromFramesPerChannel(buffer_num_frames_)),
+      num_split_frames_(rtc::CheckedDivExact(buffer_num_frames_, num_bands_)),
+      data_(new ChannelBuffer<float>(buffer_num_frames_, buffer_num_channels_)),
+      output_buffer_(
+          new ChannelBuffer<float>(output_num_frames_, num_channels_)) {
   RTC_DCHECK_GT(input_num_frames_, 0);
-  RTC_DCHECK_GT(proc_num_frames_, 0);
+  RTC_DCHECK_GT(buffer_num_frames_, 0);
   RTC_DCHECK_GT(output_num_frames_, 0);
-  RTC_DCHECK_GT(num_input_channels_, 0);
-  RTC_DCHECK_GT(num_proc_channels_, 0);
-  RTC_DCHECK_LE(num_proc_channels_, num_input_channels_);
+  RTC_DCHECK_GT(input_num_channels_, 0);
+  RTC_DCHECK_GT(buffer_num_channels_, 0);
+  RTC_DCHECK_LE(buffer_num_channels_, input_num_channels_);
 
-  if (input_num_frames_ != proc_num_frames_ ||
-      output_num_frames_ != proc_num_frames_) {
-    // Create an intermediate buffer for resampling.
-    process_buffer_.reset(
-        new ChannelBuffer<float>(proc_num_frames_, num_proc_channels_));
-
-    if (input_num_frames_ != proc_num_frames_) {
-      for (size_t i = 0; i < num_proc_channels_; ++i) {
-        input_resamplers_.push_back(std::unique_ptr<PushSincResampler>(
-            new PushSincResampler(input_num_frames_, proc_num_frames_)));
-      }
+  const bool input_resampling_needed = input_num_frames_ != buffer_num_frames_;
+  const bool output_resampling_needed =
+      output_num_frames_ != buffer_num_frames_;
+  if (input_resampling_needed) {
+    for (size_t i = 0; i < buffer_num_channels_; ++i) {
+      input_resamplers_.push_back(std::unique_ptr<PushSincResampler>(
+          new PushSincResampler(input_num_frames_, buffer_num_frames_)));
     }
+  }
 
-    if (output_num_frames_ != proc_num_frames_) {
-      for (size_t i = 0; i < num_proc_channels_; ++i) {
-        output_resamplers_.push_back(std::unique_ptr<PushSincResampler>(
-            new PushSincResampler(proc_num_frames_, output_num_frames_)));
-      }
+  if (output_resampling_needed) {
+    for (size_t i = 0; i < buffer_num_channels_; ++i) {
+      output_resamplers_.push_back(std::unique_ptr<PushSincResampler>(
+          new PushSincResampler(buffer_num_frames_, output_num_frames_)));
     }
   }
 
   if (num_bands_ > 1) {
-    split_data_.reset(
-        new IFChannelBuffer(proc_num_frames_, num_proc_channels_, num_bands_));
-    splitting_filter_.reset(
-        new SplittingFilter(num_proc_channels_, num_bands_, proc_num_frames_));
+    split_data_.reset(new ChannelBuffer<float>(
+        buffer_num_frames_, buffer_num_channels_, num_bands_));
+    splitting_filter_.reset(new SplittingFilter(
+        buffer_num_channels_, num_bands_, buffer_num_frames_));
   }
 }
 
 AudioBuffer::~AudioBuffer() {}
 
+void AudioBuffer::set_downmixing_to_specific_channel(size_t channel) {
+  downmix_by_averaging_ = false;
+  RTC_DCHECK_GT(input_num_channels_, channel);
+  channel_for_downmixing_ = std::min(channel, input_num_channels_ - 1);
+}
+
+void AudioBuffer::set_downmixing_by_averaging() {
+  downmix_by_averaging_ = true;
+}
+
 void AudioBuffer::CopyFrom(const float* const* data,
                            const StreamConfig& stream_config) {
   RTC_DCHECK_EQ(stream_config.num_frames(), input_num_frames_);
-  RTC_DCHECK_EQ(stream_config.num_channels(), num_input_channels_);
-  InitForNewData();
-  // Initialized lazily because there's a different condition in
-  // DeinterleaveFrom.
-  const bool need_to_downmix =
-      num_input_channels_ > 1 && num_proc_channels_ == 1;
-  if (need_to_downmix && !input_buffer_) {
-    input_buffer_.reset(
-        new IFChannelBuffer(input_num_frames_, num_proc_channels_));
-  }
+  RTC_DCHECK_EQ(stream_config.num_channels(), input_num_channels_);
+  RestoreNumChannels();
+  const bool downmix_needed = input_num_channels_ > 1 && num_channels_ == 1;
 
-  // Downmix.
-  const float* const* data_ptr = data;
-  if (need_to_downmix) {
-    DownmixToMono<float, float>(data, input_num_frames_, num_input_channels_,
-                                input_buffer_->fbuf()->channels()[0]);
-    data_ptr = input_buffer_->fbuf_const()->channels();
-  }
+  const bool resampling_needed = input_num_frames_ != buffer_num_frames_;
 
-  // Resample.
-  if (input_num_frames_ != proc_num_frames_) {
-    for (size_t i = 0; i < num_proc_channels_; ++i) {
-      input_resamplers_[i]->Resample(data_ptr[i], input_num_frames_,
-                                     process_buffer_->channels()[i],
-                                     proc_num_frames_);
+  if (downmix_needed) {
+    RTC_DCHECK_GT(kMaxSamplesPerChannel, input_num_frames_);
+
+    std::array<float, kMaxSamplesPerChannel> downmix;
+    if (downmix_by_averaging_) {
+      const float kOneByNumChannels = 1.f / input_num_channels_;
+      for (size_t i = 0; i < input_num_frames_; ++i) {
+        float value = data[0][i];
+        for (size_t j = 1; j < input_num_channels_; ++j) {
+          value += data[j][i];
+        }
+        downmix[i] = value * kOneByNumChannels;
+      }
     }
-    data_ptr = process_buffer_->channels();
-  }
+    const float* downmixed_data =
+        downmix_by_averaging_ ? downmix.data() : data[channel_for_downmixing_];
 
-  // Convert to the S16 range.
-  for (size_t i = 0; i < num_proc_channels_; ++i) {
-    FloatToFloatS16(data_ptr[i], proc_num_frames_,
-                    data_->fbuf()->channels()[i]);
+    if (resampling_needed) {
+      input_resamplers_[0]->Resample(downmixed_data, input_num_frames_,
+                                     data_->channels()[0], buffer_num_frames_);
+    }
+    const float* data_to_convert =
+        resampling_needed ? data_->channels()[0] : downmixed_data;
+    FloatToFloatS16(data_to_convert, buffer_num_frames_, data_->channels()[0]);
+  } else {
+    if (resampling_needed) {
+      for (size_t i = 0; i < num_channels_; ++i) {
+        input_resamplers_[i]->Resample(data[i], input_num_frames_,
+                                       data_->channels()[i],
+                                       buffer_num_frames_);
+        FloatToFloatS16(data_->channels()[i], buffer_num_frames_,
+                        data_->channels()[i]);
+      }
+    } else {
+      for (size_t i = 0; i < num_channels_; ++i) {
+        FloatToFloatS16(data[i], buffer_num_frames_, data_->channels()[i]);
+      }
+    }
   }
 }
 
 void AudioBuffer::CopyTo(const StreamConfig& stream_config,
                          float* const* data) {
   RTC_DCHECK_EQ(stream_config.num_frames(), output_num_frames_);
-  RTC_DCHECK(stream_config.num_channels() == num_channels_ ||
-             num_channels_ == 1);
 
-  // Convert to the float range.
-  float* const* data_ptr = data;
-  if (output_num_frames_ != proc_num_frames_) {
-    // Convert to an intermediate buffer for subsequent resampling.
-    data_ptr = process_buffer_->channels();
-  }
-  for (size_t i = 0; i < num_channels_; ++i) {
-    FloatS16ToFloat(data_->fbuf()->channels()[i], proc_num_frames_,
-                    data_ptr[i]);
-  }
-
-  // Resample.
-  if (output_num_frames_ != proc_num_frames_) {
+  const bool resampling_needed = output_num_frames_ != buffer_num_frames_;
+  if (resampling_needed) {
     for (size_t i = 0; i < num_channels_; ++i) {
-      output_resamplers_[i]->Resample(data_ptr[i], proc_num_frames_, data[i],
-                                      output_num_frames_);
+      FloatS16ToFloat(data_->channels()[i], buffer_num_frames_,
+                      data_->channels()[i]);
+      output_resamplers_[i]->Resample(data_->channels()[i], buffer_num_frames_,
+                                      data[i], output_num_frames_);
+    }
+  } else {
+    for (size_t i = 0; i < num_channels_; ++i) {
+      FloatS16ToFloat(data_->channels()[i], buffer_num_frames_, data[i]);
     }
   }
 
-  // Upmix.
   for (size_t i = num_channels_; i < stream_config.num_channels(); ++i) {
     memcpy(data[i], data[0], output_num_frames_ * sizeof(**data));
   }
 }
 
-void AudioBuffer::InitForNewData() {
-  num_channels_ = num_proc_channels_;
-  data_->set_num_channels(num_proc_channels_);
+void AudioBuffer::RestoreNumChannels() {
+  num_channels_ = buffer_num_channels_;
+  data_->set_num_channels(buffer_num_channels_);
   if (split_data_.get()) {
-    split_data_->set_num_channels(num_proc_channels_);
+    split_data_->set_num_channels(buffer_num_channels_);
   }
 }
 
-const float* const* AudioBuffer::split_channels_const_f(Band band) const {
-  if (split_data_.get()) {
-    return split_data_->fbuf_const()->channels(band);
-  } else {
-    return band == kBand0To8kHz ? data_->fbuf_const()->channels() : nullptr;
-  }
-}
-
-const float* const* AudioBuffer::channels_const_f() const {
-  return data_->fbuf_const()->channels();
-}
-
-float* const* AudioBuffer::channels_f() {
-  return data_->fbuf()->channels();
-}
-
-const float* const* AudioBuffer::split_bands_const_f(size_t channel) const {
-  return split_data_.get() ? split_data_->fbuf_const()->bands(channel)
-                           : data_->fbuf_const()->bands(channel);
-}
-
-float* const* AudioBuffer::split_bands_f(size_t channel) {
-  return split_data_.get() ? split_data_->fbuf()->bands(channel)
-                           : data_->fbuf()->bands(channel);
-}
-
-size_t AudioBuffer::num_channels() const {
-  return num_channels_;
-}
-
 void AudioBuffer::set_num_channels(size_t num_channels) {
+  RTC_DCHECK_GE(buffer_num_channels_, num_channels);
   num_channels_ = num_channels;
   data_->set_num_channels(num_channels);
   if (split_data_.get()) {
@@ -207,78 +193,140 @@
   }
 }
 
-size_t AudioBuffer::num_frames() const {
-  return proc_num_frames_;
-}
-
-size_t AudioBuffer::num_frames_per_band() const {
-  return num_split_frames_;
-}
-
-size_t AudioBuffer::num_bands() const {
-  return num_bands_;
-}
-
 // The resampler is only for supporting 48kHz to 16kHz in the reverse stream.
-void AudioBuffer::DeinterleaveFrom(const AudioFrame* frame) {
-  RTC_DCHECK_EQ(frame->num_channels_, num_input_channels_);
+void AudioBuffer::CopyFrom(const AudioFrame* frame) {
+  RTC_DCHECK_EQ(frame->num_channels_, input_num_channels_);
   RTC_DCHECK_EQ(frame->samples_per_channel_, input_num_frames_);
-  InitForNewData();
-  // Initialized lazily because there's a different condition in CopyFrom.
-  if ((input_num_frames_ != proc_num_frames_) && !input_buffer_) {
-    input_buffer_.reset(
-        new IFChannelBuffer(input_num_frames_, num_proc_channels_));
-  }
+  RestoreNumChannels();
 
-  int16_t* const* deinterleaved;
-  if (input_num_frames_ == proc_num_frames_) {
-    deinterleaved = data_->ibuf()->channels();
-  } else {
-    deinterleaved = input_buffer_->ibuf()->channels();
-  }
-  // TODO(yujo): handle muted frames more efficiently.
-  if (num_proc_channels_ == 1) {
-    // Downmix and deinterleave simultaneously.
-    DownmixInterleavedToMono(frame->data(), input_num_frames_,
-                             num_input_channels_, deinterleaved[0]);
-  } else {
-    RTC_DCHECK_EQ(num_proc_channels_, num_input_channels_);
-    Deinterleave(frame->data(), input_num_frames_, num_proc_channels_,
-                 deinterleaved);
-  }
+  const bool resampling_required = input_num_frames_ != buffer_num_frames_;
 
-  // Resample.
-  if (input_num_frames_ != proc_num_frames_) {
-    for (size_t i = 0; i < num_proc_channels_; ++i) {
-      input_resamplers_[i]->Resample(
-          input_buffer_->fbuf_const()->channels()[i], input_num_frames_,
-          data_->fbuf()->channels()[i], proc_num_frames_);
+  const int16_t* interleaved = frame->data();
+  if (num_channels_ == 1) {
+    if (input_num_channels_ == 1) {
+      if (resampling_required) {
+        std::array<float, kMaxSamplesPerChannel> float_buffer;
+        S16ToFloatS16(interleaved, input_num_frames_, float_buffer.data());
+        input_resamplers_[0]->Resample(float_buffer.data(), input_num_frames_,
+                                       data_->channels()[0],
+                                       buffer_num_frames_);
+      } else {
+        S16ToFloatS16(interleaved, input_num_frames_, data_->channels()[0]);
+      }
+    } else {
+      std::array<float, kMaxSamplesPerChannel> float_buffer;
+      float* downmixed_data =
+          resampling_required ? float_buffer.data() : data_->channels()[0];
+      if (downmix_by_averaging_) {
+        for (size_t j = 0, k = 0; j < input_num_frames_; ++j) {
+          int32_t sum = 0;
+          for (size_t i = 0; i < input_num_channels_; ++i, ++k) {
+            sum += interleaved[k];
+          }
+          downmixed_data[j] = sum / static_cast<int16_t>(input_num_channels_);
+        }
+      } else {
+        for (size_t j = 0, k = channel_for_downmixing_; j < input_num_frames_;
+             ++j, k += input_num_channels_) {
+          downmixed_data[j] = interleaved[k];
+        }
+      }
+
+      if (resampling_required) {
+        input_resamplers_[0]->Resample(downmixed_data, input_num_frames_,
+                                       data_->channels()[0],
+                                       buffer_num_frames_);
+      }
+    }
+  } else {
+    auto deinterleave_channel = [](size_t channel, size_t num_channels,
+                                   size_t samples_per_channel, const int16_t* x,
+                                   float* y) {
+      for (size_t j = 0, k = channel; j < samples_per_channel;
+           ++j, k += num_channels) {
+        y[j] = x[k];
+      }
+    };
+
+    if (resampling_required) {
+      std::array<float, kMaxSamplesPerChannel> float_buffer;
+      for (size_t i = 0; i < num_channels_; ++i) {
+        deinterleave_channel(i, num_channels_, input_num_frames_, interleaved,
+                             float_buffer.data());
+        input_resamplers_[i]->Resample(float_buffer.data(), input_num_frames_,
+                                       data_->channels()[i],
+                                       buffer_num_frames_);
+      }
+    } else {
+      for (size_t i = 0; i < num_channels_; ++i) {
+        deinterleave_channel(i, num_channels_, input_num_frames_, interleaved,
+                             data_->channels()[i]);
+      }
     }
   }
 }
 
-void AudioBuffer::InterleaveTo(AudioFrame* frame) const {
+void AudioBuffer::CopyTo(AudioFrame* frame) const {
   RTC_DCHECK(frame->num_channels_ == num_channels_ || num_channels_ == 1);
   RTC_DCHECK_EQ(frame->samples_per_channel_, output_num_frames_);
 
-  // Resample if necessary.
-  IFChannelBuffer* data_ptr = data_.get();
-  if (proc_num_frames_ != output_num_frames_) {
-    for (size_t i = 0; i < num_channels_; ++i) {
-      output_resamplers_[i]->Resample(
-          data_->fbuf()->channels()[i], proc_num_frames_,
-          output_buffer_->fbuf()->channels()[i], output_num_frames_);
-    }
-    data_ptr = output_buffer_.get();
-  }
+  const bool resampling_required = buffer_num_frames_ != output_num_frames_;
 
-  // TODO(yujo): handle muted frames more efficiently.
-  if (frame->num_channels_ == num_channels_) {
-    Interleave(data_ptr->ibuf()->channels(), output_num_frames_, num_channels_,
-               frame->mutable_data());
+  int16_t* interleaved = frame->mutable_data();
+  if (num_channels_ == 1) {
+    std::array<float, kMaxSamplesPerChannel> float_buffer;
+
+    if (resampling_required) {
+      output_resamplers_[0]->Resample(data_->channels()[0], buffer_num_frames_,
+                                      float_buffer.data(), output_num_frames_);
+    }
+    const float* deinterleaved =
+        resampling_required ? float_buffer.data() : data_->channels()[0];
+
+    if (frame->num_channels_ == 1) {
+      for (size_t j = 0; j < output_num_frames_; ++j) {
+        interleaved[j] = FloatS16ToS16(deinterleaved[j]);
+      }
+    } else {
+      for (size_t i = 0, k = 0; i < output_num_frames_; ++i) {
+        float tmp = FloatS16ToS16(deinterleaved[i]);
+        for (size_t j = 0; j < frame->num_channels_; ++j, ++k) {
+          interleaved[k] = tmp;
+        }
+      }
+    }
   } else {
-    UpmixMonoToInterleaved(data_ptr->ibuf()->channels()[0], output_num_frames_,
-                           frame->num_channels_, frame->mutable_data());
+    auto interleave_channel = [](size_t channel, size_t num_channels,
+                                 size_t samples_per_channel, const float* x,
+                                 int16_t* y) {
+      for (size_t k = 0, j = channel; k < samples_per_channel;
+           ++k, j += num_channels) {
+        y[j] = FloatS16ToS16(x[k]);
+      }
+    };
+
+    if (resampling_required) {
+      for (size_t i = 0; i < num_channels_; ++i) {
+        std::array<float, kMaxSamplesPerChannel> float_buffer;
+        output_resamplers_[i]->Resample(data_->channels()[i],
+                                        buffer_num_frames_, float_buffer.data(),
+                                        output_num_frames_);
+        interleave_channel(i, frame->num_channels_, output_num_frames_,
+                           float_buffer.data(), interleaved);
+      }
+    } else {
+      for (size_t i = 0; i < num_channels_; ++i) {
+        interleave_channel(i, frame->num_channels_, output_num_frames_,
+                           data_->channels()[i], interleaved);
+      }
+    }
+
+    for (size_t i = num_channels_; i < frame->num_channels_; ++i) {
+      for (size_t j = 0, k = i, n = num_channels_; j < output_num_frames_;
+           ++j, k += frame->num_channels_, n += frame->num_channels_) {
+        interleaved[k] = interleaved[n];
+      }
+    }
   }
 }
 
@@ -290,10 +338,11 @@
   splitting_filter_->Synthesis(split_data_.get(), data_.get());
 }
 
-void AudioBuffer::CopySplitChannelDataTo(size_t channel,
+void AudioBuffer::ExportSplitChannelData(size_t channel,
                                          int16_t* const* split_band_data) {
   for (size_t k = 0; k < num_bands(); ++k) {
-    const float* band_data = split_bands_f(channel)[k];
+    const float* band_data = split_bands(channel)[k];
+
     RTC_DCHECK(split_band_data[k]);
     RTC_DCHECK(band_data);
     for (size_t i = 0; i < num_frames_per_band(); ++i) {
@@ -302,11 +351,11 @@
   }
 }
 
-void AudioBuffer::CopySplitChannelDataFrom(
+void AudioBuffer::ImportSplitChannelData(
     size_t channel,
     const int16_t* const* split_band_data) {
   for (size_t k = 0; k < num_bands(); ++k) {
-    float* band_data = split_bands_f(channel)[k];
+    float* band_data = split_bands(channel)[k];
     RTC_DCHECK(split_band_data[k]);
     RTC_DCHECK(band_data);
     for (size_t i = 0; i < num_frames_per_band(); ++i) {
diff --git a/modules/audio_processing/audio_buffer.h b/modules/audio_processing/audio_buffer.h
index 16d5616..dd9b768 100644
--- a/modules/audio_processing/audio_buffer.h
+++ b/modules/audio_processing/audio_buffer.h
@@ -23,114 +23,142 @@
 
 namespace webrtc {
 
-class IFChannelBuffer;
 class PushSincResampler;
 class SplittingFilter;
 
 enum Band { kBand0To8kHz = 0, kBand8To16kHz = 1, kBand16To24kHz = 2 };
 
+// Stores any audio data in a way that allows the audio processing module to
+// operate on it in a controlled manner.
 class AudioBuffer {
  public:
-  // TODO(ajm): Switch to take ChannelLayouts.
-  AudioBuffer(size_t input_num_frames,
-              size_t num_input_channels,
-              size_t process_num_frames,
-              size_t num_process_channels,
-              size_t output_num_frames);
+  AudioBuffer(size_t input_rate,
+              size_t input_num_channels,
+              size_t buffer_rate,
+              size_t buffer_num_channels,
+              size_t output_rate);
   virtual ~AudioBuffer();
 
-  size_t num_channels() const;
-  size_t num_proc_channels() const { return num_proc_channels_; }
-  void set_num_channels(size_t num_channels);
-  size_t num_frames() const;
-  size_t num_frames_per_band() const;
-  size_t num_bands() const;
+  AudioBuffer(const AudioBuffer&) = delete;
+  AudioBuffer& operator=(const AudioBuffer&) = delete;
 
-  // Returns a pointer array to the full-band channels.
+  // Specify that downmixing should be done by selecting a single channel.
+  void set_downmixing_to_specific_channel(size_t channel);
+
+  // Specify that downmixing should be done by averaging all channels,.
+  void set_downmixing_by_averaging();
+
+  // Set the number of channels in the buffer. The specified number of channels
+  // cannot be larger than the specified buffer_num_channels. The number is also
+  // reset at each call to CopyFrom or InterleaveFrom.
+  void set_num_channels(size_t num_channels);
+
+  size_t num_channels() const { return num_channels_; }
+  size_t num_frames() const { return buffer_num_frames_; }
+  size_t num_frames_per_band() const { return num_split_frames_; }
+  size_t num_bands() const { return num_bands_; }
+
+  // Returns pointer arrays to the full-band channels.
   // Usage:
   // channels()[channel][sample].
   // Where:
-  // 0 <= channel < |num_proc_channels_|
-  // 0 <= sample < |proc_num_frames_|
-  float* const* channels_f();
-  const float* const* channels_const_f() const;
+  // 0 <= channel < |buffer_num_channels_|
+  // 0 <= sample < |buffer_num_frames_|
+  float* const* channels() { return data_->channels(); }
+  const float* const* channels_const() const { return data_->channels(); }
 
-  // Returns a pointer array to the bands for a specific channel.
+  // Returns pointer arrays to the bands for a specific channel.
   // Usage:
   // split_bands(channel)[band][sample].
   // Where:
-  // 0 <= channel < |num_proc_channels_|
+  // 0 <= channel < |buffer_num_channels_|
   // 0 <= band < |num_bands_|
   // 0 <= sample < |num_split_frames_|
-  float* const* split_bands_f(size_t channel);
-  const float* const* split_bands_const_f(size_t channel) const;
+  const float* const* split_bands_const(size_t channel) const {
+    return split_data_.get() ? split_data_->bands(channel)
+                             : data_->bands(channel);
+  }
+  float* const* split_bands(size_t channel) {
+    return split_data_.get() ? split_data_->bands(channel)
+                             : data_->bands(channel);
+  }
 
   // Returns a pointer array to the channels for a specific band.
   // Usage:
   // split_channels(band)[channel][sample].
   // Where:
   // 0 <= band < |num_bands_|
-  // 0 <= channel < |num_proc_channels_|
+  // 0 <= channel < |buffer_num_channels_|
   // 0 <= sample < |num_split_frames_|
-  const float* const* split_channels_const_f(Band band) const;
+  const float* const* split_channels_const(Band band) const {
+    if (split_data_.get()) {
+      return split_data_->channels(band);
+    } else {
+      return band == kBand0To8kHz ? data_->channels() : nullptr;
+    }
+  }
 
-  // Use for int16 interleaved data.
-  void DeinterleaveFrom(const AudioFrame* audioFrame);
-  // If |data_changed| is false, only the non-audio data members will be copied
-  // to |frame|.
-  void InterleaveTo(AudioFrame* frame) const;
-
-  // Use for float deinterleaved data.
+  // Copies data into the buffer.
+  void CopyFrom(const AudioFrame* frame);
   void CopyFrom(const float* const* data, const StreamConfig& stream_config);
+
+  // Copies data from the buffer.
+  void CopyTo(AudioFrame* frame) const;
   void CopyTo(const StreamConfig& stream_config, float* const* data);
 
-  // Splits the signal into different bands.
+  // Splits the buffer data into frequency bands.
   void SplitIntoFrequencyBands();
-  // Recombine the different bands into one signal.
+
+  // Recombines the frequency bands into a full-band signal.
   void MergeFrequencyBands();
 
   // Copies the split bands data into the integer two-dimensional array.
-  void CopySplitChannelDataTo(size_t channel, int16_t* const* split_band_data);
+  void ExportSplitChannelData(size_t channel, int16_t* const* split_band_data);
 
   // Copies the data in the integer two-dimensional array into the split_bands
   // data.
-  void CopySplitChannelDataFrom(size_t channel,
-                                const int16_t* const* split_band_data);
+  void ImportSplitChannelData(size_t channel,
+                              const int16_t* const* split_band_data);
 
   static const size_t kMaxSplitFrameLength = 160;
   static const size_t kMaxNumBands = 3;
 
+  // Deprecated methods, will be removed soon.
+  float* const* channels_f() { return channels(); }
+  const float* const* channels_const_f() const { return channels_const(); }
+  const float* const* split_bands_const_f(size_t channel) const {
+    return split_bands_const(channel);
+  }
+  float* const* split_bands_f(size_t channel) { return split_bands(channel); }
+  const float* const* split_channels_const_f(Band band) const {
+    return split_channels_const(band);
+  }
+  void DeinterleaveFrom(const AudioFrame* frame) { CopyFrom(frame); }
+  void InterleaveTo(AudioFrame* frame) const { CopyTo(frame); }
+
  private:
   FRIEND_TEST_ALL_PREFIXES(AudioBufferTest,
                            SetNumChannelsSetsChannelBuffersNumChannels);
-  // Called from DeinterleaveFrom() and CopyFrom().
-  void InitForNewData();
+  void RestoreNumChannels();
 
-  // The audio is passed into DeinterleaveFrom() or CopyFrom() with input
-  // format (samples per channel and number of channels).
   const size_t input_num_frames_;
-  const size_t num_input_channels_;
-  // The audio is stored by DeinterleaveFrom() or CopyFrom() with processing
-  // format.
-  const size_t proc_num_frames_;
-  const size_t num_proc_channels_;
-  // The audio is returned by InterleaveTo() and CopyTo() with output samples
-  // per channels and the current number of channels. This last one can be
-  // changed at any time using set_num_channels().
+  const size_t input_num_channels_;
+  const size_t buffer_num_frames_;
+  const size_t buffer_num_channels_;
   const size_t output_num_frames_;
-  size_t num_channels_;
 
+  size_t num_channels_;
   size_t num_bands_;
   size_t num_split_frames_;
 
-  std::unique_ptr<IFChannelBuffer> data_;
-  std::unique_ptr<IFChannelBuffer> split_data_;
+  std::unique_ptr<ChannelBuffer<float>> data_;
+  std::unique_ptr<ChannelBuffer<float>> split_data_;
   std::unique_ptr<SplittingFilter> splitting_filter_;
-  std::unique_ptr<IFChannelBuffer> input_buffer_;
-  std::unique_ptr<IFChannelBuffer> output_buffer_;
-  std::unique_ptr<ChannelBuffer<float>> process_buffer_;
+  std::unique_ptr<ChannelBuffer<float>> output_buffer_;
   std::vector<std::unique_ptr<PushSincResampler>> input_resamplers_;
   std::vector<std::unique_ptr<PushSincResampler>> output_resamplers_;
+  bool downmix_by_averaging_ = true;
+  size_t channel_for_downmixing_ = 0;
 };
 
 }  // namespace webrtc
diff --git a/modules/audio_processing/audio_buffer_unittest.cc b/modules/audio_processing/audio_buffer_unittest.cc
index b884799..f5ac88f 100644
--- a/modules/audio_processing/audio_buffer_unittest.cc
+++ b/modules/audio_processing/audio_buffer_unittest.cc
@@ -16,7 +16,7 @@
 
 namespace {
 
-const size_t kNumFrames = 480u;
+const size_t kSampleRateHz = 48000u;
 const size_t kStereo = 2u;
 const size_t kMono = 1u;
 
@@ -27,17 +27,17 @@
 }  // namespace
 
 TEST(AudioBufferTest, SetNumChannelsSetsChannelBuffersNumChannels) {
-  AudioBuffer ab(kNumFrames, kStereo, kNumFrames, kStereo, kNumFrames);
+  AudioBuffer ab(kSampleRateHz, kStereo, kSampleRateHz, kStereo, kSampleRateHz);
   ExpectNumChannels(ab, kStereo);
-  ab.set_num_channels(kMono);
+  ab.set_num_channels(1);
   ExpectNumChannels(ab, kMono);
-  ab.InitForNewData();
+  ab.RestoreNumChannels();
   ExpectNumChannels(ab, kStereo);
 }
 
 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
 TEST(AudioBufferTest, SetNumChannelsDeathTest) {
-  AudioBuffer ab(kNumFrames, kMono, kNumFrames, kMono, kNumFrames);
+  AudioBuffer ab(kSampleRateHz, kMono, kSampleRateHz, kMono, kSampleRateHz);
   EXPECT_DEATH(ab.set_num_channels(kStereo), "num_channels");
 }
 #endif
diff --git a/modules/audio_processing/audio_frame_view_unittest.cc b/modules/audio_processing/audio_frame_view_unittest.cc
index 70b63b1..1b8f8c0 100644
--- a/modules/audio_processing/audio_frame_view_unittest.cc
+++ b/modules/audio_processing/audio_frame_view_unittest.cc
@@ -21,18 +21,18 @@
   constexpr float kIntConstant = 17252;
   const webrtc::StreamConfig stream_config(kSampleRateHz, kNumChannels, false);
   webrtc::AudioBuffer buffer(
-      stream_config.num_frames(), stream_config.num_channels(),
-      stream_config.num_frames(), stream_config.num_channels(),
-      stream_config.num_frames());
+      stream_config.sample_rate_hz(), stream_config.num_channels(),
+      stream_config.sample_rate_hz(), stream_config.num_channels(),
+      stream_config.sample_rate_hz());
 
-  AudioFrameView<float> non_const_view(
-      buffer.channels_f(), buffer.num_channels(), buffer.num_frames());
+  AudioFrameView<float> non_const_view(buffer.channels(), buffer.num_channels(),
+                                       buffer.num_frames());
   // Modification is allowed.
   non_const_view.channel(0)[0] = kFloatConstant;
-  EXPECT_EQ(buffer.channels_f()[0][0], kFloatConstant);
+  EXPECT_EQ(buffer.channels()[0][0], kFloatConstant);
 
   AudioFrameView<const float> const_view(
-      buffer.channels_f(), buffer.num_channels(), buffer.num_frames());
+      buffer.channels(), buffer.num_channels(), buffer.num_frames());
   // Modification is not allowed.
   // const_view.channel(0)[0] = kFloatConstant;
 
@@ -44,8 +44,8 @@
   // non_const_view = other_const_view;
 
   AudioFrameView<float> non_const_float_view(
-      buffer.channels_f(), buffer.num_channels(), buffer.num_frames());
+      buffer.channels(), buffer.num_channels(), buffer.num_frames());
   non_const_float_view.channel(0)[0] = kIntConstant;
-  EXPECT_EQ(buffer.channels_f()[0][0], kIntConstant);
+  EXPECT_EQ(buffer.channels()[0][0], kIntConstant);
 }
 }  // namespace webrtc
diff --git a/modules/audio_processing/audio_processing_impl.cc b/modules/audio_processing/audio_processing_impl.cc
index fc463c1..7703870 100644
--- a/modules/audio_processing/audio_processing_impl.cc
+++ b/modules/audio_processing/audio_processing_impl.cc
@@ -498,17 +498,17 @@
 int AudioProcessingImpl::InitializeLocked() {
   UpdateActiveSubmoduleStates();
 
-  const int render_audiobuffer_num_output_frames =
+  const int render_audiobuffer_sample_rate_hz =
       formats_.api_format.reverse_output_stream().num_frames() == 0
-          ? formats_.render_processing_format.num_frames()
-          : formats_.api_format.reverse_output_stream().num_frames();
+          ? formats_.render_processing_format.sample_rate_hz()
+          : formats_.api_format.reverse_output_stream().sample_rate_hz();
   if (formats_.api_format.reverse_input_stream().num_channels() > 0) {
     render_.render_audio.reset(new AudioBuffer(
-        formats_.api_format.reverse_input_stream().num_frames(),
+        formats_.api_format.reverse_input_stream().sample_rate_hz(),
         formats_.api_format.reverse_input_stream().num_channels(),
-        formats_.render_processing_format.num_frames(),
+        formats_.render_processing_format.sample_rate_hz(),
         formats_.render_processing_format.num_channels(),
-        render_audiobuffer_num_output_frames));
+        render_audiobuffer_sample_rate_hz));
     if (formats_.api_format.reverse_input_stream() !=
         formats_.api_format.reverse_output_stream()) {
       render_.render_converter = AudioConverter::Create(
@@ -524,12 +524,12 @@
     render_.render_converter.reset(nullptr);
   }
 
-  capture_.capture_audio.reset(
-      new AudioBuffer(formats_.api_format.input_stream().num_frames(),
-                      formats_.api_format.input_stream().num_channels(),
-                      capture_nonlocked_.capture_processing_format.num_frames(),
-                      formats_.api_format.output_stream().num_channels(),
-                      formats_.api_format.output_stream().num_frames()));
+  capture_.capture_audio.reset(new AudioBuffer(
+      formats_.api_format.input_stream().sample_rate_hz(),
+      formats_.api_format.input_stream().num_channels(),
+      capture_nonlocked_.capture_processing_format.sample_rate_hz(),
+      formats_.api_format.output_stream().num_channels(),
+      formats_.api_format.output_stream().sample_rate_hz()));
 
   AllocateRenderQueue();
 
@@ -1245,11 +1245,11 @@
   }
 
   capture_.vad_activity = frame->vad_activity_;
-  capture_.capture_audio->DeinterleaveFrom(frame);
+  capture_.capture_audio->CopyFrom(frame);
   RETURN_ON_ERR(ProcessCaptureStreamLocked());
   if (submodule_states_.CaptureMultiBandProcessingActive() ||
       submodule_states_.CaptureFullBandProcessingActive()) {
-    capture_.capture_audio->InterleaveTo(frame);
+    capture_.capture_audio->CopyTo(frame);
   }
   frame->vad_activity_ = capture_.vad_activity;
 
@@ -1275,12 +1275,12 @@
 
   if (private_submodules_->pre_amplifier) {
     private_submodules_->pre_amplifier->ApplyGain(AudioFrameView<float>(
-        capture_buffer->channels_f(), capture_buffer->num_channels(),
+        capture_buffer->channels(), capture_buffer->num_channels(),
         capture_buffer->num_frames()));
   }
 
   capture_input_rms_.Analyze(rtc::ArrayView<const float>(
-      capture_buffer->channels_const_f()[0],
+      capture_buffer->channels_const()[0],
       capture_nonlocked_.capture_processing_format.num_frames()));
   const bool log_rms = ++capture_rms_interval_counter_ >= 1000;
   if (log_rms) {
@@ -1328,7 +1328,7 @@
 
     if (constants_.use_experimental_agc_process_before_aec) {
       private_submodules_->agc_manager->Process(
-          capture_buffer->channels_const_f()[0],
+          capture_buffer->channels_const()[0],
           capture_nonlocked_.capture_processing_format.num_frames(),
           capture_nonlocked_.capture_processing_format.sample_rate_hz());
     }
@@ -1437,7 +1437,7 @@
   if (config_.residual_echo_detector.enabled) {
     RTC_DCHECK(private_submodules_->echo_detector);
     private_submodules_->echo_detector->AnalyzeCaptureAudio(
-        rtc::ArrayView<const float>(capture_buffer->channels_f()[0],
+        rtc::ArrayView<const float>(capture_buffer->channels()[0],
                                     capture_buffer->num_frames()));
   }
 
@@ -1450,9 +1450,9 @@
             : 1.f;
 
     public_submodules_->transient_suppressor->Suppress(
-        capture_buffer->channels_f()[0], capture_buffer->num_frames(),
+        capture_buffer->channels()[0], capture_buffer->num_frames(),
         capture_buffer->num_channels(),
-        capture_buffer->split_bands_const_f(0)[kBand0To8kHz],
+        capture_buffer->split_bands_const(0)[kBand0To8kHz],
         capture_buffer->num_frames_per_band(),
         capture_.keyboard_info.keyboard_data,
         capture_.keyboard_info.num_keyboard_frames, voice_probability,
@@ -1475,9 +1475,9 @@
   }
 
   // The level estimator operates on the recombined data.
-  public_submodules_->level_estimator->ProcessStream(capture_buffer);
+  public_submodules_->level_estimator->ProcessStream(*capture_buffer);
   if (config_.level_estimation.enabled) {
-    private_submodules_->output_level_estimator->ProcessStream(capture_buffer);
+    private_submodules_->output_level_estimator->ProcessStream(*capture_buffer);
     capture_.stats.output_rms_dbfs =
         private_submodules_->output_level_estimator->RMS();
   } else {
@@ -1485,7 +1485,7 @@
   }
 
   capture_output_rms_.Analyze(rtc::ArrayView<const float>(
-      capture_buffer->channels_const_f()[0],
+      capture_buffer->channels_const()[0],
       capture_nonlocked_.capture_processing_format.num_frames()));
   if (log_rms) {
     RmsLevel::Levels levels = capture_output_rms_.AverageAndPeak();
@@ -1610,11 +1610,11 @@
     aec_dump_->WriteRenderStreamMessage(*frame);
   }
 
-  render_.render_audio->DeinterleaveFrom(frame);
+  render_.render_audio->CopyFrom(frame);
   RETURN_ON_ERR(ProcessRenderStreamLocked());
   if (submodule_states_.RenderMultiBandProcessingActive() ||
       submodule_states_.RenderFullBandProcessingActive()) {
-    render_.render_audio->InterleaveTo(frame);
+    render_.render_audio->CopyTo(frame);
   }
   return kNoError;
 }
diff --git a/modules/audio_processing/audio_processing_impl_unittest.cc b/modules/audio_processing/audio_processing_impl_unittest.cc
index d688db0..f6953ab 100644
--- a/modules/audio_processing/audio_processing_impl_unittest.cc
+++ b/modules/audio_processing/audio_processing_impl_unittest.cc
@@ -128,7 +128,7 @@
   void Initialize(int sample_rate_hz, int num_channels) override {}
   void Process(AudioBuffer* audio) override {
     for (size_t k = 0; k < audio->num_channels(); ++k) {
-      rtc::ArrayView<float> channel_view(audio->channels_f()[k],
+      rtc::ArrayView<float> channel_view(audio->channels()[k],
                                          audio->num_frames());
       std::transform(channel_view.begin(), channel_view.end(),
                      channel_view.begin(), ProcessSample);
diff --git a/modules/audio_processing/echo_cancellation_bit_exact_unittest.cc b/modules/audio_processing/echo_cancellation_bit_exact_unittest.cc
index d44483c..69870ff 100644
--- a/modules/audio_processing/echo_cancellation_bit_exact_unittest.cc
+++ b/modules/audio_processing/echo_cancellation_bit_exact_unittest.cc
@@ -80,16 +80,16 @@
   const int samples_per_channel = rtc::CheckedDivExact(sample_rate_hz, 100);
   const StreamConfig render_config(sample_rate_hz, num_channels, false);
   AudioBuffer render_buffer(
-      render_config.num_frames(), render_config.num_channels(),
-      render_config.num_frames(), 1, render_config.num_frames());
+      render_config.sample_rate_hz(), render_config.num_channels(),
+      render_config.sample_rate_hz(), 1, render_config.sample_rate_hz());
   test::InputAudioFile render_file(
       test::GetApmRenderTestVectorFileName(sample_rate_hz));
   std::vector<float> render_input(samples_per_channel * num_channels);
 
   const StreamConfig capture_config(sample_rate_hz, num_channels, false);
   AudioBuffer capture_buffer(
-      capture_config.num_frames(), capture_config.num_channels(),
-      capture_config.num_frames(), 1, capture_config.num_frames());
+      capture_config.sample_rate_hz(), capture_config.num_channels(),
+      capture_config.sample_rate_hz(), 1, capture_config.sample_rate_hz());
   test::InputAudioFile capture_file(
       test::GetApmCaptureTestVectorFileName(sample_rate_hz));
   std::vector<float> capture_input(samples_per_channel * num_channels);
diff --git a/modules/audio_processing/echo_cancellation_impl.cc b/modules/audio_processing/echo_cancellation_impl.cc
index 21ba177..25e8d70 100644
--- a/modules/audio_processing/echo_cancellation_impl.cc
+++ b/modules/audio_processing/echo_cancellation_impl.cc
@@ -157,11 +157,11 @@
   stream_has_echo_ = false;
   for (size_t i = 0; i < audio->num_channels(); i++) {
     for (size_t j = 0; j < stream_properties_->num_reverse_channels; j++) {
-      err = WebRtcAec_Process(cancellers_[handle_index]->state(),
-                              audio->split_bands_const_f(i), audio->num_bands(),
-                              audio->split_bands_f(i),
-                              audio->num_frames_per_band(), stream_delay_ms_use,
-                              stream_drift_samples_);
+      err =
+          WebRtcAec_Process(cancellers_[handle_index]->state(),
+                            audio->split_bands_const(i), audio->num_bands(),
+                            audio->split_bands(i), audio->num_frames_per_band(),
+                            stream_delay_ms_use, stream_drift_samples_);
 
       if (err != AudioProcessing::kNoError) {
         err = MapError(err);
@@ -383,8 +383,8 @@
     for (size_t j = 0; j < audio->num_channels(); j++) {
       // Buffer the samples in the render queue.
       packed_buffer->insert(packed_buffer->end(),
-                            audio->split_bands_const_f(j)[kBand0To8kHz],
-                            (audio->split_bands_const_f(j)[kBand0To8kHz] +
+                            audio->split_bands_const(j)[kBand0To8kHz],
+                            (audio->split_bands_const(j)[kBand0To8kHz] +
                              audio->num_frames_per_band()));
     }
   }
diff --git a/modules/audio_processing/echo_control_mobile_bit_exact_unittest.cc b/modules/audio_processing/echo_control_mobile_bit_exact_unittest.cc
index 510eda4..a4f4463 100644
--- a/modules/audio_processing/echo_control_mobile_bit_exact_unittest.cc
+++ b/modules/audio_processing/echo_control_mobile_bit_exact_unittest.cc
@@ -70,16 +70,16 @@
   const int samples_per_channel = rtc::CheckedDivExact(sample_rate_hz, 100);
   const StreamConfig render_config(sample_rate_hz, num_channels, false);
   AudioBuffer render_buffer(
-      render_config.num_frames(), render_config.num_channels(),
-      render_config.num_frames(), 1, render_config.num_frames());
+      render_config.sample_rate_hz(), render_config.num_channels(),
+      render_config.sample_rate_hz(), 1, render_config.sample_rate_hz());
   test::InputAudioFile render_file(
       test::GetApmRenderTestVectorFileName(sample_rate_hz));
   std::vector<float> render_input(samples_per_channel * num_channels);
 
   const StreamConfig capture_config(sample_rate_hz, num_channels, false);
   AudioBuffer capture_buffer(
-      capture_config.num_frames(), capture_config.num_channels(),
-      capture_config.num_frames(), 1, capture_config.num_frames());
+      capture_config.sample_rate_hz(), capture_config.num_channels(),
+      capture_config.sample_rate_hz(), 1, capture_config.sample_rate_hz());
   test::InputAudioFile capture_file(
       test::GetApmCaptureTestVectorFileName(sample_rate_hz));
   std::vector<float> capture_input(samples_per_channel * num_channels);
diff --git a/modules/audio_processing/echo_control_mobile_impl.cc b/modules/audio_processing/echo_control_mobile_impl.cc
index 982287b..8057e33 100644
--- a/modules/audio_processing/echo_control_mobile_impl.cc
+++ b/modules/audio_processing/echo_control_mobile_impl.cc
@@ -142,7 +142,7 @@
   for (size_t i = 0; i < num_output_channels; i++) {
     for (size_t j = 0; j < audio->num_channels(); j++) {
       std::array<int16_t, AudioBuffer::kMaxSplitFrameLength> data_to_buffer;
-      FloatS16ToS16(audio->split_bands_const_f(render_channel)[kBand0To8kHz],
+      FloatS16ToS16(audio->split_bands_const(render_channel)[kBand0To8kHz],
                     audio->num_frames_per_band(), data_to_buffer.data());
 
       // Buffer the samples in the render queue.
@@ -185,8 +185,8 @@
     std::array<int16_t, AudioBuffer::kMaxSplitFrameLength> split_bands_data;
     int16_t* split_bands = split_bands_data.data();
     const int16_t* clean = split_bands_data.data();
-    if (audio->split_bands_f(capture)[kBand0To8kHz]) {
-      FloatS16ToS16(audio->split_bands_f(capture)[kBand0To8kHz],
+    if (audio->split_bands(capture)[kBand0To8kHz]) {
+      FloatS16ToS16(audio->split_bands(capture)[kBand0To8kHz],
                     audio->num_frames_per_band(), split_bands_data.data());
     } else {
       clean = nullptr;
@@ -205,7 +205,7 @@
 
       if (split_bands) {
         S16ToFloatS16(split_bands, audio->num_frames_per_band(),
-                      audio->split_bands_f(capture)[kBand0To8kHz]);
+                      audio->split_bands(capture)[kBand0To8kHz]);
       }
 
       if (err != AudioProcessing::kNoError) {
@@ -227,7 +227,7 @@
   RTC_DCHECK_LE(audio->num_channels(), low_pass_reference_.size());
   reference_copied_ = true;
   for (size_t capture = 0; capture < audio->num_channels(); ++capture) {
-    FloatS16ToS16(audio->split_bands_const_f(capture)[kBand0To8kHz],
+    FloatS16ToS16(audio->split_bands_const(capture)[kBand0To8kHz],
                   audio->num_frames_per_band(),
                   low_pass_reference_[capture].data());
   }
diff --git a/modules/audio_processing/gain_control_impl.cc b/modules/audio_processing/gain_control_impl.cc
index 2fb8a18..95e6a3a 100644
--- a/modules/audio_processing/gain_control_impl.cc
+++ b/modules/audio_processing/gain_control_impl.cc
@@ -123,17 +123,16 @@
   std::array<int16_t, AudioBuffer::kMaxSplitFrameLength> mixed_low_pass_data;
   rtc::ArrayView<const int16_t> mixed_low_pass(mixed_low_pass_data.data(),
                                                audio->num_frames_per_band());
-  if (audio->num_proc_channels() == 1) {
-    FloatS16ToS16(audio->split_bands_const_f(0)[kBand0To8kHz],
+  if (audio->num_channels() == 1) {
+    FloatS16ToS16(audio->split_bands_const(0)[kBand0To8kHz],
                   audio->num_frames_per_band(), mixed_low_pass_data.data());
   } else {
     const int num_channels = static_cast<int>(audio->num_channels());
     for (size_t i = 0; i < audio->num_frames_per_band(); ++i) {
       int32_t value =
-          FloatS16ToS16(audio->split_channels_const_f(kBand0To8kHz)[0][i]);
+          FloatS16ToS16(audio->split_channels_const(kBand0To8kHz)[0][i]);
       for (int j = 1; j < num_channels; ++j) {
-        value +=
-            FloatS16ToS16(audio->split_channels_const_f(kBand0To8kHz)[j][i]);
+        value += FloatS16ToS16(audio->split_channels_const(kBand0To8kHz)[j][i]);
       }
       mixed_low_pass_data[i] = value / num_channels;
     }
@@ -165,13 +164,13 @@
     for (auto& gain_controller : gain_controllers_) {
       gain_controller->set_capture_level(analog_capture_level_);
 
-      audio->CopySplitChannelDataTo(capture_channel, split_bands);
+      audio->ExportSplitChannelData(capture_channel, split_bands);
 
       int err =
           WebRtcAgc_AddMic(gain_controller->state(), split_bands,
                            audio->num_bands(), audio->num_frames_per_band());
 
-      audio->CopySplitChannelDataFrom(capture_channel, split_bands);
+      audio->ImportSplitChannelData(capture_channel, split_bands);
 
       if (err != AudioProcessing::kNoError) {
         return AudioProcessing::kUnspecifiedError;
@@ -183,14 +182,14 @@
     for (auto& gain_controller : gain_controllers_) {
       int32_t capture_level_out = 0;
 
-      audio->CopySplitChannelDataTo(capture_channel, split_bands);
+      audio->ExportSplitChannelData(capture_channel, split_bands);
 
       int err =
           WebRtcAgc_VirtualMic(gain_controller->state(), split_bands,
                                audio->num_bands(), audio->num_frames_per_band(),
                                analog_capture_level_, &capture_level_out);
 
-      audio->CopySplitChannelDataFrom(capture_channel, split_bands);
+      audio->ImportSplitChannelData(capture_channel, split_bands);
 
       gain_controller->set_capture_level(capture_level_out);
 
@@ -229,7 +228,7 @@
                            [AudioBuffer::kMaxSplitFrameLength];
     int16_t* split_bands[AudioBuffer::kMaxNumBands] = {
         split_band_data[0], split_band_data[1], split_band_data[2]};
-    audio->CopySplitChannelDataTo(capture_channel, split_bands);
+    audio->ExportSplitChannelData(capture_channel, split_bands);
 
     // The call to stream_has_echo() is ok from a deadlock perspective
     // as the capture lock is allready held.
@@ -239,7 +238,7 @@
         gain_controller->get_capture_level(), &capture_level_out,
         stream_has_echo, &saturation_warning);
 
-    audio->CopySplitChannelDataFrom(capture_channel, split_bands);
+    audio->ImportSplitChannelData(capture_channel, split_bands);
 
     if (err != AudioProcessing::kNoError) {
       return AudioProcessing::kUnspecifiedError;
diff --git a/modules/audio_processing/gain_control_unittest.cc b/modules/audio_processing/gain_control_unittest.cc
index e249a11..f5a2ae5 100644
--- a/modules/audio_processing/gain_control_unittest.cc
+++ b/modules/audio_processing/gain_control_unittest.cc
@@ -80,16 +80,16 @@
   const int samples_per_channel = rtc::CheckedDivExact(sample_rate_hz, 100);
   const StreamConfig render_config(sample_rate_hz, num_channels, false);
   AudioBuffer render_buffer(
-      render_config.num_frames(), render_config.num_channels(),
-      render_config.num_frames(), 1, render_config.num_frames());
+      render_config.sample_rate_hz(), render_config.num_channels(),
+      render_config.sample_rate_hz(), 1, render_config.sample_rate_hz());
   test::InputAudioFile render_file(
       test::GetApmRenderTestVectorFileName(sample_rate_hz));
   std::vector<float> render_input(samples_per_channel * num_channels);
 
   const StreamConfig capture_config(sample_rate_hz, num_channels, false);
   AudioBuffer capture_buffer(
-      capture_config.num_frames(), capture_config.num_channels(),
-      capture_config.num_frames(), 1, capture_config.num_frames());
+      capture_config.sample_rate_hz(), capture_config.num_channels(),
+      capture_config.sample_rate_hz(), 1, capture_config.sample_rate_hz());
   test::InputAudioFile capture_file(
       test::GetApmCaptureTestVectorFileName(sample_rate_hz));
   std::vector<float> capture_input(samples_per_channel * num_channels);
diff --git a/modules/audio_processing/gain_controller2.cc b/modules/audio_processing/gain_controller2.cc
index a1bbb1b..7cff82d 100644
--- a/modules/audio_processing/gain_controller2.cc
+++ b/modules/audio_processing/gain_controller2.cc
@@ -43,7 +43,7 @@
 }
 
 void GainController2::Process(AudioBuffer* audio) {
-  AudioFrameView<float> float_frame(audio->channels_f(), audio->num_channels(),
+  AudioFrameView<float> float_frame(audio->channels(), audio->num_channels(),
                                     audio->num_frames());
   // Apply fixed gain first, then the adaptive one.
   gain_applier_.ApplyGain(float_frame);
diff --git a/modules/audio_processing/gain_controller2_unittest.cc b/modules/audio_processing/gain_controller2_unittest.cc
index 99749cc..185f2f2 100644
--- a/modules/audio_processing/gain_controller2_unittest.cc
+++ b/modules/audio_processing/gain_controller2_unittest.cc
@@ -28,8 +28,7 @@
 void SetAudioBufferSamples(float value, AudioBuffer* ab) {
   // Sets all the samples in |ab| to |value|.
   for (size_t k = 0; k < ab->num_channels(); ++k) {
-    std::fill(ab->channels_f()[k], ab->channels_f()[k] + ab->num_frames(),
-              value);
+    std::fill(ab->channels()[k], ab->channels()[k] + ab->num_frames(), value);
   }
 }
 
@@ -38,7 +37,7 @@
                                size_t num_frames,
                                int sample_rate) {
   const int num_samples = rtc::CheckedDivExact(sample_rate, 100);
-  AudioBuffer ab(num_samples, 1, num_samples, 1, num_samples);
+  AudioBuffer ab(sample_rate, 1, sample_rate, 1, sample_rate);
 
   // Give time to the level estimator to converge.
   for (size_t i = 0; i < num_frames + 1; ++i) {
@@ -47,7 +46,7 @@
   }
 
   // Return the last sample from the last processed frame.
-  return ab.channels_f()[0][num_samples - 1];
+  return ab.channels()[0][num_samples - 1];
 }
 
 AudioProcessing::Config::GainController2 CreateAgc2FixedDigitalModeConfig(
@@ -74,9 +73,9 @@
   constexpr size_t kStereo = 2u;
   const StreamConfig capture_config(AudioProcessing::kSampleRate48kHz, kStereo,
                                     false);
-  AudioBuffer ab(capture_config.num_frames(), capture_config.num_channels(),
-                 capture_config.num_frames(), capture_config.num_channels(),
-                 capture_config.num_frames());
+  AudioBuffer ab(capture_config.sample_rate_hz(), capture_config.num_channels(),
+                 capture_config.sample_rate_hz(), capture_config.num_channels(),
+                 capture_config.sample_rate_hz());
   test::InputAudioFile capture_file(
       test::GetApmCaptureTestVectorFileName(AudioProcessing::kSampleRate48kHz));
   std::vector<float> capture_input(capture_config.num_frames() *
@@ -99,7 +98,7 @@
   constexpr float sample_value = 1.f;
   SetAudioBufferSamples(sample_value, &ab);
   gain_controller->Process(&ab);
-  return ab.channels_f()[0][0];
+  return ab.channels()[0][0];
 }
 
 }  // namespace
diff --git a/modules/audio_processing/level_estimator_impl.cc b/modules/audio_processing/level_estimator_impl.cc
index 8adbf19..e796095 100644
--- a/modules/audio_processing/level_estimator_impl.cc
+++ b/modules/audio_processing/level_estimator_impl.cc
@@ -32,16 +32,15 @@
   rms_->Reset();
 }
 
-void LevelEstimatorImpl::ProcessStream(AudioBuffer* audio) {
-  RTC_DCHECK(audio);
+void LevelEstimatorImpl::ProcessStream(const AudioBuffer& audio) {
   rtc::CritScope cs(crit_);
   if (!enabled_) {
     return;
   }
 
-  for (size_t i = 0; i < audio->num_channels(); i++) {
-    rms_->Analyze(rtc::ArrayView<const float>(audio->channels_const_f()[i],
-                                              audio->num_frames()));
+  for (size_t i = 0; i < audio.num_channels(); i++) {
+    rms_->Analyze(rtc::ArrayView<const float>(audio.channels_const()[i],
+                                              audio.num_frames()));
   }
 }
 
diff --git a/modules/audio_processing/level_estimator_impl.h b/modules/audio_processing/level_estimator_impl.h
index da217bb..4e482f4 100644
--- a/modules/audio_processing/level_estimator_impl.h
+++ b/modules/audio_processing/level_estimator_impl.h
@@ -29,7 +29,7 @@
 
   // TODO(peah): Fold into ctor, once public API is removed.
   void Initialize();
-  void ProcessStream(AudioBuffer* audio);
+  void ProcessStream(const AudioBuffer& audio);
 
   // LevelEstimator implementation.
   int Enable(bool enable) override;
diff --git a/modules/audio_processing/level_estimator_unittest.cc b/modules/audio_processing/level_estimator_unittest.cc
index 94b84bb..7db38f0 100644
--- a/modules/audio_processing/level_estimator_unittest.cc
+++ b/modules/audio_processing/level_estimator_unittest.cc
@@ -34,9 +34,9 @@
   int samples_per_channel = rtc::CheckedDivExact(sample_rate_hz, 100);
   StreamConfig capture_config(sample_rate_hz, num_channels, false);
   AudioBuffer capture_buffer(
-      capture_config.num_frames(), capture_config.num_channels(),
-      capture_config.num_frames(), capture_config.num_channels(),
-      capture_config.num_frames());
+      capture_config.sample_rate_hz(), capture_config.num_channels(),
+      capture_config.sample_rate_hz(), capture_config.num_channels(),
+      capture_config.sample_rate_hz());
 
   test::InputAudioFile capture_file(
       test::GetApmCaptureTestVectorFileName(sample_rate_hz));
@@ -48,7 +48,7 @@
     test::CopyVectorToAudioBuffer(capture_config, capture_input,
                                   &capture_buffer);
 
-    level_estimator.ProcessStream(&capture_buffer);
+    level_estimator.ProcessStream(capture_buffer);
   }
 
   // Extract test results.
diff --git a/modules/audio_processing/low_cut_filter.cc b/modules/audio_processing/low_cut_filter.cc
index 7398481..307a7e8 100644
--- a/modules/audio_processing/low_cut_filter.cc
+++ b/modules/audio_processing/low_cut_filter.cc
@@ -101,13 +101,13 @@
   RTC_DCHECK_EQ(filters_.size(), audio->num_channels());
   for (size_t i = 0; i < filters_.size(); i++) {
     std::array<int16_t, AudioBuffer::kMaxSplitFrameLength> samples_fixed;
-    FloatS16ToS16(audio->split_bands_f(i)[kBand0To8kHz],
+    FloatS16ToS16(audio->split_bands(i)[kBand0To8kHz],
                   audio->num_frames_per_band(), samples_fixed.data());
 
     filters_[i]->Process(samples_fixed.data(), audio->num_frames_per_band());
 
     S16ToFloatS16(samples_fixed.data(), audio->num_frames_per_band(),
-                  audio->split_bands_f(i)[kBand0To8kHz]);
+                  audio->split_bands(i)[kBand0To8kHz]);
   }
 }
 
diff --git a/modules/audio_processing/low_cut_filter_unittest.cc b/modules/audio_processing/low_cut_filter_unittest.cc
index fb950da..b5bd77d 100644
--- a/modules/audio_processing/low_cut_filter_unittest.cc
+++ b/modules/audio_processing/low_cut_filter_unittest.cc
@@ -25,9 +25,9 @@
                                    const StreamConfig& stream_config,
                                    LowCutFilter* low_cut_filter) {
   AudioBuffer audio_buffer(
-      stream_config.num_frames(), stream_config.num_channels(),
-      stream_config.num_frames(), stream_config.num_channels(),
-      stream_config.num_frames());
+      stream_config.sample_rate_hz(), stream_config.num_channels(),
+      stream_config.sample_rate_hz(), stream_config.num_channels(),
+      stream_config.sample_rate_hz());
 
   test::CopyVectorToAudioBuffer(stream_config, frame_input, &audio_buffer);
   low_cut_filter->Process(&audio_buffer);
diff --git a/modules/audio_processing/noise_suppression_impl.cc b/modules/audio_processing/noise_suppression_impl.cc
index c834717..151af61 100644
--- a/modules/audio_processing/noise_suppression_impl.cc
+++ b/modules/audio_processing/noise_suppression_impl.cc
@@ -82,7 +82,7 @@
   RTC_DCHECK_EQ(suppressors_.size(), audio->num_channels());
   for (size_t i = 0; i < suppressors_.size(); i++) {
     WebRtcNs_Analyze(suppressors_[i]->state(),
-                     audio->split_bands_const_f(i)[kBand0To8kHz]);
+                     audio->split_bands_const(i)[kBand0To8kHz]);
   }
 #endif
 }
@@ -98,19 +98,19 @@
   RTC_DCHECK_EQ(suppressors_.size(), audio->num_channels());
   for (size_t i = 0; i < suppressors_.size(); i++) {
 #if defined(WEBRTC_NS_FLOAT)
-    WebRtcNs_Process(suppressors_[i]->state(), audio->split_bands_const_f(i),
-                     audio->num_bands(), audio->split_bands_f(i));
+    WebRtcNs_Process(suppressors_[i]->state(), audio->split_bands_const(i),
+                     audio->num_bands(), audio->split_bands(i));
 #elif defined(WEBRTC_NS_FIXED)
     int16_t split_band_data[AudioBuffer::kMaxNumBands]
                            [AudioBuffer::kMaxSplitFrameLength];
     int16_t* split_bands[AudioBuffer::kMaxNumBands] = {
         split_band_data[0], split_band_data[1], split_band_data[2]};
-    audio->CopySplitChannelDataTo(i, split_bands);
+    audio->ExportSplitChannelData(i, split_bands);
 
     WebRtcNsx_Process(suppressors_[i]->state(), split_bands, audio->num_bands(),
                       split_bands);
 
-    audio->CopySplitChannelDataFrom(i, split_bands);
+    audio->ImportSplitChannelData(i, split_bands);
 #endif
   }
 }
diff --git a/modules/audio_processing/noise_suppression_unittest.cc b/modules/audio_processing/noise_suppression_unittest.cc
index 29aae8b..7fae632 100644
--- a/modules/audio_processing/noise_suppression_unittest.cc
+++ b/modules/audio_processing/noise_suppression_unittest.cc
@@ -54,9 +54,9 @@
   int samples_per_channel = rtc::CheckedDivExact(sample_rate_hz, 100);
   const StreamConfig capture_config(sample_rate_hz, num_channels, false);
   AudioBuffer capture_buffer(
-      capture_config.num_frames(), capture_config.num_channels(),
-      capture_config.num_frames(), capture_config.num_channels(),
-      capture_config.num_frames());
+      capture_config.sample_rate_hz(), capture_config.num_channels(),
+      capture_config.sample_rate_hz(), capture_config.num_channels(),
+      capture_config.sample_rate_hz());
   test::InputAudioFile capture_file(
       test::GetApmCaptureTestVectorFileName(sample_rate_hz));
   std::vector<float> capture_input(samples_per_channel * num_channels);
diff --git a/modules/audio_processing/residual_echo_detector.cc b/modules/audio_processing/residual_echo_detector.cc
index 0b53cc2..6188883 100644
--- a/modules/audio_processing/residual_echo_detector.cc
+++ b/modules/audio_processing/residual_echo_detector.cc
@@ -202,8 +202,8 @@
 void EchoDetector::PackRenderAudioBuffer(AudioBuffer* audio,
                                          std::vector<float>* packed_buffer) {
   packed_buffer->clear();
-  packed_buffer->insert(packed_buffer->end(), audio->channels_f()[0],
-                        audio->channels_f()[0] + audio->num_frames());
+  packed_buffer->insert(packed_buffer->end(), audio->channels()[0],
+                        audio->channels()[0] + audio->num_frames());
 }
 
 EchoDetector::Metrics ResidualEchoDetector::GetMetrics() const {
diff --git a/modules/audio_processing/splitting_filter.cc b/modules/audio_processing/splitting_filter.cc
index 122bc9c..6289628 100644
--- a/modules/audio_processing/splitting_filter.cc
+++ b/modules/audio_processing/splitting_filter.cc
@@ -10,11 +10,19 @@
 
 #include "modules/audio_processing/splitting_filter.h"
 
+#include <array>
+
 #include "common_audio/channel_buffer.h"
 #include "common_audio/signal_processing/include/signal_processing_library.h"
 #include "rtc_base/checks.h"
 
 namespace webrtc {
+namespace {
+
+constexpr size_t kSamplesPerBand = 160;
+constexpr size_t kTwoBandFilterSamplesPerFrame = 320;
+
+}  // namespace
 
 SplittingFilter::SplittingFilter(size_t num_channels,
                                  size_t num_bands,
@@ -33,8 +41,8 @@
 
 SplittingFilter::~SplittingFilter() = default;
 
-void SplittingFilter::Analysis(const IFChannelBuffer* data,
-                               IFChannelBuffer* bands) {
+void SplittingFilter::Analysis(const ChannelBuffer<float>* data,
+                               ChannelBuffer<float>* bands) {
   RTC_DCHECK_EQ(num_bands_, bands->num_bands());
   RTC_DCHECK_EQ(data->num_channels(), bands->num_channels());
   RTC_DCHECK_EQ(data->num_frames(),
@@ -46,8 +54,8 @@
   }
 }
 
-void SplittingFilter::Synthesis(const IFChannelBuffer* bands,
-                                IFChannelBuffer* data) {
+void SplittingFilter::Synthesis(const ChannelBuffer<float>* bands,
+                                ChannelBuffer<float>* data) {
   RTC_DCHECK_EQ(num_bands_, bands->num_bands());
   RTC_DCHECK_EQ(data->num_channels(), bands->num_channels());
   RTC_DCHECK_EQ(data->num_frames(),
@@ -59,47 +67,56 @@
   }
 }
 
-void SplittingFilter::TwoBandsAnalysis(const IFChannelBuffer* data,
-                                       IFChannelBuffer* bands) {
+void SplittingFilter::TwoBandsAnalysis(const ChannelBuffer<float>* data,
+                                       ChannelBuffer<float>* bands) {
   RTC_DCHECK_EQ(two_bands_states_.size(), data->num_channels());
+  RTC_DCHECK_EQ(data->num_frames(), kTwoBandFilterSamplesPerFrame);
+
   for (size_t i = 0; i < two_bands_states_.size(); ++i) {
-    WebRtcSpl_AnalysisQMF(data->ibuf_const()->channels()[i], data->num_frames(),
-                          bands->ibuf()->channels(0)[i],
-                          bands->ibuf()->channels(1)[i],
+    std::array<std::array<int16_t, kSamplesPerBand>, 2> bands16;
+    std::array<int16_t, kTwoBandFilterSamplesPerFrame> full_band16;
+    FloatS16ToS16(data->channels(0)[i], full_band16.size(), full_band16.data());
+    WebRtcSpl_AnalysisQMF(full_band16.data(), data->num_frames(),
+                          bands16[0].data(), bands16[1].data(),
                           two_bands_states_[i].analysis_state1,
                           two_bands_states_[i].analysis_state2);
+    S16ToFloatS16(bands16[0].data(), bands16[0].size(), bands->channels(0)[i]);
+    S16ToFloatS16(bands16[1].data(), bands16[1].size(), bands->channels(1)[i]);
   }
 }
 
-void SplittingFilter::TwoBandsSynthesis(const IFChannelBuffer* bands,
-                                        IFChannelBuffer* data) {
+void SplittingFilter::TwoBandsSynthesis(const ChannelBuffer<float>* bands,
+                                        ChannelBuffer<float>* data) {
   RTC_DCHECK_LE(data->num_channels(), two_bands_states_.size());
+  RTC_DCHECK_EQ(data->num_frames(), kTwoBandFilterSamplesPerFrame);
   for (size_t i = 0; i < data->num_channels(); ++i) {
-    WebRtcSpl_SynthesisQMF(
-        bands->ibuf_const()->channels(0)[i],
-        bands->ibuf_const()->channels(1)[i], bands->num_frames_per_band(),
-        data->ibuf()->channels()[i], two_bands_states_[i].synthesis_state1,
-        two_bands_states_[i].synthesis_state2);
+    std::array<std::array<int16_t, kSamplesPerBand>, 2> bands16;
+    std::array<int16_t, kTwoBandFilterSamplesPerFrame> full_band16;
+    FloatS16ToS16(bands->channels(0)[i], bands16[0].size(), bands16[0].data());
+    FloatS16ToS16(bands->channels(1)[i], bands16[1].size(), bands16[1].data());
+    WebRtcSpl_SynthesisQMF(bands16[0].data(), bands16[1].data(),
+                           bands->num_frames_per_band(), full_band16.data(),
+                           two_bands_states_[i].synthesis_state1,
+                           two_bands_states_[i].synthesis_state2);
+    S16ToFloatS16(full_band16.data(), full_band16.size(), data->channels(0)[i]);
   }
 }
 
-void SplittingFilter::ThreeBandsAnalysis(const IFChannelBuffer* data,
-                                         IFChannelBuffer* bands) {
+void SplittingFilter::ThreeBandsAnalysis(const ChannelBuffer<float>* data,
+                                         ChannelBuffer<float>* bands) {
   RTC_DCHECK_EQ(three_band_filter_banks_.size(), data->num_channels());
   for (size_t i = 0; i < three_band_filter_banks_.size(); ++i) {
-    three_band_filter_banks_[i]->Analysis(data->fbuf_const()->channels()[i],
-                                          data->num_frames(),
-                                          bands->fbuf()->bands(i));
+    three_band_filter_banks_[i]->Analysis(data->channels()[i],
+                                          data->num_frames(), bands->bands(i));
   }
 }
 
-void SplittingFilter::ThreeBandsSynthesis(const IFChannelBuffer* bands,
-                                          IFChannelBuffer* data) {
+void SplittingFilter::ThreeBandsSynthesis(const ChannelBuffer<float>* bands,
+                                          ChannelBuffer<float>* data) {
   RTC_DCHECK_LE(data->num_channels(), three_band_filter_banks_.size());
   for (size_t i = 0; i < data->num_channels(); ++i) {
-    three_band_filter_banks_[i]->Synthesis(bands->fbuf_const()->bands(i),
-                                           bands->num_frames_per_band(),
-                                           data->fbuf()->channels()[i]);
+    three_band_filter_banks_[i]->Synthesis(
+        bands->bands(i), bands->num_frames_per_band(), data->channels()[i]);
   }
 }
 
diff --git a/modules/audio_processing/splitting_filter.h b/modules/audio_processing/splitting_filter.h
index 7d60c82..3b33c35 100644
--- a/modules/audio_processing/splitting_filter.h
+++ b/modules/audio_processing/splitting_filter.h
@@ -15,12 +15,11 @@
 #include <memory>
 #include <vector>
 
+#include "common_audio/channel_buffer.h"
 #include "modules/audio_processing/three_band_filter_bank.h"
 
 namespace webrtc {
 
-class IFChannelBuffer;
-
 struct TwoBandsStates {
   TwoBandsStates() {
     memset(analysis_state1, 0, sizeof(analysis_state1));
@@ -41,22 +40,26 @@
 //
 // For each block, Analysis() is called to split into bands and then Synthesis()
 // to merge these bands again. The input and output signals are contained in
-// IFChannelBuffers and for the different bands an array of IFChannelBuffers is
+// ChannelBuffers and for the different bands an array of ChannelBuffers is
 // used.
 class SplittingFilter {
  public:
   SplittingFilter(size_t num_channels, size_t num_bands, size_t num_frames);
   ~SplittingFilter();
 
-  void Analysis(const IFChannelBuffer* data, IFChannelBuffer* bands);
-  void Synthesis(const IFChannelBuffer* bands, IFChannelBuffer* data);
+  void Analysis(const ChannelBuffer<float>* data, ChannelBuffer<float>* bands);
+  void Synthesis(const ChannelBuffer<float>* bands, ChannelBuffer<float>* data);
 
  private:
   // Two-band analysis and synthesis work for 640 samples or less.
-  void TwoBandsAnalysis(const IFChannelBuffer* data, IFChannelBuffer* bands);
-  void TwoBandsSynthesis(const IFChannelBuffer* bands, IFChannelBuffer* data);
-  void ThreeBandsAnalysis(const IFChannelBuffer* data, IFChannelBuffer* bands);
-  void ThreeBandsSynthesis(const IFChannelBuffer* bands, IFChannelBuffer* data);
+  void TwoBandsAnalysis(const ChannelBuffer<float>* data,
+                        ChannelBuffer<float>* bands);
+  void TwoBandsSynthesis(const ChannelBuffer<float>* bands,
+                         ChannelBuffer<float>* data);
+  void ThreeBandsAnalysis(const ChannelBuffer<float>* data,
+                          ChannelBuffer<float>* bands);
+  void ThreeBandsSynthesis(const ChannelBuffer<float>* bands,
+                           ChannelBuffer<float>* data);
   void InitBuffers();
 
   const size_t num_bands_;
diff --git a/modules/audio_processing/splitting_filter_unittest.cc b/modules/audio_processing/splitting_filter_unittest.cc
index 40f0c82..30fe4ca 100644
--- a/modules/audio_processing/splitting_filter_unittest.cc
+++ b/modules/audio_processing/splitting_filter_unittest.cc
@@ -42,19 +42,19 @@
   static const size_t kChunks = 8;
   SplittingFilter splitting_filter(kChannels, kNumBands,
                                    kSamplesPer48kHzChannel);
-  IFChannelBuffer in_data(kSamplesPer48kHzChannel, kChannels, kNumBands);
-  IFChannelBuffer bands(kSamplesPer48kHzChannel, kChannels, kNumBands);
-  IFChannelBuffer out_data(kSamplesPer48kHzChannel, kChannels, kNumBands);
+  ChannelBuffer<float> in_data(kSamplesPer48kHzChannel, kChannels, kNumBands);
+  ChannelBuffer<float> bands(kSamplesPer48kHzChannel, kChannels, kNumBands);
+  ChannelBuffer<float> out_data(kSamplesPer48kHzChannel, kChannels, kNumBands);
   for (size_t i = 0; i < kChunks; ++i) {
     // Input signal generation.
     bool is_present[kNumBands];
-    memset(in_data.fbuf()->channels()[0], 0,
-           kSamplesPer48kHzChannel * sizeof(in_data.fbuf()->channels()[0][0]));
+    memset(in_data.channels()[0], 0,
+           kSamplesPer48kHzChannel * sizeof(in_data.channels()[0][0]));
     for (size_t j = 0; j < kNumBands; ++j) {
       is_present[j] = i & (static_cast<size_t>(1) << j);
       float amplitude = is_present[j] ? kAmplitude : 0.f;
       for (size_t k = 0; k < kSamplesPer48kHzChannel; ++k) {
-        in_data.fbuf()->channels()[0][k] +=
+        in_data.channels()[0][k] +=
             amplitude * sin(2.f * M_PI * kFrequenciesHz[j] *
                             (i * kSamplesPer48kHzChannel + k) / kSampleRateHz);
       }
@@ -66,8 +66,7 @@
     for (size_t j = 0; j < kNumBands; ++j) {
       energy[j] = 0.f;
       for (size_t k = 0; k < kSamplesPer16kHzChannel; ++k) {
-        energy[j] += bands.fbuf_const()->channels(j)[0][k] *
-                     bands.fbuf_const()->channels(j)[0][k];
+        energy[j] += bands.channels(j)[0][k] * bands.channels(j)[0][k];
       }
       energy[j] /= kSamplesPer16kHzChannel;
       if (is_present[j]) {
@@ -83,8 +82,7 @@
     for (size_t delay = 0; delay < kSamplesPer48kHzChannel; ++delay) {
       float tmpcorr = 0.f;
       for (size_t j = delay; j < kSamplesPer48kHzChannel; ++j) {
-        tmpcorr += in_data.fbuf_const()->channels()[0][j - delay] *
-                   out_data.fbuf_const()->channels()[0][j];
+        tmpcorr += in_data.channels()[0][j - delay] * out_data.channels()[0][j];
       }
       tmpcorr /= kSamplesPer48kHzChannel;
       if (tmpcorr > xcorr) {
diff --git a/modules/audio_processing/test/simulator_buffers.cc b/modules/audio_processing/test/simulator_buffers.cc
index 90c6d5e..4255400 100644
--- a/modules/audio_processing/test/simulator_buffers.cc
+++ b/modules/audio_processing/test/simulator_buffers.cc
@@ -59,9 +59,10 @@
     std::vector<float>* buffer_data_samples) {
   int samples_per_channel = rtc::CheckedDivExact(sample_rate_hz, 100);
   *config = StreamConfig(sample_rate_hz, num_channels, false);
-  buffer->reset(new AudioBuffer(config->num_frames(), config->num_channels(),
-                                config->num_frames(), config->num_channels(),
-                                config->num_frames()));
+  buffer->reset(
+      new AudioBuffer(config->sample_rate_hz(), config->num_channels(),
+                      config->sample_rate_hz(), config->num_channels(),
+                      config->sample_rate_hz()));
 
   buffer_data_samples->resize(samples_per_channel * num_channels);
   for (auto& v : *buffer_data_samples) {
diff --git a/modules/audio_processing/voice_detection_impl.cc b/modules/audio_processing/voice_detection_impl.cc
index 3b0eb7c..80b633c 100644
--- a/modules/audio_processing/voice_detection_impl.cc
+++ b/modules/audio_processing/voice_detection_impl.cc
@@ -63,17 +63,16 @@
   std::array<int16_t, AudioBuffer::kMaxSplitFrameLength> mixed_low_pass_data;
   rtc::ArrayView<const int16_t> mixed_low_pass(mixed_low_pass_data.data(),
                                                audio->num_frames_per_band());
-  if (audio->num_proc_channels() == 1) {
-    FloatS16ToS16(audio->split_bands_const_f(0)[kBand0To8kHz],
+  if (audio->num_channels() == 1) {
+    FloatS16ToS16(audio->split_bands_const(0)[kBand0To8kHz],
                   audio->num_frames_per_band(), mixed_low_pass_data.data());
   } else {
     const int num_channels = static_cast<int>(audio->num_channels());
     for (size_t i = 0; i < audio->num_frames_per_band(); ++i) {
       int32_t value =
-          FloatS16ToS16(audio->split_channels_const_f(kBand0To8kHz)[0][i]);
+          FloatS16ToS16(audio->split_channels_const(kBand0To8kHz)[0][i]);
       for (int j = 1; j < num_channels; ++j) {
-        value +=
-            FloatS16ToS16(audio->split_channels_const_f(kBand0To8kHz)[j][i]);
+        value += FloatS16ToS16(audio->split_channels_const(kBand0To8kHz)[j][i]);
       }
       mixed_low_pass_data[i] = value / num_channels;
     }
diff --git a/modules/audio_processing/voice_detection_unittest.cc b/modules/audio_processing/voice_detection_unittest.cc
index 663913b..538859b 100644
--- a/modules/audio_processing/voice_detection_unittest.cc
+++ b/modules/audio_processing/voice_detection_unittest.cc
@@ -47,9 +47,9 @@
   int samples_per_channel = rtc::CheckedDivExact(sample_rate_hz, 100);
   const StreamConfig capture_config(sample_rate_hz, num_channels, false);
   AudioBuffer capture_buffer(
-      capture_config.num_frames(), capture_config.num_channels(),
-      capture_config.num_frames(), capture_config.num_channels(),
-      capture_config.num_frames());
+      capture_config.sample_rate_hz(), capture_config.num_channels(),
+      capture_config.sample_rate_hz(), capture_config.num_channels(),
+      capture_config.sample_rate_hz());
   test::InputAudioFile capture_file(
       test::GetApmCaptureTestVectorFileName(sample_rate_hz));
   std::vector<float> capture_input(samples_per_channel * num_channels);