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