1 /*
2  *  Copyright (c) 2011 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 "modules/include/module_common_types.h"
14 #include "modules/video_coding/decoding_state.h"
15 #include "modules/video_coding/frame_buffer.h"
16 #include "modules/video_coding/jitter_buffer_common.h"
17 #include "modules/video_coding/packet.h"
18 #include "test/gtest.h"
19 
20 namespace webrtc {
21 
TEST(TestDecodingState,Sanity)22 TEST(TestDecodingState, Sanity) {
23   VCMDecodingState dec_state;
24   dec_state.Reset();
25   EXPECT_TRUE(dec_state.in_initial_state());
26   EXPECT_TRUE(dec_state.full_sync());
27 }
28 
TEST(TestDecodingState,FrameContinuity)29 TEST(TestDecodingState, FrameContinuity) {
30   VCMDecodingState dec_state;
31   // Check that makes decision based on correct method.
32   VCMFrameBuffer frame;
33   VCMFrameBuffer frame_key;
34   VCMPacket packet;
35   packet.is_first_packet_in_frame = true;
36   packet.timestamp = 1;
37   packet.seqNum = 0xffff;
38   packet.frameType = kVideoFrameDelta;
39   packet.video_header.codec = kRtpVideoVp8;
40   packet.video_header.codecHeader.VP8.pictureId = 0x007F;
41   FrameData frame_data;
42   frame_data.rtt_ms = 0;
43   frame_data.rolling_average_packets_per_frame = -1;
44   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
45   // Always start with a key frame.
46   dec_state.Reset();
47   EXPECT_FALSE(dec_state.ContinuousFrame(&frame));
48   packet.frameType = kVideoFrameKey;
49   EXPECT_LE(0, frame_key.InsertPacket(packet, 0, kNoErrors, frame_data));
50   EXPECT_TRUE(dec_state.ContinuousFrame(&frame_key));
51   dec_state.SetState(&frame);
52   frame.Reset();
53   packet.frameType = kVideoFrameDelta;
54   // Use pictureId
55   packet.is_first_packet_in_frame = false;
56   packet.video_header.codecHeader.VP8.pictureId = 0x0002;
57   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
58   EXPECT_FALSE(dec_state.ContinuousFrame(&frame));
59   frame.Reset();
60   packet.video_header.codecHeader.VP8.pictureId = 0;
61   packet.seqNum = 10;
62   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
63   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
64 
65   // Use sequence numbers.
66   packet.video_header.codecHeader.VP8.pictureId = kNoPictureId;
67   frame.Reset();
68   packet.seqNum = dec_state.sequence_num() - 1u;
69   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
70   EXPECT_FALSE(dec_state.ContinuousFrame(&frame));
71   frame.Reset();
72   packet.seqNum = dec_state.sequence_num() + 1u;
73   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
74   // Insert another packet to this frame
75   packet.seqNum++;
76   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
77   // Verify wrap.
78   EXPECT_LE(dec_state.sequence_num(), 0xffff);
79   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
80   dec_state.SetState(&frame);
81 
82   // Insert packet with temporal info.
83   dec_state.Reset();
84   frame.Reset();
85   packet.video_header.codecHeader.VP8.tl0PicIdx = 0;
86   packet.video_header.codecHeader.VP8.temporalIdx = 0;
87   packet.video_header.codecHeader.VP8.pictureId = 0;
88   packet.seqNum = 1;
89   packet.timestamp = 1;
90   EXPECT_TRUE(dec_state.full_sync());
91   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
92   dec_state.SetState(&frame);
93   EXPECT_TRUE(dec_state.full_sync());
94   frame.Reset();
95   // 1 layer up - still good.
96   packet.video_header.codecHeader.VP8.tl0PicIdx = 0;
97   packet.video_header.codecHeader.VP8.temporalIdx = 1;
98   packet.video_header.codecHeader.VP8.pictureId = 1;
99   packet.seqNum = 2;
100   packet.timestamp = 2;
101   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
102   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
103   dec_state.SetState(&frame);
104   EXPECT_TRUE(dec_state.full_sync());
105   frame.Reset();
106   // Lost non-base layer packet => should update sync parameter.
107   packet.video_header.codecHeader.VP8.tl0PicIdx = 0;
108   packet.video_header.codecHeader.VP8.temporalIdx = 3;
109   packet.video_header.codecHeader.VP8.pictureId = 3;
110   packet.seqNum = 4;
111   packet.timestamp = 4;
112   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
113   EXPECT_FALSE(dec_state.ContinuousFrame(&frame));
114   // Now insert the next non-base layer (belonging to a next tl0PicId).
115   frame.Reset();
116   packet.video_header.codecHeader.VP8.tl0PicIdx = 1;
117   packet.video_header.codecHeader.VP8.temporalIdx = 2;
118   packet.video_header.codecHeader.VP8.pictureId = 4;
119   packet.seqNum = 5;
120   packet.timestamp = 5;
121   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
122   // Checking continuity and not updating the state - this should not trigger
123   // an update of sync state.
124   EXPECT_FALSE(dec_state.ContinuousFrame(&frame));
125   EXPECT_TRUE(dec_state.full_sync());
126   // Next base layer (dropped interim non-base layers) - should update sync.
127   frame.Reset();
128   packet.video_header.codecHeader.VP8.tl0PicIdx = 1;
129   packet.video_header.codecHeader.VP8.temporalIdx = 0;
130   packet.video_header.codecHeader.VP8.pictureId = 5;
131   packet.seqNum = 6;
132   packet.timestamp = 6;
133   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
134   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
135   dec_state.SetState(&frame);
136   EXPECT_FALSE(dec_state.full_sync());
137 
138   // Check wrap for temporal layers.
139   frame.Reset();
140   packet.video_header.codecHeader.VP8.tl0PicIdx = 0x00FF;
141   packet.video_header.codecHeader.VP8.temporalIdx = 0;
142   packet.video_header.codecHeader.VP8.pictureId = 6;
143   packet.seqNum = 7;
144   packet.timestamp = 7;
145   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
146   dec_state.SetState(&frame);
147   EXPECT_FALSE(dec_state.full_sync());
148   frame.Reset();
149   packet.video_header.codecHeader.VP8.tl0PicIdx = 0x0000;
150   packet.video_header.codecHeader.VP8.temporalIdx = 0;
151   packet.video_header.codecHeader.VP8.pictureId = 7;
152   packet.seqNum = 8;
153   packet.timestamp = 8;
154   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
155   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
156   // The current frame is not continuous
157   dec_state.SetState(&frame);
158   EXPECT_FALSE(dec_state.ContinuousFrame(&frame));
159 }
160 
TEST(TestDecodingState,UpdateOldPacket)161 TEST(TestDecodingState, UpdateOldPacket) {
162   VCMDecodingState dec_state;
163   // Update only if zero size and newer than previous.
164   // Should only update if the timeStamp match.
165   VCMFrameBuffer frame;
166   VCMPacket packet;
167   packet.timestamp = 1;
168   packet.seqNum = 1;
169   packet.frameType = kVideoFrameDelta;
170   FrameData frame_data;
171   frame_data.rtt_ms = 0;
172   frame_data.rolling_average_packets_per_frame = -1;
173   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
174   dec_state.SetState(&frame);
175   EXPECT_EQ(dec_state.sequence_num(), 1);
176   // Insert an empty packet that does not belong to the same frame.
177   // => Sequence num should be the same.
178   packet.timestamp = 2;
179   dec_state.UpdateOldPacket(&packet);
180   EXPECT_EQ(dec_state.sequence_num(), 1);
181   // Now insert empty packet belonging to the same frame.
182   packet.timestamp = 1;
183   packet.seqNum = 2;
184   packet.frameType = kEmptyFrame;
185   packet.sizeBytes = 0;
186   dec_state.UpdateOldPacket(&packet);
187   EXPECT_EQ(dec_state.sequence_num(), 2);
188   // Now insert delta packet belonging to the same frame.
189   packet.timestamp = 1;
190   packet.seqNum = 3;
191   packet.frameType = kVideoFrameDelta;
192   packet.sizeBytes = 1400;
193   dec_state.UpdateOldPacket(&packet);
194   EXPECT_EQ(dec_state.sequence_num(), 3);
195   // Insert a packet belonging to an older timestamp - should not update the
196   // sequence number.
197   packet.timestamp = 0;
198   packet.seqNum = 4;
199   packet.frameType = kEmptyFrame;
200   packet.sizeBytes = 0;
201   dec_state.UpdateOldPacket(&packet);
202   EXPECT_EQ(dec_state.sequence_num(), 3);
203 }
204 
TEST(TestDecodingState,MultiLayerBehavior)205 TEST(TestDecodingState, MultiLayerBehavior) {
206   // Identify sync/non-sync when more than one layer.
207   VCMDecodingState dec_state;
208   // Identify packets belonging to old frames/packets.
209   // Set state for current frames.
210   // tl0PicIdx 0, temporal id 0.
211   VCMFrameBuffer frame;
212   VCMPacket packet;
213   packet.frameType = kVideoFrameDelta;
214   packet.video_header.codec = kRtpVideoVp8;
215   packet.timestamp = 0;
216   packet.seqNum = 0;
217   packet.video_header.codecHeader.VP8.tl0PicIdx = 0;
218   packet.video_header.codecHeader.VP8.temporalIdx = 0;
219   packet.video_header.codecHeader.VP8.pictureId = 0;
220   FrameData frame_data;
221   frame_data.rtt_ms = 0;
222   frame_data.rolling_average_packets_per_frame = -1;
223   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
224   dec_state.SetState(&frame);
225   // tl0PicIdx 0, temporal id 1.
226   frame.Reset();
227   packet.timestamp = 1;
228   packet.seqNum = 1;
229   packet.video_header.codecHeader.VP8.tl0PicIdx = 0;
230   packet.video_header.codecHeader.VP8.temporalIdx = 1;
231   packet.video_header.codecHeader.VP8.pictureId = 1;
232   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
233   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
234   dec_state.SetState(&frame);
235   EXPECT_TRUE(dec_state.full_sync());
236   // Lost tl0PicIdx 0, temporal id 2.
237   // Insert tl0PicIdx 0, temporal id 3.
238   frame.Reset();
239   packet.timestamp = 3;
240   packet.seqNum = 3;
241   packet.video_header.codecHeader.VP8.tl0PicIdx = 0;
242   packet.video_header.codecHeader.VP8.temporalIdx = 3;
243   packet.video_header.codecHeader.VP8.pictureId = 3;
244   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
245   EXPECT_FALSE(dec_state.ContinuousFrame(&frame));
246   dec_state.SetState(&frame);
247   EXPECT_FALSE(dec_state.full_sync());
248   // Insert next base layer
249   frame.Reset();
250   packet.timestamp = 4;
251   packet.seqNum = 4;
252   packet.video_header.codecHeader.VP8.tl0PicIdx = 1;
253   packet.video_header.codecHeader.VP8.temporalIdx = 0;
254   packet.video_header.codecHeader.VP8.pictureId = 4;
255   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
256   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
257   dec_state.SetState(&frame);
258   EXPECT_FALSE(dec_state.full_sync());
259   // Insert key frame - should update sync value.
260   // A key frame is always a base layer.
261   frame.Reset();
262   packet.frameType = kVideoFrameKey;
263   packet.is_first_packet_in_frame = 1;
264   packet.timestamp = 5;
265   packet.seqNum = 5;
266   packet.video_header.codecHeader.VP8.tl0PicIdx = 2;
267   packet.video_header.codecHeader.VP8.temporalIdx = 0;
268   packet.video_header.codecHeader.VP8.pictureId = 5;
269   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
270   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
271   dec_state.SetState(&frame);
272   EXPECT_TRUE(dec_state.full_sync());
273   // After sync, a continuous PictureId is required
274   // (continuous base layer is not enough )
275   frame.Reset();
276   packet.frameType = kVideoFrameDelta;
277   packet.timestamp = 6;
278   packet.seqNum = 6;
279   packet.video_header.codecHeader.VP8.tl0PicIdx = 3;
280   packet.video_header.codecHeader.VP8.temporalIdx = 0;
281   packet.video_header.codecHeader.VP8.pictureId = 6;
282   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
283   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
284   EXPECT_TRUE(dec_state.full_sync());
285   frame.Reset();
286   packet.frameType = kVideoFrameDelta;
287   packet.is_first_packet_in_frame = 1;
288   packet.timestamp = 8;
289   packet.seqNum = 8;
290   packet.video_header.codecHeader.VP8.tl0PicIdx = 4;
291   packet.video_header.codecHeader.VP8.temporalIdx = 0;
292   packet.video_header.codecHeader.VP8.pictureId = 8;
293   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
294   EXPECT_FALSE(dec_state.ContinuousFrame(&frame));
295   EXPECT_TRUE(dec_state.full_sync());
296   dec_state.SetState(&frame);
297   EXPECT_FALSE(dec_state.full_sync());
298 
299   // Insert a non-ref frame - should update sync value.
300   frame.Reset();
301   packet.frameType = kVideoFrameDelta;
302   packet.is_first_packet_in_frame = 1;
303   packet.timestamp = 9;
304   packet.seqNum = 9;
305   packet.video_header.codecHeader.VP8.tl0PicIdx = 4;
306   packet.video_header.codecHeader.VP8.temporalIdx = 2;
307   packet.video_header.codecHeader.VP8.pictureId = 9;
308   packet.video_header.codecHeader.VP8.layerSync = true;
309   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
310   dec_state.SetState(&frame);
311   EXPECT_TRUE(dec_state.full_sync());
312 
313   // The following test will verify the sync flag behavior after a loss.
314   // Create the following pattern:
315   // Update base layer, lose packet 1 (sync flag on, layer 2), insert packet 3
316   // (sync flag on, layer 2) check continuity and sync flag after inserting
317   // packet 2 (sync flag on, layer 1).
318   // Base layer.
319   frame.Reset();
320   dec_state.Reset();
321   packet.frameType = kVideoFrameDelta;
322   packet.is_first_packet_in_frame = 1;
323   packet.markerBit = 1;
324   packet.timestamp = 0;
325   packet.seqNum = 0;
326   packet.video_header.codecHeader.VP8.tl0PicIdx = 0;
327   packet.video_header.codecHeader.VP8.temporalIdx = 0;
328   packet.video_header.codecHeader.VP8.pictureId = 0;
329   packet.video_header.codecHeader.VP8.layerSync = false;
330   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
331   dec_state.SetState(&frame);
332   EXPECT_TRUE(dec_state.full_sync());
333   // Layer 2 - 2 packets (insert one, lose one).
334   frame.Reset();
335   packet.frameType = kVideoFrameDelta;
336   packet.is_first_packet_in_frame = 1;
337   packet.markerBit = 0;
338   packet.timestamp = 1;
339   packet.seqNum = 1;
340   packet.video_header.codecHeader.VP8.tl0PicIdx = 0;
341   packet.video_header.codecHeader.VP8.temporalIdx = 2;
342   packet.video_header.codecHeader.VP8.pictureId = 1;
343   packet.video_header.codecHeader.VP8.layerSync = true;
344   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
345   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
346   // Layer 1
347   frame.Reset();
348   packet.frameType = kVideoFrameDelta;
349   packet.is_first_packet_in_frame = 1;
350   packet.markerBit = 1;
351   packet.timestamp = 2;
352   packet.seqNum = 3;
353   packet.video_header.codecHeader.VP8.tl0PicIdx = 0;
354   packet.video_header.codecHeader.VP8.temporalIdx = 1;
355   packet.video_header.codecHeader.VP8.pictureId = 2;
356   packet.video_header.codecHeader.VP8.layerSync = true;
357   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
358   EXPECT_FALSE(dec_state.ContinuousFrame(&frame));
359   EXPECT_TRUE(dec_state.full_sync());
360 }
361 
TEST(TestDecodingState,DiscontinuousPicIdContinuousSeqNum)362 TEST(TestDecodingState, DiscontinuousPicIdContinuousSeqNum) {
363   VCMDecodingState dec_state;
364   VCMFrameBuffer frame;
365   VCMPacket packet;
366   frame.Reset();
367   packet.frameType = kVideoFrameKey;
368   packet.video_header.codec = kRtpVideoVp8;
369   packet.timestamp = 0;
370   packet.seqNum = 0;
371   packet.video_header.codecHeader.VP8.tl0PicIdx = 0;
372   packet.video_header.codecHeader.VP8.temporalIdx = 0;
373   packet.video_header.codecHeader.VP8.pictureId = 0;
374   FrameData frame_data;
375   frame_data.rtt_ms = 0;
376   frame_data.rolling_average_packets_per_frame = -1;
377   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
378   dec_state.SetState(&frame);
379   EXPECT_TRUE(dec_state.full_sync());
380 
381   // Continuous sequence number but discontinuous picture id. This implies a
382   // a loss and we have to fall back to only decoding the base layer.
383   frame.Reset();
384   packet.frameType = kVideoFrameDelta;
385   packet.timestamp += 3000;
386   ++packet.seqNum;
387   packet.video_header.codecHeader.VP8.temporalIdx = 1;
388   packet.video_header.codecHeader.VP8.pictureId = 2;
389   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
390   EXPECT_FALSE(dec_state.ContinuousFrame(&frame));
391   dec_state.SetState(&frame);
392   EXPECT_FALSE(dec_state.full_sync());
393 }
394 
TEST(TestDecodingState,OldInput)395 TEST(TestDecodingState, OldInput) {
396   VCMDecodingState dec_state;
397   // Identify packets belonging to old frames/packets.
398   // Set state for current frames.
399   VCMFrameBuffer frame;
400   VCMPacket packet;
401   packet.timestamp = 10;
402   packet.seqNum = 1;
403   FrameData frame_data;
404   frame_data.rtt_ms = 0;
405   frame_data.rolling_average_packets_per_frame = -1;
406   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
407   dec_state.SetState(&frame);
408   packet.timestamp = 9;
409   EXPECT_TRUE(dec_state.IsOldPacket(&packet));
410   // Check for old frame
411   frame.Reset();
412   frame.InsertPacket(packet, 0, kNoErrors, frame_data);
413   EXPECT_TRUE(dec_state.IsOldFrame(&frame));
414 }
415 
TEST(TestDecodingState,PictureIdRepeat)416 TEST(TestDecodingState, PictureIdRepeat) {
417   VCMDecodingState dec_state;
418   VCMFrameBuffer frame;
419   VCMPacket packet;
420   packet.frameType = kVideoFrameDelta;
421   packet.video_header.codec = kRtpVideoVp8;
422   packet.timestamp = 0;
423   packet.seqNum = 0;
424   packet.video_header.codecHeader.VP8.tl0PicIdx = 0;
425   packet.video_header.codecHeader.VP8.temporalIdx = 0;
426   packet.video_header.codecHeader.VP8.pictureId = 0;
427   FrameData frame_data;
428   frame_data.rtt_ms = 0;
429   frame_data.rolling_average_packets_per_frame = -1;
430   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
431   dec_state.SetState(&frame);
432   // tl0PicIdx 0, temporal id 1.
433   frame.Reset();
434   ++packet.timestamp;
435   ++packet.seqNum;
436   packet.video_header.codecHeader.VP8.temporalIdx++;
437   packet.video_header.codecHeader.VP8.pictureId++;
438   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
439   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
440   frame.Reset();
441   // Testing only gap in tl0PicIdx when tl0PicIdx in continuous.
442   packet.video_header.codecHeader.VP8.tl0PicIdx += 3;
443   packet.video_header.codecHeader.VP8.temporalIdx++;
444   packet.video_header.codecHeader.VP8.tl0PicIdx = 1;
445   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
446   EXPECT_FALSE(dec_state.ContinuousFrame(&frame));
447 }
448 
TEST(TestDecodingState,FrameContinuityFlexibleModeKeyFrame)449 TEST(TestDecodingState, FrameContinuityFlexibleModeKeyFrame) {
450   VCMDecodingState dec_state;
451   VCMFrameBuffer frame;
452   VCMPacket packet;
453   packet.is_first_packet_in_frame = true;
454   packet.timestamp = 1;
455   packet.seqNum = 0xffff;
456   uint8_t data[] = "I need a data pointer for this test!";
457   packet.sizeBytes = sizeof(data);
458   packet.dataPtr = data;
459   packet.video_header.codec = kRtpVideoVp9;
460 
461   RTPVideoHeaderVP9& vp9_hdr = packet.video_header.codecHeader.VP9;
462   vp9_hdr.picture_id = 10;
463   vp9_hdr.flexible_mode = true;
464 
465   FrameData frame_data;
466   frame_data.rtt_ms = 0;
467   frame_data.rolling_average_packets_per_frame = -1;
468 
469   // Key frame as first frame
470   packet.frameType = kVideoFrameKey;
471   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
472   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
473   dec_state.SetState(&frame);
474 
475   // Key frame again
476   vp9_hdr.picture_id = 11;
477   frame.Reset();
478   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
479   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
480   dec_state.SetState(&frame);
481 
482   // Ref to 11, continuous
483   frame.Reset();
484   packet.frameType = kVideoFrameDelta;
485   vp9_hdr.picture_id = 12;
486   vp9_hdr.num_ref_pics = 1;
487   vp9_hdr.pid_diff[0] = 1;
488   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
489   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
490 }
491 
TEST(TestDecodingState,FrameContinuityFlexibleModeOutOfOrderFrames)492 TEST(TestDecodingState, FrameContinuityFlexibleModeOutOfOrderFrames) {
493   VCMDecodingState dec_state;
494   VCMFrameBuffer frame;
495   VCMPacket packet;
496   packet.is_first_packet_in_frame = true;
497   packet.timestamp = 1;
498   packet.seqNum = 0xffff;
499   uint8_t data[] = "I need a data pointer for this test!";
500   packet.sizeBytes = sizeof(data);
501   packet.dataPtr = data;
502   packet.video_header.codec = kRtpVideoVp9;
503 
504   RTPVideoHeaderVP9& vp9_hdr = packet.video_header.codecHeader.VP9;
505   vp9_hdr.picture_id = 10;
506   vp9_hdr.flexible_mode = true;
507 
508   FrameData frame_data;
509   frame_data.rtt_ms = 0;
510   frame_data.rolling_average_packets_per_frame = -1;
511 
512   // Key frame as first frame
513   packet.frameType = kVideoFrameKey;
514   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
515   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
516   dec_state.SetState(&frame);
517 
518   // Ref to 10, continuous
519   frame.Reset();
520   packet.frameType = kVideoFrameDelta;
521   vp9_hdr.picture_id = 15;
522   vp9_hdr.num_ref_pics = 1;
523   vp9_hdr.pid_diff[0] = 5;
524   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
525   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
526   dec_state.SetState(&frame);
527 
528   // Out of order, last id 15, this id 12, ref to 10, continuous
529   frame.Reset();
530   vp9_hdr.picture_id = 12;
531   vp9_hdr.pid_diff[0] = 2;
532   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
533   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
534   dec_state.SetState(&frame);
535 
536   // Ref 10, 12, 15, continuous
537   frame.Reset();
538   vp9_hdr.picture_id = 20;
539   vp9_hdr.num_ref_pics = 3;
540   vp9_hdr.pid_diff[0] = 10;
541   vp9_hdr.pid_diff[1] = 8;
542   vp9_hdr.pid_diff[2] = 5;
543   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
544   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
545 }
546 
TEST(TestDecodingState,FrameContinuityFlexibleModeGeneral)547 TEST(TestDecodingState, FrameContinuityFlexibleModeGeneral) {
548   VCMDecodingState dec_state;
549   VCMFrameBuffer frame;
550   VCMPacket packet;
551   packet.is_first_packet_in_frame = true;
552   packet.timestamp = 1;
553   packet.seqNum = 0xffff;
554   uint8_t data[] = "I need a data pointer for this test!";
555   packet.sizeBytes = sizeof(data);
556   packet.dataPtr = data;
557   packet.video_header.codec = kRtpVideoVp9;
558 
559   RTPVideoHeaderVP9& vp9_hdr = packet.video_header.codecHeader.VP9;
560   vp9_hdr.picture_id = 10;
561   vp9_hdr.flexible_mode = true;
562 
563   FrameData frame_data;
564   frame_data.rtt_ms = 0;
565   frame_data.rolling_average_packets_per_frame = -1;
566 
567   // Key frame as first frame
568   packet.frameType = kVideoFrameKey;
569   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
570   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
571 
572   // Delta frame as first frame
573   frame.Reset();
574   packet.frameType = kVideoFrameDelta;
575   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
576   EXPECT_FALSE(dec_state.ContinuousFrame(&frame));
577 
578   // Key frame then delta frame
579   frame.Reset();
580   packet.frameType = kVideoFrameKey;
581   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
582   dec_state.SetState(&frame);
583   frame.Reset();
584   packet.frameType = kVideoFrameDelta;
585   vp9_hdr.num_ref_pics = 1;
586   vp9_hdr.picture_id = 15;
587   vp9_hdr.pid_diff[0] = 5;
588   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
589   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
590   dec_state.SetState(&frame);
591 
592   // Ref to 11, not continuous
593   frame.Reset();
594   vp9_hdr.picture_id = 16;
595   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
596   EXPECT_FALSE(dec_state.ContinuousFrame(&frame));
597 
598   // Ref to 15, continuous
599   frame.Reset();
600   vp9_hdr.picture_id = 16;
601   vp9_hdr.pid_diff[0] = 1;
602   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
603   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
604   dec_state.SetState(&frame);
605 
606   // Ref to 11 and 15, not continuous
607   frame.Reset();
608   vp9_hdr.picture_id = 20;
609   vp9_hdr.num_ref_pics = 2;
610   vp9_hdr.pid_diff[0] = 9;
611   vp9_hdr.pid_diff[1] = 5;
612   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
613   EXPECT_FALSE(dec_state.ContinuousFrame(&frame));
614 
615   // Ref to 10, 15 and 16, continuous
616   frame.Reset();
617   vp9_hdr.picture_id = 22;
618   vp9_hdr.num_ref_pics = 3;
619   vp9_hdr.pid_diff[0] = 12;
620   vp9_hdr.pid_diff[1] = 7;
621   vp9_hdr.pid_diff[2] = 6;
622   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
623   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
624   dec_state.SetState(&frame);
625 
626   // Key Frame, continuous
627   frame.Reset();
628   packet.frameType = kVideoFrameKey;
629   vp9_hdr.picture_id = VCMDecodingState::kFrameDecodedLength - 2;
630   vp9_hdr.num_ref_pics = 0;
631   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
632   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
633   dec_state.SetState(&frame);
634 
635   // Frame at last index, ref to KF, continuous
636   frame.Reset();
637   packet.frameType = kVideoFrameDelta;
638   vp9_hdr.picture_id = VCMDecodingState::kFrameDecodedLength - 1;
639   vp9_hdr.num_ref_pics = 1;
640   vp9_hdr.pid_diff[0] = 1;
641   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
642   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
643   dec_state.SetState(&frame);
644 
645   // Frame after wrapping buffer length, ref to last index, continuous
646   frame.Reset();
647   vp9_hdr.picture_id = 0;
648   vp9_hdr.num_ref_pics = 1;
649   vp9_hdr.pid_diff[0] = 1;
650   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
651   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
652   dec_state.SetState(&frame);
653 
654   // Frame after wrapping start frame, ref to 0, continuous
655   frame.Reset();
656   vp9_hdr.picture_id = 20;
657   vp9_hdr.num_ref_pics = 1;
658   vp9_hdr.pid_diff[0] = 20;
659   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
660   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
661   dec_state.SetState(&frame);
662 
663   // Frame after wrapping start frame, ref to 10, not continuous
664   frame.Reset();
665   vp9_hdr.picture_id = 23;
666   vp9_hdr.num_ref_pics = 1;
667   vp9_hdr.pid_diff[0] = 13;
668   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
669   EXPECT_FALSE(dec_state.ContinuousFrame(&frame));
670 
671   // Key frame, continuous
672   frame.Reset();
673   packet.frameType = kVideoFrameKey;
674   vp9_hdr.picture_id = 25;
675   vp9_hdr.num_ref_pics = 0;
676   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
677   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
678   dec_state.SetState(&frame);
679 
680   // Ref to KF, continuous
681   frame.Reset();
682   packet.frameType = kVideoFrameDelta;
683   vp9_hdr.picture_id = 26;
684   vp9_hdr.num_ref_pics = 1;
685   vp9_hdr.pid_diff[0] = 1;
686   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
687   EXPECT_TRUE(dec_state.ContinuousFrame(&frame));
688   dec_state.SetState(&frame);
689 
690   // Ref to frame previous to KF, not continuous
691   frame.Reset();
692   vp9_hdr.picture_id = 30;
693   vp9_hdr.num_ref_pics = 1;
694   vp9_hdr.pid_diff[0] = 30;
695   EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data));
696   EXPECT_FALSE(dec_state.ContinuousFrame(&frame));
697 }
698 
699 }  // namespace webrtc
700