Revert of Deliver video frames on Android, on the decode thread.

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.
  */
 
@@ skipping 53 matching lines @@
   h264_settings.keyFrameInterval = 3000;
   h264_settings.spsData = nullptr;
   h264_settings.spsLen = 0;
   h264_settings.ppsData = nullptr;
   h264_settings.ppsLen = 0;
   h264_settings.profile = H264::kProfileConstrainedBaseline;
 
   return h264_settings;
 }
 
-// Create an internal Decoder given a codec type
-static std::unique_ptr<VCMGenericDecoder> CreateDecoder(VideoCodecType type) {
-  switch (type) {
-    case kVideoCodecVP8:
-      return std::unique_ptr<VCMGenericDecoder>(
-          new VCMGenericDecoder(VP8Decoder::Create()));
-    case kVideoCodecVP9:
-      return std::unique_ptr<VCMGenericDecoder>(
-          new VCMGenericDecoder(VP9Decoder::Create()));
-    case kVideoCodecI420:
-      return std::unique_ptr<VCMGenericDecoder>(
-          new VCMGenericDecoder(new I420Decoder()));
-    case kVideoCodecH264:
-      if (H264Decoder::IsSupported()) {
-        return std::unique_ptr<VCMGenericDecoder>(
-            new VCMGenericDecoder(H264Decoder::Create()));
-      }
-      break;
-    default:
-      break;
-  }
-  LOG(LS_WARNING) << "No internal decoder of this type exists.";
-  return std::unique_ptr<VCMGenericDecoder>();
-}
-
 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) {
   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)
     : 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_(nullptr),
       internal_source_(false),
       encoded_frame_callback_(encoded_frame_callback),
+      ptr_decoder_(nullptr),
       dec_map_(),
       dec_external_map_() {}
 
 VCMCodecDataBase::~VCMCodecDataBase() {
   DeleteEncoder();
-  ptr_decoder_.reset();
+  ReleaseDecoder(ptr_decoder_);
   for (auto& kv : dec_map_)
     delete kv.second;
   for (auto& kv : dec_external_map_)
     delete kv.second;
 }
 
 void VCMCodecDataBase::Codec(VideoCodecType codec_type, VideoCodec* settings) {
   memset(settings, 0, sizeof(VideoCodec));
   switch (codec_type) {
     case kVideoCodecVP8:
@@ skipping 266 matching lines @@
 
 bool VCMCodecDataBase::DeregisterExternalDecoder(uint8_t payload_type) {
   ExternalDecoderMap::iterator it = dec_external_map_.find(payload_type);
   if (it == dec_external_map_.end()) {
     // Not found
     return false;
   }
   // We can't use payload_type to check if the decoder is currently in use,
   // because payload type may be out of date (e.g. before we decode the first
   // frame after RegisterReceiveCodec)
-  if (ptr_decoder_ &&
-      ptr_decoder_->IsSameDecoder((*it).second->external_decoder_instance)) {
+  if (ptr_decoder_ != nullptr &&
+      ptr_decoder_->_decoder == (*it).second->external_decoder_instance) {
     // Release it if it was registered and in use.
-    ptr_decoder_.reset();
+    ReleaseDecoder(ptr_decoder_);
+    ptr_decoder_ = nullptr;
   }
   DeregisterReceiveCodec(payload_type);
   delete it->second;
   dec_external_map_.erase(it);
   return true;
 }
 
 // Add the external encoder object to the list of external decoders.
 // Won't be registered as a receive codec until RegisterReceiveCodec is called.
 void VCMCodecDataBase::RegisterExternalDecoder(VideoDecoder* external_decoder,
@@ skipping 39 matching lines @@
   }
   return true;
 }
 
 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_.get();
+    return ptr_decoder_;
   }
   // Check for exisitng decoder, if exists - delete.
   if (ptr_decoder_) {
-    ptr_decoder_.reset();
+    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();
   callback->OnIncomingPayloadType(receive_codec_.plType);
   if (ptr_decoder_->RegisterDecodeCompleteCallback(decoded_frame_callback) <
       0) {
-    ptr_decoder_.reset();
+    ReleaseDecoder(ptr_decoder_);
+    ptr_decoder_ = nullptr;
     memset(&receive_codec_, 0, sizeof(VideoCodec));
     return nullptr;
   }
-  return ptr_decoder_.get();
+  return ptr_decoder_;
 }
 
-VCMGenericDecoder* VCMCodecDataBase::GetCurrentDecoder() {
-  return ptr_decoder_.get();
+void VCMCodecDataBase::ReleaseDecoder(VCMGenericDecoder* decoder) const {
+  if (decoder) {
+    RTC_DCHECK(decoder->_decoder);
+    decoder->Release();
+    if (!decoder->External()) {
+      delete decoder->_decoder;
+    }
+    delete decoder;
+  }
 }
 
 bool VCMCodecDataBase::PrefersLateDecoding() const {
-  return ptr_decoder_ ? ptr_decoder_->PrefersLateDecoding() : true;
+  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;
 }
 
-std::unique_ptr<VCMGenericDecoder> VCMCodecDataBase::CreateAndInitDecoder(
+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) << "'.";
   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;
   }
-  std::unique_ptr<VCMGenericDecoder> ptr_decoder;
+  VCMGenericDecoder* ptr_decoder = nullptr;
   const VCMExtDecoderMapItem* external_dec_item =
       FindExternalDecoderItem(payload_type);
   if (external_dec_item) {
     // External codec.
-    ptr_decoder.reset(new VCMGenericDecoder(
-        external_dec_item->external_decoder_instance, true));
+    ptr_decoder = new VCMGenericDecoder(
+        external_dec_item->external_decoder_instance, true);
   } else {
     // Create decoder.
     ptr_decoder = CreateDecoder(decoder_item->settings->codecType);
   }
   if (!ptr_decoder)
     return nullptr;
 
   // Copy over input resolutions to prevent codec reinitialization due to
   // the first frame being of a different resolution than the database values.
   // This is best effort, since there's no guarantee that width/height have been
   // parsed yet (and may be zero).
   if (frame.EncodedImage()._encodedWidth > 0 &&
       frame.EncodedImage()._encodedHeight > 0) {
     decoder_item->settings->width = frame.EncodedImage()._encodedWidth;
     decoder_item->settings->height = frame.EncodedImage()._encodedHeight;
   }
   if (ptr_decoder->InitDecode(decoder_item->settings.get(),
                               decoder_item->number_of_cores) < 0) {
+    ReleaseDecoder(ptr_decoder);
     return nullptr;
   }
   memcpy(new_codec, decoder_item->settings.get(), sizeof(VideoCodec));
   return ptr_decoder;
 }
 
 void VCMCodecDataBase::DeleteEncoder() {
   if (!ptr_encoder_)
     return;
   ptr_encoder_->Release();
   ptr_encoder_.reset();
 }
 
+VCMGenericDecoder* VCMCodecDataBase::CreateDecoder(VideoCodecType type) const {
+  switch (type) {
+    case kVideoCodecVP8:
+      return new VCMGenericDecoder(VP8Decoder::Create());
+    case kVideoCodecVP9:
+      return new VCMGenericDecoder(VP9Decoder::Create());
+    case kVideoCodecI420:
+      return new VCMGenericDecoder(new I420Decoder());
+    case kVideoCodecH264:
+      if (H264Decoder::IsSupported()) {
+        return new VCMGenericDecoder(H264Decoder::Create());
+      }
+      break;
+    default:
+      break;
+  }
+  LOG(LS_WARNING) << "No internal decoder of this type exists.";
+  return nullptr;
+}
+
 const VCMDecoderMapItem* VCMCodecDataBase::FindDecoderItem(
     uint8_t payload_type) const {
   DecoderMap::const_iterator it = dec_map_.find(payload_type);
   if (it != dec_map_.end()) {
     return (*it).second;
   }
   return nullptr;
 }
 
 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