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