Move VoiceEngineObserver into AudioSendStream so that we detect typing noises and return properly i…

talk/media/webrtc/webrtcvoiceengine.cc

 /*
  * libjingle
  * Copyright 2004 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 370 matching lines @@
   options.extended_filter_aec.Set(false);
   options.delay_agnostic_aec.Set(false);
   options.experimental_ns.Set(false);
   options.aec_dump.Set(false);
   return options;
 }
 
 std::string GetEnableString(bool enable) {
   return enable ? "enable" : "disable";
 }
+
+webrtc::AudioState::Config MakeAudioStateConfig(VoEWrapper* voe_wrapper) {
+  webrtc::AudioState::Config config;
+  config.voice_engine = voe_wrapper->engine();
+  return config;
+}
+
 } // namespace {
 
 WebRtcVoiceEngine::WebRtcVoiceEngine()
     : voe_wrapper_(new VoEWrapper()),
       tracing_(new VoETraceWrapper()),
-      adm_(NULL),
-      log_filter_(SeverityToFilter(kDefaultLogSeverity)),
-      is_dumping_aec_(false) {
+      audio_state_(webrtc::AudioState::Create(MakeAudioStateConfig(voe()))),
+      log_filter_(SeverityToFilter(kDefaultLogSeverity)) {
   Construct();
 }
 
 WebRtcVoiceEngine::WebRtcVoiceEngine(VoEWrapper* voe_wrapper,
-                                     VoETraceWrapper* tracing)
+                                     VoETraceWrapper* tracing,
+                                     webrtc::AudioState* audio_state)
     : voe_wrapper_(voe_wrapper),
       tracing_(tracing),
-      adm_(NULL),
-      log_filter_(SeverityToFilter(kDefaultLogSeverity)),
-      is_dumping_aec_(false) {
+      audio_state_(audio_state),
+      log_filter_(SeverityToFilter(kDefaultLogSeverity)) {
   Construct();
 }
 
 void WebRtcVoiceEngine::Construct() {
+  std::memset(&default_agc_config_, 0, sizeof(default_agc_config_));
   SetTraceFilter(log_filter_);
-  initialized_ = false;
   LOG(LS_VERBOSE) << "WebRtcVoiceEngine::WebRtcVoiceEngine";
   SetTraceOptions("");
   if (tracing_->SetTraceCallback(this) == -1) {
     LOG_RTCERR0(SetTraceCallback);
   }
-  if (voe_wrapper_->base()->RegisterVoiceEngineObserver(*this) == -1) {
-    LOG_RTCERR0(RegisterVoiceEngineObserver);
-  }
-  // Clear the default agc state.
-  memset(&default_agc_config_, 0, sizeof(default_agc_config_));
 
   // Load our audio codec list.
   ConstructCodecs();
 
   // Load our RTP Header extensions.
   rtp_header_extensions_.push_back(
       RtpHeaderExtension(kRtpAudioLevelHeaderExtension,
                          kRtpAudioLevelHeaderExtensionDefaultId));
   rtp_header_extensions_.push_back(
       RtpHeaderExtension(kRtpAbsoluteSenderTimeHeaderExtension,
@@ skipping 67 matching lines @@
   if (voe_wrapper_->codec()->GetCodec(index, *codec) == -1) {
     return false;
   }
   // Change the sample rate of G722 to 8000 to match SDP.
   MaybeFixupG722(codec, 8000);
   return true;
 }
 
 WebRtcVoiceEngine::~WebRtcVoiceEngine() {
   LOG(LS_VERBOSE) << "WebRtcVoiceEngine::~WebRtcVoiceEngine";
-  if (voe_wrapper_->base()->DeRegisterVoiceEngineObserver() == -1) {
-    LOG_RTCERR0(DeRegisterVoiceEngineObserver);
-  }
   if (adm_) {
     voe_wrapper_.reset();
     adm_->Release();
     adm_ = NULL;
   }
 
   tracing_->SetTraceCallback(NULL);
 }
 
-bool WebRtcVoiceEngine::Init(rtc::Thread* worker_thread) {
-  RTC_DCHECK(worker_thread == rtc::Thread::Current());
+bool WebRtcVoiceEngine::Init(rtc::Thread* thread) {
+  RTC_DCHECK(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;
 }
@@ skipping 658 matching lines @@
   if (length < 72) {
     std::string msg(trace, length);
     LOG(LS_ERROR) << "Malformed webrtc log message: ";
     LOG_V(sev) << msg;
   } else {
     std::string msg(trace + 71, length - 72);
     LOG_V(sev) << "webrtc: " << msg;
   }
 }
 
-void WebRtcVoiceEngine::CallbackOnError(int channel_id, int err_code) {
-  RTC_DCHECK(channel_id == -1);
-  LOG(LS_WARNING) << "VoiceEngine error " << err_code << " reported on channel "
-                  << channel_id << ".";
-  rtc::CritScope lock(&channels_cs_);
-  for (WebRtcVoiceMediaChannel* channel : channels_) {
-    channel->OnError(err_code);
-  }
-}
-
 void WebRtcVoiceEngine::RegisterChannel(WebRtcVoiceMediaChannel* channel) {
-  RTC_DCHECK(channel != NULL);
-  rtc::CritScope lock(&channels_cs_);
+  RTC_DCHECK(channel);
   channels_.push_back(channel);
 }
 
 void WebRtcVoiceEngine::UnregisterChannel(WebRtcVoiceMediaChannel* channel) {
-  rtc::CritScope lock(&channels_cs_);
   auto it = std::find(channels_.begin(), channels_.end(), channel);
-  if (it != channels_.end()) {
-    channels_.erase(it);
-  }
+  RTC_DCHECK(it != channels_.end());
+  channels_.erase(it);
 }
 
 // Adjusts the default AGC target level by the specified delta.
 // NB: If we start messing with other config fields, we'll want
 // to save the current webrtc::AgcConfig as well.
 bool WebRtcVoiceEngine::AdjustAgcLevel(int delta) {
   webrtc::AgcConfig config = default_agc_config_;
   config.targetLeveldBOv -= delta;
 
   LOG(LS_INFO) << "Adjusting AGC level from default -"
@@ skipping 90 matching lines @@
     // RTC_DCHECK(voe_audio_transport);
     RTC_DCHECK(call);
     audio_capture_thread_checker_.DetachFromThread();
     webrtc::AudioSendStream::Config config(nullptr);
     config.voe_channel_id = channel_;
     config.rtp.ssrc = ssrc;
     stream_ = call_->CreateAudioSendStream(config);
     RTC_DCHECK(stream_);
   }
   ~WebRtcAudioSendStream() override {
-    RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     Stop();
     call_->DestroyAudioSendStream(stream_);
   }
 
   // Starts the rendering by setting a sink to the renderer to get data
   // callback.
   // This method is called on the libjingle worker thread.
   // TODO(xians): Make sure Start() is called only once.
   void Start(AudioRenderer* renderer) {
-    RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     RTC_DCHECK(renderer);
     if (renderer_) {
       RTC_DCHECK(renderer_ == renderer);
       return;
     }
     renderer->SetSink(this);
     renderer_ = renderer;
   }
 
   webrtc::AudioSendStream::Stats GetStats() const {
-    RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     return stream_->GetStats();
   }
 
   // Stops rendering by setting the sink of the renderer to nullptr. No data
   // callback will be received after this method.
   // This method is called on the libjingle worker thread.
   void Stop() {
-    RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     if (renderer_) {
       renderer_->SetSink(nullptr);
       renderer_ = nullptr;
     }
   }
 
   // AudioRenderer::Sink implementation.
   // This method is called on the audio thread.
   void OnData(const void* audio_data,
               int bits_per_sample,
               int sample_rate,
               int number_of_channels,
               size_t number_of_frames) override {
+    RTC_DCHECK(!thread_checker_.CalledOnValidThread());
     RTC_DCHECK(audio_capture_thread_checker_.CalledOnValidThread());
     RTC_DCHECK(voe_audio_transport_);
     voe_audio_transport_->OnData(channel_,
                                  audio_data,
                                  bits_per_sample,
                                  sample_rate,
                                  number_of_channels,
                                  number_of_frames);
   }
 
   // Callback from the |renderer_| when it is going away. In case Start() has
   // never been called, this callback won't be triggered.
   void OnClose() override {
-    RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     // Set |renderer_| to nullptr to make sure no more callback will get into
     // the renderer.
     renderer_ = nullptr;
   }
 
   // Accessor to the VoE channel ID.
   int channel() const {
-    RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
+    RTC_DCHECK(thread_checker_.CalledOnValidThread());
     return channel_;
   }
 
  private:
-  rtc::ThreadChecker signal_thread_checker_;
+  rtc::ThreadChecker thread_checker_;
   rtc::ThreadChecker audio_capture_thread_checker_;
   const int channel_ = -1;
   webrtc::AudioTransport* const voe_audio_transport_ = nullptr;
   webrtc::Call* call_ = nullptr;
   webrtc::AudioSendStream* stream_ = nullptr;
 
   // Raw pointer to AudioRenderer owned by LocalAudioTrackHandler.
   // PeerConnection will make sure invalidating the pointer before the object
   // goes away.
   AudioRenderer* renderer_ = nullptr;
@@ skipping 11 matching lines @@
  private:
   int channel_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WebRtcAudioReceiveStream);
 };
 
 // WebRtcVoiceMediaChannel
 WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel(WebRtcVoiceEngine* engine,
                                                  const AudioOptions& options,
                                                  webrtc::Call* call)
-    : engine_(engine),
-      send_bitrate_setting_(false),
-      send_bitrate_bps_(0),
-      options_(),
-      dtmf_allowed_(false),
-      desired_playout_(false),
-      nack_enabled_(false),
-      playout_(false),
-      typing_noise_detected_(false),
-      desired_send_(SEND_NOTHING),
-      send_(SEND_NOTHING),
-      call_(call) {
+    : engine_(engine), call_(call) {
   LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel";
-  RTC_DCHECK(nullptr != call);
+  RTC_DCHECK(call);
   engine->RegisterChannel(this);
   SetOptions(options);
 }
 
 WebRtcVoiceMediaChannel::~WebRtcVoiceMediaChannel() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::~WebRtcVoiceMediaChannel";
 
   // Remove any remaining send streams.
   while (!send_streams_.empty()) {
@@ skipping 1184 matching lines @@
     sinfo.codec_name = stats.codec_name;
     sinfo.ext_seqnum = stats.ext_seqnum;
     sinfo.jitter_ms = stats.jitter_ms;
     sinfo.rtt_ms = stats.rtt_ms;
     sinfo.audio_level = stats.audio_level;
     sinfo.aec_quality_min = stats.aec_quality_min;
     sinfo.echo_delay_median_ms = stats.echo_delay_median_ms;
     sinfo.echo_delay_std_ms = stats.echo_delay_std_ms;
     sinfo.echo_return_loss = stats.echo_return_loss;
     sinfo.echo_return_loss_enhancement = stats.echo_return_loss_enhancement;
-    sinfo.typing_noise_detected = typing_noise_detected_;
-    // TODO(solenberg): Move to AudioSendStream.
-    //  sinfo.typing_noise_detected = stats.typing_noise_detected;
+    sinfo.typing_noise_detected =
+        (send_ == SEND_NOTHING ? false : stats.typing_noise_detected);
     info->senders.push_back(sinfo);
   }
 
   // Get SSRC and stats for each receiver.
   RTC_DCHECK(info->receivers.size() == 0);
   for (const auto& stream : receive_streams_) {
     webrtc::AudioReceiveStream::Stats stats = stream.second->GetStats();
     VoiceReceiverInfo rinfo;
     rinfo.add_ssrc(stats.remote_ssrc);
     rinfo.bytes_rcvd = stats.bytes_rcvd;
@@ skipping 19 matching lines @@
     rinfo.decoding_plc = stats.decoding_plc;
     rinfo.decoding_cng = stats.decoding_cng;
     rinfo.decoding_plc_cng = stats.decoding_plc_cng;
     rinfo.capture_start_ntp_time_ms = stats.capture_start_ntp_time_ms;
     info->receivers.push_back(rinfo);
   }
 
   return true;
 }
 
-void WebRtcVoiceMediaChannel::OnError(int error) {
-  if (send_ == SEND_NOTHING) {
-    return;
-  }
-  if (error == VE_TYPING_NOISE_WARNING) {
-    typing_noise_detected_ = true;
-  } else if (error == VE_TYPING_NOISE_OFF_WARNING) {
-    typing_noise_detected_ = false;
-  }
-}
-
 int WebRtcVoiceMediaChannel::GetOutputLevel(int channel) {
   unsigned int ulevel = 0;
   int ret = engine()->voe()->volume()->GetSpeechOutputLevel(channel, ulevel);
   return (ret == 0) ? static_cast<int>(ulevel) : -1;
 }
 
 int WebRtcVoiceMediaChannel::GetReceiveChannelId(uint32_t ssrc) const {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   const auto it = receive_channels_.find(ssrc);
   if (it != receive_channels_.end()) {
@@ skipping 62 matching lines @@
       LOG_RTCERR1(StartPlayout, channel);
       return false;
     }
   } else {
     LOG(LS_INFO) << "Stopping playout for channel #" << channel;
     engine()->voe()->base()->StopPlayout(channel);
   }
   return true;
 }
 
-// Convert VoiceEngine error code into VoiceMediaChannel::Error enum.
-VoiceMediaChannel::Error
-    WebRtcVoiceMediaChannel::WebRtcErrorToChannelError(int err_code) {
-  switch (err_code) {
-    case 0:
-      return ERROR_NONE;
-    case VE_CANNOT_START_RECORDING:
-    case VE_MIC_VOL_ERROR:
-    case VE_GET_MIC_VOL_ERROR:
-    case VE_CANNOT_ACCESS_MIC_VOL:
-      return ERROR_REC_DEVICE_OPEN_FAILED;
-    case VE_SATURATION_WARNING:
-      return ERROR_REC_DEVICE_SATURATION;
-    case VE_REC_DEVICE_REMOVED:
-      return ERROR_REC_DEVICE_REMOVED;
-    case VE_RUNTIME_REC_WARNING:
-    case VE_RUNTIME_REC_ERROR:
-      return ERROR_REC_RUNTIME_ERROR;
-    case VE_CANNOT_START_PLAYOUT:
-    case VE_SPEAKER_VOL_ERROR:
-    case VE_GET_SPEAKER_VOL_ERROR:
-    case VE_CANNOT_ACCESS_SPEAKER_VOL:
-      return ERROR_PLAY_DEVICE_OPEN_FAILED;
-    case VE_RUNTIME_PLAY_WARNING:
-    case VE_RUNTIME_PLAY_ERROR:
-      return ERROR_PLAY_RUNTIME_ERROR;
-    case VE_TYPING_NOISE_WARNING:
-      return ERROR_REC_TYPING_NOISE_DETECTED;
-    default:
-      return VoiceMediaChannel::ERROR_OTHER;
-  }
-}
-
 bool WebRtcVoiceMediaChannel::SetHeaderExtension(ExtensionSetterFunction setter,
     int channel_id, const RtpHeaderExtension* extension) {
   bool enable = false;
   int id = 0;
   std::string uri;
   if (extension) {
     enable = true;
     id = extension->id;
     uri = extension->uri;
   }
@@ skipping 60 matching lines @@
       LOG(LS_WARNING) << "Unknown codec " << ToString(codec);
       return false;
     }
   }
   return true;
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE