admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Delete enum RtpVideoCodecTypes, replaced with VideoCodecType.

Browse Source 
Bug: webrtc:8995
Change-Id: I0b44aa26f2f6a81aec7ca1281b8513d8e03228b8
Reviewed-on: https://webrtc-review.googlesource.com/79561
Reviewed-by: Sami Kalliomäki <sakal@webrtc.org>
Reviewed-by: Patrik Höglund <phoglund@webrtc.org>
Reviewed-by: Åsa Persson <asapersson@webrtc.org>
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23507}
This commit is contained in:
Niels Möller 2018-06-04 11:14:38 +02:00 committed by Commit Bot
parent b18931d30c
commit 520ca4e3b8
36 changed files with 174 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
common_types.h
View File

@ -405,6 +405,9 @@ struct VideoCodecH264 {
// Video codec types
enum VideoCodecType {
// There are various memset(..., 0, ...) calls in the code that rely on
// kVideoCodecUnknown being zero.
kVideoCodecUnknown = 0,
kVideoCodecVP8,
kVideoCodecVP9,
kVideoCodecH264,
@ -414,7 +417,13 @@ enum VideoCodecType {
kVideoCodecFlexfec,
kVideoCodecGeneric,
kVideoCodecMultiplex,
kVideoCodecUnknown
// TODO(nisse): Deprecated aliases, for code expecting RtpVideoCodecTypes.
kRtpVideoNone = kVideoCodecUnknown,
kRtpVideoGeneric = kVideoCodecGeneric,
kRtpVideoVp8 = kVideoCodecVP8,
kRtpVideoVp9 = kVideoCodecVP9,
kRtpVideoH264 = kVideoCodecH264,
};
// Translates from name of codec to codec type and vice versa.

11
modules/include/module_common_types.h
View File

@ -42,13 +42,8 @@ struct RTPAudioHeader {
size_t channel; // number of channels 2 = stereo
};
enum RtpVideoCodecTypes {
kRtpVideoNone = 0,
kRtpVideoGeneric = 1,
kRtpVideoVp8 = 2,
kRtpVideoVp9 = 3,
kRtpVideoH264 = 4
};
// TODO(nisse): Deprecated, use webrtc::VideoCodecType instead.
using RtpVideoCodecTypes = VideoCodecType;
union RTPVideoTypeHeader {
RTPVideoHeaderVP8 VP8;
@ -72,7 +67,7 @@ struct RTPVideoHeader {
bool is_first_packet_in_frame;
uint8_t simulcastIdx; // Index if the simulcast encoder creating
// this frame, 0 if not using simulcast.
RtpVideoCodecTypes codec;
VideoCodecType codec;
RTPVideoTypeHeader codecHeader;
};
union RTPTypeHeader {

4
modules/rtp_rtcp/include/rtp_rtcp_defines.h
View File

@ -55,8 +55,8 @@ struct AudioPayload {
};
struct VideoPayload {
RtpVideoCodecTypes videoCodecType;
// The H264 profile only matters if videoCodecType == kRtpVideoH264.
VideoCodecType videoCodecType;
// The H264 profile only matters if videoCodecType == kVideoCodecH264.
H264::Profile h264_profile;
};

26
modules/rtp_rtcp/source/rtp_format.cc
View File

@ -18,45 +18,45 @@
#include "modules/rtp_rtcp/source/rtp_format_vp9.h"
namespace webrtc {
RtpPacketizer* RtpPacketizer::Create(RtpVideoCodecTypes type,
RtpPacketizer* RtpPacketizer::Create(VideoCodecType type,
size_t max_payload_len,
size_t last_packet_reduction_len,
const RTPVideoTypeHeader* rtp_type_header,
FrameType frame_type) {
switch (type) {
case kRtpVideoH264:
case kVideoCodecH264:
RTC_CHECK(rtp_type_header);
return new RtpPacketizerH264(max_payload_len, last_packet_reduction_len,
rtp_type_header->H264.packetization_mode);
case kRtpVideoVp8:
case kVideoCodecVP8:
RTC_CHECK(rtp_type_header);
return new RtpPacketizerVp8(rtp_type_header->VP8, max_payload_len,
last_packet_reduction_len);
case kRtpVideoVp9:
case kVideoCodecVP9:
RTC_CHECK(rtp_type_header);
return new RtpPacketizerVp9(rtp_type_header->VP9, max_payload_len,
last_packet_reduction_len);
case kRtpVideoGeneric:
case kVideoCodecGeneric:
return new RtpPacketizerGeneric(frame_type, max_payload_len,
last_packet_reduction_len);
case kRtpVideoNone:
default:
RTC_NOTREACHED();
}
return nullptr;
}
RtpDepacketizer* RtpDepacketizer::Create(RtpVideoCodecTypes type) {
RtpDepacketizer* RtpDepacketizer::Create(VideoCodecType type) {
switch (type) {
case kRtpVideoH264:
case kVideoCodecH264:
return new RtpDepacketizerH264();
case kRtpVideoVp8:
case kVideoCodecVP8:
return new RtpDepacketizerVp8();
case kRtpVideoVp9:
case kVideoCodecVP9:
return new RtpDepacketizerVp9();
case kRtpVideoGeneric:
case kVideoCodecGeneric:
return new RtpDepacketizerGeneric();
case kRtpVideoNone:
assert(false);
default:
RTC_NOTREACHED();
}
return nullptr;
}

5
modules/rtp_rtcp/source/rtp_format.h
View File

@ -13,6 +13,7 @@
#include <string>
#include "common_types.h" // NOLINT(build/include)
#include "modules/include/module_common_types.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "rtc_base/constructormagic.h"
@ -22,7 +23,7 @@ class RtpPacketToSend;
class RtpPacketizer {
public:
static RtpPacketizer* Create(RtpVideoCodecTypes type,
static RtpPacketizer* Create(VideoCodecType type,
size_t max_payload_len,
size_t last_packet_reduction_len,
const RTPVideoTypeHeader* rtp_type_header,
@ -57,7 +58,7 @@ class RtpDepacketizer {
RTPTypeHeader type;
};
static RtpDepacketizer* Create(RtpVideoCodecTypes type);
static RtpDepacketizer* Create(VideoCodecType type);
virtual ~RtpDepacketizer() {}

4
modules/rtp_rtcp/source/rtp_format_h264.cc
View File

@ -456,7 +456,7 @@ bool RtpDepacketizerH264::ProcessStapAOrSingleNalu(
const uint8_t* payload_data) {
parsed_payload->type.Video.width = 0;
parsed_payload->type.Video.height = 0;
parsed_payload->type.Video.codec = kRtpVideoH264;
parsed_payload->type.Video.codec = kVideoCodecH264;
parsed_payload->type.Video.is_first_packet_in_frame = true;
RTPVideoHeaderH264* h264_header =
&parsed_payload->type.Video.codecHeader.H264;
@ -674,7 +674,7 @@ bool RtpDepacketizerH264::ParseFuaNalu(
}
parsed_payload->type.Video.width = 0;
parsed_payload->type.Video.height = 0;
parsed_payload->type.Video.codec = kRtpVideoH264;
parsed_payload->type.Video.codec = kVideoCodecH264;
parsed_payload->type.Video.is_first_packet_in_frame = first_fragment;
RTPVideoHeaderH264* h264 = &parsed_payload->type.Video.codecHeader.H264;
h264->packetization_type = kH264FuA;

20
modules/rtp_rtcp/source/rtp_format_h264_unittest.cc
View File

@ -67,7 +67,7 @@ RtpPacketizer* CreateH264Packetizer(H264PacketizationMode mode,
size_t last_packet_reduction) {
RTPVideoTypeHeader type_header;
type_header.H264.packetization_mode = mode;
return RtpPacketizer::Create(kRtpVideoH264, max_payload_size,
return RtpPacketizer::Create(kVideoCodecH264, max_payload_size,
last_packet_reduction, &type_header,
kEmptyFrame);
}
@ -578,7 +578,7 @@ TEST_F(RtpPacketizerH264TestSpsRewriting, StapASps) {
class RtpDepacketizerH264Test : public ::testing::Test {
protected:
RtpDepacketizerH264Test()
: depacketizer_(RtpDepacketizer::Create(kRtpVideoH264)) {}
: depacketizer_(RtpDepacketizer::Create(kVideoCodecH264)) {}
void ExpectPacket(RtpDepacketizer::ParsedPayload* parsed_payload,
const uint8_t* data,
@ -600,7 +600,7 @@ TEST_F(RtpDepacketizerH264Test, TestSingleNalu) {
ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet)));
ExpectPacket(&payload, packet, sizeof(packet));
EXPECT_EQ(kVideoFrameKey, payload.frame_type);
EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
EXPECT_EQ(kVideoCodecH264, payload.type.Video.codec);
EXPECT_TRUE(payload.type.Video.is_first_packet_in_frame);
EXPECT_EQ(kH264SingleNalu,
payload.type.Video.codecHeader.H264.packetization_type);
@ -616,7 +616,7 @@ TEST_F(RtpDepacketizerH264Test, TestSingleNaluSpsWithResolution) {
ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet)));
ExpectPacket(&payload, packet, sizeof(packet));
EXPECT_EQ(kVideoFrameKey, payload.frame_type);
EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
EXPECT_EQ(kVideoCodecH264, payload.type.Video.codec);
EXPECT_TRUE(payload.type.Video.is_first_packet_in_frame);
EXPECT_EQ(kH264SingleNalu,
payload.type.Video.codecHeader.H264.packetization_type);
@ -646,7 +646,7 @@ TEST_F(RtpDepacketizerH264Test, TestStapAKey) {
ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet)));
ExpectPacket(&payload, packet, sizeof(packet));
EXPECT_EQ(kVideoFrameKey, payload.frame_type);
EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
EXPECT_EQ(kVideoCodecH264, payload.type.Video.codec);
EXPECT_TRUE(payload.type.Video.is_first_packet_in_frame);
const RTPVideoHeaderH264& h264 = payload.type.Video.codecHeader.H264;
EXPECT_EQ(kH264StapA, h264.packetization_type);
@ -677,7 +677,7 @@ TEST_F(RtpDepacketizerH264Test, TestStapANaluSpsWithResolution) {
ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet)));
ExpectPacket(&payload, packet, sizeof(packet));
EXPECT_EQ(kVideoFrameKey, payload.frame_type);
EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
EXPECT_EQ(kVideoCodecH264, payload.type.Video.codec);
EXPECT_TRUE(payload.type.Video.is_first_packet_in_frame);
EXPECT_EQ(kH264StapA, payload.type.Video.codecHeader.H264.packetization_type);
EXPECT_EQ(1280u, payload.type.Video.width);
@ -804,7 +804,7 @@ TEST_F(RtpDepacketizerH264Test, TestStapADelta) {
ASSERT_TRUE(depacketizer_->Parse(&payload, packet, sizeof(packet)));
ExpectPacket(&payload, packet, sizeof(packet));
EXPECT_EQ(kVideoFrameDelta, payload.frame_type);
EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
EXPECT_EQ(kVideoCodecH264, payload.type.Video.codec);
EXPECT_TRUE(payload.type.Video.is_first_packet_in_frame);
EXPECT_EQ(kH264StapA, payload.type.Video.codecHeader.H264.packetization_type);
// NALU type for aggregated packets is the type of the first packet only.
@ -843,7 +843,7 @@ TEST_F(RtpDepacketizerH264Test, TestFuA) {
ASSERT_TRUE(depacketizer_->Parse(&payload, packet1, sizeof(packet1)));
ExpectPacket(&payload, kExpected1, sizeof(kExpected1));
EXPECT_EQ(kVideoFrameKey, payload.frame_type);
EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
EXPECT_EQ(kVideoCodecH264, payload.type.Video.codec);
EXPECT_TRUE(payload.type.Video.is_first_packet_in_frame);
const RTPVideoHeaderH264& h264 = payload.type.Video.codecHeader.H264;
EXPECT_EQ(kH264FuA, h264.packetization_type);
@ -859,7 +859,7 @@ TEST_F(RtpDepacketizerH264Test, TestFuA) {
ASSERT_TRUE(depacketizer_->Parse(&payload, packet2, sizeof(packet2)));
ExpectPacket(&payload, kExpected2, sizeof(kExpected2));
EXPECT_EQ(kVideoFrameKey, payload.frame_type);
EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
EXPECT_EQ(kVideoCodecH264, payload.type.Video.codec);
EXPECT_FALSE(payload.type.Video.is_first_packet_in_frame);
{
const RTPVideoHeaderH264& h264 = payload.type.Video.codecHeader.H264;
@ -873,7 +873,7 @@ TEST_F(RtpDepacketizerH264Test, TestFuA) {
ASSERT_TRUE(depacketizer_->Parse(&payload, packet3, sizeof(packet3)));
ExpectPacket(&payload, kExpected3, sizeof(kExpected3));
EXPECT_EQ(kVideoFrameKey, payload.frame_type);
EXPECT_EQ(kRtpVideoH264, payload.type.Video.codec);
EXPECT_EQ(kVideoCodecH264, payload.type.Video.codec);
EXPECT_FALSE(payload.type.Video.is_first_packet_in_frame);
{
const RTPVideoHeaderH264& h264 = payload.type.Video.codecHeader.H264;

2
modules/rtp_rtcp/source/rtp_format_video_generic.cc
View File

@ -132,7 +132,7 @@ bool RtpDepacketizerGeneric::Parse(ParsedPayload* parsed_payload,
: kVideoFrameDelta;
parsed_payload->type.Video.is_first_packet_in_frame =
(generic_header & RtpFormatVideoGeneric::kFirstPacketBit) != 0;
parsed_payload->type.Video.codec = kRtpVideoGeneric;
parsed_payload->type.Video.codec = kVideoCodecGeneric;
parsed_payload->type.Video.width = 0;
parsed_payload->type.Video.height = 0;

2
modules/rtp_rtcp/source/rtp_format_vp8.cc
View File

@ -488,7 +488,7 @@ bool RtpDepacketizerVp8::Parse(ParsedPayload* parsed_payload,
parsed_payload->type.Video.is_first_packet_in_frame =
beginning_of_partition && (partition_id == 0);
parsed_payload->type.Video.simulcastIdx = 0;
parsed_payload->type.Video.codec = kRtpVideoVp8;
parsed_payload->type.Video.codec = kVideoCodecVP8;
parsed_payload->type.Video.codecHeader.VP8.nonReference =
(*payload_data & 0x20) ? true : false; // N bit
parsed_payload->type.Video.codecHeader.VP8.partitionId = partition_id;

16
modules/rtp_rtcp/source/rtp_format_vp8_unittest.cc
View File

@ -287,7 +287,7 @@ TEST_F(RtpPacketizerVp8Test, TestTIDAndKeyIdx) {
class RtpDepacketizerVp8Test : public ::testing::Test {
protected:
RtpDepacketizerVp8Test()
: depacketizer_(RtpDepacketizer::Create(kRtpVideoVp8)) {}
: depacketizer_(RtpDepacketizer::Create(kVideoCodecVP8)) {}
void ExpectPacket(RtpDepacketizer::ParsedPayload* parsed_payload,
const uint8_t* data,
@ -314,7 +314,7 @@ TEST_F(RtpDepacketizerVp8Test, BasicHeader) {
&payload, packet + kHeaderLength, sizeof(packet) - kHeaderLength);
EXPECT_EQ(kVideoFrameDelta, payload.frame_type);
EXPECT_EQ(kRtpVideoVp8, payload.type.Video.codec);
EXPECT_EQ(kVideoCodecVP8, payload.type.Video.codec);
VerifyBasicHeader(&payload.type, 0, 1, 4);
VerifyExtensions(
&payload.type, kNoPictureId, kNoTl0PicIdx, kNoTemporalIdx, kNoKeyIdx);
@ -334,7 +334,7 @@ TEST_F(RtpDepacketizerVp8Test, PictureID) {
ExpectPacket(
&payload, packet + kHeaderLength1, sizeof(packet) - kHeaderLength1);
EXPECT_EQ(kVideoFrameDelta, payload.frame_type);
EXPECT_EQ(kRtpVideoVp8, payload.type.Video.codec);
EXPECT_EQ(kVideoCodecVP8, payload.type.Video.codec);
VerifyBasicHeader(&payload.type, 1, 0, 0);
VerifyExtensions(
&payload.type, kPictureId, kNoTl0PicIdx, kNoTemporalIdx, kNoKeyIdx);
@ -368,7 +368,7 @@ TEST_F(RtpDepacketizerVp8Test, Tl0PicIdx) {
ExpectPacket(
&payload, packet + kHeaderLength, sizeof(packet) - kHeaderLength);
EXPECT_EQ(kVideoFrameKey, payload.frame_type);
EXPECT_EQ(kRtpVideoVp8, payload.type.Video.codec);
EXPECT_EQ(kVideoCodecVP8, payload.type.Video.codec);
VerifyBasicHeader(&payload.type, 0, 1, 0);
VerifyExtensions(
&payload.type, kNoPictureId, kTl0PicIdx, kNoTemporalIdx, kNoKeyIdx);
@ -386,7 +386,7 @@ TEST_F(RtpDepacketizerVp8Test, TIDAndLayerSync) {
ExpectPacket(
&payload, packet + kHeaderLength, sizeof(packet) - kHeaderLength);
EXPECT_EQ(kVideoFrameDelta, payload.frame_type);
EXPECT_EQ(kRtpVideoVp8, payload.type.Video.codec);
EXPECT_EQ(kVideoCodecVP8, payload.type.Video.codec);
VerifyBasicHeader(&payload.type, 0, 0, 8);
VerifyExtensions(&payload.type, kNoPictureId, kNoTl0PicIdx, 2, kNoKeyIdx);
EXPECT_FALSE(payload.type.Video.codecHeader.VP8.layerSync);
@ -405,7 +405,7 @@ TEST_F(RtpDepacketizerVp8Test, KeyIdx) {
ExpectPacket(
&payload, packet + kHeaderLength, sizeof(packet) - kHeaderLength);
EXPECT_EQ(kVideoFrameDelta, payload.frame_type);
EXPECT_EQ(kRtpVideoVp8, payload.type.Video.codec);
EXPECT_EQ(kVideoCodecVP8, payload.type.Video.codec);
VerifyBasicHeader(&payload.type, 0, 0, 8);
VerifyExtensions(
&payload.type, kNoPictureId, kNoTl0PicIdx, kNoTemporalIdx, kKeyIdx);
@ -426,7 +426,7 @@ TEST_F(RtpDepacketizerVp8Test, MultipleExtensions) {
ExpectPacket(
&payload, packet + kHeaderLength, sizeof(packet) - kHeaderLength);
EXPECT_EQ(kVideoFrameDelta, payload.frame_type);
EXPECT_EQ(kRtpVideoVp8, payload.type.Video.codec);
EXPECT_EQ(kVideoCodecVP8, payload.type.Video.codec);
VerifyBasicHeader(&payload.type, 0, 0, 8);
VerifyExtensions(&payload.type, (17 << 8) + 17, 42, 1, 17);
}
@ -465,7 +465,7 @@ TEST_F(RtpDepacketizerVp8Test, TestWithPacketizer) {
auto vp8_payload = rtp_payload.subview(kHeaderLength);
ExpectPacket(&payload, vp8_payload.data(), vp8_payload.size());
EXPECT_EQ(kVideoFrameKey, payload.frame_type);
EXPECT_EQ(kRtpVideoVp8, payload.type.Video.codec);
EXPECT_EQ(kVideoCodecVP8, payload.type.Video.codec);
VerifyBasicHeader(&payload.type, 1, 1, 0);
VerifyExtensions(&payload.type,
input_header.pictureId,

2
modules/rtp_rtcp/source/rtp_format_vp9.cc
View File

@ -716,7 +716,7 @@ bool RtpDepacketizerVp9::Parse(ParsedPayload* parsed_payload,
parsed_payload->type.Video.width = 0;
parsed_payload->type.Video.height = 0;
parsed_payload->type.Video.simulcastIdx = 0;
parsed_payload->type.Video.codec = kRtpVideoVp9;
parsed_payload->type.Video.codec = kVideoCodecVP9;
parsed_payload->frame_type = p_bit ? kVideoFrameDelta : kVideoFrameKey;

2
modules/rtp_rtcp/source/rtp_format_vp9_unittest.cc
View File

@ -82,7 +82,7 @@ void ParseAndCheckPacket(const uint8_t* packet,
std::unique_ptr<RtpDepacketizer> depacketizer(new RtpDepacketizerVp9());
RtpDepacketizer::ParsedPayload parsed;
ASSERT_TRUE(depacketizer->Parse(&parsed, packet, expected_length));
EXPECT_EQ(kRtpVideoVp9, parsed.type.Video.codec);
EXPECT_EQ(kVideoCodecVP9, parsed.type.Video.codec);
VerifyHeader(expected, parsed.type.Video.codecHeader.VP9);
const size_t kExpectedPayloadLength = expected_length - expected_hdr_length;
VerifyPayload(parsed, packet + expected_hdr_length, kExpectedPayloadLength);

15
modules/rtp_rtcp/source/rtp_payload_registry.cc
View File

@ -51,22 +51,15 @@ RtpUtility::Payload CreatePayloadType(const SdpAudioFormat& audio_format) {
RtpVideoCodecTypes ConvertToRtpVideoCodecType(VideoCodecType type) {
switch (type) {
case kVideoCodecVP8:
return kRtpVideoVp8;
case kVideoCodecVP9:
return kRtpVideoVp9;
case kVideoCodecH264:
return kRtpVideoH264;
return type;
case kVideoCodecRED:
case kVideoCodecULPFEC:
return kRtpVideoNone;
case kVideoCodecI420:
case kVideoCodecFlexfec:
case kVideoCodecGeneric:
case kVideoCodecMultiplex:
case kVideoCodecUnknown:
return kRtpVideoGeneric;
return kVideoCodecUnknown;
default:
return kVideoCodecGeneric;
}
return kRtpVideoGeneric;
}
RtpUtility::Payload CreatePayloadType(const VideoCodec& video_codec) {

2
modules/rtp_rtcp/source/rtp_payload_registry_unittest.cc
View File

@ -41,7 +41,7 @@ TEST(RtpPayloadRegistryTest,
// We should get back the corresponding payload that we registered.
EXPECT_STREQ("VP8", retrieved_payload->name);
EXPECT_TRUE(retrieved_payload->typeSpecific.is_video());
EXPECT_EQ(kRtpVideoVp8,
EXPECT_EQ(kVideoCodecVP8,
retrieved_payload->typeSpecific.video_payload().videoCodecType);
// Now forget about it and verify it's gone.

2
modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
View File

@ -244,7 +244,7 @@ class RtpRtcpImplTest : public ::testing::Test {
rtp_video_header.playout_delay = {-1, -1};
rtp_video_header.is_first_packet_in_frame = true;
rtp_video_header.simulcastIdx = 0;
rtp_video_header.codec = kRtpVideoVp8;
rtp_video_header.codec = kVideoCodecVP8;
rtp_video_header.codecHeader = {vp8_header};
rtp_video_header.video_timing = {0u, 0u, 0u, 0u, 0u, 0u, false};

9
modules/rtp_rtcp/source/rtp_sender.cc
View File

@ -353,7 +353,7 @@ void RTPSender::SetRtxPayloadType(int payload_type,
}
int32_t RTPSender::CheckPayloadType(int8_t payload_type,
RtpVideoCodecTypes* video_type) {
VideoCodecType* video_type) {
rtc::CritScope lock(&send_critsect_);
if (payload_type < 0) {
@ -409,7 +409,7 @@ bool RTPSender::SendOutgoingData(FrameType frame_type,
if (!sending_media_)
return true;
}
RtpVideoCodecTypes video_type = kRtpVideoGeneric;
VideoCodecType video_type = kVideoCodecGeneric;
if (CheckPayloadType(payload_type, &video_type) != 0) {
RTC_LOG(LS_ERROR) << "Don't send data with unknown payload type: "
<< static_cast<int>(payload_type) << ".";
@ -1211,11 +1211,6 @@ int32_t RTPSender::SetAudioLevel(uint8_t level_d_bov) {
return audio_->SetAudioLevel(level_d_bov);
}
RtpVideoCodecTypes RTPSender::VideoCodecType() const {
RTC_DCHECK(!audio_configured_) << "Sender is an audio stream!";
return video_->VideoCodecType();
}
void RTPSender::SetUlpfecConfig(int red_payload_type, int ulpfec_payload_type) {
RTC_DCHECK(!audio_configured_);
video_->SetUlpfecConfig(red_payload_type, ulpfec_payload_type);

4
modules/rtp_rtcp/source/rtp_sender.h
View File

@ -187,8 +187,6 @@ class RTPSender {
// header-extension-for-audio-level-indication.
int32_t SetAudioLevel(uint8_t level_d_bov);
RtpVideoCodecTypes VideoCodecType() const;
uint32_t MaxConfiguredBitrateVideo() const;
// ULPFEC.
@ -214,7 +212,7 @@ class RTPSender {
void SetRtt(int64_t rtt_ms);
protected:
int32_t CheckPayloadType(int8_t payload_type, RtpVideoCodecTypes* video_type);
int32_t CheckPayloadType(int8_t payload_type, VideoCodecType* video_type);
private:
// Maps capture time in milliseconds to send-side delay in milliseconds.

26
modules/rtp_rtcp/source/rtp_sender_unittest.cc
View File

@ -1684,7 +1684,7 @@ TEST_P(RtpSenderVideoTest, KeyFrameHasCVO) {
RTPVideoHeader hdr = {0};
hdr.rotation = kVideoRotation_0;
rtp_sender_video_->SendVideo(kRtpVideoGeneric, kVideoFrameKey, kPayload,
rtp_sender_video_->SendVideo(kVideoCodecGeneric, kVideoFrameKey, kPayload,
kTimestamp, 0, kFrame, sizeof(kFrame), nullptr,
&hdr, kDefaultExpectedRetransmissionTimeMs);
@ -1710,7 +1710,7 @@ TEST_P(RtpSenderVideoTest, TimingFrameHasPacketizationTimstampSet) {
hdr.video_timing.encode_finish_delta_ms = kEncodeFinishDeltaMs;
fake_clock_.AdvanceTimeMilliseconds(kPacketizationTimeMs);
rtp_sender_video_->SendVideo(kRtpVideoGeneric, kVideoFrameKey, kPayload,
rtp_sender_video_->SendVideo(kVideoCodecGeneric, kVideoFrameKey, kPayload,
kTimestamp, kCaptureTimestamp, kFrame,
sizeof(kFrame), nullptr, &hdr,
kDefaultExpectedRetransmissionTimeMs);
@ -1730,12 +1730,12 @@ TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenChanged) {
RTPVideoHeader hdr = {0};
hdr.rotation = kVideoRotation_90;
EXPECT_TRUE(rtp_sender_video_->SendVideo(
kRtpVideoGeneric, kVideoFrameKey, kPayload, kTimestamp, 0, kFrame,
kVideoCodecGeneric, kVideoFrameKey, kPayload, kTimestamp, 0, kFrame,
sizeof(kFrame), nullptr, &hdr, kDefaultExpectedRetransmissionTimeMs));
hdr.rotation = kVideoRotation_0;
EXPECT_TRUE(rtp_sender_video_->SendVideo(
kRtpVideoGeneric, kVideoFrameDelta, kPayload, kTimestamp + 1, 0, kFrame,
kVideoCodecGeneric, kVideoFrameDelta, kPayload, kTimestamp + 1, 0, kFrame,
sizeof(kFrame), nullptr, &hdr, kDefaultExpectedRetransmissionTimeMs));
VideoRotation rotation;
@ -1752,11 +1752,11 @@ TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenNonZero) {
RTPVideoHeader hdr = {0};
hdr.rotation = kVideoRotation_90;
EXPECT_TRUE(rtp_sender_video_->SendVideo(
kRtpVideoGeneric, kVideoFrameKey, kPayload, kTimestamp, 0, kFrame,
kVideoCodecGeneric, kVideoFrameKey, kPayload, kTimestamp, 0, kFrame,
sizeof(kFrame), nullptr, &hdr, kDefaultExpectedRetransmissionTimeMs));
EXPECT_TRUE(rtp_sender_video_->SendVideo(
kRtpVideoGeneric, kVideoFrameDelta, kPayload, kTimestamp + 1, 0, kFrame,
kVideoCodecGeneric, kVideoFrameDelta, kPayload, kTimestamp + 1, 0, kFrame,
sizeof(kFrame), nullptr, &hdr, kDefaultExpectedRetransmissionTimeMs));
VideoRotation rotation;
@ -1788,7 +1788,7 @@ TEST_P(RtpSenderVideoTest, SendVideoWithCameraAndFlipCVO) {
TEST_P(RtpSenderVideoTest, RetransmissionTypesGeneric) {
RTPVideoHeader header;
header.codec = kRtpVideoGeneric;
header.codec = kVideoCodecGeneric;
EXPECT_EQ(kDontRetransmit,
rtp_sender_video_->GetStorageType(
@ -1810,7 +1810,7 @@ TEST_P(RtpSenderVideoTest, RetransmissionTypesGeneric) {
TEST_P(RtpSenderVideoTest, RetransmissionTypesH264) {
RTPVideoHeader header;
header.codec = kRtpVideoH264;
header.codec = kVideoCodecH264;
header.codecHeader.H264.packetization_mode =
H264PacketizationMode::NonInterleaved;
@ -1834,7 +1834,7 @@ TEST_P(RtpSenderVideoTest, RetransmissionTypesH264) {
TEST_P(RtpSenderVideoTest, RetransmissionTypesVP8BaseLayer) {
RTPVideoHeader header;
header.codec = kRtpVideoVp8;
header.codec = kVideoCodecVP8;
header.codecHeader.VP8.temporalIdx = 0;
EXPECT_EQ(kDontRetransmit,
@ -1865,7 +1865,7 @@ TEST_P(RtpSenderVideoTest, RetransmissionTypesVP8BaseLayer) {
TEST_P(RtpSenderVideoTest, RetransmissionTypesVP8HigherLayers) {
RTPVideoHeader header;
header.codec = kRtpVideoVp8;
header.codec = kVideoCodecVP8;
for (int tid = 1; tid <= kMaxTemporalStreams; ++tid) {
header.codecHeader.VP8.temporalIdx = tid;
@ -1891,7 +1891,7 @@ TEST_P(RtpSenderVideoTest, RetransmissionTypesVP8HigherLayers) {
TEST_P(RtpSenderVideoTest, RetransmissionTypesVP9) {
RTPVideoHeader header;
header.codec = kRtpVideoVp9;
header.codec = kVideoCodecVP9;
for (int tid = 1; tid <= kMaxTemporalStreams; ++tid) {
header.codecHeader.VP9.temporal_idx = tid;
@ -1923,7 +1923,7 @@ TEST_P(RtpSenderVideoTest, ConditionalRetransmit) {
// Insert VP8 frames for all temporal layers, but stop before the final index.
RTPVideoHeader header;
header.codec = kRtpVideoVp8;
header.codec = kVideoCodecVP8;
// Fill averaging window to prevent rounding errors.
constexpr int kNumRepetitions =
@ -1980,7 +1980,7 @@ TEST_P(RtpSenderVideoTest, ConditionalRetransmitLimit) {
// Insert VP8 frames for all temporal layers, but stop before the final index.
RTPVideoHeader header;
header.codec = kRtpVideoVp8;
header.codec = kVideoCodecVP8;
// Fill averaging window to prevent rounding errors.
constexpr int kNumRepetitions =

26
modules/rtp_rtcp/source/rtp_sender_video.cc
View File

@ -54,7 +54,7 @@ RTPSenderVideo::RTPSenderVideo(Clock* clock,
FlexfecSender* flexfec_sender)
: rtp_sender_(rtp_sender),
clock_(clock),
video_type_(kRtpVideoGeneric),
video_type_(kVideoCodecGeneric),
retransmission_settings_(kRetransmitBaseLayer |
kConditionallyRetransmitHigherLayers),
last_rotation_(kVideoRotation_0),
@ -68,11 +68,11 @@ RTPSenderVideo::RTPSenderVideo(Clock* clock,
RTPSenderVideo::~RTPSenderVideo() {}
void RTPSenderVideo::SetVideoCodecType(RtpVideoCodecTypes video_type) {
void RTPSenderVideo::SetVideoCodecType(enum VideoCodecType video_type) {
video_type_ = video_type;
}
RtpVideoCodecTypes RTPSenderVideo::VideoCodecType() const {
VideoCodecType RTPSenderVideo::VideoCodecType() const {
return video_type_;
}
@ -80,19 +80,19 @@ RtpVideoCodecTypes RTPSenderVideo::VideoCodecType() const {
RtpUtility::Payload* RTPSenderVideo::CreateVideoPayload(
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
int8_t payload_type) {
RtpVideoCodecTypes video_type = kRtpVideoGeneric;
enum VideoCodecType video_type = kVideoCodecGeneric;
if (RtpUtility::StringCompare(payload_name, "VP8", 3)) {
video_type = kRtpVideoVp8;
video_type = kVideoCodecVP8;
} else if (RtpUtility::StringCompare(payload_name, "VP9", 3)) {
video_type = kRtpVideoVp9;
video_type = kVideoCodecVP9;
} else if (RtpUtility::StringCompare(payload_name, "H264", 4)) {
video_type = kRtpVideoH264;
video_type = kVideoCodecH264;
} else if (RtpUtility::StringCompare(payload_name, "I420", 4)) {
video_type = kRtpVideoGeneric;
video_type = kVideoCodecGeneric;
} else if (RtpUtility::StringCompare(payload_name, "stereo", 6)) {
video_type = kRtpVideoGeneric;
video_type = kVideoCodecGeneric;
} else {
video_type = kRtpVideoGeneric;
video_type = kVideoCodecGeneric;
}
VideoPayload vp;
vp.videoCodecType = video_type;
@ -286,7 +286,7 @@ rtc::Optional<uint32_t> RTPSenderVideo::FlexfecSsrc() const {
return rtc::nullopt;
}
bool RTPSenderVideo::SendVideo(RtpVideoCodecTypes video_type,
bool RTPSenderVideo::SendVideo(enum VideoCodecType video_type,
FrameType frame_type,
int8_t payload_type,
uint32_t rtp_timestamp,
@ -486,9 +486,9 @@ StorageType RTPSenderVideo::GetStorageType(
uint8_t RTPSenderVideo::GetTemporalId(const RTPVideoHeader& header) {
switch (header.codec) {
case kRtpVideoVp8:
case kVideoCodecVP8:
return header.codecHeader.VP8.temporalIdx;
case kRtpVideoVp9:
case kVideoCodecVP9:
return header.codecHeader.VP9.temporal_idx;
default:
return kNoTemporalIdx;

8
modules/rtp_rtcp/source/rtp_sender_video.h
View File

@ -42,13 +42,13 @@ class RTPSenderVideo {
FlexfecSender* flexfec_sender);
virtual ~RTPSenderVideo();
virtual RtpVideoCodecTypes VideoCodecType() const;
virtual enum VideoCodecType VideoCodecType() const;
static RtpUtility::Payload* CreateVideoPayload(
const char payload_name[RTP_PAYLOAD_NAME_SIZE],
int8_t payload_type);
bool SendVideo(RtpVideoCodecTypes video_type,
bool SendVideo(enum VideoCodecType video_type,
FrameType frame_type,
int8_t payload_type,
uint32_t capture_timestamp,
@ -59,7 +59,7 @@ class RTPSenderVideo {
const RTPVideoHeader* video_header,
int64_t expected_retransmission_time_ms);
void SetVideoCodecType(RtpVideoCodecTypes type);
void SetVideoCodecType(enum VideoCodecType type);
// ULPFEC.
void SetUlpfecConfig(int red_payload_type, int ulpfec_payload_type);
@ -132,7 +132,7 @@ class RTPSenderVideo {
// Should never be held when calling out of this class.
rtc::CriticalSection crit_;
RtpVideoCodecTypes video_type_;
enum VideoCodecType video_type_;
int32_t retransmission_settings_ RTC_GUARDED_BY(crit_);
VideoRotation last_rotation_ RTC_GUARDED_BY(crit_);

14
modules/video_coding/decoding_state_unittest.cc
View File

@ -36,7 +36,7 @@ TEST(TestDecodingState, FrameContinuity) {
packet.timestamp = 1;
packet.seqNum = 0xffff;
packet.frameType = kVideoFrameDelta;
packet.video_header.codec = kRtpVideoVp8;
packet.video_header.codec = kVideoCodecVP8;
packet.video_header.codecHeader.VP8.pictureId = 0x007F;
FrameData frame_data;
frame_data.rtt_ms = 0;
@ -211,7 +211,7 @@ TEST(TestDecodingState, MultiLayerBehavior) {
VCMFrameBuffer frame;
VCMPacket packet;
packet.frameType = kVideoFrameDelta;
packet.video_header.codec = kRtpVideoVp8;
packet.video_header.codec = kVideoCodecVP8;
packet.timestamp = 0;
packet.seqNum = 0;
packet.video_header.codecHeader.VP8.tl0PicIdx = 0;
@ -365,7 +365,7 @@ TEST(TestDecodingState, DiscontinuousPicIdContinuousSeqNum) {
VCMPacket packet;
frame.Reset();
packet.frameType = kVideoFrameKey;
packet.video_header.codec = kRtpVideoVp8;
packet.video_header.codec = kVideoCodecVP8;
packet.timestamp = 0;
packet.seqNum = 0;
packet.video_header.codecHeader.VP8.tl0PicIdx = 0;
@ -418,7 +418,7 @@ TEST(TestDecodingState, PictureIdRepeat) {
VCMFrameBuffer frame;
VCMPacket packet;
packet.frameType = kVideoFrameDelta;
packet.video_header.codec = kRtpVideoVp8;
packet.video_header.codec = kVideoCodecVP8;
packet.timestamp = 0;
packet.seqNum = 0;
packet.video_header.codecHeader.VP8.tl0PicIdx = 0;
@ -456,7 +456,7 @@ TEST(TestDecodingState, FrameContinuityFlexibleModeKeyFrame) {
uint8_t data[] = "I need a data pointer for this test!";
packet.sizeBytes = sizeof(data);
packet.dataPtr = data;
packet.video_header.codec = kRtpVideoVp9;
packet.video_header.codec = kVideoCodecVP9;
RTPVideoHeaderVP9& vp9_hdr = packet.video_header.codecHeader.VP9;
vp9_hdr.picture_id = 10;
@ -499,7 +499,7 @@ TEST(TestDecodingState, FrameContinuityFlexibleModeOutOfOrderFrames) {
uint8_t data[] = "I need a data pointer for this test!";
packet.sizeBytes = sizeof(data);
packet.dataPtr = data;
packet.video_header.codec = kRtpVideoVp9;
packet.video_header.codec = kVideoCodecVP9;
RTPVideoHeaderVP9& vp9_hdr = packet.video_header.codecHeader.VP9;
vp9_hdr.picture_id = 10;
@ -554,7 +554,7 @@ TEST(TestDecodingState, FrameContinuityFlexibleModeGeneral) {
uint8_t data[] = "I need a data pointer for this test!";
packet.sizeBytes = sizeof(data);
packet.dataPtr = data;
packet.video_header.codec = kRtpVideoVp9;
packet.video_header.codec = kVideoCodecVP9;
RTPVideoHeaderVP9& vp9_hdr = packet.video_header.codecHeader.VP9;
vp9_hdr.picture_id = 10;

9
modules/video_coding/encoded_frame.cc
View File

@ -92,7 +92,7 @@ void VCMEncodedFrame::Reset() {
void VCMEncodedFrame::CopyCodecSpecific(const RTPVideoHeader* header) {
if (header) {
switch (header->codec) {
case kRtpVideoVp8: {
case kVideoCodecVP8: {
if (_codecSpecificInfo.codecType != kVideoCodecVP8) {
// This is the first packet for this frame.
_codecSpecificInfo.codecSpecific.VP8.pictureId = -1;
@ -119,7 +119,7 @@ void VCMEncodedFrame::CopyCodecSpecific(const RTPVideoHeader* header) {
}
break;
}
case kRtpVideoVp9: {
case kVideoCodecVP9: {
if (_codecSpecificInfo.codecType != kVideoCodecVP9) {
// This is the first packet for this frame.
_codecSpecificInfo.codecSpecific.VP9.picture_id = -1;
@ -186,12 +186,11 @@ void VCMEncodedFrame::CopyCodecSpecific(const RTPVideoHeader* header) {
}
break;
}
case kRtpVideoH264: {
case kVideoCodecH264: {
_codecSpecificInfo.codecType = kVideoCodecH264;
break;
}
case kRtpVideoNone:
case kRtpVideoGeneric: {
default: {
_codecSpecificInfo.codecType = kVideoCodecUnknown;
break;
}

19
modules/video_coding/jitter_buffer_unittest.cc
View File

@ -49,7 +49,7 @@ class Vp9SsMapTest : public ::testing::Test {
packet_.markerBit = true;
packet_.frameType = kVideoFrameKey;
packet_.codec = kVideoCodecVP9;
packet_.video_header.codec = kRtpVideoVp9;
packet_.video_header.codec = kVideoCodecVP9;
packet_.video_header.codecHeader.VP9.flexible_mode = false;
packet_.video_header.codecHeader.VP9.gof_idx = 0;
packet_.video_header.codecHeader.VP9.temporal_idx = kNoTemporalIdx;
@ -243,6 +243,7 @@ class TestBasicJitterBuffer : public ::testing::TestWithParam<std::string>,
rtpHeader.header.timestamp = timestamp_;
rtpHeader.header.markerBit = true;
rtpHeader.frameType = kVideoFrameDelta;
rtpHeader.type.Video.codec = kVideoCodecUnknown;
packet_.reset(new VCMPacket(data_, size_, rtpHeader));
}
@ -800,6 +801,7 @@ TEST_F(TestBasicJitterBuffer, TestReorderingWithPadding) {
rtpHeader.header.sequenceNumber = seq_num_ + 2;
rtpHeader.header.timestamp = timestamp_ + (33 * 90);
rtpHeader.header.markerBit = false;
rtpHeader.type.Video.codec = kVideoCodecUnknown;
VCMPacket empty_packet(data_, 0, rtpHeader);
EXPECT_EQ(kOldPacket,
jitter_buffer_->InsertPacket(empty_packet, &retransmitted));
@ -920,7 +922,7 @@ TEST_F(TestBasicJitterBuffer, TestSkipForwardVp9) {
bool re = false;
packet_->codec = kVideoCodecVP9;
packet_->video_header.codec = kRtpVideoVp9;
packet_->video_header.codec = kVideoCodecVP9;
packet_->is_first_packet_in_frame = true;
packet_->markerBit = true;
packet_->video_header.codecHeader.VP9.flexible_mode = false;
@ -973,7 +975,7 @@ TEST_F(TestBasicJitterBuffer, ReorderedVp9SsData_3TlLayers) {
bool re = false;
packet_->codec = kVideoCodecVP9;
packet_->video_header.codec = kRtpVideoVp9;
packet_->video_header.codec = kVideoCodecVP9;
packet_->is_first_packet_in_frame = true;
packet_->markerBit = true;
packet_->video_header.codecHeader.VP9.flexible_mode = false;
@ -1049,7 +1051,7 @@ TEST_F(TestBasicJitterBuffer, ReorderedVp9SsData_2Tl2SLayers) {
bool re = false;
packet_->codec = kVideoCodecVP9;
packet_->video_header.codec = kRtpVideoVp9;
packet_->video_header.codec = kVideoCodecVP9;
packet_->video_header.codecHeader.VP9.flexible_mode = false;
packet_->video_header.codecHeader.VP9.beginning_of_frame = true;
packet_->video_header.codecHeader.VP9.end_of_frame = true;
@ -1158,7 +1160,7 @@ TEST_F(TestBasicJitterBuffer, SpsAndPpsHandling) {
packet_->is_first_packet_in_frame = true;
packet_->markerBit = true;
packet_->codec = kVideoCodecH264;
packet_->video_header.codec = kRtpVideoH264;
packet_->video_header.codec = kVideoCodecH264;
packet_->video_header.codecHeader.H264.nalu_type = H264::NaluType::kIdr;
packet_->video_header.codecHeader.H264.nalus[0].type = H264::NaluType::kIdr;
packet_->video_header.codecHeader.H264.nalus[0].sps_id = -1;
@ -1178,7 +1180,7 @@ TEST_F(TestBasicJitterBuffer, SpsAndPpsHandling) {
packet_->is_first_packet_in_frame = true;
packet_->markerBit = false;
packet_->codec = kVideoCodecH264;
packet_->video_header.codec = kRtpVideoH264;
packet_->video_header.codec = kVideoCodecH264;
packet_->video_header.codecHeader.H264.nalu_type = H264::NaluType::kStapA;
packet_->video_header.codecHeader.H264.nalus[0].type = H264::NaluType::kSps;
packet_->video_header.codecHeader.H264.nalus[0].sps_id = 0;
@ -1197,7 +1199,7 @@ TEST_F(TestBasicJitterBuffer, SpsAndPpsHandling) {
packet_->is_first_packet_in_frame = false;
packet_->markerBit = true;
packet_->codec = kVideoCodecH264;
packet_->video_header.codec = kRtpVideoH264;
packet_->video_header.codec = kVideoCodecH264;
packet_->video_header.codecHeader.H264.nalu_type = H264::NaluType::kIdr;
packet_->video_header.codecHeader.H264.nalus[0].type = H264::NaluType::kIdr;
packet_->video_header.codecHeader.H264.nalus[0].sps_id = -1;
@ -1219,7 +1221,7 @@ TEST_F(TestBasicJitterBuffer, SpsAndPpsHandling) {
packet_->is_first_packet_in_frame = true;
packet_->markerBit = true;
packet_->codec = kVideoCodecH264;
packet_->video_header.codec = kRtpVideoH264;
packet_->video_header.codec = kVideoCodecH264;
packet_->video_header.codecHeader.H264.nalu_type = H264::NaluType::kSlice;
packet_->video_header.codecHeader.H264.nalus[0].type = H264::NaluType::kSlice;
packet_->video_header.codecHeader.H264.nalus[0].sps_id = -1;
@ -2163,6 +2165,7 @@ TEST_F(TestBasicJitterBuffer, H264IncompleteNalu) {
timestamp_ += 33 * 90;
WebRtcRTPHeader rtpHeader;
memset(&rtpHeader, 0, sizeof(rtpHeader));
rtpHeader.type.Video.codec = kVideoCodecUnknown;
VCMPacket emptypacket(data_, 0, rtpHeader);
emptypacket.seqNum = seq_num_;
emptypacket.timestamp = timestamp_;

15
modules/video_coding/packet.cc
View File

@ -89,8 +89,9 @@ void VCMPacket::Reset() {
}
void VCMPacket::CopyCodecSpecifics(const RTPVideoHeader& videoHeader) {
codec = videoHeader.codec;
switch (videoHeader.codec) {
case kRtpVideoVp8:
case kVideoCodecVP8:
// Handle all packets within a frame as depending on the previous packet
// TODO(holmer): This should be changed to make fragments independent
// when the VP8 RTP receiver supports fragments.
@ -103,9 +104,8 @@ void VCMPacket::CopyCodecSpecifics(const RTPVideoHeader& videoHeader) {
else
completeNALU = kNaluIncomplete;
codec = kVideoCodecVP8;
return;
case kRtpVideoVp9:
case kVideoCodecVP9:
if (is_first_packet_in_frame && markerBit)
completeNALU = kNaluComplete;
else if (is_first_packet_in_frame)
@ -115,9 +115,8 @@ void VCMPacket::CopyCodecSpecifics(const RTPVideoHeader& videoHeader) {
else
completeNALU = kNaluIncomplete;
codec = kVideoCodecVP9;
return;
case kRtpVideoH264:
case kVideoCodecH264:
is_first_packet_in_frame = videoHeader.is_first_packet_in_frame;
if (is_first_packet_in_frame)
insertStartCode = true;
@ -131,12 +130,10 @@ void VCMPacket::CopyCodecSpecifics(const RTPVideoHeader& videoHeader) {
} else {
completeNALU = kNaluIncomplete;
}
codec = kVideoCodecH264;
return;
case kRtpVideoGeneric:
codec = kVideoCodecGeneric;
case kVideoCodecGeneric:
return;
case kRtpVideoNone:
default:
codec = kVideoCodecUnknown;
return;
}

26
modules/video_coding/session_info.cc
View File

@ -60,9 +60,9 @@ int VCMSessionInfo::HighSequenceNumber() const {
int VCMSessionInfo::PictureId() const {
if (packets_.empty())
return kNoPictureId;
if (packets_.front().video_header.codec == kRtpVideoVp8) {
if (packets_.front().video_header.codec == kVideoCodecVP8) {
return packets_.front().video_header.codecHeader.VP8.pictureId;
} else if (packets_.front().video_header.codec == kRtpVideoVp9) {
} else if (packets_.front().video_header.codec == kVideoCodecVP9) {
return packets_.front().video_header.codecHeader.VP9.picture_id;
} else {
return kNoPictureId;
@ -72,9 +72,9 @@ int VCMSessionInfo::PictureId() const {
int VCMSessionInfo::TemporalId() const {
if (packets_.empty())
return kNoTemporalIdx;
if (packets_.front().video_header.codec == kRtpVideoVp8) {
if (packets_.front().video_header.codec == kVideoCodecVP8) {
return packets_.front().video_header.codecHeader.VP8.temporalIdx;
} else if (packets_.front().video_header.codec == kRtpVideoVp9) {
} else if (packets_.front().video_header.codec == kVideoCodecVP9) {
return packets_.front().video_header.codecHeader.VP9.temporal_idx;
} else {
return kNoTemporalIdx;
@ -84,9 +84,9 @@ int VCMSessionInfo::TemporalId() const {
bool VCMSessionInfo::LayerSync() const {
if (packets_.empty())
return false;
if (packets_.front().video_header.codec == kRtpVideoVp8) {
if (packets_.front().video_header.codec == kVideoCodecVP8) {
return packets_.front().video_header.codecHeader.VP8.layerSync;
} else if (packets_.front().video_header.codec == kRtpVideoVp9) {
} else if (packets_.front().video_header.codec == kVideoCodecVP9) {
return packets_.front().video_header.codecHeader.VP9.temporal_up_switch;
} else {
return false;
@ -96,9 +96,9 @@ bool VCMSessionInfo::LayerSync() const {
int VCMSessionInfo::Tl0PicId() const {
if (packets_.empty())
return kNoTl0PicIdx;
if (packets_.front().video_header.codec == kRtpVideoVp8) {
if (packets_.front().video_header.codec == kVideoCodecVP8) {
return packets_.front().video_header.codecHeader.VP8.tl0PicIdx;
} else if (packets_.front().video_header.codec == kRtpVideoVp9) {
} else if (packets_.front().video_header.codec == kVideoCodecVP9) {
return packets_.front().video_header.codecHeader.VP9.tl0_pic_idx;
} else {
return kNoTl0PicIdx;
@ -106,13 +106,14 @@ int VCMSessionInfo::Tl0PicId() const {
}
bool VCMSessionInfo::NonReference() const {
if (packets_.empty() || packets_.front().video_header.codec != kRtpVideoVp8)
if (packets_.empty() || packets_.front().video_header.codec != kVideoCodecVP8)
return false;
return packets_.front().video_header.codecHeader.VP8.nonReference;
}
std::vector<NaluInfo> VCMSessionInfo::GetNaluInfos() const {
if (packets_.empty() || packets_.front().video_header.codec != kRtpVideoH264)
if (packets_.empty() ||
packets_.front().video_header.codec != kVideoCodecH264)
return std::vector<NaluInfo>();
std::vector<NaluInfo> nalu_infos;
for (const VCMPacket& packet : packets_) {
@ -125,7 +126,8 @@ std::vector<NaluInfo> VCMSessionInfo::GetNaluInfos() const {
}
void VCMSessionInfo::SetGofInfo(const GofInfoVP9& gof_info, size_t idx) {
if (packets_.empty() || packets_.front().video_header.codec != kRtpVideoVp9 ||
if (packets_.empty() ||
packets_.front().video_header.codec != kVideoCodecVP9 ||
packets_.front().video_header.codecHeader.VP9.flexible_mode) {
return;
}
@ -185,7 +187,7 @@ 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 == kRtpVideoH264 &&
if (packet.video_header.codec == kVideoCodecH264 &&
packet.video_header.codecHeader.H264.packetization_type == kH264StapA) {
size_t required_length = 0;
const uint8_t* nalu_ptr = packet_buffer + kH264NALHeaderLengthInBytes;

1
modules/video_coding/utility/simulcast_rate_allocator_unittest.cc
View File

@ -48,6 +48,7 @@ class SimulcastRateAllocatorTest : public ::testing::TestWithParam<bool> {
public:
SimulcastRateAllocatorTest() {
memset(&codec_, 0, sizeof(VideoCodec));
codec_.codecType = kVideoCodecVP8;
codec_.minBitrate = kMinBitrateKbps;
codec_.targetBitrate = kTargetBitrateKbps;
codec_.maxBitrate = kMaxBitrateKbps;

6
modules/video_coding/video_receiver_unittest.cc
View File

@ -106,7 +106,7 @@ TEST_F(TestVideoReceiver, PaddingOnlyFrames) {
header.header.payloadType = kUnusedPayloadType;
header.header.ssrc = 1;
header.header.headerLength = 12;
header.type.Video.codec = kRtpVideoVp8;
header.type.Video.codec = kVideoCodecVP8;
for (int i = 0; i < 10; ++i) {
EXPECT_CALL(packet_request_callback_, ResendPackets(_, _)).Times(0);
InsertAndVerifyPaddingFrame(payload, &header);
@ -130,7 +130,7 @@ TEST_F(TestVideoReceiver, PaddingOnlyFramesWithLosses) {
header.header.payloadType = kUnusedPayloadType;
header.header.ssrc = 1;
header.header.headerLength = 12;
header.type.Video.codec = kRtpVideoVp8;
header.type.Video.codec = kVideoCodecVP8;
// Insert one video frame to get one frame decoded.
header.frameType = kVideoFrameKey;
header.type.Video.is_first_packet_in_frame = true;
@ -182,7 +182,7 @@ TEST_F(TestVideoReceiver, PaddingOnlyAndVideo) {
header.header.payloadType = kUnusedPayloadType;
header.header.ssrc = 1;
header.header.headerLength = 12;
header.type.Video.codec = kRtpVideoVp8;
header.type.Video.codec = kVideoCodecVP8;
header.type.Video.codecHeader.VP8.pictureId = -1;
header.type.Video.codecHeader.VP8.tl0PicIdx = -1;
for (int i = 0; i < 3; ++i) {

1
sdk/android/api/org/webrtc/MediaCodecVideoDecoder.java
View File

@ -55,6 +55,7 @@ public class MediaCodecVideoDecoder {
// Tracks webrtc::VideoCodecType.
public enum VideoCodecType {
VIDEO_CODEC_UNKNOWN,
VIDEO_CODEC_VP8,
VIDEO_CODEC_VP9,
VIDEO_CODEC_H264;

3
sdk/android/api/org/webrtc/MediaCodecVideoEncoder.java
View File

@ -47,6 +47,7 @@ public class MediaCodecVideoEncoder {
// Tracks webrtc::VideoCodecType.
public enum VideoCodecType {
VIDEO_CODEC_UNKNOWN,
VIDEO_CODEC_VP8,
VIDEO_CODEC_VP9,
VIDEO_CODEC_H264;
@ -486,6 +487,8 @@ public class MediaCodecVideoEncoder {
}
}
keyFrameIntervalSec = 20;
} else {
throw new RuntimeException("initEncode: Non-supported codec " + type);
}
if (properties == null) {
throw new RuntimeException("Can not find HW encoder for " + type);

2
test/layer_filtering_transport.cc
View File

@ -132,7 +132,7 @@ bool LayerFilteringTransport::SendRtp(const uint8_t* packet,
const bool is_vp8 = header.payloadType == vp8_video_payload_type_;
std::unique_ptr<RtpDepacketizer> depacketizer(
RtpDepacketizer::Create(is_vp8 ? kRtpVideoVp8 : kRtpVideoVp9));
RtpDepacketizer::Create(is_vp8 ? kVideoCodecVP8 : kVideoCodecVP9));
RtpDepacketizer::ParsedPayload parsed_payload;
if (depacketizer->Parse(&parsed_payload, payload, payload_data_length)) {
const int temporal_idx = static_cast<int>(

10
video/payload_router.cc
View File

@ -23,9 +23,9 @@ namespace {
// Map information from info into rtp.
void CopyCodecSpecific(const CodecSpecificInfo* info, RTPVideoHeader* rtp) {
RTC_DCHECK(info);
rtp->codec = info->codecType;
switch (info->codecType) {
case kVideoCodecVP8: {
rtp->codec = kRtpVideoVp8;
rtp->codecHeader.VP8.InitRTPVideoHeaderVP8();
rtp->codecHeader.VP8.nonReference = info->codecSpecific.VP8.nonReference;
rtp->codecHeader.VP8.temporalIdx = info->codecSpecific.VP8.temporalIdx;
@ -35,7 +35,6 @@ void CopyCodecSpecific(const CodecSpecificInfo* info, RTPVideoHeader* rtp) {
return;
}
case kVideoCodecVP9: {
rtp->codec = kRtpVideoVp9;
rtp->codecHeader.VP9.InitRTPVideoHeaderVP9();
rtp->codecHeader.VP9.inter_pic_predicted =
info->codecSpecific.VP9.inter_pic_predicted;
@ -77,13 +76,12 @@ void CopyCodecSpecific(const CodecSpecificInfo* info, RTPVideoHeader* rtp) {
return;
}
case kVideoCodecH264:
rtp->codec = kRtpVideoH264;
rtp->codecHeader.H264.packetization_mode =
info->codecSpecific.H264.packetization_mode;
return;
case kVideoCodecMultiplex:
case kVideoCodecGeneric:
rtp->codec = kRtpVideoGeneric;
rtp->codec = kVideoCodecGeneric;
rtp->simulcastIdx = info->codecSpecific.generic.simulcast_idx;
return;
default:
@ -112,7 +110,7 @@ class PayloadRouter::RtpPayloadParams final {
state_.picture_id =
(static_cast<uint16_t>(state_.picture_id) + 1) & 0x7FFF;
}
if (rtp_video_header->codec == kRtpVideoVp8) {
if (rtp_video_header->codec == kVideoCodecVP8) {
rtp_video_header->codecHeader.VP8.pictureId = state_.picture_id;
if (rtp_video_header->codecHeader.VP8.temporalIdx != kNoTemporalIdx) {
@ -122,7 +120,7 @@ class PayloadRouter::RtpPayloadParams final {
rtp_video_header->codecHeader.VP8.tl0PicIdx = state_.tl0_pic_idx;
}
}
if (rtp_video_header->codec == kRtpVideoVp9) {
if (rtp_video_header->codec == kVideoCodecVP9) {
rtp_video_header->codecHeader.VP9.picture_id = state_.picture_id;
// Note that in the case that we have no temporal layers but we do have

24
video/payload_router_unittest.cc
View File

@ -336,7 +336,7 @@ TEST(PayloadRouterTest, InfoMappedToRtpVideoHeader_Vp8) {
EXPECT_EQ(kVideoRotation_90, header->rotation);
EXPECT_EQ(VideoContentType::SCREENSHARE, header->content_type);
EXPECT_EQ(1, header->simulcastIdx);
EXPECT_EQ(kRtpVideoVp8, header->codec);
EXPECT_EQ(kVideoCodecVP8, header->codec);
EXPECT_EQ(kPictureId + 1, header->codecHeader.VP8.pictureId);
EXPECT_EQ(kTemporalIdx, header->codecHeader.VP8.temporalIdx);
EXPECT_EQ(kTl0PicIdx, header->codecHeader.VP8.tl0PicIdx);
@ -381,7 +381,7 @@ TEST(PayloadRouterTest, InfoMappedToRtpVideoHeader_Vp9) {
Unused, const RTPVideoHeader* header, Unused) {
EXPECT_EQ(kVideoRotation_90, header->rotation);
EXPECT_EQ(VideoContentType::SCREENSHARE, header->content_type);
EXPECT_EQ(kRtpVideoVp9, header->codec);
EXPECT_EQ(kVideoCodecVP9, header->codec);
EXPECT_EQ(kPictureId + 1, header->codecHeader.VP9.picture_id);
EXPECT_EQ(kTl0PicIdx, header->codecHeader.VP9.tl0_pic_idx);
EXPECT_EQ(header->codecHeader.VP9.temporal_idx,
@ -410,7 +410,7 @@ TEST(PayloadRouterTest, InfoMappedToRtpVideoHeader_Vp9) {
Unused, const RTPVideoHeader* header, Unused) {
EXPECT_EQ(kVideoRotation_90, header->rotation);
EXPECT_EQ(VideoContentType::SCREENSHARE, header->content_type);
EXPECT_EQ(kRtpVideoVp9, header->codec);
EXPECT_EQ(kVideoCodecVP9, header->codec);
EXPECT_EQ(kPictureId + 1, header->codecHeader.VP9.picture_id);
EXPECT_EQ(kTl0PicIdx, header->codecHeader.VP9.tl0_pic_idx);
EXPECT_EQ(header->codecHeader.VP9.temporal_idx,
@ -447,7 +447,7 @@ TEST(PayloadRouterTest, InfoMappedToRtpVideoHeader_H264) {
.WillOnce(Invoke([](Unused, Unused, Unused, Unused, Unused, Unused,
Unused, const RTPVideoHeader* header, Unused) {
EXPECT_EQ(0, header->simulcastIdx);
EXPECT_EQ(kRtpVideoH264, header->codec);
EXPECT_EQ(kVideoCodecH264, header->codec);
EXPECT_EQ(H264PacketizationMode::SingleNalUnit,
header->codecHeader.H264.packetization_mode);
return true;
@ -524,7 +524,7 @@ TEST(PayloadRouterTest, PictureIdIsSetForVp8) {
EXPECT_CALL(rtp1, SendOutgoingData(_, _, _, _, _, _, nullptr, _, _))
.WillOnce(Invoke([](Unused, Unused, Unused, Unused, Unused, Unused,
Unused, const RTPVideoHeader* header, Unused) {
EXPECT_EQ(kRtpVideoVp8, header->codec);
EXPECT_EQ(kVideoCodecVP8, header->codec);
EXPECT_EQ(kInitialPictureId1 + 1, header->codecHeader.VP8.pictureId);
return true;
}));
@ -539,7 +539,7 @@ TEST(PayloadRouterTest, PictureIdIsSetForVp8) {
EXPECT_CALL(rtp2, SendOutgoingData(_, _, _, _, _, _, nullptr, _, _))
.WillOnce(Invoke([](Unused, Unused, Unused, Unused, Unused, Unused,
Unused, const RTPVideoHeader* header, Unused) {
EXPECT_EQ(kRtpVideoVp8, header->codec);
EXPECT_EQ(kVideoCodecVP8, header->codec);
EXPECT_EQ(kInitialPictureId2 + 1, header->codecHeader.VP8.pictureId);
return true;
}));
@ -576,7 +576,7 @@ TEST(PayloadRouterTest, PictureIdWraps) {
EXPECT_CALL(rtp, SendOutgoingData(_, _, _, _, _, _, nullptr, _, _))
.WillOnce(Invoke([](Unused, Unused, Unused, Unused, Unused, Unused,
Unused, const RTPVideoHeader* header, Unused) {
EXPECT_EQ(kRtpVideoVp8, header->codec);
EXPECT_EQ(kVideoCodecVP8, header->codec);
EXPECT_EQ(0, header->codecHeader.VP8.pictureId);
return true;
}));
@ -614,7 +614,7 @@ TEST(PayloadRouterTest, Tl0PicIdxUpdatedForVp8) {
EXPECT_CALL(rtp, SendOutgoingData(_, _, _, _, _, _, nullptr, _, _))
.WillOnce(Invoke([](Unused, Unused, Unused, Unused, Unused, Unused,
Unused, const RTPVideoHeader* header, Unused) {
EXPECT_EQ(kRtpVideoVp8, header->codec);
EXPECT_EQ(kVideoCodecVP8, header->codec);
EXPECT_EQ(kInitialPictureId1 + 1, header->codecHeader.VP8.pictureId);
EXPECT_EQ(kInitialTl0PicIdx1, header->codecHeader.VP8.tl0PicIdx);
return true;
@ -630,7 +630,7 @@ TEST(PayloadRouterTest, Tl0PicIdxUpdatedForVp8) {
EXPECT_CALL(rtp, SendOutgoingData(_, _, _, _, _, _, nullptr, _, _))
.WillOnce(Invoke([](Unused, Unused, Unused, Unused, Unused, Unused,
Unused, const RTPVideoHeader* header, Unused) {
EXPECT_EQ(kRtpVideoVp8, header->codec);
EXPECT_EQ(kVideoCodecVP8, header->codec);
EXPECT_EQ(kInitialPictureId1 + 2, header->codecHeader.VP8.pictureId);
EXPECT_EQ(kInitialTl0PicIdx1 + 1, header->codecHeader.VP8.tl0PicIdx);
return true;
@ -670,7 +670,7 @@ TEST(PayloadRouterTest, Tl0PicIdxUpdatedForVp9) {
EXPECT_CALL(rtp, SendOutgoingData(_, _, _, _, _, _, nullptr, _, _))
.WillOnce(Invoke([](Unused, Unused, Unused, Unused, Unused, Unused,
Unused, const RTPVideoHeader* header, Unused) {
EXPECT_EQ(kRtpVideoVp9, header->codec);
EXPECT_EQ(kVideoCodecVP9, header->codec);
EXPECT_EQ(kInitialPictureId1 + 1, header->codecHeader.VP9.picture_id);
EXPECT_EQ(kInitialTl0PicIdx1, header->codecHeader.VP9.tl0_pic_idx);
return true;
@ -686,7 +686,7 @@ TEST(PayloadRouterTest, Tl0PicIdxUpdatedForVp9) {
EXPECT_CALL(rtp, SendOutgoingData(_, _, _, _, _, _, nullptr, _, _))
.WillOnce(Invoke([](Unused, Unused, Unused, Unused, Unused, Unused,
Unused, const RTPVideoHeader* header, Unused) {
EXPECT_EQ(kRtpVideoVp9, header->codec);
EXPECT_EQ(kVideoCodecVP9, header->codec);
EXPECT_EQ(kInitialPictureId1 + 2, header->codecHeader.VP9.picture_id);
EXPECT_EQ(kInitialTl0PicIdx1 + 1, header->codecHeader.VP9.tl0_pic_idx);
return true;
@ -702,7 +702,7 @@ TEST(PayloadRouterTest, Tl0PicIdxUpdatedForVp9) {
EXPECT_CALL(rtp, SendOutgoingData(_, _, _, _, _, _, nullptr, _, _))
.WillOnce(Invoke([](Unused, Unused, Unused, Unused, Unused, Unused,
Unused, const RTPVideoHeader* header, Unused) {
EXPECT_EQ(kRtpVideoVp9, header->codec);
EXPECT_EQ(kVideoCodecVP9, header->codec);
EXPECT_EQ(kInitialPictureId1 + 2, header->codecHeader.VP9.picture_id);
EXPECT_EQ(kInitialTl0PicIdx1 + 1, header->codecHeader.VP9.tl0_pic_idx);
return true;

21
video/picture_id_tests.cc
View File

@ -28,22 +28,11 @@ const int kEncoderBitrateBps = 300000;
const uint32_t kPictureIdWraparound = (1 << 15);
const size_t kNumTemporalLayers[] = {1, 2, 3};
RtpVideoCodecTypes PayloadNameToRtpVideoCodecType(
const std::string& payload_name) {
if (payload_name == "VP8") {
return kRtpVideoVp8;
} else if (payload_name == "VP9") {
return kRtpVideoVp9;
} else {
RTC_NOTREACHED();
return kRtpVideoNone;
}
}
} // namespace
class PictureIdObserver : public test::RtpRtcpObserver {
public:
explicit PictureIdObserver(RtpVideoCodecTypes codec_type)
explicit PictureIdObserver(VideoCodecType codec_type)
: test::RtpRtcpObserver(test::CallTest::kDefaultTimeoutMs),
codec_type_(codec_type),
max_expected_picture_id_gap_(0),
@ -106,7 +95,7 @@ class PictureIdObserver : public test::RtpRtcpObserver {
&parsed_payload, &packet[header.headerLength], payload_length));
switch (codec_type_) {
case kRtpVideoVp8:
case kVideoCodecVP8:
parsed->picture_id =
parsed_payload.type.Video.codecHeader.VP8.pictureId;
parsed->tl0_pic_idx =
@ -114,7 +103,7 @@ class PictureIdObserver : public test::RtpRtcpObserver {
parsed->temporal_idx =
parsed_payload.type.Video.codecHeader.VP8.temporalIdx;
break;
case kRtpVideoVp9:
case kVideoCodecVP9:
parsed->picture_id =
parsed_payload.type.Video.codecHeader.VP9.picture_id;
parsed->tl0_pic_idx =
@ -211,7 +200,7 @@ class PictureIdObserver : public test::RtpRtcpObserver {
}
rtc::CriticalSection crit_;
const RtpVideoCodecTypes codec_type_;
const VideoCodecType codec_type_;
std::map<uint32_t, ParsedPacket> last_observed_packet_ RTC_GUARDED_BY(crit_);
std::map<uint32_t, size_t> num_packets_sent_ RTC_GUARDED_BY(crit_);
int max_expected_picture_id_gap_ RTC_GUARDED_BY(crit_);
@ -297,7 +286,7 @@ class VideoStreamFactory
void PictureIdTest::SetupEncoder(VideoEncoderFactory* encoder_factory,
const std::string& payload_name) {
observer_.reset(
new PictureIdObserver(PayloadNameToRtpVideoCodecType(payload_name)));
new PictureIdObserver(PayloadStringToCodecType(payload_name)));
task_queue_.SendTask([this, encoder_factory, payload_name]() {
Call::Config config(event_log_.get());

12
video/rtp_video_stream_receiver_unittest.cc
View File

@ -136,7 +136,7 @@ class RtpVideoStreamReceiverTest : public testing::Test {
WebRtcRTPHeader GetDefaultPacket() {
WebRtcRTPHeader packet;
memset(&packet, 0, sizeof(packet));
packet.type.Video.codec = kRtpVideoH264;
packet.type.Video.codec = kVideoCodecH264;
return packet;
}
@ -206,7 +206,7 @@ TEST_F(RtpVideoStreamReceiverTest, GenericKeyFrame) {
rtp_header.header.markerBit = 1;
rtp_header.type.Video.is_first_packet_in_frame = true;
rtp_header.frameType = kVideoFrameKey;
rtp_header.type.Video.codec = kRtpVideoGeneric;
rtp_header.type.Video.codec = kVideoCodecGeneric;
mock_on_complete_frame_callback_.AppendExpectedBitstream(data.data(),
data.size());
EXPECT_CALL(mock_on_complete_frame_callback_, DoOnCompleteFrame(_));
@ -240,7 +240,7 @@ TEST_F(RtpVideoStreamReceiverTest, GenericKeyFrameBitstreamError) {
rtp_header.header.markerBit = 1;
rtp_header.type.Video.is_first_packet_in_frame = true;
rtp_header.frameType = kVideoFrameKey;
rtp_header.type.Video.codec = kRtpVideoGeneric;
rtp_header.type.Video.codec = kVideoCodecGeneric;
constexpr uint8_t expected_bitsteam[] = {1, 2, 3, 0xff};
mock_on_complete_frame_callback_.AppendExpectedBitstream(
expected_bitsteam, sizeof(expected_bitsteam));
@ -335,7 +335,7 @@ TEST_P(RtpVideoStreamReceiverTestH264, OutOfBandFmtpSpsPps) {
idr_packet.header.markerBit = 1;
idr_packet.type.Video.is_first_packet_in_frame = true;
idr_packet.frameType = kVideoFrameKey;
idr_packet.type.Video.codec = kRtpVideoH264;
idr_packet.type.Video.codec = kVideoCodecH264;
data.insert(data.end(), {1, 2, 3});
mock_on_complete_frame_callback_.AppendExpectedBitstream(
kH264StartCode, sizeof(kH264StartCode));
@ -355,7 +355,7 @@ TEST_F(RtpVideoStreamReceiverTest, PaddingInMediaStream) {
header.header.sequenceNumber = 2;
header.header.markerBit = true;
header.frameType = kVideoFrameKey;
header.type.Video.codec = kRtpVideoGeneric;
header.type.Video.codec = kVideoCodecGeneric;
mock_on_complete_frame_callback_.AppendExpectedBitstream(data.data(),
data.size());
@ -389,7 +389,7 @@ TEST_F(RtpVideoStreamReceiverTest, RequestKeyframeIfFirstFrameIsDelta) {
rtp_header.header.markerBit = 1;
rtp_header.type.Video.is_first_packet_in_frame = true;
rtp_header.frameType = kVideoFrameDelta;
rtp_header.type.Video.codec = kRtpVideoGeneric;
rtp_header.type.Video.codec = kVideoCodecGeneric;
EXPECT_CALL(mock_key_frame_request_sender_, RequestKeyFrame());
rtp_video_stream_receiver_->OnReceivedPayloadData(data.data(), data.size(),

2
video/video_quality_test.cc
View File

@ -570,7 +570,7 @@ class VideoAnalyzer : public PacketReceiver,
const size_t payload_data_length = payload_length - header.paddingLength;
const bool is_vp8 = header.payloadType == test::CallTest::kPayloadTypeVP8;
std::unique_ptr<RtpDepacketizer> depacketizer(
RtpDepacketizer::Create(is_vp8 ? kRtpVideoVp8 : kRtpVideoVp9));
RtpDepacketizer::Create(is_vp8 ? kVideoCodecVP8 : kVideoCodecVP9));
RtpDepacketizer::ParsedPayload parsed_payload;
bool result =
depacketizer->Parse(&parsed_payload, payload, payload_data_length);

2
video/video_send_stream_tests.cc
View File

@ -3177,7 +3177,7 @@ class Vp9HeaderObserver : public test::SendTest {
RtpDepacketizer::ParsedPayload parsed;
RtpDepacketizerVp9 depacketizer;
EXPECT_TRUE(depacketizer.Parse(&parsed, payload, payload_length));
EXPECT_EQ(RtpVideoCodecTypes::kRtpVideoVp9, parsed.type.Video.codec);
EXPECT_EQ(VideoCodecType::kVideoCodecVP9, parsed.type.Video.codec);
// Verify common fields for all configurations.
VerifyCommonHeader(parsed.type.Video.codecHeader.VP9);
CompareConsecutiveFrames(header, parsed.type.Video);