Reland of Deprecate VCMPacketizationCallback::SendData and use EncodedImageCallback instead.

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 67 matching lines @@
   VideoProcessing* vp_;
 };
 
 ViEEncoder::ViEEncoder(uint32_t number_of_cores,
                        const std::vector<uint32_t>& ssrcs,
                        ProcessThread* module_process_thread,
                        SendStatisticsProxy* stats_proxy,
                        rtc::VideoSinkInterface<VideoFrame>* pre_encode_callback,
                        OveruseFrameDetector* overuse_detector,
                        PacedSender* pacer,
-                       PayloadRouter* payload_router)
+                       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())),
       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());
 }
 
 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) {
     return false;
   }
   if (vcm_->RegisterSendStatisticsCallback(this) != 0) {
     return false;
   }
   return true;
 }
 
 VideoCodingModule* ViEEncoder::vcm() const {
@@ skipping 262 matching lines @@
     protection_mode = nack ? kProtectionNack : kProtectionNone;
   }
   vcm_->SetVideoProtection(protection_mode, true);
 }
 
 void ViEEncoder::OnSetRates(uint32_t bitrate_bps, int framerate) {
   if (stats_proxy_)
     stats_proxy_->OnSetRates(bitrate_bps, framerate);
 }
 
-int32_t ViEEncoder::SendData(const uint8_t payload_type,
-                             const EncodedImage& encoded_image,
-                             const RTPFragmentationHeader* fragmentation_header,
-                             const RTPVideoHeader* rtp_video_hdr) {
+void ViEEncoder::OnEncoderImplementationName(const char* implementation_name) {
+  if (stats_proxy_)
+    stats_proxy_->OnEncoderImplementationName(implementation_name);
+}
+
+int32_t ViEEncoder::Encoded(const EncodedImage& encoded_image,
+                            const CodecSpecificInfo* codec_specific_info,
+                            const RTPFragmentationHeader* fragmentation) {
   RTC_DCHECK(send_payload_router_);
 
   {
     rtc::CritScope lock(&data_cs_);
     time_of_last_frame_activity_ms_ = TickTime::MillisecondTimestamp();
   }
 
-  if (stats_proxy_)
-    stats_proxy_->OnSendEncodedImage(encoded_image, rtp_video_hdr);
+  if (post_encode_callback_) {
+    post_encode_callback_->Encoded(encoded_image, codec_specific_info,
+                                   fragmentation);
+  }
 
-  bool success = send_payload_router_->RoutePayload(
-      encoded_image._frameType, payload_type, encoded_image._timeStamp,
-      encoded_image.capture_time_ms_, encoded_image._buffer,
-      encoded_image._length, fragmentation_header, rtp_video_hdr);
+  if (stats_proxy_) {
+    stats_proxy_->OnSendEncodedImage(encoded_image, codec_specific_info);
+  }
+  int success = send_payload_router_->Encoded(
+      encoded_image, codec_specific_info, fragmentation);
   overuse_detector_->FrameSent(encoded_image._timeStamp);
 
   if (kEnableFrameRecording) {
-    int layer = rtp_video_hdr->simulcastIdx;
+    int layer = codec_specific_info->codecType == kVideoCodecVP8
+                    ? codec_specific_info->codecSpecific.VP8.simulcastIdx
+                    : 0;
     IvfFileWriter* file_writer;
     {
       rtc::CritScope lock(&data_cs_);
       if (file_writers_[layer] == nullptr) {
         std::ostringstream oss;
         oss << "send_bitstream_ssrc";
         for (uint32_t ssrc : ssrcs_)
           oss << "_" << ssrc;
         oss << "_layer" << layer << ".ivf";
         file_writers_[layer] =
-            IvfFileWriter::Open(oss.str(), rtp_video_hdr->codec);
+            IvfFileWriter::Open(oss.str(), codec_specific_info->codecType);
       }
       file_writer = file_writers_[layer].get();
     }
     if (file_writer) {
       bool ok = file_writer->WriteFrame(encoded_image);
       RTC_DCHECK(ok);
     }
   }
 
-  return success ? 0 : -1;
-}
-
-void ViEEncoder::OnEncoderImplementationName(
-    const char* implementation_name) {
-  if (stats_proxy_)
-    stats_proxy_->OnEncoderImplementationName(implementation_name);
+  return success;
 }
 
 int32_t ViEEncoder::SendStatistics(const uint32_t bit_rate,
                                    const uint32_t frame_rate) {
   if (stats_proxy_)
     stats_proxy_->OnOutgoingRate(frame_rate, bit_rate);
   return 0;
 }
 
 void ViEEncoder::OnReceivedSLI(uint32_t /*ssrc*/,
@@ skipping 59 matching lines @@
 
   if (!video_suspension_changed)
     return;
   // Video suspend-state changed, inform codec observer.
   LOG(LS_INFO) << "Video suspend state changed " << video_is_suspended
                << " for ssrc " << ssrcs_[0];
   if (stats_proxy_)
     stats_proxy_->OnSuspendChange(video_is_suspended);
 }
 
-void ViEEncoder::RegisterPostEncodeImageCallback(
-      EncodedImageCallback* post_encode_callback) {
-  vcm_->RegisterPostEncodeImageCallback(post_encode_callback);
-}
-
 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 vp_->SetTargetResolution(width, height, frame_rate);
 }
 
 void QMVideoSettingsCallback::SetTargetFramerate(int frame_rate) {
   vp_->SetTargetFramerate(frame_rate);
 }
 
 }  // namespace webrtc