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 | |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 11 | #include "media/engine/webrtc_video_engine.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> |
Jonas Olsson | a4d8737 | 2019-07-05 19:08:33 +0200 | [diff] [blame] | 14 | |
pbos@webrtc.org | c37e72e | 2015-01-05 18:51:13 +0000 | [diff] [blame] | 15 | #include <algorithm> |
pbos@webrtc.org | 3c10758 | 2014-07-20 15:27:35 +0000 | [diff] [blame] | 16 | #include <set> |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 17 | #include <string> |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 18 | #include <utility> |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 19 | |
Steve Anton | b118d42 | 2019-03-28 11:04:59 -0700 | [diff] [blame] | 20 | #include "absl/algorithm/container.h" |
Niels Möller | 039743e | 2018-10-23 10:07:25 +0200 | [diff] [blame] | 21 | #include "absl/strings/match.h" |
Florent Castelli | b05ca4b | 2020-03-05 13:39:55 +0100 | [diff] [blame] | 22 | #include "api/media_stream_interface.h" |
Niels Möller | 65f17ca | 2019-09-12 13:59:36 +0200 | [diff] [blame] | 23 | #include "api/transport/datagram_transport_interface.h" |
Elad Alon | 80f53b7 | 2019-10-11 16:19:43 +0200 | [diff] [blame] | 24 | #include "api/units/data_rate.h" |
Erik Språng | f93eda1 | 2019-01-16 17:10:57 +0100 | [diff] [blame] | 25 | #include "api/video/video_codec_constants.h" |
Åsa Persson | 5983087 | 2019-06-28 17:01:08 +0200 | [diff] [blame] | 26 | #include "api/video/video_codec_type.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 27 | #include "api/video_codecs/sdp_video_format.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 28 | #include "api/video_codecs/video_decoder_factory.h" |
| 29 | #include "api/video_codecs/video_encoder.h" |
| 30 | #include "api/video_codecs/video_encoder_factory.h" |
| 31 | #include "call/call.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 32 | #include "media/engine/simulcast.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 33 | #include "media/engine/webrtc_media_engine.h" |
| 34 | #include "media/engine/webrtc_voice_engine.h" |
| 35 | #include "rtc_base/copy_on_write_buffer.h" |
Sergey Silkin | 19da5ce | 2019-05-20 17:57:17 +0200 | [diff] [blame] | 36 | #include "rtc_base/experiments/field_trial_parser.h" |
philipel | d9cc8c0 | 2019-09-16 14:53:40 +0200 | [diff] [blame] | 37 | #include "rtc_base/experiments/field_trial_units.h" |
Elad Alon | 80f53b7 | 2019-10-11 16:19:43 +0200 | [diff] [blame] | 38 | #include "rtc_base/experiments/min_video_bitrate_experiment.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 39 | #include "rtc_base/logging.h" |
Elad Alon | 80f53b7 | 2019-10-11 16:19:43 +0200 | [diff] [blame] | 40 | #include "rtc_base/numerics/safe_conversions.h" |
Jonas Olsson | 941a07c | 2018-09-13 10:07:07 +0200 | [diff] [blame] | 41 | #include "rtc_base/strings/string_builder.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 42 | #include "rtc_base/time_utils.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 43 | #include "rtc_base/trace_event.h" |
| 44 | #include "system_wrappers/include/field_trial.h" |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 45 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 46 | namespace cricket { |
Magnus Jedvert | 07e0d01 | 2017-10-31 11:24:54 +0100 | [diff] [blame] | 47 | |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 48 | namespace { |
magjed | a35df42 | 2017-08-30 04:21:30 -0700 | [diff] [blame] | 49 | |
Florent Castelli | c1a0bcb | 2019-01-29 14:26:48 +0100 | [diff] [blame] | 50 | const int kMinLayerSize = 16; |
| 51 | |
brandtr | 340e3fd | 2017-02-28 15:43:10 -0800 | [diff] [blame] | 52 | // If this field trial is enabled, we will enable sending FlexFEC and disable |
brandtr | 31bd224 | 2017-05-19 05:47:46 -0700 | [diff] [blame] | 53 | // sending ULPFEC whenever the former has been negotiated in the SDPs. |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 54 | bool IsFlexfecFieldTrialEnabled() { |
brandtr | dbb1be5 | 2017-04-26 00:02:34 -0700 | [diff] [blame] | 55 | return webrtc::field_trial::IsEnabled("WebRTC-FlexFEC-03"); |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 56 | } |
| 57 | |
Magnus Jedvert | 9b16e2d | 2017-11-18 12:08:55 +0100 | [diff] [blame] | 58 | // If this field trial is enabled, the "flexfec-03" codec will be advertised |
| 59 | // as being supported. This means that "flexfec-03" will appear in the default |
| 60 | // SDP offer, and we therefore need to be ready to receive FlexFEC packets from |
| 61 | // the remote. It also means that FlexFEC SSRCs will be generated by |
| 62 | // MediaSession and added as "a=ssrc:" and "a=ssrc-group:" lines in the local |
| 63 | // SDP. |
brandtr | 31bd224 | 2017-05-19 05:47:46 -0700 | [diff] [blame] | 64 | bool IsFlexfecAdvertisedFieldTrialEnabled() { |
| 65 | return webrtc::field_trial::IsEnabled("WebRTC-FlexFEC-03-Advertised"); |
| 66 | } |
| 67 | |
Peter Boström | 81ea54e | 2015-05-07 11:41:09 +0200 | [diff] [blame] | 68 | void AddDefaultFeedbackParams(VideoCodec* codec) { |
Magnus Jedvert | ef20795 | 2017-10-25 17:08:04 +0200 | [diff] [blame] | 69 | // Don't add any feedback params for RED and ULPFEC. |
| 70 | if (codec->name == kRedCodecName || codec->name == kUlpfecCodecName) |
| 71 | return; |
Peter Boström | 81ea54e | 2015-05-07 11:41:09 +0200 | [diff] [blame] | 72 | codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamRemb, kParamValueEmpty)); |
stefan | 43edf0f | 2015-11-20 18:05:48 -0800 | [diff] [blame] | 73 | codec->AddFeedbackParam( |
| 74 | FeedbackParam(kRtcpFbParamTransportCc, kParamValueEmpty)); |
Magnus Jedvert | ef20795 | 2017-10-25 17:08:04 +0200 | [diff] [blame] | 75 | // Don't add any more feedback params for FLEXFEC. |
| 76 | if (codec->name == kFlexfecCodecName) |
| 77 | return; |
| 78 | codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamCcm, kRtcpFbCcmParamFir)); |
| 79 | codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamNack, kParamValueEmpty)); |
| 80 | codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamNack, kRtcpFbNackParamPli)); |
Elad Alon | fadb181 | 2019-05-24 13:40:02 +0200 | [diff] [blame] | 81 | if (codec->name == kVp8CodecName && |
| 82 | webrtc::field_trial::IsEnabled("WebRTC-RtcpLossNotification")) { |
| 83 | codec->AddFeedbackParam(FeedbackParam(kRtcpFbParamLntf, kParamValueEmpty)); |
| 84 | } |
Peter Boström | 81ea54e | 2015-05-07 11:41:09 +0200 | [diff] [blame] | 85 | } |
| 86 | |
Magnus Jedvert | 9b16e2d | 2017-11-18 12:08:55 +0100 | [diff] [blame] | 87 | // This function will assign dynamic payload types (in the range [96, 127]) to |
| 88 | // the input codecs, and also add ULPFEC, RED, FlexFEC, and associated RTX |
| 89 | // codecs for recognized codecs (VP8, VP9, H264, and RED). It will also add |
| 90 | // default feedback params to the codecs. |
| 91 | std::vector<VideoCodec> AssignPayloadTypesAndDefaultCodecs( |
| 92 | std::vector<webrtc::SdpVideoFormat> input_formats) { |
| 93 | if (input_formats.empty()) |
| 94 | return std::vector<VideoCodec>(); |
| 95 | static const int kFirstDynamicPayloadType = 96; |
| 96 | static const int kLastDynamicPayloadType = 127; |
| 97 | int payload_type = kFirstDynamicPayloadType; |
| 98 | |
| 99 | input_formats.push_back(webrtc::SdpVideoFormat(kRedCodecName)); |
| 100 | input_formats.push_back(webrtc::SdpVideoFormat(kUlpfecCodecName)); |
| 101 | |
| 102 | if (IsFlexfecAdvertisedFieldTrialEnabled()) { |
| 103 | webrtc::SdpVideoFormat flexfec_format(kFlexfecCodecName); |
| 104 | // This value is currently arbitrarily set to 10 seconds. (The unit |
| 105 | // is microseconds.) This parameter MUST be present in the SDP, but |
| 106 | // we never use the actual value anywhere in our code however. |
| 107 | // TODO(brandtr): Consider honouring this value in the sender and receiver. |
| 108 | flexfec_format.parameters = {{kFlexfecFmtpRepairWindow, "10000000"}}; |
| 109 | input_formats.push_back(flexfec_format); |
| 110 | } |
| 111 | |
| 112 | std::vector<VideoCodec> output_codecs; |
| 113 | for (const webrtc::SdpVideoFormat& format : input_formats) { |
| 114 | VideoCodec codec(format); |
| 115 | codec.id = payload_type; |
| 116 | AddDefaultFeedbackParams(&codec); |
| 117 | output_codecs.push_back(codec); |
| 118 | |
| 119 | // Increment payload type. |
| 120 | ++payload_type; |
Sami Kalliomäki | e9a18b2 | 2018-07-13 10:28:21 +0200 | [diff] [blame] | 121 | if (payload_type > kLastDynamicPayloadType) { |
| 122 | RTC_LOG(LS_ERROR) << "Out of dynamic payload types, skipping the rest."; |
Magnus Jedvert | 9b16e2d | 2017-11-18 12:08:55 +0100 | [diff] [blame] | 123 | break; |
Sami Kalliomäki | e9a18b2 | 2018-07-13 10:28:21 +0200 | [diff] [blame] | 124 | } |
Magnus Jedvert | 9b16e2d | 2017-11-18 12:08:55 +0100 | [diff] [blame] | 125 | |
Sami Kalliomäki | e9a18b2 | 2018-07-13 10:28:21 +0200 | [diff] [blame] | 126 | // Add associated RTX codec for non-FEC codecs. |
Niels Möller | 039743e | 2018-10-23 10:07:25 +0200 | [diff] [blame] | 127 | if (!absl::EqualsIgnoreCase(codec.name, kUlpfecCodecName) && |
| 128 | !absl::EqualsIgnoreCase(codec.name, kFlexfecCodecName)) { |
Magnus Jedvert | 9b16e2d | 2017-11-18 12:08:55 +0100 | [diff] [blame] | 129 | output_codecs.push_back( |
| 130 | VideoCodec::CreateRtxCodec(payload_type, codec.id)); |
| 131 | |
| 132 | // Increment payload type. |
| 133 | ++payload_type; |
Sami Kalliomäki | e9a18b2 | 2018-07-13 10:28:21 +0200 | [diff] [blame] | 134 | if (payload_type > kLastDynamicPayloadType) { |
| 135 | RTC_LOG(LS_ERROR) << "Out of dynamic payload types, skipping the rest."; |
Magnus Jedvert | 9b16e2d | 2017-11-18 12:08:55 +0100 | [diff] [blame] | 136 | break; |
Sami Kalliomäki | e9a18b2 | 2018-07-13 10:28:21 +0200 | [diff] [blame] | 137 | } |
Magnus Jedvert | 9b16e2d | 2017-11-18 12:08:55 +0100 | [diff] [blame] | 138 | } |
| 139 | } |
| 140 | return output_codecs; |
| 141 | } |
| 142 | |
Johannes Kron | 3e98368 | 2020-03-29 22:17:00 +0200 | [diff] [blame] | 143 | // is_decoder_factory is needed to keep track of the implict assumption that any |
| 144 | // H264 decoder also supports constrained base line profile. |
| 145 | // TODO(kron): Perhaps it better to move the implcit knowledge to the place |
| 146 | // where codecs are negotiated. |
| 147 | template <class T> |
| 148 | std::vector<VideoCodec> GetPayloadTypesAndDefaultCodecs( |
| 149 | const T* factory, |
| 150 | bool is_decoder_factory) { |
| 151 | if (!factory) { |
| 152 | return {}; |
| 153 | } |
| 154 | |
| 155 | std::vector<webrtc::SdpVideoFormat> supported_formats = |
| 156 | factory->GetSupportedFormats(); |
| 157 | if (is_decoder_factory) { |
| 158 | AddH264ConstrainedBaselineProfileToSupportedFormats(&supported_formats); |
| 159 | } |
| 160 | |
| 161 | return AssignPayloadTypesAndDefaultCodecs(std::move(supported_formats)); |
Magnus Jedvert | 9b16e2d | 2017-11-18 12:08:55 +0100 | [diff] [blame] | 162 | } |
| 163 | |
Åsa Persson | 23eba22 | 2018-10-02 14:47:06 +0200 | [diff] [blame] | 164 | bool IsTemporalLayersSupported(const std::string& codec_name) { |
Niels Möller | 039743e | 2018-10-23 10:07:25 +0200 | [diff] [blame] | 165 | return absl::EqualsIgnoreCase(codec_name, kVp8CodecName) || |
| 166 | absl::EqualsIgnoreCase(codec_name, kVp9CodecName); |
Åsa Persson | 23eba22 | 2018-10-02 14:47:06 +0200 | [diff] [blame] | 167 | } |
| 168 | |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 169 | static std::string CodecVectorToString(const std::vector<VideoCodec>& codecs) { |
Jonas Olsson | 941a07c | 2018-09-13 10:07:07 +0200 | [diff] [blame] | 170 | rtc::StringBuilder out; |
| 171 | out << "{"; |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 172 | for (size_t i = 0; i < codecs.size(); ++i) { |
| 173 | out << codecs[i].ToString(); |
| 174 | if (i != codecs.size() - 1) { |
| 175 | out << ", "; |
| 176 | } |
| 177 | } |
Jonas Olsson | 941a07c | 2018-09-13 10:07:07 +0200 | [diff] [blame] | 178 | out << "}"; |
Jonas Olsson | 84df1c7 | 2018-09-14 16:59:32 +0200 | [diff] [blame] | 179 | return out.Release(); |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 180 | } |
| 181 | |
| 182 | static bool ValidateCodecFormats(const std::vector<VideoCodec>& codecs) { |
| 183 | bool has_video = false; |
| 184 | for (size_t i = 0; i < codecs.size(); ++i) { |
| 185 | if (!codecs[i].ValidateCodecFormat()) { |
| 186 | return false; |
| 187 | } |
| 188 | if (codecs[i].GetCodecType() == VideoCodec::CODEC_VIDEO) { |
| 189 | has_video = true; |
| 190 | } |
| 191 | } |
| 192 | if (!has_video) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 193 | RTC_LOG(LS_ERROR) << "Setting codecs without a video codec is invalid: " |
| 194 | << CodecVectorToString(codecs); |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 195 | return false; |
| 196 | } |
| 197 | return true; |
| 198 | } |
| 199 | |
Peter Boström | d4362cd | 2015-03-25 14:17:23 +0100 | [diff] [blame] | 200 | static bool ValidateStreamParams(const StreamParams& sp) { |
| 201 | if (sp.ssrcs.empty()) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 202 | RTC_LOG(LS_ERROR) << "No SSRCs in stream parameters: " << sp.ToString(); |
Peter Boström | d4362cd | 2015-03-25 14:17:23 +0100 | [diff] [blame] | 203 | return false; |
| 204 | } |
| 205 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 206 | std::vector<uint32_t> primary_ssrcs; |
Peter Boström | d4362cd | 2015-03-25 14:17:23 +0100 | [diff] [blame] | 207 | sp.GetPrimarySsrcs(&primary_ssrcs); |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 208 | std::vector<uint32_t> rtx_ssrcs; |
Peter Boström | d4362cd | 2015-03-25 14:17:23 +0100 | [diff] [blame] | 209 | sp.GetFidSsrcs(primary_ssrcs, &rtx_ssrcs); |
| 210 | for (uint32_t rtx_ssrc : rtx_ssrcs) { |
| 211 | bool rtx_ssrc_present = false; |
| 212 | for (uint32_t sp_ssrc : sp.ssrcs) { |
| 213 | if (sp_ssrc == rtx_ssrc) { |
| 214 | rtx_ssrc_present = true; |
| 215 | break; |
| 216 | } |
| 217 | } |
| 218 | if (!rtx_ssrc_present) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 219 | RTC_LOG(LS_ERROR) << "RTX SSRC '" << rtx_ssrc |
| 220 | << "' missing from StreamParams ssrcs: " |
| 221 | << sp.ToString(); |
Peter Boström | d4362cd | 2015-03-25 14:17:23 +0100 | [diff] [blame] | 222 | return false; |
| 223 | } |
| 224 | } |
| 225 | if (!rtx_ssrcs.empty() && primary_ssrcs.size() != rtx_ssrcs.size()) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 226 | RTC_LOG(LS_ERROR) |
Peter Boström | d4362cd | 2015-03-25 14:17:23 +0100 | [diff] [blame] | 227 | << "RTX SSRCs exist, but don't cover all SSRCs (unsupported): " |
| 228 | << sp.ToString(); |
| 229 | return false; |
| 230 | } |
| 231 | |
| 232 | return true; |
| 233 | } |
| 234 | |
noahric | fdac516 | 2015-08-27 01:59:29 -0700 | [diff] [blame] | 235 | // Returns true if the given codec is disallowed from doing simulcast. |
| 236 | bool IsCodecBlacklistedForSimulcast(const std::string& codec_name) { |
Erik Språng | f5fc537 | 2018-12-19 16:04:08 +0100 | [diff] [blame] | 237 | return !webrtc::field_trial::IsDisabled("WebRTC-H264Simulcast") |
Niels Möller | 039743e | 2018-10-23 10:07:25 +0200 | [diff] [blame] | 238 | ? absl::EqualsIgnoreCase(codec_name, kVp9CodecName) |
| 239 | : absl::EqualsIgnoreCase(codec_name, kH264CodecName) || |
| 240 | absl::EqualsIgnoreCase(codec_name, kVp9CodecName); |
noahric | fdac516 | 2015-08-27 01:59:29 -0700 | [diff] [blame] | 241 | } |
| 242 | |
Åsa Persson | 1c7d48d | 2015-09-08 09:21:43 +0200 | [diff] [blame] | 243 | // The selected thresholds for QVGA and VGA corresponded to a QP around 10. |
| 244 | // The change in QP declined above the selected bitrates. |
Ilya Nikolaevskiy | 3a656d1 | 2019-02-14 14:44:22 +0100 | [diff] [blame] | 245 | static int GetMaxDefaultVideoBitrateKbps(int width, |
| 246 | int height, |
| 247 | bool is_screenshare) { |
| 248 | int max_bitrate; |
Åsa Persson | 1c7d48d | 2015-09-08 09:21:43 +0200 | [diff] [blame] | 249 | if (width * height <= 320 * 240) { |
Ilya Nikolaevskiy | 3a656d1 | 2019-02-14 14:44:22 +0100 | [diff] [blame] | 250 | max_bitrate = 600; |
Åsa Persson | 1c7d48d | 2015-09-08 09:21:43 +0200 | [diff] [blame] | 251 | } else if (width * height <= 640 * 480) { |
Ilya Nikolaevskiy | 3a656d1 | 2019-02-14 14:44:22 +0100 | [diff] [blame] | 252 | max_bitrate = 1700; |
Åsa Persson | 1c7d48d | 2015-09-08 09:21:43 +0200 | [diff] [blame] | 253 | } else if (width * height <= 960 * 540) { |
Ilya Nikolaevskiy | 3a656d1 | 2019-02-14 14:44:22 +0100 | [diff] [blame] | 254 | max_bitrate = 2000; |
Åsa Persson | 1c7d48d | 2015-09-08 09:21:43 +0200 | [diff] [blame] | 255 | } else { |
Ilya Nikolaevskiy | 3a656d1 | 2019-02-14 14:44:22 +0100 | [diff] [blame] | 256 | max_bitrate = 2500; |
Åsa Persson | 1c7d48d | 2015-09-08 09:21:43 +0200 | [diff] [blame] | 257 | } |
Ilya Nikolaevskiy | 3a656d1 | 2019-02-14 14:44:22 +0100 | [diff] [blame] | 258 | if (is_screenshare) |
| 259 | max_bitrate = std::max(max_bitrate, 1200); |
| 260 | return max_bitrate; |
Åsa Persson | 1c7d48d | 2015-09-08 09:21:43 +0200 | [diff] [blame] | 261 | } |
perkj | 2d5f091 | 2016-02-29 00:04:41 -0800 | [diff] [blame] | 262 | |
Sergey Silkin | f18072e | 2018-03-14 10:35:35 +0100 | [diff] [blame] | 263 | bool GetVp9LayersFromFieldTrialGroup(size_t* num_spatial_layers, |
| 264 | size_t* num_temporal_layers) { |
asapersson | c5dabdd | 2016-03-21 04:15:50 -0700 | [diff] [blame] | 265 | std::string group = webrtc::field_trial::FindFullName("WebRTC-SupportVP9SVC"); |
| 266 | if (group.empty()) |
| 267 | return false; |
| 268 | |
Sergey Silkin | f18072e | 2018-03-14 10:35:35 +0100 | [diff] [blame] | 269 | if (sscanf(group.c_str(), "EnabledByFlag_%zuSL%zuTL", num_spatial_layers, |
asapersson | c5dabdd | 2016-03-21 04:15:50 -0700 | [diff] [blame] | 270 | num_temporal_layers) != 2) { |
| 271 | return false; |
| 272 | } |
Erik Språng | f93eda1 | 2019-01-16 17:10:57 +0100 | [diff] [blame] | 273 | if (*num_spatial_layers > webrtc::kMaxSpatialLayers || |
| 274 | *num_spatial_layers < 1) |
asapersson | c5dabdd | 2016-03-21 04:15:50 -0700 | [diff] [blame] | 275 | return false; |
| 276 | |
Sergey Silkin | f18072e | 2018-03-14 10:35:35 +0100 | [diff] [blame] | 277 | const size_t kMaxTemporalLayers = 3; |
asapersson | c5dabdd | 2016-03-21 04:15:50 -0700 | [diff] [blame] | 278 | if (*num_temporal_layers > kMaxTemporalLayers || *num_temporal_layers < 1) |
| 279 | return false; |
| 280 | |
| 281 | return true; |
| 282 | } |
| 283 | |
Danil Chapovalov | 00c7183 | 2018-06-15 15:58:38 +0200 | [diff] [blame] | 284 | absl::optional<size_t> GetVp9SpatialLayersFromFieldTrial() { |
Sergey Silkin | f18072e | 2018-03-14 10:35:35 +0100 | [diff] [blame] | 285 | size_t num_sl; |
| 286 | size_t num_tl; |
asapersson | c5dabdd | 2016-03-21 04:15:50 -0700 | [diff] [blame] | 287 | if (GetVp9LayersFromFieldTrialGroup(&num_sl, &num_tl)) { |
| 288 | return num_sl; |
| 289 | } |
Danil Chapovalov | 00c7183 | 2018-06-15 15:58:38 +0200 | [diff] [blame] | 290 | return absl::nullopt; |
asapersson | c5dabdd | 2016-03-21 04:15:50 -0700 | [diff] [blame] | 291 | } |
| 292 | |
Danil Chapovalov | 00c7183 | 2018-06-15 15:58:38 +0200 | [diff] [blame] | 293 | absl::optional<size_t> GetVp9TemporalLayersFromFieldTrial() { |
Sergey Silkin | f18072e | 2018-03-14 10:35:35 +0100 | [diff] [blame] | 294 | size_t num_sl; |
| 295 | size_t num_tl; |
asapersson | c5dabdd | 2016-03-21 04:15:50 -0700 | [diff] [blame] | 296 | if (GetVp9LayersFromFieldTrialGroup(&num_sl, &num_tl)) { |
| 297 | return num_tl; |
| 298 | } |
Danil Chapovalov | 00c7183 | 2018-06-15 15:58:38 +0200 | [diff] [blame] | 299 | return absl::nullopt; |
asapersson | c5dabdd | 2016-03-21 04:15:50 -0700 | [diff] [blame] | 300 | } |
Åsa Persson | 45bbc8a | 2017-11-13 10:16:47 +0100 | [diff] [blame] | 301 | |
Mirko Bonadei | 53227cc | 2019-09-18 14:15:52 +0200 | [diff] [blame] | 302 | // Returns its smallest positive argument. If neither argument is positive, |
| 303 | // returns an arbitrary nonpositive value. |
| 304 | int MinPositive(int a, int b) { |
| 305 | if (a <= 0) { |
| 306 | return b; |
| 307 | } |
| 308 | if (b <= 0) { |
| 309 | return a; |
| 310 | } |
| 311 | return std::min(a, b); |
| 312 | } |
| 313 | |
Florent Castelli | 907dc80 | 2019-12-06 15:03:19 +0100 | [diff] [blame] | 314 | bool IsLayerActive(const webrtc::RtpEncodingParameters& layer) { |
| 315 | return layer.active && |
| 316 | (!layer.max_bitrate_bps || *layer.max_bitrate_bps > 0) && |
| 317 | (!layer.max_framerate || *layer.max_framerate > 0); |
| 318 | } |
| 319 | |
Ilya Nikolaevskiy | 03d9096 | 2020-02-11 12:50:38 +0100 | [diff] [blame] | 320 | size_t FindRequiredActiveLayers( |
| 321 | const webrtc::VideoEncoderConfig& encoder_config) { |
| 322 | // Need enough layers so that at least the first active one is present. |
| 323 | for (size_t i = 0; i < encoder_config.number_of_streams; ++i) { |
| 324 | if (encoder_config.simulcast_layers[i].active) { |
| 325 | return i + 1; |
| 326 | } |
| 327 | } |
| 328 | return 0; |
| 329 | } |
| 330 | |
Ilya Nikolaevskiy | 24dbb21 | 2020-03-02 20:23:50 +0100 | [diff] [blame] | 331 | int NumActiveStreams(const webrtc::RtpParameters& rtp_parameters) { |
| 332 | int res = 0; |
| 333 | for (size_t i = 0; i < rtp_parameters.encodings.size(); ++i) { |
| 334 | if (rtp_parameters.encodings[i].active) { |
| 335 | ++res; |
| 336 | } |
| 337 | } |
| 338 | return res; |
| 339 | } |
| 340 | |
Henrik Boström | f45ca37 | 2020-03-24 13:30:50 +0100 | [diff] [blame] | 341 | std::map<uint32_t, webrtc::VideoSendStream::StreamStats> |
| 342 | MergeInfoAboutOutboundRtpSubstreams( |
| 343 | const std::map<uint32_t, webrtc::VideoSendStream::StreamStats>& |
| 344 | substreams) { |
| 345 | std::map<uint32_t, webrtc::VideoSendStream::StreamStats> rtp_substreams; |
| 346 | // Add substreams for all RTP media streams. |
| 347 | for (const auto& pair : substreams) { |
| 348 | uint32_t ssrc = pair.first; |
| 349 | const webrtc::VideoSendStream::StreamStats& substream = pair.second; |
| 350 | switch (substream.type) { |
| 351 | case webrtc::VideoSendStream::StreamStats::StreamType::kMedia: |
| 352 | break; |
| 353 | case webrtc::VideoSendStream::StreamStats::StreamType::kRtx: |
| 354 | case webrtc::VideoSendStream::StreamStats::StreamType::kFlexfec: |
| 355 | continue; |
| 356 | } |
| 357 | rtp_substreams.insert(std::make_pair(ssrc, substream)); |
| 358 | } |
| 359 | // Complement the kMedia substream stats with the associated kRtx and kFlexfec |
| 360 | // substream stats. |
| 361 | for (const auto& pair : substreams) { |
| 362 | switch (pair.second.type) { |
| 363 | case webrtc::VideoSendStream::StreamStats::StreamType::kMedia: |
| 364 | continue; |
| 365 | case webrtc::VideoSendStream::StreamStats::StreamType::kRtx: |
| 366 | case webrtc::VideoSendStream::StreamStats::StreamType::kFlexfec: |
| 367 | break; |
| 368 | } |
| 369 | // The associated substream is an RTX or FlexFEC substream that is |
| 370 | // referencing an RTP media substream. |
| 371 | const webrtc::VideoSendStream::StreamStats& associated_substream = |
| 372 | pair.second; |
| 373 | RTC_DCHECK(associated_substream.referenced_media_ssrc.has_value()); |
| 374 | uint32_t media_ssrc = associated_substream.referenced_media_ssrc.value(); |
| 375 | RTC_DCHECK(substreams.find(media_ssrc) != substreams.end()); |
| 376 | webrtc::VideoSendStream::StreamStats& rtp_substream = |
| 377 | rtp_substreams[media_ssrc]; |
| 378 | |
| 379 | // We only merge |rtp_stats|. All other metrics are not applicable for RTX |
| 380 | // and FlexFEC. |
| 381 | // TODO(hbos): kRtx and kFlexfec stats should use a separate struct to make |
| 382 | // it clear what is or is not applicable. |
| 383 | rtp_substream.rtp_stats.Add(associated_substream.rtp_stats); |
| 384 | } |
| 385 | return rtp_substreams; |
| 386 | } |
| 387 | |
pbos@webrtc.org | 7fe1e03 | 2014-10-14 04:25:33 +0000 | [diff] [blame] | 388 | } // namespace |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 389 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 390 | // This constant is really an on/off, lower-level configurable NACK history |
| 391 | // duration hasn't been implemented. |
| 392 | static const int kNackHistoryMs = 1000; |
| 393 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 394 | static const int kDefaultRtcpReceiverReportSsrc = 1; |
| 395 | |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 396 | // Minimum time interval for logging stats. |
| 397 | static const int64_t kStatsLogIntervalMs = 10000; |
| 398 | |
Henrik Boström | f45ca37 | 2020-03-24 13:30:50 +0100 | [diff] [blame] | 399 | std::map<uint32_t, webrtc::VideoSendStream::StreamStats> |
| 400 | MergeInfoAboutOutboundRtpSubstreamsForTesting( |
| 401 | const std::map<uint32_t, webrtc::VideoSendStream::StreamStats>& |
| 402 | substreams) { |
| 403 | return MergeInfoAboutOutboundRtpSubstreams(substreams); |
| 404 | } |
| 405 | |
kthelgason | 29a44e3 | 2016-09-27 03:52:02 -0700 | [diff] [blame] | 406 | rtc::scoped_refptr<webrtc::VideoEncoderConfig::EncoderSpecificSettings> |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 407 | WebRtcVideoChannel::WebRtcVideoSendStream::ConfigureVideoEncoderSettings( |
Niels Möller | 60653ba | 2016-03-02 11:41:36 +0100 | [diff] [blame] | 408 | const VideoCodec& codec) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 409 | RTC_DCHECK_RUN_ON(&thread_checker_); |
Niels Möller | 60653ba | 2016-03-02 11:41:36 +0100 | [diff] [blame] | 410 | bool is_screencast = parameters_.options.is_screencast.value_or(false); |
Peter Boström | 2feafdb | 2015-09-09 14:32:14 +0200 | [diff] [blame] | 411 | // No automatic resizing when using simulcast or screencast. |
| 412 | bool automatic_resize = |
Ilya Nikolaevskiy | 24dbb21 | 2020-03-02 20:23:50 +0100 | [diff] [blame] | 413 | !is_screencast && (parameters_.config.rtp.ssrcs.size() == 1 || |
| 414 | NumActiveStreams(rtp_parameters_) == 1); |
Erik Språng | 143cec1 | 2015-04-28 10:01:41 +0200 | [diff] [blame] | 415 | bool frame_dropping = !is_screencast; |
| 416 | bool denoising; |
pbos | 4cba4eb | 2015-10-26 11:18:18 -0700 | [diff] [blame] | 417 | bool codec_default_denoising = false; |
Erik Språng | 143cec1 | 2015-04-28 10:01:41 +0200 | [diff] [blame] | 418 | if (is_screencast) { |
| 419 | denoising = false; |
| 420 | } else { |
pbos | 4cba4eb | 2015-10-26 11:18:18 -0700 | [diff] [blame] | 421 | // Use codec default if video_noise_reduction is unset. |
Niels Möller | 60653ba | 2016-03-02 11:41:36 +0100 | [diff] [blame] | 422 | codec_default_denoising = !parameters_.options.video_noise_reduction; |
| 423 | denoising = parameters_.options.video_noise_reduction.value_or(false); |
Erik Språng | 143cec1 | 2015-04-28 10:01:41 +0200 | [diff] [blame] | 424 | } |
| 425 | |
Niels Möller | 039743e | 2018-10-23 10:07:25 +0200 | [diff] [blame] | 426 | if (absl::EqualsIgnoreCase(codec.name, kH264CodecName)) { |
kthelgason | 29a44e3 | 2016-09-27 03:52:02 -0700 | [diff] [blame] | 427 | webrtc::VideoCodecH264 h264_settings = |
| 428 | webrtc::VideoEncoder::GetDefaultH264Settings(); |
| 429 | h264_settings.frameDroppingOn = frame_dropping; |
| 430 | return new rtc::RefCountedObject< |
| 431 | webrtc::VideoEncoderConfig::H264EncoderSpecificSettings>(h264_settings); |
hbos | bab934b | 2016-01-27 01:36:03 -0800 | [diff] [blame] | 432 | } |
Niels Möller | 039743e | 2018-10-23 10:07:25 +0200 | [diff] [blame] | 433 | if (absl::EqualsIgnoreCase(codec.name, kVp8CodecName)) { |
kthelgason | 29a44e3 | 2016-09-27 03:52:02 -0700 | [diff] [blame] | 434 | webrtc::VideoCodecVP8 vp8_settings = |
| 435 | webrtc::VideoEncoder::GetDefaultVp8Settings(); |
| 436 | vp8_settings.automaticResizeOn = automatic_resize; |
pbos | 4cba4eb | 2015-10-26 11:18:18 -0700 | [diff] [blame] | 437 | // VP8 denoising is enabled by default. |
kthelgason | 29a44e3 | 2016-09-27 03:52:02 -0700 | [diff] [blame] | 438 | vp8_settings.denoisingOn = codec_default_denoising ? true : denoising; |
| 439 | vp8_settings.frameDroppingOn = frame_dropping; |
| 440 | return new rtc::RefCountedObject< |
| 441 | webrtc::VideoEncoderConfig::Vp8EncoderSpecificSettings>(vp8_settings); |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 442 | } |
Niels Möller | 039743e | 2018-10-23 10:07:25 +0200 | [diff] [blame] | 443 | if (absl::EqualsIgnoreCase(codec.name, kVp9CodecName)) { |
kthelgason | 29a44e3 | 2016-09-27 03:52:02 -0700 | [diff] [blame] | 444 | webrtc::VideoCodecVP9 vp9_settings = |
| 445 | webrtc::VideoEncoder::GetDefaultVp9Settings(); |
Sergey Silkin | be71a1e | 2018-05-17 16:46:43 +0200 | [diff] [blame] | 446 | const size_t default_num_spatial_layers = |
| 447 | parameters_.config.rtp.ssrcs.size(); |
| 448 | const size_t num_spatial_layers = |
| 449 | GetVp9SpatialLayersFromFieldTrial().value_or( |
| 450 | default_num_spatial_layers); |
Sergey Silkin | f18072e | 2018-03-14 10:35:35 +0100 | [diff] [blame] | 451 | |
Sergey Silkin | be71a1e | 2018-05-17 16:46:43 +0200 | [diff] [blame] | 452 | const size_t default_num_temporal_layers = |
| 453 | num_spatial_layers > 1 ? kConferenceDefaultNumTemporalLayers : 1; |
| 454 | const size_t num_temporal_layers = |
| 455 | GetVp9TemporalLayersFromFieldTrial().value_or( |
| 456 | default_num_temporal_layers); |
Sergey Silkin | f18072e | 2018-03-14 10:35:35 +0100 | [diff] [blame] | 457 | |
Sergey Silkin | be71a1e | 2018-05-17 16:46:43 +0200 | [diff] [blame] | 458 | vp9_settings.numberOfSpatialLayers = std::min<unsigned char>( |
| 459 | num_spatial_layers, kConferenceMaxNumSpatialLayers); |
| 460 | vp9_settings.numberOfTemporalLayers = std::min<unsigned char>( |
| 461 | num_temporal_layers, kConferenceMaxNumTemporalLayers); |
Sergey Silkin | a796a7e | 2018-03-01 15:11:29 +0100 | [diff] [blame] | 462 | |
pbos | 4cba4eb | 2015-10-26 11:18:18 -0700 | [diff] [blame] | 463 | // VP9 denoising is disabled by default. |
jianj | a5e8aa6 | 2017-03-27 10:09:00 -0700 | [diff] [blame] | 464 | vp9_settings.denoisingOn = codec_default_denoising ? true : denoising; |
asapersson | 1e15a99 | 2017-06-07 04:09:45 -0700 | [diff] [blame] | 465 | vp9_settings.automaticResizeOn = automatic_resize; |
Sergey Silkin | be71a1e | 2018-05-17 16:46:43 +0200 | [diff] [blame] | 466 | // Ensure frame dropping is always enabled. |
| 467 | RTC_DCHECK(vp9_settings.frameDroppingOn); |
| 468 | if (!is_screencast) { |
Sergey Silkin | 19da5ce | 2019-05-20 17:57:17 +0200 | [diff] [blame] | 469 | webrtc::FieldTrialFlag interlayer_pred_experiment_enabled = |
| 470 | webrtc::FieldTrialFlag("Enabled"); |
| 471 | webrtc::FieldTrialEnum<webrtc::InterLayerPredMode> inter_layer_pred_mode( |
| 472 | "inter_layer_pred_mode", webrtc::InterLayerPredMode::kOnKeyPic, |
| 473 | {{"off", webrtc::InterLayerPredMode::kOff}, |
| 474 | {"on", webrtc::InterLayerPredMode::kOn}, |
| 475 | {"onkeypic", webrtc::InterLayerPredMode::kOnKeyPic}}); |
| 476 | webrtc::ParseFieldTrial( |
| 477 | {&interlayer_pred_experiment_enabled, &inter_layer_pred_mode}, |
| 478 | webrtc::field_trial::FindFullName("WebRTC-Vp9InterLayerPred")); |
| 479 | if (interlayer_pred_experiment_enabled) { |
| 480 | vp9_settings.interLayerPred = inter_layer_pred_mode; |
Sergey Silkin | cf26705 | 2019-04-09 11:40:09 +0200 | [diff] [blame] | 481 | } else { |
| 482 | // Limit inter-layer prediction to key pictures by default. |
| 483 | vp9_settings.interLayerPred = webrtc::InterLayerPredMode::kOnKeyPic; |
| 484 | } |
Ilya Nikolaevskiy | 5546aef | 2018-12-04 15:54:52 +0100 | [diff] [blame] | 485 | } else { |
Ilya Nikolaevskiy | 54659c1 | 2019-03-22 13:59:02 +0100 | [diff] [blame] | 486 | // Multiple spatial layers vp9 screenshare needs flexible mode. |
| 487 | vp9_settings.flexibleMode = vp9_settings.numberOfSpatialLayers > 1; |
| 488 | vp9_settings.interLayerPred = webrtc::InterLayerPredMode::kOn; |
Sergey Silkin | be71a1e | 2018-05-17 16:46:43 +0200 | [diff] [blame] | 489 | } |
kthelgason | 29a44e3 | 2016-09-27 03:52:02 -0700 | [diff] [blame] | 490 | return new rtc::RefCountedObject< |
| 491 | webrtc::VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings); |
andresp@webrtc.org | 188d3b2 | 2014-11-07 13:21:04 +0000 | [diff] [blame] | 492 | } |
kthelgason | 29a44e3 | 2016-09-27 03:52:02 -0700 | [diff] [blame] | 493 | return nullptr; |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 494 | } |
| 495 | |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 496 | DefaultUnsignalledSsrcHandler::DefaultUnsignalledSsrcHandler() |
brandtr | 0dc57ea | 2017-05-29 23:33:31 -0700 | [diff] [blame] | 497 | : default_sink_(nullptr) {} |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 498 | |
| 499 | UnsignalledSsrcHandler::Action DefaultUnsignalledSsrcHandler::OnUnsignalledSsrc( |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 500 | WebRtcVideoChannel* channel, |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 501 | uint32_t ssrc) { |
Danil Chapovalov | 00c7183 | 2018-06-15 15:58:38 +0200 | [diff] [blame] | 502 | absl::optional<uint32_t> default_recv_ssrc = |
brandtr | 0dc57ea | 2017-05-29 23:33:31 -0700 | [diff] [blame] | 503 | channel->GetDefaultReceiveStreamSsrc(); |
| 504 | |
| 505 | if (default_recv_ssrc) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 506 | RTC_LOG(LS_INFO) << "Destroying old default receive stream for SSRC=" |
| 507 | << ssrc << "."; |
brandtr | 0dc57ea | 2017-05-29 23:33:31 -0700 | [diff] [blame] | 508 | channel->RemoveRecvStream(*default_recv_ssrc); |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 509 | } |
| 510 | |
Seth Hampson | 5897a6e | 2018-04-03 11:16:33 -0700 | [diff] [blame] | 511 | StreamParams sp = channel->unsignaled_stream_params(); |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 512 | sp.ssrcs.push_back(ssrc); |
Seth Hampson | 5897a6e | 2018-04-03 11:16:33 -0700 | [diff] [blame] | 513 | |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 514 | RTC_LOG(LS_INFO) << "Creating default receive stream for SSRC=" << ssrc |
| 515 | << "."; |
Ruslan Burakov | 493a650 | 2019-02-27 15:32:48 +0100 | [diff] [blame] | 516 | if (!channel->AddRecvStream(sp, /*default_stream=*/true)) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 517 | RTC_LOG(LS_WARNING) << "Could not create default receive stream."; |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 518 | } |
| 519 | |
Ruslan Burakov | 493a650 | 2019-02-27 15:32:48 +0100 | [diff] [blame] | 520 | // SSRC 0 returns default_recv_base_minimum_delay_ms. |
| 521 | const int unsignaled_ssrc = 0; |
| 522 | int default_recv_base_minimum_delay_ms = |
| 523 | channel->GetBaseMinimumPlayoutDelayMs(unsignaled_ssrc).value_or(0); |
| 524 | // Set base minimum delay if it was set before for the default receive stream. |
| 525 | channel->SetBaseMinimumPlayoutDelayMs(ssrc, |
| 526 | default_recv_base_minimum_delay_ms); |
nisse | 08582ff | 2016-02-04 01:24:52 -0800 | [diff] [blame] | 527 | channel->SetSink(ssrc, default_sink_); |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 528 | return kDeliverPacket; |
| 529 | } |
| 530 | |
nisse | acd935b | 2016-11-11 03:55:13 -0800 | [diff] [blame] | 531 | rtc::VideoSinkInterface<webrtc::VideoFrame>* |
nisse | 08582ff | 2016-02-04 01:24:52 -0800 | [diff] [blame] | 532 | DefaultUnsignalledSsrcHandler::GetDefaultSink() const { |
| 533 | return default_sink_; |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 534 | } |
| 535 | |
nisse | 08582ff | 2016-02-04 01:24:52 -0800 | [diff] [blame] | 536 | void DefaultUnsignalledSsrcHandler::SetDefaultSink( |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 537 | WebRtcVideoChannel* channel, |
nisse | acd935b | 2016-11-11 03:55:13 -0800 | [diff] [blame] | 538 | rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) { |
nisse | 08582ff | 2016-02-04 01:24:52 -0800 | [diff] [blame] | 539 | default_sink_ = sink; |
Danil Chapovalov | 00c7183 | 2018-06-15 15:58:38 +0200 | [diff] [blame] | 540 | absl::optional<uint32_t> default_recv_ssrc = |
brandtr | 0dc57ea | 2017-05-29 23:33:31 -0700 | [diff] [blame] | 541 | channel->GetDefaultReceiveStreamSsrc(); |
| 542 | if (default_recv_ssrc) { |
| 543 | channel->SetSink(*default_recv_ssrc, default_sink_); |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 544 | } |
| 545 | } |
| 546 | |
Magnus Jedvert | d4b0c05 | 2017-09-14 10:24:54 +0200 | [diff] [blame] | 547 | WebRtcVideoEngine::WebRtcVideoEngine( |
| 548 | std::unique_ptr<webrtc::VideoEncoderFactory> video_encoder_factory, |
Jonas Oreland | a3aa9bd | 2019-04-17 07:38:40 +0200 | [diff] [blame] | 549 | std::unique_ptr<webrtc::VideoDecoderFactory> video_decoder_factory) |
Magnus Jedvert | 59ab353 | 2018-09-03 18:07:56 +0200 | [diff] [blame] | 550 | : decoder_factory_(std::move(video_decoder_factory)), |
Jonas Oreland | a3aa9bd | 2019-04-17 07:38:40 +0200 | [diff] [blame] | 551 | encoder_factory_(std::move(video_encoder_factory)) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 552 | RTC_LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine()"; |
Magnus Jedvert | d4b0c05 | 2017-09-14 10:24:54 +0200 | [diff] [blame] | 553 | } |
| 554 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 555 | WebRtcVideoEngine::~WebRtcVideoEngine() { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 556 | RTC_LOG(LS_INFO) << "WebRtcVideoEngine::~WebRtcVideoEngine"; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 557 | } |
| 558 | |
Sebastian Jansson | 84848f2 | 2018-11-16 10:40:36 +0100 | [diff] [blame] | 559 | VideoMediaChannel* WebRtcVideoEngine::CreateMediaChannel( |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 560 | webrtc::Call* call, |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 561 | const MediaConfig& config, |
Benjamin Wright | bfb444c | 2018-10-15 10:20:24 -0700 | [diff] [blame] | 562 | const VideoOptions& options, |
Jonas Oreland | a3aa9bd | 2019-04-17 07:38:40 +0200 | [diff] [blame] | 563 | const webrtc::CryptoOptions& crypto_options, |
| 564 | webrtc::VideoBitrateAllocatorFactory* video_bitrate_allocator_factory) { |
Sebastian Jansson | 84848f2 | 2018-11-16 10:40:36 +0100 | [diff] [blame] | 565 | RTC_LOG(LS_INFO) << "CreateMediaChannel. Options: " << options.ToString(); |
Benjamin Wright | bfb444c | 2018-10-15 10:20:24 -0700 | [diff] [blame] | 566 | return new WebRtcVideoChannel(call, config, options, crypto_options, |
Jiawei Ou | c2ebe21 | 2018-11-08 10:02:56 -0800 | [diff] [blame] | 567 | encoder_factory_.get(), decoder_factory_.get(), |
Jonas Oreland | a3aa9bd | 2019-04-17 07:38:40 +0200 | [diff] [blame] | 568 | video_bitrate_allocator_factory); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 569 | } |
Johannes Kron | 3e98368 | 2020-03-29 22:17:00 +0200 | [diff] [blame] | 570 | std::vector<VideoCodec> WebRtcVideoEngine::send_codecs() const { |
| 571 | return GetPayloadTypesAndDefaultCodecs(encoder_factory_.get(), |
| 572 | /*is_decoder_factory=*/false); |
| 573 | } |
| 574 | |
| 575 | std::vector<VideoCodec> WebRtcVideoEngine::recv_codecs() const { |
| 576 | return GetPayloadTypesAndDefaultCodecs(decoder_factory_.get(), |
| 577 | /*is_decoder_factory=*/true); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 578 | } |
| 579 | |
Markus Handell | 0357b3e | 2020-03-16 13:40:51 +0100 | [diff] [blame] | 580 | std::vector<webrtc::RtpHeaderExtensionCapability> |
| 581 | WebRtcVideoEngine::GetRtpHeaderExtensions() const { |
| 582 | std::vector<webrtc::RtpHeaderExtensionCapability> result; |
Elad Alon | 157540a | 2019-02-08 23:37:52 +0100 | [diff] [blame] | 583 | int id = 1; |
Markus Handell | 0357b3e | 2020-03-16 13:40:51 +0100 | [diff] [blame] | 584 | for (const auto& uri : |
| 585 | {webrtc::RtpExtension::kTimestampOffsetUri, |
| 586 | webrtc::RtpExtension::kAbsSendTimeUri, |
| 587 | webrtc::RtpExtension::kVideoRotationUri, |
| 588 | webrtc::RtpExtension::kTransportSequenceNumberUri, |
| 589 | webrtc::RtpExtension::kPlayoutDelayUri, |
| 590 | webrtc::RtpExtension::kVideoContentTypeUri, |
| 591 | webrtc::RtpExtension::kVideoTimingUri, |
| 592 | webrtc::RtpExtension::kFrameMarkingUri, |
| 593 | webrtc::RtpExtension::kColorSpaceUri, webrtc::RtpExtension::kMidUri, |
| 594 | webrtc::RtpExtension::kRidUri, webrtc::RtpExtension::kRepairedRidUri}) { |
| 595 | result.emplace_back(uri, id++, webrtc::RtpTransceiverDirection::kSendRecv); |
philipel | 1e05486 | 2018-10-08 16:13:53 +0200 | [diff] [blame] | 596 | } |
Markus Handell | 0357b3e | 2020-03-16 13:40:51 +0100 | [diff] [blame] | 597 | result.emplace_back( |
| 598 | webrtc::RtpExtension::kGenericFrameDescriptorUri00, id, |
| 599 | webrtc::field_trial::IsEnabled("WebRTC-GenericDescriptorAdvertised") |
| 600 | ? webrtc::RtpTransceiverDirection::kSendRecv |
| 601 | : webrtc::RtpTransceiverDirection::kStopped); |
| 602 | return result; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 603 | } |
| 604 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 605 | WebRtcVideoChannel::WebRtcVideoChannel( |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 606 | webrtc::Call* call, |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 607 | const MediaConfig& config, |
pbos@webrtc.org | fa553ef | 2014-10-20 11:07:07 +0000 | [diff] [blame] | 608 | const VideoOptions& options, |
Benjamin Wright | bfb444c | 2018-10-15 10:20:24 -0700 | [diff] [blame] | 609 | const webrtc::CryptoOptions& crypto_options, |
Magnus Jedvert | 07e0d01 | 2017-10-31 11:24:54 +0100 | [diff] [blame] | 610 | webrtc::VideoEncoderFactory* encoder_factory, |
Jiawei Ou | c2ebe21 | 2018-11-08 10:02:56 -0800 | [diff] [blame] | 611 | webrtc::VideoDecoderFactory* decoder_factory, |
| 612 | webrtc::VideoBitrateAllocatorFactory* bitrate_allocator_factory) |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 613 | : VideoMediaChannel(config), |
philipel | e8ed830 | 2019-07-03 11:53:48 +0200 | [diff] [blame] | 614 | worker_thread_(rtc::Thread::Current()), |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 615 | call_(call), |
Fredrik Solenberg | 709ed67 | 2015-09-15 12:26:33 +0200 | [diff] [blame] | 616 | unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_), |
nisse | 0db023a | 2016-03-01 04:29:59 -0800 | [diff] [blame] | 617 | video_config_(config.video), |
magjed | 2475ae2 | 2017-09-12 04:42:15 -0700 | [diff] [blame] | 618 | encoder_factory_(encoder_factory), |
| 619 | decoder_factory_(decoder_factory), |
Jiawei Ou | c2ebe21 | 2018-11-08 10:02:56 -0800 | [diff] [blame] | 620 | bitrate_allocator_factory_(bitrate_allocator_factory), |
Stefan Holmer | 2b1f651 | 2016-05-17 16:33:30 +0200 | [diff] [blame] | 621 | default_send_options_(options), |
Åsa Persson | 2c7149b | 2018-10-15 09:36:10 +0200 | [diff] [blame] | 622 | last_stats_log_ms_(-1), |
| 623 | discard_unknown_ssrc_packets_(webrtc::field_trial::IsEnabled( |
Benjamin Wright | 192eeec | 2018-10-17 17:27:25 -0700 | [diff] [blame] | 624 | "WebRTC-Video-DiscardPacketsWithUnknownSsrc")), |
Jonas Oreland | 6d83592 | 2019-03-18 10:59:40 +0100 | [diff] [blame] | 625 | crypto_options_(crypto_options), |
| 626 | unknown_ssrc_packet_buffer_( |
| 627 | webrtc::field_trial::IsEnabled( |
| 628 | "WebRTC-Video-BufferPacketsWithUnknownSsrc") |
| 629 | ? new UnhandledPacketsBuffer() |
| 630 | : nullptr) { |
Sebastian Jansson | c01367d | 2019-04-08 15:20:44 +0200 | [diff] [blame] | 631 | RTC_DCHECK(thread_checker_.IsCurrent()); |
nisse | a293ef0 | 2016-02-17 07:24:50 -0800 | [diff] [blame] | 632 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 633 | rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc; |
| 634 | sending_ = false; |
Johannes Kron | 3e98368 | 2020-03-29 22:17:00 +0200 | [diff] [blame] | 635 | recv_codecs_ = MapCodecs(GetPayloadTypesAndDefaultCodecs( |
| 636 | decoder_factory_, /*is_decoder_factory=*/true)); |
| 637 | recv_flexfec_payload_type_ = |
| 638 | recv_codecs_.empty() ? 0 : recv_codecs_.front().flexfec_payload_type; |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 639 | } |
| 640 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 641 | WebRtcVideoChannel::~WebRtcVideoChannel() { |
Peter Boström | dfd53fe | 2015-03-27 15:58:11 +0100 | [diff] [blame] | 642 | for (auto& kv : send_streams_) |
| 643 | delete kv.second; |
| 644 | for (auto& kv : receive_streams_) |
| 645 | delete kv.second; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 646 | } |
| 647 | |
philipel | e8ed830 | 2019-07-03 11:53:48 +0200 | [diff] [blame] | 648 | std::vector<WebRtcVideoChannel::VideoCodecSettings> |
| 649 | WebRtcVideoChannel::SelectSendVideoCodecs( |
magjed | 23b7a4a | 2016-11-08 01:12:54 -0800 | [diff] [blame] | 650 | const std::vector<VideoCodecSettings>& remote_mapped_codecs) const { |
philipel | e8ed830 | 2019-07-03 11:53:48 +0200 | [diff] [blame] | 651 | std::vector<webrtc::SdpVideoFormat> sdp_formats = |
Johannes Kron | 3e98368 | 2020-03-29 22:17:00 +0200 | [diff] [blame] | 652 | encoder_factory_ ? encoder_factory_->GetImplementations() |
| 653 | : std::vector<webrtc::SdpVideoFormat>(); |
philipel | e8ed830 | 2019-07-03 11:53:48 +0200 | [diff] [blame] | 654 | |
| 655 | // The returned vector holds the VideoCodecSettings in term of preference. |
| 656 | // They are orderd by receive codec preference first and local implementation |
| 657 | // preference second. |
| 658 | std::vector<VideoCodecSettings> encoders; |
| 659 | for (const VideoCodecSettings& remote_codec : remote_mapped_codecs) { |
| 660 | for (auto format_it = sdp_formats.begin(); |
| 661 | format_it != sdp_formats.end();) { |
| 662 | // For H264, we will limit the encode level to the remote offered level |
| 663 | // regardless if level asymmetry is allowed or not. This is strictly not |
| 664 | // following the spec in https://tools.ietf.org/html/rfc6184#section-8.2.2 |
| 665 | // since we should limit the encode level to the lower of local and remote |
| 666 | // level when level asymmetry is not allowed. |
| 667 | if (IsSameCodec(format_it->name, format_it->parameters, |
| 668 | remote_codec.codec.name, remote_codec.codec.params)) { |
| 669 | encoders.push_back(remote_codec); |
| 670 | |
| 671 | // To allow the VideoEncoderFactory to keep information about which |
| 672 | // implementation to instantitate when CreateEncoder is called the two |
| 673 | // parmeter sets are merged. |
| 674 | encoders.back().codec.params.insert(format_it->parameters.begin(), |
| 675 | format_it->parameters.end()); |
| 676 | |
| 677 | format_it = sdp_formats.erase(format_it); |
| 678 | } else { |
| 679 | ++format_it; |
| 680 | } |
| 681 | } |
pbos@webrtc.org | 96a9325 | 2014-11-03 14:46:44 +0000 | [diff] [blame] | 682 | } |
philipel | e8ed830 | 2019-07-03 11:53:48 +0200 | [diff] [blame] | 683 | |
| 684 | return encoders; |
pbos@webrtc.org | 96a9325 | 2014-11-03 14:46:44 +0000 | [diff] [blame] | 685 | } |
| 686 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 687 | bool WebRtcVideoChannel::NonFlexfecReceiveCodecsHaveChanged( |
deadbeef | 874ca3a | 2015-08-20 17:19:20 -0700 | [diff] [blame] | 688 | std::vector<VideoCodecSettings> before, |
| 689 | std::vector<VideoCodecSettings> after) { |
deadbeef | 874ca3a | 2015-08-20 17:19:20 -0700 | [diff] [blame] | 690 | // The receive codec order doesn't matter, so we sort the codecs before |
| 691 | // comparing. This is necessary because currently the |
| 692 | // only way to change the send codec is to munge SDP, which causes |
| 693 | // the receive codec list to change order, which causes the streams |
| 694 | // to be recreates which causes a "blink" of black video. In order |
| 695 | // to support munging the SDP in this way without recreating receive |
| 696 | // streams, we ignore the order of the received codecs so that |
| 697 | // changing the order doesn't cause this "blink". |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 698 | auto comparison = [](const VideoCodecSettings& codec1, |
| 699 | const VideoCodecSettings& codec2) { |
| 700 | return codec1.codec.id > codec2.codec.id; |
| 701 | }; |
Steve Anton | 2c9ebef | 2019-01-28 17:27:58 -0800 | [diff] [blame] | 702 | absl::c_sort(before, comparison); |
| 703 | absl::c_sort(after, comparison); |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 704 | |
| 705 | // Changes in FlexFEC payload type are handled separately in |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 706 | // WebRtcVideoChannel::GetChangedRecvParameters, so disregard FlexFEC in the |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 707 | // comparison here. |
Steve Anton | 2c9ebef | 2019-01-28 17:27:58 -0800 | [diff] [blame] | 708 | return !absl::c_equal(before, after, |
| 709 | VideoCodecSettings::EqualsDisregardingFlexfec); |
deadbeef | 874ca3a | 2015-08-20 17:19:20 -0700 | [diff] [blame] | 710 | } |
| 711 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 712 | bool WebRtcVideoChannel::GetChangedSendParameters( |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 713 | const VideoSendParameters& params, |
| 714 | ChangedSendParameters* changed_params) const { |
| 715 | if (!ValidateCodecFormats(params.codecs) || |
| 716 | !ValidateRtpExtensions(params.extensions)) { |
| 717 | return false; |
| 718 | } |
| 719 | |
philipel | e8ed830 | 2019-07-03 11:53:48 +0200 | [diff] [blame] | 720 | std::vector<VideoCodecSettings> negotiated_codecs = |
| 721 | SelectSendVideoCodecs(MapCodecs(params.codecs)); |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 722 | |
Johannes Kron | 3e98368 | 2020-03-29 22:17:00 +0200 | [diff] [blame] | 723 | // We should only fail here if send direction is enabled. |
| 724 | if (params.is_stream_active && negotiated_codecs.empty()) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 725 | RTC_LOG(LS_ERROR) << "No video codecs supported."; |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 726 | return false; |
| 727 | } |
| 728 | |
brandtr | 31bd224 | 2017-05-19 05:47:46 -0700 | [diff] [blame] | 729 | // Never enable sending FlexFEC, unless we are in the experiment. |
| 730 | if (!IsFlexfecFieldTrialEnabled()) { |
philipel | e8ed830 | 2019-07-03 11:53:48 +0200 | [diff] [blame] | 731 | RTC_LOG(LS_INFO) << "WebRTC-FlexFEC-03 field trial is not enabled."; |
| 732 | for (VideoCodecSettings& codec : negotiated_codecs) |
| 733 | codec.flexfec_payload_type = -1; |
brandtr | 31bd224 | 2017-05-19 05:47:46 -0700 | [diff] [blame] | 734 | } |
| 735 | |
philipel | e8ed830 | 2019-07-03 11:53:48 +0200 | [diff] [blame] | 736 | if (negotiated_codecs_ != negotiated_codecs) { |
Johannes Kron | 3e98368 | 2020-03-29 22:17:00 +0200 | [diff] [blame] | 737 | if (negotiated_codecs.empty()) { |
| 738 | changed_params->send_codec = absl::nullopt; |
| 739 | } else if (send_codec_ != negotiated_codecs.front()) { |
philipel | e8ed830 | 2019-07-03 11:53:48 +0200 | [diff] [blame] | 740 | changed_params->send_codec = negotiated_codecs.front(); |
| 741 | } |
| 742 | changed_params->negotiated_codecs = std::move(negotiated_codecs); |
| 743 | } |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 744 | |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 745 | // Handle RTP header extensions. |
Johannes Kron | 9190b82 | 2018-10-29 11:22:05 +0100 | [diff] [blame] | 746 | if (params.extmap_allow_mixed != ExtmapAllowMixed()) { |
| 747 | changed_params->extmap_allow_mixed = params.extmap_allow_mixed; |
| 748 | } |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 749 | std::vector<webrtc::RtpExtension> filtered_extensions = FilterRtpExtensions( |
| 750 | params.extensions, webrtc::RtpExtension::IsSupportedForVideo, true); |
skvlad | 3abb764 | 2016-06-16 12:08:03 -0700 | [diff] [blame] | 751 | if (!send_rtp_extensions_ || (*send_rtp_extensions_ != filtered_extensions)) { |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 752 | changed_params->rtp_header_extensions = |
Danil Chapovalov | 00c7183 | 2018-06-15 15:58:38 +0200 | [diff] [blame] | 753 | absl::optional<std::vector<webrtc::RtpExtension>>(filtered_extensions); |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 754 | } |
| 755 | |
Steve Anton | bb50ce5 | 2018-03-26 10:24:32 -0700 | [diff] [blame] | 756 | if (params.mid != send_params_.mid) { |
| 757 | changed_params->mid = params.mid; |
| 758 | } |
| 759 | |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 760 | // Handle max bitrate. |
Taylor Brandstetter | 58f2bd9 | 2016-04-26 17:15:23 -0700 | [diff] [blame] | 761 | if (params.max_bandwidth_bps != send_params_.max_bandwidth_bps && |
pbos | 5c7760a | 2017-03-10 11:23:12 -0800 | [diff] [blame] | 762 | params.max_bandwidth_bps >= -1) { |
| 763 | // 0 or -1 uncaps max bitrate. |
| 764 | // TODO(pbos): Reconsider how 0 should be treated. It is not mentioned as a |
| 765 | // special value and might very well be used for stopping sending. |
Oskar Sundbom | 7880758 | 2017-11-16 11:09:55 +0100 | [diff] [blame] | 766 | changed_params->max_bandwidth_bps = |
| 767 | params.max_bandwidth_bps == 0 ? -1 : params.max_bandwidth_bps; |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 768 | } |
| 769 | |
nisse | 4b4dc86 | 2016-02-17 05:25:36 -0800 | [diff] [blame] | 770 | // Handle conference mode. |
| 771 | if (params.conference_mode != send_params_.conference_mode) { |
Oskar Sundbom | 7880758 | 2017-11-16 11:09:55 +0100 | [diff] [blame] | 772 | changed_params->conference_mode = params.conference_mode; |
nisse | 4b4dc86 | 2016-02-17 05:25:36 -0800 | [diff] [blame] | 773 | } |
| 774 | |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 775 | // Handle RTCP mode. |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 776 | if (params.rtcp.reduced_size != send_params_.rtcp.reduced_size) { |
Oskar Sundbom | 7880758 | 2017-11-16 11:09:55 +0100 | [diff] [blame] | 777 | changed_params->rtcp_mode = params.rtcp.reduced_size |
| 778 | ? webrtc::RtcpMode::kReducedSize |
| 779 | : webrtc::RtcpMode::kCompound; |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 780 | } |
| 781 | |
| 782 | return true; |
| 783 | } |
| 784 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 785 | bool WebRtcVideoChannel::SetSendParameters(const VideoSendParameters& params) { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 786 | RTC_DCHECK_RUN_ON(&thread_checker_); |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 787 | TRACE_EVENT0("webrtc", "WebRtcVideoChannel::SetSendParameters"); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 788 | RTC_LOG(LS_INFO) << "SetSendParameters: " << params.ToString(); |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 789 | ChangedSendParameters changed_params; |
| 790 | if (!GetChangedSendParameters(params, &changed_params)) { |
deadbeef | 1387149 | 2015-12-09 12:37:51 -0800 | [diff] [blame] | 791 | return false; |
| 792 | } |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 793 | |
philipel | e8ed830 | 2019-07-03 11:53:48 +0200 | [diff] [blame] | 794 | if (changed_params.negotiated_codecs) { |
| 795 | for (const auto& send_codec : *changed_params.negotiated_codecs) |
| 796 | RTC_LOG(LS_INFO) << "Negotiated codec: " << send_codec.codec.ToString(); |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 797 | } |
| 798 | |
philipel | e8ed830 | 2019-07-03 11:53:48 +0200 | [diff] [blame] | 799 | send_params_ = params; |
| 800 | return ApplyChangedParams(changed_params); |
| 801 | } |
| 802 | |
philipel | d9cc8c0 | 2019-09-16 14:53:40 +0200 | [diff] [blame] | 803 | void WebRtcVideoChannel::RequestEncoderFallback() { |
philipel | e8ed830 | 2019-07-03 11:53:48 +0200 | [diff] [blame] | 804 | invoker_.AsyncInvoke<void>( |
| 805 | RTC_FROM_HERE, worker_thread_, [this] { |
| 806 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 807 | if (negotiated_codecs_.size() <= 1) { |
| 808 | RTC_LOG(LS_WARNING) |
| 809 | << "Encoder failed but no fallback codec is available"; |
| 810 | return; |
| 811 | } |
| 812 | |
| 813 | ChangedSendParameters params; |
| 814 | params.negotiated_codecs = negotiated_codecs_; |
| 815 | params.negotiated_codecs->erase(params.negotiated_codecs->begin()); |
| 816 | params.send_codec = params.negotiated_codecs->front(); |
| 817 | ApplyChangedParams(params); |
| 818 | }); |
| 819 | } |
| 820 | |
philipel | d9cc8c0 | 2019-09-16 14:53:40 +0200 | [diff] [blame] | 821 | void WebRtcVideoChannel::RequestEncoderSwitch( |
| 822 | const EncoderSwitchRequestCallback::Config& conf) { |
| 823 | invoker_.AsyncInvoke<void>(RTC_FROM_HERE, worker_thread_, [this, conf] { |
| 824 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 825 | |
philipel | 16cec3b | 2019-10-25 12:23:02 +0200 | [diff] [blame] | 826 | if (!allow_codec_switching_) { |
| 827 | RTC_LOG(LS_INFO) << "Encoder switch requested but codec switching has" |
Jonas Olsson | b2b2031 | 2020-01-14 12:11:31 +0100 | [diff] [blame] | 828 | " not been enabled yet."; |
philipel | dcb4fcc | 2019-12-11 16:35:27 +0100 | [diff] [blame] | 829 | requested_encoder_switch_ = conf; |
philipel | 16cec3b | 2019-10-25 12:23:02 +0200 | [diff] [blame] | 830 | return; |
| 831 | } |
| 832 | |
philipel | d9cc8c0 | 2019-09-16 14:53:40 +0200 | [diff] [blame] | 833 | for (VideoCodecSettings codec_setting : negotiated_codecs_) { |
| 834 | if (codec_setting.codec.name == conf.codec_name) { |
| 835 | if (conf.param) { |
| 836 | auto it = codec_setting.codec.params.find(*conf.param); |
| 837 | |
| 838 | if (it == codec_setting.codec.params.end()) { |
| 839 | continue; |
| 840 | } |
| 841 | |
| 842 | if (conf.value && it->second != *conf.value) { |
| 843 | continue; |
| 844 | } |
| 845 | } |
| 846 | |
| 847 | if (send_codec_ == codec_setting) { |
| 848 | // Already using this codec, no switch required. |
| 849 | return; |
| 850 | } |
| 851 | |
| 852 | ChangedSendParameters params; |
| 853 | params.send_codec = codec_setting; |
| 854 | ApplyChangedParams(params); |
| 855 | return; |
| 856 | } |
| 857 | } |
| 858 | |
| 859 | RTC_LOG(LS_WARNING) << "Requested encoder with codec_name:" |
| 860 | << conf.codec_name |
| 861 | << ", param:" << conf.param.value_or("none") |
| 862 | << " and value:" << conf.value.value_or("none") |
| 863 | << "not found. No switch performed."; |
| 864 | }); |
| 865 | } |
| 866 | |
philipel | 9b05803 | 2020-02-10 11:30:00 +0100 | [diff] [blame] | 867 | void WebRtcVideoChannel::RequestEncoderSwitch( |
| 868 | const webrtc::SdpVideoFormat& format) { |
| 869 | invoker_.AsyncInvoke<void>(RTC_FROM_HERE, worker_thread_, [this, format] { |
| 870 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 871 | |
| 872 | for (const VideoCodecSettings& codec_setting : negotiated_codecs_) { |
| 873 | if (IsSameCodec(format.name, format.parameters, codec_setting.codec.name, |
| 874 | codec_setting.codec.params)) { |
philipel | e457631 | 2020-02-17 17:07:12 +0100 | [diff] [blame] | 875 | VideoCodecSettings new_codec_setting = codec_setting; |
| 876 | for (const auto& kv : format.parameters) { |
| 877 | new_codec_setting.codec.params[kv.first] = kv.second; |
| 878 | } |
| 879 | |
| 880 | if (send_codec_ == new_codec_setting) { |
philipel | 9b05803 | 2020-02-10 11:30:00 +0100 | [diff] [blame] | 881 | // Already using this codec, no switch required. |
| 882 | return; |
| 883 | } |
| 884 | |
| 885 | ChangedSendParameters params; |
philipel | e457631 | 2020-02-17 17:07:12 +0100 | [diff] [blame] | 886 | params.send_codec = new_codec_setting; |
philipel | 9b05803 | 2020-02-10 11:30:00 +0100 | [diff] [blame] | 887 | ApplyChangedParams(params); |
| 888 | return; |
| 889 | } |
| 890 | } |
| 891 | |
| 892 | RTC_LOG(LS_WARNING) << "Encoder switch failed: SdpVideoFormat " |
| 893 | << format.ToString() << " not negotiated."; |
| 894 | }); |
| 895 | } |
| 896 | |
philipel | e8ed830 | 2019-07-03 11:53:48 +0200 | [diff] [blame] | 897 | bool WebRtcVideoChannel::ApplyChangedParams( |
| 898 | const ChangedSendParameters& changed_params) { |
| 899 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 900 | if (changed_params.negotiated_codecs) |
| 901 | negotiated_codecs_ = *changed_params.negotiated_codecs; |
| 902 | |
| 903 | if (changed_params.send_codec) |
| 904 | send_codec_ = changed_params.send_codec; |
| 905 | |
Johannes Kron | 9190b82 | 2018-10-29 11:22:05 +0100 | [diff] [blame] | 906 | if (changed_params.extmap_allow_mixed) { |
| 907 | SetExtmapAllowMixed(*changed_params.extmap_allow_mixed); |
| 908 | } |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 909 | if (changed_params.rtp_header_extensions) { |
skvlad | 3abb764 | 2016-06-16 12:08:03 -0700 | [diff] [blame] | 910 | send_rtp_extensions_ = changed_params.rtp_header_extensions; |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 911 | } |
| 912 | |
philipel | e8ed830 | 2019-07-03 11:53:48 +0200 | [diff] [blame] | 913 | if (changed_params.send_codec || changed_params.max_bandwidth_bps) { |
| 914 | if (send_params_.max_bandwidth_bps == -1) { |
pbos | 5c7760a | 2017-03-10 11:23:12 -0800 | [diff] [blame] | 915 | // Unset the global max bitrate (max_bitrate_bps) if max_bandwidth_bps is |
| 916 | // -1, which corresponds to no "b=AS" attribute in SDP. Note that the |
| 917 | // global max bitrate may be set below in GetBitrateConfigForCodec, from |
| 918 | // the codec max bitrate. |
| 919 | // TODO(pbos): This should be reconsidered (codec max bitrate should |
| 920 | // probably not affect global call max bitrate). |
| 921 | bitrate_config_.max_bitrate_bps = -1; |
| 922 | } |
philipel | e8ed830 | 2019-07-03 11:53:48 +0200 | [diff] [blame] | 923 | |
Taylor Brandstetter | 58f2bd9 | 2016-04-26 17:15:23 -0700 | [diff] [blame] | 924 | if (send_codec_) { |
| 925 | // TODO(holmer): Changing the codec parameters shouldn't necessarily mean |
| 926 | // that we change the min/max of bandwidth estimation. Reevaluate this. |
| 927 | bitrate_config_ = GetBitrateConfigForCodec(send_codec_->codec); |
philipel | e8ed830 | 2019-07-03 11:53:48 +0200 | [diff] [blame] | 928 | if (!changed_params.send_codec) { |
Taylor Brandstetter | 58f2bd9 | 2016-04-26 17:15:23 -0700 | [diff] [blame] | 929 | // If the codec isn't changing, set the start bitrate to -1 which means |
| 930 | // "unchanged" so that BWE isn't affected. |
| 931 | bitrate_config_.start_bitrate_bps = -1; |
| 932 | } |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 933 | } |
philipel | e8ed830 | 2019-07-03 11:53:48 +0200 | [diff] [blame] | 934 | |
| 935 | if (send_params_.max_bandwidth_bps >= 0) { |
Taylor Brandstetter | 58f2bd9 | 2016-04-26 17:15:23 -0700 | [diff] [blame] | 936 | // Note that max_bandwidth_bps intentionally takes priority over the |
| 937 | // bitrate config for the codec. This allows FEC to be applied above the |
| 938 | // codec target bitrate. |
| 939 | // TODO(pbos): Figure out whether b=AS means max bitrate for this |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 940 | // WebRtcVideoChannel (in which case we're good), or per sender (SSRC), |
Sebastian Jansson | fc8d26b | 2018-02-21 09:52:06 +0100 | [diff] [blame] | 941 | // in which case this should not set a BitrateConstraints but rather |
Taylor Brandstetter | 58f2bd9 | 2016-04-26 17:15:23 -0700 | [diff] [blame] | 942 | // reconfigure all senders. |
philipel | e8ed830 | 2019-07-03 11:53:48 +0200 | [diff] [blame] | 943 | bitrate_config_.max_bitrate_bps = send_params_.max_bandwidth_bps == 0 |
| 944 | ? -1 |
| 945 | : send_params_.max_bandwidth_bps; |
Taylor Brandstetter | 58f2bd9 | 2016-04-26 17:15:23 -0700 | [diff] [blame] | 946 | } |
Piotr (Peter) Slatala | 946b968 | 2019-03-18 10:25:02 -0700 | [diff] [blame] | 947 | |
Bjorn A Mellem | 7a9a092 | 2019-11-26 09:19:40 -0800 | [diff] [blame] | 948 | call_->GetTransportControllerSend()->SetSdpBitrateParameters( |
| 949 | bitrate_config_); |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 950 | } |
| 951 | |
Jonas Olsson | a4d8737 | 2019-07-05 19:08:33 +0200 | [diff] [blame] | 952 | for (auto& kv : send_streams_) { |
| 953 | kv.second->SetSendParameters(changed_params); |
| 954 | } |
| 955 | if (changed_params.send_codec || changed_params.rtcp_mode) { |
| 956 | // Update receive feedback parameters from new codec or RTCP mode. |
| 957 | RTC_LOG(LS_INFO) |
| 958 | << "SetFeedbackOptions on all the receive streams because the send " |
| 959 | "codec or RTCP mode has changed."; |
| 960 | for (auto& kv : receive_streams_) { |
| 961 | RTC_DCHECK(kv.second != nullptr); |
| 962 | kv.second->SetFeedbackParameters( |
| 963 | HasLntf(send_codec_->codec), HasNack(send_codec_->codec), |
Niels Möller | 7bf7a42 | 2019-09-13 08:31:45 +0200 | [diff] [blame] | 964 | HasTransportCc(send_codec_->codec), |
Jonas Olsson | a4d8737 | 2019-07-05 19:08:33 +0200 | [diff] [blame] | 965 | send_params_.rtcp.reduced_size ? webrtc::RtcpMode::kReducedSize |
| 966 | : webrtc::RtcpMode::kCompound); |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 967 | } |
Jonas Olsson | a4d8737 | 2019-07-05 19:08:33 +0200 | [diff] [blame] | 968 | } |
deadbeef | 1387149 | 2015-12-09 12:37:51 -0800 | [diff] [blame] | 969 | return true; |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 970 | } |
Taylor Brandstetter | 0cd086b | 2016-04-20 16:23:10 -0700 | [diff] [blame] | 971 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 972 | webrtc::RtpParameters WebRtcVideoChannel::GetRtpSendParameters( |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 973 | uint32_t ssrc) const { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 974 | RTC_DCHECK_RUN_ON(&thread_checker_); |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 975 | auto it = send_streams_.find(ssrc); |
| 976 | if (it == send_streams_.end()) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 977 | RTC_LOG(LS_WARNING) << "Attempting to get RTP send parameters for stream " |
Jonas Olsson | b2b2031 | 2020-01-14 12:11:31 +0100 | [diff] [blame] | 978 | "with ssrc " |
| 979 | << ssrc << " which doesn't exist."; |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 980 | return webrtc::RtpParameters(); |
| 981 | } |
| 982 | |
Taylor Brandstetter | 0cd086b | 2016-04-20 16:23:10 -0700 | [diff] [blame] | 983 | webrtc::RtpParameters rtp_params = it->second->GetRtpParameters(); |
| 984 | // Need to add the common list of codecs to the send stream-specific |
| 985 | // RTP parameters. |
| 986 | for (const VideoCodec& codec : send_params_.codecs) { |
| 987 | rtp_params.codecs.push_back(codec.ToCodecParameters()); |
| 988 | } |
| 989 | return rtp_params; |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 990 | } |
| 991 | |
Zach Stein | ba37b4b | 2018-01-23 15:02:36 -0800 | [diff] [blame] | 992 | webrtc::RTCError WebRtcVideoChannel::SetRtpSendParameters( |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 993 | uint32_t ssrc, |
| 994 | const webrtc::RtpParameters& parameters) { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 995 | RTC_DCHECK_RUN_ON(&thread_checker_); |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 996 | TRACE_EVENT0("webrtc", "WebRtcVideoChannel::SetRtpSendParameters"); |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 997 | auto it = send_streams_.find(ssrc); |
| 998 | if (it == send_streams_.end()) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 999 | RTC_LOG(LS_ERROR) << "Attempting to set RTP send parameters for stream " |
Jonas Olsson | b2b2031 | 2020-01-14 12:11:31 +0100 | [diff] [blame] | 1000 | "with ssrc " |
| 1001 | << ssrc << " which doesn't exist."; |
Zach Stein | ba37b4b | 2018-01-23 15:02:36 -0800 | [diff] [blame] | 1002 | return webrtc::RTCError(webrtc::RTCErrorType::INTERNAL_ERROR); |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1003 | } |
| 1004 | |
Taylor Brandstetter | 0cd086b | 2016-04-20 16:23:10 -0700 | [diff] [blame] | 1005 | // TODO(deadbeef): Handle setting parameters with a list of codecs in a |
| 1006 | // different order (which should change the send codec). |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1007 | webrtc::RtpParameters current_parameters = GetRtpSendParameters(ssrc); |
| 1008 | if (current_parameters.codecs != parameters.codecs) { |
Jonas Olsson | 8544799 | 2018-11-13 14:43:09 +0100 | [diff] [blame] | 1009 | RTC_DLOG(LS_ERROR) << "Using SetParameters to change the set of codecs " |
Jonas Olsson | b2b2031 | 2020-01-14 12:11:31 +0100 | [diff] [blame] | 1010 | "is not currently supported."; |
Zach Stein | ba37b4b | 2018-01-23 15:02:36 -0800 | [diff] [blame] | 1011 | return webrtc::RTCError(webrtc::RTCErrorType::INTERNAL_ERROR); |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1012 | } |
| 1013 | |
Tim Haloun | 648d28a | 2018-10-18 16:52:22 -0700 | [diff] [blame] | 1014 | if (!parameters.encodings.empty()) { |
Taylor Brandstetter | 3f1aee3 | 2020-02-27 11:59:23 -0800 | [diff] [blame] | 1015 | // Note that these values come from: |
| 1016 | // https://tools.ietf.org/html/draft-ietf-tsvwg-rtcweb-qos-16#section-5 |
| 1017 | // TODO(deadbeef): Change values depending on whether we are sending a |
| 1018 | // keyframe or non-keyframe. |
Tim Haloun | 648d28a | 2018-10-18 16:52:22 -0700 | [diff] [blame] | 1019 | rtc::DiffServCodePoint new_dscp = rtc::DSCP_DEFAULT; |
Taylor Brandstetter | 3f1aee3 | 2020-02-27 11:59:23 -0800 | [diff] [blame] | 1020 | switch (parameters.encodings[0].network_priority) { |
| 1021 | case webrtc::Priority::kVeryLow: |
| 1022 | new_dscp = rtc::DSCP_CS1; |
| 1023 | break; |
| 1024 | case webrtc::Priority::kLow: |
| 1025 | new_dscp = rtc::DSCP_DEFAULT; |
| 1026 | break; |
| 1027 | case webrtc::Priority::kMedium: |
| 1028 | new_dscp = rtc::DSCP_AF42; |
| 1029 | break; |
| 1030 | case webrtc::Priority::kHigh: |
| 1031 | new_dscp = rtc::DSCP_AF41; |
| 1032 | break; |
Tim Haloun | 648d28a | 2018-10-18 16:52:22 -0700 | [diff] [blame] | 1033 | } |
Steve Anton | e25f595 | 2019-03-08 15:09:16 -0800 | [diff] [blame] | 1034 | SetPreferredDscp(new_dscp); |
Tim Haloun | 648d28a | 2018-10-18 16:52:22 -0700 | [diff] [blame] | 1035 | } |
| 1036 | |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 1037 | return it->second->SetRtpParameters(parameters); |
| 1038 | } |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1039 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1040 | webrtc::RtpParameters WebRtcVideoChannel::GetRtpReceiveParameters( |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1041 | uint32_t ssrc) const { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1042 | RTC_DCHECK_RUN_ON(&thread_checker_); |
deadbeef | 3bc1510 | 2017-04-20 19:25:07 -0700 | [diff] [blame] | 1043 | webrtc::RtpParameters rtp_params; |
Saurav Das | 749f660 | 2019-12-04 09:31:36 -0800 | [diff] [blame] | 1044 | auto it = receive_streams_.find(ssrc); |
| 1045 | if (it == receive_streams_.end()) { |
| 1046 | RTC_LOG(LS_WARNING) |
| 1047 | << "Attempting to get RTP receive parameters for stream " |
Jonas Olsson | b2b2031 | 2020-01-14 12:11:31 +0100 | [diff] [blame] | 1048 | "with SSRC " |
| 1049 | << ssrc << " which doesn't exist."; |
Saurav Das | 749f660 | 2019-12-04 09:31:36 -0800 | [diff] [blame] | 1050 | return webrtc::RtpParameters(); |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1051 | } |
Saurav Das | 749f660 | 2019-12-04 09:31:36 -0800 | [diff] [blame] | 1052 | rtp_params = it->second->GetRtpParameters(); |
| 1053 | |
| 1054 | // Add codecs, which any stream is prepared to receive. |
| 1055 | for (const VideoCodec& codec : recv_params_.codecs) { |
| 1056 | rtp_params.codecs.push_back(codec.ToCodecParameters()); |
| 1057 | } |
| 1058 | |
| 1059 | return rtp_params; |
| 1060 | } |
| 1061 | |
| 1062 | webrtc::RtpParameters WebRtcVideoChannel::GetDefaultRtpReceiveParameters() |
| 1063 | const { |
| 1064 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 1065 | webrtc::RtpParameters rtp_params; |
| 1066 | if (!default_unsignalled_ssrc_handler_.GetDefaultSink()) { |
| 1067 | RTC_LOG(LS_WARNING) << "Attempting to get RTP parameters for the default, " |
| 1068 | "unsignaled video receive stream, but not yet " |
| 1069 | "configured to receive such a stream."; |
| 1070 | return rtp_params; |
| 1071 | } |
| 1072 | rtp_params.encodings.emplace_back(); |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1073 | |
deadbeef | 3bc1510 | 2017-04-20 19:25:07 -0700 | [diff] [blame] | 1074 | // Add codecs, which any stream is prepared to receive. |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1075 | for (const VideoCodec& codec : recv_params_.codecs) { |
| 1076 | rtp_params.codecs.push_back(codec.ToCodecParameters()); |
| 1077 | } |
Florent Castelli | abe301f | 2018-06-12 18:33:49 +0200 | [diff] [blame] | 1078 | |
Taylor Brandstetter | db0cd9e | 2016-05-16 11:40:30 -0700 | [diff] [blame] | 1079 | return rtp_params; |
| 1080 | } |
| 1081 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1082 | bool WebRtcVideoChannel::GetChangedRecvParameters( |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 1083 | const VideoRecvParameters& params, |
| 1084 | ChangedRecvParameters* changed_params) const { |
| 1085 | if (!ValidateCodecFormats(params.codecs) || |
| 1086 | !ValidateRtpExtensions(params.extensions)) { |
| 1087 | return false; |
| 1088 | } |
| 1089 | |
| 1090 | // Handle receive codecs. |
| 1091 | const std::vector<VideoCodecSettings> mapped_codecs = |
| 1092 | MapCodecs(params.codecs); |
| 1093 | if (mapped_codecs.empty()) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1094 | RTC_LOG(LS_ERROR) << "SetRecvParameters called without any video codecs."; |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 1095 | return false; |
| 1096 | } |
| 1097 | |
magjed | 23b7a4a | 2016-11-08 01:12:54 -0800 | [diff] [blame] | 1098 | // Verify that every mapped codec is supported locally. |
Johannes Kron | 3e98368 | 2020-03-29 22:17:00 +0200 | [diff] [blame] | 1099 | if (params.is_stream_active) { |
| 1100 | const std::vector<VideoCodec> local_supported_codecs = |
| 1101 | GetPayloadTypesAndDefaultCodecs(decoder_factory_, |
| 1102 | /*is_decoder_factory=*/true); |
| 1103 | for (const VideoCodecSettings& mapped_codec : mapped_codecs) { |
| 1104 | if (!FindMatchingCodec(local_supported_codecs, mapped_codec.codec)) { |
| 1105 | RTC_LOG(LS_ERROR) |
| 1106 | << "SetRecvParameters called with unsupported video codec: " |
| 1107 | << mapped_codec.codec.ToString(); |
| 1108 | return false; |
| 1109 | } |
magjed | 23b7a4a | 2016-11-08 01:12:54 -0800 | [diff] [blame] | 1110 | } |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 1111 | } |
| 1112 | |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 1113 | if (NonFlexfecReceiveCodecsHaveChanged(recv_codecs_, mapped_codecs)) { |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 1114 | changed_params->codec_settings = |
Danil Chapovalov | 00c7183 | 2018-06-15 15:58:38 +0200 | [diff] [blame] | 1115 | absl::optional<std::vector<VideoCodecSettings>>(mapped_codecs); |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 1116 | } |
| 1117 | |
| 1118 | // Handle RTP header extensions. |
| 1119 | std::vector<webrtc::RtpExtension> filtered_extensions = FilterRtpExtensions( |
| 1120 | params.extensions, webrtc::RtpExtension::IsSupportedForVideo, false); |
| 1121 | if (filtered_extensions != recv_rtp_extensions_) { |
| 1122 | changed_params->rtp_header_extensions = |
Danil Chapovalov | 00c7183 | 2018-06-15 15:58:38 +0200 | [diff] [blame] | 1123 | absl::optional<std::vector<webrtc::RtpExtension>>(filtered_extensions); |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 1124 | } |
| 1125 | |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 1126 | int flexfec_payload_type = mapped_codecs.front().flexfec_payload_type; |
| 1127 | if (flexfec_payload_type != recv_flexfec_payload_type_) { |
Oskar Sundbom | 7880758 | 2017-11-16 11:09:55 +0100 | [diff] [blame] | 1128 | changed_params->flexfec_payload_type = flexfec_payload_type; |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 1129 | } |
| 1130 | |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 1131 | return true; |
| 1132 | } |
| 1133 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1134 | bool WebRtcVideoChannel::SetRecvParameters(const VideoRecvParameters& params) { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1135 | RTC_DCHECK_RUN_ON(&thread_checker_); |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1136 | TRACE_EVENT0("webrtc", "WebRtcVideoChannel::SetRecvParameters"); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1137 | RTC_LOG(LS_INFO) << "SetRecvParameters: " << params.ToString(); |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 1138 | ChangedRecvParameters changed_params; |
| 1139 | if (!GetChangedRecvParameters(params, &changed_params)) { |
deadbeef | 1387149 | 2015-12-09 12:37:51 -0800 | [diff] [blame] | 1140 | return false; |
| 1141 | } |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 1142 | if (changed_params.flexfec_payload_type) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1143 | RTC_LOG(LS_INFO) << "Changing FlexFEC payload type (recv) from " |
| 1144 | << recv_flexfec_payload_type_ << " to " |
| 1145 | << *changed_params.flexfec_payload_type; |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 1146 | recv_flexfec_payload_type_ = *changed_params.flexfec_payload_type; |
| 1147 | } |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 1148 | if (changed_params.rtp_header_extensions) { |
| 1149 | recv_rtp_extensions_ = *changed_params.rtp_header_extensions; |
| 1150 | } |
| 1151 | if (changed_params.codec_settings) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1152 | RTC_LOG(LS_INFO) << "Changing recv codecs from " |
| 1153 | << CodecSettingsVectorToString(recv_codecs_) << " to " |
| 1154 | << CodecSettingsVectorToString( |
| 1155 | *changed_params.codec_settings); |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 1156 | recv_codecs_ = *changed_params.codec_settings; |
| 1157 | } |
| 1158 | |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1159 | for (auto& kv : receive_streams_) { |
| 1160 | kv.second->SetRecvParameters(changed_params); |
deadbeef | 1387149 | 2015-12-09 12:37:51 -0800 | [diff] [blame] | 1161 | } |
| 1162 | recv_params_ = params; |
| 1163 | return true; |
Peter Thatcher | c2ee2c8 | 2015-08-07 16:05:34 -0700 | [diff] [blame] | 1164 | } |
| 1165 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1166 | std::string WebRtcVideoChannel::CodecSettingsVectorToString( |
deadbeef | 874ca3a | 2015-08-20 17:19:20 -0700 | [diff] [blame] | 1167 | const std::vector<VideoCodecSettings>& codecs) { |
Jonas Olsson | 941a07c | 2018-09-13 10:07:07 +0200 | [diff] [blame] | 1168 | rtc::StringBuilder out; |
| 1169 | out << "{"; |
deadbeef | 874ca3a | 2015-08-20 17:19:20 -0700 | [diff] [blame] | 1170 | for (size_t i = 0; i < codecs.size(); ++i) { |
| 1171 | out << codecs[i].codec.ToString(); |
| 1172 | if (i != codecs.size() - 1) { |
| 1173 | out << ", "; |
| 1174 | } |
| 1175 | } |
Jonas Olsson | 941a07c | 2018-09-13 10:07:07 +0200 | [diff] [blame] | 1176 | out << "}"; |
Jonas Olsson | 84df1c7 | 2018-09-14 16:59:32 +0200 | [diff] [blame] | 1177 | return out.Release(); |
deadbeef | 874ca3a | 2015-08-20 17:19:20 -0700 | [diff] [blame] | 1178 | } |
| 1179 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1180 | bool WebRtcVideoChannel::GetSendCodec(VideoCodec* codec) { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1181 | RTC_DCHECK_RUN_ON(&thread_checker_); |
kwiberg | 102c6a6 | 2015-10-30 02:47:38 -0700 | [diff] [blame] | 1182 | if (!send_codec_) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1183 | RTC_LOG(LS_VERBOSE) << "GetSendCodec: No send codec set."; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1184 | return false; |
| 1185 | } |
kwiberg | 102c6a6 | 2015-10-30 02:47:38 -0700 | [diff] [blame] | 1186 | *codec = send_codec_->codec; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1187 | return true; |
| 1188 | } |
| 1189 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1190 | bool WebRtcVideoChannel::SetSend(bool send) { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1191 | RTC_DCHECK_RUN_ON(&thread_checker_); |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1192 | TRACE_EVENT0("webrtc", "WebRtcVideoChannel::SetSend"); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1193 | RTC_LOG(LS_VERBOSE) << "SetSend: " << (send ? "true" : "false"); |
kwiberg | 102c6a6 | 2015-10-30 02:47:38 -0700 | [diff] [blame] | 1194 | if (send && !send_codec_) { |
Jonas Olsson | 8544799 | 2018-11-13 14:43:09 +0100 | [diff] [blame] | 1195 | RTC_DLOG(LS_ERROR) << "SetSend(true) called before setting codec."; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1196 | return false; |
| 1197 | } |
Jonas Olsson | a4d8737 | 2019-07-05 19:08:33 +0200 | [diff] [blame] | 1198 | for (const auto& kv : send_streams_) { |
| 1199 | kv.second->SetSend(send); |
| 1200 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1201 | sending_ = send; |
| 1202 | return true; |
| 1203 | } |
| 1204 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1205 | bool WebRtcVideoChannel::SetVideoSend( |
deadbeef | 5a4a75a | 2016-06-02 16:23:38 -0700 | [diff] [blame] | 1206 | uint32_t ssrc, |
deadbeef | 5a4a75a | 2016-06-02 16:23:38 -0700 | [diff] [blame] | 1207 | const VideoOptions* options, |
nisse | acd935b | 2016-11-11 03:55:13 -0800 | [diff] [blame] | 1208 | rtc::VideoSourceInterface<webrtc::VideoFrame>* source) { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1209 | RTC_DCHECK_RUN_ON(&thread_checker_); |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 1210 | TRACE_EVENT0("webrtc", "SetVideoSend"); |
deadbeef | 5a4a75a | 2016-06-02 16:23:38 -0700 | [diff] [blame] | 1211 | RTC_DCHECK(ssrc != 0); |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 1212 | RTC_LOG(LS_INFO) << "SetVideoSend (ssrc= " << ssrc << ", options: " |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1213 | << (options ? options->ToString() : "nullptr") |
| 1214 | << ", source = " << (source ? "(source)" : "nullptr") << ")"; |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 1215 | |
deadbeef | 5a4a75a | 2016-06-02 16:23:38 -0700 | [diff] [blame] | 1216 | const auto& kv = send_streams_.find(ssrc); |
| 1217 | if (kv == send_streams_.end()) { |
| 1218 | // Allow unknown ssrc only if source is null. |
| 1219 | RTC_CHECK(source == nullptr); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1220 | RTC_LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc; |
deadbeef | 5a4a75a | 2016-06-02 16:23:38 -0700 | [diff] [blame] | 1221 | return false; |
solenberg | 1dd98f3 | 2015-09-10 01:57:14 -0700 | [diff] [blame] | 1222 | } |
deadbeef | 5a4a75a | 2016-06-02 16:23:38 -0700 | [diff] [blame] | 1223 | |
Niels Möller | ff40b14 | 2018-04-09 08:49:14 +0200 | [diff] [blame] | 1224 | return kv->second->SetVideoSend(options, source); |
solenberg | 1dd98f3 | 2015-09-10 01:57:14 -0700 | [diff] [blame] | 1225 | } |
| 1226 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1227 | bool WebRtcVideoChannel::ValidateSendSsrcAvailability( |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1228 | const StreamParams& sp) const { |
Per | a509241 | 2016-02-12 13:30:57 +0100 | [diff] [blame] | 1229 | for (uint32_t ssrc : sp.ssrcs) { |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1230 | if (send_ssrcs_.find(ssrc) != send_ssrcs_.end()) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1231 | RTC_LOG(LS_ERROR) << "Send stream with SSRC '" << ssrc |
| 1232 | << "' already exists."; |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1233 | return false; |
| 1234 | } |
| 1235 | } |
| 1236 | return true; |
| 1237 | } |
| 1238 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1239 | bool WebRtcVideoChannel::ValidateReceiveSsrcAvailability( |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1240 | const StreamParams& sp) const { |
Per | a509241 | 2016-02-12 13:30:57 +0100 | [diff] [blame] | 1241 | for (uint32_t ssrc : sp.ssrcs) { |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1242 | if (receive_ssrcs_.find(ssrc) != receive_ssrcs_.end()) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1243 | RTC_LOG(LS_ERROR) << "Receive stream with SSRC '" << ssrc |
| 1244 | << "' already exists."; |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1245 | return false; |
| 1246 | } |
| 1247 | } |
| 1248 | return true; |
| 1249 | } |
| 1250 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1251 | bool WebRtcVideoChannel::AddSendStream(const StreamParams& sp) { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1252 | RTC_DCHECK_RUN_ON(&thread_checker_); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1253 | RTC_LOG(LS_INFO) << "AddSendStream: " << sp.ToString(); |
Peter Boström | d4362cd | 2015-03-25 14:17:23 +0100 | [diff] [blame] | 1254 | if (!ValidateStreamParams(sp)) |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1255 | return false; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1256 | |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1257 | if (!ValidateSendSsrcAvailability(sp)) |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1258 | return false; |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1259 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1260 | for (uint32_t used_ssrc : sp.ssrcs) |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1261 | send_ssrcs_.insert(used_ssrc); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1262 | |
Bjorn A Mellem | 7a9a092 | 2019-11-26 09:19:40 -0800 | [diff] [blame] | 1263 | webrtc::VideoSendStream::Config config(this); |
Amit Hilbuch | b000b71 | 2019-02-25 10:22:14 -0800 | [diff] [blame] | 1264 | |
| 1265 | for (const RidDescription& rid : sp.rids()) { |
| 1266 | config.rtp.rids.push_back(rid.rid); |
| 1267 | } |
| 1268 | |
nisse | 0db023a | 2016-03-01 04:29:59 -0800 | [diff] [blame] | 1269 | config.suspend_below_min_bitrate = video_config_.suspend_below_min_bitrate; |
sergeyu | 80ed35e | 2016-11-28 13:11:13 -0800 | [diff] [blame] | 1270 | config.periodic_alr_bandwidth_probing = |
| 1271 | video_config_.periodic_alr_bandwidth_probing; |
Niels Möller | 6539f69 | 2018-01-18 08:58:50 +0100 | [diff] [blame] | 1272 | config.encoder_settings.experiment_cpu_load_estimator = |
| 1273 | video_config_.experiment_cpu_load_estimator; |
Niels Möller | 88614b0 | 2018-03-27 16:39:01 +0200 | [diff] [blame] | 1274 | config.encoder_settings.encoder_factory = encoder_factory_; |
Jiawei Ou | c2ebe21 | 2018-11-08 10:02:56 -0800 | [diff] [blame] | 1275 | config.encoder_settings.bitrate_allocator_factory = |
| 1276 | bitrate_allocator_factory_; |
philipel | d9cc8c0 | 2019-09-16 14:53:40 +0200 | [diff] [blame] | 1277 | config.encoder_settings.encoder_switch_request_callback = this; |
Benjamin Wright | 192eeec | 2018-10-17 17:27:25 -0700 | [diff] [blame] | 1278 | config.crypto_options = crypto_options_; |
Johannes Kron | 9190b82 | 2018-10-29 11:22:05 +0100 | [diff] [blame] | 1279 | config.rtp.extmap_allow_mixed = ExtmapAllowMixed(); |
Jiawei Ou | 5571812 | 2018-11-09 13:17:39 -0800 | [diff] [blame] | 1280 | config.rtcp_report_interval_ms = video_config_.rtcp_report_interval_ms; |
Niels Möller | 6539f69 | 2018-01-18 08:58:50 +0100 | [diff] [blame] | 1281 | |
Anton Sukhanov | 316f3ac | 2019-05-23 15:50:38 -0700 | [diff] [blame] | 1282 | // If sending through Datagram Transport, limit packet size to maximum |
| 1283 | // packet size supported by datagram_transport. |
| 1284 | if (media_transport_config().rtp_max_packet_size) { |
| 1285 | config.rtp.max_packet_size = |
| 1286 | media_transport_config().rtp_max_packet_size.value(); |
| 1287 | } |
| 1288 | |
nisse | 0510331 | 2016-03-16 02:22:50 -0700 | [diff] [blame] | 1289 | WebRtcVideoSendStream* stream = new WebRtcVideoSendStream( |
Niels Möller | 88614b0 | 2018-03-27 16:39:01 +0200 | [diff] [blame] | 1290 | call_, sp, std::move(config), default_send_options_, |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 1291 | video_config_.enable_cpu_adaptation, bitrate_config_.max_bitrate_bps, |
| 1292 | send_codec_, send_rtp_extensions_, send_params_); |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1293 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1294 | uint32_t ssrc = sp.first_ssrc(); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 1295 | RTC_DCHECK(ssrc != 0); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1296 | send_streams_[ssrc] = stream; |
| 1297 | |
| 1298 | if (rtcp_receiver_report_ssrc_ == kDefaultRtcpReceiverReportSsrc) { |
| 1299 | rtcp_receiver_report_ssrc_ = ssrc; |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1300 | RTC_LOG(LS_INFO) |
| 1301 | << "SetLocalSsrc on all the receive streams because we added " |
| 1302 | "a send stream."; |
Peter Boström | 3548dd2 | 2015-05-22 18:48:36 +0200 | [diff] [blame] | 1303 | for (auto& kv : receive_streams_) |
| 1304 | kv.second->SetLocalSsrc(ssrc); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1305 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1306 | if (sending_) { |
deadbeef | dbe2b87 | 2016-03-22 15:42:00 -0700 | [diff] [blame] | 1307 | stream->SetSend(true); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1308 | } |
| 1309 | |
| 1310 | return true; |
| 1311 | } |
| 1312 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1313 | bool WebRtcVideoChannel::RemoveSendStream(uint32_t ssrc) { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1314 | RTC_DCHECK_RUN_ON(&thread_checker_); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1315 | RTC_LOG(LS_INFO) << "RemoveSendStream: " << ssrc; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1316 | |
pbos@webrtc.org | 575d126 | 2014-10-08 14:48:08 +0000 | [diff] [blame] | 1317 | WebRtcVideoSendStream* removed_stream; |
Jonas Olsson | a4d8737 | 2019-07-05 19:08:33 +0200 | [diff] [blame] | 1318 | std::map<uint32_t, WebRtcVideoSendStream*>::iterator it = |
| 1319 | send_streams_.find(ssrc); |
| 1320 | if (it == send_streams_.end()) { |
| 1321 | return false; |
| 1322 | } |
| 1323 | |
| 1324 | for (uint32_t old_ssrc : it->second->GetSsrcs()) |
| 1325 | send_ssrcs_.erase(old_ssrc); |
| 1326 | |
| 1327 | removed_stream = it->second; |
| 1328 | send_streams_.erase(it); |
| 1329 | |
| 1330 | // Switch receiver report SSRCs, the one in use is no longer valid. |
| 1331 | if (rtcp_receiver_report_ssrc_ == ssrc) { |
| 1332 | rtcp_receiver_report_ssrc_ = send_streams_.empty() |
| 1333 | ? kDefaultRtcpReceiverReportSsrc |
| 1334 | : send_streams_.begin()->first; |
| 1335 | RTC_LOG(LS_INFO) << "SetLocalSsrc on all the receive streams because the " |
| 1336 | "previous local SSRC was removed."; |
| 1337 | |
| 1338 | for (auto& kv : receive_streams_) { |
| 1339 | kv.second->SetLocalSsrc(rtcp_receiver_report_ssrc_); |
pbos@webrtc.org | 575d126 | 2014-10-08 14:48:08 +0000 | [diff] [blame] | 1340 | } |
Jonas Olsson | a4d8737 | 2019-07-05 19:08:33 +0200 | [diff] [blame] | 1341 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1342 | |
pbos@webrtc.org | 575d126 | 2014-10-08 14:48:08 +0000 | [diff] [blame] | 1343 | delete removed_stream; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1344 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1345 | return true; |
| 1346 | } |
| 1347 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1348 | void WebRtcVideoChannel::DeleteReceiveStream( |
| 1349 | WebRtcVideoChannel::WebRtcVideoReceiveStream* stream) { |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1350 | for (uint32_t old_ssrc : stream->GetSsrcs()) |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1351 | receive_ssrcs_.erase(old_ssrc); |
| 1352 | delete stream; |
| 1353 | } |
| 1354 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1355 | bool WebRtcVideoChannel::AddRecvStream(const StreamParams& sp) { |
pbos@webrtc.org | a2a6fe6 | 2015-03-06 15:35:19 +0000 | [diff] [blame] | 1356 | return AddRecvStream(sp, false); |
| 1357 | } |
| 1358 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1359 | bool WebRtcVideoChannel::AddRecvStream(const StreamParams& sp, |
| 1360 | bool default_stream) { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1361 | RTC_DCHECK_RUN_ON(&thread_checker_); |
Fredrik Solenberg | 4b60c73 | 2015-05-07 14:07:48 +0200 | [diff] [blame] | 1362 | |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1363 | RTC_LOG(LS_INFO) << "AddRecvStream" |
| 1364 | << (default_stream ? " (default stream)" : "") << ": " |
| 1365 | << sp.ToString(); |
Seth Hampson | 5897a6e | 2018-04-03 11:16:33 -0700 | [diff] [blame] | 1366 | if (!sp.has_ssrcs()) { |
| 1367 | // This is a StreamParam with unsignaled SSRCs. Store it, so it can be used |
| 1368 | // later when we know the SSRC on the first packet arrival. |
| 1369 | unsignaled_stream_params_ = sp; |
| 1370 | return true; |
| 1371 | } |
| 1372 | |
Peter Boström | d4362cd | 2015-03-25 14:17:23 +0100 | [diff] [blame] | 1373 | if (!ValidateStreamParams(sp)) |
| 1374 | return false; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1375 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1376 | uint32_t ssrc = sp.first_ssrc(); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1377 | |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1378 | // Remove running stream if this was a default stream. |
nisse | a293ef0 | 2016-02-17 07:24:50 -0800 | [diff] [blame] | 1379 | const auto& prev_stream = receive_streams_.find(ssrc); |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1380 | if (prev_stream != receive_streams_.end()) { |
| 1381 | if (default_stream || !prev_stream->second->IsDefaultStream()) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1382 | RTC_LOG(LS_ERROR) << "Receive stream for SSRC '" << ssrc |
| 1383 | << "' already exists."; |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1384 | return false; |
pbos@webrtc.org | a2a6fe6 | 2015-03-06 15:35:19 +0000 | [diff] [blame] | 1385 | } |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1386 | DeleteReceiveStream(prev_stream->second); |
| 1387 | receive_streams_.erase(prev_stream); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1388 | } |
| 1389 | |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1390 | if (!ValidateReceiveSsrcAvailability(sp)) |
| 1391 | return false; |
| 1392 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1393 | for (uint32_t used_ssrc : sp.ssrcs) |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1394 | receive_ssrcs_.insert(used_ssrc); |
| 1395 | |
Bjorn A Mellem | 7a9a092 | 2019-11-26 09:19:40 -0800 | [diff] [blame] | 1396 | webrtc::VideoReceiveStream::Config config(this); |
brandtr | 8313a6f | 2017-01-13 07:41:19 -0800 | [diff] [blame] | 1397 | webrtc::FlexfecReceiveStream::Config flexfec_config(this); |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 1398 | ConfigureReceiverRtp(&config, &flexfec_config, sp); |
pbos@webrtc.org | 3bf3d23 | 2014-10-31 12:59:34 +0000 | [diff] [blame] | 1399 | |
Benjamin Wright | 192eeec | 2018-10-17 17:27:25 -0700 | [diff] [blame] | 1400 | config.crypto_options = crypto_options_; |
Rasmus Brandt | 1e27fec | 2019-01-23 09:47:50 +0100 | [diff] [blame] | 1401 | config.enable_prerenderer_smoothing = |
| 1402 | video_config_.enable_prerenderer_smoothing; |
Seth Hampson | 845e878 | 2018-03-02 11:34:10 -0800 | [diff] [blame] | 1403 | if (!sp.stream_ids().empty()) { |
| 1404 | config.sync_group = sp.stream_ids()[0]; |
Steve Anton | 5a26a3a | 2018-02-28 11:38:47 -0800 | [diff] [blame] | 1405 | } |
Peter Boström | 126c03e | 2015-05-11 12:48:12 +0200 | [diff] [blame] | 1406 | |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1407 | receive_streams_[ssrc] = new WebRtcVideoReceiveStream( |
Jonas Oreland | 6d83592 | 2019-03-18 10:59:40 +0100 | [diff] [blame] | 1408 | this, call_, sp, std::move(config), decoder_factory_, default_stream, |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 1409 | recv_codecs_, flexfec_config); |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1410 | |
| 1411 | return true; |
| 1412 | } |
| 1413 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1414 | void WebRtcVideoChannel::ConfigureReceiverRtp( |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1415 | webrtc::VideoReceiveStream::Config* config, |
brandtr | 8313a6f | 2017-01-13 07:41:19 -0800 | [diff] [blame] | 1416 | webrtc::FlexfecReceiveStream::Config* flexfec_config, |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1417 | const StreamParams& sp) const { |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1418 | uint32_t ssrc = sp.first_ssrc(); |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1419 | |
| 1420 | config->rtp.remote_ssrc = ssrc; |
| 1421 | config->rtp.local_ssrc = rtcp_receiver_report_ssrc_; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1422 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1423 | // TODO(pbos): This protection is against setting the same local ssrc as |
| 1424 | // remote which is not permitted by the lower-level API. RTCP requires a |
| 1425 | // corresponding sender SSRC. Figure out what to do when we don't have |
| 1426 | // (receive-only) or know a good local SSRC. |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1427 | if (config->rtp.remote_ssrc == config->rtp.local_ssrc) { |
| 1428 | if (config->rtp.local_ssrc != kDefaultRtcpReceiverReportSsrc) { |
| 1429 | config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1430 | } else { |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1431 | config->rtp.local_ssrc = kDefaultRtcpReceiverReportSsrc + 1; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1432 | } |
| 1433 | } |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1434 | |
brandtr | 11273f1 | 2017-01-10 05:18:15 -0800 | [diff] [blame] | 1435 | // Whether or not the receive stream sends reduced size RTCP is determined |
| 1436 | // by the send params. |
| 1437 | // TODO(deadbeef): Once we change "send_params" to "sender_params" and |
| 1438 | // "recv_params" to "receiver_params", we should get this out of |
| 1439 | // receiver_params_. |
| 1440 | config->rtp.rtcp_mode = send_params_.rtcp.reduced_size |
| 1441 | ? webrtc::RtcpMode::kReducedSize |
| 1442 | : webrtc::RtcpMode::kCompound; |
| 1443 | |
brandtr | 11273f1 | 2017-01-10 05:18:15 -0800 | [diff] [blame] | 1444 | config->rtp.transport_cc = |
| 1445 | send_codec_ ? HasTransportCc(send_codec_->codec) : false; |
| 1446 | |
brandtr | 9d58d94 | 2017-02-03 04:43:41 -0800 | [diff] [blame] | 1447 | sp.GetFidSsrc(ssrc, &config->rtp.rtx_ssrc); |
| 1448 | |
| 1449 | config->rtp.extensions = recv_rtp_extensions_; |
| 1450 | |
brandtr | 11273f1 | 2017-01-10 05:18:15 -0800 | [diff] [blame] | 1451 | // TODO(brandtr): Generalize when we add support for multistream protection. |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 1452 | flexfec_config->payload_type = recv_flexfec_payload_type_; |
brandtr | 31bd224 | 2017-05-19 05:47:46 -0700 | [diff] [blame] | 1453 | if (IsFlexfecAdvertisedFieldTrialEnabled() && |
| 1454 | sp.GetFecFrSsrc(ssrc, &flexfec_config->remote_ssrc)) { |
brandtr | 11273f1 | 2017-01-10 05:18:15 -0800 | [diff] [blame] | 1455 | flexfec_config->protected_media_ssrcs = {ssrc}; |
brandtr | 8313a6f | 2017-01-13 07:41:19 -0800 | [diff] [blame] | 1456 | flexfec_config->local_ssrc = config->rtp.local_ssrc; |
| 1457 | flexfec_config->rtcp_mode = config->rtp.rtcp_mode; |
brandtr | 9d58d94 | 2017-02-03 04:43:41 -0800 | [diff] [blame] | 1458 | // TODO(brandtr): We should be spec-compliant and set |transport_cc| here |
| 1459 | // based on the rtcp-fb for the FlexFEC codec, not the media codec. |
brandtr | 8313a6f | 2017-01-13 07:41:19 -0800 | [diff] [blame] | 1460 | flexfec_config->transport_cc = config->rtp.transport_cc; |
| 1461 | flexfec_config->rtp_header_extensions = config->rtp.extensions; |
brandtr | 11273f1 | 2017-01-10 05:18:15 -0800 | [diff] [blame] | 1462 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1463 | } |
| 1464 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1465 | bool WebRtcVideoChannel::RemoveRecvStream(uint32_t ssrc) { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1466 | RTC_DCHECK_RUN_ON(&thread_checker_); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1467 | RTC_LOG(LS_INFO) << "RemoveRecvStream: " << ssrc; |
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 | std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator stream = |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1470 | receive_streams_.find(ssrc); |
| 1471 | if (stream == receive_streams_.end()) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1472 | RTC_LOG(LS_ERROR) << "Stream not found for ssrc: " << ssrc; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1473 | return false; |
| 1474 | } |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 1475 | DeleteReceiveStream(stream->second); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1476 | receive_streams_.erase(stream); |
| 1477 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1478 | return true; |
| 1479 | } |
| 1480 | |
Saurav Das | ff27da5 | 2019-09-20 11:05:30 -0700 | [diff] [blame] | 1481 | void WebRtcVideoChannel::ResetUnsignaledRecvStream() { |
| 1482 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 1483 | RTC_LOG(LS_INFO) << "ResetUnsignaledRecvStream."; |
| 1484 | unsignaled_stream_params_ = StreamParams(); |
| 1485 | } |
| 1486 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1487 | bool WebRtcVideoChannel::SetSink( |
nisse | acd935b | 2016-11-11 03:55:13 -0800 | [diff] [blame] | 1488 | uint32_t ssrc, |
| 1489 | rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1490 | RTC_DCHECK_RUN_ON(&thread_checker_); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1491 | RTC_LOG(LS_INFO) << "SetSink: ssrc:" << ssrc << " " |
| 1492 | << (sink ? "(ptr)" : "nullptr"); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1493 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1494 | std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it = |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 1495 | receive_streams_.find(ssrc); |
| 1496 | if (it == receive_streams_.end()) { |
| 1497 | return false; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1498 | } |
| 1499 | |
nisse | 08582ff | 2016-02-04 01:24:52 -0800 | [diff] [blame] | 1500 | it->second->SetSink(sink); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1501 | return true; |
| 1502 | } |
| 1503 | |
Saurav Das | 749f660 | 2019-12-04 09:31:36 -0800 | [diff] [blame] | 1504 | void WebRtcVideoChannel::SetDefaultSink( |
| 1505 | rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) { |
| 1506 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 1507 | RTC_LOG(LS_INFO) << "SetDefaultSink: " << (sink ? "(ptr)" : "nullptr"); |
| 1508 | default_unsignalled_ssrc_handler_.SetDefaultSink(this, sink); |
| 1509 | } |
| 1510 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1511 | bool WebRtcVideoChannel::GetStats(VideoMediaInfo* info) { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1512 | RTC_DCHECK_RUN_ON(&thread_checker_); |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1513 | TRACE_EVENT0("webrtc", "WebRtcVideoChannel::GetStats"); |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 1514 | |
| 1515 | // Log stats periodically. |
| 1516 | bool log_stats = false; |
| 1517 | int64_t now_ms = rtc::TimeMillis(); |
| 1518 | if (last_stats_log_ms_ == -1 || |
| 1519 | now_ms - last_stats_log_ms_ > kStatsLogIntervalMs) { |
| 1520 | last_stats_log_ms_ = now_ms; |
| 1521 | log_stats = true; |
| 1522 | } |
| 1523 | |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 1524 | info->Clear(); |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 1525 | FillSenderStats(info, log_stats); |
| 1526 | FillReceiverStats(info, log_stats); |
hbos | a65704b | 2016-11-14 02:28:16 -0800 | [diff] [blame] | 1527 | FillSendAndReceiveCodecStats(info); |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 1528 | // TODO(holmer): We should either have rtt available as a metric on |
| 1529 | // VideoSend/ReceiveStreams, or we should remove rtt from VideoSenderInfo. |
Niels Möller | 4687915 | 2019-01-07 15:54:47 +0100 | [diff] [blame] | 1530 | // TODO(nisse): Arrange to get correct RTT also when using MediaTransport. |
pbos@webrtc.org | 2b19f06 | 2014-12-11 13:26:09 +0000 | [diff] [blame] | 1531 | webrtc::Call::Stats stats = call_->GetStats(); |
pbos@webrtc.org | 2b19f06 | 2014-12-11 13:26:09 +0000 | [diff] [blame] | 1532 | if (stats.rtt_ms != -1) { |
| 1533 | for (size_t i = 0; i < info->senders.size(); ++i) { |
| 1534 | info->senders[i].rtt_ms = stats.rtt_ms; |
| 1535 | } |
| 1536 | } |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 1537 | |
| 1538 | if (log_stats) |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1539 | RTC_LOG(LS_INFO) << stats.ToString(now_ms); |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 1540 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1541 | return true; |
| 1542 | } |
| 1543 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1544 | void WebRtcVideoChannel::FillSenderStats(VideoMediaInfo* video_media_info, |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 1545 | bool log_stats) { |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1546 | for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator it = |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 1547 | send_streams_.begin(); |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1548 | it != send_streams_.end(); ++it) { |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 1549 | video_media_info->senders.push_back( |
| 1550 | it->second->GetVideoSenderInfo(log_stats)); |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 1551 | } |
| 1552 | } |
| 1553 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1554 | void WebRtcVideoChannel::FillReceiverStats(VideoMediaInfo* video_media_info, |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 1555 | bool log_stats) { |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1556 | for (std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it = |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 1557 | receive_streams_.begin(); |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1558 | it != receive_streams_.end(); ++it) { |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 1559 | video_media_info->receivers.push_back( |
| 1560 | it->second->GetVideoReceiverInfo(log_stats)); |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 1561 | } |
| 1562 | } |
| 1563 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1564 | void WebRtcVideoChannel::FillBitrateInfo(BandwidthEstimationInfo* bwe_info) { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1565 | RTC_DCHECK_RUN_ON(&thread_checker_); |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1566 | for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator stream = |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 1567 | send_streams_.begin(); |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 1568 | stream != send_streams_.end(); ++stream) { |
stefan | f79ade1 | 2017-06-02 06:44:03 -0700 | [diff] [blame] | 1569 | stream->second->FillBitrateInfo(bwe_info); |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 1570 | } |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 1571 | } |
| 1572 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1573 | void WebRtcVideoChannel::FillSendAndReceiveCodecStats( |
hbos | a65704b | 2016-11-14 02:28:16 -0800 | [diff] [blame] | 1574 | VideoMediaInfo* video_media_info) { |
| 1575 | for (const VideoCodec& codec : send_params_.codecs) { |
| 1576 | webrtc::RtpCodecParameters codec_params = codec.ToCodecParameters(); |
| 1577 | video_media_info->send_codecs.insert( |
| 1578 | std::make_pair(codec_params.payload_type, std::move(codec_params))); |
| 1579 | } |
| 1580 | for (const VideoCodec& codec : recv_params_.codecs) { |
| 1581 | webrtc::RtpCodecParameters codec_params = codec.ToCodecParameters(); |
| 1582 | video_media_info->receive_codecs.insert( |
| 1583 | std::make_pair(codec_params.payload_type, std::move(codec_params))); |
| 1584 | } |
| 1585 | } |
| 1586 | |
Amit Hilbuch | e7a5f7b | 2019-03-12 11:10:27 -0700 | [diff] [blame] | 1587 | void WebRtcVideoChannel::OnPacketReceived(rtc::CopyOnWriteBuffer packet, |
Niels Möller | e693381 | 2018-11-05 13:01:41 +0100 | [diff] [blame] | 1588 | int64_t packet_time_us) { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1589 | RTC_DCHECK_RUN_ON(&thread_checker_); |
pbos@webrtc.org | 4e545cc | 2014-05-14 13:58:13 +0000 | [diff] [blame] | 1590 | const webrtc::PacketReceiver::DeliveryStatus delivery_result = |
Amit Hilbuch | e7a5f7b | 2019-03-12 11:10:27 -0700 | [diff] [blame] | 1591 | call_->Receiver()->DeliverPacket(webrtc::MediaType::VIDEO, packet, |
Niels Möller | e693381 | 2018-11-05 13:01:41 +0100 | [diff] [blame] | 1592 | packet_time_us); |
pbos@webrtc.org | 4e545cc | 2014-05-14 13:58:13 +0000 | [diff] [blame] | 1593 | switch (delivery_result) { |
| 1594 | case webrtc::PacketReceiver::DELIVERY_OK: |
| 1595 | return; |
| 1596 | case webrtc::PacketReceiver::DELIVERY_PACKET_ERROR: |
| 1597 | return; |
| 1598 | case webrtc::PacketReceiver::DELIVERY_UNKNOWN_SSRC: |
| 1599 | break; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1600 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1601 | |
Jonas Oreland | 6d83592 | 2019-03-18 10:59:40 +0100 | [diff] [blame] | 1602 | uint32_t ssrc = 0; |
| 1603 | if (!GetRtpSsrc(packet.cdata(), packet.size(), &ssrc)) { |
Åsa Persson | 2c7149b | 2018-10-15 09:36:10 +0200 | [diff] [blame] | 1604 | return; |
| 1605 | } |
| 1606 | |
Jonas Oreland | 6d83592 | 2019-03-18 10:59:40 +0100 | [diff] [blame] | 1607 | if (unknown_ssrc_packet_buffer_) { |
| 1608 | unknown_ssrc_packet_buffer_->AddPacket(ssrc, packet_time_us, packet); |
| 1609 | return; |
| 1610 | } |
| 1611 | |
| 1612 | if (discard_unknown_ssrc_packets_) { |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1613 | return; |
| 1614 | } |
| 1615 | |
noahric | d10a68e | 2015-07-10 11:27:55 -0700 | [diff] [blame] | 1616 | int payload_type = 0; |
Amit Hilbuch | e7a5f7b | 2019-03-12 11:10:27 -0700 | [diff] [blame] | 1617 | if (!GetRtpPayloadType(packet.cdata(), packet.size(), &payload_type)) { |
noahric | d10a68e | 2015-07-10 11:27:55 -0700 | [diff] [blame] | 1618 | return; |
| 1619 | } |
| 1620 | |
| 1621 | // 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] | 1622 | // 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] | 1623 | // it wasn't handled above by DeliverPacket, that means we don't know what |
| 1624 | // stream it associates with, and we shouldn't ever create an implicit channel |
| 1625 | // for these. |
| 1626 | for (auto& codec : recv_codecs_) { |
| 1627 | if (payload_type == codec.rtx_payload_type || |
brandtr | b5f2c3f | 2016-10-04 23:28:39 -0700 | [diff] [blame] | 1628 | payload_type == codec.ulpfec.red_rtx_payload_type || |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 1629 | payload_type == codec.ulpfec.ulpfec_payload_type) { |
noahric | d10a68e | 2015-07-10 11:27:55 -0700 | [diff] [blame] | 1630 | return; |
| 1631 | } |
| 1632 | } |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 1633 | if (payload_type == recv_flexfec_payload_type_) { |
| 1634 | return; |
| 1635 | } |
noahric | d10a68e | 2015-07-10 11:27:55 -0700 | [diff] [blame] | 1636 | |
pbos@webrtc.org | afb554f4 | 2014-08-12 23:17:13 +0000 | [diff] [blame] | 1637 | switch (unsignalled_ssrc_handler_->OnUnsignalledSsrc(this, ssrc)) { |
| 1638 | case UnsignalledSsrcHandler::kDropPacket: |
| 1639 | return; |
| 1640 | case UnsignalledSsrcHandler::kDeliverPacket: |
| 1641 | break; |
| 1642 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1643 | |
Amit Hilbuch | e7a5f7b | 2019-03-12 11:10:27 -0700 | [diff] [blame] | 1644 | if (call_->Receiver()->DeliverPacket(webrtc::MediaType::VIDEO, packet, |
Niels Möller | e693381 | 2018-11-05 13:01:41 +0100 | [diff] [blame] | 1645 | packet_time_us) != |
Danil Chapovalov | 292a73e | 2017-12-07 17:00:40 +0100 | [diff] [blame] | 1646 | webrtc::PacketReceiver::DELIVERY_OK) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1647 | RTC_LOG(LS_WARNING) << "Failed to deliver RTP packet on re-delivery."; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1648 | return; |
| 1649 | } |
| 1650 | } |
| 1651 | |
Jonas Oreland | 6d83592 | 2019-03-18 10:59:40 +0100 | [diff] [blame] | 1652 | void WebRtcVideoChannel::BackfillBufferedPackets( |
| 1653 | rtc::ArrayView<const uint32_t> ssrcs) { |
| 1654 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 1655 | if (!unknown_ssrc_packet_buffer_) { |
| 1656 | return; |
| 1657 | } |
| 1658 | |
| 1659 | int delivery_ok_cnt = 0; |
| 1660 | int delivery_unknown_ssrc_cnt = 0; |
| 1661 | int delivery_packet_error_cnt = 0; |
| 1662 | webrtc::PacketReceiver* receiver = this->call_->Receiver(); |
| 1663 | unknown_ssrc_packet_buffer_->BackfillPackets( |
| 1664 | ssrcs, [&](uint32_t ssrc, int64_t packet_time_us, |
| 1665 | rtc::CopyOnWriteBuffer packet) { |
| 1666 | switch (receiver->DeliverPacket(webrtc::MediaType::VIDEO, packet, |
| 1667 | packet_time_us)) { |
| 1668 | case webrtc::PacketReceiver::DELIVERY_OK: |
| 1669 | delivery_ok_cnt++; |
| 1670 | break; |
| 1671 | case webrtc::PacketReceiver::DELIVERY_UNKNOWN_SSRC: |
| 1672 | delivery_unknown_ssrc_cnt++; |
| 1673 | break; |
| 1674 | case webrtc::PacketReceiver::DELIVERY_PACKET_ERROR: |
| 1675 | delivery_packet_error_cnt++; |
| 1676 | break; |
| 1677 | } |
| 1678 | }); |
| 1679 | rtc::StringBuilder out; |
| 1680 | out << "[ "; |
| 1681 | for (uint32_t ssrc : ssrcs) { |
| 1682 | out << std::to_string(ssrc) << " "; |
| 1683 | } |
| 1684 | out << "]"; |
| 1685 | auto level = rtc::LS_INFO; |
| 1686 | if (delivery_unknown_ssrc_cnt > 0 || delivery_packet_error_cnt > 0) { |
| 1687 | level = rtc::LS_ERROR; |
| 1688 | } |
| 1689 | int total = |
| 1690 | delivery_ok_cnt + delivery_unknown_ssrc_cnt + delivery_packet_error_cnt; |
| 1691 | RTC_LOG_V(level) << "Backfilled " << total |
| 1692 | << " packets for ssrcs: " << out.Release() |
| 1693 | << " ok: " << delivery_ok_cnt |
| 1694 | << " error: " << delivery_packet_error_cnt |
| 1695 | << " unknown: " << delivery_unknown_ssrc_cnt; |
| 1696 | } |
| 1697 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1698 | void WebRtcVideoChannel::OnReadyToSend(bool ready) { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1699 | RTC_DCHECK_RUN_ON(&thread_checker_); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1700 | RTC_LOG(LS_VERBOSE) << "OnReadyToSend: " << (ready ? "Ready." : "Not ready."); |
skvlad | 7a43d25 | 2016-03-22 15:32:27 -0700 | [diff] [blame] | 1701 | call_->SignalChannelNetworkState( |
| 1702 | webrtc::MediaType::VIDEO, |
| 1703 | ready ? webrtc::kNetworkUp : webrtc::kNetworkDown); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1704 | } |
| 1705 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1706 | void WebRtcVideoChannel::OnNetworkRouteChanged( |
Honghai Zhang | cc411c0 | 2016-03-29 17:27:21 -0700 | [diff] [blame] | 1707 | const std::string& transport_name, |
Honghai Zhang | 0e533ef | 2016-04-19 15:41:36 -0700 | [diff] [blame] | 1708 | const rtc::NetworkRoute& network_route) { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1709 | RTC_DCHECK_RUN_ON(&thread_checker_); |
Sebastian Jansson | 8f83b42 | 2018-02-21 13:07:13 +0100 | [diff] [blame] | 1710 | call_->GetTransportControllerSend()->OnNetworkRouteChanged(transport_name, |
| 1711 | network_route); |
Stefan Holmer | 64be7fa | 2018-10-04 15:21:55 +0200 | [diff] [blame] | 1712 | call_->GetTransportControllerSend()->OnTransportOverheadChanged( |
| 1713 | network_route.packet_overhead); |
michaelt | 79e0588 | 2016-11-08 02:50:09 -0800 | [diff] [blame] | 1714 | } |
| 1715 | |
Anton Sukhanov | 98a462c | 2018-10-17 13:15:42 -0700 | [diff] [blame] | 1716 | void WebRtcVideoChannel::SetInterface( |
| 1717 | NetworkInterface* iface, |
Anton Sukhanov | 4f08faa | 2019-05-21 11:12:57 -0700 | [diff] [blame] | 1718 | const webrtc::MediaTransportConfig& media_transport_config) { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1719 | RTC_DCHECK_RUN_ON(&thread_checker_); |
Anton Sukhanov | 4f08faa | 2019-05-21 11:12:57 -0700 | [diff] [blame] | 1720 | MediaChannel::SetInterface(iface, media_transport_config); |
Erik Språng | 820ebd0 | 2018-08-20 17:14:25 +0200 | [diff] [blame] | 1721 | // Set the RTP recv/send buffer to a bigger size. |
| 1722 | |
Johannes Kron | 5a0665b | 2019-04-08 10:35:50 +0200 | [diff] [blame] | 1723 | // The group should be a positive integer with an explicit size, in |
| 1724 | // which case that is used as UDP recevie buffer size. All other values shall |
| 1725 | // result in the default value being used. |
| 1726 | const std::string group_name = |
| 1727 | webrtc::field_trial::FindFullName("WebRTC-IncreasedReceivebuffers"); |
| 1728 | int recv_buffer_size = kVideoRtpRecvBufferSize; |
| 1729 | if (!group_name.empty() && |
| 1730 | (sscanf(group_name.c_str(), "%d", &recv_buffer_size) != 1 || |
| 1731 | recv_buffer_size <= 0)) { |
| 1732 | RTC_LOG(LS_WARNING) << "Invalid receive buffer size: " << group_name; |
| 1733 | recv_buffer_size = kVideoRtpRecvBufferSize; |
| 1734 | } |
| 1735 | |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 1736 | MediaChannel::SetOption(NetworkInterface::ST_RTP, rtc::Socket::OPT_RCVBUF, |
Johannes Kron | 5a0665b | 2019-04-08 10:35:50 +0200 | [diff] [blame] | 1737 | recv_buffer_size); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1738 | |
buildbot@webrtc.org | ae694ef | 2014-10-28 17:37:17 +0000 | [diff] [blame] | 1739 | // Speculative change to increase the outbound socket buffer size. |
| 1740 | // In b/15152257, we are seeing a significant number of packets discarded |
| 1741 | // due to lack of socket buffer space, although it's not yet clear what the |
| 1742 | // ideal value should be. |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 1743 | MediaChannel::SetOption(NetworkInterface::ST_RTP, rtc::Socket::OPT_SNDBUF, |
Johannes Kron | d38a2b8 | 2018-10-23 11:31:19 +0200 | [diff] [blame] | 1744 | kVideoRtpSendBufferSize); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1745 | } |
| 1746 | |
Benjamin Wright | 192eeec | 2018-10-17 17:27:25 -0700 | [diff] [blame] | 1747 | void WebRtcVideoChannel::SetFrameDecryptor( |
| 1748 | uint32_t ssrc, |
| 1749 | rtc::scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor) { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1750 | RTC_DCHECK_RUN_ON(&thread_checker_); |
Benjamin Wright | 192eeec | 2018-10-17 17:27:25 -0700 | [diff] [blame] | 1751 | auto matching_stream = receive_streams_.find(ssrc); |
| 1752 | if (matching_stream != receive_streams_.end()) { |
| 1753 | matching_stream->second->SetFrameDecryptor(frame_decryptor); |
| 1754 | } |
| 1755 | } |
| 1756 | |
| 1757 | void WebRtcVideoChannel::SetFrameEncryptor( |
| 1758 | uint32_t ssrc, |
| 1759 | rtc::scoped_refptr<webrtc::FrameEncryptorInterface> frame_encryptor) { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1760 | RTC_DCHECK_RUN_ON(&thread_checker_); |
Benjamin Wright | 192eeec | 2018-10-17 17:27:25 -0700 | [diff] [blame] | 1761 | auto matching_stream = send_streams_.find(ssrc); |
| 1762 | if (matching_stream != send_streams_.end()) { |
| 1763 | matching_stream->second->SetFrameEncryptor(frame_encryptor); |
| 1764 | } else { |
| 1765 | RTC_LOG(LS_ERROR) << "No stream found to attach frame encryptor"; |
| 1766 | } |
| 1767 | } |
| 1768 | |
philipel | 16cec3b | 2019-10-25 12:23:02 +0200 | [diff] [blame] | 1769 | void WebRtcVideoChannel::SetVideoCodecSwitchingEnabled(bool enabled) { |
| 1770 | invoker_.AsyncInvoke<void>(RTC_FROM_HERE, worker_thread_, [this, enabled] { |
| 1771 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 1772 | allow_codec_switching_ = enabled; |
philipel | dcb4fcc | 2019-12-11 16:35:27 +0100 | [diff] [blame] | 1773 | if (allow_codec_switching_) { |
| 1774 | RTC_LOG(LS_INFO) << "Encoder switching enabled."; |
| 1775 | if (requested_encoder_switch_) { |
| 1776 | RTC_LOG(LS_INFO) << "Executing cached video encoder switch request."; |
| 1777 | RequestEncoderSwitch(*requested_encoder_switch_); |
| 1778 | requested_encoder_switch_.reset(); |
| 1779 | } |
| 1780 | } |
philipel | 16cec3b | 2019-10-25 12:23:02 +0200 | [diff] [blame] | 1781 | }); |
| 1782 | } |
| 1783 | |
Ruslan Burakov | 493a650 | 2019-02-27 15:32:48 +0100 | [diff] [blame] | 1784 | bool WebRtcVideoChannel::SetBaseMinimumPlayoutDelayMs(uint32_t ssrc, |
| 1785 | int delay_ms) { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1786 | RTC_DCHECK_RUN_ON(&thread_checker_); |
Ruslan Burakov | 493a650 | 2019-02-27 15:32:48 +0100 | [diff] [blame] | 1787 | absl::optional<uint32_t> default_ssrc = GetDefaultReceiveStreamSsrc(); |
Ruslan Burakov | 493a650 | 2019-02-27 15:32:48 +0100 | [diff] [blame] | 1788 | |
| 1789 | // SSRC of 0 represents the default receive stream. |
| 1790 | if (ssrc == 0) { |
| 1791 | default_recv_base_minimum_delay_ms_ = delay_ms; |
| 1792 | } |
| 1793 | |
| 1794 | if (ssrc == 0 && !default_ssrc) { |
| 1795 | return true; |
| 1796 | } |
| 1797 | |
| 1798 | if (ssrc == 0 && default_ssrc) { |
| 1799 | ssrc = default_ssrc.value(); |
| 1800 | } |
| 1801 | |
| 1802 | auto stream = receive_streams_.find(ssrc); |
| 1803 | if (stream != receive_streams_.end()) { |
| 1804 | stream->second->SetBaseMinimumPlayoutDelayMs(delay_ms); |
| 1805 | return true; |
| 1806 | } else { |
| 1807 | RTC_LOG(LS_ERROR) << "No stream found to set base minimum playout delay"; |
| 1808 | return false; |
| 1809 | } |
| 1810 | } |
| 1811 | |
| 1812 | absl::optional<int> WebRtcVideoChannel::GetBaseMinimumPlayoutDelayMs( |
| 1813 | uint32_t ssrc) const { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1814 | RTC_DCHECK_RUN_ON(&thread_checker_); |
Ruslan Burakov | 493a650 | 2019-02-27 15:32:48 +0100 | [diff] [blame] | 1815 | // SSRC of 0 represents the default receive stream. |
| 1816 | if (ssrc == 0) { |
| 1817 | return default_recv_base_minimum_delay_ms_; |
| 1818 | } |
| 1819 | |
| 1820 | auto stream = receive_streams_.find(ssrc); |
| 1821 | if (stream != receive_streams_.end()) { |
| 1822 | return stream->second->GetBaseMinimumPlayoutDelayMs(); |
| 1823 | } else { |
| 1824 | RTC_LOG(LS_ERROR) << "No stream found to get base minimum playout delay"; |
| 1825 | return absl::nullopt; |
| 1826 | } |
| 1827 | } |
| 1828 | |
Danil Chapovalov | 00c7183 | 2018-06-15 15:58:38 +0200 | [diff] [blame] | 1829 | absl::optional<uint32_t> WebRtcVideoChannel::GetDefaultReceiveStreamSsrc() { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1830 | RTC_DCHECK_RUN_ON(&thread_checker_); |
Danil Chapovalov | 00c7183 | 2018-06-15 15:58:38 +0200 | [diff] [blame] | 1831 | absl::optional<uint32_t> ssrc; |
brandtr | 0dc57ea | 2017-05-29 23:33:31 -0700 | [diff] [blame] | 1832 | for (auto it = receive_streams_.begin(); it != receive_streams_.end(); ++it) { |
| 1833 | if (it->second->IsDefaultStream()) { |
| 1834 | ssrc.emplace(it->first); |
| 1835 | break; |
| 1836 | } |
| 1837 | } |
| 1838 | return ssrc; |
| 1839 | } |
| 1840 | |
Jonas Oreland | 49ac595 | 2018-09-26 16:04:32 +0200 | [diff] [blame] | 1841 | std::vector<webrtc::RtpSource> WebRtcVideoChannel::GetSources( |
| 1842 | uint32_t ssrc) const { |
Steve Anton | ef50b25 | 2019-03-01 15:15:38 -0800 | [diff] [blame] | 1843 | RTC_DCHECK_RUN_ON(&thread_checker_); |
Jonas Oreland | 49ac595 | 2018-09-26 16:04:32 +0200 | [diff] [blame] | 1844 | auto it = receive_streams_.find(ssrc); |
| 1845 | if (it == receive_streams_.end()) { |
| 1846 | // TODO(bugs.webrtc.org/9781): Investigate standard compliance |
| 1847 | // with sources for streams that has been removed. |
| 1848 | RTC_LOG(LS_ERROR) << "Attempting to get contributing sources for SSRC:" |
| 1849 | << ssrc << " which doesn't exist."; |
| 1850 | return {}; |
| 1851 | } |
| 1852 | return it->second->GetSources(); |
| 1853 | } |
| 1854 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1855 | bool WebRtcVideoChannel::SendRtp(const uint8_t* data, |
| 1856 | size_t len, |
| 1857 | const webrtc::PacketOptions& options) { |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 1858 | rtc::CopyOnWriteBuffer packet(data, len, kMaxRtpPacketLen); |
stefan | c1aeaf0 | 2015-10-15 07:26:07 -0700 | [diff] [blame] | 1859 | rtc::PacketOptions rtc_options; |
| 1860 | rtc_options.packet_id = options.packet_id; |
Tim Haloun | 6ca9836 | 2018-09-17 17:06:08 -0700 | [diff] [blame] | 1861 | if (DscpEnabled()) { |
| 1862 | rtc_options.dscp = PreferredDscp(); |
| 1863 | } |
Sebastian Jansson | 0378997 | 2018-10-09 18:27:57 +0200 | [diff] [blame] | 1864 | rtc_options.info_signaled_after_sent.included_in_feedback = |
| 1865 | options.included_in_feedback; |
| 1866 | rtc_options.info_signaled_after_sent.included_in_allocation = |
| 1867 | options.included_in_allocation; |
stefan | c1aeaf0 | 2015-10-15 07:26:07 -0700 | [diff] [blame] | 1868 | return MediaChannel::SendPacket(&packet, rtc_options); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1869 | } |
| 1870 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1871 | bool WebRtcVideoChannel::SendRtcp(const uint8_t* data, size_t len) { |
jbauch | eec21bd | 2016-03-20 06:15:43 -0700 | [diff] [blame] | 1872 | rtc::CopyOnWriteBuffer packet(data, len, kMaxRtpPacketLen); |
Tim Haloun | 6ca9836 | 2018-09-17 17:06:08 -0700 | [diff] [blame] | 1873 | rtc::PacketOptions rtc_options; |
| 1874 | if (DscpEnabled()) { |
| 1875 | rtc_options.dscp = PreferredDscp(); |
| 1876 | } |
Tim Haloun | 648d28a | 2018-10-18 16:52:22 -0700 | [diff] [blame] | 1877 | |
Tim Haloun | 6ca9836 | 2018-09-17 17:06:08 -0700 | [diff] [blame] | 1878 | return MediaChannel::SendRtcp(&packet, rtc_options); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1879 | } |
| 1880 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1881 | WebRtcVideoChannel::WebRtcVideoSendStream::VideoSendStreamParameters:: |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 1882 | VideoSendStreamParameters( |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 1883 | webrtc::VideoSendStream::Config config, |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 1884 | const VideoOptions& options, |
Peter Boström | dfd53fe | 2015-03-27 15:58:11 +0100 | [diff] [blame] | 1885 | int max_bitrate_bps, |
Danil Chapovalov | 00c7183 | 2018-06-15 15:58:38 +0200 | [diff] [blame] | 1886 | const absl::optional<VideoCodecSettings>& codec_settings) |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 1887 | : config(std::move(config)), |
Peter Boström | dfd53fe | 2015-03-27 15:58:11 +0100 | [diff] [blame] | 1888 | options(options), |
| 1889 | max_bitrate_bps(max_bitrate_bps), |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1890 | conference_mode(false), |
kwiberg | 102c6a6 | 2015-10-30 02:47:38 -0700 | [diff] [blame] | 1891 | codec_settings(codec_settings) {} |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 1892 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1893 | WebRtcVideoChannel::WebRtcVideoSendStream::WebRtcVideoSendStream( |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1894 | webrtc::Call* call, |
solenberg | 4fbae2b | 2015-08-28 04:07:10 -0700 | [diff] [blame] | 1895 | const StreamParams& sp, |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 1896 | webrtc::VideoSendStream::Config config, |
nisse | 0510331 | 2016-03-16 02:22:50 -0700 | [diff] [blame] | 1897 | const VideoOptions& options, |
perkj | 2d5f091 | 2016-02-29 00:04:41 -0800 | [diff] [blame] | 1898 | bool enable_cpu_overuse_detection, |
Peter Boström | dfd53fe | 2015-03-27 15:58:11 +0100 | [diff] [blame] | 1899 | int max_bitrate_bps, |
Danil Chapovalov | 00c7183 | 2018-06-15 15:58:38 +0200 | [diff] [blame] | 1900 | const absl::optional<VideoCodecSettings>& codec_settings, |
| 1901 | const absl::optional<std::vector<webrtc::RtpExtension>>& rtp_extensions, |
deadbeef | 1387149 | 2015-12-09 12:37:51 -0800 | [diff] [blame] | 1902 | // TODO(deadbeef): Don't duplicate information between send_params, |
| 1903 | // rtp_extensions, options, etc. |
| 1904 | const VideoSendParameters& send_params) |
perkj | 2d5f091 | 2016-02-29 00:04:41 -0800 | [diff] [blame] | 1905 | : worker_thread_(rtc::Thread::Current()), |
| 1906 | ssrcs_(sp.ssrcs), |
Peter Boström | 259bd20 | 2015-05-28 13:39:50 +0200 | [diff] [blame] | 1907 | ssrc_groups_(sp.ssrc_groups), |
Henrik Kjellander | 7c027b6 | 2015-04-22 13:21:30 +0200 | [diff] [blame] | 1908 | call_(call), |
perkj | 803d97f | 2016-11-01 11:45:46 -0700 | [diff] [blame] | 1909 | enable_cpu_overuse_detection_(enable_cpu_overuse_detection), |
nisse | 2ded9b1 | 2016-04-08 02:23:55 -0700 | [diff] [blame] | 1910 | source_(nullptr), |
perkj | 2d5f091 | 2016-02-29 00:04:41 -0800 | [diff] [blame] | 1911 | stream_(nullptr), |
Christian Fremerey | 6c02541 | 2019-02-13 19:43:28 +0000 | [diff] [blame] | 1912 | encoder_sink_(nullptr), |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 1913 | parameters_(std::move(config), options, max_bitrate_bps, codec_settings), |
Zach Stein | 3ca452b | 2018-01-18 10:01:24 -0800 | [diff] [blame] | 1914 | rtp_parameters_(CreateRtpParametersWithEncodings(sp)), |
Niels Möller | ac0a4cb | 2019-10-09 15:01:33 +0200 | [diff] [blame] | 1915 | sending_(false) { |
Anton Sukhanov | 4f08faa | 2019-05-21 11:12:57 -0700 | [diff] [blame] | 1916 | // Maximum packet size may come in RtpConfig from external transport, for |
| 1917 | // example from QuicTransportInterface implementation, so do not exceed |
| 1918 | // given max_packet_size. |
| 1919 | parameters_.config.rtp.max_packet_size = |
| 1920 | std::min<size_t>(parameters_.config.rtp.max_packet_size, kVideoMtu); |
nisse | 4b4dc86 | 2016-02-17 05:25:36 -0800 | [diff] [blame] | 1921 | parameters_.conference_mode = send_params.conference_mode; |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1922 | |
| 1923 | sp.GetPrimarySsrcs(¶meters_.config.rtp.ssrcs); |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 1924 | |
deadbeef | fb2aced | 2017-01-06 23:05:37 -0800 | [diff] [blame] | 1925 | // ValidateStreamParams should prevent this from happening. |
| 1926 | RTC_CHECK(!parameters_.config.rtp.ssrcs.empty()); |
Oskar Sundbom | 7880758 | 2017-11-16 11:09:55 +0100 | [diff] [blame] | 1927 | rtp_parameters_.encodings[0].ssrc = parameters_.config.rtp.ssrcs[0]; |
deadbeef | fb2aced | 2017-01-06 23:05:37 -0800 | [diff] [blame] | 1928 | |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 1929 | // RTX. |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1930 | sp.GetFidSsrcs(parameters_.config.rtp.ssrcs, |
| 1931 | ¶meters_.config.rtp.rtx.ssrcs); |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 1932 | |
brandtr | 340e3fd | 2017-02-28 15:43:10 -0800 | [diff] [blame] | 1933 | // FlexFEC SSRCs. |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 1934 | // TODO(brandtr): This code needs to be generalized when we add support for |
| 1935 | // multistream protection. |
| 1936 | if (IsFlexfecFieldTrialEnabled()) { |
| 1937 | uint32_t flexfec_ssrc; |
| 1938 | bool flexfec_enabled = false; |
| 1939 | for (uint32_t primary_ssrc : parameters_.config.rtp.ssrcs) { |
| 1940 | if (sp.GetFecFrSsrc(primary_ssrc, &flexfec_ssrc)) { |
| 1941 | if (flexfec_enabled) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 1942 | RTC_LOG(LS_INFO) |
| 1943 | << "Multiple FlexFEC streams in local SDP, but " |
| 1944 | "our implementation only supports a single FlexFEC " |
| 1945 | "stream. Will not enable FlexFEC for proposed " |
| 1946 | "stream with SSRC: " |
| 1947 | << flexfec_ssrc << "."; |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 1948 | continue; |
| 1949 | } |
| 1950 | |
| 1951 | flexfec_enabled = true; |
brandtr | 3d200bd | 2017-01-16 06:59:19 -0800 | [diff] [blame] | 1952 | parameters_.config.rtp.flexfec.ssrc = flexfec_ssrc; |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 1953 | parameters_.config.rtp.flexfec.protected_media_ssrcs = {primary_ssrc}; |
| 1954 | } |
| 1955 | } |
| 1956 | } |
| 1957 | |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1958 | parameters_.config.rtp.c_name = sp.cname; |
skvlad | 3abb764 | 2016-06-16 12:08:03 -0700 | [diff] [blame] | 1959 | if (rtp_extensions) { |
| 1960 | parameters_.config.rtp.extensions = *rtp_extensions; |
Florent Castelli | abe301f | 2018-06-12 18:33:49 +0200 | [diff] [blame] | 1961 | rtp_parameters_.header_extensions = *rtp_extensions; |
skvlad | 3abb764 | 2016-06-16 12:08:03 -0700 | [diff] [blame] | 1962 | } |
deadbeef | 1387149 | 2015-12-09 12:37:51 -0800 | [diff] [blame] | 1963 | parameters_.config.rtp.rtcp_mode = send_params.rtcp.reduced_size |
| 1964 | ? webrtc::RtcpMode::kReducedSize |
| 1965 | : webrtc::RtcpMode::kCompound; |
Steve Anton | bb50ce5 | 2018-03-26 10:24:32 -0700 | [diff] [blame] | 1966 | parameters_.config.rtp.mid = send_params.mid; |
Florent Castelli | dacec71 | 2018-05-24 16:24:21 +0200 | [diff] [blame] | 1967 | rtp_parameters_.rtcp.reduced_size = send_params.rtcp.reduced_size; |
| 1968 | |
kwiberg | 102c6a6 | 2015-10-30 02:47:38 -0700 | [diff] [blame] | 1969 | if (codec_settings) { |
Niels Möller | 5bf8ccd | 2018-03-15 14:16:11 +0100 | [diff] [blame] | 1970 | SetCodec(*codec_settings); |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1971 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1972 | } |
| 1973 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1974 | WebRtcVideoChannel::WebRtcVideoSendStream::~WebRtcVideoSendStream() { |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 1975 | if (stream_ != NULL) { |
| 1976 | call_->DestroyVideoSendStream(stream_); |
| 1977 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 1978 | } |
| 1979 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 1980 | bool WebRtcVideoChannel::WebRtcVideoSendStream::SetVideoSend( |
deadbeef | 5a4a75a | 2016-06-02 16:23:38 -0700 | [diff] [blame] | 1981 | const VideoOptions* options, |
nisse | acd935b | 2016-11-11 03:55:13 -0800 | [diff] [blame] | 1982 | rtc::VideoSourceInterface<webrtc::VideoFrame>* source) { |
deadbeef | 5a4a75a | 2016-06-02 16:23:38 -0700 | [diff] [blame] | 1983 | TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetVideoSend"); |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1984 | RTC_DCHECK_RUN_ON(&thread_checker_); |
nisse | 2ded9b1 | 2016-04-08 02:23:55 -0700 | [diff] [blame] | 1985 | |
Niels Möller | ff40b14 | 2018-04-09 08:49:14 +0200 | [diff] [blame] | 1986 | if (options) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 1987 | VideoOptions old_options = parameters_.options; |
| 1988 | parameters_.options.SetAll(*options); |
sprang | f24a064 | 2017-02-28 13:23:26 -0800 | [diff] [blame] | 1989 | if (parameters_.options.is_screencast.value_or(false) != |
| 1990 | old_options.is_screencast.value_or(false) && |
| 1991 | parameters_.codec_settings) { |
| 1992 | // If screen content settings change, we may need to recreate the codec |
| 1993 | // instance so that the correct type is used. |
| 1994 | |
Niels Möller | 5bf8ccd | 2018-03-15 14:16:11 +0100 | [diff] [blame] | 1995 | SetCodec(*parameters_.codec_settings); |
sprang | f24a064 | 2017-02-28 13:23:26 -0800 | [diff] [blame] | 1996 | // Mark screenshare parameter as being updated, then test for any other |
| 1997 | // changes that may require codec reconfiguration. |
| 1998 | old_options.is_screencast = options->is_screencast; |
| 1999 | } |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2000 | if (parameters_.options != old_options) { |
| 2001 | ReconfigureEncoder(); |
perkj | 3b703ed | 2016-09-29 23:25:40 -0700 | [diff] [blame] | 2002 | } |
perkj | 26105b4 | 2016-09-29 22:39:10 -0700 | [diff] [blame] | 2003 | } |
| 2004 | |
perkj | 803d97f | 2016-11-01 11:45:46 -0700 | [diff] [blame] | 2005 | if (source_ && stream_) { |
Taylor Brandstetter | 49fcc10 | 2018-05-16 14:20:41 -0700 | [diff] [blame] | 2006 | stream_->SetSource(nullptr, webrtc::DegradationPreference::DISABLED); |
perkj | 803d97f | 2016-11-01 11:45:46 -0700 | [diff] [blame] | 2007 | } |
| 2008 | // Switch to the new source. |
| 2009 | source_ = source; |
| 2010 | if (source && stream_) { |
Christian Fremerey | 6c02541 | 2019-02-13 19:43:28 +0000 | [diff] [blame] | 2011 | stream_->SetSource(this, GetDegradationPreference()); |
nisse | 2ded9b1 | 2016-04-08 02:23:55 -0700 | [diff] [blame] | 2012 | } |
deadbeef | 5a4a75a | 2016-06-02 16:23:38 -0700 | [diff] [blame] | 2013 | return true; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2014 | } |
| 2015 | |
Taylor Brandstetter | 49fcc10 | 2018-05-16 14:20:41 -0700 | [diff] [blame] | 2016 | webrtc::DegradationPreference |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2017 | WebRtcVideoChannel::WebRtcVideoSendStream::GetDegradationPreference() const { |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 2018 | // Do not adapt resolution for screen content as this will likely |
| 2019 | // result in blurry and unreadable text. |
| 2020 | // |this| acts like a VideoSource to make sure SinkWants are handled on the |
| 2021 | // correct thread. |
Florent Castelli | b05ca4b | 2020-03-05 13:39:55 +0100 | [diff] [blame] | 2022 | if (!enable_cpu_overuse_detection_) { |
| 2023 | return webrtc::DegradationPreference::DISABLED; |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 2024 | } |
Florent Castelli | b05ca4b | 2020-03-05 13:39:55 +0100 | [diff] [blame] | 2025 | |
| 2026 | webrtc::DegradationPreference degradation_preference; |
| 2027 | if (rtp_parameters_.degradation_preference.has_value()) { |
| 2028 | degradation_preference = *rtp_parameters_.degradation_preference; |
| 2029 | } else { |
| 2030 | if (parameters_.options.content_hint == |
| 2031 | webrtc::VideoTrackInterface::ContentHint::kFluid) { |
| 2032 | degradation_preference = |
| 2033 | webrtc::DegradationPreference::MAINTAIN_FRAMERATE; |
| 2034 | } else if (parameters_.options.is_screencast.value_or(false) || |
| 2035 | parameters_.options.content_hint == |
| 2036 | webrtc::VideoTrackInterface::ContentHint::kDetailed || |
| 2037 | parameters_.options.content_hint == |
| 2038 | webrtc::VideoTrackInterface::ContentHint::kText) { |
| 2039 | degradation_preference = |
| 2040 | webrtc::DegradationPreference::MAINTAIN_RESOLUTION; |
| 2041 | } else if (webrtc::field_trial::IsEnabled( |
| 2042 | "WebRTC-Video-BalancedDegradation")) { |
| 2043 | // Standard wants balanced by default, but it needs to be tuned first. |
| 2044 | degradation_preference = webrtc::DegradationPreference::BALANCED; |
| 2045 | } else { |
| 2046 | // Keep MAINTAIN_FRAMERATE by default until BALANCED has been tuned for |
| 2047 | // all codecs and launched. |
| 2048 | degradation_preference = |
| 2049 | webrtc::DegradationPreference::MAINTAIN_FRAMERATE; |
| 2050 | } |
| 2051 | } |
| 2052 | |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 2053 | return degradation_preference; |
| 2054 | } |
| 2055 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 2056 | const std::vector<uint32_t>& |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2057 | WebRtcVideoChannel::WebRtcVideoSendStream::GetSsrcs() const { |
Peter Boström | d6f4c25 | 2015-03-26 16:23:04 +0100 | [diff] [blame] | 2058 | return ssrcs_; |
| 2059 | } |
| 2060 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2061 | void WebRtcVideoChannel::WebRtcVideoSendStream::SetCodec( |
Niels Möller | 5bf8ccd | 2018-03-15 14:16:11 +0100 | [diff] [blame] | 2062 | const VideoCodecSettings& codec_settings) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2063 | RTC_DCHECK_RUN_ON(&thread_checker_); |
skvlad | 3abb764 | 2016-06-16 12:08:03 -0700 | [diff] [blame] | 2064 | parameters_.encoder_config = CreateVideoEncoderConfig(codec_settings.codec); |
kwiberg | af476c7 | 2016-11-28 15:21:39 -0800 | [diff] [blame] | 2065 | RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0); |
pbos@webrtc.org | a2ef4fe | 2014-11-07 10:54:43 +0000 | [diff] [blame] | 2066 | |
Niels Möller | 259a497 | 2018-04-05 15:36:51 +0200 | [diff] [blame] | 2067 | parameters_.config.rtp.payload_name = codec_settings.codec.name; |
| 2068 | parameters_.config.rtp.payload_type = codec_settings.codec.id; |
Mirta Dvornicic | 479a3c0 | 2019-06-04 15:38:50 +0200 | [diff] [blame] | 2069 | parameters_.config.rtp.raw_payload = |
| 2070 | codec_settings.codec.packetization == kPacketizationParamRaw; |
brandtr | b5f2c3f | 2016-10-04 23:28:39 -0700 | [diff] [blame] | 2071 | parameters_.config.rtp.ulpfec = codec_settings.ulpfec; |
brandtr | 31bd224 | 2017-05-19 05:47:46 -0700 | [diff] [blame] | 2072 | parameters_.config.rtp.flexfec.payload_type = |
| 2073 | codec_settings.flexfec_payload_type; |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 2074 | |
| 2075 | // Set RTX payload type if RTX is enabled. |
| 2076 | if (!parameters_.config.rtp.rtx.ssrcs.empty()) { |
pbos@webrtc.org | b9557a9 | 2015-03-20 19:52:56 +0000 | [diff] [blame] | 2077 | if (codec_settings.rtx_payload_type == -1) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 2078 | RTC_LOG(LS_WARNING) |
| 2079 | << "RTX SSRCs configured but there's no configured RTX " |
| 2080 | "payload type. Ignoring."; |
pbos@webrtc.org | b9557a9 | 2015-03-20 19:52:56 +0000 | [diff] [blame] | 2081 | parameters_.config.rtp.rtx.ssrcs.clear(); |
| 2082 | } else { |
| 2083 | parameters_.config.rtp.rtx.payload_type = codec_settings.rtx_payload_type; |
| 2084 | } |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 2085 | } |
| 2086 | |
Elad Alon | 370f93a | 2019-06-11 14:57:57 +0200 | [diff] [blame] | 2087 | const bool has_lntf = HasLntf(codec_settings.codec); |
| 2088 | parameters_.config.rtp.lntf.enabled = has_lntf; |
| 2089 | parameters_.config.encoder_settings.capabilities.loss_notification = has_lntf; |
Elad Alon | fadb181 | 2019-05-24 13:40:02 +0200 | [diff] [blame] | 2090 | |
Peter Boström | 67c9df7 | 2015-05-11 14:34:58 +0200 | [diff] [blame] | 2091 | parameters_.config.rtp.nack.rtp_history_ms = |
| 2092 | HasNack(codec_settings.codec) ? kNackHistoryMs : 0; |
pbos@webrtc.org | 5301b0f | 2014-07-17 08:51:46 +0000 | [diff] [blame] | 2093 | |
Oskar Sundbom | 7880758 | 2017-11-16 11:09:55 +0100 | [diff] [blame] | 2094 | parameters_.codec_settings = codec_settings; |
Niels Möller | 60653ba | 2016-03-02 11:41:36 +0100 | [diff] [blame] | 2095 | |
Niels Möller | 4db138e | 2018-04-19 09:04:13 +0200 | [diff] [blame] | 2096 | // TODO(nisse): Avoid recreation, it should be enough to call |
| 2097 | // ReconfigureEncoder. |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 2098 | RTC_LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetCodec."; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2099 | RecreateWebRtcStream(); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2100 | } |
| 2101 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2102 | void WebRtcVideoChannel::WebRtcVideoSendStream::SetSendParameters( |
Peter Boström | 3afc8c4 | 2016-01-27 16:45:21 +0100 | [diff] [blame] | 2103 | const ChangedSendParameters& params) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2104 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 2105 | // |recreate_stream| means construction-time parameters have changed and the |
| 2106 | // sending stream needs to be reset with the new config. |
| 2107 | bool recreate_stream = false; |
| 2108 | if (params.rtcp_mode) { |
| 2109 | parameters_.config.rtp.rtcp_mode = *params.rtcp_mode; |
Florent Castelli | dacec71 | 2018-05-24 16:24:21 +0200 | [diff] [blame] | 2110 | rtp_parameters_.rtcp.reduced_size = |
| 2111 | parameters_.config.rtp.rtcp_mode == webrtc::RtcpMode::kReducedSize; |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2112 | recreate_stream = true; |
| 2113 | } |
Johannes Kron | 9190b82 | 2018-10-29 11:22:05 +0100 | [diff] [blame] | 2114 | if (params.extmap_allow_mixed) { |
| 2115 | parameters_.config.rtp.extmap_allow_mixed = *params.extmap_allow_mixed; |
| 2116 | recreate_stream = true; |
| 2117 | } |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2118 | if (params.rtp_header_extensions) { |
| 2119 | parameters_.config.rtp.extensions = *params.rtp_header_extensions; |
Florent Castelli | abe301f | 2018-06-12 18:33:49 +0200 | [diff] [blame] | 2120 | rtp_parameters_.header_extensions = *params.rtp_header_extensions; |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2121 | recreate_stream = true; |
| 2122 | } |
Steve Anton | bb50ce5 | 2018-03-26 10:24:32 -0700 | [diff] [blame] | 2123 | if (params.mid) { |
| 2124 | parameters_.config.rtp.mid = *params.mid; |
| 2125 | recreate_stream = true; |
| 2126 | } |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2127 | if (params.max_bandwidth_bps) { |
| 2128 | parameters_.max_bitrate_bps = *params.max_bandwidth_bps; |
| 2129 | ReconfigureEncoder(); |
| 2130 | } |
| 2131 | if (params.conference_mode) { |
| 2132 | parameters_.conference_mode = *params.conference_mode; |
| 2133 | } |
perkj | f0dcfe2 | 2016-03-10 18:32:00 +0100 | [diff] [blame] | 2134 | |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2135 | // Set codecs and options. |
philipel | e8ed830 | 2019-07-03 11:53:48 +0200 | [diff] [blame] | 2136 | if (params.send_codec) { |
| 2137 | SetCodec(*params.send_codec); |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2138 | recreate_stream = false; // SetCodec has already recreated the stream. |
| 2139 | } else if (params.conference_mode && parameters_.codec_settings) { |
Niels Möller | 5bf8ccd | 2018-03-15 14:16:11 +0100 | [diff] [blame] | 2140 | SetCodec(*parameters_.codec_settings); |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2141 | recreate_stream = false; // SetCodec has already recreated the stream. |
| 2142 | } |
| 2143 | if (recreate_stream) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 2144 | RTC_LOG(LS_INFO) |
| 2145 | << "RecreateWebRtcStream (send) because of SetSendParameters"; |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2146 | RecreateWebRtcStream(); |
| 2147 | } |
deadbeef | 1387149 | 2015-12-09 12:37:51 -0800 | [diff] [blame] | 2148 | } |
| 2149 | |
Zach Stein | ba37b4b | 2018-01-23 15:02:36 -0800 | [diff] [blame] | 2150 | webrtc::RTCError WebRtcVideoChannel::WebRtcVideoSendStream::SetRtpParameters( |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 2151 | const webrtc::RtpParameters& new_parameters) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2152 | RTC_DCHECK_RUN_ON(&thread_checker_); |
Florent Castelli | c1a0bcb | 2019-01-29 14:26:48 +0100 | [diff] [blame] | 2153 | webrtc::RTCError error = CheckRtpParametersInvalidModificationAndValues( |
| 2154 | rtp_parameters_, new_parameters); |
Zach Stein | ba37b4b | 2018-01-23 15:02:36 -0800 | [diff] [blame] | 2155 | if (!error.ok()) { |
| 2156 | return error; |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 2157 | } |
| 2158 | |
Åsa Persson | 8c1bf95 | 2018-09-13 10:42:19 +0200 | [diff] [blame] | 2159 | bool new_param = false; |
Åsa Persson | 5565981 | 2018-06-18 17:51:32 +0200 | [diff] [blame] | 2160 | for (size_t i = 0; i < rtp_parameters_.encodings.size(); ++i) { |
| 2161 | if ((new_parameters.encodings[i].min_bitrate_bps != |
| 2162 | rtp_parameters_.encodings[i].min_bitrate_bps) || |
| 2163 | (new_parameters.encodings[i].max_bitrate_bps != |
Åsa Persson | 8c1bf95 | 2018-09-13 10:42:19 +0200 | [diff] [blame] | 2164 | rtp_parameters_.encodings[i].max_bitrate_bps) || |
| 2165 | (new_parameters.encodings[i].max_framerate != |
Åsa Persson | 23eba22 | 2018-10-02 14:47:06 +0200 | [diff] [blame] | 2166 | rtp_parameters_.encodings[i].max_framerate) || |
Florent Castelli | c1a0bcb | 2019-01-29 14:26:48 +0100 | [diff] [blame] | 2167 | (new_parameters.encodings[i].scale_resolution_down_by != |
| 2168 | rtp_parameters_.encodings[i].scale_resolution_down_by) || |
Åsa Persson | 23eba22 | 2018-10-02 14:47:06 +0200 | [diff] [blame] | 2169 | (new_parameters.encodings[i].num_temporal_layers != |
| 2170 | rtp_parameters_.encodings[i].num_temporal_layers)) { |
Åsa Persson | 8c1bf95 | 2018-09-13 10:42:19 +0200 | [diff] [blame] | 2171 | new_param = true; |
| 2172 | break; |
Åsa Persson | 5565981 | 2018-06-18 17:51:32 +0200 | [diff] [blame] | 2173 | } |
| 2174 | } |
| 2175 | |
Florent Castelli | 87b3c51 | 2018-07-18 16:00:28 +0200 | [diff] [blame] | 2176 | bool new_degradation_preference = false; |
| 2177 | if (new_parameters.degradation_preference != |
| 2178 | rtp_parameters_.degradation_preference) { |
| 2179 | new_degradation_preference = true; |
| 2180 | } |
| 2181 | |
Seth Hampson | cc7125f | 2018-02-02 08:46:16 -0800 | [diff] [blame] | 2182 | // TODO(bugs.webrtc.org/8807): The bitrate priority really doesn't require an |
| 2183 | // entire encoder reconfiguration, it just needs to update the bitrate |
| 2184 | // allocator. |
Åsa Persson | 5565981 | 2018-06-18 17:51:32 +0200 | [diff] [blame] | 2185 | bool reconfigure_encoder = |
Åsa Persson | 8c1bf95 | 2018-09-13 10:42:19 +0200 | [diff] [blame] | 2186 | new_param || (new_parameters.encodings[0].bitrate_priority != |
| 2187 | rtp_parameters_.encodings[0].bitrate_priority); |
Åsa Persson | 5565981 | 2018-06-18 17:51:32 +0200 | [diff] [blame] | 2188 | |
Seth Hampson | 8234ead | 2018-02-02 15:16:24 -0800 | [diff] [blame] | 2189 | // TODO(bugs.webrtc.org/8807): The active field as well should not require |
| 2190 | // a full encoder reconfiguration, but it needs to update both the bitrate |
| 2191 | // allocator and the video bitrate allocator. |
| 2192 | bool new_send_state = false; |
| 2193 | for (size_t i = 0; i < rtp_parameters_.encodings.size(); ++i) { |
Florent Castelli | 907dc80 | 2019-12-06 15:03:19 +0100 | [diff] [blame] | 2194 | bool new_active = IsLayerActive(new_parameters.encodings[i]); |
| 2195 | bool old_active = IsLayerActive(rtp_parameters_.encodings[i]); |
| 2196 | if (new_active != old_active) { |
Seth Hampson | 8234ead | 2018-02-02 15:16:24 -0800 | [diff] [blame] | 2197 | new_send_state = true; |
| 2198 | } |
| 2199 | } |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 2200 | rtp_parameters_ = new_parameters; |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2201 | // Codecs are currently handled at the WebRtcVideoChannel level. |
Taylor Brandstetter | 0cd086b | 2016-04-20 16:23:10 -0700 | [diff] [blame] | 2202 | rtp_parameters_.codecs.clear(); |
Seth Hampson | 8234ead | 2018-02-02 15:16:24 -0800 | [diff] [blame] | 2203 | if (reconfigure_encoder || new_send_state) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2204 | ReconfigureEncoder(); |
| 2205 | } |
Seth Hampson | 8234ead | 2018-02-02 15:16:24 -0800 | [diff] [blame] | 2206 | if (new_send_state) { |
| 2207 | UpdateSendState(); |
| 2208 | } |
Florent Castelli | 87b3c51 | 2018-07-18 16:00:28 +0200 | [diff] [blame] | 2209 | if (new_degradation_preference) { |
Mirta Dvornicic | 873610c | 2020-01-02 17:10:33 +0100 | [diff] [blame] | 2210 | if (source_ && stream_) { |
| 2211 | stream_->SetSource(this, GetDegradationPreference()); |
| 2212 | } |
Florent Castelli | 87b3c51 | 2018-07-18 16:00:28 +0200 | [diff] [blame] | 2213 | } |
Zach Stein | ba37b4b | 2018-01-23 15:02:36 -0800 | [diff] [blame] | 2214 | return webrtc::RTCError::OK(); |
skvlad | dc1c62c | 2016-03-16 19:07:43 -0700 | [diff] [blame] | 2215 | } |
| 2216 | |
deadbeef | dbe2b87 | 2016-03-22 15:42:00 -0700 | [diff] [blame] | 2217 | webrtc::RtpParameters |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2218 | WebRtcVideoChannel::WebRtcVideoSendStream::GetRtpParameters() const { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2219 | RTC_DCHECK_RUN_ON(&thread_checker_); |
deadbeef | dbe2b87 | 2016-03-22 15:42:00 -0700 | [diff] [blame] | 2220 | return rtp_parameters_; |
| 2221 | } |
| 2222 | |
Benjamin Wright | 192eeec | 2018-10-17 17:27:25 -0700 | [diff] [blame] | 2223 | void WebRtcVideoChannel::WebRtcVideoSendStream::SetFrameEncryptor( |
| 2224 | rtc::scoped_refptr<webrtc::FrameEncryptorInterface> frame_encryptor) { |
| 2225 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 2226 | parameters_.config.frame_encryptor = frame_encryptor; |
| 2227 | if (stream_) { |
Jonas Oreland | 6d83592 | 2019-03-18 10:59:40 +0100 | [diff] [blame] | 2228 | RTC_LOG(LS_INFO) |
| 2229 | << "RecreateWebRtcStream (send) because of SetFrameEncryptor, ssrc=" |
| 2230 | << parameters_.config.rtp.ssrcs[0]; |
Benjamin Wright | 192eeec | 2018-10-17 17:27:25 -0700 | [diff] [blame] | 2231 | RecreateWebRtcStream(); |
| 2232 | } |
| 2233 | } |
| 2234 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2235 | void WebRtcVideoChannel::WebRtcVideoSendStream::UpdateSendState() { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2236 | RTC_DCHECK_RUN_ON(&thread_checker_); |
Seth Hampson | 8234ead | 2018-02-02 15:16:24 -0800 | [diff] [blame] | 2237 | if (sending_) { |
deadbeef | dbe2b87 | 2016-03-22 15:42:00 -0700 | [diff] [blame] | 2238 | RTC_DCHECK(stream_ != nullptr); |
Ilya Nikolaevskiy | 33d2a91 | 2019-04-02 11:05:03 +0200 | [diff] [blame] | 2239 | size_t num_layers = rtp_parameters_.encodings.size(); |
| 2240 | if (parameters_.encoder_config.number_of_streams == 1) { |
| 2241 | // SVC is used. Only one simulcast layer is present. |
| 2242 | num_layers = 1; |
| 2243 | } |
| 2244 | std::vector<bool> active_layers(num_layers); |
| 2245 | for (size_t i = 0; i < num_layers; ++i) { |
Florent Castelli | 907dc80 | 2019-12-06 15:03:19 +0100 | [diff] [blame] | 2246 | active_layers[i] = IsLayerActive(rtp_parameters_.encodings[i]); |
Seth Hampson | 8234ead | 2018-02-02 15:16:24 -0800 | [diff] [blame] | 2247 | } |
Ilya Nikolaevskiy | 72859e5 | 2020-02-05 17:31:00 +0100 | [diff] [blame] | 2248 | if (parameters_.encoder_config.number_of_streams == 1 && |
| 2249 | rtp_parameters_.encodings.size() > 1) { |
| 2250 | // SVC is used. |
| 2251 | // The only present simulcast layer should be active if any of the |
| 2252 | // configured SVC layers is active. |
Oskar Segersvärd | 06901cf | 2020-02-17 17:49:04 +0100 | [diff] [blame] | 2253 | active_layers[0] = |
| 2254 | absl::c_any_of(rtp_parameters_.encodings, |
| 2255 | [](const auto& encoding) { return encoding.active; }); |
Ilya Nikolaevskiy | 72859e5 | 2020-02-05 17:31:00 +0100 | [diff] [blame] | 2256 | } |
Seth Hampson | 8234ead | 2018-02-02 15:16:24 -0800 | [diff] [blame] | 2257 | // This updates what simulcast layers are sending, and possibly starts |
| 2258 | // or stops the VideoSendStream. |
| 2259 | stream_->UpdateActiveSimulcastLayers(active_layers); |
deadbeef | dbe2b87 | 2016-03-22 15:42:00 -0700 | [diff] [blame] | 2260 | } else { |
| 2261 | if (stream_ != nullptr) { |
| 2262 | stream_->Stop(); |
| 2263 | } |
| 2264 | } |
| 2265 | } |
| 2266 | |
pbos@webrtc.org | a2ef4fe | 2014-11-07 10:54:43 +0000 | [diff] [blame] | 2267 | webrtc::VideoEncoderConfig |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2268 | WebRtcVideoChannel::WebRtcVideoSendStream::CreateVideoEncoderConfig( |
pbos@webrtc.org | a2ef4fe | 2014-11-07 10:54:43 +0000 | [diff] [blame] | 2269 | const VideoCodec& codec) const { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2270 | RTC_DCHECK_RUN_ON(&thread_checker_); |
pbos@webrtc.org | a2ef4fe | 2014-11-07 10:54:43 +0000 | [diff] [blame] | 2271 | webrtc::VideoEncoderConfig encoder_config; |
Niels Möller | 259a497 | 2018-04-05 15:36:51 +0200 | [diff] [blame] | 2272 | encoder_config.codec_type = webrtc::PayloadStringToCodecType(codec.name); |
Niels Möller | 4db138e | 2018-04-19 09:04:13 +0200 | [diff] [blame] | 2273 | encoder_config.video_format = |
| 2274 | webrtc::SdpVideoFormat(codec.name, codec.params); |
Niels Möller | 259a497 | 2018-04-05 15:36:51 +0200 | [diff] [blame] | 2275 | |
Niels Möller | 60653ba | 2016-03-02 11:41:36 +0100 | [diff] [blame] | 2276 | bool is_screencast = parameters_.options.is_screencast.value_or(false); |
| 2277 | if (is_screencast) { |
pbos@webrtc.org | efc82c2 | 2014-10-27 13:58:00 +0000 | [diff] [blame] | 2278 | encoder_config.min_transmit_bitrate_bps = |
nisse | 51542be | 2016-02-12 02:27:06 -0800 | [diff] [blame] | 2279 | 1000 * parameters_.options.screencast_min_bitrate_kbps.value_or(0); |
Erik Språng | 143cec1 | 2015-04-28 10:01:41 +0200 | [diff] [blame] | 2280 | encoder_config.content_type = |
| 2281 | webrtc::VideoEncoderConfig::ContentType::kScreen; |
pbos@webrtc.org | efc82c2 | 2014-10-27 13:58:00 +0000 | [diff] [blame] | 2282 | } else { |
| 2283 | encoder_config.min_transmit_bitrate_bps = 0; |
Erik Språng | 143cec1 | 2015-04-28 10:01:41 +0200 | [diff] [blame] | 2284 | encoder_config.content_type = |
| 2285 | webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo; |
pbos@webrtc.org | efc82c2 | 2014-10-27 13:58:00 +0000 | [diff] [blame] | 2286 | } |
| 2287 | |
noahric | fdac516 | 2015-08-27 01:59:29 -0700 | [diff] [blame] | 2288 | // By default, the stream count for the codec configuration should match the |
| 2289 | // number of negotiated ssrcs. But if the codec is blacklisted for simulcast |
sprang | 429600d | 2017-01-26 06:12:26 -0800 | [diff] [blame] | 2290 | // or a screencast (and not in simulcast screenshare experiment), only |
| 2291 | // configure a single stream. |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2292 | encoder_config.number_of_streams = parameters_.config.rtp.ssrcs.size(); |
Florent Castelli | 66b3860 | 2019-07-10 16:57:57 +0200 | [diff] [blame] | 2293 | if (IsCodecBlacklistedForSimulcast(codec.name)) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2294 | encoder_config.number_of_streams = 1; |
noahric | fdac516 | 2015-08-27 01:59:29 -0700 | [diff] [blame] | 2295 | } |
| 2296 | |
Seth Hampson | feec91e | 2018-07-13 10:41:10 -0700 | [diff] [blame] | 2297 | // parameters_.max_bitrate comes from the max bitrate set at the SDP |
| 2298 | // (m-section) level with the attribute "b=AS." Note that we override this |
| 2299 | // value below if the RtpParameters max bitrate set with |
| 2300 | // RtpSender::SetParameters has a lower value. |
deadbeef | e702b30 | 2017-02-04 12:09:01 -0800 | [diff] [blame] | 2301 | int stream_max_bitrate = parameters_.max_bitrate_bps; |
Åsa Persson | 5565981 | 2018-06-18 17:51:32 +0200 | [diff] [blame] | 2302 | // When simulcast is enabled (when there are multiple encodings), |
| 2303 | // encodings[i].max_bitrate_bps will be enforced by |
| 2304 | // encoder_config.simulcast_layers[i].max_bitrate_bps. Otherwise, it's |
| 2305 | // enforced by stream_max_bitrate, taking the minimum of the two maximums |
| 2306 | // (one coming from SDP, the other coming from RtpParameters). |
| 2307 | if (rtp_parameters_.encodings[0].max_bitrate_bps && |
| 2308 | rtp_parameters_.encodings.size() == 1) { |
deadbeef | e702b30 | 2017-02-04 12:09:01 -0800 | [diff] [blame] | 2309 | stream_max_bitrate = |
Mirko Bonadei | 53227cc | 2019-09-18 14:15:52 +0200 | [diff] [blame] | 2310 | MinPositive(*(rtp_parameters_.encodings[0].max_bitrate_bps), |
| 2311 | parameters_.max_bitrate_bps); |
deadbeef | e702b30 | 2017-02-04 12:09:01 -0800 | [diff] [blame] | 2312 | } |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 2313 | |
Seth Hampson | feec91e | 2018-07-13 10:41:10 -0700 | [diff] [blame] | 2314 | // The codec max bitrate comes from the "x-google-max-bitrate" parameter |
| 2315 | // attribute set in the SDP for a specific codec. As done in |
| 2316 | // WebRtcVideoChannel::SetSendParameters, this value does not override the |
| 2317 | // stream max_bitrate set above. |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2318 | int codec_max_bitrate_kbps; |
Seth Hampson | feec91e | 2018-07-13 10:41:10 -0700 | [diff] [blame] | 2319 | if (codec.GetParam(kCodecParamMaxBitrate, &codec_max_bitrate_kbps) && |
| 2320 | stream_max_bitrate == -1) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2321 | stream_max_bitrate = codec_max_bitrate_kbps * 1000; |
| 2322 | } |
| 2323 | encoder_config.max_bitrate_bps = stream_max_bitrate; |
perkj | 3b703ed | 2016-09-29 23:25:40 -0700 | [diff] [blame] | 2324 | |
Seth Hampson | 24722b3 | 2017-12-22 09:36:42 -0800 | [diff] [blame] | 2325 | // The encoder config's default bitrate priority is set to 1.0, |
| 2326 | // unless it is set through the sender's encoding parameters. |
| 2327 | // The bitrate priority, which is used in the bitrate allocation, is done |
| 2328 | // on a per sender basis, so we use the first encoding's value. |
| 2329 | encoder_config.bitrate_priority = |
| 2330 | rtp_parameters_.encodings[0].bitrate_priority; |
| 2331 | |
Seth Hampson | 8234ead | 2018-02-02 15:16:24 -0800 | [diff] [blame] | 2332 | // Application-controlled state is held in the encoder_config's |
| 2333 | // simulcast_layers. Currently this is used to control which simulcast layers |
Åsa Persson | 8c1bf95 | 2018-09-13 10:42:19 +0200 | [diff] [blame] | 2334 | // are active and for configuring the min/max bitrate and max framerate. |
Åsa Persson | bdee46d | 2018-06-25 11:28:06 +0200 | [diff] [blame] | 2335 | // The encoder_config's simulcast_layers is also used for non-simulcast (when |
| 2336 | // there is a single layer). |
Seth Hampson | 8234ead | 2018-02-02 15:16:24 -0800 | [diff] [blame] | 2337 | RTC_DCHECK_GE(rtp_parameters_.encodings.size(), |
| 2338 | encoder_config.number_of_streams); |
| 2339 | RTC_DCHECK_GT(encoder_config.number_of_streams, 0); |
Sergey Silkin | 8b9b5f9 | 2018-12-10 09:28:53 +0100 | [diff] [blame] | 2340 | |
| 2341 | // Copy all provided constraints. |
| 2342 | encoder_config.simulcast_layers.resize(rtp_parameters_.encodings.size()); |
Seth Hampson | 8234ead | 2018-02-02 15:16:24 -0800 | [diff] [blame] | 2343 | for (size_t i = 0; i < encoder_config.simulcast_layers.size(); ++i) { |
| 2344 | encoder_config.simulcast_layers[i].active = |
| 2345 | rtp_parameters_.encodings[i].active; |
Åsa Persson | 5565981 | 2018-06-18 17:51:32 +0200 | [diff] [blame] | 2346 | if (rtp_parameters_.encodings[i].min_bitrate_bps) { |
| 2347 | encoder_config.simulcast_layers[i].min_bitrate_bps = |
| 2348 | *rtp_parameters_.encodings[i].min_bitrate_bps; |
| 2349 | } |
| 2350 | if (rtp_parameters_.encodings[i].max_bitrate_bps) { |
| 2351 | encoder_config.simulcast_layers[i].max_bitrate_bps = |
| 2352 | *rtp_parameters_.encodings[i].max_bitrate_bps; |
| 2353 | } |
Åsa Persson | 8c1bf95 | 2018-09-13 10:42:19 +0200 | [diff] [blame] | 2354 | if (rtp_parameters_.encodings[i].max_framerate) { |
| 2355 | encoder_config.simulcast_layers[i].max_framerate = |
| 2356 | *rtp_parameters_.encodings[i].max_framerate; |
| 2357 | } |
Florent Castelli | c1a0bcb | 2019-01-29 14:26:48 +0100 | [diff] [blame] | 2358 | if (rtp_parameters_.encodings[i].scale_resolution_down_by) { |
| 2359 | encoder_config.simulcast_layers[i].scale_resolution_down_by = |
| 2360 | *rtp_parameters_.encodings[i].scale_resolution_down_by; |
| 2361 | } |
Åsa Persson | 23eba22 | 2018-10-02 14:47:06 +0200 | [diff] [blame] | 2362 | if (rtp_parameters_.encodings[i].num_temporal_layers) { |
| 2363 | encoder_config.simulcast_layers[i].num_temporal_layers = |
| 2364 | *rtp_parameters_.encodings[i].num_temporal_layers; |
| 2365 | } |
Seth Hampson | 8234ead | 2018-02-02 15:16:24 -0800 | [diff] [blame] | 2366 | } |
| 2367 | |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2368 | int max_qp = kDefaultQpMax; |
| 2369 | codec.GetParam(kCodecParamMaxQuantization, &max_qp); |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2370 | encoder_config.video_stream_factory = |
| 2371 | new rtc::RefCountedObject<EncoderStreamFactory>( |
Åsa Persson | 8c1bf95 | 2018-09-13 10:42:19 +0200 | [diff] [blame] | 2372 | codec.name, max_qp, is_screencast, parameters_.conference_mode); |
pbos@webrtc.org | a2ef4fe | 2014-11-07 10:54:43 +0000 | [diff] [blame] | 2373 | return encoder_config; |
| 2374 | } |
| 2375 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2376 | void WebRtcVideoChannel::WebRtcVideoSendStream::ReconfigureEncoder() { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2377 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 2378 | if (!stream_) { |
sprang | fe627f3 | 2017-03-29 08:24:59 -0700 | [diff] [blame] | 2379 | // The webrtc::VideoSendStream |stream_| has not yet been created but other |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2380 | // parameters has changed. |
| 2381 | return; |
| 2382 | } |
| 2383 | |
kwiberg | af476c7 | 2016-11-28 15:21:39 -0800 | [diff] [blame] | 2384 | RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0); |
pbos@webrtc.org | a2ef4fe | 2014-11-07 10:54:43 +0000 | [diff] [blame] | 2385 | |
kwiberg | 102c6a6 | 2015-10-30 02:47:38 -0700 | [diff] [blame] | 2386 | RTC_CHECK(parameters_.codec_settings); |
| 2387 | VideoCodecSettings codec_settings = *parameters_.codec_settings; |
pbos@webrtc.org | a2ef4fe | 2014-11-07 10:54:43 +0000 | [diff] [blame] | 2388 | |
| 2389 | webrtc::VideoEncoderConfig encoder_config = |
skvlad | 3abb764 | 2016-06-16 12:08:03 -0700 | [diff] [blame] | 2390 | CreateVideoEncoderConfig(codec_settings.codec); |
pbos@webrtc.org | a2ef4fe | 2014-11-07 10:54:43 +0000 | [diff] [blame] | 2391 | |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 2392 | encoder_config.encoder_specific_settings = |
| 2393 | ConfigureVideoEncoderSettings(codec_settings.codec); |
pbos@webrtc.org | b7ed779 | 2014-10-31 13:08:10 +0000 | [diff] [blame] | 2394 | |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 2395 | stream_->ReconfigureVideoEncoder(encoder_config.Copy()); |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 2396 | |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 2397 | encoder_config.encoder_specific_settings = NULL; |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 2398 | |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 2399 | parameters_.encoder_config = std::move(encoder_config); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2400 | } |
| 2401 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2402 | void WebRtcVideoChannel::WebRtcVideoSendStream::SetSend(bool send) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2403 | RTC_DCHECK_RUN_ON(&thread_checker_); |
deadbeef | dbe2b87 | 2016-03-22 15:42:00 -0700 | [diff] [blame] | 2404 | sending_ = send; |
| 2405 | UpdateSendState(); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2406 | } |
| 2407 | |
Christian Fremerey | 6c02541 | 2019-02-13 19:43:28 +0000 | [diff] [blame] | 2408 | void WebRtcVideoChannel::WebRtcVideoSendStream::RemoveSink( |
| 2409 | rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) { |
| 2410 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 2411 | RTC_DCHECK(encoder_sink_ == sink); |
| 2412 | encoder_sink_ = nullptr; |
| 2413 | source_->RemoveSink(sink); |
| 2414 | } |
| 2415 | |
| 2416 | void WebRtcVideoChannel::WebRtcVideoSendStream::AddOrUpdateSink( |
| 2417 | rtc::VideoSinkInterface<webrtc::VideoFrame>* sink, |
| 2418 | const rtc::VideoSinkWants& wants) { |
| 2419 | if (worker_thread_ == rtc::Thread::Current()) { |
| 2420 | // AddOrUpdateSink is called on |worker_thread_| if this is the first |
| 2421 | // registration of |sink|. |
| 2422 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 2423 | encoder_sink_ = sink; |
| 2424 | source_->AddOrUpdateSink(encoder_sink_, wants); |
| 2425 | } else { |
| 2426 | // Subsequent calls to AddOrUpdateSink will happen on the encoder task |
| 2427 | // queue. |
| 2428 | invoker_.AsyncInvoke<void>( |
| 2429 | RTC_FROM_HERE, worker_thread_, [this, sink, wants] { |
| 2430 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 2431 | // |sink| may be invalidated after this task was posted since |
| 2432 | // RemoveSink is called on the worker thread. |
| 2433 | bool encoder_sink_valid = (sink == encoder_sink_); |
| 2434 | if (source_ && encoder_sink_valid) { |
| 2435 | source_->AddOrUpdateSink(encoder_sink_, wants); |
| 2436 | } |
| 2437 | }); |
| 2438 | } |
| 2439 | } |
| 2440 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2441 | VideoSenderInfo WebRtcVideoChannel::WebRtcVideoSendStream::GetVideoSenderInfo( |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 2442 | bool log_stats) { |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2443 | VideoSenderInfo info; |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2444 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 2445 | for (uint32_t ssrc : parameters_.config.rtp.ssrcs) |
| 2446 | info.add_ssrc(ssrc); |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2447 | |
hbos | a65704b | 2016-11-14 02:28:16 -0800 | [diff] [blame] | 2448 | if (parameters_.codec_settings) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2449 | info.codec_name = parameters_.codec_settings->codec.name; |
Oskar Sundbom | 7880758 | 2017-11-16 11:09:55 +0100 | [diff] [blame] | 2450 | info.codec_payload_type = parameters_.codec_settings->codec.id; |
hbos | a65704b | 2016-11-14 02:28:16 -0800 | [diff] [blame] | 2451 | } |
pbos@webrtc.org | c3d2bd2 | 2014-08-12 20:55:10 +0000 | [diff] [blame] | 2452 | |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2453 | if (stream_ == NULL) |
| 2454 | return info; |
pbos@webrtc.org | 77e11bb | 2015-02-23 16:39:07 +0000 | [diff] [blame] | 2455 | |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2456 | webrtc::VideoSendStream::Stats stats = stream_->GetStats(); |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 2457 | |
| 2458 | if (log_stats) |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 2459 | RTC_LOG(LS_INFO) << stats.ToString(rtc::TimeMillis()); |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 2460 | |
perkj | 803d97f | 2016-11-01 11:45:46 -0700 | [diff] [blame] | 2461 | info.adapt_changes = stats.number_of_cpu_adapt_changes; |
Per | 766ad3b | 2016-04-05 15:23:49 +0200 | [diff] [blame] | 2462 | info.adapt_reason = |
perkj | 803d97f | 2016-11-01 11:45:46 -0700 | [diff] [blame] | 2463 | stats.cpu_limited_resolution ? ADAPTREASON_CPU : ADAPTREASON_NONE; |
Åsa Persson | c3ed630 | 2017-11-16 14:04:52 +0100 | [diff] [blame] | 2464 | info.has_entered_low_resolution = stats.has_entered_low_resolution; |
pbos@webrtc.org | 77e11bb | 2015-02-23 16:39:07 +0000 | [diff] [blame] | 2465 | |
asapersson | 17821db | 2015-12-14 02:08:12 -0800 | [diff] [blame] | 2466 | // Get bandwidth limitation info from stream_->GetStats(). |
| 2467 | // Input resolution (output from video_adapter) can be further scaled down or |
| 2468 | // higher video layer(s) can be dropped due to bitrate constraints. |
| 2469 | // Note, adapt_changes only include changes from the video_adapter. |
| 2470 | if (stats.bw_limited_resolution) |
Per | 766ad3b | 2016-04-05 15:23:49 +0200 | [diff] [blame] | 2471 | info.adapt_reason |= ADAPTREASON_BANDWIDTH; |
asapersson | 17821db | 2015-12-14 02:08:12 -0800 | [diff] [blame] | 2472 | |
Henrik Boström | ce33b6a | 2019-05-28 17:42:38 +0200 | [diff] [blame] | 2473 | info.quality_limitation_reason = stats.quality_limitation_reason; |
| 2474 | info.quality_limitation_durations_ms = stats.quality_limitation_durations_ms; |
Evan Shrubsole | cc62b16 | 2019-09-09 11:26:45 +0200 | [diff] [blame] | 2475 | info.quality_limitation_resolution_changes = |
| 2476 | stats.quality_limitation_resolution_changes; |
Peter Boström | b7d9a97 | 2015-12-18 16:01:11 +0100 | [diff] [blame] | 2477 | info.encoder_implementation_name = stats.encoder_implementation_name; |
Peter Boström | 259bd20 | 2015-05-28 13:39:50 +0200 | [diff] [blame] | 2478 | info.ssrc_groups = ssrc_groups_; |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2479 | info.framerate_input = stats.input_frame_rate; |
| 2480 | info.framerate_sent = stats.encode_frame_rate; |
pbos@webrtc.org | 3e6e271 | 2015-02-26 12:19:31 +0000 | [diff] [blame] | 2481 | info.avg_encode_ms = stats.avg_encode_time_ms; |
| 2482 | info.encode_usage_percent = stats.encode_usage_percent; |
sakal | 43536c3 | 2016-10-24 01:46:43 -0700 | [diff] [blame] | 2483 | info.frames_encoded = stats.frames_encoded; |
Rasmus Brandt | 2efae77 | 2019-06-27 14:29:34 +0200 | [diff] [blame] | 2484 | // TODO(bugs.webrtc.org/9547): Populate individual outbound-rtp stats objects |
| 2485 | // for each simulcast stream, instead of accumulating all keyframes encoded |
| 2486 | // over all simulcast streams in the same outbound-rtp stats object. |
| 2487 | info.key_frames_encoded = 0; |
| 2488 | for (const auto& kv : stats.substreams) { |
| 2489 | info.key_frames_encoded += kv.second.frame_counts.key_frames; |
| 2490 | } |
Henrik Boström | f71362f | 2019-04-08 16:14:23 +0200 | [diff] [blame] | 2491 | info.total_encode_time_ms = stats.total_encode_time_ms; |
Henrik Boström | 23aff9b | 2019-05-20 15:15:38 +0200 | [diff] [blame] | 2492 | info.total_encoded_bytes_target = stats.total_encoded_bytes_target; |
sakal | 87da404 | 2016-10-31 06:53:47 -0700 | [diff] [blame] | 2493 | info.qp_sum = stats.qp_sum; |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2494 | |
pbos@webrtc.org | 77e11bb | 2015-02-23 16:39:07 +0000 | [diff] [blame] | 2495 | info.nominal_bitrate = stats.media_bitrate_bps; |
| 2496 | |
ilnik | 50864a8 | 2017-09-06 12:32:35 -0700 | [diff] [blame] | 2497 | info.content_type = stats.content_type; |
Ilya Nikolaevskiy | 70473fc | 2018-02-28 16:35:03 +0100 | [diff] [blame] | 2498 | info.huge_frames_sent = stats.huge_frames_sent; |
ilnik | 50864a8 | 2017-09-06 12:32:35 -0700 | [diff] [blame] | 2499 | |
pbos@webrtc.org | 273a414 | 2014-12-01 15:23:21 +0000 | [diff] [blame] | 2500 | info.send_frame_width = 0; |
| 2501 | info.send_frame_height = 0; |
Henrik Boström | 9fe1834 | 2019-05-16 18:38:20 +0200 | [diff] [blame] | 2502 | info.total_packet_send_delay_ms = 0; |
Henrik Boström | f45ca37 | 2020-03-24 13:30:50 +0100 | [diff] [blame] | 2503 | std::map<uint32_t, webrtc::VideoSendStream::StreamStats> |
| 2504 | outbound_rtp_substreams = |
| 2505 | MergeInfoAboutOutboundRtpSubstreams(stats.substreams); |
| 2506 | for (const auto& pair : outbound_rtp_substreams) { |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2507 | // TODO(pbos): Wire up additional stats, such as padding bytes. |
Henrik Boström | f45ca37 | 2020-03-24 13:30:50 +0100 | [diff] [blame] | 2508 | const webrtc::VideoSendStream::StreamStats& stream_stats = pair.second; |
| 2509 | RTC_DCHECK_EQ(stream_stats.type, |
| 2510 | webrtc::VideoSendStream::StreamStats::StreamType::kMedia); |
Niels Möller | ac0a4cb | 2019-10-09 15:01:33 +0200 | [diff] [blame] | 2511 | info.payload_bytes_sent += stream_stats.rtp_stats.transmitted.payload_bytes; |
| 2512 | info.header_and_padding_bytes_sent += |
| 2513 | stream_stats.rtp_stats.transmitted.header_bytes + |
| 2514 | stream_stats.rtp_stats.transmitted.padding_bytes; |
asapersson@webrtc.org | cfd82df | 2015-01-22 09:39:59 +0000 | [diff] [blame] | 2515 | info.packets_sent += stream_stats.rtp_stats.transmitted.packets; |
Henrik Boström | 9fe1834 | 2019-05-16 18:38:20 +0200 | [diff] [blame] | 2516 | info.total_packet_send_delay_ms += stream_stats.total_packet_send_delay_ms; |
Henrik Boström | f45ca37 | 2020-03-24 13:30:50 +0100 | [diff] [blame] | 2517 | info.retransmitted_bytes_sent += |
| 2518 | stream_stats.rtp_stats.retransmitted.payload_bytes; |
| 2519 | info.retransmitted_packets_sent += |
| 2520 | stream_stats.rtp_stats.retransmitted.packets; |
srte | 186d9c3 | 2017-08-04 05:03:53 -0700 | [diff] [blame] | 2521 | info.packets_lost += stream_stats.rtcp_stats.packets_lost; |
pbos@webrtc.org | 09c77b9 | 2015-02-25 10:42:16 +0000 | [diff] [blame] | 2522 | if (stream_stats.width > info.send_frame_width) |
| 2523 | info.send_frame_width = stream_stats.width; |
| 2524 | if (stream_stats.height > info.send_frame_height) |
| 2525 | info.send_frame_height = stream_stats.height; |
pbos@webrtc.org | 1d0fa5d | 2015-02-19 12:47:00 +0000 | [diff] [blame] | 2526 | info.firs_rcvd += stream_stats.rtcp_packet_type_counts.fir_packets; |
| 2527 | info.nacks_rcvd += stream_stats.rtcp_packet_type_counts.nack_packets; |
| 2528 | info.plis_rcvd += stream_stats.rtcp_packet_type_counts.pli_packets; |
Henrik Boström | f45ca37 | 2020-03-24 13:30:50 +0100 | [diff] [blame] | 2529 | if (stream_stats.report_block_data.has_value()) { |
Henrik Boström | 87e3f9d | 2019-05-27 10:44:24 +0200 | [diff] [blame] | 2530 | info.report_block_datas.push_back(stream_stats.report_block_data.value()); |
| 2531 | } |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2532 | } |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2533 | if (!stats.substreams.empty()) { |
| 2534 | // TODO(pbos): Report fraction lost per SSRC. |
pbos@webrtc.org | 09c77b9 | 2015-02-25 10:42:16 +0000 | [diff] [blame] | 2535 | webrtc::VideoSendStream::StreamStats first_stream_stats = |
| 2536 | stats.substreams.begin()->second; |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2537 | info.fraction_lost = |
| 2538 | static_cast<float>(first_stream_stats.rtcp_stats.fraction_lost) / |
| 2539 | (1 << 8); |
| 2540 | } |
| 2541 | |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2542 | return info; |
| 2543 | } |
| 2544 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2545 | void WebRtcVideoChannel::WebRtcVideoSendStream::FillBitrateInfo( |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 2546 | BandwidthEstimationInfo* bwe_info) { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2547 | RTC_DCHECK_RUN_ON(&thread_checker_); |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 2548 | if (stream_ == NULL) { |
| 2549 | return; |
| 2550 | } |
| 2551 | webrtc::VideoSendStream::Stats stats = stream_->GetStats(); |
pbos@webrtc.org | 09c77b9 | 2015-02-25 10:42:16 +0000 | [diff] [blame] | 2552 | for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it = |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 2553 | stats.substreams.begin(); |
pbos@webrtc.org | 09c77b9 | 2015-02-25 10:42:16 +0000 | [diff] [blame] | 2554 | it != stats.substreams.end(); ++it) { |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 2555 | bwe_info->transmit_bitrate += it->second.total_bitrate_bps; |
| 2556 | bwe_info->retransmit_bitrate += it->second.retransmit_bitrate_bps; |
| 2557 | } |
pbos@webrtc.org | 891d483 | 2015-02-26 13:15:22 +0000 | [diff] [blame] | 2558 | bwe_info->target_enc_bitrate += stats.target_media_bitrate_bps; |
pbos@webrtc.org | 77e11bb | 2015-02-23 16:39:07 +0000 | [diff] [blame] | 2559 | bwe_info->actual_enc_bitrate += stats.media_bitrate_bps; |
stefan@webrtc.org | 0bae1fa | 2014-11-05 14:05:29 +0000 | [diff] [blame] | 2560 | } |
| 2561 | |
Marina Ciocea | e77912b | 2020-02-27 16:16:55 +0100 | [diff] [blame] | 2562 | void WebRtcVideoChannel::WebRtcVideoSendStream:: |
| 2563 | SetEncoderToPacketizerFrameTransformer( |
| 2564 | rtc::scoped_refptr<webrtc::FrameTransformerInterface> |
| 2565 | frame_transformer) { |
| 2566 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 2567 | parameters_.config.frame_transformer = std::move(frame_transformer); |
Guido Urdaneta | e1aa22f | 2020-03-30 23:02:14 +0200 | [diff] [blame] | 2568 | if (stream_) |
| 2569 | RecreateWebRtcStream(); |
Marina Ciocea | e77912b | 2020-02-27 16:16:55 +0100 | [diff] [blame] | 2570 | } |
| 2571 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2572 | void WebRtcVideoChannel::WebRtcVideoSendStream::RecreateWebRtcStream() { |
perkj | fa10b55 | 2016-10-02 23:45:26 -0700 | [diff] [blame] | 2573 | RTC_DCHECK_RUN_ON(&thread_checker_); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2574 | if (stream_ != NULL) { |
| 2575 | call_->DestroyVideoSendStream(stream_); |
| 2576 | } |
pbos@webrtc.org | 6ae48c6 | 2014-06-06 10:49:19 +0000 | [diff] [blame] | 2577 | |
kwiberg | 102c6a6 | 2015-10-30 02:47:38 -0700 | [diff] [blame] | 2578 | RTC_CHECK(parameters_.codec_settings); |
Niels Möller | 60653ba | 2016-03-02 11:41:36 +0100 | [diff] [blame] | 2579 | RTC_DCHECK_EQ((parameters_.encoder_config.content_type == |
| 2580 | webrtc::VideoEncoderConfig::ContentType::kScreen), |
| 2581 | parameters_.options.is_screencast.value_or(false)) |
| 2582 | << "encoder content type inconsistent with screencast option"; |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 2583 | parameters_.encoder_config.encoder_specific_settings = |
Niels Möller | 60653ba | 2016-03-02 11:41:36 +0100 | [diff] [blame] | 2584 | ConfigureVideoEncoderSettings(parameters_.codec_settings->codec); |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 2585 | |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 2586 | webrtc::VideoSendStream::Config config = parameters_.config.Copy(); |
pbos@webrtc.org | b9557a9 | 2015-03-20 19:52:56 +0000 | [diff] [blame] | 2587 | if (!config.rtp.rtx.ssrcs.empty() && config.rtp.rtx.payload_type == -1) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 2588 | RTC_LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX " |
| 2589 | "payload type the set codec. Ignoring RTX."; |
pbos@webrtc.org | b9557a9 | 2015-03-20 19:52:56 +0000 | [diff] [blame] | 2590 | config.rtp.rtx.ssrcs.clear(); |
| 2591 | } |
Ilya Nikolaevskiy | 33d2a91 | 2019-04-02 11:05:03 +0200 | [diff] [blame] | 2592 | if (parameters_.encoder_config.number_of_streams == 1) { |
| 2593 | // SVC is used instead of simulcast. Remove unnecessary SSRCs. |
| 2594 | if (config.rtp.ssrcs.size() > 1) { |
| 2595 | config.rtp.ssrcs.resize(1); |
| 2596 | if (config.rtp.rtx.ssrcs.size() > 1) { |
| 2597 | config.rtp.rtx.ssrcs.resize(1); |
| 2598 | } |
| 2599 | } |
| 2600 | } |
perkj | 26091b1 | 2016-09-01 01:17:40 -0700 | [diff] [blame] | 2601 | stream_ = call_->CreateVideoSendStream(std::move(config), |
| 2602 | parameters_.encoder_config.Copy()); |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 2603 | |
pbos@webrtc.org | bbe0a85 | 2014-09-19 12:30:25 +0000 | [diff] [blame] | 2604 | parameters_.encoder_config.encoder_specific_settings = NULL; |
pbos@webrtc.org | 6f48f1b | 2014-07-22 16:29:54 +0000 | [diff] [blame] | 2605 | |
perkj | 803d97f | 2016-11-01 11:45:46 -0700 | [diff] [blame] | 2606 | if (source_) { |
Christian Fremerey | 6c02541 | 2019-02-13 19:43:28 +0000 | [diff] [blame] | 2607 | stream_->SetSource(this, GetDegradationPreference()); |
perkj | 803d97f | 2016-11-01 11:45:46 -0700 | [diff] [blame] | 2608 | } |
| 2609 | |
Taylor Brandstetter | 14b9d79 | 2016-09-07 17:16:54 -0700 | [diff] [blame] | 2610 | // Call stream_->Start() if necessary conditions are met. |
| 2611 | UpdateSendState(); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 2612 | } |
| 2613 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2614 | WebRtcVideoChannel::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream( |
Jonas Oreland | 6d83592 | 2019-03-18 10:59:40 +0100 | [diff] [blame] | 2615 | WebRtcVideoChannel* channel, |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2616 | webrtc::Call* call, |
Peter Boström | 259bd20 | 2015-05-28 13:39:50 +0200 | [diff] [blame] | 2617 | const StreamParams& sp, |
Tommi | 733b547 | 2016-06-10 17:58:01 +0200 | [diff] [blame] | 2618 | webrtc::VideoReceiveStream::Config config, |
Magnus Jedvert | 59ab353 | 2018-09-03 18:07:56 +0200 | [diff] [blame] | 2619 | webrtc::VideoDecoderFactory* decoder_factory, |
pbos@webrtc.org | a2a6fe6 | 2015-03-06 15:35:19 +0000 | [diff] [blame] | 2620 | bool default_stream, |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 2621 | const std::vector<VideoCodecSettings>& recv_codecs, |
brandtr | 8313a6f | 2017-01-13 07:41:19 -0800 | [diff] [blame] | 2622 | const webrtc::FlexfecReceiveStream::Config& flexfec_config) |
Jonas Oreland | 6d83592 | 2019-03-18 10:59:40 +0100 | [diff] [blame] | 2623 | : channel_(channel), |
| 2624 | call_(call), |
sakal | 1fd9595 | 2016-06-22 00:46:15 -0700 | [diff] [blame] | 2625 | stream_params_(sp), |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2626 | stream_(NULL), |
pbos@webrtc.org | a2a6fe6 | 2015-03-06 15:35:19 +0000 | [diff] [blame] | 2627 | default_stream_(default_stream), |
Tommi | 733b547 | 2016-06-10 17:58:01 +0200 | [diff] [blame] | 2628 | config_(std::move(config)), |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 2629 | flexfec_config_(flexfec_config), |
| 2630 | flexfec_stream_(nullptr), |
magjed | 2475ae2 | 2017-09-12 04:42:15 -0700 | [diff] [blame] | 2631 | decoder_factory_(decoder_factory), |
nisse | e73afba | 2016-01-28 04:47:08 -0800 | [diff] [blame] | 2632 | sink_(NULL), |
magjed@webrtc.org | fc5ad95 | 2015-01-27 09:57:01 +0000 | [diff] [blame] | 2633 | first_frame_timestamp_(-1), |
Niels Möller | ac0a4cb | 2019-10-09 15:01:33 +0200 | [diff] [blame] | 2634 | estimated_remote_start_ntp_time_ms_(0) { |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2635 | config_.renderer = this; |
Niels Möller | cbcbc22 | 2018-09-28 09:07:24 +0200 | [diff] [blame] | 2636 | ConfigureCodecs(recv_codecs); |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 2637 | ConfigureFlexfecCodec(flexfec_config.payload_type); |
| 2638 | MaybeRecreateWebRtcFlexfecStream(); |
| 2639 | RecreateWebRtcVideoStream(); |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2640 | } |
| 2641 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2642 | WebRtcVideoChannel::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() { |
brandtr | 9c3d4c4 | 2017-01-23 06:59:13 -0800 | [diff] [blame] | 2643 | if (flexfec_stream_) { |
eladalon | c0d481a | 2017-08-02 07:39:07 -0700 | [diff] [blame] | 2644 | MaybeDissociateFlexfecFromVideo(); |
brandtr | 9c3d4c4 | 2017-01-23 06:59:13 -0800 | [diff] [blame] | 2645 | call_->DestroyFlexfecReceiveStream(flexfec_stream_); |
| 2646 | } |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2647 | call_->DestroyVideoReceiveStream(stream_); |
pbos@webrtc.org | 96a9325 | 2014-11-03 14:46:44 +0000 | [diff] [blame] | 2648 | } |
| 2649 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 2650 | const std::vector<uint32_t>& |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2651 | WebRtcVideoChannel::WebRtcVideoReceiveStream::GetSsrcs() const { |
sakal | 1fd9595 | 2016-06-22 00:46:15 -0700 | [diff] [blame] | 2652 | return stream_params_.ssrcs; |
| 2653 | } |
| 2654 | |
Jonas Oreland | 49ac595 | 2018-09-26 16:04:32 +0200 | [diff] [blame] | 2655 | std::vector<webrtc::RtpSource> |
| 2656 | WebRtcVideoChannel::WebRtcVideoReceiveStream::GetSources() { |
| 2657 | RTC_DCHECK(stream_); |
| 2658 | return stream_->GetSources(); |
| 2659 | } |
| 2660 | |
Florent Castelli | abe301f | 2018-06-12 18:33:49 +0200 | [diff] [blame] | 2661 | webrtc::RtpParameters |
| 2662 | WebRtcVideoChannel::WebRtcVideoReceiveStream::GetRtpParameters() const { |
| 2663 | webrtc::RtpParameters rtp_parameters; |
Florent Castelli | 38332cd | 2018-11-20 14:08:06 +0100 | [diff] [blame] | 2664 | |
| 2665 | std::vector<uint32_t> primary_ssrcs; |
| 2666 | stream_params_.GetPrimarySsrcs(&primary_ssrcs); |
| 2667 | for (uint32_t ssrc : primary_ssrcs) { |
| 2668 | rtp_parameters.encodings.emplace_back(); |
| 2669 | rtp_parameters.encodings.back().ssrc = ssrc; |
| 2670 | } |
| 2671 | |
Florent Castelli | abe301f | 2018-06-12 18:33:49 +0200 | [diff] [blame] | 2672 | rtp_parameters.header_extensions = config_.rtp.extensions; |
Florent Castelli | 38332cd | 2018-11-20 14:08:06 +0100 | [diff] [blame] | 2673 | rtp_parameters.rtcp.reduced_size = |
| 2674 | config_.rtp.rtcp_mode == webrtc::RtcpMode::kReducedSize; |
Florent Castelli | abe301f | 2018-06-12 18:33:49 +0200 | [diff] [blame] | 2675 | |
| 2676 | return rtp_parameters; |
| 2677 | } |
| 2678 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2679 | void WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureCodecs( |
Niels Möller | cbcbc22 | 2018-09-28 09:07:24 +0200 | [diff] [blame] | 2680 | const std::vector<VideoCodecSettings>& recv_codecs) { |
nisse | 3b3622f | 2017-09-26 02:49:21 -0700 | [diff] [blame] | 2681 | RTC_DCHECK(!recv_codecs.empty()); |
pbos@webrtc.org | 96a9325 | 2014-11-03 14:46:44 +0000 | [diff] [blame] | 2682 | config_.decoders.clear(); |
kthelgason | 0c88a50 | 2017-09-04 06:29:23 -0700 | [diff] [blame] | 2683 | config_.rtp.rtx_associated_payload_types.clear(); |
Mirta Dvornicic | 479a3c0 | 2019-06-04 15:38:50 +0200 | [diff] [blame] | 2684 | config_.rtp.raw_payload_types.clear(); |
kthelgason | 0c88a50 | 2017-09-04 06:29:23 -0700 | [diff] [blame] | 2685 | for (const auto& recv_codec : recv_codecs) { |
andersc | 063f0c0 | 2017-09-11 11:50:51 -0700 | [diff] [blame] | 2686 | webrtc::SdpVideoFormat video_format(recv_codec.codec.name, |
| 2687 | recv_codec.codec.params); |
Magnus Jedvert | 7501b1c | 2017-11-09 13:43:42 +0100 | [diff] [blame] | 2688 | |
pbos@webrtc.org | 96a9325 | 2014-11-03 14:46:44 +0000 | [diff] [blame] | 2689 | webrtc::VideoReceiveStream::Decoder decoder; |
Niels Möller | cbcbc22 | 2018-09-28 09:07:24 +0200 | [diff] [blame] | 2690 | decoder.decoder_factory = decoder_factory_; |
| 2691 | decoder.video_format = video_format; |
kthelgason | 0c88a50 | 2017-09-04 06:29:23 -0700 | [diff] [blame] | 2692 | decoder.payload_type = recv_codec.codec.id; |
Niels Möller | cb7e1d2 | 2018-09-11 15:56:04 +0200 | [diff] [blame] | 2693 | decoder.video_format = |
| 2694 | webrtc::SdpVideoFormat(recv_codec.codec.name, recv_codec.codec.params); |
pbos@webrtc.org | 96a9325 | 2014-11-03 14:46:44 +0000 | [diff] [blame] | 2695 | config_.decoders.push_back(decoder); |
nisse | 26e3abb | 2017-08-25 04:44:25 -0700 | [diff] [blame] | 2696 | config_.rtp.rtx_associated_payload_types[recv_codec.rtx_payload_type] = |
| 2697 | recv_codec.codec.id; |
Mirta Dvornicic | 479a3c0 | 2019-06-04 15:38:50 +0200 | [diff] [blame] | 2698 | if (recv_codec.codec.packetization == kPacketizationParamRaw) { |
| 2699 | config_.rtp.raw_payload_types.insert(recv_codec.codec.id); |
| 2700 | } |
brandtr | 1474212 | 2017-01-27 04:53:07 -0800 | [diff] [blame] | 2701 | } |
| 2702 | |
nisse | 3b3622f | 2017-09-26 02:49:21 -0700 | [diff] [blame] | 2703 | const auto& codec = recv_codecs.front(); |
| 2704 | config_.rtp.ulpfec_payload_type = codec.ulpfec.ulpfec_payload_type; |
| 2705 | config_.rtp.red_payload_type = codec.ulpfec.red_payload_type; |
brandtr | bb7066f | 2016-12-19 09:41:04 -0800 | [diff] [blame] | 2706 | |
Elad Alon | fadb181 | 2019-05-24 13:40:02 +0200 | [diff] [blame] | 2707 | config_.rtp.lntf.enabled = HasLntf(codec.codec); |
nisse | 3b3622f | 2017-09-26 02:49:21 -0700 | [diff] [blame] | 2708 | config_.rtp.nack.rtp_history_ms = HasNack(codec.codec) ? kNackHistoryMs : 0; |
Ilya Nikolaevskiy | 634a777 | 2018-04-04 16:33:49 +0200 | [diff] [blame] | 2709 | config_.rtp.rtcp_xr.receiver_reference_time_report = HasRrtr(codec.codec); |
nisse | 3b3622f | 2017-09-26 02:49:21 -0700 | [diff] [blame] | 2710 | if (codec.ulpfec.red_rtx_payload_type != -1) { |
nisse | ca5706d | 2017-09-11 02:32:16 -0700 | [diff] [blame] | 2711 | config_.rtp |
nisse | 3b3622f | 2017-09-26 02:49:21 -0700 | [diff] [blame] | 2712 | .rtx_associated_payload_types[codec.ulpfec.red_rtx_payload_type] = |
| 2713 | codec.ulpfec.red_payload_type; |
nisse | ca5706d | 2017-09-11 02:32:16 -0700 | [diff] [blame] | 2714 | } |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2715 | } |
| 2716 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2717 | void WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureFlexfecCodec( |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 2718 | int flexfec_payload_type) { |
| 2719 | flexfec_config_.payload_type = flexfec_payload_type; |
| 2720 | } |
| 2721 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2722 | void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetLocalSsrc( |
Peter Boström | 3548dd2 | 2015-05-22 18:48:36 +0200 | [diff] [blame] | 2723 | uint32_t local_ssrc) { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 2724 | // TODO(pbos): Consider turning this sanity check into a RTC_DCHECK. You |
| 2725 | // should not be able to create a sender with the same SSRC as a receiver, but |
| 2726 | // right now this can't be done due to unittests depending on receiving what |
| 2727 | // they are sending from the same MediaChannel. |
Jonas Olsson | a564afe | 2018-02-14 10:51:15 +0100 | [diff] [blame] | 2728 | if (local_ssrc == config_.rtp.local_ssrc) { |
Jonas Olsson | 8544799 | 2018-11-13 14:43:09 +0100 | [diff] [blame] | 2729 | RTC_DLOG(LS_INFO) << "Ignoring call to SetLocalSsrc because parameters are " |
| 2730 | "unchanged; local_ssrc=" |
| 2731 | << local_ssrc; |
Peter Boström | 3548dd2 | 2015-05-22 18:48:36 +0200 | [diff] [blame] | 2732 | return; |
deadbeef | 874ca3a | 2015-08-20 17:19:20 -0700 | [diff] [blame] | 2733 | } |
Peter Boström | 3548dd2 | 2015-05-22 18:48:36 +0200 | [diff] [blame] | 2734 | |
| 2735 | config_.rtp.local_ssrc = local_ssrc; |
brandtr | fa5a368 | 2017-01-17 01:33:54 -0800 | [diff] [blame] | 2736 | flexfec_config_.local_ssrc = local_ssrc; |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 2737 | RTC_LOG(LS_INFO) |
deadbeef | 874ca3a | 2015-08-20 17:19:20 -0700 | [diff] [blame] | 2738 | << "RecreateWebRtcStream (recv) because of SetLocalSsrc; local_ssrc=" |
| 2739 | << local_ssrc; |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 2740 | MaybeRecreateWebRtcFlexfecStream(); |
| 2741 | RecreateWebRtcVideoStream(); |
Peter Boström | 3548dd2 | 2015-05-22 18:48:36 +0200 | [diff] [blame] | 2742 | } |
| 2743 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2744 | void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetFeedbackParameters( |
Elad Alon | fadb181 | 2019-05-24 13:40:02 +0200 | [diff] [blame] | 2745 | bool lntf_enabled, |
stefan | 43edf0f | 2015-11-20 18:05:48 -0800 | [diff] [blame] | 2746 | bool nack_enabled, |
Taylor Brandstetter | 5f0b83b | 2016-03-18 15:02:07 -0700 | [diff] [blame] | 2747 | bool transport_cc_enabled, |
| 2748 | webrtc::RtcpMode rtcp_mode) { |
Peter Boström | 67c9df7 | 2015-05-11 14:34:58 +0200 | [diff] [blame] | 2749 | int nack_history_ms = nack_enabled ? kNackHistoryMs : 0; |
Elad Alon | fadb181 | 2019-05-24 13:40:02 +0200 | [diff] [blame] | 2750 | if (config_.rtp.lntf.enabled == lntf_enabled && |
| 2751 | config_.rtp.nack.rtp_history_ms == nack_history_ms && |
Taylor Brandstetter | 5f0b83b | 2016-03-18 15:02:07 -0700 | [diff] [blame] | 2752 | config_.rtp.transport_cc == transport_cc_enabled && |
| 2753 | config_.rtp.rtcp_mode == rtcp_mode) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 2754 | RTC_LOG(LS_INFO) |
stefan | 43edf0f | 2015-11-20 18:05:48 -0800 | [diff] [blame] | 2755 | << "Ignoring call to SetFeedbackParameters because parameters are " |
Elad Alon | fadb181 | 2019-05-24 13:40:02 +0200 | [diff] [blame] | 2756 | "unchanged; lntf=" |
| 2757 | << lntf_enabled << ", nack=" << nack_enabled |
stefan | 43edf0f | 2015-11-20 18:05:48 -0800 | [diff] [blame] | 2758 | << ", transport_cc=" << transport_cc_enabled; |
Peter Boström | 126c03e | 2015-05-11 12:48:12 +0200 | [diff] [blame] | 2759 | return; |
Peter Boström | 67c9df7 | 2015-05-11 14:34:58 +0200 | [diff] [blame] | 2760 | } |
Elad Alon | fadb181 | 2019-05-24 13:40:02 +0200 | [diff] [blame] | 2761 | config_.rtp.lntf.enabled = lntf_enabled; |
Peter Boström | 67c9df7 | 2015-05-11 14:34:58 +0200 | [diff] [blame] | 2762 | config_.rtp.nack.rtp_history_ms = nack_history_ms; |
stefan | 43edf0f | 2015-11-20 18:05:48 -0800 | [diff] [blame] | 2763 | config_.rtp.transport_cc = transport_cc_enabled; |
Taylor Brandstetter | 5f0b83b | 2016-03-18 15:02:07 -0700 | [diff] [blame] | 2764 | config_.rtp.rtcp_mode = rtcp_mode; |
brandtr | 9d58d94 | 2017-02-03 04:43:41 -0800 | [diff] [blame] | 2765 | // TODO(brandtr): We should be spec-compliant and set |transport_cc| here |
| 2766 | // based on the rtcp-fb for the FlexFEC codec, not the media codec. |
| 2767 | flexfec_config_.transport_cc = config_.rtp.transport_cc; |
| 2768 | flexfec_config_.rtcp_mode = config_.rtp.rtcp_mode; |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 2769 | RTC_LOG(LS_INFO) |
stefan | 43edf0f | 2015-11-20 18:05:48 -0800 | [diff] [blame] | 2770 | << "RecreateWebRtcStream (recv) because of SetFeedbackParameters; nack=" |
Niels Möller | 7bf7a42 | 2019-09-13 08:31:45 +0200 | [diff] [blame] | 2771 | << nack_enabled << ", transport_cc=" << transport_cc_enabled; |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 2772 | MaybeRecreateWebRtcFlexfecStream(); |
| 2773 | RecreateWebRtcVideoStream(); |
Peter Boström | 126c03e | 2015-05-11 12:48:12 +0200 | [diff] [blame] | 2774 | } |
| 2775 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2776 | void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetRecvParameters( |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 2777 | const ChangedRecvParameters& params) { |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 2778 | bool video_needs_recreation = false; |
| 2779 | bool flexfec_needs_recreation = false; |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 2780 | if (params.codec_settings) { |
Niels Möller | cbcbc22 | 2018-09-28 09:07:24 +0200 | [diff] [blame] | 2781 | ConfigureCodecs(*params.codec_settings); |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 2782 | video_needs_recreation = true; |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 2783 | } |
| 2784 | if (params.rtp_header_extensions) { |
| 2785 | config_.rtp.extensions = *params.rtp_header_extensions; |
brandtr | 9d58d94 | 2017-02-03 04:43:41 -0800 | [diff] [blame] | 2786 | flexfec_config_.rtp_header_extensions = *params.rtp_header_extensions; |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 2787 | video_needs_recreation = true; |
| 2788 | flexfec_needs_recreation = true; |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 2789 | } |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 2790 | if (params.flexfec_payload_type) { |
| 2791 | ConfigureFlexfecCodec(*params.flexfec_payload_type); |
| 2792 | flexfec_needs_recreation = true; |
| 2793 | } |
| 2794 | if (flexfec_needs_recreation) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 2795 | RTC_LOG(LS_INFO) << "MaybeRecreateWebRtcFlexfecStream (recv) because of " |
| 2796 | "SetRecvParameters"; |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 2797 | MaybeRecreateWebRtcFlexfecStream(); |
| 2798 | } |
| 2799 | if (video_needs_recreation) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 2800 | RTC_LOG(LS_INFO) |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 2801 | << "RecreateWebRtcVideoStream (recv) because of SetRecvParameters"; |
| 2802 | RecreateWebRtcVideoStream(); |
pbos | 378dc77 | 2016-01-28 15:58:41 -0800 | [diff] [blame] | 2803 | } |
deadbeef | 1387149 | 2015-12-09 12:37:51 -0800 | [diff] [blame] | 2804 | } |
| 2805 | |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 2806 | void WebRtcVideoChannel::WebRtcVideoReceiveStream::RecreateWebRtcVideoStream() { |
Ruslan Burakov | 493a650 | 2019-02-27 15:32:48 +0100 | [diff] [blame] | 2807 | absl::optional<int> base_minimum_playout_delay_ms; |
Markus Handell | 32565f6 | 2019-12-04 10:58:17 +0100 | [diff] [blame] | 2808 | absl::optional<webrtc::VideoReceiveStream::RecordingState> recording_state; |
brandtr | fb45c6c | 2017-01-27 06:47:55 -0800 | [diff] [blame] | 2809 | if (stream_) { |
Ruslan Burakov | 493a650 | 2019-02-27 15:32:48 +0100 | [diff] [blame] | 2810 | base_minimum_playout_delay_ms = stream_->GetBaseMinimumPlayoutDelayMs(); |
Markus Handell | 32565f6 | 2019-12-04 10:58:17 +0100 | [diff] [blame] | 2811 | recording_state = stream_->SetAndGetRecordingState( |
| 2812 | webrtc::VideoReceiveStream::RecordingState(), |
| 2813 | /*generate_key_frame=*/false); |
eladalon | c0d481a | 2017-08-02 07:39:07 -0700 | [diff] [blame] | 2814 | MaybeDissociateFlexfecFromVideo(); |
brandtr | fb45c6c | 2017-01-27 06:47:55 -0800 | [diff] [blame] | 2815 | call_->DestroyVideoReceiveStream(stream_); |
| 2816 | stream_ = nullptr; |
| 2817 | } |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 2818 | webrtc::VideoReceiveStream::Config config = config_.Copy(); |
| 2819 | config.rtp.protected_by_flexfec = (flexfec_stream_ != nullptr); |
Niels Möller | cbcbc22 | 2018-09-28 09:07:24 +0200 | [diff] [blame] | 2820 | config.stream_id = stream_params_.id; |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 2821 | stream_ = call_->CreateVideoReceiveStream(std::move(config)); |
Ruslan Burakov | 493a650 | 2019-02-27 15:32:48 +0100 | [diff] [blame] | 2822 | if (base_minimum_playout_delay_ms) { |
| 2823 | stream_->SetBaseMinimumPlayoutDelayMs( |
| 2824 | base_minimum_playout_delay_ms.value()); |
| 2825 | } |
Markus Handell | 32565f6 | 2019-12-04 10:58:17 +0100 | [diff] [blame] | 2826 | if (recording_state) { |
| 2827 | stream_->SetAndGetRecordingState(std::move(*recording_state), |
| 2828 | /*generate_key_frame=*/false); |
| 2829 | } |
eladalon | c0d481a | 2017-08-02 07:39:07 -0700 | [diff] [blame] | 2830 | MaybeAssociateFlexfecWithVideo(); |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 2831 | stream_->Start(); |
Jonas Oreland | 6d83592 | 2019-03-18 10:59:40 +0100 | [diff] [blame] | 2832 | |
| 2833 | if (webrtc::field_trial::IsEnabled( |
| 2834 | "WebRTC-Video-BufferPacketsWithUnknownSsrc")) { |
Benjamin Wright | a556448 | 2019-04-03 10:44:18 -0700 | [diff] [blame] | 2835 | channel_->BackfillBufferedPackets(stream_params_.ssrcs); |
Jonas Oreland | 6d83592 | 2019-03-18 10:59:40 +0100 | [diff] [blame] | 2836 | } |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 2837 | } |
| 2838 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2839 | void WebRtcVideoChannel::WebRtcVideoReceiveStream:: |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 2840 | MaybeRecreateWebRtcFlexfecStream() { |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 2841 | if (flexfec_stream_) { |
eladalon | c0d481a | 2017-08-02 07:39:07 -0700 | [diff] [blame] | 2842 | MaybeDissociateFlexfecFromVideo(); |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 2843 | call_->DestroyFlexfecReceiveStream(flexfec_stream_); |
| 2844 | flexfec_stream_ = nullptr; |
| 2845 | } |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 2846 | if (flexfec_config_.IsCompleteAndEnabled()) { |
brandtr | 8313a6f | 2017-01-13 07:41:19 -0800 | [diff] [blame] | 2847 | flexfec_stream_ = call_->CreateFlexfecReceiveStream(flexfec_config_); |
eladalon | c0d481a | 2017-08-02 07:39:07 -0700 | [diff] [blame] | 2848 | MaybeAssociateFlexfecWithVideo(); |
| 2849 | } |
| 2850 | } |
| 2851 | |
| 2852 | void WebRtcVideoChannel::WebRtcVideoReceiveStream:: |
| 2853 | MaybeAssociateFlexfecWithVideo() { |
| 2854 | if (stream_ && flexfec_stream_) { |
| 2855 | stream_->AddSecondarySink(flexfec_stream_); |
| 2856 | } |
| 2857 | } |
| 2858 | |
| 2859 | void WebRtcVideoChannel::WebRtcVideoReceiveStream:: |
| 2860 | MaybeDissociateFlexfecFromVideo() { |
| 2861 | if (stream_ && flexfec_stream_) { |
| 2862 | stream_->RemoveSecondarySink(flexfec_stream_); |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 2863 | } |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2864 | } |
| 2865 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2866 | void WebRtcVideoChannel::WebRtcVideoReceiveStream::OnFrame( |
nisse | eb83a1a | 2016-03-21 01:27:56 -0700 | [diff] [blame] | 2867 | const webrtc::VideoFrame& frame) { |
nisse | e73afba | 2016-01-28 04:47:08 -0800 | [diff] [blame] | 2868 | rtc::CritScope crit(&sink_lock_); |
magjed@webrtc.org | fc5ad95 | 2015-01-27 09:57:01 +0000 | [diff] [blame] | 2869 | |
Ilya Nikolaevskiy | 9c38c47 | 2018-09-03 16:11:42 +0200 | [diff] [blame] | 2870 | int64_t time_now_ms = rtc::TimeMillis(); |
magjed@webrtc.org | fc5ad95 | 2015-01-27 09:57:01 +0000 | [diff] [blame] | 2871 | if (first_frame_timestamp_ < 0) |
Ilya Nikolaevskiy | 9c38c47 | 2018-09-03 16:11:42 +0200 | [diff] [blame] | 2872 | first_frame_timestamp_ = time_now_ms; |
| 2873 | int64_t elapsed_time_ms = time_now_ms - first_frame_timestamp_; |
magjed@webrtc.org | fc5ad95 | 2015-01-27 09:57:01 +0000 | [diff] [blame] | 2874 | if (frame.ntp_time_ms() > 0) |
| 2875 | estimated_remote_start_ntp_time_ms_ = frame.ntp_time_ms() - elapsed_time_ms; |
| 2876 | |
nisse | e73afba | 2016-01-28 04:47:08 -0800 | [diff] [blame] | 2877 | if (sink_ == NULL) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 2878 | RTC_LOG(LS_WARNING) << "VideoReceiveStream not connected to a VideoSink."; |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2879 | return; |
| 2880 | } |
| 2881 | |
nisse | 0934785 | 2016-10-19 00:30:30 -0700 | [diff] [blame] | 2882 | sink_->OnFrame(frame); |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2883 | } |
| 2884 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2885 | bool WebRtcVideoChannel::WebRtcVideoReceiveStream::IsDefaultStream() const { |
pbos@webrtc.org | a2a6fe6 | 2015-03-06 15:35:19 +0000 | [diff] [blame] | 2886 | return default_stream_; |
| 2887 | } |
| 2888 | |
Benjamin Wright | 192eeec | 2018-10-17 17:27:25 -0700 | [diff] [blame] | 2889 | void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetFrameDecryptor( |
| 2890 | rtc::scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor) { |
| 2891 | config_.frame_decryptor = frame_decryptor; |
| 2892 | if (stream_) { |
Jonas Oreland | 6d83592 | 2019-03-18 10:59:40 +0100 | [diff] [blame] | 2893 | RTC_LOG(LS_INFO) |
Benjamin Wright | a556448 | 2019-04-03 10:44:18 -0700 | [diff] [blame] | 2894 | << "Setting FrameDecryptor (recv) because of SetFrameDecryptor, " |
Jonas Olsson | b2b2031 | 2020-01-14 12:11:31 +0100 | [diff] [blame] | 2895 | "remote_ssrc=" |
| 2896 | << config_.rtp.remote_ssrc; |
Benjamin Wright | a556448 | 2019-04-03 10:44:18 -0700 | [diff] [blame] | 2897 | stream_->SetFrameDecryptor(frame_decryptor); |
Benjamin Wright | 192eeec | 2018-10-17 17:27:25 -0700 | [diff] [blame] | 2898 | } |
| 2899 | } |
| 2900 | |
Ruslan Burakov | 493a650 | 2019-02-27 15:32:48 +0100 | [diff] [blame] | 2901 | bool WebRtcVideoChannel::WebRtcVideoReceiveStream::SetBaseMinimumPlayoutDelayMs( |
| 2902 | int delay_ms) { |
| 2903 | return stream_ ? stream_->SetBaseMinimumPlayoutDelayMs(delay_ms) : false; |
| 2904 | } |
| 2905 | |
| 2906 | int WebRtcVideoChannel::WebRtcVideoReceiveStream::GetBaseMinimumPlayoutDelayMs() |
| 2907 | const { |
| 2908 | return stream_ ? stream_->GetBaseMinimumPlayoutDelayMs() : 0; |
| 2909 | } |
| 2910 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2911 | void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetSink( |
nisse | acd935b | 2016-11-11 03:55:13 -0800 | [diff] [blame] | 2912 | rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) { |
nisse | e73afba | 2016-01-28 04:47:08 -0800 | [diff] [blame] | 2913 | rtc::CritScope crit(&sink_lock_); |
| 2914 | sink_ = sink; |
pbos@webrtc.org | d1ea06b | 2014-07-18 09:35:58 +0000 | [diff] [blame] | 2915 | } |
| 2916 | |
pbos | f42376c | 2015-08-28 07:35:32 -0700 | [diff] [blame] | 2917 | std::string |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2918 | WebRtcVideoChannel::WebRtcVideoReceiveStream::GetCodecNameFromPayloadType( |
pbos | f42376c | 2015-08-28 07:35:32 -0700 | [diff] [blame] | 2919 | int payload_type) { |
| 2920 | for (const webrtc::VideoReceiveStream::Decoder& decoder : config_.decoders) { |
| 2921 | if (decoder.payload_type == payload_type) { |
Niels Möller | cb7e1d2 | 2018-09-11 15:56:04 +0200 | [diff] [blame] | 2922 | return decoder.video_format.name; |
pbos | f42376c | 2015-08-28 07:35:32 -0700 | [diff] [blame] | 2923 | } |
| 2924 | } |
| 2925 | return ""; |
| 2926 | } |
| 2927 | |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2928 | VideoReceiverInfo |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 2929 | WebRtcVideoChannel::WebRtcVideoReceiveStream::GetVideoReceiverInfo( |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 2930 | bool log_stats) { |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2931 | VideoReceiverInfo info; |
sakal | 1fd9595 | 2016-06-22 00:46:15 -0700 | [diff] [blame] | 2932 | info.ssrc_groups = stream_params_.ssrc_groups; |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2933 | info.add_ssrc(config_.rtp.remote_ssrc); |
| 2934 | webrtc::VideoReceiveStream::Stats stats = stream_->GetStats(); |
Peter Boström | b7d9a97 | 2015-12-18 16:01:11 +0100 | [diff] [blame] | 2935 | info.decoder_implementation_name = stats.decoder_implementation_name; |
hbos | a65704b | 2016-11-14 02:28:16 -0800 | [diff] [blame] | 2936 | if (stats.current_payload_type != -1) { |
Oskar Sundbom | 7880758 | 2017-11-16 11:09:55 +0100 | [diff] [blame] | 2937 | info.codec_payload_type = stats.current_payload_type; |
hbos | a65704b | 2016-11-14 02:28:16 -0800 | [diff] [blame] | 2938 | } |
Niels Möller | ac0a4cb | 2019-10-09 15:01:33 +0200 | [diff] [blame] | 2939 | info.payload_bytes_rcvd = stats.rtp_stats.packet_counter.payload_bytes; |
| 2940 | info.header_and_padding_bytes_rcvd = |
| 2941 | stats.rtp_stats.packet_counter.header_bytes + |
| 2942 | stats.rtp_stats.packet_counter.padding_bytes; |
Niels Möller | d77cc24 | 2019-08-22 09:40:25 +0200 | [diff] [blame] | 2943 | info.packets_rcvd = stats.rtp_stats.packet_counter.packets; |
| 2944 | info.packets_lost = stats.rtp_stats.packets_lost; |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2945 | |
| 2946 | info.framerate_rcvd = stats.network_frame_rate; |
| 2947 | info.framerate_decoded = stats.decode_frame_rate; |
| 2948 | info.framerate_output = stats.render_frame_rate; |
asapersson | 26dd92b | 2016-08-30 00:45:45 -0700 | [diff] [blame] | 2949 | info.frame_width = stats.width; |
| 2950 | info.frame_height = stats.height; |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2951 | |
pbos@webrtc.org | 1d0fa5d | 2015-02-19 12:47:00 +0000 | [diff] [blame] | 2952 | { |
nisse | e73afba | 2016-01-28 04:47:08 -0800 | [diff] [blame] | 2953 | rtc::CritScope frame_cs(&sink_lock_); |
pbos@webrtc.org | 1d0fa5d | 2015-02-19 12:47:00 +0000 | [diff] [blame] | 2954 | info.capture_start_ntp_time_ms = estimated_remote_start_ntp_time_ms_; |
| 2955 | } |
| 2956 | |
pbos@webrtc.org | 09c77b9 | 2015-02-25 10:42:16 +0000 | [diff] [blame] | 2957 | info.decode_ms = stats.decode_ms; |
| 2958 | info.max_decode_ms = stats.max_decode_ms; |
| 2959 | info.current_delay_ms = stats.current_delay_ms; |
| 2960 | info.target_delay_ms = stats.target_delay_ms; |
| 2961 | info.jitter_buffer_ms = stats.jitter_buffer_ms; |
Guido Urdaneta | 6737841 | 2019-05-28 17:38:08 +0200 | [diff] [blame] | 2962 | info.jitter_buffer_delay_seconds = stats.jitter_buffer_delay_seconds; |
| 2963 | info.jitter_buffer_emitted_count = stats.jitter_buffer_emitted_count; |
pbos@webrtc.org | 09c77b9 | 2015-02-25 10:42:16 +0000 | [diff] [blame] | 2964 | info.min_playout_delay_ms = stats.min_playout_delay_ms; |
| 2965 | info.render_delay_ms = stats.render_delay_ms; |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 2966 | info.frames_received = |
| 2967 | stats.frame_counts.key_frames + stats.frame_counts.delta_frames; |
Johannes Kron | 0c141c5 | 2019-08-26 15:04:43 +0200 | [diff] [blame] | 2968 | info.frames_dropped = stats.frames_dropped; |
sakal | e5ba44e | 2016-10-26 07:09:24 -0700 | [diff] [blame] | 2969 | info.frames_decoded = stats.frames_decoded; |
Rasmus Brandt | 2efae77 | 2019-06-27 14:29:34 +0200 | [diff] [blame] | 2970 | info.key_frames_decoded = stats.frame_counts.key_frames; |
hbos | 50cfe1f | 2017-01-23 07:21:55 -0800 | [diff] [blame] | 2971 | info.frames_rendered = stats.frames_rendered; |
sakal | cc452e1 | 2017-02-09 04:53:45 -0800 | [diff] [blame] | 2972 | info.qp_sum = stats.qp_sum; |
Johannes Kron | bfd343b | 2019-07-01 10:07:50 +0200 | [diff] [blame] | 2973 | info.total_decode_time_ms = stats.total_decode_time_ms; |
Henrik Boström | 01738c6 | 2019-04-15 17:32:00 +0200 | [diff] [blame] | 2974 | info.last_packet_received_timestamp_ms = |
| 2975 | stats.rtp_stats.last_packet_received_timestamp_ms; |
Åsa Persson | fcf79cc | 2019-10-22 15:23:44 +0200 | [diff] [blame] | 2976 | info.estimated_playout_ntp_timestamp_ms = |
| 2977 | stats.estimated_playout_ntp_timestamp_ms; |
Benjamin Wright | 514f084 | 2018-12-10 09:55:17 -0800 | [diff] [blame] | 2978 | info.first_frame_received_to_decoded_ms = |
| 2979 | stats.first_frame_received_to_decoded_ms; |
Johannes Kron | 00376e1 | 2019-11-25 10:25:42 +0100 | [diff] [blame] | 2980 | info.total_inter_frame_delay = stats.total_inter_frame_delay; |
| 2981 | info.total_squared_inter_frame_delay = stats.total_squared_inter_frame_delay; |
ilnik | a79cc28 | 2017-08-23 05:24:10 -0700 | [diff] [blame] | 2982 | info.interframe_delay_max_ms = stats.interframe_delay_max_ms; |
Sergey Silkin | 0237106 | 2019-01-31 16:45:42 +0100 | [diff] [blame] | 2983 | info.freeze_count = stats.freeze_count; |
| 2984 | info.pause_count = stats.pause_count; |
| 2985 | info.total_freezes_duration_ms = stats.total_freezes_duration_ms; |
| 2986 | info.total_pauses_duration_ms = stats.total_pauses_duration_ms; |
| 2987 | info.total_frames_duration_ms = stats.total_frames_duration_ms; |
| 2988 | info.sum_squared_frame_durations = stats.sum_squared_frame_durations; |
ilnik | f04afde | 2017-07-07 01:26:24 -0700 | [diff] [blame] | 2989 | |
ilnik | 2e1b40b | 2017-09-04 07:57:17 -0700 | [diff] [blame] | 2990 | info.content_type = stats.content_type; |
| 2991 | |
pbos | f42376c | 2015-08-28 07:35:32 -0700 | [diff] [blame] | 2992 | info.codec_name = GetCodecNameFromPayloadType(stats.current_payload_type); |
| 2993 | |
pbos@webrtc.org | 1d0fa5d | 2015-02-19 12:47:00 +0000 | [diff] [blame] | 2994 | info.firs_sent = stats.rtcp_packet_type_counts.fir_packets; |
| 2995 | info.plis_sent = stats.rtcp_packet_type_counts.pli_packets; |
| 2996 | info.nacks_sent = stats.rtcp_packet_type_counts.nack_packets; |
Elad Alon | fadb181 | 2019-05-24 13:40:02 +0200 | [diff] [blame] | 2997 | // TODO(bugs.webrtc.org/10662): Add stats for LNTF. |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 2998 | |
ilnik | 75204c5 | 2017-09-04 03:35:40 -0700 | [diff] [blame] | 2999 | info.timing_frame_info = stats.timing_frame_info; |
ilnik | 2edc684 | 2017-07-06 03:06:50 -0700 | [diff] [blame] | 3000 | |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 3001 | if (log_stats) |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 3002 | RTC_LOG(LS_INFO) << stats.ToString(rtc::TimeMillis()); |
asapersson | 2e5cfcd | 2016-08-11 08:41:18 -0700 | [diff] [blame] | 3003 | |
pbos@webrtc.org | e6f84ae | 2014-07-18 11:11:55 +0000 | [diff] [blame] | 3004 | return info; |
| 3005 | } |
| 3006 | |
Markus Handell | 32565f6 | 2019-12-04 10:58:17 +0100 | [diff] [blame] | 3007 | void WebRtcVideoChannel::WebRtcVideoReceiveStream:: |
| 3008 | SetRecordableEncodedFrameCallback( |
| 3009 | std::function<void(const webrtc::RecordableEncodedFrame&)> callback) { |
| 3010 | if (stream_) { |
| 3011 | stream_->SetAndGetRecordingState( |
| 3012 | webrtc::VideoReceiveStream::RecordingState(std::move(callback)), |
| 3013 | /*generate_key_frame=*/true); |
| 3014 | } else { |
| 3015 | RTC_LOG(LS_ERROR) << "Absent receive stream; ignoring setting encoded " |
| 3016 | "frame sink"; |
| 3017 | } |
| 3018 | } |
| 3019 | |
| 3020 | void WebRtcVideoChannel::WebRtcVideoReceiveStream:: |
| 3021 | ClearRecordableEncodedFrameCallback() { |
| 3022 | if (stream_) { |
| 3023 | stream_->SetAndGetRecordingState( |
| 3024 | webrtc::VideoReceiveStream::RecordingState(), |
| 3025 | /*generate_key_frame=*/false); |
| 3026 | } else { |
| 3027 | RTC_LOG(LS_ERROR) << "Absent receive stream; ignoring clearing encoded " |
| 3028 | "frame sink"; |
| 3029 | } |
| 3030 | } |
| 3031 | |
| 3032 | void WebRtcVideoChannel::WebRtcVideoReceiveStream::GenerateKeyFrame() { |
| 3033 | if (stream_) { |
| 3034 | stream_->GenerateKeyFrame(); |
| 3035 | } else { |
| 3036 | RTC_LOG(LS_ERROR) |
| 3037 | << "Absent receive stream; ignoring key frame generation request."; |
| 3038 | } |
| 3039 | } |
| 3040 | |
Marina Ciocea | 412a31b | 2020-02-28 16:02:06 +0100 | [diff] [blame] | 3041 | void WebRtcVideoChannel::WebRtcVideoReceiveStream:: |
| 3042 | SetDepacketizerToDecoderFrameTransformer( |
| 3043 | rtc::scoped_refptr<webrtc::FrameTransformerInterface> |
| 3044 | frame_transformer) { |
| 3045 | config_.frame_transformer = frame_transformer; |
Guido Urdaneta | e1aa22f | 2020-03-30 23:02:14 +0200 | [diff] [blame] | 3046 | if (stream_) |
| 3047 | stream_->SetDepacketizerToDecoderFrameTransformer(frame_transformer); |
Marina Ciocea | 412a31b | 2020-02-28 16:02:06 +0100 | [diff] [blame] | 3048 | } |
| 3049 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 3050 | WebRtcVideoChannel::VideoCodecSettings::VideoCodecSettings() |
brandtr | bb7066f | 2016-12-19 09:41:04 -0800 | [diff] [blame] | 3051 | : flexfec_payload_type(-1), rtx_payload_type(-1) {} |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 3052 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 3053 | bool WebRtcVideoChannel::VideoCodecSettings::operator==( |
| 3054 | const WebRtcVideoChannel::VideoCodecSettings& other) const { |
brandtr | 468da7c | 2016-11-22 02:16:47 -0800 | [diff] [blame] | 3055 | return codec == other.codec && ulpfec == other.ulpfec && |
brandtr | bb7066f | 2016-12-19 09:41:04 -0800 | [diff] [blame] | 3056 | flexfec_payload_type == other.flexfec_payload_type && |
| 3057 | rtx_payload_type == other.rtx_payload_type; |
pbos@webrtc.org | a2ef4fe | 2014-11-07 10:54:43 +0000 | [diff] [blame] | 3058 | } |
| 3059 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 3060 | bool WebRtcVideoChannel::VideoCodecSettings::EqualsDisregardingFlexfec( |
| 3061 | const WebRtcVideoChannel::VideoCodecSettings& a, |
| 3062 | const WebRtcVideoChannel::VideoCodecSettings& b) { |
brandtr | 11fb472 | 2017-05-30 01:31:37 -0700 | [diff] [blame] | 3063 | return a.codec == b.codec && a.ulpfec == b.ulpfec && |
| 3064 | a.rtx_payload_type == b.rtx_payload_type; |
| 3065 | } |
| 3066 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 3067 | bool WebRtcVideoChannel::VideoCodecSettings::operator!=( |
| 3068 | const WebRtcVideoChannel::VideoCodecSettings& other) const { |
Peter Boström | ee0b00e | 2015-04-22 18:41:14 +0200 | [diff] [blame] | 3069 | return !(*this == other); |
| 3070 | } |
| 3071 | |
eladalon | f184138 | 2017-06-12 01:16:46 -0700 | [diff] [blame] | 3072 | std::vector<WebRtcVideoChannel::VideoCodecSettings> |
| 3073 | WebRtcVideoChannel::MapCodecs(const std::vector<VideoCodec>& codecs) { |
Johannes Kron | 3e98368 | 2020-03-29 22:17:00 +0200 | [diff] [blame] | 3074 | if (codecs.empty()) { |
| 3075 | return {}; |
| 3076 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 3077 | |
| 3078 | std::vector<VideoCodecSettings> video_codecs; |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 3079 | std::map<int, VideoCodec::CodecType> payload_codec_type; |
pkasting@chromium.org | d324546 | 2015-02-23 21:28:22 +0000 | [diff] [blame] | 3080 | // |rtx_mapping| maps video payload type to rtx payload type. |
| 3081 | std::map<int, int> rtx_mapping; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 3082 | |
brandtr | b5f2c3f | 2016-10-04 23:28:39 -0700 | [diff] [blame] | 3083 | webrtc::UlpfecConfig ulpfec_config; |
Steve Anton | 2d2bbb1 | 2019-08-07 09:57:59 -0700 | [diff] [blame] | 3084 | absl::optional<int> flexfec_payload_type; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 3085 | |
Steve Anton | 2d2bbb1 | 2019-08-07 09:57:59 -0700 | [diff] [blame] | 3086 | for (const VideoCodec& in_codec : codecs) { |
| 3087 | const int payload_type = in_codec.id; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 3088 | |
Steve Anton | 2d2bbb1 | 2019-08-07 09:57:59 -0700 | [diff] [blame] | 3089 | if (payload_codec_type.find(payload_type) != payload_codec_type.end()) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 3090 | RTC_LOG(LS_ERROR) << "Payload type already registered: " |
| 3091 | << in_codec.ToString(); |
Steve Anton | 2d2bbb1 | 2019-08-07 09:57:59 -0700 | [diff] [blame] | 3092 | return {}; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 3093 | } |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 3094 | payload_codec_type[payload_type] = in_codec.GetCodecType(); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 3095 | |
| 3096 | switch (in_codec.GetCodecType()) { |
| 3097 | case VideoCodec::CODEC_RED: { |
Steve Anton | 2d2bbb1 | 2019-08-07 09:57:59 -0700 | [diff] [blame] | 3098 | if (ulpfec_config.red_payload_type != -1) { |
| 3099 | RTC_LOG(LS_ERROR) |
| 3100 | << "Duplicate RED codec: ignoring PT=" << payload_type |
| 3101 | << " in favor of PT=" << ulpfec_config.red_payload_type |
| 3102 | << " which was specified first."; |
| 3103 | break; |
| 3104 | } |
| 3105 | ulpfec_config.red_payload_type = payload_type; |
| 3106 | break; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 3107 | } |
| 3108 | |
| 3109 | case VideoCodec::CODEC_ULPFEC: { |
Steve Anton | 2d2bbb1 | 2019-08-07 09:57:59 -0700 | [diff] [blame] | 3110 | if (ulpfec_config.ulpfec_payload_type != -1) { |
| 3111 | RTC_LOG(LS_ERROR) |
| 3112 | << "Duplicate ULPFEC codec: ignoring PT=" << payload_type |
| 3113 | << " in favor of PT=" << ulpfec_config.ulpfec_payload_type |
| 3114 | << " which was specified first."; |
| 3115 | break; |
| 3116 | } |
| 3117 | ulpfec_config.ulpfec_payload_type = payload_type; |
| 3118 | break; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 3119 | } |
| 3120 | |
brandtr | 87d7d77 | 2016-11-07 03:03:41 -0800 | [diff] [blame] | 3121 | case VideoCodec::CODEC_FLEXFEC: { |
Steve Anton | 2d2bbb1 | 2019-08-07 09:57:59 -0700 | [diff] [blame] | 3122 | if (flexfec_payload_type) { |
| 3123 | RTC_LOG(LS_ERROR) |
| 3124 | << "Duplicate FLEXFEC codec: ignoring PT=" << payload_type |
| 3125 | << " in favor of PT=" << *flexfec_payload_type |
| 3126 | << " which was specified first."; |
| 3127 | break; |
| 3128 | } |
| 3129 | flexfec_payload_type = payload_type; |
| 3130 | break; |
brandtr | 87d7d77 | 2016-11-07 03:03:41 -0800 | [diff] [blame] | 3131 | } |
| 3132 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 3133 | case VideoCodec::CODEC_RTX: { |
| 3134 | int associated_payload_type; |
| 3135 | if (!in_codec.GetParam(kCodecParamAssociatedPayloadType, |
pkasting@chromium.org | e9facf8 | 2015-02-17 20:36:28 +0000 | [diff] [blame] | 3136 | &associated_payload_type) || |
| 3137 | !IsValidRtpPayloadType(associated_payload_type)) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 3138 | RTC_LOG(LS_ERROR) |
pkasting@chromium.org | e9facf8 | 2015-02-17 20:36:28 +0000 | [diff] [blame] | 3139 | << "RTX codec with invalid or no associated payload type: " |
| 3140 | << in_codec.ToString(); |
Steve Anton | 2d2bbb1 | 2019-08-07 09:57:59 -0700 | [diff] [blame] | 3141 | return {}; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 3142 | } |
Steve Anton | 2d2bbb1 | 2019-08-07 09:57:59 -0700 | [diff] [blame] | 3143 | rtx_mapping[associated_payload_type] = payload_type; |
| 3144 | break; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 3145 | } |
| 3146 | |
Steve Anton | 2d2bbb1 | 2019-08-07 09:57:59 -0700 | [diff] [blame] | 3147 | case VideoCodec::CODEC_VIDEO: { |
| 3148 | video_codecs.emplace_back(); |
| 3149 | video_codecs.back().codec = in_codec; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 3150 | break; |
Steve Anton | 2d2bbb1 | 2019-08-07 09:57:59 -0700 | [diff] [blame] | 3151 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 3152 | } |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 3153 | } |
| 3154 | |
| 3155 | // One of these codecs should have been a video codec. Only having FEC |
| 3156 | // parameters into this code is a logic error. |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 3157 | RTC_DCHECK(!video_codecs.empty()); |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 3158 | |
Steve Anton | 2d2bbb1 | 2019-08-07 09:57:59 -0700 | [diff] [blame] | 3159 | for (const auto& entry : rtx_mapping) { |
| 3160 | const int associated_payload_type = entry.first; |
| 3161 | const int rtx_payload_type = entry.second; |
| 3162 | auto it = payload_codec_type.find(associated_payload_type); |
| 3163 | if (it == payload_codec_type.end()) { |
| 3164 | RTC_LOG(LS_ERROR) << "RTX codec (PT=" << rtx_payload_type |
| 3165 | << ") mapped to PT=" << associated_payload_type |
| 3166 | << " which is not in the codec list."; |
| 3167 | return {}; |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 3168 | } |
Steve Anton | 2d2bbb1 | 2019-08-07 09:57:59 -0700 | [diff] [blame] | 3169 | const VideoCodec::CodecType associated_codec_type = it->second; |
| 3170 | if (associated_codec_type != VideoCodec::CODEC_VIDEO && |
| 3171 | associated_codec_type != VideoCodec::CODEC_RED) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 3172 | RTC_LOG(LS_ERROR) |
Steve Anton | 2d2bbb1 | 2019-08-07 09:57:59 -0700 | [diff] [blame] | 3173 | << "RTX PT=" << rtx_payload_type |
| 3174 | << " not mapped to regular video codec or RED codec (PT=" |
| 3175 | << associated_payload_type << ")."; |
| 3176 | return {}; |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 3177 | } |
Shao Changbin | e62202f | 2015-04-21 20:24:50 +0800 | [diff] [blame] | 3178 | |
Steve Anton | 2d2bbb1 | 2019-08-07 09:57:59 -0700 | [diff] [blame] | 3179 | if (associated_payload_type == ulpfec_config.red_payload_type) { |
| 3180 | ulpfec_config.red_rtx_payload_type = rtx_payload_type; |
Shao Changbin | e62202f | 2015-04-21 20:24:50 +0800 | [diff] [blame] | 3181 | } |
pbos@webrtc.org | e322a17 | 2014-06-13 11:47:28 +0000 | [diff] [blame] | 3182 | } |
| 3183 | |
Steve Anton | 2d2bbb1 | 2019-08-07 09:57:59 -0700 | [diff] [blame] | 3184 | for (VideoCodecSettings& codec_settings : video_codecs) { |
| 3185 | const int payload_type = codec_settings.codec.id; |
| 3186 | codec_settings.ulpfec = ulpfec_config; |
| 3187 | codec_settings.flexfec_payload_type = flexfec_payload_type.value_or(-1); |
| 3188 | auto it = rtx_mapping.find(payload_type); |
| 3189 | if (it != rtx_mapping.end()) { |
| 3190 | const int rtx_payload_type = it->second; |
| 3191 | codec_settings.rtx_payload_type = rtx_payload_type; |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 3192 | } |
| 3193 | } |
| 3194 | |
| 3195 | return video_codecs; |
| 3196 | } |
| 3197 | |
Markus Handell | 32565f6 | 2019-12-04 10:58:17 +0100 | [diff] [blame] | 3198 | WebRtcVideoChannel::WebRtcVideoReceiveStream* |
| 3199 | WebRtcVideoChannel::FindReceiveStream(uint32_t ssrc) { |
| 3200 | if (ssrc == 0) { |
| 3201 | absl::optional<uint32_t> default_ssrc = GetDefaultReceiveStreamSsrc(); |
| 3202 | if (!default_ssrc) { |
| 3203 | return nullptr; |
| 3204 | } |
| 3205 | ssrc = *default_ssrc; |
| 3206 | } |
| 3207 | auto it = receive_streams_.find(ssrc); |
| 3208 | if (it != receive_streams_.end()) { |
| 3209 | return it->second; |
| 3210 | } |
| 3211 | return nullptr; |
| 3212 | } |
| 3213 | |
| 3214 | void WebRtcVideoChannel::SetRecordableEncodedFrameCallback( |
| 3215 | uint32_t ssrc, |
| 3216 | std::function<void(const webrtc::RecordableEncodedFrame&)> callback) { |
| 3217 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 3218 | WebRtcVideoReceiveStream* stream = FindReceiveStream(ssrc); |
| 3219 | if (stream) { |
| 3220 | stream->SetRecordableEncodedFrameCallback(std::move(callback)); |
| 3221 | } else { |
| 3222 | RTC_LOG(LS_ERROR) << "Absent receive stream; ignoring setting encoded " |
| 3223 | "frame sink for ssrc " |
| 3224 | << ssrc; |
| 3225 | } |
| 3226 | } |
| 3227 | |
| 3228 | void WebRtcVideoChannel::ClearRecordableEncodedFrameCallback(uint32_t ssrc) { |
| 3229 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 3230 | WebRtcVideoReceiveStream* stream = FindReceiveStream(ssrc); |
| 3231 | if (stream) { |
| 3232 | stream->ClearRecordableEncodedFrameCallback(); |
| 3233 | } else { |
| 3234 | RTC_LOG(LS_ERROR) << "Absent receive stream; ignoring clearing encoded " |
| 3235 | "frame sink for ssrc " |
| 3236 | << ssrc; |
| 3237 | } |
| 3238 | } |
| 3239 | |
| 3240 | void WebRtcVideoChannel::GenerateKeyFrame(uint32_t ssrc) { |
| 3241 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 3242 | WebRtcVideoReceiveStream* stream = FindReceiveStream(ssrc); |
| 3243 | if (stream) { |
| 3244 | stream->GenerateKeyFrame(); |
| 3245 | } else { |
| 3246 | RTC_LOG(LS_ERROR) |
| 3247 | << "Absent receive stream; ignoring key frame generation for ssrc " |
| 3248 | << ssrc; |
| 3249 | } |
| 3250 | } |
| 3251 | |
Marina Ciocea | e77912b | 2020-02-27 16:16:55 +0100 | [diff] [blame] | 3252 | void WebRtcVideoChannel::SetEncoderToPacketizerFrameTransformer( |
| 3253 | uint32_t ssrc, |
| 3254 | rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer) { |
| 3255 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 3256 | auto matching_stream = send_streams_.find(ssrc); |
| 3257 | if (matching_stream != send_streams_.end()) { |
| 3258 | matching_stream->second->SetEncoderToPacketizerFrameTransformer( |
| 3259 | std::move(frame_transformer)); |
| 3260 | } |
| 3261 | } |
| 3262 | |
Marina Ciocea | 412a31b | 2020-02-28 16:02:06 +0100 | [diff] [blame] | 3263 | void WebRtcVideoChannel::SetDepacketizerToDecoderFrameTransformer( |
| 3264 | uint32_t ssrc, |
| 3265 | rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer) { |
| 3266 | RTC_DCHECK_RUN_ON(&thread_checker_); |
| 3267 | auto matching_stream = receive_streams_.find(ssrc); |
| 3268 | if (matching_stream != receive_streams_.end()) { |
| 3269 | matching_stream->second->SetDepacketizerToDecoderFrameTransformer( |
| 3270 | std::move(frame_transformer)); |
| 3271 | } |
| 3272 | } |
| 3273 | |
Åsa Persson | 8c1bf95 | 2018-09-13 10:42:19 +0200 | [diff] [blame] | 3274 | // TODO(bugs.webrtc.org/8785): Consider removing max_qp as member of |
| 3275 | // EncoderStreamFactory and instead set this value individually for each stream |
| 3276 | // in the VideoEncoderConfig.simulcast_layers. |
Florent Castelli | 66b3860 | 2019-07-10 16:57:57 +0200 | [diff] [blame] | 3277 | EncoderStreamFactory::EncoderStreamFactory(std::string codec_name, |
| 3278 | int max_qp, |
| 3279 | bool is_screenshare, |
| 3280 | bool conference_mode) |
Seth Hampson | 1370e30 | 2018-02-07 08:50:36 -0800 | [diff] [blame] | 3281 | |
ilnik | 6b826ef | 2017-06-16 06:53:48 -0700 | [diff] [blame] | 3282 | : codec_name_(codec_name), |
| 3283 | max_qp_(max_qp), |
Seth Hampson | 1370e30 | 2018-02-07 08:50:36 -0800 | [diff] [blame] | 3284 | is_screenshare_(is_screenshare), |
Florent Castelli | 66b3860 | 2019-07-10 16:57:57 +0200 | [diff] [blame] | 3285 | conference_mode_(conference_mode) {} |
ilnik | 6b826ef | 2017-06-16 06:53:48 -0700 | [diff] [blame] | 3286 | |
| 3287 | std::vector<webrtc::VideoStream> EncoderStreamFactory::CreateEncoderStreams( |
| 3288 | int width, |
| 3289 | int height, |
| 3290 | const webrtc::VideoEncoderConfig& encoder_config) { |
Åsa Persson | bdee46d | 2018-06-25 11:28:06 +0200 | [diff] [blame] | 3291 | RTC_DCHECK_GT(encoder_config.number_of_streams, 0); |
Sergey Silkin | 8b9b5f9 | 2018-12-10 09:28:53 +0100 | [diff] [blame] | 3292 | RTC_DCHECK_GE(encoder_config.simulcast_layers.size(), |
Seth Hampson | 8234ead | 2018-02-02 15:16:24 -0800 | [diff] [blame] | 3293 | encoder_config.number_of_streams); |
Seth Hampson | 8234ead | 2018-02-02 15:16:24 -0800 | [diff] [blame] | 3294 | |
Elad Alon | 80f53b7 | 2019-10-11 16:19:43 +0200 | [diff] [blame] | 3295 | const absl::optional<webrtc::DataRate> experimental_min_bitrate = |
| 3296 | GetExperimentalMinVideoBitrate(encoder_config.codec_type); |
| 3297 | |
ilnik | 6b826ef | 2017-06-16 06:53:48 -0700 | [diff] [blame] | 3298 | if (encoder_config.number_of_streams > 1 || |
Niels Möller | 039743e | 2018-10-23 10:07:25 +0200 | [diff] [blame] | 3299 | ((absl::EqualsIgnoreCase(codec_name_, kVp8CodecName) || |
| 3300 | absl::EqualsIgnoreCase(codec_name_, kH264CodecName)) && |
Florent Castelli | 66b3860 | 2019-07-10 16:57:57 +0200 | [diff] [blame] | 3301 | is_screenshare_ && conference_mode_)) { |
Rasmus Brandt | 1acdc74 | 2020-01-21 14:50:54 +0100 | [diff] [blame] | 3302 | return CreateSimulcastOrConfereceModeScreenshareStreams( |
| 3303 | width, height, encoder_config, experimental_min_bitrate); |
ilnik | 6b826ef | 2017-06-16 06:53:48 -0700 | [diff] [blame] | 3304 | } |
| 3305 | |
Rasmus Brandt | 1acdc74 | 2020-01-21 14:50:54 +0100 | [diff] [blame] | 3306 | return CreateDefaultVideoStreams(width, height, encoder_config, |
| 3307 | experimental_min_bitrate); |
| 3308 | } |
| 3309 | |
| 3310 | std::vector<webrtc::VideoStream> |
| 3311 | EncoderStreamFactory::CreateDefaultVideoStreams( |
| 3312 | int width, |
| 3313 | int height, |
| 3314 | const webrtc::VideoEncoderConfig& encoder_config, |
| 3315 | const absl::optional<webrtc::DataRate>& experimental_min_bitrate) const { |
| 3316 | std::vector<webrtc::VideoStream> layers; |
| 3317 | |
ilnik | 6b826ef | 2017-06-16 06:53:48 -0700 | [diff] [blame] | 3318 | // For unset max bitrates set default bitrate for non-simulcast. |
| 3319 | int max_bitrate_bps = |
| 3320 | (encoder_config.max_bitrate_bps > 0) |
| 3321 | ? encoder_config.max_bitrate_bps |
Ilya Nikolaevskiy | 3a656d1 | 2019-02-14 14:44:22 +0100 | [diff] [blame] | 3322 | : GetMaxDefaultVideoBitrateKbps(width, height, is_screenshare_) * |
| 3323 | 1000; |
ilnik | 6b826ef | 2017-06-16 06:53:48 -0700 | [diff] [blame] | 3324 | |
Elad Alon | 80f53b7 | 2019-10-11 16:19:43 +0200 | [diff] [blame] | 3325 | int min_bitrate_bps = |
| 3326 | experimental_min_bitrate |
| 3327 | ? rtc::saturated_cast<int>(experimental_min_bitrate->bps()) |
| 3328 | : webrtc::kDefaultMinVideoBitrateBps; |
Åsa Persson | bdee46d | 2018-06-25 11:28:06 +0200 | [diff] [blame] | 3329 | if (encoder_config.simulcast_layers[0].min_bitrate_bps > 0) { |
| 3330 | // Use set min bitrate. |
| 3331 | min_bitrate_bps = encoder_config.simulcast_layers[0].min_bitrate_bps; |
| 3332 | // If only min bitrate is configured, make sure max is above min. |
| 3333 | if (encoder_config.max_bitrate_bps <= 0) |
| 3334 | max_bitrate_bps = std::max(min_bitrate_bps, max_bitrate_bps); |
| 3335 | } |
Åsa Persson | 8c1bf95 | 2018-09-13 10:42:19 +0200 | [diff] [blame] | 3336 | int max_framerate = (encoder_config.simulcast_layers[0].max_framerate > 0) |
| 3337 | ? encoder_config.simulcast_layers[0].max_framerate |
| 3338 | : kDefaultVideoMaxFramerate; |
Åsa Persson | bdee46d | 2018-06-25 11:28:06 +0200 | [diff] [blame] | 3339 | |
Seth Hampson | 8234ead | 2018-02-02 15:16:24 -0800 | [diff] [blame] | 3340 | webrtc::VideoStream layer; |
| 3341 | layer.width = width; |
| 3342 | layer.height = height; |
Åsa Persson | 8c1bf95 | 2018-09-13 10:42:19 +0200 | [diff] [blame] | 3343 | layer.max_framerate = max_framerate; |
Åsa Persson | bdee46d | 2018-06-25 11:28:06 +0200 | [diff] [blame] | 3344 | |
Florent Castelli | c1a0bcb | 2019-01-29 14:26:48 +0100 | [diff] [blame] | 3345 | if (encoder_config.simulcast_layers[0].scale_resolution_down_by > 1.) { |
| 3346 | layer.width = std::max<size_t>( |
| 3347 | layer.width / |
| 3348 | encoder_config.simulcast_layers[0].scale_resolution_down_by, |
| 3349 | kMinLayerSize); |
| 3350 | layer.height = std::max<size_t>( |
| 3351 | layer.height / |
| 3352 | encoder_config.simulcast_layers[0].scale_resolution_down_by, |
| 3353 | kMinLayerSize); |
| 3354 | } |
| 3355 | |
Åsa Persson | bdee46d | 2018-06-25 11:28:06 +0200 | [diff] [blame] | 3356 | // In the case that the application sets a max bitrate that's lower than the |
| 3357 | // min bitrate, we adjust it down (see bugs.webrtc.org/9141). |
| 3358 | layer.min_bitrate_bps = std::min(min_bitrate_bps, max_bitrate_bps); |
Ilya Nikolaevskiy | 6957abe | 2019-01-29 16:33:04 +0100 | [diff] [blame] | 3359 | if (encoder_config.simulcast_layers[0].target_bitrate_bps <= 0) { |
| 3360 | layer.target_bitrate_bps = max_bitrate_bps; |
| 3361 | } else { |
| 3362 | layer.target_bitrate_bps = |
| 3363 | encoder_config.simulcast_layers[0].target_bitrate_bps; |
| 3364 | } |
| 3365 | layer.max_bitrate_bps = max_bitrate_bps; |
Seth Hampson | 8234ead | 2018-02-02 15:16:24 -0800 | [diff] [blame] | 3366 | layer.max_qp = max_qp_; |
| 3367 | layer.bitrate_priority = encoder_config.bitrate_priority; |
ilnik | 6b826ef | 2017-06-16 06:53:48 -0700 | [diff] [blame] | 3368 | |
Niels Möller | 039743e | 2018-10-23 10:07:25 +0200 | [diff] [blame] | 3369 | if (absl::EqualsIgnoreCase(codec_name_, kVp9CodecName)) { |
Sergey Silkin | a796a7e | 2018-03-01 15:11:29 +0100 | [diff] [blame] | 3370 | RTC_DCHECK(encoder_config.encoder_specific_settings); |
| 3371 | // Use VP9 SVC layering from codec settings which might be initialized |
| 3372 | // though field trial in ConfigureVideoEncoderSettings. |
| 3373 | webrtc::VideoCodecVP9 vp9_settings; |
| 3374 | encoder_config.encoder_specific_settings->FillVideoCodecVp9(&vp9_settings); |
| 3375 | layer.num_temporal_layers = vp9_settings.numberOfTemporalLayers; |
ilnik | 6b826ef | 2017-06-16 06:53:48 -0700 | [diff] [blame] | 3376 | } |
| 3377 | |
Ilya Nikolaevskiy | 9f6a0d5 | 2019-02-05 10:29:41 +0100 | [diff] [blame] | 3378 | if (IsTemporalLayersSupported(codec_name_)) { |
Åsa Persson | 23eba22 | 2018-10-02 14:47:06 +0200 | [diff] [blame] | 3379 | // Use configured number of temporal layers if set. |
| 3380 | if (encoder_config.simulcast_layers[0].num_temporal_layers) { |
| 3381 | layer.num_temporal_layers = |
| 3382 | *encoder_config.simulcast_layers[0].num_temporal_layers; |
| 3383 | } |
| 3384 | } |
| 3385 | |
Seth Hampson | 8234ead | 2018-02-02 15:16:24 -0800 | [diff] [blame] | 3386 | layers.push_back(layer); |
| 3387 | return layers; |
ilnik | 6b826ef | 2017-06-16 06:53:48 -0700 | [diff] [blame] | 3388 | } |
| 3389 | |
Rasmus Brandt | 1acdc74 | 2020-01-21 14:50:54 +0100 | [diff] [blame] | 3390 | std::vector<webrtc::VideoStream> |
| 3391 | EncoderStreamFactory::CreateSimulcastOrConfereceModeScreenshareStreams( |
| 3392 | int width, |
| 3393 | int height, |
| 3394 | const webrtc::VideoEncoderConfig& encoder_config, |
| 3395 | const absl::optional<webrtc::DataRate>& experimental_min_bitrate) const { |
| 3396 | std::vector<webrtc::VideoStream> layers; |
| 3397 | |
| 3398 | const bool temporal_layers_supported = |
| 3399 | absl::EqualsIgnoreCase(codec_name_, kVp8CodecName) || |
| 3400 | absl::EqualsIgnoreCase(codec_name_, kH264CodecName); |
| 3401 | // Use legacy simulcast screenshare if conference mode is explicitly enabled |
| 3402 | // or use the regular simulcast configuration path which is generic. |
Ilya Nikolaevskiy | 03d9096 | 2020-02-11 12:50:38 +0100 | [diff] [blame] | 3403 | layers = GetSimulcastConfig(FindRequiredActiveLayers(encoder_config), |
| 3404 | encoder_config.number_of_streams, width, height, |
Rasmus Brandt | 1acdc74 | 2020-01-21 14:50:54 +0100 | [diff] [blame] | 3405 | encoder_config.bitrate_priority, max_qp_, |
| 3406 | is_screenshare_ && conference_mode_, |
| 3407 | temporal_layers_supported); |
| 3408 | // Allow an experiment to override the minimum bitrate for the lowest |
| 3409 | // spatial layer. The experiment's configuration has the lowest priority. |
| 3410 | if (experimental_min_bitrate) { |
| 3411 | layers[0].min_bitrate_bps = |
| 3412 | rtc::saturated_cast<int>(experimental_min_bitrate->bps()); |
| 3413 | } |
| 3414 | // Update the active simulcast layers and configured bitrates. |
| 3415 | bool is_highest_layer_max_bitrate_configured = false; |
| 3416 | const bool has_scale_resolution_down_by = absl::c_any_of( |
| 3417 | encoder_config.simulcast_layers, [](const webrtc::VideoStream& layer) { |
| 3418 | return layer.scale_resolution_down_by != -1.; |
| 3419 | }); |
| 3420 | const int normalized_width = |
| 3421 | NormalizeSimulcastSize(width, encoder_config.number_of_streams); |
| 3422 | const int normalized_height = |
| 3423 | NormalizeSimulcastSize(height, encoder_config.number_of_streams); |
| 3424 | for (size_t i = 0; i < layers.size(); ++i) { |
| 3425 | layers[i].active = encoder_config.simulcast_layers[i].active; |
| 3426 | // Update with configured num temporal layers if supported by codec. |
| 3427 | if (encoder_config.simulcast_layers[i].num_temporal_layers && |
| 3428 | IsTemporalLayersSupported(codec_name_)) { |
| 3429 | layers[i].num_temporal_layers = |
| 3430 | *encoder_config.simulcast_layers[i].num_temporal_layers; |
| 3431 | } |
| 3432 | if (encoder_config.simulcast_layers[i].max_framerate > 0) { |
| 3433 | layers[i].max_framerate = |
| 3434 | encoder_config.simulcast_layers[i].max_framerate; |
| 3435 | } |
| 3436 | if (has_scale_resolution_down_by) { |
| 3437 | const double scale_resolution_down_by = std::max( |
| 3438 | encoder_config.simulcast_layers[i].scale_resolution_down_by, 1.0); |
| 3439 | layers[i].width = std::max( |
| 3440 | static_cast<int>(normalized_width / scale_resolution_down_by), |
| 3441 | kMinLayerSize); |
| 3442 | layers[i].height = std::max( |
| 3443 | static_cast<int>(normalized_height / scale_resolution_down_by), |
| 3444 | kMinLayerSize); |
| 3445 | } |
| 3446 | // Update simulcast bitrates with configured min and max bitrate. |
| 3447 | if (encoder_config.simulcast_layers[i].min_bitrate_bps > 0) { |
| 3448 | layers[i].min_bitrate_bps = |
| 3449 | encoder_config.simulcast_layers[i].min_bitrate_bps; |
| 3450 | } |
| 3451 | if (encoder_config.simulcast_layers[i].max_bitrate_bps > 0) { |
| 3452 | layers[i].max_bitrate_bps = |
| 3453 | encoder_config.simulcast_layers[i].max_bitrate_bps; |
| 3454 | } |
| 3455 | if (encoder_config.simulcast_layers[i].target_bitrate_bps > 0) { |
| 3456 | layers[i].target_bitrate_bps = |
| 3457 | encoder_config.simulcast_layers[i].target_bitrate_bps; |
| 3458 | } |
| 3459 | if (encoder_config.simulcast_layers[i].min_bitrate_bps > 0 && |
| 3460 | encoder_config.simulcast_layers[i].max_bitrate_bps > 0) { |
| 3461 | // Min and max bitrate are configured. |
| 3462 | // Set target to 3/4 of the max bitrate (or to max if below min). |
| 3463 | if (encoder_config.simulcast_layers[i].target_bitrate_bps <= 0) |
| 3464 | layers[i].target_bitrate_bps = layers[i].max_bitrate_bps * 3 / 4; |
| 3465 | if (layers[i].target_bitrate_bps < layers[i].min_bitrate_bps) |
| 3466 | layers[i].target_bitrate_bps = layers[i].max_bitrate_bps; |
| 3467 | } else if (encoder_config.simulcast_layers[i].min_bitrate_bps > 0) { |
| 3468 | // Only min bitrate is configured, make sure target/max are above min. |
| 3469 | layers[i].target_bitrate_bps = |
| 3470 | std::max(layers[i].target_bitrate_bps, layers[i].min_bitrate_bps); |
| 3471 | layers[i].max_bitrate_bps = |
| 3472 | std::max(layers[i].max_bitrate_bps, layers[i].min_bitrate_bps); |
| 3473 | } else if (encoder_config.simulcast_layers[i].max_bitrate_bps > 0) { |
| 3474 | // Only max bitrate is configured, make sure min/target are below max. |
| 3475 | layers[i].min_bitrate_bps = |
| 3476 | std::min(layers[i].min_bitrate_bps, layers[i].max_bitrate_bps); |
| 3477 | layers[i].target_bitrate_bps = |
| 3478 | std::min(layers[i].target_bitrate_bps, layers[i].max_bitrate_bps); |
| 3479 | } |
| 3480 | if (i == layers.size() - 1) { |
| 3481 | is_highest_layer_max_bitrate_configured = |
| 3482 | encoder_config.simulcast_layers[i].max_bitrate_bps > 0; |
| 3483 | } |
| 3484 | } |
Oskar Segersvärd | dc81e11 | 2020-02-12 16:45:53 +0100 | [diff] [blame] | 3485 | if (!is_screenshare_ && !is_highest_layer_max_bitrate_configured && |
| 3486 | encoder_config.max_bitrate_bps > 0) { |
Rasmus Brandt | 1acdc74 | 2020-01-21 14:50:54 +0100 | [diff] [blame] | 3487 | // No application-configured maximum for the largest layer. |
| 3488 | // If there is bitrate leftover, give it to the largest layer. |
Oskar Segersvärd | dc81e11 | 2020-02-12 16:45:53 +0100 | [diff] [blame] | 3489 | BoostMaxSimulcastLayer( |
Danil Chapovalov | cad3e0e | 2020-02-17 18:46:07 +0100 | [diff] [blame] | 3490 | webrtc::DataRate::BitsPerSec(encoder_config.max_bitrate_bps), &layers); |
Rasmus Brandt | 1acdc74 | 2020-01-21 14:50:54 +0100 | [diff] [blame] | 3491 | } |
| 3492 | return layers; |
| 3493 | } |
| 3494 | |
pbos@webrtc.org | b5a22b1 | 2014-05-13 11:07:01 +0000 | [diff] [blame] | 3495 | } // namespace cricket |