Simplify passing video coded factories in media engine
We soon want to be able to pass in a new type of video codec factories,
see issue 7925 for more information. We currently plumb these video
codec factories in a clumsy way from the media engine to the video
engine, which will require us to update a lot of places when we add
new video codec factory types. This CL cleans up the way we pass in
video codec factories to make it easier to add the new factory types.
In particular, this CL:
* Updates WebRtcVideoEngine to take the video codec factories as
arguments in ctor instead of in SetExternalVideoCodec functions.
* Remove the Init() function from the vidoe engines - this function is
not used.
* Update CompositeMediaEngine to take generic variadic arguments, so we
can send different arguments for different engines, without having to
update this class.
* Simplify ownership of video codec factories in WebRtcVideoEngine.
WebRtcVideoEngine outlives WebRtcVideoChannel,
WebRtcVideoSendStream and WebRtcVideoReceiveStream, so it can
keep ownership without having to share ownership with these classes.
BUG=webrtc:7925
Review-Url: https://codereview.webrtc.org/3008043002
Cr-Original-Commit-Position: refs/heads/master@{#19794}
Cr-Mirrored-From: https://chromium.googlesource.com/external/webrtc
Cr-Mirrored-Commit: 2475ae2e4cdbb7cbfa2a4801cbc36ff7eb73aacd
diff --git a/media/base/fakemediaengine.h b/media/base/fakemediaengine.h
index 0b080af..921623c 100644
--- a/media/base/fakemediaengine.h
+++ b/media/base/fakemediaengine.h
@@ -774,13 +774,7 @@
class FakeVoiceEngine : public FakeBaseEngine {
public:
- FakeVoiceEngine(webrtc::AudioDeviceModule* adm,
- const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
- audio_encoder_factory,
- const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
- audio_decoder_factory,
- rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer,
- rtc::scoped_refptr<webrtc::AudioProcessing> apm) {
+ FakeVoiceEngine() {
// Add a fake audio codec. Note that the name must not be "" as there are
// sanity checks against that.
codecs_.push_back(AudioCodec(101, "fake_audio_codec", 0, 0, 1));
@@ -843,8 +837,6 @@
codecs_.push_back(VideoCodec(0, "fake_video_codec"));
}
- void Init() {}
-
bool SetOptions(const VideoOptions& options) {
options_ = options;
options_changed_ = true;
@@ -895,55 +887,50 @@
public CompositeMediaEngine<FakeVoiceEngine, FakeVideoEngine> {
public:
FakeMediaEngine()
- : CompositeMediaEngine<FakeVoiceEngine, FakeVideoEngine>(nullptr,
- nullptr,
- nullptr,
- nullptr,
- nullptr) {}
+ : CompositeMediaEngine<FakeVoiceEngine, FakeVideoEngine>(std::tuple<>(),
+ std::tuple<>()) {
+ }
+
virtual ~FakeMediaEngine() {}
void SetAudioCodecs(const std::vector<AudioCodec>& codecs) {
- voice_.SetCodecs(codecs);
+ voice().SetCodecs(codecs);
}
void SetVideoCodecs(const std::vector<VideoCodec>& codecs) {
- video_.SetCodecs(codecs);
+ video().SetCodecs(codecs);
}
void SetAudioRtpHeaderExtensions(
const std::vector<RtpExtension>& extensions) {
- voice_.set_rtp_header_extensions(extensions);
+ voice().set_rtp_header_extensions(extensions);
}
void SetVideoRtpHeaderExtensions(
const std::vector<RtpExtension>& extensions) {
- video_.set_rtp_header_extensions(extensions);
+ video().set_rtp_header_extensions(extensions);
}
void SetAudioRtpHeaderExtensions(
const std::vector<cricket::RtpHeaderExtension>& extensions) {
- voice_.set_rtp_header_extensions(extensions);
+ voice().set_rtp_header_extensions(extensions);
}
void SetVideoRtpHeaderExtensions(
const std::vector<cricket::RtpHeaderExtension>& extensions) {
- video_.set_rtp_header_extensions(extensions);
+ video().set_rtp_header_extensions(extensions);
}
FakeVoiceMediaChannel* GetVoiceChannel(size_t index) {
- return voice_.GetChannel(index);
+ return voice().GetChannel(index);
}
FakeVideoMediaChannel* GetVideoChannel(size_t index) {
- return video_.GetChannel(index);
+ return video().GetChannel(index);
}
- bool capture() const { return video_.capture_; }
- bool options_changed() const {
- return video_.options_changed_;
- }
- void clear_options_changed() {
- video_.options_changed_ = false;
- }
+ bool capture() const { return video().capture_; }
+ bool options_changed() const { return video().options_changed_; }
+ void clear_options_changed() { video().options_changed_ = false; }
void set_fail_create_channel(bool fail) {
- voice_.set_fail_create_channel(fail);
- video_.set_fail_create_channel(fail);
+ voice().set_fail_create_channel(fail);
+ video().set_fail_create_channel(fail);
}
};
diff --git a/media/base/mediaengine.h b/media/base/mediaengine.h
index 8ce6075..52a55f9 100644
--- a/media/base/mediaengine.h
+++ b/media/base/mediaengine.h
@@ -109,71 +109,65 @@
// CompositeMediaEngine constructs a MediaEngine from separate
// voice and video engine classes.
-template<class VOICE, class VIDEO>
+template <class VOICE, class VIDEO>
class CompositeMediaEngine : public MediaEngineInterface {
public:
- CompositeMediaEngine(
- webrtc::AudioDeviceModule* adm,
- const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
- audio_encoder_factory,
- const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
- audio_decoder_factory,
- rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer,
- rtc::scoped_refptr<webrtc::AudioProcessing> audio_processing)
- : voice_(adm,
- audio_encoder_factory,
- audio_decoder_factory,
- audio_mixer,
- audio_processing) {}
+ template <class... Args1, class... Args2>
+ CompositeMediaEngine(std::tuple<Args1...> first_args,
+ std::tuple<Args2...> second_args)
+ : engines_(std::piecewise_construct,
+ std::move(first_args),
+ std::move(second_args)) {}
+
virtual ~CompositeMediaEngine() {}
virtual bool Init() {
- voice_.Init();
- video_.Init();
+ voice().Init();
return true;
}
virtual rtc::scoped_refptr<webrtc::AudioState> GetAudioState() const {
- return voice_.GetAudioState();
+ return voice().GetAudioState();
}
virtual VoiceMediaChannel* CreateChannel(webrtc::Call* call,
const MediaConfig& config,
const AudioOptions& options) {
- return voice_.CreateChannel(call, config, options);
+ return voice().CreateChannel(call, config, options);
}
virtual VideoMediaChannel* CreateVideoChannel(webrtc::Call* call,
const MediaConfig& config,
const VideoOptions& options) {
- return video_.CreateChannel(call, config, options);
+ return video().CreateChannel(call, config, options);
}
- virtual int GetInputLevel() {
- return voice_.GetInputLevel();
- }
+ virtual int GetInputLevel() { return voice().GetInputLevel(); }
virtual const std::vector<AudioCodec>& audio_send_codecs() {
- return voice_.send_codecs();
+ return voice().send_codecs();
}
virtual const std::vector<AudioCodec>& audio_recv_codecs() {
- return voice_.recv_codecs();
+ return voice().recv_codecs();
}
virtual RtpCapabilities GetAudioCapabilities() {
- return voice_.GetCapabilities();
+ return voice().GetCapabilities();
}
- virtual std::vector<VideoCodec> video_codecs() { return video_.codecs(); }
+ virtual std::vector<VideoCodec> video_codecs() { return video().codecs(); }
virtual RtpCapabilities GetVideoCapabilities() {
- return video_.GetCapabilities();
+ return video().GetCapabilities();
}
virtual bool StartAecDump(rtc::PlatformFile file, int64_t max_size_bytes) {
- return voice_.StartAecDump(file, max_size_bytes);
+ return voice().StartAecDump(file, max_size_bytes);
}
- virtual void StopAecDump() {
- voice_.StopAecDump();
- }
+ virtual void StopAecDump() { voice().StopAecDump(); }
protected:
- VOICE voice_;
- VIDEO video_;
+ VOICE& voice() { return engines_.first; }
+ VIDEO& video() { return engines_.second; }
+ const VOICE& voice() const { return engines_.first; }
+ const VIDEO& video() const { return engines_.second; }
+
+ private:
+ std::pair<VOICE, VIDEO> engines_;
};
enum DataChannelType { DCT_NONE = 0, DCT_RTP = 1, DCT_SCTP = 2, DCT_QUIC = 3 };
diff --git a/media/base/videoengine_unittest.h b/media/base/videoengine_unittest.h
index 77062ec..64fda56 100644
--- a/media/base/videoengine_unittest.h
+++ b/media/base/videoengine_unittest.h
@@ -64,7 +64,9 @@
public sigslot::has_slots<> {
protected:
VideoMediaChannelTest<E, C>()
- : call_(webrtc::Call::Create(webrtc::Call::Config(&event_log_))) {}
+ : call_(webrtc::Call::Create(webrtc::Call::Config(&event_log_))),
+ engine_(nullptr /* external_encoder_factory */,
+ nullptr /* external_decoder_factory */) {}
virtual cricket::VideoCodec DefaultCodec() = 0;
@@ -73,7 +75,6 @@
}
virtual void SetUp() {
- engine_.Init();
cricket::MediaConfig media_config;
// Disabling cpu overuse detection actually disables quality scaling too; it
// implies DegradationPreference kMaintainResolution. Automatic scaling
diff --git a/media/engine/nullwebrtcvideoengine.h b/media/engine/nullwebrtcvideoengine.h
index 2fe87f4..9c687b9 100644
--- a/media/engine/nullwebrtcvideoengine.h
+++ b/media/engine/nullwebrtcvideoengine.h
@@ -33,31 +33,15 @@
// CompositeMediaEngine.
class NullWebRtcVideoEngine {
public:
- NullWebRtcVideoEngine() {}
- ~NullWebRtcVideoEngine() {}
+ std::vector<VideoCodec> codecs() const { return std::vector<VideoCodec>(); }
- void SetExternalDecoderFactory(WebRtcVideoDecoderFactory* decoder_factory) {}
- void SetExternalEncoderFactory(WebRtcVideoEncoderFactory* encoder_factory) {}
-
- void Init() {}
-
- const std::vector<VideoCodec>& codecs() {
- return codecs_;
- }
-
- RtpCapabilities GetCapabilities() {
- RtpCapabilities capabilities;
- return capabilities;
- }
+ RtpCapabilities GetCapabilities() const { return RtpCapabilities(); }
VideoMediaChannel* CreateChannel(webrtc::Call* call,
const MediaConfig& config,
const VideoOptions& options) {
return nullptr;
}
-
- private:
- std::vector<VideoCodec> codecs_;
};
} // namespace cricket
diff --git a/media/engine/nullwebrtcvideoengine_unittest.cc b/media/engine/nullwebrtcvideoengine_unittest.cc
index e1a2964..5fa7b01 100644
--- a/media/engine/nullwebrtcvideoengine_unittest.cc
+++ b/media/engine/nullwebrtcvideoengine_unittest.cc
@@ -25,18 +25,14 @@
const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
audio_encoder_factory,
const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
- audio_decoder_factory,
- WebRtcVideoEncoderFactory* video_encoder_factory,
- WebRtcVideoDecoderFactory* video_decoder_factory)
+ audio_decoder_factory)
: CompositeMediaEngine<WebRtcVoiceEngine, NullWebRtcVideoEngine>(
- adm,
- audio_encoder_factory,
- audio_decoder_factory,
- nullptr,
- webrtc::AudioProcessing::Create()) {
- video_.SetExternalDecoderFactory(video_decoder_factory);
- video_.SetExternalEncoderFactory(video_encoder_factory);
- }
+ std::forward_as_tuple(adm,
+ audio_encoder_factory,
+ audio_decoder_factory,
+ nullptr,
+ webrtc::AudioProcessing::Create()),
+ std::forward_as_tuple()) {}
};
// Simple test to check if NullWebRtcVideoEngine implements the methods
@@ -44,7 +40,7 @@
TEST(NullWebRtcVideoEngineTest, CheckInterface) {
WebRtcMediaEngineNullVideo engine(
nullptr, webrtc::MockAudioEncoderFactory::CreateUnusedFactory(),
- webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), nullptr, nullptr);
+ webrtc::MockAudioDecoderFactory::CreateUnusedFactory());
EXPECT_TRUE(engine.Init());
}
diff --git a/media/engine/webrtcmediaengine.cc b/media/engine/webrtcmediaengine.cc
index 774b6b7..3a61ad7 100644
--- a/media/engine/webrtcmediaengine.cc
+++ b/media/engine/webrtcmediaengine.cc
@@ -24,65 +24,33 @@
namespace cricket {
-class WebRtcMediaEngine2
-#ifdef HAVE_WEBRTC_VIDEO
- : public CompositeMediaEngine<WebRtcVoiceEngine, WebRtcVideoEngine> {
-#else
- : public CompositeMediaEngine<WebRtcVoiceEngine, NullWebRtcVideoEngine> {
-#endif
- public:
- WebRtcMediaEngine2(
- webrtc::AudioDeviceModule* adm,
- const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
- audio_encoder_factory,
- const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
- audio_decoder_factory,
- WebRtcVideoEncoderFactory* video_encoder_factory,
- WebRtcVideoDecoderFactory* video_decoder_factory,
- rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer,
- rtc::scoped_refptr<webrtc::AudioProcessing> audio_processing)
-#ifdef HAVE_WEBRTC_VIDEO
- : CompositeMediaEngine<WebRtcVoiceEngine, WebRtcVideoEngine>(
- adm,
- audio_encoder_factory,
- audio_decoder_factory,
- audio_mixer,
- audio_processing){
-#else
- : CompositeMediaEngine<WebRtcVoiceEngine, NullWebRtcVideoEngine>(
- adm,
- audio_encoder_factory,
- audio_decoder_factory,
- audio_mixer,
- audio_processing) {
-#endif
- video_.SetExternalDecoderFactory(video_decoder_factory);
- video_.SetExternalEncoderFactory(video_encoder_factory);
- }
-};
+namespace {
-} // namespace cricket
-
-cricket::MediaEngineInterface* CreateWebRtcMediaEngine(
+MediaEngineInterface* CreateWebRtcMediaEngine(
webrtc::AudioDeviceModule* adm,
const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
audio_encoder_factory,
const rtc::scoped_refptr<webrtc::AudioDecoderFactory>&
audio_decoder_factory,
- cricket::WebRtcVideoEncoderFactory* video_encoder_factory,
- cricket::WebRtcVideoDecoderFactory* video_decoder_factory,
+ WebRtcVideoEncoderFactory* video_encoder_factory,
+ WebRtcVideoDecoderFactory* video_decoder_factory,
rtc::scoped_refptr<webrtc::AudioMixer> audio_mixer,
rtc::scoped_refptr<webrtc::AudioProcessing> audio_processing) {
- return new cricket::WebRtcMediaEngine2(
- adm, audio_encoder_factory, audio_decoder_factory, video_encoder_factory,
- video_decoder_factory, audio_mixer, audio_processing);
+#ifdef HAVE_WEBRTC_VIDEO
+ typedef WebRtcVideoEngine VideoEngine;
+ std::tuple<WebRtcVideoEncoderFactory*, WebRtcVideoDecoderFactory*> video_args(
+ video_encoder_factory, video_decoder_factory);
+#else
+ typedef NullWebRtcVideoEngine VideoEngine;
+ std::tuple<> video_args;
+#endif
+ return new CompositeMediaEngine<WebRtcVoiceEngine, VideoEngine>(
+ std::forward_as_tuple(adm, audio_encoder_factory, audio_decoder_factory,
+ audio_mixer, audio_processing),
+ std::move(video_args));
}
-void DestroyWebRtcMediaEngine(cricket::MediaEngineInterface* media_engine) {
- delete media_engine;
-}
-
-namespace cricket {
+} // namespace
// TODO(ossu): Backwards-compatible interface. Will be deprecated once the
// audio decoder factory is fully plumbed and used throughout WebRTC.
diff --git a/media/engine/webrtcvideoengine.cc b/media/engine/webrtcvideoengine.cc
index 284eb9a..a21f633 100644
--- a/media/engine/webrtcvideoengine.cc
+++ b/media/engine/webrtcvideoengine.cc
@@ -68,8 +68,6 @@
bool is_conference_mode_screenshare) const = 0;
virtual std::vector<VideoCodec> GetSupportedCodecs() const = 0;
-
- virtual std::unique_ptr<EncoderFactoryAdapter> clone() const = 0;
};
class DecoderFactoryAdapter {
@@ -79,12 +77,13 @@
virtual std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
const VideoCodec& codec,
const VideoDecoderParams& decoder_params) const = 0;
-
- virtual std::unique_ptr<DecoderFactoryAdapter> clone() const = 0;
};
namespace {
+std::vector<VideoCodec> AssignPayloadTypesAndAddAssociatedRtxCodecs(
+ const std::vector<VideoCodec>& input_codecs);
+
// Wraps cricket::WebRtcVideoEncoderFactory* into common EncoderFactoryAdapter
// interface.
// TODO(magjed): Add wrapper class for future webrtc::VideoEncoderFactory
@@ -107,11 +106,6 @@
std::vector<VideoCodec> GetSupportedCodecs() const override;
- std::unique_ptr<EncoderFactoryAdapter> clone() const override {
- return std::unique_ptr<EncoderFactoryAdapter>(
- new CricketEncoderFactoryAdapter(*this));
- }
-
const std::unique_ptr<WebRtcVideoEncoderFactory> internal_encoder_factory_;
WebRtcVideoEncoderFactory* const external_encoder_factory_;
};
@@ -132,11 +126,6 @@
const VideoCodec& codec,
const VideoDecoderParams& decoder_params) const override;
- std::unique_ptr<DecoderFactoryAdapter> clone() const override {
- return std::unique_ptr<DecoderFactoryAdapter>(
- new CricketDecoderFactoryAdapter(*this));
- }
-
const std::unique_ptr<WebRtcVideoDecoderFactory> internal_decoder_factory_;
WebRtcVideoDecoderFactory* const external_decoder_factory_;
};
@@ -402,12 +391,13 @@
}
}
-WebRtcVideoEngine::WebRtcVideoEngine()
- : initialized_(false),
- decoder_factory_(new CricketDecoderFactoryAdapter(
- nullptr /* external_decoder_factory */)),
- encoder_factory_(new CricketEncoderFactoryAdapter(
- nullptr /* external_encoder_factory */)) {
+WebRtcVideoEngine::WebRtcVideoEngine(
+ WebRtcVideoEncoderFactory* external_video_encoder_factory,
+ WebRtcVideoDecoderFactory* external_video_decoder_factory)
+ : decoder_factory_(
+ new CricketDecoderFactoryAdapter(external_video_decoder_factory)),
+ encoder_factory_(
+ new CricketEncoderFactoryAdapter(external_video_encoder_factory)) {
LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine()";
}
@@ -415,19 +405,13 @@
LOG(LS_INFO) << "WebRtcVideoEngine::~WebRtcVideoEngine";
}
-void WebRtcVideoEngine::Init() {
- LOG(LS_INFO) << "WebRtcVideoEngine::Init";
- initialized_ = true;
-}
-
WebRtcVideoChannel* WebRtcVideoEngine::CreateChannel(
webrtc::Call* call,
const MediaConfig& config,
const VideoOptions& options) {
- RTC_DCHECK(initialized_);
LOG(LS_INFO) << "CreateChannel. Options: " << options.ToString();
- return new WebRtcVideoChannel(call, config, options, *encoder_factory_,
- *decoder_factory_);
+ return new WebRtcVideoChannel(call, config, options, encoder_factory_.get(),
+ decoder_factory_.get());
}
std::vector<VideoCodec> WebRtcVideoEngine::codecs() const {
@@ -460,23 +444,12 @@
return capabilities;
}
-void WebRtcVideoEngine::SetExternalDecoderFactory(
- WebRtcVideoDecoderFactory* decoder_factory) {
- RTC_DCHECK(!initialized_);
- decoder_factory_.reset(new CricketDecoderFactoryAdapter(decoder_factory));
-}
-
-void WebRtcVideoEngine::SetExternalEncoderFactory(
- WebRtcVideoEncoderFactory* encoder_factory) {
- RTC_DCHECK(!initialized_);
- encoder_factory_.reset(new CricketEncoderFactoryAdapter(encoder_factory));
-}
-
+namespace {
// This function will assign dynamic payload types (in the range [96, 127]) to
// the input codecs, and also add associated RTX codecs for recognized codecs
// (VP8, VP9, H264, and RED). It will also add default feedback params to the
// codecs.
-static std::vector<VideoCodec> AssignPayloadTypesAndAddAssociatedRtxCodecs(
+std::vector<VideoCodec> AssignPayloadTypesAndAddAssociatedRtxCodecs(
const std::vector<VideoCodec>& input_codecs) {
static const int kFirstDynamicPayloadType = 96;
static const int kLastDynamicPayloadType = 127;
@@ -513,6 +486,7 @@
}
return output_codecs;
}
+} // namespace
std::vector<VideoCodec> CricketEncoderFactoryAdapter::GetSupportedCodecs()
const {
@@ -540,14 +514,14 @@
webrtc::Call* call,
const MediaConfig& config,
const VideoOptions& options,
- const EncoderFactoryAdapter& encoder_factory,
- const DecoderFactoryAdapter& decoder_factory)
+ const EncoderFactoryAdapter* encoder_factory,
+ const DecoderFactoryAdapter* decoder_factory)
: VideoMediaChannel(config),
call_(call),
unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
video_config_(config.video),
- encoder_factory_(encoder_factory.clone()),
- decoder_factory_(decoder_factory.clone()),
+ encoder_factory_(encoder_factory),
+ decoder_factory_(decoder_factory),
default_send_options_(options),
last_stats_log_ms_(-1) {
RTC_DCHECK(thread_checker_.CalledOnValidThread());
@@ -1052,7 +1026,7 @@
config.periodic_alr_bandwidth_probing =
video_config_.periodic_alr_bandwidth_probing;
WebRtcVideoSendStream* stream = new WebRtcVideoSendStream(
- call_, sp, std::move(config), default_send_options_, *encoder_factory_,
+ call_, sp, std::move(config), default_send_options_, encoder_factory_,
video_config_.enable_cpu_overuse_detection,
bitrate_config_.max_bitrate_bps, send_codec_, send_rtp_extensions_,
send_params_);
@@ -1163,7 +1137,7 @@
config.sync_group = sp.sync_label;
receive_streams_[ssrc] = new WebRtcVideoReceiveStream(
- call_, sp, std::move(config), *decoder_factory_, default_stream,
+ call_, sp, std::move(config), decoder_factory_, default_stream,
recv_codecs_, flexfec_config);
return true;
@@ -1502,7 +1476,7 @@
const StreamParams& sp,
webrtc::VideoSendStream::Config config,
const VideoOptions& options,
- const EncoderFactoryAdapter& encoder_factory,
+ const EncoderFactoryAdapter* encoder_factory,
bool enable_cpu_overuse_detection,
int max_bitrate_bps,
const rtc::Optional<VideoCodecSettings>& codec_settings,
@@ -1516,7 +1490,7 @@
call_(call),
enable_cpu_overuse_detection_(enable_cpu_overuse_detection),
source_(nullptr),
- encoder_factory_(encoder_factory.clone()),
+ encoder_factory_(encoder_factory),
stream_(nullptr),
encoder_sink_(nullptr),
parameters_(std::move(config), options, max_bitrate_bps, codec_settings),
@@ -2103,7 +2077,7 @@
webrtc::Call* call,
const StreamParams& sp,
webrtc::VideoReceiveStream::Config config,
- const DecoderFactoryAdapter& decoder_factory,
+ const DecoderFactoryAdapter* decoder_factory,
bool default_stream,
const std::vector<VideoCodecSettings>& recv_codecs,
const webrtc::FlexfecReceiveStream::Config& flexfec_config)
@@ -2114,7 +2088,7 @@
config_(std::move(config)),
flexfec_config_(flexfec_config),
flexfec_stream_(nullptr),
- decoder_factory_(decoder_factory.clone()),
+ decoder_factory_(decoder_factory),
sink_(NULL),
first_frame_timestamp_(-1),
estimated_remote_start_ntp_time_ms_(0) {
diff --git a/media/engine/webrtcvideoengine.h b/media/engine/webrtcvideoengine.h
index e61f422..8c8aefb 100644
--- a/media/engine/webrtcvideoengine.h
+++ b/media/engine/webrtcvideoengine.h
@@ -97,12 +97,13 @@
// WebRtcVideoEngine is used for the new native WebRTC Video API (webrtc:1667).
class WebRtcVideoEngine {
public:
- WebRtcVideoEngine();
+ // Video engine does not take ownership of the video codec factories and the
+ // caller needs to make sure they outlive the video engine. Internal SW video
+ // codecs will be added on top of the external codecs.
+ WebRtcVideoEngine(WebRtcVideoEncoderFactory* external_video_encoder_factory,
+ WebRtcVideoDecoderFactory* external_video_decoder_factory);
virtual ~WebRtcVideoEngine();
- // Basic video engine implementation.
- void Init();
-
WebRtcVideoChannel* CreateChannel(webrtc::Call* call,
const MediaConfig& config,
const VideoOptions& options);
@@ -110,21 +111,9 @@
std::vector<VideoCodec> codecs() const;
RtpCapabilities GetCapabilities() const;
- // Set a WebRtcVideoDecoderFactory for external decoding. Video engine does
- // not take the ownership of |decoder_factory|. The caller needs to make sure
- // that |decoder_factory| outlives the video engine.
- void SetExternalDecoderFactory(WebRtcVideoDecoderFactory* decoder_factory);
- // Set a WebRtcVideoEncoderFactory for external encoding. Video engine does
- // not take the ownership of |encoder_factory|. The caller needs to make sure
- // that |encoder_factory| outlives the video engine.
- virtual void SetExternalEncoderFactory(
- WebRtcVideoEncoderFactory* encoder_factory);
-
private:
- bool initialized_;
-
- std::unique_ptr<DecoderFactoryAdapter> decoder_factory_;
- std::unique_ptr<EncoderFactoryAdapter> encoder_factory_;
+ const std::unique_ptr<DecoderFactoryAdapter> decoder_factory_;
+ const std::unique_ptr<EncoderFactoryAdapter> encoder_factory_;
};
class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
@@ -132,8 +121,8 @@
WebRtcVideoChannel(webrtc::Call* call,
const MediaConfig& config,
const VideoOptions& options,
- const EncoderFactoryAdapter& encoder_factory,
- const DecoderFactoryAdapter& decoder_factory);
+ const EncoderFactoryAdapter* encoder_factory,
+ const DecoderFactoryAdapter* decoder_factory);
~WebRtcVideoChannel() override;
// VideoMediaChannel implementation
@@ -261,7 +250,7 @@
const StreamParams& sp,
webrtc::VideoSendStream::Config config,
const VideoOptions& options,
- const EncoderFactoryAdapter& encoder_factory,
+ const EncoderFactoryAdapter* encoder_factory,
bool enable_cpu_overuse_detection,
int max_bitrate_bps,
const rtc::Optional<VideoCodecSettings>& codec_settings,
@@ -338,9 +327,9 @@
webrtc::Call* const call_;
const bool enable_cpu_overuse_detection_;
rtc::VideoSourceInterface<webrtc::VideoFrame>* source_
- RTC_ACCESS_ON(&thread_checker_);
- std::unique_ptr<EncoderFactoryAdapter> encoder_factory_
- RTC_ACCESS_ON(&thread_checker_);
+ ACCESS_ON(&thread_checker_);
+ const EncoderFactoryAdapter* const encoder_factory_
+ ACCESS_ON(&thread_checker_);
webrtc::VideoSendStream* stream_ RTC_ACCESS_ON(&thread_checker_);
rtc::VideoSinkInterface<webrtc::VideoFrame>* encoder_sink_
@@ -371,7 +360,7 @@
webrtc::Call* call,
const StreamParams& sp,
webrtc::VideoReceiveStream::Config config,
- const DecoderFactoryAdapter& decoder_factory,
+ const DecoderFactoryAdapter* decoder_factory,
bool default_stream,
const std::vector<VideoCodecSettings>& recv_codecs,
const webrtc::FlexfecReceiveStream::Config& flexfec_config);
@@ -432,7 +421,7 @@
webrtc::FlexfecReceiveStream::Config flexfec_config_;
webrtc::FlexfecReceiveStream* flexfec_stream_;
- std::unique_ptr<DecoderFactoryAdapter> decoder_factory_;
+ const DecoderFactoryAdapter* decoder_factory_;
DecoderMap allocated_decoders_;
rtc::CriticalSection sink_lock_;
@@ -496,8 +485,8 @@
rtc::Optional<VideoCodecSettings> send_codec_;
rtc::Optional<std::vector<webrtc::RtpExtension>> send_rtp_extensions_;
- std::unique_ptr<EncoderFactoryAdapter> encoder_factory_;
- std::unique_ptr<DecoderFactoryAdapter> decoder_factory_;
+ const EncoderFactoryAdapter* const encoder_factory_;
+ const DecoderFactoryAdapter* const decoder_factory_;
std::vector<VideoCodecSettings> recv_codecs_;
std::vector<webrtc::RtpExtension> recv_rtp_extensions_;
// See reason for keeping track of the FlexFEC payload type separately in
diff --git a/media/engine/webrtcvideoengine_unittest.cc b/media/engine/webrtcvideoengine_unittest.cc
index 1306082..683ccd5 100644
--- a/media/engine/webrtcvideoengine_unittest.cc
+++ b/media/engine/webrtcvideoengine_unittest.cc
@@ -147,7 +147,7 @@
explicit WebRtcVideoEngineTest(const char* field_trials)
: override_field_trials_(field_trials),
call_(webrtc::Call::Create(webrtc::Call::Config(&event_log_))),
- engine_() {
+ engine_(&encoder_factory_, &decoder_factory_) {
std::vector<VideoCodec> engine_codecs = engine_.codecs();
RTC_DCHECK(!engine_codecs.empty());
bool codec_set = false;
@@ -172,11 +172,9 @@
// present.
cricket::VideoCodec GetEngineCodec(const std::string& name);
- VideoMediaChannel* SetUpForExternalEncoderFactory(
- cricket::WebRtcVideoEncoderFactory* encoder_factory);
+ VideoMediaChannel* SetUpForExternalEncoderFactory();
VideoMediaChannel* SetUpForExternalDecoderFactory(
- cricket::WebRtcVideoDecoderFactory* decoder_factory,
const std::vector<VideoCodec>& codecs);
void TestExtendedEncoderOveruse(bool use_external_encoder);
@@ -186,6 +184,8 @@
// Used in WebRtcVideoEngineVoiceTest, but defined here so it's properly
// initialized when the constructor is called.
std::unique_ptr<webrtc::Call> call_;
+ cricket::FakeWebRtcVideoEncoderFactory encoder_factory_;
+ cricket::FakeWebRtcVideoDecoderFactory decoder_factory_;
WebRtcVideoEngine engine_;
VideoCodec default_codec_;
std::map<int, int> default_apt_rtx_types_;
@@ -273,11 +273,9 @@
// dtor is called.
cricket::FakeVideoCapturer capturer;
- cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
- encoder_factory.AddSupportedVideoCodecType("VP8");
+ encoder_factory_.AddSupportedVideoCodecType("VP8");
- std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalEncoderFactory(&encoder_factory));
+ std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
// Add CVO extension.
@@ -305,11 +303,9 @@
// dtor is called.
cricket::FakeVideoCapturer capturer;
- cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
- encoder_factory.AddSupportedVideoCodecType("VP8");
+ encoder_factory_.AddSupportedVideoCodecType("VP8");
- std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalEncoderFactory(&encoder_factory));
+ std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
// Add CVO extension.
const int id = 1;
cricket::VideoSendParameters parameters;
@@ -329,12 +325,10 @@
TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionAfterCapturer) {
cricket::FakeVideoCapturer capturer;
- cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
- encoder_factory.AddSupportedVideoCodecType("VP8");
- encoder_factory.AddSupportedVideoCodecType("VP9");
+ encoder_factory_.AddSupportedVideoCodecType("VP8");
+ encoder_factory_.AddSupportedVideoCodecType("VP9");
- std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalEncoderFactory(&encoder_factory));
+ std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
// Set capturer.
@@ -364,7 +358,6 @@
}
TEST_F(WebRtcVideoEngineTest, SetSendFailsBeforeSettingCodecs) {
- engine_.Init();
std::unique_ptr<VideoMediaChannel> channel(
engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
@@ -377,7 +370,6 @@
}
TEST_F(WebRtcVideoEngineTest, GetStatsWithoutSendCodecsSetDoesNotCrash) {
- engine_.Init();
std::unique_ptr<VideoMediaChannel> channel(
engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
@@ -386,16 +378,14 @@
}
TEST_F(WebRtcVideoEngineTest, UseExternalFactoryForVp8WhenSupported) {
- cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
- encoder_factory.AddSupportedVideoCodecType("VP8");
+ encoder_factory_.AddSupportedVideoCodecType("VP8");
- std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalEncoderFactory(&encoder_factory));
+ std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
channel->OnReadyToSend(true);
EXPECT_TRUE(
channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
- EXPECT_EQ(0, encoder_factory.GetNumCreatedEncoders());
+ EXPECT_EQ(0, encoder_factory_.GetNumCreatedEncoders());
EXPECT_TRUE(channel->SetSend(true));
cricket::FakeVideoCapturer capturer;
EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer));
@@ -403,11 +393,11 @@
capturer.Start(capturer.GetSupportedFormats()->front()));
EXPECT_TRUE(capturer.CaptureFrame());
// Sending one frame will have allocate the encoder.
- ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(1));
- EXPECT_TRUE_WAIT(encoder_factory.encoders()[0]->GetNumEncodedFrames() > 0,
+ ASSERT_TRUE(encoder_factory_.WaitForCreatedVideoEncoders(1));
+ EXPECT_TRUE_WAIT(encoder_factory_.encoders()[0]->GetNumEncodedFrames() > 0,
kTimeout);
- int num_created_encoders = encoder_factory.GetNumCreatedEncoders();
+ int num_created_encoders = encoder_factory_.GetNumCreatedEncoders();
EXPECT_EQ(num_created_encoders, 1);
// Setting codecs of the same type should not reallocate any encoders
@@ -415,11 +405,11 @@
cricket::VideoSendParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
EXPECT_TRUE(channel->SetSendParameters(parameters));
- EXPECT_EQ(num_created_encoders, encoder_factory.GetNumCreatedEncoders());
+ EXPECT_EQ(num_created_encoders, encoder_factory_.GetNumCreatedEncoders());
// Remove stream previously added to free the external encoder instance.
EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
- EXPECT_EQ(0u, encoder_factory.encoders().size());
+ EXPECT_EQ(0u, encoder_factory_.encoders().size());
}
// Test that when an external encoder factory supports a codec we don't
@@ -443,12 +433,9 @@
h264_high.params[kH264FmtpProfileLevelId] = *ProfileLevelIdToString(
ProfileLevelId(webrtc::H264::kProfileHigh, kLevel1));
- cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
- encoder_factory.AddSupportedVideoCodec(h264_constrained_baseline);
- encoder_factory.AddSupportedVideoCodec(h264_constrained_high);
- encoder_factory.AddSupportedVideoCodec(h264_high);
- engine_.SetExternalEncoderFactory(&encoder_factory);
- engine_.Init();
+ encoder_factory_.AddSupportedVideoCodec(h264_constrained_baseline);
+ encoder_factory_.AddSupportedVideoCodec(h264_constrained_high);
+ encoder_factory_.AddSupportedVideoCodec(h264_high);
// First figure out what payload types the test codecs got assigned.
const std::vector<cricket::VideoCodec> codecs = engine_.codecs();
@@ -464,15 +451,13 @@
void WebRtcVideoEngineTest::TestExtendedEncoderOveruse(
bool use_external_encoder) {
- cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
- encoder_factory.AddSupportedVideoCodecType("VP8");
std::unique_ptr<VideoMediaChannel> channel;
FakeCall* fake_call = new FakeCall(webrtc::Call::Config(&event_log_));
call_.reset(fake_call);
if (use_external_encoder) {
- channel.reset(SetUpForExternalEncoderFactory(&encoder_factory));
+ encoder_factory_.AddSupportedVideoCodecType("VP8");
+ channel.reset(SetUpForExternalEncoderFactory());
} else {
- engine_.Init();
channel.reset(
engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
}
@@ -500,11 +485,9 @@
#if !defined(RTC_DISABLE_VP9)
TEST_F(WebRtcVideoEngineTest, CanConstructDecoderForVp9EncoderFactory) {
- cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
- encoder_factory.AddSupportedVideoCodecType("VP9");
+ encoder_factory_.AddSupportedVideoCodecType("VP9");
- std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalEncoderFactory(&encoder_factory));
+ std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
EXPECT_TRUE(
channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
@@ -512,12 +495,10 @@
#endif // !defined(RTC_DISABLE_VP9)
TEST_F(WebRtcVideoEngineTest, PropagatesInputFrameTimestamp) {
- cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
- encoder_factory.AddSupportedVideoCodecType("VP8");
+ encoder_factory_.AddSupportedVideoCodecType("VP8");
FakeCall* fake_call = new FakeCall(webrtc::Call::Config(&event_log_));
call_.reset(fake_call);
- std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalEncoderFactory(&encoder_factory));
+ std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
EXPECT_TRUE(
channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
@@ -578,16 +559,12 @@
return cricket::VideoCodec();
}
-VideoMediaChannel* WebRtcVideoEngineTest::SetUpForExternalEncoderFactory(
- cricket::WebRtcVideoEncoderFactory* encoder_factory) {
- engine_.SetExternalEncoderFactory(encoder_factory);
- engine_.Init();
-
+VideoMediaChannel* WebRtcVideoEngineTest::SetUpForExternalEncoderFactory() {
VideoMediaChannel* channel =
engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions());
cricket::VideoSendParameters parameters;
// We need to look up the codec in the engine to get the correct payload type.
- for (const VideoCodec& codec : encoder_factory->supported_codecs())
+ for (const VideoCodec& codec : encoder_factory_.supported_codecs())
parameters.codecs.push_back(GetEngineCodec(codec.name));
EXPECT_TRUE(channel->SetSendParameters(parameters));
@@ -596,11 +573,7 @@
}
VideoMediaChannel* WebRtcVideoEngineTest::SetUpForExternalDecoderFactory(
- cricket::WebRtcVideoDecoderFactory* decoder_factory,
const std::vector<VideoCodec>& codecs) {
- engine_.SetExternalDecoderFactory(decoder_factory);
- engine_.Init();
-
VideoMediaChannel* channel =
engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions());
cricket::VideoRecvParameters parameters;
@@ -611,11 +584,9 @@
}
TEST_F(WebRtcVideoEngineTest, UsesSimulcastAdapterForVp8Factories) {
- cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
- encoder_factory.AddSupportedVideoCodecType("VP8");
+ encoder_factory_.AddSupportedVideoCodecType("VP8");
- std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalEncoderFactory(&encoder_factory));
+ std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
@@ -629,15 +600,15 @@
capturer.Start(capturer.GetSupportedFormats()->front()));
EXPECT_TRUE(capturer.CaptureFrame());
- ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(2));
+ ASSERT_TRUE(encoder_factory_.WaitForCreatedVideoEncoders(2));
// Verify that encoders are configured for simulcast through adapter
// (increasing resolution and only configured to send one stream each).
int prev_width = -1;
- for (size_t i = 0; i < encoder_factory.encoders().size(); ++i) {
- ASSERT_TRUE(encoder_factory.encoders()[i]->WaitForInitEncode());
+ for (size_t i = 0; i < encoder_factory_.encoders().size(); ++i) {
+ ASSERT_TRUE(encoder_factory_.encoders()[i]->WaitForInitEncode());
webrtc::VideoCodec codec_settings =
- encoder_factory.encoders()[i]->GetCodecSettings();
+ encoder_factory_.encoders()[i]->GetCodecSettings();
EXPECT_EQ(0, codec_settings.numberOfSimulcastStreams);
EXPECT_GT(codec_settings.width, prev_width);
prev_width = codec_settings.width;
@@ -646,33 +617,27 @@
EXPECT_TRUE(channel->SetVideoSend(ssrcs.front(), true, nullptr, nullptr));
channel.reset();
- ASSERT_EQ(0u, encoder_factory.encoders().size());
+ ASSERT_EQ(0u, encoder_factory_.encoders().size());
}
TEST_F(WebRtcVideoEngineTest, ChannelWithExternalH264CanChangeToInternalVp8) {
- cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
- encoder_factory.AddSupportedVideoCodecType("H264");
+ encoder_factory_.AddSupportedVideoCodecType("H264");
- std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalEncoderFactory(&encoder_factory));
+ std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
EXPECT_TRUE(
channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
- ASSERT_EQ(1u, encoder_factory.encoders().size());
+ ASSERT_EQ(1u, encoder_factory_.encoders().size());
cricket::VideoSendParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
EXPECT_TRUE(channel->SetSendParameters(parameters));
- ASSERT_EQ(0u, encoder_factory.encoders().size());
+ ASSERT_EQ(0u, encoder_factory_.encoders().size());
}
TEST_F(WebRtcVideoEngineTest,
DontUseExternalEncoderFactoryForUnsupportedCodecs) {
- cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
- encoder_factory.AddSupportedVideoCodecType("H264");
-
- engine_.SetExternalEncoderFactory(&encoder_factory);
- engine_.Init();
+ encoder_factory_.AddSupportedVideoCodecType("H264");
std::unique_ptr<VideoMediaChannel> channel(
engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
@@ -683,17 +648,13 @@
EXPECT_TRUE(
channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
// Make sure DestroyVideoEncoder was called on the factory.
- ASSERT_EQ(0u, encoder_factory.encoders().size());
+ ASSERT_EQ(0u, encoder_factory_.encoders().size());
}
TEST_F(WebRtcVideoEngineTest,
UsesSimulcastAdapterForVp8WithCombinedVP8AndH264Factory) {
- cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
- encoder_factory.AddSupportedVideoCodecType("VP8");
- encoder_factory.AddSupportedVideoCodecType("H264");
-
- engine_.SetExternalEncoderFactory(&encoder_factory);
- engine_.Init();
+ encoder_factory_.AddSupportedVideoCodecType("VP8");
+ encoder_factory_.AddSupportedVideoCodecType("H264");
std::unique_ptr<VideoMediaChannel> channel(
engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
@@ -716,24 +677,20 @@
capturer.Start(capturer.GetSupportedFormats()->front()));
EXPECT_TRUE(capturer.CaptureFrame());
- ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(2));
- ASSERT_TRUE(encoder_factory.encoders()[0]->WaitForInitEncode());
+ ASSERT_TRUE(encoder_factory_.WaitForCreatedVideoEncoders(2));
+ ASSERT_TRUE(encoder_factory_.encoders()[0]->WaitForInitEncode());
EXPECT_EQ(webrtc::kVideoCodecVP8,
- encoder_factory.encoders()[0]->GetCodecSettings().codecType);
+ encoder_factory_.encoders()[0]->GetCodecSettings().codecType);
channel.reset();
// Make sure DestroyVideoEncoder was called on the factory.
- EXPECT_EQ(0u, encoder_factory.encoders().size());
+ EXPECT_EQ(0u, encoder_factory_.encoders().size());
}
TEST_F(WebRtcVideoEngineTest,
DestroysNonSimulcastEncoderFromCombinedVP8AndH264Factory) {
- cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
- encoder_factory.AddSupportedVideoCodecType("VP8");
- encoder_factory.AddSupportedVideoCodecType("H264");
-
- engine_.SetExternalEncoderFactory(&encoder_factory);
- engine_.Init();
+ encoder_factory_.AddSupportedVideoCodecType("VP8");
+ encoder_factory_.AddSupportedVideoCodecType("H264");
std::unique_ptr<VideoMediaChannel> channel(
engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
@@ -743,7 +700,7 @@
EXPECT_TRUE(
channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
- ASSERT_EQ(1u, encoder_factory.encoders().size());
+ ASSERT_EQ(1u, encoder_factory_.encoders().size());
// Send a frame of 720p. This should trigger a "real" encoder initialization.
cricket::VideoFormat format(
@@ -752,21 +709,19 @@
EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer));
EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(format));
EXPECT_TRUE(capturer.CaptureFrame());
- ASSERT_TRUE(encoder_factory.encoders()[0]->WaitForInitEncode());
+ ASSERT_TRUE(encoder_factory_.encoders()[0]->WaitForInitEncode());
EXPECT_EQ(webrtc::kVideoCodecH264,
- encoder_factory.encoders()[0]->GetCodecSettings().codecType);
+ encoder_factory_.encoders()[0]->GetCodecSettings().codecType);
channel.reset();
// Make sure DestroyVideoEncoder was called on the factory.
- ASSERT_EQ(0u, encoder_factory.encoders().size());
+ ASSERT_EQ(0u, encoder_factory_.encoders().size());
}
TEST_F(WebRtcVideoEngineTest, SimulcastDisabledForH264) {
- cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
- encoder_factory.AddSupportedVideoCodecType("H264");
+ encoder_factory_.AddSupportedVideoCodecType("H264");
- std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalEncoderFactory(&encoder_factory));
+ std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
EXPECT_TRUE(
@@ -780,9 +735,9 @@
EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(format));
EXPECT_TRUE(capturer.CaptureFrame());
- ASSERT_EQ(1u, encoder_factory.encoders().size());
- FakeWebRtcVideoEncoder* encoder = encoder_factory.encoders()[0];
- ASSERT_TRUE(encoder_factory.encoders()[0]->WaitForInitEncode());
+ ASSERT_EQ(1u, encoder_factory_.encoders().size());
+ FakeWebRtcVideoEncoder* encoder = encoder_factory_.encoders()[0];
+ ASSERT_TRUE(encoder_factory_.encoders()[0]->WaitForInitEncode());
EXPECT_EQ(webrtc::kVideoCodecH264, encoder->GetCodecSettings().codecType);
EXPECT_EQ(1u, encoder->GetCodecSettings().numberOfSimulcastStreams);
EXPECT_TRUE(channel->SetVideoSend(ssrcs[0], true, nullptr, nullptr));
@@ -801,7 +756,6 @@
};
// FlexFEC is not active without field trial.
- engine_.Init();
const std::vector<VideoCodec> codecs_before = engine_.codecs();
EXPECT_EQ(codecs_before.end(), std::find_if(codecs_before.begin(),
codecs_before.end(), is_flexfec));
@@ -816,10 +770,7 @@
// Test that external codecs are added to the end of the supported codec list.
TEST_F(WebRtcVideoEngineTest, ReportSupportedExternalCodecs) {
- cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
- encoder_factory.AddSupportedVideoCodecType("FakeExternalCodec");
- engine_.SetExternalEncoderFactory(&encoder_factory);
- engine_.Init();
+ encoder_factory_.AddSupportedVideoCodecType("FakeExternalCodec");
std::vector<cricket::VideoCodec> codecs(engine_.codecs());
ASSERT_GE(codecs.size(), 2u);
@@ -835,42 +786,38 @@
// does show up in the codec list after it was added.
TEST_F(WebRtcVideoEngineTest, ReportSupportedExternalCodecsWithAddedCodec) {
// Set up external encoder factory with first codec, and initialize engine.
- cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
- encoder_factory.AddSupportedVideoCodecType("FakeExternalCodec1");
- engine_.SetExternalEncoderFactory(&encoder_factory);
- engine_.Init();
+ encoder_factory_.AddSupportedVideoCodecType("FakeExternalCodec1");
// The first external codec will appear last in the vector.
std::vector<cricket::VideoCodec> codecs_before(engine_.codecs());
EXPECT_EQ("FakeExternalCodec1", codecs_before.back().name);
// Add second codec.
- encoder_factory.AddSupportedVideoCodecType("FakeExternalCodec2");
+ encoder_factory_.AddSupportedVideoCodecType("FakeExternalCodec2");
std::vector<cricket::VideoCodec> codecs_after(engine_.codecs());
EXPECT_EQ(codecs_before.size() + 1, codecs_after.size());
EXPECT_EQ("FakeExternalCodec2", codecs_after.back().name);
}
TEST_F(WebRtcVideoEngineTest, RegisterExternalDecodersIfSupported) {
- cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
- decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
+ decoder_factory_.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
cricket::VideoRecvParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalDecoderFactory(&decoder_factory, parameters.codecs));
+ SetUpForExternalDecoderFactory(parameters.codecs));
EXPECT_TRUE(
channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
- ASSERT_EQ(1u, decoder_factory.decoders().size());
+ ASSERT_EQ(1u, decoder_factory_.decoders().size());
// Setting codecs of the same type should not reallocate the decoder.
EXPECT_TRUE(channel->SetRecvParameters(parameters));
- EXPECT_EQ(1, decoder_factory.GetNumCreatedDecoders());
+ EXPECT_EQ(1, decoder_factory_.GetNumCreatedDecoders());
// Remove stream previously added to free the external decoder instance.
EXPECT_TRUE(channel->RemoveRecvStream(kSsrc));
- EXPECT_EQ(0u, decoder_factory.decoders().size());
+ EXPECT_EQ(0u, decoder_factory_.decoders().size());
}
// Verifies that we can set up decoders that are not internally supported.
@@ -879,20 +826,17 @@
// can't even query the WebRtcVideoDecoderFactory for supported codecs.
// For now we add a FakeWebRtcVideoEncoderFactory to add H264 to supported
// codecs.
- cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
- encoder_factory.AddSupportedVideoCodecType("H264");
- engine_.SetExternalEncoderFactory(&encoder_factory);
- cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
- decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264);
+ encoder_factory_.AddSupportedVideoCodecType("H264");
+ decoder_factory_.AddSupportedVideoCodecType(webrtc::kVideoCodecH264);
std::vector<cricket::VideoCodec> codecs;
codecs.push_back(GetEngineCodec("H264"));
std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalDecoderFactory(&decoder_factory, codecs));
+ SetUpForExternalDecoderFactory(codecs));
EXPECT_TRUE(
channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
- ASSERT_EQ(1u, decoder_factory.decoders().size());
+ ASSERT_EQ(1u, decoder_factory_.decoders().size());
}
class WebRtcVideoChannelBaseTest
@@ -915,31 +859,28 @@
// Verifies that id given in stream params is passed to the decoder factory.
TEST_F(WebRtcVideoEngineTest, StreamParamsIdPassedToDecoderFactory) {
- cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
- decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
+ decoder_factory_.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
cricket::VideoRecvParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalDecoderFactory(&decoder_factory, parameters.codecs));
+ SetUpForExternalDecoderFactory(parameters.codecs));
StreamParams sp = cricket::StreamParams::CreateLegacy(kSsrc);
sp.id = "FakeStreamParamsId";
EXPECT_TRUE(channel->AddRecvStream(sp));
- EXPECT_EQ(1u, decoder_factory.decoders().size());
+ EXPECT_EQ(1u, decoder_factory_.decoders().size());
- std::vector<cricket::VideoDecoderParams> params = decoder_factory.params();
+ std::vector<cricket::VideoDecoderParams> params = decoder_factory_.params();
ASSERT_EQ(1u, params.size());
EXPECT_EQ(sp.id, params[0].receive_stream_id);
}
TEST_F(WebRtcVideoEngineTest, DISABLED_RecreatesEncoderOnContentTypeChange) {
- cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
- encoder_factory.AddSupportedVideoCodecType("VP8");
+ encoder_factory_.AddSupportedVideoCodecType("VP8");
std::unique_ptr<FakeCall> fake_call(
new FakeCall(webrtc::Call::Config(&event_log_)));
- std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalEncoderFactory(&encoder_factory));
+ std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
ASSERT_TRUE(
channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
cricket::VideoCodec codec = GetEngineCodec("VP8");
@@ -956,14 +897,14 @@
EXPECT_EQ(cricket::CS_RUNNING,
capturer.Start(capturer.GetSupportedFormats()->front()));
EXPECT_TRUE(capturer.CaptureFrame());
- ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(1));
+ ASSERT_TRUE(encoder_factory_.WaitForCreatedVideoEncoders(1));
EXPECT_EQ(webrtc::kRealtimeVideo,
- encoder_factory.encoders().back()->GetCodecSettings().mode);
+ encoder_factory_.encoders().back()->GetCodecSettings().mode);
EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, &options, &capturer));
EXPECT_TRUE(capturer.CaptureFrame());
// No change in content type, keep current encoder.
- EXPECT_EQ(1, encoder_factory.GetNumCreatedEncoders());
+ EXPECT_EQ(1, encoder_factory_.GetNumCreatedEncoders());
options.is_screencast.emplace(true);
EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, &options, &capturer));
@@ -971,14 +912,14 @@
// Change to screen content, recreate encoder. For the simulcast encoder
// adapter case, this will result in two calls since InitEncode triggers a
// a new instance.
- ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(2));
+ ASSERT_TRUE(encoder_factory_.WaitForCreatedVideoEncoders(2));
EXPECT_EQ(webrtc::kScreensharing,
- encoder_factory.encoders().back()->GetCodecSettings().mode);
+ encoder_factory_.encoders().back()->GetCodecSettings().mode);
EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, &options, &capturer));
EXPECT_TRUE(capturer.CaptureFrame());
// Still screen content, no need to update encoder.
- EXPECT_EQ(2, encoder_factory.GetNumCreatedEncoders());
+ EXPECT_EQ(2, encoder_factory_.GetNumCreatedEncoders());
options.is_screencast.emplace(false);
options.video_noise_reduction.emplace(false);
@@ -986,13 +927,13 @@
// Change back to regular video content, update encoder. Also change
// a non |is_screencast| option just to verify it doesn't affect recreation.
EXPECT_TRUE(capturer.CaptureFrame());
- ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(3));
+ ASSERT_TRUE(encoder_factory_.WaitForCreatedVideoEncoders(3));
EXPECT_EQ(webrtc::kRealtimeVideo,
- encoder_factory.encoders().back()->GetCodecSettings().mode);
+ encoder_factory_.encoders().back()->GetCodecSettings().mode);
// Remove stream previously added to free the external encoder instance.
EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
- EXPECT_EQ(0u, encoder_factory.encoders().size());
+ EXPECT_EQ(0u, encoder_factory_.encoders().size());
}
#define WEBRTC_BASE_TEST(test) \
@@ -1060,7 +1001,6 @@
: WebRtcVideoEngineTest(field_trials), last_ssrc_(0) {}
void SetUp() override {
fake_call_.reset(new FakeCall(webrtc::Call::Config(&event_log_)));
- engine_.Init();
channel_.reset(engine_.CreateChannel(fake_call_.get(), GetMediaConfig(),
VideoOptions()));
channel_->OnReadyToSend(true);
@@ -1979,19 +1919,11 @@
virtual ~Vp9SettingsTest() {}
protected:
- void SetUp() override {
- engine_.SetExternalEncoderFactory(&encoder_factory_);
-
- WebRtcVideoChannelTest::SetUp();
- }
-
void TearDown() override {
// Remove references to encoder_factory_ since this will be destroyed
// before channel_ and engine_.
ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
}
-
- cricket::FakeWebRtcVideoEncoderFactory encoder_factory_;
};
TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) {
@@ -4498,10 +4430,11 @@
class WebRtcVideoChannelSimulcastTest : public testing::Test {
public:
WebRtcVideoChannelSimulcastTest()
- : fake_call_(webrtc::Call::Config(&event_log_)), last_ssrc_(0) {}
+ : fake_call_(webrtc::Call::Config(&event_log_)),
+ engine_(&encoder_factory_, &decoder_factory_),
+ last_ssrc_(0) {}
void SetUp() override {
- engine_.Init();
channel_.reset(
engine_.CreateChannel(&fake_call_, GetMediaConfig(), VideoOptions()));
channel_->OnReadyToSend(true);
@@ -4657,6 +4590,8 @@
webrtc::RtcEventLogNullImpl event_log_;
FakeCall fake_call_;
+ cricket::FakeWebRtcVideoEncoderFactory encoder_factory_;
+ cricket::FakeWebRtcVideoDecoderFactory decoder_factory_;
WebRtcVideoEngine engine_;
std::unique_ptr<VideoMediaChannel> channel_;
uint32_t last_ssrc_;
