Switch to using new ACM methods for encoder management

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 25 matching lines @@
 #include "webrtc/voice_engine/include/voe_external_media.h"
 #include "webrtc/voice_engine/include/voe_rtp_rtcp.h"
 #include "webrtc/voice_engine/output_mixer.h"
 #include "webrtc/voice_engine/statistics.h"
 #include "webrtc/voice_engine/transmit_mixer.h"
 #include "webrtc/voice_engine/utility.h"
 
 namespace webrtc {
 namespace voe {
 
+namespace {
+
+bool RegisterReceiveCodec(std::unique_ptr<AudioCodingModule>* acm,
+                          acm2::RentACodec* rac,
+                          const CodecInst& ci) {
+  const int result =
+      (*acm)->RegisterReceiveCodec(ci, [&] { return rac->RentIsacDecoder(); });
+  return result == 0;
+}
+
+}  // namespace
+
 const int kTelephoneEventAttenuationdB = 10;
 
 class TransportFeedbackProxy : public TransportFeedbackObserver {
  public:
   TransportFeedbackProxy() : feedback_observer_(nullptr) {
     pacer_thread_.DetachFromThread();
     network_thread_.DetachFromThread();
   }
 
   void SetTransportFeedbackObserver(
@@ skipping 328 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 (audio_coding_->RegisterReceiveCodec(receiveCodec) == -1) {
+  if (!RegisterReceiveCodec(&audio_coding_, &rent_a_codec_, 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 554 matching lines @@
                    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) ||
-          (audio_coding_->RegisterReceiveCodec(codec) == -1)) {
+      if (_rtpRtcpModule->RegisterSendPayload(codec) == -1 ||
+          !RegisterReceiveCodec(&audio_coding_, &rent_a_codec_, 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 ((audio_coding_->RegisterSendCodec(codec) == -1) ||
-          (audio_coding_->RegisterReceiveCodec(codec) == -1) ||
-          (_rtpRtcpModule->RegisterSendPayload(codec) == -1)) {
+      if (!codec_manager_.RegisterEncoder(codec) ||
+          !codec_manager_.MakeEncoder(&rent_a_codec_, audio_coding_.get()) ||
+          !RegisterReceiveCodec(&audio_coding_, &rent_a_codec_, 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);
       }
     }
 #ifdef WEBRTC_CODEC_RED
     // Register RED to the receiving side of the ACM.
     // We will not receive an OnInitializeDecoder() callback for RED.
     if (!STR_CASE_CMP(codec.plname, "RED")) {
-      if (audio_coding_->RegisterReceiveCodec(codec) == -1) {
+      if (!RegisterReceiveCodec(&audio_coding_, &rent_a_codec_, codec)) {
         WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
                      "Channel::Init() failed to register RED (%d/%d) "
                      "correctly",
                      codec.pltype, codec.plfreq);
       }
     }
 #endif
   }
 
   if (rx_audioproc_->noise_suppression()->set_level(kDefaultNsMode) != 0) {
@@ skipping 185 matching lines @@
     _engineStatisticsPtr->SetLastError(
         VE_INVALID_OPERATION, kTraceWarning,
         "DeRegisterVoiceEngineObserver() observer already disabled");
     return 0;
   }
   _voiceEngineObserverPtr = NULL;
   return 0;
 }
 
 int32_t Channel::GetSendCodec(CodecInst& codec) {
-  auto send_codec = audio_coding_->SendCodec();
+  auto send_codec = codec_manager_.GetCodecInst();
   if (send_codec) {
     codec = *send_codec;
     return 0;
   }
   return -1;
 }
 
 int32_t Channel::GetRecCodec(CodecInst& codec) {
   return (audio_coding_->ReceiveCodec(&codec));
 }
 
 int32_t Channel::SetSendCodec(const CodecInst& codec) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SetSendCodec()");
 
-  if (audio_coding_->RegisterSendCodec(codec) != 0) {
+  if (!codec_manager_.RegisterEncoder(codec) ||
+      !codec_manager_.MakeEncoder(&rent_a_codec_, audio_coding_.get())) {
     WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, _channelId),
                  "SetSendCodec() failed to register codec to ACM");
     return -1;
   }
 
   if (_rtpRtcpModule->RegisterSendPayload(codec) != 0) {
     _rtpRtcpModule->DeRegisterSendPayload(codec.pltype);
     if (_rtpRtcpModule->RegisterSendPayload(codec) != 0) {
       WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId, _channelId),
                    "SetSendCodec() failed to register codec to"
@@ skipping 26 matching lines @@
       0) {
     assert(false);  // This should not happen.
   }
 }
 
 int32_t Channel::SetVADStatus(bool enableVAD,
                               ACMVADMode mode,
                               bool disableDTX) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SetVADStatus(mode=%d)", mode);
-  assert(!(disableDTX && enableVAD));  // disableDTX mode is deprecated.
-  // To disable VAD, DTX must be disabled too
-  disableDTX = ((enableVAD == false) ? true : disableDTX);
-  if (audio_coding_->SetVAD(!disableDTX, enableVAD, mode) != 0) {
+  RTC_DCHECK(!(disableDTX && enableVAD));  // disableDTX mode is deprecated.
+  if (!codec_manager_.SetVAD(enableVAD, mode) ||
+      !codec_manager_.MakeEncoder(&rent_a_codec_, audio_coding_.get())) {
     _engineStatisticsPtr->SetLastError(VE_AUDIO_CODING_MODULE_ERROR,
                                        kTraceError,
                                        "SetVADStatus() failed to set VAD");
     return -1;
   }
   return 0;
 }
 
 int32_t Channel::GetVADStatus(bool& enabledVAD,
                               ACMVADMode& mode,
                               bool& disabledDTX) {
-  if (audio_coding_->VAD(&disabledDTX, &enabledVAD, &mode) != 0) {
-    _engineStatisticsPtr->SetLastError(
-        VE_AUDIO_CODING_MODULE_ERROR, kTraceError,
-        "GetVADStatus() failed to get VAD status");
-    return -1;
-  }
-  disabledDTX = !disabledDTX;
+  const auto* params = codec_manager_.GetStackParams();
+  enabledVAD = params->use_cng;
+  mode = params->vad_mode;
+  disabledDTX = !params->use_cng;
   return 0;
 }
 
 int32_t Channel::SetRecPayloadType(const CodecInst& codec) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SetRecPayloadType()");
 
   if (channel_state_.Get().playing) {
     _engineStatisticsPtr->SetLastError(
         VE_ALREADY_PLAYING, kTraceError,
@@ skipping 32 matching lines @@
           "SetRecPayloadType() ACM deregistration failed - 1");
       return -1;
     }
     return 0;
   }
 
   if (rtp_receiver_->RegisterReceivePayload(
           codec.plname, codec.pltype, codec.plfreq, codec.channels,
           (codec.rate < 0) ? 0 : codec.rate) != 0) {
     // First attempt to register failed => de-register and try again
+    // TODO(kwiberg): Retrying is probably not necessary, since
+    // AcmReceiver::AddCodec also retries.
     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 (audio_coding_->RegisterReceiveCodec(codec) != 0) {
+  if (!RegisterReceiveCodec(&audio_coding_, &rent_a_codec_, codec)) {
     audio_coding_->UnregisterReceiveCodec(codec.pltype);
-    if (audio_coding_->RegisterReceiveCodec(codec) != 0) {
+    if (!RegisterReceiveCodec(&audio_coding_, &rent_a_codec_, 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 26 matching lines @@
     _engineStatisticsPtr->SetLastError(
         VE_AUDIO_CODING_MODULE_ERROR, kTraceError,
         "SetSendCNPayloadType() failed to retrieve default CN codec "
         "settings");
     return -1;
   }
 
   // Modify the payload type (must be set to dynamic range)
   codec.pltype = type;
 
-  if (audio_coding_->RegisterSendCodec(codec) != 0) {
+  if (!codec_manager_.RegisterEncoder(codec) ||
+      !codec_manager_.MakeEncoder(&rent_a_codec_, audio_coding_.get())) {
     _engineStatisticsPtr->SetLastError(
         VE_AUDIO_CODING_MODULE_ERROR, kTraceError,
         "SetSendCNPayloadType() failed to register CN to ACM");
     return -1;
   }
 
   if (_rtpRtcpModule->RegisterSendPayload(codec) != 0) {
     _rtpRtcpModule->DeRegisterSendPayload(codec.pltype);
     if (_rtpRtcpModule->RegisterSendPayload(codec) != 0) {
       _engineStatisticsPtr->SetLastError(
@@ skipping 1442 matching lines @@
     }
 
     if (SetRedPayloadType(redPayloadtype) < 0) {
       _engineStatisticsPtr->SetLastError(
           VE_CODEC_ERROR, kTraceError,
           "SetSecondarySendCodec() Failed to register RED ACM");
       return -1;
     }
   }
 
-  if (audio_coding_->SetREDStatus(enable) != 0) {
+  if (!codec_manager_.SetCopyRed(enable) ||

[the sun, 2016/04/06 11:58:25]

Nit: should this be RED, not Red?

[kwiberg-webrtc, 2016/04/06 12:15:29]

Style guide says: "Prefer to capitalize acronyms as single words (i.e.
StartRpc(), not StartRPC())."

https://google.github.io/styleguide/cppguide.html#Function_Names

[the sun, 2016/04/06 13:05:59]

Thanks for looking that up for me! :)

Ok, then it is the other functions that should be renamed instead...

[kwiberg-webrtc, 2016/04/06 14:10:40]

It just says you should prefer it, not that you must always get what you want.
:-)

Seriously though, renaming them shouldn't be done in this CL, and since the
entire class is scheduled for a grisly end, I'd rather postpone the rename until
after that.

+      !codec_manager_.MakeEncoder(&rent_a_codec_, audio_coding_.get())) {
     _engineStatisticsPtr->SetLastError(
         VE_AUDIO_CODING_MODULE_ERROR, kTraceError,
         "SetREDStatus() failed to set RED state in the ACM");
     return -1;
   }
   return 0;
 }
 
 int Channel::GetREDStatus(bool& enabled, int& redPayloadtype) {
-  enabled = audio_coding_->REDStatus();
+  enabled = codec_manager_.GetStackParams()->use_red;
   if (enabled) {
     int8_t payloadType = 0;
     if (_rtpRtcpModule->SendREDPayloadType(&payloadType) != 0) {
       _engineStatisticsPtr->SetLastError(
           VE_RTP_RTCP_MODULE_ERROR, kTraceError,
           "GetREDStatus() failed to retrieve RED PT from RTP/RTCP "
           "module");
       return -1;
     }
     redPayloadtype = payloadType;
     return 0;
   }
   return 0;
 }
 
 int Channel::SetCodecFECStatus(bool enable) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SetCodecFECStatus()");
 
-  if (audio_coding_->SetCodecFEC(enable) != 0) {
+  if (!codec_manager_.SetCodecFEC(enable) ||
+      !codec_manager_.MakeEncoder(&rent_a_codec_, audio_coding_.get())) {
     _engineStatisticsPtr->SetLastError(
         VE_AUDIO_CODING_MODULE_ERROR, kTraceError,
         "SetCodecFECStatus() failed to set FEC state");
     return -1;
   }
   return 0;
 }
 
 bool Channel::GetCodecFECStatus() {
-  bool enabled = audio_coding_->CodecFEC();
-  return enabled;
+  return codec_manager_.GetStackParams()->use_codec_fec;
 }
 
 void Channel::SetNACKStatus(bool enable, int maxNumberOfPackets) {
   // None of these functions can fail.
   // If pacing is enabled we always store packets.
   if (!pacing_enabled_)
     _rtpRtcpModule->SetStorePacketsStatus(enable, maxNumberOfPackets);
   rtp_receive_statistics_->SetMaxReorderingThreshold(maxNumberOfPackets);
   rtp_receiver_->SetNACKStatus(enable ? kNackRtcp : kNackOff);
   if (enable)
@@ skipping 520 matching lines @@
   }
 
   if (!found_red) {
     _engineStatisticsPtr->SetLastError(
         VE_CODEC_ERROR, kTraceError,
         "SetRedPayloadType() RED is not supported");
     return -1;
   }
 
   codec.pltype = red_payload_type;
-  if (audio_coding_->RegisterSendCodec(codec) < 0) {
+  if (!codec_manager_.RegisterEncoder(codec) ||
+      !codec_manager_.MakeEncoder(&rent_a_codec_, audio_coding_.get())) {
     _engineStatisticsPtr->SetLastError(
         VE_AUDIO_CODING_MODULE_ERROR, kTraceError,
         "SetRedPayloadType() RED registration in ACM module failed");
     return -1;
   }
 
   if (_rtpRtcpModule->SetSendREDPayloadType(red_payload_type) != 0) {
     _engineStatisticsPtr->SetLastError(
         VE_RTP_RTCP_MODULE_ERROR, kTraceError,
         "SetRedPayloadType() RED registration in RTP/RTCP module failed");
@@ skipping 78 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