Support VP8 encoder settings in VideoSendStream.

Stop-gap solution to support VP8 codec settings in the new API until
encoder settings can be passed on to the VideoEncoder without requiring
explicit support for the codec.

BUG=3424
R=stefan@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/17929004

git-svn-id: http://webrtc.googlecode.com/svn/trunk@6650 4adac7df-926f-26a2-2b94-8c16560cd09d

webrtc/test/call_test.cc

@@ -16,6 +16,7 @@ namespace test {
 
 CallTest::CallTest()
     : clock_(Clock::GetRealTimeClock()),
+      encoder_settings_(NULL),
       send_stream_(NULL),
       fake_encoder_(clock_) {
 }
@@ -39,6 +40,7 @@ void CallTest::RunBaseTest(BaseTest* test) {
   if (test->ShouldCreateReceivers()) {
     CreateMatchingReceiveConfigs();
   }
+  encoder_settings_ = test->GetEncoderSettings();
   test->ModifyConfigs(&send_config_, &receive_configs_, &video_streams_);
   CreateStreams();
   test->OnStreamsCreated(send_stream_, receive_streams_);
@@ -128,8 +130,8 @@ void CallTest::CreateStreams() {
   assert(send_stream_ == NULL);
   assert(receive_streams_.empty());
 
-  send_stream_ =
-      sender_call_->CreateVideoSendStream(send_config_, video_streams_, NULL);
+  send_stream_ = sender_call_->CreateVideoSendStream(
+      send_config_, video_streams_, encoder_settings_);
 
   for (size_t i = 0; i < receive_configs_.size(); ++i) {
     receive_streams_.push_back(
@@ -183,6 +185,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,

webrtc/test/call_test.h

@@ -63,6 +63,7 @@ class CallTest : public ::testing::Test {
   scoped_ptr<Call> sender_call_;
   VideoSendStream::Config send_config_;
   std::vector<VideoStream> video_streams_;
+  const void* encoder_settings_;
   VideoSendStream* send_stream_;
 
   scoped_ptr<Call> receiver_call_;
@@ -89,6 +90,7 @@ 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,

webrtc/video/video_send_stream.cc

@@ -298,8 +298,6 @@ bool VideoSendStream::ReconfigureVideoEncoder(
     const void* encoder_settings) {
   assert(!streams.empty());
   assert(config_.rtp.ssrcs.size() >= streams.size());
-  // TODO(pbos): Wire encoder_settings.
-  assert(encoder_settings == NULL);
 
   VideoCodec video_codec;
   memset(&video_codec, 0, sizeof(video_codec));
@@ -317,6 +315,16 @@ bool VideoSendStream::ReconfigureVideoEncoder(
     video_codec.codecSpecific.VP8.keyFrameInterval = 3000;
   }
 
+  if (video_codec.codecType == kVideoCodecVP8) {
+    if (encoder_settings != NULL) {
+      video_codec.codecSpecific.VP8 =
+          *reinterpret_cast<const VideoCodecVP8*>(encoder_settings);
+    }
+  } else {
+    // TODO(pbos): Support encoder_settings codec-agnostically.
+    assert(encoder_settings == NULL);
+  }
+
   strncpy(video_codec.plName,
           config_.encoder_settings.payload_name.c_str(),
           kPayloadNameSize - 1);

webrtc/video/video_send_stream_tests.cc

@@ -1369,4 +1369,65 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
   EXPECT_EQ(1u, test_encoder.num_releases());
 }
 
+TEST_F(VideoSendStreamTest, EncoderSetupPropagatesVp8Config) {
+  class VideoCodecConfigObserver : public test::SendTest,
+                                   public test::FakeEncoder {
+   public:
+    VideoCodecConfigObserver()
+        : SendTest(kDefaultTimeoutMs),
+          FakeEncoder(Clock::GetRealTimeClock()),
+          num_initializations_(0) {
+      memset(&vp8_settings_, 0, sizeof(vp8_settings_));
+    }
+
+   private:
+    virtual void ModifyConfigs(
+        VideoSendStream::Config* send_config,
+        std::vector<VideoReceiveStream::Config>* receive_configs,
+        std::vector<VideoStream>* video_streams) OVERRIDE {
+      send_config->encoder_settings.encoder = this;
+      send_config->encoder_settings.payload_name = "VP8";
+
+      video_streams_ = *video_streams;
+    }
+
+    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 {
+      EXPECT_EQ(kVideoCodecVP8, config->codecType);
+      EXPECT_EQ(0,
+                memcmp(&config->codecSpecific.VP8,
+                       &vp8_settings_,
+                       sizeof(vp8_settings_)));
+      ++num_initializations_;
+      return FakeEncoder::InitEncode(config, number_of_cores, max_payload_size);
+    }
+
+    virtual void PerformTest() OVERRIDE {
+      EXPECT_EQ(1u, num_initializations_) << "VideoEncoder not initialized.";
+
+      vp8_settings_.denoisingOn = true;
+      stream_->ReconfigureVideoEncoder(video_streams_, &vp8_settings_);
+      EXPECT_EQ(2u, num_initializations_)
+          << "ReconfigureVideoEncoder did not reinitialize the encoder with "
+             "new encoder settings.";
+    }
+
+    virtual const void* GetEncoderSettings() OVERRIDE { return &vp8_settings_; }
+
+    VideoCodecVP8 vp8_settings_;
+    size_t num_initializations_;
+    VideoSendStream* stream_;
+    std::vector<VideoStream> video_streams_;
+  } test;
+
+  RunBaseTest(&test);
+}
+
 }  // namespace webrtc