Revert of Let ViEEncoder handle resolution changes.

webrtc/video/video_send_stream.cc

 /*
  *  Copyright (c) 2013 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/video/video_send_stream.h"
@@ skipping 503 matching lines @@
       thread_sync_event_(false /* manual_reset */, false),
       stats_proxy_(Clock::GetRealTimeClock(),
                    config,
                    encoder_config.content_type),
       config_(std::move(config)) {
   vie_encoder_.reset(
       new ViEEncoder(num_cpu_cores, &stats_proxy_, config_.encoder_settings,
                      config_.pre_encode_callback, config_.overuse_callback,
                      config_.post_encode_callback));
 
+  // TODO(perkj): Remove vector<VideoStreams> from VideoEncoderConfig and
+  // replace with max_bitrate. The VideoStream should be created by ViEEncoder
+  // when the video resolution is known.
+  int initial_max_encoder_bitrate = 0;
+  for (const auto& stream : encoder_config.streams)
+    initial_max_encoder_bitrate += stream.max_bitrate_bps;
+
   worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(new ConstructionTask(
       &send_stream_, &thread_sync_event_, &stats_proxy_, vie_encoder_.get(),
       module_process_thread, call_stats, congestion_controller,
       bitrate_allocator, send_delay_stats, remb, event_log, &config_,
-      encoder_config.max_bitrate_bps, suspended_ssrcs)));
+      initial_max_encoder_bitrate, suspended_ssrcs)));
 
   // Wait for ConstructionTask to complete so that |send_stream_| can be used.
   // |module_process_thread| must be registered and deregistered on the thread
   // it was created on.
   thread_sync_event_.Wait(rtc::Event::kForever);
   send_stream_->RegisterProcessThread(module_process_thread);
 
   vie_encoder_->RegisterProcessThread(module_process_thread);
 
   ReconfigureVideoEncoder(std::move(encoder_config));
@@ skipping 26 matching lines @@
   worker_queue_->PostTask([send_stream] { send_stream->Stop(); });
 }
 
 void VideoSendStream::SetSource(
     rtc::VideoSourceInterface<webrtc::VideoFrame>* source) {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   vie_encoder_->SetSource(source);
 }
 
 void VideoSendStream::ReconfigureVideoEncoder(VideoEncoderConfig config) {
-  // TODO(perkj): Some test cases in VideoSendStreamTest call
-  // ReconfigureVideoEncoder from the network thread.
-  // RTC_DCHECK_RUN_ON(&thread_checker_);
+  // ReconfigureVideoEncoder will be called on the thread that deliverers video
+  // frames. We must change the encoder settings immediately so that
+  // the codec settings matches the next frame.
+  // TODO(perkj): Move logic for reconfiguration the encoder due to frame size
+  // change from WebRtcVideoChannel2::WebRtcVideoSendStream::OnFrame to
+  // be internally handled by ViEEncoder.
   vie_encoder_->ConfigureEncoder(std::move(config),
                                  config_.rtp.max_packet_size);
 }
 
 VideoSendStream::Stats VideoSendStream::GetStats() {
   // TODO(perkj, solenberg): Some test cases in EndToEndTest call GetStats from
   // a network thread. See comment in Call::GetStats().
   // RTC_DCHECK_RUN_ON(&thread_checker_);
   return stats_proxy_.GetStats();
 }
@@ skipping 510 matching lines @@
                           &module_nack_rate);
     *sent_video_rate_bps += module_video_rate;
     *sent_nack_rate_bps += module_nack_rate;
     *sent_fec_rate_bps += module_fec_rate;
   }
   return 0;
 }
 
 }  // namespace internal
 }  // namespace webrtc