AVAudioEngine version AudioDeviceModule 2

audio/audio_send_stream.cc

@@ -415,11 +415,6 @@ void AudioSendStream::SetMuted(bool muted) {
   channel_send_->SetInputMute(muted);
 }
 
-bool AudioSendStream::GetMuted() {
-  RTC_DCHECK_RUN_ON(&worker_thread_checker_);
-  return channel_send_->InputMute();
-}
-
 webrtc::AudioSendStream::Stats AudioSendStream::GetStats() const {
   return GetStats(true);
 }

audio/audio_send_stream.h

@@ -94,7 +94,6 @@ class AudioSendStream final : public webrtc::AudioSendStream,
                           int payload_frequency,
                           int event,
                           int duration_ms) override;
-  bool GetMuted() override;
   void SetMuted(bool muted) override;
   webrtc::AudioSendStream::Stats GetStats() const override;
   webrtc::AudioSendStream::Stats GetStats(

audio/audio_state.cc

@@ -98,26 +98,22 @@ void AudioState::AddSendingStream(webrtc::AudioSendStream* stream,
   UpdateAudioTransportWithSendingStreams();
 
   // Make sure recording is initialized; start recording if enabled.
-  if (ShouldRecord()) {
-    auto* adm = config_.audio_device_module.get();
-    if (!adm->Recording()) {
-      if (adm->InitRecording() == 0) {
-        if (recording_enabled_) {
-
-          // TODO: Verify if the following windows only logic is still required.
+  auto* adm = config_.audio_device_module.get();
+  if (!adm->Recording()) {
+    if (adm->InitRecording() == 0) {
+      if (recording_enabled_) {
 #if defined(WEBRTC_WIN)
-          if (adm->BuiltInAECIsAvailable() && !adm->Playing()) {
-            if (!adm->PlayoutIsInitialized()) {
-              adm->InitPlayout();
-            }
-            adm->StartPlayout();
+        if (adm->BuiltInAECIsAvailable() && !adm->Playing()) {
+          if (!adm->PlayoutIsInitialized()) {
+            adm->InitPlayout();
           }
-#endif
-          adm->StartRecording();
+          adm->StartPlayout();
         }
-      } else {
-        RTC_DLOG_F(LS_ERROR) << "Failed to initialize recording.";
+#endif
+        adm->StartRecording();
       }
+    } else {
+      RTC_DLOG_F(LS_ERROR) << "Failed to initialize recording.";
     }
   }
 }
@@ -127,10 +123,7 @@ void AudioState::RemoveSendingStream(webrtc::AudioSendStream* stream) {
   auto count = sending_streams_.erase(stream);
   RTC_DCHECK_EQ(1, count);
   UpdateAudioTransportWithSendingStreams();
-
-  bool should_record = ShouldRecord();
-  RTC_LOG(LS_INFO) << "RemoveSendingStream: should_record = " << should_record;
-  if (!should_record) {
+  if (sending_streams_.empty()) {
     config_.audio_device_module->StopRecording();
   }
 }
@@ -158,7 +151,7 @@ void AudioState::SetRecording(bool enabled) {
   if (recording_enabled_ != enabled) {
     recording_enabled_ = enabled;
     if (enabled) {
-      if (ShouldRecord()) {
+      if (!sending_streams_.empty()) {
         config_.audio_device_module->StartRecording();
       }
     } else {
@@ -218,43 +211,6 @@ void AudioState::UpdateNullAudioPollerState() {
     null_audio_poller_.Stop();
   }
 }
-
-void AudioState::OnMuteStreamChanged() {
-
-  auto* adm = config_.audio_device_module.get();
-  bool should_record = ShouldRecord();
-
-  RTC_LOG(LS_INFO) << "OnMuteStreamChanged: should_record = " << should_record;
-  if (should_record && !adm->Recording()) {
-    if (adm->InitRecording() == 0) {
-      adm->StartRecording();
-    }
-  } else if (!should_record && adm->Recording()) {
-    adm->StopRecording();
-  }
-}
-
-bool AudioState::ShouldRecord() {
-  RTC_LOG(LS_INFO) << "ShouldRecord";
-  // no streams to send
-  if (sending_streams_.empty()) {
-    RTC_LOG(LS_INFO) << "ShouldRecord: send stream = empty";
-    return false;
-  }
-
-  int stream_count = sending_streams_.size();
-
-  int muted_count = 0;
-  for (const auto& kv : sending_streams_) {
-    if (kv.first->GetMuted()) {
-      muted_count++;
-    }
-  }
-
-  RTC_LOG(LS_INFO) << "ShouldRecord: " << muted_count << " muted, " << stream_count << " sending";
-  return muted_count != stream_count;
-}
-
 }  // namespace internal
 
 rtc::scoped_refptr<AudioState> AudioState::Create(

audio/audio_state.h

@@ -47,8 +47,6 @@ class AudioState : public webrtc::AudioState {
 
   void SetStereoChannelSwapping(bool enable) override;
 
-  void OnMuteStreamChanged() override;
-
   AudioDeviceModule* audio_device_module() {
     RTC_DCHECK(config_.audio_device_module);
     return config_.audio_device_module.get();
@@ -66,9 +64,6 @@ class AudioState : public webrtc::AudioState {
   void UpdateAudioTransportWithSendingStreams();
   void UpdateNullAudioPollerState() RTC_RUN_ON(&thread_checker_);
 
-  // Returns true when at least 1 stream exists and all streams are not muted.
-  bool ShouldRecord();
-
   SequenceChecker thread_checker_;
   SequenceChecker process_thread_checker_{SequenceChecker::kDetached};
   const webrtc::AudioState::Config config_;

audio/channel_send.cc

@@ -100,8 +100,6 @@ class ChannelSend : public ChannelSendInterface,
   // Muting, Volume and Level.
   void SetInputMute(bool enable) override;
 
-  bool InputMute() const override;
-
   // Stats.
   ANAStats GetANAStatistics() const override;
 
@@ -165,6 +163,8 @@ class ChannelSend : public ChannelSendInterface,
                    size_t payloadSize,
                    int64_t absolute_capture_timestamp_ms) override;
 
+  bool InputMute() const;
+
   int32_t SendRtpAudio(AudioFrameType frameType,
                        uint8_t payloadType,
                        uint32_t rtp_timestamp_without_offset,

audio/channel_send.h

@@ -83,8 +83,6 @@ class ChannelSendInterface {
   virtual bool SendTelephoneEventOutband(int event, int duration_ms) = 0;
   virtual void OnBitrateAllocation(BitrateAllocationUpdate update) = 0;
   virtual int GetTargetBitrate() const = 0;
-
-  virtual bool InputMute() const = 0;
   virtual void SetInputMute(bool muted) = 0;
 
   virtual void ProcessAndEncodeAudio(

call/audio_send_stream.h

@@ -190,7 +190,6 @@ class AudioSendStream : public AudioSender {
                                   int event,
                                   int duration_ms) = 0;
 
-  virtual bool GetMuted() = 0;
   virtual void SetMuted(bool muted) = 0;
 
   virtual Stats GetStats() const = 0;

call/audio_state.h

@@ -59,9 +59,6 @@ class AudioState : public rtc::RefCountInterface {
 
   virtual void SetStereoChannelSwapping(bool enable) = 0;
 
-  // Notify the AudioState that a stream updated it's mute state.
-  virtual void OnMuteStreamChanged() = 0;
-
   static rtc::scoped_refptr<AudioState> Create(
       const AudioState::Config& config);
 

media/engine/webrtc_voice_engine.cc

@@ -427,15 +427,10 @@ void WebRtcVoiceEngine::Init() {
   // Set default engine options.
   {
     AudioOptions options;
-    options.echo_cancellation = true;
-    options.auto_gain_control = true;
-#if defined(WEBRTC_IOS)
-    // On iOS, VPIO provides built-in NS.
+    options.echo_cancellation = false;
+    options.auto_gain_control = false;
     options.noise_suppression = false;
-#else
-    options.noise_suppression = true;
-#endif
-    options.highpass_filter = true;
+    options.highpass_filter = false;
     options.stereo_swapping = false;
     options.audio_jitter_buffer_max_packets = 200;
     options.audio_jitter_buffer_fast_accelerate = false;
@@ -483,31 +478,14 @@ void WebRtcVoiceEngine::ApplyOptions(const AudioOptions& options_in) {
   // Use desktop AEC by default, when not using hardware AEC.
   bool use_mobile_software_aec = false;
 
-#if defined(WEBRTC_IOS) && !TARGET_OS_SIMULATOR
-  if (options.ios_force_software_aec_HACK &&
-      *options.ios_force_software_aec_HACK) {
-    // EC may be forced on for a device known to have non-functioning platform
-    // AEC.
-    options.echo_cancellation = true;
-    RTC_LOG(LS_WARNING)
-        << "Force software AEC on iOS. May conflict with platform AEC.";
-  } else {
-    // On iOS, VPIO provides built-in EC.
-    options.echo_cancellation = false;
-    RTC_LOG(LS_INFO) << "Always disable AEC on iOS. Use built-in instead.";
-  }
-#elif defined(WEBRTC_ANDROID)
-  use_mobile_software_aec = true;
-#endif
+  // Skip AEC AGC NS option manipulation for iOS adn macOS.
+#if !(defined(WEBRTC_IOS) || defined(WEBRTC_MAC))
 
-// Set and adjust gain control options.
-#if defined(WEBRTC_IOS) && !TARGET_OS_SIMULATOR
-  // On iOS, VPIO provides built-in AGC.
-  options.auto_gain_control = false;
-  RTC_LOG(LS_INFO) << "Always disable AGC on iOS. Use built-in instead.";
+#if defined(WEBRTC_ANDROID)
+  use_mobile_software_aec = true;
 #endif
 
-#if defined(WEBRTC_IOS) || defined(WEBRTC_ANDROID)
+#if defined(WEBRTC_ANDROID)
   // Turn off the gain control if specified by the field trial.
   // The purpose of the field trial is to reduce the amount of resampling
   // performed inside the audio processing module on mobile platforms by
@@ -573,6 +551,7 @@ void WebRtcVoiceEngine::ApplyOptions(const AudioOptions& options_in) {
       }
     }
   }
+#endif
 
   if (options.stereo_swapping) {
     audio_state()->SetStereoChannelSwapping(*options.stereo_swapping);
@@ -606,7 +585,7 @@ void WebRtcVoiceEngine::ApplyOptions(const AudioOptions& options_in) {
   if (options.auto_gain_control) {
     const bool enabled = *options.auto_gain_control;
     apm_config.gain_controller1.enabled = enabled;
-#if defined(WEBRTC_IOS) || defined(WEBRTC_ANDROID)
+#if defined(WEBRTC_IOS) || defined(WEBRTC_MAC) || defined(WEBRTC_ANDROID)
     apm_config.gain_controller1.mode =
         apm_config.gain_controller1.kFixedDigital;
 #else
@@ -942,7 +921,7 @@ class WebRtcVoiceSendChannel::WebRtcAudioSendStream : public AudioSource::Sink {
     muted_ = muted;
   }
 
-  bool muted() const {
+  bool IsMuted() const {
     RTC_DCHECK_RUN_ON(&worker_thread_checker_);
     return muted_;
   }
@@ -969,6 +948,11 @@ class WebRtcVoiceSendChannel::WebRtcAudioSendStream : public AudioSource::Sink {
     UpdateSendState();
   }
 
+  bool HasSource() const {
+    RTC_DCHECK_RUN_ON(&worker_thread_checker_);
+    return source_ != nullptr;
+  }
+
   // Stops sending by setting the sink of the AudioSource to nullptr. No data
   // callback will be received after this method.
   // This method is called on the libjingle worker thread.
@@ -1689,17 +1673,36 @@ bool WebRtcVoiceSendChannel::MuteStream(uint32_t ssrc, bool muted) {
   // This implementation is not ideal, instead we should signal the AGC when
   // the mic channel is muted/unmuted. We can't do it today because there
   // is no good way to know which stream is mapping to the mic channel.
-  bool all_muted = muted;
-  for (const auto& kv : send_streams_) {
-    all_muted = all_muted && kv.second->muted();
-  }
-  webrtc::AudioProcessing* ap = engine()->apm();
-  if (ap) {
-    ap->set_output_will_be_muted(all_muted);
-  }
+  if (send_streams_.size() > 0) {
+    // This will be true if MuteStream is called from
+    // AudioRtpSender::ClearSend().
+    bool is_all_no_source =
+        std::none_of(send_streams_.begin(), send_streams_.end(),
+                     [](const auto& kv) { return kv.second->HasSource(); });
+
+    bool is_all_muted =
+        std::all_of(send_streams_.begin(), send_streams_.end(),
+                    [](const auto& kv) { return kv.second->IsMuted(); });
+
+    // Only mute the microphone if we're not in cleanup state
+    // (i.e. if we have active send streams)
+    webrtc::AudioProcessing* ap = engine()->apm();
+    if (ap) {
+      bool v = !is_all_no_source && is_all_muted;
+      RTC_LOG(LS_INFO) << "WebRtcVoiceSendChannel::MuteStream: APM:" << v;
+      ap->set_output_will_be_muted(v);
+    }
 
-  // Notfy the AudioState that the mute state has updated.
-  engine_->audio_state()->OnMuteStreamChanged();
+    if (!is_all_no_source) {
+      // We don't mute when ClearSend() is called.
+      webrtc::AudioDeviceModule* adm = engine()->adm();
+      if (adm) {
+        RTC_LOG(LS_INFO) << "WebRtcVoiceSendChannel::MuteStream: ADM:"
+                         << is_all_muted;
+        adm->SetMicrophoneMute(is_all_muted);
+      }
+    }
+  }
 
   return true;
 }

media/engine/webrtc_voice_engine.h

@@ -132,8 +132,6 @@ class WebRtcVoiceEngine final : public VoiceEngineInterface {
 
   absl::optional<webrtc::AudioDeviceModule::Stats> GetAudioDeviceStats()
       override;
-  // Moved to public so WebRtcVoiceMediaChannel can access it.
-  webrtc::AudioState* audio_state();
 
  private:
   // Every option that is "set" will be applied. Every option not "set" will be
@@ -147,6 +145,7 @@ class WebRtcVoiceEngine final : public VoiceEngineInterface {
 
   webrtc::AudioDeviceModule* adm();
   webrtc::AudioProcessing* apm() const;
+  webrtc::AudioState* audio_state();
 
   std::vector<AudioCodec> CollectCodecs(
       const std::vector<webrtc::AudioCodecSpec>& specs) const;

modules/audio_device/BUILD.gn

@@ -377,12 +377,25 @@ rtc_library("audio_device_impl") {
           "linux/pulseaudiosymboltable_linux.h",
         ]
       }
+      if (is_mac || is_ios) {
+        sources += [
+          "audio_engine_device.h",
+          "audio_engine_device.mm",
+        ]
+      }
+      if (is_ios) {
+        deps += [
+          "../../sdk:audio_session_objc",
+        ]
+      }
       if (is_mac) {
         sources += [
           "mac/audio_device_mac.cc",
           "mac/audio_device_mac.h",
           "mac/audio_mixer_manager_mac.cc",
           "mac/audio_mixer_manager_mac.h",
+          "mac/audio_device_utils_mac.cc",
+          "mac/audio_device_utils_mac.h",
         ]
         deps += [
           ":audio_device_impl_frameworks",

modules/audio_device/audio_device_buffer.cc

@@ -193,6 +193,16 @@ void AudioDeviceBuffer::StopRecording() {
   RTC_LOG(LS_INFO) << "total recording time: " << time_since_start;
 }
 
+bool AudioDeviceBuffer::IsPlaying() {
+  RTC_DCHECK_RUN_ON(&main_thread_checker_);
+  return playing_;
+}
+
+bool AudioDeviceBuffer::IsRecording() {
+  RTC_DCHECK_RUN_ON(&main_thread_checker_);
+  return recording_;
+}
+
 int32_t AudioDeviceBuffer::SetRecordingSampleRate(uint32_t fsHz) {
   RTC_LOG(LS_INFO) << "SetRecordingSampleRate(" << fsHz << ")";
   rec_sample_rate_ = fsHz;

modules/audio_device/audio_device_buffer.h

@@ -93,6 +93,9 @@ class AudioDeviceBuffer {
   void StopPlayout();
   void StopRecording();
 
+  bool IsPlaying();
+  bool IsRecording();
+
   int32_t SetRecordingSampleRate(uint32_t fsHz);
   int32_t SetPlayoutSampleRate(uint32_t fsHz);
   uint32_t RecordingSampleRate() const;