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

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<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 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::InputFrame(
 
   LOG(LS_VERBOSE) << "SwapFrame: " << video_frame_.width() << "x"
                   << video_frame_.height() << " -> (codec) "
-                  << parameters_.video_streams.back().width << "x"
+                  << parameters_.encoder_config.streams.back().width << "x"
-                  << parameters_.video_streams.back().height;
+                  << 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 &&
+  if (parameters_.encoder_config.streams.back().width == width &&
-      parameters_.video_streams.back().height == height) {
+      parameters_.encoder_config.streams.back().height == height) {
     return;
   }
 
-  void* encoder_settings = encoder_factory_->CreateVideoEncoderSettings(
+  webrtc::VideoEncoderConfig encoder_config = parameters_.encoder_config;
-      codec_settings.codec, parameters_.options);
+  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(
+  encoder_config.streams = encoder_factory_->CreateVideoStreams(
-      video_streams, encoder_settings);
+      codec, parameters_.options, parameters_.config.rtp.ssrcs.size());
 
-  encoder_factory_->DestroyVideoEncoderSettings(codec_settings.codec,
+  bool stream_reconfigured = stream_->ReconfigureVideoEncoder(encoder_config);
-                                                encoder_settings);
+
+  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<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 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::RecreateWebRtcStream() {
 
   VideoCodecSettings codec_settings;
   parameters_.codec_settings.Get(&codec_settings);
-  void* encoder_settings = encoder_factory_->CreateVideoEncoderSettings(
+  parameters_.encoder_config.encoder_specific_settings =
-      codec_settings.codec, parameters_.options);
+      encoder_factory_->CreateVideoEncoderSettings(codec_settings.codec,
+                                                   parameters_.options);
 
-  stream_ = call_->CreateVideoSendStream(
+  stream_ = call_->CreateVideoSendStream(parameters_.config,
-      parameters_.config, parameters_.video_streams, encoder_settings);
+                                         parameters_.encoder_config);
 
-  encoder_factory_->DestroyVideoEncoderSettings(codec_settings.codec,
+  encoder_factory_->DestroyVideoEncoderSettings(
-                                                encoder_settings);
+      codec_settings.codec,
+      parameters_.encoder_config.encoder_specific_settings);
+
+  parameters_.encoder_config.encoder_specific_settings = NULL;
 
   if (sending_) {
     stream_->Start();

talk/media/webrtc/webrtcvideoengine2.h

@@ -119,9 +119,8 @@ class WebRtcVideoEncoderFactory2 {
       const VideoCodec& codec,
       const VideoOptions& options);
 
-  virtual void* CreateVideoEncoderSettings(
+  virtual void* CreateVideoEncoderSettings(const VideoCodec& codec,
-      const VideoCodec& codec,
+                                           const VideoOptions& options);
-      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<webrtc::VideoStream> video_streams;
+      webrtc::VideoEncoderConfig encoder_config;
     };
 
     void SetCodecAndOptions(const VideoCodecSettings& codec,

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<webrtc::VideoStream>& video_streams,
+    const webrtc::VideoEncoderConfig& encoder_config)
-    const void* encoder_settings)
+    : sending_(false), config_(config), codec_settings_set_(false) {
-    : 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<webrtc::VideoStream> 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<webrtc::VideoStream>& streams,
+    const webrtc::VideoEncoderConfig& config) {
-    const void* encoder_specific) {
+  encoder_config_ = config;
-  video_streams_ = streams;
+  if (config.encoder_specific_settings != NULL) {
-  if (encoder_specific != NULL) {
     assert(config_.encoder_settings.payload_name == "VP8");
-    vp8_settings_ =
+    vp8_settings_ = *reinterpret_cast<const webrtc::VideoCodecVP8*>(
-        *reinterpret_cast<const webrtc::VideoCodecVP8*>(encoder_specific);
+                        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<webrtc::VideoStream>& video_streams,
+    const webrtc::VideoEncoderConfig& encoder_config) {
-    const void* encoder_settings) {
   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;
 }

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<webrtc::VideoStream>& video_streams,
+                      const webrtc::VideoEncoderConfig& encoder_config);
-                      const void* encoder_settings);
   webrtc::VideoSendStream::Config GetConfig();
   std::vector<webrtc::VideoStream> GetVideoStreams();
 
@@ -51,8 +50,7 @@ class FakeVideoSendStream : public webrtc::VideoSendStream {
   virtual webrtc::VideoSendStream::Stats GetStats() const OVERRIDE;
 
   virtual bool ReconfigureVideoEncoder(
-      const std::vector<webrtc::VideoStream>& streams,
+      const webrtc::VideoEncoderConfig& config) OVERRIDE;
-      const void* encoder_specific);
 
   virtual webrtc::VideoSendStreamInput* Input() OVERRIDE;
 
@@ -61,7 +59,7 @@ class FakeVideoSendStream : public webrtc::VideoSendStream {
 
   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 @@ class FakeCall : public webrtc::Call {
  private:
   virtual webrtc::VideoSendStream* CreateVideoSendStream(
       const webrtc::VideoSendStream::Config& config,
-      const std::vector<webrtc::VideoStream>& video_streams,
+      const webrtc::VideoEncoderConfig& encoder_config) OVERRIDE;
-      const void* encoder_settings) OVERRIDE;
 
   virtual void DestroyVideoSendStream(
       webrtc::VideoSendStream* send_stream) OVERRIDE;

webrtc/call.h

@@ -92,8 +92,7 @@ class Call {
 
   virtual VideoSendStream* CreateVideoSendStream(
       const VideoSendStream::Config& config,
-      const std::vector<VideoStream>& video_streams,
+      const VideoEncoderConfig& encoder_config) = 0;
-      const void* encoder_settings) = 0;
 
   virtual void DestroyVideoSendStream(VideoSendStream* send_stream) = 0;
 

webrtc/config.h

@@ -108,6 +108,20 @@ struct VideoStream {
   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_

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_, &encoder_config_);
-  test->ModifyConfigs(&send_config_, &receive_configs_, &video_streams_);
   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_stream_ =
-      send_config_, video_streams_, encoder_settings_);
+      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<VideoReceiveStream::Config>* receive_configs,
-    std::vector<VideoStream>* video_streams) {
+    VideoEncoderConfig* encoder_config) {
 }
 
 void BaseTest::OnStreamsCreated(

webrtc/test/call_test.h

@@ -65,8 +65,7 @@ class CallTest : public ::testing::Test {
 
   scoped_ptr<Call> sender_call_;
   VideoSendStream::Config send_config_;
-  std::vector<VideoStream> video_streams_;
+  VideoEncoderConfig encoder_config_;
-  const void* encoder_settings_;
   VideoSendStream* send_stream_;
 
   scoped_ptr<Call> 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<VideoReceiveStream::Config>* receive_configs,
-      std::vector<VideoStream>* video_streams);
+      VideoEncoderConfig* encoder_config);
   virtual void OnStreamsCreated(
       VideoSendStream* send_stream,
       const std::vector<VideoReceiveStream*>& receive_streams);

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);
+          test_->send_config_, test_->encoder_config_);
-      assert(test_->video_streams_.size() == 1);
+      assert(test_->encoder_config_.streams.size() == 1);
-      frame_generator_capturer_.reset(
+      frame_generator_capturer_.reset(test::FrameGeneratorCapturer::Create(
-          test::FrameGeneratorCapturer::Create(send_stream_->Input(),
+          send_stream_->Input(),
-                                               test_->video_streams_[0].width,
+          test_->encoder_config_.streams[0].width,
-                                               test_->video_streams_[0].height,
+          test_->encoder_config_.streams[0].height,
-                                               30,
+          30,
-                                               Clock::GetRealTimeClock()));
+          Clock::GetRealTimeClock()));
       send_stream_->Start();
       frame_generator_capturer_->Start();
 

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<VideoStream>& video_streams,
+      const VideoEncoderConfig& encoder_config) OVERRIDE;
-      const void* encoder_settings) 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<VideoStream>& video_streams,
+    const VideoEncoderConfig& encoder_config) {
-    const void* encoder_settings) {
   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_config,
-      encoder_settings,
       suspended_send_ssrcs_,
       base_channel_id_,
       config_.start_bitrate_bps != -1 ? config_.start_bitrate_bps

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<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 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
     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 {

webrtc/video/end_to_end_tests.cc

@@ -208,7 +208,7 @@ TEST_F(EndToEndTest, TransmitsFirstFrame) {
   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 @@ TEST_F(EndToEndTest, SendsAndReceivesH264) {
     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;
+      encoder_config->streams[0].min_bitrate_bps = 50000;
-      (*video_streams)[0].target_bitrate_bps =
+      encoder_config->streams[0].target_bitrate_bps =
-          (*video_streams)[0].max_bitrate_bps = 2000000;
+          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<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 @@ TEST_F(EndToEndTest, DISABLED_CanReceiveFec) {
     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 @@ void EndToEndTest::DecodesRetransmittedFrame(bool retransmit_over_rtx) {
     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 @@ 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.";
+  ASSERT_EQ(1u, encoder_config_.streams.size()) << "Test setup error.";
-  video_streams_[0].width = kWidth;
+  encoder_config_.streams[0].width = kWidth;
-  video_streams_[0].height = kHeight;
+  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<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 @@ void EndToEndTest::RespectsRtcpMode(newapi::RtcpMode rtcp_mode) {
     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 @@ 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<VideoStream> video_streams = test::CreateVideoStreams(1);
+    VideoEncoderConfig encoder_config;
-    VideoStream* stream = &video_streams[0];
+    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<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 @@ void EndToEndTest::TestXrReceiverReferenceTimeReport(bool enable_rrtr) {
     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 @@ void EndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
     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) {
+        for (size_t i = 0; i < encoder_config->streams.size(); ++i) {
-          (*video_streams)[i].min_bitrate_bps = 10000;
+          encoder_config->streams[i].min_bitrate_bps = 10000;
-          (*video_streams)[i].target_bitrate_bps = 15000;
+          encoder_config->streams[i].target_bitrate_bps = 15000;
-          (*video_streams)[i].max_bitrate_bps = 20000;
+          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<VideoStream> 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<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 @@ TEST_F(EndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) {
     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) {
+      for (size_t i = 0; i < encoder_config->streams.size(); ++i) {
-        (*video_streams)[i].min_bitrate_bps = 10000;
+        encoder_config->streams[i].min_bitrate_bps = 10000;
-        (*video_streams)[i].target_bitrate_bps = 15000;
+        encoder_config->streams[i].target_bitrate_bps = 15000;
-        (*video_streams)[i].max_bitrate_bps = 20000;
+        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) {
+  for (size_t i = 0; i < encoder_config_.streams.size(); ++i) {
-    video_streams_[i].min_bitrate_bps = 10000;
+    encoder_config_.streams[i].min_bitrate_bps = 10000;
-    video_streams_[i].target_bitrate_bps = 15000;
+    encoder_config_.streams[i].target_bitrate_bps = 15000;
-    video_streams_[i].max_bitrate_bps = 20000;
+    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<VideoStream> one_stream = video_streams_;
+    VideoEncoderConfig one_stream = encoder_config_;
-    one_stream.resize(1);
+    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<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       send_config->encoder_settings.encoder = this;
     }
 

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;

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<VideoStream> video_streams = test::CreateVideoStreams(1);
+  VideoEncoderConfig encoder_config;
-  VideoStream* stream = &video_streams[0];
+  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 @@ 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();
 

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;
+    encoder_config_.streams[0].target_bitrate_bps = 2000000;
-    video_streams_[0].max_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;
+    int expected_bitrate_bps = encoder_config_.streams.back().min_bitrate_bps;
-    for (size_t i = 0; i < video_streams_.size() - 1; ++i) {
+    for (size_t i = 0; i < encoder_config_.streams.size() - 1; ++i) {
-      expected_bitrate_bps += video_streams_[i].target_bitrate_bps;
+      expected_bitrate_bps += encoder_config_.streams[i].target_bitrate_bps;
     }
     stream_observer.set_expected_bitrate_bps(expected_bitrate_bps);
   }

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<VideoStream> video_streams,
+    const VideoEncoderConfig& encoder_config,
-    const void* encoder_settings,
     const std::map<uint32_t, RtpState>& 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<VideoStream>& streams,
+    const VideoEncoderConfig& config) {
-    const void* encoder_settings) {
+  const std::vector<VideoStream>& 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) {
+    if (config.encoder_specific_settings != NULL) {
-      video_codec.codecSpecific.VP8 =
+      video_codec.codecSpecific.VP8 = *reinterpret_cast<const VideoCodecVP8*>(
-          *reinterpret_cast<const VideoCodecVP8*>(encoder_settings);
+                                          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,

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<VideoStream> video_streams,
+                  const VideoEncoderConfig& encoder_config,
-                  const void* encoder_settings,
                   const std::map<uint32_t, RtpState>& 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<VideoStream>& streams,
+  virtual bool ReconfigureVideoEncoder(
-                                       const void* encoder_settings) OVERRIDE;
+      const VideoEncoderConfig& config) OVERRIDE;
 
   virtual Stats GetStats() const OVERRIDE;
 

webrtc/video/video_send_stream_tests.cc

@@ -114,7 +114,7 @@ TEST_F(VideoSendStreamTest, SupportsCName) {
     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 @@ TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
     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 @@ TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
     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 @@ TEST_F(VideoSendStreamTest, SupportsFec) {
     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 @@ void VideoSendStreamTest::TestNackRetransmission(
     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 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
     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 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
     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 @@ TEST_F(VideoSendStreamTest, ProducesStats) {
     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 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
     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 @@ TEST_F(VideoSendStreamTest, CapturesTextureAndI420VideoFrames) {
   // Prepare five input frames. Send I420VideoFrame and TextureVideoFrame
   // alternatively.
   ScopedVector<I420VideoFrame> input_frames;
-  int width = static_cast<int>(video_streams_[0].width);
+  int width = static_cast<int>(encoder_config_.streams[0].width);
-  int height = static_cast<int>(video_streams_[0].height);
+  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 @@ 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<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 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
     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 @@ 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<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 @@ TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) {
     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 @@ 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(
+    int32_t Encode(const I420VideoFrame& input_image,
-        const I420VideoFrame& input_image,
+                   const CodecSpecificInfo* codec_specific_info,
-        const CodecSpecificInfo* codec_specific_info,
+                   const std::vector<VideoFrameType>* frame_types) OVERRIDE {
-        const std::vector<VideoFrameType>* frame_types) {
       // 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);

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<VideoStream>& streams,
+  virtual bool ReconfigureVideoEncoder(const VideoEncoderConfig& config) = 0;
-                                       const void* encoder_settings) = 0;
 
   virtual Stats GetStats() const = 0;