blob: 340a78ef33d42aadb9ac74ae1400e49a6adbec4e [file] [log] [blame]
niklase@google.com470e71d2011-07-07 08:21:251/*
stefan@webrtc.org07b45a52012-02-02 08:37:482 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
niklase@google.com470e71d2011-07-07 08:21:253 *
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
pbos@webrtc.orgf5d4cb12013-05-17 13:44:4811#include "webrtc/video_engine/vie_encoder.h"
mflodman@webrtc.org84d17832011-12-01 17:02:2312
pbos@webrtc.org12dc1a32013-08-05 16:22:5313#include <assert.h>
14
stefan@webrtc.orgc3cc3752013-06-04 09:36:5615#include <algorithm>
niklase@google.com470e71d2011-07-07 08:21:2516
mflodman@webrtc.org02270cd2015-02-06 13:10:1917#include "webrtc/base/checks.h"
sprang@webrtc.org40709352013-11-26 11:41:5918#include "webrtc/common_video/interface/video_image.h"
pbos@webrtc.orgf5d4cb12013-05-17 13:44:4819#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
pbos@webrtc.org273a4142014-12-01 15:23:2120#include "webrtc/frame_callback.h"
Peter Boström8e4e8b02015-09-15 13:08:0321#include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
pbos@webrtc.orgf5d4cb12013-05-17 13:44:4822#include "webrtc/modules/pacing/include/paced_sender.h"
pbos@webrtc.orgf5d4cb12013-05-17 13:44:4823#include "webrtc/modules/utility/interface/process_thread.h"
24#include "webrtc/modules/video_coding/codecs/interface/video_codec_interface.h"
25#include "webrtc/modules/video_coding/main/interface/video_coding.h"
26#include "webrtc/modules/video_coding/main/interface/video_coding_defines.h"
sprang@webrtc.org40709352013-11-26 11:41:5927#include "webrtc/modules/video_coding/main/source/encoded_frame.h"
stefan@webrtc.org88e0dda2014-07-04 09:20:4228#include "webrtc/system_wrappers/interface/clock.h"
pbos@webrtc.orgf5d4cb12013-05-17 13:44:4829#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
30#include "webrtc/system_wrappers/interface/logging.h"
asapersson@webrtc.org96dc6852014-11-03 14:40:3831#include "webrtc/system_wrappers/interface/metrics.h"
pbos@webrtc.orgf5d4cb12013-05-17 13:44:4832#include "webrtc/system_wrappers/interface/tick_util.h"
pbos@webrtc.orgf5d4cb12013-05-17 13:44:4833#include "webrtc/system_wrappers/interface/trace_event.h"
pbos@webrtc.org273a4142014-12-01 15:23:2134#include "webrtc/video/send_statistics_proxy.h"
mflodman@webrtc.org02270cd2015-02-06 13:10:1935#include "webrtc/video_engine/payload_router.h"
pbos@webrtc.orgf5d4cb12013-05-17 13:44:4836#include "webrtc/video_engine/vie_defines.h"
niklase@google.com470e71d2011-07-07 08:21:2537
niklase@google.com470e71d2011-07-07 08:21:2538namespace webrtc {
39
pwestin@webrtc.org52b4e882013-05-02 19:02:1740// 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
pwestin@webrtc.org91563e42013-04-25 22:20:0844// Don't stop the encoder unless the delay is above this configured value.
45static const int kMinPacingDelayMs = 200;
46
stefan@webrtc.org3e005052013-10-18 15:05:2947static const float kStopPaddingThresholdMs = 2000;
48
stefan@webrtc.orgb2c8a952013-09-06 13:58:0149std::vector<uint32_t> AllocateStreamBitrates(
50 uint32_t total_bitrate,
51 const SimulcastStream* stream_configs,
52 size_t number_of_streams) {
53 if (number_of_streams == 0) {
54 std::vector<uint32_t> stream_bitrates(1, 0);
55 stream_bitrates[0] = total_bitrate;
56 return stream_bitrates;
57 }
58 std::vector<uint32_t> stream_bitrates(number_of_streams, 0);
59 uint32_t bitrate_remainder = total_bitrate;
60 for (size_t i = 0; i < stream_bitrates.size() && bitrate_remainder > 0; ++i) {
61 if (stream_configs[i].maxBitrate * 1000 > bitrate_remainder) {
62 stream_bitrates[i] = bitrate_remainder;
63 } else {
64 stream_bitrates[i] = stream_configs[i].maxBitrate * 1000;
65 }
66 bitrate_remainder -= stream_bitrates[i];
67 }
68 return stream_bitrates;
69}
70
stefan@webrtc.org439be292012-02-16 14:45:3771class QMVideoSettingsCallback : public VCMQMSettingsCallback {
mflodman@webrtc.org84d17832011-12-01 17:02:2372 public:
marpan@webrtc.orgefd01fd2012-04-18 15:56:3473 explicit QMVideoSettingsCallback(VideoProcessingModule* vpm);
mflodman@webrtc.org6879c8a2013-07-23 11:35:0074
stefan@webrtc.org439be292012-02-16 14:45:3775 ~QMVideoSettingsCallback();
niklase@google.com470e71d2011-07-07 08:21:2576
mflodman@webrtc.org84d17832011-12-01 17:02:2377 // Update VPM with QM (quality modes: frame size & frame rate) settings.
pbos@webrtc.orgb238d122013-04-09 13:41:5178 int32_t SetVideoQMSettings(const uint32_t frame_rate,
79 const uint32_t width,
80 const uint32_t height);
niklase@google.com470e71d2011-07-07 08:21:2581
jackychen6e2ce6e2015-07-13 23:26:3382 // Update target frame rate.
83 void SetTargetFramerate(int frame_rate);
84
mflodman@webrtc.org84d17832011-12-01 17:02:2385 private:
86 VideoProcessingModule* vpm_;
mflodman@webrtc.org84d17832011-12-01 17:02:2387};
niklase@google.com470e71d2011-07-07 08:21:2588
pwestin@webrtc.org49888ce2012-04-27 05:25:5389class ViEBitrateObserver : public BitrateObserver {
90 public:
mflodman@webrtc.orgf5e99db2012-06-27 09:49:3791 explicit ViEBitrateObserver(ViEEncoder* owner)
pwestin@webrtc.org49888ce2012-04-27 05:25:5392 : owner_(owner) {
93 }
mflodman@webrtc.org6879c8a2013-07-23 11:35:0094 virtual ~ViEBitrateObserver() {}
pwestin@webrtc.org49888ce2012-04-27 05:25:5395 // Implements BitrateObserver.
stefan@webrtc.orgedeea912014-12-08 19:46:2396 virtual void OnNetworkChanged(uint32_t bitrate_bps,
97 uint8_t fraction_lost,
pkasting@chromium.org16825b12015-01-12 21:51:2198 int64_t rtt) {
pwestin@webrtc.org49888ce2012-04-27 05:25:5399 owner_->OnNetworkChanged(bitrate_bps, fraction_lost, rtt);
100 }
101 private:
102 ViEEncoder* owner_;
103};
niklase@google.com470e71d2011-07-07 08:21:25104
mflodman0dbf0092015-10-19 15:12:12105ViEEncoder::ViEEncoder(uint32_t number_of_cores,
Peter Boström7083e112015-09-22 14:28:51106 ProcessThread* module_process_thread,
107 SendStatisticsProxy* stats_proxy,
108 I420FrameCallback* pre_encode_callback,
Stefan Holmere5904162015-03-26 10:11:06109 PacedSender* pacer,
Peter Boström8e4e8b02015-09-15 13:08:03110 BitrateAllocator* bitrate_allocator)
mflodman0dbf0092015-10-19 15:12:12111 : number_of_cores_(number_of_cores),
Peter Boströmf4aa4c22015-09-18 10:24:25112 vpm_(VideoProcessingModule::Create()),
mflodmanfcf54bd2015-04-14 19:28:08113 qm_callback_(new QMVideoSettingsCallback(vpm_.get())),
114 vcm_(VideoCodingModule::Create(Clock::GetRealTimeClock(),
115 this,
116 qm_callback_.get())),
stefan@webrtc.org792f1a12015-03-04 12:24:26117 send_payload_router_(NULL),
stefan@webrtc.org792f1a12015-03-04 12:24:26118 data_cs_(CriticalSectionWrapper::CreateCriticalSection()),
Peter Boström7083e112015-09-22 14:28:51119 stats_proxy_(stats_proxy),
120 pre_encode_callback_(pre_encode_callback),
Stefan Holmere5904162015-03-26 10:11:06121 pacer_(pacer),
stefan@webrtc.org792f1a12015-03-04 12:24:26122 bitrate_allocator_(bitrate_allocator),
Noah Richards099323e2015-04-15 16:14:12123 time_of_last_frame_activity_ms_(0),
Peter Boströma7531772015-09-15 11:12:24124 simulcast_enabled_(false),
stefan@webrtc.org792f1a12015-03-04 12:24:26125 min_transmit_bitrate_kbps_(0),
pbos@webrtc.org143451d2015-03-18 14:40:03126 last_observed_bitrate_bps_(0),
stefan@webrtc.org792f1a12015-03-04 12:24:26127 target_delay_ms_(0),
128 network_is_transmitting_(true),
129 encoder_paused_(false),
130 encoder_paused_and_dropped_frame_(false),
131 fec_enabled_(false),
132 nack_enabled_(false),
stefan@webrtc.org792f1a12015-03-04 12:24:26133 module_process_thread_(module_process_thread),
stefan@webrtc.org792f1a12015-03-04 12:24:26134 has_received_sli_(false),
135 picture_id_sli_(0),
136 has_received_rpsi_(false),
137 picture_id_rpsi_(0),
asaperssondec5ebf2015-10-05 09:36:17138 video_suspended_(false) {
pwestin@webrtc.org49888ce2012-04-27 05:25:53139 bitrate_observer_.reset(new ViEBitrateObserver(this));
wu@webrtc.org5d8c1022012-04-10 16:54:05140}
141
142bool ViEEncoder::Init() {
mflodmanfcf54bd2015-04-14 19:28:08143 vpm_->EnableTemporalDecimation(true);
mflodman@webrtc.org84d17832011-12-01 17:02:23144
145 // Enable/disable content analysis: off by default for now.
mflodmanfcf54bd2015-04-14 19:28:08146 vpm_->EnableContentAnalysis(false);
niklase@google.com470e71d2011-07-07 08:21:25147
mflodmanfcf54bd2015-04-14 19:28:08148 if (vcm_->RegisterTransportCallback(this) != 0) {
wu@webrtc.org5d8c1022012-04-10 16:54:05149 return false;
mflodman@webrtc.org84d17832011-12-01 17:02:23150 }
mflodmanfcf54bd2015-04-14 19:28:08151 if (vcm_->RegisterSendStatisticsCallback(this) != 0) {
wu@webrtc.org5d8c1022012-04-10 16:54:05152 return false;
mflodman@webrtc.org84d17832011-12-01 17:02:23153 }
wu@webrtc.org5d8c1022012-04-10 16:54:05154 return true;
niklase@google.com470e71d2011-07-07 08:21:25155}
156
mflodman@webrtc.org96abda02015-02-25 13:50:10157void ViEEncoder::StartThreadsAndSetSharedMembers(
Peter Boström26b08602015-06-04 13:18:17158 rtc::scoped_refptr<PayloadRouter> send_payload_router,
mflodman@webrtc.org96abda02015-02-25 13:50:10159 VCMProtectionCallback* vcm_protection_callback) {
henrikg91d6ede2015-09-17 07:24:34160 RTC_DCHECK(send_payload_router_ == NULL);
mflodman@webrtc.org96abda02015-02-25 13:50:10161
mflodman@webrtc.org02270cd2015-02-06 13:10:19162 send_payload_router_ = send_payload_router;
mflodmanfcf54bd2015-04-14 19:28:08163 vcm_->RegisterProtectionCallback(vcm_protection_callback);
Peter Boström7083e112015-09-22 14:28:51164 module_process_thread_->RegisterModule(vcm_.get());
mflodman@webrtc.org290cb562015-02-17 10:15:06165}
166
mflodman@webrtc.org96abda02015-02-25 13:50:10167void ViEEncoder::StopThreadsAndRemoveSharedMembers() {
mflodmanfcf54bd2015-04-14 19:28:08168 if (bitrate_allocator_)
169 bitrate_allocator_->RemoveBitrateObserver(bitrate_observer_.get());
Peter Boström7083e112015-09-22 14:28:51170 module_process_thread_->DeRegisterModule(vcm_.get());
171 module_process_thread_->DeRegisterModule(vpm_.get());
mflodman@webrtc.org02270cd2015-02-06 13:10:19172}
173
mflodman@webrtc.org84d17832011-12-01 17:02:23174ViEEncoder::~ViEEncoder() {
asapersson@webrtc.org96dc6852014-11-03 14:40:38175}
176
stefan@webrtc.orgbfacda62013-03-27 16:36:01177void ViEEncoder::SetNetworkTransmissionState(bool is_transmitting) {
stefan@webrtc.orgbfacda62013-03-27 16:36:01178 {
179 CriticalSectionScoped cs(data_cs_.get());
180 network_is_transmitting_ = is_transmitting;
181 }
stefan@webrtc.orgbfacda62013-03-27 16:36:01182}
183
mflodman@webrtc.org84d17832011-12-01 17:02:23184void ViEEncoder::Pause() {
mflodman@webrtc.orgd32c4472011-12-22 14:17:53185 CriticalSectionScoped cs(data_cs_.get());
stefan@webrtc.orgbfacda62013-03-27 16:36:01186 encoder_paused_ = true;
niklase@google.com470e71d2011-07-07 08:21:25187}
188
mflodman@webrtc.org84d17832011-12-01 17:02:23189void ViEEncoder::Restart() {
mflodman@webrtc.orgd32c4472011-12-22 14:17:53190 CriticalSectionScoped cs(data_cs_.get());
stefan@webrtc.orgbfacda62013-03-27 16:36:01191 encoder_paused_ = false;
mflodman@webrtc.org84d17832011-12-01 17:02:23192}
193
pbos@webrtc.orgb238d122013-04-09 13:41:51194uint8_t ViEEncoder::NumberOfCodecs() {
mflodmanfcf54bd2015-04-14 19:28:08195 return vcm_->NumberOfCodecs();
mflodman@webrtc.org84d17832011-12-01 17:02:23196}
197
pbos@webrtc.orgb238d122013-04-09 13:41:51198int32_t ViEEncoder::GetCodec(uint8_t list_index, VideoCodec* video_codec) {
mflodmanfcf54bd2015-04-14 19:28:08199 if (vcm_->Codec(list_index, video_codec) != 0) {
mflodman@webrtc.org84d17832011-12-01 17:02:23200 return -1;
201 }
202 return 0;
203}
204
pbos@webrtc.orgb238d122013-04-09 13:41:51205int32_t ViEEncoder::RegisterExternalEncoder(webrtc::VideoEncoder* encoder,
206 uint8_t pl_type,
207 bool internal_source) {
mflodman@webrtc.org84d17832011-12-01 17:02:23208 if (encoder == NULL)
209 return -1;
210
mflodmanfcf54bd2015-04-14 19:28:08211 if (vcm_->RegisterExternalEncoder(encoder, pl_type, internal_source) !=
mflodman@webrtc.org5574dac2014-04-07 10:56:31212 VCM_OK) {
mflodman@webrtc.org84d17832011-12-01 17:02:23213 return -1;
214 }
215 return 0;
216}
217
pbos@webrtc.orgb238d122013-04-09 13:41:51218int32_t ViEEncoder::DeRegisterExternalEncoder(uint8_t pl_type) {
mflodmanfcf54bd2015-04-14 19:28:08219 if (vcm_->RegisterExternalEncoder(NULL, pl_type) != VCM_OK) {
mflodman@webrtc.org84d17832011-12-01 17:02:23220 return -1;
221 }
mflodman@webrtc.org84d17832011-12-01 17:02:23222 return 0;
223}
224
pbos@webrtc.orgb238d122013-04-09 13:41:51225int32_t ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec) {
henrikg91d6ede2015-09-17 07:24:34226 RTC_DCHECK(send_payload_router_ != NULL);
mflodman@webrtc.org84d17832011-12-01 17:02:23227 // Setting target width and height for VPM.
mflodmanfcf54bd2015-04-14 19:28:08228 if (vpm_->SetTargetResolution(video_codec.width, video_codec.height,
229 video_codec.maxFramerate) != VPM_OK) {
mflodman@webrtc.org84d17832011-12-01 17:02:23230 return -1;
231 }
232
stefan@webrtc.org9075d512014-02-14 09:45:58233 {
234 CriticalSectionScoped cs(data_cs_.get());
Peter Boströma7531772015-09-15 11:12:24235 simulcast_enabled_ = video_codec.numberOfSimulcastStreams > 1;
stefan@webrtc.org9075d512014-02-14 09:45:58236 }
Stefan Holmere5904162015-03-26 10:11:06237
238 // Add a bitrate observer to the allocator and update the start, max and
239 // min bitrates of the bitrate controller as needed.
Peter Boström8e4e8b02015-09-15 13:08:03240 int allocated_bitrate_bps = bitrate_allocator_->AddBitrateObserver(
241 bitrate_observer_.get(), video_codec.minBitrate * 1000,
242 video_codec.maxBitrate * 1000);
Stefan Holmere5904162015-03-26 10:11:06243
244 webrtc::VideoCodec modified_video_codec = video_codec;
245 modified_video_codec.startBitrate = allocated_bitrate_bps / 1000;
246
mflodman@webrtc.orga4ef2ce2015-02-12 09:54:18247 size_t max_data_payload_length = send_payload_router_->MaxPayloadLength();
mflodmanfcf54bd2015-04-14 19:28:08248 if (vcm_->RegisterSendCodec(&modified_video_codec, number_of_cores_,
Peter Boströmae37abb2015-06-18 17:00:34249 static_cast<uint32_t>(max_data_payload_length)) !=
250 VCM_OK) {
mflodman@webrtc.org84d17832011-12-01 17:02:23251 return -1;
252 }
mflodman@webrtc.org84d17832011-12-01 17:02:23253 return 0;
254}
255
pbos@webrtc.orgb238d122013-04-09 13:41:51256int32_t ViEEncoder::GetEncoder(VideoCodec* video_codec) {
mflodmanfcf54bd2015-04-14 19:28:08257 *video_codec = vcm_->GetSendCodec();
mflodman@webrtc.org84d17832011-12-01 17:02:23258 return 0;
259}
niklase@google.com470e71d2011-07-07 08:21:25260
pbos@webrtc.orgb238d122013-04-09 13:41:51261int32_t ViEEncoder::GetCodecConfigParameters(
mflodman@webrtc.org84d17832011-12-01 17:02:23262 unsigned char config_parameters[kConfigParameterSize],
263 unsigned char& config_parameters_size) {
pbos@webrtc.orgb238d122013-04-09 13:41:51264 int32_t num_parameters =
mflodmanfcf54bd2015-04-14 19:28:08265 vcm_->CodecConfigParameters(config_parameters, kConfigParameterSize);
mflodman@webrtc.org84d17832011-12-01 17:02:23266 if (num_parameters <= 0) {
267 config_parameters_size = 0;
mflodman@webrtc.org84d17832011-12-01 17:02:23268 return -1;
269 }
270 config_parameters_size = static_cast<unsigned char>(num_parameters);
271 return 0;
niklase@google.com470e71d2011-07-07 08:21:25272}
273
pbos@webrtc.orgb238d122013-04-09 13:41:51274int32_t ViEEncoder::ScaleInputImage(bool enable) {
mflodman@webrtc.org84d17832011-12-01 17:02:23275 VideoFrameResampling resampling_mode = kFastRescaling;
mflodman@webrtc.org5574dac2014-04-07 10:56:31276 // TODO(mflodman) What?
277 if (enable) {
mflodman@webrtc.org84d17832011-12-01 17:02:23278 // kInterpolation is currently not supported.
mflodman@webrtc.org5574dac2014-04-07 10:56:31279 LOG_F(LS_ERROR) << "Not supported.";
mflodman@webrtc.org84d17832011-12-01 17:02:23280 return -1;
281 }
mflodmanfcf54bd2015-04-14 19:28:08282 vpm_->SetInputFrameResampleMode(resampling_mode);
niklase@google.com470e71d2011-07-07 08:21:25283
mflodman@webrtc.org84d17832011-12-01 17:02:23284 return 0;
niklase@google.com470e71d2011-07-07 08:21:25285}
286
stefana4a8d4a2015-07-15 11:39:22287int ViEEncoder::GetPaddingNeededBps() const {
Noah Richards099323e2015-04-15 16:14:12288 int64_t time_of_last_frame_activity_ms;
stefan@webrtc.org792f1a12015-03-04 12:24:26289 int min_transmit_bitrate_bps;
stefana4a8d4a2015-07-15 11:39:22290 int bitrate_bps;
henrik.lundin@webrtc.org331d4402013-11-21 14:05:40291 {
292 CriticalSectionScoped cs(data_cs_.get());
Peter Boströma7531772015-09-15 11:12:24293 bool send_padding = simulcast_enabled_ || video_suspended_ ||
294 min_transmit_bitrate_kbps_ > 0;
stefan@webrtc.org792f1a12015-03-04 12:24:26295 if (!send_padding)
296 return 0;
Noah Richards099323e2015-04-15 16:14:12297 time_of_last_frame_activity_ms = time_of_last_frame_activity_ms_;
stefan@webrtc.org792f1a12015-03-04 12:24:26298 min_transmit_bitrate_bps = 1000 * min_transmit_bitrate_kbps_;
stefana4a8d4a2015-07-15 11:39:22299 bitrate_bps = last_observed_bitrate_bps_;
henrik.lundin@webrtc.org331d4402013-11-21 14:05:40300 }
stefan@webrtc.org792f1a12015-03-04 12:24:26301
302 VideoCodec send_codec;
mflodmanfcf54bd2015-04-14 19:28:08303 if (vcm_->SendCodec(&send_codec) != 0)
stefan@webrtc.org792f1a12015-03-04 12:24:26304 return 0;
stefan@webrtc.org792f1a12015-03-04 12:24:26305
mflodmanfcf54bd2015-04-14 19:28:08306 bool video_is_suspended = vcm_->VideoSuspended();
stefan@webrtc.org792f1a12015-03-04 12:24:26307
308 // Find the max amount of padding we can allow ourselves to send at this
309 // point, based on which streams are currently active and what our current
310 // available bandwidth is.
311 int pad_up_to_bitrate_bps = 0;
312 if (send_codec.numberOfSimulcastStreams == 0) {
313 pad_up_to_bitrate_bps = send_codec.minBitrate * 1000;
314 } else {
stefana4a8d4a2015-07-15 11:39:22315 SimulcastStream* stream_configs = send_codec.simulcastStream;
stefan@webrtc.org792f1a12015-03-04 12:24:26316 pad_up_to_bitrate_bps =
317 stream_configs[send_codec.numberOfSimulcastStreams - 1].minBitrate *
318 1000;
319 for (int i = 0; i < send_codec.numberOfSimulcastStreams - 1; ++i) {
320 pad_up_to_bitrate_bps += stream_configs[i].targetBitrate * 1000;
321 }
stefan@webrtc.org508a84b2013-06-17 12:53:37322 }
stefan@webrtc.org792f1a12015-03-04 12:24:26323
324 // Disable padding if only sending one stream and video isn't suspended and
325 // min-transmit bitrate isn't used (applied later).
326 if (!video_is_suspended && send_codec.numberOfSimulcastStreams <= 1)
327 pad_up_to_bitrate_bps = 0;
328
329 // The amount of padding should decay to zero if no frames are being
Noah Richards099323e2015-04-15 16:14:12330 // captured/encoded unless a min-transmit bitrate is used.
stefan@webrtc.org792f1a12015-03-04 12:24:26331 int64_t now_ms = TickTime::MillisecondTimestamp();
Noah Richards099323e2015-04-15 16:14:12332 if (now_ms - time_of_last_frame_activity_ms > kStopPaddingThresholdMs)
stefan@webrtc.org792f1a12015-03-04 12:24:26333 pad_up_to_bitrate_bps = 0;
334
335 // Pad up to min bitrate.
336 if (pad_up_to_bitrate_bps < min_transmit_bitrate_bps)
337 pad_up_to_bitrate_bps = min_transmit_bitrate_bps;
338
339 // Padding may never exceed bitrate estimate.
340 if (pad_up_to_bitrate_bps > bitrate_bps)
341 pad_up_to_bitrate_bps = bitrate_bps;
342
343 return pad_up_to_bitrate_bps;
stefan@webrtc.org508a84b2013-06-17 12:53:37344}
345
stefan@webrtc.orgbfacda62013-03-27 16:36:01346bool ViEEncoder::EncoderPaused() const {
pwestin@webrtc.org91563e42013-04-25 22:20:08347 // Pause video if paused by caller or as long as the network is down or the
348 // pacer queue has grown too large in buffered mode.
349 if (encoder_paused_) {
350 return true;
351 }
352 if (target_delay_ms_ > 0) {
353 // Buffered mode.
354 // TODO(pwestin): Workaround until nack is configured as a time and not
355 // number of packets.
Stefan Holmere5904162015-03-26 10:11:06356 return pacer_->QueueInMs() >=
357 std::max(
358 static_cast<int>(target_delay_ms_ * kEncoderPausePacerMargin),
359 kMinPacingDelayMs);
pwestin@webrtc.org91563e42013-04-25 22:20:08360 }
Stefan Holmere5904162015-03-26 10:11:06361 if (pacer_->ExpectedQueueTimeMs() > PacedSender::kDefaultMaxQueueLengthMs) {
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16362 // Too much data in pacer queue, drop frame.
363 return true;
364 }
pwestin@webrtc.org91563e42013-04-25 22:20:08365 return !network_is_transmitting_;
stefan@webrtc.orgbfacda62013-03-27 16:36:01366}
367
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16368void ViEEncoder::TraceFrameDropStart() {
369 // Start trace event only on the first frame after encoder is paused.
370 if (!encoder_paused_and_dropped_frame_) {
371 TRACE_EVENT_ASYNC_BEGIN0("webrtc", "EncoderPaused", this);
372 }
373 encoder_paused_and_dropped_frame_ = true;
374 return;
375}
376
377void ViEEncoder::TraceFrameDropEnd() {
378 // End trace event on first frame after encoder resumes, if frame was dropped.
379 if (encoder_paused_and_dropped_frame_) {
380 TRACE_EVENT_ASYNC_END0("webrtc", "EncoderPaused", this);
381 }
382 encoder_paused_and_dropped_frame_ = false;
383}
384
Miguel Casas-Sanchez47650702015-05-30 00:21:40385void ViEEncoder::DeliverFrame(VideoFrame video_frame) {
henrikg91d6ede2015-09-17 07:24:34386 RTC_DCHECK(send_payload_router_ != NULL);
mflodman@webrtc.org47d657b2015-02-19 10:29:32387 if (!send_payload_router_->active()) {
mflodman@webrtc.org02270cd2015-02-06 13:10:19388 // We've paused or we have no channels attached, don't waste resources on
389 // encoding.
wuchengli@chromium.orgac4b87c2014-03-19 03:44:20390 return;
391 }
mflodman@webrtc.org84d17832011-12-01 17:02:23392 {
mflodman@webrtc.orgd32c4472011-12-22 14:17:53393 CriticalSectionScoped cs(data_cs_.get());
Noah Richards099323e2015-04-15 16:14:12394 time_of_last_frame_activity_ms_ = TickTime::MillisecondTimestamp();
pwestin@webrtc.org52b4e882013-05-02 19:02:17395 if (EncoderPaused()) {
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16396 TraceFrameDropStart();
pwestin@webrtc.org52b4e882013-05-02 19:02:17397 return;
398 }
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16399 TraceFrameDropEnd();
mflodman@webrtc.org84d17832011-12-01 17:02:23400 }
niklase@google.com470e71d2011-07-07 08:21:25401
Magnus Jedvert26679d62015-04-07 12:07:41402 TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", video_frame.render_time_ms(),
hclam@chromium.org1a7b9b92013-07-08 21:31:18403 "Encode");
Miguel Casas-Sanchez47650702015-05-30 00:21:40404 VideoFrame* decimated_frame = NULL;
wuchengli@chromium.orgf425b552014-06-20 12:04:05405 // TODO(wuchengli): support texture frames.
Magnus Jedvert26679d62015-04-07 12:07:41406 if (video_frame.native_handle() == NULL) {
wuchengli@chromium.orgf425b552014-06-20 12:04:05407 // Pass frame via preprocessor.
mflodmanfcf54bd2015-04-14 19:28:08408 const int ret = vpm_->PreprocessFrame(video_frame, &decimated_frame);
wuchengli@chromium.orgf425b552014-06-20 12:04:05409 if (ret == 1) {
410 // Drop this frame.
411 return;
412 }
413 if (ret != VPM_OK) {
414 return;
415 }
pwestin@webrtc.org2f476ed2012-10-30 16:21:52416 }
pbos@webrtc.orgfe1ef932013-10-21 10:34:43417
Magnus Jedvert26679d62015-04-07 12:07:41418 // If we haven't resampled the frame and we have a FrameCallback, we need to
419 // make a deep copy of |video_frame|.
Miguel Casas-Sanchez47650702015-05-30 00:21:40420 VideoFrame copied_frame;
Peter Boström7083e112015-09-22 14:28:51421 if (pre_encode_callback_) {
422 // If the frame was not resampled or scaled => use copy of original.
423 if (decimated_frame == NULL) {
424 copied_frame.CopyFrame(video_frame);
425 decimated_frame = &copied_frame;
Magnus Jedvert26679d62015-04-07 12:07:41426 }
Peter Boström7083e112015-09-22 14:28:51427 pre_encode_callback_->FrameCallback(decimated_frame);
pbos@webrtc.orgfe1ef932013-10-21 10:34:43428 }
429
Magnus Jedvert26679d62015-04-07 12:07:41430 // If the frame was not resampled, scaled, or touched by FrameCallback => use
431 // original. The frame is const from here.
Miguel Casas-Sanchez47650702015-05-30 00:21:40432 const VideoFrame* output_frame =
Magnus Jedvert26679d62015-04-07 12:07:41433 (decimated_frame != NULL) ? decimated_frame : &video_frame;
434
niklase@google.com470e71d2011-07-07 08:21:25435#ifdef VIDEOCODEC_VP8
mflodmanfcf54bd2015-04-14 19:28:08436 if (vcm_->SendCodec() == webrtc::kVideoCodecVP8) {
mflodman@webrtc.org84d17832011-12-01 17:02:23437 webrtc::CodecSpecificInfo codec_specific_info;
438 codec_specific_info.codecType = webrtc::kVideoCodecVP8;
stefan@webrtc.org7af12be2014-07-09 14:46:31439 {
440 CriticalSectionScoped cs(data_cs_.get());
441 codec_specific_info.codecSpecific.VP8.hasReceivedRPSI =
442 has_received_rpsi_;
443 codec_specific_info.codecSpecific.VP8.hasReceivedSLI =
444 has_received_sli_;
445 codec_specific_info.codecSpecific.VP8.pictureIdRPSI =
446 picture_id_rpsi_;
447 codec_specific_info.codecSpecific.VP8.pictureIdSLI =
448 picture_id_sli_;
449 has_received_sli_ = false;
450 has_received_rpsi_ = false;
451 }
mflodman@webrtc.org84d17832011-12-01 17:02:23452
mflodmanfcf54bd2015-04-14 19:28:08453 vcm_->AddVideoFrame(*output_frame, vpm_->ContentMetrics(),
454 &codec_specific_info);
mflodman@webrtc.org84d17832011-12-01 17:02:23455 return;
456 }
niklase@google.com470e71d2011-07-07 08:21:25457#endif
mflodmanfcf54bd2015-04-14 19:28:08458 vcm_->AddVideoFrame(*output_frame);
niklase@google.com470e71d2011-07-07 08:21:25459}
niklase@google.com470e71d2011-07-07 08:21:25460
pwestin@webrtc.orgce330352012-04-12 06:59:14461int ViEEncoder::SendKeyFrame() {
mflodmanfcf54bd2015-04-14 19:28:08462 return vcm_->IntraFrameRequest(0);
mflodman@webrtc.org84d17832011-12-01 17:02:23463}
464
pbos@webrtc.org143451d2015-03-18 14:40:03465uint32_t ViEEncoder::LastObservedBitrateBps() const {
466 CriticalSectionScoped cs(data_cs_.get());
467 return last_observed_bitrate_bps_;
468}
469
pbos@webrtc.orgb238d122013-04-09 13:41:51470int ViEEncoder::CodecTargetBitrate(uint32_t* bitrate) const {
mflodmanfcf54bd2015-04-14 19:28:08471 if (vcm_->Bitrate(bitrate) != 0)
stefan@webrtc.org439be292012-02-16 14:45:37472 return -1;
473 return 0;
stefan@webrtc.org07b45a52012-02-02 08:37:48474}
475
mflodman@webrtc.org96abda02015-02-25 13:50:10476int32_t ViEEncoder::UpdateProtectionMethod(bool nack, bool fec) {
henrikg91d6ede2015-09-17 07:24:34477 RTC_DCHECK(send_payload_router_ != NULL);
mflodman@webrtc.org84d17832011-12-01 17:02:23478
mflodman@webrtc.org96abda02015-02-25 13:50:10479 if (fec_enabled_ == fec && nack_enabled_ == nack) {
mflodman@webrtc.org84d17832011-12-01 17:02:23480 // No change needed, we're already in correct state.
481 return 0;
482 }
mflodman@webrtc.org96abda02015-02-25 13:50:10483 fec_enabled_ = fec;
484 nack_enabled_ = nack;
mflodman@webrtc.org84d17832011-12-01 17:02:23485
486 // Set Video Protection for VCM.
pbosba8c15b2015-07-14 16:36:34487 VCMVideoProtection protection_mode;
488 if (fec_enabled_) {
489 protection_mode =
490 nack_enabled_ ? webrtc::kProtectionNackFEC : kProtectionFEC;
mflodman@webrtc.org84d17832011-12-01 17:02:23491 } else {
pbosba8c15b2015-07-14 16:36:34492 protection_mode = nack_enabled_ ? kProtectionNack : kProtectionNone;
mflodman@webrtc.org84d17832011-12-01 17:02:23493 }
pbosba8c15b2015-07-14 16:36:34494 vcm_->SetVideoProtection(protection_mode, true);
mflodman@webrtc.org84d17832011-12-01 17:02:23495
wu@webrtc.org822fbd82013-08-15 23:38:54496 if (fec_enabled_ || nack_enabled_) {
mflodman@webrtc.org84d17832011-12-01 17:02:23497 // The send codec must be registered to set correct MTU.
498 webrtc::VideoCodec codec;
mflodmanfcf54bd2015-04-14 19:28:08499 if (vcm_->SendCodec(&codec) == 0) {
stefan@webrtc.org3d0b0d62013-03-19 10:04:57500 uint32_t current_bitrate_bps = 0;
mflodmanfcf54bd2015-04-14 19:28:08501 if (vcm_->Bitrate(&current_bitrate_bps) != 0) {
mflodman@webrtc.org5574dac2014-04-07 10:56:31502 LOG_F(LS_WARNING) <<
503 "Failed to get the current encoder target bitrate.";
stefan@webrtc.org439be292012-02-16 14:45:37504 }
stefan@webrtc.org3d0b0d62013-03-19 10:04:57505 // Convert to start bitrate in kbps.
506 codec.startBitrate = (current_bitrate_bps + 500) / 1000;
mflodman@webrtc.orga4ef2ce2015-02-12 09:54:18507 size_t max_payload_length = send_payload_router_->MaxPayloadLength();
mflodmanfcf54bd2015-04-14 19:28:08508 if (vcm_->RegisterSendCodec(&codec, number_of_cores_,
Peter Boströmae37abb2015-06-18 17:00:34509 static_cast<uint32_t>(max_payload_length)) !=
510 0) {
niklase@google.com470e71d2011-07-07 08:21:25511 return -1;
mflodman@webrtc.org84d17832011-12-01 17:02:23512 }
niklase@google.com470e71d2011-07-07 08:21:25513 }
mflodman@webrtc.org84d17832011-12-01 17:02:23514 }
515 return 0;
niklase@google.com470e71d2011-07-07 08:21:25516}
517
mikhal@webrtc.orgef9f76a2013-02-15 23:22:18518void ViEEncoder::SetSenderBufferingMode(int target_delay_ms) {
stefan@webrtc.orgbfacda62013-03-27 16:36:01519 {
520 CriticalSectionScoped cs(data_cs_.get());
521 target_delay_ms_ = target_delay_ms;
522 }
mikhal@webrtc.org3d305c62013-02-10 18:42:55523 if (target_delay_ms > 0) {
stefan@webrtc.orgbfacda62013-03-27 16:36:01524 // Disable external frame-droppers.
mflodmanfcf54bd2015-04-14 19:28:08525 vcm_->EnableFrameDropper(false);
526 vpm_->EnableTemporalDecimation(false);
mikhal@webrtc.org3d305c62013-02-10 18:42:55527 } else {
mikhal@webrtc.orgef9f76a2013-02-15 23:22:18528 // Real-time mode - enable frame droppers.
mflodmanfcf54bd2015-04-14 19:28:08529 vpm_->EnableTemporalDecimation(true);
530 vcm_->EnableFrameDropper(true);
mikhal@webrtc.org3d305c62013-02-10 18:42:55531 }
532}
533
pbos@webrtc.org891d4832015-02-26 13:15:22534void ViEEncoder::OnSetRates(uint32_t bitrate_bps, int framerate) {
Peter Boström7083e112015-09-22 14:28:51535 if (stats_proxy_)
536 stats_proxy_->OnSetRates(bitrate_bps, framerate);
pbos@webrtc.org891d4832015-02-26 13:15:22537}
538
pbos@webrtc.orgb238d122013-04-09 13:41:51539int32_t ViEEncoder::SendData(
pbos@webrtc.orgb238d122013-04-09 13:41:51540 const uint8_t payload_type,
pbos@webrtc.org273a4142014-12-01 15:23:21541 const EncodedImage& encoded_image,
mflodman@webrtc.org84d17832011-12-01 17:02:23542 const webrtc::RTPFragmentationHeader& fragmentation_header,
543 const RTPVideoHeader* rtp_video_hdr) {
henrikg91d6ede2015-09-17 07:24:34544 RTC_DCHECK(send_payload_router_ != NULL);
mflodman@webrtc.org02270cd2015-02-06 13:10:19545
pbos@webrtc.org891d4832015-02-26 13:15:22546 {
Noah Richards099323e2015-04-15 16:14:12547 CriticalSectionScoped cs(data_cs_.get());
548 time_of_last_frame_activity_ms_ = TickTime::MillisecondTimestamp();
549 }
550
Peter Boström7083e112015-09-22 14:28:51551 if (stats_proxy_ != NULL)
552 stats_proxy_->OnSendEncodedImage(encoded_image, rtp_video_hdr);
mflodman@webrtc.org02270cd2015-02-06 13:10:19553
554 return send_payload_router_->RoutePayload(
pbos22993e12015-10-19 09:39:06555 encoded_image._frameType, payload_type, encoded_image._timeStamp,
556 encoded_image.capture_time_ms_, encoded_image._buffer,
557 encoded_image._length, &fragmentation_header, rtp_video_hdr)
558 ? 0
559 : -1;
niklase@google.com470e71d2011-07-07 08:21:25560}
561
pbos@webrtc.orgb238d122013-04-09 13:41:51562int32_t ViEEncoder::SendStatistics(const uint32_t bit_rate,
563 const uint32_t frame_rate) {
Peter Boström7083e112015-09-22 14:28:51564 if (stats_proxy_)
565 stats_proxy_->OnOutgoingRate(frame_rate, bit_rate);
mflodman@webrtc.org84d17832011-12-01 17:02:23566 return 0;
niklase@google.com470e71d2011-07-07 08:21:25567}
568
andrew@webrtc.org96636862012-09-20 23:33:17569void ViEEncoder::OnReceivedSLI(uint32_t /*ssrc*/,
570 uint8_t picture_id) {
stefan@webrtc.org7af12be2014-07-09 14:46:31571 CriticalSectionScoped cs(data_cs_.get());
mflodman@webrtc.org84d17832011-12-01 17:02:23572 picture_id_sli_ = picture_id;
573 has_received_sli_ = true;
niklase@google.com470e71d2011-07-07 08:21:25574}
575
andrew@webrtc.org96636862012-09-20 23:33:17576void ViEEncoder::OnReceivedRPSI(uint32_t /*ssrc*/,
577 uint64_t picture_id) {
stefan@webrtc.org7af12be2014-07-09 14:46:31578 CriticalSectionScoped cs(data_cs_.get());
mflodman@webrtc.org84d17832011-12-01 17:02:23579 picture_id_rpsi_ = picture_id;
580 has_received_rpsi_ = true;
niklase@google.com470e71d2011-07-07 08:21:25581}
582
mflodman@webrtc.orgd6ec3862012-10-25 11:30:29583void ViEEncoder::OnReceivedIntraFrameRequest(uint32_t ssrc) {
mflodman@webrtc.org84d17832011-12-01 17:02:23584 // Key frame request from remote side, signal to VCM.
justinlin@chromium.org7bfb3a32013-05-13 22:59:00585 TRACE_EVENT0("webrtc", "OnKeyFrameRequest");
pwestin@webrtc.org1da1ce02011-10-13 15:19:55586
mflodman@webrtc.orgd6ec3862012-10-25 11:30:29587 int idx = 0;
588 {
589 CriticalSectionScoped cs(data_cs_.get());
Peter Boström5cb9ce42015-05-05 13:16:30590 auto stream_it = ssrc_streams_.find(ssrc);
mflodman@webrtc.orgd6ec3862012-10-25 11:30:29591 if (stream_it == ssrc_streams_.end()) {
mflodman@webrtc.orgd73527c2012-12-20 09:26:17592 LOG_F(LS_WARNING) << "ssrc not found: " << ssrc << ", map size "
593 << ssrc_streams_.size();
mflodman@webrtc.orgd6ec3862012-10-25 11:30:29594 return;
595 }
pbos@webrtc.orgb238d122013-04-09 13:41:51596 std::map<unsigned int, int64_t>::iterator time_it =
mflodman@webrtc.orgd6ec3862012-10-25 11:30:29597 time_last_intra_request_ms_.find(ssrc);
598 if (time_it == time_last_intra_request_ms_.end()) {
599 time_last_intra_request_ms_[ssrc] = 0;
600 }
601
pbos@webrtc.orgb238d122013-04-09 13:41:51602 int64_t now = TickTime::MillisecondTimestamp();
mflodman@webrtc.orgd6ec3862012-10-25 11:30:29603 if (time_last_intra_request_ms_[ssrc] + kViEMinKeyRequestIntervalMs > now) {
mflodman@webrtc.orgd6ec3862012-10-25 11:30:29604 return;
605 }
606 time_last_intra_request_ms_[ssrc] = now;
607 idx = stream_it->second;
mflodman@webrtc.org84d17832011-12-01 17:02:23608 }
mflodman@webrtc.orgd6ec3862012-10-25 11:30:29609 // Release the critsect before triggering key frame.
mflodmanfcf54bd2015-04-14 19:28:08610 vcm_->IntraFrameRequest(idx);
niklase@google.com470e71d2011-07-07 08:21:25611}
612
mflodman@webrtc.orgaca26292012-10-05 16:17:41613void ViEEncoder::OnLocalSsrcChanged(uint32_t old_ssrc, uint32_t new_ssrc) {
mflodman@webrtc.orgd6ec3862012-10-25 11:30:29614 CriticalSectionScoped cs(data_cs_.get());
615 std::map<unsigned int, int>::iterator it = ssrc_streams_.find(old_ssrc);
616 if (it == ssrc_streams_.end()) {
617 return;
618 }
619
620 ssrc_streams_[new_ssrc] = it->second;
621 ssrc_streams_.erase(it);
622
623 std::map<unsigned int, int64_t>::iterator time_it =
624 time_last_intra_request_ms_.find(old_ssrc);
625 int64_t last_intra_request_ms = 0;
626 if (time_it != time_last_intra_request_ms_.end()) {
627 last_intra_request_ms = time_it->second;
628 time_last_intra_request_ms_.erase(time_it);
629 }
630 time_last_intra_request_ms_[new_ssrc] = last_intra_request_ms;
631}
632
Peter Boström5cb9ce42015-05-05 13:16:30633bool ViEEncoder::SetSsrcs(const std::vector<uint32_t>& ssrcs) {
mflodman@webrtc.orgd6ec3862012-10-25 11:30:29634 VideoCodec codec;
mflodmanfcf54bd2015-04-14 19:28:08635 if (vcm_->SendCodec(&codec) != 0)
mflodman@webrtc.orgd6ec3862012-10-25 11:30:29636 return false;
637
638 if (codec.numberOfSimulcastStreams > 0 &&
639 ssrcs.size() != codec.numberOfSimulcastStreams) {
640 return false;
641 }
642
643 CriticalSectionScoped cs(data_cs_.get());
644 ssrc_streams_.clear();
645 time_last_intra_request_ms_.clear();
646 int idx = 0;
Peter Boström5cb9ce42015-05-05 13:16:30647 for (uint32_t ssrc : ssrcs) {
648 ssrc_streams_[ssrc] = idx++;
mflodman@webrtc.orgd6ec3862012-10-25 11:30:29649 }
650 return true;
mflodman@webrtc.orgaca26292012-10-05 16:17:41651}
652
pbos@webrtc.org3349ae02014-03-13 12:52:27653void ViEEncoder::SetMinTransmitBitrate(int min_transmit_bitrate_kbps) {
654 assert(min_transmit_bitrate_kbps >= 0);
655 CriticalSectionScoped crit(data_cs_.get());
656 min_transmit_bitrate_kbps_ = min_transmit_bitrate_kbps;
657}
658
pwestin@webrtc.org49888ce2012-04-27 05:25:53659// Called from ViEBitrateObserver.
stefan@webrtc.orgedeea912014-12-08 19:46:23660void ViEEncoder::OnNetworkChanged(uint32_t bitrate_bps,
661 uint8_t fraction_lost,
pkasting@chromium.org16825b12015-01-12 21:51:21662 int64_t round_trip_time_ms) {
mflodman@webrtc.org5574dac2014-04-07 10:56:31663 LOG(LS_VERBOSE) << "OnNetworkChanged, bitrate" << bitrate_bps
mflodman8602a3d2015-05-20 22:54:42664 << " packet loss " << static_cast<int>(fraction_lost)
mflodman@webrtc.org5574dac2014-04-07 10:56:31665 << " rtt " << round_trip_time_ms;
henrikg91d6ede2015-09-17 07:24:34666 RTC_DCHECK(send_payload_router_ != NULL);
mflodmanfcf54bd2015-04-14 19:28:08667 vcm_->SetChannelParameters(bitrate_bps, fraction_lost, round_trip_time_ms);
668 bool video_is_suspended = vcm_->VideoSuspended();
stefan@webrtc.org792f1a12015-03-04 12:24:26669
stefan@webrtc.org508a84b2013-06-17 12:53:37670 VideoCodec send_codec;
mflodmanfcf54bd2015-04-14 19:28:08671 if (vcm_->SendCodec(&send_codec) != 0) {
stefan@webrtc.org508a84b2013-06-17 12:53:37672 return;
673 }
stefan@webrtc.orgb2c8a952013-09-06 13:58:01674 SimulcastStream* stream_configs = send_codec.simulcastStream;
675 // Allocate the bandwidth between the streams.
676 std::vector<uint32_t> stream_bitrates = AllocateStreamBitrates(
stefan@webrtc.org792f1a12015-03-04 12:24:26677 bitrate_bps, stream_configs, send_codec.numberOfSimulcastStreams);
678 send_payload_router_->SetTargetSendBitrates(stream_bitrates);
pbos@webrtc.org709e2972014-03-19 10:59:52679
stefan@webrtc.org3e005052013-10-18 15:05:29680 {
stefan@webrtc.org3e005052013-10-18 15:05:29681 CriticalSectionScoped cs(data_cs_.get());
pbos@webrtc.org143451d2015-03-18 14:40:03682 last_observed_bitrate_bps_ = bitrate_bps;
pbos@webrtc.org484ee962013-11-21 18:44:23683 if (video_suspended_ == video_is_suspended)
684 return;
685 video_suspended_ = video_is_suspended;
mflodman0dbf0092015-10-19 15:12:12686
687 LOG(LS_INFO) << "Video suspend state changed " << video_is_suspended
688 << " for ssrc " << ssrc_streams_.begin()->first;
henrik.lundin@webrtc.org7ea4f242013-10-02 13:34:26689 }
Peter Boström7083e112015-09-22 14:28:51690 // Video suspend-state changed, inform codec observer.
691 if (stats_proxy_)
692 stats_proxy_->OnSuspendChange(video_is_suspended);
niklase@google.com470e71d2011-07-07 08:21:25693}
694
henrik.lundin@webrtc.orgce8e0932013-11-18 12:18:43695void ViEEncoder::SuspendBelowMinBitrate() {
mflodmanfcf54bd2015-04-14 19:28:08696 vcm_->SuspendBelowMinBitrate();
stefan@webrtc.org792f1a12015-03-04 12:24:26697 bitrate_allocator_->EnforceMinBitrate(false);
henrik.lundin@webrtc.org7ea4f242013-10-02 13:34:26698}
699
sprang@webrtc.org40709352013-11-26 11:41:59700void ViEEncoder::RegisterPostEncodeImageCallback(
701 EncodedImageCallback* post_encode_callback) {
mflodmanfcf54bd2015-04-14 19:28:08702 vcm_->RegisterPostEncodeImageCallback(post_encode_callback);
sprang@webrtc.org40709352013-11-26 11:41:59703}
704
marpan@webrtc.orgefd01fd2012-04-18 15:56:34705QMVideoSettingsCallback::QMVideoSettingsCallback(VideoProcessingModule* vpm)
706 : vpm_(vpm) {
mflodman@webrtc.org84d17832011-12-01 17:02:23707}
niklase@google.com470e71d2011-07-07 08:21:25708
stefan@webrtc.org439be292012-02-16 14:45:37709QMVideoSettingsCallback::~QMVideoSettingsCallback() {
mflodman@webrtc.org84d17832011-12-01 17:02:23710}
711
pbos@webrtc.orgb238d122013-04-09 13:41:51712int32_t QMVideoSettingsCallback::SetVideoQMSettings(
713 const uint32_t frame_rate,
714 const uint32_t width,
715 const uint32_t height) {
marpan@webrtc.orgcf706c22012-03-27 21:04:13716 return vpm_->SetTargetResolution(width, height, frame_rate);
mflodman@webrtc.org84d17832011-12-01 17:02:23717}
718
jackychen6e2ce6e2015-07-13 23:26:33719void QMVideoSettingsCallback::SetTargetFramerate(int frame_rate) {
720 vpm_->SetTargetFramerate(frame_rate);
721}
722
mflodman@webrtc.org84d17832011-12-01 17:02:23723} // namespace webrtc