Let ViEEncoder tell VideoSendStream about reconfigurations.

webrtc/video/vie_encoder.cc

 /*
  *  Copyright (c) 2012 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/vie_encoder.h"
 
 #include <algorithm>
 #include <limits>
+#include <utility>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/modules/pacing/paced_sender.h"
 #include "webrtc/modules/video_coding/include/video_coding.h"
 #include "webrtc/modules/video_coding/include/video_coding_defines.h"
 #include "webrtc/video/overuse_frame_detector.h"
 #include "webrtc/video/send_statistics_proxy.h"
@@ skipping 335 matching lines @@
 void ViEEncoder::DeRegisterProcessThread() {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   module_process_thread_->DeRegisterModule(&video_sender_);
 }
 
 void ViEEncoder::SetSource(rtc::VideoSourceInterface<VideoFrame>* source) {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   source_proxy_->SetSource(source);
 }
 
-void ViEEncoder::SetSink(EncodedImageCallback* sink) {
+void ViEEncoder::SetSink(EncoderSink* sink) {
   encoder_queue_.PostTask([this, sink] {
     RTC_DCHECK_RUN_ON(&encoder_queue_);
     sink_ = sink;
   });
 }
 
 void ViEEncoder::SetStartBitrate(int start_bitrate_bps) {
   encoder_queue_.PostTask([this, start_bitrate_bps] {
     RTC_DCHECK_RUN_ON(&encoder_queue_);
     encoder_start_bitrate_bps_ = start_bitrate_bps;
   });
 }
 
-void ViEEncoder::ConfigureEncoder(const VideoEncoderConfig& config,
+void ViEEncoder::ConfigureEncoder(VideoEncoderConfig config,
                                   size_t max_data_payload_length) {
   VideoCodec video_codec = VideoEncoderConfigToVideoCodec(
       config, settings_.payload_name, settings_.payload_type);
-  encoder_queue_.PostTask([this, video_codec, max_data_payload_length] {
-    ConfigureEncoderInternal(video_codec, max_data_payload_length);
+  LOG(LS_INFO) << "ConfigureEncoder: " << config.ToString();
+  std::vector<VideoStream> stream = std::move(config.streams);
+  int min_transmit_bitrate = config.min_transmit_bitrate_bps;
+  encoder_queue_.PostTask([this, video_codec, max_data_payload_length, stream,
+                           min_transmit_bitrate] {
+    ConfigureEncoderInternal(video_codec, max_data_payload_length, stream,
+                             min_transmit_bitrate);
   });
   return;
 }
 
 void ViEEncoder::ConfigureEncoderInternal(const VideoCodec& video_codec,
-                                          size_t max_data_payload_length) {
+                                          size_t max_data_payload_length,
+                                          std::vector<VideoStream> stream,
+                                          int min_transmit_bitrate) {
   RTC_DCHECK_RUN_ON(&encoder_queue_);
   RTC_DCHECK_GE(encoder_start_bitrate_bps_, 0);
   RTC_DCHECK(sink_);
 
   // Setting target width and height for VPM.
   RTC_CHECK_EQ(VPM_OK,
                vp_->SetTargetResolution(video_codec.width, video_codec.height,
                                         video_codec.maxFramerate));
 
   encoder_config_ = video_codec;
@@ skipping 21 matching lines @@
         break;
       case kScreensharing:
         content_type = VideoEncoderConfig::ContentType::kScreen;
         break;
       default:
         RTC_NOTREACHED();
         break;
     }
     stats_proxy_->SetContentType(content_type);
   }
+
+  sink_->OnEncoderConfigurationChanged(stream, min_transmit_bitrate);
 }
 
 void ViEEncoder::OnFrame(const VideoFrame& video_frame) {
   RTC_DCHECK_RUNS_SERIALIZED(&incoming_frame_race_checker_);
   stats_proxy_->OnIncomingFrame(video_frame.width(), video_frame.height());
 
   VideoFrame incoming_frame = video_frame;
 
   // Local time in webrtc time base.
   int64_t current_time = clock_->TimeInMilliseconds();
@@ skipping 224 matching lines @@
     load_observer_->OnLoadUpdate(LoadObserver::kOveruse);
 }
 
 void ViEEncoder::NormalUsage() {
   RTC_DCHECK_RUN_ON(&encoder_queue_);
   if (load_observer_)
     load_observer_->OnLoadUpdate(LoadObserver::kUnderuse);
 }
 
 }  // namespace webrtc