Make VCMEncodedFrameCallback const.

webrtc/modules/video_coding/main/source/codec_database.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 83 matching lines @@
 VCMExtDecoderMapItem::VCMExtDecoderMapItem(
     VideoDecoder* external_decoder_instance,
     uint8_t payload_type,
     bool internal_render_timing)
     : payload_type(payload_type),
       external_decoder_instance(external_decoder_instance),
       internal_render_timing(internal_render_timing) {
 }
 
 VCMCodecDataBase::VCMCodecDataBase(
-    VideoEncoderRateObserver* encoder_rate_observer)
+    VideoEncoderRateObserver* encoder_rate_observer,
+    VCMEncodedFrameCallback* encoded_frame_callback)
     : number_of_cores_(0),
       max_payload_size_(kDefaultPayloadSize),
       periodic_key_frames_(false),
       pending_encoder_reset_(true),
       send_codec_(),
       receive_codec_(),
       encoder_payload_type_(0),
       external_encoder_(NULL),
       internal_source_(false),
       encoder_rate_observer_(encoder_rate_observer),
+      encoded_frame_callback_(encoded_frame_callback),
       ptr_decoder_(NULL),
       dec_map_(),
-      dec_external_map_() {
-}
+      dec_external_map_() {}
 
 VCMCodecDataBase::~VCMCodecDataBase() {
   ResetSender();
   ResetReceiver();
 }
 
 int VCMCodecDataBase::NumberOfCodecs() {
   return VCM_NUM_VIDEO_CODECS_AVAILABLE;
 }
 
@@ skipping 99 matching lines @@
   }
   return false;
 }
 
 void VCMCodecDataBase::ResetSender() {
   DeleteEncoder();
   periodic_key_frames_ = false;
 }
 
 // Assuming only one registered encoder - since only one used, no need for more.
-bool VCMCodecDataBase::SetSendCodec(
-    const VideoCodec* send_codec,
-    int number_of_cores,
-    size_t max_payload_size,
-    VCMEncodedFrameCallback* encoded_frame_callback) {
+bool VCMCodecDataBase::SetSendCodec(const VideoCodec* send_codec,
+                                    int number_of_cores,
+                                    size_t max_payload_size) {
   RTC_DCHECK(send_codec);
   if (max_payload_size == 0) {
     max_payload_size = kDefaultPayloadSize;
   }
   RTC_DCHECK_GE(number_of_cores, 1);
   RTC_DCHECK_GE(send_codec->plType, 1);
   // Make sure the start bit rate is sane...
   RTC_DCHECK_LE(send_codec->startBitrate, 1000000u);
   RTC_DCHECK(send_codec->codecType != kVideoCodecUnknown);
   bool reset_required = pending_encoder_reset_;
@@ skipping 24 matching lines @@
   if (new_send_codec.startBitrate > new_send_codec.maxBitrate)
     new_send_codec.startBitrate = new_send_codec.maxBitrate;
 
   if (!reset_required) {
     reset_required = RequiresEncoderReset(new_send_codec);
   }
 
   memcpy(&send_codec_, &new_send_codec, sizeof(send_codec_));
 
   if (!reset_required) {
-    encoded_frame_callback->SetPayloadType(send_codec_.plType);
-    if (ptr_encoder_->RegisterEncodeCallback(encoded_frame_callback) < 0) {
-      LOG(LS_ERROR) << "Failed to register encoded-frame callback.";
-      return false;
-    }
+    encoded_frame_callback_->SetPayloadType(send_codec_.plType);
     return true;
   }
 
   // If encoder exists, will destroy it and create new one.
   DeleteEncoder();
   RTC_DCHECK_EQ(encoder_payload_type_, send_codec_.plType)
       << "Encoder not registered for payload type " << send_codec_.plType;
-  ptr_encoder_.reset(new VCMGenericEncoder(
-      external_encoder_, encoder_rate_observer_, internal_source_));
-  encoded_frame_callback->SetPayloadType(send_codec_.plType);
+  ptr_encoder_.reset(
+      new VCMGenericEncoder(external_encoder_, encoder_rate_observer_,
+                            encoded_frame_callback_, internal_source_));
+  encoded_frame_callback_->SetPayloadType(send_codec_.plType);
+  encoded_frame_callback_->SetInternalSource(internal_source_);
   if (ptr_encoder_->InitEncode(&send_codec_, number_of_cores_,
                                max_payload_size_) < 0) {
     LOG(LS_ERROR) << "Failed to initialize video encoder.";
     DeleteEncoder();
     return false;
-  } else if (ptr_encoder_->RegisterEncodeCallback(encoded_frame_callback) < 0) {
-    LOG(LS_ERROR) << "Failed to register encoded-frame callback.";
-    DeleteEncoder();
-    return false;
   }
 
   // Intentionally don't check return value since the encoder registration
   // shouldn't fail because the codec doesn't support changing the periodic key
   // frame setting.
   ptr_encoder_->SetPeriodicKeyFrames(periodic_key_frames_);
 
   pending_encoder_reset_ = false;
 
   return true;
@@ skipping 364 matching lines @@
 
 const VCMExtDecoderMapItem* VCMCodecDataBase::FindExternalDecoderItem(
     uint8_t payload_type) const {
   ExternalDecoderMap::const_iterator it = dec_external_map_.find(payload_type);
   if (it != dec_external_map_.end()) {
     return (*it).second;
   }
   return NULL;
 }
 }  // namespace webrtc