Remove ViEncoder::Pause / Start

webrtc/video/video_send_stream.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.
  */
 
@@ skipping 511 matching lines @@
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
     rtp_rtcp->IncomingRtcpPacket(packet, length);
   return true;
 }
 
 void VideoSendStream::Start() {
   if (payload_router_.active())
     return;
   TRACE_EVENT_INSTANT0("webrtc", "VideoSendStream::Start");
   payload_router_.set_active(true);
+  vie_encoder_.OnBitrateUpdated(
+      protection_bitrate_calculator_.GetEncoderTargetRate(), 0, 0);

[pbos-webrtc, 2016/06/16 13:16:28]

What does it mean to put bogus values for fraction_loss and rtt here? Don't we
have OK values for them? Can we trigger this from the correct source instead
instead of fetching target rates?

[perkj_webrtc, 2016/06/16 18:42:18]

There is no guarantee that the rtt and packet loss is valid when the transport
becomes writable and Start is called. 

Thinking about it, we should probably deregister from the BitrateAllocator.

We can store the last 

   // Was not already started, trigger a keyframe.
   vie_encoder_.SendKeyFrame();
-  vie_encoder_.Start();
 }
 
 void VideoSendStream::Stop() {
   if (!payload_router_.active())
     return;
   TRACE_EVENT_INSTANT0("webrtc", "VideoSendStream::Stop");
-  vie_encoder_.Pause();
+  vie_encoder_.OnBitrateUpdated(0, 0, 0);
   payload_router_.set_active(false);
 }
 
 VideoCaptureInput* VideoSendStream::Input() {
   return &input_;
 }
 
 bool VideoSendStream::EncoderThreadFunction(void* obj) {
   static_cast<VideoSendStream*>(obj)->EncoderProcess();
   // We're done, return false to abort.
@@ skipping 291 matching lines @@
 
 void VideoSendStream::OnBitrateUpdated(uint32_t bitrate_bps,
                                        uint8_t fraction_loss,
                                        int64_t rtt) {
   payload_router_.SetTargetSendBitrate(bitrate_bps);
   // Get the encoder target rate. It is the estimated network rate -
   // protection overhead.
   uint32_t encoder_target_rate = protection_bitrate_calculator_.SetTargetRates(
       bitrate_bps, stats_proxy_.GetSendFrameRate(), fraction_loss, rtt);
 
+  if (!payload_router_.active())
+    return;  // The send stream is currently not started.

[pbos-webrtc, 2016/06/16 13:16:28]

Should the last fraction_loss and rtt be stored?

[perkj_webrtc, 2016/06/16 18:42:18]

I dont' think they actually make sense. But we could. 

   vie_encoder_.OnBitrateUpdated(encoder_target_rate, fraction_loss, rtt);
 }
 
 int VideoSendStream::ProtectionRequest(const FecProtectionParams* delta_params,
                                        const FecProtectionParams* key_params,
                                        uint32_t* sent_video_rate_bps,
                                        uint32_t* sent_nack_rate_bps,
                                        uint32_t* sent_fec_rate_bps) {
   *sent_video_rate_bps = 0;
   *sent_nack_rate_bps = 0;
   *sent_fec_rate_bps = 0;
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     uint32_t not_used = 0;
     uint32_t module_video_rate = 0;
     uint32_t module_fec_rate = 0;
     uint32_t module_nack_rate = 0;
     rtp_rtcp->SetFecParameters(delta_params, key_params);
     rtp_rtcp->BitrateSent(&not_used, &module_video_rate, &module_fec_rate,
                           &module_nack_rate);
     *sent_video_rate_bps += module_video_rate;
     *sent_nack_rate_bps += module_nack_rate;
     *sent_fec_rate_bps += module_fec_rate;
   }
   return 0;
 }
 
 }  // namespace internal
 }  // namespace webrtc