andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 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 | |
pbos@webrtc.org | 281cff8 | 2013-05-17 13:44:48 +0000 | [diff] [blame] | 11 | #include "webrtc/video_engine/vie_encoder.h" |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 12 | |
pbos@webrtc.org | 3f45c2e | 2013-08-05 16:22:53 +0000 | [diff] [blame] | 13 | #include <assert.h> |
| 14 | |
stefan@webrtc.org | 695ff2a | 2013-06-04 09:36:56 +0000 | [diff] [blame] | 15 | #include <algorithm> |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 16 | |
sprang@webrtc.org | 2e98d45 | 2013-11-26 11:41:59 +0000 | [diff] [blame] | 17 | #include "webrtc/common_video/interface/video_image.h" |
pbos@webrtc.org | 281cff8 | 2013-05-17 13:44:48 +0000 | [diff] [blame] | 18 | #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h" |
| 19 | #include "webrtc/modules/pacing/include/paced_sender.h" |
| 20 | #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h" |
| 21 | #include "webrtc/modules/utility/interface/process_thread.h" |
| 22 | #include "webrtc/modules/video_coding/codecs/interface/video_codec_interface.h" |
| 23 | #include "webrtc/modules/video_coding/main/interface/video_coding.h" |
| 24 | #include "webrtc/modules/video_coding/main/interface/video_coding_defines.h" |
sprang@webrtc.org | 2e98d45 | 2013-11-26 11:41:59 +0000 | [diff] [blame] | 25 | #include "webrtc/modules/video_coding/main/source/encoded_frame.h" |
stefan@webrtc.org | c9995bc | 2014-07-04 09:20:42 +0000 | [diff] [blame] | 26 | #include "webrtc/system_wrappers/interface/clock.h" |
pbos@webrtc.org | 281cff8 | 2013-05-17 13:44:48 +0000 | [diff] [blame] | 27 | #include "webrtc/system_wrappers/interface/critical_section_wrapper.h" |
| 28 | #include "webrtc/system_wrappers/interface/logging.h" |
| 29 | #include "webrtc/system_wrappers/interface/tick_util.h" |
pbos@webrtc.org | 281cff8 | 2013-05-17 13:44:48 +0000 | [diff] [blame] | 30 | #include "webrtc/system_wrappers/interface/trace_event.h" |
| 31 | #include "webrtc/video_engine/include/vie_codec.h" |
| 32 | #include "webrtc/video_engine/include/vie_image_process.h" |
pbos@webrtc.org | 24e2089 | 2013-10-28 16:32:01 +0000 | [diff] [blame] | 33 | #include "webrtc/frame_callback.h" |
pbos@webrtc.org | 281cff8 | 2013-05-17 13:44:48 +0000 | [diff] [blame] | 34 | #include "webrtc/video_engine/vie_defines.h" |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 35 | |
| 36 | namespace webrtc { |
| 37 | |
pwestin@webrtc.org | 36bdba4 | 2013-05-02 19:02:17 +0000 | [diff] [blame] | 38 | // Margin on when we pause the encoder when the pacing buffer overflows relative |
| 39 | // to the configured buffer delay. |
| 40 | static const float kEncoderPausePacerMargin = 2.0f; |
| 41 | |
pwestin@webrtc.org | 3816c52 | 2013-04-25 22:20:08 +0000 | [diff] [blame] | 42 | // Don't stop the encoder unless the delay is above this configured value. |
| 43 | static const int kMinPacingDelayMs = 200; |
| 44 | |
stefan@webrtc.org | dca71b2 | 2013-03-27 16:36:01 +0000 | [diff] [blame] | 45 | // Allow packets to be transmitted in up to 2 times max video bitrate if the |
| 46 | // bandwidth estimate allows it. |
| 47 | // TODO(holmer): Expose transmission start, min and max bitrates in the |
| 48 | // VideoEngine API and remove the kTransmissionMaxBitrateMultiplier. |
| 49 | static const int kTransmissionMaxBitrateMultiplier = 2; |
pwestin@webrtc.org | 5e87b5f | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 50 | |
stefan@webrtc.org | 5e74d96 | 2013-10-18 15:05:29 +0000 | [diff] [blame] | 51 | static const float kStopPaddingThresholdMs = 2000; |
| 52 | |
stefan@webrtc.org | 7dc1790 | 2013-09-06 13:58:01 +0000 | [diff] [blame] | 53 | std::vector<uint32_t> AllocateStreamBitrates( |
| 54 | uint32_t total_bitrate, |
| 55 | const SimulcastStream* stream_configs, |
| 56 | size_t number_of_streams) { |
| 57 | if (number_of_streams == 0) { |
| 58 | std::vector<uint32_t> stream_bitrates(1, 0); |
| 59 | stream_bitrates[0] = total_bitrate; |
| 60 | return stream_bitrates; |
| 61 | } |
| 62 | std::vector<uint32_t> stream_bitrates(number_of_streams, 0); |
| 63 | uint32_t bitrate_remainder = total_bitrate; |
| 64 | for (size_t i = 0; i < stream_bitrates.size() && bitrate_remainder > 0; ++i) { |
| 65 | if (stream_configs[i].maxBitrate * 1000 > bitrate_remainder) { |
| 66 | stream_bitrates[i] = bitrate_remainder; |
| 67 | } else { |
| 68 | stream_bitrates[i] = stream_configs[i].maxBitrate * 1000; |
| 69 | } |
| 70 | bitrate_remainder -= stream_bitrates[i]; |
| 71 | } |
| 72 | return stream_bitrates; |
| 73 | } |
| 74 | |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 75 | class QMVideoSettingsCallback : public VCMQMSettingsCallback { |
| 76 | public: |
| 77 | explicit QMVideoSettingsCallback(VideoProcessingModule* vpm); |
mflodman@webrtc.org | bf76ae2 | 2013-07-23 11:35:00 +0000 | [diff] [blame] | 78 | |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 79 | ~QMVideoSettingsCallback(); |
| 80 | |
| 81 | // Update VPM with QM (quality modes: frame size & frame rate) settings. |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 82 | int32_t SetVideoQMSettings(const uint32_t frame_rate, |
| 83 | const uint32_t width, |
| 84 | const uint32_t height); |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 85 | |
| 86 | private: |
| 87 | VideoProcessingModule* vpm_; |
| 88 | }; |
| 89 | |
| 90 | class ViEBitrateObserver : public BitrateObserver { |
| 91 | public: |
| 92 | explicit ViEBitrateObserver(ViEEncoder* owner) |
| 93 | : owner_(owner) { |
| 94 | } |
mflodman@webrtc.org | bf76ae2 | 2013-07-23 11:35:00 +0000 | [diff] [blame] | 95 | virtual ~ViEBitrateObserver() {} |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 96 | // Implements BitrateObserver. |
| 97 | virtual void OnNetworkChanged(const uint32_t bitrate_bps, |
| 98 | const uint8_t fraction_lost, |
| 99 | const uint32_t rtt) { |
| 100 | owner_->OnNetworkChanged(bitrate_bps, fraction_lost, rtt); |
| 101 | } |
| 102 | private: |
| 103 | ViEEncoder* owner_; |
| 104 | }; |
| 105 | |
pwestin@webrtc.org | 5e87b5f | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 106 | class ViEPacedSenderCallback : public PacedSender::Callback { |
| 107 | public: |
| 108 | explicit ViEPacedSenderCallback(ViEEncoder* owner) |
| 109 | : owner_(owner) { |
| 110 | } |
mflodman@webrtc.org | bf76ae2 | 2013-07-23 11:35:00 +0000 | [diff] [blame] | 111 | virtual ~ViEPacedSenderCallback() {} |
hclam@chromium.org | 0f6f7cb | 2013-06-20 20:18:31 +0000 | [diff] [blame] | 112 | virtual bool TimeToSendPacket(uint32_t ssrc, uint16_t sequence_number, |
stefan@webrtc.org | b748c9d | 2013-11-13 15:29:21 +0000 | [diff] [blame] | 113 | int64_t capture_time_ms, bool retransmission) { |
| 114 | return owner_->TimeToSendPacket(ssrc, sequence_number, capture_time_ms, |
| 115 | retransmission); |
pwestin@webrtc.org | 5e87b5f | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 116 | } |
stefan@webrtc.org | 695ff2a | 2013-06-04 09:36:56 +0000 | [diff] [blame] | 117 | virtual int TimeToSendPadding(int bytes) { |
stefan@webrtc.org | 69f7605 | 2013-06-17 12:53:37 +0000 | [diff] [blame] | 118 | return owner_->TimeToSendPadding(bytes); |
pwestin@webrtc.org | 5e87b5f | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 119 | } |
| 120 | private: |
| 121 | ViEEncoder* owner_; |
| 122 | }; |
| 123 | |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 124 | ViEEncoder::ViEEncoder(int32_t engine_id, |
| 125 | int32_t channel_id, |
| 126 | uint32_t number_of_cores, |
andresp@webrtc.org | ac6d919 | 2013-05-13 10:50:50 +0000 | [diff] [blame] | 127 | const Config& config, |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 128 | ProcessThread& module_process_thread, |
| 129 | BitrateController* bitrate_controller) |
| 130 | : engine_id_(engine_id), |
| 131 | channel_id_(channel_id), |
| 132 | number_of_cores_(number_of_cores), |
stefan@webrtc.org | 8edccce | 2014-04-11 14:08:35 +0000 | [diff] [blame] | 133 | vcm_(*webrtc::VideoCodingModule::Create()), |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 134 | vpm_(*webrtc::VideoProcessingModule::Create(ViEModuleId(engine_id, |
| 135 | channel_id))), |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 136 | callback_cs_(CriticalSectionWrapper::CreateCriticalSection()), |
| 137 | data_cs_(CriticalSectionWrapper::CreateCriticalSection()), |
| 138 | bitrate_controller_(bitrate_controller), |
stefan@webrtc.org | 5e74d96 | 2013-10-18 15:05:29 +0000 | [diff] [blame] | 139 | time_of_last_incoming_frame_ms_(0), |
stefan@webrtc.org | 69f7605 | 2013-06-17 12:53:37 +0000 | [diff] [blame] | 140 | send_padding_(false), |
pbos@webrtc.org | 3f83f9c | 2014-03-13 12:52:27 +0000 | [diff] [blame] | 141 | min_transmit_bitrate_kbps_(0), |
stefan@webrtc.org | dca71b2 | 2013-03-27 16:36:01 +0000 | [diff] [blame] | 142 | target_delay_ms_(0), |
| 143 | network_is_transmitting_(true), |
| 144 | encoder_paused_(false), |
pwestin@webrtc.org | 36bdba4 | 2013-05-02 19:02:17 +0000 | [diff] [blame] | 145 | encoder_paused_and_dropped_frame_(false), |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 146 | fec_enabled_(false), |
| 147 | nack_enabled_(false), |
| 148 | codec_observer_(NULL), |
| 149 | effect_filter_(NULL), |
| 150 | module_process_thread_(module_process_thread), |
| 151 | has_received_sli_(false), |
| 152 | picture_id_sli_(0), |
| 153 | has_received_rpsi_(false), |
| 154 | picture_id_rpsi_(0), |
henrik.lundin@webrtc.org | 39079d1 | 2013-10-02 13:34:26 +0000 | [diff] [blame] | 155 | qm_callback_(NULL), |
henrik.lundin@webrtc.org | 4590177 | 2013-11-18 12:18:43 +0000 | [diff] [blame] | 156 | video_suspended_(false), |
pbos@webrtc.org | 63301bd | 2013-10-21 10:34:43 +0000 | [diff] [blame] | 157 | pre_encode_callback_(NULL) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 158 | RtpRtcp::Configuration configuration; |
| 159 | configuration.id = ViEModuleId(engine_id_, channel_id_); |
| 160 | configuration.audio = false; // Video. |
| 161 | |
| 162 | default_rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(configuration)); |
| 163 | bitrate_observer_.reset(new ViEBitrateObserver(this)); |
pwestin@webrtc.org | 5e87b5f | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 164 | pacing_callback_.reset(new ViEPacedSenderCallback(this)); |
pwestin@webrtc.org | 36bdba4 | 2013-05-02 19:02:17 +0000 | [diff] [blame] | 165 | paced_sender_.reset( |
stefan@webrtc.org | c9995bc | 2014-07-04 09:20:42 +0000 | [diff] [blame] | 166 | new PacedSender(Clock::GetRealTimeClock(), pacing_callback_.get(), |
| 167 | PacedSender::kDefaultInitialPaceKbps, 0)); |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 168 | } |
| 169 | |
| 170 | bool ViEEncoder::Init() { |
| 171 | if (vcm_.InitializeSender() != 0) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 172 | return false; |
| 173 | } |
| 174 | vpm_.EnableTemporalDecimation(true); |
| 175 | |
| 176 | // Enable/disable content analysis: off by default for now. |
| 177 | vpm_.EnableContentAnalysis(false); |
| 178 | |
pwestin@webrtc.org | 5e87b5f | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 179 | if (module_process_thread_.RegisterModule(&vcm_) != 0 || |
| 180 | module_process_thread_.RegisterModule(default_rtp_rtcp_.get()) != 0 || |
| 181 | module_process_thread_.RegisterModule(paced_sender_.get()) != 0) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 182 | return false; |
| 183 | } |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 184 | if (qm_callback_) { |
| 185 | delete qm_callback_; |
| 186 | } |
| 187 | qm_callback_ = new QMVideoSettingsCallback(&vpm_); |
| 188 | |
| 189 | #ifdef VIDEOCODEC_VP8 |
andresp@webrtc.org | c1696da | 2014-08-14 16:46:46 +0000 | [diff] [blame] | 190 | VideoCodecType codec_type = webrtc::kVideoCodecVP8; |
| 191 | #else |
| 192 | VideoCodecType codec_type = webrtc::kVideoCodecI420; |
| 193 | #endif |
| 194 | |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 195 | VideoCodec video_codec; |
andresp@webrtc.org | c1696da | 2014-08-14 16:46:46 +0000 | [diff] [blame] | 196 | if (vcm_.Codec(codec_type, &video_codec) != VCM_OK) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 197 | return false; |
| 198 | } |
stefan@webrtc.org | 5fcd7df | 2014-02-13 13:48:38 +0000 | [diff] [blame] | 199 | { |
| 200 | CriticalSectionScoped cs(data_cs_.get()); |
| 201 | send_padding_ = video_codec.numberOfSimulcastStreams > 1; |
| 202 | } |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 203 | if (vcm_.RegisterSendCodec(&video_codec, number_of_cores_, |
| 204 | default_rtp_rtcp_->MaxDataPayloadLength()) != 0) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 205 | return false; |
| 206 | } |
| 207 | if (default_rtp_rtcp_->RegisterSendPayload(video_codec) != 0) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 208 | return false; |
| 209 | } |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 210 | if (vcm_.RegisterTransportCallback(this) != 0) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 211 | return false; |
| 212 | } |
| 213 | if (vcm_.RegisterSendStatisticsCallback(this) != 0) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 214 | return false; |
| 215 | } |
| 216 | if (vcm_.RegisterVideoQMCallback(qm_callback_) != 0) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 217 | return false; |
| 218 | } |
| 219 | return true; |
| 220 | } |
| 221 | |
| 222 | ViEEncoder::~ViEEncoder() { |
stefan@webrtc.org | c0539d9 | 2012-11-29 09:18:53 +0000 | [diff] [blame] | 223 | if (bitrate_controller_) { |
| 224 | bitrate_controller_->RemoveBitrateObserver(bitrate_observer_.get()); |
| 225 | } |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 226 | module_process_thread_.DeRegisterModule(&vcm_); |
| 227 | module_process_thread_.DeRegisterModule(&vpm_); |
| 228 | module_process_thread_.DeRegisterModule(default_rtp_rtcp_.get()); |
pwestin@webrtc.org | 5e87b5f | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 229 | module_process_thread_.DeRegisterModule(paced_sender_.get()); |
mflodman@webrtc.org | c6242c9 | 2013-03-01 14:51:23 +0000 | [diff] [blame] | 230 | VideoCodingModule::Destroy(&vcm_); |
| 231 | VideoProcessingModule::Destroy(&vpm_); |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 232 | delete qm_callback_; |
| 233 | } |
| 234 | |
| 235 | int ViEEncoder::Owner() const { |
| 236 | return channel_id_; |
| 237 | } |
| 238 | |
stefan@webrtc.org | dca71b2 | 2013-03-27 16:36:01 +0000 | [diff] [blame] | 239 | void ViEEncoder::SetNetworkTransmissionState(bool is_transmitting) { |
stefan@webrtc.org | dca71b2 | 2013-03-27 16:36:01 +0000 | [diff] [blame] | 240 | { |
| 241 | CriticalSectionScoped cs(data_cs_.get()); |
| 242 | network_is_transmitting_ = is_transmitting; |
| 243 | } |
| 244 | if (is_transmitting) { |
| 245 | paced_sender_->Resume(); |
| 246 | } else { |
| 247 | paced_sender_->Pause(); |
| 248 | } |
| 249 | } |
| 250 | |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 251 | void ViEEncoder::Pause() { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 252 | CriticalSectionScoped cs(data_cs_.get()); |
stefan@webrtc.org | dca71b2 | 2013-03-27 16:36:01 +0000 | [diff] [blame] | 253 | encoder_paused_ = true; |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 254 | } |
| 255 | |
| 256 | void ViEEncoder::Restart() { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 257 | CriticalSectionScoped cs(data_cs_.get()); |
stefan@webrtc.org | dca71b2 | 2013-03-27 16:36:01 +0000 | [diff] [blame] | 258 | encoder_paused_ = false; |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 259 | } |
| 260 | |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 261 | uint8_t ViEEncoder::NumberOfCodecs() { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 262 | return vcm_.NumberOfCodecs(); |
| 263 | } |
| 264 | |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 265 | int32_t ViEEncoder::GetCodec(uint8_t list_index, VideoCodec* video_codec) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 266 | if (vcm_.Codec(list_index, video_codec) != 0) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 267 | return -1; |
| 268 | } |
| 269 | return 0; |
| 270 | } |
| 271 | |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 272 | int32_t ViEEncoder::RegisterExternalEncoder(webrtc::VideoEncoder* encoder, |
| 273 | uint8_t pl_type, |
| 274 | bool internal_source) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 275 | if (encoder == NULL) |
| 276 | return -1; |
| 277 | |
stefan@webrtc.org | 71f3f68 | 2013-01-09 08:35:40 +0000 | [diff] [blame] | 278 | if (vcm_.RegisterExternalEncoder(encoder, pl_type, internal_source) != |
mflodman@webrtc.org | 022615b | 2014-04-07 10:56:31 +0000 | [diff] [blame] | 279 | VCM_OK) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 280 | return -1; |
| 281 | } |
| 282 | return 0; |
| 283 | } |
| 284 | |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 285 | int32_t ViEEncoder::DeRegisterExternalEncoder(uint8_t pl_type) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 286 | webrtc::VideoCodec current_send_codec; |
| 287 | if (vcm_.SendCodec(¤t_send_codec) == VCM_OK) { |
stefan@webrtc.org | 6313692 | 2013-03-19 10:04:57 +0000 | [diff] [blame] | 288 | uint32_t current_bitrate_bps = 0; |
| 289 | if (vcm_.Bitrate(¤t_bitrate_bps) != 0) { |
mflodman@webrtc.org | 022615b | 2014-04-07 10:56:31 +0000 | [diff] [blame] | 290 | LOG(LS_WARNING) << "Failed to get the current encoder target bitrate."; |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 291 | } |
stefan@webrtc.org | 6313692 | 2013-03-19 10:04:57 +0000 | [diff] [blame] | 292 | current_send_codec.startBitrate = (current_bitrate_bps + 500) / 1000; |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 293 | } |
| 294 | |
| 295 | if (vcm_.RegisterExternalEncoder(NULL, pl_type) != VCM_OK) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 296 | return -1; |
| 297 | } |
| 298 | |
stefan@webrtc.org | 69f7605 | 2013-06-17 12:53:37 +0000 | [diff] [blame] | 299 | // If the external encoder is the current send codec, use vcm internal |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 300 | // encoder. |
| 301 | if (current_send_codec.plType == pl_type) { |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 302 | uint16_t max_data_payload_length = |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 303 | default_rtp_rtcp_->MaxDataPayloadLength(); |
stefan@webrtc.org | 5fcd7df | 2014-02-13 13:48:38 +0000 | [diff] [blame] | 304 | { |
| 305 | CriticalSectionScoped cs(data_cs_.get()); |
| 306 | send_padding_ = current_send_codec.numberOfSimulcastStreams > 1; |
| 307 | } |
fischman@webrtc.org | bbbe9b8 | 2014-03-07 18:00:05 +0000 | [diff] [blame] | 308 | // TODO(mflodman): Unfortunately the VideoCodec that VCM has cached a |
| 309 | // raw pointer to an |extra_options| that's long gone. Clearing it here is |
| 310 | // a hack to prevent the following code from crashing. This should be fixed |
| 311 | // for realz. https://code.google.com/p/chromium/issues/detail?id=348222 |
| 312 | current_send_codec.extra_options = NULL; |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 313 | if (vcm_.RegisterSendCodec(¤t_send_codec, number_of_cores_, |
| 314 | max_data_payload_length) != VCM_OK) { |
stefan@webrtc.org | 6111d79 | 2014-07-16 11:20:40 +0000 | [diff] [blame] | 315 | LOG(LS_INFO) << "De-registered the currently used external encoder (" |
| 316 | << static_cast<int>(pl_type) << ") and therefore tried to " |
| 317 | << "register the corresponding internal encoder, but none " |
| 318 | << "was supported."; |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 319 | } |
| 320 | } |
| 321 | return 0; |
| 322 | } |
| 323 | |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 324 | int32_t ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 325 | // Setting target width and height for VPM. |
| 326 | if (vpm_.SetTargetResolution(video_codec.width, video_codec.height, |
| 327 | video_codec.maxFramerate) != VPM_OK) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 328 | return -1; |
| 329 | } |
| 330 | |
| 331 | if (default_rtp_rtcp_->RegisterSendPayload(video_codec) != 0) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 332 | return -1; |
| 333 | } |
| 334 | // Convert from kbps to bps. |
stefan@webrtc.org | 7dc1790 | 2013-09-06 13:58:01 +0000 | [diff] [blame] | 335 | std::vector<uint32_t> stream_bitrates = AllocateStreamBitrates( |
| 336 | video_codec.startBitrate * 1000, |
| 337 | video_codec.simulcastStream, |
| 338 | video_codec.numberOfSimulcastStreams); |
| 339 | default_rtp_rtcp_->SetTargetSendBitrate(stream_bitrates); |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 340 | |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 341 | uint16_t max_data_payload_length = |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 342 | default_rtp_rtcp_->MaxDataPayloadLength(); |
| 343 | |
stefan@webrtc.org | 5a6e691 | 2014-02-14 09:45:58 +0000 | [diff] [blame] | 344 | { |
| 345 | CriticalSectionScoped cs(data_cs_.get()); |
| 346 | send_padding_ = video_codec.numberOfSimulcastStreams > 1; |
| 347 | } |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 348 | if (vcm_.RegisterSendCodec(&video_codec, number_of_cores_, |
| 349 | max_data_payload_length) != VCM_OK) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 350 | return -1; |
| 351 | } |
| 352 | |
| 353 | // Set this module as sending right away, let the slave module in the channel |
| 354 | // start and stop sending. |
andresp@webrtc.org | c1696da | 2014-08-14 16:46:46 +0000 | [diff] [blame] | 355 | if (default_rtp_rtcp_->SetSendingStatus(true) != 0) { |
| 356 | return -1; |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 357 | } |
andresp@webrtc.org | c1696da | 2014-08-14 16:46:46 +0000 | [diff] [blame] | 358 | |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 359 | bitrate_controller_->SetBitrateObserver(bitrate_observer_.get(), |
| 360 | video_codec.startBitrate * 1000, |
| 361 | video_codec.minBitrate * 1000, |
stefan@webrtc.org | dca71b2 | 2013-03-27 16:36:01 +0000 | [diff] [blame] | 362 | kTransmissionMaxBitrateMultiplier * |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 363 | video_codec.maxBitrate * 1000); |
| 364 | |
pbos@webrtc.org | 3f83f9c | 2014-03-13 12:52:27 +0000 | [diff] [blame] | 365 | CriticalSectionScoped crit(data_cs_.get()); |
| 366 | int pad_up_to_bitrate_kbps = video_codec.startBitrate; |
| 367 | if (pad_up_to_bitrate_kbps < min_transmit_bitrate_kbps_) |
| 368 | pad_up_to_bitrate_kbps = min_transmit_bitrate_kbps_; |
| 369 | |
stefan@webrtc.org | c9995bc | 2014-07-04 09:20:42 +0000 | [diff] [blame] | 370 | paced_sender_->UpdateBitrate( |
| 371 | PacedSender::kDefaultPaceMultiplier * video_codec.startBitrate, |
| 372 | pad_up_to_bitrate_kbps); |
pbos@webrtc.org | 3f83f9c | 2014-03-13 12:52:27 +0000 | [diff] [blame] | 373 | |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 374 | return 0; |
| 375 | } |
| 376 | |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 377 | int32_t ViEEncoder::GetEncoder(VideoCodec* video_codec) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 378 | if (vcm_.SendCodec(video_codec) != 0) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 379 | return -1; |
| 380 | } |
| 381 | return 0; |
| 382 | } |
| 383 | |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 384 | int32_t ViEEncoder::GetCodecConfigParameters( |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 385 | unsigned char config_parameters[kConfigParameterSize], |
| 386 | unsigned char& config_parameters_size) { |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 387 | int32_t num_parameters = |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 388 | vcm_.CodecConfigParameters(config_parameters, kConfigParameterSize); |
| 389 | if (num_parameters <= 0) { |
| 390 | config_parameters_size = 0; |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 391 | return -1; |
| 392 | } |
| 393 | config_parameters_size = static_cast<unsigned char>(num_parameters); |
| 394 | return 0; |
| 395 | } |
| 396 | |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 397 | int32_t ViEEncoder::ScaleInputImage(bool enable) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 398 | VideoFrameResampling resampling_mode = kFastRescaling; |
mflodman@webrtc.org | 022615b | 2014-04-07 10:56:31 +0000 | [diff] [blame] | 399 | // TODO(mflodman) What? |
| 400 | if (enable) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 401 | // kInterpolation is currently not supported. |
mflodman@webrtc.org | 022615b | 2014-04-07 10:56:31 +0000 | [diff] [blame] | 402 | LOG_F(LS_ERROR) << "Not supported."; |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 403 | return -1; |
| 404 | } |
| 405 | vpm_.SetInputFrameResampleMode(resampling_mode); |
| 406 | |
| 407 | return 0; |
| 408 | } |
| 409 | |
stefan@webrtc.org | b748c9d | 2013-11-13 15:29:21 +0000 | [diff] [blame] | 410 | bool ViEEncoder::TimeToSendPacket(uint32_t ssrc, |
| 411 | uint16_t sequence_number, |
| 412 | int64_t capture_time_ms, |
| 413 | bool retransmission) { |
hclam@chromium.org | 0f6f7cb | 2013-06-20 20:18:31 +0000 | [diff] [blame] | 414 | return default_rtp_rtcp_->TimeToSendPacket(ssrc, sequence_number, |
stefan@webrtc.org | b748c9d | 2013-11-13 15:29:21 +0000 | [diff] [blame] | 415 | capture_time_ms, retransmission); |
pwestin@webrtc.org | 5e87b5f | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 416 | } |
| 417 | |
stefan@webrtc.org | 69f7605 | 2013-06-17 12:53:37 +0000 | [diff] [blame] | 418 | int ViEEncoder::TimeToSendPadding(int bytes) { |
henrik.lundin@webrtc.org | b9f1eb8 | 2013-11-21 14:05:40 +0000 | [diff] [blame] | 419 | bool send_padding; |
| 420 | { |
| 421 | CriticalSectionScoped cs(data_cs_.get()); |
pbos@webrtc.org | 3f83f9c | 2014-03-13 12:52:27 +0000 | [diff] [blame] | 422 | send_padding = |
| 423 | send_padding_ || video_suspended_ || min_transmit_bitrate_kbps_ > 0; |
henrik.lundin@webrtc.org | b9f1eb8 | 2013-11-21 14:05:40 +0000 | [diff] [blame] | 424 | } |
| 425 | if (send_padding) { |
stefan@webrtc.org | 69f7605 | 2013-06-17 12:53:37 +0000 | [diff] [blame] | 426 | return default_rtp_rtcp_->TimeToSendPadding(bytes); |
| 427 | } |
| 428 | return 0; |
| 429 | } |
| 430 | |
stefan@webrtc.org | dca71b2 | 2013-03-27 16:36:01 +0000 | [diff] [blame] | 431 | bool ViEEncoder::EncoderPaused() const { |
pwestin@webrtc.org | 3816c52 | 2013-04-25 22:20:08 +0000 | [diff] [blame] | 432 | // Pause video if paused by caller or as long as the network is down or the |
| 433 | // pacer queue has grown too large in buffered mode. |
| 434 | if (encoder_paused_) { |
| 435 | return true; |
| 436 | } |
| 437 | if (target_delay_ms_ > 0) { |
| 438 | // Buffered mode. |
| 439 | // TODO(pwestin): Workaround until nack is configured as a time and not |
| 440 | // number of packets. |
| 441 | return paced_sender_->QueueInMs() >= |
pwestin@webrtc.org | 36bdba4 | 2013-05-02 19:02:17 +0000 | [diff] [blame] | 442 | std::max(static_cast<int>(target_delay_ms_ * kEncoderPausePacerMargin), |
| 443 | kMinPacingDelayMs); |
pwestin@webrtc.org | 3816c52 | 2013-04-25 22:20:08 +0000 | [diff] [blame] | 444 | } |
| 445 | return !network_is_transmitting_; |
stefan@webrtc.org | dca71b2 | 2013-03-27 16:36:01 +0000 | [diff] [blame] | 446 | } |
| 447 | |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 448 | RtpRtcp* ViEEncoder::SendRtpRtcpModule() { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 449 | return default_rtp_rtcp_.get(); |
| 450 | } |
| 451 | |
| 452 | void ViEEncoder::DeliverFrame(int id, |
mikhal@webrtc.org | 3bbed74 | 2012-10-24 18:33:04 +0000 | [diff] [blame] | 453 | I420VideoFrame* video_frame, |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 454 | int num_csrcs, |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 455 | const uint32_t CSRC[kRtpCsrcSize]) { |
wuchengli@chromium.org | 76cd2f7 | 2014-03-19 03:44:20 +0000 | [diff] [blame] | 456 | if (default_rtp_rtcp_->SendingMedia() == false) { |
| 457 | // We've paused or we have no channels attached, don't encode. |
| 458 | return; |
| 459 | } |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 460 | { |
| 461 | CriticalSectionScoped cs(data_cs_.get()); |
stefan@webrtc.org | 5e74d96 | 2013-10-18 15:05:29 +0000 | [diff] [blame] | 462 | time_of_last_incoming_frame_ms_ = TickTime::MillisecondTimestamp(); |
pwestin@webrtc.org | 36bdba4 | 2013-05-02 19:02:17 +0000 | [diff] [blame] | 463 | if (EncoderPaused()) { |
| 464 | if (!encoder_paused_and_dropped_frame_) { |
| 465 | TRACE_EVENT_ASYNC_BEGIN0("webrtc", "EncoderPaused", this); |
| 466 | } |
| 467 | encoder_paused_and_dropped_frame_ = true; |
| 468 | return; |
| 469 | } |
| 470 | if (encoder_paused_and_dropped_frame_) { |
| 471 | TRACE_EVENT_ASYNC_END0("webrtc", "EncoderPaused", this); |
| 472 | } |
| 473 | encoder_paused_and_dropped_frame_ = false; |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 474 | } |
| 475 | |
| 476 | // Convert render time, in ms, to RTP timestamp. |
| 477 | const int kMsToRtpTimestamp = 90; |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 478 | const uint32_t time_stamp = |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 479 | kMsToRtpTimestamp * |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 480 | static_cast<uint32_t>(video_frame->render_time_ms()); |
hclam@chromium.org | 74472fe | 2013-04-09 19:54:10 +0000 | [diff] [blame] | 481 | |
hclam@chromium.org | 9c0f14d | 2013-07-08 21:31:18 +0000 | [diff] [blame] | 482 | TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", video_frame->render_time_ms(), |
| 483 | "Encode"); |
mikhal@webrtc.org | 3bbed74 | 2012-10-24 18:33:04 +0000 | [diff] [blame] | 484 | video_frame->set_timestamp(time_stamp); |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 485 | |
| 486 | // Make sure the CSRC list is correct. |
| 487 | if (num_csrcs > 0) { |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 488 | uint32_t tempCSRC[kRtpCsrcSize]; |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 489 | for (int i = 0; i < num_csrcs; i++) { |
| 490 | if (CSRC[i] == 1) { |
| 491 | tempCSRC[i] = default_rtp_rtcp_->SSRC(); |
| 492 | } else { |
| 493 | tempCSRC[i] = CSRC[i]; |
| 494 | } |
| 495 | } |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 496 | default_rtp_rtcp_->SetCSRCs(tempCSRC, (uint8_t) num_csrcs); |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 497 | } |
wuchengli@chromium.org | 4ee6348 | 2014-06-20 12:04:05 +0000 | [diff] [blame] | 498 | |
pwestin@webrtc.org | 28f76e5 | 2012-10-30 16:21:52 +0000 | [diff] [blame] | 499 | I420VideoFrame* decimated_frame = NULL; |
wuchengli@chromium.org | 4ee6348 | 2014-06-20 12:04:05 +0000 | [diff] [blame] | 500 | // TODO(wuchengli): support texture frames. |
| 501 | if (video_frame->native_handle() == NULL) { |
| 502 | { |
| 503 | CriticalSectionScoped cs(callback_cs_.get()); |
| 504 | if (effect_filter_) { |
| 505 | unsigned int length = |
| 506 | CalcBufferSize(kI420, video_frame->width(), video_frame->height()); |
| 507 | scoped_ptr<uint8_t[]> video_buffer(new uint8_t[length]); |
| 508 | ExtractBuffer(*video_frame, length, video_buffer.get()); |
| 509 | effect_filter_->Transform(length, |
| 510 | video_buffer.get(), |
| 511 | video_frame->ntp_time_ms(), |
| 512 | video_frame->timestamp(), |
| 513 | video_frame->width(), |
| 514 | video_frame->height()); |
| 515 | } |
| 516 | } |
| 517 | |
| 518 | // Pass frame via preprocessor. |
| 519 | const int ret = vpm_.PreprocessFrame(*video_frame, &decimated_frame); |
| 520 | if (ret == 1) { |
| 521 | // Drop this frame. |
| 522 | return; |
| 523 | } |
| 524 | if (ret != VPM_OK) { |
| 525 | return; |
| 526 | } |
pwestin@webrtc.org | 28f76e5 | 2012-10-30 16:21:52 +0000 | [diff] [blame] | 527 | } |
wuchengli@chromium.org | 4ee6348 | 2014-06-20 12:04:05 +0000 | [diff] [blame] | 528 | // If the frame was not resampled or scaled => use original. |
pwestin@webrtc.org | 28f76e5 | 2012-10-30 16:21:52 +0000 | [diff] [blame] | 529 | if (decimated_frame == NULL) { |
| 530 | decimated_frame = video_frame; |
| 531 | } |
pbos@webrtc.org | 63301bd | 2013-10-21 10:34:43 +0000 | [diff] [blame] | 532 | |
| 533 | { |
| 534 | CriticalSectionScoped cs(callback_cs_.get()); |
| 535 | if (pre_encode_callback_) |
| 536 | pre_encode_callback_->FrameCallback(decimated_frame); |
| 537 | } |
| 538 | |
wuchengli@chromium.org | 4ee6348 | 2014-06-20 12:04:05 +0000 | [diff] [blame] | 539 | if (video_frame->native_handle() != NULL) { |
| 540 | // TODO(wuchengli): add texture support. http://crbug.com/362437 |
| 541 | return; |
| 542 | } |
| 543 | |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 544 | #ifdef VIDEOCODEC_VP8 |
| 545 | if (vcm_.SendCodec() == webrtc::kVideoCodecVP8) { |
| 546 | webrtc::CodecSpecificInfo codec_specific_info; |
| 547 | codec_specific_info.codecType = webrtc::kVideoCodecVP8; |
stefan@webrtc.org | fedbe8b | 2014-07-09 14:46:31 +0000 | [diff] [blame] | 548 | { |
| 549 | CriticalSectionScoped cs(data_cs_.get()); |
| 550 | codec_specific_info.codecSpecific.VP8.hasReceivedRPSI = |
| 551 | has_received_rpsi_; |
| 552 | codec_specific_info.codecSpecific.VP8.hasReceivedSLI = |
| 553 | has_received_sli_; |
| 554 | codec_specific_info.codecSpecific.VP8.pictureIdRPSI = |
| 555 | picture_id_rpsi_; |
| 556 | codec_specific_info.codecSpecific.VP8.pictureIdSLI = |
| 557 | picture_id_sli_; |
| 558 | has_received_sli_ = false; |
| 559 | has_received_rpsi_ = false; |
| 560 | } |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 561 | |
mflodman@webrtc.org | 022615b | 2014-04-07 10:56:31 +0000 | [diff] [blame] | 562 | vcm_.AddVideoFrame(*decimated_frame, vpm_.ContentMetrics(), |
| 563 | &codec_specific_info); |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 564 | return; |
| 565 | } |
| 566 | #endif |
mflodman@webrtc.org | 022615b | 2014-04-07 10:56:31 +0000 | [diff] [blame] | 567 | vcm_.AddVideoFrame(*decimated_frame); |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 568 | } |
| 569 | |
| 570 | void ViEEncoder::DelayChanged(int id, int frame_delay) { |
stefan@webrtc.org | 73ebe67 | 2013-04-09 14:56:29 +0000 | [diff] [blame] | 571 | default_rtp_rtcp_->SetCameraDelay(frame_delay); |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 572 | } |
| 573 | |
| 574 | int ViEEncoder::GetPreferedFrameSettings(int* width, |
| 575 | int* height, |
| 576 | int* frame_rate) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 577 | webrtc::VideoCodec video_codec; |
| 578 | memset(&video_codec, 0, sizeof(video_codec)); |
| 579 | if (vcm_.SendCodec(&video_codec) != VCM_OK) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 580 | return -1; |
| 581 | } |
| 582 | |
| 583 | *width = video_codec.width; |
| 584 | *height = video_codec.height; |
| 585 | *frame_rate = video_codec.maxFramerate; |
| 586 | return 0; |
| 587 | } |
| 588 | |
| 589 | int ViEEncoder::SendKeyFrame() { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 590 | return vcm_.IntraFrameRequest(0); |
| 591 | } |
| 592 | |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 593 | int32_t ViEEncoder::SendCodecStatistics( |
| 594 | uint32_t* num_key_frames, uint32_t* num_delta_frames) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 595 | webrtc::VCMFrameCount sent_frames; |
| 596 | if (vcm_.SentFrameCount(sent_frames) != VCM_OK) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 597 | return -1; |
| 598 | } |
| 599 | *num_key_frames = sent_frames.numKeyFrames; |
| 600 | *num_delta_frames = sent_frames.numDeltaFrames; |
| 601 | return 0; |
| 602 | } |
| 603 | |
jiayl@webrtc.org | 55a2a27 | 2014-02-27 22:32:40 +0000 | [diff] [blame] | 604 | int32_t ViEEncoder::PacerQueuingDelayMs() const { |
| 605 | return paced_sender_->QueueInMs(); |
| 606 | } |
| 607 | |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 608 | int ViEEncoder::CodecTargetBitrate(uint32_t* bitrate) const { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 609 | if (vcm_.Bitrate(bitrate) != 0) |
| 610 | return -1; |
| 611 | return 0; |
| 612 | } |
| 613 | |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 614 | int32_t ViEEncoder::UpdateProtectionMethod(bool enable_nack) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 615 | bool fec_enabled = false; |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 616 | uint8_t dummy_ptype_red = 0; |
| 617 | uint8_t dummy_ptypeFEC = 0; |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 618 | |
| 619 | // Updated protection method to VCM to get correct packetization sizes. |
| 620 | // FEC has larger overhead than NACK -> set FEC if used. |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 621 | int32_t error = default_rtp_rtcp_->GenericFECStatus(fec_enabled, |
| 622 | dummy_ptype_red, |
| 623 | dummy_ptypeFEC); |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 624 | if (error) { |
| 625 | return -1; |
| 626 | } |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 627 | if (fec_enabled_ == fec_enabled && nack_enabled_ == enable_nack) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 628 | // No change needed, we're already in correct state. |
| 629 | return 0; |
| 630 | } |
| 631 | fec_enabled_ = fec_enabled; |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 632 | nack_enabled_ = enable_nack; |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 633 | |
| 634 | // Set Video Protection for VCM. |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 635 | if (fec_enabled && nack_enabled_) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 636 | vcm_.SetVideoProtection(webrtc::kProtectionNackFEC, true); |
| 637 | } else { |
| 638 | vcm_.SetVideoProtection(webrtc::kProtectionFEC, fec_enabled_); |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 639 | vcm_.SetVideoProtection(webrtc::kProtectionNackSender, nack_enabled_); |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 640 | vcm_.SetVideoProtection(webrtc::kProtectionNackFEC, false); |
| 641 | } |
| 642 | |
wu@webrtc.org | 7fc75bb | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 643 | if (fec_enabled_ || nack_enabled_) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 644 | vcm_.RegisterProtectionCallback(this); |
| 645 | // The send codec must be registered to set correct MTU. |
| 646 | webrtc::VideoCodec codec; |
| 647 | if (vcm_.SendCodec(&codec) == 0) { |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 648 | uint16_t max_pay_load = default_rtp_rtcp_->MaxDataPayloadLength(); |
stefan@webrtc.org | 6313692 | 2013-03-19 10:04:57 +0000 | [diff] [blame] | 649 | uint32_t current_bitrate_bps = 0; |
| 650 | if (vcm_.Bitrate(¤t_bitrate_bps) != 0) { |
mflodman@webrtc.org | 022615b | 2014-04-07 10:56:31 +0000 | [diff] [blame] | 651 | LOG_F(LS_WARNING) << |
| 652 | "Failed to get the current encoder target bitrate."; |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 653 | } |
stefan@webrtc.org | 6313692 | 2013-03-19 10:04:57 +0000 | [diff] [blame] | 654 | // Convert to start bitrate in kbps. |
| 655 | codec.startBitrate = (current_bitrate_bps + 500) / 1000; |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 656 | if (vcm_.RegisterSendCodec(&codec, number_of_cores_, max_pay_load) != 0) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 657 | return -1; |
| 658 | } |
| 659 | } |
| 660 | return 0; |
| 661 | } else { |
| 662 | // FEC and NACK are disabled. |
| 663 | vcm_.RegisterProtectionCallback(NULL); |
| 664 | } |
| 665 | return 0; |
| 666 | } |
| 667 | |
mikhal@webrtc.org | 9d6fcb3 | 2013-02-15 23:22:18 +0000 | [diff] [blame] | 668 | void ViEEncoder::SetSenderBufferingMode(int target_delay_ms) { |
stefan@webrtc.org | dca71b2 | 2013-03-27 16:36:01 +0000 | [diff] [blame] | 669 | { |
| 670 | CriticalSectionScoped cs(data_cs_.get()); |
| 671 | target_delay_ms_ = target_delay_ms; |
| 672 | } |
mikhal@webrtc.org | 0c66de6 | 2013-02-10 18:42:55 +0000 | [diff] [blame] | 673 | if (target_delay_ms > 0) { |
stefan@webrtc.org | dca71b2 | 2013-03-27 16:36:01 +0000 | [diff] [blame] | 674 | // Disable external frame-droppers. |
| 675 | vcm_.EnableFrameDropper(false); |
| 676 | vpm_.EnableTemporalDecimation(false); |
stefan@webrtc.org | 04d6593 | 2013-11-27 14:16:20 +0000 | [diff] [blame] | 677 | // We don't put any limits on the pacer queue when running in buffered mode |
| 678 | // since the encoder will be paused if the queue grow too large. |
| 679 | paced_sender_->set_max_queue_length_ms(-1); |
mikhal@webrtc.org | 0c66de6 | 2013-02-10 18:42:55 +0000 | [diff] [blame] | 680 | } else { |
mikhal@webrtc.org | 9d6fcb3 | 2013-02-15 23:22:18 +0000 | [diff] [blame] | 681 | // Real-time mode - enable frame droppers. |
mikhal@webrtc.org | 0c66de6 | 2013-02-10 18:42:55 +0000 | [diff] [blame] | 682 | vpm_.EnableTemporalDecimation(true); |
| 683 | vcm_.EnableFrameDropper(true); |
stefan@webrtc.org | 04d6593 | 2013-11-27 14:16:20 +0000 | [diff] [blame] | 684 | paced_sender_->set_max_queue_length_ms( |
| 685 | PacedSender::kDefaultMaxQueueLengthMs); |
mikhal@webrtc.org | 0c66de6 | 2013-02-10 18:42:55 +0000 | [diff] [blame] | 686 | } |
| 687 | } |
| 688 | |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 689 | int32_t ViEEncoder::SendData( |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 690 | const FrameType frame_type, |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 691 | const uint8_t payload_type, |
| 692 | const uint32_t time_stamp, |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 693 | int64_t capture_time_ms, |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 694 | const uint8_t* payload_data, |
| 695 | const uint32_t payload_size, |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 696 | const webrtc::RTPFragmentationHeader& fragmentation_header, |
| 697 | const RTPVideoHeader* rtp_video_hdr) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 698 | // New encoded data, hand over to the rtp module. |
| 699 | return default_rtp_rtcp_->SendOutgoingData(frame_type, |
| 700 | payload_type, |
| 701 | time_stamp, |
| 702 | capture_time_ms, |
| 703 | payload_data, |
| 704 | payload_size, |
| 705 | &fragmentation_header, |
| 706 | rtp_video_hdr); |
| 707 | } |
| 708 | |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 709 | int32_t ViEEncoder::ProtectionRequest( |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 710 | const FecProtectionParams* delta_fec_params, |
| 711 | const FecProtectionParams* key_fec_params, |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 712 | uint32_t* sent_video_rate_bps, |
| 713 | uint32_t* sent_nack_rate_bps, |
| 714 | uint32_t* sent_fec_rate_bps) { |
mflodman@webrtc.org | 022615b | 2014-04-07 10:56:31 +0000 | [diff] [blame] | 715 | default_rtp_rtcp_->SetFecParameters(delta_fec_params, key_fec_params); |
| 716 | default_rtp_rtcp_->BitrateSent(NULL, sent_video_rate_bps, sent_fec_rate_bps, |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 717 | sent_nack_rate_bps); |
| 718 | return 0; |
| 719 | } |
| 720 | |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 721 | int32_t ViEEncoder::SendStatistics(const uint32_t bit_rate, |
| 722 | const uint32_t frame_rate) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 723 | CriticalSectionScoped cs(callback_cs_.get()); |
| 724 | if (codec_observer_) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 725 | codec_observer_->OutgoingRate(channel_id_, frame_rate, bit_rate); |
| 726 | } |
| 727 | return 0; |
| 728 | } |
| 729 | |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 730 | int32_t ViEEncoder::RegisterCodecObserver(ViEEncoderObserver* observer) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 731 | CriticalSectionScoped cs(callback_cs_.get()); |
mflodman@webrtc.org | 022615b | 2014-04-07 10:56:31 +0000 | [diff] [blame] | 732 | if (observer && codec_observer_) { |
| 733 | LOG_F(LS_ERROR) << "Observer already set."; |
| 734 | return -1; |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 735 | } |
mflodman@webrtc.org | 022615b | 2014-04-07 10:56:31 +0000 | [diff] [blame] | 736 | codec_observer_ = observer; |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 737 | return 0; |
| 738 | } |
| 739 | |
| 740 | void ViEEncoder::OnReceivedSLI(uint32_t /*ssrc*/, |
| 741 | uint8_t picture_id) { |
stefan@webrtc.org | fedbe8b | 2014-07-09 14:46:31 +0000 | [diff] [blame] | 742 | CriticalSectionScoped cs(data_cs_.get()); |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 743 | picture_id_sli_ = picture_id; |
| 744 | has_received_sli_ = true; |
| 745 | } |
| 746 | |
| 747 | void ViEEncoder::OnReceivedRPSI(uint32_t /*ssrc*/, |
| 748 | uint64_t picture_id) { |
stefan@webrtc.org | fedbe8b | 2014-07-09 14:46:31 +0000 | [diff] [blame] | 749 | CriticalSectionScoped cs(data_cs_.get()); |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 750 | picture_id_rpsi_ = picture_id; |
| 751 | has_received_rpsi_ = true; |
| 752 | } |
| 753 | |
mflodman@webrtc.org | b6d9cfc | 2012-10-25 11:30:29 +0000 | [diff] [blame] | 754 | void ViEEncoder::OnReceivedIntraFrameRequest(uint32_t ssrc) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 755 | // Key frame request from remote side, signal to VCM. |
justinlin@chromium.org | d474c13 | 2013-05-13 22:59:00 +0000 | [diff] [blame] | 756 | TRACE_EVENT0("webrtc", "OnKeyFrameRequest"); |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 757 | |
mflodman@webrtc.org | b6d9cfc | 2012-10-25 11:30:29 +0000 | [diff] [blame] | 758 | int idx = 0; |
| 759 | { |
| 760 | CriticalSectionScoped cs(data_cs_.get()); |
| 761 | std::map<unsigned int, int>::iterator stream_it = ssrc_streams_.find(ssrc); |
| 762 | if (stream_it == ssrc_streams_.end()) { |
mflodman@webrtc.org | ac09423 | 2012-12-20 09:26:17 +0000 | [diff] [blame] | 763 | LOG_F(LS_WARNING) << "ssrc not found: " << ssrc << ", map size " |
| 764 | << ssrc_streams_.size(); |
mflodman@webrtc.org | b6d9cfc | 2012-10-25 11:30:29 +0000 | [diff] [blame] | 765 | return; |
| 766 | } |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 767 | std::map<unsigned int, int64_t>::iterator time_it = |
mflodman@webrtc.org | b6d9cfc | 2012-10-25 11:30:29 +0000 | [diff] [blame] | 768 | time_last_intra_request_ms_.find(ssrc); |
| 769 | if (time_it == time_last_intra_request_ms_.end()) { |
| 770 | time_last_intra_request_ms_[ssrc] = 0; |
| 771 | } |
| 772 | |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 773 | int64_t now = TickTime::MillisecondTimestamp(); |
mflodman@webrtc.org | b6d9cfc | 2012-10-25 11:30:29 +0000 | [diff] [blame] | 774 | if (time_last_intra_request_ms_[ssrc] + kViEMinKeyRequestIntervalMs > now) { |
mflodman@webrtc.org | b6d9cfc | 2012-10-25 11:30:29 +0000 | [diff] [blame] | 775 | return; |
| 776 | } |
| 777 | time_last_intra_request_ms_[ssrc] = now; |
| 778 | idx = stream_it->second; |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 779 | } |
mflodman@webrtc.org | b6d9cfc | 2012-10-25 11:30:29 +0000 | [diff] [blame] | 780 | // Release the critsect before triggering key frame. |
| 781 | vcm_.IntraFrameRequest(idx); |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 782 | } |
| 783 | |
| 784 | void ViEEncoder::OnLocalSsrcChanged(uint32_t old_ssrc, uint32_t new_ssrc) { |
mflodman@webrtc.org | b6d9cfc | 2012-10-25 11:30:29 +0000 | [diff] [blame] | 785 | CriticalSectionScoped cs(data_cs_.get()); |
| 786 | std::map<unsigned int, int>::iterator it = ssrc_streams_.find(old_ssrc); |
| 787 | if (it == ssrc_streams_.end()) { |
| 788 | return; |
| 789 | } |
| 790 | |
| 791 | ssrc_streams_[new_ssrc] = it->second; |
| 792 | ssrc_streams_.erase(it); |
| 793 | |
| 794 | std::map<unsigned int, int64_t>::iterator time_it = |
| 795 | time_last_intra_request_ms_.find(old_ssrc); |
| 796 | int64_t last_intra_request_ms = 0; |
| 797 | if (time_it != time_last_intra_request_ms_.end()) { |
| 798 | last_intra_request_ms = time_it->second; |
| 799 | time_last_intra_request_ms_.erase(time_it); |
| 800 | } |
| 801 | time_last_intra_request_ms_[new_ssrc] = last_intra_request_ms; |
| 802 | } |
| 803 | |
| 804 | bool ViEEncoder::SetSsrcs(const std::list<unsigned int>& ssrcs) { |
| 805 | VideoCodec codec; |
| 806 | if (vcm_.SendCodec(&codec) != 0) |
| 807 | return false; |
| 808 | |
| 809 | if (codec.numberOfSimulcastStreams > 0 && |
| 810 | ssrcs.size() != codec.numberOfSimulcastStreams) { |
| 811 | return false; |
| 812 | } |
| 813 | |
| 814 | CriticalSectionScoped cs(data_cs_.get()); |
| 815 | ssrc_streams_.clear(); |
| 816 | time_last_intra_request_ms_.clear(); |
| 817 | int idx = 0; |
| 818 | for (std::list<unsigned int>::const_iterator it = ssrcs.begin(); |
| 819 | it != ssrcs.end(); ++it, ++idx) { |
| 820 | unsigned int ssrc = *it; |
| 821 | ssrc_streams_[ssrc] = idx; |
| 822 | } |
| 823 | return true; |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 824 | } |
| 825 | |
pbos@webrtc.org | 3f83f9c | 2014-03-13 12:52:27 +0000 | [diff] [blame] | 826 | void ViEEncoder::SetMinTransmitBitrate(int min_transmit_bitrate_kbps) { |
| 827 | assert(min_transmit_bitrate_kbps >= 0); |
| 828 | CriticalSectionScoped crit(data_cs_.get()); |
| 829 | min_transmit_bitrate_kbps_ = min_transmit_bitrate_kbps; |
| 830 | } |
| 831 | |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 832 | // Called from ViEBitrateObserver. |
| 833 | void ViEEncoder::OnNetworkChanged(const uint32_t bitrate_bps, |
| 834 | const uint8_t fraction_lost, |
| 835 | const uint32_t round_trip_time_ms) { |
mflodman@webrtc.org | 022615b | 2014-04-07 10:56:31 +0000 | [diff] [blame] | 836 | LOG(LS_VERBOSE) << "OnNetworkChanged, bitrate" << bitrate_bps |
| 837 | << " packet loss " << fraction_lost |
| 838 | << " rtt " << round_trip_time_ms; |
stefan@webrtc.org | 72e204a | 2013-03-18 17:00:51 +0000 | [diff] [blame] | 839 | vcm_.SetChannelParameters(bitrate_bps, fraction_lost, round_trip_time_ms); |
henrik.lundin@webrtc.org | 4590177 | 2013-11-18 12:18:43 +0000 | [diff] [blame] | 840 | bool video_is_suspended = vcm_.VideoSuspended(); |
pwestin@webrtc.org | 5e87b5f | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 841 | int bitrate_kbps = bitrate_bps / 1000; |
stefan@webrtc.org | 69f7605 | 2013-06-17 12:53:37 +0000 | [diff] [blame] | 842 | VideoCodec send_codec; |
| 843 | if (vcm_.SendCodec(&send_codec) != 0) { |
| 844 | return; |
| 845 | } |
stefan@webrtc.org | 7dc1790 | 2013-09-06 13:58:01 +0000 | [diff] [blame] | 846 | SimulcastStream* stream_configs = send_codec.simulcastStream; |
| 847 | // Allocate the bandwidth between the streams. |
| 848 | std::vector<uint32_t> stream_bitrates = AllocateStreamBitrates( |
| 849 | bitrate_bps, |
| 850 | stream_configs, |
| 851 | send_codec.numberOfSimulcastStreams); |
| 852 | // Find the max amount of padding we can allow ourselves to send at this |
| 853 | // point, based on which streams are currently active and what our current |
| 854 | // available bandwidth is. |
stefan@webrtc.org | 93cd397 | 2013-10-16 13:03:10 +0000 | [diff] [blame] | 855 | int pad_up_to_bitrate_kbps = 0; |
| 856 | if (send_codec.numberOfSimulcastStreams == 0) { |
stefan@webrtc.org | 93cd397 | 2013-10-16 13:03:10 +0000 | [diff] [blame] | 857 | pad_up_to_bitrate_kbps = send_codec.minBitrate; |
| 858 | } else { |
stefan@webrtc.org | 93cd397 | 2013-10-16 13:03:10 +0000 | [diff] [blame] | 859 | pad_up_to_bitrate_kbps = |
| 860 | stream_configs[send_codec.numberOfSimulcastStreams - 1].minBitrate; |
| 861 | for (int i = 0; i < send_codec.numberOfSimulcastStreams - 1; ++i) { |
| 862 | pad_up_to_bitrate_kbps += stream_configs[i].targetBitrate; |
| 863 | } |
stefan@webrtc.org | 7dc1790 | 2013-09-06 13:58:01 +0000 | [diff] [blame] | 864 | } |
pbos@webrtc.org | 1d61e3a | 2014-03-19 10:59:52 +0000 | [diff] [blame] | 865 | |
| 866 | // Disable padding if only sending one stream and video isn't suspended and |
| 867 | // min-transmit bitrate isn't used (applied later). |
| 868 | if (!video_is_suspended && send_codec.numberOfSimulcastStreams <= 1) |
stefan@webrtc.org | 93cd397 | 2013-10-16 13:03:10 +0000 | [diff] [blame] | 869 | pad_up_to_bitrate_kbps = 0; |
stefan@webrtc.org | 5e74d96 | 2013-10-18 15:05:29 +0000 | [diff] [blame] | 870 | |
| 871 | { |
stefan@webrtc.org | 5e74d96 | 2013-10-18 15:05:29 +0000 | [diff] [blame] | 872 | CriticalSectionScoped cs(data_cs_.get()); |
pbos@webrtc.org | 1d61e3a | 2014-03-19 10:59:52 +0000 | [diff] [blame] | 873 | // The amount of padding should decay to zero if no frames are being |
| 874 | // captured unless a min-transmit bitrate is used. |
stefan@webrtc.org | 5e74d96 | 2013-10-18 15:05:29 +0000 | [diff] [blame] | 875 | int64_t now_ms = TickTime::MillisecondTimestamp(); |
| 876 | if (now_ms - time_of_last_incoming_frame_ms_ > kStopPaddingThresholdMs) |
pbos@webrtc.org | 1d61e3a | 2014-03-19 10:59:52 +0000 | [diff] [blame] | 877 | pad_up_to_bitrate_kbps = 0; |
stefan@webrtc.org | 5e74d96 | 2013-10-18 15:05:29 +0000 | [diff] [blame] | 878 | |
pbos@webrtc.org | 1d61e3a | 2014-03-19 10:59:52 +0000 | [diff] [blame] | 879 | // Pad up to min bitrate. |
pbos@webrtc.org | 3f83f9c | 2014-03-13 12:52:27 +0000 | [diff] [blame] | 880 | if (pad_up_to_bitrate_kbps < min_transmit_bitrate_kbps_) |
| 881 | pad_up_to_bitrate_kbps = min_transmit_bitrate_kbps_; |
pbos@webrtc.org | 1d61e3a | 2014-03-19 10:59:52 +0000 | [diff] [blame] | 882 | |
| 883 | // Padding may never exceed bitrate estimate. |
| 884 | if (pad_up_to_bitrate_kbps > bitrate_kbps) |
| 885 | pad_up_to_bitrate_kbps = bitrate_kbps; |
| 886 | |
stefan@webrtc.org | c9995bc | 2014-07-04 09:20:42 +0000 | [diff] [blame] | 887 | paced_sender_->UpdateBitrate( |
| 888 | PacedSender::kDefaultPaceMultiplier * bitrate_kbps, |
| 889 | pad_up_to_bitrate_kbps); |
pbos@webrtc.org | 3f83f9c | 2014-03-13 12:52:27 +0000 | [diff] [blame] | 890 | default_rtp_rtcp_->SetTargetSendBitrate(stream_bitrates); |
pbos@webrtc.org | 7673871 | 2013-11-21 18:44:23 +0000 | [diff] [blame] | 891 | if (video_suspended_ == video_is_suspended) |
| 892 | return; |
| 893 | video_suspended_ = video_is_suspended; |
| 894 | } |
pbos@webrtc.org | 1d61e3a | 2014-03-19 10:59:52 +0000 | [diff] [blame] | 895 | |
| 896 | // Video suspend-state changed, inform codec observer. |
pbos@webrtc.org | 3f83f9c | 2014-03-13 12:52:27 +0000 | [diff] [blame] | 897 | CriticalSectionScoped crit(callback_cs_.get()); |
pbos@webrtc.org | 7673871 | 2013-11-21 18:44:23 +0000 | [diff] [blame] | 898 | if (codec_observer_) { |
mflodman@webrtc.org | 022615b | 2014-04-07 10:56:31 +0000 | [diff] [blame] | 899 | LOG(LS_INFO) << "Video suspended " << video_is_suspended |
| 900 | << " for channel " << channel_id_; |
henrik.lundin@webrtc.org | 82b883c | 2013-11-21 23:00:40 +0000 | [diff] [blame] | 901 | codec_observer_->SuspendChange(channel_id_, video_is_suspended); |
henrik.lundin@webrtc.org | 39079d1 | 2013-10-02 13:34:26 +0000 | [diff] [blame] | 902 | } |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 903 | } |
| 904 | |
pwestin@webrtc.org | 5e87b5f | 2012-11-13 21:12:39 +0000 | [diff] [blame] | 905 | PacedSender* ViEEncoder::GetPacedSender() { |
| 906 | return paced_sender_.get(); |
| 907 | } |
| 908 | |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 909 | int32_t ViEEncoder::RegisterEffectFilter(ViEEffectFilter* effect_filter) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 910 | CriticalSectionScoped cs(callback_cs_.get()); |
mflodman@webrtc.org | 022615b | 2014-04-07 10:56:31 +0000 | [diff] [blame] | 911 | if (effect_filter != NULL && effect_filter_ != NULL) { |
| 912 | LOG_F(LS_ERROR) << "Filter already set."; |
| 913 | return -1; |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 914 | } |
| 915 | effect_filter_ = effect_filter; |
| 916 | return 0; |
| 917 | } |
| 918 | |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 919 | int ViEEncoder::StartDebugRecording(const char* fileNameUTF8) { |
| 920 | return vcm_.StartDebugRecording(fileNameUTF8); |
| 921 | } |
| 922 | |
| 923 | int ViEEncoder::StopDebugRecording() { |
| 924 | return vcm_.StopDebugRecording(); |
| 925 | } |
| 926 | |
henrik.lundin@webrtc.org | 4590177 | 2013-11-18 12:18:43 +0000 | [diff] [blame] | 927 | void ViEEncoder::SuspendBelowMinBitrate() { |
| 928 | vcm_.SuspendBelowMinBitrate(); |
henrik.lundin@webrtc.org | 4ce7590 | 2013-10-28 10:16:14 +0000 | [diff] [blame] | 929 | bitrate_controller_->EnforceMinBitrate(false); |
henrik.lundin@webrtc.org | 39079d1 | 2013-10-02 13:34:26 +0000 | [diff] [blame] | 930 | } |
| 931 | |
pbos@webrtc.org | 63301bd | 2013-10-21 10:34:43 +0000 | [diff] [blame] | 932 | void ViEEncoder::RegisterPreEncodeCallback( |
| 933 | I420FrameCallback* pre_encode_callback) { |
| 934 | CriticalSectionScoped cs(callback_cs_.get()); |
| 935 | pre_encode_callback_ = pre_encode_callback; |
| 936 | } |
| 937 | |
| 938 | void ViEEncoder::DeRegisterPreEncodeCallback() { |
| 939 | CriticalSectionScoped cs(callback_cs_.get()); |
| 940 | pre_encode_callback_ = NULL; |
| 941 | } |
| 942 | |
sprang@webrtc.org | 2e98d45 | 2013-11-26 11:41:59 +0000 | [diff] [blame] | 943 | void ViEEncoder::RegisterPostEncodeImageCallback( |
| 944 | EncodedImageCallback* post_encode_callback) { |
| 945 | vcm_.RegisterPostEncodeImageCallback(post_encode_callback); |
| 946 | } |
| 947 | |
| 948 | void ViEEncoder::DeRegisterPostEncodeImageCallback() { |
| 949 | vcm_.RegisterPostEncodeImageCallback(NULL); |
| 950 | } |
| 951 | |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 952 | QMVideoSettingsCallback::QMVideoSettingsCallback(VideoProcessingModule* vpm) |
| 953 | : vpm_(vpm) { |
| 954 | } |
| 955 | |
| 956 | QMVideoSettingsCallback::~QMVideoSettingsCallback() { |
| 957 | } |
| 958 | |
pbos@webrtc.org | 67879bc | 2013-04-09 13:41:51 +0000 | [diff] [blame] | 959 | int32_t QMVideoSettingsCallback::SetVideoQMSettings( |
| 960 | const uint32_t frame_rate, |
| 961 | const uint32_t width, |
| 962 | const uint32_t height) { |
andrew@webrtc.org | b015cbe | 2012-10-22 18:19:23 +0000 | [diff] [blame] | 963 | return vpm_->SetTargetResolution(width, height, frame_rate); |
| 964 | } |
| 965 | |
| 966 | } // namespace webrtc |