/* * Copyright 2004 The WebRTC project authors. All Rights Reserved. * * Use of this source code is governed by a BSD-style license * that can be found in the LICENSE file in the root of the source * tree. An additional intellectual property rights grant can be found * in the file PATENTS. All contributing project authors may * be found in the AUTHORS file in the root of the source tree. */ #include "pc/media_session.h" #include #include #include #include #include #include #include #include #include #include #include #include #include "absl/algorithm/container.h" #include "absl/strings/match.h" #include "absl/strings/string_view.h" #include "api/audio_codecs/audio_format.h" #include "api/candidate.h" #include "api/environment/environment.h" #include "api/field_trials_view.h" #include "api/media_types.h" #include "api/payload_type.h" #include "api/rtp_parameters.h" #include "api/rtp_transceiver_direction.h" #include "api/sctp_transport_interface.h" #include "api/video_codecs/sdp_video_format.h" #include "call/fake_payload_type_suggester.h" #include "call/payload_type.h" #include "media/base/codec.h" #include "media/base/codec_list.h" #include "media/base/fake_media_engine.h" #include "media/base/media_constants.h" #include "media/base/rid_description.h" #include "media/base/stream_params.h" #include "media/base/test_utils.h" #include "p2p/base/p2p_constants.h" #include "p2p/base/transport_description.h" #include "p2p/base/transport_description_factory.h" #include "p2p/base/transport_info.h" #include "pc/codec_vendor.h" #include "pc/media_options.h" #include "pc/media_protocol_names.h" #include "pc/rtp_media_utils.h" #include "pc/rtp_parameters_conversion.h" #include "pc/session_description.h" #include "pc/simulcast_description.h" #include "rtc_base/checks.h" #include "rtc_base/fake_ssl_identity.h" #include "rtc_base/logging.h" #include "rtc_base/rtc_certificate.h" #include "rtc_base/ssl_identity.h" #include "rtc_base/string_encode.h" #include "rtc_base/strings/string_builder.h" #include "rtc_base/system/plan_b_only.h" #include "rtc_base/unique_id_generator.h" #include "test/create_test_environment.h" #include "test/gmock.h" #include "test/gtest.h" #include "test/pc/sctp/fake_sctp_transport.h" namespace webrtc { namespace { using ::testing::Bool; using ::testing::Combine; using ::testing::Contains; using ::testing::ElementsAre; using ::testing::ElementsAreArray; using ::testing::Eq; using ::testing::Field; using ::testing::Gt; using ::testing::IsEmpty; using ::testing::Not; using ::testing::NotNull; using ::testing::Pointwise; using ::testing::SizeIs; using ::testing::UnorderedElementsAreArray; using ::testing::Values; using ::testing::ValuesIn; using Candidates = std::vector; constexpr char kAudioMid[] = "0"; constexpr char kVideoMid[] = "1"; constexpr char kDataMid[] = "2"; class CodecLookupHelperForTesting : public CodecLookupHelper { public: explicit CodecLookupHelperForTesting(const FieldTrialsView& field_trials) : field_trials_(field_trials) {} webrtc::PayloadTypeSuggester* PayloadTypeSuggester() override { return &payload_type_suggester_; } CodecVendor* GetCodecVendor() override { if (!codec_vendor_) { codec_vendor_.reset( new CodecVendor(&media_engine_, rtx_enabled_, field_trials_)); } return codec_vendor_.get(); } void RegisterExpectations(absl::string_view mid, std::span codecs) { for (const Codec& c : codecs) { if (c.id.IsSet()) { RTC_CHECK(payload_type_suggester_.AddLocalMapping(mid, c.id, c).ok()); } } } void SetVideoCodecs(std::span send, std::span receive) { media_engine_.SetVideoRecvCodecs( std::vector(receive.begin(), receive.end())); media_engine_.SetVideoSendCodecs( std::vector(send.begin(), send.end())); if (field_trials_.IsEnabled("WebRTC-PayloadTypesInTransport")) { RegisterExpectations(kVideoMid, send); RegisterExpectations(kVideoMid, receive); } MaybeEnableRtx(send); codec_vendor_.reset(); } void SetAudioCodecs(std::span send, std::span receive) { media_engine_.SetAudioSendCodecs( std::vector(send.begin(), send.end())); media_engine_.SetAudioRecvCodecs( std::vector(receive.begin(), receive.end())); if (field_trials_.IsEnabled("WebRTC-PayloadTypesInTransport")) { RegisterExpectations(kAudioMid, send); RegisterExpectations(kAudioMid, receive); } codec_vendor_.reset(); } void SetAudioCodecs(std::span codecs) { SetAudioCodecs(codecs, codecs); } void SetVideoCodecs(std::span codecs) { SetVideoCodecs(codecs, codecs); } void SetAudioCodecs(std::initializer_list codecs) { SetAudioCodecs(std::span(codecs.begin(), codecs.end())); } void SetVideoCodecs(std::initializer_list codecs) { SetVideoCodecs(std::span(codecs.begin(), codecs.end())); } void ClearAudioCodecs() { SetAudioCodecs(std::vector()); } void ClearVideoCodecs() { SetVideoCodecs(std::vector()); } private: void MaybeEnableRtx(std::span codecs) { for (const Codec& c : codecs) { if (c.name == kRtxCodecName) { rtx_enabled_ = true; break; } } } const FieldTrialsView& field_trials_; FakePayloadTypeSuggester payload_type_suggester_; bool rtx_enabled_ = false; FakeMediaEngine media_engine_; std::unique_ptr codec_vendor_; }; 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 std::array kAudioCodecs1 = {CreateAudioCodec(111, "opus", 48000, 2), CreateRedAudioCodec("111"), CreateAudioCodec(103, "G722", 16000, 1), CreateAudioCodec(0, "PCMU", 8000, 1), CreateAudioCodec(8, "PCMA", 8000, 1), CreateAudioCodec(107, "CN", 48000, 1)}; const std::array kAudioCodecs2 = { CreateAudioCodec(126, "foo", 16000, 1), CreateAudioCodec(0, "PCMU", 8000, 1), CreateAudioCodec(127, "G722", 16000, 1), }; const std::array kAudioCodecsAnswer = { CreateAudioCodec(103, "G722", 16000, 1), CreateAudioCodec(0, "PCMU", 8000, 1), }; const std::array kVideoCodecs1 = {CreateVideoCodec(96, "H264-SVC"), CreateVideoCodec(97, "H264")}; const std::array kVideoCodecs1Reverse = {CreateVideoCodec(97, "H264"), CreateVideoCodec(96, "H264-SVC")}; const std::array kVideoCodecs2 = {CreateVideoCodec(126, "H264"), CreateVideoCodec(127, "H263")}; const std::array kVideoCodecsAnswer = {CreateVideoCodec(97, "H264")}; // H.265 level-id, according to H.265 spec, is calculated this way: // For any given H.265 level a.b, level-id = (a * 10 + b) * 3. For level 6.0, // level-id = (6 * 10 + 0) * 3 = 180. Similar for all other H.265 levels. constexpr char kVideoCodecsH265Level6LevelId[] = "180"; constexpr char kVideoCodecsH265Level52LevelId[] = "156"; constexpr char kVideoCodecsH265Level5LevelId[] = "150"; constexpr char kVideoCodecsH265Level4LevelId[] = "120"; constexpr char kVideoCodecsH265Level31LevelId[] = "93"; const SdpVideoFormat kH265MainProfileLevel31Sdp( "H265", {{"profile-id", "1"}, {"tier-flag", "0"}, {"level-id", kVideoCodecsH265Level31LevelId}, {"tx-mode", "SRST"}}); const SdpVideoFormat kH265MainProfileLevel4Sdp("H265", {{"profile-id", "1"}, {"tier-flag", "0"}, {"level-id", kVideoCodecsH265Level4LevelId}, {"tx-mode", "SRST"}}); const SdpVideoFormat kH265MainProfileLevel5Sdp("H265", {{"profile-id", "1"}, {"tier-flag", "0"}, {"level-id", kVideoCodecsH265Level5LevelId}, {"tx-mode", "SRST"}}); const SdpVideoFormat kH265MainProfileLevel52Sdp( "H265", {{"profile-id", "1"}, {"tier-flag", "0"}, {"level-id", kVideoCodecsH265Level52LevelId}, {"tx-mode", "SRST"}}); const SdpVideoFormat kH265MainProfileLevel6Sdp("H265", {{"profile-id", "1"}, {"tier-flag", "0"}, {"level-id", kVideoCodecsH265Level6LevelId}, {"tx-mode", "SRST"}}); const std::array kVideoCodecsH265Level31 = { CreateVideoCodec(96, kH265MainProfileLevel31Sdp)}; const std::array kVideoCodecsH265Level4 = { CreateVideoCodec(96, kH265MainProfileLevel4Sdp)}; const std::array kVideoCodecsH265Level5 = { CreateVideoCodec(96, kH265MainProfileLevel5Sdp)}; const std::array kVideoCodecsH265Level52 = { CreateVideoCodec(96, kH265MainProfileLevel52Sdp)}; const std::array kVideoCodecsH265Level6 = { CreateVideoCodec(96, kH265MainProfileLevel6Sdp)}; // Match two codec lists for content, but ignore the ID and feedback params. MATCHER_P2(CodecListsMatch, expected, field_trials, "") { if (expected.size() != arg.size()) { return false; } for (size_t i = 0; i < expected.size(); ++i) { if (!expected[i].Matches(arg[i])) { return false; } } return true; } MATCHER_P(NamesMatchImpl, expected_names, "") { std::vector actual_names; for (const auto& item : arg) { actual_names.push_back(item.name); } return ::testing::ExplainMatchResult( ::testing::ElementsAreArray(expected_names), actual_names, result_listener); } inline auto NamesMatch(std::vector expected_names) { return NamesMatchImpl(std::move(expected_names)); } const std::array kAudioRtpExtension1 = { RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 8), RtpExtension("http://google.com/testing/audio_something", 10), }; const std::array kAudioRtpExtensionEncrypted1 = { RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 8), RtpExtension("http://google.com/testing/audio_something", 11, true), }; const std::array kAudioRtpExtension2 = { RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 2), RtpExtension("http://google.com/testing/audio_something_else", 8), RtpExtension("http://google.com/testing/both_audio_and_video", 7), }; const std::array kAudioRtpExtensionEncrypted2 = { RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 2), RtpExtension("http://google.com/testing/audio_something", 13, true), RtpExtension("http://google.com/testing/audio_something_else", 5, true), }; const std::array kAudioRtpExtension3 = { RtpExtension("http://google.com/testing/audio_something", 2), RtpExtension("http://google.com/testing/both_audio_and_video", 3), }; const std::array kAudioRtpExtensionMixedEncryption1 = { RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 8), RtpExtension("http://google.com/testing/audio_something", 9), RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 10, true), RtpExtension("http://google.com/testing/audio_something", 11, true), RtpExtension("http://google.com/testing/audio_something_else", 12, true), }; const std::array kAudioRtpExtensionMixedEncryption2 = { RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 5), RtpExtension("http://google.com/testing/audio_something", 6), RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 7, true), RtpExtension("http://google.com/testing/audio_something", 8, true), RtpExtension("http://google.com/testing/audio_something_else", 9), }; const std::array kAudioRtpExtensionAnswer = { RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 8), }; const std::array kAudioRtpExtensionEncryptedAnswer = { RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 8), RtpExtension("http://google.com/testing/audio_something", 11, true), }; const std::array kAudioRtpExtensionMixedEncryptionAnswerEncryptionEnabled = { RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 10, true), RtpExtension("http://google.com/testing/audio_something", 11, true), }; const std::array kAudioRtpExtensionMixedEncryptionAnswerEncryptionDisabled = { RtpExtension("urn:ietf:params:rtp-hdrext:ssrc-audio-level", 8), RtpExtension("http://google.com/testing/audio_something", 9), }; const std::array kVideoRtpExtension1 = { RtpExtension("urn:ietf:params:rtp-hdrext:toffset", 14), RtpExtension("http://google.com/testing/video_something", 13), }; const std::array kVideoRtpExtensionEncrypted1 = { RtpExtension("urn:ietf:params:rtp-hdrext:toffset", 14), RtpExtension("http://google.com/testing/video_something", 7, true), }; const std::array kVideoRtpExtension2 = { RtpExtension("urn:ietf:params:rtp-hdrext:toffset", 2), RtpExtension("http://google.com/testing/video_something_else", 14), RtpExtension("http://google.com/testing/both_audio_and_video", 7), }; const std::array kVideoRtpExtensionEncrypted2 = { RtpExtension("urn:ietf:params:rtp-hdrext:toffset", 8), RtpExtension("http://google.com/testing/video_something", 10, true), RtpExtension("http://google.com/testing/video_something_else", 4, true), }; const std::array kVideoRtpExtension3 = { RtpExtension("http://google.com/testing/video_something", 4), RtpExtension("http://google.com/testing/both_audio_and_video", 5), }; const std::array kVideoRtpExtensionMixedEncryption = { RtpExtension("urn:ietf:params:rtp-hdrext:toffset", 14), RtpExtension("http://google.com/testing/video_something", 13), RtpExtension("urn:ietf:params:rtp-hdrext:toffset", 15, true), RtpExtension("http://google.com/testing/video_something", 16, true), }; const std::array kVideoRtpExtensionAnswer = { RtpExtension("urn:ietf:params:rtp-hdrext:toffset", 14), }; const std::array kVideoRtpExtensionEncryptedAnswer = { RtpExtension("urn:ietf:params:rtp-hdrext:toffset", 14), RtpExtension("http://google.com/testing/video_something", 7, true), }; const std::array kVideoRtpExtensionMixedEncryptionAnswerEncryptionEnabled = { RtpExtension("urn:ietf:params:rtp-hdrext:toffset", 15, true), RtpExtension("http://google.com/testing/video_something", 16, true), }; const std::array kVideoRtpExtensionMixedEncryptionAnswerEncryptionDisabled = { RtpExtension("urn:ietf:params:rtp-hdrext:toffset", 14), RtpExtension("http://google.com/testing/video_something", 13), }; const std::array kRtpExtensionTransportSequenceNumber01 = { RtpExtension("http://www.ietf.org/id/" "draft-holmer-rmcat-transport-wide-cc-extensions-01", 1), }; const std::array kRtpExtensionTransportSequenceNumber01And02 = { RtpExtension("http://www.ietf.org/id/" "draft-holmer-rmcat-transport-wide-cc-extensions-01", 1), RtpExtension( "http://www.webrtc.org/experiments/rtp-hdrext/transport-wide-cc-02", 2), }; const std::array kRtpExtensionTransportSequenceNumber02 = { RtpExtension( "http://www.webrtc.org/experiments/rtp-hdrext/transport-wide-cc-02", 2), }; const std::array kRtpExtensionGenericFrameDescriptorUri00 = { RtpExtension("http://www.webrtc.org/experiments/rtp-hdrext/" "generic-frame-descriptor-00", 3), }; constexpr uint32_t kSimulcastParamsSsrc[] = {10, 11, 20, 21, 30, 31}; constexpr uint32_t kSimSsrc[] = {10, 20, 30}; constexpr uint32_t kFec1Ssrc[] = {10, 11}; constexpr uint32_t kFec2Ssrc[] = {20, 21}; constexpr uint32_t kFec3Ssrc[] = {30, 31}; constexpr char kMediaStream1[] = "stream_1"; constexpr char kMediaStream2[] = "stream_2"; constexpr char kVideoTrack1[] = "video_1"; constexpr char kVideoTrack2[] = "video_2"; constexpr char kAudioTrack1[] = "audio_1"; constexpr char kAudioTrack2[] = "audio_2"; constexpr char kAudioTrack3[] = "audio_3"; const char* kMediaProtocols[] = {"RTP/AVP", "RTP/SAVP", "RTP/AVPF", "RTP/SAVPF"}; const char* kMediaProtocolsDtls[] = {"TCP/TLS/RTP/SAVPF", "TCP/TLS/RTP/SAVP", "UDP/TLS/RTP/SAVPF", "UDP/TLS/RTP/SAVP"}; // These constants are used to make the code using "AddMediaDescriptionOptions" // more readable. constexpr bool kStopped = true; constexpr bool kActive = false; // Helper used for debugging. It reports the media type and the parameters. std::string FullMimeType(Codec codec) { StringBuilder sb; switch (codec.type) { case Codec::Type::kAudio: sb << "audio/"; break; case Codec::Type::kVideo: sb << "video/"; break; } sb << codec.name; for (auto& param : codec.params) { sb << ";" << param.first << "=" << param.second; } return sb.Release(); } bool IsMediaContentOfType(const ContentInfo* content, MediaType media_type) { RTC_DCHECK(content); return content->media_description()->type() == media_type; } RtpTransceiverDirection GetMediaDirection(const ContentInfo* content) { RTC_DCHECK(content); return content->media_description()->direction(); } void AddRtxCodec(const Codec& rtx_codec, std::vector* codecs) { RTC_LOG(LS_VERBOSE) << "Adding RTX codec " << FullMimeType(rtx_codec); ASSERT_FALSE(FindCodecById(*codecs, rtx_codec.id)); codecs->push_back(rtx_codec); } std::vector GetCodecNames(std::span codecs) { std::vector codec_names; codec_names.reserve(codecs.size()); for (const Codec& codec : codecs) { codec_names.push_back(codec.name); } return codec_names; } // This is used for test only. MIDs are not the identification of the // MediaDescriptionOptions since some end points may not support MID and the SDP // may not contain 'mid'. std::vector::iterator FindFirstMediaDescriptionByMid( const std::string& mid, MediaSessionOptions* opts) { return absl::c_find_if( opts->media_description_options, [&mid](const MediaDescriptionOptions& t) { return t.mid == mid; }); } std::vector::const_iterator FindFirstMediaDescriptionByMid(const std::string& mid, const MediaSessionOptions& opts) { return absl::c_find_if( opts.media_description_options, [&mid](const MediaDescriptionOptions& t) { return t.mid == mid; }); } // Add a media section to the `session_options`. void AddMediaDescriptionOptions(MediaType type, const std::string& mid, RtpTransceiverDirection direction, bool stopped, MediaSessionOptions* opts) { opts->media_description_options.push_back( MediaDescriptionOptions(type, mid, direction, stopped)); } void AddAudioVideoSections(RtpTransceiverDirection direction, MediaSessionOptions* opts) { AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, direction, kActive, opts); AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, direction, kActive, opts); } void AddDataSection(RtpTransceiverDirection direction, MediaSessionOptions* opts) { AddMediaDescriptionOptions(MediaType::DATA, kDataMid, direction, kActive, opts); } void AttachSenderToMediaDescriptionOptions( const std::string& mid, MediaType type, const std::string& track_id, std::span stream_ids, std::span rids, const SimulcastLayerList& simulcast_layers, int num_sim_layer, MediaSessionOptions* session_options) { auto it = FindFirstMediaDescriptionByMid(mid, session_options); RTC_ALLOW_PLAN_B_DEPRECATION_BEGIN(); switch (type) { case MediaType::AUDIO: it->AddAudioSender(track_id, std::vector(stream_ids.begin(), stream_ids.end())); break; case MediaType::VIDEO: it->AddVideoSender( track_id, std::vector(stream_ids.begin(), stream_ids.end()), std::vector(rids.begin(), rids.end()), simulcast_layers, num_sim_layer); break; default: RTC_DCHECK_NOTREACHED(); } RTC_ALLOW_PLAN_B_DEPRECATION_END(); } void AttachSenderToMediaDescriptionOptions( const std::string& mid, MediaType type, const std::string& track_id, std::initializer_list stream_ids, std::span rids, const SimulcastLayerList& simulcast_layers, int num_sim_layer, MediaSessionOptions* session_options) { AttachSenderToMediaDescriptionOptions( mid, type, track_id, std::span(stream_ids), rids, simulcast_layers, num_sim_layer, session_options); } void AttachSenderToMediaDescriptionOptions( const std::string& mid, MediaType type, const std::string& track_id, std::span stream_ids, int num_sim_layer, MediaSessionOptions* session_options) { AttachSenderToMediaDescriptionOptions(mid, type, track_id, stream_ids, {}, SimulcastLayerList(), num_sim_layer, session_options); } void AttachSenderToMediaDescriptionOptions( const std::string& mid, MediaType type, const std::string& track_id, std::initializer_list stream_ids, int num_sim_layer, MediaSessionOptions* session_options) { AttachSenderToMediaDescriptionOptions( mid, type, track_id, std::span(stream_ids), num_sim_layer, session_options); } void AttachSenderToMediaDescriptionOptions( const std::string& mid, MediaType type, const std::string& track_id, std::initializer_list stream_ids, std::initializer_list rids, const SimulcastLayerList& simulcast_layers, int num_sim_layer, MediaSessionOptions* session_options) { AttachSenderToMediaDescriptionOptions( mid, type, track_id, std::span(stream_ids), std::span(rids), simulcast_layers, num_sim_layer, session_options); } void DetachSenderFromMediaSection(const std::string& mid, const std::string& track_id, MediaSessionOptions* session_options) { std::vector& sender_options_list = FindFirstMediaDescriptionByMid(mid, session_options)->sender_options; auto sender_it = absl::c_find_if( sender_options_list, [track_id](const SenderOptions& sender_options) { return sender_options.track_id == track_id; }); RTC_DCHECK(sender_it != sender_options_list.end()); sender_options_list.erase(sender_it); } // Helper function used to create recv-only audio MediaSessionOptions. MediaSessionOptions CreateAudioMediaSession() { MediaSessionOptions session_options; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kRecvOnly, kActive, &session_options); return session_options; } // TODO(zhihuang): Most of these tests were written while MediaSessionOptions // was designed for Plan B SDP, where only one audio "m=" section and one video // "m=" section could be generated, and ordering couldn't be controlled. Many of // these tests may be obsolete as a result, and should be refactored or removed. class MediaSessionDescriptionFactoryTest : public testing::Test { public: MediaSessionDescriptionFactoryTest(absl::string_view field_trials_string = "") : env_(CreateTestEnvironment({.field_trials = field_trials_string})), tdf1_(env_.field_trials()), tdf2_(env_.field_trials()), codec_lookup_helper_1_(env_.field_trials()), codec_lookup_helper_2_(env_.field_trials()), f1_(env_, nullptr, false, &ssrc_generator1, &tdf1_, &sctp_factory_1_, &codec_lookup_helper_1_), f2_(env_, nullptr, false, &ssrc_generator2, &tdf2_, &sctp_factory_2_, &codec_lookup_helper_2_) { codec_lookup_helper_1_.SetAudioCodecs(kAudioCodecs1); codec_lookup_helper_1_.SetVideoCodecs(kVideoCodecs1); codec_lookup_helper_2_.SetAudioCodecs(kAudioCodecs2); codec_lookup_helper_2_.SetVideoCodecs(kVideoCodecs2); tdf1_.set_certificate(RTCCertificate::Create( std::unique_ptr(new FakeSSLIdentity("id1")))); tdf2_.set_certificate(RTCCertificate::Create( std::unique_ptr(new FakeSSLIdentity("id2")))); } // Create a video StreamParamsVec object with: // - one video stream with 3 simulcast streams and FEC, StreamParamsVec CreateComplexVideoStreamParamsVec() { SsrcGroup sim_group("SIM", MAKE_VECTOR(kSimSsrc)); SsrcGroup fec_group1("FEC", MAKE_VECTOR(kFec1Ssrc)); SsrcGroup fec_group2("FEC", MAKE_VECTOR(kFec2Ssrc)); SsrcGroup fec_group3("FEC", MAKE_VECTOR(kFec3Ssrc)); std::vector ssrc_groups; ssrc_groups.push_back(sim_group); ssrc_groups.push_back(fec_group1); ssrc_groups.push_back(fec_group2); ssrc_groups.push_back(fec_group3); StreamParams simulcast_params; simulcast_params.id = kVideoTrack1; simulcast_params.ssrcs = MAKE_VECTOR(kSimulcastParamsSsrc); simulcast_params.ssrc_groups = ssrc_groups; simulcast_params.cname = "Video_SIM_FEC"; simulcast_params.set_stream_ids({kMediaStream1}); StreamParamsVec video_streams; video_streams.push_back(simulcast_params); return video_streams; } // Returns true if the transport info contains "renomination" as an // ICE option. bool GetIceRenomination(const TransportInfo* transport_info) { return absl::c_linear_search(transport_info->description.transport_options, "renomination"); } void TestTransportInfo(bool offer, const MediaSessionOptions& options, bool has_current_desc) { const std::string current_audio_ufrag = "current_audio_ufrag"; const std::string current_audio_pwd = "current_audio_pwd"; const std::string current_video_ufrag = "current_video_ufrag"; const std::string current_video_pwd = "current_video_pwd"; const std::string current_data_ufrag = "current_data_ufrag"; const std::string current_data_pwd = "current_data_pwd"; std::unique_ptr current_desc; std::unique_ptr desc; if (has_current_desc) { current_desc = std::make_unique(); current_desc->AddTransportInfo(TransportInfo( kAudioMid, TransportDescription(current_audio_ufrag, current_audio_pwd))); current_desc->AddTransportInfo(TransportInfo( kVideoMid, TransportDescription(current_video_ufrag, current_video_pwd))); current_desc->AddTransportInfo(TransportInfo( kDataMid, TransportDescription(current_data_ufrag, current_data_pwd))); } if (offer) { desc = f1_.CreateOfferOrError(options, current_desc.get()).MoveValue(); } else { std::unique_ptr offer_desc; offer_desc = f1_.CreateOfferOrError(options, nullptr).MoveValue(); desc = f1_.CreateAnswerOrError(offer_desc.get(), options, current_desc.get()) .MoveValue(); } ASSERT_TRUE(desc); const TransportInfo* ti_audio = desc->GetTransportInfoByName(kAudioMid); if (options.has_audio()) { if (has_current_desc) { EXPECT_EQ(current_audio_ufrag, ti_audio->description.ice_ufrag); EXPECT_EQ(current_audio_pwd, ti_audio->description.ice_pwd); } else { EXPECT_THAT(ti_audio->description.ice_ufrag, SizeIs(ICE_UFRAG_LENGTH)); EXPECT_THAT(ti_audio->description.ice_pwd, SizeIs(ICE_PWD_LENGTH)); } auto media_desc_options_it = FindFirstMediaDescriptionByMid(kAudioMid, options); EXPECT_EQ( media_desc_options_it->transport_options.enable_ice_renomination, GetIceRenomination(ti_audio)); } const TransportInfo* ti_video = desc->GetTransportInfoByName(kVideoMid); if (options.has_video()) { auto media_desc_options_it = FindFirstMediaDescriptionByMid(kVideoMid, options); if (options.bundle_enabled) { EXPECT_EQ(ti_audio->description.ice_ufrag, ti_video->description.ice_ufrag); EXPECT_EQ(ti_audio->description.ice_pwd, ti_video->description.ice_pwd); } else { if (has_current_desc) { EXPECT_EQ(current_video_ufrag, ti_video->description.ice_ufrag); EXPECT_EQ(current_video_pwd, ti_video->description.ice_pwd); } else { EXPECT_THAT(ti_video->description.ice_ufrag, SizeIs(ICE_UFRAG_LENGTH)); EXPECT_THAT(ti_video->description.ice_pwd, SizeIs(ICE_PWD_LENGTH)); } } EXPECT_EQ( media_desc_options_it->transport_options.enable_ice_renomination, GetIceRenomination(ti_video)); } const TransportInfo* ti_data = desc->GetTransportInfoByName(kDataMid); if (options.has_data()) { if (options.bundle_enabled) { EXPECT_EQ(ti_audio->description.ice_ufrag, ti_data->description.ice_ufrag); EXPECT_EQ(ti_audio->description.ice_pwd, ti_data->description.ice_pwd); } else { if (has_current_desc) { EXPECT_EQ(current_data_ufrag, ti_data->description.ice_ufrag); EXPECT_EQ(current_data_pwd, ti_data->description.ice_pwd); } else { EXPECT_THAT(ti_data->description.ice_ufrag, SizeIs(ICE_UFRAG_LENGTH)); EXPECT_THAT(ti_data->description.ice_pwd, SizeIs(ICE_PWD_LENGTH)); } } auto media_desc_options_it = FindFirstMediaDescriptionByMid(kDataMid, options); EXPECT_EQ( media_desc_options_it->transport_options.enable_ice_renomination, GetIceRenomination(ti_data)); } } // This test that the audio and video media direction is set to // `expected_direction_in_answer` in an answer if the offer direction is set // to `direction_in_offer` and the answer is willing to both send and receive. void TestMediaDirectionInAnswer( RtpTransceiverDirection direction_in_offer, RtpTransceiverDirection expected_direction_in_answer) { MediaSessionOptions offer_opts; AddAudioVideoSections(direction_in_offer, &offer_opts); std::unique_ptr offer = f1_.CreateOfferOrError(offer_opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); ContentInfo* ac_offer = offer->GetContentByName(kAudioMid); ASSERT_TRUE(ac_offer); ContentInfo* vc_offer = offer->GetContentByName(kVideoMid); ASSERT_TRUE(vc_offer); MediaSessionOptions answer_opts; AddAudioVideoSections(RtpTransceiverDirection::kSendRecv, &answer_opts); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), answer_opts, nullptr).MoveValue(); const AudioContentDescription* acd_answer = GetFirstAudioContentDescription(answer.get()); EXPECT_EQ(expected_direction_in_answer, acd_answer->direction()); const VideoContentDescription* vcd_answer = GetFirstVideoContentDescription(answer.get()); EXPECT_EQ(expected_direction_in_answer, vcd_answer->direction()); } bool VerifyNoCNCodecs(const ContentInfo* content) { RTC_DCHECK(content); RTC_CHECK(content->media_description()); for (const Codec& codec : content->media_description()->codecs()) { if (codec.name == "CN") { return false; } } return true; } void TestTransportSequenceNumberNegotiation( std::span local, std::span offered, std::span expectedAnswer) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); SetAudioVideoRtpHeaderExtensions(offered, offered, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); SetAudioVideoRtpHeaderExtensions(local, local, &opts); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); EXPECT_THAT( expectedAnswer, UnorderedElementsAreArray(GetFirstAudioContentDescription(answer.get()) ->rtp_header_extensions())); EXPECT_THAT( expectedAnswer, UnorderedElementsAreArray(GetFirstVideoContentDescription(answer.get()) ->rtp_header_extensions())); } std::vector HeaderExtensionCapabilitiesFromRtpExtensions( std::span extensions) { std::vector capabilities; for (const RtpExtension& extension : extensions) { RtpHeaderExtensionCapability capability( extension.uri, extension.id, extension.encrypt, RtpTransceiverDirection::kSendRecv); capabilities.push_back(capability); } return capabilities; } void SetAudioVideoRtpHeaderExtensions( std::span audio_exts, std::span video_exts, MediaSessionOptions* opts) { std::vector audio_caps = HeaderExtensionCapabilitiesFromRtpExtensions(audio_exts); std::vector video_caps = HeaderExtensionCapabilitiesFromRtpExtensions(video_exts); for (MediaDescriptionOptions& entry : opts->media_description_options) { switch (entry.type) { case MediaType::AUDIO: entry.header_extensions = audio_caps; break; case MediaType::VIDEO: entry.header_extensions = video_caps; break; default: break; } } } protected: Environment env_; UniqueRandomIdGenerator ssrc_generator1; UniqueRandomIdGenerator ssrc_generator2; TransportDescriptionFactory tdf1_; TransportDescriptionFactory tdf2_; CodecLookupHelperForTesting codec_lookup_helper_1_; CodecLookupHelperForTesting codec_lookup_helper_2_; FakeSctpTransportFactory sctp_factory_1_; FakeSctpTransportFactory sctp_factory_2_; MediaSessionDescriptionFactory f1_; MediaSessionDescriptionFactory f2_; }; // Create a typical audio offer, and ensure it matches what we expect. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioOffer) { std::unique_ptr offer = f1_.CreateOfferOrError(CreateAudioMediaSession(), nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* ac = offer->GetContentByName(kAudioMid); const ContentInfo* vc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); EXPECT_FALSE(vc); EXPECT_EQ(ac->type, MediaProtocolType::kRtp); const MediaContentDescription* acd = ac->media_description(); EXPECT_EQ(acd->type(), MediaType::AUDIO); EXPECT_THAT(acd->codecs(), CodecListsMatch(codec_lookup_helper_1_.GetCodecVendor() ->audio_sendrecv_codecs() .codecs(), &env_.field_trials())); EXPECT_EQ(acd->first_ssrc(), 0U); // no sender is attached. EXPECT_EQ(acd->bandwidth(), kAutoBandwidth); // default bandwidth (auto) EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on EXPECT_EQ(acd->protocol(), kMediaProtocolDtlsSavpf); } // Create an offer with just Opus and RED. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioOfferWithJustOpusAndRed) { // First, prefer to only use opus and red. std::vector preferences; preferences.push_back(ToRtpCodecCapability( codec_lookup_helper_1_.GetCodecVendor()->audio_sendrecv_codecs()[0])); preferences.push_back(ToRtpCodecCapability( codec_lookup_helper_1_.GetCodecVendor()->audio_sendrecv_codecs()[1])); EXPECT_THAT(preferences, NamesMatch({"opus", "red"})); MediaSessionOptions opts = CreateAudioMediaSession(); opts.media_description_options.at(0).codec_preferences = preferences; std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* ac = offer->GetContentByName(kAudioMid); const ContentInfo* vc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(ac != nullptr); ASSERT_TRUE(vc == nullptr); EXPECT_EQ(ac->type, MediaProtocolType::kRtp); const MediaContentDescription* acd = ac->media_description(); EXPECT_EQ(acd->type(), MediaType::AUDIO); EXPECT_THAT(acd->codecs(), NamesMatch({"opus", "red"})); } // Create an offer with RED before Opus, which enables RED with Opus encoding. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioOfferWithRedForOpus) { // First, prefer to only use opus and red. std::vector preferences; preferences.push_back(ToRtpCodecCapability( codec_lookup_helper_1_.GetCodecVendor()->audio_sendrecv_codecs()[1])); preferences.push_back(ToRtpCodecCapability( codec_lookup_helper_1_.GetCodecVendor()->audio_sendrecv_codecs()[0])); EXPECT_THAT(preferences, NamesMatch({"red", "opus"})); MediaSessionOptions opts = CreateAudioMediaSession(); opts.media_description_options.at(0).codec_preferences = preferences; std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* ac = offer->GetContentByName(kAudioMid); const ContentInfo* vc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(ac != nullptr); ASSERT_TRUE(vc == nullptr); EXPECT_EQ(ac->type, MediaProtocolType::kRtp); const MediaContentDescription* acd = ac->media_description(); EXPECT_EQ(acd->type(), MediaType::AUDIO); EXPECT_THAT(acd->codecs(), NamesMatch({"red", "opus"})); } // Create a typical video offer, and ensure it matches what we expect. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoOffer) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* ac = offer->GetContentByName(kAudioMid); const ContentInfo* vc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); ASSERT_TRUE(vc); EXPECT_EQ(ac->type, MediaProtocolType::kRtp); EXPECT_EQ(vc->type, MediaProtocolType::kRtp); const MediaContentDescription* acd = ac->media_description(); const MediaContentDescription* vcd = vc->media_description(); EXPECT_EQ(acd->type(), MediaType::AUDIO); EXPECT_THAT(acd->codecs(), CodecListsMatch(codec_lookup_helper_1_.GetCodecVendor() ->audio_sendrecv_codecs() .codecs(), &env_.field_trials())); EXPECT_EQ(acd->first_ssrc(), 0U); // no sender is attached EXPECT_EQ(acd->bandwidth(), kAutoBandwidth); // default bandwidth (auto) EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on EXPECT_EQ(acd->protocol(), kMediaProtocolDtlsSavpf); EXPECT_EQ(vcd->type(), MediaType::VIDEO); EXPECT_THAT(vcd->codecs(), CodecListsMatch(codec_lookup_helper_1_.GetCodecVendor() ->video_sendrecv_codecs() .codecs(), &env_.field_trials())); EXPECT_EQ(vcd->first_ssrc(), 0U); // no sender is attached EXPECT_EQ(vcd->bandwidth(), kAutoBandwidth); // default bandwidth (auto) EXPECT_TRUE(vcd->rtcp_mux()); // rtcp-mux defaults on EXPECT_EQ(vcd->protocol(), kMediaProtocolDtlsSavpf); } TEST_F(MediaSessionDescriptionFactoryTest, TestCreateOfferWithCustomCodecs) { MediaSessionOptions opts; SdpAudioFormat audio_format("custom-audio", 8000, 2); Codec custom_audio_codec = CreateAudioCodec(audio_format); custom_audio_codec.id = 123; // picked at random, but valid auto audio_options = MediaDescriptionOptions( MediaType::AUDIO, "0", RtpTransceiverDirection::kSendRecv, kActive); audio_options.codecs_to_include.push_back(custom_audio_codec); opts.media_description_options.push_back(audio_options); Codec custom_video_codec = CreateVideoCodec("custom-video"); custom_video_codec.id = 124; // picked at random, but valid auto video_options = MediaDescriptionOptions( MediaType::VIDEO, "1", RtpTransceiverDirection::kSendRecv, kActive); video_options.codecs_to_include.push_back(custom_video_codec); opts.media_description_options.push_back(video_options); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* ac = offer->GetContentByName("0"); const ContentInfo* vc = offer->GetContentByName("1"); ASSERT_TRUE(ac); ASSERT_TRUE(vc); EXPECT_EQ(ac->type, MediaProtocolType::kRtp); EXPECT_EQ(vc->type, MediaProtocolType::kRtp); const MediaContentDescription* acd = ac->media_description(); const MediaContentDescription* vcd = vc->media_description(); EXPECT_EQ(acd->type(), MediaType::AUDIO); EXPECT_THAT(acd->codecs(), NamesMatch({custom_audio_codec.name})); EXPECT_EQ(vcd->type(), MediaType::VIDEO); EXPECT_THAT(vcd->codecs(), NamesMatch({custom_video_codec.name})); } TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAnswerWithCustomCodecs) { MediaSessionOptions offer_opts; MediaSessionOptions answer_opts; AddAudioVideoSections(RtpTransceiverDirection::kSendRecv, &offer_opts); // Create custom codecs and add to answer. These will override // the normally generated codec list in the answer. // This breaks O/A rules - the responsibility for obeying those is // on the caller, not on this function. SdpAudioFormat audio_format("custom-audio", 8000, 2); Codec custom_audio_codec = CreateAudioCodec(audio_format); custom_audio_codec.id = 123; // picked at random, but valid auto audio_options = MediaDescriptionOptions( MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kSendRecv, kActive); audio_options.codecs_to_include.push_back(custom_audio_codec); answer_opts.media_description_options.push_back(audio_options); Codec custom_video_codec = CreateVideoCodec("custom-video"); custom_video_codec.id = 124; auto video_options = MediaDescriptionOptions( MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive); video_options.codecs_to_include.push_back(custom_video_codec); answer_opts.media_description_options.push_back(video_options); std::unique_ptr offer = f1_.CreateOfferOrError(offer_opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); std::unique_ptr answer = f1_.CreateAnswerOrError(offer.get(), answer_opts, nullptr).MoveValue(); const ContentInfo* ac = answer->GetContentByName(kAudioMid); const ContentInfo* vc = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); ASSERT_TRUE(vc); EXPECT_EQ(ac->type, MediaProtocolType::kRtp); EXPECT_EQ(vc->type, MediaProtocolType::kRtp); const MediaContentDescription* acd = ac->media_description(); const MediaContentDescription* vcd = vc->media_description(); EXPECT_EQ(acd->type(), MediaType::AUDIO); EXPECT_THAT(acd->codecs(), NamesMatch({custom_audio_codec.name})); EXPECT_EQ(vcd->type(), MediaType::VIDEO); EXPECT_THAT(vcd->codecs(), NamesMatch({custom_video_codec.name})); } // Test creating an offer with bundle where the Codecs have the same dynamic // RTP paylod type. The test verifies that the offer don't contain the // duplicate RTP payload types. TEST_F(MediaSessionDescriptionFactoryTest, TestBundleOfferWithSameCodecPlType) { Codec offered_video_codec = codec_lookup_helper_2_.GetCodecVendor()->video_sendrecv_codecs()[0]; Codec offered_audio_codec = codec_lookup_helper_2_.GetCodecVendor()->audio_sendrecv_codecs()[0]; ASSERT_EQ(offered_video_codec.id, offered_audio_codec.id); MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); opts.bundle_enabled = true; std::unique_ptr offer = f2_.CreateOfferOrError(opts, nullptr).MoveValue(); const VideoContentDescription* vcd = GetFirstVideoContentDescription(offer.get()); const AudioContentDescription* acd = GetFirstAudioContentDescription(offer.get()); ASSERT_TRUE(vcd); ASSERT_TRUE(acd); EXPECT_NE(vcd->codecs()[0].id, acd->codecs()[0].id); EXPECT_EQ(vcd->codecs()[0].name, offered_video_codec.name); EXPECT_EQ(acd->codecs()[0].name, offered_audio_codec.name); } // Test creating an updated offer with bundle, audio, video and data // after an audio only session has been negotiated. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateUpdatedVideoOfferWithBundle) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kRecvOnly, kActive, &opts); AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kInactive, kStopped, &opts); opts.bundle_enabled = true; std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); MediaSessionOptions updated_opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &updated_opts); updated_opts.bundle_enabled = true; std::unique_ptr updated_offer( f1_.CreateOfferOrError(updated_opts, answer.get()).MoveValue()); const AudioContentDescription* acd = GetFirstAudioContentDescription(updated_offer.get()); const VideoContentDescription* vcd = GetFirstVideoContentDescription(updated_offer.get()); EXPECT_TRUE(vcd); EXPECT_TRUE(acd); EXPECT_EQ(acd->protocol(), kMediaProtocolDtlsSavpf); EXPECT_EQ(vcd->protocol(), kMediaProtocolDtlsSavpf); } // Create an SCTP data offer with bundle without error. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateSctpDataOffer) { MediaSessionOptions opts; opts.bundle_enabled = true; AddDataSection(RtpTransceiverDirection::kSendRecv, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); EXPECT_TRUE(offer.get()); EXPECT_TRUE(offer->GetContentByName(kDataMid)); auto dcd = GetFirstSctpDataContentDescription(offer.get()); ASSERT_TRUE(dcd); // Since this transport is insecure, the protocol should be "SCTP". EXPECT_EQ(dcd->protocol(), kMediaProtocolUdpDtlsSctp); } // Create an SCTP data offer with bundle without error. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateSecureSctpDataOffer) { MediaSessionOptions opts; opts.bundle_enabled = true; AddDataSection(RtpTransceiverDirection::kSendRecv, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); EXPECT_TRUE(offer.get()); EXPECT_TRUE(offer->GetContentByName(kDataMid)); auto dcd = GetFirstSctpDataContentDescription(offer.get()); ASSERT_TRUE(dcd); // The protocol should now be "UDP/DTLS/SCTP" EXPECT_EQ(dcd->protocol(), kMediaProtocolUdpDtlsSctp); } // Test creating an sctp data channel from an already generated offer. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateImplicitSctpDataOffer) { MediaSessionOptions opts; opts.bundle_enabled = true; AddDataSection(RtpTransceiverDirection::kSendRecv, &opts); std::unique_ptr offer1( f1_.CreateOfferOrError(opts, nullptr).MoveValue()); ASSERT_TRUE(offer1.get()); const ContentInfo* data = offer1->GetContentByName(kDataMid); ASSERT_TRUE(data); ASSERT_EQ(data->media_description()->protocol(), kMediaProtocolUdpDtlsSctp); std::unique_ptr offer2( f1_.CreateOfferOrError(opts, offer1.get()).MoveValue()); data = offer2->GetContentByName(kDataMid); ASSERT_TRUE(data); EXPECT_EQ(data->media_description()->protocol(), kMediaProtocolUdpDtlsSctp); } // Test that if BUNDLE is enabled and all media sections are rejected then the // BUNDLE group is not present in the re-offer. TEST_F(MediaSessionDescriptionFactoryTest, ReOfferNoBundleGroupIfAllRejected) { MediaSessionOptions opts; opts.bundle_enabled = true; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); opts.media_description_options[0].stopped = true; std::unique_ptr reoffer = f1_.CreateOfferOrError(opts, offer.get()).MoveValue(); EXPECT_FALSE(reoffer->GetGroupByName(GROUP_TYPE_BUNDLE)); } // Test that if BUNDLE is enabled and the remote re-offer does not include a // BUNDLE group since all media sections are rejected, then the re-answer also // does not include a BUNDLE group. TEST_F(MediaSessionDescriptionFactoryTest, ReAnswerNoBundleGroupIfAllRejected) { MediaSessionOptions opts; opts.bundle_enabled = true; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); opts.media_description_options[0].stopped = true; std::unique_ptr reoffer = f1_.CreateOfferOrError(opts, offer.get()).MoveValue(); std::unique_ptr reanswer = f2_.CreateAnswerOrError(reoffer.get(), opts, answer.get()).MoveValue(); EXPECT_FALSE(reanswer->GetGroupByName(GROUP_TYPE_BUNDLE)); } // Test that if BUNDLE is enabled and the previous offerer-tagged media section // was rejected then the new offerer-tagged media section is the non-rejected // media section. TEST_F(MediaSessionDescriptionFactoryTest, ReOfferChangeBundleOffererTagged) { MediaSessionOptions opts; opts.bundle_enabled = true; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); // Reject the audio m= section and add a video m= section. opts.media_description_options[0].stopped = true; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); std::unique_ptr reoffer = f1_.CreateOfferOrError(opts, offer.get()).MoveValue(); const ContentGroup* bundle_group = reoffer->GetGroupByName(GROUP_TYPE_BUNDLE); ASSERT_TRUE(bundle_group); EXPECT_FALSE(bundle_group->HasContentName(kAudioMid)); EXPECT_TRUE(bundle_group->HasContentName(kVideoMid)); } // Test that if BUNDLE is enabled and the previous offerer-tagged media section // was rejected and a new media section is added, then the re-answer BUNDLE // group will contain only the non-rejected media section. TEST_F(MediaSessionDescriptionFactoryTest, ReAnswerChangedBundleOffererTagged) { MediaSessionOptions opts; opts.bundle_enabled = true; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); // Reject the audio m= section and add a video m= section. opts.media_description_options[0].stopped = true; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); std::unique_ptr reoffer = f1_.CreateOfferOrError(opts, offer.get()).MoveValue(); std::unique_ptr reanswer = f2_.CreateAnswerOrError(reoffer.get(), opts, answer.get()).MoveValue(); const ContentGroup* bundle_group = reanswer->GetGroupByName(GROUP_TYPE_BUNDLE); ASSERT_TRUE(bundle_group); EXPECT_FALSE(bundle_group->HasContentName(kAudioMid)); EXPECT_TRUE(bundle_group->HasContentName(kVideoMid)); } TEST_F(MediaSessionDescriptionFactoryTest, CreateAnswerForOfferWithMultipleBundleGroups) { // Create an offer with 4 m= sections, initially without BUNDLE groups. MediaSessionOptions opts; opts.bundle_enabled = false; AddMediaDescriptionOptions(MediaType::AUDIO, "1", RtpTransceiverDirection::kSendRecv, kActive, &opts); AddMediaDescriptionOptions(MediaType::AUDIO, "2", RtpTransceiverDirection::kSendRecv, kActive, &opts); AddMediaDescriptionOptions(MediaType::AUDIO, "3", RtpTransceiverDirection::kSendRecv, kActive, &opts); AddMediaDescriptionOptions(MediaType::AUDIO, "4", RtpTransceiverDirection::kSendRecv, kActive, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer->groups().empty()); // Munge the offer to have two groups. Offers like these cannot be generated // without munging, but it is valid to receive such offers from remote // endpoints. ContentGroup bundle_group1(GROUP_TYPE_BUNDLE); bundle_group1.AddContentName("1"); bundle_group1.AddContentName("2"); ContentGroup bundle_group2(GROUP_TYPE_BUNDLE); bundle_group2.AddContentName("3"); bundle_group2.AddContentName("4"); offer->AddGroup(bundle_group1); offer->AddGroup(bundle_group2); // If BUNDLE is enabled, the answer to this offer should accept both BUNDLE // groups. opts.bundle_enabled = true; std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); std::vector answer_groups = answer->GetGroupsByName(GROUP_TYPE_BUNDLE); ASSERT_EQ(answer_groups.size(), 2u); EXPECT_EQ(answer_groups[0]->content_names().size(), 2u); EXPECT_TRUE(answer_groups[0]->HasContentName("1")); EXPECT_TRUE(answer_groups[0]->HasContentName("2")); EXPECT_EQ(answer_groups[1]->content_names().size(), 2u); EXPECT_TRUE(answer_groups[1]->HasContentName("3")); EXPECT_TRUE(answer_groups[1]->HasContentName("4")); // If BUNDLE is disabled, the answer to this offer should reject both BUNDLE // groups. opts.bundle_enabled = false; answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); answer_groups = answer->GetGroupsByName(GROUP_TYPE_BUNDLE); // Rejected groups are still listed, but they are empty. ASSERT_EQ(answer_groups.size(), 2u); EXPECT_TRUE(answer_groups[0]->content_names().empty()); EXPECT_TRUE(answer_groups[1]->content_names().empty()); } // Test that if the BUNDLE offerer-tagged media section is changed in a reoffer // and there is still a non-rejected media section that was in the initial // offer, then the ICE credentials do not change in the reoffer offerer-tagged // media section. TEST_F(MediaSessionDescriptionFactoryTest, ReOfferChangeBundleOffererTaggedKeepsIceCredentials) { MediaSessionOptions opts; opts.bundle_enabled = true; AddAudioVideoSections(RtpTransceiverDirection::kSendRecv, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); // Reject the audio m= section. opts.media_description_options[0].stopped = true; std::unique_ptr reoffer = f1_.CreateOfferOrError(opts, offer.get()).MoveValue(); const TransportDescription* offer_tagged = offer->GetTransportDescriptionByName(kAudioMid); ASSERT_TRUE(offer_tagged); const TransportDescription* reoffer_tagged = reoffer->GetTransportDescriptionByName(kVideoMid); ASSERT_TRUE(reoffer_tagged); EXPECT_EQ(offer_tagged->ice_ufrag, reoffer_tagged->ice_ufrag); EXPECT_EQ(offer_tagged->ice_pwd, reoffer_tagged->ice_pwd); } // Test that if the BUNDLE offerer-tagged media section is changed in a reoffer // and there is still a non-rejected media section that was in the initial // offer, then the ICE credentials do not change in the reanswer answerer-tagged // media section. TEST_F(MediaSessionDescriptionFactoryTest, ReAnswerChangeBundleOffererTaggedKeepsIceCredentials) { MediaSessionOptions opts; opts.bundle_enabled = true; AddAudioVideoSections(RtpTransceiverDirection::kSendRecv, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); // Reject the audio m= section. opts.media_description_options[0].stopped = true; std::unique_ptr reoffer = f1_.CreateOfferOrError(opts, offer.get()).MoveValue(); std::unique_ptr reanswer = f2_.CreateAnswerOrError(reoffer.get(), opts, answer.get()).MoveValue(); const TransportDescription* answer_tagged = answer->GetTransportDescriptionByName(kAudioMid); ASSERT_TRUE(answer_tagged); const TransportDescription* reanswer_tagged = reanswer->GetTransportDescriptionByName(kVideoMid); ASSERT_TRUE(reanswer_tagged); EXPECT_EQ(answer_tagged->ice_ufrag, reanswer_tagged->ice_ufrag); EXPECT_EQ(answer_tagged->ice_pwd, reanswer_tagged->ice_pwd); } // Create an audio, video offer without legacy StreamParams. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateOfferWithoutLegacyStreams) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* ac = offer->GetContentByName(kAudioMid); const ContentInfo* vc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); ASSERT_TRUE(vc); const MediaContentDescription* acd = ac->media_description(); const MediaContentDescription* vcd = vc->media_description(); EXPECT_FALSE(vcd->has_ssrcs()); // No StreamParams. EXPECT_FALSE(acd->has_ssrcs()); // No StreamParams. } // Creates an audio+video sendonly offer. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateSendOnlyOffer) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kSendOnly, &opts); AttachSenderToMediaDescriptionOptions( kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts); AttachSenderToMediaDescriptionOptions( kAudioMid, MediaType::AUDIO, kAudioTrack1, {kMediaStream1}, 1, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); EXPECT_EQ(offer->contents().size(), 2u); EXPECT_TRUE(IsMediaContentOfType(&offer->contents()[0], MediaType::AUDIO)); EXPECT_TRUE(IsMediaContentOfType(&offer->contents()[1], MediaType::VIDEO)); EXPECT_EQ(GetMediaDirection(&offer->contents()[0]), RtpTransceiverDirection::kSendOnly); EXPECT_EQ(GetMediaDirection(&offer->contents()[1]), RtpTransceiverDirection::kSendOnly); } // Verifies that the order of the media contents in the current // SessionDescription is preserved in the new SessionDescription. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateOfferContentOrder) { MediaSessionOptions opts; AddDataSection(RtpTransceiverDirection::kSendRecv, &opts); std::unique_ptr offer1( f1_.CreateOfferOrError(opts, nullptr).MoveValue()); ASSERT_TRUE(offer1.get()); EXPECT_EQ(offer1->contents().size(), 1u); EXPECT_TRUE(IsMediaContentOfType(&offer1->contents()[0], MediaType::DATA)); AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &opts); std::unique_ptr offer2( f1_.CreateOfferOrError(opts, offer1.get()).MoveValue()); ASSERT_TRUE(offer2.get()); EXPECT_EQ(offer2->contents().size(), 2u); EXPECT_TRUE(IsMediaContentOfType(&offer2->contents()[0], MediaType::DATA)); EXPECT_TRUE(IsMediaContentOfType(&offer2->contents()[1], MediaType::VIDEO)); AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kRecvOnly, kActive, &opts); std::unique_ptr offer3( f1_.CreateOfferOrError(opts, offer2.get()).MoveValue()); ASSERT_TRUE(offer3.get()); EXPECT_EQ(offer3->contents().size(), 3u); EXPECT_TRUE(IsMediaContentOfType(&offer3->contents()[0], MediaType::DATA)); EXPECT_TRUE(IsMediaContentOfType(&offer3->contents()[1], MediaType::VIDEO)); EXPECT_TRUE(IsMediaContentOfType(&offer3->contents()[2], MediaType::AUDIO)); } // Create a typical audio answer, and ensure it matches what we expect. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioAnswer) { std::unique_ptr offer = f1_.CreateOfferOrError(CreateAudioMediaSession(), nullptr).MoveValue(); ASSERT_TRUE(offer.get()); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), CreateAudioMediaSession(), nullptr) .MoveValue(); const ContentInfo* ac = answer->GetContentByName(kAudioMid); const ContentInfo* vc = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); EXPECT_FALSE(vc); EXPECT_EQ(ac->type, MediaProtocolType::kRtp); const MediaContentDescription* acd = ac->media_description(); EXPECT_EQ(acd->type(), MediaType::AUDIO); EXPECT_THAT(acd->codecs(), CodecListsMatch(kAudioCodecsAnswer, &env_.field_trials())); EXPECT_EQ(acd->first_ssrc(), 0U); // no sender is attached EXPECT_EQ(acd->bandwidth(), kAutoBandwidth); // negotiated auto bw EXPECT_TRUE(acd->rtcp_mux()); // negotiated rtcp-mux EXPECT_EQ(acd->protocol(), kMediaProtocolDtlsSavpf); } // Create a typical audio answer with GCM ciphers enabled, and ensure it // matches what we expect. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioAnswerGcm) { MediaSessionOptions opts = CreateAudioMediaSession(); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); const ContentInfo* ac = answer->GetContentByName(kAudioMid); const ContentInfo* vc = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); EXPECT_FALSE(vc); EXPECT_EQ(ac->type, MediaProtocolType::kRtp); const MediaContentDescription* acd = ac->media_description(); EXPECT_EQ(acd->type(), MediaType::AUDIO); EXPECT_THAT(acd->codecs(), CodecListsMatch(kAudioCodecsAnswer, &env_.field_trials())); EXPECT_EQ(acd->first_ssrc(), 0U); // no sender is attached EXPECT_EQ(acd->bandwidth(), kAutoBandwidth); // negotiated auto bw EXPECT_TRUE(acd->rtcp_mux()); // negotiated rtcp-mux EXPECT_EQ(acd->protocol(), kMediaProtocolDtlsSavpf); } // Create an audio answer with no common codecs, and ensure it is rejected. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioAnswerWithNoCommonCodecs) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); codec_lookup_helper_1_.SetAudioCodecs( {CreateAudioCodec(96, "opus", 48000, 1)}); codec_lookup_helper_2_.SetAudioCodecs({CreateAudioCodec(0, "PCMU", 8000, 1)}); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); const ContentInfo* ac = answer->GetContentByName(kAudioMid); ASSERT_TRUE(ac); EXPECT_TRUE(ac->rejected); } // Create a typical video answer, and ensure it matches what we expect. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoAnswer) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); const ContentInfo* ac = answer->GetContentByName(kAudioMid); const ContentInfo* vc = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); ASSERT_TRUE(vc); EXPECT_EQ(ac->type, MediaProtocolType::kRtp); EXPECT_EQ(vc->type, MediaProtocolType::kRtp); const MediaContentDescription* acd = ac->media_description(); const MediaContentDescription* vcd = vc->media_description(); EXPECT_EQ(acd->type(), MediaType::AUDIO); EXPECT_THAT(acd->codecs(), CodecListsMatch(kAudioCodecsAnswer, &env_.field_trials())); EXPECT_EQ(acd->bandwidth(), kAutoBandwidth); // negotiated auto bw EXPECT_EQ(acd->first_ssrc(), 0U); // no sender is attached EXPECT_TRUE(acd->rtcp_mux()); // negotiated rtcp-mux EXPECT_EQ(vcd->type(), MediaType::VIDEO); EXPECT_THAT(vcd->codecs(), CodecListsMatch(kVideoCodecsAnswer, &env_.field_trials())); EXPECT_EQ(vcd->first_ssrc(), 0U); // no sender is attached EXPECT_TRUE(vcd->rtcp_mux()); // negotiated rtcp-mux EXPECT_EQ(vcd->protocol(), kMediaProtocolDtlsSavpf); } // Create a video answer with no common codecs, and ensure it is rejected. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoAnswerWithNoCommonCodecs) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); codec_lookup_helper_1_.SetVideoCodecs({CreateVideoCodec(96, "H264")}); codec_lookup_helper_2_.SetVideoCodecs({CreateVideoCodec(97, "VP8")}); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); const ContentInfo* vc = answer->GetContentByName(kVideoMid); ASSERT_TRUE(vc); EXPECT_TRUE(vc->rejected); } // Create a video answer with no common codecs (but a common FEC codec), and // ensure it is rejected. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoAnswerWithOnlyFecCodecsCommon) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); codec_lookup_helper_1_.SetVideoCodecs( {CreateVideoCodec(96, "H264"), CreateVideoCodec(118, "flexfec-03")}); codec_lookup_helper_2_.SetVideoCodecs( {CreateVideoCodec(97, "VP8"), CreateVideoCodec(118, "flexfec-03")}); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); const ContentInfo* vc = answer->GetContentByName(kVideoMid); ASSERT_TRUE(vc); EXPECT_TRUE(vc->rejected); } // The use_sctpmap flag should be set in an Sctp DataContentDescription by // default. The answer's use_sctpmap flag should match the offer's. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateDataAnswerUsesSctpmap) { MediaSessionOptions opts; AddDataSection(RtpTransceiverDirection::kSendRecv, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); ContentInfo* dc_offer = offer->GetContentByName(kDataMid); ASSERT_TRUE(dc_offer); SctpDataContentDescription* dcd_offer = dc_offer->media_description()->as_sctp(); EXPECT_TRUE(dcd_offer->use_sctpmap()); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); const ContentInfo* dc_answer = answer->GetContentByName(kDataMid); ASSERT_TRUE(dc_answer); const SctpDataContentDescription* dcd_answer = dc_answer->media_description()->as_sctp(); EXPECT_TRUE(dcd_answer->use_sctpmap()); } // The answer's use_sctpmap flag should match the offer's. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateDataAnswerWithoutSctpmap) { MediaSessionOptions opts; AddDataSection(RtpTransceiverDirection::kSendRecv, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); ContentInfo* dc_offer = offer->GetContentByName(kDataMid); ASSERT_TRUE(dc_offer); SctpDataContentDescription* dcd_offer = dc_offer->media_description()->as_sctp(); dcd_offer->set_use_sctpmap(false); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); const ContentInfo* dc_answer = answer->GetContentByName(kDataMid); ASSERT_TRUE(dc_answer); const SctpDataContentDescription* dcd_answer = dc_answer->media_description()->as_sctp(); EXPECT_FALSE(dcd_answer->use_sctpmap()); } // Test that a valid answer will be created for "DTLS/SCTP", "UDP/DTLS/SCTP" // and "TCP/DTLS/SCTP" offers. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateDataAnswerToDifferentOfferedProtos) { MediaSessionOptions opts; AddDataSection(RtpTransceiverDirection::kSendRecv, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); ContentInfo* dc_offer = offer->GetContentByName(kDataMid); ASSERT_TRUE(dc_offer); SctpDataContentDescription* dcd_offer = dc_offer->media_description()->as_sctp(); ASSERT_TRUE(dcd_offer); std::vector protos = {"DTLS/SCTP", "UDP/DTLS/SCTP", "TCP/DTLS/SCTP"}; for (const std::string& proto : protos) { dcd_offer->set_protocol(proto); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); const ContentInfo* dc_answer = answer->GetContentByName(kDataMid); ASSERT_TRUE(dc_answer); const SctpDataContentDescription* dcd_answer = dc_answer->media_description()->as_sctp(); EXPECT_FALSE(dc_answer->rejected); EXPECT_EQ(proto, dcd_answer->protocol()); } } TEST_F(MediaSessionDescriptionFactoryTest, TestCreateDataAnswerToOfferWithDefinedMessageSize) { MediaSessionOptions opts; AddDataSection(RtpTransceiverDirection::kSendRecv, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); ContentInfo* dc_offer = offer->GetContentByName(kDataMid); ASSERT_TRUE(dc_offer); SctpDataContentDescription* dcd_offer = dc_offer->media_description()->as_sctp(); ASSERT_TRUE(dcd_offer); dcd_offer->set_max_message_size(1234); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); const ContentInfo* dc_answer = answer->GetContentByName(kDataMid); ASSERT_TRUE(dc_answer); const SctpDataContentDescription* dcd_answer = dc_answer->media_description()->as_sctp(); EXPECT_FALSE(dc_answer->rejected); EXPECT_EQ(dcd_answer->max_message_size(), 1234); } TEST_F(MediaSessionDescriptionFactoryTest, TestCreateDataAnswerToOfferWithZeroMessageSize) { MediaSessionOptions opts; AddDataSection(RtpTransceiverDirection::kSendRecv, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); ContentInfo* dc_offer = offer->GetContentByName(kDataMid); ASSERT_TRUE(dc_offer); SctpDataContentDescription* dcd_offer = dc_offer->media_description()->as_sctp(); ASSERT_TRUE(dcd_offer); dcd_offer->set_max_message_size(0); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); const ContentInfo* dc_answer = answer->GetContentByName(kDataMid); ASSERT_TRUE(dc_answer); const SctpDataContentDescription* dcd_answer = dc_answer->media_description()->as_sctp(); EXPECT_FALSE(dc_answer->rejected); EXPECT_EQ(dcd_answer->max_message_size(), kSctpSendBufferSize); } class MediaSessionDescriptionFactorySnapTest : public MediaSessionDescriptionFactoryTest { public: MediaSessionDescriptionFactorySnapTest() : MediaSessionDescriptionFactoryTest("WebRTC-Sctp-Snap/Enabled/") {} }; TEST_F(MediaSessionDescriptionFactorySnapTest, TestCreateDataAnswerToOfferWithSctpInit) { MediaSessionOptions opts; opts.use_sctp_snap = true; AddDataSection(RtpTransceiverDirection::kSendRecv, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); ContentInfo* dc_offer = offer->GetContentByName("2"); ASSERT_THAT(dc_offer, NotNull()); SctpDataContentDescription* dcd_offer = dc_offer->media_description()->as_sctp(); ASSERT_THAT(dcd_offer, NotNull()); EXPECT_NE(dcd_offer->sctp_init(), std::nullopt); dcd_offer->set_sctp_init(std::nullopt); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); const ContentInfo* dc_answer = answer->GetContentByName("2"); ASSERT_THAT(dc_answer, NotNull()); const SctpDataContentDescription* dcd_answer = dc_answer->media_description()->as_sctp(); ASSERT_THAT(dcd_answer, NotNull()); EXPECT_FALSE(dc_answer->rejected); EXPECT_EQ(dcd_answer->sctp_init(), std::nullopt); } TEST_F(MediaSessionDescriptionFactorySnapTest, TestCreateOfferAfterAnswerWithoutSctpInit) { MediaSessionOptions opts; opts.use_sctp_snap = true; AddDataSection(RtpTransceiverDirection::kSendRecv, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); ContentInfo* dc_offer = offer->GetContentByName("2"); ASSERT_THAT(dc_offer, NotNull()); SctpDataContentDescription* dcd_offer = dc_offer->media_description()->as_sctp(); ASSERT_THAT(dcd_offer, NotNull()); EXPECT_NE(dcd_offer->sctp_init(), std::nullopt); dcd_offer->set_sctp_init(std::nullopt); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); const ContentInfo* dc_answer = answer->GetContentByName("2"); ASSERT_THAT(dc_answer, NotNull()); const SctpDataContentDescription* dcd_answer = dc_answer->media_description()->as_sctp(); ASSERT_THAT(dcd_answer, NotNull()); EXPECT_FALSE(dc_answer->rejected); EXPECT_EQ(dcd_answer->sctp_init(), std::nullopt); std::unique_ptr reoffer = f2_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(reoffer, NotNull()); ContentInfo* dc_reoffer = reoffer->GetContentByName("2"); ASSERT_THAT(dc_reoffer, NotNull()); SctpDataContentDescription* dcd_reoffer = dc_reoffer->media_description()->as_sctp(); ASSERT_THAT(dcd_reoffer, NotNull()); EXPECT_FALSE(dc_reoffer->rejected); EXPECT_NE(dcd_reoffer->sctp_init(), std::nullopt); } // TODO: bugs.webrtc.org/426480601 - add more SNAP tests here: // - two calls to createOffer without SLD get different cookie // - subsequent createOffer after SLD retains old cookie // - subsequent createOffer after offer without cookie has new cookie // (or stale cookie?) // Verifies that the order of the media contents in the offer is preserved in // the answer. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAnswerContentOrder) { MediaSessionOptions opts; // Creates a data only offer. AddDataSection(RtpTransceiverDirection::kSendRecv, &opts); std::unique_ptr offer1( f1_.CreateOfferOrError(opts, nullptr).MoveValue()); ASSERT_TRUE(offer1.get()); // Appends audio to the offer. AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kRecvOnly, kActive, &opts); std::unique_ptr offer2( f1_.CreateOfferOrError(opts, offer1.get()).MoveValue()); ASSERT_TRUE(offer2.get()); // Appends video to the offer. AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &opts); std::unique_ptr offer3( f1_.CreateOfferOrError(opts, offer2.get()).MoveValue()); ASSERT_TRUE(offer3.get()); std::unique_ptr answer = f2_.CreateAnswerOrError(offer3.get(), opts, nullptr).MoveValue(); ASSERT_TRUE(answer.get()); EXPECT_EQ(answer->contents().size(), 3u); EXPECT_TRUE(IsMediaContentOfType(&answer->contents()[0], MediaType::DATA)); EXPECT_TRUE(IsMediaContentOfType(&answer->contents()[1], MediaType::AUDIO)); EXPECT_TRUE(IsMediaContentOfType(&answer->contents()[2], MediaType::VIDEO)); } // TODO(deadbeef): Extend these tests to ensure the correct direction with other // answerer settings. // This test that the media direction is set to send/receive in an answer if // the offer is send receive. TEST_F(MediaSessionDescriptionFactoryTest, CreateAnswerToSendReceiveOffer) { TestMediaDirectionInAnswer(RtpTransceiverDirection::kSendRecv, RtpTransceiverDirection::kSendRecv); } // This test that the media direction is set to receive only in an answer if // the offer is send only. TEST_F(MediaSessionDescriptionFactoryTest, CreateAnswerToSendOnlyOffer) { TestMediaDirectionInAnswer(RtpTransceiverDirection::kSendOnly, RtpTransceiverDirection::kRecvOnly); } // This test that the media direction is set to send only in an answer if // the offer is recv only. TEST_F(MediaSessionDescriptionFactoryTest, CreateAnswerToRecvOnlyOffer) { TestMediaDirectionInAnswer(RtpTransceiverDirection::kRecvOnly, RtpTransceiverDirection::kSendOnly); } // This test that the media direction is set to inactive in an answer if // the offer is inactive. TEST_F(MediaSessionDescriptionFactoryTest, CreateAnswerToInactiveOffer) { TestMediaDirectionInAnswer(RtpTransceiverDirection::kInactive, RtpTransceiverDirection::kInactive); } // Test that the media protocol is RTP/AVPF if DTLS is disabled. TEST_F(MediaSessionDescriptionFactoryTest, AudioOfferAnswerWithCryptoDisabled) { MediaSessionOptions opts = CreateAudioMediaSession(); tdf1_.SetInsecureForTesting(); tdf1_.set_certificate(nullptr); tdf2_.SetInsecureForTesting(); tdf2_.set_certificate(nullptr); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); const AudioContentDescription* offer_acd = GetFirstAudioContentDescription(offer.get()); ASSERT_TRUE(offer_acd); EXPECT_EQ(offer_acd->protocol(), kMediaProtocolAvpf); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); const ContentInfo* ac_answer = answer->GetContentByName(kAudioMid); ASSERT_TRUE(ac_answer); EXPECT_FALSE(ac_answer->rejected); const AudioContentDescription* answer_acd = GetFirstAudioContentDescription(answer.get()); ASSERT_TRUE(answer_acd); EXPECT_EQ(answer_acd->protocol(), kMediaProtocolAvpf); } // Create a audio/video offer and answer and ensure that the // TransportSequenceNumber RTP v1 and v2 header extensions are handled // correctly. TEST_F(MediaSessionDescriptionFactoryTest, TestOfferAnswerWithTransportSequenceNumberV1LocalAndV1InOffer) { TestTransportSequenceNumberNegotiation( kRtpExtensionTransportSequenceNumber01, // Local. kRtpExtensionTransportSequenceNumber01, // Offer. kRtpExtensionTransportSequenceNumber01); // Expected answer. } TEST_F(MediaSessionDescriptionFactoryTest, TestOfferAnswerWithTransportSequenceNumberV1LocalAndV1V2InOffer) { TestTransportSequenceNumberNegotiation( kRtpExtensionTransportSequenceNumber01, // Local. kRtpExtensionTransportSequenceNumber01And02, // Offer. kRtpExtensionTransportSequenceNumber01); // Expected answer. } TEST_F(MediaSessionDescriptionFactoryTest, TestOfferAnswerWithTransportSequenceNumberV1LocalAndV2InOffer) { TestTransportSequenceNumberNegotiation( kRtpExtensionTransportSequenceNumber01, // Local. kRtpExtensionTransportSequenceNumber02, // Offer. {}); // Expected answer. } TEST_F(MediaSessionDescriptionFactoryTest, TestOfferAnswerWithTransportSequenceNumberV2LocalAndV1InOffer) { TestTransportSequenceNumberNegotiation( kRtpExtensionTransportSequenceNumber02, // Local. kRtpExtensionTransportSequenceNumber01, // Offer. {}); // Expected answer. } TEST_F(MediaSessionDescriptionFactoryTest, TestOfferAnswerWithTransportSequenceNumberV2LocalAndV1V2InOffer) { TestTransportSequenceNumberNegotiation( kRtpExtensionTransportSequenceNumber02, // Local. kRtpExtensionTransportSequenceNumber01And02, // Offer. kRtpExtensionTransportSequenceNumber02); // Expected answer. } TEST_F(MediaSessionDescriptionFactoryTest, TestOfferAnswerWithTransportSequenceNumberV2LocalAndV2InOffer) { TestTransportSequenceNumberNegotiation( kRtpExtensionTransportSequenceNumber02, // Local. kRtpExtensionTransportSequenceNumber02, // Offer. kRtpExtensionTransportSequenceNumber02); // Expected answer. } TEST_F(MediaSessionDescriptionFactoryTest, TestOfferAnswerWithTransportSequenceNumberV1V2LocalAndV1InOffer) { TestTransportSequenceNumberNegotiation( kRtpExtensionTransportSequenceNumber01And02, // Local. kRtpExtensionTransportSequenceNumber01, // Offer. kRtpExtensionTransportSequenceNumber01); // Expected answer. } TEST_F(MediaSessionDescriptionFactoryTest, TestOfferAnswerWithTransportSequenceNumberV1V2LocalAndV2InOffer) { TestTransportSequenceNumberNegotiation( kRtpExtensionTransportSequenceNumber01And02, // Local. kRtpExtensionTransportSequenceNumber02, // Offer. kRtpExtensionTransportSequenceNumber02); // Expected answer. } TEST_F(MediaSessionDescriptionFactoryTest, TestOfferAnswerWithTransportSequenceNumberV1V2LocalAndV1V2InOffer) { TestTransportSequenceNumberNegotiation( kRtpExtensionTransportSequenceNumber01And02, // Local. kRtpExtensionTransportSequenceNumber01And02, // Offer. kRtpExtensionTransportSequenceNumber01And02); // Expected answer. } TEST_F(MediaSessionDescriptionFactoryTest, TestNegotiateFrameDescriptorWhenUnexposedLocally) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); SetAudioVideoRtpHeaderExtensions(kRtpExtensionGenericFrameDescriptorUri00, kRtpExtensionGenericFrameDescriptorUri00, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); SetAudioVideoRtpHeaderExtensions(kRtpExtensionTransportSequenceNumber01, kRtpExtensionTransportSequenceNumber01, &opts); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); EXPECT_THAT( GetFirstAudioContentDescription(answer.get())->rtp_header_extensions(), ElementsAreArray(kRtpExtensionGenericFrameDescriptorUri00)); EXPECT_THAT( GetFirstVideoContentDescription(answer.get())->rtp_header_extensions(), ElementsAreArray(kRtpExtensionGenericFrameDescriptorUri00)); } TEST_F(MediaSessionDescriptionFactoryTest, TestNegotiateFrameDescriptorWhenExposedLocally) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); SetAudioVideoRtpHeaderExtensions(kRtpExtensionGenericFrameDescriptorUri00, kRtpExtensionGenericFrameDescriptorUri00, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); EXPECT_THAT( GetFirstAudioContentDescription(answer.get())->rtp_header_extensions(), ElementsAreArray(kRtpExtensionGenericFrameDescriptorUri00)); EXPECT_THAT( GetFirstVideoContentDescription(answer.get())->rtp_header_extensions(), ElementsAreArray(kRtpExtensionGenericFrameDescriptorUri00)); } TEST_F(MediaSessionDescriptionFactoryTest, NegotiateDependencyDescriptorWhenUnexposedLocally) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); RtpExtension offer_dd(RtpExtension::kDependencyDescriptorUri, 7); SetAudioVideoRtpHeaderExtensions({}, RtpHeaderExtensions{offer_dd}, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); RtpExtension local_tsn(RtpExtension::kTransportSequenceNumberUri, 5); SetAudioVideoRtpHeaderExtensions({}, RtpHeaderExtensions{local_tsn}, &opts); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); EXPECT_THAT( GetFirstVideoContentDescription(answer.get())->rtp_header_extensions(), ElementsAre(offer_dd)); } TEST_F(MediaSessionDescriptionFactoryTest, NegotiateDependencyDescriptorWhenExposedLocally) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); RtpExtension offer_dd(RtpExtension::kDependencyDescriptorUri, 7); RtpExtension local_dd(RtpExtension::kDependencyDescriptorUri, 5); SetAudioVideoRtpHeaderExtensions({}, RtpHeaderExtensions{offer_dd}, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); SetAudioVideoRtpHeaderExtensions({}, RtpHeaderExtensions{local_dd}, &opts); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); EXPECT_THAT( GetFirstVideoContentDescription(answer.get())->rtp_header_extensions(), ElementsAre(offer_dd)); } TEST_F(MediaSessionDescriptionFactoryTest, NegotiateAbsoluteCaptureTimeWhenUnexposedLocally) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); const RtpHeaderExtensions offered_extensions = { RtpExtension(RtpExtension::kAbsoluteCaptureTimeUri, 7)}; const RtpHeaderExtensions local_extensions = { RtpExtension(RtpExtension::kTransportSequenceNumberUri, 5)}; SetAudioVideoRtpHeaderExtensions(offered_extensions, offered_extensions, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); SetAudioVideoRtpHeaderExtensions(local_extensions, local_extensions, &opts); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); EXPECT_THAT( GetFirstVideoContentDescription(answer.get())->rtp_header_extensions(), ElementsAreArray(offered_extensions)); EXPECT_THAT( GetFirstAudioContentDescription(answer.get())->rtp_header_extensions(), ElementsAreArray(offered_extensions)); } TEST_F(MediaSessionDescriptionFactoryTest, NegotiateAbsoluteCaptureTimeWhenExposedLocally) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); const RtpHeaderExtensions offered_extensions = { RtpExtension(RtpExtension::kAbsoluteCaptureTimeUri, 7)}; const RtpHeaderExtensions local_extensions = { RtpExtension(RtpExtension::kAbsoluteCaptureTimeUri, 5)}; SetAudioVideoRtpHeaderExtensions(offered_extensions, offered_extensions, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); SetAudioVideoRtpHeaderExtensions(local_extensions, local_extensions, &opts); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); EXPECT_THAT( GetFirstVideoContentDescription(answer.get())->rtp_header_extensions(), ElementsAreArray(offered_extensions)); EXPECT_THAT( GetFirstAudioContentDescription(answer.get())->rtp_header_extensions(), ElementsAreArray(offered_extensions)); } TEST_F(MediaSessionDescriptionFactoryTest, DoNotNegotiateAbsoluteCaptureTimeWhenNotOffered) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); const RtpHeaderExtensions offered_extensions = { RtpExtension(RtpExtension::kTransportSequenceNumberUri, 7)}; const RtpHeaderExtensions local_extensions = { RtpExtension(RtpExtension::kAbsoluteCaptureTimeUri, 5)}; SetAudioVideoRtpHeaderExtensions(offered_extensions, offered_extensions, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); SetAudioVideoRtpHeaderExtensions(local_extensions, local_extensions, &opts); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); EXPECT_THAT( GetFirstVideoContentDescription(answer.get())->rtp_header_extensions(), IsEmpty()); EXPECT_THAT( GetFirstAudioContentDescription(answer.get())->rtp_header_extensions(), IsEmpty()); } TEST_F(MediaSessionDescriptionFactoryTest, OffersUnstoppedExtensionsWithAudioVideoExtensionStopped) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); opts.media_description_options.back().header_extensions = { RtpHeaderExtensionCapability("uri1", 1, RtpTransceiverDirection::kStopped), RtpHeaderExtensionCapability("uri2", 3, RtpTransceiverDirection::kSendOnly)}; AddMediaDescriptionOptions(MediaType::VIDEO, "video1", RtpTransceiverDirection::kSendRecv, kActive, &opts); opts.media_description_options.back().header_extensions = { RtpHeaderExtensionCapability("uri1", 1, RtpTransceiverDirection::kStopped), RtpHeaderExtensionCapability("uri3", 7, RtpTransceiverDirection::kSendOnly)}; std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); EXPECT_THAT( offer->contents(), ElementsAre( Property(&ContentInfo::media_description, Pointee(Property( &MediaContentDescription::rtp_header_extensions, ElementsAre(Field(&RtpExtension::uri, "uri2"))))), Property(&ContentInfo::media_description, Pointee(Property( &MediaContentDescription::rtp_header_extensions, ElementsAre(Field(&RtpExtension::uri, "uri3"))))))); } TEST_F(MediaSessionDescriptionFactoryTest, OffersUnstoppedExtensionsWithAudioExtensionStopped) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); opts.media_description_options.back().header_extensions = { RtpHeaderExtensionCapability("uri1", 1, RtpTransceiverDirection::kSendOnly), RtpHeaderExtensionCapability("uri2", 3, RtpTransceiverDirection::kStopped)}; AddMediaDescriptionOptions(MediaType::VIDEO, "video1", RtpTransceiverDirection::kSendRecv, kActive, &opts); opts.media_description_options.back().header_extensions = { RtpHeaderExtensionCapability("uri42", 42, RtpTransceiverDirection::kSendRecv), RtpHeaderExtensionCapability("uri3", 7, RtpTransceiverDirection::kSendOnly)}; std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); EXPECT_THAT( offer->contents(), ElementsAre( Property(&ContentInfo::media_description, Pointee(Property( &MediaContentDescription::rtp_header_extensions, ElementsAre(Field(&RtpExtension::uri, "uri1"))))), Property( &ContentInfo::media_description, Pointee(Property( &MediaContentDescription::rtp_header_extensions, UnorderedElementsAre(Field(&RtpExtension::uri, "uri3"), Field(&RtpExtension::uri, "uri42"))))))); } TEST_F(MediaSessionDescriptionFactoryTest, OffersUnstoppedExtensionsWithVideoExtensionStopped) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); opts.media_description_options.back().header_extensions = { RtpHeaderExtensionCapability("uri1", 5, RtpTransceiverDirection::kSendOnly), RtpHeaderExtensionCapability("uri2", 7, RtpTransceiverDirection::kSendRecv)}; AddMediaDescriptionOptions(MediaType::VIDEO, "video1", RtpTransceiverDirection::kSendRecv, kActive, &opts); opts.media_description_options.back().header_extensions = { RtpHeaderExtensionCapability("uri42", 42, RtpTransceiverDirection::kSendRecv), RtpHeaderExtensionCapability("uri3", 7, RtpTransceiverDirection::kStopped)}; std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); EXPECT_THAT( offer->contents(), ElementsAre( Property( &ContentInfo::media_description, Pointee(Property( &MediaContentDescription::rtp_header_extensions, UnorderedElementsAre(Field(&RtpExtension::uri, "uri1"), Field(&RtpExtension::uri, "uri2"))))), Property(&ContentInfo::media_description, Pointee(Property( &MediaContentDescription::rtp_header_extensions, ElementsAre(Field(&RtpExtension::uri, "uri42"))))))); } TEST_F(MediaSessionDescriptionFactoryTest, AnswersUnstoppedExtensions) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); opts.media_description_options.back().header_extensions = { RtpHeaderExtensionCapability("uri1", 4, RtpTransceiverDirection::kStopped), RtpHeaderExtensionCapability("uri2", 3, RtpTransceiverDirection::kSendOnly), RtpHeaderExtensionCapability("uri3", 2, RtpTransceiverDirection::kRecvOnly), RtpHeaderExtensionCapability("uri4", 1, RtpTransceiverDirection::kSendRecv)}; std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); opts.media_description_options.back().header_extensions = { RtpHeaderExtensionCapability("uri1", 4, RtpTransceiverDirection::kSendOnly), RtpHeaderExtensionCapability("uri2", 3, RtpTransceiverDirection::kRecvOnly), RtpHeaderExtensionCapability("uri3", 2, RtpTransceiverDirection::kStopped), RtpHeaderExtensionCapability("uri4", 1, RtpTransceiverDirection::kSendRecv)}; std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); EXPECT_THAT( answer->contents(), ElementsAre(Property( &ContentInfo::media_description, Pointee(Property(&MediaContentDescription::rtp_header_extensions, ElementsAre(Field(&RtpExtension::uri, "uri2"), Field(&RtpExtension::uri, "uri4"))))))); } TEST_F(MediaSessionDescriptionFactoryTest, AppendsUnstoppedExtensionsToCurrentDescription) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); opts.media_description_options.back().header_extensions = { RtpHeaderExtensionCapability("uri1", 1, RtpTransceiverDirection::kSendRecv)}; std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); opts.media_description_options.back().header_extensions = { RtpHeaderExtensionCapability("uri1", 2, RtpTransceiverDirection::kSendRecv), RtpHeaderExtensionCapability("uri2", 3, RtpTransceiverDirection::kRecvOnly), RtpHeaderExtensionCapability("uri3", 5, RtpTransceiverDirection::kStopped), RtpHeaderExtensionCapability("uri4", 6, RtpTransceiverDirection::kSendRecv)}; auto offer2 = f1_.CreateOfferOrError(opts, offer.get()).MoveValue(); EXPECT_THAT( offer2->contents(), ElementsAre(Property( &ContentInfo::media_description, Pointee(Property(&MediaContentDescription::rtp_header_extensions, ElementsAre(Field(&RtpExtension::uri, "uri1"), Field(&RtpExtension::uri, "uri2"), Field(&RtpExtension::uri, "uri4"))))))); } TEST_F(MediaSessionDescriptionFactoryTest, AllowsStoppedExtensionsToBeRemovedFromSubsequentOffer) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); opts.media_description_options.back().header_extensions = { RtpHeaderExtensionCapability("uri1", 1, RtpTransceiverDirection::kSendRecv), RtpHeaderExtensionCapability("uri2", 2, RtpTransceiverDirection::kSendRecv)}; std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); // Check that a subsequent offer after setting "uri2" to stopped no longer // contains the extension. opts.media_description_options.back().header_extensions = { RtpHeaderExtensionCapability("uri1", 1, RtpTransceiverDirection::kSendRecv), RtpHeaderExtensionCapability("uri2", 2, RtpTransceiverDirection::kStopped)}; auto offer2 = f1_.CreateOfferOrError(opts, offer.get()).MoveValue(); EXPECT_THAT( offer2->contents(), ElementsAre(Property( &ContentInfo::media_description, Pointee(Property(&MediaContentDescription::rtp_header_extensions, ElementsAre(Field(&RtpExtension::uri, "uri1"))))))); } // Create a video offer and answer and ensure the RTP header extensions // matches what we expect. TEST_F(MediaSessionDescriptionFactoryTest, TestOfferAnswerWithRtpExtensionHeadersWithNoEncryption) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); SetAudioVideoRtpHeaderExtensions(kAudioRtpExtension1, kVideoRtpExtension1, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); SetAudioVideoRtpHeaderExtensions(kAudioRtpExtension2, kVideoRtpExtension2, &opts); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); EXPECT_THAT( GetFirstAudioContentDescription(offer.get())->rtp_header_extensions(), UnorderedElementsAreArray(kAudioRtpExtension1)); EXPECT_THAT( GetFirstVideoContentDescription(offer.get())->rtp_header_extensions(), UnorderedElementsAreArray(kVideoRtpExtension1)); EXPECT_THAT( GetFirstAudioContentDescription(answer.get())->rtp_header_extensions(), UnorderedElementsAreArray(kAudioRtpExtensionAnswer)); EXPECT_THAT( GetFirstVideoContentDescription(answer.get())->rtp_header_extensions(), UnorderedElementsAreArray(kVideoRtpExtensionAnswer)); } TEST_F(MediaSessionDescriptionFactoryTest, TestOfferAnswerWithRtpExtensionHeadersWithEncryption) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); f1_.set_enable_encrypted_rtp_header_extensions(true); f2_.set_enable_encrypted_rtp_header_extensions(true); SetAudioVideoRtpHeaderExtensions(kAudioRtpExtensionEncrypted1, kVideoRtpExtensionEncrypted1, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); SetAudioVideoRtpHeaderExtensions(kAudioRtpExtensionEncrypted2, kVideoRtpExtensionEncrypted2, &opts); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); EXPECT_THAT( GetFirstAudioContentDescription(offer.get())->rtp_header_extensions(), UnorderedElementsAreArray(kAudioRtpExtensionEncrypted1)); EXPECT_THAT( GetFirstVideoContentDescription(offer.get())->rtp_header_extensions(), UnorderedElementsAreArray(kVideoRtpExtensionEncrypted1)); EXPECT_THAT( GetFirstAudioContentDescription(answer.get())->rtp_header_extensions(), UnorderedElementsAreArray(kAudioRtpExtensionEncryptedAnswer)); EXPECT_THAT( GetFirstVideoContentDescription(answer.get())->rtp_header_extensions(), UnorderedElementsAreArray(kVideoRtpExtensionEncryptedAnswer)); } TEST_F(MediaSessionDescriptionFactoryTest, NegotiationWithEncryptedRtpExtensionHeadersDisabledInReceiver) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); f2_.set_enable_encrypted_rtp_header_extensions(false); SetAudioVideoRtpHeaderExtensions(kAudioRtpExtensionEncrypted1, kVideoRtpExtensionEncrypted1, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); SetAudioVideoRtpHeaderExtensions(kAudioRtpExtensionEncrypted2, kVideoRtpExtensionEncrypted2, &opts); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); EXPECT_THAT( GetFirstAudioContentDescription(offer.get())->rtp_header_extensions(), UnorderedElementsAreArray(kAudioRtpExtensionEncrypted1)); EXPECT_THAT( GetFirstVideoContentDescription(offer.get())->rtp_header_extensions(), UnorderedElementsAreArray(kVideoRtpExtensionEncrypted1)); EXPECT_THAT( GetFirstAudioContentDescription(answer.get())->rtp_header_extensions(), UnorderedElementsAreArray(kAudioRtpExtensionAnswer)); EXPECT_THAT( GetFirstVideoContentDescription(answer.get())->rtp_header_extensions(), UnorderedElementsAreArray(kVideoRtpExtensionAnswer)); } TEST_F(MediaSessionDescriptionFactoryTest, NegotiationWithEncryptedRtpExtensionHeadersDisabledInSender) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); f1_.set_enable_encrypted_rtp_header_extensions(false); SetAudioVideoRtpHeaderExtensions(kAudioRtpExtensionEncrypted1, kVideoRtpExtensionEncrypted1, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); SetAudioVideoRtpHeaderExtensions(kAudioRtpExtensionEncrypted2, kVideoRtpExtensionEncrypted2, &opts); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); EXPECT_THAT( GetFirstAudioContentDescription(offer.get())->rtp_header_extensions(), UnorderedElementsAreArray(kAudioRtpExtensionAnswer)); EXPECT_THAT( GetFirstVideoContentDescription(offer.get())->rtp_header_extensions(), UnorderedElementsAreArray(kVideoRtpExtensionAnswer)); EXPECT_THAT( GetFirstAudioContentDescription(answer.get())->rtp_header_extensions(), UnorderedElementsAreArray(kAudioRtpExtensionAnswer)); EXPECT_THAT( GetFirstVideoContentDescription(answer.get())->rtp_header_extensions(), UnorderedElementsAreArray(kVideoRtpExtensionAnswer)); } TEST_F(MediaSessionDescriptionFactoryTest, PreferEncryptedRtpHeaderExtensionsWhenEncryptionEnabled) { MediaSessionOptions opts; opts.offer_extmap_allow_mixed = true; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); SetAudioVideoRtpHeaderExtensions(kAudioRtpExtensionMixedEncryption1, kVideoRtpExtensionMixedEncryption, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); SetAudioVideoRtpHeaderExtensions(kAudioRtpExtensionMixedEncryption2, kVideoRtpExtensionMixedEncryption, &opts); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); ASSERT_TRUE(answer.get()); EXPECT_THAT( GetFirstAudioContentDescription(offer.get())->rtp_header_extensions(), UnorderedElementsAreArray(kAudioRtpExtensionMixedEncryption1)); EXPECT_THAT( GetFirstVideoContentDescription(offer.get())->rtp_header_extensions(), UnorderedElementsAreArray(kVideoRtpExtensionMixedEncryption)); EXPECT_THAT( GetFirstAudioContentDescription(answer.get())->rtp_header_extensions(), UnorderedElementsAreArray( kAudioRtpExtensionMixedEncryptionAnswerEncryptionEnabled)); EXPECT_THAT( GetFirstVideoContentDescription(answer.get())->rtp_header_extensions(), UnorderedElementsAreArray( kVideoRtpExtensionMixedEncryptionAnswerEncryptionEnabled)); } TEST_F(MediaSessionDescriptionFactoryTest, UseUnencryptedRtpHeaderExtensionsWhenEncryptionDisabled) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); f1_.set_enable_encrypted_rtp_header_extensions(false); f2_.set_enable_encrypted_rtp_header_extensions(false); SetAudioVideoRtpHeaderExtensions(kAudioRtpExtensionMixedEncryption1, kVideoRtpExtensionMixedEncryption, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); SetAudioVideoRtpHeaderExtensions(kAudioRtpExtensionMixedEncryption2, kVideoRtpExtensionMixedEncryption, &opts); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); ASSERT_TRUE(answer.get()); EXPECT_THAT( GetFirstAudioContentDescription(offer.get())->rtp_header_extensions(), UnorderedElementsAreArray( kAudioRtpExtensionMixedEncryptionAnswerEncryptionDisabled)); EXPECT_THAT( GetFirstVideoContentDescription(offer.get())->rtp_header_extensions(), UnorderedElementsAreArray( kVideoRtpExtensionMixedEncryptionAnswerEncryptionDisabled)); EXPECT_THAT( GetFirstAudioContentDescription(answer.get())->rtp_header_extensions(), UnorderedElementsAreArray( kAudioRtpExtensionMixedEncryptionAnswerEncryptionDisabled)); EXPECT_THAT( GetFirstVideoContentDescription(answer.get())->rtp_header_extensions(), UnorderedElementsAreArray( kVideoRtpExtensionMixedEncryptionAnswerEncryptionDisabled)); } // Create an audio, video, data answer without legacy StreamParams. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAnswerWithoutLegacyStreams) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); const ContentInfo* ac = answer->GetContentByName(kAudioMid); const ContentInfo* vc = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); ASSERT_TRUE(vc); const MediaContentDescription* acd = ac->media_description(); const MediaContentDescription* vcd = vc->media_description(); EXPECT_FALSE(acd->has_ssrcs()); // No StreamParams. EXPECT_FALSE(vcd->has_ssrcs()); // No StreamParams. } // Create a typical video answer, and ensure it matches what we expect. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoAnswerRtcpMux) { MediaSessionOptions offer_opts; AddAudioVideoSections(RtpTransceiverDirection::kSendRecv, &offer_opts); MediaSessionOptions answer_opts; AddAudioVideoSections(RtpTransceiverDirection::kSendRecv, &answer_opts); std::unique_ptr offer; std::unique_ptr answer; offer_opts.rtcp_mux_enabled = true; answer_opts.rtcp_mux_enabled = true; offer = f1_.CreateOfferOrError(offer_opts, nullptr).MoveValue(); answer = f2_.CreateAnswerOrError(offer.get(), answer_opts, nullptr).MoveValue(); ASSERT_TRUE(GetFirstAudioContentDescription(offer.get())); ASSERT_TRUE(GetFirstVideoContentDescription(offer.get())); ASSERT_TRUE(GetFirstAudioContentDescription(answer.get())); ASSERT_TRUE(GetFirstVideoContentDescription(answer.get())); EXPECT_TRUE(GetFirstAudioContentDescription(offer.get())->rtcp_mux()); EXPECT_TRUE(GetFirstVideoContentDescription(offer.get())->rtcp_mux()); EXPECT_TRUE(GetFirstAudioContentDescription(answer.get())->rtcp_mux()); EXPECT_TRUE(GetFirstVideoContentDescription(answer.get())->rtcp_mux()); offer_opts.rtcp_mux_enabled = true; answer_opts.rtcp_mux_enabled = false; offer = f1_.CreateOfferOrError(offer_opts, nullptr).MoveValue(); answer = f2_.CreateAnswerOrError(offer.get(), answer_opts, nullptr).MoveValue(); ASSERT_TRUE(GetFirstAudioContentDescription(offer.get())); ASSERT_TRUE(GetFirstVideoContentDescription(offer.get())); ASSERT_TRUE(GetFirstAudioContentDescription(answer.get())); ASSERT_TRUE(GetFirstVideoContentDescription(answer.get())); EXPECT_TRUE(GetFirstAudioContentDescription(offer.get())->rtcp_mux()); EXPECT_TRUE(GetFirstVideoContentDescription(offer.get())->rtcp_mux()); EXPECT_FALSE(GetFirstAudioContentDescription(answer.get())->rtcp_mux()); EXPECT_FALSE(GetFirstVideoContentDescription(answer.get())->rtcp_mux()); offer_opts.rtcp_mux_enabled = false; answer_opts.rtcp_mux_enabled = true; offer = f1_.CreateOfferOrError(offer_opts, nullptr).MoveValue(); answer = f2_.CreateAnswerOrError(offer.get(), answer_opts, nullptr).MoveValue(); ASSERT_TRUE(GetFirstAudioContentDescription(offer.get())); ASSERT_TRUE(GetFirstVideoContentDescription(offer.get())); ASSERT_TRUE(GetFirstAudioContentDescription(answer.get())); ASSERT_TRUE(GetFirstVideoContentDescription(answer.get())); EXPECT_FALSE(GetFirstAudioContentDescription(offer.get())->rtcp_mux()); EXPECT_FALSE(GetFirstVideoContentDescription(offer.get())->rtcp_mux()); EXPECT_FALSE(GetFirstAudioContentDescription(answer.get())->rtcp_mux()); EXPECT_FALSE(GetFirstVideoContentDescription(answer.get())->rtcp_mux()); offer_opts.rtcp_mux_enabled = false; answer_opts.rtcp_mux_enabled = false; offer = f1_.CreateOfferOrError(offer_opts, nullptr).MoveValue(); answer = f2_.CreateAnswerOrError(offer.get(), answer_opts, nullptr).MoveValue(); ASSERT_TRUE(GetFirstAudioContentDescription(offer.get())); ASSERT_TRUE(GetFirstVideoContentDescription(offer.get())); ASSERT_TRUE(GetFirstAudioContentDescription(answer.get())); ASSERT_TRUE(GetFirstVideoContentDescription(answer.get())); EXPECT_FALSE(GetFirstAudioContentDescription(offer.get())->rtcp_mux()); EXPECT_FALSE(GetFirstVideoContentDescription(offer.get())->rtcp_mux()); EXPECT_FALSE(GetFirstAudioContentDescription(answer.get())->rtcp_mux()); EXPECT_FALSE(GetFirstVideoContentDescription(answer.get())->rtcp_mux()); } // Create an audio-only answer to a video offer. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateAudioAnswerToVideo) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kRecvOnly, kActive, &opts); AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); opts.media_description_options[1].stopped = true; std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); const ContentInfo* ac = answer->GetContentByName(kAudioMid); const ContentInfo* vc = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); ASSERT_TRUE(vc); ASSERT_TRUE(vc->media_description()); EXPECT_TRUE(vc->rejected); } // Create an answer that rejects the contents which are rejected in the offer. TEST_F(MediaSessionDescriptionFactoryTest, CreateAnswerToOfferWithRejectedMedia) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); ContentInfo* ac = offer->GetContentByName(kAudioMid); ContentInfo* vc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); ASSERT_TRUE(vc); ac->rejected = true; vc->rejected = true; std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); ac = answer->GetContentByName(kAudioMid); vc = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); ASSERT_TRUE(vc); EXPECT_TRUE(ac->rejected); EXPECT_TRUE(vc->rejected); } TEST_F(MediaSessionDescriptionFactoryTest, OfferAndAnswerDoesNotHaveMixedByteSessionAttribute) { MediaSessionOptions opts; std::unique_ptr offer = f1_.CreateOfferOrError(opts, /*current_description=*/nullptr).MoveValue(); offer->set_extmap_allow_mixed(false); std::unique_ptr answer( f2_.CreateAnswerOrError(offer.get(), opts, /*current_description=*/nullptr) .MoveValue()); EXPECT_FALSE(answer->extmap_allow_mixed()); } TEST_F(MediaSessionDescriptionFactoryTest, OfferAndAnswerHaveMixedByteSessionAttribute) { MediaSessionOptions opts; std::unique_ptr offer = f1_.CreateOfferOrError(opts, /*current_description=*/nullptr).MoveValue(); offer->set_extmap_allow_mixed(true); std::unique_ptr answer_support( f2_.CreateAnswerOrError(offer.get(), opts, /*current_description=*/nullptr) .MoveValue()); EXPECT_TRUE(answer_support->extmap_allow_mixed()); } TEST_F(MediaSessionDescriptionFactoryTest, OfferAndAnswerDoesNotHaveMixedByteMediaAttributes) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kSendRecv, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, /*current_description=*/nullptr).MoveValue(); offer->set_extmap_allow_mixed(false); MediaContentDescription* audio_offer = offer->GetContentDescriptionByName(kAudioMid); MediaContentDescription* video_offer = offer->GetContentDescriptionByName(kVideoMid); ASSERT_EQ(audio_offer->extmap_allow_mixed_level(), MediaContentDescription::AttributeLevel::kNone); ASSERT_EQ(video_offer->extmap_allow_mixed_level(), MediaContentDescription::AttributeLevel::kNone); std::unique_ptr answer( f2_.CreateAnswerOrError(offer.get(), opts, /*current_description=*/nullptr) .MoveValue()); MediaContentDescription* audio_answer = answer->GetContentDescriptionByName(kAudioMid); MediaContentDescription* video_answer = answer->GetContentDescriptionByName(kVideoMid); EXPECT_EQ(audio_answer->extmap_allow_mixed_level(), MediaContentDescription::AttributeLevel::kNone); EXPECT_EQ(video_answer->extmap_allow_mixed_level(), MediaContentDescription::AttributeLevel::kNone); } TEST_F(MediaSessionDescriptionFactoryTest, OfferAndAnswerHaveSameMixedByteMediaAttributes) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kSendRecv, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, /*current_description=*/nullptr).MoveValue(); offer->set_extmap_allow_mixed(false); MediaContentDescription* audio_offer = offer->GetContentDescriptionByName(kAudioMid); audio_offer->set_extmap_allow_mixed_level( MediaContentDescription::AttributeLevel::kMedia); MediaContentDescription* video_offer = offer->GetContentDescriptionByName(kVideoMid); video_offer->set_extmap_allow_mixed_level( MediaContentDescription::AttributeLevel::kMedia); std::unique_ptr answer( f2_.CreateAnswerOrError(offer.get(), opts, /*current_description=*/nullptr) .MoveValue()); MediaContentDescription* audio_answer = answer->GetContentDescriptionByName(kAudioMid); MediaContentDescription* video_answer = answer->GetContentDescriptionByName(kVideoMid); EXPECT_EQ(audio_answer->extmap_allow_mixed_level(), MediaContentDescription::AttributeLevel::kMedia); EXPECT_EQ(video_answer->extmap_allow_mixed_level(), MediaContentDescription::AttributeLevel::kMedia); } TEST_F(MediaSessionDescriptionFactoryTest, OfferAndAnswerHaveDifferentMixedByteMediaAttributes) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kSendRecv, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, /*current_description=*/nullptr).MoveValue(); offer->set_extmap_allow_mixed(false); MediaContentDescription* audio_offer = offer->GetContentDescriptionByName(kAudioMid); audio_offer->set_extmap_allow_mixed_level( MediaContentDescription::AttributeLevel::kNone); MediaContentDescription* video_offer = offer->GetContentDescriptionByName(kVideoMid); video_offer->set_extmap_allow_mixed_level( MediaContentDescription::AttributeLevel::kMedia); std::unique_ptr answer( f2_.CreateAnswerOrError(offer.get(), opts, /*current_description=*/nullptr) .MoveValue()); MediaContentDescription* audio_answer = answer->GetContentDescriptionByName(kAudioMid); MediaContentDescription* video_answer = answer->GetContentDescriptionByName(kVideoMid); EXPECT_EQ(audio_answer->extmap_allow_mixed_level(), MediaContentDescription::AttributeLevel::kNone); EXPECT_EQ(video_answer->extmap_allow_mixed_level(), MediaContentDescription::AttributeLevel::kMedia); } // Create an audio and video offer with: // - one video track // - two audio tracks // and ensure it matches what we expect. Also updates the initial offer by // adding a new video track and replaces one of the audio tracks. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateMultiStreamVideoOffer) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kSendRecv, &opts); AttachSenderToMediaDescriptionOptions( kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts); AttachSenderToMediaDescriptionOptions( kAudioMid, MediaType::AUDIO, kAudioTrack1, {kMediaStream1}, 1, &opts); AttachSenderToMediaDescriptionOptions( kAudioMid, MediaType::AUDIO, kAudioTrack2, {kMediaStream1}, 1, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* ac = offer->GetContentByName(kAudioMid); const ContentInfo* vc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); ASSERT_TRUE(vc); const MediaContentDescription* acd = ac->media_description(); const MediaContentDescription* vcd = vc->media_description(); EXPECT_EQ(acd->type(), MediaType::AUDIO); EXPECT_THAT(acd->codecs(), CodecListsMatch(codec_lookup_helper_1_.GetCodecVendor() ->audio_sendrecv_codecs() .codecs(), &env_.field_trials())); const StreamParamsVec& audio_streams = acd->streams(); ASSERT_EQ(audio_streams.size(), 2U); EXPECT_EQ(audio_streams[0].cname, audio_streams[1].cname); EXPECT_EQ(audio_streams[0].id, kAudioTrack1); ASSERT_EQ(audio_streams[0].ssrcs.size(), 1U); EXPECT_NE(audio_streams[0].ssrcs[0], 0U); EXPECT_EQ(audio_streams[1].id, kAudioTrack2); ASSERT_EQ(audio_streams[1].ssrcs.size(), 1U); EXPECT_NE(audio_streams[1].ssrcs[0], 0U); EXPECT_EQ(acd->bandwidth(), kAutoBandwidth); // default bandwidth (auto) EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on EXPECT_EQ(vcd->type(), MediaType::VIDEO); EXPECT_THAT(vcd->codecs(), CodecListsMatch(codec_lookup_helper_1_.GetCodecVendor() ->video_sendrecv_codecs() .codecs(), &env_.field_trials())); const StreamParamsVec& video_streams = vcd->streams(); ASSERT_EQ(video_streams.size(), 1U); EXPECT_EQ(video_streams[0].cname, audio_streams[0].cname); EXPECT_EQ(video_streams[0].id, kVideoTrack1); EXPECT_EQ(vcd->bandwidth(), kAutoBandwidth); // default bandwidth (auto) EXPECT_TRUE(vcd->rtcp_mux()); // rtcp-mux defaults on // Update the offer. Add a new video track that is not synched to the // other tracks and replace audio track 2 with audio track 3. AttachSenderToMediaDescriptionOptions( kVideoMid, MediaType::VIDEO, kVideoTrack2, {kMediaStream2}, 1, &opts); DetachSenderFromMediaSection(kAudioMid, kAudioTrack2, &opts); AttachSenderToMediaDescriptionOptions( kAudioMid, MediaType::AUDIO, kAudioTrack3, {kMediaStream1}, 1, &opts); std::unique_ptr updated_offer( f1_.CreateOfferOrError(opts, offer.get()).MoveValue()); ASSERT_TRUE(updated_offer.get()); ac = updated_offer->GetContentByName(kAudioMid); vc = updated_offer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); ASSERT_TRUE(vc); const MediaContentDescription* updated_acd = ac->media_description(); const MediaContentDescription* updated_vcd = vc->media_description(); EXPECT_EQ(acd->type(), updated_acd->type()); EXPECT_THAT(updated_acd->codecs(), CodecListsMatch(acd->codecs(), &env_.field_trials())); EXPECT_EQ(vcd->type(), updated_vcd->type()); EXPECT_THAT(updated_vcd->codecs(), CodecListsMatch(vcd->codecs(), &env_.field_trials())); const StreamParamsVec& updated_audio_streams = updated_acd->streams(); ASSERT_EQ(updated_audio_streams.size(), 2U); EXPECT_EQ(audio_streams[0], updated_audio_streams[0]); EXPECT_EQ(updated_audio_streams[1].id, kAudioTrack3); // New audio track. ASSERT_EQ(updated_audio_streams[1].ssrcs.size(), 1U); EXPECT_NE(updated_audio_streams[1].ssrcs[0], 0U); EXPECT_EQ(updated_audio_streams[0].cname, updated_audio_streams[1].cname); const StreamParamsVec& updated_video_streams = updated_vcd->streams(); ASSERT_EQ(updated_video_streams.size(), 2U); EXPECT_EQ(video_streams[0], updated_video_streams[0]); EXPECT_EQ(updated_video_streams[1].id, kVideoTrack2); // All the media streams in one PeerConnection share one RTCP CNAME. EXPECT_EQ(updated_video_streams[1].cname, updated_video_streams[0].cname); } // Create an offer with simulcast video stream. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateSimulcastVideoOffer) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kRecvOnly, kActive, &opts); AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); const int num_sim_layers = 3; AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, num_sim_layers, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* vc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(vc); const MediaContentDescription* vcd = vc->media_description(); const StreamParamsVec& video_streams = vcd->streams(); ASSERT_EQ(video_streams.size(), 1U); EXPECT_EQ(video_streams[0].id, kVideoTrack1); const SsrcGroup* sim_ssrc_group = video_streams[0].get_ssrc_group(kSimSsrcGroupSemantics); ASSERT_TRUE(sim_ssrc_group); EXPECT_EQ(static_cast(num_sim_layers), sim_ssrc_group->ssrcs.size()); } MATCHER(RidDescriptionEquals, "Verifies that two RidDescriptions are equal.") { const RidDescription& rid1 = std::get<0>(arg); const RidDescription& rid2 = std::get<1>(arg); return rid1.rid == rid2.rid && rid1.direction == rid2.direction; } void CheckSimulcastInSessionDescription( const SessionDescription* description, const std::string& content_name, std::span send_rids, const SimulcastLayerList& send_layers) { ASSERT_NE(description, nullptr); const ContentInfo* content = description->GetContentByName(content_name); ASSERT_NE(content, nullptr); const MediaContentDescription* cd = content->media_description(); ASSERT_NE(cd, nullptr); const StreamParamsVec& streams = cd->streams(); ASSERT_THAT(streams, SizeIs(1)); const StreamParams& stream = streams[0]; ASSERT_THAT(stream.ssrcs, IsEmpty()); EXPECT_TRUE(stream.has_rids()); const std::vector rids = stream.rids(); EXPECT_THAT(rids, Pointwise(RidDescriptionEquals(), send_rids)); EXPECT_TRUE(cd->HasSimulcast()); const SimulcastDescription& simulcast = cd->simulcast_description(); EXPECT_THAT(simulcast.send_layers(), SizeIs(send_layers.size())); EXPECT_THAT(simulcast.send_layers(), Pointwise(Eq(), send_layers)); ASSERT_THAT(simulcast.receive_layers().GetAllLayers(), SizeIs(0)); } // Create an offer with spec-compliant simulcast video stream. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateCompliantSimulcastOffer) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); std::vector send_rids; send_rids.push_back(RidDescription("f", RidDirection::kSend)); send_rids.push_back(RidDescription("h", RidDirection::kSend)); send_rids.push_back(RidDescription("q", RidDirection::kSend)); SimulcastLayerList simulcast_layers; simulcast_layers.AddLayer(SimulcastLayer(send_rids[0].rid, false)); simulcast_layers.AddLayer(SimulcastLayer(send_rids[1].rid, true)); simulcast_layers.AddLayer(SimulcastLayer(send_rids[2].rid, false)); AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, send_rids, simulcast_layers, 0, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); CheckSimulcastInSessionDescription(offer.get(), kVideoMid, send_rids, simulcast_layers); } // Create an offer that signals RIDs (not SSRCs) without Simulcast. // In this scenario, RIDs do not need to be negotiated (there is only one). TEST_F(MediaSessionDescriptionFactoryTest, TestOfferWithRidsNoSimulcast) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); RidDescription rid("f", RidDirection::kSend); AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, {rid}, SimulcastLayerList(), 0, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_NE(offer.get(), nullptr); const ContentInfo* content = offer->GetContentByName(kVideoMid); ASSERT_NE(content, nullptr); const MediaContentDescription* cd = content->media_description(); ASSERT_NE(cd, nullptr); const StreamParamsVec& streams = cd->streams(); ASSERT_THAT(streams, SizeIs(1)); const StreamParams& stream = streams[0]; ASSERT_THAT(stream.ssrcs, IsEmpty()); EXPECT_FALSE(stream.has_rids()); EXPECT_FALSE(cd->HasSimulcast()); } // Create an answer with spec-compliant simulcast video stream. // In this scenario, the SFU is the caller requesting that we send Simulcast. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateCompliantSimulcastAnswer) { MediaSessionOptions offer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &offer_opts); AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &offer_opts); std::unique_ptr offer = f1_.CreateOfferOrError(offer_opts, nullptr).MoveValue(); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &answer_opts); std::vector rid_descriptions{ RidDescription("f", RidDirection::kSend), RidDescription("h", RidDirection::kSend), RidDescription("q", RidDirection::kSend), }; SimulcastLayerList simulcast_layers; simulcast_layers.AddLayer(SimulcastLayer(rid_descriptions[0].rid, false)); simulcast_layers.AddLayer(SimulcastLayer(rid_descriptions[1].rid, true)); simulcast_layers.AddLayer(SimulcastLayer(rid_descriptions[2].rid, false)); AttachSenderToMediaDescriptionOptions( kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, rid_descriptions, simulcast_layers, 0, &answer_opts); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), answer_opts, nullptr).MoveValue(); CheckSimulcastInSessionDescription(answer.get(), kVideoMid, rid_descriptions, simulcast_layers); } // Create an answer that signals RIDs (not SSRCs) without Simulcast. // In this scenario, RIDs do not need to be negotiated (there is only one). // Note that RID Direction is not the same as the transceiver direction. TEST_F(MediaSessionDescriptionFactoryTest, TestAnswerWithRidsNoSimulcast) { MediaSessionOptions offer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &offer_opts); RidDescription rid_offer("f", RidDirection::kSend); AttachSenderToMediaDescriptionOptions( kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, {rid_offer}, SimulcastLayerList(), 0, &offer_opts); std::unique_ptr offer = f1_.CreateOfferOrError(offer_opts, nullptr).MoveValue(); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &answer_opts); RidDescription rid_answer("f", RidDirection::kReceive); AttachSenderToMediaDescriptionOptions( kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, {rid_answer}, SimulcastLayerList(), 0, &answer_opts); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), answer_opts, nullptr).MoveValue(); ASSERT_NE(answer.get(), nullptr); const ContentInfo* content = offer->GetContentByName(kVideoMid); ASSERT_NE(content, nullptr); const MediaContentDescription* cd = content->media_description(); ASSERT_NE(cd, nullptr); const StreamParamsVec& streams = cd->streams(); ASSERT_THAT(streams, SizeIs(1)); const StreamParams& stream = streams[0]; ASSERT_THAT(stream.ssrcs, IsEmpty()); EXPECT_FALSE(stream.has_rids()); EXPECT_FALSE(cd->HasSimulcast()); } // Create an audio and video answer to a standard video offer with: // - one video track // - two audio tracks // - two data tracks // and ensure it matches what we expect. Also updates the initial answer by // adding a new video track and removes one of the audio tracks. TEST_F(MediaSessionDescriptionFactoryTest, TestCreateMultiStreamVideoAnswer) { MediaSessionOptions offer_opts; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kRecvOnly, kActive, &offer_opts); AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &offer_opts); std::unique_ptr offer = f1_.CreateOfferOrError(offer_opts, nullptr).MoveValue(); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kSendRecv, kActive, &answer_opts); AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &answer_opts); AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &answer_opts); AttachSenderToMediaDescriptionOptions(kAudioMid, MediaType::AUDIO, kAudioTrack1, {kMediaStream1}, 1, &answer_opts); AttachSenderToMediaDescriptionOptions(kAudioMid, MediaType::AUDIO, kAudioTrack2, {kMediaStream1}, 1, &answer_opts); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), answer_opts, nullptr).MoveValue(); ASSERT_TRUE(answer.get()); const ContentInfo* ac = answer->GetContentByName(kAudioMid); const ContentInfo* vc = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); ASSERT_TRUE(vc); const MediaContentDescription* acd = ac->media_description(); const MediaContentDescription* vcd = vc->media_description(); EXPECT_EQ(acd->type(), MediaType::AUDIO); EXPECT_THAT(acd->codecs(), CodecListsMatch(kAudioCodecsAnswer, &env_.field_trials())); const StreamParamsVec& audio_streams = acd->streams(); ASSERT_EQ(audio_streams.size(), 2U); EXPECT_TRUE(audio_streams[0].cname == audio_streams[1].cname); EXPECT_EQ(audio_streams[0].id, kAudioTrack1); ASSERT_EQ(audio_streams[0].ssrcs.size(), 1U); EXPECT_NE(audio_streams[0].ssrcs[0], 0U); EXPECT_EQ(audio_streams[1].id, kAudioTrack2); ASSERT_EQ(audio_streams[1].ssrcs.size(), 1U); EXPECT_NE(audio_streams[1].ssrcs[0], 0U); EXPECT_EQ(acd->bandwidth(), kAutoBandwidth); // default bandwidth (auto) EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on EXPECT_EQ(vcd->type(), MediaType::VIDEO); EXPECT_THAT(vcd->codecs(), CodecListsMatch(kVideoCodecsAnswer, &env_.field_trials())); const StreamParamsVec& video_streams = vcd->streams(); ASSERT_EQ(video_streams.size(), 1U); EXPECT_EQ(video_streams[0].cname, audio_streams[0].cname); EXPECT_EQ(video_streams[0].id, kVideoTrack1); EXPECT_EQ(vcd->bandwidth(), kAutoBandwidth); // default bandwidth (auto) EXPECT_TRUE(vcd->rtcp_mux()); // rtcp-mux defaults on // Update the answer. Add a new video track that is not synched to the // other tracks and remove 1 audio track. AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, kVideoTrack2, {kMediaStream2}, 1, &answer_opts); DetachSenderFromMediaSection(kAudioMid, kAudioTrack2, &answer_opts); std::unique_ptr updated_answer( f2_.CreateAnswerOrError(offer.get(), answer_opts, answer.get()) .MoveValue()); ASSERT_TRUE(updated_answer.get()); ac = updated_answer->GetContentByName(kAudioMid); vc = updated_answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); ASSERT_TRUE(vc); const MediaContentDescription* updated_acd = ac->media_description(); const MediaContentDescription* updated_vcd = vc->media_description(); EXPECT_EQ(acd->type(), updated_acd->type()); EXPECT_THAT(updated_acd->codecs(), CodecListsMatch(acd->codecs(), &env_.field_trials())); EXPECT_EQ(vcd->type(), updated_vcd->type()); EXPECT_THAT(updated_vcd->codecs(), CodecListsMatch(vcd->codecs(), &env_.field_trials())); const StreamParamsVec& updated_audio_streams = updated_acd->streams(); ASSERT_EQ(updated_audio_streams.size(), 1U); EXPECT_TRUE(audio_streams[0] == updated_audio_streams[0]); const StreamParamsVec& updated_video_streams = updated_vcd->streams(); ASSERT_EQ(updated_video_streams.size(), 2U); EXPECT_EQ(video_streams[0], updated_video_streams[0]); EXPECT_EQ(updated_video_streams[1].id, kVideoTrack2); // All media streams in one PeerConnection share one CNAME. EXPECT_EQ(updated_video_streams[1].cname, updated_video_streams[0].cname); } // Create an updated offer after creating an answer to the original offer and // verify that the codecs that were part of the original answer are not changed // in the updated offer. TEST_F(MediaSessionDescriptionFactoryTest, RespondentCreatesOfferAfterCreatingAnswer) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); const AudioContentDescription* acd = GetFirstAudioContentDescription(answer.get()); EXPECT_THAT(acd->codecs(), CodecListsMatch(kAudioCodecsAnswer, &env_.field_trials())); const VideoContentDescription* vcd = GetFirstVideoContentDescription(answer.get()); EXPECT_THAT(vcd->codecs(), CodecListsMatch(kVideoCodecsAnswer, &env_.field_trials())); std::unique_ptr updated_offer( f2_.CreateOfferOrError(opts, answer.get()).MoveValue()); // The expected audio codecs are the common audio codecs from the first // offer/answer exchange plus the audio codecs only `f2_` offer, sorted in // preference order. // TODO(wu): `updated_offer` should not include the codec // (i.e. `kAudioCodecs2[0]`) the other side doesn't support. const std::vector kUpdatedAudioCodecOffer = { kAudioCodecsAnswer[0], kAudioCodecsAnswer[1], kAudioCodecs2[0], }; // 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 std::vector kUpdatedVideoCodecOffer = { kVideoCodecsAnswer[0], kVideoCodecs2[1], }; const AudioContentDescription* updated_acd = GetFirstAudioContentDescription(updated_offer.get()); EXPECT_THAT(updated_acd->codecs(), CodecListsMatch(kUpdatedAudioCodecOffer, &env_.field_trials())); const VideoContentDescription* updated_vcd = GetFirstVideoContentDescription(updated_offer.get()); EXPECT_THAT(updated_vcd->codecs(), CodecListsMatch(kUpdatedVideoCodecOffer, &env_.field_trials())); } // Test that a reoffer does not reuse audio codecs from a previous media section // that is being recycled. TEST_F(MediaSessionDescriptionFactoryTest, ReOfferDoesNotReUseRecycledAudioCodecs) { codec_lookup_helper_1_.ClearVideoCodecs(); codec_lookup_helper_2_.ClearVideoCodecs(); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::AUDIO, "a0", RtpTransceiverDirection::kSendRecv, kActive, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); // Recycle the media section by changing its mid. opts.media_description_options[0].mid = "a1"; std::unique_ptr reoffer = f2_.CreateOfferOrError(opts, answer.get()).MoveValue(); // Expect that the results of the first negotiation are ignored. If the m= // section was not recycled the payload types would match the initial offerer. const AudioContentDescription* acd = GetFirstAudioContentDescription(reoffer.get()); EXPECT_THAT(acd->codecs(), NamesMatch(GetCodecNames(kAudioCodecs2))); } // Test that a reoffer does not reuse video codecs from a previous media section // that is being recycled. TEST_F(MediaSessionDescriptionFactoryTest, ReOfferDoesNotReUseRecycledVideoCodecs) { codec_lookup_helper_1_.ClearAudioCodecs(); codec_lookup_helper_2_.ClearAudioCodecs(); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, "v0", RtpTransceiverDirection::kSendRecv, kActive, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); // Recycle the media section by changing its mid. opts.media_description_options[0].mid = "v1"; std::unique_ptr reoffer = f2_.CreateOfferOrError(opts, answer.get()).MoveValue(); // Expect that the results of the first negotiation are ignored. If the m= // section was not recycled the payload types would match the initial offerer. const VideoContentDescription* vcd = GetFirstVideoContentDescription(reoffer.get()); EXPECT_THAT(vcd->codecs(), CodecListsMatch(kVideoCodecs2, &env_.field_trials())); } // Test that a reanswer does not reuse audio codecs from a previous media // section that is being recycled. TEST_F(MediaSessionDescriptionFactoryTest, ReAnswerDoesNotReUseRecycledAudioCodecs) { codec_lookup_helper_1_.ClearVideoCodecs(); codec_lookup_helper_2_.ClearVideoCodecs(); // Perform initial offer/answer in reverse (`f2_` as offerer) so that the // second offer/answer is forward (`f1_` as offerer). MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::AUDIO, "a0", RtpTransceiverDirection::kSendRecv, kActive, &opts); std::unique_ptr offer = f2_.CreateOfferOrError(opts, nullptr).MoveValue(); std::unique_ptr answer = f1_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); // Recycle the media section by changing its mid. opts.media_description_options[0].mid = "a1"; std::unique_ptr reoffer = f1_.CreateOfferOrError(opts, answer.get()).MoveValue(); std::unique_ptr reanswer = f2_.CreateAnswerOrError(reoffer.get(), opts, offer.get()).MoveValue(); // Expect that the results of the first negotiation are ignored. If the m= // section was not recycled the payload types would match the initial offerer. const AudioContentDescription* acd = GetFirstAudioContentDescription(reanswer.get()); EXPECT_THAT(acd->codecs(), CodecListsMatch(kAudioCodecsAnswer, &env_.field_trials())); } // Test that a reanswer does not reuse video codecs from a previous media // section that is being recycled. TEST_F(MediaSessionDescriptionFactoryTest, ReAnswerDoesNotReUseRecycledVideoCodecs) { codec_lookup_helper_1_.ClearAudioCodecs(); codec_lookup_helper_2_.ClearAudioCodecs(); // Perform initial offer/answer in reverse (`f2_` as offerer) so that the // second offer/answer is forward (`f1_` as offerer). MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, "v0", RtpTransceiverDirection::kSendRecv, kActive, &opts); std::unique_ptr offer = f2_.CreateOfferOrError(opts, nullptr).MoveValue(); std::unique_ptr answer = f1_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); // Recycle the media section by changing its mid. opts.media_description_options[0].mid = "v1"; std::unique_ptr reoffer = f1_.CreateOfferOrError(opts, answer.get()).MoveValue(); std::unique_ptr reanswer = f2_.CreateAnswerOrError(reoffer.get(), opts, offer.get()).MoveValue(); // Expect that the results of the first negotiation are ignored. If the m= // section was not recycled the payload types would match the initial offerer. const VideoContentDescription* vcd = GetFirstVideoContentDescription(reanswer.get()); EXPECT_THAT(vcd->codecs(), CodecListsMatch(kVideoCodecsAnswer, &env_.field_trials())); } // Create an updated offer after creating an answer to the original offer and // verify that the codecs that were part of the original answer are not changed // in the updated offer. In this test Rtx is enabled. TEST_F(MediaSessionDescriptionFactoryTest, RespondentCreatesOfferAfterCreatingAnswerWithRtx) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &opts); std::vector f1_codecs(kVideoCodecs1.begin(), kVideoCodecs1.end()); // This creates rtx for H264 with the payload type `f1_` uses. AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs); codec_lookup_helper_1_.SetVideoCodecs(f1_codecs); std::vector f2_codecs(kVideoCodecs2.begin(), kVideoCodecs2.end()); // This creates rtx for H264 with the payload type `f2_` uses. AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs); codec_lookup_helper_2_.SetVideoCodecs(f2_codecs); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); const VideoContentDescription* vcd = GetFirstVideoContentDescription(answer.get()); std::vector expected_codecs(kVideoCodecsAnswer.begin(), kVideoCodecsAnswer.end()); AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &expected_codecs); EXPECT_THAT(vcd->codecs(), CodecListsMatch(expected_codecs, &env_.field_trials())); // Now, make sure we get same result (except for the order) if `f2_` creates // an updated offer even though the default payload types between `f1_` and // `f2_` are different. std::unique_ptr updated_offer( f2_.CreateOfferOrError(opts, answer.get()).MoveValue()); ASSERT_TRUE(updated_offer); std::unique_ptr updated_answer( f1_.CreateAnswerOrError(updated_offer.get(), opts, answer.get()) .MoveValue()); const VideoContentDescription* updated_vcd = GetFirstVideoContentDescription(updated_answer.get()); EXPECT_THAT(updated_vcd->codecs(), CodecListsMatch(expected_codecs, &env_.field_trials())); } // Regression test for: // https://bugs.chromium.org/p/webrtc/issues/detail?id=8332 // Existing codecs should always appear before new codecs in re-offers. But // under a specific set of circumstances, the existing RTX codec was ending up // added to the end of the list. TEST_F(MediaSessionDescriptionFactoryTest, RespondentCreatesOfferAfterCreatingAnswerWithRemappedRtxPayloadType) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &opts); // We specifically choose different preferred payload types for VP8 to // trigger the issue. 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); codec_lookup_helper_1_.SetVideoCodecs({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. codec_lookup_helper_2_.SetVideoCodecs( {vp9, vp9_rtx, vp8_answerer, vp8_answerer_rtx}); std::vector audio_codecs; codec_lookup_helper_1_.SetAudioCodecs(audio_codecs); codec_lookup_helper_2_.SetAudioCodecs(audio_codecs); // Offer will be {VP8, RTX for VP8}. Answer will be the same. std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); // Updated offer *should* be {VP8, RTX for VP8, VP9, RTX for VP9}. // But if the bug is triggered, RTX for VP8 ends up last. std::unique_ptr updated_offer( f2_.CreateOfferOrError(opts, answer.get()).MoveValue()); const VideoContentDescription* vcd = GetFirstVideoContentDescription(updated_offer.get()); EXPECT_THAT(vcd->codecs(), CodecListsMatch(std::vector{vp8_offerer, vp8_offerer_rtx, vp9, vp9_rtx}, &env_.field_trials())); } // Create an updated offer that adds video after creating an audio only answer // to the original offer. This test verifies that if a video codec and the RTX // codec have the same default payload type as an audio codec that is already in // use, the added codecs payload types are changed. // TODO(bugs.webrtc.org/400630582): Investigate why this fails in the legacy // path with the new test-only PT registration. TEST_F(MediaSessionDescriptionFactoryTest, RespondentCreatesOfferWithVideoAndRtxAfterCreatingAudioAnswer) { std::vector f1_codecs(kVideoCodecs1.begin(), kVideoCodecs1.end()); // This creates rtx for H264 with the payload type `f1_` uses. AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs); codec_lookup_helper_1_.SetVideoCodecs(f1_codecs); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kRecvOnly, kActive, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); const AudioContentDescription* acd = GetFirstAudioContentDescription(answer.get()); EXPECT_THAT(acd->codecs(), CodecListsMatch(kAudioCodecsAnswer, &env_.field_trials())); // Now - let `f2_` add video with RTX and let the payload type the RTX codec // reference be the same as an audio codec that was negotiated in the // first offer/answer exchange. opts.media_description_options.clear(); AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); std::vector f2_codecs(kVideoCodecs2.begin(), kVideoCodecs2.end()); ASSERT_THAT(acd->codecs().size(), Gt(0)); 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); codec_lookup_helper_2_.SetVideoCodecs(f2_codecs); std::unique_ptr updated_offer( f2_.CreateOfferOrError(opts, answer.get()).MoveValue()); ASSERT_TRUE(updated_offer); std::unique_ptr updated_answer( f1_.CreateAnswerOrError(updated_offer.get(), opts, answer.get()) .MoveValue()); const AudioContentDescription* updated_acd = GetFirstAudioContentDescription(updated_answer.get()); EXPECT_THAT(updated_acd->codecs(), CodecListsMatch(kAudioCodecsAnswer, &env_.field_trials())); const VideoContentDescription* updated_vcd = GetFirstVideoContentDescription(updated_answer.get()); ASSERT_EQ(updated_vcd->codecs()[0].name, "H264"); ASSERT_EQ(updated_vcd->codecs()[1].name, kRtxCodecName); int new_h264_pl_type = updated_vcd->codecs()[0].id; EXPECT_NE(used_pl_type, new_h264_pl_type); Codec rtx = updated_vcd->codecs()[1]; int pt_referenced_by_rtx = FromString(rtx.params[kCodecParamAssociatedPayloadType]); EXPECT_EQ(new_h264_pl_type, pt_referenced_by_rtx); } // Create an updated offer with RTX after creating an answer to an offer // without RTX, and with different default payload types. // Verify that the added RTX codec references the correct payload type. TEST_F(MediaSessionDescriptionFactoryTest, RespondentCreatesOfferWithRtxAfterCreatingAnswerWithoutRtx) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); std::vector f2_codecs(kVideoCodecs2.begin(), kVideoCodecs2.end()); // This creates rtx for H264 with the payload type `f2_` uses. AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs); codec_lookup_helper_2_.SetVideoCodecs(f2_codecs); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); const VideoContentDescription* vcd = GetFirstVideoContentDescription(answer.get()); std::vector expected_codecs(kVideoCodecsAnswer.begin(), kVideoCodecsAnswer.end()); EXPECT_THAT(vcd->codecs(), CodecListsMatch(expected_codecs, &env_.field_trials())); // Now, ensure that the RTX codec is created correctly when `f2_` creates an // updated offer, even though the default payload types are different from // those of `f1_`. std::unique_ptr updated_offer( f2_.CreateOfferOrError(opts, answer.get()).MoveValue()); ASSERT_TRUE(updated_offer); const VideoContentDescription* updated_vcd = GetFirstVideoContentDescription(updated_offer.get()); // New offer should attempt to add H263, and RTX for H264. expected_codecs.push_back(kVideoCodecs2[1]); AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs1[1].id), &expected_codecs); EXPECT_THAT(updated_vcd->codecs(), CodecListsMatch(expected_codecs, &env_.field_trials())); } // Test that RTX is ignored when there is no associated payload type parameter. TEST_F(MediaSessionDescriptionFactoryTest, RtxWithoutApt) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &opts); std::vector f1_codecs(kVideoCodecs1.begin(), kVideoCodecs1.end()); // This creates RTX without associated payload type parameter. AddRtxCodec(CreateVideoCodec(126, kRtxCodecName), &f1_codecs); codec_lookup_helper_1_.SetVideoCodecs(f1_codecs); std::vector f2_codecs(kVideoCodecs2.begin(), kVideoCodecs2.end()); // This creates RTX for H264 with the payload type `f2_` uses. AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs); codec_lookup_helper_2_.SetVideoCodecs(f2_codecs); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); // kCodecParamAssociatedPayloadType will always be added to the offer when RTX // is selected. Manually remove kCodecParamAssociatedPayloadType so that it // is possible to test that that RTX is dropped when // kCodecParamAssociatedPayloadType is missing in the offer. MediaContentDescription* media_desc = offer->GetContentDescriptionByName(kVideoMid); ASSERT_TRUE(media_desc); std::vector codecs = media_desc->codecs(); for (Codec& codec : codecs) { if (absl::StartsWith(codec.name, kRtxCodecName)) { codec.params.clear(); } } media_desc->set_codecs(codecs); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); EXPECT_THAT( GetCodecNames(GetFirstVideoContentDescription(answer.get())->codecs()), Not(Contains(kRtxCodecName))); } // Test that RTX will be filtered out in the answer if its associated payload // type doesn't match the local value. TEST_F(MediaSessionDescriptionFactoryTest, FilterOutRtxIfAptDoesntMatch) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &opts); std::vector f1_codecs(kVideoCodecs1.begin(), kVideoCodecs1.end()); // This creates RTX for H264 in sender. AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs); codec_lookup_helper_1_.SetVideoCodecs(f1_codecs); std::vector f2_codecs(kVideoCodecs2.begin(), kVideoCodecs2.end()); // This creates RTX for H263 in receiver. AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs2[1].id), &f2_codecs); codec_lookup_helper_2_.SetVideoCodecs(f2_codecs); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); // Associated payload type doesn't match, therefore, RTX codec is removed in // the answer. std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); EXPECT_THAT( GetCodecNames(GetFirstVideoContentDescription(answer.get())->codecs()), Not(Contains(kRtxCodecName))); } // Test that when multiple RTX codecs are offered, only the matched RTX codec // is added in the answer, and the unsupported RTX codec is filtered out. TEST_F(MediaSessionDescriptionFactoryTest, FilterOutUnsupportedRtxWhenCreatingAnswer) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &opts); std::vector f1_codecs(kVideoCodecs1.begin(), kVideoCodecs1.end()); // This creates RTX for H264-SVC in sender. AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs1[0].id), &f1_codecs); codec_lookup_helper_1_.SetVideoCodecs(f1_codecs); // This creates RTX for H264 in sender. AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs); codec_lookup_helper_1_.SetVideoCodecs(f1_codecs); std::vector f2_codecs(kVideoCodecs2.begin(), kVideoCodecs2.end()); // This creates RTX for H264 in receiver. AddRtxCodec(CreateVideoRtxCodec(124, kVideoCodecs2[0].id), &f2_codecs); codec_lookup_helper_2_.SetVideoCodecs(f2_codecs, f1_codecs); // H264-SVC codec is removed in the answer, therefore, associated RTX codec // for H264-SVC should also be removed. std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); const VideoContentDescription* vcd = GetFirstVideoContentDescription(answer.get()); std::vector expected_codecs(kVideoCodecsAnswer.begin(), kVideoCodecsAnswer.end()); AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &expected_codecs); EXPECT_THAT(vcd->codecs(), CodecListsMatch(expected_codecs, &env_.field_trials())); } // Test that after one RTX codec has been negotiated, a new offer can attempt // to add another. TEST_F(MediaSessionDescriptionFactoryTest, AddSecondRtxInNewOffer) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &opts); std::vector f1_codecs(kVideoCodecs1.begin(), kVideoCodecs1.end()); // This creates RTX for H264 for the offerer. AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs); codec_lookup_helper_1_.SetVideoCodecs(f1_codecs); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); const VideoContentDescription* vcd = GetFirstVideoContentDescription(offer.get()); std::vector expected_codecs(kVideoCodecs1.begin(), kVideoCodecs1.end()); AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &expected_codecs); EXPECT_THAT(vcd->codecs(), CodecListsMatch(expected_codecs, &env_.field_trials())); // Now, attempt to add RTX for H264-SVC. AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs1[0].id), &f1_codecs); codec_lookup_helper_1_.SetVideoCodecs(f1_codecs); std::unique_ptr updated_offer( f1_.CreateOfferOrError(opts, offer.get()).MoveValue()); ASSERT_TRUE(updated_offer); vcd = GetFirstVideoContentDescription(updated_offer.get()); AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs1[0].id), &expected_codecs); EXPECT_THAT(vcd->codecs(), CodecListsMatch(expected_codecs, &env_.field_trials())); } // Test that when RTX is used in conjunction with simulcast, an RTX ssrc is // generated for each simulcast ssrc and correctly grouped. TEST_F(MediaSessionDescriptionFactoryTest, SimSsrcsGenerateMultipleRtxSsrcs) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); // Add simulcast streams. AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, "stream1", {"stream1label"}, 3, &opts); // Use a single real codec, and then add RTX for it. std::vector f1_codecs; f1_codecs.push_back(CreateVideoCodec(97, "H264")); AddRtxCodec(CreateVideoRtxCodec(125, 97), &f1_codecs); codec_lookup_helper_1_.SetVideoCodecs(f1_codecs); // Ensure that the offer has an RTX ssrc for each regular ssrc, and that there // is a FID ssrc + grouping for each. std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); MediaContentDescription* media_desc = offer->GetContentDescriptionByName(kVideoMid); ASSERT_TRUE(media_desc); const StreamParamsVec& streams = media_desc->streams(); // Single stream. ASSERT_EQ(streams.size(), 1u); // Stream should have 6 ssrcs: 3 for video, 3 for RTX. EXPECT_EQ(streams[0].ssrcs.size(), 6u); // And should have a SIM group for the simulcast. EXPECT_TRUE(streams[0].has_ssrc_group("SIM")); // And a FID group for RTX. EXPECT_TRUE(streams[0].has_ssrc_group("FID")); std::vector primary_ssrcs; streams[0].GetPrimarySsrcs(&primary_ssrcs); EXPECT_EQ(primary_ssrcs.size(), 3u); std::vector fid_ssrcs; streams[0].GetFidSsrcs(primary_ssrcs, &fid_ssrcs); EXPECT_EQ(fid_ssrcs.size(), 3u); } class MediaSessionDescriptionFactoryFecTest : public MediaSessionDescriptionFactoryTest { public: MediaSessionDescriptionFactoryFecTest() : MediaSessionDescriptionFactoryTest("WebRTC-FlexFEC-03/Enabled/") {} }; // Test that, when the FlexFEC codec is added, a FlexFEC ssrc is created // together with a FEC-FR grouping. Guarded by WebRTC-FlexFEC-03 trial. TEST_F(MediaSessionDescriptionFactoryFecTest, GenerateFlexfecSsrc) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); // Add single stream. AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, "stream1", {"stream1label"}, 1, &opts); // Use a single real codec, and then add FlexFEC for it. std::vector f1_codecs; f1_codecs.push_back(CreateVideoCodec(97, "H264")); f1_codecs.push_back(CreateVideoCodec(118, "flexfec-03")); codec_lookup_helper_1_.SetVideoCodecs(f1_codecs); // Ensure that the offer has a single FlexFEC ssrc and that // there is no FEC-FR ssrc + grouping for each. std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); MediaContentDescription* media_desc = offer->GetContentDescriptionByName(kVideoMid); ASSERT_TRUE(media_desc); const StreamParamsVec& streams = media_desc->streams(); // Single stream. ASSERT_EQ(streams.size(), 1u); // Stream should have 2 ssrcs: 1 for video, 1 for FlexFEC. EXPECT_EQ(streams[0].ssrcs.size(), 2u); // And should have a FEC-FR group for FlexFEC. EXPECT_TRUE(streams[0].has_ssrc_group("FEC-FR")); std::vector primary_ssrcs; streams[0].GetPrimarySsrcs(&primary_ssrcs); ASSERT_EQ(primary_ssrcs.size(), 1u); uint32_t flexfec_ssrc; EXPECT_TRUE(streams[0].GetFecFrSsrc(primary_ssrcs[0], &flexfec_ssrc)); EXPECT_NE(flexfec_ssrc, 0u); } // Test that FlexFEC is disabled for simulcast. // TODO(brandtr): Remove this test when we support simulcast, either through // multiple FlexfecSenders, or through multistream protection. TEST_F(MediaSessionDescriptionFactoryFecTest, SimSsrcsGenerateNoFlexfecSsrcs) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); // Add simulcast streams. AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, "stream1", {"stream1label"}, 3, &opts); // Use a single real codec, and then add FlexFEC for it. std::vector f1_codecs; f1_codecs.push_back(CreateVideoCodec(97, "H264")); f1_codecs.push_back(CreateVideoCodec(118, "flexfec-03")); codec_lookup_helper_1_.SetVideoCodecs(f1_codecs); // Ensure that the offer has no FlexFEC ssrcs for each regular ssrc, and that // there is no FEC-FR ssrc + grouping for each. std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); MediaContentDescription* media_desc = offer->GetContentDescriptionByName(kVideoMid); ASSERT_TRUE(media_desc); const StreamParamsVec& streams = media_desc->streams(); // Single stream. ASSERT_EQ(streams.size(), 1u); // Stream should have 3 ssrcs: 3 for video, 0 for FlexFEC. EXPECT_EQ(streams[0].ssrcs.size(), 3u); // And should have a SIM group for the simulcast. EXPECT_TRUE(streams[0].has_ssrc_group("SIM")); // And not a FEC-FR group for FlexFEC. EXPECT_FALSE(streams[0].has_ssrc_group("FEC-FR")); std::vector primary_ssrcs; streams[0].GetPrimarySsrcs(&primary_ssrcs); EXPECT_EQ(primary_ssrcs.size(), 3u); for (uint32_t primary_ssrc : primary_ssrcs) { uint32_t flexfec_ssrc; EXPECT_FALSE(streams[0].GetFecFrSsrc(primary_ssrc, &flexfec_ssrc)); } } // Create an updated offer after creating an answer to the original offer and // verify that the RTP header extensions that were part of the original answer // are not changed in the updated offer. TEST_F(MediaSessionDescriptionFactoryTest, RespondentCreatesOfferAfterCreatingAnswerWithRtpExtensions) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); SetAudioVideoRtpHeaderExtensions(kAudioRtpExtension1, kVideoRtpExtension1, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); SetAudioVideoRtpHeaderExtensions(kAudioRtpExtension2, kVideoRtpExtension2, &opts); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); EXPECT_THAT( GetFirstAudioContentDescription(answer.get())->rtp_header_extensions(), UnorderedElementsAreArray(kAudioRtpExtensionAnswer)); EXPECT_THAT( GetFirstVideoContentDescription(answer.get())->rtp_header_extensions(), UnorderedElementsAreArray(kVideoRtpExtensionAnswer)); std::unique_ptr updated_offer( f2_.CreateOfferOrError(opts, answer.get()).MoveValue()); // The expected RTP header extensions in the new offer are the resulting // extensions from the first offer/answer exchange plus the extensions only // `f2_` offer. // Since the default local extension id `f2_` uses has already been used by // `f1_` for another extensions, it is changed to 13. const std::vector kUpdatedAudioRtpExtensions = { kAudioRtpExtensionAnswer[0], RtpExtension(kAudioRtpExtension2[1].uri, 13), kAudioRtpExtension2[2], }; // Since the default local extension id `f2_` uses has already been used by // `f1_` for another extensions, is is changed to 12. const std::vector kUpdatedVideoRtpExtensions = { kVideoRtpExtensionAnswer[0], RtpExtension(kVideoRtpExtension2[1].uri, 12), kVideoRtpExtension2[2], }; const AudioContentDescription* updated_acd = GetFirstAudioContentDescription(updated_offer.get()); EXPECT_THAT(updated_acd->rtp_header_extensions(), UnorderedElementsAreArray(kUpdatedAudioRtpExtensions)); const VideoContentDescription* updated_vcd = GetFirstVideoContentDescription(updated_offer.get()); EXPECT_THAT(updated_vcd->rtp_header_extensions(), UnorderedElementsAreArray(kUpdatedVideoRtpExtensions)); } // Verify that if the same RTP extension URI is used for audio and video, the // same ID is used. Also verify that the ID isn't changed when creating an // updated offer (this was previously a bug). TEST_F(MediaSessionDescriptionFactoryTest, RtpExtensionIdReused) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); SetAudioVideoRtpHeaderExtensions(kAudioRtpExtension3, kVideoRtpExtension3, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); // Since the audio extensions used ID 3 for "both_audio_and_video", so should // the video extensions. const std::vector kExpectedVideoRtpExtension = { kVideoRtpExtension3[0], kAudioRtpExtension3[1], }; EXPECT_THAT( GetFirstAudioContentDescription(offer.get())->rtp_header_extensions(), UnorderedElementsAreArray(kAudioRtpExtension3)); EXPECT_THAT( GetFirstVideoContentDescription(offer.get())->rtp_header_extensions(), UnorderedElementsAreArray(kExpectedVideoRtpExtension)); // Nothing should change when creating a new offer std::unique_ptr updated_offer( f1_.CreateOfferOrError(opts, offer.get()).MoveValue()); EXPECT_THAT(GetFirstAudioContentDescription(updated_offer.get()) ->rtp_header_extensions(), UnorderedElementsAreArray(kAudioRtpExtension3)); EXPECT_THAT(GetFirstVideoContentDescription(updated_offer.get()) ->rtp_header_extensions(), UnorderedElementsAreArray(kExpectedVideoRtpExtension)); } TEST_F(MediaSessionDescriptionFactoryTest, CopySessionDescription) { SessionDescription source; ContentGroup group(kAudioMid); source.AddGroup(group); std::unique_ptr acd = std::make_unique(); acd->set_codecs( std::vector(kAudioCodecs1.begin(), kAudioCodecs1.end())); acd->AddLegacyStream(1); source.AddContent(kAudioMid, MediaProtocolType::kRtp, acd->Clone()); std::unique_ptr vcd = std::make_unique(); vcd->set_codecs( std::vector(kVideoCodecs1.begin(), kVideoCodecs1.end())); vcd->AddLegacyStream(2); source.AddContent(kVideoMid, MediaProtocolType::kRtp, vcd->Clone()); std::unique_ptr copy = source.Clone(); ASSERT_TRUE(copy.get()); EXPECT_TRUE(copy->HasGroup(kAudioMid)); const ContentInfo* ac = copy->GetContentByName(kAudioMid); const ContentInfo* vc = copy->GetContentByName(kVideoMid); ASSERT_TRUE(ac); ASSERT_TRUE(vc); EXPECT_EQ(ac->type, MediaProtocolType::kRtp); const MediaContentDescription* acd_copy = ac->media_description(); EXPECT_THAT(acd_copy->codecs(), CodecListsMatch(acd->codecs(), &env_.field_trials())); EXPECT_EQ(acd->first_ssrc(), 1u); EXPECT_EQ(vc->type, MediaProtocolType::kRtp); const MediaContentDescription* vcd_copy = vc->media_description(); EXPECT_THAT(vcd_copy->codecs(), CodecListsMatch(vcd->codecs(), &env_.field_trials())); EXPECT_EQ(vcd->first_ssrc(), 2u); } // The below TestTransportInfoXXX tests create different offers/answers, and // ensure the TransportInfo in the SessionDescription matches what we expect. TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoOfferAudio) { MediaSessionOptions options; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kRecvOnly, kActive, &options); TestTransportInfo(true, options, false); } TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoOfferIceRenomination) { MediaSessionOptions options; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kRecvOnly, kActive, &options); options.media_description_options[0] .transport_options.enable_ice_renomination = true; TestTransportInfo(true, options, false); } TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoOfferAudioCurrent) { MediaSessionOptions options; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kRecvOnly, kActive, &options); TestTransportInfo(true, options, true); } TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoOfferMultimedia) { MediaSessionOptions options; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &options); TestTransportInfo(true, options, false); } TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoOfferMultimediaCurrent) { MediaSessionOptions options; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &options); TestTransportInfo(true, options, true); } TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoOfferBundle) { MediaSessionOptions options; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &options); options.bundle_enabled = true; TestTransportInfo(true, options, false); } TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoOfferBundleCurrent) { MediaSessionOptions options; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &options); options.bundle_enabled = true; TestTransportInfo(true, options, true); } TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoAnswerAudio) { MediaSessionOptions options; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kRecvOnly, kActive, &options); TestTransportInfo(false, options, false); } TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoAnswerIceRenomination) { MediaSessionOptions options; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kRecvOnly, kActive, &options); options.media_description_options[0] .transport_options.enable_ice_renomination = true; TestTransportInfo(false, options, false); } TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoAnswerAudioCurrent) { MediaSessionOptions options; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kRecvOnly, kActive, &options); TestTransportInfo(false, options, true); } TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoAnswerMultimedia) { MediaSessionOptions options; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &options); TestTransportInfo(false, options, false); } TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoAnswerMultimediaCurrent) { MediaSessionOptions options; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &options); TestTransportInfo(false, options, true); } TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoAnswerBundle) { MediaSessionOptions options; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &options); options.bundle_enabled = true; TestTransportInfo(false, options, false); } TEST_F(MediaSessionDescriptionFactoryTest, TestTransportInfoAnswerBundleCurrent) { MediaSessionOptions options; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &options); options.bundle_enabled = true; TestTransportInfo(false, options, true); } // Offers UDP/TLS/RTP/SAVPF and verifies the answer can be created and contains // UDP/TLS/RTP/SAVPF. TEST_F(MediaSessionDescriptionFactoryTest, TestOfferDtlsSavpfCreateAnswer) { std::unique_ptr offer = f1_.CreateOfferOrError(CreateAudioMediaSession(), nullptr).MoveValue(); ASSERT_TRUE(offer.get()); ContentInfo* offer_content = offer->GetContentByName(kAudioMid); ASSERT_TRUE(offer_content); MediaContentDescription* offer_audio_desc = offer_content->media_description(); offer_audio_desc->set_protocol(kMediaProtocolDtlsSavpf); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), CreateAudioMediaSession(), nullptr) .MoveValue(); ASSERT_THAT(answer, NotNull()); const ContentInfo* answer_content = answer->GetContentByName(kAudioMid); ASSERT_TRUE(answer_content); ASSERT_FALSE(answer_content->rejected); const MediaContentDescription* answer_audio_desc = answer_content->media_description(); EXPECT_EQ(answer_audio_desc->protocol(), kMediaProtocolDtlsSavpf); } // Test that we accept a DTLS offer without SDES and create an appropriate // answer. TEST_F(MediaSessionDescriptionFactoryTest, TestCryptoOfferDtlsButNotSdes) { /* TODO(hta): Figure this one out. f1_.set_secure(SEC_DISABLED); f2_.set_secure(SEC_ENABLED); tdf1_.set_secure(SEC_ENABLED); tdf2_.set_secure(SEC_ENABLED); */ MediaSessionOptions options; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &options); // Generate an offer with DTLS std::unique_ptr offer = f1_.CreateOfferOrError(options, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const TransportDescription* audio_offer_trans_desc = offer->GetTransportDescriptionByName(kAudioMid); ASSERT_TRUE(audio_offer_trans_desc->identity_fingerprint.get()); const TransportDescription* video_offer_trans_desc = offer->GetTransportDescriptionByName(kVideoMid); ASSERT_TRUE(video_offer_trans_desc->identity_fingerprint.get()); // Generate an answer with DTLS. std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), options, nullptr).MoveValue(); ASSERT_TRUE(answer.get()); const TransportDescription* audio_answer_trans_desc = answer->GetTransportDescriptionByName(kAudioMid); EXPECT_TRUE(audio_answer_trans_desc->identity_fingerprint.get()); const TransportDescription* video_answer_trans_desc = answer->GetTransportDescriptionByName(kVideoMid); EXPECT_TRUE(video_answer_trans_desc->identity_fingerprint.get()); } // Verifies if vad_enabled option is set to false, CN codecs are not present in // offer or answer. TEST_F(MediaSessionDescriptionFactoryTest, TestVADEnableOption) { MediaSessionOptions options; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &options); std::unique_ptr offer = f1_.CreateOfferOrError(options, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* audio_content = offer->GetContentByName(kAudioMid); EXPECT_FALSE(VerifyNoCNCodecs(audio_content)); options.vad_enabled = false; offer = f1_.CreateOfferOrError(options, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); audio_content = offer->GetContentByName(kAudioMid); EXPECT_TRUE(VerifyNoCNCodecs(audio_content)); std::unique_ptr answer = f1_.CreateAnswerOrError(offer.get(), options, nullptr).MoveValue(); ASSERT_TRUE(answer.get()); audio_content = answer->GetContentByName(kAudioMid); EXPECT_TRUE(VerifyNoCNCodecs(audio_content)); } // Test that the generated MIDs match the existing offer. TEST_F(MediaSessionDescriptionFactoryTest, TestMIDsMatchesExistingOffer) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::AUDIO, "audio_modified", RtpTransceiverDirection::kRecvOnly, kActive, &opts); AddMediaDescriptionOptions(MediaType::VIDEO, "video_modified", RtpTransceiverDirection::kRecvOnly, kActive, &opts); AddMediaDescriptionOptions(MediaType::DATA, "data_modified", RtpTransceiverDirection::kSendRecv, kActive, &opts); // Create offer. std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); std::unique_ptr updated_offer( f1_.CreateOfferOrError(opts, offer.get()).MoveValue()); const ContentInfo* audio_content = GetFirstAudioContent(updated_offer.get()); const ContentInfo* video_content = GetFirstVideoContent(updated_offer.get()); const ContentInfo* data_content = GetFirstDataContent(updated_offer.get()); ASSERT_TRUE(audio_content); ASSERT_TRUE(video_content); ASSERT_TRUE(data_content); EXPECT_EQ(audio_content->mid(), "audio_modified"); EXPECT_EQ(video_content->mid(), "video_modified"); EXPECT_EQ(data_content->mid(), "data_modified"); } // The following tests verify that the unified plan SDP is supported. // Test that we can create an offer with multiple media sections of same media // type. TEST_F(MediaSessionDescriptionFactoryTest, CreateOfferWithMultipleAVMediaSections) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::AUDIO, "audio_1", RtpTransceiverDirection::kSendRecv, kActive, &opts); AttachSenderToMediaDescriptionOptions( "audio_1", MediaType::AUDIO, kAudioTrack1, {kMediaStream1}, 1, &opts); AddMediaDescriptionOptions(MediaType::VIDEO, "video_1", RtpTransceiverDirection::kSendRecv, kActive, &opts); AttachSenderToMediaDescriptionOptions( "video_1", MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts); AddMediaDescriptionOptions(MediaType::AUDIO, "audio_2", RtpTransceiverDirection::kSendRecv, kActive, &opts); AttachSenderToMediaDescriptionOptions( "audio_2", MediaType::AUDIO, kAudioTrack2, {kMediaStream2}, 1, &opts); AddMediaDescriptionOptions(MediaType::VIDEO, "video_2", RtpTransceiverDirection::kSendRecv, kActive, &opts); AttachSenderToMediaDescriptionOptions( "video_2", MediaType::VIDEO, kVideoTrack2, {kMediaStream2}, 1, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); ASSERT_EQ(offer->contents().size(), 4u); EXPECT_FALSE(offer->contents()[0].rejected); const MediaContentDescription* acd = offer->contents()[0].media_description(); ASSERT_EQ(acd->streams().size(), 1u); EXPECT_EQ(acd->streams()[0].id, kAudioTrack1); EXPECT_EQ(acd->direction(), RtpTransceiverDirection::kSendRecv); EXPECT_FALSE(offer->contents()[1].rejected); const MediaContentDescription* vcd = offer->contents()[1].media_description(); ASSERT_EQ(vcd->streams().size(), 1u); EXPECT_EQ(vcd->streams()[0].id, kVideoTrack1); EXPECT_EQ(vcd->direction(), RtpTransceiverDirection::kSendRecv); EXPECT_FALSE(offer->contents()[2].rejected); acd = offer->contents()[2].media_description(); ASSERT_EQ(acd->streams().size(), 1u); EXPECT_EQ(acd->streams()[0].id, kAudioTrack2); EXPECT_EQ(acd->direction(), RtpTransceiverDirection::kSendRecv); EXPECT_FALSE(offer->contents()[3].rejected); vcd = offer->contents()[3].media_description(); ASSERT_EQ(vcd->streams().size(), 1u); EXPECT_EQ(vcd->streams()[0].id, kVideoTrack2); EXPECT_EQ(vcd->direction(), RtpTransceiverDirection::kSendRecv); } // Test that we can create an answer with multiple media sections of same media // type. TEST_F(MediaSessionDescriptionFactoryTest, CreateAnswerWithMultipleAVMediaSections) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::AUDIO, "audio_1", RtpTransceiverDirection::kSendRecv, kActive, &opts); AttachSenderToMediaDescriptionOptions( "audio_1", MediaType::AUDIO, kAudioTrack1, {kMediaStream1}, 1, &opts); AddMediaDescriptionOptions(MediaType::VIDEO, "video_1", RtpTransceiverDirection::kSendRecv, kActive, &opts); AttachSenderToMediaDescriptionOptions( "video_1", MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts); AddMediaDescriptionOptions(MediaType::AUDIO, "audio_2", RtpTransceiverDirection::kSendRecv, kActive, &opts); AttachSenderToMediaDescriptionOptions( "audio_2", MediaType::AUDIO, kAudioTrack2, {kMediaStream2}, 1, &opts); AddMediaDescriptionOptions(MediaType::VIDEO, "video_2", RtpTransceiverDirection::kSendRecv, kActive, &opts); AttachSenderToMediaDescriptionOptions( "video_2", MediaType::VIDEO, kVideoTrack2, {kMediaStream2}, 1, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); ASSERT_EQ(answer->contents().size(), 4u); EXPECT_FALSE(answer->contents()[0].rejected); const MediaContentDescription* acd = answer->contents()[0].media_description(); ASSERT_EQ(acd->streams().size(), 1u); EXPECT_EQ(acd->streams()[0].id, kAudioTrack1); EXPECT_EQ(acd->direction(), RtpTransceiverDirection::kSendRecv); EXPECT_FALSE(answer->contents()[1].rejected); const MediaContentDescription* vcd = answer->contents()[1].media_description(); ASSERT_EQ(vcd->streams().size(), 1u); EXPECT_EQ(vcd->streams()[0].id, kVideoTrack1); EXPECT_EQ(vcd->direction(), RtpTransceiverDirection::kSendRecv); EXPECT_FALSE(answer->contents()[2].rejected); acd = answer->contents()[2].media_description(); ASSERT_EQ(acd->streams().size(), 1u); EXPECT_EQ(acd->streams()[0].id, kAudioTrack2); EXPECT_EQ(acd->direction(), RtpTransceiverDirection::kSendRecv); EXPECT_FALSE(answer->contents()[3].rejected); vcd = answer->contents()[3].media_description(); ASSERT_EQ(vcd->streams().size(), 1u); EXPECT_EQ(vcd->streams()[0].id, kVideoTrack2); EXPECT_EQ(vcd->direction(), RtpTransceiverDirection::kSendRecv); } // Test that the media section will be rejected in offer if the corresponding // MediaDescriptionOptions is stopped by the offerer. TEST_F(MediaSessionDescriptionFactoryTest, CreateOfferWithMediaSectionStoppedByOfferer) { // Create an offer with two audio sections and one of them is stopped. MediaSessionOptions offer_opts; AddMediaDescriptionOptions(MediaType::AUDIO, "audio1", RtpTransceiverDirection::kSendRecv, kActive, &offer_opts); AddMediaDescriptionOptions(MediaType::AUDIO, "audio2", RtpTransceiverDirection::kInactive, kStopped, &offer_opts); std::unique_ptr offer = f1_.CreateOfferOrError(offer_opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); ASSERT_EQ(offer->contents().size(), 2u); EXPECT_FALSE(offer->contents()[0].rejected); EXPECT_TRUE(offer->contents()[1].rejected); } // Test that the media section will be rejected in answer if the corresponding // MediaDescriptionOptions is stopped by the offerer. TEST_F(MediaSessionDescriptionFactoryTest, CreateAnswerWithMediaSectionStoppedByOfferer) { // Create an offer with two audio sections and one of them is stopped. MediaSessionOptions offer_opts; AddMediaDescriptionOptions(MediaType::AUDIO, "audio1", RtpTransceiverDirection::kSendRecv, kActive, &offer_opts); AddMediaDescriptionOptions(MediaType::AUDIO, "audio2", RtpTransceiverDirection::kInactive, kStopped, &offer_opts); std::unique_ptr offer = f1_.CreateOfferOrError(offer_opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); ASSERT_EQ(offer->contents().size(), 2u); EXPECT_FALSE(offer->contents()[0].rejected); EXPECT_TRUE(offer->contents()[1].rejected); // Create an answer based on the offer. MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::AUDIO, "audio1", RtpTransceiverDirection::kSendRecv, kActive, &answer_opts); AddMediaDescriptionOptions(MediaType::AUDIO, "audio2", RtpTransceiverDirection::kSendRecv, kActive, &answer_opts); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), answer_opts, nullptr).MoveValue(); ASSERT_EQ(answer->contents().size(), 2u); EXPECT_FALSE(answer->contents()[0].rejected); EXPECT_TRUE(answer->contents()[1].rejected); } // Test that the media section will be rejected in answer if the corresponding // MediaDescriptionOptions is stopped by the answerer. TEST_F(MediaSessionDescriptionFactoryTest, CreateAnswerWithMediaSectionRejectedByAnswerer) { // Create an offer with two audio sections. MediaSessionOptions offer_opts; AddMediaDescriptionOptions(MediaType::AUDIO, "audio1", RtpTransceiverDirection::kSendRecv, kActive, &offer_opts); AddMediaDescriptionOptions(MediaType::AUDIO, "audio2", RtpTransceiverDirection::kSendRecv, kActive, &offer_opts); std::unique_ptr offer = f1_.CreateOfferOrError(offer_opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); ASSERT_EQ(offer->contents().size(), 2u); ASSERT_FALSE(offer->contents()[0].rejected); ASSERT_FALSE(offer->contents()[1].rejected); // The answerer rejects one of the audio sections. MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::AUDIO, "audio1", RtpTransceiverDirection::kSendRecv, kActive, &answer_opts); AddMediaDescriptionOptions(MediaType::AUDIO, "audio2", RtpTransceiverDirection::kInactive, kStopped, &answer_opts); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), answer_opts, nullptr).MoveValue(); ASSERT_EQ(answer->contents().size(), 2u); EXPECT_FALSE(answer->contents()[0].rejected); EXPECT_TRUE(answer->contents()[1].rejected); // The TransportInfo of the rejected m= section is expected to be added in the // answer. EXPECT_EQ(offer->transport_infos().size(), answer->transport_infos().size()); } // Test the generated media sections has the same order of the // corresponding MediaDescriptionOptions. TEST_F(MediaSessionDescriptionFactoryTest, CreateOfferRespectsMediaDescriptionOptionsOrder) { MediaSessionOptions opts; // This tests put video section first because normally audio comes first by // default. AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); ASSERT_EQ(offer->contents().size(), 2u); EXPECT_EQ(offer->contents()[0].mid(), kVideoMid); EXPECT_EQ(offer->contents()[1].mid(), kAudioMid); } // Test that different media sections using the same codec have same payload // type. TEST_F(MediaSessionDescriptionFactoryTest, PayloadTypesSharedByMediaSectionsOfSameType) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, "video1", RtpTransceiverDirection::kSendRecv, kActive, &opts); AddMediaDescriptionOptions(MediaType::VIDEO, "video2", RtpTransceiverDirection::kSendRecv, kActive, &opts); // Create an offer with two video sections using same codecs. std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); ASSERT_EQ(offer->contents().size(), 2u); const MediaContentDescription* vcd1 = offer->contents()[0].media_description(); const MediaContentDescription* vcd2 = offer->contents()[1].media_description(); EXPECT_EQ(vcd1->codecs().size(), vcd2->codecs().size()); ASSERT_EQ(vcd1->codecs().size(), 2u); EXPECT_EQ(vcd1->codecs()[0].name, vcd2->codecs()[0].name); EXPECT_EQ(vcd1->codecs()[0].id, vcd2->codecs()[0].id); EXPECT_EQ(vcd1->codecs()[1].name, vcd2->codecs()[1].name); EXPECT_EQ(vcd1->codecs()[1].id, vcd2->codecs()[1].id); // Create answer and negotiate the codecs. std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); ASSERT_THAT(answer, NotNull()); ASSERT_EQ(answer->contents().size(), 2u); vcd1 = answer->contents()[0].media_description(); vcd2 = answer->contents()[1].media_description(); EXPECT_EQ(vcd1->codecs().size(), vcd2->codecs().size()); ASSERT_EQ(vcd1->codecs().size(), 1u); EXPECT_EQ(vcd1->codecs()[0].name, vcd2->codecs()[0].name); EXPECT_EQ(vcd1->codecs()[0].id, vcd2->codecs()[0].id); } // Parameterized Sframe tests over MediaType::AUDIO and MediaType::VIDEO. // The offer/answer Sframe logic is identical for both media types. class SframeMediaTypeTest : public MediaSessionDescriptionFactoryTest, public ::testing::WithParamInterface { protected: static constexpr auto kTestMid = "sframe_test"; // Creates MediaSessionOptions with a single recv-only media section // for the parameterized media type. MediaSessionOptions CreateMediaSession() { MediaSessionOptions opts; AddMediaDescriptionOptions(GetParam(), kTestMid, RtpTransceiverDirection::kRecvOnly, kActive, &opts); return opts; } }; TEST_P(SframeMediaTypeTest, OfferWithoutSframeHasSframeEnabledFalse) { MediaSessionOptions opts = CreateMediaSession(); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); ASSERT_EQ(offer->contents().size(), 1u); EXPECT_FALSE(offer->contents()[0].media_description()->sframe_enabled()); } TEST_P(SframeMediaTypeTest, OfferWithSframeHasSframeEnabledTrue) { MediaSessionOptions opts = CreateMediaSession(); opts.media_description_options[0].sframe_enabled = true; std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); ASSERT_EQ(offer->contents().size(), 1u); EXPECT_TRUE(offer->contents()[0].media_description()->sframe_enabled()); } TEST_P(SframeMediaTypeTest, AnswerWithoutSframeHasSframeEnabledFalse) { MediaSessionOptions opts = CreateMediaSession(); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); ASSERT_THAT(answer, NotNull()); ASSERT_EQ(answer->contents().size(), 1u); EXPECT_FALSE(answer->contents()[0].media_description()->sframe_enabled()); } TEST_P(SframeMediaTypeTest, AnswerWithSframeHasSframeEnabledTrue) { MediaSessionOptions offer_opts = CreateMediaSession(); offer_opts.media_description_options[0].sframe_enabled = true; std::unique_ptr offer = f1_.CreateOfferOrError(offer_opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); MediaSessionOptions answer_opts = CreateMediaSession(); answer_opts.media_description_options[0].sframe_enabled = true; std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), answer_opts, nullptr).MoveValue(); ASSERT_THAT(answer, NotNull()); ASSERT_EQ(answer->contents().size(), 1u); EXPECT_TRUE(answer->contents()[0].media_description()->sframe_enabled()); } INSTANTIATE_TEST_SUITE_P(Sframe, SframeMediaTypeTest, ::testing::Values(MediaType::AUDIO, MediaType::VIDEO), [](const ::testing::TestParamInfo& info) { return MediaTypeToString(info.param); }); TEST_F(MediaSessionDescriptionFactoryTest, AudioVideoOfferWithoutSframeHasSframeEnabledFalse) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); ASSERT_EQ(offer->contents().size(), 2u); EXPECT_FALSE(offer->contents()[0].media_description()->sframe_enabled()); EXPECT_FALSE(offer->contents()[1].media_description()->sframe_enabled()); } // Verify that in an audio+video offer, Sframe on video does not affect audio. TEST_F(MediaSessionDescriptionFactoryTest, AudioVideoOfferWithSframeHasSframeEnabledTrue) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); opts.media_description_options[1].sframe_enabled = true; std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); ASSERT_EQ(offer->contents().size(), 2u); // Audio should not have Sframe since we only set it on the video section. EXPECT_FALSE(offer->contents()[0].media_description()->sframe_enabled()); EXPECT_TRUE(offer->contents()[1].media_description()->sframe_enabled()); } // Verify that when the offer has Sframe but the answerer does not, // answer creation succeeds and the answer has sframe_enabled=false. // The offerer is responsible for handling the mismatch (per // draft-ietf-avtcore-rtp-sframe-02 §6). TEST_F(MediaSessionDescriptionFactoryTest, AnswerWithoutSframeSucceedsWhenOfferHasSframe) { MediaSessionOptions offer_opts = CreateAudioMediaSession(); offer_opts.media_description_options[0].sframe_enabled = true; std::unique_ptr offer = f1_.CreateOfferOrError(offer_opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); ASSERT_EQ(offer->contents().size(), 1u); EXPECT_TRUE(offer->contents()[0].media_description()->sframe_enabled()); // Answerer does NOT set sframe_enabled — answer creation should succeed. MediaSessionOptions answer_opts = CreateAudioMediaSession(); auto result = f2_.CreateAnswerOrError(offer.get(), answer_opts, nullptr); ASSERT_TRUE(result.ok()); ASSERT_EQ(result.value()->contents().size(), 1u); EXPECT_FALSE( result.value()->contents()[0].media_description()->sframe_enabled()); } // Verify that when the answerer wants Sframe but the offer does not have it, // the answer must NOT include a=sframe (RFC 3264: answer is constrained by // the offer). TEST_F(MediaSessionDescriptionFactoryTest, AnswerDoesNotInjectSframeWhenOfferLacksIt) { MediaSessionOptions offer_opts = CreateAudioMediaSession(); std::unique_ptr offer = f1_.CreateOfferOrError(offer_opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); ASSERT_EQ(offer->contents().size(), 1u); EXPECT_FALSE(offer->contents()[0].media_description()->sframe_enabled()); MediaSessionOptions answer_opts = CreateAudioMediaSession(); answer_opts.media_description_options[0].sframe_enabled = true; auto result = f2_.CreateAnswerOrError(offer.get(), answer_opts, nullptr); ASSERT_TRUE(result.ok()); ASSERT_EQ(result.value()->contents().size(), 1u); EXPECT_FALSE( result.value()->contents()[0].media_description()->sframe_enabled()); } TEST_F(MediaSessionDescriptionFactoryTest, OfferSframeIsPerMediaSection) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); // Enable Sframe on audio only. opts.media_description_options[0].sframe_enabled = true; opts.media_description_options[1].sframe_enabled = false; std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); ASSERT_EQ(offer->contents().size(), 2u); EXPECT_TRUE(offer->contents()[0].media_description()->sframe_enabled()); EXPECT_FALSE(offer->contents()[1].media_description()->sframe_enabled()); } TEST_F(MediaSessionDescriptionFactoryTest, AnswerSframeIsPerMediaSection) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); // Only audio has Sframe in the offer. opts.media_description_options[0].sframe_enabled = true; opts.media_description_options[1].sframe_enabled = false; std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); // The answerer's options must agree with the offer per section. MediaSessionOptions answer_opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &answer_opts); answer_opts.media_description_options[0].sframe_enabled = true; answer_opts.media_description_options[1].sframe_enabled = false; std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), answer_opts, nullptr).MoveValue(); ASSERT_THAT(answer, NotNull()); ASSERT_EQ(answer->contents().size(), 2u); EXPECT_TRUE(answer->contents()[0].media_description()->sframe_enabled()); EXPECT_FALSE(answer->contents()[1].media_description()->sframe_enabled()); } #ifdef RTC_ENABLE_H265 // Test verifying that negotiating codecs with the same tx-mode retains the // tx-mode value. TEST_F(MediaSessionDescriptionFactoryTest, H265TxModeIsEqualRetainIt) { std::vector f1_codecs = {CreateVideoCodec(96, "H265")}; f1_codecs.back().tx_mode = "mrst"; codec_lookup_helper_1_.SetVideoCodecs(f1_codecs); std::vector f2_codecs = {CreateVideoCodec(96, "H265")}; f2_codecs.back().tx_mode = "mrst"; codec_lookup_helper_2_.SetVideoCodecs(f2_codecs); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, "video1", RtpTransceiverDirection::kSendRecv, kActive, &opts); // Create an offer with two video sections using same codecs. std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); ASSERT_EQ(offer->contents().size(), 1u); const MediaContentDescription* vcd1 = offer->contents()[0].media_description(); ASSERT_EQ(vcd1->codecs().size(), 1u); EXPECT_EQ(vcd1->codecs()[0].tx_mode, "mrst"); // Create answer and negotiate the codecs. std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); ASSERT_THAT(answer, NotNull()); ASSERT_EQ(answer->contents().size(), 1u); vcd1 = answer->contents()[0].media_description(); ASSERT_EQ(vcd1->codecs().size(), 1u); EXPECT_EQ(vcd1->codecs()[0].tx_mode, "mrst"); } // Test verifying that negotiating codecs with different tx_mode removes // the tx_mode value. TEST_F(MediaSessionDescriptionFactoryTest, H265TxModeIsDifferentDropCodecs) { std::vector f1_codecs = {CreateVideoCodec(96, "H265")}; f1_codecs.back().tx_mode = "mrst"; codec_lookup_helper_1_.SetVideoCodecs(f1_codecs); std::vector f2_codecs = {CreateVideoCodec(96, "H265")}; f2_codecs.back().tx_mode = "mrmt"; codec_lookup_helper_2_.SetVideoCodecs(f2_codecs); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, "video1", RtpTransceiverDirection::kSendRecv, kActive, &opts); // Create an offer with two video sections using same codecs. std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); ASSERT_EQ(offer->contents().size(), 1u); const VideoContentDescription* vcd1 = offer->contents()[0].media_description()->as_video(); ASSERT_EQ(vcd1->codecs().size(), 1u); EXPECT_EQ(vcd1->codecs()[0].tx_mode, "mrst"); // Create answer and negotiate the codecs. std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); ASSERT_THAT(answer, NotNull()); ASSERT_EQ(answer->contents().size(), 1u); vcd1 = answer->contents()[0].media_description()->as_video(); ASSERT_EQ(vcd1->codecs().size(), 1u); EXPECT_EQ(vcd1->codecs()[0].tx_mode, std::nullopt); } #endif // Test verifying that negotiating codecs with the same packetization retains // the packetization value. TEST_F(MediaSessionDescriptionFactoryTest, PacketizationIsEqual) { std::vector f1_codecs = {CreateVideoCodec(96, "H264")}; f1_codecs.back().packetization = "raw"; codec_lookup_helper_1_.SetVideoCodecs(f1_codecs); std::vector f2_codecs = {CreateVideoCodec(96, "H264")}; f2_codecs.back().packetization = "raw"; codec_lookup_helper_2_.SetVideoCodecs(f2_codecs); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, "video1", RtpTransceiverDirection::kSendRecv, kActive, &opts); // Create an offer with two video sections using same codecs. std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); ASSERT_EQ(offer->contents().size(), 1u); const MediaContentDescription* vcd1 = offer->contents()[0].media_description(); ASSERT_EQ(vcd1->codecs().size(), 1u); EXPECT_EQ(vcd1->codecs()[0].packetization, "raw"); // Create answer and negotiate the codecs. std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); ASSERT_THAT(answer, NotNull()); ASSERT_EQ(answer->contents().size(), 1u); vcd1 = answer->contents()[0].media_description(); ASSERT_EQ(vcd1->codecs().size(), 1u); EXPECT_EQ(vcd1->codecs()[0].packetization, "raw"); } // Test verifying that negotiating codecs with different packetization removes // the packetization value. TEST_F(MediaSessionDescriptionFactoryTest, PacketizationIsDifferent) { std::vector f1_codecs = {CreateVideoCodec(96, "H264")}; f1_codecs.back().packetization = "raw"; codec_lookup_helper_1_.SetVideoCodecs(f1_codecs); std::vector f2_codecs = {CreateVideoCodec(96, "H264")}; f2_codecs.back().packetization = "notraw"; codec_lookup_helper_2_.SetVideoCodecs(f2_codecs); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, "video1", RtpTransceiverDirection::kSendRecv, kActive, &opts); // Create an offer with two video sections using same codecs. std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); ASSERT_EQ(offer->contents().size(), 1u); const VideoContentDescription* vcd1 = offer->contents()[0].media_description()->as_video(); ASSERT_EQ(vcd1->codecs().size(), 1u); EXPECT_EQ(vcd1->codecs()[0].packetization, "raw"); // Create answer and negotiate the codecs. std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); ASSERT_THAT(answer, NotNull()); ASSERT_EQ(answer->contents().size(), 1u); vcd1 = answer->contents()[0].media_description()->as_video(); ASSERT_EQ(vcd1->codecs().size(), 1u); EXPECT_EQ(vcd1->codecs()[0].packetization, std::nullopt); } // Test that the codec preference order per media section is respected in // subsequent offer. TEST_F(MediaSessionDescriptionFactoryTest, CreateOfferRespectsCodecPreferenceOrder) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, "video1", RtpTransceiverDirection::kSendRecv, kActive, &opts); AddMediaDescriptionOptions(MediaType::VIDEO, "video2", RtpTransceiverDirection::kSendRecv, kActive, &opts); // Create an offer with two video sections using same codecs. std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); ASSERT_EQ(offer->contents().size(), 2u); MediaContentDescription* vcd1 = offer->contents()[0].media_description(); const MediaContentDescription* vcd2 = offer->contents()[1].media_description(); auto video_codecs = kVideoCodecs1; EXPECT_THAT(vcd1->codecs(), CodecListsMatch(video_codecs, &env_.field_trials())); EXPECT_THAT(vcd2->codecs(), CodecListsMatch(video_codecs, &env_.field_trials())); // Change the codec preference of the first video section and create a // follow-up offer. auto video_codecs_reverse = kVideoCodecs1Reverse; vcd1->set_codecs(std::vector(video_codecs_reverse.begin(), video_codecs_reverse.end())); std::unique_ptr updated_offer( f1_.CreateOfferOrError(opts, offer.get()).MoveValue()); vcd1 = updated_offer->contents()[0].media_description(); vcd2 = updated_offer->contents()[1].media_description(); // The video codec preference order should be respected. EXPECT_THAT(vcd1->codecs(), CodecListsMatch(video_codecs_reverse, &env_.field_trials())); EXPECT_THAT(vcd2->codecs(), CodecListsMatch(video_codecs, &env_.field_trials())); } // Test that the codec preference order per media section is respected in // the answer. TEST_F(MediaSessionDescriptionFactoryTest, CreateAnswerRespectsCodecPreferenceOrder) { MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, "video1", RtpTransceiverDirection::kSendRecv, kActive, &opts); AddMediaDescriptionOptions(MediaType::VIDEO, "video2", RtpTransceiverDirection::kSendRecv, kActive, &opts); // Create an offer with two video sections using same codecs. std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); ASSERT_EQ(offer->contents().size(), 2u); MediaContentDescription* vcd1 = offer->contents()[0].media_description(); const MediaContentDescription* vcd2 = offer->contents()[1].media_description(); auto video_codecs = kVideoCodecs1; EXPECT_THAT(vcd1->codecs(), CodecListsMatch(video_codecs, &env_.field_trials())); EXPECT_THAT(vcd2->codecs(), CodecListsMatch(video_codecs, &env_.field_trials())); // Change the codec preference of the first video section and create an // answer. auto video_codecs_reverse = kVideoCodecs1Reverse; vcd1->set_codecs(std::vector(video_codecs_reverse.begin(), video_codecs_reverse.end())); std::unique_ptr answer = f1_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); vcd1 = answer->contents()[0].media_description(); vcd2 = answer->contents()[1].media_description(); // The video codec preference order should be respected. EXPECT_THAT(vcd1->codecs(), CodecListsMatch(video_codecs_reverse, &env_.field_trials())); EXPECT_THAT(vcd2->codecs(), CodecListsMatch(video_codecs, &env_.field_trials())); } // Test that when creating an answer, the codecs use local parameters instead of // the remote ones. TEST_F(MediaSessionDescriptionFactoryTest, CreateAnswerWithLocalCodecParams) { const std::string audio_param_name = "audio_param"; const std::string audio_value1 = "audio_v1"; const std::string audio_value2 = "audio_v2"; const std::string video_param_name = "video_param"; const std::string video_value1 = "video_v1"; const std::string video_value2 = "video_v2"; auto audio_codecs1 = kAudioCodecs1; auto audio_codecs2 = kAudioCodecs1; auto video_codecs1 = kVideoCodecs1; auto video_codecs2 = kVideoCodecs1; // Set the parameters for codecs. audio_codecs1[0].SetParam(audio_param_name, audio_value1); video_codecs1[0].SetParam(video_param_name, video_value1); audio_codecs2[0].SetParam(audio_param_name, audio_value2); video_codecs2[0].SetParam(video_param_name, video_value2); codec_lookup_helper_1_.SetAudioCodecs(audio_codecs1); codec_lookup_helper_1_.SetVideoCodecs(video_codecs1); codec_lookup_helper_2_.SetAudioCodecs(audio_codecs2); codec_lookup_helper_2_.SetVideoCodecs(video_codecs2); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); auto offer_acd = offer->contents()[0].media_description(); auto offer_vcd = offer->contents()[1].media_description(); std::string value; EXPECT_TRUE(offer_acd->codecs()[0].GetParam(audio_param_name, &value)); EXPECT_EQ(audio_value1, value); EXPECT_TRUE(offer_vcd->codecs()[0].GetParam(video_param_name, &value)); EXPECT_EQ(video_value1, value); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); ASSERT_THAT(answer, NotNull()); auto answer_acd = answer->contents()[0].media_description(); auto answer_vcd = answer->contents()[1].media_description(); // Use the parameters from the local codecs. ASSERT_TRUE(answer_acd); ASSERT_THAT(answer_acd->codecs().size(), Gt(0)); EXPECT_TRUE(answer_acd->codecs()[0].GetParam(audio_param_name, &value)); EXPECT_EQ(audio_value2, value); EXPECT_TRUE(answer_vcd->codecs()[0].GetParam(video_param_name, &value)); EXPECT_EQ(video_value2, value); } // Test that matching packetization-mode is part of the criteria for matching // H264 codecs (in addition to profile-level-id). Previously, this was not the // case, so the first H264 codec with the same profile-level-id would match and // the payload type in the answer would be incorrect. // This is a regression test for bugs.webrtc.org/8808 TEST_F(MediaSessionDescriptionFactoryTest, H264MatchCriteriaIncludesPacketizationMode) { // Create two H264 codecs with the same profile level ID and different // packetization modes. Codec h264_pm0 = CreateVideoCodec(96, "H264"); h264_pm0.params[kH264FmtpProfileLevelId] = "42c01f"; h264_pm0.params[kH264FmtpPacketizationMode] = "0"; Codec h264_pm1 = CreateVideoCodec(97, "H264"); h264_pm1.params[kH264FmtpProfileLevelId] = "42c01f"; h264_pm1.params[kH264FmtpPacketizationMode] = "1"; // Offerer will send both codecs, answerer should choose the one with matching // packetization mode (and not the first one it sees). codec_lookup_helper_1_.SetVideoCodecs({h264_pm0, h264_pm1}); codec_lookup_helper_2_.SetVideoCodecs({h264_pm1}); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_THAT(offer, NotNull()); std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); ASSERT_THAT(answer, NotNull()); // Answer should have one negotiated codec with packetization-mode=1 using the // offered payload type. ASSERT_EQ(answer->contents().size(), 1u); auto answer_vcd = answer->contents()[0].media_description(); ASSERT_EQ(answer_vcd->codecs().size(), 1u); auto answer_codec = answer_vcd->codecs()[0]; EXPECT_EQ(h264_pm1.id, answer_codec.id); } class MediaProtocolTest : public testing::TestWithParam { public: MediaProtocolTest() : env_(CreateTestEnvironment()), tdf1_(env_.field_trials()), tdf2_(env_.field_trials()), codec_lookup_helper_1_(env_.field_trials()), codec_lookup_helper_2_(env_.field_trials()), f1_(env_, nullptr, false, &ssrc_generator1, &tdf1_, &sctp_factory_1_, &codec_lookup_helper_1_), f2_(env_, nullptr, false, &ssrc_generator2, &tdf2_, &sctp_factory_2_, &codec_lookup_helper_2_) { codec_lookup_helper_1_.SetAudioCodecs(kAudioCodecs1); codec_lookup_helper_1_.SetVideoCodecs(kVideoCodecs1); codec_lookup_helper_2_.SetAudioCodecs(kAudioCodecs2); codec_lookup_helper_2_.SetVideoCodecs(kVideoCodecs2); tdf1_.set_certificate(RTCCertificate::Create( std::unique_ptr(new FakeSSLIdentity("id1")))); tdf2_.set_certificate(RTCCertificate::Create( std::unique_ptr(new FakeSSLIdentity("id2")))); } protected: Environment env_; TransportDescriptionFactory tdf1_; TransportDescriptionFactory tdf2_; CodecLookupHelperForTesting codec_lookup_helper_1_; CodecLookupHelperForTesting codec_lookup_helper_2_; FakeSctpTransportFactory sctp_factory_1_; FakeSctpTransportFactory sctp_factory_2_; MediaSessionDescriptionFactory f1_; MediaSessionDescriptionFactory f2_; UniqueRandomIdGenerator ssrc_generator1; UniqueRandomIdGenerator ssrc_generator2; }; TEST_P(MediaProtocolTest, TestAudioVideoAcceptance) { MediaSessionOptions opts; AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts); std::unique_ptr offer = f1_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); // Set the protocol for all the contents. for (ContentInfo& content : offer->contents()) { content.media_description()->set_protocol(GetParam()); } std::unique_ptr answer = f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue(); const ContentInfo* ac = answer->GetContentByName(kAudioMid); const ContentInfo* vc = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); ASSERT_TRUE(vc); EXPECT_FALSE(ac->rejected); // the offer is accepted EXPECT_FALSE(vc->rejected); const MediaContentDescription* acd = ac->media_description(); const MediaContentDescription* vcd = vc->media_description(); EXPECT_EQ(GetParam(), acd->protocol()); EXPECT_EQ(GetParam(), vcd->protocol()); } INSTANTIATE_TEST_SUITE_P(MediaProtocolPatternTest, MediaProtocolTest, ValuesIn(kMediaProtocols)); INSTANTIATE_TEST_SUITE_P(MediaProtocolDtlsPatternTest, MediaProtocolTest, ValuesIn(kMediaProtocolsDtls)); void TestAudioCodecsOffer(RtpTransceiverDirection direction) { Environment env(CreateTestEnvironment()); TransportDescriptionFactory tdf(env.field_trials()); tdf.set_certificate(RTCCertificate::Create( std::unique_ptr(new FakeSSLIdentity("id")))); UniqueRandomIdGenerator ssrc_generator; CodecLookupHelperForTesting codec_lookup_helper(env.field_trials()); FakeSctpTransportFactory sctpf; MediaSessionDescriptionFactory sf(env, nullptr, false, &ssrc_generator, &tdf, &sctpf, &codec_lookup_helper); const std::vector send_codecs(kAudioCodecs1.begin(), kAudioCodecs1.end()); const std::vector recv_codecs(kAudioCodecs2.begin(), kAudioCodecs2.end()); const std::vector sendrecv_codecs(kAudioCodecsAnswer.begin(), kAudioCodecsAnswer.end()); codec_lookup_helper.SetAudioCodecs(send_codecs, recv_codecs); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, direction, kActive, &opts); if (direction == RtpTransceiverDirection::kSendRecv || direction == RtpTransceiverDirection::kSendOnly) { AttachSenderToMediaDescriptionOptions( kAudioMid, MediaType::AUDIO, kAudioTrack1, {kMediaStream1}, 1, &opts); } std::unique_ptr offer = sf.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); ContentInfo* ac = offer->GetContentByName(kAudioMid); // If the factory didn't add any audio content to the offer, we cannot check // that the codecs put in are right. This happens when we neither want to // send nor receive audio. The checks are still in place if at some point // we'd instead create an inactive stream. if (ac) { MediaContentDescription* acd = ac->media_description(); // sendrecv and inactive should both present lists as if the channel was // to be used for sending and receiving. Inactive essentially means it // might eventually be used anything, but we don't know more at this // moment. if (acd->direction() == RtpTransceiverDirection::kSendOnly) { EXPECT_THAT(acd->codecs(), CodecListsMatch(send_codecs, &env.field_trials())); } else if (acd->direction() == RtpTransceiverDirection::kRecvOnly) { EXPECT_THAT(acd->codecs(), CodecListsMatch(recv_codecs, &env.field_trials())); } else { EXPECT_THAT(acd->codecs(), CodecListsMatch(sendrecv_codecs, &env.field_trials())); } } } // Since the PT suggester reserves the static range for specific codecs, // PT numbers from the 36-63 range are used. const Codec kOfferAnswerCodecs[] = {CreateAudioCodec(40, "codec0", 16000, 1), CreateAudioCodec(41, "codec1", 8000, 1), CreateAudioCodec(42, "codec2", 8000, 1), CreateAudioCodec(43, "codec3", 8000, 1), CreateAudioCodec(44, "codec4", 8000, 2), CreateAudioCodec(45, "codec5", 32000, 1), CreateAudioCodec(46, "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 * codecs after negotiation, depending on offer and answer communication * directions. One-way directions in the offer should either result in the * opposite direction in the answer, or an inactive answer. Regardless, the * choice of codecs should be as if the answer contained the opposite * direction. Inactive offers should be treated as sendrecv/sendrecv. * * | Offer | Answer | Result * codec|send recv sr | send recv sr | s/r r/s sr/s sr/r sr/sr * 0 | x - - | - x - | x - - - - * 1 | x x x | - x - | x - - x - * 2 | - x - | x - - | - x - - - * 3 | x x x | x - - | - x x - - * 4 | - x - | x x x | - x - - - * 5 | x - - | x x x | x - - - - * 6 | x x x | x x x | x x x x x */ // Codecs used by offerer in the AudioCodecsAnswerTest constexpr int kOfferSendCodecs[] = {0, 1, 3, 5, 6}; constexpr int kOfferRecvCodecs[] = {1, 2, 3, 4, 6}; // Codecs used in the answerer in the AudioCodecsAnswerTest. The order is // jumbled to catch the answer not following the order in the offer. constexpr int kAnswerSendCodecs[] = {6, 5, 2, 3, 4}; constexpr int kAnswerRecvCodecs[] = {6, 5, 4, 1, 0}; // The resulting sets of codecs in the answer in the AudioCodecsAnswerTest constexpr int kResultSend_RecvCodecs[] = {0, 1, 5, 6}; constexpr int kResultRecv_SendCodecs[] = {2, 3, 4, 6}; constexpr int kResultSendrecv_SendCodecs[] = {3, 6}; constexpr int kResultSendrecv_RecvCodecs[] = {1, 6}; constexpr int kResultSendrecv_SendrecvCodecs[] = {6}; template std::vector VectorFromIndices(const T* array, const int (&indices)[IDXS]) { std::vector out; out.reserve(IDXS); for (int idx : indices) out.push_back(array[idx]); return out; } void TestAudioCodecsAnswer(RtpTransceiverDirection offer_direction, RtpTransceiverDirection answer_direction, bool add_legacy_stream) { Environment env(CreateTestEnvironment()); TransportDescriptionFactory offer_tdf(env.field_trials()); TransportDescriptionFactory answer_tdf(env.field_trials()); FakeSctpTransportFactory offer_sctpf; FakeSctpTransportFactory answer_sctpf; offer_tdf.set_certificate(RTCCertificate::Create( std::unique_ptr(new FakeSSLIdentity("offer_id")))); answer_tdf.set_certificate(RTCCertificate::Create( std::unique_ptr(new FakeSSLIdentity("answer_id")))); UniqueRandomIdGenerator ssrc_generator1, ssrc_generator2; CodecLookupHelperForTesting offer_codec_lookup_helper(env.field_trials()); MediaSessionDescriptionFactory offer_factory( env, nullptr, false, &ssrc_generator1, &offer_tdf, &offer_sctpf, &offer_codec_lookup_helper); CodecLookupHelperForTesting answer_codec_lookup_helper(env.field_trials()); MediaSessionDescriptionFactory answer_factory( env, nullptr, false, &ssrc_generator2, &answer_tdf, &answer_sctpf, &answer_codec_lookup_helper); offer_codec_lookup_helper.SetAudioCodecs( VectorFromIndices(kOfferAnswerCodecs, kOfferSendCodecs), VectorFromIndices(kOfferAnswerCodecs, kOfferRecvCodecs)); answer_codec_lookup_helper.SetAudioCodecs( VectorFromIndices(kOfferAnswerCodecs, kAnswerSendCodecs), VectorFromIndices(kOfferAnswerCodecs, kAnswerRecvCodecs)); MediaSessionOptions offer_opts; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, offer_direction, kActive, &offer_opts); if (RtpTransceiverDirectionHasSend(offer_direction)) { AttachSenderToMediaDescriptionOptions(kAudioMid, MediaType::AUDIO, kAudioTrack1, {kMediaStream1}, 1, &offer_opts); } std::unique_ptr offer = offer_factory.CreateOfferOrError(offer_opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::AUDIO, kAudioMid, answer_direction, kActive, &answer_opts); if (RtpTransceiverDirectionHasSend(answer_direction)) { AttachSenderToMediaDescriptionOptions(kAudioMid, MediaType::AUDIO, kAudioTrack1, {kMediaStream1}, 1, &answer_opts); } std::unique_ptr answer = answer_factory.CreateAnswerOrError(offer.get(), answer_opts, nullptr) .MoveValue(); const ContentInfo* ac = answer->GetContentByName(kAudioMid); // If the factory didn't add any audio content to the answer, we cannot // check that the codecs put in are right. This happens when we neither want // to send nor receive audio. The checks are still in place if at some point // we'd instead create an inactive stream. if (ac) { ASSERT_EQ(ac->media_description()->type(), MediaType::AUDIO); const MediaContentDescription* acd = ac->media_description(); 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) { case RtpTransceiverDirection::kInactive: target_codecs = VectorFromIndices(kOfferAnswerCodecs, kResultSendrecv_SendrecvCodecs); break; case RtpTransceiverDirection::kSendOnly: target_codecs = VectorFromIndices(kOfferAnswerCodecs, kResultSend_RecvCodecs); break; case RtpTransceiverDirection::kRecvOnly: target_codecs = VectorFromIndices(kOfferAnswerCodecs, kResultRecv_SendCodecs); break; case RtpTransceiverDirection::kSendRecv: if (acd->direction() == RtpTransceiverDirection::kSendOnly) { target_codecs = VectorFromIndices(kOfferAnswerCodecs, kResultSendrecv_SendCodecs); } else if (acd->direction() == RtpTransceiverDirection::kRecvOnly) { target_codecs = VectorFromIndices(kOfferAnswerCodecs, kResultSendrecv_RecvCodecs); } else { target_codecs = VectorFromIndices(kOfferAnswerCodecs, kResultSendrecv_SendrecvCodecs); } break; case RtpTransceiverDirection::kStopped: // This does not happen in any current test. RTC_DCHECK_NOTREACHED(); } auto format_codecs = [](std::span codecs) { StringBuilder os; bool first = true; os << "{"; for (const Codec& c : codecs) { os << (first ? " " : ", ") << c.id << ":" << c.name; first = false; } os << " }"; return os.Release(); }; EXPECT_THAT(acd->codecs(), CodecListsMatch(target_codecs, &env.field_trials())) << "Expected: " << format_codecs(target_codecs) << ", got: " << format_codecs(acd->codecs()) << "; Offered: " << RtpTransceiverDirectionToString(offer_direction) << ", answerer wants: " << RtpTransceiverDirectionToString(answer_direction) << "; got: " << RtpTransceiverDirectionToString(acd->direction()); } else { EXPECT_EQ(offer_direction, RtpTransceiverDirection::kInactive) << "Only inactive offers are allowed to not generate any audio " "content"; } } using AudioCodecsOfferTest = testing::TestWithParam; TEST_P(AudioCodecsOfferTest, TestCodecsInOffer) { TestAudioCodecsOffer(GetParam()); } INSTANTIATE_TEST_SUITE_P(MediaSessionDescriptionFactoryTest, AudioCodecsOfferTest, Values(RtpTransceiverDirection::kSendOnly, RtpTransceiverDirection::kRecvOnly, RtpTransceiverDirection::kSendRecv, RtpTransceiverDirection::kInactive)); using AudioCodecsAnswerTest = testing::TestWithParam< std::tuple>; TEST_P(AudioCodecsAnswerTest, TestCodecsInAnswer) { TestAudioCodecsAnswer(std::get<0>(GetParam()), std::get<1>(GetParam()), std::get<2>(GetParam())); } INSTANTIATE_TEST_SUITE_P(MediaSessionDescriptionFactoryTest, AudioCodecsAnswerTest, Combine(Values(RtpTransceiverDirection::kSendOnly, RtpTransceiverDirection::kRecvOnly, RtpTransceiverDirection::kSendRecv, RtpTransceiverDirection::kInactive), Values(RtpTransceiverDirection::kSendOnly, RtpTransceiverDirection::kRecvOnly, RtpTransceiverDirection::kSendRecv, RtpTransceiverDirection::kInactive), Bool())); #ifdef RTC_ENABLE_H265 class VideoCodecsOfferH265LevelIdTest : public testing::Test { public: VideoCodecsOfferH265LevelIdTest() : env_(CreateTestEnvironment()), tdf_offerer_(env_.field_trials()), tdf_answerer_(env_.field_trials()), sf_offerer_(env_, nullptr, false, &ssrc_generator_offerer_, &tdf_offerer_, &sctpf_offerer_, &codec_lookup_helper_offerer_), sf_answerer_(env_, nullptr, false, &ssrc_generator_answerer_, &tdf_answerer_, &sctpf_answerer_, &codec_lookup_helper_answerer_), codec_lookup_helper_offerer_(env_.field_trials()), codec_lookup_helper_answerer_(env_.field_trials()) { tdf_offerer_.set_certificate(RTCCertificate::Create( std::unique_ptr(new FakeSSLIdentity("offer_id")))); tdf_answerer_.set_certificate(RTCCertificate::Create( std::unique_ptr(new FakeSSLIdentity("answer_id")))); } void CheckH265Level(std::span codecs, const std::string& expected_level) { for (const Codec& codec : codecs) { if (codec.name == "H265") { auto it = codec.params.find("level-id"); ASSERT_TRUE(it != codec.params.end()); EXPECT_EQ(it->second, expected_level); } } } protected: Environment env_; TransportDescriptionFactory tdf_offerer_; TransportDescriptionFactory tdf_answerer_; UniqueRandomIdGenerator ssrc_generator_offerer_; UniqueRandomIdGenerator ssrc_generator_answerer_; FakeSctpTransportFactory sctpf_offerer_; FakeSctpTransportFactory sctpf_answerer_; MediaSessionDescriptionFactory sf_offerer_; MediaSessionDescriptionFactory sf_answerer_; CodecLookupHelperForTesting codec_lookup_helper_offerer_; CodecLookupHelperForTesting codec_lookup_helper_answerer_; }; // Both sides support H.265 level 5.2 for encoding and decoding. // Offer: level 5.2, SendRecv // Answer: level 5.2, SendRecv TEST_F(VideoCodecsOfferH265LevelIdTest, TestSendRecvSymmetrical) { const std::vector send_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector recv_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector sendrecv_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); codec_lookup_helper_offerer_.SetVideoCodecs(send_codecs, recv_codecs); codec_lookup_helper_answerer_.SetVideoCodecs(recv_codecs, send_codecs); EXPECT_THAT(codec_lookup_helper_offerer_.GetCodecVendor() ->video_sendrecv_codecs() .codecs(), CodecListsMatch(sendrecv_codecs, &env_.field_trials())); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); AttachSenderToMediaDescriptionOptions( kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts); std::unique_ptr offer = sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* oc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(oc); const MediaContentDescription* ocd = oc->media_description(); EXPECT_THAT(ocd->codecs(), CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials())); CheckH265Level(ocd->codecs(), kVideoCodecsH265Level52LevelId); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &answer_opts); AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &answer_opts); std::unique_ptr answer = sf_answerer_.CreateAnswerOrError(offer.get(), answer_opts, nullptr) .MoveValue(); ASSERT_TRUE(answer.get()); const ContentInfo* ac = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); const MediaContentDescription* acd = ac->media_description(); EXPECT_THAT(acd->codecs(), CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials())); CheckH265Level(acd->codecs(), kVideoCodecsH265Level52LevelId); } // Both sides support H.265 level 6.0 for encoding and decoding. // Offer: level 6.0, SendOnly // Answer: level 6.0, RecvOnly TEST_F(VideoCodecsOfferH265LevelIdTest, TestSendOnlySymmetrical) { const std::vector send_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector recv_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector sendrecv_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); codec_lookup_helper_offerer_.SetVideoCodecs(send_codecs, recv_codecs); codec_lookup_helper_answerer_.SetVideoCodecs(recv_codecs, send_codecs); EXPECT_THAT(codec_lookup_helper_offerer_.GetCodecVendor() ->video_sendrecv_codecs() .codecs(), CodecListsMatch(sendrecv_codecs, &env_.field_trials())); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendOnly, kActive, &opts); AttachSenderToMediaDescriptionOptions( kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts); std::unique_ptr offer = sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* oc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(oc); const MediaContentDescription* ocd = oc->media_description(); EXPECT_THAT(ocd->codecs(), CodecListsMatch(kVideoCodecsH265Level6, &env_.field_trials())); CheckH265Level(ocd->codecs(), kVideoCodecsH265Level6LevelId); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &answer_opts); std::unique_ptr answer = sf_answerer_.CreateAnswerOrError(offer.get(), answer_opts, nullptr) .MoveValue(); ASSERT_TRUE(answer.get()); const ContentInfo* ac = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); const MediaContentDescription* acd = ac->media_description(); EXPECT_THAT(acd->codecs(), CodecListsMatch(kVideoCodecsH265Level6, &env_.field_trials())); CheckH265Level(acd->codecs(), kVideoCodecsH265Level6LevelId); } // Both sides support H.265 level 5.2 for encoding and decoding. // Offer: level 5.2, RecvOnly // Answer: level 5.2, SendOnly TEST_F(VideoCodecsOfferH265LevelIdTest, TestRecvOnlySymmetrical) { const std::vector send_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector recv_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector sendrecv_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); codec_lookup_helper_offerer_.SetVideoCodecs(send_codecs, recv_codecs); codec_lookup_helper_answerer_.SetVideoCodecs(recv_codecs, send_codecs); EXPECT_THAT(codec_lookup_helper_offerer_.GetCodecVendor() ->video_sendrecv_codecs() .codecs(), CodecListsMatch(sendrecv_codecs, &env_.field_trials())); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &opts); std::unique_ptr offer = sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* oc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(oc); const MediaContentDescription* ocd = oc->media_description(); EXPECT_THAT(ocd->codecs(), CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials())); CheckH265Level(ocd->codecs(), kVideoCodecsH265Level52LevelId); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendOnly, kActive, &answer_opts); std::unique_ptr answer = sf_answerer_.CreateAnswerOrError(offer.get(), answer_opts, nullptr) .MoveValue(); ASSERT_TRUE(answer.get()); const ContentInfo* ac = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); const MediaContentDescription* acd = ac->media_description(); EXPECT_THAT(acd->codecs(), CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials())); CheckH265Level(acd->codecs(), kVideoCodecsH265Level52LevelId); } // Offerer encodes up to level 5.2, and decodes up to level 6.0. // Answerer encodes up to level 6.0, and decodes up to level 5.2. // Offer: level 5.2, SendRecv // Answer: level 5.2, SendRecv TEST_F(VideoCodecsOfferH265LevelIdTest, SendRecvOffererEncode52Decode60AnswererEncode60Decode52) { const std::vector offerer_send_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector offerer_recv_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector offerer_sendrecv_codecs( kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector answerer_send_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector answerer_recv_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs, offerer_recv_codecs); codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs, answerer_recv_codecs); EXPECT_THAT(codec_lookup_helper_offerer_.GetCodecVendor() ->video_sendrecv_codecs() .codecs(), CodecListsMatch(offerer_sendrecv_codecs, &env_.field_trials())); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); AttachSenderToMediaDescriptionOptions( kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts); std::unique_ptr offer = sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* oc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(oc); const MediaContentDescription* ocd = oc->media_description(); EXPECT_THAT(ocd->codecs(), CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials())); CheckH265Level(ocd->codecs(), kVideoCodecsH265Level52LevelId); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &answer_opts); AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &answer_opts); std::unique_ptr answer = sf_answerer_.CreateAnswerOrError(offer.get(), answer_opts, nullptr) .MoveValue(); ASSERT_TRUE(answer.get()); const ContentInfo* ac = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); const MediaContentDescription* acd = ac->media_description(); EXPECT_THAT(acd->codecs(), CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials())); CheckH265Level(acd->codecs(), kVideoCodecsH265Level52LevelId); } // Offerer encodes up to level 6, and decodes up to level 5.2. // Answerer encodes up to level 5.2, and decodes up to level 6.0. // Offer: level 5.2, SendRecv // Answer: level 5.2, SendRecv TEST_F(VideoCodecsOfferH265LevelIdTest, SendRecvOffererEncode60Decode52AnswererEncode52Decode60) { const std::vector offerer_send_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector offerer_recv_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector offerer_sendrecv_codecs( kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector answerer_send_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector answerer_recv_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs, offerer_recv_codecs); codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs, answerer_recv_codecs); EXPECT_EQ(offerer_sendrecv_codecs, codec_lookup_helper_offerer_.GetCodecVendor() ->video_sendrecv_codecs() .codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); AttachSenderToMediaDescriptionOptions( kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts); std::unique_ptr offer = sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* oc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(oc); const MediaContentDescription* ocd = oc->media_description(); EXPECT_THAT(ocd->codecs(), CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials())); CheckH265Level(ocd->codecs(), kVideoCodecsH265Level52LevelId); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &answer_opts); AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &answer_opts); std::unique_ptr answer = sf_answerer_.CreateAnswerOrError(offer.get(), answer_opts, nullptr) .MoveValue(); ASSERT_TRUE(answer.get()); const ContentInfo* ac = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); const MediaContentDescription* acd = ac->media_description(); EXPECT_THAT(acd->codecs(), CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials())); CheckH265Level(acd->codecs(), kVideoCodecsH265Level52LevelId); } // Offerer encodes up to level 6, and decodes up to level 5.2. // Answerer encodes up to level 3.1, and decodes up to level 5.0. // Offer: level 5.2, SendRecv // Answer: level 3.1, SendRecv TEST_F(VideoCodecsOfferH265LevelIdTest, SendRecvOffererEncode60Decode52AnswererEncode31Decode50) { const std::vector offerer_send_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector offerer_recv_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector offerer_sendrecv_codecs( kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector answerer_send_codecs(kVideoCodecsH265Level31.begin(), kVideoCodecsH265Level31.end()); const std::vector answerer_recv_codecs(kVideoCodecsH265Level5.begin(), kVideoCodecsH265Level5.end()); codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs, offerer_recv_codecs); codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs, answerer_recv_codecs); EXPECT_EQ(offerer_sendrecv_codecs, codec_lookup_helper_offerer_.GetCodecVendor() ->video_sendrecv_codecs() .codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); AttachSenderToMediaDescriptionOptions( kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts); std::unique_ptr offer = sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* oc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(oc); const MediaContentDescription* ocd = oc->media_description(); EXPECT_THAT(ocd->codecs(), CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials())); CheckH265Level(ocd->codecs(), kVideoCodecsH265Level52LevelId); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &answer_opts); AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &answer_opts); std::unique_ptr answer = sf_answerer_.CreateAnswerOrError(offer.get(), answer_opts, nullptr) .MoveValue(); ASSERT_TRUE(answer.get()); const ContentInfo* ac = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); const MediaContentDescription* acd = ac->media_description(); EXPECT_THAT(acd->codecs(), CodecListsMatch(kVideoCodecsH265Level31, &env_.field_trials())); CheckH265Level(acd->codecs(), kVideoCodecsH265Level31LevelId); std::unique_ptr reoffer = sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(reoffer.get()); const ContentInfo* reoffer_oc = reoffer->GetContentByName(kVideoMid); ASSERT_TRUE(reoffer_oc); const MediaContentDescription* reoffer_ocd = reoffer_oc->media_description(); EXPECT_THAT(reoffer_ocd->codecs(), CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials())); CheckH265Level(ocd->codecs(), kVideoCodecsH265Level52LevelId); } // Offerer encodes up to level 6, and decodes up to level 5.2. // Answerer encodes up to level 4, and decodes up to level 6. // Offer: level 5.2, SendRecv // Answer: level 4, SendRecv TEST_F(VideoCodecsOfferH265LevelIdTest, SendRecvOffererEncode60Decode52AnswererEncode40Decode60) { const std::vector offerer_send_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector offerer_recv_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector offerer_sendrecv_codecs( kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector answerer_send_codecs(kVideoCodecsH265Level4.begin(), kVideoCodecsH265Level4.end()); const std::vector answerer_recv_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs, offerer_recv_codecs); codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs, answerer_recv_codecs); EXPECT_EQ(offerer_sendrecv_codecs, codec_lookup_helper_offerer_.GetCodecVendor() ->video_sendrecv_codecs() .codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); AttachSenderToMediaDescriptionOptions( kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts); std::unique_ptr offer = sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* oc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(oc); const MediaContentDescription* ocd = oc->media_description(); EXPECT_THAT(ocd->codecs(), CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials())); CheckH265Level(ocd->codecs(), kVideoCodecsH265Level52LevelId); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &answer_opts); AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &answer_opts); std::unique_ptr answer = sf_answerer_.CreateAnswerOrError(offer.get(), answer_opts, nullptr) .MoveValue(); ASSERT_TRUE(answer.get()); const ContentInfo* ac = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); const MediaContentDescription* acd = ac->media_description(); EXPECT_THAT(acd->codecs(), CodecListsMatch(kVideoCodecsH265Level4, &env_.field_trials())); CheckH265Level(acd->codecs(), kVideoCodecsH265Level4LevelId); } // Offerer encodes up to level 4, and decodes up to level 6. // Answerer encodes up to level 6, and decodes up to level 5.2. // Offer: level 4, SendRecv // Answer: level 4, SendRecv TEST_F(VideoCodecsOfferH265LevelIdTest, SendRecvOffererEncode40Decode60AnswererEncode60Decode52) { const std::vector offerer_send_codecs(kVideoCodecsH265Level4.begin(), kVideoCodecsH265Level4.end()); const std::vector offerer_recv_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector offerer_sendrecv_codecs( kVideoCodecsH265Level4.begin(), kVideoCodecsH265Level4.end()); const std::vector answerer_send_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector answerer_recv_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs, offerer_recv_codecs); codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs, answerer_recv_codecs); EXPECT_EQ(offerer_sendrecv_codecs, codec_lookup_helper_offerer_.GetCodecVendor() ->video_sendrecv_codecs() .codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); AttachSenderToMediaDescriptionOptions( kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts); std::unique_ptr offer = sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* oc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(oc); const MediaContentDescription* ocd = oc->media_description(); EXPECT_THAT(ocd->codecs(), CodecListsMatch(kVideoCodecsH265Level4, &env_.field_trials())); CheckH265Level(ocd->codecs(), kVideoCodecsH265Level4LevelId); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &answer_opts); AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &answer_opts); std::unique_ptr answer = sf_answerer_.CreateAnswerOrError(offer.get(), answer_opts, nullptr) .MoveValue(); ASSERT_TRUE(answer.get()); const ContentInfo* ac = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); const MediaContentDescription* acd = ac->media_description(); EXPECT_THAT(acd->codecs(), CodecListsMatch(kVideoCodecsH265Level4, &env_.field_trials())); CheckH265Level(acd->codecs(), kVideoCodecsH265Level4LevelId); } // Offerer encodes up to level 5.2, and decodes up to level 6. // Answerer encodes up to level 6, and decodes up to level 5.2. // Offer: level 6, RecvOnly // Answer: level 6, SendOnly TEST_F(VideoCodecsOfferH265LevelIdTest, RecvOnlyOffererEncode52Decode60AnswererEncode60Decode52) { const std::vector offerer_send_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector offerer_recv_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector offerer_sendrecv_codecs( kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector answerer_send_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector answerer_recv_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs, offerer_recv_codecs); codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs, answerer_recv_codecs); EXPECT_EQ(offerer_sendrecv_codecs, codec_lookup_helper_offerer_.GetCodecVendor() ->video_sendrecv_codecs() .codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &opts); std::unique_ptr offer = sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* oc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(oc); const MediaContentDescription* ocd = oc->media_description(); EXPECT_THAT(ocd->codecs(), CodecListsMatch(kVideoCodecsH265Level6, &env_.field_trials())); CheckH265Level(ocd->codecs(), kVideoCodecsH265Level6LevelId); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendOnly, kActive, &answer_opts); AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &answer_opts); std::unique_ptr answer = sf_answerer_.CreateAnswerOrError(offer.get(), answer_opts, nullptr) .MoveValue(); ASSERT_TRUE(answer.get()); const ContentInfo* ac = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); const MediaContentDescription* acd = ac->media_description(); EXPECT_THAT(acd->codecs(), CodecListsMatch(kVideoCodecsH265Level6, &env_.field_trials())); CheckH265Level(acd->codecs(), kVideoCodecsH265Level6LevelId); } // Offerer encodes up to level 6, and decodes up to level 5.2. // Answerer encodes up to level 5.2, and decodes up to level 6. // Offer: level 5.2, RecvOnly // Answer: level 5.2, SendOnly TEST_F(VideoCodecsOfferH265LevelIdTest, RecvOnlyOffererEncode60Decode52AnswererEncode52Decode60) { const std::vector offerer_send_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector offerer_recv_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector offerer_sendrecv_codecs( kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector answerer_send_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector answerer_recv_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs, offerer_recv_codecs); codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs, answerer_recv_codecs); EXPECT_EQ(offerer_sendrecv_codecs, codec_lookup_helper_offerer_.GetCodecVendor() ->video_sendrecv_codecs() .codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &opts); std::unique_ptr offer = sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* oc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(oc); const MediaContentDescription* ocd = oc->media_description(); EXPECT_THAT(ocd->codecs(), CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials())); CheckH265Level(ocd->codecs(), kVideoCodecsH265Level52LevelId); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendOnly, kActive, &answer_opts); AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &answer_opts); std::unique_ptr answer = sf_answerer_.CreateAnswerOrError(offer.get(), answer_opts, nullptr) .MoveValue(); ASSERT_TRUE(answer.get()); const ContentInfo* ac = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); const MediaContentDescription* acd = ac->media_description(); EXPECT_THAT(acd->codecs(), CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials())); CheckH265Level(acd->codecs(), kVideoCodecsH265Level52LevelId); } // Offerer encodes up to level 6, and decodes up to level 5.2. // Answerer encodes up to level 3.1, and decodes up to level 5. // Offer: level 5.2, RecvOnly // Answer: level 3.1, SendOnly TEST_F(VideoCodecsOfferH265LevelIdTest, RecvOnlyOffererEncode60Decode52AnswererEncode31Decode50) { const std::vector offerer_send_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector offerer_recv_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector offerer_sendrecv_codecs( kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector answerer_send_codecs(kVideoCodecsH265Level31.begin(), kVideoCodecsH265Level31.end()); const std::vector answerer_recv_codecs(kVideoCodecsH265Level5.begin(), kVideoCodecsH265Level5.end()); codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs, offerer_recv_codecs); codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs, answerer_recv_codecs); EXPECT_EQ(offerer_sendrecv_codecs, codec_lookup_helper_offerer_.GetCodecVendor() ->video_sendrecv_codecs() .codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &opts); std::unique_ptr offer = sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* oc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(oc); const MediaContentDescription* ocd = oc->media_description(); EXPECT_THAT(ocd->codecs(), CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials())); CheckH265Level(ocd->codecs(), kVideoCodecsH265Level52LevelId); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendOnly, kActive, &answer_opts); AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &answer_opts); std::unique_ptr answer = sf_answerer_.CreateAnswerOrError(offer.get(), answer_opts, nullptr) .MoveValue(); ASSERT_TRUE(answer.get()); const ContentInfo* ac = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); const MediaContentDescription* acd = ac->media_description(); EXPECT_THAT(acd->codecs(), CodecListsMatch(kVideoCodecsH265Level31, &env_.field_trials())); CheckH265Level(acd->codecs(), kVideoCodecsH265Level31LevelId); } // Offerer encodes up to level 6, and decodes up to level 5.2. // Answerer encodes up to level 4, and decodes up to level 6. // Offer: level 5.2, RecvOnly // Answer: level 4, SendOnly TEST_F(VideoCodecsOfferH265LevelIdTest, RecvOnlyOffererEncode60Decode52AnswererEncode40Decode60) { const std::vector offerer_send_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector offerer_recv_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector offerer_sendrecv_codecs( kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector answerer_send_codecs(kVideoCodecsH265Level4.begin(), kVideoCodecsH265Level4.end()); const std::vector answerer_recv_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs, offerer_recv_codecs); codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs, answerer_recv_codecs); EXPECT_EQ(offerer_sendrecv_codecs, codec_lookup_helper_offerer_.GetCodecVendor() ->video_sendrecv_codecs() .codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &opts); std::unique_ptr offer = sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* oc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(oc); const MediaContentDescription* ocd = oc->media_description(); EXPECT_THAT(ocd->codecs(), CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials())); CheckH265Level(ocd->codecs(), kVideoCodecsH265Level52LevelId); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendOnly, kActive, &answer_opts); AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &answer_opts); std::unique_ptr answer = sf_answerer_.CreateAnswerOrError(offer.get(), answer_opts, nullptr) .MoveValue(); ASSERT_TRUE(answer.get()); const ContentInfo* ac = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); const MediaContentDescription* acd = ac->media_description(); EXPECT_THAT(acd->codecs(), CodecListsMatch(kVideoCodecsH265Level4, &env_.field_trials())); CheckH265Level(acd->codecs(), kVideoCodecsH265Level4LevelId); } // Offerer encodes up to level 4, and decodes up to level 6. // Answerer encodes up to level 6, and decodes up to level 5.2. // Offer: level 6, RecvOnly // Answer: level 6, SendOnly TEST_F(VideoCodecsOfferH265LevelIdTest, RecvOnlyOffererEncode40Decode60AnswererEncode60Decode52) { const std::vector offerer_send_codecs(kVideoCodecsH265Level4.begin(), kVideoCodecsH265Level4.end()); const std::vector offerer_recv_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector offerer_sendrecv_codecs( kVideoCodecsH265Level4.begin(), kVideoCodecsH265Level4.end()); const std::vector answerer_send_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector answerer_recv_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs, offerer_recv_codecs); codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs, answerer_recv_codecs); EXPECT_EQ(offerer_sendrecv_codecs, codec_lookup_helper_offerer_.GetCodecVendor() ->video_sendrecv_codecs() .codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &opts); std::unique_ptr offer = sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* oc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(oc); const MediaContentDescription* ocd = oc->media_description(); EXPECT_THAT(ocd->codecs(), CodecListsMatch(kVideoCodecsH265Level6, &env_.field_trials())); CheckH265Level(ocd->codecs(), kVideoCodecsH265Level6LevelId); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendOnly, kActive, &answer_opts); AttachSenderToMediaDescriptionOptions(kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &answer_opts); std::unique_ptr answer = sf_answerer_.CreateAnswerOrError(offer.get(), answer_opts, nullptr) .MoveValue(); ASSERT_TRUE(answer.get()); const ContentInfo* ac = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); const MediaContentDescription* acd = ac->media_description(); EXPECT_THAT(acd->codecs(), CodecListsMatch(kVideoCodecsH265Level6, &env_.field_trials())); CheckH265Level(acd->codecs(), kVideoCodecsH265Level6LevelId); } // Offerer encodes up to level 5.2, and decodes up to level 6. // Answerer encodes up to level 6, and decodes up to level 5.2. // Offer: level 5.2, SendOnly // Answer: level 5.2, RecvOnly TEST_F(VideoCodecsOfferH265LevelIdTest, SendOnlyOffererEncode52Decode60AnswererEncode60Decode52) { const std::vector offerer_send_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector offerer_recv_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector offerer_sendrecv_codecs( kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector answerer_send_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector answerer_recv_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs, offerer_recv_codecs); codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs, answerer_recv_codecs); EXPECT_EQ(offerer_sendrecv_codecs, codec_lookup_helper_offerer_.GetCodecVendor() ->video_sendrecv_codecs() .codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendOnly, kActive, &opts); AttachSenderToMediaDescriptionOptions( kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts); std::unique_ptr offer = sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* oc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(oc); const MediaContentDescription* ocd = oc->media_description(); EXPECT_THAT(ocd->codecs(), CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials())); CheckH265Level(ocd->codecs(), kVideoCodecsH265Level52LevelId); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &answer_opts); std::unique_ptr answer = sf_answerer_.CreateAnswerOrError(offer.get(), answer_opts, nullptr) .MoveValue(); ASSERT_TRUE(answer.get()); const ContentInfo* ac = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); const MediaContentDescription* acd = ac->media_description(); EXPECT_THAT(acd->codecs(), CodecListsMatch(kVideoCodecsH265Level52, &env_.field_trials())); CheckH265Level(acd->codecs(), kVideoCodecsH265Level52LevelId); } // Offerer encodes up to level 6, and decodes up to level 5.2. // Answerer encodes up to level 5.2, and decodes up to level 6. // Offer: level 6, SendOnly // Answer: level 6, RecvOnly TEST_F(VideoCodecsOfferH265LevelIdTest, SendOnlyOffererEncode60Decode52AnswererEncode52Decode60) { const std::vector offerer_send_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector offerer_recv_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector offerer_sendrecv_codecs( kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector answerer_send_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector answerer_recv_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs, offerer_recv_codecs); codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs, answerer_recv_codecs); EXPECT_EQ(offerer_sendrecv_codecs, codec_lookup_helper_offerer_.GetCodecVendor() ->video_sendrecv_codecs() .codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendOnly, kActive, &opts); AttachSenderToMediaDescriptionOptions( kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts); std::unique_ptr offer = sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* oc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(oc); const MediaContentDescription* ocd = oc->media_description(); EXPECT_THAT(ocd->codecs(), CodecListsMatch(kVideoCodecsH265Level6, &env_.field_trials())); CheckH265Level(ocd->codecs(), kVideoCodecsH265Level6LevelId); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &answer_opts); std::unique_ptr answer = sf_answerer_.CreateAnswerOrError(offer.get(), answer_opts, nullptr) .MoveValue(); ASSERT_TRUE(answer.get()); const ContentInfo* ac = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); const MediaContentDescription* acd = ac->media_description(); EXPECT_THAT(acd->codecs(), CodecListsMatch(kVideoCodecsH265Level6, &env_.field_trials())); CheckH265Level(acd->codecs(), kVideoCodecsH265Level6LevelId); } // Offerer encodes up to level 6, and decodes up to level 5.2. // Answerer encodes up to level 3.1, and decodes up to level 5. // Offer: level 6, SendOnly // Answer: level 5, RecvOnly TEST_F(VideoCodecsOfferH265LevelIdTest, SendOnlyOffererEncode60Decode52AnswererEncode31Decode50) { const std::vector offerer_send_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector offerer_recv_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector offerer_sendrecv_codecs( kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector answerer_send_codecs(kVideoCodecsH265Level31.begin(), kVideoCodecsH265Level31.end()); const std::vector answerer_recv_codecs(kVideoCodecsH265Level5.begin(), kVideoCodecsH265Level5.end()); codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs, offerer_recv_codecs); codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs, answerer_recv_codecs); EXPECT_EQ(offerer_sendrecv_codecs, codec_lookup_helper_offerer_.GetCodecVendor() ->video_sendrecv_codecs() .codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendOnly, kActive, &opts); AttachSenderToMediaDescriptionOptions( kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts); std::unique_ptr offer = sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* oc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(oc); const MediaContentDescription* ocd = oc->media_description(); EXPECT_THAT(ocd->codecs(), CodecListsMatch(kVideoCodecsH265Level6, &env_.field_trials())); CheckH265Level(ocd->codecs(), kVideoCodecsH265Level6LevelId); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &answer_opts); std::unique_ptr answer = sf_answerer_.CreateAnswerOrError(offer.get(), answer_opts, nullptr) .MoveValue(); ASSERT_TRUE(answer.get()); const ContentInfo* ac = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); const MediaContentDescription* acd = ac->media_description(); EXPECT_THAT(acd->codecs(), CodecListsMatch(kVideoCodecsH265Level5, &env_.field_trials())); CheckH265Level(acd->codecs(), kVideoCodecsH265Level5LevelId); } // Offerer encodes up to level 6, and decodes up to level 5.2. // Answerer encodes up to level 4, and decodes up to level 6. // Offer: level 6, SendOnly // Answer: level 6, RecvOnly TEST_F(VideoCodecsOfferH265LevelIdTest, SendOnlyOffererEncode60Decode52AnswererEncode40Decode60) { const std::vector offerer_send_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector offerer_recv_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector offerer_sendrecv_codecs( kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); const std::vector answerer_send_codecs(kVideoCodecsH265Level4.begin(), kVideoCodecsH265Level4.end()); const std::vector answerer_recv_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs, offerer_recv_codecs); codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs, answerer_recv_codecs); EXPECT_EQ(offerer_sendrecv_codecs, codec_lookup_helper_offerer_.GetCodecVendor() ->video_sendrecv_codecs() .codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendOnly, kActive, &opts); AttachSenderToMediaDescriptionOptions( kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts); std::unique_ptr offer = sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* oc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(oc); const MediaContentDescription* ocd = oc->media_description(); EXPECT_THAT(ocd->codecs(), CodecListsMatch(kVideoCodecsH265Level6, &env_.field_trials())); CheckH265Level(ocd->codecs(), kVideoCodecsH265Level6LevelId); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &answer_opts); std::unique_ptr answer = sf_answerer_.CreateAnswerOrError(offer.get(), answer_opts, nullptr) .MoveValue(); ASSERT_TRUE(answer.get()); const ContentInfo* ac = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); const MediaContentDescription* acd = ac->media_description(); EXPECT_THAT(acd->codecs(), CodecListsMatch(kVideoCodecsH265Level6, &env_.field_trials())); CheckH265Level(acd->codecs(), kVideoCodecsH265Level6LevelId); } // Offerer encodes up to level 4, and decodes up to level 6. // Answerer encodes up to level 6, and decodes up to level 5.2. // Offer: level 4, SendOnly // Answer: level 4, RecvOnly TEST_F(VideoCodecsOfferH265LevelIdTest, SendOnlyOffererEncode40Decode60AnswererEncode60Decode52) { const std::vector offerer_send_codecs(kVideoCodecsH265Level4.begin(), kVideoCodecsH265Level4.end()); const std::vector offerer_recv_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector offerer_sendrecv_codecs( kVideoCodecsH265Level4.begin(), kVideoCodecsH265Level4.end()); const std::vector answerer_send_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector answerer_recv_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs, offerer_recv_codecs); codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs, answerer_recv_codecs); EXPECT_EQ(offerer_sendrecv_codecs, codec_lookup_helper_offerer_.GetCodecVendor() ->video_sendrecv_codecs() .codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendOnly, kActive, &opts); AttachSenderToMediaDescriptionOptions( kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts); std::unique_ptr offer = sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* oc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(oc); const MediaContentDescription* ocd = oc->media_description(); EXPECT_THAT(ocd->codecs(), CodecListsMatch(kVideoCodecsH265Level4, &env_.field_trials())); CheckH265Level(ocd->codecs(), kVideoCodecsH265Level4LevelId); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &answer_opts); std::unique_ptr answer = sf_answerer_.CreateAnswerOrError(offer.get(), answer_opts, nullptr) .MoveValue(); ASSERT_TRUE(answer.get()); const ContentInfo* ac = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); const MediaContentDescription* acd = ac->media_description(); EXPECT_THAT(acd->codecs(), CodecListsMatch(kVideoCodecsH265Level4, &env_.field_trials())); CheckH265Level(acd->codecs(), kVideoCodecsH265Level4LevelId); } TEST_F(VideoCodecsOfferH265LevelIdTest, SendOnlyOffererEncode40Decode60AnswererEncode60Decode52WithPreference) { const std::vector offerer_send_codecs(kVideoCodecsH265Level4.begin(), kVideoCodecsH265Level4.end()); const std::vector offerer_recv_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector offerer_sendrecv_codecs( kVideoCodecsH265Level4.begin(), kVideoCodecsH265Level4.end()); const std::vector answerer_send_codecs(kVideoCodecsH265Level6.begin(), kVideoCodecsH265Level6.end()); const std::vector answerer_recv_codecs(kVideoCodecsH265Level52.begin(), kVideoCodecsH265Level52.end()); codec_lookup_helper_offerer_.SetVideoCodecs(offerer_send_codecs, offerer_recv_codecs); codec_lookup_helper_answerer_.SetVideoCodecs(answerer_send_codecs, answerer_recv_codecs); EXPECT_EQ(offerer_sendrecv_codecs, codec_lookup_helper_offerer_.GetCodecVendor() ->video_sendrecv_codecs() .codecs()); MediaSessionOptions opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kSendRecv, kActive, &opts); AttachSenderToMediaDescriptionOptions( kVideoMid, MediaType::VIDEO, kVideoTrack1, {kMediaStream1}, 1, &opts); std::vector preferences; for (const Codec& codec : codec_lookup_helper_offerer_.GetCodecVendor() ->video_recv_codecs() .codecs()) { preferences.push_back(ToRtpCodecCapability(codec)); } opts.media_description_options[0].codec_preferences = preferences; std::unique_ptr offer = sf_offerer_.CreateOfferOrError(opts, nullptr).MoveValue(); ASSERT_TRUE(offer.get()); const ContentInfo* oc = offer->GetContentByName(kVideoMid); ASSERT_TRUE(oc); const MediaContentDescription* ocd = oc->media_description(); EXPECT_THAT(ocd->codecs(), CodecListsMatch(kVideoCodecsH265Level4, &env_.field_trials())); CheckH265Level(ocd->codecs(), kVideoCodecsH265Level4LevelId); MediaSessionOptions answer_opts; AddMediaDescriptionOptions(MediaType::VIDEO, kVideoMid, RtpTransceiverDirection::kRecvOnly, kActive, &answer_opts); std::unique_ptr answer = sf_answerer_.CreateAnswerOrError(offer.get(), answer_opts, nullptr) .MoveValue(); ASSERT_TRUE(answer.get()); const ContentInfo* ac = answer->GetContentByName(kVideoMid); ASSERT_TRUE(ac); const MediaContentDescription* acd = ac->media_description(); EXPECT_THAT(acd->codecs(), CodecListsMatch(kVideoCodecsH265Level4, &env_.field_trials())); CheckH265Level(acd->codecs(), kVideoCodecsH265Level4LevelId); } #endif } // namespace } // namespace webrtc