Hooking up audio network adaptor to VoE.

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 1267 matching lines @@
                  "SetSendCodec() failed to set audio packet size");
     return -1;
   }
 
   return 0;
 }
 
 void Channel::SetBitRate(int bitrate_bps) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SetBitRate(bitrate_bps=%d)", bitrate_bps);
-  audio_coding_->SetBitRate(bitrate_bps);
+  audio_coding_->ModifyEncoder([&](std::unique_ptr<AudioEncoder>* encoder) {

[michaelt, 2016/10/11 11:38:40]

Have you done a real call with this ?
ModifyEncoder will destroy the encoder_factory. So we have to be sure that all
actions with the encoder_factory are done before we call ModifyEncoder.

[minyue-webrtc, 2016/10/11 11:59:21]

I think this should work. But thank you for bring it up. I will try it.

+    if (*encoder)
+      (*encoder)->OnReceivedTargetAudioBitrate(bitrate_bps);
+  });
   retransmission_rate_limiter_->SetMaxRate(bitrate_bps);
 }
 
 void Channel::OnIncomingFractionLoss(int fraction_lost) {
   network_predictor_->UpdatePacketLossRate(fraction_lost);
   uint8_t average_fraction_loss = network_predictor_->GetLossRate();

[michaelt, 2016/10/11 11:38:40]

shouldn't we remove this double smoothing for ANA ?

[minyue-webrtc, 2016/10/11 11:59:21]

Good question. Now the forking between using old SetPacketLossRate or
AudioNetworkAdaptor is done within OnReceivedUplinkPacketLossFraction, which
makes much better sense.

I think OnReceivedUplinkPacketLossFraction is supposed to receive non-filtered
packet loss fractions. Any filtering is encoder's responsibility.

I will add another patch set to move |network_predictor_| to AudioEncoderOpus.
WDYT? 

[michaelt, 2016/10/11 12:27:23]

Moving |network_predictor_| to the encoder and smooth PL in the case we don't
use ANA seams OK for the moment. We me move in future to make ANA not optional.
In this case we could remove |network_predictor_| and let ANA care of the
smoothing. 

-
-  // Normalizes rate to 0 - 100.
-  if (audio_coding_->SetPacketLossRate(100 * average_fraction_loss / 255) !=
-      0) {
-    assert(false);  // This should not happen.
-  }
+  audio_coding_->ModifyEncoder([&](std::unique_ptr<AudioEncoder>* encoder) {
+    if (*encoder) {
+      (*encoder)->OnReceivedUplinkPacketLossFraction(average_fraction_loss /
+                                                     255.0f);
+    }
+  });
 }
 
 int32_t Channel::SetVADStatus(bool enableVAD,
                               ACMVADMode mode,
                               bool disableDTX) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SetVADStatus(mode=%d)", mode);
   RTC_DCHECK(!(disableDTX && enableVAD));  // disableDTX mode is deprecated.
   if (!codec_manager_.SetVAD(enableVAD, mode) ||
       !codec_manager_.MakeEncoder(&rent_a_codec_, audio_coding_.get())) {
@@ skipping 176 matching lines @@
   int success = -1;
   audio_coding_->QueryEncoder([&](AudioEncoder const* encoder) {
     if (encoder) {
       *enabled = encoder->GetDtx();
       success = 0;
     }
   });
   return success;
 }
 
+bool Channel::EnableAudioNetworkAdaptor(const std::string& config_string) {
+  bool success = false;
+  audio_coding_->ModifyEncoder([&](std::unique_ptr<AudioEncoder>* encoder) {
+    if (*encoder) {
+      success = (*encoder)->EnableAudioNetworkAdaptor(
+          config_string, Clock::GetRealTimeClock());
+    }
+  });
+  return success;
+}
+
+void Channel::DisableAudioNetworkAdaptor() {
+  audio_coding_->ModifyEncoder([&](std::unique_ptr<AudioEncoder>* encoder) {
+    if (*encoder)
+      (*encoder)->DisableAudioNetworkAdaptor();
+  });
+}
+
+void Channel::SetReceiverFrameLengthRange(int min_frame_length_ms,
+                                          int max_frame_length_ms) {
+  audio_coding_->ModifyEncoder([&](std::unique_ptr<AudioEncoder>* encoder) {
+    if (*encoder) {
+      (*encoder)->SetReceiverFrameLengthRange(min_frame_length_ms,
+                                              max_frame_length_ms);
+    }
+  });
+}
+
 int32_t Channel::RegisterExternalTransport(Transport* transport) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::RegisterExternalTransport()");
 
   rtc::CritScope cs(&_callbackCritSect);
   if (_externalTransport) {
     _engineStatisticsPtr->SetLastError(
         VE_INVALID_OPERATION, kTraceError,
         "RegisterExternalTransport() external transport already enabled");
     return -1;
@@ skipping 140 matching lines @@
   }
 
   int64_t nack_window_ms = rtt;
   if (nack_window_ms < kMinRetransmissionWindowMs) {
     nack_window_ms = kMinRetransmissionWindowMs;
   } else if (nack_window_ms > kMaxRetransmissionWindowMs) {
     nack_window_ms = kMaxRetransmissionWindowMs;
   }
   retransmission_rate_limiter_->SetWindowSize(nack_window_ms);
 
+  // Invoke audio encoders OnReceivedRtt().
+  audio_coding_->ModifyEncoder([&](std::unique_ptr<AudioEncoder>* encoder) {
+    if (*encoder)
+      (*encoder)->OnReceivedRtt(rtt);
+  });
+
   uint32_t ntp_secs = 0;
   uint32_t ntp_frac = 0;
   uint32_t rtp_timestamp = 0;
   if (0 !=
       _rtpRtcpModule->RemoteNTP(&ntp_secs, &ntp_frac, NULL, NULL,
                                 &rtp_timestamp)) {
     // Waiting for RTCP.
     return 0;
   }
 
@@ skipping 1538 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