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 "testing/gtest/include/gtest/gtest.h" 14 #include "webrtc/modules/include/module_common_types.h" 15 #include "webrtc/modules/video_coding/decoding_state.h" 16 #include "webrtc/modules/video_coding/frame_buffer.h" 17 #include "webrtc/modules/video_coding/jitter_buffer_common.h" 18 #include "webrtc/modules/video_coding/packet.h" 19 20 namespace webrtc { 21 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 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.isFirstPacket = true; 36 packet.timestamp = 1; 37 packet.seqNum = 0xffff; 38 packet.frameType = kVideoFrameDelta; 39 packet.codecSpecificHeader.codec = kRtpVideoVp8; 40 packet.codecSpecificHeader.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.isFirstPacket = false; 56 packet.codecSpecificHeader.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.codecSpecificHeader.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.codecSpecificHeader.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.codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 0; 86 packet.codecSpecificHeader.codecHeader.VP8.temporalIdx = 0; 87 packet.codecSpecificHeader.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.codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 0; 97 packet.codecSpecificHeader.codecHeader.VP8.temporalIdx = 1; 98 packet.codecSpecificHeader.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.codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 0; 108 packet.codecSpecificHeader.codecHeader.VP8.temporalIdx = 3; 109 packet.codecSpecificHeader.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.codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 1; 117 packet.codecSpecificHeader.codecHeader.VP8.temporalIdx = 2; 118 packet.codecSpecificHeader.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.codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 1; 129 packet.codecSpecificHeader.codecHeader.VP8.temporalIdx = 0; 130 packet.codecSpecificHeader.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.codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 0x00FF; 141 packet.codecSpecificHeader.codecHeader.VP8.temporalIdx = 0; 142 packet.codecSpecificHeader.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.codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 0x0000; 150 packet.codecSpecificHeader.codecHeader.VP8.temporalIdx = 0; 151 packet.codecSpecificHeader.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 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 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.codecSpecificHeader.codec = kRtpVideoVp8; 215 packet.timestamp = 0; 216 packet.seqNum = 0; 217 packet.codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 0; 218 packet.codecSpecificHeader.codecHeader.VP8.temporalIdx = 0; 219 packet.codecSpecificHeader.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.codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 0; 230 packet.codecSpecificHeader.codecHeader.VP8.temporalIdx = 1; 231 packet.codecSpecificHeader.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.codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 0; 242 packet.codecSpecificHeader.codecHeader.VP8.temporalIdx = 3; 243 packet.codecSpecificHeader.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.codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 1; 253 packet.codecSpecificHeader.codecHeader.VP8.temporalIdx = 0; 254 packet.codecSpecificHeader.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.isFirstPacket = 1; 264 packet.timestamp = 5; 265 packet.seqNum = 5; 266 packet.codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 2; 267 packet.codecSpecificHeader.codecHeader.VP8.temporalIdx = 0; 268 packet.codecSpecificHeader.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.codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 3; 280 packet.codecSpecificHeader.codecHeader.VP8.temporalIdx = 0; 281 packet.codecSpecificHeader.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.isFirstPacket = 1; 288 packet.timestamp = 8; 289 packet.seqNum = 8; 290 packet.codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 4; 291 packet.codecSpecificHeader.codecHeader.VP8.temporalIdx = 0; 292 packet.codecSpecificHeader.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.isFirstPacket = 1; 303 packet.timestamp = 9; 304 packet.seqNum = 9; 305 packet.codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 4; 306 packet.codecSpecificHeader.codecHeader.VP8.temporalIdx = 2; 307 packet.codecSpecificHeader.codecHeader.VP8.pictureId = 9; 308 packet.codecSpecificHeader.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.isFirstPacket = 1; 323 packet.markerBit = 1; 324 packet.timestamp = 0; 325 packet.seqNum = 0; 326 packet.codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 0; 327 packet.codecSpecificHeader.codecHeader.VP8.temporalIdx = 0; 328 packet.codecSpecificHeader.codecHeader.VP8.pictureId = 0; 329 packet.codecSpecificHeader.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.isFirstPacket = 1; 337 packet.markerBit = 0; 338 packet.timestamp = 1; 339 packet.seqNum = 1; 340 packet.codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 0; 341 packet.codecSpecificHeader.codecHeader.VP8.temporalIdx = 2; 342 packet.codecSpecificHeader.codecHeader.VP8.pictureId = 1; 343 packet.codecSpecificHeader.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.isFirstPacket = 1; 350 packet.markerBit = 1; 351 packet.timestamp = 2; 352 packet.seqNum = 3; 353 packet.codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 0; 354 packet.codecSpecificHeader.codecHeader.VP8.temporalIdx = 1; 355 packet.codecSpecificHeader.codecHeader.VP8.pictureId = 2; 356 packet.codecSpecificHeader.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 362 TEST(TestDecodingState, DiscontinuousPicIdContinuousSeqNum) { 363 VCMDecodingState dec_state; 364 VCMFrameBuffer frame; 365 VCMPacket packet; 366 frame.Reset(); 367 packet.frameType = kVideoFrameKey; 368 packet.codecSpecificHeader.codec = kRtpVideoVp8; 369 packet.timestamp = 0; 370 packet.seqNum = 0; 371 packet.codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 0; 372 packet.codecSpecificHeader.codecHeader.VP8.temporalIdx = 0; 373 packet.codecSpecificHeader.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.codecSpecificHeader.codecHeader.VP8.temporalIdx = 1; 388 packet.codecSpecificHeader.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 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 416 TEST(TestDecodingState, PictureIdRepeat) { 417 VCMDecodingState dec_state; 418 VCMFrameBuffer frame; 419 VCMPacket packet; 420 packet.frameType = kVideoFrameDelta; 421 packet.codecSpecificHeader.codec = kRtpVideoVp8; 422 packet.timestamp = 0; 423 packet.seqNum = 0; 424 packet.codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 0; 425 packet.codecSpecificHeader.codecHeader.VP8.temporalIdx = 0; 426 packet.codecSpecificHeader.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.codecSpecificHeader.codecHeader.VP8.temporalIdx++; 437 packet.codecSpecificHeader.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.codecSpecificHeader.codecHeader.VP8.tl0PicIdx += 3; 443 packet.codecSpecificHeader.codecHeader.VP8.temporalIdx++; 444 packet.codecSpecificHeader.codecHeader.VP8.tl0PicIdx = 1; 445 EXPECT_LE(0, frame.InsertPacket(packet, 0, kNoErrors, frame_data)); 446 EXPECT_FALSE(dec_state.ContinuousFrame(&frame)); 447 } 448 449 TEST(TestDecodingState, FrameContinuityFlexibleModeKeyFrame) { 450 VCMDecodingState dec_state; 451 VCMFrameBuffer frame; 452 VCMPacket packet; 453 packet.isFirstPacket = 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.codecSpecificHeader.codec = kRtpVideoVp9; 460 461 RTPVideoHeaderVP9& vp9_hdr = packet.codecSpecificHeader.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 492 TEST(TestDecodingState, FrameContinuityFlexibleModeOutOfOrderFrames) { 493 VCMDecodingState dec_state; 494 VCMFrameBuffer frame; 495 VCMPacket packet; 496 packet.isFirstPacket = 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.codecSpecificHeader.codec = kRtpVideoVp9; 503 504 RTPVideoHeaderVP9& vp9_hdr = packet.codecSpecificHeader.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 547 TEST(TestDecodingState, FrameContinuityFlexibleModeGeneral) { 548 VCMDecodingState dec_state; 549 VCMFrameBuffer frame; 550 VCMPacket packet; 551 packet.isFirstPacket = 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.codecSpecificHeader.codec = kRtpVideoVp9; 558 559 RTPVideoHeaderVP9& vp9_hdr = packet.codecSpecificHeader.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
