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 "media/engine/webrtcvideoengine.h" | 11 #include "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 "api/video/i420_buffer.h" | 19 #include "api/video/i420_buffer.h" |
20 #include "api/video_codecs/sdp_video_format.h" | 20 #include "api/video_codecs/sdp_video_format.h" |
21 #include "api/video_codecs/video_decoder.h" | 21 #include "api/video_codecs/video_decoder.h" |
22 #include "api/video_codecs/video_decoder_factory.h" | 22 #include "api/video_codecs/video_decoder_factory.h" |
23 #include "api/video_codecs/video_encoder.h" | 23 #include "api/video_codecs/video_encoder.h" |
24 #include "api/video_codecs/video_encoder_factory.h" | 24 #include "api/video_codecs/video_encoder_factory.h" |
25 #include "call/call.h" | 25 #include "call/call.h" |
26 #include "common_video/h264/profile_level_id.h" | 26 #include "common_video/h264/profile_level_id.h" |
| 27 #include "media/base/codec.h" |
27 #include "media/engine/constants.h" | 28 #include "media/engine/constants.h" |
28 #include "media/engine/internaldecoderfactory.h" | 29 #include "media/engine/internaldecoderfactory.h" |
29 #include "media/engine/internalencoderfactory.h" | 30 #include "media/engine/internalencoderfactory.h" |
30 #include "media/engine/scopedvideodecoder.h" | 31 #include "media/engine/scopedvideodecoder.h" |
31 #include "media/engine/scopedvideoencoder.h" | 32 #include "media/engine/scopedvideoencoder.h" |
32 #include "media/engine/simulcast.h" | 33 #include "media/engine/simulcast.h" |
33 #include "media/engine/simulcast_encoder_adapter.h" | 34 #include "media/engine/simulcast_encoder_adapter.h" |
34 #include "media/engine/videodecodersoftwarefallbackwrapper.h" | 35 #include "media/engine/videodecodersoftwarefallbackwrapper.h" |
35 #include "media/engine/videoencodersoftwarefallbackwrapper.h" | 36 #include "media/engine/videoencodersoftwarefallbackwrapper.h" |
36 #include "media/engine/webrtcmediaengine.h" | 37 #include "media/engine/webrtcmediaengine.h" |
37 #include "media/engine/webrtcvideoencoderfactory.h" | 38 #include "media/engine/webrtcvideoencoderfactory.h" |
38 #include "media/engine/webrtcvoiceengine.h" | 39 #include "media/engine/webrtcvoiceengine.h" |
| 40 #include "modules/video_coding/codecs/stereo/include/stereo_decoder_adapter.h" |
| 41 #include "modules/video_coding/codecs/stereo/include/stereo_encoder_adapter.h" |
39 #include "rtc_base/copyonwritebuffer.h" | 42 #include "rtc_base/copyonwritebuffer.h" |
40 #include "rtc_base/logging.h" | 43 #include "rtc_base/logging.h" |
41 #include "rtc_base/stringutils.h" | 44 #include "rtc_base/stringutils.h" |
42 #include "rtc_base/timeutils.h" | 45 #include "rtc_base/timeutils.h" |
43 #include "rtc_base/trace_event.h" | 46 #include "rtc_base/trace_event.h" |
44 #include "system_wrappers/include/field_trial.h" | 47 #include "system_wrappers/include/field_trial.h" |
45 | 48 |
46 using DegradationPreference = webrtc::VideoSendStream::DegradationPreference; | 49 using DegradationPreference = webrtc::VideoSendStream::DegradationPreference; |
47 | 50 |
48 namespace cricket { | 51 namespace cricket { |
(...skipping 14 matching lines...) Expand all Loading... |
63 bool is_hardware_accelerated; | 66 bool is_hardware_accelerated; |
64 bool has_internal_source; | 67 bool has_internal_source; |
65 }; | 68 }; |
66 | 69 |
67 virtual ~EncoderFactoryAdapter() {} | 70 virtual ~EncoderFactoryAdapter() {} |
68 | 71 |
69 virtual AllocatedEncoder CreateVideoEncoder( | 72 virtual AllocatedEncoder CreateVideoEncoder( |
70 const VideoCodec& codec, | 73 const VideoCodec& codec, |
71 bool is_conference_mode_screenshare) const = 0; | 74 bool is_conference_mode_screenshare) const = 0; |
72 | 75 |
| 76 virtual AllocatedEncoder CreateStereoVideoEncoder( |
| 77 const VideoCodec& codec) = 0; |
| 78 |
73 virtual std::vector<VideoCodec> GetSupportedCodecs() const = 0; | 79 virtual std::vector<VideoCodec> GetSupportedCodecs() const = 0; |
74 }; | 80 }; |
75 | 81 |
76 class DecoderFactoryAdapter { | 82 class DecoderFactoryAdapter { |
77 public: | 83 public: |
78 virtual ~DecoderFactoryAdapter() {} | 84 virtual ~DecoderFactoryAdapter() {} |
79 | 85 |
80 virtual std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder( | 86 virtual std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder( |
81 const VideoCodec& codec, | 87 const VideoCodec& codec, |
82 const VideoDecoderParams& decoder_params) const = 0; | 88 const VideoDecoderParams& decoder_params) const = 0; |
| 89 |
| 90 virtual std::unique_ptr<webrtc::VideoDecoder> CreateStereoVideoDecoder( |
| 91 const VideoCodec& codec, |
| 92 VideoDecoderParams params) = 0; |
83 }; | 93 }; |
84 | 94 |
85 namespace { | 95 namespace { |
86 | 96 |
87 std::vector<VideoCodec> AssignPayloadTypesAndAddAssociatedRtxCodecs( | 97 std::vector<VideoCodec> AssignPayloadTypesAndAddAssociatedRtxCodecs( |
88 const std::vector<VideoCodec>& input_codecs); | 98 const std::vector<VideoCodec>& input_codecs); |
89 | 99 |
90 // Wraps cricket::WebRtcVideoEncoderFactory* into common EncoderFactoryAdapter | 100 // Wraps cricket::WebRtcVideoEncoderFactory* into common EncoderFactoryAdapter |
91 // interface. | 101 // interface. |
92 // TODO(magjed): Remove once WebRtcVideoEncoderFactory* is deprecated and | 102 // TODO(magjed): Remove once WebRtcVideoEncoderFactory* is deprecated and |
93 // webrtc:7925 is fixed. | 103 // webrtc:7925 is fixed. |
94 class CricketEncoderFactoryAdapter : public EncoderFactoryAdapter { | 104 class CricketEncoderFactoryAdapter : public EncoderFactoryAdapter { |
95 public: | 105 public: |
96 explicit CricketEncoderFactoryAdapter( | 106 explicit CricketEncoderFactoryAdapter( |
97 WebRtcVideoEncoderFactory* external_encoder_factory) | 107 WebRtcVideoEncoderFactory* external_encoder_factory) |
98 : internal_encoder_factory_(new InternalEncoderFactory()), | 108 : internal_encoder_factory_(new InternalEncoderFactory()), |
99 external_encoder_factory_(external_encoder_factory) {} | 109 external_encoder_factory_(external_encoder_factory) {} |
100 | 110 |
101 private: | 111 private: |
102 explicit CricketEncoderFactoryAdapter( | 112 explicit CricketEncoderFactoryAdapter( |
103 const CricketEncoderFactoryAdapter& other) | 113 const CricketEncoderFactoryAdapter& other) |
104 : CricketEncoderFactoryAdapter(other.external_encoder_factory_) {} | 114 : CricketEncoderFactoryAdapter(other.external_encoder_factory_) {} |
105 | 115 |
106 AllocatedEncoder CreateVideoEncoder( | 116 AllocatedEncoder CreateVideoEncoder( |
107 const VideoCodec& codec, | 117 const VideoCodec& codec, |
108 bool is_conference_mode_screenshare) const override; | 118 bool is_conference_mode_screenshare) const override; |
109 | 119 |
| 120 AllocatedEncoder CreateStereoVideoEncoder(const VideoCodec& codec) override; |
| 121 |
110 std::vector<VideoCodec> GetSupportedCodecs() const override; | 122 std::vector<VideoCodec> GetSupportedCodecs() const override; |
111 | 123 |
112 const std::unique_ptr<WebRtcVideoEncoderFactory> internal_encoder_factory_; | 124 const std::unique_ptr<WebRtcVideoEncoderFactory> internal_encoder_factory_; |
113 WebRtcVideoEncoderFactory* const external_encoder_factory_; | 125 WebRtcVideoEncoderFactory* const external_encoder_factory_; |
| 126 std::unique_ptr<WebRtcVideoEncoderFactory> stereo_encoder_factory_; |
114 }; | 127 }; |
115 | 128 |
116 class CricketDecoderFactoryAdapter : public DecoderFactoryAdapter { | 129 class CricketDecoderFactoryAdapter : public DecoderFactoryAdapter { |
117 public: | 130 public: |
118 explicit CricketDecoderFactoryAdapter( | 131 explicit CricketDecoderFactoryAdapter( |
119 WebRtcVideoDecoderFactory* external_decoder_factory) | 132 WebRtcVideoDecoderFactory* external_decoder_factory) |
120 : internal_decoder_factory_(new InternalDecoderFactory()), | 133 : internal_decoder_factory_(new InternalDecoderFactory()), |
121 external_decoder_factory_(external_decoder_factory) {} | 134 external_decoder_factory_(external_decoder_factory) {} |
122 | 135 |
123 private: | 136 private: |
124 explicit CricketDecoderFactoryAdapter( | 137 explicit CricketDecoderFactoryAdapter( |
125 const CricketDecoderFactoryAdapter& other) | 138 const CricketDecoderFactoryAdapter& other) |
126 : CricketDecoderFactoryAdapter(other.external_decoder_factory_) {} | 139 : CricketDecoderFactoryAdapter(other.external_decoder_factory_) {} |
127 | 140 |
128 std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder( | 141 std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder( |
129 const VideoCodec& codec, | 142 const VideoCodec& codec, |
130 const VideoDecoderParams& decoder_params) const override; | 143 const VideoDecoderParams& decoder_params) const override; |
131 | 144 |
| 145 std::unique_ptr<webrtc::VideoDecoder> CreateStereoVideoDecoder( |
| 146 const VideoCodec& codec, |
| 147 VideoDecoderParams params) override; |
| 148 |
132 const std::unique_ptr<WebRtcVideoDecoderFactory> internal_decoder_factory_; | 149 const std::unique_ptr<WebRtcVideoDecoderFactory> internal_decoder_factory_; |
133 WebRtcVideoDecoderFactory* const external_decoder_factory_; | 150 WebRtcVideoDecoderFactory* const external_decoder_factory_; |
| 151 std::unique_ptr<WebRtcVideoDecoderFactory> stereo_decoder_factory_; |
134 }; | 152 }; |
135 | 153 |
136 // Wraps webrtc::VideoEncoderFactory into common EncoderFactoryAdapter | 154 // Wraps webrtc::VideoEncoderFactory into common EncoderFactoryAdapter |
137 // interface. | 155 // interface. |
138 class WebRtcEncoderFactoryAdapter : public EncoderFactoryAdapter { | 156 class WebRtcEncoderFactoryAdapter : public EncoderFactoryAdapter { |
139 public: | 157 public: |
140 explicit WebRtcEncoderFactoryAdapter( | 158 explicit WebRtcEncoderFactoryAdapter( |
141 std::unique_ptr<webrtc::VideoEncoderFactory> encoder_factory) | 159 std::unique_ptr<webrtc::VideoEncoderFactory> encoder_factory) |
142 : encoder_factory_(std::move(encoder_factory)) {} | 160 : encoder_factory_(std::move(encoder_factory)) {} |
143 | 161 |
144 private: | 162 private: |
145 AllocatedEncoder CreateVideoEncoder( | 163 AllocatedEncoder CreateVideoEncoder( |
146 const VideoCodec& codec, | 164 const VideoCodec& codec, |
147 bool is_conference_mode_screenshare) const override { | 165 bool is_conference_mode_screenshare) const override { |
148 if (!encoder_factory_) | 166 if (!encoder_factory_) |
149 return AllocatedEncoder(); | 167 return AllocatedEncoder(); |
150 const webrtc::SdpVideoFormat format(codec.name, codec.params); | 168 const webrtc::SdpVideoFormat format(codec.name, codec.params); |
151 const webrtc::VideoEncoderFactory::CodecInfo info = | 169 const webrtc::VideoEncoderFactory::CodecInfo info = |
152 encoder_factory_->QueryVideoEncoder(format); | 170 encoder_factory_->QueryVideoEncoder(format); |
153 return AllocatedEncoder(encoder_factory_->CreateVideoEncoder(format), | 171 return AllocatedEncoder(encoder_factory_->CreateVideoEncoder(format), |
154 info.is_hardware_accelerated, | 172 info.is_hardware_accelerated, |
155 info.has_internal_source); | 173 info.has_internal_source); |
156 } | 174 } |
157 | 175 |
| 176 AllocatedEncoder CreateStereoVideoEncoder(const VideoCodec& codec) override { |
| 177 return AllocatedEncoder(); |
| 178 } |
| 179 |
158 std::vector<VideoCodec> GetSupportedCodecs() const override { | 180 std::vector<VideoCodec> GetSupportedCodecs() const override { |
159 if (!encoder_factory_) | 181 if (!encoder_factory_) |
160 return std::vector<VideoCodec>(); | 182 return std::vector<VideoCodec>(); |
161 std::vector<VideoCodec> codecs; | 183 std::vector<VideoCodec> codecs; |
162 for (const webrtc::SdpVideoFormat& format : | 184 for (const webrtc::SdpVideoFormat& format : |
163 encoder_factory_->GetSupportedFormats()) { | 185 encoder_factory_->GetSupportedFormats()) { |
164 VideoCodec codec; | 186 VideoCodec codec; |
165 codec.name = format.name; | 187 codec.name = format.name; |
166 codec.params = format.parameters; | 188 codec.params = format.parameters; |
167 codecs.push_back(codec); | 189 codecs.push_back(codec); |
(...skipping 14 matching lines...) Expand all Loading... |
182 | 204 |
183 private: | 205 private: |
184 std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder( | 206 std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder( |
185 const VideoCodec& codec, | 207 const VideoCodec& codec, |
186 const VideoDecoderParams& decoder_params) const override { | 208 const VideoDecoderParams& decoder_params) const override { |
187 return decoder_factory_ | 209 return decoder_factory_ |
188 ? decoder_factory_->CreateVideoDecoder( | 210 ? decoder_factory_->CreateVideoDecoder( |
189 webrtc::SdpVideoFormat(codec.name, codec.params)) | 211 webrtc::SdpVideoFormat(codec.name, codec.params)) |
190 : nullptr; | 212 : nullptr; |
191 } | 213 } |
| 214 std::unique_ptr<webrtc::VideoDecoder> CreateStereoVideoDecoder( |
| 215 const VideoCodec& codec, |
| 216 VideoDecoderParams params) override { |
| 217 return nullptr; |
| 218 } |
192 | 219 |
193 std::unique_ptr<webrtc::VideoDecoderFactory> decoder_factory_; | 220 std::unique_ptr<webrtc::VideoDecoderFactory> decoder_factory_; |
194 }; | 221 }; |
195 | 222 |
| 223 // Wrap cricket::WebRtcVideoEncoderFactory as a webrtc::VideoEncoderFactory. |
| 224 class StereoEncoderFactoryAdapter : public webrtc::VideoEncoderFactoryEx { |
| 225 public: |
| 226 // StereoEncoderFactoryAdapter doesn't take ownership of |factory|, which is |
| 227 // owned by e.g. PeerConnectionFactory. |
| 228 explicit StereoEncoderFactoryAdapter( |
| 229 cricket::WebRtcVideoEncoderFactory* factory, |
| 230 const cricket::VideoCodec& codec) |
| 231 : factory_(factory), codec_(codec) {} |
| 232 virtual ~StereoEncoderFactoryAdapter() {} |
| 233 |
| 234 // Implement webrtc::VideoEncoderFactory. |
| 235 webrtc::VideoEncoder* Create() override { |
| 236 return factory_->CreateVideoEncoder(codec_); |
| 237 } |
| 238 |
| 239 void Destroy(webrtc::VideoEncoder* encoder) override { |
| 240 return factory_->DestroyVideoEncoder(encoder); |
| 241 } |
| 242 |
| 243 private: |
| 244 cricket::WebRtcVideoEncoderFactory* const factory_; |
| 245 const cricket::VideoCodec codec_; |
| 246 }; |
| 247 |
| 248 // An encoder factory that wraps Create requests for all codec types |
| 249 // with a webrtc::StereoEncoderAdapter. |
| 250 class WebRtcStereoEncoderFactory : public cricket::WebRtcVideoEncoderFactory { |
| 251 public: |
| 252 explicit WebRtcStereoEncoderFactory( |
| 253 cricket::WebRtcVideoEncoderFactory* factory) |
| 254 : factory_(factory) {} |
| 255 |
| 256 webrtc::VideoEncoder* CreateVideoEncoder( |
| 257 const cricket::VideoCodec& codec) override { |
| 258 RTC_DCHECK(factory_ != NULL); |
| 259 return new webrtc::StereoEncoderAdapter( |
| 260 new StereoEncoderFactoryAdapter(factory_, codec)); |
| 261 } |
| 262 |
| 263 const std::vector<cricket::VideoCodec>& supported_codecs() const override { |
| 264 return factory_->supported_codecs(); |
| 265 } |
| 266 |
| 267 bool EncoderTypeHasInternalSource( |
| 268 webrtc::VideoCodecType type) const override { |
| 269 return factory_->EncoderTypeHasInternalSource(type); |
| 270 } |
| 271 |
| 272 void DestroyVideoEncoder(webrtc::VideoEncoder* encoder) override { |
| 273 delete encoder; |
| 274 } |
| 275 |
| 276 private: |
| 277 cricket::WebRtcVideoEncoderFactory* factory_; |
| 278 }; |
| 279 |
| 280 // Wrap cricket::WebRtcVideoDecoderFactory as a webrtc::VideoDecoderFactory. |
| 281 class StereoDecoderFactoryAdapter : public webrtc::VideoDecoderFactoryEx { |
| 282 public: |
| 283 // StereoDecoderFactoryAdapter doesn't take ownership of |factory|. |
| 284 explicit StereoDecoderFactoryAdapter( |
| 285 cricket::WebRtcVideoDecoderFactory* factory, |
| 286 webrtc::VideoCodecType type, |
| 287 VideoDecoderParams* params) |
| 288 : factory_(factory), type_(type) { |
| 289 if (params) { |
| 290 params_.reset(new VideoDecoderParams(*params)); |
| 291 } |
| 292 } |
| 293 virtual ~StereoDecoderFactoryAdapter() {} |
| 294 |
| 295 // Implement webrtc::VideoDecoderFactory. |
| 296 webrtc::VideoDecoder* Create() override { |
| 297 RTC_DCHECK(factory_); |
| 298 if (params_) |
| 299 return factory_->CreateVideoDecoderWithParams(type_, *params_); |
| 300 else |
| 301 return factory_->CreateVideoDecoder(type_); |
| 302 } |
| 303 |
| 304 void Destroy(webrtc::VideoDecoder* decoder) override { |
| 305 return factory_->DestroyVideoDecoder(decoder); |
| 306 } |
| 307 |
| 308 private: |
| 309 cricket::WebRtcVideoDecoderFactory* const factory_; |
| 310 const webrtc::VideoCodecType type_; |
| 311 std::unique_ptr<VideoDecoderParams> params_; |
| 312 }; |
| 313 |
| 314 // A decoder factory that wraps Create requests for all codec types |
| 315 // with a webrtc::StereoDecoderAdapter. |
| 316 class WebRtcStereoDecoderFactory : public cricket::WebRtcVideoDecoderFactory { |
| 317 public: |
| 318 explicit WebRtcStereoDecoderFactory( |
| 319 cricket::WebRtcVideoDecoderFactory* factory) |
| 320 : factory_(factory) {} |
| 321 |
| 322 webrtc::VideoDecoder* CreateVideoDecoder( |
| 323 webrtc::VideoCodecType type) override { |
| 324 RTC_DCHECK(factory_ != NULL); |
| 325 return new webrtc::StereoDecoderAdapter(new StereoDecoderFactoryAdapter( |
| 326 factory_, webrtc::kVideoCodecVP9, nullptr)); |
| 327 } |
| 328 |
| 329 webrtc::VideoDecoder* CreateVideoDecoderWithParams( |
| 330 webrtc::VideoCodecType type, |
| 331 VideoDecoderParams params) override { |
| 332 RTC_DCHECK(factory_ != NULL); |
| 333 return new webrtc::StereoDecoderAdapter(new StereoDecoderFactoryAdapter( |
| 334 factory_, webrtc::kVideoCodecVP9, ¶ms)); |
| 335 } |
| 336 |
| 337 void DestroyVideoDecoder(webrtc::VideoDecoder* decoder) override { |
| 338 delete decoder; |
| 339 } |
| 340 |
| 341 private: |
| 342 cricket::WebRtcVideoDecoderFactory* factory_; |
| 343 }; |
| 344 |
196 // If this field trial is enabled, we will enable sending FlexFEC and disable | 345 // If this field trial is enabled, we will enable sending FlexFEC and disable |
197 // sending ULPFEC whenever the former has been negotiated in the SDPs. | 346 // sending ULPFEC whenever the former has been negotiated in the SDPs. |
198 bool IsFlexfecFieldTrialEnabled() { | 347 bool IsFlexfecFieldTrialEnabled() { |
199 return webrtc::field_trial::IsEnabled("WebRTC-FlexFEC-03"); | 348 return webrtc::field_trial::IsEnabled("WebRTC-FlexFEC-03"); |
200 } | 349 } |
201 | 350 |
202 // If this field trial is enabled, the "flexfec-03" codec may have been | 351 // If this field trial is enabled, the "flexfec-03" codec may have been |
203 // advertised as being supported in the local SDP. That means that we must be | 352 // advertised as being supported in the local SDP. That means that we must be |
204 // ready to receive FlexFEC packets. See internalencoderfactory.cc. | 353 // ready to receive FlexFEC packets. See internalencoderfactory.cc. |
205 bool IsFlexfecAdvertisedFieldTrialEnabled() { | 354 bool IsFlexfecAdvertisedFieldTrialEnabled() { |
(...skipping 343 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
549 CodecNamesEq(codec.name, kH264CodecName) || | 698 CodecNamesEq(codec.name, kH264CodecName) || |
550 CodecNamesEq(codec.name, kRedCodecName)) { | 699 CodecNamesEq(codec.name, kRedCodecName)) { |
551 output_codecs.push_back( | 700 output_codecs.push_back( |
552 VideoCodec::CreateRtxCodec(payload_type, codec.id)); | 701 VideoCodec::CreateRtxCodec(payload_type, codec.id)); |
553 | 702 |
554 // Increment payload type. | 703 // Increment payload type. |
555 ++payload_type; | 704 ++payload_type; |
556 if (payload_type > kLastDynamicPayloadType) | 705 if (payload_type > kLastDynamicPayloadType) |
557 break; | 706 break; |
558 } | 707 } |
| 708 |
| 709 if (CodecNamesEq(codec.name, kVp9CodecName)) { |
| 710 output_codecs.push_back( |
| 711 VideoCodec::CreateStereoCodec(payload_type, codec)); |
| 712 ++payload_type; |
| 713 if (payload_type > kLastDynamicPayloadType) |
| 714 break; |
| 715 } |
559 } | 716 } |
560 return output_codecs; | 717 return output_codecs; |
561 } | 718 } |
562 } // namespace | 719 } // namespace |
563 | 720 |
564 std::vector<VideoCodec> CricketEncoderFactoryAdapter::GetSupportedCodecs() | 721 std::vector<VideoCodec> CricketEncoderFactoryAdapter::GetSupportedCodecs() |
565 const { | 722 const { |
566 std::vector<VideoCodec> codecs = InternalEncoderFactory().supported_codecs(); | 723 std::vector<VideoCodec> codecs = InternalEncoderFactory().supported_codecs(); |
567 LOG(LS_INFO) << "Internally supported codecs: " | 724 LOG(LS_INFO) << "Internally supported codecs: " |
568 << CodecVectorToString(codecs); | 725 << CodecVectorToString(codecs); |
569 | 726 |
570 // Add external codecs. | 727 // Add external codecs. |
571 if (external_encoder_factory_ != nullptr) { | 728 if (external_encoder_factory_ != nullptr) { |
572 const std::vector<VideoCodec>& external_codecs = | 729 const std::vector<VideoCodec>& external_codecs = |
573 external_encoder_factory_->supported_codecs(); | 730 external_encoder_factory_->supported_codecs(); |
574 for (const VideoCodec& codec : external_codecs) { | 731 for (const VideoCodec& codec : external_codecs) { |
575 // Don't add same codec twice. | 732 // Don't add same codec twice. |
576 if (!FindMatchingCodec(codecs, codec)) | 733 if (!FindMatchingCodec(codecs, codec)) |
577 codecs.push_back(codec); | 734 codecs.push_back(codec); |
578 } | 735 } |
579 LOG(LS_INFO) << "Codecs supported by the external encoder factory: " | 736 LOG(LS_INFO) << "Codecs supported by the external encoder factory: " |
580 << CodecVectorToString(external_codecs); | 737 << CodecVectorToString(external_codecs); |
581 } | 738 } |
582 | 739 |
583 return AssignPayloadTypesAndAddAssociatedRtxCodecs(codecs); | 740 return AssignPayloadTypesAndAddAssociatedRtxCodecs(codecs); |
584 } | 741 } |
585 | 742 |
586 WebRtcVideoChannel::WebRtcVideoChannel( | 743 WebRtcVideoChannel::WebRtcVideoChannel(webrtc::Call* call, |
587 webrtc::Call* call, | 744 const MediaConfig& config, |
588 const MediaConfig& config, | 745 const VideoOptions& options, |
589 const VideoOptions& options, | 746 EncoderFactoryAdapter* encoder_factory, |
590 const EncoderFactoryAdapter* encoder_factory, | 747 DecoderFactoryAdapter* decoder_factory) |
591 const DecoderFactoryAdapter* decoder_factory) | |
592 : VideoMediaChannel(config), | 748 : VideoMediaChannel(config), |
593 call_(call), | 749 call_(call), |
594 unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_), | 750 unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_), |
595 video_config_(config.video), | 751 video_config_(config.video), |
596 encoder_factory_(encoder_factory), | 752 encoder_factory_(encoder_factory), |
597 decoder_factory_(decoder_factory), | 753 decoder_factory_(decoder_factory), |
598 default_send_options_(options), | 754 default_send_options_(options), |
599 last_stats_log_ms_(-1) { | 755 last_stats_log_ms_(-1) { |
600 RTC_DCHECK(thread_checker_.CalledOnValidThread()); | 756 RTC_DCHECK(thread_checker_.CalledOnValidThread()); |
601 | 757 |
(...skipping 10 matching lines...) Expand all Loading... |
612 delete kv.second; | 768 delete kv.second; |
613 } | 769 } |
614 | 770 |
615 rtc::Optional<WebRtcVideoChannel::VideoCodecSettings> | 771 rtc::Optional<WebRtcVideoChannel::VideoCodecSettings> |
616 WebRtcVideoChannel::SelectSendVideoCodec( | 772 WebRtcVideoChannel::SelectSendVideoCodec( |
617 const std::vector<VideoCodecSettings>& remote_mapped_codecs) const { | 773 const std::vector<VideoCodecSettings>& remote_mapped_codecs) const { |
618 const std::vector<VideoCodec> local_supported_codecs = | 774 const std::vector<VideoCodec> local_supported_codecs = |
619 encoder_factory_->GetSupportedCodecs(); | 775 encoder_factory_->GetSupportedCodecs(); |
620 // Select the first remote codec that is supported locally. | 776 // Select the first remote codec that is supported locally. |
621 for (const VideoCodecSettings& remote_mapped_codec : remote_mapped_codecs) { | 777 for (const VideoCodecSettings& remote_mapped_codec : remote_mapped_codecs) { |
| 778 // HARDCODE TO ALPHA |
| 779 if (!cricket::VideoCodec::IsStereoCodec(remote_mapped_codec.codec)) |
| 780 continue; |
622 // For H264, we will limit the encode level to the remote offered level | 781 // For H264, we will limit the encode level to the remote offered level |
623 // regardless if level asymmetry is allowed or not. This is strictly not | 782 // regardless if level asymmetry is allowed or not. This is strictly not |
624 // following the spec in https://tools.ietf.org/html/rfc6184#section-8.2.2 | 783 // following the spec in https://tools.ietf.org/html/rfc6184#section-8.2.2 |
625 // since we should limit the encode level to the lower of local and remote | 784 // since we should limit the encode level to the lower of local and remote |
626 // level when level asymmetry is not allowed. | 785 // level when level asymmetry is not allowed. |
627 if (FindMatchingCodec(local_supported_codecs, remote_mapped_codec.codec)) | 786 if (FindMatchingCodec(local_supported_codecs, remote_mapped_codec.codec)) |
628 return rtc::Optional<VideoCodecSettings>(remote_mapped_codec); | 787 return rtc::Optional<VideoCodecSettings>(remote_mapped_codec); |
629 } | 788 } |
630 // No remote codec was supported. | 789 // No remote codec was supported. |
631 return rtc::Optional<VideoCodecSettings>(); | 790 return rtc::Optional<VideoCodecSettings>(); |
632 } | 791 } |
633 | 792 |
| 793 rtc::Optional<WebRtcVideoChannel::VideoCodecSettings> |
| 794 WebRtcVideoChannel::SelectStereoAssociatedVideoCodec( |
| 795 const std::vector<VideoCodecSettings>& remote_mapped_codecs) const { |
| 796 const std::vector<VideoCodec> local_supported_codecs = |
| 797 encoder_factory_->GetSupportedCodecs(); |
| 798 |
| 799 // Select the first remote codec that is supported locally. |
| 800 for (const VideoCodecSettings& remote_mapped_codec : remote_mapped_codecs) { |
| 801 // HARDCODE TO VP9 |
| 802 if (!CodecNamesEq(remote_mapped_codec.codec.name.c_str(), kVp9CodecName)) |
| 803 continue; |
| 804 if (!cricket::VideoCodec::IsStereoCodec(remote_mapped_codec.codec) && |
| 805 FindMatchingCodec(local_supported_codecs, remote_mapped_codec.codec)) |
| 806 return rtc::Optional<VideoCodecSettings>(remote_mapped_codec); |
| 807 } |
| 808 return rtc::Optional<VideoCodecSettings>(); |
| 809 } |
| 810 |
634 bool WebRtcVideoChannel::NonFlexfecReceiveCodecsHaveChanged( | 811 bool WebRtcVideoChannel::NonFlexfecReceiveCodecsHaveChanged( |
635 std::vector<VideoCodecSettings> before, | 812 std::vector<VideoCodecSettings> before, |
636 std::vector<VideoCodecSettings> after) { | 813 std::vector<VideoCodecSettings> after) { |
637 if (before.size() != after.size()) { | 814 if (before.size() != after.size()) { |
638 return true; | 815 return true; |
639 } | 816 } |
640 | 817 |
641 // The receive codec order doesn't matter, so we sort the codecs before | 818 // The receive codec order doesn't matter, so we sort the codecs before |
642 // comparing. This is necessary because currently the | 819 // comparing. This is necessary because currently the |
643 // only way to change the send codec is to munge SDP, which causes | 820 // only way to change the send codec is to munge SDP, which causes |
(...skipping 26 matching lines...) Expand all Loading... |
670 | 847 |
671 // Select one of the remote codecs that will be used as send codec. | 848 // Select one of the remote codecs that will be used as send codec. |
672 rtc::Optional<VideoCodecSettings> selected_send_codec = | 849 rtc::Optional<VideoCodecSettings> selected_send_codec = |
673 SelectSendVideoCodec(MapCodecs(params.codecs)); | 850 SelectSendVideoCodec(MapCodecs(params.codecs)); |
674 | 851 |
675 if (!selected_send_codec) { | 852 if (!selected_send_codec) { |
676 LOG(LS_ERROR) << "No video codecs supported."; | 853 LOG(LS_ERROR) << "No video codecs supported."; |
677 return false; | 854 return false; |
678 } | 855 } |
679 | 856 |
| 857 if (VideoCodec::IsStereoCodec(selected_send_codec->codec)) { |
| 858 rtc::Optional<VideoCodecSettings> associated_codec_settings = |
| 859 SelectStereoAssociatedVideoCodec(MapCodecs(params.codecs)); |
| 860 LOG(LS_ERROR) << __func__ << associated_codec_settings->codec.ToString(); |
| 861 if (!associated_codec_settings) { |
| 862 LOG(LS_ERROR) |
| 863 << "Stereo codec is not associated with any supported codec."; |
| 864 return false; |
| 865 } |
| 866 associated_codec_settings->stereo_codec.emplace(selected_send_codec->codec); |
| 867 selected_send_codec = associated_codec_settings; |
| 868 } |
| 869 |
680 // Never enable sending FlexFEC, unless we are in the experiment. | 870 // Never enable sending FlexFEC, unless we are in the experiment. |
681 if (!IsFlexfecFieldTrialEnabled()) { | 871 if (!IsFlexfecFieldTrialEnabled()) { |
682 if (selected_send_codec->flexfec_payload_type != -1) { | 872 if (selected_send_codec->flexfec_payload_type != -1) { |
683 LOG(LS_INFO) << "Remote supports flexfec-03, but we will not send since " | 873 LOG(LS_INFO) << "Remote supports flexfec-03, but we will not send since " |
684 << "WebRTC-FlexFEC-03 field trial is not enabled."; | 874 << "WebRTC-FlexFEC-03 field trial is not enabled."; |
685 } | 875 } |
686 selected_send_codec->flexfec_payload_type = -1; | 876 selected_send_codec->flexfec_payload_type = -1; |
687 } | 877 } |
688 | 878 |
689 if (!send_codec_ || *selected_send_codec != *send_codec_) | 879 if (!send_codec_ || *selected_send_codec != *send_codec_) |
(...skipping 852 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1542 bool has_internal_source) | 1732 bool has_internal_source) |
1543 : encoder(std::move(encoder)), | 1733 : encoder(std::move(encoder)), |
1544 is_hardware_accelerated(is_hardware_accelerated), | 1734 is_hardware_accelerated(is_hardware_accelerated), |
1545 has_internal_source(has_internal_source) {} | 1735 has_internal_source(has_internal_source) {} |
1546 | 1736 |
1547 WebRtcVideoChannel::WebRtcVideoSendStream::WebRtcVideoSendStream( | 1737 WebRtcVideoChannel::WebRtcVideoSendStream::WebRtcVideoSendStream( |
1548 webrtc::Call* call, | 1738 webrtc::Call* call, |
1549 const StreamParams& sp, | 1739 const StreamParams& sp, |
1550 webrtc::VideoSendStream::Config config, | 1740 webrtc::VideoSendStream::Config config, |
1551 const VideoOptions& options, | 1741 const VideoOptions& options, |
1552 const EncoderFactoryAdapter* encoder_factory, | 1742 EncoderFactoryAdapter* encoder_factory, |
1553 bool enable_cpu_overuse_detection, | 1743 bool enable_cpu_overuse_detection, |
1554 int max_bitrate_bps, | 1744 int max_bitrate_bps, |
1555 const rtc::Optional<VideoCodecSettings>& codec_settings, | 1745 const rtc::Optional<VideoCodecSettings>& codec_settings, |
1556 const rtc::Optional<std::vector<webrtc::RtpExtension>>& rtp_extensions, | 1746 const rtc::Optional<std::vector<webrtc::RtpExtension>>& rtp_extensions, |
1557 // TODO(deadbeef): Don't duplicate information between send_params, | 1747 // TODO(deadbeef): Don't duplicate information between send_params, |
1558 // rtp_extensions, options, etc. | 1748 // rtp_extensions, options, etc. |
1559 const VideoSendParameters& send_params) | 1749 const VideoSendParameters& send_params) |
1560 : worker_thread_(rtc::Thread::Current()), | 1750 : worker_thread_(rtc::Thread::Current()), |
1561 ssrcs_(sp.ssrcs), | 1751 ssrcs_(sp.ssrcs), |
1562 ssrc_groups_(sp.ssrc_groups), | 1752 ssrc_groups_(sp.ssrc_groups), |
(...skipping 180 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1743 false /* is_hardware_accelerated */, | 1933 false /* is_hardware_accelerated */, |
1744 false /* has_internal_source */); | 1934 false /* has_internal_source */); |
1745 } | 1935 } |
1746 | 1936 |
1747 // This shouldn't happen, we should not be trying to create something we don't | 1937 // This shouldn't happen, we should not be trying to create something we don't |
1748 // support. | 1938 // support. |
1749 RTC_NOTREACHED(); | 1939 RTC_NOTREACHED(); |
1750 return AllocatedEncoder(); | 1940 return AllocatedEncoder(); |
1751 } | 1941 } |
1752 | 1942 |
| 1943 EncoderFactoryAdapter::AllocatedEncoder |
| 1944 CricketEncoderFactoryAdapter::CreateStereoVideoEncoder( |
| 1945 const VideoCodec& codec) { |
| 1946 WebRtcStereoEncoderFactory* stereo_factory = |
| 1947 new WebRtcStereoEncoderFactory(internal_encoder_factory_.get()); |
| 1948 stereo_encoder_factory_.reset(stereo_factory); |
| 1949 return AllocatedEncoder(std::unique_ptr<webrtc::VideoEncoder>( |
| 1950 stereo_factory->CreateVideoEncoder(codec)), |
| 1951 false, false /* is_external */); |
| 1952 } |
| 1953 |
1753 void WebRtcVideoChannel::WebRtcVideoSendStream::SetCodec( | 1954 void WebRtcVideoChannel::WebRtcVideoSendStream::SetCodec( |
1754 const VideoCodecSettings& codec_settings, | 1955 const VideoCodecSettings& codec_settings, |
1755 bool force_encoder_allocation) { | 1956 bool force_encoder_allocation) { |
1756 RTC_DCHECK_RUN_ON(&thread_checker_); | 1957 RTC_DCHECK_RUN_ON(&thread_checker_); |
1757 parameters_.encoder_config = CreateVideoEncoderConfig(codec_settings.codec); | 1958 parameters_.encoder_config = CreateVideoEncoderConfig(codec_settings.codec); |
1758 RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0); | 1959 RTC_DCHECK_GT(parameters_.encoder_config.number_of_streams, 0); |
1759 | 1960 |
| 1961 const bool is_stereo_codec = codec_settings.stereo_codec.has_value(); |
| 1962 |
1760 // Do not re-create encoders of the same type. We can't overwrite | 1963 // Do not re-create encoders of the same type. We can't overwrite |
1761 // |allocated_encoder_| immediately, because we need to release it after the | 1964 // |allocated_encoder_| immediately, because we need to release it after the |
1762 // RecreateWebRtcStream() call. | 1965 // RecreateWebRtcStream() call. |
1763 std::unique_ptr<webrtc::VideoEncoder> new_encoder; | 1966 std::unique_ptr<webrtc::VideoEncoder> new_encoder; |
1764 if (force_encoder_allocation || !allocated_encoder_ || | 1967 if (force_encoder_allocation || !allocated_encoder_ || |
1765 allocated_codec_ != codec_settings.codec) { | 1968 allocated_codec_ != codec_settings.codec) { |
1766 const bool is_conference_mode_screenshare = | 1969 const bool is_conference_mode_screenshare = |
1767 parameters_.encoder_config.content_type == | 1970 parameters_.encoder_config.content_type == |
1768 webrtc::VideoEncoderConfig::ContentType::kScreen && | 1971 webrtc::VideoEncoderConfig::ContentType::kScreen && |
1769 parameters_.conference_mode; | 1972 parameters_.conference_mode; |
1770 EncoderFactoryAdapter::AllocatedEncoder new_allocated_encoder = | 1973 EncoderFactoryAdapter::AllocatedEncoder new_allocated_encoder = |
1771 encoder_factory_->CreateVideoEncoder(codec_settings.codec, | 1974 is_stereo_codec |
1772 is_conference_mode_screenshare); | 1975 ? encoder_factory_->CreateStereoVideoEncoder(codec_settings.codec) |
| 1976 : encoder_factory_->CreateVideoEncoder( |
| 1977 codec_settings.codec, is_conference_mode_screenshare); |
1773 new_encoder = std::unique_ptr<webrtc::VideoEncoder>( | 1978 new_encoder = std::unique_ptr<webrtc::VideoEncoder>( |
1774 std::move(new_allocated_encoder.encoder)); | 1979 std::move(new_allocated_encoder.encoder)); |
1775 parameters_.config.encoder_settings.encoder = new_encoder.get(); | 1980 parameters_.config.encoder_settings.encoder = new_encoder.get(); |
1776 parameters_.config.encoder_settings.full_overuse_time = | 1981 parameters_.config.encoder_settings.full_overuse_time = |
1777 new_allocated_encoder.is_hardware_accelerated; | 1982 new_allocated_encoder.is_hardware_accelerated; |
1778 parameters_.config.encoder_settings.internal_source = | 1983 parameters_.config.encoder_settings.internal_source = |
1779 new_allocated_encoder.has_internal_source; | 1984 new_allocated_encoder.has_internal_source; |
1780 } else { | 1985 } else { |
1781 new_encoder = std::move(allocated_encoder_); | 1986 new_encoder = std::move(allocated_encoder_); |
1782 } | 1987 } |
1783 parameters_.config.encoder_settings.payload_name = codec_settings.codec.name; | 1988 VideoCodec payload_codec = is_stereo_codec |
1784 parameters_.config.encoder_settings.payload_type = codec_settings.codec.id; | 1989 ? codec_settings.stereo_codec.value() |
| 1990 : codec_settings.codec; |
| 1991 parameters_.config.encoder_settings.payload_name = payload_codec.name; |
| 1992 parameters_.config.encoder_settings.payload_type = payload_codec.id; |
| 1993 parameters_.config.encoder_settings.stereo_associated_payload_name = |
| 1994 codec_settings.codec.name; |
1785 parameters_.config.rtp.ulpfec = codec_settings.ulpfec; | 1995 parameters_.config.rtp.ulpfec = codec_settings.ulpfec; |
1786 parameters_.config.rtp.flexfec.payload_type = | 1996 parameters_.config.rtp.flexfec.payload_type = |
1787 codec_settings.flexfec_payload_type; | 1997 codec_settings.flexfec_payload_type; |
1788 | 1998 |
1789 // Set RTX payload type if RTX is enabled. | 1999 // Set RTX payload type if RTX is enabled. |
1790 if (!parameters_.config.rtp.rtx.ssrcs.empty()) { | 2000 if (!parameters_.config.rtp.rtx.ssrcs.empty()) { |
1791 if (codec_settings.rtx_payload_type == -1) { | 2001 if (codec_settings.rtx_payload_type == -1) { |
1792 LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX " | 2002 LOG(LS_WARNING) << "RTX SSRCs configured but there's no configured RTX " |
1793 "payload type. Ignoring."; | 2003 "payload type. Ignoring."; |
1794 parameters_.config.rtp.rtx.ssrcs.clear(); | 2004 parameters_.config.rtp.rtx.ssrcs.clear(); |
(...skipping 222 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2017 } | 2227 } |
2018 } | 2228 } |
2019 | 2229 |
2020 VideoSenderInfo WebRtcVideoChannel::WebRtcVideoSendStream::GetVideoSenderInfo( | 2230 VideoSenderInfo WebRtcVideoChannel::WebRtcVideoSendStream::GetVideoSenderInfo( |
2021 bool log_stats) { | 2231 bool log_stats) { |
2022 VideoSenderInfo info; | 2232 VideoSenderInfo info; |
2023 RTC_DCHECK_RUN_ON(&thread_checker_); | 2233 RTC_DCHECK_RUN_ON(&thread_checker_); |
2024 for (uint32_t ssrc : parameters_.config.rtp.ssrcs) | 2234 for (uint32_t ssrc : parameters_.config.rtp.ssrcs) |
2025 info.add_ssrc(ssrc); | 2235 info.add_ssrc(ssrc); |
2026 | 2236 |
| 2237 // TODO(emircan): Add stereo codec case. |
2027 if (parameters_.codec_settings) { | 2238 if (parameters_.codec_settings) { |
2028 info.codec_name = parameters_.codec_settings->codec.name; | 2239 info.codec_name = parameters_.codec_settings->codec.name; |
2029 info.codec_payload_type = rtc::Optional<int>( | 2240 info.codec_payload_type = rtc::Optional<int>( |
2030 parameters_.codec_settings->codec.id); | 2241 parameters_.codec_settings->codec.id); |
2031 } | 2242 } |
2032 | 2243 |
2033 if (stream_ == NULL) | 2244 if (stream_ == NULL) |
2034 return info; | 2245 return info; |
2035 | 2246 |
2036 webrtc::VideoSendStream::Stats stats = stream_->GetStats(); | 2247 webrtc::VideoSendStream::Stats stats = stream_->GetStats(); |
(...skipping 106 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2143 } | 2354 } |
2144 | 2355 |
2145 // Call stream_->Start() if necessary conditions are met. | 2356 // Call stream_->Start() if necessary conditions are met. |
2146 UpdateSendState(); | 2357 UpdateSendState(); |
2147 } | 2358 } |
2148 | 2359 |
2149 WebRtcVideoChannel::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream( | 2360 WebRtcVideoChannel::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream( |
2150 webrtc::Call* call, | 2361 webrtc::Call* call, |
2151 const StreamParams& sp, | 2362 const StreamParams& sp, |
2152 webrtc::VideoReceiveStream::Config config, | 2363 webrtc::VideoReceiveStream::Config config, |
2153 const DecoderFactoryAdapter* decoder_factory, | 2364 DecoderFactoryAdapter* decoder_factory, |
2154 bool default_stream, | 2365 bool default_stream, |
2155 const std::vector<VideoCodecSettings>& recv_codecs, | 2366 const std::vector<VideoCodecSettings>& recv_codecs, |
2156 const webrtc::FlexfecReceiveStream::Config& flexfec_config) | 2367 const webrtc::FlexfecReceiveStream::Config& flexfec_config) |
2157 : call_(call), | 2368 : call_(call), |
2158 stream_params_(sp), | 2369 stream_params_(sp), |
2159 stream_(NULL), | 2370 stream_(NULL), |
2160 default_stream_(default_stream), | 2371 default_stream_(default_stream), |
2161 config_(std::move(config)), | 2372 config_(std::move(config)), |
2162 flexfec_config_(flexfec_config), | 2373 flexfec_config_(flexfec_config), |
2163 flexfec_stream_(nullptr), | 2374 flexfec_stream_(nullptr), |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2218 return internal_decoder; | 2429 return internal_decoder; |
2219 } | 2430 } |
2220 } | 2431 } |
2221 | 2432 |
2222 std::unique_ptr<webrtc::VideoDecoder> internal_decoder( | 2433 std::unique_ptr<webrtc::VideoDecoder> internal_decoder( |
2223 internal_decoder_factory_->CreateVideoDecoderWithParams(codec, | 2434 internal_decoder_factory_->CreateVideoDecoderWithParams(codec, |
2224 decoder_params)); | 2435 decoder_params)); |
2225 return internal_decoder; | 2436 return internal_decoder; |
2226 } | 2437 } |
2227 | 2438 |
| 2439 std::unique_ptr<webrtc::VideoDecoder> |
| 2440 CricketDecoderFactoryAdapter::CreateStereoVideoDecoder( |
| 2441 const VideoCodec& codec, |
| 2442 VideoDecoderParams params) { |
| 2443 webrtc::VideoCodecType type = webrtc::PayloadStringToCodecType(codec.name); |
| 2444 stereo_decoder_factory_.reset( |
| 2445 new WebRtcStereoDecoderFactory(internal_decoder_factory_.get())); |
| 2446 return std::unique_ptr<webrtc::VideoDecoder>( |
| 2447 stereo_decoder_factory_->CreateVideoDecoderWithParams(type, params)); |
| 2448 } |
| 2449 |
2228 void WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureCodecs( | 2450 void WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureCodecs( |
2229 const std::vector<VideoCodecSettings>& recv_codecs, | 2451 const std::vector<VideoCodecSettings>& recv_codecs, |
2230 DecoderMap* old_decoders) { | 2452 DecoderMap* old_decoders) { |
2231 *old_decoders = std::move(allocated_decoders_); | 2453 *old_decoders = std::move(allocated_decoders_); |
2232 config_.decoders.clear(); | 2454 config_.decoders.clear(); |
2233 config_.rtp.rtx_associated_payload_types.clear(); | 2455 config_.rtp.rtx_associated_payload_types.clear(); |
2234 for (const auto& recv_codec : recv_codecs) { | 2456 for (const auto& recv_codec : recv_codecs) { |
| 2457 const bool is_stereo_codec = |
| 2458 cricket::VideoCodec::IsStereoCodec(recv_codec.codec); |
2235 webrtc::SdpVideoFormat video_format(recv_codec.codec.name, | 2459 webrtc::SdpVideoFormat video_format(recv_codec.codec.name, |
2236 recv_codec.codec.params); | 2460 recv_codec.codec.params); |
2237 std::unique_ptr<webrtc::VideoDecoder> new_decoder; | 2461 std::unique_ptr<webrtc::VideoDecoder> new_decoder; |
2238 | 2462 |
2239 auto it = old_decoders->find(video_format); | 2463 auto it = old_decoders->find(video_format); |
2240 if (it != old_decoders->end()) { | 2464 if (it != old_decoders->end()) { |
2241 new_decoder = std::move(it->second); | 2465 new_decoder = std::move(it->second); |
2242 old_decoders->erase(it); | 2466 old_decoders->erase(it); |
2243 } | 2467 } |
2244 | 2468 |
2245 if (!new_decoder) { | 2469 if (!new_decoder) { |
2246 new_decoder = decoder_factory_->CreateVideoDecoder(recv_codec.codec, | 2470 new_decoder = is_stereo_codec |
2247 {stream_params_.id}); | 2471 ? decoder_factory_->CreateStereoVideoDecoder( |
| 2472 recv_codec.codec, {stream_params_.id}) |
| 2473 : decoder_factory_->CreateVideoDecoder( |
| 2474 recv_codec.codec, {stream_params_.id}); |
2248 } | 2475 } |
2249 | 2476 |
2250 webrtc::VideoReceiveStream::Decoder decoder; | 2477 webrtc::VideoReceiveStream::Decoder decoder; |
2251 decoder.decoder = new_decoder.get(); | 2478 decoder.decoder = new_decoder.get(); |
2252 decoder.payload_type = recv_codec.codec.id; | 2479 decoder.payload_type = recv_codec.codec.id; |
2253 decoder.payload_name = recv_codec.codec.name; | 2480 decoder.payload_name = recv_codec.codec.name; |
2254 decoder.codec_params = recv_codec.codec.params; | 2481 decoder.codec_params = recv_codec.codec.params; |
2255 config_.decoders.push_back(decoder); | 2482 config_.decoders.push_back(decoder); |
2256 config_.rtp.rtx_associated_payload_types[recv_codec.rtx_payload_type] = | 2483 config_.rtp.rtx_associated_payload_types[recv_codec.rtx_payload_type] = |
2257 recv_codec.codec.id; | 2484 recv_codec.codec.id; |
(...skipping 423 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2681 stream.temporal_layer_thresholds_bps.resize(GetDefaultVp9TemporalLayers() - | 2908 stream.temporal_layer_thresholds_bps.resize(GetDefaultVp9TemporalLayers() - |
2682 1); | 2909 1); |
2683 } | 2910 } |
2684 | 2911 |
2685 std::vector<webrtc::VideoStream> streams; | 2912 std::vector<webrtc::VideoStream> streams; |
2686 streams.push_back(stream); | 2913 streams.push_back(stream); |
2687 return streams; | 2914 return streams; |
2688 } | 2915 } |
2689 | 2916 |
2690 } // namespace cricket | 2917 } // namespace cricket |
OLD | NEW |