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 373 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 (audio_coding_->RegisterReceiveCodec(receiveCodec, [&] {
+        return rent_a_codec_.RentIsacDecoder();
+      }) == -1) {
     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 ||
+          audio_coding_->RegisterReceiveCodec(
+              codec, [&] { return rent_a_codec_.RentIsacDecoder(); }) == -1) {
         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_,
+                                      [&](std::unique_ptr<AudioEncoder> enc) {
+                                        audio_coding_->SetEncoder(
+                                            std::move(enc));
+                                      }) ||
+          audio_coding_->RegisterReceiveCodec(
+              codec, [&] { return rent_a_codec_.RentIsacDecoder(); }) == -1 ||
+          _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")) {
@@ skipping 196 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_, [&](std::unique_ptr<AudioEncoder> new_enc) {
+            audio_coding_->SetEncoder(std::move(new_enc));
+          })) {
     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.

[hlundin-webrtc, 2016/03/29 20:23:32]

Why did the assert have to go? The last parameter is still deprecated, and now
also unused. Maybe document it in the interface file (if you cannot remove the
parameter now).

[kwiberg-webrtc, 2016/03/29 23:25:32]

Good question. I remember removing it for a reason, but I can’t recall what
reason... I’ll restore it (as a DCHECK).

[hlundin-webrtc, 2016/03/30 08:36:10]

Good.

[kwiberg-webrtc, 2016/03/30 10:53:50]

Done.

-  // To disable VAD, DTX must be disabled too
-  disableDTX = ((enableVAD == false) ? true : disableDTX);
-  if (audio_coding_->SetVAD(!disableDTX, enableVAD, mode) != 0) {
+  if (!codec_manager_.SetVAD(enableVAD, mode) ||
+      !codec_manager_.MakeEncoder(
+          &rent_a_codec_, [&](std::unique_ptr<AudioEncoder> new_enc) {
+            audio_coding_->SetEncoder(std::move(new_enc));
+          })) {
     _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 42 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 (audio_coding_->RegisterReceiveCodec(codec) != 0) {
+  if (audio_coding_->RegisterReceiveCodec(

[hlundin-webrtc, 2016/03/29 20:23:32]

One could wonder if there is any valid case for registering a decoder with the
same RTP payload type as an already registered one that warrants this try-retry
construct. I could only come up with an historical reason, where we used to
allow registering CNG at different sample rates to one and the same payload
type. But that case should be no more.

[kwiberg-webrtc, 2016/03/29 23:25:32]

I don’t know of a valid case either.

[hlundin-webrtc, 2016/03/30 08:36:10]

Right. You may want to add a TODO that this is essentially the same that is done
in AcmReceiver::AddCodec. It's up to you.

[kwiberg-webrtc, 2016/03/30 10:53:50]

Done.

+          codec, [&] { return rent_a_codec_.RentIsacDecoder(); }) != 0) {
     audio_coding_->UnregisterReceiveCodec(codec.pltype);
-    if (audio_coding_->RegisterReceiveCodec(codec) != 0) {
+    if (audio_coding_->RegisterReceiveCodec(
+            codec, [&] { return rent_a_codec_.RentIsacDecoder(); }) != 0) {
       _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_,
+                                  [&](std::unique_ptr<AudioEncoder> enc) {
+                                    audio_coding_->SetEncoder(std::move(enc));
+                                  })) {
     _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) ||
+      !codec_manager_.MakeEncoder(
+          &rent_a_codec_, [&](std::unique_ptr<AudioEncoder> new_enc) {
+            audio_coding_->SetEncoder(std::move(new_enc));
+          })) {
     _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_, [&](std::unique_ptr<AudioEncoder> new_enc) {
+            audio_coding_->SetEncoder(std::move(new_enc));
+          })) {
     _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 521 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_, [&](std::unique_ptr<AudioEncoder> new_enc) {
+            audio_coding_->SetEncoder(std::move(new_enc));
+          })) {
     _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