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