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