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 | |
30 using Packet = ::webrtc::ForwardErrorCorrection::Packet; | |
31 using PacketList = ::webrtc::ForwardErrorCorrection::PacketList; | |
danilchap
2016/09/02 09:54:55
using?
brandtr
2016/09/02 11:09:14
Nope. The compiler should complain about unused us
| |
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 | |
38 constexpr size_t kUlpfecHeaderSizeLBitClear = 14; | |
39 constexpr size_t kUlpfecHeaderSizeLBitSet = 18; | |
40 constexpr size_t kUlpfecPacketMaskOffset = 12; | |
41 | |
42 std::unique_ptr<uint8_t[]> GeneratePacketMask(size_t packet_mask_size, | |
43 uint64_t seed) { | |
44 Random random(seed); | |
45 std::unique_ptr<uint8_t[]> packet_mask(new uint8_t[kUlpfecMaxPacketMaskSize]); | |
danilchap
2016/09/02 09:54:55
Does it have to be MaxPacketMasksSize? may be pack
brandtr
2016/09/02 11:09:14
Here, that would be fine. But in the Flexfec unit
danilchap
2016/09/02 11:34:58
I would vote for asymmetry in this case: Since it
brandtr
2016/09/02 11:55:29
Done.
| |
46 memset(packet_mask.get(), 0, kUlpfecMaxPacketMaskSize); | |
47 for (size_t i = 0; i < packet_mask_size; ++i) { | |
48 packet_mask[i] = random.Rand<uint8_t>(); | |
49 } | |
50 return packet_mask; | |
51 } | |
52 | |
53 std::unique_ptr<Packet> WriteHeader(const uint8_t* packet_mask, | |
54 size_t packet_mask_size) { | |
55 UlpfecHeaderWriter writer; | |
56 std::unique_ptr<Packet> written_packet(new Packet()); | |
57 written_packet->length = kMediaPacketLength; | |
58 for (size_t i = 0; i < written_packet->length; ++i) { | |
59 written_packet->data[i] = i; // Actual content doesn't matter. | |
60 } | |
61 writer.FinalizeFecHeader(kMediaStartSeqNum, packet_mask, packet_mask_size, | |
62 written_packet.get()); | |
63 return written_packet; | |
64 } | |
65 | |
66 std::unique_ptr<ReceivedFecPacket> ReadHeader(const Packet& written_packet) { | |
67 UlpfecHeaderReader reader; | |
68 std::unique_ptr<ReceivedFecPacket> read_packet(new ReceivedFecPacket()); | |
69 read_packet->ssrc = kMediaSsrc; | |
70 read_packet->protected_ssrc = kMediaSsrc; | |
danilchap
2016/09/02 09:54:55
shouldn't ReadFecHeader set this?
brandtr
2016/09/02 11:09:14
Ehm, yeah. It should definitely not be here.
| |
71 read_packet->pkt = rtc::scoped_refptr<Packet>(new Packet()); | |
72 memcpy(read_packet->pkt->data, written_packet.data, written_packet.length); | |
73 read_packet->pkt->length = written_packet.length; | |
74 EXPECT_TRUE(reader.ReadFecHeader(read_packet.get())); | |
75 return read_packet; | |
76 } | |
77 | |
78 void VerifyHeaders(size_t expected_fec_header_size, | |
79 const uint8_t* expected_packet_mask, | |
80 size_t expected_packet_mask_size, | |
81 const Packet& written_packet, | |
82 const ReceivedFecPacket& read_packet) { | |
83 EXPECT_EQ(kMediaSsrc, read_packet.ssrc); | |
84 EXPECT_EQ(expected_fec_header_size, read_packet.fec_header_size); | |
85 EXPECT_EQ(kMediaSsrc, read_packet.protected_ssrc); | |
86 EXPECT_EQ(kMediaStartSeqNum, read_packet.seq_num_base); | |
87 EXPECT_EQ(kUlpfecPacketMaskOffset, read_packet.packet_mask_offset); | |
88 ASSERT_EQ(expected_packet_mask_size, read_packet.packet_mask_size); | |
89 EXPECT_EQ(written_packet.length - expected_fec_header_size, | |
90 read_packet.protection_length); | |
91 EXPECT_EQ(0, memcmp(expected_packet_mask, | |
92 &read_packet.pkt->data[read_packet.packet_mask_offset], | |
93 read_packet.packet_mask_size)); | |
94 // Verify that the call to ReadFecHeader did not tamper with the payload. | |
95 EXPECT_EQ(0, memcmp(&written_packet.data[expected_fec_header_size], | |
96 &read_packet.pkt->data[expected_fec_header_size], | |
97 written_packet.length - expected_fec_header_size)); | |
98 } | |
99 | |
100 } // namespace | |
101 | |
102 TEST(UlpfecHeaderReaderWriterTest, CalculateSmallHeaderSize) { | |
103 UlpfecHeaderWriter writer; | |
104 auto packet_mask = GeneratePacketMask(kUlpfecPacketMaskSizeLBitClear, 0xabcd); | |
105 EXPECT_EQ(kUlpfecHeaderSizeLBitClear, | |
106 writer.FecHeaderSize(writer.MinPacketMaskSize( | |
danilchap
2016/09/02 09:54:55
possible to test these two methods separately?
Or
brandtr
2016/09/02 11:09:14
Currently, the only public caller uses these metho
| |
107 packet_mask.get(), kUlpfecPacketMaskSizeLBitClear))); | |
108 } | |
109 | |
110 TEST(UlpfecHeaderReaderWriterTest, CalculateLargeHeaderSize) { | |
111 UlpfecHeaderWriter writer; | |
112 auto packet_mask = GeneratePacketMask(kUlpfecPacketMaskSizeLBitSet, 0xabcd); | |
113 EXPECT_EQ(kUlpfecHeaderSizeLBitSet, | |
114 writer.FecHeaderSize(writer.MinPacketMaskSize( | |
115 packet_mask.get(), kUlpfecPacketMaskSizeLBitSet))); | |
116 } | |
117 | |
118 TEST(UlpfecHeaderReaderWriterTest, WriteAndReadSmallHeader) { | |
119 auto packet_mask = GeneratePacketMask(kUlpfecPacketMaskSizeLBitClear, 0xabcd); | |
danilchap
2016/09/02 09:54:55
may be add size_t packet_mask_size = kUlpfecPacket
brandtr
2016/09/02 11:09:14
Done. I made it constexpr and named it accordingly
danilchap
2016/09/02 11:34:58
I think using non-constexpr variable packet_mask_s
brandtr
2016/09/02 11:55:29
Done.
| |
120 auto written_packet = | |
121 WriteHeader(packet_mask.get(), kUlpfecPacketMaskSizeLBitClear); | |
122 auto read_packet = ReadHeader(*written_packet); | |
123 VerifyHeaders(kUlpfecHeaderSizeLBitClear, packet_mask.get(), | |
124 kUlpfecPacketMaskSizeLBitClear, *written_packet, *read_packet); | |
125 } | |
126 | |
127 TEST(UlpfecHeaderReaderWriterTest, WriteAndReadLargeHeader) { | |
128 auto packet_mask = GeneratePacketMask(kUlpfecPacketMaskSizeLBitSet, 0xabcd); | |
129 auto written_packet = | |
130 WriteHeader(packet_mask.get(), kUlpfecPacketMaskSizeLBitSet); | |
131 auto read_packet = ReadHeader(*written_packet); | |
132 VerifyHeaders(kUlpfecHeaderSizeLBitSet, packet_mask.get(), | |
133 kUlpfecPacketMaskSizeLBitSet, *written_packet, *read_packet); | |
134 } | |
135 | |
136 } // namespace webrtc | |
OLD | NEW |