1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include <stdint.h>
6
7 #include "base/macros.h"
8 #include "base/test/simple_test_tick_clock.h"
9 #include "media/cast/net/cast_transport_defines.h"
10 #include "media/cast/net/rtp/framer.h"
11 #include "media/cast/net/rtp/mock_rtp_payload_feedback.h"
12 #include "testing/gtest/include/gtest/gtest.h"
13
14 namespace media {
15 namespace cast {
16
17 class FramerTest : public ::testing::Test {
18 protected:
FramerTest()19 FramerTest()
20 : mock_rtp_payload_feedback_(),
21 framer_(&testing_clock_, &mock_rtp_payload_feedback_, 0, true, 0) {
22 payload_.assign(kMaxIpPacketSize, 0);
23
24 EXPECT_CALL(mock_rtp_payload_feedback_, CastFeedback(testing::_))
25 .WillRepeatedly(testing::Return());
26 }
27
28 ~FramerTest() override = default;
29
30 std::vector<uint8_t> payload_;
31 RtpCastHeader rtp_header_;
32 MockRtpPayloadFeedback mock_rtp_payload_feedback_;
33 Framer framer_;
34 base::SimpleTestTickClock testing_clock_;
35
36 DISALLOW_COPY_AND_ASSIGN(FramerTest);
37 };
38
TEST_F(FramerTest,EmptyState)39 TEST_F(FramerTest, EmptyState) {
40 EncodedFrame frame;
41 bool next_frame = false;
42 bool multiple = false;
43 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
44 }
45
TEST_F(FramerTest,AlwaysStartWithKey)46 TEST_F(FramerTest, AlwaysStartWithKey) {
47 EncodedFrame frame;
48 bool next_frame = false;
49 bool complete = false;
50 bool multiple = false;
51 bool duplicate = false;
52
53 // Insert non key first frame.
54 complete = framer_.InsertPacket(
55 &payload_[0], payload_.size(), rtp_header_, &duplicate);
56 EXPECT_TRUE(complete);
57 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
58 rtp_header_.frame_id = FrameId::first() + 1;
59 rtp_header_.reference_frame_id = FrameId::first() + 1;
60 rtp_header_.is_key_frame = true;
61 complete = framer_.InsertPacket(
62 &payload_[0], payload_.size(), rtp_header_, &duplicate);
63 EXPECT_TRUE(complete);
64 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
65 EXPECT_TRUE(next_frame);
66 EXPECT_TRUE(multiple);
67 EXPECT_EQ(EncodedFrame::KEY, frame.dependency);
68 EXPECT_EQ(FrameId::first() + 1, frame.frame_id);
69 EXPECT_EQ(FrameId::first() + 1, frame.referenced_frame_id);
70 framer_.ReleaseFrame(frame.frame_id);
71 }
72
TEST_F(FramerTest,CompleteFrame)73 TEST_F(FramerTest, CompleteFrame) {
74 EncodedFrame frame;
75 bool next_frame = false;
76 bool complete = false;
77 bool multiple = false;
78 bool duplicate = false;
79
80 // Start with a complete key frame.
81 rtp_header_.is_key_frame = true;
82 rtp_header_.frame_id = FrameId::first();
83 rtp_header_.reference_frame_id = FrameId::first();
84 complete = framer_.InsertPacket(
85 &payload_[0], payload_.size(), rtp_header_, &duplicate);
86 EXPECT_TRUE(complete);
87 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
88 EXPECT_TRUE(next_frame);
89 EXPECT_FALSE(multiple);
90 EXPECT_EQ(EncodedFrame::KEY, frame.dependency);
91 EXPECT_EQ(FrameId::first(), frame.frame_id);
92 EXPECT_EQ(FrameId::first(), frame.referenced_frame_id);
93 framer_.ReleaseFrame(frame.frame_id);
94
95 // Incomplete delta.
96 ++rtp_header_.frame_id;
97 rtp_header_.reference_frame_id = rtp_header_.frame_id - 1;
98 rtp_header_.is_key_frame = false;
99 rtp_header_.max_packet_id = 2;
100 complete = framer_.InsertPacket(
101 &payload_[0], payload_.size(), rtp_header_, &duplicate);
102 EXPECT_FALSE(complete);
103 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
104
105 // Complete delta - can't skip, as incomplete sequence.
106 ++rtp_header_.frame_id;
107 rtp_header_.reference_frame_id = rtp_header_.frame_id - 1;
108 rtp_header_.max_packet_id = 0;
109 complete = framer_.InsertPacket(
110 &payload_[0], payload_.size(), rtp_header_, &duplicate);
111 EXPECT_TRUE(complete);
112 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
113 }
114
TEST_F(FramerTest,DuplicatePackets)115 TEST_F(FramerTest, DuplicatePackets) {
116 EncodedFrame frame;
117 bool next_frame = false;
118 bool complete = false;
119 bool multiple = false;
120 bool duplicate = false;
121
122 // Start with an incomplete key frame.
123 rtp_header_.is_key_frame = true;
124 rtp_header_.frame_id = FrameId::first();
125 rtp_header_.reference_frame_id = FrameId::first();
126 rtp_header_.max_packet_id = 1;
127 duplicate = true;
128 complete = framer_.InsertPacket(
129 &payload_[0], payload_.size(), rtp_header_, &duplicate);
130 EXPECT_FALSE(complete);
131 EXPECT_FALSE(duplicate);
132 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
133
134 // Add same packet again in incomplete key frame.
135 duplicate = false;
136 complete = framer_.InsertPacket(
137 &payload_[0], payload_.size(), rtp_header_, &duplicate);
138 EXPECT_FALSE(complete);
139 EXPECT_TRUE(duplicate);
140 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
141
142 // Complete key frame.
143 rtp_header_.packet_id = 1;
144 duplicate = true;
145 complete = framer_.InsertPacket(
146 &payload_[0], payload_.size(), rtp_header_, &duplicate);
147 EXPECT_TRUE(complete);
148 EXPECT_FALSE(duplicate);
149 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
150 EXPECT_EQ(EncodedFrame::KEY, frame.dependency);
151 EXPECT_FALSE(multiple);
152 EXPECT_EQ(FrameId::first(), frame.referenced_frame_id);
153
154 // Add same packet again in complete key frame.
155 duplicate = false;
156 complete = framer_.InsertPacket(
157 &payload_[0], payload_.size(), rtp_header_, &duplicate);
158 EXPECT_FALSE(complete);
159 EXPECT_TRUE(duplicate);
160 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
161 EXPECT_EQ(EncodedFrame::KEY, frame.dependency);
162 EXPECT_EQ(FrameId::first(), frame.frame_id);
163 EXPECT_FALSE(multiple);
164 EXPECT_EQ(FrameId::first(), frame.referenced_frame_id);
165 framer_.ReleaseFrame(frame.frame_id);
166
167 // Incomplete delta frame.
168 ++rtp_header_.frame_id;
169 rtp_header_.reference_frame_id = rtp_header_.frame_id - 1;
170 rtp_header_.packet_id = 0;
171 rtp_header_.is_key_frame = false;
172 duplicate = true;
173 complete = framer_.InsertPacket(
174 &payload_[0], payload_.size(), rtp_header_, &duplicate);
175 EXPECT_FALSE(complete);
176 EXPECT_FALSE(duplicate);
177 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
178
179 // Add same packet again in incomplete delta frame.
180 duplicate = false;
181 complete = framer_.InsertPacket(
182 &payload_[0], payload_.size(), rtp_header_, &duplicate);
183 EXPECT_FALSE(complete);
184 EXPECT_TRUE(duplicate);
185 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
186
187 // Complete delta frame.
188 rtp_header_.packet_id = 1;
189 duplicate = true;
190 complete = framer_.InsertPacket(
191 &payload_[0], payload_.size(), rtp_header_, &duplicate);
192 EXPECT_TRUE(complete);
193 EXPECT_FALSE(duplicate);
194 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
195 EXPECT_EQ(EncodedFrame::DEPENDENT, frame.dependency);
196 EXPECT_EQ(FrameId::first() + 1, frame.frame_id);
197 EXPECT_EQ(FrameId::first(), frame.referenced_frame_id);
198 EXPECT_FALSE(multiple);
199
200 // Add same packet again in complete delta frame.
201 duplicate = false;
202 complete = framer_.InsertPacket(
203 &payload_[0], payload_.size(), rtp_header_, &duplicate);
204 EXPECT_FALSE(complete);
205 EXPECT_TRUE(duplicate);
206 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
207 EXPECT_EQ(EncodedFrame::DEPENDENT, frame.dependency);
208 EXPECT_EQ(FrameId::first() + 1, frame.frame_id);
209 EXPECT_EQ(FrameId::first(), frame.referenced_frame_id);
210 EXPECT_FALSE(multiple);
211 }
212
TEST_F(FramerTest,ContinuousSequence)213 TEST_F(FramerTest, ContinuousSequence) {
214 EncodedFrame frame;
215 bool next_frame = false;
216 bool complete = false;
217 bool multiple = false;
218 bool duplicate = false;
219
220 // Start with a complete key frame.
221 rtp_header_.is_key_frame = true;
222 rtp_header_.frame_id = FrameId::first();
223 rtp_header_.reference_frame_id = FrameId::first();
224 complete = framer_.InsertPacket(
225 &payload_[0], payload_.size(), rtp_header_, &duplicate);
226 EXPECT_TRUE(complete);
227 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
228 EXPECT_TRUE(next_frame);
229 EXPECT_FALSE(multiple);
230 EXPECT_EQ(EncodedFrame::KEY, frame.dependency);
231 EXPECT_EQ(FrameId::first(), frame.frame_id);
232 EXPECT_EQ(FrameId::first(), frame.referenced_frame_id);
233 framer_.ReleaseFrame(frame.frame_id);
234
235 // Complete - not continuous.
236 rtp_header_.frame_id = FrameId::first() + 2;
237 rtp_header_.reference_frame_id = rtp_header_.frame_id - 1;
238 rtp_header_.is_key_frame = false;
239 complete = framer_.InsertPacket(
240 &payload_[0], payload_.size(), rtp_header_, &duplicate);
241 EXPECT_TRUE(complete);
242 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
243 }
244
TEST_F(FramerTest,RequireKeyFrameForFirstFrame)245 TEST_F(FramerTest, RequireKeyFrameForFirstFrame) {
246 EncodedFrame frame;
247 bool next_frame = false;
248 bool multiple = false;
249 bool duplicate = false;
250
251 // Start with a complete key frame.
252 rtp_header_.is_key_frame = false;
253 rtp_header_.frame_id = FrameId::first();
254 framer_.InsertPacket(
255 &payload_[0], payload_.size(), rtp_header_, &duplicate);
256 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
257 rtp_header_.frame_id = FrameId::first() + 1;
258 rtp_header_.reference_frame_id = FrameId::first() + 1;
259 rtp_header_.is_key_frame = true;
260 framer_.InsertPacket(
261 &payload_[0], payload_.size(), rtp_header_, &duplicate);
262 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
263 EXPECT_TRUE(next_frame);
264 EXPECT_TRUE(multiple);
265 }
266
TEST_F(FramerTest,BasicNonLastReferenceId)267 TEST_F(FramerTest, BasicNonLastReferenceId) {
268 EncodedFrame frame;
269 bool next_frame = false;
270 bool multiple = false;
271 bool duplicate = false;
272
273 rtp_header_.is_key_frame = true;
274 rtp_header_.frame_id = FrameId::first();
275 rtp_header_.reference_frame_id = FrameId::first();
276 framer_.InsertPacket(
277 &payload_[0], payload_.size(), rtp_header_, &duplicate);
278
279 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
280 EXPECT_FALSE(multiple);
281 framer_.ReleaseFrame(frame.frame_id);
282
283 rtp_header_.is_key_frame = false;
284 rtp_header_.frame_id = FrameId::first() + 5;
285 rtp_header_.reference_frame_id = FrameId::first();
286 framer_.InsertPacket(
287 &payload_[0], payload_.size(), rtp_header_, &duplicate);
288
289 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
290 EXPECT_FALSE(next_frame);
291 EXPECT_FALSE(multiple);
292 }
293
TEST_F(FramerTest,InOrderReferenceFrameSelection)294 TEST_F(FramerTest, InOrderReferenceFrameSelection) {
295 // Create pattern: 0, 1, 4, 5.
296 EncodedFrame frame;
297 bool next_frame = false;
298 bool multiple = false;
299 bool duplicate = false;
300
301 rtp_header_.is_key_frame = true;
302 rtp_header_.frame_id = FrameId::first();
303 rtp_header_.reference_frame_id = FrameId::first();
304 framer_.InsertPacket(
305 &payload_[0], payload_.size(), rtp_header_, &duplicate);
306 rtp_header_.is_key_frame = false;
307 rtp_header_.frame_id = FrameId::first() + 1;
308 framer_.InsertPacket(
309 &payload_[0], payload_.size(), rtp_header_, &duplicate);
310
311 // Insert frame #2 partially.
312 rtp_header_.frame_id = FrameId::first() + 2;
313 rtp_header_.max_packet_id = 1;
314 framer_.InsertPacket(
315 &payload_[0], payload_.size(), rtp_header_, &duplicate);
316 rtp_header_.frame_id = FrameId::first() + 4;
317 rtp_header_.max_packet_id = 0;
318 rtp_header_.reference_frame_id = FrameId::first();
319 framer_.InsertPacket(
320 &payload_[0], payload_.size(), rtp_header_, &duplicate);
321 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
322 EXPECT_EQ(EncodedFrame::KEY, frame.dependency);
323 EXPECT_EQ(FrameId::first(), frame.frame_id);
324 EXPECT_EQ(FrameId::first(), frame.referenced_frame_id);
325 EXPECT_FALSE(multiple);
326 framer_.ReleaseFrame(frame.frame_id);
327 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
328 EXPECT_TRUE(next_frame);
329 EXPECT_TRUE(multiple);
330 EXPECT_EQ(EncodedFrame::DEPENDENT, frame.dependency);
331 EXPECT_EQ(FrameId::first() + 1, frame.frame_id);
332 EXPECT_EQ(FrameId::first(), frame.referenced_frame_id);
333 framer_.ReleaseFrame(frame.frame_id);
334 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
335 EXPECT_FALSE(next_frame);
336 EXPECT_FALSE(multiple);
337 EXPECT_EQ(EncodedFrame::DEPENDENT, frame.dependency);
338 EXPECT_EQ(FrameId::first() + 4, frame.frame_id);
339 EXPECT_EQ(FrameId::first(), frame.referenced_frame_id);
340 framer_.ReleaseFrame(frame.frame_id);
341 // Insert remaining packet of frame #2 - should no be continuous.
342 rtp_header_.frame_id = FrameId::first() + 2;
343 rtp_header_.packet_id = 1;
344 framer_.InsertPacket(
345 &payload_[0], payload_.size(), rtp_header_, &duplicate);
346 EXPECT_FALSE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
347 rtp_header_.frame_id = FrameId::first() + 5;
348 rtp_header_.reference_frame_id = rtp_header_.frame_id - 1;
349 rtp_header_.packet_id = 0;
350 rtp_header_.max_packet_id = 0;
351 framer_.InsertPacket(
352 &payload_[0], payload_.size(), rtp_header_, &duplicate);
353 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
354 EXPECT_TRUE(next_frame);
355 EXPECT_FALSE(multiple);
356 EXPECT_EQ(EncodedFrame::DEPENDENT, frame.dependency);
357 EXPECT_EQ(FrameId::first() + 5, frame.frame_id);
358 EXPECT_EQ(FrameId::first() + 4, frame.referenced_frame_id);
359 }
360
TEST_F(FramerTest,ReleasesAllReceivedKeyFramesInContinuousSequence)361 TEST_F(FramerTest, ReleasesAllReceivedKeyFramesInContinuousSequence) {
362 EncodedFrame frame;
363 bool next_frame = false;
364 bool multiple = false;
365 bool duplicate = false;
366
367 rtp_header_.is_key_frame = true;
368 rtp_header_.frame_id = FrameId::first() + 254;
369 rtp_header_.reference_frame_id = FrameId::first() + 254;
370
371 framer_.InsertPacket(
372 &payload_[0], payload_.size(), rtp_header_, &duplicate);
373 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
374 EXPECT_TRUE(next_frame);
375 EXPECT_FALSE(multiple);
376 EXPECT_EQ(EncodedFrame::KEY, frame.dependency);
377 EXPECT_EQ(FrameId::first() + 254, frame.frame_id);
378 EXPECT_EQ(FrameId::first() + 254, frame.referenced_frame_id);
379 framer_.ReleaseFrame(frame.frame_id);
380
381 rtp_header_.frame_id = FrameId::first() + 255;
382 rtp_header_.reference_frame_id = FrameId::first() + 255;
383 framer_.InsertPacket(
384 &payload_[0], payload_.size(), rtp_header_, &duplicate);
385
386 // Insert wrapped frame - should be continuous.
387 rtp_header_.frame_id = FrameId::first() + 256;
388 rtp_header_.reference_frame_id = FrameId::first() + 256;
389 framer_.InsertPacket(
390 &payload_[0], payload_.size(), rtp_header_, &duplicate);
391
392 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
393 EXPECT_TRUE(next_frame);
394 EXPECT_TRUE(multiple);
395 EXPECT_EQ(EncodedFrame::KEY, frame.dependency);
396 EXPECT_EQ(FrameId::first() + 255, frame.frame_id);
397 EXPECT_EQ(FrameId::first() + 255, frame.referenced_frame_id);
398 framer_.ReleaseFrame(frame.frame_id);
399
400 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
401 EXPECT_TRUE(next_frame);
402 EXPECT_FALSE(multiple);
403 EXPECT_EQ(EncodedFrame::KEY, frame.dependency);
404 EXPECT_EQ(FrameId::first() + 256, frame.frame_id);
405 EXPECT_EQ(FrameId::first() + 256, frame.referenced_frame_id);
406 framer_.ReleaseFrame(frame.frame_id);
407 }
408
TEST_F(FramerTest,SkipsMissingFramesWhenLaterKeyFramesAreAvailable)409 TEST_F(FramerTest, SkipsMissingFramesWhenLaterKeyFramesAreAvailable) {
410 EncodedFrame frame;
411 bool next_frame = false;
412 bool multiple = true;
413 bool duplicate = false;
414
415 // Insert and get first frame's packet.
416 rtp_header_.is_key_frame = true;
417 rtp_header_.frame_id = FrameId::first() + 253;
418 rtp_header_.reference_frame_id = FrameId::first() + 253;
419 framer_.InsertPacket(
420 &payload_[0], payload_.size(), rtp_header_, &duplicate);
421 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
422 EXPECT_TRUE(next_frame);
423 EXPECT_FALSE(multiple);
424 EXPECT_EQ(EncodedFrame::KEY, frame.dependency);
425 EXPECT_EQ(FrameId::first() + 253, frame.frame_id);
426 EXPECT_EQ(FrameId::first() + 253, frame.referenced_frame_id);
427 framer_.ReleaseFrame(frame.frame_id);
428
429 // Insert third and fourth frames' packet.
430 rtp_header_.frame_id = FrameId::first() + 255;
431 rtp_header_.reference_frame_id = FrameId::first() + 255;
432 framer_.InsertPacket(
433 &payload_[0], payload_.size(), rtp_header_, &duplicate);
434 rtp_header_.frame_id = FrameId::first() + 256;
435 rtp_header_.reference_frame_id = FrameId::first() + 256;
436 framer_.InsertPacket(
437 &payload_[0], payload_.size(), rtp_header_, &duplicate);
438
439 // Get third and fourth frame.
440 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
441 EXPECT_FALSE(next_frame);
442 EXPECT_TRUE(multiple);
443 EXPECT_EQ(EncodedFrame::KEY, frame.dependency);
444 EXPECT_EQ(FrameId::first() + 255, frame.frame_id);
445 EXPECT_EQ(FrameId::first() + 255, frame.referenced_frame_id);
446 framer_.ReleaseFrame(frame.frame_id);
447 EXPECT_TRUE(framer_.GetEncodedFrame(&frame, &next_frame, &multiple));
448 EXPECT_TRUE(next_frame);
449 EXPECT_FALSE(multiple);
450 EXPECT_EQ(EncodedFrame::KEY, frame.dependency);
451 EXPECT_EQ(FrameId::first() + 256, frame.frame_id);
452 EXPECT_EQ(FrameId::first() + 256, frame.referenced_frame_id);
453 framer_.ReleaseFrame(frame.frame_id);
454 }
455
456 } // namespace cast
457 } // namespace media
458