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
2014-09-19 12:30:25 +00:00
parent 02686115cc
commit bbe0a8517d
19 changed files with 246 additions and 189 deletions
--- a/webrtc/call.h
+++ b/webrtc/call.h
@ -92,8 +92,7 @@ class Call {

  virtual VideoSendStream* CreateVideoSendStream(
      const VideoSendStream::Config& config,
-      const std::vector<VideoStream>& video_streams,
-      const void* encoder_settings) = 0;
+      const VideoEncoderConfig& encoder_config) = 0;

  virtual void DestroyVideoSendStream(VideoSendStream* send_stream) = 0;

--- a/webrtc/config.h
+++ b/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_
--- 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<VideoReceiveStream::Config>* receive_configs,
-    std::vector<VideoStream>* video_streams) {
+    VideoEncoderConfig* encoder_config) {
 }

 void BaseTest::OnStreamsCreated(
--- a/webrtc/test/call_test.h
+++ b/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_;
-  const void* encoder_settings_;
+  VideoEncoderConfig encoder_config_;
  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);
--- 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();

--- 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<VideoStream>& video_streams,
-      const void* encoder_settings) OVERRIDE;
+      const VideoEncoderConfig& encoder_config) OVERRIDE;

  virtual void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream)
      OVERRIDE;
@ -196,8 +195,7 @@ PacketReceiver* Call::Receiver() { return this; }

 VideoSendStream* Call::CreateVideoSendStream(
    const VideoSendStream::Config& config,
-    const std::vector<VideoStream>& video_streams,
-    const void* encoder_settings) {
+    const VideoEncoderConfig& encoder_config) {
  assert(config.rtp.ssrcs.size() > 0);

  // TODO(mflodman): Base the start bitrate on a current bandwidth estimate, if
@ -207,8 +205,7 @@ 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
--- 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<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 {
--- 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<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;
-      (*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<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.";
-  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<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);
-    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<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) {
-          (*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<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) {
-        (*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<VideoStream> one_stream = video_streams_;
-    one_stream.resize(1);
+    VideoEncoderConfig one_stream = encoder_config_;
+    one_stream.streams.resize(1);
    send_stream_ =
-        sender_call_->CreateVideoSendStream(send_config_, one_stream, NULL);
+        sender_call_->CreateVideoSendStream(send_config_, one_stream);
    send_stream_->Start();
    CreateFrameGeneratorCapturer();
    frame_generator_capturer_->Start();
@ -1819,19 +1820,19 @@ 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;
    }

--- 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;
--- 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<VideoStream> video_streams = test::CreateVideoStreams(1);
-  VideoStream* stream = &video_streams[0];
+  VideoEncoderConfig encoder_config;
+  encoder_config.streams = test::CreateVideoStreams(1);
+  VideoStream* stream = &encoder_config.streams[0];
  stream->width = flags::Width();
  stream->height = flags::Height();
  stream->min_bitrate_bps = static_cast<int>(flags::MinBitrate()) * 1000;
@ -140,7 +141,7 @@ 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();

--- 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);
  }
--- 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<VideoStream> video_streams,
-    const void* encoder_settings,
+    const VideoEncoderConfig& encoder_config,
    const std::map<uint32_t, RtpState>& suspended_ssrcs,
    int base_channel,
    int start_bitrate_bps)
@ -211,7 +210,7 @@ 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 void* encoder_settings) {
+    const VideoEncoderConfig& config) {
+  const std::vector<VideoStream>& streams = config.streams;
  assert(!streams.empty());
  assert(config_.rtp.ssrcs.size() >= streams.size());

@ -311,6 +310,14 @@ 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<const VideoCodecVP8*>(encoder_settings);
+    if (config.encoder_specific_settings != NULL) {
+      video_codec.codecSpecific.VP8 = *reinterpret_cast<const VideoCodecVP8*>(
+                                          config.encoder_specific_settings);
    }
  } else {
    // TODO(pbos): Support encoder_settings codec-agnostically.
-    assert(encoder_settings == NULL);
+    assert(config.encoder_specific_settings == NULL);
  }

  strncpy(video_codec.plName,
--- 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<VideoStream> video_streams,
-                  const void* encoder_settings,
+                  const VideoEncoderConfig& encoder_config,
                  const std::map<uint32_t, RtpState>& suspended_ssrcs,
                  int base_channel,
                  int start_bitrate);
@ -57,8 +56,8 @@ class VideoSendStream : public webrtc::VideoSendStream,
  virtual void Start() OVERRIDE;
  virtual void Stop() OVERRIDE;

-  virtual bool ReconfigureVideoEncoder(const std::vector<VideoStream>& streams,
-                                       const void* encoder_settings) OVERRIDE;
+  virtual bool ReconfigureVideoEncoder(
+      const VideoEncoderConfig& config) OVERRIDE;

  virtual Stats GetStats() const OVERRIDE;

--- 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<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 height = static_cast<int>(video_streams_[0].height);
+  int width = static_cast<int>(encoder_config_.streams[0].width);
+  int height = static_cast<int>(encoder_config_.streams[0].height);
  webrtc::RefCountImpl<FakeNativeHandle>* handle1 =
      new webrtc::RefCountImpl<FakeNativeHandle>();
  webrtc::RefCountImpl<FakeNativeHandle>* handle2 =
@ -1154,7 +1154,7 @@ 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(
-        const I420VideoFrame& input_image,
-        const CodecSpecificInfo* codec_specific_info,
-        const std::vector<VideoFrameType>* frame_types) {
+    int32_t Encode(const I420VideoFrame& input_image,
+                   const CodecSpecificInfo* codec_specific_info,
+                   const std::vector<VideoFrameType>* frame_types) OVERRIDE {
      // Silently skip the encode, FakeEncoder::Encode doesn't produce VP8.
      return 0;
    }

-    virtual const void* GetEncoderSettings() OVERRIDE { return &vp8_settings_; }
-
    VideoCodecVP8 vp8_settings_;
    size_t num_initializations_;
    VideoSendStream* stream_;
-    std::vector<VideoStream> video_streams_;
+    VideoEncoderConfig encoder_config_;
  } test;

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

  virtual Stats GetStats() const = 0;