OLD | NEW |
(Empty) | |
| 1 /* |
| 2 * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. |
| 3 * |
| 4 * Use of this source code is governed by a BSD-style license |
| 5 * that can be found in the LICENSE file in the root of the source |
| 6 * tree. An additional intellectual property rights grant can be found |
| 7 * in the file PATENTS. All contributing project authors may |
| 8 * be found in the AUTHORS file in the root of the source tree. |
| 9 */ |
| 10 |
| 11 #include <string.h> |
| 12 |
| 13 #include <memory> |
| 14 #include <utility> |
| 15 |
| 16 #include "testing/gtest/include/gtest/gtest.h" |
| 17 #include "webrtc/base/basictypes.h" |
| 18 #include "webrtc/base/checks.h" |
| 19 #include "webrtc/base/random.h" |
| 20 #include "webrtc/base/scoped_ref_ptr.h" |
| 21 #include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h" |
| 22 #include "webrtc/modules/rtp_rtcp/source/flexfec_header_reader_writer.h" |
| 23 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h" |
| 24 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction_internal.h" |
| 25 |
| 26 namespace webrtc { |
| 27 |
| 28 namespace { |
| 29 |
| 30 using Packet = ::webrtc::ForwardErrorCorrection::Packet; |
| 31 using PacketList = ::webrtc::ForwardErrorCorrection::PacketList; |
| 32 using ReceivedFecPacket = ::webrtc::ForwardErrorCorrection::ReceivedFecPacket; |
| 33 |
| 34 constexpr uint32_t kMediaSsrc = 1254983; |
| 35 constexpr uint16_t kMediaStartSeqNum = 825; |
| 36 constexpr size_t kMediaPacketLength = 1234; |
| 37 constexpr uint32_t kFlexfecSsrc = 52142; |
| 38 |
| 39 // Assume single-stream protection. |
| 40 constexpr size_t kFlexfecHeaderSize0KBitsSet = 20; |
| 41 constexpr size_t kFlexfecHeaderSize1KBitsSet = 24; |
| 42 constexpr size_t kFlexfecHeaderSize2KBitsSet = 32; |
| 43 constexpr size_t kFlexfecPacketMaskOffset = 18; |
| 44 constexpr size_t kFlexfecPacketMaskSize0KBitsSet = 2; |
| 45 constexpr size_t kFlexfecPacketMaskSize1KBitsSet = 6; |
| 46 constexpr size_t kFlexfecPacketMaskSize2KBitsSet = 14; |
| 47 constexpr size_t kFlexfecMaxPacketSize = kFlexfecPacketMaskSize2KBitsSet; |
| 48 |
| 49 std::unique_ptr<uint8_t[]> GeneratePacketMask(size_t packet_mask_size, |
| 50 uint64_t seed) { |
| 51 Random random(seed); |
| 52 std::unique_ptr<uint8_t[]> packet_mask(new uint8_t[kFlexfecMaxPacketSize]); |
| 53 memset(packet_mask.get(), 0, kFlexfecMaxPacketSize); |
| 54 for (size_t i = 0; i < packet_mask_size; ++i) { |
| 55 packet_mask[i] = random.Rand<uint8_t>(); |
| 56 } |
| 57 return packet_mask; |
| 58 } |
| 59 |
| 60 void ClearBit(size_t index, uint8_t* packet_mask) { |
| 61 packet_mask[index / 8] &= ~(1 << (7 - index % 8)); |
| 62 } |
| 63 |
| 64 void SetBit(size_t index, uint8_t* packet_mask) { |
| 65 packet_mask[index / 8] |= (1 << (7 - index % 8)); |
| 66 } |
| 67 |
| 68 std::unique_ptr<Packet> WriteHeader(const uint8_t* packet_mask, |
| 69 size_t packet_mask_size) { |
| 70 FlexfecHeaderWriter writer; |
| 71 std::unique_ptr<Packet> written_packet(new Packet()); |
| 72 written_packet->length = kMediaPacketLength; |
| 73 for (size_t i = 0; i < written_packet->length; ++i) { |
| 74 written_packet->data[i] = i; // Actual content doesn't matter. |
| 75 } |
| 76 writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, packet_mask, |
| 77 packet_mask_size, written_packet.get()); |
| 78 return written_packet; |
| 79 } |
| 80 |
| 81 std::unique_ptr<ReceivedFecPacket> ReadHeader(const Packet& written_packet) { |
| 82 FlexfecHeaderReader reader; |
| 83 std::unique_ptr<ReceivedFecPacket> read_packet(new ReceivedFecPacket()); |
| 84 read_packet->ssrc = kFlexfecSsrc; |
| 85 read_packet->protected_ssrc = kMediaSsrc; |
| 86 read_packet->pkt = rtc::scoped_refptr<Packet>(new Packet()); |
| 87 memcpy(read_packet->pkt->data, written_packet.data, written_packet.length); |
| 88 read_packet->pkt->length = written_packet.length; |
| 89 EXPECT_TRUE(reader.ReadFecHeader(read_packet.get())); |
| 90 return read_packet; |
| 91 } |
| 92 |
| 93 void VerifyHeaders(size_t expected_fec_header_size, |
| 94 const uint8_t* expected_packet_mask, |
| 95 size_t expected_packet_mask_size, |
| 96 const Packet& written_packet, |
| 97 const ReceivedFecPacket& read_packet) { |
| 98 EXPECT_EQ(kFlexfecSsrc, read_packet.ssrc); |
| 99 EXPECT_EQ(expected_fec_header_size, read_packet.fec_header_size); |
| 100 EXPECT_EQ(kMediaSsrc, read_packet.protected_ssrc); |
| 101 EXPECT_EQ(kMediaStartSeqNum, read_packet.seq_num_base); |
| 102 EXPECT_EQ(kFlexfecPacketMaskOffset, read_packet.packet_mask_offset); |
| 103 ASSERT_EQ(expected_packet_mask_size, read_packet.packet_mask_size); |
| 104 EXPECT_EQ(written_packet.length - expected_fec_header_size, |
| 105 read_packet.protection_length); |
| 106 // Verify that the call to ReadFecHeader did normalize the packet masks. |
| 107 EXPECT_EQ(0, memcmp(expected_packet_mask, |
| 108 &read_packet.pkt->data[read_packet.packet_mask_offset], |
| 109 read_packet.packet_mask_size)); |
| 110 // Verify that the call to ReadFecHeader did not tamper with the payload. |
| 111 EXPECT_EQ(0, memcmp(&written_packet.data[expected_fec_header_size], |
| 112 &read_packet.pkt->data[expected_fec_header_size], |
| 113 written_packet.length - expected_fec_header_size)); |
| 114 } |
| 115 |
| 116 } // namespace |
| 117 |
| 118 TEST(FlexfecHeaderReaderWriterTest, |
| 119 ContractsShortUlpfecPacketMaskWithBit15Clear) { |
| 120 FlexfecHeaderWriter writer; |
| 121 auto packet_mask = GeneratePacketMask(kUlpfecPacketMaskSizeLBitClear, 0xabcd); |
| 122 ClearBit(15, packet_mask.get()); |
| 123 EXPECT_EQ(kFlexfecHeaderSize0KBitsSet, |
| 124 writer.FecHeaderSize(writer.MinPacketMaskSize( |
| 125 packet_mask.get(), kUlpfecPacketMaskSizeLBitClear))); |
| 126 } |
| 127 |
| 128 TEST(FlexfecHeaderReaderWriterTest, ExpandsShortUlpfecPacketMaskWithBit15Set) { |
| 129 FlexfecHeaderWriter writer; |
| 130 auto packet_mask = GeneratePacketMask(kUlpfecPacketMaskSizeLBitClear, 0xabcd); |
| 131 SetBit(15, packet_mask.get()); |
| 132 EXPECT_EQ(kFlexfecHeaderSize1KBitsSet, |
| 133 writer.FecHeaderSize(writer.MinPacketMaskSize( |
| 134 packet_mask.get(), kUlpfecPacketMaskSizeLBitClear))); |
| 135 } |
| 136 |
| 137 TEST(FlexfecHeaderReaderWriterTest, |
| 138 ContractsLongUlpfecPacketMaskWithBits46And47Clear) { |
| 139 FlexfecHeaderWriter writer; |
| 140 auto packet_mask = GeneratePacketMask(kUlpfecPacketMaskSizeLBitSet, 0xabcd); |
| 141 ClearBit(46, packet_mask.get()); |
| 142 ClearBit(47, packet_mask.get()); |
| 143 EXPECT_EQ(kFlexfecHeaderSize1KBitsSet, |
| 144 writer.FecHeaderSize(writer.MinPacketMaskSize( |
| 145 packet_mask.get(), kUlpfecPacketMaskSizeLBitSet))); |
| 146 } |
| 147 |
| 148 TEST(FlexfecHeaderReaderWriterTest, |
| 149 ExpandsLongUlpfecPacketMaskWithBits46And47Clear) { |
| 150 FlexfecHeaderWriter writer; |
| 151 auto packet_mask = GeneratePacketMask(kUlpfecPacketMaskSizeLBitSet, 0xabcd); |
| 152 SetBit(46, packet_mask.get()); |
| 153 ClearBit(47, packet_mask.get()); |
| 154 EXPECT_EQ(kFlexfecHeaderSize2KBitsSet, |
| 155 writer.FecHeaderSize(writer.MinPacketMaskSize( |
| 156 packet_mask.get(), kUlpfecPacketMaskSizeLBitSet))); |
| 157 } |
| 158 |
| 159 TEST(FlexfecHeaderReaderWriterTest, |
| 160 ExpandsLongUlpfecPacketMaskWithBit46ClearBit47Set) { |
| 161 FlexfecHeaderWriter writer; |
| 162 auto packet_mask = GeneratePacketMask(kUlpfecPacketMaskSizeLBitSet, 0xabcd); |
| 163 ClearBit(46, packet_mask.get()); |
| 164 SetBit(47, packet_mask.get()); |
| 165 EXPECT_EQ(kFlexfecHeaderSize2KBitsSet, |
| 166 writer.FecHeaderSize(writer.MinPacketMaskSize( |
| 167 packet_mask.get(), kUlpfecPacketMaskSizeLBitSet))); |
| 168 } |
| 169 |
| 170 TEST(FlexfecHeaderReaderWriterTest, |
| 171 ExpandsLongUlpfecPacketMaskWithBits46And47Set) { |
| 172 FlexfecHeaderWriter writer; |
| 173 auto packet_mask = GeneratePacketMask(kUlpfecPacketMaskSizeLBitSet, 0xabcd); |
| 174 SetBit(46, packet_mask.get()); |
| 175 SetBit(47, packet_mask.get()); |
| 176 EXPECT_EQ(kFlexfecHeaderSize2KBitsSet, |
| 177 writer.FecHeaderSize(writer.MinPacketMaskSize( |
| 178 packet_mask.get(), kUlpfecPacketMaskSizeLBitSet))); |
| 179 } |
| 180 |
| 181 TEST(FlexfecHeaderReaderWriterTest, |
| 182 WriteAndReadSmallUlpfecPacketHeaderWithMaskBit15Clear) { |
| 183 auto packet_mask = GeneratePacketMask(kUlpfecPacketMaskSizeLBitClear, 0xabcd); |
| 184 ClearBit(15, packet_mask.get()); |
| 185 auto written_packet = |
| 186 WriteHeader(packet_mask.get(), kUlpfecPacketMaskSizeLBitClear); |
| 187 auto read_packet = ReadHeader(*written_packet); |
| 188 VerifyHeaders(kFlexfecHeaderSize0KBitsSet, packet_mask.get(), |
| 189 kFlexfecPacketMaskSize0KBitsSet, *written_packet, *read_packet); |
| 190 } |
| 191 |
| 192 TEST(FlexfecHeaderReaderWriterTest, |
| 193 WriteAndReadSmallUlpfecPacketHeaderWithMaskBit15Set) { |
| 194 auto packet_mask = GeneratePacketMask(kUlpfecPacketMaskSizeLBitClear, 0xabcd); |
| 195 SetBit(15, packet_mask.get()); |
| 196 auto written_packet = |
| 197 WriteHeader(packet_mask.get(), kUlpfecPacketMaskSizeLBitClear); |
| 198 auto read_packet = ReadHeader(*written_packet); |
| 199 VerifyHeaders(kFlexfecHeaderSize1KBitsSet, packet_mask.get(), |
| 200 kFlexfecPacketMaskSize1KBitsSet, *written_packet, *read_packet); |
| 201 } |
| 202 |
| 203 TEST(FlexfecHeaderReaderWriterTest, |
| 204 WriteAndReadLargeUlpfecPacketHeaderWithMaskBits46And47Clear) { |
| 205 auto packet_mask = GeneratePacketMask(kUlpfecPacketMaskSizeLBitSet, 0xabcd); |
| 206 ClearBit(46, packet_mask.get()); |
| 207 ClearBit(47, packet_mask.get()); |
| 208 auto written_packet = |
| 209 WriteHeader(packet_mask.get(), kUlpfecPacketMaskSizeLBitSet); |
| 210 auto read_packet = ReadHeader(*written_packet); |
| 211 VerifyHeaders(kFlexfecHeaderSize1KBitsSet, packet_mask.get(), |
| 212 kFlexfecPacketMaskSize1KBitsSet, *written_packet, *read_packet); |
| 213 } |
| 214 |
| 215 TEST(FlexfecHeaderReaderWriterTest, |
| 216 WriteAndReadLargeUlpfecPacketHeaderWithMaskBit46SetBit47Clear) { |
| 217 auto packet_mask = GeneratePacketMask(kUlpfecPacketMaskSizeLBitSet, 0xabcd); |
| 218 SetBit(46, packet_mask.get()); |
| 219 ClearBit(47, packet_mask.get()); |
| 220 auto written_packet = |
| 221 WriteHeader(packet_mask.get(), kUlpfecPacketMaskSizeLBitSet); |
| 222 auto read_packet = ReadHeader(*written_packet); |
| 223 VerifyHeaders(kFlexfecHeaderSize2KBitsSet, packet_mask.get(), |
| 224 kFlexfecPacketMaskSize2KBitsSet, *written_packet, *read_packet); |
| 225 } |
| 226 |
| 227 TEST(FlexfecHeaderReaderWriterTest, |
| 228 WriteAndReadLargeUlpfecPacketHeaderMaskWithBit46ClearBit47Set) { |
| 229 auto packet_mask = GeneratePacketMask(kUlpfecPacketMaskSizeLBitSet, 0xabcd); |
| 230 ClearBit(46, packet_mask.get()); |
| 231 SetBit(47, packet_mask.get()); |
| 232 auto written_packet = |
| 233 WriteHeader(packet_mask.get(), kUlpfecPacketMaskSizeLBitSet); |
| 234 auto read_packet = ReadHeader(*written_packet); |
| 235 VerifyHeaders(kFlexfecHeaderSize2KBitsSet, packet_mask.get(), |
| 236 kFlexfecPacketMaskSize2KBitsSet, *written_packet, *read_packet); |
| 237 } |
| 238 |
| 239 TEST(FlexfecHeaderReaderWriterTest, |
| 240 WriteAndReadLargeUlpfecPacketHeaderWithMaskBits46And47Set) { |
| 241 auto packet_mask = GeneratePacketMask(kUlpfecPacketMaskSizeLBitSet, 0xabcd); |
| 242 SetBit(46, packet_mask.get()); |
| 243 SetBit(47, packet_mask.get()); |
| 244 auto written_packet = |
| 245 WriteHeader(packet_mask.get(), kUlpfecPacketMaskSizeLBitSet); |
| 246 auto read_packet = ReadHeader(*written_packet); |
| 247 VerifyHeaders(kFlexfecHeaderSize2KBitsSet, packet_mask.get(), |
| 248 kFlexfecPacketMaskSize2KBitsSet, *written_packet, *read_packet); |
| 249 } |
| 250 |
| 251 } // namespace webrtc |
OLD | NEW |