OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 4 * Use of this source code is governed by a BSD-style license |
5 * that can be found in the LICENSE file in the root of the source | 5 * that can be found in the LICENSE file in the root of the source |
6 * tree. An additional intellectual property rights grant can be found | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 #include "webrtc/media/engine/webrtcvideoengine2.h" | 11 #include "webrtc/media/engine/webrtcvideoengine.h" |
12 | 12 |
13 #include <stdio.h> | 13 #include <stdio.h> |
14 #include <algorithm> | 14 #include <algorithm> |
15 #include <set> | 15 #include <set> |
16 #include <string> | 16 #include <string> |
17 #include <utility> | 17 #include <utility> |
18 | 18 |
19 #include "webrtc/api/video/i420_buffer.h" | 19 #include "webrtc/api/video/i420_buffer.h" |
20 #include "webrtc/api/video_codecs/video_decoder.h" | 20 #include "webrtc/api/video_codecs/video_decoder.h" |
21 #include "webrtc/api/video_codecs/video_encoder.h" | 21 #include "webrtc/api/video_codecs/video_encoder.h" |
(...skipping 344 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
366 | 366 |
367 static const int kDefaultRtcpReceiverReportSsrc = 1; | 367 static const int kDefaultRtcpReceiverReportSsrc = 1; |
368 | 368 |
369 // Minimum time interval for logging stats. | 369 // Minimum time interval for logging stats. |
370 static const int64_t kStatsLogIntervalMs = 10000; | 370 static const int64_t kStatsLogIntervalMs = 10000; |
371 | 371 |
372 static std::vector<VideoCodec> GetSupportedCodecs( | 372 static std::vector<VideoCodec> GetSupportedCodecs( |
373 const WebRtcVideoEncoderFactory* external_encoder_factory); | 373 const WebRtcVideoEncoderFactory* external_encoder_factory); |
374 | 374 |
375 rtc::scoped_refptr<webrtc::VideoEncoderConfig::EncoderSpecificSettings> | 375 rtc::scoped_refptr<webrtc::VideoEncoderConfig::EncoderSpecificSettings> |
376 WebRtcVideoChannel2::WebRtcVideoSendStream::ConfigureVideoEncoderSettings( | 376 WebRtcVideoChannel::WebRtcVideoSendStream::ConfigureVideoEncoderSettings( |
377 const VideoCodec& codec) { | 377 const VideoCodec& codec) { |
378 RTC_DCHECK_RUN_ON(&thread_checker_); | 378 RTC_DCHECK_RUN_ON(&thread_checker_); |
379 bool is_screencast = parameters_.options.is_screencast.value_or(false); | 379 bool is_screencast = parameters_.options.is_screencast.value_or(false); |
380 // No automatic resizing when using simulcast or screencast. | 380 // No automatic resizing when using simulcast or screencast. |
381 bool automatic_resize = | 381 bool automatic_resize = |
382 !is_screencast && parameters_.config.rtp.ssrcs.size() == 1; | 382 !is_screencast && parameters_.config.rtp.ssrcs.size() == 1; |
383 bool frame_dropping = !is_screencast; | 383 bool frame_dropping = !is_screencast; |
384 bool denoising; | 384 bool denoising; |
385 bool codec_default_denoising = false; | 385 bool codec_default_denoising = false; |
386 if (is_screencast) { | 386 if (is_screencast) { |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
425 return new rtc::RefCountedObject< | 425 return new rtc::RefCountedObject< |
426 webrtc::VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings); | 426 webrtc::VideoEncoderConfig::Vp9EncoderSpecificSettings>(vp9_settings); |
427 } | 427 } |
428 return nullptr; | 428 return nullptr; |
429 } | 429 } |
430 | 430 |
431 DefaultUnsignalledSsrcHandler::DefaultUnsignalledSsrcHandler() | 431 DefaultUnsignalledSsrcHandler::DefaultUnsignalledSsrcHandler() |
432 : default_sink_(nullptr) {} | 432 : default_sink_(nullptr) {} |
433 | 433 |
434 UnsignalledSsrcHandler::Action DefaultUnsignalledSsrcHandler::OnUnsignalledSsrc( | 434 UnsignalledSsrcHandler::Action DefaultUnsignalledSsrcHandler::OnUnsignalledSsrc( |
435 WebRtcVideoChannel2* channel, | 435 WebRtcVideoChannel* channel, |
436 uint32_t ssrc) { | 436 uint32_t ssrc) { |
437 rtc::Optional<uint32_t> default_recv_ssrc = | 437 rtc::Optional<uint32_t> default_recv_ssrc = |
438 channel->GetDefaultReceiveStreamSsrc(); | 438 channel->GetDefaultReceiveStreamSsrc(); |
439 | 439 |
440 if (default_recv_ssrc) { | 440 if (default_recv_ssrc) { |
441 LOG(LS_INFO) << "Destroying old default receive stream for SSRC=" << ssrc | 441 LOG(LS_INFO) << "Destroying old default receive stream for SSRC=" << ssrc |
442 << "."; | 442 << "."; |
443 channel->RemoveRecvStream(*default_recv_ssrc); | 443 channel->RemoveRecvStream(*default_recv_ssrc); |
444 } | 444 } |
445 | 445 |
446 StreamParams sp; | 446 StreamParams sp; |
447 sp.ssrcs.push_back(ssrc); | 447 sp.ssrcs.push_back(ssrc); |
448 LOG(LS_INFO) << "Creating default receive stream for SSRC=" << ssrc << "."; | 448 LOG(LS_INFO) << "Creating default receive stream for SSRC=" << ssrc << "."; |
449 if (!channel->AddRecvStream(sp, true)) { | 449 if (!channel->AddRecvStream(sp, true)) { |
450 LOG(LS_WARNING) << "Could not create default receive stream."; | 450 LOG(LS_WARNING) << "Could not create default receive stream."; |
451 } | 451 } |
452 | 452 |
453 channel->SetSink(ssrc, default_sink_); | 453 channel->SetSink(ssrc, default_sink_); |
454 return kDeliverPacket; | 454 return kDeliverPacket; |
455 } | 455 } |
456 | 456 |
457 rtc::VideoSinkInterface<webrtc::VideoFrame>* | 457 rtc::VideoSinkInterface<webrtc::VideoFrame>* |
458 DefaultUnsignalledSsrcHandler::GetDefaultSink() const { | 458 DefaultUnsignalledSsrcHandler::GetDefaultSink() const { |
459 return default_sink_; | 459 return default_sink_; |
460 } | 460 } |
461 | 461 |
462 void DefaultUnsignalledSsrcHandler::SetDefaultSink( | 462 void DefaultUnsignalledSsrcHandler::SetDefaultSink( |
463 WebRtcVideoChannel2* channel, | 463 WebRtcVideoChannel* channel, |
464 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) { | 464 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) { |
465 default_sink_ = sink; | 465 default_sink_ = sink; |
466 rtc::Optional<uint32_t> default_recv_ssrc = | 466 rtc::Optional<uint32_t> default_recv_ssrc = |
467 channel->GetDefaultReceiveStreamSsrc(); | 467 channel->GetDefaultReceiveStreamSsrc(); |
468 if (default_recv_ssrc) { | 468 if (default_recv_ssrc) { |
469 channel->SetSink(*default_recv_ssrc, default_sink_); | 469 channel->SetSink(*default_recv_ssrc, default_sink_); |
470 } | 470 } |
471 } | 471 } |
472 | 472 |
473 WebRtcVideoEngine2::WebRtcVideoEngine2() | 473 WebRtcVideoEngine::WebRtcVideoEngine() |
474 : initialized_(false), | 474 : initialized_(false), |
475 external_decoder_factory_(NULL), | 475 external_decoder_factory_(NULL), |
476 external_encoder_factory_(NULL) { | 476 external_encoder_factory_(NULL) { |
477 LOG(LS_INFO) << "WebRtcVideoEngine2::WebRtcVideoEngine2()"; | 477 LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine()"; |
478 } | 478 } |
479 | 479 |
480 WebRtcVideoEngine2::~WebRtcVideoEngine2() { | 480 WebRtcVideoEngine::~WebRtcVideoEngine() { |
481 LOG(LS_INFO) << "WebRtcVideoEngine2::~WebRtcVideoEngine2"; | 481 LOG(LS_INFO) << "WebRtcVideoEngine::~WebRtcVideoEngine"; |
482 } | 482 } |
483 | 483 |
484 void WebRtcVideoEngine2::Init() { | 484 void WebRtcVideoEngine::Init() { |
485 LOG(LS_INFO) << "WebRtcVideoEngine2::Init"; | 485 LOG(LS_INFO) << "WebRtcVideoEngine::Init"; |
486 initialized_ = true; | 486 initialized_ = true; |
487 } | 487 } |
488 | 488 |
489 WebRtcVideoChannel2* WebRtcVideoEngine2::CreateChannel( | 489 WebRtcVideoChannel* WebRtcVideoEngine::CreateChannel( |
490 webrtc::Call* call, | 490 webrtc::Call* call, |
491 const MediaConfig& config, | 491 const MediaConfig& config, |
492 const VideoOptions& options) { | 492 const VideoOptions& options) { |
493 RTC_DCHECK(initialized_); | 493 RTC_DCHECK(initialized_); |
494 LOG(LS_INFO) << "CreateChannel. Options: " << options.ToString(); | 494 LOG(LS_INFO) << "CreateChannel. Options: " << options.ToString(); |
495 return new WebRtcVideoChannel2(call, config, options, | 495 return new WebRtcVideoChannel(call, config, options, |
496 external_encoder_factory_, | 496 external_encoder_factory_, |
497 external_decoder_factory_); | 497 external_decoder_factory_); |
498 } | 498 } |
499 | 499 |
500 std::vector<VideoCodec> WebRtcVideoEngine2::codecs() const { | 500 std::vector<VideoCodec> WebRtcVideoEngine::codecs() const { |
501 return GetSupportedCodecs(external_encoder_factory_); | 501 return GetSupportedCodecs(external_encoder_factory_); |
502 } | 502 } |
503 | 503 |
504 RtpCapabilities WebRtcVideoEngine2::GetCapabilities() const { | 504 RtpCapabilities WebRtcVideoEngine::GetCapabilities() const { |
505 RtpCapabilities capabilities; | 505 RtpCapabilities capabilities; |
506 capabilities.header_extensions.push_back( | 506 capabilities.header_extensions.push_back( |
507 webrtc::RtpExtension(webrtc::RtpExtension::kTimestampOffsetUri, | 507 webrtc::RtpExtension(webrtc::RtpExtension::kTimestampOffsetUri, |
508 webrtc::RtpExtension::kTimestampOffsetDefaultId)); | 508 webrtc::RtpExtension::kTimestampOffsetDefaultId)); |
509 capabilities.header_extensions.push_back( | 509 capabilities.header_extensions.push_back( |
510 webrtc::RtpExtension(webrtc::RtpExtension::kAbsSendTimeUri, | 510 webrtc::RtpExtension(webrtc::RtpExtension::kAbsSendTimeUri, |
511 webrtc::RtpExtension::kAbsSendTimeDefaultId)); | 511 webrtc::RtpExtension::kAbsSendTimeDefaultId)); |
512 capabilities.header_extensions.push_back( | 512 capabilities.header_extensions.push_back( |
513 webrtc::RtpExtension(webrtc::RtpExtension::kVideoRotationUri, | 513 webrtc::RtpExtension(webrtc::RtpExtension::kVideoRotationUri, |
514 webrtc::RtpExtension::kVideoRotationDefaultId)); | 514 webrtc::RtpExtension::kVideoRotationDefaultId)); |
515 capabilities.header_extensions.push_back(webrtc::RtpExtension( | 515 capabilities.header_extensions.push_back(webrtc::RtpExtension( |
516 webrtc::RtpExtension::kTransportSequenceNumberUri, | 516 webrtc::RtpExtension::kTransportSequenceNumberUri, |
517 webrtc::RtpExtension::kTransportSequenceNumberDefaultId)); | 517 webrtc::RtpExtension::kTransportSequenceNumberDefaultId)); |
518 capabilities.header_extensions.push_back( | 518 capabilities.header_extensions.push_back( |
519 webrtc::RtpExtension(webrtc::RtpExtension::kPlayoutDelayUri, | 519 webrtc::RtpExtension(webrtc::RtpExtension::kPlayoutDelayUri, |
520 webrtc::RtpExtension::kPlayoutDelayDefaultId)); | 520 webrtc::RtpExtension::kPlayoutDelayDefaultId)); |
521 if (IsVideoContentTypeExtensionFieldTrialEnabled()) { | 521 if (IsVideoContentTypeExtensionFieldTrialEnabled()) { |
522 capabilities.header_extensions.push_back( | 522 capabilities.header_extensions.push_back( |
523 webrtc::RtpExtension(webrtc::RtpExtension::kVideoContentTypeUri, | 523 webrtc::RtpExtension(webrtc::RtpExtension::kVideoContentTypeUri, |
524 webrtc::RtpExtension::kVideoContentTypeDefaultId)); | 524 webrtc::RtpExtension::kVideoContentTypeDefaultId)); |
525 } | 525 } |
526 return capabilities; | 526 return capabilities; |
527 } | 527 } |
528 | 528 |
529 void WebRtcVideoEngine2::SetExternalDecoderFactory( | 529 void WebRtcVideoEngine::SetExternalDecoderFactory( |
530 WebRtcVideoDecoderFactory* decoder_factory) { | 530 WebRtcVideoDecoderFactory* decoder_factory) { |
531 RTC_DCHECK(!initialized_); | 531 RTC_DCHECK(!initialized_); |
532 external_decoder_factory_ = decoder_factory; | 532 external_decoder_factory_ = decoder_factory; |
533 } | 533 } |
534 | 534 |
535 void WebRtcVideoEngine2::SetExternalEncoderFactory( | 535 void WebRtcVideoEngine::SetExternalEncoderFactory( |
536 WebRtcVideoEncoderFactory* encoder_factory) { | 536 WebRtcVideoEncoderFactory* encoder_factory) { |
537 RTC_DCHECK(!initialized_); | 537 RTC_DCHECK(!initialized_); |
538 if (external_encoder_factory_ == encoder_factory) | 538 if (external_encoder_factory_ == encoder_factory) |
539 return; | 539 return; |
540 | 540 |
541 // No matter what happens we shouldn't hold on to a stale | 541 // No matter what happens we shouldn't hold on to a stale |
542 // WebRtcSimulcastEncoderFactory. | 542 // WebRtcSimulcastEncoderFactory. |
543 simulcast_encoder_factory_.reset(); | 543 simulcast_encoder_factory_.reset(); |
544 | 544 |
545 if (encoder_factory && | 545 if (encoder_factory && |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
629 const std::vector<VideoCodec>& external_codecs = | 629 const std::vector<VideoCodec>& external_codecs = |
630 external_encoder_factory->supported_codecs(); | 630 external_encoder_factory->supported_codecs(); |
631 AppendVideoCodecs(external_codecs, &unified_codecs); | 631 AppendVideoCodecs(external_codecs, &unified_codecs); |
632 LOG(LS_INFO) << "Codecs supported by the external encoder factory: " | 632 LOG(LS_INFO) << "Codecs supported by the external encoder factory: " |
633 << CodecVectorToString(external_codecs); | 633 << CodecVectorToString(external_codecs); |
634 } | 634 } |
635 | 635 |
636 return unified_codecs; | 636 return unified_codecs; |
637 } | 637 } |
638 | 638 |
639 WebRtcVideoChannel2::WebRtcVideoChannel2( | 639 WebRtcVideoChannel::WebRtcVideoChannel( |
640 webrtc::Call* call, | 640 webrtc::Call* call, |
641 const MediaConfig& config, | 641 const MediaConfig& config, |
642 const VideoOptions& options, | 642 const VideoOptions& options, |
643 WebRtcVideoEncoderFactory* external_encoder_factory, | 643 WebRtcVideoEncoderFactory* external_encoder_factory, |
644 WebRtcVideoDecoderFactory* external_decoder_factory) | 644 WebRtcVideoDecoderFactory* external_decoder_factory) |
645 : VideoMediaChannel(config), | 645 : VideoMediaChannel(config), |
646 call_(call), | 646 call_(call), |
647 unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_), | 647 unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_), |
648 video_config_(config.video), | 648 video_config_(config.video), |
649 external_encoder_factory_(external_encoder_factory), | 649 external_encoder_factory_(external_encoder_factory), |
650 external_decoder_factory_(external_decoder_factory), | 650 external_decoder_factory_(external_decoder_factory), |
651 default_send_options_(options), | 651 default_send_options_(options), |
652 last_stats_log_ms_(-1) { | 652 last_stats_log_ms_(-1) { |
653 RTC_DCHECK(thread_checker_.CalledOnValidThread()); | 653 RTC_DCHECK(thread_checker_.CalledOnValidThread()); |
654 | 654 |
655 rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc; | 655 rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc; |
656 sending_ = false; | 656 sending_ = false; |
657 recv_codecs_ = MapCodecs(GetSupportedCodecs(external_encoder_factory)); | 657 recv_codecs_ = MapCodecs(GetSupportedCodecs(external_encoder_factory)); |
658 recv_flexfec_payload_type_ = recv_codecs_.front().flexfec_payload_type; | 658 recv_flexfec_payload_type_ = recv_codecs_.front().flexfec_payload_type; |
659 } | 659 } |
660 | 660 |
661 WebRtcVideoChannel2::~WebRtcVideoChannel2() { | 661 WebRtcVideoChannel::~WebRtcVideoChannel() { |
662 for (auto& kv : send_streams_) | 662 for (auto& kv : send_streams_) |
663 delete kv.second; | 663 delete kv.second; |
664 for (auto& kv : receive_streams_) | 664 for (auto& kv : receive_streams_) |
665 delete kv.second; | 665 delete kv.second; |
666 } | 666 } |
667 | 667 |
668 rtc::Optional<WebRtcVideoChannel2::VideoCodecSettings> | 668 rtc::Optional<WebRtcVideoChannel::VideoCodecSettings> |
669 WebRtcVideoChannel2::SelectSendVideoCodec( | 669 WebRtcVideoChannel::SelectSendVideoCodec( |
670 const std::vector<VideoCodecSettings>& remote_mapped_codecs) const { | 670 const std::vector<VideoCodecSettings>& remote_mapped_codecs) const { |
671 const std::vector<VideoCodec> local_supported_codecs = | 671 const std::vector<VideoCodec> local_supported_codecs = |
672 GetSupportedCodecs(external_encoder_factory_); | 672 GetSupportedCodecs(external_encoder_factory_); |
673 // Select the first remote codec that is supported locally. | 673 // Select the first remote codec that is supported locally. |
674 for (const VideoCodecSettings& remote_mapped_codec : remote_mapped_codecs) { | 674 for (const VideoCodecSettings& remote_mapped_codec : remote_mapped_codecs) { |
675 // For H264, we will limit the encode level to the remote offered level | 675 // For H264, we will limit the encode level to the remote offered level |
676 // regardless if level asymmetry is allowed or not. This is strictly not | 676 // regardless if level asymmetry is allowed or not. This is strictly not |
677 // following the spec in https://tools.ietf.org/html/rfc6184#section-8.2.2 | 677 // following the spec in https://tools.ietf.org/html/rfc6184#section-8.2.2 |
678 // since we should limit the encode level to the lower of local and remote | 678 // since we should limit the encode level to the lower of local and remote |
679 // level when level asymmetry is not allowed. | 679 // level when level asymmetry is not allowed. |
680 if (FindMatchingCodec(local_supported_codecs, remote_mapped_codec.codec)) | 680 if (FindMatchingCodec(local_supported_codecs, remote_mapped_codec.codec)) |
681 return rtc::Optional<VideoCodecSettings>(remote_mapped_codec); | 681 return rtc::Optional<VideoCodecSettings>(remote_mapped_codec); |
682 } | 682 } |
683 // No remote codec was supported. | 683 // No remote codec was supported. |
684 return rtc::Optional<VideoCodecSettings>(); | 684 return rtc::Optional<VideoCodecSettings>(); |
685 } | 685 } |
686 | 686 |
687 bool WebRtcVideoChannel2::NonFlexfecReceiveCodecsHaveChanged( | 687 bool WebRtcVideoChannel::NonFlexfecReceiveCodecsHaveChanged( |
688 std::vector<VideoCodecSettings> before, | 688 std::vector<VideoCodecSettings> before, |
689 std::vector<VideoCodecSettings> after) { | 689 std::vector<VideoCodecSettings> after) { |
690 if (before.size() != after.size()) { | 690 if (before.size() != after.size()) { |
691 return true; | 691 return true; |
692 } | 692 } |
693 | 693 |
694 // The receive codec order doesn't matter, so we sort the codecs before | 694 // The receive codec order doesn't matter, so we sort the codecs before |
695 // comparing. This is necessary because currently the | 695 // comparing. This is necessary because currently the |
696 // only way to change the send codec is to munge SDP, which causes | 696 // only way to change the send codec is to munge SDP, which causes |
697 // the receive codec list to change order, which causes the streams | 697 // the receive codec list to change order, which causes the streams |
698 // to be recreates which causes a "blink" of black video. In order | 698 // to be recreates which causes a "blink" of black video. In order |
699 // to support munging the SDP in this way without recreating receive | 699 // to support munging the SDP in this way without recreating receive |
700 // streams, we ignore the order of the received codecs so that | 700 // streams, we ignore the order of the received codecs so that |
701 // changing the order doesn't cause this "blink". | 701 // changing the order doesn't cause this "blink". |
702 auto comparison = | 702 auto comparison = |
703 [](const VideoCodecSettings& codec1, const VideoCodecSettings& codec2) { | 703 [](const VideoCodecSettings& codec1, const VideoCodecSettings& codec2) { |
704 return codec1.codec.id > codec2.codec.id; | 704 return codec1.codec.id > codec2.codec.id; |
705 }; | 705 }; |
706 std::sort(before.begin(), before.end(), comparison); | 706 std::sort(before.begin(), before.end(), comparison); |
707 std::sort(after.begin(), after.end(), comparison); | 707 std::sort(after.begin(), after.end(), comparison); |
708 | 708 |
709 // Changes in FlexFEC payload type are handled separately in | 709 // Changes in FlexFEC payload type are handled separately in |
710 // WebRtcVideoChannel2::GetChangedRecvParameters, so disregard FlexFEC in the | 710 // WebRtcVideoChannel::GetChangedRecvParameters, so disregard FlexFEC in the |
711 // comparison here. | 711 // comparison here. |
712 return !std::equal(before.begin(), before.end(), after.begin(), | 712 return !std::equal(before.begin(), before.end(), after.begin(), |
713 VideoCodecSettings::EqualsDisregardingFlexfec); | 713 VideoCodecSettings::EqualsDisregardingFlexfec); |
714 } | 714 } |
715 | 715 |
716 bool WebRtcVideoChannel2::GetChangedSendParameters( | 716 bool WebRtcVideoChannel::GetChangedSendParameters( |
717 const VideoSendParameters& params, | 717 const VideoSendParameters& params, |
718 ChangedSendParameters* changed_params) const { | 718 ChangedSendParameters* changed_params) const { |
719 if (!ValidateCodecFormats(params.codecs) || | 719 if (!ValidateCodecFormats(params.codecs) || |
720 !ValidateRtpExtensions(params.extensions)) { | 720 !ValidateRtpExtensions(params.extensions)) { |
721 return false; | 721 return false; |
722 } | 722 } |
723 | 723 |
724 // Select one of the remote codecs that will be used as send codec. | 724 // Select one of the remote codecs that will be used as send codec. |
725 rtc::Optional<VideoCodecSettings> selected_send_codec = | 725 rtc::Optional<VideoCodecSettings> selected_send_codec = |
726 SelectSendVideoCodec(MapCodecs(params.codecs)); | 726 SelectSendVideoCodec(MapCodecs(params.codecs)); |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
769 // Handle RTCP mode. | 769 // Handle RTCP mode. |
770 if (params.rtcp.reduced_size != send_params_.rtcp.reduced_size) { | 770 if (params.rtcp.reduced_size != send_params_.rtcp.reduced_size) { |
771 changed_params->rtcp_mode = rtc::Optional<webrtc::RtcpMode>( | 771 changed_params->rtcp_mode = rtc::Optional<webrtc::RtcpMode>( |
772 params.rtcp.reduced_size ? webrtc::RtcpMode::kReducedSize | 772 params.rtcp.reduced_size ? webrtc::RtcpMode::kReducedSize |
773 : webrtc::RtcpMode::kCompound); | 773 : webrtc::RtcpMode::kCompound); |
774 } | 774 } |
775 | 775 |
776 return true; | 776 return true; |
777 } | 777 } |
778 | 778 |
779 rtc::DiffServCodePoint WebRtcVideoChannel2::PreferredDscp() const { | 779 rtc::DiffServCodePoint WebRtcVideoChannel::PreferredDscp() const { |
780 return rtc::DSCP_AF41; | 780 return rtc::DSCP_AF41; |
781 } | 781 } |
782 | 782 |
783 bool WebRtcVideoChannel2::SetSendParameters(const VideoSendParameters& params) { | 783 bool WebRtcVideoChannel::SetSendParameters(const VideoSendParameters& params) { |
784 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetSendParameters"); | 784 TRACE_EVENT0("webrtc", "WebRtcVideoChannel::SetSendParameters"); |
785 LOG(LS_INFO) << "SetSendParameters: " << params.ToString(); | 785 LOG(LS_INFO) << "SetSendParameters: " << params.ToString(); |
786 ChangedSendParameters changed_params; | 786 ChangedSendParameters changed_params; |
787 if (!GetChangedSendParameters(params, &changed_params)) { | 787 if (!GetChangedSendParameters(params, &changed_params)) { |
788 return false; | 788 return false; |
789 } | 789 } |
790 | 790 |
791 if (changed_params.codec) { | 791 if (changed_params.codec) { |
792 const VideoCodecSettings& codec_settings = *changed_params.codec; | 792 const VideoCodecSettings& codec_settings = *changed_params.codec; |
793 send_codec_ = rtc::Optional<VideoCodecSettings>(codec_settings); | 793 send_codec_ = rtc::Optional<VideoCodecSettings>(codec_settings); |
794 LOG(LS_INFO) << "Using codec: " << codec_settings.codec.ToString(); | 794 LOG(LS_INFO) << "Using codec: " << codec_settings.codec.ToString(); |
(...skipping 21 matching lines...) Expand all Loading... |
816 // If the codec isn't changing, set the start bitrate to -1 which means | 816 // If the codec isn't changing, set the start bitrate to -1 which means |
817 // "unchanged" so that BWE isn't affected. | 817 // "unchanged" so that BWE isn't affected. |
818 bitrate_config_.start_bitrate_bps = -1; | 818 bitrate_config_.start_bitrate_bps = -1; |
819 } | 819 } |
820 } | 820 } |
821 if (params.max_bandwidth_bps >= 0) { | 821 if (params.max_bandwidth_bps >= 0) { |
822 // Note that max_bandwidth_bps intentionally takes priority over the | 822 // Note that max_bandwidth_bps intentionally takes priority over the |
823 // bitrate config for the codec. This allows FEC to be applied above the | 823 // bitrate config for the codec. This allows FEC to be applied above the |
824 // codec target bitrate. | 824 // codec target bitrate. |
825 // TODO(pbos): Figure out whether b=AS means max bitrate for this | 825 // TODO(pbos): Figure out whether b=AS means max bitrate for this |
826 // WebRtcVideoChannel2 (in which case we're good), or per sender (SSRC), | 826 // WebRtcVideoChannel (in which case we're good), or per sender (SSRC), |
827 // in which case this should not set a Call::BitrateConfig but rather | 827 // in which case this should not set a Call::BitrateConfig but rather |
828 // reconfigure all senders. | 828 // reconfigure all senders. |
829 bitrate_config_.max_bitrate_bps = | 829 bitrate_config_.max_bitrate_bps = |
830 params.max_bandwidth_bps == 0 ? -1 : params.max_bandwidth_bps; | 830 params.max_bandwidth_bps == 0 ? -1 : params.max_bandwidth_bps; |
831 } | 831 } |
832 call_->SetBitrateConfig(bitrate_config_); | 832 call_->SetBitrateConfig(bitrate_config_); |
833 } | 833 } |
834 | 834 |
835 { | 835 { |
836 rtc::CritScope stream_lock(&stream_crit_); | 836 rtc::CritScope stream_lock(&stream_crit_); |
(...skipping 12 matching lines...) Expand all Loading... |
849 HasTransportCc(send_codec_->codec), | 849 HasTransportCc(send_codec_->codec), |
850 params.rtcp.reduced_size ? webrtc::RtcpMode::kReducedSize | 850 params.rtcp.reduced_size ? webrtc::RtcpMode::kReducedSize |
851 : webrtc::RtcpMode::kCompound); | 851 : webrtc::RtcpMode::kCompound); |
852 } | 852 } |
853 } | 853 } |
854 } | 854 } |
855 send_params_ = params; | 855 send_params_ = params; |
856 return true; | 856 return true; |
857 } | 857 } |
858 | 858 |
859 webrtc::RtpParameters WebRtcVideoChannel2::GetRtpSendParameters( | 859 webrtc::RtpParameters WebRtcVideoChannel::GetRtpSendParameters( |
860 uint32_t ssrc) const { | 860 uint32_t ssrc) const { |
861 rtc::CritScope stream_lock(&stream_crit_); | 861 rtc::CritScope stream_lock(&stream_crit_); |
862 auto it = send_streams_.find(ssrc); | 862 auto it = send_streams_.find(ssrc); |
863 if (it == send_streams_.end()) { | 863 if (it == send_streams_.end()) { |
864 LOG(LS_WARNING) << "Attempting to get RTP send parameters for stream " | 864 LOG(LS_WARNING) << "Attempting to get RTP send parameters for stream " |
865 << "with ssrc " << ssrc << " which doesn't exist."; | 865 << "with ssrc " << ssrc << " which doesn't exist."; |
866 return webrtc::RtpParameters(); | 866 return webrtc::RtpParameters(); |
867 } | 867 } |
868 | 868 |
869 webrtc::RtpParameters rtp_params = it->second->GetRtpParameters(); | 869 webrtc::RtpParameters rtp_params = it->second->GetRtpParameters(); |
870 // Need to add the common list of codecs to the send stream-specific | 870 // Need to add the common list of codecs to the send stream-specific |
871 // RTP parameters. | 871 // RTP parameters. |
872 for (const VideoCodec& codec : send_params_.codecs) { | 872 for (const VideoCodec& codec : send_params_.codecs) { |
873 rtp_params.codecs.push_back(codec.ToCodecParameters()); | 873 rtp_params.codecs.push_back(codec.ToCodecParameters()); |
874 } | 874 } |
875 return rtp_params; | 875 return rtp_params; |
876 } | 876 } |
877 | 877 |
878 bool WebRtcVideoChannel2::SetRtpSendParameters( | 878 bool WebRtcVideoChannel::SetRtpSendParameters( |
879 uint32_t ssrc, | 879 uint32_t ssrc, |
880 const webrtc::RtpParameters& parameters) { | 880 const webrtc::RtpParameters& parameters) { |
881 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRtpSendParameters"); | 881 TRACE_EVENT0("webrtc", "WebRtcVideoChannel::SetRtpSendParameters"); |
882 rtc::CritScope stream_lock(&stream_crit_); | 882 rtc::CritScope stream_lock(&stream_crit_); |
883 auto it = send_streams_.find(ssrc); | 883 auto it = send_streams_.find(ssrc); |
884 if (it == send_streams_.end()) { | 884 if (it == send_streams_.end()) { |
885 LOG(LS_ERROR) << "Attempting to set RTP send parameters for stream " | 885 LOG(LS_ERROR) << "Attempting to set RTP send parameters for stream " |
886 << "with ssrc " << ssrc << " which doesn't exist."; | 886 << "with ssrc " << ssrc << " which doesn't exist."; |
887 return false; | 887 return false; |
888 } | 888 } |
889 | 889 |
890 // TODO(deadbeef): Handle setting parameters with a list of codecs in a | 890 // TODO(deadbeef): Handle setting parameters with a list of codecs in a |
891 // different order (which should change the send codec). | 891 // different order (which should change the send codec). |
892 webrtc::RtpParameters current_parameters = GetRtpSendParameters(ssrc); | 892 webrtc::RtpParameters current_parameters = GetRtpSendParameters(ssrc); |
893 if (current_parameters.codecs != parameters.codecs) { | 893 if (current_parameters.codecs != parameters.codecs) { |
894 LOG(LS_ERROR) << "Using SetParameters to change the set of codecs " | 894 LOG(LS_ERROR) << "Using SetParameters to change the set of codecs " |
895 << "is not currently supported."; | 895 << "is not currently supported."; |
896 return false; | 896 return false; |
897 } | 897 } |
898 | 898 |
899 return it->second->SetRtpParameters(parameters); | 899 return it->second->SetRtpParameters(parameters); |
900 } | 900 } |
901 | 901 |
902 webrtc::RtpParameters WebRtcVideoChannel2::GetRtpReceiveParameters( | 902 webrtc::RtpParameters WebRtcVideoChannel::GetRtpReceiveParameters( |
903 uint32_t ssrc) const { | 903 uint32_t ssrc) const { |
904 webrtc::RtpParameters rtp_params; | 904 webrtc::RtpParameters rtp_params; |
905 rtc::CritScope stream_lock(&stream_crit_); | 905 rtc::CritScope stream_lock(&stream_crit_); |
906 // SSRC of 0 represents an unsignaled receive stream. | 906 // SSRC of 0 represents an unsignaled receive stream. |
907 if (ssrc == 0) { | 907 if (ssrc == 0) { |
908 if (!default_unsignalled_ssrc_handler_.GetDefaultSink()) { | 908 if (!default_unsignalled_ssrc_handler_.GetDefaultSink()) { |
909 LOG(LS_WARNING) << "Attempting to get RTP parameters for the default, " | 909 LOG(LS_WARNING) << "Attempting to get RTP parameters for the default, " |
910 "unsignaled video receive stream, but not yet " | 910 "unsignaled video receive stream, but not yet " |
911 "configured to receive such a stream."; | 911 "configured to receive such a stream."; |
912 return rtp_params; | 912 return rtp_params; |
(...skipping 11 matching lines...) Expand all Loading... |
924 rtp_params.encodings[0].ssrc = it->second->GetFirstPrimarySsrc(); | 924 rtp_params.encodings[0].ssrc = it->second->GetFirstPrimarySsrc(); |
925 } | 925 } |
926 | 926 |
927 // Add codecs, which any stream is prepared to receive. | 927 // Add codecs, which any stream is prepared to receive. |
928 for (const VideoCodec& codec : recv_params_.codecs) { | 928 for (const VideoCodec& codec : recv_params_.codecs) { |
929 rtp_params.codecs.push_back(codec.ToCodecParameters()); | 929 rtp_params.codecs.push_back(codec.ToCodecParameters()); |
930 } | 930 } |
931 return rtp_params; | 931 return rtp_params; |
932 } | 932 } |
933 | 933 |
934 bool WebRtcVideoChannel2::SetRtpReceiveParameters( | 934 bool WebRtcVideoChannel::SetRtpReceiveParameters( |
935 uint32_t ssrc, | 935 uint32_t ssrc, |
936 const webrtc::RtpParameters& parameters) { | 936 const webrtc::RtpParameters& parameters) { |
937 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRtpReceiveParameters"); | 937 TRACE_EVENT0("webrtc", "WebRtcVideoChannel::SetRtpReceiveParameters"); |
938 rtc::CritScope stream_lock(&stream_crit_); | 938 rtc::CritScope stream_lock(&stream_crit_); |
939 | 939 |
940 // SSRC of 0 represents an unsignaled receive stream. | 940 // SSRC of 0 represents an unsignaled receive stream. |
941 if (ssrc == 0) { | 941 if (ssrc == 0) { |
942 if (!default_unsignalled_ssrc_handler_.GetDefaultSink()) { | 942 if (!default_unsignalled_ssrc_handler_.GetDefaultSink()) { |
943 LOG(LS_WARNING) << "Attempting to set RTP parameters for the default, " | 943 LOG(LS_WARNING) << "Attempting to set RTP parameters for the default, " |
944 "unsignaled video receive stream, but not yet " | 944 "unsignaled video receive stream, but not yet " |
945 "configured to receive such a stream."; | 945 "configured to receive such a stream."; |
946 return false; | 946 return false; |
947 } | 947 } |
948 } else { | 948 } else { |
949 auto it = receive_streams_.find(ssrc); | 949 auto it = receive_streams_.find(ssrc); |
950 if (it == receive_streams_.end()) { | 950 if (it == receive_streams_.end()) { |
951 LOG(LS_WARNING) << "Attempting to set RTP receive parameters for stream " | 951 LOG(LS_WARNING) << "Attempting to set RTP receive parameters for stream " |
952 << "with SSRC " << ssrc << " which doesn't exist."; | 952 << "with SSRC " << ssrc << " which doesn't exist."; |
953 return false; | 953 return false; |
954 } | 954 } |
955 } | 955 } |
956 | 956 |
957 webrtc::RtpParameters current_parameters = GetRtpReceiveParameters(ssrc); | 957 webrtc::RtpParameters current_parameters = GetRtpReceiveParameters(ssrc); |
958 if (current_parameters != parameters) { | 958 if (current_parameters != parameters) { |
959 LOG(LS_ERROR) << "Changing the RTP receive parameters is currently " | 959 LOG(LS_ERROR) << "Changing the RTP receive parameters is currently " |
960 << "unsupported."; | 960 << "unsupported."; |
961 return false; | 961 return false; |
962 } | 962 } |
963 return true; | 963 return true; |
964 } | 964 } |
965 | 965 |
966 bool WebRtcVideoChannel2::GetChangedRecvParameters( | 966 bool WebRtcVideoChannel::GetChangedRecvParameters( |
967 const VideoRecvParameters& params, | 967 const VideoRecvParameters& params, |
968 ChangedRecvParameters* changed_params) const { | 968 ChangedRecvParameters* changed_params) const { |
969 if (!ValidateCodecFormats(params.codecs) || | 969 if (!ValidateCodecFormats(params.codecs) || |
970 !ValidateRtpExtensions(params.extensions)) { | 970 !ValidateRtpExtensions(params.extensions)) { |
971 return false; | 971 return false; |
972 } | 972 } |
973 | 973 |
974 // Handle receive codecs. | 974 // Handle receive codecs. |
975 const std::vector<VideoCodecSettings> mapped_codecs = | 975 const std::vector<VideoCodecSettings> mapped_codecs = |
976 MapCodecs(params.codecs); | 976 MapCodecs(params.codecs); |
(...skipping 28 matching lines...) Expand all Loading... |
1005 | 1005 |
1006 int flexfec_payload_type = mapped_codecs.front().flexfec_payload_type; | 1006 int flexfec_payload_type = mapped_codecs.front().flexfec_payload_type; |
1007 if (flexfec_payload_type != recv_flexfec_payload_type_) { | 1007 if (flexfec_payload_type != recv_flexfec_payload_type_) { |
1008 changed_params->flexfec_payload_type = | 1008 changed_params->flexfec_payload_type = |
1009 rtc::Optional<int>(flexfec_payload_type); | 1009 rtc::Optional<int>(flexfec_payload_type); |
1010 } | 1010 } |
1011 | 1011 |
1012 return true; | 1012 return true; |
1013 } | 1013 } |
1014 | 1014 |
1015 bool WebRtcVideoChannel2::SetRecvParameters(const VideoRecvParameters& params) { | 1015 bool WebRtcVideoChannel::SetRecvParameters(const VideoRecvParameters& params) { |
1016 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetRecvParameters"); | 1016 TRACE_EVENT0("webrtc", "WebRtcVideoChannel::SetRecvParameters"); |
1017 LOG(LS_INFO) << "SetRecvParameters: " << params.ToString(); | 1017 LOG(LS_INFO) << "SetRecvParameters: " << params.ToString(); |
1018 ChangedRecvParameters changed_params; | 1018 ChangedRecvParameters changed_params; |
1019 if (!GetChangedRecvParameters(params, &changed_params)) { | 1019 if (!GetChangedRecvParameters(params, &changed_params)) { |
1020 return false; | 1020 return false; |
1021 } | 1021 } |
1022 if (changed_params.flexfec_payload_type) { | 1022 if (changed_params.flexfec_payload_type) { |
1023 LOG(LS_INFO) << "Changing FlexFEC payload type (recv) from " | 1023 LOG(LS_INFO) << "Changing FlexFEC payload type (recv) from " |
1024 << recv_flexfec_payload_type_ << " to " | 1024 << recv_flexfec_payload_type_ << " to " |
1025 << *changed_params.flexfec_payload_type; | 1025 << *changed_params.flexfec_payload_type; |
1026 recv_flexfec_payload_type_ = *changed_params.flexfec_payload_type; | 1026 recv_flexfec_payload_type_ = *changed_params.flexfec_payload_type; |
(...skipping 11 matching lines...) Expand all Loading... |
1038 { | 1038 { |
1039 rtc::CritScope stream_lock(&stream_crit_); | 1039 rtc::CritScope stream_lock(&stream_crit_); |
1040 for (auto& kv : receive_streams_) { | 1040 for (auto& kv : receive_streams_) { |
1041 kv.second->SetRecvParameters(changed_params); | 1041 kv.second->SetRecvParameters(changed_params); |
1042 } | 1042 } |
1043 } | 1043 } |
1044 recv_params_ = params; | 1044 recv_params_ = params; |
1045 return true; | 1045 return true; |
1046 } | 1046 } |
1047 | 1047 |
1048 std::string WebRtcVideoChannel2::CodecSettingsVectorToString( | 1048 std::string WebRtcVideoChannel::CodecSettingsVectorToString( |
1049 const std::vector<VideoCodecSettings>& codecs) { | 1049 const std::vector<VideoCodecSettings>& codecs) { |
1050 std::stringstream out; | 1050 std::stringstream out; |
1051 out << '{'; | 1051 out << '{'; |
1052 for (size_t i = 0; i < codecs.size(); ++i) { | 1052 for (size_t i = 0; i < codecs.size(); ++i) { |
1053 out << codecs[i].codec.ToString(); | 1053 out << codecs[i].codec.ToString(); |
1054 if (i != codecs.size() - 1) { | 1054 if (i != codecs.size() - 1) { |
1055 out << ", "; | 1055 out << ", "; |
1056 } | 1056 } |
1057 } | 1057 } |
1058 out << '}'; | 1058 out << '}'; |
1059 return out.str(); | 1059 return out.str(); |
1060 } | 1060 } |
1061 | 1061 |
1062 bool WebRtcVideoChannel2::GetSendCodec(VideoCodec* codec) { | 1062 bool WebRtcVideoChannel::GetSendCodec(VideoCodec* codec) { |
1063 if (!send_codec_) { | 1063 if (!send_codec_) { |
1064 LOG(LS_VERBOSE) << "GetSendCodec: No send codec set."; | 1064 LOG(LS_VERBOSE) << "GetSendCodec: No send codec set."; |
1065 return false; | 1065 return false; |
1066 } | 1066 } |
1067 *codec = send_codec_->codec; | 1067 *codec = send_codec_->codec; |
1068 return true; | 1068 return true; |
1069 } | 1069 } |
1070 | 1070 |
1071 bool WebRtcVideoChannel2::SetSend(bool send) { | 1071 bool WebRtcVideoChannel::SetSend(bool send) { |
1072 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::SetSend"); | 1072 TRACE_EVENT0("webrtc", "WebRtcVideoChannel::SetSend"); |
1073 LOG(LS_VERBOSE) << "SetSend: " << (send ? "true" : "false"); | 1073 LOG(LS_VERBOSE) << "SetSend: " << (send ? "true" : "false"); |
1074 if (send && !send_codec_) { | 1074 if (send && !send_codec_) { |
1075 LOG(LS_ERROR) << "SetSend(true) called before setting codec."; | 1075 LOG(LS_ERROR) << "SetSend(true) called before setting codec."; |
1076 return false; | 1076 return false; |
1077 } | 1077 } |
1078 { | 1078 { |
1079 rtc::CritScope stream_lock(&stream_crit_); | 1079 rtc::CritScope stream_lock(&stream_crit_); |
1080 for (const auto& kv : send_streams_) { | 1080 for (const auto& kv : send_streams_) { |
1081 kv.second->SetSend(send); | 1081 kv.second->SetSend(send); |
1082 } | 1082 } |
1083 } | 1083 } |
1084 sending_ = send; | 1084 sending_ = send; |
1085 return true; | 1085 return true; |
1086 } | 1086 } |
1087 | 1087 |
1088 // TODO(nisse): The enable argument was used for mute logic which has | 1088 // TODO(nisse): The enable argument was used for mute logic which has |
1089 // been moved to VideoBroadcaster. So remove the argument from this | 1089 // been moved to VideoBroadcaster. So remove the argument from this |
1090 // method. | 1090 // method. |
1091 bool WebRtcVideoChannel2::SetVideoSend( | 1091 bool WebRtcVideoChannel::SetVideoSend( |
1092 uint32_t ssrc, | 1092 uint32_t ssrc, |
1093 bool enable, | 1093 bool enable, |
1094 const VideoOptions* options, | 1094 const VideoOptions* options, |
1095 rtc::VideoSourceInterface<webrtc::VideoFrame>* source) { | 1095 rtc::VideoSourceInterface<webrtc::VideoFrame>* source) { |
1096 TRACE_EVENT0("webrtc", "SetVideoSend"); | 1096 TRACE_EVENT0("webrtc", "SetVideoSend"); |
1097 RTC_DCHECK(ssrc != 0); | 1097 RTC_DCHECK(ssrc != 0); |
1098 LOG(LS_INFO) << "SetVideoSend (ssrc= " << ssrc << ", enable = " << enable | 1098 LOG(LS_INFO) << "SetVideoSend (ssrc= " << ssrc << ", enable = " << enable |
1099 << ", options: " << (options ? options->ToString() : "nullptr") | 1099 << ", options: " << (options ? options->ToString() : "nullptr") |
1100 << ", source = " << (source ? "(source)" : "nullptr") << ")"; | 1100 << ", source = " << (source ? "(source)" : "nullptr") << ")"; |
1101 | 1101 |
1102 rtc::CritScope stream_lock(&stream_crit_); | 1102 rtc::CritScope stream_lock(&stream_crit_); |
1103 const auto& kv = send_streams_.find(ssrc); | 1103 const auto& kv = send_streams_.find(ssrc); |
1104 if (kv == send_streams_.end()) { | 1104 if (kv == send_streams_.end()) { |
1105 // Allow unknown ssrc only if source is null. | 1105 // Allow unknown ssrc only if source is null. |
1106 RTC_CHECK(source == nullptr); | 1106 RTC_CHECK(source == nullptr); |
1107 LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc; | 1107 LOG(LS_ERROR) << "No sending stream on ssrc " << ssrc; |
1108 return false; | 1108 return false; |
1109 } | 1109 } |
1110 | 1110 |
1111 return kv->second->SetVideoSend(enable, options, source); | 1111 return kv->second->SetVideoSend(enable, options, source); |
1112 } | 1112 } |
1113 | 1113 |
1114 bool WebRtcVideoChannel2::ValidateSendSsrcAvailability( | 1114 bool WebRtcVideoChannel::ValidateSendSsrcAvailability( |
1115 const StreamParams& sp) const { | 1115 const StreamParams& sp) const { |
1116 for (uint32_t ssrc : sp.ssrcs) { | 1116 for (uint32_t ssrc : sp.ssrcs) { |
1117 if (send_ssrcs_.find(ssrc) != send_ssrcs_.end()) { | 1117 if (send_ssrcs_.find(ssrc) != send_ssrcs_.end()) { |
1118 LOG(LS_ERROR) << "Send stream with SSRC '" << ssrc << "' already exists."; | 1118 LOG(LS_ERROR) << "Send stream with SSRC '" << ssrc << "' already exists."; |
1119 return false; | 1119 return false; |
1120 } | 1120 } |
1121 } | 1121 } |
1122 return true; | 1122 return true; |
1123 } | 1123 } |
1124 | 1124 |
1125 bool WebRtcVideoChannel2::ValidateReceiveSsrcAvailability( | 1125 bool WebRtcVideoChannel::ValidateReceiveSsrcAvailability( |
1126 const StreamParams& sp) const { | 1126 const StreamParams& sp) const { |
1127 for (uint32_t ssrc : sp.ssrcs) { | 1127 for (uint32_t ssrc : sp.ssrcs) { |
1128 if (receive_ssrcs_.find(ssrc) != receive_ssrcs_.end()) { | 1128 if (receive_ssrcs_.find(ssrc) != receive_ssrcs_.end()) { |
1129 LOG(LS_ERROR) << "Receive stream with SSRC '" << ssrc | 1129 LOG(LS_ERROR) << "Receive stream with SSRC '" << ssrc |
1130 << "' already exists."; | 1130 << "' already exists."; |
1131 return false; | 1131 return false; |
1132 } | 1132 } |
1133 } | 1133 } |
1134 return true; | 1134 return true; |
1135 } | 1135 } |
1136 | 1136 |
1137 bool WebRtcVideoChannel2::AddSendStream(const StreamParams& sp) { | 1137 bool WebRtcVideoChannel::AddSendStream(const StreamParams& sp) { |
1138 LOG(LS_INFO) << "AddSendStream: " << sp.ToString(); | 1138 LOG(LS_INFO) << "AddSendStream: " << sp.ToString(); |
1139 if (!ValidateStreamParams(sp)) | 1139 if (!ValidateStreamParams(sp)) |
1140 return false; | 1140 return false; |
1141 | 1141 |
1142 rtc::CritScope stream_lock(&stream_crit_); | 1142 rtc::CritScope stream_lock(&stream_crit_); |
1143 | 1143 |
1144 if (!ValidateSendSsrcAvailability(sp)) | 1144 if (!ValidateSendSsrcAvailability(sp)) |
1145 return false; | 1145 return false; |
1146 | 1146 |
1147 for (uint32_t used_ssrc : sp.ssrcs) | 1147 for (uint32_t used_ssrc : sp.ssrcs) |
(...skipping 20 matching lines...) Expand all Loading... |
1168 for (auto& kv : receive_streams_) | 1168 for (auto& kv : receive_streams_) |
1169 kv.second->SetLocalSsrc(ssrc); | 1169 kv.second->SetLocalSsrc(ssrc); |
1170 } | 1170 } |
1171 if (sending_) { | 1171 if (sending_) { |
1172 stream->SetSend(true); | 1172 stream->SetSend(true); |
1173 } | 1173 } |
1174 | 1174 |
1175 return true; | 1175 return true; |
1176 } | 1176 } |
1177 | 1177 |
1178 bool WebRtcVideoChannel2::RemoveSendStream(uint32_t ssrc) { | 1178 bool WebRtcVideoChannel::RemoveSendStream(uint32_t ssrc) { |
1179 LOG(LS_INFO) << "RemoveSendStream: " << ssrc; | 1179 LOG(LS_INFO) << "RemoveSendStream: " << ssrc; |
1180 | 1180 |
1181 WebRtcVideoSendStream* removed_stream; | 1181 WebRtcVideoSendStream* removed_stream; |
1182 { | 1182 { |
1183 rtc::CritScope stream_lock(&stream_crit_); | 1183 rtc::CritScope stream_lock(&stream_crit_); |
1184 std::map<uint32_t, WebRtcVideoSendStream*>::iterator it = | 1184 std::map<uint32_t, WebRtcVideoSendStream*>::iterator it = |
1185 send_streams_.find(ssrc); | 1185 send_streams_.find(ssrc); |
1186 if (it == send_streams_.end()) { | 1186 if (it == send_streams_.end()) { |
1187 return false; | 1187 return false; |
1188 } | 1188 } |
(...skipping 16 matching lines...) Expand all Loading... |
1205 kv.second->SetLocalSsrc(rtcp_receiver_report_ssrc_); | 1205 kv.second->SetLocalSsrc(rtcp_receiver_report_ssrc_); |
1206 } | 1206 } |
1207 } | 1207 } |
1208 } | 1208 } |
1209 | 1209 |
1210 delete removed_stream; | 1210 delete removed_stream; |
1211 | 1211 |
1212 return true; | 1212 return true; |
1213 } | 1213 } |
1214 | 1214 |
1215 void WebRtcVideoChannel2::DeleteReceiveStream( | 1215 void WebRtcVideoChannel::DeleteReceiveStream( |
1216 WebRtcVideoChannel2::WebRtcVideoReceiveStream* stream) { | 1216 WebRtcVideoChannel::WebRtcVideoReceiveStream* stream) { |
1217 for (uint32_t old_ssrc : stream->GetSsrcs()) | 1217 for (uint32_t old_ssrc : stream->GetSsrcs()) |
1218 receive_ssrcs_.erase(old_ssrc); | 1218 receive_ssrcs_.erase(old_ssrc); |
1219 delete stream; | 1219 delete stream; |
1220 } | 1220 } |
1221 | 1221 |
1222 bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp) { | 1222 bool WebRtcVideoChannel::AddRecvStream(const StreamParams& sp) { |
1223 return AddRecvStream(sp, false); | 1223 return AddRecvStream(sp, false); |
1224 } | 1224 } |
1225 | 1225 |
1226 bool WebRtcVideoChannel2::AddRecvStream(const StreamParams& sp, | 1226 bool WebRtcVideoChannel::AddRecvStream(const StreamParams& sp, |
1227 bool default_stream) { | 1227 bool default_stream) { |
1228 RTC_DCHECK(thread_checker_.CalledOnValidThread()); | 1228 RTC_DCHECK(thread_checker_.CalledOnValidThread()); |
1229 | 1229 |
1230 LOG(LS_INFO) << "AddRecvStream" << (default_stream ? " (default stream)" : "") | 1230 LOG(LS_INFO) << "AddRecvStream" << (default_stream ? " (default stream)" : "") |
1231 << ": " << sp.ToString(); | 1231 << ": " << sp.ToString(); |
1232 if (!ValidateStreamParams(sp)) | 1232 if (!ValidateStreamParams(sp)) |
1233 return false; | 1233 return false; |
1234 | 1234 |
1235 uint32_t ssrc = sp.first_ssrc(); | 1235 uint32_t ssrc = sp.first_ssrc(); |
1236 RTC_DCHECK(ssrc != 0); // TODO(pbos): Is this ever valid? | 1236 RTC_DCHECK(ssrc != 0); // TODO(pbos): Is this ever valid? |
1237 | 1237 |
(...skipping 24 matching lines...) Expand all Loading... |
1262 video_config_.disable_prerenderer_smoothing; | 1262 video_config_.disable_prerenderer_smoothing; |
1263 config.sync_group = sp.sync_label; | 1263 config.sync_group = sp.sync_label; |
1264 | 1264 |
1265 receive_streams_[ssrc] = new WebRtcVideoReceiveStream( | 1265 receive_streams_[ssrc] = new WebRtcVideoReceiveStream( |
1266 call_, sp, std::move(config), external_decoder_factory_, default_stream, | 1266 call_, sp, std::move(config), external_decoder_factory_, default_stream, |
1267 recv_codecs_, flexfec_config); | 1267 recv_codecs_, flexfec_config); |
1268 | 1268 |
1269 return true; | 1269 return true; |
1270 } | 1270 } |
1271 | 1271 |
1272 void WebRtcVideoChannel2::ConfigureReceiverRtp( | 1272 void WebRtcVideoChannel::ConfigureReceiverRtp( |
1273 webrtc::VideoReceiveStream::Config* config, | 1273 webrtc::VideoReceiveStream::Config* config, |
1274 webrtc::FlexfecReceiveStream::Config* flexfec_config, | 1274 webrtc::FlexfecReceiveStream::Config* flexfec_config, |
1275 const StreamParams& sp) const { | 1275 const StreamParams& sp) const { |
1276 uint32_t ssrc = sp.first_ssrc(); | 1276 uint32_t ssrc = sp.first_ssrc(); |
1277 | 1277 |
1278 config->rtp.remote_ssrc = ssrc; | 1278 config->rtp.remote_ssrc = ssrc; |
1279 config->rtp.local_ssrc = rtcp_receiver_report_ssrc_; | 1279 config->rtp.local_ssrc = rtcp_receiver_report_ssrc_; |
1280 | 1280 |
1281 // TODO(pbos): This protection is against setting the same local ssrc as | 1281 // TODO(pbos): This protection is against setting the same local ssrc as |
1282 // remote which is not permitted by the lower-level API. RTCP requires a | 1282 // remote which is not permitted by the lower-level API. RTCP requires a |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1314 flexfec_config->protected_media_ssrcs = {ssrc}; | 1314 flexfec_config->protected_media_ssrcs = {ssrc}; |
1315 flexfec_config->local_ssrc = config->rtp.local_ssrc; | 1315 flexfec_config->local_ssrc = config->rtp.local_ssrc; |
1316 flexfec_config->rtcp_mode = config->rtp.rtcp_mode; | 1316 flexfec_config->rtcp_mode = config->rtp.rtcp_mode; |
1317 // TODO(brandtr): We should be spec-compliant and set |transport_cc| here | 1317 // TODO(brandtr): We should be spec-compliant and set |transport_cc| here |
1318 // based on the rtcp-fb for the FlexFEC codec, not the media codec. | 1318 // based on the rtcp-fb for the FlexFEC codec, not the media codec. |
1319 flexfec_config->transport_cc = config->rtp.transport_cc; | 1319 flexfec_config->transport_cc = config->rtp.transport_cc; |
1320 flexfec_config->rtp_header_extensions = config->rtp.extensions; | 1320 flexfec_config->rtp_header_extensions = config->rtp.extensions; |
1321 } | 1321 } |
1322 } | 1322 } |
1323 | 1323 |
1324 bool WebRtcVideoChannel2::RemoveRecvStream(uint32_t ssrc) { | 1324 bool WebRtcVideoChannel::RemoveRecvStream(uint32_t ssrc) { |
1325 LOG(LS_INFO) << "RemoveRecvStream: " << ssrc; | 1325 LOG(LS_INFO) << "RemoveRecvStream: " << ssrc; |
1326 if (ssrc == 0) { | 1326 if (ssrc == 0) { |
1327 LOG(LS_ERROR) << "RemoveRecvStream with 0 ssrc is not supported."; | 1327 LOG(LS_ERROR) << "RemoveRecvStream with 0 ssrc is not supported."; |
1328 return false; | 1328 return false; |
1329 } | 1329 } |
1330 | 1330 |
1331 rtc::CritScope stream_lock(&stream_crit_); | 1331 rtc::CritScope stream_lock(&stream_crit_); |
1332 std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator stream = | 1332 std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator stream = |
1333 receive_streams_.find(ssrc); | 1333 receive_streams_.find(ssrc); |
1334 if (stream == receive_streams_.end()) { | 1334 if (stream == receive_streams_.end()) { |
1335 LOG(LS_ERROR) << "Stream not found for ssrc: " << ssrc; | 1335 LOG(LS_ERROR) << "Stream not found for ssrc: " << ssrc; |
1336 return false; | 1336 return false; |
1337 } | 1337 } |
1338 DeleteReceiveStream(stream->second); | 1338 DeleteReceiveStream(stream->second); |
1339 receive_streams_.erase(stream); | 1339 receive_streams_.erase(stream); |
1340 | 1340 |
1341 return true; | 1341 return true; |
1342 } | 1342 } |
1343 | 1343 |
1344 bool WebRtcVideoChannel2::SetSink( | 1344 bool WebRtcVideoChannel::SetSink( |
1345 uint32_t ssrc, | 1345 uint32_t ssrc, |
1346 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) { | 1346 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) { |
1347 LOG(LS_INFO) << "SetSink: ssrc:" << ssrc << " " | 1347 LOG(LS_INFO) << "SetSink: ssrc:" << ssrc << " " |
1348 << (sink ? "(ptr)" : "nullptr"); | 1348 << (sink ? "(ptr)" : "nullptr"); |
1349 if (ssrc == 0) { | 1349 if (ssrc == 0) { |
1350 // Do not hold |stream_crit_| here, since SetDefaultSink will call | 1350 // Do not hold |stream_crit_| here, since SetDefaultSink will call |
1351 // WebRtcVideoChannel2::GetDefaultReceiveStreamSsrc(). | 1351 // WebRtcVideoChannel::GetDefaultReceiveStreamSsrc(). |
1352 default_unsignalled_ssrc_handler_.SetDefaultSink(this, sink); | 1352 default_unsignalled_ssrc_handler_.SetDefaultSink(this, sink); |
1353 return true; | 1353 return true; |
1354 } | 1354 } |
1355 | 1355 |
1356 rtc::CritScope stream_lock(&stream_crit_); | 1356 rtc::CritScope stream_lock(&stream_crit_); |
1357 std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it = | 1357 std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it = |
1358 receive_streams_.find(ssrc); | 1358 receive_streams_.find(ssrc); |
1359 if (it == receive_streams_.end()) { | 1359 if (it == receive_streams_.end()) { |
1360 return false; | 1360 return false; |
1361 } | 1361 } |
1362 | 1362 |
1363 it->second->SetSink(sink); | 1363 it->second->SetSink(sink); |
1364 return true; | 1364 return true; |
1365 } | 1365 } |
1366 | 1366 |
1367 bool WebRtcVideoChannel2::GetStats(VideoMediaInfo* info) { | 1367 bool WebRtcVideoChannel::GetStats(VideoMediaInfo* info) { |
1368 TRACE_EVENT0("webrtc", "WebRtcVideoChannel2::GetStats"); | 1368 TRACE_EVENT0("webrtc", "WebRtcVideoChannel::GetStats"); |
1369 | 1369 |
1370 // Log stats periodically. | 1370 // Log stats periodically. |
1371 bool log_stats = false; | 1371 bool log_stats = false; |
1372 int64_t now_ms = rtc::TimeMillis(); | 1372 int64_t now_ms = rtc::TimeMillis(); |
1373 if (last_stats_log_ms_ == -1 || | 1373 if (last_stats_log_ms_ == -1 || |
1374 now_ms - last_stats_log_ms_ > kStatsLogIntervalMs) { | 1374 now_ms - last_stats_log_ms_ > kStatsLogIntervalMs) { |
1375 last_stats_log_ms_ = now_ms; | 1375 last_stats_log_ms_ = now_ms; |
1376 log_stats = true; | 1376 log_stats = true; |
1377 } | 1377 } |
1378 | 1378 |
1379 info->Clear(); | 1379 info->Clear(); |
1380 FillSenderStats(info, log_stats); | 1380 FillSenderStats(info, log_stats); |
1381 FillReceiverStats(info, log_stats); | 1381 FillReceiverStats(info, log_stats); |
1382 FillSendAndReceiveCodecStats(info); | 1382 FillSendAndReceiveCodecStats(info); |
1383 // TODO(holmer): We should either have rtt available as a metric on | 1383 // TODO(holmer): We should either have rtt available as a metric on |
1384 // VideoSend/ReceiveStreams, or we should remove rtt from VideoSenderInfo. | 1384 // VideoSend/ReceiveStreams, or we should remove rtt from VideoSenderInfo. |
1385 webrtc::Call::Stats stats = call_->GetStats(); | 1385 webrtc::Call::Stats stats = call_->GetStats(); |
1386 if (stats.rtt_ms != -1) { | 1386 if (stats.rtt_ms != -1) { |
1387 for (size_t i = 0; i < info->senders.size(); ++i) { | 1387 for (size_t i = 0; i < info->senders.size(); ++i) { |
1388 info->senders[i].rtt_ms = stats.rtt_ms; | 1388 info->senders[i].rtt_ms = stats.rtt_ms; |
1389 } | 1389 } |
1390 } | 1390 } |
1391 | 1391 |
1392 if (log_stats) | 1392 if (log_stats) |
1393 LOG(LS_INFO) << stats.ToString(now_ms); | 1393 LOG(LS_INFO) << stats.ToString(now_ms); |
1394 | 1394 |
1395 return true; | 1395 return true; |
1396 } | 1396 } |
1397 | 1397 |
1398 void WebRtcVideoChannel2::FillSenderStats(VideoMediaInfo* video_media_info, | 1398 void WebRtcVideoChannel::FillSenderStats(VideoMediaInfo* video_media_info, |
1399 bool log_stats) { | 1399 bool log_stats) { |
1400 rtc::CritScope stream_lock(&stream_crit_); | 1400 rtc::CritScope stream_lock(&stream_crit_); |
1401 for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator it = | 1401 for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator it = |
1402 send_streams_.begin(); | 1402 send_streams_.begin(); |
1403 it != send_streams_.end(); ++it) { | 1403 it != send_streams_.end(); ++it) { |
1404 video_media_info->senders.push_back( | 1404 video_media_info->senders.push_back( |
1405 it->second->GetVideoSenderInfo(log_stats)); | 1405 it->second->GetVideoSenderInfo(log_stats)); |
1406 } | 1406 } |
1407 } | 1407 } |
1408 | 1408 |
1409 void WebRtcVideoChannel2::FillReceiverStats(VideoMediaInfo* video_media_info, | 1409 void WebRtcVideoChannel::FillReceiverStats(VideoMediaInfo* video_media_info, |
1410 bool log_stats) { | 1410 bool log_stats) { |
1411 rtc::CritScope stream_lock(&stream_crit_); | 1411 rtc::CritScope stream_lock(&stream_crit_); |
1412 for (std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it = | 1412 for (std::map<uint32_t, WebRtcVideoReceiveStream*>::iterator it = |
1413 receive_streams_.begin(); | 1413 receive_streams_.begin(); |
1414 it != receive_streams_.end(); ++it) { | 1414 it != receive_streams_.end(); ++it) { |
1415 video_media_info->receivers.push_back( | 1415 video_media_info->receivers.push_back( |
1416 it->second->GetVideoReceiverInfo(log_stats)); | 1416 it->second->GetVideoReceiverInfo(log_stats)); |
1417 } | 1417 } |
1418 } | 1418 } |
1419 | 1419 |
1420 void WebRtcVideoChannel2::FillBitrateInfo(BandwidthEstimationInfo* bwe_info) { | 1420 void WebRtcVideoChannel::FillBitrateInfo(BandwidthEstimationInfo* bwe_info) { |
1421 rtc::CritScope stream_lock(&stream_crit_); | 1421 rtc::CritScope stream_lock(&stream_crit_); |
1422 for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator stream = | 1422 for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator stream = |
1423 send_streams_.begin(); | 1423 send_streams_.begin(); |
1424 stream != send_streams_.end(); ++stream) { | 1424 stream != send_streams_.end(); ++stream) { |
1425 stream->second->FillBitrateInfo(bwe_info); | 1425 stream->second->FillBitrateInfo(bwe_info); |
1426 } | 1426 } |
1427 } | 1427 } |
1428 | 1428 |
1429 void WebRtcVideoChannel2::FillSendAndReceiveCodecStats( | 1429 void WebRtcVideoChannel::FillSendAndReceiveCodecStats( |
1430 VideoMediaInfo* video_media_info) { | 1430 VideoMediaInfo* video_media_info) { |
1431 for (const VideoCodec& codec : send_params_.codecs) { | 1431 for (const VideoCodec& codec : send_params_.codecs) { |
1432 webrtc::RtpCodecParameters codec_params = codec.ToCodecParameters(); | 1432 webrtc::RtpCodecParameters codec_params = codec.ToCodecParameters(); |
1433 video_media_info->send_codecs.insert( | 1433 video_media_info->send_codecs.insert( |
1434 std::make_pair(codec_params.payload_type, std::move(codec_params))); | 1434 std::make_pair(codec_params.payload_type, std::move(codec_params))); |
1435 } | 1435 } |
1436 for (const VideoCodec& codec : recv_params_.codecs) { | 1436 for (const VideoCodec& codec : recv_params_.codecs) { |
1437 webrtc::RtpCodecParameters codec_params = codec.ToCodecParameters(); | 1437 webrtc::RtpCodecParameters codec_params = codec.ToCodecParameters(); |
1438 video_media_info->receive_codecs.insert( | 1438 video_media_info->receive_codecs.insert( |
1439 std::make_pair(codec_params.payload_type, std::move(codec_params))); | 1439 std::make_pair(codec_params.payload_type, std::move(codec_params))); |
1440 } | 1440 } |
1441 } | 1441 } |
1442 | 1442 |
1443 void WebRtcVideoChannel2::OnPacketReceived( | 1443 void WebRtcVideoChannel::OnPacketReceived( |
1444 rtc::CopyOnWriteBuffer* packet, | 1444 rtc::CopyOnWriteBuffer* packet, |
1445 const rtc::PacketTime& packet_time) { | 1445 const rtc::PacketTime& packet_time) { |
1446 const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp, | 1446 const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp, |
1447 packet_time.not_before); | 1447 packet_time.not_before); |
1448 const webrtc::PacketReceiver::DeliveryStatus delivery_result = | 1448 const webrtc::PacketReceiver::DeliveryStatus delivery_result = |
1449 call_->Receiver()->DeliverPacket( | 1449 call_->Receiver()->DeliverPacket( |
1450 webrtc::MediaType::VIDEO, | 1450 webrtc::MediaType::VIDEO, |
1451 packet->cdata(), packet->size(), | 1451 packet->cdata(), packet->size(), |
1452 webrtc_packet_time); | 1452 webrtc_packet_time); |
1453 switch (delivery_result) { | 1453 switch (delivery_result) { |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1494 | 1494 |
1495 if (call_->Receiver()->DeliverPacket( | 1495 if (call_->Receiver()->DeliverPacket( |
1496 webrtc::MediaType::VIDEO, | 1496 webrtc::MediaType::VIDEO, |
1497 packet->cdata(), packet->size(), | 1497 packet->cdata(), packet->size(), |
1498 webrtc_packet_time) != webrtc::PacketReceiver::DELIVERY_OK) { | 1498 webrtc_packet_time) != webrtc::PacketReceiver::DELIVERY_OK) { |
1499 LOG(LS_WARNING) << "Failed to deliver RTP packet on re-delivery."; | 1499 LOG(LS_WARNING) << "Failed to deliver RTP packet on re-delivery."; |
1500 return; | 1500 return; |
1501 } | 1501 } |
1502 } | 1502 } |
1503 | 1503 |
1504 void WebRtcVideoChannel2::OnRtcpReceived( | 1504 void WebRtcVideoChannel::OnRtcpReceived( |
1505 rtc::CopyOnWriteBuffer* packet, | 1505 rtc::CopyOnWriteBuffer* packet, |
1506 const rtc::PacketTime& packet_time) { | 1506 const rtc::PacketTime& packet_time) { |
1507 const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp, | 1507 const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp, |
1508 packet_time.not_before); | 1508 packet_time.not_before); |
1509 // TODO(pbos): Check webrtc::PacketReceiver::DELIVERY_OK once we deliver | 1509 // TODO(pbos): Check webrtc::PacketReceiver::DELIVERY_OK once we deliver |
1510 // for both audio and video on the same path. Since BundleFilter doesn't | 1510 // for both audio and video on the same path. Since BundleFilter doesn't |
1511 // filter RTCP anymore incoming RTCP packets could've been going to audio (so | 1511 // filter RTCP anymore incoming RTCP packets could've been going to audio (so |
1512 // logging failures spam the log). | 1512 // logging failures spam the log). |
1513 call_->Receiver()->DeliverPacket( | 1513 call_->Receiver()->DeliverPacket( |
1514 webrtc::MediaType::VIDEO, | 1514 webrtc::MediaType::VIDEO, |
1515 packet->cdata(), packet->size(), | 1515 packet->cdata(), packet->size(), |
1516 webrtc_packet_time); | 1516 webrtc_packet_time); |
1517 } | 1517 } |
1518 | 1518 |
1519 void WebRtcVideoChannel2::OnReadyToSend(bool ready) { | 1519 void WebRtcVideoChannel::OnReadyToSend(bool ready) { |
1520 LOG(LS_VERBOSE) << "OnReadyToSend: " << (ready ? "Ready." : "Not ready."); | 1520 LOG(LS_VERBOSE) << "OnReadyToSend: " << (ready ? "Ready." : "Not ready."); |
1521 call_->SignalChannelNetworkState( | 1521 call_->SignalChannelNetworkState( |
1522 webrtc::MediaType::VIDEO, | 1522 webrtc::MediaType::VIDEO, |
1523 ready ? webrtc::kNetworkUp : webrtc::kNetworkDown); | 1523 ready ? webrtc::kNetworkUp : webrtc::kNetworkDown); |
1524 } | 1524 } |
1525 | 1525 |
1526 void WebRtcVideoChannel2::OnNetworkRouteChanged( | 1526 void WebRtcVideoChannel::OnNetworkRouteChanged( |
1527 const std::string& transport_name, | 1527 const std::string& transport_name, |
1528 const rtc::NetworkRoute& network_route) { | 1528 const rtc::NetworkRoute& network_route) { |
1529 call_->OnNetworkRouteChanged(transport_name, network_route); | 1529 call_->OnNetworkRouteChanged(transport_name, network_route); |
1530 } | 1530 } |
1531 | 1531 |
1532 void WebRtcVideoChannel2::OnTransportOverheadChanged( | 1532 void WebRtcVideoChannel::OnTransportOverheadChanged( |
1533 int transport_overhead_per_packet) { | 1533 int transport_overhead_per_packet) { |
1534 call_->OnTransportOverheadChanged(webrtc::MediaType::VIDEO, | 1534 call_->OnTransportOverheadChanged(webrtc::MediaType::VIDEO, |
1535 transport_overhead_per_packet); | 1535 transport_overhead_per_packet); |
1536 } | 1536 } |
1537 | 1537 |
1538 void WebRtcVideoChannel2::SetInterface(NetworkInterface* iface) { | 1538 void WebRtcVideoChannel::SetInterface(NetworkInterface* iface) { |
1539 MediaChannel::SetInterface(iface); | 1539 MediaChannel::SetInterface(iface); |
1540 // Set the RTP recv/send buffer to a bigger size | 1540 // Set the RTP recv/send buffer to a bigger size |
1541 MediaChannel::SetOption(NetworkInterface::ST_RTP, | 1541 MediaChannel::SetOption(NetworkInterface::ST_RTP, |
1542 rtc::Socket::OPT_RCVBUF, | 1542 rtc::Socket::OPT_RCVBUF, |
1543 kVideoRtpBufferSize); | 1543 kVideoRtpBufferSize); |
1544 | 1544 |
1545 // Speculative change to increase the outbound socket buffer size. | 1545 // Speculative change to increase the outbound socket buffer size. |
1546 // In b/15152257, we are seeing a significant number of packets discarded | 1546 // In b/15152257, we are seeing a significant number of packets discarded |
1547 // due to lack of socket buffer space, although it's not yet clear what the | 1547 // due to lack of socket buffer space, although it's not yet clear what the |
1548 // ideal value should be. | 1548 // ideal value should be. |
1549 MediaChannel::SetOption(NetworkInterface::ST_RTP, | 1549 MediaChannel::SetOption(NetworkInterface::ST_RTP, |
1550 rtc::Socket::OPT_SNDBUF, | 1550 rtc::Socket::OPT_SNDBUF, |
1551 kVideoRtpBufferSize); | 1551 kVideoRtpBufferSize); |
1552 } | 1552 } |
1553 | 1553 |
1554 rtc::Optional<uint32_t> WebRtcVideoChannel2::GetDefaultReceiveStreamSsrc() { | 1554 rtc::Optional<uint32_t> WebRtcVideoChannel::GetDefaultReceiveStreamSsrc() { |
1555 rtc::CritScope stream_lock(&stream_crit_); | 1555 rtc::CritScope stream_lock(&stream_crit_); |
1556 rtc::Optional<uint32_t> ssrc; | 1556 rtc::Optional<uint32_t> ssrc; |
1557 for (auto it = receive_streams_.begin(); it != receive_streams_.end(); ++it) { | 1557 for (auto it = receive_streams_.begin(); it != receive_streams_.end(); ++it) { |
1558 if (it->second->IsDefaultStream()) { | 1558 if (it->second->IsDefaultStream()) { |
1559 ssrc.emplace(it->first); | 1559 ssrc.emplace(it->first); |
1560 break; | 1560 break; |
1561 } | 1561 } |
1562 } | 1562 } |
1563 return ssrc; | 1563 return ssrc; |
1564 } | 1564 } |
1565 | 1565 |
1566 bool WebRtcVideoChannel2::SendRtp(const uint8_t* data, | 1566 bool WebRtcVideoChannel::SendRtp(const uint8_t* data, |
1567 size_t len, | 1567 size_t len, |
1568 const webrtc::PacketOptions& options) { | 1568 const webrtc::PacketOptions& options) { |
1569 rtc::CopyOnWriteBuffer packet(data, len, kMaxRtpPacketLen); | 1569 rtc::CopyOnWriteBuffer packet(data, len, kMaxRtpPacketLen); |
1570 rtc::PacketOptions rtc_options; | 1570 rtc::PacketOptions rtc_options; |
1571 rtc_options.packet_id = options.packet_id; | 1571 rtc_options.packet_id = options.packet_id; |
1572 return MediaChannel::SendPacket(&packet, rtc_options); | 1572 return MediaChannel::SendPacket(&packet, rtc_options); |
1573 } | 1573 } |
1574 | 1574 |
1575 bool WebRtcVideoChannel2::SendRtcp(const uint8_t* data, size_t len) { | 1575 bool WebRtcVideoChannel::SendRtcp(const uint8_t* data, size_t len) { |
1576 rtc::CopyOnWriteBuffer packet(data, len, kMaxRtpPacketLen); | 1576 rtc::CopyOnWriteBuffer packet(data, len, kMaxRtpPacketLen); |
1577 return MediaChannel::SendRtcp(&packet, rtc::PacketOptions()); | 1577 return MediaChannel::SendRtcp(&packet, rtc::PacketOptions()); |
1578 } | 1578 } |
1579 | 1579 |
1580 WebRtcVideoChannel2::WebRtcVideoSendStream::VideoSendStreamParameters:: | 1580 WebRtcVideoChannel::WebRtcVideoSendStream::VideoSendStreamParameters:: |
1581 VideoSendStreamParameters( | 1581 VideoSendStreamParameters( |
1582 webrtc::VideoSendStream::Config config, | 1582 webrtc::VideoSendStream::Config config, |
1583 const VideoOptions& options, | 1583 const VideoOptions& options, |
1584 int max_bitrate_bps, | 1584 int max_bitrate_bps, |
1585 const rtc::Optional<VideoCodecSettings>& codec_settings) | 1585 const rtc::Optional<VideoCodecSettings>& codec_settings) |
1586 : config(std::move(config)), | 1586 : config(std::move(config)), |
1587 options(options), | 1587 options(options), |
1588 max_bitrate_bps(max_bitrate_bps), | 1588 max_bitrate_bps(max_bitrate_bps), |
1589 conference_mode(false), | 1589 conference_mode(false), |
1590 codec_settings(codec_settings) {} | 1590 codec_settings(codec_settings) {} |
1591 | 1591 |
1592 WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder::AllocatedEncoder( | 1592 WebRtcVideoChannel::WebRtcVideoSendStream::AllocatedEncoder::AllocatedEncoder( |
1593 webrtc::VideoEncoder* encoder, | 1593 webrtc::VideoEncoder* encoder, |
1594 const cricket::VideoCodec& codec, | 1594 const cricket::VideoCodec& codec, |
1595 bool external) | 1595 bool external) |
1596 : encoder(encoder), | 1596 : encoder(encoder), |
1597 external_encoder(nullptr), | 1597 external_encoder(nullptr), |
1598 codec(codec), | 1598 codec(codec), |
1599 external(external) { | 1599 external(external) { |
1600 if (external) { | 1600 if (external) { |
1601 external_encoder = encoder; | 1601 external_encoder = encoder; |
1602 this->encoder = | 1602 this->encoder = |
1603 new webrtc::VideoEncoderSoftwareFallbackWrapper(codec, encoder); | 1603 new webrtc::VideoEncoderSoftwareFallbackWrapper(codec, encoder); |
1604 } | 1604 } |
1605 } | 1605 } |
1606 | 1606 |
1607 WebRtcVideoChannel2::WebRtcVideoSendStream::WebRtcVideoSendStream( | 1607 WebRtcVideoChannel::WebRtcVideoSendStream::WebRtcVideoSendStream( |
1608 webrtc::Call* call, | 1608 webrtc::Call* call, |
1609 const StreamParams& sp, | 1609 const StreamParams& sp, |
1610 webrtc::VideoSendStream::Config config, | 1610 webrtc::VideoSendStream::Config config, |
1611 const VideoOptions& options, | 1611 const VideoOptions& options, |
1612 WebRtcVideoEncoderFactory* external_encoder_factory, | 1612 WebRtcVideoEncoderFactory* external_encoder_factory, |
1613 bool enable_cpu_overuse_detection, | 1613 bool enable_cpu_overuse_detection, |
1614 int max_bitrate_bps, | 1614 int max_bitrate_bps, |
1615 const rtc::Optional<VideoCodecSettings>& codec_settings, | 1615 const rtc::Optional<VideoCodecSettings>& codec_settings, |
1616 const rtc::Optional<std::vector<webrtc::RtpExtension>>& rtp_extensions, | 1616 const rtc::Optional<std::vector<webrtc::RtpExtension>>& rtp_extensions, |
1617 // TODO(deadbeef): Don't duplicate information between send_params, | 1617 // TODO(deadbeef): Don't duplicate information between send_params, |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1675 } | 1675 } |
1676 parameters_.config.rtp.rtcp_mode = send_params.rtcp.reduced_size | 1676 parameters_.config.rtp.rtcp_mode = send_params.rtcp.reduced_size |
1677 ? webrtc::RtcpMode::kReducedSize | 1677 ? webrtc::RtcpMode::kReducedSize |
1678 : webrtc::RtcpMode::kCompound; | 1678 : webrtc::RtcpMode::kCompound; |
1679 if (codec_settings) { | 1679 if (codec_settings) { |
1680 bool force_encoder_allocation = false; | 1680 bool force_encoder_allocation = false; |
1681 SetCodec(*codec_settings, force_encoder_allocation); | 1681 SetCodec(*codec_settings, force_encoder_allocation); |
1682 } | 1682 } |
1683 } | 1683 } |
1684 | 1684 |
1685 WebRtcVideoChannel2::WebRtcVideoSendStream::~WebRtcVideoSendStream() { | 1685 WebRtcVideoChannel::WebRtcVideoSendStream::~WebRtcVideoSendStream() { |
1686 if (stream_ != NULL) { | 1686 if (stream_ != NULL) { |
1687 call_->DestroyVideoSendStream(stream_); | 1687 call_->DestroyVideoSendStream(stream_); |
1688 } | 1688 } |
1689 DestroyVideoEncoder(&allocated_encoder_); | 1689 DestroyVideoEncoder(&allocated_encoder_); |
1690 } | 1690 } |
1691 | 1691 |
1692 bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoSend( | 1692 bool WebRtcVideoChannel::WebRtcVideoSendStream::SetVideoSend( |
1693 bool enable, | 1693 bool enable, |
1694 const VideoOptions* options, | 1694 const VideoOptions* options, |
1695 rtc::VideoSourceInterface<webrtc::VideoFrame>* source) { | 1695 rtc::VideoSourceInterface<webrtc::VideoFrame>* source) { |
1696 TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetVideoSend"); | 1696 TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetVideoSend"); |
1697 RTC_DCHECK_RUN_ON(&thread_checker_); | 1697 RTC_DCHECK_RUN_ON(&thread_checker_); |
1698 | 1698 |
1699 // Ignore |options| pointer if |enable| is false. | 1699 // Ignore |options| pointer if |enable| is false. |
1700 bool options_present = enable && options; | 1700 bool options_present = enable && options; |
1701 | 1701 |
1702 if (options_present) { | 1702 if (options_present) { |
(...skipping 21 matching lines...) Expand all Loading... |
1724 } | 1724 } |
1725 // Switch to the new source. | 1725 // Switch to the new source. |
1726 source_ = source; | 1726 source_ = source; |
1727 if (source && stream_) { | 1727 if (source && stream_) { |
1728 stream_->SetSource(this, GetDegradationPreference()); | 1728 stream_->SetSource(this, GetDegradationPreference()); |
1729 } | 1729 } |
1730 return true; | 1730 return true; |
1731 } | 1731 } |
1732 | 1732 |
1733 webrtc::VideoSendStream::DegradationPreference | 1733 webrtc::VideoSendStream::DegradationPreference |
1734 WebRtcVideoChannel2::WebRtcVideoSendStream::GetDegradationPreference() const { | 1734 WebRtcVideoChannel::WebRtcVideoSendStream::GetDegradationPreference() const { |
1735 // Do not adapt resolution for screen content as this will likely | 1735 // Do not adapt resolution for screen content as this will likely |
1736 // result in blurry and unreadable text. | 1736 // result in blurry and unreadable text. |
1737 // |this| acts like a VideoSource to make sure SinkWants are handled on the | 1737 // |this| acts like a VideoSource to make sure SinkWants are handled on the |
1738 // correct thread. | 1738 // correct thread. |
1739 DegradationPreference degradation_preference; | 1739 DegradationPreference degradation_preference; |
1740 if (!enable_cpu_overuse_detection_) { | 1740 if (!enable_cpu_overuse_detection_) { |
1741 degradation_preference = DegradationPreference::kDegradationDisabled; | 1741 degradation_preference = DegradationPreference::kDegradationDisabled; |
1742 } else { | 1742 } else { |
1743 if (parameters_.options.is_screencast.value_or(false)) { | 1743 if (parameters_.options.is_screencast.value_or(false)) { |
1744 degradation_preference = DegradationPreference::kMaintainResolution; | 1744 degradation_preference = DegradationPreference::kMaintainResolution; |
1745 } else { | 1745 } else { |
1746 degradation_preference = DegradationPreference::kMaintainFramerate; | 1746 degradation_preference = DegradationPreference::kMaintainFramerate; |
1747 } | 1747 } |
1748 } | 1748 } |
1749 return degradation_preference; | 1749 return degradation_preference; |
1750 } | 1750 } |
1751 | 1751 |
1752 const std::vector<uint32_t>& | 1752 const std::vector<uint32_t>& |
1753 WebRtcVideoChannel2::WebRtcVideoSendStream::GetSsrcs() const { | 1753 WebRtcVideoChannel::WebRtcVideoSendStream::GetSsrcs() const { |
1754 return ssrcs_; | 1754 return ssrcs_; |
1755 } | 1755 } |
1756 | 1756 |
1757 WebRtcVideoChannel2::WebRtcVideoSendStream::AllocatedEncoder | 1757 WebRtcVideoChannel::WebRtcVideoSendStream::AllocatedEncoder |
1758 WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoder( | 1758 WebRtcVideoChannel::WebRtcVideoSendStream::CreateVideoEncoder( |
1759 const VideoCodec& codec, | 1759 const VideoCodec& codec, |
1760 bool force_encoder_allocation) { | 1760 bool force_encoder_allocation) { |
1761 RTC_DCHECK_RUN_ON(&thread_checker_); | 1761 RTC_DCHECK_RUN_ON(&thread_checker_); |
1762 // Do not re-create encoders of the same type. | 1762 // Do not re-create encoders of the same type. |
1763 if (!force_encoder_allocation && codec == allocated_encoder_.codec && | 1763 if (!force_encoder_allocation && codec == allocated_encoder_.codec && |
1764 allocated_encoder_.encoder != nullptr) { | 1764 allocated_encoder_.encoder != nullptr) { |
1765 return allocated_encoder_; | 1765 return allocated_encoder_; |
1766 } | 1766 } |
1767 | 1767 |
1768 // Try creating external encoder. | 1768 // Try creating external encoder. |
(...skipping 21 matching lines...) Expand all Loading... |
1790 internal_encoder_factory_->CreateVideoEncoder(codec), codec, | 1790 internal_encoder_factory_->CreateVideoEncoder(codec), codec, |
1791 false /* is_external */); | 1791 false /* is_external */); |
1792 } | 1792 } |
1793 | 1793 |
1794 // This shouldn't happen, we should not be trying to create something we don't | 1794 // This shouldn't happen, we should not be trying to create something we don't |
1795 // support. | 1795 // support. |
1796 RTC_NOTREACHED(); | 1796 RTC_NOTREACHED(); |
1797 return AllocatedEncoder(NULL, cricket::VideoCodec(), false); | 1797 return AllocatedEncoder(NULL, cricket::VideoCodec(), false); |
1798 } | 1798 } |
1799 | 1799 |
1800 void WebRtcVideoChannel2::WebRtcVideoSendStream::DestroyVideoEncoder( | 1800 void WebRtcVideoChannel::WebRtcVideoSendStream::DestroyVideoEncoder( |
1801 AllocatedEncoder* encoder) { | 1801 AllocatedEncoder* encoder) { |
1802 RTC_DCHECK_RUN_ON(&thread_checker_); | 1802 RTC_DCHECK_RUN_ON(&thread_checker_); |
1803 if (encoder->external) { | 1803 if (encoder->external) { |
1804 external_encoder_factory_->DestroyVideoEncoder(encoder->external_encoder); | 1804 external_encoder_factory_->DestroyVideoEncoder(encoder->external_encoder); |
1805 } | 1805 } |
1806 delete encoder->encoder; | 1806 delete encoder->encoder; |
1807 } | 1807 } |
1808 | 1808 |
1809 void WebRtcVideoChannel2::WebRtcVideoSendStream::SetCodec( | 1809 void WebRtcVideoChannel::WebRtcVideoSendStream::SetCodec( |
1810 const VideoCodecSettings& codec_settings, | 1810 const VideoCodecSettings& codec_settings, |
1811 bool force_encoder_allocation) { | 1811 bool force_encoder_allocation) { |
1812 RTC_DCHECK_RUN_ON(&thread_checker_); | 1812 RTC_DCHECK_RUN_ON(&thread_checker_); |
1813 parameters_.encoder_config = CreateVideoEncoderConfig(codec_settings.codec); | 1813 parameters_.encoder_config = CreateVideoEncoderConfig(codec_settings.codec); |
1814 RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0); | 1814 RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0); |
1815 | 1815 |
1816 AllocatedEncoder new_encoder = | 1816 AllocatedEncoder new_encoder = |
1817 CreateVideoEncoder(codec_settings.codec, force_encoder_allocation); | 1817 CreateVideoEncoder(codec_settings.codec, force_encoder_allocation); |
1818 parameters_.config.encoder_settings.encoder = new_encoder.encoder; | 1818 parameters_.config.encoder_settings.encoder = new_encoder.encoder; |
1819 parameters_.config.encoder_settings.full_overuse_time = new_encoder.external; | 1819 parameters_.config.encoder_settings.full_overuse_time = new_encoder.external; |
(...skipping 20 matching lines...) Expand all Loading... |
1840 parameters_.config.rtp.rtx.ssrcs.clear(); | 1840 parameters_.config.rtp.rtx.ssrcs.clear(); |
1841 } else { | 1841 } else { |
1842 parameters_.config.rtp.rtx.payload_type = codec_settings.rtx_payload_type; | 1842 parameters_.config.rtp.rtx.payload_type = codec_settings.rtx_payload_type; |
1843 } | 1843 } |
1844 } | 1844 } |
1845 | 1845 |
1846 parameters_.config.rtp.nack.rtp_history_ms = | 1846 parameters_.config.rtp.nack.rtp_history_ms = |
1847 HasNack(codec_settings.codec) ? kNackHistoryMs : 0; | 1847 HasNack(codec_settings.codec) ? kNackHistoryMs : 0; |
1848 | 1848 |
1849 parameters_.codec_settings = | 1849 parameters_.codec_settings = |
1850 rtc::Optional<WebRtcVideoChannel2::VideoCodecSettings>(codec_settings); | 1850 rtc::Optional<WebRtcVideoChannel::VideoCodecSettings>(codec_settings); |
1851 | 1851 |
1852 LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetCodec."; | 1852 LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetCodec."; |
1853 RecreateWebRtcStream(); | 1853 RecreateWebRtcStream(); |
1854 if (allocated_encoder_.encoder != new_encoder.encoder) { | 1854 if (allocated_encoder_.encoder != new_encoder.encoder) { |
1855 DestroyVideoEncoder(&allocated_encoder_); | 1855 DestroyVideoEncoder(&allocated_encoder_); |
1856 allocated_encoder_ = new_encoder; | 1856 allocated_encoder_ = new_encoder; |
1857 } | 1857 } |
1858 } | 1858 } |
1859 | 1859 |
1860 void WebRtcVideoChannel2::WebRtcVideoSendStream::SetSendParameters( | 1860 void WebRtcVideoChannel::WebRtcVideoSendStream::SetSendParameters( |
1861 const ChangedSendParameters& params) { | 1861 const ChangedSendParameters& params) { |
1862 RTC_DCHECK_RUN_ON(&thread_checker_); | 1862 RTC_DCHECK_RUN_ON(&thread_checker_); |
1863 // |recreate_stream| means construction-time parameters have changed and the | 1863 // |recreate_stream| means construction-time parameters have changed and the |
1864 // sending stream needs to be reset with the new config. | 1864 // sending stream needs to be reset with the new config. |
1865 bool recreate_stream = false; | 1865 bool recreate_stream = false; |
1866 if (params.rtcp_mode) { | 1866 if (params.rtcp_mode) { |
1867 parameters_.config.rtp.rtcp_mode = *params.rtcp_mode; | 1867 parameters_.config.rtp.rtcp_mode = *params.rtcp_mode; |
1868 recreate_stream = true; | 1868 recreate_stream = true; |
1869 } | 1869 } |
1870 if (params.rtp_header_extensions) { | 1870 if (params.rtp_header_extensions) { |
(...skipping 17 matching lines...) Expand all Loading... |
1888 bool force_encoder_allocation = false; | 1888 bool force_encoder_allocation = false; |
1889 SetCodec(*parameters_.codec_settings, force_encoder_allocation); | 1889 SetCodec(*parameters_.codec_settings, force_encoder_allocation); |
1890 recreate_stream = false; // SetCodec has already recreated the stream. | 1890 recreate_stream = false; // SetCodec has already recreated the stream. |
1891 } | 1891 } |
1892 if (recreate_stream) { | 1892 if (recreate_stream) { |
1893 LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetSendParameters"; | 1893 LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetSendParameters"; |
1894 RecreateWebRtcStream(); | 1894 RecreateWebRtcStream(); |
1895 } | 1895 } |
1896 } | 1896 } |
1897 | 1897 |
1898 bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetRtpParameters( | 1898 bool WebRtcVideoChannel::WebRtcVideoSendStream::SetRtpParameters( |
1899 const webrtc::RtpParameters& new_parameters) { | 1899 const webrtc::RtpParameters& new_parameters) { |
1900 RTC_DCHECK_RUN_ON(&thread_checker_); | 1900 RTC_DCHECK_RUN_ON(&thread_checker_); |
1901 if (!ValidateRtpParameters(new_parameters)) { | 1901 if (!ValidateRtpParameters(new_parameters)) { |
1902 return false; | 1902 return false; |
1903 } | 1903 } |
1904 | 1904 |
1905 bool reconfigure_encoder = new_parameters.encodings[0].max_bitrate_bps != | 1905 bool reconfigure_encoder = new_parameters.encodings[0].max_bitrate_bps != |
1906 rtp_parameters_.encodings[0].max_bitrate_bps; | 1906 rtp_parameters_.encodings[0].max_bitrate_bps; |
1907 rtp_parameters_ = new_parameters; | 1907 rtp_parameters_ = new_parameters; |
1908 // Codecs are currently handled at the WebRtcVideoChannel2 level. | 1908 // Codecs are currently handled at the WebRtcVideoChannel level. |
1909 rtp_parameters_.codecs.clear(); | 1909 rtp_parameters_.codecs.clear(); |
1910 if (reconfigure_encoder) { | 1910 if (reconfigure_encoder) { |
1911 ReconfigureEncoder(); | 1911 ReconfigureEncoder(); |
1912 } | 1912 } |
1913 // Encoding may have been activated/deactivated. | 1913 // Encoding may have been activated/deactivated. |
1914 UpdateSendState(); | 1914 UpdateSendState(); |
1915 return true; | 1915 return true; |
1916 } | 1916 } |
1917 | 1917 |
1918 webrtc::RtpParameters | 1918 webrtc::RtpParameters |
1919 WebRtcVideoChannel2::WebRtcVideoSendStream::GetRtpParameters() const { | 1919 WebRtcVideoChannel::WebRtcVideoSendStream::GetRtpParameters() const { |
1920 RTC_DCHECK_RUN_ON(&thread_checker_); | 1920 RTC_DCHECK_RUN_ON(&thread_checker_); |
1921 return rtp_parameters_; | 1921 return rtp_parameters_; |
1922 } | 1922 } |
1923 | 1923 |
1924 bool WebRtcVideoChannel2::WebRtcVideoSendStream::ValidateRtpParameters( | 1924 bool WebRtcVideoChannel::WebRtcVideoSendStream::ValidateRtpParameters( |
1925 const webrtc::RtpParameters& rtp_parameters) { | 1925 const webrtc::RtpParameters& rtp_parameters) { |
1926 RTC_DCHECK_RUN_ON(&thread_checker_); | 1926 RTC_DCHECK_RUN_ON(&thread_checker_); |
1927 if (rtp_parameters.encodings.size() != 1) { | 1927 if (rtp_parameters.encodings.size() != 1) { |
1928 LOG(LS_ERROR) | 1928 LOG(LS_ERROR) |
1929 << "Attempted to set RtpParameters without exactly one encoding"; | 1929 << "Attempted to set RtpParameters without exactly one encoding"; |
1930 return false; | 1930 return false; |
1931 } | 1931 } |
1932 if (rtp_parameters.encodings[0].ssrc != rtp_parameters_.encodings[0].ssrc) { | 1932 if (rtp_parameters.encodings[0].ssrc != rtp_parameters_.encodings[0].ssrc) { |
1933 LOG(LS_ERROR) << "Attempted to set RtpParameters with modified SSRC"; | 1933 LOG(LS_ERROR) << "Attempted to set RtpParameters with modified SSRC"; |
1934 return false; | 1934 return false; |
1935 } | 1935 } |
1936 return true; | 1936 return true; |
1937 } | 1937 } |
1938 | 1938 |
1939 void WebRtcVideoChannel2::WebRtcVideoSendStream::UpdateSendState() { | 1939 void WebRtcVideoChannel::WebRtcVideoSendStream::UpdateSendState() { |
1940 RTC_DCHECK_RUN_ON(&thread_checker_); | 1940 RTC_DCHECK_RUN_ON(&thread_checker_); |
1941 // TODO(deadbeef): Need to handle more than one encoding in the future. | 1941 // TODO(deadbeef): Need to handle more than one encoding in the future. |
1942 RTC_DCHECK(rtp_parameters_.encodings.size() == 1u); | 1942 RTC_DCHECK(rtp_parameters_.encodings.size() == 1u); |
1943 if (sending_ && rtp_parameters_.encodings[0].active) { | 1943 if (sending_ && rtp_parameters_.encodings[0].active) { |
1944 RTC_DCHECK(stream_ != nullptr); | 1944 RTC_DCHECK(stream_ != nullptr); |
1945 stream_->Start(); | 1945 stream_->Start(); |
1946 } else { | 1946 } else { |
1947 if (stream_ != nullptr) { | 1947 if (stream_ != nullptr) { |
1948 stream_->Stop(); | 1948 stream_->Stop(); |
1949 } | 1949 } |
1950 } | 1950 } |
1951 } | 1951 } |
1952 | 1952 |
1953 webrtc::VideoEncoderConfig | 1953 webrtc::VideoEncoderConfig |
1954 WebRtcVideoChannel2::WebRtcVideoSendStream::CreateVideoEncoderConfig( | 1954 WebRtcVideoChannel::WebRtcVideoSendStream::CreateVideoEncoderConfig( |
1955 const VideoCodec& codec) const { | 1955 const VideoCodec& codec) const { |
1956 RTC_DCHECK_RUN_ON(&thread_checker_); | 1956 RTC_DCHECK_RUN_ON(&thread_checker_); |
1957 webrtc::VideoEncoderConfig encoder_config; | 1957 webrtc::VideoEncoderConfig encoder_config; |
1958 bool is_screencast = parameters_.options.is_screencast.value_or(false); | 1958 bool is_screencast = parameters_.options.is_screencast.value_or(false); |
1959 if (is_screencast) { | 1959 if (is_screencast) { |
1960 encoder_config.min_transmit_bitrate_bps = | 1960 encoder_config.min_transmit_bitrate_bps = |
1961 1000 * parameters_.options.screencast_min_bitrate_kbps.value_or(0); | 1961 1000 * parameters_.options.screencast_min_bitrate_kbps.value_or(0); |
1962 encoder_config.content_type = | 1962 encoder_config.content_type = |
1963 webrtc::VideoEncoderConfig::ContentType::kScreen; | 1963 webrtc::VideoEncoderConfig::ContentType::kScreen; |
1964 } else { | 1964 } else { |
(...skipping 28 matching lines...) Expand all Loading... |
1993 | 1993 |
1994 int max_qp = kDefaultQpMax; | 1994 int max_qp = kDefaultQpMax; |
1995 codec.GetParam(kCodecParamMaxQuantization, &max_qp); | 1995 codec.GetParam(kCodecParamMaxQuantization, &max_qp); |
1996 encoder_config.video_stream_factory = | 1996 encoder_config.video_stream_factory = |
1997 new rtc::RefCountedObject<EncoderStreamFactory>( | 1997 new rtc::RefCountedObject<EncoderStreamFactory>( |
1998 codec.name, max_qp, kDefaultVideoMaxFramerate, is_screencast, | 1998 codec.name, max_qp, kDefaultVideoMaxFramerate, is_screencast, |
1999 parameters_.conference_mode); | 1999 parameters_.conference_mode); |
2000 return encoder_config; | 2000 return encoder_config; |
2001 } | 2001 } |
2002 | 2002 |
2003 void WebRtcVideoChannel2::WebRtcVideoSendStream::ReconfigureEncoder() { | 2003 void WebRtcVideoChannel::WebRtcVideoSendStream::ReconfigureEncoder() { |
2004 RTC_DCHECK_RUN_ON(&thread_checker_); | 2004 RTC_DCHECK_RUN_ON(&thread_checker_); |
2005 if (!stream_) { | 2005 if (!stream_) { |
2006 // The webrtc::VideoSendStream |stream_| has not yet been created but other | 2006 // The webrtc::VideoSendStream |stream_| has not yet been created but other |
2007 // parameters has changed. | 2007 // parameters has changed. |
2008 return; | 2008 return; |
2009 } | 2009 } |
2010 | 2010 |
2011 RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0); | 2011 RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0); |
2012 | 2012 |
2013 RTC_CHECK(parameters_.codec_settings); | 2013 RTC_CHECK(parameters_.codec_settings); |
2014 VideoCodecSettings codec_settings = *parameters_.codec_settings; | 2014 VideoCodecSettings codec_settings = *parameters_.codec_settings; |
2015 | 2015 |
2016 webrtc::VideoEncoderConfig encoder_config = | 2016 webrtc::VideoEncoderConfig encoder_config = |
2017 CreateVideoEncoderConfig(codec_settings.codec); | 2017 CreateVideoEncoderConfig(codec_settings.codec); |
2018 | 2018 |
2019 encoder_config.encoder_specific_settings = ConfigureVideoEncoderSettings( | 2019 encoder_config.encoder_specific_settings = ConfigureVideoEncoderSettings( |
2020 codec_settings.codec); | 2020 codec_settings.codec); |
2021 | 2021 |
2022 stream_->ReconfigureVideoEncoder(encoder_config.Copy()); | 2022 stream_->ReconfigureVideoEncoder(encoder_config.Copy()); |
2023 | 2023 |
2024 encoder_config.encoder_specific_settings = NULL; | 2024 encoder_config.encoder_specific_settings = NULL; |
2025 | 2025 |
2026 parameters_.encoder_config = std::move(encoder_config); | 2026 parameters_.encoder_config = std::move(encoder_config); |
2027 } | 2027 } |
2028 | 2028 |
2029 void WebRtcVideoChannel2::WebRtcVideoSendStream::SetSend(bool send) { | 2029 void WebRtcVideoChannel::WebRtcVideoSendStream::SetSend(bool send) { |
2030 RTC_DCHECK_RUN_ON(&thread_checker_); | 2030 RTC_DCHECK_RUN_ON(&thread_checker_); |
2031 sending_ = send; | 2031 sending_ = send; |
2032 UpdateSendState(); | 2032 UpdateSendState(); |
2033 } | 2033 } |
2034 | 2034 |
2035 void WebRtcVideoChannel2::WebRtcVideoSendStream::RemoveSink( | 2035 void WebRtcVideoChannel::WebRtcVideoSendStream::RemoveSink( |
2036 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) { | 2036 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) { |
2037 RTC_DCHECK_RUN_ON(&thread_checker_); | 2037 RTC_DCHECK_RUN_ON(&thread_checker_); |
2038 RTC_DCHECK(encoder_sink_ == sink); | 2038 RTC_DCHECK(encoder_sink_ == sink); |
2039 encoder_sink_ = nullptr; | 2039 encoder_sink_ = nullptr; |
2040 source_->RemoveSink(sink); | 2040 source_->RemoveSink(sink); |
2041 } | 2041 } |
2042 | 2042 |
2043 void WebRtcVideoChannel2::WebRtcVideoSendStream::AddOrUpdateSink( | 2043 void WebRtcVideoChannel::WebRtcVideoSendStream::AddOrUpdateSink( |
2044 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink, | 2044 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink, |
2045 const rtc::VideoSinkWants& wants) { | 2045 const rtc::VideoSinkWants& wants) { |
2046 if (worker_thread_ == rtc::Thread::Current()) { | 2046 if (worker_thread_ == rtc::Thread::Current()) { |
2047 // AddOrUpdateSink is called on |worker_thread_| if this is the first | 2047 // AddOrUpdateSink is called on |worker_thread_| if this is the first |
2048 // registration of |sink|. | 2048 // registration of |sink|. |
2049 RTC_DCHECK_RUN_ON(&thread_checker_); | 2049 RTC_DCHECK_RUN_ON(&thread_checker_); |
2050 encoder_sink_ = sink; | 2050 encoder_sink_ = sink; |
2051 source_->AddOrUpdateSink(encoder_sink_, wants); | 2051 source_->AddOrUpdateSink(encoder_sink_, wants); |
2052 } else { | 2052 } else { |
2053 // Subsequent calls to AddOrUpdateSink will happen on the encoder task | 2053 // Subsequent calls to AddOrUpdateSink will happen on the encoder task |
2054 // queue. | 2054 // queue. |
2055 invoker_.AsyncInvoke<void>( | 2055 invoker_.AsyncInvoke<void>( |
2056 RTC_FROM_HERE, worker_thread_, [this, sink, wants] { | 2056 RTC_FROM_HERE, worker_thread_, [this, sink, wants] { |
2057 RTC_DCHECK_RUN_ON(&thread_checker_); | 2057 RTC_DCHECK_RUN_ON(&thread_checker_); |
2058 // |sink| may be invalidated after this task was posted since | 2058 // |sink| may be invalidated after this task was posted since |
2059 // RemoveSink is called on the worker thread. | 2059 // RemoveSink is called on the worker thread. |
2060 bool encoder_sink_valid = (sink == encoder_sink_); | 2060 bool encoder_sink_valid = (sink == encoder_sink_); |
2061 if (source_ && encoder_sink_valid) { | 2061 if (source_ && encoder_sink_valid) { |
2062 source_->AddOrUpdateSink(encoder_sink_, wants); | 2062 source_->AddOrUpdateSink(encoder_sink_, wants); |
2063 } | 2063 } |
2064 }); | 2064 }); |
2065 } | 2065 } |
2066 } | 2066 } |
2067 | 2067 |
2068 VideoSenderInfo WebRtcVideoChannel2::WebRtcVideoSendStream::GetVideoSenderInfo( | 2068 VideoSenderInfo WebRtcVideoChannel::WebRtcVideoSendStream::GetVideoSenderInfo( |
2069 bool log_stats) { | 2069 bool log_stats) { |
2070 VideoSenderInfo info; | 2070 VideoSenderInfo info; |
2071 RTC_DCHECK_RUN_ON(&thread_checker_); | 2071 RTC_DCHECK_RUN_ON(&thread_checker_); |
2072 for (uint32_t ssrc : parameters_.config.rtp.ssrcs) | 2072 for (uint32_t ssrc : parameters_.config.rtp.ssrcs) |
2073 info.add_ssrc(ssrc); | 2073 info.add_ssrc(ssrc); |
2074 | 2074 |
2075 if (parameters_.codec_settings) { | 2075 if (parameters_.codec_settings) { |
2076 info.codec_name = parameters_.codec_settings->codec.name; | 2076 info.codec_name = parameters_.codec_settings->codec.name; |
2077 info.codec_payload_type = rtc::Optional<int>( | 2077 info.codec_payload_type = rtc::Optional<int>( |
2078 parameters_.codec_settings->codec.id); | 2078 parameters_.codec_settings->codec.id); |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2135 webrtc::VideoSendStream::StreamStats first_stream_stats = | 2135 webrtc::VideoSendStream::StreamStats first_stream_stats = |
2136 stats.substreams.begin()->second; | 2136 stats.substreams.begin()->second; |
2137 info.fraction_lost = | 2137 info.fraction_lost = |
2138 static_cast<float>(first_stream_stats.rtcp_stats.fraction_lost) / | 2138 static_cast<float>(first_stream_stats.rtcp_stats.fraction_lost) / |
2139 (1 << 8); | 2139 (1 << 8); |
2140 } | 2140 } |
2141 | 2141 |
2142 return info; | 2142 return info; |
2143 } | 2143 } |
2144 | 2144 |
2145 void WebRtcVideoChannel2::WebRtcVideoSendStream::FillBitrateInfo( | 2145 void WebRtcVideoChannel::WebRtcVideoSendStream::FillBitrateInfo( |
2146 BandwidthEstimationInfo* bwe_info) { | 2146 BandwidthEstimationInfo* bwe_info) { |
2147 RTC_DCHECK_RUN_ON(&thread_checker_); | 2147 RTC_DCHECK_RUN_ON(&thread_checker_); |
2148 if (stream_ == NULL) { | 2148 if (stream_ == NULL) { |
2149 return; | 2149 return; |
2150 } | 2150 } |
2151 webrtc::VideoSendStream::Stats stats = stream_->GetStats(); | 2151 webrtc::VideoSendStream::Stats stats = stream_->GetStats(); |
2152 for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it = | 2152 for (std::map<uint32_t, webrtc::VideoSendStream::StreamStats>::iterator it = |
2153 stats.substreams.begin(); | 2153 stats.substreams.begin(); |
2154 it != stats.substreams.end(); ++it) { | 2154 it != stats.substreams.end(); ++it) { |
2155 bwe_info->transmit_bitrate += it->second.total_bitrate_bps; | 2155 bwe_info->transmit_bitrate += it->second.total_bitrate_bps; |
2156 bwe_info->retransmit_bitrate += it->second.retransmit_bitrate_bps; | 2156 bwe_info->retransmit_bitrate += it->second.retransmit_bitrate_bps; |
2157 } | 2157 } |
2158 bwe_info->target_enc_bitrate += stats.target_media_bitrate_bps; | 2158 bwe_info->target_enc_bitrate += stats.target_media_bitrate_bps; |
2159 bwe_info->actual_enc_bitrate += stats.media_bitrate_bps; | 2159 bwe_info->actual_enc_bitrate += stats.media_bitrate_bps; |
2160 } | 2160 } |
2161 | 2161 |
2162 void WebRtcVideoChannel2::WebRtcVideoSendStream::RecreateWebRtcStream() { | 2162 void WebRtcVideoChannel::WebRtcVideoSendStream::RecreateWebRtcStream() { |
2163 RTC_DCHECK_RUN_ON(&thread_checker_); | 2163 RTC_DCHECK_RUN_ON(&thread_checker_); |
2164 if (stream_ != NULL) { | 2164 if (stream_ != NULL) { |
2165 call_->DestroyVideoSendStream(stream_); | 2165 call_->DestroyVideoSendStream(stream_); |
2166 } | 2166 } |
2167 | 2167 |
2168 RTC_CHECK(parameters_.codec_settings); | 2168 RTC_CHECK(parameters_.codec_settings); |
2169 RTC_DCHECK_EQ((parameters_.encoder_config.content_type == | 2169 RTC_DCHECK_EQ((parameters_.encoder_config.content_type == |
2170 webrtc::VideoEncoderConfig::ContentType::kScreen), | 2170 webrtc::VideoEncoderConfig::ContentType::kScreen), |
2171 parameters_.options.is_screencast.value_or(false)) | 2171 parameters_.options.is_screencast.value_or(false)) |
2172 << "encoder content type inconsistent with screencast option"; | 2172 << "encoder content type inconsistent with screencast option"; |
(...skipping 12 matching lines...) Expand all Loading... |
2185 parameters_.encoder_config.encoder_specific_settings = NULL; | 2185 parameters_.encoder_config.encoder_specific_settings = NULL; |
2186 | 2186 |
2187 if (source_) { | 2187 if (source_) { |
2188 stream_->SetSource(this, GetDegradationPreference()); | 2188 stream_->SetSource(this, GetDegradationPreference()); |
2189 } | 2189 } |
2190 | 2190 |
2191 // Call stream_->Start() if necessary conditions are met. | 2191 // Call stream_->Start() if necessary conditions are met. |
2192 UpdateSendState(); | 2192 UpdateSendState(); |
2193 } | 2193 } |
2194 | 2194 |
2195 WebRtcVideoChannel2::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream( | 2195 WebRtcVideoChannel::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream( |
2196 webrtc::Call* call, | 2196 webrtc::Call* call, |
2197 const StreamParams& sp, | 2197 const StreamParams& sp, |
2198 webrtc::VideoReceiveStream::Config config, | 2198 webrtc::VideoReceiveStream::Config config, |
2199 WebRtcVideoDecoderFactory* external_decoder_factory, | 2199 WebRtcVideoDecoderFactory* external_decoder_factory, |
2200 bool default_stream, | 2200 bool default_stream, |
2201 const std::vector<VideoCodecSettings>& recv_codecs, | 2201 const std::vector<VideoCodecSettings>& recv_codecs, |
2202 const webrtc::FlexfecReceiveStream::Config& flexfec_config) | 2202 const webrtc::FlexfecReceiveStream::Config& flexfec_config) |
2203 : call_(call), | 2203 : call_(call), |
2204 stream_params_(sp), | 2204 stream_params_(sp), |
2205 stream_(NULL), | 2205 stream_(NULL), |
2206 default_stream_(default_stream), | 2206 default_stream_(default_stream), |
2207 config_(std::move(config)), | 2207 config_(std::move(config)), |
2208 flexfec_config_(flexfec_config), | 2208 flexfec_config_(flexfec_config), |
2209 flexfec_stream_(nullptr), | 2209 flexfec_stream_(nullptr), |
2210 external_decoder_factory_(external_decoder_factory), | 2210 external_decoder_factory_(external_decoder_factory), |
2211 sink_(NULL), | 2211 sink_(NULL), |
2212 first_frame_timestamp_(-1), | 2212 first_frame_timestamp_(-1), |
2213 estimated_remote_start_ntp_time_ms_(0) { | 2213 estimated_remote_start_ntp_time_ms_(0) { |
2214 config_.renderer = this; | 2214 config_.renderer = this; |
2215 std::vector<AllocatedDecoder> old_decoders; | 2215 std::vector<AllocatedDecoder> old_decoders; |
2216 ConfigureCodecs(recv_codecs, &old_decoders); | 2216 ConfigureCodecs(recv_codecs, &old_decoders); |
2217 ConfigureFlexfecCodec(flexfec_config.payload_type); | 2217 ConfigureFlexfecCodec(flexfec_config.payload_type); |
2218 MaybeRecreateWebRtcFlexfecStream(); | 2218 MaybeRecreateWebRtcFlexfecStream(); |
2219 RecreateWebRtcVideoStream(); | 2219 RecreateWebRtcVideoStream(); |
2220 RTC_DCHECK(old_decoders.empty()); | 2220 RTC_DCHECK(old_decoders.empty()); |
2221 } | 2221 } |
2222 | 2222 |
2223 WebRtcVideoChannel2::WebRtcVideoReceiveStream::AllocatedDecoder:: | 2223 WebRtcVideoChannel::WebRtcVideoReceiveStream::AllocatedDecoder:: |
2224 AllocatedDecoder(webrtc::VideoDecoder* decoder, | 2224 AllocatedDecoder(webrtc::VideoDecoder* decoder, |
2225 webrtc::VideoCodecType type, | 2225 webrtc::VideoCodecType type, |
2226 bool external) | 2226 bool external) |
2227 : decoder(decoder), | 2227 : decoder(decoder), |
2228 external_decoder(nullptr), | 2228 external_decoder(nullptr), |
2229 type(type), | 2229 type(type), |
2230 external(external) { | 2230 external(external) { |
2231 if (external) { | 2231 if (external) { |
2232 external_decoder = decoder; | 2232 external_decoder = decoder; |
2233 this->decoder = | 2233 this->decoder = |
2234 new webrtc::VideoDecoderSoftwareFallbackWrapper(type, external_decoder); | 2234 new webrtc::VideoDecoderSoftwareFallbackWrapper(type, external_decoder); |
2235 } | 2235 } |
2236 } | 2236 } |
2237 | 2237 |
2238 WebRtcVideoChannel2::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() { | 2238 WebRtcVideoChannel::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() { |
2239 if (flexfec_stream_) { | 2239 if (flexfec_stream_) { |
2240 call_->DestroyFlexfecReceiveStream(flexfec_stream_); | 2240 call_->DestroyFlexfecReceiveStream(flexfec_stream_); |
2241 } | 2241 } |
2242 call_->DestroyVideoReceiveStream(stream_); | 2242 call_->DestroyVideoReceiveStream(stream_); |
2243 ClearDecoders(&allocated_decoders_); | 2243 ClearDecoders(&allocated_decoders_); |
2244 } | 2244 } |
2245 | 2245 |
2246 const std::vector<uint32_t>& | 2246 const std::vector<uint32_t>& |
2247 WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetSsrcs() const { | 2247 WebRtcVideoChannel::WebRtcVideoReceiveStream::GetSsrcs() const { |
2248 return stream_params_.ssrcs; | 2248 return stream_params_.ssrcs; |
2249 } | 2249 } |
2250 | 2250 |
2251 rtc::Optional<uint32_t> | 2251 rtc::Optional<uint32_t> |
2252 WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetFirstPrimarySsrc() const { | 2252 WebRtcVideoChannel::WebRtcVideoReceiveStream::GetFirstPrimarySsrc() const { |
2253 std::vector<uint32_t> primary_ssrcs; | 2253 std::vector<uint32_t> primary_ssrcs; |
2254 stream_params_.GetPrimarySsrcs(&primary_ssrcs); | 2254 stream_params_.GetPrimarySsrcs(&primary_ssrcs); |
2255 | 2255 |
2256 if (primary_ssrcs.empty()) { | 2256 if (primary_ssrcs.empty()) { |
2257 LOG(LS_WARNING) << "Empty primary ssrcs vector, returning empty optional"; | 2257 LOG(LS_WARNING) << "Empty primary ssrcs vector, returning empty optional"; |
2258 return rtc::Optional<uint32_t>(); | 2258 return rtc::Optional<uint32_t>(); |
2259 } else { | 2259 } else { |
2260 return rtc::Optional<uint32_t>(primary_ssrcs[0]); | 2260 return rtc::Optional<uint32_t>(primary_ssrcs[0]); |
2261 } | 2261 } |
2262 } | 2262 } |
2263 | 2263 |
2264 WebRtcVideoChannel2::WebRtcVideoReceiveStream::AllocatedDecoder | 2264 WebRtcVideoChannel::WebRtcVideoReceiveStream::AllocatedDecoder |
2265 WebRtcVideoChannel2::WebRtcVideoReceiveStream::CreateOrReuseVideoDecoder( | 2265 WebRtcVideoChannel::WebRtcVideoReceiveStream::CreateOrReuseVideoDecoder( |
2266 std::vector<AllocatedDecoder>* old_decoders, | 2266 std::vector<AllocatedDecoder>* old_decoders, |
2267 const VideoCodec& codec) { | 2267 const VideoCodec& codec) { |
2268 webrtc::VideoCodecType type = webrtc::PayloadNameToCodecType(codec.name) | 2268 webrtc::VideoCodecType type = webrtc::PayloadNameToCodecType(codec.name) |
2269 .value_or(webrtc::kVideoCodecUnknown); | 2269 .value_or(webrtc::kVideoCodecUnknown); |
2270 | 2270 |
2271 for (size_t i = 0; i < old_decoders->size(); ++i) { | 2271 for (size_t i = 0; i < old_decoders->size(); ++i) { |
2272 if ((*old_decoders)[i].type == type) { | 2272 if ((*old_decoders)[i].type == type) { |
2273 AllocatedDecoder decoder = (*old_decoders)[i]; | 2273 AllocatedDecoder decoder = (*old_decoders)[i]; |
2274 (*old_decoders)[i] = old_decoders->back(); | 2274 (*old_decoders)[i] = old_decoders->back(); |
2275 old_decoders->pop_back(); | 2275 old_decoders->pop_back(); |
2276 return decoder; | 2276 return decoder; |
2277 } | 2277 } |
2278 } | 2278 } |
2279 | 2279 |
2280 if (external_decoder_factory_ != NULL) { | 2280 if (external_decoder_factory_ != NULL) { |
2281 webrtc::VideoDecoder* decoder = | 2281 webrtc::VideoDecoder* decoder = |
2282 external_decoder_factory_->CreateVideoDecoderWithParams( | 2282 external_decoder_factory_->CreateVideoDecoderWithParams( |
2283 type, {stream_params_.id}); | 2283 type, {stream_params_.id}); |
2284 if (decoder != NULL) { | 2284 if (decoder != NULL) { |
2285 return AllocatedDecoder(decoder, type, true /* is_external */); | 2285 return AllocatedDecoder(decoder, type, true /* is_external */); |
2286 } | 2286 } |
2287 } | 2287 } |
2288 | 2288 |
2289 InternalDecoderFactory internal_decoder_factory; | 2289 InternalDecoderFactory internal_decoder_factory; |
2290 return AllocatedDecoder(internal_decoder_factory.CreateVideoDecoderWithParams( | 2290 return AllocatedDecoder(internal_decoder_factory.CreateVideoDecoderWithParams( |
2291 type, {stream_params_.id}), | 2291 type, {stream_params_.id}), |
2292 type, false /* is_external */); | 2292 type, false /* is_external */); |
2293 } | 2293 } |
2294 | 2294 |
2295 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::ConfigureCodecs( | 2295 void WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureCodecs( |
2296 const std::vector<VideoCodecSettings>& recv_codecs, | 2296 const std::vector<VideoCodecSettings>& recv_codecs, |
2297 std::vector<AllocatedDecoder>* old_decoders) { | 2297 std::vector<AllocatedDecoder>* old_decoders) { |
2298 *old_decoders = allocated_decoders_; | 2298 *old_decoders = allocated_decoders_; |
2299 allocated_decoders_.clear(); | 2299 allocated_decoders_.clear(); |
2300 config_.decoders.clear(); | 2300 config_.decoders.clear(); |
2301 for (size_t i = 0; i < recv_codecs.size(); ++i) { | 2301 for (size_t i = 0; i < recv_codecs.size(); ++i) { |
2302 AllocatedDecoder allocated_decoder = | 2302 AllocatedDecoder allocated_decoder = |
2303 CreateOrReuseVideoDecoder(old_decoders, recv_codecs[i].codec); | 2303 CreateOrReuseVideoDecoder(old_decoders, recv_codecs[i].codec); |
2304 allocated_decoders_.push_back(allocated_decoder); | 2304 allocated_decoders_.push_back(allocated_decoder); |
2305 | 2305 |
(...skipping 10 matching lines...) Expand all Loading... |
2316 config_.rtp.rtx_payload_types[recv_codec.codec.id] = | 2316 config_.rtp.rtx_payload_types[recv_codec.codec.id] = |
2317 recv_codec.rtx_payload_type; | 2317 recv_codec.rtx_payload_type; |
2318 } | 2318 } |
2319 | 2319 |
2320 config_.rtp.ulpfec = recv_codecs.front().ulpfec; | 2320 config_.rtp.ulpfec = recv_codecs.front().ulpfec; |
2321 | 2321 |
2322 config_.rtp.nack.rtp_history_ms = | 2322 config_.rtp.nack.rtp_history_ms = |
2323 HasNack(recv_codecs.begin()->codec) ? kNackHistoryMs : 0; | 2323 HasNack(recv_codecs.begin()->codec) ? kNackHistoryMs : 0; |
2324 } | 2324 } |
2325 | 2325 |
2326 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::ConfigureFlexfecCodec( | 2326 void WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureFlexfecCodec( |
2327 int flexfec_payload_type) { | 2327 int flexfec_payload_type) { |
2328 flexfec_config_.payload_type = flexfec_payload_type; | 2328 flexfec_config_.payload_type = flexfec_payload_type; |
2329 } | 2329 } |
2330 | 2330 |
2331 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetLocalSsrc( | 2331 void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetLocalSsrc( |
2332 uint32_t local_ssrc) { | 2332 uint32_t local_ssrc) { |
2333 // TODO(pbos): Consider turning this sanity check into a RTC_DCHECK. You | 2333 // TODO(pbos): Consider turning this sanity check into a RTC_DCHECK. You |
2334 // should not be able to create a sender with the same SSRC as a receiver, but | 2334 // should not be able to create a sender with the same SSRC as a receiver, but |
2335 // right now this can't be done due to unittests depending on receiving what | 2335 // right now this can't be done due to unittests depending on receiving what |
2336 // they are sending from the same MediaChannel. | 2336 // they are sending from the same MediaChannel. |
2337 if (local_ssrc == config_.rtp.remote_ssrc) { | 2337 if (local_ssrc == config_.rtp.remote_ssrc) { |
2338 LOG(LS_INFO) << "Ignoring call to SetLocalSsrc because parameters are " | 2338 LOG(LS_INFO) << "Ignoring call to SetLocalSsrc because parameters are " |
2339 "unchanged; local_ssrc=" << local_ssrc; | 2339 "unchanged; local_ssrc=" << local_ssrc; |
2340 return; | 2340 return; |
2341 } | 2341 } |
2342 | 2342 |
2343 config_.rtp.local_ssrc = local_ssrc; | 2343 config_.rtp.local_ssrc = local_ssrc; |
2344 flexfec_config_.local_ssrc = local_ssrc; | 2344 flexfec_config_.local_ssrc = local_ssrc; |
2345 LOG(LS_INFO) | 2345 LOG(LS_INFO) |
2346 << "RecreateWebRtcStream (recv) because of SetLocalSsrc; local_ssrc=" | 2346 << "RecreateWebRtcStream (recv) because of SetLocalSsrc; local_ssrc=" |
2347 << local_ssrc; | 2347 << local_ssrc; |
2348 MaybeRecreateWebRtcFlexfecStream(); | 2348 MaybeRecreateWebRtcFlexfecStream(); |
2349 RecreateWebRtcVideoStream(); | 2349 RecreateWebRtcVideoStream(); |
2350 } | 2350 } |
2351 | 2351 |
2352 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetFeedbackParameters( | 2352 void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetFeedbackParameters( |
2353 bool nack_enabled, | 2353 bool nack_enabled, |
2354 bool remb_enabled, | 2354 bool remb_enabled, |
2355 bool transport_cc_enabled, | 2355 bool transport_cc_enabled, |
2356 webrtc::RtcpMode rtcp_mode) { | 2356 webrtc::RtcpMode rtcp_mode) { |
2357 int nack_history_ms = nack_enabled ? kNackHistoryMs : 0; | 2357 int nack_history_ms = nack_enabled ? kNackHistoryMs : 0; |
2358 if (config_.rtp.nack.rtp_history_ms == nack_history_ms && | 2358 if (config_.rtp.nack.rtp_history_ms == nack_history_ms && |
2359 config_.rtp.remb == remb_enabled && | 2359 config_.rtp.remb == remb_enabled && |
2360 config_.rtp.transport_cc == transport_cc_enabled && | 2360 config_.rtp.transport_cc == transport_cc_enabled && |
2361 config_.rtp.rtcp_mode == rtcp_mode) { | 2361 config_.rtp.rtcp_mode == rtcp_mode) { |
2362 LOG(LS_INFO) | 2362 LOG(LS_INFO) |
(...skipping 12 matching lines...) Expand all Loading... |
2375 flexfec_config_.transport_cc = config_.rtp.transport_cc; | 2375 flexfec_config_.transport_cc = config_.rtp.transport_cc; |
2376 flexfec_config_.rtcp_mode = config_.rtp.rtcp_mode; | 2376 flexfec_config_.rtcp_mode = config_.rtp.rtcp_mode; |
2377 LOG(LS_INFO) | 2377 LOG(LS_INFO) |
2378 << "RecreateWebRtcStream (recv) because of SetFeedbackParameters; nack=" | 2378 << "RecreateWebRtcStream (recv) because of SetFeedbackParameters; nack=" |
2379 << nack_enabled << ", remb=" << remb_enabled | 2379 << nack_enabled << ", remb=" << remb_enabled |
2380 << ", transport_cc=" << transport_cc_enabled; | 2380 << ", transport_cc=" << transport_cc_enabled; |
2381 MaybeRecreateWebRtcFlexfecStream(); | 2381 MaybeRecreateWebRtcFlexfecStream(); |
2382 RecreateWebRtcVideoStream(); | 2382 RecreateWebRtcVideoStream(); |
2383 } | 2383 } |
2384 | 2384 |
2385 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetRecvParameters( | 2385 void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetRecvParameters( |
2386 const ChangedRecvParameters& params) { | 2386 const ChangedRecvParameters& params) { |
2387 bool video_needs_recreation = false; | 2387 bool video_needs_recreation = false; |
2388 bool flexfec_needs_recreation = false; | 2388 bool flexfec_needs_recreation = false; |
2389 std::vector<AllocatedDecoder> old_decoders; | 2389 std::vector<AllocatedDecoder> old_decoders; |
2390 if (params.codec_settings) { | 2390 if (params.codec_settings) { |
2391 ConfigureCodecs(*params.codec_settings, &old_decoders); | 2391 ConfigureCodecs(*params.codec_settings, &old_decoders); |
2392 video_needs_recreation = true; | 2392 video_needs_recreation = true; |
2393 } | 2393 } |
2394 if (params.rtp_header_extensions) { | 2394 if (params.rtp_header_extensions) { |
2395 config_.rtp.extensions = *params.rtp_header_extensions; | 2395 config_.rtp.extensions = *params.rtp_header_extensions; |
(...skipping 11 matching lines...) Expand all Loading... |
2407 MaybeRecreateWebRtcFlexfecStream(); | 2407 MaybeRecreateWebRtcFlexfecStream(); |
2408 } | 2408 } |
2409 if (video_needs_recreation) { | 2409 if (video_needs_recreation) { |
2410 LOG(LS_INFO) | 2410 LOG(LS_INFO) |
2411 << "RecreateWebRtcVideoStream (recv) because of SetRecvParameters"; | 2411 << "RecreateWebRtcVideoStream (recv) because of SetRecvParameters"; |
2412 RecreateWebRtcVideoStream(); | 2412 RecreateWebRtcVideoStream(); |
2413 ClearDecoders(&old_decoders); | 2413 ClearDecoders(&old_decoders); |
2414 } | 2414 } |
2415 } | 2415 } |
2416 | 2416 |
2417 void WebRtcVideoChannel2::WebRtcVideoReceiveStream:: | 2417 void WebRtcVideoChannel::WebRtcVideoReceiveStream:: |
2418 RecreateWebRtcVideoStream() { | 2418 RecreateWebRtcVideoStream() { |
2419 if (stream_) { | 2419 if (stream_) { |
2420 call_->DestroyVideoReceiveStream(stream_); | 2420 call_->DestroyVideoReceiveStream(stream_); |
2421 stream_ = nullptr; | 2421 stream_ = nullptr; |
2422 } | 2422 } |
2423 webrtc::VideoReceiveStream::Config config = config_.Copy(); | 2423 webrtc::VideoReceiveStream::Config config = config_.Copy(); |
2424 config.rtp.protected_by_flexfec = (flexfec_stream_ != nullptr); | 2424 config.rtp.protected_by_flexfec = (flexfec_stream_ != nullptr); |
2425 stream_ = call_->CreateVideoReceiveStream(std::move(config)); | 2425 stream_ = call_->CreateVideoReceiveStream(std::move(config)); |
2426 stream_->Start(); | 2426 stream_->Start(); |
2427 } | 2427 } |
2428 | 2428 |
2429 void WebRtcVideoChannel2::WebRtcVideoReceiveStream:: | 2429 void WebRtcVideoChannel::WebRtcVideoReceiveStream:: |
2430 MaybeRecreateWebRtcFlexfecStream() { | 2430 MaybeRecreateWebRtcFlexfecStream() { |
2431 if (flexfec_stream_) { | 2431 if (flexfec_stream_) { |
2432 call_->DestroyFlexfecReceiveStream(flexfec_stream_); | 2432 call_->DestroyFlexfecReceiveStream(flexfec_stream_); |
2433 flexfec_stream_ = nullptr; | 2433 flexfec_stream_ = nullptr; |
2434 } | 2434 } |
2435 if (flexfec_config_.IsCompleteAndEnabled()) { | 2435 if (flexfec_config_.IsCompleteAndEnabled()) { |
2436 flexfec_stream_ = call_->CreateFlexfecReceiveStream(flexfec_config_); | 2436 flexfec_stream_ = call_->CreateFlexfecReceiveStream(flexfec_config_); |
2437 flexfec_stream_->Start(); | 2437 flexfec_stream_->Start(); |
2438 } | 2438 } |
2439 } | 2439 } |
2440 | 2440 |
2441 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::ClearDecoders( | 2441 void WebRtcVideoChannel::WebRtcVideoReceiveStream::ClearDecoders( |
2442 std::vector<AllocatedDecoder>* allocated_decoders) { | 2442 std::vector<AllocatedDecoder>* allocated_decoders) { |
2443 for (size_t i = 0; i < allocated_decoders->size(); ++i) { | 2443 for (size_t i = 0; i < allocated_decoders->size(); ++i) { |
2444 if ((*allocated_decoders)[i].external) { | 2444 if ((*allocated_decoders)[i].external) { |
2445 external_decoder_factory_->DestroyVideoDecoder( | 2445 external_decoder_factory_->DestroyVideoDecoder( |
2446 (*allocated_decoders)[i].external_decoder); | 2446 (*allocated_decoders)[i].external_decoder); |
2447 } | 2447 } |
2448 delete (*allocated_decoders)[i].decoder; | 2448 delete (*allocated_decoders)[i].decoder; |
2449 } | 2449 } |
2450 allocated_decoders->clear(); | 2450 allocated_decoders->clear(); |
2451 } | 2451 } |
2452 | 2452 |
2453 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::OnFrame( | 2453 void WebRtcVideoChannel::WebRtcVideoReceiveStream::OnFrame( |
2454 const webrtc::VideoFrame& frame) { | 2454 const webrtc::VideoFrame& frame) { |
2455 rtc::CritScope crit(&sink_lock_); | 2455 rtc::CritScope crit(&sink_lock_); |
2456 | 2456 |
2457 if (first_frame_timestamp_ < 0) | 2457 if (first_frame_timestamp_ < 0) |
2458 first_frame_timestamp_ = frame.timestamp(); | 2458 first_frame_timestamp_ = frame.timestamp(); |
2459 int64_t rtp_time_elapsed_since_first_frame = | 2459 int64_t rtp_time_elapsed_since_first_frame = |
2460 (timestamp_wraparound_handler_.Unwrap(frame.timestamp()) - | 2460 (timestamp_wraparound_handler_.Unwrap(frame.timestamp()) - |
2461 first_frame_timestamp_); | 2461 first_frame_timestamp_); |
2462 int64_t elapsed_time_ms = rtp_time_elapsed_since_first_frame / | 2462 int64_t elapsed_time_ms = rtp_time_elapsed_since_first_frame / |
2463 (cricket::kVideoCodecClockrate / 1000); | 2463 (cricket::kVideoCodecClockrate / 1000); |
2464 if (frame.ntp_time_ms() > 0) | 2464 if (frame.ntp_time_ms() > 0) |
2465 estimated_remote_start_ntp_time_ms_ = frame.ntp_time_ms() - elapsed_time_ms; | 2465 estimated_remote_start_ntp_time_ms_ = frame.ntp_time_ms() - elapsed_time_ms; |
2466 | 2466 |
2467 if (sink_ == NULL) { | 2467 if (sink_ == NULL) { |
2468 LOG(LS_WARNING) << "VideoReceiveStream not connected to a VideoSink."; | 2468 LOG(LS_WARNING) << "VideoReceiveStream not connected to a VideoSink."; |
2469 return; | 2469 return; |
2470 } | 2470 } |
2471 | 2471 |
2472 sink_->OnFrame(frame); | 2472 sink_->OnFrame(frame); |
2473 } | 2473 } |
2474 | 2474 |
2475 bool WebRtcVideoChannel2::WebRtcVideoReceiveStream::IsDefaultStream() const { | 2475 bool WebRtcVideoChannel::WebRtcVideoReceiveStream::IsDefaultStream() const { |
2476 return default_stream_; | 2476 return default_stream_; |
2477 } | 2477 } |
2478 | 2478 |
2479 void WebRtcVideoChannel2::WebRtcVideoReceiveStream::SetSink( | 2479 void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetSink( |
2480 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) { | 2480 rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) { |
2481 rtc::CritScope crit(&sink_lock_); | 2481 rtc::CritScope crit(&sink_lock_); |
2482 sink_ = sink; | 2482 sink_ = sink; |
2483 } | 2483 } |
2484 | 2484 |
2485 std::string | 2485 std::string |
2486 WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetCodecNameFromPayloadType( | 2486 WebRtcVideoChannel::WebRtcVideoReceiveStream::GetCodecNameFromPayloadType( |
2487 int payload_type) { | 2487 int payload_type) { |
2488 for (const webrtc::VideoReceiveStream::Decoder& decoder : config_.decoders) { | 2488 for (const webrtc::VideoReceiveStream::Decoder& decoder : config_.decoders) { |
2489 if (decoder.payload_type == payload_type) { | 2489 if (decoder.payload_type == payload_type) { |
2490 return decoder.payload_name; | 2490 return decoder.payload_name; |
2491 } | 2491 } |
2492 } | 2492 } |
2493 return ""; | 2493 return ""; |
2494 } | 2494 } |
2495 | 2495 |
2496 VideoReceiverInfo | 2496 VideoReceiverInfo |
2497 WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetVideoReceiverInfo( | 2497 WebRtcVideoChannel::WebRtcVideoReceiveStream::GetVideoReceiverInfo( |
2498 bool log_stats) { | 2498 bool log_stats) { |
2499 VideoReceiverInfo info; | 2499 VideoReceiverInfo info; |
2500 info.ssrc_groups = stream_params_.ssrc_groups; | 2500 info.ssrc_groups = stream_params_.ssrc_groups; |
2501 info.add_ssrc(config_.rtp.remote_ssrc); | 2501 info.add_ssrc(config_.rtp.remote_ssrc); |
2502 webrtc::VideoReceiveStream::Stats stats = stream_->GetStats(); | 2502 webrtc::VideoReceiveStream::Stats stats = stream_->GetStats(); |
2503 info.decoder_implementation_name = stats.decoder_implementation_name; | 2503 info.decoder_implementation_name = stats.decoder_implementation_name; |
2504 if (stats.current_payload_type != -1) { | 2504 if (stats.current_payload_type != -1) { |
2505 info.codec_payload_type = rtc::Optional<int>( | 2505 info.codec_payload_type = rtc::Optional<int>( |
2506 stats.current_payload_type); | 2506 stats.current_payload_type); |
2507 } | 2507 } |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2542 info.firs_sent = stats.rtcp_packet_type_counts.fir_packets; | 2542 info.firs_sent = stats.rtcp_packet_type_counts.fir_packets; |
2543 info.plis_sent = stats.rtcp_packet_type_counts.pli_packets; | 2543 info.plis_sent = stats.rtcp_packet_type_counts.pli_packets; |
2544 info.nacks_sent = stats.rtcp_packet_type_counts.nack_packets; | 2544 info.nacks_sent = stats.rtcp_packet_type_counts.nack_packets; |
2545 | 2545 |
2546 if (log_stats) | 2546 if (log_stats) |
2547 LOG(LS_INFO) << stats.ToString(rtc::TimeMillis()); | 2547 LOG(LS_INFO) << stats.ToString(rtc::TimeMillis()); |
2548 | 2548 |
2549 return info; | 2549 return info; |
2550 } | 2550 } |
2551 | 2551 |
2552 WebRtcVideoChannel2::VideoCodecSettings::VideoCodecSettings() | 2552 WebRtcVideoChannel::VideoCodecSettings::VideoCodecSettings() |
2553 : flexfec_payload_type(-1), rtx_payload_type(-1) {} | 2553 : flexfec_payload_type(-1), rtx_payload_type(-1) {} |
2554 | 2554 |
2555 bool WebRtcVideoChannel2::VideoCodecSettings::operator==( | 2555 bool WebRtcVideoChannel::VideoCodecSettings::operator==( |
2556 const WebRtcVideoChannel2::VideoCodecSettings& other) const { | 2556 const WebRtcVideoChannel::VideoCodecSettings& other) const { |
2557 return codec == other.codec && ulpfec == other.ulpfec && | 2557 return codec == other.codec && ulpfec == other.ulpfec && |
2558 flexfec_payload_type == other.flexfec_payload_type && | 2558 flexfec_payload_type == other.flexfec_payload_type && |
2559 rtx_payload_type == other.rtx_payload_type; | 2559 rtx_payload_type == other.rtx_payload_type; |
2560 } | 2560 } |
2561 | 2561 |
2562 bool WebRtcVideoChannel2::VideoCodecSettings::EqualsDisregardingFlexfec( | 2562 bool WebRtcVideoChannel::VideoCodecSettings::EqualsDisregardingFlexfec( |
2563 const WebRtcVideoChannel2::VideoCodecSettings& a, | 2563 const WebRtcVideoChannel::VideoCodecSettings& a, |
2564 const WebRtcVideoChannel2::VideoCodecSettings& b) { | 2564 const WebRtcVideoChannel::VideoCodecSettings& b) { |
2565 return a.codec == b.codec && a.ulpfec == b.ulpfec && | 2565 return a.codec == b.codec && a.ulpfec == b.ulpfec && |
2566 a.rtx_payload_type == b.rtx_payload_type; | 2566 a.rtx_payload_type == b.rtx_payload_type; |
2567 } | 2567 } |
2568 | 2568 |
2569 bool WebRtcVideoChannel2::VideoCodecSettings::operator!=( | 2569 bool WebRtcVideoChannel::VideoCodecSettings::operator!=( |
2570 const WebRtcVideoChannel2::VideoCodecSettings& other) const { | 2570 const WebRtcVideoChannel::VideoCodecSettings& other) const { |
2571 return !(*this == other); | 2571 return !(*this == other); |
2572 } | 2572 } |
2573 | 2573 |
2574 std::vector<WebRtcVideoChannel2::VideoCodecSettings> | 2574 std::vector<WebRtcVideoChannel::VideoCodecSettings> |
2575 WebRtcVideoChannel2::MapCodecs(const std::vector<VideoCodec>& codecs) { | 2575 WebRtcVideoChannel::MapCodecs(const std::vector<VideoCodec>& codecs) { |
2576 RTC_DCHECK(!codecs.empty()); | 2576 RTC_DCHECK(!codecs.empty()); |
2577 | 2577 |
2578 std::vector<VideoCodecSettings> video_codecs; | 2578 std::vector<VideoCodecSettings> video_codecs; |
2579 std::map<int, bool> payload_used; | 2579 std::map<int, bool> payload_used; |
2580 std::map<int, VideoCodec::CodecType> payload_codec_type; | 2580 std::map<int, VideoCodec::CodecType> payload_codec_type; |
2581 // |rtx_mapping| maps video payload type to rtx payload type. | 2581 // |rtx_mapping| maps video payload type to rtx payload type. |
2582 std::map<int, int> rtx_mapping; | 2582 std::map<int, int> rtx_mapping; |
2583 | 2583 |
2584 webrtc::UlpfecConfig ulpfec_config; | 2584 webrtc::UlpfecConfig ulpfec_config; |
2585 int flexfec_payload_type = -1; | 2585 int flexfec_payload_type = -1; |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2669 rtx_mapping[video_codecs[i].codec.id] != | 2669 rtx_mapping[video_codecs[i].codec.id] != |
2670 ulpfec_config.red_payload_type) { | 2670 ulpfec_config.red_payload_type) { |
2671 video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id]; | 2671 video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id]; |
2672 } | 2672 } |
2673 } | 2673 } |
2674 | 2674 |
2675 return video_codecs; | 2675 return video_codecs; |
2676 } | 2676 } |
2677 | 2677 |
2678 } // namespace cricket | 2678 } // namespace cricket |
OLD | NEW |