Let ViEEncoder handle resolution changes.

webrtc/test/call_test.cc

 /*
  *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #include "webrtc/base/checks.h"
 #include "webrtc/config.h"
 #include "webrtc/modules/audio_coding/codecs/builtin_audio_decoder_factory.h"
 #include "webrtc/test/call_test.h"
-#include "webrtc/test/encoder_settings.h"
 #include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/voice_engine/include/voe_base.h"
 #include "webrtc/voice_engine/include/voe_codec.h"
 
 namespace webrtc {
 namespace test {
 
 namespace {
 const int kVideoRotationRtpExtensionId = 4;
 }
@@ skipping 63 matching lines @@
   if (num_video_streams_ > 0) {
     CreateVideoStreams();
     test->OnVideoStreamsCreated(video_send_stream_, video_receive_streams_);
   }
   if (num_audio_streams_ > 0) {
     CreateAudioStreams();
     test->OnAudioStreamsCreated(audio_send_stream_, audio_receive_streams_);
   }
 
   if (num_video_streams_ > 0) {
-    CreateFrameGeneratorCapturer();
+    int width = kDefaultWidth;
+    int height = kDefaultHeight;
+    int frame_rate = kDefaultFramerate;
+    test->ModifyVideoCaptureStartResolution(&width, &height, &frame_rate);
+    CreateFrameGeneratorCapturer(frame_rate, width, height);
     test->OnFrameGeneratorCapturerCreated(frame_generator_capturer_.get());
   }
 
   Start();
   test->PerformTest();
   send_transport_->StopSending();
   receive_transport_->StopSending();
   Stop();
 
   DestroyStreams();
@@ skipping 70 matching lines @@
   RTC_DCHECK_LE(num_audio_streams, 1u);
   RTC_DCHECK(num_audio_streams == 0 || voe_send_.channel_id >= 0);
   if (num_video_streams > 0) {
     video_send_config_ = VideoSendStream::Config(send_transport);
     video_send_config_.encoder_settings.encoder = &fake_encoder_;
     video_send_config_.encoder_settings.payload_name = "FAKE";
     video_send_config_.encoder_settings.payload_type =
         kFakeVideoSendPayloadType;
     video_send_config_.rtp.extensions.push_back(
         RtpExtension(RtpExtension::kAbsSendTimeUri, kAbsSendTimeExtensionId));
-    video_encoder_config_.streams = test::CreateVideoStreams(num_video_streams);
+    FillEncoderConfiguration(num_video_streams, &video_encoder_config_);
+
     for (size_t i = 0; i < num_video_streams; ++i)
       video_send_config_.rtp.ssrcs.push_back(kVideoSendSsrcs[i]);
     video_send_config_.rtp.extensions.push_back(RtpExtension(
         RtpExtension::kVideoRotationUri, kVideoRotationRtpExtensionId));
   }
 
   if (num_audio_streams > 0) {
     audio_send_config_ = AudioSendStream::Config(send_transport);
     audio_send_config_.voe_channel_id = voe_send_.channel_id;
     audio_send_config_.rtp.ssrc = kAudioSendSsrc;
@@ skipping 30 matching lines @@
     audio_config.rtp.local_ssrc = kReceiverLocalAudioSsrc;
     audio_config.rtcp_send_transport = rtcp_send_transport;
     audio_config.voe_channel_id = voe_recv_.channel_id;
     audio_config.rtp.remote_ssrc = audio_send_config_.rtp.ssrc;
     audio_config.decoder_factory = decoder_factory_;
     audio_receive_configs_.push_back(audio_config);
   }
 }
 
 void CallTest::CreateFrameGeneratorCapturerWithDrift(Clock* clock,
-                                                     float speed) {
-  VideoStream stream = video_encoder_config_.streams.back();
+                                                     float speed,
+                                                     int framerate,
+                                                     int width,
+                                                     int height) {
   frame_generator_capturer_.reset(test::FrameGeneratorCapturer::Create(
-      stream.width, stream.height, stream.max_framerate * speed, clock));
+      width, height, framerate * speed, clock));
   video_send_stream_->SetSource(frame_generator_capturer_.get());
 }
 
-void CallTest::CreateFrameGeneratorCapturer() {
-  VideoStream stream = video_encoder_config_.streams.back();
-  frame_generator_capturer_.reset(test::FrameGeneratorCapturer::Create(
-      stream.width, stream.height, stream.max_framerate, clock_));
+void CallTest::CreateFrameGeneratorCapturer(int framerate,
+                                            int width,
+                                            int height) {
+  frame_generator_capturer_.reset(
+      test::FrameGeneratorCapturer::Create(width, height, framerate, clock_));
   video_send_stream_->SetSource(frame_generator_capturer_.get());
 }
 
 void CallTest::CreateFakeAudioDevices() {
   fake_send_audio_device_.reset(new FakeAudioDevice(
       clock_, test::ResourcePath("voice_engine/audio_long16", "pcm"),
       DriftingClock::kNoDrift));
   fake_recv_audio_device_.reset(new FakeAudioDevice(
       clock_, test::ResourcePath("voice_engine/audio_long16", "pcm"),
       DriftingClock::kNoDrift));
@@ skipping 79 matching lines @@
   voe_send_.base = nullptr;
   voe_send_.codec->Release();
   voe_send_.codec = nullptr;
 
   VoiceEngine::Delete(voe_send_.voice_engine);
   voe_send_.voice_engine = nullptr;
   VoiceEngine::Delete(voe_recv_.voice_engine);
   voe_recv_.voice_engine = nullptr;
 }
 
+const int CallTest::kDefaultWidth;
+const int CallTest::kDefaultHeight;
+const int CallTest::kDefaultFramerate;
 const int CallTest::kDefaultTimeoutMs = 30 * 1000;
 const int CallTest::kLongTimeoutMs = 120 * 1000;
 const uint8_t CallTest::kVideoSendPayloadType = 100;
 const uint8_t CallTest::kFakeVideoSendPayloadType = 125;
 const uint8_t CallTest::kSendRtxPayloadType = 98;
 const uint8_t CallTest::kRedPayloadType = 118;
 const uint8_t CallTest::kRtxRedPayloadType = 99;
 const uint8_t CallTest::kUlpfecPayloadType = 119;
 const uint8_t CallTest::kAudioSendPayloadType = 103;
 const uint32_t CallTest::kSendRtxSsrcs[kNumSsrcs] = {0xBADCAFD, 0xBADCAFE,
@@ skipping 38 matching lines @@
 
 size_t BaseTest::GetNumAudioStreams() const {
   return 0;
 }
 
 void BaseTest::ModifyVideoConfigs(
     VideoSendStream::Config* send_config,
     std::vector<VideoReceiveStream::Config>* receive_configs,
     VideoEncoderConfig* encoder_config) {}
 
+void BaseTest::ModifyVideoCaptureStartResolution(int* width,
+                                                 int* heigt,
+                                                 int* frame_rate) {}
+
 void BaseTest::OnVideoStreamsCreated(
     VideoSendStream* send_stream,
     const std::vector<VideoReceiveStream*>& receive_streams) {}
 
 void BaseTest::ModifyAudioConfigs(
     AudioSendStream::Config* send_config,
     std::vector<AudioReceiveStream::Config>* receive_configs) {}
 
 void BaseTest::OnAudioStreamsCreated(
     AudioSendStream* send_stream,
@@ skipping 12 matching lines @@
 
 EndToEndTest::EndToEndTest(unsigned int timeout_ms) : BaseTest(timeout_ms) {
 }
 
 bool EndToEndTest::ShouldCreateReceivers() const {
   return true;
 }
 
 }  // namespace test
 }  // namespace webrtc