diff --git a/call.h b/call.h
index 3030074..bb1dca1 100644
--- a/call.h
+++ b/call.h
@@ -92,8 +92,7 @@
 
   virtual VideoSendStream* CreateVideoSendStream(
       const VideoSendStream::Config& config,
-      const std::vector<VideoStream>& video_streams,
-      const void* encoder_settings) = 0;
+      const VideoEncoderConfig& encoder_config) = 0;
 
   virtual void DestroyVideoSendStream(VideoSendStream* send_stream) = 0;
 
diff --git a/config.h b/config.h
index e4bccf9..6f3fb1d 100644
--- a/config.h
+++ b/config.h
@@ -108,6 +108,20 @@
   std::vector<int> temporal_layers;
 };
 
+struct VideoEncoderConfig {
+  enum ContentType {
+    kRealtimeVideo,
+    kScreenshare,
+  };
+
+  VideoEncoderConfig()
+      : content_type(kRealtimeVideo), encoder_specific_settings(NULL) {}
+
+  std::vector<VideoStream> streams;
+  ContentType content_type;
+  void* encoder_specific_settings;
+};
+
 }  // namespace webrtc
 
 #endif  // WEBRTC_CONFIG_H_
diff --git a/test/call_test.cc b/test/call_test.cc
index ccad755..d49f6e3 100644
--- a/test/call_test.cc
+++ b/test/call_test.cc
@@ -16,7 +16,6 @@
 
 CallTest::CallTest()
     : clock_(Clock::GetRealTimeClock()),
-      encoder_settings_(NULL),
       send_stream_(NULL),
       fake_encoder_(clock_) {
 }
@@ -40,8 +39,7 @@
   if (test->ShouldCreateReceivers()) {
     CreateMatchingReceiveConfigs();
   }
-  encoder_settings_ = test->GetEncoderSettings();
-  test->ModifyConfigs(&send_config_, &receive_configs_, &video_streams_);
+  test->ModifyConfigs(&send_config_, &receive_configs_, &encoder_config_);
   CreateStreams();
   test->OnStreamsCreated(send_stream_, receive_streams_);
 
@@ -92,7 +90,7 @@
   send_config_.encoder_settings.encoder = &fake_encoder_;
   send_config_.encoder_settings.payload_name = "FAKE";
   send_config_.encoder_settings.payload_type = kFakeSendPayloadType;
-  video_streams_ = test::CreateVideoStreams(num_streams);
+  encoder_config_.streams = test::CreateVideoStreams(num_streams);
   for (size_t i = 0; i < num_streams; ++i)
     send_config_.rtp.ssrcs.push_back(kSendSsrcs[i]);
 }
@@ -123,7 +121,7 @@
 }
 
 void CallTest::CreateFrameGeneratorCapturer() {
-  VideoStream stream = video_streams_.back();
+  VideoStream stream = encoder_config_.streams.back();
   frame_generator_capturer_.reset(
       test::FrameGeneratorCapturer::Create(send_stream_->Input(),
                                            stream.width,
@@ -135,8 +133,8 @@
   assert(send_stream_ == NULL);
   assert(receive_streams_.empty());
 
-  send_stream_ = sender_call_->CreateVideoSendStream(
-      send_config_, video_streams_, encoder_settings_);
+  send_stream_ =
+      sender_call_->CreateVideoSendStream(send_config_, encoder_config_);
 
   for (size_t i = 0; i < receive_configs_.size(); ++i) {
     receive_streams_.push_back(
@@ -193,14 +191,10 @@
   return 1;
 }
 
-const void* BaseTest::GetEncoderSettings() {
-  return NULL;
-}
-
 void BaseTest::ModifyConfigs(
     VideoSendStream::Config* send_config,
     std::vector<VideoReceiveStream::Config>* receive_configs,
-    std::vector<VideoStream>* video_streams) {
+    VideoEncoderConfig* encoder_config) {
 }
 
 void BaseTest::OnStreamsCreated(
diff --git a/test/call_test.h b/test/call_test.h
index a03c3bb..695fb2a 100644
--- a/test/call_test.h
+++ b/test/call_test.h
@@ -65,8 +65,7 @@
 
   scoped_ptr<Call> sender_call_;
   VideoSendStream::Config send_config_;
-  std::vector<VideoStream> video_streams_;
-  const void* encoder_settings_;
+  VideoEncoderConfig encoder_config_;
   VideoSendStream* send_stream_;
 
   scoped_ptr<Call> receiver_call_;
@@ -93,11 +92,10 @@
   virtual Call::Config GetReceiverCallConfig();
   virtual void OnCallsCreated(Call* sender_call, Call* receiver_call);
 
-  virtual const void* GetEncoderSettings();
   virtual void ModifyConfigs(
       VideoSendStream::Config* send_config,
       std::vector<VideoReceiveStream::Config>* receive_configs,
-      std::vector<VideoStream>* video_streams);
+      VideoEncoderConfig* encoder_config);
   virtual void OnStreamsCreated(
       VideoSendStream* send_stream,
       const std::vector<VideoReceiveStream*>& receive_streams);
diff --git a/video/bitrate_estimator_tests.cc b/video/bitrate_estimator_tests.cc
index 40c1ed6..6f12805 100644
--- a/video/bitrate_estimator_tests.cc
+++ b/video/bitrate_estimator_tests.cc
@@ -148,7 +148,7 @@
     send_config_.encoder_settings.encoder = NULL;
     send_config_.encoder_settings.payload_name = "FAKE";
     send_config_.encoder_settings.payload_type = kFakeSendPayloadType;
-    video_streams_ = test::CreateVideoStreams(1);
+    encoder_config_.streams = test::CreateVideoStreams(1);
 
     receive_config_ = VideoReceiveStream::Config();
     assert(receive_config_.codecs.empty());
@@ -195,14 +195,14 @@
       test_->send_config_.rtp.ssrcs[0]++;
       test_->send_config_.encoder_settings.encoder = &fake_encoder_;
       send_stream_ = test_->sender_call_->CreateVideoSendStream(
-          test_->send_config_, test_->video_streams_, NULL);
-      assert(test_->video_streams_.size() == 1);
-      frame_generator_capturer_.reset(
-          test::FrameGeneratorCapturer::Create(send_stream_->Input(),
-                                               test_->video_streams_[0].width,
-                                               test_->video_streams_[0].height,
-                                               30,
-                                               Clock::GetRealTimeClock()));
+          test_->send_config_, test_->encoder_config_);
+      assert(test_->encoder_config_.streams.size() == 1);
+      frame_generator_capturer_.reset(test::FrameGeneratorCapturer::Create(
+          send_stream_->Input(),
+          test_->encoder_config_.streams[0].width,
+          test_->encoder_config_.streams[0].height,
+          30,
+          Clock::GetRealTimeClock()));
       send_stream_->Start();
       frame_generator_capturer_->Start();
 
diff --git a/video/call.cc b/video/call.cc
index b4adafd..442e75b 100644
--- a/video/call.cc
+++ b/video/call.cc
@@ -87,8 +87,7 @@
 
   virtual VideoSendStream* CreateVideoSendStream(
       const VideoSendStream::Config& config,
-      const std::vector<VideoStream>& video_streams,
-      const void* encoder_settings) OVERRIDE;
+      const VideoEncoderConfig& encoder_config) OVERRIDE;
 
   virtual void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream)
       OVERRIDE;
@@ -196,8 +195,7 @@
 
 VideoSendStream* Call::CreateVideoSendStream(
     const VideoSendStream::Config& config,
-    const std::vector<VideoStream>& video_streams,
-    const void* encoder_settings) {
+    const VideoEncoderConfig& encoder_config) {
   assert(config.rtp.ssrcs.size() > 0);
 
   // TODO(mflodman): Base the start bitrate on a current bandwidth estimate, if
@@ -207,8 +205,7 @@
       overuse_observer_proxy_.get(),
       video_engine_,
       config,
-      video_streams,
-      encoder_settings,
+      encoder_config,
       suspended_send_ssrcs_,
       base_channel_id_,
       config_.start_bitrate_bps != -1 ? config_.start_bitrate_bps
diff --git a/video/call_perf_tests.cc b/video/call_perf_tests.cc
index 557c514..d055af9 100644
--- a/video/call_perf_tests.cc
+++ b/video/call_perf_tests.cc
@@ -399,7 +399,7 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       (*receive_configs)[0].renderer = this;
       // Enable the receiver side rtt calculation.
       (*receive_configs)[0].rtp.rtcp_xr.receiver_reference_time_report = true;
@@ -546,7 +546,7 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       if (pad_to_min_bitrate_) {
         send_config->rtp.min_transmit_bitrate_bps = kMinTransmitBitrateBps;
       } else {
diff --git a/video/end_to_end_tests.cc b/video/end_to_end_tests.cc
index 1b76eab..0e87a03 100644
--- a/video/end_to_end_tests.cc
+++ b/video/end_to_end_tests.cc
@@ -208,7 +208,7 @@
   Start();
 
   scoped_ptr<test::FrameGenerator> frame_generator(test::FrameGenerator::Create(
-      video_streams_[0].width, video_streams_[0].height));
+      encoder_config_.streams[0].width, encoder_config_.streams[0].height));
   send_stream_->Input()->SwapFrame(frame_generator->NextFrame());
 
   EXPECT_EQ(kEventSignaled, renderer.Wait())
@@ -238,13 +238,13 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       send_config->encoder_settings.encoder = &fake_encoder_;
       send_config->encoder_settings.payload_name = "H264";
       send_config->encoder_settings.payload_type = kFakeSendPayloadType;
-      (*video_streams)[0].min_bitrate_bps = 50000;
-      (*video_streams)[0].target_bitrate_bps =
-          (*video_streams)[0].max_bitrate_bps = 2000000;
+      encoder_config->streams[0].min_bitrate_bps = 50000;
+      encoder_config->streams[0].target_bitrate_bps =
+          encoder_config->streams[0].max_bitrate_bps = 2000000;
 
       (*receive_configs)[0].renderer = this;
       VideoCodec codec =
@@ -369,7 +369,7 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
     }
@@ -463,7 +463,7 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       // TODO(pbos): Run this test with combined NACK/FEC enabled as well.
       // int rtp_history_ms = 1000;
       // (*receive_configs)[0].rtp.nack.rtp_history_ms = rtp_history_ms;
@@ -541,7 +541,7 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       (*receive_configs)[0].pre_render_callback = this;
       (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
@@ -647,9 +647,9 @@
       VideoEncoder::Create(VideoEncoder::kVp8));
   send_config_.encoder_settings.encoder = encoder.get();
   send_config_.encoder_settings.payload_name = "VP8";
-  ASSERT_EQ(1u, video_streams_.size()) << "Test setup error.";
-  video_streams_[0].width = kWidth;
-  video_streams_[0].height = kHeight;
+  ASSERT_EQ(1u, encoder_config_.streams.size()) << "Test setup error.";
+  encoder_config_.streams[0].width = kWidth;
+  encoder_config_.streams[0].height = kHeight;
   send_config_.pre_encode_callback = &pre_encode_callback;
 
   CreateMatchingReceiveConfigs();
@@ -744,7 +744,7 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       send_config->rtp.nack.rtp_history_ms = rtp_history_ms_;
       (*receive_configs)[0].rtp.nack.rtp_history_ms = rtp_history_ms_;
       (*receive_configs)[0].renderer = this;
@@ -891,7 +891,7 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       (*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       (*receive_configs)[0].rtp.rtcp_mode = rtcp_mode_;
@@ -988,15 +988,16 @@
     send_config.encoder_settings.encoder = encoders[i].get();
     send_config.encoder_settings.payload_name = "VP8";
     send_config.encoder_settings.payload_type = 124;
-    std::vector<VideoStream> video_streams = test::CreateVideoStreams(1);
-    VideoStream* stream = &video_streams[0];
+    VideoEncoderConfig encoder_config;
+    encoder_config.streams = test::CreateVideoStreams(1);
+    VideoStream* stream = &encoder_config.streams[0];
     stream->width = width;
     stream->height = height;
     stream->max_framerate = 5;
     stream->min_bitrate_bps = stream->target_bitrate_bps =
         stream->max_bitrate_bps = 100000;
     send_streams[i] =
-        sender_call->CreateVideoSendStream(send_config, video_streams, NULL);
+        sender_call->CreateVideoSendStream(send_config, encoder_config);
     send_streams[i]->Start();
 
     VideoReceiveStream::Config receive_config;
@@ -1087,7 +1088,7 @@
   Start();
 
   scoped_ptr<test::FrameGenerator> frame_generator(test::FrameGenerator::Create(
-      video_streams_[0].width, video_streams_[0].height));
+      encoder_config_.streams[0].width, encoder_config_.streams[0].height));
   send_stream_->Input()->SwapFrame(frame_generator->NextFrame());
 
   EXPECT_EQ(kEventSignaled, post_encode_observer.Wait())
@@ -1212,7 +1213,7 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       (*receive_configs)[0].rtp.rtcp_mode = newapi::kRtcpReducedSize;
       (*receive_configs)[0].rtp.rtcp_xr.receiver_reference_time_report =
           enable_rrtr_;
@@ -1280,19 +1281,19 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       if (num_ssrcs_ > 1) {
         // Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
-        for (size_t i = 0; i < video_streams->size(); ++i) {
-          (*video_streams)[i].min_bitrate_bps = 10000;
-          (*video_streams)[i].target_bitrate_bps = 15000;
-          (*video_streams)[i].max_bitrate_bps = 20000;
+        for (size_t i = 0; i < encoder_config->streams.size(); ++i) {
+          encoder_config->streams[i].min_bitrate_bps = 10000;
+          encoder_config->streams[i].target_bitrate_bps = 15000;
+          encoder_config->streams[i].max_bitrate_bps = 20000;
         }
       }
 
-      all_streams_ = *video_streams;
+      encoder_config_all_streams_ = *encoder_config;
       if (send_single_ssrc_first_)
-        video_streams->resize(1);
+        encoder_config->streams.resize(1);
     }
 
     virtual void OnStreamsCreated(
@@ -1308,7 +1309,7 @@
 
       if (send_single_ssrc_first_) {
         // Set full simulcast and continue with the rest of the SSRCs.
-        send_stream_->ReconfigureVideoEncoder(all_streams_, NULL);
+        send_stream_->ReconfigureVideoEncoder(encoder_config_all_streams_);
         EXPECT_EQ(kEventSignaled, Wait())
             << "Timed out while waiting on additional SSRCs.";
       }
@@ -1325,7 +1326,7 @@
     bool expect_single_ssrc_;
 
     VideoSendStream* send_stream_;
-    std::vector<VideoStream> all_streams_;
+    VideoEncoderConfig encoder_config_all_streams_;
   } test(kSendSsrcs, num_ssrcs, send_single_ssrc_first);
 
   RunBaseTest(&test);
@@ -1469,7 +1470,7 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       send_config->pre_encode_callback = this;  // Used to inject delay.
       send_config->rtp.c_name = "SomeCName";
 
@@ -1645,12 +1646,12 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       // Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
-      for (size_t i = 0; i < video_streams->size(); ++i) {
-        (*video_streams)[i].min_bitrate_bps = 10000;
-        (*video_streams)[i].target_bitrate_bps = 15000;
-        (*video_streams)[i].max_bitrate_bps = 20000;
+      for (size_t i = 0; i < encoder_config->streams.size(); ++i) {
+        encoder_config->streams[i].min_bitrate_bps = 10000;
+        encoder_config->streams[i].target_bitrate_bps = 15000;
+        encoder_config->streams[i].max_bitrate_bps = 20000;
       }
       // Significantly higher than max bitrates for all video streams -> forcing
       // padding to trigger redundant padding on all RTX SSRCs.
@@ -1784,10 +1785,10 @@
   }
 
   // Lower bitrates so that all streams send initially.
-  for (size_t i = 0; i < video_streams_.size(); ++i) {
-    video_streams_[i].min_bitrate_bps = 10000;
-    video_streams_[i].target_bitrate_bps = 15000;
-    video_streams_[i].max_bitrate_bps = 20000;
+  for (size_t i = 0; i < encoder_config_.streams.size(); ++i) {
+    encoder_config_.streams[i].min_bitrate_bps = 10000;
+    encoder_config_.streams[i].target_bitrate_bps = 15000;
+    encoder_config_.streams[i].max_bitrate_bps = 20000;
   }
 
   CreateMatchingReceiveConfigs();
@@ -1806,10 +1807,10 @@
     sender_call_->DestroyVideoSendStream(send_stream_);
 
     // Re-create VideoSendStream with only one stream.
-    std::vector<VideoStream> one_stream = video_streams_;
-    one_stream.resize(1);
+    VideoEncoderConfig one_stream = encoder_config_;
+    one_stream.streams.resize(1);
     send_stream_ =
-        sender_call_->CreateVideoSendStream(send_config_, one_stream, NULL);
+        sender_call_->CreateVideoSendStream(send_config_, one_stream);
     send_stream_->Start();
     CreateFrameGeneratorCapturer();
     frame_generator_capturer_->Start();
@@ -1819,19 +1820,19 @@
         << "Timed out waiting for single RTP packet.";
 
     // Reconfigure back to use all streams.
-    send_stream_->ReconfigureVideoEncoder(video_streams_, NULL);
+    send_stream_->ReconfigureVideoEncoder(encoder_config_);
     observer.ResetExpectedSsrcs(kNumSsrcs);
     EXPECT_EQ(kEventSignaled, observer.Wait())
         << "Timed out waiting for all SSRCs to send packets.";
 
     // Reconfigure down to one stream.
-    send_stream_->ReconfigureVideoEncoder(one_stream, NULL);
+    send_stream_->ReconfigureVideoEncoder(one_stream);
     observer.ResetExpectedSsrcs(1);
     EXPECT_EQ(kEventSignaled, observer.Wait())
         << "Timed out waiting for single RTP packet.";
 
     // Reconfigure back to use all streams.
-    send_stream_->ReconfigureVideoEncoder(video_streams_, NULL);
+    send_stream_->ReconfigureVideoEncoder(encoder_config_);
     observer.ResetExpectedSsrcs(kNumSsrcs);
     EXPECT_EQ(kEventSignaled, observer.Wait())
         << "Timed out waiting for all SSRCs to send packets.";
@@ -1934,7 +1935,7 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       send_config->encoder_settings.encoder = this;
     }
 
diff --git a/video/full_stack.cc b/video/full_stack.cc
index cd1190c..6ae85c4 100644
--- a/video/full_stack.cc
+++ b/video/full_stack.cc
@@ -393,7 +393,7 @@
   send_config_.encoder_settings.payload_name = "VP8";
   send_config_.encoder_settings.payload_type = 124;
 
-  VideoStream* stream = &video_streams_[0];
+  VideoStream* stream = &encoder_config_.streams[0];
   stream->width = params.clip.width;
   stream->height = params.clip.height;
   stream->min_bitrate_bps = params.min_bitrate_bps;
diff --git a/video/loopback.cc b/video/loopback.cc
index 29a3c78..488adf4 100644
--- a/video/loopback.cc
+++ b/video/loopback.cc
@@ -129,8 +129,9 @@
   send_config.encoder_settings.encoder = encoder.get();
   send_config.encoder_settings.payload_name = flags::Codec();
   send_config.encoder_settings.payload_type = 124;
-  std::vector<VideoStream> video_streams = test::CreateVideoStreams(1);
-  VideoStream* stream = &video_streams[0];
+  VideoEncoderConfig encoder_config;
+  encoder_config.streams = test::CreateVideoStreams(1);
+  VideoStream* stream = &encoder_config.streams[0];
   stream->width = flags::Width();
   stream->height = flags::Height();
   stream->min_bitrate_bps = static_cast<int>(flags::MinBitrate()) * 1000;
@@ -140,7 +141,7 @@
   stream->max_qp = 56;
 
   VideoSendStream* send_stream =
-      call->CreateVideoSendStream(send_config, video_streams, NULL);
+      call->CreateVideoSendStream(send_config, encoder_config);
 
   Clock* test_clock = Clock::GetRealTimeClock();
 
diff --git a/video/rampup_tests.cc b/video/rampup_tests.cc
index e1dd95a..10bcb7f 100644
--- a/video/rampup_tests.cc
+++ b/video/rampup_tests.cc
@@ -411,8 +411,8 @@
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
   if (num_streams == 1) {
-    video_streams_[0].target_bitrate_bps = 2000000;
-    video_streams_[0].max_bitrate_bps = 2000000;
+    encoder_config_.streams[0].target_bitrate_bps = 2000000;
+    encoder_config_.streams[0].max_bitrate_bps = 2000000;
   }
 
   send_config_.rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
@@ -430,9 +430,9 @@
     // For multi stream rampup until all streams are being sent. That means
     // enough birate to send all the target streams plus the min bitrate of
     // the last one.
-    int expected_bitrate_bps = video_streams_.back().min_bitrate_bps;
-    for (size_t i = 0; i < video_streams_.size() - 1; ++i) {
-      expected_bitrate_bps += video_streams_[i].target_bitrate_bps;
+    int expected_bitrate_bps = encoder_config_.streams.back().min_bitrate_bps;
+    for (size_t i = 0; i < encoder_config_.streams.size() - 1; ++i) {
+      expected_bitrate_bps += encoder_config_.streams[i].target_bitrate_bps;
     }
     stream_observer.set_expected_bitrate_bps(expected_bitrate_bps);
   }
diff --git a/video/video_send_stream.cc b/video/video_send_stream.cc
index 7d64755..beaa037 100644
--- a/video/video_send_stream.cc
+++ b/video/video_send_stream.cc
@@ -114,8 +114,7 @@
     CpuOveruseObserver* overuse_observer,
     webrtc::VideoEngine* video_engine,
     const VideoSendStream::Config& config,
-    const std::vector<VideoStream> video_streams,
-    const void* encoder_settings,
+    const VideoEncoderConfig& encoder_config,
     const std::map<uint32_t, RtpState>& suspended_ssrcs,
     int base_channel,
     int start_bitrate_bps)
@@ -211,7 +210,7 @@
   }
 
   codec_ = ViECodec::GetInterface(video_engine);
-  if (!ReconfigureVideoEncoder(video_streams, encoder_settings))
+  if (!ReconfigureVideoEncoder(encoder_config))
     abort();
 
   if (overuse_observer)
@@ -297,8 +296,8 @@
 }
 
 bool VideoSendStream::ReconfigureVideoEncoder(
-    const std::vector<VideoStream>& streams,
-    const void* encoder_settings) {
+    const VideoEncoderConfig& config) {
+  const std::vector<VideoStream>& streams = config.streams;
   assert(!streams.empty());
   assert(config_.rtp.ssrcs.size() >= streams.size());
 
@@ -311,6 +310,14 @@
   } else {
     video_codec.codecType = kVideoCodecGeneric;
   }
+  switch (config.content_type) {
+    case VideoEncoderConfig::kRealtimeVideo:
+      video_codec.mode = kRealtimeVideo;
+      break;
+    case VideoEncoderConfig::kScreenshare:
+      video_codec.mode = kScreensharing;
+      break;
+  }
 
   if (video_codec.codecType == kVideoCodecVP8) {
     video_codec.codecSpecific.VP8 = VideoEncoder::GetDefaultVp8Settings();
@@ -319,13 +326,13 @@
   }
 
   if (video_codec.codecType == kVideoCodecVP8) {
-    if (encoder_settings != NULL) {
-      video_codec.codecSpecific.VP8 =
-          *reinterpret_cast<const VideoCodecVP8*>(encoder_settings);
+    if (config.encoder_specific_settings != NULL) {
+      video_codec.codecSpecific.VP8 = *reinterpret_cast<const VideoCodecVP8*>(
+                                          config.encoder_specific_settings);
     }
   } else {
     // TODO(pbos): Support encoder_settings codec-agnostically.
-    assert(encoder_settings == NULL);
+    assert(config.encoder_specific_settings == NULL);
   }
 
   strncpy(video_codec.plName,
diff --git a/video/video_send_stream.h b/video/video_send_stream.h
index 130c1c5..8a77852 100644
--- a/video/video_send_stream.h
+++ b/video/video_send_stream.h
@@ -46,8 +46,7 @@
                   CpuOveruseObserver* overuse_observer,
                   webrtc::VideoEngine* video_engine,
                   const VideoSendStream::Config& config,
-                  const std::vector<VideoStream> video_streams,
-                  const void* encoder_settings,
+                  const VideoEncoderConfig& encoder_config,
                   const std::map<uint32_t, RtpState>& suspended_ssrcs,
                   int base_channel,
                   int start_bitrate);
@@ -57,8 +56,8 @@
   virtual void Start() OVERRIDE;
   virtual void Stop() OVERRIDE;
 
-  virtual bool ReconfigureVideoEncoder(const std::vector<VideoStream>& streams,
-                                       const void* encoder_settings) OVERRIDE;
+  virtual bool ReconfigureVideoEncoder(
+      const VideoEncoderConfig& config) OVERRIDE;
 
   virtual Stats GetStats() const OVERRIDE;
 
diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc
index 7a641bd..888e47b 100644
--- a/video/video_send_stream_tests.cc
+++ b/video/video_send_stream_tests.cc
@@ -114,7 +114,7 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       send_config->rtp.c_name = kCName;
     }
 
@@ -152,7 +152,7 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       send_config->rtp.extensions.push_back(
           RtpExtension(RtpExtension::kAbsSendTime, kAbsSendTimeExtensionId));
     }
@@ -193,7 +193,7 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       send_config->encoder_settings.encoder = &encoder_;
       send_config->rtp.extensions.push_back(
           RtpExtension(RtpExtension::kTOffset, kTOffsetExtensionId));
@@ -360,7 +360,7 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       send_config->rtp.fec.red_payload_type = kRedPayloadType;
       send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
     }
@@ -440,7 +440,7 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       send_config->rtp.rtx.payload_type = retransmit_payload_type_;
       if (retransmit_ssrc_ != kSendSsrcs[0])
@@ -613,7 +613,7 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       if (use_fec_) {
         send_config->rtp.fec.red_payload_type = kRedPayloadType;
         send_config->rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
@@ -788,14 +788,14 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
       send_config->pre_encode_callback = this;
       send_config->suspend_below_min_bitrate = true;
-      int min_bitrate_bps = (*video_streams)[0].min_bitrate_bps;
+      int min_bitrate_bps = encoder_config->streams[0].min_bitrate_bps;
       set_low_remb_bps(min_bitrate_bps - 10000);
       int threshold_window = std::max(min_bitrate_bps / 10, 10000);
-      ASSERT_GT((*video_streams)[0].max_bitrate_bps,
+      ASSERT_GT(encoder_config->streams[0].max_bitrate_bps,
                 min_bitrate_bps + threshold_window + 5000);
       set_high_remb_bps(min_bitrate_bps + threshold_window + 5000);
     }
@@ -977,7 +977,7 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       SetConfig(*send_config);
     }
 
@@ -1074,7 +1074,7 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       send_config->rtp.min_transmit_bitrate_bps = kMinTransmitBitrateBps;
     }
 
@@ -1133,8 +1133,8 @@
   // Prepare five input frames. Send I420VideoFrame and TextureVideoFrame
   // alternatively.
   ScopedVector<I420VideoFrame> input_frames;
-  int width = static_cast<int>(video_streams_[0].width);
-  int height = static_cast<int>(video_streams_[0].height);
+  int width = static_cast<int>(encoder_config_.streams[0].width);
+  int height = static_cast<int>(encoder_config_.streams[0].height);
   webrtc::RefCountImpl<FakeNativeHandle>* handle1 =
       new webrtc::RefCountImpl<FakeNativeHandle>();
   webrtc::RefCountImpl<FakeNativeHandle>* handle2 =
@@ -1154,7 +1154,7 @@
     send_stream_->Input()->SwapFrame(frame.get());
     // Do not send the next frame too fast, so the frame dropper won't drop it.
     if (i < input_frames.size() - 1)
-      SleepMs(1000 / video_streams_[0].max_framerate);
+      SleepMs(1000 / encoder_config_.streams[0].max_framerate);
     // Wait until the output frame is received before sending the next input
     // frame. Or the previous input frame may be replaced without delivering.
     observer.WaitOutputFrame();
@@ -1327,16 +1327,16 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       send_config->encoder_settings.encoder = this;
-      video_streams_ = *video_streams;
+      encoder_config_ = *encoder_config;
     }
 
     virtual void PerformTest() OVERRIDE {
       EXPECT_EQ(kEventSignaled, Wait())
           << "Timed out while waiting for Encode.";
       EXPECT_EQ(0u, num_releases());
-      stream_->ReconfigureVideoEncoder(video_streams_, NULL);
+      stream_->ReconfigureVideoEncoder(encoder_config_);
       EXPECT_EQ(0u, num_releases());
       stream_->Stop();
       // Encoder should not be released before destroying the VideoSendStream.
@@ -1354,7 +1354,7 @@
     bool callback_registered_ GUARDED_BY(crit_);
     size_t num_releases_ GUARDED_BY(crit_);
     bool released_ GUARDED_BY(crit_);
-    std::vector<VideoStream> video_streams_;
+    VideoEncoderConfig encoder_config_;
   } test_encoder;
 
   RunBaseTest(&test_encoder);
@@ -1363,6 +1363,62 @@
   EXPECT_EQ(1u, test_encoder.num_releases());
 }
 
+TEST_F(VideoSendStreamTest, EncoderSetupPropagatesCommonEncoderConfigValues) {
+  class VideoCodecConfigObserver : public test::SendTest,
+                                   public test::FakeEncoder {
+   public:
+    VideoCodecConfigObserver()
+        : SendTest(kDefaultTimeoutMs),
+          FakeEncoder(Clock::GetRealTimeClock()),
+          num_initializations_(0) {}
+
+   private:
+    virtual void ModifyConfigs(
+        VideoSendStream::Config* send_config,
+        std::vector<VideoReceiveStream::Config>* receive_configs,
+        VideoEncoderConfig* encoder_config) OVERRIDE {
+      send_config->encoder_settings.encoder = this;
+      encoder_config_ = *encoder_config;
+    }
+
+    virtual void OnStreamsCreated(
+        VideoSendStream* send_stream,
+        const std::vector<VideoReceiveStream*>& receive_streams) OVERRIDE {
+      stream_ = send_stream;
+    }
+
+    virtual int32_t InitEncode(const VideoCodec* config,
+                               int32_t number_of_cores,
+                               uint32_t max_payload_size) OVERRIDE {
+      if (num_initializations_ == 0) {
+        // Verify default values.
+        EXPECT_EQ(kRealtimeVideo, config->mode);
+      } else {
+        // Verify that changed values are propagated.
+        EXPECT_EQ(kScreensharing, config->mode);
+      }
+      ++num_initializations_;
+      return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
+    }
+
+    virtual void PerformTest() OVERRIDE {
+      EXPECT_EQ(1u, num_initializations_) << "VideoEncoder not initialized.";
+
+      encoder_config_.content_type = VideoEncoderConfig::kScreenshare;
+      stream_->ReconfigureVideoEncoder(encoder_config_);
+      EXPECT_EQ(2u, num_initializations_)
+          << "ReconfigureVideoEncoder did not reinitialize the encoder with "
+             "new encoder settings.";
+    }
+
+    size_t num_initializations_;
+    VideoSendStream* stream_;
+    VideoEncoderConfig encoder_config_;
+  } test;
+
+  RunBaseTest(&test);
+}
+
 TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) {
   class VideoCodecConfigObserver : public test::SendTest,
                                    public test::FakeEncoder {
@@ -1378,11 +1434,12 @@
     virtual void ModifyConfigs(
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStream::Config>* receive_configs,
-        std::vector<VideoStream>* video_streams) OVERRIDE {
+        VideoEncoderConfig* encoder_config) OVERRIDE {
       send_config->encoder_settings.encoder = this;
       send_config->encoder_settings.payload_name = "VP8";
 
-      video_streams_ = *video_streams;
+      encoder_config->encoder_specific_settings = &vp8_settings_;
+      encoder_config_ = *encoder_config;
     }
 
     virtual void OnStreamsCreated(
@@ -1407,26 +1464,23 @@
       EXPECT_EQ(1u, num_initializations_) << "VideoEncoder not initialized.";
 
       vp8_settings_.denoisingOn = true;
-      stream_->ReconfigureVideoEncoder(video_streams_, &vp8_settings_);
+      stream_->ReconfigureVideoEncoder(encoder_config_);
       EXPECT_EQ(2u, num_initializations_)
           << "ReconfigureVideoEncoder did not reinitialize the encoder with "
              "new encoder settings.";
     }
 
-    int32_t Encode(
-        const I420VideoFrame& input_image,
-        const CodecSpecificInfo* codec_specific_info,
-        const std::vector<VideoFrameType>* frame_types) {
+    int32_t Encode(const I420VideoFrame& input_image,
+                   const CodecSpecificInfo* codec_specific_info,
+                   const std::vector<VideoFrameType>* frame_types) OVERRIDE {
       // Silently skip the encode, FakeEncoder::Encode doesn't produce VP8.
       return 0;
     }
 
-    virtual const void* GetEncoderSettings() OVERRIDE { return &vp8_settings_; }
-
     VideoCodecVP8 vp8_settings_;
     size_t num_initializations_;
     VideoSendStream* stream_;
-    std::vector<VideoStream> video_streams_;
+    VideoEncoderConfig encoder_config_;
   } test;
 
   RunBaseTest(&test);
diff --git a/video_send_stream.h b/video_send_stream.h
index 8c9d5b7..dd2bec1 100644
--- a/video_send_stream.h
+++ b/video_send_stream.h
@@ -153,8 +153,7 @@
   // Set which streams to send. Must have at least as many SSRCs as configured
   // in the config. Encoder settings are passed on to the encoder instance along
   // with the VideoStream settings.
-  virtual bool ReconfigureVideoEncoder(const std::vector<VideoStream>& streams,
-                                       const void* encoder_settings) = 0;
+  virtual bool ReconfigureVideoEncoder(const VideoEncoderConfig& config) = 0;
 
   virtual Stats GetStats() const = 0;