Move all calls after SetEncoder into SetEncoder.

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.
  */
 
@@ skipping 102 matching lines @@
                                      this,
                                      qm_callback_.get())),
       stats_proxy_(stats_proxy),
       pre_encode_callback_(pre_encode_callback),
       overuse_detector_(overuse_detector),
       pacer_(pacer),
       send_payload_router_(payload_router),
       bitrate_allocator_(bitrate_allocator),
       time_of_last_frame_activity_ms_(0),
       encoder_config_(),
-      min_transmit_bitrate_kbps_(0),
+      min_transmit_bitrate_bps_(0),
       last_observed_bitrate_bps_(0),
       network_is_transmitting_(true),
       encoder_paused_(false),
       encoder_paused_and_dropped_frame_(false),
       time_last_intra_request_ms_(ssrcs.size(), -1),
       module_process_thread_(module_process_thread),
       has_received_sli_(false),
       picture_id_sli_(0),
       has_received_rpsi_(false),
       picture_id_rpsi_(0),
@@ skipping 53 matching lines @@
   }
   return 0;
 }
 
 int32_t ViEEncoder::DeRegisterExternalEncoder(uint8_t pl_type) {
   if (vcm_->RegisterExternalEncoder(NULL, pl_type) != VCM_OK) {
     return -1;
   }
   return 0;
 }
-void ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec) {
+void ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec,
+                            int min_transmit_bitrate_bps) {
   RTC_DCHECK(send_payload_router_ != NULL);
   // Setting target width and height for VPM.
   RTC_CHECK_EQ(VPM_OK,
                vp_->SetTargetResolution(video_codec.width, video_codec.height,
                                         video_codec.maxFramerate));
 
   // Cache codec before calling AddBitrateObserver (which calls OnNetworkChanged
   // that makes use of the number of simulcast streams configured).
   {
     rtc::CritScope lock(&data_cs_);
     encoder_config_ = video_codec;
     encoder_paused_ = true;
+    min_transmit_bitrate_bps_ = min_transmit_bitrate_bps;
   }
 
   // Add a bitrate observer to the allocator and update the start, max and
   // min bitrates of the bitrate controller as needed.
   int allocated_bitrate_bps = bitrate_allocator_->AddBitrateObserver(
       bitrate_observer_.get(), video_codec.minBitrate * 1000,
       video_codec.maxBitrate * 1000);
 
   webrtc::VideoCodec modified_video_codec = video_codec;
   modified_video_codec.startBitrate = allocated_bitrate_bps / 1000;
 
   size_t max_data_payload_length = send_payload_router_->MaxPayloadLength();
   bool success = vcm_->RegisterSendCodec(
                      &modified_video_codec, number_of_cores_,
                      static_cast<uint32_t>(max_data_payload_length)) == VCM_OK;
   if (!success) {
     LOG(LS_ERROR) << "Failed to configure encoder.";
     RTC_DCHECK(success);
   }
 
   send_payload_router_->SetSendingRtpModules(
       video_codec.numberOfSimulcastStreams);
 
   // Restart the media flow
   Restart();
+  if (stats_proxy_) {
+    // Clear stats for disabled layers.
+    for (size_t i = video_codec.numberOfSimulcastStreams; i < ssrcs_.size();
+         ++i) {
+      stats_proxy_->OnInactiveSsrc(ssrcs_[i]);
+    }
+    VideoEncoderConfig::ContentType content_type;
+    switch (video_codec.mode) {
+      case kRealtimeVideo:
+        content_type = VideoEncoderConfig::ContentType::kRealtimeVideo;
+        break;
+      case kScreensharing:
+        content_type = VideoEncoderConfig::ContentType::kScreen;
+        break;
+      default:
+        RTC_NOTREACHED();
+        break;
+    }
+    stats_proxy_->SetContentType(content_type);
+  }
 }
 
 int ViEEncoder::GetPaddingNeededBps() const {
   int64_t time_of_last_frame_activity_ms;
   int min_transmit_bitrate_bps;
   int bitrate_bps;
   VideoCodec send_codec;
   {
     rtc::CritScope lock(&data_cs_);
     bool send_padding = encoder_config_.numberOfSimulcastStreams > 1 ||
-                        video_suspended_ || min_transmit_bitrate_kbps_ > 0;
+                        video_suspended_ || min_transmit_bitrate_bps_ > 0;
     if (!send_padding)
       return 0;
     time_of_last_frame_activity_ms = time_of_last_frame_activity_ms_;
-    min_transmit_bitrate_bps = 1000 * min_transmit_bitrate_kbps_;
+    min_transmit_bitrate_bps = min_transmit_bitrate_bps_;
     bitrate_bps = last_observed_bitrate_bps_;
     send_codec = encoder_config_;
   }
 
   bool video_is_suspended = vcm_->VideoSuspended();
 
   // Find the max amount of padding we can allow ourselves to send at this
   // point, based on which streams are currently active and what our current
   // available bandwidth is.
   int pad_up_to_bitrate_bps = 0;
@@ skipping 221 matching lines @@
         return;
       }
       time_last_intra_request_ms_[i] = now_ms;
     }
     vcm_->IntraFrameRequest(static_cast<int>(i));
     return;
   }
   RTC_NOTREACHED() << "Should not receive keyframe requests on unknown SSRCs.";
 }
 
-void ViEEncoder::SetMinTransmitBitrate(int min_transmit_bitrate_kbps) {
-  assert(min_transmit_bitrate_kbps >= 0);
-  rtc::CritScope lock(&data_cs_);
-  min_transmit_bitrate_kbps_ = min_transmit_bitrate_kbps;
-}
-
 // Called from ViEBitrateObserver.
 void ViEEncoder::OnNetworkChanged(uint32_t bitrate_bps,
                                   uint8_t fraction_lost,
                                   int64_t round_trip_time_ms) {
   LOG(LS_VERBOSE) << "OnNetworkChanged, bitrate" << bitrate_bps
                   << " packet loss " << static_cast<int>(fraction_lost)
                   << " rtt " << round_trip_time_ms;
   RTC_DCHECK(send_payload_router_ != NULL);
   vcm_->SetChannelParameters(bitrate_bps, fraction_lost, round_trip_time_ms);
   bool video_is_suspended = vcm_->VideoSuspended();
@@ skipping 44 matching lines @@
     const uint32_t width,
     const uint32_t height) {
   return vp_->SetTargetResolution(width, height, frame_rate);
 }
 
 void QMVideoSettingsCallback::SetTargetFramerate(int frame_rate) {
   vp_->SetTargetFramerate(frame_rate);
 }
 
 }  // namespace webrtc