h26x_packet_buffer_unittest.cc (53147B)
1 /* 2 * Copyright (c) 2021 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 #include "modules/video_coding/h26x_packet_buffer.h" 11 12 #include <cstdint> 13 #include <cstring> 14 #include <memory> 15 #include <string> 16 #include <utility> 17 #include <vector> 18 19 #include "api/array_view.h" 20 #include "api/video/render_resolution.h" 21 #include "api/video/video_codec_type.h" 22 #include "api/video/video_frame_type.h" 23 #include "common_video/h264/h264_common.h" 24 #include "modules/rtp_rtcp/source/rtp_video_header.h" 25 #include "modules/video_coding/codecs/h264/include/h264_globals.h" 26 #include "rtc_base/checks.h" 27 #include "rtc_base/copy_on_write_buffer.h" 28 #include "rtc_base/system/unused.h" 29 #include "test/gmock.h" 30 #include "test/gtest.h" 31 #ifdef RTC_ENABLE_H265 32 #include "common_video/h265/h265_common.h" 33 #endif 34 35 namespace webrtc { 36 namespace { 37 38 using ::testing::ElementsAreArray; 39 using ::testing::Eq; 40 using ::testing::IsEmpty; 41 using ::testing::SizeIs; 42 43 using H264::NaluType::kAud; 44 using H264::NaluType::kFuA; 45 using H264::NaluType::kIdr; 46 using H264::NaluType::kPps; 47 using H264::NaluType::kSlice; 48 using H264::NaluType::kSps; 49 using H264::NaluType::kStapA; 50 51 constexpr int kBufferSize = 2048; 52 // Example sprop string from https://tools.ietf.org/html/rfc3984. 53 constexpr char kExampleSpropString[] = "Z0IACpZTBYmI,aMljiA=="; 54 const std::vector<uint8_t> kExampleSpropRawSps{0x67, 0x42, 0x00, 0x0A, 0x96, 55 0x53, 0x05, 0x89, 0x88}; 56 const std::vector<uint8_t> kExampleSpropRawPps{0x68, 0xC9, 0x63, 0x88}; 57 58 std::vector<uint8_t> StartCode() { 59 return {0, 0, 0, 1}; 60 } 61 62 NaluInfo MakeNaluInfo(uint8_t type) { 63 NaluInfo res; 64 res.type = type; 65 res.sps_id = -1; 66 res.pps_id = -1; 67 return res; 68 } 69 70 class H264Packet { 71 public: 72 explicit H264Packet(H264PacketizationTypes type); 73 74 H264Packet& Idr(std::vector<uint8_t> payload = {9, 9, 9}, int pps_id = -1); 75 H264Packet& Slice(std::vector<uint8_t> payload = {9, 9, 9}); 76 H264Packet& Sps(std::vector<uint8_t> payload = {9, 9, 9}, int sps_id = -1); 77 H264Packet& SpsWithResolution(RenderResolution resolution, 78 std::vector<uint8_t> payload = {9, 9, 9}); 79 H264Packet& Pps(std::vector<uint8_t> payload = {9, 9, 9}, 80 int pps_id = -1, 81 int sps_id = -1); 82 H264Packet& Aud(); 83 H264Packet& Marker(); 84 H264Packet& AsFirstFragment(); 85 H264Packet& AsFirstPacket(); 86 H264Packet& Time(uint32_t rtp_timestamp); 87 H264Packet& SeqNum(int64_t rtp_seq_num); 88 89 std::unique_ptr<H26xPacketBuffer::Packet> Build(); 90 91 private: 92 CopyOnWriteBuffer BuildFuaPayload() const; 93 CopyOnWriteBuffer BuildSingleNaluPayload() const; 94 CopyOnWriteBuffer BuildStapAPayload() const; 95 96 RTPVideoHeaderH264& H264Header() { 97 return std::get<RTPVideoHeaderH264>(video_header_.video_type_header); 98 } 99 const RTPVideoHeaderH264& H264Header() const { 100 return std::get<RTPVideoHeaderH264>(video_header_.video_type_header); 101 } 102 103 H264PacketizationTypes type_; 104 RTPVideoHeader video_header_; 105 bool first_fragment_ = false; 106 bool first_packet_ = false; 107 bool marker_bit_ = false; 108 uint32_t rtp_timestamp_ = 0; 109 int64_t rtp_seq_num_ = 0; 110 std::vector<std::vector<uint8_t>> nalu_payloads_; 111 }; 112 113 H264Packet::H264Packet(H264PacketizationTypes type) : type_(type) { 114 video_header_.video_type_header.emplace<RTPVideoHeaderH264>(); 115 } 116 117 H264Packet& H264Packet::Idr(std::vector<uint8_t> payload, int pps_id) { 118 auto& h264_header = H264Header(); 119 auto nalu_info = MakeNaluInfo(kIdr); 120 nalu_info.pps_id = pps_id; 121 h264_header.nalus.push_back(nalu_info); 122 nalu_payloads_.push_back(std::move(payload)); 123 return *this; 124 } 125 126 H264Packet& H264Packet::Slice(std::vector<uint8_t> payload) { 127 auto& h264_header = H264Header(); 128 h264_header.nalus.push_back(MakeNaluInfo(kSlice)); 129 nalu_payloads_.push_back(std::move(payload)); 130 return *this; 131 } 132 133 H264Packet& H264Packet::Sps(std::vector<uint8_t> payload, int sps_id) { 134 auto& h264_header = H264Header(); 135 auto nalu_info = MakeNaluInfo(kSps); 136 nalu_info.pps_id = sps_id; 137 h264_header.nalus.push_back(nalu_info); 138 nalu_payloads_.push_back(std::move(payload)); 139 return *this; 140 } 141 142 H264Packet& H264Packet::SpsWithResolution(RenderResolution resolution, 143 std::vector<uint8_t> payload) { 144 auto& h264_header = H264Header(); 145 h264_header.nalus.push_back(MakeNaluInfo(kSps)); 146 video_header_.width = resolution.Width(); 147 video_header_.height = resolution.Height(); 148 nalu_payloads_.push_back(std::move(payload)); 149 return *this; 150 } 151 152 H264Packet& H264Packet::Pps(std::vector<uint8_t> payload, 153 int pps_id, 154 int sps_id) { 155 auto& h264_header = H264Header(); 156 auto nalu_info = MakeNaluInfo(kPps); 157 nalu_info.pps_id = pps_id; 158 nalu_info.sps_id = sps_id; 159 h264_header.nalus.push_back(nalu_info); 160 nalu_payloads_.push_back(std::move(payload)); 161 return *this; 162 } 163 164 H264Packet& H264Packet::Aud() { 165 auto& h264_header = H264Header(); 166 h264_header.nalus.push_back(MakeNaluInfo(kAud)); 167 nalu_payloads_.push_back({}); 168 return *this; 169 } 170 171 H264Packet& H264Packet::Marker() { 172 marker_bit_ = true; 173 return *this; 174 } 175 176 H264Packet& H264Packet::AsFirstFragment() { 177 first_fragment_ = true; 178 return *this; 179 } 180 181 H264Packet& H264Packet::AsFirstPacket() { 182 first_packet_ = true; 183 return *this; 184 } 185 186 H264Packet& H264Packet::Time(uint32_t rtp_timestamp) { 187 rtp_timestamp_ = rtp_timestamp; 188 return *this; 189 } 190 191 H264Packet& H264Packet::SeqNum(int64_t rtp_seq_num) { 192 rtp_seq_num_ = rtp_seq_num; 193 return *this; 194 } 195 196 std::unique_ptr<H26xPacketBuffer::Packet> H264Packet::Build() { 197 auto res = std::make_unique<H26xPacketBuffer::Packet>(); 198 199 auto& h264_header = H264Header(); 200 switch (type_) { 201 case kH264FuA: { 202 RTC_CHECK_EQ(h264_header.nalus.size(), 1); 203 res->video_payload = BuildFuaPayload(); 204 break; 205 } 206 case kH264SingleNalu: { 207 RTC_CHECK_EQ(h264_header.nalus.size(), 1); 208 res->video_payload = BuildSingleNaluPayload(); 209 break; 210 } 211 case kH264StapA: { 212 RTC_CHECK_GT(h264_header.nalus.size(), 1); 213 res->video_payload = BuildStapAPayload(); 214 break; 215 } 216 } 217 218 if (type_ == kH264FuA && !first_fragment_) { 219 h264_header.nalus.clear(); 220 } 221 222 h264_header.packetization_type = type_; 223 res->marker_bit = marker_bit_; 224 res->video_header = video_header_; 225 res->timestamp = rtp_timestamp_; 226 res->sequence_number = rtp_seq_num_; 227 res->video_header.codec = kVideoCodecH264; 228 res->video_header.is_first_packet_in_frame = first_packet_; 229 230 return res; 231 } 232 233 CopyOnWriteBuffer H264Packet::BuildFuaPayload() const { 234 return CopyOnWriteBuffer(nalu_payloads_[0]); 235 } 236 237 CopyOnWriteBuffer H264Packet::BuildSingleNaluPayload() const { 238 CopyOnWriteBuffer res; 239 auto& h264_header = H264Header(); 240 res.AppendData(&h264_header.nalus[0].type, 1); 241 res.AppendData(nalu_payloads_[0]); 242 return res; 243 } 244 245 CopyOnWriteBuffer H264Packet::BuildStapAPayload() const { 246 CopyOnWriteBuffer res; 247 248 const uint8_t indicator = H264::NaluType::kStapA; 249 res.AppendData(&indicator, 1); 250 251 auto& h264_header = H264Header(); 252 for (size_t i = 0; i < h264_header.nalus.size(); ++i) { 253 // The two first bytes indicates the nalu segment size. 254 uint8_t length_as_array[2] = { 255 0, static_cast<uint8_t>(nalu_payloads_[i].size() + 1)}; 256 res.AppendData(length_as_array); 257 258 res.AppendData(&h264_header.nalus[i].type, 1); 259 res.AppendData(nalu_payloads_[i]); 260 } 261 return res; 262 } 263 264 #ifdef RTC_ENABLE_H265 265 class H265Packet { 266 public: 267 H265Packet() = default; 268 269 H265Packet& Idr(std::vector<uint8_t> payload = {9, 9, 9}); 270 H265Packet& Slice(H265::NaluType type, 271 std::vector<uint8_t> payload = {9, 9, 9}); 272 H265Packet& Vps(std::vector<uint8_t> payload = {9, 9, 9}); 273 H265Packet& Sps(std::vector<uint8_t> payload = {9, 9, 9}); 274 H265Packet& SpsWithResolution(RenderResolution resolution, 275 std::vector<uint8_t> payload = {9, 9, 9}); 276 H265Packet& Pps(std::vector<uint8_t> payload = {9, 9, 9}); 277 H265Packet& Aud(); 278 H265Packet& Marker(); 279 H265Packet& AsFirstFragment(); 280 H265Packet& AsFirstPacket(); 281 H265Packet& Time(uint32_t rtp_timestamp); 282 H265Packet& SeqNum(int64_t rtp_seq_num); 283 284 std::unique_ptr<H26xPacketBuffer::Packet> Build(); 285 286 private: 287 H265Packet& StartCode(); 288 289 RTPVideoHeader video_header_; 290 bool first_fragment_ = false; 291 bool first_packet_ = false; 292 bool marker_bit_ = false; 293 uint32_t rtp_timestamp_ = 0; 294 uint16_t rtp_seq_num_ = 0; 295 std::vector<std::vector<uint8_t>> nalu_payloads_; 296 }; 297 298 H265Packet& H265Packet::Idr(std::vector<uint8_t> payload) { 299 return Slice(H265::NaluType::kIdrNLp, std::move(payload)); 300 } 301 302 H265Packet& H265Packet::Slice(H265::NaluType type, 303 std::vector<uint8_t> payload) { 304 StartCode(); 305 // Nalu header. Assume layer ID is 0 and TID is 2. 306 nalu_payloads_.push_back({static_cast<uint8_t>(type << 1), 0x02}); 307 nalu_payloads_.push_back(std::move(payload)); 308 return *this; 309 } 310 311 H265Packet& H265Packet::Vps(std::vector<uint8_t> payload) { 312 return Slice(H265::NaluType::kVps, std::move(payload)); 313 } 314 315 H265Packet& H265Packet::Sps(std::vector<uint8_t> payload) { 316 return Slice(H265::NaluType::kSps, std::move(payload)); 317 } 318 319 H265Packet& H265Packet::SpsWithResolution(RenderResolution resolution, 320 std::vector<uint8_t> payload) { 321 video_header_.width = resolution.Width(); 322 video_header_.height = resolution.Height(); 323 return Sps(std::move(payload)); 324 } 325 326 H265Packet& H265Packet::Pps(std::vector<uint8_t> payload) { 327 return Slice(H265::NaluType::kPps, std::move(payload)); 328 } 329 330 H265Packet& H265Packet::Aud() { 331 return Slice(H265::NaluType::kAud, {}); 332 } 333 334 H265Packet& H265Packet::Marker() { 335 marker_bit_ = true; 336 return *this; 337 } 338 339 H265Packet& H265Packet::StartCode() { 340 nalu_payloads_.push_back({0x00, 0x00, 0x00, 0x01}); 341 return *this; 342 } 343 344 std::unique_ptr<H26xPacketBuffer::Packet> H265Packet::Build() { 345 auto res = std::make_unique<H26xPacketBuffer::Packet>(); 346 res->marker_bit = marker_bit_; 347 res->video_header = video_header_; 348 res->timestamp = rtp_timestamp_; 349 res->sequence_number = rtp_seq_num_; 350 res->video_header.codec = kVideoCodecH265; 351 res->video_payload = CopyOnWriteBuffer(); 352 res->video_header.is_first_packet_in_frame = first_packet_; 353 for (const auto& payload : nalu_payloads_) { 354 res->video_payload.AppendData(payload); 355 } 356 357 return res; 358 } 359 360 H265Packet& H265Packet::AsFirstFragment() { 361 first_fragment_ = true; 362 return *this; 363 } 364 365 H265Packet& H265Packet::AsFirstPacket() { 366 first_packet_ = true; 367 return *this; 368 } 369 370 H265Packet& H265Packet::Time(uint32_t rtp_timestamp) { 371 rtp_timestamp_ = rtp_timestamp; 372 return *this; 373 } 374 375 H265Packet& H265Packet::SeqNum(int64_t rtp_seq_num) { 376 rtp_seq_num_ = rtp_seq_num; 377 return *this; 378 } 379 #endif 380 381 ArrayView<const uint8_t> PacketPayload( 382 const std::unique_ptr<H26xPacketBuffer::Packet>& packet) { 383 return packet->video_payload; 384 } 385 386 std::vector<uint8_t> FlatVector( 387 const std::vector<std::vector<uint8_t>>& elems) { 388 std::vector<uint8_t> res; 389 for (const auto& elem : elems) { 390 res.insert(res.end(), elem.begin(), elem.end()); 391 } 392 return res; 393 } 394 395 TEST(H26xPacketBufferTest, IdrOnlyKeyframeWithSprop) { 396 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/true); 397 packet_buffer.SetSpropParameterSets(kExampleSpropString); 398 399 auto packets = packet_buffer 400 .InsertPacket(H264Packet(kH264SingleNalu) 401 .Idr({1, 2, 3}, 0) 402 .AsFirstPacket() 403 .Marker() 404 .Build()) 405 .packets; 406 EXPECT_THAT(packets, SizeIs(1)); 407 EXPECT_THAT(PacketPayload(packets[0]), 408 ElementsAreArray(FlatVector({StartCode(), 409 kExampleSpropRawSps, 410 StartCode(), 411 kExampleSpropRawPps, 412 StartCode(), 413 {kIdr, 1, 2, 3}}))); 414 } 415 416 TEST(H26xPacketBufferTest, IdrOnlyKeyframeWithoutSprop) { 417 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/true); 418 419 // Cannot fix biststream by prepending SPS and PPS because no sprop string is 420 // available. Request a key frame. 421 EXPECT_TRUE(packet_buffer 422 .InsertPacket(H264Packet(kH264SingleNalu) 423 .Idr({9, 9, 9}, 0) 424 .AsFirstPacket() 425 .Marker() 426 .Build()) 427 .buffer_cleared); 428 } 429 430 TEST(H26xPacketBufferTest, IdrOnlyKeyframeWithSpropAndUnknownPpsId) { 431 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/true); 432 packet_buffer.SetSpropParameterSets(kExampleSpropString); 433 434 // Cannot fix biststream because sprop string doesn't contain a PPS with given 435 // ID. Request a key frame. 436 EXPECT_TRUE(packet_buffer 437 .InsertPacket(H264Packet(kH264SingleNalu) 438 .Idr({9, 9, 9}, 1) 439 .AsFirstPacket() 440 .Marker() 441 .Build()) 442 .buffer_cleared); 443 } 444 445 TEST(H26xPacketBufferTest, IdrOnlyKeyframeInTheMiddle) { 446 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/true); 447 packet_buffer.SetSpropParameterSets(kExampleSpropString); 448 449 RTC_UNUSED(packet_buffer.InsertPacket(H264Packet(kH264SingleNalu) 450 .Sps({1, 2, 3}, 1) 451 .SeqNum(0) 452 .Time(0) 453 .AsFirstPacket() 454 .Build())); 455 RTC_UNUSED(packet_buffer.InsertPacket(H264Packet(kH264SingleNalu) 456 .Pps({4, 5, 6}, 1, 1) 457 .SeqNum(1) 458 .Time(0) 459 .AsFirstPacket() 460 .Build())); 461 EXPECT_THAT(packet_buffer 462 .InsertPacket(H264Packet(kH264SingleNalu) 463 .Idr({7, 8, 9}, 1) 464 .SeqNum(2) 465 .Time(0) 466 .AsFirstPacket() 467 .Marker() 468 .Build()) 469 .packets, 470 SizeIs(3)); 471 472 EXPECT_THAT(packet_buffer 473 .InsertPacket(H264Packet(kH264SingleNalu) 474 .Slice() 475 .SeqNum(3) 476 .Time(1) 477 .AsFirstPacket() 478 .Marker() 479 .Build()) 480 .packets, 481 SizeIs(1)); 482 483 auto packets = packet_buffer 484 .InsertPacket(H264Packet(kH264SingleNalu) 485 .Idr({10, 11, 12}, 0) 486 .SeqNum(4) 487 .Time(2) 488 .AsFirstPacket() 489 .Marker() 490 .Build()) 491 .packets; 492 EXPECT_THAT(packets, SizeIs(1)); 493 EXPECT_THAT(PacketPayload(packets[0]), 494 ElementsAreArray(FlatVector({StartCode(), 495 kExampleSpropRawSps, 496 StartCode(), 497 kExampleSpropRawPps, 498 StartCode(), 499 {kIdr, 10, 11, 12}}))); 500 } 501 502 TEST(H26xPacketBufferTest, IdrIsNotKeyframe) { 503 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 504 505 EXPECT_THAT(packet_buffer 506 .InsertPacket(H264Packet(kH264SingleNalu) 507 .Idr() 508 .AsFirstPacket() 509 .Marker() 510 .Build()) 511 .packets, 512 IsEmpty()); 513 } 514 515 TEST(H26xPacketBufferTest, IdrIsKeyframeFuaRequiresFirstFragmet) { 516 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/true); 517 packet_buffer.SetSpropParameterSets(kExampleSpropString); 518 519 // Not marked as the first fragment 520 EXPECT_THAT(packet_buffer 521 .InsertPacket(H264Packet(kH264FuA) 522 .Idr() 523 .SeqNum(0) 524 .Time(0) 525 .AsFirstPacket() 526 .Build()) 527 .packets, 528 IsEmpty()); 529 530 EXPECT_THAT( 531 packet_buffer 532 .InsertPacket( 533 H264Packet(kH264FuA).Idr().SeqNum(1).Time(0).Marker().Build()) 534 .packets, 535 IsEmpty()); 536 537 // Marked as first fragment 538 EXPECT_THAT(packet_buffer 539 .InsertPacket(H264Packet(kH264FuA) 540 .Idr({9, 9, 9}, 0) 541 .SeqNum(2) 542 .Time(1) 543 .AsFirstFragment() 544 .AsFirstPacket() 545 .Build()) 546 .packets, 547 IsEmpty()); 548 549 EXPECT_THAT( 550 packet_buffer 551 .InsertPacket( 552 H264Packet(kH264FuA).Idr().SeqNum(3).Time(1).Marker().Build()) 553 .packets, 554 SizeIs(2)); 555 } 556 557 TEST(H26xPacketBufferTest, SpsPpsIdrIsKeyframeSingleNalus) { 558 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 559 560 RTC_UNUSED(packet_buffer.InsertPacket(H264Packet(kH264SingleNalu) 561 .Sps() 562 .SeqNum(0) 563 .Time(0) 564 .AsFirstPacket() 565 .Build())); 566 RTC_UNUSED(packet_buffer.InsertPacket( 567 H264Packet(kH264SingleNalu).Pps().SeqNum(1).Time(0).Build())); 568 EXPECT_THAT(packet_buffer 569 .InsertPacket(H264Packet(kH264SingleNalu) 570 .Idr() 571 .SeqNum(2) 572 .Time(0) 573 .AsFirstPacket() 574 .Marker() 575 .Build()) 576 .packets, 577 SizeIs(3)); 578 } 579 580 TEST(H26xPacketBufferTest, SpsPpsIdrIsKeyframeIgnoresSprop) { 581 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 582 583 // When h264_allow_idr_only_keyframes is false, sprop string should be 584 // ignored. Use in band parameter sets. 585 packet_buffer.SetSpropParameterSets(kExampleSpropString); 586 587 RTC_UNUSED(packet_buffer.InsertPacket(H264Packet(kH264SingleNalu) 588 .Sps({1, 2, 3}, 0) 589 .SeqNum(0) 590 .Time(0) 591 .AsFirstPacket() 592 .Build())); 593 RTC_UNUSED(packet_buffer.InsertPacket(H264Packet(kH264SingleNalu) 594 .Pps({4, 5, 6}, 0, 0) 595 .SeqNum(1) 596 .Time(0) 597 .AsFirstPacket() 598 .Build())); 599 auto packets = packet_buffer 600 .InsertPacket(H264Packet(kH264SingleNalu) 601 .Idr({7, 8, 9}, 0) 602 .SeqNum(2) 603 .Time(0) 604 .AsFirstPacket() 605 .Marker() 606 .Build()) 607 .packets; 608 EXPECT_THAT(packets, SizeIs(3)); 609 EXPECT_THAT(PacketPayload(packets[0]), 610 ElementsAreArray(FlatVector({StartCode(), {kSps, 1, 2, 3}}))); 611 EXPECT_THAT(PacketPayload(packets[1]), 612 ElementsAreArray(FlatVector({StartCode(), {kPps, 4, 5, 6}}))); 613 EXPECT_THAT(PacketPayload(packets[2]), 614 ElementsAreArray(FlatVector({StartCode(), {kIdr, 7, 8, 9}}))); 615 } 616 617 TEST(H26xPacketBufferTest, PpsIdrIsNotKeyframeSingleNalus) { 618 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 619 620 RTC_UNUSED(packet_buffer.InsertPacket(H264Packet(kH264SingleNalu) 621 .Pps() 622 .SeqNum(0) 623 .Time(0) 624 .AsFirstPacket() 625 .Build())); 626 EXPECT_THAT(packet_buffer 627 .InsertPacket(H264Packet(kH264SingleNalu) 628 .Idr() 629 .SeqNum(1) 630 .Time(0) 631 .AsFirstPacket() 632 .Marker() 633 .Build()) 634 .packets, 635 IsEmpty()); 636 } 637 638 TEST(H26xPacketBufferTest, SpsIdrIsNotKeyframeSingleNalus) { 639 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 640 641 RTC_UNUSED(packet_buffer.InsertPacket(H264Packet(kH264SingleNalu) 642 .Sps() 643 .SeqNum(0) 644 .Time(0) 645 .AsFirstPacket() 646 .Build())); 647 EXPECT_THAT(packet_buffer 648 .InsertPacket(H264Packet(kH264SingleNalu) 649 .Idr() 650 .SeqNum(1) 651 .Time(0) 652 .AsFirstPacket() 653 .Marker() 654 .Build()) 655 .packets, 656 IsEmpty()); 657 } 658 659 TEST(H26xPacketBufferTest, SpsPpsIdrIsKeyframeStapA) { 660 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 661 662 EXPECT_THAT(packet_buffer 663 .InsertPacket(H264Packet(kH264StapA) 664 .Sps() 665 .Pps() 666 .Idr() 667 .SeqNum(0) 668 .Time(0) 669 .AsFirstPacket() 670 .Marker() 671 .Build()) 672 .packets, 673 SizeIs(1)); 674 } 675 676 TEST(H26xPacketBufferTest, PpsIdrIsNotKeyframeStapA) { 677 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 678 679 EXPECT_THAT(packet_buffer 680 .InsertPacket(H264Packet(kH264StapA) 681 .Pps() 682 .Idr() 683 .SeqNum(0) 684 .Time(0) 685 .AsFirstPacket() 686 .Marker() 687 .Build()) 688 .packets, 689 IsEmpty()); 690 } 691 692 TEST(H26xPacketBufferTest, SpsIdrIsNotKeyframeStapA) { 693 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 694 695 EXPECT_THAT(packet_buffer 696 .InsertPacket(H264Packet(kH264StapA) 697 .Sps() 698 .Idr() 699 .SeqNum(2) 700 .Time(2) 701 .AsFirstPacket() 702 .Marker() 703 .Build()) 704 .packets, 705 IsEmpty()); 706 707 EXPECT_THAT(packet_buffer 708 .InsertPacket(H264Packet(kH264StapA) 709 .Sps() 710 .Pps() 711 .Idr() 712 .SeqNum(3) 713 .Time(3) 714 .AsFirstPacket() 715 .Marker() 716 .Build()) 717 .packets, 718 SizeIs(1)); 719 } 720 721 TEST(H26xPacketBufferTest, InsertingSpsPpsLastCompletesKeyframe) { 722 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 723 724 RTC_UNUSED(packet_buffer.InsertPacket(H264Packet(kH264SingleNalu) 725 .Idr() 726 .SeqNum(2) 727 .Time(1) 728 .AsFirstPacket() 729 .Marker() 730 .Build())); 731 732 EXPECT_THAT(packet_buffer 733 .InsertPacket(H264Packet(kH264StapA) 734 .Sps() 735 .Pps() 736 .SeqNum(1) 737 .Time(1) 738 .AsFirstPacket() 739 .Build()) 740 .packets, 741 SizeIs(2)); 742 } 743 744 TEST(H26xPacketBufferTest, InsertingMidFuaCompletesFrame) { 745 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 746 747 EXPECT_THAT(packet_buffer 748 .InsertPacket(H264Packet(kH264StapA) 749 .Sps() 750 .Pps() 751 .Idr() 752 .SeqNum(0) 753 .Time(0) 754 .AsFirstPacket() 755 .Marker() 756 .Build()) 757 .packets, 758 SizeIs(1)); 759 760 RTC_UNUSED(packet_buffer.InsertPacket(H264Packet(kH264FuA) 761 .Slice() 762 .SeqNum(1) 763 .Time(1) 764 .AsFirstFragment() 765 .AsFirstPacket() 766 .Build())); 767 RTC_UNUSED(packet_buffer.InsertPacket( 768 H264Packet(kH264FuA).Slice().SeqNum(3).Time(1).Marker().Build())); 769 EXPECT_THAT( 770 packet_buffer 771 .InsertPacket(H264Packet(kH264FuA).Slice().SeqNum(2).Time(1).Build()) 772 .packets, 773 SizeIs(3)); 774 } 775 776 TEST(H26xPacketBufferTest, SeqNumJumpDoesNotCompleteFrame) { 777 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 778 779 EXPECT_THAT(packet_buffer 780 .InsertPacket(H264Packet(kH264StapA) 781 .Sps() 782 .Pps() 783 .Idr() 784 .SeqNum(0) 785 .Time(0) 786 .AsFirstPacket() 787 .Marker() 788 .Build()) 789 .packets, 790 SizeIs(1)); 791 792 EXPECT_THAT(packet_buffer 793 .InsertPacket(H264Packet(kH264FuA) 794 .Slice() 795 .SeqNum(1) 796 .Time(1) 797 .AsFirstPacket() 798 .Build()) 799 .packets, 800 IsEmpty()); 801 802 // Add `kBufferSize` to make the index of the sequence number wrap and end up 803 // where the packet with sequence number 2 would have ended up. 804 EXPECT_THAT(packet_buffer 805 .InsertPacket(H264Packet(kH264FuA) 806 .Slice() 807 .SeqNum(2 + kBufferSize) 808 .Time(3) 809 .Marker() 810 .Build()) 811 .packets, 812 IsEmpty()); 813 } 814 815 TEST(H26xPacketBufferTest, OldFramesAreNotCompletedAfterBufferWrap) { 816 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 817 818 EXPECT_THAT(packet_buffer 819 .InsertPacket(H264Packet(kH264SingleNalu) 820 .Slice() 821 .SeqNum(1) 822 .Time(1) 823 .AsFirstPacket() 824 .Marker() 825 .Build()) 826 .packets, 827 IsEmpty()); 828 829 // New keyframe, preceedes packet with sequence number 1 in the buffer. 830 EXPECT_THAT(packet_buffer 831 .InsertPacket(H264Packet(kH264StapA) 832 .Sps() 833 .Pps() 834 .Idr() 835 .SeqNum(kBufferSize) 836 .Time(kBufferSize) 837 .AsFirstPacket() 838 .Marker() 839 .Build()) 840 .packets, 841 SizeIs(1)); 842 } 843 844 TEST(H26xPacketBufferTest, OldPacketsDontBlockNewPackets) { 845 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 846 EXPECT_THAT(packet_buffer 847 .InsertPacket(H264Packet(kH264StapA) 848 .Sps() 849 .Pps() 850 .Idr() 851 .SeqNum(kBufferSize) 852 .Time(kBufferSize) 853 .AsFirstPacket() 854 .Marker() 855 .Build()) 856 .packets, 857 SizeIs(1)); 858 859 RTC_UNUSED(packet_buffer.InsertPacket(H264Packet(kH264FuA) 860 .Slice() 861 .SeqNum(kBufferSize + 1) 862 .Time(kBufferSize + 1) 863 .AsFirstFragment() 864 .AsFirstPacket() 865 .Build())); 866 867 RTC_UNUSED(packet_buffer.InsertPacket(H264Packet(kH264FuA) 868 .Slice() 869 .SeqNum(kBufferSize + 3) 870 .Time(kBufferSize + 1) 871 .Marker() 872 .Build())); 873 EXPECT_THAT( 874 packet_buffer 875 .InsertPacket(H264Packet(kH264FuA).Slice().SeqNum(2).Time(2).Build()) 876 .packets, 877 IsEmpty()); 878 879 EXPECT_THAT(packet_buffer 880 .InsertPacket(H264Packet(kH264FuA) 881 .Slice() 882 .SeqNum(kBufferSize + 2) 883 .Time(kBufferSize + 1) 884 .Build()) 885 .packets, 886 SizeIs(3)); 887 } 888 889 TEST(H26xPacketBufferTest, OldPacketDoesntCompleteFrame) { 890 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 891 892 EXPECT_THAT(packet_buffer 893 .InsertPacket(H264Packet(kH264StapA) 894 .Sps() 895 .Pps() 896 .Idr() 897 .SeqNum(kBufferSize) 898 .Time(kBufferSize) 899 .AsFirstPacket() 900 .Marker() 901 .Build()) 902 .packets, 903 SizeIs(1)); 904 905 EXPECT_THAT(packet_buffer 906 .InsertPacket(H264Packet(kH264FuA) 907 .Slice() 908 .SeqNum(kBufferSize + 3) 909 .Time(kBufferSize + 1) 910 .Marker() 911 .Build()) 912 .packets, 913 IsEmpty()); 914 915 EXPECT_THAT( 916 packet_buffer 917 .InsertPacket( 918 H264Packet(kH264FuA).Slice().SeqNum(2).Time(2).Marker().Build()) 919 .packets, 920 IsEmpty()); 921 922 EXPECT_THAT(packet_buffer 923 .InsertPacket(H264Packet(kH264FuA) 924 .Slice() 925 .SeqNum(kBufferSize + 1) 926 .Time(kBufferSize + 1) 927 .AsFirstFragment() 928 .AsFirstPacket() 929 .Build()) 930 .packets, 931 IsEmpty()); 932 } 933 934 TEST(H26xPacketBufferTest, FrameBoundariesAreSet) { 935 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 936 937 auto key = packet_buffer.InsertPacket(H264Packet(kH264StapA) 938 .Sps() 939 .Pps() 940 .Idr() 941 .SeqNum(1) 942 .Time(1) 943 .Marker() 944 .Build()); 945 946 ASSERT_THAT(key.packets, SizeIs(1)); 947 EXPECT_TRUE(key.packets[0]->video_header.is_first_packet_in_frame); 948 EXPECT_TRUE(key.packets[0]->video_header.is_last_packet_in_frame); 949 950 RTC_UNUSED(packet_buffer.InsertPacket( 951 H264Packet(kH264FuA).Slice().SeqNum(2).Time(2).Build())); 952 RTC_UNUSED(packet_buffer.InsertPacket( 953 H264Packet(kH264FuA).Slice().SeqNum(3).Time(2).Build())); 954 auto delta = packet_buffer.InsertPacket( 955 H264Packet(kH264FuA).Slice().SeqNum(4).Time(2).Marker().Build()); 956 957 ASSERT_THAT(delta.packets, SizeIs(3)); 958 EXPECT_TRUE(delta.packets[0]->video_header.is_first_packet_in_frame); 959 EXPECT_FALSE(delta.packets[0]->video_header.is_last_packet_in_frame); 960 961 EXPECT_FALSE(delta.packets[1]->video_header.is_first_packet_in_frame); 962 EXPECT_FALSE(delta.packets[1]->video_header.is_last_packet_in_frame); 963 964 EXPECT_FALSE(delta.packets[2]->video_header.is_first_packet_in_frame); 965 EXPECT_TRUE(delta.packets[2]->video_header.is_last_packet_in_frame); 966 } 967 968 TEST(H26xPacketBufferTest, ResolutionSetOnFirstPacket) { 969 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 970 971 RTC_UNUSED(packet_buffer.InsertPacket(H264Packet(kH264SingleNalu) 972 .Aud() 973 .SeqNum(1) 974 .AsFirstPacket() 975 .Time(1) 976 .Build())); 977 auto res = packet_buffer.InsertPacket(H264Packet(kH264StapA) 978 .SpsWithResolution({320, 240}) 979 .Pps() 980 .Idr() 981 .SeqNum(2) 982 .AsFirstPacket() 983 .Time(1) 984 .Marker() 985 .Build()); 986 987 ASSERT_THAT(res.packets, SizeIs(2)); 988 EXPECT_THAT(res.packets[0]->video_header.width, Eq(320)); 989 EXPECT_THAT(res.packets[0]->video_header.height, Eq(240)); 990 } 991 992 TEST(H26xPacketBufferTest, KeyframeAndDeltaFrameSetOnFirstPacket) { 993 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 994 995 RTC_UNUSED(packet_buffer.InsertPacket(H264Packet(kH264SingleNalu) 996 .Aud() 997 .SeqNum(1) 998 .AsFirstPacket() 999 .Time(1) 1000 .Build())); 1001 auto key = packet_buffer.InsertPacket(H264Packet(kH264StapA) 1002 .Sps() 1003 .Pps() 1004 .Idr() 1005 .SeqNum(2) 1006 .AsFirstPacket() 1007 .Time(1) 1008 .Marker() 1009 .Build()); 1010 1011 auto delta = packet_buffer.InsertPacket(H264Packet(kH264SingleNalu) 1012 .Slice() 1013 .SeqNum(3) 1014 .Time(2) 1015 .AsFirstPacket() 1016 .Marker() 1017 .Build()); 1018 1019 ASSERT_THAT(key.packets, SizeIs(2)); 1020 EXPECT_THAT(key.packets[0]->video_header.frame_type, 1021 Eq(VideoFrameType::kVideoFrameKey)); 1022 ASSERT_THAT(delta.packets, SizeIs(1)); 1023 EXPECT_THAT(delta.packets[0]->video_header.frame_type, 1024 Eq(VideoFrameType::kVideoFrameDelta)); 1025 } 1026 1027 TEST(H26xPacketBufferTest, RtpSeqNumWrap) { 1028 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 1029 1030 RTC_UNUSED(packet_buffer.InsertPacket(H264Packet(kH264StapA) 1031 .Sps() 1032 .Pps() 1033 .SeqNum(0xffff) 1034 .Time(0) 1035 .AsFirstPacket() 1036 .Build())); 1037 1038 RTC_UNUSED(packet_buffer.InsertPacket(H264Packet(kH264FuA) 1039 .Idr() 1040 .SeqNum(0x1'0000) 1041 .Time(0) 1042 .AsFirstPacket() 1043 .Build())); 1044 EXPECT_THAT(packet_buffer 1045 .InsertPacket(H264Packet(kH264FuA) 1046 .Idr() 1047 .SeqNum(0x1'0001) 1048 .Time(0) 1049 .Marker() 1050 .Build()) 1051 .packets, 1052 SizeIs(3)); 1053 } 1054 1055 TEST(H26xPacketBufferTest, StapAFixedBitstream) { 1056 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 1057 1058 auto packets = packet_buffer 1059 .InsertPacket(H264Packet(kH264StapA) 1060 .Sps({1, 2, 3}) 1061 .Pps({4, 5, 6}) 1062 .Idr({7, 8, 9}) 1063 .SeqNum(0) 1064 .Time(0) 1065 .AsFirstPacket() 1066 .Marker() 1067 .Build()) 1068 .packets; 1069 1070 ASSERT_THAT(packets, SizeIs(1)); 1071 EXPECT_THAT(PacketPayload(packets[0]), 1072 ElementsAreArray(FlatVector({StartCode(), 1073 {kSps, 1, 2, 3}, 1074 StartCode(), 1075 {kPps, 4, 5, 6}, 1076 StartCode(), 1077 {kIdr, 7, 8, 9}}))); 1078 } 1079 1080 TEST(H26xPacketBufferTest, SingleNaluFixedBitstream) { 1081 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 1082 1083 RTC_UNUSED(packet_buffer.InsertPacket(H264Packet(kH264SingleNalu) 1084 .Sps({1, 2, 3}) 1085 .SeqNum(0) 1086 .Time(0) 1087 .AsFirstPacket() 1088 .Build())); 1089 RTC_UNUSED(packet_buffer.InsertPacket(H264Packet(kH264SingleNalu) 1090 .Pps({4, 5, 6}) 1091 .SeqNum(1) 1092 .Time(0) 1093 .AsFirstPacket() 1094 .Build())); 1095 auto packets = packet_buffer 1096 .InsertPacket(H264Packet(kH264SingleNalu) 1097 .Idr({7, 8, 9}) 1098 .SeqNum(2) 1099 .Time(0) 1100 .AsFirstPacket() 1101 .Marker() 1102 .Build()) 1103 .packets; 1104 1105 ASSERT_THAT(packets, SizeIs(3)); 1106 EXPECT_THAT(PacketPayload(packets[0]), 1107 ElementsAreArray(FlatVector({StartCode(), {kSps, 1, 2, 3}}))); 1108 EXPECT_THAT(PacketPayload(packets[1]), 1109 ElementsAreArray(FlatVector({StartCode(), {kPps, 4, 5, 6}}))); 1110 EXPECT_THAT(PacketPayload(packets[2]), 1111 ElementsAreArray(FlatVector({StartCode(), {kIdr, 7, 8, 9}}))); 1112 } 1113 1114 TEST(H26xPacketBufferTest, StapaAndFuaFixedBitstream) { 1115 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 1116 1117 RTC_UNUSED(packet_buffer.InsertPacket(H264Packet(kH264StapA) 1118 .Sps({1, 2, 3}) 1119 .Pps({4, 5, 6}) 1120 .SeqNum(0) 1121 .Time(0) 1122 .AsFirstPacket() 1123 .Build())); 1124 RTC_UNUSED(packet_buffer.InsertPacket(H264Packet(kH264FuA) 1125 .Idr({8, 8, 8}) 1126 .SeqNum(1) 1127 .Time(0) 1128 .AsFirstFragment() 1129 .AsFirstPacket() 1130 .Build())); 1131 auto packets = packet_buffer 1132 .InsertPacket(H264Packet(kH264FuA) 1133 .Idr({9, 9, 9}) 1134 .SeqNum(2) 1135 .Time(0) 1136 .Marker() 1137 .Build()) 1138 .packets; 1139 1140 ASSERT_THAT(packets, SizeIs(3)); 1141 EXPECT_THAT( 1142 PacketPayload(packets[0]), 1143 ElementsAreArray(FlatVector( 1144 {StartCode(), {kSps, 1, 2, 3}, StartCode(), {kPps, 4, 5, 6}}))); 1145 EXPECT_THAT(PacketPayload(packets[1]), 1146 ElementsAreArray(FlatVector({StartCode(), {8, 8, 8}}))); 1147 // Third is a continuation of second, so only the payload is expected. 1148 EXPECT_THAT(PacketPayload(packets[2]), 1149 ElementsAreArray(FlatVector({{9, 9, 9}}))); 1150 } 1151 1152 TEST(H26xPacketBufferTest, FullPacketBufferDoesNotBlockKeyframe) { 1153 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 1154 1155 for (int i = 0; i < kBufferSize; ++i) { 1156 EXPECT_THAT( 1157 packet_buffer 1158 .InsertPacket( 1159 H264Packet(kH264SingleNalu).Slice().SeqNum(i).Time(0).Build()) 1160 .packets, 1161 IsEmpty()); 1162 } 1163 1164 EXPECT_THAT(packet_buffer 1165 .InsertPacket(H264Packet(kH264StapA) 1166 .Sps() 1167 .Pps() 1168 .Idr() 1169 .SeqNum(kBufferSize) 1170 .Time(1) 1171 .AsFirstPacket() 1172 .Marker() 1173 .Build()) 1174 .packets, 1175 SizeIs(1)); 1176 } 1177 1178 TEST(H26xPacketBufferTest, AssembleFrameAfterReordering) { 1179 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 1180 1181 EXPECT_THAT(packet_buffer 1182 .InsertPacket(H264Packet(kH264StapA) 1183 .Sps() 1184 .Pps() 1185 .Idr() 1186 .SeqNum(2) 1187 .Time(2) 1188 .AsFirstPacket() 1189 .Marker() 1190 .Build()) 1191 .packets, 1192 SizeIs(1)); 1193 1194 EXPECT_THAT(packet_buffer 1195 .InsertPacket(H264Packet(kH264SingleNalu) 1196 .Slice() 1197 .SeqNum(1) 1198 .Time(1) 1199 .AsFirstPacket() 1200 .Marker() 1201 .Build()) 1202 .packets, 1203 IsEmpty()); 1204 1205 EXPECT_THAT(packet_buffer 1206 .InsertPacket(H264Packet(kH264StapA) 1207 .Sps() 1208 .Pps() 1209 .Idr() 1210 .SeqNum(0) 1211 .Time(0) 1212 .AsFirstPacket() 1213 .Marker() 1214 .Build()) 1215 .packets, 1216 SizeIs(2)); 1217 } 1218 1219 TEST(H26xPacketBufferTest, AssembleFrameAfterLoss) { 1220 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 1221 1222 EXPECT_THAT(packet_buffer 1223 .InsertPacket(H264Packet(kH264StapA) 1224 .Sps() 1225 .Pps() 1226 .Idr() 1227 .SeqNum(0) 1228 .Time(0) 1229 .AsFirstPacket() 1230 .Marker() 1231 .Build()) 1232 .packets, 1233 SizeIs(1)); 1234 1235 EXPECT_THAT(packet_buffer 1236 .InsertPacket(H264Packet(kH264StapA) 1237 .Sps() 1238 .Pps() 1239 .Idr() 1240 .SeqNum(2) 1241 .Time(2) 1242 .AsFirstPacket() 1243 .Marker() 1244 .Build()) 1245 .packets, 1246 SizeIs(1)); 1247 } 1248 1249 #ifdef RTC_ENABLE_H265 1250 TEST(H26xPacketBufferTest, H265VpsSpsPpsIdrIsKeyframe) { 1251 H26xPacketBuffer packet_buffer(/*allow_idr_only_keyframes=*/false); 1252 1253 EXPECT_THAT(packet_buffer 1254 .InsertPacket(H265Packet() 1255 .Vps() 1256 .Sps() 1257 .Pps() 1258 .Idr() 1259 .AsFirstPacket() 1260 .Marker() 1261 .Build()) 1262 .packets, 1263 SizeIs(1)); 1264 } 1265 1266 TEST(H26xPacketBufferTest, H265IrapIsNotKeyframe) { 1267 std::vector<H265::NaluType> irap_types = { 1268 H265::NaluType::kBlaWLp, H265::NaluType::kBlaWRadl, 1269 H265::NaluType::kBlaNLp, H265::NaluType::kIdrWRadl, 1270 H265::NaluType::kIdrNLp, H265::NaluType::kCra, 1271 H265::NaluType::kRsvIrapVcl23}; 1272 for (const H265::NaluType type : irap_types) { 1273 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 1274 1275 EXPECT_THAT( 1276 packet_buffer 1277 .InsertPacket( 1278 H265Packet().Slice(type).AsFirstPacket().Marker().Build()) 1279 .packets, 1280 IsEmpty()); 1281 } 1282 } 1283 1284 TEST(H26xPacketBufferTest, H265IdrIsNotKeyFrame) { 1285 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 1286 1287 EXPECT_THAT( 1288 packet_buffer 1289 .InsertPacket(H265Packet().Idr().AsFirstPacket().Marker().Build()) 1290 .packets, 1291 IsEmpty()); 1292 } 1293 1294 TEST(H26xPacketBufferTest, H265IdrIsNotKeyFrameEvenWithSprop) { 1295 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/true); 1296 packet_buffer.SetSpropParameterSets(kExampleSpropString); 1297 1298 EXPECT_THAT( 1299 packet_buffer 1300 .InsertPacket(H265Packet().Idr().AsFirstPacket().Marker().Build()) 1301 .packets, 1302 IsEmpty()); 1303 } 1304 1305 TEST(H26xPacketBufferTest, H265SpsPpsIdrIsNotKeyFrame) { 1306 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 1307 1308 EXPECT_THAT( 1309 packet_buffer 1310 .InsertPacket( 1311 H265Packet().Sps().Pps().Idr().AsFirstPacket().Marker().Build()) 1312 .packets, 1313 IsEmpty()); 1314 } 1315 1316 TEST(H26xPacketBufferTest, H265VpsPpsIdrIsNotKeyFrame) { 1317 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 1318 1319 EXPECT_THAT( 1320 packet_buffer 1321 .InsertPacket( 1322 H265Packet().Vps().Pps().Idr().AsFirstPacket().Marker().Build()) 1323 .packets, 1324 IsEmpty()); 1325 } 1326 1327 TEST(H26xPacketBufferTest, H265VpsSpsIdrIsNotKeyFrame) { 1328 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 1329 1330 EXPECT_THAT( 1331 packet_buffer 1332 .InsertPacket( 1333 H265Packet().Vps().Sps().Idr().AsFirstPacket().Marker().Build()) 1334 .packets, 1335 IsEmpty()); 1336 } 1337 1338 TEST(H26xPacketBufferTest, H265VpsIdrIsNotKeyFrame) { 1339 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 1340 1341 EXPECT_THAT(packet_buffer 1342 .InsertPacket( 1343 H265Packet().Vps().Idr().AsFirstPacket().Marker().Build()) 1344 .packets, 1345 IsEmpty()); 1346 } 1347 1348 TEST(H26xPacketBufferTest, H265SpsIdrIsNotKeyFrame) { 1349 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 1350 1351 EXPECT_THAT(packet_buffer 1352 .InsertPacket( 1353 H265Packet().Sps().Idr().AsFirstPacket().Marker().Build()) 1354 .packets, 1355 IsEmpty()); 1356 } 1357 1358 TEST(H26xPacketBufferTest, H265PpsIdrIsNotKeyFrame) { 1359 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 1360 1361 EXPECT_THAT(packet_buffer 1362 .InsertPacket( 1363 H265Packet().Pps().Idr().AsFirstPacket().Marker().Build()) 1364 .packets, 1365 IsEmpty()); 1366 } 1367 1368 TEST(H26xPacketBufferTest, H265ResolutionSetOnSpsPacket) { 1369 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 1370 1371 RTC_UNUSED(packet_buffer.InsertPacket( 1372 H265Packet().Aud().SeqNum(1).Time(1).AsFirstPacket().Build())); 1373 auto res = packet_buffer.InsertPacket(H265Packet() 1374 .Vps() 1375 .SpsWithResolution({320, 240}) 1376 .Pps() 1377 .Idr() 1378 .SeqNum(2) 1379 .Time(1) 1380 .AsFirstPacket() 1381 .Marker() 1382 .Build()); 1383 1384 ASSERT_THAT(res.packets, SizeIs(2)); 1385 EXPECT_THAT(res.packets[0]->video_header.width, Eq(320)); 1386 EXPECT_THAT(res.packets[0]->video_header.height, Eq(240)); 1387 } 1388 1389 TEST(H26xPacketBufferTest, H265InsertingVpsSpsPpsLastCompletesKeyframe) { 1390 H26xPacketBuffer packet_buffer(/*h264_allow_idr_only_keyframes=*/false); 1391 1392 RTC_UNUSED(packet_buffer.InsertPacket( 1393 H265Packet().Idr().SeqNum(2).Time(1).Marker().Build())); 1394 1395 EXPECT_THAT(packet_buffer 1396 .InsertPacket(H265Packet() 1397 .Vps() 1398 .Sps() 1399 .Pps() 1400 .SeqNum(1) 1401 .Time(1) 1402 .AsFirstPacket() 1403 .Build()) 1404 .packets, 1405 SizeIs(2)); 1406 } 1407 #endif // RTC_ENABLE_H265 1408 1409 } // namespace 1410 } // namespace webrtc