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

Expand use of CodecList to cover pc/media_session.cc

Browse Source 
This allows us to verify consistency of codec lists in more places.

Bug: webrtc:360058654
Change-Id: Ibd0d10579c4b8058031db0df458e8fc9e2181152
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/371921
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Reviewed-by: Henrik Boström <hbos@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#43594}
This commit is contained in:
Harald Alvestrand 2024-12-17 16:10:01 +00:00 committed by WebRTC LUCI CQ
parent b2120cb723
commit 486e3deba0
4 changed files with 165 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
media/base/codec_list.h
View File

@ -22,6 +22,7 @@ class CodecList {
public: public:
using iterator = std::vector<Codec>::iterator; using iterator = std::vector<Codec>::iterator;
using const_iterator = std::vector<Codec>::const_iterator; using const_iterator = std::vector<Codec>::const_iterator;
using value_type = Codec;
CodecList() {} CodecList() {}
explicit CodecList(const std::vector<Codec>& codecs) { explicit CodecList(const std::vector<Codec>& codecs) {
@ -35,8 +36,13 @@ class CodecList {
const_iterator end() const { return codecs_.end(); } const_iterator end() const { return codecs_.end(); }
const Codec& operator[](size_t i) const { return codecs_[i]; } const Codec& operator[](size_t i) const { return codecs_[i]; }
Codec& operator[](size_t i) { return codecs_[i]; } Codec& operator[](size_t i) { return codecs_[i]; }
void push_back(const Codec& codec) { codecs_.push_back(codec); } void push_back(const Codec& codec) {
codecs_.push_back(codec);
CheckConsistency();
}
bool empty() const { return codecs_.empty(); } bool empty() const { return codecs_.empty(); }
void clear() { codecs_.clear(); }
size_t size() const { return codecs_.size(); }
// Access to the whole codec list // Access to the whole codec list
const std::vector<Codec>& codecs() const { return codecs_; } const std::vector<Codec>& codecs() const { return codecs_; }
std::vector<Codec>& writable_codecs() { return codecs_; } std::vector<Codec>& writable_codecs() { return codecs_; }

131
pc/media_session.cc
View File

@ -146,6 +146,14 @@ bool IsComfortNoiseCodec(const Codec& codec) {
return absl::EqualsIgnoreCase(codec.name, kComfortNoiseCodecName); return absl::EqualsIgnoreCase(codec.name, kComfortNoiseCodecName);
} }
// Wrapper for FindMatchingCodecs that uses CodecList
std::optional<Codec> FindMatchingCodec(const CodecList& codecs1,
const CodecList& codecs2,
const Codec& codec_to_match) {
return webrtc::FindMatchingCodec(codecs1.codecs(), codecs2.codecs(),
codec_to_match);
}
void StripCNCodecs(CodecList& audio_codecs) { void StripCNCodecs(CodecList& audio_codecs) {
audio_codecs.writable_codecs().erase( audio_codecs.writable_codecs().erase(
std::remove_if( std::remove_if(
@ -509,13 +517,13 @@ webrtc::RTCError AssignCodecIdsAndLinkRed(
return webrtc::RTCError::OK(); return webrtc::RTCError::OK();
} }
void NegotiateCodecs(const std::vector<Codec>& local_codecs, void NegotiateCodecs(const CodecList& local_codecs,
const std::vector<Codec>& offered_codecs, const CodecList& offered_codecs,
std::vector<Codec>* negotiated_codecs, std::vector<Codec>* negotiated_codecs,
bool keep_offer_order) { bool keep_offer_order) {
for (const Codec& ours : local_codecs) { for (const Codec& ours : local_codecs) {
std::optional<Codec> theirs = std::optional<Codec> theirs =
webrtc::FindMatchingCodec(local_codecs, offered_codecs, ours); FindMatchingCodec(local_codecs, offered_codecs, ours);
// Note that we intentionally only find one matching codec for each of our // Note that we intentionally only find one matching codec for each of our
// local codecs, in case the remote offer contains duplicate codecs. // local codecs, in case the remote offer contains duplicate codecs.
if (theirs) { if (theirs) {
@ -657,8 +665,7 @@ void MergeCodecs(const CodecList& reference_codecs,
for (const Codec& reference_codec : reference_codecs) { for (const Codec& reference_codec : reference_codecs) {
if (reference_codec.GetResiliencyType() != Codec::ResiliencyType::kRtx && if (reference_codec.GetResiliencyType() != Codec::ResiliencyType::kRtx &&
reference_codec.GetResiliencyType() != Codec::ResiliencyType::kRed && reference_codec.GetResiliencyType() != Codec::ResiliencyType::kRed &&
!webrtc::FindMatchingCodec(reference_codecs.codecs(), !FindMatchingCodec(reference_codecs, offered_codecs, reference_codec)) {
offered_codecs.codecs(), reference_codec)) {
Codec codec = reference_codec; Codec codec = reference_codec;
used_pltypes->FindAndSetIdUsed(&codec); used_pltypes->FindAndSetIdUsed(&codec);
offered_codecs.push_back(codec); offered_codecs.push_back(codec);
@ -668,8 +675,7 @@ void MergeCodecs(const CodecList& reference_codecs,
// Add all new RTX or RED codecs. // Add all new RTX or RED codecs.
for (const Codec& reference_codec : reference_codecs) { for (const Codec& reference_codec : reference_codecs) {
if (reference_codec.GetResiliencyType() == Codec::ResiliencyType::kRtx && if (reference_codec.GetResiliencyType() == Codec::ResiliencyType::kRtx &&
!webrtc::FindMatchingCodec(reference_codecs.codecs(), !FindMatchingCodec(reference_codecs, offered_codecs, reference_codec)) {
offered_codecs.codecs(), reference_codec)) {
Codec rtx_codec = reference_codec; Codec rtx_codec = reference_codec;
const Codec* associated_codec = const Codec* associated_codec =
GetAssociatedCodecForRtx(reference_codecs, rtx_codec); GetAssociatedCodecForRtx(reference_codecs, rtx_codec);
@ -678,9 +684,8 @@ void MergeCodecs(const CodecList& reference_codecs,
} }
// Find a codec in the offered list that matches the reference codec. // Find a codec in the offered list that matches the reference codec.
// Its payload type may be different than the reference codec. // Its payload type may be different than the reference codec.
std::optional<Codec> matching_codec = std::optional<Codec> matching_codec = FindMatchingCodec(
webrtc::FindMatchingCodec(reference_codecs.codecs(), reference_codecs, offered_codecs, *associated_codec);
offered_codecs.codecs(), *associated_codec);
if (!matching_codec) { if (!matching_codec) {
RTC_LOG(LS_WARNING) RTC_LOG(LS_WARNING)
<< "Couldn't find matching " << associated_codec->name << " codec."; << "Couldn't find matching " << associated_codec->name << " codec.";
@ -693,16 +698,14 @@ void MergeCodecs(const CodecList& reference_codecs,
offered_codecs.push_back(rtx_codec); offered_codecs.push_back(rtx_codec);
} else if (reference_codec.GetResiliencyType() == } else if (reference_codec.GetResiliencyType() ==
Codec::ResiliencyType::kRed && Codec::ResiliencyType::kRed &&
!webrtc::FindMatchingCodec(reference_codecs.codecs(), !FindMatchingCodec(reference_codecs, offered_codecs,
offered_codecs.codecs(),
reference_codec)) { reference_codec)) {
Codec red_codec = reference_codec; Codec red_codec = reference_codec;
const Codec* associated_codec = const Codec* associated_codec =
GetAssociatedCodecForRed(reference_codecs, red_codec); GetAssociatedCodecForRed(reference_codecs, red_codec);
if (associated_codec) { if (associated_codec) {
std::optional<Codec> matching_codec = webrtc::FindMatchingCodec( std::optional<Codec> matching_codec = FindMatchingCodec(
reference_codecs.codecs(), offered_codecs.codecs(), reference_codecs, offered_codecs, *associated_codec);
*associated_codec);
if (!matching_codec) { if (!matching_codec) {
RTC_LOG(LS_WARNING) << "Couldn't find matching " RTC_LOG(LS_WARNING) << "Couldn't find matching "
<< associated_codec->name << " codec."; << associated_codec->name << " codec.";
@ -751,8 +754,7 @@ CodecList MatchCodecPreference(
if (found_codec != supported_codecs.end()) { if (found_codec != supported_codecs.end()) {
std::optional<Codec> found_codec_with_correct_pt = std::optional<Codec> found_codec_with_correct_pt =
webrtc::FindMatchingCodec(supported_codecs.codecs(), codecs.codecs(), FindMatchingCodec(supported_codecs, codecs, *found_codec);
*found_codec);
if (found_codec_with_correct_pt) { if (found_codec_with_correct_pt) {
// RED may already have been added if its primary codec is before RED // RED may already have been added if its primary codec is before RED
// in the codec list. // in the codec list.
@ -1159,11 +1161,10 @@ webrtc::RTCErrorOr<std::vector<Codec>> GetNegotiatedCodecsForOffer(
} }
// Add other supported codecs. // Add other supported codecs.
for (const Codec& codec : supported_codecs) { for (const Codec& codec : supported_codecs) {
std::optional<Codec> found_codec = webrtc::FindMatchingCodec( std::optional<Codec> found_codec =
supported_codecs.codecs(), codecs.codecs(), codec); FindMatchingCodec(supported_codecs, codecs, codec);
if (found_codec && if (found_codec &&
!webrtc::FindMatchingCodec(supported_codecs.codecs(), !FindMatchingCodec(supported_codecs, filtered_codecs, codec)) {
filtered_codecs.codecs(), codec)) {
// Use the `found_codec` from `codecs` because it has the // Use the `found_codec` from `codecs` because it has the
// correctly mapped payload type. // correctly mapped payload type.
// This is only done for video since we do not yet have rtx for audio. // This is only done for video since we do not yet have rtx for audio.
@ -1176,10 +1177,8 @@ webrtc::RTCErrorOr<std::vector<Codec>> GetNegotiatedCodecsForOffer(
RTC_DCHECK(referenced_codec); RTC_DCHECK(referenced_codec);
// Find the codec we should be referencing and point to it. // Find the codec we should be referencing and point to it.
std::optional<Codec> changed_referenced_codec = std::optional<Codec> changed_referenced_codec = FindMatchingCodec(
webrtc::FindMatchingCodec(supported_codecs.codecs(), supported_codecs, filtered_codecs, *referenced_codec);
filtered_codecs.codecs(),
*referenced_codec);
if (changed_referenced_codec) { if (changed_referenced_codec) {
found_codec->SetParam(kCodecParamAssociatedPayloadType, found_codec->SetParam(kCodecParamAssociatedPayloadType,
changed_referenced_codec->id); changed_referenced_codec->id);
@ -1241,10 +1240,8 @@ webrtc::RTCErrorOr<Codecs> GetNegotiatedCodecsForAnswer(
// Add other supported codecs. // Add other supported codecs.
CodecList other_codecs; CodecList other_codecs;
for (const Codec& codec : supported_codecs) { for (const Codec& codec : supported_codecs) {
if (webrtc::FindMatchingCodec(supported_codecs.codecs(), codecs.codecs(), if (FindMatchingCodec(supported_codecs, codecs, codec) &&
codec) && !FindMatchingCodec(supported_codecs, filtered_codecs, codec)) {
!webrtc::FindMatchingCodec(supported_codecs.codecs(),
filtered_codecs.codecs(), codec)) {
// We should use the local codec with local parameters and the codec id // We should use the local codec with local parameters and the codec id
// would be correctly mapped in `NegotiateCodecs`. // would be correctly mapped in `NegotiateCodecs`.
other_codecs.push_back(codec); other_codecs.push_back(codec);
@ -1331,50 +1328,52 @@ MediaSessionDescriptionFactory::MediaSessionDescriptionFactory(
"WebRTC-PayloadTypesInTransport")) { "WebRTC-PayloadTypesInTransport")) {
RTC_CHECK(transport_desc_factory_); RTC_CHECK(transport_desc_factory_);
if (media_engine) { if (media_engine) {
audio_send_codecs_ = media_engine->voice().send_codecs(); audio_send_codecs_ = CodecList(media_engine->voice().send_codecs());
audio_recv_codecs_ = media_engine->voice().recv_codecs(); audio_recv_codecs_ = CodecList(media_engine->voice().recv_codecs());
video_send_codecs_ = media_engine->video().send_codecs(rtx_enabled); video_send_codecs_ =
video_recv_codecs_ = media_engine->video().recv_codecs(rtx_enabled); CodecList(media_engine->video().send_codecs(rtx_enabled));
video_recv_codecs_ =
CodecList(media_engine->video().recv_codecs(rtx_enabled));
} }
ComputeAudioCodecsIntersectionAndUnion(); ComputeAudioCodecsIntersectionAndUnion();
ComputeVideoCodecsIntersectionAndUnion(); ComputeVideoCodecsIntersectionAndUnion();
} }
const Codecs& MediaSessionDescriptionFactory::audio_sendrecv_codecs() const { const CodecList& MediaSessionDescriptionFactory::audio_sendrecv_codecs() const {
return audio_sendrecv_codecs_; return audio_sendrecv_codecs_;
} }
const Codecs& MediaSessionDescriptionFactory::audio_send_codecs() const { const CodecList& MediaSessionDescriptionFactory::audio_send_codecs() const {
return audio_send_codecs_; return audio_send_codecs_;
} }
const Codecs& MediaSessionDescriptionFactory::audio_recv_codecs() const { const CodecList& MediaSessionDescriptionFactory::audio_recv_codecs() const {
return audio_recv_codecs_; return audio_recv_codecs_;
} }
void MediaSessionDescriptionFactory::set_audio_codecs( void MediaSessionDescriptionFactory::set_audio_codecs(
const Codecs& send_codecs, const CodecList& send_codecs,
const Codecs& recv_codecs) { const CodecList& recv_codecs) {
audio_send_codecs_ = send_codecs; audio_send_codecs_ = send_codecs;
audio_recv_codecs_ = recv_codecs; audio_recv_codecs_ = recv_codecs;
ComputeAudioCodecsIntersectionAndUnion(); ComputeAudioCodecsIntersectionAndUnion();
} }
const Codecs& MediaSessionDescriptionFactory::video_sendrecv_codecs() const { const CodecList& MediaSessionDescriptionFactory::video_sendrecv_codecs() const {
return video_sendrecv_codecs_; return video_sendrecv_codecs_;
} }
const Codecs& MediaSessionDescriptionFactory::video_send_codecs() const { const CodecList& MediaSessionDescriptionFactory::video_send_codecs() const {
return video_send_codecs_; return video_send_codecs_;
} }
const Codecs& MediaSessionDescriptionFactory::video_recv_codecs() const { const CodecList& MediaSessionDescriptionFactory::video_recv_codecs() const {
return video_recv_codecs_; return video_recv_codecs_;
} }
void MediaSessionDescriptionFactory::set_video_codecs( void MediaSessionDescriptionFactory::set_video_codecs(
const Codecs& send_codecs, const CodecList& send_codecs,
const Codecs& recv_codecs) { const CodecList& recv_codecs) {
video_send_codecs_ = send_codecs; video_send_codecs_ = send_codecs;
video_recv_codecs_ = recv_codecs; video_recv_codecs_ = recv_codecs;
ComputeVideoCodecsIntersectionAndUnion(); ComputeVideoCodecsIntersectionAndUnion();
@ -1746,7 +1745,7 @@ MediaSessionDescriptionFactory::CreateAnswerOrError(
return answer; return answer;
} }
const Codecs& MediaSessionDescriptionFactory::GetAudioCodecsForOffer( const CodecList& MediaSessionDescriptionFactory::GetAudioCodecsForOffer(
const RtpTransceiverDirection& direction) const { const RtpTransceiverDirection& direction) const {
switch (direction) { switch (direction) {
// If stream is inactive - generate list as if sendrecv. // If stream is inactive - generate list as if sendrecv.
@ -1762,7 +1761,7 @@ const Codecs& MediaSessionDescriptionFactory::GetAudioCodecsForOffer(
RTC_CHECK_NOTREACHED(); RTC_CHECK_NOTREACHED();
} }
const Codecs& MediaSessionDescriptionFactory::GetAudioCodecsForAnswer( const CodecList& MediaSessionDescriptionFactory::GetAudioCodecsForAnswer(
const RtpTransceiverDirection& offer, const RtpTransceiverDirection& offer,
const RtpTransceiverDirection& answer) const { const RtpTransceiverDirection& answer) const {
switch (answer) { switch (answer) {
@ -1781,7 +1780,7 @@ const Codecs& MediaSessionDescriptionFactory::GetAudioCodecsForAnswer(
RTC_CHECK_NOTREACHED(); RTC_CHECK_NOTREACHED();
} }
const Codecs& MediaSessionDescriptionFactory::GetVideoCodecsForOffer( const CodecList& MediaSessionDescriptionFactory::GetVideoCodecsForOffer(
const RtpTransceiverDirection& direction) const { const RtpTransceiverDirection& direction) const {
switch (direction) { switch (direction) {
// If stream is inactive - generate list as if sendrecv. // If stream is inactive - generate list as if sendrecv.
@ -1797,7 +1796,7 @@ const Codecs& MediaSessionDescriptionFactory::GetVideoCodecsForOffer(
RTC_CHECK_NOTREACHED(); RTC_CHECK_NOTREACHED();
} }
const Codecs& MediaSessionDescriptionFactory::GetVideoCodecsForAnswer( const CodecList& MediaSessionDescriptionFactory::GetVideoCodecsForAnswer(
const RtpTransceiverDirection& offer, const RtpTransceiverDirection& offer,
const RtpTransceiverDirection& answer) const { const RtpTransceiverDirection& answer) const {
switch (answer) { switch (answer) {
@ -1886,22 +1885,20 @@ void MediaSessionDescriptionFactory::GetCodecsForAnswer(
if (IsMediaContentOfType(&content, MEDIA_TYPE_AUDIO)) { if (IsMediaContentOfType(&content, MEDIA_TYPE_AUDIO)) {
CodecList offered_codecs(content.media_description()->codecs()); CodecList offered_codecs(content.media_description()->codecs());
for (const Codec& offered_audio_codec : offered_codecs) { for (const Codec& offered_audio_codec : offered_codecs) {
if (!webrtc::FindMatchingCodec(offered_codecs.codecs(), if (!FindMatchingCodec(offered_codecs, filtered_offered_audio_codecs,
filtered_offered_audio_codecs.codecs(),
offered_audio_codec) && offered_audio_codec) &&
webrtc::FindMatchingCodec(offered_codecs.codecs(), FindMatchingCodec(offered_codecs, all_audio_codecs_,
all_audio_codecs_, offered_audio_codec)) { offered_audio_codec)) {
filtered_offered_audio_codecs.push_back(offered_audio_codec); filtered_offered_audio_codecs.push_back(offered_audio_codec);
} }
} }
} else if (IsMediaContentOfType(&content, MEDIA_TYPE_VIDEO)) { } else if (IsMediaContentOfType(&content, MEDIA_TYPE_VIDEO)) {
CodecList offered_codecs(content.media_description()->codecs()); CodecList offered_codecs(content.media_description()->codecs());
for (const Codec& offered_video_codec : offered_codecs) { for (const Codec& offered_video_codec : offered_codecs) {
if (!webrtc::FindMatchingCodec(offered_codecs.codecs(), if (!FindMatchingCodec(offered_codecs, filtered_offered_video_codecs,
filtered_offered_video_codecs.codecs(),
offered_video_codec) && offered_video_codec) &&
webrtc::FindMatchingCodec(offered_codecs.codecs(), FindMatchingCodec(offered_codecs, all_video_codecs_,
all_video_codecs_, offered_video_codec)) { offered_video_codec)) {
filtered_offered_video_codecs.push_back(offered_video_codec); filtered_offered_video_codecs.push_back(offered_video_codec);
} }
} }
@ -2049,7 +2046,7 @@ RTCError MediaSessionDescriptionFactory::AddRtpContentForOffer(
std::vector<Codec> codecs_to_include; std::vector<Codec> codecs_to_include;
if (media_description_options.codecs_to_include.empty()) { if (media_description_options.codecs_to_include.empty()) {
std::vector<Codec> supported_codecs = CodecList supported_codecs =
media_description_options.type == MEDIA_TYPE_AUDIO media_description_options.type == MEDIA_TYPE_AUDIO
? GetAudioCodecsForOffer(media_description_options.direction) ? GetAudioCodecsForOffer(media_description_options.direction)
: GetVideoCodecsForOffer(media_description_options.direction); : GetVideoCodecsForOffer(media_description_options.direction);
@ -2219,7 +2216,7 @@ RTCError MediaSessionDescriptionFactory::AddRtpContentForAnswer(
std::vector<Codec> codecs_to_include; std::vector<Codec> codecs_to_include;
bool negotiate; bool negotiate;
if (media_description_options.codecs_to_include.empty()) { if (media_description_options.codecs_to_include.empty()) {
const std::vector<Codec>& supported_codecs = const CodecList& supported_codecs =
media_description_options.type == MEDIA_TYPE_AUDIO media_description_options.type == MEDIA_TYPE_AUDIO
? GetAudioCodecsForAnswer(offer_rtd, answer_rtd) ? GetAudioCodecsForAnswer(offer_rtd, answer_rtd)
: GetVideoCodecsForAnswer(offer_rtd, answer_rtd); : GetVideoCodecsForAnswer(offer_rtd, answer_rtd);
@ -2253,7 +2250,8 @@ RTCError MediaSessionDescriptionFactory::AddRtpContentForAnswer(
} }
if (negotiate) { if (negotiate) {
std::vector<Codec> negotiated_codecs; std::vector<Codec> negotiated_codecs;
NegotiateCodecs(codecs_to_include, offer_content_description->codecs(), NegotiateCodecs(CodecList(codecs_to_include),
CodecList(offer_content_description->codecs()),
&negotiated_codecs, &negotiated_codecs,
media_description_options.codec_preferences.empty()); media_description_options.codec_preferences.empty());
codecs_to_include = negotiated_codecs; codecs_to_include = negotiated_codecs;
@ -2431,16 +2429,14 @@ void MediaSessionDescriptionFactory::ComputeAudioCodecsIntersectionAndUnion() {
// Compute the audio codecs union. // Compute the audio codecs union.
for (const Codec& send : audio_send_codecs_) { for (const Codec& send : audio_send_codecs_) {
all_audio_codecs_.push_back(send); all_audio_codecs_.push_back(send);
if (!webrtc::FindMatchingCodec(audio_send_codecs_, audio_recv_codecs_, if (!FindMatchingCodec(audio_send_codecs_, audio_recv_codecs_, send)) {
send)) {
// It doesn't make sense to have an RTX codec we support sending but not // It doesn't make sense to have an RTX codec we support sending but not
// receiving. // receiving.
RTC_DCHECK(send.GetResiliencyType() != Codec::ResiliencyType::kRtx); RTC_DCHECK(send.GetResiliencyType() != Codec::ResiliencyType::kRtx);
} }
} }
for (const Codec& recv : audio_recv_codecs_) { for (const Codec& recv : audio_recv_codecs_) {
if (!webrtc::FindMatchingCodec(audio_recv_codecs_, audio_send_codecs_, if (!FindMatchingCodec(audio_recv_codecs_, audio_send_codecs_, recv)) {
recv)) {
all_audio_codecs_.push_back(recv); all_audio_codecs_.push_back(recv);
} }
} }
@ -2449,8 +2445,10 @@ void MediaSessionDescriptionFactory::ComputeAudioCodecsIntersectionAndUnion() {
// order we'd like to follow. The reasoning is that encoding is usually more // order we'd like to follow. The reasoning is that encoding is usually more
// expensive than decoding, and prioritizing a codec in the send list probably // expensive than decoding, and prioritizing a codec in the send list probably
// means it's a codec we can handle efficiently. // means it's a codec we can handle efficiently.
std::vector<Codec> audio_sendrecv_codecs_vector;
NegotiateCodecs(audio_recv_codecs_, audio_send_codecs_, NegotiateCodecs(audio_recv_codecs_, audio_send_codecs_,
&audio_sendrecv_codecs_, true); &audio_sendrecv_codecs_vector, true);
audio_sendrecv_codecs_ = CodecList(audio_sendrecv_codecs_vector);
} }
void MediaSessionDescriptionFactory::ComputeVideoCodecsIntersectionAndUnion() { void MediaSessionDescriptionFactory::ComputeVideoCodecsIntersectionAndUnion() {
@ -2458,8 +2456,7 @@ void MediaSessionDescriptionFactory::ComputeVideoCodecsIntersectionAndUnion() {
// Use ComputeCodecsUnion to avoid having duplicate payload IDs // Use ComputeCodecsUnion to avoid having duplicate payload IDs
all_video_codecs_ = ComputeCodecsUnion(CodecList(video_recv_codecs_), all_video_codecs_ = ComputeCodecsUnion(CodecList(video_recv_codecs_),
CodecList(video_send_codecs_)) CodecList(video_send_codecs_));
.codecs();
// Use NegotiateCodecs to merge our codec lists, since the operation is // Use NegotiateCodecs to merge our codec lists, since the operation is
// essentially the same. Put send_codecs as the offered_codecs, which is the // essentially the same. Put send_codecs as the offered_codecs, which is the
@ -2469,8 +2466,10 @@ void MediaSessionDescriptionFactory::ComputeVideoCodecsIntersectionAndUnion() {
// Also for the same profile of a codec, if there are different levels in the // Also for the same profile of a codec, if there are different levels in the
// send and receive codecs, |video_sendrecv_codecs_| will contain the lower // send and receive codecs, |video_sendrecv_codecs_| will contain the lower
// level of the two for that profile. // level of the two for that profile.
std::vector<Codec> video_sendrecv_codecs_vector;
NegotiateCodecs(video_recv_codecs_, video_send_codecs_, NegotiateCodecs(video_recv_codecs_, video_send_codecs_,
&video_sendrecv_codecs_, true); &video_sendrecv_codecs_vector, true);
video_sendrecv_codecs_ = CodecList(video_sendrecv_codecs_vector);
} }
bool IsMediaContent(const ContentInfo* content) { bool IsMediaContent(const ContentInfo* content) {

51
pc/media_session.h
View File

@ -24,6 +24,7 @@
#include "api/rtp_transceiver_direction.h" #include "api/rtp_transceiver_direction.h"
#include "call/payload_type.h" #include "call/payload_type.h"
#include "media/base/codec.h" #include "media/base/codec.h"
#include "media/base/codec_list.h"
#include "media/base/rid_description.h" #include "media/base/rid_description.h"
#include "media/base/stream_params.h" #include "media/base/stream_params.h"
#include "p2p/base/ice_credentials_iterator.h" #include "p2p/base/ice_credentials_iterator.h"
@ -151,14 +152,24 @@ class MediaSessionDescriptionFactory {
const TransportDescriptionFactory* factory, const TransportDescriptionFactory* factory,
webrtc::PayloadTypeSuggester* pt_suggester); webrtc::PayloadTypeSuggester* pt_suggester);
const Codecs& audio_sendrecv_codecs() const; const CodecList& audio_sendrecv_codecs() const;
const Codecs& audio_send_codecs() const; const CodecList& audio_send_codecs() const;
const Codecs& audio_recv_codecs() const; const CodecList& audio_recv_codecs() const;
void set_audio_codecs(const Codecs& send_codecs, const Codecs& recv_codecs); void set_audio_codecs(const CodecList& send_codecs,
const Codecs& video_sendrecv_codecs() const; const CodecList& recv_codecs);
const Codecs& video_send_codecs() const; void set_audio_codecs(const std::vector<Codec>& send_codecs,
const Codecs& video_recv_codecs() const; const std::vector<Codec>& recv_codecs) {
void set_video_codecs(const Codecs& send_codecs, const Codecs& recv_codecs); set_audio_codecs(CodecList(send_codecs), CodecList(recv_codecs));
}
const CodecList& video_sendrecv_codecs() const;
const CodecList& video_send_codecs() const;
const CodecList& video_recv_codecs() const;
void set_video_codecs(const CodecList& send_codecs,
const CodecList& recv_codecs);
void set_video_codecs(const std::vector<Codec>& send_codecs,
const std::vector<Codec>& recv_codecs) {
set_video_codecs(CodecList(send_codecs), CodecList(recv_codecs));
}
RtpHeaderExtensions filtered_rtp_header_extensions( RtpHeaderExtensions filtered_rtp_header_extensions(
RtpHeaderExtensions extensions) const; RtpHeaderExtensions extensions) const;
@ -184,14 +195,14 @@ class MediaSessionDescriptionFactory {
RtpHeaderExtensions video; RtpHeaderExtensions video;
}; };
const Codecs& GetAudioCodecsForOffer( const CodecList& GetAudioCodecsForOffer(
const webrtc::RtpTransceiverDirection& direction) const; const webrtc::RtpTransceiverDirection& direction) const;
const Codecs& GetAudioCodecsForAnswer( const CodecList& GetAudioCodecsForAnswer(
const webrtc::RtpTransceiverDirection& offer, const webrtc::RtpTransceiverDirection& offer,
const webrtc::RtpTransceiverDirection& answer) const; const webrtc::RtpTransceiverDirection& answer) const;
const Codecs& GetVideoCodecsForOffer( const CodecList& GetVideoCodecsForOffer(
const webrtc::RtpTransceiverDirection& direction) const; const webrtc::RtpTransceiverDirection& direction) const;
const Codecs& GetVideoCodecsForAnswer( const CodecList& GetVideoCodecsForAnswer(
const webrtc::RtpTransceiverDirection& offer, const webrtc::RtpTransceiverDirection& offer,
const webrtc::RtpTransceiverDirection& answer) const; const webrtc::RtpTransceiverDirection& answer) const;
void GetCodecsForOffer( void GetCodecsForOffer(
@ -303,18 +314,18 @@ class MediaSessionDescriptionFactory {
} }
bool is_unified_plan_ = false; bool is_unified_plan_ = false;
Codecs audio_send_codecs_; CodecList audio_send_codecs_;
Codecs audio_recv_codecs_; CodecList audio_recv_codecs_;
// Intersection of send and recv. // Intersection of send and recv.
Codecs audio_sendrecv_codecs_; CodecList audio_sendrecv_codecs_;
// Union of send and recv. // Union of send and recv.
Codecs all_audio_codecs_; CodecList all_audio_codecs_;
Codecs video_send_codecs_; CodecList video_send_codecs_;
Codecs video_recv_codecs_; CodecList video_recv_codecs_;
// Intersection of send and recv. // Intersection of send and recv.
Codecs video_sendrecv_codecs_; CodecList video_sendrecv_codecs_;
// Union of send and recv. // Union of send and recv.
Codecs all_video_codecs_; CodecList all_video_codecs_;
// This object may or may not be owned by this class. // This object may or may not be owned by this class.
webrtc::AlwaysValidPointer<rtc::UniqueRandomIdGenerator> const webrtc::AlwaysValidPointer<rtc::UniqueRandomIdGenerator> const
ssrc_generator_; ssrc_generator_;

102
pc/media_session_unittest.cc
View File

@ -855,13 +855,13 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateVideoOffer) {
const MediaContentDescription* acd = ac->media_description(); const MediaContentDescription* acd = ac->media_description();
const MediaContentDescription* vcd = vc->media_description(); const MediaContentDescription* vcd = vc->media_description();
EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type()); EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
EXPECT_EQ(f1_.audio_sendrecv_codecs(), acd->codecs()); EXPECT_EQ(f1_.audio_sendrecv_codecs().codecs(), acd->codecs());
EXPECT_EQ(0U, acd->first_ssrc()); // no sender is attached EXPECT_EQ(0U, acd->first_ssrc()); // no sender is attached
EXPECT_EQ(kAutoBandwidth, acd->bandwidth()); // default bandwidth (auto) EXPECT_EQ(kAutoBandwidth, acd->bandwidth()); // default bandwidth (auto)
EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on
EXPECT_EQ(kMediaProtocolDtlsSavpf, acd->protocol()); EXPECT_EQ(kMediaProtocolDtlsSavpf, acd->protocol());
EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type()); EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type());
EXPECT_EQ(f1_.video_sendrecv_codecs(), vcd->codecs()); EXPECT_EQ(f1_.video_sendrecv_codecs().codecs(), vcd->codecs());
EXPECT_EQ(0U, vcd->first_ssrc()); // no sender is attached EXPECT_EQ(0U, vcd->first_ssrc()); // no sender is attached
EXPECT_EQ(kAutoBandwidth, vcd->bandwidth()); // default bandwidth (auto) EXPECT_EQ(kAutoBandwidth, vcd->bandwidth()); // default bandwidth (auto)
EXPECT_TRUE(vcd->rtcp_mux()); // rtcp-mux defaults on EXPECT_TRUE(vcd->rtcp_mux()); // rtcp-mux defaults on
@ -2617,7 +2617,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateMultiStreamVideoOffer) {
const MediaContentDescription* acd = ac->media_description(); const MediaContentDescription* acd = ac->media_description();
const MediaContentDescription* vcd = vc->media_description(); const MediaContentDescription* vcd = vc->media_description();
EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type()); EXPECT_EQ(MEDIA_TYPE_AUDIO, acd->type());
EXPECT_EQ(f1_.audio_sendrecv_codecs(), acd->codecs()); EXPECT_EQ(f1_.audio_sendrecv_codecs().codecs(), acd->codecs());
const StreamParamsVec& audio_streams = acd->streams(); const StreamParamsVec& audio_streams = acd->streams();
ASSERT_EQ(2U, audio_streams.size()); ASSERT_EQ(2U, audio_streams.size());
@ -2633,7 +2633,7 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestCreateMultiStreamVideoOffer) {
EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on EXPECT_TRUE(acd->rtcp_mux()); // rtcp-mux defaults on
EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type()); EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type());
EXPECT_EQ(f1_.video_sendrecv_codecs(), vcd->codecs()); EXPECT_EQ(f1_.video_sendrecv_codecs().codecs(), vcd->codecs());
const StreamParamsVec& video_streams = vcd->streams(); const StreamParamsVec& video_streams = vcd->streams();
ASSERT_EQ(1U, video_streams.size()); ASSERT_EQ(1U, video_streams.size());
@ -3028,8 +3028,8 @@ TEST_F(MediaSessionDescriptionFactoryTest,
// that is being recycled. // that is being recycled.
TEST_F(MediaSessionDescriptionFactoryTest, TEST_F(MediaSessionDescriptionFactoryTest,
ReOfferDoesNotReUseRecycledAudioCodecs) { ReOfferDoesNotReUseRecycledAudioCodecs) {
f1_.set_video_codecs({}, {}); f1_.set_video_codecs(CodecList{}, CodecList{});
f2_.set_video_codecs({}, {}); f2_.set_video_codecs(CodecList{}, CodecList{});
MediaSessionOptions opts; MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_AUDIO, "a0", AddMediaDescriptionOptions(MEDIA_TYPE_AUDIO, "a0",
@ -3062,8 +3062,8 @@ TEST_F(MediaSessionDescriptionFactoryTest,
// that is being recycled. // that is being recycled.
TEST_F(MediaSessionDescriptionFactoryTest, TEST_F(MediaSessionDescriptionFactoryTest,
ReOfferDoesNotReUseRecycledVideoCodecs) { ReOfferDoesNotReUseRecycledVideoCodecs) {
f1_.set_audio_codecs({}, {}); f1_.set_audio_codecs(CodecList{}, CodecList{});
f2_.set_audio_codecs({}, {}); f2_.set_audio_codecs(CodecList{}, CodecList{});
MediaSessionOptions opts; MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "v0", AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "v0",
@ -3089,8 +3089,8 @@ TEST_F(MediaSessionDescriptionFactoryTest,
// section that is being recycled. // section that is being recycled.
TEST_F(MediaSessionDescriptionFactoryTest, TEST_F(MediaSessionDescriptionFactoryTest,
ReAnswerDoesNotReUseRecycledAudioCodecs) { ReAnswerDoesNotReUseRecycledAudioCodecs) {
f1_.set_video_codecs({}, {}); f1_.set_video_codecs(CodecList{}, CodecList{});
f2_.set_video_codecs({}, {}); f2_.set_video_codecs(CodecList{}, CodecList{});
// Perform initial offer/answer in reverse (`f2_` as offerer) so that the // Perform initial offer/answer in reverse (`f2_` as offerer) so that the
// second offer/answer is forward (`f1_` as offerer). // second offer/answer is forward (`f1_` as offerer).
@ -3121,8 +3121,8 @@ TEST_F(MediaSessionDescriptionFactoryTest,
// section that is being recycled. // section that is being recycled.
TEST_F(MediaSessionDescriptionFactoryTest, TEST_F(MediaSessionDescriptionFactoryTest,
ReAnswerDoesNotReUseRecycledVideoCodecs) { ReAnswerDoesNotReUseRecycledVideoCodecs) {
f1_.set_audio_codecs({}, {}); f1_.set_audio_codecs(CodecList{}, CodecList{});
f2_.set_audio_codecs({}, {}); f2_.set_audio_codecs(CodecList{}, CodecList{});
// Perform initial offer/answer in reverse (`f2_` as offerer) so that the // Perform initial offer/answer in reverse (`f2_` as offerer) so that the
// second offer/answer is forward (`f1_` as offerer). // second offer/answer is forward (`f1_` as offerer).
@ -4677,27 +4677,27 @@ TEST_F(MediaSessionDescriptionFactoryTest, TestSetAudioCodecs) {
// Test proper merge // Test proper merge
sf.set_audio_codecs(send_codecs, recv_codecs); sf.set_audio_codecs(send_codecs, recv_codecs);
EXPECT_EQ(send_codecs, sf.audio_send_codecs()); EXPECT_EQ(send_codecs, sf.audio_send_codecs().codecs());
EXPECT_EQ(recv_codecs, sf.audio_recv_codecs()); EXPECT_EQ(recv_codecs, sf.audio_recv_codecs().codecs());
EXPECT_EQ(sendrecv_codecs, sf.audio_sendrecv_codecs()); EXPECT_EQ(sendrecv_codecs, sf.audio_sendrecv_codecs().codecs());
// Test empty send codecs list // Test empty send codecs list
sf.set_audio_codecs(no_codecs, recv_codecs); sf.set_audio_codecs(no_codecs, recv_codecs);
EXPECT_EQ(no_codecs, sf.audio_send_codecs()); EXPECT_EQ(no_codecs, sf.audio_send_codecs().codecs());
EXPECT_EQ(recv_codecs, sf.audio_recv_codecs()); EXPECT_EQ(recv_codecs, sf.audio_recv_codecs().codecs());
EXPECT_EQ(no_codecs, sf.audio_sendrecv_codecs()); EXPECT_EQ(no_codecs, sf.audio_sendrecv_codecs().codecs());
// Test empty recv codecs list // Test empty recv codecs list
sf.set_audio_codecs(send_codecs, no_codecs); sf.set_audio_codecs(send_codecs, no_codecs);
EXPECT_EQ(send_codecs, sf.audio_send_codecs()); EXPECT_EQ(send_codecs, sf.audio_send_codecs().codecs());
EXPECT_EQ(no_codecs, sf.audio_recv_codecs()); EXPECT_EQ(no_codecs, sf.audio_recv_codecs().codecs());
EXPECT_EQ(no_codecs, sf.audio_sendrecv_codecs()); EXPECT_EQ(no_codecs, sf.audio_sendrecv_codecs().codecs());
// Test all empty codec lists // Test all empty codec lists
sf.set_audio_codecs(no_codecs, no_codecs); sf.set_audio_codecs(no_codecs, no_codecs);
EXPECT_EQ(no_codecs, sf.audio_send_codecs()); EXPECT_EQ(no_codecs, sf.audio_send_codecs().codecs());
EXPECT_EQ(no_codecs, sf.audio_recv_codecs()); EXPECT_EQ(no_codecs, sf.audio_recv_codecs().codecs());
EXPECT_EQ(no_codecs, sf.audio_sendrecv_codecs()); EXPECT_EQ(no_codecs, sf.audio_sendrecv_codecs().codecs());
} }
// Compare the two vectors of codecs ignoring the payload type. // Compare the two vectors of codecs ignoring the payload type.
@ -5029,7 +5029,7 @@ TEST_F(VideoCodecsOfferH265LevelIdTest, TestSendRecvSymmetrical) {
MAKE_VECTOR(kVideoCodecsH265Level52); MAKE_VECTOR(kVideoCodecsH265Level52);
sf_offerer_.set_video_codecs(send_codecs, recv_codecs); sf_offerer_.set_video_codecs(send_codecs, recv_codecs);
sf_answerer_.set_video_codecs(recv_codecs, send_codecs); sf_answerer_.set_video_codecs(recv_codecs, send_codecs);
EXPECT_EQ(sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); EXPECT_EQ(sendrecv_codecs, sf_offerer_.video_sendrecv_codecs().codecs());
MediaSessionOptions opts; MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
@ -5076,7 +5076,7 @@ TEST_F(VideoCodecsOfferH265LevelIdTest, TestSendOnlySymmetrical) {
MAKE_VECTOR(kVideoCodecsH265Level6); MAKE_VECTOR(kVideoCodecsH265Level6);
sf_offerer_.set_video_codecs(send_codecs, recv_codecs); sf_offerer_.set_video_codecs(send_codecs, recv_codecs);
sf_answerer_.set_video_codecs(recv_codecs, send_codecs); sf_answerer_.set_video_codecs(recv_codecs, send_codecs);
EXPECT_EQ(sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); EXPECT_EQ(sendrecv_codecs, sf_offerer_.video_sendrecv_codecs().codecs());
MediaSessionOptions opts; MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
@ -5120,7 +5120,7 @@ TEST_F(VideoCodecsOfferH265LevelIdTest, TestRecvOnlySymmetrical) {
MAKE_VECTOR(kVideoCodecsH265Level52); MAKE_VECTOR(kVideoCodecsH265Level52);
sf_offerer_.set_video_codecs(send_codecs, recv_codecs); sf_offerer_.set_video_codecs(send_codecs, recv_codecs);
sf_answerer_.set_video_codecs(recv_codecs, send_codecs); sf_answerer_.set_video_codecs(recv_codecs, send_codecs);
EXPECT_EQ(sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); EXPECT_EQ(sendrecv_codecs, sf_offerer_.video_sendrecv_codecs().codecs());
MediaSessionOptions opts; MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
@ -5170,7 +5170,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest,
MAKE_VECTOR(kVideoCodecsH265Level52); MAKE_VECTOR(kVideoCodecsH265Level52);
sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs);
sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs);
EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); EXPECT_EQ(offerer_sendrecv_codecs,
sf_offerer_.video_sendrecv_codecs().codecs());
MediaSessionOptions opts; MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
@ -5225,7 +5226,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest,
MAKE_VECTOR(kVideoCodecsH265Level6); MAKE_VECTOR(kVideoCodecsH265Level6);
sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs);
sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs);
EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); EXPECT_EQ(offerer_sendrecv_codecs,
sf_offerer_.video_sendrecv_codecs().codecs());
MediaSessionOptions opts; MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
@ -5280,7 +5282,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest,
MAKE_VECTOR(kVideoCodecsH265Level5); MAKE_VECTOR(kVideoCodecsH265Level5);
sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs);
sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs);
EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); EXPECT_EQ(offerer_sendrecv_codecs,
sf_offerer_.video_sendrecv_codecs().codecs());
MediaSessionOptions opts; MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
@ -5345,7 +5348,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest,
MAKE_VECTOR(kVideoCodecsH265Level6); MAKE_VECTOR(kVideoCodecsH265Level6);
sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs);
sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs);
EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); EXPECT_EQ(offerer_sendrecv_codecs,
sf_offerer_.video_sendrecv_codecs().codecs());
MediaSessionOptions opts; MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
@ -5400,7 +5404,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest,
MAKE_VECTOR(kVideoCodecsH265Level52); MAKE_VECTOR(kVideoCodecsH265Level52);
sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs);
sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs);
EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); EXPECT_EQ(offerer_sendrecv_codecs,
sf_offerer_.video_sendrecv_codecs().codecs());
MediaSessionOptions opts; MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
@ -5455,7 +5460,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest,
MAKE_VECTOR(kVideoCodecsH265Level52); MAKE_VECTOR(kVideoCodecsH265Level52);
sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs);
sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs);
EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); EXPECT_EQ(offerer_sendrecv_codecs,
sf_offerer_.video_sendrecv_codecs().codecs());
MediaSessionOptions opts; MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
@ -5507,7 +5513,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest,
MAKE_VECTOR(kVideoCodecsH265Level6); MAKE_VECTOR(kVideoCodecsH265Level6);
sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs);
sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs);
EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); EXPECT_EQ(offerer_sendrecv_codecs,
sf_offerer_.video_sendrecv_codecs().codecs());
MediaSessionOptions opts; MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
@ -5559,7 +5566,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest,
MAKE_VECTOR(kVideoCodecsH265Level5); MAKE_VECTOR(kVideoCodecsH265Level5);
sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs);
sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs);
EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); EXPECT_EQ(offerer_sendrecv_codecs,
sf_offerer_.video_sendrecv_codecs().codecs());
MediaSessionOptions opts; MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
@ -5611,7 +5619,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest,
MAKE_VECTOR(kVideoCodecsH265Level6); MAKE_VECTOR(kVideoCodecsH265Level6);
sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs);
sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs);
EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); EXPECT_EQ(offerer_sendrecv_codecs,
sf_offerer_.video_sendrecv_codecs().codecs());
MediaSessionOptions opts; MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
@ -5663,7 +5672,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest,
MAKE_VECTOR(kVideoCodecsH265Level52); MAKE_VECTOR(kVideoCodecsH265Level52);
sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs);
sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs);
EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); EXPECT_EQ(offerer_sendrecv_codecs,
sf_offerer_.video_sendrecv_codecs().codecs());
MediaSessionOptions opts; MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
@ -5715,7 +5725,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest,
MAKE_VECTOR(kVideoCodecsH265Level52); MAKE_VECTOR(kVideoCodecsH265Level52);
sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs);
sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs);
EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); EXPECT_EQ(offerer_sendrecv_codecs,
sf_offerer_.video_sendrecv_codecs().codecs());
MediaSessionOptions opts; MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
@ -5768,7 +5779,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest,
MAKE_VECTOR(kVideoCodecsH265Level6); MAKE_VECTOR(kVideoCodecsH265Level6);
sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs);
sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs);
EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); EXPECT_EQ(offerer_sendrecv_codecs,
sf_offerer_.video_sendrecv_codecs().codecs());
MediaSessionOptions opts; MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
@ -5821,7 +5833,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest,
MAKE_VECTOR(kVideoCodecsH265Level5); MAKE_VECTOR(kVideoCodecsH265Level5);
sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs);
sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs);
EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); EXPECT_EQ(offerer_sendrecv_codecs,
sf_offerer_.video_sendrecv_codecs().codecs());
MediaSessionOptions opts; MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
@ -5874,7 +5887,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest,
MAKE_VECTOR(kVideoCodecsH265Level6); MAKE_VECTOR(kVideoCodecsH265Level6);
sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs);
sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs);
EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); EXPECT_EQ(offerer_sendrecv_codecs,
sf_offerer_.video_sendrecv_codecs().codecs());
MediaSessionOptions opts; MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
@ -5927,7 +5941,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest,
MAKE_VECTOR(kVideoCodecsH265Level52); MAKE_VECTOR(kVideoCodecsH265Level52);
sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs);
sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs);
EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); EXPECT_EQ(offerer_sendrecv_codecs,
sf_offerer_.video_sendrecv_codecs().codecs());
MediaSessionOptions opts; MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
@ -5976,7 +5991,8 @@ TEST_F(VideoCodecsOfferH265LevelIdTest,
MAKE_VECTOR(kVideoCodecsH265Level52); MAKE_VECTOR(kVideoCodecsH265Level52);
sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs); sf_offerer_.set_video_codecs(offerer_send_codecs, offerer_recv_codecs);
sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs); sf_answerer_.set_video_codecs(answerer_send_codecs, answerer_recv_codecs);
EXPECT_EQ(offerer_sendrecv_codecs, sf_offerer_.video_sendrecv_codecs()); EXPECT_EQ(offerer_sendrecv_codecs,
sf_offerer_.video_sendrecv_codecs().codecs());
MediaSessionOptions opts; MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video", AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",