Remove VideoReceiveStream deregister of decoders.

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 93 matching lines @@
       encoder_payload_type_(0),
       external_encoder_(nullptr),
       internal_source_(false),
       encoder_rate_observer_(encoder_rate_observer),
       encoded_frame_callback_(encoded_frame_callback),
       ptr_decoder_(nullptr),
       dec_map_(),
       dec_external_map_() {}
 
 VCMCodecDataBase::~VCMCodecDataBase() {
-  ResetSender();
-  ResetReceiver();
+  DeleteEncoder();
+  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:
       strncpy(settings->plName, "VP8", 4);
       settings->codecType = kVideoCodecVP8;
       // 96 to 127 dynamic payload types for video codecs.
       settings->plType = kDefaultPayloadType;
@@ skipping 55 matching lines @@
       return;
     case kVideoCodecRED:
     case kVideoCodecULPFEC:
     case kVideoCodecGeneric:
     case kVideoCodecUnknown:
       RTC_NOTREACHED();
       return;
   }
 }
 
-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) {
   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);
@@ skipping 184 matching lines @@
 }
 
 bool VCMCodecDataBase::SetPeriodicKeyFrames(bool enable) {
   periodic_key_frames_ = enable;
   if (ptr_encoder_) {
     return (ptr_encoder_->SetPeriodicKeyFrames(periodic_key_frames_) == 0);
   }
   return true;
 }
 
-void VCMCodecDataBase::ResetReceiver() {
-  ReleaseDecoder(ptr_decoder_);
-  ptr_decoder_ = nullptr;
-  memset(&receive_codec_, 0, sizeof(VideoCodec));
-  while (!dec_map_.empty()) {
-    DecoderMap::iterator it = dec_map_.begin();
-    delete (*it).second;
-    dec_map_.erase(it);
-  }
-  while (!dec_external_map_.empty()) {
-    ExternalDecoderMap::iterator external_it = dec_external_map_.begin();
-    delete (*external_it).second;
-    dec_external_map_.erase(external_it);
-  }
-}
-
 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_ != nullptr &&
-      &ptr_decoder_->_decoder == (*it).second->external_decoder_instance) {
+      ptr_decoder_->_decoder == (*it).second->external_decoder_instance) {
     // Release it if it was registered and in use.
     ReleaseDecoder(ptr_decoder_);
     ptr_decoder_ = nullptr;
   }
   DeregisterReceiveCodec(payload_type);
-  delete (*it).second;
+  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,
     uint8_t payload_type,
     bool internal_render_timing) {
@@ skipping 26 matching lines @@
                                                           require_key_frame);
   return true;
 }
 
 bool VCMCodecDataBase::DeregisterReceiveCodec(
     uint8_t payload_type) {
   DecoderMap::iterator it = dec_map_.find(payload_type);
   if (it == dec_map_.end()) {
     return false;
   }
-  VCMDecoderMapItem* dec_item = (*it).second;
-  delete dec_item;
+  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);
@@ skipping 35 matching lines @@
     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);
+    assert(decoder->_decoder);
     decoder->Release();
     if (!decoder->External()) {
-      delete &decoder->_decoder;
+      delete decoder->_decoder;
     }
     delete decoder;
   }
 }
 
 bool VCMCodecDataBase::SupportsRenderScheduling() const {
   const VCMExtDecoderMapItem* ext_item = FindExternalDecoderItem(
       receive_codec_.plType);
   if (!ext_item)
     return true;
@@ skipping 14 matching lines @@
     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) {
     // External codec.
     ptr_decoder = new VCMGenericDecoder(
-        *external_dec_item->external_decoder_instance, true);
+        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
@@ skipping 15 matching lines @@
 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()));
+      return new VCMGenericDecoder(VP8Decoder::Create());
     case kVideoCodecVP9:
-      return new VCMGenericDecoder(*(VP9Decoder::Create()));
+      return new VCMGenericDecoder(VP9Decoder::Create());
     case kVideoCodecI420:
-      return new VCMGenericDecoder(*(new I420Decoder));
+      return new VCMGenericDecoder(new I420Decoder());
     case kVideoCodecH264:
       if (H264Decoder::IsSupported()) {
-        return new VCMGenericDecoder(*(H264Decoder::Create()));
+        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