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

Deprecate cricket::VideoCodec and cricket::AudioCodec

Browse source 
These are aliases for cricket::Codec.
Also remove internal usage

Bug: b/42225532
Change-Id: I220b95260dc942368cb6280432a058159eec8700
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/349321
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Florent Castelli <orphis@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#42194}
This commit is contained in:
Harald Alvestrand 2024-04-29 10:15:34 +00:00 committed by WebRTC LUCI CQ
parent 64437e8cc0
commit d78e30e00b
30 changed files with 546 additions and 588 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
media/base/codec.h
View file

@ -200,11 +200,12 @@ struct RTC_EXPORT Codec {
};
// TODO(webrtc:15214): Compatibility names, to be migrated away and removed.
using VideoCodec = Codec;
using AudioCodec = Codec;
using VideoCodec [[deprecated]] = Codec;
using AudioCodec [[deprecated]] = Codec;
using VideoCodecs = std::vector<Codec>;
using AudioCodecs = std::vector<Codec>;
using VideoCodecs [[deprecated]] = std::vector<Codec>;
using AudioCodecs [[deprecated]] = std::vector<Codec>;
using Codecs = std::vector<Codec>;
Codec CreateAudioCodec(int id,
const std::string& name,

165
media/base/codec_unittest.cc
View file

@ -18,13 +18,11 @@
#include "modules/video_coding/codecs/h264/include/h264.h"
#include "rtc_base/gunit.h"
using cricket::AudioCodec;
using cricket::Codec;
using cricket::FeedbackParam;
using cricket::kCodecParamAssociatedPayloadType;
using cricket::kCodecParamMaxBitrate;
using cricket::kCodecParamMinBitrate;
using cricket::VideoCodec;
class TestCodec : public Codec {
public:
@ -69,27 +67,27 @@ TEST(CodecTest, TestCodecOperators) {
}
TEST(CodecTest, TestAudioCodecOperators) {
AudioCodec c0 = cricket::CreateAudioCodec(96, "A", 44100, 2);
AudioCodec c1 = cricket::CreateAudioCodec(95, "A", 44100, 2);
AudioCodec c2 = cricket::CreateAudioCodec(96, "x", 44100, 2);
AudioCodec c3 = cricket::CreateAudioCodec(96, "A", 48000, 2);
AudioCodec c4 = cricket::CreateAudioCodec(96, "A", 44100, 2);
Codec c0 = cricket::CreateAudioCodec(96, "A", 44100, 2);
Codec c1 = cricket::CreateAudioCodec(95, "A", 44100, 2);
Codec c2 = cricket::CreateAudioCodec(96, "x", 44100, 2);
Codec c3 = cricket::CreateAudioCodec(96, "A", 48000, 2);
Codec c4 = cricket::CreateAudioCodec(96, "A", 44100, 2);
c4.bitrate = 10000;
AudioCodec c5 = cricket::CreateAudioCodec(96, "A", 44100, 1);
Codec c5 = cricket::CreateAudioCodec(96, "A", 44100, 1);
EXPECT_NE(c0, c1);
EXPECT_NE(c0, c2);
EXPECT_NE(c0, c3);
EXPECT_NE(c0, c4);
EXPECT_NE(c0, c5);
AudioCodec c8 = cricket::CreateAudioCodec(0, "", 0, 0);
AudioCodec c9 = c0;
Codec c8 = cricket::CreateAudioCodec(0, "", 0, 0);
Codec c9 = c0;
EXPECT_EQ(c9, c0);
AudioCodec c10(c0);
AudioCodec c11(c0);
AudioCodec c12(c0);
AudioCodec c13(c0);
Codec c10(c0);
Codec c11(c0);
Codec c12(c0);
Codec c13(c0);
c10.params["x"] = "abc";
c11.params["x"] = "def";
c12.params["y"] = "abc";
@ -103,9 +101,9 @@ TEST(CodecTest, TestAudioCodecOperators) {
EXPECT_EQ(c13, c10);
}
TEST(CodecTest, TestAudioCodecMatches) {
TEST(CodecTest, TestCodecMatches) {
// Test a codec with a static payload type.
AudioCodec c0 = cricket::CreateAudioCodec(34, "A", 44100, 1);
Codec c0 = cricket::CreateAudioCodec(34, "A", 44100, 1);
EXPECT_TRUE(c0.Matches(cricket::CreateAudioCodec(34, "", 44100, 1)));
EXPECT_TRUE(c0.Matches(cricket::CreateAudioCodec(34, "", 44100, 0)));
EXPECT_TRUE(c0.Matches(cricket::CreateAudioCodec(34, "", 44100, 0)));
@ -118,7 +116,7 @@ TEST(CodecTest, TestAudioCodecMatches) {
EXPECT_FALSE(c0.Matches(cricket::CreateAudioCodec(95, "", 55100, 2)));
// Test a codec with a dynamic payload type.
AudioCodec c1 = cricket::CreateAudioCodec(96, "A", 44100, 1);
Codec c1 = cricket::CreateAudioCodec(96, "A", 44100, 1);
EXPECT_TRUE(c1.Matches(cricket::CreateAudioCodec(96, "A", 0, 0)));
EXPECT_TRUE(c1.Matches(cricket::CreateAudioCodec(97, "A", 0, 0)));
EXPECT_TRUE(c1.Matches(cricket::CreateAudioCodec(96, "a", 0, 0)));
@ -132,7 +130,7 @@ TEST(CodecTest, TestAudioCodecMatches) {
EXPECT_FALSE(c1.Matches(cricket::CreateAudioCodec(96, "A", 55100, 1)));
// Test a codec with a dynamic payload type, and auto bitrate.
AudioCodec c2 = cricket::CreateAudioCodec(97, "A", 16000, 1);
Codec c2 = cricket::CreateAudioCodec(97, "A", 16000, 1);
// Use default bitrate.
EXPECT_TRUE(c2.Matches(cricket::CreateAudioCodec(97, "A", 16000, 1)));
EXPECT_TRUE(c2.Matches(cricket::CreateAudioCodec(97, "A", 16000, 0)));
@ -142,16 +140,16 @@ TEST(CodecTest, TestAudioCodecMatches) {
EXPECT_TRUE(c2.Matches(cricket::CreateAudioCodec(97, "A", 16000, 1)));
// Stereo doesn't match channels = 0.
AudioCodec c3 = cricket::CreateAudioCodec(96, "A", 44100, 2);
Codec c3 = cricket::CreateAudioCodec(96, "A", 44100, 2);
EXPECT_TRUE(c3.Matches(cricket::CreateAudioCodec(96, "A", 44100, 2)));
EXPECT_FALSE(c3.Matches(cricket::CreateAudioCodec(96, "A", 44100, 1)));
EXPECT_FALSE(c3.Matches(cricket::CreateAudioCodec(96, "A", 44100, 0)));
}
TEST(CodecTest, TestOpusAudioCodecWithDifferentParameters) {
AudioCodec opus_with_fec = cricket::CreateAudioCodec(96, "opus", 48000, 2);
Codec opus_with_fec = cricket::CreateAudioCodec(96, "opus", 48000, 2);
opus_with_fec.params["useinbandfec"] = "1";
AudioCodec opus_without_fec = cricket::CreateAudioCodec(96, "opus", 48000, 2);
Codec opus_without_fec = cricket::CreateAudioCodec(96, "opus", 48000, 2);
EXPECT_TRUE(opus_with_fec != opus_without_fec);
// Matches does not compare parameters for audio.
@ -165,21 +163,21 @@ TEST(CodecTest, TestOpusAudioCodecWithDifferentParameters) {
}
TEST(CodecTest, TestVideoCodecOperators) {
VideoCodec c0 = cricket::CreateVideoCodec(96, "V");
VideoCodec c1 = cricket::CreateVideoCodec(95, "V");
VideoCodec c2 = cricket::CreateVideoCodec(96, "x");
Codec c0 = cricket::CreateVideoCodec(96, "V");
Codec c1 = cricket::CreateVideoCodec(95, "V");
Codec c2 = cricket::CreateVideoCodec(96, "x");
EXPECT_TRUE(c0 != c1);
EXPECT_TRUE(c0 != c2);
VideoCodec c8 = cricket::CreateVideoCodec(0, "");
VideoCodec c9 = c0;
Codec c8 = cricket::CreateVideoCodec(0, "");
Codec c9 = c0;
EXPECT_TRUE(c9 == c0);
VideoCodec c10(c0);
VideoCodec c11(c0);
VideoCodec c12(c0);
VideoCodec c13(c0);
Codec c10(c0);
Codec c11(c0);
Codec c12(c0);
Codec c13(c0);
c10.params["x"] = "abc";
c11.params["x"] = "def";
c12.params["y"] = "abc";
@ -194,9 +192,9 @@ TEST(CodecTest, TestVideoCodecOperators) {
}
TEST(CodecTest, TestVideoCodecEqualsWithDifferentPacketization) {
VideoCodec c0 = cricket::CreateVideoCodec(100, cricket::kVp8CodecName);
VideoCodec c1 = cricket::CreateVideoCodec(100, cricket::kVp8CodecName);
VideoCodec c2 = cricket::CreateVideoCodec(100, cricket::kVp8CodecName);
Codec c0 = cricket::CreateVideoCodec(100, cricket::kVp8CodecName);
Codec c1 = cricket::CreateVideoCodec(100, cricket::kVp8CodecName);
Codec c2 = cricket::CreateVideoCodec(100, cricket::kVp8CodecName);
c2.packetization = "raw";
EXPECT_EQ(c0, c1);
@ -207,13 +205,13 @@ TEST(CodecTest, TestVideoCodecEqualsWithDifferentPacketization) {
TEST(CodecTest, TestVideoCodecMatches) {
// Test a codec with a static payload type.
VideoCodec c0 = cricket::CreateVideoCodec(34, "V");
Codec c0 = cricket::CreateVideoCodec(34, "V");
EXPECT_TRUE(c0.Matches(cricket::CreateVideoCodec(34, "")));
EXPECT_FALSE(c0.Matches(cricket::CreateVideoCodec(96, "")));
EXPECT_FALSE(c0.Matches(cricket::CreateVideoCodec(96, "V")));
// Test a codec with a dynamic payload type.
VideoCodec c1 = cricket::CreateVideoCodec(96, "V");
Codec c1 = cricket::CreateVideoCodec(96, "V");
EXPECT_TRUE(c1.Matches(cricket::CreateVideoCodec(96, "V")));
EXPECT_TRUE(c1.Matches(cricket::CreateVideoCodec(97, "V")));
EXPECT_TRUE(c1.Matches(cricket::CreateVideoCodec(96, "v")));
@ -227,8 +225,8 @@ TEST(CodecTest, TestVideoCodecMatches) {
}
TEST(CodecTest, TestVideoCodecMatchesWithDifferentPacketization) {
VideoCodec c0 = cricket::CreateVideoCodec(100, cricket::kVp8CodecName);
VideoCodec c1 = cricket::CreateVideoCodec(101, cricket::kVp8CodecName);
Codec c0 = cricket::CreateVideoCodec(100, cricket::kVp8CodecName);
Codec c1 = cricket::CreateVideoCodec(101, cricket::kVp8CodecName);
c1.packetization = "raw";
EXPECT_TRUE(c0.Matches(c1));
@ -241,13 +239,12 @@ TEST(CodecTest, TestAV1CodecMatches) {
const char kProfile1[] = "1";
const char kProfile2[] = "2";
VideoCodec c_no_profile =
cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
VideoCodec c_profile0 = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
Codec c_no_profile = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
Codec c_profile0 = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
c_profile0.params[cricket::kAv1FmtpProfile] = kProfile0;
VideoCodec c_profile1 = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
Codec c_profile1 = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
c_profile1.params[cricket::kAv1FmtpProfile] = kProfile1;
VideoCodec c_profile2 = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
Codec c_profile2 = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
c_profile2.params[cricket::kAv1FmtpProfile] = kProfile2;
// An AV1 entry with no profile specified should be treated as profile-0.
@ -255,23 +252,21 @@ TEST(CodecTest, TestAV1CodecMatches) {
{
// Two AV1 entries without a profile specified are treated as duplicates.
VideoCodec c_no_profile_eq =
Codec c_no_profile_eq =
cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
EXPECT_TRUE(c_no_profile.Matches(c_no_profile_eq));
}
{
// Two AV1 entries with profile 0 specified are treated as duplicates.
VideoCodec c_profile0_eq =
cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
Codec c_profile0_eq = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
c_profile0_eq.params[cricket::kAv1FmtpProfile] = kProfile0;
EXPECT_TRUE(c_profile0.Matches(c_profile0_eq));
}
{
// Two AV1 entries with profile 1 specified are treated as duplicates.
VideoCodec c_profile1_eq =
cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
Codec c_profile1_eq = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
c_profile1_eq.params[cricket::kAv1FmtpProfile] = kProfile1;
EXPECT_TRUE(c_profile1.Matches(c_profile1_eq));
}
@ -290,30 +285,27 @@ TEST(CodecTest, TestVP9CodecMatches) {
const char kProfile0[] = "0";
const char kProfile2[] = "2";
VideoCodec c_no_profile =
cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
VideoCodec c_profile0 = cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
Codec c_no_profile = cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
Codec c_profile0 = cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
c_profile0.params[webrtc::kVP9FmtpProfileId] = kProfile0;
EXPECT_TRUE(c_profile0.Matches(c_no_profile));
{
VideoCodec c_profile0_eq =
cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
Codec c_profile0_eq = cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
c_profile0_eq.params[webrtc::kVP9FmtpProfileId] = kProfile0;
EXPECT_TRUE(c_profile0.Matches(c_profile0_eq));
}
{
VideoCodec c_profile2 =
cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
Codec c_profile2 = cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
c_profile2.params[webrtc::kVP9FmtpProfileId] = kProfile2;
EXPECT_FALSE(c_profile0.Matches(c_profile2));
EXPECT_FALSE(c_no_profile.Matches(c_profile2));
}
{
VideoCodec c_no_profile_eq =
Codec c_no_profile_eq =
cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
EXPECT_TRUE(c_no_profile.Matches(c_no_profile_eq));
}
@ -326,12 +318,12 @@ TEST(CodecTest, TestH264CodecMatches) {
const char kProfileLevelId2[] = "42a01e";
const char kProfileLevelId3[] = "42e01e";
VideoCodec pli_1_pm_0 = cricket::CreateVideoCodec(95, "H264");
Codec pli_1_pm_0 = cricket::CreateVideoCodec(95, "H264");
pli_1_pm_0.params[cricket::kH264FmtpProfileLevelId] = kProfileLevelId1;
pli_1_pm_0.params[cricket::kH264FmtpPacketizationMode] = "0";
{
VideoCodec pli_1_pm_blank = cricket::CreateVideoCodec(95, "H264");
Codec pli_1_pm_blank = cricket::CreateVideoCodec(95, "H264");
pli_1_pm_blank.params[cricket::kH264FmtpProfileLevelId] = kProfileLevelId1;
pli_1_pm_blank.params.erase(
pli_1_pm_blank.params.find(cricket::kH264FmtpPacketizationMode));
@ -345,7 +337,7 @@ TEST(CodecTest, TestH264CodecMatches) {
}
{
VideoCodec pli_1_pm_1 = cricket::CreateVideoCodec(95, "H264");
Codec pli_1_pm_1 = cricket::CreateVideoCodec(95, "H264");
pli_1_pm_1.params[cricket::kH264FmtpProfileLevelId] = kProfileLevelId1;
pli_1_pm_1.params[cricket::kH264FmtpPacketizationMode] = "1";
@ -356,7 +348,7 @@ TEST(CodecTest, TestH264CodecMatches) {
}
{
VideoCodec pli_2_pm_0 = cricket::CreateVideoCodec(95, "H264");
Codec pli_2_pm_0 = cricket::CreateVideoCodec(95, "H264");
pli_2_pm_0.params[cricket::kH264FmtpProfileLevelId] = kProfileLevelId2;
pli_2_pm_0.params[cricket::kH264FmtpPacketizationMode] = "0";
@ -367,7 +359,7 @@ TEST(CodecTest, TestH264CodecMatches) {
}
{
VideoCodec pli_3_pm_0_asym = cricket::CreateVideoCodec(95, "H264");
Codec pli_3_pm_0_asym = cricket::CreateVideoCodec(95, "H264");
pli_3_pm_0_asym.params[cricket::kH264FmtpProfileLevelId] = kProfileLevelId3;
pli_3_pm_0_asym.params[cricket::kH264FmtpPacketizationMode] = "0";
@ -391,12 +383,10 @@ TEST(CodecTest, TestH265CodecMatches) {
constexpr char kLevel4[] = "120";
constexpr char kTxMrst[] = "MRST";
VideoCodec c_ptl_blank =
cricket::CreateVideoCodec(95, cricket::kH265CodecName);
Codec c_ptl_blank = cricket::CreateVideoCodec(95, cricket::kH265CodecName);
{
VideoCodec c_profile_1 =
cricket::CreateVideoCodec(95, cricket::kH265CodecName);
Codec c_profile_1 = cricket::CreateVideoCodec(95, cricket::kH265CodecName);
c_profile_1.params[cricket::kH265FmtpProfileId] = kProfile1;
// Matches since profile-id unspecified defaults to "1".
@ -404,7 +394,7 @@ TEST(CodecTest, TestH265CodecMatches) {
}
{
VideoCodec c_tier_flag_1 =
Codec c_tier_flag_1 =
cricket::CreateVideoCodec(95, cricket::kH265CodecName);
c_tier_flag_1.params[cricket::kH265FmtpTierFlag] = kTier1;
@ -413,7 +403,7 @@ TEST(CodecTest, TestH265CodecMatches) {
}
{
VideoCodec c_level_id_3_1 =
Codec c_level_id_3_1 =
cricket::CreateVideoCodec(95, cricket::kH265CodecName);
c_level_id_3_1.params[cricket::kH265FmtpLevelId] = kLevel3_1;
@ -422,8 +412,7 @@ TEST(CodecTest, TestH265CodecMatches) {
}
{
VideoCodec c_level_id_4 =
cricket::CreateVideoCodec(95, cricket::kH265CodecName);
Codec c_level_id_4 = cricket::CreateVideoCodec(95, cricket::kH265CodecName);
c_level_id_4.params[cricket::kH265FmtpLevelId] = kLevel4;
// Does not match since different level-ids are specified.
@ -431,7 +420,7 @@ TEST(CodecTest, TestH265CodecMatches) {
}
{
VideoCodec c_tx_mode_mrst =
Codec c_tx_mode_mrst =
cricket::CreateVideoCodec(95, cricket::kH265CodecName);
c_tx_mode_mrst.params[cricket::kH265FmtpTxMode] = kTxMrst;
@ -444,7 +433,7 @@ TEST(CodecTest, TestH265CodecMatches) {
#endif
TEST(CodecTest, TestSetParamGetParamAndRemoveParam) {
AudioCodec codec = cricket::CreateAudioCodec(0, "foo", 22222, 2);
Codec codec = cricket::CreateAudioCodec(0, "foo", 22222, 2);
codec.SetParam("a", "1");
codec.SetParam("b", "x");
@ -485,11 +474,11 @@ TEST(CodecTest, TestIntersectFeedbackParams) {
TEST(CodecTest, TestGetCodecType) {
// Codec type comparison should be case insensitive on names.
const VideoCodec codec = cricket::CreateVideoCodec(96, "V");
const VideoCodec rtx_codec = cricket::CreateVideoCodec(96, "rTx");
const VideoCodec ulpfec_codec = cricket::CreateVideoCodec(96, "ulpFeC");
const VideoCodec flexfec_codec = cricket::CreateVideoCodec(96, "FlExFeC-03");
const VideoCodec red_codec = cricket::CreateVideoCodec(96, "ReD");
const Codec codec = cricket::CreateVideoCodec(96, "V");
const Codec rtx_codec = cricket::CreateVideoCodec(96, "rTx");
const Codec ulpfec_codec = cricket::CreateVideoCodec(96, "ulpFeC");
const Codec flexfec_codec = cricket::CreateVideoCodec(96, "FlExFeC-03");
const Codec red_codec = cricket::CreateVideoCodec(96, "ReD");
EXPECT_TRUE(codec.IsMediaCodec());
EXPECT_EQ(codec.GetResiliencyType(), Codec::ResiliencyType::kNone);
EXPECT_EQ(rtx_codec.GetResiliencyType(), Codec::ResiliencyType::kRtx);
@ -499,7 +488,7 @@ TEST(CodecTest, TestGetCodecType) {
}
TEST(CodecTest, TestCreateRtxCodec) {
const VideoCodec rtx_codec = cricket::CreateVideoRtxCodec(96, 120);
const Codec rtx_codec = cricket::CreateVideoRtxCodec(96, 120);
EXPECT_EQ(96, rtx_codec.id);
EXPECT_EQ(rtx_codec.GetResiliencyType(), Codec::ResiliencyType::kRtx);
int associated_payload_type;
@ -509,8 +498,8 @@ TEST(CodecTest, TestCreateRtxCodec) {
}
TEST(CodecTest, TestMatchesRtpCodecRtx) {
const VideoCodec rtx_codec_1 = cricket::CreateVideoRtxCodec(96, 120);
const VideoCodec rtx_codec_2 = cricket::CreateVideoRtxCodec(96, 121);
const Codec rtx_codec_1 = cricket::CreateVideoRtxCodec(96, 120);
const Codec rtx_codec_2 = cricket::CreateVideoRtxCodec(96, 121);
EXPECT_TRUE(rtx_codec_1.Matches(rtx_codec_2));
// MatchesRtpCodec ignores the different associated payload type (apt) for
// RTX.
@ -518,48 +507,48 @@ TEST(CodecTest, TestMatchesRtpCodecRtx) {
}
TEST(CodecTest, TestValidateCodecFormat) {
const VideoCodec codec = cricket::CreateVideoCodec(96, "V");
const Codec codec = cricket::CreateVideoCodec(96, "V");
ASSERT_TRUE(codec.ValidateCodecFormat());
// Accept 0-127 as payload types.
VideoCodec low_payload_type = codec;
Codec low_payload_type = codec;
low_payload_type.id = 0;
VideoCodec high_payload_type = codec;
Codec high_payload_type = codec;
high_payload_type.id = 127;
ASSERT_TRUE(low_payload_type.ValidateCodecFormat());
EXPECT_TRUE(high_payload_type.ValidateCodecFormat());
// Reject negative payloads.
VideoCodec negative_payload_type = codec;
Codec negative_payload_type = codec;
negative_payload_type.id = -1;
EXPECT_FALSE(negative_payload_type.ValidateCodecFormat());
// Reject too-high payloads.
VideoCodec too_high_payload_type = codec;
Codec too_high_payload_type = codec;
too_high_payload_type.id = 128;
EXPECT_FALSE(too_high_payload_type.ValidateCodecFormat());
// Reject codecs with min bitrate > max bitrate.
VideoCodec incorrect_bitrates = codec;
Codec incorrect_bitrates = codec;
incorrect_bitrates.params[kCodecParamMinBitrate] = "100";
incorrect_bitrates.params[kCodecParamMaxBitrate] = "80";
EXPECT_FALSE(incorrect_bitrates.ValidateCodecFormat());
// Accept min bitrate == max bitrate.
VideoCodec equal_bitrates = codec;
Codec equal_bitrates = codec;
equal_bitrates.params[kCodecParamMinBitrate] = "100";
equal_bitrates.params[kCodecParamMaxBitrate] = "100";
EXPECT_TRUE(equal_bitrates.ValidateCodecFormat());
// Accept min bitrate < max bitrate.
VideoCodec different_bitrates = codec;
Codec different_bitrates = codec;
different_bitrates.params[kCodecParamMinBitrate] = "99";
different_bitrates.params[kCodecParamMaxBitrate] = "100";
EXPECT_TRUE(different_bitrates.ValidateCodecFormat());
}
TEST(CodecTest, TestToCodecParameters) {
VideoCodec v = cricket::CreateVideoCodec(96, "V");
Codec v = cricket::CreateVideoCodec(96, "V");
v.SetParam("p1", "v1");
webrtc::RtpCodecParameters codec_params_1 = v.ToCodecParameters();
EXPECT_EQ(96, codec_params_1.payload_type);
@ -571,7 +560,7 @@ TEST(CodecTest, TestToCodecParameters) {
EXPECT_EQ("p1", codec_params_1.parameters.begin()->first);
EXPECT_EQ("v1", codec_params_1.parameters.begin()->second);
AudioCodec a = cricket::CreateAudioCodec(97, "A", 44100, 2);
Codec a = cricket::CreateAudioCodec(97, "A", 44100, 2);
a.SetParam("p1", "a1");
webrtc::RtpCodecParameters codec_params_2 = a.ToCodecParameters();
EXPECT_EQ(97, codec_params_2.payload_type);

50
media/base/fake_media_engine.cc
View file

@ -62,8 +62,7 @@ FakeVoiceMediaReceiveChannel::FakeVoiceMediaReceiveChannel(
SetOptions(options);
}
FakeVoiceMediaReceiveChannel::~FakeVoiceMediaReceiveChannel() = default;
const std::vector<AudioCodec>& FakeVoiceMediaReceiveChannel::recv_codecs()
const {
const std::vector<Codec>& FakeVoiceMediaReceiveChannel::recv_codecs() const {
return recv_codecs_;
}
const std::vector<FakeVoiceMediaReceiveChannel::DtmfInfo>&
@ -160,7 +159,7 @@ std::vector<webrtc::RtpSource> FakeVoiceMediaReceiveChannel::GetSources(
return std::vector<webrtc::RtpSource>();
}
bool FakeVoiceMediaReceiveChannel::SetRecvCodecs(
const std::vector<AudioCodec>& codecs) {
const std::vector<Codec>& codecs) {
if (fail_set_recv_codecs()) {
// Fake the failure in SetRecvCodecs.
return false;
@ -216,7 +215,7 @@ FakeVoiceMediaSendChannel::FakeVoiceMediaSendChannel(
SetOptions(options);
}
FakeVoiceMediaSendChannel::~FakeVoiceMediaSendChannel() = default;
const std::vector<AudioCodec>& FakeVoiceMediaSendChannel::send_codecs() const {
const std::vector<Codec>& FakeVoiceMediaSendChannel::send_codecs() const {
return send_codecs_;
}
absl::optional<Codec> FakeVoiceMediaSendChannel::GetSendCodec() const {
@ -267,7 +266,7 @@ bool FakeVoiceMediaSendChannel::HasSource(uint32_t ssrc) const {
return local_sinks_.find(ssrc) != local_sinks_.end();
}
bool FakeVoiceMediaSendChannel::CanInsertDtmf() {
for (std::vector<AudioCodec>::const_iterator it = send_codecs_.begin();
for (std::vector<Codec>::const_iterator it = send_codecs_.begin();
it != send_codecs_.end(); ++it) {
// Find the DTMF telephone event "codec".
if (absl::EqualsIgnoreCase(it->name, "telephone-event")) {
@ -292,7 +291,7 @@ bool FakeVoiceMediaSendChannel::GetStats(VoiceMediaSendInfo* info) {
return false;
}
bool FakeVoiceMediaSendChannel::SetSendCodecs(
const std::vector<AudioCodec>& codecs) {
const std::vector<Codec>& codecs) {
if (fail_set_send_codecs()) {
// Fake the failure in SetSendCodecs.
return false;
@ -343,10 +342,10 @@ FakeVideoMediaSendChannel::FakeVideoMediaSendChannel(
SetOptions(options);
}
FakeVideoMediaSendChannel::~FakeVideoMediaSendChannel() = default;
const std::vector<VideoCodec>& FakeVideoMediaSendChannel::send_codecs() const {
const std::vector<Codec>& FakeVideoMediaSendChannel::send_codecs() const {
return send_codecs_;
}
const std::vector<VideoCodec>& FakeVideoMediaSendChannel::codecs() const {
const std::vector<Codec>& FakeVideoMediaSendChannel::codecs() const {
return send_codecs();
}
const VideoOptions& FakeVideoMediaSendChannel::options() const {
@ -393,7 +392,7 @@ bool FakeVideoMediaSendChannel::GetStats(VideoMediaSendInfo* info) {
return false;
}
bool FakeVideoMediaSendChannel::SetSendCodecs(
const std::vector<VideoCodec>& codecs) {
const std::vector<Codec>& codecs) {
if (fail_set_send_codecs()) {
// Fake the failure in SetSendCodecs.
return false;
@ -424,8 +423,7 @@ FakeVideoMediaReceiveChannel::FakeVideoMediaReceiveChannel(
SetOptions(options);
}
FakeVideoMediaReceiveChannel::~FakeVideoMediaReceiveChannel() = default;
const std::vector<VideoCodec>& FakeVideoMediaReceiveChannel::recv_codecs()
const {
const std::vector<Codec>& FakeVideoMediaReceiveChannel::recv_codecs() const {
return recv_codecs_;
}
bool FakeVideoMediaReceiveChannel::rendering() const {
@ -503,7 +501,7 @@ absl::optional<int> FakeVideoMediaReceiveChannel::GetBaseMinimumPlayoutDelayMs(
return absl::nullopt;
}
bool FakeVideoMediaReceiveChannel::SetRecvCodecs(
const std::vector<VideoCodec>& codecs) {
const std::vector<Codec>& codecs) {
if (fail_set_recv_codecs()) {
// Fake the failure in SetRecvCodecs.
return false;
@ -566,20 +564,20 @@ FakeVoiceEngine::CreateReceiveChannel(
call->network_thread());
return ch;
}
const std::vector<AudioCodec>& FakeVoiceEngine::send_codecs() const {
const std::vector<Codec>& FakeVoiceEngine::send_codecs() const {
return send_codecs_;
}
const std::vector<AudioCodec>& FakeVoiceEngine::recv_codecs() const {
const std::vector<Codec>& FakeVoiceEngine::recv_codecs() const {
return recv_codecs_;
}
void FakeVoiceEngine::SetCodecs(const std::vector<AudioCodec>& codecs) {
void FakeVoiceEngine::SetCodecs(const std::vector<Codec>& codecs) {
send_codecs_ = codecs;
recv_codecs_ = codecs;
}
void FakeVoiceEngine::SetRecvCodecs(const std::vector<AudioCodec>& codecs) {
void FakeVoiceEngine::SetRecvCodecs(const std::vector<Codec>& codecs) {
recv_codecs_ = codecs;
}
void FakeVoiceEngine::SetSendCodecs(const std::vector<AudioCodec>& codecs) {
void FakeVoiceEngine::SetSendCodecs(const std::vector<Codec>& codecs) {
send_codecs_ = codecs;
}
int FakeVoiceEngine::GetInputLevel() {
@ -647,19 +645,19 @@ FakeVideoEngine::CreateReceiveChannel(
call->network_thread());
return ch;
}
std::vector<VideoCodec> FakeVideoEngine::send_codecs(bool use_rtx) const {
std::vector<Codec> FakeVideoEngine::send_codecs(bool use_rtx) const {
return send_codecs_;
}
std::vector<VideoCodec> FakeVideoEngine::recv_codecs(bool use_rtx) const {
std::vector<Codec> FakeVideoEngine::recv_codecs(bool use_rtx) const {
return recv_codecs_;
}
void FakeVideoEngine::SetSendCodecs(const std::vector<VideoCodec>& codecs) {
void FakeVideoEngine::SetSendCodecs(const std::vector<Codec>& codecs) {
send_codecs_ = codecs;
}
void FakeVideoEngine::SetRecvCodecs(const std::vector<VideoCodec>& codecs) {
void FakeVideoEngine::SetRecvCodecs(const std::vector<Codec>& codecs) {
recv_codecs_ = codecs;
}
@ -682,18 +680,16 @@ FakeMediaEngine::FakeMediaEngine()
voice_(static_cast<FakeVoiceEngine*>(&voice())),
video_(static_cast<FakeVideoEngine*>(&video())) {}
FakeMediaEngine::~FakeMediaEngine() {}
void FakeMediaEngine::SetAudioCodecs(const std::vector<AudioCodec>& codecs) {
void FakeMediaEngine::SetAudioCodecs(const std::vector<Codec>& codecs) {
voice_->SetCodecs(codecs);
}
void FakeMediaEngine::SetAudioRecvCodecs(
const std::vector<AudioCodec>& codecs) {
void FakeMediaEngine::SetAudioRecvCodecs(const std::vector<Codec>& codecs) {
voice_->SetRecvCodecs(codecs);
}
void FakeMediaEngine::SetAudioSendCodecs(
const std::vector<AudioCodec>& codecs) {
void FakeMediaEngine::SetAudioSendCodecs(const std::vector<Codec>& codecs) {
voice_->SetSendCodecs(codecs);
}
void FakeMediaEngine::SetVideoCodecs(const std::vector<VideoCodec>& codecs) {
void FakeMediaEngine::SetVideoCodecs(const std::vector<Codec>& codecs) {
video_->SetSendCodecs(codecs);
video_->SetRecvCodecs(codecs);
}

72
media/base/fake_media_engine.h
View file

@ -452,7 +452,7 @@ class FakeVoiceMediaReceiveChannel
virtual ~FakeVoiceMediaReceiveChannel();
// Test methods
const std::vector<AudioCodec>& recv_codecs() const;
const std::vector<Codec>& recv_codecs() const;
const std::vector<DtmfInfo>& dtmf_info_queue() const;
const AudioOptions& options() const;
int max_bps() const;
@ -516,11 +516,11 @@ class FakeVoiceMediaReceiveChannel
AudioSource* source_;
};
bool SetRecvCodecs(const std::vector<AudioCodec>& codecs);
bool SetRecvCodecs(const std::vector<Codec>& codecs);
bool SetMaxSendBandwidth(int bps);
bool SetOptions(const AudioOptions& options);
std::vector<AudioCodec> recv_codecs_;
std::vector<Codec> recv_codecs_;
std::map<uint32_t, double> output_scalings_;
std::map<uint32_t, int> output_delays_;
std::vector<DtmfInfo> dtmf_info_queue_;
@ -543,7 +543,7 @@ class FakeVoiceMediaSendChannel
webrtc::TaskQueueBase* network_thread);
~FakeVoiceMediaSendChannel() override;
const std::vector<AudioCodec>& send_codecs() const;
const std::vector<Codec>& send_codecs() const;
const std::vector<DtmfInfo>& dtmf_info_queue() const;
const AudioOptions& options() const;
int max_bps() const;
@ -599,12 +599,12 @@ class FakeVoiceMediaSendChannel
AudioSource* source_;
};
bool SetSendCodecs(const std::vector<AudioCodec>& codecs);
bool SetSendCodecs(const std::vector<Codec>& codecs);
bool SetMaxSendBandwidth(int bps);
bool SetOptions(const AudioOptions& options);
bool SetLocalSource(uint32_t ssrc, AudioSource* source);
std::vector<AudioCodec> send_codecs_;
std::vector<Codec> send_codecs_;
std::map<uint32_t, double> output_scalings_;
std::map<uint32_t, int> output_delays_;
std::vector<DtmfInfo> dtmf_info_queue_;
@ -637,8 +637,8 @@ class FakeVideoMediaReceiveChannel
return cricket::MEDIA_TYPE_VIDEO;
}
const std::vector<VideoCodec>& recv_codecs() const;
const std::vector<VideoCodec>& send_codecs() const;
const std::vector<Codec>& recv_codecs() const;
const std::vector<Codec>& send_codecs() const;
bool rendering() const;
const VideoOptions& options() const;
const std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*>&
@ -682,12 +682,12 @@ class FakeVideoMediaReceiveChannel
}
private:
bool SetRecvCodecs(const std::vector<VideoCodec>& codecs);
bool SetSendCodecs(const std::vector<VideoCodec>& codecs);
bool SetRecvCodecs(const std::vector<Codec>& codecs);
bool SetSendCodecs(const std::vector<Codec>& codecs);
bool SetOptions(const VideoOptions& options);
bool SetMaxSendBandwidth(int bps);
std::vector<VideoCodec> recv_codecs_;
std::vector<Codec> recv_codecs_;
std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*> sinks_;
std::map<uint32_t, rtc::VideoSourceInterface<webrtc::VideoFrame>*> sources_;
std::map<uint32_t, int> output_delays_;
@ -711,8 +711,8 @@ class FakeVideoMediaSendChannel
return cricket::MEDIA_TYPE_VIDEO;
}
const std::vector<VideoCodec>& send_codecs() const;
const std::vector<VideoCodec>& codecs() const;
const std::vector<Codec>& send_codecs() const;
const std::vector<Codec>& codecs() const;
const VideoOptions& options() const;
const std::map<uint32_t, rtc::VideoSinkInterface<webrtc::VideoFrame>*>&
sinks() const;
@ -749,11 +749,11 @@ class FakeVideoMediaSendChannel
bool GetStats(VideoMediaSendInfo* info) override;
private:
bool SetSendCodecs(const std::vector<VideoCodec>& codecs);
bool SetSendCodecs(const std::vector<Codec>& codecs);
bool SetOptions(const VideoOptions& options);
bool SetMaxSendBandwidth(int bps);
std::vector<VideoCodec> send_codecs_;
std::vector<Codec> send_codecs_;
std::map<uint32_t, rtc::VideoSourceInterface<webrtc::VideoFrame>*> sources_;
VideoOptions options_;
int max_bps_;
@ -780,11 +780,11 @@ class FakeVoiceEngine : public VoiceEngineInterface {
// TODO(ossu): For proper testing, These should either individually settable
// or the voice engine should reference mockable factories.
const std::vector<AudioCodec>& send_codecs() const override;
const std::vector<AudioCodec>& recv_codecs() const override;
void SetCodecs(const std::vector<AudioCodec>& codecs);
void SetRecvCodecs(const std::vector<AudioCodec>& codecs);
void SetSendCodecs(const std::vector<AudioCodec>& codecs);
const std::vector<Codec>& send_codecs() const override;
const std::vector<Codec>& recv_codecs() const override;
void SetCodecs(const std::vector<Codec>& codecs);
void SetRecvCodecs(const std::vector<Codec>& codecs);
void SetSendCodecs(const std::vector<Codec>& codecs);
int GetInputLevel();
bool StartAecDump(webrtc::FileWrapper file, int64_t max_size_bytes) override;
void StopAecDump() override;
@ -796,8 +796,8 @@ class FakeVoiceEngine : public VoiceEngineInterface {
std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions);
private:
std::vector<AudioCodec> recv_codecs_;
std::vector<AudioCodec> send_codecs_;
std::vector<Codec> recv_codecs_;
std::vector<Codec> send_codecs_;
bool fail_create_channel_;
std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions_;
@ -823,16 +823,12 @@ class FakeVideoEngine : public VideoEngineInterface {
FakeVideoMediaSendChannel* GetSendChannel(size_t index);
FakeVideoMediaReceiveChannel* GetReceiveChannel(size_t index);
std::vector<VideoCodec> send_codecs() const override {
return send_codecs(true);
}
std::vector<VideoCodec> recv_codecs() const override {
return recv_codecs(true);
}
std::vector<VideoCodec> send_codecs(bool include_rtx) const override;
std::vector<VideoCodec> recv_codecs(bool include_rtx) const override;
void SetSendCodecs(const std::vector<VideoCodec>& codecs);
void SetRecvCodecs(const std::vector<VideoCodec>& codecs);
std::vector<Codec> send_codecs() const override { return send_codecs(true); }
std::vector<Codec> recv_codecs() const override { return recv_codecs(true); }
std::vector<Codec> send_codecs(bool include_rtx) const override;
std::vector<Codec> recv_codecs(bool include_rtx) const override;
void SetSendCodecs(const std::vector<Codec>& codecs);
void SetRecvCodecs(const std::vector<Codec>& codecs);
bool SetCapture(bool capture);
std::vector<webrtc::RtpHeaderExtensionCapability> GetRtpHeaderExtensions()
const override;
@ -840,8 +836,8 @@ class FakeVideoEngine : public VideoEngineInterface {
std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions);
private:
std::vector<VideoCodec> send_codecs_;
std::vector<VideoCodec> recv_codecs_;
std::vector<Codec> send_codecs_;
std::vector<Codec> recv_codecs_;
bool capture_;
VideoOptions options_;
bool fail_create_channel_;
@ -856,10 +852,10 @@ class FakeMediaEngine : public CompositeMediaEngine {
~FakeMediaEngine() override;
void SetAudioCodecs(const std::vector<AudioCodec>& codecs);
void SetAudioRecvCodecs(const std::vector<AudioCodec>& codecs);
void SetAudioSendCodecs(const std::vector<AudioCodec>& codecs);
void SetVideoCodecs(const std::vector<VideoCodec>& codecs);
void SetAudioCodecs(const std::vector<Codec>& codecs);
void SetAudioRecvCodecs(const std::vector<Codec>& codecs);
void SetAudioSendCodecs(const std::vector<Codec>& codecs);
void SetVideoCodecs(const std::vector<Codec>& codecs);
void set_fail_create_channel(bool fail);

12
media/base/media_engine.h
View file

@ -118,8 +118,8 @@ class VoiceEngineInterface : public RtpHeaderExtensionQueryInterface {
return nullptr;
}
virtual const std::vector<AudioCodec>& send_codecs() const = 0;
virtual const std::vector<AudioCodec>& recv_codecs() const = 0;
virtual const std::vector<Codec>& send_codecs() const = 0;
virtual const std::vector<Codec>& recv_codecs() const = 0;
// Starts AEC dump using existing file, a maximum file size in bytes can be
// specified. Logging is stopped just before the size limit is exceeded.
@ -164,16 +164,16 @@ class VideoEngineInterface : public RtpHeaderExtensionQueryInterface {
}
// Retrieve list of supported codecs.
virtual std::vector<VideoCodec> send_codecs() const = 0;
virtual std::vector<VideoCodec> recv_codecs() const = 0;
virtual std::vector<Codec> send_codecs() const = 0;
virtual std::vector<Codec> recv_codecs() const = 0;
// As above, but if include_rtx is false, don't include RTX codecs.
// TODO(bugs.webrtc.org/13931): Remove default implementation once
// upstream subclasses have converted.
virtual std::vector<VideoCodec> send_codecs(bool include_rtx) const {
virtual std::vector<Codec> send_codecs(bool include_rtx) const {
RTC_DCHECK(include_rtx);
return send_codecs();
}
virtual std::vector<VideoCodec> recv_codecs(bool include_rtx) const {
virtual std::vector<Codec> recv_codecs(bool include_rtx) const {
RTC_DCHECK(include_rtx);
return recv_codecs();
}

4
media/base/media_engine_unittest.cc
View file

@ -70,8 +70,8 @@ class MostlyMockVoiceEngineInterface : public VoiceEngineInterface {
GetAudioState,
(),
(const, override));
MOCK_METHOD(std::vector<AudioCodec>&, send_codecs, (), (const, override));
MOCK_METHOD(std::vector<AudioCodec>&, recv_codecs, (), (const, override));
MOCK_METHOD(std::vector<Codec>&, send_codecs, (), (const, override));
MOCK_METHOD(std::vector<Codec>&, recv_codecs, (), (const, override));
MOCK_METHOD(bool,
StartAecDump,
(webrtc::FileWrapper file, int64_t max_size_bytes),

8
media/engine/fake_webrtc_video_engine.cc
View file

@ -120,8 +120,8 @@ void FakeWebRtcVideoDecoderFactory::DecoderDestroyed(
void FakeWebRtcVideoDecoderFactory::AddSupportedVideoCodecType(
const std::string& name) {
// This is to match the default H264 params of cricket::VideoCodec.
cricket::VideoCodec video_codec = cricket::CreateVideoCodec(name);
// This is to match the default H264 params of cricket::Codec.
cricket::Codec video_codec = cricket::CreateVideoCodec(name);
supported_codec_formats_.push_back(
webrtc::SdpVideoFormat(video_codec.name, video_codec.params));
}
@ -287,8 +287,8 @@ void FakeWebRtcVideoEncoderFactory::AddSupportedVideoCodec(
void FakeWebRtcVideoEncoderFactory::AddSupportedVideoCodecType(
const std::string& name,
const std::vector<webrtc::ScalabilityMode>& scalability_modes) {
// This is to match the default H264 params of cricket::VideoCodec.
cricket::VideoCodec video_codec = cricket::CreateVideoCodec(name);
// This is to match the default H264 params of cricket::Codec.
cricket::Codec video_codec = cricket::CreateVideoCodec(name);
formats_.push_back(webrtc::SdpVideoFormat(
video_codec.name, video_codec.params,
{scalability_modes.begin(), scalability_modes.end()}));

6
media/engine/payload_type_mapper.cc
View file

@ -19,7 +19,7 @@
namespace cricket {
webrtc::SdpAudioFormat AudioCodecToSdpAudioFormat(const AudioCodec& ac) {
webrtc::SdpAudioFormat AudioCodecToSdpAudioFormat(const Codec& ac) {
return webrtc::SdpAudioFormat(ac.name, ac.clockrate, ac.channels, ac.params);
}
@ -122,7 +122,7 @@ absl::optional<int> PayloadTypeMapper::FindMappingFor(
return absl::nullopt;
}
absl::optional<AudioCodec> PayloadTypeMapper::ToAudioCodec(
absl::optional<Codec> PayloadTypeMapper::ToAudioCodec(
const webrtc::SdpAudioFormat& format) {
// TODO(ossu): We can safely set bitrate to zero here, since that field is
// not presented in the SDP. It is used to ferry around some target bitrate
@ -131,7 +131,7 @@ absl::optional<AudioCodec> PayloadTypeMapper::ToAudioCodec(
// ACM or NetEq.
auto opt_payload_type = GetMappingFor(format);
if (opt_payload_type) {
AudioCodec codec =
Codec codec =
cricket::CreateAudioCodec(*opt_payload_type, format.name,
format.clockrate_hz, format.num_channels);
codec.params = format.parameters;

4
media/engine/payload_type_mapper.h
View file

@ -20,7 +20,7 @@
namespace cricket {
webrtc::SdpAudioFormat AudioCodecToSdpAudioFormat(const AudioCodec& ac);
webrtc::SdpAudioFormat AudioCodecToSdpAudioFormat(const Codec& ac);
class PayloadTypeMapper {
public:
@ -39,7 +39,7 @@ class PayloadTypeMapper {
// Like GetMappingFor, but fills in an AudioCodec structure with the necessary
// information instead.
absl::optional<AudioCodec> ToAudioCodec(const webrtc::SdpAudioFormat& format);
absl::optional<Codec> ToAudioCodec(const webrtc::SdpAudioFormat& format);
private:
struct SdpAudioFormatOrdering {

2
media/engine/payload_type_mapper_unittest.cc
View file

@ -126,7 +126,7 @@ TEST_F(PayloadTypeMapperTest, ToAudioCodec) {
if (opt_payload_type && opt_audio_codec) {
int payload_type = *opt_payload_type;
const AudioCodec& codec = *opt_audio_codec;
const Codec& codec = *opt_audio_codec;
EXPECT_EQ(codec.id, payload_type);
EXPECT_EQ(codec.name, format.name);

45
media/engine/webrtc_video_engine.cc
View file

@ -111,7 +111,7 @@ bool IsDisabled(const webrtc::FieldTrialsView& trials, absl::string_view name) {
return absl::StartsWith(trials.Lookup(name), "Disabled");
}
void AddDefaultFeedbackParams(VideoCodec* codec,
void AddDefaultFeedbackParams(Codec* codec,
const webrtc::FieldTrialsView& trials) {
// Don't add any feedback params for RED and ULPFEC.
if (codec->name == kRedCodecName || codec->name == kUlpfecCodecName)
@ -133,7 +133,7 @@ void AddDefaultFeedbackParams(VideoCodec* codec,
// Helper function to determine whether a codec should use the [35, 63] range.
// Should be used when adding new codecs (or variants).
bool IsCodecValidForLowerRange(const VideoCodec& codec) {
bool IsCodecValidForLowerRange(const Codec& codec) {
if (absl::EqualsIgnoreCase(codec.name, kFlexfecCodecName) ||
absl::EqualsIgnoreCase(codec.name, kAv1CodecName) ||
absl::EqualsIgnoreCase(codec.name, kAv1xCodecName)) {
@ -174,7 +174,7 @@ bool IsCodecValidForLowerRange(const VideoCodec& codec) {
// TODO(kron): Perhaps it is better to move the implicit knowledge to the place
// where codecs are negotiated.
template <class T>
std::vector<VideoCodec> GetPayloadTypesAndDefaultCodecs(
std::vector<Codec> GetPayloadTypesAndDefaultCodecs(
const T* factory,
bool is_decoder_factory,
bool include_rtx,
@ -190,7 +190,7 @@ std::vector<VideoCodec> GetPayloadTypesAndDefaultCodecs(
}
if (supported_formats.empty())
return std::vector<VideoCodec>();
return std::vector<Codec>();
supported_formats.push_back(webrtc::SdpVideoFormat(kRedCodecName));
supported_formats.push_back(webrtc::SdpVideoFormat(kUlpfecCodecName));
@ -217,9 +217,9 @@ std::vector<VideoCodec> GetPayloadTypesAndDefaultCodecs(
int payload_type_upper = kFirstDynamicPayloadTypeUpperRange;
int payload_type_lower = kFirstDynamicPayloadTypeLowerRange;
std::vector<VideoCodec> output_codecs;
std::vector<Codec> output_codecs;
for (const webrtc::SdpVideoFormat& format : supported_formats) {
VideoCodec codec = cricket::CreateVideoCodec(format);
Codec codec = cricket::CreateVideoCodec(format);
bool isFecCodec = absl::EqualsIgnoreCase(codec.name, kUlpfecCodecName) ||
absl::EqualsIgnoreCase(codec.name, kFlexfecCodecName);
@ -270,7 +270,7 @@ std::vector<VideoCodec> GetPayloadTypesAndDefaultCodecs(
return output_codecs;
}
static std::string CodecVectorToString(const std::vector<VideoCodec>& codecs) {
static std::string CodecVectorToString(const std::vector<Codec>& codecs) {
rtc::StringBuilder out;
out << "{";
for (size_t i = 0; i < codecs.size(); ++i) {
@ -283,7 +283,7 @@ static std::string CodecVectorToString(const std::vector<VideoCodec>& codecs) {
return out.Release();
}
static bool ValidateCodecFormats(const std::vector<VideoCodec>& codecs) {
static bool ValidateCodecFormats(const std::vector<Codec>& codecs) {
bool has_video = false;
for (size_t i = 0; i < codecs.size(); ++i) {
if (!codecs[i].ValidateCodecFormat()) {
@ -497,7 +497,7 @@ bool IsActiveFromEncodings(
}
bool IsScalabilityModeSupportedByCodec(
const VideoCodec& codec,
const Codec& codec,
const std::string& scalability_mode,
const webrtc::VideoSendStream::Config& config) {
return config.encoder_settings.encoder_factory
@ -509,7 +509,7 @@ bool IsScalabilityModeSupportedByCodec(
// Fallback to default value if the scalability mode is unset or unsupported by
// the codec.
void FallbackToDefaultScalabilityModeIfNotSupported(
const VideoCodec& codec,
const Codec& codec,
const webrtc::VideoSendStream::Config& config,
std::vector<webrtc::RtpEncodingParameters>& encodings) {
if (!absl::c_any_of(encodings,
@ -545,8 +545,7 @@ void FallbackToDefaultScalabilityModeIfNotSupported(
// "codecs". Note that VideoCodecSettings correspond to concrete codecs like
// VP8, VP9, H264 while VideoCodecs correspond also to "virtual" codecs like
// RTX, ULPFEC, FLEXFEC.
std::vector<VideoCodecSettings> MapCodecs(
const std::vector<VideoCodec>& codecs) {
std::vector<VideoCodecSettings> MapCodecs(const std::vector<Codec>& codecs) {
if (codecs.empty()) {
return {};
}
@ -560,7 +559,7 @@ std::vector<VideoCodecSettings> MapCodecs(
webrtc::UlpfecConfig ulpfec_config;
absl::optional<int> flexfec_payload_type;
for (const VideoCodec& in_codec : codecs) {
for (const Codec& in_codec : codecs) {
const int payload_type = in_codec.id;
if (payload_codec_type.find(payload_type) != payload_codec_type.end()) {
@ -796,13 +795,13 @@ WebRtcVideoEngine::CreateReceiveChannel(
call, config, options, crypto_options, decoder_factory_.get());
}
std::vector<VideoCodec> WebRtcVideoEngine::send_codecs(bool include_rtx) const {
std::vector<Codec> WebRtcVideoEngine::send_codecs(bool include_rtx) const {
return GetPayloadTypesAndDefaultCodecs(encoder_factory_.get(),
/*is_decoder_factory=*/false,
include_rtx, trials_);
}
std::vector<VideoCodec> WebRtcVideoEngine::recv_codecs(bool include_rtx) const {
std::vector<Codec> WebRtcVideoEngine::recv_codecs(bool include_rtx) const {
return GetPayloadTypesAndDefaultCodecs(decoder_factory_.get(),
/*is_decoder_factory=*/true,
include_rtx, trials_);
@ -902,7 +901,7 @@ WebRtcVideoSendChannel::~WebRtcVideoSendChannel() {
rtc::scoped_refptr<webrtc::VideoEncoderConfig::EncoderSpecificSettings>
WebRtcVideoSendChannel::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
const VideoCodec& codec) {
const Codec& codec) {
RTC_DCHECK_RUN_ON(&thread_checker_);
bool is_screencast = parameters_.options.is_screencast.value_or(false);
// No automatic resizing when using simulcast or screencast, or when
@ -1298,7 +1297,7 @@ webrtc::RtpParameters WebRtcVideoSendChannel::GetRtpSendParameters(
webrtc::RtpParameters rtp_params = it->second->GetRtpParameters();
// Need to add the common list of codecs to the send stream-specific
// RTP parameters.
for (const VideoCodec& codec : send_params_.codecs) {
for (const Codec& codec : send_params_.codecs) {
if (send_codec() && send_codec()->codec.id == codec.id) {
// Put the current send codec to the front of the codecs list.
RTC_DCHECK_EQ(codec.name, send_codec()->codec.name);
@ -2092,7 +2091,7 @@ void WebRtcVideoSendChannel::WebRtcVideoSendStream::UpdateSendState() {
webrtc::VideoEncoderConfig
WebRtcVideoSendChannel::WebRtcVideoSendStream::CreateVideoEncoderConfig(
const VideoCodec& codec) const {
const Codec& codec) const {
RTC_DCHECK_RUN_ON(&thread_checker_);
webrtc::VideoEncoderConfig encoder_config;
encoder_config.codec_type = webrtc::PayloadStringToCodecType(codec.name);
@ -2644,7 +2643,7 @@ webrtc::RtpParameters WebRtcVideoReceiveChannel::GetRtpReceiverParameters(
rtp_params.header_extensions = recv_rtp_extensions_;
// Add codecs, which any stream is prepared to receive.
for (const VideoCodec& codec : recv_params_.codecs) {
for (const Codec& codec : recv_params_.codecs) {
rtp_params.codecs.push_back(codec.ToCodecParameters());
}
@ -2664,7 +2663,7 @@ WebRtcVideoReceiveChannel::GetDefaultRtpReceiveParameters() const {
rtp_params.encodings.emplace_back();
// Add codecs, which any stream is prepared to receive.
for (const VideoCodec& codec : recv_params_.codecs) {
for (const Codec& codec : recv_params_.codecs) {
rtp_params.codecs.push_back(codec.ToCodecParameters());
}
@ -2690,7 +2689,7 @@ bool WebRtcVideoReceiveChannel::GetChangedReceiverParameters(
// Verify that every mapped codec is supported locally.
if (params.is_stream_active) {
const std::vector<VideoCodec> local_supported_codecs =
const std::vector<Codec> local_supported_codecs =
GetPayloadTypesAndDefaultCodecs(decoder_factory_,
/*is_decoder_factory=*/true,
/*include_rtx=*/true, call_->trials());
@ -3041,7 +3040,7 @@ void WebRtcVideoReceiveChannel::FillReceiveCodecStats(
VideoMediaReceiveInfo* video_media_info) {
for (const auto& receiver : video_media_info->receivers) {
auto codec =
absl::c_find_if(recv_params_.codecs, [&receiver](const VideoCodec& c) {
absl::c_find_if(recv_params_.codecs, [&receiver](const Codec& c) {
return receiver.codec_payload_type &&
*receiver.codec_payload_type == c.id;
});
@ -3911,7 +3910,7 @@ void WebRtcVideoReceiveChannel::SetDepacketizerToDecoderFrameTransformer(
// ------------------------- VideoCodecSettings --------------------
VideoCodecSettings::VideoCodecSettings(const VideoCodec& codec)
VideoCodecSettings::VideoCodecSettings(const Codec& codec)
: codec(codec), flexfec_payload_type(-1), rtx_payload_type(-1) {}
bool VideoCodecSettings::operator==(const VideoCodecSettings& other) const {

20
media/engine/webrtc_video_engine.h
View file

@ -116,14 +116,10 @@ class WebRtcVideoEngine : public VideoEngineInterface {
const VideoOptions& options,
const webrtc::CryptoOptions& crypto_options) override;
std::vector<VideoCodec> send_codecs() const override {
return send_codecs(true);
}
std::vector<VideoCodec> recv_codecs() const override {
return recv_codecs(true);
}
std::vector<VideoCodec> send_codecs(bool include_rtx) const override;
std::vector<VideoCodec> recv_codecs(bool include_rtx) const override;
std::vector<Codec> send_codecs() const override { return send_codecs(true); }
std::vector<Codec> recv_codecs() const override { return recv_codecs(true); }
std::vector<Codec> send_codecs(bool include_rtx) const override;
std::vector<Codec> recv_codecs(bool include_rtx) const override;
std::vector<webrtc::RtpHeaderExtensionCapability> GetRtpHeaderExtensions()
const override;
@ -136,7 +132,7 @@ class WebRtcVideoEngine : public VideoEngineInterface {
};
struct VideoCodecSettings {
explicit VideoCodecSettings(const VideoCodec& codec);
explicit VideoCodecSettings(const Codec& codec);
// Checks if all members of |*this| are equal to the corresponding members
// of `other`.
@ -148,7 +144,7 @@ struct VideoCodecSettings {
static bool EqualsDisregardingFlexfec(const VideoCodecSettings& a,
const VideoCodecSettings& b);
VideoCodec codec;
Codec codec;
webrtc::UlpfecConfig ulpfec;
int flexfec_payload_type; // -1 if absent.
int rtx_payload_type; // -1 if absent.
@ -391,11 +387,11 @@ class WebRtcVideoSendChannel : public MediaChannelUtil,
};
rtc::scoped_refptr<webrtc::VideoEncoderConfig::EncoderSpecificSettings>
ConfigureVideoEncoderSettings(const VideoCodec& codec);
ConfigureVideoEncoderSettings(const Codec& codec);
void SetCodec(const VideoCodecSettings& codec);
void RecreateWebRtcStream();
webrtc::VideoEncoderConfig CreateVideoEncoderConfig(
const VideoCodec& codec) const;
const Codec& codec) const;
void ReconfigureEncoder(webrtc::SetParametersCallback callback);
// Calls Start or Stop according to whether or not `sending_` is true.

164
media/engine/webrtc_video_engine_unittest.cc
View file

@ -137,12 +137,12 @@ constexpr size_t kNumSimulcastStreams = 3;
static const char kUnsupportedExtensionName[] =
"urn:ietf:params:rtp-hdrext:unsupported";
cricket::VideoCodec RemoveFeedbackParams(cricket::VideoCodec&& codec) {
cricket::Codec RemoveFeedbackParams(cricket::Codec&& codec) {
codec.feedback_params = cricket::FeedbackParams();
return std::move(codec);
}
void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec,
void VerifyCodecHasDefaultFeedbackParams(const cricket::Codec& codec,
bool lntf_expected) {
EXPECT_EQ(lntf_expected,
codec.HasFeedbackParam(cricket::FeedbackParam(
@ -161,9 +161,8 @@ void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec,
// Return true if any codec in `codecs` is an RTX codec with associated
// payload type `payload_type`.
bool HasRtxCodec(const std::vector<cricket::VideoCodec>& codecs,
int payload_type) {
for (const cricket::VideoCodec& codec : codecs) {
bool HasRtxCodec(const std::vector<cricket::Codec>& codecs, int payload_type) {
for (const cricket::Codec& codec : codecs) {
int associated_payload_type;
if (absl::EqualsIgnoreCase(codec.name.c_str(), "rtx") &&
codec.GetParam(cricket::kCodecParamAssociatedPayloadType,
@ -177,8 +176,8 @@ bool HasRtxCodec(const std::vector<cricket::VideoCodec>& codecs,
// Return true if any codec in `codecs` is an RTX codec, independent of
// payload type.
bool HasAnyRtxCodec(const std::vector<cricket::VideoCodec>& codecs) {
for (const cricket::VideoCodec& codec : codecs) {
bool HasAnyRtxCodec(const std::vector<cricket::Codec>& codecs) {
for (const cricket::Codec& codec : codecs) {
if (absl::EqualsIgnoreCase(codec.name.c_str(), "rtx")) {
return true;
}
@ -381,7 +380,7 @@ class WebRtcVideoEngineTest : public ::testing::Test {
// Find the codec in the engine with the given name. The codec must be
// present.
cricket::VideoCodec GetEngineCodec(const std::string& name) const;
cricket::Codec GetEngineCodec(const std::string& name) const;
void AddSupportedVideoCodecType(
const std::string& name,
const std::vector<webrtc::ScalabilityMode>& scalability_modes = {});
@ -391,7 +390,7 @@ class WebRtcVideoEngineTest : public ::testing::Test {
std::unique_ptr<VideoMediaReceiveChannelInterface>
SetRecvParamsWithAllSupportedCodecs();
std::unique_ptr<VideoMediaReceiveChannelInterface>
SetRecvParamsWithSupportedCodecs(const std::vector<VideoCodec>& codecs);
SetRecvParamsWithSupportedCodecs(const std::vector<Codec>& codecs);
void ExpectRtpCapabilitySupport(const char* uri, bool supported) const;
@ -406,7 +405,7 @@ class WebRtcVideoEngineTest : public ::testing::Test {
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory_;
WebRtcVideoEngine engine_;
absl::optional<VideoCodec> default_codec_;
absl::optional<Codec> default_codec_;
std::map<int, int> default_apt_rtx_types_;
};
@ -414,7 +413,7 @@ TEST_F(WebRtcVideoEngineTest, DefaultRtxCodecHasAssociatedPayloadTypeSet) {
encoder_factory_->AddSupportedVideoCodecType("VP8");
AssignDefaultCodec();
std::vector<VideoCodec> engine_codecs = engine_.send_codecs();
std::vector<Codec> engine_codecs = engine_.send_codecs();
for (size_t i = 0; i < engine_codecs.size(); ++i) {
if (engine_codecs[i].name != kRtxCodecName)
continue;
@ -717,7 +716,7 @@ TEST_F(WebRtcVideoEngineTest, RtxCodecAddedForH264Codec) {
encoder_factory_->AddSupportedVideoCodec(h264_high);
// First figure out what payload types the test codecs got assigned.
const std::vector<cricket::VideoCodec> codecs = engine_.send_codecs();
const std::vector<cricket::Codec> codecs = engine_.send_codecs();
// Now search for RTX codecs for them. Expect that they all have associated
// RTX codecs.
EXPECT_TRUE(HasRtxCodec(
@ -799,9 +798,9 @@ TEST_F(WebRtcVideoEngineTest, PropagatesInputFrameTimestamp) {
}
void WebRtcVideoEngineTest::AssignDefaultAptRtxTypes() {
std::vector<VideoCodec> engine_codecs = engine_.send_codecs();
std::vector<Codec> engine_codecs = engine_.send_codecs();
RTC_DCHECK(!engine_codecs.empty());
for (const cricket::VideoCodec& codec : engine_codecs) {
for (const cricket::Codec& codec : engine_codecs) {
if (codec.name == "rtx") {
int associated_payload_type;
if (codec.GetParam(kCodecParamAssociatedPayloadType,
@ -813,10 +812,10 @@ void WebRtcVideoEngineTest::AssignDefaultAptRtxTypes() {
}
void WebRtcVideoEngineTest::AssignDefaultCodec() {
std::vector<VideoCodec> engine_codecs = engine_.send_codecs();
std::vector<Codec> engine_codecs = engine_.send_codecs();
RTC_DCHECK(!engine_codecs.empty());
bool codec_set = false;
for (const cricket::VideoCodec& codec : engine_codecs) {
for (const cricket::Codec& codec : engine_codecs) {
if (!codec_set && codec.name != "rtx" && codec.name != "red" &&
codec.name != "ulpfec" && codec.name != "flexfec-03") {
default_codec_ = codec;
@ -829,9 +828,9 @@ void WebRtcVideoEngineTest::AssignDefaultCodec() {
size_t WebRtcVideoEngineTest::GetEngineCodecIndex(
const std::string& name) const {
const std::vector<cricket::VideoCodec> codecs = engine_.send_codecs();
const std::vector<cricket::Codec> codecs = engine_.send_codecs();
for (size_t i = 0; i < codecs.size(); ++i) {
const cricket::VideoCodec engine_codec = codecs[i];
const cricket::Codec engine_codec = codecs[i];
if (!absl::EqualsIgnoreCase(name, engine_codec.name))
continue;
// The tests only use H264 Constrained Baseline. Make sure we don't return
@ -851,7 +850,7 @@ size_t WebRtcVideoEngineTest::GetEngineCodecIndex(
return -1;
}
cricket::VideoCodec WebRtcVideoEngineTest::GetEngineCodec(
cricket::Codec WebRtcVideoEngineTest::GetEngineCodec(
const std::string& name) const {
return engine_.send_codecs()[GetEngineCodecIndex(name)];
}
@ -873,7 +872,7 @@ WebRtcVideoEngineTest::SetSendParamsWithAllSupportedCodecs() {
// We need to look up the codec in the engine to get the correct payload type.
for (const webrtc::SdpVideoFormat& format :
encoder_factory_->GetSupportedFormats()) {
cricket::VideoCodec engine_codec = GetEngineCodec(format.name);
cricket::Codec engine_codec = GetEngineCodec(format.name);
if (!absl::c_linear_search(parameters.codecs, engine_codec)) {
parameters.codecs.push_back(engine_codec);
}
@ -886,7 +885,7 @@ WebRtcVideoEngineTest::SetSendParamsWithAllSupportedCodecs() {
std::unique_ptr<VideoMediaReceiveChannelInterface>
WebRtcVideoEngineTest::SetRecvParamsWithSupportedCodecs(
const std::vector<VideoCodec>& codecs) {
const std::vector<Codec>& codecs) {
std::unique_ptr<VideoMediaReceiveChannelInterface> channel =
engine_.CreateReceiveChannel(call_.get(), GetMediaConfig(),
VideoOptions(), webrtc::CryptoOptions());
@ -899,10 +898,10 @@ WebRtcVideoEngineTest::SetRecvParamsWithSupportedCodecs(
std::unique_ptr<VideoMediaReceiveChannelInterface>
WebRtcVideoEngineTest::SetRecvParamsWithAllSupportedCodecs() {
std::vector<VideoCodec> codecs;
std::vector<Codec> codecs;
for (const webrtc::SdpVideoFormat& format :
decoder_factory_->GetSupportedFormats()) {
cricket::VideoCodec engine_codec = GetEngineCodec(format.name);
cricket::Codec engine_codec = GetEngineCodec(format.name);
if (!absl::c_linear_search(codecs, engine_codec)) {
codecs.push_back(engine_codec);
}
@ -965,7 +964,7 @@ TEST_F(WebRtcVideoEngineTest, UpdatesUnsignaledRtxSsrcAndRecoversPayload) {
// Setup a channel with VP8, RTX and transport sequence number header
// extension. Receive stream is not explicitly configured.
AddSupportedVideoCodecType("VP8");
std::vector<VideoCodec> supported_codecs =
std::vector<Codec> supported_codecs =
engine_.recv_codecs(/*include_rtx=*/true);
ASSERT_EQ(supported_codecs[1].name, "rtx");
int rtx_payload_type = supported_codecs[1].id;
@ -1192,7 +1191,7 @@ TEST_F(WebRtcVideoEngineTest, SimulcastEnabledForH264) {
TEST_F(WebRtcVideoEngineTest, Flexfec03SendCodecEnablesWithFieldTrial) {
encoder_factory_->AddSupportedVideoCodecType("VP8");
auto flexfec = Field("name", &VideoCodec::name, "flexfec-03");
auto flexfec = Field("name", &Codec::name, "flexfec-03");
EXPECT_THAT(engine_.send_codecs(), Not(Contains(flexfec)));
@ -1205,16 +1204,15 @@ TEST_F(WebRtcVideoEngineTest, Flexfec03SendCodecEnablesWithFieldTrial) {
TEST_F(WebRtcVideoEngineTest, Flexfec03LowerPayloadTypeRange) {
encoder_factory_->AddSupportedVideoCodecType("VP8");
auto flexfec = Field("name", &VideoCodec::name, "flexfec-03");
auto flexfec = Field("name", &Codec::name, "flexfec-03");
// FlexFEC is active with field trial.
webrtc::test::ScopedKeyValueConfig override_field_trials(
field_trials_, "WebRTC-FlexFEC-03-Advertised/Enabled/");
auto send_codecs = engine_.send_codecs();
auto it = std::find_if(send_codecs.begin(), send_codecs.end(),
[](const cricket::VideoCodec& codec) {
return codec.name == "flexfec-03";
});
auto it = std::find_if(
send_codecs.begin(), send_codecs.end(),
[](const cricket::Codec& codec) { return codec.name == "flexfec-03"; });
ASSERT_NE(it, send_codecs.end());
EXPECT_LE(35, it->id);
EXPECT_GE(65, it->id);
@ -1241,11 +1239,11 @@ TEST_F(WebRtcVideoEngineTest, ReportSupportedAddedCodec) {
// Set up external encoder factory with first codec, and initialize engine.
encoder_factory_->AddSupportedVideoCodecType(kFakeExternalCodecName1);
std::vector<cricket::VideoCodec> codecs_before(engine_.send_codecs());
std::vector<cricket::Codec> codecs_before(engine_.send_codecs());
// Add second codec.
encoder_factory_->AddSupportedVideoCodecType(kFakeExternalCodecName2);
std::vector<cricket::VideoCodec> codecs_after(engine_.send_codecs());
std::vector<cricket::Codec> codecs_after(engine_.send_codecs());
// The codec itself and RTX should have been added.
EXPECT_EQ(codecs_before.size() + 2, codecs_after.size());
@ -1293,7 +1291,7 @@ TEST_F(WebRtcVideoEngineTest, RegisterH264DecoderIfSupported) {
// For now we add a FakeWebRtcVideoEncoderFactory to add H264 to supported
// codecs.
AddSupportedVideoCodecType("H264");
std::vector<cricket::VideoCodec> codecs;
std::vector<cricket::Codec> codecs;
codecs.push_back(GetEngineCodec("H264"));
auto receive_channel = SetRecvParamsWithSupportedCodecs(codecs);
@ -1382,7 +1380,7 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, Vp8) {
.WillRepeatedly(Return(supported_formats));
// Verify the codecs from the engine.
const std::vector<VideoCodec> engine_codecs = engine.send_codecs();
const std::vector<Codec> engine_codecs = engine.send_codecs();
// Verify default codecs has been added correctly.
EXPECT_EQ(5u, engine_codecs.size());
EXPECT_EQ("VP8", engine_codecs.at(0).name);
@ -1481,7 +1479,7 @@ TEST_F(WebRtcVideoEngineTest, DISABLED_RecreatesEncoderOnContentTypeChange) {
ASSERT_TRUE(
send_channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
cricket::VideoCodec codec = GetEngineCodec("VP8");
cricket::Codec codec = GetEngineCodec("VP8");
cricket::VideoSenderParameters parameters;
parameters.codecs.push_back(codec);
send_channel->OnReadyToSend(true);
@ -1536,8 +1534,8 @@ TEST_F(WebRtcVideoEngineTest, DISABLED_RecreatesEncoderOnContentTypeChange) {
TEST_F(WebRtcVideoEngineTest, SetVideoRtxEnabled) {
AddSupportedVideoCodecType("VP8");
std::vector<VideoCodec> send_codecs;
std::vector<VideoCodec> recv_codecs;
std::vector<Codec> send_codecs;
std::vector<Codec> recv_codecs;
webrtc::test::ScopedKeyValueConfig field_trials;
@ -1831,7 +1829,7 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test {
bool SetDefaultCodec() { return SetOneCodec(DefaultCodec()); }
bool SetOneCodec(const cricket::VideoCodec& codec) {
bool SetOneCodec(const cricket::Codec& codec) {
frame_source_ = std::make_unique<cricket::FakeFrameSource>(
kVideoWidth, kVideoHeight, rtc::kNumMicrosecsPerSec / kFramerate);
@ -1879,7 +1877,7 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test {
}
// Tests that we can send and receive frames.
void SendAndReceive(const cricket::VideoCodec& codec) {
void SendAndReceive(const cricket::Codec& codec) {
EXPECT_TRUE(SetOneCodec(codec));
EXPECT_TRUE(SetSend(true));
receive_channel_->SetDefaultSink(&renderer_);
@ -1889,7 +1887,7 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test {
EXPECT_EQ(codec.id, GetPayloadType(GetRtpPacket(0)));
}
void SendReceiveManyAndGetStats(const cricket::VideoCodec& codec,
void SendReceiveManyAndGetStats(const cricket::Codec& codec,
int duration_sec,
int fps) {
EXPECT_TRUE(SetOneCodec(codec));
@ -1920,7 +1918,7 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test {
// Two streams one channel tests.
// Tests that we can send and receive frames.
void TwoStreamsSendAndReceive(const cricket::VideoCodec& codec) {
void TwoStreamsSendAndReceive(const cricket::Codec& codec) {
SetUpSecondStream();
// Test sending and receiving on first stream.
SendAndReceive(codec);
@ -1929,8 +1927,8 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test {
EXPECT_GT(NumRtpPackets(), 0);
}
cricket::VideoCodec GetEngineCodec(const std::string& name) {
for (const cricket::VideoCodec& engine_codec : engine_.send_codecs()) {
cricket::Codec GetEngineCodec(const std::string& name) {
for (const cricket::Codec& engine_codec : engine_.send_codecs()) {
if (absl::EqualsIgnoreCase(name, engine_codec.name))
return engine_codec;
}
@ -1939,7 +1937,7 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test {
return cricket::CreateVideoCodec(0, "");
}
cricket::VideoCodec DefaultCodec() { return GetEngineCodec("VP8"); }
cricket::Codec DefaultCodec() { return GetEngineCodec("VP8"); }
cricket::StreamParams DefaultSendStreamParams() {
return cricket::StreamParams::CreateLegacy(kSsrc);
@ -2303,12 +2301,12 @@ TEST_F(WebRtcVideoChannelBaseTest, SimulateConference) {
// Tests that we can add and remove capturers and frames are sent out properly
TEST_F(WebRtcVideoChannelBaseTest, DISABLED_AddRemoveCapturer) {
using cricket::Codec;
using cricket::FOURCC_I420;
using cricket::VideoCodec;
using cricket::VideoFormat;
using cricket::VideoOptions;
VideoCodec codec = DefaultCodec();
Codec codec = DefaultCodec();
const int time_between_send_ms = VideoFormat::FpsToInterval(kFramerate);
EXPECT_TRUE(SetOneCodec(codec));
EXPECT_TRUE(SetSend(true));
@ -2495,7 +2493,7 @@ TEST_F(WebRtcVideoChannelBaseTest, TwoStreamsSendAndReceive) {
// initially will use QVGA instead of VGA.
// TODO(pbos): Set up the quality scaler so that both senders reliably start
// at QVGA, then verify that instead.
cricket::VideoCodec codec = GetEngineCodec("VP8");
cricket::Codec codec = GetEngineCodec("VP8");
codec.params[kCodecParamStartBitrate] = "1000000";
TwoStreamsSendAndReceive(codec);
}
@ -2508,7 +2506,7 @@ TEST_F(WebRtcVideoChannelBaseTest, RequestEncoderFallback) {
parameters.codecs.push_back(GetEngineCodec("VP8"));
EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
absl::optional<VideoCodec> codec = send_channel_->GetSendCodec();
absl::optional<Codec> codec = send_channel_->GetSendCodec();
ASSERT_TRUE(codec);
EXPECT_EQ("VP9", codec->name);
@ -2534,7 +2532,7 @@ TEST_F(WebRtcVideoChannelBaseTest, RequestEncoderSwitchDefaultFallback) {
parameters.codecs.push_back(GetEngineCodec("VP8"));
EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
absl::optional<VideoCodec> codec = send_channel_->GetSendCodec();
absl::optional<Codec> codec = send_channel_->GetSendCodec();
ASSERT_TRUE(codec);
EXPECT_EQ("VP9", codec->name);
@ -2552,7 +2550,7 @@ TEST_F(WebRtcVideoChannelBaseTest, RequestEncoderSwitchDefaultFallback) {
}
TEST_F(WebRtcVideoChannelBaseTest, RequestEncoderSwitchStrictPreference) {
VideoCodec vp9 = GetEngineCodec("VP9");
Codec vp9 = GetEngineCodec("VP9");
vp9.params["profile-id"] = "0";
cricket::VideoSenderParameters parameters;
@ -2560,7 +2558,7 @@ TEST_F(WebRtcVideoChannelBaseTest, RequestEncoderSwitchStrictPreference) {
parameters.codecs.push_back(vp9);
EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
absl::optional<VideoCodec> codec = send_channel_->GetSendCodec();
absl::optional<Codec> codec = send_channel_->GetSendCodec();
ASSERT_TRUE(codec);
EXPECT_EQ("VP8", codec->name);
@ -2674,8 +2672,8 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest {
return static_cast<cricket::WebRtcVideoSendChannel*>(channel)->transport();
}
cricket::VideoCodec GetEngineCodec(const std::string& name) {
for (const cricket::VideoCodec& engine_codec : engine_.send_codecs()) {
cricket::Codec GetEngineCodec(const std::string& name) {
for (const cricket::Codec& engine_codec : engine_.send_codecs()) {
if (absl::EqualsIgnoreCase(name, engine_codec.name))
return engine_codec;
}
@ -2684,7 +2682,7 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest {
return cricket::CreateVideoCodec(0, "");
}
cricket::VideoCodec DefaultCodec() { return GetEngineCodec("VP8"); }
cricket::Codec DefaultCodec() { return GetEngineCodec("VP8"); }
// After receciving and processing the packet, enough time is advanced that
// the unsignalled receive stream cooldown is no longer in effect.
@ -3425,7 +3423,7 @@ TEST_F(WebRtcVideoChannelTest, ReconfiguresEncodersWhenNotSending) {
TEST_F(WebRtcVideoChannelTest, UsesCorrectSettingsForScreencast) {
static const int kScreenshareMinBitrateKbps = 800;
cricket::VideoCodec codec = GetEngineCodec("VP8");
cricket::Codec codec = GetEngineCodec("VP8");
cricket::VideoSenderParameters parameters;
parameters.codecs.push_back(codec);
EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
@ -4126,7 +4124,7 @@ TEST_F(WebRtcVideoChannelTest, DoesNotAdaptOnOveruseWhenScreensharing) {
}
TEST_F(WebRtcVideoChannelTest, PreviousAdaptationDoesNotApplyToScreenshare) {
cricket::VideoCodec codec = GetEngineCodec("VP8");
cricket::Codec codec = GetEngineCodec("VP8");
cricket::VideoSenderParameters parameters;
parameters.codecs.push_back(codec);
@ -4180,7 +4178,7 @@ TEST_F(WebRtcVideoChannelTest, PreviousAdaptationDoesNotApplyToScreenshare) {
void WebRtcVideoChannelTest::TestDegradationPreference(
bool resolution_scaling_enabled,
bool fps_scaling_enabled) {
cricket::VideoCodec codec = GetEngineCodec("VP8");
cricket::Codec codec = GetEngineCodec("VP8");
cricket::VideoSenderParameters parameters;
parameters.codecs.push_back(codec);
@ -4214,7 +4212,7 @@ void WebRtcVideoChannelTest::TestDegradationPreference(
void WebRtcVideoChannelTest::TestCpuAdaptation(bool enable_overuse,
bool is_screenshare) {
cricket::VideoCodec codec = GetEngineCodec("VP8");
cricket::Codec codec = GetEngineCodec("VP8");
cricket::VideoSenderParameters parameters;
parameters.codecs.push_back(codec);
@ -4305,7 +4303,7 @@ TEST_F(WebRtcVideoChannelTest, SetDefaultSendCodecs) {
AssignDefaultAptRtxTypes();
ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters_));
absl::optional<VideoCodec> codec = send_channel_->GetSendCodec();
absl::optional<Codec> codec = send_channel_->GetSendCodec();
ASSERT_TRUE(codec);
EXPECT_TRUE(codec->Matches(engine_.send_codecs()[0]));
@ -4534,7 +4532,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, DuplicateFlexfecCodecIsDropped) {
cricket::VideoReceiverParameters recv_parameters;
recv_parameters.codecs.push_back(GetEngineCodec("VP8"));
recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
cricket::VideoCodec duplicate = GetEngineCodec("flexfec-03");
cricket::Codec duplicate = GetEngineCodec("flexfec-03");
duplicate.id = kUnusedPayloadType1;
recv_parameters.codecs.push_back(duplicate);
ASSERT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters));
@ -4677,7 +4675,7 @@ TEST_F(WebRtcVideoChannelTest,
EXPECT_FALSE(FindCodecById(engine_.send_codecs(), kUnusedPayloadType));
cricket::VideoSenderParameters parameters;
cricket::VideoCodec rtx_codec =
cricket::Codec rtx_codec =
cricket::CreateVideoCodec(kUnusedPayloadType, "rtx");
parameters.codecs.push_back(rtx_codec);
EXPECT_FALSE(send_channel_->SetSenderParameters(parameters))
@ -4691,7 +4689,7 @@ TEST_F(WebRtcVideoChannelTest,
EXPECT_FALSE(FindCodecById(engine_.send_codecs(), kUnusedPayloadType1));
EXPECT_FALSE(FindCodecById(engine_.send_codecs(), kUnusedPayloadType2));
{
cricket::VideoCodec rtx_codec = cricket::CreateVideoRtxCodec(
cricket::Codec rtx_codec = cricket::CreateVideoRtxCodec(
kUnusedPayloadType1, GetEngineCodec("VP8").id);
cricket::VideoSenderParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
@ -4699,7 +4697,7 @@ TEST_F(WebRtcVideoChannelTest,
ASSERT_TRUE(send_channel_->SetSenderParameters(parameters));
}
{
cricket::VideoCodec rtx_codec =
cricket::Codec rtx_codec =
cricket::CreateVideoRtxCodec(kUnusedPayloadType1, kUnusedPayloadType2);
cricket::VideoSenderParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
@ -4724,7 +4722,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithChangedRtxPayloadType) {
// Original payload type for RTX.
cricket::VideoSenderParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
cricket::VideoCodec rtx_codec =
cricket::Codec rtx_codec =
cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx");
rtx_codec.SetParam("apt", GetEngineCodec("VP8").id);
parameters.codecs.push_back(rtx_codec);
@ -4794,7 +4792,7 @@ TEST_F(WebRtcVideoChannelFlexfecSendRecvTest,
TEST_F(WebRtcVideoChannelTest, SetSendCodecsChangesExistingStreams) {
cricket::VideoSenderParameters parameters;
cricket::VideoCodec codec = cricket::CreateVideoCodec(100, "VP8");
cricket::Codec codec = cricket::CreateVideoCodec(100, "VP8");
codec.SetParam(kCodecParamMaxQuantization, kDefaultVideoMaxQpVpx);
parameters.codecs.push_back(codec);
@ -5096,7 +5094,7 @@ TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithMaxQuantization) {
EXPECT_EQ(atoi(kMaxQuantization),
AddSendStream()->GetVideoStreams().back().max_qp);
absl::optional<VideoCodec> codec = send_channel_->GetSendCodec();
absl::optional<Codec> codec = send_channel_->GetSendCodec();
ASSERT_TRUE(codec);
EXPECT_EQ(kMaxQuantization, codec->params[kCodecParamMaxQuantization]);
}
@ -5158,7 +5156,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithRtx) {
cricket::VideoReceiverParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
cricket::VideoCodec rtx_codec =
cricket::Codec rtx_codec =
cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx");
parameters.codecs.push_back(rtx_codec);
EXPECT_FALSE(receive_channel_->SetReceiverParameters(parameters))
@ -5171,7 +5169,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithRtx) {
parameters.codecs[1].SetParam("apt", GetEngineCodec("VP8").id);
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
cricket::VideoCodec rtx_codec2 =
cricket::Codec rtx_codec2 =
cricket::CreateVideoCodec(kUnusedPayloadType2, "rtx");
rtx_codec2.SetParam("apt", rtx_codec.id);
parameters.codecs.push_back(rtx_codec2);
@ -5182,7 +5180,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithRtx) {
}
TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithPacketization) {
cricket::VideoCodec vp8_codec = GetEngineCodec("VP8");
cricket::Codec vp8_codec = GetEngineCodec("VP8");
vp8_codec.packetization = kPacketizationParamRaw;
cricket::VideoReceiverParameters parameters;
@ -5266,7 +5264,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithChangedRtxPayloadType) {
// Original payload type for RTX.
cricket::VideoReceiverParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
cricket::VideoCodec rtx_codec =
cricket::Codec rtx_codec =
cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx");
rtx_codec.SetParam("apt", GetEngineCodec("VP8").id);
parameters.codecs.push_back(rtx_codec);
@ -5310,7 +5308,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRtxWithRtxTime) {
// Payload type for RTX.
cricket::VideoReceiverParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
cricket::VideoCodec rtx_codec =
cricket::Codec rtx_codec =
cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx");
rtx_codec.SetParam("apt", GetEngineCodec("VP8").id);
parameters.codecs.push_back(rtx_codec);
@ -7376,8 +7374,8 @@ void WebRtcVideoChannelTest::TestReceiveUnsignaledSsrcPacket(
EXPECT_FALSE(FindCodecById(engine_.recv_codecs(), kRedRtxPayloadType));
// Add a RED RTX codec.
VideoCodec red_rtx_codec = cricket::CreateVideoRtxCodec(
kRedRtxPayloadType, GetEngineCodec("red").id);
Codec red_rtx_codec = cricket::CreateVideoRtxCodec(kRedRtxPayloadType,
GetEngineCodec("red").id);
recv_parameters_.codecs.push_back(red_rtx_codec);
EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_));
@ -7422,7 +7420,7 @@ TEST_F(WebRtcVideoChannelTest, Vp9PacketCreatesUnsignalledStream) {
TEST_F(WebRtcVideoChannelTest, RtxPacketDoesntCreateUnsignalledStream) {
AssignDefaultAptRtxTypes();
const cricket::VideoCodec vp8 = GetEngineCodec("VP8");
const cricket::Codec vp8 = GetEngineCodec("VP8");
const int rtx_vp8_payload_type = default_apt_rtx_types_[vp8.id];
TestReceiveUnsignaledSsrcPacket(rtx_vp8_payload_type,
false /* expect_created_receive_stream */);
@ -7446,7 +7444,7 @@ TEST_F(WebRtcVideoChannelTest, RedRtxPacketDoesntCreateUnsignalledStream) {
TEST_F(WebRtcVideoChannelTest, RtxAfterMediaPacketUpdatesUnsignalledRtxSsrc) {
AssignDefaultAptRtxTypes();
const cricket::VideoCodec vp8 = GetEngineCodec("VP8");
const cricket::Codec vp8 = GetEngineCodec("VP8");
const int payload_type = vp8.id;
const int rtx_vp8_payload_type = default_apt_rtx_types_[vp8.id];
const uint32_t ssrc = kIncomingUnsignalledSsrc;
@ -7481,7 +7479,7 @@ TEST_F(WebRtcVideoChannelTest, RtxAfterMediaPacketUpdatesUnsignalledRtxSsrc) {
TEST_F(WebRtcVideoChannelTest, UnsignaledStreamCreatedAfterMediaPacket) {
AssignDefaultAptRtxTypes();
const cricket::VideoCodec vp8 = GetEngineCodec("VP8");
const cricket::Codec vp8 = GetEngineCodec("VP8");
const int payload_type = vp8.id;
const int rtx_vp8_payload_type = default_apt_rtx_types_[vp8.id];
const uint32_t ssrc = kIncomingUnsignalledSsrc;
@ -7519,7 +7517,7 @@ TEST_F(WebRtcVideoChannelTest, ReceiveDifferentUnsignaledSsrc) {
parameters.codecs.push_back(GetEngineCodec("VP9"));
#if defined(WEBRTC_USE_H264)
cricket::VideoCodec H264codec = cricket::CreateVideoCodec(126, "H264");
cricket::Codec H264codec = cricket::CreateVideoCodec(126, "H264");
parameters.codecs.push_back(H264codec);
#endif
@ -9197,10 +9195,10 @@ TEST_F(WebRtcVideoChannelTest, GetRtpReceiveFmtpSprop) {
TEST_F(WebRtcVideoChannelTest, DISABLED_GetRtpReceiveFmtpSprop) {
#endif
cricket::VideoReceiverParameters parameters;
cricket::VideoCodec kH264sprop1 = cricket::CreateVideoCodec(101, "H264");
cricket::Codec kH264sprop1 = cricket::CreateVideoCodec(101, "H264");
kH264sprop1.SetParam(kH264FmtpSpropParameterSets, "uvw");
parameters.codecs.push_back(kH264sprop1);
cricket::VideoCodec kH264sprop2 = cricket::CreateVideoCodec(102, "H264");
cricket::Codec kH264sprop2 = cricket::CreateVideoCodec(102, "H264");
kH264sprop2.SetParam(kH264FmtpSpropParameterSets, "xyz");
parameters.codecs.push_back(kH264sprop2);
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
@ -9303,7 +9301,7 @@ TEST_F(WebRtcVideoChannelTest,
AddReceiveStreamAfterReceivingNonPrimaryUnsignaledSsrc) {
// Receive VP8 RTX packet.
RtpPacketReceived rtp_packet;
const cricket::VideoCodec vp8 = GetEngineCodec("VP8");
const cricket::Codec vp8 = GetEngineCodec("VP8");
rtp_packet.SetPayloadType(default_apt_rtx_types_[vp8.id]);
rtp_packet.SetSsrc(2);
ReceivePacketAndAdvanceTime(rtp_packet);
@ -9515,7 +9513,7 @@ class WebRtcVideoChannelSimulcastTest : public ::testing::Test {
}
protected:
void VerifySimulcastSettings(const VideoCodec& codec,
void VerifySimulcastSettings(const Codec& codec,
int capture_width,
int capture_height,
size_t num_configured_streams,
@ -9753,7 +9751,7 @@ TEST_F(WebRtcVideoChannelTest, SetsRidsOnSendStream) {
}
TEST_F(WebRtcVideoChannelBaseTest, EncoderSelectorSwitchCodec) {
VideoCodec vp9 = GetEngineCodec("VP9");
Codec vp9 = GetEngineCodec("VP9");
cricket::VideoSenderParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
@ -9761,7 +9759,7 @@ TEST_F(WebRtcVideoChannelBaseTest, EncoderSelectorSwitchCodec) {
EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
send_channel_->SetSend(true);
absl::optional<VideoCodec> codec = send_channel_->GetSendCodec();
absl::optional<Codec> codec = send_channel_->GetSendCodec();
ASSERT_TRUE(codec);
EXPECT_EQ("VP8", codec->name);

52
media/engine/webrtc_voice_engine.cc
View file

@ -127,7 +127,7 @@ bool ValidateStreamParams(const StreamParams& sp) {
}
// Dumps an AudioCodec in RFC 2327-ish format.
std::string ToString(const AudioCodec& codec) {
std::string ToString(const Codec& codec) {
rtc::StringBuilder ss;
ss << codec.name << "/" << codec.clockrate << "/" << codec.channels;
if (!codec.params.empty()) {
@ -141,13 +141,13 @@ std::string ToString(const AudioCodec& codec) {
return ss.Release();
}
bool IsCodec(const AudioCodec& codec, const char* ref_name) {
bool IsCodec(const Codec& codec, const char* ref_name) {
return absl::EqualsIgnoreCase(codec.name, ref_name);
}
absl::optional<AudioCodec> FindCodec(const std::vector<AudioCodec>& codecs,
const AudioCodec& codec) {
for (const AudioCodec& c : codecs) {
absl::optional<Codec> FindCodec(const std::vector<Codec>& codecs,
const Codec& codec) {
for (const Codec& c : codecs) {
if (c.Matches(codec)) {
return c;
}
@ -155,13 +155,13 @@ absl::optional<AudioCodec> FindCodec(const std::vector<AudioCodec>& codecs,
return absl::nullopt;
}
bool VerifyUniquePayloadTypes(const std::vector<AudioCodec>& codecs) {
bool VerifyUniquePayloadTypes(const std::vector<Codec>& codecs) {
if (codecs.empty()) {
return true;
}
std::vector<int> payload_types;
absl::c_transform(codecs, std::back_inserter(payload_types),
[](const AudioCodec& codec) { return codec.id; });
[](const Codec& codec) { return codec.id; });
absl::c_sort(payload_types);
return absl::c_adjacent_find(payload_types) == payload_types.end();
}
@ -302,7 +302,7 @@ webrtc::AudioReceiveStreamInterface::Config BuildReceiveStreamConfig(
// Utility function to check if RED codec and its parameters match a codec spec.
bool CheckRedParameters(
const AudioCodec& red_codec,
const Codec& red_codec,
const webrtc::AudioSendStream::Config::SendCodecSpec& send_codec_spec) {
if (red_codec.clockrate != send_codec_spec.format.clockrate_hz ||
red_codec.channels != send_codec_spec.format.num_channels) {
@ -383,13 +383,13 @@ void WebRtcVoiceEngine::Init() {
// Load our audio codec lists.
RTC_LOG(LS_VERBOSE) << "Supported send codecs in order of preference:";
send_codecs_ = CollectCodecs(encoder_factory_->GetSupportedEncoders());
for (const AudioCodec& codec : send_codecs_) {
for (const Codec& codec : send_codecs_) {
RTC_LOG(LS_VERBOSE) << ToString(codec);
}
RTC_LOG(LS_VERBOSE) << "Supported recv codecs in order of preference:";
recv_codecs_ = CollectCodecs(decoder_factory_->GetSupportedDecoders());
for (const AudioCodec& codec : recv_codecs_) {
for (const Codec& codec : recv_codecs_) {
RTC_LOG(LS_VERBOSE) << ToString(codec);
}
@ -629,12 +629,12 @@ void WebRtcVoiceEngine::ApplyOptions(const AudioOptions& options_in) {
ap->ApplyConfig(apm_config);
}
const std::vector<AudioCodec>& WebRtcVoiceEngine::send_codecs() const {
const std::vector<Codec>& WebRtcVoiceEngine::send_codecs() const {
RTC_DCHECK(signal_thread_checker_.IsCurrent());
return send_codecs_;
}
const std::vector<AudioCodec>& WebRtcVoiceEngine::recv_codecs() const {
const std::vector<Codec>& WebRtcVoiceEngine::recv_codecs() const {
RTC_DCHECK(signal_thread_checker_.IsCurrent());
return recv_codecs_;
}
@ -707,10 +707,10 @@ webrtc::AudioState* WebRtcVoiceEngine::audio_state() {
return audio_state_.get();
}
std::vector<AudioCodec> WebRtcVoiceEngine::CollectCodecs(
std::vector<Codec> WebRtcVoiceEngine::CollectCodecs(
const std::vector<webrtc::AudioCodecSpec>& specs) const {
PayloadTypeMapper mapper;
std::vector<AudioCodec> out;
std::vector<Codec> out;
// Only generate CN payload types for these clockrates:
std::map<int, bool, std::greater<int>> generate_cn = {
@ -720,8 +720,8 @@ std::vector<AudioCodec> WebRtcVoiceEngine::CollectCodecs(
{8000, false}, {16000, false}, {32000, false}, {48000, false}};
auto map_format = [&mapper](const webrtc::SdpAudioFormat& format,
std::vector<AudioCodec>* out) {
absl::optional<AudioCodec> opt_codec = mapper.ToAudioCodec(format);
std::vector<Codec>* out) {
absl::optional<Codec> opt_codec = mapper.ToAudioCodec(format);
if (opt_codec) {
if (out) {
out->push_back(*opt_codec);
@ -736,9 +736,9 @@ std::vector<AudioCodec> WebRtcVoiceEngine::CollectCodecs(
for (const auto& spec : specs) {
// We need to do some extra stuff before adding the main codecs to out.
absl::optional<AudioCodec> opt_codec = map_format(spec.format, nullptr);
absl::optional<Codec> opt_codec = map_format(spec.format, nullptr);
if (opt_codec) {
AudioCodec& codec = *opt_codec;
Codec& codec = *opt_codec;
if (spec.info.supports_network_adaption) {
codec.AddFeedbackParam(
FeedbackParam(kRtcpFbParamTransportCc, kParamValueEmpty));
@ -1772,7 +1772,7 @@ bool WebRtcVoiceSendChannel::GetStats(VoiceMediaSendInfo* info) {
void WebRtcVoiceSendChannel::FillSendCodecStats(
VoiceMediaSendInfo* voice_media_info) {
for (const auto& sender : voice_media_info->senders) {
auto codec = absl::c_find_if(send_codecs_, [&sender](const AudioCodec& c) {
auto codec = absl::c_find_if(send_codecs_, [&sender](const Codec& c) {
return sender.codec_payload_type && *sender.codec_payload_type == c.id;
});
if (codec != send_codecs_.end()) {
@ -1810,7 +1810,7 @@ webrtc::RtpParameters WebRtcVoiceSendChannel::GetRtpSendParameters(
webrtc::RtpParameters rtp_params = it->second->rtp_parameters();
// Need to add the common list of codecs to the send stream-specific
// RTP parameters.
for (const AudioCodec& codec : send_codecs_) {
for (const Codec& codec : send_codecs_) {
rtp_params.codecs.push_back(codec.ToCodecParameters());
}
return rtp_params;
@ -2084,7 +2084,7 @@ webrtc::RtpParameters WebRtcVoiceReceiveChannel::GetRtpReceiverParameters(
rtp_params.encodings.back().ssrc = it->second->stream().remote_ssrc();
rtp_params.header_extensions = recv_rtp_extensions_;
for (const AudioCodec& codec : recv_codecs_) {
for (const Codec& codec : recv_codecs_) {
rtp_params.codecs.push_back(codec.ToCodecParameters());
}
return rtp_params;
@ -2102,7 +2102,7 @@ WebRtcVoiceReceiveChannel::GetDefaultRtpReceiveParameters() const {
}
rtp_params.encodings.emplace_back();
for (const AudioCodec& codec : recv_codecs_) {
for (const Codec& codec : recv_codecs_) {
rtp_params.codecs.push_back(codec.ToCodecParameters());
}
return rtp_params;
@ -2124,7 +2124,7 @@ bool WebRtcVoiceReceiveChannel::SetOptions(const AudioOptions& options) {
}
bool WebRtcVoiceReceiveChannel::SetRecvCodecs(
const std::vector<AudioCodec>& codecs) {
const std::vector<Codec>& codecs) {
RTC_DCHECK_RUN_ON(worker_thread_);
// Set the payload types to be used for incoming media.
@ -2138,10 +2138,10 @@ bool WebRtcVoiceReceiveChannel::SetRecvCodecs(
// Create a payload type -> SdpAudioFormat map with all the decoders. Fail
// unless the factory claims to support all decoders.
std::map<int, webrtc::SdpAudioFormat> decoder_map;
for (const AudioCodec& codec : codecs) {
for (const Codec& codec : codecs) {
// Log a warning if a codec's payload type is changing. This used to be
// treated as an error. It's abnormal, but not really illegal.
absl::optional<AudioCodec> old_codec = FindCodec(recv_codecs_, codec);
absl::optional<Codec> old_codec = FindCodec(recv_codecs_, codec);
if (old_codec && old_codec->id != codec.id) {
RTC_LOG(LS_WARNING) << codec.name << " mapped to a second payload type ("
<< codec.id << ", was already mapped to "
@ -2632,7 +2632,7 @@ void WebRtcVoiceReceiveChannel::FillReceiveCodecStats(
VoiceMediaReceiveInfo* voice_media_info) {
for (const auto& receiver : voice_media_info->receivers) {
auto codec =
absl::c_find_if(recv_codecs_, [&receiver](const AudioCodec& c) {
absl::c_find_if(recv_codecs_, [&receiver](const Codec& c) {
return receiver.codec_payload_type &&
*receiver.codec_payload_type == c.id;
});

16
media/engine/webrtc_voice_engine.h
View file

@ -116,8 +116,8 @@ class WebRtcVoiceEngine final : public VoiceEngineInterface {
const webrtc::CryptoOptions& crypto_options,
webrtc::AudioCodecPairId codec_pair_id) override;
const std::vector<AudioCodec>& send_codecs() const override;
const std::vector<AudioCodec>& recv_codecs() const override;
const std::vector<Codec>& send_codecs() const override;
const std::vector<Codec>& recv_codecs() const override;
std::vector<webrtc::RtpHeaderExtensionCapability> GetRtpHeaderExtensions()
const override;
@ -147,7 +147,7 @@ class WebRtcVoiceEngine final : public VoiceEngineInterface {
webrtc::AudioProcessing* apm() const;
webrtc::AudioState* audio_state();
std::vector<AudioCodec> CollectCodecs(
std::vector<Codec> CollectCodecs(
const std::vector<webrtc::AudioCodecSpec>& specs) const;
webrtc::SequenceChecker signal_thread_checker_{
@ -166,8 +166,8 @@ class WebRtcVoiceEngine final : public VoiceEngineInterface {
std::unique_ptr<webrtc::AudioFrameProcessor> audio_frame_processor_;
// The primary instance of WebRtc VoiceEngine.
rtc::scoped_refptr<webrtc::AudioState> audio_state_;
std::vector<AudioCodec> send_codecs_;
std::vector<AudioCodec> recv_codecs_;
std::vector<Codec> send_codecs_;
std::vector<Codec> recv_codecs_;
bool is_dumping_aec_ = false;
bool initialized_ = false;
@ -299,7 +299,7 @@ class WebRtcVoiceSendChannel final : public MediaChannelUtil,
webrtc::SequenceChecker::kDetached};
WebRtcVoiceEngine* const engine_ = nullptr;
std::vector<AudioCodec> send_codecs_;
std::vector<Codec> send_codecs_;
int max_send_bitrate_bps_ = 0;
AudioOptions options_;
@ -428,7 +428,7 @@ class WebRtcVoiceReceiveChannel final
private:
bool SetOptions(const AudioOptions& options);
bool SetRecvCodecs(const std::vector<AudioCodec>& codecs);
bool SetRecvCodecs(const std::vector<Codec>& codecs);
bool SetLocalSource(uint32_t ssrc, AudioSource* source);
bool MuteStream(uint32_t ssrc, bool mute);
@ -453,7 +453,7 @@ class WebRtcVoiceReceiveChannel final
// TODO(kwiberg): decoder_map_ and recv_codecs_ store the exact same
// information, in slightly different formats. Eliminate recv_codecs_.
std::map<int, webrtc::SdpAudioFormat> decoder_map_;
std::vector<AudioCodec> recv_codecs_;
std::vector<Codec> recv_codecs_;
AudioOptions options_;
bool recv_nack_enabled_ = false;

45
media/engine/webrtc_voice_engine_unittest.cc
View file

@ -65,23 +65,22 @@ using ::webrtc::Environment;
constexpr uint32_t kMaxUnsignaledRecvStreams = 4;
const cricket::AudioCodec kPcmuCodec =
cricket::CreateAudioCodec(0, "PCMU", 8000, 1);
const cricket::AudioCodec kOpusCodec =
const cricket::Codec kPcmuCodec = cricket::CreateAudioCodec(0, "PCMU", 8000, 1);
const cricket::Codec kOpusCodec =
cricket::CreateAudioCodec(111, "opus", 48000, 2);
const cricket::AudioCodec kG722CodecVoE =
const cricket::Codec kG722CodecVoE =
cricket::CreateAudioCodec(9, "G722", 16000, 1);
const cricket::AudioCodec kG722CodecSdp =
const cricket::Codec kG722CodecSdp =
cricket::CreateAudioCodec(9, "G722", 8000, 1);
const cricket::AudioCodec kCn8000Codec =
const cricket::Codec kCn8000Codec =
cricket::CreateAudioCodec(13, "CN", 8000, 1);
const cricket::AudioCodec kCn16000Codec =
const cricket::Codec kCn16000Codec =
cricket::CreateAudioCodec(105, "CN", 16000, 1);
const cricket::AudioCodec kRed48000Codec =
const cricket::Codec kRed48000Codec =
cricket::CreateAudioCodec(112, "RED", 48000, 2);
const cricket::AudioCodec kTelephoneEventCodec1 =
const cricket::Codec kTelephoneEventCodec1 =
cricket::CreateAudioCodec(106, "telephone-event", 8000, 1);
const cricket::AudioCodec kTelephoneEventCodec2 =
const cricket::Codec kTelephoneEventCodec2 =
cricket::CreateAudioCodec(107, "telephone-event", 32000, 1);
const uint32_t kSsrc0 = 0;
@ -360,9 +359,7 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam<bool> {
EXPECT_TRUE(send_channel_->SetAudioSend(ssrc, enable, options, source));
}
void TestInsertDtmf(uint32_t ssrc,
bool caller,
const cricket::AudioCodec& codec) {
void TestInsertDtmf(uint32_t ssrc, bool caller, const cricket::Codec& codec) {
EXPECT_TRUE(SetupChannel());
if (caller) {
// If this is a caller, local description will be applied and add the
@ -431,7 +428,7 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam<bool> {
// `max_bitrate` is a parameter to set to SetMaxSendBandwidth().
// `expected_result` is the expected result from SetMaxSendBandwidth().
// `expected_bitrate` is the expected audio bitrate afterward.
void TestMaxSendBandwidth(const cricket::AudioCodec& codec,
void TestMaxSendBandwidth(const cricket::Codec& codec,
int max_bitrate,
bool expected_result,
int expected_bitrate) {
@ -456,7 +453,7 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam<bool> {
return send_channel_->SetRtpSendParameters(ssrc, parameters).ok();
}
void SetGlobalMaxBitrate(const cricket::AudioCodec& codec, int bitrate) {
void SetGlobalMaxBitrate(const cricket::Codec& codec, int bitrate) {
cricket::AudioSenderParameter send_parameters;
send_parameters.codecs.push_back(codec);
send_parameters.max_bandwidth_bps = bitrate;
@ -484,7 +481,7 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam<bool> {
return GetSendStreamConfig(ssrc).audio_network_adaptor_config;
}
void SetAndExpectMaxBitrate(const cricket::AudioCodec& codec,
void SetAndExpectMaxBitrate(const cricket::Codec& codec,
int global_max,
int stream_max,
bool expected_result,
@ -789,14 +786,14 @@ class WebRtcVoiceEngineTestFake : public ::testing::TestWithParam<bool> {
const cricket::VoiceMediaSendInfo& send_info,
const cricket::VoiceMediaReceiveInfo& receive_info) const {
EXPECT_EQ(send_parameters_.codecs.size(), send_info.send_codecs.size());
for (const cricket::AudioCodec& codec : send_parameters_.codecs) {
for (const cricket::Codec& codec : send_parameters_.codecs) {
ASSERT_EQ(send_info.send_codecs.count(codec.id), 1U);
EXPECT_EQ(send_info.send_codecs.find(codec.id)->second,
codec.ToCodecParameters());
}
EXPECT_EQ(recv_parameters_.codecs.size(),
receive_info.receive_codecs.size());
for (const cricket::AudioCodec& codec : recv_parameters_.codecs) {
for (const cricket::Codec& codec : recv_parameters_.codecs) {
ASSERT_EQ(receive_info.receive_codecs.count(codec.id), 1U);
EXPECT_EQ(receive_info.receive_codecs.find(codec.id)->second,
codec.ToCodecParameters());
@ -893,9 +890,9 @@ TEST_P(WebRtcVoiceEngineTestFake, CreateRecvStream) {
}
TEST_P(WebRtcVoiceEngineTestFake, OpusSupportsTransportCc) {
const std::vector<cricket::AudioCodec>& codecs = engine_->send_codecs();
const std::vector<cricket::Codec>& codecs = engine_->send_codecs();
bool opus_found = false;
for (const cricket::AudioCodec& codec : codecs) {
for (const cricket::Codec& codec : codecs) {
if (codec.name == "opus") {
EXPECT_TRUE(HasTransportCc(codec));
opus_found = true;
@ -3764,7 +3761,7 @@ TEST(WebRtcVoiceEngineTest, HasCorrectPayloadTypeMapping) {
webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), nullptr, apm,
nullptr, field_trials);
engine.Init();
for (const cricket::AudioCodec& codec : engine.send_codecs()) {
for (const cricket::Codec& codec : engine.send_codecs()) {
auto is_codec = [&codec](const char* name, int clockrate = 0) {
return absl::EqualsIgnoreCase(codec.name, name) &&
(clockrate == 0 || codec.clockrate == clockrate);
@ -3952,8 +3949,8 @@ TEST(WebRtcVoiceEngineTest, CollectRecvCodecs) {
// Rather than just ASSERTing that there are enough codecs, ensure that we
// can check the actual values safely, to provide better test results.
auto get_codec = [&codecs](size_t index) -> const cricket::AudioCodec& {
static const cricket::AudioCodec missing_codec =
auto get_codec = [&codecs](size_t index) -> const cricket::Codec& {
static const cricket::Codec missing_codec =
cricket::CreateAudioCodec(0, "<missing>", 0, 0);
if (codecs.size() > index)
return codecs[index];
@ -3972,7 +3969,7 @@ TEST(WebRtcVoiceEngineTest, CollectRecvCodecs) {
// check supplementary codecs are ordered after the general codecs.
auto find_codec = [&codecs](const webrtc::SdpAudioFormat& format) -> int {
for (size_t i = 0; i != codecs.size(); ++i) {
const cricket::AudioCodec& codec = codecs[i];
const cricket::Codec& codec = codecs[i];
if (absl::EqualsIgnoreCase(codec.name, format.name) &&
codec.clockrate == format.clockrate_hz &&
codec.channels == format.num_channels) {

10
pc/channel.cc
View file

@ -1029,15 +1029,15 @@ bool VideoChannel::SetLocalContent_w(const MediaContentDescription* content,
// instead.
bool needs_send_params_update = false;
if (type == SdpType::kAnswer || type == SdpType::kPrAnswer) {
webrtc::flat_set<const VideoCodec*> matched_codecs;
for (VideoCodec& send_codec : send_params.codecs) {
if (absl::c_any_of(matched_codecs, [&](const VideoCodec* c) {
webrtc::flat_set<const Codec*> matched_codecs;
for (Codec& send_codec : send_params.codecs) {
if (absl::c_any_of(matched_codecs, [&](const Codec* c) {
return send_codec.Matches(*c);
})) {
continue;
}
std::vector<const VideoCodec*> recv_codecs =
std::vector<const Codec*> recv_codecs =
FindAllMatchingCodecs(recv_params.codecs, send_codec);
if (recv_codecs.empty()) {
continue;
@ -1045,7 +1045,7 @@ bool VideoChannel::SetLocalContent_w(const MediaContentDescription* content,
bool may_ignore_packetization = false;
bool has_matching_packetization = false;
for (const VideoCodec* recv_codec : recv_codecs) {
for (const Codec* recv_codec : recv_codecs) {
if (!recv_codec->packetization.has_value() &&
send_codec.packetization.has_value()) {
may_ignore_packetization = true;

52
pc/channel_unittest.cc
View file

@ -2098,8 +2098,8 @@ TEST_F(VideoChannelSingleThreadTest, UpdateLocalStreamsWithSimulcast) {
}
TEST_F(VideoChannelSingleThreadTest, TestSetLocalOfferWithPacketization) {
const cricket::VideoCodec kVp8Codec = cricket::CreateVideoCodec(97, "VP8");
cricket::VideoCodec vp9_codec = cricket::CreateVideoCodec(98, "VP9");
const cricket::Codec kVp8Codec = cricket::CreateVideoCodec(97, "VP8");
cricket::Codec vp9_codec = cricket::CreateVideoCodec(98, "VP9");
vp9_codec.packetization = cricket::kPacketizationParamRaw;
cricket::VideoContentDescription video;
video.set_codecs({kVp8Codec, vp9_codec});
@ -2121,8 +2121,8 @@ TEST_F(VideoChannelSingleThreadTest, TestSetLocalOfferWithPacketization) {
}
TEST_F(VideoChannelSingleThreadTest, TestSetRemoteOfferWithPacketization) {
const cricket::VideoCodec kVp8Codec = cricket::CreateVideoCodec(97, "VP8");
cricket::VideoCodec vp9_codec = cricket::CreateVideoCodec(98, "VP9");
const cricket::Codec kVp8Codec = cricket::CreateVideoCodec(97, "VP8");
cricket::Codec vp9_codec = cricket::CreateVideoCodec(98, "VP9");
vp9_codec.packetization = cricket::kPacketizationParamRaw;
cricket::VideoContentDescription video;
video.set_codecs({kVp8Codec, vp9_codec});
@ -2143,8 +2143,8 @@ TEST_F(VideoChannelSingleThreadTest, TestSetRemoteOfferWithPacketization) {
}
TEST_F(VideoChannelSingleThreadTest, TestSetAnswerWithPacketization) {
const cricket::VideoCodec kVp8Codec = cricket::CreateVideoCodec(97, "VP8");
cricket::VideoCodec vp9_codec = cricket::CreateVideoCodec(98, "VP9");
const cricket::Codec kVp8Codec = cricket::CreateVideoCodec(97, "VP8");
cricket::Codec vp9_codec = cricket::CreateVideoCodec(98, "VP9");
vp9_codec.packetization = cricket::kPacketizationParamRaw;
cricket::VideoContentDescription video;
video.set_codecs({kVp8Codec, vp9_codec});
@ -2175,8 +2175,8 @@ TEST_F(VideoChannelSingleThreadTest, TestSetAnswerWithPacketization) {
}
TEST_F(VideoChannelSingleThreadTest, TestSetLocalAnswerWithoutPacketization) {
const cricket::VideoCodec kLocalCodec = cricket::CreateVideoCodec(98, "VP8");
cricket::VideoCodec remote_codec = cricket::CreateVideoCodec(99, "VP8");
const cricket::Codec kLocalCodec = cricket::CreateVideoCodec(98, "VP8");
cricket::Codec remote_codec = cricket::CreateVideoCodec(99, "VP8");
remote_codec.packetization = cricket::kPacketizationParamRaw;
cricket::VideoContentDescription local_video;
local_video.set_codecs({kLocalCodec});
@ -2197,9 +2197,9 @@ TEST_F(VideoChannelSingleThreadTest, TestSetLocalAnswerWithoutPacketization) {
}
TEST_F(VideoChannelSingleThreadTest, TestSetRemoteAnswerWithoutPacketization) {
cricket::VideoCodec local_codec = cricket::CreateVideoCodec(98, "VP8");
cricket::Codec local_codec = cricket::CreateVideoCodec(98, "VP8");
local_codec.packetization = cricket::kPacketizationParamRaw;
const cricket::VideoCodec kRemoteCodec = cricket::CreateVideoCodec(99, "VP8");
const cricket::Codec kRemoteCodec = cricket::CreateVideoCodec(99, "VP8");
cricket::VideoContentDescription local_video;
local_video.set_codecs({local_codec});
cricket::VideoContentDescription remote_video;
@ -2221,9 +2221,9 @@ TEST_F(VideoChannelSingleThreadTest, TestSetRemoteAnswerWithoutPacketization) {
TEST_F(VideoChannelSingleThreadTest,
TestSetRemoteAnswerWithInvalidPacketization) {
cricket::VideoCodec local_codec = cricket::CreateVideoCodec(98, "VP8");
cricket::Codec local_codec = cricket::CreateVideoCodec(98, "VP8");
local_codec.packetization = cricket::kPacketizationParamRaw;
cricket::VideoCodec remote_codec = cricket::CreateVideoCodec(99, "VP8");
cricket::Codec remote_codec = cricket::CreateVideoCodec(99, "VP8");
remote_codec.packetization = "unknownpacketizationattributevalue";
cricket::VideoContentDescription local_video;
local_video.set_codecs({local_codec});
@ -2246,9 +2246,9 @@ TEST_F(VideoChannelSingleThreadTest,
TEST_F(VideoChannelSingleThreadTest,
TestSetLocalAnswerWithInvalidPacketization) {
cricket::VideoCodec local_codec = cricket::CreateVideoCodec(98, "VP8");
cricket::Codec local_codec = cricket::CreateVideoCodec(98, "VP8");
local_codec.packetization = cricket::kPacketizationParamRaw;
const cricket::VideoCodec kRemoteCodec = cricket::CreateVideoCodec(99, "VP8");
const cricket::Codec kRemoteCodec = cricket::CreateVideoCodec(99, "VP8");
cricket::VideoContentDescription local_video;
local_video.set_codecs({local_codec});
cricket::VideoContentDescription remote_video;
@ -2269,12 +2269,12 @@ TEST_F(VideoChannelSingleThreadTest,
TEST_F(VideoChannelSingleThreadTest,
StopsPacketizationVerificationWhenMatchIsFoundInRemoteAnswer) {
cricket::VideoCodec vp8_foo = cricket::CreateVideoCodec(96, "VP8");
cricket::Codec vp8_foo = cricket::CreateVideoCodec(96, "VP8");
vp8_foo.packetization = "foo";
cricket::VideoCodec vp8_bar = cricket::CreateVideoCodec(97, "VP8");
cricket::Codec vp8_bar = cricket::CreateVideoCodec(97, "VP8");
vp8_bar.packetization = "bar";
cricket::VideoCodec vp9 = cricket::CreateVideoCodec(98, "VP9");
cricket::VideoCodec vp9_foo = cricket::CreateVideoCodec(99, "VP9");
cricket::Codec vp9 = cricket::CreateVideoCodec(98, "VP9");
cricket::Codec vp9_foo = cricket::CreateVideoCodec(99, "VP9");
vp9_foo.packetization = "bar";
cricket::VideoContentDescription local;
local.set_codecs({vp8_foo, vp8_bar, vp9_foo});
@ -2305,12 +2305,12 @@ TEST_F(VideoChannelSingleThreadTest,
TEST_F(VideoChannelSingleThreadTest,
StopsPacketizationVerificationWhenMatchIsFoundInLocalAnswer) {
cricket::VideoCodec vp8_foo = cricket::CreateVideoCodec(96, "VP8");
cricket::Codec vp8_foo = cricket::CreateVideoCodec(96, "VP8");
vp8_foo.packetization = "foo";
cricket::VideoCodec vp8_bar = cricket::CreateVideoCodec(97, "VP8");
cricket::Codec vp8_bar = cricket::CreateVideoCodec(97, "VP8");
vp8_bar.packetization = "bar";
cricket::VideoCodec vp9 = cricket::CreateVideoCodec(98, "VP9");
cricket::VideoCodec vp9_foo = cricket::CreateVideoCodec(99, "VP9");
cricket::Codec vp9 = cricket::CreateVideoCodec(98, "VP9");
cricket::Codec vp9_foo = cricket::CreateVideoCodec(99, "VP9");
vp9_foo.packetization = "bar";
cricket::VideoContentDescription local;
local.set_codecs({vp8_foo, vp9});
@ -2341,8 +2341,8 @@ TEST_F(VideoChannelSingleThreadTest,
TEST_F(VideoChannelSingleThreadTest,
ConsidersAllCodecsWithDiffrentPacketizationsInRemoteAnswer) {
cricket::VideoCodec vp8 = cricket::CreateVideoCodec(96, "VP8");
cricket::VideoCodec vp8_raw = cricket::CreateVideoCodec(97, "VP8");
cricket::Codec vp8 = cricket::CreateVideoCodec(96, "VP8");
cricket::Codec vp8_raw = cricket::CreateVideoCodec(97, "VP8");
vp8_raw.packetization = cricket::kPacketizationParamRaw;
cricket::VideoContentDescription local;
local.set_codecs({vp8, vp8_raw});
@ -2373,8 +2373,8 @@ TEST_F(VideoChannelSingleThreadTest,
TEST_F(VideoChannelSingleThreadTest,
ConsidersAllCodecsWithDiffrentPacketizationsInLocalAnswer) {
cricket::VideoCodec vp8 = cricket::CreateVideoCodec(96, "VP8");
cricket::VideoCodec vp8_raw = cricket::CreateVideoCodec(97, "VP8");
cricket::Codec vp8 = cricket::CreateVideoCodec(96, "VP8");
cricket::Codec vp8_raw = cricket::CreateVideoCodec(97, "VP8");
vp8_raw.packetization = cricket::kPacketizationParamRaw;
cricket::VideoContentDescription local;
local.set_codecs({vp8_raw, vp8});

62
pc/media_session.cc
View file

@ -127,9 +127,9 @@ bool IsComfortNoiseCodec(const Codec& codec) {
return absl::EqualsIgnoreCase(codec.name, kComfortNoiseCodecName);
}
void StripCNCodecs(AudioCodecs* audio_codecs) {
void StripCNCodecs(Codecs* audio_codecs) {
audio_codecs->erase(std::remove_if(audio_codecs->begin(), audio_codecs->end(),
[](const AudioCodec& codec) {
[](const Codec& codec) {
return IsComfortNoiseCodec(codec);
}),
audio_codecs->end());
@ -1160,7 +1160,7 @@ const TransportDescription* GetTransportDescription(
return desc;
}
webrtc::RTCErrorOr<AudioCodecs> GetNegotiatedCodecsForOffer(
webrtc::RTCErrorOr<Codecs> GetNegotiatedCodecsForOffer(
const MediaDescriptionOptions& media_description_options,
const MediaSessionOptions& session_options,
const ContentInfo* current_content,
@ -1237,7 +1237,7 @@ webrtc::RTCErrorOr<AudioCodecs> GetNegotiatedCodecsForOffer(
return filtered_codecs;
}
webrtc::RTCErrorOr<AudioCodecs> GetNegotiatedCodecsForAnswer(
webrtc::RTCErrorOr<Codecs> GetNegotiatedCodecsForAnswer(
const MediaDescriptionOptions& media_description_options,
const MediaSessionOptions& session_options,
const ContentInfo* current_content,
@ -1363,43 +1363,41 @@ MediaSessionDescriptionFactory::MediaSessionDescriptionFactory(
ComputeVideoCodecsIntersectionAndUnion();
}
const AudioCodecs& MediaSessionDescriptionFactory::audio_sendrecv_codecs()
const {
const Codecs& MediaSessionDescriptionFactory::audio_sendrecv_codecs() const {
return audio_sendrecv_codecs_;
}
const AudioCodecs& MediaSessionDescriptionFactory::audio_send_codecs() const {
const Codecs& MediaSessionDescriptionFactory::audio_send_codecs() const {
return audio_send_codecs_;
}
const AudioCodecs& MediaSessionDescriptionFactory::audio_recv_codecs() const {
const Codecs& MediaSessionDescriptionFactory::audio_recv_codecs() const {
return audio_recv_codecs_;
}
void MediaSessionDescriptionFactory::set_audio_codecs(
const AudioCodecs& send_codecs,
const AudioCodecs& recv_codecs) {
const Codecs& send_codecs,
const Codecs& recv_codecs) {
audio_send_codecs_ = send_codecs;
audio_recv_codecs_ = recv_codecs;
ComputeAudioCodecsIntersectionAndUnion();
}
const VideoCodecs& MediaSessionDescriptionFactory::video_sendrecv_codecs()
const {
const Codecs& MediaSessionDescriptionFactory::video_sendrecv_codecs() const {
return video_sendrecv_codecs_;
}
const VideoCodecs& MediaSessionDescriptionFactory::video_send_codecs() const {
const Codecs& MediaSessionDescriptionFactory::video_send_codecs() const {
return video_send_codecs_;
}
const VideoCodecs& MediaSessionDescriptionFactory::video_recv_codecs() const {
const Codecs& MediaSessionDescriptionFactory::video_recv_codecs() const {
return video_recv_codecs_;
}
void MediaSessionDescriptionFactory::set_video_codecs(
const VideoCodecs& send_codecs,
const VideoCodecs& recv_codecs) {
const Codecs& send_codecs,
const Codecs& recv_codecs) {
video_send_codecs_ = send_codecs;
video_recv_codecs_ = recv_codecs;
ComputeVideoCodecsIntersectionAndUnion();
@ -1445,8 +1443,8 @@ MediaSessionDescriptionFactory::CreateOfferOrError(
StreamParamsVec current_streams =
GetCurrentStreamParams(current_active_contents);
AudioCodecs offer_audio_codecs;
VideoCodecs offer_video_codecs;
Codecs offer_audio_codecs;
Codecs offer_video_codecs;
GetCodecsForOffer(current_active_contents, &offer_audio_codecs,
&offer_video_codecs);
AudioVideoRtpHeaderExtensions extensions_with_ids =
@ -1578,8 +1576,8 @@ MediaSessionDescriptionFactory::CreateAnswerOrError(
// Note that these lists may be further filtered for each m= section; this
// step is done just to establish the payload type mappings shared by all
// sections.
AudioCodecs answer_audio_codecs;
VideoCodecs answer_video_codecs;
Codecs answer_audio_codecs;
Codecs answer_video_codecs;
GetCodecsForAnswer(current_active_contents, *offer, &answer_audio_codecs,
&answer_video_codecs);
@ -1742,7 +1740,7 @@ MediaSessionDescriptionFactory::CreateAnswerOrError(
return answer;
}
const AudioCodecs& MediaSessionDescriptionFactory::GetAudioCodecsForOffer(
const Codecs& MediaSessionDescriptionFactory::GetAudioCodecsForOffer(
const RtpTransceiverDirection& direction) const {
switch (direction) {
// If stream is inactive - generate list as if sendrecv.
@ -1758,7 +1756,7 @@ const AudioCodecs& MediaSessionDescriptionFactory::GetAudioCodecsForOffer(
RTC_CHECK_NOTREACHED();
}
const AudioCodecs& MediaSessionDescriptionFactory::GetAudioCodecsForAnswer(
const Codecs& MediaSessionDescriptionFactory::GetAudioCodecsForAnswer(
const RtpTransceiverDirection& offer,
const RtpTransceiverDirection& answer) const {
switch (answer) {
@ -1777,7 +1775,7 @@ const AudioCodecs& MediaSessionDescriptionFactory::GetAudioCodecsForAnswer(
RTC_CHECK_NOTREACHED();
}
const VideoCodecs& MediaSessionDescriptionFactory::GetVideoCodecsForOffer(
const Codecs& MediaSessionDescriptionFactory::GetVideoCodecsForOffer(
const RtpTransceiverDirection& direction) const {
switch (direction) {
// If stream is inactive - generate list as if sendrecv.
@ -1793,7 +1791,7 @@ const VideoCodecs& MediaSessionDescriptionFactory::GetVideoCodecsForOffer(
RTC_CHECK_NOTREACHED();
}
const VideoCodecs& MediaSessionDescriptionFactory::GetVideoCodecsForAnswer(
const Codecs& MediaSessionDescriptionFactory::GetVideoCodecsForAnswer(
const RtpTransceiverDirection& offer,
const RtpTransceiverDirection& answer) const {
switch (answer) {
@ -1814,8 +1812,8 @@ const VideoCodecs& MediaSessionDescriptionFactory::GetVideoCodecsForAnswer(
void MergeCodecsFromDescription(
const std::vector<const ContentInfo*>& current_active_contents,
AudioCodecs* audio_codecs,
VideoCodecs* video_codecs,
Codecs* audio_codecs,
Codecs* video_codecs,
UsedPayloadTypes* used_pltypes) {
for (const ContentInfo* content : current_active_contents) {
if (IsMediaContentOfType(content, MEDIA_TYPE_AUDIO)) {
@ -1836,8 +1834,8 @@ void MergeCodecsFromDescription(
// on the directional attribute (happens in another method).
void MediaSessionDescriptionFactory::GetCodecsForOffer(
const std::vector<const ContentInfo*>& current_active_contents,
AudioCodecs* audio_codecs,
VideoCodecs* video_codecs) const {
Codecs* audio_codecs,
Codecs* video_codecs) const {
// First - get all codecs from the current description if the media type
// is used. Add them to `used_pltypes` so the payload type is not reused if a
// new media type is added.
@ -1860,8 +1858,8 @@ void MediaSessionDescriptionFactory::GetCodecsForOffer(
void MediaSessionDescriptionFactory::GetCodecsForAnswer(
const std::vector<const ContentInfo*>& current_active_contents,
const SessionDescription& remote_offer,
AudioCodecs* audio_codecs,
VideoCodecs* video_codecs) const {
Codecs* audio_codecs,
Codecs* video_codecs) const {
// First - get all codecs from the current description if the media type
// is used. Add them to `used_pltypes` so the payload type is not reused if a
// new media type is added.
@ -1870,8 +1868,8 @@ void MediaSessionDescriptionFactory::GetCodecsForAnswer(
video_codecs, &used_pltypes);
// Second - filter out codecs that we don't support at all and should ignore.
AudioCodecs filtered_offered_audio_codecs;
VideoCodecs filtered_offered_video_codecs;
Codecs filtered_offered_audio_codecs;
Codecs filtered_offered_video_codecs;
for (const ContentInfo& content : remote_offer.contents()) {
if (IsMediaContentOfType(&content, MEDIA_TYPE_AUDIO)) {
std::vector<Codec> offered_codecs = content.media_description()->codecs();

50
pc/media_session.h
View file

@ -148,16 +148,14 @@ class MediaSessionDescriptionFactory {
rtc::UniqueRandomIdGenerator* ssrc_generator,
const TransportDescriptionFactory* factory);
const AudioCodecs& audio_sendrecv_codecs() const;
const AudioCodecs& audio_send_codecs() const;
const AudioCodecs& audio_recv_codecs() const;
void set_audio_codecs(const AudioCodecs& send_codecs,
const AudioCodecs& recv_codecs);
const VideoCodecs& video_sendrecv_codecs() const;
const VideoCodecs& video_send_codecs() const;
const VideoCodecs& video_recv_codecs() const;
void set_video_codecs(const VideoCodecs& send_codecs,
const VideoCodecs& recv_codecs);
const Codecs& audio_sendrecv_codecs() const;
const Codecs& audio_send_codecs() const;
const Codecs& audio_recv_codecs() const;
void set_audio_codecs(const Codecs& send_codecs, const Codecs& recv_codecs);
const Codecs& video_sendrecv_codecs() const;
const Codecs& video_send_codecs() const;
const Codecs& video_recv_codecs() const;
void set_video_codecs(const Codecs& send_codecs, const Codecs& recv_codecs);
RtpHeaderExtensions filtered_rtp_header_extensions(
RtpHeaderExtensions extensions) const;
@ -183,25 +181,25 @@ class MediaSessionDescriptionFactory {
RtpHeaderExtensions video;
};
const AudioCodecs& GetAudioCodecsForOffer(
const Codecs& GetAudioCodecsForOffer(
const webrtc::RtpTransceiverDirection& direction) const;
const AudioCodecs& GetAudioCodecsForAnswer(
const Codecs& GetAudioCodecsForAnswer(
const webrtc::RtpTransceiverDirection& offer,
const webrtc::RtpTransceiverDirection& answer) const;
const VideoCodecs& GetVideoCodecsForOffer(
const Codecs& GetVideoCodecsForOffer(
const webrtc::RtpTransceiverDirection& direction) const;
const VideoCodecs& GetVideoCodecsForAnswer(
const Codecs& GetVideoCodecsForAnswer(
const webrtc::RtpTransceiverDirection& offer,
const webrtc::RtpTransceiverDirection& answer) const;
void GetCodecsForOffer(
const std::vector<const ContentInfo*>& current_active_contents,
AudioCodecs* audio_codecs,
VideoCodecs* video_codecs) const;
Codecs* audio_codecs,
Codecs* video_codecs) const;
void GetCodecsForAnswer(
const std::vector<const ContentInfo*>& current_active_contents,
const SessionDescription& remote_offer,
AudioCodecs* audio_codecs,
VideoCodecs* video_codecs) const;
Codecs* audio_codecs,
Codecs* video_codecs) const;
AudioVideoRtpHeaderExtensions GetOfferedRtpHeaderExtensionsWithIds(
const std::vector<const ContentInfo*>& current_active_contents,
bool extmap_allow_mixed,
@ -302,18 +300,18 @@ class MediaSessionDescriptionFactory {
}
bool is_unified_plan_ = false;
AudioCodecs audio_send_codecs_;
AudioCodecs audio_recv_codecs_;
Codecs audio_send_codecs_;
Codecs audio_recv_codecs_;
// Intersection of send and recv.
AudioCodecs audio_sendrecv_codecs_;
Codecs audio_sendrecv_codecs_;
// Union of send and recv.
AudioCodecs all_audio_codecs_;
VideoCodecs video_send_codecs_;
VideoCodecs video_recv_codecs_;
Codecs all_audio_codecs_;
Codecs video_send_codecs_;
Codecs video_recv_codecs_;
// Intersection of send and recv.
VideoCodecs video_sendrecv_codecs_;
Codecs video_sendrecv_codecs_;
// Union of send and recv.
VideoCodecs all_video_codecs_;
Codecs all_video_codecs_;
// This object may or may not be owned by this class.
webrtc::AlwaysValidPointer<rtc::UniqueRandomIdGenerator> const
ssrc_generator_;

146
pc/media_session_unittest.cc
View file

@ -78,42 +78,42 @@ using ::webrtc::RtpTransceiverDirection;
using Candidates = std::vector<Candidate>;
AudioCodec CreateRedAudioCodec(absl::string_view encoding_id) {
AudioCodec red = CreateAudioCodec(63, "red", 48000, 2);
Codec CreateRedAudioCodec(absl::string_view encoding_id) {
Codec red = CreateAudioCodec(63, "red", 48000, 2);
red.SetParam(kCodecParamNotInNameValueFormat,
std::string(encoding_id) + '/' + std::string(encoding_id));
return red;
}
const AudioCodec kAudioCodecs1[] = {CreateAudioCodec(111, "opus", 48000, 2),
CreateRedAudioCodec("111"),
CreateAudioCodec(102, "iLBC", 8000, 1),
CreateAudioCodec(0, "PCMU", 8000, 1),
CreateAudioCodec(8, "PCMA", 8000, 1),
CreateAudioCodec(117, "red", 8000, 1),
CreateAudioCodec(107, "CN", 48000, 1)};
const Codec kAudioCodecs1[] = {CreateAudioCodec(111, "opus", 48000, 2),
CreateRedAudioCodec("111"),
CreateAudioCodec(102, "iLBC", 8000, 1),
CreateAudioCodec(0, "PCMU", 8000, 1),
CreateAudioCodec(8, "PCMA", 8000, 1),
CreateAudioCodec(117, "red", 8000, 1),
CreateAudioCodec(107, "CN", 48000, 1)};
const AudioCodec kAudioCodecs2[] = {
const Codec kAudioCodecs2[] = {
CreateAudioCodec(126, "foo", 16000, 1),
CreateAudioCodec(0, "PCMU", 8000, 1),
CreateAudioCodec(127, "iLBC", 8000, 1),
};
const AudioCodec kAudioCodecsAnswer[] = {
const Codec kAudioCodecsAnswer[] = {
CreateAudioCodec(102, "iLBC", 8000, 1),
CreateAudioCodec(0, "PCMU", 8000, 1),
};
const VideoCodec kVideoCodecs1[] = {CreateVideoCodec(96, "H264-SVC"),
CreateVideoCodec(97, "H264")};
const Codec kVideoCodecs1[] = {CreateVideoCodec(96, "H264-SVC"),
CreateVideoCodec(97, "H264")};
const VideoCodec kVideoCodecs1Reverse[] = {CreateVideoCodec(97, "H264"),
CreateVideoCodec(96, "H264-SVC")};
const Codec kVideoCodecs1Reverse[] = {CreateVideoCodec(97, "H264"),
CreateVideoCodec(96, "H264-SVC")};
const VideoCodec kVideoCodecs2[] = {CreateVideoCodec(126, "H264"),
CreateVideoCodec(127, "H263")};
const Codec kVideoCodecs2[] = {CreateVideoCodec(126, "H264"),
CreateVideoCodec(127, "H263")};
const VideoCodec kVideoCodecsAnswer[] = {CreateVideoCodec(97, "H264")};
const Codec kVideoCodecsAnswer[] = {CreateVideoCodec(97, "H264")};
const RtpExtension kAudioRtpExtension1[] = {
RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 8),
@ -264,7 +264,7 @@ RtpTransceiverDirection GetMediaDirection(const ContentInfo* content) {
return content->media_description()->direction();
}
void AddRtxCodec(const VideoCodec& rtx_codec, std::vector<VideoCodec>* codecs) {
void AddRtxCodec(const Codec& rtx_codec, std::vector<Codec>* codecs) {
ASSERT_FALSE(FindCodecById(*codecs, rtx_codec.id));
codecs->push_back(rtx_codec);
}
@ -744,8 +744,8 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoOffer) {
// RTP playlod type. The test verifies that the offer don't contain the
// duplicate RTP payload types.
TEST_F(MediaSessionDescriptionFactoryTest, TestBundleOfferWithSameCodecPlType) {
const VideoCodec& offered_video_codec = f2_.video_sendrecv_codecs()[0];
const AudioCodec& offered_audio_codec = f2_.audio_sendrecv_codecs()[0];
const Codec& offered_video_codec = f2_.video_sendrecv_codecs()[0];
const Codec& offered_audio_codec = f2_.audio_sendrecv_codecs()[0];
ASSERT_EQ(offered_video_codec.id, offered_audio_codec.id);
MediaSessionOptions opts;
@ -2705,7 +2705,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
// preference order.
// TODO(wu): `updated_offer` should not include the codec
// (i.e. `kAudioCodecs2[0]`) the other side doesn't support.
const AudioCodec kUpdatedAudioCodecOffer[] = {
const Codec kUpdatedAudioCodecOffer[] = {
kAudioCodecsAnswer[0],
kAudioCodecsAnswer[1],
kAudioCodecs2[0],
@ -2714,7 +2714,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
// The expected video codecs are the common video codecs from the first
// offer/answer exchange plus the video codecs only `f2_` offer, sorted in
// preference order.
const VideoCodec kUpdatedVideoCodecOffer[] = {
const Codec kUpdatedVideoCodecOffer[] = {
kVideoCodecsAnswer[0],
kVideoCodecs2[1],
};
@ -2856,12 +2856,12 @@ TEST_F(MediaSessionDescriptionFactoryTest,
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
// This creates rtx for H264 with the payload type `f1_` uses.
AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
f1_.set_video_codecs(f1_codecs, f1_codecs);
std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
// This creates rtx for H264 with the payload type `f2_` uses.
AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs);
f2_.set_video_codecs(f2_codecs, f2_codecs);
@ -2875,7 +2875,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
const VideoContentDescription* vcd =
GetFirstVideoContentDescription(answer.get());
std::vector<VideoCodec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
std::vector<Codec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &expected_codecs);
EXPECT_EQ(expected_codecs, vcd->codecs());
@ -2909,22 +2909,21 @@ TEST_F(MediaSessionDescriptionFactoryTest,
&opts);
// We specifically choose different preferred payload types for VP8 to
// trigger the issue.
VideoCodec vp8_offerer = CreateVideoCodec(100, "VP8");
VideoCodec vp8_offerer_rtx = CreateVideoRtxCodec(101, vp8_offerer.id);
VideoCodec vp8_answerer = CreateVideoCodec(110, "VP8");
VideoCodec vp8_answerer_rtx = CreateVideoRtxCodec(111, vp8_answerer.id);
VideoCodec vp9 = CreateVideoCodec(120, "VP9");
VideoCodec vp9_rtx = CreateVideoRtxCodec(121, vp9.id);
Codec vp8_offerer = CreateVideoCodec(100, "VP8");
Codec vp8_offerer_rtx = CreateVideoRtxCodec(101, vp8_offerer.id);
Codec vp8_answerer = CreateVideoCodec(110, "VP8");
Codec vp8_answerer_rtx = CreateVideoRtxCodec(111, vp8_answerer.id);
Codec vp9 = CreateVideoCodec(120, "VP9");
Codec vp9_rtx = CreateVideoRtxCodec(121, vp9.id);
std::vector<VideoCodec> f1_codecs = {vp8_offerer, vp8_offerer_rtx};
std::vector<Codec> f1_codecs = {vp8_offerer, vp8_offerer_rtx};
// We also specifically cause the answerer to prefer VP9, such that if it
// *doesn't* honor the existing preferred codec (VP8) we'll notice.
std::vector<VideoCodec> f2_codecs = {vp9, vp9_rtx, vp8_answerer,
vp8_answerer_rtx};
std::vector<Codec> f2_codecs = {vp9, vp9_rtx, vp8_answerer, vp8_answerer_rtx};
f1_.set_video_codecs(f1_codecs, f1_codecs);
f2_.set_video_codecs(f2_codecs, f2_codecs);
std::vector<AudioCodec> audio_codecs;
std::vector<Codec> audio_codecs;
f1_.set_audio_codecs(audio_codecs, audio_codecs);
f2_.set_audio_codecs(audio_codecs, audio_codecs);
@ -2942,7 +2941,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
const VideoContentDescription* vcd =
GetFirstVideoContentDescription(updated_offer.get());
std::vector<VideoCodec> codecs = vcd->codecs();
std::vector<Codec> codecs = vcd->codecs();
ASSERT_EQ(4u, codecs.size());
EXPECT_EQ(vp8_offerer, codecs[0]);
EXPECT_EQ(vp8_offerer_rtx, codecs[1]);
@ -2956,7 +2955,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
// use, the added codecs payload types are changed.
TEST_F(MediaSessionDescriptionFactoryTest,
RespondentCreatesOfferWithVideoAndRtxAfterCreatingAudioAnswer) {
std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
// This creates rtx for H264 with the payload type `f1_` uses.
AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
f1_.set_video_codecs(f1_codecs, f1_codecs);
@ -2981,7 +2980,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
opts.media_description_options.clear();
AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts);
std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
int used_pl_type = acd->codecs()[0].id;
f2_codecs[0].id = used_pl_type; // Set the payload type for H264.
AddRtxCodec(CreateVideoRtxCodec(125, used_pl_type), &f2_codecs);
@ -3005,7 +3004,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
ASSERT_EQ(kRtxCodecName, updated_vcd->codecs()[1].name);
int new_h264_pl_type = updated_vcd->codecs()[0].id;
EXPECT_NE(used_pl_type, new_h264_pl_type);
VideoCodec rtx = updated_vcd->codecs()[1];
Codec rtx = updated_vcd->codecs()[1];
int pt_referenced_by_rtx =
rtc::FromString<int>(rtx.params[kCodecParamAssociatedPayloadType]);
EXPECT_EQ(new_h264_pl_type, pt_referenced_by_rtx);
@ -3019,7 +3018,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
MediaSessionOptions opts;
AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts);
std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
// This creates rtx for H264 with the payload type `f2_` uses.
AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs);
f2_.set_video_codecs(f2_codecs, f2_codecs);
@ -3033,7 +3032,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
const VideoContentDescription* vcd =
GetFirstVideoContentDescription(answer.get());
std::vector<VideoCodec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
std::vector<Codec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
EXPECT_EQ(expected_codecs, vcd->codecs());
// Now, ensure that the RTX codec is created correctly when `f2_` creates an
@ -3058,12 +3057,12 @@ TEST_F(MediaSessionDescriptionFactoryTest, RtxWithoutApt) {
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
// This creates RTX without associated payload type parameter.
AddRtxCodec(CreateVideoCodec(126, kRtxCodecName), &f1_codecs);
f1_.set_video_codecs(f1_codecs, f1_codecs);
std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
// This creates RTX for H264 with the payload type `f2_` uses.
AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs);
f2_.set_video_codecs(f2_codecs, f2_codecs);
@ -3101,12 +3100,12 @@ TEST_F(MediaSessionDescriptionFactoryTest, FilterOutRtxIfAptDoesntMatch) {
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
// This creates RTX for H264 in sender.
AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
f1_.set_video_codecs(f1_codecs, f1_codecs);
std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
// This creates RTX for H263 in receiver.
AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs2[1].id), &f2_codecs);
f2_.set_video_codecs(f2_codecs, f2_codecs);
@ -3132,7 +3131,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
// This creates RTX for H264-SVC in sender.
AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs1[0].id), &f1_codecs);
f1_.set_video_codecs(f1_codecs, f1_codecs);
@ -3141,7 +3140,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
f1_.set_video_codecs(f1_codecs, f1_codecs);
std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
// This creates RTX for H264 in receiver.
AddRtxCodec(CreateVideoRtxCodec(124, kVideoCodecs2[0].id), &f2_codecs);
f2_.set_video_codecs(f2_codecs, f1_codecs);
@ -3155,7 +3154,7 @@ TEST_F(MediaSessionDescriptionFactoryTest,
f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue();
const VideoContentDescription* vcd =
GetFirstVideoContentDescription(answer.get());
std::vector<VideoCodec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
std::vector<Codec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &expected_codecs);
EXPECT_EQ(expected_codecs, vcd->codecs());
@ -3168,7 +3167,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, AddSecondRtxInNewOffer) {
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
// This creates RTX for H264 for the offerer.
AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
f1_.set_video_codecs(f1_codecs, f1_codecs);
@ -3179,7 +3178,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, AddSecondRtxInNewOffer) {
const VideoContentDescription* vcd =
GetFirstVideoContentDescription(offer.get());
std::vector<VideoCodec> expected_codecs = MAKE_VECTOR(kVideoCodecs1);
std::vector<Codec> expected_codecs = MAKE_VECTOR(kVideoCodecs1);
AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &expected_codecs);
EXPECT_EQ(expected_codecs, vcd->codecs());
@ -3208,7 +3207,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, SimSsrcsGenerateMultipleRtxSsrcs) {
{"stream1label"}, 3, &opts);
// Use a single real codec, and then add RTX for it.
std::vector<VideoCodec> f1_codecs;
std::vector<Codec> f1_codecs;
f1_codecs.push_back(CreateVideoCodec(97, "H264"));
AddRtxCodec(CreateVideoRtxCodec(125, 97), &f1_codecs);
f1_.set_video_codecs(f1_codecs, f1_codecs);
@ -3252,7 +3251,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, GenerateFlexfecSsrc) {
{"stream1label"}, 1, &opts);
// Use a single real codec, and then add FlexFEC for it.
std::vector<VideoCodec> f1_codecs;
std::vector<Codec> f1_codecs;
f1_codecs.push_back(CreateVideoCodec(97, "H264"));
f1_codecs.push_back(CreateVideoCodec(118, "flexfec-03"));
f1_.set_video_codecs(f1_codecs, f1_codecs);
@ -3295,7 +3294,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, SimSsrcsGenerateNoFlexfecSsrcs) {
{"stream1label"}, 3, &opts);
// Use a single real codec, and then add FlexFEC for it.
std::vector<VideoCodec> f1_codecs;
std::vector<Codec> f1_codecs;
f1_codecs.push_back(CreateVideoCodec(97, "H264"));
f1_codecs.push_back(CreateVideoCodec(118, "flexfec-03"));
f1_.set_video_codecs(f1_codecs, f1_codecs);
@ -4276,10 +4275,10 @@ TEST_F(MediaSessionDescriptionFactoryTest,
H264MatchCriteriaIncludesPacketizationMode) {
// Create two H264 codecs with the same profile level ID and different
// packetization modes.
VideoCodec h264_pm0 = CreateVideoCodec(96, "H264");
Codec h264_pm0 = CreateVideoCodec(96, "H264");
h264_pm0.params[kH264FmtpProfileLevelId] = "42c01f";
h264_pm0.params[kH264FmtpPacketizationMode] = "0";
VideoCodec h264_pm1 = CreateVideoCodec(97, "H264");
Codec h264_pm1 = CreateVideoCodec(97, "H264");
h264_pm1.params[kH264FmtpProfileLevelId] = "42c01f";
h264_pm1.params[kH264FmtpPacketizationMode] = "1";
@ -4380,17 +4379,16 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestSetAudioCodecs) {
UniqueRandomIdGenerator ssrc_generator;
MediaSessionDescriptionFactory sf(nullptr, false, &ssrc_generator, &tdf);
std::vector<AudioCodec> send_codecs = MAKE_VECTOR(kAudioCodecs1);
std::vector<AudioCodec> recv_codecs = MAKE_VECTOR(kAudioCodecs2);
std::vector<Codec> send_codecs = MAKE_VECTOR(kAudioCodecs1);
std::vector<Codec> recv_codecs = MAKE_VECTOR(kAudioCodecs2);
// The merged list of codecs should contain any send codecs that are also
// nominally in the receive codecs list. Payload types should be picked from
// the send codecs and a number-of-channels of 0 and 1 should be equivalent
// (set to 1). This equals what happens when the send codecs are used in an
// offer and the receive codecs are used in the following answer.
const std::vector<AudioCodec> sendrecv_codecs =
MAKE_VECTOR(kAudioCodecsAnswer);
const std::vector<AudioCodec> no_codecs;
const std::vector<Codec> sendrecv_codecs = MAKE_VECTOR(kAudioCodecsAnswer);
const std::vector<Codec> no_codecs;
RTC_CHECK_EQ(send_codecs[2].name, "iLBC")
<< "Please don't change shared test data!";
@ -4452,10 +4450,9 @@ void TestAudioCodecsOffer(RtpTransceiverDirection direction) {
UniqueRandomIdGenerator ssrc_generator;
MediaSessionDescriptionFactory sf(nullptr, false, &ssrc_generator, &tdf);
const std::vector<AudioCodec> send_codecs = MAKE_VECTOR(kAudioCodecs1);
const std::vector<AudioCodec> recv_codecs = MAKE_VECTOR(kAudioCodecs2);
const std::vector<AudioCodec> sendrecv_codecs =
MAKE_VECTOR(kAudioCodecsAnswer);
const std::vector<Codec> send_codecs = MAKE_VECTOR(kAudioCodecs1);
const std::vector<Codec> recv_codecs = MAKE_VECTOR(kAudioCodecs2);
const std::vector<Codec> sendrecv_codecs = MAKE_VECTOR(kAudioCodecsAnswer);
sf.set_audio_codecs(send_codecs, recv_codecs);
MediaSessionOptions opts;
@ -4493,14 +4490,13 @@ void TestAudioCodecsOffer(RtpTransceiverDirection direction) {
}
}
const AudioCodec kOfferAnswerCodecs[] = {
CreateAudioCodec(0, "codec0", 16000, 1),
CreateAudioCodec(1, "codec1", 8000, 1),
CreateAudioCodec(2, "codec2", 8000, 1),
CreateAudioCodec(3, "codec3", 8000, 1),
CreateAudioCodec(4, "codec4", 8000, 2),
CreateAudioCodec(5, "codec5", 32000, 1),
CreateAudioCodec(6, "codec6", 48000, 1)};
const Codec kOfferAnswerCodecs[] = {CreateAudioCodec(0, "codec0", 16000, 1),
CreateAudioCodec(1, "codec1", 8000, 1),
CreateAudioCodec(2, "codec2", 8000, 1),
CreateAudioCodec(3, "codec3", 8000, 1),
CreateAudioCodec(4, "codec4", 8000, 2),
CreateAudioCodec(5, "codec5", 32000, 1),
CreateAudioCodec(6, "codec6", 48000, 1)};
/* The codecs groups below are chosen as per the matrix below. The objective
* is to have different sets of codecs in the inputs, to get unique sets of
@ -4604,7 +4600,7 @@ void TestAudioCodecsAnswer(RtpTransceiverDirection offer_direction,
ASSERT_EQ(MEDIA_TYPE_AUDIO, ac->media_description()->type());
const MediaContentDescription* acd = ac->media_description();
std::vector<AudioCodec> target_codecs;
std::vector<Codec> target_codecs;
// For offers with sendrecv or inactive, we should never reply with more
// codecs than offered, with these codec sets.
switch (offer_direction) {
@ -4637,7 +4633,7 @@ void TestAudioCodecsAnswer(RtpTransceiverDirection offer_direction,
RTC_DCHECK_NOTREACHED();
}
auto format_codecs = [](const std::vector<AudioCodec>& codecs) {
auto format_codecs = [](const std::vector<Codec>& codecs) {
rtc::StringBuilder os;
bool first = true;
os << "{";

2
pc/peer_connection.cc
View file

@ -1141,7 +1141,7 @@ PeerConnection::AddTransceiver(
"Attempted to set an unimplemented parameter of RtpParameters.");
}
std::vector<cricket::VideoCodec> codecs;
std::vector<cricket::Codec> codecs;
// Gather the current codec capabilities to allow checking scalabilityMode and
// codec selection against supported values.
if (media_type == cricket::MEDIA_TYPE_VIDEO) {

8
pc/peer_connection_factory.cc
View file

@ -134,14 +134,14 @@ RtpCapabilities PeerConnectionFactory::GetRtpSenderCapabilities(
RTC_DCHECK_RUN_ON(signaling_thread());
switch (kind) {
case cricket::MEDIA_TYPE_AUDIO: {
cricket::AudioCodecs cricket_codecs;
cricket::Codecs cricket_codecs;
cricket_codecs = media_engine()->voice().send_codecs();
auto extensions =
GetDefaultEnabledRtpHeaderExtensions(media_engine()->voice());
return ToRtpCapabilities(cricket_codecs, extensions);
}
case cricket::MEDIA_TYPE_VIDEO: {
cricket::VideoCodecs cricket_codecs;
cricket::Codecs cricket_codecs;
cricket_codecs = media_engine()->video().send_codecs(context_->use_rtx());
auto extensions =
GetDefaultEnabledRtpHeaderExtensions(media_engine()->video());
@ -161,14 +161,14 @@ RtpCapabilities PeerConnectionFactory::GetRtpReceiverCapabilities(
RTC_DCHECK_RUN_ON(signaling_thread());
switch (kind) {
case cricket::MEDIA_TYPE_AUDIO: {
cricket::AudioCodecs cricket_codecs;
cricket::Codecs cricket_codecs;
cricket_codecs = media_engine()->voice().recv_codecs();
auto extensions =
GetDefaultEnabledRtpHeaderExtensions(media_engine()->voice());
return ToRtpCapabilities(cricket_codecs, extensions);
}
case cricket::MEDIA_TYPE_VIDEO: {
cricket::VideoCodecs cricket_codecs =
cricket::Codecs cricket_codecs =
media_engine()->video().recv_codecs(context_->use_rtx());
auto extensions =
GetDefaultEnabledRtpHeaderExtensions(media_engine()->video());

4
pc/peer_connection_integrationtest.cc
View file

@ -2573,7 +2573,7 @@ TEST_P(PeerConnectionIntegrationTest, CodecNamesAreCaseInsensitive) {
ASSERT_NE(nullptr, audio);
auto audio_codecs = audio->codecs();
audio_codecs.erase(std::remove_if(audio_codecs.begin(), audio_codecs.end(),
[](const cricket::AudioCodec& codec) {
[](const cricket::Codec& codec) {
return codec.name != "opus";
}),
audio_codecs.end());
@ -2586,7 +2586,7 @@ TEST_P(PeerConnectionIntegrationTest, CodecNamesAreCaseInsensitive) {
ASSERT_NE(nullptr, video);
auto video_codecs = video->codecs();
video_codecs.erase(std::remove_if(video_codecs.begin(), video_codecs.end(),
[](const cricket::VideoCodec& codec) {
[](const cricket::Codec& codec) {
return codec.name != "VP8";
}),
video_codecs.end());

48
pc/peer_connection_media_unittest.cc
View file

@ -599,7 +599,7 @@ TEST_P(PeerConnectionMediaTest,
// Test that raw packetization is not set in the offer by default.
TEST_P(PeerConnectionMediaTest, RawPacketizationNotSetInOffer) {
std::vector<cricket::VideoCodec> fake_codecs;
std::vector<cricket::Codec> fake_codecs;
fake_codecs.push_back(cricket::CreateVideoCodec(111, cricket::kVp8CodecName));
fake_codecs.push_back(cricket::CreateVideoRtxCodec(112, 111));
fake_codecs.push_back(cricket::CreateVideoCodec(113, cricket::kVp9CodecName));
@ -621,7 +621,7 @@ TEST_P(PeerConnectionMediaTest, RawPacketizationNotSetInOffer) {
// Test that raw packetization is set in the offer and answer for all
// video payload when raw_packetization_for_video is true.
TEST_P(PeerConnectionMediaTest, RawPacketizationSetInOfferAndAnswer) {
std::vector<cricket::VideoCodec> fake_codecs;
std::vector<cricket::Codec> fake_codecs;
fake_codecs.push_back(cricket::CreateVideoCodec(111, cricket::kVp8CodecName));
fake_codecs.push_back(cricket::CreateVideoRtxCodec(112, 111));
fake_codecs.push_back(cricket::CreateVideoCodec(113, cricket::kVp9CodecName));
@ -664,7 +664,7 @@ TEST_P(PeerConnectionMediaTest, RawPacketizationSetInOfferAndAnswer) {
// raw_packetization_for_video is true if it was not set in the offer.
TEST_P(PeerConnectionMediaTest,
RawPacketizationNotSetInAnswerWhenNotSetInOffer) {
std::vector<cricket::VideoCodec> fake_codecs;
std::vector<cricket::Codec> fake_codecs;
fake_codecs.push_back(cricket::CreateVideoCodec(111, cricket::kVp8CodecName));
fake_codecs.push_back(cricket::CreateVideoRtxCodec(112, 111));
fake_codecs.push_back(cricket::CreateVideoCodec(113, cricket::kVp9CodecName));
@ -906,9 +906,9 @@ TEST_P(PeerConnectionMediaTest, AnswerHasDifferentDirectionsForAudioVideo) {
}
void AddComfortNoiseCodecsToSend(cricket::FakeMediaEngine* media_engine) {
const cricket::AudioCodec kComfortNoiseCodec8k =
const cricket::Codec kComfortNoiseCodec8k =
cricket::CreateAudioCodec(102, cricket::kCnCodecName, 8000, 1);
const cricket::AudioCodec kComfortNoiseCodec16k =
const cricket::Codec kComfortNoiseCodec16k =
cricket::CreateAudioCodec(103, cricket::kCnCodecName, 16000, 1);
auto codecs = media_engine->voice().send_codecs();
@ -1246,13 +1246,13 @@ TEST_P(PeerConnectionMediaTest, SetRemoteDescriptionFailsWithDuplicateMids) {
// endpoint selected a different payload type or there was a conflict), the RED
// fmtp line is modified to refer to the correct payload type.
TEST_P(PeerConnectionMediaTest, RedFmtpPayloadTypeReassigned) {
std::vector<cricket::AudioCodec> caller_fake_codecs;
std::vector<cricket::Codec> caller_fake_codecs;
caller_fake_codecs.push_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
auto caller_fake_engine = std::make_unique<FakeMediaEngine>();
caller_fake_engine->SetAudioCodecs(caller_fake_codecs);
auto caller = CreatePeerConnectionWithAudio(std::move(caller_fake_engine));
std::vector<cricket::AudioCodec> callee_fake_codecs;
std::vector<cricket::Codec> callee_fake_codecs;
callee_fake_codecs.push_back(cricket::CreateAudioCodec(120, "foo", 0, 1));
callee_fake_codecs.push_back(
cricket::CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
@ -1289,7 +1289,7 @@ TEST_P(PeerConnectionMediaTest, RedFmtpPayloadTypeReassigned) {
// Test that RED without fmtp does match RED without fmtp.
TEST_P(PeerConnectionMediaTest, RedFmtpPayloadTypeNoFmtpMatchNoFmtp) {
std::vector<cricket::AudioCodec> caller_fake_codecs;
std::vector<cricket::Codec> caller_fake_codecs;
caller_fake_codecs.push_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
caller_fake_codecs.push_back(
cricket::CreateAudioCodec(101, cricket::kRedCodecName, 0, 1));
@ -1297,7 +1297,7 @@ TEST_P(PeerConnectionMediaTest, RedFmtpPayloadTypeNoFmtpMatchNoFmtp) {
caller_fake_engine->SetAudioCodecs(caller_fake_codecs);
auto caller = CreatePeerConnectionWithAudio(std::move(caller_fake_engine));
std::vector<cricket::AudioCodec> callee_fake_codecs;
std::vector<cricket::Codec> callee_fake_codecs;
callee_fake_codecs.push_back(cricket::CreateAudioCodec(120, "foo", 0, 1));
callee_fake_codecs.push_back(
cricket::CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
@ -1331,7 +1331,7 @@ TEST_P(PeerConnectionMediaTest, RedFmtpPayloadTypeNoFmtpMatchNoFmtp) {
// Test that RED without fmtp does not match RED with fmtp.
TEST_P(PeerConnectionMediaTest, RedFmtpPayloadTypeNoFmtpNoMatchFmtp) {
std::vector<cricket::AudioCodec> caller_fake_codecs;
std::vector<cricket::Codec> caller_fake_codecs;
caller_fake_codecs.push_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
caller_fake_codecs.push_back(
cricket::CreateAudioCodec(101, cricket::kRedCodecName, 0, 1));
@ -1339,7 +1339,7 @@ TEST_P(PeerConnectionMediaTest, RedFmtpPayloadTypeNoFmtpNoMatchFmtp) {
caller_fake_engine->SetAudioCodecs(caller_fake_codecs);
auto caller = CreatePeerConnectionWithAudio(std::move(caller_fake_engine));
std::vector<cricket::AudioCodec> callee_fake_codecs;
std::vector<cricket::Codec> callee_fake_codecs;
callee_fake_codecs.push_back(cricket::CreateAudioCodec(120, "foo", 0, 1));
callee_fake_codecs.push_back(
cricket::CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
@ -1378,7 +1378,7 @@ TEST_P(PeerConnectionMediaTest, RedFmtpPayloadTypeNoFmtpNoMatchFmtp) {
// Test that RED with fmtp must match base codecs.
TEST_P(PeerConnectionMediaTest, RedFmtpPayloadTypeMustMatchBaseCodecs) {
std::vector<cricket::AudioCodec> caller_fake_codecs;
std::vector<cricket::Codec> caller_fake_codecs;
caller_fake_codecs.push_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
caller_fake_codecs.push_back(
cricket::CreateAudioCodec(101, cricket::kRedCodecName, 0, 1));
@ -1388,7 +1388,7 @@ TEST_P(PeerConnectionMediaTest, RedFmtpPayloadTypeMustMatchBaseCodecs) {
caller_fake_engine->SetAudioCodecs(caller_fake_codecs);
auto caller = CreatePeerConnectionWithAudio(std::move(caller_fake_engine));
std::vector<cricket::AudioCodec> callee_fake_codecs;
std::vector<cricket::Codec> callee_fake_codecs;
callee_fake_codecs.push_back(cricket::CreateAudioCodec(120, "foo", 0, 1));
callee_fake_codecs.push_back(
cricket::CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
@ -1412,7 +1412,7 @@ TEST_P(PeerConnectionMediaTest, RedFmtpPayloadTypeMustMatchBaseCodecs) {
// Test behaviour when the RED fmtp attempts to specify different codecs
// which is not supported.
TEST_P(PeerConnectionMediaTest, RedFmtpPayloadMixed) {
std::vector<cricket::AudioCodec> caller_fake_codecs;
std::vector<cricket::Codec> caller_fake_codecs;
caller_fake_codecs.push_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
caller_fake_codecs.push_back(cricket::CreateAudioCodec(102, "bar", 0, 1));
caller_fake_codecs.push_back(
@ -1423,7 +1423,7 @@ TEST_P(PeerConnectionMediaTest, RedFmtpPayloadMixed) {
caller_fake_engine->SetAudioCodecs(caller_fake_codecs);
auto caller = CreatePeerConnectionWithAudio(std::move(caller_fake_engine));
std::vector<cricket::AudioCodec> callee_fake_codecs;
std::vector<cricket::Codec> callee_fake_codecs;
callee_fake_codecs.push_back(cricket::CreateAudioCodec(120, "foo", 0, 1));
callee_fake_codecs.push_back(
cricket::CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
@ -1446,7 +1446,7 @@ TEST_P(PeerConnectionMediaTest, RedFmtpPayloadMixed) {
// Test behaviour when the RED fmtp attempts to negotiate different levels of
// redundancy.
TEST_P(PeerConnectionMediaTest, RedFmtpPayloadDifferentRedundancy) {
std::vector<cricket::AudioCodec> caller_fake_codecs;
std::vector<cricket::Codec> caller_fake_codecs;
caller_fake_codecs.push_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
caller_fake_codecs.push_back(
cricket::CreateAudioCodec(101, cricket::kRedCodecName, 0, 1));
@ -1456,7 +1456,7 @@ TEST_P(PeerConnectionMediaTest, RedFmtpPayloadDifferentRedundancy) {
caller_fake_engine->SetAudioCodecs(caller_fake_codecs);
auto caller = CreatePeerConnectionWithAudio(std::move(caller_fake_engine));
std::vector<cricket::AudioCodec> callee_fake_codecs;
std::vector<cricket::Codec> callee_fake_codecs;
callee_fake_codecs.push_back(cricket::CreateAudioCodec(120, "foo", 0, 1));
callee_fake_codecs.push_back(
cricket::CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
@ -2004,12 +2004,12 @@ TEST_F(PeerConnectionMediaTestUnifiedPlan,
SetCodecPreferencesAvoidsPayloadTypeConflictInOffer) {
auto fake_engine = std::make_unique<cricket::FakeMediaEngine>();
std::vector<cricket::AudioCodec> audio_codecs;
std::vector<cricket::Codec> audio_codecs;
audio_codecs.emplace_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
audio_codecs.emplace_back(cricket::CreateAudioRtxCodec(101, 100));
fake_engine->SetAudioCodecs(audio_codecs);
std::vector<cricket::VideoCodec> video_codecs;
std::vector<cricket::Codec> video_codecs;
video_codecs.emplace_back(cricket::CreateVideoCodec(100, "bar"));
video_codecs.emplace_back(cricket::CreateVideoRtxCodec(101, 100));
fake_engine->SetVideoCodecs(video_codecs);
@ -2045,12 +2045,12 @@ TEST_F(PeerConnectionMediaTestUnifiedPlan,
SetCodecPreferencesAvoidsPayloadTypeConflictInAnswer) {
auto fake_engine = std::make_unique<cricket::FakeMediaEngine>();
std::vector<cricket::AudioCodec> audio_codecs;
std::vector<cricket::Codec> audio_codecs;
audio_codecs.emplace_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
audio_codecs.emplace_back(cricket::CreateAudioRtxCodec(101, 100));
fake_engine->SetAudioCodecs(audio_codecs);
std::vector<cricket::VideoCodec> video_codecs;
std::vector<cricket::Codec> video_codecs;
video_codecs.emplace_back(cricket::CreateVideoCodec(100, "bar"));
video_codecs.emplace_back(cricket::CreateVideoRtxCodec(101, 100));
fake_engine->SetVideoCodecs(video_codecs);
@ -2090,12 +2090,12 @@ TEST_F(PeerConnectionMediaTestUnifiedPlan,
SetCodecPreferencesAvoidsPayloadTypeConflictInSubsequentOffer) {
auto fake_engine = std::make_unique<cricket::FakeMediaEngine>();
std::vector<cricket::AudioCodec> audio_codecs;
std::vector<cricket::Codec> audio_codecs;
audio_codecs.emplace_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
audio_codecs.emplace_back(cricket::CreateAudioRtxCodec(101, 100));
fake_engine->SetAudioCodecs(audio_codecs);
std::vector<cricket::VideoCodec> video_codecs;
std::vector<cricket::Codec> video_codecs;
video_codecs.emplace_back(cricket::CreateVideoCodec(100, "bar"));
video_codecs.emplace_back(cricket::CreateVideoRtxCodec(101, 100));
fake_engine->SetVideoCodecs(video_codecs);
@ -2136,7 +2136,7 @@ TEST_F(PeerConnectionMediaTestUnifiedPlan,
SetCodecPreferencesReceiveOnlyWithSendOnlyTransceiverStops) {
auto fake_engine = std::make_unique<cricket::FakeMediaEngine>();
std::vector<cricket::AudioCodec> audio_codecs;
std::vector<cricket::Codec> audio_codecs;
audio_codecs.emplace_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
fake_engine->SetAudioRecvCodecs(audio_codecs);

31
pc/rtp_parameters_conversion_unittest.cc
View file

@ -397,8 +397,7 @@ TEST(RtpParametersConversionTest, ToRtcpFeedbackErrors) {
}
TEST(RtpParametersConversionTest, ToAudioRtpCodecCapability) {
cricket::AudioCodec cricket_codec =
cricket::CreateAudioCodec(50, "foo", 22222, 4);
cricket::Codec cricket_codec = cricket::CreateAudioCodec(50, "foo", 22222, 4);
cricket_codec.params["foo"] = "bar";
cricket_codec.feedback_params.Add(cricket::FeedbackParam("transport-cc"));
RtpCodecCapability codec = ToRtpCodecCapability(cricket_codec);
@ -416,7 +415,7 @@ TEST(RtpParametersConversionTest, ToAudioRtpCodecCapability) {
}
TEST(RtpParametersConversionTest, ToVideoRtpCodecCapability) {
cricket::VideoCodec cricket_codec = cricket::CreateVideoCodec(101, "VID");
cricket::Codec cricket_codec = cricket::CreateVideoCodec(101, "VID");
cricket_codec.clockrate = 80000;
cricket_codec.params["foo"] = "bar";
cricket_codec.params["ANOTHER"] = "param";
@ -464,8 +463,7 @@ TEST(RtpParametersConversionTest, ToRtpEncodingsWithMultipleStreamParams) {
}
TEST(RtpParametersConversionTest, ToAudioRtpCodecParameters) {
cricket::AudioCodec cricket_codec =
cricket::CreateAudioCodec(50, "foo", 22222, 4);
cricket::Codec cricket_codec = cricket::CreateAudioCodec(50, "foo", 22222, 4);
cricket_codec.params["foo"] = "bar";
cricket_codec.feedback_params.Add(cricket::FeedbackParam("transport-cc"));
RtpCodecParameters codec = ToRtpCodecParameters(cricket_codec);
@ -483,7 +481,7 @@ TEST(RtpParametersConversionTest, ToAudioRtpCodecParameters) {
}
TEST(RtpParametersConversionTest, ToVideoRtpCodecParameters) {
cricket::VideoCodec cricket_codec = cricket::CreateVideoCodec(101, "VID");
cricket::Codec cricket_codec = cricket::CreateVideoCodec(101, "VID");
cricket_codec.clockrate = 80000;
cricket_codec.params["foo"] = "bar";
cricket_codec.params["ANOTHER"] = "param";
@ -509,8 +507,7 @@ TEST(RtpParametersConversionTest, ToVideoRtpCodecParameters) {
// An unknown feedback param should just be ignored.
TEST(RtpParametersConversionTest, ToRtpCodecCapabilityUnknownFeedbackParam) {
cricket::AudioCodec cricket_codec =
cricket::CreateAudioCodec(50, "foo", 22222, 4);
cricket::Codec cricket_codec = cricket::CreateAudioCodec(50, "foo", 22222, 4);
cricket_codec.params["foo"] = "bar";
cricket_codec.feedback_params.Add({"unknown", "param"});
cricket_codec.feedback_params.Add(cricket::FeedbackParam("transport-cc"));
@ -525,21 +522,21 @@ TEST(RtpParametersConversionTest, ToRtpCodecCapabilityUnknownFeedbackParam) {
// test that the result of ToRtpCodecCapability ends up in the result, and that
// the "fec" list is assembled correctly.
TEST(RtpParametersConversionTest, ToRtpCapabilities) {
cricket::VideoCodec vp8 = cricket::CreateVideoCodec(101, "VP8");
cricket::Codec vp8 = cricket::CreateVideoCodec(101, "VP8");
vp8.clockrate = 90000;
cricket::VideoCodec red = cricket::CreateVideoCodec(102, "red");
cricket::Codec red = cricket::CreateVideoCodec(102, "red");
red.clockrate = 90000;
cricket::VideoCodec ulpfec = cricket::CreateVideoCodec(103, "ulpfec");
cricket::Codec ulpfec = cricket::CreateVideoCodec(103, "ulpfec");
ulpfec.clockrate = 90000;
cricket::VideoCodec flexfec = cricket::CreateVideoCodec(102, "flexfec-03");
cricket::Codec flexfec = cricket::CreateVideoCodec(102, "flexfec-03");
flexfec.clockrate = 90000;
cricket::VideoCodec rtx = cricket::CreateVideoRtxCodec(014, 101);
cricket::Codec rtx = cricket::CreateVideoRtxCodec(014, 101);
cricket::VideoCodec rtx2 = cricket::CreateVideoRtxCodec(105, 109);
cricket::Codec rtx2 = cricket::CreateVideoRtxCodec(105, 109);
RtpCapabilities capabilities =
ToRtpCapabilities({vp8, ulpfec, rtx, rtx2}, {{"uri", 1}, {"uri2", 3}});
@ -570,13 +567,13 @@ TEST(RtpParametersConversionTest, ToRtpCapabilities) {
}
TEST(RtpParametersConversionTest, ToRtpParameters) {
cricket::VideoCodec vp8 = cricket::CreateVideoCodec(101, "VP8");
cricket::Codec vp8 = cricket::CreateVideoCodec(101, "VP8");
vp8.clockrate = 90000;
cricket::VideoCodec red = cricket::CreateVideoCodec(102, "red");
cricket::Codec red = cricket::CreateVideoCodec(102, "red");
red.clockrate = 90000;
cricket::VideoCodec ulpfec = cricket::CreateVideoCodec(103, "ulpfec");
cricket::Codec ulpfec = cricket::CreateVideoCodec(103, "ulpfec");
ulpfec.clockrate = 90000;
cricket::StreamParamsVec streams;

2
pc/rtp_sender_receiver_unittest.cc
View file

@ -174,7 +174,7 @@ class RtpSenderReceiverTest
// Needed to use DTMF sender.
void AddDtmfCodec() {
cricket::AudioSenderParameter params;
const cricket::AudioCodec kTelephoneEventCodec =
const cricket::Codec kTelephoneEventCodec =
cricket::CreateAudioCodec(106, "telephone-event", 8000, 1);
params.codecs.push_back(kTelephoneEventCodec);
voice_media_send_channel()->SetSenderParameters(params);

5
pc/test/mock_rtp_sender_internal.h
View file

@ -68,10 +68,7 @@ class MockRtpSenderInternal : public RtpSenderInternal {
CheckCodecParameters,
(const RtpParameters&),
(override));
MOCK_METHOD(void,
SetSendCodecs,
(std::vector<cricket::VideoCodec>),
(override));
MOCK_METHOD(void, SetSendCodecs, (std::vector<cricket::Codec>), (override));
MOCK_METHOD(rtc::scoped_refptr<DtmfSenderInterface>,
GetDtmfSender,
(),

4
pc/webrtc_sdp.cc
View file

@ -3633,7 +3633,7 @@ bool ParseRtpmapAttribute(absl::string_view line,
}
if (media_type == cricket::MEDIA_TYPE_VIDEO) {
for (const cricket::VideoCodec& existing_codec : media_desc->codecs()) {
for (const cricket::Codec& existing_codec : media_desc->codecs()) {
if (!existing_codec.name.empty() && payload_type == existing_codec.id &&
(!absl::EqualsIgnoreCase(encoding_name, existing_codec.name) ||
clock_rate != existing_codec.clockrate)) {
@ -3664,7 +3664,7 @@ bool ParseRtpmapAttribute(absl::string_view line,
return ParseFailed(line, "At most 24 channels are supported.", error);
}
for (const cricket::AudioCodec& existing_codec : media_desc->codecs()) {
for (const cricket::Codec& existing_codec : media_desc->codecs()) {
// TODO(crbug.com/1338902) re-add checks for clockrate and number of
// channels.
if (!existing_codec.name.empty() && payload_type == existing_codec.id &&

36
pc/webrtc_sdp_unittest.cc
View file

@ -1880,15 +1880,15 @@ class WebRtcSdpTest : public ::testing::Test {
GetFirstVideoContentDescription(jdesc_output->description());
ASSERT_TRUE(vcd);
ASSERT_FALSE(vcd->codecs().empty());
cricket::VideoCodec vp8 = vcd->codecs()[0];
cricket::Codec vp8 = vcd->codecs()[0];
EXPECT_EQ("VP8", vp8.name);
EXPECT_EQ(99, vp8.id);
cricket::VideoCodec rtx = vcd->codecs()[1];
cricket::Codec rtx = vcd->codecs()[1];
EXPECT_EQ("RTX", rtx.name);
EXPECT_EQ(95, rtx.id);
VerifyCodecParameter(rtx.params, "apt", vp8.id);
// VP9 is listed last in the m= line so should come after VP8 and RTX.
cricket::VideoCodec vp9 = vcd->codecs()[2];
cricket::Codec vp9 = vcd->codecs()[2];
EXPECT_EQ("VP9", vp9.name);
EXPECT_EQ(96, vp9.id);
}
@ -1935,7 +1935,7 @@ class WebRtcSdpTest : public ::testing::Test {
GetFirstVideoContentDescription(jdesc_output->description());
ASSERT_TRUE(vcd);
ASSERT_FALSE(vcd->codecs().empty());
cricket::VideoCodec vp8 = vcd->codecs()[0];
cricket::Codec vp8 = vcd->codecs()[0];
EXPECT_EQ(vp8.name, "VP8");
EXPECT_EQ(101, vp8.id);
EXPECT_TRUE(vp8.HasFeedbackParam(cricket::FeedbackParam(
@ -2280,7 +2280,7 @@ TEST_F(WebRtcSdpTest, ParseSslTcpCandidate) {
}
TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithH264) {
cricket::VideoCodec h264_codec = cricket::CreateVideoCodec("H264");
cricket::Codec h264_codec = cricket::CreateVideoCodec("H264");
h264_codec.SetParam("profile-level-id", "42e01f");
h264_codec.SetParam("level-asymmetry-allowed", "1");
h264_codec.SetParam("packetization-mode", "1");
@ -2368,7 +2368,7 @@ TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithoutRtpmap) {
EXPECT_TRUE(SdpDeserialize(kSdpNoRtpmapString, &jdesc));
cricket::AudioContentDescription* audio =
cricket::GetFirstAudioContentDescription(jdesc.description());
cricket::AudioCodecs ref_codecs;
cricket::Codecs ref_codecs;
// The codecs in the AudioContentDescription should be in the same order as
// the payload types (<fmt>s) on the m= line.
ref_codecs.push_back(cricket::CreateAudioCodec(0, "PCMU", 8000, 1));
@ -3232,7 +3232,7 @@ TEST_F(WebRtcSdpTest, DeserializeVideoFmtp) {
GetFirstVideoContentDescription(jdesc_output.description());
ASSERT_TRUE(vcd);
ASSERT_FALSE(vcd->codecs().empty());
cricket::VideoCodec vp8 = vcd->codecs()[0];
cricket::Codec vp8 = vcd->codecs()[0];
EXPECT_EQ("VP8", vp8.name);
EXPECT_EQ(120, vp8.id);
webrtc::CodecParameterMap::iterator found =
@ -3266,7 +3266,7 @@ TEST_F(WebRtcSdpTest, DeserializeVideoFmtpWithSprops) {
GetFirstVideoContentDescription(jdesc_output.description());
ASSERT_TRUE(vcd);
ASSERT_FALSE(vcd->codecs().empty());
cricket::VideoCodec h264 = vcd->codecs()[0];
cricket::Codec h264 = vcd->codecs()[0];
EXPECT_EQ("H264", h264.name);
EXPECT_EQ(98, h264.id);
webrtc::CodecParameterMap::const_iterator found =
@ -3299,7 +3299,7 @@ TEST_F(WebRtcSdpTest, DeserializeVideoFmtpWithSpace) {
GetFirstVideoContentDescription(jdesc_output.description());
ASSERT_TRUE(vcd);
ASSERT_FALSE(vcd->codecs().empty());
cricket::VideoCodec vp8 = vcd->codecs()[0];
cricket::Codec vp8 = vcd->codecs()[0];
EXPECT_EQ("VP8", vp8.name);
EXPECT_EQ(120, vp8.id);
webrtc::CodecParameterMap::iterator found =
@ -3345,15 +3345,15 @@ TEST_F(WebRtcSdpTest, DeserializePacketizationAttributeWithIllegalValue) {
GetFirstVideoContentDescription(jdesc_output.description());
ASSERT_TRUE(vcd);
ASSERT_THAT(vcd->codecs(), testing::SizeIs(3));
cricket::VideoCodec vp8 = vcd->codecs()[0];
cricket::Codec vp8 = vcd->codecs()[0];
EXPECT_EQ(vp8.name, "VP8");
EXPECT_EQ(vp8.id, 120);
EXPECT_EQ(vp8.packetization, "raw");
cricket::VideoCodec vp9 = vcd->codecs()[1];
cricket::Codec vp9 = vcd->codecs()[1];
EXPECT_EQ(vp9.name, "VP9");
EXPECT_EQ(vp9.id, 121);
EXPECT_EQ(vp9.packetization, absl::nullopt);
cricket::VideoCodec h264 = vcd->codecs()[2];
cricket::Codec h264 = vcd->codecs()[2];
EXPECT_EQ(h264.name, "H264");
EXPECT_EQ(h264.id, 122);
EXPECT_EQ(h264.packetization, absl::nullopt);
@ -3362,7 +3362,7 @@ TEST_F(WebRtcSdpTest, DeserializePacketizationAttributeWithIllegalValue) {
TEST_F(WebRtcSdpTest, SerializeAudioFmtpWithUnknownParameter) {
AudioContentDescription* acd = GetFirstAudioContentDescription(&desc_);
cricket::AudioCodecs codecs = acd->codecs();
cricket::Codecs codecs = acd->codecs();
codecs[0].params["unknown-future-parameter"] = "SomeFutureValue";
acd->set_codecs(codecs);
@ -3379,7 +3379,7 @@ TEST_F(WebRtcSdpTest, SerializeAudioFmtpWithUnknownParameter) {
TEST_F(WebRtcSdpTest, SerializeAudioFmtpWithKnownFmtpParameter) {
AudioContentDescription* acd = GetFirstAudioContentDescription(&desc_);
cricket::AudioCodecs codecs = acd->codecs();
cricket::Codecs codecs = acd->codecs();
codecs[0].params["stereo"] = "1";
acd->set_codecs(codecs);
@ -3395,7 +3395,7 @@ TEST_F(WebRtcSdpTest, SerializeAudioFmtpWithKnownFmtpParameter) {
TEST_F(WebRtcSdpTest, SerializeAudioFmtpWithPTimeAndMaxPTime) {
AudioContentDescription* acd = GetFirstAudioContentDescription(&desc_);
cricket::AudioCodecs codecs = acd->codecs();
cricket::Codecs codecs = acd->codecs();
codecs[0].params["ptime"] = "20";
codecs[0].params["maxptime"] = "120";
acd->set_codecs(codecs);
@ -3414,7 +3414,7 @@ TEST_F(WebRtcSdpTest, SerializeAudioFmtpWithPTimeAndMaxPTime) {
TEST_F(WebRtcSdpTest, SerializeAudioFmtpWithTelephoneEvent) {
AudioContentDescription* acd = GetFirstAudioContentDescription(&desc_);
cricket::AudioCodecs codecs = acd->codecs();
cricket::Codecs codecs = acd->codecs();
cricket::Codec dtmf =
cricket::CreateAudioCodec(105, "telephone-event", 8000, 1);
dtmf.params[""] = "0-15";
@ -3437,7 +3437,7 @@ TEST_F(WebRtcSdpTest, SerializeAudioFmtpWithTelephoneEvent) {
TEST_F(WebRtcSdpTest, SerializeVideoFmtp) {
VideoContentDescription* vcd = GetFirstVideoContentDescription(&desc_);
cricket::VideoCodecs codecs = vcd->codecs();
cricket::Codecs codecs = vcd->codecs();
codecs[0].params["x-google-min-bitrate"] = "10";
vcd->set_codecs(codecs);
@ -3453,7 +3453,7 @@ TEST_F(WebRtcSdpTest, SerializeVideoFmtp) {
TEST_F(WebRtcSdpTest, SerializeVideoPacketizationAttribute) {
VideoContentDescription* vcd = GetFirstVideoContentDescription(&desc_);
cricket::VideoCodecs codecs = vcd->codecs();
cricket::Codecs codecs = vcd->codecs();
codecs[0].packetization = "raw";
vcd->set_codecs(codecs);