1 files changed, 24 insertions, 88 deletions

diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc
index 6a6b0e13..5a496988 100644
--- a/video/video_send_stream_tests.cc
+++ b/video/video_send_stream_tests.cc
@@ -23,6 +23,7 @@
 #include "webrtc/system_wrappers/interface/sleep.h"
 #include "webrtc/system_wrappers/interface/thread_wrapper.h"
 #include "webrtc/test/direct_transport.h"
+#include "webrtc/test/encoder_settings.h"
 #include "webrtc/test/fake_encoder.h"
 #include "webrtc/test/configurable_frame_size_encoder.h"
 #include "webrtc/test/frame_generator_capturer.h"
@@ -59,17 +60,16 @@ class VideoSendStreamTest : public ::testing::Test {
     call->DestroyVideoSendStream(send_stream_);
   }
 
-  VideoSendStream::Config GetSendTestConfig(Call* call,
-                                            size_t number_of_streams) {
-    assert(number_of_streams <= kNumSendSsrcs);
+  VideoSendStream::Config GetSendTestConfig(Call* call, size_t num_streams) {
+    assert(num_streams <= kNumSendSsrcs);
     VideoSendStream::Config config = call->GetDefaultSendConfig();
-    config.encoder = &fake_encoder_;
-    config.internal_source = false;
-    for (size_t i = 0; i < number_of_streams; ++i)
+    config.encoder_settings = test::CreateEncoderSettings(
+        &fake_encoder_, "FAKE", kFakeSendPayloadType, num_streams);
+    config.encoder_settings.encoder = &fake_encoder_;
+    config.encoder_settings.payload_type = kFakeSendPayloadType;
+    for (size_t i = 0; i < num_streams; ++i)
       config.rtp.ssrcs.push_back(kSendSsrcs[i]);
     config.pacing = true;
-    test::FakeEncoder::SetCodecSettings(&config.codec, number_of_streams);
-    config.codec.plType = kFakeSendPayloadType;
     return config;
   }
 
@@ -161,15 +161,17 @@ void VideoSendStreamTest::SendsSetSsrcs(size_t num_ssrcs,
 
   if (num_ssrcs > 1) {
     // Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
-    for (size_t i = 0; i < num_ssrcs; ++i) {
-      send_config.codec.simulcastStream[i].minBitrate = 10;
-      send_config.codec.simulcastStream[i].targetBitrate = 10;
-      send_config.codec.simulcastStream[i].maxBitrate = 10;
+    std::vector<VideoStream>* streams = &send_config.encoder_settings.streams;
+    for (size_t i = 0; i < streams->size(); ++i) {
+      (*streams)[i].min_bitrate_bps = 10000;
+      (*streams)[i].target_bitrate_bps = 10000;
+      (*streams)[i].max_bitrate_bps = 10000;
     }
   }
 
+  std::vector<VideoStream> all_streams = send_config.encoder_settings.streams;
   if (send_single_ssrc_first)
-    send_config.codec.numberOfSimulcastStreams = 1;
+    send_config.encoder_settings.streams.resize(1);
 
   send_stream_ = call->CreateVideoSendStream(send_config);
   scoped_ptr<test::FrameGeneratorCapturer> frame_generator_capturer(
@@ -184,9 +186,7 @@ void VideoSendStreamTest::SendsSetSsrcs(size_t num_ssrcs,
 
   if (send_single_ssrc_first) {
     // Set full simulcast and continue with the rest of the SSRCs.
-    send_config.codec.numberOfSimulcastStreams =
-        static_cast<unsigned char>(num_ssrcs);
-    send_stream_->SetCodec(send_config.codec);
+    send_stream_->ReconfigureVideoEncoder(all_streams, NULL);
     EXPECT_EQ(kEventSignaled, observer.Wait())
         << "Timed out while waiting on additional SSRCs.";
   }
@@ -338,7 +338,7 @@ TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
   scoped_ptr<Call> call(Call::Create(call_config));
 
   VideoSendStream::Config send_config = GetSendTestConfig(call.get(), 1);
-  send_config.encoder = &encoder;
+  send_config.encoder_settings.encoder = &encoder;
   send_config.rtp.extensions.push_back(
       RtpExtension(RtpExtension::kTOffset, kTOffsetExtensionId));
 
@@ -766,12 +766,11 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
     send_config.rtp.fec.ulpfec_payload_type = kUlpfecPayloadType;
   }
 
-  if (format == kVP8) {
-    strcpy(send_config.codec.plName, "VP8");
-    send_config.codec.codecType = kVideoCodecVP8;
-  }
+  if (format == kVP8)
+    send_config.encoder_settings.payload_name = "VP8";
+
   send_config.pacing = false;
-  send_config.encoder = &encoder;
+  send_config.encoder_settings.encoder = &encoder;
   send_config.rtp.max_packet_size = kMaxPacketSize;
   send_config.post_encode_callback = &observer;
 
@@ -801,68 +800,6 @@ TEST_F(VideoSendStreamTest, FragmentsVp8AccordingToMaxPacketSizeWithFec) {
   TestPacketFragmentationSize(kVP8, true);
 }
 
-TEST_F(VideoSendStreamTest, CanChangeSendCodec) {
-  static const uint8_t kFirstPayloadType = 121;
-  static const uint8_t kSecondPayloadType = 122;
-
-  class CodecChangeObserver : public test::RtpRtcpObserver {
-   public:
-    CodecChangeObserver(VideoSendStream** send_stream_ptr)
-        : RtpRtcpObserver(30 * 1000),
-          received_first_payload_(EventWrapper::Create()),
-          send_stream_ptr_(send_stream_ptr) {}
-
-    virtual Action OnSendRtp(const uint8_t* packet, size_t length) OVERRIDE {
-      RTPHeader header;
-      EXPECT_TRUE(parser_->Parse(packet, static_cast<int>(length), &header));
-
-      if (header.payloadType == kFirstPayloadType) {
-        received_first_payload_->Set();
-      } else if (header.payloadType == kSecondPayloadType) {
-        observation_complete_->Set();
-      }
-
-      return SEND_PACKET;
-    }
-
-    virtual EventTypeWrapper Wait() OVERRIDE {
-      EXPECT_EQ(kEventSignaled, received_first_payload_->Wait(30 * 1000))
-          << "Timed out while waiting for first payload.";
-
-      EXPECT_TRUE((*send_stream_ptr_)->SetCodec(second_codec_));
-
-      EXPECT_EQ(kEventSignaled, RtpRtcpObserver::Wait())
-          << "Timed out while waiting for second payload type.";
-
-      // Return OK regardless, prevents double error reporting.
-      return kEventSignaled;
-    }
-
-    void SetSecondCodec(const VideoCodec& codec) { second_codec_ = codec; }
-
-   private:
-    scoped_ptr<EventWrapper> received_first_payload_;
-    VideoSendStream** send_stream_ptr_;
-    VideoCodec second_codec_;
-  } observer(&send_stream_);
-
-  Call::Config call_config(observer.SendTransport());
-  scoped_ptr<Call> call(Call::Create(call_config));
-
-  std::vector<VideoCodec> codecs = call->GetVideoCodecs();
-  ASSERT_GE(codecs.size(), 2u)
-      << "Test needs at least 2 separate codecs to work.";
-  codecs[0].plType = kFirstPayloadType;
-  codecs[1].plType = kSecondPayloadType;
-  observer.SetSecondCodec(codecs[1]);
-
-  VideoSendStream::Config send_config = GetSendTestConfig(call.get(), 1);
-  send_config.codec = codecs[0];
-  send_config.encoder = NULL;
-
-  RunSendTest(call.get(), send_config, &observer);
-}
-
 // The test will go through a number of phases.
 // 1. Start sending packets.
 // 2. As soon as the RTP stream has been detected, signal a low REMB value to
@@ -1005,11 +942,10 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
   send_config.rtp.nack.rtp_history_ms = 1000;
   send_config.pre_encode_callback = &observer;
   send_config.suspend_below_min_bitrate = true;
-  unsigned int min_bitrate_bps =
-      send_config.codec.simulcastStream[0].minBitrate * 1000;
+  int min_bitrate_bps = send_config.encoder_settings.streams[0].min_bitrate_bps;
   observer.set_low_remb_bps(min_bitrate_bps - 10000);
-  unsigned int threshold_window = std::max(min_bitrate_bps / 10, 10000u);
-  ASSERT_GT(send_config.codec.simulcastStream[0].maxBitrate * 1000,
+  int threshold_window = std::max(min_bitrate_bps / 10, 10000);
+  ASSERT_GT(send_config.encoder_settings.streams[0].max_bitrate_bps,
             min_bitrate_bps + threshold_window + 5000);
   observer.set_high_remb_bps(min_bitrate_bps + threshold_window + 5000);