Initial VideoProcessing refactoring.

webrtc/video_engine/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 54 matching lines @@
     } else {
       stream_bitrates[i] = stream_configs[i].maxBitrate * 1000;
     }
     bitrate_remainder -= stream_bitrates[i];
   }
   return stream_bitrates;
 }
 
 class QMVideoSettingsCallback : public VCMQMSettingsCallback {
  public:
-  explicit QMVideoSettingsCallback(VideoProcessingModule* vpm);
+  explicit QMVideoSettingsCallback(VideoProcessing* vpm);
 
   ~QMVideoSettingsCallback();
 
   // Update VPM with QM (quality modes: frame size & frame rate) settings.
   int32_t SetVideoQMSettings(const uint32_t frame_rate,
                              const uint32_t width,
                              const uint32_t height);
 
   // Update target frame rate.
   void SetTargetFramerate(int frame_rate);
 
  private:
-  VideoProcessingModule* vpm_;
+  VideoProcessing* vp_;
 };
 
 class ViEBitrateObserver : public BitrateObserver {
  public:
   explicit ViEBitrateObserver(ViEEncoder* owner)
       : owner_(owner) {
   }
   virtual ~ViEBitrateObserver() {}
   // Implements BitrateObserver.
   virtual void OnNetworkChanged(uint32_t bitrate_bps,
                                 uint8_t fraction_lost,
                                 int64_t rtt) {
     owner_->OnNetworkChanged(bitrate_bps, fraction_lost, rtt);
   }
  private:
   ViEEncoder* owner_;
 };
 
 ViEEncoder::ViEEncoder(uint32_t number_of_cores,
                        ProcessThread* module_process_thread,
                        SendStatisticsProxy* stats_proxy,
                        I420FrameCallback* pre_encode_callback,
                        PacedSender* pacer,
                        BitrateAllocator* bitrate_allocator)
     : number_of_cores_(number_of_cores),
-      vpm_(VideoProcessingModule::Create()),
-      qm_callback_(new QMVideoSettingsCallback(vpm_.get())),
+      vp_(VideoProcessing::Create()),
+      qm_callback_(new QMVideoSettingsCallback(vp_.get())),
       vcm_(VideoCodingModule::Create(Clock::GetRealTimeClock(),
                                      this,
                                      qm_callback_.get())),
       send_payload_router_(NULL),
       data_cs_(CriticalSectionWrapper::CreateCriticalSection()),
       stats_proxy_(stats_proxy),
       pre_encode_callback_(pre_encode_callback),
       pacer_(pacer),
       bitrate_allocator_(bitrate_allocator),
       time_of_last_frame_activity_ms_(0),
       encoder_config_(),
       min_transmit_bitrate_kbps_(0),
       last_observed_bitrate_bps_(0),
       target_delay_ms_(0),
       network_is_transmitting_(true),
       encoder_paused_(false),
       encoder_paused_and_dropped_frame_(false),
       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) {
   bitrate_observer_.reset(new ViEBitrateObserver(this));
 }
 
 bool ViEEncoder::Init() {
-  vpm_->EnableTemporalDecimation(true);
+  vp_->EnableTemporalDecimation(true);
 
   // Enable/disable content analysis: off by default for now.
-  vpm_->EnableContentAnalysis(false);
+  vp_->EnableContentAnalysis(false);
 
   if (vcm_->RegisterTransportCallback(this) != 0) {
     return false;
   }
   if (vcm_->RegisterSendStatisticsCallback(this) != 0) {
     return false;
   }
   return true;
 }
 
 void ViEEncoder::StartThreadsAndSetSharedMembers(
     rtc::scoped_refptr<PayloadRouter> send_payload_router,
     VCMProtectionCallback* vcm_protection_callback) {
   RTC_DCHECK(send_payload_router_ == NULL);
 
   send_payload_router_ = send_payload_router;
   vcm_->RegisterProtectionCallback(vcm_protection_callback);
   module_process_thread_->RegisterModule(vcm_.get());
 }
 
 void ViEEncoder::StopThreadsAndRemoveSharedMembers() {
   if (bitrate_allocator_)
     bitrate_allocator_->RemoveBitrateObserver(bitrate_observer_.get());
   module_process_thread_->DeRegisterModule(vcm_.get());
-  module_process_thread_->DeRegisterModule(vpm_.get());
 }
 
 ViEEncoder::~ViEEncoder() {
 }
 
 void ViEEncoder::SetNetworkTransmissionState(bool is_transmitting) {
   {
     CriticalSectionScoped cs(data_cs_.get());
     network_is_transmitting_ = is_transmitting;
   }
@@ skipping 22 matching lines @@
 int32_t ViEEncoder::DeRegisterExternalEncoder(uint8_t pl_type) {
   if (vcm_->RegisterExternalEncoder(NULL, pl_type) != VCM_OK) {
     return -1;
   }
   return 0;
 }
 
 int32_t ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec) {
   RTC_DCHECK(send_payload_router_ != NULL);
   // Setting target width and height for VPM.
-  if (vpm_->SetTargetResolution(video_codec.width, video_codec.height,
-                                video_codec.maxFramerate) != VPM_OK) {
+  if (vp_->SetTargetResolution(video_codec.width, video_codec.height,
+                               video_codec.maxFramerate) != VPM_OK) {
     return -1;
   }
 
   // Cache codec before calling AddBitrateObserver (which calls OnNetworkChanged
   // that makes use of the number of simulcast streams configured).
   {
     CriticalSectionScoped cs(data_cs_.get());
     encoder_config_ = video_codec;
   }
 
@@ skipping 125 matching lines @@
     if (EncoderPaused()) {
       TraceFrameDropStart();
       return;
     }
     TraceFrameDropEnd();
     codec_type = encoder_config_.codecType;
   }
 
   TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", video_frame.render_time_ms(),
                           "Encode");
-  VideoFrame* decimated_frame = NULL;
+  const VideoFrame* frame_to_send = &video_frame;
   // TODO(wuchengli): support texture frames.
   if (video_frame.native_handle() == NULL) {
     // Pass frame via preprocessor.
-    const int ret = vpm_->PreprocessFrame(video_frame, &decimated_frame);
-    if (ret == 1) {
-      // Drop this frame.
-      return;
-    }
-    if (ret != VPM_OK) {
+    frame_to_send = vp_->PreprocessFrame(video_frame);
+    if (!frame_to_send) {
+      // Drop this frame, or there was an error processing it.
       return;
     }
   }
 
   // If we haven't resampled the frame and we have a FrameCallback, we need to
   // make a deep copy of |video_frame|.
   VideoFrame copied_frame;
   if (pre_encode_callback_) {
-    // If the frame was not resampled or scaled => use copy of original.
-    if (decimated_frame == NULL) {
-      copied_frame.CopyFrame(video_frame);
-      decimated_frame = &copied_frame;
-    }
-    pre_encode_callback_->FrameCallback(decimated_frame);
+    copied_frame.CopyFrame(*frame_to_send);
+    pre_encode_callback_->FrameCallback(&copied_frame);
+    frame_to_send = &copied_frame;
   }
 
-  // If the frame was not resampled, scaled, or touched by FrameCallback => use
-  // original. The frame is const from here.
-  const VideoFrame* output_frame =
-      (decimated_frame != NULL) ? decimated_frame : &video_frame;
-
   if (codec_type == webrtc::kVideoCodecVP8) {
     webrtc::CodecSpecificInfo codec_specific_info;
     codec_specific_info.codecType = webrtc::kVideoCodecVP8;
     {
       CriticalSectionScoped cs(data_cs_.get());
       codec_specific_info.codecSpecific.VP8.hasReceivedRPSI =
           has_received_rpsi_;
       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(*output_frame, vpm_->ContentMetrics(),
+    vcm_->AddVideoFrame(*frame_to_send, vp_->GetContentMetrics(),
                         &codec_specific_info);
     return;
   }
-  vcm_->AddVideoFrame(*output_frame);
+  vcm_->AddVideoFrame(*frame_to_send);
 }
 
 int ViEEncoder::SendKeyFrame() {
   return vcm_->IntraFrameRequest(0);
 }
 
 uint32_t ViEEncoder::LastObservedBitrateBps() const {
   CriticalSectionScoped cs(data_cs_.get());
   return last_observed_bitrate_bps_;
 }
@@ skipping 17 matching lines @@
 }
 
 void ViEEncoder::SetSenderBufferingMode(int target_delay_ms) {
   {
     CriticalSectionScoped cs(data_cs_.get());
     target_delay_ms_ = target_delay_ms;
   }
   if (target_delay_ms > 0) {
     // Disable external frame-droppers.
     vcm_->EnableFrameDropper(false);
-    vpm_->EnableTemporalDecimation(false);
+    vp_->EnableTemporalDecimation(false);
   } else {
     // Real-time mode - enable frame droppers.
-    vpm_->EnableTemporalDecimation(true);
+    vp_->EnableTemporalDecimation(true);
     vcm_->EnableFrameDropper(true);
   }
 }
 
 void ViEEncoder::OnSetRates(uint32_t bitrate_bps, int framerate) {
   if (stats_proxy_)
     stats_proxy_->OnSetRates(bitrate_bps, framerate);
 }
 
 int32_t ViEEncoder::SendData(
@@ skipping 147 matching lines @@
 void ViEEncoder::SuspendBelowMinBitrate() {
   vcm_->SuspendBelowMinBitrate();
   bitrate_allocator_->EnforceMinBitrate(false);
 }
 
 void ViEEncoder::RegisterPostEncodeImageCallback(
       EncodedImageCallback* post_encode_callback) {
   vcm_->RegisterPostEncodeImageCallback(post_encode_callback);
 }
 
-QMVideoSettingsCallback::QMVideoSettingsCallback(VideoProcessingModule* vpm)
-    : vpm_(vpm) {
+QMVideoSettingsCallback::QMVideoSettingsCallback(VideoProcessing* vpm)
+    : vp_(vpm) {
 }
 
 QMVideoSettingsCallback::~QMVideoSettingsCallback() {
 }
 
 int32_t QMVideoSettingsCallback::SetVideoQMSettings(
     const uint32_t frame_rate,
     const uint32_t width,
     const uint32_t height) {
-  return vpm_->SetTargetResolution(width, height, frame_rate);
+  return vp_->SetTargetResolution(width, height, frame_rate);
 }
 
 void QMVideoSettingsCallback::SetTargetFramerate(int frame_rate) {
-  vpm_->SetTargetFramerate(frame_rate);
+  vp_->SetTargetFramerate(frame_rate);
 }
 
 }  // namespace webrtc