Adding audio network adaptor to AudioEncoderOpus.

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

 /*
  *  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.
  */
 
 #ifndef WEBRTC_MODULES_AUDIO_CODING_CODECS_OPUS_AUDIO_ENCODER_OPUS_H_
 #define WEBRTC_MODULES_AUDIO_CODING_CODECS_OPUS_AUDIO_ENCODER_OPUS_H_
 
 #include <vector>
 
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/optional.h"
+#include "webrtc/modules/audio_coding/audio_network_adaptor/include/audio_network_adaptor.h"
 #include "webrtc/modules/audio_coding/codecs/opus/opus_interface.h"
 #include "webrtc/modules/audio_coding/codecs/audio_encoder.h"
 
 namespace webrtc {
 
 struct CodecInst;
 
 class AudioEncoderOpus final : public AudioEncoder {
  public:
   enum ApplicationMode {
@@ skipping 23 matching lines @@
    private:
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS) || defined(WEBRTC_ARCH_ARM)
     // If we are on Android, iOS and/or ARM, use a lower complexity setting as
     // default, to save encoder complexity.
     static const int kDefaultComplexity = 5;
 #else
     static const int kDefaultComplexity = 9;
 #endif
   };
 
-  explicit AudioEncoderOpus(const Config& config);
+  // |audio_network_adaptor| is for dependency injection for testing.
+  AudioEncoderOpus(
+      const Config& config,
+      std::unique_ptr<AudioNetworkAdaptor> audio_network_adaptor = nullptr);

[kwiberg-webrtc, 2016/10/04 08:52:35]

I'm still not convinced it's a good idea to inject the ANA like this, since
AudioEncoderOpus will sometimes delete and recreate the object and thus lose
whatever is special with the ANA you provide here.

It would make much more sense to inject an ANA *factory* here, which would then
be used whenever we needed an ANA. I was going to suggest using a simple
std::function for this, but from the .cc file it looks like AudioEncoderOpus
needs to pass a ton of arguments to the ANA factory, so maybe just define an
interface for it (with just one function, CreateAna), and have the
AudioEncoderOpus constructor look like this:

  AudioEncoderOpus(
      const Config& config,
      std::unique_ptr<AudioNetworkAdaptorFactory>
          audio_network_adaptor_factory = nullptr);

Yes, this gets a little hairy (mainly because of all the arguments that
AudioNetworkAdaptorFactory::CreateAna will need to take), so I'll understand if
you don't want to take this advice, but what you want to do is allow the caller
to change the type of an object used internally in AudioEncoderOpus; this (or
something similar) is the general way to do that. Injecting a ready-made ANA
would only make sense if AudioEncoderOpus never destroyed or recreated its ANA.

+
   explicit AudioEncoderOpus(const CodecInst& codec_inst);
+
   ~AudioEncoderOpus() override;
 
   int SampleRateHz() const override;
   size_t NumChannels() const override;
   size_t Num10MsFramesInNextPacket() const override;
   size_t Max10MsFramesInAPacket() const override;
   int GetTargetBitrate() const override;
 
   void Reset() override;
   bool SetFec(bool enable) override;
 
   // Set Opus DTX. Once enabled, Opus stops transmission, when it detects voice
   // being inactive. During that, it still sends 2 packets (one for content, one
   // for signaling) about every 400 ms.
   bool SetDtx(bool enable) override;
   bool GetDtx() const override;
 
   bool SetApplication(Application application) override;
   void SetMaxPlaybackRate(int frequency_hz) override;
   void SetProjectedPacketLossRate(double fraction) override;
   void SetTargetBitrate(int target_bps) override;
 
+  bool EnableAudioNetworkAdaptor(const std::string& config_string,
+                                 const Clock* clock) override;
+  void DisableAudioNetworkAdaptor() override;
+  void OnReceivedUplinkBandwidth(int uplink_bandwidth_bps) override;
+  void OnReceivedUplinkPacketLossFraction(
+      float uplink_packet_loss_fraction) override;
+  void OnReceivedTargetAudioBitrate(int target_audio_bitrate_bps) override;
+  void OnReceivedRtt(int rtt_ms) override;
+  void SetReceiverFrameLengthRange(int min_frame_length_ms,
+                                   int max_frame_length_ms) override;
+
   // Getters for testing.
   double packet_loss_rate() const { return packet_loss_rate_; }
   ApplicationMode application() const { return config_.application; }
+  bool fec_enabled() const { return config_.fec_enabled; }
+  size_t num_channels_to_encode() const { return num_channels_to_encode_; }
+  int next_frame_length_ms() const { return next_frame_length_ms_; }
 
  protected:
   EncodedInfo EncodeImpl(uint32_t rtp_timestamp,
                          rtc::ArrayView<const int16_t> audio,
                          rtc::Buffer* encoded) override;
 
  private:
   size_t Num10msFramesPerPacket() const;
   size_t SamplesPer10msFrame() const;
   size_t SufficientOutputBufferSize() const;
   bool RecreateEncoderInstance(const Config& config);
+  void SetFrameLength(int frame_length_ms);
+  void SetNumChannelsToEncode(size_t num_channels_to_encode);
+  void ApplyAudioNetworkAdaptor();
 
   Config config_;
   double packet_loss_rate_;
   std::vector<int16_t> input_buffer_;
   OpusEncInst* inst_;
   uint32_t first_timestamp_in_buffer_;
+  size_t num_channels_to_encode_;
+  int next_frame_length_ms_;
+  std::unique_ptr<AudioNetworkAdaptor> audio_network_adaptor_;
+
   RTC_DISALLOW_COPY_AND_ASSIGN(AudioEncoderOpus);
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_AUDIO_CODING_CODECS_OPUS_AUDIO_ENCODER_OPUS_H_