diff --git a/webrtc/modules/rtp_rtcp/source/flexfec_receiver.cc b/webrtc/modules/rtp_rtcp/source/flexfec_receiver.cc index a365fcbec4..4a88cb4f91 100644 --- a/webrtc/modules/rtp_rtcp/source/flexfec_receiver.cc +++ b/webrtc/modules/rtp_rtcp/source/flexfec_receiver.cc @@ -112,7 +112,7 @@ bool FlexfecReceiver::AddReceivedPacket(const RtpPacketReceived& packet) { // This implementation only returns _recovered_ media packets through the // callback, whereas the implementation in UlpfecReceiver returns _all inserted_ // media packets through the callback. The latter behaviour makes sense -// for ULPFEC, since the ULPFEC receiver is owned by the RtpStreamReceiver. +// for ULPFEC, since the ULPFEC receiver is owned by the RtpVideoStreamReceiver. // Here, however, the received media pipeline is more decoupled from the // FlexFEC decoder, and we therefore do not interfere with the reception // of non-recovered media packets. diff --git a/webrtc/video/BUILD.gn b/webrtc/video/BUILD.gn index cc16269dd7..cfbadf5bff 100644 --- a/webrtc/video/BUILD.gn +++ b/webrtc/video/BUILD.gn @@ -24,10 +24,10 @@ rtc_static_library("video") { "receive_statistics_proxy.h", "report_block_stats.cc", "report_block_stats.h", - "rtp_stream_receiver.cc", - "rtp_stream_receiver.h", "rtp_streams_synchronizer.cc", "rtp_streams_synchronizer.h", + "rtp_video_stream_receiver.cc", + "rtp_video_stream_receiver.h", "send_delay_stats.cc", "send_delay_stats.h", "send_statistics_proxy.cc", @@ -240,7 +240,7 @@ if (rtc_include_tests) { "quality_threshold_unittest.cc", "receive_statistics_proxy_unittest.cc", "report_block_stats_unittest.cc", - "rtp_stream_receiver_unittest.cc", + "rtp_video_stream_receiver_unittest.cc", "send_delay_stats_unittest.cc", "send_statistics_proxy_unittest.cc", "stats_counter_unittest.cc", diff --git a/webrtc/video/rtp_stream_receiver.cc b/webrtc/video/rtp_video_stream_receiver.cc similarity index 88% rename from webrtc/video/rtp_stream_receiver.cc rename to webrtc/video/rtp_video_stream_receiver.cc index 78057771d6..0a946975d7 100644 --- a/webrtc/video/rtp_stream_receiver.cc +++ b/webrtc/video/rtp_video_stream_receiver.cc @@ -8,7 +8,7 @@ * be found in the AUTHORS file in the root of the source tree. */ -#include "webrtc/video/rtp_stream_receiver.h" +#include "webrtc/video/rtp_video_stream_receiver.h" #include #include @@ -78,7 +78,7 @@ std::unique_ptr CreateRtpRtcpModule( static const int kPacketLogIntervalMs = 10000; -RtpStreamReceiver::RtpStreamReceiver( +RtpVideoStreamReceiver::RtpVideoStreamReceiver( Transport* transport, RtcpRttStats* rtt_stats, PacketRouter* packet_router, @@ -189,7 +189,7 @@ RtpStreamReceiver::RtpStreamReceiver( reference_finder_.reset(new video_coding::RtpFrameReferenceFinder(this)); } -RtpStreamReceiver::~RtpStreamReceiver() { +RtpVideoStreamReceiver::~RtpVideoStreamReceiver() { if (nack_module_) { process_thread_->DeRegisterModule(nack_module_.get()); } @@ -200,14 +200,14 @@ RtpStreamReceiver::~RtpStreamReceiver() { UpdateHistograms(); } -bool RtpStreamReceiver::AddReceiveCodec( +bool RtpVideoStreamReceiver::AddReceiveCodec( const VideoCodec& video_codec, const std::map& codec_params) { pt_codec_params_.insert(make_pair(video_codec.plType, codec_params)); return AddReceiveCodec(video_codec); } -bool RtpStreamReceiver::AddReceiveCodec(const VideoCodec& video_codec) { +bool RtpVideoStreamReceiver::AddReceiveCodec(const VideoCodec& video_codec) { int8_t old_pltype = -1; if (rtp_payload_registry_.ReceivePayloadType(video_codec, &old_pltype) != -1) { @@ -216,19 +216,19 @@ bool RtpStreamReceiver::AddReceiveCodec(const VideoCodec& video_codec) { return rtp_payload_registry_.RegisterReceivePayload(video_codec) == 0; } -uint32_t RtpStreamReceiver::GetRemoteSsrc() const { +uint32_t RtpVideoStreamReceiver::GetRemoteSsrc() const { return rtp_receiver_->SSRC(); } -int RtpStreamReceiver::GetCsrcs(uint32_t* csrcs) const { +int RtpVideoStreamReceiver::GetCsrcs(uint32_t* csrcs) const { return rtp_receiver_->CSRCs(csrcs); } -RtpReceiver* RtpStreamReceiver::GetRtpReceiver() const { +RtpReceiver* RtpVideoStreamReceiver::GetRtpReceiver() const { return rtp_receiver_.get(); } -int32_t RtpStreamReceiver::OnReceivedPayloadData( +int32_t RtpVideoStreamReceiver::OnReceivedPayloadData( const uint8_t* payload_data, size_t payload_size, const WebRtcRTPHeader* rtp_header) { @@ -279,8 +279,8 @@ int32_t RtpStreamReceiver::OnReceivedPayloadData( // TODO(nisse): Try to delete this method. Obstacles: It is used by // ParseAndHandleEncapsulatingHeader, for handling Rtx packets, and // for callbacks from |ulpfec_receiver_|. -void RtpStreamReceiver::OnRecoveredPacket(const uint8_t* rtp_packet, - size_t rtp_packet_length) { +void RtpVideoStreamReceiver::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; @@ -292,7 +292,7 @@ void RtpStreamReceiver::OnRecoveredPacket(const uint8_t* rtp_packet, // TODO(pbos): Remove as soon as audio can handle a changing payload type // without this callback. -int32_t RtpStreamReceiver::OnInitializeDecoder( +int32_t RtpVideoStreamReceiver::OnInitializeDecoder( const int8_t payload_type, const char payload_name[RTP_PAYLOAD_NAME_SIZE], const int frequency, @@ -302,13 +302,13 @@ int32_t RtpStreamReceiver::OnInitializeDecoder( return 0; } -void RtpStreamReceiver::OnIncomingSSRCChanged(const uint32_t ssrc) { +void RtpVideoStreamReceiver::OnIncomingSSRCChanged(const uint32_t ssrc) { rtp_rtcp_->SetRemoteSSRC(ssrc); } // This method handles both regular RTP packets and packets recovered // via FlexFEC. -void RtpStreamReceiver::OnRtpPacket(const RtpPacketReceived& packet) { +void RtpVideoStreamReceiver::OnRtpPacket(const RtpPacketReceived& packet) { { rtc::CritScope lock(&receive_cs_); if (!receiving_) { @@ -364,35 +364,34 @@ void RtpStreamReceiver::OnRtpPacket(const RtpPacketReceived& packet) { } } -int32_t RtpStreamReceiver::RequestKeyFrame() { +int32_t RtpVideoStreamReceiver::RequestKeyFrame() { return rtp_rtcp_->RequestKeyFrame(); } -bool RtpStreamReceiver::IsUlpfecEnabled() const { +bool RtpVideoStreamReceiver::IsUlpfecEnabled() const { return config_.rtp.ulpfec.ulpfec_payload_type != -1; } -bool RtpStreamReceiver::IsRedEnabled() const { +bool RtpVideoStreamReceiver::IsRedEnabled() const { return config_.rtp.ulpfec.red_payload_type != -1; } -bool RtpStreamReceiver::IsRetransmissionsEnabled() const { +bool RtpVideoStreamReceiver::IsRetransmissionsEnabled() const { return config_.rtp.nack.rtp_history_ms > 0; } -void RtpStreamReceiver::RequestPacketRetransmit( +void RtpVideoStreamReceiver::RequestPacketRetransmit( const std::vector& sequence_numbers) { rtp_rtcp_->SendNack(sequence_numbers); } -int32_t RtpStreamReceiver::ResendPackets(const uint16_t* sequence_numbers, - uint16_t length) { +int32_t RtpVideoStreamReceiver::ResendPackets(const uint16_t* sequence_numbers, + uint16_t length) { return rtp_rtcp_->SendNACK(sequence_numbers, length); } -void RtpStreamReceiver::OnReceivedFrame( +void RtpVideoStreamReceiver::OnReceivedFrame( std::unique_ptr frame) { - if (!has_received_frame_) { has_received_frame_ = true; if (frame->FrameType() != kVideoFrameKey) @@ -404,7 +403,7 @@ void RtpStreamReceiver::OnReceivedFrame( reference_finder_->ManageFrame(std::move(frame)); } -void RtpStreamReceiver::OnCompleteFrame( +void RtpVideoStreamReceiver::OnCompleteFrame( std::unique_ptr frame) { { rtc::CritScope lock(&last_seq_num_cs_); @@ -415,23 +414,25 @@ void RtpStreamReceiver::OnCompleteFrame( complete_frame_callback_->OnCompleteFrame(std::move(frame)); } -void RtpStreamReceiver::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) { +void RtpVideoStreamReceiver::OnRttUpdate(int64_t avg_rtt_ms, + int64_t max_rtt_ms) { if (nack_module_) nack_module_->UpdateRtt(max_rtt_ms); } -rtc::Optional RtpStreamReceiver::LastReceivedPacketMs() const { +rtc::Optional RtpVideoStreamReceiver::LastReceivedPacketMs() const { return packet_buffer_->LastReceivedPacketMs(); } -rtc::Optional RtpStreamReceiver::LastReceivedKeyframePacketMs() const { +rtc::Optional RtpVideoStreamReceiver::LastReceivedKeyframePacketMs() + const { return packet_buffer_->LastReceivedKeyframePacketMs(); } -void RtpStreamReceiver::ReceivePacket(const uint8_t* packet, - size_t packet_length, - const RTPHeader& header, - bool in_order) { +void RtpVideoStreamReceiver::ReceivePacket(const uint8_t* packet, + size_t packet_length, + const RTPHeader& header, + bool in_order) { if (rtp_payload_registry_.IsEncapsulated(header)) { ParseAndHandleEncapsulatingHeader(packet, packet_length, header); return; @@ -448,7 +449,7 @@ void RtpStreamReceiver::ReceivePacket(const uint8_t* packet, payload_specific, in_order); } -void RtpStreamReceiver::ParseAndHandleEncapsulatingHeader( +void RtpVideoStreamReceiver::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(); @@ -493,7 +494,8 @@ void RtpStreamReceiver::ParseAndHandleEncapsulatingHeader( } } -void RtpStreamReceiver::NotifyReceiverOfFecPacket(const RTPHeader& header) { +void RtpVideoStreamReceiver::NotifyReceiverOfFecPacket( + const RTPHeader& header) { int8_t last_media_payload_type = rtp_payload_registry_.last_received_media_payload_type(); if (last_media_payload_type < 0) { @@ -525,8 +527,8 @@ void RtpStreamReceiver::NotifyReceiverOfFecPacket(const RTPHeader& header) { OnReceivedPayloadData(nullptr, 0, &rtp_header); } -bool RtpStreamReceiver::DeliverRtcp(const uint8_t* rtcp_packet, - size_t rtcp_packet_length) { +bool RtpVideoStreamReceiver::DeliverRtcp(const uint8_t* rtcp_packet, + size_t rtcp_packet_length) { { rtc::CritScope lock(&receive_cs_); if (!receiving_) { @@ -555,7 +557,7 @@ bool RtpStreamReceiver::DeliverRtcp(const uint8_t* rtcp_packet, return true; } -void RtpStreamReceiver::FrameContinuous(uint16_t picture_id) { +void RtpVideoStreamReceiver::FrameContinuous(uint16_t picture_id) { if (!nack_module_) return; @@ -570,7 +572,7 @@ void RtpStreamReceiver::FrameContinuous(uint16_t picture_id) { nack_module_->ClearUpTo(seq_num); } -void RtpStreamReceiver::FrameDecoded(uint16_t picture_id) { +void RtpVideoStreamReceiver::FrameDecoded(uint16_t picture_id) { int seq_num = -1; { rtc::CritScope lock(&last_seq_num_cs_); @@ -587,22 +589,22 @@ void RtpStreamReceiver::FrameDecoded(uint16_t picture_id) { } } -void RtpStreamReceiver::SignalNetworkState(NetworkState state) { +void RtpVideoStreamReceiver::SignalNetworkState(NetworkState state) { rtp_rtcp_->SetRTCPStatus(state == kNetworkUp ? config_.rtp.rtcp_mode : RtcpMode::kOff); } -void RtpStreamReceiver::StartReceive() { +void RtpVideoStreamReceiver::StartReceive() { rtc::CritScope lock(&receive_cs_); receiving_ = true; } -void RtpStreamReceiver::StopReceive() { +void RtpVideoStreamReceiver::StopReceive() { rtc::CritScope lock(&receive_cs_); receiving_ = false; } -bool RtpStreamReceiver::IsPacketInOrder(const RTPHeader& header) const { +bool RtpVideoStreamReceiver::IsPacketInOrder(const RTPHeader& header) const { StreamStatistician* statistician = rtp_receive_statistics_->GetStatistician(header.ssrc); if (!statistician) @@ -610,8 +612,8 @@ bool RtpStreamReceiver::IsPacketInOrder(const RTPHeader& header) const { return statistician->IsPacketInOrder(header.sequenceNumber); } -bool RtpStreamReceiver::IsPacketRetransmitted(const RTPHeader& header, - bool in_order) const { +bool RtpVideoStreamReceiver::IsPacketRetransmitted(const RTPHeader& header, + bool in_order) const { // Retransmissions are handled separately if RTX is enabled. if (rtp_payload_registry_.RtxEnabled()) return false; @@ -626,7 +628,7 @@ bool RtpStreamReceiver::IsPacketRetransmitted(const RTPHeader& header, statistician->IsRetransmitOfOldPacket(header, min_rtt); } -void RtpStreamReceiver::UpdateHistograms() { +void RtpVideoStreamReceiver::UpdateHistograms() { FecPacketCounter counter = ulpfec_receiver_->GetPacketCounter(); if (counter.first_packet_time_ms == -1) return; @@ -648,7 +650,7 @@ void RtpStreamReceiver::UpdateHistograms() { } } -void RtpStreamReceiver::EnableReceiveRtpHeaderExtension( +void RtpVideoStreamReceiver::EnableReceiveRtpHeaderExtension( const std::string& extension, int id) { // One-byte-extension local identifiers are in the range 1-14 inclusive. RTC_DCHECK_GE(id, 1); @@ -658,7 +660,7 @@ void RtpStreamReceiver::EnableReceiveRtpHeaderExtension( StringToRtpExtensionType(extension), id)); } -void RtpStreamReceiver::InsertSpsPpsIntoTracker(uint8_t payload_type) { +void RtpVideoStreamReceiver::InsertSpsPpsIntoTracker(uint8_t payload_type) { auto codec_params_it = pt_codec_params_.find(payload_type); if (codec_params_it == pt_codec_params_.end()) return; diff --git a/webrtc/video/rtp_stream_receiver.h b/webrtc/video/rtp_video_stream_receiver.h similarity index 91% rename from webrtc/video/rtp_stream_receiver.h rename to webrtc/video/rtp_video_stream_receiver.h index f6b36faeea..e298803c3f 100644 --- a/webrtc/video/rtp_stream_receiver.h +++ b/webrtc/video/rtp_video_stream_receiver.h @@ -8,8 +8,8 @@ * be found in the AUTHORS file in the root of the source tree. */ -#ifndef WEBRTC_VIDEO_RTP_STREAM_RECEIVER_H_ -#define WEBRTC_VIDEO_RTP_STREAM_RECEIVER_H_ +#ifndef WEBRTC_VIDEO_RTP_VIDEO_STREAM_RECEIVER_H_ +#define WEBRTC_VIDEO_RTP_VIDEO_STREAM_RECEIVER_H_ #include #include @@ -55,16 +55,16 @@ namespace vcm { class VideoReceiver; } // namespace vcm -class RtpStreamReceiver : public RtpData, - public RecoveredPacketReceiver, - public RtpFeedback, - public VCMFrameTypeCallback, - public VCMPacketRequestCallback, - public video_coding::OnReceivedFrameCallback, - public video_coding::OnCompleteFrameCallback, - public CallStatsObserver { +class RtpVideoStreamReceiver : public RtpData, + public RecoveredPacketReceiver, + public RtpFeedback, + public VCMFrameTypeCallback, + public VCMPacketRequestCallback, + public video_coding::OnReceivedFrameCallback, + public video_coding::OnCompleteFrameCallback, + public CallStatsObserver { public: - RtpStreamReceiver( + RtpVideoStreamReceiver( Transport* transport, RtcpRttStats* rtt_stats, PacketRouter* packet_router, @@ -75,7 +75,7 @@ class RtpStreamReceiver : public RtpData, KeyFrameRequestSender* keyframe_request_sender, video_coding::OnCompleteFrameCallback* complete_frame_callback, VCMTiming* timing); - ~RtpStreamReceiver(); + ~RtpVideoStreamReceiver(); bool AddReceiveCodec(const VideoCodec& video_codec, const std::map& codec_params); @@ -203,4 +203,4 @@ class RtpStreamReceiver : public RtpData, } // namespace webrtc -#endif // WEBRTC_VIDEO_RTP_STREAM_RECEIVER_H_ +#endif // WEBRTC_VIDEO_RTP_VIDEO_STREAM_RECEIVER_H_ diff --git a/webrtc/video/rtp_stream_receiver_unittest.cc b/webrtc/video/rtp_video_stream_receiver_unittest.cc similarity index 84% rename from webrtc/video/rtp_stream_receiver_unittest.cc rename to webrtc/video/rtp_video_stream_receiver_unittest.cc index 09ba501f1a..5f14089780 100644 --- a/webrtc/video/rtp_stream_receiver_unittest.cc +++ b/webrtc/video/rtp_video_stream_receiver_unittest.cc @@ -25,7 +25,7 @@ #include "webrtc/system_wrappers/include/clock.h" #include "webrtc/system_wrappers/include/field_trial_default.h" #include "webrtc/test/field_trial.h" -#include "webrtc/video/rtp_stream_receiver.h" +#include "webrtc/video/rtp_video_stream_receiver.h" using testing::_; @@ -95,15 +95,15 @@ class MockOnCompleteFrameCallback } // namespace -class RtpStreamReceiverTest : public testing::Test { +class RtpVideoStreamReceiverTest : public testing::Test { public: - RtpStreamReceiverTest() + RtpVideoStreamReceiverTest() : config_(CreateConfig()), timing_(Clock::GetRealTimeClock()), process_thread_(ProcessThread::Create("TestThread")) {} void SetUp() { - rtp_stream_receiver_.reset(new RtpStreamReceiver( + rtp_video_stream_receiver_.reset(new RtpVideoStreamReceiver( &mock_transport_, nullptr, &packet_router_, &config_, nullptr, process_thread_.get(), &mock_nack_sender_, &mock_key_frame_request_sender_, &mock_on_complete_frame_callback_, @@ -175,10 +175,10 @@ class RtpStreamReceiverTest : public testing::Test { PacketRouter packet_router_; VCMTiming timing_; std::unique_ptr process_thread_; - std::unique_ptr rtp_stream_receiver_; + std::unique_ptr rtp_video_stream_receiver_; }; -TEST_F(RtpStreamReceiverTest, GenericKeyFrame) { +TEST_F(RtpVideoStreamReceiverTest, GenericKeyFrame) { WebRtcRTPHeader rtp_header; const std::vector data({1, 2, 3, 4}); memset(&rtp_header, 0, sizeof(rtp_header)); @@ -190,11 +190,11 @@ TEST_F(RtpStreamReceiverTest, GenericKeyFrame) { mock_on_complete_frame_callback_.AppendExpectedBitstream(data.data(), data.size()); EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_)); - rtp_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(), - &rtp_header); + rtp_video_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(), + &rtp_header); } -TEST_F(RtpStreamReceiverTest, GenericKeyFrameBitstreamError) { +TEST_F(RtpVideoStreamReceiverTest, GenericKeyFrameBitstreamError) { WebRtcRTPHeader rtp_header; const std::vector data({1, 2, 3, 4}); memset(&rtp_header, 0, sizeof(rtp_header)); @@ -208,11 +208,11 @@ TEST_F(RtpStreamReceiverTest, GenericKeyFrameBitstreamError) { expected_bitsteam, sizeof(expected_bitsteam)); EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrameFailBitstream(_)); - rtp_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(), - &rtp_header); + rtp_video_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(), + &rtp_header); } -TEST_F(RtpStreamReceiverTest, InBandSpsPps) { +TEST_F(RtpVideoStreamReceiverTest, InBandSpsPps) { std::vector sps_data; WebRtcRTPHeader sps_packet = GetDefaultPacket(); AddSps(&sps_packet, 0, &sps_data); @@ -221,8 +221,8 @@ TEST_F(RtpStreamReceiverTest, InBandSpsPps) { kH264StartCode, sizeof(kH264StartCode)); mock_on_complete_frame_callback_.AppendExpectedBitstream(sps_data.data(), sps_data.size()); - rtp_stream_receiver_->OnReceivedPayloadData(sps_data.data(), sps_data.size(), - &sps_packet); + rtp_video_stream_receiver_->OnReceivedPayloadData( + sps_data.data(), sps_data.size(), &sps_packet); std::vector pps_data; WebRtcRTPHeader pps_packet = GetDefaultPacket(); @@ -232,8 +232,8 @@ TEST_F(RtpStreamReceiverTest, InBandSpsPps) { kH264StartCode, sizeof(kH264StartCode)); mock_on_complete_frame_callback_.AppendExpectedBitstream(pps_data.data(), pps_data.size()); - rtp_stream_receiver_->OnReceivedPayloadData(pps_data.data(), pps_data.size(), - &pps_packet); + rtp_video_stream_receiver_->OnReceivedPayloadData( + pps_data.data(), pps_data.size(), &pps_packet); std::vector idr_data; WebRtcRTPHeader idr_packet = GetDefaultPacket(); @@ -250,11 +250,11 @@ TEST_F(RtpStreamReceiverTest, InBandSpsPps) { mock_on_complete_frame_callback_.AppendExpectedBitstream(idr_data.data(), idr_data.size()); EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_)); - rtp_stream_receiver_->OnReceivedPayloadData(idr_data.data(), idr_data.size(), - &idr_packet); + rtp_video_stream_receiver_->OnReceivedPayloadData( + idr_data.data(), idr_data.size(), &idr_packet); } -TEST_F(RtpStreamReceiverTest, OutOfBandFmtpSpsPps) { +TEST_F(RtpVideoStreamReceiverTest, OutOfBandFmtpSpsPps) { constexpr int kPayloadType = 99; VideoCodec codec; codec.plType = kPayloadType; @@ -263,7 +263,7 @@ TEST_F(RtpStreamReceiverTest, OutOfBandFmtpSpsPps) { // . codec_params.insert( {cricket::kH264FmtpSpropParameterSets, "Z0IACpZTBYmI,aMljiA=="}); - rtp_stream_receiver_->AddReceiveCodec(codec, codec_params); + rtp_video_stream_receiver_->AddReceiveCodec(codec, codec_params); const uint8_t binary_sps[] = {0x67, 0x42, 0x00, 0x0a, 0x96, 0x53, 0x05, 0x89, 0x88}; mock_on_complete_frame_callback_.AppendExpectedBitstream( @@ -292,11 +292,11 @@ TEST_F(RtpStreamReceiverTest, OutOfBandFmtpSpsPps) { mock_on_complete_frame_callback_.AppendExpectedBitstream(data.data(), data.size()); EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_)); - rtp_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(), - &idr_packet); + rtp_video_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(), + &idr_packet); } -TEST_F(RtpStreamReceiverTest, PaddingInMediaStream) { +TEST_F(RtpVideoStreamReceiverTest, PaddingInMediaStream) { WebRtcRTPHeader header = GetDefaultPacket(); std::vector data; data.insert(data.end(), {1, 2, 3}); @@ -310,28 +310,28 @@ TEST_F(RtpStreamReceiverTest, PaddingInMediaStream) { data.size()); EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_)); - rtp_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(), - &header); + rtp_video_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(), + &header); header.header.sequenceNumber = 3; - rtp_stream_receiver_->OnReceivedPayloadData(nullptr, 0, &header); + rtp_video_stream_receiver_->OnReceivedPayloadData(nullptr, 0, &header); header.frameType = kVideoFrameDelta; header.header.sequenceNumber = 4; EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_)); - rtp_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(), - &header); + rtp_video_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(), + &header); header.header.sequenceNumber = 6; - rtp_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(), - &header); + rtp_video_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(), + &header); EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_)); header.header.sequenceNumber = 5; - rtp_stream_receiver_->OnReceivedPayloadData(nullptr, 0, &header); + rtp_video_stream_receiver_->OnReceivedPayloadData(nullptr, 0, &header); } -TEST_F(RtpStreamReceiverTest, RequestKeyframeIfFirstFrameIsDelta) { +TEST_F(RtpVideoStreamReceiverTest, RequestKeyframeIfFirstFrameIsDelta) { WebRtcRTPHeader rtp_header; const std::vector data({1, 2, 3, 4}); memset(&rtp_header, 0, sizeof(rtp_header)); @@ -342,8 +342,8 @@ TEST_F(RtpStreamReceiverTest, RequestKeyframeIfFirstFrameIsDelta) { rtp_header.type.Video.codec = kRtpVideoGeneric; EXPECT_CALL(mock_key_frame_request_sender_, RequestKeyFrame()); - rtp_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(), - &rtp_header); + rtp_video_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(), + &rtp_header); } } // namespace webrtc diff --git a/webrtc/video/video_receive_stream.cc b/webrtc/video/video_receive_stream.cc index 6e7ea13b2a..aa5c368310 100644 --- a/webrtc/video/video_receive_stream.cc +++ b/webrtc/video/video_receive_stream.cc @@ -184,16 +184,16 @@ VideoReceiveStream::VideoReceiveStream( timing_(new VCMTiming(clock_)), video_receiver_(clock_, nullptr, this, timing_.get(), this, this), stats_proxy_(&config_, clock_), - rtp_stream_receiver_(&transport_adapter_, - call_stats_->rtcp_rtt_stats(), - packet_router, - &config_, - &stats_proxy_, - process_thread_, - this, // NackSender - this, // KeyFrameRequestSender - this, // OnCompleteFrameCallback - timing_.get()), + rtp_video_stream_receiver_(&transport_adapter_, + call_stats_->rtcp_rtt_stats(), + packet_router, + &config_, + &stats_proxy_, + process_thread_, + this, // NackSender + this, // KeyFrameRequestSender + this, // OnCompleteFrameCallback + timing_.get()), rtp_stream_sync_(this) { LOG(LS_INFO) << "VideoReceiveStream: " << config_.ToString(); @@ -234,16 +234,16 @@ VideoReceiveStream::~VideoReceiveStream() { void VideoReceiveStream::SignalNetworkState(NetworkState state) { RTC_DCHECK_RUN_ON(&worker_thread_checker_); - rtp_stream_receiver_.SignalNetworkState(state); + rtp_video_stream_receiver_.SignalNetworkState(state); } bool VideoReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) { - return rtp_stream_receiver_.DeliverRtcp(packet, length); + return rtp_video_stream_receiver_.DeliverRtcp(packet, length); } void VideoReceiveStream::OnRtpPacket(const RtpPacketReceived& packet) { - rtp_stream_receiver_.OnRtpPacket(packet); + rtp_video_stream_receiver_.OnRtpPacket(packet); } void VideoReceiveStream::SetSync(Syncable* audio_syncable) { @@ -257,12 +257,13 @@ void VideoReceiveStream::Start() { return; bool protected_by_fec = config_.rtp.protected_by_flexfec || - rtp_stream_receiver_.IsUlpfecEnabled(); + rtp_video_stream_receiver_.IsUlpfecEnabled(); frame_buffer_->Start(); - call_stats_->RegisterStatsObserver(&rtp_stream_receiver_); + call_stats_->RegisterStatsObserver(&rtp_video_stream_receiver_); - if (rtp_stream_receiver_.IsRetransmissionsEnabled() && protected_by_fec) { + if (rtp_video_stream_receiver_.IsRetransmissionsEnabled() && + protected_by_fec) { frame_buffer_->SetProtectionMode(kProtectionNackFEC); } @@ -283,34 +284,35 @@ void VideoReceiveStream::Start() { video_receiver_.RegisterExternalDecoder(decoder.decoder, decoder.payload_type); VideoCodec codec = CreateDecoderVideoCodec(decoder); - RTC_CHECK( - rtp_stream_receiver_.AddReceiveCodec(codec, decoder.codec_params)); + RTC_CHECK(rtp_video_stream_receiver_.AddReceiveCodec(codec, + decoder.codec_params)); RTC_CHECK_EQ(VCM_OK, video_receiver_.RegisterReceiveCodec( &codec, num_cpu_cores_, false)); } video_stream_decoder_.reset(new VideoStreamDecoder( - &video_receiver_, &rtp_stream_receiver_, &rtp_stream_receiver_, - rtp_stream_receiver_.IsRetransmissionsEnabled(), protected_by_fec, + &video_receiver_, &rtp_video_stream_receiver_, + &rtp_video_stream_receiver_, + rtp_video_stream_receiver_.IsRetransmissionsEnabled(), protected_by_fec, &stats_proxy_, renderer)); // Register the channel to receive stats updates. call_stats_->RegisterStatsObserver(video_stream_decoder_.get()); // Start the decode thread decode_thread_.Start(); decode_thread_.SetPriority(rtc::kHighestPriority); - rtp_stream_receiver_.StartReceive(); + rtp_video_stream_receiver_.StartReceive(); } void VideoReceiveStream::Stop() { RTC_DCHECK_RUN_ON(&worker_thread_checker_); - rtp_stream_receiver_.StopReceive(); + rtp_video_stream_receiver_.StopReceive(); // TriggerDecoderShutdown will release any waiting decoder thread and make it // stop immediately, instead of waiting for a timeout. Needs to be called // before joining the decoder thread thread. video_receiver_.TriggerDecoderShutdown(); frame_buffer_->Stop(); - call_stats_->DeregisterStatsObserver(&rtp_stream_receiver_); + call_stats_->DeregisterStatsObserver(&rtp_video_stream_receiver_); if (decode_thread_.IsRunning()) { decode_thread_.Stop(); @@ -403,18 +405,18 @@ EncodedImageCallback::Result VideoReceiveStream::OnEncodedImage( void VideoReceiveStream::SendNack( const std::vector& sequence_numbers) { - rtp_stream_receiver_.RequestPacketRetransmit(sequence_numbers); + rtp_video_stream_receiver_.RequestPacketRetransmit(sequence_numbers); } void VideoReceiveStream::RequestKeyFrame() { - rtp_stream_receiver_.RequestKeyFrame(); + rtp_video_stream_receiver_.RequestKeyFrame(); } void VideoReceiveStream::OnCompleteFrame( std::unique_ptr frame) { int last_continuous_pid = frame_buffer_->InsertFrame(std::move(frame)); if (last_continuous_pid != -1) - rtp_stream_receiver_.FrameContinuous(last_continuous_pid); + rtp_video_stream_receiver_.FrameContinuous(last_continuous_pid); } int VideoReceiveStream::id() const { @@ -426,14 +428,14 @@ rtc::Optional VideoReceiveStream::GetInfo() const { RTC_DCHECK_RUN_ON(&module_process_thread_checker_); Syncable::Info info; - RtpReceiver* rtp_receiver = rtp_stream_receiver_.GetRtpReceiver(); + RtpReceiver* rtp_receiver = rtp_video_stream_receiver_.GetRtpReceiver(); RTC_DCHECK(rtp_receiver); if (!rtp_receiver->Timestamp(&info.latest_received_capture_timestamp)) return rtc::Optional(); if (!rtp_receiver->LastReceivedTimeMs(&info.latest_receive_time_ms)) return rtc::Optional(); - RtpRtcp* rtp_rtcp = rtp_stream_receiver_.rtp_rtcp(); + RtpRtcp* rtp_rtcp = rtp_video_stream_receiver_.rtp_rtcp(); RTC_DCHECK(rtp_rtcp); if (rtp_rtcp->RemoteNTP(&info.capture_time_ntp_secs, &info.capture_time_ntp_frac, @@ -475,13 +477,13 @@ bool VideoReceiveStream::Decode() { if (frame) { if (video_receiver_.Decode(frame.get()) == VCM_OK) - rtp_stream_receiver_.FrameDecoded(frame->picture_id); + rtp_video_stream_receiver_.FrameDecoded(frame->picture_id); } else { int64_t now_ms = clock_->TimeInMilliseconds(); rtc::Optional last_packet_ms = - rtp_stream_receiver_.LastReceivedPacketMs(); + rtp_video_stream_receiver_.LastReceivedPacketMs(); rtc::Optional last_keyframe_packet_ms = - rtp_stream_receiver_.LastReceivedKeyframePacketMs(); + rtp_video_stream_receiver_.LastReceivedKeyframePacketMs(); // To avoid spamming keyframe requests for a stream that is not active we // check if we have received a packet within the last 5 seconds. diff --git a/webrtc/video/video_receive_stream.h b/webrtc/video/video_receive_stream.h index 9cf7215f1b..22e476f450 100644 --- a/webrtc/video/video_receive_stream.h +++ b/webrtc/video/video_receive_stream.h @@ -24,8 +24,8 @@ #include "webrtc/modules/video_coding/video_coding_impl.h" #include "webrtc/system_wrappers/include/clock.h" #include "webrtc/video/receive_statistics_proxy.h" -#include "webrtc/video/rtp_stream_receiver.h" #include "webrtc/video/rtp_streams_synchronizer.h" +#include "webrtc/video/rtp_video_stream_receiver.h" #include "webrtc/video/transport_adapter.h" #include "webrtc/video/video_stream_decoder.h" #include "webrtc/video_receive_stream.h" @@ -127,7 +127,7 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream, vcm::VideoReceiver video_receiver_; std::unique_ptr> incoming_video_stream_; ReceiveStatisticsProxy stats_proxy_; - RtpStreamReceiver rtp_stream_receiver_; + RtpVideoStreamReceiver rtp_video_stream_receiver_; std::unique_ptr video_stream_decoder_; RtpStreamsSynchronizer rtp_stream_sync_;