From d78e30e00bff28779e97df0ff19c539a73dfe8f8 Mon Sep 17 00:00:00 2001 From: Harald Alvestrand Date: Mon, 29 Apr 2024 10:15:34 +0000 Subject: [PATCH] Deprecate cricket::VideoCodec and cricket::AudioCodec 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 Reviewed-by: Florent Castelli Cr-Commit-Position: refs/heads/main@{#42194} --- media/base/codec.h | 9 +- media/base/codec_unittest.cc | 165 +++++++++---------- media/base/fake_media_engine.cc | 50 +++--- media/base/fake_media_engine.h | 72 ++++---- media/base/media_engine.h | 12 +- media/base/media_engine_unittest.cc | 4 +- media/engine/fake_webrtc_video_engine.cc | 8 +- media/engine/payload_type_mapper.cc | 6 +- media/engine/payload_type_mapper.h | 4 +- media/engine/payload_type_mapper_unittest.cc | 2 +- media/engine/webrtc_video_engine.cc | 45 +++-- media/engine/webrtc_video_engine.h | 20 +-- media/engine/webrtc_video_engine_unittest.cc | 164 +++++++++--------- media/engine/webrtc_voice_engine.cc | 52 +++--- media/engine/webrtc_voice_engine.h | 16 +- media/engine/webrtc_voice_engine_unittest.cc | 45 +++-- pc/channel.cc | 10 +- pc/channel_unittest.cc | 52 +++--- pc/media_session.cc | 62 ++++--- pc/media_session.h | 50 +++--- pc/media_session_unittest.cc | 146 ++++++++-------- pc/peer_connection.cc | 2 +- pc/peer_connection_factory.cc | 8 +- pc/peer_connection_integrationtest.cc | 4 +- pc/peer_connection_media_unittest.cc | 48 +++--- pc/rtp_parameters_conversion_unittest.cc | 31 ++-- pc/rtp_sender_receiver_unittest.cc | 2 +- pc/test/mock_rtp_sender_internal.h | 5 +- pc/webrtc_sdp.cc | 4 +- pc/webrtc_sdp_unittest.cc | 36 ++-- 30 files changed, 546 insertions(+), 588 deletions(-) diff --git a/media/base/codec.h b/media/base/codec.h index af604b74dc..99a6852462 100644 --- a/media/base/codec.h +++ b/media/base/codec.h @@ -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; -using AudioCodecs = std::vector; +using VideoCodecs [[deprecated]] = std::vector; +using AudioCodecs [[deprecated]] = std::vector; +using Codecs = std::vector; Codec CreateAudioCodec(int id, const std::string& name, diff --git a/media/base/codec_unittest.cc b/media/base/codec_unittest.cc index b9852595fa..08b37fb34e 100644 --- a/media/base/codec_unittest.cc +++ b/media/base/codec_unittest.cc @@ -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); diff --git a/media/base/fake_media_engine.cc b/media/base/fake_media_engine.cc index 5a1da3326e..d5c0e02585 100644 --- a/media/base/fake_media_engine.cc +++ b/media/base/fake_media_engine.cc @@ -62,8 +62,7 @@ FakeVoiceMediaReceiveChannel::FakeVoiceMediaReceiveChannel( SetOptions(options); } FakeVoiceMediaReceiveChannel::~FakeVoiceMediaReceiveChannel() = default; -const std::vector& FakeVoiceMediaReceiveChannel::recv_codecs() - const { +const std::vector& FakeVoiceMediaReceiveChannel::recv_codecs() const { return recv_codecs_; } const std::vector& @@ -160,7 +159,7 @@ std::vector FakeVoiceMediaReceiveChannel::GetSources( return std::vector(); } bool FakeVoiceMediaReceiveChannel::SetRecvCodecs( - const std::vector& codecs) { + const std::vector& 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& FakeVoiceMediaSendChannel::send_codecs() const { +const std::vector& FakeVoiceMediaSendChannel::send_codecs() const { return send_codecs_; } absl::optional 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::const_iterator it = send_codecs_.begin(); + for (std::vector::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& codecs) { + const std::vector& 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& FakeVideoMediaSendChannel::send_codecs() const { +const std::vector& FakeVideoMediaSendChannel::send_codecs() const { return send_codecs_; } -const std::vector& FakeVideoMediaSendChannel::codecs() const { +const std::vector& 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& codecs) { + const std::vector& 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& FakeVideoMediaReceiveChannel::recv_codecs() - const { +const std::vector& FakeVideoMediaReceiveChannel::recv_codecs() const { return recv_codecs_; } bool FakeVideoMediaReceiveChannel::rendering() const { @@ -503,7 +501,7 @@ absl::optional FakeVideoMediaReceiveChannel::GetBaseMinimumPlayoutDelayMs( return absl::nullopt; } bool FakeVideoMediaReceiveChannel::SetRecvCodecs( - const std::vector& codecs) { + const std::vector& 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& FakeVoiceEngine::send_codecs() const { +const std::vector& FakeVoiceEngine::send_codecs() const { return send_codecs_; } -const std::vector& FakeVoiceEngine::recv_codecs() const { +const std::vector& FakeVoiceEngine::recv_codecs() const { return recv_codecs_; } -void FakeVoiceEngine::SetCodecs(const std::vector& codecs) { +void FakeVoiceEngine::SetCodecs(const std::vector& codecs) { send_codecs_ = codecs; recv_codecs_ = codecs; } -void FakeVoiceEngine::SetRecvCodecs(const std::vector& codecs) { +void FakeVoiceEngine::SetRecvCodecs(const std::vector& codecs) { recv_codecs_ = codecs; } -void FakeVoiceEngine::SetSendCodecs(const std::vector& codecs) { +void FakeVoiceEngine::SetSendCodecs(const std::vector& codecs) { send_codecs_ = codecs; } int FakeVoiceEngine::GetInputLevel() { @@ -647,19 +645,19 @@ FakeVideoEngine::CreateReceiveChannel( call->network_thread()); return ch; } -std::vector FakeVideoEngine::send_codecs(bool use_rtx) const { +std::vector FakeVideoEngine::send_codecs(bool use_rtx) const { return send_codecs_; } -std::vector FakeVideoEngine::recv_codecs(bool use_rtx) const { +std::vector FakeVideoEngine::recv_codecs(bool use_rtx) const { return recv_codecs_; } -void FakeVideoEngine::SetSendCodecs(const std::vector& codecs) { +void FakeVideoEngine::SetSendCodecs(const std::vector& codecs) { send_codecs_ = codecs; } -void FakeVideoEngine::SetRecvCodecs(const std::vector& codecs) { +void FakeVideoEngine::SetRecvCodecs(const std::vector& codecs) { recv_codecs_ = codecs; } @@ -682,18 +680,16 @@ FakeMediaEngine::FakeMediaEngine() voice_(static_cast(&voice())), video_(static_cast(&video())) {} FakeMediaEngine::~FakeMediaEngine() {} -void FakeMediaEngine::SetAudioCodecs(const std::vector& codecs) { +void FakeMediaEngine::SetAudioCodecs(const std::vector& codecs) { voice_->SetCodecs(codecs); } -void FakeMediaEngine::SetAudioRecvCodecs( - const std::vector& codecs) { +void FakeMediaEngine::SetAudioRecvCodecs(const std::vector& codecs) { voice_->SetRecvCodecs(codecs); } -void FakeMediaEngine::SetAudioSendCodecs( - const std::vector& codecs) { +void FakeMediaEngine::SetAudioSendCodecs(const std::vector& codecs) { voice_->SetSendCodecs(codecs); } -void FakeMediaEngine::SetVideoCodecs(const std::vector& codecs) { +void FakeMediaEngine::SetVideoCodecs(const std::vector& codecs) { video_->SetSendCodecs(codecs); video_->SetRecvCodecs(codecs); } diff --git a/media/base/fake_media_engine.h b/media/base/fake_media_engine.h index 6453890757..b56af0e99e 100644 --- a/media/base/fake_media_engine.h +++ b/media/base/fake_media_engine.h @@ -452,7 +452,7 @@ class FakeVoiceMediaReceiveChannel virtual ~FakeVoiceMediaReceiveChannel(); // Test methods - const std::vector& recv_codecs() const; + const std::vector& recv_codecs() const; const std::vector& 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& codecs); + bool SetRecvCodecs(const std::vector& codecs); bool SetMaxSendBandwidth(int bps); bool SetOptions(const AudioOptions& options); - std::vector recv_codecs_; + std::vector recv_codecs_; std::map output_scalings_; std::map output_delays_; std::vector dtmf_info_queue_; @@ -543,7 +543,7 @@ class FakeVoiceMediaSendChannel webrtc::TaskQueueBase* network_thread); ~FakeVoiceMediaSendChannel() override; - const std::vector& send_codecs() const; + const std::vector& send_codecs() const; const std::vector& 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& codecs); + bool SetSendCodecs(const std::vector& codecs); bool SetMaxSendBandwidth(int bps); bool SetOptions(const AudioOptions& options); bool SetLocalSource(uint32_t ssrc, AudioSource* source); - std::vector send_codecs_; + std::vector send_codecs_; std::map output_scalings_; std::map output_delays_; std::vector dtmf_info_queue_; @@ -637,8 +637,8 @@ class FakeVideoMediaReceiveChannel return cricket::MEDIA_TYPE_VIDEO; } - const std::vector& recv_codecs() const; - const std::vector& send_codecs() const; + const std::vector& recv_codecs() const; + const std::vector& send_codecs() const; bool rendering() const; const VideoOptions& options() const; const std::map*>& @@ -682,12 +682,12 @@ class FakeVideoMediaReceiveChannel } private: - bool SetRecvCodecs(const std::vector& codecs); - bool SetSendCodecs(const std::vector& codecs); + bool SetRecvCodecs(const std::vector& codecs); + bool SetSendCodecs(const std::vector& codecs); bool SetOptions(const VideoOptions& options); bool SetMaxSendBandwidth(int bps); - std::vector recv_codecs_; + std::vector recv_codecs_; std::map*> sinks_; std::map*> sources_; std::map output_delays_; @@ -711,8 +711,8 @@ class FakeVideoMediaSendChannel return cricket::MEDIA_TYPE_VIDEO; } - const std::vector& send_codecs() const; - const std::vector& codecs() const; + const std::vector& send_codecs() const; + const std::vector& codecs() const; const VideoOptions& options() const; const std::map*>& sinks() const; @@ -749,11 +749,11 @@ class FakeVideoMediaSendChannel bool GetStats(VideoMediaSendInfo* info) override; private: - bool SetSendCodecs(const std::vector& codecs); + bool SetSendCodecs(const std::vector& codecs); bool SetOptions(const VideoOptions& options); bool SetMaxSendBandwidth(int bps); - std::vector send_codecs_; + std::vector send_codecs_; std::map*> 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& send_codecs() const override; - const std::vector& recv_codecs() const override; - void SetCodecs(const std::vector& codecs); - void SetRecvCodecs(const std::vector& codecs); - void SetSendCodecs(const std::vector& codecs); + const std::vector& send_codecs() const override; + const std::vector& recv_codecs() const override; + void SetCodecs(const std::vector& codecs); + void SetRecvCodecs(const std::vector& codecs); + void SetSendCodecs(const std::vector& 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 header_extensions); private: - std::vector recv_codecs_; - std::vector send_codecs_; + std::vector recv_codecs_; + std::vector send_codecs_; bool fail_create_channel_; std::vector header_extensions_; @@ -823,16 +823,12 @@ class FakeVideoEngine : public VideoEngineInterface { FakeVideoMediaSendChannel* GetSendChannel(size_t index); FakeVideoMediaReceiveChannel* GetReceiveChannel(size_t index); - std::vector send_codecs() const override { - return send_codecs(true); - } - std::vector recv_codecs() const override { - return recv_codecs(true); - } - std::vector send_codecs(bool include_rtx) const override; - std::vector recv_codecs(bool include_rtx) const override; - void SetSendCodecs(const std::vector& codecs); - void SetRecvCodecs(const std::vector& codecs); + std::vector send_codecs() const override { return send_codecs(true); } + std::vector recv_codecs() const override { return recv_codecs(true); } + std::vector send_codecs(bool include_rtx) const override; + std::vector recv_codecs(bool include_rtx) const override; + void SetSendCodecs(const std::vector& codecs); + void SetRecvCodecs(const std::vector& codecs); bool SetCapture(bool capture); std::vector GetRtpHeaderExtensions() const override; @@ -840,8 +836,8 @@ class FakeVideoEngine : public VideoEngineInterface { std::vector header_extensions); private: - std::vector send_codecs_; - std::vector recv_codecs_; + std::vector send_codecs_; + std::vector 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& codecs); - void SetAudioRecvCodecs(const std::vector& codecs); - void SetAudioSendCodecs(const std::vector& codecs); - void SetVideoCodecs(const std::vector& codecs); + void SetAudioCodecs(const std::vector& codecs); + void SetAudioRecvCodecs(const std::vector& codecs); + void SetAudioSendCodecs(const std::vector& codecs); + void SetVideoCodecs(const std::vector& codecs); void set_fail_create_channel(bool fail); diff --git a/media/base/media_engine.h b/media/base/media_engine.h index 63cc86fe5a..3deda0983a 100644 --- a/media/base/media_engine.h +++ b/media/base/media_engine.h @@ -118,8 +118,8 @@ class VoiceEngineInterface : public RtpHeaderExtensionQueryInterface { return nullptr; } - virtual const std::vector& send_codecs() const = 0; - virtual const std::vector& recv_codecs() const = 0; + virtual const std::vector& send_codecs() const = 0; + virtual const std::vector& 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 send_codecs() const = 0; - virtual std::vector recv_codecs() const = 0; + virtual std::vector send_codecs() const = 0; + virtual std::vector 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 send_codecs(bool include_rtx) const { + virtual std::vector send_codecs(bool include_rtx) const { RTC_DCHECK(include_rtx); return send_codecs(); } - virtual std::vector recv_codecs(bool include_rtx) const { + virtual std::vector recv_codecs(bool include_rtx) const { RTC_DCHECK(include_rtx); return recv_codecs(); } diff --git a/media/base/media_engine_unittest.cc b/media/base/media_engine_unittest.cc index b8db32a2d5..6f78d61337 100644 --- a/media/base/media_engine_unittest.cc +++ b/media/base/media_engine_unittest.cc @@ -70,8 +70,8 @@ class MostlyMockVoiceEngineInterface : public VoiceEngineInterface { GetAudioState, (), (const, override)); - MOCK_METHOD(std::vector&, send_codecs, (), (const, override)); - MOCK_METHOD(std::vector&, recv_codecs, (), (const, override)); + MOCK_METHOD(std::vector&, send_codecs, (), (const, override)); + MOCK_METHOD(std::vector&, recv_codecs, (), (const, override)); MOCK_METHOD(bool, StartAecDump, (webrtc::FileWrapper file, int64_t max_size_bytes), diff --git a/media/engine/fake_webrtc_video_engine.cc b/media/engine/fake_webrtc_video_engine.cc index 556f696d76..cb702687b7 100644 --- a/media/engine/fake_webrtc_video_engine.cc +++ b/media/engine/fake_webrtc_video_engine.cc @@ -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& 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()})); diff --git a/media/engine/payload_type_mapper.cc b/media/engine/payload_type_mapper.cc index bd86453b1c..0f7c00eda2 100644 --- a/media/engine/payload_type_mapper.cc +++ b/media/engine/payload_type_mapper.cc @@ -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 PayloadTypeMapper::FindMappingFor( return absl::nullopt; } -absl::optional PayloadTypeMapper::ToAudioCodec( +absl::optional 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 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; diff --git a/media/engine/payload_type_mapper.h b/media/engine/payload_type_mapper.h index 1d5cd7198f..3a79a4d804 100644 --- a/media/engine/payload_type_mapper.h +++ b/media/engine/payload_type_mapper.h @@ -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 ToAudioCodec(const webrtc::SdpAudioFormat& format); + absl::optional ToAudioCodec(const webrtc::SdpAudioFormat& format); private: struct SdpAudioFormatOrdering { diff --git a/media/engine/payload_type_mapper_unittest.cc b/media/engine/payload_type_mapper_unittest.cc index 92253a0f5d..62cca1e47e 100644 --- a/media/engine/payload_type_mapper_unittest.cc +++ b/media/engine/payload_type_mapper_unittest.cc @@ -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); diff --git a/media/engine/webrtc_video_engine.cc b/media/engine/webrtc_video_engine.cc index d4dccdf18f..7a10bf1936 100644 --- a/media/engine/webrtc_video_engine.cc +++ b/media/engine/webrtc_video_engine.cc @@ -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 -std::vector GetPayloadTypesAndDefaultCodecs( +std::vector GetPayloadTypesAndDefaultCodecs( const T* factory, bool is_decoder_factory, bool include_rtx, @@ -190,7 +190,7 @@ std::vector GetPayloadTypesAndDefaultCodecs( } if (supported_formats.empty()) - return std::vector(); + return std::vector(); supported_formats.push_back(webrtc::SdpVideoFormat(kRedCodecName)); supported_formats.push_back(webrtc::SdpVideoFormat(kUlpfecCodecName)); @@ -217,9 +217,9 @@ std::vector GetPayloadTypesAndDefaultCodecs( int payload_type_upper = kFirstDynamicPayloadTypeUpperRange; int payload_type_lower = kFirstDynamicPayloadTypeLowerRange; - std::vector output_codecs; + std::vector 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 GetPayloadTypesAndDefaultCodecs( return output_codecs; } -static std::string CodecVectorToString(const std::vector& codecs) { +static std::string CodecVectorToString(const std::vector& 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& codecs) { return out.Release(); } -static bool ValidateCodecFormats(const std::vector& codecs) { +static bool ValidateCodecFormats(const std::vector& 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& 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 MapCodecs( - const std::vector& codecs) { +std::vector MapCodecs(const std::vector& codecs) { if (codecs.empty()) { return {}; } @@ -560,7 +559,7 @@ std::vector MapCodecs( webrtc::UlpfecConfig ulpfec_config; absl::optional 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 WebRtcVideoEngine::send_codecs(bool include_rtx) const { +std::vector WebRtcVideoEngine::send_codecs(bool include_rtx) const { return GetPayloadTypesAndDefaultCodecs(encoder_factory_.get(), /*is_decoder_factory=*/false, include_rtx, trials_); } -std::vector WebRtcVideoEngine::recv_codecs(bool include_rtx) const { +std::vector 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 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 local_supported_codecs = + const std::vector 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 { diff --git a/media/engine/webrtc_video_engine.h b/media/engine/webrtc_video_engine.h index d370a5445b..14df03a1cc 100644 --- a/media/engine/webrtc_video_engine.h +++ b/media/engine/webrtc_video_engine.h @@ -116,14 +116,10 @@ class WebRtcVideoEngine : public VideoEngineInterface { const VideoOptions& options, const webrtc::CryptoOptions& crypto_options) override; - std::vector send_codecs() const override { - return send_codecs(true); - } - std::vector recv_codecs() const override { - return recv_codecs(true); - } - std::vector send_codecs(bool include_rtx) const override; - std::vector recv_codecs(bool include_rtx) const override; + std::vector send_codecs() const override { return send_codecs(true); } + std::vector recv_codecs() const override { return recv_codecs(true); } + std::vector send_codecs(bool include_rtx) const override; + std::vector recv_codecs(bool include_rtx) const override; std::vector 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 - 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. diff --git a/media/engine/webrtc_video_engine_unittest.cc b/media/engine/webrtc_video_engine_unittest.cc index ca69dcabbf..f8612f88a1 100644 --- a/media/engine/webrtc_video_engine_unittest.cc +++ b/media/engine/webrtc_video_engine_unittest.cc @@ -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& codecs, - int payload_type) { - for (const cricket::VideoCodec& codec : codecs) { +bool HasRtxCodec(const std::vector& 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& codecs, // Return true if any codec in `codecs` is an RTX codec, independent of // payload type. -bool HasAnyRtxCodec(const std::vector& codecs) { - for (const cricket::VideoCodec& codec : codecs) { +bool HasAnyRtxCodec(const std::vector& 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& scalability_modes = {}); @@ -391,7 +390,7 @@ class WebRtcVideoEngineTest : public ::testing::Test { std::unique_ptr SetRecvParamsWithAllSupportedCodecs(); std::unique_ptr - SetRecvParamsWithSupportedCodecs(const std::vector& codecs); + SetRecvParamsWithSupportedCodecs(const std::vector& codecs); void ExpectRtpCapabilitySupport(const char* uri, bool supported) const; @@ -406,7 +405,7 @@ class WebRtcVideoEngineTest : public ::testing::Test { std::unique_ptr video_bitrate_allocator_factory_; WebRtcVideoEngine engine_; - absl::optional default_codec_; + absl::optional default_codec_; std::map default_apt_rtx_types_; }; @@ -414,7 +413,7 @@ TEST_F(WebRtcVideoEngineTest, DefaultRtxCodecHasAssociatedPayloadTypeSet) { encoder_factory_->AddSupportedVideoCodecType("VP8"); AssignDefaultCodec(); - std::vector engine_codecs = engine_.send_codecs(); + std::vector 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 codecs = engine_.send_codecs(); + const std::vector 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 engine_codecs = engine_.send_codecs(); + std::vector 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 engine_codecs = engine_.send_codecs(); + std::vector 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 codecs = engine_.send_codecs(); + const std::vector 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 WebRtcVideoEngineTest::SetRecvParamsWithSupportedCodecs( - const std::vector& codecs) { + const std::vector& codecs) { std::unique_ptr channel = engine_.CreateReceiveChannel(call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions()); @@ -899,10 +898,10 @@ WebRtcVideoEngineTest::SetRecvParamsWithSupportedCodecs( std::unique_ptr WebRtcVideoEngineTest::SetRecvParamsWithAllSupportedCodecs() { - std::vector codecs; + std::vector 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 supported_codecs = + std::vector 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 codecs_before(engine_.send_codecs()); + std::vector codecs_before(engine_.send_codecs()); // Add second codec. encoder_factory_->AddSupportedVideoCodecType(kFakeExternalCodecName2); - std::vector codecs_after(engine_.send_codecs()); + std::vector 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 codecs; + std::vector 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 engine_codecs = engine.send_codecs(); + const std::vector 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 send_codecs; - std::vector recv_codecs; + std::vector send_codecs; + std::vector 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( 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 codec = send_channel_->GetSendCodec(); + absl::optional 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 codec = send_channel_->GetSendCodec(); + absl::optional 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 codec = send_channel_->GetSendCodec(); + absl::optional codec = send_channel_->GetSendCodec(); ASSERT_TRUE(codec); EXPECT_EQ("VP8", codec->name); @@ -2674,8 +2672,8 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest { return static_cast(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 codec = send_channel_->GetSendCodec(); + absl::optional 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 codec = send_channel_->GetSendCodec(); + absl::optional 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 codec = send_channel_->GetSendCodec(); + absl::optional codec = send_channel_->GetSendCodec(); ASSERT_TRUE(codec); EXPECT_EQ("VP8", codec->name); diff --git a/media/engine/webrtc_voice_engine.cc b/media/engine/webrtc_voice_engine.cc index 704544c3d5..db43848224 100644 --- a/media/engine/webrtc_voice_engine.cc +++ b/media/engine/webrtc_voice_engine.cc @@ -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 FindCodec(const std::vector& codecs, - const AudioCodec& codec) { - for (const AudioCodec& c : codecs) { +absl::optional FindCodec(const std::vector& codecs, + const Codec& codec) { + for (const Codec& c : codecs) { if (c.Matches(codec)) { return c; } @@ -155,13 +155,13 @@ absl::optional FindCodec(const std::vector& codecs, return absl::nullopt; } -bool VerifyUniquePayloadTypes(const std::vector& codecs) { +bool VerifyUniquePayloadTypes(const std::vector& codecs) { if (codecs.empty()) { return true; } std::vector 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& WebRtcVoiceEngine::send_codecs() const { +const std::vector& WebRtcVoiceEngine::send_codecs() const { RTC_DCHECK(signal_thread_checker_.IsCurrent()); return send_codecs_; } -const std::vector& WebRtcVoiceEngine::recv_codecs() const { +const std::vector& 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 WebRtcVoiceEngine::CollectCodecs( +std::vector WebRtcVoiceEngine::CollectCodecs( const std::vector& specs) const { PayloadTypeMapper mapper; - std::vector out; + std::vector out; // Only generate CN payload types for these clockrates: std::map> generate_cn = { @@ -720,8 +720,8 @@ std::vector WebRtcVoiceEngine::CollectCodecs( {8000, false}, {16000, false}, {32000, false}, {48000, false}}; auto map_format = [&mapper](const webrtc::SdpAudioFormat& format, - std::vector* out) { - absl::optional opt_codec = mapper.ToAudioCodec(format); + std::vector* out) { + absl::optional opt_codec = mapper.ToAudioCodec(format); if (opt_codec) { if (out) { out->push_back(*opt_codec); @@ -736,9 +736,9 @@ std::vector WebRtcVoiceEngine::CollectCodecs( for (const auto& spec : specs) { // We need to do some extra stuff before adding the main codecs to out. - absl::optional opt_codec = map_format(spec.format, nullptr); + absl::optional 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& codecs) { + const std::vector& 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 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 old_codec = FindCodec(recv_codecs_, codec); + absl::optional 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; }); diff --git a/media/engine/webrtc_voice_engine.h b/media/engine/webrtc_voice_engine.h index 502a062edb..379e91d56b 100644 --- a/media/engine/webrtc_voice_engine.h +++ b/media/engine/webrtc_voice_engine.h @@ -116,8 +116,8 @@ class WebRtcVoiceEngine final : public VoiceEngineInterface { const webrtc::CryptoOptions& crypto_options, webrtc::AudioCodecPairId codec_pair_id) override; - const std::vector& send_codecs() const override; - const std::vector& recv_codecs() const override; + const std::vector& send_codecs() const override; + const std::vector& recv_codecs() const override; std::vector GetRtpHeaderExtensions() const override; @@ -147,7 +147,7 @@ class WebRtcVoiceEngine final : public VoiceEngineInterface { webrtc::AudioProcessing* apm() const; webrtc::AudioState* audio_state(); - std::vector CollectCodecs( + std::vector CollectCodecs( const std::vector& specs) const; webrtc::SequenceChecker signal_thread_checker_{ @@ -166,8 +166,8 @@ class WebRtcVoiceEngine final : public VoiceEngineInterface { std::unique_ptr audio_frame_processor_; // The primary instance of WebRtc VoiceEngine. rtc::scoped_refptr audio_state_; - std::vector send_codecs_; - std::vector recv_codecs_; + std::vector send_codecs_; + std::vector 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 send_codecs_; + std::vector 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& codecs); + bool SetRecvCodecs(const std::vector& 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 decoder_map_; - std::vector recv_codecs_; + std::vector recv_codecs_; AudioOptions options_; bool recv_nack_enabled_ = false; diff --git a/media/engine/webrtc_voice_engine_unittest.cc b/media/engine/webrtc_voice_engine_unittest.cc index 852abd9ddf..ad9140b66a 100644 --- a/media/engine/webrtc_voice_engine_unittest.cc +++ b/media/engine/webrtc_voice_engine_unittest.cc @@ -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 { 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 { // `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 { 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 { 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 { 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& codecs = engine_->send_codecs(); + const std::vector& 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, "", 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) { diff --git a/pc/channel.cc b/pc/channel.cc index 7a1f55d9e9..483b2ce2e7 100644 --- a/pc/channel.cc +++ b/pc/channel.cc @@ -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 matched_codecs; - for (VideoCodec& send_codec : send_params.codecs) { - if (absl::c_any_of(matched_codecs, [&](const VideoCodec* c) { + webrtc::flat_set 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 recv_codecs = + std::vector 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; diff --git a/pc/channel_unittest.cc b/pc/channel_unittest.cc index 21a147c78c..ade298bebb 100644 --- a/pc/channel_unittest.cc +++ b/pc/channel_unittest.cc @@ -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}); diff --git a/pc/media_session.cc b/pc/media_session.cc index a7352cce08..86b785c91b 100644 --- a/pc/media_session.cc +++ b/pc/media_session.cc @@ -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 GetNegotiatedCodecsForOffer( +webrtc::RTCErrorOr GetNegotiatedCodecsForOffer( const MediaDescriptionOptions& media_description_options, const MediaSessionOptions& session_options, const ContentInfo* current_content, @@ -1237,7 +1237,7 @@ webrtc::RTCErrorOr GetNegotiatedCodecsForOffer( return filtered_codecs; } -webrtc::RTCErrorOr GetNegotiatedCodecsForAnswer( +webrtc::RTCErrorOr 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& 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& 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& 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 offered_codecs = content.media_description()->codecs(); diff --git a/pc/media_session.h b/pc/media_session.h index c9fbc4ba63..4e7bf67f9c 100644 --- a/pc/media_session.h +++ b/pc/media_session.h @@ -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& current_active_contents, - AudioCodecs* audio_codecs, - VideoCodecs* video_codecs) const; + Codecs* audio_codecs, + Codecs* video_codecs) const; void GetCodecsForAnswer( const std::vector& 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& 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 const ssrc_generator_; diff --git a/pc/media_session_unittest.cc b/pc/media_session_unittest.cc index d00ad1c90e..19f7898167 100644 --- a/pc/media_session_unittest.cc +++ b/pc/media_session_unittest.cc @@ -78,42 +78,42 @@ using ::webrtc::RtpTransceiverDirection; using Candidates = std::vector; -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* codecs) { +void AddRtxCodec(const Codec& rtx_codec, std::vector* 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 f1_codecs = MAKE_VECTOR(kVideoCodecs1); + std::vector 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 f2_codecs = MAKE_VECTOR(kVideoCodecs2); + std::vector 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 expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer); + std::vector 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 f1_codecs = {vp8_offerer, vp8_offerer_rtx}; + std::vector 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 f2_codecs = {vp9, vp9_rtx, vp8_answerer, - vp8_answerer_rtx}; + std::vector 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 audio_codecs; + std::vector 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 codecs = vcd->codecs(); + std::vector 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 f1_codecs = MAKE_VECTOR(kVideoCodecs1); + std::vector 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 f2_codecs = MAKE_VECTOR(kVideoCodecs2); + std::vector 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(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 f2_codecs = MAKE_VECTOR(kVideoCodecs2); + std::vector 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 expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer); + std::vector 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 f1_codecs = MAKE_VECTOR(kVideoCodecs1); + std::vector 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 f2_codecs = MAKE_VECTOR(kVideoCodecs2); + std::vector 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 f1_codecs = MAKE_VECTOR(kVideoCodecs1); + std::vector 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 f2_codecs = MAKE_VECTOR(kVideoCodecs2); + std::vector 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 f1_codecs = MAKE_VECTOR(kVideoCodecs1); + std::vector 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 f2_codecs = MAKE_VECTOR(kVideoCodecs2); + std::vector 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 expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer); + std::vector 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 f1_codecs = MAKE_VECTOR(kVideoCodecs1); + std::vector 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 expected_codecs = MAKE_VECTOR(kVideoCodecs1); + std::vector 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 f1_codecs; + std::vector 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 f1_codecs; + std::vector 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 f1_codecs; + std::vector 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 send_codecs = MAKE_VECTOR(kAudioCodecs1); - std::vector recv_codecs = MAKE_VECTOR(kAudioCodecs2); + std::vector send_codecs = MAKE_VECTOR(kAudioCodecs1); + std::vector 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 sendrecv_codecs = - MAKE_VECTOR(kAudioCodecsAnswer); - const std::vector no_codecs; + const std::vector sendrecv_codecs = MAKE_VECTOR(kAudioCodecsAnswer); + const std::vector 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 send_codecs = MAKE_VECTOR(kAudioCodecs1); - const std::vector recv_codecs = MAKE_VECTOR(kAudioCodecs2); - const std::vector sendrecv_codecs = - MAKE_VECTOR(kAudioCodecsAnswer); + const std::vector send_codecs = MAKE_VECTOR(kAudioCodecs1); + const std::vector recv_codecs = MAKE_VECTOR(kAudioCodecs2); + const std::vector 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 target_codecs; + std::vector 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& codecs) { + auto format_codecs = [](const std::vector& codecs) { rtc::StringBuilder os; bool first = true; os << "{"; diff --git a/pc/peer_connection.cc b/pc/peer_connection.cc index 444a0bf618..44fae1344e 100644 --- a/pc/peer_connection.cc +++ b/pc/peer_connection.cc @@ -1141,7 +1141,7 @@ PeerConnection::AddTransceiver( "Attempted to set an unimplemented parameter of RtpParameters."); } - std::vector codecs; + std::vector codecs; // Gather the current codec capabilities to allow checking scalabilityMode and // codec selection against supported values. if (media_type == cricket::MEDIA_TYPE_VIDEO) { diff --git a/pc/peer_connection_factory.cc b/pc/peer_connection_factory.cc index 92fdfc8026..e62a680116 100644 --- a/pc/peer_connection_factory.cc +++ b/pc/peer_connection_factory.cc @@ -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()); diff --git a/pc/peer_connection_integrationtest.cc b/pc/peer_connection_integrationtest.cc index 24ca52f619..0e4e52b99c 100644 --- a/pc/peer_connection_integrationtest.cc +++ b/pc/peer_connection_integrationtest.cc @@ -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()); diff --git a/pc/peer_connection_media_unittest.cc b/pc/peer_connection_media_unittest.cc index e114e5d926..97faae5da5 100644 --- a/pc/peer_connection_media_unittest.cc +++ b/pc/peer_connection_media_unittest.cc @@ -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 fake_codecs; + std::vector 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 fake_codecs; + std::vector 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 fake_codecs; + std::vector 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 caller_fake_codecs; + std::vector caller_fake_codecs; caller_fake_codecs.push_back(cricket::CreateAudioCodec(100, "foo", 0, 1)); auto caller_fake_engine = std::make_unique(); caller_fake_engine->SetAudioCodecs(caller_fake_codecs); auto caller = CreatePeerConnectionWithAudio(std::move(caller_fake_engine)); - std::vector callee_fake_codecs; + std::vector 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 caller_fake_codecs; + std::vector 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 callee_fake_codecs; + std::vector 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 caller_fake_codecs; + std::vector 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 callee_fake_codecs; + std::vector 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 caller_fake_codecs; + std::vector 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 callee_fake_codecs; + std::vector 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 caller_fake_codecs; + std::vector 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 callee_fake_codecs; + std::vector 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 caller_fake_codecs; + std::vector 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 callee_fake_codecs; + std::vector 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(); - std::vector audio_codecs; + std::vector 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 video_codecs; + std::vector 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(); - std::vector audio_codecs; + std::vector 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 video_codecs; + std::vector 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(); - std::vector audio_codecs; + std::vector 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 video_codecs; + std::vector 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(); - std::vector audio_codecs; + std::vector audio_codecs; audio_codecs.emplace_back(cricket::CreateAudioCodec(100, "foo", 0, 1)); fake_engine->SetAudioRecvCodecs(audio_codecs); diff --git a/pc/rtp_parameters_conversion_unittest.cc b/pc/rtp_parameters_conversion_unittest.cc index 9b48bfacc9..0c68b0a47f 100644 --- a/pc/rtp_parameters_conversion_unittest.cc +++ b/pc/rtp_parameters_conversion_unittest.cc @@ -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; diff --git a/pc/rtp_sender_receiver_unittest.cc b/pc/rtp_sender_receiver_unittest.cc index 259b2d26fd..c6c342e940 100644 --- a/pc/rtp_sender_receiver_unittest.cc +++ b/pc/rtp_sender_receiver_unittest.cc @@ -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); diff --git a/pc/test/mock_rtp_sender_internal.h b/pc/test/mock_rtp_sender_internal.h index bb7776b706..925e9ec910 100644 --- a/pc/test/mock_rtp_sender_internal.h +++ b/pc/test/mock_rtp_sender_internal.h @@ -68,10 +68,7 @@ class MockRtpSenderInternal : public RtpSenderInternal { CheckCodecParameters, (const RtpParameters&), (override)); - MOCK_METHOD(void, - SetSendCodecs, - (std::vector), - (override)); + MOCK_METHOD(void, SetSendCodecs, (std::vector), (override)); MOCK_METHOD(rtc::scoped_refptr, GetDtmfSender, (), diff --git a/pc/webrtc_sdp.cc b/pc/webrtc_sdp.cc index b6cea4dfbf..8def097f1d 100644 --- a/pc/webrtc_sdp.cc +++ b/pc/webrtc_sdp.cc @@ -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 && diff --git a/pc/webrtc_sdp_unittest.cc b/pc/webrtc_sdp_unittest.cc index afa2304666..f71b303283 100644 --- a/pc/webrtc_sdp_unittest.cc +++ b/pc/webrtc_sdp_unittest.cc @@ -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 (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);