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