上一节《7-21 StartRecording处理逻辑》
本节源码分析录制麦克风流程，最终是调用StartRecording开始录制，该函数里面创建并启动了一个采集线程，线程函数是AudioDeviceWindowsCore::DoCaptureThreadPollDMO，注意默认是在打开了aec回声消除功能。

WebRtcVoiceMediaChannel::SetSend

  1. void WebRtcVoiceMediaChannel::SetSend(bool send) {
  2.  ***
  4.   // Change the settings on each send channel.
  5.   for (auto& kv : send_streams_) {
  6.     kv.second->SetSend(send);
  7.   }
  9.   send_ = send;
  10. }

-》

SetSend

  1. void SetSend(bool send) {
  2.     RTC_DCHECK_RUN_ON(&worker_thread_checker_);
  3.     send_ = send;
  4.     UpdateSendState();
  5.   }

-》

UpdateSendState

  1.  void UpdateSendState() {
  2.     RTC_DCHECK_RUN_ON(&worker_thread_checker_);
  3.     RTC_DCHECK(stream_);
  4.     RTC_DCHECK_EQ(1UL, rtp_parameters_.encodings.size());
  5.     if (send_ && source_ != nullptr && rtp_parameters_.encodings[0].active) {
  6.       stream_->Start();
  7.     } else {  // !send || source_ = nullptr
  8.       stream_->Stop();
  9.     }
  10.   }

-》

AudioSendStream::Start

  1. void AudioSendStream::Start() {
  2.   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
  3.   if (sending_) {
  4.     return;
  5.   }
  6.   if (!config_.has_dscp && config_.min_bitrate_bps != -1 &&
  7.       config_.max_bitrate_bps != -1 &&
  8.       (allocate_audio_without_feedback_ || TransportSeqNumId(config_) != 0)) {
  9.     rtp_transport_->AccountForAudioPacketsInPacedSender(true);
  10.     if (send_side_bwe_with_overhead_)
  11.       rtp_transport_->IncludeOverheadInPacedSender();
  12.     rtp_rtcp_module_->SetAsPartOfAllocation(true);
  13.     ConfigureBitrateObserver();
  14.   } else {
  15.     rtp_rtcp_module_->SetAsPartOfAllocation(false);
  16.   }
  17.   channel_send_->StartSend();
  18.   sending_ = true;
  19.   audio_state()->AddSendingStream(this, encoder_sample_rate_hz_,
  20.                                   encoder_num_channels_);
  21. }

—》

AudioState::AddSendingStream

  1. void (webrtc::AudioSendStream* stream,
  2.                                   int sample_rate_hz,
  3.                                   size_t num_channels) {
  4.   RTC_DCHECK(thread_checker_.IsCurrent());
  5.   auto& properties = sending_streams_[stream];
  6.   properties.sample_rate_hz = sample_rate_hz;
  7.   properties.num_channels = num_channels;
  8.   UpdateAudioTransportWithSendingStreams();
  10.   // Make sure recording is initialized; start recording if enabled.
  11.   auto* adm = config_.audio_device_module.get();
  12.   if (!adm->Recording()) {
  13.     if (adm->InitRecording() == 0) {
  14.       if (recording_enabled_) {
  15.         adm->StartRecording();
  16.       }
  17.     } else {
  18.       RTC_DLOG_F(LS_ERROR) << "Failed to initialize recording.";
  19.     }
  20.   }
  21. }

—》

AudioDeviceModuleImpl::StartRecording

  1. int32_t AudioDeviceModuleImpl::StartRecording() {
  2.   RTC_LOG(INFO) << __FUNCTION__;
  3.   CHECKinitialized_();
  4.   if (Recording()) {
  5.     return 0;
  6.   }
  7.   audio_device_buffer_.StartRecording();
  8.   int32_t result = audio_device_->StartRecording();
  9.   RTC_LOG(INFO) << "output: " << result;
  10.   RTC_HISTOGRAM_BOOLEAN("WebRTC.Audio.StartRecordingSuccess",
  11.                         static_cast<int>(result == 0));
  12.   return result;
  13. }

—》

AudioDeviceWindowsCore::StartRecording

  1. int32_t AudioDeviceWindowsCore::StartRecording() {
  2.   if (!_recIsInitialized) {
  3.     return -1;
  4.   }
  6.   if (_hRecThread != NULL) {
  7.     return 0;
  8.   }
  10.   if (_recording) {
  11.     return 0;
  12.   }
  14.   {
  15.     MutexLock lockScoped(&mutex_);
  17.     // Create thread which will drive the capturing
  18.     LPTHREAD_START_ROUTINE lpStartAddress = WSAPICaptureThread;
  19.     if (_builtInAecEnabled) { // 如果使用AEC，则重定向使用DMO采集音频
  20.       // Redirect to the DMO polling method.
  21.       lpStartAddress = WSAPICaptureThreadPollDMO;
  23.       if (!_playing) {
  24.         // The DMO won't provide us captured output data unless we
  25.         // give it render data to process.
  26.         RTC_LOG(LS_ERROR)
  27.             << "Playout must be started before recording when using"
  28.                " the built-in AEC";
  29.         return -1;
  30.       }
  31.     }
  33.       // 前面的，如果使用了_builtInAecEnabled，则真正执行的是WSAPICaptureThreadPollDMO
  34.     assert(_hRecThread == NULL);
  35.     _hRecThread = CreateThread(NULL, 0, lpStartAddress, this, 0, NULL);
  36.     if (_hRecThread == NULL) {
  37.       RTC_LOG(LS_ERROR) << "failed to create the recording thread";
  38.       return -1;
  39.     }
  41.     // Set thread priority to highest possible
  42.       // 设置线程优先级别
  43.     SetThreadPriority(_hRecThread, THREAD_PRIORITY_TIME_CRITICAL);
  44.   }  // critScoped
  46.     // 当前线程挂起
  47.   DWORD ret = WaitForSingleObject(_hCaptureStartedEvent, 1000);
  48.   if (ret != WAIT_OBJECT_0) {
  49.     RTC_LOG(LS_VERBOSE) << "capturing did not start up properly";
  50.     return -1;
  51.   }
  52.   RTC_LOG(LS_VERBOSE) << "capture audio stream has now started...";
  54.   _recording = true;
  56.   return 0;
  57. }

WSAPICaptureThreadPollDMO
DWORD WINAPI AudioDeviceWindowsCore::WSAPICaptureThreadPollDMO(LPVOID context) {
return reinterpret_cast(context) ->DoCaptureThreadPollDMO();
}

采集音频线程

AudioDeviceWindowsCore::DoCaptureThreadPollDMO

  1. DWORD AudioDeviceWindowsCore::DoCaptureThreadPollDMO() {
  2.   assert(_mediaBuffer != NULL);
  3.   bool keepRecording = true;
  5.   // Initialize COM as MTA in this thread.
  6.   ScopedCOMInitializer comInit(ScopedCOMInitializer::kMTA);
  7.   if (!comInit.Succeeded()) {
  8.     RTC_LOG(LS_ERROR) << "failed to initialize COM in polling DMO thread";
  9.     return 1;
  10.   }
  12.   HRESULT hr = InitCaptureThreadPriority();
  13.   if (FAILED(hr)) {
  14.     return hr;
  15.   }
  17.   // Set event which will ensure that the calling thread modifies the
  18.   // recording state to true.
  19.   SetEvent(_hCaptureStartedEvent);
  21.   // >> ---------------------------- THREAD LOOP ----------------------------
  22.   while (keepRecording) {
  23.     // Poll the DMO every 5 ms.
  24.     // (The same interval used in the Wave implementation.)
  25.     DWORD waitResult = WaitForSingleObject(_hShutdownCaptureEvent, 5);
  26.     switch (waitResult) {
  27.       case WAIT_OBJECT_0:  // _hShutdownCaptureEvent
  28.         keepRecording = false;
  29.         break;
  30.       case WAIT_TIMEOUT:  // timeout notification
  31.         break;
  32.       default:  // unexpected error
  33.         RTC_LOG(LS_WARNING) << "Unknown wait termination on capture side";
  34.         hr = -1;  // To signal an error callback.
  35.         keepRecording = false;
  36.         break;
  37.     }
  39.       // 真正采集的核心逻辑
  40.     while (keepRecording) {
  41.       MutexLock lockScoped(&mutex_);
  43.       DWORD dwStatus = 0;
  44.       {
  45.         DMO_OUTPUT_DATA_BUFFER dmoBuffer = {0};
  46.         dmoBuffer.pBuffer = _mediaBuffer;//必须是继承IMediaBuffer的
  47.         dmoBuffer.pBuffer->AddRef();
  49.         // Poll the DMO for AEC processed capture data. The DMO will
  50.         // copy available data to |dmoBuffer|, and should only return
  51.         // 10 ms frames. The value of |dwStatus| should be ignored.
  52.         hr = _dmo->ProcessOutput(0, 1, &dmoBuffer, &dwStatus);
  53.         SAFE_RELEASE(dmoBuffer.pBuffer);
  54.         dwStatus = dmoBuffer.dwStatus;
  55.       }
  56.       if (FAILED(hr)) {
  57.         _TraceCOMError(hr);
  58.         keepRecording = false;
  59.         assert(false);
  60.         break;
  61.       }
  63.       ULONG bytesProduced = 0;
  64.       BYTE* data;
  65.       // Get a pointer to the data buffer. This should be valid until
  66.       // the next call to ProcessOutput.
  67.         // 获取buffer数据和数据大小
  68.         // bytesProduced=320，输出采样率16000，每个采样2个字节，每次采集10ms数据
  69.       hr = _mediaBuffer->GetBufferAndLength(&data, &bytesProduced);
  70.       if (FAILED(hr)) {
  71.         _TraceCOMError(hr);
  72.         keepRecording = false;
  73.         assert(false);
  74.         break;
  75.       }
  77.       if (bytesProduced > 0) {
  78.           //断点值 160 = 320/2
  79.         const int kSamplesProduced = bytesProduced / _recAudioFrameSize;
  80.         // TODO(andrew): verify that this is always satisfied. It might
  81.         // be that ProcessOutput will try to return more than 10 ms if
  82.         // we fail to call it frequently enough.
  83.         assert(kSamplesProduced == static_cast<int>(_recBlockSize));
  84.         assert(sizeof(BYTE) == sizeof(int8_t));
  86.         _ptrAudioBuffer->SetRecordedBuffer(reinterpret_cast<int8_t*>(data),
  87.                                            kSamplesProduced);
  88.         _ptrAudioBuffer->SetVQEData(0, 0);
  90.         _UnLock();  // Release lock while making the callback.
  91.           // 将数据输送到上层逻辑去处理
  92.         _ptrAudioBuffer->DeliverRecordedData();
  93.         _Lock();
  94.       }
  96.       // Reset length to indicate buffer availability.
  97.       hr = _mediaBuffer->SetLength(0);
  98.       if (FAILED(hr)) {
  99.         _TraceCOMError(hr);
  100.         keepRecording = false;
  101.         assert(false);
  102.         break;
  103.       }
  105.       if (!(dwStatus & DMO_OUTPUT_DATA_BUFFERF_INCOMPLETE)) {
  106.         // The DMO cannot currently produce more data. This is the
  107.         // normal case; otherwise it means the DMO had more than 10 ms
  108.         // of data available and ProcessOutput should be called again.
  109.         break;
  110.       }
  111.     }
  112.   }
  113.   // ---------------------------- THREAD LOOP ---------------------------- <<
  115.   RevertCaptureThreadPriority();
  117.   if (FAILED(hr)) {
  118.     RTC_LOG(LS_ERROR)
  119.         << "Recording error: capturing thread has ended prematurely";
  120.   } else {
  121.     RTC_LOG(LS_VERBOSE) << "Capturing thread is now terminated properly";
  122.   }
  124.   return hr;
  125. }

将数据输送到上层逻辑去处理

_ptrAudioBuffer->DeliverRecordedData();

  1. AudioDeviceBuffer::DeliverRecordedData
  2. -》
  3. audio_transport_cb_->RecordedDataIsAvailable(
  4.       rec_buffer_.data(), frames, bytes_per_frame, rec_channels_,
  5.       rec_sample_rate_, total_delay_ms, 0, 0, typing_status_,
  6.       new_mic_level_dummy);

H:\webrtc-20210315\webrtc-20210315\webrtc\webrtc-checkout\src\modules\audio_device\audio_device_data_observer.cc

  1. // AudioTransport methods overrides.
  2.   int32_t RecordedDataIsAvailable(const void* audioSamples,
  3.                                   const size_t nSamples,
  4.                                   const size_t nBytesPerSample,
  5.                                   const size_t nChannels,
  6.                                   const uint32_t samples_per_sec,
  7.                                   const uint32_t total_delay_ms,
  8.                                   const int32_t clockDrift,
  9.                                   const uint32_t currentMicLevel,
  10.                                   const bool keyPressed,
  11.                                   uint32_t& newMicLevel) override {
  12.     int32_t res = 0;
  13.     // Capture PCM data of locally captured audio.
  14.     //   std::unique_ptr<AudioDeviceDataObserver> observer_;
  15.     if (observer_) {
  16.       observer_->OnCaptureData(audioSamples, nSamples, nBytesPerSample,
  17.                                nChannels, samples_per_sec);
  18.     }
  20.     // Send to the actual audio transport.
  21.     if (audio_transport_) {
  22.       res = audio_transport_->RecordedDataIsAvailable(
  23.           audioSamples, nSamples, nBytesPerSample, nChannels, samples_per_sec,
  24.           total_delay_ms, clockDrift, currentMicLevel, keyPressed, newMicLevel);
  25.     }
  27.     return res;
  28.   }

1 外面应用层调用

observer的值来自
ADMWrapper(rtc::scoped_refptr impl,
AudioDeviceDataObserver* legacy_observer,
std::unique_ptr observer)
: impl(impl),
legacyobserver(legacyobserver),
observer(std::move(observer))
-》
rtc::scoped_refptr CreateAudioDeviceWithDataObserver(
AudioDeviceModule::AudioLayer audio_layer,
TaskQueueFactory task_queue_factory,
AudioDeviceDataObserver legacy_observer) {
rtc::scoped_refptr audio_device(
new rtc::RefCountedObject(audio_layer, task_queue_factory,
legacy_observer, nullptr));
*

2 拷贝到每个发送流进行传输

if (audiotransport) {
res = audiotransport->RecordedDataIsAvailable(
audioSamples, nSamples, nBytesPerSample, nChannels, samples_per_sec,
total_delay_ms, clockDrift, currentMicLevel, keyPressed, newMicLevel);
}

audiotransport的值为RegisterAudioCallback传参值。
// Override AudioDeviceModule’s RegisterAudioCallback method to remember the
// actual audio transport (e.g.: voice engine).
int32t RegisterAudioCallback(AudioTransport* audio_callback) override {
// Remember the audio callback to forward PCM data
audio_transport = audio_callback;
return 0;
}

学习资料

https://blog.csdn.net/linalg/article/details/123376296