webrtc代码走读二(视频数据处理流程)

视频采集

CaptureInputPin::Receive(IMediaSample* media_sample)

filter->ProcessCapturedFrame(sample_props.pbBuffer, sample_props.lActual,resulting_capability_);

capture_observer_->IncomingFrame(buffer, length, frame_info);

DeliverCapturedFrame(captureFrame);

_dataCallBack->OnFrame(captureFrame);

void VideoStreamEncoder::OnFrame(const VideoFrame& video_frame) {

视频编码

void PacedSender::EnqueuePackets(

    std::vector<std::unique_ptr<RtpPacketToSend>> packets)

pacing_controller_.EnqueuePacket(std::move(packet));

RTPSender::SendToNetwork(std::unique_ptr<RtpPacketToSend> packet)

RTPSenderVideo::SendVideo(

    int payload_type,

    absl::optional<VideoCodecType> codec_type,

    uint32_t rtp_timestamp,

    int64_t capture_time_ms,

    rtc::ArrayView<const uint8_t> payload,

    RTPVideoHeader video_header,

    absl::optional<int64_t> expected_retransmission_time_ms,

    absl::optional<int64_t> estimated_capture_clock_offset_ms)

void RTPSenderVideo::LogAndSendToNetwork

rtp_sender_->EnqueuePackets

VideoSendStreamImpl::OnEncodedImage(

    const EncodedImage& encoded_image,

    const CodecSpecificInfo* codec_specific_info)

webrtc::EncodedImage& EncodedImage()

void VideoStreamEncoder::EncodeVideoFrame(const VideoFrame& video_frame,int64_t time_when_posted_us)

àmain_queue_->PostTask(ToQueuedTask(task_safety_, [this]()

MultithreadedFakeH264Encoder::EncodeTask::run

void StartThreads(std::vector<std::unique_ptr<Thread>>* threads,

                  MessageHandler* handler)

视频发包

void StartThreads(std::vector<std::unique_ptr<Thread>>* threads,

                  MessageHandler* handler)

PacedSender::Process()

pacing_controller_.ProcessPackets

PacingController::EnqueuePacket

PacingController::EnqueuePacketInternal(

    std::unique_ptr<RtpPacketToSend> packet,

    int priority)

packet_queue_.Push

WebRtcVideoChannel::SendRtp

MediaChannel::SendRtp

BaseChannel::SendPacket

BaseChannel::SendPacket(bool rtcp,

                             rtc::CopyOnWriteBuffer* packet,

                             const rtc::PacketOptions& options)

ediaChannel::SendRtp(const uint8_t* data,

                           size_t len,

                           const webrtc::PacketOptions& options)

network_thread_->PostTask(ToQueuedTask(network_safety_, std::move(send)))

视频解包

Thread::Start()

Thread::PreRun()

Thread::Run(RunLoop* run_loop)

bool PhysicalSocketServer::Wait(int cmsWait, bool process_io)

void SocketDispatcher::OnEvent(uint32_t ff, int err)

AsyncUDPSocket::OnReadEvent(AsyncSocket* socket)

AllocationSequence::OnReadPacket(rtc::AsyncPacketSocket* socket,

                                      const char* data,

                                      size_t size,

                                      const rtc::SocketAddress& remote_addr,const int64_t& packet_time_us)

UDPPort::HandleIncomingPacket(rtc::AsyncPacketSocket* socket,

                                   const char* data,

                                   size_t size,

const rtc::SocketAddress& remote_addr,int64_t packet_time_us)

UDPPort::OnReadPacket(rtc::AsyncPacketSocket* socket,

                           const char* data,size_t size,

                           const rtc::SocketAddress& remote_addr, const int64_t& packet_time_us)

Connection::OnReadPacket(const char* data, size_t size, int64_t packet_time_us)

P2PTransportChannel::OnReadPacket(Connection* connection,

const char* data,size_t len,int64_t packet_time_us)

DtlsTransport::OnReadPacket(rtc::PacketTransportInternal* transport, const char* data,size_t size,const int64_t& packet_time_us,

                                 int flags)

RtpTransport::OnReadPacket(rtc::PacketTransportInternal* transport,

                                const char* data,

                                size_t len,  const int64_t& packet_time_us, int flags)

SrtpTransport::OnRtpPacketReceived(rtc::CopyOnWriteBuffer packet, int64_t packet_time_us)

WebRtcVideoChannel::OnPacketReceived(rtc::CopyOnWriteBuffer packet,int64_t packet_time_us)

PacketReceiver::DeliveryStatus Call::DeliverPacket

DeliverRtp(media_type, std::move(packet), packet_time_us)

RtpStreamReceiverController::OnRtpPacket(const RtpPacketReceived& packet)

RtpDemuxer::OnRtpPacket(const RtpPacketReceived& packet)

RtpVideoStreamReceiver::OnRtpPacket(const RtpPacketReceived& packet)

RtpVideoStreamReceiver::ReceivePacket(const RtpPacketReceived& packet)

OnReceivedPayloadData(std::move(parsed_payload->video_payload), packet,

                        parsed_payload->video_header)

PacketBuffer::InsertPacket(Packet&& packet, StatisticsCalculator* stats, size_t last_decoded_length,size_t sample_rateint target_level_ms,

                               const DecoderDatabase& decoder_database)

视频解码

IncomingVideoStream::OnFrame(const VideoFrame& video_frame)

VideoStreamDecoder::FrameToRender(VideoFrame& video_frame,

                                          absl::optional<uint8_t> qp,  int32_t decode_time_ms,

                                          VideoContentType content_type)

VCMDecodedFrameCallback::Decoded(VideoFrame& decodedImage,absl::optional<int32_t> decode_time_ms,

                                      absl::optional<uint8_t> qp)

H264DecoderImpl::Decode(const EncodedImage& input_image,

                                bool /*missing_frames*/,

                                int64_t /*render_time_ms*/

VCMGenericDecoder::Decode(const VCMEncodedFrame& frame, Timestamp now)

VideoReceiver::Decode(uint16_t maxWaitTimeMs)

VideoReceiveStream::OnFrame(const VideoFrame& video_frame)

StartThread(ThreadMainInfo* info)

视频渲染

StartThreads(std::vector<std::unique_ptr<Thread>>& threads,

                  MessageHandler* handler)

function run()

Thread::ThreadMain()

TaskQueueWin::RunThreadMain()

TaskQueueWin::RunPendingTasks()

IncomingVideoStream::OnFrame()

IncomingVideoStream::Dequeue()

WebRtcVideoReceiveStream::onFrame()

VideoBroadcaster::onFrame()

VideoRenderer::onFrame()

InvalidateRect(wnd_, NULL, TRUE);

MainWnd::OnPaint()