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.
  */
 
@@ skipping 15 matching lines @@
 const int kMaxBitrateBps = 512000;
 
 AudioEncoderOpus::Config CreateConfig(const CodecInst& codec_inst) {
   AudioEncoderOpus::Config config;
   config.frame_size_ms = rtc::CheckedDivExact(codec_inst.pacsize, 48);
   config.num_channels = codec_inst.channels;
   config.bitrate_bps = rtc::Optional<int>(codec_inst.rate);
   config.payload_type = codec_inst.pltype;
   config.application = config.num_channels == 1 ? AudioEncoderOpus::kVoip
                                                 : AudioEncoderOpus::kAudio;
+  config.audio_network_adaptor_enabled = false;
   return config;
 }
 
 // Optimize the loss rate to configure Opus. Basically, optimized loss rate is
 // the input loss rate rounded down to various levels, because a robustly good
 // audio quality is achieved by lowering the packet loss down.
 // Additionally, to prevent toggling, margins are used, i.e., when jumping to
 // a loss rate from below, a higher threshold is used than jumping to the same
 // level from above.
 double OptimizePacketLossRate(double new_loss_rate, double old_loss_rate) {
@@ skipping 51 matching lines @@
 }
 
 int AudioEncoderOpus::Config::GetBitrateBps() const {
   RTC_DCHECK(IsOk());
   if (bitrate_bps)
     return *bitrate_bps;  // Explicitly set value.
   else
     return num_channels == 1 ? 32000 : 64000;  // Default value.
 }
 
-AudioEncoderOpus::AudioEncoderOpus(const Config& config)
-    : packet_loss_rate_(0.0), inst_(nullptr) {
+AudioEncoderOpus::AudioEncoderOpus(
+    const Config& config,
+    std::unique_ptr<AudioNetworkAdaptor> audio_network_adaptor)
+    : packet_loss_rate_(0.0),
+      inst_(nullptr),
+      audio_network_adaptor_(std::move(audio_network_adaptor)) {
   RTC_CHECK(RecreateEncoderInstance(config));
 }
 
 AudioEncoderOpus::AudioEncoderOpus(const CodecInst& codec_inst)
-    : AudioEncoderOpus(CreateConfig(codec_inst)) {}
+    : AudioEncoderOpus(CreateConfig(codec_inst), nullptr) {}
 
 AudioEncoderOpus::~AudioEncoderOpus() {
   RTC_CHECK_EQ(0, WebRtcOpus_EncoderFree(inst_));
 }
 
 int AudioEncoderOpus::SampleRateHz() const {
   return kSampleRateHz;
 }
 
 size_t AudioEncoderOpus::NumChannels() const {
@@ skipping 10 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()));
 }
 
+bool AudioEncoderOpus::SetAudioNetworkAdaptor(bool enable) {
+  if (config_.audio_network_adaptor_enabled == enable)
+    return true;
+  config_.audio_network_adaptor_enabled = enable;
+  if (config_.audio_network_adaptor_enabled) {
+    // TODO(minyue): Create AudioNetworkAdaptorImpl.
+  } else {
+    audio_network_adaptor_.reset(nullptr);
+  }
+  return true;
+}

[kwiberg-webrtc, 2016/09/27 09:35:54]

Hmm. I don't quite understand in what circumstances this function is going to be
called, I think. It destroys and recreates the ANA that we got in the
constructor, so the state change is much more invasive than I guessed from just
seeing the method name and signature.

Specifically, who is going to be calling this function, and to what end?

[minyue-webrtc, 2016/09/27 16:02:33]

My intention is to make it hook up in similar manner as SetDtx.

+
+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_->SetTargetAudioBitrate(target_audio_bitrate_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();
+}
+
+void AudioEncoderOpus::SetReceiverFrameLengthRange(int min_frame_length_ms,
+                                                   int max_frame_length_ms) {
+  if (!config_.audio_network_adaptor_enabled)
+    return;
+  RTC_DCHECK(audio_network_adaptor_);
+  audio_network_adaptor_->SetReceiverFrameLengthRange(min_frame_length_ms,
+                                                      max_frame_length_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 36 matching lines @@
   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.
+  next_frame_size_ms_ = config_.frame_size_ms;
   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));

[kwiberg-webrtc, 2016/09/27 09:35:54]

Remove commented-out code.

[minyue-webrtc, 2016/09/27 16:02:33]

Yes, we can do it now. Since WebRtcOpus_SetForceChannels has landed.

+  num_channels_to_encode_ = num_channels_to_encode;
+}
+
+void AudioEncoderOpus::ApplyAudioNetworkAdaptor() {

[kwiberg-webrtc, 2016/09/27 09:35:55]

"ApplyAudioNetworkAdaptorConfig"?

[minyue-webrtc, 2016/09/27 16:02:33]

I think ApplyAudioNetworkAdaptor may be better since the intention is clear: let
AudioNetworkAdaptor to adapt the encoding. 

ApplyAudioNetworkAdaptorConfig sounds like we need to give a config?

+  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 && config.num_channels);

[kwiberg-webrtc, 2016/09/27 09:35:54]

It's often better to split things like this up into separate DCHECK calls. That
way, if they trigger you'll know which field was false.

Also, it looks like not all of these are Optional or bool or pointers? When
testing if an integer is nonzero, perfer to write x != 0 instead of just x.

[minyue-webrtc, 2016/09/27 16:02:33]

ok. will change in next patch set.

+  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