| /* | |
| * Copyright (c) 2019 The WebRTC project authors. All Rights Reserved. | |
| * | |
| * Use of this source code is governed by a BSD-style license | |
| * that can be found in the LICENSE file in the root of the source | |
| * tree. An additional intellectual property rights grant can be found | |
| * in the file PATENTS. All contributing project authors may | |
| * be found in the AUTHORS file in the root of the source tree. | |
| */ | |
| #include "modules/rtp_rtcp/source/video_rtp_depacketizer_vp8.h" | |
| #include <cstddef> | |
| #include <cstdint> | |
| #include <optional> | |
| #include "api/array_view.h" | |
| #include "api/video/video_codec_type.h" | |
| #include "api/video/video_frame_type.h" | |
| #include "modules/rtp_rtcp/source/rtp_format_vp8.h" | |
| #include "modules/rtp_rtcp/source/rtp_packet_to_send.h" | |
| #include "modules/rtp_rtcp/source/rtp_video_header.h" | |
| #include "modules/rtp_rtcp/source/video_rtp_depacketizer.h" | |
| #include "modules/video_coding/codecs/interface/common_constants.h" | |
| #include "modules/video_coding/codecs/vp8/include/vp8_globals.h" | |
| #include "rtc_base/copy_on_write_buffer.h" | |
| #include "test/gtest.h" | |
| // VP8 payload descriptor | |
| // https://datatracker.ietf.org/doc/html/rfc7741#section-4.2 | |
| // | |
| // 0 1 2 3 4 5 6 7 | |
| // +-+-+-+-+-+-+-+-+ | |
| // |X|R|N|S|R| PID | (REQUIRED) | |
| // +-+-+-+-+-+-+-+-+ | |
| // X: |I|L|T|K| RSV | (OPTIONAL) | |
| // +-+-+-+-+-+-+-+-+ | |
| // I: |M| PictureID | (OPTIONAL) | |
| // +-+-+-+-+-+-+-+-+ | |
| // | PictureID | | |
| // +-+-+-+-+-+-+-+-+ | |
| // L: | TL0PICIDX | (OPTIONAL) | |
| // +-+-+-+-+-+-+-+-+ | |
| // T/K: |TID|Y| KEYIDX | (OPTIONAL) | |
| // +-+-+-+-+-+-+-+-+ | |
| // | |
| // VP8 payload header. Considered part of the actual payload, sent to decoder. | |
| // https://datatracker.ietf.org/doc/html/rfc7741#section-4.3 | |
| // | |
| // 0 1 2 3 4 5 6 7 | |
| // +-+-+-+-+-+-+-+-+ | |
| // |Size0|H| VER |P| | |
| // +-+-+-+-+-+-+-+-+ | |
| // : ... : | |
| // +-+-+-+-+-+-+-+-+ | |
| namespace webrtc { | |
| namespace { | |
| TEST(VideoRtpDepacketizerVp8Test, BasicHeader) { | |
| uint8_t packet[4] = {0}; | |
| packet[0] = 0b0001'0100; // S = 1, partition ID = 4. | |
| packet[1] = 0x01; // P frame. | |
| RTPVideoHeader video_header; | |
| int offset = VideoRtpDepacketizerVp8::ParseRtpPayload(packet, &video_header); | |
| EXPECT_EQ(offset, 1); | |
| EXPECT_EQ(video_header.frame_type, VideoFrameType::kVideoFrameDelta); | |
| EXPECT_EQ(video_header.codec, kVideoCodecVP8); | |
| const auto& vp8_header = | |
| std::get<RTPVideoHeaderVP8>(video_header.video_type_header); | |
| EXPECT_FALSE(vp8_header.nonReference); | |
| EXPECT_TRUE(vp8_header.beginningOfPartition); | |
| EXPECT_EQ(vp8_header.partitionId, 4); | |
| EXPECT_EQ(vp8_header.pictureId, kNoPictureId); | |
| EXPECT_EQ(vp8_header.tl0PicIdx, kNoTl0PicIdx); | |
| EXPECT_EQ(vp8_header.temporalIdx, kNoTemporalIdx); | |
| EXPECT_EQ(vp8_header.keyIdx, kNoKeyIdx); | |
| } | |
| TEST(VideoRtpDepacketizerVp8Test, OneBytePictureID) { | |
| const uint8_t kPictureId = 17; | |
| uint8_t packet[10] = {0}; | |
| packet[0] = 0b1010'0000; | |
| packet[1] = 0b1000'0000; | |
| packet[2] = kPictureId; | |
| RTPVideoHeader video_header; | |
| int offset = VideoRtpDepacketizerVp8::ParseRtpPayload(packet, &video_header); | |
| EXPECT_EQ(offset, 3); | |
| const auto& vp8_header = | |
| std::get<RTPVideoHeaderVP8>(video_header.video_type_header); | |
| EXPECT_EQ(vp8_header.pictureId, kPictureId); | |
| } | |
| TEST(VideoRtpDepacketizerVp8Test, TwoBytePictureID) { | |
| const uint16_t kPictureId = 0x1234; | |
| uint8_t packet[10] = {0}; | |
| packet[0] = 0b1010'0000; | |
| packet[1] = 0b1000'0000; | |
| packet[2] = 0x80 | 0x12; | |
| packet[3] = 0x34; | |
| RTPVideoHeader video_header; | |
| int offset = VideoRtpDepacketizerVp8::ParseRtpPayload(packet, &video_header); | |
| EXPECT_EQ(offset, 4); | |
| const auto& vp8_header = | |
| std::get<RTPVideoHeaderVP8>(video_header.video_type_header); | |
| EXPECT_EQ(vp8_header.pictureId, kPictureId); | |
| } | |
| TEST(VideoRtpDepacketizerVp8Test, Tl0PicIdx) { | |
| const uint8_t kTl0PicIdx = 17; | |
| uint8_t packet[13] = {0}; | |
| packet[0] = 0b1000'0000; | |
| packet[1] = 0b0100'0000; | |
| packet[2] = kTl0PicIdx; | |
| RTPVideoHeader video_header; | |
| int offset = VideoRtpDepacketizerVp8::ParseRtpPayload(packet, &video_header); | |
| EXPECT_EQ(offset, 3); | |
| const auto& vp8_header = | |
| std::get<RTPVideoHeaderVP8>(video_header.video_type_header); | |
| EXPECT_EQ(vp8_header.tl0PicIdx, kTl0PicIdx); | |
| } | |
| TEST(VideoRtpDepacketizerVp8Test, TIDAndLayerSync) { | |
| uint8_t packet[10] = {0}; | |
| packet[0] = 0b1000'0000; | |
| packet[1] = 0b0010'0000; | |
| packet[2] = 0b10'0'00000; // TID(2) + LayerSync(false) | |
| RTPVideoHeader video_header; | |
| int offset = VideoRtpDepacketizerVp8::ParseRtpPayload(packet, &video_header); | |
| EXPECT_EQ(offset, 3); | |
| const auto& vp8_header = | |
| std::get<RTPVideoHeaderVP8>(video_header.video_type_header); | |
| EXPECT_EQ(vp8_header.temporalIdx, 2); | |
| EXPECT_FALSE(vp8_header.layerSync); | |
| } | |
| TEST(VideoRtpDepacketizerVp8Test, KeyIdx) { | |
| const uint8_t kKeyIdx = 17; | |
| uint8_t packet[10] = {0}; | |
| packet[0] = 0b1000'0000; | |
| packet[1] = 0b0001'0000; | |
| packet[2] = kKeyIdx; | |
| RTPVideoHeader video_header; | |
| int offset = VideoRtpDepacketizerVp8::ParseRtpPayload(packet, &video_header); | |
| EXPECT_EQ(offset, 3); | |
| const auto& vp8_header = | |
| std::get<RTPVideoHeaderVP8>(video_header.video_type_header); | |
| EXPECT_EQ(vp8_header.keyIdx, kKeyIdx); | |
| } | |
| TEST(VideoRtpDepacketizerVp8Test, MultipleExtensions) { | |
| uint8_t packet[10] = {0}; | |
| packet[0] = 0b1010'0110; // X and N bit set, partition ID = 6 | |
| packet[1] = 0b1111'0000; | |
| packet[2] = 0x80 | 0x12; // PictureID, high 7 bits. | |
| packet[3] = 0x34; // PictureID, low 8 bits. | |
| packet[4] = 42; // Tl0PicIdx. | |
| packet[5] = 0b01'1'10001; | |
| RTPVideoHeader video_header; | |
| int offset = VideoRtpDepacketizerVp8::ParseRtpPayload(packet, &video_header); | |
| EXPECT_EQ(offset, 6); | |
| const auto& vp8_header = | |
| std::get<RTPVideoHeaderVP8>(video_header.video_type_header); | |
| EXPECT_TRUE(vp8_header.nonReference); | |
| EXPECT_EQ(vp8_header.partitionId, 0b0110); | |
| EXPECT_EQ(vp8_header.pictureId, 0x1234); | |
| EXPECT_EQ(vp8_header.tl0PicIdx, 42); | |
| EXPECT_EQ(vp8_header.temporalIdx, 1); | |
| EXPECT_TRUE(vp8_header.layerSync); | |
| EXPECT_EQ(vp8_header.keyIdx, 0b10001); | |
| } | |
| TEST(VideoRtpDepacketizerVp8Test, TooShortHeader) { | |
| uint8_t packet[4] = {0}; | |
| packet[0] = 0b1000'0000; | |
| packet[1] = 0b1111'0000; // All extensions are enabled... | |
| packet[2] = 0x80 | 17; // ... but only 2 bytes PictureID is provided. | |
| packet[3] = 17; // PictureID, low 8 bits. | |
| RTPVideoHeader unused; | |
| EXPECT_EQ(VideoRtpDepacketizerVp8::ParseRtpPayload(packet, &unused), 0); | |
| } | |
| TEST(VideoRtpDepacketizerVp8Test, WithPacketizer) { | |
| uint8_t data[10] = {0}; | |
| RtpPacketToSend packet(/*extensions=*/nullptr); | |
| RTPVideoHeaderVP8 input_header; | |
| input_header.nonReference = true; | |
| input_header.pictureId = 300; | |
| input_header.temporalIdx = 1; | |
| input_header.layerSync = false; | |
| input_header.tl0PicIdx = kNoTl0PicIdx; // Disable. | |
| input_header.keyIdx = 31; | |
| RtpPacketizerVp8 packetizer(data, /*limits=*/{}, input_header); | |
| EXPECT_EQ(packetizer.NumPackets(), 1u); | |
| ASSERT_TRUE(packetizer.NextPacket(&packet)); | |
| VideoRtpDepacketizerVp8 depacketizer; | |
| std::optional<VideoRtpDepacketizer::ParsedRtpPayload> parsed = | |
| depacketizer.Parse(packet.PayloadBuffer()); | |
| ASSERT_TRUE(parsed); | |
| EXPECT_EQ(parsed->video_header.codec, kVideoCodecVP8); | |
| const auto& vp8_header = | |
| std::get<RTPVideoHeaderVP8>(parsed->video_header.video_type_header); | |
| EXPECT_EQ(vp8_header.nonReference, input_header.nonReference); | |
| EXPECT_EQ(vp8_header.pictureId, input_header.pictureId); | |
| EXPECT_EQ(vp8_header.tl0PicIdx, input_header.tl0PicIdx); | |
| EXPECT_EQ(vp8_header.temporalIdx, input_header.temporalIdx); | |
| EXPECT_EQ(vp8_header.layerSync, input_header.layerSync); | |
| EXPECT_EQ(vp8_header.keyIdx, input_header.keyIdx); | |
| } | |
| TEST(VideoRtpDepacketizerVp8Test, ReferencesInputCopyOnWriteBuffer) { | |
| constexpr size_t kHeaderSize = 5; | |
| uint8_t packet[16] = {0}; | |
| packet[0] = 0b1000'0000; | |
| packet[1] = 0b1111'0000; // with all extensions, | |
| packet[2] = 15; // and one-byte picture id. | |
| CopyOnWriteBuffer rtp_payload(packet); | |
| VideoRtpDepacketizerVp8 depacketizer; | |
| std::optional<VideoRtpDepacketizer::ParsedRtpPayload> parsed = | |
| depacketizer.Parse(rtp_payload); | |
| ASSERT_TRUE(parsed); | |
| EXPECT_EQ(parsed->video_payload.size(), rtp_payload.size() - kHeaderSize); | |
| // Compare pointers to check there was no copy on write buffer unsharing. | |
| EXPECT_EQ(parsed->video_payload.cdata(), rtp_payload.cdata() + kHeaderSize); | |
| } | |
| TEST(VideoRtpDepacketizerVp8Test, FailsOnEmptyPayload) { | |
| ArrayView<const uint8_t> empty; | |
| RTPVideoHeader video_header; | |
| EXPECT_EQ(VideoRtpDepacketizerVp8::ParseRtpPayload(empty, &video_header), 0); | |
| } | |
| } // namespace | |
| } // namespace webrtc |