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/forward_error_correction.h" | |
23 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction_internal.h" | |
24 #include "webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer.h" | |
25 | |
26 namespace webrtc { | |
27 | |
28 namespace { | |
29 constexpr uint32_t kMediaSsrc = 1254983; | |
30 constexpr uint16_t kMediaStartSeqNum = 825; | |
31 constexpr size_t kMediaPacketLength = 1234; | |
32 | |
33 constexpr size_t kUlpfecHeaderSizeLBitClear = 14; | |
34 constexpr size_t kUlpfecHeaderSizeLBitSet = 18; | |
35 constexpr size_t kUlpfecPacketMaskOffset = 12; | |
36 } // namespace | |
37 | |
38 using Packet = ::webrtc::ForwardErrorCorrection::Packet; | |
danilchap
2016/09/01 16:28:48
Using is recommended to put at the top part of the
brandtr
2016/09/02 08:29:13
Done.
| |
39 using PacketList = ::webrtc::ForwardErrorCorrection::PacketList; | |
40 using ReceivedFecPacket = ::webrtc::ForwardErrorCorrection::ReceivedFecPacket; | |
41 | |
42 class UlpfecHeaderReaderWriterTest : public ::testing::Test { | |
43 protected: | |
44 UlpfecHeaderReaderWriterTest() : random_(0xabcdef123456) {} | |
45 | |
46 // Randomly generate packet mask of specified size. | |
47 void GeneratePacketMask(size_t packet_mask_size); | |
48 | |
49 std::unique_ptr<Packet> WriteHeader(size_t packet_mask_size); | |
50 std::unique_ptr<ReceivedFecPacket> ReadHeader(const Packet& packet_to_write); | |
51 | |
52 void VerifyHeaders(size_t expected_fec_header_size, | |
53 size_t expected_packet_mask_size, | |
54 const Packet& packet_to_write, | |
55 const ReceivedFecPacket& packet_to_read); | |
56 | |
57 UlpfecHeaderReader reader_; | |
58 UlpfecHeaderWriter writer_; | |
59 | |
60 Random random_; | |
61 uint8_t packet_mask_[kUlpfecMaxPacketMaskSize]; | |
62 }; | |
63 | |
64 void UlpfecHeaderReaderWriterTest::GeneratePacketMask(size_t packet_mask_size) { | |
65 RTC_DCHECK_LE(packet_mask_size, kUlpfecMaxPacketMaskSize); | |
66 memset(packet_mask_, 0u, sizeof(packet_mask_)); | |
67 for (size_t i = 0; i < packet_mask_size; ++i) { | |
68 packet_mask_[i] = random_.Rand<uint8_t>(); | |
69 } | |
70 } | |
71 | |
72 std::unique_ptr<Packet> UlpfecHeaderReaderWriterTest::WriteHeader( | |
73 size_t packet_mask_size) { | |
74 std::unique_ptr<Packet> packet_to_write(new Packet()); | |
75 packet_to_write->length = kMediaPacketLength; | |
76 for (size_t i = 0; i < packet_to_write->length; ++i) { | |
77 packet_to_write->data[i] = random_.Rand<uint8_t>(); | |
78 } | |
79 constexpr uint16_t kSeqNumBase = kMediaStartSeqNum; | |
80 writer_.FinalizeFecHeader(kSeqNumBase, packet_mask_, packet_mask_size, | |
81 packet_to_write.get()); | |
82 return packet_to_write; | |
83 } | |
84 | |
85 std::unique_ptr<ReceivedFecPacket> UlpfecHeaderReaderWriterTest::ReadHeader( | |
86 const Packet& packet_to_write) { | |
87 std::unique_ptr<ReceivedFecPacket> packet_to_read(new ReceivedFecPacket()); | |
88 packet_to_read->ssrc = kMediaSsrc; | |
89 packet_to_read->protected_ssrc = kMediaSsrc; | |
90 packet_to_read->pkt = rtc::scoped_refptr<Packet>(new Packet()); | |
91 memcpy(packet_to_read->pkt->data, packet_to_write.data, | |
92 packet_to_write.length); | |
93 packet_to_read->pkt->length = packet_to_write.length; | |
94 EXPECT_TRUE(reader_.ReadFecHeader(packet_to_read.get())); | |
95 return packet_to_read; | |
96 } | |
97 | |
98 void UlpfecHeaderReaderWriterTest::VerifyHeaders( | |
99 size_t expected_fec_header_size, | |
100 size_t expected_packet_mask_size, | |
101 const Packet& packet_to_write, | |
102 const ReceivedFecPacket& packet_to_read) { | |
103 EXPECT_EQ(kMediaSsrc, packet_to_read.ssrc); | |
104 EXPECT_EQ(expected_fec_header_size, packet_to_read.fec_header_size); | |
105 EXPECT_EQ(kMediaSsrc, packet_to_read.protected_ssrc); | |
106 EXPECT_EQ(kMediaStartSeqNum, packet_to_read.seq_num_base); | |
107 EXPECT_EQ(kUlpfecPacketMaskOffset, packet_to_read.packet_mask_offset); | |
108 ASSERT_EQ(expected_packet_mask_size, packet_to_read.packet_mask_size); | |
109 EXPECT_EQ(packet_to_write.length - expected_fec_header_size, | |
110 packet_to_read.protection_length); | |
111 EXPECT_EQ(0, | |
112 memcmp(packet_mask_, | |
113 &packet_to_read.pkt->data[packet_to_read.packet_mask_offset], | |
114 packet_to_read.packet_mask_size)); | |
115 // Verify that the call to ReadFecHeader did not tamper with the payload. | |
116 EXPECT_EQ(0, memcmp(&packet_to_write.data[expected_fec_header_size], | |
117 &packet_to_read.pkt->data[expected_fec_header_size], | |
118 packet_to_write.length - expected_fec_header_size)); | |
119 } | |
120 | |
121 TEST_F(UlpfecHeaderReaderWriterTest, CalculateSmallHeaderSize) { | |
122 GeneratePacketMask(kUlpfecPacketMaskSizeLBitClear); | |
123 EXPECT_EQ(kUlpfecHeaderSizeLBitClear, | |
124 writer_.FecHeaderSize(writer_.MinPacketMaskSize( | |
125 packet_mask_, kUlpfecPacketMaskSizeLBitClear))); | |
126 } | |
127 | |
128 TEST_F(UlpfecHeaderReaderWriterTest, CalculateLargeHeaderSize) { | |
129 GeneratePacketMask(kUlpfecPacketMaskSizeLBitSet); | |
130 EXPECT_EQ(kUlpfecHeaderSizeLBitSet, | |
131 writer_.FecHeaderSize(writer_.MinPacketMaskSize( | |
132 packet_mask_, kUlpfecPacketMaskSizeLBitSet))); | |
133 } | |
134 | |
135 TEST_F(UlpfecHeaderReaderWriterTest, WriteAndReadSmallHeader) { | |
136 GeneratePacketMask(kUlpfecPacketMaskSizeLBitClear); | |
137 auto packet_to_write = WriteHeader(kUlpfecPacketMaskSizeLBitClear); | |
138 auto packet_to_read = ReadHeader(*packet_to_write); | |
139 VerifyHeaders(kUlpfecHeaderSizeLBitClear, kUlpfecPacketMaskSizeLBitClear, | |
140 *packet_to_write, *packet_to_read); | |
141 } | |
142 | |
143 TEST_F(UlpfecHeaderReaderWriterTest, WriteAndReadLargeHeader) { | |
144 GeneratePacketMask(kUlpfecPacketMaskSizeLBitSet); | |
145 auto packet_to_write = WriteHeader(kUlpfecPacketMaskSizeLBitSet); | |
146 auto packet_to_read = ReadHeader(*packet_to_write); | |
147 VerifyHeaders(kUlpfecHeaderSizeLBitSet, kUlpfecPacketMaskSizeLBitSet, | |
148 *packet_to_write, *packet_to_read); | |
149 } | |
150 | |
151 } // namespace webrtc | |
OLD | NEW |