Implementing auto pausing of video streams.

webrtc/call/call.cc

 /*
  *  Copyright (c) 2013 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 <string.h>
 
+#include <algorithm>
 #include <map>
 #include <memory>
 #include <vector>
 
 #include "webrtc/audio/audio_receive_stream.h"
 #include "webrtc/audio/audio_send_stream.h"
 #include "webrtc/audio/audio_state.h"
 #include "webrtc/audio/scoped_voe_interface.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/constructormagic.h"
@@ skipping 647 matching lines @@
   video_send_delay_stats_->OnSentPacket(sent_packet.packet_id,
                                         clock_->TimeInMilliseconds());
   congestion_controller_->OnSentPacket(sent_packet);
 }
 
 void Call::OnNetworkChanged(uint32_t target_bitrate_bps, uint8_t fraction_loss,
                             int64_t rtt_ms) {
   uint32_t allocated_bitrate_bps = bitrate_allocator_->OnNetworkChanged(
       target_bitrate_bps, fraction_loss, rtt_ms);
 
   int pad_up_to_bitrate_bps = 0;

[pbos-webrtc, 2016/06/06 15:26:29]

Should this be an uint32_t?

[mflodman, 2016/06/09 13:23:13]

I can take care of this in a follow up to not make this CL too large, it would
require changes in VideoSendStream to return correct type from there.

   {
     ReadLockScoped read_lock(*send_crit_);
     // No need to update as long as we're not sending.
     if (video_send_streams_.empty())
       return;
 
     for (VideoSendStream* stream : video_send_streams_)
       pad_up_to_bitrate_bps += stream->GetPaddingNeededBps();
   }
   // Allocated bitrate might be higher than bitrate estimate if enforcing min
   // bitrate, or lower if estimate is higher than the sum of max bitrates, so
   // set the pacer bitrate to the maximum of the two.
   uint32_t pacer_bitrate_bps =
       std::max(target_bitrate_bps, allocated_bitrate_bps);
   {
     rtc::CritScope lock(&bitrate_crit_);
     // We only update these stats if we have send streams, and assume that
     // OnNetworkChanged is called roughly with a fixed frequency.
     estimated_send_bitrate_sum_kbits_ += target_bitrate_bps / 1000;
     pacer_bitrate_sum_kbits_ += pacer_bitrate_bps / 1000;
     ++num_bitrate_updates_;
   }
+
+  // Make sure to not ask for more padding than the current BWE allows for.

[pbos-webrtc, 2016/06/06 15:26:29]

Should this be controlled in here or capped inside? (E.g. does
CongestionController know about the max bitrate?)

[mflodman, 2016/06/09 13:23:13]

That is a good question, but Per is reworking this entirely in another CL
(already up for review) and I'd prefer to keep it this way to make his change
easier. It will go in very soon.

OK?

+  pad_up_to_bitrate_bps = std::min(static_cast<uint32_t>(pad_up_to_bitrate_bps),
+                                   target_bitrate_bps);
   congestion_controller_->SetAllocatedSendBitrate(allocated_bitrate_bps,
                                                   pad_up_to_bitrate_bps);
 }
 
 void Call::ConfigureSync(const std::string& sync_group) {
   // Set sync only if there was no previous one.
   if (voice_engine() == nullptr || sync_group.empty())
     return;
 
   AudioReceiveStream* sync_audio_stream = nullptr;
@@ skipping 135 matching lines @@
   // thread. Then this check can be enabled.
   // RTC_DCHECK(!configuration_thread_checker_.CalledOnValidThread());
   if (RtpHeaderParser::IsRtcp(packet, length))
     return DeliverRtcp(media_type, packet, length);
 
   return DeliverRtp(media_type, packet, length, packet_time);
 }
 
 }  // namespace internal
 }  // namespace webrtc