A few simplifications to CodecDatabase and VCMGenericDecoder

webrtc/modules/video_coding/generic_decoder.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/generic_decoder.h"
+
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/modules/video_coding/include/video_coding.h"
-#include "webrtc/modules/video_coding/generic_decoder.h"
 #include "webrtc/modules/video_coding/internal_defines.h"
 #include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
 
 VCMDecodedFrameCallback::VCMDecodedFrameCallback(VCMTiming* timing,
                                                  Clock* clock)
     : _clock(clock),
       _timing(timing),
       _timestampMap(kDecoderFrameMemoryLength),
@@ skipping 122 matching lines @@
   if (_timestampMap.Pop(timestamp) == NULL) {
     return VCM_GENERAL_ERROR;
   }
   return VCM_OK;
 }
 
 VCMGenericDecoder::VCMGenericDecoder(VideoDecoder* decoder, bool isExternal)
     : _callback(NULL),
       _frameInfos(),
       _nextFrameInfoIdx(0),
-      _decoder(decoder),
+      decoder_(decoder),
       _codecType(kVideoCodecUnknown),
       _isExternal(isExternal),
-      _keyFrameDecoded(false),
-      _last_keyframe_content_type(VideoContentType::UNSPECIFIED) {}
+      _last_keyframe_content_type(VideoContentType::UNSPECIFIED) {
+  RTC_DCHECK(decoder_);
+}
 
-VCMGenericDecoder::~VCMGenericDecoder() {}
+VCMGenericDecoder::~VCMGenericDecoder() {
+  decoder_->Release();
+  if (_isExternal)
+    decoder_.release();
+  RTC_DCHECK(_isExternal || !decoder_);
+}
 
 int32_t VCMGenericDecoder::InitDecode(const VideoCodec* settings,
                                       int32_t numberOfCores) {
   TRACE_EVENT0("webrtc", "VCMGenericDecoder::InitDecode");
   _codecType = settings->codecType;
 
-  return _decoder->InitDecode(settings, numberOfCores);
+  return decoder_->InitDecode(settings, numberOfCores);
 }
 
 int32_t VCMGenericDecoder::Decode(const VCMEncodedFrame& frame, int64_t nowMs) {
     TRACE_EVENT1("webrtc", "VCMGenericDecoder::Decode", "timestamp",
                  frame.EncodedImage()._timeStamp);
     _frameInfos[_nextFrameInfoIdx].decodeStartTimeMs = nowMs;
     _frameInfos[_nextFrameInfoIdx].renderTimeMs = frame.RenderTimeMs();
     _frameInfos[_nextFrameInfoIdx].rotation = frame.rotation();
     _frameInfos[_nextFrameInfoIdx].timing = frame.video_timing();
     // Set correctly only for key frames. Thus, use latest key frame
     // content type. If the corresponding key frame was lost, decode will fail
     // and content type will be ignored.
     if (frame.FrameType() == kVideoFrameKey) {
       _frameInfos[_nextFrameInfoIdx].content_type = frame.contentType();
       _last_keyframe_content_type = frame.contentType();
     } else {
       _frameInfos[_nextFrameInfoIdx].content_type = _last_keyframe_content_type;
     }
     _callback->Map(frame.TimeStamp(), &_frameInfos[_nextFrameInfoIdx]);
 
     _nextFrameInfoIdx = (_nextFrameInfoIdx + 1) % kDecoderFrameMemoryLength;
     const RTPFragmentationHeader dummy_header;
-    int32_t ret = _decoder->Decode(frame.EncodedImage(), frame.MissingFrame(),
+    int32_t ret = decoder_->Decode(frame.EncodedImage(), frame.MissingFrame(),
                                    &dummy_header,
                                    frame.CodecSpecific(), frame.RenderTimeMs());
 
-    _callback->OnDecoderImplementationName(_decoder->ImplementationName());
+    _callback->OnDecoderImplementationName(decoder_->ImplementationName());
     if (ret < WEBRTC_VIDEO_CODEC_OK) {
         LOG(LS_WARNING) << "Failed to decode frame with timestamp "
                         << frame.TimeStamp() << ", error code: " << ret;
         _callback->Pop(frame.TimeStamp());
         return ret;
     } else if (ret == WEBRTC_VIDEO_CODEC_NO_OUTPUT ||
                ret == WEBRTC_VIDEO_CODEC_REQUEST_SLI) {
         // No output
         _callback->Pop(frame.TimeStamp());
     }
     return ret;
 }
 
-int32_t VCMGenericDecoder::Release() {
-  return _decoder->Release();
-}
-
 int32_t VCMGenericDecoder::RegisterDecodeCompleteCallback(
     VCMDecodedFrameCallback* callback) {
   _callback = callback;
-  return _decoder->RegisterDecodeCompleteCallback(callback);
-}
-
-bool VCMGenericDecoder::External() const {
-  return _isExternal;
+  return decoder_->RegisterDecodeCompleteCallback(callback);
 }
 
 bool VCMGenericDecoder::PrefersLateDecoding() const {
-  return _decoder->PrefersLateDecoding();
+  return decoder_->PrefersLateDecoding();
 }
 
 }  // namespace webrtc