Start using APM directly in WVoMC (not VoEAudioProcessing)

webrtc/media/engine/fakewebrtcvoiceengine.h

 /*
  *  Copyright (c) 2010 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 27 matching lines @@
 
 #define WEBRTC_STUB(method, args) \
   int method args override { return 0; }
 
 #define WEBRTC_STUB_CONST(method, args) \
   int method args const override { return 0; }
 
 #define WEBRTC_BOOL_STUB(method, args) \
   bool method args override { return true; }
 
-#define WEBRTC_BOOL_STUB_CONST(method, args) \
-  bool method args const override { return true; }
-
 #define WEBRTC_VOID_STUB(method, args) \
   void method args override {}
 
 #define WEBRTC_FUNC(method, args) int method args override
 
-#define WEBRTC_VOID_FUNC(method, args) void method args override
-
-class FakeAudioProcessing : public webrtc::AudioProcessing {
- public:
-  FakeAudioProcessing() : experimental_ns_enabled_(false) {}
-
-  WEBRTC_STUB(Initialize, ())
-  WEBRTC_STUB(Initialize, (
-      int input_sample_rate_hz,
-      int output_sample_rate_hz,
-      int reverse_sample_rate_hz,
-      webrtc::AudioProcessing::ChannelLayout input_layout,
-      webrtc::AudioProcessing::ChannelLayout output_layout,
-      webrtc::AudioProcessing::ChannelLayout reverse_layout));
-  WEBRTC_STUB(Initialize, (
-      const webrtc::ProcessingConfig& processing_config));
-
-  WEBRTC_VOID_STUB(ApplyConfig, (const AudioProcessing::Config& config));
-  WEBRTC_VOID_FUNC(SetExtraOptions, (const webrtc::Config& config)) {
-    experimental_ns_enabled_ = config.Get<webrtc::ExperimentalNs>().enabled;
-  }
-
-  WEBRTC_STUB_CONST(proc_sample_rate_hz, ());
-  WEBRTC_STUB_CONST(proc_split_sample_rate_hz, ());
-  size_t num_input_channels() const override { return 0; }
-  size_t num_proc_channels() const override { return 0; }
-  size_t num_output_channels() const override { return 0; }
-  size_t num_reverse_channels() const override { return 0; }
-  WEBRTC_VOID_STUB(set_output_will_be_muted, (bool muted));
-  WEBRTC_STUB(ProcessStream, (webrtc::AudioFrame* frame));
-  WEBRTC_STUB(ProcessStream, (
-      const float* const* src,
-      size_t samples_per_channel,
-      int input_sample_rate_hz,
-      webrtc::AudioProcessing::ChannelLayout input_layout,
-      int output_sample_rate_hz,
-      webrtc::AudioProcessing::ChannelLayout output_layout,
-      float* const* dest));
-  WEBRTC_STUB(ProcessStream,
-              (const float* const* src,
-               const webrtc::StreamConfig& input_config,
-               const webrtc::StreamConfig& output_config,
-               float* const* dest));
-  WEBRTC_STUB(ProcessReverseStream, (webrtc::AudioFrame * frame));
-  WEBRTC_STUB(AnalyzeReverseStream, (
-      const float* const* data,
-      size_t samples_per_channel,
-      int sample_rate_hz,
-      webrtc::AudioProcessing::ChannelLayout layout));
-  WEBRTC_STUB(ProcessReverseStream,
-              (const float* const* src,
-               const webrtc::StreamConfig& reverse_input_config,
-               const webrtc::StreamConfig& reverse_output_config,
-               float* const* dest));
-  WEBRTC_STUB(set_stream_delay_ms, (int delay));
-  WEBRTC_STUB_CONST(stream_delay_ms, ());
-  WEBRTC_BOOL_STUB_CONST(was_stream_delay_set, ());
-  WEBRTC_VOID_STUB(set_stream_key_pressed, (bool key_pressed));
-  WEBRTC_VOID_STUB(set_delay_offset_ms, (int offset));
-  WEBRTC_STUB_CONST(delay_offset_ms, ());
-  WEBRTC_STUB(StartDebugRecording,
-              (const char filename[kMaxFilenameSize], int64_t max_size_bytes));
-  WEBRTC_STUB(StartDebugRecording, (FILE * handle, int64_t max_size_bytes));
-  WEBRTC_STUB(StartDebugRecording, (FILE * handle));
-  WEBRTC_STUB(StartDebugRecordingForPlatformFile, (rtc::PlatformFile handle));
-  WEBRTC_STUB(StopDebugRecording, ());
-  WEBRTC_VOID_STUB(UpdateHistogramsOnCallEnd, ());
-  webrtc::EchoCancellation* echo_cancellation() const override { return NULL; }
-  webrtc::EchoControlMobile* echo_control_mobile() const override {
-    return NULL;
-  }
-  webrtc::GainControl* gain_control() const override { return NULL; }
-  webrtc::HighPassFilter* high_pass_filter() const override { return NULL; }
-  webrtc::LevelEstimator* level_estimator() const override { return NULL; }
-  webrtc::NoiseSuppression* noise_suppression() const override { return NULL; }
-  webrtc::VoiceDetection* voice_detection() const override { return NULL; }
-
-  bool experimental_ns_enabled() {
-    return experimental_ns_enabled_;
-  }
-
- private:
-  bool experimental_ns_enabled_;
-};
-
 class FakeWebRtcVoiceEngine
     : public webrtc::VoEAudioProcessing,
       public webrtc::VoEBase, public webrtc::VoECodec,
       public webrtc::VoEHardware,
       public webrtc::VoEVolumeControl {
  public:
   struct Channel {
     int associate_send_channel = -1;
     std::vector<webrtc::CodecInst> recv_codecs;
     size_t neteq_capacity = 0;
     bool neteq_fast_accelerate = false;
   };
 
-  FakeWebRtcVoiceEngine() {
+  explicit FakeWebRtcVoiceEngine(webrtc::AudioProcessing* apm) : apm_(apm) {
     memset(&agc_config_, 0, sizeof(agc_config_));
   }
   ~FakeWebRtcVoiceEngine() override {
     RTC_CHECK(channels_.empty());
   }
 
   bool ec_metrics_enabled() const { return ec_metrics_enabled_; }
 
   bool IsInited() const { return inited_; }
   int GetLastChannel() const { return last_channel_; }
@@ skipping 18 matching lines @@
                const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
                    decoder_factory)) {
     inited_ = true;
     return 0;
   }
   WEBRTC_FUNC(Terminate, ()) {
     inited_ = false;
     return 0;
   }
   webrtc::AudioProcessing* audio_processing() override {
-    return &audio_processing_;
+    return apm_;
   }
   webrtc::AudioDeviceModule* audio_device_module() override {
     return nullptr;
   }
   WEBRTC_FUNC(CreateChannel, ()) {
     return CreateChannel(webrtc::VoEBase::ChannelConfig());
   }
   WEBRTC_FUNC(CreateChannel, (const webrtc::VoEBase::ChannelConfig& config)) {
     if (fail_create_channel_) {
       return -1;
@@ skipping 133 matching lines @@
   WEBRTC_FUNC(SetNsStatus, (bool enable, webrtc::NsModes mode)) {
     ns_enabled_ = enable;
     ns_mode_ = mode;
     return 0;
   }
   WEBRTC_FUNC(GetNsStatus, (bool& enabled, webrtc::NsModes& mode)) {
     enabled = ns_enabled_;
     mode = ns_mode_;
     return 0;
   }
-
   WEBRTC_FUNC(SetAgcStatus, (bool enable, webrtc::AgcModes mode)) {
     agc_enabled_ = enable;
     agc_mode_ = mode;
     return 0;
   }
   WEBRTC_FUNC(GetAgcStatus, (bool& enabled, webrtc::AgcModes& mode)) {
     enabled = agc_enabled_;
     mode = agc_mode_;
     return 0;
   }
-
   WEBRTC_FUNC(SetAgcConfig, (webrtc::AgcConfig config)) {
     agc_config_ = config;
     return 0;
   }
   WEBRTC_FUNC(GetAgcConfig, (webrtc::AgcConfig& config)) {
     config = agc_config_;
     return 0;
   }
   WEBRTC_FUNC(SetEcStatus, (bool enable, webrtc::EcModes mode)) {
     ec_enabled_ = enable;
@@ skipping 21 matching lines @@
   }
   WEBRTC_STUB(VoiceActivityIndicator, (int channel));
   WEBRTC_FUNC(SetEcMetricsStatus, (bool enable)) {
     ec_metrics_enabled_ = enable;
     return 0;
   }
   WEBRTC_STUB(GetEcMetricsStatus, (bool& enabled));
   WEBRTC_STUB(GetEchoMetrics, (int& ERL, int& ERLE, int& RERL, int& A_NLP));
   WEBRTC_STUB(GetEcDelayMetrics, (int& delay_median, int& delay_std,
       float& fraction_poor_delays));
-
   WEBRTC_STUB(StartDebugRecording, (const char* fileNameUTF8));
   WEBRTC_STUB(StartDebugRecording, (FILE* handle));
   WEBRTC_STUB(StopDebugRecording, ());
-
   WEBRTC_FUNC(SetTypingDetectionStatus, (bool enable)) {
     typing_detection_enabled_ = enable;
     return 0;
   }
   WEBRTC_FUNC(GetTypingDetectionStatus, (bool& enabled)) {
     enabled = typing_detection_enabled_;
     return 0;
   }
-
   WEBRTC_STUB(TimeSinceLastTyping, (int& seconds));
   WEBRTC_STUB(SetTypingDetectionParameters, (int timeWindow,
                                              int costPerTyping,
                                              int reportingThreshold,
                                              int penaltyDecay,
                                              int typeEventDelay));
   int EnableHighPassFilter(bool enable) override {
     highpass_filter_enabled_ = enable;
     return 0;
   }
@@ skipping 28 matching lines @@
   bool ns_enabled_ = false;
   bool agc_enabled_ = false;
   bool highpass_filter_enabled_ = false;
   bool stereo_swapping_enabled_ = false;
   bool typing_detection_enabled_ = false;
   webrtc::EcModes ec_mode_ = webrtc::kEcDefault;
   webrtc::AecmModes aecm_mode_ = webrtc::kAecmSpeakerphone;
   webrtc::NsModes ns_mode_ = webrtc::kNsDefault;
   webrtc::AgcModes agc_mode_ = webrtc::kAgcDefault;
   webrtc::AgcConfig agc_config_;
-  FakeAudioProcessing audio_processing_;
+  webrtc::AudioProcessing* apm_ = nullptr;
+
+  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(FakeWebRtcVoiceEngine);
 };
 
 }  // namespace cricket
 
 #endif  // WEBRTC_MEDIA_ENGINE_FAKEWEBRTCVOICEENGINE_H_