src/third_party/webrtc/modules/audio_processing/audio_processing_impl.cc

   1 /*
   2  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include "webrtc/modules/audio_processing/audio_processing_impl.h"
  12
  13 #include <assert.h>
  14
  15 #include "webrtc/common_audio/include/audio_util.h"
  16 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
  17 #include "webrtc/modules/audio_processing/audio_buffer.h"
  18 #include "webrtc/modules/audio_processing/common.h"
  19 #include "webrtc/modules/audio_processing/echo_cancellation_impl.h"
  20 #include "webrtc/modules/audio_processing/echo_control_mobile_impl.h"
  21 #include "webrtc/modules/audio_processing/gain_control_impl.h"
  22 #include "webrtc/modules/audio_processing/high_pass_filter_impl.h"
  23 #include "webrtc/modules/audio_processing/level_estimator_impl.h"
  24 #include "webrtc/modules/audio_processing/noise_suppression_impl.h"
  25 #include "webrtc/modules/audio_processing/processing_component.h"
  26 #include "webrtc/modules/audio_processing/voice_detection_impl.h"
  27 #include "webrtc/modules/interface/module_common_types.h"
  28 #include "webrtc/system_wrappers/interface/compile_assert.h"
  29 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
  30 #include "webrtc/system_wrappers/interface/file_wrapper.h"
  31 #include "webrtc/system_wrappers/interface/logging.h"
  32
  33 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
  34 // Files generated at build-time by the protobuf compiler.
  35 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD
  36 #include "external/webrtc/webrtc/modules/audio_processing/debug.pb.h"
  37 #else
  38 #include "webrtc/audio_processing/debug.pb.h"
  39 #endif
  40 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
  41
  42 #define RETURN_ON_ERR(expr)  \
  43   do {                       \
  44     int err = expr;          \
  45     if (err != kNoError) {   \
  46       return err;            \
  47     }                        \
  48   } while (0)
  49
  50 namespace webrtc {
  51
  52 // Throughout webrtc, it's assumed that success is represented by zero.
  53 COMPILE_ASSERT(AudioProcessing::kNoError == 0, no_error_must_be_zero);
  54
  55 AudioProcessing* AudioProcessing::Create(int id) {
  56   return Create();
  57 }
  58
  59 AudioProcessing* AudioProcessing::Create() {
  60   Config config;
  61   return Create(config);
  62 }
  63
  64 AudioProcessing* AudioProcessing::Create(const Config& config) {
  65   AudioProcessingImpl* apm = new AudioProcessingImpl(config);
  66   if (apm->Initialize() != kNoError) {
  67     delete apm;
  68     apm = NULL;
  69   }
  70
  71   return apm;
  72 }
  73
  74 AudioProcessingImpl::AudioProcessingImpl(const Config& config)
  75     : echo_cancellation_(NULL),
  76       echo_control_mobile_(NULL),
  77       gain_control_(NULL),
  78       high_pass_filter_(NULL),
  79       level_estimator_(NULL),
  80       noise_suppression_(NULL),
  81       voice_detection_(NULL),
  82       crit_(CriticalSectionWrapper::CreateCriticalSection()),
  83 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
  84       debug_file_(FileWrapper::Create()),
  85       event_msg_(new audioproc::Event()),
  86 #endif
  87       fwd_in_format_(kSampleRate16kHz, 1),
  88       fwd_proc_format_(kSampleRate16kHz, 1),
  89       fwd_out_format_(kSampleRate16kHz),
  90       rev_in_format_(kSampleRate16kHz, 1),
  91       rev_proc_format_(kSampleRate16kHz, 1),
  92       split_rate_(kSampleRate16kHz),
  93       stream_delay_ms_(0),
  94       delay_offset_ms_(0),
  95       was_stream_delay_set_(false),
  96       output_will_be_muted_(false),
  97       key_pressed_(false) {
  98   echo_cancellation_ = new EchoCancellationImpl(this, crit_);
  99   component_list_.push_back(echo_cancellation_);
 100
 101   echo_control_mobile_ = new EchoControlMobileImpl(this, crit_);
 102   component_list_.push_back(echo_control_mobile_);
 103
 104   gain_control_ = new GainControlImpl(this, crit_);
 105   component_list_.push_back(gain_control_);
 106
 107   high_pass_filter_ = new HighPassFilterImpl(this, crit_);
 108   component_list_.push_back(high_pass_filter_);
 109
 110   level_estimator_ = new LevelEstimatorImpl(this, crit_);
 111   component_list_.push_back(level_estimator_);
 112
 113   noise_suppression_ = new NoiseSuppressionImpl(this, crit_);
 114   component_list_.push_back(noise_suppression_);
 115
 116   voice_detection_ = new VoiceDetectionImpl(this, crit_);
 117   component_list_.push_back(voice_detection_);
 118
 119   SetExtraOptions(config);
 120 }
 121
 122 AudioProcessingImpl::~AudioProcessingImpl() {
 123   {
 124     CriticalSectionScoped crit_scoped(crit_);
 125     while (!component_list_.empty()) {
 126       ProcessingComponent* component = component_list_.front();
 127       component->Destroy();
 128       delete component;
 129       component_list_.pop_front();
 130     }
 131
 132 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 133     if (debug_file_->Open()) {
 134       debug_file_->CloseFile();
 135     }
 136 #endif
 137   }
 138   delete crit_;
 139   crit_ = NULL;
 140 }
 141
 142 int AudioProcessingImpl::Initialize() {
 143   CriticalSectionScoped crit_scoped(crit_);
 144   return InitializeLocked();
 145 }
 146
 147 int AudioProcessingImpl::set_sample_rate_hz(int rate) {
 148   CriticalSectionScoped crit_scoped(crit_);
 149   return InitializeLocked(rate,
 150                           rate,
 151                           rev_in_format_.rate(),
 152                           fwd_in_format_.num_channels(),
 153                           fwd_proc_format_.num_channels(),
 154                           rev_in_format_.num_channels());
 155 }
 156
 157 int AudioProcessingImpl::Initialize(int input_sample_rate_hz,
 158                                     int output_sample_rate_hz,
 159                                     int reverse_sample_rate_hz,
 160                                     ChannelLayout input_layout,
 161                                     ChannelLayout output_layout,
 162                                     ChannelLayout reverse_layout) {
 163   CriticalSectionScoped crit_scoped(crit_);
 164   return InitializeLocked(input_sample_rate_hz,
 165                           output_sample_rate_hz,
 166                           reverse_sample_rate_hz,
 167                           ChannelsFromLayout(input_layout),
 168                           ChannelsFromLayout(output_layout),
 169                           ChannelsFromLayout(reverse_layout));
 170 }
 171
 172 int AudioProcessingImpl::InitializeLocked() {
 173   render_audio_.reset(new AudioBuffer(rev_in_format_.samples_per_channel(),
 174                                       rev_in_format_.num_channels(),
 175                                       rev_proc_format_.samples_per_channel(),
 176                                       rev_proc_format_.num_channels(),
 177                                       rev_proc_format_.samples_per_channel()));
 178   capture_audio_.reset(new AudioBuffer(fwd_in_format_.samples_per_channel(),
 179                                        fwd_in_format_.num_channels(),
 180                                        fwd_proc_format_.samples_per_channel(),
 181                                        fwd_proc_format_.num_channels(),
 182                                        fwd_out_format_.samples_per_channel()));
 183
 184   // Initialize all components.
 185   std::list<ProcessingComponent*>::iterator it;
 186   for (it = component_list_.begin(); it != component_list_.end(); ++it) {
 187     int err = (*it)->Initialize();
 188     if (err != kNoError) {
 189       return err;
 190     }
 191   }
 192
 193 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 194   if (debug_file_->Open()) {
 195     int err = WriteInitMessage();
 196     if (err != kNoError) {
 197       return err;
 198     }
 199   }
 200 #endif
 201
 202   return kNoError;
 203 }
 204
 205 int AudioProcessingImpl::InitializeLocked(int input_sample_rate_hz,
 206                                           int output_sample_rate_hz,
 207                                           int reverse_sample_rate_hz,
 208                                           int num_input_channels,
 209                                           int num_output_channels,
 210                                           int num_reverse_channels) {
 211   if (input_sample_rate_hz <= 0 ||
 212       output_sample_rate_hz <= 0 ||
 213       reverse_sample_rate_hz <= 0) {
 214     return kBadSampleRateError;
 215   }
 216   if (num_output_channels > num_input_channels) {
 217     return kBadNumberChannelsError;
 218   }
 219   // Only mono and stereo supported currently.
 220   if (num_input_channels > 2 || num_input_channels < 1 ||
 221       num_output_channels > 2 || num_output_channels < 1 ||
 222       num_reverse_channels > 2 || num_reverse_channels < 1) {
 223     return kBadNumberChannelsError;
 224   }
 225
 226   fwd_in_format_.set(input_sample_rate_hz, num_input_channels);
 227   fwd_out_format_.set(output_sample_rate_hz);
 228   rev_in_format_.set(reverse_sample_rate_hz, num_reverse_channels);
 229
 230   // We process at the closest native rate >= min(input rate, output rate)...
 231   int min_proc_rate = std::min(fwd_in_format_.rate(), fwd_out_format_.rate());
 232   int fwd_proc_rate;
 233   if (min_proc_rate > kSampleRate16kHz) {
 234     fwd_proc_rate = kSampleRate32kHz;
 235   } else if (min_proc_rate > kSampleRate8kHz) {
 236     fwd_proc_rate = kSampleRate16kHz;
 237   } else {
 238     fwd_proc_rate = kSampleRate8kHz;
 239   }
 240   // ...with one exception.
 241   if (echo_control_mobile_->is_enabled() && min_proc_rate > kSampleRate16kHz) {
 242     fwd_proc_rate = kSampleRate16kHz;
 243   }
 244
 245   fwd_proc_format_.set(fwd_proc_rate, num_output_channels);
 246
 247   // We normally process the reverse stream at 16 kHz. Unless...
 248   int rev_proc_rate = kSampleRate16kHz;
 249   if (fwd_proc_format_.rate() == kSampleRate8kHz) {
 250     // ...the forward stream is at 8 kHz.
 251     rev_proc_rate = kSampleRate8kHz;
 252   } else {
 253     if (rev_in_format_.rate() == kSampleRate32kHz) {
 254       // ...or the input is at 32 kHz, in which case we use the splitting
 255       // filter rather than the resampler.
 256       rev_proc_rate = kSampleRate32kHz;
 257     }
 258   }
 259
 260   // TODO(ajm): Enable this.
 261   // Always downmix the reverse stream to mono for analysis.
 262   //rev_proc_format_.set(rev_proc_rate, 1);
 263   rev_proc_format_.set(rev_proc_rate, rev_in_format_.num_channels());
 264
 265   if (fwd_proc_format_.rate() == kSampleRate32kHz) {
 266     split_rate_ = kSampleRate16kHz;
 267   } else {
 268     split_rate_ = fwd_proc_format_.rate();
 269   }
 270
 271   return InitializeLocked();
 272 }
 273
 274 // Calls InitializeLocked() if any of the audio parameters have changed from
 275 // their current values.
 276 int AudioProcessingImpl::MaybeInitializeLocked(int input_sample_rate_hz,
 277                                                int output_sample_rate_hz,
 278                                                int reverse_sample_rate_hz,
 279                                                int num_input_channels,
 280                                                int num_output_channels,
 281                                                int num_reverse_channels) {
 282   if (input_sample_rate_hz == fwd_in_format_.rate() &&
 283       output_sample_rate_hz == fwd_out_format_.rate() &&
 284       reverse_sample_rate_hz == rev_in_format_.rate() &&
 285       num_input_channels == fwd_in_format_.num_channels() &&
 286       num_output_channels == fwd_proc_format_.num_channels() &&
 287       num_reverse_channels == rev_in_format_.num_channels()) {
 288     return kNoError;
 289   }
 290
 291   return InitializeLocked(input_sample_rate_hz,
 292                           output_sample_rate_hz,
 293                           reverse_sample_rate_hz,
 294                           num_input_channels,
 295                           num_output_channels,
 296                           num_reverse_channels);
 297 }
 298
 299 void AudioProcessingImpl::SetExtraOptions(const Config& config) {
 300   CriticalSectionScoped crit_scoped(crit_);
 301   std::list<ProcessingComponent*>::iterator it;
 302   for (it = component_list_.begin(); it != component_list_.end(); ++it)
 303     (*it)->SetExtraOptions(config);
 304 }
 305
 306 int AudioProcessingImpl::EnableExperimentalNs(bool enable) {
 307   return kNoError;
 308 }
 309
 310 int AudioProcessingImpl::input_sample_rate_hz() const {
 311   CriticalSectionScoped crit_scoped(crit_);
 312   return fwd_in_format_.rate();
 313 }
 314
 315 int AudioProcessingImpl::sample_rate_hz() const {
 316   CriticalSectionScoped crit_scoped(crit_);
 317   return fwd_in_format_.rate();
 318 }
 319
 320 int AudioProcessingImpl::proc_sample_rate_hz() const {
 321   return fwd_proc_format_.rate();
 322 }
 323
 324 int AudioProcessingImpl::proc_split_sample_rate_hz() const {
 325   return split_rate_;
 326 }
 327
 328 int AudioProcessingImpl::num_reverse_channels() const {
 329   return rev_proc_format_.num_channels();
 330 }
 331
 332 int AudioProcessingImpl::num_input_channels() const {
 333   return fwd_in_format_.num_channels();
 334 }
 335
 336 int AudioProcessingImpl::num_output_channels() const {
 337   return fwd_proc_format_.num_channels();
 338 }
 339
 340 void AudioProcessingImpl::set_output_will_be_muted(bool muted) {
 341   output_will_be_muted_ = muted;
 342 }
 343
 344 bool AudioProcessingImpl::output_will_be_muted() const {
 345   return output_will_be_muted_;
 346 }
 347
 348 int AudioProcessingImpl::ProcessStream(const float* const* src,
 349                                        int samples_per_channel,
 350                                        int input_sample_rate_hz,
 351                                        ChannelLayout input_layout,
 352                                        int output_sample_rate_hz,
 353                                        ChannelLayout output_layout,
 354                                        float* const* dest) {
 355   CriticalSectionScoped crit_scoped(crit_);
 356   if (!src || !dest) {
 357     return kNullPointerError;
 358   }
 359
 360   RETURN_ON_ERR(MaybeInitializeLocked(input_sample_rate_hz,
 361                                       output_sample_rate_hz,
 362                                       rev_in_format_.rate(),
 363                                       ChannelsFromLayout(input_layout),
 364                                       ChannelsFromLayout(output_layout),
 365                                       rev_in_format_.num_channels()));
 366   if (samples_per_channel != fwd_in_format_.samples_per_channel()) {
 367     return kBadDataLengthError;
 368   }
 369
 370 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 371   if (debug_file_->Open()) {
 372     event_msg_->set_type(audioproc::Event::STREAM);
 373     audioproc::Stream* msg = event_msg_->mutable_stream();
 374     const size_t channel_size = sizeof(float) * samples_per_channel;
 375     for (int i = 0; i < fwd_in_format_.num_channels(); ++i)
 376       msg->add_input_channel(src[i], channel_size);
 377   }
 378 #endif
 379
 380   capture_audio_->CopyFrom(src, samples_per_channel, input_layout);
 381   RETURN_ON_ERR(ProcessStreamLocked());
 382   if (output_copy_needed(is_data_processed())) {
 383     capture_audio_->CopyTo(fwd_out_format_.samples_per_channel(),
 384                            output_layout,
 385                            dest);
 386   }
 387
 388 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 389   if (debug_file_->Open()) {
 390     audioproc::Stream* msg = event_msg_->mutable_stream();
 391     const size_t channel_size = sizeof(float) * samples_per_channel;
 392     for (int i = 0; i < fwd_proc_format_.num_channels(); ++i)
 393       msg->add_output_channel(dest[i], channel_size);
 394     RETURN_ON_ERR(WriteMessageToDebugFile());
 395   }
 396 #endif
 397
 398   return kNoError;
 399 }
 400
 401 int AudioProcessingImpl::ProcessStream(AudioFrame* frame) {
 402   CriticalSectionScoped crit_scoped(crit_);
 403   if (!frame) {
 404     return kNullPointerError;
 405   }
 406   // Must be a native rate.
 407   if (frame->sample_rate_hz_ != kSampleRate8kHz &&
 408       frame->sample_rate_hz_ != kSampleRate16kHz &&
 409       frame->sample_rate_hz_ != kSampleRate32kHz) {
 410     return kBadSampleRateError;
 411   }
 412   if (echo_control_mobile_->is_enabled() &&
 413       frame->sample_rate_hz_ > kSampleRate16kHz) {
 414     LOG(LS_ERROR) << "AECM only supports 16 or 8 kHz sample rates";
 415     return kUnsupportedComponentError;
 416   }
 417
 418   // TODO(ajm): The input and output rates and channels are currently
 419   // constrained to be identical in the int16 interface.
 420   RETURN_ON_ERR(MaybeInitializeLocked(frame->sample_rate_hz_,
 421                                       frame->sample_rate_hz_,
 422                                       rev_in_format_.rate(),
 423                                       frame->num_channels_,
 424                                       frame->num_channels_,
 425                                       rev_in_format_.num_channels()));
 426   if (frame->samples_per_channel_ != fwd_in_format_.samples_per_channel()) {
 427     return kBadDataLengthError;
 428   }
 429
 430 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 431   if (debug_file_->Open()) {
 432     event_msg_->set_type(audioproc::Event::STREAM);
 433     audioproc::Stream* msg = event_msg_->mutable_stream();
 434     const size_t data_size = sizeof(int16_t) *
 435                              frame->samples_per_channel_ *
 436                              frame->num_channels_;
 437     msg->set_input_data(frame->data_, data_size);
 438   }
 439 #endif
 440
 441   capture_audio_->DeinterleaveFrom(frame);
 442   RETURN_ON_ERR(ProcessStreamLocked());
 443   capture_audio_->InterleaveTo(frame, output_copy_needed(is_data_processed()));
 444
 445 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 446   if (debug_file_->Open()) {
 447     audioproc::Stream* msg = event_msg_->mutable_stream();
 448     const size_t data_size = sizeof(int16_t) *
 449                              frame->samples_per_channel_ *
 450                              frame->num_channels_;
 451     msg->set_output_data(frame->data_, data_size);
 452     RETURN_ON_ERR(WriteMessageToDebugFile());
 453   }
 454 #endif
 455
 456   return kNoError;
 457 }
 458
 459
 460 int AudioProcessingImpl::ProcessStreamLocked() {
 461 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 462   if (debug_file_->Open()) {
 463     audioproc::Stream* msg = event_msg_->mutable_stream();
 464     msg->set_delay(stream_delay_ms_);
 465     msg->set_drift(echo_cancellation_->stream_drift_samples());
 466     msg->set_level(gain_control_->stream_analog_level());
 467     msg->set_keypress(key_pressed_);
 468   }
 469 #endif
 470
 471   AudioBuffer* ca = capture_audio_.get();  // For brevity.
 472   bool data_processed = is_data_processed();
 473   if (analysis_needed(data_processed)) {
 474     for (int i = 0; i < fwd_proc_format_.num_channels(); i++) {
 475       // Split into a low and high band.
 476       WebRtcSpl_AnalysisQMF(ca->data(i),
 477                             ca->samples_per_channel(),
 478                             ca->low_pass_split_data(i),
 479                             ca->high_pass_split_data(i),
 480                             ca->filter_states(i)->analysis_filter_state1,
 481                             ca->filter_states(i)->analysis_filter_state2);
 482     }
 483   }
 484
 485   RETURN_ON_ERR(high_pass_filter_->ProcessCaptureAudio(ca));
 486   RETURN_ON_ERR(gain_control_->AnalyzeCaptureAudio(ca));
 487   RETURN_ON_ERR(echo_cancellation_->ProcessCaptureAudio(ca));
 488
 489   if (echo_control_mobile_->is_enabled() && noise_suppression_->is_enabled()) {
 490     ca->CopyLowPassToReference();
 491   }
 492   RETURN_ON_ERR(noise_suppression_->ProcessCaptureAudio(ca));
 493   RETURN_ON_ERR(echo_control_mobile_->ProcessCaptureAudio(ca));
 494   RETURN_ON_ERR(voice_detection_->ProcessCaptureAudio(ca));
 495   RETURN_ON_ERR(gain_control_->ProcessCaptureAudio(ca));
 496
 497   if (synthesis_needed(data_processed)) {
 498     for (int i = 0; i < fwd_proc_format_.num_channels(); i++) {
 499       // Recombine low and high bands.
 500       WebRtcSpl_SynthesisQMF(ca->low_pass_split_data(i),
 501                              ca->high_pass_split_data(i),
 502                              ca->samples_per_split_channel(),
 503                              ca->data(i),
 504                              ca->filter_states(i)->synthesis_filter_state1,
 505                              ca->filter_states(i)->synthesis_filter_state2);
 506     }
 507   }
 508
 509   // The level estimator operates on the recombined data.
 510   RETURN_ON_ERR(level_estimator_->ProcessStream(ca));
 511
 512   was_stream_delay_set_ = false;
 513   return kNoError;
 514 }
 515
 516 int AudioProcessingImpl::AnalyzeReverseStream(const float* const* data,
 517                                               int samples_per_channel,
 518                                               int sample_rate_hz,
 519                                               ChannelLayout layout) {
 520   CriticalSectionScoped crit_scoped(crit_);
 521   if (data == NULL) {
 522     return kNullPointerError;
 523   }
 524
 525   const int num_channels = ChannelsFromLayout(layout);
 526   RETURN_ON_ERR(MaybeInitializeLocked(fwd_in_format_.rate(),
 527                                       fwd_out_format_.rate(),
 528                                       sample_rate_hz,
 529                                       fwd_in_format_.num_channels(),
 530                                       fwd_proc_format_.num_channels(),
 531                                       num_channels));
 532   if (samples_per_channel != rev_in_format_.samples_per_channel()) {
 533     return kBadDataLengthError;
 534   }
 535
 536 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 537   if (debug_file_->Open()) {
 538     event_msg_->set_type(audioproc::Event::REVERSE_STREAM);
 539     audioproc::ReverseStream* msg = event_msg_->mutable_reverse_stream();
 540     const size_t channel_size = sizeof(float) * samples_per_channel;
 541     for (int i = 0; i < num_channels; ++i)
 542       msg->add_channel(data[i], channel_size);
 543     RETURN_ON_ERR(WriteMessageToDebugFile());
 544   }
 545 #endif
 546
 547   render_audio_->CopyFrom(data, samples_per_channel, layout);
 548   return AnalyzeReverseStreamLocked();
 549 }
 550
 551 int AudioProcessingImpl::AnalyzeReverseStream(AudioFrame* frame) {
 552   CriticalSectionScoped crit_scoped(crit_);
 553   if (frame == NULL) {
 554     return kNullPointerError;
 555   }
 556   // Must be a native rate.
 557   if (frame->sample_rate_hz_ != kSampleRate8kHz &&
 558       frame->sample_rate_hz_ != kSampleRate16kHz &&
 559       frame->sample_rate_hz_ != kSampleRate32kHz) {
 560     return kBadSampleRateError;
 561   }
 562   // This interface does not tolerate different forward and reverse rates.
 563   if (frame->sample_rate_hz_ != fwd_in_format_.rate()) {
 564     return kBadSampleRateError;
 565   }
 566
 567   RETURN_ON_ERR(MaybeInitializeLocked(fwd_in_format_.rate(),
 568                                       fwd_out_format_.rate(),
 569                                       frame->sample_rate_hz_,
 570                                       fwd_in_format_.num_channels(),
 571                                       fwd_in_format_.num_channels(),
 572                                       frame->num_channels_));
 573   if (frame->samples_per_channel_ != rev_in_format_.samples_per_channel()) {
 574     return kBadDataLengthError;
 575   }
 576
 577 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 578   if (debug_file_->Open()) {
 579     event_msg_->set_type(audioproc::Event::REVERSE_STREAM);
 580     audioproc::ReverseStream* msg = event_msg_->mutable_reverse_stream();
 581     const size_t data_size = sizeof(int16_t) *
 582                              frame->samples_per_channel_ *
 583                              frame->num_channels_;
 584     msg->set_data(frame->data_, data_size);
 585     RETURN_ON_ERR(WriteMessageToDebugFile());
 586   }
 587 #endif
 588
 589   render_audio_->DeinterleaveFrom(frame);
 590   return AnalyzeReverseStreamLocked();
 591 }
 592
 593 int AudioProcessingImpl::AnalyzeReverseStreamLocked() {
 594   AudioBuffer* ra = render_audio_.get();  // For brevity.
 595   if (rev_proc_format_.rate() == kSampleRate32kHz) {
 596     for (int i = 0; i < rev_proc_format_.num_channels(); i++) {
 597       // Split into low and high band.
 598       WebRtcSpl_AnalysisQMF(ra->data(i),
 599                             ra->samples_per_channel(),
 600                             ra->low_pass_split_data(i),
 601                             ra->high_pass_split_data(i),
 602                             ra->filter_states(i)->analysis_filter_state1,
 603                             ra->filter_states(i)->analysis_filter_state2);
 604     }
 605   }
 606
 607   RETURN_ON_ERR(echo_cancellation_->ProcessRenderAudio(ra));
 608   RETURN_ON_ERR(echo_control_mobile_->ProcessRenderAudio(ra));
 609   RETURN_ON_ERR(gain_control_->ProcessRenderAudio(ra));
 610
 611   return kNoError;
 612 }
 613
 614 int AudioProcessingImpl::set_stream_delay_ms(int delay) {
 615   Error retval = kNoError;
 616   was_stream_delay_set_ = true;
 617   delay += delay_offset_ms_;
 618
 619   if (delay < 0) {
 620     delay = 0;
 621     retval = kBadStreamParameterWarning;
 622   }
 623
 624   // TODO(ajm): the max is rather arbitrarily chosen; investigate.
 625   if (delay > 500) {
 626     delay = 500;
 627     retval = kBadStreamParameterWarning;
 628   }
 629
 630   stream_delay_ms_ = delay;
 631   return retval;
 632 }
 633
 634 int AudioProcessingImpl::stream_delay_ms() const {
 635   return stream_delay_ms_;
 636 }
 637
 638 bool AudioProcessingImpl::was_stream_delay_set() const {
 639   return was_stream_delay_set_;
 640 }
 641
 642 void AudioProcessingImpl::set_stream_key_pressed(bool key_pressed) {
 643   key_pressed_ = key_pressed;
 644 }
 645
 646 bool AudioProcessingImpl::stream_key_pressed() const {
 647   return key_pressed_;
 648 }
 649
 650 void AudioProcessingImpl::set_delay_offset_ms(int offset) {
 651   CriticalSectionScoped crit_scoped(crit_);
 652   delay_offset_ms_ = offset;
 653 }
 654
 655 int AudioProcessingImpl::delay_offset_ms() const {
 656   return delay_offset_ms_;
 657 }
 658
 659 int AudioProcessingImpl::StartDebugRecording(
 660     const char filename[AudioProcessing::kMaxFilenameSize]) {
 661   CriticalSectionScoped crit_scoped(crit_);
 662   assert(kMaxFilenameSize == FileWrapper::kMaxFileNameSize);
 663
 664   if (filename == NULL) {
 665     return kNullPointerError;
 666   }
 667
 668 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 669   // Stop any ongoing recording.
 670   if (debug_file_->Open()) {
 671     if (debug_file_->CloseFile() == -1) {
 672       return kFileError;
 673     }
 674   }
 675
 676   if (debug_file_->OpenFile(filename, false) == -1) {
 677     debug_file_->CloseFile();
 678     return kFileError;
 679   }
 680
 681   int err = WriteInitMessage();
 682   if (err != kNoError) {
 683     return err;
 684   }
 685   return kNoError;
 686 #else
 687   return kUnsupportedFunctionError;
 688 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 689 }
 690
 691 int AudioProcessingImpl::StartDebugRecording(FILE* handle) {
 692   CriticalSectionScoped crit_scoped(crit_);
 693
 694   if (handle == NULL) {
 695     return kNullPointerError;
 696   }
 697
 698 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 699   // Stop any ongoing recording.
 700   if (debug_file_->Open()) {
 701     if (debug_file_->CloseFile() == -1) {
 702       return kFileError;
 703     }
 704   }
 705
 706   if (debug_file_->OpenFromFileHandle(handle, true, false) == -1) {
 707     return kFileError;
 708   }
 709
 710   int err = WriteInitMessage();
 711   if (err != kNoError) {
 712     return err;
 713   }
 714   return kNoError;
 715 #else
 716   return kUnsupportedFunctionError;
 717 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 718 }
 719
 720 int AudioProcessingImpl::StopDebugRecording() {
 721   CriticalSectionScoped crit_scoped(crit_);
 722
 723 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 724   // We just return if recording hasn't started.
 725   if (debug_file_->Open()) {
 726     if (debug_file_->CloseFile() == -1) {
 727       return kFileError;
 728     }
 729   }
 730   return kNoError;
 731 #else
 732   return kUnsupportedFunctionError;
 733 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 734 }
 735
 736 EchoCancellation* AudioProcessingImpl::echo_cancellation() const {
 737   return echo_cancellation_;
 738 }
 739
 740 EchoControlMobile* AudioProcessingImpl::echo_control_mobile() const {
 741   return echo_control_mobile_;
 742 }
 743
 744 GainControl* AudioProcessingImpl::gain_control() const {
 745   return gain_control_;
 746 }
 747
 748 HighPassFilter* AudioProcessingImpl::high_pass_filter() const {
 749   return high_pass_filter_;
 750 }
 751
 752 LevelEstimator* AudioProcessingImpl::level_estimator() const {
 753   return level_estimator_;
 754 }
 755
 756 NoiseSuppression* AudioProcessingImpl::noise_suppression() const {
 757   return noise_suppression_;
 758 }
 759
 760 VoiceDetection* AudioProcessingImpl::voice_detection() const {
 761   return voice_detection_;
 762 }
 763
 764 bool AudioProcessingImpl::is_data_processed() const {
 765   int enabled_count = 0;
 766   std::list<ProcessingComponent*>::const_iterator it;
 767   for (it = component_list_.begin(); it != component_list_.end(); it++) {
 768     if ((*it)->is_component_enabled()) {
 769       enabled_count++;
 770     }
 771   }
 772
 773   // Data is unchanged if no components are enabled, or if only level_estimator_
 774   // or voice_detection_ is enabled.
 775   if (enabled_count == 0) {
 776     return false;
 777   } else if (enabled_count == 1) {
 778     if (level_estimator_->is_enabled() || voice_detection_->is_enabled()) {
 779       return false;
 780     }
 781   } else if (enabled_count == 2) {
 782     if (level_estimator_->is_enabled() && voice_detection_->is_enabled()) {
 783       return false;
 784     }
 785   }
 786   return true;
 787 }
 788
 789 bool AudioProcessingImpl::output_copy_needed(bool is_data_processed) const {
 790   // Check if we've upmixed or downmixed the audio.
 791   return ((fwd_proc_format_.num_channels() != fwd_in_format_.num_channels()) ||
 792           is_data_processed);
 793 }
 794
 795 bool AudioProcessingImpl::synthesis_needed(bool is_data_processed) const {
 796   return (is_data_processed && fwd_proc_format_.rate() == kSampleRate32kHz);
 797 }
 798
 799 bool AudioProcessingImpl::analysis_needed(bool is_data_processed) const {
 800   if (!is_data_processed && !voice_detection_->is_enabled()) {
 801     // Only level_estimator_ is enabled.
 802     return false;
 803   } else if (fwd_proc_format_.rate() == kSampleRate32kHz) {
 804     // Something besides level_estimator_ is enabled, and we have super-wb.
 805     return true;
 806   }
 807   return false;
 808 }
 809
 810 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 811 int AudioProcessingImpl::WriteMessageToDebugFile() {
 812   int32_t size = event_msg_->ByteSize();
 813   if (size <= 0) {
 814     return kUnspecifiedError;
 815   }
 816 #if defined(WEBRTC_ARCH_BIG_ENDIAN)
 817   // TODO(ajm): Use little-endian "on the wire". For the moment, we can be
 818   //            pretty safe in assuming little-endian.
 819 #endif
 820
 821   if (!event_msg_->SerializeToString(&event_str_)) {
 822     return kUnspecifiedError;
 823   }
 824
 825   // Write message preceded by its size.
 826   if (!debug_file_->Write(&size, sizeof(int32_t))) {
 827     return kFileError;
 828   }
 829   if (!debug_file_->Write(event_str_.data(), event_str_.length())) {
 830     return kFileError;
 831   }
 832
 833   event_msg_->Clear();
 834
 835   return kNoError;
 836 }
 837
 838 int AudioProcessingImpl::WriteInitMessage() {
 839   event_msg_->set_type(audioproc::Event::INIT);
 840   audioproc::Init* msg = event_msg_->mutable_init();
 841   msg->set_sample_rate(fwd_in_format_.rate());
 842   msg->set_num_input_channels(fwd_in_format_.num_channels());
 843   msg->set_num_output_channels(fwd_proc_format_.num_channels());
 844   msg->set_num_reverse_channels(rev_in_format_.num_channels());
 845   msg->set_reverse_sample_rate(rev_in_format_.rate());
 846   msg->set_output_sample_rate(fwd_out_format_.rate());
 847
 848   int err = WriteMessageToDebugFile();
 849   if (err != kNoError) {
 850     return err;
 851   }
 852
 853   return kNoError;
 854 }
 855 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 856
 857 }  // namespace webrtc