前言

image.png

代码分析

H:\webrtc-20210315\webrtc-20210315\webrtc\webrtc-checkout\src\modules\video_capture\windows\sink_filter_ds.cc

CaptureInputPin::Receive

采集的数据首先经过这里。

  1. STDMETHODIMP CaptureInputPin::Receive(IMediaSample* media_sample) {
  2.   //RTC_DCHECK_RUN_ON(&capture_checker_);
  4.   CaptureSinkFilter* const filter = static_cast<CaptureSinkFilter*>(Filter());
  6.   if (flushing_.load(std::memory_order_relaxed))
  7.     return S_FALSE;
  9.   if (runtime_error_.load(std::memory_order_relaxed))
  10.     return VFW_E_RUNTIME_ERROR;
  12.   if (!capture_thread_id_) {
  13.     // Make sure we set the thread name only once.
  14.     capture_thread_id_ = GetCurrentThreadId();
  15.     rtc::SetCurrentThreadName("webrtc_video_capture");
  16.   }
  18.   AM_SAMPLE2_PROPERTIES sample_props = {};
  19.   GetSampleProperties(media_sample, &sample_props);
  20.   // Has the format changed in this sample?
  21.   if (sample_props.dwSampleFlags & AM_SAMPLE_TYPECHANGED) {
  22.     // Check the derived class accepts the new format.
  23.     // This shouldn't fail as the source must call QueryAccept first.
  25.     // Note: This will modify resulting_capability_.
  26.     // That should be OK as long as resulting_capability_ is only modified
  27.     // on this thread while it is running (filter is not stopped), and only
  28.     // modified on the main thread when the filter is stopped (i.e. this thread
  29.     // is not running).
  30.     if (!TranslateMediaTypeToVideoCaptureCapability(sample_props.pMediaType,
  31.                                                     &resulting_capability_)) {
  32.       // Raise a runtime error if we fail the media type
  33.       runtime_error_ = true;
  34.       EndOfStream();
  35.       Filter()->NotifyEvent(EC_ERRORABORT, VFW_E_TYPE_NOT_ACCEPTED, 0);
  36.       return VFW_E_INVALIDMEDIATYPE;
  37.     }
  38.   }
  40.   filter->ProcessCapturedFrame(sample_props.pbBuffer, sample_props.lActual,
  41.                                resulting_capability_);
  43.   return S_OK;
  44. }

—》 filter->ProcessCapturedFrame(sampleprops.pbBuffer, sample_props.lActual,
resulting_capability);

CaptureSinkFilter::ProcessCapturedFrame

  1. void CaptureSinkFilter::ProcessCapturedFrame(
  2.     unsigned char* buffer,
  3.     size_t length,
  4.     const VideoCaptureCapability& frame_info) {
  5.   // Called on the capture thread.
  6.   capture_observer_->IncomingFrame(buffer, length, frame_info);
  7. }

—》

  1. int32_t VideoCaptureImpl::IncomingFrame(uint8_t* videoFrame,
  2.                                         size_t videoFrameLength,
  3.                                         const VideoCaptureCapability& frameInfo,
  4.                                         int64_t captureTime /*=0*/) {
  5.   MutexLock lock(&api_lock_);
  7.   const int32_t width = frameInfo.width;
  8.   const int32_t height = frameInfo.height;
  10.   TRACE_EVENT1("webrtc", "VC::IncomingFrame", "capture_time", captureTime);
  12.   // Not encoded, convert to I420.
  13.   if (frameInfo.videoType != VideoType::kMJPEG &&
  14.       CalcBufferSize(frameInfo.videoType, width, abs(height)) !=
  15.           videoFrameLength) {
  16.     RTC_LOG(LS_ERROR) << "Wrong incoming frame length.";
  17.     return -1;
  18.   }
  20.   int stride_y = width;
  21.   int stride_uv = (width + 1) / 2;
  22.   int target_width = width;
  23.   int target_height = abs(height);
  25.   // SetApplyRotation doesn't take any lock. Make a local copy here.
  26.   bool apply_rotation = apply_rotation_;
  28.   if (apply_rotation) {
  29.     // Rotating resolution when for 90/270 degree rotations.
  30.     if (_rotateFrame == kVideoRotation_90 ||
  31.         _rotateFrame == kVideoRotation_270) {
  32.       target_width = abs(height);
  33.       target_height = width;
  34.     }
  35.   }
  37.   // Setting absolute height (in case it was negative).
  38.   // In Windows, the image starts bottom left, instead of top left.
  39.   // Setting a negative source height, inverts the image (within LibYuv).
  41.   // TODO(nisse): Use a pool?
  42.   rtc::scoped_refptr<I420Buffer> buffer = I420Buffer::Create(
  43.       target_width, target_height, stride_y, stride_uv, stride_uv);
  45.   libyuv::RotationMode rotation_mode = libyuv::kRotate0;
  46.   if (apply_rotation) {
  47.     switch (_rotateFrame) {
  48.       case kVideoRotation_0:
  49.         rotation_mode = libyuv::kRotate0;
  50.         break;
  51.       case kVideoRotation_90:
  52.         rotation_mode = libyuv::kRotate90;
  53.         break;
  54.       case kVideoRotation_180:
  55.         rotation_mode = libyuv::kRotate180;
  56.         break;
  57.       case kVideoRotation_270:
  58.         rotation_mode = libyuv::kRotate270;
  59.         break;
  60.     }
  61.   }
  63.     // 将输入数据转为I420
  64.   const int conversionResult = libyuv::ConvertToI420(
  65.       videoFrame, videoFrameLength, buffer.get()->MutableDataY(),
  66.       buffer.get()->StrideY(), buffer.get()->MutableDataU(),
  67.       buffer.get()->StrideU(), buffer.get()->MutableDataV(),
  68.       buffer.get()->StrideV(), 0, 0,  // No Cropping
  69.       width, height, target_width, target_height, rotation_mode,
  70.       ConvertVideoType(frameInfo.videoType));
  71.   if (conversionResult < 0) {
  72.     RTC_LOG(LS_ERROR) << "Failed to convert capture frame from type "
  73.                       << static_cast<int>(frameInfo.videoType) << "to I420.";
  74.     return -1;
  75.   }
  77.   VideoFrame captureFrame =
  78.       VideoFrame::Builder()
  79.           .set_video_frame_buffer(buffer)
  80.           .set_timestamp_rtp(0)
  81.           .set_timestamp_ms(rtc::TimeMillis())
  82.           .set_rotation(!apply_rotation ? _rotateFrame : kVideoRotation_0)
  83.           .build();
  84.   captureFrame.set_ntp_time_ms(captureTime);
  86.   DeliverCapturedFrame(captureFrame);
  88.   return 0;
  89. }

—> DeliverCapturedFrame(captureFrame);

VideoCaptureImpl::DeliverCapturedFrame

  1. int32_t VideoCaptureImpl::DeliverCapturedFrame(VideoFrame& captureFrame) {
  2.   UpdateFrameCount();  // frame count used for local frame rate callback.
  4.   if (_dataCallBack) { 
  5.     _dataCallBack->OnFrame(captureFrame);
  6.   }
  8.   return 0;
  9. }

—> _dataCallBack->OnFrame(captureFrame);
h:\webrtc-20210315\webrtc-20210315\webrtc\webrtc-checkout\src\test\vcm_capturer.cc

VcmCapturer::OnFrame

  1. void VcmCapturer::OnFrame(const VideoFrame& frame) {
  2.   TestVideoCapturer::OnFrame(frame); // 里面调用broadcaster_.OnFrame分发数据
  3. }