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

4 files changed, 52 insertions, 58 deletions

diff --git a/talk/media/webrtc/webrtcvideoengine2.cc b/talk/media/webrtc/webrtcvideoengine2.cc
index a1a9aa41cf..22a763016c 100644
--- a/talk/media/webrtc/webrtcvideoengine2.cc
+++ b/talk/media/webrtc/webrtcvideoengine2.cc
@@ -229,13 +229,9 @@ void WebRtcVideoEncoderFactory2::DestroyVideoEncoderSettings(
   if (encoder_settings == NULL) {
     return;
   }
-
   if (_stricmp(codec.name.c_str(), kVp8CodecName) == 0) {
     delete reinterpret_cast<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_.video_streams.back().height;
+                  << parameters_.encoder_config.streams.back().width << "x"
+                  << parameters_.encoder_config.streams.back().height;
   stream_->Input()->SwapFrame(&video_frame_);
 }
 
@@ -1446,7 +1442,7 @@ bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoFormat(
         << parameters_.config.rtp.ssrcs[0] << ".";
   } else {
     // TODO(pbos): Fix me, this only affects the last stream!
-    parameters_.video_streams.back().max_framerate =
+    parameters_.encoder_config.streams.back().max_framerate =
         VideoFormat::IntervalToFps(format.interval);
     SetDimensions(format.width, format.height, false);
   }
@@ -1494,7 +1490,7 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodecAndOptions(
   if (video_streams.empty()) {
     return;
   }
-  parameters_.video_streams = video_streams;
+  parameters_.encoder_config.streams = video_streams;
   format_ = VideoFormat(codec_settings.codec.width,
                         codec_settings.codec.height,
                         VideoFormat::FpsToInterval(30),
@@ -1541,7 +1537,7 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::SetDimensions(
     int width,
     int height,
     bool override_max) {
-  assert(!parameters_.video_streams.empty());
+  assert(!parameters_.encoder_config.streams.empty());
   LOG(LS_VERBOSE) << "SetDimensions: " << width << "x" << height;
 
   VideoCodecSettings codec_settings;
@@ -1554,27 +1550,30 @@ void WebRtcVideoChannel2::WebRtcVideoSendStream::SetDimensions(
       height = codec_settings.codec.height;
   }
 
-  if (parameters_.video_streams.back().width == width &&
-      parameters_.video_streams.back().height == height) {
+  if (parameters_.encoder_config.streams.back().width == width &&
+      parameters_.encoder_config.streams.back().height == height) {
     return;
   }
 
-  void* encoder_settings = encoder_factory_->CreateVideoEncoderSettings(
-      codec_settings.codec, parameters_.options);
+  webrtc::VideoEncoderConfig encoder_config = parameters_.encoder_config;
+  encoder_config.encoder_specific_settings =
+      encoder_factory_->CreateVideoEncoderSettings(codec_settings.codec,
+                                                   parameters_.options);
 
   VideoCodec codec = codec_settings.codec;
   codec.width = width;
   codec.height = height;
-  std::vector<webrtc::VideoStream> video_streams =
-      encoder_factory_->CreateVideoStreams(codec,
-                                           parameters_.options,
-                                           parameters_.config.rtp.ssrcs.size());
 
-  bool stream_reconfigured = stream_->ReconfigureVideoEncoder(
-      video_streams, encoder_settings);
+  encoder_config.streams = encoder_factory_->CreateVideoStreams(
+      codec, parameters_.options, parameters_.config.rtp.ssrcs.size());
 
-  encoder_factory_->DestroyVideoEncoderSettings(codec_settings.codec,
-                                                encoder_settings);
+  bool stream_reconfigured = stream_->ReconfigureVideoEncoder(encoder_config);
+
+  encoder_factory_->DestroyVideoEncoderSettings(
+      codec_settings.codec,
+      encoder_config.encoder_specific_settings);
+
+  encoder_config.encoder_specific_settings = NULL;
 
   if (!stream_reconfigured) {
     LOG(LS_WARNING) << "Failed to reconfigure video encoder for dimensions: "
@@ -1582,7 +1581,7 @@ 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(
-      codec_settings.codec, parameters_.options);
+  parameters_.encoder_config.encoder_specific_settings =
+      encoder_factory_->CreateVideoEncoderSettings(codec_settings.codec,
+                                                   parameters_.options);
+
+  stream_ = call_->CreateVideoSendStream(parameters_.config,
+                                         parameters_.encoder_config);
 
-  stream_ = call_->CreateVideoSendStream(
-      parameters_.config, parameters_.video_streams, encoder_settings);
+  encoder_factory_->DestroyVideoEncoderSettings(
+      codec_settings.codec,
+      parameters_.encoder_config.encoder_specific_settings);
 
-  encoder_factory_->DestroyVideoEncoderSettings(codec_settings.codec,
-                                                encoder_settings);
+  parameters_.encoder_config.encoder_specific_settings = NULL;
 
   if (sending_) {
     stream_->Start();
diff --git a/talk/media/webrtc/webrtcvideoengine2.h b/talk/media/webrtc/webrtcvideoengine2.h
index d77afb9d2f..f285d10a92 100644
--- a/talk/media/webrtc/webrtcvideoengine2.h
+++ b/talk/media/webrtc/webrtcvideoengine2.h
@@ -119,9 +119,8 @@ class WebRtcVideoEncoderFactory2 {
       const VideoCodec& codec,
       const VideoOptions& options);
 
-  virtual void* CreateVideoEncoderSettings(
-      const VideoCodec& codec,
-      const VideoOptions& options);
+  virtual void* CreateVideoEncoderSettings(const VideoCodec& codec,
+                                           const VideoOptions& options);
 
   virtual void DestroyVideoEncoderSettings(const VideoCodec& codec,
                                            void* encoder_settings);
@@ -316,7 +315,7 @@ class WebRtcVideoChannel2 : public rtc::MessageHandler,
       // Sent resolutions + bitrates etc. by the underlying VideoSendStream,
       // typically changes when setting a new resolution or reconfiguring
       // bitrates.
-      std::vector<webrtc::VideoStream> video_streams;
+      webrtc::VideoEncoderConfig encoder_config;
     };
 
     void SetCodecAndOptions(const VideoCodecSettings& codec,
diff --git a/talk/media/webrtc/webrtcvideoengine2_unittest.cc b/talk/media/webrtc/webrtcvideoengine2_unittest.cc
index 2178a68895..6112c50ec8 100644
--- a/talk/media/webrtc/webrtcvideoengine2_unittest.cc
+++ b/talk/media/webrtc/webrtcvideoengine2_unittest.cc
@@ -68,13 +68,10 @@ void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec) {
 namespace cricket {
 FakeVideoSendStream::FakeVideoSendStream(
     const webrtc::VideoSendStream::Config& config,
-    const std::vector<webrtc::VideoStream>& video_streams,
-    const void* encoder_settings)
-    : sending_(false),
-      config_(config),
-      codec_settings_set_(false) {
+    const webrtc::VideoEncoderConfig& encoder_config)
+    : sending_(false), config_(config), codec_settings_set_(false) {
   assert(config.encoder_settings.encoder != NULL);
-  ReconfigureVideoEncoder(video_streams, encoder_settings);
+  ReconfigureVideoEncoder(encoder_config);
 }
 
 webrtc::VideoSendStream::Config FakeVideoSendStream::GetConfig() {
@@ -82,7 +79,7 @@ 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 void* encoder_specific) {
-  video_streams_ = streams;
-  if (encoder_specific != NULL) {
+    const webrtc::VideoEncoderConfig& config) {
+  encoder_config_ = config;
+  if (config.encoder_specific_settings != NULL) {
     assert(config_.encoder_settings.payload_name == "VP8");
-    vp8_settings_ =
-        *reinterpret_cast<const webrtc::VideoCodecVP8*>(encoder_specific);
+    vp8_settings_ = *reinterpret_cast<const webrtc::VideoCodecVP8*>(
+                        config.encoder_specific_settings);
   }
-  codec_settings_set_ = encoder_specific != NULL;
+  codec_settings_set_ = config.encoder_specific_settings != NULL;
   return true;
 }
 
@@ -226,10 +222,9 @@ webrtc::Call::NetworkState FakeCall::GetNetworkState() const {
 
 webrtc::VideoSendStream* FakeCall::CreateVideoSendStream(
     const webrtc::VideoSendStream::Config& config,
-    const std::vector<webrtc::VideoStream>& video_streams,
-    const void* encoder_settings) {
+    const webrtc::VideoEncoderConfig& encoder_config) {
   FakeVideoSendStream* fake_stream =
-      new FakeVideoSendStream(config, video_streams, encoder_settings);
+      new FakeVideoSendStream(config, encoder_config);
   video_send_streams_.push_back(fake_stream);
   return fake_stream;
 }
diff --git a/talk/media/webrtc/webrtcvideoengine2_unittest.h b/talk/media/webrtc/webrtcvideoengine2_unittest.h
index 5aaa3e33d2..30f1efb85b 100644
--- a/talk/media/webrtc/webrtcvideoengine2_unittest.h
+++ b/talk/media/webrtc/webrtcvideoengine2_unittest.h
@@ -39,8 +39,7 @@ namespace cricket {
 class FakeVideoSendStream : public webrtc::VideoSendStream {
  public:
   FakeVideoSendStream(const webrtc::VideoSendStream::Config& config,
-                      const std::vector<webrtc::VideoStream>& video_streams,
-                      const void* encoder_settings);
+                      const webrtc::VideoEncoderConfig& encoder_config);
   webrtc::VideoSendStream::Config GetConfig();
   std::vector<webrtc::VideoStream> GetVideoStreams();
 
@@ -51,8 +50,7 @@ class FakeVideoSendStream : public webrtc::VideoSendStream {
   virtual webrtc::VideoSendStream::Stats GetStats() const OVERRIDE;
 
   virtual bool ReconfigureVideoEncoder(
-      const std::vector<webrtc::VideoStream>& streams,
-      const void* encoder_specific);
+      const webrtc::VideoEncoderConfig& config) OVERRIDE;
 
   virtual webrtc::VideoSendStreamInput* Input() OVERRIDE;
 
@@ -61,7 +59,7 @@ 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 void* encoder_settings) OVERRIDE;
+      const webrtc::VideoEncoderConfig& encoder_config) OVERRIDE;
 
   virtual void DestroyVideoSendStream(
       webrtc::VideoSendStream* send_stream) OVERRIDE;