Revert of AcmReceiver: Look up last decoder in NetEq's table of decoders

webrtc/modules/audio_coding/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 14 matching lines @@
 #include "webrtc/modules/audio_coding/acm2/acm_resampler.h"
 #include "webrtc/modules/audio_coding/acm2/call_statistics.h"
 #include "webrtc/modules/audio_coding/neteq/include/neteq.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/trace.h"
 
 namespace webrtc {
 
 namespace acm2 {
 
+namespace {
+
+// Is the given codec a CNG codec?
+// TODO(kwiberg): Move to RentACodec.
+bool IsCng(int codec_id) {
+  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)
-    : last_audio_buffer_(new int16_t[AudioFrame::kMaxDataSizeSamples]),
+    : last_audio_decoder_(nullptr),
+      last_audio_buffer_(new int16_t[AudioFrame::kMaxDataSizeSamples]),
       neteq_(NetEq::Create(config.neteq_config, config.decoder_factory)),
       clock_(config.clock),
       resampled_last_output_frame_(true) {
   assert(clock_);
   memset(last_audio_buffer_.get(), 0, AudioFrame::kMaxDataSizeSamples);
 }
 
 AcmReceiver::~AcmReceiver() {
   delete neteq_;
 }
@@ skipping 26 matching lines @@
 }
 
 int AcmReceiver::InsertPacket(const WebRtcRTPHeader& rtp_header,
                               rtc::ArrayView<const uint8_t> incoming_payload) {
   uint32_t receive_timestamp = 0;
   const RTPHeader* header = &rtp_header.header;  // Just a shorthand.
 
   {
     rtc::CritScope lock(&crit_sect_);
 
-    const rtc::Optional<CodecInst> ci =
-        RtpHeaderToDecoder(*header, incoming_payload[0]);
-    if (!ci) {
+    const Decoder* decoder = RtpHeaderToDecoder(*header, incoming_payload[0]);
+    if (!decoder) {
       LOG_F(LS_ERROR) << "Payload-type "
                       << static_cast<int>(header->payloadType)
                       << " is not registered.";
       return -1;
     }
-    receive_timestamp = NowInTimestamp(ci->plfreq);
+    const int sample_rate_hz = [&decoder] {
+      const auto ci = RentACodec::CodecIdFromIndex(decoder->acm_codec_id);
+      return ci ? RentACodec::CodecInstById(*ci)->plfreq : -1;
+    }();
+    receive_timestamp = NowInTimestamp(sample_rate_hz);
 
-    if (STR_CASE_CMP(ci->plname, "cn") == 0) {
-      if (last_audio_decoder_ && last_audio_decoder_->channels > 1) {
-        // This is a CNG and the audio codec is not mono, so skip pushing in
-        // packets into NetEq.
+    // If this is a CNG while the audio codec is not mono, skip pushing in
+    // packets into NetEq.
+    if (IsCng(decoder->acm_codec_id) && last_audio_decoder_ &&
+        last_audio_decoder_->channels > 1)
         return 0;
-      }
-    } else {
-      last_audio_decoder_ = ci;
-      last_packet_sample_rate_hz_ = rtc::Optional<int>(ci->plfreq);
+    if (!IsCng(decoder->acm_codec_id) &&
+        decoder->acm_codec_id !=
+            *RentACodec::CodecIndexFromId(RentACodec::CodecId::kAVT)) {
+      last_audio_decoder_ = decoder;
+      last_packet_sample_rate_hz_ = rtc::Optional<int>(decoder->sample_rate_hz);
     }
 
   }  // |crit_sect_| is released.
 
   if (neteq_->InsertPacket(rtp_header, incoming_payload, receive_timestamp) <
       0) {
     LOG(LERROR) << "AcmReceiver::InsertPacket "
                 << static_cast<int>(header->payloadType)
                 << " Failed to insert packet";
     return -1;
@@ skipping 144 matching lines @@
     if (neteq_->RemovePayloadType(cur->second.payload_type) == 0) {
       decoders_.erase(cur);
     } else {
       LOG_F(LS_ERROR) << "Cannot remove payload "
                       << static_cast<int>(cur->second.payload_type);
       ret_val = -1;
     }
   }
 
   // No codec is registered, invalidate last audio decoder.
-  last_audio_decoder_ = rtc::Optional<CodecInst>();
+  last_audio_decoder_ = nullptr;
   last_packet_sample_rate_hz_ = rtc::Optional<int>();
   return ret_val;
 }
 
 int AcmReceiver::RemoveCodec(uint8_t payload_type) {
   rtc::CritScope lock(&crit_sect_);
   auto it = decoders_.find(payload_type);
   if (it == decoders_.end()) {  // Such a payload-type is not registered.
     return 0;
   }
   if (neteq_->RemovePayloadType(payload_type) != NetEq::kOK) {
     LOG(LERROR) << "AcmReceiver::RemoveCodec" << static_cast<int>(payload_type);
     return -1;
   }
-  if (last_audio_decoder_ && payload_type == last_audio_decoder_->pltype) {
-    last_audio_decoder_ = rtc::Optional<CodecInst>();
+  if (last_audio_decoder_ == &it->second) {
+    last_audio_decoder_ = nullptr;
     last_packet_sample_rate_hz_ = rtc::Optional<int>();
   }
   decoders_.erase(it);
   return 0;
 }
 
 rtc::Optional<uint32_t> AcmReceiver::GetPlayoutTimestamp() {
   return neteq_->GetPlayoutTimestamp();
 }
 
 int AcmReceiver::FilteredCurrentDelayMs() const {
   return neteq_->FilteredCurrentDelayMs();
 }
 
 int AcmReceiver::LastAudioCodec(CodecInst* codec) const {
   rtc::CritScope lock(&crit_sect_);
   if (!last_audio_decoder_) {
     return -1;
   }
-  *codec = *last_audio_decoder_;
+  *codec = *RentACodec::CodecInstById(
+      *RentACodec::CodecIdFromIndex(last_audio_decoder_->acm_codec_id));
+  codec->pltype = last_audio_decoder_->payload_type;
+  codec->channels = last_audio_decoder_->channels;
+  codec->plfreq = last_audio_decoder_->sample_rate_hz;
   return 0;
 }
 
 void AcmReceiver::GetNetworkStatistics(NetworkStatistics* acm_stat) {
   NetEqNetworkStatistics neteq_stat;
   // NetEq function always returns zero, so we don't check the return value.
   neteq_->NetworkStatistics(&neteq_stat);
 
   acm_stat->currentBufferSize = neteq_stat.current_buffer_size_ms;
   acm_stat->preferredBufferSize = neteq_stat.preferred_buffer_size_ms;
@@ skipping 43 matching lines @@
 std::vector<uint16_t> AcmReceiver::GetNackList(
     int64_t round_trip_time_ms) const {
   return neteq_->GetNackList(round_trip_time_ms);
 }
 
 void AcmReceiver::ResetInitialDelay() {
   neteq_->SetMinimumDelay(0);
   // TODO(turajs): Should NetEq Buffer be flushed?
 }
 
-const rtc::Optional<CodecInst> AcmReceiver::RtpHeaderToDecoder(
+const AcmReceiver::Decoder* AcmReceiver::RtpHeaderToDecoder(
     const RTPHeader& rtp_header,
     uint8_t payload_type) const {
-  const rtc::Optional<CodecInst> ci =
-      neteq_->GetDecoder(rtp_header.payloadType);
-  if (ci && STR_CASE_CMP(ci->plname, "red") == 0) {
-    // This is a RED packet. Get the payload of the audio codec.
-    return neteq_->GetDecoder(payload_type & 0x7f);
-  } else {
-    return ci;
+  auto it = decoders_.find(rtp_header.payloadType);
+  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_type & 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
   // the least significant bits. (32-6) bits cover 2^(32-6) = 67108864 ms.
   // We masked 6 most significant bits of 32-bit so there is no overflow in
   // the conversion from milliseconds to timestamp.
   const uint32_t now_in_ms = static_cast<uint32_t>(
       clock_->TimeInMilliseconds() & 0x03ffffff);
   return static_cast<uint32_t>(
       (decoder_sampling_rate / 1000) * now_in_ms);
 }
 
 void AcmReceiver::GetDecodingCallStatistics(
     AudioDecodingCallStats* stats) const {
   rtc::CritScope lock(&crit_sect_);
   *stats = call_stats_.GetDecodingStatistics();
 }
 
 }  // namespace acm2
 
 }  // namespace webrtc