Variable audio bitrate.

webrtc/audio/audio_send_stream.cc

 /*
  *  Copyright (c) 2015 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 41 matching lines @@
   // TODO(solenberg): Encoder config.
   ss << ", cng_payload_type: " << cng_payload_type;
   ss << '}';
   return ss.str();
 }
 
 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());
   RTC_DCHECK(congestion_controller);
 
   VoiceEngineImpl* voe_impl = static_cast<VoiceEngineImpl*>(voice_engine());
   channel_proxy_ = voe_impl->GetChannelProxy(config_.voe_channel_id);
   channel_proxy_->RegisterSenderCongestionControlObjects(
       congestion_controller->pacer(),
       congestion_controller->GetTransportFeedbackObserver(),
@@ skipping 23 matching lines @@
 
 AudioSendStream::~AudioSendStream() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   LOG(LS_INFO) << "~AudioSendStream: " << config_.ToString();
   channel_proxy_->DeRegisterExternalTransport();
   channel_proxy_->ResetCongestionControlObjects();
 }
 
 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) {
     LOG(LS_ERROR) << "AudioSendStream::Start failed with error: " << error;
   }
 }
 
 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) {
     LOG(LS_ERROR) << "AudioSendStream::Stop failed with error: " << error;
   }
 }
 
 bool AudioSendStream::SendTelephoneEvent(int payload_type, int event,
                                          int duration_ms) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 94 matching lines @@
 }
 
 bool AudioSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
   // TODO(solenberg): Tests call this function on a network thread, libjingle
   // calls on the worker thread. We should move towards always using a network
   // thread. Then this check can be enabled.
   // RTC_DCHECK(!thread_checker_.CalledOnValidThread());
   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_;
 }
 
 VoiceEngine* AudioSendStream::voice_engine() const {
   internal::AudioState* audio_state =
       static_cast<internal::AudioState*>(audio_state_.get());
   VoiceEngine* voice_engine = audio_state->voice_engine();
   RTC_DCHECK(voice_engine);
   return voice_engine;
 }
 }  // namespace internal
 }  // namespace webrtc