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