Variable audio bitrate.

webrtc/audio/audio_send_stream.cc

Index: webrtc/audio/audio_send_stream.cc
diff --git a/webrtc/audio/audio_send_stream.cc b/webrtc/audio/audio_send_stream.cc
index d08bfeaa1ef70c43de1de0fd57f1e252966542ec..b72d3d094c86823379130572a58a2dea15e3191a 100644
--- a/webrtc/audio/audio_send_stream.cc
+++ b/webrtc/audio/audio_send_stream.cc
@@ -59,8 +59,11 @@ namespace internal {
 AudioSendStream::AudioSendStream(
     const webrtc::AudioSendStream::Config& config,
     const rtc::scoped_refptr<webrtc::AudioState>& audio_state,
-    CongestionController* congestion_controller)
-    : config_(config), audio_state_(audio_state) {
+    CongestionController* congestion_controller,
+    BitrateAllocator* bitrate_allocator)
+    : config_(config),
+      audio_state_(audio_state),
+      bitrate_allocator_(bitrate_allocator) {
   LOG(LS_INFO) << "AudioSendStream: " << config_.ToString();
   RTC_DCHECK_NE(config_.voe_channel_id, -1);
   RTC_DCHECK(audio_state_.get());
@@ -104,6 +107,12 @@ AudioSendStream::~AudioSendStream() {
 
 void AudioSendStream::Start() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  if (config_.min_bitrate_kbps != -1 && config_.max_bitrate_kbps != -1) {
+    RTC_DCHECK_GE(config_.max_bitrate_kbps, config_.min_bitrate_kbps);
+    bitrate_allocator_->AddObserver(this, config_.min_bitrate_kbps * 1000,
+                                    config_.max_bitrate_kbps * 1000, 0, true);
+  }
+
   ScopedVoEInterface<VoEBase> base(voice_engine());
   int error = base->StartSend(config_.voe_channel_id);
   if (error != 0) {
@@ -113,6 +122,7 @@ void AudioSendStream::Start() {
 
 void AudioSendStream::Stop() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  bitrate_allocator_->RemoveObserver(this);
   ScopedVoEInterface<VoEBase> base(voice_engine());
   int error = base->StopSend(config_.voe_channel_id);
   if (error != 0) {
@@ -227,6 +237,23 @@ bool AudioSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
   return channel_proxy_->ReceivedRTCPPacket(packet, length);
 }
 
+uint32_t AudioSendStream::OnBitrateUpdated(uint32_t bitrate_bps,
+                                           uint8_t fraction_loss,
+                                           int64_t rtt) {
+  RTC_DCHECK_GE(bitrate_bps,
+                static_cast<uint32_t>(config_.min_bitrate_kbps * 1000));
+  // The bitrate allocator might allocate an higher than max configured bitrate
+  // if there is room, to allow for, as example, extra FEC. Ignore that for now.
+  const uint32_t max_bitrate_bps = config_.max_bitrate_kbps * 1000;
+  if (bitrate_bps > max_bitrate_bps)
+    bitrate_bps = max_bitrate_bps;
+
+  channel_proxy_->SetBitrate(bitrate_bps);
+
+  // Possible audio protection used is ignored for now.

[stefan-webrtc, 2016/07/20 10:14:59]

Maybe rewrite as:
TODO(mflodman): Return amount of audio protection used here.

[mflodman, 2016/07/22 13:50:29]

This information isn't available to us and would require changes to audio
encoders and Opus to expose to AudioSendStream, work that there are no plans to
do when I asked. All this is currently handled internally by Opus.

I don't want to put a TODO here since there are no plans to actually do the
work.

I updated the comment though, looks ok?

[stefan-webrtc, 2016/07/25 15:06:20]

Acknowledged.

+  return 0;

[minyue-webrtc, 2016/07/21 10:59:19]

do we need to return

max_bitrate_bps - bitrate_bps

for the case that bitrate is clamped by the max

[mflodman, 2016/07/22 13:50:29]

We should return the bitrate used for FEC, but we don't know that at this point
for Opus since that is all done internally in the encoder. So to do that
properly, we would need an API from the encoder to ask for the amount of FEC
used.

We can change this when Opus / ACM exposes this.

[minyue-webrtc, 2016/07/25 14:33:47]

OK, the comment on OnBitrateUpdated says
"
Returns the amount of protection used by the BitrateAllocatorObserve
"
I did not have a good understanding of "protection" in here. So you mean that it
is expected to return FEC usage within |bitrate_bps|? What is that used for
then?

It is true that Opus's FEC is included in bitrate_bps and no way to tell how
large it is for the moment.

+}
+
 const webrtc::AudioSendStream::Config& AudioSendStream::config() const {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   return config_;