Simplifying audio network adaptor by moving receiver frame length range to ctor.

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/arraysize.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/exp_filter.h"
 #include "webrtc/base/safe_conversions.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/audio_network_adaptor_impl.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/controller_manager.h"
 #include "webrtc/modules/audio_coding/codecs/opus/opus_interface.h"
 #include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
@@ skipping 120 matching lines @@
 AudioEncoderOpus::AudioEncoderOpus(
     const Config& config,
     AudioNetworkAdaptorCreator&& audio_network_adaptor_creator)
     : packet_loss_rate_(0.0),
       inst_(nullptr),
       packet_loss_fraction_smoother_(new PacketLossFractionSmoother(
           config.clock ? config.clock : Clock::GetRealTimeClock())),
       audio_network_adaptor_creator_(
           audio_network_adaptor_creator
               ? std::move(audio_network_adaptor_creator)
-              : [this](const std::string& config_string, const Clock* clock) {
-                  return DefaultAudioNetworkAdaptorCreator(config_string,
-                                                           clock);
+              : [this](const std::string& config_string,
+                       int min_receiver_frame_length_ms,
+                       int max_receiver_frame_length_ms,
+                       const Clock* clock) {
+                  return DefaultAudioNetworkAdaptorCreator(
+                      config_string, min_receiver_frame_length_ms,
+                      max_receiver_frame_length_ms, clock);
                 }) {
   RTC_CHECK(RecreateEncoderInstance(config));
 }
 
 AudioEncoderOpus::AudioEncoderOpus(const CodecInst& codec_inst)
     : AudioEncoderOpus(CreateConfig(codec_inst), nullptr) {}
 
 AudioEncoderOpus::~AudioEncoderOpus() {
   RTC_CHECK_EQ(0, WebRtcOpus_EncoderFree(inst_));
 }
@@ skipping 77 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::EnableAudioNetworkAdaptor(
     const std::string& config_string,
+    int min_receiver_frame_length_ms,
+    int max_receiver_frame_length_ms,
     const Clock* clock) {
-  audio_network_adaptor_ = audio_network_adaptor_creator_(config_string, clock);
+  audio_network_adaptor_ = audio_network_adaptor_creator_(
+      config_string, min_receiver_frame_length_ms, max_receiver_frame_length_ms,
+      clock);
   return audio_network_adaptor_.get() != nullptr;
 }
 
 void AudioEncoderOpus::DisableAudioNetworkAdaptor() {
   audio_network_adaptor_.reset(nullptr);
 }
 
 void AudioEncoderOpus::OnReceivedUplinkBandwidth(int uplink_bandwidth_bps) {
   if (!audio_network_adaptor_)
     return;
@@ skipping 21 matching lines @@
   ApplyAudioNetworkAdaptor();
 }
 
 void AudioEncoderOpus::OnReceivedRtt(int rtt_ms) {
   if (!audio_network_adaptor_)
     return;
   audio_network_adaptor_->SetRtt(rtt_ms);
   ApplyAudioNetworkAdaptor();
 }
 
-void AudioEncoderOpus::SetReceiverFrameLengthRange(int min_frame_length_ms,
-                                                   int max_frame_length_ms) {
-  if (!audio_network_adaptor_)
-    return;
-  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 118 matching lines @@
   SetFrameLength(*config.frame_length_ms);
   SetFec(*config.enable_fec);
   SetProjectedPacketLossRate(*config.uplink_packet_loss_fraction);
   SetDtx(*config.enable_dtx);
   SetNumChannelsToEncode(*config.num_channels);
 }
 
 std::unique_ptr<AudioNetworkAdaptor>
 AudioEncoderOpus::DefaultAudioNetworkAdaptorCreator(
     const std::string& config_string,
+    int min_receiver_frame_length_ms,
+    int max_receiver_frame_length_ms,
     const Clock* clock) const {
   AudioNetworkAdaptorImpl::Config config;
   config.clock = clock;
+
+  std::vector<int> frame_lengths;

[michaelt, 2016/10/18 08:25:23]

Would be nice to have a unit-test for this functionality. 

[minyue-webrtc, 2016/10/18 13:25:13]

I agree. I thought about it but did not find a good way to test. Thanks for
pushing this. Now I have one.

+  std::copy_if(kSupportedFrameLengths,
+               kSupportedFrameLengths + arraysize(kSupportedFrameLengths),
+               std::back_inserter(frame_lengths), [&](int frame_length_ms) {
+                 return frame_length_ms >= min_receiver_frame_length_ms &&
+                        frame_length_ms <= max_receiver_frame_length_ms;
+               });
+  RTC_DCHECK(std::is_sorted(frame_lengths.begin(), frame_lengths.end()));
+
   return std::unique_ptr<AudioNetworkAdaptor>(new AudioNetworkAdaptorImpl(
       config, ControllerManagerImpl::Create(
-                  config_string, NumChannels(), kSupportedFrameLengths,
+                  config_string, NumChannels(), frame_lengths,
                   num_channels_to_encode_, next_frame_length_ms_,
                   GetTargetBitrate(), config_.fec_enabled, GetDtx(), clock)));
 }
 
 }  // namespace webrtc