mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-13 13:50:40 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Delete generic frame descriptor v1 trait and enum value

Browse source 
Bug: webrtc:11358
Change-Id: I272a45881f8ef9963b502c6d17edc97e7d9fbc8e
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/173582
Reviewed-by: Markus Handell <handellm@webrtc.org>
Reviewed-by: Sam Zackrisson <saza@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31089}
This commit is contained in:
Danil Chapovalov 2020-04-14 16:11:59 +02:00 committed by Commit Bot
parent efdff53176
commit ec9fc2208e
12 changed files with 85 additions and 292 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
modules/rtp_rtcp/include/rtp_rtcp_defines.h
View file

@ -70,7 +70,6 @@ enum RTPExtensionType : int {
kRtpExtensionMid,
kRtpExtensionGenericFrameDescriptor00,
kRtpExtensionGenericFrameDescriptor = kRtpExtensionGenericFrameDescriptor00,
kRtpExtensionGenericFrameDescriptor01,
kRtpExtensionGenericFrameDescriptor02,
kRtpExtensionColorSpace,
kRtpExtensionNumberOfExtensions // Must be the last entity in the enum.

11
modules/rtp_rtcp/source/rtp_generic_frame_descriptor.h
View file

@ -38,15 +38,6 @@ class RtpGenericFrameDescriptor {
bool LastPacketInSubFrame() const { return end_of_subframe_; }
void SetLastPacketInSubFrame(bool last) { end_of_subframe_ = last; }
// Denotes whether the frame is discardable. That is, whether skipping it
// would have no effect on the decodability of subsequent frames.
// An absl::optional is used because version 0 of the extension did not
// support this flag. (The optional aspect is relevant only when parsing.)
// TODO(bugs.webrtc.org/10243): Make this into a plain bool when v00 of
// the extension is deprecated.
absl::optional<bool> Discardable() const { return discardable_; }
void SetDiscardable(bool discardable) { discardable_ = discardable; }
// Properties below undefined if !FirstPacketInSubFrame()
// Valid range for temporal layer: [0, 7]
int TemporalLayer() const;
@ -74,8 +65,6 @@ class RtpGenericFrameDescriptor {
bool beginning_of_subframe_ = false;
bool end_of_subframe_ = false;
absl::optional<bool> discardable_;
uint16_t frame_id_ = 0;
uint8_t spatial_layers_ = 1;
uint8_t temporal_layer_ = 0;

73
modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension.cc
View file

@ -20,18 +20,16 @@ constexpr uint8_t kFlagEndOfSubframe = 0x40;
// In version 00, the flags F and L in the first byte correspond to
// kFlagFirstSubframeV00 and kFlagLastSubframeV00. In practice, they were
// always set to |true|. In version 01, these flags are deprecated, and we use
// one of their bits for the discardability flag.
// always set to |true|.
constexpr uint8_t kFlagFirstSubframeV00 = 0x20;
constexpr uint8_t kFlagLastSubframeV00 = 0x10;
constexpr uint8_t kFlagDiscardableV01 = 0x10;
constexpr uint8_t kFlagDependencies = 0x08;
constexpr uint8_t kMaskTemporalLayer = 0x07;
constexpr uint8_t kFlagMoreDependencies = 0x01;
constexpr uint8_t kFlageXtendedOffset = 0x02;
} // namespace
// 0 1 2 3 4 5 6 7
// +-+-+-+-+-+-+-+-+
// |B|E|F|L|D| T |
@ -58,9 +56,10 @@ constexpr uint8_t kFlageXtendedOffset = 0x02;
// +---------------+
// | ... |
// +-+-+-+-+-+-+-+-+
constexpr RTPExtensionType RtpGenericFrameDescriptorExtension00::kId;
constexpr char RtpGenericFrameDescriptorExtension00::kUri[];
bool RtpGenericFrameDescriptorExtensionParse(
size_t version,
bool RtpGenericFrameDescriptorExtension00::Parse(
rtc::ArrayView<const uint8_t> data,
RtpGenericFrameDescriptor* descriptor) {
if (data.empty()) {
@ -71,10 +70,6 @@ bool RtpGenericFrameDescriptorExtensionParse(
descriptor->SetFirstPacketInSubFrame(begins_subframe);
descriptor->SetLastPacketInSubFrame((data[0] & kFlagEndOfSubframe) != 0);
if (version >= 1) {
descriptor->SetDiscardable((data[0] & kFlagDiscardableV01) != 0);
}
// Parse Subframe details provided in 1st packet of subframe.
if (!begins_subframe) {
return data.size() == 1;
@ -115,7 +110,7 @@ bool RtpGenericFrameDescriptorExtensionParse(
return true;
}
size_t RtpGenericFrameDescriptorExtensionValueSize(
size_t RtpGenericFrameDescriptorExtension00::ValueSize(
const RtpGenericFrameDescriptor& descriptor) {
if (!descriptor.FirstPacketInSubFrame())
return 1;
@ -132,23 +127,15 @@ size_t RtpGenericFrameDescriptorExtensionValueSize(
return size;
}
bool RtpGenericFrameDescriptorExtensionWrite(
size_t version,
bool RtpGenericFrameDescriptorExtension00::Write(
rtc::ArrayView<uint8_t> data,
const RtpGenericFrameDescriptor& descriptor) {
RTC_CHECK_EQ(data.size(),
RtpGenericFrameDescriptorExtensionValueSize(descriptor));
RTC_CHECK_EQ(data.size(), ValueSize(descriptor));
uint8_t base_header =
(descriptor.FirstPacketInSubFrame() ? kFlagBeginOfSubframe : 0) |
(descriptor.LastPacketInSubFrame() ? kFlagEndOfSubframe : 0);
if (version == 0) {
base_header |= kFlagFirstSubframeV00;
base_header |= kFlagLastSubframeV00;
} else if (version >= 1) {
const absl::optional<bool> discardable = descriptor.Discardable();
base_header |= (discardable.value_or(false) ? kFlagDiscardableV01 : 0);
}
if (!descriptor.FirstPacketInSubFrame()) {
data[0] = base_header;
@ -184,48 +171,4 @@ bool RtpGenericFrameDescriptorExtensionWrite(
return true;
}
} // namespace
constexpr RTPExtensionType RtpGenericFrameDescriptorExtension00::kId;
constexpr char RtpGenericFrameDescriptorExtension00::kUri[];
bool RtpGenericFrameDescriptorExtension00::Parse(
rtc::ArrayView<const uint8_t> data,
RtpGenericFrameDescriptor* descriptor) {
return RtpGenericFrameDescriptorExtensionParse(0, data, descriptor);
}
size_t RtpGenericFrameDescriptorExtension00::ValueSize(
const RtpGenericFrameDescriptor& descriptor) {
// No difference between existing versions.
return RtpGenericFrameDescriptorExtensionValueSize(descriptor);
}
bool RtpGenericFrameDescriptorExtension00::Write(
rtc::ArrayView<uint8_t> data,
const RtpGenericFrameDescriptor& descriptor) {
return RtpGenericFrameDescriptorExtensionWrite(0, data, descriptor);
}
constexpr RTPExtensionType RtpGenericFrameDescriptorExtension01::kId;
constexpr char RtpGenericFrameDescriptorExtension01::kUri[];
bool RtpGenericFrameDescriptorExtension01::Parse(
rtc::ArrayView<const uint8_t> data,
RtpGenericFrameDescriptor* descriptor) {
return RtpGenericFrameDescriptorExtensionParse(1, data, descriptor);
}
size_t RtpGenericFrameDescriptorExtension01::ValueSize(
const RtpGenericFrameDescriptor& descriptor) {
// No difference between existing versions.
return RtpGenericFrameDescriptorExtensionValueSize(descriptor);
}
bool RtpGenericFrameDescriptorExtension01::Write(
rtc::ArrayView<uint8_t> data,
const RtpGenericFrameDescriptor& descriptor) {
return RtpGenericFrameDescriptorExtensionWrite(1, data, descriptor);
}
} // namespace webrtc

16
modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension.h
View file

@ -35,22 +35,6 @@ class RtpGenericFrameDescriptorExtension00 {
const RtpGenericFrameDescriptor& descriptor);
};
class RtpGenericFrameDescriptorExtension01 {
public:
using value_type = RtpGenericFrameDescriptor;
static constexpr RTPExtensionType kId = kRtpExtensionGenericFrameDescriptor01;
static constexpr char kUri[] =
"http://www.webrtc.org/experiments/rtp-hdrext/"
"generic-frame-descriptor-01";
static constexpr int kMaxSizeBytes = 16;
static bool Parse(rtc::ArrayView<const uint8_t> data,
RtpGenericFrameDescriptor* descriptor);
static size_t ValueSize(const RtpGenericFrameDescriptor& descriptor);
static bool Write(rtc::ArrayView<uint8_t> data,
const RtpGenericFrameDescriptor& descriptor);
};
} // namespace webrtc
#endif // MODULES_RTP_RTCP_SOURCE_RTP_GENERIC_FRAME_DESCRIPTOR_EXTENSION_H_

240
modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension_unittest.cc
View file

@ -23,87 +23,27 @@ constexpr uint8_t kDeprecatedFlags = 0x30;
// TODO(danilchap): Add fuzzer to test for various invalid inputs.
class RtpGenericFrameDescriptorExtensionTest
: public ::testing::Test,
public ::testing::WithParamInterface<int> {
public:
RtpGenericFrameDescriptorExtensionTest() : version_(GetParam()) {}
bool Parse(rtc::ArrayView<const uint8_t> data,
RtpGenericFrameDescriptor* descriptor) const {
switch (version_) {
case 0:
return RtpGenericFrameDescriptorExtension00::Parse(data, descriptor);
case 1:
return RtpGenericFrameDescriptorExtension01::Parse(data, descriptor);
}
RTC_NOTREACHED();
return false;
}
size_t ValueSize(const RtpGenericFrameDescriptor& descriptor) const {
switch (version_) {
case 0:
return RtpGenericFrameDescriptorExtension00::ValueSize(descriptor);
case 1:
return RtpGenericFrameDescriptorExtension01::ValueSize(descriptor);
}
RTC_NOTREACHED();
return 0;
}
bool Write(rtc::ArrayView<uint8_t> data,
const RtpGenericFrameDescriptor& descriptor) const {
switch (version_) {
case 0:
return RtpGenericFrameDescriptorExtension00::Write(data, descriptor);
case 1:
return RtpGenericFrameDescriptorExtension01::Write(data, descriptor);
}
RTC_NOTREACHED();
return false;
}
protected:
const int version_;
};
INSTANTIATE_TEST_SUITE_P(All,
RtpGenericFrameDescriptorExtensionTest,
::testing::Values(0, 1));
TEST_P(RtpGenericFrameDescriptorExtensionTest,
TEST(RtpGenericFrameDescriptorExtensionTest,
ParseFirstPacketOfIndependenSubFrame) {
const int kTemporalLayer = 5;
constexpr uint8_t kRaw[] = {0x80 | kTemporalLayer, 0x49, 0x12, 0x34};
RtpGenericFrameDescriptor descriptor;
ASSERT_TRUE(Parse(kRaw, &descriptor));
ASSERT_TRUE(RtpGenericFrameDescriptorExtension00::Parse(kRaw, &descriptor));
EXPECT_TRUE(descriptor.FirstPacketInSubFrame());
EXPECT_FALSE(descriptor.LastPacketInSubFrame());
const absl::optional<bool> discardable = descriptor.Discardable();
if (version_ == 0) {
ASSERT_FALSE(discardable.has_value());
} else {
ASSERT_TRUE(discardable.has_value());
EXPECT_FALSE(discardable.value());
}
EXPECT_THAT(descriptor.FrameDependenciesDiffs(), IsEmpty());
EXPECT_EQ(descriptor.TemporalLayer(), kTemporalLayer);
EXPECT_EQ(descriptor.SpatialLayersBitmask(), 0x49);
EXPECT_EQ(descriptor.FrameId(), 0x3412);
}
TEST_P(RtpGenericFrameDescriptorExtensionTest,
TEST(RtpGenericFrameDescriptorExtensionTest,
WriteFirstPacketOfIndependenSubFrame) {
const int kTemporalLayer = 5;
uint8_t kRaw[] = {0x80 | kTemporalLayer, 0x49, 0x12, 0x34};
if (version_ == 0) {
kRaw[0] |= kDeprecatedFlags;
}
uint8_t kRaw[] = {0x80 | kTemporalLayer | kDeprecatedFlags, 0x49, 0x12, 0x34};
RtpGenericFrameDescriptor descriptor;
descriptor.SetFirstPacketInSubFrame(true);
@ -111,263 +51,215 @@ TEST_P(RtpGenericFrameDescriptorExtensionTest,
descriptor.SetSpatialLayersBitmask(0x49);
descriptor.SetFrameId(0x3412);
ASSERT_EQ(ValueSize(descriptor), sizeof(kRaw));
ASSERT_EQ(RtpGenericFrameDescriptorExtension00::ValueSize(descriptor),
sizeof(kRaw));
uint8_t buffer[sizeof(kRaw)];
EXPECT_TRUE(Write(buffer, descriptor));
EXPECT_TRUE(RtpGenericFrameDescriptorExtension00::Write(buffer, descriptor));
EXPECT_THAT(buffer, ElementsAreArray(kRaw));
}
TEST_P(RtpGenericFrameDescriptorExtensionTest, ParseLastPacketOfSubFrame) {
TEST(RtpGenericFrameDescriptorExtensionTest, ParseLastPacketOfSubFrame) {
constexpr uint8_t kRaw[] = {0x40};
RtpGenericFrameDescriptor descriptor;
ASSERT_TRUE(Parse(kRaw, &descriptor));
ASSERT_TRUE(RtpGenericFrameDescriptorExtension00::Parse(kRaw, &descriptor));
EXPECT_FALSE(descriptor.FirstPacketInSubFrame());
const absl::optional<bool> discardable = descriptor.Discardable();
if (version_ == 0) {
ASSERT_FALSE(discardable.has_value());
} else {
ASSERT_TRUE(discardable.has_value());
EXPECT_FALSE(discardable.value());
}
EXPECT_TRUE(descriptor.LastPacketInSubFrame());
}
TEST_P(RtpGenericFrameDescriptorExtensionTest, WriteLastPacketOfSubFrame) {
uint8_t kRaw[] = {0x40};
if (version_ == 0) {
kRaw[0] |= kDeprecatedFlags;
}
TEST(RtpGenericFrameDescriptorExtensionTest, WriteLastPacketOfSubFrame) {
uint8_t kRaw[] = {0x40 | kDeprecatedFlags};
RtpGenericFrameDescriptor descriptor;
descriptor.SetLastPacketInSubFrame(true);
ASSERT_EQ(ValueSize(descriptor), sizeof(kRaw));
ASSERT_EQ(RtpGenericFrameDescriptorExtension00::ValueSize(descriptor),
sizeof(kRaw));
uint8_t buffer[sizeof(kRaw)];
EXPECT_TRUE(Write(buffer, descriptor));
EXPECT_TRUE(RtpGenericFrameDescriptorExtension00::Write(buffer, descriptor));
EXPECT_THAT(buffer, ElementsAreArray(kRaw));
}
TEST_P(RtpGenericFrameDescriptorExtensionTest, ParseDiscardable) {
if (version_ == 0) {
return;
}
constexpr uint8_t kRaw[] = {0x10};
RtpGenericFrameDescriptor descriptor;
ASSERT_TRUE(Parse(kRaw, &descriptor));
const absl::optional<bool> discardable = descriptor.Discardable();
ASSERT_TRUE(discardable.has_value());
EXPECT_TRUE(discardable.value());
}
TEST_P(RtpGenericFrameDescriptorExtensionTest, WriteDiscardable) {
if (version_ == 0) {
return;
}
constexpr uint8_t kRaw[] = {0x10};
RtpGenericFrameDescriptor descriptor;
descriptor.SetDiscardable(true);
ASSERT_EQ(ValueSize(descriptor), sizeof(kRaw));
uint8_t buffer[sizeof(kRaw)];
EXPECT_TRUE(Write(buffer, descriptor));
EXPECT_THAT(buffer, ElementsAreArray(kRaw));
}
TEST_P(RtpGenericFrameDescriptorExtensionTest, ParseMinShortFrameDependencies) {
TEST(RtpGenericFrameDescriptorExtensionTest, ParseMinShortFrameDependencies) {
constexpr uint16_t kDiff = 1;
constexpr uint8_t kRaw[] = {0x88, 0x01, 0x00, 0x00, 0x04};
RtpGenericFrameDescriptor descriptor;
ASSERT_TRUE(Parse(kRaw, &descriptor));
ASSERT_TRUE(RtpGenericFrameDescriptorExtension00::Parse(kRaw, &descriptor));
ASSERT_TRUE(descriptor.FirstPacketInSubFrame());
EXPECT_THAT(descriptor.FrameDependenciesDiffs(), ElementsAre(kDiff));
}
TEST_P(RtpGenericFrameDescriptorExtensionTest, WriteMinShortFrameDependencies) {
TEST(RtpGenericFrameDescriptorExtensionTest, WriteMinShortFrameDependencies) {
constexpr uint16_t kDiff = 1;
uint8_t kRaw[] = {0x88, 0x01, 0x00, 0x00, 0x04};
if (version_ == 0) {
kRaw[0] |= kDeprecatedFlags;
}
uint8_t kRaw[] = {0x88 | kDeprecatedFlags, 0x01, 0x00, 0x00, 0x04};
RtpGenericFrameDescriptor descriptor;
descriptor.SetFirstPacketInSubFrame(true);
descriptor.AddFrameDependencyDiff(kDiff);
ASSERT_EQ(ValueSize(descriptor), sizeof(kRaw));
ASSERT_EQ(RtpGenericFrameDescriptorExtension00::ValueSize(descriptor),
sizeof(kRaw));
uint8_t buffer[sizeof(kRaw)];
EXPECT_TRUE(Write(buffer, descriptor));
EXPECT_TRUE(RtpGenericFrameDescriptorExtension00::Write(buffer, descriptor));
EXPECT_THAT(buffer, ElementsAreArray(kRaw));
}
TEST_P(RtpGenericFrameDescriptorExtensionTest, ParseMaxShortFrameDependencies) {
TEST(RtpGenericFrameDescriptorExtensionTest, ParseMaxShortFrameDependencies) {
constexpr uint16_t kDiff = 0x3f;
constexpr uint8_t kRaw[] = {0xb8, 0x01, 0x00, 0x00, 0xfc};
RtpGenericFrameDescriptor descriptor;
ASSERT_TRUE(Parse(kRaw, &descriptor));
ASSERT_TRUE(RtpGenericFrameDescriptorExtension00::Parse(kRaw, &descriptor));
ASSERT_TRUE(descriptor.FirstPacketInSubFrame());
EXPECT_THAT(descriptor.FrameDependenciesDiffs(), ElementsAre(kDiff));
}
TEST_P(RtpGenericFrameDescriptorExtensionTest, WriteMaxShortFrameDependencies) {
TEST(RtpGenericFrameDescriptorExtensionTest, WriteMaxShortFrameDependencies) {
constexpr uint16_t kDiff = 0x3f;
uint8_t kRaw[] = {0x88, 0x01, 0x00, 0x00, 0xfc};
if (version_ == 0) {
kRaw[0] |= kDeprecatedFlags;
}
uint8_t kRaw[] = {0x88 | kDeprecatedFlags, 0x01, 0x00, 0x00, 0xfc};
RtpGenericFrameDescriptor descriptor;
descriptor.SetFirstPacketInSubFrame(true);
descriptor.AddFrameDependencyDiff(kDiff);
ASSERT_EQ(ValueSize(descriptor), sizeof(kRaw));
ASSERT_EQ(RtpGenericFrameDescriptorExtension00::ValueSize(descriptor),
sizeof(kRaw));
uint8_t buffer[sizeof(kRaw)];
EXPECT_TRUE(Write(buffer, descriptor));
EXPECT_TRUE(RtpGenericFrameDescriptorExtension00::Write(buffer, descriptor));
EXPECT_THAT(buffer, ElementsAreArray(kRaw));
}
TEST_P(RtpGenericFrameDescriptorExtensionTest, ParseMinLongFrameDependencies) {
TEST(RtpGenericFrameDescriptorExtensionTest, ParseMinLongFrameDependencies) {
constexpr uint16_t kDiff = 0x40;
constexpr uint8_t kRaw[] = {0xb8, 0x01, 0x00, 0x00, 0x02, 0x01};
RtpGenericFrameDescriptor descriptor;
ASSERT_TRUE(Parse(kRaw, &descriptor));
ASSERT_TRUE(RtpGenericFrameDescriptorExtension00::Parse(kRaw, &descriptor));
ASSERT_TRUE(descriptor.FirstPacketInSubFrame());
EXPECT_THAT(descriptor.FrameDependenciesDiffs(), ElementsAre(kDiff));
}
TEST_P(RtpGenericFrameDescriptorExtensionTest, WriteMinLongFrameDependencies) {
TEST(RtpGenericFrameDescriptorExtensionTest, WriteMinLongFrameDependencies) {
constexpr uint16_t kDiff = 0x40;
uint8_t kRaw[] = {0x88, 0x01, 0x00, 0x00, 0x02, 0x01};
if (version_ == 0) {
kRaw[0] |= kDeprecatedFlags;
}
uint8_t kRaw[] = {0x88 | kDeprecatedFlags, 0x01, 0x00, 0x00, 0x02, 0x01};
RtpGenericFrameDescriptor descriptor;
descriptor.SetFirstPacketInSubFrame(true);
descriptor.AddFrameDependencyDiff(kDiff);
ASSERT_EQ(ValueSize(descriptor), sizeof(kRaw));
ASSERT_EQ(RtpGenericFrameDescriptorExtension00::ValueSize(descriptor),
sizeof(kRaw));
uint8_t buffer[sizeof(kRaw)];
EXPECT_TRUE(Write(buffer, descriptor));
EXPECT_TRUE(RtpGenericFrameDescriptorExtension00::Write(buffer, descriptor));
EXPECT_THAT(buffer, ElementsAreArray(kRaw));
}
TEST_P(RtpGenericFrameDescriptorExtensionTest,
TEST(RtpGenericFrameDescriptorExtensionTest,
ParseLongFrameDependenciesAsBigEndian) {
constexpr uint16_t kDiff = 0x7654 >> 2;
constexpr uint8_t kRaw[] = {0xb8, 0x01, 0x00, 0x00, 0x54 | 0x02, 0x76};
RtpGenericFrameDescriptor descriptor;
ASSERT_TRUE(Parse(kRaw, &descriptor));
ASSERT_TRUE(RtpGenericFrameDescriptorExtension00::Parse(kRaw, &descriptor));
ASSERT_TRUE(descriptor.FirstPacketInSubFrame());
EXPECT_THAT(descriptor.FrameDependenciesDiffs(), ElementsAre(kDiff));
}
TEST_P(RtpGenericFrameDescriptorExtensionTest,
TEST(RtpGenericFrameDescriptorExtensionTest,
WriteLongFrameDependenciesAsBigEndian) {
constexpr uint16_t kDiff = 0x7654 >> 2;
uint8_t kRaw[] = {0x88, 0x01, 0x00, 0x00, 0x54 | 0x02, 0x76};
if (version_ == 0) {
kRaw[0] |= kDeprecatedFlags;
}
uint8_t kRaw[] = {
0x88 | kDeprecatedFlags, 0x01, 0x00, 0x00, 0x54 | 0x02, 0x76};
RtpGenericFrameDescriptor descriptor;
descriptor.SetFirstPacketInSubFrame(true);
descriptor.AddFrameDependencyDiff(kDiff);
ASSERT_EQ(ValueSize(descriptor), sizeof(kRaw));
ASSERT_EQ(RtpGenericFrameDescriptorExtension00::ValueSize(descriptor),
sizeof(kRaw));
uint8_t buffer[sizeof(kRaw)];
EXPECT_TRUE(Write(buffer, descriptor));
EXPECT_TRUE(RtpGenericFrameDescriptorExtension00::Write(buffer, descriptor));
EXPECT_THAT(buffer, ElementsAreArray(kRaw));
}
TEST_P(RtpGenericFrameDescriptorExtensionTest, ParseMaxLongFrameDependencies) {
TEST(RtpGenericFrameDescriptorExtensionTest, ParseMaxLongFrameDependencies) {
constexpr uint16_t kDiff = 0x3fff;
constexpr uint8_t kRaw[] = {0xb8, 0x01, 0x00, 0x00, 0xfe, 0xff};
RtpGenericFrameDescriptor descriptor;
ASSERT_TRUE(Parse(kRaw, &descriptor));
ASSERT_TRUE(RtpGenericFrameDescriptorExtension00::Parse(kRaw, &descriptor));
ASSERT_TRUE(descriptor.FirstPacketInSubFrame());
EXPECT_THAT(descriptor.FrameDependenciesDiffs(), ElementsAre(kDiff));
}
TEST_P(RtpGenericFrameDescriptorExtensionTest, WriteMaxLongFrameDependencies) {
TEST(RtpGenericFrameDescriptorExtensionTest, WriteMaxLongFrameDependencies) {
constexpr uint16_t kDiff = 0x3fff;
uint8_t kRaw[] = {0x88, 0x01, 0x00, 0x00, 0xfe, 0xff};
if (version_ == 0) {
kRaw[0] |= kDeprecatedFlags;
}
uint8_t kRaw[] = {0x88 | kDeprecatedFlags, 0x01, 0x00, 0x00, 0xfe, 0xff};
RtpGenericFrameDescriptor descriptor;
descriptor.SetFirstPacketInSubFrame(true);
descriptor.AddFrameDependencyDiff(kDiff);
ASSERT_EQ(ValueSize(descriptor), sizeof(kRaw));
ASSERT_EQ(RtpGenericFrameDescriptorExtension00::ValueSize(descriptor),
sizeof(kRaw));
uint8_t buffer[sizeof(kRaw)];
EXPECT_TRUE(Write(buffer, descriptor));
EXPECT_TRUE(RtpGenericFrameDescriptorExtension00::Write(buffer, descriptor));
EXPECT_THAT(buffer, ElementsAreArray(kRaw));
}
TEST_P(RtpGenericFrameDescriptorExtensionTest, ParseTwoFrameDependencies) {
TEST(RtpGenericFrameDescriptorExtensionTest, ParseTwoFrameDependencies) {
constexpr uint16_t kDiff1 = 9;
constexpr uint16_t kDiff2 = 15;
constexpr uint8_t kRaw[] = {
0xb8, 0x01, 0x00, 0x00, (kDiff1 << 2) | 0x01, kDiff2 << 2};
RtpGenericFrameDescriptor descriptor;
ASSERT_TRUE(Parse(kRaw, &descriptor));
ASSERT_TRUE(RtpGenericFrameDescriptorExtension00::Parse(kRaw, &descriptor));
ASSERT_TRUE(descriptor.FirstPacketInSubFrame());
EXPECT_THAT(descriptor.FrameDependenciesDiffs(), ElementsAre(kDiff1, kDiff2));
}
TEST_P(RtpGenericFrameDescriptorExtensionTest, WriteTwoFrameDependencies) {
TEST(RtpGenericFrameDescriptorExtensionTest, WriteTwoFrameDependencies) {
constexpr uint16_t kDiff1 = 9;
constexpr uint16_t kDiff2 = 15;
uint8_t kRaw[] = {0x88, 0x01, 0x00, 0x00, (kDiff1 << 2) | 0x01, kDiff2 << 2};
if (version_ == 0) {
kRaw[0] |= kDeprecatedFlags;
}
uint8_t kRaw[] = {0x88 | kDeprecatedFlags, 0x01, 0x00, 0x00,
(kDiff1 << 2) | 0x01, kDiff2 << 2};
RtpGenericFrameDescriptor descriptor;
descriptor.SetFirstPacketInSubFrame(true);
descriptor.AddFrameDependencyDiff(kDiff1);
descriptor.AddFrameDependencyDiff(kDiff2);
ASSERT_EQ(ValueSize(descriptor), sizeof(kRaw));
ASSERT_EQ(RtpGenericFrameDescriptorExtension00::ValueSize(descriptor),
sizeof(kRaw));
uint8_t buffer[sizeof(kRaw)];
EXPECT_TRUE(Write(buffer, descriptor));
EXPECT_TRUE(RtpGenericFrameDescriptorExtension00::Write(buffer, descriptor));
EXPECT_THAT(buffer, ElementsAreArray(kRaw));
}
TEST_P(RtpGenericFrameDescriptorExtensionTest,
TEST(RtpGenericFrameDescriptorExtensionTest,
ParseResolutionOnIndependentFrame) {
constexpr int kWidth = 0x2468;
constexpr int kHeight = 0x6543;
constexpr uint8_t kRaw[] = {0xb0, 0x01, 0x00, 0x00, 0x24, 0x68, 0x65, 0x43};
RtpGenericFrameDescriptor descriptor;
ASSERT_TRUE(Parse(kRaw, &descriptor));
ASSERT_TRUE(RtpGenericFrameDescriptorExtension00::Parse(kRaw, &descriptor));
EXPECT_EQ(descriptor.Width(), kWidth);
EXPECT_EQ(descriptor.Height(), kHeight);
}
TEST_P(RtpGenericFrameDescriptorExtensionTest,
TEST(RtpGenericFrameDescriptorExtensionTest,
WriteResolutionOnIndependentFrame) {
constexpr int kWidth = 0x2468;
constexpr int kHeight = 0x6543;
uint8_t kRaw[] = {0x80, 0x01, 0x00, 0x00, 0x24, 0x68, 0x65, 0x43};
if (version_ == 0) {
kRaw[0] |= kDeprecatedFlags;
}
uint8_t kRaw[] = {
0x80 | kDeprecatedFlags, 0x01, 0x00, 0x00, 0x24, 0x68, 0x65, 0x43};
RtpGenericFrameDescriptor descriptor;
descriptor.SetFirstPacketInSubFrame(true);
descriptor.SetResolution(kWidth, kHeight);
ASSERT_EQ(ValueSize(descriptor), sizeof(kRaw));
ASSERT_EQ(RtpGenericFrameDescriptorExtension00::ValueSize(descriptor),
sizeof(kRaw));
uint8_t buffer[sizeof(kRaw)];
EXPECT_TRUE(Write(buffer, descriptor));
EXPECT_TRUE(RtpGenericFrameDescriptorExtension00::Write(buffer, descriptor));
EXPECT_THAT(buffer, ElementsAreArray(kRaw));
}
} // namespace

1
modules/rtp_rtcp/source/rtp_header_extension_map.cc
View file

@ -46,7 +46,6 @@ constexpr ExtensionInfo kExtensions[] = {
CreateExtensionInfo<RepairedRtpStreamId>(),
CreateExtensionInfo<RtpMid>(),
CreateExtensionInfo<RtpGenericFrameDescriptorExtension00>(),
CreateExtensionInfo<RtpGenericFrameDescriptorExtension01>(),
CreateExtensionInfo<RtpDependencyDescriptorExtension>(),
CreateExtensionInfo<ColorSpaceExtension>(),
CreateExtensionInfo<InbandComfortNoiseExtension>(),

1
modules/rtp_rtcp/source/rtp_packet.cc
View file

@ -190,7 +190,6 @@ void RtpPacket::ZeroMutableExtensions() {
case RTPExtensionType::kRtpExtensionColorSpace:
case RTPExtensionType::kRtpExtensionFrameMarking:
case RTPExtensionType::kRtpExtensionGenericFrameDescriptor00:
case RTPExtensionType::kRtpExtensionGenericFrameDescriptor01:
case RTPExtensionType::kRtpExtensionGenericFrameDescriptor02:
case RTPExtensionType::kRtpExtensionMid:
case RTPExtensionType::kRtpExtensionNumberOfExtensions:

2
modules/rtp_rtcp/source/rtp_sender.cc
View file

@ -82,8 +82,6 @@ constexpr RtpExtensionSize kVideoExtensionSizes[] = {
CreateMaxExtensionSize<RtpMid>(),
{RtpGenericFrameDescriptorExtension00::kId,
RtpGenericFrameDescriptorExtension00::kMaxSizeBytes},
{RtpGenericFrameDescriptorExtension01::kId,
RtpGenericFrameDescriptorExtension01::kMaxSizeBytes},
};
bool HasBweExtension(const RtpHeaderExtensionMap& extensions_map) {

7
modules/rtp_rtcp/source/rtp_sender_unittest.cc
View file

@ -47,8 +47,7 @@ namespace {
enum : int { // The first valid value is 1.
kAbsoluteSendTimeExtensionId = 1,
kAudioLevelExtensionId,
kGenericDescriptorId00,
kGenericDescriptorId01,
kGenericDescriptorId,
kMidExtensionId,
kRepairedRidExtensionId,
kRidExtensionId,
@ -109,9 +108,7 @@ class LoopbackTransportTest : public webrtc::Transport {
kVideoTimingExtensionId);
receivers_extensions_.Register<RtpMid>(kMidExtensionId);
receivers_extensions_.Register<RtpGenericFrameDescriptorExtension00>(
kGenericDescriptorId00);
receivers_extensions_.Register<RtpGenericFrameDescriptorExtension01>(
kGenericDescriptorId01);
kGenericDescriptorId);
receivers_extensions_.Register<RtpStreamId>(kRidExtensionId);
receivers_extensions_.Register<RepairedRtpStreamId>(
kRepairedRidExtensionId);

3
modules/rtp_rtcp/source/rtp_sender_video.cc
View file

@ -358,12 +358,11 @@ void RTPSenderVideo::AddRtpHeaderExtensions(
descriptor.attached_structure.release();
}
// Do not use v0/v1 generic frame descriptor when v2 is stored.
// Do not use generic frame descriptor when dependency descriptor is stored.
if (!extension_is_set) {
RtpGenericFrameDescriptor generic_descriptor;
generic_descriptor.SetFirstPacketInSubFrame(first_packet);
generic_descriptor.SetLastPacketInSubFrame(last_packet);
generic_descriptor.SetDiscardable(video_header.generic->discardable);
if (first_packet) {
generic_descriptor.SetFrameId(

1
modules/rtp_rtcp/source/rtp_utility.cc
View file

@ -534,7 +534,6 @@ void RtpHeaderParser::ParseOneByteExtensionHeader(
break;
}
case kRtpExtensionGenericFrameDescriptor00:
case kRtpExtensionGenericFrameDescriptor01:
case kRtpExtensionGenericFrameDescriptor02:
RTC_LOG(WARNING)
<< "RtpGenericFrameDescriptor unsupported by rtp header parser.";

5
test/fuzzers/rtp_packet_fuzzer.cc
View file

@ -136,11 +136,6 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
packet.GetExtension<RtpGenericFrameDescriptorExtension00>(&descriptor);
break;
}
case kRtpExtensionGenericFrameDescriptor01: {
RtpGenericFrameDescriptor descriptor;
packet.GetExtension<RtpGenericFrameDescriptorExtension01>(&descriptor);
break;
}
case kRtpExtensionColorSpace: {
ColorSpace color_space;
packet.GetExtension<ColorSpaceExtension>(&color_space);