Cache the subtype of each DecoderInfo to make the Is* checks quicker.

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.
  */
 
@@ skipping 13 matching lines @@
       active_cng_decoder_type_(-1),
       decoder_factory_(decoder_factory) {}
 
 DecoderDatabase::~DecoderDatabase() = default;
 
 DecoderDatabase::DecoderInfo::DecoderInfo(const SdpAudioFormat& audio_format,
                                           AudioDecoderFactory* factory)
     : audio_format_(audio_format),
       factory_(factory),
       external_decoder_(nullptr),
-      cng_decoder_(CngDecoder::Create(audio_format)) {}
+      cng_decoder_(CngDecoder::Create(audio_format)),
+      subtype_(SubtypeFromFormat(audio_format)) {}
 
 DecoderDatabase::DecoderInfo::DecoderInfo(NetEqDecoder ct,
                                           AudioDecoderFactory* factory)
     : audio_format_(*acm2::RentACodec::NetEqDecoderToSdpAudioFormat(ct)),
       factory_(factory),
       external_decoder_(nullptr),
-      cng_decoder_(CngDecoder::Create(audio_format_)) {}
+      cng_decoder_(CngDecoder::Create(audio_format_)),
+      subtype_(SubtypeFromFormat(audio_format_)) {}
 
 DecoderDatabase::DecoderInfo::DecoderInfo(const SdpAudioFormat& audio_format,
                                           AudioDecoder* ext_dec)
     : audio_format_(audio_format),
       factory_(nullptr),
-      external_decoder_(ext_dec) {
+      external_decoder_(ext_dec),
+      subtype_(Subtype::kNormal) {
   RTC_CHECK(ext_dec);
 }
 
 DecoderDatabase::DecoderInfo::DecoderInfo(DecoderInfo&&) = default;
 DecoderDatabase::DecoderInfo::~DecoderInfo() = default;
 
 AudioDecoder* DecoderDatabase::DecoderInfo::GetDecoder() const {
-  if (IsDtmf() || IsRed() || IsComfortNoise()) {
+  if (subtype_ != Subtype::kNormal) {
     // These are handled internally, so they have no AudioDecoder objects.
     return nullptr;
   }
   if (external_decoder_) {
     RTC_DCHECK(!decoder_);
     RTC_DCHECK(!cng_decoder_);
     return external_decoder_;
   }
   if (!decoder_) {
     // TODO(ossu): Keep a check here for now, since a number of tests create
     // DecoderInfos without factories.
     RTC_DCHECK(factory_);
     decoder_ = factory_->MakeAudioDecoder(audio_format_);
   }
   RTC_DCHECK(decoder_) << "Failed to create: " << audio_format_;
   return decoder_.get();
 }
 
-bool DecoderDatabase::DecoderInfo::IsComfortNoise() const {
-  RTC_DCHECK_EQ(!!cng_decoder_, IsType("CN"));
-  return !!cng_decoder_;
-}
-
-bool DecoderDatabase::DecoderInfo::IsDtmf() const {
-  return IsType("telephone-event");
-}
-
-bool DecoderDatabase::DecoderInfo::IsRed() const {
-  return IsType("red");
-}
-
 bool DecoderDatabase::DecoderInfo::IsType(const char* name) const {
   return STR_CASE_CMP(audio_format_.name.c_str(), name) == 0;
 }
 
 bool DecoderDatabase::DecoderInfo::IsType(const std::string& name) const {
   return IsType(name.c_str());
 }
 
 rtc::Optional<DecoderDatabase::DecoderInfo::CngDecoder>
 DecoderDatabase::DecoderInfo::CngDecoder::Create(const SdpAudioFormat& format) {
   if (STR_CASE_CMP(format.name.c_str(), "CN") == 0) {
     return rtc::Optional<CngDecoder>({format.clockrate_hz});
   } else {
     return rtc::Optional<CngDecoder>();
   }
 }
 
+DecoderDatabase::DecoderInfo::Subtype
+DecoderDatabase::DecoderInfo::SubtypeFromFormat(const SdpAudioFormat& format) {
+  if (STR_CASE_CMP(format.name.c_str(), "CN") == 0) {
+    return Subtype::kComfortNoise;
+  } else if (STR_CASE_CMP(format.name.c_str(), "telephone-event") == 0) {
+    return Subtype::kDtmf;
+  } else if (STR_CASE_CMP(format.name.c_str(), "red") == 0) {
+    return Subtype::kRed;
+  }
+
+  return Subtype::kNormal;
+}
+
 bool DecoderDatabase::Empty() const { return decoders_.empty(); }
 
 int DecoderDatabase::Size() const { return static_cast<int>(decoders_.size()); }
 
 void DecoderDatabase::Reset() {
   decoders_.clear();
   active_decoder_type_ = -1;
   active_cng_decoder_type_ = -1;
 }
 
@@ skipping 178 matching lines @@
       // 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