zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Simplify passing video coded factories in media engine

Browse Source 
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-Commit-Position: refs/heads/master@{#19794}
This commit is contained in:
magjed
2017-09-12 04:42:15 -07:00
committed by Commit Bot
parent 1e7dd31001
commit 2475ae2e4c
9 changed files with 209 additions and 381 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
webrtc/media/base/fakemediaengine.h
View File

@ -774,13 +774,7 @@ class FakeBaseEngine {
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 @@ class FakeVideoEngine : public FakeBaseEngine {
codecs_.push_back(VideoCodec(0, "fake_video_codec"));
}
void Init() {}
bool SetOptions(const VideoOptions& options) {
options_ = options;
options_changed_ = true;
@ -895,55 +887,50 @@ class FakeMediaEngine :
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);
}
};

58
webrtc/media/base/mediaengine.h
View File

@ -112,68 +112,62 @@ class MediaEngineFactory {
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 };

5
webrtc/media/base/videoengine_unittest.h
View File

@ -64,7 +64,9 @@ class VideoMediaChannelTest : public testing::Test,
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 @@ class VideoMediaChannelTest : public testing::Test,
}
virtual void SetUp() {
engine_.Init();
cricket::MediaConfig media_config;
// Disabling cpu overuse detection actually disables quality scaling too; it
// implies DegradationPreference kMaintainResolution. Automatic scaling

20
webrtc/media/engine/nullwebrtcvideoengine.h
View File

@ -33,31 +33,15 @@ class WebRtcVideoEncoderFactory;
// 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

14
webrtc/media/engine/nullwebrtcvideoengine_unittest.cc
View File

@ -25,18 +25,14 @@ class WebRtcMediaEngineNullVideo
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,
std::forward_as_tuple(adm,
audio_encoder_factory,
audio_decoder_factory,
nullptr,
webrtc::AudioProcessing::Create()) {
video_.SetExternalDecoderFactory(video_decoder_factory);
video_.SetExternalEncoderFactory(video_encoder_factory);
}
webrtc::AudioProcessing::Create()),
std::forward_as_tuple()) {}
};
// Simple test to check if NullWebRtcVideoEngine implements the methods
@ -44,7 +40,7 @@ class WebRtcMediaEngineNullVideo
TEST(NullWebRtcVideoEngineTest, CheckInterface) {
WebRtcMediaEngineNullVideo engine(
nullptr, webrtc::MockAudioEncoderFactory::CreateUnusedFactory(),
webrtc::MockAudioDecoderFactory::CreateUnusedFactory(), nullptr, nullptr);
webrtc::MockAudioDecoderFactory::CreateUnusedFactory());
EXPECT_TRUE(engine.Init());
}

64
webrtc/media/engine/webrtcmediaengine.cc
View File

@ -24,14 +24,9 @@
namespace cricket {
class WebRtcMediaEngine2
#ifdef HAVE_WEBRTC_VIDEO
: public CompositeMediaEngine<WebRtcVoiceEngine, WebRtcVideoEngine> {
#else
: public CompositeMediaEngine<WebRtcVoiceEngine, NullWebRtcVideoEngine> {
#endif
public:
WebRtcMediaEngine2(
namespace {
MediaEngineInterface* CreateWebRtcMediaEngine(
webrtc::AudioDeviceModule* adm,
const rtc::scoped_refptr<webrtc::AudioEncoderFactory>&
audio_encoder_factory,
@ -40,49 +35,22 @@ class WebRtcMediaEngine2
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 cricket
cricket::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,
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.

76
webrtc/media/engine/webrtcvideoengine.cc
View File

@ -68,8 +68,6 @@ class EncoderFactoryAdapter {
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 @@ class DecoderFactoryAdapter {
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 @@ class CricketEncoderFactoryAdapter : public EncoderFactoryAdapter {
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 @@ class CricketDecoderFactoryAdapter : public DecoderFactoryAdapter {
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 @@ void DefaultUnsignalledSsrcHandler::SetDefaultSink(
}
}
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 @@ WebRtcVideoEngine::~WebRtcVideoEngine() {
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 @@ RtpCapabilities WebRtcVideoEngine::GetCapabilities() const {
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 @@ static std::vector<VideoCodec> AssignPayloadTypesAndAddAssociatedRtxCodecs(
}
return output_codecs;
}
} // namespace
std::vector<VideoCodec> CricketEncoderFactoryAdapter::GetSupportedCodecs()
const {
@ -540,14 +514,14 @@ WebRtcVideoChannel::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)
: 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 @@ bool WebRtcVideoChannel::AddSendStream(const StreamParams& sp) {
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 @@ bool WebRtcVideoChannel::AddRecvStream(const StreamParams& sp,
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 @@ WebRtcVideoChannel::WebRtcVideoSendStream::WebRtcVideoSendStream(
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 @@ WebRtcVideoChannel::WebRtcVideoSendStream::WebRtcVideoSendStream(
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 @@ WebRtcVideoChannel::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
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 @@ WebRtcVideoChannel::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
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) {

45
webrtc/media/engine/webrtcvideoengine.h
View File

@ -97,12 +97,13 @@ class DefaultUnsignalledSsrcHandler : public UnsignalledSsrcHandler {
// 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 @@ class WebRtcVideoEngine {
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 @@ class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
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 @@ class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
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 @@ class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
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 @@ class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
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 @@ class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
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 @@ class WebRtcVideoChannel : public VideoMediaChannel, public webrtc::Transport {
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

249
webrtc/media/engine/webrtcvideoengine_unittest.cc
View File

@ -147,7 +147,7 @@ class WebRtcVideoEngineTest : public ::testing::Test {
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 @@ class WebRtcVideoEngineTest : public ::testing::Test {
// 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 @@ class WebRtcVideoEngineTest : public ::testing::Test {
// 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 @@ TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionBeforeCapturer) {
// 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 @@ TEST_F(WebRtcVideoEngineTest, CVOSetHeaderExtensionBeforeAddSendStream) {
// 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, CVOSetHeaderExtensionBeforeAddSendStream) {
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, CVOSetHeaderExtensionAfterCapturer) {
}
TEST_F(WebRtcVideoEngineTest, SetSendFailsBeforeSettingCodecs) {
engine_.Init();
std::unique_ptr<VideoMediaChannel> channel(
engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
@ -377,7 +370,6 @@ TEST_F(WebRtcVideoEngineTest, SetSendFailsBeforeSettingCodecs) {
}
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, GetStatsWithoutSendCodecsSetDoesNotCrash) {
}
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 @@ TEST_F(WebRtcVideoEngineTest, UseExternalFactoryForVp8WhenSupported) {
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 @@ TEST_F(WebRtcVideoEngineTest, UseExternalFactoryForVp8WhenSupported) {
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 @@ TEST_F(WebRtcVideoEngineTest, RtxCodecAddedForExternalCodec) {
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 @@ TEST_F(WebRtcVideoEngineTest, RtxCodecAddedForExternalCodec) {
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 @@ TEST_F(WebRtcVideoEngineTest, DisablesFullEncoderTimeForNonExternalEncoders) {
#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 @@ TEST_F(WebRtcVideoEngineTest, CanConstructDecoderForVp9EncoderFactory) {
#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 @@ cricket::VideoCodec WebRtcVideoEngineTest::GetEngineCodec(
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::SetUpForExternalEncoderFactory(
}
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 @@ VideoMediaChannel* WebRtcVideoEngineTest::SetUpForExternalDecoderFactory(
}
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 @@ TEST_F(WebRtcVideoEngineTest, UsesSimulcastAdapterForVp8Factories) {
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 @@ TEST_F(WebRtcVideoEngineTest, UsesSimulcastAdapterForVp8Factories) {
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 @@ TEST_F(WebRtcVideoEngineTest,
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 @@ TEST_F(WebRtcVideoEngineTest,
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 @@ TEST_F(WebRtcVideoEngineTest,
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 @@ TEST_F(WebRtcVideoEngineTest,
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 @@ TEST_F(WebRtcVideoEngineTest, SimulcastDisabledForH264) {
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 @@ TEST_F(WebRtcVideoEngineTest,
};
// 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_F(WebRtcVideoEngineTest,
// 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 @@ TEST_F(WebRtcVideoEngineTest, ReportSupportedExternalCodecs) {
// 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 @@ TEST_F(WebRtcVideoEngineTest, RegisterExternalH264DecoderIfSupported) {
// 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 @@ class WebRtcVideoChannelBaseTest
// 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 @@ TEST_F(WebRtcVideoEngineTest, DISABLED_RecreatesEncoderOnContentTypeChange) {
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 @@ TEST_F(WebRtcVideoEngineTest, DISABLED_RecreatesEncoderOnContentTypeChange) {
// 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 @@ TEST_F(WebRtcVideoEngineTest, DISABLED_RecreatesEncoderOnContentTypeChange) {
// 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 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest {
: 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 @@ class Vp9SettingsTest : public WebRtcVideoChannelTest {
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 @@ TEST_F(WebRtcVideoChannelTest, ConfiguresLocalSsrcOnExistingReceivers) {
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 @@ class WebRtcVideoChannelSimulcastTest : public testing::Test {
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_;