mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-17 07:37:51 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Reland "Reland "Reland "Distinguish between send and receive video codecs"""

Browse source 
This is a reland of 4e64e60589

This CL lands all code except the code that activates the change,
see media/engine/webrtc_video_engine.cc
Once downstream projects are fixed, there will be a one-line change to
activate the change to distinguish between send and receive video codecs.

Original change's description:
> Reland "Reland "Distinguish between send and receive video codecs""
>
> This is a reland of 77eb338ae4
>
> Original change's description:
> > Reland "Distinguish between send and receive video codecs"
> >
> > This reverts commit f2d6fe62f2.
> >
> > Reason for revert: Downstream test updated.
> >
> > Original change's description:
> > > Revert "Reland "Distinguish between send and receive video codecs""
> > >
> > > This reverts commit 26e6afe93f.
> > >
> > > Reason for revert: Breaks another downstream test.
> > >
> > > Original change's description:
> > > > Reland "Distinguish between send and receive video codecs"
> > > >
> > > > This reverts commit f22af3cca7.
> > > >
> > > > Reason for revert: Downstream tests have been updated.
> > > >
> > > > Original change's description:
> > > > > Revert "Distinguish between send and receive video codecs"
> > > > >
> > > > > This reverts commit 18314bd8d2.
> > > > >
> > > > > Reason for revert: Breaks downstream test.
> > > > >
> > > > > Original change's description:
> > > > > > Distinguish between send and receive video codecs
> > > > > >
> > > > > > Even though send and receive codecs are 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: I16a80da44c5061ca42f2aabda76e6bf0b879bf7b
> > > > > > Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161306
> > > > > > Reviewed-by: Anders Carlsson <andersc@webrtc.org>
> > > > > > Reviewed-by: Steve Anton <steveanton@webrtc.org>
> > > > > > Commit-Queue: Johannes Kron <kron@webrtc.org>
> > > > > > Cr-Commit-Position: refs/heads/master@{#30041}
> > > > >
> > > > > TBR=steveanton@webrtc.org,andersc@webrtc.org,kron@webrtc.org
> > > > >
> > > > > Change-Id: I7e5807460006db613e9b3b369ec6036b88f164fd
> > > > > No-Presubmit: true
> > > > > No-Tree-Checks: true
> > > > > No-Try: true
> > > > > Bug: chromium:1029737
> > > > > Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161662
> > > > > Reviewed-by: Johannes Kron <kron@webrtc.org>
> > > > > Commit-Queue: Johannes Kron <kron@webrtc.org>
> > > > > Cr-Commit-Position: refs/heads/master@{#30042}
> > > >
> > > > TBR=steveanton@webrtc.org,andersc@webrtc.org,kron@webrtc.org
> > > >
> > > > # Not skipping CQ checks because original CL landed > 1 day ago.
> > > >
> > > > Bug: chromium:1029737
> > > > Change-Id: Ia70b11376b43888e2495ef21838c2d2e3c68d735
> > > > Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/161734
> > > > Reviewed-by: Johannes Kron <kron@webrtc.org>
> > > > Reviewed-by: Steve Anton <steveanton@webrtc.org>
> > > > Reviewed-by: Anders Carlsson <andersc@webrtc.org>
> > > > Commit-Queue: Johannes Kron <kron@webrtc.org>
> > > > Cr-Commit-Position: refs/heads/master@{#30078}
> > >
> > > TBR=steveanton@webrtc.org,andersc@webrtc.org,kron@webrtc.org
> > >
> > > Change-Id: Ia4971b898c9209a3736a916a1c2c48d392dfdad6
> > > No-Presubmit: true
> > > No-Tree-Checks: true
> > > No-Try: true
> > > Bug: chromium:1029737
> > > Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/162140
> > > Reviewed-by: Johannes Kron <kron@webrtc.org>
> > > Commit-Queue: Johannes Kron <kron@webrtc.org>
> > > Cr-Commit-Position: refs/heads/master@{#30079}
> >
> > TBR=steveanton@webrtc.org,andersc@webrtc.org,kron@webrtc.org
> >
> > # Not skipping CQ checks because original CL landed > 1 day ago.
> >
> > Bug: chromium:1029737
> > Change-Id: If2c3c5b5e7d86cb852a1f20f02b6ceae62b2e0c8
> > Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/162186
> > Reviewed-by: Johannes Kron <kron@webrtc.org>
> > Reviewed-by: Anders Carlsson <andersc@webrtc.org>
> > Reviewed-by: Steve Anton <steveanton@webrtc.org>
> > Commit-Queue: Johannes Kron <kron@webrtc.org>
> > Cr-Commit-Position: refs/heads/master@{#30097}
>
> Bug: chromium:1029737
> Change-Id: I5912822df8169fbb3097c0f440f7924527fa950b
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/162483
> Reviewed-by: Steve Anton <steveanton@webrtc.org>
> Reviewed-by: Anders Carlsson <andersc@webrtc.org>
> Commit-Queue: Johannes Kron <kron@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#30120}

Bug: chromium:1029737
Change-Id: Id4f1c6f6f0cf7b96fe93dd22d14310d286af31f3
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/165682
Reviewed-by: Steve Anton <steveanton@webrtc.org>
Reviewed-by: Anders Carlsson <andersc@webrtc.org>
Commit-Queue: Johannes Kron <kron@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#30219}
This commit is contained in:
Johannes Kron 2019-12-16 09:54:07 +00:00 committed by Commit Bot
parent 0e3a3f6b1d
commit 9cad4dccc9
13 changed files with 196 additions and 110 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
api/test/video/function_video_decoder_factory.h
View file

@ -33,11 +33,14 @@ class FunctionVideoDecoderFactory final : public VideoDecoderFactory {
std::function<std::unique_ptr<VideoDecoder>(const SdpVideoFormat&)> std::function<std::unique_ptr<VideoDecoder>(const SdpVideoFormat&)>
create) create)
: create_(std::move(create)) {} : create_(std::move(create)) {}
FunctionVideoDecoderFactory(
std::function<std::unique_ptr<VideoDecoder>()> create,
std::vector<SdpVideoFormat> sdp_video_formats)
: create_([create](const SdpVideoFormat&) { return create(); }),
sdp_video_formats_(sdp_video_formats) {}
// Unused by tests.
std::vector<SdpVideoFormat> GetSupportedFormats() const override { std::vector<SdpVideoFormat> GetSupportedFormats() const override {
RTC_NOTREACHED(); return sdp_video_formats_;
return {};
} }
std::unique_ptr<VideoDecoder> CreateVideoDecoder( std::unique_ptr<VideoDecoder> CreateVideoDecoder(
@ -48,6 +51,7 @@ class FunctionVideoDecoderFactory final : public VideoDecoderFactory {
private: private:
const std::function<std::unique_ptr<VideoDecoder>(const SdpVideoFormat&)> const std::function<std::unique_ptr<VideoDecoder>(const SdpVideoFormat&)>
create_; create_;
const std::vector<SdpVideoFormat> sdp_video_formats_;
}; };
} // namespace test } // namespace test

24
media/base/fake_media_engine.cc
View file

@ -567,7 +567,8 @@ FakeVideoEngine::FakeVideoEngine()
: capture_(false), fail_create_channel_(false) { : capture_(false), fail_create_channel_(false) {
// Add a fake video codec. Note that the name must not be "" as there are // Add a fake video codec. Note that the name must not be "" as there are
// sanity checks against that. // 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"));
} }
RtpCapabilities FakeVideoEngine::GetCapabilities() const { RtpCapabilities FakeVideoEngine::GetCapabilities() const {
return RtpCapabilities(); return RtpCapabilities();
@ -598,12 +599,22 @@ void FakeVideoEngine::UnregisterChannel(VideoMediaChannel* channel) {
RTC_DCHECK(it != channels_.end()); RTC_DCHECK(it != channels_.end());
channels_.erase(it); channels_.erase(it);
} }
std::vector<VideoCodec> FakeVideoEngine::codecs() const { std::vector<VideoCodec> FakeVideoEngine::send_codecs() const {
return codecs_; 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) { bool FakeVideoEngine::SetCapture(bool capture) {
capture_ = capture; capture_ = capture;
return true; return true;
@ -627,7 +638,8 @@ void FakeMediaEngine::SetAudioSendCodecs(
voice_->SetSendCodecs(codecs); voice_->SetSendCodecs(codecs);
} }
void FakeMediaEngine::SetVideoCodecs(const std::vector<VideoCodec>& codecs) { void FakeMediaEngine::SetVideoCodecs(const std::vector<VideoCodec>& codecs) {
video_->SetCodecs(codecs); video_->SetSendCodecs(codecs);
video_->SetRecvCodecs(codecs);
} }
FakeVoiceMediaChannel* FakeMediaEngine::GetVoiceChannel(size_t index) { FakeVoiceMediaChannel* FakeMediaEngine::GetVoiceChannel(size_t index) {

9
media/base/fake_media_engine.h
View file

@ -559,13 +559,16 @@ class FakeVideoEngine : public VideoEngineInterface {
override; override;
FakeVideoMediaChannel* GetChannel(size_t index); FakeVideoMediaChannel* GetChannel(size_t index);
void UnregisterChannel(VideoMediaChannel* channel); void UnregisterChannel(VideoMediaChannel* channel);
std::vector<VideoCodec> codecs() const override; std::vector<VideoCodec> send_codecs() const override;
void SetCodecs(const std::vector<VideoCodec> codecs); 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); bool SetCapture(bool capture);
private: private:
std::vector<FakeVideoMediaChannel*> channels_; std::vector<FakeVideoMediaChannel*> channels_;
std::vector<VideoCodec> codecs_; std::vector<VideoCodec> send_codecs_;
std::vector<VideoCodec> recv_codecs_;
bool capture_; bool capture_;
VideoOptions options_; VideoOptions options_;
bool fail_create_channel_; bool fail_create_channel_;

4
media/base/media_engine.h
View file

@ -99,7 +99,9 @@ class VideoEngineInterface {
webrtc::VideoBitrateAllocatorFactory* webrtc::VideoBitrateAllocatorFactory*
video_bitrate_allocator_factory) = 0; 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;
virtual RtpCapabilities GetCapabilities() const = 0; virtual RtpCapabilities GetCapabilities() const = 0;
}; };

8
media/engine/fake_webrtc_video_engine.cc
View file

@ -117,6 +117,14 @@ void FakeWebRtcVideoDecoderFactory::AddSupportedVideoCodecType(
supported_codec_formats_.push_back(format); supported_codec_formats_.push_back(format);
} }
void FakeWebRtcVideoDecoderFactory::AddSupportedVideoCodecType(
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() { int FakeWebRtcVideoDecoderFactory::GetNumCreatedDecoders() {
return num_created_decoders_; return num_created_decoders_;
} }

1
media/engine/fake_webrtc_video_engine.h
View file

@ -68,6 +68,7 @@ class FakeWebRtcVideoDecoderFactory : public webrtc::VideoDecoderFactory {
void DecoderDestroyed(FakeWebRtcVideoDecoder* decoder); void DecoderDestroyed(FakeWebRtcVideoDecoder* decoder);
void AddSupportedVideoCodecType(const webrtc::SdpVideoFormat& format); void AddSupportedVideoCodecType(const webrtc::SdpVideoFormat& format);
void AddSupportedVideoCodecType(const std::string& name);
int GetNumCreatedDecoders(); int GetNumCreatedDecoders();
const std::vector<FakeWebRtcVideoDecoder*>& decoders(); const std::vector<FakeWebRtcVideoDecoder*>& decoders();

6
media/engine/null_webrtc_video_engine.h
View file

@ -30,7 +30,11 @@ class VideoMediaChannel;
// CompositeMediaEngine. // CompositeMediaEngine.
class NullWebRtcVideoEngine : public VideoEngineInterface { class NullWebRtcVideoEngine : public VideoEngineInterface {
public: 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>(); return std::vector<VideoCodec>();
} }

25
media/engine/webrtc_video_engine.cc
View file

@ -139,11 +139,11 @@ std::vector<VideoCodec> AssignPayloadTypesAndDefaultCodecs(
return output_codecs; return output_codecs;
} }
std::vector<VideoCodec> AssignPayloadTypesAndDefaultCodecs( template <class T>
const webrtc::VideoEncoderFactory* encoder_factory) { std::vector<VideoCodec> GetPayloadTypesAndDefaultCodecs(const T factory) {
return encoder_factory ? AssignPayloadTypesAndDefaultCodecs( return factory ? AssignPayloadTypesAndDefaultCodecs(
encoder_factory->GetSupportedFormats()) factory->GetSupportedFormats())
: std::vector<VideoCodec>(); : std::vector<VideoCodec>();
} }
bool IsTemporalLayersSupported(const std::string& codec_name) { bool IsTemporalLayersSupported(const std::string& codec_name) {
@ -476,8 +476,14 @@ VideoMediaChannel* WebRtcVideoEngine::CreateMediaChannel(
encoder_factory_.get(), decoder_factory_.get(), encoder_factory_.get(), decoder_factory_.get(),
video_bitrate_allocator_factory); video_bitrate_allocator_factory);
} }
std::vector<VideoCodec> WebRtcVideoEngine::codecs() const { std::vector<VideoCodec> WebRtcVideoEngine::send_codecs() const {
return AssignPayloadTypesAndDefaultCodecs(encoder_factory_.get()); return GetPayloadTypesAndDefaultCodecs(encoder_factory_.get());
}
std::vector<VideoCodec> WebRtcVideoEngine::recv_codecs() const {
// TODO(kron): Change to decoder_factory_ once incorrect configuration in
// downstream projects have been fixed.
return GetPayloadTypesAndDefaultCodecs(encoder_factory_.get());
} }
RtpCapabilities WebRtcVideoEngine::GetCapabilities() const { RtpCapabilities WebRtcVideoEngine::GetCapabilities() const {
@ -547,8 +553,7 @@ WebRtcVideoChannel::WebRtcVideoChannel(
rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc; rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
sending_ = false; sending_ = false;
recv_codecs_ = recv_codecs_ = MapCodecs(GetPayloadTypesAndDefaultCodecs(decoder_factory_));
MapCodecs(AssignPayloadTypesAndDefaultCodecs(encoder_factory_));
recv_flexfec_payload_type_ = recv_codecs_.front().flexfec_payload_type; recv_flexfec_payload_type_ = recv_codecs_.front().flexfec_payload_type;
} }
@ -973,7 +978,7 @@ bool WebRtcVideoChannel::GetChangedRecvParameters(
// Verify that every mapped codec is supported locally. // Verify that every mapped codec is supported locally.
const std::vector<VideoCodec> local_supported_codecs = const std::vector<VideoCodec> local_supported_codecs =
AssignPayloadTypesAndDefaultCodecs(encoder_factory_); GetPayloadTypesAndDefaultCodecs(decoder_factory_);
for (const VideoCodecSettings& mapped_codec : mapped_codecs) { for (const VideoCodecSettings& mapped_codec : mapped_codecs) {
if (!FindMatchingCodec(local_supported_codecs, mapped_codec.codec)) { if (!FindMatchingCodec(local_supported_codecs, mapped_codec.codec)) {
RTC_LOG(LS_ERROR) RTC_LOG(LS_ERROR)

3
media/engine/webrtc_video_engine.h
View file

@ -97,7 +97,8 @@ class WebRtcVideoEngine : public VideoEngineInterface {
webrtc::VideoBitrateAllocatorFactory* video_bitrate_allocator_factory) webrtc::VideoBitrateAllocatorFactory* video_bitrate_allocator_factory)
override; override;
std::vector<VideoCodec> codecs() const override; std::vector<VideoCodec> send_codecs() const override;
std::vector<VideoCodec> recv_codecs() const override;
RtpCapabilities GetCapabilities() const override; RtpCapabilities GetCapabilities() const override;
private: private:

159
media/engine/webrtc_video_engine_unittest.cc
View file

@ -265,7 +265,7 @@ class WebRtcVideoEngineTest : public ::testing::Test {
// Find the codec in the engine with the given name. The codec must be // Find the codec in the engine with the given name. The codec must be
// present. // present.
cricket::VideoCodec GetEngineCodec(const std::string& name) const; cricket::VideoCodec GetEngineCodec(const std::string& name) const;
void AddSupportedVideoCodecType(const std::string& name);
VideoMediaChannel* SetSendParamsWithAllSupportedCodecs(); VideoMediaChannel* SetSendParamsWithAllSupportedCodecs();
VideoMediaChannel* SetRecvParamsWithSupportedCodecs( VideoMediaChannel* SetRecvParamsWithSupportedCodecs(
@ -296,7 +296,7 @@ TEST_F(WebRtcVideoEngineTest, DefaultRtxCodecHasAssociatedPayloadTypeSet) {
encoder_factory_->AddSupportedVideoCodecType("VP8"); encoder_factory_->AddSupportedVideoCodecType("VP8");
AssignDefaultCodec(); 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) { for (size_t i = 0; i < engine_codecs.size(); ++i) {
if (engine_codecs[i].name != kRtxCodecName) if (engine_codecs[i].name != kRtxCodecName)
continue; continue;
@ -375,7 +375,7 @@ TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionBeforeCapturer) {
// dtor is called. // dtor is called.
::testing::NiceMock<MockVideoSource> video_source; ::testing::NiceMock<MockVideoSource> video_source;
encoder_factory_->AddSupportedVideoCodecType("VP8"); AddSupportedVideoCodecType("VP8");
std::unique_ptr<VideoMediaChannel> channel( std::unique_ptr<VideoMediaChannel> channel(
SetSendParamsWithAllSupportedCodecs()); SetSendParamsWithAllSupportedCodecs());
@ -414,7 +414,7 @@ TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionBeforeAddSendStream) {
// dtor is called. // dtor is called.
::testing::NiceMock<MockVideoSource> video_source; ::testing::NiceMock<MockVideoSource> video_source;
encoder_factory_->AddSupportedVideoCodecType("VP8"); AddSupportedVideoCodecType("VP8");
std::unique_ptr<VideoMediaChannel> channel( std::unique_ptr<VideoMediaChannel> channel(
SetSendParamsWithAllSupportedCodecs()); SetSendParamsWithAllSupportedCodecs());
@ -438,8 +438,8 @@ TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionBeforeAddSendStream) {
TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionAfterCapturer) { TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionAfterCapturer) {
::testing::NiceMock<MockVideoSource> video_source; ::testing::NiceMock<MockVideoSource> video_source;
encoder_factory_->AddSupportedVideoCodecType("VP8"); AddSupportedVideoCodecType("VP8");
encoder_factory_->AddSupportedVideoCodecType("VP9"); AddSupportedVideoCodecType("VP9");
std::unique_ptr<VideoMediaChannel> channel( std::unique_ptr<VideoMediaChannel> channel(
SetSendParamsWithAllSupportedCodecs()); SetSendParamsWithAllSupportedCodecs());
@ -483,7 +483,7 @@ TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionAfterCapturer) {
} }
TEST_F(WebRtcVideoEngineTest, SetSendFailsBeforeSettingCodecs) { TEST_F(WebRtcVideoEngineTest, SetSendFailsBeforeSettingCodecs) {
encoder_factory_->AddSupportedVideoCodecType("VP8"); AddSupportedVideoCodecType("VP8");
std::unique_ptr<VideoMediaChannel> channel(engine_.CreateMediaChannel( std::unique_ptr<VideoMediaChannel> channel(engine_.CreateMediaChannel(
call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(), call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
@ -498,7 +498,7 @@ TEST_F(WebRtcVideoEngineTest, SetSendFailsBeforeSettingCodecs) {
} }
TEST_F(WebRtcVideoEngineTest, GetStatsWithoutSendCodecsSetDoesNotCrash) { TEST_F(WebRtcVideoEngineTest, GetStatsWithoutSendCodecsSetDoesNotCrash) {
encoder_factory_->AddSupportedVideoCodecType("VP8"); AddSupportedVideoCodecType("VP8");
std::unique_ptr<VideoMediaChannel> channel(engine_.CreateMediaChannel( std::unique_ptr<VideoMediaChannel> channel(engine_.CreateMediaChannel(
call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(), call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
@ -509,7 +509,7 @@ TEST_F(WebRtcVideoEngineTest, GetStatsWithoutSendCodecsSetDoesNotCrash) {
} }
TEST_F(WebRtcVideoEngineTest, UseFactoryForVp8WhenSupported) { TEST_F(WebRtcVideoEngineTest, UseFactoryForVp8WhenSupported) {
encoder_factory_->AddSupportedVideoCodecType("VP8"); AddSupportedVideoCodecType("VP8");
std::unique_ptr<VideoMediaChannel> channel( std::unique_ptr<VideoMediaChannel> channel(
SetSendParamsWithAllSupportedCodecs()); SetSendParamsWithAllSupportedCodecs());
@ -569,7 +569,7 @@ TEST_F(WebRtcVideoEngineTest, RtxCodecAddedForH264Codec) {
encoder_factory_->AddSupportedVideoCodec(h264_high); encoder_factory_->AddSupportedVideoCodec(h264_high);
// First figure out what payload types the test codecs got assigned. // 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 // Now search for RTX codecs for them. Expect that they all have associated
// RTX codecs. // RTX codecs.
EXPECT_TRUE(HasRtxCodec( EXPECT_TRUE(HasRtxCodec(
@ -586,7 +586,7 @@ TEST_F(WebRtcVideoEngineTest, RtxCodecAddedForH264Codec) {
#if defined(RTC_ENABLE_VP9) #if defined(RTC_ENABLE_VP9)
TEST_F(WebRtcVideoEngineTest, CanConstructDecoderForVp9EncoderFactory) { TEST_F(WebRtcVideoEngineTest, CanConstructDecoderForVp9EncoderFactory) {
encoder_factory_->AddSupportedVideoCodecType("VP9"); AddSupportedVideoCodecType("VP9");
std::unique_ptr<VideoMediaChannel> channel( std::unique_ptr<VideoMediaChannel> channel(
SetSendParamsWithAllSupportedCodecs()); SetSendParamsWithAllSupportedCodecs());
@ -597,7 +597,7 @@ TEST_F(WebRtcVideoEngineTest, CanConstructDecoderForVp9EncoderFactory) {
#endif // defined(RTC_ENABLE_VP9) #endif // defined(RTC_ENABLE_VP9)
TEST_F(WebRtcVideoEngineTest, PropagatesInputFrameTimestamp) { TEST_F(WebRtcVideoEngineTest, PropagatesInputFrameTimestamp) {
encoder_factory_->AddSupportedVideoCodecType("VP8"); AddSupportedVideoCodecType("VP8");
FakeCall* fake_call = new FakeCall(); FakeCall* fake_call = new FakeCall();
call_.reset(fake_call); call_.reset(fake_call);
std::unique_ptr<VideoMediaChannel> channel( std::unique_ptr<VideoMediaChannel> channel(
@ -651,7 +651,7 @@ TEST_F(WebRtcVideoEngineTest, PropagatesInputFrameTimestamp) {
} }
void WebRtcVideoEngineTest::AssignDefaultAptRtxTypes() { void WebRtcVideoEngineTest::AssignDefaultAptRtxTypes() {
std::vector<VideoCodec> engine_codecs = engine_.codecs(); std::vector<VideoCodec> engine_codecs = engine_.send_codecs();
RTC_DCHECK(!engine_codecs.empty()); RTC_DCHECK(!engine_codecs.empty());
for (const cricket::VideoCodec& codec : engine_codecs) { for (const cricket::VideoCodec& codec : engine_codecs) {
if (codec.name == "rtx") { if (codec.name == "rtx") {
@ -665,7 +665,7 @@ void WebRtcVideoEngineTest::AssignDefaultAptRtxTypes() {
} }
void WebRtcVideoEngineTest::AssignDefaultCodec() { void WebRtcVideoEngineTest::AssignDefaultCodec() {
std::vector<VideoCodec> engine_codecs = engine_.codecs(); std::vector<VideoCodec> engine_codecs = engine_.send_codecs();
RTC_DCHECK(!engine_codecs.empty()); RTC_DCHECK(!engine_codecs.empty());
bool codec_set = false; bool codec_set = false;
for (const cricket::VideoCodec& codec : engine_codecs) { for (const cricket::VideoCodec& codec : engine_codecs) {
@ -681,7 +681,7 @@ void WebRtcVideoEngineTest::AssignDefaultCodec() {
size_t WebRtcVideoEngineTest::GetEngineCodecIndex( size_t WebRtcVideoEngineTest::GetEngineCodecIndex(
const std::string& name) const { 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) { for (size_t i = 0; i < codecs.size(); ++i) {
const cricket::VideoCodec engine_codec = codecs[i]; const cricket::VideoCodec engine_codec = codecs[i];
if (!absl::EqualsIgnoreCase(name, engine_codec.name)) if (!absl::EqualsIgnoreCase(name, engine_codec.name))
@ -705,7 +705,13 @@ size_t WebRtcVideoEngineTest::GetEngineCodecIndex(
cricket::VideoCodec WebRtcVideoEngineTest::GetEngineCodec( cricket::VideoCodec WebRtcVideoEngineTest::GetEngineCodec(
const std::string& name) const { 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* VideoMediaChannel*
@ -754,7 +760,7 @@ void WebRtcVideoEngineTest::ExpectRtpCapabilitySupport(const char* uri,
} }
TEST_F(WebRtcVideoEngineTest, UsesSimulcastAdapterForVp8Factories) { TEST_F(WebRtcVideoEngineTest, UsesSimulcastAdapterForVp8Factories) {
encoder_factory_->AddSupportedVideoCodecType("VP8"); AddSupportedVideoCodecType("VP8");
std::unique_ptr<VideoMediaChannel> channel( std::unique_ptr<VideoMediaChannel> channel(
SetSendParamsWithAllSupportedCodecs()); SetSendParamsWithAllSupportedCodecs());
@ -791,8 +797,8 @@ TEST_F(WebRtcVideoEngineTest, UsesSimulcastAdapterForVp8Factories) {
} }
TEST_F(WebRtcVideoEngineTest, ChannelWithH264CanChangeToVp8) { TEST_F(WebRtcVideoEngineTest, ChannelWithH264CanChangeToVp8) {
encoder_factory_->AddSupportedVideoCodecType("VP8"); AddSupportedVideoCodecType("VP8");
encoder_factory_->AddSupportedVideoCodecType("H264"); AddSupportedVideoCodecType("H264");
// Frame source. // Frame source.
webrtc::test::FrameForwarder frame_forwarder; webrtc::test::FrameForwarder frame_forwarder;
@ -826,8 +832,8 @@ TEST_F(WebRtcVideoEngineTest, ChannelWithH264CanChangeToVp8) {
TEST_F(WebRtcVideoEngineTest, TEST_F(WebRtcVideoEngineTest,
UsesSimulcastAdapterForVp8WithCombinedVP8AndH264Factory) { UsesSimulcastAdapterForVp8WithCombinedVP8AndH264Factory) {
encoder_factory_->AddSupportedVideoCodecType("VP8"); AddSupportedVideoCodecType("VP8");
encoder_factory_->AddSupportedVideoCodecType("H264"); AddSupportedVideoCodecType("H264");
std::unique_ptr<VideoMediaChannel> channel(engine_.CreateMediaChannel( std::unique_ptr<VideoMediaChannel> channel(engine_.CreateMediaChannel(
call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(), call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
@ -862,8 +868,8 @@ TEST_F(WebRtcVideoEngineTest,
TEST_F(WebRtcVideoEngineTest, TEST_F(WebRtcVideoEngineTest,
DestroysNonSimulcastEncoderFromCombinedVP8AndH264Factory) { DestroysNonSimulcastEncoderFromCombinedVP8AndH264Factory) {
encoder_factory_->AddSupportedVideoCodecType("VP8"); AddSupportedVideoCodecType("VP8");
encoder_factory_->AddSupportedVideoCodecType("H264"); AddSupportedVideoCodecType("H264");
std::unique_ptr<VideoMediaChannel> channel(engine_.CreateMediaChannel( std::unique_ptr<VideoMediaChannel> channel(engine_.CreateMediaChannel(
call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(), call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
@ -896,7 +902,7 @@ TEST_F(WebRtcVideoEngineTest, SimulcastEnabledForH264BehindFieldTrial) {
RTC_DCHECK(!override_field_trials_); RTC_DCHECK(!override_field_trials_);
override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>( override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>(
"WebRTC-H264Simulcast/Enabled/"); "WebRTC-H264Simulcast/Enabled/");
encoder_factory_->AddSupportedVideoCodecType("H264"); AddSupportedVideoCodecType("H264");
std::unique_ptr<VideoMediaChannel> channel(engine_.CreateMediaChannel( std::unique_ptr<VideoMediaChannel> channel(engine_.CreateMediaChannel(
call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(), call_.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
@ -936,13 +942,13 @@ TEST_F(WebRtcVideoEngineTest,
auto flexfec = Field("name", &VideoCodec::name, "flexfec-03"); auto flexfec = Field("name", &VideoCodec::name, "flexfec-03");
// FlexFEC is not active without field trial. // 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. // FlexFEC is active with field trial.
RTC_DCHECK(!override_field_trials_); RTC_DCHECK(!override_field_trials_);
override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>( override_field_trials_ = std::make_unique<webrtc::test::ScopedFieldTrials>(
"WebRTC-FlexFEC-03-Advertised/Enabled/"); "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. // Test that codecs are added in the order they are reported from the factory.
@ -966,11 +972,11 @@ TEST_F(WebRtcVideoEngineTest, ReportSupportedAddedCodec) {
// Set up external encoder factory with first codec, and initialize engine. // Set up external encoder factory with first codec, and initialize engine.
encoder_factory_->AddSupportedVideoCodecType(kFakeExternalCodecName1); encoder_factory_->AddSupportedVideoCodecType(kFakeExternalCodecName1);
std::vector<cricket::VideoCodec> codecs_before(engine_.codecs()); std::vector<cricket::VideoCodec> codecs_before(engine_.send_codecs());
// Add second codec. // Add second codec.
encoder_factory_->AddSupportedVideoCodecType(kFakeExternalCodecName2); 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. // The codec itself and RTX should have been added.
EXPECT_EQ(codecs_before.size() + 2, codecs_after.size()); EXPECT_EQ(codecs_before.size() + 2, codecs_after.size());
@ -986,12 +992,11 @@ TEST_F(WebRtcVideoEngineTest, ReportRtxForExternalCodec) {
encoder_factory_->AddSupportedVideoCodecType(kFakeCodecName); encoder_factory_->AddSupportedVideoCodecType(kFakeCodecName);
const size_t fake_codec_index = GetEngineCodecIndex(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) { TEST_F(WebRtcVideoEngineTest, RegisterDecodersIfSupported) {
encoder_factory_->AddSupportedVideoCodecType("VP8"); AddSupportedVideoCodecType("VP8");
decoder_factory_->AddSupportedVideoCodecType(webrtc::SdpVideoFormat("VP8"));
cricket::VideoRecvParameters parameters; cricket::VideoRecvParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP8"));
@ -1036,8 +1041,7 @@ TEST_F(WebRtcVideoEngineTest, RegisterH264DecoderIfSupported) {
// empty list of RtpSource without crashing. // empty list of RtpSource without crashing.
TEST_F(WebRtcVideoEngineTest, GetSourcesWithNonExistingSsrc) { TEST_F(WebRtcVideoEngineTest, GetSourcesWithNonExistingSsrc) {
// Setup an recv stream with |kSsrc|. // Setup an recv stream with |kSsrc|.
encoder_factory_->AddSupportedVideoCodecType("VP8"); AddSupportedVideoCodecType("VP8");
decoder_factory_->AddSupportedVideoCodecType(webrtc::SdpVideoFormat("VP8"));
cricket::VideoRecvParameters parameters; cricket::VideoRecvParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP8"));
std::unique_ptr<VideoMediaChannel> channel( std::unique_ptr<VideoMediaChannel> channel(
@ -1056,7 +1060,8 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, NullFactories) {
std::unique_ptr<webrtc::VideoDecoderFactory> decoder_factory; std::unique_ptr<webrtc::VideoDecoderFactory> decoder_factory;
WebRtcVideoEngine engine(std::move(encoder_factory), WebRtcVideoEngine engine(std::move(encoder_factory),
std::move(decoder_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) { TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, EmptyFactories) {
@ -1068,8 +1073,11 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, EmptyFactories) {
WebRtcVideoEngine engine( WebRtcVideoEngine engine(
(std::unique_ptr<webrtc::VideoEncoderFactory>(encoder_factory)), (std::unique_ptr<webrtc::VideoEncoderFactory>(encoder_factory)),
(std::unique_ptr<webrtc::VideoDecoderFactory>(decoder_factory))); (std::unique_ptr<webrtc::VideoDecoderFactory>(decoder_factory)));
EXPECT_CALL(*encoder_factory, GetSupportedFormats()); // TODO(kron): Change to Times(1) once send and receive codecs are changed
EXPECT_EQ(0u, engine.codecs().size()); // to be treated independently.
EXPECT_CALL(*encoder_factory, GetSupportedFormats()).Times(2);
EXPECT_EQ(0u, engine.send_codecs().size());
EXPECT_EQ(0u, engine.recv_codecs().size());
EXPECT_CALL(*encoder_factory, Die()); EXPECT_CALL(*encoder_factory, Die());
EXPECT_CALL(*decoder_factory, Die()); EXPECT_CALL(*decoder_factory, Die());
} }
@ -1098,9 +1106,11 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, Vp8) {
const std::vector<webrtc::SdpVideoFormat> supported_formats = {vp8_format}; const std::vector<webrtc::SdpVideoFormat> supported_formats = {vp8_format};
EXPECT_CALL(*encoder_factory, GetSupportedFormats()) EXPECT_CALL(*encoder_factory, GetSupportedFormats())
.WillRepeatedly(::testing::Return(supported_formats)); .WillRepeatedly(::testing::Return(supported_formats));
EXPECT_CALL(*decoder_factory, GetSupportedFormats())
.WillRepeatedly(::testing::Return(supported_formats));
// Verify the codecs from the engine. // 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. // Verify default codecs has been added correctly.
EXPECT_EQ(5u, engine_codecs.size()); EXPECT_EQ(5u, engine_codecs.size());
EXPECT_EQ("VP8", engine_codecs.at(0).name); EXPECT_EQ("VP8", engine_codecs.at(0).name);
@ -1233,12 +1243,14 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, NullDecoder) {
const auto call = absl::WrapUnique(webrtc::Call::Create(call_config)); const auto call = absl::WrapUnique(webrtc::Call::Create(call_config));
// Create recv channel. // Create recv channel.
EXPECT_CALL(*decoder_factory, GetSupportedFormats())
.WillRepeatedly(::testing::Return(supported_formats));
const int recv_ssrc = 321; const int recv_ssrc = 321;
std::unique_ptr<VideoMediaChannel> recv_channel(engine.CreateMediaChannel( std::unique_ptr<VideoMediaChannel> recv_channel(engine.CreateMediaChannel(
call.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(), call.get(), GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
rate_allocator_factory.get())); rate_allocator_factory.get()));
cricket::VideoRecvParameters recv_parameters; 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->SetRecvParameters(recv_parameters));
EXPECT_TRUE(recv_channel->AddRecvStream( EXPECT_TRUE(recv_channel->AddRecvStream(
cricket::StreamParams::CreateLegacy(recv_ssrc))); cricket::StreamParams::CreateLegacy(recv_ssrc)));
@ -1326,9 +1338,9 @@ class WebRtcVideoChannelEncodedFrameCallbackTest : public ::testing::Test {
webrtc::CreateBuiltinVideoBitrateAllocatorFactory()), webrtc::CreateBuiltinVideoBitrateAllocatorFactory()),
engine_( engine_(
webrtc::CreateBuiltinVideoEncoderFactory(), webrtc::CreateBuiltinVideoEncoderFactory(),
std::make_unique<webrtc::test::FunctionVideoDecoderFactory>([]() { std::make_unique<webrtc::test::FunctionVideoDecoderFactory>(
return std::make_unique<webrtc::test::FakeDecoder>(); []() { return std::make_unique<webrtc::test::FakeDecoder>(); },
})), kSdpVideoFormats)),
channel_(absl::WrapUnique(static_cast<cricket::WebRtcVideoChannel*>( channel_(absl::WrapUnique(static_cast<cricket::WebRtcVideoChannel*>(
engine_.CreateMediaChannel( engine_.CreateMediaChannel(
call_.get(), call_.get(),
@ -1339,7 +1351,7 @@ class WebRtcVideoChannelEncodedFrameCallbackTest : public ::testing::Test {
network_interface_.SetDestination(channel_.get()); network_interface_.SetDestination(channel_.get());
channel_->SetInterface(&network_interface_, webrtc::MediaTransportConfig()); channel_->SetInterface(&network_interface_, webrtc::MediaTransportConfig());
cricket::VideoRecvParameters parameters; cricket::VideoRecvParameters parameters;
parameters.codecs = engine_.codecs(); parameters.codecs = engine_.recv_codecs();
channel_->SetRecvParameters(parameters); channel_->SetRecvParameters(parameters);
} }
@ -1363,6 +1375,7 @@ class WebRtcVideoChannelEncodedFrameCallbackTest : public ::testing::Test {
EXPECT_EQ(0, renderer_.errors()); EXPECT_EQ(0, renderer_.errors());
} }
static const std::vector<webrtc::SdpVideoFormat> kSdpVideoFormats;
webrtc::FieldTrialBasedConfig field_trials_; webrtc::FieldTrialBasedConfig field_trials_;
webrtc::RtcEventLogNull event_log_; webrtc::RtcEventLogNull event_log_;
std::unique_ptr<webrtc::TaskQueueFactory> task_queue_factory_; std::unique_ptr<webrtc::TaskQueueFactory> task_queue_factory_;
@ -1375,6 +1388,10 @@ class WebRtcVideoChannelEncodedFrameCallbackTest : public ::testing::Test {
cricket::FakeVideoRenderer renderer_; cricket::FakeVideoRenderer renderer_;
}; };
const std::vector<webrtc::SdpVideoFormat>
WebRtcVideoChannelEncodedFrameCallbackTest::kSdpVideoFormats = {
webrtc::SdpVideoFormat("VP8")};
TEST_F(WebRtcVideoChannelEncodedFrameCallbackTest, TEST_F(WebRtcVideoChannelEncodedFrameCallbackTest,
SetEncodedFrameBufferFunction_DefaultStream) { SetEncodedFrameBufferFunction_DefaultStream) {
testing::MockFunction<void(const webrtc::RecordableEncodedFrame&)> callback; testing::MockFunction<void(const webrtc::RecordableEncodedFrame&)> callback;
@ -1480,7 +1497,7 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test {
network_interface_.SetDestination(channel_.get()); network_interface_.SetDestination(channel_.get());
channel_->SetInterface(&network_interface_, webrtc::MediaTransportConfig()); channel_->SetInterface(&network_interface_, webrtc::MediaTransportConfig());
cricket::VideoRecvParameters parameters; cricket::VideoRecvParameters parameters;
parameters.codecs = engine_.codecs(); parameters.codecs = engine_.send_codecs();
channel_->SetRecvParameters(parameters); channel_->SetRecvParameters(parameters);
EXPECT_TRUE(channel_->AddSendStream(DefaultSendStreamParams())); EXPECT_TRUE(channel_->AddSendStream(DefaultSendStreamParams()));
frame_forwarder_ = std::make_unique<webrtc::test::FrameForwarder>(); frame_forwarder_ = std::make_unique<webrtc::test::FrameForwarder>();
@ -1628,7 +1645,7 @@ class WebRtcVideoChannelBaseTest : public ::testing::Test {
} }
cricket::VideoCodec GetEngineCodec(const std::string& name) { 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)) if (absl::EqualsIgnoreCase(name, engine_codec.name))
return engine_codec; return engine_codec;
} }
@ -2405,10 +2422,10 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest {
frame_source_(1280, 720, rtc::kNumMicrosecsPerSec / 30), frame_source_(1280, 720, rtc::kNumMicrosecsPerSec / 30),
last_ssrc_(0) {} last_ssrc_(0) {}
void SetUp() override { void SetUp() override {
encoder_factory_->AddSupportedVideoCodecType("VP8"); AddSupportedVideoCodecType("VP8");
encoder_factory_->AddSupportedVideoCodecType("VP9"); AddSupportedVideoCodecType("VP9");
#if defined(WEBRTC_USE_H264) #if defined(WEBRTC_USE_H264)
encoder_factory_->AddSupportedVideoCodecType("H264"); AddSupportedVideoCodecType("H264");
#endif #endif
fake_call_.reset(new FakeCall()); fake_call_.reset(new FakeCall());
@ -2417,8 +2434,8 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest {
webrtc::CryptoOptions(), video_bitrate_allocator_factory_.get())); webrtc::CryptoOptions(), video_bitrate_allocator_factory_.get()));
channel_->OnReadyToSend(true); channel_->OnReadyToSend(true);
last_ssrc_ = 123; last_ssrc_ = 123;
send_parameters_.codecs = engine_.codecs(); send_parameters_.codecs = engine_.send_codecs();
recv_parameters_.codecs = engine_.codecs(); recv_parameters_.codecs = engine_.recv_codecs();
ASSERT_TRUE(channel_->SetSendParameters(send_parameters_)); ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
} }
@ -2590,7 +2607,7 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest {
VerifyCodecHasDefaultFeedbackParams(default_codec_, expect_lntf_enabled); VerifyCodecHasDefaultFeedbackParams(default_codec_, expect_lntf_enabled);
cricket::VideoSendParameters parameters; cricket::VideoSendParameters parameters;
parameters.codecs = engine_.codecs(); parameters.codecs = engine_.send_codecs();
EXPECT_TRUE(channel_->SetSendParameters(parameters)); EXPECT_TRUE(channel_->SetSendParameters(parameters));
EXPECT_TRUE(channel_->SetSend(true)); EXPECT_TRUE(channel_->SetSend(true));
@ -2735,7 +2752,7 @@ TEST_F(WebRtcVideoChannelTest, SetsSyncGroupFromSyncLabel) {
TEST_F(WebRtcVideoChannelTest, RecvStreamWithSimAndRtx) { TEST_F(WebRtcVideoChannelTest, RecvStreamWithSimAndRtx) {
cricket::VideoSendParameters parameters; cricket::VideoSendParameters parameters;
parameters.codecs = engine_.codecs(); parameters.codecs = engine_.send_codecs();
EXPECT_TRUE(channel_->SetSendParameters(parameters)); EXPECT_TRUE(channel_->SetSendParameters(parameters));
EXPECT_TRUE(channel_->SetSend(true)); EXPECT_TRUE(channel_->SetSend(true));
parameters.conference_mode = true; parameters.conference_mode = true;
@ -3048,7 +3065,7 @@ TEST_F(WebRtcVideoChannelTest, TransportCcCanBeEnabledAndDisabled) {
// Verify that transport cc feedback is turned on when setting default codecs // Verify that transport cc feedback is turned on when setting default codecs
// since the default codecs have transport cc feedback enabled. // since the default codecs have transport cc feedback enabled.
parameters.codecs = engine_.codecs(); parameters.codecs = engine_.send_codecs();
EXPECT_TRUE(channel_->SetSendParameters(parameters)); EXPECT_TRUE(channel_->SetSendParameters(parameters));
stream = fake_call_->GetVideoReceiveStreams()[0]; stream = fake_call_->GetVideoReceiveStreams()[0];
EXPECT_TRUE(stream->GetConfig().rtp.transport_cc); EXPECT_TRUE(stream->GetConfig().rtp.transport_cc);
@ -3077,7 +3094,7 @@ TEST_F(WebRtcVideoChannelTest, LossNotificationCanBeEnabledAndDisabled) {
{ {
cricket::VideoSendParameters parameters; cricket::VideoSendParameters parameters;
parameters.codecs = engine_.codecs(); parameters.codecs = engine_.send_codecs();
EXPECT_TRUE(channel_->SetSendParameters(parameters)); EXPECT_TRUE(channel_->SetSendParameters(parameters));
EXPECT_TRUE(channel_->SetSend(true)); EXPECT_TRUE(channel_->SetSend(true));
} }
@ -3101,7 +3118,7 @@ TEST_F(WebRtcVideoChannelTest, LossNotificationCanBeEnabledAndDisabled) {
EXPECT_FALSE(send_stream->GetConfig().rtp.lntf.enabled); EXPECT_FALSE(send_stream->GetConfig().rtp.lntf.enabled);
// Setting the default codecs again, including VP8, turns LNTF back on. // 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)); EXPECT_TRUE(channel_->SetSendParameters(parameters));
recv_stream = fake_call_->GetVideoReceiveStreams()[0]; recv_stream = fake_call_->GetVideoReceiveStreams()[0];
EXPECT_TRUE(recv_stream->GetConfig().rtp.lntf.enabled); EXPECT_TRUE(recv_stream->GetConfig().rtp.lntf.enabled);
@ -3114,7 +3131,7 @@ TEST_F(WebRtcVideoChannelTest, NackIsEnabledByDefault) {
VerifyCodecHasDefaultFeedbackParams(default_codec_, false); VerifyCodecHasDefaultFeedbackParams(default_codec_, false);
cricket::VideoSendParameters parameters; cricket::VideoSendParameters parameters;
parameters.codecs = engine_.codecs(); parameters.codecs = engine_.send_codecs();
EXPECT_TRUE(channel_->SetSendParameters(parameters)); EXPECT_TRUE(channel_->SetSendParameters(parameters));
EXPECT_TRUE(channel_->SetSend(true)); EXPECT_TRUE(channel_->SetSend(true));
@ -3152,7 +3169,7 @@ TEST_F(WebRtcVideoChannelTest, NackCanBeEnabledAndDisabled) {
// Verify that NACK is turned on when setting default codecs since the // Verify that NACK is turned on when setting default codecs since the
// default codecs have NACK enabled. // default codecs have NACK enabled.
parameters.codecs = engine_.codecs(); parameters.codecs = engine_.send_codecs();
EXPECT_TRUE(channel_->SetSendParameters(parameters)); EXPECT_TRUE(channel_->SetSendParameters(parameters));
recv_stream = fake_call_->GetVideoReceiveStreams()[0]; recv_stream = fake_call_->GetVideoReceiveStreams()[0];
EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0); EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
@ -3890,7 +3907,7 @@ TEST_F(WebRtcVideoChannelTest, SetDefaultSendCodecs) {
VideoCodec codec; VideoCodec codec;
EXPECT_TRUE(channel_->GetSendCodec(&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. // Using a RTX setup to verify that the default RTX payload type is good.
const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1); const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
@ -4238,7 +4255,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest,
TEST_F(WebRtcVideoChannelTest, TEST_F(WebRtcVideoChannelTest,
SetSendCodecRejectsRtxWithoutAssociatedPayloadType) { SetSendCodecRejectsRtxWithoutAssociatedPayloadType) {
const int kUnusedPayloadType = 127; const int kUnusedPayloadType = 127;
EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType)); EXPECT_FALSE(FindCodecById(engine_.send_codecs(), kUnusedPayloadType));
cricket::VideoSendParameters parameters; cricket::VideoSendParameters parameters;
cricket::VideoCodec rtx_codec(kUnusedPayloadType, "rtx"); cricket::VideoCodec rtx_codec(kUnusedPayloadType, "rtx");
@ -4251,8 +4268,8 @@ TEST_F(WebRtcVideoChannelTest,
SetSendCodecRejectsRtxWithoutMatchingVideoCodec) { SetSendCodecRejectsRtxWithoutMatchingVideoCodec) {
const int kUnusedPayloadType1 = 126; const int kUnusedPayloadType1 = 126;
const int kUnusedPayloadType2 = 127; const int kUnusedPayloadType2 = 127;
EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType1)); EXPECT_FALSE(FindCodecById(engine_.send_codecs(), kUnusedPayloadType1));
EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType2)); EXPECT_FALSE(FindCodecById(engine_.send_codecs(), kUnusedPayloadType2));
{ {
cricket::VideoCodec rtx_codec = cricket::VideoCodec::CreateRtxCodec( cricket::VideoCodec rtx_codec = cricket::VideoCodec::CreateRtxCodec(
kUnusedPayloadType1, GetEngineCodec("VP8").id); kUnusedPayloadType1, GetEngineCodec("VP8").id);
@ -4275,8 +4292,8 @@ TEST_F(WebRtcVideoChannelTest,
TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithChangedRtxPayloadType) { TEST_F(WebRtcVideoChannelTest, SetSendCodecsWithChangedRtxPayloadType) {
const int kUnusedPayloadType1 = 126; const int kUnusedPayloadType1 = 126;
const int kUnusedPayloadType2 = 127; const int kUnusedPayloadType2 = 127;
EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType1)); EXPECT_FALSE(FindCodecById(engine_.send_codecs(), kUnusedPayloadType1));
EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType2)); EXPECT_FALSE(FindCodecById(engine_.send_codecs(), kUnusedPayloadType2));
// SSRCs for RTX. // SSRCs for RTX.
cricket::StreamParams params = cricket::StreamParams params =
@ -4677,8 +4694,8 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithOnlyVp8) {
TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithRtx) { TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithRtx) {
const int kUnusedPayloadType1 = 126; const int kUnusedPayloadType1 = 126;
const int kUnusedPayloadType2 = 127; const int kUnusedPayloadType2 = 127;
EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType1)); EXPECT_FALSE(FindCodecById(engine_.recv_codecs(), kUnusedPayloadType1));
EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType2)); EXPECT_FALSE(FindCodecById(engine_.recv_codecs(), kUnusedPayloadType2));
cricket::VideoRecvParameters parameters; cricket::VideoRecvParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8")); parameters.codecs.push_back(GetEngineCodec("VP8"));
@ -4776,8 +4793,8 @@ TEST_F(WebRtcVideoChannelTest, DuplicateRedCodecIsDropped) {
TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithChangedRtxPayloadType) { TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithChangedRtxPayloadType) {
const int kUnusedPayloadType1 = 126; const int kUnusedPayloadType1 = 126;
const int kUnusedPayloadType2 = 127; const int kUnusedPayloadType2 = 127;
EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType1)); EXPECT_FALSE(FindCodecById(engine_.recv_codecs(), kUnusedPayloadType1));
EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType2)); EXPECT_FALSE(FindCodecById(engine_.recv_codecs(), kUnusedPayloadType2));
// SSRCs for RTX. // SSRCs for RTX.
cricket::StreamParams params = cricket::StreamParams params =
@ -4825,13 +4842,14 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsDifferentPayloadType) {
TEST_F(WebRtcVideoChannelTest, SetRecvCodecsAcceptDefaultCodecs) { TEST_F(WebRtcVideoChannelTest, SetRecvCodecsAcceptDefaultCodecs) {
cricket::VideoRecvParameters parameters; cricket::VideoRecvParameters parameters;
parameters.codecs = engine_.codecs(); parameters.codecs = engine_.recv_codecs();
EXPECT_TRUE(channel_->SetRecvParameters(parameters)); EXPECT_TRUE(channel_->SetRecvParameters(parameters));
FakeVideoReceiveStream* stream = AddRecvStream(); FakeVideoReceiveStream* stream = AddRecvStream();
const webrtc::VideoReceiveStream::Config& config = stream->GetConfig(); const webrtc::VideoReceiveStream::Config& config = stream->GetConfig();
EXPECT_EQ(engine_.codecs()[0].name, config.decoders[0].video_format.name); EXPECT_EQ(engine_.recv_codecs()[0].name,
EXPECT_EQ(engine_.codecs()[0].id, config.decoders[0].payload_type); config.decoders[0].video_format.name);
EXPECT_EQ(engine_.recv_codecs()[0].id, config.decoders[0].payload_type);
} }
TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRejectUnsupportedCodec) { TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRejectUnsupportedCodec) {
@ -5721,7 +5739,7 @@ void WebRtcVideoChannelTest::TestReceiveUnsignaledSsrcPacket(
uint8_t payload_type, uint8_t payload_type,
bool expect_created_receive_stream) { bool expect_created_receive_stream) {
// kRedRtxPayloadType must currently be unused. // kRedRtxPayloadType must currently be unused.
EXPECT_FALSE(FindCodecById(engine_.codecs(), kRedRtxPayloadType)); EXPECT_FALSE(FindCodecById(engine_.recv_codecs(), kRedRtxPayloadType));
// Add a RED RTX codec. // Add a RED RTX codec.
VideoCodec red_rtx_codec = VideoCodec red_rtx_codec =
@ -7578,6 +7596,7 @@ class WebRtcVideoChannelSimulcastTest : public ::testing::Test {
void SetUp() override { void SetUp() override {
encoder_factory_->AddSupportedVideoCodecType("VP8"); encoder_factory_->AddSupportedVideoCodecType("VP8");
decoder_factory_->AddSupportedVideoCodecType("VP8");
channel_.reset(engine_.CreateMediaChannel( channel_.reset(engine_.CreateMediaChannel(
&fake_call_, GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(), &fake_call_, GetMediaConfig(), VideoOptions(), webrtc::CryptoOptions(),
mock_rate_allocator_factory_.get())); mock_rate_allocator_factory_.get()));

4
pc/channel_manager.cc
View file

@ -94,7 +94,9 @@ void ChannelManager::GetSupportedVideoCodecs(
} }
codecs->clear(); codecs->clear();
std::vector<VideoCodec> video_codecs = media_engine_->video().codecs(); // TODO(kron): Update code to distuiguish between send and receive codecs. Use
// send codecs for now to be consistent with old behavior.
std::vector<VideoCodec> video_codecs = media_engine_->video().send_codecs();
for (const auto& video_codec : video_codecs) { for (const auto& video_codec : video_codecs) {
if (!enable_rtx_ && if (!enable_rtx_ &&
absl::EqualsIgnoreCase(kRtxCodecName, video_codec.name)) { absl::EqualsIgnoreCase(kRtxCodecName, video_codec.name)) {

8
pc/peer_connection_media_unittest.cc
View file

@ -1434,7 +1434,7 @@ TEST_F(PeerConnectionMediaTestUnifiedPlan,
TEST_F(PeerConnectionMediaTestUnifiedPlan, TEST_F(PeerConnectionMediaTestUnifiedPlan,
SetCodecPreferencesVideoRejectsOnlyRtxRedFec) { SetCodecPreferencesVideoRejectsOnlyRtxRedFec) {
auto fake_engine = std::make_unique<FakeMediaEngine>(); 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( video_codecs.push_back(
cricket::VideoCodec(video_codecs.back().id + 1, cricket::kRtxCodecName)); cricket::VideoCodec(video_codecs.back().id + 1, cricket::kRtxCodecName));
video_codecs.push_back( video_codecs.push_back(
@ -1540,7 +1540,7 @@ TEST_F(PeerConnectionMediaTestUnifiedPlan,
TEST_F(PeerConnectionMediaTestUnifiedPlan, SetCodecPreferencesVideoWithRtx) { TEST_F(PeerConnectionMediaTestUnifiedPlan, SetCodecPreferencesVideoWithRtx) {
auto caller_fake_engine = std::make_unique<FakeMediaEngine>(); 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.push_back(cricket::VideoCodec(
caller_video_codecs.back().id + 1, cricket::kVp8CodecName)); caller_video_codecs.back().id + 1, cricket::kVp8CodecName));
caller_video_codecs.push_back(cricket::VideoCodec( caller_video_codecs.push_back(cricket::VideoCodec(
@ -1592,7 +1592,7 @@ TEST_F(PeerConnectionMediaTestUnifiedPlan, SetCodecPreferencesVideoWithRtx) {
TEST_F(PeerConnectionMediaTestUnifiedPlan, TEST_F(PeerConnectionMediaTestUnifiedPlan,
SetCodecPreferencesVideoCodecsNegotiation) { SetCodecPreferencesVideoCodecsNegotiation) {
auto caller_fake_engine = std::make_unique<FakeMediaEngine>(); 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.push_back(cricket::VideoCodec(
caller_video_codecs.back().id + 1, cricket::kVp8CodecName)); caller_video_codecs.back().id + 1, cricket::kVp8CodecName));
caller_video_codecs.push_back(cricket::VideoCodec( caller_video_codecs.push_back(cricket::VideoCodec(
@ -1666,7 +1666,7 @@ TEST_F(PeerConnectionMediaTestUnifiedPlan,
TEST_F(PeerConnectionMediaTestUnifiedPlan, TEST_F(PeerConnectionMediaTestUnifiedPlan,
SetCodecPreferencesVideoCodecsNegotiationReverseOrder) { SetCodecPreferencesVideoCodecsNegotiationReverseOrder) {
auto caller_fake_engine = std::make_unique<FakeMediaEngine>(); 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.push_back(cricket::VideoCodec(
caller_video_codecs.back().id + 1, cricket::kVp8CodecName)); caller_video_codecs.back().id + 1, cricket::kVp8CodecName));
caller_video_codecs.push_back(cricket::VideoCodec( caller_video_codecs.push_back(cricket::VideoCodec(

45
sdk/objc/components/video_codec/RTCDefaultVideoDecoderFactory.m
View file

@ -21,6 +21,41 @@
@implementation RTCDefaultVideoDecoderFactory @implementation RTCDefaultVideoDecoderFactory
- (NSArray<RTCVideoCodecInfo *> *)supportedCodecs {
NSDictionary<NSString *, NSString *> *constrainedHighParams = @{
@"profile-level-id" : kRTCMaxSupportedH264ProfileLevelConstrainedHigh,
@"level-asymmetry-allowed" : @"1",
@"packetization-mode" : @"1",
};
RTCVideoCodecInfo *constrainedHighInfo =
[[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecH264Name
parameters:constrainedHighParams];
NSDictionary<NSString *, NSString *> *constrainedBaselineParams = @{
@"profile-level-id" : kRTCMaxSupportedH264ProfileLevelConstrainedBaseline,
@"level-asymmetry-allowed" : @"1",
@"packetization-mode" : @"1",
};
RTCVideoCodecInfo *constrainedBaselineInfo =
[[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecH264Name
parameters:constrainedBaselineParams];
RTCVideoCodecInfo *vp8Info = [[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecVp8Name];
#if defined(RTC_ENABLE_VP9)
RTCVideoCodecInfo *vp9Info = [[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecVp9Name];
#endif
return @[
constrainedHighInfo,
constrainedBaselineInfo,
vp8Info,
#if defined(RTC_ENABLE_VP9)
vp9Info,
#endif
];
}
- (id<RTCVideoDecoder>)createDecoder:(RTCVideoCodecInfo *)info { - (id<RTCVideoDecoder>)createDecoder:(RTCVideoCodecInfo *)info {
if ([info.name isEqualToString:kRTCVideoCodecH264Name]) { if ([info.name isEqualToString:kRTCVideoCodecH264Name]) {
return [[RTCVideoDecoderH264 alloc] init]; return [[RTCVideoDecoderH264 alloc] init];
@ -35,14 +70,4 @@
return nil; return nil;
} }
- (NSArray<RTCVideoCodecInfo *> *)supportedCodecs {
return @[
[[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecH264Name],
[[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecVp8Name],
#if defined(RTC_ENABLE_VP9)
[[RTCVideoCodecInfo alloc] initWithName:kRTCVideoCodecVp9Name],
#endif
];
}
@end @end