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