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