From 68786d20400f1f3744ad83549325665c18ea9e5b Mon Sep 17 00:00:00 2001 From: stefan Date: Tue, 8 Sep 2015 05:36:15 -0700 Subject: [PATCH] Wire up PacketTime to ReceiveStreams. BUG=webrtc:4758 Review URL: https://codereview.webrtc.org/1333483002 Cr-Commit-Position: refs/heads/master@{#9892} --- talk/media/webrtc/fakewebrtccall.cc | 8 ++-- talk/media/webrtc/fakewebrtccall.h | 12 +++-- talk/media/webrtc/webrtcvideoengine2.cc | 24 ++++++---- talk/media/webrtc/webrtcvoiceengine.cc | 16 +++++-- webrtc/call.h | 4 +- webrtc/stream.h | 4 +- webrtc/test/fake_network_pipe.cc | 2 +- webrtc/test/fake_network_pipe_unittest.cc | 54 ++++++++++------------- webrtc/video/audio_receive_stream.cc | 6 ++- webrtc/video/audio_receive_stream.h | 4 +- webrtc/video/call.cc | 35 +++++++++------ webrtc/video/call_perf_tests.cc | 16 ++++--- webrtc/video/end_to_end_tests.cc | 27 +++++++----- webrtc/video/full_stack.cc | 8 ++-- webrtc/video/packet_injection_tests.cc | 2 +- webrtc/video/rampup_tests.cc | 5 ++- webrtc/video/rampup_tests.h | 6 ++- webrtc/video/replay.cc | 2 +- webrtc/video/video_receive_stream.cc | 6 ++- webrtc/video/video_receive_stream.h | 4 +- webrtc/video/video_send_stream_tests.cc | 6 ++- 21 files changed, 155 insertions(+), 96 deletions(-) diff --git a/talk/media/webrtc/fakewebrtccall.cc b/talk/media/webrtc/fakewebrtccall.cc index 742c970909..a85bdb10b4 100644 --- a/talk/media/webrtc/fakewebrtccall.cc +++ b/talk/media/webrtc/fakewebrtccall.cc @@ -314,9 +314,11 @@ webrtc::PacketReceiver* FakeCall::Receiver() { return this; } -FakeCall::DeliveryStatus FakeCall::DeliverPacket(webrtc::MediaType media_type, - const uint8_t* packet, - size_t length) { +FakeCall::DeliveryStatus FakeCall::DeliverPacket( + webrtc::MediaType media_type, + const uint8_t* packet, + size_t length, + const webrtc::PacketTime& packet_time) { EXPECT_GE(length, 12u); uint32_t ssrc; if (!GetRtpSsrc(packet, length, &ssrc)) diff --git a/talk/media/webrtc/fakewebrtccall.h b/talk/media/webrtc/fakewebrtccall.h index 5f217822ef..422848dda1 100644 --- a/talk/media/webrtc/fakewebrtccall.h +++ b/talk/media/webrtc/fakewebrtccall.h @@ -58,7 +58,9 @@ class FakeAudioReceiveStream : public webrtc::AudioReceiveStream { bool DeliverRtcp(const uint8_t* packet, size_t length) override { return true; } - bool DeliverRtp(const uint8_t* packet, size_t length) override { + bool DeliverRtp(const uint8_t* packet, + size_t length, + const webrtc::PacketTime& packet_time) override { return true; } @@ -136,7 +138,9 @@ class FakeVideoReceiveStream : public webrtc::VideoReceiveStream { bool DeliverRtcp(const uint8_t* packet, size_t length) override { return true; } - bool DeliverRtp(const uint8_t* packet, size_t length) override { + bool DeliverRtp(const uint8_t* packet, + size_t length, + const webrtc::PacketTime& packet_time) override { return true; } @@ -187,7 +191,9 @@ class FakeCall : public webrtc::Call, public webrtc::PacketReceiver { webrtc::PacketReceiver* Receiver() override; DeliveryStatus DeliverPacket(webrtc::MediaType media_type, - const uint8_t* packet, size_t length) override; + const uint8_t* packet, + size_t length, + const webrtc::PacketTime& packet_time) override; webrtc::Call::Stats GetStats() const override; diff --git a/talk/media/webrtc/webrtcvideoengine2.cc b/talk/media/webrtc/webrtcvideoengine2.cc index 923fee6525..7d4181740e 100644 --- a/talk/media/webrtc/webrtcvideoengine2.cc +++ b/talk/media/webrtc/webrtcvideoengine2.cc @@ -1451,9 +1451,13 @@ bool WebRtcVideoChannel2::RequestIntraFrame() { void WebRtcVideoChannel2::OnPacketReceived( rtc::Buffer* packet, const rtc::PacketTime& packet_time) { + const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp, + packet_time.not_before); const webrtc::PacketReceiver::DeliveryStatus delivery_result = - call_->Receiver()->DeliverPacket(webrtc::MediaType::VIDEO, - reinterpret_cast(packet->data()), packet->size()); + call_->Receiver()->DeliverPacket( + webrtc::MediaType::VIDEO, + reinterpret_cast(packet->data()), packet->size(), + webrtc_packet_time); switch (delivery_result) { case webrtc::PacketReceiver::DELIVERY_OK: return; @@ -1493,9 +1497,10 @@ void WebRtcVideoChannel2::OnPacketReceived( break; } - if (call_->Receiver()->DeliverPacket(webrtc::MediaType::VIDEO, - reinterpret_cast(packet->data()), packet->size()) != - webrtc::PacketReceiver::DELIVERY_OK) { + if (call_->Receiver()->DeliverPacket( + webrtc::MediaType::VIDEO, + reinterpret_cast(packet->data()), packet->size(), + webrtc_packet_time) != webrtc::PacketReceiver::DELIVERY_OK) { LOG(LS_WARNING) << "Failed to deliver RTP packet on re-delivery."; return; } @@ -1504,9 +1509,12 @@ void WebRtcVideoChannel2::OnPacketReceived( void WebRtcVideoChannel2::OnRtcpReceived( rtc::Buffer* packet, const rtc::PacketTime& packet_time) { - if (call_->Receiver()->DeliverPacket(webrtc::MediaType::VIDEO, - reinterpret_cast(packet->data()), packet->size()) != - webrtc::PacketReceiver::DELIVERY_OK) { + const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp, + packet_time.not_before); + if (call_->Receiver()->DeliverPacket( + webrtc::MediaType::VIDEO, + reinterpret_cast(packet->data()), packet->size(), + webrtc_packet_time) != webrtc::PacketReceiver::DELIVERY_OK) { LOG(LS_WARNING) << "Failed to deliver RTCP packet."; } } diff --git a/talk/media/webrtc/webrtcvoiceengine.cc b/talk/media/webrtc/webrtcvoiceengine.cc index 93f4b97b14..bcf1738c85 100644 --- a/talk/media/webrtc/webrtcvoiceengine.cc +++ b/talk/media/webrtc/webrtcvoiceengine.cc @@ -2949,8 +2949,12 @@ void WebRtcVoiceMediaChannel::OnPacketReceived( // If hooked up to a "Call", forward packet there too. if (call_) { - call_->Receiver()->DeliverPacket(webrtc::MediaType::AUDIO, - reinterpret_cast(packet->data()), packet->size()); + const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp, + packet_time.not_before); + call_->Receiver()->DeliverPacket( + webrtc::MediaType::AUDIO, + reinterpret_cast(packet->data()), packet->size(), + webrtc_packet_time); } // Pick which channel to send this packet to. If this packet doesn't match @@ -2990,8 +2994,12 @@ void WebRtcVoiceMediaChannel::OnRtcpReceived( // If hooked up to a "Call", forward packet there too. if (call_) { - call_->Receiver()->DeliverPacket(webrtc::MediaType::AUDIO, - reinterpret_cast(packet->data()), packet->size()); + const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp, + packet_time.not_before); + call_->Receiver()->DeliverPacket( + webrtc::MediaType::AUDIO, + reinterpret_cast(packet->data()), packet->size(), + webrtc_packet_time); } // Sending channels need all RTCP packets with feedback information. diff --git a/webrtc/call.h b/webrtc/call.h index 160a918cb2..e426cc5c4b 100644 --- a/webrtc/call.h +++ b/webrtc/call.h @@ -45,7 +45,9 @@ class PacketReceiver { virtual DeliveryStatus DeliverPacket(MediaType media_type, const uint8_t* packet, - size_t length) = 0; + size_t length, + const PacketTime& packet_time) = 0; + protected: virtual ~PacketReceiver() {} }; diff --git a/webrtc/stream.h b/webrtc/stream.h index fd30571726..5afab0f200 100644 --- a/webrtc/stream.h +++ b/webrtc/stream.h @@ -42,7 +42,9 @@ class Stream { class ReceiveStream : public Stream { public: // Called when a RTP packet is received. - virtual bool DeliverRtp(const uint8_t* packet, size_t length) = 0; + virtual bool DeliverRtp(const uint8_t* packet, + size_t length, + const PacketTime& packet_time) = 0; }; // Common base class for send streams. diff --git a/webrtc/test/fake_network_pipe.cc b/webrtc/test/fake_network_pipe.cc index 7a63fa8220..b3c9ee91ab 100644 --- a/webrtc/test/fake_network_pipe.cc +++ b/webrtc/test/fake_network_pipe.cc @@ -200,7 +200,7 @@ void FakeNetworkPipe::Process() { NetworkPacket* packet = packets_to_deliver.front(); packets_to_deliver.pop(); packet_receiver_->DeliverPacket(MediaType::ANY, packet->data(), - packet->data_length()); + packet->data_length(), PacketTime()); delete packet; } } diff --git a/webrtc/test/fake_network_pipe_unittest.cc b/webrtc/test/fake_network_pipe_unittest.cc index 65573438c5..a753fc5312 100644 --- a/webrtc/test/fake_network_pipe_unittest.cc +++ b/webrtc/test/fake_network_pipe_unittest.cc @@ -29,12 +29,13 @@ class MockReceiver : public PacketReceiver { virtual ~MockReceiver() {} void IncomingPacket(const uint8_t* data, size_t length) { - DeliverPacket(MediaType::ANY, data, length); + DeliverPacket(MediaType::ANY, data, length, PacketTime()); delete [] data; } - MOCK_METHOD3(DeliverPacket, - DeliveryStatus(MediaType, const uint8_t*, size_t)); + MOCK_METHOD4( + DeliverPacket, + DeliveryStatus(MediaType, const uint8_t*, size_t, const PacketTime&)); }; class FakeNetworkPipeTest : public ::testing::Test { @@ -42,7 +43,7 @@ class FakeNetworkPipeTest : public ::testing::Test { virtual void SetUp() { TickTime::UseFakeClock(12345); receiver_.reset(new MockReceiver()); - ON_CALL(*receiver_, DeliverPacket(_, _, _)) + ON_CALL(*receiver_, DeliverPacket(_, _, _, _)) .WillByDefault(Return(PacketReceiver::DELIVERY_OK)); } @@ -84,26 +85,22 @@ TEST_F(FakeNetworkPipeTest, CapacityTest) { kPacketSize); // Time haven't increased yet, so we souldn't get any packets. - EXPECT_CALL(*receiver_, DeliverPacket(_, _, _)) - .Times(0); + EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(0); pipe->Process(); // Advance enough time to release one packet. TickTime::AdvanceFakeClock(kPacketTimeMs); - EXPECT_CALL(*receiver_, DeliverPacket(_, _, _)) - .Times(1); + EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(1); pipe->Process(); // Release all but one packet TickTime::AdvanceFakeClock(9 * kPacketTimeMs - 1); - EXPECT_CALL(*receiver_, DeliverPacket(_, _, _)) - .Times(8); + EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(8); pipe->Process(); // And the last one. TickTime::AdvanceFakeClock(1); - EXPECT_CALL(*receiver_, DeliverPacket(_, _, _)) - .Times(1); + EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(1); pipe->Process(); } @@ -126,20 +123,17 @@ TEST_F(FakeNetworkPipeTest, ExtraDelayTest) { // Increase more than kPacketTimeMs, but not more than the extra delay. TickTime::AdvanceFakeClock(kPacketTimeMs); - EXPECT_CALL(*receiver_, DeliverPacket(_, _, _)) - .Times(0); + EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(0); pipe->Process(); // Advance the network delay to get the first packet. TickTime::AdvanceFakeClock(config.queue_delay_ms); - EXPECT_CALL(*receiver_, DeliverPacket(_, _, _)) - .Times(1); + EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(1); pipe->Process(); // Advance one more kPacketTimeMs to get the last packet. TickTime::AdvanceFakeClock(kPacketTimeMs); - EXPECT_CALL(*receiver_, DeliverPacket(_, _, _)) - .Times(1); + EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(1); pipe->Process(); } @@ -162,8 +156,7 @@ TEST_F(FakeNetworkPipeTest, QueueLengthTest) { // Increase time enough to deliver all three packets, verify only two are // delivered. TickTime::AdvanceFakeClock(3 * kPacketTimeMs); - EXPECT_CALL(*receiver_, DeliverPacket(_, _, _)) - .Times(2); + EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(2); pipe->Process(); } @@ -184,8 +177,7 @@ TEST_F(FakeNetworkPipeTest, StatisticsTest) { SendPackets(pipe.get(), 3, kPacketSize); TickTime::AdvanceFakeClock(3 * kPacketTimeMs + config.queue_delay_ms); - EXPECT_CALL(*receiver_, DeliverPacket(_, _, _)) - .Times(2); + EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(2); pipe->Process(); // Packet 1: kPacketTimeMs + config.queue_delay_ms, @@ -215,13 +207,13 @@ TEST_F(FakeNetworkPipeTest, ChangingCapacityWithEmptyPipeTest) { int packet_time_ms = PacketTimeMs(config.link_capacity_kbps, kPacketSize); // Time hasn't increased yet, so we souldn't get any packets. - EXPECT_CALL(*receiver_, DeliverPacket(_, _, _)).Times(0); + EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(0); pipe->Process(); // Advance time in steps to release one packet at a time. for (int i = 0; i < kNumPackets; ++i) { TickTime::AdvanceFakeClock(packet_time_ms); - EXPECT_CALL(*receiver_, DeliverPacket(_, _, _)).Times(1); + EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(1); pipe->Process(); } @@ -237,20 +229,20 @@ TEST_F(FakeNetworkPipeTest, ChangingCapacityWithEmptyPipeTest) { packet_time_ms = PacketTimeMs(config.link_capacity_kbps, kPacketSize); // Time hasn't increased yet, so we souldn't get any packets. - EXPECT_CALL(*receiver_, DeliverPacket(_, _, _)).Times(0); + EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(0); pipe->Process(); // Advance time in steps to release one packet at a time. for (int i = 0; i < kNumPackets; ++i) { TickTime::AdvanceFakeClock(packet_time_ms); - EXPECT_CALL(*receiver_, DeliverPacket(_, _, _)).Times(1); + EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(1); pipe->Process(); } // Check that all the packets were sent. EXPECT_EQ(static_cast(2 * kNumPackets), pipe->sent_packets()); TickTime::AdvanceFakeClock(pipe->TimeUntilNextProcess()); - EXPECT_CALL(*receiver_, DeliverPacket(_, _, _)).Times(0); + EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(0); pipe->Process(); } @@ -283,27 +275,27 @@ TEST_F(FakeNetworkPipeTest, ChangingCapacityWithPacketsInPipeTest) { int packet_time_2_ms = PacketTimeMs(config.link_capacity_kbps, kPacketSize); // Time hasn't increased yet, so we souldn't get any packets. - EXPECT_CALL(*receiver_, DeliverPacket(_, _, _)).Times(0); + EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(0); pipe->Process(); // Advance time in steps to release one packet at a time. for (int i = 0; i < kNumPackets; ++i) { TickTime::AdvanceFakeClock(packet_time_1_ms); - EXPECT_CALL(*receiver_, DeliverPacket(_, _, _)).Times(1); + EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(1); pipe->Process(); } // Advance time in steps to release one packet at a time. for (int i = 0; i < kNumPackets; ++i) { TickTime::AdvanceFakeClock(packet_time_2_ms); - EXPECT_CALL(*receiver_, DeliverPacket(_, _, _)).Times(1); + EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(1); pipe->Process(); } // Check that all the packets were sent. EXPECT_EQ(static_cast(2 * kNumPackets), pipe->sent_packets()); TickTime::AdvanceFakeClock(pipe->TimeUntilNextProcess()); - EXPECT_CALL(*receiver_, DeliverPacket(_, _, _)).Times(0); + EXPECT_CALL(*receiver_, DeliverPacket(_, _, _, _)).Times(0); pipe->Process(); } } // namespace webrtc diff --git a/webrtc/video/audio_receive_stream.cc b/webrtc/video/audio_receive_stream.cc index 6731ea40ae..9b400021db 100644 --- a/webrtc/video/audio_receive_stream.cc +++ b/webrtc/video/audio_receive_stream.cc @@ -87,7 +87,9 @@ bool AudioReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) { return false; } -bool AudioReceiveStream::DeliverRtp(const uint8_t* packet, size_t length) { +bool AudioReceiveStream::DeliverRtp(const uint8_t* packet, + size_t length, + const PacketTime& packet_time) { RTPHeader header; if (!rtp_header_parser_->Parse(packet, length, &header)) { @@ -99,6 +101,8 @@ bool AudioReceiveStream::DeliverRtp(const uint8_t* packet, size_t length) { if (config_.combined_audio_video_bwe && header.extension.hasAbsoluteSendTime) { int64_t arrival_time_ms = TickTime::MillisecondTimestamp(); + if (packet_time.timestamp >= 0) + arrival_time_ms = packet_time.timestamp; size_t payload_size = length - header.headerLength; remote_bitrate_estimator_->IncomingPacket(arrival_time_ms, payload_size, header, false); diff --git a/webrtc/video/audio_receive_stream.h b/webrtc/video/audio_receive_stream.h index 08d929adb3..c9ac04af39 100644 --- a/webrtc/video/audio_receive_stream.h +++ b/webrtc/video/audio_receive_stream.h @@ -31,7 +31,9 @@ class AudioReceiveStream : public webrtc::AudioReceiveStream { void Stop() override; void SignalNetworkState(NetworkState state) override; bool DeliverRtcp(const uint8_t* packet, size_t length) override; - bool DeliverRtp(const uint8_t* packet, size_t length) override; + bool DeliverRtp(const uint8_t* packet, + size_t length, + const PacketTime& packet_time) override; // webrtc::AudioReceiveStream implementation. webrtc::AudioReceiveStream::Stats GetStats() const override; diff --git a/webrtc/video/call.cc b/webrtc/video/call.cc index 6c58fc1877..f3a5db4735 100644 --- a/webrtc/video/call.cc +++ b/webrtc/video/call.cc @@ -69,8 +69,10 @@ class Call : public webrtc::Call, public PacketReceiver { Stats GetStats() const override; - DeliveryStatus DeliverPacket(MediaType media_type, const uint8_t* packet, - size_t length) override; + DeliveryStatus DeliverPacket(MediaType media_type, + const uint8_t* packet, + size_t length, + const PacketTime& packet_time) override; void SetBitrateConfig( const webrtc::Call::Config::BitrateConfig& bitrate_config) override; @@ -79,8 +81,10 @@ class Call : public webrtc::Call, public PacketReceiver { private: DeliveryStatus DeliverRtcp(MediaType media_type, const uint8_t* packet, size_t length); - DeliveryStatus DeliverRtp(MediaType media_type, const uint8_t* packet, - size_t length); + DeliveryStatus DeliverRtp(MediaType media_type, + const uint8_t* packet, + size_t length, + const PacketTime& packet_time); void SetBitrateControllerConfig( const webrtc::Call::Config::BitrateConfig& bitrate_config); @@ -475,7 +479,8 @@ PacketReceiver::DeliveryStatus Call::DeliverRtcp(MediaType media_type, PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type, const uint8_t* packet, - size_t length) { + size_t length, + const PacketTime& packet_time) { // Minimum RTP header size. if (length < 12) return DELIVERY_PACKET_ERROR; @@ -486,27 +491,31 @@ PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type, if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) { auto it = audio_receive_ssrcs_.find(ssrc); if (it != audio_receive_ssrcs_.end()) { - return it->second->DeliverRtp(packet, length) ? DELIVERY_OK - : DELIVERY_PACKET_ERROR; + return it->second->DeliverRtp(packet, length, packet_time) + ? DELIVERY_OK + : DELIVERY_PACKET_ERROR; } } if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) { auto it = video_receive_ssrcs_.find(ssrc); if (it != video_receive_ssrcs_.end()) { - return it->second->DeliverRtp(packet, length) ? DELIVERY_OK - : DELIVERY_PACKET_ERROR; + return it->second->DeliverRtp(packet, length, packet_time) + ? DELIVERY_OK + : DELIVERY_PACKET_ERROR; } } return DELIVERY_UNKNOWN_SSRC; } -PacketReceiver::DeliveryStatus Call::DeliverPacket(MediaType media_type, - const uint8_t* packet, - size_t length) { +PacketReceiver::DeliveryStatus Call::DeliverPacket( + MediaType media_type, + const uint8_t* packet, + size_t length, + const PacketTime& packet_time) { if (RtpHeaderParser::IsRtcp(packet, length)) return DeliverRtcp(media_type, packet, length); - return DeliverRtp(media_type, packet, length); + return DeliverRtp(media_type, packet, length, packet_time); } } // namespace internal diff --git a/webrtc/video/call_perf_tests.cc b/webrtc/video/call_perf_tests.cc index 592b68ebef..a301452c95 100644 --- a/webrtc/video/call_perf_tests.cc +++ b/webrtc/video/call_perf_tests.cc @@ -197,8 +197,10 @@ void CallPerfTest::TestAudioVideoSync(bool fec, bool create_audio_first) { : channel_(channel), voe_network_(voe_network), parser_(RtpHeaderParser::Create()) {} - DeliveryStatus DeliverPacket(MediaType media_type, const uint8_t* packet, - size_t length) override { + DeliveryStatus DeliverPacket(MediaType media_type, + const uint8_t* packet, + size_t length, + const PacketTime& packet_time) override { EXPECT_TRUE(media_type == MediaType::ANY || media_type == MediaType::AUDIO); int ret; @@ -540,8 +542,10 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) { test::RtpRtcpObserver::SetReceivers(this, receive_transport_receiver); } - DeliveryStatus DeliverPacket(MediaType media_type, const uint8_t* packet, - size_t length) override { + DeliveryStatus DeliverPacket(MediaType media_type, + const uint8_t* packet, + size_t length, + const PacketTime& packet_time) override { VideoSendStream::Stats stats = send_stream_->GetStats(); if (stats.substreams.size() > 0) { DCHECK_EQ(1u, stats.substreams.size()); @@ -575,8 +579,8 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) { observation_complete_->Set(); } } - return send_transport_receiver_->DeliverPacket(media_type, packet, - length); + return send_transport_receiver_->DeliverPacket(media_type, packet, length, + packet_time); } void OnStreamsCreated( diff --git a/webrtc/video/end_to_end_tests.cc b/webrtc/video/end_to_end_tests.cc index 9f62ec8add..a71c2e08be 100644 --- a/webrtc/video/end_to_end_tests.cc +++ b/webrtc/video/end_to_end_tests.cc @@ -993,13 +993,16 @@ TEST_F(EndToEndTest, UnknownRtpPacketGivesUnknownSsrcReturnCode) { } private: - DeliveryStatus DeliverPacket(MediaType media_type, const uint8_t* packet, - size_t length) override { + DeliveryStatus DeliverPacket(MediaType media_type, + const uint8_t* packet, + size_t length, + const PacketTime& packet_time) override { if (RtpHeaderParser::IsRtcp(packet, length)) { - return receiver_->DeliverPacket(media_type, packet, length); + return receiver_->DeliverPacket(media_type, packet, length, + packet_time); } else { DeliveryStatus delivery_status = - receiver_->DeliverPacket(media_type, packet, length); + receiver_->DeliverPacket(media_type, packet, length, packet_time); EXPECT_EQ(DELIVERY_UNKNOWN_SSRC, delivery_status); delivered_packet_->Set(); return delivery_status; @@ -1552,8 +1555,10 @@ TEST_F(EndToEndTest, VerifyBandwidthStats) { receiver_call_(nullptr), has_seen_pacer_delay_(false) {} - DeliveryStatus DeliverPacket(MediaType media_type, const uint8_t* packet, - size_t length) override { + DeliveryStatus DeliverPacket(MediaType media_type, + const uint8_t* packet, + size_t length, + const PacketTime& packet_time) override { Call::Stats sender_stats = sender_call_->GetStats(); Call::Stats receiver_stats = receiver_call_->GetStats(); if (!has_seen_pacer_delay_) @@ -1563,7 +1568,7 @@ TEST_F(EndToEndTest, VerifyBandwidthStats) { observation_complete_->Set(); } return receiver_call_->Receiver()->DeliverPacket(media_type, packet, - length); + length, packet_time); } void OnCallsCreated(Call* sender_call, Call* receiver_call) override { @@ -1719,15 +1724,17 @@ void EndToEndTest::VerifyHistogramStats(bool use_rtx, bool use_red) { return SEND_PACKET; } - DeliveryStatus DeliverPacket(MediaType media_type, const uint8_t* packet, - size_t length) override { + DeliveryStatus DeliverPacket(MediaType media_type, + const uint8_t* packet, + size_t length, + const PacketTime& packet_time) override { // GetStats calls GetSendChannelRtcpStatistics // (via VideoSendStream::GetRtt) which updates ReportBlockStats used by // WebRTC.Video.SentPacketsLostInPercent. // TODO(asapersson): Remove dependency on calling GetStats. sender_call_->GetStats(); return receiver_call_->Receiver()->DeliverPacket(media_type, packet, - length); + length, packet_time); } bool MinMetricRunTimePassed() { diff --git a/webrtc/video/full_stack.cc b/webrtc/video/full_stack.cc index 45c28ad623..1fee08779c 100644 --- a/webrtc/video/full_stack.cc +++ b/webrtc/video/full_stack.cc @@ -109,8 +109,10 @@ class VideoAnalyzer : public PacketReceiver, virtual void SetReceiver(PacketReceiver* receiver) { receiver_ = receiver; } - DeliveryStatus DeliverPacket(MediaType media_type, const uint8_t* packet, - size_t length) override { + DeliveryStatus DeliverPacket(MediaType media_type, + const uint8_t* packet, + size_t length, + const PacketTime& packet_time) override { rtc::scoped_ptr parser(RtpHeaderParser::Create()); RTPHeader header; parser->Parse(packet, length, &header); @@ -120,7 +122,7 @@ class VideoAnalyzer : public PacketReceiver, Clock::GetRealTimeClock()->CurrentNtpInMilliseconds(); } - return receiver_->DeliverPacket(media_type, packet, length); + return receiver_->DeliverPacket(media_type, packet, length, packet_time); } void IncomingCapturedFrame(const VideoFrame& video_frame) override { diff --git a/webrtc/video/packet_injection_tests.cc b/webrtc/video/packet_injection_tests.cc index 133935ca29..18ca0581d1 100644 --- a/webrtc/video/packet_injection_tests.cc +++ b/webrtc/video/packet_injection_tests.cc @@ -61,7 +61,7 @@ void PacketInjectionTest::InjectIncorrectPacket(CodecType codec_type, Start(); EXPECT_EQ(PacketReceiver::DELIVERY_PACKET_ERROR, receiver_call_->Receiver()->DeliverPacket(MediaType::VIDEO, packet, - length)); + length, PacketTime())); Stop(); DestroyStreams(); diff --git a/webrtc/video/rampup_tests.cc b/webrtc/video/rampup_tests.cc index 92b55bfdf7..fb533cb890 100644 --- a/webrtc/video/rampup_tests.cc +++ b/webrtc/video/rampup_tests.cc @@ -265,7 +265,10 @@ bool LowRateStreamObserver::SendRtp(const uint8_t* data, size_t length) { } PacketReceiver::DeliveryStatus LowRateStreamObserver::DeliverPacket( - MediaType media_type, const uint8_t* packet, size_t length) { + MediaType media_type, + const uint8_t* packet, + size_t length, + const PacketTime& packet_time) { rtc::CritScope lock(&crit_); RTPHeader header; EXPECT_TRUE(rtp_parser_->Parse(packet, length, &header)); diff --git a/webrtc/video/rampup_tests.h b/webrtc/video/rampup_tests.h index ae9e9d95db..56c5e75a6e 100644 --- a/webrtc/video/rampup_tests.h +++ b/webrtc/video/rampup_tests.h @@ -102,8 +102,10 @@ class LowRateStreamObserver : public test::DirectTransport, bool SendRtp(const uint8_t* data, size_t length) override; - DeliveryStatus DeliverPacket(MediaType media_type, const uint8_t* packet, - size_t length) override; + DeliveryStatus DeliverPacket(MediaType media_type, + const uint8_t* packet, + size_t length, + const PacketTime& packet_time) override; bool SendRtcp(const uint8_t* packet, size_t length) override; diff --git a/webrtc/video/replay.cc b/webrtc/video/replay.cc index 2a8a0a878e..6f0703bbd6 100644 --- a/webrtc/video/replay.cc +++ b/webrtc/video/replay.cc @@ -285,7 +285,7 @@ void RtpReplay() { break; ++num_packets; switch (call->Receiver()->DeliverPacket(webrtc::MediaType::ANY, packet.data, - packet.length)) { + packet.length, PacketTime())) { case PacketReceiver::DELIVERY_OK: break; case PacketReceiver::DELIVERY_UNKNOWN_SSRC: { diff --git a/webrtc/video/video_receive_stream.cc b/webrtc/video/video_receive_stream.cc index 5737ca98a2..9f0e26f78d 100644 --- a/webrtc/video/video_receive_stream.cc +++ b/webrtc/video/video_receive_stream.cc @@ -290,8 +290,10 @@ bool VideoReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) { return vie_channel_->ReceivedRTCPPacket(packet, length) == 0; } -bool VideoReceiveStream::DeliverRtp(const uint8_t* packet, size_t length) { - return vie_channel_->ReceivedRTPPacket(packet, length, PacketTime()) == 0; +bool VideoReceiveStream::DeliverRtp(const uint8_t* packet, + size_t length, + const PacketTime& packet_time) { + return vie_channel_->ReceivedRTPPacket(packet, length, packet_time) == 0; } void VideoReceiveStream::FrameCallback(VideoFrame* video_frame) { diff --git a/webrtc/video/video_receive_stream.h b/webrtc/video/video_receive_stream.h index 47a4d60626..15742383d0 100644 --- a/webrtc/video/video_receive_stream.h +++ b/webrtc/video/video_receive_stream.h @@ -49,7 +49,9 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream, void Stop() override; void SignalNetworkState(NetworkState state) override; bool DeliverRtcp(const uint8_t* packet, size_t length) override; - bool DeliverRtp(const uint8_t* packet, size_t length) override; + bool DeliverRtp(const uint8_t* packet, + size_t length, + const PacketTime& packet_time) override; // webrtc::VideoReceiveStream implementation. webrtc::VideoReceiveStream::Stats GetStats() const override; diff --git a/webrtc/video/video_send_stream_tests.cc b/webrtc/video/video_send_stream_tests.cc index 0890a10f47..c558099557 100644 --- a/webrtc/video/video_send_stream_tests.cc +++ b/webrtc/video/video_send_stream_tests.cc @@ -957,8 +957,10 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) { } private: - DeliveryStatus DeliverPacket(MediaType media_type, const uint8_t* packet, - size_t length) override { + DeliveryStatus DeliverPacket(MediaType media_type, + const uint8_t* packet, + size_t length, + const PacketTime& packet_time) override { EXPECT_TRUE(media_type == MediaType::ANY || media_type == MediaType::VIDEO); if (RtpHeaderParser::IsRtcp(packet, length))