NetEq: Simplify DecoderDatabase::DecoderInfo

webrtc/modules/audio_coding/neteq/decoder_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/audio_coding/neteq/decoder_database.h"
 
 #include <assert.h>
 #include <utility>  // pair
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/audio_coding/codecs/audio_decoder.h"
 
 namespace webrtc {
 
 DecoderDatabase::DecoderDatabase()
     : active_decoder_(-1), active_cng_decoder_(-1) {}
 
 DecoderDatabase::~DecoderDatabase() {}
 
-DecoderDatabase::DecoderInfo::~DecoderInfo() {
-  if (!external) delete decoder;
+DecoderDatabase::DecoderInfo::DecoderInfo(NetEqDecoder ct,
+                                          const std::string& nm,
+                                          int fs,
+                                          AudioDecoder* ext_dec)
+    : codec_type(ct),
+      name(nm),
+      fs_hz(fs),
+      rtp_sample_rate_hz(fs),
+      external_decoder(ext_dec) {}
+
+DecoderDatabase::DecoderInfo::DecoderInfo(DecoderInfo&&) = default;
+DecoderDatabase::DecoderInfo::~DecoderInfo() = default;
+
+AudioDecoder* DecoderDatabase::DecoderInfo::GetDecoder() {
+  if (external_decoder) {
+    RTC_DCHECK(!decoder_);
+    return external_decoder;
+  }
+  if (!decoder_) {
+    decoder_.reset(CreateAudioDecoder(codec_type));
+  }
+  RTC_DCHECK(decoder_);
+  return decoder_.get();
 }
 
 bool DecoderDatabase::Empty() const { return decoders_.empty(); }
 
 int DecoderDatabase::Size() const { return static_cast<int>(decoders_.size()); }
 
 void DecoderDatabase::Reset() {
   decoders_.clear();
   active_decoder_ = -1;
   active_cng_decoder_ = -1;
 }
 
 int DecoderDatabase::RegisterPayload(uint8_t rtp_payload_type,
                                      NetEqDecoder codec_type,
                                      const std::string& name) {
   if (rtp_payload_type > 0x7F) {
     return kInvalidRtpPayloadType;
   }
   if (!CodecSupported(codec_type)) {
     return kCodecNotSupported;
   }
   const int fs_hz = CodecSampleRateHz(codec_type);
-  DecoderInfo info(codec_type, name, fs_hz, NULL, false);
-  auto ret = decoders_.insert(std::make_pair(rtp_payload_type, info));
+  DecoderInfo info(codec_type, name, fs_hz, nullptr);
+  auto ret =
+      decoders_.insert(std::make_pair(rtp_payload_type, std::move(info)));
   if (ret.second == false) {
     // Database already contains a decoder with type |rtp_payload_type|.
     return kDecoderExists;
   }
   return kOK;
 }
 
 int DecoderDatabase::InsertExternal(uint8_t rtp_payload_type,
                                     NetEqDecoder codec_type,
                                     const std::string& codec_name,
                                     int fs_hz,
                                     AudioDecoder* decoder) {
   if (rtp_payload_type > 0x7F) {
     return kInvalidRtpPayloadType;
   }
   if (!CodecSupported(codec_type)) {
     return kCodecNotSupported;
   }
   if (fs_hz != 8000 && fs_hz != 16000 && fs_hz != 32000 && fs_hz != 48000) {
     return kInvalidSampleRate;
   }
   if (!decoder) {
     return kInvalidPointer;
   }
   std::pair<DecoderMap::iterator, bool> ret;
-  DecoderInfo info(codec_type, codec_name, fs_hz, decoder, true);
-  ret = decoders_.insert(std::make_pair(rtp_payload_type, info));
+  DecoderInfo info(codec_type, codec_name, fs_hz, decoder);
+  ret = decoders_.insert(std::make_pair(rtp_payload_type, std::move(info)));
   if (ret.second == false) {
     // Database already contains a decoder with type |rtp_payload_type|.
     return kDecoderExists;
   }
   return kOK;
 }
 
 int DecoderDatabase::Remove(uint8_t rtp_payload_type) {
   if (decoders_.erase(rtp_payload_type) == 0) {
     // No decoder with that |rtp_payload_type|.
@@ skipping 35 matching lines @@
   if (IsDtmf(rtp_payload_type) || IsRed(rtp_payload_type)) {
     // These are not real decoders.
     return NULL;
   }
   DecoderMap::iterator it = decoders_.find(rtp_payload_type);
   if (it == decoders_.end()) {
     // Decoder not found.
     return NULL;
   }
   DecoderInfo* info = &(*it).second;
-  if (!info->decoder) {
-    // Create the decoder object.
-    AudioDecoder* decoder = CreateAudioDecoder(info->codec_type);
-    assert(decoder);  // Should not be able to have an unsupported codec here.
-    info->decoder = decoder;
-  }
-  return info->decoder;
+  return info->GetDecoder();
 }
 
 bool DecoderDatabase::IsType(uint8_t rtp_payload_type,
                              NetEqDecoder codec_type) const {
   DecoderMap::const_iterator it = decoders_.find(rtp_payload_type);
   if (it == decoders_.end()) {
     // Decoder not found.
     return false;
   }
   return ((*it).second.codec_type == codec_type);
@@ skipping 32 matching lines @@
     // This is the first active decoder.
     *new_decoder = true;
   } else if (active_decoder_ != rtp_payload_type) {
     // Moving from one active decoder to another. Delete the first one.
     DecoderMap::iterator it = decoders_.find(active_decoder_);
     if (it == decoders_.end()) {
       // Decoder not found. This should not be possible.
       assert(false);
       return kDecoderNotFound;
     }
-    if (!(*it).second.external) {
-      // Delete the AudioDecoder object, unless it is an externally created
-      // decoder.
-      delete (*it).second.decoder;
-      (*it).second.decoder = NULL;
-    }
+    it->second.DropDecoder();
     *new_decoder = true;
   }
   active_decoder_ = rtp_payload_type;
   return kOK;
 }
 
 AudioDecoder* DecoderDatabase::GetActiveDecoder() {
   if (active_decoder_ < 0) {
     // No active decoder.
     return NULL;
   }
   return GetDecoder(active_decoder_);
 }
 
 int DecoderDatabase::SetActiveCngDecoder(uint8_t rtp_payload_type) {
   // Check that |rtp_payload_type| exists in the database.
   DecoderMap::const_iterator it = decoders_.find(rtp_payload_type);
   if (it == decoders_.end()) {
     // Decoder not found.
     return kDecoderNotFound;
   }
   if (active_cng_decoder_ >= 0 && active_cng_decoder_ != rtp_payload_type) {
     // Moving from one active CNG decoder to another. Delete the first one.
     DecoderMap::iterator it = decoders_.find(active_cng_decoder_);
     if (it == decoders_.end()) {
       // Decoder not found. This should not be possible.
       assert(false);
       return kDecoderNotFound;
     }
-    if (!(*it).second.external) {
-      // Delete the AudioDecoder object, unless it is an externally created
-      // decoder.
-      delete (*it).second.decoder;
-      (*it).second.decoder = NULL;
-    }
+    it->second.DropDecoder();
   }
   active_cng_decoder_ = rtp_payload_type;
   return kOK;
 }
 
 AudioDecoder* DecoderDatabase::GetActiveCngDecoder() {
   if (active_cng_decoder_ < 0) {
     // No active CNG decoder.
     return NULL;
   }
   return GetDecoder(active_cng_decoder_);
 }
 
 int DecoderDatabase::CheckPayloadTypes(const PacketList& packet_list) const {
   PacketList::const_iterator it;
   for (it = packet_list.begin(); it != packet_list.end(); ++it) {
     if (decoders_.find((*it)->header.payloadType) == decoders_.end()) {
       // Payload type is not found.
       LOG(LS_WARNING) << "CheckPayloadTypes: unknown RTP payload type "
                       << static_cast<int>((*it)->header.payloadType);
       return kDecoderNotFound;
     }
   }
   return kOK;
 }
 
 
 }  // namespace webrtc