diff --git a/talk/media/webrtc/webrtcvideoengine2.cc b/talk/media/webrtc/webrtcvideoengine2.cc index a1a9aa41c..22a763016 100644 --- a/talk/media/webrtc/webrtcvideoengine2.cc +++ b/talk/media/webrtc/webrtcvideoengine2.cc @@ -229,13 +229,9 @@ void WebRtcVideoEncoderFactory2::DestroyVideoEncoderSettings( if (encoder_settings == NULL) { return; } - if (_stricmp(codec.name.c_str(), kVp8CodecName) == 0) { delete reinterpret_cast(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 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::InputFrame( 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 @@ bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoFormat( << 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 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodecAndOptions( 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 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::SetDimensions( 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 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::SetDimensions( 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 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 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::SetDimensions( return; } - parameters_.video_streams = video_streams; + parameters_.encoder_config = encoder_config; } void WebRtcVideoChannel2::WebRtcVideoSendStream::Start() { @@ -1646,9 +1645,9 @@ WebRtcVideoChannel2::WebRtcVideoSendStream::GetVideoSenderInfo() { info.input_frame_width = last_captured_frame_format.width; info.input_frame_height = last_captured_frame_format.height; info.send_frame_width = - static_cast(parameters_.video_streams.front().width); + static_cast(parameters_.encoder_config.streams.front().width); info.send_frame_height = - static_cast(parameters_.video_streams.front().height); + static_cast(parameters_.encoder_config.streams.front().height); } // TODO(pbos): Support or remove the following stats. @@ -1665,14 +1664,18 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::RecreateWebRtcStream() { 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 d77afb9d2..f285d10a9 100644 --- a/talk/media/webrtc/webrtcvideoengine2.h +++ b/talk/media/webrtc/webrtcvideoengine2.h @@ -119,9 +119,8 @@ class WebRtcVideoEncoderFactory2 { 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 @@ class WebRtcVideoChannel2 : public rtc::MessageHandler, // Sent resolutions + bitrates etc. by the underlying VideoSendStream, // typically changes when setting a new resolution or reconfiguring // bitrates. - std::vector 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 2178a6889..6112c50ec 100644 --- a/talk/media/webrtc/webrtcvideoengine2_unittest.cc +++ b/talk/media/webrtc/webrtcvideoengine2_unittest.cc @@ -68,13 +68,10 @@ void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec) { namespace cricket { FakeVideoSendStream::FakeVideoSendStream( const webrtc::VideoSendStream::Config& config, - const std::vector& 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 @@ webrtc::VideoSendStream::Config FakeVideoSendStream::GetConfig() { } std::vector FakeVideoSendStream::GetVideoStreams() { - return video_streams_; + return encoder_config_.streams; } bool FakeVideoSendStream::IsSending() const { @@ -104,15 +101,14 @@ webrtc::VideoSendStream::Stats FakeVideoSendStream::GetStats() const { } bool FakeVideoSendStream::ReconfigureVideoEncoder( - const std::vector& 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(encoder_specific); + vp8_settings_ = *reinterpret_cast( + 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::Call::NetworkState FakeCall::GetNetworkState() const { webrtc::VideoSendStream* FakeCall::CreateVideoSendStream( const webrtc::VideoSendStream::Config& config, - const std::vector& 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 5aaa3e33d..30f1efb85 100644 --- a/talk/media/webrtc/webrtcvideoengine2_unittest.h +++ b/talk/media/webrtc/webrtcvideoengine2_unittest.h @@ -39,8 +39,7 @@ namespace cricket { class FakeVideoSendStream : public webrtc::VideoSendStream { public: FakeVideoSendStream(const webrtc::VideoSendStream::Config& config, - const std::vector& video_streams, - const void* encoder_settings); + const webrtc::VideoEncoderConfig& encoder_config); webrtc::VideoSendStream::Config GetConfig(); std::vector GetVideoStreams(); @@ -51,8 +50,7 @@ class FakeVideoSendStream : public webrtc::VideoSendStream { virtual webrtc::VideoSendStream::Stats GetStats() const OVERRIDE; virtual bool ReconfigureVideoEncoder( - const std::vector& streams, - const void* encoder_specific); + const webrtc::VideoEncoderConfig& config) OVERRIDE; virtual webrtc::VideoSendStreamInput* Input() OVERRIDE; @@ -61,7 +59,7 @@ class FakeVideoSendStream : public webrtc::VideoSendStream { bool sending_; webrtc::VideoSendStream::Config config_; - std::vector video_streams_; + webrtc::VideoEncoderConfig encoder_config_; bool codec_settings_set_; webrtc::VideoCodecVP8 vp8_settings_; }; @@ -108,8 +106,7 @@ class FakeCall : public webrtc::Call { private: virtual webrtc::VideoSendStream* CreateVideoSendStream( const webrtc::VideoSendStream::Config& config, - const std::vector& 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 303007401..bb1dca144 100644 --- a/webrtc/call.h +++ b/webrtc/call.h @@ -92,8 +92,7 @@ class Call { virtual VideoSendStream* CreateVideoSendStream( const VideoSendStream::Config& config, - const std::vector& 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 e4bccf90f..6f3fb1d66 100644 --- a/webrtc/config.h +++ b/webrtc/config.h @@ -108,6 +108,20 @@ struct VideoStream { std::vector temporal_layers; }; +struct VideoEncoderConfig { + enum ContentType { + kRealtimeVideo, + kScreenshare, + }; + + VideoEncoderConfig() + : content_type(kRealtimeVideo), encoder_specific_settings(NULL) {} + + std::vector 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 ccad7551d..d49f6e3fe 100644 --- a/webrtc/test/call_test.cc +++ b/webrtc/test/call_test.cc @@ -16,7 +16,6 @@ namespace test { CallTest::CallTest() : clock_(Clock::GetRealTimeClock()), - encoder_settings_(NULL), send_stream_(NULL), fake_encoder_(clock_) { } @@ -40,8 +39,7 @@ void CallTest::RunBaseTest(BaseTest* test) { 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 @@ void CallTest::CreateSendConfig(size_t num_streams) { 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::CreateMatchingReceiveConfigs() { } 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 @@ void CallTest::CreateStreams() { 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 @@ size_t BaseTest::GetNumStreams() const { return 1; } -const void* BaseTest::GetEncoderSettings() { - return NULL; -} - void BaseTest::ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* video_streams) { + VideoEncoderConfig* encoder_config) { } void BaseTest::OnStreamsCreated( diff --git a/webrtc/test/call_test.h b/webrtc/test/call_test.h index a03c3bbef..695fb2acd 100644 --- a/webrtc/test/call_test.h +++ b/webrtc/test/call_test.h @@ -65,8 +65,7 @@ class CallTest : public ::testing::Test { scoped_ptr sender_call_; VideoSendStream::Config send_config_; - std::vector video_streams_; - const void* encoder_settings_; + VideoEncoderConfig encoder_config_; VideoSendStream* send_stream_; scoped_ptr receiver_call_; @@ -93,11 +92,10 @@ class BaseTest : public RtpRtcpObserver { 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* receive_configs, - std::vector* video_streams); + VideoEncoderConfig* encoder_config); virtual void OnStreamsCreated( VideoSendStream* send_stream, const std::vector& receive_streams); diff --git a/webrtc/video/bitrate_estimator_tests.cc b/webrtc/video/bitrate_estimator_tests.cc index 40c1ed682..6f1280594 100644 --- a/webrtc/video/bitrate_estimator_tests.cc +++ b/webrtc/video/bitrate_estimator_tests.cc @@ -148,7 +148,7 @@ class BitrateEstimatorTest : public test::CallTest { 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 @@ class BitrateEstimatorTest : public test::CallTest { 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 b4adafd75..442e75bd7 100644 --- a/webrtc/video/call.cc +++ b/webrtc/video/call.cc @@ -87,8 +87,7 @@ class Call : public webrtc::Call, public PacketReceiver { virtual VideoSendStream* CreateVideoSendStream( const VideoSendStream::Config& config, - const std::vector& video_streams, - const void* encoder_settings) OVERRIDE; + const VideoEncoderConfig& encoder_config) OVERRIDE; virtual void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) OVERRIDE; @@ -196,8 +195,7 @@ PacketReceiver* Call::Receiver() { return this; } VideoSendStream* Call::CreateVideoSendStream( const VideoSendStream::Config& config, - const std::vector& 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 @@ VideoSendStream* Call::CreateVideoSendStream( 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 557c5149c..d055af93e 100644 --- a/webrtc/video/call_perf_tests.cc +++ b/webrtc/video/call_perf_tests.cc @@ -399,7 +399,7 @@ void CallPerfTest::TestCaptureNtpTime(const FakeNetworkPipe::Config& net_config, virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* 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 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) { virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* 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 1b76eab7e..0e87a0338 100644 --- a/webrtc/video/end_to_end_tests.cc +++ b/webrtc/video/end_to_end_tests.cc @@ -208,7 +208,7 @@ TEST_F(EndToEndTest, TransmitsFirstFrame) { Start(); scoped_ptr 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 @@ TEST_F(EndToEndTest, SendsAndReceivesH264) { virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* 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 @@ TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) { virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* 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 @@ TEST_F(EndToEndTest, DISABLED_CanReceiveFec) { virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* 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 @@ void EndToEndTest::DecodesRetransmittedFrame(bool retransmit_over_rtx) { virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* 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 @@ TEST_F(EndToEndTest, UsesFrameCallbacks) { 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 @@ void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) { virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* 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 @@ void EndToEndTest::RespectsRtcpMode(newapi::RtcpMode rtcp_mode) { virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* 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 @@ TEST_F(EndToEndTest, SendsAndReceivesMultipleStreams) { send_config.encoder_settings.encoder = encoders[i].get(); send_config.encoder_settings.payload_name = "VP8"; send_config.encoder_settings.payload_type = 124; - std::vector 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 @@ TEST_F(EndToEndTest, ObserversEncodedFrames) { Start(); scoped_ptr 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 @@ void EndToEndTest::TestXrReceiverReferenceTimeReport(bool enable_rrtr) { virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* 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 @@ void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs, virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* 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 @@ void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs, 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 @@ void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs, bool expect_single_ssrc_; VideoSendStream* send_stream_; - std::vector all_streams_; + VideoEncoderConfig encoder_config_all_streams_; } test(kSendSsrcs, num_ssrcs, send_single_ssrc_first); RunBaseTest(&test); @@ -1469,7 +1470,7 @@ TEST_F(EndToEndTest, GetStats) { virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* 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 @@ TEST_F(EndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) { virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* 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 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx) { } // 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 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx) { sender_call_->DestroyVideoSendStream(send_stream_); // Re-create VideoSendStream with only one stream. - std::vector 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 @@ void EndToEndTest::TestRtpStatePreservation(bool use_rtx) { << "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 @@ TEST_F(EndToEndTest, RespectsNetworkState) { virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* 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 cd1190cc8..6ae85c4b1 100644 --- a/webrtc/video/full_stack.cc +++ b/webrtc/video/full_stack.cc @@ -393,7 +393,7 @@ void FullStackTest::RunTest(const FullStackTestParams& params) { 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 29a3c7823..488adf41d 100644 --- a/webrtc/video/loopback.cc +++ b/webrtc/video/loopback.cc @@ -129,8 +129,9 @@ void Loopback() { send_config.encoder_settings.encoder = encoder.get(); send_config.encoder_settings.payload_name = flags::Codec(); send_config.encoder_settings.payload_type = 124; - std::vector 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(flags::MinBitrate()) * 1000; @@ -140,7 +141,7 @@ void Loopback() { 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 e1dd95a67..10bcb7f19 100644 --- a/webrtc/video/rampup_tests.cc +++ b/webrtc/video/rampup_tests.cc @@ -411,8 +411,8 @@ void RampUpTest::RunRampUpTest(bool rtx, 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 @@ void RampUpTest::RunRampUpTest(bool rtx, // 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 7d64755d0..beaa03702 100644 --- a/webrtc/video/video_send_stream.cc +++ b/webrtc/video/video_send_stream.cc @@ -114,8 +114,7 @@ VideoSendStream::VideoSendStream( CpuOveruseObserver* overuse_observer, webrtc::VideoEngine* video_engine, const VideoSendStream::Config& config, - const std::vector video_streams, - const void* encoder_settings, + const VideoEncoderConfig& encoder_config, const std::map& suspended_ssrcs, int base_channel, int start_bitrate_bps) @@ -211,7 +210,7 @@ VideoSendStream::VideoSendStream( } codec_ = ViECodec::GetInterface(video_engine); - if (!ReconfigureVideoEncoder(video_streams, encoder_settings)) + if (!ReconfigureVideoEncoder(encoder_config)) abort(); if (overuse_observer) @@ -297,8 +296,8 @@ void VideoSendStream::Stop() { } bool VideoSendStream::ReconfigureVideoEncoder( - const std::vector& streams, - const void* encoder_settings) { + const VideoEncoderConfig& config) { + const std::vector& streams = config.streams; assert(!streams.empty()); assert(config_.rtp.ssrcs.size() >= streams.size()); @@ -311,6 +310,14 @@ bool VideoSendStream::ReconfigureVideoEncoder( } 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 @@ bool VideoSendStream::ReconfigureVideoEncoder( } if (video_codec.codecType == kVideoCodecVP8) { - if (encoder_settings != NULL) { - video_codec.codecSpecific.VP8 = - *reinterpret_cast(encoder_settings); + if (config.encoder_specific_settings != NULL) { + video_codec.codecSpecific.VP8 = *reinterpret_cast( + 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 130c1c5ca..8a77852e3 100644 --- a/webrtc/video/video_send_stream.h +++ b/webrtc/video/video_send_stream.h @@ -46,8 +46,7 @@ class VideoSendStream : public webrtc::VideoSendStream, CpuOveruseObserver* overuse_observer, webrtc::VideoEngine* video_engine, const VideoSendStream::Config& config, - const std::vector video_streams, - const void* encoder_settings, + const VideoEncoderConfig& encoder_config, const std::map& suspended_ssrcs, int base_channel, int start_bitrate); @@ -57,8 +56,8 @@ class VideoSendStream : public webrtc::VideoSendStream, virtual void Start() OVERRIDE; virtual void Stop() OVERRIDE; - virtual bool ReconfigureVideoEncoder(const std::vector& 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 7a641bd4d..888e47b89 100644 --- a/webrtc/video/video_send_stream_tests.cc +++ b/webrtc/video/video_send_stream_tests.cc @@ -114,7 +114,7 @@ TEST_F(VideoSendStreamTest, SupportsCName) { virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* video_streams) OVERRIDE { + VideoEncoderConfig* encoder_config) OVERRIDE { send_config->rtp.c_name = kCName; } @@ -152,7 +152,7 @@ TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) { virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* video_streams) OVERRIDE { + VideoEncoderConfig* encoder_config) OVERRIDE { send_config->rtp.extensions.push_back( RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId)); } @@ -193,7 +193,7 @@ TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) { virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* 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 @@ TEST_F(VideoSendStreamTest, SupportsFec) { virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* 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 @@ void VideoSendStreamTest::TestNackRetransmission( virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* 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 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format, virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* 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 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) { virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* 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 @@ TEST_F(VideoSendStreamTest, ProducesStats) { virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* video_streams) OVERRIDE { + VideoEncoderConfig* encoder_config) OVERRIDE { SetConfig(*send_config); } @@ -1074,7 +1074,7 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) { virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* video_streams) OVERRIDE { + VideoEncoderConfig* encoder_config) OVERRIDE { send_config->rtp.min_transmit_bitrate_bps = kMinTransmitBitrateBps; } @@ -1133,8 +1133,8 @@ TEST_F(VideoSendStreamTest, CapturesTextureAndI420VideoFrames) { // Prepare five input frames. Send I420VideoFrame and TextureVideoFrame // alternatively. ScopedVector input_frames; - int width = static_cast(video_streams_[0].width); - int height = static_cast(video_streams_[0].height); + int width = static_cast(encoder_config_.streams[0].width); + int height = static_cast(encoder_config_.streams[0].height); webrtc::RefCountImpl* handle1 = new webrtc::RefCountImpl(); webrtc::RefCountImpl* handle2 = @@ -1154,7 +1154,7 @@ TEST_F(VideoSendStreamTest, CapturesTextureAndI420VideoFrames) { 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 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) { virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* 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 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) { bool callback_registered_ GUARDED_BY(crit_); size_t num_releases_ GUARDED_BY(crit_); bool released_ GUARDED_BY(crit_); - std::vector video_streams_; + VideoEncoderConfig encoder_config_; } test_encoder; RunBaseTest(&test_encoder); @@ -1363,6 +1363,62 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) { 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* 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& 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 @@ TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) { virtual void ModifyConfigs( VideoSendStream::Config* send_config, std::vector* receive_configs, - std::vector* 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 @@ TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) { 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* frame_types) { + int32_t Encode(const I420VideoFrame& input_image, + const CodecSpecificInfo* codec_specific_info, + const std::vector* 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 video_streams_; + VideoEncoderConfig encoder_config_; } test; RunBaseTest(&test); diff --git a/webrtc/video_send_stream.h b/webrtc/video_send_stream.h index 8c9d5b7fe..dd2bec127 100644 --- a/webrtc/video_send_stream.h +++ b/webrtc/video_send_stream.h @@ -153,8 +153,7 @@ class VideoSendStream { // 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& streams, - const void* encoder_settings) = 0; + virtual bool ReconfigureVideoEncoder(const VideoEncoderConfig& config) = 0; virtual Stats GetStats() const = 0;