jitter_buffer_unittest.cc (66697B)
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/jitter_buffer.h" 12 13 #include <cstddef> 14 #include <cstdint> 15 #include <cstring> 16 #include <memory> 17 #include <vector> 18 19 #include "absl/memory/memory.h" 20 #include "api/field_trials.h" 21 #include "api/rtp_headers.h" 22 #include "api/video/video_codec_type.h" 23 #include "api/video/video_frame_type.h" 24 #include "common_video/h264/h264_common.h" 25 #include "modules/rtp_rtcp/source/rtp_video_header.h" 26 #include "modules/video_coding/codecs/h264/include/h264_globals.h" 27 #include "modules/video_coding/codecs/vp9/include/vp9_globals.h" 28 #include "modules/video_coding/deprecated/event_wrapper.h" 29 #include "modules/video_coding/deprecated/jitter_buffer_common.h" 30 #include "modules/video_coding/deprecated/packet.h" 31 #include "modules/video_coding/deprecated/stream_generator.h" 32 #include "modules/video_coding/encoded_frame.h" 33 #include "system_wrappers/include/clock.h" 34 #include "test/create_test_field_trials.h" 35 #include "test/gtest.h" 36 37 namespace webrtc { 38 39 class TestBasicJitterBuffer : public ::testing::Test { 40 protected: 41 TestBasicJitterBuffer() {} 42 void SetUp() override { 43 clock_.reset(new SimulatedClock(0)); 44 jitter_buffer_.reset(new VCMJitterBuffer( 45 clock_.get(), absl::WrapUnique(EventWrapper::Create()), field_trials_)); 46 jitter_buffer_->Start(); 47 seq_num_ = 1234; 48 timestamp_ = 0; 49 size_ = 1400; 50 // Data vector - 0, 0, 0x80, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0x80, 3.... 51 data_[0] = 0; 52 data_[1] = 0; 53 data_[2] = 0x80; 54 int count = 3; 55 for (unsigned int i = 3; i < sizeof(data_) - 3; ++i) { 56 data_[i] = count; 57 count++; 58 if (count == 10) { 59 data_[i + 1] = 0; 60 data_[i + 2] = 0; 61 data_[i + 3] = 0x80; 62 count = 3; 63 i += 3; 64 } 65 } 66 RTPHeader rtp_header; 67 RTPVideoHeader video_header; 68 rtp_header.sequenceNumber = seq_num_; 69 rtp_header.timestamp = timestamp_; 70 rtp_header.markerBit = true; 71 video_header.codec = kVideoCodecGeneric; 72 video_header.is_first_packet_in_frame = true; 73 video_header.frame_type = VideoFrameType::kVideoFrameDelta; 74 packet_.reset(new VCMPacket(data_, size_, rtp_header, video_header, 75 /*ntp_time_ms=*/0, clock_->CurrentTime())); 76 } 77 78 VCMEncodedFrame* DecodeCompleteFrame() { 79 VCMEncodedFrame* found_frame = jitter_buffer_->NextCompleteFrame(10); 80 if (!found_frame) 81 return nullptr; 82 return jitter_buffer_->ExtractAndSetDecode(found_frame->RtpTimestamp()); 83 } 84 85 void CheckOutFrame(VCMEncodedFrame* frame_out, 86 unsigned int size, 87 bool startCode) { 88 ASSERT_TRUE(frame_out); 89 90 const uint8_t* outData = frame_out->data(); 91 unsigned int i = 0; 92 93 if (startCode) { 94 EXPECT_EQ(0, outData[0]); 95 EXPECT_EQ(0, outData[1]); 96 EXPECT_EQ(0, outData[2]); 97 EXPECT_EQ(1, outData[3]); 98 i += 4; 99 } 100 101 EXPECT_EQ(size, frame_out->size()); 102 int count = 3; 103 for (; i < size; i++) { 104 if (outData[i] == 0 && outData[i + 1] == 0 && outData[i + 2] == 0x80) { 105 i += 2; 106 } else if (startCode && outData[i] == 0 && outData[i + 1] == 0) { 107 EXPECT_EQ(0, outData[0]); 108 EXPECT_EQ(0, outData[1]); 109 EXPECT_EQ(0, outData[2]); 110 EXPECT_EQ(1, outData[3]); 111 i += 3; 112 } else { 113 EXPECT_EQ(count, outData[i]); 114 count++; 115 if (count == 10) { 116 count = 3; 117 } 118 } 119 } 120 } 121 122 uint16_t seq_num_; 123 uint32_t timestamp_; 124 int size_; 125 uint8_t data_[1500]; 126 FieldTrials field_trials_ = CreateTestFieldTrials(); 127 std::unique_ptr<VCMPacket> packet_; 128 std::unique_ptr<SimulatedClock> clock_; 129 std::unique_ptr<VCMJitterBuffer> jitter_buffer_; 130 }; 131 132 class TestRunningJitterBuffer : public ::testing::Test { 133 protected: 134 enum { kDataBufferSize = 10 }; 135 136 void SetUp() override { 137 clock_.reset(new SimulatedClock(0)); 138 max_nack_list_size_ = 150; 139 oldest_packet_to_nack_ = 250; 140 jitter_buffer_ = new VCMJitterBuffer( 141 clock_.get(), absl::WrapUnique(EventWrapper::Create()), field_trials_); 142 stream_generator_ = new StreamGenerator(0, clock_->TimeInMilliseconds()); 143 jitter_buffer_->Start(); 144 jitter_buffer_->SetNackSettings(max_nack_list_size_, oldest_packet_to_nack_, 145 0); 146 memset(data_buffer_, 0, kDataBufferSize); 147 } 148 149 void TearDown() override { 150 jitter_buffer_->Stop(); 151 delete stream_generator_; 152 delete jitter_buffer_; 153 } 154 155 VCMFrameBufferEnum InsertPacketAndPop(int index) { 156 VCMPacket packet; 157 packet.dataPtr = data_buffer_; 158 bool packet_available = stream_generator_->PopPacket(&packet, index); 159 EXPECT_TRUE(packet_available); 160 if (!packet_available) 161 return kGeneralError; // Return here to avoid crashes below. 162 bool retransmitted = false; 163 return jitter_buffer_->InsertPacket(packet, &retransmitted); 164 } 165 166 VCMFrameBufferEnum InsertPacket(int index) { 167 VCMPacket packet; 168 packet.dataPtr = data_buffer_; 169 bool packet_available = stream_generator_->GetPacket(&packet, index); 170 EXPECT_TRUE(packet_available); 171 if (!packet_available) 172 return kGeneralError; // Return here to avoid crashes below. 173 bool retransmitted = false; 174 return jitter_buffer_->InsertPacket(packet, &retransmitted); 175 } 176 177 VCMFrameBufferEnum InsertFrame(VideoFrameType frame_type) { 178 stream_generator_->GenerateFrame( 179 frame_type, (frame_type != VideoFrameType::kEmptyFrame) ? 1 : 0, 180 (frame_type == VideoFrameType::kEmptyFrame) ? 1 : 0, 181 clock_->TimeInMilliseconds()); 182 VCMFrameBufferEnum ret = InsertPacketAndPop(0); 183 clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs); 184 return ret; 185 } 186 187 VCMFrameBufferEnum InsertFrames(int num_frames, VideoFrameType frame_type) { 188 VCMFrameBufferEnum ret_for_all = kNoError; 189 for (int i = 0; i < num_frames; ++i) { 190 VCMFrameBufferEnum ret = InsertFrame(frame_type); 191 if (ret < kNoError) { 192 ret_for_all = ret; 193 } else if (ret_for_all >= kNoError) { 194 ret_for_all = ret; 195 } 196 } 197 return ret_for_all; 198 } 199 200 void DropFrame(int num_packets) { 201 stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameDelta, 202 num_packets, 0, 203 clock_->TimeInMilliseconds()); 204 for (int i = 0; i < num_packets; ++i) 205 stream_generator_->DropLastPacket(); 206 clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs); 207 } 208 209 bool DecodeCompleteFrame() { 210 VCMEncodedFrame* found_frame = jitter_buffer_->NextCompleteFrame(0); 211 if (!found_frame) 212 return false; 213 214 VCMEncodedFrame* frame = 215 jitter_buffer_->ExtractAndSetDecode(found_frame->RtpTimestamp()); 216 bool ret = (frame != nullptr); 217 jitter_buffer_->ReleaseFrame(frame); 218 return ret; 219 } 220 221 FieldTrials field_trials_ = CreateTestFieldTrials(); 222 VCMJitterBuffer* jitter_buffer_; 223 StreamGenerator* stream_generator_; 224 std::unique_ptr<SimulatedClock> clock_; 225 size_t max_nack_list_size_; 226 int oldest_packet_to_nack_; 227 uint8_t data_buffer_[kDataBufferSize]; 228 }; 229 230 class TestJitterBufferNack : public TestRunningJitterBuffer { 231 protected: 232 TestJitterBufferNack() {} 233 void SetUp() override { TestRunningJitterBuffer::SetUp(); } 234 235 void TearDown() override { TestRunningJitterBuffer::TearDown(); } 236 }; 237 238 TEST_F(TestBasicJitterBuffer, StopRunning) { 239 jitter_buffer_->Stop(); 240 EXPECT_TRUE(nullptr == DecodeCompleteFrame()); 241 jitter_buffer_->Start(); 242 243 // No packets inserted. 244 EXPECT_TRUE(nullptr == DecodeCompleteFrame()); 245 } 246 247 TEST_F(TestBasicJitterBuffer, SinglePacketFrame) { 248 // Always start with a complete key frame when not allowing errors. 249 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 250 packet_->video_header.is_first_packet_in_frame = true; 251 packet_->markerBit = true; 252 packet_->timestamp += 123 * 90; 253 254 // Insert the packet to the jitter buffer and get a frame. 255 bool retransmitted = false; 256 EXPECT_EQ(kCompleteSession, 257 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 258 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 259 CheckOutFrame(frame_out, size_, false); 260 EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType()); 261 jitter_buffer_->ReleaseFrame(frame_out); 262 } 263 264 TEST_F(TestBasicJitterBuffer, DualPacketFrame) { 265 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 266 packet_->video_header.is_first_packet_in_frame = true; 267 packet_->markerBit = false; 268 269 bool retransmitted = false; 270 EXPECT_EQ(kIncomplete, 271 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 272 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 273 // Should not be complete. 274 EXPECT_TRUE(frame_out == nullptr); 275 276 ++seq_num_; 277 packet_->video_header.is_first_packet_in_frame = false; 278 packet_->markerBit = true; 279 packet_->seqNum = seq_num_; 280 281 EXPECT_EQ(kCompleteSession, 282 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 283 284 frame_out = DecodeCompleteFrame(); 285 CheckOutFrame(frame_out, 2 * size_, false); 286 287 EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType()); 288 jitter_buffer_->ReleaseFrame(frame_out); 289 } 290 291 TEST_F(TestBasicJitterBuffer, 100PacketKeyFrame) { 292 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 293 packet_->video_header.is_first_packet_in_frame = true; 294 packet_->markerBit = false; 295 296 bool retransmitted = false; 297 EXPECT_EQ(kIncomplete, 298 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 299 300 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 301 302 // Frame should not be complete. 303 EXPECT_TRUE(frame_out == nullptr); 304 305 // Insert 98 frames. 306 int loop = 0; 307 do { 308 seq_num_++; 309 packet_->video_header.is_first_packet_in_frame = false; 310 packet_->markerBit = false; 311 packet_->seqNum = seq_num_; 312 313 EXPECT_EQ(kIncomplete, 314 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 315 loop++; 316 } while (loop < 98); 317 318 // Insert last packet. 319 ++seq_num_; 320 packet_->video_header.is_first_packet_in_frame = false; 321 packet_->markerBit = true; 322 packet_->seqNum = seq_num_; 323 324 EXPECT_EQ(kCompleteSession, 325 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 326 327 frame_out = DecodeCompleteFrame(); 328 329 CheckOutFrame(frame_out, 100 * size_, false); 330 EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType()); 331 jitter_buffer_->ReleaseFrame(frame_out); 332 } 333 334 TEST_F(TestBasicJitterBuffer, 100PacketDeltaFrame) { 335 // Always start with a complete key frame. 336 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 337 packet_->video_header.is_first_packet_in_frame = true; 338 packet_->markerBit = true; 339 340 bool retransmitted = false; 341 EXPECT_EQ(kCompleteSession, 342 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 343 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 344 EXPECT_FALSE(frame_out == nullptr); 345 jitter_buffer_->ReleaseFrame(frame_out); 346 347 ++seq_num_; 348 packet_->seqNum = seq_num_; 349 packet_->markerBit = false; 350 packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta; 351 packet_->timestamp += 33 * 90; 352 353 EXPECT_EQ(kIncomplete, 354 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 355 356 frame_out = DecodeCompleteFrame(); 357 358 // Frame should not be complete. 359 EXPECT_TRUE(frame_out == nullptr); 360 361 packet_->video_header.is_first_packet_in_frame = false; 362 // Insert 98 frames. 363 int loop = 0; 364 do { 365 ++seq_num_; 366 packet_->seqNum = seq_num_; 367 368 // Insert a packet into a frame. 369 EXPECT_EQ(kIncomplete, 370 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 371 loop++; 372 } while (loop < 98); 373 374 // Insert the last packet. 375 ++seq_num_; 376 packet_->video_header.is_first_packet_in_frame = false; 377 packet_->markerBit = true; 378 packet_->seqNum = seq_num_; 379 380 EXPECT_EQ(kCompleteSession, 381 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 382 383 frame_out = DecodeCompleteFrame(); 384 385 CheckOutFrame(frame_out, 100 * size_, false); 386 EXPECT_EQ(VideoFrameType::kVideoFrameDelta, frame_out->FrameType()); 387 jitter_buffer_->ReleaseFrame(frame_out); 388 } 389 390 TEST_F(TestBasicJitterBuffer, PacketReorderingReverseOrder) { 391 // Insert the "first" packet last. 392 seq_num_ += 100; 393 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 394 packet_->video_header.is_first_packet_in_frame = false; 395 packet_->markerBit = true; 396 packet_->seqNum = seq_num_; 397 packet_->timestamp = timestamp_; 398 399 bool retransmitted = false; 400 EXPECT_EQ(kIncomplete, 401 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 402 403 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 404 405 EXPECT_TRUE(frame_out == nullptr); 406 407 // Insert 98 packets. 408 int loop = 0; 409 do { 410 seq_num_--; 411 packet_->video_header.is_first_packet_in_frame = false; 412 packet_->markerBit = false; 413 packet_->seqNum = seq_num_; 414 415 EXPECT_EQ(kIncomplete, 416 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 417 loop++; 418 } while (loop < 98); 419 420 // Insert the last packet. 421 seq_num_--; 422 packet_->video_header.is_first_packet_in_frame = true; 423 packet_->markerBit = false; 424 packet_->seqNum = seq_num_; 425 426 EXPECT_EQ(kCompleteSession, 427 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 428 429 frame_out = DecodeCompleteFrame(); 430 431 CheckOutFrame(frame_out, 100 * size_, false); 432 433 EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType()); 434 jitter_buffer_->ReleaseFrame(frame_out); 435 } 436 437 TEST_F(TestBasicJitterBuffer, FrameReordering2Frames2PacketsEach) { 438 packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta; 439 packet_->video_header.is_first_packet_in_frame = true; 440 packet_->markerBit = false; 441 442 bool retransmitted = false; 443 EXPECT_EQ(kIncomplete, 444 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 445 446 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 447 448 EXPECT_TRUE(frame_out == nullptr); 449 450 seq_num_++; 451 packet_->video_header.is_first_packet_in_frame = false; 452 packet_->markerBit = true; 453 packet_->seqNum = seq_num_; 454 455 EXPECT_EQ(kCompleteSession, 456 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 457 458 // check that we fail to get frame since seqnum is not continuous 459 frame_out = DecodeCompleteFrame(); 460 EXPECT_TRUE(frame_out == nullptr); 461 462 seq_num_ -= 3; 463 timestamp_ -= 33 * 90; 464 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 465 packet_->video_header.is_first_packet_in_frame = true; 466 packet_->markerBit = false; 467 packet_->seqNum = seq_num_; 468 packet_->timestamp = timestamp_; 469 470 EXPECT_EQ(kIncomplete, 471 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 472 473 frame_out = DecodeCompleteFrame(); 474 475 // It should not be complete. 476 EXPECT_TRUE(frame_out == nullptr); 477 478 seq_num_++; 479 packet_->video_header.is_first_packet_in_frame = false; 480 packet_->markerBit = true; 481 packet_->seqNum = seq_num_; 482 483 EXPECT_EQ(kCompleteSession, 484 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 485 486 frame_out = DecodeCompleteFrame(); 487 CheckOutFrame(frame_out, 2 * size_, false); 488 EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType()); 489 jitter_buffer_->ReleaseFrame(frame_out); 490 491 frame_out = DecodeCompleteFrame(); 492 CheckOutFrame(frame_out, 2 * size_, false); 493 EXPECT_EQ(VideoFrameType::kVideoFrameDelta, frame_out->FrameType()); 494 jitter_buffer_->ReleaseFrame(frame_out); 495 } 496 497 TEST_F(TestBasicJitterBuffer, TestReorderingWithPadding) { 498 jitter_buffer_->SetNackSettings(kMaxNumberOfFrames, kMaxNumberOfFrames, 0); 499 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 500 packet_->video_header.is_first_packet_in_frame = true; 501 packet_->markerBit = true; 502 503 // Send in an initial good packet/frame (Frame A) to start things off. 504 bool retransmitted = false; 505 EXPECT_EQ(kCompleteSession, 506 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 507 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 508 EXPECT_TRUE(frame_out != nullptr); 509 jitter_buffer_->ReleaseFrame(frame_out); 510 511 // Now send in a complete delta frame (Frame C), but with a sequence number 512 // gap. No pic index either, so no temporal scalability cheating :) 513 packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta; 514 // Leave a gap of 2 sequence numbers and two frames. 515 packet_->seqNum = seq_num_ + 3; 516 packet_->timestamp = timestamp_ + (66 * 90); 517 // Still isFirst = marker = true. 518 // Session should be complete (frame is complete), but there's nothing to 519 // decode yet. 520 EXPECT_EQ(kCompleteSession, 521 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 522 frame_out = DecodeCompleteFrame(); 523 EXPECT_TRUE(frame_out == nullptr); 524 525 // Now send in a complete delta frame (Frame B) that is continuous from A, but 526 // doesn't fill the full gap to C. The rest of the gap is going to be padding. 527 packet_->seqNum = seq_num_ + 1; 528 packet_->timestamp = timestamp_ + (33 * 90); 529 // Still isFirst = marker = true. 530 EXPECT_EQ(kCompleteSession, 531 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 532 frame_out = DecodeCompleteFrame(); 533 EXPECT_TRUE(frame_out != nullptr); 534 jitter_buffer_->ReleaseFrame(frame_out); 535 536 // But Frame C isn't continuous yet. 537 frame_out = DecodeCompleteFrame(); 538 EXPECT_TRUE(frame_out == nullptr); 539 540 // Add in the padding. These are empty packets (data length is 0) with no 541 // marker bit and matching the timestamp of Frame B. 542 RTPHeader rtp_header; 543 RTPVideoHeader video_header; 544 rtp_header.sequenceNumber = seq_num_ + 2; 545 rtp_header.timestamp = timestamp_ + (33 * 90); 546 rtp_header.markerBit = false; 547 video_header.codec = kVideoCodecGeneric; 548 video_header.frame_type = VideoFrameType::kEmptyFrame; 549 VCMPacket empty_packet(data_, 0, rtp_header, video_header, 550 /*ntp_time_ms=*/0, clock_->CurrentTime()); 551 EXPECT_EQ(kOldPacket, 552 jitter_buffer_->InsertPacket(empty_packet, &retransmitted)); 553 empty_packet.seqNum += 1; 554 EXPECT_EQ(kOldPacket, 555 jitter_buffer_->InsertPacket(empty_packet, &retransmitted)); 556 557 // But now Frame C should be ready! 558 frame_out = DecodeCompleteFrame(); 559 EXPECT_TRUE(frame_out != nullptr); 560 jitter_buffer_->ReleaseFrame(frame_out); 561 } 562 563 TEST_F(TestBasicJitterBuffer, DuplicatePackets) { 564 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 565 packet_->video_header.is_first_packet_in_frame = true; 566 packet_->markerBit = false; 567 packet_->seqNum = seq_num_; 568 packet_->timestamp = timestamp_; 569 EXPECT_EQ(0, jitter_buffer_->num_packets()); 570 EXPECT_EQ(0, jitter_buffer_->num_duplicated_packets()); 571 572 bool retransmitted = false; 573 EXPECT_EQ(kIncomplete, 574 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 575 576 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 577 578 EXPECT_TRUE(frame_out == nullptr); 579 EXPECT_EQ(1, jitter_buffer_->num_packets()); 580 EXPECT_EQ(0, jitter_buffer_->num_duplicated_packets()); 581 582 // Insert a packet into a frame. 583 EXPECT_EQ(kDuplicatePacket, 584 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 585 EXPECT_EQ(2, jitter_buffer_->num_packets()); 586 EXPECT_EQ(1, jitter_buffer_->num_duplicated_packets()); 587 588 seq_num_++; 589 packet_->seqNum = seq_num_; 590 packet_->markerBit = true; 591 packet_->video_header.is_first_packet_in_frame = false; 592 593 EXPECT_EQ(kCompleteSession, 594 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 595 596 frame_out = DecodeCompleteFrame(); 597 ASSERT_TRUE(frame_out != nullptr); 598 CheckOutFrame(frame_out, 2 * size_, false); 599 600 EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType()); 601 EXPECT_EQ(3, jitter_buffer_->num_packets()); 602 EXPECT_EQ(1, jitter_buffer_->num_duplicated_packets()); 603 jitter_buffer_->ReleaseFrame(frame_out); 604 } 605 606 TEST_F(TestBasicJitterBuffer, DuplicatePreviousDeltaFramePacket) { 607 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 608 packet_->video_header.is_first_packet_in_frame = true; 609 packet_->markerBit = true; 610 packet_->seqNum = seq_num_; 611 packet_->timestamp = timestamp_; 612 EXPECT_EQ(0, jitter_buffer_->num_packets()); 613 EXPECT_EQ(0, jitter_buffer_->num_duplicated_packets()); 614 615 bool retransmitted = false; 616 // Insert first complete frame. 617 EXPECT_EQ(kCompleteSession, 618 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 619 620 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 621 ASSERT_TRUE(frame_out != nullptr); 622 CheckOutFrame(frame_out, size_, false); 623 EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType()); 624 jitter_buffer_->ReleaseFrame(frame_out); 625 626 // Insert 3 delta frames. 627 for (uint16_t i = 1; i <= 3; ++i) { 628 packet_->seqNum = seq_num_ + i; 629 packet_->timestamp = timestamp_ + (i * 33) * 90; 630 packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta; 631 EXPECT_EQ(kCompleteSession, 632 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 633 EXPECT_EQ(i + 1, jitter_buffer_->num_packets()); 634 EXPECT_EQ(0, jitter_buffer_->num_duplicated_packets()); 635 } 636 637 // Retransmit second delta frame. 638 packet_->seqNum = seq_num_ + 2; 639 packet_->timestamp = timestamp_ + 66 * 90; 640 641 EXPECT_EQ(kDuplicatePacket, 642 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 643 644 EXPECT_EQ(5, jitter_buffer_->num_packets()); 645 EXPECT_EQ(1, jitter_buffer_->num_duplicated_packets()); 646 647 // Should be able to decode 3 delta frames, key frame already decoded. 648 for (size_t i = 0; i < 3; ++i) { 649 frame_out = DecodeCompleteFrame(); 650 ASSERT_TRUE(frame_out != nullptr); 651 CheckOutFrame(frame_out, size_, false); 652 EXPECT_EQ(VideoFrameType::kVideoFrameDelta, frame_out->FrameType()); 653 jitter_buffer_->ReleaseFrame(frame_out); 654 } 655 } 656 657 TEST_F(TestBasicJitterBuffer, TestSkipForwardVp9) { 658 // Verify that JB skips forward to next base layer frame. 659 // ------------------------------------------------- 660 // | 65485 | 65486 | 65487 | 65488 | 65489 | ... 661 // | pid:5 | pid:6 | pid:7 | pid:8 | pid:9 | ... 662 // | tid:0 | tid:2 | tid:1 | tid:2 | tid:0 | ... 663 // | ss | x | x | x | | 664 // ------------------------------------------------- 665 // |<----------tl0idx:200--------->|<---tl0idx:201--- 666 667 jitter_buffer_->SetNackSettings(kMaxNumberOfFrames, kMaxNumberOfFrames, 0); 668 auto& vp9_header = 669 packet_->video_header.video_type_header.emplace<RTPVideoHeaderVP9>(); 670 671 bool re = false; 672 packet_->video_header.codec = kVideoCodecVP9; 673 packet_->video_header.is_first_packet_in_frame = true; 674 packet_->markerBit = true; 675 vp9_header.flexible_mode = false; 676 vp9_header.spatial_idx = 0; 677 vp9_header.beginning_of_frame = true; 678 vp9_header.end_of_frame = true; 679 vp9_header.temporal_up_switch = false; 680 681 packet_->seqNum = 65485; 682 packet_->timestamp = 1000; 683 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 684 vp9_header.picture_id = 5; 685 vp9_header.tl0_pic_idx = 200; 686 vp9_header.temporal_idx = 0; 687 vp9_header.ss_data_available = true; 688 vp9_header.gof.SetGofInfoVP9( 689 kTemporalStructureMode3); // kTemporalStructureMode3: 0-2-1-2.. 690 EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &re)); 691 692 // Insert next temporal layer 0. 693 packet_->seqNum = 65489; 694 packet_->timestamp = 13000; 695 packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta; 696 vp9_header.picture_id = 9; 697 vp9_header.tl0_pic_idx = 201; 698 vp9_header.temporal_idx = 0; 699 vp9_header.ss_data_available = false; 700 EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &re)); 701 702 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 703 EXPECT_EQ(1000U, frame_out->RtpTimestamp()); 704 EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType()); 705 jitter_buffer_->ReleaseFrame(frame_out); 706 707 frame_out = DecodeCompleteFrame(); 708 EXPECT_EQ(13000U, frame_out->RtpTimestamp()); 709 EXPECT_EQ(VideoFrameType::kVideoFrameDelta, frame_out->FrameType()); 710 jitter_buffer_->ReleaseFrame(frame_out); 711 } 712 713 TEST_F(TestBasicJitterBuffer, ReorderedVp9SsData_3TlLayers) { 714 // Verify that frames are updated with SS data when SS packet is reordered. 715 // -------------------------------- 716 // | 65486 | 65487 | 65485 |... 717 // | pid:6 | pid:7 | pid:5 |... 718 // | tid:2 | tid:1 | tid:0 |... 719 // | | | ss | 720 // -------------------------------- 721 // |<--------tl0idx:200--------->| 722 723 auto& vp9_header = 724 packet_->video_header.video_type_header.emplace<RTPVideoHeaderVP9>(); 725 726 bool re = false; 727 packet_->video_header.codec = kVideoCodecVP9; 728 packet_->video_header.is_first_packet_in_frame = true; 729 packet_->markerBit = true; 730 vp9_header.flexible_mode = false; 731 vp9_header.spatial_idx = 0; 732 vp9_header.beginning_of_frame = true; 733 vp9_header.end_of_frame = true; 734 vp9_header.tl0_pic_idx = 200; 735 736 packet_->seqNum = 65486; 737 packet_->timestamp = 6000; 738 packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta; 739 vp9_header.picture_id = 6; 740 vp9_header.temporal_idx = 2; 741 vp9_header.temporal_up_switch = true; 742 EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &re)); 743 744 packet_->seqNum = 65487; 745 packet_->timestamp = 9000; 746 packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta; 747 vp9_header.picture_id = 7; 748 vp9_header.temporal_idx = 1; 749 vp9_header.temporal_up_switch = true; 750 EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &re)); 751 752 // Insert first frame with SS data. 753 packet_->seqNum = 65485; 754 packet_->timestamp = 3000; 755 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 756 packet_->video_header.width = 352; 757 packet_->video_header.height = 288; 758 vp9_header.picture_id = 5; 759 vp9_header.temporal_idx = 0; 760 vp9_header.temporal_up_switch = false; 761 vp9_header.ss_data_available = true; 762 vp9_header.gof.SetGofInfoVP9( 763 kTemporalStructureMode3); // kTemporalStructureMode3: 0-2-1-2.. 764 EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &re)); 765 766 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 767 EXPECT_EQ(3000U, frame_out->RtpTimestamp()); 768 EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType()); 769 EXPECT_EQ(0, frame_out->CodecSpecific()->codecSpecific.VP9.temporal_idx); 770 EXPECT_FALSE( 771 frame_out->CodecSpecific()->codecSpecific.VP9.temporal_up_switch); 772 jitter_buffer_->ReleaseFrame(frame_out); 773 774 frame_out = DecodeCompleteFrame(); 775 EXPECT_EQ(6000U, frame_out->RtpTimestamp()); 776 EXPECT_EQ(VideoFrameType::kVideoFrameDelta, frame_out->FrameType()); 777 EXPECT_EQ(2, frame_out->CodecSpecific()->codecSpecific.VP9.temporal_idx); 778 EXPECT_TRUE(frame_out->CodecSpecific()->codecSpecific.VP9.temporal_up_switch); 779 jitter_buffer_->ReleaseFrame(frame_out); 780 781 frame_out = DecodeCompleteFrame(); 782 EXPECT_EQ(9000U, frame_out->RtpTimestamp()); 783 EXPECT_EQ(VideoFrameType::kVideoFrameDelta, frame_out->FrameType()); 784 EXPECT_EQ(1, frame_out->CodecSpecific()->codecSpecific.VP9.temporal_idx); 785 EXPECT_TRUE(frame_out->CodecSpecific()->codecSpecific.VP9.temporal_up_switch); 786 jitter_buffer_->ReleaseFrame(frame_out); 787 } 788 789 TEST_F(TestBasicJitterBuffer, ReorderedVp9SsData_2Tl2SLayers) { 790 // Verify that frames are updated with SS data when SS packet is reordered. 791 // ----------------------------------------- 792 // | 65486 | 65487 | 65485 | 65484 |... 793 // | pid:6 | pid:6 | pid:5 | pid:5 |... 794 // | tid:1 | tid:1 | tid:0 | tid:0 |... 795 // | sid:0 | sid:1 | sid:1 | sid:0 |... 796 // | t:6000 | t:6000 | t:3000 | t:3000 | 797 // | | | | ss | 798 // ----------------------------------------- 799 // |<-----------tl0idx:200------------>| 800 801 auto& vp9_header = 802 packet_->video_header.video_type_header.emplace<RTPVideoHeaderVP9>(); 803 804 bool re = false; 805 packet_->video_header.codec = kVideoCodecVP9; 806 vp9_header.flexible_mode = false; 807 vp9_header.beginning_of_frame = true; 808 vp9_header.end_of_frame = true; 809 vp9_header.tl0_pic_idx = 200; 810 811 packet_->video_header.is_first_packet_in_frame = true; 812 packet_->markerBit = false; 813 packet_->seqNum = 65486; 814 packet_->timestamp = 6000; 815 packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta; 816 vp9_header.spatial_idx = 0; 817 vp9_header.picture_id = 6; 818 vp9_header.temporal_idx = 1; 819 vp9_header.temporal_up_switch = true; 820 EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_, &re)); 821 822 packet_->video_header.is_first_packet_in_frame = false; 823 packet_->markerBit = true; 824 packet_->seqNum = 65487; 825 packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta; 826 vp9_header.spatial_idx = 1; 827 vp9_header.picture_id = 6; 828 vp9_header.temporal_idx = 1; 829 vp9_header.temporal_up_switch = true; 830 EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &re)); 831 832 packet_->video_header.is_first_packet_in_frame = false; 833 packet_->markerBit = true; 834 packet_->seqNum = 65485; 835 packet_->timestamp = 3000; 836 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 837 vp9_header.spatial_idx = 1; 838 vp9_header.picture_id = 5; 839 vp9_header.temporal_idx = 0; 840 vp9_header.temporal_up_switch = false; 841 EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_, &re)); 842 843 // Insert first frame with SS data. 844 packet_->video_header.is_first_packet_in_frame = true; 845 packet_->markerBit = false; 846 packet_->seqNum = 65484; 847 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 848 packet_->video_header.width = 352; 849 packet_->video_header.height = 288; 850 vp9_header.spatial_idx = 0; 851 vp9_header.picture_id = 5; 852 vp9_header.temporal_idx = 0; 853 vp9_header.temporal_up_switch = false; 854 vp9_header.ss_data_available = true; 855 vp9_header.gof.SetGofInfoVP9( 856 kTemporalStructureMode2); // kTemporalStructureMode3: 0-1-0-1.. 857 EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &re)); 858 859 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 860 EXPECT_EQ(3000U, frame_out->RtpTimestamp()); 861 EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType()); 862 EXPECT_EQ(0, frame_out->CodecSpecific()->codecSpecific.VP9.temporal_idx); 863 EXPECT_FALSE( 864 frame_out->CodecSpecific()->codecSpecific.VP9.temporal_up_switch); 865 jitter_buffer_->ReleaseFrame(frame_out); 866 867 frame_out = DecodeCompleteFrame(); 868 EXPECT_EQ(6000U, frame_out->RtpTimestamp()); 869 EXPECT_EQ(VideoFrameType::kVideoFrameDelta, frame_out->FrameType()); 870 EXPECT_EQ(1, frame_out->CodecSpecific()->codecSpecific.VP9.temporal_idx); 871 EXPECT_TRUE(frame_out->CodecSpecific()->codecSpecific.VP9.temporal_up_switch); 872 jitter_buffer_->ReleaseFrame(frame_out); 873 } 874 875 TEST_F(TestBasicJitterBuffer, H264InsertStartCode) { 876 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 877 packet_->video_header.is_first_packet_in_frame = true; 878 packet_->markerBit = false; 879 packet_->seqNum = seq_num_; 880 packet_->timestamp = timestamp_; 881 packet_->insertStartCode = true; 882 883 bool retransmitted = false; 884 EXPECT_EQ(kIncomplete, 885 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 886 887 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 888 889 // Frame should not be complete. 890 EXPECT_TRUE(frame_out == nullptr); 891 892 seq_num_++; 893 packet_->video_header.is_first_packet_in_frame = false; 894 packet_->markerBit = true; 895 packet_->seqNum = seq_num_; 896 897 EXPECT_EQ(kCompleteSession, 898 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 899 900 frame_out = DecodeCompleteFrame(); 901 CheckOutFrame(frame_out, size_ * 2 + 4 * 2, true); 902 EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType()); 903 jitter_buffer_->ReleaseFrame(frame_out); 904 } 905 906 TEST_F(TestBasicJitterBuffer, SpsAndPpsHandling) { 907 auto& h264_header = 908 packet_->video_header.video_type_header.emplace<RTPVideoHeaderH264>(); 909 packet_->timestamp = timestamp_; 910 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 911 packet_->video_header.is_first_packet_in_frame = true; 912 packet_->markerBit = true; 913 packet_->video_header.codec = kVideoCodecH264; 914 h264_header.nalu_type = H264::NaluType::kIdr; 915 h264_header.nalus = { 916 {.type = H264::NaluType::kIdr, .sps_id = -1, .pps_id = 0}}; 917 bool retransmitted = false; 918 EXPECT_EQ(kCompleteSession, 919 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 920 // Not decodable since sps and pps are missing. 921 EXPECT_EQ(nullptr, DecodeCompleteFrame()); 922 923 timestamp_ += 3000; 924 packet_->timestamp = timestamp_; 925 ++seq_num_; 926 packet_->seqNum = seq_num_; 927 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 928 packet_->video_header.is_first_packet_in_frame = true; 929 packet_->markerBit = false; 930 packet_->video_header.codec = kVideoCodecH264; 931 h264_header.nalu_type = H264::NaluType::kStapA; 932 h264_header.nalus = { 933 {.type = H264::NaluType::kSps, .sps_id = 0, .pps_id = -1}, 934 {.type = H264::NaluType::kPps, .sps_id = 0, .pps_id = 0}}; 935 // Not complete since the marker bit hasn't been received. 936 EXPECT_EQ(kIncomplete, 937 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 938 939 ++seq_num_; 940 packet_->seqNum = seq_num_; 941 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 942 packet_->video_header.is_first_packet_in_frame = false; 943 packet_->markerBit = true; 944 packet_->video_header.codec = kVideoCodecH264; 945 h264_header.nalu_type = H264::NaluType::kIdr; 946 h264_header.nalus = { 947 {.type = H264::NaluType::kIdr, .sps_id = -1, .pps_id = 0}}; 948 // Complete and decodable since the pps and sps are received in the first 949 // packet of this frame. 950 EXPECT_EQ(kCompleteSession, 951 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 952 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 953 ASSERT_NE(nullptr, frame_out); 954 jitter_buffer_->ReleaseFrame(frame_out); 955 956 timestamp_ += 3000; 957 packet_->timestamp = timestamp_; 958 ++seq_num_; 959 packet_->seqNum = seq_num_; 960 packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta; 961 packet_->video_header.is_first_packet_in_frame = true; 962 packet_->markerBit = true; 963 packet_->video_header.codec = kVideoCodecH264; 964 h264_header.nalu_type = H264::NaluType::kSlice; 965 h264_header.nalus = { 966 {.type = H264::NaluType::kIdr, .sps_id = -1, .pps_id = 0}}; 967 968 // Complete and decodable since sps, pps and key frame has been received. 969 EXPECT_EQ(kCompleteSession, 970 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 971 frame_out = DecodeCompleteFrame(); 972 ASSERT_NE(nullptr, frame_out); 973 jitter_buffer_->ReleaseFrame(frame_out); 974 } 975 976 TEST_F(TestBasicJitterBuffer, DeltaFrame100PacketsWithSeqNumWrap) { 977 seq_num_ = 0xfff0; 978 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 979 packet_->video_header.is_first_packet_in_frame = true; 980 packet_->markerBit = false; 981 packet_->seqNum = seq_num_; 982 packet_->timestamp = timestamp_; 983 984 bool retransmitted = false; 985 EXPECT_EQ(kIncomplete, 986 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 987 988 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 989 990 EXPECT_TRUE(frame_out == nullptr); 991 992 int loop = 0; 993 do { 994 seq_num_++; 995 packet_->video_header.is_first_packet_in_frame = false; 996 packet_->markerBit = false; 997 packet_->seqNum = seq_num_; 998 999 EXPECT_EQ(kIncomplete, 1000 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1001 1002 frame_out = DecodeCompleteFrame(); 1003 1004 EXPECT_TRUE(frame_out == nullptr); 1005 1006 loop++; 1007 } while (loop < 98); 1008 1009 seq_num_++; 1010 packet_->video_header.is_first_packet_in_frame = false; 1011 packet_->markerBit = true; 1012 packet_->seqNum = seq_num_; 1013 1014 EXPECT_EQ(kCompleteSession, 1015 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1016 1017 frame_out = DecodeCompleteFrame(); 1018 1019 CheckOutFrame(frame_out, 100 * size_, false); 1020 1021 EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType()); 1022 jitter_buffer_->ReleaseFrame(frame_out); 1023 } 1024 1025 TEST_F(TestBasicJitterBuffer, PacketReorderingReverseWithNegSeqNumWrap) { 1026 // Insert "first" packet last seqnum. 1027 seq_num_ = 10; 1028 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 1029 packet_->video_header.is_first_packet_in_frame = false; 1030 packet_->markerBit = true; 1031 packet_->seqNum = seq_num_; 1032 1033 bool retransmitted = false; 1034 EXPECT_EQ(kIncomplete, 1035 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1036 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 1037 1038 // Should not be complete. 1039 EXPECT_TRUE(frame_out == nullptr); 1040 1041 // Insert 98 frames. 1042 int loop = 0; 1043 do { 1044 seq_num_--; 1045 packet_->video_header.is_first_packet_in_frame = false; 1046 packet_->markerBit = false; 1047 packet_->seqNum = seq_num_; 1048 1049 EXPECT_EQ(kIncomplete, 1050 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1051 1052 frame_out = DecodeCompleteFrame(); 1053 1054 EXPECT_TRUE(frame_out == nullptr); 1055 1056 loop++; 1057 } while (loop < 98); 1058 1059 // Insert last packet. 1060 seq_num_--; 1061 packet_->video_header.is_first_packet_in_frame = true; 1062 packet_->markerBit = false; 1063 packet_->seqNum = seq_num_; 1064 1065 EXPECT_EQ(kCompleteSession, 1066 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1067 1068 frame_out = DecodeCompleteFrame(); 1069 CheckOutFrame(frame_out, 100 * size_, false); 1070 EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType()); 1071 jitter_buffer_->ReleaseFrame(frame_out); 1072 } 1073 1074 TEST_F(TestBasicJitterBuffer, TestInsertOldFrame) { 1075 // ------- ------- 1076 // | 2 | | 1 | 1077 // ------- ------- 1078 // t = 3000 t = 2000 1079 seq_num_ = 2; 1080 timestamp_ = 3000; 1081 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 1082 packet_->video_header.is_first_packet_in_frame = true; 1083 packet_->markerBit = true; 1084 packet_->timestamp = timestamp_; 1085 packet_->seqNum = seq_num_; 1086 1087 bool retransmitted = false; 1088 EXPECT_EQ(kCompleteSession, 1089 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1090 1091 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 1092 EXPECT_EQ(3000u, frame_out->RtpTimestamp()); 1093 CheckOutFrame(frame_out, size_, false); 1094 EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType()); 1095 jitter_buffer_->ReleaseFrame(frame_out); 1096 1097 seq_num_--; 1098 timestamp_ = 2000; 1099 packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta; 1100 packet_->video_header.is_first_packet_in_frame = true; 1101 packet_->markerBit = true; 1102 packet_->seqNum = seq_num_; 1103 packet_->timestamp = timestamp_; 1104 1105 EXPECT_EQ(kOldPacket, jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1106 } 1107 1108 TEST_F(TestBasicJitterBuffer, TestInsertOldFrameWithSeqNumWrap) { 1109 // ------- ------- 1110 // | 2 | | 1 | 1111 // ------- ------- 1112 // t = 3000 t = 0xffffff00 1113 1114 seq_num_ = 2; 1115 timestamp_ = 3000; 1116 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 1117 packet_->video_header.is_first_packet_in_frame = true; 1118 packet_->markerBit = true; 1119 packet_->seqNum = seq_num_; 1120 packet_->timestamp = timestamp_; 1121 1122 bool retransmitted = false; 1123 EXPECT_EQ(kCompleteSession, 1124 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1125 1126 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 1127 EXPECT_EQ(timestamp_, frame_out->RtpTimestamp()); 1128 1129 CheckOutFrame(frame_out, size_, false); 1130 1131 EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType()); 1132 1133 jitter_buffer_->ReleaseFrame(frame_out); 1134 1135 seq_num_--; 1136 timestamp_ = 0xffffff00; 1137 packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta; 1138 packet_->video_header.is_first_packet_in_frame = true; 1139 packet_->markerBit = true; 1140 packet_->seqNum = seq_num_; 1141 packet_->timestamp = timestamp_; 1142 1143 // This timestamp is old. 1144 EXPECT_EQ(kOldPacket, jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1145 } 1146 1147 TEST_F(TestBasicJitterBuffer, TimestampWrap) { 1148 // --------------- --------------- 1149 // | 1 | 2 | | 3 | 4 | 1150 // --------------- --------------- 1151 // t = 0xffffff00 t = 33*90 1152 1153 timestamp_ = 0xffffff00; 1154 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 1155 packet_->video_header.is_first_packet_in_frame = true; 1156 packet_->markerBit = false; 1157 packet_->seqNum = seq_num_; 1158 packet_->timestamp = timestamp_; 1159 1160 bool retransmitted = false; 1161 EXPECT_EQ(kIncomplete, 1162 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1163 1164 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 1165 EXPECT_TRUE(frame_out == nullptr); 1166 1167 seq_num_++; 1168 packet_->video_header.is_first_packet_in_frame = false; 1169 packet_->markerBit = true; 1170 packet_->seqNum = seq_num_; 1171 1172 EXPECT_EQ(kCompleteSession, 1173 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1174 1175 frame_out = DecodeCompleteFrame(); 1176 CheckOutFrame(frame_out, 2 * size_, false); 1177 jitter_buffer_->ReleaseFrame(frame_out); 1178 1179 seq_num_++; 1180 timestamp_ += 33 * 90; 1181 packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta; 1182 packet_->video_header.is_first_packet_in_frame = true; 1183 packet_->markerBit = false; 1184 packet_->seqNum = seq_num_; 1185 packet_->timestamp = timestamp_; 1186 1187 EXPECT_EQ(kIncomplete, 1188 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1189 1190 frame_out = DecodeCompleteFrame(); 1191 EXPECT_TRUE(frame_out == nullptr); 1192 1193 seq_num_++; 1194 packet_->video_header.is_first_packet_in_frame = false; 1195 packet_->markerBit = true; 1196 packet_->seqNum = seq_num_; 1197 1198 EXPECT_EQ(kCompleteSession, 1199 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1200 1201 frame_out = DecodeCompleteFrame(); 1202 CheckOutFrame(frame_out, 2 * size_, false); 1203 EXPECT_EQ(VideoFrameType::kVideoFrameDelta, frame_out->FrameType()); 1204 jitter_buffer_->ReleaseFrame(frame_out); 1205 } 1206 1207 TEST_F(TestBasicJitterBuffer, 2FrameWithTimestampWrap) { 1208 // ------- ------- 1209 // | 1 | | 2 | 1210 // ------- ------- 1211 // t = 0xffffff00 t = 2700 1212 1213 timestamp_ = 0xffffff00; 1214 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 1215 packet_->video_header.is_first_packet_in_frame = true; 1216 packet_->markerBit = true; 1217 packet_->timestamp = timestamp_; 1218 1219 bool retransmitted = false; 1220 // Insert first frame (session will be complete). 1221 EXPECT_EQ(kCompleteSession, 1222 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1223 1224 // Insert next frame. 1225 seq_num_++; 1226 timestamp_ = 2700; 1227 packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta; 1228 packet_->video_header.is_first_packet_in_frame = true; 1229 packet_->markerBit = true; 1230 packet_->seqNum = seq_num_; 1231 packet_->timestamp = timestamp_; 1232 1233 EXPECT_EQ(kCompleteSession, 1234 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1235 1236 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 1237 EXPECT_EQ(0xffffff00, frame_out->RtpTimestamp()); 1238 CheckOutFrame(frame_out, size_, false); 1239 EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType()); 1240 jitter_buffer_->ReleaseFrame(frame_out); 1241 1242 VCMEncodedFrame* frame_out2 = DecodeCompleteFrame(); 1243 EXPECT_EQ(2700u, frame_out2->RtpTimestamp()); 1244 CheckOutFrame(frame_out2, size_, false); 1245 EXPECT_EQ(VideoFrameType::kVideoFrameDelta, frame_out2->FrameType()); 1246 jitter_buffer_->ReleaseFrame(frame_out2); 1247 } 1248 1249 TEST_F(TestBasicJitterBuffer, Insert2FramesReOrderedWithTimestampWrap) { 1250 // ------- ------- 1251 // | 2 | | 1 | 1252 // ------- ------- 1253 // t = 2700 t = 0xffffff00 1254 1255 seq_num_ = 2; 1256 timestamp_ = 2700; 1257 packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta; 1258 packet_->video_header.is_first_packet_in_frame = true; 1259 packet_->markerBit = true; 1260 packet_->seqNum = seq_num_; 1261 packet_->timestamp = timestamp_; 1262 1263 bool retransmitted = false; 1264 EXPECT_EQ(kCompleteSession, 1265 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1266 1267 // Insert second frame 1268 seq_num_--; 1269 timestamp_ = 0xffffff00; 1270 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 1271 packet_->video_header.is_first_packet_in_frame = true; 1272 packet_->markerBit = true; 1273 packet_->seqNum = seq_num_; 1274 packet_->timestamp = timestamp_; 1275 1276 EXPECT_EQ(kCompleteSession, 1277 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1278 1279 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 1280 EXPECT_EQ(0xffffff00, frame_out->RtpTimestamp()); 1281 CheckOutFrame(frame_out, size_, false); 1282 EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType()); 1283 jitter_buffer_->ReleaseFrame(frame_out); 1284 1285 VCMEncodedFrame* frame_out2 = DecodeCompleteFrame(); 1286 EXPECT_EQ(2700u, frame_out2->RtpTimestamp()); 1287 CheckOutFrame(frame_out2, size_, false); 1288 EXPECT_EQ(VideoFrameType::kVideoFrameDelta, frame_out2->FrameType()); 1289 jitter_buffer_->ReleaseFrame(frame_out2); 1290 } 1291 1292 TEST_F(TestBasicJitterBuffer, DeltaFrameWithMoreThanMaxNumberOfPackets) { 1293 int loop = 0; 1294 bool firstPacket = true; 1295 bool retransmitted = false; 1296 // Insert kMaxPacketsInJitterBuffer into frame. 1297 do { 1298 seq_num_++; 1299 packet_->video_header.is_first_packet_in_frame = false; 1300 packet_->markerBit = false; 1301 packet_->seqNum = seq_num_; 1302 1303 if (firstPacket) { 1304 EXPECT_EQ(kIncomplete, 1305 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1306 firstPacket = false; 1307 } else { 1308 EXPECT_EQ(kIncomplete, 1309 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1310 } 1311 1312 loop++; 1313 } while (loop < kMaxPacketsInSession); 1314 1315 // Max number of packets inserted. 1316 // Insert one more packet. 1317 seq_num_++; 1318 packet_->video_header.is_first_packet_in_frame = false; 1319 packet_->markerBit = true; 1320 packet_->seqNum = seq_num_; 1321 1322 // Insert the packet -> frame recycled. 1323 EXPECT_EQ(kSizeError, jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1324 EXPECT_TRUE(nullptr == DecodeCompleteFrame()); 1325 } 1326 1327 TEST_F(TestBasicJitterBuffer, ExceedNumOfFrameWithSeqNumWrap) { 1328 // TEST fill JB with more than max number of frame (50 delta frames + 1329 // 51 key frames) with wrap in seq_num_ 1330 // 1331 // -------------------------------------------------------------- 1332 // | 65485 | 65486 | 65487 | .... | 65535 | 0 | 1 | 2 | .....| 50 | 1333 // -------------------------------------------------------------- 1334 // |<-----------delta frames------------->|<------key frames----->| 1335 1336 // Make sure the jitter doesn't request a keyframe after too much non- 1337 // decodable frames. 1338 jitter_buffer_->SetNackSettings(kMaxNumberOfFrames, kMaxNumberOfFrames, 0); 1339 1340 int loop = 0; 1341 seq_num_ = 65485; 1342 uint32_t first_key_frame_timestamp = 0; 1343 bool retransmitted = false; 1344 // Insert MAX_NUMBER_OF_FRAMES frames. 1345 do { 1346 timestamp_ += 33 * 90; 1347 seq_num_++; 1348 packet_->video_header.is_first_packet_in_frame = true; 1349 packet_->markerBit = true; 1350 packet_->seqNum = seq_num_; 1351 packet_->timestamp = timestamp_; 1352 1353 if (loop == 50) { 1354 first_key_frame_timestamp = packet_->timestamp; 1355 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 1356 } 1357 1358 // Insert frame. 1359 EXPECT_EQ(kCompleteSession, 1360 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1361 1362 loop++; 1363 } while (loop < kMaxNumberOfFrames); 1364 1365 // Max number of frames inserted. 1366 1367 // Insert one more frame. 1368 timestamp_ += 33 * 90; 1369 seq_num_++; 1370 packet_->video_header.is_first_packet_in_frame = true; 1371 packet_->markerBit = true; 1372 packet_->seqNum = seq_num_; 1373 packet_->timestamp = timestamp_; 1374 1375 // Now, no free frame - frames will be recycled until first key frame. 1376 EXPECT_EQ(kFlushIndicator, 1377 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1378 1379 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 1380 EXPECT_EQ(first_key_frame_timestamp, frame_out->RtpTimestamp()); 1381 CheckOutFrame(frame_out, size_, false); 1382 EXPECT_EQ(VideoFrameType::kVideoFrameKey, frame_out->FrameType()); 1383 jitter_buffer_->ReleaseFrame(frame_out); 1384 } 1385 1386 TEST_F(TestBasicJitterBuffer, EmptyLastFrame) { 1387 seq_num_ = 3; 1388 // Insert one empty packet per frame, should never return the last timestamp 1389 // inserted. Only return empty frames in the presence of subsequent frames. 1390 int maxSize = 1000; 1391 bool retransmitted = false; 1392 for (int i = 0; i < maxSize + 10; i++) { 1393 timestamp_ += 33 * 90; 1394 seq_num_++; 1395 packet_->video_header.is_first_packet_in_frame = false; 1396 packet_->markerBit = false; 1397 packet_->seqNum = seq_num_; 1398 packet_->timestamp = timestamp_; 1399 packet_->video_header.frame_type = VideoFrameType::kEmptyFrame; 1400 1401 EXPECT_EQ(kNoError, jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1402 } 1403 } 1404 1405 TEST_F(TestBasicJitterBuffer, NextFrameWhenIncomplete) { 1406 // Test that a we cannot get incomplete frames from the JB if we haven't 1407 // received the marker bit, unless we have received a packet from a later 1408 // timestamp. 1409 // Start with a complete key frame - insert and decode. 1410 jitter_buffer_->SetNackSettings(kMaxNumberOfFrames, kMaxNumberOfFrames, 0); 1411 packet_->video_header.frame_type = VideoFrameType::kVideoFrameKey; 1412 packet_->video_header.is_first_packet_in_frame = true; 1413 packet_->markerBit = true; 1414 bool retransmitted = false; 1415 1416 EXPECT_EQ(kCompleteSession, 1417 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1418 VCMEncodedFrame* frame_out = DecodeCompleteFrame(); 1419 EXPECT_TRUE(frame_out != nullptr); 1420 jitter_buffer_->ReleaseFrame(frame_out); 1421 1422 packet_->seqNum += 2; 1423 packet_->timestamp += 33 * 90; 1424 packet_->video_header.frame_type = VideoFrameType::kVideoFrameDelta; 1425 packet_->video_header.is_first_packet_in_frame = false; 1426 packet_->markerBit = false; 1427 1428 EXPECT_EQ(kIncomplete, 1429 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1430 1431 packet_->seqNum += 2; 1432 packet_->timestamp += 33 * 90; 1433 packet_->video_header.is_first_packet_in_frame = true; 1434 1435 EXPECT_EQ(kIncomplete, 1436 jitter_buffer_->InsertPacket(*packet_, &retransmitted)); 1437 } 1438 1439 TEST_F(TestRunningJitterBuffer, Full) { 1440 // Make sure the jitter doesn't request a keyframe after too much non- 1441 // decodable frames. 1442 jitter_buffer_->SetNackSettings(kMaxNumberOfFrames, kMaxNumberOfFrames, 0); 1443 // Insert a key frame and decode it. 1444 EXPECT_GE(InsertFrame(VideoFrameType::kVideoFrameKey), kNoError); 1445 EXPECT_TRUE(DecodeCompleteFrame()); 1446 DropFrame(1); 1447 // Fill the jitter buffer. 1448 EXPECT_GE(InsertFrames(kMaxNumberOfFrames, VideoFrameType::kVideoFrameDelta), 1449 kNoError); 1450 // Make sure we can't decode these frames. 1451 EXPECT_FALSE(DecodeCompleteFrame()); 1452 // This frame will make the jitter buffer recycle frames until a key frame. 1453 // Since none is found it will have to wait until the next key frame before 1454 // decoding. 1455 EXPECT_EQ(kFlushIndicator, InsertFrame(VideoFrameType::kVideoFrameDelta)); 1456 EXPECT_FALSE(DecodeCompleteFrame()); 1457 } 1458 1459 TEST_F(TestRunningJitterBuffer, EmptyPackets) { 1460 // Make sure a frame can get complete even though empty packets are missing. 1461 stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameKey, 3, 3, 1462 clock_->TimeInMilliseconds()); 1463 bool request_key_frame = false; 1464 // Insert empty packet. 1465 EXPECT_EQ(kNoError, InsertPacketAndPop(4)); 1466 EXPECT_FALSE(request_key_frame); 1467 // Insert 3 media packets. 1468 EXPECT_EQ(kIncomplete, InsertPacketAndPop(0)); 1469 EXPECT_FALSE(request_key_frame); 1470 EXPECT_EQ(kIncomplete, InsertPacketAndPop(0)); 1471 EXPECT_FALSE(request_key_frame); 1472 EXPECT_EQ(kCompleteSession, InsertPacketAndPop(0)); 1473 EXPECT_FALSE(request_key_frame); 1474 // Insert empty packet. 1475 EXPECT_EQ(kCompleteSession, InsertPacketAndPop(0)); 1476 EXPECT_FALSE(request_key_frame); 1477 } 1478 1479 TEST_F(TestRunningJitterBuffer, SkipToKeyFrame) { 1480 // Insert delta frames. 1481 EXPECT_GE(InsertFrames(5, VideoFrameType::kVideoFrameDelta), kNoError); 1482 // Can't decode without a key frame. 1483 EXPECT_FALSE(DecodeCompleteFrame()); 1484 InsertFrame(VideoFrameType::kVideoFrameKey); 1485 // Skip to the next key frame. 1486 EXPECT_TRUE(DecodeCompleteFrame()); 1487 } 1488 1489 TEST_F(TestRunningJitterBuffer, DontSkipToKeyFrameIfDecodable) { 1490 InsertFrame(VideoFrameType::kVideoFrameKey); 1491 EXPECT_TRUE(DecodeCompleteFrame()); 1492 const int kNumDeltaFrames = 5; 1493 EXPECT_GE(InsertFrames(kNumDeltaFrames, VideoFrameType::kVideoFrameDelta), 1494 kNoError); 1495 InsertFrame(VideoFrameType::kVideoFrameKey); 1496 for (int i = 0; i < kNumDeltaFrames + 1; ++i) { 1497 EXPECT_TRUE(DecodeCompleteFrame()); 1498 } 1499 } 1500 1501 TEST_F(TestRunningJitterBuffer, KeyDeltaKeyDelta) { 1502 InsertFrame(VideoFrameType::kVideoFrameKey); 1503 EXPECT_TRUE(DecodeCompleteFrame()); 1504 const int kNumDeltaFrames = 5; 1505 EXPECT_GE(InsertFrames(kNumDeltaFrames, VideoFrameType::kVideoFrameDelta), 1506 kNoError); 1507 InsertFrame(VideoFrameType::kVideoFrameKey); 1508 EXPECT_GE(InsertFrames(kNumDeltaFrames, VideoFrameType::kVideoFrameDelta), 1509 kNoError); 1510 InsertFrame(VideoFrameType::kVideoFrameKey); 1511 for (int i = 0; i < 2 * (kNumDeltaFrames + 1); ++i) { 1512 EXPECT_TRUE(DecodeCompleteFrame()); 1513 } 1514 } 1515 1516 TEST_F(TestRunningJitterBuffer, TwoPacketsNonContinuous) { 1517 InsertFrame(VideoFrameType::kVideoFrameKey); 1518 EXPECT_TRUE(DecodeCompleteFrame()); 1519 stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameDelta, 1, 0, 1520 clock_->TimeInMilliseconds()); 1521 clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs); 1522 stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameDelta, 2, 0, 1523 clock_->TimeInMilliseconds()); 1524 EXPECT_EQ(kIncomplete, InsertPacketAndPop(1)); 1525 EXPECT_EQ(kCompleteSession, InsertPacketAndPop(1)); 1526 EXPECT_FALSE(DecodeCompleteFrame()); 1527 EXPECT_EQ(kCompleteSession, InsertPacketAndPop(0)); 1528 EXPECT_TRUE(DecodeCompleteFrame()); 1529 EXPECT_TRUE(DecodeCompleteFrame()); 1530 } 1531 1532 TEST_F(TestJitterBufferNack, EmptyPackets) { 1533 // Make sure empty packets doesn't clog the jitter buffer. 1534 EXPECT_GE(InsertFrames(kMaxNumberOfFrames, VideoFrameType::kEmptyFrame), 1535 kNoError); 1536 InsertFrame(VideoFrameType::kVideoFrameKey); 1537 EXPECT_TRUE(DecodeCompleteFrame()); 1538 } 1539 1540 TEST_F(TestJitterBufferNack, NackTooOldPackets) { 1541 // Insert a key frame and decode it. 1542 EXPECT_GE(InsertFrame(VideoFrameType::kVideoFrameKey), kNoError); 1543 EXPECT_TRUE(DecodeCompleteFrame()); 1544 1545 // Drop one frame and insert `kNackHistoryLength` to trigger NACKing a too 1546 // old packet. 1547 DropFrame(1); 1548 // Insert a frame which should trigger a recycle until the next key frame. 1549 EXPECT_EQ(kFlushIndicator, InsertFrames(oldest_packet_to_nack_ + 1, 1550 VideoFrameType::kVideoFrameDelta)); 1551 EXPECT_FALSE(DecodeCompleteFrame()); 1552 1553 bool request_key_frame = false; 1554 std::vector<uint16_t> nack_list = 1555 jitter_buffer_->GetNackList(&request_key_frame); 1556 // No key frame will be requested since the jitter buffer is empty. 1557 EXPECT_FALSE(request_key_frame); 1558 EXPECT_EQ(0u, nack_list.size()); 1559 1560 EXPECT_GE(InsertFrame(VideoFrameType::kVideoFrameDelta), kNoError); 1561 // Waiting for a key frame. 1562 EXPECT_FALSE(DecodeCompleteFrame()); 1563 1564 // The next complete continuous frame isn't a key frame, but we're waiting 1565 // for one. 1566 EXPECT_FALSE(DecodeCompleteFrame()); 1567 EXPECT_GE(InsertFrame(VideoFrameType::kVideoFrameKey), kNoError); 1568 // Skipping ahead to the key frame. 1569 EXPECT_TRUE(DecodeCompleteFrame()); 1570 } 1571 1572 TEST_F(TestJitterBufferNack, NackLargeJitterBuffer) { 1573 // Insert a key frame and decode it. 1574 EXPECT_GE(InsertFrame(VideoFrameType::kVideoFrameKey), kNoError); 1575 EXPECT_TRUE(DecodeCompleteFrame()); 1576 1577 // Insert a frame which should trigger a recycle until the next key frame. 1578 EXPECT_GE( 1579 InsertFrames(oldest_packet_to_nack_, VideoFrameType::kVideoFrameDelta), 1580 kNoError); 1581 1582 bool request_key_frame = false; 1583 std::vector<uint16_t> nack_list = 1584 jitter_buffer_->GetNackList(&request_key_frame); 1585 // Verify that the jitter buffer does not request a key frame. 1586 EXPECT_FALSE(request_key_frame); 1587 // Verify that no packets are NACKed. 1588 EXPECT_EQ(0u, nack_list.size()); 1589 // Verify that we can decode the next frame. 1590 EXPECT_TRUE(DecodeCompleteFrame()); 1591 } 1592 1593 TEST_F(TestJitterBufferNack, NackListFull) { 1594 // Insert a key frame and decode it. 1595 EXPECT_GE(InsertFrame(VideoFrameType::kVideoFrameKey), kNoError); 1596 EXPECT_TRUE(DecodeCompleteFrame()); 1597 1598 // Generate and drop `kNackHistoryLength` packets to fill the NACK list. 1599 DropFrame(max_nack_list_size_ + 1); 1600 // Insert a frame which should trigger a recycle until the next key frame. 1601 EXPECT_EQ(kFlushIndicator, InsertFrame(VideoFrameType::kVideoFrameDelta)); 1602 EXPECT_FALSE(DecodeCompleteFrame()); 1603 1604 bool request_key_frame = false; 1605 jitter_buffer_->GetNackList(&request_key_frame); 1606 // The jitter buffer is empty, so we won't request key frames until we get a 1607 // packet. 1608 EXPECT_FALSE(request_key_frame); 1609 1610 EXPECT_GE(InsertFrame(VideoFrameType::kVideoFrameDelta), kNoError); 1611 // Now we have a packet in the jitter buffer, a key frame will be requested 1612 // since it's not a key frame. 1613 jitter_buffer_->GetNackList(&request_key_frame); 1614 // The jitter buffer is empty, so we won't request key frames until we get a 1615 // packet. 1616 EXPECT_TRUE(request_key_frame); 1617 // The next complete continuous frame isn't a key frame, but we're waiting 1618 // for one. 1619 EXPECT_FALSE(DecodeCompleteFrame()); 1620 EXPECT_GE(InsertFrame(VideoFrameType::kVideoFrameKey), kNoError); 1621 // Skipping ahead to the key frame. 1622 EXPECT_TRUE(DecodeCompleteFrame()); 1623 } 1624 1625 TEST_F(TestJitterBufferNack, NoNackListReturnedBeforeFirstDecode) { 1626 DropFrame(10); 1627 // Insert a frame and try to generate a NACK list. Shouldn't get one. 1628 EXPECT_GE(InsertFrame(VideoFrameType::kVideoFrameDelta), kNoError); 1629 bool request_key_frame = false; 1630 std::vector<uint16_t> nack_list = 1631 jitter_buffer_->GetNackList(&request_key_frame); 1632 // No list generated, and a key frame request is signaled. 1633 EXPECT_EQ(0u, nack_list.size()); 1634 EXPECT_TRUE(request_key_frame); 1635 } 1636 1637 TEST_F(TestJitterBufferNack, NackListBuiltBeforeFirstDecode) { 1638 stream_generator_->Init(0, clock_->TimeInMilliseconds()); 1639 InsertFrame(VideoFrameType::kVideoFrameKey); 1640 stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameDelta, 2, 0, 1641 clock_->TimeInMilliseconds()); 1642 stream_generator_->NextPacket(nullptr); // Drop packet. 1643 EXPECT_EQ(kIncomplete, InsertPacketAndPop(0)); 1644 EXPECT_TRUE(DecodeCompleteFrame()); 1645 bool extended = false; 1646 std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended); 1647 EXPECT_EQ(1u, nack_list.size()); 1648 } 1649 1650 TEST_F(TestJitterBufferNack, VerifyRetransmittedFlag) { 1651 stream_generator_->Init(0, clock_->TimeInMilliseconds()); 1652 stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameKey, 3, 0, 1653 clock_->TimeInMilliseconds()); 1654 VCMPacket packet; 1655 stream_generator_->PopPacket(&packet, 0); 1656 bool retransmitted = false; 1657 EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(packet, &retransmitted)); 1658 EXPECT_FALSE(retransmitted); 1659 // Drop second packet. 1660 stream_generator_->PopPacket(&packet, 1); 1661 EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(packet, &retransmitted)); 1662 EXPECT_FALSE(retransmitted); 1663 EXPECT_FALSE(DecodeCompleteFrame()); 1664 bool extended = false; 1665 std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended); 1666 uint16_t seq_num; 1667 EXPECT_EQ(1u, nack_list.size()); 1668 seq_num = nack_list[0]; 1669 stream_generator_->PopPacket(&packet, 0); 1670 EXPECT_EQ(packet.seqNum, seq_num); 1671 EXPECT_EQ(kCompleteSession, 1672 jitter_buffer_->InsertPacket(packet, &retransmitted)); 1673 EXPECT_TRUE(retransmitted); 1674 EXPECT_TRUE(DecodeCompleteFrame()); 1675 } 1676 1677 TEST_F(TestJitterBufferNack, UseNackToRecoverFirstKeyFrame) { 1678 stream_generator_->Init(0, clock_->TimeInMilliseconds()); 1679 stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameKey, 3, 0, 1680 clock_->TimeInMilliseconds()); 1681 EXPECT_EQ(kIncomplete, InsertPacketAndPop(0)); 1682 // Drop second packet. 1683 EXPECT_EQ(kIncomplete, InsertPacketAndPop(1)); 1684 EXPECT_FALSE(DecodeCompleteFrame()); 1685 bool extended = false; 1686 std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended); 1687 uint16_t seq_num; 1688 ASSERT_EQ(1u, nack_list.size()); 1689 seq_num = nack_list[0]; 1690 VCMPacket packet; 1691 stream_generator_->GetPacket(&packet, 0); 1692 EXPECT_EQ(packet.seqNum, seq_num); 1693 } 1694 1695 TEST_F(TestJitterBufferNack, UseNackToRecoverFirstKeyFrameSecondInQueue) { 1696 VCMPacket packet; 1697 stream_generator_->Init(0, clock_->TimeInMilliseconds()); 1698 // First frame is delta. 1699 stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameDelta, 3, 0, 1700 clock_->TimeInMilliseconds()); 1701 EXPECT_EQ(kIncomplete, InsertPacketAndPop(0)); 1702 // Drop second packet in frame. 1703 ASSERT_TRUE(stream_generator_->PopPacket(&packet, 0)); 1704 EXPECT_EQ(kIncomplete, InsertPacketAndPop(0)); 1705 // Second frame is key. 1706 stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameKey, 3, 0, 1707 clock_->TimeInMilliseconds() + 10); 1708 EXPECT_EQ(kIncomplete, InsertPacketAndPop(0)); 1709 // Drop second packet in frame. 1710 EXPECT_EQ(kIncomplete, InsertPacketAndPop(1)); 1711 EXPECT_FALSE(DecodeCompleteFrame()); 1712 bool extended = false; 1713 std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended); 1714 uint16_t seq_num; 1715 ASSERT_EQ(1u, nack_list.size()); 1716 seq_num = nack_list[0]; 1717 stream_generator_->GetPacket(&packet, 0); 1718 EXPECT_EQ(packet.seqNum, seq_num); 1719 } 1720 1721 TEST_F(TestJitterBufferNack, NormalOperation) { 1722 EXPECT_GE(InsertFrame(VideoFrameType::kVideoFrameKey), kNoError); 1723 EXPECT_TRUE(DecodeCompleteFrame()); 1724 1725 // ---------------------------------------------------------------- 1726 // | 1 | 2 | .. | 8 | 9 | x | 11 | 12 | .. | 19 | x | 21 | .. | 100 | 1727 // ---------------------------------------------------------------- 1728 stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameKey, 100, 0, 1729 clock_->TimeInMilliseconds()); 1730 clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs); 1731 EXPECT_EQ(kIncomplete, InsertPacketAndPop(0)); 1732 // Verify that the frame is incomplete. 1733 EXPECT_FALSE(DecodeCompleteFrame()); 1734 while (stream_generator_->PacketsRemaining() > 1) { 1735 if (stream_generator_->NextSequenceNumber() % 10 != 0) { 1736 EXPECT_EQ(kIncomplete, InsertPacketAndPop(0)); 1737 } else { 1738 stream_generator_->NextPacket(nullptr); // Drop packet 1739 } 1740 } 1741 EXPECT_EQ(kIncomplete, InsertPacketAndPop(0)); 1742 EXPECT_EQ(0, stream_generator_->PacketsRemaining()); 1743 EXPECT_FALSE(DecodeCompleteFrame()); 1744 bool request_key_frame = false; 1745 1746 // Verify the NACK list. 1747 std::vector<uint16_t> nack_list = 1748 jitter_buffer_->GetNackList(&request_key_frame); 1749 const size_t kExpectedNackSize = 9; 1750 ASSERT_EQ(kExpectedNackSize, nack_list.size()); 1751 for (size_t i = 0; i < nack_list.size(); ++i) 1752 EXPECT_EQ((1 + i) * 10, nack_list[i]); 1753 } 1754 1755 TEST_F(TestJitterBufferNack, NormalOperationWrap) { 1756 bool request_key_frame = false; 1757 // ------- ------------------------------------------------------------ 1758 // | 65532 | | 65533 | 65534 | 65535 | x | 1 | .. | 9 | x | 11 |.....| 96 | 1759 // ------- ------------------------------------------------------------ 1760 stream_generator_->Init(65532, clock_->TimeInMilliseconds()); 1761 InsertFrame(VideoFrameType::kVideoFrameKey); 1762 EXPECT_FALSE(request_key_frame); 1763 EXPECT_TRUE(DecodeCompleteFrame()); 1764 stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameDelta, 100, 0, 1765 clock_->TimeInMilliseconds()); 1766 EXPECT_EQ(kIncomplete, InsertPacketAndPop(0)); 1767 while (stream_generator_->PacketsRemaining() > 1) { 1768 if (stream_generator_->NextSequenceNumber() % 10 != 0) { 1769 EXPECT_EQ(kIncomplete, InsertPacketAndPop(0)); 1770 EXPECT_FALSE(request_key_frame); 1771 } else { 1772 stream_generator_->NextPacket(nullptr); // Drop packet 1773 } 1774 } 1775 EXPECT_EQ(kIncomplete, InsertPacketAndPop(0)); 1776 EXPECT_FALSE(request_key_frame); 1777 EXPECT_EQ(0, stream_generator_->PacketsRemaining()); 1778 EXPECT_FALSE(DecodeCompleteFrame()); 1779 EXPECT_FALSE(DecodeCompleteFrame()); 1780 bool extended = false; 1781 std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended); 1782 // Verify the NACK list. 1783 const size_t kExpectedNackSize = 10; 1784 ASSERT_EQ(kExpectedNackSize, nack_list.size()); 1785 for (size_t i = 0; i < nack_list.size(); ++i) 1786 EXPECT_EQ(i * 10, nack_list[i]); 1787 } 1788 1789 TEST_F(TestJitterBufferNack, NormalOperationWrap2) { 1790 bool request_key_frame = false; 1791 // ----------------------------------- 1792 // | 65532 | 65533 | 65534 | x | 0 | 1 | 1793 // ----------------------------------- 1794 stream_generator_->Init(65532, clock_->TimeInMilliseconds()); 1795 InsertFrame(VideoFrameType::kVideoFrameKey); 1796 EXPECT_FALSE(request_key_frame); 1797 EXPECT_TRUE(DecodeCompleteFrame()); 1798 stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameDelta, 1, 0, 1799 clock_->TimeInMilliseconds()); 1800 clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs); 1801 for (int i = 0; i < 5; ++i) { 1802 if (stream_generator_->NextSequenceNumber() != 65535) { 1803 EXPECT_EQ(kCompleteSession, InsertPacketAndPop(0)); 1804 EXPECT_FALSE(request_key_frame); 1805 } else { 1806 stream_generator_->NextPacket(nullptr); // Drop packet 1807 } 1808 stream_generator_->GenerateFrame(VideoFrameType::kVideoFrameDelta, 1, 0, 1809 clock_->TimeInMilliseconds()); 1810 clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs); 1811 } 1812 EXPECT_EQ(kCompleteSession, InsertPacketAndPop(0)); 1813 EXPECT_FALSE(request_key_frame); 1814 bool extended = false; 1815 std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended); 1816 // Verify the NACK list. 1817 ASSERT_EQ(1u, nack_list.size()); 1818 EXPECT_EQ(65535, nack_list[0]); 1819 } 1820 1821 TEST_F(TestJitterBufferNack, ResetByFutureKeyFrameDoesntError) { 1822 stream_generator_->Init(0, clock_->TimeInMilliseconds()); 1823 InsertFrame(VideoFrameType::kVideoFrameKey); 1824 EXPECT_TRUE(DecodeCompleteFrame()); 1825 bool extended = false; 1826 std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended); 1827 EXPECT_EQ(0u, nack_list.size()); 1828 1829 // Far-into-the-future video frame, could be caused by resetting the encoder 1830 // or otherwise restarting. This should not fail when error when the packet is 1831 // a keyframe, even if all of the nack list needs to be flushed. 1832 stream_generator_->Init(10000, clock_->TimeInMilliseconds()); 1833 clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs); 1834 InsertFrame(VideoFrameType::kVideoFrameKey); 1835 EXPECT_TRUE(DecodeCompleteFrame()); 1836 nack_list = jitter_buffer_->GetNackList(&extended); 1837 EXPECT_EQ(0u, nack_list.size()); 1838 1839 // Stream should be decodable from this point. 1840 clock_->AdvanceTimeMilliseconds(kDefaultFramePeriodMs); 1841 InsertFrame(VideoFrameType::kVideoFrameDelta); 1842 EXPECT_TRUE(DecodeCompleteFrame()); 1843 nack_list = jitter_buffer_->GetNackList(&extended); 1844 EXPECT_EQ(0u, nack_list.size()); 1845 } 1846 } // namespace webrtc