From fa66659c6b5a13af3cdfcbf24e3bb88356e7f867 Mon Sep 17 00:00:00 2001 From: mflodman Date: Thu, 28 Apr 2016 23:15:33 -0700 Subject: [PATCH] Rename ViEReceiver and move ownership to VideoReceiveStream. This CL will be followed up with another CL removing everything related to RTP from ViEChannel to RtpStreamReceiver, i.e. remove ViEChannel::rtp_stream_receiver_. BUG=5838 Review-Url: https://codereview.webrtc.org/1917363005 Cr-Commit-Position: refs/heads/master@{#12553} --- webrtc/video/BUILD.gn | 4 +- ...vie_receiver.cc => rtp_stream_receiver.cc} | 116 ++++++++++-------- .../{vie_receiver.h => rtp_stream_receiver.h} | 32 +++-- webrtc/video/video_receive_stream.cc | 60 +++++---- webrtc/video/video_receive_stream.h | 2 +- webrtc/video/vie_channel.cc | 59 ++------- webrtc/video/vie_channel.h | 30 +---- webrtc/video/webrtc_video.gypi | 4 +- 8 files changed, 139 insertions(+), 168 deletions(-) rename webrtc/video/{vie_receiver.cc => rtp_stream_receiver.cc} (81%) rename webrtc/video/{vie_receiver.h => rtp_stream_receiver.h} (84%) diff --git a/webrtc/video/BUILD.gn b/webrtc/video/BUILD.gn index 4f1b7ae197..ec45987172 100644 --- a/webrtc/video/BUILD.gn +++ b/webrtc/video/BUILD.gn @@ -24,6 +24,8 @@ source_set("video") { "receive_statistics_proxy.h", "report_block_stats.cc", "report_block_stats.h", + "rtp_stream_receiver.cc", + "rtp_stream_receiver.h", "send_statistics_proxy.cc", "send_statistics_proxy.h", "stream_synchronization.cc", @@ -40,8 +42,6 @@ source_set("video") { "vie_channel.h", "vie_encoder.cc", "vie_encoder.h", - "vie_receiver.cc", - "vie_receiver.h", "vie_remb.cc", "vie_remb.h", "vie_sync_module.cc", diff --git a/webrtc/video/vie_receiver.cc b/webrtc/video/rtp_stream_receiver.cc similarity index 81% rename from webrtc/video/vie_receiver.cc rename to webrtc/video/rtp_stream_receiver.cc index 95d2f6fc8e..6421190e98 100644 --- a/webrtc/video/vie_receiver.cc +++ b/webrtc/video/rtp_stream_receiver.cc @@ -8,7 +8,7 @@ * be found in the AUTHORS file in the root of the source tree. */ -#include "webrtc/video/vie_receiver.h" +#include "webrtc/video/rtp_stream_receiver.h" #include @@ -67,13 +67,13 @@ std::unique_ptr CreateRtpRtcpModule( static const int kPacketLogIntervalMs = 10000; -ViEReceiver::ViEReceiver(vcm::VideoReceiver* video_receiver, - RemoteBitrateEstimator* remote_bitrate_estimator, - RtpFeedback* rtp_feedback, - Transport* transport, - RtcpRttStats* rtt_stats, - PacedSender* paced_sender, - PacketRouter* packet_router) +RtpStreamReceiver::RtpStreamReceiver( + vcm::VideoReceiver* video_receiver, + RemoteBitrateEstimator* remote_bitrate_estimator, + Transport* transport, + RtcpRttStats* rtt_stats, + PacedSender* paced_sender, + PacketRouter* packet_router) : clock_(Clock::GetRealTimeClock()), video_receiver_(video_receiver), remote_bitrate_estimator_(remote_bitrate_estimator), @@ -83,7 +83,7 @@ ViEReceiver::ViEReceiver(vcm::VideoReceiver* video_receiver, rtp_header_parser_(RtpHeaderParser::Create()), rtp_receiver_(RtpReceiver::CreateVideoReceiver(clock_, this, - rtp_feedback, + this, &rtp_payload_registry_)), rtp_receive_statistics_(ReceiveStatistics::Create(clock_)), fec_receiver_(FecReceiver::Create(this)), @@ -101,12 +101,12 @@ ViEReceiver::ViEReceiver(vcm::VideoReceiver* video_receiver, rtp_rtcp_->SetKeyFrameRequestMethod(kKeyFrameReqPliRtcp); } -ViEReceiver::~ViEReceiver() { +RtpStreamReceiver::~RtpStreamReceiver() { packet_router_->RemoveRtpModule(rtp_rtcp_.get()); UpdateHistograms(); } -void ViEReceiver::UpdateHistograms() { +void RtpStreamReceiver::UpdateHistograms() { FecPacketCounter counter = fec_receiver_->GetPacketCounter(); if (counter.num_packets > 0) { RTC_LOGGED_HISTOGRAM_PERCENTAGE( @@ -121,7 +121,7 @@ void ViEReceiver::UpdateHistograms() { } } -bool ViEReceiver::SetReceiveCodec(const VideoCodec& video_codec) { +bool RtpStreamReceiver::SetReceiveCodec(const VideoCodec& video_codec) { int8_t old_pltype = -1; if (rtp_payload_registry_.ReceivePayloadType( video_codec.plName, kVideoPayloadTypeFrequency, 0, @@ -134,8 +134,8 @@ bool ViEReceiver::SetReceiveCodec(const VideoCodec& video_codec) { 0, 0) == 0; } -void ViEReceiver::SetNackStatus(bool enable, - int max_nack_reordering_threshold) { +void RtpStreamReceiver::SetNackStatus(bool enable, + int max_nack_reordering_threshold) { if (!enable) { // Reset the threshold back to the lower default threshold when NACK is // disabled since we no longer will be receiving retransmissions. @@ -146,56 +146,57 @@ void ViEReceiver::SetNackStatus(bool enable, rtp_receiver_->SetNACKStatus(enable ? kNackRtcp : kNackOff); } -void ViEReceiver::SetRtxPayloadType(int payload_type, - int associated_payload_type) { +void RtpStreamReceiver::SetRtxPayloadType(int payload_type, + int associated_payload_type) { rtp_payload_registry_.SetRtxPayloadType(payload_type, associated_payload_type); } -void ViEReceiver::SetUseRtxPayloadMappingOnRestore(bool val) { +void RtpStreamReceiver::SetUseRtxPayloadMappingOnRestore(bool val) { rtp_payload_registry_.set_use_rtx_payload_mapping_on_restore(val); } -void ViEReceiver::SetRtxSsrc(uint32_t ssrc) { +void RtpStreamReceiver::SetRtxSsrc(uint32_t ssrc) { rtp_payload_registry_.SetRtxSsrc(ssrc); } -bool ViEReceiver::GetRtxSsrc(uint32_t* ssrc) const { +bool RtpStreamReceiver::GetRtxSsrc(uint32_t* ssrc) const { return rtp_payload_registry_.GetRtxSsrc(ssrc); } -bool ViEReceiver::IsFecEnabled() const { +bool RtpStreamReceiver::IsFecEnabled() const { return rtp_payload_registry_.ulpfec_payload_type() > -1; } -uint32_t ViEReceiver::GetRemoteSsrc() const { +uint32_t RtpStreamReceiver::GetRemoteSsrc() const { return rtp_receiver_->SSRC(); } -int ViEReceiver::GetCsrcs(uint32_t* csrcs) const { +int RtpStreamReceiver::GetCsrcs(uint32_t* csrcs) const { return rtp_receiver_->CSRCs(csrcs); } -RtpReceiver* ViEReceiver::GetRtpReceiver() const { +RtpReceiver* RtpStreamReceiver::GetRtpReceiver() const { return rtp_receiver_.get(); } -void ViEReceiver::EnableReceiveRtpHeaderExtension(const std::string& extension, - int id) { +void RtpStreamReceiver::EnableReceiveRtpHeaderExtension( + const std::string& extension, int id) { RTC_DCHECK(RtpExtension::IsSupportedForVideo(extension)); RTC_CHECK(rtp_header_parser_->RegisterRtpHeaderExtension( StringToRtpExtensionType(extension), id)); } -void ViEReceiver::RegisterRtcpPacketTypeCounterObserver( +void RtpStreamReceiver::RegisterRtcpPacketTypeCounterObserver( RtcpPacketTypeCounterObserver* observer) { rtcp_packet_type_counter_observer_.Set(observer); } -int32_t ViEReceiver::OnReceivedPayloadData(const uint8_t* payload_data, - const size_t payload_size, - const WebRtcRTPHeader* rtp_header) { +int32_t RtpStreamReceiver::OnReceivedPayloadData( + const uint8_t* payload_data, + const size_t payload_size, + const WebRtcRTPHeader* rtp_header) { RTC_DCHECK(video_receiver_); WebRtcRTPHeader rtp_header_with_ntp = *rtp_header; rtp_header_with_ntp.ntp_time_ms = @@ -208,8 +209,8 @@ int32_t ViEReceiver::OnReceivedPayloadData(const uint8_t* payload_data, return 0; } -bool ViEReceiver::OnRecoveredPacket(const uint8_t* rtp_packet, - size_t rtp_packet_length) { +bool RtpStreamReceiver::OnRecoveredPacket(const uint8_t* rtp_packet, + size_t rtp_packet_length) { RTPHeader header; if (!rtp_header_parser_->Parse(rtp_packet, rtp_packet_length, &header)) { return false; @@ -219,9 +220,25 @@ bool ViEReceiver::OnRecoveredPacket(const uint8_t* rtp_packet, return ReceivePacket(rtp_packet, rtp_packet_length, header, in_order); } -bool ViEReceiver::DeliverRtp(const uint8_t* rtp_packet, - size_t rtp_packet_length, - const PacketTime& packet_time) { +// TODO(pbos): Remove as soon as audio can handle a changing payload type +// without this callback. +int32_t RtpStreamReceiver::OnInitializeDecoder( + const int8_t payload_type, + const char payload_name[RTP_PAYLOAD_NAME_SIZE], + const int frequency, + const size_t channels, + const uint32_t rate) { + RTC_NOTREACHED(); + return 0; +} + +void RtpStreamReceiver::OnIncomingSSRCChanged(const uint32_t ssrc) { + rtp_rtcp_->SetRemoteSSRC(ssrc); +} + +bool RtpStreamReceiver::DeliverRtp(const uint8_t* rtp_packet, + size_t rtp_packet_length, + const PacketTime& packet_time) { RTC_DCHECK(remote_bitrate_estimator_); { rtc::CritScope lock(&receive_cs_); @@ -276,10 +293,10 @@ bool ViEReceiver::DeliverRtp(const uint8_t* rtp_packet, return ret; } -bool ViEReceiver::ReceivePacket(const uint8_t* packet, - size_t packet_length, - const RTPHeader& header, - bool in_order) { +bool RtpStreamReceiver::ReceivePacket(const uint8_t* packet, + size_t packet_length, + const RTPHeader& header, + bool in_order) { if (rtp_payload_registry_.IsEncapsulated(header)) { return ParseAndHandleEncapsulatingHeader(packet, packet_length, header); } @@ -295,9 +312,8 @@ bool ViEReceiver::ReceivePacket(const uint8_t* packet, payload_specific, in_order); } -bool ViEReceiver::ParseAndHandleEncapsulatingHeader(const uint8_t* packet, - size_t packet_length, - const RTPHeader& header) { +bool RtpStreamReceiver::ParseAndHandleEncapsulatingHeader( + const uint8_t* packet, size_t packet_length, const RTPHeader& header) { if (rtp_payload_registry_.IsRed(header)) { int8_t ulpfec_pt = rtp_payload_registry_.ulpfec_payload_type(); if (packet[header.headerLength] == ulpfec_pt) { @@ -343,7 +359,7 @@ bool ViEReceiver::ParseAndHandleEncapsulatingHeader(const uint8_t* packet, return false; } -void ViEReceiver::NotifyReceiverOfFecPacket(const RTPHeader& header) { +void RtpStreamReceiver::NotifyReceiverOfFecPacket(const RTPHeader& header) { int8_t last_media_payload_type = rtp_payload_registry_.last_received_media_payload_type(); if (last_media_payload_type < 0) { @@ -370,8 +386,8 @@ void ViEReceiver::NotifyReceiverOfFecPacket(const RTPHeader& header) { OnReceivedPayloadData(nullptr, 0, &rtp_header); } -bool ViEReceiver::DeliverRtcp(const uint8_t* rtcp_packet, - size_t rtcp_packet_length) { +bool RtpStreamReceiver::DeliverRtcp(const uint8_t* rtcp_packet, + size_t rtcp_packet_length) { { rtc::CritScope lock(&receive_cs_); if (!receiving_) { @@ -400,21 +416,21 @@ bool ViEReceiver::DeliverRtcp(const uint8_t* rtcp_packet, return true; } -void ViEReceiver::StartReceive() { +void RtpStreamReceiver::StartReceive() { rtc::CritScope lock(&receive_cs_); receiving_ = true; } -void ViEReceiver::StopReceive() { +void RtpStreamReceiver::StopReceive() { rtc::CritScope lock(&receive_cs_); receiving_ = false; } -ReceiveStatistics* ViEReceiver::GetReceiveStatistics() const { +ReceiveStatistics* RtpStreamReceiver::GetReceiveStatistics() const { return rtp_receive_statistics_.get(); } -bool ViEReceiver::IsPacketInOrder(const RTPHeader& header) const { +bool RtpStreamReceiver::IsPacketInOrder(const RTPHeader& header) const { StreamStatistician* statistician = rtp_receive_statistics_->GetStatistician(header.ssrc); if (!statistician) @@ -422,8 +438,8 @@ bool ViEReceiver::IsPacketInOrder(const RTPHeader& header) const { return statistician->IsPacketInOrder(header.sequenceNumber); } -bool ViEReceiver::IsPacketRetransmitted(const RTPHeader& header, - bool in_order) const { +bool RtpStreamReceiver::IsPacketRetransmitted(const RTPHeader& header, + bool in_order) const { // Retransmissions are handled separately if RTX is enabled. if (rtp_payload_registry_.RtxEnabled()) return false; diff --git a/webrtc/video/vie_receiver.h b/webrtc/video/rtp_stream_receiver.h similarity index 84% rename from webrtc/video/vie_receiver.h rename to webrtc/video/rtp_stream_receiver.h index cd7638f65e..d5513fb518 100644 --- a/webrtc/video/vie_receiver.h +++ b/webrtc/video/rtp_stream_receiver.h @@ -8,8 +8,8 @@ * be found in the AUTHORS file in the root of the source tree. */ -#ifndef WEBRTC_VIDEO_VIE_RECEIVER_H_ -#define WEBRTC_VIDEO_VIE_RECEIVER_H_ +#ifndef WEBRTC_VIDEO_RTP_STREAM_RECEIVER_H_ +#define WEBRTC_VIDEO_RTP_STREAM_RECEIVER_H_ #include #include @@ -44,16 +44,15 @@ namespace vcm { class VideoReceiver; } // namespace vcm -class ViEReceiver : public RtpData { +class RtpStreamReceiver : public RtpData, public RtpFeedback { public: - ViEReceiver(vcm::VideoReceiver* video_receiver, - RemoteBitrateEstimator* remote_bitrate_estimator, - RtpFeedback* rtp_feedback, - Transport* transport, - RtcpRttStats* rtt_stats, - PacedSender* paced_sender, - PacketRouter* packet_router); - ~ViEReceiver(); + RtpStreamReceiver(vcm::VideoReceiver* video_receiver, + RemoteBitrateEstimator* remote_bitrate_estimator, + Transport* transport, + RtcpRttStats* rtt_stats, + PacedSender* paced_sender, + PacketRouter* packet_router); + ~RtpStreamReceiver(); bool SetReceiveCodec(const VideoCodec& video_codec); @@ -93,6 +92,15 @@ class ViEReceiver : public RtpData { const WebRtcRTPHeader* rtp_header) override; bool OnRecoveredPacket(const uint8_t* packet, size_t packet_length) override; + // Implements RtpFeedback. + int32_t OnInitializeDecoder(const int8_t payload_type, + const char payload_name[RTP_PAYLOAD_NAME_SIZE], + const int frequency, + const size_t channels, + const uint32_t rate) override; + void OnIncomingSSRCChanged(const uint32_t ssrc) override; + void OnIncomingCSRCChanged(const uint32_t CSRC, const bool added) override {} + ReceiveStatistics* GetReceiveStatistics() const; template @@ -169,4 +177,4 @@ class ViEReceiver : public RtpData { } // namespace webrtc -#endif // WEBRTC_VIDEO_VIE_RECEIVER_H_ +#endif // WEBRTC_VIDEO_RTP_STREAM_RECEIVER_H_ diff --git a/webrtc/video/video_receive_stream.cc b/webrtc/video/video_receive_stream.cc index fc98c582e1..b82fa9a670 100644 --- a/webrtc/video/video_receive_stream.cc +++ b/webrtc/video/video_receive_stream.cc @@ -165,15 +165,15 @@ VideoReceiveStream::VideoReceiveStream( video_receiver_(clock_, nullptr, this, this, this), incoming_video_stream_(0, config.disable_prerenderer_smoothing), stats_proxy_(config_, clock_), - vie_channel_(&transport_adapter_, - process_thread, - &video_receiver_, - congestion_controller_->GetRemoteBitrateEstimator( - UseSendSideBwe(config_)), - call_stats_->rtcp_rtt_stats(), - congestion_controller_->pacer(), - congestion_controller_->packet_router()), - vie_receiver_(vie_channel_.vie_receiver()), + rtp_stream_receiver_(&video_receiver_, + congestion_controller_->GetRemoteBitrateEstimator( + UseSendSideBwe(config_)), + &transport_adapter_, + call_stats_->rtcp_rtt_stats(), + congestion_controller_->pacer(), + congestion_controller_->packet_router()), + vie_channel_(&video_receiver_, + &rtp_stream_receiver_), vie_sync_(&video_receiver_), rtp_rtcp_(vie_channel_.rtp_rtcp()) { LOG(LS_INFO) << "VideoReceiveStream: " << config_.ToString(); @@ -206,12 +206,12 @@ VideoReceiveStream::VideoReceiveStream( RTC_DCHECK(kv.second.ssrc != 0); RTC_DCHECK(kv.second.payload_type != 0); - vie_receiver_->SetRtxSsrc(kv.second.ssrc); - vie_receiver_->SetRtxPayloadType(kv.second.payload_type, kv.first); + rtp_stream_receiver_.SetRtxSsrc(kv.second.ssrc); + rtp_stream_receiver_.SetRtxPayloadType(kv.second.payload_type, kv.first); } // TODO(holmer): When Chrome no longer depends on this being false by default, // always use the mapping and remove this whole codepath. - vie_receiver_->SetUseRtxPayloadMappingOnRestore( + rtp_stream_receiver_.SetUseRtxPayloadMappingOnRestore( config_.rtp.use_rtx_payload_mapping_on_restore); if (config_.rtp.remb) { @@ -225,7 +225,7 @@ VideoReceiveStream::VideoReceiveStream( // One-byte-extension local identifiers are in the range 1-14 inclusive. RTC_DCHECK_GE(id, 1); RTC_DCHECK_LE(id, 14); - vie_receiver_->EnableReceiveRtpHeaderExtension(extension, id); + rtp_stream_receiver_.EnableReceiveRtpHeaderExtension(extension, id); } if (config_.rtp.fec.ulpfec_payload_type != -1) { @@ -236,7 +236,7 @@ VideoReceiveStream::VideoReceiveStream( codec.codecType = kVideoCodecULPFEC; strncpy(codec.plName, "ulpfec", sizeof(codec.plName)); codec.plType = config_.rtp.fec.ulpfec_payload_type; - RTC_CHECK(vie_receiver_->SetReceiveCodec(codec)); + RTC_CHECK(rtp_stream_receiver_.SetReceiveCodec(codec)); } if (config_.rtp.fec.red_payload_type != -1) { VideoCodec codec; @@ -244,10 +244,11 @@ VideoReceiveStream::VideoReceiveStream( codec.codecType = kVideoCodecRED; strncpy(codec.plName, "red", sizeof(codec.plName)); codec.plType = config_.rtp.fec.red_payload_type; - RTC_CHECK(vie_receiver_->SetReceiveCodec(codec)); + RTC_CHECK(rtp_stream_receiver_.SetReceiveCodec(codec)); if (config_.rtp.fec.red_rtx_payload_type != -1) { - vie_receiver_->SetRtxPayloadType(config_.rtp.fec.red_rtx_payload_type, - config_.rtp.fec.red_payload_type); + rtp_stream_receiver_.SetRtxPayloadType( + config_.rtp.fec.red_rtx_payload_type, + config_.rtp.fec.red_payload_type); } } @@ -255,9 +256,9 @@ VideoReceiveStream::VideoReceiveStream( rtp_rtcp_->SetRtcpXrRrtrStatus(true); vie_channel_.RegisterReceiveStatisticsProxy(&stats_proxy_); - vie_receiver_->GetReceiveStatistics()->RegisterRtpStatisticsCallback( + rtp_stream_receiver_.GetReceiveStatistics()->RegisterRtpStatisticsCallback( &stats_proxy_); - vie_receiver_->GetReceiveStatistics()->RegisterRtcpStatisticsCallback( + rtp_stream_receiver_.GetReceiveStatistics()->RegisterRtcpStatisticsCallback( &stats_proxy_); // Stats callback for CNAME changes. rtp_rtcp_->RegisterRtcpStatisticsCallback(&stats_proxy_); @@ -277,7 +278,7 @@ VideoReceiveStream::VideoReceiveStream( VideoCodec codec = CreateDecoderVideoCodec(decoder); - RTC_CHECK(vie_receiver_->SetReceiveCodec(codec)); + RTC_CHECK(rtp_stream_receiver_.SetReceiveCodec(codec)); RTC_CHECK_EQ(VCM_OK, video_receiver_.RegisterReceiveCodec( &codec, num_cpu_cores, false)); } @@ -288,6 +289,8 @@ VideoReceiveStream::VideoReceiveStream( vie_channel_.SetIncomingVideoStream(&incoming_video_stream_); vie_channel_.RegisterPreRenderCallback(this); + process_thread_->RegisterModule(rtp_stream_receiver_.GetReceiveStatistics()); + process_thread_->RegisterModule(rtp_stream_receiver_.rtp_rtcp()); process_thread_->RegisterModule(&video_receiver_); process_thread_->RegisterModule(&vie_sync_); } @@ -298,6 +301,9 @@ VideoReceiveStream::~VideoReceiveStream() { process_thread_->DeRegisterModule(&vie_sync_); process_thread_->DeRegisterModule(&video_receiver_); + process_thread_->DeRegisterModule(rtp_stream_receiver_.rtp_rtcp()); + process_thread_->DeRegisterModule( + rtp_stream_receiver_.GetReceiveStatistics()); // Deregister external decoders so that they are no longer running during // destruction. This effectively stops the VCM since the decoder thread is @@ -313,7 +319,7 @@ VideoReceiveStream::~VideoReceiveStream() { remb_->RemoveReceiveChannel(rtp_rtcp_); congestion_controller_->GetRemoteBitrateEstimator(UseSendSideBwe(config_)) - ->RemoveStream(vie_receiver_->GetRemoteSsrc()); + ->RemoveStream(rtp_stream_receiver_.GetRemoteSsrc()); } void VideoReceiveStream::Start() { @@ -324,12 +330,12 @@ void VideoReceiveStream::Start() { // Start the decode thread decode_thread_.Start(); decode_thread_.SetPriority(rtc::kHighestPriority); - vie_receiver_->StartReceive(); + rtp_stream_receiver_.StartReceive(); } void VideoReceiveStream::Stop() { incoming_video_stream_.Stop(); - vie_receiver_->StopReceive(); + rtp_stream_receiver_.StopReceive(); video_receiver_.TriggerDecoderShutdown(); decode_thread_.Stop(); transport_adapter_.Disable(); @@ -340,12 +346,12 @@ void VideoReceiveStream::SetSyncChannel(VoiceEngine* voice_engine, if (voice_engine && audio_channel_id != -1) { VoEVideoSync* voe_sync_interface = VoEVideoSync::GetInterface(voice_engine); vie_sync_.ConfigureSync(audio_channel_id, voe_sync_interface, rtp_rtcp_, - vie_receiver_->GetRtpReceiver()); + rtp_stream_receiver_.GetRtpReceiver()); voe_sync_interface->Release(); return; } vie_sync_.ConfigureSync(-1, nullptr, rtp_rtcp_, - vie_receiver_->GetRtpReceiver()); + rtp_stream_receiver_.GetRtpReceiver()); } VideoReceiveStream::Stats VideoReceiveStream::GetStats() const { @@ -353,13 +359,13 @@ VideoReceiveStream::Stats VideoReceiveStream::GetStats() const { } bool VideoReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) { - return vie_receiver_->DeliverRtcp(packet, length); + return rtp_stream_receiver_.DeliverRtcp(packet, length); } bool VideoReceiveStream::DeliverRtp(const uint8_t* packet, size_t length, const PacketTime& packet_time) { - return vie_receiver_->DeliverRtp(packet, length, packet_time); + return rtp_stream_receiver_.DeliverRtp(packet, length, packet_time); } void VideoReceiveStream::FrameCallback(VideoFrame* video_frame) { diff --git a/webrtc/video/video_receive_stream.h b/webrtc/video/video_receive_stream.h index 316e281fcc..5c474226b0 100644 --- a/webrtc/video/video_receive_stream.h +++ b/webrtc/video/video_receive_stream.h @@ -108,8 +108,8 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream, vcm::VideoReceiver video_receiver_; IncomingVideoStream incoming_video_stream_; ReceiveStatisticsProxy stats_proxy_; + RtpStreamReceiver rtp_stream_receiver_; ViEChannel vie_channel_; - ViEReceiver* const vie_receiver_; ViESyncModule vie_sync_; RtpRtcp* const rtp_rtcp_; diff --git a/webrtc/video/vie_channel.cc b/webrtc/video/vie_channel.cc index a8ee4bcad0..6595ce4498 100644 --- a/webrtc/video/vie_channel.cc +++ b/webrtc/video/vie_channel.cc @@ -16,13 +16,11 @@ #include "webrtc/base/checks.h" #include "webrtc/base/logging.h" -#include "webrtc/base/platform_thread.h" #include "webrtc/common_video/include/frame_callback.h" #include "webrtc/common_video/include/incoming_video_stream.h" #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h" #include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h" #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h" -#include "webrtc/modules/utility/include/process_thread.h" #include "webrtc/modules/video_coding/video_coding_impl.h" #include "webrtc/modules/video_processing/include/video_processing.h" #include "webrtc/modules/video_render/video_render_defines.h" @@ -51,18 +49,11 @@ class ChannelStatsObserver : public CallStatsObserver { ViEChannel* const owner_; }; -ViEChannel::ViEChannel(Transport* transport, - ProcessThread* module_process_thread, - vcm::VideoReceiver* video_receiver, - RemoteBitrateEstimator* remote_bitrate_estimator, - RtcpRttStats* rtt_stats, - PacedSender* paced_sender, - PacketRouter* packet_router) - : module_process_thread_(module_process_thread), - video_receiver_(video_receiver), - vie_receiver_(video_receiver, remote_bitrate_estimator, this, transport, - rtt_stats, paced_sender, packet_router), - rtp_rtcp_(vie_receiver_.rtp_rtcp()), +ViEChannel::ViEChannel(vcm::VideoReceiver* video_receiver, + RtpStreamReceiver* rtp_stream_receiver) + : video_receiver_(video_receiver), + rtp_stream_receiver_(rtp_stream_receiver), + rtp_rtcp_(rtp_stream_receiver_->rtp_rtcp()), stats_observer_(new ChannelStatsObserver(this)), receive_stats_callback_(nullptr), incoming_video_stream_(nullptr), @@ -74,10 +65,10 @@ ViEChannel::ViEChannel(Transport* transport, max_nack_reordering_threshold_, 0); } +ViEChannel::~ViEChannel() {} + int32_t ViEChannel::Init() { static const int kDefaultRenderDelayMs = 10; - module_process_thread_->RegisterModule(vie_receiver_.GetReceiveStatistics()); - module_process_thread_->RegisterModule(rtp_rtcp_); if (video_receiver_->RegisterReceiveCallback(this) != 0) { return -1; @@ -90,14 +81,6 @@ int32_t ViEChannel::Init() { return 0; } -ViEChannel::~ViEChannel() { - // Make sure we don't get more callbacks from the RTP module. - module_process_thread_->DeRegisterModule( - vie_receiver_.GetReceiveStatistics()); - - module_process_thread_->DeRegisterModule(rtp_rtcp_); -} - void ViEChannel::SetProtectionMode(bool enable_nack, bool enable_fec, int payload_type_red, @@ -141,7 +124,7 @@ void ViEChannel::ProcessNACKRequest(const bool enable) { // Turn on NACK. if (rtp_rtcp_->RTCP() == RtcpMode::kOff) return; - vie_receiver_.SetNackStatus(true, max_nack_reordering_threshold_); + rtp_stream_receiver_->SetNackStatus(true, max_nack_reordering_threshold_); video_receiver_->RegisterPacketRequestCallback(this); // Don't introduce errors when NACK is enabled. video_receiver_->SetDecodeErrorMode(kNoErrors); @@ -151,7 +134,7 @@ void ViEChannel::ProcessNACKRequest(const bool enable) { // When NACK is off, allow decoding with errors. Otherwise, the video // will freeze, and will only recover with a complete key frame. video_receiver_->SetDecodeErrorMode(kWithErrors); - vie_receiver_.SetNackStatus(false, max_nack_reordering_threshold_); + rtp_stream_receiver_->SetNackStatus(false, max_nack_reordering_threshold_); } } @@ -170,11 +153,7 @@ RtpState ViEChannel::GetRtpStateForSsrc(uint32_t ssrc) const { void ViEChannel::RegisterRtcpPacketTypeCounterObserver( RtcpPacketTypeCounterObserver* observer) { - vie_receiver_.RegisterRtcpPacketTypeCounterObserver(observer); -} - -ViEReceiver* ViEChannel::vie_receiver() { - return &vie_receiver_; + rtp_stream_receiver_->RegisterRtcpPacketTypeCounterObserver(observer); } CallStatsObserver* ViEChannel::GetStatsObserver() { @@ -275,24 +254,6 @@ void ViEChannel::RegisterPreRenderCallback( pre_render_callback_ = pre_render_callback; } -// TODO(pbos): Remove as soon as audio can handle a changing payload type -// without this callback. -int32_t ViEChannel::OnInitializeDecoder( - const int8_t payload_type, - const char payload_name[RTP_PAYLOAD_NAME_SIZE], - const int frequency, - const size_t channels, - const uint32_t rate) { - RTC_NOTREACHED(); - return 0; -} - -void ViEChannel::OnIncomingSSRCChanged(const uint32_t ssrc) { - rtp_rtcp_->SetRemoteSSRC(ssrc); -} - -void ViEChannel::OnIncomingCSRCChanged(const uint32_t CSRC, const bool added) {} - void ViEChannel::RegisterReceiveStatisticsProxy( ReceiveStatisticsProxy* receive_statistics_proxy) { rtc::CritScope lock(&crit_); diff --git a/webrtc/video/vie_channel.h b/webrtc/video/vie_channel.h index 597ac5bfe0..0411857826 100644 --- a/webrtc/video/vie_channel.h +++ b/webrtc/video/vie_channel.h @@ -25,7 +25,7 @@ #include "webrtc/modules/video_coding/include/video_coding_defines.h" #include "webrtc/system_wrappers/include/tick_util.h" #include "webrtc/typedefs.h" -#include "webrtc/video/vie_receiver.h" +#include "webrtc/video/rtp_stream_receiver.h" #include "webrtc/video/vie_sync_module.h" namespace webrtc { @@ -39,7 +39,6 @@ class IncomingVideoStream; class PacedSender; class PacketRouter; class PayloadRouter; -class ProcessThread; class ReceiveStatisticsProxy; class RtcpRttStats; class ViERTPObserver; @@ -59,18 +58,12 @@ class ViEChannel : public VCMFrameTypeCallback, public VCMReceiveCallback, public VCMReceiveStatisticsCallback, public VCMDecoderTimingCallback, - public VCMPacketRequestCallback, - public RtpFeedback { + public VCMPacketRequestCallback { public: friend class ChannelStatsObserver; - ViEChannel(Transport* transport, - ProcessThread* module_process_thread, - vcm::VideoReceiver* video_receiver, - RemoteBitrateEstimator* remote_bitrate_estimator, - RtcpRttStats* rtt_stats, - PacedSender* paced_sender, - PacketRouter* packet_router); + ViEChannel(vcm::VideoReceiver* video_receiver, + RtpStreamReceiver* rtp_stream_receiver); ~ViEChannel(); int32_t Init(); @@ -84,17 +77,6 @@ class ViEChannel : public VCMFrameTypeCallback, RtpState GetRtpStateForSsrc(uint32_t ssrc) const; - // Implements RtpFeedback. - int32_t OnInitializeDecoder(const int8_t payload_type, - const char payload_name[RTP_PAYLOAD_NAME_SIZE], - const int frequency, - const size_t channels, - const uint32_t rate) override; - void OnIncomingSSRCChanged(const uint32_t ssrc) override; - void OnIncomingCSRCChanged(const uint32_t CSRC, const bool added) override; - - // Gets the module used by the channel. - ViEReceiver* vie_receiver(); CallStatsObserver* GetStatsObserver(); @@ -154,13 +136,11 @@ class ViEChannel : public VCMFrameTypeCallback, // Compute NACK list parameters for the buffering mode. int GetRequiredNackListSize(int target_delay_ms); - ProcessThread* const module_process_thread_; - // Used for all registered callbacks except rendering. rtc::CriticalSection crit_; vcm::VideoReceiver* const video_receiver_; - ViEReceiver vie_receiver_; + RtpStreamReceiver* const rtp_stream_receiver_; RtpRtcp* const rtp_rtcp_; // Helper to report call statistics. diff --git a/webrtc/video/webrtc_video.gypi b/webrtc/video/webrtc_video.gypi index f11ce95727..54efbcd16e 100644 --- a/webrtc/video/webrtc_video.gypi +++ b/webrtc/video/webrtc_video.gypi @@ -39,6 +39,8 @@ 'video/receive_statistics_proxy.h', 'video/report_block_stats.cc', 'video/report_block_stats.h', + 'video/rtp_stream_receiver.cc', + 'video/rtp_stream_receiver.h', 'video/send_statistics_proxy.cc', 'video/send_statistics_proxy.h', 'video/stream_synchronization.cc', @@ -55,8 +57,6 @@ 'video/vie_channel.h', 'video/vie_encoder.cc', 'video/vie_encoder.h', - 'video/vie_receiver.cc', - 'video/vie_receiver.h', 'video/vie_remb.cc', 'video/vie_remb.h', 'video/vie_sync_module.cc',