Merge the codec types
This allows simplifying code in the codebase to be able to remove a lot
of templated code and special casing for either AudioCodec and VideoCodec.
Code simplifications will come in later changes.
Bug: webrtc:15214
Change-Id: I6e75e6ea725163feb6cc4eb49f37b4722d6c6689
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/308501
Reviewed-by: Henrik Boström <hbos@webrtc.org>
Commit-Queue: Florent Castelli <orphis@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#40276}
diff --git a/media/base/codec.cc b/media/base/codec.cc
index a707a48..7a238cf 100644
--- a/media/base/codec.cc
+++ b/media/base/codec.cc
@@ -323,20 +323,6 @@
return true;
}
-AudioCodec::AudioCodec(int id,
- const std::string& name,
- int clockrate,
- int unused_bitrate,
- size_t channels)
- : Codec(Type::kAudio, id, name, clockrate, channels) {}
-
-AudioCodec::AudioCodec() : Codec(Type::kAudio) {}
-
-AudioCodec::AudioCodec(const AudioCodec& c) = default;
-AudioCodec::AudioCodec(AudioCodec&& c) = default;
-AudioCodec& AudioCodec::operator=(const AudioCodec& c) = default;
-AudioCodec& AudioCodec::operator=(AudioCodec&& c) = default;
-
std::string Codec::ToString() const {
char buf[256];
@@ -359,66 +345,16 @@
return sb.str();
}
-VideoCodec::VideoCodec(int id, const std::string& name)
- : Codec(Type::kVideo, id, name, kVideoCodecClockrate) {
- SetDefaultParameters();
-}
-
-VideoCodec::VideoCodec(const std::string& name) : VideoCodec(0 /* id */, name) {
- SetDefaultParameters();
-}
-
-VideoCodec::VideoCodec() : Codec(Type::kVideo) {
- clockrate = kVideoCodecClockrate;
-}
-
-VideoCodec::VideoCodec(const webrtc::SdpVideoFormat& c) : Codec(c) {}
-
-VideoCodec::VideoCodec(const VideoCodec& c) = default;
-VideoCodec::VideoCodec(VideoCodec&& c) = default;
-VideoCodec& VideoCodec::operator=(const VideoCodec& c) = default;
-VideoCodec& VideoCodec::operator=(VideoCodec&& c) = default;
-
-void VideoCodec::SetDefaultParameters() {
- if (absl::EqualsIgnoreCase(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.
- SetParam(kH264FmtpPacketizationMode, "1");
- }
-}
-
-VideoCodec VideoCodec::CreateRtxCodec(int rtx_payload_type,
- int associated_payload_type) {
- return CreateVideoRtxCodec(rtx_payload_type, associated_payload_type);
-}
-
-VideoCodec CreateVideoRtxCodec(int rtx_payload_type,
- int associated_payload_type) {
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
- VideoCodec rtx_codec(rtx_payload_type, kRtxCodecName);
-#pragma clang diagnostic pop
+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);
return rtx_codec;
}
-VideoCodec::CodecType VideoCodec::GetCodecType() const {
- if (absl::EqualsIgnoreCase(name, kRedCodecName)) {
- return CODEC_RED;
- }
- if (absl::EqualsIgnoreCase(name, kUlpfecCodecName)) {
- return CODEC_ULPFEC;
- }
- if (absl::EqualsIgnoreCase(name, kFlexfecCodecName)) {
- return CODEC_FLEXFEC;
- }
- if (absl::EqualsIgnoreCase(name, kRtxCodecName)) {
- return CODEC_RTX;
- }
-
- return CODEC_VIDEO;
+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);
+ return rtx_codec;
}
bool HasLntf(const Codec& codec) {
@@ -499,35 +435,31 @@
}
}
-AudioCodec CreateAudioCodec(int id,
- const std::string& name,
- int clockrate,
- size_t channels) {
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
- return AudioCodec(id, name, clockrate, 0, channels);
-#pragma clang diagnostic pop
+Codec CreateAudioCodec(int id,
+ const std::string& name,
+ int clockrate,
+ size_t channels) {
+ return Codec(Codec::Type::kAudio, id, name, clockrate, channels);
}
-VideoCodec CreateVideoCodec(const std::string& name) {
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
- return VideoCodec(name);
-#pragma clang diagnostic pop
+Codec CreateVideoCodec(const std::string& name) {
+ return CreateVideoCodec(0, name);
}
-VideoCodec CreateVideoCodec(int id, const std::string& name) {
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
- return VideoCodec(id, name);
-#pragma clang diagnostic pop
+Codec CreateVideoCodec(int id, const std::string& name) {
+ Codec c(Codec::Type::kVideo, id, name, kVideoCodecClockrate);
+ if (absl::EqualsIgnoreCase(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");
+ }
+ return c;
}
-VideoCodec CreateVideoCodec(const webrtc::SdpVideoFormat& c) {
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
- return VideoCodec(c);
-#pragma clang diagnostic pop
+Codec CreateVideoCodec(const webrtc::SdpVideoFormat& c) {
+ return Codec(c);
}
} // namespace cricket
diff --git a/media/base/codec.h b/media/base/codec.h
index 34f4506..1ca0931 100644
--- a/media/base/codec.h
+++ b/media/base/codec.h
@@ -38,6 +38,7 @@
: id_(id), param_(kParamValueEmpty) {}
bool operator==(const FeedbackParam& other) const;
+ bool operator!=(const FeedbackParam& c) const { return !(*this == c); }
const std::string& id() const { return id_; }
const std::string& param() const { return param_; }
@@ -52,6 +53,7 @@
FeedbackParams();
~FeedbackParams();
bool operator==(const FeedbackParams& other) const;
+ bool operator!=(const FeedbackParams& c) const { return !(*this == c); }
bool Has(const FeedbackParam& param) const;
void Add(const FeedbackParam& param);
@@ -163,71 +165,34 @@
const std::string& name,
int clockrate,
size_t channels);
+
explicit Codec(const webrtc::SdpVideoFormat& c);
+
+ friend Codec CreateAudioCodec(int id,
+ const std::string& name,
+ int clockrate,
+ size_t channels);
+ friend Codec CreateAudioRtxCodec(int rtx_payload_type,
+ int associated_payload_type);
+ friend Codec CreateVideoCodec(int id, const std::string& name);
+ friend Codec CreateVideoCodec(const webrtc::SdpVideoFormat& c);
+ friend Codec CreateVideoRtxCodec(int rtx_payload_type,
+ int associated_payload_type);
};
-struct AudioCodec : public Codec {
- // Creates a codec with the given parameters.
- [[deprecated("Use cricket::CreateAudioCodec")]] AudioCodec(
- int id,
- const std::string& name,
- int clockrate,
- int unused_bitrate,
- size_t channels);
- // Creates an empty codec.
- [[deprecated("Do not create empty AudioCodec")]] AudioCodec();
- AudioCodec(const AudioCodec& c);
- AudioCodec(AudioCodec&& c);
- ~AudioCodec() override = default;
+// TODO(webrtc:15214): Compatibility names, to be migrated away and removed.
+using VideoCodec = Codec;
+using AudioCodec = Codec;
- AudioCodec& operator=(const AudioCodec& c);
- AudioCodec& operator=(AudioCodec&& c);
-};
-
-struct RTC_EXPORT VideoCodec : public Codec {
- // Creates a codec with the given parameters.
- [[deprecated("Use cricket::CreateVideoCodec")]] VideoCodec(
- int id,
- const std::string& name);
- // Creates a codec with the given name and empty id.
- [[deprecated("Use cricket::CreateVideoCodec")]] explicit VideoCodec(
- const std::string& name);
- // Creates an empty codec.
- [[deprecated("Do not create empty VideoCodec")]] VideoCodec();
- VideoCodec(const VideoCodec& c);
- [[deprecated]] explicit VideoCodec(const webrtc::SdpVideoFormat& c);
- VideoCodec(VideoCodec&& c);
- ~VideoCodec() override = default;
-
- VideoCodec& operator=(const VideoCodec& c);
- VideoCodec& operator=(VideoCodec&& c);
-
- [[deprecated]] static VideoCodec CreateRtxCodec(int rtx_payload_type,
- int associated_payload_type);
-
- enum [[deprecated]] CodecType {
- CODEC_VIDEO,
- CODEC_RED,
- CODEC_ULPFEC,
- CODEC_FLEXFEC,
- CODEC_RTX,
- };
-
- [[deprecated]] CodecType GetCodecType() const;
-
- private:
- void SetDefaultParameters();
-};
-
-AudioCodec CreateAudioCodec(int id,
- const std::string& name,
- int clockrate,
- size_t channels);
-VideoCodec CreateVideoCodec(const std::string& name);
-VideoCodec CreateVideoCodec(int id, const std::string& name);
-VideoCodec CreateVideoCodec(const webrtc::SdpVideoFormat& c);
-VideoCodec CreateVideoRtxCodec(int rtx_payload_type,
- int associated_payload_type);
+Codec CreateAudioCodec(int id,
+ const std::string& name,
+ int clockrate,
+ size_t channels);
+Codec CreateAudioRtxCodec(int rtx_payload_type, int associated_payload_type);
+Codec CreateVideoCodec(const std::string& name);
+Codec CreateVideoCodec(int id, const std::string& name);
+Codec CreateVideoCodec(const webrtc::SdpVideoFormat& c);
+Codec CreateVideoRtxCodec(int rtx_payload_type, int associated_payload_type);
// Get the codec setting associated with `payload_type`. If there
// is no codec associated with that payload type it returns nullptr.
diff --git a/media/base/codec_unittest.cc b/media/base/codec_unittest.cc
index 0d405be..eb34530 100644
--- a/media/base/codec_unittest.cc
+++ b/media/base/codec_unittest.cc
@@ -82,14 +82,8 @@
EXPECT_NE(c0, c4);
EXPECT_NE(c0, c5);
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
- AudioCodec c7;
-#pragma clang diagnostic pop
AudioCodec c8 = cricket::CreateAudioCodec(0, "", 0, 0);
AudioCodec c9 = c0;
- EXPECT_EQ(c8, c7);
- EXPECT_NE(c9, c7);
EXPECT_EQ(c9, c0);
AudioCodec c10(c0);
@@ -162,14 +156,8 @@
EXPECT_TRUE(c0 != c1);
EXPECT_TRUE(c0 != c2);
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
- VideoCodec c7;
-#pragma clang diagnostic pop
VideoCodec c8 = cricket::CreateVideoCodec(0, "");
VideoCodec c9 = c0;
- EXPECT_TRUE(c8 == c7);
- EXPECT_TRUE(c9 != c7);
EXPECT_TRUE(c9 == c0);
VideoCodec c10(c0);
diff --git a/pc/peer_connection_media_unittest.cc b/pc/peer_connection_media_unittest.cc
index dd497ba..72bd9bd 100644
--- a/pc/peer_connection_media_unittest.cc
+++ b/pc/peer_connection_media_unittest.cc
@@ -573,8 +573,7 @@
TEST_P(PeerConnectionMediaTest, RawPacketizationNotSetInOffer) {
std::vector<cricket::VideoCodec> fake_codecs;
fake_codecs.push_back(cricket::CreateVideoCodec(111, cricket::kVp8CodecName));
- fake_codecs.push_back(cricket::CreateVideoCodec(112, cricket::kRtxCodecName));
- fake_codecs.back().params[cricket::kCodecParamAssociatedPayloadType] = "111";
+ 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));
@@ -596,8 +595,7 @@
TEST_P(PeerConnectionMediaTest, RawPacketizationSetInOfferAndAnswer) {
std::vector<cricket::VideoCodec> fake_codecs;
fake_codecs.push_back(cricket::CreateVideoCodec(111, cricket::kVp8CodecName));
- fake_codecs.push_back(cricket::CreateVideoCodec(112, cricket::kRtxCodecName));
- fake_codecs.back().params[cricket::kCodecParamAssociatedPayloadType] = "111";
+ 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));
@@ -640,8 +638,7 @@
RawPacketizationNotSetInAnswerWhenNotSetInOffer) {
std::vector<cricket::VideoCodec> fake_codecs;
fake_codecs.push_back(cricket::CreateVideoCodec(111, cricket::kVp8CodecName));
- fake_codecs.push_back(cricket::CreateVideoCodec(112, cricket::kRtxCodecName));
- fake_codecs.back().params[cricket::kCodecParamAssociatedPayloadType] = "111";
+ 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));
@@ -1706,10 +1703,8 @@
SetCodecPreferencesAudioRejectsOnlyRtxRedFec) {
auto fake_engine = std::make_unique<FakeMediaEngine>();
auto audio_codecs = fake_engine->voice().send_codecs();
- audio_codecs.push_back(cricket::CreateAudioCodec(
- audio_codecs.back().id + 1, cricket::kRtxCodecName, 0, 1));
- audio_codecs.back().params[cricket::kCodecParamAssociatedPayloadType] =
- std::to_string(audio_codecs.back().id - 1);
+ 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(
@@ -1803,10 +1798,8 @@
SetCodecPreferencesVideoRejectsOnlyRtxRedFec) {
auto fake_engine = std::make_unique<FakeMediaEngine>();
auto video_codecs = fake_engine->video().send_codecs();
- video_codecs.push_back(cricket::CreateVideoCodec(video_codecs.back().id + 1,
- cricket::kRtxCodecName));
- video_codecs.back().params[cricket::kCodecParamAssociatedPayloadType] =
- std::to_string(video_codecs.back().id - 1);
+ 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,
@@ -1913,16 +1906,12 @@
auto caller_video_codecs = caller_fake_engine->video().send_codecs();
caller_video_codecs.push_back(cricket::CreateVideoCodec(
caller_video_codecs.back().id + 1, cricket::kVp8CodecName));
- caller_video_codecs.push_back(cricket::CreateVideoCodec(
- caller_video_codecs.back().id + 1, cricket::kRtxCodecName));
- caller_video_codecs.back().params[cricket::kCodecParamAssociatedPayloadType] =
- std::to_string(caller_video_codecs.back().id - 1);
+ caller_video_codecs.push_back(cricket::CreateVideoRtxCodec(
+ caller_video_codecs.back().id + 1, caller_video_codecs.back().id));
caller_video_codecs.push_back(cricket::CreateVideoCodec(
caller_video_codecs.back().id + 1, cricket::kVp9CodecName));
- caller_video_codecs.push_back(cricket::CreateVideoCodec(
- caller_video_codecs.back().id + 1, cricket::kRtxCodecName));
- caller_video_codecs.back().params[cricket::kCodecParamAssociatedPayloadType] =
- std::to_string(caller_video_codecs.back().id - 1);
+ caller_video_codecs.push_back(cricket::CreateVideoRtxCodec(
+ caller_video_codecs.back().id + 1, caller_video_codecs.back().id));
caller_fake_engine->SetVideoCodecs(caller_video_codecs);
auto caller = CreatePeerConnectionWithVideo(std::move(caller_fake_engine));
@@ -1965,16 +1954,12 @@
auto caller_video_codecs = caller_fake_engine->video().send_codecs();
caller_video_codecs.push_back(cricket::CreateVideoCodec(
caller_video_codecs.back().id + 1, cricket::kVp8CodecName));
- caller_video_codecs.push_back(cricket::CreateVideoCodec(
- caller_video_codecs.back().id + 1, cricket::kRtxCodecName));
- caller_video_codecs.back().params[cricket::kCodecParamAssociatedPayloadType] =
- std::to_string(caller_video_codecs.back().id - 1);
+ caller_video_codecs.push_back(cricket::CreateVideoRtxCodec(
+ caller_video_codecs.back().id + 1, caller_video_codecs.back().id));
caller_video_codecs.push_back(cricket::CreateVideoCodec(
caller_video_codecs.back().id + 1, cricket::kVp9CodecName));
- caller_video_codecs.push_back(cricket::CreateVideoCodec(
- caller_video_codecs.back().id + 1, cricket::kRtxCodecName));
- caller_video_codecs.back().params[cricket::kCodecParamAssociatedPayloadType] =
- std::to_string(caller_video_codecs.back().id - 1);
+ caller_video_codecs.push_back(cricket::CreateVideoRtxCodec(
+ caller_video_codecs.back().id + 1, caller_video_codecs.back().id));
caller_fake_engine->SetVideoCodecs(caller_video_codecs);
auto callee_fake_engine = std::make_unique<FakeMediaEngine>();
@@ -2039,16 +2024,12 @@
auto caller_video_codecs = caller_fake_engine->video().send_codecs();
caller_video_codecs.push_back(cricket::CreateVideoCodec(
caller_video_codecs.back().id + 1, cricket::kVp8CodecName));
- caller_video_codecs.push_back(cricket::CreateVideoCodec(
- caller_video_codecs.back().id + 1, cricket::kRtxCodecName));
- caller_video_codecs.back().params[cricket::kCodecParamAssociatedPayloadType] =
- std::to_string(caller_video_codecs.back().id - 1);
+ caller_video_codecs.push_back(cricket::CreateVideoRtxCodec(
+ caller_video_codecs.back().id + 1, caller_video_codecs.back().id));
caller_video_codecs.push_back(cricket::CreateVideoCodec(
caller_video_codecs.back().id + 1, cricket::kVp9CodecName));
- caller_video_codecs.push_back(cricket::CreateVideoCodec(
- caller_video_codecs.back().id + 1, cricket::kRtxCodecName));
- caller_video_codecs.back().params[cricket::kCodecParamAssociatedPayloadType] =
- std::to_string(caller_video_codecs.back().id - 1);
+ caller_video_codecs.push_back(cricket::CreateVideoRtxCodec(
+ caller_video_codecs.back().id + 1, caller_video_codecs.back().id));
caller_fake_engine->SetVideoCodecs(caller_video_codecs);
auto callee_fake_engine = std::make_unique<FakeMediaEngine>();
@@ -2130,15 +2111,13 @@
auto fake_engine = std::make_unique<cricket::FakeMediaEngine>();
std::vector<cricket::AudioCodec> audio_codecs;
- audio_codecs.emplace_back(100, "foo", 0, 0, 1);
- audio_codecs.emplace_back(101, cricket::kRtxCodecName, 0, 0, 1);
- audio_codecs.back().params[cricket::kCodecParamAssociatedPayloadType] = "100";
+ audio_codecs.emplace_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
+ audio_codecs.emplace_back(cricket::CreateAudioRtxCodec(101, 100));
fake_engine->SetAudioCodecs(audio_codecs);
std::vector<cricket::VideoCodec> video_codecs;
- video_codecs.emplace_back(100, "bar");
- video_codecs.emplace_back(101, cricket::kRtxCodecName);
- video_codecs.back().params[cricket::kCodecParamAssociatedPayloadType] = "100";
+ video_codecs.emplace_back(cricket::CreateVideoCodec(100, "bar"));
+ video_codecs.emplace_back(cricket::CreateVideoRtxCodec(101, 100));
fake_engine->SetVideoCodecs(video_codecs);
auto caller = CreatePeerConnectionWithAudioVideo(std::move(fake_engine));
@@ -2173,15 +2152,13 @@
auto fake_engine = std::make_unique<cricket::FakeMediaEngine>();
std::vector<cricket::AudioCodec> audio_codecs;
- audio_codecs.emplace_back(100, "foo", 0, 0, 1);
- audio_codecs.emplace_back(101, cricket::kRtxCodecName, 0, 0, 1);
- audio_codecs.back().params[cricket::kCodecParamAssociatedPayloadType] = "100";
+ audio_codecs.emplace_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
+ audio_codecs.emplace_back(cricket::CreateAudioRtxCodec(101, 100));
fake_engine->SetAudioCodecs(audio_codecs);
std::vector<cricket::VideoCodec> video_codecs;
- video_codecs.emplace_back(100, "bar");
- video_codecs.emplace_back(101, cricket::kRtxCodecName);
- video_codecs.back().params[cricket::kCodecParamAssociatedPayloadType] = "100";
+ video_codecs.emplace_back(cricket::CreateVideoCodec(100, "bar"));
+ video_codecs.emplace_back(cricket::CreateVideoRtxCodec(101, 100));
fake_engine->SetVideoCodecs(video_codecs);
auto caller = CreatePeerConnectionWithAudioVideo(std::move(fake_engine));
@@ -2220,15 +2197,13 @@
auto fake_engine = std::make_unique<cricket::FakeMediaEngine>();
std::vector<cricket::AudioCodec> audio_codecs;
- audio_codecs.emplace_back(100, "foo", 0, 0, 1);
- audio_codecs.emplace_back(101, cricket::kRtxCodecName, 0, 0, 1);
- audio_codecs.back().params[cricket::kCodecParamAssociatedPayloadType] = "100";
+ audio_codecs.emplace_back(cricket::CreateAudioCodec(100, "foo", 0, 1));
+ audio_codecs.emplace_back(cricket::CreateAudioRtxCodec(101, 100));
fake_engine->SetAudioCodecs(audio_codecs);
std::vector<cricket::VideoCodec> video_codecs;
- video_codecs.emplace_back(100, "bar");
- video_codecs.emplace_back(101, cricket::kRtxCodecName);
- video_codecs.back().params[cricket::kCodecParamAssociatedPayloadType] = "100";
+ video_codecs.emplace_back(cricket::CreateVideoCodec(100, "bar"));
+ video_codecs.emplace_back(cricket::CreateVideoRtxCodec(101, 100));
fake_engine->SetVideoCodecs(video_codecs);
auto caller = CreatePeerConnectionWithAudioVideo(std::move(fake_engine));
diff --git a/pc/rtp_parameters_conversion.cc b/pc/rtp_parameters_conversion.cc
index fa8599c..2463cef 100644
--- a/pc/rtp_parameters_conversion.cc
+++ b/pc/rtp_parameters_conversion.cc
@@ -18,6 +18,7 @@
#include "api/array_view.h"
#include "api/media_types.h"
+#include "api/rtc_error.h"
#include "media/base/codec.h"
#include "media/base/media_constants.h"
#include "media/base/rtp_utils.h"
@@ -80,79 +81,71 @@
RTC_CHECK_NOTREACHED();
}
-template <typename C>
-static RTCErrorOr<C> ToCricketCodecTypeSpecific(
- const RtpCodecParameters& codec);
+RTCErrorOr<cricket::Codec> ToCricketCodec(const RtpCodecParameters& codec) {
+ switch (codec.kind) {
+ case cricket::MEDIA_TYPE_AUDIO:
+ if (codec.kind != cricket::MEDIA_TYPE_AUDIO) {
+ LOG_AND_RETURN_ERROR(
+ RTCErrorType::INVALID_PARAMETER,
+ "Can't use video codec with audio sender or receiver.");
+ }
+ if (!codec.num_channels) {
+ LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER,
+ "Missing number of channels for audio codec.");
+ }
+ if (*codec.num_channels <= 0) {
+ LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_RANGE,
+ "Number of channels must be positive.");
+ }
+ if (!codec.clock_rate) {
+ LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER,
+ "Missing codec clock rate.");
+ }
+ if (*codec.clock_rate <= 0) {
+ LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_RANGE,
+ "Clock rate must be positive.");
+ }
+ break;
+ case cricket::MEDIA_TYPE_VIDEO:
+ if (codec.kind != cricket::MEDIA_TYPE_VIDEO) {
+ LOG_AND_RETURN_ERROR(
+ RTCErrorType::INVALID_PARAMETER,
+ "Can't use audio codec with video sender or receiver.");
+ }
+ if (codec.num_channels) {
+ LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER,
+ "Video codec shouldn't have num_channels.");
+ }
+ if (!codec.clock_rate) {
+ LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER,
+ "Missing codec clock rate.");
+ }
+ if (*codec.clock_rate != cricket::kVideoCodecClockrate) {
+ LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER,
+ "Video clock rate must be 90000.");
+ }
+ break;
+ default:
+ LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER,
+ "Unknown codec type");
+ }
-template <>
-RTCErrorOr<cricket::AudioCodec> ToCricketCodecTypeSpecific<cricket::AudioCodec>(
- const RtpCodecParameters& codec) {
- if (codec.kind != cricket::MEDIA_TYPE_AUDIO) {
- LOG_AND_RETURN_ERROR(
- RTCErrorType::INVALID_PARAMETER,
- "Can't use video codec with audio sender or receiver.");
- }
- if (!codec.num_channels) {
- LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER,
- "Missing number of channels for audio codec.");
- }
- if (*codec.num_channels <= 0) {
- LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_RANGE,
- "Number of channels must be positive.");
- }
- if (!codec.clock_rate) {
- LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER,
- "Missing codec clock rate.");
- }
- if (*codec.clock_rate <= 0) {
- LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_RANGE,
- "Clock rate must be positive.");
- }
- return cricket::CreateAudioCodec(0, codec.name, *codec.clock_rate,
- *codec.num_channels);
-}
-
-// Video codecs don't use num_channels or clock_rate, but they should at least
-// be validated to ensure the application isn't trying to do something it
-// doesn't intend to.
-template <>
-RTCErrorOr<cricket::VideoCodec> ToCricketCodecTypeSpecific<cricket::VideoCodec>(
- const RtpCodecParameters& codec) {
- if (codec.kind != cricket::MEDIA_TYPE_VIDEO) {
- LOG_AND_RETURN_ERROR(
- RTCErrorType::INVALID_PARAMETER,
- "Can't use audio codec with video sender or receiver.");
- }
- if (codec.num_channels) {
- LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER,
- "Video codec shouldn't have num_channels.");
- }
- if (!codec.clock_rate) {
- LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER,
- "Missing codec clock rate.");
- }
- if (*codec.clock_rate != cricket::kVideoCodecClockrate) {
- LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_PARAMETER,
- "Video clock rate must be 90000.");
- }
- return cricket::CreateVideoCodec(0, codec.name);
-}
-
-template <typename C>
-RTCErrorOr<C> ToCricketCodec(const RtpCodecParameters& codec) {
- // Start with audio/video specific conversion.
- RTCErrorOr<C> result = ToCricketCodecTypeSpecific<C>(codec);
- if (!result.ok()) {
- return result.MoveError();
- }
- C cricket_codec = result.MoveValue();
if (!cricket::IsValidRtpPayloadType(codec.payload_type)) {
char buf[40];
rtc::SimpleStringBuilder sb(buf);
sb << "Invalid payload type: " << codec.payload_type;
LOG_AND_RETURN_ERROR(RTCErrorType::INVALID_RANGE, sb.str());
}
- cricket_codec.id = codec.payload_type;
+
+ cricket::Codec cricket_codec = [&]() {
+ if (codec.kind == cricket::MEDIA_TYPE_AUDIO) {
+ return cricket::CreateAudioCodec(codec.payload_type, codec.name,
+ *codec.clock_rate, *codec.num_channels);
+ }
+ RTC_DCHECK(codec.kind == cricket::MEDIA_TYPE_VIDEO);
+ return cricket::CreateVideoCodec(codec.payload_type, codec.name);
+ }();
+
for (const RtcpFeedback& feedback : codec.rtcp_feedback) {
auto result = ToCricketFeedbackParam(feedback);
if (!result.ok()) {
@@ -164,18 +157,12 @@
return std::move(cricket_codec);
}
-template RTCErrorOr<cricket::AudioCodec> ToCricketCodec(
- const RtpCodecParameters& codec);
-template RTCErrorOr<cricket::VideoCodec> ToCricketCodec(
- const RtpCodecParameters& codec);
-
-template <typename C>
-RTCErrorOr<std::vector<C>> ToCricketCodecs(
+RTCErrorOr<std::vector<cricket::Codec>> ToCricketCodecs(
const std::vector<RtpCodecParameters>& codecs) {
- std::vector<C> cricket_codecs;
+ std::vector<cricket::Codec> cricket_codecs;
std::set<int> seen_payload_types;
for (const RtpCodecParameters& codec : codecs) {
- auto result = ToCricketCodec<C>(codec);
+ auto result = ToCricketCodec(codec);
if (!result.ok()) {
return result.MoveError();
}
@@ -190,12 +177,6 @@
return std::move(cricket_codecs);
}
-template RTCErrorOr<std::vector<cricket::AudioCodec>> ToCricketCodecs<
- cricket::AudioCodec>(const std::vector<RtpCodecParameters>& codecs);
-
-template RTCErrorOr<std::vector<cricket::VideoCodec>> ToCricketCodecs<
- cricket::VideoCodec>(const std::vector<RtpCodecParameters>& codecs);
-
RTCErrorOr<cricket::StreamParamsVec> ToCricketStreamParamsVec(
const std::vector<RtpEncodingParameters>& encodings) {
if (encodings.size() > 1u) {
@@ -278,51 +259,12 @@
return rtp_encodings;
}
-template <typename C>
-cricket::MediaType KindOfCodec();
-
-template <>
-cricket::MediaType KindOfCodec<cricket::AudioCodec>() {
- return cricket::MEDIA_TYPE_AUDIO;
-}
-
-template <>
-cricket::MediaType KindOfCodec<cricket::VideoCodec>() {
- return cricket::MEDIA_TYPE_VIDEO;
-}
-
-template <typename C>
-static void ToRtpCodecCapabilityTypeSpecific(const C& cricket_codec,
- RtpCodecCapability* codec);
-
-template <>
-void ToRtpCodecCapabilityTypeSpecific<cricket::AudioCodec>(
- const cricket::AudioCodec& cricket_codec,
- RtpCodecCapability* codec) {
- codec->num_channels = static_cast<int>(cricket_codec.channels);
-}
-
-template <>
-void ToRtpCodecCapabilityTypeSpecific<cricket::VideoCodec>(
- const cricket::VideoCodec& cricket_codec,
- RtpCodecCapability* codec) {
- if (cricket_codec.scalability_modes.empty() ||
- (cricket_codec.scalability_modes.size() == 1 &&
- cricket_codec.scalability_modes[0] == ScalabilityMode::kL1T1)) {
- // https://w3c.github.io/webrtc-svc/#dom-rtcrtpcodeccapability-scalabilitymodes
- // If a codec does not support encoding of scalability modes other than
- // "L1T1", then the scalabilityModes member is not provided.
- return;
- }
-
- codec->scalability_modes = cricket_codec.scalability_modes;
-}
-
-template <typename C>
-RtpCodecCapability ToRtpCodecCapability(const C& cricket_codec) {
+RtpCodecCapability ToRtpCodecCapability(const cricket::Codec& cricket_codec) {
RtpCodecCapability codec;
codec.name = cricket_codec.name;
- codec.kind = KindOfCodec<C>();
+ codec.kind = cricket_codec.type == cricket::Codec::Type::kAudio
+ ? cricket::MEDIA_TYPE_AUDIO
+ : cricket::MEDIA_TYPE_VIDEO;
codec.clock_rate.emplace(cricket_codec.clockrate);
codec.preferred_payload_type.emplace(cricket_codec.id);
for (const cricket::FeedbackParam& cricket_feedback :
@@ -332,37 +274,25 @@
codec.rtcp_feedback.push_back(feedback.value());
}
}
- ToRtpCodecCapabilityTypeSpecific(cricket_codec, &codec);
+ switch (cricket_codec.type) {
+ case cricket::Codec::Type::kAudio:
+ codec.num_channels = static_cast<int>(cricket_codec.channels);
+ break;
+ case cricket::Codec::Type::kVideo:
+ codec.scalability_modes = cricket_codec.scalability_modes;
+ break;
+ }
codec.parameters.insert(cricket_codec.params.begin(),
cricket_codec.params.end());
return codec;
}
-template RtpCodecCapability ToRtpCodecCapability<cricket::AudioCodec>(
- const cricket::AudioCodec& cricket_codec);
-template RtpCodecCapability ToRtpCodecCapability<cricket::VideoCodec>(
- const cricket::VideoCodec& cricket_codec);
-
-template <typename C>
-static void ToRtpCodecParametersTypeSpecific(const C& cricket_codec,
- RtpCodecParameters* codec);
-template <>
-void ToRtpCodecParametersTypeSpecific<cricket::AudioCodec>(
- const cricket::AudioCodec& cricket_codec,
- RtpCodecParameters* codec) {
- codec->num_channels = static_cast<int>(cricket_codec.channels);
-}
-
-template <>
-void ToRtpCodecParametersTypeSpecific<cricket::VideoCodec>(
- const cricket::VideoCodec& cricket_codec,
- RtpCodecParameters* codec) {}
-
-template <typename C>
-RtpCodecParameters ToRtpCodecParameters(const C& cricket_codec) {
+RtpCodecParameters ToRtpCodecParameters(const cricket::Codec& cricket_codec) {
RtpCodecParameters codec_param;
codec_param.name = cricket_codec.name;
- codec_param.kind = KindOfCodec<C>();
+ codec_param.kind = cricket_codec.type == cricket::Codec::Type::kAudio
+ ? cricket::MEDIA_TYPE_AUDIO
+ : cricket::MEDIA_TYPE_VIDEO;
codec_param.clock_rate.emplace(cricket_codec.clockrate);
codec_param.payload_type = cricket_codec.id;
for (const cricket::FeedbackParam& cricket_feedback :
@@ -372,26 +302,27 @@
codec_param.rtcp_feedback.push_back(feedback.value());
}
}
- ToRtpCodecParametersTypeSpecific(cricket_codec, &codec_param);
+ switch (cricket_codec.type) {
+ case cricket::Codec::Type::kAudio:
+ codec_param.num_channels = static_cast<int>(cricket_codec.channels);
+ break;
+ case cricket::Codec::Type::kVideo:
+ // Nothing to do.
+ break;
+ }
codec_param.parameters = cricket_codec.params;
return codec_param;
}
-template RtpCodecParameters ToRtpCodecParameters<cricket::AudioCodec>(
- const cricket::AudioCodec& cricket_codec);
-template RtpCodecParameters ToRtpCodecParameters<cricket::VideoCodec>(
- const cricket::VideoCodec& cricket_codec);
-
-template <class C>
RtpCapabilities ToRtpCapabilities(
- const std::vector<C>& cricket_codecs,
+ const std::vector<cricket::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 C& cricket_codec : cricket_codecs) {
+ for (const cricket::Codec& cricket_codec : cricket_codecs) {
if (cricket_codec.name == cricket::kRedCodecName) {
have_red = true;
} else if (cricket_codec.name == cricket::kUlpfecCodecName) {
@@ -428,20 +359,12 @@
return capabilities;
}
-template RtpCapabilities ToRtpCapabilities<cricket::AudioCodec>(
- const std::vector<cricket::AudioCodec>& cricket_codecs,
- const cricket::RtpHeaderExtensions& cricket_extensions);
-template RtpCapabilities ToRtpCapabilities<cricket::VideoCodec>(
- const std::vector<cricket::VideoCodec>& cricket_codecs,
- const cricket::RtpHeaderExtensions& cricket_extensions);
-
-template <class C>
RtpParameters ToRtpParameters(
- const std::vector<C>& cricket_codecs,
+ const std::vector<cricket::Codec>& cricket_codecs,
const cricket::RtpHeaderExtensions& cricket_extensions,
const cricket::StreamParamsVec& stream_params) {
RtpParameters rtp_parameters;
- for (const C& cricket_codec : cricket_codecs) {
+ for (const cricket::Codec& cricket_codec : cricket_codecs) {
rtp_parameters.codecs.push_back(ToRtpCodecParameters(cricket_codec));
}
for (const RtpExtension& cricket_extension : cricket_extensions) {
@@ -452,13 +375,4 @@
return rtp_parameters;
}
-template RtpParameters ToRtpParameters<cricket::AudioCodec>(
- const std::vector<cricket::AudioCodec>& cricket_codecs,
- const cricket::RtpHeaderExtensions& cricket_extensions,
- const cricket::StreamParamsVec& stream_params);
-template RtpParameters ToRtpParameters<cricket::VideoCodec>(
- const std::vector<cricket::VideoCodec>& cricket_codecs,
- const cricket::RtpHeaderExtensions& cricket_extensions,
- const cricket::StreamParamsVec& stream_params);
-
} // namespace webrtc
diff --git a/pc/rtp_parameters_conversion.h b/pc/rtp_parameters_conversion.h
index 959f3fd..2cc39dd 100644
--- a/pc/rtp_parameters_conversion.h
+++ b/pc/rtp_parameters_conversion.h
@@ -48,13 +48,11 @@
// Verifies that the codec kind is correct, and it has mandatory parameters
// filled, with values in valid ranges.
-template <typename C>
-RTCErrorOr<C> ToCricketCodec(const RtpCodecParameters& codec);
+RTCErrorOr<cricket::Codec> ToCricketCodec(const RtpCodecParameters& codec);
// Verifies that payload types aren't duplicated, in addition to normal
// validation.
-template <typename C>
-RTCErrorOr<std::vector<C>> ToCricketCodecs(
+RTCErrorOr<std::vector<cricket::Codec>> ToCricketCodecs(
const std::vector<RtpCodecParameters>& codecs);
// SSRCs are allowed to be ommitted. This may be used for receive parameters
@@ -82,20 +80,15 @@
std::vector<RtpEncodingParameters> ToRtpEncodings(
const cricket::StreamParamsVec& stream_params);
-template <typename C>
-RtpCodecParameters ToRtpCodecParameters(const C& cricket_codec);
+RtpCodecParameters ToRtpCodecParameters(const cricket::Codec& cricket_codec);
+RtpCodecCapability ToRtpCodecCapability(const cricket::Codec& cricket_codec);
-template <typename C>
-RtpCodecCapability ToRtpCodecCapability(const C& cricket_codec);
-
-template <class C>
RtpCapabilities ToRtpCapabilities(
- const std::vector<C>& cricket_codecs,
+ const std::vector<cricket::Codec>& cricket_codecs,
const cricket::RtpHeaderExtensions& cricket_extensions);
-template <class C>
RtpParameters ToRtpParameters(
- const std::vector<C>& cricket_codecs,
+ const std::vector<cricket::Codec>& cricket_codecs,
const cricket::RtpHeaderExtensions& cricket_extensions,
const cricket::StreamParamsVec& stream_params);
diff --git a/pc/rtp_parameters_conversion_unittest.cc b/pc/rtp_parameters_conversion_unittest.cc
index b1e6323..9b48bfa 100644
--- a/pc/rtp_parameters_conversion_unittest.cc
+++ b/pc/rtp_parameters_conversion_unittest.cc
@@ -88,7 +88,7 @@
codec.num_channels.emplace(6);
codec.parameters["foo"] = "bar";
codec.rtcp_feedback.emplace_back(RtcpFeedbackType::TRANSPORT_CC);
- auto result = ToCricketCodec<cricket::AudioCodec>(codec);
+ auto result = ToCricketCodec(codec);
ASSERT_TRUE(result.ok());
EXPECT_EQ("AuDiO", result.value().name);
@@ -114,7 +114,7 @@
codec.rtcp_feedback.emplace_back(RtcpFeedbackType::TRANSPORT_CC);
codec.rtcp_feedback.emplace_back(RtcpFeedbackType::NACK,
RtcpFeedbackMessageType::PLI);
- auto result = ToCricketCodec<cricket::VideoCodec>(codec);
+ auto result = ToCricketCodec(codec);
ASSERT_TRUE(result.ok());
EXPECT_EQ("coolcodec", result.value().name);
@@ -147,18 +147,18 @@
video_codec.payload_type = 102;
video_codec.clock_rate.emplace(90000);
- auto audio_result = ToCricketCodec<cricket::AudioCodec>(audio_codec);
+ auto audio_result = ToCricketCodec(audio_codec);
EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, audio_result.error().type());
- auto video_result = ToCricketCodec<cricket::VideoCodec>(video_codec);
+ auto video_result = ToCricketCodec(video_codec);
EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, video_result.error().type());
// Sanity check that if the kind is correct, the conversion succeeds.
audio_codec.kind = cricket::MEDIA_TYPE_AUDIO;
video_codec.kind = cricket::MEDIA_TYPE_VIDEO;
- audio_result = ToCricketCodec<cricket::AudioCodec>(audio_codec);
+ audio_result = ToCricketCodec(audio_codec);
EXPECT_TRUE(audio_result.ok());
- video_result = ToCricketCodec<cricket::VideoCodec>(video_codec);
+ video_result = ToCricketCodec(video_codec);
EXPECT_TRUE(video_result.ok());
}
@@ -169,28 +169,28 @@
codec.kind = cricket::MEDIA_TYPE_AUDIO;
codec.payload_type = 111;
codec.clock_rate.emplace(48000);
- auto result = ToCricketCodec<cricket::AudioCodec>(codec);
+ auto result = ToCricketCodec(codec);
EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type());
// Negative number of channels.
codec.num_channels.emplace(-1);
- result = ToCricketCodec<cricket::AudioCodec>(codec);
+ result = ToCricketCodec(codec);
EXPECT_EQ(RTCErrorType::INVALID_RANGE, result.error().type());
// Missing clock rate.
codec.num_channels.emplace(2);
codec.clock_rate.reset();
- result = ToCricketCodec<cricket::AudioCodec>(codec);
+ result = ToCricketCodec(codec);
EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type());
// Negative clock rate.
codec.clock_rate.emplace(-48000);
- result = ToCricketCodec<cricket::AudioCodec>(codec);
+ result = ToCricketCodec(codec);
EXPECT_EQ(RTCErrorType::INVALID_RANGE, result.error().type());
// Sanity check that conversion succeeds if these errors are fixed.
codec.clock_rate.emplace(48000);
- result = ToCricketCodec<cricket::AudioCodec>(codec);
+ result = ToCricketCodec(codec);
EXPECT_TRUE(result.ok());
}
@@ -200,23 +200,23 @@
codec.name = "VP8";
codec.kind = cricket::MEDIA_TYPE_VIDEO;
codec.payload_type = 102;
- auto result = ToCricketCodec<cricket::VideoCodec>(codec);
+ auto result = ToCricketCodec(codec);
EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type());
// Invalid clock rate.
codec.clock_rate.emplace(48000);
- result = ToCricketCodec<cricket::VideoCodec>(codec);
+ result = ToCricketCodec(codec);
EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type());
// Channels set (should be unset).
codec.clock_rate.emplace(90000);
codec.num_channels.emplace(2);
- result = ToCricketCodec<cricket::VideoCodec>(codec);
+ result = ToCricketCodec(codec);
EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type());
// Sanity check that conversion succeeds if these errors are fixed.
codec.num_channels.reset();
- result = ToCricketCodec<cricket::VideoCodec>(codec);
+ result = ToCricketCodec(codec);
EXPECT_TRUE(result.ok());
}
@@ -227,17 +227,17 @@
codec.clock_rate.emplace(90000);
codec.payload_type = -1000;
- auto result = ToCricketCodec<cricket::VideoCodec>(codec);
+ auto result = ToCricketCodec(codec);
EXPECT_EQ(RTCErrorType::INVALID_RANGE, result.error().type());
// Max payload type is 127.
codec.payload_type = 128;
- result = ToCricketCodec<cricket::VideoCodec>(codec);
+ result = ToCricketCodec(codec);
EXPECT_EQ(RTCErrorType::INVALID_RANGE, result.error().type());
// Sanity check that conversion succeeds with a valid payload type.
codec.payload_type = 127;
- result = ToCricketCodec<cricket::VideoCodec>(codec);
+ result = ToCricketCodec(codec);
EXPECT_TRUE(result.ok());
}
@@ -252,12 +252,12 @@
codec.rtcp_feedback.emplace_back(RtcpFeedbackType::CCM,
RtcpFeedbackMessageType::PLI);
- auto result = ToCricketCodec<cricket::VideoCodec>(codec);
+ auto result = ToCricketCodec(codec);
EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type());
// Sanity check that conversion succeeds without invalid feedback.
codec.rtcp_feedback.clear();
- result = ToCricketCodec<cricket::VideoCodec>(codec);
+ result = ToCricketCodec(codec);
EXPECT_TRUE(result.ok());
}
@@ -274,7 +274,7 @@
codec.payload_type = 100;
codecs.push_back(codec);
- auto result = ToCricketCodecs<cricket::VideoCodec>(codecs);
+ auto result = ToCricketCodecs(codecs);
ASSERT_TRUE(result.ok());
ASSERT_EQ(2u, result.value().size());
EXPECT_EQ("VP8", result.value()[0].name);
@@ -296,12 +296,12 @@
codec.payload_type = 99;
codecs.push_back(codec);
- auto result = ToCricketCodecs<cricket::VideoCodec>(codecs);
+ auto result = ToCricketCodecs(codecs);
EXPECT_EQ(RTCErrorType::INVALID_PARAMETER, result.error().type());
// Sanity check that this succeeds without the duplicate payload type.
codecs[1].payload_type = 120;
- result = ToCricketCodecs<cricket::VideoCodec>(codecs);
+ result = ToCricketCodecs(codecs);
EXPECT_TRUE(result.ok());
}
@@ -541,8 +541,8 @@
cricket::VideoCodec rtx2 = cricket::CreateVideoRtxCodec(105, 109);
- RtpCapabilities capabilities = ToRtpCapabilities<cricket::VideoCodec>(
- {vp8, ulpfec, rtx, rtx2}, {{"uri", 1}, {"uri2", 3}});
+ RtpCapabilities capabilities =
+ ToRtpCapabilities({vp8, ulpfec, rtx, rtx2}, {{"uri", 1}, {"uri2", 3}});
ASSERT_EQ(3u, capabilities.codecs.size());
EXPECT_EQ("VP8", capabilities.codecs[0].name);
EXPECT_EQ("ulpfec", capabilities.codecs[1].name);
@@ -555,15 +555,15 @@
EXPECT_EQ(3, capabilities.header_extensions[1].preferred_id);
EXPECT_EQ(0u, capabilities.fec.size());
- capabilities = ToRtpCapabilities<cricket::VideoCodec>(
- {vp8, red, ulpfec, rtx}, cricket::RtpHeaderExtensions());
+ capabilities = ToRtpCapabilities({vp8, red, ulpfec, rtx},
+ cricket::RtpHeaderExtensions());
EXPECT_EQ(4u, capabilities.codecs.size());
EXPECT_THAT(
capabilities.fec,
UnorderedElementsAre(FecMechanism::RED, FecMechanism::RED_AND_ULPFEC));
- capabilities = ToRtpCapabilities<cricket::VideoCodec>(
- {vp8, red, flexfec}, cricket::RtpHeaderExtensions());
+ capabilities =
+ ToRtpCapabilities({vp8, red, flexfec}, cricket::RtpHeaderExtensions());
EXPECT_EQ(3u, capabilities.codecs.size());
EXPECT_THAT(capabilities.fec,
UnorderedElementsAre(FecMechanism::RED, FecMechanism::FLEXFEC));
@@ -584,8 +584,8 @@
stream.ssrcs.push_back(1234u);
streams.push_back(stream);
- RtpParameters rtp_parameters = ToRtpParameters<cricket::VideoCodec>(
- {vp8, red, ulpfec}, {{"uri", 1}, {"uri2", 3}}, streams);
+ RtpParameters rtp_parameters =
+ ToRtpParameters({vp8, red, ulpfec}, {{"uri", 1}, {"uri2", 3}}, streams);
ASSERT_EQ(3u, rtp_parameters.codecs.size());
EXPECT_EQ("VP8", rtp_parameters.codecs[0].name);
EXPECT_EQ("red", rtp_parameters.codecs[1].name);
diff --git a/pc/webrtc_sdp.cc b/pc/webrtc_sdp.cc
index 467b8c2..1e2f319 100644
--- a/pc/webrtc_sdp.cc
+++ b/pc/webrtc_sdp.cc
@@ -2897,14 +2897,16 @@
// is no Codec associated with that payload type it returns an empty codec
// with that payload type.
template <class T>
-T GetCodecWithPayloadType(const std::vector<T>& codecs, int payload_type) {
+T GetCodecWithPayloadType(cricket::MediaType type,
+ const std::vector<T>& codecs,
+ int payload_type) {
const T* codec = FindCodecById(codecs, payload_type);
if (codec)
return *codec;
// Return empty codec with `payload_type`.
- if constexpr (std::is_same<T, cricket::AudioCodec>::value) {
+ if (type == cricket::MEDIA_TYPE_AUDIO) {
return cricket::CreateAudioCodec(payload_type, "", 0, 0);
- } else if constexpr (std::is_same<T, cricket::VideoCodec>::value) {
+ } else {
return cricket::CreateVideoCodec(payload_type, "");
}
}
@@ -2937,7 +2939,8 @@
int payload_type,
const cricket::CodecParameterMap& parameters) {
// Codec might already have been populated (from rtpmap).
- U new_codec = GetCodecWithPayloadType(static_cast<T*>(content_desc)->codecs(),
+ U new_codec = GetCodecWithPayloadType(content_desc->type(),
+ static_cast<T*>(content_desc)->codecs(),
payload_type);
AddParameters(parameters, &new_codec);
AddOrReplaceCodec<T, U>(content_desc, new_codec);
@@ -2950,7 +2953,8 @@
int payload_type,
const cricket::FeedbackParam& feedback_param) {
// Codec might already have been populated (from rtpmap).
- U new_codec = GetCodecWithPayloadType(static_cast<T*>(content_desc)->codecs(),
+ U new_codec = GetCodecWithPayloadType(content_desc->type(),
+ static_cast<T*>(content_desc)->codecs(),
payload_type);
AddFeedbackParameter(feedback_param, &new_codec);
AddOrReplaceCodec<T, U>(content_desc, new_codec);
@@ -2967,8 +2971,8 @@
}
// Codec might already have been populated (from rtpmap).
- cricket::VideoCodec codec =
- GetCodecWithPayloadType(video_desc->codecs(), payload_type);
+ cricket::VideoCodec codec = GetCodecWithPayloadType(
+ video_desc->type(), video_desc->codecs(), payload_type);
codec.packetization = std::string(packetization);
AddOrReplaceCodec<VideoContentDescription, cricket::VideoCodec>(video_desc,
codec);
@@ -3592,8 +3596,8 @@
AudioContentDescription* audio_desc) {
// Codec may already be populated with (only) optional parameters
// (from an fmtp).
- cricket::AudioCodec codec =
- GetCodecWithPayloadType(audio_desc->codecs(), payload_type);
+ cricket::AudioCodec codec = GetCodecWithPayloadType(
+ audio_desc->type(), audio_desc->codecs(), payload_type);
codec.name = std::string(name);
codec.clockrate = clockrate;
codec.bitrate = bitrate;
@@ -3609,8 +3613,8 @@
VideoContentDescription* video_desc) {
// Codec may already be populated with (only) optional parameters
// (from an fmtp).
- cricket::VideoCodec codec =
- GetCodecWithPayloadType(video_desc->codecs(), payload_type);
+ cricket::VideoCodec codec = GetCodecWithPayloadType(
+ video_desc->type(), video_desc->codecs(), payload_type);
codec.name = std::string(name);
AddOrReplaceCodec<VideoContentDescription, cricket::VideoCodec>(video_desc,
codec);
