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