Adding audio network adaptor to AudioEncoderOpus.

webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.cc

 /*
  *  Copyright (c) 2014 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.
  */
 
 #include "webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h"
 
 #include <algorithm>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/safe_conversions.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/audio_coding/codecs/opus/opus_interface.h"
+#include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
 
 namespace webrtc {
 
 namespace {
 
 const int kSampleRateHz = 48000;
 const int kMinBitrateBps = 500;
 const int kMaxBitrateBps = 512000;
 
 AudioEncoderOpus::Config CreateConfig(const CodecInst& codec_inst) {
@@ skipping 105 matching lines @@
 
 int AudioEncoderOpus::GetTargetBitrate() const {
   return config_.GetBitrateBps();
 }
 
 void AudioEncoderOpus::Reset() {
   RTC_CHECK(RecreateEncoderInstance(config_));
 }
 
 bool AudioEncoderOpus::SetFec(bool enable) {
-  auto conf = config_;
-  conf.fec_enabled = enable;
-  return RecreateEncoderInstance(conf);
+  if (enable) {
+    RTC_CHECK_EQ(0, WebRtcOpus_EnableFec(inst_));
+  } else {
+    RTC_CHECK_EQ(0, WebRtcOpus_DisableFec(inst_));
+  }
+  config_.fec_enabled = enable;
+  return true;
 }
 
 bool AudioEncoderOpus::SetDtx(bool enable) {
-  auto conf = config_;
-  conf.dtx_enabled = enable;
-  return RecreateEncoderInstance(conf);
+  if (enable) {
+    RTC_CHECK_EQ(0, WebRtcOpus_EnableDtx(inst_));
+  } else {
+    RTC_CHECK_EQ(0, WebRtcOpus_DisableDtx(inst_));
+  }
+  config_.dtx_enabled = enable;
+  return true;
 }
 
 bool AudioEncoderOpus::GetDtx() const {
   return config_.dtx_enabled;
 }
 
 bool AudioEncoderOpus::SetApplication(Application application) {
   auto conf = config_;
   switch (application) {
     case Application::kSpeech:
@@ skipping 22 matching lines @@
   }
 }
 
 void AudioEncoderOpus::SetTargetBitrate(int bits_per_second) {
   config_.bitrate_bps = rtc::Optional<int>(
       std::max(std::min(bits_per_second, kMaxBitrateBps), kMinBitrateBps));
   RTC_DCHECK(config_.IsOk());
   RTC_CHECK_EQ(0, WebRtcOpus_SetBitRate(inst_, config_.GetBitrateBps()));
 }
 
+void AudioEncoderOpus::OnReceivedUplinkBandwidth(int uplink_bandwidth_bps) {
+  if (!config_.audio_network_adaptor_enabled)
+    return;
+  RTC_DCHECK(audio_network_adaptor_);
+  audio_network_adaptor_->SetUplinkBandwidth(uplink_bandwidth_bps);
+  ApplyAudioNetworkAdaptor();
+}
+
+void AudioEncoderOpus::OnReceivedUplinkPacketLossFraction(float uplink_packet_loss_fraction) {
+  if (!config_.audio_network_adaptor_enabled)
+    return;
+  RTC_DCHECK(audio_network_adaptor_);
+  audio_network_adaptor_->SetUplinkPacketLossFraction(uplink_packet_loss_fraction);
+  ApplyAudioNetworkAdaptor();
+}
+
+void AudioEncoderOpus::OnReceivedTargetAudioBitrate(int target_audio_bitrate_bps) {
+  if (!config_.audio_network_adaptor_enabled)
+    return;
+  RTC_DCHECK(audio_network_adaptor_);
+//  audio_network_adaptor_->SetReceivedTargetAudioBitrate(uplink_bandwidth_bps);
+  ApplyAudioNetworkAdaptor();
+}
+
+void AudioEncoderOpus::OnReceivedRtt(int rtt_ms) {
+  if (!config_.audio_network_adaptor_enabled)
+    return;
+  RTC_DCHECK(audio_network_adaptor_);
+//  audio_network_adaptor_->SetRtt(rtt_ms);
+  ApplyAudioNetworkAdaptor();
+}
+
 AudioEncoder::EncodedInfo AudioEncoderOpus::EncodeImpl(
     uint32_t rtp_timestamp,
     rtc::ArrayView<const int16_t> audio,
     rtc::Buffer* encoded) {
 
   if (input_buffer_.empty())
     first_timestamp_in_buffer_ = rtp_timestamp;
 
   input_buffer_.insert(input_buffer_.end(), audio.cbegin(), audio.cend());
   if (input_buffer_.size() <
@@ skipping 14 matching lines @@
                                      config_.num_channels),
                 rtc::saturated_cast<int16_t>(max_encoded_bytes),
                 encoded.data());
 
             RTC_CHECK_GE(status, 0);  // Fails only if fed invalid data.
 
             return static_cast<size_t>(status);
           });
   input_buffer_.clear();
 
+  // Will use new packet size for next encoding.
+  config_.frame_size_ms = next_frame_size_ms_;
+
   info.encoded_timestamp = first_timestamp_in_buffer_;
   info.payload_type = config_.payload_type;
   info.send_even_if_empty = true;  // Allows Opus to send empty packets.
   info.speech = (info.encoded_bytes > 0);
   info.encoder_type = CodecType::kOpus;
   return info;
 }
 
 size_t AudioEncoderOpus::Num10msFramesPerPacket() const {
   return static_cast<size_t>(rtc::CheckedDivExact(config_.frame_size_ms, 10));
@@ skipping 19 matching lines @@
 bool AudioEncoderOpus::RecreateEncoderInstance(const Config& config) {
   if (!config.IsOk())
     return false;
   if (inst_)
     RTC_CHECK_EQ(0, WebRtcOpus_EncoderFree(inst_));
   input_buffer_.clear();
   input_buffer_.reserve(Num10msFramesPerPacket() * SamplesPer10msFrame());
   RTC_CHECK_EQ(0, WebRtcOpus_EncoderCreate(&inst_, config.num_channels,
                                            config.application));
   RTC_CHECK_EQ(0, WebRtcOpus_SetBitRate(inst_, config.GetBitrateBps()));
   if (config.fec_enabled) {

[michaelt, 2016/09/22 12:13:14]

Use new function to set FEC and DTX

[minyue-webrtc, 2016/09/27 08:30:36]

ok, will do

[minyue-webrtc, 2016/09/29 15:34:24]

I gave it a second thought, and feel that it may not read good if we do that.
since SetDtx/Fec is supposed to change |config_|, which will be overwritten
again on 328.

So we may need to differentiate before-|config_| setting of Dtx/Fec and
after-|config_|.

What may happen is that we do
AudioEncoderOpus::SetDtx(bool enable) {
  if (config_.dtx == enable)
    return;
  ...
}
to remove redundant calling. Then this will fail.

     RTC_CHECK_EQ(0, WebRtcOpus_EnableFec(inst_));
   } else {
     RTC_CHECK_EQ(0, WebRtcOpus_DisableFec(inst_));
   }
   RTC_CHECK_EQ(
       0, WebRtcOpus_SetMaxPlaybackRate(inst_, config.max_playback_rate_hz));
   RTC_CHECK_EQ(0, WebRtcOpus_SetComplexity(inst_, config.complexity));
   if (config.dtx_enabled) {
     RTC_CHECK_EQ(0, WebRtcOpus_EnableDtx(inst_));
   } else {
     RTC_CHECK_EQ(0, WebRtcOpus_DisableDtx(inst_));
   }
   RTC_CHECK_EQ(0,
                WebRtcOpus_SetPacketLossRate(
                    inst_, static_cast<int32_t>(packet_loss_rate_ * 100 + .5)));
   config_ = config;
+
+  num_channels_to_encode_ = 0;  // Opus automatic mode.

[michaelt, 2016/09/22 12:13:14]

I think we should create a enum class for num_channels_to_encode

[minyue-webrtc, 2016/09/27 08:30:36]

I think we should not use "0", since audio network adaptor does not understand
zero. We can simply initialize num_channels_to_encode_ = config.num_channels

+  next_frame_size_ms_ = config_.frame_size_ms;
+  if (config_.audio_network_adaptor_enabled) {
+    // TODO(minyue): Create AudioNetworkAdaptorImpl.
+  }
   return true;
 }
 
+void AudioEncoderOpus::SetFrameLength(int frame_length_ms) {
+  next_frame_size_ms_ = frame_length_ms;
+}
+
+void AudioEncoderOpus::SetNumChannelsToEncode(size_t num_channels_to_encode) {
+  RTC_DCHECK_GT(num_channels_to_encode, 0u);
+  RTC_DCHECK_LE(num_channels_to_encode, config_.num_channels);
+
+  if (num_channels_to_encode_ == num_channels_to_encode)
+    return;
+
+//  RTC_CHECK_EQ(0, WebRtcOpus_SetForceChannels(inst_, num_channels_to_encode));
+  num_channels_to_encode_ = num_channels_to_encode;
+}
+
+void AudioEncoderOpus::ApplyAudioNetworkAdaptor() {
+  auto config = audio_network_adaptor_->GetEncoderRuntimeConfig();
+
+  RTC_DCHECK(config.bitrate_bps && config.frame_length_ms &&
+             config.uplink_packet_loss_fraction && config.enable_fec &&
+             config.enable_dtx);
+  RTC_DCHECK(*config.frame_length_ms == 20 || *config.frame_length_ms == 60);
+
+  SetTargetBitrate(*config.bitrate_bps);
+  SetFrameLength(*config.frame_length_ms);
+  SetFec(*config.enable_fec);
+  SetProjectedPacketLossRate(*config.uplink_packet_loss_fraction);
+  SetDtx(*config.enable_dtx);
+  SetNumChannelsToEncode(*config.num_channels);
+}
+
 }  // namespace webrtc