Using Rent-A-Codec for static Codec access in WVoE/MC.

talk/media/webrtc/fakewebrtcvoiceengine.h

 /*
  * libjingle
  * Copyright 2010 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 23 matching lines @@
 
 #include "talk/media/base/codec.h"
 #include "talk/media/base/rtputils.h"
 #include "talk/media/webrtc/fakewebrtccommon.h"
 #include "talk/media/webrtc/webrtcvoe.h"
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/config.h"
+#include "webrtc/modules/audio_coding/main/acm2/rent_a_codec.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
 
 namespace cricket {
 
 static const char kFakeDefaultDeviceName[] = "Fake Default";
 static const int kFakeDefaultDeviceId = -1;
 static const char kFakeDeviceName[] = "Fake Device";
 #ifdef WIN32
 static const int kFakeDeviceId = 0;
 #else
 static const int kFakeDeviceId = 1;
 #endif
 
 static const int kOpusBandwidthNb = 4000;
 static const int kOpusBandwidthMb = 6000;
 static const int kOpusBandwidthWb = 8000;
 static const int kOpusBandwidthSwb = 12000;
 static const int kOpusBandwidthFb = 20000;
 
 #define WEBRTC_CHECK_CHANNEL(channel) \
   if (channels_.find(channel) == channels_.end()) return -1;
 
-#define WEBRTC_ASSERT_CHANNEL(channel) \
-  RTC_DCHECK(channels_.find(channel) != channels_.end());
-
-// Verify the header extension ID, if enabled, is within the bounds specified in
-// [RFC5285]: 1-14 inclusive.
-#define WEBRTC_CHECK_HEADER_EXTENSION_ID(enable, id) \
-  do { \
-    if (enable && (id < 1 || id > 14)) { \
-      return -1; \
-    } \
-  } while (0);
-
 class FakeAudioProcessing : public webrtc::AudioProcessing {
  public:
   FakeAudioProcessing() : experimental_ns_enabled_(false) {}
 
   WEBRTC_STUB(Initialize, ())
   WEBRTC_STUB(Initialize, (
       int input_sample_rate_hz,
       int output_sample_rate_hz,
       int reverse_sample_rate_hz,
       webrtc::AudioProcessing::ChannelLayout input_layout,
@@ skipping 124 matching lines @@
     int associate_send_channel;
     DtmfInfo dtmf_info;
     std::vector<webrtc::CodecInst> recv_codecs;
     webrtc::CodecInst send_codec;
     webrtc::PacketTime last_rtp_packet_time;
     std::list<std::string> packets;
     int neteq_capacity;
     bool neteq_fast_accelerate;
   };
 
-  FakeWebRtcVoiceEngine(const cricket::AudioCodec* const* codecs,
-                        int num_codecs)
+  FakeWebRtcVoiceEngine()
       : inited_(false),
         last_channel_(-1),
         fail_create_channel_(false),
-        codecs_(codecs),
-        num_codecs_(num_codecs),
         num_set_send_codecs_(0),
         ec_enabled_(false),
         ec_metrics_enabled_(false),
         cng_enabled_(false),
         ns_enabled_(false),
         agc_enabled_(false),
         highpass_filter_enabled_(false),
         stereo_swapping_enabled_(false),
         typing_detection_enabled_(false),
         ec_mode_(webrtc::kEcDefault),
         aecm_mode_(webrtc::kAecmSpeakerphone),
         ns_mode_(webrtc::kNsDefault),
         agc_mode_(webrtc::kAgcDefault),
         observer_(NULL),
         playout_fail_channel_(-1),
         send_fail_channel_(-1),
         recording_sample_rate_(-1),
         playout_sample_rate_(-1) {
     memset(&agc_config_, 0, sizeof(agc_config_));
   }
   ~FakeWebRtcVoiceEngine() {
-    // Ought to have all been deleted by the WebRtcVoiceMediaChannel
-    // destructors, but just in case ...
-    for (std::map<int, Channel*>::const_iterator i = channels_.begin();
-         i != channels_.end(); ++i) {
-      delete i->second;
-    }
+    RTC_CHECK(channels_.empty());
   }
 
   bool ec_metrics_enabled() const { return ec_metrics_enabled_; }
 
   bool IsInited() const { return inited_; }
   int GetLastChannel() const { return last_channel_; }
   int GetNumChannels() const { return static_cast<int>(channels_.size()); }
   uint32_t GetLocalSSRC(int channel) {
     return channels_[channel]->send_ssrc;
   }
@@ skipping 18 matching lines @@
   int GetMaxEncodingBandwidth(int channel) {
     return channels_[channel]->max_encoding_bandwidth;
   }
   bool GetNACK(int channel) {
     return channels_[channel]->nack;
   }
   int GetNACKMaxPackets(int channel) {
     return channels_[channel]->nack_max_packets;
   }
   const webrtc::PacketTime& GetLastRtpPacketTime(int channel) {
-    WEBRTC_ASSERT_CHANNEL(channel);
+    RTC_DCHECK(channels_.find(channel) != channels_.end());
     return channels_[channel]->last_rtp_packet_time;
   }
   int GetSendCNPayloadType(int channel, bool wideband) {
     return (wideband) ?
         channels_[channel]->cn16_type :
         channels_[channel]->cn8_type;
   }
   int GetSendTelephoneEventPayloadType(int channel) {
     return channels_[channel]->dtmf_type;
   }
@@ skipping 23 matching lines @@
     send_fail_channel_ = channel;
   }
   void set_fail_create_channel(bool fail_create_channel) {
     fail_create_channel_ = fail_create_channel;
   }
   int AddChannel(const webrtc::Config& config) {
     if (fail_create_channel_) {
       return -1;
     }
     Channel* ch = new Channel();
-    for (int i = 0; i < NumOfCodecs(); ++i) {
-      webrtc::CodecInst codec;
-      GetCodec(i, codec);
-      ch->recv_codecs.push_back(codec);
+    for (const webrtc::CodecInst& c : webrtc::acm2::RentACodec::Database()) {
+      ch->recv_codecs.push_back(c);

[kwiberg-webrtc, 2015/11/26 14:13:56]

auto db = webrtc::acm2::RentACodec::Database();
ch->recv_codecs.insert(ch->recv_codecs.end(), db.begin(), db.end());

or, if the vector is sure to be empty,

ch->recv_codecs.assign(db.begin(), db.end());

[the sun, 2015/11/26 14:27:20]

Done.

     }
     if (config.Get<webrtc::NetEqCapacityConfig>().enabled) {
       ch->neteq_capacity = config.Get<webrtc::NetEqCapacityConfig>().capacity;
     }
     ch->neteq_fast_accelerate =
         config.Get<webrtc::NetEqFastAccelerate>().enabled;
     channels_[++last_channel_] = ch;
     return last_channel_;
   }
 
@@ skipping 80 matching lines @@
   WEBRTC_STUB(LastError, ());
   WEBRTC_FUNC(AssociateSendChannel, (int channel,
                                      int accociate_send_channel)) {
     WEBRTC_CHECK_CHANNEL(channel);
     channels_[channel]->associate_send_channel = accociate_send_channel;
     return 0;
   }
   webrtc::RtcEventLog* GetEventLog() { return nullptr; }
 
   // webrtc::VoECodec
-  WEBRTC_FUNC(NumOfCodecs, ()) {
-    return num_codecs_;
-  }
-  WEBRTC_FUNC(GetCodec, (int index, webrtc::CodecInst& codec)) {
-    if (index < 0 || index >= NumOfCodecs()) {
-      return -1;
-    }
-    const cricket::AudioCodec& c(*codecs_[index]);
-    codec.pltype = c.id;
-    rtc::strcpyn(codec.plname, sizeof(codec.plname), c.name.c_str());
-    codec.plfreq = c.clockrate;
-    codec.pacsize = 0;
-    codec.channels = c.channels;
-    codec.rate = c.bitrate;
-    return 0;
-  }
+  WEBRTC_STUB(NumOfCodecs, ());
+  WEBRTC_STUB(GetCodec, (int index, webrtc::CodecInst& codec));
   WEBRTC_FUNC(SetSendCodec, (int channel, const webrtc::CodecInst& codec)) {
     WEBRTC_CHECK_CHANNEL(channel);
     // To match the behavior of the real implementation.
     if (_stricmp(codec.plname, "telephone-event") == 0 ||
         _stricmp(codec.plname, "audio/telephone-event") == 0 ||
         _stricmp(codec.plname, "CN") == 0 ||
         _stricmp(codec.plname, "red") == 0 ) {
       return -1;
     }
     channels_[channel]->send_codec = codec;
@@ skipping 17 matching lines @@
     if (codec.pltype != -1) {
       for (std::vector<webrtc::CodecInst>::iterator it =
           ch->recv_codecs.begin(); it != ch->recv_codecs.end(); ++it) {
         if (it->pltype == codec.pltype &&
             _stricmp(it->plname, codec.plname) != 0) {
           return -1;
         }
       }
     }
     // Otherwise try to find this codec and update its payload type.
+    int result = -1;  // not found
     for (std::vector<webrtc::CodecInst>::iterator it = ch->recv_codecs.begin();
          it != ch->recv_codecs.end(); ++it) {
       if (strcmp(it->plname, codec.plname) == 0 &&
-          it->plfreq == codec.plfreq) {
+          it->plfreq == codec.plfreq &&
+          it->channels == codec.channels) {
         it->pltype = codec.pltype;
-        it->channels = codec.channels;
-        return 0;
+        result = 0;
       }
     }
-    return -1;  // not found
+    return result;
   }
   WEBRTC_FUNC(SetSendCNPayloadType, (int channel, int type,
                                      webrtc::PayloadFrequencies frequency)) {
     WEBRTC_CHECK_CHANNEL(channel);
     if (frequency == webrtc::kFreq8000Hz) {
       channels_[channel]->cn8_type = type;
     } else if (frequency == webrtc::kFreq16000Hz) {
       channels_[channel]->cn16_type = type;
     }
     return 0;
@@ skipping 410 matching lines @@
 #endif
     strcpy(name, s);
     guid[0] = '\0';
     return 0;
   }
 
   bool inited_;
   int last_channel_;
   std::map<int, Channel*> channels_;
   bool fail_create_channel_;
-  const cricket::AudioCodec* const* codecs_;
-  int num_codecs_;
   int num_set_send_codecs_;  // how many times we call SetSendCodec().
   bool ec_enabled_;
   bool ec_metrics_enabled_;
   bool cng_enabled_;
   bool ns_enabled_;
   bool agc_enabled_;
   bool highpass_filter_enabled_;
   bool stereo_swapping_enabled_;
   bool typing_detection_enabled_;
   webrtc::EcModes ec_mode_;
   webrtc::AecmModes aecm_mode_;
   webrtc::NsModes ns_mode_;
   webrtc::AgcModes agc_mode_;
   webrtc::AgcConfig agc_config_;
   webrtc::VoiceEngineObserver* observer_;
   int playout_fail_channel_;
   int send_fail_channel_;
   int recording_sample_rate_;
   int playout_sample_rate_;
   DtmfInfo dtmf_info_;
   FakeAudioProcessing audio_processing_;
 };
 
-#undef WEBRTC_CHECK_HEADER_EXTENSION_ID
-
 }  // namespace cricket
 
 #endif  // TALK_SESSION_PHONE_FAKEWEBRTCVOICEENGINE_H_