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 "webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi.h" | |
12 | |
13 #include "webrtc/test/gmock.h" | |
14 #include "webrtc/test/gtest.h" | |
15 #include "webrtc/test/rtcp_packet_parser.h" | |
16 | |
17 using testing::ElementsAreArray; | |
18 using testing::make_tuple; | |
19 using webrtc::rtcp::Rpsi; | |
20 | |
21 namespace webrtc { | |
22 namespace { | |
23 const uint32_t kSenderSsrc = 0x12345678; | |
24 const uint32_t kRemoteSsrc = 0x23456789; | |
25 // 10000|01 100001|0 1000011 (7 bits = 1 byte in native string). | |
26 const uint64_t kPictureId = 0x106143; | |
27 const uint8_t kPayloadType = 100; | |
28 // Manually created Rpsi packet matching constants above. | |
29 const uint8_t kPacket[] = {0x83, 206, 0x00, 0x04, | |
30 0x12, 0x34, 0x56, 0x78, | |
31 0x23, 0x45, 0x67, 0x89, | |
32 24, 100, 0xc1, 0xc2, | |
33 0x43, 0, 0, 0}; | |
34 } // namespace | |
35 | |
36 TEST(RtcpPacketRpsiTest, Parse) { | |
37 Rpsi mutable_parsed; | |
38 EXPECT_TRUE(test::ParseSinglePacket(kPacket, &mutable_parsed)); | |
39 const Rpsi& parsed = mutable_parsed; // Read values from constant object. | |
40 | |
41 EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc()); | |
42 EXPECT_EQ(kRemoteSsrc, parsed.media_ssrc()); | |
43 EXPECT_EQ(kPayloadType, parsed.payload_type()); | |
44 EXPECT_EQ(kPictureId, parsed.picture_id()); | |
45 } | |
46 | |
47 TEST(RtcpPacketRpsiTest, Create) { | |
48 Rpsi rpsi; | |
49 rpsi.SetSenderSsrc(kSenderSsrc); | |
50 rpsi.SetMediaSsrc(kRemoteSsrc); | |
51 rpsi.SetPayloadType(kPayloadType); | |
52 rpsi.SetPictureId(kPictureId); | |
53 | |
54 rtc::Buffer packet = rpsi.Build(); | |
55 | |
56 EXPECT_THAT(make_tuple(packet.data(), packet.size()), | |
57 ElementsAreArray(kPacket)); | |
58 } | |
59 | |
60 TEST(RtcpPacketRpsiTest, ParseFailsOnTooSmallPacket) { | |
61 Rpsi rpsi; | |
62 rpsi.SetSenderSsrc(kSenderSsrc); | |
63 rpsi.SetMediaSsrc(kRemoteSsrc); | |
64 | |
65 rtc::Buffer packet = rpsi.Build(); | |
66 packet[3]--; // Reduce size field by one word (4 bytes). | |
67 packet.SetSize(packet.size() - 4); | |
68 | |
69 EXPECT_FALSE(test::ParseSinglePacket(packet, &rpsi)); | |
70 } | |
71 | |
72 TEST(RtcpPacketRpsiTest, ParseFailsOnFractionalPaddingBytes) { | |
73 Rpsi rpsi; | |
74 rpsi.SetSenderSsrc(kSenderSsrc); | |
75 rpsi.SetMediaSsrc(kRemoteSsrc); | |
76 rpsi.SetPictureId(kPictureId); | |
77 rtc::Buffer packet = rpsi.Build(); | |
78 uint8_t* padding_bits = packet.data() + 12; | |
79 uint8_t saved_padding_bits = *padding_bits; | |
80 ASSERT_TRUE(test::ParseSinglePacket(packet, &rpsi)); | |
81 | |
82 for (uint8_t i = 1; i < 8; ++i) { | |
83 *padding_bits = saved_padding_bits + i; | |
84 EXPECT_FALSE(test::ParseSinglePacket(packet, &rpsi)); | |
85 } | |
86 } | |
87 | |
88 TEST(RtcpPacketRpsiTest, ParseFailsOnTooBigPadding) { | |
89 Rpsi rpsi; | |
90 rpsi.SetSenderSsrc(kSenderSsrc); | |
91 rpsi.SetMediaSsrc(kRemoteSsrc); | |
92 rpsi.SetPictureId(1); // Small picture id that occupy just 1 byte. | |
93 rtc::Buffer packet = rpsi.Build(); | |
94 uint8_t* padding_bits = packet.data() + 12; | |
95 ASSERT_TRUE(test::ParseSinglePacket(packet, &rpsi)); | |
96 | |
97 *padding_bits += 8; | |
98 EXPECT_FALSE(test::ParseSinglePacket(packet, &rpsi)); | |
99 } | |
100 | |
101 // For raw rpsi packet extract how many bytes are used to store picture_id. | |
102 size_t UsedBytes(const rtc::Buffer& packet) { // Works for small packets only. | |
103 RTC_CHECK_EQ(packet.data()[2], 0); // Assume packet is small. | |
104 size_t total_rpsi_payload_bytes = 4 * (packet.data()[3] - 2) - 2; | |
105 uint8_t padding_bits = packet.data()[12]; | |
106 RTC_CHECK_EQ(padding_bits % 8, 0); | |
107 return total_rpsi_payload_bytes - (padding_bits / 8); | |
108 } | |
109 | |
110 TEST(RtcpPacketRpsiTest, WithOneByteNativeString) { | |
111 Rpsi rpsi; | |
112 // 1000001 (7 bits = 1 byte in native string). | |
113 const uint64_t kPictureId = 0x41; | |
114 const uint16_t kNumberOfValidBytes = 1; | |
115 rpsi.SetPictureId(kPictureId); | |
116 | |
117 rtc::Buffer packet = rpsi.Build(); | |
118 EXPECT_EQ(kNumberOfValidBytes, UsedBytes(packet)); | |
119 | |
120 Rpsi parsed; | |
121 EXPECT_TRUE(test::ParseSinglePacket(packet, &parsed)); | |
122 EXPECT_EQ(kPictureId, parsed.picture_id()); | |
123 } | |
124 | |
125 TEST(RtcpPacketRpsiTest, WithTwoByteNativeString) { | |
126 Rpsi rpsi; | |
127 // |1 0000001 (7 bits = 1 byte in native string). | |
128 const uint64_t kPictureId = 0x81; | |
129 const uint16_t kNumberOfValidBytes = 2; | |
130 rpsi.SetPictureId(kPictureId); | |
131 | |
132 rtc::Buffer packet = rpsi.Build(); | |
133 EXPECT_EQ(kNumberOfValidBytes, UsedBytes(packet)); | |
134 | |
135 Rpsi parsed; | |
136 EXPECT_TRUE(test::ParseSinglePacket(packet, &parsed)); | |
137 EXPECT_EQ(kPictureId, parsed.picture_id()); | |
138 } | |
139 | |
140 TEST(RtcpPacketRpsiTest, WithThreeByteNativeString) { | |
141 Rpsi rpsi; | |
142 // 10000|00 100000|0 1000000 (7 bits = 1 byte in native string). | |
143 const uint64_t kPictureId = 0x102040; | |
144 const uint16_t kNumberOfValidBytes = 3; | |
145 rpsi.SetPictureId(kPictureId); | |
146 | |
147 rtc::Buffer packet = rpsi.Build(); | |
148 EXPECT_EQ(kNumberOfValidBytes, UsedBytes(packet)); | |
149 | |
150 Rpsi parsed; | |
151 EXPECT_TRUE(test::ParseSinglePacket(packet, &parsed)); | |
152 EXPECT_EQ(kPictureId, parsed.picture_id()); | |
153 } | |
154 | |
155 TEST(RtcpPacketRpsiTest, WithFourByteNativeString) { | |
156 Rpsi rpsi; | |
157 // 1000|001 00001|01 100001|1 1000010 (7 bits = 1 byte in native string). | |
158 const uint64_t kPictureId = 0x84161C2; | |
159 const uint16_t kNumberOfValidBytes = 4; | |
160 rpsi.SetPictureId(kPictureId); | |
161 | |
162 rtc::Buffer packet = rpsi.Build(); | |
163 EXPECT_EQ(kNumberOfValidBytes, UsedBytes(packet)); | |
164 | |
165 Rpsi parsed; | |
166 EXPECT_TRUE(test::ParseSinglePacket(packet, &parsed)); | |
167 EXPECT_EQ(kPictureId, parsed.picture_id()); | |
168 } | |
169 | |
170 TEST(RtcpPacketRpsiTest, WithMaxPictureId) { | |
171 Rpsi rpsi; | |
172 // 1 1111111| 1111111 1|111111 11|11111 111|1111 1111|111 11111| | |
173 // 11 111111|1 1111111 (7 bits = 1 byte in native string). | |
174 const uint64_t kPictureId = 0xffffffffffffffff; | |
175 const uint16_t kNumberOfValidBytes = 10; | |
176 rpsi.SetPictureId(kPictureId); | |
177 | |
178 rtc::Buffer packet = rpsi.Build(); | |
179 EXPECT_EQ(kNumberOfValidBytes, UsedBytes(packet)); | |
180 | |
181 Rpsi parsed; | |
182 EXPECT_TRUE(test::ParseSinglePacket(packet, &parsed)); | |
183 EXPECT_EQ(kPictureId, parsed.picture_id()); | |
184 } | |
185 } // namespace webrtc | |
OLD | NEW |