1 /*
2  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3  *
4  *  Use of this source code is governed by a BSD-style license
5  *  that can be found in the LICENSE file in the root of the source
6  *  tree. An additional intellectual property rights grant can be found
7  *  in the file PATENTS.  All contributing project authors may
8  *  be found in the AUTHORS file in the root of the source tree.
9  */
10 
11 #include "webrtc/video/vie_encoder.h"
12 
13 #include <assert.h>
14 
15 #include <algorithm>
16 
17 #include "webrtc/base/checks.h"
18 #include "webrtc/base/logging.h"
19 #include "webrtc/base/trace_event.h"
20 #include "webrtc/call/bitrate_allocator.h"
21 #include "webrtc/common_video/include/video_image.h"
22 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
23 #include "webrtc/frame_callback.h"
24 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
25 #include "webrtc/modules/pacing/paced_sender.h"
26 #include "webrtc/modules/utility/include/process_thread.h"
27 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
28 #include "webrtc/modules/video_coding/include/video_coding.h"
29 #include "webrtc/modules/video_coding/include/video_coding_defines.h"
30 #include "webrtc/modules/video_coding/encoded_frame.h"
31 #include "webrtc/system_wrappers/include/clock.h"
32 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
33 #include "webrtc/system_wrappers/include/metrics.h"
34 #include "webrtc/system_wrappers/include/tick_util.h"
35 #include "webrtc/video/payload_router.h"
36 #include "webrtc/video/send_statistics_proxy.h"
37 
38 namespace webrtc {
39 
40 // Margin on when we pause the encoder when the pacing buffer overflows relative
41 // to the configured buffer delay.
42 static const float kEncoderPausePacerMargin = 2.0f;
43 
44 // Don't stop the encoder unless the delay is above this configured value.
45 static const int kMinPacingDelayMs = 200;
46 
47 static const float kStopPaddingThresholdMs = 2000;
48 
49 static const int kMinKeyFrameRequestIntervalMs = 300;
50 
AllocateStreamBitrates(uint32_t total_bitrate,const SimulcastStream * stream_configs,size_t number_of_streams)51 std::vector<uint32_t> AllocateStreamBitrates(
52     uint32_t total_bitrate,
53     const SimulcastStream* stream_configs,
54     size_t number_of_streams) {
55   if (number_of_streams == 0) {
56     std::vector<uint32_t> stream_bitrates(1, 0);
57     stream_bitrates[0] = total_bitrate;
58     return stream_bitrates;
59   }
60   std::vector<uint32_t> stream_bitrates(number_of_streams, 0);
61   uint32_t bitrate_remainder = total_bitrate;
62   for (size_t i = 0; i < stream_bitrates.size() && bitrate_remainder > 0; ++i) {
63     if (stream_configs[i].maxBitrate * 1000 > bitrate_remainder) {
64       stream_bitrates[i] = bitrate_remainder;
65     } else {
66       stream_bitrates[i] = stream_configs[i].maxBitrate * 1000;
67     }
68     bitrate_remainder -= stream_bitrates[i];
69   }
70   return stream_bitrates;
71 }
72 
73 class QMVideoSettingsCallback : public VCMQMSettingsCallback {
74  public:
75   explicit QMVideoSettingsCallback(VideoProcessing* vpm);
76 
77   ~QMVideoSettingsCallback();
78 
79   // Update VPM with QM (quality modes: frame size & frame rate) settings.
80   int32_t SetVideoQMSettings(const uint32_t frame_rate,
81                              const uint32_t width,
82                              const uint32_t height);
83 
84   // Update target frame rate.
85   void SetTargetFramerate(int frame_rate);
86 
87  private:
88   VideoProcessing* vp_;
89 };
90 
91 class ViEBitrateObserver : public BitrateObserver {
92  public:
ViEBitrateObserver(ViEEncoder * owner)93   explicit ViEBitrateObserver(ViEEncoder* owner)
94       : owner_(owner) {
95   }
~ViEBitrateObserver()96   virtual ~ViEBitrateObserver() {}
97   // Implements BitrateObserver.
OnNetworkChanged(uint32_t bitrate_bps,uint8_t fraction_lost,int64_t rtt)98   virtual void OnNetworkChanged(uint32_t bitrate_bps,
99                                 uint8_t fraction_lost,
100                                 int64_t rtt) {
101     owner_->OnNetworkChanged(bitrate_bps, fraction_lost, rtt);
102   }
103  private:
104   ViEEncoder* owner_;
105 };
106 
ViEEncoder(uint32_t number_of_cores,ProcessThread * module_process_thread,SendStatisticsProxy * stats_proxy,I420FrameCallback * pre_encode_callback,PacedSender * pacer,BitrateAllocator * bitrate_allocator)107 ViEEncoder::ViEEncoder(uint32_t number_of_cores,
108                        ProcessThread* module_process_thread,
109                        SendStatisticsProxy* stats_proxy,
110                        I420FrameCallback* pre_encode_callback,
111                        PacedSender* pacer,
112                        BitrateAllocator* bitrate_allocator)
113     : number_of_cores_(number_of_cores),
114       vp_(VideoProcessing::Create()),
115       qm_callback_(new QMVideoSettingsCallback(vp_.get())),
116       vcm_(VideoCodingModule::Create(Clock::GetRealTimeClock(),
117                                      this,
118                                      qm_callback_.get())),
119       send_payload_router_(NULL),
120       data_cs_(CriticalSectionWrapper::CreateCriticalSection()),
121       stats_proxy_(stats_proxy),
122       pre_encode_callback_(pre_encode_callback),
123       pacer_(pacer),
124       bitrate_allocator_(bitrate_allocator),
125       time_of_last_frame_activity_ms_(0),
126       encoder_config_(),
127       min_transmit_bitrate_kbps_(0),
128       last_observed_bitrate_bps_(0),
129       target_delay_ms_(0),
130       network_is_transmitting_(true),
131       encoder_paused_(false),
132       encoder_paused_and_dropped_frame_(false),
133       module_process_thread_(module_process_thread),
134       has_received_sli_(false),
135       picture_id_sli_(0),
136       has_received_rpsi_(false),
137       picture_id_rpsi_(0),
138       video_suspended_(false) {
139   bitrate_observer_.reset(new ViEBitrateObserver(this));
140 }
141 
Init()142 bool ViEEncoder::Init() {
143   vp_->EnableTemporalDecimation(true);
144 
145   // Enable/disable content analysis: off by default for now.
146   vp_->EnableContentAnalysis(false);
147 
148   if (vcm_->RegisterTransportCallback(this) != 0) {
149     return false;
150   }
151   if (vcm_->RegisterSendStatisticsCallback(this) != 0) {
152     return false;
153   }
154   return true;
155 }
156 
StartThreadsAndSetSharedMembers(rtc::scoped_refptr<PayloadRouter> send_payload_router,VCMProtectionCallback * vcm_protection_callback)157 void ViEEncoder::StartThreadsAndSetSharedMembers(
158     rtc::scoped_refptr<PayloadRouter> send_payload_router,
159     VCMProtectionCallback* vcm_protection_callback) {
160   RTC_DCHECK(send_payload_router_ == NULL);
161 
162   send_payload_router_ = send_payload_router;
163   vcm_->RegisterProtectionCallback(vcm_protection_callback);
164   module_process_thread_->RegisterModule(vcm_.get());
165 }
166 
StopThreadsAndRemoveSharedMembers()167 void ViEEncoder::StopThreadsAndRemoveSharedMembers() {
168   if (bitrate_allocator_)
169     bitrate_allocator_->RemoveBitrateObserver(bitrate_observer_.get());
170   module_process_thread_->DeRegisterModule(vcm_.get());
171 }
172 
~ViEEncoder()173 ViEEncoder::~ViEEncoder() {
174 }
175 
SetNetworkTransmissionState(bool is_transmitting)176 void ViEEncoder::SetNetworkTransmissionState(bool is_transmitting) {
177   {
178     CriticalSectionScoped cs(data_cs_.get());
179     network_is_transmitting_ = is_transmitting;
180   }
181 }
182 
Pause()183 void ViEEncoder::Pause() {
184   CriticalSectionScoped cs(data_cs_.get());
185   encoder_paused_ = true;
186 }
187 
Restart()188 void ViEEncoder::Restart() {
189   CriticalSectionScoped cs(data_cs_.get());
190   encoder_paused_ = false;
191 }
192 
RegisterExternalEncoder(webrtc::VideoEncoder * encoder,uint8_t pl_type,bool internal_source)193 int32_t ViEEncoder::RegisterExternalEncoder(webrtc::VideoEncoder* encoder,
194                                             uint8_t pl_type,
195                                             bool internal_source) {
196   if (vcm_->RegisterExternalEncoder(encoder, pl_type, internal_source) !=
197       VCM_OK) {
198     return -1;
199   }
200   return 0;
201 }
202 
DeRegisterExternalEncoder(uint8_t pl_type)203 int32_t ViEEncoder::DeRegisterExternalEncoder(uint8_t pl_type) {
204   if (vcm_->RegisterExternalEncoder(NULL, pl_type) != VCM_OK) {
205     return -1;
206   }
207   return 0;
208 }
209 
SetEncoder(const webrtc::VideoCodec & video_codec)210 int32_t ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec) {
211   RTC_DCHECK(send_payload_router_ != NULL);
212   // Setting target width and height for VPM.
213   if (vp_->SetTargetResolution(video_codec.width, video_codec.height,
214                                video_codec.maxFramerate) != VPM_OK) {
215     return -1;
216   }
217 
218   // Cache codec before calling AddBitrateObserver (which calls OnNetworkChanged
219   // that makes use of the number of simulcast streams configured).
220   {
221     CriticalSectionScoped cs(data_cs_.get());
222     encoder_config_ = video_codec;
223   }
224 
225   // Add a bitrate observer to the allocator and update the start, max and
226   // min bitrates of the bitrate controller as needed.
227   int allocated_bitrate_bps = bitrate_allocator_->AddBitrateObserver(
228       bitrate_observer_.get(), video_codec.minBitrate * 1000,
229       video_codec.maxBitrate * 1000);
230 
231   webrtc::VideoCodec modified_video_codec = video_codec;
232   modified_video_codec.startBitrate = allocated_bitrate_bps / 1000;
233 
234   size_t max_data_payload_length = send_payload_router_->MaxPayloadLength();
235   if (vcm_->RegisterSendCodec(&modified_video_codec, number_of_cores_,
236                               static_cast<uint32_t>(max_data_payload_length)) !=
237       VCM_OK) {
238     return -1;
239   }
240   return 0;
241 }
242 
GetPaddingNeededBps() const243 int ViEEncoder::GetPaddingNeededBps() const {
244   int64_t time_of_last_frame_activity_ms;
245   int min_transmit_bitrate_bps;
246   int bitrate_bps;
247   VideoCodec send_codec;
248   {
249     CriticalSectionScoped cs(data_cs_.get());
250     bool send_padding = encoder_config_.numberOfSimulcastStreams > 1 ||
251                         video_suspended_ || min_transmit_bitrate_kbps_ > 0;
252     if (!send_padding)
253       return 0;
254     time_of_last_frame_activity_ms = time_of_last_frame_activity_ms_;
255     min_transmit_bitrate_bps = 1000 * min_transmit_bitrate_kbps_;
256     bitrate_bps = last_observed_bitrate_bps_;
257     send_codec = encoder_config_;
258   }
259 
260   bool video_is_suspended = vcm_->VideoSuspended();
261 
262   // Find the max amount of padding we can allow ourselves to send at this
263   // point, based on which streams are currently active and what our current
264   // available bandwidth is.
265   int pad_up_to_bitrate_bps = 0;
266   if (send_codec.numberOfSimulcastStreams == 0) {
267     pad_up_to_bitrate_bps = send_codec.minBitrate * 1000;
268   } else {
269     SimulcastStream* stream_configs = send_codec.simulcastStream;
270     pad_up_to_bitrate_bps =
271         stream_configs[send_codec.numberOfSimulcastStreams - 1].minBitrate *
272         1000;
273     for (int i = 0; i < send_codec.numberOfSimulcastStreams - 1; ++i) {
274       pad_up_to_bitrate_bps += stream_configs[i].targetBitrate * 1000;
275     }
276   }
277 
278   // Disable padding if only sending one stream and video isn't suspended and
279   // min-transmit bitrate isn't used (applied later).
280   if (!video_is_suspended && send_codec.numberOfSimulcastStreams <= 1)
281     pad_up_to_bitrate_bps = 0;
282 
283   // The amount of padding should decay to zero if no frames are being
284   // captured/encoded unless a min-transmit bitrate is used.
285   int64_t now_ms = TickTime::MillisecondTimestamp();
286   if (now_ms - time_of_last_frame_activity_ms > kStopPaddingThresholdMs)
287     pad_up_to_bitrate_bps = 0;
288 
289   // Pad up to min bitrate.
290   if (pad_up_to_bitrate_bps < min_transmit_bitrate_bps)
291     pad_up_to_bitrate_bps = min_transmit_bitrate_bps;
292 
293   // Padding may never exceed bitrate estimate.
294   if (pad_up_to_bitrate_bps > bitrate_bps)
295     pad_up_to_bitrate_bps = bitrate_bps;
296 
297   return pad_up_to_bitrate_bps;
298 }
299 
EncoderPaused() const300 bool ViEEncoder::EncoderPaused() const {
301   // Pause video if paused by caller or as long as the network is down or the
302   // pacer queue has grown too large in buffered mode.
303   if (encoder_paused_) {
304     return true;
305   }
306   if (target_delay_ms_ > 0) {
307     // Buffered mode.
308     // TODO(pwestin): Workaround until nack is configured as a time and not
309     // number of packets.
310     return pacer_->QueueInMs() >=
311            std::max(
312                static_cast<int>(target_delay_ms_ * kEncoderPausePacerMargin),
313                kMinPacingDelayMs);
314   }
315   if (pacer_->ExpectedQueueTimeMs() > PacedSender::kMaxQueueLengthMs) {
316     // Too much data in pacer queue, drop frame.
317     return true;
318   }
319   return !network_is_transmitting_;
320 }
321 
TraceFrameDropStart()322 void ViEEncoder::TraceFrameDropStart() {
323   // Start trace event only on the first frame after encoder is paused.
324   if (!encoder_paused_and_dropped_frame_) {
325     TRACE_EVENT_ASYNC_BEGIN0("webrtc", "EncoderPaused", this);
326   }
327   encoder_paused_and_dropped_frame_ = true;
328   return;
329 }
330 
TraceFrameDropEnd()331 void ViEEncoder::TraceFrameDropEnd() {
332   // End trace event on first frame after encoder resumes, if frame was dropped.
333   if (encoder_paused_and_dropped_frame_) {
334     TRACE_EVENT_ASYNC_END0("webrtc", "EncoderPaused", this);
335   }
336   encoder_paused_and_dropped_frame_ = false;
337 }
338 
DeliverFrame(VideoFrame video_frame)339 void ViEEncoder::DeliverFrame(VideoFrame video_frame) {
340   RTC_DCHECK(send_payload_router_ != NULL);
341   if (!send_payload_router_->active()) {
342     // We've paused or we have no channels attached, don't waste resources on
343     // encoding.
344     return;
345   }
346   VideoCodecType codec_type;
347   {
348     CriticalSectionScoped cs(data_cs_.get());
349     time_of_last_frame_activity_ms_ = TickTime::MillisecondTimestamp();
350     if (EncoderPaused()) {
351       TraceFrameDropStart();
352       return;
353     }
354     TraceFrameDropEnd();
355     codec_type = encoder_config_.codecType;
356   }
357 
358   TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", video_frame.render_time_ms(),
359                           "Encode");
360   const VideoFrame* frame_to_send = &video_frame;
361   // TODO(wuchengli): support texture frames.
362   if (video_frame.native_handle() == NULL) {
363     // Pass frame via preprocessor.
364     frame_to_send = vp_->PreprocessFrame(video_frame);
365     if (!frame_to_send) {
366       // Drop this frame, or there was an error processing it.
367       return;
368     }
369   }
370 
371   // If we haven't resampled the frame and we have a FrameCallback, we need to
372   // make a deep copy of |video_frame|.
373   VideoFrame copied_frame;
374   if (pre_encode_callback_) {
375     copied_frame.CopyFrame(*frame_to_send);
376     pre_encode_callback_->FrameCallback(&copied_frame);
377     frame_to_send = &copied_frame;
378   }
379 
380   if (codec_type == webrtc::kVideoCodecVP8) {
381     webrtc::CodecSpecificInfo codec_specific_info;
382     codec_specific_info.codecType = webrtc::kVideoCodecVP8;
383     {
384       CriticalSectionScoped cs(data_cs_.get());
385       codec_specific_info.codecSpecific.VP8.hasReceivedRPSI =
386           has_received_rpsi_;
387       codec_specific_info.codecSpecific.VP8.hasReceivedSLI =
388           has_received_sli_;
389       codec_specific_info.codecSpecific.VP8.pictureIdRPSI =
390           picture_id_rpsi_;
391       codec_specific_info.codecSpecific.VP8.pictureIdSLI  =
392           picture_id_sli_;
393       has_received_sli_ = false;
394       has_received_rpsi_ = false;
395     }
396 
397     vcm_->AddVideoFrame(*frame_to_send, vp_->GetContentMetrics(),
398                         &codec_specific_info);
399     return;
400   }
401   vcm_->AddVideoFrame(*frame_to_send);
402 }
403 
SendKeyFrame()404 int ViEEncoder::SendKeyFrame() {
405   return vcm_->IntraFrameRequest(0);
406 }
407 
LastObservedBitrateBps() const408 uint32_t ViEEncoder::LastObservedBitrateBps() const {
409   CriticalSectionScoped cs(data_cs_.get());
410   return last_observed_bitrate_bps_;
411 }
412 
CodecTargetBitrate(uint32_t * bitrate) const413 int ViEEncoder::CodecTargetBitrate(uint32_t* bitrate) const {
414   if (vcm_->Bitrate(bitrate) != 0)
415     return -1;
416   return 0;
417 }
418 
SetProtectionMethod(bool nack,bool fec)419 void ViEEncoder::SetProtectionMethod(bool nack, bool fec) {
420   // Set Video Protection for VCM.
421   VCMVideoProtection protection_mode;
422   if (fec) {
423     protection_mode =
424         nack ? webrtc::kProtectionNackFEC : kProtectionFEC;
425   } else {
426     protection_mode = nack ? kProtectionNack : kProtectionNone;
427   }
428   vcm_->SetVideoProtection(protection_mode, true);
429 }
430 
SetSenderBufferingMode(int target_delay_ms)431 void ViEEncoder::SetSenderBufferingMode(int target_delay_ms) {
432   {
433     CriticalSectionScoped cs(data_cs_.get());
434     target_delay_ms_ = target_delay_ms;
435   }
436   if (target_delay_ms > 0) {
437     // Disable external frame-droppers.
438     vcm_->EnableFrameDropper(false);
439     vp_->EnableTemporalDecimation(false);
440   } else {
441     // Real-time mode - enable frame droppers.
442     vp_->EnableTemporalDecimation(true);
443     vcm_->EnableFrameDropper(true);
444   }
445 }
446 
OnSetRates(uint32_t bitrate_bps,int framerate)447 void ViEEncoder::OnSetRates(uint32_t bitrate_bps, int framerate) {
448   if (stats_proxy_)
449     stats_proxy_->OnSetRates(bitrate_bps, framerate);
450 }
451 
SendData(const uint8_t payload_type,const EncodedImage & encoded_image,const webrtc::RTPFragmentationHeader & fragmentation_header,const RTPVideoHeader * rtp_video_hdr)452 int32_t ViEEncoder::SendData(
453     const uint8_t payload_type,
454     const EncodedImage& encoded_image,
455     const webrtc::RTPFragmentationHeader& fragmentation_header,
456     const RTPVideoHeader* rtp_video_hdr) {
457   RTC_DCHECK(send_payload_router_ != NULL);
458 
459   {
460     CriticalSectionScoped cs(data_cs_.get());
461     time_of_last_frame_activity_ms_ = TickTime::MillisecondTimestamp();
462   }
463 
464   if (stats_proxy_ != NULL)
465     stats_proxy_->OnSendEncodedImage(encoded_image, rtp_video_hdr);
466 
467   return send_payload_router_->RoutePayload(
468              encoded_image._frameType, payload_type, encoded_image._timeStamp,
469              encoded_image.capture_time_ms_, encoded_image._buffer,
470              encoded_image._length, &fragmentation_header, rtp_video_hdr)
471              ? 0
472              : -1;
473 }
474 
OnEncoderImplementationName(const char * implementation_name)475 void ViEEncoder::OnEncoderImplementationName(
476     const char* implementation_name) {
477   if (stats_proxy_)
478     stats_proxy_->OnEncoderImplementationName(implementation_name);
479 }
480 
SendStatistics(const uint32_t bit_rate,const uint32_t frame_rate)481 int32_t ViEEncoder::SendStatistics(const uint32_t bit_rate,
482                                    const uint32_t frame_rate) {
483   if (stats_proxy_)
484     stats_proxy_->OnOutgoingRate(frame_rate, bit_rate);
485   return 0;
486 }
487 
OnReceivedSLI(uint32_t,uint8_t picture_id)488 void ViEEncoder::OnReceivedSLI(uint32_t /*ssrc*/,
489                                uint8_t picture_id) {
490   CriticalSectionScoped cs(data_cs_.get());
491   picture_id_sli_ = picture_id;
492   has_received_sli_ = true;
493 }
494 
OnReceivedRPSI(uint32_t,uint64_t picture_id)495 void ViEEncoder::OnReceivedRPSI(uint32_t /*ssrc*/,
496                                 uint64_t picture_id) {
497   CriticalSectionScoped cs(data_cs_.get());
498   picture_id_rpsi_ = picture_id;
499   has_received_rpsi_ = true;
500 }
501 
OnReceivedIntraFrameRequest(uint32_t ssrc)502 void ViEEncoder::OnReceivedIntraFrameRequest(uint32_t ssrc) {
503   // Key frame request from remote side, signal to VCM.
504   TRACE_EVENT0("webrtc", "OnKeyFrameRequest");
505 
506   int idx = 0;
507   {
508     CriticalSectionScoped cs(data_cs_.get());
509     auto stream_it = ssrc_streams_.find(ssrc);
510     if (stream_it == ssrc_streams_.end()) {
511       LOG_F(LS_WARNING) << "ssrc not found: " << ssrc << ", map size "
512                         << ssrc_streams_.size();
513       return;
514     }
515     std::map<unsigned int, int64_t>::iterator time_it =
516         time_last_intra_request_ms_.find(ssrc);
517     if (time_it == time_last_intra_request_ms_.end()) {
518       time_last_intra_request_ms_[ssrc] = 0;
519     }
520 
521     int64_t now = TickTime::MillisecondTimestamp();
522     if (time_last_intra_request_ms_[ssrc] + kMinKeyFrameRequestIntervalMs
523         > now) {
524       return;
525     }
526     time_last_intra_request_ms_[ssrc] = now;
527     idx = stream_it->second;
528   }
529   // Release the critsect before triggering key frame.
530   vcm_->IntraFrameRequest(idx);
531 }
532 
OnLocalSsrcChanged(uint32_t old_ssrc,uint32_t new_ssrc)533 void ViEEncoder::OnLocalSsrcChanged(uint32_t old_ssrc, uint32_t new_ssrc) {
534   CriticalSectionScoped cs(data_cs_.get());
535   std::map<unsigned int, int>::iterator it = ssrc_streams_.find(old_ssrc);
536   if (it == ssrc_streams_.end()) {
537     return;
538   }
539 
540   ssrc_streams_[new_ssrc] = it->second;
541   ssrc_streams_.erase(it);
542 
543   std::map<unsigned int, int64_t>::iterator time_it =
544       time_last_intra_request_ms_.find(old_ssrc);
545   int64_t last_intra_request_ms = 0;
546   if (time_it != time_last_intra_request_ms_.end()) {
547     last_intra_request_ms = time_it->second;
548     time_last_intra_request_ms_.erase(time_it);
549   }
550   time_last_intra_request_ms_[new_ssrc] = last_intra_request_ms;
551 }
552 
SetSsrcs(const std::vector<uint32_t> & ssrcs)553 void ViEEncoder::SetSsrcs(const std::vector<uint32_t>& ssrcs) {
554   CriticalSectionScoped cs(data_cs_.get());
555   ssrc_streams_.clear();
556   time_last_intra_request_ms_.clear();
557   int idx = 0;
558   for (uint32_t ssrc : ssrcs) {
559     ssrc_streams_[ssrc] = idx++;
560   }
561 }
562 
SetMinTransmitBitrate(int min_transmit_bitrate_kbps)563 void ViEEncoder::SetMinTransmitBitrate(int min_transmit_bitrate_kbps) {
564   assert(min_transmit_bitrate_kbps >= 0);
565   CriticalSectionScoped crit(data_cs_.get());
566   min_transmit_bitrate_kbps_ = min_transmit_bitrate_kbps;
567 }
568 
569 // Called from ViEBitrateObserver.
OnNetworkChanged(uint32_t bitrate_bps,uint8_t fraction_lost,int64_t round_trip_time_ms)570 void ViEEncoder::OnNetworkChanged(uint32_t bitrate_bps,
571                                   uint8_t fraction_lost,
572                                   int64_t round_trip_time_ms) {
573   LOG(LS_VERBOSE) << "OnNetworkChanged, bitrate" << bitrate_bps
574                   << " packet loss " << static_cast<int>(fraction_lost)
575                   << " rtt " << round_trip_time_ms;
576   RTC_DCHECK(send_payload_router_ != NULL);
577   vcm_->SetChannelParameters(bitrate_bps, fraction_lost, round_trip_time_ms);
578   bool video_is_suspended = vcm_->VideoSuspended();
579   bool video_suspension_changed;
580   VideoCodec send_codec;
581   uint32_t first_ssrc;
582   {
583     CriticalSectionScoped cs(data_cs_.get());
584     last_observed_bitrate_bps_ = bitrate_bps;
585     video_suspension_changed = video_suspended_ != video_is_suspended;
586     video_suspended_ = video_is_suspended;
587     send_codec = encoder_config_;
588     first_ssrc = ssrc_streams_.begin()->first;
589   }
590 
591   SimulcastStream* stream_configs = send_codec.simulcastStream;
592   // Allocate the bandwidth between the streams.
593   std::vector<uint32_t> stream_bitrates = AllocateStreamBitrates(
594       bitrate_bps, stream_configs, send_codec.numberOfSimulcastStreams);
595   send_payload_router_->SetTargetSendBitrates(stream_bitrates);
596 
597   if (!video_suspension_changed)
598     return;
599   // Video suspend-state changed, inform codec observer.
600   LOG(LS_INFO) << "Video suspend state changed " << video_is_suspended
601                << " for ssrc " << first_ssrc;
602   if (stats_proxy_)
603     stats_proxy_->OnSuspendChange(video_is_suspended);
604 }
605 
SuspendBelowMinBitrate()606 void ViEEncoder::SuspendBelowMinBitrate() {
607   vcm_->SuspendBelowMinBitrate();
608   bitrate_allocator_->EnforceMinBitrate(false);
609 }
610 
RegisterPostEncodeImageCallback(EncodedImageCallback * post_encode_callback)611 void ViEEncoder::RegisterPostEncodeImageCallback(
612       EncodedImageCallback* post_encode_callback) {
613   vcm_->RegisterPostEncodeImageCallback(post_encode_callback);
614 }
615 
QMVideoSettingsCallback(VideoProcessing * vpm)616 QMVideoSettingsCallback::QMVideoSettingsCallback(VideoProcessing* vpm)
617     : vp_(vpm) {
618 }
619 
~QMVideoSettingsCallback()620 QMVideoSettingsCallback::~QMVideoSettingsCallback() {
621 }
622 
SetVideoQMSettings(const uint32_t frame_rate,const uint32_t width,const uint32_t height)623 int32_t QMVideoSettingsCallback::SetVideoQMSettings(
624     const uint32_t frame_rate,
625     const uint32_t width,
626     const uint32_t height) {
627   return vp_->SetTargetResolution(width, height, frame_rate);
628 }
629 
SetTargetFramerate(int frame_rate)630 void QMVideoSettingsCallback::SetTargetFramerate(int frame_rate) {
631   vp_->SetTargetFramerate(frame_rate);
632 }
633 
634 }  // namespace webrtc
635