mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-13 13:50:40 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Change vcm::VideoReceiver::IncomingPacket to not use WebRtcRTPHeader

Browse source 
Bug: webrtc:10397
Change-Id: Id549516faab1b1047ef52dd8229a73eeb48c5fe2
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/134162
Reviewed-by: Philip Eliasson <philipel@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#27761}
This commit is contained in:
Niels Möller 2019-04-25 10:02:52 +02:00 committed by Commit Bot
parent 8848229234
commit be7a0ec2e6
5 changed files with 86 additions and 55 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
modules/video_coding/include/video_coding.h
View file

@ -127,10 +127,17 @@ class VideoCodingModule : public Module {
// Input: // Input:
// - incomingPayload : Payload of the packet. // - incomingPayload : Payload of the packet.
// - payloadLength : Length of the payload. // - payloadLength : Length of the payload.
// - rtpInfo : The parsed header. // - rtp_header : The parsed RTP header.
// - video_header : The relevant extensions and payload header.
// //
// Return value : VCM_OK, on success. // Return value : VCM_OK, on success.
// < 0, on error. // < 0, on error.
virtual int32_t IncomingPacket(const uint8_t* incomingPayload,
size_t payloadLength,
const RTPHeader& rtp_header,
const RTPVideoHeader& video_header) = 0;
// DEPRECATED
virtual int32_t IncomingPacket(const uint8_t* incomingPayload, virtual int32_t IncomingPacket(const uint8_t* incomingPayload,
size_t payloadLength, size_t payloadLength,
const WebRtcRTPHeader& rtpInfo) = 0; const WebRtcRTPHeader& rtpInfo) = 0;

11
modules/video_coding/video_coding_impl.cc
View file

@ -93,7 +93,16 @@ class VideoCodingModuleImpl : public VideoCodingModule {
int32_t IncomingPacket(const uint8_t* incomingPayload, int32_t IncomingPacket(const uint8_t* incomingPayload,
size_t payloadLength, size_t payloadLength,
const WebRtcRTPHeader& rtpInfo) override { const WebRtcRTPHeader& rtpInfo) override {
return receiver_.IncomingPacket(incomingPayload, payloadLength, rtpInfo); return IncomingPacket(incomingPayload, payloadLength, rtpInfo.header,
rtpInfo.video_header());
}
int32_t IncomingPacket(const uint8_t* incomingPayload,
size_t payloadLength,
const RTPHeader& rtp_header,
const RTPVideoHeader& video_header) override {
return receiver_.IncomingPacket(incomingPayload, payloadLength, rtp_header,
video_header);
} }
int SetReceiverRobustnessMode(ReceiverRobustness robustnessMode) override { int SetReceiverRobustnessMode(ReceiverRobustness robustnessMode) override {

3
modules/video_coding/video_coding_impl.h
View file

@ -76,7 +76,8 @@ class VideoReceiver : public Module {
int32_t IncomingPacket(const uint8_t* incomingPayload, int32_t IncomingPacket(const uint8_t* incomingPayload,
size_t payloadLength, size_t payloadLength,
const WebRtcRTPHeader& rtpInfo); const RTPHeader& rtp_header,
const RTPVideoHeader& video_header);
void SetNackSettings(size_t max_nack_list_size, void SetNackSettings(size_t max_nack_list_size,
int max_packet_age_to_nack, int max_packet_age_to_nack,

12
modules/video_coding/video_receiver.cc
View file

@ -323,11 +323,12 @@ int32_t VideoReceiver::RegisterReceiveCodec(const VideoCodec* receiveCodec,
// Incoming packet from network parsed and ready for decode, non blocking. // Incoming packet from network parsed and ready for decode, non blocking.
int32_t VideoReceiver::IncomingPacket(const uint8_t* incomingPayload, int32_t VideoReceiver::IncomingPacket(const uint8_t* incomingPayload,
size_t payloadLength, size_t payloadLength,
const WebRtcRTPHeader& rtpInfo) { const RTPHeader& rtp_header,
const RTPVideoHeader& video_header) {
RTC_DCHECK_RUN_ON(&module_thread_checker_); RTC_DCHECK_RUN_ON(&module_thread_checker_);
if (rtpInfo.frameType == VideoFrameType::kVideoFrameKey) { if (video_header.frame_type == VideoFrameType::kVideoFrameKey) {
TRACE_EVENT1("webrtc", "VCM::PacketKeyFrame", "seqnum", TRACE_EVENT1("webrtc", "VCM::PacketKeyFrame", "seqnum",
rtpInfo.header.sequenceNumber); rtp_header.sequenceNumber);
} }
if (incomingPayload == nullptr) { if (incomingPayload == nullptr) {
// The jitter buffer doesn't handle non-zero payload lengths for packets // The jitter buffer doesn't handle non-zero payload lengths for packets
@ -335,8 +336,9 @@ int32_t VideoReceiver::IncomingPacket(const uint8_t* incomingPayload,
// TODO(holmer): We should fix this in the jitter buffer. // TODO(holmer): We should fix this in the jitter buffer.
payloadLength = 0; payloadLength = 0;
} }
const VCMPacket packet(incomingPayload, payloadLength, rtpInfo.header, // Callers don't provide any ntp time.
rtpInfo.video_header(), rtpInfo.ntp_time_ms); const VCMPacket packet(incomingPayload, payloadLength, rtp_header,
video_header, /*ntp_time_ms=*/0);
int32_t ret = _receiver.InsertPacket(packet); int32_t ret = _receiver.InsertPacket(packet);
// TODO(holmer): Investigate if this somehow should use the key frame // TODO(holmer): Investigate if this somehow should use the key frame

106
modules/video_coding/video_receiver_unittest.cc
View file

@ -55,23 +55,29 @@ class TestVideoReceiver : public ::testing::Test {
receiver_.RegisterReceiveCallback(&receive_callback_); receiver_.RegisterReceiveCallback(&receive_callback_);
} }
WebRtcRTPHeader GetDefaultVp8Header() const { RTPHeader GetDefaultRTPHeader() const {
WebRtcRTPHeader header = {}; RTPHeader header;
header.frameType = VideoFrameType::kEmptyFrame; header.markerBit = false;
header.header.markerBit = false; header.payloadType = kUnusedPayloadType;
header.header.payloadType = kUnusedPayloadType; header.ssrc = 1;
header.header.ssrc = 1; header.headerLength = 12;
header.header.headerLength = 12;
header.video_header().codec = kVideoCodecVP8;
return header; return header;
} }
RTPVideoHeader GetDefaultVp8Header() const {
RTPVideoHeader video_header = {};
video_header.frame_type = VideoFrameType::kEmptyFrame;
video_header.codec = kVideoCodecVP8;
return video_header;
}
void InsertAndVerifyPaddingFrame(const uint8_t* payload, void InsertAndVerifyPaddingFrame(const uint8_t* payload,
WebRtcRTPHeader* header) { RTPHeader* header,
const RTPVideoHeader& video_header) {
for (int j = 0; j < 5; ++j) { for (int j = 0; j < 5; ++j) {
// Padding only packets are passed to the VCM with payload size 0. // Padding only packets are passed to the VCM with payload size 0.
EXPECT_EQ(0, receiver_.IncomingPacket(payload, 0, *header)); EXPECT_EQ(0, receiver_.IncomingPacket(payload, 0, *header, video_header));
++header->header.sequenceNumber; ++header->sequenceNumber;
} }
receiver_.Process(); receiver_.Process();
EXPECT_CALL(decoder_, Decode(_, _, _)).Times(0); EXPECT_CALL(decoder_, Decode(_, _, _)).Times(0);
@ -80,9 +86,11 @@ class TestVideoReceiver : public ::testing::Test {
void InsertAndVerifyDecodableFrame(const uint8_t* payload, void InsertAndVerifyDecodableFrame(const uint8_t* payload,
size_t length, size_t length,
WebRtcRTPHeader* header) { RTPHeader* header,
EXPECT_EQ(0, receiver_.IncomingPacket(payload, length, *header)); const RTPVideoHeader& video_header) {
++header->header.sequenceNumber; EXPECT_EQ(0,
receiver_.IncomingPacket(payload, length, *header, video_header));
++header->sequenceNumber;
EXPECT_CALL(packet_request_callback_, ResendPackets(_, _)).Times(0); EXPECT_CALL(packet_request_callback_, ResendPackets(_, _)).Times(0);
receiver_.Process(); receiver_.Process();
@ -102,13 +110,14 @@ class TestVideoReceiver : public ::testing::Test {
TEST_F(TestVideoReceiver, PaddingOnlyFrames) { TEST_F(TestVideoReceiver, PaddingOnlyFrames) {
const size_t kPaddingSize = 220; const size_t kPaddingSize = 220;
const uint8_t kPayload[kPaddingSize] = {0}; const uint8_t kPayload[kPaddingSize] = {0};
WebRtcRTPHeader header = GetDefaultVp8Header(); RTPHeader header = GetDefaultRTPHeader();
header.header.paddingLength = kPaddingSize; RTPVideoHeader video_header = GetDefaultVp8Header();
header.paddingLength = kPaddingSize;
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
EXPECT_CALL(packet_request_callback_, ResendPackets(_, _)).Times(0); EXPECT_CALL(packet_request_callback_, ResendPackets(_, _)).Times(0);
InsertAndVerifyPaddingFrame(kPayload, &header); InsertAndVerifyPaddingFrame(kPayload, &header, video_header);
clock_.AdvanceTimeMilliseconds(33); clock_.AdvanceTimeMilliseconds(33);
header.header.timestamp += 3000; header.timestamp += 3000;
} }
} }
@ -116,30 +125,31 @@ TEST_F(TestVideoReceiver, PaddingOnlyFramesWithLosses) {
const size_t kFrameSize = 1200; const size_t kFrameSize = 1200;
const size_t kPaddingSize = 220; const size_t kPaddingSize = 220;
const uint8_t kPayload[kFrameSize] = {0}; const uint8_t kPayload[kFrameSize] = {0};
WebRtcRTPHeader header = GetDefaultVp8Header(); RTPHeader header = GetDefaultRTPHeader();
header.header.paddingLength = kPaddingSize; RTPVideoHeader video_header = GetDefaultVp8Header();
header.video_header().video_type_header.emplace<RTPVideoHeaderVP8>(); header.paddingLength = kPaddingSize;
video_header.video_type_header.emplace<RTPVideoHeaderVP8>();
// Insert one video frame to get one frame decoded. // Insert one video frame to get one frame decoded.
header.video_header().frame_type = VideoFrameType::kVideoFrameKey; video_header.frame_type = VideoFrameType::kVideoFrameKey;
header.video_header().is_first_packet_in_frame = true; video_header.is_first_packet_in_frame = true;
header.header.markerBit = true; header.markerBit = true;
InsertAndVerifyDecodableFrame(kPayload, kFrameSize, &header); InsertAndVerifyDecodableFrame(kPayload, kFrameSize, &header, video_header);
clock_.AdvanceTimeMilliseconds(33); clock_.AdvanceTimeMilliseconds(33);
header.header.timestamp += 3000; header.timestamp += 3000;
header.video_header().frame_type = VideoFrameType::kEmptyFrame; video_header.frame_type = VideoFrameType::kEmptyFrame;
header.video_header().is_first_packet_in_frame = false; video_header.is_first_packet_in_frame = false;
header.header.markerBit = false; header.markerBit = false;
// Insert padding frames. // Insert padding frames.
for (int i = 0; i < 10; ++i) { for (int i = 0; i < 10; ++i) {
// Lose one packet from the 6th frame. // Lose one packet from the 6th frame.
if (i == 5) { if (i == 5) {
++header.header.sequenceNumber; ++header.sequenceNumber;
} }
// Lose the 4th frame. // Lose the 4th frame.
if (i == 3) { if (i == 3) {
header.header.sequenceNumber += 5; header.sequenceNumber += 5;
} else { } else {
if (i > 3 && i < 5) { if (i > 3 && i < 5) {
EXPECT_CALL(packet_request_callback_, ResendPackets(_, 5)).Times(1); EXPECT_CALL(packet_request_callback_, ResendPackets(_, 5)).Times(1);
@ -148,10 +158,10 @@ TEST_F(TestVideoReceiver, PaddingOnlyFramesWithLosses) {
} else { } else {
EXPECT_CALL(packet_request_callback_, ResendPackets(_, _)).Times(0); EXPECT_CALL(packet_request_callback_, ResendPackets(_, _)).Times(0);
} }
InsertAndVerifyPaddingFrame(kPayload, &header); InsertAndVerifyPaddingFrame(kPayload, &header, video_header);
} }
clock_.AdvanceTimeMilliseconds(33); clock_.AdvanceTimeMilliseconds(33);
header.header.timestamp += 3000; header.timestamp += 3000;
} }
} }
@ -159,11 +169,12 @@ TEST_F(TestVideoReceiver, PaddingOnlyAndVideo) {
const size_t kFrameSize = 1200; const size_t kFrameSize = 1200;
const size_t kPaddingSize = 220; const size_t kPaddingSize = 220;
const uint8_t kPayload[kFrameSize] = {0}; const uint8_t kPayload[kFrameSize] = {0};
WebRtcRTPHeader header = GetDefaultVp8Header(); RTPHeader header = GetDefaultRTPHeader();
header.video_header().is_first_packet_in_frame = false; RTPVideoHeader video_header = GetDefaultVp8Header();
header.header.paddingLength = kPaddingSize; video_header.is_first_packet_in_frame = false;
header.paddingLength = kPaddingSize;
auto& vp8_header = auto& vp8_header =
header.video.video_type_header.emplace<RTPVideoHeaderVP8>(); video_header.video_type_header.emplace<RTPVideoHeaderVP8>();
vp8_header.pictureId = -1; vp8_header.pictureId = -1;
vp8_header.tl0PicIdx = -1; vp8_header.tl0PicIdx = -1;
@ -171,24 +182,25 @@ TEST_F(TestVideoReceiver, PaddingOnlyAndVideo) {
// Insert 2 video frames. // Insert 2 video frames.
for (int j = 0; j < 2; ++j) { for (int j = 0; j < 2; ++j) {
if (i == 0 && j == 0) // First frame should be a key frame. if (i == 0 && j == 0) // First frame should be a key frame.
header.video_header().frame_type = VideoFrameType::kVideoFrameKey; video_header.frame_type = VideoFrameType::kVideoFrameKey;
else else
header.video_header().frame_type = VideoFrameType::kVideoFrameDelta; video_header.frame_type = VideoFrameType::kVideoFrameDelta;
header.video_header().is_first_packet_in_frame = true; video_header.is_first_packet_in_frame = true;
header.header.markerBit = true; header.markerBit = true;
InsertAndVerifyDecodableFrame(kPayload, kFrameSize, &header); InsertAndVerifyDecodableFrame(kPayload, kFrameSize, &header,
video_header);
clock_.AdvanceTimeMilliseconds(33); clock_.AdvanceTimeMilliseconds(33);
header.header.timestamp += 3000; header.timestamp += 3000;
} }
// Insert 2 padding only frames. // Insert 2 padding only frames.
header.video_header().frame_type = VideoFrameType::kEmptyFrame; video_header.frame_type = VideoFrameType::kEmptyFrame;
header.video_header().is_first_packet_in_frame = false; video_header.is_first_packet_in_frame = false;
header.header.markerBit = false; header.markerBit = false;
for (int j = 0; j < 2; ++j) { for (int j = 0; j < 2; ++j) {
// InsertAndVerifyPaddingFrame(kPayload, &header); // InsertAndVerifyPaddingFrame(kPayload, &header);
clock_.AdvanceTimeMilliseconds(33); clock_.AdvanceTimeMilliseconds(33);
header.header.timestamp += 3000; header.timestamp += 3000;
} }
} }
} }