diff --git a/webrtc/modules/audio_processing/audio_buffer.cc b/webrtc/modules/audio_processing/audio_buffer.cc
index 9073ad7..6f73262 100644
--- a/webrtc/modules/audio_processing/audio_buffer.cc
+++ b/webrtc/modules/audio_processing/audio_buffer.cc
@@ -403,21 +403,37 @@
   }
 }
 
-void AudioBuffer::InterleaveTo(AudioFrame* frame, bool data_changed) const {
-  assert(proc_num_frames_ == output_num_frames_);
-  assert(num_channels_ == num_input_channels_);
-  assert(frame->num_channels_ == num_channels_);
-  assert(frame->samples_per_channel_ == proc_num_frames_);
+void AudioBuffer::InterleaveTo(AudioFrame* frame, bool data_changed) {
   frame->vad_activity_ = activity_;
-
   if (!data_changed) {
     return;
   }
 
-  Interleave(data_->ibuf()->channels(),
-             proc_num_frames_,
-             num_channels_,
-             frame->data_);
+  assert(frame->num_channels_ == num_channels_ || num_channels_ == 1);
+  assert(frame->samples_per_channel_ == output_num_frames_);
+
+  // Resample if necessary.
+  IFChannelBuffer* data_ptr = data_.get();
+  if (proc_num_frames_ != output_num_frames_) {
+    if (!output_buffer_) {
+      output_buffer_.reset(
+          new IFChannelBuffer(output_num_frames_, num_channels_));
+    }
+    for (int 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();
+  }
+
+  if (frame->num_channels_ == num_channels_) {
+    Interleave(data_ptr->ibuf()->channels(), proc_num_frames_, num_channels_,
+               frame->data_);
+  } else {
+    UpmixMonoToInterleaved(data_ptr->ibuf()->channels()[0], proc_num_frames_,
+                           frame->num_channels_, frame->data_);
+  }
 }
 
 void AudioBuffer::CopyLowPassToReference() {
diff --git a/webrtc/modules/audio_processing/audio_buffer.h b/webrtc/modules/audio_processing/audio_buffer.h
index 6750af0..aeb303b 100644
--- a/webrtc/modules/audio_processing/audio_buffer.h
+++ b/webrtc/modules/audio_processing/audio_buffer.h
@@ -109,7 +109,7 @@
   void DeinterleaveFrom(AudioFrame* audioFrame);
   // If |data_changed| is false, only the non-audio data members will be copied
   // to |frame|.
-  void InterleaveTo(AudioFrame* frame, bool data_changed) const;
+  void InterleaveTo(AudioFrame* frame, bool data_changed);
 
   // Use for float deinterleaved data.
   void CopyFrom(const float* const* data, const StreamConfig& stream_config);
@@ -152,6 +152,7 @@
   rtc::scoped_ptr<ChannelBuffer<int16_t> > mixed_low_pass_channels_;
   rtc::scoped_ptr<ChannelBuffer<int16_t> > low_pass_reference_channels_;
   rtc::scoped_ptr<IFChannelBuffer> input_buffer_;
+  rtc::scoped_ptr<IFChannelBuffer> output_buffer_;
   rtc::scoped_ptr<ChannelBuffer<float> > process_buffer_;
   ScopedVector<PushSincResampler> input_resamplers_;
   ScopedVector<PushSincResampler> output_resamplers_;
diff --git a/webrtc/modules/audio_processing/audio_processing_impl.cc b/webrtc/modules/audio_processing/audio_processing_impl.cc
index 81d6c70..c9e4ddc 100644
--- a/webrtc/modules/audio_processing/audio_processing_impl.cc
+++ b/webrtc/modules/audio_processing/audio_processing_impl.cc
@@ -15,8 +15,9 @@
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/platform_file.h"
-#include "webrtc/common_audio/include/audio_util.h"
+#include "webrtc/common_audio/audio_converter.h"
 #include "webrtc/common_audio/channel_buffer.h"
+#include "webrtc/common_audio/include/audio_util.h"
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 extern "C" {
 #include "webrtc/modules/audio_processing/aec/aec_core.h"
@@ -29,6 +30,7 @@
 #include "webrtc/modules/audio_processing/echo_control_mobile_impl.h"
 #include "webrtc/modules/audio_processing/gain_control_impl.h"
 #include "webrtc/modules/audio_processing/high_pass_filter_impl.h"
+#include "webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer.h"
 #include "webrtc/modules/audio_processing/level_estimator_impl.h"
 #include "webrtc/modules/audio_processing/noise_suppression_impl.h"
 #include "webrtc/modules/audio_processing/processing_component.h"
@@ -184,6 +186,7 @@
 #endif
       api_format_({{{kSampleRate16kHz, 1, false},
                     {kSampleRate16kHz, 1, false},
+                    {kSampleRate16kHz, 1, false},
                     {kSampleRate16kHz, 1, false}}}),
       fwd_proc_format_(kSampleRate16kHz),
       rev_proc_format_(kSampleRate16kHz, 1),
@@ -210,7 +213,8 @@
 #endif
       beamformer_enabled_(config.Get<Beamforming>().enabled),
       beamformer_(beamformer),
-      array_geometry_(config.Get<Beamforming>().array_geometry) {
+      array_geometry_(config.Get<Beamforming>().array_geometry),
+      intelligibility_enabled_(config.Get<Intelligibility>().enabled) {
   echo_cancellation_ = new EchoCancellationImpl(this, crit_);
   component_list_.push_back(echo_cancellation_);
 
@@ -282,11 +286,17 @@
                                     ChannelLayout output_layout,
                                     ChannelLayout reverse_layout) {
   const ProcessingConfig processing_config = {
-      {{input_sample_rate_hz, ChannelsFromLayout(input_layout),
+      {{input_sample_rate_hz,
+        ChannelsFromLayout(input_layout),
         LayoutHasKeyboard(input_layout)},
-       {output_sample_rate_hz, ChannelsFromLayout(output_layout),
+       {output_sample_rate_hz,
+        ChannelsFromLayout(output_layout),
         LayoutHasKeyboard(output_layout)},
-       {reverse_sample_rate_hz, ChannelsFromLayout(reverse_layout),
+       {reverse_sample_rate_hz,
+        ChannelsFromLayout(reverse_layout),
+        LayoutHasKeyboard(reverse_layout)},
+       {reverse_sample_rate_hz,
+        ChannelsFromLayout(reverse_layout),
         LayoutHasKeyboard(reverse_layout)}}};
 
   return Initialize(processing_config);
@@ -301,14 +311,28 @@
   const int fwd_audio_buffer_channels =
       beamformer_enabled_ ? api_format_.input_stream().num_channels()
                           : api_format_.output_stream().num_channels();
-  if (api_format_.reverse_stream().num_channels() > 0) {
+  const int rev_audio_buffer_out_num_frames =
+      api_format_.reverse_output_stream().num_frames() == 0
+          ? rev_proc_format_.num_frames()
+          : api_format_.reverse_output_stream().num_frames();
+  if (api_format_.reverse_input_stream().num_channels() > 0) {
     render_audio_.reset(new AudioBuffer(
-        api_format_.reverse_stream().num_frames(),
-        api_format_.reverse_stream().num_channels(),
+        api_format_.reverse_input_stream().num_frames(),
+        api_format_.reverse_input_stream().num_channels(),
         rev_proc_format_.num_frames(), rev_proc_format_.num_channels(),
-        rev_proc_format_.num_frames()));
+        rev_audio_buffer_out_num_frames));
+    if (rev_conversion_needed()) {
+      render_converter_ = AudioConverter::Create(
+          api_format_.reverse_input_stream().num_channels(),
+          api_format_.reverse_input_stream().num_frames(),
+          api_format_.reverse_output_stream().num_channels(),
+          api_format_.reverse_output_stream().num_frames());
+    } else {
+      render_converter_.reset(nullptr);
+    }
   } else {
     render_audio_.reset(nullptr);
+    render_converter_.reset(nullptr);
   }
   capture_audio_.reset(new AudioBuffer(
       api_format_.input_stream().num_frames(),
@@ -329,6 +353,8 @@
 
   InitializeBeamformer();
 
+  InitializeIntelligibility();
+
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   if (debug_file_->Open()) {
     int err = WriteInitMessage();
@@ -396,7 +422,8 @@
     // ...the forward stream is at 8 kHz.
     rev_proc_rate = kSampleRate8kHz;
   } else {
-    if (api_format_.reverse_stream().sample_rate_hz() == kSampleRate32kHz) {
+    if (api_format_.reverse_input_stream().sample_rate_hz() ==
+        kSampleRate32kHz) {
       // ...or the input is at 32 kHz, in which case we use the splitting
       // filter rather than the resampler.
       rev_proc_rate = kSampleRate32kHz;
@@ -624,6 +651,7 @@
   MaybeUpdateHistograms();
 
   AudioBuffer* ca = capture_audio_.get();  // For brevity.
+
   if (use_new_agc_ && gain_control_->is_enabled()) {
     agc_manager_->AnalyzePreProcess(ca->channels()[0], ca->num_channels(),
                                     fwd_proc_format_.num_frames());
@@ -634,6 +662,11 @@
     ca->SplitIntoFrequencyBands();
   }
 
+  if (intelligibility_enabled_) {
+    intelligibility_enhancer_->AnalyzeCaptureAudio(
+        ca->split_channels_f(kBand0To8kHz), split_rate_, ca->num_channels());
+  }
+
   if (beamformer_enabled_) {
     beamformer_->ProcessChunk(*ca->split_data_f(), ca->split_data_f());
     ca->set_num_channels(1);
@@ -684,50 +717,81 @@
 
 int AudioProcessingImpl::AnalyzeReverseStream(const float* const* data,
                                               int samples_per_channel,
-                                              int sample_rate_hz,
+                                              int rev_sample_rate_hz,
                                               ChannelLayout layout) {
   const StreamConfig reverse_config = {
-      sample_rate_hz, ChannelsFromLayout(layout), LayoutHasKeyboard(layout),
+      rev_sample_rate_hz, ChannelsFromLayout(layout), LayoutHasKeyboard(layout),
   };
   if (samples_per_channel != reverse_config.num_frames()) {
     return kBadDataLengthError;
   }
-  return AnalyzeReverseStream(data, reverse_config);
+  return AnalyzeReverseStream(data, reverse_config, reverse_config);
+}
+
+int AudioProcessingImpl::ProcessReverseStream(
+    const float* const* src,
+    const StreamConfig& reverse_input_config,
+    const StreamConfig& reverse_output_config,
+    float* const* dest) {
+  RETURN_ON_ERR(
+      AnalyzeReverseStream(src, reverse_input_config, reverse_output_config));
+  if (is_rev_processed()) {
+    render_audio_->CopyTo(api_format_.reverse_output_stream(), dest);
+  } else if (rev_conversion_needed()) {
+    render_converter_->Convert(src, reverse_input_config.num_samples(), dest,
+                               reverse_output_config.num_samples());
+  } else {
+    CopyAudioIfNeeded(src, reverse_input_config.num_frames(),
+                      reverse_input_config.num_channels(), dest);
+  }
+
+  return kNoError;
 }
 
 int AudioProcessingImpl::AnalyzeReverseStream(
-    const float* const* data,
-    const StreamConfig& reverse_config) {
+    const float* const* src,
+    const StreamConfig& reverse_input_config,
+    const StreamConfig& reverse_output_config) {
   CriticalSectionScoped crit_scoped(crit_);
-  if (data == NULL) {
+  if (src == NULL) {
     return kNullPointerError;
   }
 
-  if (reverse_config.num_channels() <= 0) {
+  if (reverse_input_config.num_channels() <= 0) {
     return kBadNumberChannelsError;
   }
 
   ProcessingConfig processing_config = api_format_;
-  processing_config.reverse_stream() = reverse_config;
+  processing_config.reverse_input_stream() = reverse_input_config;
+  processing_config.reverse_output_stream() = reverse_output_config;
 
   RETURN_ON_ERR(MaybeInitializeLocked(processing_config));
-  assert(reverse_config.num_frames() ==
-         api_format_.reverse_stream().num_frames());
+  assert(reverse_input_config.num_frames() ==
+         api_format_.reverse_input_stream().num_frames());
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   if (debug_file_->Open()) {
     event_msg_->set_type(audioproc::Event::REVERSE_STREAM);
     audioproc::ReverseStream* msg = event_msg_->mutable_reverse_stream();
     const size_t channel_size =
-        sizeof(float) * api_format_.reverse_stream().num_frames();
-    for (int i = 0; i < api_format_.reverse_stream().num_channels(); ++i)
-      msg->add_channel(data[i], channel_size);
+        sizeof(float) * api_format_.reverse_input_stream().num_frames();
+    for (int i = 0; i < api_format_.reverse_input_stream().num_channels(); ++i)
+      msg->add_channel(src[i], channel_size);
     RETURN_ON_ERR(WriteMessageToDebugFile());
   }
 #endif
 
-  render_audio_->CopyFrom(data, api_format_.reverse_stream());
-  return AnalyzeReverseStreamLocked();
+  render_audio_->CopyFrom(src, api_format_.reverse_input_stream());
+  return ProcessReverseStreamLocked();
+}
+
+int AudioProcessingImpl::ProcessReverseStream(AudioFrame* frame) {
+  RETURN_ON_ERR(AnalyzeReverseStream(frame));
+  if (is_rev_processed()) {
+    render_audio_->InterleaveTo(frame, true);
+  }
+
+  return kNoError;
 }
 
 int AudioProcessingImpl::AnalyzeReverseStream(AudioFrame* frame) {
@@ -752,12 +816,18 @@
   }
 
   ProcessingConfig processing_config = api_format_;
-  processing_config.reverse_stream().set_sample_rate_hz(frame->sample_rate_hz_);
-  processing_config.reverse_stream().set_num_channels(frame->num_channels_);
+  processing_config.reverse_input_stream().set_sample_rate_hz(
+      frame->sample_rate_hz_);
+  processing_config.reverse_input_stream().set_num_channels(
+      frame->num_channels_);
+  processing_config.reverse_output_stream().set_sample_rate_hz(
+      frame->sample_rate_hz_);
+  processing_config.reverse_output_stream().set_num_channels(
+      frame->num_channels_);
 
   RETURN_ON_ERR(MaybeInitializeLocked(processing_config));
   if (frame->samples_per_channel_ !=
-      api_format_.reverse_stream().num_frames()) {
+      api_format_.reverse_input_stream().num_frames()) {
     return kBadDataLengthError;
   }
 
@@ -771,23 +841,32 @@
     RETURN_ON_ERR(WriteMessageToDebugFile());
   }
 #endif
-
   render_audio_->DeinterleaveFrom(frame);
-  return AnalyzeReverseStreamLocked();
+  return ProcessReverseStreamLocked();
 }
 
-int AudioProcessingImpl::AnalyzeReverseStreamLocked() {
+int AudioProcessingImpl::ProcessReverseStreamLocked() {
   AudioBuffer* ra = render_audio_.get();  // For brevity.
   if (rev_proc_format_.sample_rate_hz() == kSampleRate32kHz) {
     ra->SplitIntoFrequencyBands();
   }
 
+  if (intelligibility_enabled_) {
+    intelligibility_enhancer_->ProcessRenderAudio(
+        ra->split_channels_f(kBand0To8kHz), split_rate_, ra->num_channels());
+  }
+
   RETURN_ON_ERR(echo_cancellation_->ProcessRenderAudio(ra));
   RETURN_ON_ERR(echo_control_mobile_->ProcessRenderAudio(ra));
   if (!use_new_agc_) {
     RETURN_ON_ERR(gain_control_->ProcessRenderAudio(ra));
   }
 
+  if (rev_proc_format_.sample_rate_hz() == kSampleRate32kHz &&
+      is_rev_processed()) {
+    ra->MergeFrequencyBands();
+  }
+
   return kNoError;
 }
 
@@ -1004,6 +1083,15 @@
   return false;
 }
 
+bool AudioProcessingImpl::is_rev_processed() const {
+  return intelligibility_enabled_ && intelligibility_enhancer_->active();
+}
+
+bool AudioProcessingImpl::rev_conversion_needed() const {
+  return (api_format_.reverse_input_stream() !=
+          api_format_.reverse_output_stream());
+}
+
 void AudioProcessingImpl::InitializeExperimentalAgc() {
   if (use_new_agc_) {
     if (!agc_manager_.get()) {
@@ -1036,6 +1124,16 @@
   }
 }
 
+void AudioProcessingImpl::InitializeIntelligibility() {
+  if (intelligibility_enabled_) {
+    IntelligibilityEnhancer::Config config;
+    config.sample_rate_hz = split_rate_;
+    config.num_capture_channels = capture_audio_->num_channels();
+    config.num_render_channels = render_audio_->num_channels();
+    intelligibility_enhancer_.reset(new IntelligibilityEnhancer(config));
+  }
+}
+
 void AudioProcessingImpl::MaybeUpdateHistograms() {
   static const int kMinDiffDelayMs = 60;
 
@@ -1134,9 +1232,12 @@
   msg->set_sample_rate(api_format_.input_stream().sample_rate_hz());
   msg->set_num_input_channels(api_format_.input_stream().num_channels());
   msg->set_num_output_channels(api_format_.output_stream().num_channels());
-  msg->set_num_reverse_channels(api_format_.reverse_stream().num_channels());
-  msg->set_reverse_sample_rate(api_format_.reverse_stream().sample_rate_hz());
+  msg->set_num_reverse_channels(
+      api_format_.reverse_input_stream().num_channels());
+  msg->set_reverse_sample_rate(
+      api_format_.reverse_input_stream().sample_rate_hz());
   msg->set_output_sample_rate(api_format_.output_stream().sample_rate_hz());
+  // TODO(ekmeyerson): Add reverse output fields to event_msg_.
 
   int err = WriteMessageToDebugFile();
   if (err != kNoError) {
diff --git a/webrtc/modules/audio_processing/audio_processing_impl.h b/webrtc/modules/audio_processing/audio_processing_impl.h
index a44b5a8..a08f7b3 100644
--- a/webrtc/modules/audio_processing/audio_processing_impl.h
+++ b/webrtc/modules/audio_processing/audio_processing_impl.h
@@ -23,6 +23,7 @@
 
 class AgcManagerDirect;
 class AudioBuffer;
+class AudioConverter;
 
 template<typename T>
 class Beamformer;
@@ -39,6 +40,7 @@
 class ProcessingComponent;
 class TransientSuppressor;
 class VoiceDetectionImpl;
+class IntelligibilityEnhancer;
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 namespace audioproc {
@@ -89,12 +91,15 @@
                     const StreamConfig& output_config,
                     float* const* dest) override;
   int AnalyzeReverseStream(AudioFrame* frame) override;
+  int ProcessReverseStream(AudioFrame* frame) override;
   int AnalyzeReverseStream(const float* const* data,
                            int samples_per_channel,
                            int sample_rate_hz,
                            ChannelLayout layout) override;
-  int AnalyzeReverseStream(const float* const* data,
-                           const StreamConfig& reverse_config) override;
+  int ProcessReverseStream(const float* const* src,
+                           const StreamConfig& reverse_input_config,
+                           const StreamConfig& reverse_output_config,
+                           float* const* dest) override;
   int set_stream_delay_ms(int delay) override;
   int stream_delay_ms() const override;
   bool was_stream_delay_set() const override;
@@ -124,16 +129,23 @@
       EXCLUSIVE_LOCKS_REQUIRED(crit_);
   int MaybeInitializeLocked(const ProcessingConfig& config)
       EXCLUSIVE_LOCKS_REQUIRED(crit_);
+  // TODO(ekm): Remove once all clients updated to new interface.
+  int AnalyzeReverseStream(const float* const* src,
+                           const StreamConfig& input_config,
+                           const StreamConfig& output_config);
   int ProcessStreamLocked() EXCLUSIVE_LOCKS_REQUIRED(crit_);
-  int AnalyzeReverseStreamLocked() EXCLUSIVE_LOCKS_REQUIRED(crit_);
+  int ProcessReverseStreamLocked() EXCLUSIVE_LOCKS_REQUIRED(crit_);
 
   bool is_data_processed() const;
   bool output_copy_needed(bool is_data_processed) const;
   bool synthesis_needed(bool is_data_processed) const;
   bool analysis_needed(bool is_data_processed) const;
+  bool is_rev_processed() const;
+  bool rev_conversion_needed() const;
   void InitializeExperimentalAgc() EXCLUSIVE_LOCKS_REQUIRED(crit_);
   void InitializeTransient() EXCLUSIVE_LOCKS_REQUIRED(crit_);
   void InitializeBeamformer() EXCLUSIVE_LOCKS_REQUIRED(crit_);
+  void InitializeIntelligibility() EXCLUSIVE_LOCKS_REQUIRED(crit_);
   void MaybeUpdateHistograms() EXCLUSIVE_LOCKS_REQUIRED(crit_);
 
   EchoCancellationImpl* echo_cancellation_;
@@ -149,6 +161,7 @@
   CriticalSectionWrapper* crit_;
   rtc::scoped_ptr<AudioBuffer> render_audio_;
   rtc::scoped_ptr<AudioBuffer> capture_audio_;
+  rtc::scoped_ptr<AudioConverter> render_converter_;
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   // TODO(andrew): make this more graceful. Ideally we would split this stuff
   // out into a separate class with an "enabled" and "disabled" implementation.
@@ -191,6 +204,9 @@
   const bool beamformer_enabled_;
   rtc::scoped_ptr<Beamformer<float>> beamformer_;
   const std::vector<Point> array_geometry_;
+
+  bool intelligibility_enabled_;
+  rtc::scoped_ptr<IntelligibilityEnhancer> intelligibility_enhancer_;
 };
 
 }  // namespace webrtc
diff --git a/webrtc/modules/audio_processing/include/audio_processing.h b/webrtc/modules/audio_processing/include/audio_processing.h
index 0854844..fd91bfa 100644
--- a/webrtc/modules/audio_processing/include/audio_processing.h
+++ b/webrtc/modules/audio_processing/include/audio_processing.h
@@ -116,6 +116,18 @@
   const std::vector<Point> array_geometry;
 };
 
+// Use to enable intelligibility enhancer in audio processing. Must be provided
+// though the constructor. It will have no impact if used with
+// AudioProcessing::SetExtraOptions().
+//
+// Note: If enabled and the reverse stream has more than one output channel,
+// the reverse stream will become an upmixed mono signal.
+struct Intelligibility {
+  Intelligibility() : enabled(false) {}
+  explicit Intelligibility(bool enabled) : enabled(enabled) {}
+  bool enabled;
+};
+
 static const int kAudioProcMaxNativeSampleRateHz = 32000;
 
 // The Audio Processing Module (APM) provides a collection of voice processing
@@ -333,21 +345,28 @@
   // |input_sample_rate_hz()|
   //
   // TODO(ajm): add const to input; requires an implementation fix.
+  // DEPRECATED: Use |ProcessReverseStream| instead.
+  // TODO(ekm): Remove once all users have updated to |ProcessReverseStream|.
   virtual int AnalyzeReverseStream(AudioFrame* frame) = 0;
 
+  // Same as |AnalyzeReverseStream|, but may modify |frame| if intelligibility
+  // is enabled.
+  virtual int ProcessReverseStream(AudioFrame* frame) = 0;
+
   // Accepts deinterleaved float audio with the range [-1, 1]. Each element
   // of |data| points to a channel buffer, arranged according to |layout|.
-  //
   // TODO(mgraczyk): Remove once clients are updated to use the new interface.
   virtual int AnalyzeReverseStream(const float* const* data,
                                    int samples_per_channel,
-                                   int sample_rate_hz,
+                                   int rev_sample_rate_hz,
                                    ChannelLayout layout) = 0;
 
   // Accepts deinterleaved float audio with the range [-1, 1]. Each element of
   // |data| points to a channel buffer, arranged according to |reverse_config|.
-  virtual int AnalyzeReverseStream(const float* const* data,
-                                   const StreamConfig& reverse_config) = 0;
+  virtual int ProcessReverseStream(const float* const* src,
+                                   const StreamConfig& reverse_input_config,
+                                   const StreamConfig& reverse_output_config,
+                                   float* const* dest) = 0;
 
   // This must be called if and only if echo processing is enabled.
   //
@@ -492,6 +511,7 @@
 
   bool has_keyboard() const { return has_keyboard_; }
   int num_frames() const { return num_frames_; }
+  int num_samples() const { return num_channels_ * num_frames_; }
 
   bool operator==(const StreamConfig& other) const {
     return sample_rate_hz_ == other.sample_rate_hz_ &&
@@ -517,7 +537,8 @@
   enum StreamName {
     kInputStream,
     kOutputStream,
-    kReverseStream,
+    kReverseInputStream,
+    kReverseOutputStream,
     kNumStreamNames,
   };
 
@@ -527,13 +548,21 @@
   const StreamConfig& output_stream() const {
     return streams[StreamName::kOutputStream];
   }
-  const StreamConfig& reverse_stream() const {
-    return streams[StreamName::kReverseStream];
+  const StreamConfig& reverse_input_stream() const {
+    return streams[StreamName::kReverseInputStream];
+  }
+  const StreamConfig& reverse_output_stream() const {
+    return streams[StreamName::kReverseOutputStream];
   }
 
   StreamConfig& input_stream() { return streams[StreamName::kInputStream]; }
   StreamConfig& output_stream() { return streams[StreamName::kOutputStream]; }
-  StreamConfig& reverse_stream() { return streams[StreamName::kReverseStream]; }
+  StreamConfig& reverse_input_stream() {
+    return streams[StreamName::kReverseInputStream];
+  }
+  StreamConfig& reverse_output_stream() {
+    return streams[StreamName::kReverseOutputStream];
+  }
 
   bool operator==(const ProcessingConfig& other) const {
     for (int i = 0; i < StreamName::kNumStreamNames; ++i) {
diff --git a/webrtc/modules/audio_processing/include/mock_audio_processing.h b/webrtc/modules/audio_processing/include/mock_audio_processing.h
index 8007a86..f0d9c32 100644
--- a/webrtc/modules/audio_processing/include/mock_audio_processing.h
+++ b/webrtc/modules/audio_processing/include/mock_audio_processing.h
@@ -227,11 +227,15 @@
                    float* const* dest));
   MOCK_METHOD1(AnalyzeReverseStream,
       int(AudioFrame* frame));
+  MOCK_METHOD1(ProcessReverseStream, int(AudioFrame* frame));
   MOCK_METHOD4(AnalyzeReverseStream,
       int(const float* const* data, int frames, int sample_rate_hz,
           ChannelLayout input_layout));
-  MOCK_METHOD2(AnalyzeReverseStream,
-      int(const float* const* data, const StreamConfig& reverse_config));
+  MOCK_METHOD4(ProcessReverseStream,
+               int(const float* const* src,
+                   const StreamConfig& input_config,
+                   const StreamConfig& output_config,
+                   float* const* dest));
   MOCK_METHOD1(set_stream_delay_ms,
       int(int delay));
   MOCK_CONST_METHOD0(stream_delay_ms,
diff --git a/webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer.cc b/webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer.cc
index dbb7e63..8eccde4 100644
--- a/webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer.cc
+++ b/webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer.cc
@@ -19,18 +19,18 @@
 
 #include <math.h>
 #include <stdlib.h>
-
 #include <algorithm>
 #include <numeric>
 
 #include "webrtc/base/checks.h"
-#include "webrtc/common_audio/vad/include/webrtc_vad.h"
+#include "webrtc/common_audio/include/audio_util.h"
 #include "webrtc/common_audio/window_generator.h"
 
 namespace webrtc {
 
 namespace {
 
+const int kErbResolution = 2;
 const int kWindowSizeMs = 2;
 const int kChunkSizeMs = 10;  // Size provided by APM.
 const float kClipFreq = 200.0f;
@@ -64,124 +64,93 @@
   }
 }
 
-IntelligibilityEnhancer::IntelligibilityEnhancer(int erb_resolution,
-                                                 int sample_rate_hz,
-                                                 int channels,
-                                                 int cv_type,
-                                                 float cv_alpha,
-                                                 int cv_win,
-                                                 int analysis_rate,
-                                                 int variance_rate,
-                                                 float gain_limit)
+IntelligibilityEnhancer::IntelligibilityEnhancer()
+    : IntelligibilityEnhancer(IntelligibilityEnhancer::Config()) {
+}
+
+IntelligibilityEnhancer::IntelligibilityEnhancer(const Config& config)
     : freqs_(RealFourier::ComplexLength(
-          RealFourier::FftOrder(sample_rate_hz * kWindowSizeMs / 1000))),
+          RealFourier::FftOrder(config.sample_rate_hz * kWindowSizeMs / 1000))),
       window_size_(1 << RealFourier::FftOrder(freqs_)),
-      chunk_length_(sample_rate_hz * kChunkSizeMs / 1000),
-      bank_size_(GetBankSize(sample_rate_hz, erb_resolution)),
-      sample_rate_hz_(sample_rate_hz),
-      erb_resolution_(erb_resolution),
-      channels_(channels),
-      analysis_rate_(analysis_rate),
-      variance_rate_(variance_rate),
+      chunk_length_(config.sample_rate_hz * kChunkSizeMs / 1000),
+      bank_size_(GetBankSize(config.sample_rate_hz, kErbResolution)),
+      sample_rate_hz_(config.sample_rate_hz),
+      erb_resolution_(kErbResolution),
+      num_capture_channels_(config.num_capture_channels),
+      num_render_channels_(config.num_render_channels),
+      analysis_rate_(config.analysis_rate),
+      active_(true),
       clear_variance_(freqs_,
-                      static_cast<VarianceType>(cv_type),
-                      cv_win,
-                      cv_alpha),
-      noise_variance_(freqs_, VarianceType::kStepInfinite, 475, 0.01f),
+                      config.var_type,
+                      config.var_window_size,
+                      config.var_decay_rate),
+      noise_variance_(freqs_,
+                      config.var_type,
+                      config.var_window_size,
+                      config.var_decay_rate),
       filtered_clear_var_(new float[bank_size_]),
       filtered_noise_var_(new float[bank_size_]),
       filter_bank_(bank_size_),
       center_freqs_(new float[bank_size_]),
       rho_(new float[bank_size_]),
       gains_eq_(new float[bank_size_]),
-      gain_applier_(freqs_, gain_limit),
-      temp_out_buffer_(nullptr),
-      input_audio_(new float* [channels]),
+      gain_applier_(freqs_, config.gain_change_limit),
+      temp_render_out_buffer_(chunk_length_, num_render_channels_),
+      temp_capture_out_buffer_(chunk_length_, num_capture_channels_),
       kbd_window_(new float[window_size_]),
       render_callback_(this, AudioSource::kRenderStream),
       capture_callback_(this, AudioSource::kCaptureStream),
       block_count_(0),
-      analysis_step_(0),
-      vad_high_(WebRtcVad_Create()),
-      vad_low_(WebRtcVad_Create()),
-      vad_tmp_buffer_(new int16_t[chunk_length_]) {
-  DCHECK_LE(kConfigRho, 1.0f);
+      analysis_step_(0) {
+  DCHECK_LE(config.rho, 1.0f);
 
   CreateErbBank();
 
-  WebRtcVad_Init(vad_high_);
-  WebRtcVad_set_mode(vad_high_, 0);  // High likelihood of speech.
-  WebRtcVad_Init(vad_low_);
-  WebRtcVad_set_mode(vad_low_, 3);  // Low likelihood of speech.
-
-  temp_out_buffer_ = static_cast<float**>(
-      malloc(sizeof(*temp_out_buffer_) * channels_ +
-             sizeof(**temp_out_buffer_) * chunk_length_ * channels_));
-  for (int i = 0; i < channels_; ++i) {
-    temp_out_buffer_[i] =
-        reinterpret_cast<float*>(temp_out_buffer_ + channels_) +
-        chunk_length_ * i;
-  }
-
   // Assumes all rho equal.
   for (int i = 0; i < bank_size_; ++i) {
-    rho_[i] = kConfigRho * kConfigRho;
+    rho_[i] = config.rho * config.rho;
   }
 
   float freqs_khz = kClipFreq / 1000.0f;
   int erb_index = static_cast<int>(ceilf(
       11.17f * logf((freqs_khz + 0.312f) / (freqs_khz + 14.6575f)) + 43.0f));
-  start_freq_ = std::max(1, erb_index * erb_resolution);
+  start_freq_ = max(1, erb_index * erb_resolution_);
 
   WindowGenerator::KaiserBesselDerived(kKbdAlpha, window_size_,
                                        kbd_window_.get());
   render_mangler_.reset(new LappedTransform(
-      channels_, channels_, chunk_length_, kbd_window_.get(), window_size_,
-      window_size_ / 2, &render_callback_));
+      num_render_channels_, num_render_channels_, chunk_length_,
+      kbd_window_.get(), window_size_, window_size_ / 2, &render_callback_));
   capture_mangler_.reset(new LappedTransform(
-      channels_, channels_, chunk_length_, kbd_window_.get(), window_size_,
-      window_size_ / 2, &capture_callback_));
+      num_capture_channels_, num_capture_channels_, chunk_length_,
+      kbd_window_.get(), window_size_, window_size_ / 2, &capture_callback_));
 }
 
-IntelligibilityEnhancer::~IntelligibilityEnhancer() {
-  WebRtcVad_Free(vad_low_);
-  WebRtcVad_Free(vad_high_);
-  free(temp_out_buffer_);
-}
+void IntelligibilityEnhancer::ProcessRenderAudio(float* const* audio,
+                                                 int sample_rate_hz,
+                                                 int num_channels) {
+  CHECK_EQ(sample_rate_hz_, sample_rate_hz);
+  CHECK_EQ(num_render_channels_, num_channels);
 
-void IntelligibilityEnhancer::ProcessRenderAudio(float* const* audio) {
-  for (int i = 0; i < chunk_length_; ++i) {
-    vad_tmp_buffer_[i] = (int16_t)audio[0][i];
+  if (active_) {
+    render_mangler_->ProcessChunk(audio, temp_render_out_buffer_.channels());
   }
-  has_voice_low_ = WebRtcVad_Process(vad_low_, sample_rate_hz_,
-                                     vad_tmp_buffer_.get(), chunk_length_) == 1;
 
-  // Process and enhance chunk of |audio|
-  render_mangler_->ProcessChunk(audio, temp_out_buffer_);
-
-  for (int i = 0; i < channels_; ++i) {
-    memcpy(audio[i], temp_out_buffer_[i],
-           chunk_length_ * sizeof(**temp_out_buffer_));
-  }
-}
-
-void IntelligibilityEnhancer::ProcessCaptureAudio(float* const* audio) {
-  for (int i = 0; i < chunk_length_; ++i) {
-    vad_tmp_buffer_[i] = (int16_t)audio[0][i];
-  }
-  // TODO(bercic): The VAD was always detecting voice in the noise stream,
-  // no matter what the aggressiveness, so it was temporarily disabled here.
-
-  #if 0
-    if (WebRtcVad_Process(vad_high_, sample_rate_hz_, vad_tmp_buffer_.get(),
-      chunk_length_) == 1) {
-      printf("capture HAS speech\n");
-      return;
+  if (active_) {
+    for (int i = 0; i < num_render_channels_; ++i) {
+      memcpy(audio[i], temp_render_out_buffer_.channels()[i],
+             chunk_length_ * sizeof(**audio));
     }
-    printf("capture NO speech\n");
-  #endif
+  }
+}
 
-  capture_mangler_->ProcessChunk(audio, temp_out_buffer_);
+void IntelligibilityEnhancer::AnalyzeCaptureAudio(float* const* audio,
+                                                  int sample_rate_hz,
+                                                  int num_channels) {
+  CHECK_EQ(sample_rate_hz_, sample_rate_hz);
+  CHECK_EQ(num_capture_channels_, num_channels);
+
+  capture_mangler_->ProcessChunk(audio, temp_capture_out_buffer_.channels());
 }
 
 void IntelligibilityEnhancer::DispatchAudio(
@@ -206,28 +175,21 @@
     return;
   }
 
-  // For now, always assumes enhancement is necessary.
-  // TODO(ekmeyerson): Change to only enhance if necessary,
-  // based on experiments with different cutoffs.
-  if (has_voice_low_ || true) {
+  // TODO(ekm): Use VAD to |Step| and |AnalyzeClearBlock| only if necessary.
+  if (true) {
     clear_variance_.Step(in_block, false);
-    const float power_target = std::accumulate(
-        clear_variance_.variance(), clear_variance_.variance() + freqs_, 0.0f);
-
     if (block_count_ % analysis_rate_ == analysis_rate_ - 1) {
+      const float power_target = std::accumulate(
+          clear_variance_.variance(), clear_variance_.variance() + freqs_, 0.f);
       AnalyzeClearBlock(power_target);
       ++analysis_step_;
-      if (analysis_step_ == variance_rate_) {
-        analysis_step_ = 0;
-        clear_variance_.Clear();
-        noise_variance_.Clear();
-      }
     }
     ++block_count_;
   }
 
-  /* efidata(n,:) = sqrt(b(n)) * fidata(n,:) */
-  gain_applier_.Apply(in_block, out_block);
+  if (active_) {
+    gain_applier_.Apply(in_block, out_block);
+  }
 }
 
 void IntelligibilityEnhancer::AnalyzeClearBlock(float power_target) {
@@ -406,4 +368,8 @@
   return ret;
 }
 
+bool IntelligibilityEnhancer::active() const {
+  return active_;
+}
+
 }  // namespace webrtc
diff --git a/webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer.h b/webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer.h
index 7f18be8..1a2ef23 100644
--- a/webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer.h
+++ b/webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer.h
@@ -20,11 +20,9 @@
 
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/common_audio/lapped_transform.h"
+#include "webrtc/common_audio/channel_buffer.h"
 #include "webrtc/modules/audio_processing/intelligibility/intelligibility_utils.h"
 
-struct WebRtcVadInst;
-typedef struct WebRtcVadInst VadInst;
-
 namespace webrtc {
 
 // Speech intelligibility enhancement module. Reads render and capture
@@ -33,32 +31,45 @@
 // Note: assumes speech and noise streams are already separated.
 class IntelligibilityEnhancer {
  public:
-  // Construct a new instance with the given filter bank resolution,
-  // sampling rate, number of channels and analysis rates.
-  // |analysis_rate| sets the number of input blocks (containing speech!)
-  // to elapse before a new gain computation is made. |variance_rate| specifies
-  // the number of gain recomputations after which the variances are reset.
-  // |cv_*| are parameters for the VarianceArray constructor for the
-  // clear speech stream.
-  // TODO(bercic): the |cv_*|, |*_rate| and |gain_limit| parameters should
-  // probably go away once fine tuning is done. They override the internal
-  // constants in the class (kGainChangeLimit, kAnalyzeRate, kVarianceRate).
-  IntelligibilityEnhancer(int erb_resolution,
-                          int sample_rate_hz,
-                          int channels,
-                          int cv_type,
-                          float cv_alpha,
-                          int cv_win,
-                          int analysis_rate,
-                          int variance_rate,
-                          float gain_limit);
-  ~IntelligibilityEnhancer();
+  struct Config {
+    // |var_*| are parameters for the VarianceArray constructor for the
+    // clear speech stream.
+    // TODO(bercic): the |var_*|, |*_rate| and |gain_limit| parameters should
+    // probably go away once fine tuning is done.
+    Config()
+        : sample_rate_hz(16000),
+          num_capture_channels(1),
+          num_render_channels(1),
+          var_type(intelligibility::VarianceArray::kStepDecaying),
+          var_decay_rate(0.9f),
+          var_window_size(10),
+          analysis_rate(800),
+          gain_change_limit(0.1f),
+          rho(0.02f) {}
+    int sample_rate_hz;
+    int num_capture_channels;
+    int num_render_channels;
+    intelligibility::VarianceArray::StepType var_type;
+    float var_decay_rate;
+    int var_window_size;
+    int analysis_rate;
+    float gain_change_limit;
+    float rho;
+  };
+
+  explicit IntelligibilityEnhancer(const Config& config);
+  IntelligibilityEnhancer();  // Initialize with default config.
 
   // Reads and processes chunk of noise stream in time domain.
-  void ProcessCaptureAudio(float* const* audio);
+  void AnalyzeCaptureAudio(float* const* audio,
+                           int sample_rate_hz,
+                           int num_channels);
 
   // Reads chunk of speech in time domain and updates with modified signal.
-  void ProcessRenderAudio(float* const* audio);
+  void ProcessRenderAudio(float* const* audio,
+                          int sample_rate_hz,
+                          int num_channels);
+  bool active() const;
 
  private:
   enum AudioSource {
@@ -133,9 +144,12 @@
   const int bank_size_;     // Num ERB filters.
   const int sample_rate_hz_;
   const int erb_resolution_;
-  const int channels_;       // Num channels.
+  const int num_capture_channels_;
+  const int num_render_channels_;
   const int analysis_rate_;  // Num blocks before gains recalculated.
-  const int variance_rate_;  // Num recalculations before history is cleared.
+
+  const bool active_;  // Whether render gains are being updated.
+                       // TODO(ekm): Add logic for updating |active_|.
 
   intelligibility::VarianceArray clear_variance_;
   intelligibility::VarianceArray noise_variance_;
@@ -149,12 +163,11 @@
   rtc::scoped_ptr<float[]> gains_eq_;  // Pre-filter modified gains.
   intelligibility::GainApplier gain_applier_;
 
-  // Destination buffer used to reassemble blocked chunks before overwriting
+  // Destination buffers used to reassemble blocked chunks before overwriting
   // the original input array with modifications.
-  // TODO(ekmeyerson): Switch to using ChannelBuffer.
-  float** temp_out_buffer_;
+  ChannelBuffer<float> temp_render_out_buffer_;
+  ChannelBuffer<float> temp_capture_out_buffer_;
 
-  rtc::scoped_ptr<float* []> input_audio_;
   rtc::scoped_ptr<float[]> kbd_window_;
   TransformCallback render_callback_;
   TransformCallback capture_callback_;
@@ -162,14 +175,6 @@
   rtc::scoped_ptr<LappedTransform> capture_mangler_;
   int block_count_;
   int analysis_step_;
-
-  // TODO(bercic): Quick stopgap measure for voice detection in the clear
-  // and noise streams.
-  // Note: VAD currently does not affect anything in IntelligibilityEnhancer.
-  VadInst* vad_high_;
-  VadInst* vad_low_;
-  rtc::scoped_ptr<int16_t[]> vad_tmp_buffer_;
-  bool has_voice_low_;  // Whether voice detected in speech stream.
 };
 
 }  // namespace webrtc
diff --git a/webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer_unittest.cc b/webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer_unittest.cc
index 490db2c..cb0085d 100644
--- a/webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer_unittest.cc
+++ b/webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer_unittest.cc
@@ -19,6 +19,7 @@
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/arraysize.h"
+#include "webrtc/base/scoped_ptr.h"
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer.h"
 
@@ -74,15 +75,9 @@
 
 // Enhancer initialization parameters.
 const int kSamples = 2000;
-const int kErbResolution = 2;
 const int kSampleRate = 1000;
-const int kFragmentSize = kSampleRate / 100;
 const int kNumChannels = 1;
-const float kDecayRate = 0.9f;
-const int kWindowSize = 800;
-const int kAnalyzeRate = 800;
-const int kVarianceRate = 2;
-const float kGainLimit = 0.1f;
+const int kFragmentSize = kSampleRate / 100;
 
 }  // namespace
 
@@ -92,28 +87,20 @@
 class IntelligibilityEnhancerTest : public ::testing::Test {
  protected:
   IntelligibilityEnhancerTest()
-      : enh_(kErbResolution,
-             kSampleRate,
-             kNumChannels,
-             VarianceArray::kStepInfinite,
-             kDecayRate,
-             kWindowSize,
-             kAnalyzeRate,
-             kVarianceRate,
-             kGainLimit),
-        clear_data_(kSamples),
-        noise_data_(kSamples),
-        orig_data_(kSamples) {}
+      : clear_data_(kSamples), noise_data_(kSamples), orig_data_(kSamples) {
+    config_.sample_rate_hz = kSampleRate;
+    enh_.reset(new IntelligibilityEnhancer(config_));
+  }
 
   bool CheckUpdate(VarianceArray::StepType step_type) {
-    IntelligibilityEnhancer enh(kErbResolution, kSampleRate, kNumChannels,
-                                step_type, kDecayRate, kWindowSize,
-                                kAnalyzeRate, kVarianceRate, kGainLimit);
+    config_.sample_rate_hz = kSampleRate;
+    config_.var_type = step_type;
+    enh_.reset(new IntelligibilityEnhancer(config_));
     float* clear_cursor = &clear_data_[0];
     float* noise_cursor = &noise_data_[0];
     for (int i = 0; i < kSamples; i += kFragmentSize) {
-      enh.ProcessCaptureAudio(&noise_cursor);
-      enh.ProcessRenderAudio(&clear_cursor);
+      enh_->AnalyzeCaptureAudio(&noise_cursor, kSampleRate, kNumChannels);
+      enh_->ProcessRenderAudio(&clear_cursor, kSampleRate, kNumChannels);
       clear_cursor += kFragmentSize;
       noise_cursor += kFragmentSize;
     }
@@ -125,7 +112,8 @@
     return false;
   }
 
-  IntelligibilityEnhancer enh_;
+  IntelligibilityEnhancer::Config config_;
+  rtc::scoped_ptr<IntelligibilityEnhancer> enh_;
   vector<float> clear_data_;
   vector<float> noise_data_;
   vector<float> orig_data_;
@@ -161,12 +149,12 @@
 
 // Tests ERB bank creation, comparing against matlab output.
 TEST_F(IntelligibilityEnhancerTest, TestErbCreation) {
-  ASSERT_EQ(static_cast<int>(arraysize(kTestCenterFreqs)), enh_.bank_size_);
-  for (int i = 0; i < enh_.bank_size_; ++i) {
-    EXPECT_NEAR(kTestCenterFreqs[i], enh_.center_freqs_[i], kMaxTestError);
-    ASSERT_EQ(static_cast<int>(arraysize(kTestFilterBank[0])), enh_.freqs_);
-    for (int j = 0; j < enh_.freqs_; ++j) {
-      EXPECT_NEAR(kTestFilterBank[i][j], enh_.filter_bank_[i][j],
+  ASSERT_EQ(static_cast<int>(arraysize(kTestCenterFreqs)), enh_->bank_size_);
+  for (int i = 0; i < enh_->bank_size_; ++i) {
+    EXPECT_NEAR(kTestCenterFreqs[i], enh_->center_freqs_[i], kMaxTestError);
+    ASSERT_EQ(static_cast<int>(arraysize(kTestFilterBank[0])), enh_->freqs_);
+    for (int j = 0; j < enh_->freqs_; ++j) {
+      EXPECT_NEAR(kTestFilterBank[i][j], enh_->filter_bank_[i][j],
                   kMaxTestError);
     }
   }
@@ -175,29 +163,29 @@
 // Tests analytic solution for optimal gains, comparing
 // against matlab output.
 TEST_F(IntelligibilityEnhancerTest, TestSolveForGains) {
-  ASSERT_EQ(kTestStartFreq, enh_.start_freq_);
-  vector<float> sols(enh_.bank_size_);
+  ASSERT_EQ(kTestStartFreq, enh_->start_freq_);
+  vector<float> sols(enh_->bank_size_);
   float lambda = -0.001f;
-  for (int i = 0; i < enh_.bank_size_; i++) {
-    enh_.filtered_clear_var_[i] = 0.0f;
-    enh_.filtered_noise_var_[i] = 0.0f;
-    enh_.rho_[i] = 0.02f;
+  for (int i = 0; i < enh_->bank_size_; i++) {
+    enh_->filtered_clear_var_[i] = 0.0f;
+    enh_->filtered_noise_var_[i] = 0.0f;
+    enh_->rho_[i] = 0.02f;
   }
-  enh_.SolveForGainsGivenLambda(lambda, enh_.start_freq_, &sols[0]);
-  for (int i = 0; i < enh_.bank_size_; i++) {
+  enh_->SolveForGainsGivenLambda(lambda, enh_->start_freq_, &sols[0]);
+  for (int i = 0; i < enh_->bank_size_; i++) {
     EXPECT_NEAR(kTestZeroVar[i], sols[i], kMaxTestError);
   }
-  for (int i = 0; i < enh_.bank_size_; i++) {
-    enh_.filtered_clear_var_[i] = static_cast<float>(i + 1);
-    enh_.filtered_noise_var_[i] = static_cast<float>(enh_.bank_size_ - i);
+  for (int i = 0; i < enh_->bank_size_; i++) {
+    enh_->filtered_clear_var_[i] = static_cast<float>(i + 1);
+    enh_->filtered_noise_var_[i] = static_cast<float>(enh_->bank_size_ - i);
   }
-  enh_.SolveForGainsGivenLambda(lambda, enh_.start_freq_, &sols[0]);
-  for (int i = 0; i < enh_.bank_size_; i++) {
+  enh_->SolveForGainsGivenLambda(lambda, enh_->start_freq_, &sols[0]);
+  for (int i = 0; i < enh_->bank_size_; i++) {
     EXPECT_NEAR(kTestNonZeroVarLambdaTop[i], sols[i], kMaxTestError);
   }
   lambda = -1.0;
-  enh_.SolveForGainsGivenLambda(lambda, enh_.start_freq_, &sols[0]);
-  for (int i = 0; i < enh_.bank_size_; i++) {
+  enh_->SolveForGainsGivenLambda(lambda, enh_->start_freq_, &sols[0]);
+  for (int i = 0; i < enh_->bank_size_; i++) {
     EXPECT_NEAR(kTestZeroVar[i], sols[i], kMaxTestError);
   }
 }
diff --git a/webrtc/modules/audio_processing/intelligibility/intelligibility_utils.cc b/webrtc/modules/audio_processing/intelligibility/intelligibility_utils.cc
index 00d9b53..2c2743f 100644
--- a/webrtc/modules/audio_processing/intelligibility/intelligibility_utils.cc
+++ b/webrtc/modules/audio_processing/intelligibility/intelligibility_utils.cc
@@ -51,33 +51,33 @@
 
 static const int kWindowBlockSize = 10;
 
-VarianceArray::VarianceArray(int freqs,
+VarianceArray::VarianceArray(int num_freqs,
                              StepType type,
                              int window_size,
                              float decay)
-    : running_mean_(new complex<float>[freqs]()),
-      running_mean_sq_(new complex<float>[freqs]()),
-      sub_running_mean_(new complex<float>[freqs]()),
-      sub_running_mean_sq_(new complex<float>[freqs]()),
-      variance_(new float[freqs]()),
-      conj_sum_(new float[freqs]()),
-      freqs_(freqs),
+    : running_mean_(new complex<float>[num_freqs]()),
+      running_mean_sq_(new complex<float>[num_freqs]()),
+      sub_running_mean_(new complex<float>[num_freqs]()),
+      sub_running_mean_sq_(new complex<float>[num_freqs]()),
+      variance_(new float[num_freqs]()),
+      conj_sum_(new float[num_freqs]()),
+      num_freqs_(num_freqs),
       window_size_(window_size),
       decay_(decay),
       history_cursor_(0),
       count_(0),
       array_mean_(0.0f),
       buffer_full_(false) {
-  history_.reset(new rtc::scoped_ptr<complex<float>[]>[freqs_]());
-  for (int i = 0; i < freqs_; ++i) {
+  history_.reset(new rtc::scoped_ptr<complex<float>[]>[num_freqs_]());
+  for (int i = 0; i < num_freqs_; ++i) {
     history_[i].reset(new complex<float>[window_size_]());
   }
-  subhistory_.reset(new rtc::scoped_ptr<complex<float>[]>[freqs_]());
-  for (int i = 0; i < freqs_; ++i) {
+  subhistory_.reset(new rtc::scoped_ptr<complex<float>[]>[num_freqs_]());
+  for (int i = 0; i < num_freqs_; ++i) {
     subhistory_[i].reset(new complex<float>[window_size_]());
   }
-  subhistory_sq_.reset(new rtc::scoped_ptr<complex<float>[]>[freqs_]());
-  for (int i = 0; i < freqs_; ++i) {
+  subhistory_sq_.reset(new rtc::scoped_ptr<complex<float>[]>[num_freqs_]());
+  for (int i = 0; i < num_freqs_; ++i) {
     subhistory_sq_[i].reset(new complex<float>[window_size_]());
   }
   switch (type) {
@@ -104,7 +104,7 @@
 void VarianceArray::InfiniteStep(const complex<float>* data, bool skip_fudge) {
   array_mean_ = 0.0f;
   ++count_;
-  for (int i = 0; i < freqs_; ++i) {
+  for (int i = 0; i < num_freqs_; ++i) {
     complex<float> sample = data[i];
     if (!skip_fudge) {
       sample = zerofudge(sample);
@@ -132,7 +132,7 @@
 void VarianceArray::DecayStep(const complex<float>* data, bool /*dummy*/) {
   array_mean_ = 0.0f;
   ++count_;
-  for (int i = 0; i < freqs_; ++i) {
+  for (int i = 0; i < num_freqs_; ++i) {
     complex<float> sample = data[i];
     sample = zerofudge(sample);
 
@@ -159,7 +159,7 @@
 void VarianceArray::WindowedStep(const complex<float>* data, bool /*dummy*/) {
   int num = min(count_ + 1, window_size_);
   array_mean_ = 0.0f;
-  for (int i = 0; i < freqs_; ++i) {
+  for (int i = 0; i < num_freqs_; ++i) {
     complex<float> mean;
     float conj_sum = 0.0f;
 
@@ -192,7 +192,7 @@
 // are recomputed from scratch at each of these transitions.
 void VarianceArray::BlockedStep(const complex<float>* data, bool /*dummy*/) {
   int blocks = min(window_size_, history_cursor_ + 1);
-  for (int i = 0; i < freqs_; ++i) {
+  for (int i = 0; i < num_freqs_; ++i) {
     AddToMean(data[i], count_ + 1, &sub_running_mean_[i]);
     AddToMean(data[i] * std::conj(data[i]), count_ + 1,
               &sub_running_mean_sq_[i]);
@@ -228,7 +228,7 @@
   // TODO(ekmeyerson) To mitigate potential divergence, add counter so that
   // after every so often sums are computed scratch by summing over all
   // elements instead of subtracting oldest and adding newest.
-  for (int i = 0; i < freqs_; ++i) {
+  for (int i = 0; i < num_freqs_; ++i) {
     sub_running_mean_[i] += data[i];
     sub_running_mean_sq_[i] += data[i] * std::conj(data[i]);
   }
@@ -239,7 +239,7 @@
   if (count_ >= kWindowBlockSize) {
     count_ = 0;
 
-    for (int i = 0; i < freqs_; ++i) {
+    for (int i = 0; i < num_freqs_; ++i) {
       running_mean_[i] -= subhistory_[i][history_cursor_];
       running_mean_sq_[i] -= subhistory_sq_[i][history_cursor_];
 
@@ -268,10 +268,11 @@
 }
 
 void VarianceArray::Clear() {
-  memset(running_mean_.get(), 0, sizeof(*running_mean_.get()) * freqs_);
-  memset(running_mean_sq_.get(), 0, sizeof(*running_mean_sq_.get()) * freqs_);
-  memset(variance_.get(), 0, sizeof(*variance_.get()) * freqs_);
-  memset(conj_sum_.get(), 0, sizeof(*conj_sum_.get()) * freqs_);
+  memset(running_mean_.get(), 0, sizeof(*running_mean_.get()) * num_freqs_);
+  memset(running_mean_sq_.get(), 0,
+         sizeof(*running_mean_sq_.get()) * num_freqs_);
+  memset(variance_.get(), 0, sizeof(*variance_.get()) * num_freqs_);
+  memset(conj_sum_.get(), 0, sizeof(*conj_sum_.get()) * num_freqs_);
   history_cursor_ = 0;
   count_ = 0;
   array_mean_ = 0.0f;
@@ -279,14 +280,14 @@
 
 void VarianceArray::ApplyScale(float scale) {
   array_mean_ = 0.0f;
-  for (int i = 0; i < freqs_; ++i) {
+  for (int i = 0; i < num_freqs_; ++i) {
     variance_[i] *= scale * scale;
     array_mean_ += (variance_[i] - array_mean_) / (i + 1);
   }
 }
 
 GainApplier::GainApplier(int freqs, float change_limit)
-    : freqs_(freqs),
+    : num_freqs_(freqs),
       change_limit_(change_limit),
       target_(new float[freqs]()),
       current_(new float[freqs]()) {
@@ -298,7 +299,7 @@
 
 void GainApplier::Apply(const complex<float>* in_block,
                         complex<float>* out_block) {
-  for (int i = 0; i < freqs_; ++i) {
+  for (int i = 0; i < num_freqs_; ++i) {
     float factor = sqrtf(fabsf(current_[i]));
     if (!std::isnormal(factor)) {
       factor = 1.0f;
diff --git a/webrtc/modules/audio_processing/intelligibility/intelligibility_utils.h b/webrtc/modules/audio_processing/intelligibility/intelligibility_utils.h
index 5013ef0..fa0e974 100644
--- a/webrtc/modules/audio_processing/intelligibility/intelligibility_utils.h
+++ b/webrtc/modules/audio_processing/intelligibility/intelligibility_utils.h
@@ -119,7 +119,7 @@
   rtc::scoped_ptr<float[]> variance_;
   rtc::scoped_ptr<float[]> conj_sum_;
 
-  const int freqs_;
+  const int num_freqs_;
   const int window_size_;
   const float decay_;
   int history_cursor_;
@@ -145,7 +145,7 @@
   float* target() const { return target_.get(); }
 
  private:
-  const int freqs_;
+  const int num_freqs_;
   const float change_limit_;
   rtc::scoped_ptr<float[]> target_;
   rtc::scoped_ptr<float[]> current_;
diff --git a/webrtc/modules/audio_processing/intelligibility/test/intelligibility_proc.cc b/webrtc/modules/audio_processing/intelligibility/test/intelligibility_proc.cc
index cef41e9..6b6bfa0 100644
--- a/webrtc/modules/audio_processing/intelligibility/test/intelligibility_proc.cc
+++ b/webrtc/modules/audio_processing/intelligibility/test/intelligibility_proc.cc
@@ -31,6 +31,7 @@
 #include "webrtc/test/testsupport/fileutils.h"
 
 using std::complex;
+using webrtc::intelligibility::VarianceArray;
 
 namespace webrtc {
 namespace {
@@ -40,7 +41,7 @@
 }
 
 DEFINE_int32(clear_type,
-             webrtc::intelligibility::VarianceArray::kStepInfinite,
+             webrtc::intelligibility::VarianceArray::kStepDecaying,
              "Variance algorithm for clear data.");
 DEFINE_double(clear_alpha, 0.9, "Variance decay factor for clear data.");
 DEFINE_int32(clear_window,
@@ -67,8 +68,6 @@
               "Enhanced output. Use '-' to "
               "play through aplay immediately.");
 
-// Constant IntelligibilityEnhancer constructor parameters.
-const int kErbResolution = 2;
 const int kNumChannels = 1;
 
 // void function for gtest
@@ -108,11 +107,14 @@
   noise_file.ReadSamples(samples, &noise_fpcm[0]);
 
   // Run intelligibility enhancement.
-
-  IntelligibilityEnhancer enh(
-      kErbResolution, FLAGS_sample_rate, kNumChannels, FLAGS_clear_type,
-      static_cast<float>(FLAGS_clear_alpha), FLAGS_clear_window, FLAGS_ana_rate,
-      FLAGS_var_rate, FLAGS_gain_limit);
+  IntelligibilityEnhancer::Config config;
+  config.sample_rate_hz = FLAGS_sample_rate;
+  config.var_type = static_cast<VarianceArray::StepType>(FLAGS_clear_type);
+  config.var_decay_rate = static_cast<float>(FLAGS_clear_alpha);
+  config.var_window_size = FLAGS_clear_window;
+  config.analysis_rate = FLAGS_ana_rate;
+  config.gain_change_limit = FLAGS_gain_limit;
+  IntelligibilityEnhancer enh(config);
 
   // Slice the input into smaller chunks, as the APM would do, and feed them
   // through the enhancer.
@@ -120,8 +122,8 @@
   float* noise_cursor = &noise_fpcm[0];
 
   for (size_t i = 0; i < samples; i += fragment_size) {
-    enh.ProcessCaptureAudio(&noise_cursor);
-    enh.ProcessRenderAudio(&clear_cursor);
+    enh.AnalyzeCaptureAudio(&noise_cursor, FLAGS_sample_rate, kNumChannels);
+    enh.ProcessRenderAudio(&clear_cursor, FLAGS_sample_rate, kNumChannels);
     clear_cursor += fragment_size;
     noise_cursor += fragment_size;
   }
diff --git a/webrtc/modules/audio_processing/test/audio_processing_unittest.cc b/webrtc/modules/audio_processing/test/audio_processing_unittest.cc
index 3030182..8384c36 100644
--- a/webrtc/modules/audio_processing/test/audio_processing_unittest.cc
+++ b/webrtc/modules/audio_processing/test/audio_processing_unittest.cc
@@ -40,6 +40,9 @@
 namespace webrtc {
 namespace {
 
+// TODO(ekmeyerson): Switch to using StreamConfig and ProcessingConfig where
+// applicable.
+
 // TODO(bjornv): This is not feasible until the functionality has been
 // re-implemented; see comment at the bottom of this file. For now, the user has
 // to hard code the |write_ref_data| value.
@@ -62,6 +65,8 @@
 const size_t kProcessSampleRatesSize = sizeof(kProcessSampleRates) /
     sizeof(*kProcessSampleRates);
 
+enum StreamDirection { kForward = 0, kReverse };
+
 void ConvertToFloat(const int16_t* int_data, ChannelBuffer<float>* cb) {
   ChannelBuffer<int16_t> cb_int(cb->num_frames(),
                                 cb->num_channels());
@@ -252,13 +257,16 @@
 std::string OutputFilePath(std::string name,
                            int input_rate,
                            int output_rate,
-                           int reverse_rate,
+                           int reverse_input_rate,
+                           int reverse_output_rate,
                            int num_input_channels,
                            int num_output_channels,
-                           int num_reverse_channels) {
+                           int num_reverse_input_channels,
+                           int num_reverse_output_channels,
+                           StreamDirection file_direction) {
   std::ostringstream ss;
-  ss << name << "_i" << num_input_channels << "_" << input_rate / 1000
-     << "_r" << num_reverse_channels << "_" << reverse_rate  / 1000 << "_";
+  ss << name << "_i" << num_input_channels << "_" << input_rate / 1000 << "_ir"
+     << num_reverse_input_channels << "_" << reverse_input_rate / 1000 << "_";
   if (num_output_channels == 1) {
     ss << "mono";
   } else if (num_output_channels == 2) {
@@ -266,7 +274,16 @@
   } else {
     assert(false);
   }
-  ss << output_rate / 1000 << "_pcm";
+  ss << output_rate / 1000;
+  if (num_reverse_output_channels == 1) {
+    ss << "_rmono";
+  } else if (num_reverse_output_channels == 2) {
+    ss << "_rstereo";
+  } else {
+    assert(false);
+  }
+  ss << reverse_output_rate / 1000;
+  ss << "_d" << file_direction << "_pcm";
 
   std::string filename = ss.str();
   if (temp_filenames[filename].empty())
@@ -340,9 +357,9 @@
   void Init(int sample_rate_hz,
             int output_sample_rate_hz,
             int reverse_sample_rate_hz,
-            int num_reverse_channels,
             int num_input_channels,
             int num_output_channels,
+            int num_reverse_channels,
             bool open_output_file);
   void Init(AudioProcessing* ap);
   void EnableAllComponents();
@@ -458,6 +475,7 @@
             ap->Initialize(
                 {{{frame_->sample_rate_hz_, frame_->num_channels_},
                   {output_sample_rate_hz_, num_output_channels_},
+                  {revframe_->sample_rate_hz_, revframe_->num_channels_},
                   {revframe_->sample_rate_hz_, revframe_->num_channels_}}}));
 }
 
@@ -496,13 +514,10 @@
     if (out_file_) {
       ASSERT_EQ(0, fclose(out_file_));
     }
-    filename = OutputFilePath("out",
-                              sample_rate_hz,
-                              output_sample_rate_hz,
-                              reverse_sample_rate_hz,
-                              num_input_channels,
-                              num_output_channels,
-                              num_reverse_channels);
+    filename = OutputFilePath(
+        "out", sample_rate_hz, output_sample_rate_hz, reverse_sample_rate_hz,
+        reverse_sample_rate_hz, num_input_channels, num_output_channels,
+        num_reverse_channels, num_reverse_channels, kForward);
     out_file_ = fopen(filename.c_str(), "wb");
     ASSERT_TRUE(out_file_ != NULL) << "Could not open file " <<
           filename << "\n";
@@ -819,13 +834,16 @@
     int num_rev_channels,
     AudioProcessing::Error expected_return) {
   const ProcessingConfig processing_config = {
-      {{ frame_->sample_rate_hz_, apm_->num_input_channels() },
-       { output_sample_rate_hz_, apm_->num_output_channels() },
-       { frame_->sample_rate_hz_, num_rev_channels }}};
+      {{frame_->sample_rate_hz_, apm_->num_input_channels()},
+       {output_sample_rate_hz_, apm_->num_output_channels()},
+       {frame_->sample_rate_hz_, num_rev_channels},
+       {frame_->sample_rate_hz_, num_rev_channels}}};
 
-  EXPECT_EQ(expected_return,
-            apm_->AnalyzeReverseStream(float_cb_->channels(),
-                                       processing_config.reverse_stream()));
+  EXPECT_EQ(
+      expected_return,
+      apm_->ProcessReverseStream(
+          float_cb_->channels(), processing_config.reverse_input_stream(),
+          processing_config.reverse_output_stream(), float_cb_->channels()));
 }
 
 TEST_F(ApmTest, ChannelsInt16Interface) {
@@ -1531,6 +1549,8 @@
     for (int j = 0; j < 1000; j++) {
       EXPECT_EQ(apm_->kNoError, apm_->ProcessStream(frame_));
       EXPECT_TRUE(FrameDataAreEqual(*frame_, frame_copy));
+      EXPECT_EQ(apm_->kNoError, apm_->ProcessReverseStream(frame_));
+      EXPECT_TRUE(FrameDataAreEqual(*frame_, frame_copy));
     }
   }
 }
@@ -1555,6 +1575,19 @@
   for (size_t i = 0; i < kSamples; ++i) {
     EXPECT_EQ(src[i], dest[i]);
   }
+
+  // Same for ProcessReverseStream.
+  float rev_dest[kSamples] = {};
+  auto rev_dest_channels = &rev_dest[0];
+
+  StreamConfig input_stream = {sample_rate, 1};
+  StreamConfig output_stream = {sample_rate, 1};
+  EXPECT_NOERR(apm_->ProcessReverseStream(&src_channels, input_stream,
+                                          output_stream, &rev_dest_channels));
+
+  for (size_t i = 0; i < kSamples; ++i) {
+    EXPECT_EQ(src[i], rev_dest[i]);
+  }
 }
 
 TEST_F(ApmTest, IdenticalInputChannelsResultInIdenticalOutputChannels) {
@@ -2299,15 +2332,18 @@
 // Due to the resampling distortion, we don't expect identical results, but
 // enforce SNR thresholds which vary depending on the format. 0 is a special
 // case SNR which corresponds to inf, or zero error.
-typedef std::tr1::tuple<int, int, int, double> AudioProcessingTestData;
+typedef std::tr1::tuple<int, int, int, int, double, double>
+    AudioProcessingTestData;
 class AudioProcessingTest
     : public testing::TestWithParam<AudioProcessingTestData> {
  public:
   AudioProcessingTest()
       : input_rate_(std::tr1::get<0>(GetParam())),
         output_rate_(std::tr1::get<1>(GetParam())),
-        reverse_rate_(std::tr1::get<2>(GetParam())),
-        expected_snr_(std::tr1::get<3>(GetParam())) {}
+        reverse_input_rate_(std::tr1::get<2>(GetParam())),
+        reverse_output_rate_(std::tr1::get<3>(GetParam())),
+        expected_snr_(std::tr1::get<4>(GetParam())),
+        expected_reverse_snr_(std::tr1::get<5>(GetParam())) {}
 
   virtual ~AudioProcessingTest() {}
 
@@ -2323,13 +2359,9 @@
       for (size_t j = 0; j < kNumChannelsSize; ++j) {
         for (size_t k = 0; k < kNumChannelsSize; ++k) {
           // The reference files always have matching input and output channels.
-          ProcessFormat(kNativeRates[i],
-                        kNativeRates[i],
-                        kNativeRates[i],
-                        kNumChannels[j],
-                        kNumChannels[j],
-                        kNumChannels[k],
-                        "ref");
+          ProcessFormat(kNativeRates[i], kNativeRates[i], kNativeRates[i],
+                        kNativeRates[i], kNumChannels[j], kNumChannels[j],
+                        kNumChannels[k], kNumChannels[k], "ref");
         }
       }
     }
@@ -2338,59 +2370,75 @@
   static void TearDownTestCase() {
     ClearTempFiles();
   }
+
   // Runs a process pass on files with the given parameters and dumps the output
-  // to a file specified with |output_file_prefix|.
+  // to a file specified with |output_file_prefix|. Both forward and reverse
+  // output streams are dumped.
   static void ProcessFormat(int input_rate,
                             int output_rate,
-                            int reverse_rate,
+                            int reverse_input_rate,
+                            int reverse_output_rate,
                             int num_input_channels,
                             int num_output_channels,
-                            int num_reverse_channels,
+                            int num_reverse_input_channels,
+                            int num_reverse_output_channels,
                             std::string output_file_prefix) {
     Config config;
     config.Set<ExperimentalAgc>(new ExperimentalAgc(false));
     rtc::scoped_ptr<AudioProcessing> ap(AudioProcessing::Create(config));
     EnableAllAPComponents(ap.get());
-    ap->Initialize({{{input_rate, num_input_channels},
-                     {output_rate, num_output_channels},
-                     {reverse_rate, num_reverse_channels}}});
 
-    FILE* far_file = fopen(ResourceFilePath("far", reverse_rate).c_str(), "rb");
+    ProcessingConfig processing_config = {
+        {{input_rate, num_input_channels},
+         {output_rate, num_output_channels},
+         {reverse_input_rate, num_reverse_input_channels},
+         {reverse_output_rate, num_reverse_output_channels}}};
+    ap->Initialize(processing_config);
+
+    FILE* far_file =
+        fopen(ResourceFilePath("far", reverse_input_rate).c_str(), "rb");
     FILE* near_file = fopen(ResourceFilePath("near", input_rate).c_str(), "rb");
-    FILE* out_file = fopen(OutputFilePath(output_file_prefix,
-                                          input_rate,
-                                          output_rate,
-                                          reverse_rate,
-                                          num_input_channels,
-                                          num_output_channels,
-                                          num_reverse_channels).c_str(), "wb");
+    FILE* out_file =
+        fopen(OutputFilePath(output_file_prefix, input_rate, output_rate,
+                             reverse_input_rate, reverse_output_rate,
+                             num_input_channels, num_output_channels,
+                             num_reverse_input_channels,
+                             num_reverse_output_channels, kForward).c_str(),
+              "wb");
+    FILE* rev_out_file =
+        fopen(OutputFilePath(output_file_prefix, input_rate, output_rate,
+                             reverse_input_rate, reverse_output_rate,
+                             num_input_channels, num_output_channels,
+                             num_reverse_input_channels,
+                             num_reverse_output_channels, kReverse).c_str(),
+              "wb");
     ASSERT_TRUE(far_file != NULL);
     ASSERT_TRUE(near_file != NULL);
     ASSERT_TRUE(out_file != NULL);
+    ASSERT_TRUE(rev_out_file != NULL);
 
     ChannelBuffer<float> fwd_cb(SamplesFromRate(input_rate),
                                 num_input_channels);
-    ChannelBuffer<float> rev_cb(SamplesFromRate(reverse_rate),
-                                num_reverse_channels);
+    ChannelBuffer<float> rev_cb(SamplesFromRate(reverse_input_rate),
+                                num_reverse_input_channels);
     ChannelBuffer<float> out_cb(SamplesFromRate(output_rate),
                                 num_output_channels);
+    ChannelBuffer<float> rev_out_cb(SamplesFromRate(reverse_output_rate),
+                                    num_reverse_output_channels);
 
     // Temporary buffers.
     const int max_length =
-        2 * std::max(out_cb.num_frames(),
-                     std::max(fwd_cb.num_frames(),
-                              rev_cb.num_frames()));
+        2 * std::max(std::max(out_cb.num_frames(), rev_out_cb.num_frames()),
+                     std::max(fwd_cb.num_frames(), rev_cb.num_frames()));
     rtc::scoped_ptr<float[]> float_data(new float[max_length]);
     rtc::scoped_ptr<int16_t[]> int_data(new int16_t[max_length]);
 
     int analog_level = 127;
     while (ReadChunk(far_file, int_data.get(), float_data.get(), &rev_cb) &&
            ReadChunk(near_file, int_data.get(), float_data.get(), &fwd_cb)) {
-      EXPECT_NOERR(ap->AnalyzeReverseStream(
-          rev_cb.channels(),
-          rev_cb.num_frames(),
-          reverse_rate,
-          LayoutFromChannels(num_reverse_channels)));
+      EXPECT_NOERR(ap->ProcessReverseStream(
+          rev_cb.channels(), processing_config.reverse_input_stream(),
+          processing_config.reverse_output_stream(), rev_out_cb.channels()));
 
       EXPECT_NOERR(ap->set_stream_delay_ms(0));
       ap->echo_cancellation()->set_stream_drift_samples(0);
@@ -2405,274 +2453,293 @@
           LayoutFromChannels(num_output_channels),
           out_cb.channels()));
 
-      Interleave(out_cb.channels(),
-                 out_cb.num_frames(),
-                 out_cb.num_channels(),
+      // Dump forward output to file.
+      Interleave(out_cb.channels(), out_cb.num_frames(), out_cb.num_channels(),
                  float_data.get());
-      // Dump output to file.
       int out_length = out_cb.num_channels() * out_cb.num_frames();
+
       ASSERT_EQ(static_cast<size_t>(out_length),
                 fwrite(float_data.get(), sizeof(float_data[0]),
                        out_length, out_file));
 
+      // Dump reverse output to file.
+      Interleave(rev_out_cb.channels(), rev_out_cb.num_frames(),
+                 rev_out_cb.num_channels(), float_data.get());
+      int rev_out_length = rev_out_cb.num_channels() * rev_out_cb.num_frames();
+
+      ASSERT_EQ(static_cast<size_t>(rev_out_length),
+                fwrite(float_data.get(), sizeof(float_data[0]), rev_out_length,
+                       rev_out_file));
+
       analog_level = ap->gain_control()->stream_analog_level();
     }
     fclose(far_file);
     fclose(near_file);
     fclose(out_file);
+    fclose(rev_out_file);
   }
 
  protected:
   int input_rate_;
   int output_rate_;
-  int reverse_rate_;
+  int reverse_input_rate_;
+  int reverse_output_rate_;
   double expected_snr_;
+  double expected_reverse_snr_;
 };
 
 TEST_P(AudioProcessingTest, Formats) {
   struct ChannelFormat {
     int num_input;
     int num_output;
-    int num_reverse;
+    int num_reverse_input;
+    int num_reverse_output;
   };
   ChannelFormat cf[] = {
-    {1, 1, 1},
-    {1, 1, 2},
-    {2, 1, 1},
-    {2, 1, 2},
-    {2, 2, 1},
-    {2, 2, 2},
+      {1, 1, 1, 1},
+      {1, 1, 2, 1},
+      {2, 1, 1, 1},
+      {2, 1, 2, 1},
+      {2, 2, 1, 1},
+      {2, 2, 2, 2},
   };
   size_t channel_format_size = sizeof(cf) / sizeof(*cf);
 
   for (size_t i = 0; i < channel_format_size; ++i) {
-    ProcessFormat(input_rate_,
-                  output_rate_,
-                  reverse_rate_,
-                  cf[i].num_input,
-                  cf[i].num_output,
-                  cf[i].num_reverse,
-                  "out");
-    int min_ref_rate = std::min(input_rate_, output_rate_);
-    int ref_rate;
+    ProcessFormat(input_rate_, output_rate_, reverse_input_rate_,
+                  reverse_output_rate_, cf[i].num_input, cf[i].num_output,
+                  cf[i].num_reverse_input, cf[i].num_reverse_output, "out");
 
-    if (min_ref_rate > 32000) {
-      ref_rate = 48000;
-    } else if (min_ref_rate > 16000) {
-      ref_rate = 32000;
-    } else if (min_ref_rate > 8000) {
-      ref_rate = 16000;
-    } else {
-      ref_rate = 8000;
-    }
+    // Verify output for both directions.
+    std::vector<StreamDirection> stream_directions;
+    stream_directions.push_back(kForward);
+    stream_directions.push_back(kReverse);
+    for (StreamDirection file_direction : stream_directions) {
+      const int in_rate = file_direction ? reverse_input_rate_ : input_rate_;
+      const int out_rate = file_direction ? reverse_output_rate_ : output_rate_;
+      const int out_num =
+          file_direction ? cf[i].num_reverse_output : cf[i].num_output;
+      const double expected_snr =
+          file_direction ? expected_reverse_snr_ : expected_snr_;
+
+      const int min_ref_rate = std::min(in_rate, out_rate);
+      int ref_rate;
+
+      if (min_ref_rate > 32000) {
+        ref_rate = 48000;
+      } else if (min_ref_rate > 16000) {
+        ref_rate = 32000;
+      } else if (min_ref_rate > 8000) {
+        ref_rate = 16000;
+      } else {
+        ref_rate = 8000;
+      }
 #ifdef WEBRTC_AUDIOPROC_FIXED_PROFILE
-    ref_rate = std::min(ref_rate, 16000);
+      if (file_direction == kForward) {
+        ref_rate = std::min(ref_rate, 16000);
+      }
 #endif
+      FILE* out_file = fopen(
+          OutputFilePath("out", input_rate_, output_rate_, reverse_input_rate_,
+                         reverse_output_rate_, cf[i].num_input,
+                         cf[i].num_output, cf[i].num_reverse_input,
+                         cf[i].num_reverse_output, file_direction).c_str(),
+          "rb");
+      // The reference files always have matching input and output channels.
+      FILE* ref_file = fopen(
+          OutputFilePath("ref", ref_rate, ref_rate, ref_rate, ref_rate,
+                         cf[i].num_output, cf[i].num_output,
+                         cf[i].num_reverse_output, cf[i].num_reverse_output,
+                         file_direction).c_str(),
+          "rb");
+      ASSERT_TRUE(out_file != NULL);
+      ASSERT_TRUE(ref_file != NULL);
 
-    FILE* out_file = fopen(OutputFilePath("out",
-                                          input_rate_,
-                                          output_rate_,
-                                          reverse_rate_,
-                                          cf[i].num_input,
-                                          cf[i].num_output,
-                                          cf[i].num_reverse).c_str(), "rb");
-    // The reference files always have matching input and output channels.
-    FILE* ref_file = fopen(OutputFilePath("ref",
-                                          ref_rate,
-                                          ref_rate,
-                                          ref_rate,
-                                          cf[i].num_output,
-                                          cf[i].num_output,
-                                          cf[i].num_reverse).c_str(), "rb");
-    ASSERT_TRUE(out_file != NULL);
-    ASSERT_TRUE(ref_file != NULL);
+      const int ref_length = SamplesFromRate(ref_rate) * out_num;
+      const int out_length = SamplesFromRate(out_rate) * out_num;
+      // Data from the reference file.
+      rtc::scoped_ptr<float[]> ref_data(new float[ref_length]);
+      // Data from the output file.
+      rtc::scoped_ptr<float[]> out_data(new float[out_length]);
+      // Data from the resampled output, in case the reference and output rates
+      // don't match.
+      rtc::scoped_ptr<float[]> cmp_data(new float[ref_length]);
 
-    const int ref_length = SamplesFromRate(ref_rate) * cf[i].num_output;
-    const int out_length = SamplesFromRate(output_rate_) * cf[i].num_output;
-    // Data from the reference file.
-    rtc::scoped_ptr<float[]> ref_data(new float[ref_length]);
-    // Data from the output file.
-    rtc::scoped_ptr<float[]> out_data(new float[out_length]);
-    // Data from the resampled output, in case the reference and output rates
-    // don't match.
-    rtc::scoped_ptr<float[]> cmp_data(new float[ref_length]);
+      PushResampler<float> resampler;
+      resampler.InitializeIfNeeded(out_rate, ref_rate, out_num);
 
-    PushResampler<float> resampler;
-    resampler.InitializeIfNeeded(output_rate_, ref_rate, cf[i].num_output);
+      // Compute the resampling delay of the output relative to the reference,
+      // to find the region over which we should search for the best SNR.
+      float expected_delay_sec = 0;
+      if (in_rate != ref_rate) {
+        // Input resampling delay.
+        expected_delay_sec +=
+            PushSincResampler::AlgorithmicDelaySeconds(in_rate);
+      }
+      if (out_rate != ref_rate) {
+        // Output resampling delay.
+        expected_delay_sec +=
+            PushSincResampler::AlgorithmicDelaySeconds(ref_rate);
+        // Delay of converting the output back to its processing rate for
+        // testing.
+        expected_delay_sec +=
+            PushSincResampler::AlgorithmicDelaySeconds(out_rate);
+      }
+      int expected_delay =
+          floor(expected_delay_sec * ref_rate + 0.5f) * out_num;
 
-    // Compute the resampling delay of the output relative to the reference,
-    // to find the region over which we should search for the best SNR.
-    float expected_delay_sec = 0;
-    if (input_rate_ != ref_rate) {
-      // Input resampling delay.
-      expected_delay_sec +=
-          PushSincResampler::AlgorithmicDelaySeconds(input_rate_);
-    }
-    if (output_rate_ != ref_rate) {
-      // Output resampling delay.
-      expected_delay_sec +=
-          PushSincResampler::AlgorithmicDelaySeconds(ref_rate);
-      // Delay of converting the output back to its processing rate for testing.
-      expected_delay_sec +=
-          PushSincResampler::AlgorithmicDelaySeconds(output_rate_);
-    }
-    int expected_delay = floor(expected_delay_sec * ref_rate + 0.5f) *
-                         cf[i].num_output;
+      double variance = 0;
+      double sq_error = 0;
+      while (fread(out_data.get(), sizeof(out_data[0]), out_length, out_file) &&
+             fread(ref_data.get(), sizeof(ref_data[0]), ref_length, ref_file)) {
+        float* out_ptr = out_data.get();
+        if (out_rate != ref_rate) {
+          // Resample the output back to its internal processing rate if
+          // necssary.
+          ASSERT_EQ(ref_length, resampler.Resample(out_ptr, out_length,
+                                                   cmp_data.get(), ref_length));
+          out_ptr = cmp_data.get();
+        }
 
-    double variance = 0;
-    double sq_error = 0;
-    while (fread(out_data.get(), sizeof(out_data[0]), out_length, out_file) &&
-           fread(ref_data.get(), sizeof(ref_data[0]), ref_length, ref_file)) {
-      float* out_ptr = out_data.get();
-      if (output_rate_ != ref_rate) {
-        // Resample the output back to its internal processing rate if necssary.
-        ASSERT_EQ(ref_length, resampler.Resample(out_ptr,
-                                                 out_length,
-                                                 cmp_data.get(),
-                                                 ref_length));
-        out_ptr = cmp_data.get();
+        // Update the |sq_error| and |variance| accumulators with the highest
+        // SNR of reference vs output.
+        UpdateBestSNR(ref_data.get(), out_ptr, ref_length, expected_delay,
+                      &variance, &sq_error);
       }
 
-      // Update the |sq_error| and |variance| accumulators with the highest SNR
-      // of reference vs output.
-      UpdateBestSNR(ref_data.get(),
-                    out_ptr,
-                    ref_length,
-                    expected_delay,
-                    &variance,
-                    &sq_error);
-    }
+      std::cout << "(" << input_rate_ << ", " << output_rate_ << ", "
+                << reverse_input_rate_ << ", " << reverse_output_rate_ << ", "
+                << cf[i].num_input << ", " << cf[i].num_output << ", "
+                << cf[i].num_reverse_input << ", " << cf[i].num_reverse_output
+                << ", " << file_direction << "): ";
+      if (sq_error > 0) {
+        double snr = 10 * log10(variance / sq_error);
+        EXPECT_GE(snr, expected_snr);
+        EXPECT_NE(0, expected_snr);
+        std::cout << "SNR=" << snr << " dB" << std::endl;
+      } else {
+        EXPECT_EQ(expected_snr, 0);
+        std::cout << "SNR="
+                  << "inf dB" << std::endl;
+      }
 
-    std::cout << "(" << input_rate_ << ", "
-                     << output_rate_ << ", "
-                     << reverse_rate_ << ", "
-                     << cf[i].num_input << ", "
-                     << cf[i].num_output << ", "
-                     << cf[i].num_reverse << "): ";
-    if (sq_error > 0) {
-      double snr = 10 * log10(variance / sq_error);
-      EXPECT_GE(snr, expected_snr_);
-      EXPECT_NE(0, expected_snr_);
-      std::cout << "SNR=" << snr << " dB" << std::endl;
-    } else {
-      EXPECT_EQ(expected_snr_, 0);
-      std::cout << "SNR=" << "inf dB" << std::endl;
+      fclose(out_file);
+      fclose(ref_file);
     }
-
-    fclose(out_file);
-    fclose(ref_file);
   }
 }
 
 #if defined(WEBRTC_AUDIOPROC_FLOAT_PROFILE)
 INSTANTIATE_TEST_CASE_P(
-    CommonFormats, AudioProcessingTest, testing::Values(
-        std::tr1::make_tuple(48000, 48000, 48000, 0),
-        std::tr1::make_tuple(48000, 48000, 32000, 40),
-        std::tr1::make_tuple(48000, 48000, 16000, 40),
-        std::tr1::make_tuple(48000, 44100, 48000, 20),
-        std::tr1::make_tuple(48000, 44100, 32000, 20),
-        std::tr1::make_tuple(48000, 44100, 16000, 20),
-        std::tr1::make_tuple(48000, 32000, 48000, 30),
-        std::tr1::make_tuple(48000, 32000, 32000, 30),
-        std::tr1::make_tuple(48000, 32000, 16000, 30),
-        std::tr1::make_tuple(48000, 16000, 48000, 25),
-        std::tr1::make_tuple(48000, 16000, 32000, 25),
-        std::tr1::make_tuple(48000, 16000, 16000, 25),
+    CommonFormats,
+    AudioProcessingTest,
+    testing::Values(std::tr1::make_tuple(48000, 48000, 48000, 48000, 0, 0),
+                    std::tr1::make_tuple(48000, 48000, 32000, 48000, 40, 30),
+                    std::tr1::make_tuple(48000, 48000, 16000, 48000, 40, 20),
+                    std::tr1::make_tuple(48000, 44100, 48000, 44100, 20, 20),
+                    std::tr1::make_tuple(48000, 44100, 32000, 44100, 20, 15),
+                    std::tr1::make_tuple(48000, 44100, 16000, 44100, 20, 15),
+                    std::tr1::make_tuple(48000, 32000, 48000, 32000, 30, 35),
+                    std::tr1::make_tuple(48000, 32000, 32000, 32000, 30, 0),
+                    std::tr1::make_tuple(48000, 32000, 16000, 32000, 30, 20),
+                    std::tr1::make_tuple(48000, 16000, 48000, 16000, 25, 20),
+                    std::tr1::make_tuple(48000, 16000, 32000, 16000, 25, 20),
+                    std::tr1::make_tuple(48000, 16000, 16000, 16000, 25, 0),
 
-        std::tr1::make_tuple(44100, 48000, 48000, 30),
-        std::tr1::make_tuple(44100, 48000, 32000, 30),
-        std::tr1::make_tuple(44100, 48000, 16000, 30),
-        std::tr1::make_tuple(44100, 44100, 48000, 20),
-        std::tr1::make_tuple(44100, 44100, 32000, 20),
-        std::tr1::make_tuple(44100, 44100, 16000, 20),
-        std::tr1::make_tuple(44100, 32000, 48000, 30),
-        std::tr1::make_tuple(44100, 32000, 32000, 30),
-        std::tr1::make_tuple(44100, 32000, 16000, 30),
-        std::tr1::make_tuple(44100, 16000, 48000, 25),
-        std::tr1::make_tuple(44100, 16000, 32000, 25),
-        std::tr1::make_tuple(44100, 16000, 16000, 25),
+                    std::tr1::make_tuple(44100, 48000, 48000, 48000, 30, 0),
+                    std::tr1::make_tuple(44100, 48000, 32000, 48000, 30, 30),
+                    std::tr1::make_tuple(44100, 48000, 16000, 48000, 30, 20),
+                    std::tr1::make_tuple(44100, 44100, 48000, 44100, 20, 20),
+                    std::tr1::make_tuple(44100, 44100, 32000, 44100, 20, 15),
+                    std::tr1::make_tuple(44100, 44100, 16000, 44100, 20, 15),
+                    std::tr1::make_tuple(44100, 32000, 48000, 32000, 30, 35),
+                    std::tr1::make_tuple(44100, 32000, 32000, 32000, 30, 0),
+                    std::tr1::make_tuple(44100, 32000, 16000, 32000, 30, 20),
+                    std::tr1::make_tuple(44100, 16000, 48000, 16000, 25, 20),
+                    std::tr1::make_tuple(44100, 16000, 32000, 16000, 25, 20),
+                    std::tr1::make_tuple(44100, 16000, 16000, 16000, 25, 0),
 
-        std::tr1::make_tuple(32000, 48000, 48000, 30),
-        std::tr1::make_tuple(32000, 48000, 32000, 35),
-        std::tr1::make_tuple(32000, 48000, 16000, 30),
-        std::tr1::make_tuple(32000, 44100, 48000, 20),
-        std::tr1::make_tuple(32000, 44100, 32000, 20),
-        std::tr1::make_tuple(32000, 44100, 16000, 20),
-        std::tr1::make_tuple(32000, 32000, 48000, 40),
-        std::tr1::make_tuple(32000, 32000, 32000, 0),
-        std::tr1::make_tuple(32000, 32000, 16000, 40),
-        std::tr1::make_tuple(32000, 16000, 48000, 25),
-        std::tr1::make_tuple(32000, 16000, 32000, 25),
-        std::tr1::make_tuple(32000, 16000, 16000, 25),
+                    std::tr1::make_tuple(32000, 48000, 48000, 48000, 30, 0),
+                    std::tr1::make_tuple(32000, 48000, 32000, 48000, 35, 30),
+                    std::tr1::make_tuple(32000, 48000, 16000, 48000, 30, 20),
+                    std::tr1::make_tuple(32000, 44100, 48000, 44100, 20, 20),
+                    std::tr1::make_tuple(32000, 44100, 32000, 44100, 20, 15),
+                    std::tr1::make_tuple(32000, 44100, 16000, 44100, 20, 15),
+                    std::tr1::make_tuple(32000, 32000, 48000, 32000, 40, 35),
+                    std::tr1::make_tuple(32000, 32000, 32000, 32000, 0, 0),
+                    std::tr1::make_tuple(32000, 32000, 16000, 32000, 40, 20),
+                    std::tr1::make_tuple(32000, 16000, 48000, 16000, 25, 20),
+                    std::tr1::make_tuple(32000, 16000, 32000, 16000, 25, 20),
+                    std::tr1::make_tuple(32000, 16000, 16000, 16000, 25, 0),
 
-        std::tr1::make_tuple(16000, 48000, 48000, 25),
-        std::tr1::make_tuple(16000, 48000, 32000, 25),
-        std::tr1::make_tuple(16000, 48000, 16000, 25),
-        std::tr1::make_tuple(16000, 44100, 48000, 15),
-        std::tr1::make_tuple(16000, 44100, 32000, 15),
-        std::tr1::make_tuple(16000, 44100, 16000, 15),
-        std::tr1::make_tuple(16000, 32000, 48000, 25),
-        std::tr1::make_tuple(16000, 32000, 32000, 25),
-        std::tr1::make_tuple(16000, 32000, 16000, 25),
-        std::tr1::make_tuple(16000, 16000, 48000, 40),
-        std::tr1::make_tuple(16000, 16000, 32000, 50),
-        std::tr1::make_tuple(16000, 16000, 16000, 0)));
+                    std::tr1::make_tuple(16000, 48000, 48000, 48000, 25, 0),
+                    std::tr1::make_tuple(16000, 48000, 32000, 48000, 25, 30),
+                    std::tr1::make_tuple(16000, 48000, 16000, 48000, 25, 20),
+                    std::tr1::make_tuple(16000, 44100, 48000, 44100, 15, 20),
+                    std::tr1::make_tuple(16000, 44100, 32000, 44100, 15, 15),
+                    std::tr1::make_tuple(16000, 44100, 16000, 44100, 15, 15),
+                    std::tr1::make_tuple(16000, 32000, 48000, 32000, 25, 35),
+                    std::tr1::make_tuple(16000, 32000, 32000, 32000, 25, 0),
+                    std::tr1::make_tuple(16000, 32000, 16000, 32000, 25, 20),
+                    std::tr1::make_tuple(16000, 16000, 48000, 16000, 40, 20),
+                    std::tr1::make_tuple(16000, 16000, 32000, 16000, 50, 20),
+                    std::tr1::make_tuple(16000, 16000, 16000, 16000, 0, 0)));
 
 #elif defined(WEBRTC_AUDIOPROC_FIXED_PROFILE)
 INSTANTIATE_TEST_CASE_P(
-    CommonFormats, AudioProcessingTest, testing::Values(
-        std::tr1::make_tuple(48000, 48000, 48000, 20),
-        std::tr1::make_tuple(48000, 48000, 32000, 20),
-        std::tr1::make_tuple(48000, 48000, 16000, 20),
-        std::tr1::make_tuple(48000, 44100, 48000, 15),
-        std::tr1::make_tuple(48000, 44100, 32000, 15),
-        std::tr1::make_tuple(48000, 44100, 16000, 15),
-        std::tr1::make_tuple(48000, 32000, 48000, 20),
-        std::tr1::make_tuple(48000, 32000, 32000, 20),
-        std::tr1::make_tuple(48000, 32000, 16000, 20),
-        std::tr1::make_tuple(48000, 16000, 48000, 20),
-        std::tr1::make_tuple(48000, 16000, 32000, 20),
-        std::tr1::make_tuple(48000, 16000, 16000, 20),
+    CommonFormats,
+    AudioProcessingTest,
+    testing::Values(std::tr1::make_tuple(48000, 48000, 48000, 48000, 20, 0),
+                    std::tr1::make_tuple(48000, 48000, 32000, 48000, 20, 30),
+                    std::tr1::make_tuple(48000, 48000, 16000, 48000, 20, 20),
+                    std::tr1::make_tuple(48000, 44100, 48000, 44100, 15, 20),
+                    std::tr1::make_tuple(48000, 44100, 32000, 44100, 15, 15),
+                    std::tr1::make_tuple(48000, 44100, 16000, 44100, 15, 15),
+                    std::tr1::make_tuple(48000, 32000, 48000, 32000, 20, 35),
+                    std::tr1::make_tuple(48000, 32000, 32000, 32000, 20, 0),
+                    std::tr1::make_tuple(48000, 32000, 16000, 32000, 20, 20),
+                    std::tr1::make_tuple(48000, 16000, 48000, 16000, 20, 20),
+                    std::tr1::make_tuple(48000, 16000, 32000, 16000, 20, 20),
+                    std::tr1::make_tuple(48000, 16000, 16000, 16000, 20, 0),
 
-        std::tr1::make_tuple(44100, 48000, 48000, 20),
-        std::tr1::make_tuple(44100, 48000, 32000, 20),
-        std::tr1::make_tuple(44100, 48000, 16000, 20),
-        std::tr1::make_tuple(44100, 44100, 48000, 15),
-        std::tr1::make_tuple(44100, 44100, 32000, 15),
-        std::tr1::make_tuple(44100, 44100, 16000, 15),
-        std::tr1::make_tuple(44100, 32000, 48000, 20),
-        std::tr1::make_tuple(44100, 32000, 32000, 20),
-        std::tr1::make_tuple(44100, 32000, 16000, 20),
-        std::tr1::make_tuple(44100, 16000, 48000, 20),
-        std::tr1::make_tuple(44100, 16000, 32000, 20),
-        std::tr1::make_tuple(44100, 16000, 16000, 20),
+                    std::tr1::make_tuple(44100, 48000, 48000, 48000, 20, 0),
+                    std::tr1::make_tuple(44100, 48000, 32000, 48000, 20, 30),
+                    std::tr1::make_tuple(44100, 48000, 16000, 48000, 20, 20),
+                    std::tr1::make_tuple(44100, 44100, 48000, 44100, 15, 20),
+                    std::tr1::make_tuple(44100, 44100, 32000, 44100, 15, 15),
+                    std::tr1::make_tuple(44100, 44100, 16000, 44100, 15, 15),
+                    std::tr1::make_tuple(44100, 32000, 48000, 32000, 20, 35),
+                    std::tr1::make_tuple(44100, 32000, 32000, 32000, 20, 0),
+                    std::tr1::make_tuple(44100, 32000, 16000, 32000, 20, 20),
+                    std::tr1::make_tuple(44100, 16000, 48000, 16000, 20, 20),
+                    std::tr1::make_tuple(44100, 16000, 32000, 16000, 20, 20),
+                    std::tr1::make_tuple(44100, 16000, 16000, 16000, 20, 0),
 
-        std::tr1::make_tuple(32000, 48000, 48000, 20),
-        std::tr1::make_tuple(32000, 48000, 32000, 20),
-        std::tr1::make_tuple(32000, 48000, 16000, 20),
-        std::tr1::make_tuple(32000, 44100, 48000, 15),
-        std::tr1::make_tuple(32000, 44100, 32000, 15),
-        std::tr1::make_tuple(32000, 44100, 16000, 15),
-        std::tr1::make_tuple(32000, 32000, 48000, 20),
-        std::tr1::make_tuple(32000, 32000, 32000, 20),
-        std::tr1::make_tuple(32000, 32000, 16000, 20),
-        std::tr1::make_tuple(32000, 16000, 48000, 20),
-        std::tr1::make_tuple(32000, 16000, 32000, 20),
-        std::tr1::make_tuple(32000, 16000, 16000, 20),
+                    std::tr1::make_tuple(32000, 48000, 48000, 48000, 20, 0),
+                    std::tr1::make_tuple(32000, 48000, 32000, 48000, 20, 30),
+                    std::tr1::make_tuple(32000, 48000, 16000, 48000, 20, 20),
+                    std::tr1::make_tuple(32000, 44100, 48000, 44100, 15, 20),
+                    std::tr1::make_tuple(32000, 44100, 32000, 44100, 15, 15),
+                    std::tr1::make_tuple(32000, 44100, 16000, 44100, 15, 15),
+                    std::tr1::make_tuple(32000, 32000, 48000, 32000, 20, 35),
+                    std::tr1::make_tuple(32000, 32000, 32000, 32000, 20, 0),
+                    std::tr1::make_tuple(32000, 32000, 16000, 32000, 20, 20),
+                    std::tr1::make_tuple(32000, 16000, 48000, 16000, 20, 20),
+                    std::tr1::make_tuple(32000, 16000, 32000, 16000, 20, 20),
+                    std::tr1::make_tuple(32000, 16000, 16000, 16000, 20, 0),
 
-        std::tr1::make_tuple(16000, 48000, 48000, 25),
-        std::tr1::make_tuple(16000, 48000, 32000, 25),
-        std::tr1::make_tuple(16000, 48000, 16000, 25),
-        std::tr1::make_tuple(16000, 44100, 48000, 15),
-        std::tr1::make_tuple(16000, 44100, 32000, 15),
-        std::tr1::make_tuple(16000, 44100, 16000, 15),
-        std::tr1::make_tuple(16000, 32000, 48000, 25),
-        std::tr1::make_tuple(16000, 32000, 32000, 25),
-        std::tr1::make_tuple(16000, 32000, 16000, 25),
-        std::tr1::make_tuple(16000, 16000, 48000, 35),
-        std::tr1::make_tuple(16000, 16000, 32000, 40),
-        std::tr1::make_tuple(16000, 16000, 16000, 0)));
+                    std::tr1::make_tuple(16000, 48000, 48000, 48000, 25, 0),
+                    std::tr1::make_tuple(16000, 48000, 32000, 48000, 25, 30),
+                    std::tr1::make_tuple(16000, 48000, 16000, 48000, 25, 20),
+                    std::tr1::make_tuple(16000, 44100, 48000, 44100, 15, 20),
+                    std::tr1::make_tuple(16000, 44100, 32000, 44100, 15, 15),
+                    std::tr1::make_tuple(16000, 44100, 16000, 44100, 15, 15),
+                    std::tr1::make_tuple(16000, 32000, 48000, 32000, 25, 35),
+                    std::tr1::make_tuple(16000, 32000, 32000, 32000, 25, 0),
+                    std::tr1::make_tuple(16000, 32000, 16000, 32000, 25, 20),
+                    std::tr1::make_tuple(16000, 16000, 48000, 16000, 35, 20),
+                    std::tr1::make_tuple(16000, 16000, 32000, 16000, 40, 20),
+                    std::tr1::make_tuple(16000, 16000, 16000, 16000, 0, 0)));
 #endif
 
 // TODO(henrike): re-implement functionality lost when removing the old main
diff --git a/webrtc/modules/audio_processing/test/audioproc_float.cc b/webrtc/modules/audio_processing/test/audioproc_float.cc
index d2983b2..f22c41e 100644
--- a/webrtc/modules/audio_processing/test/audioproc_float.cc
+++ b/webrtc/modules/audio_processing/test/audioproc_float.cc
@@ -25,7 +25,11 @@
 
 DEFINE_string(dump, "", "The name of the debug dump file to read from.");
 DEFINE_string(i, "", "The name of the input file to read from.");
+DEFINE_string(i_rev, "", "The name of the reverse input file to read from.");
 DEFINE_string(o, "out.wav", "Name of the output file to write to.");
+DEFINE_string(o_rev,
+              "out_rev.wav",
+              "Name of the reverse output file to write to.");
 DEFINE_int32(out_channels, 0, "Number of output channels. Defaults to input.");
 DEFINE_int32(out_sample_rate, 0,
              "Output sample rate in Hz. Defaults to input.");
@@ -40,6 +44,7 @@
 DEFINE_bool(ns, false, "Enable noise suppression.");
 DEFINE_bool(ts, false, "Enable transient suppression.");
 DEFINE_bool(bf, false, "Enable beamforming.");
+DEFINE_bool(ie, false, "Enable intelligibility enhancer.");
 DEFINE_bool(all, false, "Enable all components.");
 
 DEFINE_int32(ns_level, -1, "Noise suppression level [0 - 3].");
@@ -85,6 +90,7 @@
 
   Config config;
   config.Set<ExperimentalNs>(new ExperimentalNs(FLAGS_ts || FLAGS_all));
+  config.Set<Intelligibility>(new Intelligibility(FLAGS_ie || FLAGS_all));
 
   if (FLAGS_bf || FLAGS_all) {
     const size_t num_mics = in_file.num_channels();
@@ -102,6 +108,7 @@
     fprintf(stderr, "-aec requires a -dump file.\n");
     return -1;
   }
+  bool process_reverse = !FLAGS_i_rev.empty();
   CHECK_EQ(kNoErr, ap->gain_control()->Enable(FLAGS_agc || FLAGS_all));
   CHECK_EQ(kNoErr, ap->gain_control()->set_mode(GainControl::kFixedDigital));
   CHECK_EQ(kNoErr, ap->high_pass_filter()->Enable(FLAGS_hpf || FLAGS_all));
@@ -124,6 +131,33 @@
 
   std::vector<float> in_interleaved(in_buf.size());
   std::vector<float> out_interleaved(out_buf.size());
+
+  rtc::scoped_ptr<WavReader> in_rev_file;
+  rtc::scoped_ptr<WavWriter> out_rev_file;
+  rtc::scoped_ptr<ChannelBuffer<float>> in_rev_buf;
+  rtc::scoped_ptr<ChannelBuffer<float>> out_rev_buf;
+  std::vector<float> in_rev_interleaved;
+  std::vector<float> out_rev_interleaved;
+  if (process_reverse) {
+    in_rev_file.reset(new WavReader(FLAGS_i_rev));
+    out_rev_file.reset(new WavWriter(FLAGS_o_rev, in_rev_file->sample_rate(),
+                                     in_rev_file->num_channels()));
+    printf("In rev file: %s\nChannels: %d, Sample rate: %d Hz\n\n",
+           FLAGS_i_rev.c_str(), in_rev_file->num_channels(),
+           in_rev_file->sample_rate());
+    printf("Out rev file: %s\nChannels: %d, Sample rate: %d Hz\n\n",
+           FLAGS_o_rev.c_str(), out_rev_file->num_channels(),
+           out_rev_file->sample_rate());
+    in_rev_buf.reset(new ChannelBuffer<float>(
+        rtc::CheckedDivExact(in_rev_file->sample_rate(), kChunksPerSecond),
+        in_rev_file->num_channels()));
+    in_rev_interleaved.resize(in_rev_buf->size());
+    out_rev_buf.reset(new ChannelBuffer<float>(
+        rtc::CheckedDivExact(out_rev_file->sample_rate(), kChunksPerSecond),
+        out_rev_file->num_channels()));
+    out_rev_interleaved.resize(out_rev_buf->size());
+  }
+
   TickTime processing_start_time;
   TickInterval accumulated_time;
   int num_chunks = 0;
@@ -134,6 +168,12 @@
   const StreamConfig output_config = {
       out_file.sample_rate(), out_buf.num_channels(),
   };
+  const StreamConfig reverse_input_config = {
+      in_rev_file->sample_rate(), in_rev_file->num_channels(),
+  };
+  const StreamConfig reverse_output_config = {
+      out_rev_file->sample_rate(), out_rev_file->num_channels(),
+  };
   while (in_file.ReadSamples(in_interleaved.size(),
                              &in_interleaved[0]) == in_interleaved.size()) {
     // Have logs display the file time rather than wallclock time.
@@ -142,12 +182,25 @@
                     &in_interleaved[0]);
     Deinterleave(&in_interleaved[0], in_buf.num_frames(),
                  in_buf.num_channels(), in_buf.channels());
+    if (process_reverse) {
+      in_rev_file->ReadSamples(in_rev_interleaved.size(),
+                               in_rev_interleaved.data());
+      FloatS16ToFloat(in_rev_interleaved.data(), in_rev_interleaved.size(),
+                      in_rev_interleaved.data());
+      Deinterleave(in_rev_interleaved.data(), in_rev_buf->num_frames(),
+                   in_rev_buf->num_channels(), in_rev_buf->channels());
+    }
 
     if (FLAGS_perf) {
       processing_start_time = TickTime::Now();
     }
     CHECK_EQ(kNoErr, ap->ProcessStream(in_buf.channels(), input_config,
                                        output_config, out_buf.channels()));
+    if (process_reverse) {
+      CHECK_EQ(kNoErr, ap->ProcessReverseStream(
+                           in_rev_buf->channels(), reverse_input_config,
+                           reverse_output_config, out_rev_buf->channels()));
+    }
     if (FLAGS_perf) {
       accumulated_time += TickTime::Now() - processing_start_time;
     }
@@ -157,6 +210,14 @@
     FloatToFloatS16(&out_interleaved[0], out_interleaved.size(),
                     &out_interleaved[0]);
     out_file.WriteSamples(&out_interleaved[0], out_interleaved.size());
+    if (process_reverse) {
+      Interleave(out_rev_buf->channels(), out_rev_buf->num_frames(),
+                 out_rev_buf->num_channels(), out_rev_interleaved.data());
+      FloatToFloatS16(out_rev_interleaved.data(), out_rev_interleaved.size(),
+                      out_rev_interleaved.data());
+      out_rev_file->WriteSamples(out_rev_interleaved.data(),
+                                 out_rev_interleaved.size());
+    }
     num_chunks++;
   }
   if (FLAGS_perf) {