Move cricket::Codec to webrtc namespace
Bug: webrtc:42232595
Change-Id: I7f7ca9fdec96510ade3daac45861d46cee591a82
No-Iwyu: LSC
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/385121
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Auto-Submit: Evan Shrubsole <eshr@webrtc.org>
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#44323}
diff --git a/call/call.cc b/call/call.cc
index da6a6a4..1e6d4d2 100644
--- a/call/call.cc
+++ b/call/call.cc
@@ -111,12 +111,12 @@
public:
PayloadTypeSuggesterForTests() = default;
RTCErrorOr<PayloadType> SuggestPayloadType(const std::string& /* mid */,
- cricket::Codec codec) override {
+ Codec codec) override {
return payload_type_picker_.SuggestMapping(codec, nullptr);
}
RTCError AddLocalMapping(const std::string& /* mid */,
PayloadType /* payload_type */,
- const cricket::Codec& /* codec */) override {
+ const Codec& /* codec */) override {
return RTCError::OK();
}
diff --git a/call/fake_payload_type_suggester.h b/call/fake_payload_type_suggester.h
index c2aa6eb..f98d387 100644
--- a/call/fake_payload_type_suggester.h
+++ b/call/fake_payload_type_suggester.h
@@ -26,13 +26,13 @@
public:
webrtc::RTCErrorOr<webrtc::PayloadType> SuggestPayloadType(
const std::string& mid,
- cricket::Codec codec) override {
+ Codec codec) override {
// Ignores mid argument.
return pt_picker_.SuggestMapping(codec, nullptr);
}
webrtc::RTCError AddLocalMapping(const std::string& mid,
webrtc::PayloadType payload_type,
- const cricket::Codec& codec) override {
+ const Codec& codec) override {
return webrtc::RTCError::OK();
}
diff --git a/call/payload_type.h b/call/payload_type.h
index 672c489..d91da50 100644
--- a/call/payload_type.h
+++ b/call/payload_type.h
@@ -50,12 +50,12 @@
// The function will either return a PT already in use on the connection
// or a newly suggested one.
virtual RTCErrorOr<PayloadType> SuggestPayloadType(const std::string& mid,
- cricket::Codec codec) = 0;
+ Codec codec) = 0;
// Register a payload type as mapped to a specific codec for this MID
// at this time.
virtual RTCError AddLocalMapping(const std::string& mid,
PayloadType payload_type,
- const cricket::Codec& codec) = 0;
+ const Codec& codec) = 0;
};
} // namespace webrtc
diff --git a/call/payload_type_picker.cc b/call/payload_type_picker.cc
index 01e5ba9..eff4d58 100644
--- a/call/payload_type_picker.cc
+++ b/call/payload_type_picker.cc
@@ -41,7 +41,7 @@
// Note: The only fields we need from a Codec are the type (audio/video),
// the subtype (vp8/h264/....), the clock rate, the channel count, and the
-// fmtp parameters. The use of cricket::Codec, which contains more fields,
+// fmtp parameters. The use of Codec, which contains more fields,
// is only a temporary measure.
struct MapTableEntry {
@@ -51,9 +51,9 @@
// Helper function to determine whether a codec should use the [35, 63] range.
// Should be used when adding new codecs (or variants).
-bool CodecPrefersLowerRange(const cricket::Codec& codec) {
+bool CodecPrefersLowerRange(const Codec& codec) {
// All audio codecs prefer upper range.
- if (codec.type == cricket::Codec::Type::kAudio) {
+ if (codec.type == Codec::Type::kAudio) {
return absl::EqualsIgnoreCase(codec.name, cricket::kRedCodecName);
}
if (absl::EqualsIgnoreCase(codec.name, cricket::kFlexfecCodecName) ||
@@ -95,7 +95,7 @@
return false;
}
-RTCErrorOr<PayloadType> FindFreePayloadType(const cricket::Codec& codec,
+RTCErrorOr<PayloadType> FindFreePayloadType(const Codec& codec,
std::set<PayloadType> seen_pt) {
// Prefer to use lower range for codecs that can handle it.
bool prefer_lower_range = CodecPrefersLowerRange(codec);
@@ -193,13 +193,12 @@
{{cricket::kDtmfCodecName, 16000, 1}, 113},
{{cricket::kDtmfCodecName, 8000, 1}, 126}};
for (const MapTableEntry& entry : default_audio_mappings) {
- AddMapping(PayloadType(entry.payload_type),
- cricket::CreateAudioCodec(entry.format));
+ AddMapping(PayloadType(entry.payload_type), CreateAudioCodec(entry.format));
}
}
RTCErrorOr<PayloadType> PayloadTypePicker::SuggestMapping(
- cricket::Codec codec,
+ Codec codec,
const PayloadTypeRecorder* excluder) {
// Test compatibility: If the codec contains a PT, and it is free, use it.
// This saves having to rewrite tests that set the codec ID themselves.
@@ -232,8 +231,7 @@
return found_pt;
}
-RTCError PayloadTypePicker::AddMapping(PayloadType payload_type,
- cricket::Codec codec) {
+RTCError PayloadTypePicker::AddMapping(PayloadType payload_type, Codec codec) {
// Completely duplicate mappings are ignored.
// Multiple mappings for the same codec and the same PT are legal;
for (const MapEntry& entry : entries_) {
@@ -248,7 +246,7 @@
}
RTCError PayloadTypeRecorder::AddMapping(PayloadType payload_type,
- cricket::Codec codec) {
+ Codec codec) {
auto existing_codec_it = payload_type_to_codec_.find(payload_type);
if (existing_codec_it != payload_type_to_codec_.end() &&
!MatchesWithCodecRules(codec, existing_codec_it->second)) {
@@ -286,13 +284,13 @@
return RTCError::OK();
}
-std::vector<std::pair<PayloadType, cricket::Codec>>
-PayloadTypeRecorder::GetMappings() const {
- return std::vector<std::pair<PayloadType, cricket::Codec>>{};
+std::vector<std::pair<PayloadType, Codec>> PayloadTypeRecorder::GetMappings()
+ const {
+ return std::vector<std::pair<PayloadType, Codec>>{};
}
RTCErrorOr<PayloadType> PayloadTypeRecorder::LookupPayloadType(
- cricket::Codec codec) const {
+ Codec codec) const {
// Note that having multiple PTs mapping to the same codec is NOT an error.
// In this case, we return the first found (not deterministic).
auto result =
@@ -307,7 +305,7 @@
return result->first;
}
-RTCErrorOr<cricket::Codec> PayloadTypeRecorder::LookupCodec(
+RTCErrorOr<Codec> PayloadTypeRecorder::LookupCodec(
PayloadType payload_type) const {
auto result = payload_type_to_codec_.find(payload_type);
if (result == payload_type_to_codec_.end()) {
diff --git a/call/payload_type_picker.h b/call/payload_type_picker.h
index 8826ffb..85cc0bb 100644
--- a/call/payload_type_picker.h
+++ b/call/payload_type_picker.h
@@ -34,21 +34,21 @@
PayloadTypePicker& operator=(PayloadTypePicker&&) = delete;
// Suggest a payload type for the codec.
// If the excluder maps it to something different, don't suggest it.
- RTCErrorOr<PayloadType> SuggestMapping(cricket::Codec codec,
+ RTCErrorOr<PayloadType> SuggestMapping(Codec codec,
const PayloadTypeRecorder* excluder);
- RTCError AddMapping(PayloadType payload_type, cricket::Codec codec);
+ RTCError AddMapping(PayloadType payload_type, Codec codec);
private:
class MapEntry {
public:
- MapEntry(PayloadType payload_type, cricket::Codec codec)
+ MapEntry(PayloadType payload_type, Codec codec)
: payload_type_(payload_type), codec_(codec) {}
PayloadType payload_type() const { return payload_type_; }
- cricket::Codec codec() const { return codec_; }
+ Codec codec() const { return codec_; }
private:
PayloadType payload_type_;
- cricket::Codec codec_;
+ Codec codec_;
};
std::vector<MapEntry> entries_;
std::set<PayloadType> seen_payload_types_;
@@ -70,10 +70,10 @@
RTC_DCHECK(disallow_redefinition_level_ == 0);
}
- RTCError AddMapping(PayloadType payload_type, cricket::Codec codec);
- std::vector<std::pair<PayloadType, cricket::Codec>> GetMappings() const;
- RTCErrorOr<PayloadType> LookupPayloadType(cricket::Codec codec) const;
- RTCErrorOr<cricket::Codec> LookupCodec(PayloadType payload_type) const;
+ RTCError AddMapping(PayloadType payload_type, Codec codec);
+ std::vector<std::pair<PayloadType, Codec>> GetMappings() const;
+ RTCErrorOr<PayloadType> LookupPayloadType(Codec codec) const;
+ RTCErrorOr<Codec> LookupCodec(PayloadType payload_type) const;
// Redefinition guard.
// In some scenarios, redefinition must be allowed between one offer/answer
// set and the next offer/answer set, but within the processing of one
@@ -90,8 +90,8 @@
private:
PayloadTypePicker& suggester_;
- std::map<PayloadType, cricket::Codec> payload_type_to_codec_;
- std::map<PayloadType, cricket::Codec> checkpoint_payload_type_to_codec_;
+ std::map<PayloadType, Codec> payload_type_to_codec_;
+ std::map<PayloadType, Codec> checkpoint_payload_type_to_codec_;
int disallow_redefinition_level_ = 0;
std::set<PayloadType> accepted_definitions_;
};
diff --git a/call/payload_type_picker_unittest.cc b/call/payload_type_picker_unittest.cc
index f476908..3f4905b 100644
--- a/call/payload_type_picker_unittest.cc
+++ b/call/payload_type_picker_unittest.cc
@@ -43,7 +43,7 @@
PayloadTypeRecorder recorder(picker);
const PayloadType a_payload_type(123);
const PayloadType not_a_payload_type(44);
- cricket::Codec a_codec = cricket::CreateVideoCodec(0, "vp8");
+ Codec a_codec = CreateVideoCodec(0, "vp8");
auto error = recorder.AddMapping(a_payload_type, a_codec);
ASSERT_TRUE(error.ok());
auto result = recorder.LookupCodec(a_payload_type);
@@ -62,10 +62,8 @@
PayloadTypePicker picker;
PayloadTypeRecorder recorder(picker);
const PayloadType a_payload_type(123);
- cricket::Codec a_codec =
- cricket::CreateVideoCodec(cricket::Codec::kIdNotSet, "vp8");
- cricket::Codec b_codec =
- cricket::CreateVideoCodec(cricket::Codec::kIdNotSet, "vp9");
+ Codec a_codec = CreateVideoCodec(Codec::kIdNotSet, "vp8");
+ Codec b_codec = CreateVideoCodec(Codec::kIdNotSet, "vp9");
recorder.AddMapping(a_payload_type, a_codec);
auto error = recorder.AddMapping(a_payload_type, b_codec);
EXPECT_TRUE(error.ok());
@@ -78,10 +76,8 @@
PayloadTypePicker picker;
PayloadTypeRecorder recorder(picker);
const PayloadType a_payload_type(123);
- cricket::Codec a_codec =
- cricket::CreateVideoCodec(cricket::Codec::kIdNotSet, "vp8");
- cricket::Codec b_codec =
- cricket::CreateVideoCodec(cricket::Codec::kIdNotSet, "vp9");
+ Codec a_codec = CreateVideoCodec(Codec::kIdNotSet, "vp8");
+ Codec b_codec = CreateVideoCodec(Codec::kIdNotSet, "vp9");
recorder.DisallowRedefinition();
recorder.AddMapping(a_payload_type, a_codec);
auto error = recorder.AddMapping(a_payload_type, b_codec);
@@ -99,9 +95,9 @@
const PayloadType b_payload_type(124);
const PayloadType not_a_payload_type(44);
- cricket::Codec a_codec = cricket::CreateVideoCodec(0, "vp8");
+ Codec a_codec = CreateVideoCodec(0, "vp8");
- cricket::Codec b_codec = cricket::CreateVideoCodec(0, "vp9");
+ Codec b_codec = CreateVideoCodec(0, "vp9");
auto error = recorder.AddMapping(a_payload_type, a_codec);
ASSERT_TRUE(error.ok());
recorder.Commit();
@@ -139,8 +135,7 @@
TEST(PayloadTypePicker, StaticValueIsGood) {
PayloadTypePicker picker;
- cricket::Codec a_codec =
- cricket::CreateAudioCodec(-1, cricket::kPcmuCodecName, 8000, 1);
+ Codec a_codec = CreateAudioCodec(-1, cricket::kPcmuCodecName, 8000, 1);
auto result = picker.SuggestMapping(a_codec, nullptr);
// In the absence of existing mappings, PCMU always has 0 as PT.
ASSERT_TRUE(result.ok());
@@ -149,7 +144,7 @@
TEST(PayloadTypePicker, DynamicValueIsGood) {
PayloadTypePicker picker;
- cricket::Codec a_codec = cricket::CreateAudioCodec(-1, "lyra", 8000, 1);
+ Codec a_codec = CreateAudioCodec(-1, "lyra", 8000, 1);
auto result = picker.SuggestMapping(a_codec, nullptr);
// This should result in a value from the dynamic range; since this is the
// first assignment, it should be in the upper range.
@@ -161,7 +156,7 @@
TEST(PayloadTypePicker, RecordedValueReturned) {
PayloadTypePicker picker;
PayloadTypeRecorder recorder(picker);
- cricket::Codec a_codec = cricket::CreateAudioCodec(-1, "lyra", 8000, 1);
+ Codec a_codec = CreateAudioCodec(-1, "lyra", 8000, 1);
recorder.AddMapping(47, a_codec);
auto result = picker.SuggestMapping(a_codec, &recorder);
ASSERT_TRUE(result.ok());
@@ -172,8 +167,8 @@
PayloadTypePicker picker;
PayloadTypeRecorder recorder1(picker);
PayloadTypeRecorder recorder2(picker);
- cricket::Codec a_codec = cricket::CreateAudioCodec(-1, "lyra", 8000, 1);
- cricket::Codec b_codec = cricket::CreateAudioCodec(-1, "mlcodec", 8000, 1);
+ Codec a_codec = CreateAudioCodec(-1, "lyra", 8000, 1);
+ Codec b_codec = CreateAudioCodec(-1, "mlcodec", 8000, 1);
recorder1.AddMapping(47, a_codec);
recorder2.AddMapping(47, b_codec);
auto result = picker.SuggestMapping(b_codec, &recorder1);
@@ -183,35 +178,33 @@
TEST(PayloadTypePicker, AudioGetsHigherRange) {
PayloadTypePicker picker;
- cricket::Codec an_audio_codec =
- cricket::CreateAudioCodec(-1, "lyra", 8000, 1);
+ Codec an_audio_codec = CreateAudioCodec(-1, "lyra", 8000, 1);
auto result = picker.SuggestMapping(an_audio_codec, nullptr).value();
EXPECT_THAT(result, Ge(96));
}
TEST(PayloadTypePicker, AudioRedGetsLowerRange) {
PayloadTypePicker picker;
- cricket::Codec an_audio_codec =
- cricket::CreateAudioCodec(-1, "red", 48000, 2);
+ Codec an_audio_codec = CreateAudioCodec(-1, "red", 48000, 2);
auto result = picker.SuggestMapping(an_audio_codec, nullptr).value();
EXPECT_THAT(result, Le(63));
}
TEST(PayloadTypePicker, VideoGetsTreatedSpecially) {
PayloadTypePicker picker;
- cricket::Codec h264_constrained = cricket::CreateVideoCodec(SdpVideoFormat(
+ Codec h264_constrained = CreateVideoCodec(SdpVideoFormat(
cricket::kH264CodecName, {{cricket::kH264FmtpProfileLevelId, "42e01f"},
{cricket::kH264FmtpLevelAsymmetryAllowed, "1"},
{cricket::kH264FmtpPacketizationMode, "1"}}));
- cricket::Codec h264_yuv444 = cricket::CreateVideoCodec(SdpVideoFormat(
+ Codec h264_yuv444 = CreateVideoCodec(SdpVideoFormat(
cricket::kH264CodecName, {{cricket::kH264FmtpProfileLevelId, "f4001f"},
{cricket::kH264FmtpLevelAsymmetryAllowed, "1"},
{cricket::kH264FmtpPacketizationMode, "1"}}));
- cricket::Codec vp9_profile_2 = cricket::CreateVideoCodec(SdpVideoFormat(
- {cricket::kVp9CodecName, {{cricket::kVP9ProfileId, "2"}}}));
- cricket::Codec vp9_profile_3 = cricket::CreateVideoCodec(SdpVideoFormat(
- {cricket::kVp9CodecName, {{cricket::kVP9ProfileId, "3"}}}));
- cricket::Codec h265 = cricket::CreateVideoCodec(SdpVideoFormat(
+ Codec vp9_profile_2 = CreateVideoCodec(
+ {cricket::kVp9CodecName, {{cricket::kVP9ProfileId, "2"}}});
+ Codec vp9_profile_3 = CreateVideoCodec(
+ {cricket::kVp9CodecName, {{cricket::kVP9ProfileId, "3"}}});
+ Codec h265 = CreateVideoCodec(SdpVideoFormat(
cricket::kH265CodecName, {{cricket::kH265FmtpProfileId, "1"},
{cricket::kH265FmtpTierFlag, "0"},
{cricket::kH265FmtpLevelId, "93"},
@@ -225,8 +218,7 @@
EXPECT_THAT(picker.SuggestMapping(h265, nullptr).value(), Le(63));
// RTX with a primary codec in the lower range is valid for lower range.
- cricket::Codec lower_range_rtx =
- cricket::CreateVideoRtxCodec(cricket::Codec::kIdNotSet, 63);
+ Codec lower_range_rtx = CreateVideoRtxCodec(Codec::kIdNotSet, 63);
EXPECT_THAT(picker.SuggestMapping(lower_range_rtx, nullptr).value(), Le(63));
}
@@ -234,15 +226,15 @@
// No opinion on whether these are right or wrong, just that their
// behavior is consistent.
PayloadTypePicker picker;
- cricket::Codec h264_constrained = cricket::CreateVideoCodec(SdpVideoFormat(
+ Codec h264_constrained = CreateVideoCodec(SdpVideoFormat(
cricket::kH264CodecName, {{cricket::kH264FmtpProfileLevelId, "42e01f"},
{cricket::kH264FmtpLevelAsymmetryAllowed, "1"},
{cricket::kH264FmtpPacketizationMode, "1"}}));
- cricket::Codec h264_high_1f = cricket::CreateVideoCodec(SdpVideoFormat(
+ Codec h264_high_1f = CreateVideoCodec(SdpVideoFormat(
cricket::kH264CodecName, {{cricket::kH264FmtpProfileLevelId, "640c1f"},
{cricket::kH264FmtpLevelAsymmetryAllowed, "1"},
{cricket::kH264FmtpPacketizationMode, "1"}}));
- cricket::Codec h264_high_2a = cricket::CreateVideoCodec(SdpVideoFormat(
+ Codec h264_high_2a = CreateVideoCodec(SdpVideoFormat(
cricket::kH264CodecName, {{cricket::kH264FmtpProfileLevelId, "640c2a"},
{cricket::kH264FmtpLevelAsymmetryAllowed, "1"},
{cricket::kH264FmtpPacketizationMode, "1"}}));
diff --git a/media/BUILD.gn b/media/BUILD.gn
index b7cefbb..033ebc2 100644
--- a/media/BUILD.gn
+++ b/media/BUILD.gn
@@ -384,6 +384,7 @@
"../rtc_base:stringutils",
"../rtc_base/system:rtc_export",
"//third_party/abseil-cpp/absl/algorithm:container",
+ "//third_party/abseil-cpp/absl/base:core_headers",
"//third_party/abseil-cpp/absl/container:inlined_vector",
"//third_party/abseil-cpp/absl/functional:any_invocable",
"//third_party/abseil-cpp/absl/strings",
diff --git a/media/base/codec.cc b/media/base/codec.cc
index 6caa19c..7052fe0 100644
--- a/media/base/codec.cc
+++ b/media/base/codec.cc
@@ -34,7 +34,7 @@
#include "rtc_base/string_encode.h"
#include "rtc_base/strings/string_builder.h"
-namespace cricket {
+namespace webrtc {
FeedbackParams::FeedbackParams() = default;
FeedbackParams::~FeedbackParams() = default;
@@ -119,7 +119,7 @@
}
Codec::Codec(const webrtc::SdpVideoFormat& c)
- : Codec(Type::kVideo, kIdNotSet, c.name, kVideoCodecClockrate) {
+ : Codec(Type::kVideo, kIdNotSet, c.name, cricket::kVideoCodecClockrate) {
params = c.parameters;
scalability_modes = c.scalability_modes;
}
@@ -177,8 +177,8 @@
params[key] = absl::StrCat(value);
}
-bool Codec::RemoveParam(const std::string& key) {
- return params.erase(key) == 1;
+bool Codec::RemoveParam(const std::string& name) {
+ return params.erase(name) == 1;
}
void Codec::AddFeedbackParam(const FeedbackParam& param) {
@@ -217,7 +217,7 @@
bool Codec::IsMediaCodec() const {
return !IsResiliencyCodec() &&
- !absl::EqualsIgnoreCase(name, kComfortNoiseCodecName);
+ !absl::EqualsIgnoreCase(name, cricket::kComfortNoiseCodecName);
}
bool Codec::IsResiliencyCodec() const {
@@ -225,16 +225,16 @@
}
Codec::ResiliencyType Codec::GetResiliencyType() const {
- if (absl::EqualsIgnoreCase(name, kRedCodecName)) {
+ if (absl::EqualsIgnoreCase(name, cricket::kRedCodecName)) {
return ResiliencyType::kRed;
}
- if (absl::EqualsIgnoreCase(name, kUlpfecCodecName)) {
+ if (absl::EqualsIgnoreCase(name, cricket::kUlpfecCodecName)) {
return ResiliencyType::kUlpfec;
}
- if (absl::EqualsIgnoreCase(name, kFlexfecCodecName)) {
+ if (absl::EqualsIgnoreCase(name, cricket::kFlexfecCodecName)) {
return ResiliencyType::kFlexfec;
}
- if (absl::EqualsIgnoreCase(name, kRtxCodecName)) {
+ if (absl::EqualsIgnoreCase(name, cricket::kRtxCodecName)) {
return ResiliencyType::kRtx;
}
return ResiliencyType::kNone;
@@ -251,8 +251,8 @@
int min_bitrate = -1;
int max_bitrate = -1;
- if (GetParam(kCodecParamMinBitrate, &min_bitrate) &&
- GetParam(kCodecParamMaxBitrate, &max_bitrate)) {
+ if (GetParam(cricket::kCodecParamMinBitrate, &min_bitrate) &&
+ GetParam(cricket::kCodecParamMaxBitrate, &max_bitrate)) {
if (max_bitrate < min_bitrate) {
RTC_LOG(LS_ERROR) << "Codec with max < min bitrate: " << ToString();
return false;
@@ -284,14 +284,17 @@
}
Codec CreateAudioRtxCodec(int rtx_payload_type, int associated_payload_type) {
- Codec rtx_codec = CreateAudioCodec(rtx_payload_type, kRtxCodecName, 0, 1);
- rtx_codec.SetParam(kCodecParamAssociatedPayloadType, associated_payload_type);
+ Codec rtx_codec =
+ CreateAudioCodec(rtx_payload_type, cricket::kRtxCodecName, 0, 1);
+ rtx_codec.SetParam(cricket::kCodecParamAssociatedPayloadType,
+ associated_payload_type);
return rtx_codec;
}
Codec CreateVideoRtxCodec(int rtx_payload_type, int associated_payload_type) {
- Codec rtx_codec = CreateVideoCodec(rtx_payload_type, kRtxCodecName);
- rtx_codec.SetParam(kCodecParamAssociatedPayloadType, associated_payload_type);
+ Codec rtx_codec = CreateVideoCodec(rtx_payload_type, cricket::kRtxCodecName);
+ rtx_codec.SetParam(cricket::kCodecParamAssociatedPayloadType,
+ associated_payload_type);
return rtx_codec;
}
@@ -305,22 +308,22 @@
bool HasLntf(const Codec& codec) {
return codec.HasFeedbackParam(
- FeedbackParam(kRtcpFbParamLntf, kParamValueEmpty));
+ FeedbackParam(cricket::kRtcpFbParamLntf, cricket::kParamValueEmpty));
}
bool HasNack(const Codec& codec) {
return codec.HasFeedbackParam(
- FeedbackParam(kRtcpFbParamNack, kParamValueEmpty));
+ FeedbackParam(cricket::kRtcpFbParamNack, cricket::kParamValueEmpty));
}
bool HasRemb(const Codec& codec) {
return codec.HasFeedbackParam(
- FeedbackParam(kRtcpFbParamRemb, kParamValueEmpty));
+ FeedbackParam(cricket::kRtcpFbParamRemb, cricket::kParamValueEmpty));
}
bool HasRrtr(const Codec& codec) {
return codec.HasFeedbackParam(
- FeedbackParam(kRtcpFbParamRrtr, kParamValueEmpty));
+ FeedbackParam(cricket::kRtcpFbParamRrtr, cricket::kParamValueEmpty));
}
const Codec* FindMatchingVideoCodec(const std::vector<Codec>& supported_codecs,
@@ -404,13 +407,13 @@
}
Codec CreateVideoCodec(int id, const std::string& name) {
- Codec c(Codec::Type::kVideo, id, name, kVideoCodecClockrate);
- if (absl::EqualsIgnoreCase(kH264CodecName, name)) {
+ Codec c(Codec::Type::kVideo, id, name, cricket::kVideoCodecClockrate);
+ if (absl::EqualsIgnoreCase(cricket::kH264CodecName, name)) {
// This default is set for all H.264 codecs created because
// that was the default before packetization mode support was added.
// TODO(hta): Move this to the places that create VideoCodecs from
// SDP or from knowledge of implementation capabilities.
- c.SetParam(kH264FmtpPacketizationMode, "1");
+ c.SetParam(cricket::kH264FmtpPacketizationMode, "1");
}
return c;
}
@@ -425,4 +428,4 @@
return c;
}
-} // namespace cricket
+} // namespace webrtc
diff --git a/media/base/codec.h b/media/base/codec.h
index 2bc2fb9..879beee 100644
--- a/media/base/codec.h
+++ b/media/base/codec.h
@@ -16,6 +16,7 @@
#include <string>
#include <vector>
+#include "absl/base/macros.h"
#include "absl/container/inlined_vector.h"
#include "absl/strings/str_format.h"
#include "absl/strings/string_view.h"
@@ -26,7 +27,7 @@
#include "media/base/media_constants.h"
#include "rtc_base/system/rtc_export.h"
-namespace cricket {
+namespace webrtc {
class FeedbackParam {
public:
@@ -34,7 +35,7 @@
FeedbackParam(absl::string_view id, const std::string& param)
: id_(id), param_(param) {}
explicit FeedbackParam(absl::string_view id)
- : id_(id), param_(kParamValueEmpty) {}
+ : id_(id), param_(cricket::kParamValueEmpty) {}
bool operator==(const FeedbackParam& other) const;
bool operator!=(const FeedbackParam& c) const { return !(*this == c); }
@@ -225,12 +226,6 @@
int associated_payload_type);
};
-// TODO(webrtc:15214): Compatibility names, to be migrated away and removed.
-using VideoCodec [[deprecated]] = Codec;
-using AudioCodec [[deprecated]] = Codec;
-
-using VideoCodecs [[deprecated]] = std::vector<Codec>;
-using AudioCodecs [[deprecated]] = std::vector<Codec>;
using Codecs = std::vector<Codec>;
Codec CreateAudioCodec(int id,
@@ -242,7 +237,7 @@
Codec CreateVideoCodec(const std::string& name);
Codec CreateVideoCodec(int id, const std::string& name);
Codec CreateVideoCodec(const webrtc::SdpVideoFormat& c);
-Codec CreateVideoCodec(int id, const webrtc::SdpVideoFormat& c);
+Codec CreateVideoCodec(int id, const webrtc::SdpVideoFormat& sdp);
Codec CreateVideoRtxCodec(int rtx_payload_type, int associated_payload_type);
// Get the codec setting associated with `payload_type`. If there
@@ -266,6 +261,96 @@
RTC_EXPORT void AddH264ConstrainedBaselineProfileToSupportedFormats(
std::vector<webrtc::SdpVideoFormat>* supported_formats);
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace cricket {
+
+using FeedbackParam ABSL_DEPRECATE_AND_INLINE() = webrtc::FeedbackParam;
+using FeedbackParams ABSL_DEPRECATE_AND_INLINE() = webrtc::FeedbackParams;
+using Codec ABSL_DEPRECATE_AND_INLINE() = webrtc::Codec;
+using Codecs ABSL_DEPRECATE_AND_INLINE() = webrtc::Codecs;
+
+// TODO(webrtc:15214): Compatibility names, to be migrated away and removed.
+using VideoCodec ABSL_DEPRECATE_AND_INLINE() = webrtc::Codec;
+using AudioCodec ABSL_DEPRECATE_AND_INLINE() = webrtc::Codec;
+using VideoCodecs ABSL_DEPRECATE_AND_INLINE() = webrtc::Codecs;
+using AudioCodecs ABSL_DEPRECATE_AND_INLINE() = webrtc::Codecs;
+using ::webrtc::AddH264ConstrainedBaselineProfileToSupportedFormats;
+
+ABSL_DEPRECATE_AND_INLINE()
+inline webrtc::Codec CreateAudioCodec(int id,
+ const std::string& name,
+ int clockrate,
+ size_t channels) {
+ return webrtc::CreateAudioCodec(id, name, clockrate, channels);
+}
+ABSL_DEPRECATE_AND_INLINE()
+inline webrtc::Codec CreateAudioCodec(const webrtc::SdpAudioFormat& c) {
+ return webrtc::CreateAudioCodec(c);
+}
+ABSL_DEPRECATE_AND_INLINE()
+inline webrtc::Codec CreateAudioRtxCodec(int rtx_payload_type,
+ int associated_payload_type) {
+ return webrtc::CreateAudioRtxCodec(rtx_payload_type, associated_payload_type);
+}
+ABSL_DEPRECATE_AND_INLINE()
+inline webrtc::Codec CreateVideoCodec(const std::string& name) {
+ return webrtc::CreateVideoCodec(name);
+}
+ABSL_DEPRECATE_AND_INLINE()
+inline webrtc::Codec CreateVideoCodec(int id, const std::string& name) {
+ return webrtc::CreateVideoCodec(id, name);
+}
+ABSL_DEPRECATE_AND_INLINE()
+inline webrtc::Codec CreateVideoCodec(const webrtc::SdpVideoFormat& c) {
+ return webrtc::CreateVideoCodec(c);
+}
+ABSL_DEPRECATE_AND_INLINE()
+inline webrtc::Codec CreateVideoCodec(int id, const webrtc::SdpVideoFormat& c) {
+ return webrtc::CreateVideoCodec(id, c);
+}
+ABSL_DEPRECATE_AND_INLINE()
+inline webrtc::Codec CreateVideoRtxCodec(int rtx_payload_type,
+ int associated_payload_type) {
+ return webrtc::CreateVideoRtxCodec(rtx_payload_type, associated_payload_type);
+}
+
+ABSL_DEPRECATE_AND_INLINE()
+inline const webrtc::Codec* FindCodecById(
+ const std::vector<webrtc::Codec>& codecs,
+ int payload_type) {
+ return webrtc::FindCodecById(codecs, payload_type);
+}
+
+ABSL_DEPRECATE_AND_INLINE()
+inline bool HasLntf(const webrtc::Codec& codec) {
+ return webrtc::HasLntf(codec);
+}
+ABSL_DEPRECATE_AND_INLINE()
+inline bool HasNack(const webrtc::Codec& codec) {
+ return webrtc::HasNack(codec);
+}
+ABSL_DEPRECATE_AND_INLINE()
+inline bool HasRemb(const webrtc::Codec& codec) {
+ return webrtc::HasRemb(codec);
+}
+ABSL_DEPRECATE_AND_INLINE() inline bool HasRrtr(const webrtc::Codec& codec) {
+ return webrtc::HasRrtr(codec);
+}
+ABSL_DEPRECATE_AND_INLINE()
+inline const webrtc::Codec* FindMatchingVideoCodec(
+ const webrtc::Codecs& supported_codecs,
+ const webrtc::Codec& codec) {
+ return webrtc::FindMatchingVideoCodec(supported_codecs, codec);
+}
+ABSL_DEPRECATE_AND_INLINE()
+inline std::vector<const webrtc::Codec*> FindAllMatchingCodecs(
+ const webrtc::Codecs& supported_codecs,
+ const webrtc::Codec& codec) {
+ return webrtc::FindAllMatchingCodecs(supported_codecs, codec);
+}
} // namespace cricket
diff --git a/media/base/codec_comparators.cc b/media/base/codec_comparators.cc
index 37952ca..caff493 100644
--- a/media/base/codec_comparators.cc
+++ b/media/base/codec_comparators.cc
@@ -37,8 +37,6 @@
namespace {
-using cricket::Codec;
-
// TODO(bugs.webrtc.org/15847): remove code duplication of IsSameCodecSpecific
// in api/video_codecs/sdp_video_format.cc
std::string GetFmtpParameterOrDefault(const CodecParameterMap& params,
diff --git a/media/base/codec_comparators.h b/media/base/codec_comparators.h
index 64423c7..1d242b1 100644
--- a/media/base/codec_comparators.h
+++ b/media/base/codec_comparators.h
@@ -20,13 +20,12 @@
namespace webrtc {
// Comparison used for the Codec::Matches function
-bool MatchesWithCodecRules(const cricket::Codec& left_codec,
- const cricket::Codec& codec);
+bool MatchesWithCodecRules(const Codec& left_codec, const Codec& codec);
// Comparison that also checks on codecs referenced by PT in the
// fmtp line, as used with RED and RTX "codecs".
-bool MatchesWithReferenceAttributes(const cricket::Codec& left_codec,
- const cricket::Codec& right_codec);
+bool MatchesWithReferenceAttributes(const Codec& left_codec,
+ const Codec& right_codec);
// Finds a codec in `codecs2` that matches `codec_to_match`, which is
// a member of `codecs1`. If `codec_to_match` is an RED or RTX codec, both
@@ -35,18 +34,16 @@
// PT numbering spaces, and it is trying to find the codec in codecs2
// that has the same functionality as `codec_to_match` so that its PT
// can be used in place of the original.
-std::optional<cricket::Codec> FindMatchingCodec(
- const std::vector<cricket::Codec>& codecs1,
- const std::vector<cricket::Codec>& codecs2,
- const cricket::Codec& codec_to_match);
+std::optional<Codec> FindMatchingCodec(const std::vector<Codec>& codecs1,
+ const std::vector<Codec>& codecs2,
+ const Codec& codec_to_match);
// Similar to `Codec::MatchesRtpCodec` but not an exact match of parameters.
// Unspecified parameters are treated as default.
-bool IsSameRtpCodec(const cricket::Codec& codec, const RtpCodec& rtp_codec);
+bool IsSameRtpCodec(const Codec& codec, const RtpCodec& rtp_codec);
// Similar to `IsSameRtpCodec` but ignoring the level related parameter.
-bool IsSameRtpCodecIgnoringLevel(const cricket::Codec& codec,
- const RtpCodec& rtp_codec);
+bool IsSameRtpCodecIgnoringLevel(const Codec& codec, const RtpCodec& rtp_codec);
} // namespace webrtc
#endif // MEDIA_BASE_CODEC_COMPARATORS_H_
diff --git a/media/base/codec_comparators_unittest.cc b/media/base/codec_comparators_unittest.cc
index d22cb94..7bd0d3d 100644
--- a/media/base/codec_comparators_unittest.cc
+++ b/media/base/codec_comparators_unittest.cc
@@ -22,16 +22,13 @@
namespace webrtc {
-using cricket::Codec;
-using cricket::CreateAudioCodec;
-using cricket::CreateVideoCodec;
using cricket::kH264CodecName;
using cricket::kH264FmtpPacketizationMode;
using ::testing::TestWithParam;
using ::testing::ValuesIn;
TEST(CodecComparatorsTest, CodecMatchesItself) {
- Codec codec = cricket::CreateVideoCodec("custom");
+ Codec codec = CreateVideoCodec("custom");
EXPECT_TRUE(MatchesWithCodecRules(codec, codec));
}
@@ -82,15 +79,12 @@
TEST(CodecComparatorsTest, MatchesWithReferenceAttributesRed) {
// Test that RED codecs' reference attributes get parsed correctly.
- Codec codec_1 =
- cricket::CreateAudioCodec(101, cricket::kRedCodecName, 48000, 2);
+ Codec codec_1 = CreateAudioCodec(101, cricket::kRedCodecName, 48000, 2);
codec_1.SetParam(cricket::kCodecParamNotInNameValueFormat, "100/100");
- Codec codec_2 =
- cricket::CreateAudioCodec(102, cricket::kRedCodecName, 48000, 2);
+ Codec codec_2 = CreateAudioCodec(102, cricket::kRedCodecName, 48000, 2);
codec_2.SetParam(cricket::kCodecParamNotInNameValueFormat, "101/101");
// Mixed codecs in RED
- Codec codec_3 =
- cricket::CreateAudioCodec(103, cricket::kRedCodecName, 48000, 2);
+ Codec codec_3 = CreateAudioCodec(103, cricket::kRedCodecName, 48000, 2);
codec_3.SetParam(cricket::kCodecParamNotInNameValueFormat, "100/101");
// Identical codecs always match.
EXPECT_TRUE(MatchesWithReferenceAttributes(codec_1, codec_1));
@@ -102,14 +96,12 @@
EXPECT_FALSE(MatchesWithReferenceAttributes(codec_2, codec_3));
// Overflow of longer lists are ignored.
// Overlong list - overflow should be ignored.
- Codec codec_4 =
- cricket::CreateAudioCodec(103, cricket::kRedCodecName, 48000, 2);
+ Codec codec_4 = CreateAudioCodec(103, cricket::kRedCodecName, 48000, 2);
codec_4.SetParam(cricket::kCodecParamNotInNameValueFormat, "100/100/101/102");
EXPECT_TRUE(MatchesWithReferenceAttributes(codec_4, codec_4));
EXPECT_TRUE(MatchesWithReferenceAttributes(codec_1, codec_4));
// Broken syntax will cause a non-match with anything except itself.
- Codec codec_5 =
- cricket::CreateAudioCodec(103, cricket::kRedCodecName, 48000, 2);
+ Codec codec_5 = CreateAudioCodec(103, cricket::kRedCodecName, 48000, 2);
codec_5.SetParam(cricket::kCodecParamNotInNameValueFormat, "");
EXPECT_TRUE(MatchesWithReferenceAttributes(codec_5, codec_5));
EXPECT_FALSE(MatchesWithReferenceAttributes(codec_1, codec_5));
@@ -126,8 +118,8 @@
TEST_P(IsSameRtpCodecTest, IsSameRtpCodec) {
TestParams param = GetParam();
- Codec codec1 = cricket::CreateVideoCodec(param.codec1);
- Codec codec2 = cricket::CreateVideoCodec(param.codec2);
+ Codec codec1 = CreateVideoCodec(param.codec1);
+ Codec codec2 = CreateVideoCodec(param.codec2);
EXPECT_EQ(IsSameRtpCodec(codec1, codec2.ToCodecParameters()),
param.expected_result);
@@ -348,53 +340,53 @@
TEST(CodecTest, TestCodecMatches) {
// Test a codec with a static payload type.
- Codec c0 = cricket::CreateAudioCodec(34, "A", 44100, 1);
- EXPECT_TRUE(c0.Matches(cricket::CreateAudioCodec(34, "", 44100, 1)));
- EXPECT_TRUE(c0.Matches(cricket::CreateAudioCodec(34, "", 44100, 0)));
- EXPECT_TRUE(c0.Matches(cricket::CreateAudioCodec(34, "", 44100, 0)));
- EXPECT_TRUE(c0.Matches(cricket::CreateAudioCodec(34, "", 0, 0)));
- EXPECT_FALSE(c0.Matches(cricket::CreateAudioCodec(96, "A", 44100, 1)));
- EXPECT_FALSE(c0.Matches(cricket::CreateAudioCodec(96, "", 44100, 1)));
- EXPECT_FALSE(c0.Matches(cricket::CreateAudioCodec(95, "", 55100, 1)));
- EXPECT_FALSE(c0.Matches(cricket::CreateAudioCodec(95, "", 44100, 1)));
- EXPECT_FALSE(c0.Matches(cricket::CreateAudioCodec(95, "", 44100, 2)));
- EXPECT_FALSE(c0.Matches(cricket::CreateAudioCodec(95, "", 55100, 2)));
+ Codec c0 = CreateAudioCodec(34, "A", 44100, 1);
+ EXPECT_TRUE(c0.Matches(CreateAudioCodec(34, "", 44100, 1)));
+ EXPECT_TRUE(c0.Matches(CreateAudioCodec(34, "", 44100, 0)));
+ EXPECT_TRUE(c0.Matches(CreateAudioCodec(34, "", 44100, 0)));
+ EXPECT_TRUE(c0.Matches(CreateAudioCodec(34, "", 0, 0)));
+ EXPECT_FALSE(c0.Matches(CreateAudioCodec(96, "A", 44100, 1)));
+ EXPECT_FALSE(c0.Matches(CreateAudioCodec(96, "", 44100, 1)));
+ EXPECT_FALSE(c0.Matches(CreateAudioCodec(95, "", 55100, 1)));
+ EXPECT_FALSE(c0.Matches(CreateAudioCodec(95, "", 44100, 1)));
+ EXPECT_FALSE(c0.Matches(CreateAudioCodec(95, "", 44100, 2)));
+ EXPECT_FALSE(c0.Matches(CreateAudioCodec(95, "", 55100, 2)));
// Test a codec with a dynamic payload type.
- Codec c1 = cricket::CreateAudioCodec(96, "A", 44100, 1);
- EXPECT_TRUE(c1.Matches(cricket::CreateAudioCodec(96, "A", 0, 0)));
- EXPECT_TRUE(c1.Matches(cricket::CreateAudioCodec(97, "A", 0, 0)));
- EXPECT_TRUE(c1.Matches(cricket::CreateAudioCodec(96, "a", 0, 0)));
- EXPECT_TRUE(c1.Matches(cricket::CreateAudioCodec(97, "a", 0, 0)));
- EXPECT_TRUE(c1.Matches(cricket::CreateAudioCodec(35, "a", 0, 0)));
- EXPECT_TRUE(c1.Matches(cricket::CreateAudioCodec(42, "a", 0, 0)));
- EXPECT_TRUE(c1.Matches(cricket::CreateAudioCodec(65, "a", 0, 0)));
- EXPECT_FALSE(c1.Matches(cricket::CreateAudioCodec(95, "A", 0, 0)));
- EXPECT_FALSE(c1.Matches(cricket::CreateAudioCodec(34, "A", 0, 0)));
- EXPECT_FALSE(c1.Matches(cricket::CreateAudioCodec(96, "", 44100, 2)));
- EXPECT_FALSE(c1.Matches(cricket::CreateAudioCodec(96, "A", 55100, 1)));
+ Codec c1 = CreateAudioCodec(96, "A", 44100, 1);
+ EXPECT_TRUE(c1.Matches(CreateAudioCodec(96, "A", 0, 0)));
+ EXPECT_TRUE(c1.Matches(CreateAudioCodec(97, "A", 0, 0)));
+ EXPECT_TRUE(c1.Matches(CreateAudioCodec(96, "a", 0, 0)));
+ EXPECT_TRUE(c1.Matches(CreateAudioCodec(97, "a", 0, 0)));
+ EXPECT_TRUE(c1.Matches(CreateAudioCodec(35, "a", 0, 0)));
+ EXPECT_TRUE(c1.Matches(CreateAudioCodec(42, "a", 0, 0)));
+ EXPECT_TRUE(c1.Matches(CreateAudioCodec(65, "a", 0, 0)));
+ EXPECT_FALSE(c1.Matches(CreateAudioCodec(95, "A", 0, 0)));
+ EXPECT_FALSE(c1.Matches(CreateAudioCodec(34, "A", 0, 0)));
+ EXPECT_FALSE(c1.Matches(CreateAudioCodec(96, "", 44100, 2)));
+ EXPECT_FALSE(c1.Matches(CreateAudioCodec(96, "A", 55100, 1)));
// Test a codec with a dynamic payload type, and auto bitrate.
- Codec c2 = cricket::CreateAudioCodec(97, "A", 16000, 1);
+ Codec c2 = CreateAudioCodec(97, "A", 16000, 1);
// Use default bitrate.
- EXPECT_TRUE(c2.Matches(cricket::CreateAudioCodec(97, "A", 16000, 1)));
- EXPECT_TRUE(c2.Matches(cricket::CreateAudioCodec(97, "A", 16000, 0)));
+ EXPECT_TRUE(c2.Matches(CreateAudioCodec(97, "A", 16000, 1)));
+ EXPECT_TRUE(c2.Matches(CreateAudioCodec(97, "A", 16000, 0)));
// Use explicit bitrate.
- EXPECT_TRUE(c2.Matches(cricket::CreateAudioCodec(97, "A", 16000, 1)));
+ EXPECT_TRUE(c2.Matches(CreateAudioCodec(97, "A", 16000, 1)));
// Backward compatibility with clients that might send "-1" (for default).
- EXPECT_TRUE(c2.Matches(cricket::CreateAudioCodec(97, "A", 16000, 1)));
+ EXPECT_TRUE(c2.Matches(CreateAudioCodec(97, "A", 16000, 1)));
// Stereo doesn't match channels = 0.
- Codec c3 = cricket::CreateAudioCodec(96, "A", 44100, 2);
- EXPECT_TRUE(c3.Matches(cricket::CreateAudioCodec(96, "A", 44100, 2)));
- EXPECT_FALSE(c3.Matches(cricket::CreateAudioCodec(96, "A", 44100, 1)));
- EXPECT_FALSE(c3.Matches(cricket::CreateAudioCodec(96, "A", 44100, 0)));
+ Codec c3 = CreateAudioCodec(96, "A", 44100, 2);
+ EXPECT_TRUE(c3.Matches(CreateAudioCodec(96, "A", 44100, 2)));
+ EXPECT_FALSE(c3.Matches(CreateAudioCodec(96, "A", 44100, 1)));
+ EXPECT_FALSE(c3.Matches(CreateAudioCodec(96, "A", 44100, 0)));
}
TEST(CodecTest, TestOpusAudioCodecWithDifferentParameters) {
- Codec opus_with_fec = cricket::CreateAudioCodec(96, "opus", 48000, 2);
+ Codec opus_with_fec = CreateAudioCodec(96, "opus", 48000, 2);
opus_with_fec.params["useinbandfec"] = "1";
- Codec opus_without_fec = cricket::CreateAudioCodec(96, "opus", 48000, 2);
+ Codec opus_without_fec = CreateAudioCodec(96, "opus", 48000, 2);
EXPECT_TRUE(opus_with_fec != opus_without_fec);
// Matches does not compare parameters for audio.
@@ -409,28 +401,28 @@
TEST(CodecTest, TestVideoCodecMatches) {
// Test a codec with a static payload type.
- Codec c0 = cricket::CreateVideoCodec(34, "V");
- EXPECT_TRUE(c0.Matches(cricket::CreateVideoCodec(34, "")));
- EXPECT_FALSE(c0.Matches(cricket::CreateVideoCodec(96, "")));
- EXPECT_FALSE(c0.Matches(cricket::CreateVideoCodec(96, "V")));
+ Codec c0 = CreateVideoCodec(34, "V");
+ EXPECT_TRUE(c0.Matches(CreateVideoCodec(34, "")));
+ EXPECT_FALSE(c0.Matches(CreateVideoCodec(96, "")));
+ EXPECT_FALSE(c0.Matches(CreateVideoCodec(96, "V")));
// Test a codec with a dynamic payload type.
- Codec c1 = cricket::CreateVideoCodec(96, "V");
- EXPECT_TRUE(c1.Matches(cricket::CreateVideoCodec(96, "V")));
- EXPECT_TRUE(c1.Matches(cricket::CreateVideoCodec(97, "V")));
- EXPECT_TRUE(c1.Matches(cricket::CreateVideoCodec(96, "v")));
- EXPECT_TRUE(c1.Matches(cricket::CreateVideoCodec(97, "v")));
- EXPECT_TRUE(c1.Matches(cricket::CreateVideoCodec(35, "v")));
- EXPECT_TRUE(c1.Matches(cricket::CreateVideoCodec(42, "v")));
- EXPECT_TRUE(c1.Matches(cricket::CreateVideoCodec(65, "v")));
- EXPECT_FALSE(c1.Matches(cricket::CreateVideoCodec(96, "")));
- EXPECT_FALSE(c1.Matches(cricket::CreateVideoCodec(95, "V")));
- EXPECT_FALSE(c1.Matches(cricket::CreateVideoCodec(34, "V")));
+ Codec c1 = CreateVideoCodec(96, "V");
+ EXPECT_TRUE(c1.Matches(CreateVideoCodec(96, "V")));
+ EXPECT_TRUE(c1.Matches(CreateVideoCodec(97, "V")));
+ EXPECT_TRUE(c1.Matches(CreateVideoCodec(96, "v")));
+ EXPECT_TRUE(c1.Matches(CreateVideoCodec(97, "v")));
+ EXPECT_TRUE(c1.Matches(CreateVideoCodec(35, "v")));
+ EXPECT_TRUE(c1.Matches(CreateVideoCodec(42, "v")));
+ EXPECT_TRUE(c1.Matches(CreateVideoCodec(65, "v")));
+ EXPECT_FALSE(c1.Matches(CreateVideoCodec(96, "")));
+ EXPECT_FALSE(c1.Matches(CreateVideoCodec(95, "V")));
+ EXPECT_FALSE(c1.Matches(CreateVideoCodec(34, "V")));
}
TEST(CodecTest, TestVideoCodecMatchesWithDifferentPacketization) {
- Codec c0 = cricket::CreateVideoCodec(100, cricket::kVp8CodecName);
- Codec c1 = cricket::CreateVideoCodec(101, cricket::kVp8CodecName);
+ Codec c0 = CreateVideoCodec(100, cricket::kVp8CodecName);
+ Codec c1 = CreateVideoCodec(101, cricket::kVp8CodecName);
c1.packetization = "raw";
EXPECT_TRUE(c0.Matches(c1));
@@ -443,12 +435,12 @@
const char kProfile1[] = "1";
const char kProfile2[] = "2";
- Codec c_no_profile = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
- Codec c_profile0 = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
+ Codec c_no_profile = CreateVideoCodec(95, cricket::kAv1CodecName);
+ Codec c_profile0 = CreateVideoCodec(95, cricket::kAv1CodecName);
c_profile0.params[cricket::kAv1FmtpProfile] = kProfile0;
- Codec c_profile1 = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
+ Codec c_profile1 = CreateVideoCodec(95, cricket::kAv1CodecName);
c_profile1.params[cricket::kAv1FmtpProfile] = kProfile1;
- Codec c_profile2 = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
+ Codec c_profile2 = CreateVideoCodec(95, cricket::kAv1CodecName);
c_profile2.params[cricket::kAv1FmtpProfile] = kProfile2;
// An AV1 entry with no profile specified should be treated as profile-0.
@@ -456,21 +448,20 @@
{
// Two AV1 entries without a profile specified are treated as duplicates.
- Codec c_no_profile_eq =
- cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
+ Codec c_no_profile_eq = CreateVideoCodec(95, cricket::kAv1CodecName);
EXPECT_TRUE(c_no_profile.Matches(c_no_profile_eq));
}
{
// Two AV1 entries with profile 0 specified are treated as duplicates.
- Codec c_profile0_eq = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
+ Codec c_profile0_eq = CreateVideoCodec(95, cricket::kAv1CodecName);
c_profile0_eq.params[cricket::kAv1FmtpProfile] = kProfile0;
EXPECT_TRUE(c_profile0.Matches(c_profile0_eq));
}
{
// Two AV1 entries with profile 1 specified are treated as duplicates.
- Codec c_profile1_eq = cricket::CreateVideoCodec(95, cricket::kAv1CodecName);
+ Codec c_profile1_eq = CreateVideoCodec(95, cricket::kAv1CodecName);
c_profile1_eq.params[cricket::kAv1FmtpProfile] = kProfile1;
EXPECT_TRUE(c_profile1.Matches(c_profile1_eq));
}
@@ -489,28 +480,27 @@
const char kProfile0[] = "0";
const char kProfile2[] = "2";
- Codec c_no_profile = cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
- Codec c_profile0 = cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
+ Codec c_no_profile = CreateVideoCodec(95, cricket::kVp9CodecName);
+ Codec c_profile0 = CreateVideoCodec(95, cricket::kVp9CodecName);
c_profile0.params[webrtc::kVP9FmtpProfileId] = kProfile0;
EXPECT_TRUE(c_profile0.Matches(c_no_profile));
{
- Codec c_profile0_eq = cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
+ Codec c_profile0_eq = CreateVideoCodec(95, cricket::kVp9CodecName);
c_profile0_eq.params[webrtc::kVP9FmtpProfileId] = kProfile0;
EXPECT_TRUE(c_profile0.Matches(c_profile0_eq));
}
{
- Codec c_profile2 = cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
+ Codec c_profile2 = CreateVideoCodec(95, cricket::kVp9CodecName);
c_profile2.params[webrtc::kVP9FmtpProfileId] = kProfile2;
EXPECT_FALSE(c_profile0.Matches(c_profile2));
EXPECT_FALSE(c_no_profile.Matches(c_profile2));
}
{
- Codec c_no_profile_eq =
- cricket::CreateVideoCodec(95, cricket::kVp9CodecName);
+ Codec c_no_profile_eq = CreateVideoCodec(95, cricket::kVp9CodecName);
EXPECT_TRUE(c_no_profile.Matches(c_no_profile_eq));
}
}
@@ -522,12 +512,12 @@
const char kProfileLevelId2[] = "42a01e";
const char kProfileLevelId3[] = "42e01e";
- Codec pli_1_pm_0 = cricket::CreateVideoCodec(95, "H264");
+ Codec pli_1_pm_0 = CreateVideoCodec(95, "H264");
pli_1_pm_0.params[cricket::kH264FmtpProfileLevelId] = kProfileLevelId1;
pli_1_pm_0.params[cricket::kH264FmtpPacketizationMode] = "0";
{
- Codec pli_1_pm_blank = cricket::CreateVideoCodec(95, "H264");
+ Codec pli_1_pm_blank = CreateVideoCodec(95, "H264");
pli_1_pm_blank.params[cricket::kH264FmtpProfileLevelId] = kProfileLevelId1;
pli_1_pm_blank.params.erase(
pli_1_pm_blank.params.find(cricket::kH264FmtpPacketizationMode));
@@ -541,7 +531,7 @@
}
{
- Codec pli_1_pm_1 = cricket::CreateVideoCodec(95, "H264");
+ Codec pli_1_pm_1 = CreateVideoCodec(95, "H264");
pli_1_pm_1.params[cricket::kH264FmtpProfileLevelId] = kProfileLevelId1;
pli_1_pm_1.params[cricket::kH264FmtpPacketizationMode] = "1";
@@ -552,7 +542,7 @@
}
{
- Codec pli_2_pm_0 = cricket::CreateVideoCodec(95, "H264");
+ Codec pli_2_pm_0 = CreateVideoCodec(95, "H264");
pli_2_pm_0.params[cricket::kH264FmtpProfileLevelId] = kProfileLevelId2;
pli_2_pm_0.params[cricket::kH264FmtpPacketizationMode] = "0";
@@ -563,7 +553,7 @@
}
{
- Codec pli_3_pm_0_asym = cricket::CreateVideoCodec(95, "H264");
+ Codec pli_3_pm_0_asym = CreateVideoCodec(95, "H264");
pli_3_pm_0_asym.params[cricket::kH264FmtpProfileLevelId] = kProfileLevelId3;
pli_3_pm_0_asym.params[cricket::kH264FmtpPacketizationMode] = "0";
@@ -587,10 +577,10 @@
constexpr char kLevel4[] = "120";
constexpr char kTxMrst[] = "MRST";
- Codec c_ptl_blank = cricket::CreateVideoCodec(95, cricket::kH265CodecName);
+ Codec c_ptl_blank = CreateVideoCodec(95, cricket::kH265CodecName);
{
- Codec c_profile_1 = cricket::CreateVideoCodec(95, cricket::kH265CodecName);
+ Codec c_profile_1 = CreateVideoCodec(95, cricket::kH265CodecName);
c_profile_1.params[cricket::kH265FmtpProfileId] = kProfile1;
// Matches since profile-id unspecified defaults to "1".
@@ -598,8 +588,7 @@
}
{
- Codec c_tier_flag_1 =
- cricket::CreateVideoCodec(95, cricket::kH265CodecName);
+ Codec c_tier_flag_1 = CreateVideoCodec(95, cricket::kH265CodecName);
c_tier_flag_1.params[cricket::kH265FmtpTierFlag] = kTier1;
// Does not match since profile-space unspecified defaults to "0".
@@ -607,8 +596,7 @@
}
{
- Codec c_level_id_3_1 =
- cricket::CreateVideoCodec(95, cricket::kH265CodecName);
+ Codec c_level_id_3_1 = CreateVideoCodec(95, cricket::kH265CodecName);
c_level_id_3_1.params[cricket::kH265FmtpLevelId] = kLevel3_1;
// Matches since level-id unspecified defaults to "93".
@@ -616,7 +604,7 @@
}
{
- Codec c_level_id_4 = cricket::CreateVideoCodec(95, cricket::kH265CodecName);
+ Codec c_level_id_4 = CreateVideoCodec(95, cricket::kH265CodecName);
c_level_id_4.params[cricket::kH265FmtpLevelId] = kLevel4;
// Matches since we ignore level-id when matching H.265 codecs.
@@ -624,8 +612,7 @@
}
{
- Codec c_tx_mode_mrst =
- cricket::CreateVideoCodec(95, cricket::kH265CodecName);
+ Codec c_tx_mode_mrst = CreateVideoCodec(95, cricket::kH265CodecName);
c_tx_mode_mrst.params[cricket::kH265FmtpTxMode] = kTxMrst;
// Does not match since tx-mode implies to "SRST" and must be not specified
@@ -637,8 +624,8 @@
#endif
TEST(CodecTest, TestMatchesRtpCodecRtx) {
- const Codec rtx_codec_1 = cricket::CreateVideoRtxCodec(96, 120);
- const Codec rtx_codec_2 = cricket::CreateVideoRtxCodec(96, 121);
+ const Codec rtx_codec_1 = CreateVideoRtxCodec(96, 120);
+ const Codec rtx_codec_2 = CreateVideoRtxCodec(96, 121);
EXPECT_TRUE(rtx_codec_1.Matches(rtx_codec_2));
// MatchesRtpCodec ignores the different associated payload type (apt) for
// RTX.
diff --git a/media/base/codec_list.cc b/media/base/codec_list.cc
index c4b7252..4e7d0d9 100644
--- a/media/base/codec_list.cc
+++ b/media/base/codec_list.cc
@@ -21,7 +21,7 @@
#include "rtc_base/logging.h"
#include "rtc_base/string_encode.h"
-namespace cricket {
+namespace webrtc {
using webrtc::RTCError;
using webrtc::RTCErrorOr;
@@ -43,14 +43,15 @@
}
}
}
- for (const Codec& codec : codecs) {
+ for (const webrtc::Codec& codec : codecs) {
switch (codec.GetResiliencyType()) {
case Codec::ResiliencyType::kRed:
// Check that the target codec exists
break;
case Codec::ResiliencyType::kRtx: {
// Check that the target codec exists
- const auto apt_it = codec.params.find(kCodecParamAssociatedPayloadType);
+ const auto apt_it =
+ codec.params.find(cricket::kCodecParamAssociatedPayloadType);
// Not true - there's a test that deliberately injects a wrong
// RTX codec (MediaSessionDescriptionFactoryTest.RtxWithoutApt)
// TODO: https://issues.webrtc.org/384756622 - reject codec earlier and
@@ -121,4 +122,4 @@
RTC_DCHECK(CheckInputConsistency(codecs_).ok());
}
-} // namespace cricket
+} // namespace webrtc
diff --git a/media/base/codec_list.h b/media/base/codec_list.h
index 428a3d4..e4ca3e8 100644
--- a/media/base/codec_list.h
+++ b/media/base/codec_list.h
@@ -17,7 +17,7 @@
#include "api/rtc_error.h"
#include "media/base/codec.h"
-namespace cricket {
+namespace webrtc {
class CodecList {
public:
@@ -35,7 +35,7 @@
// Creates a codec list on untrusted data. If successful, the
// resulting CodecList satisfies all the CodecList invariants.
- static webrtc::RTCErrorOr<CodecList> Create(const std::vector<Codec>& codecs);
+ static RTCErrorOr<CodecList> Create(const std::vector<Codec>& codecs);
// Creates a codec list on trusted data. Only for use when
// the codec list is generated from internal code.
static CodecList CreateFromTrustedData(const std::vector<Codec>& codecs) {
@@ -83,6 +83,12 @@
std::vector<Codec> codecs_;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace cricket {
+using ::webrtc::CodecList;
} // namespace cricket
#endif // MEDIA_BASE_CODEC_LIST_H_
diff --git a/media/base/codec_list_unittest.cc b/media/base/codec_list_unittest.cc
index 2806f06..161b59d 100644
--- a/media/base/codec_list_unittest.cc
+++ b/media/base/codec_list_unittest.cc
@@ -19,7 +19,7 @@
#include "rtc_base/checks.h"
#include "test/gtest.h"
-namespace cricket {
+namespace webrtc {
namespace {
using webrtc::RTCErrorOr;
@@ -29,16 +29,15 @@
CodecList empty_list = CodecList::CreateFromTrustedData(std::vector<Codec>{});
EXPECT_TRUE(empty_list.empty());
EXPECT_TRUE(empty_list.codecs().empty());
- Codec video_codec = CreateVideoCodec({webrtc::SdpVideoFormat{"VP8"}});
+ Codec video_codec = CreateVideoCodec({SdpVideoFormat{"VP8"}});
CodecList one_codec = CodecList::CreateFromTrustedData({{video_codec}});
EXPECT_EQ(one_codec.size(), 1U);
EXPECT_EQ(one_codec.codecs()[0], video_codec);
}
TEST(CodecList, RejectIllegalConstructorArguments) {
- std::vector<Codec> apt_without_number{
- CreateVideoCodec({webrtc::SdpVideoFormat{
- "rtx", webrtc::CodecParameterMap{{"apt", "not-a-number"}}}})};
+ std::vector<Codec> apt_without_number{webrtc::CreateVideoCodec(
+ {SdpVideoFormat{"rtx", CodecParameterMap{{"apt", "not-a-number"}}}})};
apt_without_number[0].id = 96;
RTCErrorOr<CodecList> checked_codec_list =
CodecList::Create(apt_without_number);
@@ -55,9 +54,8 @@
// Checks that can't be enabled log things instead.
// Note: DCHECK is on in some release builds, so we can't use
// EXPECT_DEBUG_DEATH here.
- std::vector<Codec> apt_without_number{
- CreateVideoCodec({webrtc::SdpVideoFormat{
- "rtx", webrtc::CodecParameterMap{{"apt", "not-a-number"}}}})};
+ std::vector<Codec> apt_without_number{webrtc::CreateVideoCodec(
+ {SdpVideoFormat{"rtx", CodecParameterMap{{"apt", "not-a-number"}}}})};
apt_without_number[0].id = 96;
#if RTC_DCHECK_IS_ON
EXPECT_DEATH(
@@ -72,4 +70,4 @@
#endif
} // namespace
-} // namespace cricket
+} // namespace webrtc
diff --git a/media/base/codec_unittest.cc b/media/base/codec_unittest.cc
index cfe2552..1017f89 100644
--- a/media/base/codec_unittest.cc
+++ b/media/base/codec_unittest.cc
@@ -24,8 +24,9 @@
#include "modules/video_coding/codecs/h264/include/h264.h"
#include "test/gtest.h"
-using cricket::Codec;
-using cricket::FeedbackParam;
+namespace webrtc {
+namespace {
+
using cricket::kCodecParamAssociatedPayloadType;
using cricket::kCodecParamMaxBitrate;
using cricket::kCodecParamMinBitrate;
@@ -73,20 +74,20 @@
}
TEST(CodecTest, TestAudioCodecOperators) {
- Codec c0 = cricket::CreateAudioCodec(96, "A", 44100, 2);
- Codec c1 = cricket::CreateAudioCodec(95, "A", 44100, 2);
- Codec c2 = cricket::CreateAudioCodec(96, "x", 44100, 2);
- Codec c3 = cricket::CreateAudioCodec(96, "A", 48000, 2);
- Codec c4 = cricket::CreateAudioCodec(96, "A", 44100, 2);
+ Codec c0 = CreateAudioCodec(96, "A", 44100, 2);
+ Codec c1 = CreateAudioCodec(95, "A", 44100, 2);
+ Codec c2 = CreateAudioCodec(96, "x", 44100, 2);
+ Codec c3 = CreateAudioCodec(96, "A", 48000, 2);
+ Codec c4 = CreateAudioCodec(96, "A", 44100, 2);
c4.bitrate = 10000;
- Codec c5 = cricket::CreateAudioCodec(96, "A", 44100, 1);
+ Codec c5 = CreateAudioCodec(96, "A", 44100, 1);
EXPECT_NE(c0, c1);
EXPECT_NE(c0, c2);
EXPECT_NE(c0, c3);
EXPECT_NE(c0, c4);
EXPECT_NE(c0, c5);
- Codec c8 = cricket::CreateAudioCodec(0, "", 0, 0);
+ Codec c8 = CreateAudioCodec(0, "", 0, 0);
Codec c9 = c0;
EXPECT_EQ(c9, c0);
@@ -108,14 +109,14 @@
}
TEST(CodecTest, TestVideoCodecOperators) {
- Codec c0 = cricket::CreateVideoCodec(96, "V");
- Codec c1 = cricket::CreateVideoCodec(95, "V");
- Codec c2 = cricket::CreateVideoCodec(96, "x");
+ Codec c0 = CreateVideoCodec(96, "V");
+ Codec c1 = CreateVideoCodec(95, "V");
+ Codec c2 = CreateVideoCodec(96, "x");
EXPECT_TRUE(c0 != c1);
EXPECT_TRUE(c0 != c2);
- Codec c8 = cricket::CreateVideoCodec(0, "");
+ Codec c8 = CreateVideoCodec(0, "");
Codec c9 = c0;
EXPECT_TRUE(c9 == c0);
@@ -137,9 +138,9 @@
}
TEST(CodecTest, TestVideoCodecEqualsWithDifferentPacketization) {
- Codec c0 = cricket::CreateVideoCodec(100, cricket::kVp8CodecName);
- Codec c1 = cricket::CreateVideoCodec(100, cricket::kVp8CodecName);
- Codec c2 = cricket::CreateVideoCodec(100, cricket::kVp8CodecName);
+ Codec c0 = CreateVideoCodec(100, cricket::kVp8CodecName);
+ Codec c1 = CreateVideoCodec(100, cricket::kVp8CodecName);
+ Codec c2 = CreateVideoCodec(100, cricket::kVp8CodecName);
c2.packetization = "raw";
EXPECT_EQ(c0, c1);
@@ -149,7 +150,7 @@
}
TEST(CodecTest, TestSetParamGetParamAndRemoveParam) {
- Codec codec = cricket::CreateAudioCodec(0, "foo", 22222, 2);
+ Codec codec = CreateAudioCodec(0, "foo", 22222, 2);
codec.SetParam("a", "1");
codec.SetParam("b", "x");
@@ -190,11 +191,11 @@
TEST(CodecTest, TestGetCodecType) {
// Codec type comparison should be case insensitive on names.
- const Codec codec = cricket::CreateVideoCodec(96, "V");
- const Codec rtx_codec = cricket::CreateVideoCodec(96, "rTx");
- const Codec ulpfec_codec = cricket::CreateVideoCodec(96, "ulpFeC");
- const Codec flexfec_codec = cricket::CreateVideoCodec(96, "FlExFeC-03");
- const Codec red_codec = cricket::CreateVideoCodec(96, "ReD");
+ const Codec codec = CreateVideoCodec(96, "V");
+ const Codec rtx_codec = CreateVideoCodec(96, "rTx");
+ const Codec ulpfec_codec = CreateVideoCodec(96, "ulpFeC");
+ const Codec flexfec_codec = CreateVideoCodec(96, "FlExFeC-03");
+ const Codec red_codec = CreateVideoCodec(96, "ReD");
EXPECT_TRUE(codec.IsMediaCodec());
EXPECT_EQ(codec.GetResiliencyType(), Codec::ResiliencyType::kNone);
EXPECT_EQ(rtx_codec.GetResiliencyType(), Codec::ResiliencyType::kRtx);
@@ -204,7 +205,7 @@
}
TEST(CodecTest, TestCreateRtxCodec) {
- const Codec rtx_codec = cricket::CreateVideoRtxCodec(96, 120);
+ const Codec rtx_codec = CreateVideoRtxCodec(96, 120);
EXPECT_EQ(96, rtx_codec.id);
EXPECT_EQ(rtx_codec.GetResiliencyType(), Codec::ResiliencyType::kRtx);
int associated_payload_type;
@@ -214,7 +215,7 @@
}
TEST(CodecTest, TestValidateCodecFormat) {
- const Codec codec = cricket::CreateVideoCodec(96, "V");
+ const Codec codec = CreateVideoCodec(96, "V");
ASSERT_TRUE(codec.ValidateCodecFormat());
// Accept 0-127 as payload types.
@@ -255,7 +256,7 @@
}
TEST(CodecTest, TestToCodecParameters) {
- Codec v = cricket::CreateVideoCodec(96, "V");
+ Codec v = CreateVideoCodec(96, "V");
v.SetParam("p1", "v1");
webrtc::RtpCodecParameters codec_params_1 = v.ToCodecParameters();
EXPECT_EQ(96, codec_params_1.payload_type);
@@ -267,7 +268,7 @@
EXPECT_EQ("p1", codec_params_1.parameters.begin()->first);
EXPECT_EQ("v1", codec_params_1.parameters.begin()->second);
- Codec a = cricket::CreateAudioCodec(97, "A", 44100, 2);
+ Codec a = CreateAudioCodec(97, "A", 44100, 2);
a.SetParam("p1", "a1");
webrtc::RtpCodecParameters codec_params_2 = a.ToCodecParameters();
EXPECT_EQ(97, codec_params_2.payload_type);
@@ -289,8 +290,7 @@
std::vector<webrtc::SdpVideoFormat> supported_formats =
kExplicitlySupportedFormats;
- cricket::AddH264ConstrainedBaselineProfileToSupportedFormats(
- &supported_formats);
+ AddH264ConstrainedBaselineProfileToSupportedFormats(&supported_formats);
const webrtc::SdpVideoFormat kH264ConstrainedBasedlinePacketization1 =
webrtc::CreateH264Format(webrtc::H264Profile::kProfileConstrainedBaseline,
@@ -313,8 +313,7 @@
std::vector<webrtc::SdpVideoFormat> supported_formats =
kExplicitlySupportedFormats;
- cricket::AddH264ConstrainedBaselineProfileToSupportedFormats(
- &supported_formats);
+ AddH264ConstrainedBaselineProfileToSupportedFormats(&supported_formats);
EXPECT_EQ(supported_formats[0], kExplicitlySupportedFormats[0]);
EXPECT_EQ(supported_formats.size(), kExplicitlySupportedFormats.size());
@@ -333,8 +332,7 @@
std::vector<webrtc::SdpVideoFormat> supported_formats =
kExplicitlySupportedFormats;
- cricket::AddH264ConstrainedBaselineProfileToSupportedFormats(
- &supported_formats);
+ AddH264ConstrainedBaselineProfileToSupportedFormats(&supported_formats);
EXPECT_EQ(supported_formats[0], kExplicitlySupportedFormats[0]);
EXPECT_EQ(supported_formats[1], kExplicitlySupportedFormats[1]);
@@ -344,8 +342,11 @@
}
TEST(CodecTest, AbslStringify) {
- Codec codec = cricket::CreateAudioCodec(47, "custom-audio", 48000, 2);
+ Codec codec = CreateAudioCodec(47, "custom-audio", 48000, 2);
EXPECT_EQ(absl::StrCat(codec), "[47:audio/custom-audio/48000/2]");
codec.params["key"] = "value";
EXPECT_EQ(absl::StrCat(codec), "[47:audio/custom-audio/48000/2;key=value]");
}
+
+} // namespace
+} // namespace webrtc
diff --git a/media/base/fake_media_engine.cc b/media/base/fake_media_engine.cc
index 32a179c..e72a642 100644
--- a/media/base/fake_media_engine.cc
+++ b/media/base/fake_media_engine.cc
@@ -88,7 +88,8 @@
SetOptions(options);
}
FakeVoiceMediaReceiveChannel::~FakeVoiceMediaReceiveChannel() = default;
-const std::vector<Codec>& FakeVoiceMediaReceiveChannel::recv_codecs() const {
+const std::vector<webrtc::Codec>& FakeVoiceMediaReceiveChannel::recv_codecs()
+ const {
return recv_codecs_;
}
const std::vector<FakeVoiceMediaReceiveChannel::DtmfInfo>&
@@ -186,7 +187,7 @@
return std::vector<webrtc::RtpSource>();
}
bool FakeVoiceMediaReceiveChannel::SetRecvCodecs(
- const std::vector<Codec>& codecs) {
+ const std::vector<webrtc::Codec>& codecs) {
if (fail_set_recv_codecs()) {
// Fake the failure in SetRecvCodecs.
return false;
@@ -242,10 +243,11 @@
SetOptions(options);
}
FakeVoiceMediaSendChannel::~FakeVoiceMediaSendChannel() = default;
-const std::vector<Codec>& FakeVoiceMediaSendChannel::send_codecs() const {
+const std::vector<webrtc::Codec>& FakeVoiceMediaSendChannel::send_codecs()
+ const {
return send_codecs_;
}
-std::optional<Codec> FakeVoiceMediaSendChannel::GetSendCodec() const {
+std::optional<webrtc::Codec> FakeVoiceMediaSendChannel::GetSendCodec() const {
if (!send_codecs_.empty()) {
return send_codecs_.front();
}
@@ -293,7 +295,7 @@
return local_sinks_.find(ssrc) != local_sinks_.end();
}
bool FakeVoiceMediaSendChannel::CanInsertDtmf() {
- for (std::vector<Codec>::const_iterator it = send_codecs_.begin();
+ for (std::vector<webrtc::Codec>::const_iterator it = send_codecs_.begin();
it != send_codecs_.end(); ++it) {
// Find the DTMF telephone event "codec".
if (absl::EqualsIgnoreCase(it->name, "telephone-event")) {
@@ -318,7 +320,7 @@
return false;
}
bool FakeVoiceMediaSendChannel::SetSendCodecs(
- const std::vector<Codec>& codecs) {
+ const std::vector<webrtc::Codec>& codecs) {
if (fail_set_send_codecs()) {
// Fake the failure in SetSendCodecs.
return false;
@@ -369,10 +371,11 @@
SetOptions(options);
}
FakeVideoMediaSendChannel::~FakeVideoMediaSendChannel() = default;
-const std::vector<Codec>& FakeVideoMediaSendChannel::send_codecs() const {
+const std::vector<webrtc::Codec>& FakeVideoMediaSendChannel::send_codecs()
+ const {
return send_codecs_;
}
-const std::vector<Codec>& FakeVideoMediaSendChannel::codecs() const {
+const std::vector<webrtc::Codec>& FakeVideoMediaSendChannel::codecs() const {
return send_codecs();
}
const VideoOptions& FakeVideoMediaSendChannel::options() const {
@@ -389,7 +392,7 @@
SetSendRtpHeaderExtensions(params.extensions) &&
SetMaxSendBandwidth(params.max_bandwidth_bps));
}
-std::optional<Codec> FakeVideoMediaSendChannel::GetSendCodec() const {
+std::optional<webrtc::Codec> FakeVideoMediaSendChannel::GetSendCodec() const {
if (send_codecs_.empty()) {
return std::nullopt;
}
@@ -419,7 +422,7 @@
return false;
}
bool FakeVideoMediaSendChannel::SetSendCodecs(
- const std::vector<Codec>& codecs) {
+ const std::vector<webrtc::Codec>& codecs) {
if (fail_set_send_codecs()) {
// Fake the failure in SetSendCodecs.
return false;
@@ -450,7 +453,8 @@
SetOptions(options);
}
FakeVideoMediaReceiveChannel::~FakeVideoMediaReceiveChannel() = default;
-const std::vector<Codec>& FakeVideoMediaReceiveChannel::recv_codecs() const {
+const std::vector<webrtc::Codec>& FakeVideoMediaReceiveChannel::recv_codecs()
+ const {
return recv_codecs_;
}
bool FakeVideoMediaReceiveChannel::rendering() const {
@@ -528,7 +532,7 @@
return std::nullopt;
}
bool FakeVideoMediaReceiveChannel::SetRecvCodecs(
- const std::vector<Codec>& codecs) {
+ const std::vector<webrtc::Codec>& codecs) {
if (fail_set_recv_codecs()) {
// Fake the failure in SetRecvCodecs.
return false;
@@ -566,7 +570,7 @@
webrtc::make_ref_counted<FakeVoiceDecoderFactory>(this)) {
// Add a fake audio codec. Note that the name must not be "" as there are
// sanity checks against that.
- SetCodecs({cricket::CreateAudioCodec(101, "fake_audio_codec", 8000, 1)});
+ SetCodecs({webrtc::CreateAudioCodec(101, "fake_audio_codec", 8000, 1)});
}
void FakeVoiceEngine::Init() {}
rtc::scoped_refptr<webrtc::AudioState> FakeVoiceEngine::GetAudioState() const {
@@ -596,20 +600,20 @@
call->network_thread());
return ch;
}
-const std::vector<Codec>& FakeVoiceEngine::LegacySendCodecs() const {
+const std::vector<webrtc::Codec>& FakeVoiceEngine::LegacySendCodecs() const {
return send_codecs_;
}
-const std::vector<Codec>& FakeVoiceEngine::LegacyRecvCodecs() const {
+const std::vector<webrtc::Codec>& FakeVoiceEngine::LegacyRecvCodecs() const {
return recv_codecs_;
}
-void FakeVoiceEngine::SetCodecs(const std::vector<Codec>& codecs) {
+void FakeVoiceEngine::SetCodecs(const std::vector<webrtc::Codec>& codecs) {
send_codecs_ = codecs;
recv_codecs_ = codecs;
}
-void FakeVoiceEngine::SetRecvCodecs(const std::vector<Codec>& codecs) {
+void FakeVoiceEngine::SetRecvCodecs(const std::vector<webrtc::Codec>& codecs) {
recv_codecs_ = codecs;
}
-void FakeVoiceEngine::SetSendCodecs(const std::vector<Codec>& codecs) {
+void FakeVoiceEngine::SetSendCodecs(const std::vector<webrtc::Codec>& codecs) {
send_codecs_ = codecs;
}
int FakeVoiceEngine::GetInputLevel() {
@@ -638,8 +642,8 @@
FakeVideoEngine::FakeVideoEngine() : capture_(false) {
// Add a fake video codec. Note that the name must not be "" as there are
// sanity checks against that.
- send_codecs_.push_back(cricket::CreateVideoCodec(111, "fake_video_codec"));
- recv_codecs_.push_back(cricket::CreateVideoCodec(111, "fake_video_codec"));
+ send_codecs_.push_back(webrtc::CreateVideoCodec(111, "fake_video_codec"));
+ recv_codecs_.push_back(webrtc::CreateVideoCodec(111, "fake_video_codec"));
}
bool FakeVideoEngine::SetOptions(const VideoOptions& options) {
options_ = options;
@@ -669,19 +673,21 @@
call->network_thread());
return ch;
}
-std::vector<Codec> FakeVideoEngine::LegacySendCodecs(bool /* use_rtx */) const {
+std::vector<webrtc::Codec> FakeVideoEngine::LegacySendCodecs(
+ bool /* use_rtx */) const {
return send_codecs_;
}
-std::vector<Codec> FakeVideoEngine::LegacyRecvCodecs(bool /* use_rtx */) const {
+std::vector<webrtc::Codec> FakeVideoEngine::LegacyRecvCodecs(
+ bool /* use_rtx */) const {
return recv_codecs_;
}
-void FakeVideoEngine::SetSendCodecs(const std::vector<Codec>& codecs) {
+void FakeVideoEngine::SetSendCodecs(const std::vector<webrtc::Codec>& codecs) {
send_codecs_ = codecs;
}
-void FakeVideoEngine::SetRecvCodecs(const std::vector<Codec>& codecs) {
+void FakeVideoEngine::SetRecvCodecs(const std::vector<webrtc::Codec>& codecs) {
recv_codecs_ = codecs;
}
@@ -704,23 +710,27 @@
voice_(static_cast<FakeVoiceEngine*>(&voice())),
video_(static_cast<FakeVideoEngine*>(&video())) {}
FakeMediaEngine::~FakeMediaEngine() {}
-void FakeMediaEngine::SetAudioCodecs(const std::vector<Codec>& codecs) {
+void FakeMediaEngine::SetAudioCodecs(const std::vector<webrtc::Codec>& codecs) {
voice_->SetCodecs(codecs);
}
-void FakeMediaEngine::SetAudioRecvCodecs(const std::vector<Codec>& codecs) {
+void FakeMediaEngine::SetAudioRecvCodecs(
+ const std::vector<webrtc::Codec>& codecs) {
voice_->SetRecvCodecs(codecs);
}
-void FakeMediaEngine::SetAudioSendCodecs(const std::vector<Codec>& codecs) {
+void FakeMediaEngine::SetAudioSendCodecs(
+ const std::vector<webrtc::Codec>& codecs) {
voice_->SetSendCodecs(codecs);
}
-void FakeMediaEngine::SetVideoCodecs(const std::vector<Codec>& codecs) {
+void FakeMediaEngine::SetVideoCodecs(const std::vector<webrtc::Codec>& codecs) {
video_->SetSendCodecs(codecs);
video_->SetRecvCodecs(codecs);
}
-void FakeMediaEngine::SetVideoRecvCodecs(const std::vector<Codec>& codecs) {
+void FakeMediaEngine::SetVideoRecvCodecs(
+ const std::vector<webrtc::Codec>& codecs) {
video_->SetRecvCodecs(codecs);
}
-void FakeMediaEngine::SetVideoSendCodecs(const std::vector<Codec>& codecs) {
+void FakeMediaEngine::SetVideoSendCodecs(
+ const std::vector<webrtc::Codec>& codecs) {
video_->SetSendCodecs(codecs);
}
diff --git a/media/base/fake_media_engine.h b/media/base/fake_media_engine.h
index f8bdcc7..a202186 100644
--- a/media/base/fake_media_engine.h
+++ b/media/base/fake_media_engine.h
@@ -495,7 +495,7 @@
virtual ~FakeVoiceMediaReceiveChannel();
// Test methods
- const std::vector<Codec>& recv_codecs() const;
+ const std::vector<webrtc::Codec>& recv_codecs() const;
const std::vector<DtmfInfo>& dtmf_info_queue() const;
const AudioOptions& options() const;
int max_bps() const;
@@ -560,11 +560,11 @@
AudioSource* source_;
};
- bool SetRecvCodecs(const std::vector<Codec>& codecs);
+ bool SetRecvCodecs(const std::vector<webrtc::Codec>& codecs);
bool SetMaxSendBandwidth(int bps);
bool SetOptions(const AudioOptions& options);
- std::vector<Codec> recv_codecs_;
+ std::vector<webrtc::Codec> recv_codecs_;
std::map<uint32_t, double> output_scalings_;
std::map<uint32_t, int> output_delays_;
std::vector<DtmfInfo> dtmf_info_queue_;
@@ -588,7 +588,7 @@
webrtc::TaskQueueBase* network_thread);
~FakeVoiceMediaSendChannel() override;
- const std::vector<Codec>& send_codecs() const;
+ const std::vector<webrtc::Codec>& send_codecs() const;
const std::vector<DtmfInfo>& dtmf_info_queue() const;
const AudioOptions& options() const;
int max_bps() const;
@@ -621,7 +621,7 @@
bool SendCodecHasNack() const override { return false; }
void SetSendCodecChangedCallback(
absl::AnyInvocable<void()> /* callback */) override {}
- std::optional<Codec> GetSendCodec() const override;
+ std::optional<webrtc::Codec> GetSendCodec() const override;
bool GetStats(VoiceMediaSendInfo* stats) override;
@@ -644,12 +644,12 @@
AudioSource* source_;
};
- bool SetSendCodecs(const std::vector<Codec>& codecs);
+ bool SetSendCodecs(const std::vector<webrtc::Codec>& codecs);
bool SetMaxSendBandwidth(int bps);
bool SetOptions(const AudioOptions& options);
bool SetLocalSource(uint32_t ssrc, AudioSource* source);
- std::vector<Codec> send_codecs_;
+ std::vector<webrtc::Codec> send_codecs_;
std::map<uint32_t, double> output_scalings_;
std::map<uint32_t, int> output_delays_;
std::vector<DtmfInfo> dtmf_info_queue_;
@@ -682,8 +682,8 @@
return webrtc::MediaType::VIDEO;
}
- const std::vector<Codec>& recv_codecs() const;
- const std::vector<Codec>& send_codecs() const;
+ const std::vector<webrtc::Codec>& recv_codecs() const;
+ const std::vector<webrtc::Codec>& send_codecs() const;
bool rendering() const;
const VideoOptions& options() const;
const std::map<uint32_t, webrtc::VideoSinkInterface<webrtc::VideoFrame>*>&
@@ -727,12 +727,12 @@
}
private:
- bool SetRecvCodecs(const std::vector<Codec>& codecs);
- bool SetSendCodecs(const std::vector<Codec>& codecs);
+ bool SetRecvCodecs(const std::vector<webrtc::Codec>& codecs);
+ bool SetSendCodecs(const std::vector<webrtc::Codec>& codecs);
bool SetOptions(const VideoOptions& options);
bool SetMaxSendBandwidth(int bps);
- std::vector<Codec> recv_codecs_;
+ std::vector<webrtc::Codec> recv_codecs_;
std::map<uint32_t, webrtc::VideoSinkInterface<webrtc::VideoFrame>*> sinks_;
std::map<uint32_t, webrtc::VideoSourceInterface<webrtc::VideoFrame>*>
sources_;
@@ -757,15 +757,15 @@
return webrtc::MediaType::VIDEO;
}
- const std::vector<Codec>& send_codecs() const;
- const std::vector<Codec>& codecs() const;
+ const std::vector<webrtc::Codec>& send_codecs() const;
+ const std::vector<webrtc::Codec>& codecs() const;
const VideoOptions& options() const;
const std::map<uint32_t, webrtc::VideoSinkInterface<webrtc::VideoFrame>*>&
sinks() const;
int max_bps() const;
bool SetSenderParameters(const VideoSenderParameters& params) override;
- std::optional<Codec> GetSendCodec() const override;
+ std::optional<webrtc::Codec> GetSendCodec() const override;
bool SetSend(bool send) override;
bool SetVideoSend(
@@ -794,11 +794,11 @@
bool GetStats(VideoMediaSendInfo* info) override;
private:
- bool SetSendCodecs(const std::vector<Codec>& codecs);
+ bool SetSendCodecs(const std::vector<webrtc::Codec>& codecs);
bool SetOptions(const VideoOptions& options);
bool SetMaxSendBandwidth(int bps);
- std::vector<Codec> send_codecs_;
+ std::vector<webrtc::Codec> send_codecs_;
std::map<uint32_t, webrtc::VideoSourceInterface<webrtc::VideoFrame>*>
sources_;
VideoOptions options_;
@@ -827,17 +827,17 @@
// TODO(ossu): For proper testing, These should either individually settable
// or the voice engine should reference mockable factories.
// TODO: https://issues.webrtc.org/360058654 - stop faking codecs here.
- const std::vector<Codec>& LegacySendCodecs() const override;
- const std::vector<Codec>& LegacyRecvCodecs() const override;
+ const std::vector<webrtc::Codec>& LegacySendCodecs() const override;
+ const std::vector<webrtc::Codec>& LegacyRecvCodecs() const override;
webrtc::AudioEncoderFactory* encoder_factory() const override {
return encoder_factory_.get();
}
webrtc::AudioDecoderFactory* decoder_factory() const override {
return decoder_factory_.get();
}
- void SetCodecs(const std::vector<Codec>& codecs);
- void SetRecvCodecs(const std::vector<Codec>& codecs);
- void SetSendCodecs(const std::vector<Codec>& codecs);
+ void SetCodecs(const std::vector<webrtc::Codec>& codecs);
+ void SetRecvCodecs(const std::vector<webrtc::Codec>& codecs);
+ void SetSendCodecs(const std::vector<webrtc::Codec>& codecs);
int GetInputLevel();
bool StartAecDump(webrtc::FileWrapper file, int64_t max_size_bytes) override;
void StopAecDump() override;
@@ -905,8 +905,8 @@
FakeVoiceEngine* owner_;
};
- std::vector<Codec> recv_codecs_;
- std::vector<Codec> send_codecs_;
+ std::vector<webrtc::Codec> recv_codecs_;
+ std::vector<webrtc::Codec> send_codecs_;
webrtc::scoped_refptr<FakeVoiceEncoderFactory> encoder_factory_;
webrtc::scoped_refptr<FakeVoiceDecoderFactory> decoder_factory_;
std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions_;
@@ -933,16 +933,16 @@
FakeVideoMediaSendChannel* GetSendChannel(size_t index);
FakeVideoMediaReceiveChannel* GetReceiveChannel(size_t index);
- std::vector<Codec> LegacySendCodecs() const override {
+ std::vector<webrtc::Codec> LegacySendCodecs() const override {
return LegacySendCodecs(true);
}
- std::vector<Codec> LegacyRecvCodecs() const override {
+ std::vector<webrtc::Codec> LegacyRecvCodecs() const override {
return LegacyRecvCodecs(true);
}
- std::vector<Codec> LegacySendCodecs(bool include_rtx) const override;
- std::vector<Codec> LegacyRecvCodecs(bool include_rtx) const override;
- void SetSendCodecs(const std::vector<Codec>& codecs);
- void SetRecvCodecs(const std::vector<Codec>& codecs);
+ std::vector<webrtc::Codec> LegacySendCodecs(bool include_rtx) const override;
+ std::vector<webrtc::Codec> LegacyRecvCodecs(bool include_rtx) const override;
+ void SetSendCodecs(const std::vector<webrtc::Codec>& codecs);
+ void SetRecvCodecs(const std::vector<webrtc::Codec>& codecs);
bool SetCapture(bool capture);
std::vector<webrtc::RtpHeaderExtensionCapability> GetRtpHeaderExtensions()
const override;
@@ -950,8 +950,8 @@
std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions);
private:
- std::vector<Codec> send_codecs_;
- std::vector<Codec> recv_codecs_;
+ std::vector<webrtc::Codec> send_codecs_;
+ std::vector<webrtc::Codec> recv_codecs_;
bool capture_;
VideoOptions options_;
std::vector<webrtc::RtpHeaderExtensionCapability> header_extensions_;
@@ -965,12 +965,12 @@
~FakeMediaEngine() override;
- void SetAudioCodecs(const std::vector<Codec>& codecs);
- void SetAudioRecvCodecs(const std::vector<Codec>& codecs);
- void SetAudioSendCodecs(const std::vector<Codec>& codecs);
- void SetVideoCodecs(const std::vector<Codec>& codecs);
- void SetVideoRecvCodecs(const std::vector<Codec>& codecs);
- void SetVideoSendCodecs(const std::vector<Codec>& codecs);
+ void SetAudioCodecs(const std::vector<webrtc::Codec>& codecs);
+ void SetAudioRecvCodecs(const std::vector<webrtc::Codec>& codecs);
+ void SetAudioSendCodecs(const std::vector<webrtc::Codec>& codecs);
+ void SetVideoCodecs(const std::vector<webrtc::Codec>& codecs);
+ void SetVideoRecvCodecs(const std::vector<webrtc::Codec>& codecs);
+ void SetVideoSendCodecs(const std::vector<webrtc::Codec>& codecs);
FakeVoiceEngine* fake_voice_engine() { return voice_; }
FakeVideoEngine* fake_video_engine() { return video_; }
diff --git a/media/base/media_channel.h b/media/base/media_channel.h
index eef3c4c..3de664d 100644
--- a/media/base/media_channel.h
+++ b/media/base/media_channel.h
@@ -190,7 +190,7 @@
virtual webrtc::MediaType media_type() const = 0;
// Gets the currently set codecs/payload types to be used for outgoing media.
- virtual std::optional<Codec> GetSendCodec() const = 0;
+ virtual std::optional<webrtc::Codec> GetSendCodec() const = 0;
// Creates a new outgoing media stream with SSRCs and CNAME as described
// by sp.
@@ -836,7 +836,7 @@
// It is also used as a key to map the channnel to its transport.
std::string mid;
- std::vector<Codec> codecs;
+ std::vector<webrtc::Codec> codecs;
std::vector<webrtc::RtpExtension> extensions;
// For a send stream this is true if we've negotiated a send direction,
// for a receive stream this is true if we've negotiated a receive direction.
diff --git a/media/base/media_engine.cc b/media/base/media_engine.cc
index 3735c50..811b008 100644
--- a/media/base/media_engine.cc
+++ b/media/base/media_engine.cc
@@ -35,7 +35,7 @@
namespace cricket {
namespace {
-bool SupportsMode(const cricket::Codec& codec,
+bool SupportsMode(const webrtc::Codec& codec,
std::optional<std::string> scalability_mode) {
if (!scalability_mode.has_value()) {
return true;
@@ -92,8 +92,8 @@
webrtc::RTCError CheckScalabilityModeValues(
const webrtc::RtpParameters& rtp_parameters,
- rtc::ArrayView<cricket::Codec> send_codecs,
- std::optional<cricket::Codec> send_codec) {
+ rtc::ArrayView<webrtc::Codec> send_codecs,
+ std::optional<webrtc::Codec> send_codec) {
using webrtc::RTCErrorType;
if (send_codecs.empty()) {
@@ -105,7 +105,7 @@
for (size_t i = 0; i < rtp_parameters.encodings.size(); ++i) {
if (rtp_parameters.encodings[i].codec) {
bool codecFound = false;
- for (const cricket::Codec& codec : send_codecs) {
+ for (const webrtc::Codec& codec : send_codecs) {
if (IsSameRtpCodecIgnoringLevel(codec,
*rtp_parameters.encodings[i].codec) &&
SupportsMode(codec, rtp_parameters.encodings[i].scalability_mode)) {
@@ -124,7 +124,7 @@
if (rtp_parameters.encodings[i].scalability_mode) {
if (!send_codec) {
bool scalabilityModeFound = false;
- for (const cricket::Codec& codec : send_codecs) {
+ for (const webrtc::Codec& codec : send_codecs) {
for (const auto& scalability_mode : codec.scalability_modes) {
if (ScalabilityModeToString(scalability_mode) ==
*rtp_parameters.encodings[i].scalability_mode) {
@@ -166,8 +166,8 @@
webrtc::RTCError CheckRtpParametersValues(
const webrtc::RtpParameters& rtp_parameters,
- rtc::ArrayView<cricket::Codec> send_codecs,
- std::optional<cricket::Codec> send_codec,
+ rtc::ArrayView<webrtc::Codec> send_codecs,
+ std::optional<webrtc::Codec> send_codec,
const webrtc::FieldTrialsView& field_trials) {
using webrtc::RTCErrorType;
@@ -254,8 +254,8 @@
webrtc::RTCError CheckRtpParametersInvalidModificationAndValues(
const webrtc::RtpParameters& old_rtp_parameters,
const webrtc::RtpParameters& rtp_parameters,
- rtc::ArrayView<cricket::Codec> send_codecs,
- std::optional<cricket::Codec> send_codec,
+ rtc::ArrayView<webrtc::Codec> send_codecs,
+ std::optional<webrtc::Codec> send_codec,
const webrtc::FieldTrialsView& field_trials) {
using webrtc::RTCErrorType;
if (rtp_parameters.encodings.size() != old_rtp_parameters.encodings.size()) {
diff --git a/media/base/media_engine.h b/media/base/media_engine.h
index 6d7f086..7dc02c1 100644
--- a/media/base/media_engine.h
+++ b/media/base/media_engine.h
@@ -46,15 +46,15 @@
// least one video codec of the list. If the list is empty, no check is done.
webrtc::RTCError CheckScalabilityModeValues(
const webrtc::RtpParameters& new_parameters,
- rtc::ArrayView<cricket::Codec> send_codecs,
- std::optional<cricket::Codec> send_codec);
+ rtc::ArrayView<webrtc::Codec> send_codecs,
+ std::optional<webrtc::Codec> send_codec);
// Checks the parameters have valid and supported values, and checks parameters
// with CheckScalabilityModeValues().
webrtc::RTCError CheckRtpParametersValues(
const webrtc::RtpParameters& new_parameters,
- rtc::ArrayView<cricket::Codec> send_codecs,
- std::optional<cricket::Codec> send_codec,
+ rtc::ArrayView<webrtc::Codec> send_codecs,
+ std::optional<webrtc::Codec> send_codec,
const webrtc::FieldTrialsView& field_trials);
// Checks that the immutable values have not changed in new_parameters and
@@ -62,8 +62,8 @@
webrtc::RTCError CheckRtpParametersInvalidModificationAndValues(
const webrtc::RtpParameters& old_parameters,
const webrtc::RtpParameters& new_parameters,
- rtc::ArrayView<cricket::Codec> send_codecs,
- std::optional<cricket::Codec> send_codec,
+ rtc::ArrayView<webrtc::Codec> send_codecs,
+ std::optional<webrtc::Codec> send_codec,
const webrtc::FieldTrialsView& field_trials);
// Checks that the immutable values have not changed in new_parameters and
@@ -122,7 +122,7 @@
// Legacy: Retrieve list of supported codecs.
// + protection codecs, and assigns PT numbers that may have to be
// reassigned.
- // This function is being moved to cricket::CodecVendor
+ // This function is being moved to CodecVendor
// TODO: https://issues.webrtc.org/360058654 - remove when all users updated.
[[deprecated]] inline const std::vector<Codec>& send_codecs() const {
return LegacySendCodecs();
@@ -130,8 +130,8 @@
[[deprecated]] inline const std::vector<Codec>& recv_codecs() const {
return LegacyRecvCodecs();
}
- virtual const std::vector<Codec>& LegacySendCodecs() const = 0;
- virtual const std::vector<Codec>& LegacyRecvCodecs() const = 0;
+ virtual const std::vector<webrtc::Codec>& LegacySendCodecs() const = 0;
+ virtual const std::vector<webrtc::Codec>& LegacyRecvCodecs() const = 0;
virtual webrtc::AudioEncoderFactory* encoder_factory() const = 0;
virtual webrtc::AudioDecoderFactory* decoder_factory() const = 0;
@@ -174,7 +174,7 @@
// Legacy: Retrieve list of supported codecs.
// + protection codecs, and assigns PT numbers that may have to be
// reassigned.
- // This functionality is being moved to the cricket::CodecVendor class.
+ // This functionality is being moved to the CodecVendor class.
// TODO: https://issues.webrtc.org/360058654 - deprecate and remove.
[[deprecated]] inline std::vector<Codec> send_codecs() const {
return LegacySendCodecs();
@@ -182,14 +182,16 @@
[[deprecated]] inline std::vector<Codec> recv_codecs() const {
return LegacyRecvCodecs();
}
- virtual std::vector<Codec> LegacySendCodecs() const = 0;
- virtual std::vector<Codec> LegacyRecvCodecs() const = 0;
+ virtual std::vector<webrtc::Codec> LegacySendCodecs() const = 0;
+ virtual std::vector<webrtc::Codec> LegacyRecvCodecs() const = 0;
// As above, but if include_rtx is false, don't include RTX codecs.
[[deprecated]] inline std::vector<Codec> send_codecs(bool include_rtx) const {
return LegacySendCodecs(include_rtx);
}
- virtual std::vector<Codec> LegacySendCodecs(bool include_rtx) const = 0;
- virtual std::vector<Codec> LegacyRecvCodecs(bool include_rtx) const = 0;
+ virtual std::vector<webrtc::Codec> LegacySendCodecs(
+ bool include_rtx) const = 0;
+ virtual std::vector<webrtc::Codec> LegacyRecvCodecs(
+ bool include_rtx) const = 0;
[[deprecated]] inline std::vector<Codec> recv_codecs(bool include_rtx) const {
return LegacyRecvCodecs(include_rtx);
}
diff --git a/media/base/media_engine_unittest.cc b/media/base/media_engine_unittest.cc
index c8bca11..9c4d5a5 100644
--- a/media/base/media_engine_unittest.cc
+++ b/media/base/media_engine_unittest.cc
@@ -81,8 +81,14 @@
GetAudioState,
(),
(const, override));
- MOCK_METHOD(std::vector<Codec>&, LegacySendCodecs, (), (const, override));
- MOCK_METHOD(std::vector<Codec>&, LegacyRecvCodecs, (), (const, override));
+ MOCK_METHOD(std::vector<webrtc::Codec>&,
+ LegacySendCodecs,
+ (),
+ (const, override));
+ MOCK_METHOD(std::vector<webrtc::Codec>&,
+ LegacyRecvCodecs,
+ (),
+ (const, override));
MOCK_METHOD(bool,
StartAecDump,
(webrtc::FileWrapper file, int64_t max_size_bytes),
diff --git a/media/base/rid_description.h b/media/base/rid_description.h
index 78e129f..ab0965c 100644
--- a/media/base/rid_description.h
+++ b/media/base/rid_description.h
@@ -79,7 +79,7 @@
// When the RID is serialized/deserialized, these codecs are mapped to/from
// the payload types listed in the media section, ensuring PT consistency in
// the SDP even when `codecs[i].id` cannot be trusted.
- std::vector<Codec> codecs;
+ std::vector<webrtc::Codec> codecs;
// Contains key-value pairs for restrictions.
// The keys are not validated against a known set.
diff --git a/media/engine/fake_webrtc_video_engine.cc b/media/engine/fake_webrtc_video_engine.cc
index e5abd4e..1f96969 100644
--- a/media/engine/fake_webrtc_video_engine.cc
+++ b/media/engine/fake_webrtc_video_engine.cc
@@ -143,8 +143,8 @@
void FakeWebRtcVideoDecoderFactory::AddSupportedVideoCodecType(
const std::string& name) {
- // This is to match the default H264 params of cricket::Codec.
- cricket::Codec video_codec = cricket::CreateVideoCodec(name);
+ // This is to match the default H264 params of Codec.
+ Codec video_codec = CreateVideoCodec(name);
supported_codec_formats_.push_back(
SdpVideoFormat(video_codec.name, video_codec.params));
}
@@ -309,8 +309,8 @@
void FakeWebRtcVideoEncoderFactory::AddSupportedVideoCodecType(
const std::string& name,
const std::vector<ScalabilityMode>& scalability_modes) {
- // This is to match the default H264 params of cricket::Codec.
- cricket::Codec video_codec = cricket::CreateVideoCodec(name);
+ // This is to match the default H264 params of Codec.
+ Codec video_codec = CreateVideoCodec(name);
formats_.push_back(
SdpVideoFormat(video_codec.name, video_codec.params,
{scalability_modes.begin(), scalability_modes.end()}));
diff --git a/media/engine/webrtc_media_engine.cc b/media/engine/webrtc_media_engine.cc
index 6eebeeb..531c4a7 100644
--- a/media/engine/webrtc_media_engine.cc
+++ b/media/engine/webrtc_media_engine.cc
@@ -164,7 +164,8 @@
return result;
}
-webrtc::BitrateConstraints GetBitrateConfigForCodec(const Codec& codec) {
+webrtc::BitrateConstraints GetBitrateConfigForCodec(
+ const webrtc::Codec& codec) {
webrtc::BitrateConstraints config;
int bitrate_kbps = 0;
if (codec.GetParam(kCodecParamMinBitrate, &bitrate_kbps) &&
diff --git a/media/engine/webrtc_media_engine.h b/media/engine/webrtc_media_engine.h
index 5bd5a8b..2b9d398 100644
--- a/media/engine/webrtc_media_engine.h
+++ b/media/engine/webrtc_media_engine.h
@@ -38,7 +38,7 @@
bool filter_redundant_extensions,
const webrtc::FieldTrialsView& trials);
-webrtc::BitrateConstraints GetBitrateConfigForCodec(const Codec& codec);
+webrtc::BitrateConstraints GetBitrateConfigForCodec(const webrtc::Codec& codec);
} // namespace cricket
diff --git a/media/engine/webrtc_video_engine.cc b/media/engine/webrtc_video_engine.cc
index a6070b7..3439a61 100644
--- a/media/engine/webrtc_video_engine.cc
+++ b/media/engine/webrtc_video_engine.cc
@@ -141,23 +141,28 @@
return absl::StartsWith(trials.Lookup(name), "Disabled");
}
-void AddDefaultFeedbackParams(Codec* codec,
+void AddDefaultFeedbackParams(webrtc::Codec* codec,
const webrtc::FieldTrialsView& trials) {
// Don't add any feedback params for RED and ULPFEC.
if (codec->name == kRedCodecName || codec->name == kUlpfecCodecName)
return;
- codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamRemb, kParamValueEmpty));
codec->AddFeedbackParam(
- FeedbackParam(kRtcpFbParamTransportCc, kParamValueEmpty));
+ webrtc::FeedbackParam(kRtcpFbParamRemb, kParamValueEmpty));
+ codec->AddFeedbackParam(
+ webrtc::FeedbackParam(kRtcpFbParamTransportCc, kParamValueEmpty));
// Don't add any more feedback params for FLEXFEC.
if (codec->name == kFlexfecCodecName)
return;
- codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamCcm, kRtcpFbCcmParamFir));
- codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamNack, kParamValueEmpty));
- codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamNack, kRtcpFbNackParamPli));
+ codec->AddFeedbackParam(
+ webrtc::FeedbackParam(kRtcpFbParamCcm, kRtcpFbCcmParamFir));
+ codec->AddFeedbackParam(
+ webrtc::FeedbackParam(kRtcpFbParamNack, kParamValueEmpty));
+ codec->AddFeedbackParam(
+ webrtc::FeedbackParam(kRtcpFbParamNack, kRtcpFbNackParamPli));
if (codec->name == kVp8CodecName &&
IsEnabled(trials, "WebRTC-RtcpLossNotification")) {
- codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamLntf, kParamValueEmpty));
+ codec->AddFeedbackParam(
+ webrtc::FeedbackParam(kRtcpFbParamLntf, kParamValueEmpty));
}
}
@@ -178,7 +183,8 @@
std::vector<webrtc::SdpVideoFormat> supported_formats =
factory->GetSupportedFormats();
if (is_decoder_factory) {
- AddH264ConstrainedBaselineProfileToSupportedFormats(&supported_formats);
+ webrtc::AddH264ConstrainedBaselineProfileToSupportedFormats(
+ &supported_formats);
}
if (supported_formats.empty())
@@ -203,11 +209,11 @@
// This function will assign dynamic payload types (in the range [96, 127]
// and then [35, 63]) to the input codecs, and also add ULPFEC, RED, FlexFEC,
// It will also add default feedback params to the codecs.
-webrtc::RTCErrorOr<Codec> AssignPayloadType(
+webrtc::RTCErrorOr<webrtc::Codec> AssignPayloadType(
const webrtc::SdpVideoFormat& format,
webrtc::PayloadTypePicker& pt_mapper,
const webrtc::FieldTrialsView& trials) {
- Codec codec = cricket::CreateVideoCodec(format);
+ webrtc::Codec codec = webrtc::CreateVideoCodec(format);
webrtc::RTCErrorOr<webrtc::PayloadType> result =
pt_mapper.SuggestMapping(codec, /* excluder= */ nullptr);
if (!result.ok()) {
@@ -220,10 +226,10 @@
// This function will add a associated RTX codec for a recognized primary codecs
// (VP8, VP9, AV1, H264, and RED).
-webrtc::RTCErrorOr<Codec> AddRtx(const Codec& primary_codec,
- webrtc::PayloadTypePicker& pt_mapper) {
- Codec rtx_codec =
- cricket::CreateVideoRtxCodec(Codec::kIdNotSet, primary_codec.id);
+webrtc::RTCErrorOr<webrtc::Codec> AddRtx(const webrtc::Codec& primary_codec,
+ webrtc::PayloadTypePicker& pt_mapper) {
+ webrtc::Codec rtx_codec =
+ webrtc::CreateVideoRtxCodec(webrtc::Codec::kIdNotSet, primary_codec.id);
webrtc::RTCErrorOr<webrtc::PayloadType> result =
pt_mapper.SuggestMapping(rtx_codec, /* excluder= */ nullptr);
if (!result.ok()) {
@@ -236,7 +242,7 @@
// TODO(kron): Perhaps it is better to move the implicit knowledge to the place
// where codecs are negotiated.
template <class T>
-std::vector<Codec> GetPayloadTypesAndDefaultCodecs(
+std::vector<webrtc::Codec> GetPayloadTypesAndDefaultCodecs(
const T* factory,
bool is_decoder_factory,
bool include_rtx,
@@ -246,9 +252,9 @@
webrtc::PayloadTypePicker pt_mapper;
std::unordered_set<int> used_payload_types;
- std::vector<Codec> output_codecs;
+ std::vector<webrtc::Codec> output_codecs;
for (const auto& supported_format : supported_formats) {
- webrtc::RTCErrorOr<Codec> result =
+ webrtc::RTCErrorOr<webrtc::Codec> result =
AssignPayloadType(supported_format, pt_mapper, trials);
if (!result.ok()) {
// TODO: https://issues.webrtc.org/360058654 - stop assigning PTs here.
@@ -264,15 +270,16 @@
}
output_codecs.push_back(result.value());
if (include_rtx) {
- Codec::ResiliencyType resiliency_type =
+ webrtc::Codec::ResiliencyType resiliency_type =
result.value().GetResiliencyType();
// FEC codecs do not use retransmission.
- if (resiliency_type == Codec::ResiliencyType::kFlexfec ||
- resiliency_type == Codec::ResiliencyType::kUlpfec) {
+ if (resiliency_type == webrtc::Codec::ResiliencyType::kFlexfec ||
+ resiliency_type == webrtc::Codec::ResiliencyType::kUlpfec) {
continue;
}
- webrtc::RTCErrorOr<Codec> rtx_result = AddRtx(result.value(), pt_mapper);
+ webrtc::RTCErrorOr<webrtc::Codec> rtx_result =
+ AddRtx(result.value(), pt_mapper);
if (!rtx_result.ok()) {
// TODO: https://issues.webrtc.org/360058654 - stop assigning PTs here.
// TODO: https://issues.webrtc.org/360058654 - Handle running out of
@@ -285,7 +292,8 @@
return output_codecs;
}
-static std::string CodecVectorToString(const std::vector<Codec>& codecs) {
+static std::string CodecVectorToString(
+ const std::vector<webrtc::Codec>& codecs) {
rtc::StringBuilder out;
out << "{";
for (size_t i = 0; i < codecs.size(); ++i) {
@@ -298,7 +306,7 @@
return out.Release();
}
-static bool ValidateCodecFormats(const std::vector<Codec>& codecs) {
+static bool ValidateCodecFormats(const std::vector<webrtc::Codec>& codecs) {
bool has_video = false;
for (size_t i = 0; i < codecs.size(); ++i) {
if (!codecs[i].ValidateCodecFormat()) {
@@ -512,7 +520,7 @@
}
bool IsScalabilityModeSupportedByCodec(
- const Codec& codec,
+ const webrtc::Codec& codec,
const std::string& scalability_mode,
const webrtc::VideoSendStream::Config& config) {
return config.encoder_settings.encoder_factory
@@ -524,7 +532,7 @@
// Fallback to default value if the scalability mode is unset or unsupported by
// the codec.
void FallbackToDefaultScalabilityModeIfNotSupported(
- const Codec& codec,
+ const webrtc::Codec& codec,
const webrtc::VideoSendStream::Config& config,
std::vector<webrtc::RtpEncodingParameters>& encodings) {
if (!absl::c_any_of(encodings,
@@ -568,22 +576,22 @@
// VP8, VP9, H264 while VideoCodecs correspond also to "virtual" codecs like
// RTX, ULPFEC, FLEXFEC.
webrtc::RTCErrorOr<std::vector<VideoCodecSettings>> MapCodecs(
- const std::vector<Codec>& codecs) {
+ const std::vector<webrtc::Codec>& codecs) {
std::vector<VideoCodecSettings> video_codecs;
if (codecs.empty()) {
return video_codecs;
}
- std::map<int, Codec::ResiliencyType> payload_codec_type;
+ std::map<int, webrtc::Codec::ResiliencyType> payload_codec_type;
// `rtx_mapping` maps video payload type to rtx payload type.
std::map<int, int> rtx_mapping;
std::map<int, int> rtx_time_mapping;
- std::map<int, Codec> defined_codecs;
+ std::map<int, webrtc::Codec> defined_codecs;
webrtc::UlpfecConfig ulpfec_config;
std::optional<int> flexfec_payload_type;
- for (const Codec& in_codec : codecs) {
+ for (const webrtc::Codec& in_codec : codecs) {
const int payload_type = in_codec.id;
if (payload_codec_type.find(payload_type) != payload_codec_type.end()) {
@@ -603,7 +611,7 @@
payload_codec_type[payload_type] = in_codec.GetResiliencyType();
switch (in_codec.GetResiliencyType()) {
- case Codec::ResiliencyType::kRed: {
+ case webrtc::Codec::ResiliencyType::kRed: {
if (ulpfec_config.red_payload_type != -1) {
RTC_LOG(LS_ERROR)
<< "Duplicate RED codec: ignoring PT=" << payload_type
@@ -615,7 +623,7 @@
break;
}
- case Codec::ResiliencyType::kUlpfec: {
+ case webrtc::Codec::ResiliencyType::kUlpfec: {
if (ulpfec_config.ulpfec_payload_type != -1) {
RTC_LOG(LS_ERROR)
<< "Duplicate ULPFEC codec: ignoring PT=" << payload_type
@@ -627,7 +635,7 @@
break;
}
- case Codec::ResiliencyType::kFlexfec: {
+ case webrtc::Codec::ResiliencyType::kFlexfec: {
if (flexfec_payload_type) {
RTC_LOG(LS_ERROR)
<< "Duplicate FLEXFEC codec: ignoring PT=" << payload_type
@@ -639,7 +647,7 @@
break;
}
- case Codec::ResiliencyType::kRtx: {
+ case webrtc::Codec::ResiliencyType::kRtx: {
int associated_payload_type;
if (!in_codec.GetParam(kCodecParamAssociatedPayloadType,
&associated_payload_type) ||
@@ -658,7 +666,7 @@
break;
}
- case Codec::ResiliencyType::kNone: {
+ case webrtc::Codec::ResiliencyType::kNone: {
video_codecs.emplace_back(in_codec);
break;
}
@@ -680,9 +688,9 @@
return webrtc::RTCError(webrtc::RTCErrorType::INVALID_PARAMETER,
"RTX codec with unlisted APT");
}
- const Codec::ResiliencyType associated_codec_type = it->second;
- if (associated_codec_type != Codec::ResiliencyType::kNone &&
- associated_codec_type != Codec::ResiliencyType::kRed) {
+ const webrtc::Codec::ResiliencyType associated_codec_type = it->second;
+ if (associated_codec_type != webrtc::Codec::ResiliencyType::kNone &&
+ associated_codec_type != webrtc::Codec::ResiliencyType::kRed) {
RTC_LOG(LS_ERROR)
<< "RTX PT=" << rtx_payload_type
<< " not mapped to regular video codec or RED codec (PT="
@@ -871,13 +879,15 @@
call, config, options, crypto_options, decoder_factory_.get());
}
-std::vector<Codec> WebRtcVideoEngine::LegacySendCodecs(bool include_rtx) const {
+std::vector<webrtc::Codec> WebRtcVideoEngine::LegacySendCodecs(
+ bool include_rtx) const {
return GetPayloadTypesAndDefaultCodecs(encoder_factory_.get(),
/*is_decoder_factory=*/false,
include_rtx, trials_);
}
-std::vector<Codec> WebRtcVideoEngine::LegacyRecvCodecs(bool include_rtx) const {
+std::vector<webrtc::Codec> WebRtcVideoEngine::LegacyRecvCodecs(
+ bool include_rtx) const {
return GetPayloadTypesAndDefaultCodecs(decoder_factory_.get(),
/*is_decoder_factory=*/true,
include_rtx, trials_);
@@ -982,7 +992,7 @@
rtc::scoped_refptr<webrtc::VideoEncoderConfig::EncoderSpecificSettings>
WebRtcVideoSendChannel::WebRtcVideoSendStream::ConfigureVideoEncoderSettings(
- const Codec& codec) {
+ const webrtc::Codec& codec) {
RTC_DCHECK_RUN_ON(&thread_checker_);
bool is_screencast = parameters_.options.is_screencast.value_or(false);
// No automatic resizing when using simulcast or screencast, or when
@@ -1422,7 +1432,7 @@
webrtc::RtpParameters rtp_params = it->second->GetRtpParameters();
// Need to add the common list of codecs to the send stream-specific
// RTP parameters.
- for (const Codec& codec : send_params_.codecs) {
+ for (const webrtc::Codec& codec : send_params_.codecs) {
if (send_codec() && send_codec()->codec.id == codec.id) {
// Put the current send codec to the front of the codecs list.
RTC_DCHECK_EQ(codec.name, send_codec()->codec.name);
@@ -1508,7 +1518,7 @@
return it->second->SetRtpParameters(parameters, std::move(callback));
}
-std::optional<Codec> WebRtcVideoSendChannel::GetSendCodec() const {
+std::optional<webrtc::Codec> WebRtcVideoSendChannel::GetSendCodec() const {
RTC_DCHECK_RUN_ON(&thread_checker_);
if (!send_codec()) {
RTC_LOG(LS_VERBOSE) << "GetSendCodec: No send codec set.";
@@ -2030,12 +2040,12 @@
}
}
- const bool has_lntf = HasLntf(codec_settings.codec);
+ const bool has_lntf = webrtc::HasLntf(codec_settings.codec);
parameters_.config.rtp.lntf.enabled = has_lntf;
parameters_.config.encoder_settings.capabilities.loss_notification = has_lntf;
parameters_.config.rtp.nack.rtp_history_ms =
- HasNack(codec_settings.codec) ? kNackHistoryMs : 0;
+ webrtc::HasNack(codec_settings.codec) ? kNackHistoryMs : 0;
parameters_.codec_settings = codec_settings;
@@ -2121,8 +2131,7 @@
// Set codecs and options.
if (params.send_codec) {
SetCodec(*params.send_codec,
- params.send_codecs.value_or(
- std::vector<cricket::VideoCodecSettings>()));
+ params.send_codecs.value_or(std::vector<VideoCodecSettings>()));
recreate_stream = false; // SetCodec has already recreated the stream.
} else if (params.conference_mode && parameters_.codec_settings) {
SetCodec(*parameters_.codec_settings, parameters_.codec_settings_list);
@@ -2275,7 +2284,7 @@
webrtc::VideoEncoderConfig
WebRtcVideoSendChannel::WebRtcVideoSendStream::CreateVideoEncoderConfig(
- const Codec& codec) const {
+ const webrtc::Codec& codec) const {
RTC_DCHECK_RUN_ON(&thread_checker_);
webrtc::VideoEncoderConfig encoder_config;
encoder_config.codec_type = webrtc::PayloadStringToCodecType(codec.name);
@@ -2844,7 +2853,7 @@
rtp_params.header_extensions = recv_rtp_extensions_;
// Add codecs, which any stream is prepared to receive.
- for (const Codec& codec : recv_params_.codecs) {
+ for (const webrtc::Codec& codec : recv_params_.codecs) {
rtp_params.codecs.push_back(codec.ToCodecParameters());
}
@@ -2864,7 +2873,7 @@
rtp_params.encodings.emplace_back();
// Add codecs, which any stream is prepared to receive.
- for (const Codec& codec : recv_params_.codecs) {
+ for (const webrtc::Codec& codec : recv_params_.codecs) {
rtp_params.codecs.push_back(codec.ToCodecParameters());
}
@@ -2891,12 +2900,13 @@
// Verify that every mapped codec is supported locally.
if (params.is_stream_active) {
- const std::vector<Codec> local_supported_codecs =
+ const std::vector<webrtc::Codec> local_supported_codecs =
GetPayloadTypesAndDefaultCodecs(decoder_factory_,
/*is_decoder_factory=*/true,
/*include_rtx=*/true, call_->trials());
for (const VideoCodecSettings& mapped_codec : mapped_codecs) {
- if (!FindMatchingVideoCodec(local_supported_codecs, mapped_codec.codec)) {
+ if (!webrtc::FindMatchingVideoCodec(local_supported_codecs,
+ mapped_codec.codec)) {
RTC_LOG(LS_ERROR) << "GetChangedReceiverParameters called with "
"unsupported video codec: "
<< mapped_codec.codec.ToString();
@@ -3241,8 +3251,8 @@
void WebRtcVideoReceiveChannel::FillReceiveCodecStats(
VideoMediaReceiveInfo* video_media_info) {
for (const auto& receiver : video_media_info->receivers) {
- auto codec =
- absl::c_find_if(recv_params_.codecs, [&receiver](const Codec& c) {
+ auto codec = absl::c_find_if(
+ recv_params_.codecs, [&receiver](const webrtc::Codec& c) {
return receiver.codec_payload_type &&
*receiver.codec_payload_type == c.id;
});
@@ -3483,13 +3493,15 @@
const VideoCodecSettings& codec = recv_codecs.front();
config_.rtp.ulpfec_payload_type = codec.ulpfec.ulpfec_payload_type;
config_.rtp.red_payload_type = codec.ulpfec.red_payload_type;
- config_.rtp.lntf.enabled = HasLntf(codec.codec);
- config_.rtp.nack.rtp_history_ms = HasNack(codec.codec) ? kNackHistoryMs : 0;
+ config_.rtp.lntf.enabled = webrtc::HasLntf(codec.codec);
+ config_.rtp.nack.rtp_history_ms =
+ webrtc::HasNack(codec.codec) ? kNackHistoryMs : 0;
if (codec.rtx_time && config_.rtp.nack.rtp_history_ms != 0) {
config_.rtp.nack.rtp_history_ms = *codec.rtx_time;
}
- config_.rtp.rtcp_xr.receiver_reference_time_report = HasRrtr(codec.codec);
+ config_.rtp.rtcp_xr.receiver_reference_time_report =
+ webrtc::HasRrtr(codec.codec);
if (codec.ulpfec.red_rtx_payload_type != -1) {
config_.rtp
@@ -3570,14 +3582,14 @@
config_.rtp.ulpfec_payload_type);
}
- const bool has_lntf = HasLntf(codec.codec);
+ const bool has_lntf = webrtc::HasLntf(codec.codec);
if (config_.rtp.lntf.enabled != has_lntf) {
config_.rtp.lntf.enabled = has_lntf;
stream_->SetLossNotificationEnabled(has_lntf);
}
int new_history_ms = config_.rtp.nack.rtp_history_ms;
- const int rtp_history_ms = HasNack(codec.codec) ? kNackHistoryMs : 0;
+ const int rtp_history_ms = webrtc::HasNack(codec.codec) ? kNackHistoryMs : 0;
if (rtp_history_ms != config_.rtp.nack.rtp_history_ms) {
new_history_ms = rtp_history_ms;
}
@@ -3593,7 +3605,7 @@
stream_->SetNackHistory(webrtc::TimeDelta::Millis(new_history_ms));
}
- const bool has_rtr = HasRrtr(codec.codec);
+ const bool has_rtr = webrtc::HasRrtr(codec.codec);
if (has_rtr != config_.rtp.rtcp_xr.receiver_reference_time_report) {
config_.rtp.rtcp_xr.receiver_reference_time_report = has_rtr;
stream_->SetRtcpXr(config_.rtp.rtcp_xr);
@@ -4117,7 +4129,7 @@
// ------------------------- VideoCodecSettings --------------------
-VideoCodecSettings::VideoCodecSettings(const Codec& codec)
+VideoCodecSettings::VideoCodecSettings(const webrtc::Codec& codec)
: codec(codec), flexfec_payload_type(-1), rtx_payload_type(-1) {}
bool VideoCodecSettings::operator==(const VideoCodecSettings& other) const {
diff --git a/media/engine/webrtc_video_engine.h b/media/engine/webrtc_video_engine.h
index 923ef98..62bff11 100644
--- a/media/engine/webrtc_video_engine.h
+++ b/media/engine/webrtc_video_engine.h
@@ -117,14 +117,14 @@
const webrtc::CryptoOptions& crypto_options) override;
// TODO: https://issues.webrtc.org/360058654 - remove Legacy functions.
- std::vector<Codec> LegacySendCodecs() const override {
+ std::vector<webrtc::Codec> LegacySendCodecs() const override {
return LegacySendCodecs(true);
}
- std::vector<Codec> LegacyRecvCodecs() const override {
+ std::vector<webrtc::Codec> LegacyRecvCodecs() const override {
return LegacyRecvCodecs(true);
}
- std::vector<Codec> LegacySendCodecs(bool include_rtx) const override;
- std::vector<Codec> LegacyRecvCodecs(bool include_rtx) const override;
+ std::vector<webrtc::Codec> LegacySendCodecs(bool include_rtx) const override;
+ std::vector<webrtc::Codec> LegacyRecvCodecs(bool include_rtx) const override;
std::vector<webrtc::RtpHeaderExtensionCapability> GetRtpHeaderExtensions()
const override;
@@ -137,7 +137,7 @@
};
struct VideoCodecSettings {
- explicit VideoCodecSettings(const Codec& codec);
+ explicit VideoCodecSettings(const webrtc::Codec& codec);
// Checks if all members of |*this| are equal to the corresponding members
// of `other`.
@@ -149,7 +149,7 @@
static bool EqualsDisregardingFlexfec(const VideoCodecSettings& a,
const VideoCodecSettings& b);
- Codec codec;
+ webrtc::Codec codec;
webrtc::UlpfecConfig ulpfec;
int flexfec_payload_type; // -1 if absent.
int rtx_payload_type; // -1 if absent.
@@ -199,7 +199,7 @@
const webrtc::RtpParameters& parameters,
webrtc::SetParametersCallback callback) override;
webrtc::RtpParameters GetRtpSendParameters(uint32_t ssrc) const override;
- std::optional<Codec> GetSendCodec() const override;
+ std::optional<webrtc::Codec> GetSendCodec() const override;
bool SetSend(bool send) override;
bool SetVideoSend(
uint32_t ssrc,
@@ -278,14 +278,14 @@
if (!send_codec()) {
return false;
}
- return HasLntf(send_codec()->codec);
+ return webrtc::HasLntf(send_codec()->codec);
}
bool SendCodecHasNack() const override {
RTC_DCHECK_RUN_ON(&thread_checker_);
if (!send_codec()) {
return false;
}
- return HasNack(send_codec()->codec);
+ return webrtc::HasNack(send_codec()->codec);
}
std::optional<int> SendCodecRtxTime() const override {
RTC_DCHECK_RUN_ON(&thread_checker_);
@@ -399,12 +399,12 @@
};
rtc::scoped_refptr<webrtc::VideoEncoderConfig::EncoderSpecificSettings>
- ConfigureVideoEncoderSettings(const Codec& codec);
+ ConfigureVideoEncoderSettings(const webrtc::Codec& codec);
void SetCodec(const VideoCodecSettings& codec,
const std::vector<VideoCodecSettings>& codec_settings_list);
void RecreateWebRtcStream();
webrtc::VideoEncoderConfig CreateVideoEncoderConfig(
- const Codec& codec) const;
+ const webrtc::Codec& codec) const;
void ReconfigureEncoder(webrtc::SetParametersCallback callback);
// Calls Start or Stop according to whether or not `sending_` is true.
diff --git a/media/engine/webrtc_video_engine_unittest.cc b/media/engine/webrtc_video_engine_unittest.cc
index ee2dea8..401999d 100644
--- a/media/engine/webrtc_video_engine_unittest.cc
+++ b/media/engine/webrtc_video_engine_unittest.cc
@@ -183,32 +183,32 @@
static const char kUnsupportedExtensionName[] =
"urn:ietf:params:rtp-hdrext:unsupported";
-cricket::Codec RemoveFeedbackParams(cricket::Codec&& codec) {
- codec.feedback_params = cricket::FeedbackParams();
+webrtc::Codec RemoveFeedbackParams(webrtc::Codec&& codec) {
+ codec.feedback_params = webrtc::FeedbackParams();
return std::move(codec);
}
-void VerifyCodecHasDefaultFeedbackParams(const cricket::Codec& codec,
+void VerifyCodecHasDefaultFeedbackParams(const webrtc::Codec& codec,
bool lntf_expected) {
EXPECT_EQ(lntf_expected,
- codec.HasFeedbackParam(cricket::FeedbackParam(
+ codec.HasFeedbackParam(webrtc::FeedbackParam(
cricket::kRtcpFbParamLntf, cricket::kParamValueEmpty)));
- EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
+ EXPECT_TRUE(codec.HasFeedbackParam(webrtc::FeedbackParam(
cricket::kRtcpFbParamNack, cricket::kParamValueEmpty)));
- EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
+ EXPECT_TRUE(codec.HasFeedbackParam(webrtc::FeedbackParam(
cricket::kRtcpFbParamNack, cricket::kRtcpFbNackParamPli)));
- EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
+ EXPECT_TRUE(codec.HasFeedbackParam(webrtc::FeedbackParam(
cricket::kRtcpFbParamRemb, cricket::kParamValueEmpty)));
- EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
+ EXPECT_TRUE(codec.HasFeedbackParam(webrtc::FeedbackParam(
cricket::kRtcpFbParamTransportCc, cricket::kParamValueEmpty)));
- EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
+ EXPECT_TRUE(codec.HasFeedbackParam(webrtc::FeedbackParam(
cricket::kRtcpFbParamCcm, cricket::kRtcpFbCcmParamFir)));
}
// Return true if any codec in `codecs` is an RTX codec with associated
// payload type `payload_type`.
-bool HasRtxCodec(const std::vector<cricket::Codec>& codecs, int payload_type) {
- for (const cricket::Codec& codec : codecs) {
+bool HasRtxCodec(const std::vector<webrtc::Codec>& codecs, int payload_type) {
+ for (const webrtc::Codec& codec : codecs) {
int associated_payload_type;
if (absl::EqualsIgnoreCase(codec.name.c_str(), "rtx") &&
codec.GetParam(cricket::kCodecParamAssociatedPayloadType,
@@ -222,8 +222,8 @@
// Return true if any codec in `codecs` is an RTX codec, independent of
// payload type.
-bool HasAnyRtxCodec(const std::vector<cricket::Codec>& codecs) {
- for (const cricket::Codec& codec : codecs) {
+bool HasAnyRtxCodec(const std::vector<webrtc::Codec>& codecs) {
+ for (const webrtc::Codec& codec : codecs) {
if (absl::EqualsIgnoreCase(codec.name.c_str(), "rtx")) {
return true;
}
@@ -427,7 +427,7 @@
// Find the codec in the engine with the given name. The codec must be
// present.
- cricket::Codec GetEngineCodec(const std::string& name) const;
+ webrtc::Codec GetEngineCodec(const std::string& name) const;
void AddSupportedVideoCodecType(
const std::string& name,
const std::vector<webrtc::ScalabilityMode>& scalability_modes = {});
@@ -439,7 +439,7 @@
std::unique_ptr<VideoMediaReceiveChannelInterface>
SetRecvParamsWithAllSupportedCodecs();
std::unique_ptr<VideoMediaReceiveChannelInterface>
- SetRecvParamsWithSupportedCodecs(const std::vector<Codec>& codecs);
+ SetRecvParamsWithSupportedCodecs(const std::vector<webrtc::Codec>& codecs);
void ExpectRtpCapabilitySupport(const char* uri, bool supported) const;
@@ -454,7 +454,7 @@
std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
video_bitrate_allocator_factory_;
WebRtcVideoEngine engine_;
- std::optional<Codec> default_codec_;
+ std::optional<webrtc::Codec> default_codec_;
std::map<int, int> default_apt_rtx_types_;
};
@@ -462,7 +462,7 @@
encoder_factory_->AddSupportedVideoCodecType("VP8");
AssignDefaultCodec();
- std::vector<Codec> engine_codecs = engine_.LegacySendCodecs();
+ std::vector<webrtc::Codec> engine_codecs = engine_.LegacySendCodecs();
for (size_t i = 0; i < engine_codecs.size(); ++i) {
if (engine_codecs[i].name != kRtxCodecName)
continue;
@@ -485,7 +485,7 @@
AddSupportedVideoCodecType("VP9");
AddSupportedVideoCodecType("AV1");
AddSupportedVideoCodecType("H264");
- for (const Codec& codec : engine_.LegacySendCodecs()) {
+ for (const webrtc::Codec& codec : engine_.LegacySendCodecs()) {
if (codec.name != kRtxCodecName)
continue;
int associated_payload_type;
@@ -493,7 +493,7 @@
&associated_payload_type));
EXPECT_EQ(codec.id, associated_payload_type + 1);
}
- for (const Codec& codec : engine_.LegacyRecvCodecs()) {
+ for (const webrtc::Codec& codec : engine_.LegacyRecvCodecs()) {
if (codec.name != kRtxCodecName)
continue;
int associated_payload_type;
@@ -823,21 +823,21 @@
encoder_factory_->AddSupportedVideoCodec(h264_high);
// First figure out what payload types the test codecs got assigned.
- const std::vector<cricket::Codec> codecs = engine_.LegacySendCodecs();
+ const std::vector<webrtc::Codec> codecs = engine_.LegacySendCodecs();
// Now search for RTX codecs for them. Expect that they all have associated
// RTX codecs.
EXPECT_TRUE(HasRtxCodec(
- codecs, FindMatchingVideoCodec(
- codecs, cricket::CreateVideoCodec(h264_constrained_baseline))
+ codecs, webrtc::FindMatchingVideoCodec(
+ codecs, webrtc::CreateVideoCodec(h264_constrained_baseline))
->id));
EXPECT_TRUE(HasRtxCodec(
- codecs, FindMatchingVideoCodec(
- codecs, cricket::CreateVideoCodec(h264_constrained_high))
+ codecs, webrtc::FindMatchingVideoCodec(
+ codecs, webrtc::CreateVideoCodec(h264_constrained_high))
->id));
- EXPECT_TRUE(HasRtxCodec(
- codecs,
- FindMatchingVideoCodec(codecs, cricket::CreateVideoCodec(h264_high))
- ->id));
+ EXPECT_TRUE(
+ HasRtxCodec(codecs, webrtc::FindMatchingVideoCodec(
+ codecs, webrtc::CreateVideoCodec(h264_high))
+ ->id));
}
#if defined(RTC_ENABLE_VP9)
@@ -905,9 +905,9 @@
}
void WebRtcVideoEngineTest::AssignDefaultAptRtxTypes() {
- std::vector<Codec> engine_codecs = engine_.LegacySendCodecs();
+ std::vector<webrtc::Codec> engine_codecs = engine_.LegacySendCodecs();
RTC_DCHECK(!engine_codecs.empty());
- for (const cricket::Codec& codec : engine_codecs) {
+ for (const webrtc::Codec& codec : engine_codecs) {
if (codec.name == "rtx") {
int associated_payload_type;
if (codec.GetParam(kCodecParamAssociatedPayloadType,
@@ -919,10 +919,10 @@
}
void WebRtcVideoEngineTest::AssignDefaultCodec() {
- std::vector<Codec> engine_codecs = engine_.LegacySendCodecs();
+ std::vector<webrtc::Codec> engine_codecs = engine_.LegacySendCodecs();
RTC_DCHECK(!engine_codecs.empty());
bool codec_set = false;
- for (const cricket::Codec& codec : engine_codecs) {
+ for (const webrtc::Codec& codec : engine_codecs) {
if (!codec_set && codec.name != "rtx" && codec.name != "red" &&
codec.name != "ulpfec" && codec.name != "flexfec-03") {
default_codec_ = codec;
@@ -935,9 +935,9 @@
size_t WebRtcVideoEngineTest::GetEngineCodecIndex(
const std::string& name) const {
- const std::vector<cricket::Codec> codecs = engine_.LegacySendCodecs();
+ const std::vector<webrtc::Codec> codecs = engine_.LegacySendCodecs();
for (size_t i = 0; i < codecs.size(); ++i) {
- const cricket::Codec engine_codec = codecs[i];
+ const webrtc::Codec engine_codec = codecs[i];
if (!absl::EqualsIgnoreCase(name, engine_codec.name))
continue;
// The tests only use H264 Constrained Baseline. Make sure we don't return
@@ -957,7 +957,7 @@
return -1;
}
-cricket::Codec WebRtcVideoEngineTest::GetEngineCodec(
+webrtc::Codec WebRtcVideoEngineTest::GetEngineCodec(
const std::string& name) const {
return engine_.LegacySendCodecs()[GetEngineCodecIndex(name)];
}
@@ -985,7 +985,7 @@
// We need to look up the codec in the engine to get the correct payload type.
for (const webrtc::SdpVideoFormat& format :
encoder_factory_->GetSupportedFormats()) {
- cricket::Codec engine_codec = GetEngineCodec(format.name);
+ webrtc::Codec engine_codec = GetEngineCodec(format.name);
if (!absl::c_linear_search(parameters.codecs, engine_codec)) {
parameters.codecs.push_back(engine_codec);
}
@@ -998,7 +998,7 @@
std::unique_ptr<VideoMediaReceiveChannelInterface>
WebRtcVideoEngineTest::SetRecvParamsWithSupportedCodecs(
- const std::vector<Codec>& codecs) {
+ const std::vector<webrtc::Codec>& codecs) {
std::unique_ptr<VideoMediaReceiveChannelInterface> channel =
engine_.CreateReceiveChannel(call_.get(), GetMediaConfig(),
VideoOptions(), webrtc::CryptoOptions());
@@ -1011,10 +1011,10 @@
std::unique_ptr<VideoMediaReceiveChannelInterface>
WebRtcVideoEngineTest::SetRecvParamsWithAllSupportedCodecs() {
- std::vector<Codec> codecs;
+ std::vector<webrtc::Codec> codecs;
for (const webrtc::SdpVideoFormat& format :
decoder_factory_->GetSupportedFormats()) {
- cricket::Codec engine_codec = GetEngineCodec(format.name);
+ webrtc::Codec engine_codec = GetEngineCodec(format.name);
if (!absl::c_linear_search(codecs, engine_codec)) {
codecs.push_back(engine_codec);
}
@@ -1077,7 +1077,7 @@
// Setup a channel with VP8, RTX and transport sequence number header
// extension. Receive stream is not explicitly configured.
AddSupportedVideoCodecType("VP8");
- std::vector<Codec> supported_codecs =
+ std::vector<webrtc::Codec> supported_codecs =
engine_.LegacyRecvCodecs(/*include_rtx=*/true);
ASSERT_EQ(supported_codecs[1].name, "rtx");
int rtx_payload_type = supported_codecs[1].id;
@@ -1304,7 +1304,7 @@
TEST_F(WebRtcVideoEngineTest, Flexfec03SendCodecEnablesWithFieldTrial) {
encoder_factory_->AddSupportedVideoCodecType("VP8");
- auto flexfec = Field("name", &Codec::name, "flexfec-03");
+ auto flexfec = Field("name", &webrtc::Codec::name, "flexfec-03");
EXPECT_THAT(engine_.LegacySendCodecs(), Not(Contains(flexfec)));
@@ -1317,7 +1317,7 @@
TEST_F(WebRtcVideoEngineTest, Flexfec03LowerPayloadTypeRange) {
encoder_factory_->AddSupportedVideoCodecType("VP8");
- auto flexfec = Field("name", &Codec::name, "flexfec-03");
+ auto flexfec = Field("name", &webrtc::Codec::name, "flexfec-03");
// FlexFEC is active with field trial.
webrtc::test::ScopedKeyValueConfig override_field_trials(
@@ -1325,7 +1325,7 @@
auto send_codecs = engine_.LegacySendCodecs();
auto it = std::find_if(
send_codecs.begin(), send_codecs.end(),
- [](const cricket::Codec& codec) { return codec.name == "flexfec-03"; });
+ [](const webrtc::Codec& codec) { return codec.name == "flexfec-03"; });
ASSERT_NE(it, send_codecs.end());
EXPECT_LE(35, it->id);
EXPECT_GE(65, it->id);
@@ -1352,11 +1352,11 @@
// Set up external encoder factory with first codec, and initialize engine.
encoder_factory_->AddSupportedVideoCodecType(kFakeExternalCodecName1);
- std::vector<cricket::Codec> codecs_before(engine_.LegacySendCodecs());
+ std::vector<webrtc::Codec> codecs_before(engine_.LegacySendCodecs());
// Add second codec.
encoder_factory_->AddSupportedVideoCodecType(kFakeExternalCodecName2);
- std::vector<cricket::Codec> codecs_after(engine_.LegacySendCodecs());
+ std::vector<webrtc::Codec> codecs_after(engine_.LegacySendCodecs());
// The codec itself and RTX should have been added.
EXPECT_EQ(codecs_before.size() + 2, codecs_after.size());
@@ -1404,7 +1404,7 @@
// For now we add a FakeWebRtcVideoEncoderFactory to add H264 to supported
// codecs.
AddSupportedVideoCodecType("H264");
- std::vector<cricket::Codec> codecs;
+ std::vector<webrtc::Codec> codecs;
codecs.push_back(GetEngineCodec("H264"));
auto receive_channel = SetRecvParamsWithSupportedCodecs(codecs);
@@ -1493,7 +1493,7 @@
.WillRepeatedly(Return(supported_formats));
// Verify the codecs from the engine.
- const std::vector<Codec> engine_codecs = engine.LegacySendCodecs();
+ const std::vector<webrtc::Codec> engine_codecs = engine.LegacySendCodecs();
// Verify default codecs has been added correctly.
EXPECT_EQ(5u, engine_codecs.size());
EXPECT_EQ("VP8", engine_codecs.at(0).name);
@@ -1592,7 +1592,7 @@
ASSERT_TRUE(
send_channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
- cricket::Codec codec = GetEngineCodec("VP8");
+ webrtc::Codec codec = GetEngineCodec("VP8");
cricket::VideoSenderParameters parameters;
parameters.codecs.push_back(codec);
send_channel->OnReadyToSend(true);
@@ -1647,8 +1647,8 @@
TEST_F(WebRtcVideoEngineTest, SetVideoRtxEnabled) {
AddSupportedVideoCodecType("VP8");
- std::vector<Codec> send_codecs;
- std::vector<Codec> recv_codecs;
+ std::vector<webrtc::Codec> send_codecs;
+ std::vector<webrtc::Codec> recv_codecs;
webrtc::test::ScopedKeyValueConfig field_trials;
@@ -1942,7 +1942,7 @@
bool SetDefaultCodec() { return SetOneCodec(DefaultCodec()); }
- bool SetOneCodec(const cricket::Codec& codec) {
+ bool SetOneCodec(const webrtc::Codec& codec) {
frame_source_ = std::make_unique<webrtc::FakeFrameSource>(
kVideoWidth, kVideoHeight, webrtc::kNumMicrosecsPerSec / kFramerate);
@@ -1990,7 +1990,7 @@
}
// Tests that we can send and receive frames.
- void SendAndReceive(const cricket::Codec& codec) {
+ void SendAndReceive(const webrtc::Codec& codec) {
EXPECT_TRUE(SetOneCodec(codec));
EXPECT_TRUE(SetSend(true));
receive_channel_->SetDefaultSink(&renderer_);
@@ -2000,7 +2000,7 @@
EXPECT_EQ(codec.id, GetPayloadType(GetRtpPacket(0)));
}
- void SendReceiveManyAndGetStats(const cricket::Codec& codec,
+ void SendReceiveManyAndGetStats(const webrtc::Codec& codec,
int duration_sec,
int fps) {
EXPECT_TRUE(SetOneCodec(codec));
@@ -2031,7 +2031,7 @@
// Two streams one channel tests.
// Tests that we can send and receive frames.
- void TwoStreamsSendAndReceive(const cricket::Codec& codec) {
+ void TwoStreamsSendAndReceive(const webrtc::Codec& codec) {
SetUpSecondStream();
// Test sending and receiving on first stream.
SendAndReceive(codec);
@@ -2040,17 +2040,17 @@
EXPECT_GT(NumRtpPackets(), 0);
}
- cricket::Codec GetEngineCodec(const std::string& name) {
- for (const cricket::Codec& engine_codec : engine_.LegacySendCodecs()) {
+ webrtc::Codec GetEngineCodec(const std::string& name) {
+ for (const webrtc::Codec& engine_codec : engine_.LegacySendCodecs()) {
if (absl::EqualsIgnoreCase(name, engine_codec.name))
return engine_codec;
}
// This point should never be reached.
ADD_FAILURE() << "Unrecognized codec name: " << name;
- return cricket::CreateVideoCodec(0, "");
+ return webrtc::CreateVideoCodec(0, "");
}
- cricket::Codec DefaultCodec() { return GetEngineCodec("VP8"); }
+ webrtc::Codec DefaultCodec() { return GetEngineCodec("VP8"); }
cricket::StreamParams DefaultSendStreamParams() {
return cricket::StreamParams::CreateLegacy(kSsrc);
@@ -2284,7 +2284,7 @@
const int kFps = 10;
SendReceiveManyAndGetStats(GetEngineCodec("VP9"), kDurationSec, kFps);
- const cricket::Codec& new_codec = GetEngineCodec("VP8");
+ const webrtc::Codec& new_codec = GetEngineCodec("VP8");
EXPECT_TRUE(SetOneCodec(new_codec));
EXPECT_TRUE(SetSend(true));
cricket::VideoMediaSendInfo send_info;
@@ -2432,10 +2432,10 @@
// Tests that we can add and remove capturers and frames are sent out properly
TEST_F(WebRtcVideoChannelBaseTest, DISABLED_AddRemoveCapturer) {
- using cricket::Codec;
using cricket::FOURCC_I420;
using cricket::VideoFormat;
using cricket::VideoOptions;
+ using webrtc::Codec;
Codec codec = DefaultCodec();
const int time_between_send_ms = VideoFormat::FpsToInterval(kFramerate);
@@ -2625,7 +2625,7 @@
// initially will use QVGA instead of VGA.
// TODO(pbos): Set up the quality scaler so that both senders reliably start
// at QVGA, then verify that instead.
- cricket::Codec codec = GetEngineCodec("VP8");
+ webrtc::Codec codec = GetEngineCodec("VP8");
codec.params[kCodecParamStartBitrate] = "1000000";
TwoStreamsSendAndReceive(codec);
}
@@ -2638,7 +2638,7 @@
parameters.codecs.push_back(GetEngineCodec("VP8"));
EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
- std::optional<Codec> codec = send_channel_->GetSendCodec();
+ std::optional<webrtc::Codec> codec = send_channel_->GetSendCodec();
ASSERT_TRUE(codec);
EXPECT_EQ("VP9", codec->name);
@@ -2670,7 +2670,7 @@
parameters.codecs.push_back(GetEngineCodec("VP8"));
EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
- std::optional<Codec> codec = send_channel_->GetSendCodec();
+ std::optional<webrtc::Codec> codec = send_channel_->GetSendCodec();
ASSERT_TRUE(codec);
EXPECT_EQ("VP9", codec->name);
@@ -2696,7 +2696,7 @@
parameters.codecs.push_back(GetEngineCodec("VP8"));
EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
- std::optional<Codec> codec = send_channel_->GetSendCodec();
+ std::optional<webrtc::Codec> codec = send_channel_->GetSendCodec();
ASSERT_TRUE(codec);
EXPECT_EQ("VP9", codec->name);
@@ -2714,7 +2714,7 @@
}
TEST_F(WebRtcVideoChannelBaseTest, RequestEncoderSwitchStrictPreference) {
- Codec vp9 = GetEngineCodec("VP9");
+ webrtc::Codec vp9 = GetEngineCodec("VP9");
vp9.params["profile-id"] = "0";
cricket::VideoSenderParameters parameters;
@@ -2722,7 +2722,7 @@
parameters.codecs.push_back(vp9);
EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
- std::optional<Codec> codec = send_channel_->GetSendCodec();
+ std::optional<webrtc::Codec> codec = send_channel_->GetSendCodec();
ASSERT_TRUE(codec);
EXPECT_EQ("VP8", codec->name);
@@ -2836,17 +2836,17 @@
return static_cast<cricket::WebRtcVideoSendChannel*>(channel)->transport();
}
- cricket::Codec GetEngineCodec(const std::string& name) {
- for (const cricket::Codec& engine_codec : engine_.LegacySendCodecs()) {
+ webrtc::Codec GetEngineCodec(const std::string& name) {
+ for (const webrtc::Codec& engine_codec : engine_.LegacySendCodecs()) {
if (absl::EqualsIgnoreCase(name, engine_codec.name))
return engine_codec;
}
// This point should never be reached.
ADD_FAILURE() << "Unrecognized codec name: " << name;
- return cricket::CreateVideoCodec(0, "");
+ return webrtc::CreateVideoCodec(0, "");
}
- cricket::Codec DefaultCodec() { return GetEngineCodec("VP8"); }
+ webrtc::Codec DefaultCodec() { return GetEngineCodec("VP8"); }
// After receciving and processing the packet, enough time is advanced that
// the unsignalled receive stream cooldown is no longer in effect.
@@ -3628,7 +3628,7 @@
TEST_F(WebRtcVideoChannelTest, UsesCorrectSettingsForScreencast) {
static const int kScreenshareMinBitrateKbps = 800;
- cricket::Codec codec = GetEngineCodec("VP8");
+ webrtc::Codec codec = GetEngineCodec("VP8");
cricket::VideoSenderParameters parameters;
parameters.codecs.push_back(codec);
EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
@@ -4370,7 +4370,7 @@
}
TEST_F(WebRtcVideoChannelTest, PreviousAdaptationDoesNotApplyToScreenshare) {
- cricket::Codec codec = GetEngineCodec("VP8");
+ webrtc::Codec codec = GetEngineCodec("VP8");
cricket::VideoSenderParameters parameters;
parameters.codecs.push_back(codec);
@@ -4425,7 +4425,7 @@
void WebRtcVideoChannelTest::TestDegradationPreference(
bool resolution_scaling_enabled,
bool fps_scaling_enabled) {
- cricket::Codec codec = GetEngineCodec("VP8");
+ webrtc::Codec codec = GetEngineCodec("VP8");
cricket::VideoSenderParameters parameters;
parameters.codecs.push_back(codec);
@@ -4460,7 +4460,7 @@
void WebRtcVideoChannelTest::TestCpuAdaptation(bool enable_overuse,
bool is_screenshare) {
- cricket::Codec codec = GetEngineCodec("VP8");
+ webrtc::Codec codec = GetEngineCodec("VP8");
cricket::VideoSenderParameters parameters;
parameters.codecs.push_back(codec);
@@ -4552,7 +4552,7 @@
AssignDefaultAptRtxTypes();
ASSERT_TRUE(send_channel_->SetSenderParameters(send_parameters_));
- std::optional<Codec> codec = send_channel_->GetSendCodec();
+ std::optional<webrtc::Codec> codec = send_channel_->GetSendCodec();
ASSERT_TRUE(codec);
EXPECT_TRUE(codec->Matches(engine_.LegacySendCodecs()[0]));
@@ -4647,7 +4647,7 @@
TEST_F(WebRtcVideoChannelFlexfecRecvTest,
DefaultFlexfecCodecHasRembFeedbackParam) {
- EXPECT_TRUE(cricket::HasRemb(GetEngineCodec("flexfec-03")));
+ EXPECT_TRUE(webrtc::HasRemb(GetEngineCodec("flexfec-03")));
}
TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetDefaultRecvCodecsWithoutSsrc) {
@@ -4781,7 +4781,7 @@
cricket::VideoReceiverParameters recv_parameters;
recv_parameters.codecs.push_back(GetEngineCodec("VP8"));
recv_parameters.codecs.push_back(GetEngineCodec("flexfec-03"));
- cricket::Codec duplicate = GetEngineCodec("flexfec-03");
+ webrtc::Codec duplicate = GetEngineCodec("flexfec-03");
duplicate.id = kUnusedPayloadType1;
recv_parameters.codecs.push_back(duplicate);
ASSERT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters));
@@ -4924,11 +4924,11 @@
TEST_F(WebRtcVideoChannelTest,
SetSendCodecRejectsRtxWithoutAssociatedPayloadType) {
const int kUnusedPayloadType = 127;
- EXPECT_FALSE(FindCodecById(engine_.LegacySendCodecs(), kUnusedPayloadType));
+ EXPECT_FALSE(
+ webrtc::FindCodecById(engine_.LegacySendCodecs(), kUnusedPayloadType));
cricket::VideoSenderParameters parameters;
- cricket::Codec rtx_codec =
- cricket::CreateVideoCodec(kUnusedPayloadType, "rtx");
+ webrtc::Codec rtx_codec = webrtc::CreateVideoCodec(kUnusedPayloadType, "rtx");
parameters.codecs.push_back(rtx_codec);
EXPECT_FALSE(send_channel_->SetSenderParameters(parameters))
<< "RTX codec without associated payload type should be rejected.";
@@ -4938,10 +4938,12 @@
SetSendCodecRejectsRtxWithoutMatchingVideoCodec) {
const int kUnusedPayloadType1 = 126;
const int kUnusedPayloadType2 = 127;
- EXPECT_FALSE(FindCodecById(engine_.LegacySendCodecs(), kUnusedPayloadType1));
- EXPECT_FALSE(FindCodecById(engine_.LegacySendCodecs(), kUnusedPayloadType2));
+ EXPECT_FALSE(
+ webrtc::FindCodecById(engine_.LegacySendCodecs(), kUnusedPayloadType1));
+ EXPECT_FALSE(
+ webrtc::FindCodecById(engine_.LegacySendCodecs(), kUnusedPayloadType2));
{
- cricket::Codec rtx_codec = cricket::CreateVideoRtxCodec(
+ webrtc::Codec rtx_codec = webrtc::CreateVideoRtxCodec(
kUnusedPayloadType1, GetEngineCodec("VP8").id);
cricket::VideoSenderParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
@@ -4949,8 +4951,8 @@
ASSERT_TRUE(send_channel_->SetSenderParameters(parameters));
}
{
- cricket::Codec rtx_codec =
- cricket::CreateVideoRtxCodec(kUnusedPayloadType1, kUnusedPayloadType2);
+ webrtc::Codec rtx_codec =
+ webrtc::CreateVideoRtxCodec(kUnusedPayloadType1, kUnusedPayloadType2);
cricket::VideoSenderParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
parameters.codecs.push_back(rtx_codec);
@@ -4962,8 +4964,10 @@
TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithChangedRtxPayloadType) {
const int kUnusedPayloadType1 = 126;
const int kUnusedPayloadType2 = 127;
- EXPECT_FALSE(FindCodecById(engine_.LegacySendCodecs(), kUnusedPayloadType1));
- EXPECT_FALSE(FindCodecById(engine_.LegacySendCodecs(), kUnusedPayloadType2));
+ EXPECT_FALSE(
+ webrtc::FindCodecById(engine_.LegacySendCodecs(), kUnusedPayloadType1));
+ EXPECT_FALSE(
+ webrtc::FindCodecById(engine_.LegacySendCodecs(), kUnusedPayloadType2));
// SSRCs for RTX.
cricket::StreamParams params =
@@ -4974,8 +4978,8 @@
// Original payload type for RTX.
cricket::VideoSenderParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
- cricket::Codec rtx_codec =
- cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx");
+ webrtc::Codec rtx_codec =
+ webrtc::CreateVideoCodec(kUnusedPayloadType1, "rtx");
rtx_codec.SetParam("apt", GetEngineCodec("VP8").id);
parameters.codecs.push_back(rtx_codec);
EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
@@ -5045,7 +5049,7 @@
TEST_F(WebRtcVideoChannelTest, SetSendCodecsChangesExistingStreams) {
cricket::VideoSenderParameters parameters;
- cricket::Codec codec = cricket::CreateVideoCodec(100, "VP8");
+ webrtc::Codec codec = webrtc::CreateVideoCodec(100, "VP8");
codec.SetParam(kCodecParamMaxQuantization, kDefaultVideoMaxQpVpx);
parameters.codecs.push_back(codec);
@@ -5100,8 +5104,8 @@
SetSenderParametersRemovesSelectedCodecFromRtpParameters) {
EXPECT_TRUE(AddSendStream());
cricket::VideoSenderParameters parameters;
- parameters.codecs.push_back(cricket::CreateVideoCodec(100, "VP8"));
- parameters.codecs.push_back(cricket::CreateVideoCodec(100, "VP9"));
+ parameters.codecs.push_back(webrtc::CreateVideoCodec(100, "VP8"));
+ parameters.codecs.push_back(webrtc::CreateVideoCodec(100, "VP9"));
send_channel_->SetSenderParameters(parameters);
webrtc::RtpParameters initial_params =
@@ -5119,7 +5123,7 @@
send_channel_->SetRtpSendParameters(last_ssrc_, initial_params).ok());
parameters.codecs.clear();
- parameters.codecs.push_back(cricket::CreateVideoCodec(100, "VP8"));
+ parameters.codecs.push_back(webrtc::CreateVideoCodec(100, "VP8"));
send_channel_->SetSenderParameters(parameters);
// Since VP9 is no longer negotiated, the RTP parameters should not have a
@@ -5349,7 +5353,7 @@
EXPECT_EQ(atoi(kMaxQuantization),
AddSendStream()->GetVideoStreams().back().max_qp);
- std::optional<Codec> codec = send_channel_->GetSendCodec();
+ std::optional<webrtc::Codec> codec = send_channel_->GetSendCodec();
ASSERT_TRUE(codec);
EXPECT_EQ(kMaxQuantization, codec->params[kCodecParamMaxQuantization]);
}
@@ -5406,13 +5410,15 @@
TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithRtx) {
const int kUnusedPayloadType1 = 126;
const int kUnusedPayloadType2 = 127;
- EXPECT_FALSE(FindCodecById(engine_.LegacyRecvCodecs(), kUnusedPayloadType1));
- EXPECT_FALSE(FindCodecById(engine_.LegacyRecvCodecs(), kUnusedPayloadType2));
+ EXPECT_FALSE(
+ webrtc::FindCodecById(engine_.LegacyRecvCodecs(), kUnusedPayloadType1));
+ EXPECT_FALSE(
+ webrtc::FindCodecById(engine_.LegacyRecvCodecs(), kUnusedPayloadType2));
cricket::VideoReceiverParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
- cricket::Codec rtx_codec =
- cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx");
+ webrtc::Codec rtx_codec =
+ webrtc::CreateVideoCodec(kUnusedPayloadType1, "rtx");
parameters.codecs.push_back(rtx_codec);
EXPECT_FALSE(receive_channel_->SetReceiverParameters(parameters))
<< "RTX codec without associated payload should be rejected.";
@@ -5424,8 +5430,8 @@
parameters.codecs[1].SetParam("apt", GetEngineCodec("VP8").id);
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
- cricket::Codec rtx_codec2 =
- cricket::CreateVideoCodec(kUnusedPayloadType2, "rtx");
+ webrtc::Codec rtx_codec2 =
+ webrtc::CreateVideoCodec(kUnusedPayloadType2, "rtx");
rtx_codec2.SetParam("apt", rtx_codec.id);
parameters.codecs.push_back(rtx_codec2);
@@ -5435,7 +5441,7 @@
}
TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithPacketization) {
- cricket::Codec vp8_codec = GetEngineCodec("VP8");
+ webrtc::Codec vp8_codec = GetEngineCodec("VP8");
vp8_codec.packetization = kPacketizationParamRaw;
cricket::VideoReceiverParameters parameters;
@@ -5476,9 +5482,9 @@
cricket::VideoReceiverParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
- parameters.codecs.push_back(cricket::CreateVideoCodec(
+ parameters.codecs.push_back(webrtc::CreateVideoCodec(
kFirstUlpfecPayloadType, cricket::kUlpfecCodecName));
- parameters.codecs.push_back(cricket::CreateVideoCodec(
+ parameters.codecs.push_back(webrtc::CreateVideoCodec(
kSecondUlpfecPayloadType, cricket::kUlpfecCodecName));
ASSERT_TRUE(receive_channel_->SetReceiverParameters(parameters));
@@ -5494,9 +5500,9 @@
cricket::VideoReceiverParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
parameters.codecs.push_back(
- cricket::CreateVideoCodec(kFirstRedPayloadType, cricket::kRedCodecName));
+ webrtc::CreateVideoCodec(kFirstRedPayloadType, cricket::kRedCodecName));
parameters.codecs.push_back(
- cricket::CreateVideoCodec(kSecondRedPayloadType, cricket::kRedCodecName));
+ webrtc::CreateVideoCodec(kSecondRedPayloadType, cricket::kRedCodecName));
ASSERT_TRUE(receive_channel_->SetReceiverParameters(parameters));
webrtc::FakeVideoReceiveStream* recv_stream = AddRecvStream();
@@ -5507,8 +5513,10 @@
TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithChangedRtxPayloadType) {
const int kUnusedPayloadType1 = 126;
const int kUnusedPayloadType2 = 127;
- EXPECT_FALSE(FindCodecById(engine_.LegacyRecvCodecs(), kUnusedPayloadType1));
- EXPECT_FALSE(FindCodecById(engine_.LegacyRecvCodecs(), kUnusedPayloadType2));
+ EXPECT_FALSE(
+ webrtc::FindCodecById(engine_.LegacyRecvCodecs(), kUnusedPayloadType1));
+ EXPECT_FALSE(
+ webrtc::FindCodecById(engine_.LegacyRecvCodecs(), kUnusedPayloadType2));
// SSRCs for RTX.
cricket::StreamParams params =
@@ -5519,8 +5527,8 @@
// Original payload type for RTX.
cricket::VideoReceiverParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
- cricket::Codec rtx_codec =
- cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx");
+ webrtc::Codec rtx_codec =
+ webrtc::CreateVideoCodec(kUnusedPayloadType1, "rtx");
rtx_codec.SetParam("apt", GetEngineCodec("VP8").id);
parameters.codecs.push_back(rtx_codec);
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
@@ -5551,8 +5559,10 @@
TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRtxWithRtxTime) {
const int kUnusedPayloadType1 = 126;
const int kUnusedPayloadType2 = 127;
- EXPECT_FALSE(FindCodecById(engine_.LegacyRecvCodecs(), kUnusedPayloadType1));
- EXPECT_FALSE(FindCodecById(engine_.LegacyRecvCodecs(), kUnusedPayloadType2));
+ EXPECT_FALSE(
+ webrtc::FindCodecById(engine_.LegacyRecvCodecs(), kUnusedPayloadType1));
+ EXPECT_FALSE(
+ webrtc::FindCodecById(engine_.LegacyRecvCodecs(), kUnusedPayloadType2));
// SSRCs for RTX.
cricket::StreamParams params =
@@ -5563,8 +5573,8 @@
// Payload type for RTX.
cricket::VideoReceiverParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
- cricket::Codec rtx_codec =
- cricket::CreateVideoCodec(kUnusedPayloadType1, "rtx");
+ webrtc::Codec rtx_codec =
+ webrtc::CreateVideoCodec(kUnusedPayloadType1, "rtx");
rtx_codec.SetParam("apt", GetEngineCodec("VP8").id);
parameters.codecs.push_back(rtx_codec);
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
@@ -5642,7 +5652,7 @@
TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRejectUnsupportedCodec) {
cricket::VideoReceiverParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
- parameters.codecs.push_back(cricket::CreateVideoCodec(101, "WTF3"));
+ parameters.codecs.push_back(webrtc::CreateVideoCodec(101, "WTF3"));
EXPECT_FALSE(receive_channel_->SetReceiverParameters(parameters));
}
@@ -7640,11 +7650,12 @@
uint8_t payload_type,
bool expect_created_receive_stream) {
// kRedRtxPayloadType must currently be unused.
- EXPECT_FALSE(FindCodecById(engine_.LegacyRecvCodecs(), kRedRtxPayloadType));
+ EXPECT_FALSE(
+ webrtc::FindCodecById(engine_.LegacyRecvCodecs(), kRedRtxPayloadType));
// Add a RED RTX codec.
- Codec red_rtx_codec = cricket::CreateVideoRtxCodec(kRedRtxPayloadType,
- GetEngineCodec("red").id);
+ webrtc::Codec red_rtx_codec =
+ webrtc::CreateVideoRtxCodec(kRedRtxPayloadType, GetEngineCodec("red").id);
recv_parameters_.codecs.push_back(red_rtx_codec);
EXPECT_TRUE(receive_channel_->SetReceiverParameters(recv_parameters_));
@@ -7689,7 +7700,7 @@
TEST_F(WebRtcVideoChannelTest, RtxPacketDoesntCreateUnsignalledStream) {
AssignDefaultAptRtxTypes();
- const cricket::Codec vp8 = GetEngineCodec("VP8");
+ const webrtc::Codec vp8 = GetEngineCodec("VP8");
const int rtx_vp8_payload_type = default_apt_rtx_types_[vp8.id];
TestReceiveUnsignaledSsrcPacket(rtx_vp8_payload_type,
false /* expect_created_receive_stream */);
@@ -7713,7 +7724,7 @@
TEST_F(WebRtcVideoChannelTest, RtxAfterMediaPacketUpdatesUnsignalledRtxSsrc) {
AssignDefaultAptRtxTypes();
- const cricket::Codec vp8 = GetEngineCodec("VP8");
+ const webrtc::Codec vp8 = GetEngineCodec("VP8");
const int payload_type = vp8.id;
const int rtx_vp8_payload_type = default_apt_rtx_types_[vp8.id];
const uint32_t ssrc = kIncomingUnsignalledSsrc;
@@ -7748,7 +7759,7 @@
TEST_F(WebRtcVideoChannelTest, UnsignaledStreamCreatedAfterMediaPacket) {
AssignDefaultAptRtxTypes();
- const cricket::Codec vp8 = GetEngineCodec("VP8");
+ const webrtc::Codec vp8 = GetEngineCodec("VP8");
const int payload_type = vp8.id;
const int rtx_vp8_payload_type = default_apt_rtx_types_[vp8.id];
const uint32_t ssrc = kIncomingUnsignalledSsrc;
@@ -7786,7 +7797,7 @@
parameters.codecs.push_back(GetEngineCodec("VP9"));
#if defined(WEBRTC_USE_H264)
- cricket::Codec H264codec = cricket::CreateVideoCodec(126, "H264");
+ webrtc::Codec H264codec = webrtc::CreateVideoCodec(126, "H264");
parameters.codecs.push_back(H264codec);
#endif
@@ -8256,7 +8267,7 @@
// Set up WebRtcVideoChannel for 3-layer simulcast.
encoder_factory_->AddSupportedVideoCodecType(codec_name);
VideoSenderParameters parameters;
- cricket::Codec codec = cricket::CreateVideoCodec(codec_name);
+ webrtc::Codec codec = webrtc::CreateVideoCodec(codec_name);
// Codec ID does not matter, but must be valid.
codec.id = 123;
parameters.codecs.push_back(codec);
@@ -9349,8 +9360,8 @@
webrtc::RtpParameters rtp_parameters =
send_channel_->GetRtpSendParameters(last_ssrc_);
EXPECT_EQ(3UL, rtp_parameters.encodings.size());
- cricket::Codec vp8 = GetEngineCodec("VP8");
- cricket::Codec vp9 = GetEngineCodec("VP9");
+ webrtc::Codec vp8 = GetEngineCodec("VP8");
+ webrtc::Codec vp9 = GetEngineCodec("VP9");
rtp_parameters.encodings[0].codec = vp8.ToCodecParameters();
rtp_parameters.encodings[1].codec = vp8.ToCodecParameters();
rtp_parameters.encodings[2].codec = vp9.ToCodecParameters();
@@ -9388,7 +9399,7 @@
AddSendStream();
cricket::VideoSenderParameters parameters;
- cricket::Codec vp8 = GetEngineCodec("VP8");
+ webrtc::Codec vp8 = GetEngineCodec("VP8");
parameters.codecs.push_back(vp8);
// `codec_settings_list.size()` is 1 after this in the
@@ -9639,10 +9650,10 @@
TEST_F(WebRtcVideoChannelTest, DISABLED_GetRtpReceiveFmtpSprop) {
#endif
cricket::VideoReceiverParameters parameters;
- cricket::Codec kH264sprop1 = cricket::CreateVideoCodec(101, "H264");
+ webrtc::Codec kH264sprop1 = webrtc::CreateVideoCodec(101, "H264");
kH264sprop1.SetParam(kH264FmtpSpropParameterSets, "uvw");
parameters.codecs.push_back(kH264sprop1);
- cricket::Codec kH264sprop2 = cricket::CreateVideoCodec(102, "H264");
+ webrtc::Codec kH264sprop2 = webrtc::CreateVideoCodec(102, "H264");
kH264sprop2.SetParam(kH264FmtpSpropParameterSets, "xyz");
parameters.codecs.push_back(kH264sprop2);
EXPECT_TRUE(receive_channel_->SetReceiverParameters(parameters));
@@ -9745,7 +9756,7 @@
AddReceiveStreamAfterReceivingNonPrimaryUnsignaledSsrc) {
// Receive VP8 RTX packet.
RtpPacketReceived rtp_packet;
- const cricket::Codec vp8 = GetEngineCodec("VP8");
+ const webrtc::Codec vp8 = GetEngineCodec("VP8");
rtp_packet.SetPayloadType(default_apt_rtx_types_[vp8.id]);
rtp_packet.SetSsrc(2);
ReceivePacketAndAdvanceTime(rtp_packet);
@@ -9961,7 +9972,7 @@
}
protected:
- void VerifySimulcastSettings(const Codec& codec_in,
+ void VerifySimulcastSettings(const webrtc::Codec& codec_in,
int capture_width,
int capture_height,
size_t num_configured_streams,
@@ -9970,7 +9981,7 @@
bool conference_mode) {
cricket::VideoSenderParameters parameters;
// The codec ID does not matter, but must be valid.
- Codec codec = codec_in;
+ webrtc::Codec codec = codec_in;
codec.id = 123;
parameters.codecs.push_back(codec);
parameters.conference_mode = conference_mode;
@@ -10117,33 +10128,33 @@
};
TEST_F(WebRtcVideoChannelSimulcastTest, SetSendCodecsWith2SimulcastStreams) {
- VerifySimulcastSettings(cricket::CreateVideoCodec("VP8"), 640, 360, 2, 2,
+ VerifySimulcastSettings(webrtc::CreateVideoCodec("VP8"), 640, 360, 2, 2,
false, true);
}
TEST_F(WebRtcVideoChannelSimulcastTest, SetSendCodecsWith3SimulcastStreams) {
- VerifySimulcastSettings(cricket::CreateVideoCodec("VP8"), 1280, 720, 3, 3,
+ VerifySimulcastSettings(webrtc::CreateVideoCodec("VP8"), 1280, 720, 3, 3,
false, true);
}
// Test that we normalize send codec format size in simulcast.
TEST_F(WebRtcVideoChannelSimulcastTest, SetSendCodecsWithOddSizeInSimulcast) {
- VerifySimulcastSettings(cricket::CreateVideoCodec("VP8"), 541, 271, 2, 2,
+ VerifySimulcastSettings(webrtc::CreateVideoCodec("VP8"), 541, 271, 2, 2,
false, true);
}
TEST_F(WebRtcVideoChannelSimulcastTest, SetSendCodecsForScreenshare) {
- VerifySimulcastSettings(cricket::CreateVideoCodec("VP8"), 1280, 720, 3, 3,
+ VerifySimulcastSettings(webrtc::CreateVideoCodec("VP8"), 1280, 720, 3, 3,
true, false);
}
TEST_F(WebRtcVideoChannelSimulcastTest, SetSendCodecsForSimulcastScreenshare) {
- VerifySimulcastSettings(cricket::CreateVideoCodec("VP8"), 1280, 720, 3, 2,
+ VerifySimulcastSettings(webrtc::CreateVideoCodec("VP8"), 1280, 720, 3, 2,
true, true);
}
TEST_F(WebRtcVideoChannelSimulcastTest, SimulcastScreenshareWithoutConference) {
- VerifySimulcastSettings(cricket::CreateVideoCodec("VP8"), 1280, 720, 3, 3,
+ VerifySimulcastSettings(webrtc::CreateVideoCodec("VP8"), 1280, 720, 3, 3,
true, false);
}
@@ -10207,7 +10218,7 @@
}
TEST_F(WebRtcVideoChannelBaseTest, EncoderSelectorSwitchCodec) {
- Codec vp9 = GetEngineCodec("VP9");
+ webrtc::Codec vp9 = GetEngineCodec("VP9");
cricket::VideoSenderParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
@@ -10215,7 +10226,7 @@
EXPECT_TRUE(send_channel_->SetSenderParameters(parameters));
send_channel_->SetSend(true);
- std::optional<Codec> codec = send_channel_->GetSendCodec();
+ std::optional<webrtc::Codec> codec = send_channel_->GetSendCodec();
ASSERT_TRUE(codec);
EXPECT_EQ("VP8", codec->name);
diff --git a/media/engine/webrtc_voice_engine.cc b/media/engine/webrtc_voice_engine.cc
index 5a9ef1c..a8ea5d2 100644
--- a/media/engine/webrtc_voice_engine.cc
+++ b/media/engine/webrtc_voice_engine.cc
@@ -151,7 +151,7 @@
}
// Dumps an AudioCodec in RFC 2327-ish format.
-std::string ToString(const Codec& codec) {
+std::string ToString(const webrtc::Codec& codec) {
rtc::StringBuilder ss;
ss << codec.name << "/" << codec.clockrate << "/" << codec.channels;
if (!codec.params.empty()) {
@@ -165,13 +165,13 @@
return ss.Release();
}
-bool IsCodec(const Codec& codec, const char* ref_name) {
+bool IsCodec(const webrtc::Codec& codec, const char* ref_name) {
return absl::EqualsIgnoreCase(codec.name, ref_name);
}
-std::optional<Codec> FindCodec(const std::vector<Codec>& codecs,
- const Codec& codec) {
- for (const Codec& c : codecs) {
+std::optional<webrtc::Codec> FindCodec(const std::vector<webrtc::Codec>& codecs,
+ const webrtc::Codec& codec) {
+ for (const webrtc::Codec& c : codecs) {
if (c.Matches(codec)) {
return c;
}
@@ -179,13 +179,13 @@
return std::nullopt;
}
-bool VerifyUniquePayloadTypes(const std::vector<Codec>& codecs) {
+bool VerifyUniquePayloadTypes(const std::vector<webrtc::Codec>& codecs) {
if (codecs.empty()) {
return true;
}
std::vector<int> payload_types;
absl::c_transform(codecs, std::back_inserter(payload_types),
- [](const Codec& codec) { return codec.id; });
+ [](const webrtc::Codec& codec) { return codec.id; });
absl::c_sort(payload_types);
return absl::c_adjacent_find(payload_types) == payload_types.end();
}
@@ -324,7 +324,7 @@
// Utility function to check if RED codec and its parameters match a codec spec.
bool CheckRedParameters(
- const Codec& red_codec,
+ const webrtc::Codec& red_codec,
const webrtc::AudioSendStream::Config::SendCodecSpec& send_codec_spec) {
if (red_codec.clockrate != send_codec_spec.format.clockrate_hz ||
red_codec.channels != send_codec_spec.format.num_channels) {
@@ -353,7 +353,7 @@
return true;
}
-webrtc::SdpAudioFormat AudioCodecToSdpAudioFormat(const Codec& ac) {
+webrtc::SdpAudioFormat AudioCodecToSdpAudioFormat(const webrtc::Codec& ac) {
return webrtc::SdpAudioFormat(ac.name, ac.clockrate, ac.channels, ac.params);
}
@@ -361,12 +361,12 @@
// This is a "preliminary" pass, done to prime the
// payload type picker with a normal set of PTs.
// TODO: https://issues.webrtc.org/360058654 - remove.
-std::vector<Codec> LegacyCollectCodecs(
+std::vector<webrtc::Codec> LegacyCollectCodecs(
const std::vector<webrtc::AudioCodecSpec>& specs,
bool allocate_pt) {
// Only used for the legacy "allocate_pt = true" case.
webrtc::PayloadTypePicker pt_mapper;
- std::vector<Codec> out;
+ std::vector<webrtc::Codec> out;
// Only generate CN payload types for these clockrates:
std::map<int, bool, std::greater<int>> generate_cn = {{8000, false}};
@@ -375,7 +375,7 @@
{48000, false}};
for (const auto& spec : specs) {
- cricket::Codec codec = CreateAudioCodec(spec.format);
+ webrtc::Codec codec = webrtc::CreateAudioCodec(spec.format);
if (allocate_pt) {
auto pt_or_error = pt_mapper.SuggestMapping(codec, nullptr);
// We need to do some extra stuff before adding the main codecs to out.
@@ -386,7 +386,7 @@
}
if (spec.info.supports_network_adaption) {
codec.AddFeedbackParam(
- FeedbackParam(kRtcpFbParamTransportCc, kParamValueEmpty));
+ webrtc::FeedbackParam(kRtcpFbParamTransportCc, kParamValueEmpty));
}
if (spec.info.allow_comfort_noise) {
@@ -412,14 +412,15 @@
if (allocate_pt) {
std::string red_fmtp =
absl::StrCat(codec.id) + "/" + absl::StrCat(codec.id);
- cricket::Codec red_codec = CreateAudioCodec(
+ webrtc::Codec red_codec = webrtc::CreateAudioCodec(
{kRedCodecName, codec.clockrate, codec.channels, {{"", red_fmtp}}});
red_codec.id = pt_mapper.SuggestMapping(red_codec, nullptr).value();
out.push_back(red_codec);
} else {
// We don't know the PT to put into the RED fmtp parameter yet.
// Leave it out.
- cricket::Codec red_codec = CreateAudioCodec({kRedCodecName, 48000, 2});
+ webrtc::Codec red_codec =
+ webrtc::CreateAudioCodec({kRedCodecName, 48000, 2});
out.push_back(red_codec);
}
}
@@ -428,7 +429,8 @@
// Add CN codecs after "proper" audio codecs.
for (const auto& cn : generate_cn) {
if (cn.second) {
- cricket::Codec cn_codec = CreateAudioCodec({kCnCodecName, cn.first, 1});
+ webrtc::Codec cn_codec =
+ webrtc::CreateAudioCodec({kCnCodecName, cn.first, 1});
if (allocate_pt) {
cn_codec.id = pt_mapper.SuggestMapping(cn_codec, nullptr).value();
}
@@ -439,8 +441,8 @@
// Add telephone-event codecs last.
for (const auto& dtmf : generate_dtmf) {
if (dtmf.second) {
- cricket::Codec dtmf_codec =
- CreateAudioCodec({kDtmfCodecName, dtmf.first, 1});
+ webrtc::Codec dtmf_codec =
+ webrtc::CreateAudioCodec({kDtmfCodecName, dtmf.first, 1});
if (allocate_pt) {
dtmf_codec.id = pt_mapper.SuggestMapping(dtmf_codec, nullptr).value();
}
@@ -506,7 +508,7 @@
send_codecs_ =
LegacyCollectCodecs(encoder_factory_->GetSupportedEncoders(),
!payload_types_in_transport_trial_enabled_);
- for (const Codec& codec : send_codecs_) {
+ for (const webrtc::Codec& codec : send_codecs_) {
RTC_LOG(LS_VERBOSE) << ToString(codec);
}
@@ -514,7 +516,7 @@
recv_codecs_ =
LegacyCollectCodecs(decoder_factory_->GetSupportedDecoders(),
!payload_types_in_transport_trial_enabled_);
- for (const Codec& codec : recv_codecs_) {
+ for (const webrtc::Codec& codec : recv_codecs_) {
RTC_LOG(LS_VERBOSE) << ToString(codec);
}
@@ -754,12 +756,12 @@
ap->ApplyConfig(apm_config);
}
-const std::vector<Codec>& WebRtcVoiceEngine::LegacySendCodecs() const {
+const std::vector<webrtc::Codec>& WebRtcVoiceEngine::LegacySendCodecs() const {
RTC_DCHECK(signal_thread_checker_.IsCurrent());
return send_codecs_;
}
-const std::vector<Codec>& WebRtcVoiceEngine::LegacyRecvCodecs() const {
+const std::vector<webrtc::Codec>& WebRtcVoiceEngine::LegacyRecvCodecs() const {
RTC_DCHECK(signal_thread_checker_.IsCurrent());
return recv_codecs_;
}
@@ -1320,7 +1322,7 @@
// all the information at once.
// Finding if the RtpParameters force a specific codec
- std::optional<Codec> force_codec;
+ std::optional<webrtc::Codec> force_codec;
if (send_streams_.size() == 1) {
// Since audio simulcast is not supported, currently, only PlanB
// has multiple tracks and we don't care about getting the
@@ -1388,9 +1390,9 @@
return SetOptions(params.options);
}
-std::optional<Codec> WebRtcVoiceSendChannel::GetSendCodec() const {
+std::optional<webrtc::Codec> WebRtcVoiceSendChannel::GetSendCodec() const {
if (send_codec_spec_) {
- return CreateAudioCodec(send_codec_spec_->format);
+ return webrtc::CreateAudioCodec(send_codec_spec_->format);
}
return std::nullopt;
}
@@ -1399,14 +1401,14 @@
// codec settings from the given list of codecs (originally from SDP). Both send
// and receive streams may be reconfigured based on the new settings.
bool WebRtcVoiceSendChannel::SetSendCodecs(
- const std::vector<Codec>& codecs,
- std::optional<Codec> preferred_codec) {
+ const std::vector<webrtc::Codec>& codecs,
+ std::optional<webrtc::Codec> preferred_codec) {
RTC_DCHECK_RUN_ON(worker_thread_);
dtmf_payload_type_ = std::nullopt;
dtmf_payload_freq_ = -1;
// Validate supplied codecs list.
- for (const Codec& codec : codecs) {
+ for (const webrtc::Codec& codec : codecs) {
// TODO(solenberg): Validate more aspects of input - that payload types
// don't overlap, remove redundant/unsupported codecs etc -
// the same way it is done for RtpHeaderExtensions.
@@ -1420,8 +1422,8 @@
// Find PT of telephone-event codec with lowest clockrate, as a fallback, in
// case we don't have a DTMF codec with a rate matching the send codec's, or
// if this function returns early.
- std::vector<Codec> dtmf_codecs;
- for (const Codec& codec : codecs) {
+ std::vector<webrtc::Codec> dtmf_codecs;
+ for (const webrtc::Codec& codec : codecs) {
if (IsCodec(codec, kDtmfCodecName)) {
dtmf_codecs.push_back(codec);
if (!dtmf_payload_type_ || codec.clockrate < dtmf_payload_freq_) {
@@ -1436,7 +1438,7 @@
webrtc::BitrateConstraints bitrate_config;
std::optional<webrtc::AudioCodecInfo> voice_codec_info;
size_t send_codec_position = 0;
- for (const Codec& voice_codec : codecs) {
+ for (const webrtc::Codec& voice_codec : codecs) {
if (!(IsCodec(voice_codec, kCnCodecName) ||
IsCodec(voice_codec, kDtmfCodecName) ||
IsCodec(voice_codec, kRedCodecName)) &&
@@ -1456,8 +1458,8 @@
if (voice_codec.bitrate > 0) {
send_codec_spec->target_bitrate_bps = voice_codec.bitrate;
}
- send_codec_spec->nack_enabled = HasNack(voice_codec);
- send_codec_spec->enable_non_sender_rtt = HasRrtr(voice_codec);
+ send_codec_spec->nack_enabled = webrtc::HasNack(voice_codec);
+ send_codec_spec->enable_non_sender_rtt = webrtc::HasRrtr(voice_codec);
bitrate_config = GetBitrateConfigForCodec(voice_codec);
break;
}
@@ -1473,7 +1475,7 @@
if (voice_codec_info->allow_comfort_noise) {
// Loop through the codecs list again to find the CN codec.
// TODO(solenberg): Break out into a separate function?
- for (const Codec& cn_codec : codecs) {
+ for (const webrtc::Codec& cn_codec : codecs) {
if (IsCodec(cn_codec, kCnCodecName) &&
cn_codec.clockrate == send_codec_spec->format.clockrate_hz &&
cn_codec.channels == voice_codec_info->num_channels) {
@@ -1491,7 +1493,7 @@
}
// Find the telephone-event PT exactly matching the preferred send codec.
- for (const Codec& dtmf_codec : dtmf_codecs) {
+ for (const webrtc::Codec& dtmf_codec : dtmf_codecs) {
if (dtmf_codec.clockrate == send_codec_spec->format.clockrate_hz) {
dtmf_payload_type_ = dtmf_codec.id;
dtmf_payload_freq_ = dtmf_codec.clockrate;
@@ -1505,7 +1507,7 @@
// RED codec needs to be negotiated before the actual codec they
// reference.
for (size_t i = 0; i < send_codec_position; ++i) {
- const Codec& red_codec = codecs[i];
+ const webrtc::Codec& red_codec = codecs[i];
if (IsCodec(red_codec, kRedCodecName) &&
CheckRedParameters(red_codec, *send_codec_spec)) {
send_codec_spec->red_payload_type = red_codec.id;
@@ -1836,9 +1838,11 @@
void WebRtcVoiceSendChannel::FillSendCodecStats(
VoiceMediaSendInfo* voice_media_info) {
for (const auto& sender : voice_media_info->senders) {
- auto codec = absl::c_find_if(send_codecs_, [&sender](const Codec& c) {
- return sender.codec_payload_type && *sender.codec_payload_type == c.id;
- });
+ auto codec =
+ absl::c_find_if(send_codecs_, [&sender](const webrtc::Codec& c) {
+ return sender.codec_payload_type &&
+ *sender.codec_payload_type == c.id;
+ });
if (codec != send_codecs_.end()) {
voice_media_info->send_codecs.insert(
std::make_pair(codec->id, codec->ToCodecParameters()));
@@ -1874,7 +1878,7 @@
webrtc::RtpParameters rtp_params = it->second->rtp_parameters();
// Need to add the common list of codecs to the send stream-specific
// RTP parameters.
- for (const Codec& codec : send_codecs_) {
+ for (const webrtc::Codec& codec : send_codecs_) {
rtp_params.codecs.push_back(codec.ToCodecParameters());
}
return rtp_params;
@@ -1924,7 +1928,7 @@
}
SetPreferredDscp(new_dscp);
- std::optional<cricket::Codec> send_codec = GetSendCodec();
+ std::optional<webrtc::Codec> send_codec = GetSendCodec();
// Since we validate that all layers have the same value, we can just check
// the first layer.
// TODO: https://issues.webrtc.org/362277533 - Support mixed-codec simulcast
@@ -2158,7 +2162,7 @@
rtp_params.encodings.back().ssrc = it->second->stream().remote_ssrc();
rtp_params.header_extensions = recv_rtp_extensions_;
- for (const Codec& codec : recv_codecs_) {
+ for (const webrtc::Codec& codec : recv_codecs_) {
rtp_params.codecs.push_back(codec.ToCodecParameters());
}
rtp_params.rtcp.reduced_size =
@@ -2178,7 +2182,7 @@
}
rtp_params.encodings.emplace_back();
- for (const Codec& codec : recv_codecs_) {
+ for (const webrtc::Codec& codec : recv_codecs_) {
rtp_params.codecs.push_back(codec.ToCodecParameters());
}
return rtp_params;
@@ -2200,7 +2204,7 @@
}
bool WebRtcVoiceReceiveChannel::SetRecvCodecs(
- const std::vector<Codec>& codecs_in) {
+ const std::vector<webrtc::Codec>& codecs_in) {
RTC_DCHECK_RUN_ON(worker_thread_);
auto codecs = codecs_in;
@@ -2223,10 +2227,10 @@
// Create a payload type -> SdpAudioFormat map with all the decoders. Fail
// unless the factory claims to support all decoders.
std::map<int, webrtc::SdpAudioFormat> decoder_map;
- for (const Codec& codec : codecs) {
+ for (const webrtc::Codec& codec : codecs) {
// Log a warning if a codec's payload type is changing. This used to be
// treated as an error. It's abnormal, but not really illegal.
- std::optional<Codec> old_codec = FindCodec(recv_codecs_, codec);
+ std::optional<webrtc::Codec> old_codec = FindCodec(recv_codecs_, codec);
if (old_codec && old_codec->id != codec.id) {
RTC_LOG(LS_WARNING) << codec.name << " mapped to a second payload type ("
<< codec.id << ", was already mapped to "
@@ -2730,10 +2734,11 @@
void WebRtcVoiceReceiveChannel::FillReceiveCodecStats(
VoiceMediaReceiveInfo* voice_media_info) {
for (const auto& receiver : voice_media_info->receivers) {
- auto codec = absl::c_find_if(recv_codecs_, [&receiver](const Codec& c) {
- return receiver.codec_payload_type &&
- *receiver.codec_payload_type == c.id;
- });
+ auto codec =
+ absl::c_find_if(recv_codecs_, [&receiver](const webrtc::Codec& c) {
+ return receiver.codec_payload_type &&
+ *receiver.codec_payload_type == c.id;
+ });
if (codec != recv_codecs_.end()) {
voice_media_info->receive_codecs.insert(
std::make_pair(codec->id, codec->ToCodecParameters()));
diff --git a/media/engine/webrtc_voice_engine.h b/media/engine/webrtc_voice_engine.h
index f83aef5..3e8f101 100644
--- a/media/engine/webrtc_voice_engine.h
+++ b/media/engine/webrtc_voice_engine.h
@@ -116,8 +116,8 @@
const webrtc::CryptoOptions& crypto_options,
webrtc::AudioCodecPairId codec_pair_id) override;
- const std::vector<Codec>& LegacySendCodecs() const override;
- const std::vector<Codec>& LegacyRecvCodecs() const override;
+ const std::vector<webrtc::Codec>& LegacySendCodecs() const override;
+ const std::vector<webrtc::Codec>& LegacyRecvCodecs() const override;
webrtc::AudioEncoderFactory* encoder_factory() const override {
return encoder_factory_.get();
@@ -170,8 +170,8 @@
std::unique_ptr<webrtc::AudioFrameProcessor> audio_frame_processor_;
// The primary instance of WebRtc VoiceEngine.
rtc::scoped_refptr<webrtc::AudioState> audio_state_;
- std::vector<Codec> send_codecs_;
- std::vector<Codec> recv_codecs_;
+ std::vector<webrtc::Codec> send_codecs_;
+ std::vector<webrtc::Codec> recv_codecs_;
bool is_dumping_aec_ = false;
bool initialized_ = false;
@@ -209,7 +209,7 @@
}
VoiceMediaSendChannelInterface* AsVoiceSendChannel() override { return this; }
- std::optional<Codec> GetSendCodec() const override;
+ std::optional<webrtc::Codec> GetSendCodec() const override;
// Functions imported from MediaChannelUtil
void SetInterface(MediaChannelNetworkInterface* iface) override {
@@ -292,8 +292,8 @@
private:
bool SetOptions(const AudioOptions& options);
- bool SetSendCodecs(const std::vector<Codec>& codecs,
- std::optional<Codec> preferred_codec);
+ bool SetSendCodecs(const std::vector<webrtc::Codec>& codecs,
+ std::optional<webrtc::Codec> preferred_codec);
bool SetLocalSource(uint32_t ssrc, AudioSource* source);
bool MuteStream(uint32_t ssrc, bool mute);
@@ -307,7 +307,7 @@
webrtc::SequenceChecker::kDetached};
WebRtcVoiceEngine* const engine_ = nullptr;
- std::vector<Codec> send_codecs_;
+ std::vector<webrtc::Codec> send_codecs_;
int max_send_bitrate_bps_ = 0;
AudioOptions options_;
@@ -440,7 +440,7 @@
private:
bool SetOptions(const AudioOptions& options);
- bool SetRecvCodecs(const std::vector<Codec>& codecs);
+ bool SetRecvCodecs(const std::vector<webrtc::Codec>& codecs);
bool SetLocalSource(uint32_t ssrc, AudioSource* source);
bool MuteStream(uint32_t ssrc, bool mute);
@@ -465,7 +465,7 @@
// TODO(kwiberg): decoder_map_ and recv_codecs_ store the exact same
// information, in slightly different formats. Eliminate recv_codecs_.
std::map<int, webrtc::SdpAudioFormat> decoder_map_;
- std::vector<Codec> recv_codecs_;
+ std::vector<webrtc::Codec> recv_codecs_;
AudioOptions options_;
bool recv_nack_enabled_ = false;
diff --git a/media/engine/webrtc_voice_engine_unittest.cc b/media/engine/webrtc_voice_engine_unittest.cc
index 1db9c22..7b1b09a 100644
--- a/media/engine/webrtc_voice_engine_unittest.cc
+++ b/media/engine/webrtc_voice_engine_unittest.cc
@@ -100,25 +100,24 @@
constexpr uint32_t kMaxUnsignaledRecvStreams = 4;
-const cricket::Codec kPcmuCodec = cricket::CreateAudioCodec(0, "PCMU", 8000, 1);
-const cricket::Codec kOpusCodec =
- cricket::CreateAudioCodec(111, "opus", 48000, 2);
-const cricket::Codec kG722CodecVoE =
- cricket::CreateAudioCodec(9, "G722", 16000, 1);
-const cricket::Codec kG722CodecSdp =
- cricket::CreateAudioCodec(9, "G722", 8000, 1);
-const cricket::Codec kCn8000Codec =
- cricket::CreateAudioCodec(13, "CN", 8000, 1);
-const cricket::Codec kCn16000Codec =
- cricket::CreateAudioCodec(105, "CN", 16000, 1);
-const cricket::Codec kRed48000Codec =
- cricket::CreateAudioCodec(112, "RED", 48000, 2);
-const cricket::Codec kTelephoneEventCodec1 =
- cricket::CreateAudioCodec(106, "telephone-event", 8000, 1);
-const cricket::Codec kTelephoneEventCodec2 =
- cricket::CreateAudioCodec(107, "telephone-event", 32000, 1);
-const cricket::Codec kUnknownCodec =
- cricket::CreateAudioCodec(127, "XYZ", 32000, 1);
+const webrtc::Codec kPcmuCodec = webrtc::CreateAudioCodec(0, "PCMU", 8000, 1);
+const webrtc::Codec kOpusCodec =
+ webrtc::CreateAudioCodec(111, "opus", 48000, 2);
+const webrtc::Codec kG722CodecVoE =
+ webrtc::CreateAudioCodec(9, "G722", 16000, 1);
+const webrtc::Codec kG722CodecSdp =
+ webrtc::CreateAudioCodec(9, "G722", 8000, 1);
+const webrtc::Codec kCn8000Codec = webrtc::CreateAudioCodec(13, "CN", 8000, 1);
+const webrtc::Codec kCn16000Codec =
+ webrtc::CreateAudioCodec(105, "CN", 16000, 1);
+const webrtc::Codec kRed48000Codec =
+ webrtc::CreateAudioCodec(112, "RED", 48000, 2);
+const webrtc::Codec kTelephoneEventCodec1 =
+ webrtc::CreateAudioCodec(106, "telephone-event", 8000, 1);
+const webrtc::Codec kTelephoneEventCodec2 =
+ webrtc::CreateAudioCodec(107, "telephone-event", 32000, 1);
+const webrtc::Codec kUnknownCodec =
+ webrtc::CreateAudioCodec(127, "XYZ", 32000, 1);
const uint32_t kSsrc0 = 0;
const uint32_t kSsrc1 = 1;
@@ -186,12 +185,12 @@
EXPECT_CALL(*adm, Terminate()).WillOnce(Return(0));
}
-std::vector<cricket::Codec> AddIdToCodecs(
+std::vector<webrtc::Codec> AddIdToCodecs(
webrtc::PayloadTypePicker& pt_mapper,
- std::vector<cricket::Codec>&& codecs_in) {
- std::vector<cricket::Codec> codecs = std::move(codecs_in);
- for (cricket::Codec& codec : codecs) {
- if (codec.id == cricket::Codec::kIdNotSet) {
+ std::vector<webrtc::Codec>&& codecs_in) {
+ std::vector<webrtc::Codec> codecs = std::move(codecs_in);
+ for (webrtc::Codec& codec : codecs) {
+ if (codec.id == webrtc::Codec::kIdNotSet) {
auto id_or_error = pt_mapper.SuggestMapping(codec, nullptr);
EXPECT_TRUE(id_or_error.ok());
if (id_or_error.ok()) {
@@ -202,10 +201,10 @@
return codecs;
}
-std::vector<cricket::Codec> ReceiveCodecsWithId(
+std::vector<webrtc::Codec> ReceiveCodecsWithId(
cricket::WebRtcVoiceEngine& engine) {
webrtc::PayloadTypePicker pt_mapper;
- std::vector<cricket::Codec> codecs = engine.LegacyRecvCodecs();
+ std::vector<webrtc::Codec> codecs = engine.LegacyRecvCodecs();
return AddIdToCodecs(pt_mapper, std::move(codecs));
}
@@ -419,7 +418,7 @@
EXPECT_TRUE(send_channel_->SetAudioSend(ssrc, enable, options, source));
}
- void TestInsertDtmf(uint32_t ssrc, bool caller, const cricket::Codec& codec) {
+ void TestInsertDtmf(uint32_t ssrc, bool caller, const webrtc::Codec& codec) {
EXPECT_TRUE(SetupChannel());
if (caller) {
// If this is a caller, local description will be applied and add the
@@ -488,7 +487,7 @@
// `max_bitrate` is a parameter to set to SetMaxSendBandwidth().
// `expected_result` is the expected result from SetMaxSendBandwidth().
// `expected_bitrate` is the expected audio bitrate afterward.
- void TestMaxSendBandwidth(const cricket::Codec& codec,
+ void TestMaxSendBandwidth(const webrtc::Codec& codec,
int max_bitrate,
bool expected_result,
int expected_bitrate) {
@@ -513,7 +512,7 @@
return send_channel_->SetRtpSendParameters(ssrc, parameters).ok();
}
- void SetGlobalMaxBitrate(const cricket::Codec& codec, int bitrate) {
+ void SetGlobalMaxBitrate(const webrtc::Codec& codec, int bitrate) {
cricket::AudioSenderParameter send_parameters;
send_parameters.codecs.push_back(codec);
send_parameters.max_bandwidth_bps = bitrate;
@@ -544,7 +543,7 @@
return GetSendStreamConfig(ssrc).audio_network_adaptor_config;
}
- void SetAndExpectMaxBitrate(const cricket::Codec& codec,
+ void SetAndExpectMaxBitrate(const webrtc::Codec& codec,
int global_max,
int stream_max,
bool expected_result,
@@ -854,14 +853,14 @@
const cricket::VoiceMediaSendInfo& send_info,
const cricket::VoiceMediaReceiveInfo& receive_info) const {
EXPECT_EQ(send_parameters_.codecs.size(), send_info.send_codecs.size());
- for (const cricket::Codec& codec : send_parameters_.codecs) {
+ for (const webrtc::Codec& codec : send_parameters_.codecs) {
ASSERT_EQ(send_info.send_codecs.count(codec.id), 1U);
EXPECT_EQ(send_info.send_codecs.find(codec.id)->second,
codec.ToCodecParameters());
}
EXPECT_EQ(recv_parameters_.codecs.size(),
receive_info.receive_codecs.size());
- for (const cricket::Codec& codec : recv_parameters_.codecs) {
+ for (const webrtc::Codec& codec : recv_parameters_.codecs) {
ASSERT_EQ(receive_info.receive_codecs.count(codec.id), 1U);
EXPECT_EQ(receive_info.receive_codecs.find(codec.id)->second,
codec.ToCodecParameters());
@@ -906,8 +905,8 @@
return static_cast<cricket::WebRtcVoiceReceiveChannel*>(
receive_channel_.get());
}
- std::vector<cricket::Codec> SendCodecsWithId() {
- std::vector<cricket::Codec> codecs = engine_->LegacySendCodecs();
+ std::vector<webrtc::Codec> SendCodecsWithId() {
+ std::vector<webrtc::Codec> codecs = engine_->LegacySendCodecs();
return AddIdToCodecs(pt_mapper_, std::move(codecs));
}
@@ -1993,7 +1992,7 @@
EXPECT_TRUE(SetupRecvStream());
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
- parameters.codecs[0].AddFeedbackParam(cricket::FeedbackParam(
+ parameters.codecs[0].AddFeedbackParam(webrtc::FeedbackParam(
cricket::kRtcpFbParamNack, cricket::kParamValueEmpty));
EXPECT_EQ(0, GetRecvStreamConfig(kSsrcX).rtp.nack.rtp_history_ms);
SetSenderParameters(parameters);
@@ -2010,7 +2009,7 @@
EXPECT_TRUE(AddRecvStream(kSsrcY));
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
- parameters.codecs[0].AddFeedbackParam(cricket::FeedbackParam(
+ parameters.codecs[0].AddFeedbackParam(webrtc::FeedbackParam(
cricket::kRtcpFbParamNack, cricket::kParamValueEmpty));
EXPECT_EQ(0, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms);
SetSenderParameters(parameters);
@@ -2023,7 +2022,7 @@
EXPECT_TRUE(AddRecvStream(kSsrcY));
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
- parameters.codecs[0].AddFeedbackParam(cricket::FeedbackParam(
+ parameters.codecs[0].AddFeedbackParam(webrtc::FeedbackParam(
cricket::kRtcpFbParamNack, cricket::kParamValueEmpty));
SetSenderParameters(parameters);
EXPECT_EQ(kRtpHistoryMs, GetRecvStreamConfig(kSsrcY).rtp.nack.rtp_history_ms);
@@ -2040,7 +2039,7 @@
cricket::AudioSenderParameter parameters;
parameters.codecs.push_back(kOpusCodec);
parameters.codecs.push_back(kCn16000Codec);
- parameters.codecs[0].AddFeedbackParam(cricket::FeedbackParam(
+ parameters.codecs[0].AddFeedbackParam(webrtc::FeedbackParam(
cricket::kRtcpFbParamNack, cricket::kParamValueEmpty));
SetSenderParameters(parameters);
@@ -3903,7 +3902,7 @@
webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), nullptr, apm,
nullptr, env.field_trials());
engine.Init();
- for (const cricket::Codec& codec : engine.LegacySendCodecs()) {
+ for (const webrtc::Codec& codec : engine.LegacySendCodecs()) {
auto is_codec = [&codec](const char* name, int clockrate = 0) {
return absl::EqualsIgnoreCase(codec.name, name) &&
(clockrate == 0 || codec.clockrate == clockrate);
@@ -4028,7 +4027,7 @@
webrtc::CryptoOptions(), call.get(), webrtc::AudioCodecPairId::Create());
{
cricket::AudioSenderParameter params;
- params.codecs.push_back(cricket::CreateAudioCodec(1, "opus", 48000, 2));
+ params.codecs.push_back(webrtc::CreateAudioCodec(1, "opus", 48000, 2));
params.extensions.push_back(webrtc::RtpExtension(
webrtc::RtpExtension::kTransportSequenceNumberUri, 1));
EXPECT_TRUE(channel.SetSenderParameters(params));
@@ -4088,9 +4087,9 @@
// Rather than just ASSERTing that there are enough codecs, ensure that we
// can check the actual values safely, to provide better test results.
- auto get_codec = [&codecs](size_t index) -> const cricket::Codec& {
- static const cricket::Codec missing_codec =
- cricket::CreateAudioCodec(0, "<missing>", 0, 0);
+ auto get_codec = [&codecs](size_t index) -> const webrtc::Codec& {
+ static const webrtc::Codec missing_codec =
+ webrtc::CreateAudioCodec(0, "<missing>", 0, 0);
if (codecs.size() > index)
return codecs[index];
return missing_codec;
@@ -4108,7 +4107,7 @@
// check supplementary codecs are ordered after the general codecs.
auto find_codec = [&codecs](const webrtc::SdpAudioFormat& format) -> int {
for (size_t i = 0; i != codecs.size(); ++i) {
- const cricket::Codec& codec = codecs[i];
+ const webrtc::Codec& codec = codecs[i];
if (absl::EqualsIgnoreCase(codec.name, format.name) &&
codec.clockrate == format.clockrate_hz &&
codec.channels == format.num_channels) {
@@ -4175,9 +4174,9 @@
// Rather than just ASSERTing that there are enough codecs, ensure that we
// can check the actual values safely, to provide better test results.
- auto get_codec = [&codecs](size_t index) -> const cricket::Codec& {
- static const cricket::Codec missing_codec =
- cricket::CreateAudioCodec(0, "<missing>", 0, 0);
+ auto get_codec = [&codecs](size_t index) -> const webrtc::Codec& {
+ static const webrtc::Codec missing_codec =
+ webrtc::CreateAudioCodec(0, "<missing>", 0, 0);
if (codecs.size() > index)
return codecs[index];
return missing_codec;
@@ -4195,7 +4194,7 @@
// check supplementary codecs are ordered after the general codecs.
auto find_codec = [&codecs](const webrtc::SdpAudioFormat& format) -> int {
for (size_t i = 0; i != codecs.size(); ++i) {
- const cricket::Codec& codec = codecs[i];
+ const webrtc::Codec& codec = codecs[i];
if (absl::EqualsIgnoreCase(codec.name, format.name) &&
codec.clockrate == format.clockrate_hz &&
codec.channels == format.num_channels) {
diff --git a/pc/channel.cc b/pc/channel.cc
index c00b952..5fef525 100644
--- a/pc/channel.cc
+++ b/pc/channel.cc
@@ -919,7 +919,7 @@
bool criteria_modified = false;
if (webrtc::RtpTransceiverDirectionHasRecv(content->direction())) {
- for (const cricket::Codec& codec : content->codecs()) {
+ for (const Codec& codec : content->codecs()) {
if (MaybeAddHandledPayloadType(codec.id)) {
criteria_modified = true;
}
@@ -1068,23 +1068,23 @@
// instead.
bool needs_send_params_update = false;
if (type == SdpType::kAnswer || type == SdpType::kPrAnswer) {
- flat_set<const cricket::Codec*> matched_codecs;
- for (cricket::Codec& send_codec : send_params.codecs) {
- if (absl::c_any_of(matched_codecs, [&](const cricket::Codec* c) {
+ flat_set<const Codec*> matched_codecs;
+ for (Codec& send_codec : send_params.codecs) {
+ if (absl::c_any_of(matched_codecs, [&](const Codec* c) {
return send_codec.Matches(*c);
})) {
continue;
}
- std::vector<const cricket::Codec*> recv_codecs =
- cricket::FindAllMatchingCodecs(recv_params.codecs, send_codec);
+ std::vector<const Codec*> recv_codecs =
+ FindAllMatchingCodecs(recv_params.codecs, send_codec);
if (recv_codecs.empty()) {
continue;
}
bool may_ignore_packetization = false;
bool has_matching_packetization = false;
- for (const cricket::Codec* recv_codec : recv_codecs) {
+ for (const Codec* recv_codec : recv_codecs) {
if (!recv_codec->packetization.has_value() &&
send_codec.packetization.has_value()) {
may_ignore_packetization = true;
@@ -1121,7 +1121,7 @@
bool criteria_modified = false;
if (webrtc::RtpTransceiverDirectionHasRecv(content->direction())) {
- for (const cricket::Codec& codec : content->codecs()) {
+ for (const Codec& codec : content->codecs()) {
if (MaybeAddHandledPayloadType(codec.id))
criteria_modified = true;
}
@@ -1182,23 +1182,23 @@
// instead.
bool needs_recv_params_update = false;
if (type == SdpType::kAnswer || type == SdpType::kPrAnswer) {
- flat_set<const cricket::Codec*> matched_codecs;
- for (cricket::Codec& recv_codec : recv_params.codecs) {
- if (absl::c_any_of(matched_codecs, [&](const cricket::Codec* c) {
+ flat_set<const Codec*> matched_codecs;
+ for (Codec& recv_codec : recv_params.codecs) {
+ if (absl::c_any_of(matched_codecs, [&](const Codec* c) {
return recv_codec.Matches(*c);
})) {
continue;
}
- std::vector<const cricket::Codec*> send_codecs =
- cricket::FindAllMatchingCodecs(send_params.codecs, recv_codec);
+ std::vector<const Codec*> send_codecs =
+ FindAllMatchingCodecs(send_params.codecs, recv_codec);
if (send_codecs.empty()) {
continue;
}
bool may_ignore_packetization = false;
bool has_matching_packetization = false;
- for (const cricket::Codec* send_codec : send_codecs) {
+ for (const Codec* send_codec : send_codecs) {
if (!send_codec->packetization.has_value() &&
recv_codec.packetization.has_value()) {
may_ignore_packetization = true;
diff --git a/pc/channel_unittest.cc b/pc/channel_unittest.cc
index dccc6d5..dbfd787 100644
--- a/pc/channel_unittest.cc
+++ b/pc/channel_unittest.cc
@@ -79,14 +79,12 @@
using ::webrtc::RtpTransceiverDirection;
using ::webrtc::SdpType;
-const cricket::Codec kPcmuCodec =
- cricket::CreateAudioCodec(0, "PCMU", 64000, 1);
-const cricket::Codec kPcmaCodec =
- cricket::CreateAudioCodec(8, "PCMA", 64000, 1);
-const cricket::Codec kIsacCodec =
- cricket::CreateAudioCodec(103, "ISAC", 40000, 1);
-const cricket::Codec kH264Codec = cricket::CreateVideoCodec(97, "H264");
-const cricket::Codec kH264SvcCodec = cricket::CreateVideoCodec(99, "H264-SVC");
+const webrtc::Codec kPcmuCodec = webrtc::CreateAudioCodec(0, "PCMU", 64000, 1);
+const webrtc::Codec kPcmaCodec = webrtc::CreateAudioCodec(8, "PCMA", 64000, 1);
+const webrtc::Codec kIsacCodec =
+ webrtc::CreateAudioCodec(103, "ISAC", 40000, 1);
+const webrtc::Codec kH264Codec = webrtc::CreateVideoCodec(97, "H264");
+const webrtc::Codec kH264SvcCodec = webrtc::CreateVideoCodec(99, "H264-SVC");
const uint32_t kSsrc1 = 0x1111;
const uint32_t kSsrc2 = 0x2222;
const uint32_t kSsrc3 = 0x3333;
@@ -535,8 +533,8 @@
bool CheckNoRtp2() { return media_send_channel2_impl()->CheckNoRtp(); }
void CreateContent(int flags,
- const cricket::Codec& audio_codec,
- const cricket::Codec& video_codec,
+ const webrtc::Codec& audio_codec,
+ const webrtc::Codec& video_codec,
typename T::Content* content) {
// overridden in specialized classes
}
@@ -1617,8 +1615,8 @@
template <>
void ChannelTest<VoiceTraits>::CreateContent(
int flags,
- const cricket::Codec& audio_codec,
- const cricket::Codec& video_codec,
+ const webrtc::Codec& audio_codec,
+ const webrtc::Codec& video_codec,
webrtc::AudioContentDescription* audio) {
audio->AddCodec(audio_codec);
audio->set_rtcp_mux((flags & RTCP_MUX) != 0);
@@ -1697,8 +1695,8 @@
template <>
void ChannelTest<VideoTraits>::CreateContent(
int flags,
- const cricket::Codec& audio_codec,
- const cricket::Codec& video_codec,
+ const webrtc::Codec& audio_codec,
+ const webrtc::Codec& video_codec,
webrtc::VideoContentDescription* video) {
video->AddCodec(video_codec);
video->set_rtcp_mux((flags & RTCP_MUX) != 0);
@@ -2154,8 +2152,8 @@
}
TEST_F(VideoChannelSingleThreadTest, TestSetLocalOfferWithPacketization) {
- const cricket::Codec kVp8Codec = cricket::CreateVideoCodec(97, "VP8");
- cricket::Codec vp9_codec = cricket::CreateVideoCodec(98, "VP9");
+ const webrtc::Codec kVp8Codec = webrtc::CreateVideoCodec(97, "VP8");
+ webrtc::Codec vp9_codec = webrtc::CreateVideoCodec(98, "VP9");
vp9_codec.packetization = cricket::kPacketizationParamRaw;
webrtc::VideoContentDescription video;
video.set_codecs({kVp8Codec, vp9_codec});
@@ -2177,8 +2175,8 @@
}
TEST_F(VideoChannelSingleThreadTest, TestSetRemoteOfferWithPacketization) {
- const cricket::Codec kVp8Codec = cricket::CreateVideoCodec(97, "VP8");
- cricket::Codec vp9_codec = cricket::CreateVideoCodec(98, "VP9");
+ const webrtc::Codec kVp8Codec = webrtc::CreateVideoCodec(97, "VP8");
+ webrtc::Codec vp9_codec = webrtc::CreateVideoCodec(98, "VP9");
vp9_codec.packetization = cricket::kPacketizationParamRaw;
webrtc::VideoContentDescription video;
video.set_codecs({kVp8Codec, vp9_codec});
@@ -2199,8 +2197,8 @@
}
TEST_F(VideoChannelSingleThreadTest, TestSetAnswerWithPacketization) {
- const cricket::Codec kVp8Codec = cricket::CreateVideoCodec(97, "VP8");
- cricket::Codec vp9_codec = cricket::CreateVideoCodec(98, "VP9");
+ const webrtc::Codec kVp8Codec = webrtc::CreateVideoCodec(97, "VP8");
+ webrtc::Codec vp9_codec = webrtc::CreateVideoCodec(98, "VP9");
vp9_codec.packetization = cricket::kPacketizationParamRaw;
webrtc::VideoContentDescription video;
video.set_codecs({kVp8Codec, vp9_codec});
@@ -2231,8 +2229,8 @@
}
TEST_F(VideoChannelSingleThreadTest, TestSetLocalAnswerWithoutPacketization) {
- const cricket::Codec kLocalCodec = cricket::CreateVideoCodec(98, "VP8");
- cricket::Codec remote_codec = cricket::CreateVideoCodec(99, "VP8");
+ const webrtc::Codec kLocalCodec = webrtc::CreateVideoCodec(98, "VP8");
+ webrtc::Codec remote_codec = webrtc::CreateVideoCodec(99, "VP8");
remote_codec.packetization = cricket::kPacketizationParamRaw;
webrtc::VideoContentDescription local_video;
local_video.set_codecs({kLocalCodec});
@@ -2253,9 +2251,9 @@
}
TEST_F(VideoChannelSingleThreadTest, TestSetRemoteAnswerWithoutPacketization) {
- cricket::Codec local_codec = cricket::CreateVideoCodec(98, "VP8");
+ webrtc::Codec local_codec = webrtc::CreateVideoCodec(98, "VP8");
local_codec.packetization = cricket::kPacketizationParamRaw;
- const cricket::Codec kRemoteCodec = cricket::CreateVideoCodec(99, "VP8");
+ const webrtc::Codec kRemoteCodec = webrtc::CreateVideoCodec(99, "VP8");
webrtc::VideoContentDescription local_video;
local_video.set_codecs({local_codec});
webrtc::VideoContentDescription remote_video;
@@ -2277,9 +2275,9 @@
TEST_F(VideoChannelSingleThreadTest,
TestSetRemoteAnswerWithInvalidPacketization) {
- cricket::Codec local_codec = cricket::CreateVideoCodec(98, "VP8");
+ webrtc::Codec local_codec = webrtc::CreateVideoCodec(98, "VP8");
local_codec.packetization = cricket::kPacketizationParamRaw;
- cricket::Codec remote_codec = cricket::CreateVideoCodec(99, "VP8");
+ webrtc::Codec remote_codec = webrtc::CreateVideoCodec(99, "VP8");
remote_codec.packetization = "unknownpacketizationattributevalue";
webrtc::VideoContentDescription local_video;
local_video.set_codecs({local_codec});
@@ -2302,9 +2300,9 @@
TEST_F(VideoChannelSingleThreadTest,
TestSetLocalAnswerWithInvalidPacketization) {
- cricket::Codec local_codec = cricket::CreateVideoCodec(98, "VP8");
+ webrtc::Codec local_codec = webrtc::CreateVideoCodec(98, "VP8");
local_codec.packetization = cricket::kPacketizationParamRaw;
- const cricket::Codec kRemoteCodec = cricket::CreateVideoCodec(99, "VP8");
+ const webrtc::Codec kRemoteCodec = webrtc::CreateVideoCodec(99, "VP8");
webrtc::VideoContentDescription local_video;
local_video.set_codecs({local_codec});
webrtc::VideoContentDescription remote_video;
@@ -2325,12 +2323,12 @@
TEST_F(VideoChannelSingleThreadTest,
StopsPacketizationVerificationWhenMatchIsFoundInRemoteAnswer) {
- cricket::Codec vp8_foo = cricket::CreateVideoCodec(96, "VP8");
+ webrtc::Codec vp8_foo = webrtc::CreateVideoCodec(96, "VP8");
vp8_foo.packetization = "foo";
- cricket::Codec vp8_bar = cricket::CreateVideoCodec(97, "VP8");
+ webrtc::Codec vp8_bar = webrtc::CreateVideoCodec(97, "VP8");
vp8_bar.packetization = "bar";
- cricket::Codec vp9 = cricket::CreateVideoCodec(98, "VP9");
- cricket::Codec vp9_foo = cricket::CreateVideoCodec(99, "VP9");
+ webrtc::Codec vp9 = webrtc::CreateVideoCodec(98, "VP9");
+ webrtc::Codec vp9_foo = webrtc::CreateVideoCodec(99, "VP9");
vp9_foo.packetization = "bar";
webrtc::VideoContentDescription local;
local.set_codecs({vp8_foo, vp8_bar, vp9_foo});
@@ -2345,28 +2343,28 @@
EXPECT_THAT(
media_receive_channel1_impl()->recv_codecs(),
- ElementsAre(AllOf(Field(&cricket::Codec::id, 96),
- Field(&cricket::Codec::packetization, "foo")),
- AllOf(Field(&cricket::Codec::id, 97),
- Field(&cricket::Codec::packetization, "bar")),
- AllOf(Field(&cricket::Codec::id, 99),
- Field(&cricket::Codec::packetization, std::nullopt))));
+ ElementsAre(AllOf(Field(&webrtc::Codec::id, 96),
+ Field(&webrtc::Codec::packetization, "foo")),
+ AllOf(Field(&webrtc::Codec::id, 97),
+ Field(&webrtc::Codec::packetization, "bar")),
+ AllOf(Field(&webrtc::Codec::id, 99),
+ Field(&webrtc::Codec::packetization, std::nullopt))));
EXPECT_THAT(
media_send_channel1_impl()->send_codecs(),
- ElementsAre(AllOf(Field(&cricket::Codec::id, 96),
- Field(&cricket::Codec::packetization, "foo")),
- AllOf(Field(&cricket::Codec::id, 98),
- Field(&cricket::Codec::packetization, std::nullopt))));
+ ElementsAre(AllOf(Field(&webrtc::Codec::id, 96),
+ Field(&webrtc::Codec::packetization, "foo")),
+ AllOf(Field(&webrtc::Codec::id, 98),
+ Field(&webrtc::Codec::packetization, std::nullopt))));
}
TEST_F(VideoChannelSingleThreadTest,
StopsPacketizationVerificationWhenMatchIsFoundInLocalAnswer) {
- cricket::Codec vp8_foo = cricket::CreateVideoCodec(96, "VP8");
+ webrtc::Codec vp8_foo = webrtc::CreateVideoCodec(96, "VP8");
vp8_foo.packetization = "foo";
- cricket::Codec vp8_bar = cricket::CreateVideoCodec(97, "VP8");
+ webrtc::Codec vp8_bar = webrtc::CreateVideoCodec(97, "VP8");
vp8_bar.packetization = "bar";
- cricket::Codec vp9 = cricket::CreateVideoCodec(98, "VP9");
- cricket::Codec vp9_foo = cricket::CreateVideoCodec(99, "VP9");
+ webrtc::Codec vp9 = webrtc::CreateVideoCodec(98, "VP9");
+ webrtc::Codec vp9_foo = webrtc::CreateVideoCodec(99, "VP9");
vp9_foo.packetization = "bar";
webrtc::VideoContentDescription local;
local.set_codecs({vp8_foo, vp9});
@@ -2381,24 +2379,24 @@
EXPECT_THAT(
media_receive_channel1_impl()->recv_codecs(),
- ElementsAre(AllOf(Field(&cricket::Codec::id, 96),
- Field(&cricket::Codec::packetization, "foo")),
- AllOf(Field(&cricket::Codec::id, 98),
- Field(&cricket::Codec::packetization, std::nullopt))));
+ ElementsAre(AllOf(Field(&webrtc::Codec::id, 96),
+ Field(&webrtc::Codec::packetization, "foo")),
+ AllOf(Field(&webrtc::Codec::id, 98),
+ Field(&webrtc::Codec::packetization, std::nullopt))));
EXPECT_THAT(
media_send_channel1_impl()->send_codecs(),
- ElementsAre(AllOf(Field(&cricket::Codec::id, 96),
- Field(&cricket::Codec::packetization, "foo")),
- AllOf(Field(&cricket::Codec::id, 97),
- Field(&cricket::Codec::packetization, "bar")),
- AllOf(Field(&cricket::Codec::id, 99),
- Field(&cricket::Codec::packetization, std::nullopt))));
+ ElementsAre(AllOf(Field(&webrtc::Codec::id, 96),
+ Field(&webrtc::Codec::packetization, "foo")),
+ AllOf(Field(&webrtc::Codec::id, 97),
+ Field(&webrtc::Codec::packetization, "bar")),
+ AllOf(Field(&webrtc::Codec::id, 99),
+ Field(&webrtc::Codec::packetization, std::nullopt))));
}
TEST_F(VideoChannelSingleThreadTest,
ConsidersAllCodecsWithDiffrentPacketizationsInRemoteAnswer) {
- cricket::Codec vp8 = cricket::CreateVideoCodec(96, "VP8");
- cricket::Codec vp8_raw = cricket::CreateVideoCodec(97, "VP8");
+ webrtc::Codec vp8 = webrtc::CreateVideoCodec(96, "VP8");
+ webrtc::Codec vp8_raw = webrtc::CreateVideoCodec(97, "VP8");
vp8_raw.packetization = cricket::kPacketizationParamRaw;
webrtc::VideoContentDescription local;
local.set_codecs({vp8, vp8_raw});
@@ -2413,24 +2411,24 @@
EXPECT_THAT(
media_receive_channel1_impl()->recv_codecs(),
- ElementsAre(AllOf(Field(&cricket::Codec::id, 96),
- Field(&cricket::Codec::packetization, std::nullopt)),
- AllOf(Field(&cricket::Codec::id, 97),
- Field(&cricket::Codec::packetization,
+ ElementsAre(AllOf(Field(&webrtc::Codec::id, 96),
+ Field(&webrtc::Codec::packetization, std::nullopt)),
+ AllOf(Field(&webrtc::Codec::id, 97),
+ Field(&webrtc::Codec::packetization,
cricket::kPacketizationParamRaw))));
EXPECT_THAT(
media_send_channel1_impl()->send_codecs(),
- ElementsAre(AllOf(Field(&cricket::Codec::id, 97),
- Field(&cricket::Codec::packetization,
+ ElementsAre(AllOf(Field(&webrtc::Codec::id, 97),
+ Field(&webrtc::Codec::packetization,
cricket::kPacketizationParamRaw)),
- AllOf(Field(&cricket::Codec::id, 96),
- Field(&cricket::Codec::packetization, std::nullopt))));
+ AllOf(Field(&webrtc::Codec::id, 96),
+ Field(&webrtc::Codec::packetization, std::nullopt))));
}
TEST_F(VideoChannelSingleThreadTest,
ConsidersAllCodecsWithDiffrentPacketizationsInLocalAnswer) {
- cricket::Codec vp8 = cricket::CreateVideoCodec(96, "VP8");
- cricket::Codec vp8_raw = cricket::CreateVideoCodec(97, "VP8");
+ webrtc::Codec vp8 = webrtc::CreateVideoCodec(96, "VP8");
+ webrtc::Codec vp8_raw = webrtc::CreateVideoCodec(97, "VP8");
vp8_raw.packetization = cricket::kPacketizationParamRaw;
webrtc::VideoContentDescription local;
local.set_codecs({vp8_raw, vp8});
@@ -2445,17 +2443,17 @@
EXPECT_THAT(
media_receive_channel1_impl()->recv_codecs(),
- ElementsAre(AllOf(Field(&cricket::Codec::id, 97),
- Field(&cricket::Codec::packetization,
+ ElementsAre(AllOf(Field(&webrtc::Codec::id, 97),
+ Field(&webrtc::Codec::packetization,
cricket::kPacketizationParamRaw)),
- AllOf(Field(&cricket::Codec::id, 96),
- Field(&cricket::Codec::packetization, std::nullopt))));
+ AllOf(Field(&webrtc::Codec::id, 96),
+ Field(&webrtc::Codec::packetization, std::nullopt))));
EXPECT_THAT(
media_send_channel1_impl()->send_codecs(),
- ElementsAre(AllOf(Field(&cricket::Codec::id, 96),
- Field(&cricket::Codec::packetization, std::nullopt)),
- AllOf(Field(&cricket::Codec::id, 97),
- Field(&cricket::Codec::packetization,
+ ElementsAre(AllOf(Field(&webrtc::Codec::id, 96),
+ Field(&webrtc::Codec::packetization, std::nullopt)),
+ AllOf(Field(&webrtc::Codec::id, 97),
+ Field(&webrtc::Codec::packetization,
cricket::kPacketizationParamRaw))));
}
diff --git a/pc/codec_vendor.cc b/pc/codec_vendor.cc
index 5bf580c..3354709 100644
--- a/pc/codec_vendor.cc
+++ b/pc/codec_vendor.cc
@@ -67,25 +67,23 @@
return absl::EqualsIgnoreCase(capability.name, cricket::kRedCodecName);
}
-bool IsComfortNoiseCodec(const cricket::Codec& codec) {
+bool IsComfortNoiseCodec(const Codec& codec) {
return absl::EqualsIgnoreCase(codec.name, cricket::kComfortNoiseCodecName);
}
// Wrapper for FindMatchingCodecs that uses CodecList
-std::optional<cricket::Codec> FindMatchingCodec(
- const cricket::CodecList& codecs1,
- const cricket::CodecList& codecs2,
- const cricket::Codec& codec_to_match) {
+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(cricket::CodecList& audio_codecs) {
+void StripCNCodecs(CodecList& audio_codecs) {
audio_codecs.writable_codecs().erase(
- std::remove_if(audio_codecs.begin(), audio_codecs.end(),
- [](const cricket::Codec& codec) {
- return IsComfortNoiseCodec(codec);
- }),
+ std::remove_if(
+ audio_codecs.begin(), audio_codecs.end(),
+ [](const Codec& codec) { return IsComfortNoiseCodec(codec); }),
audio_codecs.end());
}
@@ -96,9 +94,8 @@
return content->media_description()->type() == media_type;
}
// Find the codec in `codec_list` that `rtx_codec` is associated with.
-const cricket::Codec* GetAssociatedCodecForRtx(
- const cricket::CodecList& codec_list,
- const cricket::Codec& rtx_codec) {
+const Codec* GetAssociatedCodecForRtx(const CodecList& codec_list,
+ const Codec& rtx_codec) {
std::string associated_pt_str;
if (!rtx_codec.GetParam(cricket::kCodecParamAssociatedPayloadType,
&associated_pt_str)) {
@@ -116,8 +113,8 @@
}
// Find the associated codec for the RTX codec.
- const cricket::Codec* associated_codec =
- cricket::FindCodecById(codec_list.codecs(), associated_pt);
+ const Codec* associated_codec =
+ FindCodecById(codec_list.codecs(), associated_pt);
if (!associated_codec) {
RTC_LOG(LS_WARNING) << "Couldn't find associated codec with payload type "
<< associated_pt << " for RTX codec " << rtx_codec.id
@@ -127,13 +124,12 @@
}
// Find the codec in `codec_list` that `red_codec` is associated with.
-const cricket::Codec* GetAssociatedCodecForRed(
- const cricket::CodecList& codec_list,
- const cricket::Codec& red_codec) {
+const Codec* GetAssociatedCodecForRed(const CodecList& codec_list,
+ const Codec& red_codec) {
std::string fmtp;
if (!red_codec.GetParam(cricket::kCodecParamNotInNameValueFormat, &fmtp)) {
// Don't log for video/RED where this is normal.
- if (red_codec.type == cricket::Codec::Type::kAudio) {
+ if (red_codec.type == Codec::Type::kAudio) {
RTC_LOG(LS_WARNING) << "RED codec " << red_codec.id
<< " is missing an associated payload type.";
}
@@ -155,8 +151,8 @@
}
// Find the associated codec for the RED codec.
- const cricket::Codec* associated_codec =
- cricket::FindCodecById(codec_list.codecs(), associated_pt);
+ const Codec* associated_codec =
+ FindCodecById(codec_list.codecs(), associated_pt);
if (!associated_codec) {
RTC_LOG(LS_WARNING) << "Couldn't find associated codec with payload type "
<< associated_pt << " for RED codec " << red_codec.id
@@ -168,20 +164,18 @@
// Adds all codecs from `reference_codecs` to `offered_codecs` that don't
// already exist in `offered_codecs` and ensure the payload types don't
// collide.
-RTCError MergeCodecs(const cricket::CodecList& reference_codecs,
+RTCError MergeCodecs(const CodecList& reference_codecs,
const std::string& mid,
- cricket::CodecList& offered_codecs,
+ CodecList& offered_codecs,
PayloadTypeSuggester& pt_suggester) {
// Add all new codecs that are not RTX/RED codecs.
// The two-pass splitting of the loops means preferring payload types
// of actual codecs with respect to collisions.
- for (const cricket::Codec& reference_codec : reference_codecs) {
- if (reference_codec.GetResiliencyType() !=
- cricket::Codec::ResiliencyType::kRtx &&
- reference_codec.GetResiliencyType() !=
- cricket::Codec::ResiliencyType::kRed &&
+ for (const Codec& reference_codec : reference_codecs) {
+ if (reference_codec.GetResiliencyType() != Codec::ResiliencyType::kRtx &&
+ reference_codec.GetResiliencyType() != Codec::ResiliencyType::kRed &&
!FindMatchingCodec(reference_codecs, offered_codecs, reference_codec)) {
- cricket::Codec codec = reference_codec;
+ Codec codec = reference_codec;
RTCErrorOr<PayloadType> suggestion =
pt_suggester.SuggestPayloadType(mid, codec);
if (!suggestion.ok()) {
@@ -193,19 +187,18 @@
}
// Add all new RTX or RED codecs.
- for (const cricket::Codec& reference_codec : reference_codecs) {
- if (reference_codec.GetResiliencyType() ==
- cricket::Codec::ResiliencyType::kRtx &&
+ for (const Codec& reference_codec : reference_codecs) {
+ if (reference_codec.GetResiliencyType() == Codec::ResiliencyType::kRtx &&
!FindMatchingCodec(reference_codecs, offered_codecs, reference_codec)) {
- cricket::Codec rtx_codec = reference_codec;
- const cricket::Codec* associated_codec =
+ Codec rtx_codec = reference_codec;
+ const Codec* associated_codec =
GetAssociatedCodecForRtx(reference_codecs, rtx_codec);
if (!associated_codec) {
continue;
}
// Find a codec in the offered list that matches the reference codec.
// Its payload type may be different than the reference codec.
- std::optional<cricket::Codec> matching_codec = FindMatchingCodec(
+ std::optional<Codec> matching_codec = FindMatchingCodec(
reference_codecs, offered_codecs, *associated_codec);
if (!matching_codec) {
RTC_LOG(LS_WARNING)
@@ -223,14 +216,14 @@
rtx_codec.id = suggestion.value();
offered_codecs.push_back(rtx_codec);
} else if (reference_codec.GetResiliencyType() ==
- cricket::Codec::ResiliencyType::kRed &&
+ Codec::ResiliencyType::kRed &&
!FindMatchingCodec(reference_codecs, offered_codecs,
reference_codec)) {
- cricket::Codec red_codec = reference_codec;
- const cricket::Codec* associated_codec =
+ Codec red_codec = reference_codec;
+ const Codec* associated_codec =
GetAssociatedCodecForRed(reference_codecs, red_codec);
if (associated_codec) {
- std::optional<cricket::Codec> matching_codec = FindMatchingCodec(
+ std::optional<Codec> matching_codec = FindMatchingCodec(
reference_codecs, offered_codecs, *associated_codec);
if (!matching_codec) {
RTC_LOG(LS_WARNING) << "Couldn't find matching "
@@ -258,38 +251,35 @@
// already exist in `offered_codecs` and ensure the payload types don't
// collide.
// OLD VERSION - uses UsedPayloadTypes
-void MergeCodecs(const cricket::CodecList& reference_codecs,
- cricket::CodecList& offered_codecs,
+void MergeCodecs(const CodecList& reference_codecs,
+ CodecList& offered_codecs,
UsedPayloadTypes* used_pltypes) {
// Add all new codecs that are not RTX/RED codecs.
// The two-pass splitting of the loops means preferring payload types
// of actual codecs with respect to collisions.
- for (const cricket::Codec& reference_codec : reference_codecs) {
- if (reference_codec.GetResiliencyType() !=
- cricket::Codec::ResiliencyType::kRtx &&
- reference_codec.GetResiliencyType() !=
- cricket::Codec::ResiliencyType::kRed &&
+ for (const Codec& reference_codec : reference_codecs) {
+ if (reference_codec.GetResiliencyType() != Codec::ResiliencyType::kRtx &&
+ reference_codec.GetResiliencyType() != Codec::ResiliencyType::kRed &&
!FindMatchingCodec(reference_codecs, offered_codecs, reference_codec)) {
- cricket::Codec codec = reference_codec;
+ Codec codec = reference_codec;
used_pltypes->FindAndSetIdUsed(&codec);
offered_codecs.push_back(codec);
}
}
// Add all new RTX or RED codecs.
- for (const cricket::Codec& reference_codec : reference_codecs) {
- if (reference_codec.GetResiliencyType() ==
- cricket::Codec::ResiliencyType::kRtx &&
+ for (const Codec& reference_codec : reference_codecs) {
+ if (reference_codec.GetResiliencyType() == Codec::ResiliencyType::kRtx &&
!FindMatchingCodec(reference_codecs, offered_codecs, reference_codec)) {
- cricket::Codec rtx_codec = reference_codec;
- const cricket::Codec* associated_codec =
+ Codec rtx_codec = reference_codec;
+ const Codec* associated_codec =
GetAssociatedCodecForRtx(reference_codecs, rtx_codec);
if (!associated_codec) {
continue;
}
// Find a codec in the offered list that matches the reference codec.
// Its payload type may be different than the reference codec.
- std::optional<cricket::Codec> matching_codec = FindMatchingCodec(
+ std::optional<Codec> matching_codec = FindMatchingCodec(
reference_codecs, offered_codecs, *associated_codec);
if (!matching_codec) {
RTC_LOG(LS_WARNING)
@@ -302,14 +292,14 @@
used_pltypes->FindAndSetIdUsed(&rtx_codec);
offered_codecs.push_back(rtx_codec);
} else if (reference_codec.GetResiliencyType() ==
- cricket::Codec::ResiliencyType::kRed &&
+ Codec::ResiliencyType::kRed &&
!FindMatchingCodec(reference_codecs, offered_codecs,
reference_codec)) {
- cricket::Codec red_codec = reference_codec;
- const cricket::Codec* associated_codec =
+ Codec red_codec = reference_codec;
+ const Codec* associated_codec =
GetAssociatedCodecForRed(reference_codecs, red_codec);
if (associated_codec) {
- std::optional<cricket::Codec> matching_codec = FindMatchingCodec(
+ std::optional<Codec> matching_codec = FindMatchingCodec(
reference_codecs, offered_codecs, *associated_codec);
if (!matching_codec) {
RTC_LOG(LS_WARNING) << "Couldn't find matching "
@@ -333,11 +323,11 @@
// a list filtered for the media section`s direction but with default payload
// types.
// static
-cricket::CodecList MatchCodecPreference(
+CodecList MatchCodecPreference(
const std::vector<RtpCodecCapability>& codec_preferences,
- const cricket::CodecList& codecs,
- const cricket::CodecList& supported_codecs) {
- cricket::CodecList filtered_codecs;
+ const CodecList& codecs,
+ const CodecList& supported_codecs) {
+ CodecList filtered_codecs;
bool want_rtx = false;
bool want_red = false;
@@ -351,7 +341,7 @@
bool red_was_added = false;
for (const auto& codec_preference : codec_preferences) {
auto found_codec = absl::c_find_if(
- supported_codecs, [&codec_preference](const cricket::Codec& codec) {
+ supported_codecs, [&codec_preference](const Codec& codec) {
// We should not filter out the codec in |codec_preferences| if it
// has a higher level than the codec in |supported_codecs|, as the
// codec in |supported_codecs| may be only with lower level in
@@ -360,13 +350,13 @@
});
if (found_codec != supported_codecs.end()) {
- std::optional<cricket::Codec> found_codec_with_correct_pt =
+ std::optional<Codec> found_codec_with_correct_pt =
FindMatchingCodec(supported_codecs, codecs, *found_codec);
if (found_codec_with_correct_pt) {
// RED may already have been added if its primary codec is before RED
// in the codec list.
bool is_red_codec = found_codec_with_correct_pt->GetResiliencyType() ==
- cricket::Codec::ResiliencyType::kRed;
+ Codec::ResiliencyType::kRed;
if (!is_red_codec || !red_was_added) {
filtered_codecs.push_back(*found_codec_with_correct_pt);
red_was_added = is_red_codec ? true : red_was_added;
@@ -375,8 +365,8 @@
// Search for the matching rtx or red codec.
if (want_red || want_rtx) {
for (const auto& codec : codecs) {
- if (want_rtx && codec.GetResiliencyType() ==
- cricket::Codec::ResiliencyType::kRtx) {
+ if (want_rtx &&
+ codec.GetResiliencyType() == Codec::ResiliencyType::kRtx) {
const auto apt =
codec.params.find(cricket::kCodecParamAssociatedPayloadType);
if (apt != codec.params.end() && apt->second == id) {
@@ -384,7 +374,7 @@
break;
}
} else if (want_red && codec.GetResiliencyType() ==
- cricket::Codec::ResiliencyType::kRed) {
+ Codec::ResiliencyType::kRed) {
// For RED, do not insert the codec again if it was already
// inserted. audio/red for opus gets enabled by having RED before
// the primary codec.
@@ -412,9 +402,9 @@
return filtered_codecs;
}
-void NegotiatePacketization(const cricket::Codec& local_codec,
- const cricket::Codec& remote_codec,
- cricket::Codec* negotiated_codec) {
+void NegotiatePacketization(const Codec& local_codec,
+ const Codec& remote_codec,
+ Codec* negotiated_codec) {
negotiated_codec->packetization =
(local_codec.packetization == remote_codec.packetization)
? local_codec.packetization
@@ -422,9 +412,9 @@
}
#ifdef RTC_ENABLE_H265
-void NegotiateTxMode(const cricket::Codec& local_codec,
- const cricket::Codec& remote_codec,
- cricket::Codec* negotiated_codec) {
+void NegotiateTxMode(const Codec& local_codec,
+ const Codec& remote_codec,
+ Codec* negotiated_codec) {
negotiated_codec->tx_mode = (local_codec.tx_mode == remote_codec.tx_mode)
? local_codec.tx_mode
: std::nullopt;
@@ -435,8 +425,8 @@
// |supported_codecs| with same profile.
void NegotiateVideoCodecLevelsForOffer(
const MediaDescriptionOptions& media_description_options,
- const cricket::CodecList& supported_codecs,
- cricket::CodecList& filtered_codecs) {
+ const CodecList& supported_codecs,
+ CodecList& filtered_codecs) {
if (filtered_codecs.empty() || supported_codecs.empty()) {
return;
}
@@ -450,7 +440,7 @@
// The assumption here is that H.265 codecs with the same profile and tier
// are already with highest level for that profile in both
// |supported_codecs| and |filtered_codecs|.
- for (const cricket::Codec& supported_codec : supported_codecs) {
+ for (const Codec& supported_codec : supported_codecs) {
if (absl::EqualsIgnoreCase(supported_codec.name,
cricket::kH265CodecName)) {
std::optional<H265ProfileTierLevel> supported_ptl =
@@ -486,25 +476,24 @@
#endif
}
-RTCError NegotiateCodecs(const cricket::CodecList& local_codecs,
- const cricket::CodecList& offered_codecs,
- cricket::CodecList& negotiated_codecs_out,
+RTCError NegotiateCodecs(const CodecList& local_codecs,
+ const CodecList& offered_codecs,
+ CodecList& negotiated_codecs_out,
bool keep_offer_order) {
std::map<int, int> pt_mapping_table;
// Since we build the negotiated codec list one entry at a time,
// the list will have inconsistencies during building.
- std::vector<cricket::Codec> negotiated_codecs;
- for (const cricket::Codec& ours : local_codecs) {
- std::optional<cricket::Codec> theirs =
+ std::vector<Codec> negotiated_codecs;
+ for (const Codec& ours : local_codecs) {
+ std::optional<Codec> theirs =
FindMatchingCodec(local_codecs, offered_codecs, ours);
// Note that we intentionally only find one matching codec for each of our
// local codecs, in case the remote offer contains duplicate codecs.
if (theirs) {
- cricket::Codec negotiated = ours;
+ Codec negotiated = ours;
NegotiatePacketization(ours, *theirs, &negotiated);
negotiated.IntersectFeedbackParams(*theirs);
- if (negotiated.GetResiliencyType() ==
- cricket::Codec::ResiliencyType::kRtx) {
+ if (negotiated.GetResiliencyType() == Codec::ResiliencyType::kRtx) {
// We support parsing the declarative rtx-time parameter.
const auto rtx_time_it =
theirs->params.find(cricket::kCodecParamRtxTime);
@@ -512,7 +501,7 @@
negotiated.SetParam(cricket::kCodecParamRtxTime, rtx_time_it->second);
}
} else if (negotiated.GetResiliencyType() ==
- cricket::Codec::ResiliencyType::kRed) {
+ Codec::ResiliencyType::kRed) {
const auto red_it =
theirs->params.find(cricket::kCodecParamNotInNameValueFormat);
if (red_it != theirs->params.end()) {
@@ -539,9 +528,8 @@
}
}
// Fix up apt parameters that point to other PTs.
- for (cricket::Codec& negotiated : negotiated_codecs) {
- if (negotiated.GetResiliencyType() ==
- cricket::Codec::ResiliencyType::kRtx) {
+ for (Codec& negotiated : negotiated_codecs) {
+ if (negotiated.GetResiliencyType() == Codec::ResiliencyType::kRtx) {
// Change the apt value according to the pt mapping table.
// This avoids changing to apt values that don't exist any more.
std::string apt_str;
@@ -571,17 +559,15 @@
// This can be skipped when the transceiver has any codec preferences.
std::unordered_map<int, int> payload_type_preferences;
int preference = static_cast<int>(offered_codecs.size() + 1);
- for (const cricket::Codec& codec : offered_codecs) {
+ for (const Codec& codec : offered_codecs) {
payload_type_preferences[codec.id] = preference--;
}
absl::c_sort(negotiated_codecs, [&payload_type_preferences](
- const cricket::Codec& a,
- const cricket::Codec& b) {
+ const Codec& a, const Codec& b) {
return payload_type_preferences[a.id] > payload_type_preferences[b.id];
});
}
- RTCErrorOr<cricket::CodecList> result =
- cricket::CodecList::Create(negotiated_codecs);
+ RTCErrorOr<CodecList> result = CodecList::Create(negotiated_codecs);
if (!result.ok()) {
return result.MoveError();
}
@@ -596,10 +582,10 @@
// first OPUS codec in the codec list.
RTCError AssignCodecIdsAndLinkRed(PayloadTypeSuggester* pt_suggester,
const std::string& mid,
- std::vector<cricket::Codec>& codecs) {
- int codec_payload_type = cricket::Codec::kIdNotSet;
- for (cricket::Codec& codec : codecs) {
- if (codec.id == cricket::Codec::kIdNotSet) {
+ std::vector<Codec>& codecs) {
+ int codec_payload_type = Codec::kIdNotSet;
+ for (Codec& codec : codecs) {
+ if (codec.id == Codec::kIdNotSet) {
// Add payload types to codecs, if needed
// This should only happen if WebRTC-PayloadTypesInTransport field trial
// is enabled.
@@ -612,13 +598,13 @@
}
// record first Opus codec id
if (absl::EqualsIgnoreCase(codec.name, cricket::kOpusCodecName) &&
- codec_payload_type == cricket::Codec::kIdNotSet) {
+ codec_payload_type == Codec::kIdNotSet) {
codec_payload_type = codec.id;
}
}
- if (codec_payload_type != cricket::Codec::kIdNotSet) {
- for (cricket::Codec& codec : codecs) {
- if (codec.type == cricket::Codec::Type::kAudio &&
+ if (codec_payload_type != Codec::kIdNotSet) {
+ for (Codec& codec : codecs) {
+ if (codec.type == Codec::Type::kAudio &&
absl::EqualsIgnoreCase(codec.name, cricket::kRedCodecName)) {
if (codec.params.empty()) {
char buffer[100];
@@ -634,19 +620,17 @@
} // namespace
-RTCErrorOr<std::vector<cricket::Codec>>
-CodecVendor::GetNegotiatedCodecsForOffer(
+RTCErrorOr<std::vector<Codec>> CodecVendor::GetNegotiatedCodecsForOffer(
const MediaDescriptionOptions& media_description_options,
const MediaSessionOptions& session_options,
const ContentInfo* current_content,
PayloadTypeSuggester& pt_suggester) {
- cricket::CodecList codecs;
+ CodecList codecs;
std::string mid = media_description_options.mid;
// If current content exists and is not being recycled, use its codecs.
if (current_content && current_content->mid() == mid) {
- RTCErrorOr<cricket::CodecList> checked_codec_list =
- cricket::CodecList::Create(
- current_content->media_description()->codecs());
+ RTCErrorOr<CodecList> checked_codec_list =
+ CodecList::Create(current_content->media_description()->codecs());
if (!checked_codec_list.ok()) {
return checked_codec_list.MoveError();
}
@@ -659,8 +643,8 @@
} else {
MergeCodecs(all_video_codecs(), mid, codecs, pt_suggester);
}
- cricket::CodecList filtered_codecs;
- cricket::CodecList supported_codecs =
+ CodecList filtered_codecs;
+ CodecList supported_codecs =
media_description_options.type == MediaType::AUDIO
? GetAudioCodecsForOffer(media_description_options.direction)
: GetVideoCodecsForOffer(media_description_options.direction);
@@ -687,7 +671,7 @@
}
const MediaContentDescription* mcd =
current_content->media_description();
- for (const cricket::Codec& codec : mcd->codecs()) {
+ for (const Codec& codec : mcd->codecs()) {
if (webrtc::FindMatchingCodec(mcd->codecs(), codecs.codecs(),
codec)) {
filtered_codecs.push_back(codec);
@@ -703,16 +687,15 @@
used_pltypes.FindAndSetIdUsed(&codec);
}
// Add other supported codecs.
- for (const cricket::Codec& codec : supported_codecs) {
- std::optional<cricket::Codec> found_codec =
+ for (const Codec& codec : supported_codecs) {
+ std::optional<Codec> found_codec =
FindMatchingCodec(supported_codecs, codecs, codec);
if (found_codec &&
!FindMatchingCodec(supported_codecs, filtered_codecs, codec)) {
// Use the `found_codec` from `codecs` because it has the
// correctly mapped payload type (most of the time).
if (media_description_options.type == MediaType::VIDEO &&
- found_codec->GetResiliencyType() ==
- cricket::Codec::ResiliencyType::kRtx) {
+ found_codec->GetResiliencyType() == Codec::ResiliencyType::kRtx) {
// For RTX we might need to adjust the apt parameter if we got a
// remote offer without RTX for a codec for which we support RTX.
// This is only done for video since we do not yet have rtx for
@@ -722,9 +705,8 @@
RTC_DCHECK(referenced_codec);
// Find the codec we should be referencing and point to it.
- std::optional<cricket::Codec> changed_referenced_codec =
- FindMatchingCodec(supported_codecs, filtered_codecs,
- *referenced_codec);
+ std::optional<Codec> changed_referenced_codec = FindMatchingCodec(
+ supported_codecs, filtered_codecs, *referenced_codec);
if (changed_referenced_codec) {
found_codec->SetParam(cricket::kCodecParamAssociatedPayloadType,
changed_referenced_codec->id);
@@ -743,7 +725,7 @@
StripCNCodecs(filtered_codecs);
} else if (media_description_options.type == MediaType::VIDEO &&
session_options.raw_packetization_for_video) {
- for (cricket::Codec& codec : filtered_codecs) {
+ for (Codec& codec : filtered_codecs) {
if (codec.IsMediaCodec()) {
codec.packetization = cricket::kPacketizationParamRaw;
}
@@ -754,8 +736,8 @@
} else {
// media_description_options.codecs_to_include contains codecs
// TODO: issues.webrtc.org/360058654 - figure out if this can be deleted.
- RTCErrorOr<cricket::CodecList> codecs_from_arg =
- cricket::CodecList::Create(media_description_options.codecs_to_include);
+ RTCErrorOr<CodecList> codecs_from_arg =
+ CodecList::Create(media_description_options.codecs_to_include);
if (!codecs_from_arg.ok()) {
return codecs_from_arg.MoveError();
}
@@ -766,20 +748,19 @@
return filtered_codecs.codecs();
}
-RTCErrorOr<cricket::Codecs> CodecVendor::GetNegotiatedCodecsForAnswer(
+RTCErrorOr<Codecs> CodecVendor::GetNegotiatedCodecsForAnswer(
const MediaDescriptionOptions& media_description_options,
const MediaSessionOptions& session_options,
RtpTransceiverDirection offer_rtd,
RtpTransceiverDirection answer_rtd,
const ContentInfo* current_content,
- const std::vector<cricket::Codec> codecs_from_offer,
+ const std::vector<Codec> codecs_from_offer,
PayloadTypeSuggester& pt_suggester) {
- cricket::CodecList codecs;
+ CodecList codecs;
std::string mid = media_description_options.mid;
if (current_content && current_content->mid() == mid) {
- RTCErrorOr<cricket::CodecList> checked_codec_list =
- cricket::CodecList::Create(
- current_content->media_description()->codecs());
+ RTCErrorOr<CodecList> checked_codec_list =
+ CodecList::Create(current_content->media_description()->codecs());
if (!checked_codec_list.ok()) {
return checked_codec_list.MoveError();
}
@@ -791,10 +772,10 @@
} else {
MergeCodecs(all_video_codecs(), mid, codecs, pt_suggester);
}
- cricket::CodecList filtered_codecs;
- cricket::CodecList negotiated_codecs;
+ CodecList filtered_codecs;
+ CodecList negotiated_codecs;
if (media_description_options.codecs_to_include.empty()) {
- const cricket::CodecList& supported_codecs =
+ const CodecList& supported_codecs =
media_description_options.type == MediaType::AUDIO
? GetAudioCodecsForAnswer(offer_rtd, answer_rtd)
: GetVideoCodecsForAnswer(offer_rtd, answer_rtd);
@@ -817,7 +798,7 @@
}
const MediaContentDescription* mcd =
current_content->media_description();
- for (const cricket::Codec& codec : mcd->codecs()) {
+ for (const Codec& codec : mcd->codecs()) {
if (webrtc::FindMatchingCodec(mcd->codecs(), codecs.codecs(),
codec)) {
filtered_codecs.push_back(codec);
@@ -834,15 +815,14 @@
StripCNCodecs(filtered_codecs);
} else if (media_description_options.type == MediaType::VIDEO &&
session_options.raw_packetization_for_video) {
- for (cricket::Codec& codec : filtered_codecs) {
+ for (Codec& codec : filtered_codecs) {
if (codec.IsMediaCodec()) {
codec.packetization = cricket::kPacketizationParamRaw;
}
}
}
// An offer is external data, so needs to be checked before use.
- auto checked_codecs_from_offer =
- cricket::CodecList::Create(codecs_from_offer);
+ auto checked_codecs_from_offer = CodecList::Create(codecs_from_offer);
if (!checked_codecs_from_offer.ok()) {
return checked_codecs_from_offer.MoveError();
}
@@ -851,8 +831,8 @@
media_description_options.codec_preferences.empty());
} else {
// media_description_options.codecs_to_include contains codecs
- RTCErrorOr<cricket::CodecList> codecs_from_arg =
- cricket::CodecList::Create(media_description_options.codecs_to_include);
+ RTCErrorOr<CodecList> codecs_from_arg =
+ CodecList::Create(media_description_options.codecs_to_include);
if (!codecs_from_arg.ok()) {
return codecs_from_arg.MoveError();
}
@@ -885,35 +865,35 @@
}
}
-const cricket::CodecList& CodecVendor::audio_send_codecs() const {
+const CodecList& CodecVendor::audio_send_codecs() const {
return audio_send_codecs_.codecs();
}
-const cricket::CodecList& CodecVendor::audio_recv_codecs() const {
+const CodecList& CodecVendor::audio_recv_codecs() const {
return audio_recv_codecs_.codecs();
}
-void CodecVendor::set_audio_codecs(const cricket::CodecList& send_codecs,
- const cricket::CodecList& recv_codecs) {
+void CodecVendor::set_audio_codecs(const CodecList& send_codecs,
+ const CodecList& recv_codecs) {
audio_send_codecs_.set_codecs(send_codecs);
audio_recv_codecs_.set_codecs(recv_codecs);
}
-const cricket::CodecList& CodecVendor::video_send_codecs() const {
+const CodecList& CodecVendor::video_send_codecs() const {
return video_send_codecs_.codecs();
}
-const cricket::CodecList& CodecVendor::video_recv_codecs() const {
+const CodecList& CodecVendor::video_recv_codecs() const {
return video_recv_codecs_.codecs();
}
-void CodecVendor::set_video_codecs(const cricket::CodecList& send_codecs,
- const cricket::CodecList& recv_codecs) {
+void CodecVendor::set_video_codecs(const CodecList& send_codecs,
+ const CodecList& recv_codecs) {
video_send_codecs_.set_codecs(send_codecs);
video_recv_codecs_.set_codecs(recv_codecs);
}
-cricket::CodecList CodecVendor::GetVideoCodecsForOffer(
+CodecList CodecVendor::GetVideoCodecsForOffer(
const RtpTransceiverDirection& direction) const {
switch (direction) {
// If stream is inactive - generate list as if sendrecv.
@@ -929,7 +909,7 @@
RTC_CHECK_NOTREACHED();
}
-cricket::CodecList CodecVendor::GetVideoCodecsForAnswer(
+CodecList CodecVendor::GetVideoCodecsForAnswer(
const RtpTransceiverDirection& offer,
const RtpTransceiverDirection& answer) const {
switch (answer) {
@@ -948,7 +928,7 @@
RTC_CHECK_NOTREACHED();
}
-cricket::CodecList CodecVendor::GetAudioCodecsForOffer(
+CodecList CodecVendor::GetAudioCodecsForOffer(
const RtpTransceiverDirection& direction) const {
switch (direction) {
// If stream is inactive - generate list as if sendrecv.
@@ -964,7 +944,7 @@
RTC_CHECK_NOTREACHED();
}
-cricket::CodecList CodecVendor::GetAudioCodecsForAnswer(
+CodecList CodecVendor::GetAudioCodecsForAnswer(
const RtpTransceiverDirection& offer,
const RtpTransceiverDirection& answer) const {
switch (answer) {
@@ -983,11 +963,11 @@
RTC_CHECK_NOTREACHED();
}
-cricket::CodecList CodecVendor::all_video_codecs() const {
- cricket::CodecList all_codecs;
+CodecList CodecVendor::all_video_codecs() const {
+ CodecList all_codecs;
UsedPayloadTypes used_payload_types;
- for (const cricket::Codec& codec : video_recv_codecs_.codecs()) {
- cricket::Codec codec_mutable = codec;
+ for (const Codec& codec : video_recv_codecs_.codecs()) {
+ Codec codec_mutable = codec;
used_payload_types.FindAndSetIdUsed(&codec_mutable);
all_codecs.push_back(codec_mutable);
}
@@ -999,20 +979,19 @@
return all_codecs;
}
-cricket::CodecList CodecVendor::all_audio_codecs() const {
+CodecList CodecVendor::all_audio_codecs() const {
// Compute the audio codecs union.
- cricket::CodecList codecs;
- for (const cricket::Codec& send : audio_send_codecs_.codecs()) {
+ CodecList codecs;
+ for (const Codec& send : audio_send_codecs_.codecs()) {
codecs.push_back(send);
if (!FindMatchingCodec(audio_send_codecs_.codecs(),
audio_recv_codecs_.codecs(), send)) {
// It doesn't make sense to have an RTX codec we support sending but not
// receiving.
- RTC_DCHECK(send.GetResiliencyType() !=
- cricket::Codec::ResiliencyType::kRtx);
+ RTC_DCHECK(send.GetResiliencyType() != Codec::ResiliencyType::kRtx);
}
}
- for (const cricket::Codec& recv : audio_recv_codecs_.codecs()) {
+ for (const Codec& recv : audio_recv_codecs_.codecs()) {
if (!FindMatchingCodec(audio_recv_codecs_.codecs(),
audio_send_codecs_.codecs(), recv)) {
codecs.push_back(recv);
@@ -1021,13 +1000,13 @@
return codecs;
}
-cricket::CodecList CodecVendor::audio_sendrecv_codecs() const {
+CodecList CodecVendor::audio_sendrecv_codecs() const {
// Use NegotiateCodecs to merge our codec lists, since the operation is
// essentially the same. Put send_codecs as the offered_codecs, which is the
// order we'd like to follow. The reasoning is that encoding is usually more
// expensive than decoding, and prioritizing a codec in the send list probably
// means it's a codec we can handle efficiently.
- cricket::CodecList audio_sendrecv_codecs;
+ CodecList audio_sendrecv_codecs;
auto error =
NegotiateCodecs(audio_recv_codecs_.codecs(), audio_send_codecs_.codecs(),
audio_sendrecv_codecs, true);
@@ -1035,7 +1014,7 @@
return audio_sendrecv_codecs;
}
-cricket::CodecList CodecVendor::video_sendrecv_codecs() const {
+CodecList CodecVendor::video_sendrecv_codecs() const {
// Use NegotiateCodecs to merge our codec lists, since the operation is
// essentially the same. Put send_codecs as the offered_codecs, which is the
// order we'd like to follow. The reasoning is that encoding is usually more
@@ -1044,7 +1023,7 @@
// Also for the same profile of a codec, if there are different levels in the
// send and receive codecs, |video_sendrecv_codecs| will contain the lower
// level of the two for that profile.
- cricket::CodecList video_sendrecv_codecs;
+ CodecList video_sendrecv_codecs;
auto error =
NegotiateCodecs(video_recv_codecs_.codecs(), video_send_codecs_.codecs(),
video_sendrecv_codecs, true);
diff --git a/pc/codec_vendor.h b/pc/codec_vendor.h
index 6d9a2f6..4bc93f8 100644
--- a/pc/codec_vendor.h
+++ b/pc/codec_vendor.h
@@ -47,57 +47,57 @@
const FieldTrialsView& trials);
public:
- RTCErrorOr<std::vector<cricket::Codec>> GetNegotiatedCodecsForOffer(
+ RTCErrorOr<std::vector<Codec>> GetNegotiatedCodecsForOffer(
const MediaDescriptionOptions& media_description_options,
const MediaSessionOptions& session_options,
const ContentInfo* current_content,
PayloadTypeSuggester& pt_suggester);
- RTCErrorOr<cricket::Codecs> GetNegotiatedCodecsForAnswer(
+ RTCErrorOr<Codecs> GetNegotiatedCodecsForAnswer(
const MediaDescriptionOptions& media_description_options,
const MediaSessionOptions& session_options,
RtpTransceiverDirection offer_rtd,
RtpTransceiverDirection answer_rtd,
const ContentInfo* current_content,
- std::vector<cricket::Codec> codecs_from_offer,
+ std::vector<Codec> codecs_from_offer,
PayloadTypeSuggester& pt_suggester);
// Functions exposed for testing
- void set_audio_codecs(const cricket::CodecList& send_codecs,
- const cricket::CodecList& recv_codecs);
- void set_audio_codecs(const std::vector<cricket::Codec>& send_codecs,
- const std::vector<cricket::Codec>& recv_codecs) {
- set_audio_codecs(cricket::CodecList::CreateFromTrustedData(send_codecs),
- cricket::CodecList::CreateFromTrustedData(recv_codecs));
+ void set_audio_codecs(const CodecList& send_codecs,
+ const CodecList& recv_codecs);
+ void set_audio_codecs(const std::vector<Codec>& send_codecs,
+ const std::vector<Codec>& recv_codecs) {
+ set_audio_codecs(CodecList::CreateFromTrustedData(send_codecs),
+ CodecList::CreateFromTrustedData(recv_codecs));
}
- void set_video_codecs(const cricket::CodecList& send_codecs,
- const cricket::CodecList& recv_codecs);
- void set_video_codecs(const std::vector<cricket::Codec>& send_codecs,
- const std::vector<cricket::Codec>& recv_codecs) {
- set_video_codecs(cricket::CodecList::CreateFromTrustedData(send_codecs),
- cricket::CodecList::CreateFromTrustedData(recv_codecs));
+ 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::CreateFromTrustedData(send_codecs),
+ CodecList::CreateFromTrustedData(recv_codecs));
}
- cricket::CodecList audio_sendrecv_codecs() const;
- const cricket::CodecList& audio_send_codecs() const;
- const cricket::CodecList& audio_recv_codecs() const;
- cricket::CodecList video_sendrecv_codecs() const;
- const cricket::CodecList& video_send_codecs() const;
- const cricket::CodecList& video_recv_codecs() const;
+ CodecList audio_sendrecv_codecs() const;
+ const CodecList& audio_send_codecs() const;
+ const CodecList& audio_recv_codecs() const;
+ CodecList video_sendrecv_codecs() const;
+ const CodecList& video_send_codecs() const;
+ const CodecList& video_recv_codecs() const;
private:
- cricket::CodecList GetAudioCodecsForOffer(
+ CodecList GetAudioCodecsForOffer(
const RtpTransceiverDirection& direction) const;
- cricket::CodecList GetAudioCodecsForAnswer(
+ CodecList GetAudioCodecsForAnswer(
const RtpTransceiverDirection& offer,
const RtpTransceiverDirection& answer) const;
- cricket::CodecList GetVideoCodecsForOffer(
+ CodecList GetVideoCodecsForOffer(
const RtpTransceiverDirection& direction) const;
- cricket::CodecList GetVideoCodecsForAnswer(
+ CodecList GetVideoCodecsForAnswer(
const RtpTransceiverDirection& offer,
const RtpTransceiverDirection& answer) const;
- cricket::CodecList all_video_codecs() const;
- cricket::CodecList all_audio_codecs() const;
+ CodecList all_video_codecs() const;
+ CodecList all_audio_codecs() const;
TypedCodecVendor audio_send_codecs_;
TypedCodecVendor audio_recv_codecs_;
diff --git a/pc/codec_vendor_unittest.cc b/pc/codec_vendor_unittest.cc
index 88ce32e..9d8270b 100644
--- a/pc/codec_vendor_unittest.cc
+++ b/pc/codec_vendor_unittest.cc
@@ -28,46 +28,44 @@
namespace webrtc {
namespace {
-cricket::Codec CreateRedAudioCodec(absl::string_view encoding_id) {
- cricket::Codec red = cricket::CreateAudioCodec(63, "red", 48000, 2);
+Codec CreateRedAudioCodec(absl::string_view encoding_id) {
+ Codec red = CreateAudioCodec(63, "red", 48000, 2);
red.SetParam(cricket::kCodecParamNotInNameValueFormat,
std::string(encoding_id) + '/' + std::string(encoding_id));
return red;
}
-const cricket::Codec kAudioCodecs1[] = {
- cricket::CreateAudioCodec(111, "opus", 48000, 2),
- CreateRedAudioCodec("111"),
- cricket::CreateAudioCodec(102, "G722", 16000, 1),
- cricket::CreateAudioCodec(0, "PCMU", 8000, 1),
- cricket::CreateAudioCodec(8, "PCMA", 8000, 1),
- cricket::CreateAudioCodec(107, "CN", 48000, 1)};
+const Codec kAudioCodecs1[] = {CreateAudioCodec(111, "opus", 48000, 2),
+ CreateRedAudioCodec("111"),
+ CreateAudioCodec(102, "G722", 16000, 1),
+ CreateAudioCodec(0, "PCMU", 8000, 1),
+ CreateAudioCodec(8, "PCMA", 8000, 1),
+ CreateAudioCodec(107, "CN", 48000, 1)};
-const cricket::Codec kAudioCodecs2[] = {
- cricket::CreateAudioCodec(126, "foo", 16000, 1),
- cricket::CreateAudioCodec(0, "PCMU", 8000, 1),
- cricket::CreateAudioCodec(127, "G722", 16000, 1),
+const Codec kAudioCodecs2[] = {
+ CreateAudioCodec(126, "foo", 16000, 1),
+ CreateAudioCodec(0, "PCMU", 8000, 1),
+ CreateAudioCodec(127, "G722", 16000, 1),
};
-const cricket::Codec kAudioCodecsAnswer[] = {
- cricket::CreateAudioCodec(102, "G722", 16000, 1),
- cricket::CreateAudioCodec(0, "PCMU", 8000, 1),
+const Codec kAudioCodecsAnswer[] = {
+ CreateAudioCodec(102, "G722", 16000, 1),
+ CreateAudioCodec(0, "PCMU", 8000, 1),
};
TEST(CodecVendorTest, TestSetAudioCodecs) {
std::unique_ptr<FieldTrials> trials = FieldTrials::CreateNoGlobal("");
CodecVendor codec_vendor(nullptr, false, *trials);
- std::vector<cricket::Codec> send_codecs = MAKE_VECTOR(kAudioCodecs1);
- std::vector<cricket::Codec> recv_codecs = MAKE_VECTOR(kAudioCodecs2);
+ std::vector<Codec> send_codecs = MAKE_VECTOR(kAudioCodecs1);
+ std::vector<Codec> recv_codecs = MAKE_VECTOR(kAudioCodecs2);
// The merged list of codecs should contain any send codecs that are also
// nominally in the receive codecs list. Payload types should be picked from
// the send codecs and a number-of-channels of 0 and 1 should be equivalent
// (set to 1). This equals what happens when the send codecs are used in an
// offer and the receive codecs are used in the following answer.
- const std::vector<cricket::Codec> sendrecv_codecs =
- MAKE_VECTOR(kAudioCodecsAnswer);
- cricket::CodecList no_codecs;
+ const std::vector<Codec> sendrecv_codecs = MAKE_VECTOR(kAudioCodecsAnswer);
+ CodecList no_codecs;
RTC_CHECK_EQ(send_codecs[2].name, "G722")
<< "Please don't change shared test data!";
@@ -82,23 +80,22 @@
recv_codecs[1].name = "pcmu";
// Test proper merge
- codec_vendor.set_audio_codecs(
- cricket::CodecList::CreateFromTrustedData(send_codecs),
- cricket::CodecList::CreateFromTrustedData(recv_codecs));
+ codec_vendor.set_audio_codecs(CodecList::CreateFromTrustedData(send_codecs),
+ CodecList::CreateFromTrustedData(recv_codecs));
EXPECT_EQ(send_codecs, codec_vendor.audio_send_codecs().codecs());
EXPECT_EQ(recv_codecs, codec_vendor.audio_recv_codecs().codecs());
EXPECT_EQ(sendrecv_codecs, codec_vendor.audio_sendrecv_codecs().codecs());
// Test empty send codecs list
- codec_vendor.set_audio_codecs(
- no_codecs, cricket::CodecList::CreateFromTrustedData(recv_codecs));
+ codec_vendor.set_audio_codecs(no_codecs,
+ CodecList::CreateFromTrustedData(recv_codecs));
EXPECT_EQ(no_codecs.codecs(), codec_vendor.audio_send_codecs().codecs());
EXPECT_EQ(recv_codecs, codec_vendor.audio_recv_codecs().codecs());
EXPECT_EQ(no_codecs.codecs(), codec_vendor.audio_sendrecv_codecs().codecs());
// Test empty recv codecs list
- codec_vendor.set_audio_codecs(
- cricket::CodecList::CreateFromTrustedData(send_codecs), no_codecs);
+ codec_vendor.set_audio_codecs(CodecList::CreateFromTrustedData(send_codecs),
+ no_codecs);
EXPECT_EQ(send_codecs, codec_vendor.audio_send_codecs().codecs());
EXPECT_EQ(no_codecs.codecs(), codec_vendor.audio_recv_codecs().codecs());
EXPECT_EQ(no_codecs.codecs(), codec_vendor.audio_sendrecv_codecs().codecs());
diff --git a/pc/jsep_session_description_unittest.cc b/pc/jsep_session_description_unittest.cc
index a65a5a5..01d38da 100644
--- a/pc/jsep_session_description_unittest.cc
+++ b/pc/jsep_session_description_unittest.cc
@@ -64,11 +64,11 @@
// VideoContentDescription
auto video = std::make_unique<webrtc::VideoContentDescription>();
- audio->AddCodec(cricket::CreateAudioCodec(103, "ISAC", 16000, 0));
+ audio->AddCodec(webrtc::CreateAudioCodec(103, "ISAC", 16000, 0));
desc->AddContent(cricket::CN_AUDIO, MediaProtocolType::kRtp,
std::move(audio));
- video->AddCodec(cricket::CreateVideoCodec(120, "VP8"));
+ video->AddCodec(webrtc::CreateVideoCodec(120, "VP8"));
desc->AddContent(cricket::CN_VIDEO, MediaProtocolType::kRtp,
std::move(video));
diff --git a/pc/jsep_transport_controller.cc b/pc/jsep_transport_controller.cc
index 87de9fb..451dfec 100644
--- a/pc/jsep_transport_controller.cc
+++ b/pc/jsep_transport_controller.cc
@@ -257,7 +257,7 @@
RTCErrorOr<webrtc::PayloadType> JsepTransportController::SuggestPayloadType(
const std::string& mid,
- cricket::Codec codec) {
+ Codec codec) {
// Because SDP processing runs on the signal thread and Call processing
// runs on the worker thread, we allow cross thread invocation until we
// can clean up the thread work.
@@ -278,7 +278,7 @@
auto remote_result =
transport->remote_payload_types().LookupPayloadType(codec);
if (remote_result.ok()) {
- RTCErrorOr<cricket::Codec> local_result =
+ RTCErrorOr<Codec> local_result =
transport->local_payload_types().LookupCodec(remote_result.value());
if (local_result.ok()) {
// Already in use, possibly for something else.
@@ -303,7 +303,7 @@
RTCError JsepTransportController::AddLocalMapping(const std::string& mid,
PayloadType payload_type,
- const cricket::Codec& codec) {
+ const Codec& codec) {
// Because SDP processing runs on the signal thread and Call processing
// runs on the worker thread, we allow cross thread invocation until we
// can clean up the thread work.
diff --git a/pc/jsep_transport_controller.h b/pc/jsep_transport_controller.h
index 93eb01a..a3cf501 100644
--- a/pc/jsep_transport_controller.h
+++ b/pc/jsep_transport_controller.h
@@ -233,10 +233,10 @@
// The function will either return a PT already in use on the connection
// or a newly suggested one.
RTCErrorOr<PayloadType> SuggestPayloadType(const std::string& mid,
- cricket::Codec codec) override;
+ Codec codec) override;
RTCError AddLocalMapping(const std::string& mid,
PayloadType payload_type,
- const cricket::Codec& codec) override;
+ const Codec& codec) override;
const PayloadTypePicker& PayloadTypePickerForTesting() const {
return payload_type_picker_;
}
diff --git a/pc/jsep_transport_controller_unittest.cc b/pc/jsep_transport_controller_unittest.cc
index a9a9ccf..5a14c99 100644
--- a/pc/jsep_transport_controller_unittest.cc
+++ b/pc/jsep_transport_controller_unittest.cc
@@ -3004,8 +3004,7 @@
TEST_F(JsepTransportControllerTest, SuggestPayloadTypeBasic) {
auto config = JsepTransportController::Config();
CreateJsepTransportController(std::move(config));
- cricket::Codec pcmu_codec =
- cricket::CreateAudioCodec(-1, cricket::kPcmuCodecName, 8000, 1);
+ Codec pcmu_codec = CreateAudioCodec(-1, cricket::kPcmuCodecName, 8000, 1);
RTCErrorOr<PayloadType> pcmu_pt =
transport_controller_->SuggestPayloadType("mid", pcmu_codec);
ASSERT_TRUE(pcmu_pt.ok());
@@ -3016,8 +3015,7 @@
auto config = JsepTransportController::Config();
CreateJsepTransportController(std::move(config));
const PayloadType remote_lyra_pt(99);
- cricket::Codec remote_lyra_codec =
- cricket::CreateAudioCodec(remote_lyra_pt, "lyra", 8000, 1);
+ Codec remote_lyra_codec = CreateAudioCodec(remote_lyra_pt, "lyra", 8000, 1);
auto offer = std::make_unique<SessionDescription>();
AddAudioSection(offer.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
@@ -3026,8 +3024,7 @@
EXPECT_TRUE(transport_controller_
->SetRemoteDescription(SdpType::kOffer, nullptr, offer.get())
.ok());
- cricket::Codec local_lyra_codec =
- cricket::CreateAudioCodec(-1, "lyra", 8000, 1);
+ Codec local_lyra_codec = CreateAudioCodec(-1, "lyra", 8000, 1);
RTCErrorOr<PayloadType> lyra_pt =
transport_controller_->SuggestPayloadType(kAudioMid1, local_lyra_codec);
ASSERT_TRUE(lyra_pt.ok());
@@ -3040,8 +3037,7 @@
CreateJsepTransportController(std::move(config));
// libwebrtc will normally allocate 110 to DTMF/48000
const PayloadType remote_opus_pt(110);
- cricket::Codec remote_opus_codec =
- cricket::CreateAudioCodec(remote_opus_pt, "opus", 48000, 2);
+ Codec remote_opus_codec = CreateAudioCodec(remote_opus_pt, "opus", 48000, 2);
auto offer = std::make_unique<SessionDescription>();
AddAudioSection(offer.get(), kAudioMid1, kIceUfrag1, kIcePwd1,
cricket::ICEMODE_FULL, cricket::CONNECTIONROLE_ACTPASS,
@@ -3051,14 +3047,13 @@
->SetRemoteDescription(SdpType::kOffer, nullptr, offer.get())
.ok());
// Check that we get the Opus codec back with the remote PT
- cricket::Codec local_opus_codec =
- cricket::CreateAudioCodec(-1, "opus", 48000, 2);
+ Codec local_opus_codec = CreateAudioCodec(-1, "opus", 48000, 2);
RTCErrorOr<PayloadType> local_opus_pt =
transport_controller_->SuggestPayloadType(kAudioMid1, local_opus_codec);
EXPECT_EQ(local_opus_pt.value(), remote_opus_pt);
// Check that we don't get 110 allocated for DTMF, since it's in use for opus
- cricket::Codec local_other_codec =
- cricket::CreateAudioCodec(-1, cricket::kDtmfCodecName, 48000, 1);
+ Codec local_other_codec =
+ CreateAudioCodec(-1, cricket::kDtmfCodecName, 48000, 1);
RTCErrorOr<PayloadType> other_pt =
transport_controller_->SuggestPayloadType(kAudioMid1, local_other_codec);
ASSERT_TRUE(other_pt.ok());
diff --git a/pc/media_options.h b/pc/media_options.h
index d742a3f..bf25fc3 100644
--- a/pc/media_options.h
+++ b/pc/media_options.h
@@ -72,7 +72,7 @@
std::vector<RtpHeaderExtensionCapability> header_extensions;
// Codecs to include in a generated offer or answer.
// If this is used, session-level codec lists MUST be ignored.
- std::vector<cricket::Codec> codecs_to_include;
+ std::vector<Codec> codecs_to_include;
private:
// Doesn't DCHECK on `type`.
diff --git a/pc/media_session.cc b/pc/media_session.cc
index 5ac66b8..7c81eff 100644
--- a/pc/media_session.cc
+++ b/pc/media_session.cc
@@ -115,20 +115,19 @@
namespace {
-bool ContainsRtxCodec(const std::vector<cricket::Codec>& codecs) {
- return absl::c_find_if(codecs, [](const cricket::Codec& c) {
- return c.GetResiliencyType() == cricket::Codec::ResiliencyType::kRtx;
+bool ContainsRtxCodec(const std::vector<Codec>& codecs) {
+ return absl::c_find_if(codecs, [](const Codec& c) {
+ return c.GetResiliencyType() == Codec::ResiliencyType::kRtx;
}) != codecs.end();
}
-bool ContainsFlexfecCodec(const std::vector<cricket::Codec>& codecs) {
- return absl::c_find_if(codecs, [](const cricket::Codec& c) {
- return c.GetResiliencyType() ==
- cricket::Codec::ResiliencyType::kFlexfec;
+bool ContainsFlexfecCodec(const std::vector<Codec>& codecs) {
+ return absl::c_find_if(codecs, [](const Codec& c) {
+ return c.GetResiliencyType() == Codec::ResiliencyType::kFlexfec;
}) != codecs.end();
}
-bool IsComfortNoiseCodec(const cricket::Codec& codec) {
+bool IsComfortNoiseCodec(const Codec& codec) {
return absl::EqualsIgnoreCase(codec.name, cricket::kComfortNoiseCodecName);
}
@@ -410,7 +409,7 @@
RTCError CreateMediaContentOffer(
const MediaDescriptionOptions& media_description_options,
const MediaSessionOptions& session_options,
- const std::vector<cricket::Codec>& codecs,
+ const std::vector<Codec>& codecs,
const cricket::RtpHeaderExtensions& rtp_extensions,
UniqueRandomIdGenerator* ssrc_generator,
cricket::StreamParamsVec* current_streams,
@@ -546,7 +545,7 @@
}
bool SetCodecsInAnswer(const MediaContentDescription* offer,
- const std::vector<cricket::Codec>& local_codecs,
+ const std::vector<Codec>& local_codecs,
const MediaDescriptionOptions& media_description_options,
const MediaSessionOptions& session_options,
UniqueRandomIdGenerator* ssrc_generator,
@@ -1167,9 +1166,9 @@
RTC_DCHECK(media_description_options.type == webrtc::MediaType::AUDIO ||
media_description_options.type == webrtc::MediaType::VIDEO);
- std::vector<cricket::Codec> codecs_to_include;
+ std::vector<Codec> codecs_to_include;
std::string mid = media_description_options.mid;
- RTCErrorOr<std::vector<cricket::Codec>> error_or_filtered_codecs =
+ RTCErrorOr<std::vector<Codec>> error_or_filtered_codecs =
codec_lookup_helper_->CodecVendor(mid)->GetNegotiatedCodecsForOffer(
media_description_options, session_options, current_content,
*codec_lookup_helper_->PayloadTypeSuggester());
@@ -1329,8 +1328,8 @@
auto offer_rtd = offer_content_description->direction();
auto answer_rtd = NegotiateRtpTransceiverDirection(offer_rtd, wants_rtd);
- std::vector<cricket::Codec> codecs_to_include;
- RTCErrorOr<std::vector<cricket::Codec>> error_or_filtered_codecs =
+ std::vector<Codec> codecs_to_include;
+ RTCErrorOr<std::vector<Codec>> error_or_filtered_codecs =
codec_lookup_helper_->CodecVendor(media_description_options.mid)
->GetNegotiatedCodecsForAnswer(
media_description_options, session_options, offer_rtd, answer_rtd,
@@ -1343,7 +1342,7 @@
// Determine if we have media codecs in common.
bool has_usable_media_codecs =
std::find_if(codecs_to_include.begin(), codecs_to_include.end(),
- [](const cricket::Codec& c) {
+ [](const Codec& c) {
return c.IsMediaCodec() && !IsComfortNoiseCodec(c);
}) != codecs_to_include.end();
@@ -1364,7 +1363,7 @@
"WebRTC-RFC8888CongestionControlFeedback"));
for (auto& codec : codecs_to_include) {
codec.feedback_params.Remove(
- cricket::FeedbackParam(cricket::kRtcpFbParamTransportCc));
+ FeedbackParam(cricket::kRtcpFbParamTransportCc));
}
}
if (!SetCodecsInAnswer(offer_content_description, codecs_to_include,
diff --git a/pc/media_session_unittest.cc b/pc/media_session_unittest.cc
index 00b33a9..299db9e 100644
--- a/pc/media_session_unittest.cc
+++ b/pc/media_session_unittest.cc
@@ -102,45 +102,41 @@
::webrtc::CodecVendor codec_vendor_;
};
-cricket::Codec CreateRedAudioCodec(absl::string_view encoding_id) {
- cricket::Codec red = cricket::CreateAudioCodec(63, "red", 48000, 2);
+Codec CreateRedAudioCodec(absl::string_view encoding_id) {
+ Codec red = CreateAudioCodec(63, "red", 48000, 2);
red.SetParam(cricket::kCodecParamNotInNameValueFormat,
std::string(encoding_id) + '/' + std::string(encoding_id));
return red;
}
-const cricket::Codec kAudioCodecs1[] = {
- cricket::CreateAudioCodec(111, "opus", 48000, 2),
- CreateRedAudioCodec("111"),
- cricket::CreateAudioCodec(103, "G722", 16000, 1),
- cricket::CreateAudioCodec(0, "PCMU", 8000, 1),
- cricket::CreateAudioCodec(8, "PCMA", 8000, 1),
- cricket::CreateAudioCodec(107, "CN", 48000, 1)};
+const Codec 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 cricket::Codec kAudioCodecs2[] = {
- cricket::CreateAudioCodec(126, "foo", 16000, 1),
- cricket::CreateAudioCodec(0, "PCMU", 8000, 1),
- cricket::CreateAudioCodec(127, "G722", 16000, 1),
+const Codec kAudioCodecs2[] = {
+ CreateAudioCodec(126, "foo", 16000, 1),
+ CreateAudioCodec(0, "PCMU", 8000, 1),
+ CreateAudioCodec(127, "G722", 16000, 1),
};
-const cricket::Codec kAudioCodecsAnswer[] = {
- cricket::CreateAudioCodec(103, "G722", 16000, 1),
- cricket::CreateAudioCodec(0, "PCMU", 8000, 1),
+const Codec kAudioCodecsAnswer[] = {
+ CreateAudioCodec(103, "G722", 16000, 1),
+ CreateAudioCodec(0, "PCMU", 8000, 1),
};
-const cricket::Codec kVideoCodecs1[] = {
- cricket::CreateVideoCodec(96, "H264-SVC"),
- cricket::CreateVideoCodec(97, "H264")};
+const Codec kVideoCodecs1[] = {CreateVideoCodec(96, "H264-SVC"),
+ CreateVideoCodec(97, "H264")};
-const cricket::Codec kVideoCodecs1Reverse[] = {
- cricket::CreateVideoCodec(97, "H264"),
- cricket::CreateVideoCodec(96, "H264-SVC")};
+const Codec kVideoCodecs1Reverse[] = {CreateVideoCodec(97, "H264"),
+ CreateVideoCodec(96, "H264-SVC")};
-const cricket::Codec kVideoCodecs2[] = {cricket::CreateVideoCodec(126, "H264"),
- cricket::CreateVideoCodec(127, "H263")};
+const Codec kVideoCodecs2[] = {CreateVideoCodec(126, "H264"),
+ CreateVideoCodec(127, "H263")};
-const cricket::Codec kVideoCodecsAnswer[] = {
- cricket::CreateVideoCodec(97, "H264")};
+const Codec 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,
@@ -182,27 +178,27 @@
kVideoCodecsH265Level6LevelId},
{"tx-mode", "SRST"}});
-const cricket::Codec kVideoCodecsH265Level31[] = {
- cricket::CreateVideoCodec(96, kH265MainProfileLevel31Sdp)};
-const cricket::Codec kVideoCodecsH265Level4[] = {
- cricket::CreateVideoCodec(96, kH265MainProfileLevel4Sdp)};
-const cricket::Codec kVideoCodecsH265Level5[] = {
- cricket::CreateVideoCodec(96, kH265MainProfileLevel5Sdp)};
-const cricket::Codec kVideoCodecsH265Level52[] = {
- cricket::CreateVideoCodec(96, kH265MainProfileLevel52Sdp)};
-const cricket::Codec kVideoCodecsH265Level6[] = {
- cricket::CreateVideoCodec(96, kH265MainProfileLevel6Sdp)};
+const Codec kVideoCodecsH265Level31[] = {
+ CreateVideoCodec(96, kH265MainProfileLevel31Sdp)};
+const Codec kVideoCodecsH265Level4[] = {
+ CreateVideoCodec(96, kH265MainProfileLevel4Sdp)};
+const Codec kVideoCodecsH265Level5[] = {
+ CreateVideoCodec(96, kH265MainProfileLevel5Sdp)};
+const Codec kVideoCodecsH265Level52[] = {
+ CreateVideoCodec(96, kH265MainProfileLevel52Sdp)};
+const Codec kVideoCodecsH265Level6[] = {
+ CreateVideoCodec(96, kH265MainProfileLevel6Sdp)};
// Match two codec lists for content, but ignore the ID.
-bool CodecListsMatch(rtc::ArrayView<const cricket::Codec> list1,
- rtc::ArrayView<const cricket::Codec> list2) {
+bool CodecListsMatch(rtc::ArrayView<const Codec> list1,
+ rtc::ArrayView<const Codec> list2) {
if (list1.size() != list2.size()) {
return false;
}
for (size_t i = 0; i < list1.size(); ++i) {
- cricket::Codec codec1 = list1[i];
- cricket::Codec codec2 = list2[i];
- codec1.id = cricket::Codec::kIdNotSet;
- codec2.id = cricket::Codec::kIdNotSet;
+ Codec codec1 = list1[i];
+ Codec codec2 = list2[i];
+ codec1.id = Codec::kIdNotSet;
+ codec2.id = Codec::kIdNotSet;
if (codec1 != codec2) {
RTC_LOG(LS_ERROR) << "Mismatch at position " << i << " between " << codec1
<< " and " << codec2;
@@ -383,13 +379,13 @@
constexpr bool kActive = false;
// Helper used for debugging. It reports the media type and the parameters.
-std::string FullMimeType(cricket::Codec codec) {
+std::string FullMimeType(Codec codec) {
StringBuilder sb;
switch (codec.type) {
- case cricket::Codec::Type::kAudio:
+ case Codec::Type::kAudio:
sb << "audio/";
break;
- case cricket::Codec::Type::kVideo:
+ case Codec::Type::kVideo:
sb << "video/";
break;
}
@@ -411,15 +407,13 @@
return content->media_description()->direction();
}
-void AddRtxCodec(const cricket::Codec& rtx_codec,
- std::vector<cricket::Codec>* codecs) {
+void AddRtxCodec(const Codec& rtx_codec, std::vector<Codec>* codecs) {
RTC_LOG(LS_VERBOSE) << "Adding RTX codec " << FullMimeType(rtx_codec);
- ASSERT_FALSE(cricket::FindCodecById(*codecs, rtx_codec.id));
+ ASSERT_FALSE(FindCodecById(*codecs, rtx_codec.id));
codecs->push_back(rtx_codec);
}
-std::vector<std::string> GetCodecNames(
- const std::vector<cricket::Codec>& codecs) {
+std::vector<std::string> GetCodecNames(const std::vector<Codec>& codecs) {
std::vector<std::string> codec_names;
codec_names.reserve(codecs.size());
for (const auto& codec : codecs) {
@@ -725,7 +719,7 @@
bool VerifyNoCNCodecs(const ContentInfo* content) {
RTC_DCHECK(content);
RTC_CHECK(content->media_description());
- for (const cricket::Codec& codec : content->media_description()->codecs()) {
+ for (const Codec& codec : content->media_description()->codecs()) {
if (codec.name == "CN") {
return false;
}
@@ -920,7 +914,7 @@
MediaSessionOptions opts;
SdpAudioFormat audio_format("custom-audio", 8000, 2);
- cricket::Codec custom_audio_codec = cricket::CreateAudioCodec(audio_format);
+ Codec custom_audio_codec = CreateAudioCodec(audio_format);
custom_audio_codec.id = 123; // picked at random, but valid
auto audio_options =
MediaDescriptionOptions(webrtc::MediaType::AUDIO, "0",
@@ -928,7 +922,7 @@
audio_options.codecs_to_include.push_back(custom_audio_codec);
opts.media_description_options.push_back(audio_options);
- cricket::Codec custom_video_codec = cricket::CreateVideoCodec("custom-video");
+ Codec custom_video_codec = CreateVideoCodec("custom-video");
custom_video_codec.id = 124; // picked at random, but valid
auto video_options =
MediaDescriptionOptions(webrtc::MediaType::VIDEO, "1",
@@ -968,7 +962,7 @@
// 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);
- cricket::Codec custom_audio_codec = cricket::CreateAudioCodec(audio_format);
+ Codec custom_audio_codec = CreateAudioCodec(audio_format);
custom_audio_codec.id = 123; // picked at random, but valid
auto audio_options =
MediaDescriptionOptions(webrtc::MediaType::AUDIO, "audio",
@@ -976,7 +970,7 @@
audio_options.codecs_to_include.push_back(custom_audio_codec);
answer_opts.media_description_options.push_back(audio_options);
- cricket::Codec custom_video_codec = cricket::CreateVideoCodec("custom-video");
+ Codec custom_video_codec = CreateVideoCodec("custom-video");
custom_video_codec.id = 124;
auto video_options =
MediaDescriptionOptions(webrtc::MediaType::VIDEO, "video",
@@ -1012,9 +1006,9 @@
// RTP paylod type. The test verifies that the offer don't contain the
// duplicate RTP payload types.
TEST_F(MediaSessionDescriptionFactoryTest, TestBundleOfferWithSameCodecPlType) {
- cricket::Codec offered_video_codec =
+ Codec offered_video_codec =
codec_lookup_helper_2_.CodecVendor("")->video_sendrecv_codecs()[0];
- cricket::Codec offered_audio_codec =
+ Codec offered_audio_codec =
codec_lookup_helper_2_.CodecVendor("")->audio_sendrecv_codecs()[0];
ASSERT_EQ(offered_video_codec.id, offered_audio_codec.id);
@@ -1474,11 +1468,11 @@
AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "audio",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- std::vector f1_codecs = {cricket::CreateAudioCodec(96, "opus", 48000, 1)};
+ std::vector f1_codecs = {CreateAudioCodec(96, "opus", 48000, 1)};
codec_lookup_helper_1_.CodecVendor("")->set_audio_codecs(f1_codecs,
f1_codecs);
- std::vector f2_codecs = {cricket::CreateAudioCodec(0, "PCMU", 8000, 1)};
+ std::vector f2_codecs = {CreateAudioCodec(0, "PCMU", 8000, 1)};
codec_lookup_helper_2_.CodecVendor("")->set_audio_codecs(f2_codecs,
f2_codecs);
@@ -1527,11 +1521,11 @@
AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- std::vector f1_codecs = {cricket::CreateVideoCodec(96, "H264")};
+ std::vector f1_codecs = {CreateVideoCodec(96, "H264")};
codec_lookup_helper_1_.CodecVendor("")->set_video_codecs(f1_codecs,
f1_codecs);
- std::vector f2_codecs = {cricket::CreateVideoCodec(97, "VP8")};
+ std::vector f2_codecs = {CreateVideoCodec(97, "VP8")};
codec_lookup_helper_2_.CodecVendor("")->set_video_codecs(f2_codecs,
f2_codecs);
@@ -1552,13 +1546,13 @@
AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video",
RtpTransceiverDirection::kSendRecv, kActive,
&opts);
- std::vector f1_codecs = {cricket::CreateVideoCodec(96, "H264"),
- cricket::CreateVideoCodec(118, "flexfec-03")};
+ std::vector f1_codecs = {CreateVideoCodec(96, "H264"),
+ CreateVideoCodec(118, "flexfec-03")};
codec_lookup_helper_1_.CodecVendor("")->set_video_codecs(f1_codecs,
f1_codecs);
- std::vector f2_codecs = {cricket::CreateVideoCodec(97, "VP8"),
- cricket::CreateVideoCodec(118, "flexfec-03")};
+ std::vector f2_codecs = {CreateVideoCodec(97, "VP8"),
+ CreateVideoCodec(118, "flexfec-03")};
codec_lookup_helper_2_.CodecVendor("")->set_video_codecs(f2_codecs,
f2_codecs);
@@ -3101,7 +3095,7 @@
// preference order.
// TODO(wu): `updated_offer` should not include the codec
// (i.e. `kAudioCodecs2[0]`) the other side doesn't support.
- const cricket::Codec kUpdatedAudioCodecOffer[] = {
+ const Codec kUpdatedAudioCodecOffer[] = {
kAudioCodecsAnswer[0],
kAudioCodecsAnswer[1],
kAudioCodecs2[0],
@@ -3110,7 +3104,7 @@
// 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 cricket::Codec kUpdatedVideoCodecOffer[] = {
+ const Codec kUpdatedVideoCodecOffer[] = {
kVideoCodecsAnswer[0],
kVideoCodecs2[1],
};
@@ -3128,10 +3122,10 @@
// that is being recycled.
TEST_F(MediaSessionDescriptionFactoryTest,
ReOfferDoesNotReUseRecycledAudioCodecs) {
- codec_lookup_helper_1_.CodecVendor("")->set_video_codecs(
- cricket::CodecList{}, cricket::CodecList{});
- codec_lookup_helper_2_.CodecVendor("")->set_video_codecs(
- cricket::CodecList{}, cricket::CodecList{});
+ codec_lookup_helper_1_.CodecVendor("")->set_video_codecs(CodecList{},
+ CodecList{});
+ codec_lookup_helper_2_.CodecVendor("")->set_video_codecs(CodecList{},
+ CodecList{});
MediaSessionOptions opts;
AddMediaDescriptionOptions(webrtc::MediaType::AUDIO, "a0",
@@ -3164,10 +3158,10 @@
// that is being recycled.
TEST_F(MediaSessionDescriptionFactoryTest,
ReOfferDoesNotReUseRecycledVideoCodecs) {
- codec_lookup_helper_1_.CodecVendor("")->set_audio_codecs(
- cricket::CodecList{}, cricket::CodecList{});
- codec_lookup_helper_2_.CodecVendor("")->set_audio_codecs(
- cricket::CodecList{}, cricket::CodecList{});
+ codec_lookup_helper_1_.CodecVendor("")->set_audio_codecs(CodecList{},
+ CodecList{});
+ codec_lookup_helper_2_.CodecVendor("")->set_audio_codecs(CodecList{},
+ CodecList{});
MediaSessionOptions opts;
AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "v0",
@@ -3193,10 +3187,10 @@
// section that is being recycled.
TEST_F(MediaSessionDescriptionFactoryTest,
ReAnswerDoesNotReUseRecycledAudioCodecs) {
- codec_lookup_helper_1_.CodecVendor("")->set_video_codecs(
- cricket::CodecList{}, cricket::CodecList{});
- codec_lookup_helper_2_.CodecVendor("")->set_video_codecs(
- cricket::CodecList{}, cricket::CodecList{});
+ codec_lookup_helper_1_.CodecVendor("")->set_video_codecs(CodecList{},
+ CodecList{});
+ codec_lookup_helper_2_.CodecVendor("")->set_video_codecs(CodecList{},
+ CodecList{});
// Perform initial offer/answer in reverse (`f2_` as offerer) so that the
// second offer/answer is forward (`f1_` as offerer).
@@ -3227,10 +3221,10 @@
// section that is being recycled.
TEST_F(MediaSessionDescriptionFactoryTest,
ReAnswerDoesNotReUseRecycledVideoCodecs) {
- codec_lookup_helper_1_.CodecVendor("")->set_audio_codecs(
- cricket::CodecList{}, cricket::CodecList{});
- codec_lookup_helper_2_.CodecVendor("")->set_audio_codecs(
- cricket::CodecList{}, cricket::CodecList{});
+ codec_lookup_helper_1_.CodecVendor("")->set_audio_codecs(CodecList{},
+ CodecList{});
+ codec_lookup_helper_2_.CodecVendor("")->set_audio_codecs(CodecList{},
+ CodecList{});
// Perform initial offer/answer in reverse (`f2_` as offerer) so that the
// second offer/answer is forward (`f1_` as offerer).
@@ -3266,17 +3260,15 @@
AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video",
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
- std::vector<cricket::Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
+ std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
// This creates rtx for H264 with the payload type `f1_` uses.
- AddRtxCodec(cricket::CreateVideoRtxCodec(126, kVideoCodecs1[1].id),
- &f1_codecs);
+ AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
codec_lookup_helper_1_.CodecVendor("")->set_video_codecs(f1_codecs,
f1_codecs);
- std::vector<cricket::Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
+ std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
// This creates rtx for H264 with the payload type `f2_` uses.
- AddRtxCodec(cricket::CreateVideoRtxCodec(125, kVideoCodecs2[0].id),
- &f2_codecs);
+ AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs);
codec_lookup_helper_2_.CodecVendor("")->set_video_codecs(f2_codecs,
f2_codecs);
@@ -3289,9 +3281,8 @@
const VideoContentDescription* vcd =
GetFirstVideoContentDescription(answer.get());
- std::vector<cricket::Codec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
- AddRtxCodec(cricket::CreateVideoRtxCodec(126, kVideoCodecs1[1].id),
- &expected_codecs);
+ std::vector<Codec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
+ AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &expected_codecs);
EXPECT_TRUE(CodecListsMatch(expected_codecs, vcd->codecs()));
@@ -3324,26 +3315,23 @@
&opts);
// We specifically choose different preferred payload types for VP8 to
// trigger the issue.
- cricket::Codec vp8_offerer = cricket::CreateVideoCodec(100, "VP8");
- cricket::Codec vp8_offerer_rtx =
- cricket::CreateVideoRtxCodec(101, vp8_offerer.id);
- cricket::Codec vp8_answerer = cricket::CreateVideoCodec(110, "VP8");
- cricket::Codec vp8_answerer_rtx =
- cricket::CreateVideoRtxCodec(111, vp8_answerer.id);
- cricket::Codec vp9 = cricket::CreateVideoCodec(120, "VP9");
- cricket::Codec vp9_rtx = cricket::CreateVideoRtxCodec(121, vp9.id);
+ Codec vp8_offerer = CreateVideoCodec(100, "VP8");
+ Codec vp8_offerer_rtx = CreateVideoRtxCodec(101, vp8_offerer.id);
+ Codec vp8_answerer = CreateVideoCodec(110, "VP8");
+ Codec vp8_answerer_rtx = CreateVideoRtxCodec(111, vp8_answerer.id);
+ Codec vp9 = CreateVideoCodec(120, "VP9");
+ Codec vp9_rtx = CreateVideoRtxCodec(121, vp9.id);
- std::vector<cricket::Codec> f1_codecs = {vp8_offerer, vp8_offerer_rtx};
+ std::vector<Codec> f1_codecs = {vp8_offerer, vp8_offerer_rtx};
// We also specifically cause the answerer to prefer VP9, such that if it
// *doesn't* honor the existing preferred codec (VP8) we'll notice.
- std::vector<cricket::Codec> f2_codecs = {vp9, vp9_rtx, vp8_answerer,
- vp8_answerer_rtx};
+ std::vector<Codec> f2_codecs = {vp9, vp9_rtx, vp8_answerer, vp8_answerer_rtx};
codec_lookup_helper_1_.CodecVendor("")->set_video_codecs(f1_codecs,
f1_codecs);
codec_lookup_helper_2_.CodecVendor("")->set_video_codecs(f2_codecs,
f2_codecs);
- std::vector<cricket::Codec> audio_codecs;
+ std::vector<Codec> audio_codecs;
codec_lookup_helper_1_.CodecVendor("")->set_audio_codecs(audio_codecs,
audio_codecs);
codec_lookup_helper_2_.CodecVendor("")->set_audio_codecs(audio_codecs,
@@ -3363,7 +3351,7 @@
const VideoContentDescription* vcd =
GetFirstVideoContentDescription(updated_offer.get());
- std::vector<cricket::Codec> codecs = vcd->codecs();
+ std::vector<Codec> codecs = vcd->codecs();
ASSERT_EQ(4u, codecs.size());
EXPECT_EQ(vp8_offerer, codecs[0]);
EXPECT_EQ(vp8_offerer_rtx, codecs[1]);
@@ -3377,10 +3365,9 @@
// use, the added codecs payload types are changed.
TEST_F(MediaSessionDescriptionFactoryTest,
RespondentCreatesOfferWithVideoAndRtxAfterCreatingAudioAnswer) {
- std::vector<cricket::Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
+ std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
// This creates rtx for H264 with the payload type `f1_` uses.
- AddRtxCodec(cricket::CreateVideoRtxCodec(126, kVideoCodecs1[1].id),
- &f1_codecs);
+ AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
codec_lookup_helper_1_.CodecVendor("")->set_video_codecs(f1_codecs,
f1_codecs);
@@ -3404,11 +3391,11 @@
opts.media_description_options.clear();
AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts);
- std::vector<cricket::Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
+ std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
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(cricket::CreateVideoRtxCodec(125, used_pl_type), &f2_codecs);
+ AddRtxCodec(CreateVideoRtxCodec(125, used_pl_type), &f2_codecs);
codec_lookup_helper_2_.CodecVendor("")->set_video_codecs(f2_codecs,
f2_codecs);
@@ -3430,7 +3417,7 @@
ASSERT_EQ(cricket::kRtxCodecName, updated_vcd->codecs()[1].name);
int new_h264_pl_type = updated_vcd->codecs()[0].id;
EXPECT_NE(used_pl_type, new_h264_pl_type);
- cricket::Codec rtx = updated_vcd->codecs()[1];
+ Codec rtx = updated_vcd->codecs()[1];
int pt_referenced_by_rtx =
FromString<int>(rtx.params[cricket::kCodecParamAssociatedPayloadType]);
EXPECT_EQ(new_h264_pl_type, pt_referenced_by_rtx);
@@ -3444,10 +3431,9 @@
MediaSessionOptions opts;
AddAudioVideoSections(RtpTransceiverDirection::kRecvOnly, &opts);
- std::vector<cricket::Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
+ std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
// This creates rtx for H264 with the payload type `f2_` uses.
- AddRtxCodec(cricket::CreateVideoRtxCodec(125, kVideoCodecs2[0].id),
- &f2_codecs);
+ AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs);
codec_lookup_helper_2_.CodecVendor("")->set_video_codecs(f2_codecs,
f2_codecs);
@@ -3460,7 +3446,7 @@
const VideoContentDescription* vcd =
GetFirstVideoContentDescription(answer.get());
- std::vector<cricket::Codec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
+ std::vector<Codec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
EXPECT_EQ(expected_codecs, vcd->codecs());
// Now, ensure that the RTX codec is created correctly when `f2_` creates an
@@ -3475,8 +3461,7 @@
// New offer should attempt to add H263, and RTX for H264.
expected_codecs.push_back(kVideoCodecs2[1]);
- AddRtxCodec(cricket::CreateVideoRtxCodec(125, kVideoCodecs1[1].id),
- &expected_codecs);
+ AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs1[1].id), &expected_codecs);
EXPECT_TRUE(CodecListsMatch(expected_codecs, updated_vcd->codecs()));
}
@@ -3486,17 +3471,15 @@
AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video",
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
- std::vector<cricket::Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
+ std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
// This creates RTX without associated payload type parameter.
- AddRtxCodec(cricket::CreateVideoCodec(126, cricket::kRtxCodecName),
- &f1_codecs);
+ AddRtxCodec(CreateVideoCodec(126, cricket::kRtxCodecName), &f1_codecs);
codec_lookup_helper_1_.CodecVendor("")->set_video_codecs(f1_codecs,
f1_codecs);
- std::vector<cricket::Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
+ std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
// This creates RTX for H264 with the payload type `f2_` uses.
- AddRtxCodec(cricket::CreateVideoRtxCodec(125, kVideoCodecs2[0].id),
- &f2_codecs);
+ AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs);
codec_lookup_helper_2_.CodecVendor("")->set_video_codecs(f2_codecs,
f2_codecs);
@@ -3510,8 +3493,8 @@
MediaContentDescription* media_desc =
offer->GetContentDescriptionByName(cricket::CN_VIDEO);
ASSERT_TRUE(media_desc);
- std::vector<cricket::Codec> codecs = media_desc->codecs();
- for (cricket::Codec& codec : codecs) {
+ std::vector<Codec> codecs = media_desc->codecs();
+ for (Codec& codec : codecs) {
if (absl::StartsWith(codec.name, cricket::kRtxCodecName)) {
codec.params.clear();
}
@@ -3533,17 +3516,15 @@
AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video",
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
- std::vector<cricket::Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
+ std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
// This creates RTX for H264 in sender.
- AddRtxCodec(cricket::CreateVideoRtxCodec(126, kVideoCodecs1[1].id),
- &f1_codecs);
+ AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
codec_lookup_helper_1_.CodecVendor("")->set_video_codecs(f1_codecs,
f1_codecs);
- std::vector<cricket::Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
+ std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
// This creates RTX for H263 in receiver.
- AddRtxCodec(cricket::CreateVideoRtxCodec(125, kVideoCodecs2[1].id),
- &f2_codecs);
+ AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs2[1].id), &f2_codecs);
codec_lookup_helper_2_.CodecVendor("")->set_video_codecs(f2_codecs,
f2_codecs);
@@ -3568,23 +3549,20 @@
AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video",
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
- std::vector<cricket::Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
+ std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
// This creates RTX for H264-SVC in sender.
- AddRtxCodec(cricket::CreateVideoRtxCodec(125, kVideoCodecs1[0].id),
- &f1_codecs);
+ AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs1[0].id), &f1_codecs);
codec_lookup_helper_1_.CodecVendor("")->set_video_codecs(f1_codecs,
f1_codecs);
// This creates RTX for H264 in sender.
- AddRtxCodec(cricket::CreateVideoRtxCodec(126, kVideoCodecs1[1].id),
- &f1_codecs);
+ AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
codec_lookup_helper_1_.CodecVendor("")->set_video_codecs(f1_codecs,
f1_codecs);
- std::vector<cricket::Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
+ std::vector<Codec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
// This creates RTX for H264 in receiver.
- AddRtxCodec(cricket::CreateVideoRtxCodec(124, kVideoCodecs2[0].id),
- &f2_codecs);
+ AddRtxCodec(CreateVideoRtxCodec(124, kVideoCodecs2[0].id), &f2_codecs);
codec_lookup_helper_2_.CodecVendor("")->set_video_codecs(f2_codecs,
f1_codecs);
@@ -3597,9 +3575,8 @@
f2_.CreateAnswerOrError(offer.get(), opts, nullptr).MoveValue();
const VideoContentDescription* vcd =
GetFirstVideoContentDescription(answer.get());
- std::vector<cricket::Codec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
- AddRtxCodec(cricket::CreateVideoRtxCodec(126, kVideoCodecs1[1].id),
- &expected_codecs);
+ std::vector<Codec> expected_codecs = MAKE_VECTOR(kVideoCodecsAnswer);
+ AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &expected_codecs);
EXPECT_TRUE(CodecListsMatch(expected_codecs, vcd->codecs()));
}
@@ -3611,10 +3588,9 @@
AddMediaDescriptionOptions(webrtc::MediaType::VIDEO, "video",
RtpTransceiverDirection::kRecvOnly, kActive,
&opts);
- std::vector<cricket::Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
+ std::vector<Codec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
// This creates RTX for H264 for the offerer.
- AddRtxCodec(cricket::CreateVideoRtxCodec(126, kVideoCodecs1[1].id),
- &f1_codecs);
+ AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
codec_lookup_helper_1_.CodecVendor("")->set_video_codecs(f1_codecs,
f1_codecs);
@@ -3624,14 +3600,12 @@
const VideoContentDescription* vcd =
GetFirstVideoContentDescription(offer.get());
- std::vector<cricket::Codec> expected_codecs = MAKE_VECTOR(kVideoCodecs1);
- AddRtxCodec(cricket::CreateVideoRtxCodec(126, kVideoCodecs1[1].id),
- &expected_codecs);
+ std::vector<Codec> expected_codecs = MAKE_VECTOR(kVideoCodecs1);
+ AddRtxCodec(CreateVideoRtxCodec(126, kVideoCodecs1[1].id), &expected_codecs);
EXPECT_TRUE(CodecListsMatch(expected_codecs, vcd->codecs()));
// Now, attempt to add RTX for H264-SVC.
- AddRtxCodec(cricket::CreateVideoRtxCodec(125, kVideoCodecs1[0].id),
- &f1_codecs);
+ AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs1[0].id), &f1_codecs);
codec_lookup_helper_1_.CodecVendor("")->set_video_codecs(f1_codecs,
f1_codecs);
@@ -3640,8 +3614,7 @@
ASSERT_TRUE(updated_offer);
vcd = GetFirstVideoContentDescription(updated_offer.get());
- AddRtxCodec(cricket::CreateVideoRtxCodec(125, kVideoCodecs1[0].id),
- &expected_codecs);
+ AddRtxCodec(CreateVideoRtxCodec(125, kVideoCodecs1[0].id), &expected_codecs);
EXPECT_TRUE(CodecListsMatch(expected_codecs, vcd->codecs()));
}
@@ -3657,9 +3630,9 @@
"stream1", {"stream1label"}, 3, &opts);
// Use a single real codec, and then add RTX for it.
- std::vector<cricket::Codec> f1_codecs;
- f1_codecs.push_back(cricket::CreateVideoCodec(97, "H264"));
- AddRtxCodec(cricket::CreateVideoRtxCodec(125, 97), &f1_codecs);
+ std::vector<Codec> f1_codecs;
+ f1_codecs.push_back(CreateVideoCodec(97, "H264"));
+ AddRtxCodec(CreateVideoRtxCodec(125, 97), &f1_codecs);
codec_lookup_helper_1_.CodecVendor("")->set_video_codecs(f1_codecs,
f1_codecs);
@@ -3702,9 +3675,9 @@
"stream1", {"stream1label"}, 1, &opts);
// Use a single real codec, and then add FlexFEC for it.
- std::vector<cricket::Codec> f1_codecs;
- f1_codecs.push_back(cricket::CreateVideoCodec(97, "H264"));
- f1_codecs.push_back(cricket::CreateVideoCodec(118, "flexfec-03"));
+ std::vector<Codec> f1_codecs;
+ f1_codecs.push_back(CreateVideoCodec(97, "H264"));
+ f1_codecs.push_back(CreateVideoCodec(118, "flexfec-03"));
codec_lookup_helper_1_.CodecVendor("")->set_video_codecs(f1_codecs,
f1_codecs);
@@ -3746,9 +3719,9 @@
"stream1", {"stream1label"}, 3, &opts);
// Use a single real codec, and then add FlexFEC for it.
- std::vector<cricket::Codec> f1_codecs;
- f1_codecs.push_back(cricket::CreateVideoCodec(97, "H264"));
- f1_codecs.push_back(cricket::CreateVideoCodec(118, "flexfec-03"));
+ std::vector<Codec> f1_codecs;
+ f1_codecs.push_back(CreateVideoCodec(97, "H264"));
+ f1_codecs.push_back(CreateVideoCodec(118, "flexfec-03"));
codec_lookup_helper_1_.CodecVendor("")->set_video_codecs(f1_codecs,
f1_codecs);
@@ -4422,12 +4395,12 @@
// Test verifying that negotiating codecs with the same tx-mode retains the
// tx-mode value.
TEST_F(MediaSessionDescriptionFactoryTest, H265TxModeIsEqualRetainIt) {
- std::vector f1_codecs = {cricket::CreateVideoCodec(96, "H265")};
+ std::vector f1_codecs = {CreateVideoCodec(96, "H265")};
f1_codecs.back().tx_mode = "mrst";
codec_lookup_helper_1_.CodecVendor("")->set_video_codecs(f1_codecs,
f1_codecs);
- std::vector f2_codecs = {cricket::CreateVideoCodec(96, "H265")};
+ std::vector f2_codecs = {CreateVideoCodec(96, "H265")};
f2_codecs.back().tx_mode = "mrst";
codec_lookup_helper_2_.CodecVendor("")->set_video_codecs(f2_codecs,
f2_codecs);
@@ -4460,12 +4433,12 @@
// Test verifying that negotiating codecs with different tx_mode removes
// the tx_mode value.
TEST_F(MediaSessionDescriptionFactoryTest, H265TxModeIsDifferentDropCodecs) {
- std::vector f1_codecs = {cricket::CreateVideoCodec(96, "H265")};
+ std::vector f1_codecs = {CreateVideoCodec(96, "H265")};
f1_codecs.back().tx_mode = "mrst";
codec_lookup_helper_1_.CodecVendor("")->set_video_codecs(f1_codecs,
f1_codecs);
- std::vector f2_codecs = {cricket::CreateVideoCodec(96, "H265")};
+ std::vector f2_codecs = {CreateVideoCodec(96, "H265")};
f2_codecs.back().tx_mode = "mrmt";
codec_lookup_helper_2_.CodecVendor("")->set_video_codecs(f2_codecs,
f2_codecs);
@@ -4499,12 +4472,12 @@
// Test verifying that negotiating codecs with the same packetization retains
// the packetization value.
TEST_F(MediaSessionDescriptionFactoryTest, PacketizationIsEqual) {
- std::vector f1_codecs = {cricket::CreateVideoCodec(96, "H264")};
+ std::vector f1_codecs = {CreateVideoCodec(96, "H264")};
f1_codecs.back().packetization = "raw";
codec_lookup_helper_1_.CodecVendor("")->set_video_codecs(f1_codecs,
f1_codecs);
- std::vector f2_codecs = {cricket::CreateVideoCodec(96, "H264")};
+ std::vector f2_codecs = {CreateVideoCodec(96, "H264")};
f2_codecs.back().packetization = "raw";
codec_lookup_helper_2_.CodecVendor("")->set_video_codecs(f2_codecs,
f2_codecs);
@@ -4537,12 +4510,12 @@
// Test verifying that negotiating codecs with different packetization removes
// the packetization value.
TEST_F(MediaSessionDescriptionFactoryTest, PacketizationIsDifferent) {
- std::vector f1_codecs = {cricket::CreateVideoCodec(96, "H264")};
+ std::vector f1_codecs = {CreateVideoCodec(96, "H264")};
f1_codecs.back().packetization = "raw";
codec_lookup_helper_1_.CodecVendor("")->set_video_codecs(f1_codecs,
f1_codecs);
- std::vector f2_codecs = {cricket::CreateVideoCodec(96, "H264")};
+ std::vector f2_codecs = {CreateVideoCodec(96, "H264")};
f2_codecs.back().packetization = "notraw";
codec_lookup_helper_2_.CodecVendor("")->set_video_codecs(f2_codecs,
f2_codecs);
@@ -4716,10 +4689,10 @@
H264MatchCriteriaIncludesPacketizationMode) {
// Create two H264 codecs with the same profile level ID and different
// packetization modes.
- cricket::Codec h264_pm0 = cricket::CreateVideoCodec(96, "H264");
+ Codec h264_pm0 = CreateVideoCodec(96, "H264");
h264_pm0.params[cricket::kH264FmtpProfileLevelId] = "42c01f";
h264_pm0.params[cricket::kH264FmtpPacketizationMode] = "0";
- cricket::Codec h264_pm1 = cricket::CreateVideoCodec(97, "H264");
+ Codec h264_pm1 = CreateVideoCodec(97, "H264");
h264_pm1.params[cricket::kH264FmtpProfileLevelId] = "42c01f";
h264_pm1.params[cricket::kH264FmtpPacketizationMode] = "1";
@@ -4819,8 +4792,8 @@
ValuesIn(kMediaProtocolsDtls));
// Compare the two vectors of codecs ignoring the payload type.
-bool CodecsMatch(const std::vector<cricket::Codec>& codecs1,
- const std::vector<cricket::Codec>& codecs2) {
+bool CodecsMatch(const std::vector<Codec>& codecs1,
+ const std::vector<Codec>& codecs2) {
if (codecs1.size() != codecs2.size()) {
return false;
}
@@ -4843,10 +4816,9 @@
CodecLookupHelperForTesting codec_lookup_helper(field_trials);
MediaSessionDescriptionFactory sf(nullptr, false, &ssrc_generator, &tdf,
&codec_lookup_helper);
- const std::vector<cricket::Codec> send_codecs = MAKE_VECTOR(kAudioCodecs1);
- const std::vector<cricket::Codec> recv_codecs = MAKE_VECTOR(kAudioCodecs2);
- const std::vector<cricket::Codec> sendrecv_codecs =
- MAKE_VECTOR(kAudioCodecsAnswer);
+ const std::vector<Codec> send_codecs = MAKE_VECTOR(kAudioCodecs1);
+ const std::vector<Codec> recv_codecs = MAKE_VECTOR(kAudioCodecs2);
+ const std::vector<Codec> sendrecv_codecs = MAKE_VECTOR(kAudioCodecsAnswer);
codec_lookup_helper.CodecVendor("")->set_audio_codecs(send_codecs,
recv_codecs);
@@ -4888,14 +4860,13 @@
// Since the PT suggester reserves the static range for specific codecs,
// PT numbers from the 36-63 range are used.
-const cricket::Codec kOfferAnswerCodecs[] = {
- cricket::CreateAudioCodec(40, "codec0", 16000, 1),
- cricket::CreateAudioCodec(41, "codec1", 8000, 1),
- cricket::CreateAudioCodec(42, "codec2", 8000, 1),
- cricket::CreateAudioCodec(43, "codec3", 8000, 1),
- cricket::CreateAudioCodec(44, "codec4", 8000, 2),
- cricket::CreateAudioCodec(45, "codec5", 32000, 1),
- cricket::CreateAudioCodec(46, "codec6", 48000, 1)};
+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
@@ -5001,7 +4972,7 @@
ASSERT_EQ(webrtc::MediaType::AUDIO, ac->media_description()->type());
const MediaContentDescription* acd = ac->media_description();
- std::vector<cricket::Codec> target_codecs;
+ std::vector<Codec> target_codecs;
// For offers with sendrecv or inactive, we should never reply with more
// codecs than offered, with these codec sets.
switch (offer_direction) {
@@ -5034,7 +5005,7 @@
RTC_DCHECK_NOTREACHED();
}
- auto format_codecs = [](const std::vector<cricket::Codec>& codecs) {
+ auto format_codecs = [](const std::vector<Codec>& codecs) {
StringBuilder os;
bool first = true;
os << "{";
@@ -5118,7 +5089,7 @@
std::unique_ptr<SSLIdentity>(new FakeSSLIdentity("answer_id"))));
}
- void CheckH265Level(const std::vector<cricket::Codec>& codecs,
+ void CheckH265Level(const std::vector<Codec>& codecs,
const std::string& expected_level) {
for (const auto& codec : codecs) {
if (codec.name == "H265") {
@@ -5145,11 +5116,9 @@
// Offer: level 5.2, SendRecv
// Answer: level 5.2, SendRecv
TEST_F(VideoCodecsOfferH265LevelIdTest, TestSendRecvSymmetrical) {
- const std::vector<cricket::Codec> send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> sendrecv_codecs =
+ const std::vector<Codec> send_codecs = MAKE_VECTOR(kVideoCodecsH265Level52);
+ const std::vector<Codec> recv_codecs = MAKE_VECTOR(kVideoCodecsH265Level52);
+ const std::vector<Codec> sendrecv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
codec_lookup_helper_offerer_.CodecVendor("")->set_video_codecs(send_codecs,
recv_codecs);
@@ -5200,11 +5169,9 @@
// Offer: level 6.0, SendOnly
// Answer: level 6.0, RecvOnly
TEST_F(VideoCodecsOfferH265LevelIdTest, TestSendOnlySymmetrical) {
- const std::vector<cricket::Codec> send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> sendrecv_codecs =
+ const std::vector<Codec> send_codecs = MAKE_VECTOR(kVideoCodecsH265Level6);
+ const std::vector<Codec> recv_codecs = MAKE_VECTOR(kVideoCodecsH265Level6);
+ const std::vector<Codec> sendrecv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
codec_lookup_helper_offerer_.CodecVendor("")->set_video_codecs(send_codecs,
recv_codecs);
@@ -5251,11 +5218,9 @@
// Offer: level 5.2, RecvOnly
// Answer: level 5.2, SendOnly
TEST_F(VideoCodecsOfferH265LevelIdTest, TestRecvOnlySymmetrical) {
- const std::vector<cricket::Codec> send_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> recv_codecs =
- MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> sendrecv_codecs =
+ const std::vector<Codec> send_codecs = MAKE_VECTOR(kVideoCodecsH265Level52);
+ const std::vector<Codec> recv_codecs = MAKE_VECTOR(kVideoCodecsH265Level52);
+ const std::vector<Codec> sendrecv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
codec_lookup_helper_offerer_.CodecVendor("")->set_video_codecs(send_codecs,
recv_codecs);
@@ -5301,15 +5266,15 @@
// Answer: level 5.2, SendRecv
TEST_F(VideoCodecsOfferH265LevelIdTest,
SendRecvOffererEncode52Decode60AnswererEncode60Decode52) {
- const std::vector<cricket::Codec> offerer_send_codecs =
+ const std::vector<Codec> offerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> offerer_recv_codecs =
+ const std::vector<Codec> offerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> offerer_sendrecv_codecs =
+ const std::vector<Codec> offerer_sendrecv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> answerer_send_codecs =
+ const std::vector<Codec> answerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> answerer_recv_codecs =
+ const std::vector<Codec> answerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
codec_lookup_helper_offerer_.CodecVendor("")->set_video_codecs(
offerer_send_codecs, offerer_recv_codecs);
@@ -5363,15 +5328,15 @@
// Answer: level 5.2, SendRecv
TEST_F(VideoCodecsOfferH265LevelIdTest,
SendRecvOffererEncode60Decode52AnswererEncode52Decode60) {
- const std::vector<cricket::Codec> offerer_send_codecs =
+ const std::vector<Codec> offerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> offerer_recv_codecs =
+ const std::vector<Codec> offerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> offerer_sendrecv_codecs =
+ const std::vector<Codec> offerer_sendrecv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> answerer_send_codecs =
+ const std::vector<Codec> answerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> answerer_recv_codecs =
+ const std::vector<Codec> answerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
codec_lookup_helper_offerer_.CodecVendor("")->set_video_codecs(
offerer_send_codecs, offerer_recv_codecs);
@@ -5425,15 +5390,15 @@
// Answer: level 3.1, SendRecv
TEST_F(VideoCodecsOfferH265LevelIdTest,
SendRecvOffererEncode60Decode52AnswererEncode31Decode50) {
- const std::vector<cricket::Codec> offerer_send_codecs =
+ const std::vector<Codec> offerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> offerer_recv_codecs =
+ const std::vector<Codec> offerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> offerer_sendrecv_codecs =
+ const std::vector<Codec> offerer_sendrecv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> answerer_send_codecs =
+ const std::vector<Codec> answerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level31);
- const std::vector<cricket::Codec> answerer_recv_codecs =
+ const std::vector<Codec> answerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level5);
codec_lookup_helper_offerer_.CodecVendor("")->set_video_codecs(
offerer_send_codecs, offerer_recv_codecs);
@@ -5497,15 +5462,15 @@
// Answer: level 4, SendRecv
TEST_F(VideoCodecsOfferH265LevelIdTest,
SendRecvOffererEncode60Decode52AnswererEncode40Decode60) {
- const std::vector<cricket::Codec> offerer_send_codecs =
+ const std::vector<Codec> offerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> offerer_recv_codecs =
+ const std::vector<Codec> offerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> offerer_sendrecv_codecs =
+ const std::vector<Codec> offerer_sendrecv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> answerer_send_codecs =
+ const std::vector<Codec> answerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level4);
- const std::vector<cricket::Codec> answerer_recv_codecs =
+ const std::vector<Codec> answerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
codec_lookup_helper_offerer_.CodecVendor("")->set_video_codecs(
offerer_send_codecs, offerer_recv_codecs);
@@ -5559,15 +5524,15 @@
// Answer: level 4, SendRecv
TEST_F(VideoCodecsOfferH265LevelIdTest,
SendRecvOffererEncode40Decode60AnswererEncode60Decode52) {
- const std::vector<cricket::Codec> offerer_send_codecs =
+ const std::vector<Codec> offerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level4);
- const std::vector<cricket::Codec> offerer_recv_codecs =
+ const std::vector<Codec> offerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> offerer_sendrecv_codecs =
+ const std::vector<Codec> offerer_sendrecv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level4);
- const std::vector<cricket::Codec> answerer_send_codecs =
+ const std::vector<Codec> answerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> answerer_recv_codecs =
+ const std::vector<Codec> answerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
codec_lookup_helper_offerer_.CodecVendor("")->set_video_codecs(
offerer_send_codecs, offerer_recv_codecs);
@@ -5621,15 +5586,15 @@
// Answer: level 6, SendOnly
TEST_F(VideoCodecsOfferH265LevelIdTest,
RecvOnlyOffererEncode52Decode60AnswererEncode60Decode52) {
- const std::vector<cricket::Codec> offerer_send_codecs =
+ const std::vector<Codec> offerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> offerer_recv_codecs =
+ const std::vector<Codec> offerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> offerer_sendrecv_codecs =
+ const std::vector<Codec> offerer_sendrecv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> answerer_send_codecs =
+ const std::vector<Codec> answerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> answerer_recv_codecs =
+ const std::vector<Codec> answerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
codec_lookup_helper_offerer_.CodecVendor("")->set_video_codecs(
offerer_send_codecs, offerer_recv_codecs);
@@ -5679,15 +5644,15 @@
// Answer: level 5.2, SendOnly
TEST_F(VideoCodecsOfferH265LevelIdTest,
RecvOnlyOffererEncode60Decode52AnswererEncode52Decode60) {
- const std::vector<cricket::Codec> offerer_send_codecs =
+ const std::vector<Codec> offerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> offerer_recv_codecs =
+ const std::vector<Codec> offerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> offerer_sendrecv_codecs =
+ const std::vector<Codec> offerer_sendrecv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> answerer_send_codecs =
+ const std::vector<Codec> answerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> answerer_recv_codecs =
+ const std::vector<Codec> answerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
codec_lookup_helper_offerer_.CodecVendor("")->set_video_codecs(
offerer_send_codecs, offerer_recv_codecs);
@@ -5737,15 +5702,15 @@
// Answer: level 3.1, SendOnly
TEST_F(VideoCodecsOfferH265LevelIdTest,
RecvOnlyOffererEncode60Decode52AnswererEncode31Decode50) {
- const std::vector<cricket::Codec> offerer_send_codecs =
+ const std::vector<Codec> offerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> offerer_recv_codecs =
+ const std::vector<Codec> offerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> offerer_sendrecv_codecs =
+ const std::vector<Codec> offerer_sendrecv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> answerer_send_codecs =
+ const std::vector<Codec> answerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level31);
- const std::vector<cricket::Codec> answerer_recv_codecs =
+ const std::vector<Codec> answerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level5);
codec_lookup_helper_offerer_.CodecVendor("")->set_video_codecs(
offerer_send_codecs, offerer_recv_codecs);
@@ -5795,15 +5760,15 @@
// Answer: level 4, SendOnly
TEST_F(VideoCodecsOfferH265LevelIdTest,
RecvOnlyOffererEncode60Decode52AnswererEncode40Decode60) {
- const std::vector<cricket::Codec> offerer_send_codecs =
+ const std::vector<Codec> offerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> offerer_recv_codecs =
+ const std::vector<Codec> offerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> offerer_sendrecv_codecs =
+ const std::vector<Codec> offerer_sendrecv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> answerer_send_codecs =
+ const std::vector<Codec> answerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level4);
- const std::vector<cricket::Codec> answerer_recv_codecs =
+ const std::vector<Codec> answerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
codec_lookup_helper_offerer_.CodecVendor("")->set_video_codecs(
offerer_send_codecs, offerer_recv_codecs);
@@ -5853,15 +5818,15 @@
// Answer: level 6, SendOnly
TEST_F(VideoCodecsOfferH265LevelIdTest,
RecvOnlyOffererEncode40Decode60AnswererEncode60Decode52) {
- const std::vector<cricket::Codec> offerer_send_codecs =
+ const std::vector<Codec> offerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level4);
- const std::vector<cricket::Codec> offerer_recv_codecs =
+ const std::vector<Codec> offerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> offerer_sendrecv_codecs =
+ const std::vector<Codec> offerer_sendrecv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level4);
- const std::vector<cricket::Codec> answerer_send_codecs =
+ const std::vector<Codec> answerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> answerer_recv_codecs =
+ const std::vector<Codec> answerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
codec_lookup_helper_offerer_.CodecVendor("")->set_video_codecs(
offerer_send_codecs, offerer_recv_codecs);
@@ -5911,15 +5876,15 @@
// Answer: level 5.2, RecvOnly
TEST_F(VideoCodecsOfferH265LevelIdTest,
SendOnlyOffererEncode52Decode60AnswererEncode60Decode52) {
- const std::vector<cricket::Codec> offerer_send_codecs =
+ const std::vector<Codec> offerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> offerer_recv_codecs =
+ const std::vector<Codec> offerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> offerer_sendrecv_codecs =
+ const std::vector<Codec> offerer_sendrecv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> answerer_send_codecs =
+ const std::vector<Codec> answerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> answerer_recv_codecs =
+ const std::vector<Codec> answerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
codec_lookup_helper_offerer_.CodecVendor("")->set_video_codecs(
offerer_send_codecs, offerer_recv_codecs);
@@ -5970,15 +5935,15 @@
// Answer: level 6, RecvOnly
TEST_F(VideoCodecsOfferH265LevelIdTest,
SendOnlyOffererEncode60Decode52AnswererEncode52Decode60) {
- const std::vector<cricket::Codec> offerer_send_codecs =
+ const std::vector<Codec> offerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> offerer_recv_codecs =
+ const std::vector<Codec> offerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> offerer_sendrecv_codecs =
+ const std::vector<Codec> offerer_sendrecv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> answerer_send_codecs =
+ const std::vector<Codec> answerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> answerer_recv_codecs =
+ const std::vector<Codec> answerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
codec_lookup_helper_offerer_.CodecVendor("")->set_video_codecs(
offerer_send_codecs, offerer_recv_codecs);
@@ -6029,15 +5994,15 @@
// Answer: level 5, RecvOnly
TEST_F(VideoCodecsOfferH265LevelIdTest,
SendOnlyOffererEncode60Decode52AnswererEncode31Decode50) {
- const std::vector<cricket::Codec> offerer_send_codecs =
+ const std::vector<Codec> offerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> offerer_recv_codecs =
+ const std::vector<Codec> offerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> offerer_sendrecv_codecs =
+ const std::vector<Codec> offerer_sendrecv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> answerer_send_codecs =
+ const std::vector<Codec> answerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level31);
- const std::vector<cricket::Codec> answerer_recv_codecs =
+ const std::vector<Codec> answerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level5);
codec_lookup_helper_offerer_.CodecVendor("")->set_video_codecs(
offerer_send_codecs, offerer_recv_codecs);
@@ -6088,15 +6053,15 @@
// Answer: level 6, RecvOnly
TEST_F(VideoCodecsOfferH265LevelIdTest,
SendOnlyOffererEncode60Decode52AnswererEncode40Decode60) {
- const std::vector<cricket::Codec> offerer_send_codecs =
+ const std::vector<Codec> offerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> offerer_recv_codecs =
+ const std::vector<Codec> offerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> offerer_sendrecv_codecs =
+ const std::vector<Codec> offerer_sendrecv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
- const std::vector<cricket::Codec> answerer_send_codecs =
+ const std::vector<Codec> answerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level4);
- const std::vector<cricket::Codec> answerer_recv_codecs =
+ const std::vector<Codec> answerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
codec_lookup_helper_offerer_.CodecVendor("")->set_video_codecs(
offerer_send_codecs, offerer_recv_codecs);
@@ -6147,15 +6112,15 @@
// Answer: level 4, RecvOnly
TEST_F(VideoCodecsOfferH265LevelIdTest,
SendOnlyOffererEncode40Decode60AnswererEncode60Decode52) {
- const std::vector<cricket::Codec> offerer_send_codecs =
+ const std::vector<Codec> offerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level4);
- const std::vector<cricket::Codec> offerer_recv_codecs =
+ const std::vector<Codec> offerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> offerer_sendrecv_codecs =
+ const std::vector<Codec> offerer_sendrecv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level4);
- const std::vector<cricket::Codec> answerer_send_codecs =
+ const std::vector<Codec> answerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> answerer_recv_codecs =
+ const std::vector<Codec> answerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
codec_lookup_helper_offerer_.CodecVendor("")->set_video_codecs(
offerer_send_codecs, offerer_recv_codecs);
@@ -6202,15 +6167,15 @@
TEST_F(VideoCodecsOfferH265LevelIdTest,
SendOnlyOffererEncode40Decode60AnswererEncode60Decode52WithPreference) {
- const std::vector<cricket::Codec> offerer_send_codecs =
+ const std::vector<Codec> offerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level4);
- const std::vector<cricket::Codec> offerer_recv_codecs =
+ const std::vector<Codec> offerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> offerer_sendrecv_codecs =
+ const std::vector<Codec> offerer_sendrecv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level4);
- const std::vector<cricket::Codec> answerer_send_codecs =
+ const std::vector<Codec> answerer_send_codecs =
MAKE_VECTOR(kVideoCodecsH265Level6);
- const std::vector<cricket::Codec> answerer_recv_codecs =
+ const std::vector<Codec> answerer_recv_codecs =
MAKE_VECTOR(kVideoCodecsH265Level52);
codec_lookup_helper_offerer_.CodecVendor("")->set_video_codecs(
offerer_send_codecs, offerer_recv_codecs);
diff --git a/pc/peer_connection.cc b/pc/peer_connection.cc
index 9eb1627..468cabf 100644
--- a/pc/peer_connection.cc
+++ b/pc/peer_connection.cc
@@ -1106,7 +1106,7 @@
"Attempted to set an unimplemented parameter of RtpParameters.");
}
- std::vector<cricket::Codec> codecs;
+ std::vector<Codec> codecs;
// Gather the current codec capabilities to allow checking scalabilityMode and
// codec selection against supported values.
CodecVendor codec_vendor(context_->media_engine(), false,
diff --git a/pc/peer_connection_encodings_integrationtest.cc b/pc/peer_connection_encodings_integrationtest.cc
index 62d306f..213a426 100644
--- a/pc/peer_connection_encodings_integrationtest.cc
+++ b/pc/peer_connection_encodings_integrationtest.cc
@@ -1860,10 +1860,10 @@
// Munge a new parameter for VP8 in the offer.
auto* mcd = offer->description()->contents()[0].media_description();
ASSERT_THAT(mcd, NotNull());
- std::vector<cricket::Codec> codecs = mcd->codecs();
- ASSERT_THAT(codecs, Contains(Field(&cricket::Codec::name, "VP8")));
+ std::vector<Codec> codecs = mcd->codecs();
+ ASSERT_THAT(codecs, Contains(Field(&Codec::name, "VP8")));
auto vp8_codec = absl::c_find_if(
- codecs, [](const cricket::Codec& codec) { return codec.name == "VP8"; });
+ codecs, [](const Codec& codec) { return codec.name == "VP8"; });
vp8_codec->params.emplace("non-standard-param", "true");
mcd->set_codecs(codecs);
@@ -1879,9 +1879,9 @@
mcd = answer->description()->contents()[0].media_description();
ASSERT_THAT(mcd, NotNull());
codecs = mcd->codecs();
- ASSERT_THAT(codecs, Contains(Field(&cricket::Codec::name, "VP8")));
+ ASSERT_THAT(codecs, Contains(Field(&Codec::name, "VP8")));
vp8_codec = absl::c_find_if(
- codecs, [](const cricket::Codec& codec) { return codec.name == "VP8"; });
+ codecs, [](const Codec& codec) { return codec.name == "VP8"; });
vp8_codec->params.emplace("non-standard-param", "true");
mcd->set_codecs(codecs);
p1 = SetLocalDescription(remote_pc_wrapper, answer.get());
diff --git a/pc/peer_connection_factory.cc b/pc/peer_connection_factory.cc
index 80b3fe7..7951462 100644
--- a/pc/peer_connection_factory.cc
+++ b/pc/peer_connection_factory.cc
@@ -153,14 +153,14 @@
RTC_DCHECK_RUN_ON(signaling_thread());
switch (kind) {
case webrtc::MediaType::AUDIO: {
- cricket::Codecs cricket_codecs;
+ Codecs cricket_codecs;
cricket_codecs = codec_vendor_.audio_send_codecs().codecs();
auto extensions =
GetDefaultEnabledRtpHeaderExtensions(media_engine()->voice());
return ToRtpCapabilities(cricket_codecs, extensions);
}
case webrtc::MediaType::VIDEO: {
- cricket::Codecs cricket_codecs;
+ Codecs cricket_codecs;
cricket_codecs = codec_vendor_.video_send_codecs().codecs();
auto extensions =
GetDefaultEnabledRtpHeaderExtensions(media_engine()->video());
@@ -178,15 +178,14 @@
RTC_DCHECK_RUN_ON(signaling_thread());
switch (kind) {
case webrtc::MediaType::AUDIO: {
- cricket::Codecs cricket_codecs;
+ Codecs cricket_codecs;
cricket_codecs = codec_vendor_.audio_recv_codecs().codecs();
auto extensions =
GetDefaultEnabledRtpHeaderExtensions(media_engine()->voice());
return ToRtpCapabilities(cricket_codecs, extensions);
}
case webrtc::MediaType::VIDEO: {
- cricket::Codecs cricket_codecs =
- codec_vendor_.video_recv_codecs().codecs();
+ Codecs cricket_codecs = codec_vendor_.video_recv_codecs().codecs();
auto extensions =
GetDefaultEnabledRtpHeaderExtensions(media_engine()->video());
return ToRtpCapabilities(cricket_codecs, extensions);
diff --git a/pc/peer_connection_integrationtest.cc b/pc/peer_connection_integrationtest.cc
index ecc918c..5cd69c9 100644
--- a/pc/peer_connection_integrationtest.cc
+++ b/pc/peer_connection_integrationtest.cc
@@ -1227,7 +1227,7 @@
}),
extensions.end());
media->set_rtp_header_extensions(extensions);
- media->set_codecs({cricket::CreateVideoCodec(pt++, "VP8")});
+ media->set_codecs({CreateVideoCodec(pt++, "VP8")});
}
}
@@ -2875,10 +2875,9 @@
ASSERT_NE(nullptr, audio);
auto audio_codecs = audio->codecs();
audio_codecs.erase(
- std::remove_if(audio_codecs.begin(), audio_codecs.end(),
- [](const cricket::Codec& codec) {
- return codec.name != "opus";
- }),
+ std::remove_if(
+ audio_codecs.begin(), audio_codecs.end(),
+ [](const Codec& codec) { return codec.name != "opus"; }),
audio_codecs.end());
ASSERT_EQ(1u, audio_codecs.size());
audio_codecs[0].name = "OpUs";
@@ -2889,10 +2888,9 @@
ASSERT_NE(nullptr, video);
auto video_codecs = video->codecs();
video_codecs.erase(
- std::remove_if(video_codecs.begin(), video_codecs.end(),
- [](const cricket::Codec& codec) {
- return codec.name != "VP8";
- }),
+ std::remove_if(
+ video_codecs.begin(), video_codecs.end(),
+ [](const Codec& codec) { return codec.name != "VP8"; }),
video_codecs.end());
ASSERT_EQ(1u, video_codecs.size());
video_codecs[0].name = "vP8";
@@ -4276,14 +4274,14 @@
[](std::unique_ptr<SessionDescriptionInterface>& sdp) {
for (ContentInfo& content : sdp->description()->contents()) {
MediaContentDescription* media = content.media_description();
- std::vector<cricket::Codec> codecs = media->codecs();
- std::vector<cricket::Codec> codecs_out;
- for (cricket::Codec codec : codecs) {
+ std::vector<Codec> codecs = media->codecs();
+ std::vector<Codec> codecs_out;
+ for (Codec codec : codecs) {
if (codec.name == "opus") {
- codec.AddFeedbackParam(cricket::FeedbackParam(
- cricket::kRtcpFbParamNack, cricket::kParamValueEmpty));
- codec.AddFeedbackParam(cricket::FeedbackParam(
- cricket::kRtcpFbParamRrtr, cricket::kParamValueEmpty));
+ codec.AddFeedbackParam(FeedbackParam(cricket::kRtcpFbParamNack,
+ cricket::kParamValueEmpty));
+ codec.AddFeedbackParam(FeedbackParam(cricket::kRtcpFbParamRrtr,
+ cricket::kParamValueEmpty));
codecs_out.push_back(codec);
}
}
@@ -4331,11 +4329,11 @@
[](std::unique_ptr<SessionDescriptionInterface>& sdp) {
for (ContentInfo& content : sdp->description()->contents()) {
MediaContentDescription* media = content.media_description();
- std::vector<cricket::Codec> codecs = media->codecs();
- std::vector<cricket::Codec> codecs_out;
- for (const cricket::Codec& codec : codecs) {
+ std::vector<Codec> codecs = media->codecs();
+ std::vector<Codec> codecs_out;
+ for (const Codec& codec : codecs) {
if (codec.name == "VP8") {
- ASSERT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
+ ASSERT_TRUE(codec.HasFeedbackParam(FeedbackParam(
cricket::kRtcpFbParamNack, cricket::kParamValueEmpty)));
codecs_out.push_back(codec);
}
@@ -4433,7 +4431,7 @@
if (!content.media_description()) {
continue;
}
- std::vector<cricket::Codec> codecs = content.media_description()->codecs();
+ std::vector<Codec> codecs = content.media_description()->codecs();
int left = 0;
int right = codecs.size() - 1;
while (left < right) {
@@ -4776,7 +4774,7 @@
auto munger = [](std::unique_ptr<SessionDescriptionInterface>& sdp) {
auto video = GetFirstVideoContentDescription(sdp->description());
auto codecs = video->codecs();
- std::optional<cricket::Codec> replacement_codec;
+ std::optional<Codec> replacement_codec;
for (auto&& codec : codecs) {
if (codec.name == "AV1") {
replacement_codec = codec;
@@ -4860,8 +4858,8 @@
auto codecs =
answer->description()->contents()[0].media_description()->codecs();
std::vector<int> apt_values;
- for (const cricket::Codec& codec : codecs) {
- if (codec.GetResiliencyType() == cricket::Codec::ResiliencyType::kRtx) {
+ for (const Codec& codec : codecs) {
+ if (codec.GetResiliencyType() == Codec::ResiliencyType::kRtx) {
const auto apt_it =
codec.params.find(cricket::kCodecParamAssociatedPayloadType);
int apt_value;
@@ -4870,7 +4868,7 @@
}
}
for (int apt : apt_values) {
- EXPECT_THAT(codecs, Contains(Field("id", &cricket::Codec::id, apt)));
+ EXPECT_THAT(codecs, Contains(Field("id", &Codec::id, apt)));
}
}
diff --git a/pc/peer_connection_interface_unittest.cc b/pc/peer_connection_interface_unittest.cc
index 252c32d..b70d6aa 100644
--- a/pc/peer_connection_interface_unittest.cc
+++ b/pc/peer_connection_interface_unittest.cc
@@ -1227,7 +1227,7 @@
bool HasCNCodecs(const ContentInfo* content) {
RTC_DCHECK(content);
RTC_DCHECK(content->media_description());
- for (const cricket::Codec& codec : content->media_description()->codecs()) {
+ for (const Codec& codec : content->media_description()->codecs()) {
if (codec.name == "CN") {
return true;
}
diff --git a/pc/peer_connection_media_unittest.cc b/pc/peer_connection_media_unittest.cc
index b4416ea..5819b08 100644
--- a/pc/peer_connection_media_unittest.cc
+++ b/pc/peer_connection_media_unittest.cc
@@ -568,13 +568,12 @@
// Test that raw packetization is not set in the offer by default.
TEST_P(PeerConnectionMediaTest, RawPacketizationNotSetInOffer) {
- std::vector<cricket::Codec> fake_codecs;
- fake_codecs.push_back(cricket::CreateVideoCodec(111, cricket::kVp8CodecName));
- fake_codecs.push_back(cricket::CreateVideoRtxCodec(112, 111));
- fake_codecs.push_back(cricket::CreateVideoCodec(113, cricket::kVp9CodecName));
- fake_codecs.push_back(
- cricket::CreateVideoCodec(114, cricket::kH264CodecName));
- fake_codecs.push_back(cricket::CreateVideoCodec(115, "HEVC"));
+ std::vector<Codec> fake_codecs;
+ fake_codecs.push_back(CreateVideoCodec(111, cricket::kVp8CodecName));
+ fake_codecs.push_back(CreateVideoRtxCodec(112, 111));
+ fake_codecs.push_back(CreateVideoCodec(113, cricket::kVp9CodecName));
+ fake_codecs.push_back(CreateVideoCodec(114, cricket::kH264CodecName));
+ fake_codecs.push_back(CreateVideoCodec(115, "HEVC"));
auto caller_fake_engine = std::make_unique<FakeMediaEngine>();
caller_fake_engine->SetVideoCodecs(fake_codecs);
@@ -590,13 +589,12 @@
// Test that raw packetization is set in the offer and answer for all
// video payload when raw_packetization_for_video is true.
TEST_P(PeerConnectionMediaTest, RawPacketizationSetInOfferAndAnswer) {
- std::vector<cricket::Codec> fake_codecs;
- fake_codecs.push_back(cricket::CreateVideoCodec(111, cricket::kVp8CodecName));
- fake_codecs.push_back(cricket::CreateVideoRtxCodec(112, 111));
- fake_codecs.push_back(cricket::CreateVideoCodec(113, cricket::kVp9CodecName));
- fake_codecs.push_back(
- cricket::CreateVideoCodec(114, cricket::kH264CodecName));
- fake_codecs.push_back(cricket::CreateVideoCodec(115, "HEVC"));
+ std::vector<Codec> fake_codecs;
+ fake_codecs.push_back(CreateVideoCodec(111, cricket::kVp8CodecName));
+ fake_codecs.push_back(CreateVideoRtxCodec(112, 111));
+ fake_codecs.push_back(CreateVideoCodec(113, cricket::kVp9CodecName));
+ fake_codecs.push_back(CreateVideoCodec(114, cricket::kH264CodecName));
+ fake_codecs.push_back(CreateVideoCodec(115, "HEVC"));
auto caller_fake_engine = std::make_unique<FakeMediaEngine>();
caller_fake_engine->SetVideoCodecs(fake_codecs);
auto callee_fake_engine = std::make_unique<FakeMediaEngine>();
@@ -633,13 +631,12 @@
// raw_packetization_for_video is true if it was not set in the offer.
TEST_P(PeerConnectionMediaTest,
RawPacketizationNotSetInAnswerWhenNotSetInOffer) {
- std::vector<cricket::Codec> fake_codecs;
- fake_codecs.push_back(cricket::CreateVideoCodec(111, cricket::kVp8CodecName));
- fake_codecs.push_back(cricket::CreateVideoRtxCodec(112, 111));
- fake_codecs.push_back(cricket::CreateVideoCodec(113, cricket::kVp9CodecName));
- fake_codecs.push_back(
- cricket::CreateVideoCodec(114, cricket::kH264CodecName));
- fake_codecs.push_back(cricket::CreateVideoCodec(115, "HEVC"));
+ std::vector<Codec> fake_codecs;
+ fake_codecs.push_back(CreateVideoCodec(111, cricket::kVp8CodecName));
+ fake_codecs.push_back(CreateVideoRtxCodec(112, 111));
+ fake_codecs.push_back(CreateVideoCodec(113, cricket::kVp9CodecName));
+ fake_codecs.push_back(CreateVideoCodec(114, cricket::kH264CodecName));
+ fake_codecs.push_back(CreateVideoCodec(115, "HEVC"));
auto caller_fake_engine = std::make_unique<FakeMediaEngine>();
caller_fake_engine->SetVideoCodecs(fake_codecs);
auto callee_fake_engine = std::make_unique<FakeMediaEngine>();
@@ -875,10 +872,10 @@
}
void AddComfortNoiseCodecsToSend(cricket::FakeMediaEngine* media_engine) {
- const cricket::Codec kComfortNoiseCodec8k =
- cricket::CreateAudioCodec(102, cricket::kCnCodecName, 8000, 1);
- const cricket::Codec kComfortNoiseCodec16k =
- cricket::CreateAudioCodec(103, cricket::kCnCodecName, 16000, 1);
+ const Codec kComfortNoiseCodec8k =
+ CreateAudioCodec(102, cricket::kCnCodecName, 8000, 1);
+ const Codec kComfortNoiseCodec16k =
+ CreateAudioCodec(103, cricket::kCnCodecName, 16000, 1);
auto codecs = media_engine->voice().LegacySendCodecs();
codecs.push_back(kComfortNoiseCodec8k);
@@ -1211,16 +1208,16 @@
// endpoint selected a different payload type or there was a conflict), the RED
// fmtp line is modified to refer to the correct payload type.
TEST_P(PeerConnectionMediaTest, RedFmtpPayloadTypeReassigned) {
- std::vector<cricket::Codec> caller_fake_codecs;
- caller_fake_codecs.push_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
+ std::vector<Codec> caller_fake_codecs;
+ caller_fake_codecs.push_back(CreateAudioCodec(100, "foo", 0, 1));
auto caller_fake_engine = std::make_unique<FakeMediaEngine>();
caller_fake_engine->SetAudioCodecs(caller_fake_codecs);
auto caller = CreatePeerConnectionWithAudio(std::move(caller_fake_engine));
- std::vector<cricket::Codec> callee_fake_codecs;
- callee_fake_codecs.push_back(cricket::CreateAudioCodec(120, "foo", 0, 1));
+ std::vector<Codec> callee_fake_codecs;
+ callee_fake_codecs.push_back(CreateAudioCodec(120, "foo", 0, 1));
callee_fake_codecs.push_back(
- cricket::CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
+ CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
callee_fake_codecs.back().SetParam(cricket::kCodecParamNotInNameValueFormat,
"120/120");
auto callee_fake_engine = std::make_unique<FakeMediaEngine>();
@@ -1254,18 +1251,18 @@
// Test that RED without fmtp does match RED without fmtp.
TEST_P(PeerConnectionMediaTest, RedFmtpPayloadTypeNoFmtpMatchNoFmtp) {
- std::vector<cricket::Codec> caller_fake_codecs;
- caller_fake_codecs.push_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
+ std::vector<Codec> caller_fake_codecs;
+ caller_fake_codecs.push_back(CreateAudioCodec(100, "foo", 0, 1));
caller_fake_codecs.push_back(
- cricket::CreateAudioCodec(101, cricket::kRedCodecName, 0, 1));
+ CreateAudioCodec(101, cricket::kRedCodecName, 0, 1));
auto caller_fake_engine = std::make_unique<FakeMediaEngine>();
caller_fake_engine->SetAudioCodecs(caller_fake_codecs);
auto caller = CreatePeerConnectionWithAudio(std::move(caller_fake_engine));
- std::vector<cricket::Codec> callee_fake_codecs;
- callee_fake_codecs.push_back(cricket::CreateAudioCodec(120, "foo", 0, 1));
+ std::vector<Codec> callee_fake_codecs;
+ callee_fake_codecs.push_back(CreateAudioCodec(120, "foo", 0, 1));
callee_fake_codecs.push_back(
- cricket::CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
+ CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
auto callee_fake_engine = std::make_unique<FakeMediaEngine>();
callee_fake_engine->SetAudioCodecs(callee_fake_codecs);
auto callee = CreatePeerConnectionWithAudio(std::move(callee_fake_engine));
@@ -1296,18 +1293,18 @@
// Test that RED without fmtp does not match RED with fmtp.
TEST_P(PeerConnectionMediaTest, RedFmtpPayloadTypeNoFmtpNoMatchFmtp) {
- std::vector<cricket::Codec> caller_fake_codecs;
- caller_fake_codecs.push_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
+ std::vector<Codec> caller_fake_codecs;
+ caller_fake_codecs.push_back(CreateAudioCodec(100, "foo", 0, 1));
caller_fake_codecs.push_back(
- cricket::CreateAudioCodec(101, cricket::kRedCodecName, 0, 1));
+ CreateAudioCodec(101, cricket::kRedCodecName, 0, 1));
auto caller_fake_engine = std::make_unique<FakeMediaEngine>();
caller_fake_engine->SetAudioCodecs(caller_fake_codecs);
auto caller = CreatePeerConnectionWithAudio(std::move(caller_fake_engine));
- std::vector<cricket::Codec> callee_fake_codecs;
- callee_fake_codecs.push_back(cricket::CreateAudioCodec(120, "foo", 0, 1));
+ std::vector<Codec> callee_fake_codecs;
+ callee_fake_codecs.push_back(CreateAudioCodec(120, "foo", 0, 1));
callee_fake_codecs.push_back(
- cricket::CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
+ CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
callee_fake_codecs.back().SetParam(cricket::kCodecParamNotInNameValueFormat,
"120/120");
auto callee_fake_engine = std::make_unique<FakeMediaEngine>();
@@ -1343,21 +1340,21 @@
// Test that RED with fmtp must match base codecs.
TEST_P(PeerConnectionMediaTest, RedFmtpPayloadTypeMustMatchBaseCodecs) {
- std::vector<cricket::Codec> caller_fake_codecs;
- caller_fake_codecs.push_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
+ std::vector<Codec> caller_fake_codecs;
+ caller_fake_codecs.push_back(CreateAudioCodec(100, "foo", 0, 1));
caller_fake_codecs.push_back(
- cricket::CreateAudioCodec(101, cricket::kRedCodecName, 0, 1));
+ CreateAudioCodec(101, cricket::kRedCodecName, 0, 1));
caller_fake_codecs.back().SetParam(cricket::kCodecParamNotInNameValueFormat,
"100/100");
auto caller_fake_engine = std::make_unique<FakeMediaEngine>();
caller_fake_engine->SetAudioCodecs(caller_fake_codecs);
auto caller = CreatePeerConnectionWithAudio(std::move(caller_fake_engine));
- std::vector<cricket::Codec> callee_fake_codecs;
- callee_fake_codecs.push_back(cricket::CreateAudioCodec(120, "foo", 0, 1));
+ std::vector<Codec> callee_fake_codecs;
+ callee_fake_codecs.push_back(CreateAudioCodec(120, "foo", 0, 1));
callee_fake_codecs.push_back(
- cricket::CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
- callee_fake_codecs.push_back(cricket::CreateAudioCodec(122, "bar", 0, 1));
+ CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
+ callee_fake_codecs.push_back(CreateAudioCodec(122, "bar", 0, 1));
callee_fake_codecs.back().SetParam(cricket::kCodecParamNotInNameValueFormat,
"122/122");
auto callee_fake_engine = std::make_unique<FakeMediaEngine>();
@@ -1377,21 +1374,21 @@
// Test behaviour when the RED fmtp attempts to specify different codecs
// which is not supported.
TEST_P(PeerConnectionMediaTest, RedFmtpPayloadMixed) {
- std::vector<cricket::Codec> caller_fake_codecs;
- caller_fake_codecs.push_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
- caller_fake_codecs.push_back(cricket::CreateAudioCodec(102, "bar", 0, 1));
+ std::vector<Codec> caller_fake_codecs;
+ caller_fake_codecs.push_back(CreateAudioCodec(100, "foo", 0, 1));
+ caller_fake_codecs.push_back(CreateAudioCodec(102, "bar", 0, 1));
caller_fake_codecs.push_back(
- cricket::CreateAudioCodec(101, cricket::kRedCodecName, 0, 1));
+ CreateAudioCodec(101, cricket::kRedCodecName, 0, 1));
caller_fake_codecs.back().SetParam(cricket::kCodecParamNotInNameValueFormat,
"100/102");
auto caller_fake_engine = std::make_unique<FakeMediaEngine>();
caller_fake_engine->SetAudioCodecs(caller_fake_codecs);
auto caller = CreatePeerConnectionWithAudio(std::move(caller_fake_engine));
- std::vector<cricket::Codec> callee_fake_codecs;
- callee_fake_codecs.push_back(cricket::CreateAudioCodec(120, "foo", 0, 1));
+ std::vector<Codec> callee_fake_codecs;
+ callee_fake_codecs.push_back(CreateAudioCodec(120, "foo", 0, 1));
callee_fake_codecs.push_back(
- cricket::CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
+ CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
callee_fake_codecs.back().SetParam(cricket::kCodecParamNotInNameValueFormat,
"120/120");
auto callee_fake_engine = std::make_unique<FakeMediaEngine>();
@@ -1411,20 +1408,20 @@
// Test behaviour when the RED fmtp attempts to negotiate different levels of
// redundancy.
TEST_P(PeerConnectionMediaTest, RedFmtpPayloadDifferentRedundancy) {
- std::vector<cricket::Codec> caller_fake_codecs;
- caller_fake_codecs.push_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
+ std::vector<Codec> caller_fake_codecs;
+ caller_fake_codecs.push_back(CreateAudioCodec(100, "foo", 0, 1));
caller_fake_codecs.push_back(
- cricket::CreateAudioCodec(101, cricket::kRedCodecName, 0, 1));
+ CreateAudioCodec(101, cricket::kRedCodecName, 0, 1));
caller_fake_codecs.back().SetParam(cricket::kCodecParamNotInNameValueFormat,
"100/100");
auto caller_fake_engine = std::make_unique<FakeMediaEngine>();
caller_fake_engine->SetAudioCodecs(caller_fake_codecs);
auto caller = CreatePeerConnectionWithAudio(std::move(caller_fake_engine));
- std::vector<cricket::Codec> callee_fake_codecs;
- callee_fake_codecs.push_back(cricket::CreateAudioCodec(120, "foo", 0, 1));
+ std::vector<Codec> callee_fake_codecs;
+ callee_fake_codecs.push_back(CreateAudioCodec(120, "foo", 0, 1));
callee_fake_codecs.push_back(
- cricket::CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
+ CreateAudioCodec(121, cricket::kRedCodecName, 0, 1));
callee_fake_codecs.back().SetParam(cricket::kCodecParamNotInNameValueFormat,
"120/120/120");
auto callee_fake_engine = std::make_unique<FakeMediaEngine>();
@@ -1492,8 +1489,8 @@
SetCodecPreferencesAudioMissingRecvCodec) {
auto fake_engine = std::make_unique<FakeMediaEngine>();
auto send_codecs = fake_engine->voice().LegacySendCodecs();
- send_codecs.push_back(cricket::CreateAudioCodec(send_codecs.back().id + 1,
- "send_only_codec", 0, 1));
+ send_codecs.push_back(
+ CreateAudioCodec(send_codecs.back().id + 1, "send_only_codec", 0, 1));
fake_engine->SetAudioSendCodecs(send_codecs);
auto caller = CreatePeerConnectionWithAudio(std::move(fake_engine));
@@ -1533,12 +1530,12 @@
SetCodecPreferencesAudioRejectsOnlyRtxRedFec) {
auto fake_engine = std::make_unique<FakeMediaEngine>();
auto audio_codecs = fake_engine->voice().LegacySendCodecs();
- audio_codecs.push_back(cricket::CreateAudioRtxCodec(
- audio_codecs.back().id + 1, audio_codecs.back().id));
- audio_codecs.push_back(cricket::CreateAudioCodec(
- audio_codecs.back().id + 1, cricket::kRedCodecName, 0, 1));
- audio_codecs.push_back(cricket::CreateAudioCodec(
- audio_codecs.back().id + 1, cricket::kUlpfecCodecName, 0, 1));
+ audio_codecs.push_back(
+ CreateAudioRtxCodec(audio_codecs.back().id + 1, audio_codecs.back().id));
+ audio_codecs.push_back(CreateAudioCodec(audio_codecs.back().id + 1,
+ cricket::kRedCodecName, 0, 1));
+ audio_codecs.push_back(CreateAudioCodec(audio_codecs.back().id + 1,
+ cricket::kUlpfecCodecName, 0, 1));
fake_engine->SetAudioCodecs(audio_codecs);
auto caller = CreatePeerConnectionWithAudio(std::move(fake_engine));
@@ -1620,12 +1617,12 @@
SetCodecPreferencesVideoRejectsOnlyRtxRedFec) {
auto fake_engine = std::make_unique<FakeMediaEngine>();
auto video_codecs = fake_engine->video().LegacySendCodecs();
- video_codecs.push_back(cricket::CreateVideoRtxCodec(
- video_codecs.back().id + 1, video_codecs.back().id));
- video_codecs.push_back(cricket::CreateVideoCodec(video_codecs.back().id + 1,
- cricket::kRedCodecName));
- video_codecs.push_back(cricket::CreateVideoCodec(video_codecs.back().id + 1,
- cricket::kUlpfecCodecName));
+ video_codecs.push_back(
+ CreateVideoRtxCodec(video_codecs.back().id + 1, video_codecs.back().id));
+ video_codecs.push_back(
+ CreateVideoCodec(video_codecs.back().id + 1, cricket::kRedCodecName));
+ video_codecs.push_back(
+ CreateVideoCodec(video_codecs.back().id + 1, cricket::kUlpfecCodecName));
fake_engine->SetVideoCodecs(video_codecs);
auto caller = CreatePeerConnectionWithVideo(std::move(fake_engine));
@@ -1716,13 +1713,13 @@
TEST_F(PeerConnectionMediaTestUnifiedPlan, SetCodecPreferencesVideoWithRtx) {
auto caller_fake_engine = std::make_unique<FakeMediaEngine>();
auto caller_video_codecs = caller_fake_engine->video().LegacySendCodecs();
- caller_video_codecs.push_back(cricket::CreateVideoCodec(
+ caller_video_codecs.push_back(CreateVideoCodec(
caller_video_codecs.back().id + 1, cricket::kVp8CodecName));
- caller_video_codecs.push_back(cricket::CreateVideoRtxCodec(
+ caller_video_codecs.push_back(CreateVideoRtxCodec(
caller_video_codecs.back().id + 1, caller_video_codecs.back().id));
- caller_video_codecs.push_back(cricket::CreateVideoCodec(
+ caller_video_codecs.push_back(CreateVideoCodec(
caller_video_codecs.back().id + 1, cricket::kVp9CodecName));
- caller_video_codecs.push_back(cricket::CreateVideoRtxCodec(
+ caller_video_codecs.push_back(CreateVideoRtxCodec(
caller_video_codecs.back().id + 1, caller_video_codecs.back().id));
caller_fake_engine->SetVideoCodecs(caller_video_codecs);
@@ -1761,13 +1758,13 @@
SetCodecPreferencesVideoCodecsNegotiation) {
auto caller_fake_engine = std::make_unique<FakeMediaEngine>();
auto caller_video_codecs = caller_fake_engine->video().LegacySendCodecs();
- caller_video_codecs.push_back(cricket::CreateVideoCodec(
+ caller_video_codecs.push_back(CreateVideoCodec(
caller_video_codecs.back().id + 1, cricket::kVp8CodecName));
- caller_video_codecs.push_back(cricket::CreateVideoRtxCodec(
+ caller_video_codecs.push_back(CreateVideoRtxCodec(
caller_video_codecs.back().id + 1, caller_video_codecs.back().id));
- caller_video_codecs.push_back(cricket::CreateVideoCodec(
+ caller_video_codecs.push_back(CreateVideoCodec(
caller_video_codecs.back().id + 1, cricket::kVp9CodecName));
- caller_video_codecs.push_back(cricket::CreateVideoRtxCodec(
+ caller_video_codecs.push_back(CreateVideoRtxCodec(
caller_video_codecs.back().id + 1, caller_video_codecs.back().id));
caller_fake_engine->SetVideoCodecs(caller_video_codecs);
@@ -1825,13 +1822,13 @@
SetCodecPreferencesVideoCodecsNegotiationReverseOrder) {
auto caller_fake_engine = std::make_unique<FakeMediaEngine>();
auto caller_video_codecs = caller_fake_engine->video().LegacySendCodecs();
- caller_video_codecs.push_back(cricket::CreateVideoCodec(
+ caller_video_codecs.push_back(CreateVideoCodec(
caller_video_codecs.back().id + 1, cricket::kVp8CodecName));
- caller_video_codecs.push_back(cricket::CreateVideoRtxCodec(
+ caller_video_codecs.push_back(CreateVideoRtxCodec(
caller_video_codecs.back().id + 1, caller_video_codecs.back().id));
- caller_video_codecs.push_back(cricket::CreateVideoCodec(
+ caller_video_codecs.push_back(CreateVideoCodec(
caller_video_codecs.back().id + 1, cricket::kVp9CodecName));
- caller_video_codecs.push_back(cricket::CreateVideoRtxCodec(
+ caller_video_codecs.push_back(CreateVideoRtxCodec(
caller_video_codecs.back().id + 1, caller_video_codecs.back().id));
caller_fake_engine->SetVideoCodecs(caller_video_codecs);
@@ -1907,14 +1904,14 @@
SetCodecPreferencesAvoidsPayloadTypeConflictInOffer) {
auto fake_engine = std::make_unique<cricket::FakeMediaEngine>();
- std::vector<cricket::Codec> audio_codecs;
- audio_codecs.emplace_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
- audio_codecs.emplace_back(cricket::CreateAudioRtxCodec(101, 100));
+ std::vector<Codec> audio_codecs;
+ audio_codecs.emplace_back(CreateAudioCodec(100, "foo", 0, 1));
+ audio_codecs.emplace_back(CreateAudioRtxCodec(101, 100));
fake_engine->SetAudioCodecs(audio_codecs);
- std::vector<cricket::Codec> video_codecs;
- video_codecs.emplace_back(cricket::CreateVideoCodec(100, "bar"));
- video_codecs.emplace_back(cricket::CreateVideoRtxCodec(101, 100));
+ std::vector<Codec> video_codecs;
+ video_codecs.emplace_back(CreateVideoCodec(100, "bar"));
+ video_codecs.emplace_back(CreateVideoRtxCodec(101, 100));
fake_engine->SetVideoCodecs(video_codecs);
auto caller = CreatePeerConnectionWithAudioVideo(std::move(fake_engine));
@@ -1948,14 +1945,14 @@
SetCodecPreferencesAvoidsPayloadTypeConflictInAnswer) {
auto fake_engine = std::make_unique<cricket::FakeMediaEngine>();
- std::vector<cricket::Codec> audio_codecs;
- audio_codecs.emplace_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
- audio_codecs.emplace_back(cricket::CreateAudioRtxCodec(101, 100));
+ std::vector<Codec> audio_codecs;
+ audio_codecs.emplace_back(CreateAudioCodec(100, "foo", 0, 1));
+ audio_codecs.emplace_back(CreateAudioRtxCodec(101, 100));
fake_engine->SetAudioCodecs(audio_codecs);
- std::vector<cricket::Codec> video_codecs;
- video_codecs.emplace_back(cricket::CreateVideoCodec(100, "bar"));
- video_codecs.emplace_back(cricket::CreateVideoRtxCodec(101, 100));
+ std::vector<Codec> video_codecs;
+ video_codecs.emplace_back(CreateVideoCodec(100, "bar"));
+ video_codecs.emplace_back(CreateVideoRtxCodec(101, 100));
fake_engine->SetVideoCodecs(video_codecs);
auto caller = CreatePeerConnectionWithAudioVideo(std::move(fake_engine));
@@ -1993,14 +1990,14 @@
SetCodecPreferencesAvoidsPayloadTypeConflictInSubsequentOffer) {
auto fake_engine = std::make_unique<cricket::FakeMediaEngine>();
- std::vector<cricket::Codec> audio_codecs;
- audio_codecs.emplace_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
- audio_codecs.emplace_back(cricket::CreateAudioRtxCodec(101, 100));
+ std::vector<Codec> audio_codecs;
+ audio_codecs.emplace_back(CreateAudioCodec(100, "foo", 0, 1));
+ audio_codecs.emplace_back(CreateAudioRtxCodec(101, 100));
fake_engine->SetAudioCodecs(audio_codecs);
- std::vector<cricket::Codec> video_codecs;
- video_codecs.emplace_back(cricket::CreateVideoCodec(100, "bar"));
- video_codecs.emplace_back(cricket::CreateVideoRtxCodec(101, 100));
+ std::vector<Codec> video_codecs;
+ video_codecs.emplace_back(CreateVideoCodec(100, "bar"));
+ video_codecs.emplace_back(CreateVideoRtxCodec(101, 100));
fake_engine->SetVideoCodecs(video_codecs);
auto caller = CreatePeerConnectionWithAudioVideo(std::move(fake_engine));
@@ -2039,8 +2036,8 @@
SetCodecPreferencesRecvOnlyCodecOnSendOnlyTransceiver) {
auto fake_engine = std::make_unique<cricket::FakeMediaEngine>();
- std::vector<cricket::Codec> audio_codecs;
- audio_codecs.emplace_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
+ std::vector<Codec> audio_codecs;
+ audio_codecs.emplace_back(CreateAudioCodec(100, "foo", 0, 1));
fake_engine->SetAudioRecvCodecs(audio_codecs);
auto caller = CreatePeerConnectionWithAudio(std::move(fake_engine));
@@ -2066,11 +2063,10 @@
TEST_F(PeerConnectionMediaTestUnifiedPlan, SetCodecPreferencesVideoNoRtx) {
auto fake_engine = std::make_unique<cricket::FakeMediaEngine>();
- std::vector<cricket::Codec> video_codecs;
- video_codecs.emplace_back(cricket::CreateVideoCodec(100, "bar"));
- video_codecs.emplace_back(cricket::CreateVideoRtxCodec(101, 100));
- video_codecs.emplace_back(
- cricket::CreateVideoCodec(102, cricket::kRedCodecName));
+ std::vector<Codec> video_codecs;
+ video_codecs.emplace_back(CreateVideoCodec(100, "bar"));
+ video_codecs.emplace_back(CreateVideoRtxCodec(101, 100));
+ video_codecs.emplace_back(CreateVideoCodec(102, cricket::kRedCodecName));
fake_engine->SetVideoCodecs(video_codecs);
auto caller = CreatePeerConnectionWithVideo(std::move(fake_engine));
diff --git a/pc/peer_connection_rtp_unittest.cc b/pc/peer_connection_rtp_unittest.cc
index dbf4ac6..f341d39 100644
--- a/pc/peer_connection_rtp_unittest.cc
+++ b/pc/peer_connection_rtp_unittest.cc
@@ -1788,7 +1788,7 @@
init.send_encodings[0].scalability_mode = std::nullopt;
init.send_encodings[0].codec =
- cricket::CreateVideoCodec(SdpVideoFormat("VP8", {})).ToCodecParameters();
+ CreateVideoCodec(SdpVideoFormat("VP8", {})).ToCodecParameters();
EXPECT_EQ(RTCErrorType::NONE,
caller->pc()
->AddTransceiver(webrtc::MediaType::VIDEO, init)
@@ -1798,7 +1798,7 @@
init.send_encodings[0].scalability_mode = "L1T2";
init.send_encodings[0].codec =
- cricket::CreateVideoCodec(SdpVideoFormat("VP8", {})).ToCodecParameters();
+ CreateVideoCodec(SdpVideoFormat("VP8", {})).ToCodecParameters();
EXPECT_EQ(RTCErrorType::NONE,
caller->pc()
->AddTransceiver(webrtc::MediaType::VIDEO, init)
@@ -1808,7 +1808,7 @@
init.send_encodings[0].scalability_mode = "L2T2";
init.send_encodings[0].codec =
- cricket::CreateVideoCodec(SdpVideoFormat("VP8", {})).ToCodecParameters();
+ CreateVideoCodec(SdpVideoFormat("VP8", {})).ToCodecParameters();
EXPECT_EQ(RTCErrorType::UNSUPPORTED_OPERATION,
caller->pc()
->AddTransceiver(webrtc::MediaType::VIDEO, init)
diff --git a/pc/peer_connection_signaling_unittest.cc b/pc/peer_connection_signaling_unittest.cc
index a406df1..904d2fd 100644
--- a/pc/peer_connection_signaling_unittest.cc
+++ b/pc/peer_connection_signaling_unittest.cc
@@ -1070,11 +1070,11 @@
offer->description()->contents()[0].media_description()->codecs();
auto flexfec_it = std::find_if(
offer_codecs.begin(), offer_codecs.end(),
- [](const cricket::Codec& codec) { return codec.name == "flexfec-03"; });
+ [](const Codec& codec) { return codec.name == "flexfec-03"; });
ASSERT_EQ(flexfec_it->id, 35);
- auto av1_it = std::find_if(
- offer_codecs.begin(), offer_codecs.end(),
- [](const cricket::Codec& codec) { return codec.name == "AV1"; });
+ auto av1_it =
+ std::find_if(offer_codecs.begin(), offer_codecs.end(),
+ [](const Codec& codec) { return codec.name == "AV1"; });
if (av1_it != offer_codecs.end()) {
ASSERT_NE(av1_it->id, 35);
}
diff --git a/pc/rtp_parameters_conversion.cc b/pc/rtp_parameters_conversion.cc
index a2ba2ef..b8a6340 100644
--- a/pc/rtp_parameters_conversion.cc
+++ b/pc/rtp_parameters_conversion.cc
@@ -24,7 +24,7 @@
namespace webrtc {
std::optional<RtcpFeedback> ToRtcpFeedback(
- const cricket::FeedbackParam& cricket_feedback) {
+ const FeedbackParam& cricket_feedback) {
if (cricket_feedback.id() == cricket::kRtcpFbParamCcm) {
if (cricket_feedback.param() == cricket::kRtcpFbCcmParamFir) {
return RtcpFeedback(RtcpFeedbackType::CCM, RtcpFeedbackMessageType::FIR);
@@ -75,15 +75,15 @@
return std::nullopt;
}
-RtpCodecCapability ToRtpCodecCapability(const cricket::Codec& cricket_codec) {
+RtpCodecCapability ToRtpCodecCapability(const Codec& cricket_codec) {
RtpCodecCapability codec;
codec.name = cricket_codec.name;
- codec.kind = cricket_codec.type == cricket::Codec::Type::kAudio
+ codec.kind = cricket_codec.type == Codec::Type::kAudio
? webrtc::MediaType::AUDIO
: webrtc::MediaType::VIDEO;
codec.clock_rate.emplace(cricket_codec.clockrate);
codec.preferred_payload_type.emplace(cricket_codec.id);
- for (const cricket::FeedbackParam& cricket_feedback :
+ for (const FeedbackParam& cricket_feedback :
cricket_codec.feedback_params.params()) {
std::optional<RtcpFeedback> feedback = ToRtcpFeedback(cricket_feedback);
if (feedback) {
@@ -91,10 +91,10 @@
}
}
switch (cricket_codec.type) {
- case cricket::Codec::Type::kAudio:
+ case Codec::Type::kAudio:
codec.num_channels = static_cast<int>(cricket_codec.channels);
break;
- case cricket::Codec::Type::kVideo:
+ case Codec::Type::kVideo:
codec.scalability_modes = cricket_codec.scalability_modes;
break;
}
@@ -104,14 +104,14 @@
}
RtpCapabilities ToRtpCapabilities(
- const std::vector<cricket::Codec>& cricket_codecs,
+ const std::vector<Codec>& cricket_codecs,
const cricket::RtpHeaderExtensions& cricket_extensions) {
RtpCapabilities capabilities;
bool have_red = false;
bool have_ulpfec = false;
bool have_flexfec = false;
bool have_rtx = false;
- for (const cricket::Codec& cricket_codec : cricket_codecs) {
+ for (const Codec& cricket_codec : cricket_codecs) {
if (cricket_codec.name == cricket::kRedCodecName) {
if (have_red) {
// There should only be one RED codec entry in caps.
diff --git a/pc/rtp_parameters_conversion.h b/pc/rtp_parameters_conversion.h
index b188b36..1247b01 100644
--- a/pc/rtp_parameters_conversion.h
+++ b/pc/rtp_parameters_conversion.h
@@ -35,12 +35,12 @@
// Returns empty value if `cricket_feedback` is a feedback type not
// supported/recognized.
std::optional<RtcpFeedback> ToRtcpFeedback(
- const cricket::FeedbackParam& cricket_feedback);
+ const FeedbackParam& cricket_feedback);
-RtpCodecCapability ToRtpCodecCapability(const cricket::Codec& cricket_codec);
+RtpCodecCapability ToRtpCodecCapability(const Codec& cricket_codec);
RtpCapabilities ToRtpCapabilities(
- const std::vector<cricket::Codec>& cricket_codecs,
+ const std::vector<Codec>& cricket_codecs,
const cricket::RtpHeaderExtensions& cricket_extensions);
} // namespace webrtc
diff --git a/pc/rtp_parameters_conversion_unittest.cc b/pc/rtp_parameters_conversion_unittest.cc
index 7c87f41..e87cb7d 100644
--- a/pc/rtp_parameters_conversion_unittest.cc
+++ b/pc/rtp_parameters_conversion_unittest.cc
@@ -31,10 +31,10 @@
EXPECT_EQ(RtcpFeedback(RtcpFeedbackType::CCM, RtcpFeedbackMessageType::FIR),
*result);
- result = ToRtcpFeedback(cricket::FeedbackParam("goog-lntf"));
+ result = ToRtcpFeedback(FeedbackParam("goog-lntf"));
EXPECT_EQ(RtcpFeedback(RtcpFeedbackType::LNTF), *result);
- result = ToRtcpFeedback(cricket::FeedbackParam("nack"));
+ result = ToRtcpFeedback(FeedbackParam("nack"));
EXPECT_EQ(RtcpFeedback(RtcpFeedbackType::NACK,
RtcpFeedbackMessageType::GENERIC_NACK),
*result);
@@ -43,10 +43,10 @@
EXPECT_EQ(RtcpFeedback(RtcpFeedbackType::NACK, RtcpFeedbackMessageType::PLI),
*result);
- result = ToRtcpFeedback(cricket::FeedbackParam("goog-remb"));
+ result = ToRtcpFeedback(FeedbackParam("goog-remb"));
EXPECT_EQ(RtcpFeedback(RtcpFeedbackType::REMB), *result);
- result = ToRtcpFeedback(cricket::FeedbackParam("transport-cc"));
+ result = ToRtcpFeedback(FeedbackParam("transport-cc"));
EXPECT_EQ(RtcpFeedback(RtcpFeedbackType::TRANSPORT_CC), *result);
}
@@ -55,7 +55,7 @@
std::optional<RtcpFeedback> result = ToRtcpFeedback({"ccm", "pli"});
EXPECT_FALSE(result);
- result = ToRtcpFeedback(cricket::FeedbackParam("ccm"));
+ result = ToRtcpFeedback(FeedbackParam("ccm"));
EXPECT_FALSE(result);
// LNTF with message type (should be left empty).
@@ -75,14 +75,14 @@
EXPECT_FALSE(result);
// Unknown message type.
- result = ToRtcpFeedback(cricket::FeedbackParam("foo"));
+ result = ToRtcpFeedback(FeedbackParam("foo"));
EXPECT_FALSE(result);
}
TEST(RtpParametersConversionTest, ToAudioRtpCodecCapability) {
- cricket::Codec cricket_codec = cricket::CreateAudioCodec(50, "foo", 22222, 4);
+ Codec cricket_codec = CreateAudioCodec(50, "foo", 22222, 4);
cricket_codec.params["foo"] = "bar";
- cricket_codec.feedback_params.Add(cricket::FeedbackParam("transport-cc"));
+ cricket_codec.feedback_params.Add(FeedbackParam("transport-cc"));
RtpCodecCapability codec = ToRtpCodecCapability(cricket_codec);
EXPECT_EQ("foo", codec.name);
@@ -98,12 +98,12 @@
}
TEST(RtpParametersConversionTest, ToVideoRtpCodecCapability) {
- cricket::Codec cricket_codec = cricket::CreateVideoCodec(101, "VID");
+ Codec cricket_codec = CreateVideoCodec(101, "VID");
cricket_codec.clockrate = 80000;
cricket_codec.params["foo"] = "bar";
cricket_codec.params["ANOTHER"] = "param";
- cricket_codec.feedback_params.Add(cricket::FeedbackParam("transport-cc"));
- cricket_codec.feedback_params.Add(cricket::FeedbackParam("goog-lntf"));
+ cricket_codec.feedback_params.Add(FeedbackParam("transport-cc"));
+ cricket_codec.feedback_params.Add(FeedbackParam("goog-lntf"));
cricket_codec.feedback_params.Add({"nack", "pli"});
RtpCodecCapability codec = ToRtpCodecCapability(cricket_codec);
@@ -124,10 +124,10 @@
// An unknown feedback param should just be ignored.
TEST(RtpParametersConversionTest, ToRtpCodecCapabilityUnknownFeedbackParam) {
- cricket::Codec cricket_codec = cricket::CreateAudioCodec(50, "foo", 22222, 4);
+ Codec cricket_codec = CreateAudioCodec(50, "foo", 22222, 4);
cricket_codec.params["foo"] = "bar";
cricket_codec.feedback_params.Add({"unknown", "param"});
- cricket_codec.feedback_params.Add(cricket::FeedbackParam("transport-cc"));
+ cricket_codec.feedback_params.Add(FeedbackParam("transport-cc"));
RtpCodecCapability codec = ToRtpCodecCapability(cricket_codec);
ASSERT_EQ(1u, codec.rtcp_feedback.size());
@@ -139,17 +139,17 @@
// test that the result of ToRtpCodecCapability ends up in the result, and that
// the "fec" list is assembled correctly.
TEST(RtpParametersConversionTest, ToRtpCapabilities) {
- cricket::Codec vp8 = cricket::CreateVideoCodec(101, "VP8");
+ Codec vp8 = CreateVideoCodec(101, "VP8");
- cricket::Codec red = cricket::CreateVideoCodec(102, "red");
+ Codec red = CreateVideoCodec(102, "red");
// Note: fmtp not usually done for video-red but we want it filtered.
red.SetParam(cricket::kCodecParamNotInNameValueFormat, "101/101");
- cricket::Codec red2 = cricket::CreateVideoCodec(127, "red");
- cricket::Codec ulpfec = cricket::CreateVideoCodec(103, "ulpfec");
- cricket::Codec flexfec = cricket::CreateVideoCodec(102, "flexfec-03");
- cricket::Codec rtx = cricket::CreateVideoRtxCodec(014, 101);
- cricket::Codec rtx2 = cricket::CreateVideoRtxCodec(105, 109);
+ Codec red2 = CreateVideoCodec(127, "red");
+ Codec ulpfec = CreateVideoCodec(103, "ulpfec");
+ Codec flexfec = CreateVideoCodec(102, "flexfec-03");
+ Codec rtx = CreateVideoRtxCodec(014, 101);
+ Codec rtx2 = CreateVideoRtxCodec(105, 109);
RtpCapabilities capabilities =
ToRtpCapabilities({vp8, ulpfec, rtx, rtx2}, {{"uri", 1}, {"uri2", 3}});
diff --git a/pc/rtp_sender.cc b/pc/rtp_sender.cc
index df3316e..d004157 100644
--- a/pc/rtp_sender.cc
+++ b/pc/rtp_sender.cc
@@ -365,12 +365,12 @@
}
RTCError RtpSenderBase::CheckCodecParameters(const RtpParameters& parameters) {
- std::optional<cricket::Codec> send_codec = media_channel_->GetSendCodec();
+ std::optional<Codec> send_codec = media_channel_->GetSendCodec();
// Match the currently used codec against the codec preferences to gather
// the SVC capabilities.
- std::optional<cricket::Codec> send_codec_with_svc_info;
- if (send_codec && send_codec->type == cricket::Codec::Type::kVideo) {
+ std::optional<Codec> send_codec_with_svc_info;
+ if (send_codec && send_codec->type == Codec::Type::kVideo) {
auto codec_match = absl::c_find_if(
send_codecs_, [&](auto& codec) { return send_codec->Matches(codec); });
if (codec_match != send_codecs_.end()) {
diff --git a/pc/rtp_sender.h b/pc/rtp_sender.h
index 5a1cb7f..08cd6b0 100644
--- a/pc/rtp_sender.h
+++ b/pc/rtp_sender.h
@@ -104,8 +104,8 @@
// Used by the owning transceiver to inform the sender on the currently
// selected codecs.
- virtual void SetSendCodecs(std::vector<cricket::Codec> send_codecs) = 0;
- virtual std::vector<cricket::Codec> GetSendCodecs() const = 0;
+ virtual void SetSendCodecs(std::vector<Codec> send_codecs) = 0;
+ virtual std::vector<Codec> GetSendCodecs() const = 0;
virtual void NotifyFirstPacketSent() = 0;
};
@@ -225,12 +225,10 @@
is_transceiver_stopped_ = true;
}
- void SetSendCodecs(std::vector<cricket::Codec> send_codecs) override {
+ void SetSendCodecs(std::vector<Codec> send_codecs) override {
send_codecs_ = send_codecs;
}
- std::vector<cricket::Codec> GetSendCodecs() const override {
- return send_codecs_;
- }
+ std::vector<Codec> GetSendCodecs() const override { return send_codecs_; }
void NotifyFirstPacketSent() override;
void SetObserver(RtpSenderObserverInterface* observer) override;
@@ -272,7 +270,7 @@
std::vector<std::string> stream_ids_;
RtpParameters init_parameters_;
- std::vector<cricket::Codec> send_codecs_;
+ std::vector<Codec> send_codecs_;
// TODO(tommi): `media_channel_` and several other member variables in this
// class (ssrc_, stopped_, etc) are accessed from more than one thread without
diff --git a/pc/rtp_sender_receiver_unittest.cc b/pc/rtp_sender_receiver_unittest.cc
index 0422354..e26e04f 100644
--- a/pc/rtp_sender_receiver_unittest.cc
+++ b/pc/rtp_sender_receiver_unittest.cc
@@ -170,8 +170,8 @@
// Needed to use DTMF sender.
void AddDtmfCodec() {
cricket::AudioSenderParameter params;
- const cricket::Codec kTelephoneEventCodec =
- cricket::CreateAudioCodec(106, "telephone-event", 8000, 1);
+ const Codec kTelephoneEventCodec =
+ CreateAudioCodec(106, "telephone-event", 8000, 1);
params.codecs.push_back(kTelephoneEventCodec);
voice_media_send_channel()->SetSenderParameters(params);
}
diff --git a/pc/rtp_transceiver.cc b/pc/rtp_transceiver.cc
index 36f0cb9..f1a6b4d 100644
--- a/pc/rtp_transceiver.cc
+++ b/pc/rtp_transceiver.cc
@@ -70,12 +70,11 @@
});
}
-RTCError VerifyCodecPreferences(
- const std::vector<RtpCodecCapability>& codecs,
- const std::vector<cricket::Codec>& send_codecs,
- const std::vector<cricket::Codec>& recv_codecs) {
+RTCError VerifyCodecPreferences(const std::vector<RtpCodecCapability>& codecs,
+ const std::vector<Codec>& send_codecs,
+ const std::vector<Codec>& recv_codecs) {
// `codec_capabilities` is the union of `send_codecs` and `recv_codecs`.
- std::vector<cricket::Codec> codec_capabilities;
+ std::vector<Codec> codec_capabilities;
codec_capabilities.reserve(send_codecs.size() + recv_codecs.size());
codec_capabilities.insert(codec_capabilities.end(), send_codecs.begin(),
send_codecs.end());
@@ -87,7 +86,7 @@
const RtpCodecCapability& codec) {
return !codec.IsMediaCodec() ||
absl::c_any_of(codec_capabilities,
- [&codec](const cricket::Codec& codec_capability) {
+ [&codec](const Codec& codec_capability) {
return IsSameRtpCodec(codec_capability, codec);
});
})) {
@@ -404,7 +403,7 @@
RTC_DCHECK_EQ(media_type(), sender->media_type());
RTC_DCHECK(!absl::c_linear_search(senders_, sender));
- std::vector<cricket::Codec> send_codecs =
+ std::vector<Codec> send_codecs =
media_type() == webrtc::MediaType::VIDEO
? codec_vendor().video_send_codecs().codecs()
: codec_vendor().audio_send_codecs().codecs();
@@ -681,7 +680,7 @@
RTCError RtpTransceiver::UpdateCodecPreferencesCaches(
const std::vector<RtpCodecCapability>& codecs) {
// Get codec capabilities from media engine.
- std::vector<cricket::Codec> send_codecs, recv_codecs;
+ std::vector<Codec> send_codecs, recv_codecs;
if (media_type_ == webrtc::MediaType::AUDIO) {
send_codecs = codec_vendor().audio_send_codecs().codecs();
recv_codecs = codec_vendor().audio_recv_codecs().codecs();
@@ -710,11 +709,11 @@
}
// Is this a send codec, receive codec or both?
bool is_send_codec =
- absl::c_any_of(send_codecs, [&codec](const cricket::Codec& send_codec) {
+ absl::c_any_of(send_codecs, [&codec](const Codec& send_codec) {
return IsSameRtpCodecIgnoringLevel(send_codec, codec);
});
bool is_recv_codec =
- absl::c_any_of(recv_codecs, [&codec](const cricket::Codec& recv_codec) {
+ absl::c_any_of(recv_codecs, [&codec](const Codec& recv_codec) {
return IsSameRtpCodecIgnoringLevel(recv_codec, codec);
});
// The codec being neither for sending or receving is not possible because
diff --git a/pc/rtp_transceiver_unittest.cc b/pc/rtp_transceiver_unittest.cc
index 98b955a..fc2a5b4 100644
--- a/pc/rtp_transceiver_unittest.cc
+++ b/pc/rtp_transceiver_unittest.cc
@@ -236,13 +236,13 @@
MockReceiver(webrtc::MediaType::VIDEO))) {}
struct H264CodecCapabilities {
- cricket::Codec cricket_sendrecv_codec;
+ Codec cricket_sendrecv_codec;
RtpCodecCapability sendrecv_codec;
- cricket::Codec cricket_sendonly_codec;
+ Codec cricket_sendonly_codec;
RtpCodecCapability sendonly_codec;
- cricket::Codec cricket_recvonly_codec;
+ Codec cricket_recvonly_codec;
RtpCodecCapability recvonly_codec;
- cricket::Codec cricket_rtx_codec;
+ Codec cricket_rtx_codec;
RtpCodecCapability rtx_codec;
};
@@ -258,26 +258,26 @@
// For H264, the profile and level IDs are entangled. This function uses
// profile-level-id values that are not equal even when levels are ignored.
H264CodecCapabilities ConfigureH264CodecCapabilities() {
- cricket::Codec cricket_sendrecv_codec = cricket::CreateVideoCodec(
- SdpVideoFormat("H264",
- {{"level-asymmetry-allowed", "1"},
- {"packetization-mode", "1"},
- {"profile-level-id", "42f00b"}},
- {ScalabilityMode::kL1T1}));
- cricket::Codec cricket_sendonly_codec = cricket::CreateVideoCodec(
- SdpVideoFormat("H264",
- {{"level-asymmetry-allowed", "1"},
- {"packetization-mode", "1"},
- {"profile-level-id", "640034"}},
- {ScalabilityMode::kL1T1}));
- cricket::Codec cricket_recvonly_codec = cricket::CreateVideoCodec(
- SdpVideoFormat("H264",
- {{"level-asymmetry-allowed", "1"},
- {"packetization-mode", "1"},
- {"profile-level-id", "f4001f"}},
- {ScalabilityMode::kL1T1}));
- cricket::Codec cricket_rtx_codec = cricket::CreateVideoRtxCodec(
- cricket::Codec::kIdNotSet, cricket::Codec::kIdNotSet);
+ Codec cricket_sendrecv_codec =
+ CreateVideoCodec(SdpVideoFormat("H264",
+ {{"level-asymmetry-allowed", "1"},
+ {"packetization-mode", "1"},
+ {"profile-level-id", "42f00b"}},
+ {ScalabilityMode::kL1T1}));
+ Codec cricket_sendonly_codec =
+ CreateVideoCodec(SdpVideoFormat("H264",
+ {{"level-asymmetry-allowed", "1"},
+ {"packetization-mode", "1"},
+ {"profile-level-id", "640034"}},
+ {ScalabilityMode::kL1T1}));
+ Codec cricket_recvonly_codec =
+ CreateVideoCodec(SdpVideoFormat("H264",
+ {{"level-asymmetry-allowed", "1"},
+ {"packetization-mode", "1"},
+ {"profile-level-id", "f4001f"}},
+ {ScalabilityMode::kL1T1}));
+ Codec cricket_rtx_codec =
+ CreateVideoRtxCodec(Codec::kIdNotSet, Codec::kIdNotSet);
media_engine()->SetVideoSendCodecs(
{cricket_sendrecv_codec, cricket_sendonly_codec, cricket_rtx_codec});
media_engine()->SetVideoRecvCodecs(
@@ -312,23 +312,23 @@
// A valid H265 level-id, but one not present in either getCapabilities().
static constexpr const char* kLevelNotInCapabilities = "135";
- cricket::Codec cricket_sendonly_codec;
+ Codec cricket_sendonly_codec;
RtpCodecCapability sendonly_codec;
- cricket::Codec cricket_recvonly_codec;
+ Codec cricket_recvonly_codec;
RtpCodecCapability recvonly_codec;
};
// For H265, the profile and level IDs are separate and are ignored by
// IsSameRtpCodecIgnoringLevel().
H265CodecCapabilities ConfigureH265CodecCapabilities() {
- cricket::Codec cricket_sendonly_codec = cricket::CreateVideoCodec(
+ Codec cricket_sendonly_codec = CreateVideoCodec(
SdpVideoFormat("H265",
{{"profile-id", "1"},
{"tier-flag", "0"},
{"level-id", H265CodecCapabilities::kSendOnlyLevel},
{"tx-mode", "SRST"}},
{ScalabilityMode::kL1T1}));
- cricket::Codec cricket_recvonly_codec = cricket::CreateVideoCodec(
+ Codec cricket_recvonly_codec = CreateVideoCodec(
SdpVideoFormat("H265",
{{"profile-id", "1"},
{"tier-flag", "0"},
@@ -463,25 +463,25 @@
TEST_F(RtpTransceiverFilteredCodecPreferencesTest,
H264LevelIdsIgnoredByFilter) {
// Baseline 3.1 and 5.2 are compatible when ignoring level IDs.
- cricket::Codec baseline_3_1 = cricket::CreateVideoCodec(
- SdpVideoFormat("H264",
- {{"level-asymmetry-allowed", "1"},
- {"packetization-mode", "1"},
- {"profile-level-id", "42001f"}},
- {ScalabilityMode::kL1T1}));
- cricket::Codec baseline_5_2 = cricket::CreateVideoCodec(
- SdpVideoFormat("H264",
- {{"level-asymmetry-allowed", "1"},
- {"packetization-mode", "1"},
- {"profile-level-id", "420034"}},
- {ScalabilityMode::kL1T1}));
+ Codec baseline_3_1 =
+ CreateVideoCodec(SdpVideoFormat("H264",
+ {{"level-asymmetry-allowed", "1"},
+ {"packetization-mode", "1"},
+ {"profile-level-id", "42001f"}},
+ {ScalabilityMode::kL1T1}));
+ Codec baseline_5_2 =
+ CreateVideoCodec(SdpVideoFormat("H264",
+ {{"level-asymmetry-allowed", "1"},
+ {"packetization-mode", "1"},
+ {"profile-level-id", "420034"}},
+ {ScalabilityMode::kL1T1}));
// High is NOT compatible with baseline.
- cricket::Codec high_3_1 = cricket::CreateVideoCodec(
- SdpVideoFormat("H264",
- {{"level-asymmetry-allowed", "1"},
- {"packetization-mode", "1"},
- {"profile-level-id", "64001f"}},
- {ScalabilityMode::kL1T1}));
+ Codec high_3_1 =
+ CreateVideoCodec(SdpVideoFormat("H264",
+ {{"level-asymmetry-allowed", "1"},
+ {"packetization-mode", "1"},
+ {"profile-level-id", "64001f"}},
+ {ScalabilityMode::kL1T1}));
// Configure being able to both send and receive Baseline but using different
// level IDs in either direction, while the High profile is "truly" recvonly.
media_engine()->SetVideoSendCodecs({baseline_3_1});
@@ -542,7 +542,7 @@
TEST_F(RtpTransceiverFilteredCodecPreferencesTest,
H265LevelIdHasToBeFromSenderOrReceiverCapabilities) {
ConfigureH265CodecCapabilities();
- cricket::Codec cricket_codec = cricket::CreateVideoCodec(SdpVideoFormat(
+ Codec cricket_codec = CreateVideoCodec(SdpVideoFormat(
"H265",
{{"profile-id", "1"},
{"tier-flag", "0"},
diff --git a/pc/sdp_munging_detector.cc b/pc/sdp_munging_detector.cc
index ef841b1..590749b 100644
--- a/pc/sdp_munging_detector.cc
+++ b/pc/sdp_munging_detector.cc
@@ -105,7 +105,7 @@
// Opus stereo modification required to enabled stereo playout for opus.
bool created_opus_stereo =
absl::c_find_if(last_created_media_description->codecs(),
- [](const cricket::Codec codec) {
+ [](const Codec codec) {
std::string value;
return codec.name == cricket::kOpusCodecName &&
codec.GetParam(cricket::kCodecParamStereo,
@@ -114,7 +114,7 @@
}) != last_created_media_description->codecs().end();
bool set_opus_stereo =
absl::c_find_if(
- media_description_to_set->codecs(), [](const cricket::Codec codec) {
+ media_description_to_set->codecs(), [](const Codec codec) {
std::string value;
return codec.name == cricket::kOpusCodecName &&
codec.GetParam(cricket::kCodecParamStereo, &value) &&
@@ -128,12 +128,12 @@
// Nonstandard 5.1/7.1 opus variant.
bool created_multiopus =
absl::c_find_if(last_created_media_description->codecs(),
- [](const cricket::Codec codec) {
+ [](const Codec codec) {
return codec.name == "multiopus";
}) != last_created_media_description->codecs().end();
bool set_multiopus =
absl::c_find_if(media_description_to_set->codecs(),
- [](const cricket::Codec codec) {
+ [](const Codec codec) {
return codec.name == "multiopus";
}) != media_description_to_set->codecs().end();
if (!created_multiopus && set_multiopus) {
@@ -144,11 +144,11 @@
// L16.
bool created_l16 =
absl::c_find_if(last_created_media_description->codecs(),
- [](const cricket::Codec codec) {
+ [](const Codec codec) {
return codec.name == cricket::kL16CodecName;
}) != last_created_media_description->codecs().end();
bool set_l16 = absl::c_find_if(media_description_to_set->codecs(),
- [](const cricket::Codec codec) {
+ [](const Codec codec) {
return codec.name == cricket::kL16CodecName;
}) != media_description_to_set->codecs().end();
if (!created_l16 && set_l16) {
@@ -165,15 +165,15 @@
// Audio NACK is not offered by default.
bool created_nack =
absl::c_find_if(last_created_media_description->codecs(),
- [](const cricket::Codec codec) {
+ [](const Codec codec) {
return codec.HasFeedbackParam(
- cricket::FeedbackParam(cricket::kRtcpFbParamNack));
+ FeedbackParam(cricket::kRtcpFbParamNack));
}) != last_created_media_description->codecs().end();
bool set_nack =
absl::c_find_if(media_description_to_set->codecs(),
- [](const cricket::Codec codec) {
+ [](const Codec codec) {
return codec.HasFeedbackParam(
- cricket::FeedbackParam(cricket::kRtcpFbParamNack));
+ FeedbackParam(cricket::kRtcpFbParamNack));
}) != media_description_to_set->codecs().end();
if (!created_nack && set_nack) {
RTC_LOG(LS_WARNING) << "SDP munging: audio nack enabled.";
@@ -183,15 +183,15 @@
// RRTR is not offered by default.
bool created_rrtr =
absl::c_find_if(last_created_media_description->codecs(),
- [](const cricket::Codec codec) {
+ [](const Codec codec) {
return codec.HasFeedbackParam(
- cricket::FeedbackParam(cricket::kRtcpFbParamRrtr));
+ FeedbackParam(cricket::kRtcpFbParamRrtr));
}) != last_created_media_description->codecs().end();
bool set_rrtr =
absl::c_find_if(media_description_to_set->codecs(),
- [](const cricket::Codec codec) {
+ [](const Codec codec) {
return codec.HasFeedbackParam(
- cricket::FeedbackParam(cricket::kRtcpFbParamRrtr));
+ FeedbackParam(cricket::kRtcpFbParamRrtr));
}) != media_description_to_set->codecs().end();
if (!created_rrtr && set_rrtr) {
RTC_LOG(LS_WARNING) << "SDP munging: audio rrtr enabled.";
@@ -202,7 +202,7 @@
// the other side.
bool created_opus_fec =
absl::c_find_if(last_created_media_description->codecs(),
- [](const cricket::Codec codec) {
+ [](const Codec codec) {
std::string value;
return codec.name == cricket::kOpusCodecName &&
codec.GetParam(cricket::kCodecParamUseInbandFec,
@@ -211,7 +211,7 @@
}) != last_created_media_description->codecs().end();
bool set_opus_fec =
absl::c_find_if(
- media_description_to_set->codecs(), [](const cricket::Codec codec) {
+ media_description_to_set->codecs(), [](const Codec codec) {
std::string value;
return codec.name == cricket::kOpusCodecName &&
codec.GetParam(cricket::kCodecParamUseInbandFec, &value) &&
@@ -225,7 +225,7 @@
// the other side.
bool created_opus_dtx =
absl::c_find_if(last_created_media_description->codecs(),
- [](const cricket::Codec codec) {
+ [](const Codec codec) {
std::string value;
return codec.name == cricket::kOpusCodecName &&
codec.GetParam(cricket::kCodecParamUseDtx,
@@ -234,7 +234,7 @@
}) != last_created_media_description->codecs().end();
bool set_opus_dtx =
absl::c_find_if(
- media_description_to_set->codecs(), [](const cricket::Codec codec) {
+ media_description_to_set->codecs(), [](const Codec codec) {
std::string value;
return codec.name == cricket::kOpusCodecName &&
codec.GetParam(cricket::kCodecParamUseDtx, &value) &&
@@ -249,7 +249,7 @@
// the other side.
bool created_opus_cbr =
absl::c_find_if(last_created_media_description->codecs(),
- [](const cricket::Codec codec) {
+ [](const Codec codec) {
std::string value;
return codec.name == cricket::kOpusCodecName &&
codec.GetParam(cricket::kCodecParamCbr,
@@ -258,7 +258,7 @@
}) != last_created_media_description->codecs().end();
bool set_opus_cbr =
absl::c_find_if(
- media_description_to_set->codecs(), [](const cricket::Codec codec) {
+ media_description_to_set->codecs(), [](const Codec codec) {
std::string value;
return codec.name == cricket::kOpusCodecName &&
codec.GetParam(cricket::kCodecParamCbr, &value) &&
@@ -314,7 +314,7 @@
// sps-pps-idr-in-keyframe.
bool created_sps_pps_idr_in_keyframe =
absl::c_find_if(last_created_media_description->codecs(),
- [](const cricket::Codec codec) {
+ [](const Codec codec) {
std::string value;
return codec.name == cricket::kH264CodecName &&
codec.GetParam(
@@ -324,7 +324,7 @@
}) != last_created_media_description->codecs().end();
bool set_sps_pps_idr_in_keyframe =
absl::c_find_if(
- media_description_to_set->codecs(), [](const cricket::Codec codec) {
+ media_description_to_set->codecs(), [](const Codec codec) {
std::string value;
return codec.name == cricket::kH264CodecName &&
codec.GetParam(cricket::kH264FmtpSpsPpsIdrInKeyframe,
diff --git a/pc/sdp_offer_answer.cc b/pc/sdp_offer_answer.cc
index 37bc76e..106bb4e 100644
--- a/pc/sdp_offer_answer.cc
+++ b/pc/sdp_offer_answer.cc
@@ -808,7 +808,7 @@
auto send_rid = RidDescription(encoding.rid, RidDirection::kSend);
if (encoding.codec) {
auto send_codecs = transceiver->sender_internal()->GetSendCodecs();
- for (const cricket::Codec& codec : send_codecs) {
+ for (const Codec& codec : send_codecs) {
if (IsSameRtpCodecIgnoringLevel(codec, *encoding.codec)) {
send_rid.codecs.push_back(codec);
break;
@@ -5507,7 +5507,7 @@
}
const MediaContentDescription* media_desc =
content_info.media_description();
- for (const cricket::Codec& codec : media_desc->codecs()) {
+ for (const Codec& codec : media_desc->codecs()) {
if (media_type == webrtc::MediaType::AUDIO) {
if (payload_types->audio_payload_types.count(codec.id)) {
// Two m= sections are using the same payload type, thus demuxing
diff --git a/pc/sdp_offer_answer_unittest.cc b/pc/sdp_offer_answer_unittest.cc
index 06f2c6e..4c6b87d 100644
--- a/pc/sdp_offer_answer_unittest.cc
+++ b/pc/sdp_offer_answer_unittest.cc
@@ -684,8 +684,8 @@
// Verify that the serialized SDP includes pt=.
std::string sdp;
offer->ToString(&sdp);
- const cricket::Codec* vp8_send_codec = nullptr;
- const cricket::Codec* vp9_send_codec = nullptr;
+ const Codec* vp8_send_codec = nullptr;
+ const Codec* vp9_send_codec = nullptr;
for (auto& codec : send_codecs) {
if (codec.name == vp8_codec_capability->name && !vp8_send_codec) {
vp8_send_codec = &codec;
@@ -1361,7 +1361,7 @@
// The previously negotiated PT should still map to the same VP9 codec.
auto it = std::find_if(
codecs.begin(), codecs.end(),
- [&](const cricket::Codec& codec) { return codec.id == payload_type; });
+ [&](const Codec& codec) { return codec.id == payload_type; });
ASSERT_TRUE(it != codecs.end());
const auto& vp9_codec = *it;
EXPECT_EQ(vp9_codec.name, "VP9");
@@ -1696,10 +1696,10 @@
ASSERT_EQ(contents.size(), 1u);
auto* media_description = contents[0].media_description();
ASSERT_TRUE(media_description);
- std::vector<cricket::Codec> codecs = media_description->codecs();
+ std::vector<Codec> codecs = media_description->codecs();
ASSERT_EQ(codecs.size(), 1u);
ASSERT_NE(codecs[0].id, 127);
- auto av1 = cricket::CreateVideoCodec(SdpVideoFormat("AV1", {}));
+ auto av1 = CreateVideoCodec(SdpVideoFormat("AV1", {}));
av1.id = 127;
codecs.insert(codecs.begin(), av1);
media_description->set_codecs(codecs);
@@ -2051,7 +2051,7 @@
ASSERT_EQ(contents.size(), 1u);
auto* media_description = contents[0].media_description();
ASSERT_TRUE(media_description);
- std::vector<cricket::Codec> codecs = media_description->codecs();
+ std::vector<Codec> codecs = media_description->codecs();
for (auto& codec : codecs) {
if (codec.name == cricket::kH264CodecName) {
codec.SetParam(cricket::kH264FmtpSpsPpsIdrInKeyframe,
@@ -2077,7 +2077,7 @@
ASSERT_EQ(contents.size(), 1u);
auto* media_description = contents[0].media_description();
ASSERT_TRUE(media_description);
- std::vector<cricket::Codec> codecs = media_description->codecs();
+ std::vector<Codec> codecs = media_description->codecs();
for (auto& codec : codecs) {
if (codec.name == cricket::kOpusCodecName) {
codec.SetParam(cricket::kCodecParamStereo, cricket::kParamValueTrue);
@@ -2100,7 +2100,7 @@
ASSERT_EQ(contents.size(), 1u);
auto* media_description = contents[0].media_description();
ASSERT_TRUE(media_description);
- std::vector<cricket::Codec> codecs = media_description->codecs();
+ std::vector<Codec> codecs = media_description->codecs();
for (auto& codec : codecs) {
if (codec.name == cricket::kOpusCodecName) {
// Enabled by default so we need to remove the parameter.
@@ -2124,7 +2124,7 @@
ASSERT_EQ(contents.size(), 1u);
auto* media_description = contents[0].media_description();
ASSERT_TRUE(media_description);
- std::vector<cricket::Codec> codecs = media_description->codecs();
+ std::vector<Codec> codecs = media_description->codecs();
for (auto& codec : codecs) {
if (codec.name == cricket::kOpusCodecName) {
codec.SetParam(cricket::kCodecParamUseDtx, cricket::kParamValueTrue);
@@ -2147,7 +2147,7 @@
ASSERT_EQ(contents.size(), 1u);
auto* media_description = contents[0].media_description();
ASSERT_TRUE(media_description);
- std::vector<cricket::Codec> codecs = media_description->codecs();
+ std::vector<Codec> codecs = media_description->codecs();
for (auto& codec : codecs) {
if (codec.name == cricket::kOpusCodecName) {
codec.SetParam(cricket::kCodecParamCbr, cricket::kParamValueTrue);
@@ -2170,7 +2170,7 @@
ASSERT_EQ(contents.size(), 1u);
auto* media_description = contents[0].media_description();
ASSERT_TRUE(media_description);
- std::vector<cricket::Codec> codecs = media_description->codecs();
+ std::vector<Codec> codecs = media_description->codecs();
codecs.pop_back();
media_description->set_codecs(codecs);
RTCError error;
@@ -2189,8 +2189,8 @@
ASSERT_EQ(contents.size(), 1u);
auto* media_description = contents[0].media_description();
ASSERT_TRUE(media_description);
- std::vector<cricket::Codec> codecs = media_description->codecs();
- auto codec = cricket::CreateAudioCodec(SdpAudioFormat("pcmu", 8000, 1, {}));
+ std::vector<Codec> codecs = media_description->codecs();
+ auto codec = CreateAudioCodec(SdpAudioFormat("pcmu", 8000, 1, {}));
codec.id = 19; // IANA reserved payload type, should not conflict.
codecs.push_back(codec);
media_description->set_codecs(codecs);
@@ -2210,7 +2210,7 @@
ASSERT_EQ(contents.size(), 1u);
auto* media_description = contents[0].media_description();
ASSERT_TRUE(media_description);
- std::vector<cricket::Codec> codecs = media_description->codecs();
+ std::vector<Codec> codecs = media_description->codecs();
codecs.pop_back();
media_description->set_codecs(codecs);
RTCError error;
@@ -2229,8 +2229,8 @@
ASSERT_EQ(contents.size(), 1u);
auto* media_description = contents[0].media_description();
ASSERT_TRUE(media_description);
- std::vector<cricket::Codec> codecs = media_description->codecs();
- auto codec = cricket::CreateVideoCodec(SdpVideoFormat("VP8", {}));
+ std::vector<Codec> codecs = media_description->codecs();
+ auto codec = CreateVideoCodec(SdpVideoFormat("VP8", {}));
codec.id = 19; // IANA reserved payload type, should not conflict.
codecs.push_back(codec);
media_description->set_codecs(codecs);
@@ -2250,12 +2250,12 @@
ASSERT_EQ(contents.size(), 1u);
auto* media_description = contents[0].media_description();
ASSERT_TRUE(media_description);
- std::vector<cricket::Codec> codecs = media_description->codecs();
+ std::vector<Codec> codecs = media_description->codecs();
auto multiopus =
- cricket::CreateAudioCodec(SdpAudioFormat("multiopus", 48000, 4,
- {{"channel_mapping", "0,1,2,3"},
- {"coupled_streams", "2"},
- {"num_streams", "2"}}));
+ CreateAudioCodec(SdpAudioFormat("multiopus", 48000, 4,
+ {{"channel_mapping", "0,1,2,3"},
+ {"coupled_streams", "2"},
+ {"num_streams", "2"}}));
multiopus.id = 19; // IANA reserved payload type, should not conflict.
codecs.push_back(multiopus);
media_description->set_codecs(codecs);
@@ -2275,8 +2275,8 @@
ASSERT_EQ(contents.size(), 1u);
auto* media_description = contents[0].media_description();
ASSERT_TRUE(media_description);
- std::vector<cricket::Codec> codecs = media_description->codecs();
- auto l16 = cricket::CreateAudioCodec(SdpAudioFormat("L16", 48000, 2, {}));
+ std::vector<Codec> codecs = media_description->codecs();
+ auto l16 = CreateAudioCodec(SdpAudioFormat("L16", 48000, 2, {}));
l16.id = 19; // IANA reserved payload type, should not conflict.
codecs.push_back(l16);
media_description->set_codecs(codecs);
@@ -2504,7 +2504,7 @@
ASSERT_TRUE(media_description);
auto codecs = media_description->codecs();
ASSERT_GT(codecs.size(), 0u);
- codecs[0].feedback_params.Add(cricket::FeedbackParam("nack"));
+ codecs[0].feedback_params.Add(FeedbackParam("nack"));
media_description->set_codecs(codecs);
RTCError error;
@@ -2525,7 +2525,7 @@
ASSERT_TRUE(media_description);
auto codecs = media_description->codecs();
ASSERT_GT(codecs.size(), 0u);
- codecs[0].feedback_params.Add(cricket::FeedbackParam("rrtr"));
+ codecs[0].feedback_params.Add(FeedbackParam("rrtr"));
media_description->set_codecs(codecs);
RTCError error;
diff --git a/pc/session_description.h b/pc/session_description.h
index 1b39b18..1cfeac8 100644
--- a/pc/session_description.h
+++ b/pc/session_description.h
@@ -230,18 +230,16 @@
}
// Codecs should be in preference order (most preferred codec first).
- const std::vector<cricket::Codec>& codecs() const { return codecs_; }
- void set_codecs(const std::vector<cricket::Codec>& codecs) {
- codecs_ = codecs;
- }
+ const std::vector<Codec>& codecs() const { return codecs_; }
+ void set_codecs(const std::vector<Codec>& codecs) { codecs_ = codecs; }
virtual bool has_codecs() const { return !codecs_.empty(); }
bool HasCodec(int id) {
- return absl::c_find_if(codecs_, [id](const cricket::Codec codec) {
+ return absl::c_find_if(codecs_, [id](const Codec codec) {
return codec.id == id;
}) != codecs_.end();
}
- void AddCodec(const cricket::Codec& codec) { codecs_.push_back(codec); }
- void AddOrReplaceCodec(const cricket::Codec& codec) {
+ void AddCodec(const Codec& codec) { codecs_.push_back(codec); }
+ void AddOrReplaceCodec(const Codec& codec) {
for (auto it = codecs_.begin(); it != codecs_.end(); ++it) {
if (it->id == codec.id) {
*it = codec;
@@ -250,7 +248,7 @@
}
AddCodec(codec);
}
- void AddCodecs(const std::vector<cricket::Codec>& codecs) {
+ void AddCodecs(const std::vector<Codec>& codecs) {
for (const auto& codec : codecs) {
AddCodec(codec);
}
@@ -286,7 +284,7 @@
// by each final subclass.
virtual MediaContentDescription* CloneInternal() const = 0;
- std::vector<cricket::Codec> codecs_;
+ std::vector<Codec> codecs_;
};
class RtpMediaContentDescription : public MediaContentDescription {};
diff --git a/pc/simulcast_sdp_serializer.cc b/pc/simulcast_sdp_serializer.cc
index 6e2ec93..f12e777 100644
--- a/pc/simulcast_sdp_serializer.cc
+++ b/pc/simulcast_sdp_serializer.cc
@@ -290,11 +290,11 @@
// looking up codecs from the media description, as opposed to trusting the
// `rid_descriptions.codecs[i].id` directly as these are typically wrong.
std::vector<int> payload_types;
- for (const cricket::Codec& codec : rid_description.codecs) {
+ for (const Codec& codec : rid_description.codecs) {
RtpCodec rtp_codec = codec.ToCodecParameters();
const auto it = std::find_if(
media_desc.codecs().begin(), media_desc.codecs().end(),
- [&rtp_codec](const cricket::Codec& m_section_codec) {
+ [&rtp_codec](const Codec& m_section_codec) {
return IsSameRtpCodecIgnoringLevel(m_section_codec, rtp_codec);
});
// The desired codec from setParameters() may not have been negotiated, e.g.
@@ -302,7 +302,7 @@
if (it == media_desc.codecs().end()) {
break;
}
- if (it->id == cricket::Codec::kIdNotSet) {
+ if (it->id == Codec::kIdNotSet) {
RTC_DCHECK_NOTREACHED();
break;
}
@@ -428,7 +428,7 @@
for (const int& payload_type : rid_payload_types) {
const auto it =
std::find_if(media_desc.codecs().begin(), media_desc.codecs().end(),
- [&payload_type](const cricket::Codec& m_section_codec) {
+ [&payload_type](const Codec& m_section_codec) {
return m_section_codec.id == payload_type;
});
if (it == media_desc.codecs().end()) {
diff --git a/pc/simulcast_sdp_serializer_unittest.cc b/pc/simulcast_sdp_serializer_unittest.cc
index ce3a96c..4ab036e 100644
--- a/pc/simulcast_sdp_serializer_unittest.cc
+++ b/pc/simulcast_sdp_serializer_unittest.cc
@@ -323,8 +323,8 @@
// Test serialization for RidDescription with format list.
TEST_F(RidDescriptionSdpSerializerTest, Serialize_FormatList) {
- cricket::Codec vp8 = cricket::CreateVideoCodec(101, "VP8");
- cricket::Codec vp9 = cricket::CreateVideoCodec(102, "VP9");
+ Codec vp8 = CreateVideoCodec(101, "VP8");
+ Codec vp9 = CreateVideoCodec(102, "VP9");
VideoContentDescription video_desc;
video_desc.set_codecs({vp8, vp9});
@@ -335,7 +335,7 @@
// Test serialization for RidDescription with format list.
TEST_F(RidDescriptionSdpSerializerTest, Serialize_FormatListSingleFormat) {
- cricket::Codec vp8 = cricket::CreateVideoCodec(100, "VP8");
+ Codec vp8 = CreateVideoCodec(100, "VP8");
VideoContentDescription video_desc;
video_desc.set_codecs({vp8});
@@ -357,8 +357,8 @@
// Test serialization for RidDescription with format list and attribute list.
// Note: restriction list will be sorted because it is stored in a map.
TEST_F(RidDescriptionSdpSerializerTest, Serialize_FormatAndAttributeList) {
- cricket::Codec vp8 = cricket::CreateVideoCodec(103, "VP8");
- cricket::Codec vp9 = cricket::CreateVideoCodec(104, "VP9");
+ Codec vp8 = CreateVideoCodec(103, "VP8");
+ Codec vp9 = CreateVideoCodec(104, "VP9");
VideoContentDescription video_desc;
video_desc.set_codecs({vp8, vp9});
@@ -373,7 +373,7 @@
// Test serialization for attribute list that has key with no value.
// Note: restriction list will be sorted because it is stored in a map.
TEST_F(RidDescriptionSdpSerializerTest, Serialize_RestrictionWithoutValue) {
- cricket::Codec vp8 = cricket::CreateVideoCodec(103, "VP8");
+ Codec vp8 = CreateVideoCodec(103, "VP8");
VideoContentDescription video_desc;
video_desc.set_codecs({vp8});
@@ -400,7 +400,7 @@
// Test simulcast deserialization with single format.
TEST_F(RidDescriptionSdpSerializerTest, Deserialize_WithFormat) {
- cricket::Codec vp8 = cricket::CreateVideoCodec(101, "VP8");
+ Codec vp8 = CreateVideoCodec(101, "VP8");
VideoContentDescription video_desc;
video_desc.set_codecs({vp8});
@@ -412,7 +412,7 @@
// Test simulcast deserialization with valid format syntax (`pt=97`) but using
// a payload type that does not refer to any codec in the media description.
TEST_F(RidDescriptionSdpSerializerTest, Deserialize_ReferencingUnknownCodec) {
- cricket::Codec vp8 = cricket::CreateVideoCodec(101, "VP8");
+ Codec vp8 = CreateVideoCodec(101, "VP8");
VideoContentDescription video_desc;
video_desc.set_codecs({vp8});
@@ -423,10 +423,10 @@
// Test simulcast deserialization with multiple formats.
TEST_F(RidDescriptionSdpSerializerTest, Deserialize_WithMultipleFormats) {
- cricket::Codec vp8 = cricket::CreateVideoCodec(101, "VP8");
- cricket::Codec vp9 = cricket::CreateVideoCodec(102, "VP9");
- cricket::Codec av1 = cricket::CreateVideoCodec(103, "AV1");
- cricket::Codec h264 = cricket::CreateVideoCodec(104, "H264");
+ Codec vp8 = CreateVideoCodec(101, "VP8");
+ Codec vp9 = CreateVideoCodec(102, "VP9");
+ Codec av1 = CreateVideoCodec(103, "AV1");
+ Codec h264 = CreateVideoCodec(104, "H264");
VideoContentDescription video_desc;
video_desc.set_codecs({vp8, vp9, av1, h264});
@@ -467,8 +467,8 @@
// Test simulcast deserialization with multiple formats and restrictions.
TEST_F(RidDescriptionSdpSerializerTest, Deserialize_WithFormatAndRestrictions) {
- cricket::Codec av1 = cricket::CreateVideoCodec(103, "AV1");
- cricket::Codec h264 = cricket::CreateVideoCodec(104, "H264");
+ Codec av1 = CreateVideoCodec(103, "AV1");
+ Codec h264 = CreateVideoCodec(104, "H264");
VideoContentDescription video_desc;
video_desc.set_codecs({av1, h264});
@@ -483,7 +483,7 @@
// Test simulcast deserialization with restriction that has no value.
TEST_F(RidDescriptionSdpSerializerTest, Deserialize_RestrictionHasNoValue) {
- cricket::Codec h264 = cricket::CreateVideoCodec(104, "H264");
+ Codec h264 = CreateVideoCodec(104, "H264");
VideoContentDescription video_desc;
video_desc.set_codecs({h264});
@@ -510,8 +510,8 @@
// Parameterized negative test case for deserialization with invalid inputs.
TEST_P(RidDescriptionSdpSerializerTest, RidDescriptionDeserializationFailed) {
VideoContentDescription video_desc;
- video_desc.set_codecs({cricket::CreateVideoCodec(101, "VP8"),
- cricket::CreateVideoCodec(102, "VP9")});
+ video_desc.set_codecs(
+ {CreateVideoCodec(101, "VP8"), CreateVideoCodec(102, "VP9")});
SimulcastSdpSerializer deserializer;
auto result = deserializer.DeserializeRidDescription(video_desc, GetParam());
diff --git a/pc/test/mock_rtp_sender_internal.h b/pc/test/mock_rtp_sender_internal.h
index 4722a69..e2902b2 100644
--- a/pc/test/mock_rtp_sender_internal.h
+++ b/pc/test/mock_rtp_sender_internal.h
@@ -82,11 +82,8 @@
CheckCodecParameters,
(const RtpParameters&),
(override));
- MOCK_METHOD(void, SetSendCodecs, (std::vector<cricket::Codec>), (override));
- MOCK_METHOD(std::vector<cricket::Codec>,
- GetSendCodecs,
- (),
- (const, override));
+ MOCK_METHOD(void, SetSendCodecs, (std::vector<Codec>), (override));
+ MOCK_METHOD(std::vector<Codec>, GetSendCodecs, (), (const, override));
MOCK_METHOD(rtc::scoped_refptr<DtmfSenderInterface>,
GetDtmfSender,
(),
diff --git a/pc/typed_codec_vendor.cc b/pc/typed_codec_vendor.cc
index 2c67b19..c9a0561 100644
--- a/pc/typed_codec_vendor.cc
+++ b/pc/typed_codec_vendor.cc
@@ -31,9 +31,9 @@
namespace {
// Create the voice codecs. Do not allocate payload types at this time.
-std::vector<cricket::Codec> CollectAudioCodecs(
+std::vector<Codec> CollectAudioCodecs(
const std::vector<AudioCodecSpec>& specs) {
- std::vector<cricket::Codec> out;
+ std::vector<Codec> out;
// Only generate CN payload types for these clockrates:
std::map<int, bool, std::greater<int>> generate_cn = {{8000, false}};
@@ -42,10 +42,10 @@
{48000, false}};
for (const auto& spec : specs) {
- cricket::Codec codec = cricket::CreateAudioCodec(spec.format);
+ Codec codec = CreateAudioCodec(spec.format);
if (spec.info.supports_network_adaption) {
- codec.AddFeedbackParam(cricket::FeedbackParam(
- cricket::kRtcpFbParamTransportCc, cricket::kParamValueEmpty));
+ codec.AddFeedbackParam(FeedbackParam(cricket::kRtcpFbParamTransportCc,
+ cricket::kParamValueEmpty));
}
if (spec.info.allow_comfort_noise) {
@@ -70,8 +70,7 @@
if (codec.name == cricket::kOpusCodecName) {
// We don't know the PT to put into the RED fmtp parameter yet.
// Leave it out.
- cricket::Codec red_codec =
- cricket::CreateAudioCodec({cricket::kRedCodecName, 48000, 2});
+ Codec red_codec = CreateAudioCodec({cricket::kRedCodecName, 48000, 2});
out.push_back(red_codec);
}
}
@@ -79,8 +78,7 @@
// Add CN codecs after "proper" audio codecs.
for (const auto& cn : generate_cn) {
if (cn.second) {
- cricket::Codec cn_codec =
- cricket::CreateAudioCodec({cricket::kCnCodecName, cn.first, 1});
+ Codec cn_codec = CreateAudioCodec({cricket::kCnCodecName, cn.first, 1});
out.push_back(cn_codec);
}
}
@@ -88,8 +86,8 @@
// Add telephone-event codecs last.
for (const auto& dtmf : generate_dtmf) {
if (dtmf.second) {
- cricket::Codec dtmf_codec =
- cricket::CreateAudioCodec({cricket::kDtmfCodecName, dtmf.first, 1});
+ Codec dtmf_codec =
+ CreateAudioCodec({cricket::kDtmfCodecName, dtmf.first, 1});
out.push_back(dtmf_codec);
}
}
@@ -108,20 +106,16 @@
if (type == MediaType::AUDIO) {
if (is_sender) {
if (media_engine->voice().encoder_factory()) {
- codecs_ = cricket::CodecList::CreateFromTrustedData(
- CollectAudioCodecs(media_engine->voice()
- .encoder_factory()
- ->GetSupportedEncoders()));
+ codecs_ = CodecList::CreateFromTrustedData(CollectAudioCodecs(
+ media_engine->voice().encoder_factory()->GetSupportedEncoders()));
} else {
RTC_LOG(LS_WARNING)
<< "No voice encoder factory. Should only happen in test.";
}
} else {
if (media_engine->voice().decoder_factory()) {
- codecs_ = cricket::CodecList::CreateFromTrustedData(
- CollectAudioCodecs(media_engine->voice()
- .decoder_factory()
- ->GetSupportedDecoders()));
+ codecs_ = CodecList::CreateFromTrustedData(CollectAudioCodecs(
+ media_engine->voice().decoder_factory()->GetSupportedDecoders()));
} else {
RTC_LOG(LS_WARNING)
<< "No voice decoder factory. Should only happen in test.";
@@ -131,10 +125,10 @@
// Use legacy mechanisms for getting codecs from video engine.
// TODO: https://issues.webrtc.org/360058654 - apply late assign to video.
if (is_sender) {
- codecs_ = cricket::CodecList::CreateFromTrustedData(
+ codecs_ = CodecList::CreateFromTrustedData(
media_engine->video().LegacySendCodecs(rtx_enabled));
} else {
- codecs_ = cricket::CodecList::CreateFromTrustedData(
+ codecs_ = CodecList::CreateFromTrustedData(
media_engine->video().LegacyRecvCodecs(rtx_enabled));
}
}
@@ -142,18 +136,18 @@
// Use current mechanisms for getting codecs from media engine.
if (type == MediaType::AUDIO) {
if (is_sender) {
- codecs_ = cricket::CodecList::CreateFromTrustedData(
+ codecs_ = CodecList::CreateFromTrustedData(
media_engine->voice().LegacySendCodecs());
} else {
- codecs_ = cricket::CodecList::CreateFromTrustedData(
+ codecs_ = CodecList::CreateFromTrustedData(
media_engine->voice().LegacyRecvCodecs());
}
} else {
if (is_sender) {
- codecs_ = cricket::CodecList::CreateFromTrustedData(
+ codecs_ = CodecList::CreateFromTrustedData(
media_engine->video().LegacySendCodecs(rtx_enabled));
} else {
- codecs_ = cricket::CodecList::CreateFromTrustedData(
+ codecs_ = CodecList::CreateFromTrustedData(
media_engine->video().LegacyRecvCodecs(rtx_enabled));
}
}
diff --git a/pc/typed_codec_vendor.h b/pc/typed_codec_vendor.h
index 1b64827..a81e565 100644
--- a/pc/typed_codec_vendor.h
+++ b/pc/typed_codec_vendor.h
@@ -31,14 +31,14 @@
bool is_sender,
bool rtx_enabled,
const FieldTrialsView& trials);
- const cricket::CodecList& codecs() const { return codecs_; }
- void set_codecs(const cricket::CodecList& codecs) { codecs_ = codecs; }
+ const CodecList& codecs() const { return codecs_; }
+ void set_codecs(const CodecList& codecs) { codecs_ = codecs; }
// For easy initialization, copying is allowed.
TypedCodecVendor(const TypedCodecVendor& from) = default;
TypedCodecVendor& operator=(const TypedCodecVendor& from) = default;
private:
- cricket::CodecList codecs_;
+ CodecList codecs_;
};
} // namespace webrtc
diff --git a/pc/used_ids.h b/pc/used_ids.h
index bc68329..b719a04 100644
--- a/pc/used_ids.h
+++ b/pc/used_ids.h
@@ -90,15 +90,15 @@
// Helper class used for finding duplicate RTP payload types among audio, video
// and data codecs. When bundle is used the payload types may not collide.
-class UsedPayloadTypes : public UsedIds<cricket::Codec> {
+class UsedPayloadTypes : public UsedIds<Codec> {
public:
UsedPayloadTypes()
- : UsedIds<cricket::Codec>(kFirstDynamicPayloadTypeLowerRange,
- kLastDynamicPayloadTypeUpperRange) {}
+ : UsedIds<Codec>(kFirstDynamicPayloadTypeLowerRange,
+ kLastDynamicPayloadTypeUpperRange) {}
// Check if a payload type is valid. The range [64-95] is forbidden
// when rtcp-mux is used.
- static bool IsIdValid(cricket::Codec codec, bool rtcp_mux) {
+ static bool IsIdValid(Codec codec, bool rtcp_mux) {
if (rtcp_mux && (codec.id > kLastDynamicPayloadTypeLowerRange &&
codec.id < kFirstDynamicPayloadTypeUpperRange)) {
return false;
@@ -112,7 +112,7 @@
if (new_id > kLastDynamicPayloadTypeLowerRange &&
new_id < kFirstDynamicPayloadTypeUpperRange)
return true;
- return UsedIds<cricket::Codec>::IsIdUsed(new_id);
+ return UsedIds<Codec>::IsIdUsed(new_id);
}
private:
diff --git a/pc/webrtc_sdp.cc b/pc/webrtc_sdp.cc
index b387628..8af2057 100644
--- a/pc/webrtc_sdp.cc
+++ b/pc/webrtc_sdp.cc
@@ -1415,7 +1415,7 @@
media_type == webrtc::MediaType::VIDEO) {
type = media_type == webrtc::MediaType::AUDIO ? kSdpMediaTypeAudio
: kSdpMediaTypeVideo;
- for (const cricket::Codec& codec : media_desc->codecs()) {
+ for (const Codec& codec : media_desc->codecs()) {
fmt.append(" ");
fmt.append(absl::StrCat(codec.id));
}
@@ -1820,7 +1820,7 @@
return !empty;
}
-void AddFmtpLine(const cricket::Codec& codec, std::string* message) {
+void AddFmtpLine(const Codec& codec, std::string* message) {
StringBuilder os;
WriteFmtpHeader(codec.id, &os);
os << kSdpDelimiterSpace;
@@ -1831,7 +1831,7 @@
return;
}
-void AddPacketizationLine(const cricket::Codec& codec, std::string* message) {
+void AddPacketizationLine(const Codec& codec, std::string* message) {
if (!codec.packetization) {
return;
}
@@ -1841,8 +1841,8 @@
AddLine(os.str(), message);
}
-void AddRtcpFbLines(const cricket::Codec& codec, std::string* message) {
- for (const cricket::FeedbackParam& param : codec.feedback_params.params()) {
+void AddRtcpFbLines(const Codec& codec, std::string* message) {
+ for (const FeedbackParam& param : codec.feedback_params.params()) {
StringBuilder os;
WriteRtcpFbHeader(codec.id, &os);
os << " " << param.id();
@@ -1882,7 +1882,7 @@
RTC_DCHECK(media_desc != NULL);
StringBuilder os;
if (media_type == webrtc::MediaType::VIDEO) {
- for (const cricket::Codec& codec : media_desc->codecs()) {
+ for (const Codec& codec : media_desc->codecs()) {
// RFC 4566
// a=rtpmap:<payload type> <encoding name>/<clock rate>
// [/<encodingparameters>]
@@ -1900,7 +1900,7 @@
std::vector<int> ptimes;
std::vector<int> maxptimes;
int max_minptime = 0;
- for (const cricket::Codec& codec : media_desc->codecs()) {
+ for (const Codec& codec : media_desc->codecs()) {
RTC_DCHECK(!codec.name.empty());
// RFC 4566
// a=rtpmap:<payload type> <encoding name>/<clock rate>
@@ -2537,13 +2537,13 @@
std::string encoding_name = kStaticPayloadAudioCodecs[payload_type].name;
int clock_rate = kStaticPayloadAudioCodecs[payload_type].clockrate;
size_t channels = kStaticPayloadAudioCodecs[payload_type].channels;
- media_desc->AddCodec(cricket::CreateAudioCodec(
- payload_type, encoding_name, clock_rate, channels));
+ media_desc->AddCodec(
+ CreateAudioCodec(payload_type, encoding_name, clock_rate, channels));
}
}
}
-static void BackfillCodecParameters(std::vector<cricket::Codec>& codecs) {
+static void BackfillCodecParameters(std::vector<Codec>& codecs) {
for (auto& codec : codecs) {
std::string unused_value;
if (absl::EqualsIgnoreCase(cricket::kVp9CodecName, codec.name)) {
@@ -2619,11 +2619,11 @@
for (int pt : payload_types) {
payload_type_preferences[pt] = preference--;
}
- std::vector<cricket::Codec> codecs = media_desc->codecs();
- absl::c_sort(codecs, [&payload_type_preferences](const cricket::Codec& a,
- const cricket::Codec& b) {
- return payload_type_preferences[a.id] > payload_type_preferences[b.id];
- });
+ std::vector<Codec> codecs = media_desc->codecs();
+ absl::c_sort(
+ codecs, [&payload_type_preferences](const Codec& a, const Codec& b) {
+ return payload_type_preferences[a.id] > payload_type_preferences[b.id];
+ });
// Backfill any default parameters.
BackfillCodecParameters(codecs);
@@ -2845,8 +2845,7 @@
return true;
}
-void AddParameters(const webrtc::CodecParameterMap& parameters,
- cricket::Codec* codec) {
+void AddParameters(const webrtc::CodecParameterMap& parameters, Codec* codec) {
for (const auto& entry : parameters) {
const std::string& key = entry.first;
const std::string& value = entry.second;
@@ -2854,14 +2853,13 @@
}
}
-void AddFeedbackParameter(const cricket::FeedbackParam& feedback_param,
- cricket::Codec* codec) {
+void AddFeedbackParameter(const FeedbackParam& feedback_param, Codec* codec) {
codec->AddFeedbackParam(feedback_param);
}
-void AddFeedbackParameters(const cricket::FeedbackParams& feedback_params,
- cricket::Codec* codec) {
- for (const cricket::FeedbackParam& param : feedback_params.params()) {
+void AddFeedbackParameters(const FeedbackParams& feedback_params,
+ Codec* codec) {
+ for (const FeedbackParam& param : feedback_params.params()) {
codec->AddFeedbackParam(param);
}
}
@@ -2869,27 +2867,26 @@
// Gets the current codec setting associated with `payload_type`. If there
// is no Codec associated with that payload type it returns an empty codec
// with that payload type.
-cricket::Codec GetCodecWithPayloadType(
- webrtc::MediaType type,
- const std::vector<cricket::Codec>& codecs,
- int payload_type) {
- const cricket::Codec* codec = FindCodecById(codecs, payload_type);
+Codec GetCodecWithPayloadType(webrtc::MediaType type,
+ const std::vector<Codec>& codecs,
+ int payload_type) {
+ const Codec* codec = FindCodecById(codecs, payload_type);
if (codec)
return *codec;
// Return empty codec with `payload_type`.
if (type == webrtc::MediaType::AUDIO) {
- return cricket::CreateAudioCodec(payload_type, "", 0, 0);
+ return CreateAudioCodec(payload_type, "", 0, 0);
} else {
- return cricket::CreateVideoCodec(payload_type, "");
+ return CreateVideoCodec(payload_type, "");
}
}
// Updates or creates a new codec entry in the media description.
void AddOrReplaceCodec(MediaContentDescription* content_desc,
- const cricket::Codec& codec) {
- std::vector<cricket::Codec> codecs = content_desc->codecs();
+ const Codec& codec) {
+ std::vector<Codec> codecs = content_desc->codecs();
bool found = false;
- for (cricket::Codec& existing_codec : codecs) {
+ for (Codec& existing_codec : codecs) {
if (codec.id == existing_codec.id) {
// Overwrite existing codec with the new codec.
existing_codec = codec;
@@ -2910,7 +2907,7 @@
int payload_type,
const webrtc::CodecParameterMap& parameters) {
// Codec might already have been populated (from rtpmap).
- cricket::Codec new_codec = GetCodecWithPayloadType(
+ Codec new_codec = GetCodecWithPayloadType(
content_desc->type(), content_desc->codecs(), payload_type);
AddParameters(parameters, &new_codec);
AddOrReplaceCodec(content_desc, new_codec);
@@ -2920,9 +2917,9 @@
// to `feedback_param`.
void UpdateCodec(MediaContentDescription* content_desc,
int payload_type,
- const cricket::FeedbackParam& feedback_param) {
+ const FeedbackParam& feedback_param) {
// Codec might already have been populated (from rtpmap).
- cricket::Codec new_codec = GetCodecWithPayloadType(
+ Codec new_codec = GetCodecWithPayloadType(
content_desc->type(), content_desc->codecs(), payload_type);
AddFeedbackParameter(feedback_param, &new_codec);
AddOrReplaceCodec(content_desc, new_codec);
@@ -2939,18 +2936,17 @@
}
// Codec might already have been populated (from rtpmap).
- cricket::Codec codec =
+ Codec codec =
GetCodecWithPayloadType(desc->type(), desc->codecs(), payload_type);
codec.packetization = std::string(packetization);
AddOrReplaceCodec(desc, codec);
}
-std::optional<cricket::Codec> PopWildcardCodec(
- std::vector<cricket::Codec>* codecs) {
+std::optional<Codec> PopWildcardCodec(std::vector<Codec>* codecs) {
RTC_DCHECK(codecs);
for (auto iter = codecs->begin(); iter != codecs->end(); ++iter) {
if (iter->id == kWildcardPayloadType) {
- cricket::Codec wildcard_codec = *iter;
+ Codec wildcard_codec = *iter;
codecs->erase(iter);
return wildcard_codec;
}
@@ -2961,7 +2957,7 @@
void UpdateFromWildcardCodecs(MediaContentDescription* desc) {
RTC_DCHECK(desc);
auto codecs = desc->codecs();
- std::optional<cricket::Codec> wildcard_codec = PopWildcardCodec(&codecs);
+ std::optional<Codec> wildcard_codec = PopWildcardCodec(&codecs);
if (!wildcard_codec) {
return;
}
@@ -2982,8 +2978,8 @@
if (value.empty()) {
return;
}
- std::vector<cricket::Codec> codecs = desc->codecs();
- for (cricket::Codec& codec : codecs) {
+ std::vector<Codec> codecs = desc->codecs();
+ for (Codec& codec : codecs) {
codec.params[name] = std::string(value);
}
desc->set_codecs(codecs);
@@ -3387,9 +3383,8 @@
// Codec has not been populated correctly unless the name has been set. This
// can happen if an SDP has an fmtp or rtcp-fb with a payload type but doesn't
// have a corresponding "rtpmap" line. This should lead to a parse error.
- if (!absl::c_all_of(media_desc->codecs(), [](const cricket::Codec codec) {
- return !codec.name.empty();
- })) {
+ if (!absl::c_all_of(media_desc->codecs(),
+ [](const Codec codec) { return !codec.name.empty(); })) {
return ParseFailed("Failed to parse codecs correctly.", error);
}
if (media_type == webrtc::MediaType::AUDIO) {
@@ -3528,7 +3523,7 @@
MediaContentDescription* desc) {
// Codec may already be populated with (only) optional parameters
// (from an fmtp).
- cricket::Codec codec =
+ Codec codec =
GetCodecWithPayloadType(desc->type(), desc->codecs(), payload_type);
codec.name = std::string(name);
codec.clockrate = clockrate;
@@ -3544,7 +3539,7 @@
MediaContentDescription* desc) {
// Codec may already be populated with (only) optional parameters
// (from an fmtp).
- cricket::Codec codec =
+ Codec codec =
GetCodecWithPayloadType(desc->type(), desc->codecs(), payload_type);
codec.name = std::string(name);
AddOrReplaceCodec(desc, codec);
@@ -3596,7 +3591,7 @@
}
if (media_type == webrtc::MediaType::VIDEO) {
- for (const cricket::Codec& existing_codec : media_desc->codecs()) {
+ for (const Codec& existing_codec : media_desc->codecs()) {
if (!existing_codec.name.empty() && payload_type == existing_codec.id &&
(!absl::EqualsIgnoreCase(encoding_name, existing_codec.name) ||
clock_rate != existing_codec.clockrate)) {
@@ -3627,7 +3622,7 @@
return ParseFailed(line, "At most 24 channels are supported.", error);
}
- for (const cricket::Codec& existing_codec : media_desc->codecs()) {
+ for (const Codec& existing_codec : media_desc->codecs()) {
// TODO(crbug.com/1338902) re-add checks for clockrate and number of
// channels.
if (!existing_codec.name.empty() && payload_type == existing_codec.id &&
@@ -3788,7 +3783,7 @@
++iter) {
param.append(iter->data(), iter->length());
}
- const cricket::FeedbackParam feedback_param(id, param);
+ const FeedbackParam feedback_param(id, param);
if (media_type == webrtc::MediaType::AUDIO ||
media_type == webrtc::MediaType::VIDEO) {
diff --git a/pc/webrtc_sdp_unittest.cc b/pc/webrtc_sdp_unittest.cc
index 990d800..77ef019 100644
--- a/pc/webrtc_sdp_unittest.cc
+++ b/pc/webrtc_sdp_unittest.cc
@@ -1247,9 +1247,9 @@
audio->set_rtcp_mux(true);
audio->set_rtcp_reduced_size(true);
audio->set_protocol(webrtc::kMediaProtocolSavpf);
- audio->AddCodec(cricket::CreateAudioCodec(111, "opus", 48000, 2));
- audio->AddCodec(cricket::CreateAudioCodec(103, "ISAC", 16000, 1));
- audio->AddCodec(cricket::CreateAudioCodec(104, "ISAC", 32000, 1));
+ audio->AddCodec(webrtc::CreateAudioCodec(111, "opus", 48000, 2));
+ audio->AddCodec(webrtc::CreateAudioCodec(103, "ISAC", 16000, 1));
+ audio->AddCodec(webrtc::CreateAudioCodec(104, "ISAC", 32000, 1));
return audio;
}
@@ -1323,7 +1323,7 @@
VideoContentDescription* CreateVideoContentDescription() {
VideoContentDescription* video = new VideoContentDescription();
video->set_protocol(webrtc::kMediaProtocolSavpf);
- video->AddCodec(cricket::CreateVideoCodec(120, "VP8"));
+ video->AddCodec(webrtc::CreateVideoCodec(120, "VP8"));
return video;
}
@@ -1857,7 +1857,7 @@
webrtc::GetFirstAudioContentDescription(jdesc_output->description());
ASSERT_TRUE(acd);
ASSERT_FALSE(acd->codecs().empty());
- cricket::Codec opus = acd->codecs()[0];
+ webrtc::Codec opus = acd->codecs()[0];
EXPECT_EQ("opus", opus.name);
EXPECT_EQ(111, opus.id);
VerifyCodecParameter(opus.params, "minptime", params.min_ptime);
@@ -1871,7 +1871,7 @@
VerifyCodecParameter(codec.params, "maxptime", params.max_ptime);
}
- cricket::Codec dtmf = acd->codecs()[3];
+ webrtc::Codec dtmf = acd->codecs()[3];
EXPECT_EQ("telephone-event", dtmf.name);
EXPECT_EQ(105, dtmf.id);
EXPECT_EQ(3u,
@@ -1883,15 +1883,15 @@
webrtc::GetFirstVideoContentDescription(jdesc_output->description());
ASSERT_TRUE(vcd);
ASSERT_FALSE(vcd->codecs().empty());
- cricket::Codec vp8 = vcd->codecs()[0];
+ webrtc::Codec vp8 = vcd->codecs()[0];
EXPECT_EQ("VP8", vp8.name);
EXPECT_EQ(99, vp8.id);
- cricket::Codec rtx = vcd->codecs()[1];
+ webrtc::Codec rtx = vcd->codecs()[1];
EXPECT_EQ("RTX", rtx.name);
EXPECT_EQ(95, rtx.id);
VerifyCodecParameter(rtx.params, "apt", vp8.id);
// VP9 is listed last in the m= line so should come after VP8 and RTX.
- cricket::Codec vp9 = vcd->codecs()[2];
+ webrtc::Codec vp9 = vcd->codecs()[2];
EXPECT_EQ("VP9", vp9.name);
EXPECT_EQ(96, vp9.id);
}
@@ -1929,27 +1929,27 @@
webrtc::GetFirstAudioContentDescription(jdesc_output->description());
ASSERT_TRUE(acd);
ASSERT_FALSE(acd->codecs().empty());
- cricket::Codec opus = acd->codecs()[0];
+ webrtc::Codec opus = acd->codecs()[0];
EXPECT_EQ(111, opus.id);
- EXPECT_TRUE(opus.HasFeedbackParam(cricket::FeedbackParam(
+ EXPECT_TRUE(opus.HasFeedbackParam(webrtc::FeedbackParam(
cricket::kRtcpFbParamNack, cricket::kParamValueEmpty)));
const VideoContentDescription* vcd =
webrtc::GetFirstVideoContentDescription(jdesc_output->description());
ASSERT_TRUE(vcd);
ASSERT_FALSE(vcd->codecs().empty());
- cricket::Codec vp8 = vcd->codecs()[0];
+ webrtc::Codec vp8 = vcd->codecs()[0];
EXPECT_EQ(vp8.name, "VP8");
EXPECT_EQ(101, vp8.id);
- EXPECT_TRUE(vp8.HasFeedbackParam(cricket::FeedbackParam(
+ EXPECT_TRUE(vp8.HasFeedbackParam(webrtc::FeedbackParam(
cricket::kRtcpFbParamLntf, cricket::kParamValueEmpty)));
- EXPECT_TRUE(vp8.HasFeedbackParam(cricket::FeedbackParam(
+ EXPECT_TRUE(vp8.HasFeedbackParam(webrtc::FeedbackParam(
cricket::kRtcpFbParamNack, cricket::kParamValueEmpty)));
- EXPECT_TRUE(vp8.HasFeedbackParam(cricket::FeedbackParam(
+ EXPECT_TRUE(vp8.HasFeedbackParam(webrtc::FeedbackParam(
cricket::kRtcpFbParamNack, cricket::kRtcpFbNackParamPli)));
- EXPECT_TRUE(vp8.HasFeedbackParam(cricket::FeedbackParam(
+ EXPECT_TRUE(vp8.HasFeedbackParam(webrtc::FeedbackParam(
cricket::kRtcpFbParamRemb, cricket::kParamValueEmpty)));
- EXPECT_TRUE(vp8.HasFeedbackParam(cricket::FeedbackParam(
+ EXPECT_TRUE(vp8.HasFeedbackParam(webrtc::FeedbackParam(
cricket::kRtcpFbParamCcm, cricket::kRtcpFbCcmParamFir)));
}
@@ -2286,7 +2286,7 @@
}
TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithH264) {
- cricket::Codec h264_codec = cricket::CreateVideoCodec("H264");
+ webrtc::Codec h264_codec = webrtc::CreateVideoCodec("H264");
// Id must be valid, but value doesn't matter.
h264_codec.id = 123;
h264_codec.SetParam("profile-level-id", "42e01f");
@@ -2376,12 +2376,12 @@
EXPECT_TRUE(SdpDeserialize(kSdpNoRtpmapString, &jdesc));
webrtc::AudioContentDescription* audio =
webrtc::GetFirstAudioContentDescription(jdesc.description());
- cricket::Codecs ref_codecs;
+ webrtc::Codecs ref_codecs;
// The codecs in the AudioContentDescription should be in the same order as
// the payload types (<fmt>s) on the m= line.
- ref_codecs.push_back(cricket::CreateAudioCodec(0, "PCMU", 8000, 1));
- ref_codecs.push_back(cricket::CreateAudioCodec(18, "G729", 8000, 1));
- ref_codecs.push_back(cricket::CreateAudioCodec(103, "ISAC", 16000, 1));
+ ref_codecs.push_back(webrtc::CreateAudioCodec(0, "PCMU", 8000, 1));
+ ref_codecs.push_back(webrtc::CreateAudioCodec(18, "G729", 8000, 1));
+ ref_codecs.push_back(webrtc::CreateAudioCodec(103, "ISAC", 16000, 1));
EXPECT_EQ(ref_codecs, audio->codecs());
}
@@ -2400,7 +2400,7 @@
webrtc::AudioContentDescription* audio =
webrtc::GetFirstAudioContentDescription(jdesc.description());
- cricket::Codec g729 = audio->codecs()[0];
+ webrtc::Codec g729 = audio->codecs()[0];
EXPECT_EQ("G729", g729.name);
EXPECT_EQ(8000, g729.clockrate);
EXPECT_EQ(18, g729.id);
@@ -2408,7 +2408,7 @@
ASSERT_TRUE(found != g729.params.end());
EXPECT_EQ(found->second, "yes");
- cricket::Codec isac = audio->codecs()[1];
+ webrtc::Codec isac = audio->codecs()[1];
EXPECT_EQ("ISAC", isac.name);
EXPECT_EQ(103, isac.id);
EXPECT_EQ(16000, isac.clockrate);
@@ -3247,7 +3247,7 @@
webrtc::GetFirstVideoContentDescription(jdesc_output.description());
ASSERT_TRUE(vcd);
ASSERT_FALSE(vcd->codecs().empty());
- cricket::Codec vp8 = vcd->codecs()[0];
+ webrtc::Codec vp8 = vcd->codecs()[0];
EXPECT_EQ("VP8", vp8.name);
EXPECT_EQ(120, vp8.id);
webrtc::CodecParameterMap::iterator found =
@@ -3281,7 +3281,7 @@
webrtc::GetFirstVideoContentDescription(jdesc_output.description());
ASSERT_TRUE(vcd);
ASSERT_FALSE(vcd->codecs().empty());
- cricket::Codec h264 = vcd->codecs()[0];
+ webrtc::Codec h264 = vcd->codecs()[0];
EXPECT_EQ("H264", h264.name);
EXPECT_EQ(98, h264.id);
webrtc::CodecParameterMap::const_iterator found =
@@ -3314,7 +3314,7 @@
webrtc::GetFirstVideoContentDescription(jdesc_output.description());
ASSERT_TRUE(vcd);
ASSERT_FALSE(vcd->codecs().empty());
- cricket::Codec vp8 = vcd->codecs()[0];
+ webrtc::Codec vp8 = vcd->codecs()[0];
EXPECT_EQ("VP8", vp8.name);
EXPECT_EQ(120, vp8.id);
webrtc::CodecParameterMap::iterator found =
@@ -3352,7 +3352,7 @@
webrtc::GetFirstAudioContentDescription(jdesc_output.description());
ASSERT_TRUE(acd);
ASSERT_THAT(acd->codecs(), testing::SizeIs(1));
- cricket::Codec opus = acd->codecs()[0];
+ webrtc::Codec opus = acd->codecs()[0];
EXPECT_EQ(opus.name, "opus");
EXPECT_EQ(opus.id, 111);
@@ -3360,15 +3360,15 @@
webrtc::GetFirstVideoContentDescription(jdesc_output.description());
ASSERT_TRUE(vcd);
ASSERT_THAT(vcd->codecs(), testing::SizeIs(3));
- cricket::Codec vp8 = vcd->codecs()[0];
+ webrtc::Codec vp8 = vcd->codecs()[0];
EXPECT_EQ(vp8.name, "VP8");
EXPECT_EQ(vp8.id, 120);
EXPECT_EQ(vp8.packetization, "raw");
- cricket::Codec vp9 = vcd->codecs()[1];
+ webrtc::Codec vp9 = vcd->codecs()[1];
EXPECT_EQ(vp9.name, "VP9");
EXPECT_EQ(vp9.id, 121);
EXPECT_EQ(vp9.packetization, std::nullopt);
- cricket::Codec h264 = vcd->codecs()[2];
+ webrtc::Codec h264 = vcd->codecs()[2];
EXPECT_EQ(h264.name, "H264");
EXPECT_EQ(h264.id, 122);
EXPECT_EQ(h264.packetization, std::nullopt);
@@ -3378,7 +3378,7 @@
AudioContentDescription* acd =
webrtc::GetFirstAudioContentDescription(&desc_);
- cricket::Codecs codecs = acd->codecs();
+ webrtc::Codecs codecs = acd->codecs();
codecs[0].params["unknown-future-parameter"] = "SomeFutureValue";
acd->set_codecs(codecs);
@@ -3396,7 +3396,7 @@
AudioContentDescription* acd =
webrtc::GetFirstAudioContentDescription(&desc_);
- cricket::Codecs codecs = acd->codecs();
+ webrtc::Codecs codecs = acd->codecs();
codecs[0].params["stereo"] = "1";
acd->set_codecs(codecs);
@@ -3413,7 +3413,7 @@
AudioContentDescription* acd =
webrtc::GetFirstAudioContentDescription(&desc_);
- cricket::Codecs codecs = acd->codecs();
+ webrtc::Codecs codecs = acd->codecs();
codecs[0].params["ptime"] = "20";
codecs[0].params["maxptime"] = "120";
acd->set_codecs(codecs);
@@ -3433,9 +3433,9 @@
AudioContentDescription* acd =
webrtc::GetFirstAudioContentDescription(&desc_);
- cricket::Codecs codecs = acd->codecs();
- cricket::Codec dtmf =
- cricket::CreateAudioCodec(105, "telephone-event", 8000, 1);
+ webrtc::Codecs codecs = acd->codecs();
+ webrtc::Codec dtmf =
+ webrtc::CreateAudioCodec(105, "telephone-event", 8000, 1);
dtmf.params[""] = "0-15";
codecs.push_back(dtmf);
acd->set_codecs(codecs);
@@ -3457,7 +3457,7 @@
VideoContentDescription* vcd =
webrtc::GetFirstVideoContentDescription(&desc_);
- cricket::Codecs codecs = vcd->codecs();
+ webrtc::Codecs codecs = vcd->codecs();
codecs[0].params["x-google-min-bitrate"] = "10";
vcd->set_codecs(codecs);
@@ -3474,7 +3474,7 @@
VideoContentDescription* vcd =
webrtc::GetFirstVideoContentDescription(&desc_);
- cricket::Codecs codecs = vcd->codecs();
+ webrtc::Codecs codecs = vcd->codecs();
codecs[0].packetization = "raw";
vcd->set_codecs(codecs);
@@ -5116,7 +5116,7 @@
const auto content = jdesc.description()->contents()[0];
const auto* description = content.media_description();
ASSERT_NE(description, nullptr);
- const std::vector<cricket::Codec> codecs = description->codecs();
+ const std::vector<webrtc::Codec> codecs = description->codecs();
ASSERT_EQ(codecs.size(), 4u);
std::string value;
diff --git a/video/sv_loopback.cc b/video/sv_loopback.cc
index 3944eba..a0fda05 100644
--- a/video/sv_loopback.cc
+++ b/video/sv_loopback.cc
@@ -501,7 +501,7 @@
return absl::GetFlag(FLAGS_start_bitrate);
}
-std::string Codec() {
+std::string CodecName() {
return absl::GetFlag(FLAGS_codec);
}
@@ -615,7 +615,7 @@
ScreenshareTargetBitrateKbps() * 1000;
params.video[screenshare_idx].max_bitrate_bps =
ScreenshareMaxBitrateKbps() * 1000;
- params.video[screenshare_idx].codec = Codec();
+ params.video[screenshare_idx].codec = CodecName();
params.video[screenshare_idx].num_temporal_layers =
ScreenshareNumTemporalLayers();
params.video[screenshare_idx].selected_tl = ScreenshareSelectedTL();
@@ -630,7 +630,7 @@
params.video[camera_idx].max_bitrate_bps = VideoMaxBitrateKbps() * 1000;
params.video[camera_idx].suspend_below_min_bitrate =
absl::GetFlag(FLAGS_suspend_below_min_bitrate);
- params.video[camera_idx].codec = Codec();
+ params.video[camera_idx].codec = CodecName();
params.video[camera_idx].num_temporal_layers = VideoNumTemporalLayers();
params.video[camera_idx].selected_tl = VideoSelectedTL();
params.video[camera_idx].ulpfec = absl::GetFlag(FLAGS_use_ulpfec);
diff --git a/video/video_loopback.cc b/video/video_loopback.cc
index bcd3b35..699b953 100644
--- a/video/video_loopback.cc
+++ b/video/video_loopback.cc
@@ -256,7 +256,7 @@
}
}
-std::string Codec() {
+std::string CodecName() {
return absl::GetFlag(FLAGS_codec);
}
@@ -387,7 +387,7 @@
params.video[0].max_bitrate_bps = MaxBitrateKbps() * 1000;
params.video[0].suspend_below_min_bitrate =
absl::GetFlag(FLAGS_suspend_below_min_bitrate);
- params.video[0].codec = Codec();
+ params.video[0].codec = CodecName();
params.video[0].num_temporal_layers = NumTemporalLayers();
params.video[0].selected_tl = SelectedTL();
params.video[0].min_transmit_bps = 0;
