From 486e3deba04336266326f45d2b314b5bfac9e7ae Mon Sep 17 00:00:00 2001 From: Harald Alvestrand Date: Tue, 17 Dec 2024 16:10:01 +0000 Subject: [PATCH] Expand use of CodecList to cover pc/media_session.cc MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This allows us to verify consistency of codec lists in more places. Bug: webrtc:360058654 Change-Id: Ibd0d10579c4b8058031db0df458e8fc9e2181152 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/371921 Commit-Queue: Harald Alvestrand Reviewed-by: Henrik Boström Cr-Commit-Position: refs/heads/main@{#43594} --- media/base/codec_list.h | 8 +- pc/media_session.cc | 137 +++++++++++++++++------------------ pc/media_session.h | 51 ++++++++----- pc/media_session_unittest.cc | 102 +++++++++++++++----------- 4 files changed, 165 insertions(+), 133 deletions(-) diff --git a/media/base/codec_list.h b/media/base/codec_list.h index 717c8f8b08..5f19583c8d 100644 --- a/media/base/codec_list.h +++ b/media/base/codec_list.h @@ -22,6 +22,7 @@ class CodecList { public: using iterator = std::vector::iterator; using const_iterator = std::vector::const_iterator; + using value_type = Codec; CodecList() {} explicit CodecList(const std::vector& codecs) { @@ -35,8 +36,13 @@ class CodecList { const_iterator end() const { return codecs_.end(); } const Codec& operator[](size_t i) const { return codecs_[i]; } Codec& operator[](size_t i) { return codecs_[i]; } - void push_back(const Codec& codec) { codecs_.push_back(codec); } + void push_back(const Codec& codec) { + codecs_.push_back(codec); + CheckConsistency(); + } bool empty() const { return codecs_.empty(); } + void clear() { codecs_.clear(); } + size_t size() const { return codecs_.size(); } // Access to the whole codec list const std::vector& codecs() const { return codecs_; } std::vector& writable_codecs() { return codecs_; } diff --git a/pc/media_session.cc b/pc/media_session.cc index 9772eec798..b61e39c299 100644 --- a/pc/media_session.cc +++ b/pc/media_session.cc @@ -146,6 +146,14 @@ bool IsComfortNoiseCodec(const Codec& codec) { return absl::EqualsIgnoreCase(codec.name, kComfortNoiseCodecName); } +// Wrapper for FindMatchingCodecs that uses CodecList +std::optional FindMatchingCodec(const CodecList& codecs1, + const CodecList& codecs2, + const Codec& codec_to_match) { + return webrtc::FindMatchingCodec(codecs1.codecs(), codecs2.codecs(), + codec_to_match); +} + void StripCNCodecs(CodecList& audio_codecs) { audio_codecs.writable_codecs().erase( std::remove_if( @@ -509,13 +517,13 @@ webrtc::RTCError AssignCodecIdsAndLinkRed( return webrtc::RTCError::OK(); } -void NegotiateCodecs(const std::vector& local_codecs, - const std::vector& offered_codecs, +void NegotiateCodecs(const CodecList& local_codecs, + const CodecList& offered_codecs, std::vector* negotiated_codecs, bool keep_offer_order) { for (const Codec& ours : local_codecs) { std::optional theirs = - webrtc::FindMatchingCodec(local_codecs, offered_codecs, ours); + FindMatchingCodec(local_codecs, offered_codecs, ours); // Note that we intentionally only find one matching codec for each of our // local codecs, in case the remote offer contains duplicate codecs. if (theirs) { @@ -657,8 +665,7 @@ void MergeCodecs(const CodecList& reference_codecs, for (const Codec& reference_codec : reference_codecs) { if (reference_codec.GetResiliencyType() != Codec::ResiliencyType::kRtx && reference_codec.GetResiliencyType() != Codec::ResiliencyType::kRed && - !webrtc::FindMatchingCodec(reference_codecs.codecs(), - offered_codecs.codecs(), reference_codec)) { + !FindMatchingCodec(reference_codecs, offered_codecs, reference_codec)) { Codec codec = reference_codec; used_pltypes->FindAndSetIdUsed(&codec); offered_codecs.push_back(codec); @@ -668,8 +675,7 @@ void MergeCodecs(const CodecList& reference_codecs, // Add all new RTX or RED codecs. for (const Codec& reference_codec : reference_codecs) { if (reference_codec.GetResiliencyType() == Codec::ResiliencyType::kRtx && - !webrtc::FindMatchingCodec(reference_codecs.codecs(), - offered_codecs.codecs(), reference_codec)) { + !FindMatchingCodec(reference_codecs, offered_codecs, reference_codec)) { Codec rtx_codec = reference_codec; const Codec* associated_codec = GetAssociatedCodecForRtx(reference_codecs, rtx_codec); @@ -678,9 +684,8 @@ void MergeCodecs(const CodecList& reference_codecs, } // Find a codec in the offered list that matches the reference codec. // Its payload type may be different than the reference codec. - std::optional matching_codec = - webrtc::FindMatchingCodec(reference_codecs.codecs(), - offered_codecs.codecs(), *associated_codec); + std::optional matching_codec = FindMatchingCodec( + reference_codecs, offered_codecs, *associated_codec); if (!matching_codec) { RTC_LOG(LS_WARNING) << "Couldn't find matching " << associated_codec->name << " codec."; @@ -693,16 +698,14 @@ void MergeCodecs(const CodecList& reference_codecs, offered_codecs.push_back(rtx_codec); } else if (reference_codec.GetResiliencyType() == Codec::ResiliencyType::kRed && - !webrtc::FindMatchingCodec(reference_codecs.codecs(), - offered_codecs.codecs(), - reference_codec)) { + !FindMatchingCodec(reference_codecs, offered_codecs, + reference_codec)) { Codec red_codec = reference_codec; const Codec* associated_codec = GetAssociatedCodecForRed(reference_codecs, red_codec); if (associated_codec) { - std::optional matching_codec = webrtc::FindMatchingCodec( - reference_codecs.codecs(), offered_codecs.codecs(), - *associated_codec); + std::optional matching_codec = FindMatchingCodec( + reference_codecs, offered_codecs, *associated_codec); if (!matching_codec) { RTC_LOG(LS_WARNING) << "Couldn't find matching " << associated_codec->name << " codec."; @@ -751,8 +754,7 @@ CodecList MatchCodecPreference( if (found_codec != supported_codecs.end()) { std::optional found_codec_with_correct_pt = - webrtc::FindMatchingCodec(supported_codecs.codecs(), codecs.codecs(), - *found_codec); + FindMatchingCodec(supported_codecs, codecs, *found_codec); if (found_codec_with_correct_pt) { // RED may already have been added if its primary codec is before RED // in the codec list. @@ -1159,11 +1161,10 @@ webrtc::RTCErrorOr> GetNegotiatedCodecsForOffer( } // Add other supported codecs. for (const Codec& codec : supported_codecs) { - std::optional found_codec = webrtc::FindMatchingCodec( - supported_codecs.codecs(), codecs.codecs(), codec); + std::optional found_codec = + FindMatchingCodec(supported_codecs, codecs, codec); if (found_codec && - !webrtc::FindMatchingCodec(supported_codecs.codecs(), - filtered_codecs.codecs(), codec)) { + !FindMatchingCodec(supported_codecs, filtered_codecs, codec)) { // Use the `found_codec` from `codecs` because it has the // correctly mapped payload type. // This is only done for video since we do not yet have rtx for audio. @@ -1176,10 +1177,8 @@ webrtc::RTCErrorOr> GetNegotiatedCodecsForOffer( RTC_DCHECK(referenced_codec); // Find the codec we should be referencing and point to it. - std::optional changed_referenced_codec = - webrtc::FindMatchingCodec(supported_codecs.codecs(), - filtered_codecs.codecs(), - *referenced_codec); + std::optional changed_referenced_codec = FindMatchingCodec( + supported_codecs, filtered_codecs, *referenced_codec); if (changed_referenced_codec) { found_codec->SetParam(kCodecParamAssociatedPayloadType, changed_referenced_codec->id); @@ -1241,10 +1240,8 @@ webrtc::RTCErrorOr GetNegotiatedCodecsForAnswer( // Add other supported codecs. CodecList other_codecs; for (const Codec& codec : supported_codecs) { - if (webrtc::FindMatchingCodec(supported_codecs.codecs(), codecs.codecs(), - codec) && - !webrtc::FindMatchingCodec(supported_codecs.codecs(), - filtered_codecs.codecs(), codec)) { + if (FindMatchingCodec(supported_codecs, codecs, codec) && + !FindMatchingCodec(supported_codecs, filtered_codecs, codec)) { // We should use the local codec with local parameters and the codec id // would be correctly mapped in `NegotiateCodecs`. other_codecs.push_back(codec); @@ -1331,50 +1328,52 @@ MediaSessionDescriptionFactory::MediaSessionDescriptionFactory( "WebRTC-PayloadTypesInTransport")) { RTC_CHECK(transport_desc_factory_); if (media_engine) { - audio_send_codecs_ = media_engine->voice().send_codecs(); - audio_recv_codecs_ = media_engine->voice().recv_codecs(); - video_send_codecs_ = media_engine->video().send_codecs(rtx_enabled); - video_recv_codecs_ = media_engine->video().recv_codecs(rtx_enabled); + audio_send_codecs_ = CodecList(media_engine->voice().send_codecs()); + audio_recv_codecs_ = CodecList(media_engine->voice().recv_codecs()); + video_send_codecs_ = + CodecList(media_engine->video().send_codecs(rtx_enabled)); + video_recv_codecs_ = + CodecList(media_engine->video().recv_codecs(rtx_enabled)); } ComputeAudioCodecsIntersectionAndUnion(); ComputeVideoCodecsIntersectionAndUnion(); } -const Codecs& MediaSessionDescriptionFactory::audio_sendrecv_codecs() const { +const CodecList& MediaSessionDescriptionFactory::audio_sendrecv_codecs() const { return audio_sendrecv_codecs_; } -const Codecs& MediaSessionDescriptionFactory::audio_send_codecs() const { +const CodecList& MediaSessionDescriptionFactory::audio_send_codecs() const { return audio_send_codecs_; } -const Codecs& MediaSessionDescriptionFactory::audio_recv_codecs() const { +const CodecList& MediaSessionDescriptionFactory::audio_recv_codecs() const { return audio_recv_codecs_; } void MediaSessionDescriptionFactory::set_audio_codecs( - const Codecs& send_codecs, - const Codecs& recv_codecs) { + const CodecList& send_codecs, + const CodecList& recv_codecs) { audio_send_codecs_ = send_codecs; audio_recv_codecs_ = recv_codecs; ComputeAudioCodecsIntersectionAndUnion(); } -const Codecs& MediaSessionDescriptionFactory::video_sendrecv_codecs() const { +const CodecList& MediaSessionDescriptionFactory::video_sendrecv_codecs() const { return video_sendrecv_codecs_; } -const Codecs& MediaSessionDescriptionFactory::video_send_codecs() const { +const CodecList& MediaSessionDescriptionFactory::video_send_codecs() const { return video_send_codecs_; } -const Codecs& MediaSessionDescriptionFactory::video_recv_codecs() const { +const CodecList& MediaSessionDescriptionFactory::video_recv_codecs() const { return video_recv_codecs_; } void MediaSessionDescriptionFactory::set_video_codecs( - const Codecs& send_codecs, - const Codecs& recv_codecs) { + const CodecList& send_codecs, + const CodecList& recv_codecs) { video_send_codecs_ = send_codecs; video_recv_codecs_ = recv_codecs; ComputeVideoCodecsIntersectionAndUnion(); @@ -1746,7 +1745,7 @@ MediaSessionDescriptionFactory::CreateAnswerOrError( return answer; } -const Codecs& MediaSessionDescriptionFactory::GetAudioCodecsForOffer( +const CodecList& MediaSessionDescriptionFactory::GetAudioCodecsForOffer( const RtpTransceiverDirection& direction) const { switch (direction) { // If stream is inactive - generate list as if sendrecv. @@ -1762,7 +1761,7 @@ const Codecs& MediaSessionDescriptionFactory::GetAudioCodecsForOffer( RTC_CHECK_NOTREACHED(); } -const Codecs& MediaSessionDescriptionFactory::GetAudioCodecsForAnswer( +const CodecList& MediaSessionDescriptionFactory::GetAudioCodecsForAnswer( const RtpTransceiverDirection& offer, const RtpTransceiverDirection& answer) const { switch (answer) { @@ -1781,7 +1780,7 @@ const Codecs& MediaSessionDescriptionFactory::GetAudioCodecsForAnswer( RTC_CHECK_NOTREACHED(); } -const Codecs& MediaSessionDescriptionFactory::GetVideoCodecsForOffer( +const CodecList& MediaSessionDescriptionFactory::GetVideoCodecsForOffer( const RtpTransceiverDirection& direction) const { switch (direction) { // If stream is inactive - generate list as if sendrecv. @@ -1797,7 +1796,7 @@ const Codecs& MediaSessionDescriptionFactory::GetVideoCodecsForOffer( RTC_CHECK_NOTREACHED(); } -const Codecs& MediaSessionDescriptionFactory::GetVideoCodecsForAnswer( +const CodecList& MediaSessionDescriptionFactory::GetVideoCodecsForAnswer( const RtpTransceiverDirection& offer, const RtpTransceiverDirection& answer) const { switch (answer) { @@ -1886,22 +1885,20 @@ void MediaSessionDescriptionFactory::GetCodecsForAnswer( if (IsMediaContentOfType(&content, MEDIA_TYPE_AUDIO)) { CodecList offered_codecs(content.media_description()->codecs()); for (const Codec& offered_audio_codec : offered_codecs) { - if (!webrtc::FindMatchingCodec(offered_codecs.codecs(), - filtered_offered_audio_codecs.codecs(), - offered_audio_codec) && - webrtc::FindMatchingCodec(offered_codecs.codecs(), - all_audio_codecs_, offered_audio_codec)) { + if (!FindMatchingCodec(offered_codecs, filtered_offered_audio_codecs, + offered_audio_codec) && + FindMatchingCodec(offered_codecs, all_audio_codecs_, + offered_audio_codec)) { filtered_offered_audio_codecs.push_back(offered_audio_codec); } } } else if (IsMediaContentOfType(&content, MEDIA_TYPE_VIDEO)) { CodecList offered_codecs(content.media_description()->codecs()); for (const Codec& offered_video_codec : offered_codecs) { - if (!webrtc::FindMatchingCodec(offered_codecs.codecs(), - filtered_offered_video_codecs.codecs(), - offered_video_codec) && - webrtc::FindMatchingCodec(offered_codecs.codecs(), - all_video_codecs_, offered_video_codec)) { + if (!FindMatchingCodec(offered_codecs, filtered_offered_video_codecs, + offered_video_codec) && + FindMatchingCodec(offered_codecs, all_video_codecs_, + offered_video_codec)) { filtered_offered_video_codecs.push_back(offered_video_codec); } } @@ -2049,7 +2046,7 @@ RTCError MediaSessionDescriptionFactory::AddRtpContentForOffer( std::vector codecs_to_include; if (media_description_options.codecs_to_include.empty()) { - std::vector supported_codecs = + CodecList supported_codecs = media_description_options.type == MEDIA_TYPE_AUDIO ? GetAudioCodecsForOffer(media_description_options.direction) : GetVideoCodecsForOffer(media_description_options.direction); @@ -2219,7 +2216,7 @@ RTCError MediaSessionDescriptionFactory::AddRtpContentForAnswer( std::vector codecs_to_include; bool negotiate; if (media_description_options.codecs_to_include.empty()) { - const std::vector& supported_codecs = + const CodecList& supported_codecs = media_description_options.type == MEDIA_TYPE_AUDIO ? GetAudioCodecsForAnswer(offer_rtd, answer_rtd) : GetVideoCodecsForAnswer(offer_rtd, answer_rtd); @@ -2253,7 +2250,8 @@ RTCError MediaSessionDescriptionFactory::AddRtpContentForAnswer( } if (negotiate) { std::vector negotiated_codecs; - NegotiateCodecs(codecs_to_include, offer_content_description->codecs(), + NegotiateCodecs(CodecList(codecs_to_include), + CodecList(offer_content_description->codecs()), &negotiated_codecs, media_description_options.codec_preferences.empty()); codecs_to_include = negotiated_codecs; @@ -2431,16 +2429,14 @@ void MediaSessionDescriptionFactory::ComputeAudioCodecsIntersectionAndUnion() { // Compute the audio codecs union. for (const Codec& send : audio_send_codecs_) { all_audio_codecs_.push_back(send); - if (!webrtc::FindMatchingCodec(audio_send_codecs_, audio_recv_codecs_, - send)) { + if (!FindMatchingCodec(audio_send_codecs_, audio_recv_codecs_, send)) { // It doesn't make sense to have an RTX codec we support sending but not // receiving. RTC_DCHECK(send.GetResiliencyType() != Codec::ResiliencyType::kRtx); } } for (const Codec& recv : audio_recv_codecs_) { - if (!webrtc::FindMatchingCodec(audio_recv_codecs_, audio_send_codecs_, - recv)) { + if (!FindMatchingCodec(audio_recv_codecs_, audio_send_codecs_, recv)) { all_audio_codecs_.push_back(recv); } } @@ -2449,8 +2445,10 @@ void MediaSessionDescriptionFactory::ComputeAudioCodecsIntersectionAndUnion() { // order we'd like to follow. The reasoning is that encoding is usually more // expensive than decoding, and prioritizing a codec in the send list probably // means it's a codec we can handle efficiently. + std::vector audio_sendrecv_codecs_vector; NegotiateCodecs(audio_recv_codecs_, audio_send_codecs_, - &audio_sendrecv_codecs_, true); + &audio_sendrecv_codecs_vector, true); + audio_sendrecv_codecs_ = CodecList(audio_sendrecv_codecs_vector); } void MediaSessionDescriptionFactory::ComputeVideoCodecsIntersectionAndUnion() { @@ -2458,8 +2456,7 @@ void MediaSessionDescriptionFactory::ComputeVideoCodecsIntersectionAndUnion() { // Use ComputeCodecsUnion to avoid having duplicate payload IDs all_video_codecs_ = ComputeCodecsUnion(CodecList(video_recv_codecs_), - CodecList(video_send_codecs_)) - .codecs(); + CodecList(video_send_codecs_)); // Use NegotiateCodecs to merge our codec lists, since the operation is // essentially the same. Put send_codecs as the offered_codecs, which is the @@ -2469,8 +2466,10 @@ void MediaSessionDescriptionFactory::ComputeVideoCodecsIntersectionAndUnion() { // Also for the same profile of a codec, if there are different levels in the // send and receive codecs, |video_sendrecv_codecs_| will contain the lower // level of the two for that profile. + std::vector video_sendrecv_codecs_vector; NegotiateCodecs(video_recv_codecs_, video_send_codecs_, - &video_sendrecv_codecs_, true); + &video_sendrecv_codecs_vector, true); + video_sendrecv_codecs_ = CodecList(video_sendrecv_codecs_vector); } bool IsMediaContent(const ContentInfo* content) { diff --git a/pc/media_session.h b/pc/media_session.h index 83f35f88ae..ea89acb87d 100644 --- a/pc/media_session.h +++ b/pc/media_session.h @@ -24,6 +24,7 @@ #include "api/rtp_transceiver_direction.h" #include "call/payload_type.h" #include "media/base/codec.h" +#include "media/base/codec_list.h" #include "media/base/rid_description.h" #include "media/base/stream_params.h" #include "p2p/base/ice_credentials_iterator.h" @@ -151,14 +152,24 @@ class MediaSessionDescriptionFactory { const TransportDescriptionFactory* factory, webrtc::PayloadTypeSuggester* pt_suggester); - 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); + const CodecList& audio_sendrecv_codecs() const; + const CodecList& audio_send_codecs() const; + const CodecList& audio_recv_codecs() const; + void set_audio_codecs(const CodecList& send_codecs, + const CodecList& recv_codecs); + void set_audio_codecs(const std::vector& send_codecs, + const std::vector& recv_codecs) { + set_audio_codecs(CodecList(send_codecs), CodecList(recv_codecs)); + } + const CodecList& video_sendrecv_codecs() const; + const CodecList& video_send_codecs() const; + const CodecList& video_recv_codecs() const; + void set_video_codecs(const CodecList& send_codecs, + const CodecList& recv_codecs); + void set_video_codecs(const std::vector& send_codecs, + const std::vector& recv_codecs) { + set_video_codecs(CodecList(send_codecs), CodecList(recv_codecs)); + } RtpHeaderExtensions filtered_rtp_header_extensions( RtpHeaderExtensions extensions) const; @@ -184,14 +195,14 @@ class MediaSessionDescriptionFactory { RtpHeaderExtensions video; }; - const Codecs& GetAudioCodecsForOffer( + const CodecList& GetAudioCodecsForOffer( const webrtc::RtpTransceiverDirection& direction) const; - const Codecs& GetAudioCodecsForAnswer( + const CodecList& GetAudioCodecsForAnswer( const webrtc::RtpTransceiverDirection& offer, const webrtc::RtpTransceiverDirection& answer) const; - const Codecs& GetVideoCodecsForOffer( + const CodecList& GetVideoCodecsForOffer( const webrtc::RtpTransceiverDirection& direction) const; - const Codecs& GetVideoCodecsForAnswer( + const CodecList& GetVideoCodecsForAnswer( const webrtc::RtpTransceiverDirection& offer, const webrtc::RtpTransceiverDirection& answer) const; void GetCodecsForOffer( @@ -303,18 +314,18 @@ class MediaSessionDescriptionFactory { } bool is_unified_plan_ = false; - Codecs audio_send_codecs_; - Codecs audio_recv_codecs_; + CodecList audio_send_codecs_; + CodecList audio_recv_codecs_; // Intersection of send and recv. - Codecs audio_sendrecv_codecs_; + CodecList audio_sendrecv_codecs_; // Union of send and recv. - Codecs all_audio_codecs_; - Codecs video_send_codecs_; - Codecs video_recv_codecs_; + CodecList all_audio_codecs_; + CodecList video_send_codecs_; + CodecList video_recv_codecs_; // Intersection of send and recv. - Codecs video_sendrecv_codecs_; + CodecList video_sendrecv_codecs_; // Union of send and recv. - Codecs all_video_codecs_; + CodecList 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 e28aa86288..2332d6abea 100644 --- a/pc/media_session_unittest.cc +++ b/pc/media_session_unittest.cc @@ -855,13 +855,13 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoOffer) { const MediaContentDescription* acd = ac->media_description(); const MediaContentDescription* vcd = vc->media_description(); EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type()); - EXPECT_EQ(f1_.audio_sendrecv_codecs(), acd->codecs()); + EXPECT_EQ(f1_.audio_sendrecv_codecs().codecs(), acd->codecs()); EXPECT_EQ(0U, acd->first_ssrc()); // no sender is attached EXPECT_EQ(kAutoBandwidth, acd->bandwidth()); // default bandwidth (auto) EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on EXPECT_EQ(kMediaProtocolDtlsSavpf, acd->protocol()); EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type()); - EXPECT_EQ(f1_.video_sendrecv_codecs(), vcd->codecs()); + EXPECT_EQ(f1_.video_sendrecv_codecs().codecs(), vcd->codecs()); EXPECT_EQ(0U, vcd->first_ssrc()); // no sender is attached EXPECT_EQ(kAutoBandwidth, vcd->bandwidth()); // default bandwidth (auto) EXPECT_TRUE(vcd->rtcp_mux()); // rtcp-mux defaults on @@ -2617,7 +2617,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateMultiStreamVideoOffer) { const MediaContentDescription* acd = ac->media_description(); const MediaContentDescription* vcd = vc->media_description(); EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type()); - EXPECT_EQ(f1_.audio_sendrecv_codecs(), acd->codecs()); + EXPECT_EQ(f1_.audio_sendrecv_codecs().codecs(), acd->codecs()); const StreamParamsVec& audio_streams = acd->streams(); ASSERT_EQ(2U, audio_streams.size()); @@ -2633,7 +2633,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateMultiStreamVideoOffer) { EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type()); - EXPECT_EQ(f1_.video_sendrecv_codecs(), vcd->codecs()); + EXPECT_EQ(f1_.video_sendrecv_codecs().codecs(), vcd->codecs()); const StreamParamsVec& video_streams = vcd->streams(); ASSERT_EQ(1U, video_streams.size()); @@ -3028,8 +3028,8 @@ TEST_F(MediaSessionDescriptionFactoryTest, // that is being recycled. TEST_F(MediaSessionDescriptionFactoryTest, ReOfferDoesNotReUseRecycledAudioCodecs) { - f1_.set_video_codecs({}, {}); - f2_.set_video_codecs({}, {}); + f1_.set_video_codecs(CodecList{}, CodecList{}); + f2_.set_video_codecs(CodecList{}, CodecList{}); MediaSessionOptions opts; AddMediaDescriptionOptions(MEDIA_TYPE_AUDIO, "a0", @@ -3062,8 +3062,8 @@ TEST_F(MediaSessionDescriptionFactoryTest, // that is being recycled. TEST_F(MediaSessionDescriptionFactoryTest, ReOfferDoesNotReUseRecycledVideoCodecs) { - f1_.set_audio_codecs({}, {}); - f2_.set_audio_codecs({}, {}); + f1_.set_audio_codecs(CodecList{}, CodecList{}); + f2_.set_audio_codecs(CodecList{}, CodecList{}); MediaSessionOptions opts; AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "v0", @@ -3089,8 +3089,8 @@ TEST_F(MediaSessionDescriptionFactoryTest, // section that is being recycled. TEST_F(MediaSessionDescriptionFactoryTest, ReAnswerDoesNotReUseRecycledAudioCodecs) { - f1_.set_video_codecs({}, {}); - f2_.set_video_codecs({}, {}); + f1_.set_video_codecs(CodecList{}, CodecList{}); + f2_.set_video_codecs(CodecList{}, CodecList{}); // Perform initial offer/answer in reverse (`f2_` as offerer) so that the // second offer/answer is forward (`f1_` as offerer). @@ -3121,8 +3121,8 @@ TEST_F(MediaSessionDescriptionFactoryTest, // section that is being recycled. TEST_F(MediaSessionDescriptionFactoryTest, ReAnswerDoesNotReUseRecycledVideoCodecs) { - f1_.set_audio_codecs({}, {}); - f2_.set_audio_codecs({}, {}); + f1_.set_audio_codecs(CodecList{}, CodecList{}); + f2_.set_audio_codecs(CodecList{}, CodecList{}); // Perform initial offer/answer in reverse (`f2_` as offerer) so that the // second offer/answer is forward (`f1_` as offerer). @@ -4677,27 +4677,27 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestSetAudioCodecs) { // Test proper merge sf.set_audio_codecs(send_codecs, recv_codecs); - EXPECT_EQ(send_codecs, sf.audio_send_codecs()); - EXPECT_EQ(recv_codecs, sf.audio_recv_codecs()); - EXPECT_EQ(sendrecv_codecs, sf.audio_sendrecv_codecs()); + EXPECT_EQ(send_codecs, sf.audio_send_codecs().codecs()); + EXPECT_EQ(recv_codecs, sf.audio_recv_codecs().codecs()); + EXPECT_EQ(sendrecv_codecs, sf.audio_sendrecv_codecs().codecs()); // Test empty send codecs list sf.set_audio_codecs(no_codecs, recv_codecs); - EXPECT_EQ(no_codecs, sf.audio_send_codecs()); - EXPECT_EQ(recv_codecs, sf.audio_recv_codecs()); - EXPECT_EQ(no_codecs, sf.audio_sendrecv_codecs()); + EXPECT_EQ(no_codecs, sf.audio_send_codecs().codecs()); + EXPECT_EQ(recv_codecs, sf.audio_recv_codecs().codecs()); + EXPECT_EQ(no_codecs, sf.audio_sendrecv_codecs().codecs()); // Test empty recv codecs list sf.set_audio_codecs(send_codecs, no_codecs); - EXPECT_EQ(send_codecs, sf.audio_send_codecs()); - EXPECT_EQ(no_codecs, sf.audio_recv_codecs()); - EXPECT_EQ(no_codecs, sf.audio_sendrecv_codecs()); + EXPECT_EQ(send_codecs, sf.audio_send_codecs().codecs()); + EXPECT_EQ(no_codecs, sf.audio_recv_codecs().codecs()); + EXPECT_EQ(no_codecs, sf.audio_sendrecv_codecs().codecs()); // Test all empty codec lists sf.set_audio_codecs(no_codecs, no_codecs); - EXPECT_EQ(no_codecs, sf.audio_send_codecs()); - EXPECT_EQ(no_codecs, sf.audio_recv_codecs()); - EXPECT_EQ(no_codecs, sf.audio_sendrecv_codecs()); + EXPECT_EQ(no_codecs, sf.audio_send_codecs().codecs()); + EXPECT_EQ(no_codecs, sf.audio_recv_codecs().codecs()); + EXPECT_EQ(no_codecs, sf.audio_sendrecv_codecs().codecs()); } // Compare the two vectors of codecs ignoring the payload type. @@ -5029,7 +5029,7 @@ TEST_F(VideoCodecsOfferH265LevelIdTest, TestSendRecvSymmetrical) { MAKE_VECTOR(kVideoCodecsH265Level52); sf_offerer_.set_video_codecs(send_codecs, recv_codecs); sf_answerer_.set_video_codecs(recv_codecs, send_codecs); - EXPECT_EQ(sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); + EXPECT_EQ(sendrecv_codecs, sf_offerer_.video_sendrecv_codecs().codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", @@ -5076,7 +5076,7 @@ TEST_F(VideoCodecsOfferH265LevelIdTest, TestSendOnlySymmetrical) { MAKE_VECTOR(kVideoCodecsH265Level6); sf_offerer_.set_video_codecs(send_codecs, recv_codecs); sf_answerer_.set_video_codecs(recv_codecs, send_codecs); - EXPECT_EQ(sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); + EXPECT_EQ(sendrecv_codecs, sf_offerer_.video_sendrecv_codecs().codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", @@ -5120,7 +5120,7 @@ TEST_F(VideoCodecsOfferH265LevelIdTest, TestRecvOnlySymmetrical) { MAKE_VECTOR(kVideoCodecsH265Level52); sf_offerer_.set_video_codecs(send_codecs, recv_codecs); sf_answerer_.set_video_codecs(recv_codecs, send_codecs); - EXPECT_EQ(sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); + EXPECT_EQ(sendrecv_codecs, sf_offerer_.video_sendrecv_codecs().codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", @@ -5170,7 +5170,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest, MAKE_VECTOR(kVideoCodecsH265Level52); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); - EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); + EXPECT_EQ(offerer_sendrecv_codecs, + sf_offerer_.video_sendrecv_codecs().codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", @@ -5225,7 +5226,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest, MAKE_VECTOR(kVideoCodecsH265Level6); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); - EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); + EXPECT_EQ(offerer_sendrecv_codecs, + sf_offerer_.video_sendrecv_codecs().codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", @@ -5280,7 +5282,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest, MAKE_VECTOR(kVideoCodecsH265Level5); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); - EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); + EXPECT_EQ(offerer_sendrecv_codecs, + sf_offerer_.video_sendrecv_codecs().codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", @@ -5345,7 +5348,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest, MAKE_VECTOR(kVideoCodecsH265Level6); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); - EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); + EXPECT_EQ(offerer_sendrecv_codecs, + sf_offerer_.video_sendrecv_codecs().codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", @@ -5400,7 +5404,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest, MAKE_VECTOR(kVideoCodecsH265Level52); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); - EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); + EXPECT_EQ(offerer_sendrecv_codecs, + sf_offerer_.video_sendrecv_codecs().codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", @@ -5455,7 +5460,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest, MAKE_VECTOR(kVideoCodecsH265Level52); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); - EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); + EXPECT_EQ(offerer_sendrecv_codecs, + sf_offerer_.video_sendrecv_codecs().codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", @@ -5507,7 +5513,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest, MAKE_VECTOR(kVideoCodecsH265Level6); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); - EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); + EXPECT_EQ(offerer_sendrecv_codecs, + sf_offerer_.video_sendrecv_codecs().codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", @@ -5559,7 +5566,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest, MAKE_VECTOR(kVideoCodecsH265Level5); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); - EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); + EXPECT_EQ(offerer_sendrecv_codecs, + sf_offerer_.video_sendrecv_codecs().codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", @@ -5611,7 +5619,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest, MAKE_VECTOR(kVideoCodecsH265Level6); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); - EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); + EXPECT_EQ(offerer_sendrecv_codecs, + sf_offerer_.video_sendrecv_codecs().codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", @@ -5663,7 +5672,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest, MAKE_VECTOR(kVideoCodecsH265Level52); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); - EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); + EXPECT_EQ(offerer_sendrecv_codecs, + sf_offerer_.video_sendrecv_codecs().codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", @@ -5715,7 +5725,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest, MAKE_VECTOR(kVideoCodecsH265Level52); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); - EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); + EXPECT_EQ(offerer_sendrecv_codecs, + sf_offerer_.video_sendrecv_codecs().codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", @@ -5768,7 +5779,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest, MAKE_VECTOR(kVideoCodecsH265Level6); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); - EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); + EXPECT_EQ(offerer_sendrecv_codecs, + sf_offerer_.video_sendrecv_codecs().codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", @@ -5821,7 +5833,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest, MAKE_VECTOR(kVideoCodecsH265Level5); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); - EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); + EXPECT_EQ(offerer_sendrecv_codecs, + sf_offerer_.video_sendrecv_codecs().codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", @@ -5874,7 +5887,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest, MAKE_VECTOR(kVideoCodecsH265Level6); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); - EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); + EXPECT_EQ(offerer_sendrecv_codecs, + sf_offerer_.video_sendrecv_codecs().codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", @@ -5927,7 +5941,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest, MAKE_VECTOR(kVideoCodecsH265Level52); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); - EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); + EXPECT_EQ(offerer_sendrecv_codecs, + sf_offerer_.video_sendrecv_codecs().codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", @@ -5976,7 +5991,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest, MAKE_VECTOR(kVideoCodecsH265Level52); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); - EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); + EXPECT_EQ(offerer_sendrecv_codecs, + sf_offerer_.video_sendrecv_codecs().codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",