diff --git a/call/payload_router.cc b/call/payload_router.cc index 8aaaad7ad4..cf24b42ef9 100644 --- a/call/payload_router.cc +++ b/call/payload_router.cc @@ -72,11 +72,13 @@ void CopyCodecSpecific(const CodecSpecificInfo* info, RTPVideoHeader* rtp) { rtp->vp9().end_of_picture = info->codecSpecific.VP9.end_of_picture; return; } - case kVideoCodecH264: - rtp->h264().packetization_mode = + case kVideoCodecH264: { + auto& h264_header = rtp->video_type_header.emplace(); + h264_header.packetization_mode = info->codecSpecific.H264.packetization_mode; rtp->simulcastIdx = info->codecSpecific.H264.simulcast_idx; return; + } case kVideoCodecMultiplex: case kVideoCodecGeneric: rtp->codec = kVideoCodecGeneric; diff --git a/call/payload_router_unittest.cc b/call/payload_router_unittest.cc index bd19ad35dd..d6dfedbb2b 100644 --- a/call/payload_router_unittest.cc +++ b/call/payload_router_unittest.cc @@ -445,8 +445,10 @@ TEST(PayloadRouterTest, InfoMappedToRtpVideoHeader_H264) { Unused, const RTPVideoHeader* header, Unused) { EXPECT_EQ(0, header->simulcastIdx); EXPECT_EQ(kVideoCodecH264, header->codec); + const auto& h264 = + absl::get(header->video_type_header); EXPECT_EQ(H264PacketizationMode::SingleNalUnit, - header->h264().packetization_mode); + h264.packetization_mode); return true; })); diff --git a/modules/rtp_rtcp/source/rtp_format.cc b/modules/rtp_rtcp/source/rtp_format.cc index 8bd27a7624..3f2038e1c6 100644 --- a/modules/rtp_rtcp/source/rtp_format.cc +++ b/modules/rtp_rtcp/source/rtp_format.cc @@ -23,17 +23,18 @@ RtpPacketizer* RtpPacketizer::Create(VideoCodecType type, size_t last_packet_reduction_len, const RTPVideoHeader* rtp_video_header, FrameType frame_type) { + RTC_CHECK(type == kVideoCodecGeneric || rtp_video_header); switch (type) { - case kVideoCodecH264: - RTC_CHECK(rtp_video_header); + case kVideoCodecH264: { + const auto& h264 = + absl::get(rtp_video_header->video_type_header); return new RtpPacketizerH264(max_payload_len, last_packet_reduction_len, - rtp_video_header->h264().packetization_mode); + h264.packetization_mode); + } case kVideoCodecVP8: - RTC_CHECK(rtp_video_header); return new RtpPacketizerVp8(rtp_video_header->vp8(), max_payload_len, last_packet_reduction_len); case kVideoCodecVP9: - RTC_CHECK(rtp_video_header); return new RtpPacketizerVp9(rtp_video_header->vp9(), max_payload_len, last_packet_reduction_len); case kVideoCodecGeneric: diff --git a/modules/rtp_rtcp/source/rtp_format_h264.cc b/modules/rtp_rtcp/source/rtp_format_h264.cc index 0b8c15f866..45e8d11fe2 100644 --- a/modules/rtp_rtcp/source/rtp_format_h264.cc +++ b/modules/rtp_rtcp/source/rtp_format_h264.cc @@ -429,7 +429,8 @@ bool RtpDepacketizerH264::Parse(ParsedPayload* parsed_payload, modified_buffer_.reset(); uint8_t nal_type = payload_data[0] & kTypeMask; - parsed_payload->video_header().h264().nalus_length = 0; + parsed_payload->video_header() + .video_type_header.emplace(); if (nal_type == H264::NaluType::kFuA) { // Fragmented NAL units (FU-A). if (!ParseFuaNalu(parsed_payload, payload_data)) @@ -458,7 +459,8 @@ bool RtpDepacketizerH264::ProcessStapAOrSingleNalu( parsed_payload->video_header().codec = kVideoCodecH264; parsed_payload->video_header().simulcastIdx = 0; parsed_payload->video_header().is_first_packet_in_frame = true; - RTPVideoHeaderH264* h264_header = &parsed_payload->video_header().h264(); + auto& h264_header = absl::get( + parsed_payload->video_header().video_type_header); const uint8_t* nalu_start = payload_data + kNalHeaderSize; const size_t nalu_length = length_ - kNalHeaderSize; @@ -476,13 +478,13 @@ bool RtpDepacketizerH264::ProcessStapAOrSingleNalu( return false; } - h264_header->packetization_type = kH264StapA; + h264_header.packetization_type = kH264StapA; nal_type = payload_data[kStapAHeaderSize] & kTypeMask; } else { - h264_header->packetization_type = kH264SingleNalu; + h264_header.packetization_type = kH264SingleNalu; nalu_start_offsets.push_back(0); } - h264_header->nalu_type = nal_type; + h264_header.nalu_type = nal_type; parsed_payload->frame_type = kVideoFrameDelta; nalu_start_offsets.push_back(length_ + kLengthFieldSize); // End offset. @@ -528,7 +530,7 @@ bool RtpDepacketizerH264::ProcessStapAOrSingleNalu( } // Rewrite length field to new SPS size. - if (h264_header->packetization_type == kH264StapA) { + if (h264_header.packetization_type == kH264StapA) { size_t length_field_offset = start_offset - (H264::kNaluTypeSize + kLengthFieldSize); // Stap-A Length includes payload data and type header. @@ -617,13 +619,13 @@ bool RtpDepacketizerH264::ProcessStapAOrSingleNalu( RTC_LOG(LS_WARNING) << "Unexpected STAP-A or FU-A received."; return false; } - RTPVideoHeaderH264* h264 = &parsed_payload->video_header().h264(); - if (h264->nalus_length == kMaxNalusPerPacket) { + + if (h264_header.nalus_length == kMaxNalusPerPacket) { RTC_LOG(LS_WARNING) << "Received packet containing more than " << kMaxNalusPerPacket << " NAL units. Will not keep track sps and pps ids for all of them."; } else { - h264->nalus[h264->nalus_length++] = nalu; + h264_header.nalus[h264_header.nalus_length++] = nalu; } } @@ -676,12 +678,13 @@ bool RtpDepacketizerH264::ParseFuaNalu( parsed_payload->video_header().codec = kVideoCodecH264; parsed_payload->video_header().simulcastIdx = 0; parsed_payload->video_header().is_first_packet_in_frame = first_fragment; - RTPVideoHeaderH264* h264 = &parsed_payload->video_header().h264(); - h264->packetization_type = kH264FuA; - h264->nalu_type = original_nal_type; + auto& h264_header = absl::get( + parsed_payload->video_header().video_type_header); + h264_header.packetization_type = kH264FuA; + h264_header.nalu_type = original_nal_type; if (first_fragment) { - h264->nalus[h264->nalus_length] = nalu; - h264->nalus_length = 1; + h264_header.nalus[h264_header.nalus_length] = nalu; + h264_header.nalus_length = 1; } return true; } diff --git a/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc b/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc index dc17b4fb34..1f69fcb3ba 100644 --- a/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_format_h264_unittest.cc @@ -26,6 +26,12 @@ namespace { using ::testing::ElementsAreArray; +struct H264ParsedPayload : public RtpDepacketizer::ParsedPayload { + RTPVideoHeaderH264& h264() { + return absl::get(video.video_type_header); + } +}; + constexpr RtpPacketToSend::ExtensionManager* kNoExtensions = nullptr; const size_t kMaxPayloadSize = 1200; const size_t kLengthFieldLength = 2; @@ -66,7 +72,8 @@ RtpPacketizer* CreateH264Packetizer(H264PacketizationMode mode, size_t max_payload_size, size_t last_packet_reduction) { RTPVideoHeader header; - header.h264().packetization_mode = mode; + header.video_type_header.emplace().packetization_mode = + mode; return RtpPacketizer::Create(kVideoCodecH264, max_payload_size, last_packet_reduction, &header, kEmptyFrame); } @@ -579,7 +586,7 @@ class RtpDepacketizerH264Test : public ::testing::Test { RtpDepacketizerH264Test() : depacketizer_(RtpDepacketizer::Create(kVideoCodecH264)) {} - void ExpectPacket(RtpDepacketizer::ParsedPayload* parsed_payload, + void ExpectPacket(H264ParsedPayload* parsed_payload, const uint8_t* data, size_t length) { ASSERT_TRUE(parsed_payload != NULL); @@ -594,29 +601,29 @@ class RtpDepacketizerH264Test : public ::testing::Test { TEST_F(RtpDepacketizerH264Test, TestSingleNalu) { uint8_t packet[2] = {0x05, 0xFF}; // F=0, NRI=0, Type=5 (IDR). - RtpDepacketizer::ParsedPayload payload; + H264ParsedPayload payload; ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet))); ExpectPacket(&payload, packet, sizeof(packet)); EXPECT_EQ(kVideoFrameKey, payload.frame_type); EXPECT_EQ(kVideoCodecH264, payload.video_header().codec); EXPECT_TRUE(payload.video_header().is_first_packet_in_frame); - EXPECT_EQ(kH264SingleNalu, payload.video_header().h264().packetization_type); - EXPECT_EQ(kIdr, payload.video_header().h264().nalu_type); + EXPECT_EQ(kH264SingleNalu, payload.h264().packetization_type); + EXPECT_EQ(kIdr, payload.h264().nalu_type); } TEST_F(RtpDepacketizerH264Test, TestSingleNaluSpsWithResolution) { uint8_t packet[] = {kSps, 0x7A, 0x00, 0x1F, 0xBC, 0xD9, 0x40, 0x50, 0x05, 0xBA, 0x10, 0x00, 0x00, 0x03, 0x00, 0xC0, 0x00, 0x00, 0x03, 0x2A, 0xE0, 0xF1, 0x83, 0x25}; - RtpDepacketizer::ParsedPayload payload; + H264ParsedPayload payload; ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet))); ExpectPacket(&payload, packet, sizeof(packet)); EXPECT_EQ(kVideoFrameKey, payload.frame_type); EXPECT_EQ(kVideoCodecH264, payload.video_header().codec); EXPECT_TRUE(payload.video_header().is_first_packet_in_frame); - EXPECT_EQ(kH264SingleNalu, payload.video_header().h264().packetization_type); + EXPECT_EQ(kH264SingleNalu, payload.h264().packetization_type); EXPECT_EQ(1280u, payload.video_header().width); EXPECT_EQ(720u, payload.video_header().height); } @@ -639,13 +646,13 @@ TEST_F(RtpDepacketizerH264Test, TestStapAKey) { 0x85, 0xB8, 0x0, 0x4, 0x0, 0x0, 0x13, 0x93, 0x12, 0x0}; // clang-format on - RtpDepacketizer::ParsedPayload payload; + H264ParsedPayload payload; ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet))); ExpectPacket(&payload, packet, sizeof(packet)); EXPECT_EQ(kVideoFrameKey, payload.frame_type); EXPECT_EQ(kVideoCodecH264, payload.video_header().codec); EXPECT_TRUE(payload.video_header().is_first_packet_in_frame); - const RTPVideoHeaderH264& h264 = payload.video_header().h264(); + const RTPVideoHeaderH264& h264 = payload.h264(); EXPECT_EQ(kH264StapA, h264.packetization_type); // NALU type for aggregated packets is the type of the first packet only. EXPECT_EQ(kSps, h264.nalu_type); @@ -669,14 +676,14 @@ TEST_F(RtpDepacketizerH264Test, TestStapANaluSpsWithResolution) { 0x00, 0x03, kIdr, 0xFF, 0x00, 0x00, 0x04, kIdr, 0xFF, 0x00, 0x11}; - RtpDepacketizer::ParsedPayload payload; + H264ParsedPayload payload; ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet))); ExpectPacket(&payload, packet, sizeof(packet)); EXPECT_EQ(kVideoFrameKey, payload.frame_type); EXPECT_EQ(kVideoCodecH264, payload.video_header().codec); EXPECT_TRUE(payload.video_header().is_first_packet_in_frame); - EXPECT_EQ(kH264StapA, payload.video_header().h264().packetization_type); + EXPECT_EQ(kH264StapA, payload.h264().packetization_type); EXPECT_EQ(1280u, payload.video_header().width); EXPECT_EQ(720u, payload.video_header().height); } @@ -693,7 +700,7 @@ TEST_F(RtpDepacketizerH264Test, TestEmptyStapARejected) { uint8_t trailing_empty_packet[] = {kStapA, 0x00, 0x03, kIdr, 0xFF, 0x00, 0x00, 0x00}; - RtpDepacketizer::ParsedPayload payload; + H264ParsedPayload payload; EXPECT_FALSE(depacketizer_->Parse(&payload, lone_empty_packet, sizeof(lone_empty_packet))); @@ -732,7 +739,7 @@ TEST_F(RtpDepacketizerH264Test, DepacketizeWithRewriting) { out_buffer.AppendData(kHeader, 2); out_buffer.AppendData(kIdrTwo); - RtpDepacketizer::ParsedPayload payload; + H264ParsedPayload payload; EXPECT_TRUE( depacketizer_->Parse(&payload, in_buffer.data(), in_buffer.size())); @@ -779,7 +786,7 @@ TEST_F(RtpDepacketizerH264Test, DepacketizeWithDoubleRewriting) { out_buffer.AppendData(kHeader, 2); out_buffer.AppendData(kIdrTwo); - RtpDepacketizer::ParsedPayload payload; + H264ParsedPayload payload; EXPECT_TRUE( depacketizer_->Parse(&payload, in_buffer.data(), in_buffer.size())); @@ -796,16 +803,16 @@ TEST_F(RtpDepacketizerH264Test, TestStapADelta) { // Length, nal header, payload. 0, 0x02, kSlice, 0xFF, 0, 0x03, kSlice, 0xFF, 0x00, 0, 0x04, kSlice, 0xFF, 0x00, 0x11}; - RtpDepacketizer::ParsedPayload payload; + H264ParsedPayload payload; ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet))); ExpectPacket(&payload, packet, sizeof(packet)); EXPECT_EQ(kVideoFrameDelta, payload.frame_type); EXPECT_EQ(kVideoCodecH264, payload.video_header().codec); EXPECT_TRUE(payload.video_header().is_first_packet_in_frame); - EXPECT_EQ(kH264StapA, payload.video_header().h264().packetization_type); + EXPECT_EQ(kH264StapA, payload.h264().packetization_type); // NALU type for aggregated packets is the type of the first packet only. - EXPECT_EQ(kSlice, payload.video_header().h264().nalu_type); + EXPECT_EQ(kSlice, payload.h264().nalu_type); } TEST_F(RtpDepacketizerH264Test, TestFuA) { @@ -833,7 +840,7 @@ TEST_F(RtpDepacketizerH264Test, TestFuA) { }; const uint8_t kExpected3[] = {0x03}; - RtpDepacketizer::ParsedPayload payload; + H264ParsedPayload payload; // We expect that the first packet is one byte shorter since the FU-A header // has been replaced by the original nal header. @@ -842,7 +849,7 @@ TEST_F(RtpDepacketizerH264Test, TestFuA) { EXPECT_EQ(kVideoFrameKey, payload.frame_type); EXPECT_EQ(kVideoCodecH264, payload.video_header().codec); EXPECT_TRUE(payload.video_header().is_first_packet_in_frame); - const RTPVideoHeaderH264& h264 = payload.video_header().h264(); + const RTPVideoHeaderH264& h264 = payload.h264(); EXPECT_EQ(kH264FuA, h264.packetization_type); EXPECT_EQ(kIdr, h264.nalu_type); ASSERT_EQ(1u, h264.nalus_length); @@ -852,28 +859,28 @@ TEST_F(RtpDepacketizerH264Test, TestFuA) { // Following packets will be 2 bytes shorter since they will only be appended // onto the first packet. - payload = RtpDepacketizer::ParsedPayload(); + payload = H264ParsedPayload(); ASSERT_TRUE(depacketizer_->Parse(&payload, packet2, sizeof(packet2))); ExpectPacket(&payload, kExpected2, sizeof(kExpected2)); EXPECT_EQ(kVideoFrameKey, payload.frame_type); EXPECT_EQ(kVideoCodecH264, payload.video_header().codec); EXPECT_FALSE(payload.video_header().is_first_packet_in_frame); { - const RTPVideoHeaderH264& h264 = payload.video_header().h264(); + const RTPVideoHeaderH264& h264 = payload.h264(); EXPECT_EQ(kH264FuA, h264.packetization_type); EXPECT_EQ(kIdr, h264.nalu_type); // NALU info is only expected for the first FU-A packet. EXPECT_EQ(0u, h264.nalus_length); } - payload = RtpDepacketizer::ParsedPayload(); + payload = H264ParsedPayload(); ASSERT_TRUE(depacketizer_->Parse(&payload, packet3, sizeof(packet3))); ExpectPacket(&payload, kExpected3, sizeof(kExpected3)); EXPECT_EQ(kVideoFrameKey, payload.frame_type); EXPECT_EQ(kVideoCodecH264, payload.video_header().codec); EXPECT_FALSE(payload.video_header().is_first_packet_in_frame); { - const RTPVideoHeaderH264& h264 = payload.video_header().h264(); + const RTPVideoHeaderH264& h264 = payload.h264(); EXPECT_EQ(kH264FuA, h264.packetization_type); EXPECT_EQ(kIdr, h264.nalu_type); // NALU info is only expected for the first FU-A packet. @@ -884,37 +891,37 @@ TEST_F(RtpDepacketizerH264Test, TestFuA) { TEST_F(RtpDepacketizerH264Test, TestEmptyPayload) { // Using a wild pointer to crash on accesses from inside the depacketizer. uint8_t* garbage_ptr = reinterpret_cast(0x4711); - RtpDepacketizer::ParsedPayload payload; + H264ParsedPayload payload; EXPECT_FALSE(depacketizer_->Parse(&payload, garbage_ptr, 0)); } TEST_F(RtpDepacketizerH264Test, TestTruncatedFuaNalu) { const uint8_t kPayload[] = {0x9c}; - RtpDepacketizer::ParsedPayload payload; + H264ParsedPayload payload; EXPECT_FALSE(depacketizer_->Parse(&payload, kPayload, sizeof(kPayload))); } TEST_F(RtpDepacketizerH264Test, TestTruncatedSingleStapANalu) { const uint8_t kPayload[] = {0xd8, 0x27}; - RtpDepacketizer::ParsedPayload payload; + H264ParsedPayload payload; EXPECT_FALSE(depacketizer_->Parse(&payload, kPayload, sizeof(kPayload))); } TEST_F(RtpDepacketizerH264Test, TestStapAPacketWithTruncatedNalUnits) { const uint8_t kPayload[] = {0x58, 0xCB, 0xED, 0xDF}; - RtpDepacketizer::ParsedPayload payload; + H264ParsedPayload payload; EXPECT_FALSE(depacketizer_->Parse(&payload, kPayload, sizeof(kPayload))); } TEST_F(RtpDepacketizerH264Test, TestTruncationJustAfterSingleStapANalu) { const uint8_t kPayload[] = {0x38, 0x27, 0x27}; - RtpDepacketizer::ParsedPayload payload; + H264ParsedPayload payload; EXPECT_FALSE(depacketizer_->Parse(&payload, kPayload, sizeof(kPayload))); } TEST_F(RtpDepacketizerH264Test, TestShortSpsPacket) { const uint8_t kPayload[] = {0x27, 0x80, 0x00}; - RtpDepacketizer::ParsedPayload payload; + H264ParsedPayload payload; EXPECT_TRUE(depacketizer_->Parse(&payload, kPayload, sizeof(kPayload))); } @@ -923,9 +930,9 @@ TEST_F(RtpDepacketizerH264Test, TestSeiPacket) { kSei, // F=0, NRI=0, Type=6. 0x03, 0x03, 0x03, 0x03 // Payload. }; - RtpDepacketizer::ParsedPayload payload; + H264ParsedPayload payload; ASSERT_TRUE(depacketizer_->Parse(&payload, kPayload, sizeof(kPayload))); - const RTPVideoHeaderH264& h264 = payload.video_header().h264(); + const RTPVideoHeaderH264& h264 = payload.h264(); EXPECT_EQ(kVideoFrameDelta, payload.frame_type); EXPECT_EQ(kH264SingleNalu, h264.packetization_type); EXPECT_EQ(kSei, h264.nalu_type); diff --git a/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/modules/rtp_rtcp/source/rtp_sender_unittest.cc index 1d0ddaf322..a88d95f7c4 100644 --- a/modules/rtp_rtcp/source/rtp_sender_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_sender_unittest.cc @@ -1102,7 +1102,6 @@ TEST_P(RtpSenderTest, NoFlexfecForTimingFrames) { EXPECT_EQ(0, rtp_sender_->RegisterPayload(payload_name, kPayloadType, 90000, 0, 1500)); RTPVideoHeader video_header; - memset(&video_header, 0, sizeof(RTPVideoHeader)); video_header.video_timing.flags = VideoSendTiming::kTriggeredByTimer; EXPECT_TRUE(rtp_sender_->SendOutgoingData( kVideoFrameKey, kPayloadType, kTimestamp, kCaptureTimeMs, kPayloadData, @@ -1810,8 +1809,9 @@ TEST_P(RtpSenderVideoTest, RetransmissionTypesGeneric) { TEST_P(RtpSenderVideoTest, RetransmissionTypesH264) { RTPVideoHeader header; + header.video_type_header.emplace().packetization_mode = + H264PacketizationMode::NonInterleaved; header.codec = kVideoCodecH264; - header.h264().packetization_mode = H264PacketizationMode::NonInterleaved; EXPECT_EQ(kDontRetransmit, rtp_sender_video_->GetStorageType( diff --git a/modules/rtp_rtcp/source/rtp_video_header.h b/modules/rtp_rtcp/source/rtp_video_header.h index 49e2d2978c..5aa2a3c604 100644 --- a/modules/rtp_rtcp/source/rtp_video_header.h +++ b/modules/rtp_rtcp/source/rtp_video_header.h @@ -55,20 +55,6 @@ struct RTPVideoHeader { return absl::get(video_type_header); } - // TODO(philipel): Remove when downstream projects have been updated. - RTPVideoHeaderH264& h264() { - if (!absl::holds_alternative(video_type_header)) - video_type_header.emplace(); - - return absl::get(video_type_header); - } - // TODO(philipel): Remove when downstream projects have been updated. - const RTPVideoHeaderH264& h264() const { - if (!absl::holds_alternative(video_type_header)) - video_type_header.emplace(); - - return absl::get(video_type_header); - } uint16_t width; uint16_t height; diff --git a/modules/video_coding/h264_sps_pps_tracker.cc b/modules/video_coding/h264_sps_pps_tracker.cc index 51931f89d2..d67d827b08 100644 --- a/modules/video_coding/h264_sps_pps_tracker.cc +++ b/modules/video_coding/h264_sps_pps_tracker.cc @@ -36,14 +36,15 @@ H264SpsPpsTracker::PacketAction H264SpsPpsTracker::CopyAndFixBitstream( const uint8_t* data = packet->dataPtr; const size_t data_size = packet->sizeBytes; const RTPVideoHeader& video_header = packet->video_header; - RTPVideoHeaderH264* codec_header = &packet->video_header.h264(); + auto& h264_header = + absl::get(packet->video_header.video_type_header); bool append_sps_pps = false; auto sps = sps_data_.end(); auto pps = pps_data_.end(); - for (size_t i = 0; i < codec_header->nalus_length; ++i) { - const NaluInfo& nalu = codec_header->nalus[i]; + for (size_t i = 0; i < h264_header.nalus_length; ++i) { + const NaluInfo& nalu = h264_header.nalus[i]; switch (nalu.type) { case H264::NaluType::kSps: { sps_data_[nalu.sps_id].width = packet->width; @@ -110,7 +111,7 @@ H264SpsPpsTracker::PacketAction H264SpsPpsTracker::CopyAndFixBitstream( required_size += pps->second.size + sizeof(start_code_h264); } - if (codec_header->packetization_type == kH264StapA) { + if (h264_header.packetization_type == kH264StapA) { const uint8_t* nalu_ptr = data + 1; while (nalu_ptr < data + data_size) { RTC_DCHECK(video_header.is_first_packet_in_frame); @@ -155,9 +156,9 @@ H264SpsPpsTracker::PacketAction H264SpsPpsTracker::CopyAndFixBitstream( pps_info.type = H264::NaluType::kPps; pps_info.sps_id = sps->first; pps_info.pps_id = pps->first; - if (codec_header->nalus_length + 2 <= kMaxNalusPerPacket) { - codec_header->nalus[codec_header->nalus_length++] = sps_info; - codec_header->nalus[codec_header->nalus_length++] = pps_info; + if (h264_header.nalus_length + 2 <= kMaxNalusPerPacket) { + h264_header.nalus[h264_header.nalus_length++] = sps_info; + h264_header.nalus[h264_header.nalus_length++] = pps_info; } else { RTC_LOG(LS_WARNING) << "Not enough space in H.264 codec header to insert " "SPS/PPS provided out-of-band."; @@ -165,7 +166,7 @@ H264SpsPpsTracker::PacketAction H264SpsPpsTracker::CopyAndFixBitstream( } // Copy the rest of the bitstream and insert start codes. - if (codec_header->packetization_type == kH264StapA) { + if (h264_header.packetization_type == kH264StapA) { const uint8_t* nalu_ptr = data + 1; while (nalu_ptr < data + data_size) { memcpy(insert_at, start_code_h264, sizeof(start_code_h264)); diff --git a/modules/video_coding/h264_sps_pps_tracker_unittest.cc b/modules/video_coding/h264_sps_pps_tracker_unittest.cc index 4b43955cd7..dad82943dc 100644 --- a/modules/video_coding/h264_sps_pps_tracker_unittest.cc +++ b/modules/video_coding/h264_sps_pps_tracker_unittest.cc @@ -46,21 +46,29 @@ void ExpectSpsPpsIdr(const RTPVideoHeaderH264& codec_header, EXPECT_TRUE(contains_idr); } +class H264VcmPacket : public VCMPacket { + public: + H264VcmPacket() { + codec = kVideoCodecH264; + video_header.is_first_packet_in_frame = false; + auto& type_header = + video_header.video_type_header.emplace(); + type_header.nalus_length = 0; + type_header.packetization_type = kH264SingleNalu; + } + + RTPVideoHeaderH264& h264() { + return absl::get(video_header.video_type_header); + } +}; + } // namespace class TestH264SpsPpsTracker : public ::testing::Test { public: - VCMPacket GetDefaultPacket() { - VCMPacket packet; - packet.codec = kVideoCodecH264; - packet.video_header.h264().nalus_length = 0; - packet.video_header.is_first_packet_in_frame = false; - packet.video_header.h264().packetization_type = kH264SingleNalu; - - return packet; - } - - void AddSps(VCMPacket* packet, uint8_t sps_id, std::vector* data) { + void AddSps(H264VcmPacket* packet, + uint8_t sps_id, + std::vector* data) { NaluInfo info; info.type = H264::NaluType::kSps; info.sps_id = sps_id; @@ -68,11 +76,10 @@ class TestH264SpsPpsTracker : public ::testing::Test { data->push_back(H264::NaluType::kSps); data->push_back(sps_id); // The sps data, just a single byte. - packet->video_header.h264() - .nalus[packet->video_header.h264().nalus_length++] = info; + packet->h264().nalus[packet->h264().nalus_length++] = info; } - void AddPps(VCMPacket* packet, + void AddPps(H264VcmPacket* packet, uint8_t sps_id, uint8_t pps_id, std::vector* data) { @@ -83,18 +90,16 @@ class TestH264SpsPpsTracker : public ::testing::Test { data->push_back(H264::NaluType::kPps); data->push_back(pps_id); // The pps data, just a single byte. - packet->video_header.h264() - .nalus[packet->video_header.h264().nalus_length++] = info; + packet->h264().nalus[packet->h264().nalus_length++] = info; } - void AddIdr(VCMPacket* packet, int pps_id) { + void AddIdr(H264VcmPacket* packet, int pps_id) { NaluInfo info; info.type = H264::NaluType::kIdr; info.sps_id = -1; info.pps_id = pps_id; - packet->video_header.h264() - .nalus[packet->video_header.h264().nalus_length++] = info; + packet->h264().nalus[packet->h264().nalus_length++] = info; } protected: @@ -103,8 +108,8 @@ class TestH264SpsPpsTracker : public ::testing::Test { TEST_F(TestH264SpsPpsTracker, NoNalus) { uint8_t data[] = {1, 2, 3}; - VCMPacket packet = GetDefaultPacket(); - packet.video_header.h264().packetization_type = kH264FuA; + H264VcmPacket packet; + packet.h264().packetization_type = kH264FuA; packet.dataPtr = data; packet.sizeBytes = sizeof(data); @@ -115,8 +120,8 @@ TEST_F(TestH264SpsPpsTracker, NoNalus) { TEST_F(TestH264SpsPpsTracker, FuAFirstPacket) { uint8_t data[] = {1, 2, 3}; - VCMPacket packet = GetDefaultPacket(); - packet.video_header.h264().packetization_type = kH264FuA; + H264VcmPacket packet; + packet.h264().packetization_type = kH264FuA; packet.video_header.is_first_packet_in_frame = true; packet.dataPtr = data; packet.sizeBytes = sizeof(data); @@ -131,8 +136,8 @@ TEST_F(TestH264SpsPpsTracker, FuAFirstPacket) { TEST_F(TestH264SpsPpsTracker, StapAIncorrectSegmentLength) { uint8_t data[] = {0, 0, 2, 0}; - VCMPacket packet = GetDefaultPacket(); - packet.video_header.h264().packetization_type = kH264StapA; + H264VcmPacket packet; + packet.h264().packetization_type = kH264StapA; packet.video_header.is_first_packet_in_frame = true; packet.dataPtr = data; packet.sizeBytes = sizeof(data); @@ -142,7 +147,7 @@ TEST_F(TestH264SpsPpsTracker, StapAIncorrectSegmentLength) { TEST_F(TestH264SpsPpsTracker, NoNalusFirstPacket) { uint8_t data[] = {1, 2, 3}; - VCMPacket packet = GetDefaultPacket(); + H264VcmPacket packet; packet.video_header.is_first_packet_in_frame = true; packet.dataPtr = data; packet.sizeBytes = sizeof(data); @@ -157,8 +162,8 @@ TEST_F(TestH264SpsPpsTracker, NoNalusFirstPacket) { TEST_F(TestH264SpsPpsTracker, IdrNoSpsPpsInserted) { std::vector data = {1, 2, 3}; - VCMPacket packet = GetDefaultPacket(); - packet.video_header.h264().packetization_type = kH264FuA; + H264VcmPacket packet; + packet.h264().packetization_type = kH264FuA; AddIdr(&packet, 0); packet.dataPtr = data.data(); @@ -171,7 +176,7 @@ TEST_F(TestH264SpsPpsTracker, IdrNoSpsPpsInserted) { TEST_F(TestH264SpsPpsTracker, IdrFirstPacketNoSpsPpsInserted) { std::vector data = {1, 2, 3}; - VCMPacket packet = GetDefaultPacket(); + H264VcmPacket packet; packet.video_header.is_first_packet_in_frame = true; AddIdr(&packet, 0); @@ -184,7 +189,7 @@ TEST_F(TestH264SpsPpsTracker, IdrFirstPacketNoSpsPpsInserted) { TEST_F(TestH264SpsPpsTracker, IdrFirstPacketNoPpsInserted) { std::vector data = {1, 2, 3}; - VCMPacket packet = GetDefaultPacket(); + H264VcmPacket packet; packet.video_header.is_first_packet_in_frame = true; AddSps(&packet, 0, &data); @@ -198,7 +203,7 @@ TEST_F(TestH264SpsPpsTracker, IdrFirstPacketNoPpsInserted) { TEST_F(TestH264SpsPpsTracker, IdrFirstPacketNoSpsInserted) { std::vector data = {1, 2, 3}; - VCMPacket packet = GetDefaultPacket(); + H264VcmPacket packet; packet.video_header.is_first_packet_in_frame = true; AddPps(&packet, 0, 0, &data); @@ -212,7 +217,7 @@ TEST_F(TestH264SpsPpsTracker, IdrFirstPacketNoSpsInserted) { TEST_F(TestH264SpsPpsTracker, SpsPpsPacketThenIdrFirstPacket) { std::vector data; - VCMPacket sps_pps_packet = GetDefaultPacket(); + H264VcmPacket sps_pps_packet; // Insert SPS/PPS AddSps(&sps_pps_packet, 0, &data); @@ -225,7 +230,7 @@ TEST_F(TestH264SpsPpsTracker, SpsPpsPacketThenIdrFirstPacket) { data.clear(); // Insert first packet of the IDR - VCMPacket idr_packet = GetDefaultPacket(); + H264VcmPacket idr_packet; idr_packet.video_header.is_first_packet_in_frame = true; AddIdr(&idr_packet, 1); data.insert(data.end(), {1, 2, 3}); @@ -243,8 +248,8 @@ TEST_F(TestH264SpsPpsTracker, SpsPpsPacketThenIdrFirstPacket) { TEST_F(TestH264SpsPpsTracker, SpsPpsIdrInStapA) { std::vector data; - VCMPacket packet = GetDefaultPacket(); - packet.video_header.h264().packetization_type = kH264StapA; + H264VcmPacket packet; + packet.h264().packetization_type = kH264StapA; packet.video_header.is_first_packet_in_frame = true; // Always true for StapA data.insert(data.end(), {0}); // First byte is ignored @@ -284,18 +289,18 @@ TEST_F(TestH264SpsPpsTracker, SpsPpsOutOfBand) { tracker_.InsertSpsPpsNalus(sps, pps); // Insert first packet of the IDR. - VCMPacket idr_packet = GetDefaultPacket(); + H264VcmPacket idr_packet; idr_packet.video_header.is_first_packet_in_frame = true; AddIdr(&idr_packet, 0); idr_packet.dataPtr = kData; idr_packet.sizeBytes = sizeof(kData); - EXPECT_EQ(1u, idr_packet.video_header.h264().nalus_length); + EXPECT_EQ(1u, idr_packet.h264().nalus_length); EXPECT_EQ(H264SpsPpsTracker::kInsert, tracker_.CopyAndFixBitstream(&idr_packet)); - EXPECT_EQ(3u, idr_packet.video_header.h264().nalus_length); + EXPECT_EQ(3u, idr_packet.h264().nalus_length); EXPECT_EQ(320, idr_packet.width); EXPECT_EQ(240, idr_packet.height); - ExpectSpsPpsIdr(idr_packet.video_header.h264(), 0, 0); + ExpectSpsPpsIdr(idr_packet.h264(), 0, 0); if (idr_packet.dataPtr != kData) { // In case CopyAndFixBitStream() prepends SPS/PPS nalus to the packet, it @@ -317,7 +322,7 @@ TEST_F(TestH264SpsPpsTracker, SpsPpsOutOfBandWrongNaluHeader) { tracker_.InsertSpsPpsNalus(sps, pps); // Insert first packet of the IDR. - VCMPacket idr_packet = GetDefaultPacket(); + H264VcmPacket idr_packet; idr_packet.video_header.is_first_packet_in_frame = true; AddIdr(&idr_packet, 0); idr_packet.dataPtr = kData; @@ -336,7 +341,7 @@ TEST_F(TestH264SpsPpsTracker, SpsPpsOutOfBandIncompleteNalu) { tracker_.InsertSpsPpsNalus(sps, pps); // Insert first packet of the IDR. - VCMPacket idr_packet = GetDefaultPacket(); + H264VcmPacket idr_packet; idr_packet.video_header.is_first_packet_in_frame = true; AddIdr(&idr_packet, 0); idr_packet.dataPtr = kData; @@ -350,7 +355,7 @@ TEST_F(TestH264SpsPpsTracker, SaveRestoreWidthHeight) { // Insert an SPS/PPS packet with width/height and make sure // that information is set on the first IDR packet. - VCMPacket sps_pps_packet = GetDefaultPacket(); + H264VcmPacket sps_pps_packet; AddSps(&sps_pps_packet, 0, &data); AddPps(&sps_pps_packet, 0, 1, &data); sps_pps_packet.dataPtr = data.data(); @@ -361,7 +366,7 @@ TEST_F(TestH264SpsPpsTracker, SaveRestoreWidthHeight) { tracker_.CopyAndFixBitstream(&sps_pps_packet)); delete[] sps_pps_packet.dataPtr; - VCMPacket idr_packet = GetDefaultPacket(); + H264VcmPacket idr_packet; idr_packet.video_header.is_first_packet_in_frame = true; AddIdr(&idr_packet, 1); data.insert(data.end(), {1, 2, 3}); diff --git a/modules/video_coding/jitter_buffer_unittest.cc b/modules/video_coding/jitter_buffer_unittest.cc index adb495d6fe..756dc523c3 100644 --- a/modules/video_coding/jitter_buffer_unittest.cc +++ b/modules/video_coding/jitter_buffer_unittest.cc @@ -1155,17 +1155,19 @@ TEST_F(TestBasicJitterBuffer, H264InsertStartCode) { TEST_F(TestBasicJitterBuffer, SpsAndPpsHandling) { jitter_buffer_->SetDecodeErrorMode(kNoErrors); + auto& h264_header = + packet_->video_header.video_type_header.emplace(); packet_->timestamp = timestamp_; packet_->frameType = kVideoFrameKey; packet_->is_first_packet_in_frame = true; packet_->markerBit = true; packet_->codec = kVideoCodecH264; packet_->video_header.codec = kVideoCodecH264; - packet_->video_header.h264().nalu_type = H264::NaluType::kIdr; - packet_->video_header.h264().nalus[0].type = H264::NaluType::kIdr; - packet_->video_header.h264().nalus[0].sps_id = -1; - packet_->video_header.h264().nalus[0].pps_id = 0; - packet_->video_header.h264().nalus_length = 1; + h264_header.nalu_type = H264::NaluType::kIdr; + h264_header.nalus[0].type = H264::NaluType::kIdr; + h264_header.nalus[0].sps_id = -1; + h264_header.nalus[0].pps_id = 0; + h264_header.nalus_length = 1; bool retransmitted = false; EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &retransmitted)); @@ -1181,14 +1183,14 @@ TEST_F(TestBasicJitterBuffer, SpsAndPpsHandling) { packet_->markerBit = false; packet_->codec = kVideoCodecH264; packet_->video_header.codec = kVideoCodecH264; - packet_->video_header.h264().nalu_type = H264::NaluType::kStapA; - packet_->video_header.h264().nalus[0].type = H264::NaluType::kSps; - packet_->video_header.h264().nalus[0].sps_id = 0; - packet_->video_header.h264().nalus[0].pps_id = -1; - packet_->video_header.h264().nalus[1].type = H264::NaluType::kPps; - packet_->video_header.h264().nalus[1].sps_id = 0; - packet_->video_header.h264().nalus[1].pps_id = 0; - packet_->video_header.h264().nalus_length = 2; + h264_header.nalu_type = H264::NaluType::kStapA; + h264_header.nalus[0].type = H264::NaluType::kSps; + h264_header.nalus[0].sps_id = 0; + h264_header.nalus[0].pps_id = -1; + h264_header.nalus[1].type = H264::NaluType::kPps; + h264_header.nalus[1].sps_id = 0; + h264_header.nalus[1].pps_id = 0; + h264_header.nalus_length = 2; // Not complete since the marker bit hasn't been received. EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_, &retransmitted)); @@ -1200,11 +1202,11 @@ TEST_F(TestBasicJitterBuffer, SpsAndPpsHandling) { packet_->markerBit = true; packet_->codec = kVideoCodecH264; packet_->video_header.codec = kVideoCodecH264; - packet_->video_header.h264().nalu_type = H264::NaluType::kIdr; - packet_->video_header.h264().nalus[0].type = H264::NaluType::kIdr; - packet_->video_header.h264().nalus[0].sps_id = -1; - packet_->video_header.h264().nalus[0].pps_id = 0; - packet_->video_header.h264().nalus_length = 1; + h264_header.nalu_type = H264::NaluType::kIdr; + h264_header.nalus[0].type = H264::NaluType::kIdr; + h264_header.nalus[0].sps_id = -1; + h264_header.nalus[0].pps_id = 0; + h264_header.nalus_length = 1; // Complete and decodable since the pps and sps are received in the first // packet of this frame. EXPECT_EQ(kCompleteSession, @@ -1222,11 +1224,11 @@ TEST_F(TestBasicJitterBuffer, SpsAndPpsHandling) { packet_->markerBit = true; packet_->codec = kVideoCodecH264; packet_->video_header.codec = kVideoCodecH264; - packet_->video_header.h264().nalu_type = H264::NaluType::kSlice; - packet_->video_header.h264().nalus[0].type = H264::NaluType::kSlice; - packet_->video_header.h264().nalus[0].sps_id = -1; - packet_->video_header.h264().nalus[0].pps_id = 0; - packet_->video_header.h264().nalus_length = 1; + h264_header.nalu_type = H264::NaluType::kSlice; + h264_header.nalus[0].type = H264::NaluType::kSlice; + h264_header.nalus[0].sps_id = -1; + h264_header.nalus[0].pps_id = 0; + h264_header.nalus_length = 1; // Complete and decodable since sps, pps and key frame has been received. EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_, &retransmitted)); diff --git a/modules/video_coding/packet_buffer.cc b/modules/video_coding/packet_buffer.cc index 28ade462a0..e1172b3749 100644 --- a/modules/video_coding/packet_buffer.cc +++ b/modules/video_coding/packet_buffer.cc @@ -303,18 +303,17 @@ std::vector> PacketBuffer::FindFrames( break; if (is_h264 && !is_h264_keyframe) { - const RTPVideoHeaderH264& header = - data_buffer_[start_index].video_header.h264(); - - if (header.nalus_length >= kMaxNalusPerPacket) + const auto* h264_header = absl::get_if( + &data_buffer_[start_index].video_header.video_type_header); + if (!h264_header || h264_header->nalus_length >= kMaxNalusPerPacket) return found_frames; - for (size_t j = 0; j < header.nalus_length; ++j) { - if (header.nalus[j].type == H264::NaluType::kSps) { + for (size_t j = 0; j < h264_header->nalus_length; ++j) { + if (h264_header->nalus[j].type == H264::NaluType::kSps) { has_h264_sps = true; - } else if (header.nalus[j].type == H264::NaluType::kPps) { + } else if (h264_header->nalus[j].type == H264::NaluType::kPps) { has_h264_pps = true; - } else if (header.nalus[j].type == H264::NaluType::kIdr) { + } else if (h264_header->nalus[j].type == H264::NaluType::kIdr) { has_h264_idr = true; } } diff --git a/modules/video_coding/session_info.cc b/modules/video_coding/session_info.cc index 1b6f7329c8..93a1d535c0 100644 --- a/modules/video_coding/session_info.cc +++ b/modules/video_coding/session_info.cc @@ -110,8 +110,10 @@ std::vector VCMSessionInfo::GetNaluInfos() const { return std::vector(); std::vector nalu_infos; for (const VCMPacket& packet : packets_) { - for (size_t i = 0; i < packet.video_header.h264().nalus_length; ++i) { - nalu_infos.push_back(packet.video_header.h264().nalus[i]); + const auto& h264 = + absl::get(packet.video_header.video_type_header); + for (size_t i = 0; i < h264.nalus_length; ++i) { + nalu_infos.push_back(h264.nalus[i]); } } return nalu_infos; @@ -175,8 +177,9 @@ size_t VCMSessionInfo::InsertBuffer(uint8_t* frame_buffer, // header supplied by the H264 depacketizer. const size_t kH264NALHeaderLengthInBytes = 1; const size_t kLengthFieldLength = 2; - if (packet.video_header.codec == kVideoCodecH264 && - packet.video_header.h264().packetization_type == kH264StapA) { + const auto* h264 = + absl::get_if(&packet.video_header.video_type_header); + if (h264 && h264->packetization_type == kH264StapA) { size_t required_length = 0; const uint8_t* nalu_ptr = packet_buffer + kH264NALHeaderLengthInBytes; while (nalu_ptr < packet_buffer + packet.sizeBytes) { diff --git a/modules/video_coding/video_packet_buffer_unittest.cc b/modules/video_coding/video_packet_buffer_unittest.cc index 58611ffb7b..f588026ec9 100644 --- a/modules/video_coding/video_packet_buffer_unittest.cc +++ b/modules/video_coding/video_packet_buffer_unittest.cc @@ -508,17 +508,19 @@ class TestPacketBufferH264 : public TestPacketBuffer { uint8_t* data = nullptr) { // data pointer VCMPacket packet; packet.codec = kVideoCodecH264; + auto& h264_header = + packet.video_header.video_type_header.emplace(); packet.seqNum = seq_num; packet.timestamp = timestamp; if (keyframe == kKeyFrame) { if (sps_pps_idr_is_keyframe_) { - packet.video_header.h264().nalus[0].type = H264::NaluType::kSps; - packet.video_header.h264().nalus[1].type = H264::NaluType::kPps; - packet.video_header.h264().nalus[2].type = H264::NaluType::kIdr; - packet.video_header.h264().nalus_length = 3; + h264_header.nalus[0].type = H264::NaluType::kSps; + h264_header.nalus[1].type = H264::NaluType::kPps; + h264_header.nalus[2].type = H264::NaluType::kIdr; + h264_header.nalus_length = 3; } else { - packet.video_header.h264().nalus[0].type = H264::NaluType::kIdr; - packet.video_header.h264().nalus_length = 1; + h264_header.nalus[0].type = H264::NaluType::kIdr; + h264_header.nalus_length = 1; } } packet.is_first_packet_in_frame = first == kFirst; @@ -592,12 +594,14 @@ TEST_P(TestPacketBufferH264Parameterized, GetBitstreamBufferPadding) { new uint8_t[sizeof(data_data) + EncodedImage::kBufferPaddingBytesH264]); VCMPacket packet; - packet.video_header.h264().nalus_length = 1; - packet.video_header.h264().nalus[0].type = H264::NaluType::kIdr; + auto& h264_header = + packet.video_header.video_type_header.emplace(); + h264_header.nalus_length = 1; + h264_header.nalus[0].type = H264::NaluType::kIdr; + h264_header.packetization_type = kH264SingleNalu; packet.seqNum = seq_num; packet.codec = kVideoCodecH264; packet.insertStartCode = true; - packet.video_header.h264().packetization_type = kH264SingleNalu; packet.dataPtr = data; packet.sizeBytes = sizeof(data_data); packet.is_first_packet_in_frame = true; @@ -755,7 +759,9 @@ TEST_F(TestPacketBuffer, IncomingCodecChange) { EXPECT_TRUE(packet_buffer_->InsertPacket(&packet)); packet.codec = kVideoCodecH264; - packet.video_header.h264().nalus_length = 1; + auto& h264_header = + packet.video_header.video_type_header.emplace(); + h264_header.nalus_length = 1; packet.timestamp = 3; packet.seqNum = 3; EXPECT_TRUE(packet_buffer_->InsertPacket(&packet)); @@ -778,7 +784,9 @@ TEST_F(TestPacketBuffer, TooManyNalusInPacket) { packet.frameType = kVideoFrameKey; packet.is_first_packet_in_frame = true; packet.markerBit = true; - packet.video_header.h264().nalus_length = kMaxNalusPerPacket; + auto& h264_header = + packet.video_header.video_type_header.emplace(); + h264_header.nalus_length = kMaxNalusPerPacket; packet.sizeBytes = 0; packet.dataPtr = nullptr; EXPECT_TRUE(packet_buffer_->InsertPacket(&packet)); @@ -873,9 +881,10 @@ class TestPacketBufferH264IdrIsKeyframe }; TEST_F(TestPacketBufferH264IdrIsKeyframe, IdrIsKeyframe) { - packet_.video_header.h264().nalus[0].type = H264::NaluType::kIdr; - packet_.video_header.h264().nalus_length = 1; - + auto& h264_header = + packet_.video_header.video_type_header.emplace(); + h264_header.nalus[0].type = H264::NaluType::kIdr; + h264_header.nalus_length = 1; packet_buffer_->InsertPacket(&packet_); ASSERT_EQ(1u, frames_from_callback_.size()); @@ -883,10 +892,12 @@ TEST_F(TestPacketBufferH264IdrIsKeyframe, IdrIsKeyframe) { } TEST_F(TestPacketBufferH264IdrIsKeyframe, SpsPpsIdrIsKeyframe) { - packet_.video_header.h264().nalus[0].type = H264::NaluType::kSps; - packet_.video_header.h264().nalus[1].type = H264::NaluType::kPps; - packet_.video_header.h264().nalus[2].type = H264::NaluType::kIdr; - packet_.video_header.h264().nalus_length = 3; + auto& h264_header = + packet_.video_header.video_type_header.emplace(); + h264_header.nalus[0].type = H264::NaluType::kSps; + h264_header.nalus[1].type = H264::NaluType::kPps; + h264_header.nalus[2].type = H264::NaluType::kIdr; + h264_header.nalus_length = 3; packet_buffer_->InsertPacket(&packet_); @@ -902,8 +913,10 @@ class TestPacketBufferH264SpsPpsIdrIsKeyframe }; TEST_F(TestPacketBufferH264SpsPpsIdrIsKeyframe, IdrIsNotKeyframe) { - packet_.video_header.h264().nalus[0].type = H264::NaluType::kIdr; - packet_.video_header.h264().nalus_length = 1; + auto& h264_header = + packet_.video_header.video_type_header.emplace(); + h264_header.nalus[0].type = H264::NaluType::kIdr; + h264_header.nalus_length = 1; packet_buffer_->InsertPacket(&packet_); @@ -912,9 +925,11 @@ TEST_F(TestPacketBufferH264SpsPpsIdrIsKeyframe, IdrIsNotKeyframe) { } TEST_F(TestPacketBufferH264SpsPpsIdrIsKeyframe, SpsPpsIsNotKeyframe) { - packet_.video_header.h264().nalus[0].type = H264::NaluType::kSps; - packet_.video_header.h264().nalus[1].type = H264::NaluType::kPps; - packet_.video_header.h264().nalus_length = 2; + auto& h264_header = + packet_.video_header.video_type_header.emplace(); + h264_header.nalus[0].type = H264::NaluType::kSps; + h264_header.nalus[1].type = H264::NaluType::kPps; + h264_header.nalus_length = 2; packet_buffer_->InsertPacket(&packet_); @@ -923,10 +938,12 @@ TEST_F(TestPacketBufferH264SpsPpsIdrIsKeyframe, SpsPpsIsNotKeyframe) { } TEST_F(TestPacketBufferH264SpsPpsIdrIsKeyframe, SpsPpsIdrIsKeyframe) { - packet_.video_header.h264().nalus[0].type = H264::NaluType::kSps; - packet_.video_header.h264().nalus[1].type = H264::NaluType::kPps; - packet_.video_header.h264().nalus[2].type = H264::NaluType::kIdr; - packet_.video_header.h264().nalus_length = 3; + auto& h264_header = + packet_.video_header.video_type_header.emplace(); + h264_header.nalus[0].type = H264::NaluType::kSps; + h264_header.nalus[1].type = H264::NaluType::kPps; + h264_header.nalus[2].type = H264::NaluType::kIdr; + h264_header.nalus_length = 3; packet_buffer_->InsertPacket(&packet_); diff --git a/modules/video_coding/video_receiver_unittest.cc b/modules/video_coding/video_receiver_unittest.cc index 8b64e77756..a4778e8e88 100644 --- a/modules/video_coding/video_receiver_unittest.cc +++ b/modules/video_coding/video_receiver_unittest.cc @@ -98,8 +98,7 @@ TEST_F(TestVideoReceiver, PaddingOnlyFrames) { 0, receiver_->RegisterPacketRequestCallback(&packet_request_callback_)); const size_t kPaddingSize = 220; const uint8_t payload[kPaddingSize] = {0}; - WebRtcRTPHeader header; - memset(&header, 0, sizeof(header)); + WebRtcRTPHeader header = {}; header.frameType = kEmptyFrame; header.header.markerBit = false; header.header.paddingLength = kPaddingSize; @@ -122,8 +121,7 @@ TEST_F(TestVideoReceiver, PaddingOnlyFramesWithLosses) { const size_t kFrameSize = 1200; const size_t kPaddingSize = 220; const uint8_t payload[kFrameSize] = {0}; - WebRtcRTPHeader header; - memset(&header, 0, sizeof(header)); + WebRtcRTPHeader header = {}; header.frameType = kEmptyFrame; header.header.markerBit = false; header.header.paddingLength = kPaddingSize; @@ -173,8 +171,7 @@ TEST_F(TestVideoReceiver, PaddingOnlyAndVideo) { const size_t kFrameSize = 1200; const size_t kPaddingSize = 220; const uint8_t payload[kFrameSize] = {0}; - WebRtcRTPHeader header; - memset(&header, 0, sizeof(header)); + WebRtcRTPHeader header = {}; header.frameType = kEmptyFrame; header.video_header().is_first_packet_in_frame = false; header.header.markerBit = false; diff --git a/video/rtp_video_stream_receiver_unittest.cc b/video/rtp_video_stream_receiver_unittest.cc index 394fa5acdc..d74d4628d0 100644 --- a/video/rtp_video_stream_receiver_unittest.cc +++ b/video/rtp_video_stream_receiver_unittest.cc @@ -134,9 +134,9 @@ class RtpVideoStreamReceiverTest : public testing::Test { } WebRtcRTPHeader GetDefaultPacket() { - WebRtcRTPHeader packet; - memset(&packet, 0, sizeof(packet)); + WebRtcRTPHeader packet = {}; packet.video_header().codec = kVideoCodecH264; + packet.video_header().video_type_header.emplace(); return packet; } @@ -151,9 +151,9 @@ class RtpVideoStreamReceiverTest : public testing::Test { info.pps_id = -1; data->push_back(H264::NaluType::kSps); data->push_back(sps_id); - packet->video_header() - .h264() - .nalus[packet->video_header().h264().nalus_length++] = info; + auto& h264 = + absl::get(packet->video_header().video_type_header); + h264.nalus[h264.nalus_length++] = info; } void AddPps(WebRtcRTPHeader* packet, @@ -166,9 +166,9 @@ class RtpVideoStreamReceiverTest : public testing::Test { info.pps_id = pps_id; data->push_back(H264::NaluType::kPps); data->push_back(pps_id); - packet->video_header() - .h264() - .nalus[packet->video_header().h264().nalus_length++] = info; + auto& h264 = + absl::get(packet->video_header().video_type_header); + h264.nalus[h264.nalus_length++] = info; } void AddIdr(WebRtcRTPHeader* packet, int pps_id) { @@ -176,9 +176,9 @@ class RtpVideoStreamReceiverTest : public testing::Test { info.type = H264::NaluType::kIdr; info.sps_id = -1; info.pps_id = pps_id; - packet->video_header() - .h264() - .nalus[packet->video_header().h264().nalus_length++] = info; + auto& h264 = + absl::get(packet->video_header().video_type_header); + h264.nalus[h264.nalus_length++] = info; } protected: @@ -202,9 +202,8 @@ class RtpVideoStreamReceiverTest : public testing::Test { }; TEST_F(RtpVideoStreamReceiverTest, GenericKeyFrame) { - WebRtcRTPHeader rtp_header; + WebRtcRTPHeader rtp_header = {}; const std::vector data({1, 2, 3, 4}); - memset(&rtp_header, 0, sizeof(rtp_header)); rtp_header.header.sequenceNumber = 1; rtp_header.header.markerBit = 1; rtp_header.video_header().is_first_packet_in_frame = true; @@ -260,9 +259,8 @@ TEST_F(RtpVideoStreamReceiverTest, } TEST_F(RtpVideoStreamReceiverTest, GenericKeyFrameBitstreamError) { - WebRtcRTPHeader rtp_header; + WebRtcRTPHeader rtp_header = {}; const std::vector data({1, 2, 3, 4}); - memset(&rtp_header, 0, sizeof(rtp_header)); rtp_header.header.sequenceNumber = 1; rtp_header.header.markerBit = 1; rtp_header.video_header().is_first_packet_in_frame = true; @@ -409,9 +407,8 @@ TEST_F(RtpVideoStreamReceiverTest, PaddingInMediaStream) { } TEST_F(RtpVideoStreamReceiverTest, RequestKeyframeIfFirstFrameIsDelta) { - WebRtcRTPHeader rtp_header; + WebRtcRTPHeader rtp_header = {}; const std::vector data({1, 2, 3, 4}); - memset(&rtp_header, 0, sizeof(rtp_header)); rtp_header.header.sequenceNumber = 1; rtp_header.header.markerBit = 1; rtp_header.video_header().is_first_packet_in_frame = true;