上一节《7-17 播放声音的具体流程》

AudioState::AddReceivingStream

H:\webrtc-20210315\webrtc-20210315\webrtc\webrtc-checkout\src\audio\audio_state.cc

  1. void AudioState::AddReceivingStream(webrtc::AudioReceiveStream* stream) {
  2. ***
  3.   auto* adm = config_.audio_device_module.get();
  4.   if (!adm->Playing()) {
  5.     if (adm->InitPlayout() == 0) {
  6.       if (playout_enabled_) {
  7.         adm->StartPlayout();
  8. ***
  9.    }

AudioDeviceModuleImpl::StartPlayout

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

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

AudioDeviceWindowsCore::StartPlayout

H:\webrtc-20210315\webrtc-20210315\webrtc\webrtc-checkout\src\modules\audio_device\win\audio_device_core_win.cc
播放声音的主要逻辑都是在这里完成。

  1. int32_t AudioDeviceWindowsCore::StartPlayout() {
  2.   if (!_playIsInitialized) {
  3.     return -1;
  4.   }
  6.   if (_hPlayThread != NULL) {
  7.     return 0;
  8.   }
  10.   if (_playing) {
  11.     return 0;
  12.   }
  14.   {
  15.     MutexLock lockScoped(&mutex_);
  17.     // Create thread which will drive the rendering.
  18.     assert(_hPlayThread == NULL);
  19.     _hPlayThread = CreateThread(NULL, 0, WSAPIRenderThread, this, 0, NULL);
  20.     if (_hPlayThread == NULL) {
  21.       RTC_LOG(LS_ERROR) << "failed to create the playout thread";
  22.       return -1;
  23.     }
  25.     // Set thread priority to highest possible.
  26.     SetThreadPriority(_hPlayThread, THREAD_PRIORITY_TIME_CRITICAL);
  27.   }  // critScoped
  29.   DWORD ret = WaitForSingleObject(_hRenderStartedEvent, 1000);
  30.   if (ret != WAIT_OBJECT_0) {
  31.     RTC_LOG(LS_VERBOSE) << "rendering did not start up properly";
  32.     return -1;
  33.   }
  35.   _playing = true;
  36.   RTC_LOG(LS_VERBOSE) << "rendering audio stream has now started...";
  38.   return 0;
  39. }
  42. DWORD WINAPI AudioDeviceWindowsCore::WSAPIRenderThread(LPVOID context) {
  43.   return reinterpret_cast<AudioDeviceWindowsCore*>(context)->DoRenderThread();
  44. }

image.png

WSAPIRenderThread线程函数

  1. DWORD WINAPI AudioDeviceWindowsCore::WSAPIRenderThread(LPVOID context) {
  2.   return reinterpret_cast<AudioDeviceWindowsCore*>(context)->DoRenderThread();
  3. }

AudioDeviceWindowsCore::DoRenderThread

  1. DWORD AudioDeviceWindowsCore::DoRenderThread() {
  2. ***
  3.   // Initialize COM as MTA in this thread.
  4.   ScopedCOMInitializer comInit(ScopedCOMInitializer::kMTA);
  5.   if (!comInit.Succeeded()) {
  6.     RTC_LOG(LS_ERROR) << "failed to initialize COM in render thread";
  7.     return 1;
  8.   }
  10.   rtc::SetCurrentThreadName("webrtc_core_audio_render_thread");
  12.   // Use Multimedia Class Scheduler Service (MMCSS) to boost the thread
  13.   // priority.
  14.   // 是否支持avrt
  15.   if (_winSupportAvrt) {
  16.     DWORD taskIndex(0);
  17.     hMmTask = _PAvSetMmThreadCharacteristicsA("Pro Audio", &taskIndex);
  18.     if (hMmTask) {
  19.       if (FALSE == _PAvSetMmThreadPriority(hMmTask, AVRT_PRIORITY_CRITICAL)) {
  20.     ****
  21.   }
  23.   _Lock();
  25.   IAudioClock* clock = NULL;
  27.   // Get size of rendering buffer (length is expressed as the number of audio
  28.   // frames the buffer can hold). This value is fixed during the rendering
  29.   // session.
  30.   // 获取扬声器的buffer大小，断点值为1056
  31.   UINT32 bufferLength = 0;
  32.   hr = _ptrClientOut->GetBufferSize(&bufferLength);
  33.   EXIT_ON_ERROR(hr);
  34.   RTC_LOG(LS_VERBOSE) << "[REND] size of buffer       : " << bufferLength;
  36.   // Get maximum latency for the current stream (will not change for the
  37.   // lifetime  of the IAudioClient object).
  38.   //
  39.   REFERENCE_TIME latency;
  40.   _ptrClientOut->GetStreamLatency(&latency); //打断点值为0，没有延迟
  41.   RTC_LOG(LS_VERBOSE) << "[REND] max stream latency   : " << (DWORD)latency
  42.                       << " (" << (double)(latency / 10000.0) << " ms)";
  44.   // Get the length of the periodic interval separating successive processing
  45.   // passes by the audio engine on the data in the endpoint buffer.
  46.   //
  47.   // The period between processing passes by the audio engine is fixed for a
  48.   // particular audio endpoint device and represents the smallest processing
  49.   // quantum for the audio engine. This period plus the stream latency between
  50.   // the buffer and endpoint device represents the minimum possible latency that
  51.   // an audio application can achieve. Typical value: 100000 <=> 0.01 sec =
  52.   // 10ms.
  53.   // 播放周期
  54.   REFERENCE_TIME devPeriod = 0;
  55.   REFERENCE_TIME devPeriodMin = 0; 
  56.   _ptrClientOut->GetDevicePeriod(&devPeriod, &devPeriodMin);//断点值， 10万，3万
  57.   RTC_LOG(LS_VERBOSE) << "[REND] device period        : " << (DWORD)devPeriod
  58.                       << " (" << (double)(devPeriod / 10000.0) << " ms)";
  60.   // Derive initial rendering delay.
  61.   // Example: 10*(960/480) + 15 = 20 + 15 = 35ms
  62.   // 这里的10是10毫秒，播放缓冲区大小，当前断点值 10* (1056/480) + (0+ 10万)/1万 = 30
  63.   int playout_delay = 10 * (bufferLength / _playBlockSize) +
  64.                       (int)((latency + devPeriod) / 10000);
  65.   _sndCardPlayDelay = playout_delay;
  66.   _writtenSamples = 0;
  67.   RTC_LOG(LS_VERBOSE) << "[REND] initial delay        : " << playout_delay;
  69.         // 缓存区可以播放的时间
  70.   double endpointBufferSizeMS =
  71.       10.0 * ((double)bufferLength / (double)_devicePlayBlockSize);
  72.   RTC_LOG(LS_VERBOSE) << "[REND] endpointBufferSizeMS : "
  73.                       << endpointBufferSizeMS;
  75.   // Before starting the stream, fill the rendering buffer with silence.
  76.   //获取缓存区的地址，后面将数据写到这里
  77.   BYTE* pData = NULL;
  78.   hr = _ptrRenderClient->GetBuffer(bufferLength, &pData);
  79.   EXIT_ON_ERROR(hr);
  81.         // 释放缓存区，同时默认写入静默音
  82.   hr =
  83.       _ptrRenderClient->ReleaseBuffer(bufferLength, AUDCLNT_BUFFERFLAGS_SILENT);
  84.   EXIT_ON_ERROR(hr);
  86.   _writtenSamples += bufferLength;
  88.   // 获取IAudioClock服务
  89.   hr = _ptrClientOut->GetService(__uuidof(IAudioClock), (void**)&clock);
  90.   if (FAILED(hr)) {
  91.     RTC_LOG(LS_WARNING)
  92.         << "failed to get IAudioClock interface from the IAudioClient";
  93.   }
  95.         // 启动音频流
  96.   // Start up the rendering audio stream.
  97.   hr = _ptrClientOut->Start();
  98.   EXIT_ON_ERROR(hr);
  100.   _UnLock();
  102.   // Set event which will ensure that the calling thread modifies the playing
  103.   // state to true.
  104.   // 发送一个开始播放的通知
  105.   SetEvent(_hRenderStartedEvent);
  107.   // >> ------------------ THREAD LOOP ------------------
  109.   while (keepPlaying) {
  110.     // Wait for a render notification event or a shutdown event 
  111.      // 等待信号和解析
  112.     DWORD waitResult = WaitForMultipleObjects(2, waitArray, FALSE, 500);
  113.     switch (waitResult) {
  114.       case WAIT_OBJECT_0 + 0:  // _hShutdownRenderEvent
  115.         keepPlaying = false;
  116.         break;
  117.       case WAIT_OBJECT_0 + 1:  // _hRenderSamplesReadyEvent
  118.         break;
  119.       case WAIT_TIMEOUT:  // timeout notification
  120.         RTC_LOG(LS_WARNING) << "render event timed out after 0.5 seconds";
  121.         goto Exit;
  122.       default:  // unexpected error
  123.         RTC_LOG(LS_WARNING) << "unknown wait termination on render side";
  124.         goto Exit;
  125.     }
  127.     while (keepPlaying) {
  128.       _Lock();
  130.       // Sanity check to ensure that essential states are not modified
  131.       // during the unlocked period.
  132.       if (_ptrRenderClient == NULL || _ptrClientOut == NULL) {
  133.         _UnLock();
  134.         RTC_LOG(LS_ERROR)
  135.             << "output state has been modified during unlocked period";
  136.         goto Exit;
  137.       }
  139.       // Get the number of frames of padding (queued up to play) in the endpoint
  140.       // buffer. 获取要填充的大小
  141.       UINT32 padding = 0;
  142.       hr = _ptrClientOut->GetCurrentPadding(&padding);
  143.       EXIT_ON_ERROR(hr);
  145.       // Derive the amount of available space in the output buffer
  146.       uint32_t framesAvailable = bufferLength - padding;
  148.       // Do we have 10 ms available in the render buffer?
  149.       if (framesAvailable < _playBlockSize) { // 没有空间填写
  150.         // Not enough space in render buffer to store next render packet.
  151.         _UnLock();
  152.         break;
  153.       }
  155.       // Write n*10ms buffers to the render buffer
  156.       const uint32_t n10msBuffers = (framesAvailable / _playBlockSize);
  157.       for (uint32_t n = 0; n < n10msBuffers; n++) {
  158.         // Get pointer (i.e., grab the buffer) to next space in the shared
  159.         // render buffer. 
  160.         hr = _ptrRenderClient->GetBuffer(_playBlockSize, &pData);
  161.         EXIT_ON_ERROR(hr);
  163.         if (_ptrAudioBuffer) { 
  164.           // Request data to be played out (#bytes =
  165.           // _playBlockSize*_audioFrameSize)
  166.           _UnLock();
  167.           int32_t nSamples =
  168.               _ptrAudioBuffer->RequestPlayoutData(_playBlockSize); // 获取播放数据大小
  169.           _Lock();
  171.           if (nSamples == -1) {
  172.             _UnLock();
  173.             RTC_LOG(LS_ERROR) << "failed to read data from render client";
  174.             goto Exit;
  175.           }
  177.           // Sanity check to ensure that essential states are not modified
  178.           // during the unlocked period
  179.           if (_ptrRenderClient == NULL || _ptrClientOut == NULL) {
  180.             _UnLock();
  181.             RTC_LOG(LS_ERROR)
  182.                 << "output state has been modified during unlocked"
  183.                    " period";
  184.             goto Exit;
  185.           }
  186.           if (nSamples != static_cast<int32_t>(_playBlockSize)) {
  187.             RTC_LOG(LS_WARNING)
  188.                 << "nSamples(" << nSamples << ") != _playBlockSize"
  189.                 << _playBlockSize << ")";
  190.           }
  192.           // Get the actual (stored) data
  193.             // 将_ptrAudioBuffer的数据读取放到扬声器的bufer中，扬声器会不停的去读来播放
  194.           nSamples = _ptrAudioBuffer->GetPlayoutData((int8_t*)pData);
  195.         }
  197.         DWORD dwFlags(0);
  198.         hr = _ptrRenderClient->ReleaseBuffer(_playBlockSize, dwFlags);
  199.         // See http://msdn.microsoft.com/en-us/library/dd316605(VS.85).aspx
  200.         // for more details regarding AUDCLNT_E_DEVICE_INVALIDATED.
  201.         EXIT_ON_ERROR(hr);
  203.           // 写入的大小要递增
  204.         _writtenSamples += _playBlockSize;
  205.       }
  207.       // Check the current delay on the playout side.
  208.       if (clock) {
  209.         UINT64 pos = 0;
  210.         UINT64 freq = 1;
  211.         clock->GetPosition(&pos, NULL);
  212.         clock->GetFrequency(&freq);
  213.         playout_delay = ROUND((double(_writtenSamples) / _devicePlaySampleRate -
  214.                                double(pos) / freq) *
  215.                               1000.0);
  216.           // 每次播放完都要更新该值，时刻获取播放延迟时间
  217.         _sndCardPlayDelay = playout_delay;
  218.       }
  220.       _UnLock();
  221.     }
  222.   }
  224.   // ------------------ THREAD LOOP ------------------ <<
  226.   SleepMs(static_cast<DWORD>(endpointBufferSizeMS + 0.5));
  227.   hr = _ptrClientOut->Stop();
  229. ****
  230. }