NetEq: Add codec name and RTP timestamp rate to 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 {
+namespace {
+// The codec names are taken from ACMCodecDB::database_.
+std::string CodecName(NetEqDecoder codec_type) {
+  switch (codec_type) {
+    case NetEqDecoder::kDecoderPCMu:
+    case NetEqDecoder::kDecoderPCMu_2ch:
+      return "PCMU";
+    case NetEqDecoder::kDecoderPCMa:
+    case NetEqDecoder::kDecoderPCMa_2ch:
+      return "PCMA";
+    case NetEqDecoder::kDecoderPCM16B:
+    case NetEqDecoder::kDecoderPCM16B_2ch:
+    case NetEqDecoder::kDecoderPCM16B_5ch:
+    case NetEqDecoder::kDecoderPCM16Bwb:
+    case NetEqDecoder::kDecoderPCM16Bwb_2ch:
+    case NetEqDecoder::kDecoderPCM16Bswb32kHz:
+    case NetEqDecoder::kDecoderPCM16Bswb32kHz_2ch:
+    case NetEqDecoder::kDecoderPCM16Bswb48kHz:
+    case NetEqDecoder::kDecoderPCM16Bswb48kHz_2ch:
+      return "L16";
+#ifdef WEBRTC_CODEC_G722
+    case NetEqDecoder::kDecoderG722:
+    case NetEqDecoder::kDecoderG722_2ch:
+      return "G722";
+#endif
+#ifdef WEBRTC_CODEC_ILBC
+    case NetEqDecoder::kDecoderILBC:
+      return "ILBC";
+#endif
+#if defined(WEBRTC_CODEC_ISACFX) || defined(WEBRTC_CODEC_ISAC)
+    case NetEqDecoder::kDecoderISAC:
+#ifdef WEBRTC_CODEC_ISAC
+    case NetEqDecoder::kDecoderISACswb:
+#endif
+      return "ISAC";
+#endif
+#ifdef WEBRTC_CODEC_OPUS
+    case NetEqDecoder::kDecoderOpus:
+    case NetEqDecoder::kDecoderOpus_2ch:
+      return "opus";
+#endif
+    case NetEqDecoder::kDecoderCNGnb:
+    case NetEqDecoder::kDecoderCNGwb:
+    case NetEqDecoder::kDecoderCNGswb32kHz:
+    case NetEqDecoder::kDecoderCNGswb48kHz:
+      return "CN";
+    case NetEqDecoder::kDecoderRED:
+      return "red";
+    case NetEqDecoder::kDecoderAVT:
+      return "telephone-event";
+    case NetEqDecoder::kDecoderArbitrary:
+      return "arbitrary";
+    default:
+      RTC_NOTREACHED();
+      return "unknown";
+  }
+}
+}  // namespace

[kwiberg-webrtc, 2015/12/02 09:50:42]

Should we standardize on either lower- or uppercase names? We currently do
case-insensitive comparisons everywhere, and it'd be nice not to.

[hlundin-webrtc, 2015/12/02 16:19:24]

Yes, we should. But no longer relevant for this CL.

 
 DecoderDatabase::DecoderDatabase()
     : active_decoder_(-1), active_cng_decoder_(-1) {}
 
 DecoderDatabase::~DecoderDatabase() {}
 
 DecoderDatabase::DecoderInfo::~DecoderInfo() {
   if (!external) delete decoder;
 }
 
 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) {
   if (rtp_payload_type > 0x7F) {
     return kInvalidRtpPayloadType;
   }
   if (!CodecSupported(codec_type)) {
     return kCodecNotSupported;
   }
-  int fs_hz = CodecSampleRateHz(codec_type);
-  std::pair<DecoderMap::iterator, bool> ret;
-  DecoderInfo info(codec_type, fs_hz, NULL, false);
-  ret = decoders_.insert(std::make_pair(rtp_payload_type, info));
+  const int fs_hz = CodecSampleRateHz(codec_type);
+  const std::string name = CodecName(codec_type);
+  DecoderInfo info(codec_type, name, fs_hz, NULL, false);
+  auto ret = decoders_.insert(std::make_pair(rtp_payload_type, 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, fs_hz, decoder, true);
+  DecoderInfo info(codec_type, codec_name, fs_hz, decoder, true);
   ret = decoders_.insert(std::make_pair(rtp_payload_type, 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) {
@@ skipping 164 matching lines @@
       LOG(LS_WARNING) << "CheckPayloadTypes: unknown RTP payload type "
                       << static_cast<int>((*it)->header.payloadType);
       return kDecoderNotFound;
     }
   }
   return kOK;
 }
 
 
 }  // namespace webrtc