Reland "Distinguish between send and receive codecs"
This reverts commit 8e8b36a94a7a7a1fd0f8093979a406afa56e18c1.
Reason for revert: The CL has been improved with the following changes,
- Fixed negotiation of send/receive only clients.
- Handles the implicit assumption that any H264 decoder also can
decode H264 constraint baseline.
Original change's description:
> Distinguish between send and receive codecs
>
> Even though send and receive codecs may be the same, they might have
> different support in HW. Distinguish between send and receive codecs
> to be able to keep track of which codecs have HW support.
>
> Bug: chromium:1029737
> Change-Id: Id119560becadfe0aaf861c892a6485f1c2eb378d
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/165763
> Commit-Queue: Johannes Kron <kron@webrtc.org>
> Reviewed-by: Steve Anton <steveanton@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#30284}
Change-Id: I834ed48ee78d04922c73e2836165e476925e1cc5
Bug: chromium:1029737
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/168605
Commit-Queue: Johannes Kron <kron@webrtc.org>
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Reviewed-by: Johannes Kron <kron@webrtc.org>
Reviewed-by: Henrik Boström <hbos@webrtc.org>
Reviewed-by: Sergey Silkin <ssilkin@webrtc.org>
Reviewed-by: Steve Anton <steveanton@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#30932}
diff --git a/api/test/video/function_video_decoder_factory.h b/api/test/video/function_video_decoder_factory.h
index 03a4323..86abdd0 100644
--- a/api/test/video/function_video_decoder_factory.h
+++ b/api/test/video/function_video_decoder_factory.h
@@ -28,16 +28,23 @@
public:
explicit FunctionVideoDecoderFactory(
std::function<std::unique_ptr<VideoDecoder>()> create)
- : create_([create](const SdpVideoFormat&) { return create(); }) {}
+ : create_([create = std::move(create)](const SdpVideoFormat&) {
+ return create();
+ }) {}
explicit FunctionVideoDecoderFactory(
std::function<std::unique_ptr<VideoDecoder>(const SdpVideoFormat&)>
create)
: create_(std::move(create)) {}
+ FunctionVideoDecoderFactory(
+ std::function<std::unique_ptr<VideoDecoder>()> create,
+ std::vector<SdpVideoFormat> sdp_video_formats)
+ : create_([create = std::move(create)](const SdpVideoFormat&) {
+ return create();
+ }),
+ sdp_video_formats_(std::move(sdp_video_formats)) {}
- // Unused by tests.
std::vector<SdpVideoFormat> GetSupportedFormats() const override {
- RTC_NOTREACHED();
- return {};
+ return sdp_video_formats_;
}
std::unique_ptr<VideoDecoder> CreateVideoDecoder(
@@ -48,6 +55,7 @@
private:
const std::function<std::unique_ptr<VideoDecoder>(const SdpVideoFormat&)>
create_;
+ const std::vector<SdpVideoFormat> sdp_video_formats_;
};
} // namespace test
diff --git a/api/test/video/function_video_encoder_factory.h b/api/test/video/function_video_encoder_factory.h
index 85f848c..40a187a 100644
--- a/api/test/video/function_video_encoder_factory.h
+++ b/api/test/video/function_video_encoder_factory.h
@@ -29,7 +29,9 @@
public:
explicit FunctionVideoEncoderFactory(
std::function<std::unique_ptr<VideoEncoder>()> create)
- : create_([create](const SdpVideoFormat&) { return create(); }) {}
+ : create_([create = std::move(create)](const SdpVideoFormat&) {
+ return create();
+ }) {}
explicit FunctionVideoEncoderFactory(
std::function<std::unique_ptr<VideoEncoder>(const SdpVideoFormat&)>
create)
diff --git a/media/BUILD.gn b/media/BUILD.gn
index 7e116cb..7053780 100644
--- a/media/BUILD.gn
+++ b/media/BUILD.gn
@@ -566,6 +566,7 @@
"../audio",
"../call:call_interfaces",
"../common_video",
+ "../media:rtc_h264_profile_id",
"../modules/audio_device:mock_audio_device",
"../modules/audio_processing",
"../modules/audio_processing:api",
@@ -573,6 +574,7 @@
"../modules/rtp_rtcp",
"../modules/video_coding:simulcast_test_fixture_impl",
"../modules/video_coding:video_codec_interface",
+ "../modules/video_coding:webrtc_h264",
"../modules/video_coding:webrtc_vp8",
"../modules/video_coding/codecs/av1:libaom_av1_decoder",
"../p2p:p2p_test_utils",
diff --git a/media/base/codec.cc b/media/base/codec.cc
index 168e7a7..6b9a052 100644
--- a/media/base/codec.cc
+++ b/media/base/codec.cc
@@ -57,6 +57,18 @@
return true;
}
+bool IsCodecInList(
+ const webrtc::SdpVideoFormat& format,
+ const std::vector<webrtc::SdpVideoFormat>& existing_formats) {
+ for (auto existing_format : existing_formats) {
+ if (IsSameCodec(format.name, format.parameters, existing_format.name,
+ existing_format.parameters)) {
+ return true;
+ }
+ }
+ return false;
+}
+
} // namespace
FeedbackParams::FeedbackParams() = default;
@@ -423,4 +435,43 @@
IsSameCodecSpecific(name1, params1, name2, params2);
}
+// If a decoder supports any H264 profile, it is implicitly assumed to also
+// support constrained base line even though it's not explicitly listed.
+void AddH264ConstrainedBaselineProfileToSupportedFormats(
+ std::vector<webrtc::SdpVideoFormat>* supported_formats) {
+ std::vector<webrtc::SdpVideoFormat> cbr_supported_formats;
+
+ // For any H264 supported profile, add the corresponding constrained baseline
+ // profile.
+ for (auto it = supported_formats->cbegin(); it != supported_formats->cend();
+ ++it) {
+ if (it->name == cricket::kH264CodecName) {
+ const absl::optional<webrtc::H264::ProfileLevelId> profile_level_id =
+ webrtc::H264::ParseSdpProfileLevelId(it->parameters);
+ if (profile_level_id && profile_level_id->profile !=
+ webrtc::H264::kProfileConstrainedBaseline) {
+ webrtc::SdpVideoFormat cbp_format = *it;
+ webrtc::H264::ProfileLevelId cbp_profile = *profile_level_id;
+ cbp_profile.profile = webrtc::H264::kProfileConstrainedBaseline;
+ cbp_format.parameters[cricket::kH264FmtpProfileLevelId] =
+ *webrtc::H264::ProfileLevelIdToString(cbp_profile);
+ cbr_supported_formats.push_back(cbp_format);
+ }
+ }
+ }
+
+ size_t original_size = supported_formats->size();
+ // ...if it's not already in the list.
+ std::copy_if(cbr_supported_formats.begin(), cbr_supported_formats.end(),
+ std::back_inserter(*supported_formats),
+ [supported_formats](const webrtc::SdpVideoFormat& format) {
+ return !IsCodecInList(format, *supported_formats);
+ });
+
+ if (supported_formats->size() > original_size) {
+ RTC_LOG(LS_WARNING) << "Explicitly added H264 constrained baseline to list "
+ "of supported formats.";
+ }
+}
+
} // namespace cricket
diff --git a/media/base/codec.h b/media/base/codec.h
index f327199..fd8a97c 100644
--- a/media/base/codec.h
+++ b/media/base/codec.h
@@ -243,6 +243,9 @@
const std::string& name2,
const CodecParameterMap& params2);
+RTC_EXPORT void AddH264ConstrainedBaselineProfileToSupportedFormats(
+ std::vector<webrtc::SdpVideoFormat>* supported_formats);
+
} // namespace cricket
#endif // MEDIA_BASE_CODEC_H_
diff --git a/media/base/codec_unittest.cc b/media/base/codec_unittest.cc
index 62968e0..04130e1 100644
--- a/media/base/codec_unittest.cc
+++ b/media/base/codec_unittest.cc
@@ -12,7 +12,10 @@
#include <tuple>
+#include "common_types.h" // NOLINT(build/include)
+#include "media/base/h264_profile_level_id.h"
#include "media/base/vp9_profile.h"
+#include "modules/video_coding/codecs/h264/include/h264.h"
#include "rtc_base/gunit.h"
using cricket::AudioCodec;
@@ -438,6 +441,69 @@
EXPECT_EQ("a1", codec_params_2.parameters.begin()->second);
}
+TEST(CodecTest, H264CostrainedBaselineIsAddedIfH264IsSupported) {
+ const std::vector<webrtc::SdpVideoFormat> kExplicitlySupportedFormats = {
+ webrtc::CreateH264Format(webrtc::H264::kProfileBaseline,
+ webrtc::H264::kLevel3_1, "1"),
+ webrtc::CreateH264Format(webrtc::H264::kProfileBaseline,
+ webrtc::H264::kLevel3_1, "0")};
+
+ std::vector<webrtc::SdpVideoFormat> supported_formats =
+ kExplicitlySupportedFormats;
+ cricket::AddH264ConstrainedBaselineProfileToSupportedFormats(
+ &supported_formats);
+
+ const webrtc::SdpVideoFormat kH264ConstrainedBasedlinePacketization1 =
+ webrtc::CreateH264Format(webrtc::H264::kProfileConstrainedBaseline,
+ webrtc::H264::kLevel3_1, "1");
+ const webrtc::SdpVideoFormat kH264ConstrainedBasedlinePacketization0 =
+ webrtc::CreateH264Format(webrtc::H264::kProfileConstrainedBaseline,
+ webrtc::H264::kLevel3_1, "0");
+
+ EXPECT_EQ(supported_formats[0], kExplicitlySupportedFormats[0]);
+ EXPECT_EQ(supported_formats[1], kExplicitlySupportedFormats[1]);
+ EXPECT_EQ(supported_formats[2], kH264ConstrainedBasedlinePacketization1);
+ EXPECT_EQ(supported_formats[3], kH264ConstrainedBasedlinePacketization0);
+}
+
+TEST(CodecTest, H264CostrainedBaselineIsNotAddedIfH264IsUnsupported) {
+ const std::vector<webrtc::SdpVideoFormat> kExplicitlySupportedFormats = {
+ {cricket::kVp9CodecName,
+ {{webrtc::kVP9FmtpProfileId,
+ VP9ProfileToString(webrtc::VP9Profile::kProfile0)}}}};
+
+ std::vector<webrtc::SdpVideoFormat> supported_formats =
+ kExplicitlySupportedFormats;
+ cricket::AddH264ConstrainedBaselineProfileToSupportedFormats(
+ &supported_formats);
+
+ EXPECT_EQ(supported_formats[0], kExplicitlySupportedFormats[0]);
+ EXPECT_EQ(supported_formats.size(), kExplicitlySupportedFormats.size());
+}
+
+TEST(CodecTest, H264CostrainedBaselineNotAddedIfAlreadySpecified) {
+ const std::vector<webrtc::SdpVideoFormat> kExplicitlySupportedFormats = {
+ webrtc::CreateH264Format(webrtc::H264::kProfileBaseline,
+ webrtc::H264::kLevel3_1, "1"),
+ webrtc::CreateH264Format(webrtc::H264::kProfileBaseline,
+ webrtc::H264::kLevel3_1, "0"),
+ webrtc::CreateH264Format(webrtc::H264::kProfileConstrainedBaseline,
+ webrtc::H264::kLevel3_1, "1"),
+ webrtc::CreateH264Format(webrtc::H264::kProfileConstrainedBaseline,
+ webrtc::H264::kLevel3_1, "0")};
+
+ std::vector<webrtc::SdpVideoFormat> supported_formats =
+ kExplicitlySupportedFormats;
+ cricket::AddH264ConstrainedBaselineProfileToSupportedFormats(
+ &supported_formats);
+
+ EXPECT_EQ(supported_formats[0], kExplicitlySupportedFormats[0]);
+ EXPECT_EQ(supported_formats[1], kExplicitlySupportedFormats[1]);
+ EXPECT_EQ(supported_formats[2], kExplicitlySupportedFormats[2]);
+ EXPECT_EQ(supported_formats[3], kExplicitlySupportedFormats[3]);
+ EXPECT_EQ(supported_formats.size(), kExplicitlySupportedFormats.size());
+}
+
// Tests that the helper IsSameCodec returns the correct value for codecs that
// must also be matched on particular parameter values.
using IsSameCodecParamsTestCase =
diff --git a/media/base/fake_media_engine.cc b/media/base/fake_media_engine.cc
index e4d8917..1040757 100644
--- a/media/base/fake_media_engine.cc
+++ b/media/base/fake_media_engine.cc
@@ -575,7 +575,8 @@
: capture_(false), fail_create_channel_(false) {
// Add a fake video codec. Note that the name must not be "" as there are
// sanity checks against that.
- codecs_.push_back(VideoCodec(0, "fake_video_codec"));
+ send_codecs_.push_back(VideoCodec(0, "fake_video_codec"));
+ recv_codecs_.push_back(VideoCodec(0, "fake_video_codec"));
}
bool FakeVideoEngine::SetOptions(const VideoOptions& options) {
options_ = options;
@@ -603,12 +604,22 @@
RTC_DCHECK(it != channels_.end());
channels_.erase(it);
}
-std::vector<VideoCodec> FakeVideoEngine::codecs() const {
- return codecs_;
+std::vector<VideoCodec> FakeVideoEngine::send_codecs() const {
+ return send_codecs_;
}
-void FakeVideoEngine::SetCodecs(const std::vector<VideoCodec> codecs) {
- codecs_ = codecs;
+
+std::vector<VideoCodec> FakeVideoEngine::recv_codecs() const {
+ return recv_codecs_;
}
+
+void FakeVideoEngine::SetSendCodecs(const std::vector<VideoCodec>& codecs) {
+ send_codecs_ = codecs;
+}
+
+void FakeVideoEngine::SetRecvCodecs(const std::vector<VideoCodec>& codecs) {
+ recv_codecs_ = codecs;
+}
+
bool FakeVideoEngine::SetCapture(bool capture) {
capture_ = capture;
return true;
@@ -640,7 +651,8 @@
voice_->SetSendCodecs(codecs);
}
void FakeMediaEngine::SetVideoCodecs(const std::vector<VideoCodec>& codecs) {
- video_->SetCodecs(codecs);
+ video_->SetSendCodecs(codecs);
+ video_->SetRecvCodecs(codecs);
}
FakeVoiceMediaChannel* FakeMediaEngine::GetVoiceChannel(size_t index) {
diff --git a/media/base/fake_media_engine.h b/media/base/fake_media_engine.h
index 10dd546..338c329 100644
--- a/media/base/fake_media_engine.h
+++ b/media/base/fake_media_engine.h
@@ -563,8 +563,10 @@
override;
FakeVideoMediaChannel* GetChannel(size_t index);
void UnregisterChannel(VideoMediaChannel* channel);
- std::vector<VideoCodec> codecs() const override;
- void SetCodecs(const std::vector<VideoCodec> codecs);
+ std::vector<VideoCodec> send_codecs() const override;
+ std::vector<VideoCodec> recv_codecs() const override;
+ void SetSendCodecs(const std::vector<VideoCodec>& codecs);
+ void SetRecvCodecs(const std::vector<VideoCodec>& codecs);
bool SetCapture(bool capture);
std::vector<webrtc::RtpHeaderExtensionCapability> GetRtpHeaderExtensions()
const override;
@@ -573,7 +575,8 @@
private:
std::vector<FakeVideoMediaChannel*> channels_;
- std::vector<VideoCodec> codecs_;
+ std::vector<VideoCodec> send_codecs_;
+ std::vector<VideoCodec> recv_codecs_;
bool capture_;
VideoOptions options_;
bool fail_create_channel_;
diff --git a/media/base/media_channel.h b/media/base/media_channel.h
index 7ca6002..c2c1b56 100644
--- a/media/base/media_channel.h
+++ b/media/base/media_channel.h
@@ -749,6 +749,10 @@
std::vector<Codec> codecs;
std::vector<webrtc::RtpExtension> extensions;
+ // For a send stream this is true if we've neogtiated a send direction,
+ // for a receive stream this is true if we've negotiated a receive direction.
+ bool is_stream_active = true;
+
// TODO(pthatcher): Add streams.
RtcpParameters rtcp;
diff --git a/media/base/media_engine.h b/media/base/media_engine.h
index 713afcc..be0ae59 100644
--- a/media/base/media_engine.h
+++ b/media/base/media_engine.h
@@ -108,7 +108,8 @@
webrtc::VideoBitrateAllocatorFactory*
video_bitrate_allocator_factory) = 0;
- virtual std::vector<VideoCodec> codecs() const = 0;
+ virtual std::vector<VideoCodec> send_codecs() const = 0;
+ virtual std::vector<VideoCodec> recv_codecs() const = 0;
};
// MediaEngineInterface is an abstraction of a media engine which can be
diff --git a/media/engine/fake_webrtc_video_engine.cc b/media/engine/fake_webrtc_video_engine.cc
index 0ee2bcc..91f7e53 100644
--- a/media/engine/fake_webrtc_video_engine.cc
+++ b/media/engine/fake_webrtc_video_engine.cc
@@ -113,8 +113,11 @@
}
void FakeWebRtcVideoDecoderFactory::AddSupportedVideoCodecType(
- const webrtc::SdpVideoFormat& format) {
- supported_codec_formats_.push_back(format);
+ const std::string& name) {
+ // This is to match the default H264 params of cricket::VideoCodec.
+ cricket::VideoCodec video_codec(name);
+ supported_codec_formats_.push_back(
+ webrtc::SdpVideoFormat(video_codec.name, video_codec.params));
}
int FakeWebRtcVideoDecoderFactory::GetNumCreatedDecoders() {
diff --git a/media/engine/fake_webrtc_video_engine.h b/media/engine/fake_webrtc_video_engine.h
index 7b32ac8..28dc4fe 100644
--- a/media/engine/fake_webrtc_video_engine.h
+++ b/media/engine/fake_webrtc_video_engine.h
@@ -67,7 +67,7 @@
const webrtc::SdpVideoFormat& format) override;
void DecoderDestroyed(FakeWebRtcVideoDecoder* decoder);
- void AddSupportedVideoCodecType(const webrtc::SdpVideoFormat& format);
+ void AddSupportedVideoCodecType(const std::string& name);
int GetNumCreatedDecoders();
const std::vector<FakeWebRtcVideoDecoder*>& decoders();
diff --git a/media/engine/null_webrtc_video_engine.h b/media/engine/null_webrtc_video_engine.h
index fc556f6..a914af9 100644
--- a/media/engine/null_webrtc_video_engine.h
+++ b/media/engine/null_webrtc_video_engine.h
@@ -30,7 +30,11 @@
// CompositeMediaEngine.
class NullWebRtcVideoEngine : public VideoEngineInterface {
public:
- std::vector<VideoCodec> codecs() const override {
+ std::vector<VideoCodec> send_codecs() const override {
+ return std::vector<VideoCodec>();
+ }
+
+ std::vector<VideoCodec> recv_codecs() const override {
return std::vector<VideoCodec>();
}
diff --git a/media/engine/webrtc_video_engine.cc b/media/engine/webrtc_video_engine.cc
index 9a8ee88..5ecd221 100644
--- a/media/engine/webrtc_video_engine.cc
+++ b/media/engine/webrtc_video_engine.cc
@@ -140,11 +140,25 @@
return output_codecs;
}
-std::vector<VideoCodec> AssignPayloadTypesAndDefaultCodecs(
- const webrtc::VideoEncoderFactory* encoder_factory) {
- return encoder_factory ? AssignPayloadTypesAndDefaultCodecs(
- encoder_factory->GetSupportedFormats())
- : std::vector<VideoCodec>();
+// is_decoder_factory is needed to keep track of the implict assumption that any
+// H264 decoder also supports constrained base line profile.
+// TODO(kron): Perhaps it better to move the implcit knowledge to the place
+// where codecs are negotiated.
+template <class T>
+std::vector<VideoCodec> GetPayloadTypesAndDefaultCodecs(
+ const T* factory,
+ bool is_decoder_factory) {
+ if (!factory) {
+ return {};
+ }
+
+ std::vector<webrtc::SdpVideoFormat> supported_formats =
+ factory->GetSupportedFormats();
+ if (is_decoder_factory) {
+ AddH264ConstrainedBaselineProfileToSupportedFormats(&supported_formats);
+ }
+
+ return AssignPayloadTypesAndDefaultCodecs(std::move(supported_formats));
}
bool IsTemporalLayersSupported(const std::string& codec_name) {
@@ -553,8 +567,14 @@
encoder_factory_.get(), decoder_factory_.get(),
video_bitrate_allocator_factory);
}
-std::vector<VideoCodec> WebRtcVideoEngine::codecs() const {
- return AssignPayloadTypesAndDefaultCodecs(encoder_factory_.get());
+std::vector<VideoCodec> WebRtcVideoEngine::send_codecs() const {
+ return GetPayloadTypesAndDefaultCodecs(encoder_factory_.get(),
+ /*is_decoder_factory=*/false);
+}
+
+std::vector<VideoCodec> WebRtcVideoEngine::recv_codecs() const {
+ return GetPayloadTypesAndDefaultCodecs(decoder_factory_.get(),
+ /*is_decoder_factory=*/true);
}
std::vector<webrtc::RtpHeaderExtensionCapability>
@@ -612,9 +632,10 @@
rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
sending_ = false;
- recv_codecs_ =
- MapCodecs(AssignPayloadTypesAndDefaultCodecs(encoder_factory_));
- recv_flexfec_payload_type_ = recv_codecs_.front().flexfec_payload_type;
+ recv_codecs_ = MapCodecs(GetPayloadTypesAndDefaultCodecs(
+ decoder_factory_, /*is_decoder_factory=*/true));
+ recv_flexfec_payload_type_ =
+ recv_codecs_.empty() ? 0 : recv_codecs_.front().flexfec_payload_type;
}
WebRtcVideoChannel::~WebRtcVideoChannel() {
@@ -628,7 +649,8 @@
WebRtcVideoChannel::SelectSendVideoCodecs(
const std::vector<VideoCodecSettings>& remote_mapped_codecs) const {
std::vector<webrtc::SdpVideoFormat> sdp_formats =
- encoder_factory_->GetImplementations();
+ encoder_factory_ ? encoder_factory_->GetImplementations()
+ : std::vector<webrtc::SdpVideoFormat>();
// The returned vector holds the VideoCodecSettings in term of preference.
// They are orderd by receive codec preference first and local implementation
@@ -698,7 +720,8 @@
std::vector<VideoCodecSettings> negotiated_codecs =
SelectSendVideoCodecs(MapCodecs(params.codecs));
- if (negotiated_codecs.empty()) {
+ // We should only fail here if send direction is enabled.
+ if (params.is_stream_active && negotiated_codecs.empty()) {
RTC_LOG(LS_ERROR) << "No video codecs supported.";
return false;
}
@@ -711,7 +734,9 @@
}
if (negotiated_codecs_ != negotiated_codecs) {
- if (send_codec_ != negotiated_codecs.front()) {
+ if (negotiated_codecs.empty()) {
+ changed_params->send_codec = absl::nullopt;
+ } else if (send_codec_ != negotiated_codecs.front()) {
changed_params->send_codec = negotiated_codecs.front();
}
changed_params->negotiated_codecs = std::move(negotiated_codecs);
@@ -878,8 +903,6 @@
if (changed_params.send_codec)
send_codec_ = changed_params.send_codec;
- RTC_DCHECK(send_codec_);
-
if (changed_params.extmap_allow_mixed) {
SetExtmapAllowMixed(*changed_params.extmap_allow_mixed);
}
@@ -1073,14 +1096,17 @@
}
// Verify that every mapped codec is supported locally.
- const std::vector<VideoCodec> local_supported_codecs =
- AssignPayloadTypesAndDefaultCodecs(encoder_factory_);
- for (const VideoCodecSettings& mapped_codec : mapped_codecs) {
- if (!FindMatchingCodec(local_supported_codecs, mapped_codec.codec)) {
- RTC_LOG(LS_ERROR)
- << "SetRecvParameters called with unsupported video codec: "
- << mapped_codec.codec.ToString();
- return false;
+ if (params.is_stream_active) {
+ const std::vector<VideoCodec> local_supported_codecs =
+ GetPayloadTypesAndDefaultCodecs(decoder_factory_,
+ /*is_decoder_factory=*/true);
+ for (const VideoCodecSettings& mapped_codec : mapped_codecs) {
+ if (!FindMatchingCodec(local_supported_codecs, mapped_codec.codec)) {
+ RTC_LOG(LS_ERROR)
+ << "SetRecvParameters called with unsupported video codec: "
+ << mapped_codec.codec.ToString();
+ return false;
+ }
}
}
@@ -3041,7 +3067,9 @@
std::vector<WebRtcVideoChannel::VideoCodecSettings>
WebRtcVideoChannel::MapCodecs(const std::vector<VideoCodec>& codecs) {
- RTC_DCHECK(!codecs.empty());
+ if (codecs.empty()) {
+ return {};
+ }
std::vector<VideoCodecSettings> video_codecs;
std::map<int, VideoCodec::CodecType> payload_codec_type;
diff --git a/media/engine/webrtc_video_engine.h b/media/engine/webrtc_video_engine.h
index 4eade6f..323eaa9 100644
--- a/media/engine/webrtc_video_engine.h
+++ b/media/engine/webrtc_video_engine.h
@@ -110,7 +110,8 @@
webrtc::VideoBitrateAllocatorFactory* video_bitrate_allocator_factory)
override;
- std::vector<VideoCodec> codecs() const override;
+ std::vector<VideoCodec> send_codecs() const override;
+ std::vector<VideoCodec> recv_codecs() const override;
std::vector<webrtc::RtpHeaderExtensionCapability> GetRtpHeaderExtensions()
const override;
diff --git a/media/engine/webrtc_video_engine_unittest.cc b/media/engine/webrtc_video_engine_unittest.cc
index bc2f5f2..395d38a 100644
--- a/media/engine/webrtc_video_engine_unittest.cc
+++ b/media/engine/webrtc_video_engine_unittest.cc
@@ -271,7 +271,7 @@
// Find the codec in the engine with the given name. The codec must be
// present.
cricket::VideoCodec GetEngineCodec(const std::string& name) const;
-
+ void AddSupportedVideoCodecType(const std::string& name);
VideoMediaChannel* SetSendParamsWithAllSupportedCodecs();
VideoMediaChannel* SetRecvParamsWithSupportedCodecs(
@@ -302,7 +302,7 @@
encoder_factory_->AddSupportedVideoCodecType("VP8");
AssignDefaultCodec();
- std::vector<VideoCodec> engine_codecs = engine_.codecs();
+ std::vector<VideoCodec> engine_codecs = engine_.send_codecs();
for (size_t i = 0; i < engine_codecs.size(); ++i) {
if (engine_codecs[i].name != kRtxCodecName)
continue;
@@ -372,7 +372,7 @@
// dtor is called.
::testing::NiceMock<MockVideoSource> video_source;
- encoder_factory_->AddSupportedVideoCodecType("VP8");
+ AddSupportedVideoCodecType("VP8");
std::unique_ptr<VideoMediaChannel> channel(
SetSendParamsWithAllSupportedCodecs());
@@ -409,7 +409,7 @@
// dtor is called.
::testing::NiceMock<MockVideoSource> video_source;
- encoder_factory_->AddSupportedVideoCodecType("VP8");
+ AddSupportedVideoCodecType("VP8");
std::unique_ptr<VideoMediaChannel> channel(
SetSendParamsWithAllSupportedCodecs());
@@ -432,8 +432,8 @@
TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionAfterCapturer) {
::testing::NiceMock<MockVideoSource> video_source;
- encoder_factory_->AddSupportedVideoCodecType("VP8");
- encoder_factory_->AddSupportedVideoCodecType("VP9");
+ AddSupportedVideoCodecType("VP8");
+ AddSupportedVideoCodecType("VP9");
std::unique_ptr<VideoMediaChannel> channel(
SetSendParamsWithAllSupportedCodecs());
@@ -474,7 +474,7 @@
}
TEST_F(WebRtcVideoEngineTest, SetSendFailsBeforeSettingCodecs) {
- encoder_factory_->AddSupportedVideoCodecType("VP8");
+ AddSupportedVideoCodecType("VP8");
std::unique_ptr<VideoMediaChannel> channel(engine_.CreateMediaChannel(
call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
@@ -489,7 +489,7 @@
}
TEST_F(WebRtcVideoEngineTest, GetStatsWithoutSendCodecsSetDoesNotCrash) {
- encoder_factory_->AddSupportedVideoCodecType("VP8");
+ AddSupportedVideoCodecType("VP8");
std::unique_ptr<VideoMediaChannel> channel(engine_.CreateMediaChannel(
call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
@@ -500,7 +500,7 @@
}
TEST_F(WebRtcVideoEngineTest, UseFactoryForVp8WhenSupported) {
- encoder_factory_->AddSupportedVideoCodecType("VP8");
+ AddSupportedVideoCodecType("VP8");
std::unique_ptr<VideoMediaChannel> channel(
SetSendParamsWithAllSupportedCodecs());
@@ -560,7 +560,7 @@
encoder_factory_->AddSupportedVideoCodec(h264_high);
// First figure out what payload types the test codecs got assigned.
- const std::vector<cricket::VideoCodec> codecs = engine_.codecs();
+ const std::vector<cricket::VideoCodec> codecs = engine_.send_codecs();
// Now search for RTX codecs for them. Expect that they all have associated
// RTX codecs.
EXPECT_TRUE(HasRtxCodec(
@@ -577,7 +577,7 @@
#if defined(RTC_ENABLE_VP9)
TEST_F(WebRtcVideoEngineTest, CanConstructDecoderForVp9EncoderFactory) {
- encoder_factory_->AddSupportedVideoCodecType("VP9");
+ AddSupportedVideoCodecType("VP9");
std::unique_ptr<VideoMediaChannel> channel(
SetSendParamsWithAllSupportedCodecs());
@@ -588,7 +588,7 @@
#endif // defined(RTC_ENABLE_VP9)
TEST_F(WebRtcVideoEngineTest, PropagatesInputFrameTimestamp) {
- encoder_factory_->AddSupportedVideoCodecType("VP8");
+ AddSupportedVideoCodecType("VP8");
FakeCall* fake_call = new FakeCall();
call_.reset(fake_call);
std::unique_ptr<VideoMediaChannel> channel(
@@ -642,7 +642,7 @@
}
void WebRtcVideoEngineTest::AssignDefaultAptRtxTypes() {
- std::vector<VideoCodec> engine_codecs = engine_.codecs();
+ std::vector<VideoCodec> engine_codecs = engine_.send_codecs();
RTC_DCHECK(!engine_codecs.empty());
for (const cricket::VideoCodec& codec : engine_codecs) {
if (codec.name == "rtx") {
@@ -656,7 +656,7 @@
}
void WebRtcVideoEngineTest::AssignDefaultCodec() {
- std::vector<VideoCodec> engine_codecs = engine_.codecs();
+ std::vector<VideoCodec> engine_codecs = engine_.send_codecs();
RTC_DCHECK(!engine_codecs.empty());
bool codec_set = false;
for (const cricket::VideoCodec& codec : engine_codecs) {
@@ -672,7 +672,7 @@
size_t WebRtcVideoEngineTest::GetEngineCodecIndex(
const std::string& name) const {
- const std::vector<cricket::VideoCodec> codecs = engine_.codecs();
+ const std::vector<cricket::VideoCodec> codecs = engine_.send_codecs();
for (size_t i = 0; i < codecs.size(); ++i) {
const cricket::VideoCodec engine_codec = codecs[i];
if (!absl::EqualsIgnoreCase(name, engine_codec.name))
@@ -696,7 +696,13 @@
cricket::VideoCodec WebRtcVideoEngineTest::GetEngineCodec(
const std::string& name) const {
- return engine_.codecs()[GetEngineCodecIndex(name)];
+ return engine_.send_codecs()[GetEngineCodecIndex(name)];
+}
+
+void WebRtcVideoEngineTest::AddSupportedVideoCodecType(
+ const std::string& name) {
+ encoder_factory_->AddSupportedVideoCodecType(name);
+ decoder_factory_->AddSupportedVideoCodecType(name);
}
VideoMediaChannel*
@@ -743,7 +749,7 @@
}
TEST_F(WebRtcVideoEngineTest, UsesSimulcastAdapterForVp8Factories) {
- encoder_factory_->AddSupportedVideoCodecType("VP8");
+ AddSupportedVideoCodecType("VP8");
std::unique_ptr<VideoMediaChannel> channel(
SetSendParamsWithAllSupportedCodecs());
@@ -780,8 +786,8 @@
}
TEST_F(WebRtcVideoEngineTest, ChannelWithH264CanChangeToVp8) {
- encoder_factory_->AddSupportedVideoCodecType("VP8");
- encoder_factory_->AddSupportedVideoCodecType("H264");
+ AddSupportedVideoCodecType("VP8");
+ AddSupportedVideoCodecType("H264");
// Frame source.
webrtc::test::FrameForwarder frame_forwarder;
@@ -815,8 +821,8 @@
TEST_F(WebRtcVideoEngineTest,
UsesSimulcastAdapterForVp8WithCombinedVP8AndH264Factory) {
- encoder_factory_->AddSupportedVideoCodecType("VP8");
- encoder_factory_->AddSupportedVideoCodecType("H264");
+ AddSupportedVideoCodecType("VP8");
+ AddSupportedVideoCodecType("H264");
std::unique_ptr<VideoMediaChannel> channel(engine_.CreateMediaChannel(
call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
@@ -851,8 +857,8 @@
TEST_F(WebRtcVideoEngineTest,
DestroysNonSimulcastEncoderFromCombinedVP8AndH264Factory) {
- encoder_factory_->AddSupportedVideoCodecType("VP8");
- encoder_factory_->AddSupportedVideoCodecType("H264");
+ AddSupportedVideoCodecType("VP8");
+ AddSupportedVideoCodecType("H264");
std::unique_ptr<VideoMediaChannel> channel(engine_.CreateMediaChannel(
call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
@@ -885,7 +891,7 @@
RTC_DCHECK(!override_field_trials_);
override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>(
"WebRTC-H264Simulcast/Enabled/");
- encoder_factory_->AddSupportedVideoCodecType("H264");
+ AddSupportedVideoCodecType("H264");
std::unique_ptr<VideoMediaChannel> channel(engine_.CreateMediaChannel(
call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
@@ -925,13 +931,13 @@
auto flexfec = Field("name", &VideoCodec::name, "flexfec-03");
// FlexFEC is not active without field trial.
- EXPECT_THAT(engine_.codecs(), Not(Contains(flexfec)));
+ EXPECT_THAT(engine_.send_codecs(), Not(Contains(flexfec)));
// FlexFEC is active with field trial.
RTC_DCHECK(!override_field_trials_);
override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>(
"WebRTC-FlexFEC-03-Advertised/Enabled/");
- EXPECT_THAT(engine_.codecs(), Contains(flexfec));
+ EXPECT_THAT(engine_.send_codecs(), Contains(flexfec));
}
// Test that codecs are added in the order they are reported from the factory.
@@ -955,11 +961,11 @@
// Set up external encoder factory with first codec, and initialize engine.
encoder_factory_->AddSupportedVideoCodecType(kFakeExternalCodecName1);
- std::vector<cricket::VideoCodec> codecs_before(engine_.codecs());
+ std::vector<cricket::VideoCodec> codecs_before(engine_.send_codecs());
// Add second codec.
encoder_factory_->AddSupportedVideoCodecType(kFakeExternalCodecName2);
- std::vector<cricket::VideoCodec> codecs_after(engine_.codecs());
+ std::vector<cricket::VideoCodec> codecs_after(engine_.send_codecs());
// The codec itself and RTX should have been added.
EXPECT_EQ(codecs_before.size() + 2, codecs_after.size());
@@ -975,12 +981,11 @@
encoder_factory_->AddSupportedVideoCodecType(kFakeCodecName);
const size_t fake_codec_index = GetEngineCodecIndex(kFakeCodecName);
- EXPECT_EQ("rtx", engine_.codecs().at(fake_codec_index + 1).name);
+ EXPECT_EQ("rtx", engine_.send_codecs().at(fake_codec_index + 1).name);
}
TEST_F(WebRtcVideoEngineTest, RegisterDecodersIfSupported) {
- encoder_factory_->AddSupportedVideoCodecType("VP8");
- decoder_factory_->AddSupportedVideoCodecType(webrtc::SdpVideoFormat("VP8"));
+ AddSupportedVideoCodecType("VP8");
cricket::VideoRecvParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
@@ -1006,10 +1011,7 @@
// can't even query the WebRtcVideoDecoderFactory for supported codecs.
// For now we add a FakeWebRtcVideoEncoderFactory to add H264 to supported
// codecs.
- encoder_factory_->AddSupportedVideoCodecType("H264");
- webrtc::SdpVideoFormat supported_h264("H264");
- supported_h264.parameters[kH264FmtpPacketizationMode] = "1";
- decoder_factory_->AddSupportedVideoCodecType(supported_h264);
+ AddSupportedVideoCodecType("H264");
std::vector<cricket::VideoCodec> codecs;
codecs.push_back(GetEngineCodec("H264"));
@@ -1025,8 +1027,7 @@
// empty list of RtpSource without crashing.
TEST_F(WebRtcVideoEngineTest, GetSourcesWithNonExistingSsrc) {
// Setup an recv stream with |kSsrc|.
- encoder_factory_->AddSupportedVideoCodecType("VP8");
- decoder_factory_->AddSupportedVideoCodecType(webrtc::SdpVideoFormat("VP8"));
+ AddSupportedVideoCodecType("VP8");
cricket::VideoRecvParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
std::unique_ptr<VideoMediaChannel> channel(
@@ -1045,7 +1046,8 @@
std::unique_ptr<webrtc::VideoDecoderFactory> decoder_factory;
WebRtcVideoEngine engine(std::move(encoder_factory),
std::move(decoder_factory));
- EXPECT_EQ(0u, engine.codecs().size());
+ EXPECT_EQ(0u, engine.send_codecs().size());
+ EXPECT_EQ(0u, engine.recv_codecs().size());
}
TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, EmptyFactories) {
@@ -1057,8 +1059,11 @@
WebRtcVideoEngine engine(
(std::unique_ptr<webrtc::VideoEncoderFactory>(encoder_factory)),
(std::unique_ptr<webrtc::VideoDecoderFactory>(decoder_factory)));
- EXPECT_CALL(*encoder_factory, GetSupportedFormats());
- EXPECT_EQ(0u, engine.codecs().size());
+ // TODO(kron): Change to Times(1) once send and receive codecs are changed
+ // to be treated independently.
+ EXPECT_CALL(*encoder_factory, GetSupportedFormats()).Times(1);
+ EXPECT_EQ(0u, engine.send_codecs().size());
+ EXPECT_EQ(0u, engine.recv_codecs().size());
EXPECT_CALL(*encoder_factory, Die());
EXPECT_CALL(*decoder_factory, Die());
}
@@ -1087,9 +1092,11 @@
const std::vector<webrtc::SdpVideoFormat> supported_formats = {vp8_format};
EXPECT_CALL(*encoder_factory, GetSupportedFormats())
.WillRepeatedly(Return(supported_formats));
+ EXPECT_CALL(*decoder_factory, GetSupportedFormats())
+ .WillRepeatedly(Return(supported_formats));
// Verify the codecs from the engine.
- const std::vector<VideoCodec> engine_codecs = engine.codecs();
+ const std::vector<VideoCodec> engine_codecs = engine.send_codecs();
// Verify default codecs has been added correctly.
EXPECT_EQ(5u, engine_codecs.size());
EXPECT_EQ("VP8", engine_codecs.at(0).name);
@@ -1222,12 +1229,14 @@
const auto call = absl::WrapUnique(webrtc::Call::Create(call_config));
// Create recv channel.
+ EXPECT_CALL(*decoder_factory, GetSupportedFormats())
+ .WillRepeatedly(::testing::Return(supported_formats));
const int recv_ssrc = 321;
std::unique_ptr<VideoMediaChannel> recv_channel(engine.CreateMediaChannel(
call.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
rate_allocator_factory.get()));
cricket::VideoRecvParameters recv_parameters;
- recv_parameters.codecs.push_back(engine.codecs().front());
+ recv_parameters.codecs.push_back(engine.recv_codecs().front());
EXPECT_TRUE(recv_channel->SetRecvParameters(recv_parameters));
EXPECT_TRUE(recv_channel->AddRecvStream(
cricket::StreamParams::CreateLegacy(recv_ssrc)));
@@ -1315,9 +1324,9 @@
webrtc::CreateBuiltinVideoBitrateAllocatorFactory()),
engine_(
webrtc::CreateBuiltinVideoEncoderFactory(),
- std::make_unique<webrtc::test::FunctionVideoDecoderFactory>([]() {
- return std::make_unique<webrtc::test::FakeDecoder>();
- })),
+ std::make_unique<webrtc::test::FunctionVideoDecoderFactory>(
+ []() { return std::make_unique<webrtc::test::FakeDecoder>(); },
+ kSdpVideoFormats)),
channel_(absl::WrapUnique(static_cast<cricket::WebRtcVideoChannel*>(
engine_.CreateMediaChannel(
call_.get(),
@@ -1328,7 +1337,7 @@
network_interface_.SetDestination(channel_.get());
channel_->SetInterface(&network_interface_, webrtc::MediaTransportConfig());
cricket::VideoRecvParameters parameters;
- parameters.codecs = engine_.codecs();
+ parameters.codecs = engine_.recv_codecs();
channel_->SetRecvParameters(parameters);
}
@@ -1352,6 +1361,7 @@
EXPECT_EQ(0, renderer_.errors());
}
+ static const std::vector<webrtc::SdpVideoFormat> kSdpVideoFormats;
webrtc::FieldTrialBasedConfig field_trials_;
webrtc::RtcEventLogNull event_log_;
std::unique_ptr<webrtc::TaskQueueFactory> task_queue_factory_;
@@ -1364,6 +1374,10 @@
cricket::FakeVideoRenderer renderer_;
};
+const std::vector<webrtc::SdpVideoFormat>
+ WebRtcVideoChannelEncodedFrameCallbackTest::kSdpVideoFormats = {
+ webrtc::SdpVideoFormat("VP8")};
+
TEST_F(WebRtcVideoChannelEncodedFrameCallbackTest,
SetEncodedFrameBufferFunction_DefaultStream) {
testing::MockFunction<void(const webrtc::RecordableEncodedFrame&)> callback;
@@ -1469,7 +1483,7 @@
network_interface_.SetDestination(channel_.get());
channel_->SetInterface(&network_interface_, webrtc::MediaTransportConfig());
cricket::VideoRecvParameters parameters;
- parameters.codecs = engine_.codecs();
+ parameters.codecs = engine_.send_codecs();
channel_->SetRecvParameters(parameters);
EXPECT_TRUE(channel_->AddSendStream(DefaultSendStreamParams()));
frame_forwarder_ = std::make_unique<webrtc::test::FrameForwarder>();
@@ -1617,7 +1631,7 @@
}
cricket::VideoCodec GetEngineCodec(const std::string& name) {
- for (const cricket::VideoCodec& engine_codec : engine_.codecs()) {
+ for (const cricket::VideoCodec& engine_codec : engine_.send_codecs()) {
if (absl::EqualsIgnoreCase(name, engine_codec.name))
return engine_codec;
}
@@ -2394,10 +2408,10 @@
frame_source_(1280, 720, rtc::kNumMicrosecsPerSec / 30),
last_ssrc_(0) {}
void SetUp() override {
- encoder_factory_->AddSupportedVideoCodecType("VP8");
- encoder_factory_->AddSupportedVideoCodecType("VP9");
+ AddSupportedVideoCodecType("VP8");
+ AddSupportedVideoCodecType("VP9");
#if defined(WEBRTC_USE_H264)
- encoder_factory_->AddSupportedVideoCodecType("H264");
+ AddSupportedVideoCodecType("H264");
#endif
fake_call_.reset(new FakeCall());
@@ -2406,8 +2420,8 @@
webrtc::CryptoOptions(), video_bitrate_allocator_factory_.get()));
channel_->OnReadyToSend(true);
last_ssrc_ = 123;
- send_parameters_.codecs = engine_.codecs();
- recv_parameters_.codecs = engine_.codecs();
+ send_parameters_.codecs = engine_.send_codecs();
+ recv_parameters_.codecs = engine_.recv_codecs();
ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
}
@@ -2579,7 +2593,7 @@
VerifyCodecHasDefaultFeedbackParams(default_codec_, expect_lntf_enabled);
cricket::VideoSendParameters parameters;
- parameters.codecs = engine_.codecs();
+ parameters.codecs = engine_.send_codecs();
EXPECT_TRUE(channel_->SetSendParameters(parameters));
EXPECT_TRUE(channel_->SetSend(true));
@@ -2724,7 +2738,7 @@
TEST_F(WebRtcVideoChannelTest, RecvStreamWithSimAndRtx) {
cricket::VideoSendParameters parameters;
- parameters.codecs = engine_.codecs();
+ parameters.codecs = engine_.send_codecs();
EXPECT_TRUE(channel_->SetSendParameters(parameters));
EXPECT_TRUE(channel_->SetSend(true));
parameters.conference_mode = true;
@@ -3037,7 +3051,7 @@
// Verify that transport cc feedback is turned on when setting default codecs
// since the default codecs have transport cc feedback enabled.
- parameters.codecs = engine_.codecs();
+ parameters.codecs = engine_.send_codecs();
EXPECT_TRUE(channel_->SetSendParameters(parameters));
stream = fake_call_->GetVideoReceiveStreams()[0];
EXPECT_TRUE(stream->GetConfig().rtp.transport_cc);
@@ -3066,7 +3080,7 @@
{
cricket::VideoSendParameters parameters;
- parameters.codecs = engine_.codecs();
+ parameters.codecs = engine_.send_codecs();
EXPECT_TRUE(channel_->SetSendParameters(parameters));
EXPECT_TRUE(channel_->SetSend(true));
}
@@ -3090,7 +3104,7 @@
EXPECT_FALSE(send_stream->GetConfig().rtp.lntf.enabled);
// Setting the default codecs again, including VP8, turns LNTF back on.
- parameters.codecs = engine_.codecs();
+ parameters.codecs = engine_.send_codecs();
EXPECT_TRUE(channel_->SetSendParameters(parameters));
recv_stream = fake_call_->GetVideoReceiveStreams()[0];
EXPECT_TRUE(recv_stream->GetConfig().rtp.lntf.enabled);
@@ -3103,7 +3117,7 @@
VerifyCodecHasDefaultFeedbackParams(default_codec_, false);
cricket::VideoSendParameters parameters;
- parameters.codecs = engine_.codecs();
+ parameters.codecs = engine_.send_codecs();
EXPECT_TRUE(channel_->SetSendParameters(parameters));
EXPECT_TRUE(channel_->SetSend(true));
@@ -3141,7 +3155,7 @@
// Verify that NACK is turned on when setting default codecs since the
// default codecs have NACK enabled.
- parameters.codecs = engine_.codecs();
+ parameters.codecs = engine_.send_codecs();
EXPECT_TRUE(channel_->SetSendParameters(parameters));
recv_stream = fake_call_->GetVideoReceiveStreams()[0];
EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
@@ -3879,7 +3893,7 @@
VideoCodec codec;
EXPECT_TRUE(channel_->GetSendCodec(&codec));
- EXPECT_TRUE(codec.Matches(engine_.codecs()[0]));
+ EXPECT_TRUE(codec.Matches(engine_.send_codecs()[0]));
// Using a RTX setup to verify that the default RTX payload type is good.
const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
@@ -4227,7 +4241,7 @@
TEST_F(WebRtcVideoChannelTest,
SetSendCodecRejectsRtxWithoutAssociatedPayloadType) {
const int kUnusedPayloadType = 127;
- EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType));
+ EXPECT_FALSE(FindCodecById(engine_.send_codecs(), kUnusedPayloadType));
cricket::VideoSendParameters parameters;
cricket::VideoCodec rtx_codec(kUnusedPayloadType, "rtx");
@@ -4240,8 +4254,8 @@
SetSendCodecRejectsRtxWithoutMatchingVideoCodec) {
const int kUnusedPayloadType1 = 126;
const int kUnusedPayloadType2 = 127;
- EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType1));
- EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType2));
+ EXPECT_FALSE(FindCodecById(engine_.send_codecs(), kUnusedPayloadType1));
+ EXPECT_FALSE(FindCodecById(engine_.send_codecs(), kUnusedPayloadType2));
{
cricket::VideoCodec rtx_codec = cricket::VideoCodec::CreateRtxCodec(
kUnusedPayloadType1, GetEngineCodec("VP8").id);
@@ -4264,8 +4278,8 @@
TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithChangedRtxPayloadType) {
const int kUnusedPayloadType1 = 126;
const int kUnusedPayloadType2 = 127;
- EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType1));
- EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType2));
+ EXPECT_FALSE(FindCodecById(engine_.send_codecs(), kUnusedPayloadType1));
+ EXPECT_FALSE(FindCodecById(engine_.send_codecs(), kUnusedPayloadType2));
// SSRCs for RTX.
cricket::StreamParams params =
@@ -4666,8 +4680,8 @@
TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithRtx) {
const int kUnusedPayloadType1 = 126;
const int kUnusedPayloadType2 = 127;
- EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType1));
- EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType2));
+ EXPECT_FALSE(FindCodecById(engine_.recv_codecs(), kUnusedPayloadType1));
+ EXPECT_FALSE(FindCodecById(engine_.recv_codecs(), kUnusedPayloadType2));
cricket::VideoRecvParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
@@ -4765,8 +4779,8 @@
TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithChangedRtxPayloadType) {
const int kUnusedPayloadType1 = 126;
const int kUnusedPayloadType2 = 127;
- EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType1));
- EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType2));
+ EXPECT_FALSE(FindCodecById(engine_.recv_codecs(), kUnusedPayloadType1));
+ EXPECT_FALSE(FindCodecById(engine_.recv_codecs(), kUnusedPayloadType2));
// SSRCs for RTX.
cricket::StreamParams params =
@@ -4814,13 +4828,14 @@
TEST_F(WebRtcVideoChannelTest, SetRecvCodecsAcceptDefaultCodecs) {
cricket::VideoRecvParameters parameters;
- parameters.codecs = engine_.codecs();
+ parameters.codecs = engine_.recv_codecs();
EXPECT_TRUE(channel_->SetRecvParameters(parameters));
FakeVideoReceiveStream* stream = AddRecvStream();
const webrtc::VideoReceiveStream::Config& config = stream->GetConfig();
- EXPECT_EQ(engine_.codecs()[0].name, config.decoders[0].video_format.name);
- EXPECT_EQ(engine_.codecs()[0].id, config.decoders[0].payload_type);
+ EXPECT_EQ(engine_.recv_codecs()[0].name,
+ config.decoders[0].video_format.name);
+ EXPECT_EQ(engine_.recv_codecs()[0].id, config.decoders[0].payload_type);
}
TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRejectUnsupportedCodec) {
@@ -5884,7 +5899,7 @@
uint8_t payload_type,
bool expect_created_receive_stream) {
// kRedRtxPayloadType must currently be unused.
- EXPECT_FALSE(FindCodecById(engine_.codecs(), kRedRtxPayloadType));
+ EXPECT_FALSE(FindCodecById(engine_.recv_codecs(), kRedRtxPayloadType));
// Add a RED RTX codec.
VideoCodec red_rtx_codec =
@@ -7718,6 +7733,7 @@
void SetUp() override {
encoder_factory_->AddSupportedVideoCodecType("VP8");
+ decoder_factory_->AddSupportedVideoCodecType("VP8");
channel_.reset(engine_.CreateMediaChannel(
&fake_call_, GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
mock_rate_allocator_factory_.get()));
diff --git a/modules/video_coding/codecs/h264/h264.cc b/modules/video_coding/codecs/h264/h264.cc
index 147e964..be5b031 100644
--- a/modules/video_coding/codecs/h264/h264.cc
+++ b/modules/video_coding/codecs/h264/h264.cc
@@ -16,7 +16,6 @@
#include "absl/types/optional.h"
#include "api/video_codecs/sdp_video_format.h"
-#include "media/base/h264_profile_level_id.h"
#include "media/base/media_constants.h"
#if defined(WEBRTC_USE_H264)
@@ -44,6 +43,8 @@
#endif
}
+} // namespace
+
SdpVideoFormat CreateH264Format(H264::Profile profile,
H264::Level level,
const std::string& packetization_mode) {
@@ -57,8 +58,6 @@
{cricket::kH264FmtpPacketizationMode, packetization_mode}});
}
-} // namespace
-
void DisableRtcUseH264() {
#if defined(WEBRTC_USE_H264)
g_rtc_use_h264 = false;
diff --git a/modules/video_coding/codecs/h264/include/h264.h b/modules/video_coding/codecs/h264/include/h264.h
index f5cebcf..70ca817 100644
--- a/modules/video_coding/codecs/h264/include/h264.h
+++ b/modules/video_coding/codecs/h264/include/h264.h
@@ -13,9 +13,11 @@
#define MODULES_VIDEO_CODING_CODECS_H264_INCLUDE_H264_H_
#include <memory>
+#include <string>
#include <vector>
#include "media/base/codec.h"
+#include "media/base/h264_profile_level_id.h"
#include "modules/video_coding/include/video_codec_interface.h"
#include "rtc_base/system/rtc_export.h"
@@ -23,6 +25,12 @@
struct SdpVideoFormat;
+// Creates an H264 SdpVideoFormat entry with specified paramters.
+RTC_EXPORT SdpVideoFormat
+CreateH264Format(H264::Profile profile,
+ H264::Level level,
+ const std::string& packetization_mode);
+
// Set to disable the H.264 encoder/decoder implementations that are provided if
// |rtc_use_h264| build flag is true (if false, this function does nothing).
// This function should only be called before or during WebRTC initialization
diff --git a/pc/channel.cc b/pc/channel.cc
index d6f884c..03e63b0 100644
--- a/pc/channel.cc
+++ b/pc/channel.cc
@@ -98,7 +98,9 @@
void RtpParametersFromMediaDescription(
const MediaContentDescriptionImpl<Codec>* desc,
const RtpHeaderExtensions& extensions,
+ bool is_stream_active,
RtpParameters<Codec>* params) {
+ params->is_stream_active = is_stream_active;
// TODO(pthatcher): Remove this once we're sure no one will give us
// a description without codecs. Currently the ORTC implementation is relying
// on this.
@@ -118,8 +120,10 @@
void RtpSendParametersFromMediaDescription(
const MediaContentDescriptionImpl<Codec>* desc,
const RtpHeaderExtensions& extensions,
+ bool is_stream_active,
RtpSendParameters<Codec>* send_params) {
- RtpParametersFromMediaDescription(desc, extensions, send_params);
+ RtpParametersFromMediaDescription(desc, extensions, is_stream_active,
+ send_params);
send_params->max_bandwidth_bps = desc->bandwidth();
send_params->extmap_allow_mixed = desc->extmap_allow_mixed();
}
@@ -838,7 +842,9 @@
media_channel()->SetExtmapAllowMixed(audio->extmap_allow_mixed());
AudioRecvParameters recv_params = last_recv_params_;
- RtpParametersFromMediaDescription(audio, rtp_header_extensions, &recv_params);
+ RtpParametersFromMediaDescription(
+ audio, rtp_header_extensions,
+ webrtc::RtpTransceiverDirectionHasRecv(audio->direction()), &recv_params);
if (!media_channel()->SetRecvParameters(recv_params)) {
SafeSetError("Failed to set local audio description recv parameters.",
error_desc);
@@ -891,8 +897,9 @@
GetFilteredRtpHeaderExtensions(audio->rtp_header_extensions());
AudioSendParameters send_params = last_send_params_;
- RtpSendParametersFromMediaDescription(audio, rtp_header_extensions,
- &send_params);
+ RtpSendParametersFromMediaDescription(
+ audio, rtp_header_extensions,
+ webrtc::RtpTransceiverDirectionHasRecv(audio->direction()), &send_params);
send_params.mid = content_name();
bool parameters_applied = media_channel()->SetSendParameters(send_params);
@@ -989,9 +996,12 @@
media_channel()->SetExtmapAllowMixed(video->extmap_allow_mixed());
VideoRecvParameters recv_params = last_recv_params_;
- RtpParametersFromMediaDescription(video, rtp_header_extensions, &recv_params);
+ RtpParametersFromMediaDescription(
+ video, rtp_header_extensions,
+ webrtc::RtpTransceiverDirectionHasRecv(video->direction()), &recv_params);
VideoSendParameters send_params = last_send_params_;
+
bool needs_send_params_update = false;
if (type == SdpType::kAnswer || type == SdpType::kPrAnswer) {
for (auto& send_codec : send_params.codecs) {
@@ -1070,14 +1080,16 @@
GetFilteredRtpHeaderExtensions(video->rtp_header_extensions());
VideoSendParameters send_params = last_send_params_;
- RtpSendParametersFromMediaDescription(video, rtp_header_extensions,
- &send_params);
+ RtpSendParametersFromMediaDescription(
+ video, rtp_header_extensions,
+ webrtc::RtpTransceiverDirectionHasRecv(video->direction()), &send_params);
if (video->conference_mode()) {
send_params.conference_mode = true;
}
send_params.mid = content_name();
VideoRecvParameters recv_params = last_recv_params_;
+
bool needs_recv_params_update = false;
if (type == SdpType::kAnswer || type == SdpType::kPrAnswer) {
for (auto& recv_codec : recv_params.codecs) {
@@ -1213,7 +1225,9 @@
GetFilteredRtpHeaderExtensions(data->rtp_header_extensions());
DataRecvParameters recv_params = last_recv_params_;
- RtpParametersFromMediaDescription(data, rtp_header_extensions, &recv_params);
+ RtpParametersFromMediaDescription(
+ data, rtp_header_extensions,
+ webrtc::RtpTransceiverDirectionHasRecv(data->direction()), &recv_params);
if (!media_channel()->SetRecvParameters(recv_params)) {
SafeSetError("Failed to set remote data description recv parameters.",
error_desc);
@@ -1273,8 +1287,9 @@
RTC_LOG(LS_INFO) << "Setting remote data description";
DataSendParameters send_params = last_send_params_;
- RtpSendParametersFromMediaDescription<DataCodec>(data, rtp_header_extensions,
- &send_params);
+ RtpSendParametersFromMediaDescription<DataCodec>(
+ data, rtp_header_extensions,
+ webrtc::RtpTransceiverDirectionHasRecv(data->direction()), &send_params);
if (!media_channel()->SetSendParameters(send_params)) {
SafeSetError("Failed to set remote data description send parameters.",
error_desc);
diff --git a/pc/channel_manager.cc b/pc/channel_manager.cc
index 17e4751..f5f3dd4 100644
--- a/pc/channel_manager.cc
+++ b/pc/channel_manager.cc
@@ -79,14 +79,31 @@
*codecs = media_engine_->voice().recv_codecs();
}
-void ChannelManager::GetSupportedVideoCodecs(
+void ChannelManager::GetSupportedVideoSendCodecs(
std::vector<VideoCodec>* codecs) const {
if (!media_engine_) {
return;
}
codecs->clear();
- std::vector<VideoCodec> video_codecs = media_engine_->video().codecs();
+ std::vector<VideoCodec> video_codecs = media_engine_->video().send_codecs();
+ for (const auto& video_codec : video_codecs) {
+ if (!enable_rtx_ &&
+ absl::EqualsIgnoreCase(kRtxCodecName, video_codec.name)) {
+ continue;
+ }
+ codecs->push_back(video_codec);
+ }
+}
+
+void ChannelManager::GetSupportedVideoReceiveCodecs(
+ std::vector<VideoCodec>* codecs) const {
+ if (!media_engine_) {
+ return;
+ }
+ codecs->clear();
+
+ std::vector<VideoCodec> video_codecs = media_engine_->video().recv_codecs();
for (const auto& video_codec : video_codecs) {
if (!enable_rtx_ &&
absl::EqualsIgnoreCase(kRtxCodecName, video_codec.name)) {
diff --git a/pc/channel_manager.h b/pc/channel_manager.h
index fa4bf7b..415e476 100644
--- a/pc/channel_manager.h
+++ b/pc/channel_manager.h
@@ -75,7 +75,8 @@
// Can be called before starting the media engine.
void GetSupportedAudioSendCodecs(std::vector<AudioCodec>* codecs) const;
void GetSupportedAudioReceiveCodecs(std::vector<AudioCodec>* codecs) const;
- void GetSupportedVideoCodecs(std::vector<VideoCodec>* codecs) const;
+ void GetSupportedVideoSendCodecs(std::vector<VideoCodec>* codecs) const;
+ void GetSupportedVideoReceiveCodecs(std::vector<VideoCodec>* codecs) const;
void GetSupportedDataCodecs(std::vector<DataCodec>* codecs) const;
RtpHeaderExtensions GetDefaultEnabledAudioRtpHeaderExtensions() const;
std::vector<webrtc::RtpHeaderExtensionCapability>
diff --git a/pc/channel_manager_unittest.cc b/pc/channel_manager_unittest.cc
index 9078513..6f3128e 100644
--- a/pc/channel_manager_unittest.cc
+++ b/pc/channel_manager_unittest.cc
@@ -142,22 +142,29 @@
}
TEST_F(ChannelManagerTest, SetVideoRtxEnabled) {
- std::vector<VideoCodec> codecs;
+ std::vector<VideoCodec> send_codecs;
+ std::vector<VideoCodec> recv_codecs;
const VideoCodec rtx_codec(96, "rtx");
// By default RTX is disabled.
- cm_->GetSupportedVideoCodecs(&codecs);
- EXPECT_FALSE(ContainsMatchingCodec(codecs, rtx_codec));
+ cm_->GetSupportedVideoSendCodecs(&send_codecs);
+ EXPECT_FALSE(ContainsMatchingCodec(send_codecs, rtx_codec));
+ cm_->GetSupportedVideoSendCodecs(&recv_codecs);
+ EXPECT_FALSE(ContainsMatchingCodec(recv_codecs, rtx_codec));
// Enable and check.
EXPECT_TRUE(cm_->SetVideoRtxEnabled(true));
- cm_->GetSupportedVideoCodecs(&codecs);
- EXPECT_TRUE(ContainsMatchingCodec(codecs, rtx_codec));
+ cm_->GetSupportedVideoSendCodecs(&send_codecs);
+ EXPECT_TRUE(ContainsMatchingCodec(send_codecs, rtx_codec));
+ cm_->GetSupportedVideoSendCodecs(&recv_codecs);
+ EXPECT_TRUE(ContainsMatchingCodec(recv_codecs, rtx_codec));
// Disable and check.
EXPECT_TRUE(cm_->SetVideoRtxEnabled(false));
- cm_->GetSupportedVideoCodecs(&codecs);
- EXPECT_FALSE(ContainsMatchingCodec(codecs, rtx_codec));
+ cm_->GetSupportedVideoSendCodecs(&send_codecs);
+ EXPECT_FALSE(ContainsMatchingCodec(send_codecs, rtx_codec));
+ cm_->GetSupportedVideoSendCodecs(&recv_codecs);
+ EXPECT_FALSE(ContainsMatchingCodec(recv_codecs, rtx_codec));
// Cannot toggle rtx after initialization.
EXPECT_TRUE(cm_->Init());
@@ -167,8 +174,10 @@
// Can set again after terminate.
cm_->Terminate();
EXPECT_TRUE(cm_->SetVideoRtxEnabled(true));
- cm_->GetSupportedVideoCodecs(&codecs);
- EXPECT_TRUE(ContainsMatchingCodec(codecs, rtx_codec));
+ cm_->GetSupportedVideoSendCodecs(&send_codecs);
+ EXPECT_TRUE(ContainsMatchingCodec(send_codecs, rtx_codec));
+ cm_->GetSupportedVideoSendCodecs(&recv_codecs);
+ EXPECT_TRUE(ContainsMatchingCodec(recv_codecs, rtx_codec));
}
TEST_F(ChannelManagerTest, CreateDestroyChannels) {
diff --git a/pc/media_session.cc b/pc/media_session.cc
index 2f57e61..a9c523d 100644
--- a/pc/media_session.cc
+++ b/pc/media_session.cc
@@ -1367,11 +1367,13 @@
channel_manager->GetSupportedAudioReceiveCodecs(&audio_recv_codecs_);
audio_rtp_extensions_ =
channel_manager->GetDefaultEnabledAudioRtpHeaderExtensions();
- channel_manager->GetSupportedVideoCodecs(&video_codecs_);
+ channel_manager->GetSupportedVideoSendCodecs(&video_send_codecs_);
+ channel_manager->GetSupportedVideoReceiveCodecs(&video_recv_codecs_);
video_rtp_extensions_ =
channel_manager->GetDefaultEnabledVideoRtpHeaderExtensions();
channel_manager->GetSupportedDataCodecs(&rtp_data_codecs_);
ComputeAudioCodecsIntersectionAndUnion();
+ ComputeVideoCodecsIntersectionAndUnion();
}
const AudioCodecs& MediaSessionDescriptionFactory::audio_sendrecv_codecs()
@@ -1395,6 +1397,27 @@
ComputeAudioCodecsIntersectionAndUnion();
}
+const VideoCodecs& MediaSessionDescriptionFactory::video_sendrecv_codecs()
+ const {
+ return video_sendrecv_codecs_;
+}
+
+const VideoCodecs& MediaSessionDescriptionFactory::video_send_codecs() const {
+ return video_send_codecs_;
+}
+
+const VideoCodecs& MediaSessionDescriptionFactory::video_recv_codecs() const {
+ return video_recv_codecs_;
+}
+
+void MediaSessionDescriptionFactory::set_video_codecs(
+ const VideoCodecs& send_codecs,
+ const VideoCodecs& recv_codecs) {
+ video_send_codecs_ = send_codecs;
+ video_recv_codecs_ = recv_codecs;
+ ComputeVideoCodecsIntersectionAndUnion();
+}
+
static void RemoveUnifiedPlanExtensions(RtpHeaderExtensions* extensions) {
RTC_DCHECK(extensions);
@@ -1777,6 +1800,43 @@
}
}
+const VideoCodecs& MediaSessionDescriptionFactory::GetVideoCodecsForOffer(
+ const RtpTransceiverDirection& direction) const {
+ switch (direction) {
+ // If stream is inactive - generate list as if sendrecv.
+ case RtpTransceiverDirection::kSendRecv:
+ case RtpTransceiverDirection::kInactive:
+ return video_sendrecv_codecs_;
+ case RtpTransceiverDirection::kSendOnly:
+ return video_send_codecs_;
+ case RtpTransceiverDirection::kRecvOnly:
+ return video_recv_codecs_;
+ case RtpTransceiverDirection::kStopped:
+ RTC_NOTREACHED();
+ return video_sendrecv_codecs_;
+ }
+}
+
+const VideoCodecs& MediaSessionDescriptionFactory::GetVideoCodecsForAnswer(
+ const RtpTransceiverDirection& offer,
+ const RtpTransceiverDirection& answer) const {
+ switch (answer) {
+ // For inactive and sendrecv answers, generate lists as if we were to accept
+ // the offer's direction. See RFC 3264 Section 6.1.
+ case RtpTransceiverDirection::kSendRecv:
+ case RtpTransceiverDirection::kInactive:
+ return GetVideoCodecsForOffer(
+ webrtc::RtpTransceiverDirectionReversed(offer));
+ case RtpTransceiverDirection::kSendOnly:
+ return video_send_codecs_;
+ case RtpTransceiverDirection::kRecvOnly:
+ return video_recv_codecs_;
+ case RtpTransceiverDirection::kStopped:
+ RTC_NOTREACHED();
+ return video_sendrecv_codecs_;
+ }
+}
+
void MergeCodecsFromDescription(
const std::vector<const ContentInfo*>& current_active_contents,
AudioCodecs* audio_codecs,
@@ -1824,7 +1884,7 @@
// Add our codecs that are not in the current description.
MergeCodecs<AudioCodec>(all_audio_codecs_, audio_codecs, &used_pltypes);
- MergeCodecs<VideoCodec>(video_codecs_, video_codecs, &used_pltypes);
+ MergeCodecs<VideoCodec>(all_video_codecs_, video_codecs, &used_pltypes);
MergeCodecs<DataCodec>(rtp_data_codecs_, rtp_data_codecs, &used_pltypes);
}
@@ -1872,7 +1932,7 @@
if (!FindMatchingCodec<VideoCodec>(video->codecs(),
filtered_offered_video_codecs,
offered_video_codec, nullptr) &&
- FindMatchingCodec<VideoCodec>(video->codecs(), video_codecs_,
+ FindMatchingCodec<VideoCodec>(video->codecs(), all_video_codecs_,
offered_video_codec, nullptr)) {
filtered_offered_video_codecs.push_back(offered_video_codec);
}
@@ -2079,7 +2139,7 @@
IsDtlsActive(current_content, current_description) ? cricket::SEC_DISABLED
: secure();
- std::unique_ptr<AudioContentDescription> audio(new AudioContentDescription());
+ auto audio = std::make_unique<AudioContentDescription>();
std::vector<std::string> crypto_suites;
GetSupportedAudioSdesCryptoSuiteNames(session_options.crypto_options,
&crypto_suites);
@@ -2107,6 +2167,8 @@
return true;
}
+// TODO(kron): This function is very similar to AddAudioContentForOffer.
+// Refactor to reuse shared code.
bool MediaSessionDescriptionFactory::AddVideoContentForOffer(
const MediaDescriptionOptions& media_description_options,
const MediaSessionOptions& session_options,
@@ -2117,14 +2179,10 @@
StreamParamsVec* current_streams,
SessionDescription* desc,
IceCredentialsIterator* ice_credentials) const {
- cricket::SecurePolicy sdes_policy =
- IsDtlsActive(current_content, current_description) ? cricket::SEC_DISABLED
- : secure();
-
- std::unique_ptr<VideoContentDescription> video(new VideoContentDescription());
- std::vector<std::string> crypto_suites;
- GetSupportedVideoSdesCryptoSuiteNames(session_options.crypto_options,
- &crypto_suites);
+ // Filter video_codecs (which includes all codecs, with correctly remapped
+ // payload types) based on transceiver direction.
+ const VideoCodecs& supported_video_codecs =
+ GetVideoCodecsForOffer(media_description_options.direction);
VideoCodecs filtered_codecs;
@@ -2132,7 +2190,7 @@
// Add the codecs from the current transceiver's codec preferences.
// They override any existing codecs from previous negotiations.
filtered_codecs = MatchCodecPreference(
- media_description_options.codec_preferences, video_codecs_);
+ media_description_options.codec_preferences, supported_video_codecs);
} else {
// Add the codecs from current content if it exists and is not rejected nor
// recycled.
@@ -2150,11 +2208,11 @@
}
// Add other supported video codecs.
VideoCodec found_codec;
- for (const VideoCodec& codec : video_codecs_) {
- if (FindMatchingCodec<VideoCodec>(video_codecs_, video_codecs, codec,
- &found_codec) &&
- !FindMatchingCodec<VideoCodec>(video_codecs_, filtered_codecs, codec,
- nullptr)) {
+ for (const VideoCodec& codec : supported_video_codecs) {
+ if (FindMatchingCodec<VideoCodec>(supported_video_codecs, video_codecs,
+ codec, &found_codec) &&
+ !FindMatchingCodec<VideoCodec>(supported_video_codecs,
+ filtered_codecs, codec, nullptr)) {
// Use the |found_codec| from |video_codecs| because it has the
// correctly mapped payload type.
filtered_codecs.push_back(found_codec);
@@ -2170,6 +2228,13 @@
}
}
+ cricket::SecurePolicy sdes_policy =
+ IsDtlsActive(current_content, current_description) ? cricket::SEC_DISABLED
+ : secure();
+ auto video = std::make_unique<VideoContentDescription>();
+ std::vector<std::string> crypto_suites;
+ GetSupportedVideoSdesCryptoSuiteNames(session_options.crypto_options,
+ &crypto_suites);
if (!CreateMediaContentOffer(media_description_options, session_options,
filtered_codecs, sdes_policy,
GetCryptos(current_content), crypto_suites,
@@ -2192,6 +2257,7 @@
current_description, desc, ice_credentials)) {
return false;
}
+
return true;
}
@@ -2203,8 +2269,7 @@
StreamParamsVec* current_streams,
SessionDescription* desc,
IceCredentialsIterator* ice_credentials) const {
- std::unique_ptr<SctpDataContentDescription> data(
- new SctpDataContentDescription());
+ auto data = std::make_unique<SctpDataContentDescription>();
bool secure_transport = (transport_desc_factory_->secure() != SEC_DISABLED);
@@ -2250,8 +2315,7 @@
StreamParamsVec* current_streams,
SessionDescription* desc,
IceCredentialsIterator* ice_credentials) const {
- std::unique_ptr<RtpDataContentDescription> data(
- new RtpDataContentDescription());
+ auto data = std::make_unique<RtpDataContentDescription>();
bool secure_transport = (transport_desc_factory_->secure() != SEC_DISABLED);
cricket::SecurePolicy sdes_policy =
@@ -2391,8 +2455,7 @@
bool bundle_enabled = offer_description->HasGroup(GROUP_TYPE_BUNDLE) &&
session_options.bundle_enabled;
- std::unique_ptr<AudioContentDescription> audio_answer(
- new AudioContentDescription());
+ auto audio_answer = std::make_unique<AudioContentDescription>();
// Do not require or create SDES cryptos if DTLS is used.
cricket::SecurePolicy sdes_policy =
audio_transport->secure() ? cricket::SEC_DISABLED : secure();
@@ -2432,6 +2495,8 @@
return true;
}
+// TODO(kron): This function is very similar to AddAudioContentForAnswer.
+// Refactor to reuse shared code.
bool MediaSessionDescriptionFactory::AddVideoContentForAnswer(
const MediaDescriptionOptions& media_description_options,
const MediaSessionOptions& session_options,
@@ -2456,11 +2521,20 @@
return false;
}
+ // Pick codecs based on the requested communications direction in the offer
+ // and the selected direction in the answer.
+ // Note these will be filtered one final time in CreateMediaContentAnswer.
+ auto wants_rtd = media_description_options.direction;
+ auto offer_rtd = offer_video_description->direction();
+ auto answer_rtd = NegotiateRtpTransceiverDirection(offer_rtd, wants_rtd);
+ VideoCodecs supported_video_codecs =
+ GetVideoCodecsForAnswer(offer_rtd, answer_rtd);
+
VideoCodecs filtered_codecs;
if (!media_description_options.codec_preferences.empty()) {
filtered_codecs = MatchCodecPreference(
- media_description_options.codec_preferences, video_codecs_);
+ media_description_options.codec_preferences, supported_video_codecs);
} else {
// Add the codecs from current content if it exists and is not rejected nor
// recycled.
@@ -2477,11 +2551,11 @@
}
}
// Add other supported video codecs.
- for (const VideoCodec& codec : video_codecs_) {
- if (FindMatchingCodec<VideoCodec>(video_codecs_, video_codecs, codec,
- nullptr) &&
- !FindMatchingCodec<VideoCodec>(video_codecs_, filtered_codecs, codec,
- nullptr)) {
+ for (const VideoCodec& codec : supported_video_codecs) {
+ if (FindMatchingCodec<VideoCodec>(supported_video_codecs, video_codecs,
+ codec, nullptr) &&
+ !FindMatchingCodec<VideoCodec>(supported_video_codecs,
+ filtered_codecs, codec, nullptr)) {
// We should use the local codec with local parameters and the codec id
// would be correctly mapped in |NegotiateCodecs|.
filtered_codecs.push_back(codec);
@@ -2499,9 +2573,7 @@
bool bundle_enabled = offer_description->HasGroup(GROUP_TYPE_BUNDLE) &&
session_options.bundle_enabled;
-
- std::unique_ptr<VideoContentDescription> video_answer(
- new VideoContentDescription());
+ auto video_answer = std::make_unique<VideoContentDescription>();
// Do not require or create SDES cryptos if DTLS is used.
cricket::SecurePolicy sdes_policy =
video_transport->secure() ? cricket::SEC_DISABLED : secure();
@@ -2671,6 +2743,38 @@
&audio_sendrecv_codecs_, true);
}
+void MediaSessionDescriptionFactory::ComputeVideoCodecsIntersectionAndUnion() {
+ video_sendrecv_codecs_.clear();
+ all_video_codecs_.clear();
+ // Compute the video codecs union.
+ for (const VideoCodec& send : video_send_codecs_) {
+ all_video_codecs_.push_back(send);
+ if (!FindMatchingCodec<VideoCodec>(video_send_codecs_, video_recv_codecs_,
+ send, nullptr)) {
+ // TODO(kron): This check is violated by the unit test:
+ // MediaSessionDescriptionFactoryTest.RtxWithoutApt
+ // Remove either the test or the check.
+
+ // It doesn't make sense to have an RTX codec we support sending but not
+ // receiving.
+ // RTC_DCHECK(!IsRtxCodec(send));
+ }
+ }
+ for (const VideoCodec& recv : video_recv_codecs_) {
+ if (!FindMatchingCodec<VideoCodec>(video_recv_codecs_, video_send_codecs_,
+ recv, nullptr)) {
+ all_video_codecs_.push_back(recv);
+ }
+ }
+ // 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.
+ NegotiateCodecs(video_recv_codecs_, video_send_codecs_,
+ &video_sendrecv_codecs_, true);
+}
+
bool IsMediaContent(const ContentInfo* content) {
return (content && (content->type == MediaProtocolType::kRtp ||
content->type == MediaProtocolType::kSctp));
diff --git a/pc/media_session.h b/pc/media_session.h
index 235945c..ef83834 100644
--- a/pc/media_session.h
+++ b/pc/media_session.h
@@ -151,8 +151,11 @@
audio_rtp_extensions_ = extensions;
}
RtpHeaderExtensions audio_rtp_header_extensions() const;
- const VideoCodecs& video_codecs() const { return video_codecs_; }
- void set_video_codecs(const VideoCodecs& codecs) { video_codecs_ = codecs; }
+ const VideoCodecs& video_sendrecv_codecs() const;
+ const VideoCodecs& video_send_codecs() const;
+ const VideoCodecs& video_recv_codecs() const;
+ void set_video_codecs(const VideoCodecs& send_codecs,
+ const VideoCodecs& recv_codecs);
void set_video_rtp_header_extensions(const RtpHeaderExtensions& extensions) {
video_rtp_extensions_ = extensions;
}
@@ -186,6 +189,11 @@
const AudioCodecs& GetAudioCodecsForAnswer(
const webrtc::RtpTransceiverDirection& offer,
const webrtc::RtpTransceiverDirection& answer) const;
+ const VideoCodecs& GetVideoCodecsForOffer(
+ const webrtc::RtpTransceiverDirection& direction) const;
+ const VideoCodecs& GetVideoCodecsForAnswer(
+ const webrtc::RtpTransceiverDirection& offer,
+ const webrtc::RtpTransceiverDirection& answer) const;
void GetCodecsForOffer(
const std::vector<const ContentInfo*>& current_active_contents,
AudioCodecs* audio_codecs,
@@ -317,6 +325,8 @@
void ComputeAudioCodecsIntersectionAndUnion();
+ void ComputeVideoCodecsIntersectionAndUnion();
+
bool is_unified_plan_ = false;
AudioCodecs audio_send_codecs_;
AudioCodecs audio_recv_codecs_;
@@ -325,7 +335,12 @@
// Union of send and recv.
AudioCodecs all_audio_codecs_;
RtpHeaderExtensions audio_rtp_extensions_;
- VideoCodecs video_codecs_;
+ VideoCodecs video_send_codecs_;
+ VideoCodecs video_recv_codecs_;
+ // Intersection of send and recv.
+ VideoCodecs video_sendrecv_codecs_;
+ // Union of send and recv.
+ VideoCodecs all_video_codecs_;
RtpHeaderExtensions video_rtp_extensions_;
RtpDataCodecs rtp_data_codecs_;
// This object is not owned by the channel so it must outlive it.
diff --git a/pc/media_session_unittest.cc b/pc/media_session_unittest.cc
index 548b778..ffc4a6f 100644
--- a/pc/media_session_unittest.cc
+++ b/pc/media_session_unittest.cc
@@ -422,11 +422,13 @@
: f1_(&tdf1_, &ssrc_generator1), f2_(&tdf2_, &ssrc_generator2) {
f1_.set_audio_codecs(MAKE_VECTOR(kAudioCodecs1),
MAKE_VECTOR(kAudioCodecs1));
- f1_.set_video_codecs(MAKE_VECTOR(kVideoCodecs1));
+ f1_.set_video_codecs(MAKE_VECTOR(kVideoCodecs1),
+ MAKE_VECTOR(kVideoCodecs1));
f1_.set_rtp_data_codecs(MAKE_VECTOR(kDataCodecs1));
f2_.set_audio_codecs(MAKE_VECTOR(kAudioCodecs2),
MAKE_VECTOR(kAudioCodecs2));
- f2_.set_video_codecs(MAKE_VECTOR(kVideoCodecs2));
+ f2_.set_video_codecs(MAKE_VECTOR(kVideoCodecs2),
+ MAKE_VECTOR(kVideoCodecs2));
f2_.set_rtp_data_codecs(MAKE_VECTOR(kDataCodecs2));
tdf1_.set_certificate(rtc::RTCCertificate::Create(
std::unique_ptr<rtc::SSLIdentity>(new rtc::FakeSSLIdentity("id1"))));
@@ -804,7 +806,7 @@
ASSERT_CRYPTO(acd, 1U, kDefaultSrtpCryptoSuite);
EXPECT_EQ(cricket::kMediaProtocolSavpf, acd->protocol());
EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type());
- EXPECT_EQ(f1_.video_codecs(), vcd->codecs());
+ EXPECT_EQ(f1_.video_sendrecv_codecs(), vcd->codecs());
EXPECT_EQ(0U, vcd->first_ssrc()); // no sender is attached
EXPECT_EQ(kAutoBandwidth, vcd->bandwidth()); // default bandwidth (auto)
EXPECT_TRUE(vcd->rtcp_mux()); // rtcp-mux defaults on
@@ -816,7 +818,7 @@
// RTP playlod type. The test verifies that the offer don't contain the
// duplicate RTP payload types.
TEST_F(MediaSessionDescriptionFactoryTest, TestBundleOfferWithSameCodecPlType) {
- const VideoCodec& offered_video_codec = f2_.video_codecs()[0];
+ const VideoCodec& offered_video_codec = f2_.video_sendrecv_codecs()[0];
const AudioCodec& offered_audio_codec = f2_.audio_sendrecv_codecs()[0];
const RtpDataCodec& offered_data_codec = f2_.rtp_data_codecs()[0];
ASSERT_EQ(offered_video_codec.id, offered_audio_codec.id);
@@ -2221,7 +2223,7 @@
ASSERT_CRYPTO(acd, 1U, kDefaultSrtpCryptoSuite);
EXPECT_EQ(MEDIA_TYPE_VIDEO, vcd->type());
- EXPECT_EQ(f1_.video_codecs(), vcd->codecs());
+ EXPECT_EQ(f1_.video_sendrecv_codecs(), vcd->codecs());
ASSERT_CRYPTO(vcd, 1U, kDefaultSrtpCryptoSuite);
const StreamParamsVec& video_streams = vcd->streams();
@@ -2717,8 +2719,8 @@
// that is being recycled.
TEST_F(MediaSessionDescriptionFactoryTest,
ReOfferDoesNotReUseRecycledAudioCodecs) {
- f1_.set_video_codecs({});
- f2_.set_video_codecs({});
+ f1_.set_video_codecs({}, {});
+ f2_.set_video_codecs({}, {});
MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_AUDIO, "a0",
@@ -2770,8 +2772,8 @@
// section that is being recycled.
TEST_F(MediaSessionDescriptionFactoryTest,
ReAnswerDoesNotReUseRecycledAudioCodecs) {
- f1_.set_video_codecs({});
- f2_.set_video_codecs({});
+ f1_.set_video_codecs({}, {});
+ f2_.set_video_codecs({}, {});
// Perform initial offer/answer in reverse (|f2_| as offerer) so that the
// second offer/answer is forward (|f1_| as offerer).
@@ -2840,12 +2842,12 @@
std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
// This creates rtx for H264 with the payload type |f1_| uses.
AddRtxCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
- f1_.set_video_codecs(f1_codecs);
+ f1_.set_video_codecs(f1_codecs, f1_codecs);
std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
// This creates rtx for H264 with the payload type |f2_| uses.
AddRtxCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs);
- f2_.set_video_codecs(f2_codecs);
+ f2_.set_video_codecs(f2_codecs, f2_codecs);
std::unique_ptr<SessionDescription> offer = f1_.CreateOffer(opts, NULL);
ASSERT_TRUE(offer.get() != NULL);
@@ -2904,8 +2906,8 @@
std::vector<VideoCodec> f2_codecs = {vp9, vp9_rtx, vp8_answerer,
vp8_answerer_rtx};
- f1_.set_video_codecs(f1_codecs);
- f2_.set_video_codecs(f2_codecs);
+ f1_.set_video_codecs(f1_codecs, f1_codecs);
+ f2_.set_video_codecs(f2_codecs, f2_codecs);
std::vector<AudioCodec> audio_codecs;
f1_.set_audio_codecs(audio_codecs, audio_codecs);
f2_.set_audio_codecs(audio_codecs, audio_codecs);
@@ -2940,7 +2942,7 @@
std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
// This creates rtx for H264 with the payload type |f1_| uses.
AddRtxCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
- f1_.set_video_codecs(f1_codecs);
+ f1_.set_video_codecs(f1_codecs, f1_codecs);
MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_AUDIO, "audio",
@@ -2965,7 +2967,7 @@
int used_pl_type = acd->codecs()[0].id;
f2_codecs[0].id = used_pl_type; // Set the payload type for H264.
AddRtxCodec(VideoCodec::CreateRtxCodec(125, used_pl_type), &f2_codecs);
- f2_.set_video_codecs(f2_codecs);
+ f2_.set_video_codecs(f2_codecs, f2_codecs);
std::unique_ptr<SessionDescription> updated_offer(
f2_.CreateOffer(opts, answer.get()));
@@ -3001,7 +3003,7 @@
std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
// This creates rtx for H264 with the payload type |f2_| uses.
AddRtxCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs);
- f2_.set_video_codecs(f2_codecs);
+ f2_.set_video_codecs(f2_codecs, f2_codecs);
std::unique_ptr<SessionDescription> offer = f1_.CreateOffer(opts, nullptr);
ASSERT_TRUE(offer.get() != nullptr);
@@ -3040,12 +3042,12 @@
std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
// This creates RTX without associated payload type parameter.
AddRtxCodec(VideoCodec(126, cricket::kRtxCodecName), &f1_codecs);
- f1_.set_video_codecs(f1_codecs);
+ f1_.set_video_codecs(f1_codecs, f1_codecs);
std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
// This creates RTX for H264 with the payload type |f2_| uses.
AddRtxCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs2[0].id), &f2_codecs);
- f2_.set_video_codecs(f2_codecs);
+ f2_.set_video_codecs(f2_codecs, f2_codecs);
std::unique_ptr<SessionDescription> offer = f1_.CreateOffer(opts, NULL);
ASSERT_TRUE(offer.get() != NULL);
@@ -3083,12 +3085,12 @@
std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
// This creates RTX for H264 in sender.
AddRtxCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
- f1_.set_video_codecs(f1_codecs);
+ f1_.set_video_codecs(f1_codecs, f1_codecs);
std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
// This creates RTX for H263 in receiver.
AddRtxCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs2[1].id), &f2_codecs);
- f2_.set_video_codecs(f2_codecs);
+ f2_.set_video_codecs(f2_codecs, f2_codecs);
std::unique_ptr<SessionDescription> offer = f1_.CreateOffer(opts, NULL);
ASSERT_TRUE(offer.get() != NULL);
@@ -3113,16 +3115,16 @@
std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
// This creates RTX for H264-SVC in sender.
AddRtxCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs1[0].id), &f1_codecs);
- f1_.set_video_codecs(f1_codecs);
+ f1_.set_video_codecs(f1_codecs, f1_codecs);
// This creates RTX for H264 in sender.
AddRtxCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
- f1_.set_video_codecs(f1_codecs);
+ f1_.set_video_codecs(f1_codecs, f1_codecs);
std::vector<VideoCodec> f2_codecs = MAKE_VECTOR(kVideoCodecs2);
// This creates RTX for H264 in receiver.
AddRtxCodec(VideoCodec::CreateRtxCodec(124, kVideoCodecs2[0].id), &f2_codecs);
- f2_.set_video_codecs(f2_codecs);
+ f2_.set_video_codecs(f2_codecs, f1_codecs);
// H264-SVC codec is removed in the answer, therefore, associated RTX codec
// for H264-SVC should also be removed.
@@ -3149,7 +3151,7 @@
std::vector<VideoCodec> f1_codecs = MAKE_VECTOR(kVideoCodecs1);
// This creates RTX for H264 for the offerer.
AddRtxCodec(VideoCodec::CreateRtxCodec(126, kVideoCodecs1[1].id), &f1_codecs);
- f1_.set_video_codecs(f1_codecs);
+ f1_.set_video_codecs(f1_codecs, f1_codecs);
std::unique_ptr<SessionDescription> offer = f1_.CreateOffer(opts, nullptr);
ASSERT_TRUE(offer);
@@ -3163,7 +3165,7 @@
// Now, attempt to add RTX for H264-SVC.
AddRtxCodec(VideoCodec::CreateRtxCodec(125, kVideoCodecs1[0].id), &f1_codecs);
- f1_.set_video_codecs(f1_codecs);
+ f1_.set_video_codecs(f1_codecs, f1_codecs);
std::unique_ptr<SessionDescription> updated_offer(
f1_.CreateOffer(opts, offer.get()));
@@ -3190,7 +3192,7 @@
std::vector<VideoCodec> f1_codecs;
f1_codecs.push_back(VideoCodec(97, "H264"));
AddRtxCodec(VideoCodec::CreateRtxCodec(125, 97), &f1_codecs);
- f1_.set_video_codecs(f1_codecs);
+ f1_.set_video_codecs(f1_codecs, f1_codecs);
// Ensure that the offer has an RTX ssrc for each regular ssrc, and that there
// is a FID ssrc + grouping for each.
@@ -3232,7 +3234,7 @@
std::vector<VideoCodec> f1_codecs;
f1_codecs.push_back(VideoCodec(97, "H264"));
f1_codecs.push_back(VideoCodec(118, "flexfec-03"));
- f1_.set_video_codecs(f1_codecs);
+ f1_.set_video_codecs(f1_codecs, f1_codecs);
// Ensure that the offer has a single FlexFEC ssrc and that
// there is no FEC-FR ssrc + grouping for each.
@@ -3273,7 +3275,7 @@
std::vector<VideoCodec> f1_codecs;
f1_codecs.push_back(VideoCodec(97, "H264"));
f1_codecs.push_back(VideoCodec(118, "flexfec-03"));
- f1_.set_video_codecs(f1_codecs);
+ f1_.set_video_codecs(f1_codecs, f1_codecs);
// Ensure that the offer has no FlexFEC ssrcs for each regular ssrc, and that
// there is no FEC-FR ssrc + grouping for each.
@@ -4405,9 +4407,9 @@
video_codecs2[0].SetParam(video_param_name, video_value2);
f1_.set_audio_codecs(audio_codecs1, audio_codecs1);
- f1_.set_video_codecs(video_codecs1);
+ f1_.set_video_codecs(video_codecs1, video_codecs1);
f2_.set_audio_codecs(audio_codecs2, audio_codecs2);
- f2_.set_video_codecs(video_codecs2);
+ f2_.set_video_codecs(video_codecs2, video_codecs2);
MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_AUDIO, "audio",
@@ -4457,8 +4459,8 @@
// Offerer will send both codecs, answerer should choose the one with matching
// packetization mode (and not the first one it sees).
- f1_.set_video_codecs({h264_pm0, h264_pm1});
- f2_.set_video_codecs({h264_pm1});
+ f1_.set_video_codecs({h264_pm0, h264_pm1}, {h264_pm0, h264_pm1});
+ f2_.set_video_codecs({h264_pm1}, {h264_pm1});
MediaSessionOptions opts;
AddMediaDescriptionOptions(MEDIA_TYPE_VIDEO, "video",
@@ -4487,11 +4489,13 @@
: f1_(&tdf1_, &ssrc_generator1), f2_(&tdf2_, &ssrc_generator2) {
f1_.set_audio_codecs(MAKE_VECTOR(kAudioCodecs1),
MAKE_VECTOR(kAudioCodecs1));
- f1_.set_video_codecs(MAKE_VECTOR(kVideoCodecs1));
+ f1_.set_video_codecs(MAKE_VECTOR(kVideoCodecs1),
+ MAKE_VECTOR(kVideoCodecs1));
f1_.set_rtp_data_codecs(MAKE_VECTOR(kDataCodecs1));
f2_.set_audio_codecs(MAKE_VECTOR(kAudioCodecs2),
MAKE_VECTOR(kAudioCodecs2));
- f2_.set_video_codecs(MAKE_VECTOR(kVideoCodecs2));
+ f2_.set_video_codecs(MAKE_VECTOR(kVideoCodecs2),
+ MAKE_VECTOR(kVideoCodecs2));
f2_.set_rtp_data_codecs(MAKE_VECTOR(kDataCodecs2));
f1_.set_secure(SEC_ENABLED);
f2_.set_secure(SEC_ENABLED);
diff --git a/pc/peer_connection_factory.cc b/pc/peer_connection_factory.cc
index a0a999f..cfb8718 100644
--- a/pc/peer_connection_factory.cc
+++ b/pc/peer_connection_factory.cc
@@ -167,7 +167,7 @@
}
case cricket::MEDIA_TYPE_VIDEO: {
cricket::VideoCodecs cricket_codecs;
- channel_manager_->GetSupportedVideoCodecs(&cricket_codecs);
+ channel_manager_->GetSupportedVideoSendCodecs(&cricket_codecs);
return ToRtpCapabilities(
cricket_codecs,
channel_manager_->GetDefaultEnabledVideoRtpHeaderExtensions());
@@ -192,7 +192,7 @@
}
case cricket::MEDIA_TYPE_VIDEO: {
cricket::VideoCodecs cricket_codecs;
- channel_manager_->GetSupportedVideoCodecs(&cricket_codecs);
+ channel_manager_->GetSupportedVideoReceiveCodecs(&cricket_codecs);
return ToRtpCapabilities(
cricket_codecs,
channel_manager_->GetDefaultEnabledVideoRtpHeaderExtensions());
diff --git a/pc/peer_connection_integrationtest.cc b/pc/peer_connection_integrationtest.cc
index 054091e..9ecb8b2 100644
--- a/pc/peer_connection_integrationtest.cc
+++ b/pc/peer_connection_integrationtest.cc
@@ -214,7 +214,9 @@
dependencies.cert_generator = std::move(cert_generator);
if (!client->Init(nullptr, nullptr, std::move(dependencies), network_thread,
worker_thread, nullptr,
- /*media_transport_factory=*/nullptr)) {
+ /*media_transport_factory=*/nullptr,
+ /*reset_encoder_factory=*/false,
+ /*reset_decoder_factory=*/false)) {
delete client;
return nullptr;
}
@@ -608,7 +610,9 @@
rtc::Thread* network_thread,
rtc::Thread* worker_thread,
std::unique_ptr<webrtc::FakeRtcEventLogFactory> event_log_factory,
- std::unique_ptr<webrtc::MediaTransportFactory> media_transport_factory) {
+ std::unique_ptr<webrtc::MediaTransportFactory> media_transport_factory,
+ bool reset_encoder_factory,
+ bool reset_decoder_factory) {
// There's an error in this test code if Init ends up being called twice.
RTC_DCHECK(!peer_connection_);
RTC_DCHECK(!peer_connection_factory_);
@@ -636,6 +640,14 @@
pc_factory_dependencies.task_queue_factory.get();
media_deps.adm = fake_audio_capture_module_;
webrtc::SetMediaEngineDefaults(&media_deps);
+
+ if (reset_encoder_factory) {
+ media_deps.video_encoder_factory.reset();
+ }
+ if (reset_decoder_factory) {
+ media_deps.video_decoder_factory.reset();
+ }
+
pc_factory_dependencies.media_engine =
cricket::CreateMediaEngine(std::move(media_deps));
pc_factory_dependencies.call_factory = webrtc::CreateCallFactory();
@@ -1269,7 +1281,9 @@
const RTCConfiguration* config,
webrtc::PeerConnectionDependencies dependencies,
std::unique_ptr<webrtc::FakeRtcEventLogFactory> event_log_factory,
- std::unique_ptr<webrtc::MediaTransportFactory> media_transport_factory) {
+ std::unique_ptr<webrtc::MediaTransportFactory> media_transport_factory,
+ bool reset_encoder_factory,
+ bool reset_decoder_factory) {
RTCConfiguration modified_config;
if (config) {
modified_config = *config;
@@ -1285,7 +1299,8 @@
if (!client->Init(options, &modified_config, std::move(dependencies),
network_thread_.get(), worker_thread_.get(),
std::move(event_log_factory),
- std::move(media_transport_factory))) {
+ std::move(media_transport_factory), reset_encoder_factory,
+ reset_decoder_factory)) {
return nullptr;
}
return client;
@@ -1299,10 +1314,11 @@
webrtc::PeerConnectionDependencies dependencies) {
std::unique_ptr<webrtc::FakeRtcEventLogFactory> event_log_factory(
new webrtc::FakeRtcEventLogFactory(rtc::Thread::Current()));
- return CreatePeerConnectionWrapper(debug_name, options, config,
- std::move(dependencies),
- std::move(event_log_factory),
- /*media_transport_factory=*/nullptr);
+ return CreatePeerConnectionWrapper(
+ debug_name, options, config, std::move(dependencies),
+ std::move(event_log_factory),
+ /*media_transport_factory=*/nullptr, /*reset_encoder_factory=*/false,
+ /*reset_decoder_factory=*/false);
}
bool CreatePeerConnectionWrappers() {
@@ -1323,11 +1339,15 @@
sdp_semantics_ = caller_semantics;
caller_ = CreatePeerConnectionWrapper(
"Caller", nullptr, nullptr, webrtc::PeerConnectionDependencies(nullptr),
- nullptr, /*media_transport_factory=*/nullptr);
+ nullptr, /*media_transport_factory=*/nullptr,
+ /*reset_encoder_factory=*/false,
+ /*reset_decoder_factory=*/false);
sdp_semantics_ = callee_semantics;
callee_ = CreatePeerConnectionWrapper(
"Callee", nullptr, nullptr, webrtc::PeerConnectionDependencies(nullptr),
- nullptr, /*media_transport_factory=*/nullptr);
+ nullptr, /*media_transport_factory=*/nullptr,
+ /*reset_encoder_factory=*/false,
+ /*reset_decoder_factory=*/false);
sdp_semantics_ = original_semantics;
return caller_ && callee_;
}
@@ -1338,11 +1358,13 @@
caller_ = CreatePeerConnectionWrapper(
"Caller", nullptr, &caller_config,
webrtc::PeerConnectionDependencies(nullptr), nullptr,
- /*media_transport_factory=*/nullptr);
+ /*media_transport_factory=*/nullptr, /*reset_encoder_factory=*/false,
+ /*reset_decoder_factory=*/false);
callee_ = CreatePeerConnectionWrapper(
"Callee", nullptr, &callee_config,
webrtc::PeerConnectionDependencies(nullptr), nullptr,
- /*media_transport_factory=*/nullptr);
+ /*media_transport_factory=*/nullptr, /*reset_encoder_factory=*/false,
+ /*reset_decoder_factory=*/false);
return caller_ && callee_;
}
@@ -1351,14 +1373,16 @@
const PeerConnectionInterface::RTCConfiguration& callee_config,
std::unique_ptr<webrtc::MediaTransportFactory> caller_factory,
std::unique_ptr<webrtc::MediaTransportFactory> callee_factory) {
- caller_ =
- CreatePeerConnectionWrapper("Caller", nullptr, &caller_config,
- webrtc::PeerConnectionDependencies(nullptr),
- nullptr, std::move(caller_factory));
- callee_ =
- CreatePeerConnectionWrapper("Callee", nullptr, &callee_config,
- webrtc::PeerConnectionDependencies(nullptr),
- nullptr, std::move(callee_factory));
+ caller_ = CreatePeerConnectionWrapper(
+ "Caller", nullptr, &caller_config,
+ webrtc::PeerConnectionDependencies(nullptr), nullptr,
+ std::move(caller_factory), /*reset_encoder_factory=*/false,
+ /*reset_decoder_factory=*/false);
+ callee_ = CreatePeerConnectionWrapper(
+ "Callee", nullptr, &callee_config,
+ webrtc::PeerConnectionDependencies(nullptr), nullptr,
+ std::move(callee_factory), /*reset_encoder_factory=*/false,
+ /*reset_decoder_factory=*/false);
return caller_ && callee_;
}
@@ -1367,14 +1391,16 @@
webrtc::PeerConnectionDependencies caller_dependencies,
const PeerConnectionInterface::RTCConfiguration& callee_config,
webrtc::PeerConnectionDependencies callee_dependencies) {
- caller_ =
- CreatePeerConnectionWrapper("Caller", nullptr, &caller_config,
- std::move(caller_dependencies), nullptr,
- /*media_transport_factory=*/nullptr);
- callee_ =
- CreatePeerConnectionWrapper("Callee", nullptr, &callee_config,
- std::move(callee_dependencies), nullptr,
- /*media_transport_factory=*/nullptr);
+ caller_ = CreatePeerConnectionWrapper(
+ "Caller", nullptr, &caller_config, std::move(caller_dependencies),
+ nullptr,
+ /*media_transport_factory=*/nullptr, /*reset_encoder_factory=*/false,
+ /*reset_decoder_factory=*/false);
+ callee_ = CreatePeerConnectionWrapper(
+ "Callee", nullptr, &callee_config, std::move(callee_dependencies),
+ nullptr,
+ /*media_transport_factory=*/nullptr, /*reset_encoder_factory=*/false,
+ /*reset_decoder_factory=*/false);
return caller_ && callee_;
}
@@ -1384,11 +1410,13 @@
caller_ = CreatePeerConnectionWrapper(
"Caller", &caller_options, nullptr,
webrtc::PeerConnectionDependencies(nullptr), nullptr,
- /*media_transport_factory=*/nullptr);
+ /*media_transport_factory=*/nullptr, /*reset_encoder_factory=*/false,
+ /*reset_decoder_factory=*/false);
callee_ = CreatePeerConnectionWrapper(
"Callee", &callee_options, nullptr,
webrtc::PeerConnectionDependencies(nullptr), nullptr,
- /*media_transport_factory=*/nullptr);
+ /*media_transport_factory=*/nullptr, /*reset_encoder_factory=*/false,
+ /*reset_decoder_factory=*/false);
return caller_ && callee_;
}
@@ -1411,9 +1439,24 @@
webrtc::PeerConnectionDependencies dependencies(nullptr);
dependencies.cert_generator = std::move(cert_generator);
- return CreatePeerConnectionWrapper("New Peer", nullptr, nullptr,
- std::move(dependencies), nullptr,
- /*media_transport_factory=*/nullptr);
+ return CreatePeerConnectionWrapper(
+ "New Peer", nullptr, nullptr, std::move(dependencies), nullptr,
+ /*media_transport_factory=*/nullptr, /*reset_encoder_factory=*/false,
+ /*reset_decoder_factory=*/false);
+ }
+
+ bool CreateOneDirectionalPeerConnectionWrappers(bool caller_to_callee) {
+ caller_ = CreatePeerConnectionWrapper(
+ "Caller", nullptr, nullptr, webrtc::PeerConnectionDependencies(nullptr),
+ nullptr, /*media_transport_factory=*/nullptr,
+ /*reset_encoder_factory=*/!caller_to_callee,
+ /*reset_decoder_factory=*/caller_to_callee);
+ callee_ = CreatePeerConnectionWrapper(
+ "Callee", nullptr, nullptr, webrtc::PeerConnectionDependencies(nullptr),
+ nullptr, /*media_transport_factory=*/nullptr,
+ /*reset_encoder_factory=*/caller_to_callee,
+ /*reset_decoder_factory=*/!caller_to_callee);
+ return caller_ && callee_;
}
cricket::TestTurnServer* CreateTurnServer(
@@ -2042,6 +2085,168 @@
ASSERT_TRUE(ExpectNewFrames(media_expectations));
}
+// Tests that send only works without the caller having a decoder factory and
+// the callee having an encoder factory.
+TEST_P(PeerConnectionIntegrationTest, EndToEndCallWithSendOnlyVideo) {
+ ASSERT_TRUE(
+ CreateOneDirectionalPeerConnectionWrappers(/*caller_to_callee=*/true));
+ ConnectFakeSignaling();
+ // Add one-directional video, from caller to callee.
+ rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track =
+ caller()->CreateLocalVideoTrack();
+ caller()->AddTrack(caller_track);
+ PeerConnectionInterface::RTCOfferAnswerOptions options;
+ options.offer_to_receive_video = 0;
+ caller()->SetOfferAnswerOptions(options);
+ caller()->CreateAndSetAndSignalOffer();
+ ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+ ASSERT_EQ(callee()->pc()->GetReceivers().size(), 1u);
+
+ // Expect video to be received in one direction.
+ MediaExpectations media_expectations;
+ media_expectations.CallerExpectsNoVideo();
+ media_expectations.CalleeExpectsSomeVideo();
+
+ EXPECT_TRUE(ExpectNewFrames(media_expectations));
+}
+
+// Tests that receive only works without the caller having an encoder factory
+// and the callee having a decoder factory.
+TEST_P(PeerConnectionIntegrationTest, EndToEndCallWithReceiveOnlyVideo) {
+ ASSERT_TRUE(
+ CreateOneDirectionalPeerConnectionWrappers(/*caller_to_callee=*/false));
+ ConnectFakeSignaling();
+ // Add one-directional video, from callee to caller.
+ rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track =
+ callee()->CreateLocalVideoTrack();
+ callee()->AddTrack(callee_track);
+ PeerConnectionInterface::RTCOfferAnswerOptions options;
+ options.offer_to_receive_video = 1;
+ caller()->SetOfferAnswerOptions(options);
+ caller()->CreateAndSetAndSignalOffer();
+ ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+ ASSERT_EQ(caller()->pc()->GetReceivers().size(), 1u);
+
+ // Expect video to be received in one direction.
+ MediaExpectations media_expectations;
+ media_expectations.CallerExpectsSomeVideo();
+ media_expectations.CalleeExpectsNoVideo();
+
+ EXPECT_TRUE(ExpectNewFrames(media_expectations));
+}
+
+TEST_P(PeerConnectionIntegrationTest,
+ EndToEndCallAddReceiveVideoToSendOnlyCall) {
+ ASSERT_TRUE(CreatePeerConnectionWrappers());
+ ConnectFakeSignaling();
+ // Add one-directional video, from caller to callee.
+ rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track =
+ caller()->CreateLocalVideoTrack();
+ caller()->AddTrack(caller_track);
+ caller()->CreateAndSetAndSignalOffer();
+ ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+
+ // Add receive video.
+ rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track =
+ callee()->CreateLocalVideoTrack();
+ callee()->AddTrack(callee_track);
+ caller()->CreateAndSetAndSignalOffer();
+ ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+
+ // Ensure that video frames are received end-to-end.
+ MediaExpectations media_expectations;
+ media_expectations.ExpectBidirectionalVideo();
+ ASSERT_TRUE(ExpectNewFrames(media_expectations));
+}
+
+TEST_P(PeerConnectionIntegrationTest,
+ EndToEndCallAddSendVideoToReceiveOnlyCall) {
+ ASSERT_TRUE(CreatePeerConnectionWrappers());
+ ConnectFakeSignaling();
+ // Add one-directional video, from callee to caller.
+ rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track =
+ callee()->CreateLocalVideoTrack();
+ callee()->AddTrack(callee_track);
+ caller()->CreateAndSetAndSignalOffer();
+ ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+
+ // Add send video.
+ rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track =
+ caller()->CreateLocalVideoTrack();
+ caller()->AddTrack(caller_track);
+ caller()->CreateAndSetAndSignalOffer();
+ ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+
+ // Expect video to be received in one direction.
+ MediaExpectations media_expectations;
+ media_expectations.ExpectBidirectionalVideo();
+ ASSERT_TRUE(ExpectNewFrames(media_expectations));
+}
+
+TEST_P(PeerConnectionIntegrationTest,
+ EndToEndCallRemoveReceiveVideoFromSendReceiveCall) {
+ ASSERT_TRUE(CreatePeerConnectionWrappers());
+ ConnectFakeSignaling();
+ // Add send video, from caller to callee.
+ rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track =
+ caller()->CreateLocalVideoTrack();
+ rtc::scoped_refptr<webrtc::RtpSenderInterface> caller_sender =
+ caller()->AddTrack(caller_track);
+ // Add receive video, from callee to caller.
+ rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track =
+ callee()->CreateLocalVideoTrack();
+
+ rtc::scoped_refptr<webrtc::RtpSenderInterface> callee_sender =
+ callee()->AddTrack(callee_track);
+ caller()->CreateAndSetAndSignalOffer();
+ ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+
+ // Remove receive video (i.e., callee sender track).
+ callee()->pc()->RemoveTrack(callee_sender);
+
+ caller()->CreateAndSetAndSignalOffer();
+ ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+
+ // Expect one-directional video.
+ MediaExpectations media_expectations;
+ media_expectations.CallerExpectsNoVideo();
+ media_expectations.CalleeExpectsSomeVideo();
+
+ ASSERT_TRUE(ExpectNewFrames(media_expectations));
+}
+
+TEST_P(PeerConnectionIntegrationTest,
+ EndToEndCallRemoveSendVideoFromSendReceiveCall) {
+ ASSERT_TRUE(CreatePeerConnectionWrappers());
+ ConnectFakeSignaling();
+ // Add send video, from caller to callee.
+ rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track =
+ caller()->CreateLocalVideoTrack();
+ rtc::scoped_refptr<webrtc::RtpSenderInterface> caller_sender =
+ caller()->AddTrack(caller_track);
+ // Add receive video, from callee to caller.
+ rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track =
+ callee()->CreateLocalVideoTrack();
+
+ rtc::scoped_refptr<webrtc::RtpSenderInterface> callee_sender =
+ callee()->AddTrack(callee_track);
+ caller()->CreateAndSetAndSignalOffer();
+ ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+
+ // Remove send video (i.e., caller sender track).
+ caller()->pc()->RemoveTrack(caller_sender);
+
+ caller()->CreateAndSetAndSignalOffer();
+ ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+
+ // Expect one-directional video.
+ MediaExpectations media_expectations;
+ media_expectations.CalleeExpectsNoVideo();
+ media_expectations.CallerExpectsSomeVideo();
+
+ ASSERT_TRUE(ExpectNewFrames(media_expectations));
+}
+
// This test sets up a audio call initially, with the callee rejecting video
// initially. Then later the callee decides to upgrade to audio/video, and
// initiates a new offer/answer exchange.
@@ -2539,6 +2744,37 @@
ASSERT_TRUE(ExpectNewFrames(media_expectations));
}
+TEST_F(PeerConnectionIntegrationTestUnifiedPlan,
+ EndToEndCallAddReceiveVideoToSendOnlyCall) {
+ ASSERT_TRUE(CreatePeerConnectionWrappers());
+ ConnectFakeSignaling();
+ // Add one-directional video, from caller to callee.
+ rtc::scoped_refptr<webrtc::VideoTrackInterface> track =
+ caller()->CreateLocalVideoTrack();
+
+ RtpTransceiverInit video_transceiver_init;
+ video_transceiver_init.stream_ids = {"video1"};
+ video_transceiver_init.direction = RtpTransceiverDirection::kSendOnly;
+ auto video_sender =
+ caller()->pc()->AddTransceiver(track, video_transceiver_init).MoveValue();
+ caller()->CreateAndSetAndSignalOffer();
+ ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+
+ // Add receive direction.
+ video_sender->SetDirection(RtpTransceiverDirection::kSendRecv);
+
+ rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track =
+ callee()->CreateLocalVideoTrack();
+
+ callee()->AddTrack(callee_track);
+ caller()->CreateAndSetAndSignalOffer();
+ ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
+ // Ensure that video frames are received end-to-end.
+ MediaExpectations media_expectations;
+ media_expectations.ExpectBidirectionalVideo();
+ ASSERT_TRUE(ExpectNewFrames(media_expectations));
+}
+
// Tests that video flows between multiple video tracks when SSRCs are not
// signaled. This exercises the MID RTP header extension which is needed to
// demux the incoming video tracks.
@@ -5459,9 +5695,10 @@
auto ice_transport_factory = std::make_unique<MockIceTransportFactory>();
EXPECT_CALL(*ice_transport_factory, RecordIceTransportCreated()).Times(1);
dependencies.ice_transport_factory = std::move(ice_transport_factory);
- auto wrapper =
- CreatePeerConnectionWrapper("Caller", nullptr, &default_config,
- std::move(dependencies), nullptr, nullptr);
+ auto wrapper = CreatePeerConnectionWrapper(
+ "Caller", nullptr, &default_config, std::move(dependencies), nullptr,
+ nullptr, /*reset_encoder_factory=*/false,
+ /*reset_decoder_factory=*/false);
ASSERT_TRUE(wrapper);
wrapper->CreateDataChannel();
rtc::scoped_refptr<MockSetSessionDescriptionObserver> observer(
diff --git a/pc/peer_connection_media_unittest.cc b/pc/peer_connection_media_unittest.cc
index 077c4a3..c9ffd77 100644
--- a/pc/peer_connection_media_unittest.cc
+++ b/pc/peer_connection_media_unittest.cc
@@ -1434,9 +1434,11 @@
TEST_F(PeerConnectionMediaTestUnifiedPlan,
SetCodecPreferencesVideoRejectsOnlyRtxRedFec) {
auto fake_engine = std::make_unique<FakeMediaEngine>();
- auto video_codecs = fake_engine->video().codecs();
+ auto video_codecs = fake_engine->video().send_codecs();
video_codecs.push_back(
cricket::VideoCodec(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::VideoCodec(video_codecs.back().id + 1, cricket::kRedCodecName));
video_codecs.push_back(cricket::VideoCodec(video_codecs.back().id + 1,
@@ -1540,7 +1542,7 @@
TEST_F(PeerConnectionMediaTestUnifiedPlan, SetCodecPreferencesVideoWithRtx) {
auto caller_fake_engine = std::make_unique<FakeMediaEngine>();
- auto caller_video_codecs = caller_fake_engine->video().codecs();
+ auto caller_video_codecs = caller_fake_engine->video().send_codecs();
caller_video_codecs.push_back(cricket::VideoCodec(
caller_video_codecs.back().id + 1, cricket::kVp8CodecName));
caller_video_codecs.push_back(cricket::VideoCodec(
@@ -1592,7 +1594,7 @@
TEST_F(PeerConnectionMediaTestUnifiedPlan,
SetCodecPreferencesVideoCodecsNegotiation) {
auto caller_fake_engine = std::make_unique<FakeMediaEngine>();
- auto caller_video_codecs = caller_fake_engine->video().codecs();
+ auto caller_video_codecs = caller_fake_engine->video().send_codecs();
caller_video_codecs.push_back(cricket::VideoCodec(
caller_video_codecs.back().id + 1, cricket::kVp8CodecName));
caller_video_codecs.push_back(cricket::VideoCodec(
@@ -1666,7 +1668,7 @@
TEST_F(PeerConnectionMediaTestUnifiedPlan,
SetCodecPreferencesVideoCodecsNegotiationReverseOrder) {
auto caller_fake_engine = std::make_unique<FakeMediaEngine>();
- auto caller_video_codecs = caller_fake_engine->video().codecs();
+ auto caller_video_codecs = caller_fake_engine->video().send_codecs();
caller_video_codecs.push_back(cricket::VideoCodec(
caller_video_codecs.back().id + 1, cricket::kVp8CodecName));
caller_video_codecs.push_back(cricket::VideoCodec(
diff --git a/pc/rtp_transceiver.cc b/pc/rtp_transceiver.cc
index ca57b91..d6e5ff4 100644
--- a/pc/rtp_transceiver.cc
+++ b/pc/rtp_transceiver.cc
@@ -22,6 +22,82 @@
#include "rtc_base/logging.h"
namespace webrtc {
+namespace {
+template <class T>
+RTCError VerifyCodecPreferences(const std::vector<RtpCodecCapability>& codecs,
+ const std::vector<T>& send_codecs,
+ const std::vector<T>& recv_codecs) {
+ // If the intersection between codecs and
+ // RTCRtpSender.getCapabilities(kind).codecs or the intersection between
+ // codecs and RTCRtpReceiver.getCapabilities(kind).codecs only contains RTX,
+ // RED or FEC codecs or is an empty set, throw InvalidModificationError.
+ // This ensures that we always have something to offer, regardless of
+ // transceiver.direction.
+
+ if (!absl::c_any_of(codecs, [&recv_codecs](const RtpCodecCapability& codec) {
+ return codec.name != cricket::kRtxCodecName &&
+ codec.name != cricket::kRedCodecName &&
+ codec.name != cricket::kFlexfecCodecName &&
+ absl::c_any_of(recv_codecs, [&codec](const T& recv_codec) {
+ return recv_codec.MatchesCapability(codec);
+ });
+ })) {
+ return RTCError(RTCErrorType::INVALID_MODIFICATION,
+ "Invalid codec preferences: Missing codec from recv "
+ "codec capabilities.");
+ }
+
+ if (!absl::c_any_of(codecs, [&send_codecs](const RtpCodecCapability& codec) {
+ return codec.name != cricket::kRtxCodecName &&
+ codec.name != cricket::kRedCodecName &&
+ codec.name != cricket::kFlexfecCodecName &&
+ absl::c_any_of(send_codecs, [&codec](const T& send_codec) {
+ return send_codec.MatchesCapability(codec);
+ });
+ })) {
+ return RTCError(RTCErrorType::INVALID_MODIFICATION,
+ "Invalid codec preferences: Missing codec from send "
+ "codec capabilities.");
+ }
+
+ // Let codecCapabilities be the union of
+ // RTCRtpSender.getCapabilities(kind).codecs and
+ // RTCRtpReceiver.getCapabilities(kind).codecs. For each codec in codecs, If
+ // codec is not in codecCapabilities, throw InvalidModificationError.
+ for (const auto& codec_preference : codecs) {
+ bool is_recv_codec =
+ absl::c_any_of(recv_codecs, [&codec_preference](const T& codec) {
+ return codec.MatchesCapability(codec_preference);
+ });
+
+ bool is_send_codec =
+ absl::c_any_of(send_codecs, [&codec_preference](const T& codec) {
+ return codec.MatchesCapability(codec_preference);
+ });
+
+ if (!is_recv_codec && !is_send_codec) {
+ return RTCError(
+ RTCErrorType::INVALID_MODIFICATION,
+ std::string("Invalid codec preferences: invalid codec with name \"") +
+ codec_preference.name + "\".");
+ }
+ }
+
+ // Check we have a real codec (not just rtx, red or fec)
+ if (absl::c_all_of(codecs, [](const RtpCodecCapability& codec) {
+ return codec.name == cricket::kRtxCodecName ||
+ codec.name == cricket::kRedCodecName ||
+ codec.name == cricket::kUlpfecCodecName;
+ })) {
+ return RTCError(RTCErrorType::INVALID_MODIFICATION,
+ "Invalid codec preferences: codec list must have a non "
+ "RTX, RED or FEC entry.");
+ }
+
+ return RTCError::OK();
+}
+
+} // namespace
RtpTransceiver::RtpTransceiver(cricket::MediaType media_type)
: unified_plan_(false), media_type_(media_type) {
@@ -255,111 +331,27 @@
return absl::c_linear_search(codecs, codec);
});
+ // 6. to 8.
+ RTCError result;
if (media_type_ == cricket::MEDIA_TYPE_AUDIO) {
- std::vector<cricket::AudioCodec> audio_codecs;
-
std::vector<cricket::AudioCodec> recv_codecs, send_codecs;
channel_manager_->GetSupportedAudioReceiveCodecs(&recv_codecs);
channel_manager_->GetSupportedAudioSendCodecs(&send_codecs);
- // 6. If the intersection between codecs and
- // RTCRtpSender.getCapabilities(kind).codecs or the intersection between
- // codecs and RTCRtpReceiver.getCapabilities(kind).codecs only contains RTX,
- // RED or FEC codecs or is an empty set, throw InvalidModificationError.
- // This ensures that we always have something to offer, regardless of
- // transceiver.direction.
-
- if (!absl::c_any_of(
- codecs, [&recv_codecs](const RtpCodecCapability& codec) {
- return codec.name != cricket::kRtxCodecName &&
- codec.name != cricket::kRedCodecName &&
- codec.name != cricket::kFlexfecCodecName &&
- absl::c_any_of(
- recv_codecs,
- [&codec](const cricket::AudioCodec& recv_codec) {
- return recv_codec.MatchesCapability(codec);
- });
- })) {
- return RTCError(RTCErrorType::INVALID_MODIFICATION,
- "Invalid codec preferences: Missing codec from recv "
- "codec capabilities.");
- }
-
- if (!absl::c_any_of(
- codecs, [&send_codecs](const RtpCodecCapability& codec) {
- return codec.name != cricket::kRtxCodecName &&
- codec.name != cricket::kRedCodecName &&
- codec.name != cricket::kFlexfecCodecName &&
- absl::c_any_of(
- send_codecs,
- [&codec](const cricket::AudioCodec& send_codec) {
- return send_codec.MatchesCapability(codec);
- });
- })) {
- return RTCError(RTCErrorType::INVALID_MODIFICATION,
- "Invalid codec preferences: Missing codec from send "
- "codec capabilities.");
- }
-
- // 7. Let codecCapabilities be the union of
- // RTCRtpSender.getCapabilities(kind).codecs and
- // RTCRtpReceiver.getCapabilities(kind).codecs. 8.1 For each codec in
- // codecs, If codec is not in codecCapabilities, throw
- // InvalidModificationError.
- for (const auto& codec_preference : codecs) {
- bool is_recv_codec = absl::c_any_of(
- recv_codecs, [&codec_preference](const cricket::AudioCodec& codec) {
- return codec.MatchesCapability(codec_preference);
- });
-
- bool is_send_codec = absl::c_any_of(
- send_codecs, [&codec_preference](const cricket::AudioCodec& codec) {
- return codec.MatchesCapability(codec_preference);
- });
-
- if (!is_recv_codec && !is_send_codec) {
- return RTCError(
- RTCErrorType::INVALID_MODIFICATION,
- std::string(
- "Invalid codec preferences: invalid codec with name \"") +
- codec_preference.name + "\".");
- }
- }
+ result = VerifyCodecPreferences(codecs, send_codecs, recv_codecs);
} else if (media_type_ == cricket::MEDIA_TYPE_VIDEO) {
- std::vector<cricket::VideoCodec> video_codecs;
- // Video codecs are both for the receive and send side, so the checks are
- // simpler than the audio ones.
- channel_manager_->GetSupportedVideoCodecs(&video_codecs);
+ std::vector<cricket::VideoCodec> recv_codecs, send_codecs;
+ channel_manager_->GetSupportedVideoReceiveCodecs(&recv_codecs);
+ channel_manager_->GetSupportedVideoSendCodecs(&send_codecs);
- // Validate codecs
- for (const auto& codec_preference : codecs) {
- if (!absl::c_any_of(video_codecs, [&codec_preference](
- const cricket::VideoCodec& codec) {
- return codec.MatchesCapability(codec_preference);
- })) {
- return RTCError(
- RTCErrorType::INVALID_MODIFICATION,
- std::string(
- "Invalid codec preferences: invalid codec with name \"") +
- codec_preference.name + "\".");
- }
- }
+ result = VerifyCodecPreferences(codecs, send_codecs, recv_codecs);
}
- // Check we have a real codec (not just rtx, red or fec)
- if (absl::c_all_of(codecs, [](const RtpCodecCapability& codec) {
- return codec.name == cricket::kRtxCodecName ||
- codec.name == cricket::kRedCodecName ||
- codec.name == cricket::kUlpfecCodecName;
- })) {
- return RTCError(RTCErrorType::INVALID_MODIFICATION,
- "Invalid codec preferences: codec list must have a non "
- "RTX, RED or FEC entry.");
+ if (result.ok()) {
+ codec_preferences_ = codecs;
}
- codec_preferences_ = codecs;
-
- return RTCError::OK();
+ return result;
}
std::vector<RtpHeaderExtensionCapability>
