RentACodec: New class that takes over part of ACMCodecDB's job

webrtc/modules/audio_coding/main/acm2/acm_receiver.cc

 /*
  *  Copyright (c) 2013 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 @@
             << "labeled VAD-passive";
         break;
       }
       default:
         assert(false);
     }
   }
 }
 
 // Is the given codec a CNG codec?
+// TODO(kwiberg): Move to RentACodec.
 bool IsCng(int codec_id) {
-  return (codec_id == ACMCodecDB::kCNNB || codec_id == ACMCodecDB::kCNWB ||
-      codec_id == ACMCodecDB::kCNSWB || codec_id == ACMCodecDB::kCNFB);
+  auto i = RentACodec::CodecIdFromIndex(codec_id);
+  return (i && (*i == RentACodec::CodecId::kCNNB ||
+                *i == RentACodec::CodecId::kCNWB ||
+                *i == RentACodec::CodecId::kCNSWB ||
+                *i == RentACodec::CodecId::kCNFB));
 }
 
 }  // namespace
 
 AcmReceiver::AcmReceiver(const AudioCodingModule::Config& config)
     : crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
       id_(config.id),
       last_audio_decoder_(nullptr),
       previous_audio_activity_(AudioFrame::kVadPassive),
       current_sample_rate_hz_(config.neteq_config.sample_rate_hz),
@@ skipping 107 matching lines @@
     }
     const int sample_rate_hz = ACMCodecDB::CodecFreq(decoder->acm_codec_id);
     receive_timestamp = NowInTimestamp(sample_rate_hz);
 
     if (IsCng(decoder->acm_codec_id)) {
       // If this is a CNG while the audio codec is not mono skip pushing in
       // packets into NetEq.
       if (last_audio_decoder_ && last_audio_decoder_->channels > 1)
         return 0;
       packet_type = InitialDelayManager::kCngPacket;
-    } else if (decoder->acm_codec_id == ACMCodecDB::kAVT) {
+    } else if (decoder->acm_codec_id ==
+               *RentACodec::CodecIndexFromId(RentACodec::CodecId::kAVT)) {
       packet_type = InitialDelayManager::kAvtPacket;
     } else {
       if (decoder != last_audio_decoder_) {
         // This is either the first audio packet or send codec is changed.
         // Therefore, either NetEq buffer is empty or will be flushed when this
         // packet is inserted.
         new_codec = true;
 
         // Updating NACK'sampling rate is required, either first packet is
         // received or codec is changed. Furthermore, reset is required if codec
@@ skipping 304 matching lines @@
   }
   return neteq_->GetPlayoutTimestamp(timestamp);
 }
 
 int AcmReceiver::last_audio_codec_id() const {
   CriticalSectionScoped lock(crit_sect_.get());
   return last_audio_decoder_ ? last_audio_decoder_->acm_codec_id : -1;
 }
 
 int AcmReceiver::RedPayloadType() const {
-  if (ACMCodecDB::kRED >= 0) {  // This ensures that RED is defined in WebRTC.
+  const auto red_index =
+      RentACodec::CodecIndexFromId(RentACodec::CodecId::kRED);
+  if (red_index) {
     CriticalSectionScoped lock(crit_sect_.get());
     for (const auto& decoder_pair : decoders_) {
       const Decoder& decoder = decoder_pair.second;
-      if (decoder.acm_codec_id == ACMCodecDB::kRED)
+      if (decoder.acm_codec_id == *red_index)
         return decoder.payload_type;
     }
   }
   LOG(WARNING) << "RED is not registered.";
   return -1;
 }
 
 int AcmReceiver::LastAudioCodec(CodecInst* codec) const {
   CriticalSectionScoped lock(crit_sect_.get());
   if (!last_audio_decoder_) {
@@ skipping 146 matching lines @@
   frame->vad_activity_ = AudioFrame::kVadPassive;
   size_t samples = frame->samples_per_channel_ * frame->num_channels_;
   memset(frame->data_, 0, samples * sizeof(int16_t));
   return true;
 }
 
 const AcmReceiver::Decoder* AcmReceiver::RtpHeaderToDecoder(
     const RTPHeader& rtp_header,
     const uint8_t* payload) const {
   auto it = decoders_.find(rtp_header.payloadType);
-  if (ACMCodecDB::kRED >= 0 &&  // This ensures that RED is defined in WebRTC.
-      it != decoders_.end() && ACMCodecDB::kRED == it->second.acm_codec_id) {
+  const auto red_index =
+      RentACodec::CodecIndexFromId(RentACodec::CodecId::kRED);
+  if (red_index &&  // This ensures that RED is defined in WebRTC.
+      it != decoders_.end() &&
+      it->second.acm_codec_id == *red_index) {
     // This is a RED packet, get the payload of the audio codec.
     it = decoders_.find(payload[0] & 0x7F);
   }
 
   // Check if the payload is registered.
   return it != decoders_.end() ? &it->second : nullptr;
 }
 
 uint32_t AcmReceiver::NowInTimestamp(int decoder_sampling_rate) const {
   // Down-cast the time to (32-6)-bit since we only care about
@@ skipping 25 matching lines @@
 
 void AcmReceiver::GetDecodingCallStatistics(
     AudioDecodingCallStats* stats) const {
   CriticalSectionScoped lock(crit_sect_.get());
   *stats = call_stats_.GetDecodingStatistics();
 }
 
 }  // namespace acm2
 
 }  // namespace webrtc