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/webrtcvideoengine.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" |
22 #include "webrtc/call/call.h" | 22 #include "webrtc/call/call.h" |
23 #include "webrtc/common_video/h264/profile_level_id.h" | 23 #include "webrtc/common_video/h264/profile_level_id.h" |
24 #include "webrtc/media/engine/constants.h" | 24 #include "webrtc/media/engine/constants.h" |
25 #include "webrtc/media/engine/internaldecoderfactory.h" | 25 #include "webrtc/media/engine/internaldecoderfactory.h" |
26 #include "webrtc/media/engine/internalencoderfactory.h" | 26 #include "webrtc/media/engine/internalencoderfactory.h" |
| 27 #include "webrtc/media/engine/scopedvideodecoder.h" |
27 #include "webrtc/media/engine/scopedvideoencoder.h" | 28 #include "webrtc/media/engine/scopedvideoencoder.h" |
28 #include "webrtc/media/engine/simulcast.h" | 29 #include "webrtc/media/engine/simulcast.h" |
29 #include "webrtc/media/engine/simulcast_encoder_adapter.h" | 30 #include "webrtc/media/engine/simulcast_encoder_adapter.h" |
30 #include "webrtc/media/engine/videodecodersoftwarefallbackwrapper.h" | 31 #include "webrtc/media/engine/videodecodersoftwarefallbackwrapper.h" |
31 #include "webrtc/media/engine/videoencodersoftwarefallbackwrapper.h" | 32 #include "webrtc/media/engine/videoencodersoftwarefallbackwrapper.h" |
32 #include "webrtc/media/engine/webrtcmediaengine.h" | 33 #include "webrtc/media/engine/webrtcmediaengine.h" |
33 #include "webrtc/media/engine/webrtcvideoencoderfactory.h" | 34 #include "webrtc/media/engine/webrtcvideoencoderfactory.h" |
34 #include "webrtc/media/engine/webrtcvoiceengine.h" | 35 #include "webrtc/media/engine/webrtcvoiceengine.h" |
35 #include "webrtc/rtc_base/copyonwritebuffer.h" | 36 #include "webrtc/rtc_base/copyonwritebuffer.h" |
36 #include "webrtc/rtc_base/logging.h" | 37 #include "webrtc/rtc_base/logging.h" |
(...skipping 27 matching lines...) Expand all Loading... |
64 | 65 |
65 virtual AllocatedEncoder CreateVideoEncoder( | 66 virtual AllocatedEncoder CreateVideoEncoder( |
66 const VideoCodec& codec, | 67 const VideoCodec& codec, |
67 bool is_conference_mode_screenshare) const = 0; | 68 bool is_conference_mode_screenshare) const = 0; |
68 | 69 |
69 virtual std::vector<VideoCodec> GetSupportedCodecs() const = 0; | 70 virtual std::vector<VideoCodec> GetSupportedCodecs() const = 0; |
70 | 71 |
71 virtual std::unique_ptr<EncoderFactoryAdapter> clone() const = 0; | 72 virtual std::unique_ptr<EncoderFactoryAdapter> clone() const = 0; |
72 }; | 73 }; |
73 | 74 |
| 75 class DecoderFactoryAdapter { |
| 76 public: |
| 77 virtual ~DecoderFactoryAdapter() {} |
| 78 |
| 79 virtual std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder( |
| 80 webrtc::VideoCodecType type, |
| 81 const VideoDecoderParams& decoder_params) const = 0; |
| 82 |
| 83 virtual std::unique_ptr<DecoderFactoryAdapter> clone() const = 0; |
| 84 }; |
| 85 |
74 namespace { | 86 namespace { |
75 | 87 |
76 // Wraps cricket::WebRtcVideoEncoderFactory* into common EncoderFactoryAdapter | 88 // Wraps cricket::WebRtcVideoEncoderFactory* into common EncoderFactoryAdapter |
77 // interface. | 89 // interface. |
78 // TODO(magjed): Add wrapper class for future webrtc::VideoEncoderFactory | 90 // TODO(magjed): Add wrapper class for future webrtc::VideoEncoderFactory |
79 // interface, https://bugs.chromium.org/p/webrtc/issues/detail?id=7925. | 91 // interface, https://bugs.chromium.org/p/webrtc/issues/detail?id=7925. |
80 class CricketEncoderFactoryAdapter : public EncoderFactoryAdapter { | 92 class CricketEncoderFactoryAdapter : public EncoderFactoryAdapter { |
81 public: | 93 public: |
82 explicit CricketEncoderFactoryAdapter( | 94 explicit CricketEncoderFactoryAdapter( |
83 WebRtcVideoEncoderFactory* external_encoder_factory) | 95 WebRtcVideoEncoderFactory* external_encoder_factory) |
(...skipping 13 matching lines...) Expand all Loading... |
97 | 109 |
98 std::unique_ptr<EncoderFactoryAdapter> clone() const override { | 110 std::unique_ptr<EncoderFactoryAdapter> clone() const override { |
99 return std::unique_ptr<EncoderFactoryAdapter>( | 111 return std::unique_ptr<EncoderFactoryAdapter>( |
100 new CricketEncoderFactoryAdapter(*this)); | 112 new CricketEncoderFactoryAdapter(*this)); |
101 } | 113 } |
102 | 114 |
103 const std::unique_ptr<WebRtcVideoEncoderFactory> internal_encoder_factory_; | 115 const std::unique_ptr<WebRtcVideoEncoderFactory> internal_encoder_factory_; |
104 WebRtcVideoEncoderFactory* const external_encoder_factory_; | 116 WebRtcVideoEncoderFactory* const external_encoder_factory_; |
105 }; | 117 }; |
106 | 118 |
| 119 class CricketDecoderFactoryAdapter : public DecoderFactoryAdapter { |
| 120 public: |
| 121 explicit CricketDecoderFactoryAdapter( |
| 122 WebRtcVideoDecoderFactory* external_decoder_factory) |
| 123 : internal_decoder_factory_(new InternalDecoderFactory()), |
| 124 external_decoder_factory_(external_decoder_factory) {} |
| 125 |
| 126 private: |
| 127 explicit CricketDecoderFactoryAdapter( |
| 128 const CricketDecoderFactoryAdapter& other) |
| 129 : CricketDecoderFactoryAdapter(other.external_decoder_factory_) {} |
| 130 |
| 131 std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder( |
| 132 webrtc::VideoCodecType type, |
| 133 const VideoDecoderParams& decoder_params) const override; |
| 134 |
| 135 std::unique_ptr<DecoderFactoryAdapter> clone() const override { |
| 136 return std::unique_ptr<DecoderFactoryAdapter>( |
| 137 new CricketDecoderFactoryAdapter(*this)); |
| 138 } |
| 139 |
| 140 const std::unique_ptr<WebRtcVideoDecoderFactory> internal_decoder_factory_; |
| 141 WebRtcVideoDecoderFactory* const external_decoder_factory_; |
| 142 }; |
| 143 |
107 // If this field trial is enabled, we will enable sending FlexFEC and disable | 144 // If this field trial is enabled, we will enable sending FlexFEC and disable |
108 // sending ULPFEC whenever the former has been negotiated in the SDPs. | 145 // sending ULPFEC whenever the former has been negotiated in the SDPs. |
109 bool IsFlexfecFieldTrialEnabled() { | 146 bool IsFlexfecFieldTrialEnabled() { |
110 return webrtc::field_trial::IsEnabled("WebRTC-FlexFEC-03"); | 147 return webrtc::field_trial::IsEnabled("WebRTC-FlexFEC-03"); |
111 } | 148 } |
112 | 149 |
113 // If this field trial is enabled, the "flexfec-03" codec may have been | 150 // If this field trial is enabled, the "flexfec-03" codec may have been |
114 // advertised as being supported in the local SDP. That means that we must be | 151 // advertised as being supported in the local SDP. That means that we must be |
115 // ready to receive FlexFEC packets. See internalencoderfactory.cc. | 152 // ready to receive FlexFEC packets. See internalencoderfactory.cc. |
116 bool IsFlexfecAdvertisedFieldTrialEnabled() { | 153 bool IsFlexfecAdvertisedFieldTrialEnabled() { |
(...skipping 243 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
360 default_sink_ = sink; | 397 default_sink_ = sink; |
361 rtc::Optional<uint32_t> default_recv_ssrc = | 398 rtc::Optional<uint32_t> default_recv_ssrc = |
362 channel->GetDefaultReceiveStreamSsrc(); | 399 channel->GetDefaultReceiveStreamSsrc(); |
363 if (default_recv_ssrc) { | 400 if (default_recv_ssrc) { |
364 channel->SetSink(*default_recv_ssrc, default_sink_); | 401 channel->SetSink(*default_recv_ssrc, default_sink_); |
365 } | 402 } |
366 } | 403 } |
367 | 404 |
368 WebRtcVideoEngine::WebRtcVideoEngine() | 405 WebRtcVideoEngine::WebRtcVideoEngine() |
369 : initialized_(false), | 406 : initialized_(false), |
370 external_decoder_factory_(NULL), | 407 decoder_factory_(new CricketDecoderFactoryAdapter( |
| 408 nullptr /* external_decoder_factory */)), |
371 encoder_factory_(new CricketEncoderFactoryAdapter( | 409 encoder_factory_(new CricketEncoderFactoryAdapter( |
372 nullptr /* external_encoder_factory */)) { | 410 nullptr /* external_encoder_factory */)) { |
373 LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine()"; | 411 LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine()"; |
374 } | 412 } |
375 | 413 |
376 WebRtcVideoEngine::~WebRtcVideoEngine() { | 414 WebRtcVideoEngine::~WebRtcVideoEngine() { |
377 LOG(LS_INFO) << "WebRtcVideoEngine::~WebRtcVideoEngine"; | 415 LOG(LS_INFO) << "WebRtcVideoEngine::~WebRtcVideoEngine"; |
378 } | 416 } |
379 | 417 |
380 void WebRtcVideoEngine::Init() { | 418 void WebRtcVideoEngine::Init() { |
381 LOG(LS_INFO) << "WebRtcVideoEngine::Init"; | 419 LOG(LS_INFO) << "WebRtcVideoEngine::Init"; |
382 initialized_ = true; | 420 initialized_ = true; |
383 } | 421 } |
384 | 422 |
385 WebRtcVideoChannel* WebRtcVideoEngine::CreateChannel( | 423 WebRtcVideoChannel* WebRtcVideoEngine::CreateChannel( |
386 webrtc::Call* call, | 424 webrtc::Call* call, |
387 const MediaConfig& config, | 425 const MediaConfig& config, |
388 const VideoOptions& options) { | 426 const VideoOptions& options) { |
389 RTC_DCHECK(initialized_); | 427 RTC_DCHECK(initialized_); |
390 LOG(LS_INFO) << "CreateChannel. Options: " << options.ToString(); | 428 LOG(LS_INFO) << "CreateChannel. Options: " << options.ToString(); |
391 return new WebRtcVideoChannel(call, config, options, *encoder_factory_, | 429 return new WebRtcVideoChannel(call, config, options, *encoder_factory_, |
392 external_decoder_factory_); | 430 *decoder_factory_); |
393 } | 431 } |
394 | 432 |
395 std::vector<VideoCodec> WebRtcVideoEngine::codecs() const { | 433 std::vector<VideoCodec> WebRtcVideoEngine::codecs() const { |
396 return encoder_factory_->GetSupportedCodecs(); | 434 return encoder_factory_->GetSupportedCodecs(); |
397 } | 435 } |
398 | 436 |
399 RtpCapabilities WebRtcVideoEngine::GetCapabilities() const { | 437 RtpCapabilities WebRtcVideoEngine::GetCapabilities() const { |
400 RtpCapabilities capabilities; | 438 RtpCapabilities capabilities; |
401 capabilities.header_extensions.push_back( | 439 capabilities.header_extensions.push_back( |
402 webrtc::RtpExtension(webrtc::RtpExtension::kTimestampOffsetUri, | 440 webrtc::RtpExtension(webrtc::RtpExtension::kTimestampOffsetUri, |
(...skipping 15 matching lines...) Expand all Loading... |
418 webrtc::RtpExtension::kVideoContentTypeDefaultId)); | 456 webrtc::RtpExtension::kVideoContentTypeDefaultId)); |
419 capabilities.header_extensions.push_back( | 457 capabilities.header_extensions.push_back( |
420 webrtc::RtpExtension(webrtc::RtpExtension::kVideoTimingUri, | 458 webrtc::RtpExtension(webrtc::RtpExtension::kVideoTimingUri, |
421 webrtc::RtpExtension::kVideoTimingDefaultId)); | 459 webrtc::RtpExtension::kVideoTimingDefaultId)); |
422 return capabilities; | 460 return capabilities; |
423 } | 461 } |
424 | 462 |
425 void WebRtcVideoEngine::SetExternalDecoderFactory( | 463 void WebRtcVideoEngine::SetExternalDecoderFactory( |
426 WebRtcVideoDecoderFactory* decoder_factory) { | 464 WebRtcVideoDecoderFactory* decoder_factory) { |
427 RTC_DCHECK(!initialized_); | 465 RTC_DCHECK(!initialized_); |
428 external_decoder_factory_ = decoder_factory; | 466 decoder_factory_.reset(new CricketDecoderFactoryAdapter(decoder_factory)); |
429 } | 467 } |
430 | 468 |
431 void WebRtcVideoEngine::SetExternalEncoderFactory( | 469 void WebRtcVideoEngine::SetExternalEncoderFactory( |
432 WebRtcVideoEncoderFactory* encoder_factory) { | 470 WebRtcVideoEncoderFactory* encoder_factory) { |
433 RTC_DCHECK(!initialized_); | 471 RTC_DCHECK(!initialized_); |
434 encoder_factory_.reset(new CricketEncoderFactoryAdapter(encoder_factory)); | 472 encoder_factory_.reset(new CricketEncoderFactoryAdapter(encoder_factory)); |
435 } | 473 } |
436 | 474 |
437 // This function will assign dynamic payload types (in the range [96, 127]) to | 475 // This function will assign dynamic payload types (in the range [96, 127]) to |
438 // the input codecs, and also add associated RTX codecs for recognized codecs | 476 // the input codecs, and also add associated RTX codecs for recognized codecs |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
496 } | 534 } |
497 | 535 |
498 return AssignPayloadTypesAndAddAssociatedRtxCodecs(codecs); | 536 return AssignPayloadTypesAndAddAssociatedRtxCodecs(codecs); |
499 } | 537 } |
500 | 538 |
501 WebRtcVideoChannel::WebRtcVideoChannel( | 539 WebRtcVideoChannel::WebRtcVideoChannel( |
502 webrtc::Call* call, | 540 webrtc::Call* call, |
503 const MediaConfig& config, | 541 const MediaConfig& config, |
504 const VideoOptions& options, | 542 const VideoOptions& options, |
505 const EncoderFactoryAdapter& encoder_factory, | 543 const EncoderFactoryAdapter& encoder_factory, |
506 WebRtcVideoDecoderFactory* external_decoder_factory) | 544 const DecoderFactoryAdapter& decoder_factory) |
507 : VideoMediaChannel(config), | 545 : VideoMediaChannel(config), |
508 call_(call), | 546 call_(call), |
509 unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_), | 547 unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_), |
510 video_config_(config.video), | 548 video_config_(config.video), |
511 encoder_factory_(encoder_factory.clone()), | 549 encoder_factory_(encoder_factory.clone()), |
512 external_decoder_factory_(external_decoder_factory), | 550 decoder_factory_(decoder_factory.clone()), |
513 default_send_options_(options), | 551 default_send_options_(options), |
514 last_stats_log_ms_(-1) { | 552 last_stats_log_ms_(-1) { |
515 RTC_DCHECK(thread_checker_.CalledOnValidThread()); | 553 RTC_DCHECK(thread_checker_.CalledOnValidThread()); |
516 | 554 |
517 rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc; | 555 rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc; |
518 sending_ = false; | 556 sending_ = false; |
519 recv_codecs_ = MapCodecs(encoder_factory_->GetSupportedCodecs()); | 557 recv_codecs_ = MapCodecs(encoder_factory_->GetSupportedCodecs()); |
520 recv_flexfec_payload_type_ = recv_codecs_.front().flexfec_payload_type; | 558 recv_flexfec_payload_type_ = recv_codecs_.front().flexfec_payload_type; |
521 } | 559 } |
522 | 560 |
(...skipping 595 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1118 | 1156 |
1119 webrtc::VideoReceiveStream::Config config(this); | 1157 webrtc::VideoReceiveStream::Config config(this); |
1120 webrtc::FlexfecReceiveStream::Config flexfec_config(this); | 1158 webrtc::FlexfecReceiveStream::Config flexfec_config(this); |
1121 ConfigureReceiverRtp(&config, &flexfec_config, sp); | 1159 ConfigureReceiverRtp(&config, &flexfec_config, sp); |
1122 | 1160 |
1123 config.disable_prerenderer_smoothing = | 1161 config.disable_prerenderer_smoothing = |
1124 video_config_.disable_prerenderer_smoothing; | 1162 video_config_.disable_prerenderer_smoothing; |
1125 config.sync_group = sp.sync_label; | 1163 config.sync_group = sp.sync_label; |
1126 | 1164 |
1127 receive_streams_[ssrc] = new WebRtcVideoReceiveStream( | 1165 receive_streams_[ssrc] = new WebRtcVideoReceiveStream( |
1128 call_, sp, std::move(config), external_decoder_factory_, default_stream, | 1166 call_, sp, std::move(config), *decoder_factory_, default_stream, |
1129 recv_codecs_, flexfec_config); | 1167 recv_codecs_, flexfec_config); |
1130 | 1168 |
1131 return true; | 1169 return true; |
1132 } | 1170 } |
1133 | 1171 |
1134 void WebRtcVideoChannel::ConfigureReceiverRtp( | 1172 void WebRtcVideoChannel::ConfigureReceiverRtp( |
1135 webrtc::VideoReceiveStream::Config* config, | 1173 webrtc::VideoReceiveStream::Config* config, |
1136 webrtc::FlexfecReceiveStream::Config* flexfec_config, | 1174 webrtc::FlexfecReceiveStream::Config* flexfec_config, |
1137 const StreamParams& sp) const { | 1175 const StreamParams& sp) const { |
1138 uint32_t ssrc = sp.first_ssrc(); | 1176 uint32_t ssrc = sp.first_ssrc(); |
(...skipping 917 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2056 } | 2094 } |
2057 | 2095 |
2058 // Call stream_->Start() if necessary conditions are met. | 2096 // Call stream_->Start() if necessary conditions are met. |
2059 UpdateSendState(); | 2097 UpdateSendState(); |
2060 } | 2098 } |
2061 | 2099 |
2062 WebRtcVideoChannel::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream( | 2100 WebRtcVideoChannel::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream( |
2063 webrtc::Call* call, | 2101 webrtc::Call* call, |
2064 const StreamParams& sp, | 2102 const StreamParams& sp, |
2065 webrtc::VideoReceiveStream::Config config, | 2103 webrtc::VideoReceiveStream::Config config, |
2066 WebRtcVideoDecoderFactory* external_decoder_factory, | 2104 const DecoderFactoryAdapter& decoder_factory, |
2067 bool default_stream, | 2105 bool default_stream, |
2068 const std::vector<VideoCodecSettings>& recv_codecs, | 2106 const std::vector<VideoCodecSettings>& recv_codecs, |
2069 const webrtc::FlexfecReceiveStream::Config& flexfec_config) | 2107 const webrtc::FlexfecReceiveStream::Config& flexfec_config) |
2070 : call_(call), | 2108 : call_(call), |
2071 stream_params_(sp), | 2109 stream_params_(sp), |
2072 stream_(NULL), | 2110 stream_(NULL), |
2073 default_stream_(default_stream), | 2111 default_stream_(default_stream), |
2074 config_(std::move(config)), | 2112 config_(std::move(config)), |
2075 flexfec_config_(flexfec_config), | 2113 flexfec_config_(flexfec_config), |
2076 flexfec_stream_(nullptr), | 2114 flexfec_stream_(nullptr), |
2077 external_decoder_factory_(external_decoder_factory), | 2115 decoder_factory_(decoder_factory.clone()), |
2078 sink_(NULL), | 2116 sink_(NULL), |
2079 first_frame_timestamp_(-1), | 2117 first_frame_timestamp_(-1), |
2080 estimated_remote_start_ntp_time_ms_(0) { | 2118 estimated_remote_start_ntp_time_ms_(0) { |
2081 config_.renderer = this; | 2119 config_.renderer = this; |
2082 std::vector<AllocatedDecoder> old_decoders; | 2120 std::map<webrtc::VideoCodecType, std::unique_ptr<webrtc::VideoDecoder>> |
| 2121 old_decoders; |
2083 ConfigureCodecs(recv_codecs, &old_decoders); | 2122 ConfigureCodecs(recv_codecs, &old_decoders); |
2084 ConfigureFlexfecCodec(flexfec_config.payload_type); | 2123 ConfigureFlexfecCodec(flexfec_config.payload_type); |
2085 MaybeRecreateWebRtcFlexfecStream(); | 2124 MaybeRecreateWebRtcFlexfecStream(); |
2086 RecreateWebRtcVideoStream(); | 2125 RecreateWebRtcVideoStream(); |
2087 RTC_DCHECK(old_decoders.empty()); | 2126 RTC_DCHECK(old_decoders.empty()); |
2088 } | 2127 } |
2089 | 2128 |
2090 WebRtcVideoChannel::WebRtcVideoReceiveStream::AllocatedDecoder:: | |
2091 AllocatedDecoder(webrtc::VideoDecoder* decoder, | |
2092 webrtc::VideoCodecType type, | |
2093 bool external) | |
2094 : decoder(decoder), | |
2095 external_decoder(nullptr), | |
2096 type(type), | |
2097 external(external) { | |
2098 if (external) { | |
2099 external_decoder = decoder; | |
2100 this->decoder = | |
2101 new webrtc::VideoDecoderSoftwareFallbackWrapper(type, external_decoder); | |
2102 } | |
2103 } | |
2104 | |
2105 WebRtcVideoChannel::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() { | 2129 WebRtcVideoChannel::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() { |
2106 if (flexfec_stream_) { | 2130 if (flexfec_stream_) { |
2107 MaybeDissociateFlexfecFromVideo(); | 2131 MaybeDissociateFlexfecFromVideo(); |
2108 call_->DestroyFlexfecReceiveStream(flexfec_stream_); | 2132 call_->DestroyFlexfecReceiveStream(flexfec_stream_); |
2109 } | 2133 } |
2110 call_->DestroyVideoReceiveStream(stream_); | 2134 call_->DestroyVideoReceiveStream(stream_); |
2111 ClearDecoders(&allocated_decoders_); | 2135 allocated_decoders_.clear(); |
2112 } | 2136 } |
2113 | 2137 |
2114 const std::vector<uint32_t>& | 2138 const std::vector<uint32_t>& |
2115 WebRtcVideoChannel::WebRtcVideoReceiveStream::GetSsrcs() const { | 2139 WebRtcVideoChannel::WebRtcVideoReceiveStream::GetSsrcs() const { |
2116 return stream_params_.ssrcs; | 2140 return stream_params_.ssrcs; |
2117 } | 2141 } |
2118 | 2142 |
2119 rtc::Optional<uint32_t> | 2143 rtc::Optional<uint32_t> |
2120 WebRtcVideoChannel::WebRtcVideoReceiveStream::GetFirstPrimarySsrc() const { | 2144 WebRtcVideoChannel::WebRtcVideoReceiveStream::GetFirstPrimarySsrc() const { |
2121 std::vector<uint32_t> primary_ssrcs; | 2145 std::vector<uint32_t> primary_ssrcs; |
2122 stream_params_.GetPrimarySsrcs(&primary_ssrcs); | 2146 stream_params_.GetPrimarySsrcs(&primary_ssrcs); |
2123 | 2147 |
2124 if (primary_ssrcs.empty()) { | 2148 if (primary_ssrcs.empty()) { |
2125 LOG(LS_WARNING) << "Empty primary ssrcs vector, returning empty optional"; | 2149 LOG(LS_WARNING) << "Empty primary ssrcs vector, returning empty optional"; |
2126 return rtc::Optional<uint32_t>(); | 2150 return rtc::Optional<uint32_t>(); |
2127 } else { | 2151 } else { |
2128 return rtc::Optional<uint32_t>(primary_ssrcs[0]); | 2152 return rtc::Optional<uint32_t>(primary_ssrcs[0]); |
2129 } | 2153 } |
2130 } | 2154 } |
2131 | 2155 |
2132 WebRtcVideoChannel::WebRtcVideoReceiveStream::AllocatedDecoder | 2156 std::unique_ptr<webrtc::VideoDecoder> |
2133 WebRtcVideoChannel::WebRtcVideoReceiveStream::CreateOrReuseVideoDecoder( | 2157 CricketDecoderFactoryAdapter::CreateVideoDecoder( |
2134 std::vector<AllocatedDecoder>* old_decoders, | 2158 webrtc::VideoCodecType type, |
2135 const VideoCodec& codec) { | 2159 const VideoDecoderParams& decoder_params) const { |
2136 webrtc::VideoCodecType type = webrtc::PayloadStringToCodecType(codec.name); | 2160 if (external_decoder_factory_ != nullptr) { |
2137 | 2161 std::unique_ptr<webrtc::VideoDecoder> external_decoder = |
2138 for (size_t i = 0; i < old_decoders->size(); ++i) { | 2162 CreateScopedVideoDecoder(external_decoder_factory_, type, |
2139 if ((*old_decoders)[i].type == type) { | 2163 decoder_params); |
2140 AllocatedDecoder decoder = (*old_decoders)[i]; | 2164 if (external_decoder) { |
2141 (*old_decoders)[i] = old_decoders->back(); | 2165 std::unique_ptr<webrtc::VideoDecoder> internal_decoder( |
2142 old_decoders->pop_back(); | 2166 new webrtc::VideoDecoderSoftwareFallbackWrapper( |
2143 return decoder; | 2167 type, std::move(external_decoder))); |
| 2168 return internal_decoder; |
2144 } | 2169 } |
2145 } | 2170 } |
2146 | 2171 |
2147 if (external_decoder_factory_ != NULL) { | 2172 std::unique_ptr<webrtc::VideoDecoder> internal_decoder( |
2148 webrtc::VideoDecoder* decoder = | 2173 internal_decoder_factory_->CreateVideoDecoderWithParams(type, |
2149 external_decoder_factory_->CreateVideoDecoderWithParams( | 2174 decoder_params)); |
2150 type, {stream_params_.id}); | 2175 return internal_decoder; |
2151 if (decoder != NULL) { | |
2152 return AllocatedDecoder(decoder, type, true /* is_external */); | |
2153 } | |
2154 } | |
2155 | |
2156 InternalDecoderFactory internal_decoder_factory; | |
2157 return AllocatedDecoder(internal_decoder_factory.CreateVideoDecoderWithParams( | |
2158 type, {stream_params_.id}), | |
2159 type, false /* is_external */); | |
2160 } | 2176 } |
2161 | 2177 |
2162 void WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureCodecs( | 2178 void WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureCodecs( |
2163 const std::vector<VideoCodecSettings>& recv_codecs, | 2179 const std::vector<VideoCodecSettings>& recv_codecs, |
2164 std::vector<AllocatedDecoder>* old_decoders) { | 2180 std::map<webrtc::VideoCodecType, std::unique_ptr<webrtc::VideoDecoder>>* |
2165 *old_decoders = allocated_decoders_; | 2181 old_decoders) { |
| 2182 *old_decoders = std::move(allocated_decoders_); |
2166 allocated_decoders_.clear(); | 2183 allocated_decoders_.clear(); |
2167 config_.decoders.clear(); | 2184 config_.decoders.clear(); |
2168 for (size_t i = 0; i < recv_codecs.size(); ++i) { | 2185 for (size_t i = 0; i < recv_codecs.size(); ++i) { |
2169 AllocatedDecoder allocated_decoder = | 2186 webrtc::VideoCodecType type = |
2170 CreateOrReuseVideoDecoder(old_decoders, recv_codecs[i].codec); | 2187 webrtc::PayloadStringToCodecType(recv_codecs[i].codec.name); |
2171 allocated_decoders_.push_back(allocated_decoder); | 2188 std::unique_ptr<webrtc::VideoDecoder> new_decoder; |
| 2189 |
| 2190 auto it = old_decoders->find(type); |
| 2191 if (it != old_decoders->end()) { |
| 2192 new_decoder = std::move(it->second); |
| 2193 old_decoders->erase(it); |
| 2194 } |
| 2195 |
| 2196 if (!new_decoder) { |
| 2197 new_decoder = |
| 2198 decoder_factory_->CreateVideoDecoder(type, {stream_params_.id}); |
| 2199 } |
2172 | 2200 |
2173 webrtc::VideoReceiveStream::Decoder decoder; | 2201 webrtc::VideoReceiveStream::Decoder decoder; |
2174 decoder.decoder = allocated_decoder.decoder; | 2202 decoder.decoder = new_decoder.get(); |
2175 decoder.payload_type = recv_codecs[i].codec.id; | 2203 decoder.payload_type = recv_codecs[i].codec.id; |
2176 decoder.payload_name = recv_codecs[i].codec.name; | 2204 decoder.payload_name = recv_codecs[i].codec.name; |
2177 decoder.codec_params = recv_codecs[i].codec.params; | 2205 decoder.codec_params = recv_codecs[i].codec.params; |
2178 config_.decoders.push_back(decoder); | 2206 config_.decoders.push_back(decoder); |
| 2207 |
| 2208 allocated_decoders_.insert(std::make_pair(type, std::move(new_decoder))); |
2179 } | 2209 } |
2180 | 2210 |
2181 config_.rtp.rtx_associated_payload_types.clear(); | 2211 config_.rtp.rtx_associated_payload_types.clear(); |
2182 for (const VideoCodecSettings& recv_codec : recv_codecs) { | 2212 for (const VideoCodecSettings& recv_codec : recv_codecs) { |
2183 config_.rtp.rtx_associated_payload_types[recv_codec.rtx_payload_type] = | 2213 config_.rtp.rtx_associated_payload_types[recv_codec.rtx_payload_type] = |
2184 recv_codec.codec.id; | 2214 recv_codec.codec.id; |
2185 } | 2215 } |
2186 | 2216 |
2187 config_.rtp.ulpfec = recv_codecs.front().ulpfec; | 2217 config_.rtp.ulpfec = recv_codecs.front().ulpfec; |
2188 | 2218 |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2246 << nack_enabled << ", remb=" << remb_enabled | 2276 << nack_enabled << ", remb=" << remb_enabled |
2247 << ", transport_cc=" << transport_cc_enabled; | 2277 << ", transport_cc=" << transport_cc_enabled; |
2248 MaybeRecreateWebRtcFlexfecStream(); | 2278 MaybeRecreateWebRtcFlexfecStream(); |
2249 RecreateWebRtcVideoStream(); | 2279 RecreateWebRtcVideoStream(); |
2250 } | 2280 } |
2251 | 2281 |
2252 void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetRecvParameters( | 2282 void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetRecvParameters( |
2253 const ChangedRecvParameters& params) { | 2283 const ChangedRecvParameters& params) { |
2254 bool video_needs_recreation = false; | 2284 bool video_needs_recreation = false; |
2255 bool flexfec_needs_recreation = false; | 2285 bool flexfec_needs_recreation = false; |
2256 std::vector<AllocatedDecoder> old_decoders; | 2286 std::map<webrtc::VideoCodecType, std::unique_ptr<webrtc::VideoDecoder>> |
| 2287 old_decoders; |
2257 if (params.codec_settings) { | 2288 if (params.codec_settings) { |
2258 ConfigureCodecs(*params.codec_settings, &old_decoders); | 2289 ConfigureCodecs(*params.codec_settings, &old_decoders); |
2259 video_needs_recreation = true; | 2290 video_needs_recreation = true; |
2260 } | 2291 } |
2261 if (params.rtp_header_extensions) { | 2292 if (params.rtp_header_extensions) { |
2262 config_.rtp.extensions = *params.rtp_header_extensions; | 2293 config_.rtp.extensions = *params.rtp_header_extensions; |
2263 flexfec_config_.rtp_header_extensions = *params.rtp_header_extensions; | 2294 flexfec_config_.rtp_header_extensions = *params.rtp_header_extensions; |
2264 video_needs_recreation = true; | 2295 video_needs_recreation = true; |
2265 flexfec_needs_recreation = true; | 2296 flexfec_needs_recreation = true; |
2266 } | 2297 } |
2267 if (params.flexfec_payload_type) { | 2298 if (params.flexfec_payload_type) { |
2268 ConfigureFlexfecCodec(*params.flexfec_payload_type); | 2299 ConfigureFlexfecCodec(*params.flexfec_payload_type); |
2269 flexfec_needs_recreation = true; | 2300 flexfec_needs_recreation = true; |
2270 } | 2301 } |
2271 if (flexfec_needs_recreation) { | 2302 if (flexfec_needs_recreation) { |
2272 LOG(LS_INFO) << "MaybeRecreateWebRtcFlexfecStream (recv) because of " | 2303 LOG(LS_INFO) << "MaybeRecreateWebRtcFlexfecStream (recv) because of " |
2273 "SetRecvParameters"; | 2304 "SetRecvParameters"; |
2274 MaybeRecreateWebRtcFlexfecStream(); | 2305 MaybeRecreateWebRtcFlexfecStream(); |
2275 } | 2306 } |
2276 if (video_needs_recreation) { | 2307 if (video_needs_recreation) { |
2277 LOG(LS_INFO) | 2308 LOG(LS_INFO) |
2278 << "RecreateWebRtcVideoStream (recv) because of SetRecvParameters"; | 2309 << "RecreateWebRtcVideoStream (recv) because of SetRecvParameters"; |
2279 RecreateWebRtcVideoStream(); | 2310 RecreateWebRtcVideoStream(); |
2280 ClearDecoders(&old_decoders); | |
2281 } | 2311 } |
2282 } | 2312 } |
2283 | 2313 |
2284 void WebRtcVideoChannel::WebRtcVideoReceiveStream:: | 2314 void WebRtcVideoChannel::WebRtcVideoReceiveStream:: |
2285 RecreateWebRtcVideoStream() { | 2315 RecreateWebRtcVideoStream() { |
2286 if (stream_) { | 2316 if (stream_) { |
2287 MaybeDissociateFlexfecFromVideo(); | 2317 MaybeDissociateFlexfecFromVideo(); |
2288 call_->DestroyVideoReceiveStream(stream_); | 2318 call_->DestroyVideoReceiveStream(stream_); |
2289 stream_ = nullptr; | 2319 stream_ = nullptr; |
2290 } | 2320 } |
(...skipping 24 matching lines...) Expand all Loading... |
2315 } | 2345 } |
2316 } | 2346 } |
2317 | 2347 |
2318 void WebRtcVideoChannel::WebRtcVideoReceiveStream:: | 2348 void WebRtcVideoChannel::WebRtcVideoReceiveStream:: |
2319 MaybeDissociateFlexfecFromVideo() { | 2349 MaybeDissociateFlexfecFromVideo() { |
2320 if (stream_ && flexfec_stream_) { | 2350 if (stream_ && flexfec_stream_) { |
2321 stream_->RemoveSecondarySink(flexfec_stream_); | 2351 stream_->RemoveSecondarySink(flexfec_stream_); |
2322 } | 2352 } |
2323 } | 2353 } |
2324 | 2354 |
2325 void WebRtcVideoChannel::WebRtcVideoReceiveStream::ClearDecoders( | |
2326 std::vector<AllocatedDecoder>* allocated_decoders) { | |
2327 for (size_t i = 0; i < allocated_decoders->size(); ++i) { | |
2328 if ((*allocated_decoders)[i].external) { | |
2329 external_decoder_factory_->DestroyVideoDecoder( | |
2330 (*allocated_decoders)[i].external_decoder); | |
2331 } | |
2332 delete (*allocated_decoders)[i].decoder; | |
2333 } | |
2334 allocated_decoders->clear(); | |
2335 } | |
2336 | |
2337 void WebRtcVideoChannel::WebRtcVideoReceiveStream::OnFrame( | 2355 void WebRtcVideoChannel::WebRtcVideoReceiveStream::OnFrame( |
2338 const webrtc::VideoFrame& frame) { | 2356 const webrtc::VideoFrame& frame) { |
2339 rtc::CritScope crit(&sink_lock_); | 2357 rtc::CritScope crit(&sink_lock_); |
2340 | 2358 |
2341 if (first_frame_timestamp_ < 0) | 2359 if (first_frame_timestamp_ < 0) |
2342 first_frame_timestamp_ = frame.timestamp(); | 2360 first_frame_timestamp_ = frame.timestamp(); |
2343 int64_t rtp_time_elapsed_since_first_frame = | 2361 int64_t rtp_time_elapsed_since_first_frame = |
2344 (timestamp_wraparound_handler_.Unwrap(frame.timestamp()) - | 2362 (timestamp_wraparound_handler_.Unwrap(frame.timestamp()) - |
2345 first_frame_timestamp_); | 2363 first_frame_timestamp_); |
2346 int64_t elapsed_time_ms = rtp_time_elapsed_since_first_frame / | 2364 int64_t elapsed_time_ms = rtp_time_elapsed_since_first_frame / |
(...skipping 261 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2608 stream.temporal_layer_thresholds_bps.resize(GetDefaultVp9TemporalLayers() - | 2626 stream.temporal_layer_thresholds_bps.resize(GetDefaultVp9TemporalLayers() - |
2609 1); | 2627 1); |
2610 } | 2628 } |
2611 | 2629 |
2612 std::vector<webrtc::VideoStream> streams; | 2630 std::vector<webrtc::VideoStream> streams; |
2613 streams.push_back(stream); | 2631 streams.push_back(stream); |
2614 return streams; | 2632 return streams; |
2615 } | 2633 } |
2616 | 2634 |
2617 } // namespace cricket | 2635 } // namespace cricket |
OLD | NEW |