Stop using old AudioCodingModule::RegisterReceiveCodec overloads

webrtc/voice_engine/channel.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.
  */
 
@@ skipping 30 matching lines @@
 #include "webrtc/voice_engine/utility.h"
 
 namespace webrtc {
 namespace voe {
 
 namespace {
 
 constexpr int64_t kMaxRetransmissionWindowMs = 1000;
 constexpr int64_t kMinRetransmissionWindowMs = 30;
 
-bool RegisterReceiveCodec(std::unique_ptr<AudioCodingModule>* acm,
-                          acm2::RentACodec* rac,
-                          const CodecInst& ci) {
-  const int result = (*acm)->RegisterReceiveCodec(
-      ci, [&] { return rac->RentIsacDecoder(ci.plfreq); });
-  return result == 0;
-}
-
 }  // namespace
 
 const int kTelephoneEventAttenuationdB = 10;
 
 class RtcEventLogProxy final : public webrtc::RtcEventLog {
  public:
   RtcEventLogProxy() : event_log_(nullptr) {}
 
   bool StartLogging(const std::string& file_name,
                     int64_t max_size_bytes) override {
@@ skipping 405 matching lines @@
   receiveCodec.pltype = payloadType;
   receiveCodec.plfreq = frequency;
   receiveCodec.channels = channels;
   receiveCodec.rate = rate;
   strncpy(receiveCodec.plname, payloadName, RTP_PAYLOAD_NAME_SIZE - 1);
 
   audio_coding_->Codec(payloadName, &dummyCodec, frequency, channels);
   receiveCodec.pacsize = dummyCodec.pacsize;
 
   // Register the new codec to the ACM
-  if (!RegisterReceiveCodec(&audio_coding_, &rent_a_codec_, receiveCodec)) {
+  if (!audio_coding_->RegisterReceiveCodec(receiveCodec.pltype,

[ossu, 2016/10/05 13:39:59]

Don't make a CodecInst just to convert it to an SdpAudioFormat.
I don't believe pacsize is at all used further on, so the call to
audio_coding_->Codec should be removed as well.

[kwiberg-webrtc, 2016/10/06 12:14:52]

The problem is that since the caller has given us the sample rate and the number
of channels, I need exactly the logic that's in CodecInstToSdp in order to fix
G722's clock rate and Opus's stereo parameter. The real solution is (probably)
to change the arguments so that the caller gives us an SdpAudioFormat instead,
but I wanted to do that in a separate CL. This one deals exclusively with
removing all callers of the old ACM::RegisterReceiveCodec methods.

+                                           CodecInstToSdp(receiveCodec))) {
     WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
                  "Channel::OnInitializeDecoder() invalid codec ("
                  "pt=%d, name=%s) received - 1",
                  payloadType, payloadName);
     _engineStatisticsPtr->SetLastError(VE_AUDIO_CODING_MODULE_ERROR);
     return -1;
   }
 
   return 0;
 }
@@ skipping 495 matching lines @@
     _engineStatisticsPtr->SetLastError(
         VE_CANNOT_INIT_CHANNEL, kTraceError,
         "Channel::Init() callbacks not registered");
     return -1;
   }
 
   // --- Register all supported codecs to the receiving side of the
   // RTP/RTCP module
 
   CodecInst codec;
   const uint8_t nSupportedCodecs = AudioCodingModule::NumberOfCodecs();

[ossu, 2016/10/05 13:39:58]

How should this be done now that there are two different sets of codecs? One
from a factory and one from AudioCodingModule? Do will still need to support
this default setup of registering everything? Oh, and I guess this is for both
receiving and sending?

[kwiberg-webrtc, 2016/10/06 12:14:52]

My thinking is that tests and stuff that want to iterate over "all" codecs
should ask the factory/-ies for the list of supported codecs (which is a thing
we intend to continue to support). The ACM methods that list codecs should be
removed when we no longer need them.

[ossu, 2016/10/21 12:24:05]

Acknowledged.

 
   for (int idx = 0; idx < nSupportedCodecs; idx++) {
     // Open up the RTP/RTCP receiver for all supported codecs
     if ((audio_coding_->Codec(idx, &codec) == -1) ||
         (rtp_receiver_->RegisterReceivePayload(
              codec.plname, codec.pltype, codec.plfreq, codec.channels,
              (codec.rate < 0) ? 0 : codec.rate) == -1)) {
       WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
                    "Channel::Init() unable to register %s "
                    "(%d/%d/%" PRIuS "/%d) to RTP/RTCP receiver",
                    codec.plname, codec.pltype, codec.plfreq, codec.channels,
                    codec.rate);
     } else {
       WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                    "Channel::Init() %s (%d/%d/%" PRIuS
                    "/%d) has been "
                    "added to the RTP/RTCP receiver",
                    codec.plname, codec.pltype, codec.plfreq, codec.channels,
                    codec.rate);
     }
 
     // Ensure that PCMU is used as default codec on the sending side
     if (!STR_CASE_CMP(codec.plname, "PCMU") && (codec.channels == 1)) {
       SetSendCodec(codec);
     }
 
     // Register default PT for outband 'telephone-event'
     if (!STR_CASE_CMP(codec.plname, "telephone-event")) {
       if (_rtpRtcpModule->RegisterSendPayload(codec) == -1 ||
-          !RegisterReceiveCodec(&audio_coding_, &rent_a_codec_, codec)) {
+          !audio_coding_->RegisterReceiveCodec(codec.pltype,
+                                               CodecInstToSdp(codec))) {
         WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
                      "Channel::Init() failed to register outband "
                      "'telephone-event' (%d/%d) correctly",
                      codec.pltype, codec.plfreq);
       }
     }
 
     if (!STR_CASE_CMP(codec.plname, "CN")) {
       if (!codec_manager_.RegisterEncoder(codec) ||
           !codec_manager_.MakeEncoder(&rent_a_codec_, audio_coding_.get()) ||
-          !RegisterReceiveCodec(&audio_coding_, &rent_a_codec_, codec) ||
+          !audio_coding_->RegisterReceiveCodec(codec.pltype,
+                                               CodecInstToSdp(codec)) ||
           _rtpRtcpModule->RegisterSendPayload(codec) == -1) {
         WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
                      "Channel::Init() failed to register CN (%d/%d) "
                      "correctly - 1",
                      codec.pltype, codec.plfreq);
       }
     }
   }
 
   return 0;
@@ skipping 328 matching lines @@
     rtp_receiver_->DeRegisterReceivePayload(codec.pltype);
     if (rtp_receiver_->RegisterReceivePayload(
             codec.plname, codec.pltype, codec.plfreq, codec.channels,
             (codec.rate < 0) ? 0 : codec.rate) != 0) {
       _engineStatisticsPtr->SetLastError(
           VE_RTP_RTCP_MODULE_ERROR, kTraceError,
           "SetRecPayloadType() RTP/RTCP-module registration failed");
       return -1;
     }
   }
-  if (!RegisterReceiveCodec(&audio_coding_, &rent_a_codec_, codec)) {
+  if (!audio_coding_->RegisterReceiveCodec(codec.pltype,
+                                           CodecInstToSdp(codec))) {
     audio_coding_->UnregisterReceiveCodec(codec.pltype);
-    if (!RegisterReceiveCodec(&audio_coding_, &rent_a_codec_, codec)) {
+    if (!audio_coding_->RegisterReceiveCodec(codec.pltype,
+                                             CodecInstToSdp(codec))) {
       _engineStatisticsPtr->SetLastError(
           VE_AUDIO_CODING_MODULE_ERROR, kTraceError,
           "SetRecPayloadType() ACM registration failed - 1");
       return -1;
     }
   }
   return 0;
 }
 
 int32_t Channel::GetRecPayloadType(CodecInst& codec) {
@@ skipping 1802 matching lines @@
   int64_t min_rtt = 0;
   if (_rtpRtcpModule->RTT(remoteSSRC, &rtt, &avg_rtt, &min_rtt, &max_rtt) !=
       0) {
     return 0;
   }
   return rtt;
 }
 
 }  // namespace voe
 }  // namespace webrtc