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

Revert "Delete CodecNamesEq, replaced with absl::EqualsIgnoreCase"

Browse Source 
This reverts commit 80cd25bcfb2264fa0f1192de942a6f063879dd42.

Reason for revert: Breaks downstream project

Original change's description:
> Delete CodecNamesEq, replaced with absl::EqualsIgnoreCase
>
> Bug: None
> Change-Id: I225fe1e16a3c96e5a03e3ae8fe975f368be7e6ad
> Reviewed-on: https://webrtc-review.googlesource.com/c/107303
> Commit-Queue: Niels Moller <nisse@webrtc.org>
> Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#25312}

TBR=mbonadei@webrtc.org,kwiberg@webrtc.org,nisse@webrtc.org

No-Try: true
Bug: None
Change-Id: I77b66bc032e2d95d1bd408c6cdeceb4dcd511699
Reviewed-on: https://webrtc-review.googlesource.com/c/107643
Reviewed-by: Oleh Prypin <oprypin@webrtc.org>
Commit-Queue: Oleh Prypin <oprypin@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#25317}
This commit is contained in:
Oleh Prypin 2018-10-23 15:18:23 +02:00 committed by Commit Bot
parent 7e6b528e5d
commit 6e8e2993dd
18 changed files with 66 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
api/video_codecs/BUILD.gn
View File

@ -82,7 +82,6 @@ rtc_static_library("builtin_video_encoder_factory") {
"../../rtc_base:ptr_util",
"../../rtc_base/system:rtc_export",
"//third_party/abseil-cpp/absl/memory",
"//third_party/abseil-cpp/absl/strings",
]
}

3
api/video_codecs/builtin_video_encoder_factory.cc
View File

@ -13,7 +13,6 @@
#include <vector>
#include "absl/memory/memory.h"
#include "absl/strings/match.h"
#include "api/video_codecs/sdp_video_format.h"
#include "media/base/codec.h"
#include "media/base/mediaconstants.h"
@ -60,7 +59,7 @@ class BuiltinVideoEncoderFactory : public VideoEncoderFactory {
if (IsFormatSupported(internal_encoder_factory_->GetSupportedFormats(),
format)) {
internal_encoder =
absl::EqualsIgnoreCase(format.name, cricket::kVp8CodecName)
cricket::CodecNamesEq(format.name.c_str(), cricket::kVp8CodecName)
? absl::make_unique<VP8EncoderSimulcastProxy>(
internal_encoder_factory_.get(), format)
: internal_encoder_factory_->CreateVideoEncoder(format);

15
api/video_codecs/video_codec.cc
View File

@ -115,6 +115,11 @@ static const char* kPayloadNameI420 = "I420";
static const char* kPayloadNameGeneric = "Generic";
static const char* kPayloadNameMultiplex = "Multiplex";
// TODO(nisse): Delete this wrapper.
static bool CodecNamesEq(const char* name1, const char* name2) {
return absl::EqualsIgnoreCase(name1, name2);
}
const char* CodecTypeToPayloadString(VideoCodecType type) {
switch (type) {
case kVideoCodecVP8:
@ -132,15 +137,15 @@ const char* CodecTypeToPayloadString(VideoCodecType type) {
}
VideoCodecType PayloadStringToCodecType(const std::string& name) {
if (absl::EqualsIgnoreCase(name, kPayloadNameVp8))
if (CodecNamesEq(name.c_str(), kPayloadNameVp8))
return kVideoCodecVP8;
if (absl::EqualsIgnoreCase(name, kPayloadNameVp9))
if (CodecNamesEq(name.c_str(), kPayloadNameVp9))
return kVideoCodecVP9;
if (absl::EqualsIgnoreCase(name, kPayloadNameH264))
if (CodecNamesEq(name.c_str(), kPayloadNameH264))
return kVideoCodecH264;
if (absl::EqualsIgnoreCase(name, kPayloadNameI420))
if (CodecNamesEq(name.c_str(), kPayloadNameI420))
return kVideoCodecI420;
if (absl::EqualsIgnoreCase(name, kPayloadNameMultiplex))
if (CodecNamesEq(name.c_str(), kPayloadNameMultiplex))
return kVideoCodecMultiplex;
return kVideoCodecGeneric;
}

1
media/BUILD.gn
View File

@ -250,7 +250,6 @@ rtc_static_library("rtc_internal_video_codecs") {
"../rtc_base:rtc_base_approved",
"../rtc_base:sequenced_task_checker",
"../rtc_base/system:rtc_export",
"//third_party/abseil-cpp/absl/strings",
"//third_party/abseil-cpp/absl/types:optional",
]
}

19
media/base/codec.cc
View File

@ -268,10 +268,10 @@ static bool IsSameH264PacketizationMode(const CodecParameterMap& ours,
bool VideoCodec::Matches(const VideoCodec& other) const {
if (!Codec::Matches(other))
return false;
if (absl::EqualsIgnoreCase(name, kH264CodecName))
if (CodecNamesEq(name.c_str(), kH264CodecName))
return webrtc::H264::IsSameH264Profile(params, other.params) &&
IsSameH264PacketizationMode(params, other.params);
if (absl::EqualsIgnoreCase(name, kVp9CodecName))
if (CodecNamesEq(name.c_str(), kVp9CodecName))
return webrtc::IsSameVP9Profile(params, other.params);
return true;
}
@ -362,6 +362,15 @@ bool HasTransportCc(const Codec& codec) {
FeedbackParam(kRtcpFbParamTransportCc, kParamValueEmpty));
}
// TODO(nisse): Delete these wrappers.
bool CodecNamesEq(const std::string& name1, const std::string& name2) {
return CodecNamesEq(name1.c_str(), name2.c_str());
}
bool CodecNamesEq(const char* name1, const char* name2) {
return absl::EqualsIgnoreCase(name1, name2);
}
const VideoCodec* FindMatchingCodec(
const std::vector<VideoCodec>& supported_codecs,
const VideoCodec& codec) {
@ -379,12 +388,12 @@ bool IsSameCodec(const std::string& name1,
const std::string& name2,
const CodecParameterMap& params2) {
// If different names (case insensitive), then not same formats.
if (!absl::EqualsIgnoreCase(name1, name2))
if (!CodecNamesEq(name1, name2))
return false;
// For every format besides H264 and VP9, comparing names is enough.
if (absl::EqualsIgnoreCase(name1, kH264CodecName))
if (CodecNamesEq(name1.c_str(), kH264CodecName))
return webrtc::H264::IsSameH264Profile(params1, params2);
if (absl::EqualsIgnoreCase(name1, kVp9CodecName))
if (CodecNamesEq(name1.c_str(), kVp9CodecName))
return webrtc::IsSameVP9Profile(params1, params2);
return true;
}

3
media/base/codec.h
View File

@ -216,6 +216,9 @@ const Codec* FindCodecById(const std::vector<Codec>& codecs, int payload_type) {
return nullptr;
}
RTC_EXPORT bool CodecNamesEq(const std::string& name1,
const std::string& name2);
RTC_EXPORT bool CodecNamesEq(const char* name1, const char* name2);
bool HasNack(const Codec& codec);
bool HasRemb(const Codec& codec);
bool HasRrtr(const Codec& codec);

5
media/engine/convert_legacy_video_factory.cc
View File

@ -15,7 +15,6 @@
#include <vector>
#include "absl/memory/memory.h"
#include "absl/strings/match.h"
#include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_decoder_software_fallback_wrapper.h"
#include "api/video_codecs/video_encoder_factory.h"
@ -131,7 +130,7 @@ class EncoderAdapter : public webrtc::VideoEncoderFactory {
if (IsFormatSupported(internal_encoder_factory_->GetSupportedFormats(),
format)) {
internal_encoder =
absl::EqualsIgnoreCase(format.name, kVp8CodecName)
CodecNamesEq(format.name.c_str(), kVp8CodecName)
? absl::make_unique<webrtc::VP8EncoderSimulcastProxy>(
internal_encoder_factory_.get(), format)
: internal_encoder_factory_->CreateVideoEncoder(format);
@ -142,7 +141,7 @@ class EncoderAdapter : public webrtc::VideoEncoderFactory {
if (IsFormatSupported(external_encoder_factory_->GetSupportedFormats(),
format)) {
external_encoder =
absl::EqualsIgnoreCase(format.name, kVp8CodecName)
CodecNamesEq(format.name.c_str(), kVp8CodecName)
? absl::make_unique<webrtc::SimulcastEncoderAdapter>(
external_encoder_factory_.get(), format)
: external_encoder_factory_->CreateVideoEncoder(format);

3
media/engine/fakewebrtcvideoengine.cc
View File

@ -10,7 +10,6 @@
#include "media/engine/fakewebrtcvideoengine.h"
#include "absl/strings/match.h"
#include "media/base/codec.h"
#include "media/engine/simulcast_encoder_adapter.h"
#include "media/engine/webrtcvideodecoderfactory.h"
@ -219,7 +218,7 @@ FakeWebRtcVideoEncoderFactory::CreateVideoEncoder(
rtc::CritScope lock(&crit_);
std::unique_ptr<webrtc::VideoEncoder> encoder;
if (IsFormatSupported(formats_, format)) {
if (absl::EqualsIgnoreCase(format.name, kVp8CodecName) &&
if (CodecNamesEq(format.name.c_str(), kVp8CodecName) &&
!vp8_factory_mode_) {
// The simulcast adapter will ask this factory for multiple VP8
// encoders. Enter vp8_factory_mode so that we now create these encoders

7
media/engine/internaldecoderfactory.cc
View File

@ -10,7 +10,6 @@
#include "media/engine/internaldecoderfactory.h"
#include "absl/strings/match.h"
#include "api/video_codecs/sdp_video_format.h"
#include "media/base/mediaconstants.h"
#include "modules/video_coding/codecs/h264/include/h264.h"
@ -56,11 +55,11 @@ std::unique_ptr<VideoDecoder> InternalDecoderFactory::CreateVideoDecoder(
return nullptr;
}
if (absl::EqualsIgnoreCase(format.name, cricket::kVp8CodecName))
if (cricket::CodecNamesEq(format.name, cricket::kVp8CodecName))
return VP8Decoder::Create();
if (absl::EqualsIgnoreCase(format.name, cricket::kVp9CodecName))
if (cricket::CodecNamesEq(format.name, cricket::kVp9CodecName))
return VP9Decoder::Create();
if (absl::EqualsIgnoreCase(format.name, cricket::kH264CodecName))
if (cricket::CodecNamesEq(format.name, cricket::kH264CodecName))
return H264Decoder::Create();
RTC_NOTREACHED();

7
media/engine/internalencoderfactory.cc
View File

@ -12,7 +12,6 @@
#include <utility>
#include "absl/strings/match.h"
#include "api/video_codecs/sdp_video_format.h"
#include "modules/video_coding/codecs/h264/include/h264.h"
#include "modules/video_coding/codecs/vp8/include/vp8.h"
@ -42,11 +41,11 @@ VideoEncoderFactory::CodecInfo InternalEncoderFactory::QueryVideoEncoder(
std::unique_ptr<VideoEncoder> InternalEncoderFactory::CreateVideoEncoder(
const SdpVideoFormat& format) {
if (absl::EqualsIgnoreCase(format.name, cricket::kVp8CodecName))
if (cricket::CodecNamesEq(format.name, cricket::kVp8CodecName))
return VP8Encoder::Create();
if (absl::EqualsIgnoreCase(format.name, cricket::kVp9CodecName))
if (cricket::CodecNamesEq(format.name, cricket::kVp9CodecName))
return VP9Encoder::Create(cricket::VideoCodec(format));
if (absl::EqualsIgnoreCase(format.name, cricket::kH264CodecName))
if (cricket::CodecNamesEq(format.name, cricket::kH264CodecName))
return H264Encoder::Create(cricket::VideoCodec(format));
RTC_LOG(LS_ERROR) << "Trying to created encoder of unsupported format "
<< format.name;

9
media/engine/multiplexcodecfactory.cc
View File

@ -12,7 +12,6 @@
#include <utility>
#include "absl/strings/match.h"
#include "api/video_codecs/sdp_video_format.h"
#include "media/base/codec.h"
#include "media/base/mediaconstants.h"
@ -23,8 +22,8 @@
namespace {
bool IsMultiplexCodec(const cricket::VideoCodec& codec) {
return absl::EqualsIgnoreCase(codec.name.c_str(),
cricket::kMultiplexCodecName);
return cricket::CodecNamesEq(codec.name.c_str(),
cricket::kMultiplexCodecName);
}
} // anonymous namespace
@ -43,7 +42,7 @@ std::vector<SdpVideoFormat> MultiplexEncoderFactory::GetSupportedFormats()
const {
std::vector<SdpVideoFormat> formats = factory_->GetSupportedFormats();
for (const auto& format : formats) {
if (absl::EqualsIgnoreCase(format.name, kMultiplexAssociatedCodecName)) {
if (cricket::CodecNamesEq(format.name, kMultiplexAssociatedCodecName)) {
SdpVideoFormat multiplex_format = format;
multiplex_format.parameters[cricket::kCodecParamAssociatedCodecName] =
format.name;
@ -89,7 +88,7 @@ std::vector<SdpVideoFormat> MultiplexDecoderFactory::GetSupportedFormats()
const {
std::vector<SdpVideoFormat> formats = factory_->GetSupportedFormats();
for (const auto& format : formats) {
if (absl::EqualsIgnoreCase(format.name, kMultiplexAssociatedCodecName)) {
if (cricket::CodecNamesEq(format.name, kMultiplexAssociatedCodecName)) {
SdpVideoFormat multiplex_format = format;
multiplex_format.parameters[cricket::kCodecParamAssociatedCodecName] =
format.name;

30
media/engine/webrtcvideoengine.cc
View File

@ -16,7 +16,6 @@
#include <string>
#include <utility>
#include "absl/strings/match.h"
#include "api/video_codecs/sdp_video_format.h"
#include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder.h"
@ -112,8 +111,8 @@ std::vector<VideoCodec> AssignPayloadTypesAndDefaultCodecs(
}
// Add associated RTX codec for non-FEC codecs.
if (!absl::EqualsIgnoreCase(codec.name, kUlpfecCodecName) &&
!absl::EqualsIgnoreCase(codec.name, kFlexfecCodecName)) {
if (!CodecNamesEq(codec.name, kUlpfecCodecName) &&
!CodecNamesEq(codec.name, kFlexfecCodecName)) {
output_codecs.push_back(
VideoCodec::CreateRtxCodec(payload_type, codec.id));
@ -148,8 +147,8 @@ int GetMaxFramerate(const webrtc::VideoEncoderConfig& encoder_config,
}
bool IsTemporalLayersSupported(const std::string& codec_name) {
return absl::EqualsIgnoreCase(codec_name, kVp8CodecName) ||
absl::EqualsIgnoreCase(codec_name, kVp9CodecName);
return CodecNamesEq(codec_name, kVp8CodecName) ||
CodecNamesEq(codec_name, kVp9CodecName);
}
static std::string CodecVectorToString(const std::vector<VideoCodec>& codecs) {
@ -221,9 +220,9 @@ static bool ValidateStreamParams(const StreamParams& sp) {
// Returns true if the given codec is disallowed from doing simulcast.
bool IsCodecBlacklistedForSimulcast(const std::string& codec_name) {
return webrtc::field_trial::IsEnabled("WebRTC-H264Simulcast")
? absl::EqualsIgnoreCase(codec_name, kVp9CodecName)
: absl::EqualsIgnoreCase(codec_name, kH264CodecName) ||
absl::EqualsIgnoreCase(codec_name, kVp9CodecName);
? CodecNamesEq(codec_name, kVp9CodecName)
: CodecNamesEq(codec_name, kH264CodecName) ||
CodecNamesEq(codec_name, kVp9CodecName);
}
// The selected thresholds for QVGA and VGA corresponded to a QP around 10.
@ -338,14 +337,14 @@ WebRtcVideoChannel::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
denoising = parameters_.options.video_noise_reduction.value_or(false);
}
if (absl::EqualsIgnoreCase(codec.name, kH264CodecName)) {
if (CodecNamesEq(codec.name, kH264CodecName)) {
webrtc::VideoCodecH264 h264_settings =
webrtc::VideoEncoder::GetDefaultH264Settings();
h264_settings.frameDroppingOn = frame_dropping;
return new rtc::RefCountedObject<
webrtc::VideoEncoderConfig::H264EncoderSpecificSettings>(h264_settings);
}
if (absl::EqualsIgnoreCase(codec.name, kVp8CodecName)) {
if (CodecNamesEq(codec.name, kVp8CodecName)) {
webrtc::VideoCodecVP8 vp8_settings =
webrtc::VideoEncoder::GetDefaultVp8Settings();
vp8_settings.automaticResizeOn = automatic_resize;
@ -355,7 +354,7 @@ WebRtcVideoChannel::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
return new rtc::RefCountedObject<
webrtc::VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8_settings);
}
if (absl::EqualsIgnoreCase(codec.name, kVp9CodecName)) {
if (CodecNamesEq(codec.name, kVp9CodecName)) {
webrtc::VideoCodecVP9 vp9_settings =
webrtc::VideoEncoder::GetDefaultVp9Settings();
const size_t default_num_spatial_layers =
@ -2697,11 +2696,10 @@ std::vector<webrtc::VideoStream> EncoderStreamFactory::CreateEncoderStreams(
std::vector<webrtc::VideoStream> layers;
if (encoder_config.number_of_streams > 1 ||
((absl::EqualsIgnoreCase(codec_name_, kVp8CodecName) ||
absl::EqualsIgnoreCase(codec_name_, kH264CodecName)) &&
((CodecNamesEq(codec_name_, kVp8CodecName) ||
CodecNamesEq(codec_name_, kH264CodecName)) &&
is_screenshare_ && screenshare_config_explicitly_enabled_)) {
bool temporal_layers_supported =
absl::EqualsIgnoreCase(codec_name_, kVp8CodecName);
bool temporal_layers_supported = CodecNamesEq(codec_name_, kVp8CodecName);
layers = GetSimulcastConfig(encoder_config.number_of_streams, width, height,
0 /*not used*/, encoder_config.bitrate_priority,
max_qp_, 0 /*not_used*/, is_screenshare_,
@ -2794,7 +2792,7 @@ std::vector<webrtc::VideoStream> EncoderStreamFactory::CreateEncoderStreams(
layer.max_qp = max_qp_;
layer.bitrate_priority = encoder_config.bitrate_priority;
if (absl::EqualsIgnoreCase(codec_name_, kVp9CodecName)) {
if (CodecNamesEq(codec_name_, kVp9CodecName)) {
RTC_DCHECK(encoder_config.encoder_specific_settings);
// Use VP9 SVC layering from codec settings which might be initialized
// though field trial in ConfigureVideoEncoderSettings.

9
media/engine/webrtcvideoengine_unittest.cc
View File

@ -14,7 +14,6 @@
#include <utility>
#include <vector>
#include "absl/strings/match.h"
#include "api/rtpparameters.h"
#include "api/test/mock_video_decoder_factory.h"
#include "api/test/mock_video_encoder_factory.h"
@ -102,7 +101,7 @@ bool HasRtxCodec(const std::vector<cricket::VideoCodec>& codecs,
int payload_type) {
for (const cricket::VideoCodec& codec : codecs) {
int associated_payload_type;
if (absl::EqualsIgnoreCase(codec.name.c_str(), "rtx") &&
if (cricket::CodecNamesEq(codec.name.c_str(), "rtx") &&
codec.GetParam(cricket::kCodecParamAssociatedPayloadType,
&associated_payload_type) &&
associated_payload_type == payload_type) {
@ -651,11 +650,11 @@ size_t WebRtcVideoEngineTest::GetEngineCodecIndex(
const std::vector<cricket::VideoCodec> codecs = engine_.codecs();
for (size_t i = 0; i < codecs.size(); ++i) {
const cricket::VideoCodec engine_codec = codecs[i];
if (!absl::EqualsIgnoreCase(name, engine_codec.name))
if (!CodecNamesEq(name, engine_codec.name))
continue;
// The tests only use H264 Constrained Baseline. Make sure we don't return
// an internal H264 codec from the engine with a different H264 profile.
if (absl::EqualsIgnoreCase(name.c_str(), kH264CodecName)) {
if (CodecNamesEq(name.c_str(), kH264CodecName)) {
const absl::optional<webrtc::H264::ProfileLevelId> profile_level_id =
webrtc::H264::ParseSdpProfileLevelId(engine_codec.params);
if (profile_level_id->profile !=
@ -1432,7 +1431,7 @@ class WebRtcVideoChannelBaseTest : public testing::Test {
cricket::VideoCodec GetEngineCodec(const std::string& name) {
for (const cricket::VideoCodec& engine_codec : engine_.codecs()) {
if (absl::EqualsIgnoreCase(name, engine_codec.name))
if (CodecNamesEq(name, engine_codec.name))
return engine_codec;
}
// This point should never be reached.

1
modules/video_coding/BUILD.gn
View File

@ -306,7 +306,6 @@ rtc_static_library("webrtc_h264") {
"../../rtc_base/system:rtc_export",
"../../system_wrappers:metrics",
"//third_party/abseil-cpp/absl/memory",
"//third_party/abseil-cpp/absl/strings",
"//third_party/libyuv",
]

3
modules/video_coding/codecs/h264/h264_encoder_impl.cc
View File

@ -19,7 +19,6 @@
#include "third_party/openh264/src/codec/api/svc/codec_def.h"
#include "third_party/openh264/src/codec/api/svc/codec_ver.h"
#include "absl/strings/match.h"
#include "common_video/libyuv/include/webrtc_libyuv.h"
#include "modules/video_coding/utility/simulcast_rate_allocator.h"
#include "modules/video_coding/utility/simulcast_utility.h"
@ -168,7 +167,7 @@ H264EncoderImpl::H264EncoderImpl(const cricket::VideoCodec& codec)
encoded_image_callback_(nullptr),
has_reported_init_(false),
has_reported_error_(false) {
RTC_CHECK(absl::EqualsIgnoreCase(codec.name, cricket::kH264CodecName));
RTC_CHECK(cricket::CodecNamesEq(codec.name, cricket::kH264CodecName));
std::string packetization_mode_string;
if (codec.GetParam(cricket::kH264FmtpPacketizationMode,
&packetization_mode_string) &&

1
pc/BUILD.gn
View File

@ -212,7 +212,6 @@ rtc_static_library("peerconnection") {
"../system_wrappers:field_trial",
"../system_wrappers:metrics",
"//third_party/abseil-cpp/absl/memory",
"//third_party/abseil-cpp/absl/strings",
"//third_party/abseil-cpp/absl/types:optional",
]
}

5
pc/mediasession.cc
View File

@ -312,8 +312,7 @@ void FilterDataCodecs(std::vector<DataCodec>* codecs, bool sctp) {
sctp ? kGoogleRtpDataCodecName : kGoogleSctpDataCodecName;
codecs->erase(std::remove_if(codecs->begin(), codecs->end(),
[&codec_name](const DataCodec& codec) {
return absl::EqualsIgnoreCase(codec.name,
codec_name);
return CodecNamesEq(codec.name, codec_name);
}),
codecs->end());
}
@ -747,7 +746,7 @@ static void NegotiateCodecs(const std::vector<C>& local_codecs,
RTC_DCHECK(apt_it != theirs.params.end());
negotiated.SetParam(kCodecParamAssociatedPayloadType, apt_it->second);
}
if (absl::EqualsIgnoreCase(ours.name, kH264CodecName)) {
if (CodecNamesEq(ours.name.c_str(), kH264CodecName)) {
webrtc::H264::GenerateProfileLevelIdForAnswer(
ours.params, theirs.params, &negotiated.params);
}

9
pc/webrtcsdp.cc
View File

@ -23,12 +23,11 @@
#include <utility>
#include <vector>
#include "absl/strings/match.h"
#include "api/mediatypes.h"
#include "api/candidate.h"
#include "api/cryptoparams.h"
#include "api/jsepicecandidate.h"
#include "api/jsepsessiondescription.h"
#include "api/mediatypes.h"
// for RtpExtension
#include "api/rtpparameters.h"
#include "media/base/codec.h"
@ -1313,8 +1312,8 @@ void BuildMediaDescription(const ContentInfo* content_info,
if (data_desc->use_sctpmap()) {
for (const cricket::DataCodec& codec : data_desc->codecs()) {
if (absl::EqualsIgnoreCase(codec.name,
cricket::kGoogleSctpDataCodecName) &&
if (cricket::CodecNamesEq(codec.name,
cricket::kGoogleSctpDataCodecName) &&
codec.GetParam(cricket::kCodecParamPort, &sctp_port)) {
break;
}
@ -1752,7 +1751,7 @@ void AddRtcpFbLines(const T& codec, std::string* message) {
bool AddSctpDataCodec(DataContentDescription* media_desc, int sctp_port) {
for (const auto& codec : media_desc->codecs()) {
if (absl::EqualsIgnoreCase(codec.name, cricket::kGoogleSctpDataCodecName)) {
if (cricket::CodecNamesEq(codec.name, cricket::kGoogleSctpDataCodecName)) {
return ParseFailed("", "Can't have multiple sctp port attributes.", NULL);
}
}