Make VCMEncodedFrameCallback const.

webrtc/modules/video_coding/main/source/generic_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 70 matching lines @@
       rtp->simulcastIdx = info->codecSpecific.generic.simulcast_idx;
       return;
     default:
       return;
   }
 }
 }  // namespace
 
 //#define DEBUG_ENCODER_BIT_STREAM
 
-VCMGenericEncoder::VCMGenericEncoder(VideoEncoder* encoder,
-                                     VideoEncoderRateObserver* rate_observer,
-                                     bool internalSource)
+VCMGenericEncoder::VCMGenericEncoder(
+    VideoEncoder* encoder,
+    VideoEncoderRateObserver* rate_observer,
+    VCMEncodedFrameCallback* encoded_frame_callback,
+    bool internalSource)
     : encoder_(encoder),
       rate_observer_(rate_observer),
-      vcm_encoded_frame_callback_(nullptr),
+      vcm_encoded_frame_callback_(encoded_frame_callback),
+      internal_source_(internalSource),
       encoder_params_({0, 0, 0, 0}),
-      internal_source_(internalSource),
       rotation_(kVideoRotation_0),
       is_screenshare_(false) {}
 
-VCMGenericEncoder::~VCMGenericEncoder()
-{
+VCMGenericEncoder::~VCMGenericEncoder() {}
+
+int32_t VCMGenericEncoder::Release() {
+  return encoder_->Release();
 }
 
-int32_t VCMGenericEncoder::Release()
-{
-    {
-      rtc::CritScope lock(&params_lock_);
-      encoder_params_ = {0, 0, 0, 0};
-      vcm_encoded_frame_callback_ = nullptr;
-    }
+int32_t VCMGenericEncoder::InitEncode(const VideoCodec* settings,
+                                      int32_t numberOfCores,
+                                      size_t maxPayloadSize) {
+  {
+    rtc::CritScope lock(&params_lock_);
+    encoder_params_.target_bitrate = settings->startBitrate * 1000;
+    encoder_params_.input_frame_rate = settings->maxFramerate;
+  }
 
-    return encoder_->Release();
-}
-
-int32_t
-VCMGenericEncoder::InitEncode(const VideoCodec* settings,
-                              int32_t numberOfCores,
-                              size_t maxPayloadSize)
-{
-    {
-      rtc::CritScope lock(&params_lock_);
-      encoder_params_.target_bitrate = settings->startBitrate * 1000;
-      encoder_params_.input_frame_rate = settings->maxFramerate;
-    }
-
-    is_screenshare_ = settings->mode == VideoCodecMode::kScreensharing;
-    if (encoder_->InitEncode(settings, numberOfCores, maxPayloadSize) != 0) {
-      LOG(LS_ERROR) << "Failed to initialize the encoder associated with "
-                       "payload name: " << settings->plName;
-      return -1;
-    }
-    return 0;
+  is_screenshare_ = settings->mode == VideoCodecMode::kScreensharing;
+  if (encoder_->InitEncode(settings, numberOfCores, maxPayloadSize) != 0) {
+    LOG(LS_ERROR) << "Failed to initialize the encoder associated with "
+                     "payload name: "
+                  << settings->plName;
+    return -1;
+  }
+  encoder_->RegisterEncodeCompleteCallback(vcm_encoded_frame_callback_);
+  return 0;
 }
 
 int32_t VCMGenericEncoder::Encode(const VideoFrame& inputFrame,
                                   const CodecSpecificInfo* codecSpecificInfo,
                                   const std::vector<FrameType>& frameTypes) {
   for (FrameType frame_type : frameTypes)
     RTC_DCHECK(frame_type == kVideoFrameKey || frame_type == kVideoFrameDelta);
 
   rotation_ = inputFrame.rotation();
 
-  if (vcm_encoded_frame_callback_) {
-    // Keep track of the current frame rotation and apply to the output of the
-    // encoder. There might not be exact as the encoder could have one frame
-    // delay but it should be close enough.
-    vcm_encoded_frame_callback_->SetRotation(rotation_);
-  }
+  // Keep track of the current frame rotation and apply to the output of the
+  // encoder. There might not be exact as the encoder could have one frame delay
+  // but it should be close enough.
+  // TODO(pbos): Map from timestamp, this is racy (even if rotation_ is locked
+  // properly, which it isn't). More than one frame may be in the pipeline.
+  vcm_encoded_frame_callback_->SetRotation(rotation_);
 
   int32_t result = encoder_->Encode(inputFrame, codecSpecificInfo, &frameTypes);
   if (is_screenshare_ &&
       result == WEBRTC_VIDEO_CODEC_TARGET_BITRATE_OVERSHOOT) {
     // Target bitrate exceeded, encoder state has been reset - try again.
     return encoder_->Encode(inputFrame, codecSpecificInfo, &frameTypes);
   }
 
   return result;
 }
@@ skipping 33 matching lines @@
 {
     return encoder_->SetPeriodicKeyFrames(enable);
 }
 
 int32_t VCMGenericEncoder::RequestFrame(
     const std::vector<FrameType>& frame_types) {
   VideoFrame image;
   return encoder_->Encode(image, NULL, &frame_types);
 }
 
-int32_t
-VCMGenericEncoder::RegisterEncodeCallback(VCMEncodedFrameCallback* VCMencodedFrameCallback)
-{
-    VCMencodedFrameCallback->SetInternalSource(internal_source_);
-    vcm_encoded_frame_callback_ = VCMencodedFrameCallback;
-    return encoder_->RegisterEncodeCompleteCallback(VCMencodedFrameCallback);
-}
-
 bool
 VCMGenericEncoder::InternalSource() const
 {
     return internal_source_;
 }
 
 void VCMGenericEncoder::OnDroppedFrame() {
   encoder_->OnDroppedFrame();
 }
 
@@ skipping 82 matching lines @@
 }
 
 void
 VCMEncodedFrameCallback::SetMediaOpt(
     media_optimization::MediaOptimization *mediaOpt)
 {
     _mediaOpt = mediaOpt;
 }
 
 }  // namespace webrtc