Remove callback_cs_ in ViEEncoder.

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 86 matching lines @@
                                 uint8_t fraction_lost,
                                 int64_t rtt) {
     owner_->OnNetworkChanged(bitrate_bps, fraction_lost, rtt);
   }
  private:
   ViEEncoder* owner_;
 };
 
 ViEEncoder::ViEEncoder(int32_t channel_id,
                        uint32_t number_of_cores,
-                       ProcessThread& module_process_thread,
+                       ProcessThread* module_process_thread,
+                       SendStatisticsProxy* stats_proxy,
+                       I420FrameCallback* pre_encode_callback,
                        PacedSender* pacer,
                        BitrateAllocator* bitrate_allocator)
     : channel_id_(channel_id),
       number_of_cores_(number_of_cores),
       vpm_(VideoProcessingModule::Create()),
       qm_callback_(new QMVideoSettingsCallback(vpm_.get())),
       vcm_(VideoCodingModule::Create(Clock::GetRealTimeClock(),
                                      this,
                                      qm_callback_.get())),
       send_payload_router_(NULL),
-      callback_cs_(CriticalSectionWrapper::CreateCriticalSection()),
       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),
       simulcast_enabled_(false),
       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),
       fec_enabled_(false),
       nack_enabled_(false),
-      codec_observer_(NULL),
       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),
-      pre_encode_callback_(NULL),
-      start_ms_(Clock::GetRealTimeClock()->TimeInMilliseconds()),
-      send_statistics_proxy_(NULL) {
+      start_ms_(Clock::GetRealTimeClock()->TimeInMilliseconds()) {
   bitrate_observer_.reset(new ViEBitrateObserver(this));
 }
 
 bool ViEEncoder::Init() {
   vpm_->EnableTemporalDecimation(true);
 
   // Enable/disable content analysis: off by default for now.
   vpm_->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());
+  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());
+  module_process_thread_->DeRegisterModule(vcm_.get());
+  module_process_thread_->DeRegisterModule(vpm_.get());
 }
 
 ViEEncoder::~ViEEncoder() {
   UpdateHistograms();
 }
 
 void ViEEncoder::UpdateHistograms() {
   int64_t elapsed_sec =
       (Clock::GetRealTimeClock()->TimeInMilliseconds() - start_ms_) / 1000;
   if (elapsed_sec < metrics::kMinRunTimeInSeconds) {
@@ skipping 257 matching lines @@
       return;
     }
     if (ret != VPM_OK) {
       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;
-  {
-    CriticalSectionScoped cs(callback_cs_.get());
-    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);
+  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);
   }
 
   // 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;
 
 #ifdef VIDEOCODEC_VP8
   if (vcm_->SendCodec() == webrtc::kVideoCodecVP8) {
     webrtc::CodecSpecificInfo codec_specific_info;
@@ skipping 98 matching lines @@
     vcm_->EnableFrameDropper(false);
     vpm_->EnableTemporalDecimation(false);
   } else {
     // Real-time mode - enable frame droppers.
     vpm_->EnableTemporalDecimation(true);
     vcm_->EnableFrameDropper(true);
   }
 }
 
 void ViEEncoder::OnSetRates(uint32_t bitrate_bps, int framerate) {
-  CriticalSectionScoped cs(callback_cs_.get());
-  if (send_statistics_proxy_ != nullptr)
-    send_statistics_proxy_->OnSetRates(bitrate_bps, framerate);
+  if (stats_proxy_)
+    stats_proxy_->OnSetRates(bitrate_bps, framerate);
 }
 
 int32_t ViEEncoder::SendData(
     const uint8_t payload_type,
     const EncodedImage& encoded_image,
     const webrtc::RTPFragmentationHeader& fragmentation_header,
     const RTPVideoHeader* rtp_video_hdr) {
   RTC_DCHECK(send_payload_router_ != NULL);
 
   {
     CriticalSectionScoped cs(data_cs_.get());
     time_of_last_frame_activity_ms_ = TickTime::MillisecondTimestamp();
   }
 
-  {
-    CriticalSectionScoped cs(callback_cs_.get());
-    if (send_statistics_proxy_ != NULL)
-      send_statistics_proxy_->OnSendEncodedImage(encoded_image, rtp_video_hdr);
-  }
+  if (stats_proxy_ != NULL)
+    stats_proxy_->OnSendEncodedImage(encoded_image, rtp_video_hdr);
 
   return send_payload_router_->RoutePayload(
       VCMEncodedFrame::ConvertFrameType(encoded_image._frameType), payload_type,
       encoded_image._timeStamp, encoded_image.capture_time_ms_,
       encoded_image._buffer, encoded_image._length, &fragmentation_header,
       rtp_video_hdr) ? 0 : -1;
 }
 
 int32_t ViEEncoder::SendStatistics(const uint32_t bit_rate,
                                    const uint32_t frame_rate) {
-  CriticalSectionScoped cs(callback_cs_.get());
-  if (codec_observer_) {
-    codec_observer_->OutgoingRate(channel_id_, frame_rate, bit_rate);
-  }
+  if (stats_proxy_)
+    stats_proxy_->OnOutgoingRate(frame_rate, bit_rate);
   return 0;
 }
 
-int32_t ViEEncoder::RegisterCodecObserver(ViEEncoderObserver* observer) {
-  CriticalSectionScoped cs(callback_cs_.get());
-  if (observer && codec_observer_) {
-    LOG_F(LS_ERROR) << "Observer already set.";
-    return -1;
-  }
-  codec_observer_ = observer;
-  return 0;
-}
-
 void ViEEncoder::OnReceivedSLI(uint32_t /*ssrc*/,
                                uint8_t picture_id) {
   CriticalSectionScoped cs(data_cs_.get());
   picture_id_sli_ = picture_id;
   has_received_sli_ = true;
 }
 
 void ViEEncoder::OnReceivedRPSI(uint32_t /*ssrc*/,
                                 uint64_t picture_id) {
   CriticalSectionScoped cs(data_cs_.get());
@@ skipping 97 matching lines @@
   std::vector<uint32_t> stream_bitrates = AllocateStreamBitrates(
       bitrate_bps, stream_configs, send_codec.numberOfSimulcastStreams);
   send_payload_router_->SetTargetSendBitrates(stream_bitrates);
 
   {
     CriticalSectionScoped cs(data_cs_.get());
     last_observed_bitrate_bps_ = bitrate_bps;
     if (video_suspended_ == video_is_suspended)
       return;
     video_suspended_ = video_is_suspended;
+    LOG(LS_INFO) << "Video suspended " << video_is_suspended
+                 << " for channel " << channel_id_;
   }
   // Video suspend-state changed, inform codec observer.
-  CriticalSectionScoped crit(callback_cs_.get());
-  if (codec_observer_) {
-    LOG(LS_INFO) << "Video suspended " << video_is_suspended
-                 << " for channel " << channel_id_;
-    codec_observer_->SuspendChange(channel_id_, video_is_suspended);
-  }
+  if (stats_proxy_)
+    stats_proxy_->OnSuspendChange(video_is_suspended);
 }
 
 void ViEEncoder::SuspendBelowMinBitrate() {
   vcm_->SuspendBelowMinBitrate();
   bitrate_allocator_->EnforceMinBitrate(false);
 }
 
-void ViEEncoder::RegisterPreEncodeCallback(
-    I420FrameCallback* pre_encode_callback) {
-  CriticalSectionScoped cs(callback_cs_.get());
-  pre_encode_callback_ = pre_encode_callback;
-}
-
 void ViEEncoder::RegisterPostEncodeImageCallback(
       EncodedImageCallback* post_encode_callback) {
   vcm_->RegisterPostEncodeImageCallback(post_encode_callback);
 }
 
-void ViEEncoder::RegisterSendStatisticsProxy(
-    SendStatisticsProxy* send_statistics_proxy) {
-  CriticalSectionScoped cs(callback_cs_.get());
-  send_statistics_proxy_ = send_statistics_proxy;
-}
-
 QMVideoSettingsCallback::QMVideoSettingsCallback(VideoProcessingModule* vpm)
     : vpm_(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);
 }
 
 void QMVideoSettingsCallback::SetTargetFramerate(int frame_rate) {
   vpm_->SetTargetFramerate(frame_rate);
 }
 
 }  // namespace webrtc