Use vcm::VideoSender in ViEEncoder.

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 73 matching lines @@
                        SendStatisticsProxy* stats_proxy,
                        rtc::VideoSinkInterface<VideoFrame>* pre_encode_callback,
                        OveruseFrameDetector* overuse_detector,
                        PacedSender* pacer,
                        PayloadRouter* payload_router,
                        EncodedImageCallback* post_encode_callback)
     : number_of_cores_(number_of_cores),
       ssrcs_(ssrcs),
       vp_(VideoProcessing::Create()),
       qm_callback_(new QMVideoSettingsCallback(vp_.get())),
-      vcm_(VideoCodingModule::Create(Clock::GetRealTimeClock(),
-                                     this,
-                                     qm_callback_.get())),
+      video_sender_(Clock::GetRealTimeClock(), this, 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),
       post_encode_callback_(post_encode_callback),
       time_of_last_frame_activity_ms_(0),
       encoder_config_(),
       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),
       video_suspended_(false) {
-  module_process_thread_->RegisterModule(vcm_.get());
+  module_process_thread_->RegisterModule(&video_sender_);
 }
 
 bool ViEEncoder::Init() {
   vp_->EnableTemporalDecimation(true);
 
   // Enable/disable content analysis: off by default for now.
   vp_->EnableContentAnalysis(false);
 
-  vcm_->RegisterPostEncodeImageCallback(this);
-
   // TODO(perkj): Remove  |RegisterTransportCallback| as soon as we don't use
   // VCMPacketizationCallback::OnEncoderImplementationName.
-  if (vcm_->RegisterTransportCallback(this) != 0) {
+  if (video_sender_.RegisterTransportCallback(this) != 0) {
     return false;
   }
-  if (vcm_->RegisterSendStatisticsCallback(this) != 0) {
+  if (video_sender_.RegisterSendStatisticsCallback(this) != 0) {
     return false;
   }
   return true;
 }
 
-VideoCodingModule* ViEEncoder::vcm() const {
-  return vcm_.get();
+vcm::VideoSender* ViEEncoder::video_sender() {
+  return &video_sender_;
 }
 
 ViEEncoder::~ViEEncoder() {
-  module_process_thread_->DeRegisterModule(vcm_.get());
+  module_process_thread_->DeRegisterModule(&video_sender_);
 }
 
 void ViEEncoder::SetNetworkTransmissionState(bool is_transmitting) {
   {
     rtc::CritScope lock(&data_cs_);
     network_is_transmitting_ = is_transmitting;
   }
 }
 
 void ViEEncoder::Pause() {
   rtc::CritScope lock(&data_cs_);
   encoder_paused_ = true;
 }
 
 void ViEEncoder::Restart() {
   rtc::CritScope lock(&data_cs_);
   encoder_paused_ = false;
 }
 
 int32_t ViEEncoder::RegisterExternalEncoder(webrtc::VideoEncoder* encoder,
                                             uint8_t pl_type,
                                             bool internal_source) {
-  if (vcm_->RegisterExternalEncoder(encoder, pl_type, internal_source) !=
-      VCM_OK) {
-    return -1;
-  }
+  video_sender_.RegisterExternalEncoder(encoder, pl_type, internal_source);
   return 0;
 }
 
 int32_t ViEEncoder::DeRegisterExternalEncoder(uint8_t pl_type) {
-  if (vcm_->RegisterExternalEncoder(nullptr, pl_type) != VCM_OK) {
-    return -1;
-  }
+  video_sender_.RegisterExternalEncoder(nullptr, pl_type, false);
   return 0;
 }
 void ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec,
                             int min_transmit_bitrate_bps) {
   RTC_DCHECK(send_payload_router_);
   // 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 OnBitrateUpdated
   // 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;
   }
 
   size_t max_data_payload_length = send_payload_router_->MaxPayloadLength();
-  bool success = vcm_->RegisterSendCodec(
+  bool success = video_sender_.RegisterSendCodec(
                      &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);
 
@@ skipping 32 matching lines @@
     bool send_padding = encoder_config_.numberOfSimulcastStreams > 1 ||
                         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 = min_transmit_bitrate_bps_;
     bitrate_bps = last_observed_bitrate_bps_;
     send_codec = encoder_config_;
   }
 
-  bool video_is_suspended = vcm_->VideoSuspended();
+  bool video_is_suspended = video_sender_.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;
   if (send_codec.numberOfSimulcastStreams == 0) {
     pad_up_to_bitrate_bps = send_codec.minBitrate * 1000;
   } else {
     SimulcastStream* stream_configs = send_codec.simulcastStream;
     pad_up_to_bitrate_bps =
@@ skipping 101 matching lines @@
       codec_specific_info.codecSpecific.VP8.hasReceivedSLI =
           has_received_sli_;
       codec_specific_info.codecSpecific.VP8.pictureIdRPSI =
           picture_id_rpsi_;
       codec_specific_info.codecSpecific.VP8.pictureIdSLI  =
           picture_id_sli_;
       has_received_sli_ = false;
       has_received_rpsi_ = false;
     }
 
-    vcm_->AddVideoFrame(*frame_to_send, vp_->GetContentMetrics(),
-                        &codec_specific_info);
+    video_sender_.AddVideoFrame(*frame_to_send, vp_->GetContentMetrics(),
+                                &codec_specific_info);
     return;
   }
-  vcm_->AddVideoFrame(*frame_to_send);
+  video_sender_.AddVideoFrame(*frame_to_send, nullptr, nullptr);
 }
 
 void ViEEncoder::SendKeyFrame() {
-  vcm_->IntraFrameRequest(0);
-}
-
-uint32_t ViEEncoder::LastObservedBitrateBps() const {
-  rtc::CritScope lock(&data_cs_);
-  return last_observed_bitrate_bps_;
-}
-
-int ViEEncoder::CodecTargetBitrate(uint32_t* bitrate) const {
-  if (vcm_->Bitrate(bitrate) != 0)
-    return -1;
-  return 0;
+  video_sender_.IntraFrameRequest(0);
 }
 
 void ViEEncoder::SetProtectionMethod(bool nack, bool fec) {
   // Set Video Protection for VCM.
   VCMVideoProtection protection_mode;
   if (fec) {
     protection_mode =
         nack ? webrtc::kProtectionNackFEC : kProtectionFEC;
   } else {
     protection_mode = nack ? kProtectionNack : kProtectionNone;
   }
-  vcm_->SetVideoProtection(protection_mode, true);
+  video_sender_.SetVideoProtection(protection_mode);
 }
 
 void ViEEncoder::OnSetRates(uint32_t bitrate_bps, int framerate) {
   if (stats_proxy_)
     stats_proxy_->OnSetRates(bitrate_bps, framerate);
 }
 
 void ViEEncoder::OnEncoderImplementationName(const char* implementation_name) {
   if (stats_proxy_)
     stats_proxy_->OnEncoderImplementationName(implementation_name);
@@ skipping 78 matching lines @@
       continue;
     int64_t now_ms = TickTime::MillisecondTimestamp();
     {
       rtc::CritScope lock(&data_cs_);
       if (time_last_intra_request_ms_[i] + kMinKeyFrameRequestIntervalMs >
           now_ms) {
         return;
       }
       time_last_intra_request_ms_[i] = now_ms;
     }
-    vcm_->IntraFrameRequest(static_cast<int>(i));
+    video_sender_.IntraFrameRequest(static_cast<int>(i));
     return;
   }
   RTC_NOTREACHED() << "Should not receive keyframe requests on unknown SSRCs.";
 }
 
 void ViEEncoder::OnBitrateUpdated(uint32_t bitrate_bps,
                                   uint8_t fraction_lost,
                                   int64_t round_trip_time_ms) {
   LOG(LS_VERBOSE) << "OnBitrateUpdated, bitrate" << bitrate_bps
                   << " packet loss " << static_cast<int>(fraction_lost)
                   << " rtt " << round_trip_time_ms;
   RTC_DCHECK(send_payload_router_);
-  vcm_->SetChannelParameters(bitrate_bps, fraction_lost, round_trip_time_ms);
-  bool video_is_suspended = vcm_->VideoSuspended();
+  video_sender_.SetChannelParameters(bitrate_bps, fraction_lost,
+                                     round_trip_time_ms);
+  bool video_is_suspended = video_sender_.VideoSuspended();
   bool video_suspension_changed;
   VideoCodec send_codec;
   {
     rtc::CritScope lock(&data_cs_);
     last_observed_bitrate_bps_ = bitrate_bps;
     video_suspension_changed = video_suspended_ != video_is_suspended;
     video_suspended_ = video_is_suspended;
     send_codec = encoder_config_;
   }
 
@@ skipping 24 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