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 |
(...skipping 24 matching lines...) Expand all Loading... |
35 #include "webrtc/rtc_base/copyonwritebuffer.h" | 35 #include "webrtc/rtc_base/copyonwritebuffer.h" |
36 #include "webrtc/rtc_base/logging.h" | 36 #include "webrtc/rtc_base/logging.h" |
37 #include "webrtc/rtc_base/stringutils.h" | 37 #include "webrtc/rtc_base/stringutils.h" |
38 #include "webrtc/rtc_base/timeutils.h" | 38 #include "webrtc/rtc_base/timeutils.h" |
39 #include "webrtc/rtc_base/trace_event.h" | 39 #include "webrtc/rtc_base/trace_event.h" |
40 #include "webrtc/system_wrappers/include/field_trial.h" | 40 #include "webrtc/system_wrappers/include/field_trial.h" |
41 | 41 |
42 using DegradationPreference = webrtc::VideoSendStream::DegradationPreference; | 42 using DegradationPreference = webrtc::VideoSendStream::DegradationPreference; |
43 | 43 |
44 namespace cricket { | 44 namespace cricket { |
| 45 // This class represents all encoders, i.e. both internal and external. It |
| 46 // serves as a temporary adapter between WebRtcVideoEncoderFactory* and the new |
| 47 // factory interface that is being developed. |
| 48 // TODO(magjed): Remove once WebRtcVideoEncoderFactory* is deprecated and |
| 49 // webrtc:7925 is fixed. |
| 50 class EncoderFactoryAdapter { |
| 51 public: |
| 52 struct AllocatedEncoder { |
| 53 AllocatedEncoder() = default; |
| 54 AllocatedEncoder(std::unique_ptr<webrtc::VideoEncoder> encoder, |
| 55 bool is_hardware_accelerated, |
| 56 bool has_internal_source); |
| 57 |
| 58 std::unique_ptr<webrtc::VideoEncoder> encoder; |
| 59 bool is_hardware_accelerated; |
| 60 bool has_internal_source; |
| 61 }; |
| 62 |
| 63 virtual ~EncoderFactoryAdapter() {} |
| 64 |
| 65 virtual AllocatedEncoder CreateVideoEncoder( |
| 66 const VideoCodec& codec, |
| 67 bool is_conference_mode_screenshare) const = 0; |
| 68 |
| 69 virtual std::vector<VideoCodec> GetSupportedCodecs() const = 0; |
| 70 |
| 71 virtual std::unique_ptr<EncoderFactoryAdapter> clone() const = 0; |
| 72 }; |
| 73 |
45 namespace { | 74 namespace { |
| 75 |
| 76 // Wraps cricket::WebRtcVideoEncoderFactory* into common EncoderFactoryAdapter |
| 77 // interface. |
| 78 // TODO(magjed): Add wrapper class for future webrtc::VideoEncoderFactory |
| 79 // interface, https://bugs.chromium.org/p/webrtc/issues/detail?id=7925. |
| 80 class CricketEncoderFactoryAdapter : public EncoderFactoryAdapter { |
| 81 public: |
| 82 explicit CricketEncoderFactoryAdapter( |
| 83 WebRtcVideoEncoderFactory* external_encoder_factory) |
| 84 : internal_encoder_factory_(new InternalEncoderFactory()), |
| 85 external_encoder_factory_(external_encoder_factory) {} |
| 86 |
| 87 private: |
| 88 explicit CricketEncoderFactoryAdapter( |
| 89 const CricketEncoderFactoryAdapter& other) |
| 90 : CricketEncoderFactoryAdapter(other.external_encoder_factory_) {} |
| 91 |
| 92 AllocatedEncoder CreateVideoEncoder( |
| 93 const VideoCodec& codec, |
| 94 bool is_conference_mode_screenshare) const override; |
| 95 |
| 96 std::vector<VideoCodec> GetSupportedCodecs() const override; |
| 97 |
| 98 std::unique_ptr<EncoderFactoryAdapter> clone() const override { |
| 99 return std::unique_ptr<EncoderFactoryAdapter>( |
| 100 new CricketEncoderFactoryAdapter(*this)); |
| 101 } |
| 102 |
| 103 const std::unique_ptr<WebRtcVideoEncoderFactory> internal_encoder_factory_; |
| 104 WebRtcVideoEncoderFactory* const external_encoder_factory_; |
| 105 }; |
| 106 |
46 // If this field trial is enabled, we will enable sending FlexFEC and disable | 107 // If this field trial is enabled, we will enable sending FlexFEC and disable |
47 // sending ULPFEC whenever the former has been negotiated in the SDPs. | 108 // sending ULPFEC whenever the former has been negotiated in the SDPs. |
48 bool IsFlexfecFieldTrialEnabled() { | 109 bool IsFlexfecFieldTrialEnabled() { |
49 return webrtc::field_trial::IsEnabled("WebRTC-FlexFEC-03"); | 110 return webrtc::field_trial::IsEnabled("WebRTC-FlexFEC-03"); |
50 } | 111 } |
51 | 112 |
52 // If this field trial is enabled, the "flexfec-03" codec may have been | 113 // If this field trial is enabled, the "flexfec-03" codec may have been |
53 // advertised as being supported in the local SDP. That means that we must be | 114 // advertised as being supported in the local SDP. That means that we must be |
54 // ready to receive FlexFEC packets. See internalencoderfactory.cc. | 115 // ready to receive FlexFEC packets. See internalencoderfactory.cc. |
55 bool IsFlexfecAdvertisedFieldTrialEnabled() { | 116 bool IsFlexfecAdvertisedFieldTrialEnabled() { |
(...skipping 143 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
199 | 260 |
200 // This constant is really an on/off, lower-level configurable NACK history | 261 // This constant is really an on/off, lower-level configurable NACK history |
201 // duration hasn't been implemented. | 262 // duration hasn't been implemented. |
202 static const int kNackHistoryMs = 1000; | 263 static const int kNackHistoryMs = 1000; |
203 | 264 |
204 static const int kDefaultRtcpReceiverReportSsrc = 1; | 265 static const int kDefaultRtcpReceiverReportSsrc = 1; |
205 | 266 |
206 // Minimum time interval for logging stats. | 267 // Minimum time interval for logging stats. |
207 static const int64_t kStatsLogIntervalMs = 10000; | 268 static const int64_t kStatsLogIntervalMs = 10000; |
208 | 269 |
209 static std::vector<VideoCodec> GetSupportedCodecs( | |
210 const WebRtcVideoEncoderFactory* external_encoder_factory); | |
211 | |
212 rtc::scoped_refptr<webrtc::VideoEncoderConfig::EncoderSpecificSettings> | 270 rtc::scoped_refptr<webrtc::VideoEncoderConfig::EncoderSpecificSettings> |
213 WebRtcVideoChannel::WebRtcVideoSendStream::ConfigureVideoEncoderSettings( | 271 WebRtcVideoChannel::WebRtcVideoSendStream::ConfigureVideoEncoderSettings( |
214 const VideoCodec& codec) { | 272 const VideoCodec& codec) { |
215 RTC_DCHECK_RUN_ON(&thread_checker_); | 273 RTC_DCHECK_RUN_ON(&thread_checker_); |
216 bool is_screencast = parameters_.options.is_screencast.value_or(false); | 274 bool is_screencast = parameters_.options.is_screencast.value_or(false); |
217 // No automatic resizing when using simulcast or screencast. | 275 // No automatic resizing when using simulcast or screencast. |
218 bool automatic_resize = | 276 bool automatic_resize = |
219 !is_screencast && parameters_.config.rtp.ssrcs.size() == 1; | 277 !is_screencast && parameters_.config.rtp.ssrcs.size() == 1; |
220 bool frame_dropping = !is_screencast; | 278 bool frame_dropping = !is_screencast; |
221 bool denoising; | 279 bool denoising; |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
303 rtc::Optional<uint32_t> default_recv_ssrc = | 361 rtc::Optional<uint32_t> default_recv_ssrc = |
304 channel->GetDefaultReceiveStreamSsrc(); | 362 channel->GetDefaultReceiveStreamSsrc(); |
305 if (default_recv_ssrc) { | 363 if (default_recv_ssrc) { |
306 channel->SetSink(*default_recv_ssrc, default_sink_); | 364 channel->SetSink(*default_recv_ssrc, default_sink_); |
307 } | 365 } |
308 } | 366 } |
309 | 367 |
310 WebRtcVideoEngine::WebRtcVideoEngine() | 368 WebRtcVideoEngine::WebRtcVideoEngine() |
311 : initialized_(false), | 369 : initialized_(false), |
312 external_decoder_factory_(NULL), | 370 external_decoder_factory_(NULL), |
313 external_encoder_factory_(NULL) { | 371 encoder_factory_(new CricketEncoderFactoryAdapter( |
| 372 nullptr /* external_encoder_factory */)) { |
314 LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine()"; | 373 LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine()"; |
315 } | 374 } |
316 | 375 |
317 WebRtcVideoEngine::~WebRtcVideoEngine() { | 376 WebRtcVideoEngine::~WebRtcVideoEngine() { |
318 LOG(LS_INFO) << "WebRtcVideoEngine::~WebRtcVideoEngine"; | 377 LOG(LS_INFO) << "WebRtcVideoEngine::~WebRtcVideoEngine"; |
319 } | 378 } |
320 | 379 |
321 void WebRtcVideoEngine::Init() { | 380 void WebRtcVideoEngine::Init() { |
322 LOG(LS_INFO) << "WebRtcVideoEngine::Init"; | 381 LOG(LS_INFO) << "WebRtcVideoEngine::Init"; |
323 initialized_ = true; | 382 initialized_ = true; |
324 } | 383 } |
325 | 384 |
326 WebRtcVideoChannel* WebRtcVideoEngine::CreateChannel( | 385 WebRtcVideoChannel* WebRtcVideoEngine::CreateChannel( |
327 webrtc::Call* call, | 386 webrtc::Call* call, |
328 const MediaConfig& config, | 387 const MediaConfig& config, |
329 const VideoOptions& options) { | 388 const VideoOptions& options) { |
330 RTC_DCHECK(initialized_); | 389 RTC_DCHECK(initialized_); |
331 LOG(LS_INFO) << "CreateChannel. Options: " << options.ToString(); | 390 LOG(LS_INFO) << "CreateChannel. Options: " << options.ToString(); |
332 return new WebRtcVideoChannel(call, config, options, | 391 return new WebRtcVideoChannel(call, config, options, *encoder_factory_, |
333 external_encoder_factory_, | |
334 external_decoder_factory_); | 392 external_decoder_factory_); |
335 } | 393 } |
336 | 394 |
337 std::vector<VideoCodec> WebRtcVideoEngine::codecs() const { | 395 std::vector<VideoCodec> WebRtcVideoEngine::codecs() const { |
338 return GetSupportedCodecs(external_encoder_factory_); | 396 return encoder_factory_->GetSupportedCodecs(); |
339 } | 397 } |
340 | 398 |
341 RtpCapabilities WebRtcVideoEngine::GetCapabilities() const { | 399 RtpCapabilities WebRtcVideoEngine::GetCapabilities() const { |
342 RtpCapabilities capabilities; | 400 RtpCapabilities capabilities; |
343 capabilities.header_extensions.push_back( | 401 capabilities.header_extensions.push_back( |
344 webrtc::RtpExtension(webrtc::RtpExtension::kTimestampOffsetUri, | 402 webrtc::RtpExtension(webrtc::RtpExtension::kTimestampOffsetUri, |
345 webrtc::RtpExtension::kTimestampOffsetDefaultId)); | 403 webrtc::RtpExtension::kTimestampOffsetDefaultId)); |
346 capabilities.header_extensions.push_back( | 404 capabilities.header_extensions.push_back( |
347 webrtc::RtpExtension(webrtc::RtpExtension::kAbsSendTimeUri, | 405 webrtc::RtpExtension(webrtc::RtpExtension::kAbsSendTimeUri, |
348 webrtc::RtpExtension::kAbsSendTimeDefaultId)); | 406 webrtc::RtpExtension::kAbsSendTimeDefaultId)); |
(...skipping 17 matching lines...) Expand all Loading... |
366 | 424 |
367 void WebRtcVideoEngine::SetExternalDecoderFactory( | 425 void WebRtcVideoEngine::SetExternalDecoderFactory( |
368 WebRtcVideoDecoderFactory* decoder_factory) { | 426 WebRtcVideoDecoderFactory* decoder_factory) { |
369 RTC_DCHECK(!initialized_); | 427 RTC_DCHECK(!initialized_); |
370 external_decoder_factory_ = decoder_factory; | 428 external_decoder_factory_ = decoder_factory; |
371 } | 429 } |
372 | 430 |
373 void WebRtcVideoEngine::SetExternalEncoderFactory( | 431 void WebRtcVideoEngine::SetExternalEncoderFactory( |
374 WebRtcVideoEncoderFactory* encoder_factory) { | 432 WebRtcVideoEncoderFactory* encoder_factory) { |
375 RTC_DCHECK(!initialized_); | 433 RTC_DCHECK(!initialized_); |
376 external_encoder_factory_ = encoder_factory; | 434 encoder_factory_.reset(new CricketEncoderFactoryAdapter(encoder_factory)); |
377 } | 435 } |
378 | 436 |
379 // This is a helper function for AppendVideoCodecs below. It will return the | 437 // This is a helper function for AppendVideoCodecs below. It will return the |
380 // first unused dynamic payload type (in the range [96, 127]), or nothing if no | 438 // first unused dynamic payload type (in the range [96, 127]), or nothing if no |
381 // payload type is unused. | 439 // payload type is unused. |
382 static rtc::Optional<int> NextFreePayloadType( | 440 static rtc::Optional<int> NextFreePayloadType( |
383 const std::vector<VideoCodec>& codecs) { | 441 const std::vector<VideoCodec>& codecs) { |
384 static const int kFirstDynamicPayloadType = 96; | 442 static const int kFirstDynamicPayloadType = 96; |
385 static const int kLastDynamicPayloadType = 127; | 443 static const int kLastDynamicPayloadType = 127; |
386 bool is_payload_used[1 + kLastDynamicPayloadType - kFirstDynamicPayloadType] = | 444 bool is_payload_used[1 + kLastDynamicPayloadType - kFirstDynamicPayloadType] = |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
432 const rtc::Optional<int> rtx_payload_type = | 490 const rtc::Optional<int> rtx_payload_type = |
433 NextFreePayloadType(*unified_codecs); | 491 NextFreePayloadType(*unified_codecs); |
434 if (!rtx_payload_type) | 492 if (!rtx_payload_type) |
435 return; | 493 return; |
436 unified_codecs->push_back( | 494 unified_codecs->push_back( |
437 VideoCodec::CreateRtxCodec(*rtx_payload_type, codec.id)); | 495 VideoCodec::CreateRtxCodec(*rtx_payload_type, codec.id)); |
438 } | 496 } |
439 } | 497 } |
440 } | 498 } |
441 | 499 |
442 static std::vector<VideoCodec> GetSupportedCodecs( | 500 std::vector<VideoCodec> CricketEncoderFactoryAdapter::GetSupportedCodecs() |
443 const WebRtcVideoEncoderFactory* external_encoder_factory) { | 501 const { |
444 const std::vector<VideoCodec> internal_codecs = | 502 const std::vector<VideoCodec> internal_codecs = |
445 InternalEncoderFactory().supported_codecs(); | 503 InternalEncoderFactory().supported_codecs(); |
446 LOG(LS_INFO) << "Internally supported codecs: " | 504 LOG(LS_INFO) << "Internally supported codecs: " |
447 << CodecVectorToString(internal_codecs); | 505 << CodecVectorToString(internal_codecs); |
448 | 506 |
449 std::vector<VideoCodec> unified_codecs; | 507 std::vector<VideoCodec> unified_codecs; |
450 AppendVideoCodecs(internal_codecs, &unified_codecs); | 508 AppendVideoCodecs(internal_codecs, &unified_codecs); |
451 | 509 |
452 if (external_encoder_factory != nullptr) { | 510 if (external_encoder_factory_ != nullptr) { |
453 const std::vector<VideoCodec>& external_codecs = | 511 const std::vector<VideoCodec>& external_codecs = |
454 external_encoder_factory->supported_codecs(); | 512 external_encoder_factory_->supported_codecs(); |
455 AppendVideoCodecs(external_codecs, &unified_codecs); | 513 AppendVideoCodecs(external_codecs, &unified_codecs); |
456 LOG(LS_INFO) << "Codecs supported by the external encoder factory: " | 514 LOG(LS_INFO) << "Codecs supported by the external encoder factory: " |
457 << CodecVectorToString(external_codecs); | 515 << CodecVectorToString(external_codecs); |
458 } | 516 } |
459 | 517 |
460 return unified_codecs; | 518 return unified_codecs; |
461 } | 519 } |
462 | 520 |
463 WebRtcVideoChannel::WebRtcVideoChannel( | 521 WebRtcVideoChannel::WebRtcVideoChannel( |
464 webrtc::Call* call, | 522 webrtc::Call* call, |
465 const MediaConfig& config, | 523 const MediaConfig& config, |
466 const VideoOptions& options, | 524 const VideoOptions& options, |
467 WebRtcVideoEncoderFactory* external_encoder_factory, | 525 const EncoderFactoryAdapter& encoder_factory, |
468 WebRtcVideoDecoderFactory* external_decoder_factory) | 526 WebRtcVideoDecoderFactory* external_decoder_factory) |
469 : VideoMediaChannel(config), | 527 : VideoMediaChannel(config), |
470 call_(call), | 528 call_(call), |
471 unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_), | 529 unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_), |
472 video_config_(config.video), | 530 video_config_(config.video), |
473 external_encoder_factory_(external_encoder_factory), | 531 encoder_factory_(encoder_factory.clone()), |
474 external_decoder_factory_(external_decoder_factory), | 532 external_decoder_factory_(external_decoder_factory), |
475 default_send_options_(options), | 533 default_send_options_(options), |
476 last_stats_log_ms_(-1) { | 534 last_stats_log_ms_(-1) { |
477 RTC_DCHECK(thread_checker_.CalledOnValidThread()); | 535 RTC_DCHECK(thread_checker_.CalledOnValidThread()); |
478 | 536 |
479 rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc; | 537 rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc; |
480 sending_ = false; | 538 sending_ = false; |
481 recv_codecs_ = MapCodecs(GetSupportedCodecs(external_encoder_factory)); | 539 recv_codecs_ = MapCodecs(encoder_factory_->GetSupportedCodecs()); |
482 recv_flexfec_payload_type_ = recv_codecs_.front().flexfec_payload_type; | 540 recv_flexfec_payload_type_ = recv_codecs_.front().flexfec_payload_type; |
483 } | 541 } |
484 | 542 |
485 WebRtcVideoChannel::~WebRtcVideoChannel() { | 543 WebRtcVideoChannel::~WebRtcVideoChannel() { |
486 for (auto& kv : send_streams_) | 544 for (auto& kv : send_streams_) |
487 delete kv.second; | 545 delete kv.second; |
488 for (auto& kv : receive_streams_) | 546 for (auto& kv : receive_streams_) |
489 delete kv.second; | 547 delete kv.second; |
490 } | 548 } |
491 | 549 |
492 rtc::Optional<WebRtcVideoChannel::VideoCodecSettings> | 550 rtc::Optional<WebRtcVideoChannel::VideoCodecSettings> |
493 WebRtcVideoChannel::SelectSendVideoCodec( | 551 WebRtcVideoChannel::SelectSendVideoCodec( |
494 const std::vector<VideoCodecSettings>& remote_mapped_codecs) const { | 552 const std::vector<VideoCodecSettings>& remote_mapped_codecs) const { |
495 const std::vector<VideoCodec> local_supported_codecs = | 553 const std::vector<VideoCodec> local_supported_codecs = |
496 GetSupportedCodecs(external_encoder_factory_); | 554 encoder_factory_->GetSupportedCodecs(); |
497 // Select the first remote codec that is supported locally. | 555 // Select the first remote codec that is supported locally. |
498 for (const VideoCodecSettings& remote_mapped_codec : remote_mapped_codecs) { | 556 for (const VideoCodecSettings& remote_mapped_codec : remote_mapped_codecs) { |
499 // For H264, we will limit the encode level to the remote offered level | 557 // For H264, we will limit the encode level to the remote offered level |
500 // regardless if level asymmetry is allowed or not. This is strictly not | 558 // regardless if level asymmetry is allowed or not. This is strictly not |
501 // following the spec in https://tools.ietf.org/html/rfc6184#section-8.2.2 | 559 // following the spec in https://tools.ietf.org/html/rfc6184#section-8.2.2 |
502 // since we should limit the encode level to the lower of local and remote | 560 // since we should limit the encode level to the lower of local and remote |
503 // level when level asymmetry is not allowed. | 561 // level when level asymmetry is not allowed. |
504 if (FindMatchingCodec(local_supported_codecs, remote_mapped_codec.codec)) | 562 if (FindMatchingCodec(local_supported_codecs, remote_mapped_codec.codec)) |
505 return rtc::Optional<VideoCodecSettings>(remote_mapped_codec); | 563 return rtc::Optional<VideoCodecSettings>(remote_mapped_codec); |
506 } | 564 } |
(...skipping 291 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
798 // Handle receive codecs. | 856 // Handle receive codecs. |
799 const std::vector<VideoCodecSettings> mapped_codecs = | 857 const std::vector<VideoCodecSettings> mapped_codecs = |
800 MapCodecs(params.codecs); | 858 MapCodecs(params.codecs); |
801 if (mapped_codecs.empty()) { | 859 if (mapped_codecs.empty()) { |
802 LOG(LS_ERROR) << "SetRecvParameters called without any video codecs."; | 860 LOG(LS_ERROR) << "SetRecvParameters called without any video codecs."; |
803 return false; | 861 return false; |
804 } | 862 } |
805 | 863 |
806 // Verify that every mapped codec is supported locally. | 864 // Verify that every mapped codec is supported locally. |
807 const std::vector<VideoCodec> local_supported_codecs = | 865 const std::vector<VideoCodec> local_supported_codecs = |
808 GetSupportedCodecs(external_encoder_factory_); | 866 encoder_factory_->GetSupportedCodecs(); |
809 for (const VideoCodecSettings& mapped_codec : mapped_codecs) { | 867 for (const VideoCodecSettings& mapped_codec : mapped_codecs) { |
810 if (!FindMatchingCodec(local_supported_codecs, mapped_codec.codec)) { | 868 if (!FindMatchingCodec(local_supported_codecs, mapped_codec.codec)) { |
811 LOG(LS_ERROR) << "SetRecvParameters called with unsupported video codec: " | 869 LOG(LS_ERROR) << "SetRecvParameters called with unsupported video codec: " |
812 << mapped_codec.codec.ToString(); | 870 << mapped_codec.codec.ToString(); |
813 return false; | 871 return false; |
814 } | 872 } |
815 } | 873 } |
816 | 874 |
817 if (NonFlexfecReceiveCodecsHaveChanged(recv_codecs_, mapped_codecs)) { | 875 if (NonFlexfecReceiveCodecsHaveChanged(recv_codecs_, mapped_codecs)) { |
818 changed_params->codec_settings = | 876 changed_params->codec_settings = |
(...skipping 150 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
969 return false; | 1027 return false; |
970 | 1028 |
971 for (uint32_t used_ssrc : sp.ssrcs) | 1029 for (uint32_t used_ssrc : sp.ssrcs) |
972 send_ssrcs_.insert(used_ssrc); | 1030 send_ssrcs_.insert(used_ssrc); |
973 | 1031 |
974 webrtc::VideoSendStream::Config config(this); | 1032 webrtc::VideoSendStream::Config config(this); |
975 config.suspend_below_min_bitrate = video_config_.suspend_below_min_bitrate; | 1033 config.suspend_below_min_bitrate = video_config_.suspend_below_min_bitrate; |
976 config.periodic_alr_bandwidth_probing = | 1034 config.periodic_alr_bandwidth_probing = |
977 video_config_.periodic_alr_bandwidth_probing; | 1035 video_config_.periodic_alr_bandwidth_probing; |
978 WebRtcVideoSendStream* stream = new WebRtcVideoSendStream( | 1036 WebRtcVideoSendStream* stream = new WebRtcVideoSendStream( |
979 call_, sp, std::move(config), default_send_options_, | 1037 call_, sp, std::move(config), default_send_options_, *encoder_factory_, |
980 external_encoder_factory_, video_config_.enable_cpu_overuse_detection, | 1038 video_config_.enable_cpu_overuse_detection, |
981 bitrate_config_.max_bitrate_bps, send_codec_, send_rtp_extensions_, | 1039 bitrate_config_.max_bitrate_bps, send_codec_, send_rtp_extensions_, |
982 send_params_); | 1040 send_params_); |
983 | 1041 |
984 uint32_t ssrc = sp.first_ssrc(); | 1042 uint32_t ssrc = sp.first_ssrc(); |
985 RTC_DCHECK(ssrc != 0); | 1043 RTC_DCHECK(ssrc != 0); |
986 send_streams_[ssrc] = stream; | 1044 send_streams_[ssrc] = stream; |
987 | 1045 |
988 if (rtcp_receiver_report_ssrc_ == kDefaultRtcpReceiverReportSsrc) { | 1046 if (rtcp_receiver_report_ssrc_ == kDefaultRtcpReceiverReportSsrc) { |
989 rtcp_receiver_report_ssrc_ = ssrc; | 1047 rtcp_receiver_report_ssrc_ = ssrc; |
990 LOG(LS_INFO) << "SetLocalSsrc on all the receive streams because we added " | 1048 LOG(LS_INFO) << "SetLocalSsrc on all the receive streams because we added " |
(...skipping 415 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1406 webrtc::VideoSendStream::Config config, | 1464 webrtc::VideoSendStream::Config config, |
1407 const VideoOptions& options, | 1465 const VideoOptions& options, |
1408 int max_bitrate_bps, | 1466 int max_bitrate_bps, |
1409 const rtc::Optional<VideoCodecSettings>& codec_settings) | 1467 const rtc::Optional<VideoCodecSettings>& codec_settings) |
1410 : config(std::move(config)), | 1468 : config(std::move(config)), |
1411 options(options), | 1469 options(options), |
1412 max_bitrate_bps(max_bitrate_bps), | 1470 max_bitrate_bps(max_bitrate_bps), |
1413 conference_mode(false), | 1471 conference_mode(false), |
1414 codec_settings(codec_settings) {} | 1472 codec_settings(codec_settings) {} |
1415 | 1473 |
1416 WebRtcVideoChannel::WebRtcVideoSendStream::AllocatedEncoder::AllocatedEncoder( | 1474 EncoderFactoryAdapter::AllocatedEncoder::AllocatedEncoder( |
1417 std::unique_ptr<webrtc::VideoEncoder> encoder, | 1475 std::unique_ptr<webrtc::VideoEncoder> encoder, |
1418 bool is_external, | 1476 bool is_hardware_accelerated, |
1419 const cricket::VideoCodec& codec, | |
1420 bool has_internal_source) | 1477 bool has_internal_source) |
1421 : encoder_(std::move(encoder)), | 1478 : encoder(std::move(encoder)), |
1422 is_external_(is_external), | 1479 is_hardware_accelerated(is_hardware_accelerated), |
1423 codec_(codec), | 1480 has_internal_source(has_internal_source) {} |
1424 has_internal_source_(has_internal_source) {} | |
1425 | |
1426 void WebRtcVideoChannel::WebRtcVideoSendStream::AllocatedEncoder::Reset() { | |
1427 encoder_.reset(); | |
1428 codec_ = cricket::VideoCodec(); | |
1429 } | |
1430 | 1481 |
1431 WebRtcVideoChannel::WebRtcVideoSendStream::WebRtcVideoSendStream( | 1482 WebRtcVideoChannel::WebRtcVideoSendStream::WebRtcVideoSendStream( |
1432 webrtc::Call* call, | 1483 webrtc::Call* call, |
1433 const StreamParams& sp, | 1484 const StreamParams& sp, |
1434 webrtc::VideoSendStream::Config config, | 1485 webrtc::VideoSendStream::Config config, |
1435 const VideoOptions& options, | 1486 const VideoOptions& options, |
1436 WebRtcVideoEncoderFactory* external_encoder_factory, | 1487 const EncoderFactoryAdapter& encoder_factory, |
1437 bool enable_cpu_overuse_detection, | 1488 bool enable_cpu_overuse_detection, |
1438 int max_bitrate_bps, | 1489 int max_bitrate_bps, |
1439 const rtc::Optional<VideoCodecSettings>& codec_settings, | 1490 const rtc::Optional<VideoCodecSettings>& codec_settings, |
1440 const rtc::Optional<std::vector<webrtc::RtpExtension>>& rtp_extensions, | 1491 const rtc::Optional<std::vector<webrtc::RtpExtension>>& rtp_extensions, |
1441 // TODO(deadbeef): Don't duplicate information between send_params, | 1492 // TODO(deadbeef): Don't duplicate information between send_params, |
1442 // rtp_extensions, options, etc. | 1493 // rtp_extensions, options, etc. |
1443 const VideoSendParameters& send_params) | 1494 const VideoSendParameters& send_params) |
1444 : worker_thread_(rtc::Thread::Current()), | 1495 : worker_thread_(rtc::Thread::Current()), |
1445 ssrcs_(sp.ssrcs), | 1496 ssrcs_(sp.ssrcs), |
1446 ssrc_groups_(sp.ssrc_groups), | 1497 ssrc_groups_(sp.ssrc_groups), |
1447 call_(call), | 1498 call_(call), |
1448 enable_cpu_overuse_detection_(enable_cpu_overuse_detection), | 1499 enable_cpu_overuse_detection_(enable_cpu_overuse_detection), |
1449 source_(nullptr), | 1500 source_(nullptr), |
1450 external_encoder_factory_(external_encoder_factory), | 1501 encoder_factory_(encoder_factory.clone()), |
1451 internal_encoder_factory_(new InternalEncoderFactory()), | |
1452 stream_(nullptr), | 1502 stream_(nullptr), |
1453 encoder_sink_(nullptr), | 1503 encoder_sink_(nullptr), |
1454 parameters_(std::move(config), options, max_bitrate_bps, codec_settings), | 1504 parameters_(std::move(config), options, max_bitrate_bps, codec_settings), |
1455 rtp_parameters_(CreateRtpParametersWithOneEncoding()), | 1505 rtp_parameters_(CreateRtpParametersWithOneEncoding()), |
1456 sending_(false) { | 1506 sending_(false) { |
1457 parameters_.config.rtp.max_packet_size = kVideoMtu; | 1507 parameters_.config.rtp.max_packet_size = kVideoMtu; |
1458 parameters_.conference_mode = send_params.conference_mode; | 1508 parameters_.conference_mode = send_params.conference_mode; |
1459 | 1509 |
1460 sp.GetPrimarySsrcs(¶meters_.config.rtp.ssrcs); | 1510 sp.GetPrimarySsrcs(¶meters_.config.rtp.ssrcs); |
1461 | 1511 |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1503 bool force_encoder_allocation = false; | 1553 bool force_encoder_allocation = false; |
1504 SetCodec(*codec_settings, force_encoder_allocation); | 1554 SetCodec(*codec_settings, force_encoder_allocation); |
1505 } | 1555 } |
1506 } | 1556 } |
1507 | 1557 |
1508 WebRtcVideoChannel::WebRtcVideoSendStream::~WebRtcVideoSendStream() { | 1558 WebRtcVideoChannel::WebRtcVideoSendStream::~WebRtcVideoSendStream() { |
1509 if (stream_ != NULL) { | 1559 if (stream_ != NULL) { |
1510 call_->DestroyVideoSendStream(stream_); | 1560 call_->DestroyVideoSendStream(stream_); |
1511 } | 1561 } |
1512 // Release |allocated_encoder_|. | 1562 // Release |allocated_encoder_|. |
1513 allocated_encoder_.Reset(); | 1563 allocated_encoder_.reset(); |
1514 } | 1564 } |
1515 | 1565 |
1516 bool WebRtcVideoChannel::WebRtcVideoSendStream::SetVideoSend( | 1566 bool WebRtcVideoChannel::WebRtcVideoSendStream::SetVideoSend( |
1517 bool enable, | 1567 bool enable, |
1518 const VideoOptions* options, | 1568 const VideoOptions* options, |
1519 rtc::VideoSourceInterface<webrtc::VideoFrame>* source) { | 1569 rtc::VideoSourceInterface<webrtc::VideoFrame>* source) { |
1520 TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetVideoSend"); | 1570 TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetVideoSend"); |
1521 RTC_DCHECK_RUN_ON(&thread_checker_); | 1571 RTC_DCHECK_RUN_ON(&thread_checker_); |
1522 | 1572 |
1523 // Ignore |options| pointer if |enable| is false. | 1573 // Ignore |options| pointer if |enable| is false. |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1574 } | 1624 } |
1575 } | 1625 } |
1576 return degradation_preference; | 1626 return degradation_preference; |
1577 } | 1627 } |
1578 | 1628 |
1579 const std::vector<uint32_t>& | 1629 const std::vector<uint32_t>& |
1580 WebRtcVideoChannel::WebRtcVideoSendStream::GetSsrcs() const { | 1630 WebRtcVideoChannel::WebRtcVideoSendStream::GetSsrcs() const { |
1581 return ssrcs_; | 1631 return ssrcs_; |
1582 } | 1632 } |
1583 | 1633 |
1584 WebRtcVideoChannel::WebRtcVideoSendStream::AllocatedEncoder | 1634 EncoderFactoryAdapter::AllocatedEncoder |
1585 WebRtcVideoChannel::WebRtcVideoSendStream::CreateVideoEncoder( | 1635 CricketEncoderFactoryAdapter::CreateVideoEncoder( |
1586 const VideoCodec& codec) { | 1636 const VideoCodec& codec, |
1587 RTC_DCHECK_RUN_ON(&thread_checker_); | 1637 bool is_conference_mode_screenshare) const { |
1588 | |
1589 // Try creating external encoder. | 1638 // Try creating external encoder. |
1590 if (external_encoder_factory_ != nullptr && | 1639 if (external_encoder_factory_ != nullptr && |
1591 FindMatchingCodec(external_encoder_factory_->supported_codecs(), codec)) { | 1640 FindMatchingCodec(external_encoder_factory_->supported_codecs(), codec)) { |
1592 std::unique_ptr<webrtc::VideoEncoder> external_encoder; | 1641 std::unique_ptr<webrtc::VideoEncoder> external_encoder; |
1593 if (CodecNamesEq(codec.name.c_str(), kVp8CodecName)) { | 1642 if (CodecNamesEq(codec.name.c_str(), kVp8CodecName)) { |
1594 // If it's a codec type we can simulcast, create a wrapped encoder. | 1643 // If it's a codec type we can simulcast, create a wrapped encoder. |
1595 external_encoder = std::unique_ptr<webrtc::VideoEncoder>( | 1644 external_encoder = std::unique_ptr<webrtc::VideoEncoder>( |
1596 new webrtc::SimulcastEncoderAdapter(external_encoder_factory_)); | 1645 new webrtc::SimulcastEncoderAdapter(external_encoder_factory_)); |
1597 } else { | 1646 } else { |
1598 external_encoder = | 1647 external_encoder = |
1599 CreateScopedVideoEncoder(external_encoder_factory_, codec); | 1648 CreateScopedVideoEncoder(external_encoder_factory_, codec); |
1600 } | 1649 } |
1601 if (external_encoder) { | 1650 if (external_encoder) { |
1602 std::unique_ptr<webrtc::VideoEncoder> internal_encoder( | 1651 std::unique_ptr<webrtc::VideoEncoder> internal_encoder( |
1603 new webrtc::VideoEncoderSoftwareFallbackWrapper( | 1652 new webrtc::VideoEncoderSoftwareFallbackWrapper( |
1604 codec, std::move(external_encoder))); | 1653 codec, std::move(external_encoder))); |
1605 const webrtc::VideoCodecType codec_type = | 1654 const webrtc::VideoCodecType codec_type = |
1606 webrtc::PayloadStringToCodecType(codec.name); | 1655 webrtc::PayloadStringToCodecType(codec.name); |
1607 const bool has_internal_source = | 1656 const bool has_internal_source = |
1608 external_encoder_factory_->EncoderTypeHasInternalSource(codec_type); | 1657 external_encoder_factory_->EncoderTypeHasInternalSource(codec_type); |
1609 return AllocatedEncoder(std::move(internal_encoder), | 1658 return AllocatedEncoder(std::move(internal_encoder), |
1610 true /* is_external */, codec, | 1659 true /* is_hardware_accelerated */, |
1611 has_internal_source); | 1660 has_internal_source); |
1612 } | 1661 } |
1613 } | 1662 } |
1614 | 1663 |
1615 // Try creating internal encoder. | 1664 // Try creating internal encoder. |
1616 std::unique_ptr<webrtc::VideoEncoder> internal_encoder; | 1665 std::unique_ptr<webrtc::VideoEncoder> internal_encoder; |
1617 if (FindMatchingCodec(internal_encoder_factory_->supported_codecs(), codec)) { | 1666 if (FindMatchingCodec(internal_encoder_factory_->supported_codecs(), codec)) { |
1618 if (CodecNamesEq(codec.name.c_str(), kVp8CodecName) && | 1667 if (CodecNamesEq(codec.name.c_str(), kVp8CodecName) && |
1619 parameters_.encoder_config.content_type == | 1668 is_conference_mode_screenshare && UseSimulcastScreenshare()) { |
1620 webrtc::VideoEncoderConfig::ContentType::kScreen && | |
1621 parameters_.conference_mode && UseSimulcastScreenshare()) { | |
1622 // TODO(sprang): Remove this adapter once libvpx supports simulcast with | 1669 // TODO(sprang): Remove this adapter once libvpx supports simulcast with |
1623 // same-resolution substreams. | 1670 // same-resolution substreams. |
1624 internal_encoder = std::unique_ptr<webrtc::VideoEncoder>( | 1671 internal_encoder = std::unique_ptr<webrtc::VideoEncoder>( |
1625 new webrtc::SimulcastEncoderAdapter(internal_encoder_factory_.get())); | 1672 new webrtc::SimulcastEncoderAdapter(internal_encoder_factory_.get())); |
1626 } else { | 1673 } else { |
1627 internal_encoder = std::unique_ptr<webrtc::VideoEncoder>( | 1674 internal_encoder = std::unique_ptr<webrtc::VideoEncoder>( |
1628 internal_encoder_factory_->CreateVideoEncoder(codec)); | 1675 internal_encoder_factory_->CreateVideoEncoder(codec)); |
1629 } | 1676 } |
1630 return AllocatedEncoder(std::move(internal_encoder), | 1677 return AllocatedEncoder(std::move(internal_encoder), |
1631 false /* is_external */, codec, | 1678 false /* is_hardware_accelerated */, |
1632 false /* has_internal_source */); | 1679 false /* has_internal_source */); |
1633 } | 1680 } |
1634 | 1681 |
1635 // This shouldn't happen, we should not be trying to create something we don't | 1682 // This shouldn't happen, we should not be trying to create something we don't |
1636 // support. | 1683 // support. |
1637 RTC_NOTREACHED(); | 1684 RTC_NOTREACHED(); |
1638 return AllocatedEncoder(); | 1685 return AllocatedEncoder(); |
1639 } | 1686 } |
1640 | 1687 |
1641 void WebRtcVideoChannel::WebRtcVideoSendStream::SetCodec( | 1688 void WebRtcVideoChannel::WebRtcVideoSendStream::SetCodec( |
1642 const VideoCodecSettings& codec_settings, | 1689 const VideoCodecSettings& codec_settings, |
1643 bool force_encoder_allocation) { | 1690 bool force_encoder_allocation) { |
1644 RTC_DCHECK_RUN_ON(&thread_checker_); | 1691 RTC_DCHECK_RUN_ON(&thread_checker_); |
1645 parameters_.encoder_config = CreateVideoEncoderConfig(codec_settings.codec); | 1692 parameters_.encoder_config = CreateVideoEncoderConfig(codec_settings.codec); |
1646 RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0); | 1693 RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0); |
1647 | 1694 |
1648 // Do not re-create encoders of the same type. We can't overwrite | 1695 // Do not re-create encoders of the same type. We can't overwrite |
1649 // |allocated_encoder_| immediately, because we need to release it after the | 1696 // |allocated_encoder_| immediately, because we need to release it after the |
1650 // RecreateWebRtcStream() call. | 1697 // RecreateWebRtcStream() call. |
1651 AllocatedEncoder new_encoder; | 1698 std::unique_ptr<webrtc::VideoEncoder> new_encoder; |
1652 if (force_encoder_allocation || !allocated_encoder_.encoder() || | 1699 if (force_encoder_allocation || !allocated_encoder_ || |
1653 allocated_encoder_.codec() != codec_settings.codec) { | 1700 allocated_codec_ != codec_settings.codec) { |
1654 new_encoder = CreateVideoEncoder(codec_settings.codec); | 1701 const bool is_conference_mode_screenshare = |
| 1702 parameters_.encoder_config.content_type == |
| 1703 webrtc::VideoEncoderConfig::ContentType::kScreen && |
| 1704 parameters_.conference_mode; |
| 1705 EncoderFactoryAdapter::AllocatedEncoder new_allocated_encoder = |
| 1706 encoder_factory_->CreateVideoEncoder(codec_settings.codec, |
| 1707 is_conference_mode_screenshare); |
| 1708 new_encoder = std::unique_ptr<webrtc::VideoEncoder>( |
| 1709 std::move(new_allocated_encoder.encoder)); |
| 1710 parameters_.config.encoder_settings.encoder = new_encoder.get(); |
| 1711 parameters_.config.encoder_settings.full_overuse_time = |
| 1712 new_allocated_encoder.is_hardware_accelerated; |
| 1713 parameters_.config.encoder_settings.internal_source = |
| 1714 new_allocated_encoder.has_internal_source; |
1655 } else { | 1715 } else { |
1656 new_encoder = std::move(allocated_encoder_); | 1716 new_encoder = std::move(allocated_encoder_); |
1657 } | 1717 } |
1658 parameters_.config.encoder_settings.encoder = new_encoder.encoder(); | |
1659 parameters_.config.encoder_settings.full_overuse_time = | |
1660 new_encoder.IsExternal(); | |
1661 parameters_.config.encoder_settings.payload_name = codec_settings.codec.name; | 1718 parameters_.config.encoder_settings.payload_name = codec_settings.codec.name; |
1662 parameters_.config.encoder_settings.payload_type = codec_settings.codec.id; | 1719 parameters_.config.encoder_settings.payload_type = codec_settings.codec.id; |
1663 parameters_.config.encoder_settings.internal_source = | |
1664 new_encoder.HasInternalSource(); | |
1665 parameters_.config.rtp.ulpfec = codec_settings.ulpfec; | 1720 parameters_.config.rtp.ulpfec = codec_settings.ulpfec; |
1666 parameters_.config.rtp.flexfec.payload_type = | 1721 parameters_.config.rtp.flexfec.payload_type = |
1667 codec_settings.flexfec_payload_type; | 1722 codec_settings.flexfec_payload_type; |
1668 | 1723 |
1669 // Set RTX payload type if RTX is enabled. | 1724 // Set RTX payload type if RTX is enabled. |
1670 if (!parameters_.config.rtp.rtx.ssrcs.empty()) { | 1725 if (!parameters_.config.rtp.rtx.ssrcs.empty()) { |
1671 if (codec_settings.rtx_payload_type == -1) { | 1726 if (codec_settings.rtx_payload_type == -1) { |
1672 LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX " | 1727 LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX " |
1673 "payload type. Ignoring."; | 1728 "payload type. Ignoring."; |
1674 parameters_.config.rtp.rtx.ssrcs.clear(); | 1729 parameters_.config.rtp.rtx.ssrcs.clear(); |
1675 } else { | 1730 } else { |
1676 parameters_.config.rtp.rtx.payload_type = codec_settings.rtx_payload_type; | 1731 parameters_.config.rtp.rtx.payload_type = codec_settings.rtx_payload_type; |
1677 } | 1732 } |
1678 } | 1733 } |
1679 | 1734 |
1680 parameters_.config.rtp.nack.rtp_history_ms = | 1735 parameters_.config.rtp.nack.rtp_history_ms = |
1681 HasNack(codec_settings.codec) ? kNackHistoryMs : 0; | 1736 HasNack(codec_settings.codec) ? kNackHistoryMs : 0; |
1682 | 1737 |
1683 parameters_.codec_settings = | 1738 parameters_.codec_settings = |
1684 rtc::Optional<WebRtcVideoChannel::VideoCodecSettings>(codec_settings); | 1739 rtc::Optional<WebRtcVideoChannel::VideoCodecSettings>(codec_settings); |
1685 | 1740 |
1686 LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetCodec."; | 1741 LOG(LS_INFO) << "RecreateWebRtcStream (send) because of SetCodec."; |
1687 RecreateWebRtcStream(); | 1742 RecreateWebRtcStream(); |
1688 allocated_encoder_ = std::move(new_encoder); | 1743 allocated_encoder_ = std::move(new_encoder); |
| 1744 allocated_codec_ = codec_settings.codec; |
1689 } | 1745 } |
1690 | 1746 |
1691 void WebRtcVideoChannel::WebRtcVideoSendStream::SetSendParameters( | 1747 void WebRtcVideoChannel::WebRtcVideoSendStream::SetSendParameters( |
1692 const ChangedSendParameters& params) { | 1748 const ChangedSendParameters& params) { |
1693 RTC_DCHECK_RUN_ON(&thread_checker_); | 1749 RTC_DCHECK_RUN_ON(&thread_checker_); |
1694 // |recreate_stream| means construction-time parameters have changed and the | 1750 // |recreate_stream| means construction-time parameters have changed and the |
1695 // sending stream needs to be reset with the new config. | 1751 // sending stream needs to be reset with the new config. |
1696 bool recreate_stream = false; | 1752 bool recreate_stream = false; |
1697 if (params.rtcp_mode) { | 1753 if (params.rtcp_mode) { |
1698 parameters_.config.rtp.rtcp_mode = *params.rtcp_mode; | 1754 parameters_.config.rtp.rtcp_mode = *params.rtcp_mode; |
(...skipping 873 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2572 stream.temporal_layer_thresholds_bps.resize(GetDefaultVp9TemporalLayers() - | 2628 stream.temporal_layer_thresholds_bps.resize(GetDefaultVp9TemporalLayers() - |
2573 1); | 2629 1); |
2574 } | 2630 } |
2575 | 2631 |
2576 std::vector<webrtc::VideoStream> streams; | 2632 std::vector<webrtc::VideoStream> streams; |
2577 streams.push_back(stream); | 2633 streams.push_back(stream); |
2578 return streams; | 2634 return streams; |
2579 } | 2635 } |
2580 | 2636 |
2581 } // namespace cricket | 2637 } // namespace cricket |
OLD | NEW |