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
38namespace webrtc {
39
40// Margin on when we pause the encoder when the pacing buffer overflows relative
41// to the configured buffer delay.
42static const float kEncoderPausePacerMargin = 2.0f;
43
44// Don't stop the encoder unless the delay is above this configured value.
45static const int kMinPacingDelayMs = 200;
46
47static const float kStopPaddingThresholdMs = 2000;
48
49static const int kMinKeyFrameRequestIntervalMs = 300;
50
51std::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
73class 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
91class ViEBitrateObserver : public BitrateObserver {
92 public:
93  explicit ViEBitrateObserver(ViEEncoder* owner)
94      : owner_(owner) {
95  }
96  virtual ~ViEBitrateObserver() {}
97  // Implements BitrateObserver.
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
107ViEEncoder::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
142bool 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
157void 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
167void ViEEncoder::StopThreadsAndRemoveSharedMembers() {
168  if (bitrate_allocator_)
169    bitrate_allocator_->RemoveBitrateObserver(bitrate_observer_.get());
170  module_process_thread_->DeRegisterModule(vcm_.get());
171}
172
173ViEEncoder::~ViEEncoder() {
174}
175
176void ViEEncoder::SetNetworkTransmissionState(bool is_transmitting) {
177  {
178    CriticalSectionScoped cs(data_cs_.get());
179    network_is_transmitting_ = is_transmitting;
180  }
181}
182
183void ViEEncoder::Pause() {
184  CriticalSectionScoped cs(data_cs_.get());
185  encoder_paused_ = true;
186}
187
188void ViEEncoder::Restart() {
189  CriticalSectionScoped cs(data_cs_.get());
190  encoder_paused_ = false;
191}
192
193int32_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
203int32_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
210int32_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
243int 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
300bool 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
322void 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
331void 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
339void 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
404int ViEEncoder::SendKeyFrame() {
405  return vcm_->IntraFrameRequest(0);
406}
407
408uint32_t ViEEncoder::LastObservedBitrateBps() const {
409  CriticalSectionScoped cs(data_cs_.get());
410  return last_observed_bitrate_bps_;
411}
412
413int ViEEncoder::CodecTargetBitrate(uint32_t* bitrate) const {
414  if (vcm_->Bitrate(bitrate) != 0)
415    return -1;
416  return 0;
417}
418
419void 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
431void 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
447void ViEEncoder::OnSetRates(uint32_t bitrate_bps, int framerate) {
448  if (stats_proxy_)
449    stats_proxy_->OnSetRates(bitrate_bps, framerate);
450}
451
452int32_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
475void ViEEncoder::OnEncoderImplementationName(
476    const char* implementation_name) {
477  if (stats_proxy_)
478    stats_proxy_->OnEncoderImplementationName(implementation_name);
479}
480
481int32_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
488void 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
495void 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
502void 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
533void 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
553void 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
563void 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.
570void 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
606void ViEEncoder::SuspendBelowMinBitrate() {
607  vcm_->SuspendBelowMinBitrate();
608  bitrate_allocator_->EnforceMinBitrate(false);
609}
610
611void ViEEncoder::RegisterPostEncodeImageCallback(
612      EncodedImageCallback* post_encode_callback) {
613  vcm_->RegisterPostEncodeImageCallback(post_encode_callback);
614}
615
616QMVideoSettingsCallback::QMVideoSettingsCallback(VideoProcessing* vpm)
617    : vp_(vpm) {
618}
619
620QMVideoSettingsCallback::~QMVideoSettingsCallback() {
621}
622
623int32_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
630void QMVideoSettingsCallback::SetTargetFramerate(int frame_rate) {
631  vp_->SetTargetFramerate(frame_rate);
632}
633
634}  // namespace webrtc
635