Remove WVoE::SetAudioDeviceModule() - it is now set in ctor.

webrtc/media/engine/webrtcvoiceengine.cc

 /*
  *  Copyright (c) 2004 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 231 matching lines @@
   webrtc::AudioState::Config config;
   config.voice_engine = voe_wrapper->engine();
   return config;
 }
 
 class WebRtcVoiceCodecs final {
  public:
   // TODO(solenberg): Do this filtering once off-line, add a simple AudioCodec
   // list and add a test which verifies VoE supports the listed codecs.
   static std::vector<AudioCodec> SupportedCodecs() {
-    LOG(LS_INFO) << "WebRtc VoiceEngine codecs:";
     std::vector<AudioCodec> result;
     for (webrtc::CodecInst voe_codec : webrtc::acm2::RentACodec::Database()) {
       // Change the sample rate of G722 to 8000 to match SDP.
       MaybeFixupG722(&voe_codec, 8000);
       // Skip uncompressed formats.
       if (IsCodec(voe_codec, kL16CodecName)) {
         continue;
       }
 
       const CodecPref* pref = NULL;
       for (size_t j = 0; j < arraysize(kCodecPrefs); ++j) {
         if (IsCodec(voe_codec, kCodecPrefs[j].name) &&
             kCodecPrefs[j].clockrate == voe_codec.plfreq &&
             kCodecPrefs[j].channels == voe_codec.channels) {
           pref = &kCodecPrefs[j];
           break;
         }
       }
 
       if (pref) {
         // Use the payload type that we've configured in our pref table;
         // use the offset in our pref table to determine the sort order.
         AudioCodec codec(
             pref->payload_type, voe_codec.plname, voe_codec.plfreq,
             voe_codec.rate, voe_codec.channels,
             static_cast<int>(arraysize(kCodecPrefs)) - (pref - kCodecPrefs));
-        LOG(LS_INFO) << ToString(codec);
         if (IsCodec(codec, kIsacCodecName)) {
           // Indicate auto-bitrate in signaling.
           codec.bitrate = 0;
         }
         if (IsCodec(codec, kOpusCodecName)) {
           // Only add fmtp parameters that differ from the spec.
           if (kPreferredMinPTime != kOpusDefaultMinPTime) {
             codec.params[kCodecParamMinPTime] =
                 rtc::ToString(kPreferredMinPTime);
           }
           if (kPreferredMaxPTime != kOpusDefaultMaxPTime) {
             codec.params[kCodecParamMaxPTime] =
                 rtc::ToString(kPreferredMaxPTime);
           }
           codec.SetParam(kCodecParamUseInbandFec, 1);
           codec.AddFeedbackParam(
               FeedbackParam(kRtcpFbParamTransportCc, kParamValueEmpty));
 
           // TODO(hellner): Add ptime, sprop-stereo, and stereo
           // when they can be set to values other than the default.
         }
         result.push_back(codec);
       } else {
-        LOG(LS_WARNING) << "Unexpected codec: " << ToString(voe_codec);
+        LOG(LS_INFO) << "[Unused] " << ToString(voe_codec);
       }
     }
     // Make sure they are in local preference order.
     std::sort(result.begin(), result.end(), &AudioCodec::Preferable);
     return result;
   }
 
   static bool ToCodecInst(const AudioCodec& in,
                           webrtc::CodecInst* out) {
     for (webrtc::CodecInst voe_codec : webrtc::acm2::RentACodec::Database()) {
@@ skipping 194 matching lines @@
   { kRedCodecName,    8000,  1, 127, false, { } },
   { kDtmfCodecName,   8000,  1, 126, false, { } },
 };
 } // namespace {
 
 bool WebRtcVoiceEngine::ToCodecInst(const AudioCodec& in,
                                     webrtc::CodecInst* out) {
   return WebRtcVoiceCodecs::ToCodecInst(in, out);
 }
 
-WebRtcVoiceEngine::WebRtcVoiceEngine()
-    : voe_wrapper_(new VoEWrapper()),
-      audio_state_(webrtc::AudioState::Create(MakeAudioStateConfig(voe()))) {
-  Construct();
+WebRtcVoiceEngine::WebRtcVoiceEngine(webrtc::AudioDeviceModule* adm)
+    : WebRtcVoiceEngine(adm, new VoEWrapper()) {
+  audio_state_ = webrtc::AudioState::Create(MakeAudioStateConfig(voe()));
 }
 
-WebRtcVoiceEngine::WebRtcVoiceEngine(VoEWrapper* voe_wrapper)
-    : voe_wrapper_(voe_wrapper) {
-  Construct();
-}
-
-void WebRtcVoiceEngine::Construct() {
+WebRtcVoiceEngine::WebRtcVoiceEngine(webrtc::AudioDeviceModule* adm,
+                                     VoEWrapper* voe_wrapper)
+    : adm_(adm), voe_wrapper_(voe_wrapper) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  LOG(LS_VERBOSE) << "WebRtcVoiceEngine::WebRtcVoiceEngine";
+  LOG(LS_INFO) << "WebRtcVoiceEngine::WebRtcVoiceEngine";
+  RTC_DCHECK(voe_wrapper);
 
   signal_thread_checker_.DetachFromThread();
-  std::memset(&default_agc_config_, 0, sizeof(default_agc_config_));
+
+  // Load our audio codec list.
+  LOG(LS_INFO) << "Supported codecs in order of preference:";
+  codecs_ = WebRtcVoiceCodecs::SupportedCodecs();
+  for (const AudioCodec& codec : codecs_) {
+    LOG(LS_INFO) << ToString(codec);
+  }
+
   voe_config_.Set<webrtc::VoicePacing>(new webrtc::VoicePacing(true));
 
-  webrtc::Trace::set_level_filter(kDefaultTraceFilter);
+  // Temporarily turn logging level up for the Init() call.
   webrtc::Trace::SetTraceCallback(this);
-
-  // Load our audio codec list.
-  codecs_ = WebRtcVoiceCodecs::SupportedCodecs();
-}
-
-WebRtcVoiceEngine::~WebRtcVoiceEngine() {
-  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  LOG(LS_VERBOSE) << "WebRtcVoiceEngine::~WebRtcVoiceEngine";
-  if (adm_) {
-    voe_wrapper_.reset();
-    adm_->Release();
-    adm_ = NULL;
-  }
-  webrtc::Trace::SetTraceCallback(nullptr);
-}
-
-bool WebRtcVoiceEngine::Init(rtc::Thread* worker_thread) {
-  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  RTC_DCHECK(worker_thread == rtc::Thread::Current());
-  LOG(LS_INFO) << "WebRtcVoiceEngine::Init";
-  bool res = InitInternal();
-  if (res) {
-    LOG(LS_INFO) << "WebRtcVoiceEngine::Init Done!";
-  } else {
-    LOG(LS_ERROR) << "WebRtcVoiceEngine::Init failed";
-    Terminate();
-  }
-  return res;
-}
-
-bool WebRtcVoiceEngine::InitInternal() {
-  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  // Temporarily turn logging level up for the Init call.
   webrtc::Trace::set_level_filter(kElevatedTraceFilter);
   LOG(LS_INFO) << webrtc::VoiceEngine::GetVersionString();
-  if (voe_wrapper_->base()->Init(adm_) == -1) {
-    LOG_RTCERR0_EX(Init, voe_wrapper_->error());
-    return false;
+  RTC_CHECK_EQ(0, voe_wrapper_->base()->Init(adm_.get()));
+  webrtc::Trace::set_level_filter(kDefaultTraceFilter);
+
+  // No ADM supplied? Get the default one from VoE.
+  if (!adm_) {
+    adm_ = voe_wrapper_->base()->audio_device_module();
   }
-  webrtc::Trace::set_level_filter(kDefaultTraceFilter);
+  RTC_DCHECK(adm_);
 
   // Save the default AGC configuration settings. This must happen before
   // calling ApplyOptions or the default will be overwritten.
-  if (voe_wrapper_->processing()->GetAgcConfig(default_agc_config_) == -1) {
-    LOG_RTCERR0(GetAgcConfig);
-    return false;
-  }
+  int error = voe_wrapper_->processing()->GetAgcConfig(default_agc_config_);
+  RTC_DCHECK_EQ(0, error);
 
   // Set default engine options.
   {
     AudioOptions options;
     options.echo_cancellation = rtc::Optional<bool>(true);
     options.auto_gain_control = rtc::Optional<bool>(true);
     options.noise_suppression = rtc::Optional<bool>(true);
     options.highpass_filter = rtc::Optional<bool>(true);
     options.stereo_swapping = rtc::Optional<bool>(false);
     options.audio_jitter_buffer_max_packets = rtc::Optional<int>(50);
     options.audio_jitter_buffer_fast_accelerate = rtc::Optional<bool>(false);
     options.typing_detection = rtc::Optional<bool>(true);
     options.adjust_agc_delta = rtc::Optional<int>(0);
     options.experimental_agc = rtc::Optional<bool>(false);
     options.extended_filter_aec = rtc::Optional<bool>(false);
     options.delay_agnostic_aec = rtc::Optional<bool>(false);
     options.experimental_ns = rtc::Optional<bool>(false);
-    if (!ApplyOptions(options)) {
-      return false;
-    }
-  }
-
-  // Print our codec list again for the call diagnostic log.
-  LOG(LS_INFO) << "WebRtc VoiceEngine codecs:";
-  for (const AudioCodec& codec : codecs_) {
-    LOG(LS_INFO) << ToString(codec);
+    bool error = ApplyOptions(options);
+    RTC_DCHECK(error);
   }
 
   SetDefaultDevices();
-
-  initialized_ = true;
-  return true;
 }
 
-void WebRtcVoiceEngine::Terminate() {
+WebRtcVoiceEngine::~WebRtcVoiceEngine() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  LOG(LS_INFO) << "WebRtcVoiceEngine::Terminate";
-  initialized_ = false;
-
+  LOG(LS_INFO) << "WebRtcVoiceEngine::~WebRtcVoiceEngine";
   StopAecDump();
-
   voe_wrapper_->base()->Terminate();
+  webrtc::Trace::SetTraceCallback(nullptr);
 }
 
 rtc::scoped_refptr<webrtc::AudioState>
     WebRtcVoiceEngine::GetAudioState() const {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   return audio_state_;
 }
 
 VoiceMediaChannel* WebRtcVoiceEngine::CreateChannel(
     webrtc::Call* call,
     const MediaConfig& config,
     const AudioOptions& options) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   return new WebRtcVoiceMediaChannel(this, config, options, call);
 }
 
 bool WebRtcVoiceEngine::ApplyOptions(const AudioOptions& options_in) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  LOG(LS_INFO) << "ApplyOptions: " << options_in.ToString();
+  LOG(LS_INFO) << "WebRtcVoiceEngine::ApplyOptions: " << options_in.ToString();
   AudioOptions options = options_in;  // The options are modified below.
 
   // kEcConference is AEC with high suppression.
   webrtc::EcModes ec_mode = webrtc::kEcConference;
   webrtc::AecmModes aecm_mode = webrtc::kAecmSpeakerphone;
   webrtc::AgcModes agc_mode = webrtc::kAgcAdaptiveAnalog;
   webrtc::NsModes ns_mode = webrtc::kNsHighSuppression;
   if (options.aecm_generate_comfort_noise) {
     LOG(LS_VERBOSE) << "Comfort noise explicitly set to "
                     << *options.aecm_generate_comfort_noise
@@ skipping 384 matching lines @@
                << default_agc_config_.targetLeveldBOv << "dB to -"
                << config.targetLeveldBOv << "dB";
 
   if (voe_wrapper_->processing()->SetAgcConfig(config) == -1) {
     LOG_RTCERR1(SetAgcConfig, config.targetLeveldBOv);
     return false;
   }
   return true;
 }
 
-bool WebRtcVoiceEngine::SetAudioDeviceModule(webrtc::AudioDeviceModule* adm) {
-  RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
-  if (initialized_) {
-    LOG(LS_WARNING) << "SetAudioDeviceModule can not be called after Init.";
-    return false;
-  }
-  if (adm_) {
-    adm_->Release();
-    adm_ = NULL;
-  }
-  if (adm) {
-    adm_ = adm;
-    adm_->AddRef();
-  }
-  return true;
-}
-
 bool WebRtcVoiceEngine::StartAecDump(rtc::PlatformFile file,
                                      int64_t max_size_bytes) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   FILE* aec_dump_file_stream = rtc::FdopenPlatformFileForWriting(file);
   if (!aec_dump_file_stream) {
     LOG(LS_ERROR) << "Could not open AEC dump file stream.";
     if (!rtc::ClosePlatformFile(file))
       LOG(LS_WARNING) << "Could not close file.";
     return false;
   }
@@ skipping 1473 matching lines @@
     }
   } else {
     LOG(LS_INFO) << "Stopping playout for channel #" << channel;
     engine()->voe()->base()->StopPlayout(channel);
   }
   return true;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE