pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1 | /* |
kjellander | 1afca73 | 2016-02-07 20:46:45 -0800 | [diff] [blame] | 2 | * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved. |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 3 | * |
kjellander | 1afca73 | 2016-02-07 20:46:45 -0800 | [diff] [blame] | 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. |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 9 | */ |
| 10 | |
kjellander@webrtc.org | 5ad1297 | 2016-02-12 06:39:40 +0100 | [diff] [blame] | 11 | #include "webrtc/media/engine/webrtcvideoengine2.h" |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 12 | |
asapersson | c5dabdd | 2016-03-21 04:15:50 -0700 | [diff] [blame] | 13 | #include <stdio.h> |
pbos@webrtc.org | c37e72e | 2015-01-05 18:51:13 +0000 | [diff] [blame] | 14 | #include <algorithm> |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 15 | #include <set> |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 16 | #include <string> |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 17 | #include <utility> |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 18 | |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 19 | #include "webrtc/base/copyonwritebuffer.h" |
buildbot@webrtc.org | a09a999 | 2014-08-13 17:26:08 +0000 | [diff] [blame] | 20 | #include "webrtc/base/logging.h" |
| 21 | #include "webrtc/base/stringutils.h" |
qiangchen | c27d89f | 2015-07-16 10:27:16 -0700 | [diff] [blame] | 22 | #include "webrtc/base/timeutils.h" |
tommi | e4f9650 | 2015-10-20 23:00:48 -0700 | [diff] [blame] | 23 | #include "webrtc/base/trace_event.h" |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 24 | #include "webrtc/call.h" |
magjed | 725e484 | 2016-11-16 00:48:13 -0800 | [diff] [blame] | 25 | #include "webrtc/common_video/h264/profile_level_id.h" |
kjellander@webrtc.org | 5ad1297 | 2016-02-12 06:39:40 +0100 | [diff] [blame] | 26 | #include "webrtc/media/engine/constants.h" |
magjed | 509e4fe | 2016-11-18 01:34:11 -0800 | [diff] [blame] | 27 | #include "webrtc/media/engine/internalencoderfactory.h" |
kjellander@webrtc.org | 5ad1297 | 2016-02-12 06:39:40 +0100 | [diff] [blame] | 28 | #include "webrtc/media/engine/simulcast.h" |
magjed | 614d5b7 | 2016-11-15 06:30:54 -0800 | [diff] [blame] | 29 | #include "webrtc/media/engine/videoencodersoftwarefallbackwrapper.h" |
magjed | f6acc2a | 2016-11-22 01:43:03 -0800 | [diff] [blame] | 30 | #include "webrtc/media/engine/videodecodersoftwarefallbackwrapper.h" |
kjellander@webrtc.org | 5ad1297 | 2016-02-12 06:39:40 +0100 | [diff] [blame] | 31 | #include "webrtc/media/engine/webrtcmediaengine.h" |
| 32 | #include "webrtc/media/engine/webrtcvideoencoderfactory.h" |
kjellander@webrtc.org | 5ad1297 | 2016-02-12 06:39:40 +0100 | [diff] [blame] | 33 | #include "webrtc/media/engine/webrtcvoiceengine.h" |
Peter Boström | 81ea54e | 2015-05-07 11:41:09 +0200 | [diff] [blame] | 34 | #include "webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h" |
Henrik Kjellander | 98f5351 | 2015-10-28 18:17:40 +0100 | [diff] [blame] | 35 | #include "webrtc/system_wrappers/include/field_trial.h" |
pbos@webrtc.org | 776e6f2 | 2014-10-29 15:28:39 +0000 | [diff] [blame] | 36 | #include "webrtc/video_decoder.h" |
pbos@webrtc.org | ab990ae | 2014-09-17 09:02:25 +0000 | [diff] [blame] | 37 | #include "webrtc/video_encoder.h" |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 38 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 39 | namespace cricket { |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 40 | namespace { |
Peter Boström | 81ea54e | 2015-05-07 11:41:09 +0200 | [diff] [blame] | 41 | |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 42 | // Three things happen when the FlexFEC field trial is enabled: |
| 43 | // 1) FlexFEC is exposed in the default codec list, eventually showing up |
| 44 | // in the default SDP. (See InternalEncoderFactory ctor.) |
| 45 | // 2) FlexFEC send parameters are set in the VideoSendStream config. |
| 46 | // 3) FlexFEC receive parameters are set in the FlexfecReceiveStream config, |
| 47 | // and the corresponding object is instantiated. |
| 48 | const char kFlexfecFieldTrialName[] = "WebRTC-FlexFEC-03"; |
| 49 | |
| 50 | bool IsFlexfecFieldTrialEnabled() { |
| 51 | return webrtc::field_trial::FindFullName(kFlexfecFieldTrialName) == "Enabled"; |
| 52 | } |
| 53 | |
Peter Boström | 81ea54e | 2015-05-07 11:41:09 +0200 | [diff] [blame] | 54 | // Wrap cricket::WebRtcVideoEncoderFactory as a webrtc::VideoEncoderFactory. |
| 55 | class EncoderFactoryAdapter : public webrtc::VideoEncoderFactory { |
| 56 | public: |
| 57 | // EncoderFactoryAdapter doesn't take ownership of |factory|, which is owned |
| 58 | // by e.g. PeerConnectionFactory. |
| 59 | explicit EncoderFactoryAdapter(cricket::WebRtcVideoEncoderFactory* factory) |
| 60 | : factory_(factory) {} |
| 61 | virtual ~EncoderFactoryAdapter() {} |
| 62 | |
| 63 | // Implement webrtc::VideoEncoderFactory. |
| 64 | webrtc::VideoEncoder* Create() override { |
magjed | 1e45cc6 | 2016-10-28 07:43:45 -0700 | [diff] [blame] | 65 | return factory_->CreateVideoEncoder(VideoCodec(kVp8CodecName)); |
Peter Boström | 81ea54e | 2015-05-07 11:41:09 +0200 | [diff] [blame] | 66 | } |
| 67 | |
| 68 | void Destroy(webrtc::VideoEncoder* encoder) override { |
| 69 | return factory_->DestroyVideoEncoder(encoder); |
| 70 | } |
| 71 | |
| 72 | private: |
| 73 | cricket::WebRtcVideoEncoderFactory* const factory_; |
| 74 | }; |
| 75 | |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 76 | webrtc::Call::Config::BitrateConfig GetBitrateConfigForCodec( |
| 77 | const VideoCodec& codec) { |
| 78 | webrtc::Call::Config::BitrateConfig config; |
| 79 | int bitrate_kbps; |
| 80 | if (codec.GetParam(kCodecParamMinBitrate, &bitrate_kbps) && |
| 81 | bitrate_kbps > 0) { |
| 82 | config.min_bitrate_bps = bitrate_kbps * 1000; |
| 83 | } else { |
| 84 | config.min_bitrate_bps = 0; |
| 85 | } |
| 86 | if (codec.GetParam(kCodecParamStartBitrate, &bitrate_kbps) && |
| 87 | bitrate_kbps > 0) { |
| 88 | config.start_bitrate_bps = bitrate_kbps * 1000; |
| 89 | } else { |
| 90 | // Do not reconfigure start bitrate unless it's specified and positive. |
| 91 | config.start_bitrate_bps = -1; |
| 92 | } |
| 93 | if (codec.GetParam(kCodecParamMaxBitrate, &bitrate_kbps) && |
| 94 | bitrate_kbps > 0) { |
| 95 | config.max_bitrate_bps = bitrate_kbps * 1000; |
| 96 | } else { |
| 97 | config.max_bitrate_bps = -1; |
| 98 | } |
| 99 | return config; |
| 100 | } |
| 101 | |
Peter Boström | 81ea54e | 2015-05-07 11:41:09 +0200 | [diff] [blame] | 102 | // An encoder factory that wraps Create requests for simulcastable codec types |
| 103 | // with a webrtc::SimulcastEncoderAdapter. Non simulcastable codec type |
| 104 | // requests are just passed through to the contained encoder factory. |
| 105 | class WebRtcSimulcastEncoderFactory |
| 106 | : public cricket::WebRtcVideoEncoderFactory { |
| 107 | public: |
| 108 | // WebRtcSimulcastEncoderFactory doesn't take ownership of |factory|, which is |
| 109 | // owned by e.g. PeerConnectionFactory. |
| 110 | explicit WebRtcSimulcastEncoderFactory( |
| 111 | cricket::WebRtcVideoEncoderFactory* factory) |
| 112 | : factory_(factory) {} |
| 113 | |
| 114 | static bool UseSimulcastEncoderFactory( |
magjed | 1e45cc6 | 2016-10-28 07:43:45 -0700 | [diff] [blame] | 115 | const std::vector<cricket::VideoCodec>& codecs) { |
Peter Boström | 81ea54e | 2015-05-07 11:41:09 +0200 | [diff] [blame] | 116 | // If any codec is VP8, use the simulcast factory. If asked to create a |
| 117 | // non-VP8 codec, we'll just return a contained factory encoder directly. |
| 118 | for (const auto& codec : codecs) { |
magjed | 1e45cc6 | 2016-10-28 07:43:45 -0700 | [diff] [blame] | 119 | if (CodecNamesEq(codec.name.c_str(), kVp8CodecName)) { |
Peter Boström | 81ea54e | 2015-05-07 11:41:09 +0200 | [diff] [blame] | 120 | return true; |
| 121 | } |
| 122 | } |
| 123 | return false; |
| 124 | } |
| 125 | |
| 126 | webrtc::VideoEncoder* CreateVideoEncoder( |
magjed | 1e45cc6 | 2016-10-28 07:43:45 -0700 | [diff] [blame] | 127 | const cricket::VideoCodec& codec) override { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 128 | RTC_DCHECK(factory_ != NULL); |
Peter Boström | 81ea54e | 2015-05-07 11:41:09 +0200 | [diff] [blame] | 129 | // If it's a codec type we can simulcast, create a wrapped encoder. |
magjed | 1e45cc6 | 2016-10-28 07:43:45 -0700 | [diff] [blame] | 130 | if (CodecNamesEq(codec.name.c_str(), kVp8CodecName)) { |
Peter Boström | 81ea54e | 2015-05-07 11:41:09 +0200 | [diff] [blame] | 131 | return new webrtc::SimulcastEncoderAdapter( |
| 132 | new EncoderFactoryAdapter(factory_)); |
| 133 | } |
magjed | 1e45cc6 | 2016-10-28 07:43:45 -0700 | [diff] [blame] | 134 | webrtc::VideoEncoder* encoder = factory_->CreateVideoEncoder(codec); |
Peter Boström | 81ea54e | 2015-05-07 11:41:09 +0200 | [diff] [blame] | 135 | if (encoder) { |
| 136 | non_simulcast_encoders_.push_back(encoder); |
| 137 | } |
| 138 | return encoder; |
| 139 | } |
| 140 | |
magjed | 1e45cc6 | 2016-10-28 07:43:45 -0700 | [diff] [blame] | 141 | const std::vector<cricket::VideoCodec>& supported_codecs() const override { |
| 142 | return factory_->supported_codecs(); |
Peter Boström | 81ea54e | 2015-05-07 11:41:09 +0200 | [diff] [blame] | 143 | } |
| 144 | |
| 145 | bool EncoderTypeHasInternalSource( |
| 146 | webrtc::VideoCodecType type) const override { |
| 147 | return factory_->EncoderTypeHasInternalSource(type); |
| 148 | } |
| 149 | |
| 150 | void DestroyVideoEncoder(webrtc::VideoEncoder* encoder) override { |
| 151 | // Check first to see if the encoder wasn't wrapped in a |
| 152 | // SimulcastEncoderAdapter. In that case, ask the factory to destroy it. |
| 153 | if (std::remove(non_simulcast_encoders_.begin(), |
| 154 | non_simulcast_encoders_.end(), |
| 155 | encoder) != non_simulcast_encoders_.end()) { |
| 156 | factory_->DestroyVideoEncoder(encoder); |
| 157 | return; |
| 158 | } |
| 159 | |
| 160 | // Otherwise, SimulcastEncoderAdapter can be deleted directly, and will call |
| 161 | // DestroyVideoEncoder on the factory for individual encoder instances. |
| 162 | delete encoder; |
| 163 | } |
| 164 | |
| 165 | private: |
magjed | d2fce17 | 2016-11-02 11:08:29 -0700 | [diff] [blame] | 166 | // Disable overloaded virtual function warning. TODO(magjed): Remove once |
| 167 | // http://crbug/webrtc/6402 is fixed. |
| 168 | using cricket::WebRtcVideoEncoderFactory::CreateVideoEncoder; |
| 169 | |
Peter Boström | 81ea54e | 2015-05-07 11:41:09 +0200 | [diff] [blame] | 170 | cricket::WebRtcVideoEncoderFactory* factory_; |
| 171 | // A list of encoders that were created without being wrapped in a |
| 172 | // SimulcastEncoderAdapter. |
| 173 | std::vector<webrtc::VideoEncoder*> non_simulcast_encoders_; |
| 174 | }; |
| 175 | |
Peter Boström | 81ea54e | 2015-05-07 11:41:09 +0200 | [diff] [blame] | 176 | void AddDefaultFeedbackParams(VideoCodec* codec) { |
| 177 | codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamCcm, kRtcpFbCcmParamFir)); |
| 178 | codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamNack, kParamValueEmpty)); |
| 179 | codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamNack, kRtcpFbNackParamPli)); |
| 180 | codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamRemb, kParamValueEmpty)); |
stefan | 43edf0f | 2015-11-20 18:05:48 -0800 | [diff] [blame] | 181 | codec->AddFeedbackParam( |
| 182 | FeedbackParam(kRtcpFbParamTransportCc, kParamValueEmpty)); |
Peter Boström | 81ea54e | 2015-05-07 11:41:09 +0200 | [diff] [blame] | 183 | } |
| 184 | |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 185 | static std::string CodecVectorToString(const std::vector<VideoCodec>& codecs) { |
| 186 | std::stringstream out; |
| 187 | out << '{'; |
| 188 | for (size_t i = 0; i < codecs.size(); ++i) { |
| 189 | out << codecs[i].ToString(); |
| 190 | if (i != codecs.size() - 1) { |
| 191 | out << ", "; |
| 192 | } |
| 193 | } |
| 194 | out << '}'; |
| 195 | return out.str(); |
| 196 | } |
| 197 | |
| 198 | static bool ValidateCodecFormats(const std::vector<VideoCodec>& codecs) { |
| 199 | bool has_video = false; |
| 200 | for (size_t i = 0; i < codecs.size(); ++i) { |
| 201 | if (!codecs[i].ValidateCodecFormat()) { |
| 202 | return false; |
| 203 | } |
| 204 | if (codecs[i].GetCodecType() == VideoCodec::CODEC_VIDEO) { |
| 205 | has_video = true; |
| 206 | } |
| 207 | } |
| 208 | if (!has_video) { |
| 209 | LOG(LS_ERROR) << "Setting codecs without a video codec is invalid: " |
| 210 | << CodecVectorToString(codecs); |
| 211 | return false; |
| 212 | } |
| 213 | return true; |
| 214 | } |
| 215 | |
Peter Boström | d4362cd | 2015-03-25 14:17:23 +0100 | [diff] [blame] | 216 | static bool ValidateStreamParams(const StreamParams& sp) { |
| 217 | if (sp.ssrcs.empty()) { |
| 218 | LOG(LS_ERROR) << "No SSRCs in stream parameters: " << sp.ToString(); |
| 219 | return false; |
| 220 | } |
| 221 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 222 | std::vector<uint32_t> primary_ssrcs; |
Peter Boström | d4362cd | 2015-03-25 14:17:23 +0100 | [diff] [blame] | 223 | sp.GetPrimarySsrcs(&primary_ssrcs); |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 224 | std::vector<uint32_t> rtx_ssrcs; |
Peter Boström | d4362cd | 2015-03-25 14:17:23 +0100 | [diff] [blame] | 225 | sp.GetFidSsrcs(primary_ssrcs, &rtx_ssrcs); |
| 226 | for (uint32_t rtx_ssrc : rtx_ssrcs) { |
| 227 | bool rtx_ssrc_present = false; |
| 228 | for (uint32_t sp_ssrc : sp.ssrcs) { |
| 229 | if (sp_ssrc == rtx_ssrc) { |
| 230 | rtx_ssrc_present = true; |
| 231 | break; |
| 232 | } |
| 233 | } |
| 234 | if (!rtx_ssrc_present) { |
| 235 | LOG(LS_ERROR) << "RTX SSRC '" << rtx_ssrc |
| 236 | << "' missing from StreamParams ssrcs: " << sp.ToString(); |
| 237 | return false; |
| 238 | } |
| 239 | } |
| 240 | if (!rtx_ssrcs.empty() && primary_ssrcs.size() != rtx_ssrcs.size()) { |
| 241 | LOG(LS_ERROR) |
| 242 | << "RTX SSRCs exist, but don't cover all SSRCs (unsupported): " |
| 243 | << sp.ToString(); |
| 244 | return false; |
| 245 | } |
| 246 | |
| 247 | return true; |
| 248 | } |
| 249 | |
noahric | fdac516 | 2015-08-27 01:59:29 -0700 | [diff] [blame] | 250 | // Returns true if the given codec is disallowed from doing simulcast. |
| 251 | bool IsCodecBlacklistedForSimulcast(const std::string& codec_name) { |
asapersson | 3ed3487 | 2015-11-10 05:16:26 -0800 | [diff] [blame] | 252 | return CodecNamesEq(codec_name, kH264CodecName) || |
| 253 | CodecNamesEq(codec_name, kVp9CodecName); |
noahric | fdac516 | 2015-08-27 01:59:29 -0700 | [diff] [blame] | 254 | } |
| 255 | |
Åsa Persson | 1c7d48d | 2015-09-08 09:21:43 +0200 | [diff] [blame] | 256 | // The selected thresholds for QVGA and VGA corresponded to a QP around 10. |
| 257 | // The change in QP declined above the selected bitrates. |
| 258 | static int GetMaxDefaultVideoBitrateKbps(int width, int height) { |
| 259 | if (width * height <= 320 * 240) { |
| 260 | return 600; |
| 261 | } else if (width * height <= 640 * 480) { |
| 262 | return 1700; |
| 263 | } else if (width * height <= 960 * 540) { |
| 264 | return 2000; |
| 265 | } else { |
| 266 | return 2500; |
| 267 | } |
| 268 | } |
perkj | 2d5f091 | 2016-02-29 00:04:41 -0800 | [diff] [blame] | 269 | |
asapersson | c5dabdd | 2016-03-21 04:15:50 -0700 | [diff] [blame] | 270 | bool GetVp9LayersFromFieldTrialGroup(int* num_spatial_layers, |
| 271 | int* num_temporal_layers) { |
| 272 | std::string group = webrtc::field_trial::FindFullName("WebRTC-SupportVP9SVC"); |
| 273 | if (group.empty()) |
| 274 | return false; |
| 275 | |
| 276 | if (sscanf(group.c_str(), "EnabledByFlag_%dSL%dTL", num_spatial_layers, |
| 277 | num_temporal_layers) != 2) { |
| 278 | return false; |
| 279 | } |
asapersson | af9e4ac | 2016-03-31 00:36:49 -0700 | [diff] [blame] | 280 | const int kMaxSpatialLayers = 2; |
asapersson | c5dabdd | 2016-03-21 04:15:50 -0700 | [diff] [blame] | 281 | if (*num_spatial_layers > kMaxSpatialLayers || *num_spatial_layers < 1) |
| 282 | return false; |
| 283 | |
| 284 | const int kMaxTemporalLayers = 3; |
| 285 | if (*num_temporal_layers > kMaxTemporalLayers || *num_temporal_layers < 1) |
| 286 | return false; |
| 287 | |
| 288 | return true; |
| 289 | } |
| 290 | |
| 291 | int GetDefaultVp9SpatialLayers() { |
| 292 | int num_sl; |
| 293 | int num_tl; |
| 294 | if (GetVp9LayersFromFieldTrialGroup(&num_sl, &num_tl)) { |
| 295 | return num_sl; |
| 296 | } |
| 297 | return 1; |
| 298 | } |
| 299 | |
| 300 | int GetDefaultVp9TemporalLayers() { |
| 301 | int num_sl; |
| 302 | int num_tl; |
| 303 | if (GetVp9LayersFromFieldTrialGroup(&num_sl, &num_tl)) { |
| 304 | return num_tl; |
| 305 | } |
| 306 | return 1; |
| 307 | } |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 308 | |
| 309 | class EncoderStreamFactory |
| 310 | : public webrtc::VideoEncoderConfig::VideoStreamFactoryInterface { |
| 311 | public: |
| 312 | EncoderStreamFactory(std::string codec_name, |
| 313 | int max_qp, |
| 314 | int max_framerate, |
| 315 | bool is_screencast, |
| 316 | bool conference_mode) |
| 317 | : codec_name_(codec_name), |
| 318 | max_qp_(max_qp), |
| 319 | max_framerate_(max_framerate), |
| 320 | is_screencast_(is_screencast), |
| 321 | conference_mode_(conference_mode) {} |
| 322 | |
| 323 | private: |
| 324 | std::vector<webrtc::VideoStream> CreateEncoderStreams( |
| 325 | int width, |
| 326 | int height, |
| 327 | const webrtc::VideoEncoderConfig& encoder_config) override { |
| 328 | RTC_DCHECK(encoder_config.number_of_streams > 1 ? !is_screencast_ : true); |
| 329 | if (encoder_config.number_of_streams > 1) { |
| 330 | return GetSimulcastConfig(encoder_config.number_of_streams, width, height, |
| 331 | encoder_config.max_bitrate_bps, max_qp_, |
| 332 | max_framerate_); |
| 333 | } |
| 334 | |
| 335 | // For unset max bitrates set default bitrate for non-simulcast. |
| 336 | int max_bitrate_bps = |
| 337 | (encoder_config.max_bitrate_bps > 0) |
| 338 | ? encoder_config.max_bitrate_bps |
| 339 | : GetMaxDefaultVideoBitrateKbps(width, height) * 1000; |
| 340 | |
| 341 | webrtc::VideoStream stream; |
| 342 | stream.width = width; |
| 343 | stream.height = height; |
| 344 | stream.max_framerate = max_framerate_; |
| 345 | stream.min_bitrate_bps = kMinVideoBitrateKbps * 1000; |
| 346 | stream.target_bitrate_bps = stream.max_bitrate_bps = max_bitrate_bps; |
| 347 | stream.max_qp = max_qp_; |
| 348 | |
| 349 | // Conference mode screencast uses 2 temporal layers split at 100kbit. |
| 350 | if (conference_mode_ && is_screencast_) { |
| 351 | ScreenshareLayerConfig config = ScreenshareLayerConfig::GetDefault(); |
| 352 | // For screenshare in conference mode, tl0 and tl1 bitrates are |
| 353 | // piggybacked |
| 354 | // on the VideoCodec struct as target and max bitrates, respectively. |
| 355 | // See eg. webrtc::VP8EncoderImpl::SetRates(). |
| 356 | stream.target_bitrate_bps = config.tl0_bitrate_kbps * 1000; |
| 357 | stream.max_bitrate_bps = config.tl1_bitrate_kbps * 1000; |
| 358 | stream.temporal_layer_thresholds_bps.clear(); |
| 359 | stream.temporal_layer_thresholds_bps.push_back(config.tl0_bitrate_kbps * |
| 360 | 1000); |
| 361 | } |
| 362 | |
| 363 | if (CodecNamesEq(codec_name_, kVp9CodecName) && !is_screencast_) { |
| 364 | stream.temporal_layer_thresholds_bps.resize( |
| 365 | GetDefaultVp9TemporalLayers() - 1); |
| 366 | } |
| 367 | |
| 368 | std::vector<webrtc::VideoStream> streams; |
| 369 | streams.push_back(stream); |
| 370 | return streams; |
| 371 | } |
| 372 | |
| 373 | const std::string codec_name_; |
| 374 | const int max_qp_; |
| 375 | const int max_framerate_; |
| 376 | const bool is_screencast_; |
| 377 | const bool conference_mode_; |
| 378 | }; |
| 379 | |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 380 | } // namespace |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 381 | |
kjellander@webrtc.org | 5ad1297 | 2016-02-12 06:39:40 +0100 | [diff] [blame] | 382 | // Constants defined in webrtc/media/engine/constants.h |
Peter Boström | 81ea54e | 2015-05-07 11:41:09 +0200 | [diff] [blame] | 383 | // TODO(pbos): Move these to a separate constants.cc file. |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 384 | const int kMinVideoBitrateKbps = 30; |
Peter Boström | 81ea54e | 2015-05-07 11:41:09 +0200 | [diff] [blame] | 385 | |
| 386 | const int kVideoMtu = 1200; |
| 387 | const int kVideoRtpBufferSize = 65536; |
| 388 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 389 | // This constant is really an on/off, lower-level configurable NACK history |
| 390 | // duration hasn't been implemented. |
| 391 | static const int kNackHistoryMs = 1000; |
| 392 | |
buildbot@webrtc.org | 933d88a | 2014-09-18 20:23:05 +0000 | [diff] [blame] | 393 | static const int kDefaultQpMax = 56; |
| 394 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 395 | static const int kDefaultRtcpReceiverReportSsrc = 1; |
| 396 | |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 397 | // Minimum time interval for logging stats. |
| 398 | static const int64_t kStatsLogIntervalMs = 10000; |
| 399 | |
magjed | 1e45cc6 | 2016-10-28 07:43:45 -0700 | [diff] [blame] | 400 | static std::vector<VideoCodec> GetSupportedCodecs( |
| 401 | const WebRtcVideoEncoderFactory* external_encoder_factory); |
| 402 | |
kthelgason | 29a44e3 | 2016-09-27 03:52:02 -0700 | [diff] [blame] | 403 | rtc::scoped_refptr<webrtc::VideoEncoderConfig::EncoderSpecificSettings> |
| 404 | WebRtcVideoChannel2::WebRtcVideoSendStream::ConfigureVideoEncoderSettings( |
Niels Möller | 60653ba | 2016-03-02 11:41:36 +0100 | [diff] [blame] | 405 | const VideoCodec& codec) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 406 | RTC_DCHECK_RUN_ON(&thread_checker_); |
Niels Möller | 60653ba | 2016-03-02 11:41:36 +0100 | [diff] [blame] | 407 | bool is_screencast = parameters_.options.is_screencast.value_or(false); |
Peter Boström | 2feafdb | 2015-09-09 14:32:14 +0200 | [diff] [blame] | 408 | // No automatic resizing when using simulcast or screencast. |
| 409 | bool automatic_resize = |
| 410 | !is_screencast && parameters_.config.rtp.ssrcs.size() == 1; |
Erik Språng | 143cec1 | 2015-04-28 10:01:41 +0200 | [diff] [blame] | 411 | bool frame_dropping = !is_screencast; |
| 412 | bool denoising; |
pbos | 4cba4eb | 2015-10-26 11:18:18 -0700 | [diff] [blame] | 413 | bool codec_default_denoising = false; |
Erik Språng | 143cec1 | 2015-04-28 10:01:41 +0200 | [diff] [blame] | 414 | if (is_screencast) { |
| 415 | denoising = false; |
| 416 | } else { |
pbos | 4cba4eb | 2015-10-26 11:18:18 -0700 | [diff] [blame] | 417 | // Use codec default if video_noise_reduction is unset. |
Niels Möller | 60653ba | 2016-03-02 11:41:36 +0100 | [diff] [blame] | 418 | codec_default_denoising = !parameters_.options.video_noise_reduction; |
| 419 | denoising = parameters_.options.video_noise_reduction.value_or(false); |
Erik Språng | 143cec1 | 2015-04-28 10:01:41 +0200 | [diff] [blame] | 420 | } |
| 421 | |
hbos | bab934b | 2016-01-27 01:36:03 -0800 | [diff] [blame] | 422 | if (CodecNamesEq(codec.name, kH264CodecName)) { |
kthelgason | 29a44e3 | 2016-09-27 03:52:02 -0700 | [diff] [blame] | 423 | webrtc::VideoCodecH264 h264_settings = |
| 424 | webrtc::VideoEncoder::GetDefaultH264Settings(); |
| 425 | h264_settings.frameDroppingOn = frame_dropping; |
| 426 | return new rtc::RefCountedObject< |
| 427 | webrtc::VideoEncoderConfig::H264EncoderSpecificSettings>(h264_settings); |
hbos | bab934b | 2016-01-27 01:36:03 -0800 | [diff] [blame] | 428 | } |
Shao Changbin | e62202f | 2015-04-21 20:24:50 +0800 | [diff] [blame] | 429 | if (CodecNamesEq(codec.name, kVp8CodecName)) { |
kthelgason | 29a44e3 | 2016-09-27 03:52:02 -0700 | [diff] [blame] | 430 | webrtc::VideoCodecVP8 vp8_settings = |
| 431 | webrtc::VideoEncoder::GetDefaultVp8Settings(); |
| 432 | vp8_settings.automaticResizeOn = automatic_resize; |
pbos | 4cba4eb | 2015-10-26 11:18:18 -0700 | [diff] [blame] | 433 | // VP8 denoising is enabled by default. |
kthelgason | 29a44e3 | 2016-09-27 03:52:02 -0700 | [diff] [blame] | 434 | vp8_settings.denoisingOn = codec_default_denoising ? true : denoising; |
| 435 | vp8_settings.frameDroppingOn = frame_dropping; |
| 436 | return new rtc::RefCountedObject< |
| 437 | webrtc::VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8_settings); |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 438 | } |
Shao Changbin | e62202f | 2015-04-21 20:24:50 +0800 | [diff] [blame] | 439 | if (CodecNamesEq(codec.name, kVp9CodecName)) { |
kthelgason | 29a44e3 | 2016-09-27 03:52:02 -0700 | [diff] [blame] | 440 | webrtc::VideoCodecVP9 vp9_settings = |
| 441 | webrtc::VideoEncoder::GetDefaultVp9Settings(); |
asapersson | c5dabdd | 2016-03-21 04:15:50 -0700 | [diff] [blame] | 442 | if (is_screencast) { |
| 443 | // TODO(asapersson): Set to 2 for now since there is a DCHECK in |
| 444 | // VideoSendStream::ReconfigureVideoEncoder. |
kthelgason | 29a44e3 | 2016-09-27 03:52:02 -0700 | [diff] [blame] | 445 | vp9_settings.numberOfSpatialLayers = 2; |
asapersson | c5dabdd | 2016-03-21 04:15:50 -0700 | [diff] [blame] | 446 | } else { |
kthelgason | 29a44e3 | 2016-09-27 03:52:02 -0700 | [diff] [blame] | 447 | vp9_settings.numberOfSpatialLayers = GetDefaultVp9SpatialLayers(); |
asapersson | c5dabdd | 2016-03-21 04:15:50 -0700 | [diff] [blame] | 448 | } |
pbos | 4cba4eb | 2015-10-26 11:18:18 -0700 | [diff] [blame] | 449 | // VP9 denoising is disabled by default. |
kthelgason | 29a44e3 | 2016-09-27 03:52:02 -0700 | [diff] [blame] | 450 | vp9_settings.denoisingOn = codec_default_denoising ? false : denoising; |
| 451 | vp9_settings.frameDroppingOn = frame_dropping; |
| 452 | return new rtc::RefCountedObject< |
| 453 | webrtc::VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings); |
andresp@webrtc.org | 188d3b2 | 2014-11-07 13:21:04 +0000 | [diff] [blame] | 454 | } |
kthelgason | 29a44e3 | 2016-09-27 03:52:02 -0700 | [diff] [blame] | 455 | return nullptr; |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 456 | } |
| 457 | |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 458 | DefaultUnsignalledSsrcHandler::DefaultUnsignalledSsrcHandler() |
nisse | 08582ff | 2016-02-04 01:24:52 -0800 | [diff] [blame] | 459 | : default_recv_ssrc_(0), default_sink_(NULL) {} |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 460 | |
| 461 | UnsignalledSsrcHandler::Action DefaultUnsignalledSsrcHandler::OnUnsignalledSsrc( |
pbos@webrtc.org | a2a6fe6 | 2015-03-06 15:35:19 +0000 | [diff] [blame] | 462 | WebRtcVideoChannel2* channel, |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 463 | uint32_t ssrc) { |
| 464 | if (default_recv_ssrc_ != 0) { // Already one default stream. |
| 465 | LOG(LS_WARNING) << "Unknown SSRC, but default receive stream already set."; |
| 466 | return kDropPacket; |
| 467 | } |
| 468 | |
| 469 | StreamParams sp; |
| 470 | sp.ssrcs.push_back(ssrc); |
| 471 | LOG(LS_INFO) << "Creating default receive stream for SSRC=" << ssrc << "."; |
pbos@webrtc.org | a2a6fe6 | 2015-03-06 15:35:19 +0000 | [diff] [blame] | 472 | if (!channel->AddRecvStream(sp, true)) { |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 473 | LOG(LS_WARNING) << "Could not create default receive stream."; |
| 474 | } |
| 475 | |
nisse | 08582ff | 2016-02-04 01:24:52 -0800 | [diff] [blame] | 476 | channel->SetSink(ssrc, default_sink_); |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 477 | default_recv_ssrc_ = ssrc; |
| 478 | return kDeliverPacket; |
| 479 | } |
| 480 | |
nisse | acd935b | 2016-11-11 03:55:13 -0800 | [diff] [blame] | 481 | rtc::VideoSinkInterface<webrtc::VideoFrame>* |
nisse | 08582ff | 2016-02-04 01:24:52 -0800 | [diff] [blame] | 482 | DefaultUnsignalledSsrcHandler::GetDefaultSink() const { |
| 483 | return default_sink_; |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 484 | } |
| 485 | |
nisse | 08582ff | 2016-02-04 01:24:52 -0800 | [diff] [blame] | 486 | void DefaultUnsignalledSsrcHandler::SetDefaultSink( |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 487 | VideoMediaChannel* channel, |
nisse | acd935b | 2016-11-11 03:55:13 -0800 | [diff] [blame] | 488 | rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) { |
nisse | 08582ff | 2016-02-04 01:24:52 -0800 | [diff] [blame] | 489 | default_sink_ = sink; |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 490 | if (default_recv_ssrc_ != 0) { |
nisse | 08582ff | 2016-02-04 01:24:52 -0800 | [diff] [blame] | 491 | channel->SetSink(default_recv_ssrc_, default_sink_); |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 492 | } |
| 493 | } |
| 494 | |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 495 | WebRtcVideoEngine2::WebRtcVideoEngine2() |
| 496 | : initialized_(false), |
pbos@webrtc.org | 0a2087a | 2014-09-23 09:40:22 +0000 | [diff] [blame] | 497 | external_decoder_factory_(NULL), |
| 498 | external_encoder_factory_(NULL) { |
pbos@webrtc.org | b648b9d | 2014-08-26 11:08:06 +0000 | [diff] [blame] | 499 | LOG(LS_INFO) << "WebRtcVideoEngine2::WebRtcVideoEngine2()"; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 500 | } |
| 501 | |
| 502 | WebRtcVideoEngine2::~WebRtcVideoEngine2() { |
| 503 | LOG(LS_INFO) << "WebRtcVideoEngine2::~WebRtcVideoEngine2"; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 504 | } |
| 505 | |
Fredrik Solenberg | 9a416bd | 2015-05-22 09:04:09 +0200 | [diff] [blame] | 506 | void WebRtcVideoEngine2::Init() { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 507 | LOG(LS_INFO) << "WebRtcVideoEngine2::Init"; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 508 | initialized_ = true; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 509 | } |
| 510 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 511 | WebRtcVideoChannel2* WebRtcVideoEngine2::CreateChannel( |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 512 | webrtc::Call* call, |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 513 | const MediaConfig& config, |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 514 | const VideoOptions& options) { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 515 | RTC_DCHECK(initialized_); |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 516 | LOG(LS_INFO) << "CreateChannel. Options: " << options.ToString(); |
magjed | 23b7a4a | 2016-11-08 01:12:54 -0800 | [diff] [blame] | 517 | return new WebRtcVideoChannel2(call, config, options, |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 518 | external_encoder_factory_, |
| 519 | external_decoder_factory_); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 520 | } |
| 521 | |
brandtr | ffc6118 | 2016-11-28 06:02:22 -0800 | [diff] [blame] | 522 | std::vector<VideoCodec> WebRtcVideoEngine2::codecs() const { |
| 523 | return GetSupportedCodecs(external_encoder_factory_); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 524 | } |
| 525 | |
Stefan Holmer | 9d69c3f | 2015-12-07 10:45:43 +0100 | [diff] [blame] | 526 | RtpCapabilities WebRtcVideoEngine2::GetCapabilities() const { |
| 527 | RtpCapabilities capabilities; |
| 528 | capabilities.header_extensions.push_back( |
isheriff | 6f8d686 | 2016-05-26 11:24:55 -0700 | [diff] [blame] | 529 | webrtc::RtpExtension(webrtc::RtpExtension::kTimestampOffsetUri, |
| 530 | webrtc::RtpExtension::kTimestampOffsetDefaultId)); |
Stefan Holmer | 9d69c3f | 2015-12-07 10:45:43 +0100 | [diff] [blame] | 531 | capabilities.header_extensions.push_back( |
isheriff | 6f8d686 | 2016-05-26 11:24:55 -0700 | [diff] [blame] | 532 | webrtc::RtpExtension(webrtc::RtpExtension::kAbsSendTimeUri, |
| 533 | webrtc::RtpExtension::kAbsSendTimeDefaultId)); |
Stefan Holmer | 9d69c3f | 2015-12-07 10:45:43 +0100 | [diff] [blame] | 534 | capabilities.header_extensions.push_back( |
isheriff | 6f8d686 | 2016-05-26 11:24:55 -0700 | [diff] [blame] | 535 | webrtc::RtpExtension(webrtc::RtpExtension::kVideoRotationUri, |
| 536 | webrtc::RtpExtension::kVideoRotationDefaultId)); |
Stefan Holmer | 06a5e1a | 2016-09-02 12:36:49 +0200 | [diff] [blame] | 537 | capabilities.header_extensions.push_back(webrtc::RtpExtension( |
| 538 | webrtc::RtpExtension::kTransportSequenceNumberUri, |
| 539 | webrtc::RtpExtension::kTransportSequenceNumberDefaultId)); |
isheriff | 6b4b5f3 | 2016-06-08 00:24:21 -0700 | [diff] [blame] | 540 | capabilities.header_extensions.push_back( |
| 541 | webrtc::RtpExtension(webrtc::RtpExtension::kPlayoutDelayUri, |
| 542 | webrtc::RtpExtension::kPlayoutDelayDefaultId)); |
Stefan Holmer | 9d69c3f | 2015-12-07 10:45:43 +0100 | [diff] [blame] | 543 | return capabilities; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 544 | } |
| 545 | |
pbos@webrtc.org | 0a2087a | 2014-09-23 09:40:22 +0000 | [diff] [blame] | 546 | void WebRtcVideoEngine2::SetExternalDecoderFactory( |
| 547 | WebRtcVideoDecoderFactory* decoder_factory) { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 548 | RTC_DCHECK(!initialized_); |
pbos@webrtc.org | 0a2087a | 2014-09-23 09:40:22 +0000 | [diff] [blame] | 549 | external_decoder_factory_ = decoder_factory; |
| 550 | } |
| 551 | |
| 552 | void WebRtcVideoEngine2::SetExternalEncoderFactory( |
| 553 | WebRtcVideoEncoderFactory* encoder_factory) { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 554 | RTC_DCHECK(!initialized_); |
pbos@webrtc.org | f18fba2 | 2015-01-14 16:26:23 +0000 | [diff] [blame] | 555 | if (external_encoder_factory_ == encoder_factory) |
| 556 | return; |
| 557 | |
| 558 | // No matter what happens we shouldn't hold on to a stale |
| 559 | // WebRtcSimulcastEncoderFactory. |
| 560 | simulcast_encoder_factory_.reset(); |
| 561 | |
| 562 | if (encoder_factory && |
| 563 | WebRtcSimulcastEncoderFactory::UseSimulcastEncoderFactory( |
magjed | 1e45cc6 | 2016-10-28 07:43:45 -0700 | [diff] [blame] | 564 | encoder_factory->supported_codecs())) { |
pbos@webrtc.org | f18fba2 | 2015-01-14 16:26:23 +0000 | [diff] [blame] | 565 | simulcast_encoder_factory_.reset( |
| 566 | new WebRtcSimulcastEncoderFactory(encoder_factory)); |
| 567 | encoder_factory = simulcast_encoder_factory_.get(); |
| 568 | } |
pbos@webrtc.org | 0a2087a | 2014-09-23 09:40:22 +0000 | [diff] [blame] | 569 | external_encoder_factory_ = encoder_factory; |
pbos@webrtc.org | 0a2087a | 2014-09-23 09:40:22 +0000 | [diff] [blame] | 570 | } |
| 571 | |
magjed | 509e4fe | 2016-11-18 01:34:11 -0800 | [diff] [blame] | 572 | // This is a helper function for AppendVideoCodecs below. It will return the |
| 573 | // first unused dynamic payload type (in the range [96, 127]), or nothing if no |
| 574 | // payload type is unused. |
| 575 | static rtc::Optional<int> NextFreePayloadType( |
| 576 | const std::vector<VideoCodec>& codecs) { |
| 577 | static const int kFirstDynamicPayloadType = 96; |
| 578 | static const int kLastDynamicPayloadType = 127; |
| 579 | bool is_payload_used[1 + kLastDynamicPayloadType - kFirstDynamicPayloadType] = |
| 580 | {false}; |
| 581 | for (const VideoCodec& codec : codecs) { |
| 582 | if (kFirstDynamicPayloadType <= codec.id && |
| 583 | codec.id <= kLastDynamicPayloadType) { |
| 584 | is_payload_used[codec.id - kFirstDynamicPayloadType] = true; |
magjed | eacbaea | 2016-11-17 08:51:59 -0800 | [diff] [blame] | 585 | } |
magjed | 509e4fe | 2016-11-18 01:34:11 -0800 | [diff] [blame] | 586 | } |
| 587 | for (int i = kFirstDynamicPayloadType; i <= kLastDynamicPayloadType; ++i) { |
| 588 | if (!is_payload_used[i - kFirstDynamicPayloadType]) |
| 589 | return rtc::Optional<int>(i); |
| 590 | } |
| 591 | // No free payload type. |
| 592 | return rtc::Optional<int>(); |
| 593 | } |
| 594 | |
| 595 | // This is a helper function for GetSupportedCodecs below. It will append new |
| 596 | // unique codecs from |input_codecs| to |unified_codecs|. It will add default |
| 597 | // feedback params to the codecs and will also add an associated RTX codec for |
| 598 | // recognized codecs (VP8, VP9, H264, and Red). |
| 599 | static void AppendVideoCodecs(const std::vector<VideoCodec>& input_codecs, |
| 600 | std::vector<VideoCodec>* unified_codecs) { |
| 601 | for (VideoCodec codec : input_codecs) { |
| 602 | const rtc::Optional<int> payload_type = |
| 603 | NextFreePayloadType(*unified_codecs); |
| 604 | if (!payload_type) |
| 605 | return; |
| 606 | codec.id = *payload_type; |
| 607 | // TODO(magjed): Move the responsibility of setting these parameters to the |
| 608 | // encoder factories instead. |
| 609 | if (codec.name != kRedCodecName && codec.name != kUlpfecCodecName) |
| 610 | AddDefaultFeedbackParams(&codec); |
| 611 | // Don't add same codec twice. |
| 612 | if (FindMatchingCodec(*unified_codecs, codec)) |
magjed | eacbaea | 2016-11-17 08:51:59 -0800 | [diff] [blame] | 613 | continue; |
| 614 | |
magjed | 509e4fe | 2016-11-18 01:34:11 -0800 | [diff] [blame] | 615 | unified_codecs->push_back(codec); |
magjed | eacbaea | 2016-11-17 08:51:59 -0800 | [diff] [blame] | 616 | |
magjed | 509e4fe | 2016-11-18 01:34:11 -0800 | [diff] [blame] | 617 | // Add associated RTX codec for recognized codecs. |
| 618 | // TODO(deadbeef): Should we add RTX codecs for external codecs whose names |
| 619 | // we don't recognize? |
| 620 | if (CodecNamesEq(codec.name, kVp8CodecName) || |
| 621 | CodecNamesEq(codec.name, kVp9CodecName) || |
| 622 | CodecNamesEq(codec.name, kH264CodecName) || |
| 623 | CodecNamesEq(codec.name, kRedCodecName)) { |
| 624 | const rtc::Optional<int> rtx_payload_type = |
| 625 | NextFreePayloadType(*unified_codecs); |
| 626 | if (!rtx_payload_type) |
| 627 | return; |
| 628 | unified_codecs->push_back( |
| 629 | VideoCodec::CreateRtxCodec(*rtx_payload_type, codec.id)); |
| 630 | } |
magjed | eacbaea | 2016-11-17 08:51:59 -0800 | [diff] [blame] | 631 | } |
magjed | 509e4fe | 2016-11-18 01:34:11 -0800 | [diff] [blame] | 632 | } |
| 633 | |
| 634 | static std::vector<VideoCodec> GetSupportedCodecs( |
| 635 | const WebRtcVideoEncoderFactory* external_encoder_factory) { |
| 636 | const std::vector<VideoCodec> internal_codecs = |
| 637 | InternalEncoderFactory().supported_codecs(); |
| 638 | LOG(LS_INFO) << "Internally supported codecs: " |
| 639 | << CodecVectorToString(internal_codecs); |
| 640 | |
| 641 | std::vector<VideoCodec> unified_codecs; |
| 642 | AppendVideoCodecs(internal_codecs, &unified_codecs); |
| 643 | |
| 644 | if (external_encoder_factory != nullptr) { |
| 645 | const std::vector<VideoCodec>& external_codecs = |
| 646 | external_encoder_factory->supported_codecs(); |
| 647 | AppendVideoCodecs(external_codecs, &unified_codecs); |
| 648 | LOG(LS_INFO) << "Codecs supported by the external encoder factory: " |
| 649 | << CodecVectorToString(external_codecs); |
| 650 | } |
| 651 | |
| 652 | return unified_codecs; |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 653 | } |
| 654 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 655 | WebRtcVideoChannel2::WebRtcVideoChannel2( |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 656 | webrtc::Call* call, |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 657 | const MediaConfig& config, |
pbos@webrtc.org | fa553ef | 2014-10-20 11:07:07 +0000 | [diff] [blame] | 658 | const VideoOptions& options, |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 659 | WebRtcVideoEncoderFactory* external_encoder_factory, |
pbos@webrtc.org | f1c8b90 | 2015-01-14 17:29:27 +0000 | [diff] [blame] | 660 | WebRtcVideoDecoderFactory* external_decoder_factory) |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 661 | : VideoMediaChannel(config), |
| 662 | call_(call), |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 663 | unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_), |
nisse | 0db023a | 2016-03-01 04:29:59 -0800 | [diff] [blame] | 664 | video_config_(config.video), |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 665 | external_encoder_factory_(external_encoder_factory), |
nisse | 0510331 | 2016-03-16 02:22:50 -0700 | [diff] [blame] | 666 | external_decoder_factory_(external_decoder_factory), |
Stefan Holmer | 2b1f651 | 2016-05-17 16:33:30 +0200 | [diff] [blame] | 667 | default_send_options_(options), |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 668 | last_stats_log_ms_(-1) { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 669 | RTC_DCHECK(thread_checker_.CalledOnValidThread()); |
nisse | a293ef0 | 2016-02-17 07:24:50 -0800 | [diff] [blame] | 670 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 671 | rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc; |
| 672 | sending_ = false; |
magjed | 23b7a4a | 2016-11-08 01:12:54 -0800 | [diff] [blame] | 673 | recv_codecs_ = MapCodecs(GetSupportedCodecs(external_encoder_factory)); |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 674 | } |
| 675 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 676 | WebRtcVideoChannel2::~WebRtcVideoChannel2() { |
Peter Boström | dfd53fe | 2015-03-27 15:58:11 +0100 | [diff] [blame] | 677 | for (auto& kv : send_streams_) |
| 678 | delete kv.second; |
| 679 | for (auto& kv : receive_streams_) |
| 680 | delete kv.second; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 681 | } |
| 682 | |
magjed | 23b7a4a | 2016-11-08 01:12:54 -0800 | [diff] [blame] | 683 | rtc::Optional<WebRtcVideoChannel2::VideoCodecSettings> |
| 684 | WebRtcVideoChannel2::SelectSendVideoCodec( |
| 685 | const std::vector<VideoCodecSettings>& remote_mapped_codecs) const { |
| 686 | const std::vector<VideoCodec> local_supported_codecs = |
magjed | 1e45cc6 | 2016-10-28 07:43:45 -0700 | [diff] [blame] | 687 | GetSupportedCodecs(external_encoder_factory_); |
magjed | 23b7a4a | 2016-11-08 01:12:54 -0800 | [diff] [blame] | 688 | // Select the first remote codec that is supported locally. |
| 689 | for (const VideoCodecSettings& remote_mapped_codec : remote_mapped_codecs) { |
magjed | f823ede | 2016-11-12 09:53:04 -0800 | [diff] [blame] | 690 | // For H264, we will limit the encode level to the remote offered level |
| 691 | // regardless if level asymmetry is allowed or not. This is strictly not |
| 692 | // following the spec in https://tools.ietf.org/html/rfc6184#section-8.2.2 |
| 693 | // since we should limit the encode level to the lower of local and remote |
| 694 | // level when level asymmetry is not allowed. |
| 695 | if (FindMatchingCodec(local_supported_codecs, remote_mapped_codec.codec)) |
magjed | 23b7a4a | 2016-11-08 01:12:54 -0800 | [diff] [blame] | 696 | return rtc::Optional<VideoCodecSettings>(remote_mapped_codec); |
pbos@webrtc.org | 96a9325 | 2014-11-03 14:46:44 +0000 | [diff] [blame] | 697 | } |
magjed | 23b7a4a | 2016-11-08 01:12:54 -0800 | [diff] [blame] | 698 | // No remote codec was supported. |
| 699 | return rtc::Optional<VideoCodecSettings>(); |
pbos@webrtc.org | 96a9325 | 2014-11-03 14:46:44 +0000 | [diff] [blame] | 700 | } |
| 701 | |
deadbeef | 874ca3a | 2015-08-20 17:19:20 -0700 | [diff] [blame] | 702 | bool WebRtcVideoChannel2::ReceiveCodecsHaveChanged( |
| 703 | std::vector<VideoCodecSettings> before, |
| 704 | std::vector<VideoCodecSettings> after) { |
| 705 | if (before.size() != after.size()) { |
| 706 | return true; |
| 707 | } |
| 708 | // The receive codec order doesn't matter, so we sort the codecs before |
| 709 | // comparing. This is necessary because currently the |
| 710 | // only way to change the send codec is to munge SDP, which causes |
| 711 | // the receive codec list to change order, which causes the streams |
| 712 | // to be recreates which causes a "blink" of black video. In order |
| 713 | // to support munging the SDP in this way without recreating receive |
| 714 | // streams, we ignore the order of the received codecs so that |
| 715 | // changing the order doesn't cause this "blink". |
| 716 | auto comparison = |
| 717 | [](const VideoCodecSettings& codec1, const VideoCodecSettings& codec2) { |
| 718 | return codec1.codec.id > codec2.codec.id; |
| 719 | }; |
| 720 | std::sort(before.begin(), before.end(), comparison); |
| 721 | std::sort(after.begin(), after.end(), comparison); |
deadbeef | 67cf2c1 | 2016-04-13 10:07:16 -0700 | [diff] [blame] | 722 | return before != after; |
deadbeef | 874ca3a | 2015-08-20 17:19:20 -0700 | [diff] [blame] | 723 | } |
| 724 | |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 725 | bool WebRtcVideoChannel2::GetChangedSendParameters( |
| 726 | const VideoSendParameters& params, |
| 727 | ChangedSendParameters* changed_params) const { |
| 728 | if (!ValidateCodecFormats(params.codecs) || |
| 729 | !ValidateRtpExtensions(params.extensions)) { |
| 730 | return false; |
| 731 | } |
| 732 | |
magjed | 23b7a4a | 2016-11-08 01:12:54 -0800 | [diff] [blame] | 733 | // Select one of the remote codecs that will be used as send codec. |
| 734 | const rtc::Optional<VideoCodecSettings> selected_send_codec = |
| 735 | SelectSendVideoCodec(MapCodecs(params.codecs)); |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 736 | |
magjed | 23b7a4a | 2016-11-08 01:12:54 -0800 | [diff] [blame] | 737 | if (!selected_send_codec) { |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 738 | LOG(LS_ERROR) << "No video codecs supported."; |
| 739 | return false; |
| 740 | } |
| 741 | |
magjed | 23b7a4a | 2016-11-08 01:12:54 -0800 | [diff] [blame] | 742 | if (!send_codec_ || *selected_send_codec != *send_codec_) |
| 743 | changed_params->codec = selected_send_codec; |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 744 | |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 745 | // Handle RTP header extensions. |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 746 | std::vector<webrtc::RtpExtension> filtered_extensions = FilterRtpExtensions( |
| 747 | params.extensions, webrtc::RtpExtension::IsSupportedForVideo, true); |
skvlad | 3abb764 | 2016-06-16 12:08:03 -0700 | [diff] [blame] | 748 | if (!send_rtp_extensions_ || (*send_rtp_extensions_ != filtered_extensions)) { |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 749 | changed_params->rtp_header_extensions = |
| 750 | rtc::Optional<std::vector<webrtc::RtpExtension>>(filtered_extensions); |
| 751 | } |
| 752 | |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 753 | // Handle max bitrate. |
Taylor Brandstetter | 58f2bd9 | 2016-04-26 17:15:23 -0700 | [diff] [blame] | 754 | if (params.max_bandwidth_bps != send_params_.max_bandwidth_bps && |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 755 | params.max_bandwidth_bps >= 0) { |
| 756 | // 0 uncaps max bitrate (-1). |
| 757 | changed_params->max_bandwidth_bps = rtc::Optional<int>( |
| 758 | params.max_bandwidth_bps == 0 ? -1 : params.max_bandwidth_bps); |
| 759 | } |
| 760 | |
nisse | 4b4dc86 | 2016-02-17 05:25:36 -0800 | [diff] [blame] | 761 | // Handle conference mode. |
| 762 | if (params.conference_mode != send_params_.conference_mode) { |
| 763 | changed_params->conference_mode = |
| 764 | rtc::Optional<bool>(params.conference_mode); |
| 765 | } |
| 766 | |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 767 | // Handle RTCP mode. |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 768 | if (params.rtcp.reduced_size != send_params_.rtcp.reduced_size) { |
| 769 | changed_params->rtcp_mode = rtc::Optional<webrtc::RtcpMode>( |
| 770 | params.rtcp.reduced_size ? webrtc::RtcpMode::kReducedSize |
| 771 | : webrtc::RtcpMode::kCompound); |
| 772 | } |
| 773 | |
| 774 | return true; |
| 775 | } |
| 776 | |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 777 | rtc::DiffServCodePoint WebRtcVideoChannel2::PreferredDscp() const { |
| 778 | return rtc::DSCP_AF41; |
| 779 | } |
| 780 | |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 781 | bool WebRtcVideoChannel2::SetSendParameters(const VideoSendParameters& params) { |
Peter Boström | 9f45a45 | 2015-12-08 13:25:57 +0100 | [diff] [blame] | 782 | TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetSendParameters"); |
solenberg | 7e4e01a | 2015-12-02 08:05:01 -0800 | [diff] [blame] | 783 | LOG(LS_INFO) << "SetSendParameters: " << params.ToString(); |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 784 | ChangedSendParameters changed_params; |
| 785 | if (!GetChangedSendParameters(params, &changed_params)) { |
deadbeef | 1387149 | 2015-12-09 12:37:51 -0800 | [diff] [blame] | 786 | return false; |
| 787 | } |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 788 | |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 789 | if (changed_params.codec) { |
| 790 | const VideoCodecSettings& codec_settings = *changed_params.codec; |
| 791 | send_codec_ = rtc::Optional<VideoCodecSettings>(codec_settings); |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 792 | LOG(LS_INFO) << "Using codec: " << codec_settings.codec.ToString(); |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 793 | } |
| 794 | |
| 795 | if (changed_params.rtp_header_extensions) { |
skvlad | 3abb764 | 2016-06-16 12:08:03 -0700 | [diff] [blame] | 796 | send_rtp_extensions_ = changed_params.rtp_header_extensions; |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 797 | } |
| 798 | |
Taylor Brandstetter | 58f2bd9 | 2016-04-26 17:15:23 -0700 | [diff] [blame] | 799 | if (changed_params.codec || changed_params.max_bandwidth_bps) { |
| 800 | if (send_codec_) { |
| 801 | // TODO(holmer): Changing the codec parameters shouldn't necessarily mean |
| 802 | // that we change the min/max of bandwidth estimation. Reevaluate this. |
| 803 | bitrate_config_ = GetBitrateConfigForCodec(send_codec_->codec); |
| 804 | if (!changed_params.codec) { |
| 805 | // If the codec isn't changing, set the start bitrate to -1 which means |
| 806 | // "unchanged" so that BWE isn't affected. |
| 807 | bitrate_config_.start_bitrate_bps = -1; |
| 808 | } |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 809 | } |
Taylor Brandstetter | 58f2bd9 | 2016-04-26 17:15:23 -0700 | [diff] [blame] | 810 | if (params.max_bandwidth_bps >= 0) { |
| 811 | // Note that max_bandwidth_bps intentionally takes priority over the |
| 812 | // bitrate config for the codec. This allows FEC to be applied above the |
| 813 | // codec target bitrate. |
| 814 | // TODO(pbos): Figure out whether b=AS means max bitrate for this |
| 815 | // WebRtcVideoChannel2 (in which case we're good), or per sender (SSRC), |
| 816 | // in which case this should not set a Call::BitrateConfig but rather |
| 817 | // reconfigure all senders. |
| 818 | bitrate_config_.max_bitrate_bps = |
| 819 | params.max_bandwidth_bps == 0 ? -1 : params.max_bandwidth_bps; |
| 820 | } |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 821 | call_->SetBitrateConfig(bitrate_config_); |
| 822 | } |
| 823 | |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 824 | { |
deadbeef | 1387149 | 2015-12-09 12:37:51 -0800 | [diff] [blame] | 825 | rtc::CritScope stream_lock(&stream_crit_); |
| 826 | for (auto& kv : send_streams_) { |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 827 | kv.second->SetSendParameters(changed_params); |
| 828 | } |
Taylor Brandstetter | 5f0b83b | 2016-03-18 15:02:07 -0700 | [diff] [blame] | 829 | if (changed_params.codec || changed_params.rtcp_mode) { |
| 830 | // Update receive feedback parameters from new codec or RTCP mode. |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 831 | LOG(LS_INFO) |
| 832 | << "SetFeedbackOptions on all the receive streams because the send " |
Taylor Brandstetter | 5f0b83b | 2016-03-18 15:02:07 -0700 | [diff] [blame] | 833 | "codec or RTCP mode has changed."; |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 834 | for (auto& kv : receive_streams_) { |
| 835 | RTC_DCHECK(kv.second != nullptr); |
Taylor Brandstetter | 5f0b83b | 2016-03-18 15:02:07 -0700 | [diff] [blame] | 836 | kv.second->SetFeedbackParameters( |
| 837 | HasNack(send_codec_->codec), HasRemb(send_codec_->codec), |
| 838 | HasTransportCc(send_codec_->codec), |
| 839 | params.rtcp.reduced_size ? webrtc::RtcpMode::kReducedSize |
| 840 | : webrtc::RtcpMode::kCompound); |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 841 | } |
deadbeef | 1387149 | 2015-12-09 12:37:51 -0800 | [diff] [blame] | 842 | } |
| 843 | } |
| 844 | send_params_ = params; |
| 845 | return true; |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 846 | } |
Taylor Brandstetter | 0cd086b | 2016-04-20 16:23:10 -0700 | [diff] [blame] | 847 | |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 848 | webrtc::RtpParameters WebRtcVideoChannel2::GetRtpSendParameters( |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 849 | uint32_t ssrc) const { |
| 850 | rtc::CritScope stream_lock(&stream_crit_); |
| 851 | auto it = send_streams_.find(ssrc); |
| 852 | if (it == send_streams_.end()) { |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 853 | LOG(LS_WARNING) << "Attempting to get RTP send parameters for stream " |
| 854 | << "with ssrc " << ssrc << " which doesn't exist."; |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 855 | return webrtc::RtpParameters(); |
| 856 | } |
| 857 | |
Taylor Brandstetter | 0cd086b | 2016-04-20 16:23:10 -0700 | [diff] [blame] | 858 | webrtc::RtpParameters rtp_params = it->second->GetRtpParameters(); |
| 859 | // Need to add the common list of codecs to the send stream-specific |
| 860 | // RTP parameters. |
| 861 | for (const VideoCodec& codec : send_params_.codecs) { |
| 862 | rtp_params.codecs.push_back(codec.ToCodecParameters()); |
| 863 | } |
| 864 | return rtp_params; |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 865 | } |
| 866 | |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 867 | bool WebRtcVideoChannel2::SetRtpSendParameters( |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 868 | uint32_t ssrc, |
| 869 | const webrtc::RtpParameters& parameters) { |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 870 | TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRtpSendParameters"); |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 871 | rtc::CritScope stream_lock(&stream_crit_); |
| 872 | auto it = send_streams_.find(ssrc); |
| 873 | if (it == send_streams_.end()) { |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 874 | LOG(LS_ERROR) << "Attempting to set RTP send parameters for stream " |
| 875 | << "with ssrc " << ssrc << " which doesn't exist."; |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 876 | return false; |
| 877 | } |
| 878 | |
Taylor Brandstetter | 0cd086b | 2016-04-20 16:23:10 -0700 | [diff] [blame] | 879 | // TODO(deadbeef): Handle setting parameters with a list of codecs in a |
| 880 | // different order (which should change the send codec). |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 881 | webrtc::RtpParameters current_parameters = GetRtpSendParameters(ssrc); |
| 882 | if (current_parameters.codecs != parameters.codecs) { |
| 883 | LOG(LS_ERROR) << "Using SetParameters to change the set of codecs " |
| 884 | << "is not currently supported."; |
| 885 | return false; |
| 886 | } |
| 887 | |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 888 | return it->second->SetRtpParameters(parameters); |
| 889 | } |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 890 | |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 891 | webrtc::RtpParameters WebRtcVideoChannel2::GetRtpReceiveParameters( |
| 892 | uint32_t ssrc) const { |
| 893 | rtc::CritScope stream_lock(&stream_crit_); |
| 894 | auto it = receive_streams_.find(ssrc); |
| 895 | if (it == receive_streams_.end()) { |
| 896 | LOG(LS_WARNING) << "Attempting to get RTP receive parameters for stream " |
| 897 | << "with ssrc " << ssrc << " which doesn't exist."; |
| 898 | return webrtc::RtpParameters(); |
| 899 | } |
| 900 | |
| 901 | // TODO(deadbeef): Return stream-specific parameters. |
| 902 | webrtc::RtpParameters rtp_params = CreateRtpParametersWithOneEncoding(); |
| 903 | for (const VideoCodec& codec : recv_params_.codecs) { |
| 904 | rtp_params.codecs.push_back(codec.ToCodecParameters()); |
| 905 | } |
sakal | 1fd9595 | 2016-06-22 00:46:15 -0700 | [diff] [blame] | 906 | rtp_params.encodings[0].ssrc = it->second->GetFirstPrimarySsrc(); |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 907 | return rtp_params; |
| 908 | } |
| 909 | |
| 910 | bool WebRtcVideoChannel2::SetRtpReceiveParameters( |
| 911 | uint32_t ssrc, |
| 912 | const webrtc::RtpParameters& parameters) { |
| 913 | TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRtpReceiveParameters"); |
| 914 | rtc::CritScope stream_lock(&stream_crit_); |
| 915 | auto it = receive_streams_.find(ssrc); |
| 916 | if (it == receive_streams_.end()) { |
| 917 | LOG(LS_ERROR) << "Attempting to set RTP receive parameters for stream " |
| 918 | << "with ssrc " << ssrc << " which doesn't exist."; |
| 919 | return false; |
| 920 | } |
| 921 | |
| 922 | webrtc::RtpParameters current_parameters = GetRtpReceiveParameters(ssrc); |
| 923 | if (current_parameters != parameters) { |
| 924 | LOG(LS_ERROR) << "Changing the RTP receive parameters is currently " |
| 925 | << "unsupported."; |
| 926 | return false; |
| 927 | } |
| 928 | return true; |
| 929 | } |
| 930 | |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 931 | bool WebRtcVideoChannel2::GetChangedRecvParameters( |
| 932 | const VideoRecvParameters& params, |
| 933 | ChangedRecvParameters* changed_params) const { |
| 934 | if (!ValidateCodecFormats(params.codecs) || |
| 935 | !ValidateRtpExtensions(params.extensions)) { |
| 936 | return false; |
| 937 | } |
| 938 | |
| 939 | // Handle receive codecs. |
| 940 | const std::vector<VideoCodecSettings> mapped_codecs = |
| 941 | MapCodecs(params.codecs); |
| 942 | if (mapped_codecs.empty()) { |
| 943 | LOG(LS_ERROR) << "SetRecvParameters called without any video codecs."; |
| 944 | return false; |
| 945 | } |
| 946 | |
magjed | 23b7a4a | 2016-11-08 01:12:54 -0800 | [diff] [blame] | 947 | // Verify that every mapped codec is supported locally. |
| 948 | const std::vector<VideoCodec> local_supported_codecs = |
| 949 | GetSupportedCodecs(external_encoder_factory_); |
| 950 | for (const VideoCodecSettings& mapped_codec : mapped_codecs) { |
magjed | f823ede | 2016-11-12 09:53:04 -0800 | [diff] [blame] | 951 | if (!FindMatchingCodec(local_supported_codecs, mapped_codec.codec)) { |
magjed | 23b7a4a | 2016-11-08 01:12:54 -0800 | [diff] [blame] | 952 | LOG(LS_ERROR) << "SetRecvParameters called with unsupported video codec: " |
| 953 | << mapped_codec.codec.ToString(); |
| 954 | return false; |
| 955 | } |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 956 | } |
| 957 | |
magjed | 23b7a4a | 2016-11-08 01:12:54 -0800 | [diff] [blame] | 958 | if (ReceiveCodecsHaveChanged(recv_codecs_, mapped_codecs)) { |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 959 | changed_params->codec_settings = |
magjed | 23b7a4a | 2016-11-08 01:12:54 -0800 | [diff] [blame] | 960 | rtc::Optional<std::vector<VideoCodecSettings>>(mapped_codecs); |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 961 | } |
| 962 | |
| 963 | // Handle RTP header extensions. |
| 964 | std::vector<webrtc::RtpExtension> filtered_extensions = FilterRtpExtensions( |
| 965 | params.extensions, webrtc::RtpExtension::IsSupportedForVideo, false); |
| 966 | if (filtered_extensions != recv_rtp_extensions_) { |
| 967 | changed_params->rtp_header_extensions = |
| 968 | rtc::Optional<std::vector<webrtc::RtpExtension>>(filtered_extensions); |
| 969 | } |
| 970 | |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 971 | return true; |
| 972 | } |
| 973 | |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 974 | bool WebRtcVideoChannel2::SetRecvParameters(const VideoRecvParameters& params) { |
Peter Boström | 9f45a45 | 2015-12-08 13:25:57 +0100 | [diff] [blame] | 975 | TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRecvParameters"); |
solenberg | 7e4e01a | 2015-12-02 08:05:01 -0800 | [diff] [blame] | 976 | LOG(LS_INFO) << "SetRecvParameters: " << params.ToString(); |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 977 | ChangedRecvParameters changed_params; |
| 978 | if (!GetChangedRecvParameters(params, &changed_params)) { |
deadbeef | 1387149 | 2015-12-09 12:37:51 -0800 | [diff] [blame] | 979 | return false; |
| 980 | } |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 981 | if (changed_params.rtp_header_extensions) { |
| 982 | recv_rtp_extensions_ = *changed_params.rtp_header_extensions; |
| 983 | } |
| 984 | if (changed_params.codec_settings) { |
| 985 | LOG(LS_INFO) << "Changing recv codecs from " |
| 986 | << CodecSettingsVectorToString(recv_codecs_) << " to " |
| 987 | << CodecSettingsVectorToString(*changed_params.codec_settings); |
| 988 | recv_codecs_ = *changed_params.codec_settings; |
| 989 | } |
| 990 | |
| 991 | { |
deadbeef | 1387149 | 2015-12-09 12:37:51 -0800 | [diff] [blame] | 992 | rtc::CritScope stream_lock(&stream_crit_); |
| 993 | for (auto& kv : receive_streams_) { |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 994 | kv.second->SetRecvParameters(changed_params); |
deadbeef | 1387149 | 2015-12-09 12:37:51 -0800 | [diff] [blame] | 995 | } |
| 996 | } |
| 997 | recv_params_ = params; |
| 998 | return true; |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 999 | } |
| 1000 | |
deadbeef | 874ca3a | 2015-08-20 17:19:20 -0700 | [diff] [blame] | 1001 | std::string WebRtcVideoChannel2::CodecSettingsVectorToString( |
| 1002 | const std::vector<VideoCodecSettings>& codecs) { |
| 1003 | std::stringstream out; |
| 1004 | out << '{'; |
| 1005 | for (size_t i = 0; i < codecs.size(); ++i) { |
| 1006 | out << codecs[i].codec.ToString(); |
| 1007 | if (i != codecs.size() - 1) { |
| 1008 | out << ", "; |
| 1009 | } |
| 1010 | } |
| 1011 | out << '}'; |
| 1012 | return out.str(); |
| 1013 | } |
| 1014 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1015 | bool WebRtcVideoChannel2::GetSendCodec(VideoCodec* codec) { |
kwiberg | 102c6a6 | 2015-10-30 02:47:38 -0700 | [diff] [blame] | 1016 | if (!send_codec_) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1017 | LOG(LS_VERBOSE) << "GetSendCodec: No send codec set."; |
| 1018 | return false; |
| 1019 | } |
kwiberg | 102c6a6 | 2015-10-30 02:47:38 -0700 | [diff] [blame] | 1020 | *codec = send_codec_->codec; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1021 | return true; |
| 1022 | } |
| 1023 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1024 | bool WebRtcVideoChannel2::SetSend(bool send) { |
Peter Boström | dabc944 | 2016-04-11 11:45:14 +0200 | [diff] [blame] | 1025 | TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetSend"); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1026 | LOG(LS_VERBOSE) << "SetSend: " << (send ? "true" : "false"); |
kwiberg | 102c6a6 | 2015-10-30 02:47:38 -0700 | [diff] [blame] | 1027 | if (send && !send_codec_) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1028 | LOG(LS_ERROR) << "SetSend(true) called before setting codec."; |
| 1029 | return false; |
| 1030 | } |
deadbeef | dbe2b87 | 2016-03-22 15:42:00 -0700 | [diff] [blame] | 1031 | { |
| 1032 | rtc::CritScope stream_lock(&stream_crit_); |
| 1033 | for (const auto& kv : send_streams_) { |
| 1034 | kv.second->SetSend(send); |
| 1035 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1036 | } |
| 1037 | sending_ = send; |
| 1038 | return true; |
| 1039 | } |
| 1040 | |
nisse | 2ded9b1 | 2016-04-08 02:23:55 -0700 | [diff] [blame] | 1041 | // TODO(nisse): The enable argument was used for mute logic which has |
deadbeef | 5a4a75a | 2016-06-02 16:23:38 -0700 | [diff] [blame] | 1042 | // been moved to VideoBroadcaster. So remove the argument from this |
| 1043 | // method. |
| 1044 | bool WebRtcVideoChannel2::SetVideoSend( |
| 1045 | uint32_t ssrc, |
| 1046 | bool enable, |
| 1047 | const VideoOptions* options, |
nisse | acd935b | 2016-11-11 03:55:13 -0800 | [diff] [blame] | 1048 | rtc::VideoSourceInterface<webrtc::VideoFrame>* source) { |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 1049 | TRACE_EVENT0("webrtc", "SetVideoSend"); |
deadbeef | 5a4a75a | 2016-06-02 16:23:38 -0700 | [diff] [blame] | 1050 | RTC_DCHECK(ssrc != 0); |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 1051 | LOG(LS_INFO) << "SetVideoSend (ssrc= " << ssrc << ", enable = " << enable |
deadbeef | 5a4a75a | 2016-06-02 16:23:38 -0700 | [diff] [blame] | 1052 | << ", options: " << (options ? options->ToString() : "nullptr") |
| 1053 | << ", source = " << (source ? "(source)" : "nullptr") << ")"; |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 1054 | |
deadbeef | 5a4a75a | 2016-06-02 16:23:38 -0700 | [diff] [blame] | 1055 | rtc::CritScope stream_lock(&stream_crit_); |
| 1056 | const auto& kv = send_streams_.find(ssrc); |
| 1057 | if (kv == send_streams_.end()) { |
| 1058 | // Allow unknown ssrc only if source is null. |
| 1059 | RTC_CHECK(source == nullptr); |
| 1060 | LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc; |
| 1061 | return false; |
solenberg | 1dd98f3 | 2015-09-10 01:57:14 -0700 | [diff] [blame] | 1062 | } |
deadbeef | 5a4a75a | 2016-06-02 16:23:38 -0700 | [diff] [blame] | 1063 | |
| 1064 | return kv->second->SetVideoSend(enable, options, source); |
solenberg | 1dd98f3 | 2015-09-10 01:57:14 -0700 | [diff] [blame] | 1065 | } |
| 1066 | |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1067 | bool WebRtcVideoChannel2::ValidateSendSsrcAvailability( |
| 1068 | const StreamParams& sp) const { |
Per | a509241 | 2016-02-12 13:30:57 +0100 | [diff] [blame] | 1069 | for (uint32_t ssrc : sp.ssrcs) { |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1070 | if (send_ssrcs_.find(ssrc) != send_ssrcs_.end()) { |
| 1071 | LOG(LS_ERROR) << "Send stream with SSRC '" << ssrc << "' already exists."; |
| 1072 | return false; |
| 1073 | } |
| 1074 | } |
| 1075 | return true; |
| 1076 | } |
| 1077 | |
| 1078 | bool WebRtcVideoChannel2::ValidateReceiveSsrcAvailability( |
| 1079 | const StreamParams& sp) const { |
Per | a509241 | 2016-02-12 13:30:57 +0100 | [diff] [blame] | 1080 | for (uint32_t ssrc : sp.ssrcs) { |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1081 | if (receive_ssrcs_.find(ssrc) != receive_ssrcs_.end()) { |
| 1082 | LOG(LS_ERROR) << "Receive stream with SSRC '" << ssrc |
| 1083 | << "' already exists."; |
| 1084 | return false; |
| 1085 | } |
| 1086 | } |
| 1087 | return true; |
| 1088 | } |
| 1089 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1090 | bool WebRtcVideoChannel2::AddSendStream(const StreamParams& sp) { |
| 1091 | LOG(LS_INFO) << "AddSendStream: " << sp.ToString(); |
Peter Boström | d4362cd | 2015-03-25 14:17:23 +0100 | [diff] [blame] | 1092 | if (!ValidateStreamParams(sp)) |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1093 | return false; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1094 | |
pbos@webrtc.org | 575d126 | 2014-10-08 14:48:08 +0000 | [diff] [blame] | 1095 | rtc::CritScope stream_lock(&stream_crit_); |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1096 | |
| 1097 | if (!ValidateSendSsrcAvailability(sp)) |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1098 | return false; |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1099 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1100 | for (uint32_t used_ssrc : sp.ssrcs) |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1101 | send_ssrcs_.insert(used_ssrc); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1102 | |
solenberg | e526974 | 2015-09-08 05:13:22 -0700 | [diff] [blame] | 1103 | webrtc::VideoSendStream::Config config(this); |
nisse | 0db023a | 2016-03-01 04:29:59 -0800 | [diff] [blame] | 1104 | config.suspend_below_min_bitrate = video_config_.suspend_below_min_bitrate; |
sergeyu | 80ed35e | 2016-11-28 13:11:13 -0800 | [diff] [blame] | 1105 | config.periodic_alr_bandwidth_probing = |
| 1106 | video_config_.periodic_alr_bandwidth_probing; |
nisse | 0510331 | 2016-03-16 02:22:50 -0700 | [diff] [blame] | 1107 | WebRtcVideoSendStream* stream = new WebRtcVideoSendStream( |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 1108 | call_, sp, std::move(config), default_send_options_, |
| 1109 | external_encoder_factory_, video_config_.enable_cpu_overuse_detection, |
nisse | 0510331 | 2016-03-16 02:22:50 -0700 | [diff] [blame] | 1110 | bitrate_config_.max_bitrate_bps, send_codec_, send_rtp_extensions_, |
| 1111 | send_params_); |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1112 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1113 | uint32_t ssrc = sp.first_ssrc(); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 1114 | RTC_DCHECK(ssrc != 0); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1115 | send_streams_[ssrc] = stream; |
| 1116 | |
| 1117 | if (rtcp_receiver_report_ssrc_ == kDefaultRtcpReceiverReportSsrc) { |
| 1118 | rtcp_receiver_report_ssrc_ = ssrc; |
deadbeef | 874ca3a | 2015-08-20 17:19:20 -0700 | [diff] [blame] | 1119 | LOG(LS_INFO) << "SetLocalSsrc on all the receive streams because we added " |
| 1120 | "a send stream."; |
Peter Boström | 3548dd2 | 2015-05-22 18:48:36 +0200 | [diff] [blame] | 1121 | for (auto& kv : receive_streams_) |
| 1122 | kv.second->SetLocalSsrc(ssrc); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1123 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1124 | if (sending_) { |
deadbeef | dbe2b87 | 2016-03-22 15:42:00 -0700 | [diff] [blame] | 1125 | stream->SetSend(true); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1126 | } |
| 1127 | |
| 1128 | return true; |
| 1129 | } |
| 1130 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1131 | bool WebRtcVideoChannel2::RemoveSendStream(uint32_t ssrc) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1132 | LOG(LS_INFO) << "RemoveSendStream: " << ssrc; |
| 1133 | |
pbos@webrtc.org | 575d126 | 2014-10-08 14:48:08 +0000 | [diff] [blame] | 1134 | WebRtcVideoSendStream* removed_stream; |
| 1135 | { |
| 1136 | rtc::CritScope stream_lock(&stream_crit_); |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1137 | std::map<uint32_t, WebRtcVideoSendStream*>::iterator it = |
pbos@webrtc.org | 575d126 | 2014-10-08 14:48:08 +0000 | [diff] [blame] | 1138 | send_streams_.find(ssrc); |
| 1139 | if (it == send_streams_.end()) { |
| 1140 | return false; |
| 1141 | } |
| 1142 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1143 | for (uint32_t old_ssrc : it->second->GetSsrcs()) |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1144 | send_ssrcs_.erase(old_ssrc); |
| 1145 | |
pbos@webrtc.org | 575d126 | 2014-10-08 14:48:08 +0000 | [diff] [blame] | 1146 | removed_stream = it->second; |
| 1147 | send_streams_.erase(it); |
Peter Boström | dfa2815 | 2015-10-21 17:21:10 +0200 | [diff] [blame] | 1148 | |
| 1149 | // Switch receiver report SSRCs, the one in use is no longer valid. |
| 1150 | if (rtcp_receiver_report_ssrc_ == ssrc) { |
| 1151 | rtcp_receiver_report_ssrc_ = send_streams_.empty() |
| 1152 | ? kDefaultRtcpReceiverReportSsrc |
| 1153 | : send_streams_.begin()->first; |
| 1154 | LOG(LS_INFO) << "SetLocalSsrc on all the receive streams because the " |
| 1155 | "previous local SSRC was removed."; |
| 1156 | |
| 1157 | for (auto& kv : receive_streams_) { |
| 1158 | kv.second->SetLocalSsrc(rtcp_receiver_report_ssrc_); |
| 1159 | } |
| 1160 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1161 | } |
| 1162 | |
pbos@webrtc.org | 575d126 | 2014-10-08 14:48:08 +0000 | [diff] [blame] | 1163 | delete removed_stream; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1164 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1165 | return true; |
| 1166 | } |
| 1167 | |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1168 | void WebRtcVideoChannel2::DeleteReceiveStream( |
| 1169 | WebRtcVideoChannel2::WebRtcVideoReceiveStream* stream) { |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1170 | for (uint32_t old_ssrc : stream->GetSsrcs()) |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1171 | receive_ssrcs_.erase(old_ssrc); |
| 1172 | delete stream; |
| 1173 | } |
| 1174 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1175 | bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp) { |
pbos@webrtc.org | a2a6fe6 | 2015-03-06 15:35:19 +0000 | [diff] [blame] | 1176 | return AddRecvStream(sp, false); |
| 1177 | } |
| 1178 | |
| 1179 | bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp, |
| 1180 | bool default_stream) { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 1181 | RTC_DCHECK(thread_checker_.CalledOnValidThread()); |
Fredrik Solenberg | 4b60c73 | 2015-05-07 14:07:48 +0200 | [diff] [blame] | 1182 | |
Peter Boström | d4362cd | 2015-03-25 14:17:23 +0100 | [diff] [blame] | 1183 | LOG(LS_INFO) << "AddRecvStream" << (default_stream ? " (default stream)" : "") |
| 1184 | << ": " << sp.ToString(); |
| 1185 | if (!ValidateStreamParams(sp)) |
| 1186 | return false; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1187 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1188 | uint32_t ssrc = sp.first_ssrc(); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 1189 | RTC_DCHECK(ssrc != 0); // TODO(pbos): Is this ever valid? |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1190 | |
pbos@webrtc.org | 575d126 | 2014-10-08 14:48:08 +0000 | [diff] [blame] | 1191 | rtc::CritScope stream_lock(&stream_crit_); |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1192 | // Remove running stream if this was a default stream. |
nisse | a293ef0 | 2016-02-17 07:24:50 -0800 | [diff] [blame] | 1193 | const auto& prev_stream = receive_streams_.find(ssrc); |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1194 | if (prev_stream != receive_streams_.end()) { |
| 1195 | if (default_stream || !prev_stream->second->IsDefaultStream()) { |
| 1196 | LOG(LS_ERROR) << "Receive stream for SSRC '" << ssrc |
| 1197 | << "' already exists."; |
| 1198 | return false; |
pbos@webrtc.org | a2a6fe6 | 2015-03-06 15:35:19 +0000 | [diff] [blame] | 1199 | } |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1200 | DeleteReceiveStream(prev_stream->second); |
| 1201 | receive_streams_.erase(prev_stream); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1202 | } |
| 1203 | |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1204 | if (!ValidateReceiveSsrcAvailability(sp)) |
| 1205 | return false; |
| 1206 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1207 | for (uint32_t used_ssrc : sp.ssrcs) |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1208 | receive_ssrcs_.insert(used_ssrc); |
| 1209 | |
solenberg | 4fbae2b | 2015-08-28 04:07:10 -0700 | [diff] [blame] | 1210 | webrtc::VideoReceiveStream::Config config(this); |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 1211 | webrtc::FlexfecConfig flexfec_config; |
| 1212 | ConfigureReceiverRtp(&config, &flexfec_config, sp); |
pbos@webrtc.org | 3bf3d23 | 2014-10-31 12:59:34 +0000 | [diff] [blame] | 1213 | |
pbos | 8fc7fa7 | 2015-07-15 08:02:58 -0700 | [diff] [blame] | 1214 | // Set up A/V sync group based on sync label. |
| 1215 | config.sync_group = sp.sync_label; |
pbos@webrtc.org | 3bf3d23 | 2014-10-31 12:59:34 +0000 | [diff] [blame] | 1216 | |
kwiberg | 102c6a6 | 2015-10-30 02:47:38 -0700 | [diff] [blame] | 1217 | config.rtp.remb = send_codec_ ? HasRemb(send_codec_->codec) : false; |
stefan | 43edf0f | 2015-11-20 18:05:48 -0800 | [diff] [blame] | 1218 | config.rtp.transport_cc = |
| 1219 | send_codec_ ? HasTransportCc(send_codec_->codec) : false; |
nisse | 7ade7b3 | 2016-03-23 04:48:10 -0700 | [diff] [blame] | 1220 | config.disable_prerenderer_smoothing = |
| 1221 | video_config_.disable_prerenderer_smoothing; |
Peter Boström | 126c03e | 2015-05-11 12:48:12 +0200 | [diff] [blame] | 1222 | |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1223 | receive_streams_[ssrc] = new WebRtcVideoReceiveStream( |
Tommi | 733b547 | 2016-06-10 17:58:01 +0200 | [diff] [blame] | 1224 | call_, sp, std::move(config), external_decoder_factory_, default_stream, |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 1225 | recv_codecs_, flexfec_config); |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1226 | |
| 1227 | return true; |
| 1228 | } |
| 1229 | |
| 1230 | void WebRtcVideoChannel2::ConfigureReceiverRtp( |
| 1231 | webrtc::VideoReceiveStream::Config* config, |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 1232 | webrtc::FlexfecConfig* flexfec_config, |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1233 | const StreamParams& sp) const { |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1234 | uint32_t ssrc = sp.first_ssrc(); |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1235 | |
| 1236 | config->rtp.remote_ssrc = ssrc; |
| 1237 | config->rtp.local_ssrc = rtcp_receiver_report_ssrc_; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1238 | |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1239 | config->rtp.extensions = recv_rtp_extensions_; |
Taylor Brandstetter | 5f0b83b | 2016-03-18 15:02:07 -0700 | [diff] [blame] | 1240 | // Whether or not the receive stream sends reduced size RTCP is determined |
| 1241 | // by the send params. |
| 1242 | // TODO(deadbeef): Once we change "send_params" to "sender_params" and |
| 1243 | // "recv_params" to "receiver_params", we should get this out of |
| 1244 | // receiver_params_. |
| 1245 | config->rtp.rtcp_mode = send_params_.rtcp.reduced_size |
deadbeef | 1387149 | 2015-12-09 12:37:51 -0800 | [diff] [blame] | 1246 | ? webrtc::RtcpMode::kReducedSize |
| 1247 | : webrtc::RtcpMode::kCompound; |
pbos@webrtc.org | 257e130 | 2014-07-25 19:01:32 +0000 | [diff] [blame] | 1248 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1249 | // TODO(pbos): This protection is against setting the same local ssrc as |
| 1250 | // remote which is not permitted by the lower-level API. RTCP requires a |
| 1251 | // corresponding sender SSRC. Figure out what to do when we don't have |
| 1252 | // (receive-only) or know a good local SSRC. |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1253 | if (config->rtp.remote_ssrc == config->rtp.local_ssrc) { |
| 1254 | if (config->rtp.local_ssrc != kDefaultRtcpReceiverReportSsrc) { |
| 1255 | config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1256 | } else { |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1257 | config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc + 1; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1258 | } |
| 1259 | } |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1260 | |
| 1261 | for (size_t i = 0; i < recv_codecs_.size(); ++i) { |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1262 | uint32_t rtx_ssrc; |
andresp@webrtc.org | 82775b1 | 2014-11-07 09:37:54 +0000 | [diff] [blame] | 1263 | if (recv_codecs_[i].rtx_payload_type != -1 && |
| 1264 | sp.GetFidSsrc(ssrc, &rtx_ssrc)) { |
| 1265 | webrtc::VideoReceiveStream::Config::Rtp::Rtx& rtx = |
| 1266 | config->rtp.rtx[recv_codecs_[i].codec.id]; |
| 1267 | rtx.ssrc = rtx_ssrc; |
| 1268 | rtx.payload_type = recv_codecs_[i].rtx_payload_type; |
| 1269 | } |
| 1270 | } |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 1271 | |
| 1272 | // TODO(brandtr): This code needs to be generalized when we add support for |
| 1273 | // multistream protection. |
| 1274 | uint32_t flexfec_ssrc; |
| 1275 | if (sp.GetFecFrSsrc(ssrc, &flexfec_ssrc)) { |
| 1276 | flexfec_config->flexfec_ssrc = flexfec_ssrc; |
| 1277 | flexfec_config->protected_media_ssrcs = {ssrc}; |
| 1278 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1279 | } |
| 1280 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1281 | bool WebRtcVideoChannel2::RemoveRecvStream(uint32_t ssrc) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1282 | LOG(LS_INFO) << "RemoveRecvStream: " << ssrc; |
| 1283 | if (ssrc == 0) { |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 1284 | LOG(LS_ERROR) << "RemoveRecvStream with 0 ssrc is not supported."; |
| 1285 | return false; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1286 | } |
| 1287 | |
pbos@webrtc.org | 575d126 | 2014-10-08 14:48:08 +0000 | [diff] [blame] | 1288 | rtc::CritScope stream_lock(&stream_crit_); |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1289 | std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator stream = |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1290 | receive_streams_.find(ssrc); |
| 1291 | if (stream == receive_streams_.end()) { |
| 1292 | LOG(LS_ERROR) << "Stream not found for ssrc: " << ssrc; |
| 1293 | return false; |
| 1294 | } |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1295 | DeleteReceiveStream(stream->second); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1296 | receive_streams_.erase(stream); |
| 1297 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1298 | return true; |
| 1299 | } |
| 1300 | |
nisse | acd935b | 2016-11-11 03:55:13 -0800 | [diff] [blame] | 1301 | bool WebRtcVideoChannel2::SetSink( |
| 1302 | uint32_t ssrc, |
| 1303 | rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) { |
deadbeef | 5a4a75a | 2016-06-02 16:23:38 -0700 | [diff] [blame] | 1304 | LOG(LS_INFO) << "SetSink: ssrc:" << ssrc << " " |
| 1305 | << (sink ? "(ptr)" : "nullptr"); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1306 | if (ssrc == 0) { |
nisse | 08582ff | 2016-02-04 01:24:52 -0800 | [diff] [blame] | 1307 | default_unsignalled_ssrc_handler_.SetDefaultSink(this, sink); |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1308 | return true; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1309 | } |
| 1310 | |
pbos@webrtc.org | 575d126 | 2014-10-08 14:48:08 +0000 | [diff] [blame] | 1311 | rtc::CritScope stream_lock(&stream_crit_); |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1312 | std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it = |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1313 | receive_streams_.find(ssrc); |
| 1314 | if (it == receive_streams_.end()) { |
| 1315 | return false; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1316 | } |
| 1317 | |
nisse | 08582ff | 2016-02-04 01:24:52 -0800 | [diff] [blame] | 1318 | it->second->SetSink(sink); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1319 | return true; |
| 1320 | } |
| 1321 | |
pbos@webrtc.org | 058b1f1 | 2015-03-04 08:54:32 +0000 | [diff] [blame] | 1322 | bool WebRtcVideoChannel2::GetStats(VideoMediaInfo* info) { |
Peter Boström | ca8b404 | 2016-03-08 14:24:13 -0800 | [diff] [blame] | 1323 | TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::GetStats"); |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 1324 | |
| 1325 | // Log stats periodically. |
| 1326 | bool log_stats = false; |
| 1327 | int64_t now_ms = rtc::TimeMillis(); |
| 1328 | if (last_stats_log_ms_ == -1 || |
| 1329 | now_ms - last_stats_log_ms_ > kStatsLogIntervalMs) { |
| 1330 | last_stats_log_ms_ = now_ms; |
| 1331 | log_stats = true; |
| 1332 | } |
| 1333 | |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 1334 | info->Clear(); |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 1335 | FillSenderStats(info, log_stats); |
| 1336 | FillReceiverStats(info, log_stats); |
hbos | a65704b | 2016-11-14 02:28:16 -0800 | [diff] [blame] | 1337 | FillSendAndReceiveCodecStats(info); |
pbos@webrtc.org | 2b19f06 | 2014-12-11 13:26:09 +0000 | [diff] [blame] | 1338 | webrtc::Call::Stats stats = call_->GetStats(); |
| 1339 | FillBandwidthEstimationStats(stats, info); |
| 1340 | if (stats.rtt_ms != -1) { |
| 1341 | for (size_t i = 0; i < info->senders.size(); ++i) { |
| 1342 | info->senders[i].rtt_ms = stats.rtt_ms; |
| 1343 | } |
| 1344 | } |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 1345 | |
| 1346 | if (log_stats) |
| 1347 | LOG(LS_INFO) << stats.ToString(now_ms); |
| 1348 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1349 | return true; |
| 1350 | } |
| 1351 | |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 1352 | void WebRtcVideoChannel2::FillSenderStats(VideoMediaInfo* video_media_info, |
| 1353 | bool log_stats) { |
pbos@webrtc.org | 575d126 | 2014-10-08 14:48:08 +0000 | [diff] [blame] | 1354 | rtc::CritScope stream_lock(&stream_crit_); |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1355 | for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator it = |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 1356 | send_streams_.begin(); |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1357 | it != send_streams_.end(); ++it) { |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 1358 | video_media_info->senders.push_back( |
| 1359 | it->second->GetVideoSenderInfo(log_stats)); |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 1360 | } |
| 1361 | } |
| 1362 | |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 1363 | void WebRtcVideoChannel2::FillReceiverStats(VideoMediaInfo* video_media_info, |
| 1364 | bool log_stats) { |
pbos@webrtc.org | 575d126 | 2014-10-08 14:48:08 +0000 | [diff] [blame] | 1365 | rtc::CritScope stream_lock(&stream_crit_); |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1366 | for (std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it = |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 1367 | receive_streams_.begin(); |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1368 | it != receive_streams_.end(); ++it) { |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 1369 | video_media_info->receivers.push_back( |
| 1370 | it->second->GetVideoReceiverInfo(log_stats)); |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 1371 | } |
| 1372 | } |
| 1373 | |
| 1374 | void WebRtcVideoChannel2::FillBandwidthEstimationStats( |
pbos@webrtc.org | 2b19f06 | 2014-12-11 13:26:09 +0000 | [diff] [blame] | 1375 | const webrtc::Call::Stats& stats, |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 1376 | VideoMediaInfo* video_media_info) { |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 1377 | BandwidthEstimationInfo bwe_info; |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 1378 | bwe_info.available_send_bandwidth = stats.send_bandwidth_bps; |
| 1379 | bwe_info.available_recv_bandwidth = stats.recv_bandwidth_bps; |
| 1380 | bwe_info.bucket_delay = stats.pacer_delay_ms; |
| 1381 | |
| 1382 | // Get send stream bitrate stats. |
| 1383 | rtc::CritScope stream_lock(&stream_crit_); |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1384 | for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator stream = |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 1385 | send_streams_.begin(); |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1386 | stream != send_streams_.end(); ++stream) { |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 1387 | stream->second->FillBandwidthEstimationInfo(&bwe_info); |
| 1388 | } |
| 1389 | video_media_info->bw_estimations.push_back(bwe_info); |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 1390 | } |
| 1391 | |
hbos | a65704b | 2016-11-14 02:28:16 -0800 | [diff] [blame] | 1392 | void WebRtcVideoChannel2::FillSendAndReceiveCodecStats( |
| 1393 | VideoMediaInfo* video_media_info) { |
| 1394 | for (const VideoCodec& codec : send_params_.codecs) { |
| 1395 | webrtc::RtpCodecParameters codec_params = codec.ToCodecParameters(); |
| 1396 | video_media_info->send_codecs.insert( |
| 1397 | std::make_pair(codec_params.payload_type, std::move(codec_params))); |
| 1398 | } |
| 1399 | for (const VideoCodec& codec : recv_params_.codecs) { |
| 1400 | webrtc::RtpCodecParameters codec_params = codec.ToCodecParameters(); |
| 1401 | video_media_info->receive_codecs.insert( |
| 1402 | std::make_pair(codec_params.payload_type, std::move(codec_params))); |
| 1403 | } |
| 1404 | } |
| 1405 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1406 | void WebRtcVideoChannel2::OnPacketReceived( |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 1407 | rtc::CopyOnWriteBuffer* packet, |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1408 | const rtc::PacketTime& packet_time) { |
stefan | 68786d2 | 2015-09-08 05:36:15 -0700 | [diff] [blame] | 1409 | const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp, |
| 1410 | packet_time.not_before); |
pbos@webrtc.org | 4e545cc | 2014-05-14 13:58:13 +0000 | [diff] [blame] | 1411 | const webrtc::PacketReceiver::DeliveryStatus delivery_result = |
stefan | 68786d2 | 2015-09-08 05:36:15 -0700 | [diff] [blame] | 1412 | call_->Receiver()->DeliverPacket( |
| 1413 | webrtc::MediaType::VIDEO, |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 1414 | packet->cdata(), packet->size(), |
stefan | 68786d2 | 2015-09-08 05:36:15 -0700 | [diff] [blame] | 1415 | webrtc_packet_time); |
pbos@webrtc.org | 4e545cc | 2014-05-14 13:58:13 +0000 | [diff] [blame] | 1416 | switch (delivery_result) { |
| 1417 | case webrtc::PacketReceiver::DELIVERY_OK: |
| 1418 | return; |
| 1419 | case webrtc::PacketReceiver::DELIVERY_PACKET_ERROR: |
| 1420 | return; |
| 1421 | case webrtc::PacketReceiver::DELIVERY_UNKNOWN_SSRC: |
| 1422 | break; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1423 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1424 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1425 | uint32_t ssrc = 0; |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 1426 | if (!GetRtpSsrc(packet->cdata(), packet->size(), &ssrc)) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1427 | return; |
| 1428 | } |
| 1429 | |
noahric | d10a68e | 2015-07-10 11:27:55 -0700 | [diff] [blame] | 1430 | int payload_type = 0; |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 1431 | if (!GetRtpPayloadType(packet->cdata(), packet->size(), &payload_type)) { |
noahric | d10a68e | 2015-07-10 11:27:55 -0700 | [diff] [blame] | 1432 | return; |
| 1433 | } |
| 1434 | |
| 1435 | // See if this payload_type is registered as one that usually gets its own |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 1436 | // SSRC (RTX) or at least is safe to drop either way (FEC). If it is, and |
noahric | d10a68e | 2015-07-10 11:27:55 -0700 | [diff] [blame] | 1437 | // it wasn't handled above by DeliverPacket, that means we don't know what |
| 1438 | // stream it associates with, and we shouldn't ever create an implicit channel |
| 1439 | // for these. |
| 1440 | for (auto& codec : recv_codecs_) { |
| 1441 | if (payload_type == codec.rtx_payload_type || |
brandtr | b5f2c3f | 2016-10-04 23:28:39 -0700 | [diff] [blame] | 1442 | payload_type == codec.ulpfec.red_rtx_payload_type || |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 1443 | payload_type == codec.ulpfec.ulpfec_payload_type || |
| 1444 | payload_type == codec.flexfec.flexfec_payload_type) { |
noahric | d10a68e | 2015-07-10 11:27:55 -0700 | [diff] [blame] | 1445 | return; |
| 1446 | } |
| 1447 | } |
| 1448 | |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 1449 | switch (unsignalled_ssrc_handler_->OnUnsignalledSsrc(this, ssrc)) { |
| 1450 | case UnsignalledSsrcHandler::kDropPacket: |
| 1451 | return; |
| 1452 | case UnsignalledSsrcHandler::kDeliverPacket: |
| 1453 | break; |
| 1454 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1455 | |
stefan | 68786d2 | 2015-09-08 05:36:15 -0700 | [diff] [blame] | 1456 | if (call_->Receiver()->DeliverPacket( |
| 1457 | webrtc::MediaType::VIDEO, |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 1458 | packet->cdata(), packet->size(), |
stefan | 68786d2 | 2015-09-08 05:36:15 -0700 | [diff] [blame] | 1459 | webrtc_packet_time) != webrtc::PacketReceiver::DELIVERY_OK) { |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 1460 | LOG(LS_WARNING) << "Failed to deliver RTP packet on re-delivery."; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1461 | return; |
| 1462 | } |
| 1463 | } |
| 1464 | |
| 1465 | void WebRtcVideoChannel2::OnRtcpReceived( |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 1466 | rtc::CopyOnWriteBuffer* packet, |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1467 | const rtc::PacketTime& packet_time) { |
stefan | 68786d2 | 2015-09-08 05:36:15 -0700 | [diff] [blame] | 1468 | const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp, |
| 1469 | packet_time.not_before); |
Peter Boström | 2aff615 | 2015-11-18 13:47:16 +0100 | [diff] [blame] | 1470 | // TODO(pbos): Check webrtc::PacketReceiver::DELIVERY_OK once we deliver |
| 1471 | // for both audio and video on the same path. Since BundleFilter doesn't |
| 1472 | // filter RTCP anymore incoming RTCP packets could've been going to audio (so |
| 1473 | // logging failures spam the log). |
| 1474 | call_->Receiver()->DeliverPacket( |
| 1475 | webrtc::MediaType::VIDEO, |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 1476 | packet->cdata(), packet->size(), |
Peter Boström | 2aff615 | 2015-11-18 13:47:16 +0100 | [diff] [blame] | 1477 | webrtc_packet_time); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1478 | } |
| 1479 | |
| 1480 | void WebRtcVideoChannel2::OnReadyToSend(bool ready) { |
pbos@webrtc.org | 26c0c41 | 2014-09-03 16:17:12 +0000 | [diff] [blame] | 1481 | LOG(LS_VERBOSE) << "OnReadyToSend: " << (ready ? "Ready." : "Not ready."); |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 1482 | call_->SignalChannelNetworkState( |
| 1483 | webrtc::MediaType::VIDEO, |
| 1484 | ready ? webrtc::kNetworkUp : webrtc::kNetworkDown); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1485 | } |
| 1486 | |
Honghai Zhang | cc411c0 | 2016-03-29 17:27:21 -0700 | [diff] [blame] | 1487 | void WebRtcVideoChannel2::OnNetworkRouteChanged( |
| 1488 | const std::string& transport_name, |
Honghai Zhang | 0e533ef | 2016-04-19 15:41:36 -0700 | [diff] [blame] | 1489 | const rtc::NetworkRoute& network_route) { |
| 1490 | call_->OnNetworkRouteChanged(transport_name, network_route); |
Honghai Zhang | cc411c0 | 2016-03-29 17:27:21 -0700 | [diff] [blame] | 1491 | } |
| 1492 | |
michaelt | 79e0588 | 2016-11-08 02:50:09 -0800 | [diff] [blame] | 1493 | void WebRtcVideoChannel2::OnTransportOverheadChanged( |
| 1494 | int transport_overhead_per_packet) { |
| 1495 | call_->OnTransportOverheadChanged(webrtc::MediaType::VIDEO, |
| 1496 | transport_overhead_per_packet); |
| 1497 | } |
| 1498 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1499 | void WebRtcVideoChannel2::SetInterface(NetworkInterface* iface) { |
| 1500 | MediaChannel::SetInterface(iface); |
| 1501 | // Set the RTP recv/send buffer to a bigger size |
| 1502 | MediaChannel::SetOption(NetworkInterface::ST_RTP, |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1503 | rtc::Socket::OPT_RCVBUF, |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1504 | kVideoRtpBufferSize); |
| 1505 | |
buildbot@webrtc.org | ae694ef | 2014-10-28 17:37:17 +0000 | [diff] [blame] | 1506 | // Speculative change to increase the outbound socket buffer size. |
| 1507 | // In b/15152257, we are seeing a significant number of packets discarded |
| 1508 | // due to lack of socket buffer space, although it's not yet clear what the |
| 1509 | // ideal value should be. |
| 1510 | MediaChannel::SetOption(NetworkInterface::ST_RTP, |
| 1511 | rtc::Socket::OPT_SNDBUF, |
| 1512 | kVideoRtpBufferSize); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1513 | } |
| 1514 | |
stefan | 1d8a506 | 2015-10-02 03:39:33 -0700 | [diff] [blame] | 1515 | bool WebRtcVideoChannel2::SendRtp(const uint8_t* data, |
| 1516 | size_t len, |
| 1517 | const webrtc::PacketOptions& options) { |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 1518 | rtc::CopyOnWriteBuffer packet(data, len, kMaxRtpPacketLen); |
stefan | c1aeaf0 | 2015-10-15 07:26:07 -0700 | [diff] [blame] | 1519 | rtc::PacketOptions rtc_options; |
| 1520 | rtc_options.packet_id = options.packet_id; |
| 1521 | return MediaChannel::SendPacket(&packet, rtc_options); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1522 | } |
| 1523 | |
| 1524 | bool WebRtcVideoChannel2::SendRtcp(const uint8_t* data, size_t len) { |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 1525 | rtc::CopyOnWriteBuffer packet(data, len, kMaxRtpPacketLen); |
stefan | c1aeaf0 | 2015-10-15 07:26:07 -0700 | [diff] [blame] | 1526 | return MediaChannel::SendRtcp(&packet, rtc::PacketOptions()); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1527 | } |
| 1528 | |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 1529 | WebRtcVideoChannel2::WebRtcVideoSendStream::VideoSendStreamParameters:: |
| 1530 | VideoSendStreamParameters( |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 1531 | webrtc::VideoSendStream::Config config, |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 1532 | const VideoOptions& options, |
Peter Boström | dfd53fe | 2015-03-27 15:58:11 +0100 | [diff] [blame] | 1533 | int max_bitrate_bps, |
Karl Wiberg | be57983 | 2015-11-10 22:34:18 +0100 | [diff] [blame] | 1534 | const rtc::Optional<VideoCodecSettings>& codec_settings) |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 1535 | : config(std::move(config)), |
Peter Boström | dfd53fe | 2015-03-27 15:58:11 +0100 | [diff] [blame] | 1536 | options(options), |
| 1537 | max_bitrate_bps(max_bitrate_bps), |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1538 | conference_mode(false), |
kwiberg | 102c6a6 | 2015-10-30 02:47:38 -0700 | [diff] [blame] | 1539 | codec_settings(codec_settings) {} |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 1540 | |
Peter Boström | 4d71ede | 2015-05-19 23:09:35 +0200 | [diff] [blame] | 1541 | WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder::AllocatedEncoder( |
| 1542 | webrtc::VideoEncoder* encoder, |
magjed | 509e4fe | 2016-11-18 01:34:11 -0800 | [diff] [blame] | 1543 | const cricket::VideoCodec& codec, |
Peter Boström | 4d71ede | 2015-05-19 23:09:35 +0200 | [diff] [blame] | 1544 | bool external) |
| 1545 | : encoder(encoder), |
| 1546 | external_encoder(nullptr), |
magjed | 509e4fe | 2016-11-18 01:34:11 -0800 | [diff] [blame] | 1547 | codec(codec), |
Peter Boström | 4d71ede | 2015-05-19 23:09:35 +0200 | [diff] [blame] | 1548 | external(external) { |
| 1549 | if (external) { |
| 1550 | external_encoder = encoder; |
| 1551 | this->encoder = |
magjed | 509e4fe | 2016-11-18 01:34:11 -0800 | [diff] [blame] | 1552 | new webrtc::VideoEncoderSoftwareFallbackWrapper(codec, encoder); |
Peter Boström | 4d71ede | 2015-05-19 23:09:35 +0200 | [diff] [blame] | 1553 | } |
| 1554 | } |
| 1555 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1556 | WebRtcVideoChannel2::WebRtcVideoSendStream::WebRtcVideoSendStream( |
| 1557 | webrtc::Call* call, |
solenberg | 4fbae2b | 2015-08-28 04:07:10 -0700 | [diff] [blame] | 1558 | const StreamParams& sp, |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 1559 | webrtc::VideoSendStream::Config config, |
nisse | 0510331 | 2016-03-16 02:22:50 -0700 | [diff] [blame] | 1560 | const VideoOptions& options, |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 1561 | WebRtcVideoEncoderFactory* external_encoder_factory, |
perkj | 2d5f091 | 2016-02-29 00:04:41 -0800 | [diff] [blame] | 1562 | bool enable_cpu_overuse_detection, |
Peter Boström | dfd53fe | 2015-03-27 15:58:11 +0100 | [diff] [blame] | 1563 | int max_bitrate_bps, |
Karl Wiberg | be57983 | 2015-11-10 22:34:18 +0100 | [diff] [blame] | 1564 | const rtc::Optional<VideoCodecSettings>& codec_settings, |
skvlad | 3abb764 | 2016-06-16 12:08:03 -0700 | [diff] [blame] | 1565 | const rtc::Optional<std::vector<webrtc::RtpExtension>>& rtp_extensions, |
deadbeef | 1387149 | 2015-12-09 12:37:51 -0800 | [diff] [blame] | 1566 | // TODO(deadbeef): Don't duplicate information between send_params, |
| 1567 | // rtp_extensions, options, etc. |
| 1568 | const VideoSendParameters& send_params) |
perkj | 2d5f091 | 2016-02-29 00:04:41 -0800 | [diff] [blame] | 1569 | : worker_thread_(rtc::Thread::Current()), |
| 1570 | ssrcs_(sp.ssrcs), |
Peter Boström | 259bd20 | 2015-05-28 13:39:50 +0200 | [diff] [blame] | 1571 | ssrc_groups_(sp.ssrc_groups), |
Henrik Kjellander | 7c027b6 | 2015-04-22 13:21:30 +0200 | [diff] [blame] | 1572 | call_(call), |
perkj | 803d97f | 2016-11-01 11:45:46 -0700 | [diff] [blame] | 1573 | enable_cpu_overuse_detection_(enable_cpu_overuse_detection), |
nisse | 2ded9b1 | 2016-04-08 02:23:55 -0700 | [diff] [blame] | 1574 | source_(nullptr), |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 1575 | external_encoder_factory_(external_encoder_factory), |
perkj | 2d5f091 | 2016-02-29 00:04:41 -0800 | [diff] [blame] | 1576 | stream_(nullptr), |
perkj | a49cbd3 | 2016-09-16 07:53:41 -0700 | [diff] [blame] | 1577 | encoder_sink_(nullptr), |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 1578 | parameters_(std::move(config), options, max_bitrate_bps, codec_settings), |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1579 | rtp_parameters_(CreateRtpParametersWithOneEncoding()), |
magjed | 509e4fe | 2016-11-18 01:34:11 -0800 | [diff] [blame] | 1580 | allocated_encoder_(nullptr, cricket::VideoCodec(), false), |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1581 | sending_(false), |
nisse | 74c10b5 | 2016-09-05 00:51:16 -0700 | [diff] [blame] | 1582 | last_frame_timestamp_us_(0) { |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1583 | parameters_.config.rtp.max_packet_size = kVideoMtu; |
nisse | 4b4dc86 | 2016-02-17 05:25:36 -0800 | [diff] [blame] | 1584 | parameters_.conference_mode = send_params.conference_mode; |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1585 | |
| 1586 | sp.GetPrimarySsrcs(¶meters_.config.rtp.ssrcs); |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 1587 | |
| 1588 | // RTX. |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1589 | sp.GetFidSsrcs(parameters_.config.rtp.ssrcs, |
| 1590 | ¶meters_.config.rtp.rtx.ssrcs); |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 1591 | |
| 1592 | // FlexFEC. |
| 1593 | // TODO(brandtr): This code needs to be generalized when we add support for |
| 1594 | // multistream protection. |
| 1595 | if (IsFlexfecFieldTrialEnabled()) { |
| 1596 | uint32_t flexfec_ssrc; |
| 1597 | bool flexfec_enabled = false; |
| 1598 | for (uint32_t primary_ssrc : parameters_.config.rtp.ssrcs) { |
| 1599 | if (sp.GetFecFrSsrc(primary_ssrc, &flexfec_ssrc)) { |
| 1600 | if (flexfec_enabled) { |
| 1601 | LOG(LS_INFO) << "Multiple FlexFEC streams proposed by remote, but " |
| 1602 | "our implementation only supports a single FlexFEC " |
| 1603 | "stream. Will not enable FlexFEC for proposed " |
| 1604 | "stream with SSRC: " |
| 1605 | << flexfec_ssrc << "."; |
| 1606 | continue; |
| 1607 | } |
| 1608 | |
| 1609 | flexfec_enabled = true; |
| 1610 | parameters_.config.rtp.flexfec.flexfec_ssrc = flexfec_ssrc; |
| 1611 | parameters_.config.rtp.flexfec.protected_media_ssrcs = {primary_ssrc}; |
| 1612 | } |
| 1613 | } |
| 1614 | } |
| 1615 | |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1616 | parameters_.config.rtp.c_name = sp.cname; |
skvlad | 3abb764 | 2016-06-16 12:08:03 -0700 | [diff] [blame] | 1617 | if (rtp_extensions) { |
| 1618 | parameters_.config.rtp.extensions = *rtp_extensions; |
| 1619 | } |
deadbeef | 1387149 | 2015-12-09 12:37:51 -0800 | [diff] [blame] | 1620 | parameters_.config.rtp.rtcp_mode = send_params.rtcp.reduced_size |
| 1621 | ? webrtc::RtcpMode::kReducedSize |
| 1622 | : webrtc::RtcpMode::kCompound; |
kwiberg | 102c6a6 | 2015-10-30 02:47:38 -0700 | [diff] [blame] | 1623 | if (codec_settings) { |
nisse | 0db023a | 2016-03-01 04:29:59 -0800 | [diff] [blame] | 1624 | SetCodec(*codec_settings); |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1625 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1626 | } |
| 1627 | |
| 1628 | WebRtcVideoChannel2::WebRtcVideoSendStream::~WebRtcVideoSendStream() { |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1629 | if (stream_ != NULL) { |
| 1630 | call_->DestroyVideoSendStream(stream_); |
| 1631 | } |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 1632 | DestroyVideoEncoder(&allocated_encoder_); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1633 | } |
| 1634 | |
Per | a509241 | 2016-02-12 13:30:57 +0100 | [diff] [blame] | 1635 | void WebRtcVideoChannel2::WebRtcVideoSendStream::OnFrame( |
nisse | acd935b | 2016-11-11 03:55:13 -0800 | [diff] [blame] | 1636 | const webrtc::VideoFrame& frame) { |
Per | a509241 | 2016-02-12 13:30:57 +0100 | [diff] [blame] | 1637 | TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::OnFrame"); |
nisse | 74c10b5 | 2016-09-05 00:51:16 -0700 | [diff] [blame] | 1638 | webrtc::VideoFrame video_frame(frame.video_frame_buffer(), |
| 1639 | frame.rotation(), |
| 1640 | frame.timestamp_us()); |
| 1641 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 1642 | rtc::CritScope cs(&lock_); |
skvlad | 3abb764 | 2016-06-16 12:08:03 -0700 | [diff] [blame] | 1643 | |
| 1644 | if (video_frame.width() != last_frame_info_.width || |
| 1645 | video_frame.height() != last_frame_info_.height || |
| 1646 | video_frame.rotation() != last_frame_info_.rotation || |
| 1647 | video_frame.is_texture() != last_frame_info_.is_texture) { |
| 1648 | last_frame_info_.width = video_frame.width(); |
| 1649 | last_frame_info_.height = video_frame.height(); |
| 1650 | last_frame_info_.rotation = video_frame.rotation(); |
| 1651 | last_frame_info_.is_texture = video_frame.is_texture(); |
skvlad | 3abb764 | 2016-06-16 12:08:03 -0700 | [diff] [blame] | 1652 | |
| 1653 | LOG(LS_INFO) << "Video frame parameters changed: dimensions=" |
| 1654 | << last_frame_info_.width << "x" << last_frame_info_.height |
| 1655 | << ", rotation=" << last_frame_info_.rotation |
| 1656 | << ", texture=" << last_frame_info_.is_texture; |
| 1657 | } |
| 1658 | |
perkj | a49cbd3 | 2016-09-16 07:53:41 -0700 | [diff] [blame] | 1659 | if (encoder_sink_ == NULL) { |
Peter Boström | ad1f9b6 | 2015-04-08 14:04:01 +0200 | [diff] [blame] | 1660 | // Frame input before send codecs are configured, dropping frame. |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1661 | return; |
| 1662 | } |
pbos@webrtc.org | 86196c4 | 2015-02-16 21:02:00 +0000 | [diff] [blame] | 1663 | |
nisse | 74c10b5 | 2016-09-05 00:51:16 -0700 | [diff] [blame] | 1664 | last_frame_timestamp_us_ = video_frame.timestamp_us(); |
skvlad | 3abb764 | 2016-06-16 12:08:03 -0700 | [diff] [blame] | 1665 | |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1666 | // Forward frame to the encoder regardless if we are sending or not. This is |
| 1667 | // to ensure that the encoder can be reconfigured with the correct frame size |
| 1668 | // as quickly as possible. |
perkj | a49cbd3 | 2016-09-16 07:53:41 -0700 | [diff] [blame] | 1669 | encoder_sink_->OnFrame(video_frame); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1670 | } |
| 1671 | |
deadbeef | 5a4a75a | 2016-06-02 16:23:38 -0700 | [diff] [blame] | 1672 | bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoSend( |
| 1673 | bool enable, |
| 1674 | const VideoOptions* options, |
nisse | acd935b | 2016-11-11 03:55:13 -0800 | [diff] [blame] | 1675 | rtc::VideoSourceInterface<webrtc::VideoFrame>* source) { |
deadbeef | 5a4a75a | 2016-06-02 16:23:38 -0700 | [diff] [blame] | 1676 | TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetVideoSend"); |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1677 | RTC_DCHECK_RUN_ON(&thread_checker_); |
nisse | 2ded9b1 | 2016-04-08 02:23:55 -0700 | [diff] [blame] | 1678 | |
deadbeef | 5a4a75a | 2016-06-02 16:23:38 -0700 | [diff] [blame] | 1679 | // Ignore |options| pointer if |enable| is false. |
| 1680 | bool options_present = enable && options; |
| 1681 | bool source_changing = source_ != source; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1682 | |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1683 | if (options_present) { |
| 1684 | VideoOptions old_options = parameters_.options; |
| 1685 | parameters_.options.SetAll(*options); |
| 1686 | if (parameters_.options != old_options) { |
| 1687 | ReconfigureEncoder(); |
perkj | 3b703ed | 2016-09-29 23:25:40 -0700 | [diff] [blame] | 1688 | } |
perkj | 26105b4 | 2016-09-29 22:39:10 -0700 | [diff] [blame] | 1689 | } |
| 1690 | |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1691 | if (source_changing) { |
| 1692 | rtc::CritScope cs(&lock_); |
perkj | 803d97f | 2016-11-01 11:45:46 -0700 | [diff] [blame] | 1693 | if (source == nullptr && last_frame_info_.width > 0 && encoder_sink_) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1694 | LOG(LS_VERBOSE) << "Disabling capturer, sending black frame."; |
| 1695 | // Force this black frame not to be dropped due to timestamp order |
| 1696 | // check. As IncomingCapturedFrame will drop the frame if this frame's |
| 1697 | // timestamp is less than or equal to last frame's timestamp, it is |
| 1698 | // necessary to give this black frame a larger timestamp than the |
| 1699 | // previous one. |
| 1700 | last_frame_timestamp_us_ += rtc::kNumMicrosecsPerMillisec; |
| 1701 | rtc::scoped_refptr<webrtc::I420Buffer> black_buffer( |
| 1702 | webrtc::I420Buffer::Create(last_frame_info_.width, |
| 1703 | last_frame_info_.height)); |
| 1704 | black_buffer->SetToBlack(); |
| 1705 | |
| 1706 | encoder_sink_->OnFrame(webrtc::VideoFrame( |
| 1707 | black_buffer, last_frame_info_.rotation, last_frame_timestamp_us_)); |
| 1708 | } |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1709 | } |
| 1710 | |
perkj | 803d97f | 2016-11-01 11:45:46 -0700 | [diff] [blame] | 1711 | // TODO(perkj, nisse): Remove |source_| and directly call |
| 1712 | // |stream_|->SetSource(source) once the video frame types have been |
| 1713 | // merged. |
| 1714 | if (source_ && stream_) { |
| 1715 | stream_->SetSource( |
| 1716 | nullptr, webrtc::VideoSendStream::DegradationPreference::kBalanced); |
| 1717 | } |
| 1718 | // Switch to the new source. |
| 1719 | source_ = source; |
| 1720 | if (source && stream_) { |
| 1721 | // Do not adapt resolution for screen content as this will likely |
| 1722 | // result in blurry and unreadable text. |
| 1723 | stream_->SetSource( |
| 1724 | this, enable_cpu_overuse_detection_ && |
| 1725 | !parameters_.options.is_screencast.value_or(false) |
| 1726 | ? webrtc::VideoSendStream::DegradationPreference::kBalanced |
| 1727 | : webrtc::VideoSendStream::DegradationPreference:: |
| 1728 | kMaintainResolution); |
nisse | 2ded9b1 | 2016-04-08 02:23:55 -0700 | [diff] [blame] | 1729 | } |
deadbeef | 5a4a75a | 2016-06-02 16:23:38 -0700 | [diff] [blame] | 1730 | return true; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1731 | } |
| 1732 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1733 | const std::vector<uint32_t>& |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1734 | WebRtcVideoChannel2::WebRtcVideoSendStream::GetSsrcs() const { |
| 1735 | return ssrcs_; |
| 1736 | } |
| 1737 | |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 1738 | WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder |
| 1739 | WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoder( |
| 1740 | const VideoCodec& codec) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1741 | RTC_DCHECK_RUN_ON(&thread_checker_); |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 1742 | // Do not re-create encoders of the same type. |
magjed | 509e4fe | 2016-11-18 01:34:11 -0800 | [diff] [blame] | 1743 | if (codec == allocated_encoder_.codec && |
| 1744 | allocated_encoder_.encoder != nullptr) { |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 1745 | return allocated_encoder_; |
| 1746 | } |
| 1747 | |
magjed | 509e4fe | 2016-11-18 01:34:11 -0800 | [diff] [blame] | 1748 | // Try creating external encoder. |
| 1749 | if (external_encoder_factory_ != nullptr && |
| 1750 | FindMatchingCodec(external_encoder_factory_->supported_codecs(), codec)) { |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 1751 | webrtc::VideoEncoder* encoder = |
magjed | 1e45cc6 | 2016-10-28 07:43:45 -0700 | [diff] [blame] | 1752 | external_encoder_factory_->CreateVideoEncoder(codec); |
magjed | 509e4fe | 2016-11-18 01:34:11 -0800 | [diff] [blame] | 1753 | if (encoder != nullptr) |
| 1754 | return AllocatedEncoder(encoder, codec, true /* is_external */); |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 1755 | } |
| 1756 | |
magjed | 509e4fe | 2016-11-18 01:34:11 -0800 | [diff] [blame] | 1757 | // Try creating internal encoder. |
| 1758 | InternalEncoderFactory internal_encoder_factory; |
| 1759 | if (FindMatchingCodec(internal_encoder_factory.supported_codecs(), codec)) { |
| 1760 | return AllocatedEncoder(internal_encoder_factory.CreateVideoEncoder(codec), |
| 1761 | codec, false /* is_external */); |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 1762 | } |
| 1763 | |
| 1764 | // This shouldn't happen, we should not be trying to create something we don't |
| 1765 | // support. |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 1766 | RTC_DCHECK(false); |
magjed | 509e4fe | 2016-11-18 01:34:11 -0800 | [diff] [blame] | 1767 | return AllocatedEncoder(NULL, cricket::VideoCodec(), false); |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 1768 | } |
| 1769 | |
| 1770 | void WebRtcVideoChannel2::WebRtcVideoSendStream::DestroyVideoEncoder( |
| 1771 | AllocatedEncoder* encoder) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1772 | RTC_DCHECK_RUN_ON(&thread_checker_); |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 1773 | if (encoder->external) { |
Peter Boström | 4d71ede | 2015-05-19 23:09:35 +0200 | [diff] [blame] | 1774 | external_encoder_factory_->DestroyVideoEncoder(encoder->external_encoder); |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 1775 | } |
Peter Boström | 4d71ede | 2015-05-19 23:09:35 +0200 | [diff] [blame] | 1776 | delete encoder->encoder; |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 1777 | } |
| 1778 | |
nisse | 0db023a | 2016-03-01 04:29:59 -0800 | [diff] [blame] | 1779 | void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodec( |
| 1780 | const VideoCodecSettings& codec_settings) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1781 | RTC_DCHECK_RUN_ON(&thread_checker_); |
skvlad | 3abb764 | 2016-06-16 12:08:03 -0700 | [diff] [blame] | 1782 | parameters_.encoder_config = CreateVideoEncoderConfig(codec_settings.codec); |
kwiberg | af476c7 | 2016-11-28 15:21:39 -0800 | [diff] [blame^] | 1783 | RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0); |
pbos@webrtc.org | a2ef4fe | 2014-11-07 10:54:43 +0000 | [diff] [blame] | 1784 | |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 1785 | AllocatedEncoder new_encoder = CreateVideoEncoder(codec_settings.codec); |
| 1786 | parameters_.config.encoder_settings.encoder = new_encoder.encoder; |
Peter Boström | e449915 | 2016-02-05 11:13:28 +0100 | [diff] [blame] | 1787 | parameters_.config.encoder_settings.full_overuse_time = new_encoder.external; |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1788 | parameters_.config.encoder_settings.payload_name = codec_settings.codec.name; |
| 1789 | parameters_.config.encoder_settings.payload_type = codec_settings.codec.id; |
sophiechang | 47d78cc | 2015-09-03 18:24:44 -0700 | [diff] [blame] | 1790 | if (new_encoder.external) { |
magjed | 10165ab | 2016-11-22 10:16:57 -0800 | [diff] [blame] | 1791 | webrtc::VideoCodecType type = |
| 1792 | webrtc::PayloadNameToCodecType(codec_settings.codec.name) |
| 1793 | .value_or(webrtc::kVideoCodecUnknown); |
sophiechang | 47d78cc | 2015-09-03 18:24:44 -0700 | [diff] [blame] | 1794 | parameters_.config.encoder_settings.internal_source = |
| 1795 | external_encoder_factory_->EncoderTypeHasInternalSource(type); |
| 1796 | } |
brandtr | b5f2c3f | 2016-10-04 23:28:39 -0700 | [diff] [blame] | 1797 | parameters_.config.rtp.ulpfec = codec_settings.ulpfec; |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 1798 | parameters_.config.rtp.flexfec.flexfec_payload_type = |
| 1799 | codec_settings.flexfec.flexfec_payload_type; |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1800 | |
| 1801 | // Set RTX payload type if RTX is enabled. |
| 1802 | if (!parameters_.config.rtp.rtx.ssrcs.empty()) { |
pbos@webrtc.org | b9557a9 | 2015-03-20 19:52:56 +0000 | [diff] [blame] | 1803 | if (codec_settings.rtx_payload_type == -1) { |
| 1804 | LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX " |
| 1805 | "payload type. Ignoring."; |
| 1806 | parameters_.config.rtp.rtx.ssrcs.clear(); |
| 1807 | } else { |
| 1808 | parameters_.config.rtp.rtx.payload_type = codec_settings.rtx_payload_type; |
| 1809 | } |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1810 | } |
| 1811 | |
Peter Boström | 67c9df7 | 2015-05-11 14:34:58 +0200 | [diff] [blame] | 1812 | parameters_.config.rtp.nack.rtp_history_ms = |
| 1813 | HasNack(codec_settings.codec) ? kNackHistoryMs : 0; |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1814 | |
kwiberg | 102c6a6 | 2015-10-30 02:47:38 -0700 | [diff] [blame] | 1815 | parameters_.codec_settings = |
Karl Wiberg | be57983 | 2015-11-10 22:34:18 +0100 | [diff] [blame] | 1816 | rtc::Optional<WebRtcVideoChannel2::VideoCodecSettings>(codec_settings); |
Niels Möller | 60653ba | 2016-03-02 11:41:36 +0100 | [diff] [blame] | 1817 | |
| 1818 | LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetCodec."; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1819 | RecreateWebRtcStream(); |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 1820 | if (allocated_encoder_.encoder != new_encoder.encoder) { |
| 1821 | DestroyVideoEncoder(&allocated_encoder_); |
| 1822 | allocated_encoder_ = new_encoder; |
| 1823 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1824 | } |
| 1825 | |
deadbeef | 1387149 | 2015-12-09 12:37:51 -0800 | [diff] [blame] | 1826 | void WebRtcVideoChannel2::WebRtcVideoSendStream::SetSendParameters( |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 1827 | const ChangedSendParameters& params) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1828 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 1829 | // |recreate_stream| means construction-time parameters have changed and the |
| 1830 | // sending stream needs to be reset with the new config. |
| 1831 | bool recreate_stream = false; |
| 1832 | if (params.rtcp_mode) { |
| 1833 | parameters_.config.rtp.rtcp_mode = *params.rtcp_mode; |
| 1834 | recreate_stream = true; |
| 1835 | } |
| 1836 | if (params.rtp_header_extensions) { |
| 1837 | parameters_.config.rtp.extensions = *params.rtp_header_extensions; |
| 1838 | recreate_stream = true; |
| 1839 | } |
| 1840 | if (params.max_bandwidth_bps) { |
| 1841 | parameters_.max_bitrate_bps = *params.max_bandwidth_bps; |
| 1842 | ReconfigureEncoder(); |
| 1843 | } |
| 1844 | if (params.conference_mode) { |
| 1845 | parameters_.conference_mode = *params.conference_mode; |
| 1846 | } |
perkj | f0dcfe2 | 2016-03-10 18:32:00 +0100 | [diff] [blame] | 1847 | |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1848 | // Set codecs and options. |
| 1849 | if (params.codec) { |
| 1850 | SetCodec(*params.codec); |
| 1851 | recreate_stream = false; // SetCodec has already recreated the stream. |
| 1852 | } else if (params.conference_mode && parameters_.codec_settings) { |
| 1853 | SetCodec(*parameters_.codec_settings); |
| 1854 | recreate_stream = false; // SetCodec has already recreated the stream. |
| 1855 | } |
| 1856 | if (recreate_stream) { |
| 1857 | LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetSendParameters"; |
| 1858 | RecreateWebRtcStream(); |
| 1859 | } |
deadbeef | 1387149 | 2015-12-09 12:37:51 -0800 | [diff] [blame] | 1860 | } |
| 1861 | |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1862 | bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetRtpParameters( |
| 1863 | const webrtc::RtpParameters& new_parameters) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1864 | RTC_DCHECK_RUN_ON(&thread_checker_); |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1865 | if (!ValidateRtpParameters(new_parameters)) { |
| 1866 | return false; |
| 1867 | } |
| 1868 | |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1869 | bool reconfigure_encoder = new_parameters.encodings[0].max_bitrate_bps != |
| 1870 | rtp_parameters_.encodings[0].max_bitrate_bps; |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1871 | rtp_parameters_ = new_parameters; |
Taylor Brandstetter | 0cd086b | 2016-04-20 16:23:10 -0700 | [diff] [blame] | 1872 | // Codecs are currently handled at the WebRtcVideoChannel2 level. |
| 1873 | rtp_parameters_.codecs.clear(); |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1874 | if (reconfigure_encoder) { |
| 1875 | ReconfigureEncoder(); |
| 1876 | } |
deadbeef | dbe2b87 | 2016-03-22 15:42:00 -0700 | [diff] [blame] | 1877 | // Encoding may have been activated/deactivated. |
| 1878 | UpdateSendState(); |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1879 | return true; |
| 1880 | } |
| 1881 | |
deadbeef | dbe2b87 | 2016-03-22 15:42:00 -0700 | [diff] [blame] | 1882 | webrtc::RtpParameters |
| 1883 | WebRtcVideoChannel2::WebRtcVideoSendStream::GetRtpParameters() const { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1884 | RTC_DCHECK_RUN_ON(&thread_checker_); |
deadbeef | dbe2b87 | 2016-03-22 15:42:00 -0700 | [diff] [blame] | 1885 | return rtp_parameters_; |
| 1886 | } |
| 1887 | |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1888 | bool WebRtcVideoChannel2::WebRtcVideoSendStream::ValidateRtpParameters( |
| 1889 | const webrtc::RtpParameters& rtp_parameters) { |
| 1890 | if (rtp_parameters.encodings.size() != 1) { |
| 1891 | LOG(LS_ERROR) |
| 1892 | << "Attempted to set RtpParameters without exactly one encoding"; |
| 1893 | return false; |
| 1894 | } |
| 1895 | return true; |
| 1896 | } |
| 1897 | |
deadbeef | dbe2b87 | 2016-03-22 15:42:00 -0700 | [diff] [blame] | 1898 | void WebRtcVideoChannel2::WebRtcVideoSendStream::UpdateSendState() { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1899 | RTC_DCHECK_RUN_ON(&thread_checker_); |
deadbeef | dbe2b87 | 2016-03-22 15:42:00 -0700 | [diff] [blame] | 1900 | // TODO(deadbeef): Need to handle more than one encoding in the future. |
| 1901 | RTC_DCHECK(rtp_parameters_.encodings.size() == 1u); |
| 1902 | if (sending_ && rtp_parameters_.encodings[0].active) { |
| 1903 | RTC_DCHECK(stream_ != nullptr); |
| 1904 | stream_->Start(); |
| 1905 | } else { |
| 1906 | if (stream_ != nullptr) { |
| 1907 | stream_->Stop(); |
| 1908 | } |
| 1909 | } |
| 1910 | } |
| 1911 | |
pbos@webrtc.org | a2ef4fe | 2014-11-07 10:54:43 +0000 | [diff] [blame] | 1912 | webrtc::VideoEncoderConfig |
| 1913 | WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoderConfig( |
pbos@webrtc.org | a2ef4fe | 2014-11-07 10:54:43 +0000 | [diff] [blame] | 1914 | const VideoCodec& codec) const { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1915 | RTC_DCHECK_RUN_ON(&thread_checker_); |
pbos@webrtc.org | a2ef4fe | 2014-11-07 10:54:43 +0000 | [diff] [blame] | 1916 | webrtc::VideoEncoderConfig encoder_config; |
Niels Möller | 60653ba | 2016-03-02 11:41:36 +0100 | [diff] [blame] | 1917 | bool is_screencast = parameters_.options.is_screencast.value_or(false); |
| 1918 | if (is_screencast) { |
pbos@webrtc.org | efc82c2 | 2014-10-27 13:58:00 +0000 | [diff] [blame] | 1919 | encoder_config.min_transmit_bitrate_bps = |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 1920 | 1000 * parameters_.options.screencast_min_bitrate_kbps.value_or(0); |
Erik Språng | 143cec1 | 2015-04-28 10:01:41 +0200 | [diff] [blame] | 1921 | encoder_config.content_type = |
| 1922 | webrtc::VideoEncoderConfig::ContentType::kScreen; |
pbos@webrtc.org | efc82c2 | 2014-10-27 13:58:00 +0000 | [diff] [blame] | 1923 | } else { |
| 1924 | encoder_config.min_transmit_bitrate_bps = 0; |
Erik Språng | 143cec1 | 2015-04-28 10:01:41 +0200 | [diff] [blame] | 1925 | encoder_config.content_type = |
| 1926 | webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo; |
pbos@webrtc.org | efc82c2 | 2014-10-27 13:58:00 +0000 | [diff] [blame] | 1927 | } |
| 1928 | |
noahric | fdac516 | 2015-08-27 01:59:29 -0700 | [diff] [blame] | 1929 | // By default, the stream count for the codec configuration should match the |
| 1930 | // number of negotiated ssrcs. But if the codec is blacklisted for simulcast |
| 1931 | // or a screencast, only configure a single stream. |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1932 | encoder_config.number_of_streams = parameters_.config.rtp.ssrcs.size(); |
Niels Möller | 60653ba | 2016-03-02 11:41:36 +0100 | [diff] [blame] | 1933 | if (IsCodecBlacklistedForSimulcast(codec.name) || is_screencast) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1934 | encoder_config.number_of_streams = 1; |
noahric | fdac516 | 2015-08-27 01:59:29 -0700 | [diff] [blame] | 1935 | } |
| 1936 | |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1937 | int stream_max_bitrate = |
| 1938 | MinPositive(rtp_parameters_.encodings[0].max_bitrate_bps, |
| 1939 | parameters_.max_bitrate_bps); |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 1940 | |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1941 | int codec_max_bitrate_kbps; |
| 1942 | if (codec.GetParam(kCodecParamMaxBitrate, &codec_max_bitrate_kbps)) { |
| 1943 | stream_max_bitrate = codec_max_bitrate_kbps * 1000; |
| 1944 | } |
| 1945 | encoder_config.max_bitrate_bps = stream_max_bitrate; |
perkj | 3b703ed | 2016-09-29 23:25:40 -0700 | [diff] [blame] | 1946 | |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1947 | int max_qp = kDefaultQpMax; |
| 1948 | codec.GetParam(kCodecParamMaxQuantization, &max_qp); |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1949 | encoder_config.video_stream_factory = |
| 1950 | new rtc::RefCountedObject<EncoderStreamFactory>( |
perkj | 2675274 | 2016-10-24 01:21:16 -0700 | [diff] [blame] | 1951 | codec.name, max_qp, kDefaultVideoMaxFramerate, is_screencast, |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1952 | parameters_.conference_mode); |
pbos@webrtc.org | a2ef4fe | 2014-11-07 10:54:43 +0000 | [diff] [blame] | 1953 | return encoder_config; |
| 1954 | } |
| 1955 | |
skvlad | 3abb764 | 2016-06-16 12:08:03 -0700 | [diff] [blame] | 1956 | void WebRtcVideoChannel2::WebRtcVideoSendStream::ReconfigureEncoder() { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1957 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 1958 | if (!stream_) { |
| 1959 | // The webrtc::VideoSendStream |stream_|has not yet been created but other |
| 1960 | // parameters has changed. |
| 1961 | return; |
| 1962 | } |
| 1963 | |
kwiberg | af476c7 | 2016-11-28 15:21:39 -0800 | [diff] [blame^] | 1964 | RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0); |
pbos@webrtc.org | a2ef4fe | 2014-11-07 10:54:43 +0000 | [diff] [blame] | 1965 | |
kwiberg | 102c6a6 | 2015-10-30 02:47:38 -0700 | [diff] [blame] | 1966 | RTC_CHECK(parameters_.codec_settings); |
| 1967 | VideoCodecSettings codec_settings = *parameters_.codec_settings; |
pbos@webrtc.org | a2ef4fe | 2014-11-07 10:54:43 +0000 | [diff] [blame] | 1968 | |
| 1969 | webrtc::VideoEncoderConfig encoder_config = |
skvlad | 3abb764 | 2016-06-16 12:08:03 -0700 | [diff] [blame] | 1970 | CreateVideoEncoderConfig(codec_settings.codec); |
pbos@webrtc.org | a2ef4fe | 2014-11-07 10:54:43 +0000 | [diff] [blame] | 1971 | |
Erik Språng | 143cec1 | 2015-04-28 10:01:41 +0200 | [diff] [blame] | 1972 | encoder_config.encoder_specific_settings = ConfigureVideoEncoderSettings( |
Niels Möller | 60653ba | 2016-03-02 11:41:36 +0100 | [diff] [blame] | 1973 | codec_settings.codec); |
pbos@webrtc.org | b7ed779 | 2014-10-31 13:08:10 +0000 | [diff] [blame] | 1974 | |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 1975 | stream_->ReconfigureVideoEncoder(encoder_config.Copy()); |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 1976 | |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 1977 | encoder_config.encoder_specific_settings = NULL; |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 1978 | |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 1979 | parameters_.encoder_config = std::move(encoder_config); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1980 | } |
| 1981 | |
deadbeef | dbe2b87 | 2016-03-22 15:42:00 -0700 | [diff] [blame] | 1982 | void WebRtcVideoChannel2::WebRtcVideoSendStream::SetSend(bool send) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1983 | RTC_DCHECK_RUN_ON(&thread_checker_); |
deadbeef | dbe2b87 | 2016-03-22 15:42:00 -0700 | [diff] [blame] | 1984 | sending_ = send; |
| 1985 | UpdateSendState(); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1986 | } |
| 1987 | |
perkj | 803d97f | 2016-11-01 11:45:46 -0700 | [diff] [blame] | 1988 | void WebRtcVideoChannel2::WebRtcVideoSendStream::RemoveSink( |
| 1989 | VideoSinkInterface<webrtc::VideoFrame>* sink) { |
| 1990 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 1991 | { |
| 1992 | rtc::CritScope cs(&lock_); |
| 1993 | RTC_DCHECK(encoder_sink_ == sink); |
| 1994 | encoder_sink_ = nullptr; |
| 1995 | } |
| 1996 | source_->RemoveSink(this); |
| 1997 | } |
| 1998 | |
perkj | a49cbd3 | 2016-09-16 07:53:41 -0700 | [diff] [blame] | 1999 | void WebRtcVideoChannel2::WebRtcVideoSendStream::AddOrUpdateSink( |
| 2000 | VideoSinkInterface<webrtc::VideoFrame>* sink, |
| 2001 | const rtc::VideoSinkWants& wants) { |
perkj | 803d97f | 2016-11-01 11:45:46 -0700 | [diff] [blame] | 2002 | if (worker_thread_ == rtc::Thread::Current()) { |
| 2003 | // AddOrUpdateSink is called on |worker_thread_| if this is the first |
| 2004 | // registration of |sink|. |
| 2005 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 2006 | { |
| 2007 | rtc::CritScope cs(&lock_); |
| 2008 | encoder_sink_ = sink; |
perkj | 2d5f091 | 2016-02-29 00:04:41 -0800 | [diff] [blame] | 2009 | } |
perkj | 803d97f | 2016-11-01 11:45:46 -0700 | [diff] [blame] | 2010 | source_->AddOrUpdateSink(this, wants); |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2011 | } else { |
perkj | 803d97f | 2016-11-01 11:45:46 -0700 | [diff] [blame] | 2012 | // Subsequent calls to AddOrUpdateSink will happen on the encoder task |
| 2013 | // queue. |
| 2014 | invoker_.AsyncInvoke<void>(RTC_FROM_HERE, worker_thread_, [this, wants] { |
| 2015 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 2016 | bool encoder_sink_valid = true; |
| 2017 | { |
| 2018 | rtc::CritScope cs(&lock_); |
| 2019 | encoder_sink_valid = encoder_sink_ != nullptr; |
| 2020 | } |
| 2021 | // Since |source_| is still valid after a call to RemoveSink, check if |
| 2022 | // |encoder_sink_| is still valid to check if this call should be |
| 2023 | // cancelled. |
| 2024 | if (source_ && encoder_sink_valid) { |
| 2025 | source_->AddOrUpdateSink(this, wants); |
| 2026 | } |
| 2027 | }); |
perkj | 2d5f091 | 2016-02-29 00:04:41 -0800 | [diff] [blame] | 2028 | } |
perkj | 2d5f091 | 2016-02-29 00:04:41 -0800 | [diff] [blame] | 2029 | } |
| 2030 | |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 2031 | VideoSenderInfo WebRtcVideoChannel2::WebRtcVideoSendStream::GetVideoSenderInfo( |
| 2032 | bool log_stats) { |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2033 | VideoSenderInfo info; |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2034 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 2035 | for (uint32_t ssrc : parameters_.config.rtp.ssrcs) |
| 2036 | info.add_ssrc(ssrc); |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2037 | |
hbos | a65704b | 2016-11-14 02:28:16 -0800 | [diff] [blame] | 2038 | if (parameters_.codec_settings) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2039 | info.codec_name = parameters_.codec_settings->codec.name; |
hbos | 1acfbd2 | 2016-11-17 23:43:29 -0800 | [diff] [blame] | 2040 | info.codec_payload_type = rtc::Optional<int>( |
| 2041 | parameters_.codec_settings->codec.id); |
hbos | a65704b | 2016-11-14 02:28:16 -0800 | [diff] [blame] | 2042 | } |
pbos@webrtc.org | c3d2bd2 | 2014-08-12 20:55:10 +0000 | [diff] [blame] | 2043 | |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2044 | if (stream_ == NULL) |
| 2045 | return info; |
pbos@webrtc.org | 77e11bb | 2015-02-23 16:39:07 +0000 | [diff] [blame] | 2046 | |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2047 | webrtc::VideoSendStream::Stats stats = stream_->GetStats(); |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 2048 | |
| 2049 | if (log_stats) |
| 2050 | LOG(LS_INFO) << stats.ToString(rtc::TimeMillis()); |
| 2051 | |
perkj | 803d97f | 2016-11-01 11:45:46 -0700 | [diff] [blame] | 2052 | info.adapt_changes = stats.number_of_cpu_adapt_changes; |
Per | 766ad3b | 2016-04-05 15:23:49 +0200 | [diff] [blame] | 2053 | info.adapt_reason = |
perkj | 803d97f | 2016-11-01 11:45:46 -0700 | [diff] [blame] | 2054 | stats.cpu_limited_resolution ? ADAPTREASON_CPU : ADAPTREASON_NONE; |
pbos@webrtc.org | 77e11bb | 2015-02-23 16:39:07 +0000 | [diff] [blame] | 2055 | |
asapersson | 17821db | 2015-12-14 02:08:12 -0800 | [diff] [blame] | 2056 | // Get bandwidth limitation info from stream_->GetStats(). |
| 2057 | // Input resolution (output from video_adapter) can be further scaled down or |
| 2058 | // higher video layer(s) can be dropped due to bitrate constraints. |
| 2059 | // Note, adapt_changes only include changes from the video_adapter. |
| 2060 | if (stats.bw_limited_resolution) |
Per | 766ad3b | 2016-04-05 15:23:49 +0200 | [diff] [blame] | 2061 | info.adapt_reason |= ADAPTREASON_BANDWIDTH; |
asapersson | 17821db | 2015-12-14 02:08:12 -0800 | [diff] [blame] | 2062 | |
Peter Boström | b7d9a97 | 2015-12-18 16:01:11 +0100 | [diff] [blame] | 2063 | info.encoder_implementation_name = stats.encoder_implementation_name; |
Peter Boström | 259bd20 | 2015-05-28 13:39:50 +0200 | [diff] [blame] | 2064 | info.ssrc_groups = ssrc_groups_; |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2065 | info.framerate_input = stats.input_frame_rate; |
| 2066 | info.framerate_sent = stats.encode_frame_rate; |
pbos@webrtc.org | 3e6e271 | 2015-02-26 12:19:31 +0000 | [diff] [blame] | 2067 | info.avg_encode_ms = stats.avg_encode_time_ms; |
| 2068 | info.encode_usage_percent = stats.encode_usage_percent; |
sakal | 43536c3 | 2016-10-24 01:46:43 -0700 | [diff] [blame] | 2069 | info.frames_encoded = stats.frames_encoded; |
sakal | 87da404 | 2016-10-31 06:53:47 -0700 | [diff] [blame] | 2070 | info.qp_sum = stats.qp_sum; |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2071 | |
pbos@webrtc.org | 77e11bb | 2015-02-23 16:39:07 +0000 | [diff] [blame] | 2072 | info.nominal_bitrate = stats.media_bitrate_bps; |
Per | a48ddb7 | 2016-09-29 11:48:50 +0200 | [diff] [blame] | 2073 | info.preferred_bitrate = stats.preferred_media_bitrate_bps; |
pbos@webrtc.org | 77e11bb | 2015-02-23 16:39:07 +0000 | [diff] [blame] | 2074 | |
pbos@webrtc.org | 273a414 | 2014-12-01 15:23:21 +0000 | [diff] [blame] | 2075 | info.send_frame_width = 0; |
| 2076 | info.send_frame_height = 0; |
pbos@webrtc.org | 09c77b9 | 2015-02-25 10:42:16 +0000 | [diff] [blame] | 2077 | for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it = |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2078 | stats.substreams.begin(); |
pbos@webrtc.org | 09c77b9 | 2015-02-25 10:42:16 +0000 | [diff] [blame] | 2079 | it != stats.substreams.end(); ++it) { |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2080 | // TODO(pbos): Wire up additional stats, such as padding bytes. |
pbos@webrtc.org | 09c77b9 | 2015-02-25 10:42:16 +0000 | [diff] [blame] | 2081 | webrtc::VideoSendStream::StreamStats stream_stats = it->second; |
asapersson@webrtc.org | cfd82df | 2015-01-22 09:39:59 +0000 | [diff] [blame] | 2082 | info.bytes_sent += stream_stats.rtp_stats.transmitted.payload_bytes + |
| 2083 | stream_stats.rtp_stats.transmitted.header_bytes + |
| 2084 | stream_stats.rtp_stats.transmitted.padding_bytes; |
| 2085 | info.packets_sent += stream_stats.rtp_stats.transmitted.packets; |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2086 | info.packets_lost += stream_stats.rtcp_stats.cumulative_lost; |
pbos@webrtc.org | 09c77b9 | 2015-02-25 10:42:16 +0000 | [diff] [blame] | 2087 | if (stream_stats.width > info.send_frame_width) |
| 2088 | info.send_frame_width = stream_stats.width; |
| 2089 | if (stream_stats.height > info.send_frame_height) |
| 2090 | info.send_frame_height = stream_stats.height; |
pbos@webrtc.org | 1d0fa5d | 2015-02-19 12:47:00 +0000 | [diff] [blame] | 2091 | info.firs_rcvd += stream_stats.rtcp_packet_type_counts.fir_packets; |
| 2092 | info.nacks_rcvd += stream_stats.rtcp_packet_type_counts.nack_packets; |
| 2093 | info.plis_rcvd += stream_stats.rtcp_packet_type_counts.pli_packets; |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2094 | } |
| 2095 | |
| 2096 | if (!stats.substreams.empty()) { |
| 2097 | // TODO(pbos): Report fraction lost per SSRC. |
pbos@webrtc.org | 09c77b9 | 2015-02-25 10:42:16 +0000 | [diff] [blame] | 2098 | webrtc::VideoSendStream::StreamStats first_stream_stats = |
| 2099 | stats.substreams.begin()->second; |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2100 | info.fraction_lost = |
| 2101 | static_cast<float>(first_stream_stats.rtcp_stats.fraction_lost) / |
| 2102 | (1 << 8); |
| 2103 | } |
| 2104 | |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2105 | return info; |
| 2106 | } |
| 2107 | |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 2108 | void WebRtcVideoChannel2::WebRtcVideoSendStream::FillBandwidthEstimationInfo( |
| 2109 | BandwidthEstimationInfo* bwe_info) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2110 | RTC_DCHECK_RUN_ON(&thread_checker_); |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 2111 | if (stream_ == NULL) { |
| 2112 | return; |
| 2113 | } |
| 2114 | webrtc::VideoSendStream::Stats stats = stream_->GetStats(); |
pbos@webrtc.org | 09c77b9 | 2015-02-25 10:42:16 +0000 | [diff] [blame] | 2115 | for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it = |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 2116 | stats.substreams.begin(); |
pbos@webrtc.org | 09c77b9 | 2015-02-25 10:42:16 +0000 | [diff] [blame] | 2117 | it != stats.substreams.end(); ++it) { |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 2118 | bwe_info->transmit_bitrate += it->second.total_bitrate_bps; |
| 2119 | bwe_info->retransmit_bitrate += it->second.retransmit_bitrate_bps; |
| 2120 | } |
pbos@webrtc.org | 891d483 | 2015-02-26 13:15:22 +0000 | [diff] [blame] | 2121 | bwe_info->target_enc_bitrate += stats.target_media_bitrate_bps; |
pbos@webrtc.org | 77e11bb | 2015-02-23 16:39:07 +0000 | [diff] [blame] | 2122 | bwe_info->actual_enc_bitrate += stats.media_bitrate_bps; |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 2123 | } |
| 2124 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2125 | void WebRtcVideoChannel2::WebRtcVideoSendStream::RecreateWebRtcStream() { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2126 | RTC_DCHECK_RUN_ON(&thread_checker_); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2127 | if (stream_ != NULL) { |
| 2128 | call_->DestroyVideoSendStream(stream_); |
| 2129 | } |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 2130 | |
kwiberg | 102c6a6 | 2015-10-30 02:47:38 -0700 | [diff] [blame] | 2131 | RTC_CHECK(parameters_.codec_settings); |
Niels Möller | 60653ba | 2016-03-02 11:41:36 +0100 | [diff] [blame] | 2132 | RTC_DCHECK_EQ((parameters_.encoder_config.content_type == |
| 2133 | webrtc::VideoEncoderConfig::ContentType::kScreen), |
| 2134 | parameters_.options.is_screencast.value_or(false)) |
| 2135 | << "encoder content type inconsistent with screencast option"; |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 2136 | parameters_.encoder_config.encoder_specific_settings = |
Niels Möller | 60653ba | 2016-03-02 11:41:36 +0100 | [diff] [blame] | 2137 | ConfigureVideoEncoderSettings(parameters_.codec_settings->codec); |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 2138 | |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 2139 | webrtc::VideoSendStream::Config config = parameters_.config.Copy(); |
pbos@webrtc.org | b9557a9 | 2015-03-20 19:52:56 +0000 | [diff] [blame] | 2140 | if (!config.rtp.rtx.ssrcs.empty() && config.rtp.rtx.payload_type == -1) { |
| 2141 | LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX " |
| 2142 | "payload type the set codec. Ignoring RTX."; |
| 2143 | config.rtp.rtx.ssrcs.clear(); |
| 2144 | } |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 2145 | stream_ = call_->CreateVideoSendStream(std::move(config), |
| 2146 | parameters_.encoder_config.Copy()); |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 2147 | |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 2148 | parameters_.encoder_config.encoder_specific_settings = NULL; |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 2149 | |
perkj | 803d97f | 2016-11-01 11:45:46 -0700 | [diff] [blame] | 2150 | if (source_) { |
| 2151 | // TODO(perkj, nisse): Remove |source_| and directly call |
| 2152 | // |stream_|->SetSource(source) once the video frame types have been |
| 2153 | // merged and |stream_| internally reconfigure the encoder on frame |
| 2154 | // resolution change. |
| 2155 | // Do not adapt resolution for screen content as this will likely result in |
| 2156 | // blurry and unreadable text. |
| 2157 | stream_->SetSource( |
| 2158 | this, enable_cpu_overuse_detection_ && |
| 2159 | !parameters_.options.is_screencast.value_or(false) |
| 2160 | ? webrtc::VideoSendStream::DegradationPreference::kBalanced |
| 2161 | : webrtc::VideoSendStream::DegradationPreference:: |
| 2162 | kMaintainResolution); |
| 2163 | } |
| 2164 | |
Taylor Brandstetter | 14b9d79 | 2016-09-07 17:16:54 -0700 | [diff] [blame] | 2165 | // Call stream_->Start() if necessary conditions are met. |
| 2166 | UpdateSendState(); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2167 | } |
| 2168 | |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2169 | WebRtcVideoChannel2::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream( |
| 2170 | webrtc::Call* call, |
Peter Boström | 259bd20 | 2015-05-28 13:39:50 +0200 | [diff] [blame] | 2171 | const StreamParams& sp, |
Tommi | 733b547 | 2016-06-10 17:58:01 +0200 | [diff] [blame] | 2172 | webrtc::VideoReceiveStream::Config config, |
pbos@webrtc.org | 776e6f2 | 2014-10-29 15:28:39 +0000 | [diff] [blame] | 2173 | WebRtcVideoDecoderFactory* external_decoder_factory, |
pbos@webrtc.org | a2a6fe6 | 2015-03-06 15:35:19 +0000 | [diff] [blame] | 2174 | bool default_stream, |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 2175 | const std::vector<VideoCodecSettings>& recv_codecs, |
| 2176 | const webrtc::FlexfecConfig& flexfec_config) |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2177 | : call_(call), |
sakal | 1fd9595 | 2016-06-22 00:46:15 -0700 | [diff] [blame] | 2178 | stream_params_(sp), |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2179 | stream_(NULL), |
pbos@webrtc.org | a2a6fe6 | 2015-03-06 15:35:19 +0000 | [diff] [blame] | 2180 | default_stream_(default_stream), |
Tommi | 733b547 | 2016-06-10 17:58:01 +0200 | [diff] [blame] | 2181 | config_(std::move(config)), |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 2182 | flexfec_config_(flexfec_config), |
| 2183 | flexfec_stream_(nullptr), |
pbos@webrtc.org | 776e6f2 | 2014-10-29 15:28:39 +0000 | [diff] [blame] | 2184 | external_decoder_factory_(external_decoder_factory), |
nisse | e73afba | 2016-01-28 04:47:08 -0800 | [diff] [blame] | 2185 | sink_(NULL), |
magjed@webrtc.org | fc5ad95 | 2015-01-27 09:57:01 +0000 | [diff] [blame] | 2186 | first_frame_timestamp_(-1), |
| 2187 | estimated_remote_start_ntp_time_ms_(0) { |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2188 | config_.renderer = this; |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 2189 | std::vector<AllocatedDecoder> old_decoders; |
| 2190 | ConfigureCodecs(recv_codecs, &old_decoders); |
| 2191 | RecreateWebRtcStream(); |
| 2192 | RTC_DCHECK(old_decoders.empty()); |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2193 | } |
| 2194 | |
Peter Boström | 7252a2b | 2015-05-18 19:42:03 +0200 | [diff] [blame] | 2195 | WebRtcVideoChannel2::WebRtcVideoReceiveStream::AllocatedDecoder:: |
| 2196 | AllocatedDecoder(webrtc::VideoDecoder* decoder, |
| 2197 | webrtc::VideoCodecType type, |
| 2198 | bool external) |
| 2199 | : decoder(decoder), |
| 2200 | external_decoder(nullptr), |
| 2201 | type(type), |
| 2202 | external(external) { |
| 2203 | if (external) { |
| 2204 | external_decoder = decoder; |
| 2205 | this->decoder = |
| 2206 | new webrtc::VideoDecoderSoftwareFallbackWrapper(type, external_decoder); |
| 2207 | } |
| 2208 | } |
| 2209 | |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2210 | WebRtcVideoChannel2::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() { |
| 2211 | call_->DestroyVideoReceiveStream(stream_); |
pbos@webrtc.org | 96a9325 | 2014-11-03 14:46:44 +0000 | [diff] [blame] | 2212 | ClearDecoders(&allocated_decoders_); |
| 2213 | } |
| 2214 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 2215 | const std::vector<uint32_t>& |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 2216 | WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetSsrcs() const { |
sakal | 1fd9595 | 2016-06-22 00:46:15 -0700 | [diff] [blame] | 2217 | return stream_params_.ssrcs; |
| 2218 | } |
| 2219 | |
| 2220 | rtc::Optional<uint32_t> |
| 2221 | WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetFirstPrimarySsrc() const { |
| 2222 | std::vector<uint32_t> primary_ssrcs; |
| 2223 | stream_params_.GetPrimarySsrcs(&primary_ssrcs); |
| 2224 | |
| 2225 | if (primary_ssrcs.empty()) { |
| 2226 | LOG(LS_WARNING) << "Empty primary ssrcs vector, returning empty optional"; |
| 2227 | return rtc::Optional<uint32_t>(); |
| 2228 | } else { |
| 2229 | return rtc::Optional<uint32_t>(primary_ssrcs[0]); |
| 2230 | } |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 2231 | } |
| 2232 | |
pbos@webrtc.org | 96a9325 | 2014-11-03 14:46:44 +0000 | [diff] [blame] | 2233 | WebRtcVideoChannel2::WebRtcVideoReceiveStream::AllocatedDecoder |
| 2234 | WebRtcVideoChannel2::WebRtcVideoReceiveStream::CreateOrReuseVideoDecoder( |
| 2235 | std::vector<AllocatedDecoder>* old_decoders, |
| 2236 | const VideoCodec& codec) { |
magjed | 10165ab | 2016-11-22 10:16:57 -0800 | [diff] [blame] | 2237 | webrtc::VideoCodecType type = webrtc::PayloadNameToCodecType(codec.name) |
| 2238 | .value_or(webrtc::kVideoCodecUnknown); |
pbos@webrtc.org | 96a9325 | 2014-11-03 14:46:44 +0000 | [diff] [blame] | 2239 | |
| 2240 | for (size_t i = 0; i < old_decoders->size(); ++i) { |
| 2241 | if ((*old_decoders)[i].type == type) { |
| 2242 | AllocatedDecoder decoder = (*old_decoders)[i]; |
| 2243 | (*old_decoders)[i] = old_decoders->back(); |
| 2244 | old_decoders->pop_back(); |
| 2245 | return decoder; |
| 2246 | } |
| 2247 | } |
| 2248 | |
| 2249 | if (external_decoder_factory_ != NULL) { |
| 2250 | webrtc::VideoDecoder* decoder = |
sakal | 1fd9595 | 2016-06-22 00:46:15 -0700 | [diff] [blame] | 2251 | external_decoder_factory_->CreateVideoDecoderWithParams( |
| 2252 | type, {stream_params_.id}); |
pbos@webrtc.org | 96a9325 | 2014-11-03 14:46:44 +0000 | [diff] [blame] | 2253 | if (decoder != NULL) { |
| 2254 | return AllocatedDecoder(decoder, type, true); |
| 2255 | } |
| 2256 | } |
| 2257 | |
| 2258 | if (type == webrtc::kVideoCodecVP8) { |
| 2259 | return AllocatedDecoder( |
| 2260 | webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kVp8), type, false); |
| 2261 | } |
| 2262 | |
pbos@webrtc.org | b9557a9 | 2015-03-20 19:52:56 +0000 | [diff] [blame] | 2263 | if (type == webrtc::kVideoCodecVP9) { |
| 2264 | return AllocatedDecoder( |
| 2265 | webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kVp9), type, false); |
| 2266 | } |
| 2267 | |
Zeke Chin | 71f6f44 | 2015-06-29 14:34:58 -0700 | [diff] [blame] | 2268 | if (type == webrtc::kVideoCodecH264) { |
| 2269 | return AllocatedDecoder( |
| 2270 | webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kH264), type, false); |
| 2271 | } |
| 2272 | |
jbauch | e03ac51 | 2016-02-03 05:51:48 -0800 | [diff] [blame] | 2273 | return AllocatedDecoder( |
| 2274 | webrtc::VideoDecoder::Create(webrtc::VideoDecoder::kUnsupportedCodec), |
| 2275 | webrtc::kVideoCodecUnknown, false); |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2276 | } |
| 2277 | |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 2278 | void WebRtcVideoChannel2::WebRtcVideoReceiveStream::ConfigureCodecs( |
| 2279 | const std::vector<VideoCodecSettings>& recv_codecs, |
| 2280 | std::vector<AllocatedDecoder>* old_decoders) { |
| 2281 | *old_decoders = allocated_decoders_; |
pbos@webrtc.org | 96a9325 | 2014-11-03 14:46:44 +0000 | [diff] [blame] | 2282 | allocated_decoders_.clear(); |
| 2283 | config_.decoders.clear(); |
| 2284 | for (size_t i = 0; i < recv_codecs.size(); ++i) { |
| 2285 | AllocatedDecoder allocated_decoder = |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 2286 | CreateOrReuseVideoDecoder(old_decoders, recv_codecs[i].codec); |
pbos@webrtc.org | 96a9325 | 2014-11-03 14:46:44 +0000 | [diff] [blame] | 2287 | allocated_decoders_.push_back(allocated_decoder); |
| 2288 | |
| 2289 | webrtc::VideoReceiveStream::Decoder decoder; |
| 2290 | decoder.decoder = allocated_decoder.decoder; |
| 2291 | decoder.payload_type = recv_codecs[i].codec.id; |
| 2292 | decoder.payload_name = recv_codecs[i].codec.name; |
magjed | 5dfac56 | 2016-11-25 03:56:37 -0800 | [diff] [blame] | 2293 | decoder.codec_params = recv_codecs[i].codec.params; |
pbos@webrtc.org | 96a9325 | 2014-11-03 14:46:44 +0000 | [diff] [blame] | 2294 | config_.decoders.push_back(decoder); |
| 2295 | } |
| 2296 | |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2297 | // TODO(pbos): Reconfigure RTX based on incoming recv_codecs. |
brandtr | b5f2c3f | 2016-10-04 23:28:39 -0700 | [diff] [blame] | 2298 | config_.rtp.ulpfec = recv_codecs.front().ulpfec; |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 2299 | flexfec_config_.flexfec_payload_type = |
| 2300 | recv_codecs.front().flexfec.flexfec_payload_type; |
pbos@webrtc.org | 257e130 | 2014-07-25 19:01:32 +0000 | [diff] [blame] | 2301 | config_.rtp.nack.rtp_history_ms = |
Shao Changbin | e62202f | 2015-04-21 20:24:50 +0800 | [diff] [blame] | 2302 | HasNack(recv_codecs.begin()->codec) ? kNackHistoryMs : 0; |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2303 | } |
| 2304 | |
Peter Boström | 3548dd2 | 2015-05-22 18:48:36 +0200 | [diff] [blame] | 2305 | void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetLocalSsrc( |
| 2306 | uint32_t local_ssrc) { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 2307 | // TODO(pbos): Consider turning this sanity check into a RTC_DCHECK. You |
| 2308 | // should not be able to create a sender with the same SSRC as a receiver, but |
| 2309 | // right now this can't be done due to unittests depending on receiving what |
| 2310 | // they are sending from the same MediaChannel. |
deadbeef | 874ca3a | 2015-08-20 17:19:20 -0700 | [diff] [blame] | 2311 | if (local_ssrc == config_.rtp.remote_ssrc) { |
| 2312 | LOG(LS_INFO) << "Ignoring call to SetLocalSsrc because parameters are " |
| 2313 | "unchanged; local_ssrc=" << local_ssrc; |
Peter Boström | 3548dd2 | 2015-05-22 18:48:36 +0200 | [diff] [blame] | 2314 | return; |
deadbeef | 874ca3a | 2015-08-20 17:19:20 -0700 | [diff] [blame] | 2315 | } |
Peter Boström | 3548dd2 | 2015-05-22 18:48:36 +0200 | [diff] [blame] | 2316 | |
| 2317 | config_.rtp.local_ssrc = local_ssrc; |
deadbeef | 874ca3a | 2015-08-20 17:19:20 -0700 | [diff] [blame] | 2318 | LOG(LS_INFO) |
| 2319 | << "RecreateWebRtcStream (recv) because of SetLocalSsrc; local_ssrc=" |
| 2320 | << local_ssrc; |
Peter Boström | 3548dd2 | 2015-05-22 18:48:36 +0200 | [diff] [blame] | 2321 | RecreateWebRtcStream(); |
| 2322 | } |
| 2323 | |
stefan | 43edf0f | 2015-11-20 18:05:48 -0800 | [diff] [blame] | 2324 | void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetFeedbackParameters( |
| 2325 | bool nack_enabled, |
| 2326 | bool remb_enabled, |
Taylor Brandstetter | 5f0b83b | 2016-03-18 15:02:07 -0700 | [diff] [blame] | 2327 | bool transport_cc_enabled, |
| 2328 | webrtc::RtcpMode rtcp_mode) { |
Peter Boström | 67c9df7 | 2015-05-11 14:34:58 +0200 | [diff] [blame] | 2329 | int nack_history_ms = nack_enabled ? kNackHistoryMs : 0; |
| 2330 | if (config_.rtp.nack.rtp_history_ms == nack_history_ms && |
stefan | 43edf0f | 2015-11-20 18:05:48 -0800 | [diff] [blame] | 2331 | config_.rtp.remb == remb_enabled && |
Taylor Brandstetter | 5f0b83b | 2016-03-18 15:02:07 -0700 | [diff] [blame] | 2332 | config_.rtp.transport_cc == transport_cc_enabled && |
| 2333 | config_.rtp.rtcp_mode == rtcp_mode) { |
stefan | 43edf0f | 2015-11-20 18:05:48 -0800 | [diff] [blame] | 2334 | LOG(LS_INFO) |
| 2335 | << "Ignoring call to SetFeedbackParameters because parameters are " |
| 2336 | "unchanged; nack=" |
| 2337 | << nack_enabled << ", remb=" << remb_enabled |
| 2338 | << ", transport_cc=" << transport_cc_enabled; |
Peter Boström | 126c03e | 2015-05-11 12:48:12 +0200 | [diff] [blame] | 2339 | return; |
Peter Boström | 67c9df7 | 2015-05-11 14:34:58 +0200 | [diff] [blame] | 2340 | } |
| 2341 | config_.rtp.remb = remb_enabled; |
| 2342 | config_.rtp.nack.rtp_history_ms = nack_history_ms; |
stefan | 43edf0f | 2015-11-20 18:05:48 -0800 | [diff] [blame] | 2343 | config_.rtp.transport_cc = transport_cc_enabled; |
Taylor Brandstetter | 5f0b83b | 2016-03-18 15:02:07 -0700 | [diff] [blame] | 2344 | config_.rtp.rtcp_mode = rtcp_mode; |
stefan | 43edf0f | 2015-11-20 18:05:48 -0800 | [diff] [blame] | 2345 | LOG(LS_INFO) |
| 2346 | << "RecreateWebRtcStream (recv) because of SetFeedbackParameters; nack=" |
| 2347 | << nack_enabled << ", remb=" << remb_enabled |
| 2348 | << ", transport_cc=" << transport_cc_enabled; |
Peter Boström | 126c03e | 2015-05-11 12:48:12 +0200 | [diff] [blame] | 2349 | RecreateWebRtcStream(); |
| 2350 | } |
| 2351 | |
deadbeef | 1387149 | 2015-12-09 12:37:51 -0800 | [diff] [blame] | 2352 | void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRecvParameters( |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 2353 | const ChangedRecvParameters& params) { |
| 2354 | bool needs_recreation = false; |
| 2355 | std::vector<AllocatedDecoder> old_decoders; |
| 2356 | if (params.codec_settings) { |
| 2357 | ConfigureCodecs(*params.codec_settings, &old_decoders); |
| 2358 | needs_recreation = true; |
| 2359 | } |
| 2360 | if (params.rtp_header_extensions) { |
| 2361 | config_.rtp.extensions = *params.rtp_header_extensions; |
| 2362 | needs_recreation = true; |
| 2363 | } |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 2364 | if (needs_recreation) { |
| 2365 | LOG(LS_INFO) << "RecreateWebRtcStream (recv) because of SetRecvParameters"; |
| 2366 | RecreateWebRtcStream(); |
| 2367 | ClearDecoders(&old_decoders); |
| 2368 | } |
deadbeef | 1387149 | 2015-12-09 12:37:51 -0800 | [diff] [blame] | 2369 | } |
| 2370 | |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2371 | void WebRtcVideoChannel2::WebRtcVideoReceiveStream::RecreateWebRtcStream() { |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 2372 | if (flexfec_stream_) { |
| 2373 | call_->DestroyFlexfecReceiveStream(flexfec_stream_); |
| 2374 | flexfec_stream_ = nullptr; |
| 2375 | } |
| 2376 | if (stream_) { |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2377 | call_->DestroyVideoReceiveStream(stream_); |
| 2378 | } |
brandtr | e6f98c7 | 2016-11-11 03:28:30 -0800 | [diff] [blame] | 2379 | stream_ = call_->CreateVideoReceiveStream(config_.Copy()); |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2380 | stream_->Start(); |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 2381 | if (IsFlexfecFieldTrialEnabled() && flexfec_config_.IsCompleteAndEnabled()) { |
| 2382 | flexfec_stream_ = call_->CreateFlexfecReceiveStream(flexfec_config_); |
| 2383 | flexfec_stream_->Start(); |
| 2384 | } |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2385 | } |
| 2386 | |
pbos@webrtc.org | 96a9325 | 2014-11-03 14:46:44 +0000 | [diff] [blame] | 2387 | void WebRtcVideoChannel2::WebRtcVideoReceiveStream::ClearDecoders( |
| 2388 | std::vector<AllocatedDecoder>* allocated_decoders) { |
| 2389 | for (size_t i = 0; i < allocated_decoders->size(); ++i) { |
| 2390 | if ((*allocated_decoders)[i].external) { |
pbos@webrtc.org | 776e6f2 | 2014-10-29 15:28:39 +0000 | [diff] [blame] | 2391 | external_decoder_factory_->DestroyVideoDecoder( |
Peter Boström | 7252a2b | 2015-05-18 19:42:03 +0200 | [diff] [blame] | 2392 | (*allocated_decoders)[i].external_decoder); |
pbos@webrtc.org | 776e6f2 | 2014-10-29 15:28:39 +0000 | [diff] [blame] | 2393 | } |
Peter Boström | 7252a2b | 2015-05-18 19:42:03 +0200 | [diff] [blame] | 2394 | delete (*allocated_decoders)[i].decoder; |
pbos@webrtc.org | 776e6f2 | 2014-10-29 15:28:39 +0000 | [diff] [blame] | 2395 | } |
pbos@webrtc.org | 96a9325 | 2014-11-03 14:46:44 +0000 | [diff] [blame] | 2396 | allocated_decoders->clear(); |
pbos@webrtc.org | 776e6f2 | 2014-10-29 15:28:39 +0000 | [diff] [blame] | 2397 | } |
| 2398 | |
nisse | eb83a1a | 2016-03-21 01:27:56 -0700 | [diff] [blame] | 2399 | void WebRtcVideoChannel2::WebRtcVideoReceiveStream::OnFrame( |
| 2400 | const webrtc::VideoFrame& frame) { |
nisse | e73afba | 2016-01-28 04:47:08 -0800 | [diff] [blame] | 2401 | rtc::CritScope crit(&sink_lock_); |
magjed@webrtc.org | fc5ad95 | 2015-01-27 09:57:01 +0000 | [diff] [blame] | 2402 | |
| 2403 | if (first_frame_timestamp_ < 0) |
| 2404 | first_frame_timestamp_ = frame.timestamp(); |
| 2405 | int64_t rtp_time_elapsed_since_first_frame = |
| 2406 | (timestamp_wraparound_handler_.Unwrap(frame.timestamp()) - |
| 2407 | first_frame_timestamp_); |
| 2408 | int64_t elapsed_time_ms = rtp_time_elapsed_since_first_frame / |
| 2409 | (cricket::kVideoCodecClockrate / 1000); |
| 2410 | if (frame.ntp_time_ms() > 0) |
| 2411 | estimated_remote_start_ntp_time_ms_ = frame.ntp_time_ms() - elapsed_time_ms; |
| 2412 | |
nisse | e73afba | 2016-01-28 04:47:08 -0800 | [diff] [blame] | 2413 | if (sink_ == NULL) { |
| 2414 | LOG(LS_WARNING) << "VideoReceiveStream not connected to a VideoSink."; |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2415 | return; |
| 2416 | } |
| 2417 | |
nisse | 0934785 | 2016-10-19 00:30:30 -0700 | [diff] [blame] | 2418 | sink_->OnFrame(frame); |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2419 | } |
| 2420 | |
pbos@webrtc.org | a2a6fe6 | 2015-03-06 15:35:19 +0000 | [diff] [blame] | 2421 | bool WebRtcVideoChannel2::WebRtcVideoReceiveStream::IsDefaultStream() const { |
| 2422 | return default_stream_; |
| 2423 | } |
| 2424 | |
nisse | e73afba | 2016-01-28 04:47:08 -0800 | [diff] [blame] | 2425 | void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetSink( |
nisse | acd935b | 2016-11-11 03:55:13 -0800 | [diff] [blame] | 2426 | rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) { |
nisse | e73afba | 2016-01-28 04:47:08 -0800 | [diff] [blame] | 2427 | rtc::CritScope crit(&sink_lock_); |
| 2428 | sink_ = sink; |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2429 | } |
| 2430 | |
pbos | f42376c | 2015-08-28 07:35:32 -0700 | [diff] [blame] | 2431 | std::string |
| 2432 | WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetCodecNameFromPayloadType( |
| 2433 | int payload_type) { |
| 2434 | for (const webrtc::VideoReceiveStream::Decoder& decoder : config_.decoders) { |
| 2435 | if (decoder.payload_type == payload_type) { |
| 2436 | return decoder.payload_name; |
| 2437 | } |
| 2438 | } |
| 2439 | return ""; |
| 2440 | } |
| 2441 | |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2442 | VideoReceiverInfo |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 2443 | WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetVideoReceiverInfo( |
| 2444 | bool log_stats) { |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2445 | VideoReceiverInfo info; |
sakal | 1fd9595 | 2016-06-22 00:46:15 -0700 | [diff] [blame] | 2446 | info.ssrc_groups = stream_params_.ssrc_groups; |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2447 | info.add_ssrc(config_.rtp.remote_ssrc); |
| 2448 | webrtc::VideoReceiveStream::Stats stats = stream_->GetStats(); |
Peter Boström | b7d9a97 | 2015-12-18 16:01:11 +0100 | [diff] [blame] | 2449 | info.decoder_implementation_name = stats.decoder_implementation_name; |
hbos | a65704b | 2016-11-14 02:28:16 -0800 | [diff] [blame] | 2450 | if (stats.current_payload_type != -1) { |
hbos | 1acfbd2 | 2016-11-17 23:43:29 -0800 | [diff] [blame] | 2451 | info.codec_payload_type = rtc::Optional<int>( |
| 2452 | stats.current_payload_type); |
hbos | a65704b | 2016-11-14 02:28:16 -0800 | [diff] [blame] | 2453 | } |
asapersson@webrtc.org | cfd82df | 2015-01-22 09:39:59 +0000 | [diff] [blame] | 2454 | info.bytes_rcvd = stats.rtp_stats.transmitted.payload_bytes + |
| 2455 | stats.rtp_stats.transmitted.header_bytes + |
| 2456 | stats.rtp_stats.transmitted.padding_bytes; |
| 2457 | info.packets_rcvd = stats.rtp_stats.transmitted.packets; |
Peter Boström | 393347f | 2015-04-22 14:52:45 +0200 | [diff] [blame] | 2458 | info.packets_lost = stats.rtcp_stats.cumulative_lost; |
| 2459 | info.fraction_lost = |
| 2460 | static_cast<float>(stats.rtcp_stats.fraction_lost) / (1 << 8); |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2461 | |
| 2462 | info.framerate_rcvd = stats.network_frame_rate; |
| 2463 | info.framerate_decoded = stats.decode_frame_rate; |
| 2464 | info.framerate_output = stats.render_frame_rate; |
asapersson | 26dd92b | 2016-08-30 00:45:45 -0700 | [diff] [blame] | 2465 | info.frame_width = stats.width; |
| 2466 | info.frame_height = stats.height; |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2467 | |
pbos@webrtc.org | 1d0fa5d | 2015-02-19 12:47:00 +0000 | [diff] [blame] | 2468 | { |
nisse | e73afba | 2016-01-28 04:47:08 -0800 | [diff] [blame] | 2469 | rtc::CritScope frame_cs(&sink_lock_); |
pbos@webrtc.org | 1d0fa5d | 2015-02-19 12:47:00 +0000 | [diff] [blame] | 2470 | info.capture_start_ntp_time_ms = estimated_remote_start_ntp_time_ms_; |
| 2471 | } |
| 2472 | |
pbos@webrtc.org | 09c77b9 | 2015-02-25 10:42:16 +0000 | [diff] [blame] | 2473 | info.decode_ms = stats.decode_ms; |
| 2474 | info.max_decode_ms = stats.max_decode_ms; |
| 2475 | info.current_delay_ms = stats.current_delay_ms; |
| 2476 | info.target_delay_ms = stats.target_delay_ms; |
| 2477 | info.jitter_buffer_ms = stats.jitter_buffer_ms; |
| 2478 | info.min_playout_delay_ms = stats.min_playout_delay_ms; |
| 2479 | info.render_delay_ms = stats.render_delay_ms; |
sakal | e5ba44e | 2016-10-26 07:09:24 -0700 | [diff] [blame] | 2480 | info.frames_decoded = stats.frames_decoded; |
pbos@webrtc.org | 09c77b9 | 2015-02-25 10:42:16 +0000 | [diff] [blame] | 2481 | |
pbos | f42376c | 2015-08-28 07:35:32 -0700 | [diff] [blame] | 2482 | info.codec_name = GetCodecNameFromPayloadType(stats.current_payload_type); |
| 2483 | |
pbos@webrtc.org | 1d0fa5d | 2015-02-19 12:47:00 +0000 | [diff] [blame] | 2484 | info.firs_sent = stats.rtcp_packet_type_counts.fir_packets; |
| 2485 | info.plis_sent = stats.rtcp_packet_type_counts.pli_packets; |
| 2486 | info.nacks_sent = stats.rtcp_packet_type_counts.nack_packets; |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2487 | |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 2488 | if (log_stats) |
| 2489 | LOG(LS_INFO) << stats.ToString(rtc::TimeMillis()); |
| 2490 | |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2491 | return info; |
| 2492 | } |
| 2493 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2494 | WebRtcVideoChannel2::VideoCodecSettings::VideoCodecSettings() |
| 2495 | : rtx_payload_type(-1) {} |
| 2496 | |
pbos@webrtc.org | a2ef4fe | 2014-11-07 10:54:43 +0000 | [diff] [blame] | 2497 | bool WebRtcVideoChannel2::VideoCodecSettings::operator==( |
| 2498 | const WebRtcVideoChannel2::VideoCodecSettings& other) const { |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 2499 | return codec == other.codec && ulpfec == other.ulpfec && |
| 2500 | flexfec == other.flexfec && rtx_payload_type == other.rtx_payload_type; |
pbos@webrtc.org | a2ef4fe | 2014-11-07 10:54:43 +0000 | [diff] [blame] | 2501 | } |
| 2502 | |
Peter Boström | ee0b00e | 2015-04-22 18:41:14 +0200 | [diff] [blame] | 2503 | bool WebRtcVideoChannel2::VideoCodecSettings::operator!=( |
| 2504 | const WebRtcVideoChannel2::VideoCodecSettings& other) const { |
| 2505 | return !(*this == other); |
| 2506 | } |
| 2507 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2508 | std::vector<WebRtcVideoChannel2::VideoCodecSettings> |
| 2509 | WebRtcVideoChannel2::MapCodecs(const std::vector<VideoCodec>& codecs) { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 2510 | RTC_DCHECK(!codecs.empty()); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2511 | |
| 2512 | std::vector<VideoCodecSettings> video_codecs; |
| 2513 | std::map<int, bool> payload_used; |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 2514 | std::map<int, VideoCodec::CodecType> payload_codec_type; |
pkasting@chromium.org | d324546 | 2015-02-23 21:28:22 +0000 | [diff] [blame] | 2515 | // |rtx_mapping| maps video payload type to rtx payload type. |
| 2516 | std::map<int, int> rtx_mapping; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2517 | |
brandtr | b5f2c3f | 2016-10-04 23:28:39 -0700 | [diff] [blame] | 2518 | webrtc::UlpfecConfig ulpfec_config; |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 2519 | int flexfec_payload_type = -1; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2520 | |
| 2521 | for (size_t i = 0; i < codecs.size(); ++i) { |
| 2522 | const VideoCodec& in_codec = codecs[i]; |
| 2523 | int payload_type = in_codec.id; |
| 2524 | |
| 2525 | if (payload_used[payload_type]) { |
| 2526 | LOG(LS_ERROR) << "Payload type already registered: " |
| 2527 | << in_codec.ToString(); |
| 2528 | return std::vector<VideoCodecSettings>(); |
| 2529 | } |
| 2530 | payload_used[payload_type] = true; |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 2531 | payload_codec_type[payload_type] = in_codec.GetCodecType(); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2532 | |
| 2533 | switch (in_codec.GetCodecType()) { |
| 2534 | case VideoCodec::CODEC_RED: { |
| 2535 | // RED payload type, should not have duplicates. |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 2536 | RTC_DCHECK_EQ(-1, ulpfec_config.red_payload_type); |
brandtr | b5f2c3f | 2016-10-04 23:28:39 -0700 | [diff] [blame] | 2537 | ulpfec_config.red_payload_type = in_codec.id; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2538 | continue; |
| 2539 | } |
| 2540 | |
| 2541 | case VideoCodec::CODEC_ULPFEC: { |
| 2542 | // ULPFEC payload type, should not have duplicates. |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 2543 | RTC_DCHECK_EQ(-1, ulpfec_config.ulpfec_payload_type); |
brandtr | b5f2c3f | 2016-10-04 23:28:39 -0700 | [diff] [blame] | 2544 | ulpfec_config.ulpfec_payload_type = in_codec.id; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2545 | continue; |
| 2546 | } |
| 2547 | |
brandtr | 87d7d77 | 2016-11-07 03:03:41 -0800 | [diff] [blame] | 2548 | case VideoCodec::CODEC_FLEXFEC: { |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 2549 | // FlexFEC payload type, should not have duplicates. |
| 2550 | RTC_DCHECK_EQ(-1, flexfec_payload_type); |
| 2551 | flexfec_payload_type = in_codec.id; |
brandtr | 87d7d77 | 2016-11-07 03:03:41 -0800 | [diff] [blame] | 2552 | continue; |
| 2553 | } |
| 2554 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2555 | case VideoCodec::CODEC_RTX: { |
| 2556 | int associated_payload_type; |
| 2557 | if (!in_codec.GetParam(kCodecParamAssociatedPayloadType, |
pkasting@chromium.org | e9facf8 | 2015-02-17 20:36:28 +0000 | [diff] [blame] | 2558 | &associated_payload_type) || |
| 2559 | !IsValidRtpPayloadType(associated_payload_type)) { |
| 2560 | LOG(LS_ERROR) |
| 2561 | << "RTX codec with invalid or no associated payload type: " |
| 2562 | << in_codec.ToString(); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2563 | return std::vector<VideoCodecSettings>(); |
| 2564 | } |
| 2565 | rtx_mapping[associated_payload_type] = in_codec.id; |
| 2566 | continue; |
| 2567 | } |
| 2568 | |
| 2569 | case VideoCodec::CODEC_VIDEO: |
| 2570 | break; |
| 2571 | } |
| 2572 | |
| 2573 | video_codecs.push_back(VideoCodecSettings()); |
| 2574 | video_codecs.back().codec = in_codec; |
| 2575 | } |
| 2576 | |
| 2577 | // One of these codecs should have been a video codec. Only having FEC |
| 2578 | // parameters into this code is a logic error. |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 2579 | RTC_DCHECK(!video_codecs.empty()); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2580 | |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 2581 | for (std::map<int, int>::const_iterator it = rtx_mapping.begin(); |
| 2582 | it != rtx_mapping.end(); |
| 2583 | ++it) { |
| 2584 | if (!payload_used[it->first]) { |
| 2585 | LOG(LS_ERROR) << "RTX mapped to payload not in codec list."; |
| 2586 | return std::vector<VideoCodecSettings>(); |
| 2587 | } |
Shao Changbin | e62202f | 2015-04-21 20:24:50 +0800 | [diff] [blame] | 2588 | if (payload_codec_type[it->first] != VideoCodec::CODEC_VIDEO && |
| 2589 | payload_codec_type[it->first] != VideoCodec::CODEC_RED) { |
| 2590 | LOG(LS_ERROR) << "RTX not mapped to regular video codec or RED codec."; |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 2591 | return std::vector<VideoCodecSettings>(); |
| 2592 | } |
Shao Changbin | e62202f | 2015-04-21 20:24:50 +0800 | [diff] [blame] | 2593 | |
brandtr | b5f2c3f | 2016-10-04 23:28:39 -0700 | [diff] [blame] | 2594 | if (it->first == ulpfec_config.red_payload_type) { |
| 2595 | ulpfec_config.red_rtx_payload_type = it->second; |
Shao Changbin | e62202f | 2015-04-21 20:24:50 +0800 | [diff] [blame] | 2596 | } |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 2597 | } |
| 2598 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2599 | for (size_t i = 0; i < video_codecs.size(); ++i) { |
brandtr | b5f2c3f | 2016-10-04 23:28:39 -0700 | [diff] [blame] | 2600 | video_codecs[i].ulpfec = ulpfec_config; |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 2601 | video_codecs[i].flexfec.flexfec_payload_type = flexfec_payload_type; |
Shao Changbin | e62202f | 2015-04-21 20:24:50 +0800 | [diff] [blame] | 2602 | if (rtx_mapping[video_codecs[i].codec.id] != 0 && |
| 2603 | rtx_mapping[video_codecs[i].codec.id] != |
brandtr | b5f2c3f | 2016-10-04 23:28:39 -0700 | [diff] [blame] | 2604 | ulpfec_config.red_payload_type) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2605 | video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id]; |
| 2606 | } |
| 2607 | } |
| 2608 | |
| 2609 | return video_codecs; |
| 2610 | } |
| 2611 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2612 | } // namespace cricket |