generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Fix single nalu packetization bug.

Browse Source 
Nalus which had the same size as the max payload size would cause the payload size accounting to wrap.

R=pbos@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/16269004

git-svn-id: http://webrtc.googlecode.com/svn/trunk@6846 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
stefan@webrtc.org 2014-08-07 15:02:16 +00:00
parent e8c84bf4de
commit 9d74f7ce8c
2 changed files with 52 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
webrtc/modules/rtp_rtcp/source/rtp_format_h264.cc
View File

@ -168,11 +168,11 @@ int RtpPacketizerH264::PacketizeStapA(size_t fragment_index,
false,
true,
header));
payload_size_left -= fragment_length;
// If we are going to try to aggregate more fragments into this packet
// we need to add the STAP-A NALU header.
if (aggregated_fragments == 0)
if (aggregated_fragments == 0 && payload_size_left > 0)
payload_size_left -= kNalHeaderSize;
payload_size_left -= fragment_length;
++aggregated_fragments;
}
// Next fragment.

52
webrtc/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc
View File

@ -140,6 +140,20 @@ void VerifyStapAPayload(const RTPFragmentationHeader& fragmentation,
::testing::ElementsAreArray(&packet[expected_payload_offset],
expected_payload_length));
}
void VerifySingleNaluPayload(const RTPFragmentationHeader& fragmentation,
size_t nalu_index,
const uint8_t* frame,
size_t frame_length,
const uint8_t* packet,
size_t packet_length) {
std::vector<uint8_t> expected_payload_vector(
&frame[fragmentation.fragmentationOffset[nalu_index]],
&frame[fragmentation.fragmentationOffset[nalu_index] +
fragmentation.fragmentationLength[nalu_index]]);
EXPECT_THAT(expected_payload_vector,
::testing::ElementsAreArray(packet, packet_length));
}
} // namespace
TEST(RtpPacketizerH264Test, TestSingleNalu) {
@ -157,8 +171,42 @@ TEST(RtpPacketizerH264Test, TestSingleNalu) {
ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
EXPECT_EQ(2u, length);
EXPECT_TRUE(last);
EXPECT_EQ(frame[0], packet[0]);
EXPECT_EQ(frame[1], packet[1]);
VerifySingleNaluPayload(
fragmentation, 0, frame, sizeof(frame), packet, length);
EXPECT_FALSE(packetizer->NextPacket(packet, &length, &last));
}
TEST(RtpPacketizerH264Test, TestSingleNaluTwoPackets) {
const size_t kFrameSize = kMaxPayloadSize + 100;
uint8_t frame[kFrameSize] = {0};
for (size_t i = 0; i < kFrameSize; ++i)
frame[i] = i;
RTPFragmentationHeader fragmentation;
fragmentation.VerifyAndAllocateFragmentationHeader(2);
fragmentation.fragmentationOffset[0] = 0;
fragmentation.fragmentationLength[0] = kMaxPayloadSize;
fragmentation.fragmentationOffset[1] = kMaxPayloadSize;
fragmentation.fragmentationLength[1] = 100;
// Set NAL headers.
frame[fragmentation.fragmentationOffset[0]] = 0x01;
frame[fragmentation.fragmentationOffset[1]] = 0x01;
scoped_ptr<RtpPacketizer> packetizer(
RtpPacketizer::Create(kRtpVideoH264, kMaxPayloadSize));
packetizer->SetPayloadData(frame, kFrameSize, &fragmentation);
uint8_t packet[kMaxPayloadSize] = {0};
size_t length = 0;
bool last = false;
ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
ASSERT_EQ(fragmentation.fragmentationOffset[1], length);
VerifySingleNaluPayload(fragmentation, 0, frame, kFrameSize, packet, length);
ASSERT_TRUE(packetizer->NextPacket(packet, &length, &last));
ASSERT_EQ(fragmentation.fragmentationLength[1], length);
VerifySingleNaluPayload(fragmentation, 1, frame, kFrameSize, packet, length);
EXPECT_TRUE(last);
EXPECT_FALSE(packetizer->NextPacket(packet, &length, &last));
}