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