Updates to VCMDecodedFrameCallback, VideoReceiver and a few related classes/tests.

webrtc/modules/video_coding/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.
  */
 
 #include "webrtc/modules/video_coding/codec_database.h"
 
-#include <assert.h>
-
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/video_coding/codecs/h264/include/h264.h"
 #include "webrtc/modules/video_coding/codecs/i420/include/i420.h"
 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h"
 #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h"
 #include "webrtc/modules/video_coding/internal_defines.h"
 
 namespace {
 const size_t kDefaultPayloadSize = 1440;
@@ skipping 47 matching lines @@
 
   return h264_settings;
 }
 
 VCMDecoderMapItem::VCMDecoderMapItem(VideoCodec* settings,
                                      int number_of_cores,
                                      bool require_key_frame)
     : settings(settings),
       number_of_cores(number_of_cores),
       require_key_frame(require_key_frame) {
-  assert(number_of_cores >= 0);
+  RTC_DCHECK_GE(number_of_cores, 0);
 }
 
 VCMExtDecoderMapItem::VCMExtDecoderMapItem(
     VideoDecoder* external_decoder_instance,
     uint8_t payload_type)
     : payload_type(payload_type),
       external_decoder_instance(external_decoder_instance) {}
 
 VCMCodecDataBase::VCMCodecDataBase(
     VCMEncodedFrameCallback* encoded_frame_callback)
@@ skipping 180 matching lines @@
 
 VideoCodecType VCMCodecDataBase::SendCodec() const {
   if (!ptr_encoder_) {
     return kVideoCodecUnknown;
   }
   return send_codec_.codecType;
 }
 
 bool VCMCodecDataBase::DeregisterExternalEncoder(uint8_t payload_type,
                                                  bool* was_send_codec) {
-  assert(was_send_codec);
+  RTC_DCHECK(was_send_codec);
   *was_send_codec = false;
   if (encoder_payload_type_ != payload_type) {
     return false;
   }
   if (send_codec_.plType == payload_type) {
     // De-register as send codec if needed.
     DeleteEncoder();
     memset(&send_codec_, 0, sizeof(VideoCodec));
     *was_send_codec = true;
   }
@@ skipping 151 matching lines @@
   delete it->second;
   dec_map_.erase(it);
   if (receive_codec_.plType == payload_type) {
     // This codec is currently in use.
     memset(&receive_codec_, 0, sizeof(VideoCodec));
   }
   return true;
 }
 
 bool VCMCodecDataBase::ReceiveCodec(VideoCodec* current_receive_codec) const {
-  assert(current_receive_codec);
+  RTC_DCHECK(current_receive_codec);
   if (!ptr_decoder_) {
     return false;
   }
   memcpy(current_receive_codec, &receive_codec_, sizeof(VideoCodec));
   return true;
 }
 
 VideoCodecType VCMCodecDataBase::ReceiveCodec() const {
   if (!ptr_decoder_) {
     return kVideoCodecUnknown;
   }
   return receive_codec_.codecType;
 }
 
 VCMGenericDecoder* VCMCodecDataBase::GetDecoder(
     const VCMEncodedFrame& frame,
     VCMDecodedFrameCallback* decoded_frame_callback) {
+  RTC_DCHECK(decoded_frame_callback->UserReceiveCallback());
   uint8_t payload_type = frame.PayloadType();
   if (payload_type == receive_codec_.plType || payload_type == 0) {
     return ptr_decoder_;
   }
   // Check for exisitng decoder, if exists - delete.
   if (ptr_decoder_) {
     ReleaseDecoder(ptr_decoder_);
     ptr_decoder_ = nullptr;
     memset(&receive_codec_, 0, sizeof(VideoCodec));
   }
   ptr_decoder_ = CreateAndInitDecoder(frame, &receive_codec_);
   if (!ptr_decoder_) {
     return nullptr;
   }
   VCMReceiveCallback* callback = decoded_frame_callback->UserReceiveCallback();
-  if (callback)
-    callback->OnIncomingPayloadType(receive_codec_.plType);
+  callback->OnIncomingPayloadType(receive_codec_.plType);
   if (ptr_decoder_->RegisterDecodeCompleteCallback(decoded_frame_callback) <
       0) {
     ReleaseDecoder(ptr_decoder_);
     ptr_decoder_ = nullptr;
     memset(&receive_codec_, 0, sizeof(VideoCodec));
     return nullptr;
   }
   return ptr_decoder_;
 }
 
 void VCMCodecDataBase::ReleaseDecoder(VCMGenericDecoder* decoder) const {
   if (decoder) {
-    assert(decoder->_decoder);
+    RTC_DCHECK(decoder->_decoder);
     decoder->Release();
     if (!decoder->External()) {
       delete decoder->_decoder;
     }
     delete decoder;
   }
 }
 
 bool VCMCodecDataBase::PrefersLateDecoding() const {
   if (!ptr_decoder_)
     return true;
   return ptr_decoder_->PrefersLateDecoding();
 }
 
 bool VCMCodecDataBase::MatchesCurrentResolution(int width, int height) const {
   return send_codec_.width == width && send_codec_.height == height;
 }
 
 VCMGenericDecoder* VCMCodecDataBase::CreateAndInitDecoder(
     const VCMEncodedFrame& frame,
     VideoCodec* new_codec) const {
   uint8_t payload_type = frame.PayloadType();
   LOG(LS_INFO) << "Initializing decoder with payload type '"
                << static_cast<int>(payload_type) << "'.";
-  assert(new_codec);
+  RTC_DCHECK(new_codec);
   const VCMDecoderMapItem* decoder_item = FindDecoderItem(payload_type);
   if (!decoder_item) {
     LOG(LS_ERROR) << "Can't find a decoder associated with payload type: "
                   << static_cast<int>(payload_type);
     return nullptr;
   }
   VCMGenericDecoder* ptr_decoder = nullptr;
   const VCMExtDecoderMapItem* external_dec_item =
       FindExternalDecoderItem(payload_type);
   if (external_dec_item) {
@@ skipping 63 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 nullptr;
 }
 }  // namespace webrtc