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) {
+    if (!*encoder) {
+      // There is no existing encoder.
+      return;
+    }
+    (*encoder)->OnReceivedTargetAudioBitrate(bitrate_bps);
+  });

[kwiberg-webrtc, 2016/10/06 09:46:13]

You can probably just do

  if (*encoder) {
    (*encoder)->OnReceivedTargetAudioBitrate(bitrate_bps);
  }

That !*encoder means we have no encoder is probably not that hard to guess.

[minyue-webrtc, 2016/10/11 09:00:22]

Done.

   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();
-
-  // 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) {
+      // There is no existing encoder.
+      return;
+    }
+    (*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) {
+      // There is no existing encoder.
+      return;
+    }
+    success = (*encoder)->EnableAudioNetworkAdaptor(config_string,
+                                                    Clock::GetRealTimeClock());
+  });
+  return success;
+}
+
+void Channel::DisableAudioNetworkAdaptor() {
+  audio_coding_->ModifyEncoder([&](std::unique_ptr<AudioEncoder>* encoder) {
+    if (!*encoder) {
+      // There is no existing encoder.
+      return;
+    }
+    (*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) {
+      // There is no existing encoder.
+      return;
+    }
+    (*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) {
+      // There is no existing encoder.
+      return;
+    }
+    (*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