Moves channel-dependent audio input processing to separate encoder task queue

webrtc/voice_engine/voe_base_impl.cc

 /*
  *  Copyright (c) 2012 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 59 matching lines @@
   } else if (warning == AudioDeviceObserver::kPlayoutWarning) {
     warningCode = VE_RUNTIME_PLAY_WARNING;
     LOG_F(LS_WARNING) << "VE_RUNTIME_PLAY_WARNING";
   }
   if (voiceEngineObserverPtr_) {
     // Deliver callback (-1 <=> no channel dependency)
     voiceEngineObserverPtr_->CallbackOnError(-1, warningCode);
   }
 }
 
-int32_t VoEBaseImpl::RecordedDataIsAvailable(const void* audioSamples,
-                                             const size_t nSamples,
-                                             const size_t nBytesPerSample,
-                                             const size_t nChannels,
-                                             const uint32_t samplesPerSec,
-                                             const uint32_t totalDelayMS,
-                                             const int32_t clockDrift,
-                                             const uint32_t currentMicLevel,
-                                             const bool keyPressed,
-                                             uint32_t& newMicLevel) {
-  newMicLevel = static_cast<uint32_t>(ProcessRecordedDataWithAPM(
-      nullptr, 0, audioSamples, samplesPerSec, nChannels, nSamples,
-      totalDelayMS, clockDrift, currentMicLevel, keyPressed));
+int32_t VoEBaseImpl::RecordedDataIsAvailable(
+    const void* audio_data,
+    const size_t number_of_frames,
+    const size_t bytes_per_sample,
+    const size_t number_of_channels,
+    const uint32_t sample_rate,
+    const uint32_t audio_delay_milliseconds,
+    const int32_t clock_drift,
+    const uint32_t volume,
+    const bool key_pressed,
+    uint32_t& new_mic_volume) {
+  RTC_DCHECK_EQ(2 * number_of_channels, bytes_per_sample);
+  RTC_DCHECK(shared_->transmit_mixer() != nullptr);
+  RTC_DCHECK(shared_->audio_device() != nullptr);
+
+  uint32_t max_volume = 0;
+  uint16_t voe_mic_level = 0;
+  // Check for zero to skip this calculation; the consumer may use this to
+  // indicate no volume is available.
+  if (volume != 0) {
+    // Scale from ADM to VoE level range
+    if (shared_->audio_device()->MaxMicrophoneVolume(&max_volume) == 0) {
+      if (max_volume) {
+        voe_mic_level = static_cast<uint16_t>(
+            (volume * kMaxVolumeLevel + static_cast<int>(max_volume / 2)) /
+            max_volume);
+      }
+    }
+    // We learned that on certain systems (e.g Linux) the voe_mic_level
+    // can be greater than the maxVolumeLevel therefore
+    // we are going to cap the voe_mic_level to the maxVolumeLevel
+    // and change the maxVolume to volume if it turns out that
+    // the voe_mic_level is indeed greater than the maxVolumeLevel.
+    if (voe_mic_level > kMaxVolumeLevel) {
+      voe_mic_level = kMaxVolumeLevel;
+      max_volume = volume;
+    }
+  }
+
+  // Perform channel-independent operations
+  // (APM, mix with file, record to file, mute, etc.)
+  shared_->transmit_mixer()->PrepareDemux(
+      audio_data, number_of_frames, number_of_channels, sample_rate,
+      static_cast<uint16_t>(audio_delay_milliseconds), clock_drift,
+      voe_mic_level, key_pressed);
+
+  // Copy the audio frame to each sending channel and perform
+  // channel-dependent operations (file mixing, mute, etc.), encode and
+  // packetize+transmit the RTP packet.
+  shared_->transmit_mixer()->ProcessAndEncodeAudio();
+
+  // Scale from VoE to ADM level range.
+  uint32_t new_voe_mic_level = shared_->transmit_mixer()->CaptureLevel();
+  if (new_voe_mic_level != voe_mic_level) {
+    // Return the new volume if AGC has changed the volume.
+    return static_cast<int>((new_voe_mic_level * max_volume +
+                             static_cast<int>(kMaxVolumeLevel / 2)) /
+                            kMaxVolumeLevel);
+  }
+
   return 0;
 }
 
 int32_t VoEBaseImpl::NeedMorePlayData(const size_t nSamples,
                                       const size_t nBytesPerSample,
                                       const size_t nChannels,
                                       const uint32_t samplesPerSec,
                                       void* audioSamples,
                                       size_t& nSamplesOut,
                                       int64_t* elapsed_time_ms,
                                       int64_t* ntp_time_ms) {
   GetPlayoutData(static_cast<int>(samplesPerSec), nChannels, nSamples, true,
                  audioSamples, elapsed_time_ms, ntp_time_ms);
   nSamplesOut = audioFrame_.samples_per_channel_;
   return 0;
 }
 
 void VoEBaseImpl::PushCaptureData(int voe_channel, const void* audio_data,
                                   int bits_per_sample, int sample_rate,
                                   size_t number_of_channels,
                                   size_t number_of_frames) {
   voe::ChannelOwner ch = shared_->channel_manager().GetChannel(voe_channel);
-  voe::Channel* channel_ptr = ch.channel();
-  if (!channel_ptr) return;
-
-  if (channel_ptr->Sending()) {
-    channel_ptr->Demultiplex(static_cast<const int16_t*>(audio_data),
-                             sample_rate, number_of_frames, number_of_channels);
-    channel_ptr->PrepareEncodeAndSend(sample_rate);
-    channel_ptr->EncodeAndSend();
+  voe::Channel* channel = ch.channel();
+  if (!channel)
+    return;
+  if (channel->Sending()) {
+    // Send the audio to each channel directly without using the APM in the
+    // transmit mixer.
+    channel->ProcessAndEncodeAudio(static_cast<const int16_t*>(audio_data),
+                                   sample_rate, number_of_frames,
+                                   number_of_channels);
   }
 }
 
 void VoEBaseImpl::PullRenderData(int bits_per_sample,
                                  int sample_rate,
                                  size_t number_of_channels,
                                  size_t number_of_frames,
                                  void* audio_data, int64_t* elapsed_time_ms,
                                  int64_t* ntp_time_ms) {
   assert(bits_per_sample == 16);
@@ skipping 237 matching lines @@
   config_copy.acm_config.decoder_factory = decoder_factory_;
   voe::ChannelOwner channel_owner =
       shared_->channel_manager().CreateChannel(config_copy);
   return InitializeChannel(&channel_owner);
 }
 
 int VoEBaseImpl::InitializeChannel(voe::ChannelOwner* channel_owner) {
   if (channel_owner->channel()->SetEngineInformation(
           shared_->statistics(), *shared_->output_mixer(),
           *shared_->process_thread(), *shared_->audio_device(),
-          voiceEngineObserverPtr_, &callbackCritSect_) != 0) {
+          voiceEngineObserverPtr_, &callbackCritSect_,
+          shared_->encoder_queue()) != 0) {
     shared_->SetLastError(
         VE_CHANNEL_NOT_CREATED, kTraceError,
         "CreateChannel() failed to associate engine and channel."
         " Destroying channel.");
     shared_->channel_manager().DestroyChannel(
         channel_owner->channel()->ChannelId());
     return -1;
   } else if (channel_owner->channel()->Init() != 0) {
     shared_->SetLastError(
         VE_CHANNEL_NOT_CREATED, kTraceError,
@@ skipping 123 matching lines @@
     shared_->SetLastError(VE_NOT_INITED, kTraceError);
     return -1;
   }
   voe::ChannelOwner ch = shared_->channel_manager().GetChannel(channel);
   voe::Channel* channelPtr = ch.channel();
   if (channelPtr == nullptr) {
     shared_->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
                           "StopSend() failed to locate channel");
     return -1;
   }
-  if (channelPtr->StopSend() != 0) {
-    LOG_F(LS_WARNING) << "StopSend() failed to stop sending for channel "
-                      << channel;
-  }
+  channelPtr->StopSend();
   return StopSend();
 }
 
 int VoEBaseImpl::GetVersion(char version[1024]) {
   if (version == nullptr) {
     shared_->SetLastError(VE_INVALID_ARGUMENT, kTraceError);
     return -1;
   }
 
   std::string versionString = VoiceEngine::GetVersionString();
@@ skipping 103 matching lines @@
     shared_->set_audio_device(nullptr);
   }
 
   if (shared_->audio_processing()) {
     shared_->set_audio_processing(nullptr);
   }
 
   return shared_->statistics().SetUnInitialized();
 }
 
-int VoEBaseImpl::ProcessRecordedDataWithAPM(
-    const int voe_channels[], size_t number_of_voe_channels,
-    const void* audio_data, uint32_t sample_rate, size_t number_of_channels,
-    size_t number_of_frames, uint32_t audio_delay_milliseconds,
-    int32_t clock_drift, uint32_t volume, bool key_pressed) {
-  assert(shared_->transmit_mixer() != nullptr);
-  assert(shared_->audio_device() != nullptr);
-
-  uint32_t max_volume = 0;
-  uint16_t voe_mic_level = 0;
-  // Check for zero to skip this calculation; the consumer may use this to
-  // indicate no volume is available.
-  if (volume != 0) {
-    // Scale from ADM to VoE level range
-    if (shared_->audio_device()->MaxMicrophoneVolume(&max_volume) == 0) {
-      if (max_volume) {
-        voe_mic_level = static_cast<uint16_t>(
-            (volume * kMaxVolumeLevel + static_cast<int>(max_volume / 2)) /
-            max_volume);
-      }
-    }
-    // We learned that on certain systems (e.g Linux) the voe_mic_level
-    // can be greater than the maxVolumeLevel therefore
-    // we are going to cap the voe_mic_level to the maxVolumeLevel
-    // and change the maxVolume to volume if it turns out that
-    // the voe_mic_level is indeed greater than the maxVolumeLevel.
-    if (voe_mic_level > kMaxVolumeLevel) {
-      voe_mic_level = kMaxVolumeLevel;
-      max_volume = volume;
-    }
-  }
-
-  // Perform channel-independent operations
-  // (APM, mix with file, record to file, mute, etc.)
-  shared_->transmit_mixer()->PrepareDemux(
-      audio_data, number_of_frames, number_of_channels, sample_rate,
-      static_cast<uint16_t>(audio_delay_milliseconds), clock_drift,
-      voe_mic_level, key_pressed);
-
-  // Copy the audio frame to each sending channel and perform
-  // channel-dependent operations (file mixing, mute, etc.), encode and
-  // packetize+transmit the RTP packet. When |number_of_voe_channels| == 0,
-  // do the operations on all the existing VoE channels; otherwise the
-  // operations will be done on specific channels.
-  if (number_of_voe_channels == 0) {
-    shared_->transmit_mixer()->DemuxAndMix();
-    shared_->transmit_mixer()->EncodeAndSend();
-  } else {
-    shared_->transmit_mixer()->DemuxAndMix(voe_channels,
-                                           number_of_voe_channels);
-    shared_->transmit_mixer()->EncodeAndSend(voe_channels,
-                                             number_of_voe_channels);
-  }
-
-  // Scale from VoE to ADM level range.
-  uint32_t new_voe_mic_level = shared_->transmit_mixer()->CaptureLevel();
-  if (new_voe_mic_level != voe_mic_level) {
-    // Return the new volume if AGC has changed the volume.
-    return static_cast<int>((new_voe_mic_level * max_volume +
-                             static_cast<int>(kMaxVolumeLevel / 2)) /
-                            kMaxVolumeLevel);
-  }
-
-  // Return 0 to indicate no change on the volume.
-  return 0;
-}
-
 void VoEBaseImpl::GetPlayoutData(int sample_rate, size_t number_of_channels,
                                  size_t number_of_frames, bool feed_data_to_apm,
                                  void* audio_data, int64_t* elapsed_time_ms,
                                  int64_t* ntp_time_ms) {
   assert(shared_->output_mixer() != nullptr);
 
   // TODO(andrew): if the device is running in mono, we should tell the mixer
   // here so that it will only request mono from AudioCodingModule.
   // Perform mixing of all active participants (channel-based mixing)
   shared_->output_mixer()->MixActiveChannels();
@@ skipping 39 matching lines @@
     shared_->SetLastError(VE_CHANNEL_NOT_VALID, kTraceError,
         "AssociateSendChannel() failed to locate accociate_send_channel");
     return -1;
   }
 
   channel_ptr->set_associate_send_channel(ch);
   return 0;
 }
 
 }  // namespace webrtc