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 const VideoCodec& codec, | |
magjed_webrtc
2017/09/11 14:59:21
Actually, can you use webrtc::SdpVideoFormat direc
andersc
2017/09/11 15:29:09
Ignored after offline discussion
| |
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 const VideoCodec& codec, | |
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 919 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2058 } | 2096 } |
2059 | 2097 |
2060 // Call stream_->Start() if necessary conditions are met. | 2098 // Call stream_->Start() if necessary conditions are met. |
2061 UpdateSendState(); | 2099 UpdateSendState(); |
2062 } | 2100 } |
2063 | 2101 |
2064 WebRtcVideoChannel::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream( | 2102 WebRtcVideoChannel::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream( |
2065 webrtc::Call* call, | 2103 webrtc::Call* call, |
2066 const StreamParams& sp, | 2104 const StreamParams& sp, |
2067 webrtc::VideoReceiveStream::Config config, | 2105 webrtc::VideoReceiveStream::Config config, |
2068 WebRtcVideoDecoderFactory* external_decoder_factory, | 2106 const DecoderFactoryAdapter& decoder_factory, |
2069 bool default_stream, | 2107 bool default_stream, |
2070 const std::vector<VideoCodecSettings>& recv_codecs, | 2108 const std::vector<VideoCodecSettings>& recv_codecs, |
2071 const webrtc::FlexfecReceiveStream::Config& flexfec_config) | 2109 const webrtc::FlexfecReceiveStream::Config& flexfec_config) |
2072 : call_(call), | 2110 : call_(call), |
2073 stream_params_(sp), | 2111 stream_params_(sp), |
2074 stream_(NULL), | 2112 stream_(NULL), |
2075 default_stream_(default_stream), | 2113 default_stream_(default_stream), |
2076 config_(std::move(config)), | 2114 config_(std::move(config)), |
2077 flexfec_config_(flexfec_config), | 2115 flexfec_config_(flexfec_config), |
2078 flexfec_stream_(nullptr), | 2116 flexfec_stream_(nullptr), |
2079 external_decoder_factory_(external_decoder_factory), | 2117 decoder_factory_(decoder_factory.clone()), |
2080 sink_(NULL), | 2118 sink_(NULL), |
2081 first_frame_timestamp_(-1), | 2119 first_frame_timestamp_(-1), |
2082 estimated_remote_start_ntp_time_ms_(0) { | 2120 estimated_remote_start_ntp_time_ms_(0) { |
2083 config_.renderer = this; | 2121 config_.renderer = this; |
2084 std::vector<AllocatedDecoder> old_decoders; | 2122 std::map<webrtc::SdpVideoFormat, std::unique_ptr<webrtc::VideoDecoder>, |
2123 webrtc::SdpVideoFormatCompare> | |
2124 old_decoders; | |
2085 ConfigureCodecs(recv_codecs, &old_decoders); | 2125 ConfigureCodecs(recv_codecs, &old_decoders); |
2086 ConfigureFlexfecCodec(flexfec_config.payload_type); | 2126 ConfigureFlexfecCodec(flexfec_config.payload_type); |
2087 MaybeRecreateWebRtcFlexfecStream(); | 2127 MaybeRecreateWebRtcFlexfecStream(); |
2088 RecreateWebRtcVideoStream(); | 2128 RecreateWebRtcVideoStream(); |
2089 RTC_DCHECK(old_decoders.empty()); | 2129 RTC_DCHECK(old_decoders.empty()); |
2090 } | 2130 } |
2091 | 2131 |
2092 WebRtcVideoChannel::WebRtcVideoReceiveStream::AllocatedDecoder:: | |
2093 AllocatedDecoder(webrtc::VideoDecoder* decoder, | |
2094 webrtc::VideoCodecType type, | |
2095 bool external) | |
2096 : decoder(decoder), | |
2097 external_decoder(nullptr), | |
2098 type(type), | |
2099 external(external) { | |
2100 if (external) { | |
2101 external_decoder = decoder; | |
2102 this->decoder = | |
2103 new webrtc::VideoDecoderSoftwareFallbackWrapper(type, external_decoder); | |
2104 } | |
2105 } | |
2106 | |
2107 WebRtcVideoChannel::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() { | 2132 WebRtcVideoChannel::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() { |
2108 if (flexfec_stream_) { | 2133 if (flexfec_stream_) { |
2109 MaybeDissociateFlexfecFromVideo(); | 2134 MaybeDissociateFlexfecFromVideo(); |
2110 call_->DestroyFlexfecReceiveStream(flexfec_stream_); | 2135 call_->DestroyFlexfecReceiveStream(flexfec_stream_); |
2111 } | 2136 } |
2112 call_->DestroyVideoReceiveStream(stream_); | 2137 call_->DestroyVideoReceiveStream(stream_); |
2113 ClearDecoders(&allocated_decoders_); | 2138 allocated_decoders_.clear(); |
2114 } | 2139 } |
2115 | 2140 |
2116 const std::vector<uint32_t>& | 2141 const std::vector<uint32_t>& |
2117 WebRtcVideoChannel::WebRtcVideoReceiveStream::GetSsrcs() const { | 2142 WebRtcVideoChannel::WebRtcVideoReceiveStream::GetSsrcs() const { |
2118 return stream_params_.ssrcs; | 2143 return stream_params_.ssrcs; |
2119 } | 2144 } |
2120 | 2145 |
2121 rtc::Optional<uint32_t> | 2146 rtc::Optional<uint32_t> |
2122 WebRtcVideoChannel::WebRtcVideoReceiveStream::GetFirstPrimarySsrc() const { | 2147 WebRtcVideoChannel::WebRtcVideoReceiveStream::GetFirstPrimarySsrc() const { |
2123 std::vector<uint32_t> primary_ssrcs; | 2148 std::vector<uint32_t> primary_ssrcs; |
2124 stream_params_.GetPrimarySsrcs(&primary_ssrcs); | 2149 stream_params_.GetPrimarySsrcs(&primary_ssrcs); |
2125 | 2150 |
2126 if (primary_ssrcs.empty()) { | 2151 if (primary_ssrcs.empty()) { |
2127 LOG(LS_WARNING) << "Empty primary ssrcs vector, returning empty optional"; | 2152 LOG(LS_WARNING) << "Empty primary ssrcs vector, returning empty optional"; |
2128 return rtc::Optional<uint32_t>(); | 2153 return rtc::Optional<uint32_t>(); |
2129 } else { | 2154 } else { |
2130 return rtc::Optional<uint32_t>(primary_ssrcs[0]); | 2155 return rtc::Optional<uint32_t>(primary_ssrcs[0]); |
2131 } | 2156 } |
2132 } | 2157 } |
2133 | 2158 |
2134 WebRtcVideoChannel::WebRtcVideoReceiveStream::AllocatedDecoder | 2159 std::unique_ptr<webrtc::VideoDecoder> |
2135 WebRtcVideoChannel::WebRtcVideoReceiveStream::CreateOrReuseVideoDecoder( | 2160 CricketDecoderFactoryAdapter::CreateVideoDecoder( |
2136 std::vector<AllocatedDecoder>* old_decoders, | 2161 const VideoCodec& codec, |
2137 const VideoCodec& codec) { | 2162 const VideoDecoderParams& decoder_params) const { |
2138 webrtc::VideoCodecType type = webrtc::PayloadStringToCodecType(codec.name); | 2163 if (external_decoder_factory_ != nullptr) { |
2139 | 2164 std::unique_ptr<webrtc::VideoDecoder> external_decoder = |
2140 const auto& found = std::find_if( | 2165 CreateScopedVideoDecoder(external_decoder_factory_, codec, |
2141 old_decoders->begin(), old_decoders->end(), | 2166 decoder_params); |
2142 [type](const AllocatedDecoder decoder) { return decoder.type == type; }); | 2167 if (external_decoder) { |
2143 if (found != old_decoders->end()) { | 2168 webrtc::VideoCodecType type = |
2144 AllocatedDecoder decoder = *found; | 2169 webrtc::PayloadStringToCodecType(codec.name); |
2145 old_decoders->erase(found); | 2170 std::unique_ptr<webrtc::VideoDecoder> internal_decoder( |
2146 return decoder; | 2171 new webrtc::VideoDecoderSoftwareFallbackWrapper( |
2147 } | 2172 type, std::move(external_decoder))); |
2148 | 2173 return internal_decoder; |
2149 if (external_decoder_factory_ != NULL) { | |
2150 webrtc::VideoDecoder* decoder = | |
2151 external_decoder_factory_->CreateVideoDecoderWithParams( | |
2152 codec, {stream_params_.id}); | |
2153 if (decoder != NULL) { | |
2154 return AllocatedDecoder(decoder, type, true /* is_external */); | |
2155 } | 2174 } |
2156 } | 2175 } |
2157 | 2176 |
2158 InternalDecoderFactory internal_decoder_factory; | 2177 std::unique_ptr<webrtc::VideoDecoder> internal_decoder( |
2159 return AllocatedDecoder(internal_decoder_factory.CreateVideoDecoderWithParams( | 2178 internal_decoder_factory_->CreateVideoDecoderWithParams(codec, |
2160 codec, {stream_params_.id}), | 2179 decoder_params)); |
2161 type, false /* is_external */); | 2180 return internal_decoder; |
2162 } | 2181 } |
2163 | 2182 |
2164 void WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureCodecs( | 2183 void WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureCodecs( |
2165 const std::vector<VideoCodecSettings>& recv_codecs, | 2184 const std::vector<VideoCodecSettings>& recv_codecs, |
2166 std::vector<AllocatedDecoder>* old_decoders) { | 2185 std::map<webrtc::SdpVideoFormat, |
2167 *old_decoders = allocated_decoders_; | 2186 std::unique_ptr<webrtc::VideoDecoder>, |
2168 allocated_decoders_.clear(); | 2187 webrtc::SdpVideoFormatCompare>* old_decoders) { |
2188 *old_decoders = std::move(allocated_decoders_); | |
2169 config_.decoders.clear(); | 2189 config_.decoders.clear(); |
2170 config_.rtp.rtx_associated_payload_types.clear(); | 2190 config_.rtp.rtx_associated_payload_types.clear(); |
2171 for (const auto& recv_codec : recv_codecs) { | 2191 for (const auto& recv_codec : recv_codecs) { |
2172 AllocatedDecoder allocated_decoder = | 2192 webrtc::SdpVideoFormat video_format = |
magjed_webrtc
2017/09/11 14:59:21
Just write:
webrtc::SdpVideoFormat video_format(re
andersc
2017/09/11 15:29:09
Done.
| |
2173 CreateOrReuseVideoDecoder(old_decoders, recv_codec.codec); | 2193 webrtc::SdpVideoFormat(recv_codec.codec.name, recv_codec.codec.params); |
2174 allocated_decoders_.push_back(allocated_decoder); | 2194 std::unique_ptr<webrtc::VideoDecoder> new_decoder; |
2195 | |
2196 auto it = old_decoders->find(video_format); | |
2197 if (it != old_decoders->end()) { | |
2198 new_decoder = std::move(it->second); | |
2199 old_decoders->erase(it); | |
2200 } | |
2201 | |
2202 if (!new_decoder) { | |
2203 new_decoder = decoder_factory_->CreateVideoDecoder(recv_codec.codec, | |
2204 {stream_params_.id}); | |
2205 } | |
2175 | 2206 |
2176 webrtc::VideoReceiveStream::Decoder decoder; | 2207 webrtc::VideoReceiveStream::Decoder decoder; |
2177 decoder.decoder = allocated_decoder.decoder; | 2208 decoder.decoder = new_decoder.get(); |
2178 decoder.payload_type = recv_codec.codec.id; | 2209 decoder.payload_type = recv_codec.codec.id; |
2179 decoder.payload_name = recv_codec.codec.name; | 2210 decoder.payload_name = recv_codec.codec.name; |
2180 decoder.codec_params = recv_codec.codec.params; | 2211 decoder.codec_params = recv_codec.codec.params; |
2181 config_.decoders.push_back(decoder); | 2212 config_.decoders.push_back(decoder); |
2182 config_.rtp.rtx_associated_payload_types[recv_codec.rtx_payload_type] = | 2213 config_.rtp.rtx_associated_payload_types[recv_codec.rtx_payload_type] = |
2183 recv_codec.codec.id; | 2214 recv_codec.codec.id; |
2215 | |
2216 allocated_decoders_.insert( | |
magjed_webrtc
2017/09/11 14:59:21
Check that we actually inserted something and didn
andersc
2017/09/11 15:29:09
Done.
| |
2217 std::make_pair(video_format, std::move(new_decoder))); | |
2184 } | 2218 } |
2185 | 2219 |
2186 config_.rtp.ulpfec = recv_codecs.front().ulpfec; | 2220 config_.rtp.ulpfec = recv_codecs.front().ulpfec; |
2187 | 2221 |
2188 config_.rtp.nack.rtp_history_ms = | 2222 config_.rtp.nack.rtp_history_ms = |
2189 HasNack(recv_codecs.begin()->codec) ? kNackHistoryMs : 0; | 2223 HasNack(recv_codecs.begin()->codec) ? kNackHistoryMs : 0; |
2190 if (config_.rtp.ulpfec.red_rtx_payload_type != -1) { | 2224 if (config_.rtp.ulpfec.red_rtx_payload_type != -1) { |
2191 config_.rtp | 2225 config_.rtp |
2192 .rtx_associated_payload_types[config_.rtp.ulpfec.red_rtx_payload_type] = | 2226 .rtx_associated_payload_types[config_.rtp.ulpfec.red_rtx_payload_type] = |
2193 config_.rtp.ulpfec.red_payload_type; | 2227 config_.rtp.ulpfec.red_payload_type; |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2250 << nack_enabled << ", remb=" << remb_enabled | 2284 << nack_enabled << ", remb=" << remb_enabled |
2251 << ", transport_cc=" << transport_cc_enabled; | 2285 << ", transport_cc=" << transport_cc_enabled; |
2252 MaybeRecreateWebRtcFlexfecStream(); | 2286 MaybeRecreateWebRtcFlexfecStream(); |
2253 RecreateWebRtcVideoStream(); | 2287 RecreateWebRtcVideoStream(); |
2254 } | 2288 } |
2255 | 2289 |
2256 void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetRecvParameters( | 2290 void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetRecvParameters( |
2257 const ChangedRecvParameters& params) { | 2291 const ChangedRecvParameters& params) { |
2258 bool video_needs_recreation = false; | 2292 bool video_needs_recreation = false; |
2259 bool flexfec_needs_recreation = false; | 2293 bool flexfec_needs_recreation = false; |
2260 std::vector<AllocatedDecoder> old_decoders; | 2294 std::map<webrtc::SdpVideoFormat, std::unique_ptr<webrtc::VideoDecoder>, |
2295 webrtc::SdpVideoFormatCompare> | |
2296 old_decoders; | |
2261 if (params.codec_settings) { | 2297 if (params.codec_settings) { |
2262 ConfigureCodecs(*params.codec_settings, &old_decoders); | 2298 ConfigureCodecs(*params.codec_settings, &old_decoders); |
2263 video_needs_recreation = true; | 2299 video_needs_recreation = true; |
2264 } | 2300 } |
2265 if (params.rtp_header_extensions) { | 2301 if (params.rtp_header_extensions) { |
2266 config_.rtp.extensions = *params.rtp_header_extensions; | 2302 config_.rtp.extensions = *params.rtp_header_extensions; |
2267 flexfec_config_.rtp_header_extensions = *params.rtp_header_extensions; | 2303 flexfec_config_.rtp_header_extensions = *params.rtp_header_extensions; |
2268 video_needs_recreation = true; | 2304 video_needs_recreation = true; |
2269 flexfec_needs_recreation = true; | 2305 flexfec_needs_recreation = true; |
2270 } | 2306 } |
2271 if (params.flexfec_payload_type) { | 2307 if (params.flexfec_payload_type) { |
2272 ConfigureFlexfecCodec(*params.flexfec_payload_type); | 2308 ConfigureFlexfecCodec(*params.flexfec_payload_type); |
2273 flexfec_needs_recreation = true; | 2309 flexfec_needs_recreation = true; |
2274 } | 2310 } |
2275 if (flexfec_needs_recreation) { | 2311 if (flexfec_needs_recreation) { |
2276 LOG(LS_INFO) << "MaybeRecreateWebRtcFlexfecStream (recv) because of " | 2312 LOG(LS_INFO) << "MaybeRecreateWebRtcFlexfecStream (recv) because of " |
2277 "SetRecvParameters"; | 2313 "SetRecvParameters"; |
2278 MaybeRecreateWebRtcFlexfecStream(); | 2314 MaybeRecreateWebRtcFlexfecStream(); |
2279 } | 2315 } |
2280 if (video_needs_recreation) { | 2316 if (video_needs_recreation) { |
2281 LOG(LS_INFO) | 2317 LOG(LS_INFO) |
2282 << "RecreateWebRtcVideoStream (recv) because of SetRecvParameters"; | 2318 << "RecreateWebRtcVideoStream (recv) because of SetRecvParameters"; |
2283 RecreateWebRtcVideoStream(); | 2319 RecreateWebRtcVideoStream(); |
2284 ClearDecoders(&old_decoders); | |
2285 } | 2320 } |
2286 } | 2321 } |
2287 | 2322 |
2288 void WebRtcVideoChannel::WebRtcVideoReceiveStream:: | 2323 void WebRtcVideoChannel::WebRtcVideoReceiveStream:: |
2289 RecreateWebRtcVideoStream() { | 2324 RecreateWebRtcVideoStream() { |
2290 if (stream_) { | 2325 if (stream_) { |
2291 MaybeDissociateFlexfecFromVideo(); | 2326 MaybeDissociateFlexfecFromVideo(); |
2292 call_->DestroyVideoReceiveStream(stream_); | 2327 call_->DestroyVideoReceiveStream(stream_); |
2293 stream_ = nullptr; | 2328 stream_ = nullptr; |
2294 } | 2329 } |
(...skipping 24 matching lines...) Expand all Loading... | |
2319 } | 2354 } |
2320 } | 2355 } |
2321 | 2356 |
2322 void WebRtcVideoChannel::WebRtcVideoReceiveStream:: | 2357 void WebRtcVideoChannel::WebRtcVideoReceiveStream:: |
2323 MaybeDissociateFlexfecFromVideo() { | 2358 MaybeDissociateFlexfecFromVideo() { |
2324 if (stream_ && flexfec_stream_) { | 2359 if (stream_ && flexfec_stream_) { |
2325 stream_->RemoveSecondarySink(flexfec_stream_); | 2360 stream_->RemoveSecondarySink(flexfec_stream_); |
2326 } | 2361 } |
2327 } | 2362 } |
2328 | 2363 |
2329 void WebRtcVideoChannel::WebRtcVideoReceiveStream::ClearDecoders( | |
2330 std::vector<AllocatedDecoder>* allocated_decoders) { | |
2331 for (auto& dec : *allocated_decoders) { | |
2332 if (dec.external) | |
2333 external_decoder_factory_->DestroyVideoDecoder(dec.external_decoder); | |
2334 delete dec.decoder; | |
2335 } | |
2336 allocated_decoders->clear(); | |
2337 } | |
2338 | |
2339 void WebRtcVideoChannel::WebRtcVideoReceiveStream::OnFrame( | 2364 void WebRtcVideoChannel::WebRtcVideoReceiveStream::OnFrame( |
2340 const webrtc::VideoFrame& frame) { | 2365 const webrtc::VideoFrame& frame) { |
2341 rtc::CritScope crit(&sink_lock_); | 2366 rtc::CritScope crit(&sink_lock_); |
2342 | 2367 |
2343 if (first_frame_timestamp_ < 0) | 2368 if (first_frame_timestamp_ < 0) |
2344 first_frame_timestamp_ = frame.timestamp(); | 2369 first_frame_timestamp_ = frame.timestamp(); |
2345 int64_t rtp_time_elapsed_since_first_frame = | 2370 int64_t rtp_time_elapsed_since_first_frame = |
2346 (timestamp_wraparound_handler_.Unwrap(frame.timestamp()) - | 2371 (timestamp_wraparound_handler_.Unwrap(frame.timestamp()) - |
2347 first_frame_timestamp_); | 2372 first_frame_timestamp_); |
2348 int64_t elapsed_time_ms = rtp_time_elapsed_since_first_frame / | 2373 int64_t elapsed_time_ms = rtp_time_elapsed_since_first_frame / |
(...skipping 263 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2612 stream.temporal_layer_thresholds_bps.resize(GetDefaultVp9TemporalLayers() - | 2637 stream.temporal_layer_thresholds_bps.resize(GetDefaultVp9TemporalLayers() - |
2613 1); | 2638 1); |
2614 } | 2639 } |
2615 | 2640 |
2616 std::vector<webrtc::VideoStream> streams; | 2641 std::vector<webrtc::VideoStream> streams; |
2617 streams.push_back(stream); | 2642 streams.push_back(stream); |
2618 return streams; | 2643 return streams; |
2619 } | 2644 } |
2620 | 2645 |
2621 } // namespace cricket | 2646 } // namespace cricket |
OLD | NEW |