Revert of WebRtcVoiceEngine: Use AudioDecoderFactory to generate recv codecs.

webrtc/media/engine/webrtcvoiceengine.cc

 /*
  *  Copyright (c) 2004 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.
  */
 
 #ifdef HAVE_WEBRTC_VOICE
 
 #include "webrtc/media/engine/webrtcvoiceengine.h"
 
 #include <algorithm>
 #include <cstdio>
-#include <functional>
 #include <string>
 #include <vector>
 
 #include "webrtc/audio_sink.h"
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/base64.h"
 #include "webrtc/base/byteorder.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/common.h"
 #include "webrtc/media/base/audiosource.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/media/base/streamparams.h"
-#include "webrtc/media/engine/payload_type_mapper.h"
 #include "webrtc/media/engine/webrtcmediaengine.h"
 #include "webrtc/media/engine/webrtcvoe.h"
 #include "webrtc/modules/audio_coding/acm2/rent_a_codec.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 #include "webrtc/system_wrappers/include/trace.h"
 
 namespace cricket {
 namespace {
 
@@ skipping 196 matching lines @@
 webrtc::AudioState::Config MakeAudioStateConfig(VoEWrapper* voe_wrapper) {
   webrtc::AudioState::Config config;
   config.voice_engine = voe_wrapper->engine();
   return config;
 }
 
 class WebRtcVoiceCodecs final {
  public:
   // TODO(solenberg): Do this filtering once off-line, add a simple AudioCodec
   // list and add a test which verifies VoE supports the listed codecs.
-  static std::vector<AudioCodec> SupportedSendCodecs() {
+  static std::vector<AudioCodec> SupportedCodecs() {
     std::vector<AudioCodec> result;
     // Iterate first over our preferred codecs list, so that the results are
     // added in order of preference.
     for (size_t i = 0; i < arraysize(kCodecPrefs); ++i) {
       const CodecPref* pref = &kCodecPrefs[i];
       for (webrtc::CodecInst voe_codec : webrtc::acm2::RentACodec::Database()) {
         // Change the sample rate of G722 to 8000 to match SDP.
         MaybeFixupG722(&voe_codec, 8000);
         // Skip uncompressed formats.
         if (IsCodec(voe_codec, kL16CodecName)) {
@@ skipping 242 matching lines @@
 }
 
 WebRtcVoiceEngine::WebRtcVoiceEngine(
     webrtc::AudioDeviceModule* adm,
     const rtc::scoped_refptr<webrtc::AudioDecoderFactory>& decoder_factory,
     VoEWrapper* voe_wrapper)
     : adm_(adm), decoder_factory_(decoder_factory), voe_wrapper_(voe_wrapper) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   LOG(LS_INFO) << "WebRtcVoiceEngine::WebRtcVoiceEngine";
   RTC_DCHECK(voe_wrapper);
-  RTC_DCHECK(decoder_factory);
 
   signal_thread_checker_.DetachFromThread();
 
   // Load our audio codec list.
-  LOG(LS_INFO) << "Supported send codecs in order of preference:";
-  send_codecs_ = WebRtcVoiceCodecs::SupportedSendCodecs();
-  for (const AudioCodec& codec : send_codecs_) {
+  LOG(LS_INFO) << "Supported codecs in order of preference:";
+  codecs_ = WebRtcVoiceCodecs::SupportedCodecs();
+  for (const AudioCodec& codec : codecs_) {
     LOG(LS_INFO) << ToString(codec);
   }
 
-  LOG(LS_INFO) << "Supported recv codecs in order of preference:";
-  recv_codecs_ = CollectRecvCodecs();
-  for (const AudioCodec& codec : recv_codecs_) {
-    LOG(LS_INFO) << ToString(codec);
-  }
-
   voe_config_.Set<webrtc::VoicePacing>(new webrtc::VoicePacing(true));
 
   // Temporarily turn logging level up for the Init() call.
   webrtc::Trace::SetTraceCallback(this);
   webrtc::Trace::set_level_filter(kElevatedTraceFilter);
   LOG(LS_INFO) << webrtc::VoiceEngine::GetVersionString();
   RTC_CHECK_EQ(0, voe_wrapper_->base()->Init(adm_.get(), nullptr,
                                              decoder_factory_));
   webrtc::Trace::set_level_filter(kDefaultTraceFilter);
 
@@ skipping 395 matching lines @@
 
 int WebRtcVoiceEngine::GetInputLevel() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   unsigned int ulevel;
   return (voe_wrapper_->volume()->GetSpeechInputLevel(ulevel) != -1) ?
       static_cast<int>(ulevel) : -1;
 }
 
 const std::vector<AudioCodec>& WebRtcVoiceEngine::send_codecs() const {
   RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
-  return send_codecs_;
+  return codecs_;
 }
 
 const std::vector<AudioCodec>& WebRtcVoiceEngine::recv_codecs() const {
   RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
-  return recv_codecs_;
+  return codecs_;
 }
 
 RtpCapabilities WebRtcVoiceEngine::GetCapabilities() const {
   RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
   RtpCapabilities capabilities;
   capabilities.header_extensions.push_back(
       webrtc::RtpExtension(webrtc::RtpExtension::kAudioLevelUri,
                            webrtc::RtpExtension::kAudioLevelDefaultId));
   capabilities.header_extensions.push_back(
       webrtc::RtpExtension(webrtc::RtpExtension::kAbsSendTimeUri,
@@ skipping 119 matching lines @@
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   return voe_wrapper_->base()->CreateChannel(voe_config_);
 }
 
 webrtc::AudioDeviceModule* WebRtcVoiceEngine::adm() {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   RTC_DCHECK(adm_);
   return adm_;
 }
 
-AudioCodecs WebRtcVoiceEngine::CollectRecvCodecs() const {
-  PayloadTypeMapper mapper;
-  AudioCodecs out;
-  const std::vector<webrtc::SdpAudioFormat>& formats =
-      decoder_factory_->GetSupportedFormats();
-
-  // Only generate CN payload types for these clockrates
-  std::map<int, bool, std::greater<int>> generate_cn = {{ 8000,  false },
-                                                        { 16000, false },
-                                                        { 32000, false }};
-
-  auto map_format = [&mapper, &out] (const webrtc::SdpAudioFormat& format) {
-    rtc::Optional<AudioCodec> opt_codec = mapper.ToAudioCodec(format);
-    if (!opt_codec) {
-      LOG(LS_ERROR) << "Unable to assign payload type to format: " << format;
-      return false;
-    }
-
-    auto& codec = *opt_codec;
-    if (IsCodec(codec, kOpusCodecName)) {
-      // TODO(ossu): Set this specifically for Opus for now, until we have a
-      // better way of dealing with rtcp-fb parameters.
-      codec.AddFeedbackParam(
-          FeedbackParam(kRtcpFbParamTransportCc, kParamValueEmpty));
-    }
-    out.push_back(codec);
-    return true;
-  };
-
-  for (const auto& format : formats) {
-    if (map_format(format)) {
-      // TODO(ossu): We should get more than just a format from the factory, so
-      // we can determine if a format should be used with CN or not. For now,
-      // generate a CN entry for each supported clock rate also used by a format
-      // supported by the factory.
-      auto cn = generate_cn.find(format.clockrate_hz);
-      if (cn != generate_cn.end() /* && format.allow_comfort_noise */) {
-        cn->second = true;
-      }
-    }
-  }
-
-  // Add CN codecs after "proper" audio codecs
-  for (const auto& cn : generate_cn) {
-    if (cn.second) {
-      map_format({kCnCodecName, cn.first, 1});
-    }
-  }
-
-  // Add telephone-event codec last
-  map_format({kDtmfCodecName, 8000, 1});
-
-  return out;
-}
-
 class WebRtcVoiceMediaChannel::WebRtcAudioSendStream
     : public AudioSource::Sink {
  public:
   WebRtcAudioSendStream(int ch,
                         webrtc::AudioTransport* voe_audio_transport,
                         uint32_t ssrc,
                         const std::string& c_name,
                         const SendCodecSpec& send_codec_spec,
                         const std::vector<webrtc::RtpExtension>& extensions,
                         webrtc::Call* call,
@@ skipping 1522 matching lines @@
     }
   } else {
     LOG(LS_INFO) << "Stopping playout for channel #" << channel;
     engine()->voe()->base()->StopPlayout(channel);
   }
   return true;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE