admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Wire up PacketTime to ReceiveStreams.

Browse Source 
BUG=webrtc:4758

Review URL: https://codereview.webrtc.org/1333483002

Cr-Commit-Position: refs/heads/master@{#9892}
This commit is contained in:
stefan 2015-09-08 05:36:15 -07:00 committed by Commit bot
parent e526974759
commit 68786d2040
21 changed files with 155 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
talk/media/webrtc/fakewebrtccall.cc
View File

@ -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))

12
talk/media/webrtc/fakewebrtccall.h
View File

@ -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;

24
talk/media/webrtc/webrtcvideoengine2.cc
View File

@ -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<const uint8_t*>(packet->data()), packet->size());
call_->Receiver()->DeliverPacket(
webrtc::MediaType::VIDEO,
reinterpret_cast<const uint8_t*>(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<const uint8_t*>(packet->data()), packet->size()) !=
webrtc::PacketReceiver::DELIVERY_OK) {
if (call_->Receiver()->DeliverPacket(
webrtc::MediaType::VIDEO,
reinterpret_cast<const uint8_t*>(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<const uint8_t*>(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<const uint8_t*>(packet->data()), packet->size(),
webrtc_packet_time) != webrtc::PacketReceiver::DELIVERY_OK) {
LOG(LS_WARNING) << "Failed to deliver RTCP packet.";
}
}

16
talk/media/webrtc/webrtcvoiceengine.cc
View File

@ -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<const uint8_t*>(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<const uint8_t*>(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<const uint8_t*>(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<const uint8_t*>(packet->data()), packet->size(),
webrtc_packet_time);
}
// Sending channels need all RTCP packets with feedback information.

4
webrtc/call.h
View File

@ -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() {}
};

4
webrtc/stream.h
View File

@ -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.

2
webrtc/test/fake_network_pipe.cc
View File

@ -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;
}
}

54
webrtc/test/fake_network_pipe_unittest.cc
View File

@ -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<size_t>(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<size_t>(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

6
webrtc/video/audio_receive_stream.cc
View File

@ -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);

4
webrtc/video/audio_receive_stream.h
View File

@ -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;

35
webrtc/video/call.cc
View File

@ -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

16
webrtc/video/call_perf_tests.cc
View File

@ -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(

27
webrtc/video/end_to_end_tests.cc
View File

@ -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() {

8
webrtc/video/full_stack.cc
View File

@ -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<RtpHeaderParser> 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 {

2
webrtc/video/packet_injection_tests.cc
View File

@ -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();

5
webrtc/video/rampup_tests.cc
View File

@ -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));

6
webrtc/video/rampup_tests.h
View File

@ -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;

2
webrtc/video/replay.cc
View File

@ -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: {

6
webrtc/video/video_receive_stream.cc
View File

@ -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) {

4
webrtc/video/video_receive_stream.h
View File

@ -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;

6
webrtc/video/video_send_stream_tests.cc
View File

@ -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))