Config struct for VideoEncoder.
Used for config parameters in common between multiple codecs as well as
the encoder-specific pointer. In particular this contains content mode
(realtime video vs. screenshare).
BUG=1788
R=mflodman@webrtc.org, stefan@webrtc.org
Review URL: https://webrtc-codereview.appspot.com/16319004
git-svn-id: http://webrtc.googlecode.com/svn/trunk@7239 4adac7df-926f-26a2-2b94-8c16560cd09d
diff --git a/talk/media/webrtc/webrtcvideoengine2.cc b/talk/media/webrtc/webrtcvideoengine2.cc
index a1a9aa4..22a7630 100644
--- a/talk/media/webrtc/webrtcvideoengine2.cc
+++ b/talk/media/webrtc/webrtcvideoengine2.cc
@@ -229,13 +229,9 @@
if (encoder_settings == NULL) {
return;
}
-
if (_stricmp(codec.name.c_str(), kVp8CodecName) == 0) {
delete reinterpret_cast<webrtc::VideoCodecVP8*>(encoder_settings);
- return;
}
- // We should be able to destroy all encoder settings we've allocated.
- assert(false);
}
bool WebRtcVideoEncoderFactory2::SupportsCodec(const VideoCodec& codec) {
@@ -1389,8 +1385,8 @@
LOG(LS_VERBOSE) << "SwapFrame: " << video_frame_.width() << "x"
<< video_frame_.height() << " -> (codec) "
- << parameters_.video_streams.back().width << "x"
- << parameters_.video_streams.back().height;
+ << parameters_.encoder_config.streams.back().width << "x"
+ << parameters_.encoder_config.streams.back().height;
stream_->Input()->SwapFrame(&video_frame_);
}
@@ -1446,7 +1442,7 @@
<< parameters_.config.rtp.ssrcs[0] << ".";
} else {
// TODO(pbos): Fix me, this only affects the last stream!
- parameters_.video_streams.back().max_framerate =
+ parameters_.encoder_config.streams.back().max_framerate =
VideoFormat::IntervalToFps(format.interval);
SetDimensions(format.width, format.height, false);
}
@@ -1494,7 +1490,7 @@
if (video_streams.empty()) {
return;
}
- parameters_.video_streams = video_streams;
+ parameters_.encoder_config.streams = video_streams;
format_ = VideoFormat(codec_settings.codec.width,
codec_settings.codec.height,
VideoFormat::FpsToInterval(30),
@@ -1541,7 +1537,7 @@
int width,
int height,
bool override_max) {
- assert(!parameters_.video_streams.empty());
+ assert(!parameters_.encoder_config.streams.empty());
LOG(LS_VERBOSE) << "SetDimensions: " << width << "x" << height;
VideoCodecSettings codec_settings;
@@ -1554,27 +1550,30 @@
height = codec_settings.codec.height;
}
- if (parameters_.video_streams.back().width == width &&
- parameters_.video_streams.back().height == height) {
+ if (parameters_.encoder_config.streams.back().width == width &&
+ parameters_.encoder_config.streams.back().height == height) {
return;
}
- void* encoder_settings = encoder_factory_->CreateVideoEncoderSettings(
- codec_settings.codec, parameters_.options);
+ webrtc::VideoEncoderConfig encoder_config = parameters_.encoder_config;
+ encoder_config.encoder_specific_settings =
+ encoder_factory_->CreateVideoEncoderSettings(codec_settings.codec,
+ parameters_.options);
VideoCodec codec = codec_settings.codec;
codec.width = width;
codec.height = height;
- std::vector<webrtc::VideoStream> video_streams =
- encoder_factory_->CreateVideoStreams(codec,
- parameters_.options,
- parameters_.config.rtp.ssrcs.size());
- bool stream_reconfigured = stream_->ReconfigureVideoEncoder(
- video_streams, encoder_settings);
+ encoder_config.streams = encoder_factory_->CreateVideoStreams(
+ codec, parameters_.options, parameters_.config.rtp.ssrcs.size());
- encoder_factory_->DestroyVideoEncoderSettings(codec_settings.codec,
- encoder_settings);
+ bool stream_reconfigured = stream_->ReconfigureVideoEncoder(encoder_config);
+
+ encoder_factory_->DestroyVideoEncoderSettings(
+ codec_settings.codec,
+ encoder_config.encoder_specific_settings);
+
+ encoder_config.encoder_specific_settings = NULL;
if (!stream_reconfigured) {
LOG(LS_WARNING) << "Failed to reconfigure video encoder for dimensions: "
@@ -1582,7 +1581,7 @@
return;
}
- parameters_.video_streams = video_streams;
+ parameters_.encoder_config = encoder_config;
}
void WebRtcVideoChannel2::WebRtcVideoSendStream::Start() {
@@ -1646,9 +1645,9 @@
info.input_frame_width = last_captured_frame_format.width;
info.input_frame_height = last_captured_frame_format.height;
info.send_frame_width =
- static_cast<int>(parameters_.video_streams.front().width);
+ static_cast<int>(parameters_.encoder_config.streams.front().width);
info.send_frame_height =
- static_cast<int>(parameters_.video_streams.front().height);
+ static_cast<int>(parameters_.encoder_config.streams.front().height);
}
// TODO(pbos): Support or remove the following stats.
@@ -1665,14 +1664,18 @@
VideoCodecSettings codec_settings;
parameters_.codec_settings.Get(&codec_settings);
- void* encoder_settings = encoder_factory_->CreateVideoEncoderSettings(
- codec_settings.codec, parameters_.options);
+ parameters_.encoder_config.encoder_specific_settings =
+ encoder_factory_->CreateVideoEncoderSettings(codec_settings.codec,
+ parameters_.options);
- stream_ = call_->CreateVideoSendStream(
- parameters_.config, parameters_.video_streams, encoder_settings);
+ stream_ = call_->CreateVideoSendStream(parameters_.config,
+ parameters_.encoder_config);
- encoder_factory_->DestroyVideoEncoderSettings(codec_settings.codec,
- encoder_settings);
+ encoder_factory_->DestroyVideoEncoderSettings(
+ codec_settings.codec,
+ parameters_.encoder_config.encoder_specific_settings);
+
+ parameters_.encoder_config.encoder_specific_settings = NULL;
if (sending_) {
stream_->Start();
diff --git a/talk/media/webrtc/webrtcvideoengine2.h b/talk/media/webrtc/webrtcvideoengine2.h
index d77afb9..f285d10 100644
--- a/talk/media/webrtc/webrtcvideoengine2.h
+++ b/talk/media/webrtc/webrtcvideoengine2.h
@@ -119,9 +119,8 @@
const VideoCodec& codec,
const VideoOptions& options);
- virtual void* CreateVideoEncoderSettings(
- const VideoCodec& codec,
- const VideoOptions& options);
+ virtual void* CreateVideoEncoderSettings(const VideoCodec& codec,
+ const VideoOptions& options);
virtual void DestroyVideoEncoderSettings(const VideoCodec& codec,
void* encoder_settings);
@@ -316,7 +315,7 @@
// Sent resolutions + bitrates etc. by the underlying VideoSendStream,
// typically changes when setting a new resolution or reconfiguring
// bitrates.
- std::vector<webrtc::VideoStream> video_streams;
+ webrtc::VideoEncoderConfig encoder_config;
};
void SetCodecAndOptions(const VideoCodecSettings& codec,
diff --git a/talk/media/webrtc/webrtcvideoengine2_unittest.cc b/talk/media/webrtc/webrtcvideoengine2_unittest.cc
index 2178a68..6112c50 100644
--- a/talk/media/webrtc/webrtcvideoengine2_unittest.cc
+++ b/talk/media/webrtc/webrtcvideoengine2_unittest.cc
@@ -68,13 +68,10 @@
namespace cricket {
FakeVideoSendStream::FakeVideoSendStream(
const webrtc::VideoSendStream::Config& config,
- const std::vector<webrtc::VideoStream>& video_streams,
- const void* encoder_settings)
- : sending_(false),
- config_(config),
- codec_settings_set_(false) {
+ const webrtc::VideoEncoderConfig& encoder_config)
+ : sending_(false), config_(config), codec_settings_set_(false) {
assert(config.encoder_settings.encoder != NULL);
- ReconfigureVideoEncoder(video_streams, encoder_settings);
+ ReconfigureVideoEncoder(encoder_config);
}
webrtc::VideoSendStream::Config FakeVideoSendStream::GetConfig() {
@@ -82,7 +79,7 @@
}
std::vector<webrtc::VideoStream> FakeVideoSendStream::GetVideoStreams() {
- return video_streams_;
+ return encoder_config_.streams;
}
bool FakeVideoSendStream::IsSending() const {
@@ -104,15 +101,14 @@
}
bool FakeVideoSendStream::ReconfigureVideoEncoder(
- const std::vector<webrtc::VideoStream>& streams,
- const void* encoder_specific) {
- video_streams_ = streams;
- if (encoder_specific != NULL) {
+ const webrtc::VideoEncoderConfig& config) {
+ encoder_config_ = config;
+ if (config.encoder_specific_settings != NULL) {
assert(config_.encoder_settings.payload_name == "VP8");
- vp8_settings_ =
- *reinterpret_cast<const webrtc::VideoCodecVP8*>(encoder_specific);
+ vp8_settings_ = *reinterpret_cast<const webrtc::VideoCodecVP8*>(
+ config.encoder_specific_settings);
}
- codec_settings_set_ = encoder_specific != NULL;
+ codec_settings_set_ = config.encoder_specific_settings != NULL;
return true;
}
@@ -226,10 +222,9 @@
webrtc::VideoSendStream* FakeCall::CreateVideoSendStream(
const webrtc::VideoSendStream::Config& config,
- const std::vector<webrtc::VideoStream>& video_streams,
- const void* encoder_settings) {
+ const webrtc::VideoEncoderConfig& encoder_config) {
FakeVideoSendStream* fake_stream =
- new FakeVideoSendStream(config, video_streams, encoder_settings);
+ new FakeVideoSendStream(config, encoder_config);
video_send_streams_.push_back(fake_stream);
return fake_stream;
}
diff --git a/talk/media/webrtc/webrtcvideoengine2_unittest.h b/talk/media/webrtc/webrtcvideoengine2_unittest.h
index 5aaa3e3..30f1efb 100644
--- a/talk/media/webrtc/webrtcvideoengine2_unittest.h
+++ b/talk/media/webrtc/webrtcvideoengine2_unittest.h
@@ -39,8 +39,7 @@
class FakeVideoSendStream : public webrtc::VideoSendStream {
public:
FakeVideoSendStream(const webrtc::VideoSendStream::Config& config,
- const std::vector<webrtc::VideoStream>& video_streams,
- const void* encoder_settings);
+ const webrtc::VideoEncoderConfig& encoder_config);
webrtc::VideoSendStream::Config GetConfig();
std::vector<webrtc::VideoStream> GetVideoStreams();
@@ -51,8 +50,7 @@
virtual webrtc::VideoSendStream::Stats GetStats() const OVERRIDE;
virtual bool ReconfigureVideoEncoder(
- const std::vector<webrtc::VideoStream>& streams,
- const void* encoder_specific);
+ const webrtc::VideoEncoderConfig& config) OVERRIDE;
virtual webrtc::VideoSendStreamInput* Input() OVERRIDE;
@@ -61,7 +59,7 @@
bool sending_;
webrtc::VideoSendStream::Config config_;
- std::vector<webrtc::VideoStream> video_streams_;
+ webrtc::VideoEncoderConfig encoder_config_;
bool codec_settings_set_;
webrtc::VideoCodecVP8 vp8_settings_;
};
@@ -108,8 +106,7 @@
private:
virtual webrtc::VideoSendStream* CreateVideoSendStream(
const webrtc::VideoSendStream::Config& config,
- const std::vector<webrtc::VideoStream>& video_streams,
- const void* encoder_settings) OVERRIDE;
+ const webrtc::VideoEncoderConfig& encoder_config) OVERRIDE;
virtual void DestroyVideoSendStream(
webrtc::VideoSendStream* send_stream) OVERRIDE;
diff --git a/webrtc/call.h b/webrtc/call.h
index 3030074..bb1dca1 100644
--- a/webrtc/call.h
+++ b/webrtc/call.h
@@ -92,8 +92,7 @@
virtual VideoSendStream* CreateVideoSendStream(
const VideoSendStream::Config& config,
- const std::vector<VideoStream>& video_streams,
- const void* encoder_settings) = 0;
+ const VideoEncoderConfig& encoder_config) = 0;
virtual void DestroyVideoSendStream(VideoSendStream* send_stream) = 0;
diff --git a/webrtc/config.h b/webrtc/config.h
index e4bccf9..6f3fb1d 100644
--- a/webrtc/config.h
+++ b/webrtc/config.h
@@ -108,6 +108,20 @@
std::vector<int> temporal_layers;
};
+struct VideoEncoderConfig {
+ enum ContentType {
+ kRealtimeVideo,
+ kScreenshare,
+ };
+
+ VideoEncoderConfig()
+ : content_type(kRealtimeVideo), encoder_specific_settings(NULL) {}
+
+ std::vector<VideoStream> streams;
+ ContentType content_type;
+ void* encoder_specific_settings;
+};
+
} // namespace webrtc
#endif // WEBRTC_CONFIG_H_
diff --git a/webrtc/test/call_test.cc b/webrtc/test/call_test.cc
index ccad755..d49f6e3 100644
--- a/webrtc/test/call_test.cc
+++ b/webrtc/test/call_test.cc
@@ -16,7 +16,6 @@
CallTest::CallTest()
: clock_(Clock::GetRealTimeClock()),
- encoder_settings_(NULL),
send_stream_(NULL),
fake_encoder_(clock_) {
}
@@ -40,8 +39,7 @@
if (test->ShouldCreateReceivers()) {
CreateMatchingReceiveConfigs();
}
- encoder_settings_ = test->GetEncoderSettings();
- test->ModifyConfigs(&send_config_, &receive_configs_, &video_streams_);
+ test->ModifyConfigs(&send_config_, &receive_configs_, &encoder_config_);
CreateStreams();
test->OnStreamsCreated(send_stream_, receive_streams_);
@@ -92,7 +90,7 @@
send_config_.encoder_settings.encoder = &fake_encoder_;
send_config_.encoder_settings.payload_name = "FAKE";
send_config_.encoder_settings.payload_type = kFakeSendPayloadType;
- video_streams_ = test::CreateVideoStreams(num_streams);
+ encoder_config_.streams = test::CreateVideoStreams(num_streams);
for (size_t i = 0; i < num_streams; ++i)
send_config_.rtp.ssrcs.push_back(kSendSsrcs[i]);
}
@@ -123,7 +121,7 @@
}
void CallTest::CreateFrameGeneratorCapturer() {
- VideoStream stream = video_streams_.back();
+ VideoStream stream = encoder_config_.streams.back();
frame_generator_capturer_.reset(
test::FrameGeneratorCapturer::Create(send_stream_->Input(),
stream.width,
@@ -135,8 +133,8 @@
assert(send_stream_ == NULL);
assert(receive_streams_.empty());
- send_stream_ = sender_call_->CreateVideoSendStream(
- send_config_, video_streams_, encoder_settings_);
+ send_stream_ =
+ sender_call_->CreateVideoSendStream(send_config_, encoder_config_);
for (size_t i = 0; i < receive_configs_.size(); ++i) {
receive_streams_.push_back(
@@ -193,14 +191,10 @@
return 1;
}
-const void* BaseTest::GetEncoderSettings() {
- return NULL;
-}
-
void BaseTest::ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) {
+ VideoEncoderConfig* encoder_config) {
}
void BaseTest::OnStreamsCreated(
diff --git a/webrtc/test/call_test.h b/webrtc/test/call_test.h
index a03c3bb..695fb2a 100644
--- a/webrtc/test/call_test.h
+++ b/webrtc/test/call_test.h
@@ -65,8 +65,7 @@
scoped_ptr<Call> sender_call_;
VideoSendStream::Config send_config_;
- std::vector<VideoStream> video_streams_;
- const void* encoder_settings_;
+ VideoEncoderConfig encoder_config_;
VideoSendStream* send_stream_;
scoped_ptr<Call> receiver_call_;
@@ -93,11 +92,10 @@
virtual Call::Config GetReceiverCallConfig();
virtual void OnCallsCreated(Call* sender_call, Call* receiver_call);
- virtual const void* GetEncoderSettings();
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams);
+ VideoEncoderConfig* encoder_config);
virtual void OnStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams);
diff --git a/webrtc/video/bitrate_estimator_tests.cc b/webrtc/video/bitrate_estimator_tests.cc
index 40c1ed6..6f12805 100644
--- a/webrtc/video/bitrate_estimator_tests.cc
+++ b/webrtc/video/bitrate_estimator_tests.cc
@@ -148,7 +148,7 @@
send_config_.encoder_settings.encoder = NULL;
send_config_.encoder_settings.payload_name = "FAKE";
send_config_.encoder_settings.payload_type = kFakeSendPayloadType;
- video_streams_ = test::CreateVideoStreams(1);
+ encoder_config_.streams = test::CreateVideoStreams(1);
receive_config_ = VideoReceiveStream::Config();
assert(receive_config_.codecs.empty());
@@ -195,14 +195,14 @@
test_->send_config_.rtp.ssrcs[0]++;
test_->send_config_.encoder_settings.encoder = &fake_encoder_;
send_stream_ = test_->sender_call_->CreateVideoSendStream(
- test_->send_config_, test_->video_streams_, NULL);
- assert(test_->video_streams_.size() == 1);
- frame_generator_capturer_.reset(
- test::FrameGeneratorCapturer::Create(send_stream_->Input(),
- test_->video_streams_[0].width,
- test_->video_streams_[0].height,
- 30,
- Clock::GetRealTimeClock()));
+ test_->send_config_, test_->encoder_config_);
+ assert(test_->encoder_config_.streams.size() == 1);
+ frame_generator_capturer_.reset(test::FrameGeneratorCapturer::Create(
+ send_stream_->Input(),
+ test_->encoder_config_.streams[0].width,
+ test_->encoder_config_.streams[0].height,
+ 30,
+ Clock::GetRealTimeClock()));
send_stream_->Start();
frame_generator_capturer_->Start();
diff --git a/webrtc/video/call.cc b/webrtc/video/call.cc
index b4adafd..442e75b 100644
--- a/webrtc/video/call.cc
+++ b/webrtc/video/call.cc
@@ -87,8 +87,7 @@
virtual VideoSendStream* CreateVideoSendStream(
const VideoSendStream::Config& config,
- const std::vector<VideoStream>& video_streams,
- const void* encoder_settings) OVERRIDE;
+ const VideoEncoderConfig& encoder_config) OVERRIDE;
virtual void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream)
OVERRIDE;
@@ -196,8 +195,7 @@
VideoSendStream* Call::CreateVideoSendStream(
const VideoSendStream::Config& config,
- const std::vector<VideoStream>& video_streams,
- const void* encoder_settings) {
+ const VideoEncoderConfig& encoder_config) {
assert(config.rtp.ssrcs.size() > 0);
// TODO(mflodman): Base the start bitrate on a current bandwidth estimate, if
@@ -207,8 +205,7 @@
overuse_observer_proxy_.get(),
video_engine_,
config,
- video_streams,
- encoder_settings,
+ encoder_config,
suspended_send_ssrcs_,
base_channel_id_,
config_.start_bitrate_bps != -1 ? config_.start_bitrate_bps
diff --git a/webrtc/video/call_perf_tests.cc b/webrtc/video/call_perf_tests.cc
index 557c514..d055af9 100644
--- a/webrtc/video/call_perf_tests.cc
+++ b/webrtc/video/call_perf_tests.cc
@@ -399,7 +399,7 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
(*receive_configs)[0].renderer = this;
// Enable the receiver side rtt calculation.
(*receive_configs)[0].rtp.rtcp_xr.receiver_reference_time_report = true;
@@ -546,7 +546,7 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
if (pad_to_min_bitrate_) {
send_config->rtp.min_transmit_bitrate_bps = kMinTransmitBitrateBps;
} else {
diff --git a/webrtc/video/end_to_end_tests.cc b/webrtc/video/end_to_end_tests.cc
index 1b76eab..0e87a03 100644
--- a/webrtc/video/end_to_end_tests.cc
+++ b/webrtc/video/end_to_end_tests.cc
@@ -208,7 +208,7 @@
Start();
scoped_ptr<test::FrameGenerator> frame_generator(test::FrameGenerator::Create(
- video_streams_[0].width, video_streams_[0].height));
+ encoder_config_.streams[0].width, encoder_config_.streams[0].height));
send_stream_->Input()->SwapFrame(frame_generator->NextFrame());
EXPECT_EQ(kEventSignaled, renderer.Wait())
@@ -238,13 +238,13 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
send_config->encoder_settings.encoder = &fake_encoder_;
send_config->encoder_settings.payload_name = "H264";
send_config->encoder_settings.payload_type = kFakeSendPayloadType;
- (*video_streams)[0].min_bitrate_bps = 50000;
- (*video_streams)[0].target_bitrate_bps =
- (*video_streams)[0].max_bitrate_bps = 2000000;
+ encoder_config->streams[0].min_bitrate_bps = 50000;
+ encoder_config->streams[0].target_bitrate_bps =
+ encoder_config->streams[0].max_bitrate_bps = 2000000;
(*receive_configs)[0].renderer = this;
VideoCodec codec =
@@ -369,7 +369,7 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
(*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
}
@@ -463,7 +463,7 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
// TODO(pbos): Run this test with combined NACK/FEC enabled as well.
// int rtp_history_ms = 1000;
// (*receive_configs)[0].rtp.nack.rtp_history_ms = rtp_history_ms;
@@ -541,7 +541,7 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
(*receive_configs)[0].pre_render_callback = this;
(*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
@@ -647,9 +647,9 @@
VideoEncoder::Create(VideoEncoder::kVp8));
send_config_.encoder_settings.encoder = encoder.get();
send_config_.encoder_settings.payload_name = "VP8";
- ASSERT_EQ(1u, video_streams_.size()) << "Test setup error.";
- video_streams_[0].width = kWidth;
- video_streams_[0].height = kHeight;
+ ASSERT_EQ(1u, encoder_config_.streams.size()) << "Test setup error.";
+ encoder_config_.streams[0].width = kWidth;
+ encoder_config_.streams[0].height = kHeight;
send_config_.pre_encode_callback = &pre_encode_callback;
CreateMatchingReceiveConfigs();
@@ -744,7 +744,7 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
send_config->rtp.nack.rtp_history_ms = rtp_history_ms_;
(*receive_configs)[0].rtp.nack.rtp_history_ms = rtp_history_ms_;
(*receive_configs)[0].renderer = this;
@@ -891,7 +891,7 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
(*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
(*receive_configs)[0].rtp.rtcp_mode = rtcp_mode_;
@@ -988,15 +988,16 @@
send_config.encoder_settings.encoder = encoders[i].get();
send_config.encoder_settings.payload_name = "VP8";
send_config.encoder_settings.payload_type = 124;
- std::vector<VideoStream> video_streams = test::CreateVideoStreams(1);
- VideoStream* stream = &video_streams[0];
+ VideoEncoderConfig encoder_config;
+ encoder_config.streams = test::CreateVideoStreams(1);
+ VideoStream* stream = &encoder_config.streams[0];
stream->width = width;
stream->height = height;
stream->max_framerate = 5;
stream->min_bitrate_bps = stream->target_bitrate_bps =
stream->max_bitrate_bps = 100000;
send_streams[i] =
- sender_call->CreateVideoSendStream(send_config, video_streams, NULL);
+ sender_call->CreateVideoSendStream(send_config, encoder_config);
send_streams[i]->Start();
VideoReceiveStream::Config receive_config;
@@ -1087,7 +1088,7 @@
Start();
scoped_ptr<test::FrameGenerator> frame_generator(test::FrameGenerator::Create(
- video_streams_[0].width, video_streams_[0].height));
+ encoder_config_.streams[0].width, encoder_config_.streams[0].height));
send_stream_->Input()->SwapFrame(frame_generator->NextFrame());
EXPECT_EQ(kEventSignaled, post_encode_observer.Wait())
@@ -1212,7 +1213,7 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
(*receive_configs)[0].rtp.rtcp_mode = newapi::kRtcpReducedSize;
(*receive_configs)[0].rtp.rtcp_xr.receiver_reference_time_report =
enable_rrtr_;
@@ -1280,19 +1281,19 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
if (num_ssrcs_ > 1) {
// Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
- for (size_t i = 0; i < video_streams->size(); ++i) {
- (*video_streams)[i].min_bitrate_bps = 10000;
- (*video_streams)[i].target_bitrate_bps = 15000;
- (*video_streams)[i].max_bitrate_bps = 20000;
+ for (size_t i = 0; i < encoder_config->streams.size(); ++i) {
+ encoder_config->streams[i].min_bitrate_bps = 10000;
+ encoder_config->streams[i].target_bitrate_bps = 15000;
+ encoder_config->streams[i].max_bitrate_bps = 20000;
}
}
- all_streams_ = *video_streams;
+ encoder_config_all_streams_ = *encoder_config;
if (send_single_ssrc_first_)
- video_streams->resize(1);
+ encoder_config->streams.resize(1);
}
virtual void OnStreamsCreated(
@@ -1308,7 +1309,7 @@
if (send_single_ssrc_first_) {
// Set full simulcast and continue with the rest of the SSRCs.
- send_stream_->ReconfigureVideoEncoder(all_streams_, NULL);
+ send_stream_->ReconfigureVideoEncoder(encoder_config_all_streams_);
EXPECT_EQ(kEventSignaled, Wait())
<< "Timed out while waiting on additional SSRCs.";
}
@@ -1325,7 +1326,7 @@
bool expect_single_ssrc_;
VideoSendStream* send_stream_;
- std::vector<VideoStream> all_streams_;
+ VideoEncoderConfig encoder_config_all_streams_;
} test(kSendSsrcs, num_ssrcs, send_single_ssrc_first);
RunBaseTest(&test);
@@ -1469,7 +1470,7 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
send_config->pre_encode_callback = this; // Used to inject delay.
send_config->rtp.c_name = "SomeCName";
@@ -1645,12 +1646,12 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
// Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
- for (size_t i = 0; i < video_streams->size(); ++i) {
- (*video_streams)[i].min_bitrate_bps = 10000;
- (*video_streams)[i].target_bitrate_bps = 15000;
- (*video_streams)[i].max_bitrate_bps = 20000;
+ for (size_t i = 0; i < encoder_config->streams.size(); ++i) {
+ encoder_config->streams[i].min_bitrate_bps = 10000;
+ encoder_config->streams[i].target_bitrate_bps = 15000;
+ encoder_config->streams[i].max_bitrate_bps = 20000;
}
// Significantly higher than max bitrates for all video streams -> forcing
// padding to trigger redundant padding on all RTX SSRCs.
@@ -1784,10 +1785,10 @@
}
// Lower bitrates so that all streams send initially.
- for (size_t i = 0; i < video_streams_.size(); ++i) {
- video_streams_[i].min_bitrate_bps = 10000;
- video_streams_[i].target_bitrate_bps = 15000;
- video_streams_[i].max_bitrate_bps = 20000;
+ for (size_t i = 0; i < encoder_config_.streams.size(); ++i) {
+ encoder_config_.streams[i].min_bitrate_bps = 10000;
+ encoder_config_.streams[i].target_bitrate_bps = 15000;
+ encoder_config_.streams[i].max_bitrate_bps = 20000;
}
CreateMatchingReceiveConfigs();
@@ -1806,10 +1807,10 @@
sender_call_->DestroyVideoSendStream(send_stream_);
// Re-create VideoSendStream with only one stream.
- std::vector<VideoStream> one_stream = video_streams_;
- one_stream.resize(1);
+ VideoEncoderConfig one_stream = encoder_config_;
+ one_stream.streams.resize(1);
send_stream_ =
- sender_call_->CreateVideoSendStream(send_config_, one_stream, NULL);
+ sender_call_->CreateVideoSendStream(send_config_, one_stream);
send_stream_->Start();
CreateFrameGeneratorCapturer();
frame_generator_capturer_->Start();
@@ -1819,19 +1820,19 @@
<< "Timed out waiting for single RTP packet.";
// Reconfigure back to use all streams.
- send_stream_->ReconfigureVideoEncoder(video_streams_, NULL);
+ send_stream_->ReconfigureVideoEncoder(encoder_config_);
observer.ResetExpectedSsrcs(kNumSsrcs);
EXPECT_EQ(kEventSignaled, observer.Wait())
<< "Timed out waiting for all SSRCs to send packets.";
// Reconfigure down to one stream.
- send_stream_->ReconfigureVideoEncoder(one_stream, NULL);
+ send_stream_->ReconfigureVideoEncoder(one_stream);
observer.ResetExpectedSsrcs(1);
EXPECT_EQ(kEventSignaled, observer.Wait())
<< "Timed out waiting for single RTP packet.";
// Reconfigure back to use all streams.
- send_stream_->ReconfigureVideoEncoder(video_streams_, NULL);
+ send_stream_->ReconfigureVideoEncoder(encoder_config_);
observer.ResetExpectedSsrcs(kNumSsrcs);
EXPECT_EQ(kEventSignaled, observer.Wait())
<< "Timed out waiting for all SSRCs to send packets.";
@@ -1934,7 +1935,7 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
send_config->encoder_settings.encoder = this;
}
diff --git a/webrtc/video/full_stack.cc b/webrtc/video/full_stack.cc
index cd1190c..6ae85c4 100644
--- a/webrtc/video/full_stack.cc
+++ b/webrtc/video/full_stack.cc
@@ -393,7 +393,7 @@
send_config_.encoder_settings.payload_name = "VP8";
send_config_.encoder_settings.payload_type = 124;
- VideoStream* stream = &video_streams_[0];
+ VideoStream* stream = &encoder_config_.streams[0];
stream->width = params.clip.width;
stream->height = params.clip.height;
stream->min_bitrate_bps = params.min_bitrate_bps;
diff --git a/webrtc/video/loopback.cc b/webrtc/video/loopback.cc
index 29a3c78..488adf4 100644
--- a/webrtc/video/loopback.cc
+++ b/webrtc/video/loopback.cc
@@ -129,8 +129,9 @@
send_config.encoder_settings.encoder = encoder.get();
send_config.encoder_settings.payload_name = flags::Codec();
send_config.encoder_settings.payload_type = 124;
- std::vector<VideoStream> video_streams = test::CreateVideoStreams(1);
- VideoStream* stream = &video_streams[0];
+ VideoEncoderConfig encoder_config;
+ encoder_config.streams = test::CreateVideoStreams(1);
+ VideoStream* stream = &encoder_config.streams[0];
stream->width = flags::Width();
stream->height = flags::Height();
stream->min_bitrate_bps = static_cast<int>(flags::MinBitrate()) * 1000;
@@ -140,7 +141,7 @@
stream->max_qp = 56;
VideoSendStream* send_stream =
- call->CreateVideoSendStream(send_config, video_streams, NULL);
+ call->CreateVideoSendStream(send_config, encoder_config);
Clock* test_clock = Clock::GetRealTimeClock();
diff --git a/webrtc/video/rampup_tests.cc b/webrtc/video/rampup_tests.cc
index e1dd95a..10bcb7f 100644
--- a/webrtc/video/rampup_tests.cc
+++ b/webrtc/video/rampup_tests.cc
@@ -411,8 +411,8 @@
receiver_transport.SetReceiver(sender_call_->Receiver());
if (num_streams == 1) {
- video_streams_[0].target_bitrate_bps = 2000000;
- video_streams_[0].max_bitrate_bps = 2000000;
+ encoder_config_.streams[0].target_bitrate_bps = 2000000;
+ encoder_config_.streams[0].max_bitrate_bps = 2000000;
}
send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
@@ -430,9 +430,9 @@
// For multi stream rampup until all streams are being sent. That means
// enough birate to send all the target streams plus the min bitrate of
// the last one.
- int expected_bitrate_bps = video_streams_.back().min_bitrate_bps;
- for (size_t i = 0; i < video_streams_.size() - 1; ++i) {
- expected_bitrate_bps += video_streams_[i].target_bitrate_bps;
+ int expected_bitrate_bps = encoder_config_.streams.back().min_bitrate_bps;
+ for (size_t i = 0; i < encoder_config_.streams.size() - 1; ++i) {
+ expected_bitrate_bps += encoder_config_.streams[i].target_bitrate_bps;
}
stream_observer.set_expected_bitrate_bps(expected_bitrate_bps);
}
diff --git a/webrtc/video/video_send_stream.cc b/webrtc/video/video_send_stream.cc
index 7d64755..beaa037 100644
--- a/webrtc/video/video_send_stream.cc
+++ b/webrtc/video/video_send_stream.cc
@@ -114,8 +114,7 @@
CpuOveruseObserver* overuse_observer,
webrtc::VideoEngine* video_engine,
const VideoSendStream::Config& config,
- const std::vector<VideoStream> video_streams,
- const void* encoder_settings,
+ const VideoEncoderConfig& encoder_config,
const std::map<uint32_t, RtpState>& suspended_ssrcs,
int base_channel,
int start_bitrate_bps)
@@ -211,7 +210,7 @@
}
codec_ = ViECodec::GetInterface(video_engine);
- if (!ReconfigureVideoEncoder(video_streams, encoder_settings))
+ if (!ReconfigureVideoEncoder(encoder_config))
abort();
if (overuse_observer)
@@ -297,8 +296,8 @@
}
bool VideoSendStream::ReconfigureVideoEncoder(
- const std::vector<VideoStream>& streams,
- const void* encoder_settings) {
+ const VideoEncoderConfig& config) {
+ const std::vector<VideoStream>& streams = config.streams;
assert(!streams.empty());
assert(config_.rtp.ssrcs.size() >= streams.size());
@@ -311,6 +310,14 @@
} else {
video_codec.codecType = kVideoCodecGeneric;
}
+ switch (config.content_type) {
+ case VideoEncoderConfig::kRealtimeVideo:
+ video_codec.mode = kRealtimeVideo;
+ break;
+ case VideoEncoderConfig::kScreenshare:
+ video_codec.mode = kScreensharing;
+ break;
+ }
if (video_codec.codecType == kVideoCodecVP8) {
video_codec.codecSpecific.VP8 = VideoEncoder::GetDefaultVp8Settings();
@@ -319,13 +326,13 @@
}
if (video_codec.codecType == kVideoCodecVP8) {
- if (encoder_settings != NULL) {
- video_codec.codecSpecific.VP8 =
- *reinterpret_cast<const VideoCodecVP8*>(encoder_settings);
+ if (config.encoder_specific_settings != NULL) {
+ video_codec.codecSpecific.VP8 = *reinterpret_cast<const VideoCodecVP8*>(
+ config.encoder_specific_settings);
}
} else {
// TODO(pbos): Support encoder_settings codec-agnostically.
- assert(encoder_settings == NULL);
+ assert(config.encoder_specific_settings == NULL);
}
strncpy(video_codec.plName,
diff --git a/webrtc/video/video_send_stream.h b/webrtc/video/video_send_stream.h
index 130c1c5..8a77852 100644
--- a/webrtc/video/video_send_stream.h
+++ b/webrtc/video/video_send_stream.h
@@ -46,8 +46,7 @@
CpuOveruseObserver* overuse_observer,
webrtc::VideoEngine* video_engine,
const VideoSendStream::Config& config,
- const std::vector<VideoStream> video_streams,
- const void* encoder_settings,
+ const VideoEncoderConfig& encoder_config,
const std::map<uint32_t, RtpState>& suspended_ssrcs,
int base_channel,
int start_bitrate);
@@ -57,8 +56,8 @@
virtual void Start() OVERRIDE;
virtual void Stop() OVERRIDE;
- virtual bool ReconfigureVideoEncoder(const std::vector<VideoStream>& streams,
- const void* encoder_settings) OVERRIDE;
+ virtual bool ReconfigureVideoEncoder(
+ const VideoEncoderConfig& config) OVERRIDE;
virtual Stats GetStats() const OVERRIDE;
diff --git a/webrtc/video/video_send_stream_tests.cc b/webrtc/video/video_send_stream_tests.cc
index 7a641bd..888e47b 100644
--- a/webrtc/video/video_send_stream_tests.cc
+++ b/webrtc/video/video_send_stream_tests.cc
@@ -114,7 +114,7 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
send_config->rtp.c_name = kCName;
}
@@ -152,7 +152,7 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
send_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId));
}
@@ -193,7 +193,7 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
send_config->encoder_settings.encoder = &encoder_;
send_config->rtp.extensions.push_back(
RtpExtension(RtpExtension::kTOffset, kTOffsetExtensionId));
@@ -360,7 +360,7 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
send_config->rtp.fec.red_payload_type = kRedPayloadType;
send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
}
@@ -440,7 +440,7 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
send_config->rtp.rtx.payload_type = retransmit_payload_type_;
if (retransmit_ssrc_ != kSendSsrcs[0])
@@ -613,7 +613,7 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
if (use_fec_) {
send_config->rtp.fec.red_payload_type = kRedPayloadType;
send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
@@ -788,14 +788,14 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
send_config->pre_encode_callback = this;
send_config->suspend_below_min_bitrate = true;
- int min_bitrate_bps = (*video_streams)[0].min_bitrate_bps;
+ int min_bitrate_bps = encoder_config->streams[0].min_bitrate_bps;
set_low_remb_bps(min_bitrate_bps - 10000);
int threshold_window = std::max(min_bitrate_bps / 10, 10000);
- ASSERT_GT((*video_streams)[0].max_bitrate_bps,
+ ASSERT_GT(encoder_config->streams[0].max_bitrate_bps,
min_bitrate_bps + threshold_window + 5000);
set_high_remb_bps(min_bitrate_bps + threshold_window + 5000);
}
@@ -977,7 +977,7 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
SetConfig(*send_config);
}
@@ -1074,7 +1074,7 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
send_config->rtp.min_transmit_bitrate_bps = kMinTransmitBitrateBps;
}
@@ -1133,8 +1133,8 @@
// Prepare five input frames. Send I420VideoFrame and TextureVideoFrame
// alternatively.
ScopedVector<I420VideoFrame> input_frames;
- int width = static_cast<int>(video_streams_[0].width);
- int height = static_cast<int>(video_streams_[0].height);
+ int width = static_cast<int>(encoder_config_.streams[0].width);
+ int height = static_cast<int>(encoder_config_.streams[0].height);
webrtc::RefCountImpl<FakeNativeHandle>* handle1 =
new webrtc::RefCountImpl<FakeNativeHandle>();
webrtc::RefCountImpl<FakeNativeHandle>* handle2 =
@@ -1154,7 +1154,7 @@
send_stream_->Input()->SwapFrame(frame.get());
// Do not send the next frame too fast, so the frame dropper won't drop it.
if (i < input_frames.size() - 1)
- SleepMs(1000 / video_streams_[0].max_framerate);
+ SleepMs(1000 / encoder_config_.streams[0].max_framerate);
// Wait until the output frame is received before sending the next input
// frame. Or the previous input frame may be replaced without delivering.
observer.WaitOutputFrame();
@@ -1327,16 +1327,16 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
send_config->encoder_settings.encoder = this;
- video_streams_ = *video_streams;
+ encoder_config_ = *encoder_config;
}
virtual void PerformTest() OVERRIDE {
EXPECT_EQ(kEventSignaled, Wait())
<< "Timed out while waiting for Encode.";
EXPECT_EQ(0u, num_releases());
- stream_->ReconfigureVideoEncoder(video_streams_, NULL);
+ stream_->ReconfigureVideoEncoder(encoder_config_);
EXPECT_EQ(0u, num_releases());
stream_->Stop();
// Encoder should not be released before destroying the VideoSendStream.
@@ -1354,7 +1354,7 @@
bool callback_registered_ GUARDED_BY(crit_);
size_t num_releases_ GUARDED_BY(crit_);
bool released_ GUARDED_BY(crit_);
- std::vector<VideoStream> video_streams_;
+ VideoEncoderConfig encoder_config_;
} test_encoder;
RunBaseTest(&test_encoder);
@@ -1363,6 +1363,62 @@
EXPECT_EQ(1u, test_encoder.num_releases());
}
+TEST_F(VideoSendStreamTest, EncoderSetupPropagatesCommonEncoderConfigValues) {
+ class VideoCodecConfigObserver : public test::SendTest,
+ public test::FakeEncoder {
+ public:
+ VideoCodecConfigObserver()
+ : SendTest(kDefaultTimeoutMs),
+ FakeEncoder(Clock::GetRealTimeClock()),
+ num_initializations_(0) {}
+
+ private:
+ virtual void ModifyConfigs(
+ VideoSendStream::Config* send_config,
+ std::vector<VideoReceiveStream::Config>* receive_configs,
+ VideoEncoderConfig* encoder_config) OVERRIDE {
+ send_config->encoder_settings.encoder = this;
+ encoder_config_ = *encoder_config;
+ }
+
+ virtual void OnStreamsCreated(
+ VideoSendStream* send_stream,
+ const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE {
+ stream_ = send_stream;
+ }
+
+ virtual int32_t InitEncode(const VideoCodec* config,
+ int32_t number_of_cores,
+ uint32_t max_payload_size) OVERRIDE {
+ if (num_initializations_ == 0) {
+ // Verify default values.
+ EXPECT_EQ(kRealtimeVideo, config->mode);
+ } else {
+ // Verify that changed values are propagated.
+ EXPECT_EQ(kScreensharing, config->mode);
+ }
+ ++num_initializations_;
+ return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
+ }
+
+ virtual void PerformTest() OVERRIDE {
+ EXPECT_EQ(1u, num_initializations_) << "VideoEncoder not initialized.";
+
+ encoder_config_.content_type = VideoEncoderConfig::kScreenshare;
+ stream_->ReconfigureVideoEncoder(encoder_config_);
+ EXPECT_EQ(2u, num_initializations_)
+ << "ReconfigureVideoEncoder did not reinitialize the encoder with "
+ "new encoder settings.";
+ }
+
+ size_t num_initializations_;
+ VideoSendStream* stream_;
+ VideoEncoderConfig encoder_config_;
+ } test;
+
+ RunBaseTest(&test);
+}
+
TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) {
class VideoCodecConfigObserver : public test::SendTest,
public test::FakeEncoder {
@@ -1378,11 +1434,12 @@
virtual void ModifyConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
- std::vector<VideoStream>* video_streams) OVERRIDE {
+ VideoEncoderConfig* encoder_config) OVERRIDE {
send_config->encoder_settings.encoder = this;
send_config->encoder_settings.payload_name = "VP8";
- video_streams_ = *video_streams;
+ encoder_config->encoder_specific_settings = &vp8_settings_;
+ encoder_config_ = *encoder_config;
}
virtual void OnStreamsCreated(
@@ -1407,26 +1464,23 @@
EXPECT_EQ(1u, num_initializations_) << "VideoEncoder not initialized.";
vp8_settings_.denoisingOn = true;
- stream_->ReconfigureVideoEncoder(video_streams_, &vp8_settings_);
+ stream_->ReconfigureVideoEncoder(encoder_config_);
EXPECT_EQ(2u, num_initializations_)
<< "ReconfigureVideoEncoder did not reinitialize the encoder with "
"new encoder settings.";
}
- int32_t Encode(
- const I420VideoFrame& input_image,
- const CodecSpecificInfo* codec_specific_info,
- const std::vector<VideoFrameType>* frame_types) {
+ int32_t Encode(const I420VideoFrame& input_image,
+ const CodecSpecificInfo* codec_specific_info,
+ const std::vector<VideoFrameType>* frame_types) OVERRIDE {
// Silently skip the encode, FakeEncoder::Encode doesn't produce VP8.
return 0;
}
- virtual const void* GetEncoderSettings() OVERRIDE { return &vp8_settings_; }
-
VideoCodecVP8 vp8_settings_;
size_t num_initializations_;
VideoSendStream* stream_;
- std::vector<VideoStream> video_streams_;
+ VideoEncoderConfig encoder_config_;
} test;
RunBaseTest(&test);
diff --git a/webrtc/video_send_stream.h b/webrtc/video_send_stream.h
index 8c9d5b7..dd2bec1 100644
--- a/webrtc/video_send_stream.h
+++ b/webrtc/video_send_stream.h
@@ -153,8 +153,7 @@
// Set which streams to send. Must have at least as many SSRCs as configured
// in the config. Encoder settings are passed on to the encoder instance along
// with the VideoStream settings.
- virtual bool ReconfigureVideoEncoder(const std::vector<VideoStream>& streams,
- const void* encoder_settings) = 0;
+ virtual bool ReconfigureVideoEncoder(const VideoEncoderConfig& config) = 0;
virtual Stats GetStats() const = 0;
