Line data Source code
1 : /*
2 : * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 : *
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
6 : * tree. An additional intellectual property rights grant can be found
7 : * in the file PATENTS. All contributing project authors may
8 : * be found in the AUTHORS file in the root of the source tree.
9 : */
10 :
11 : #include "webrtc/modules/video_coding/codec_database.h"
12 :
13 : #include <assert.h>
14 :
15 : #include "webrtc/base/checks.h"
16 : #include "webrtc/base/logging.h"
17 : #include "webrtc/modules/video_coding/codecs/h264/include/h264.h"
18 : #include "webrtc/modules/video_coding/codecs/i420/include/i420.h"
19 : #include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h"
20 : #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h"
21 : #include "webrtc/modules/video_coding/internal_defines.h"
22 :
23 : namespace {
24 : const size_t kDefaultPayloadSize = 1440;
25 : const uint8_t kDefaultPayloadType = 100;
26 : }
27 :
28 : namespace webrtc {
29 :
30 0 : VideoCodecVP8 VideoEncoder::GetDefaultVp8Settings() {
31 : VideoCodecVP8 vp8_settings;
32 0 : memset(&vp8_settings, 0, sizeof(vp8_settings));
33 :
34 0 : vp8_settings.resilience = kResilientStream;
35 0 : vp8_settings.numberOfTemporalLayers = 1;
36 0 : vp8_settings.denoisingOn = true;
37 0 : vp8_settings.errorConcealmentOn = false;
38 0 : vp8_settings.automaticResizeOn = false;
39 0 : vp8_settings.frameDroppingOn = true;
40 0 : vp8_settings.keyFrameInterval = 3000;
41 :
42 0 : return vp8_settings;
43 : }
44 :
45 0 : VideoCodecVP9 VideoEncoder::GetDefaultVp9Settings() {
46 : VideoCodecVP9 vp9_settings;
47 0 : memset(&vp9_settings, 0, sizeof(vp9_settings));
48 :
49 0 : vp9_settings.resilience = 1;
50 0 : vp9_settings.numberOfTemporalLayers = 1;
51 0 : vp9_settings.denoisingOn = false;
52 0 : vp9_settings.frameDroppingOn = true;
53 0 : vp9_settings.keyFrameInterval = 3000;
54 0 : vp9_settings.adaptiveQpMode = true;
55 0 : vp9_settings.automaticResizeOn = true;
56 0 : vp9_settings.numberOfSpatialLayers = 1;
57 0 : vp9_settings.flexibleMode = false;
58 0 : return vp9_settings;
59 : }
60 :
61 0 : VideoCodecH264 VideoEncoder::GetDefaultH264Settings() {
62 : VideoCodecH264 h264_settings;
63 0 : memset(&h264_settings, 0, sizeof(h264_settings));
64 :
65 0 : h264_settings.frameDroppingOn = true;
66 0 : h264_settings.keyFrameInterval = 3000;
67 0 : h264_settings.spsData = nullptr;
68 0 : h264_settings.spsLen = 0;
69 0 : h264_settings.ppsData = nullptr;
70 0 : h264_settings.ppsLen = 0;
71 0 : h264_settings.profile = H264::kProfileConstrainedBaseline;
72 :
73 0 : return h264_settings;
74 : }
75 :
76 0 : VCMDecoderMapItem::VCMDecoderMapItem(VideoCodec* settings,
77 : int number_of_cores,
78 0 : bool require_key_frame)
79 : : settings(settings),
80 : number_of_cores(number_of_cores),
81 0 : require_key_frame(require_key_frame) {
82 0 : assert(number_of_cores >= 0);
83 0 : }
84 :
85 0 : VCMExtDecoderMapItem::VCMExtDecoderMapItem(
86 : VideoDecoder* external_decoder_instance,
87 0 : uint8_t payload_type)
88 : : payload_type(payload_type),
89 0 : external_decoder_instance(external_decoder_instance) {}
90 :
91 0 : VCMCodecDataBase::VCMCodecDataBase(
92 0 : VCMEncodedFrameCallback* encoded_frame_callback)
93 : : number_of_cores_(0),
94 : max_payload_size_(kDefaultPayloadSize),
95 : periodic_key_frames_(false),
96 : pending_encoder_reset_(true),
97 : send_codec_(),
98 : receive_codec_(),
99 : encoder_payload_type_(0),
100 : external_encoder_(nullptr),
101 : internal_source_(false),
102 : encoded_frame_callback_(encoded_frame_callback),
103 : ptr_decoder_(nullptr),
104 : dec_map_(),
105 0 : dec_external_map_() {}
106 :
107 0 : VCMCodecDataBase::~VCMCodecDataBase() {
108 0 : DeleteEncoder();
109 0 : ReleaseDecoder(ptr_decoder_);
110 0 : for (auto& kv : dec_map_)
111 0 : delete kv.second;
112 0 : for (auto& kv : dec_external_map_)
113 0 : delete kv.second;
114 0 : }
115 :
116 0 : void VCMCodecDataBase::Codec(VideoCodecType codec_type, VideoCodec* settings) {
117 0 : memset(settings, 0, sizeof(VideoCodec));
118 0 : switch (codec_type) {
119 : case kVideoCodecVP8:
120 0 : strncpy(settings->plName, "VP8", 4);
121 0 : settings->codecType = kVideoCodecVP8;
122 : // 96 to 127 dynamic payload types for video codecs.
123 0 : settings->plType = kDefaultPayloadType;
124 0 : settings->startBitrate = kDefaultStartBitrateKbps;
125 0 : settings->minBitrate = VCM_MIN_BITRATE;
126 0 : settings->maxBitrate = 0;
127 0 : settings->maxFramerate = VCM_DEFAULT_FRAME_RATE;
128 0 : settings->width = VCM_DEFAULT_CODEC_WIDTH;
129 0 : settings->height = VCM_DEFAULT_CODEC_HEIGHT;
130 : // consider using 2 to avoid deal with 'odd' downscales
131 0 : settings->resolution_divisor = 1; // may not actually be needed
132 0 : settings->numberOfSimulcastStreams = 0;
133 0 : settings->qpMax = 56;
134 0 : *(settings->VP8()) = VideoEncoder::GetDefaultVp8Settings();
135 0 : return;
136 : case kVideoCodecVP9:
137 0 : strncpy(settings->plName, "VP9", 4);
138 0 : settings->codecType = kVideoCodecVP9;
139 : // 96 to 127 dynamic payload types for video codecs.
140 0 : settings->plType = kDefaultPayloadType;
141 0 : settings->startBitrate = 100;
142 0 : settings->minBitrate = VCM_MIN_BITRATE;
143 0 : settings->maxBitrate = 0;
144 0 : settings->maxFramerate = VCM_DEFAULT_FRAME_RATE;
145 0 : settings->width = VCM_DEFAULT_CODEC_WIDTH;
146 0 : settings->height = VCM_DEFAULT_CODEC_HEIGHT;
147 : // consider using 2 to avoid deal with 'odd' downscales
148 0 : settings->resolution_divisor = 1; // may not actually be needed
149 0 : settings->numberOfSimulcastStreams = 0;
150 0 : settings->qpMax = 56;
151 0 : *(settings->VP9()) = VideoEncoder::GetDefaultVp9Settings();
152 0 : return;
153 : case kVideoCodecH264:
154 0 : strncpy(settings->plName, "H264", 5);
155 0 : settings->codecType = kVideoCodecH264;
156 : // 96 to 127 dynamic payload types for video codecs.
157 0 : settings->plType = kDefaultPayloadType;
158 0 : settings->startBitrate = kDefaultStartBitrateKbps;
159 0 : settings->minBitrate = VCM_MIN_BITRATE;
160 0 : settings->maxBitrate = 0;
161 0 : settings->maxFramerate = VCM_DEFAULT_FRAME_RATE;
162 0 : settings->width = VCM_DEFAULT_CODEC_WIDTH;
163 0 : settings->height = VCM_DEFAULT_CODEC_HEIGHT;
164 : // consider using 2 to avoid deal with 'odd' downscales
165 0 : settings->resolution_divisor = 1; // may not actually be needed
166 0 : settings->numberOfSimulcastStreams = 0;
167 0 : settings->qpMax = 56;
168 0 : *(settings->H264()) = VideoEncoder::GetDefaultH264Settings();
169 0 : return;
170 : case kVideoCodecI420:
171 0 : strncpy(settings->plName, "I420", 5);
172 0 : settings->codecType = kVideoCodecI420;
173 : // 96 to 127 dynamic payload types for video codecs.
174 0 : settings->plType = kDefaultPayloadType;
175 : // Bitrate needed for this size and framerate.
176 0 : settings->startBitrate = 3 * VCM_DEFAULT_CODEC_WIDTH *
177 : VCM_DEFAULT_CODEC_HEIGHT * 8 *
178 : VCM_DEFAULT_FRAME_RATE / 1000 / 2;
179 0 : settings->maxBitrate = settings->startBitrate;
180 0 : settings->maxFramerate = VCM_DEFAULT_FRAME_RATE;
181 0 : settings->width = VCM_DEFAULT_CODEC_WIDTH;
182 0 : settings->height = VCM_DEFAULT_CODEC_HEIGHT;
183 0 : settings->minBitrate = VCM_MIN_BITRATE;
184 : // consider using 2 to avoid deal with 'odd' downscales
185 0 : settings->resolution_divisor = 1; // may not actually be needed
186 0 : settings->numberOfSimulcastStreams = 0;
187 0 : return;
188 : case kVideoCodecRED:
189 : case kVideoCodecULPFEC:
190 : case kVideoCodecFlexfec:
191 : case kVideoCodecGeneric:
192 : case kVideoCodecUnknown:
193 0 : RTC_NOTREACHED();
194 0 : return;
195 : }
196 : }
197 :
198 : // Assuming only one registered encoder - since only one used, no need for more.
199 0 : bool VCMCodecDataBase::SetSendCodec(const VideoCodec* send_codec,
200 : int number_of_cores,
201 : size_t max_payload_size) {
202 0 : RTC_DCHECK(send_codec);
203 0 : if (max_payload_size == 0) {
204 0 : max_payload_size = kDefaultPayloadSize;
205 : }
206 0 : RTC_DCHECK_GE(number_of_cores, 1);
207 0 : RTC_DCHECK_GE(send_codec->plType, 1);
208 : // Make sure the start bit rate is sane...
209 0 : RTC_DCHECK_LE(send_codec->startBitrate, 1000000);
210 0 : RTC_DCHECK(send_codec->codecType != kVideoCodecUnknown);
211 0 : bool reset_required = pending_encoder_reset_;
212 0 : if (number_of_cores_ != number_of_cores) {
213 0 : number_of_cores_ = number_of_cores;
214 0 : reset_required = true;
215 : }
216 0 : if (max_payload_size_ != max_payload_size) {
217 0 : max_payload_size_ = max_payload_size;
218 0 : reset_required = true;
219 : }
220 :
221 0 : VideoCodec new_send_codec;
222 0 : memcpy(&new_send_codec, send_codec, sizeof(new_send_codec));
223 :
224 0 : if (new_send_codec.maxBitrate == 0) {
225 : // max is one bit per pixel
226 0 : new_send_codec.maxBitrate = (static_cast<int>(send_codec->height) *
227 0 : static_cast<int>(send_codec->width) *
228 0 : static_cast<int>(send_codec->maxFramerate)) /
229 : 1000;
230 0 : if (send_codec->startBitrate > new_send_codec.maxBitrate) {
231 : // But if the user tries to set a higher start bit rate we will
232 : // increase the max accordingly.
233 0 : new_send_codec.maxBitrate = send_codec->startBitrate;
234 : }
235 : }
236 :
237 0 : if (new_send_codec.startBitrate > new_send_codec.maxBitrate)
238 0 : new_send_codec.startBitrate = new_send_codec.maxBitrate;
239 :
240 0 : if (!reset_required) {
241 0 : reset_required = RequiresEncoderReset(new_send_codec);
242 : }
243 :
244 0 : memcpy(&send_codec_, &new_send_codec, sizeof(send_codec_));
245 :
246 0 : if (!reset_required) {
247 0 : return true;
248 : }
249 :
250 : // If encoder exists, will destroy it and create new one.
251 0 : DeleteEncoder();
252 0 : RTC_DCHECK_EQ(encoder_payload_type_, send_codec_.plType)
253 0 : << "Encoder not registered for payload type " << send_codec_.plType;
254 0 : ptr_encoder_.reset(new VCMGenericEncoder(
255 0 : external_encoder_, encoded_frame_callback_, internal_source_));
256 0 : encoded_frame_callback_->SetInternalSource(internal_source_);
257 0 : if (ptr_encoder_->InitEncode(&send_codec_, number_of_cores_,
258 : max_payload_size_) < 0) {
259 0 : LOG(LS_ERROR) << "Failed to initialize video encoder.";
260 0 : DeleteEncoder();
261 0 : return false;
262 : }
263 :
264 : // Intentionally don't check return value since the encoder registration
265 : // shouldn't fail because the codec doesn't support changing the periodic key
266 : // frame setting.
267 0 : ptr_encoder_->SetPeriodicKeyFrames(periodic_key_frames_);
268 :
269 0 : pending_encoder_reset_ = false;
270 :
271 0 : return true;
272 : }
273 :
274 0 : bool VCMCodecDataBase::SendCodec(VideoCodec* current_send_codec) const {
275 0 : if (!ptr_encoder_) {
276 0 : return false;
277 : }
278 0 : memcpy(current_send_codec, &send_codec_, sizeof(VideoCodec));
279 0 : return true;
280 : }
281 :
282 0 : VideoCodecType VCMCodecDataBase::SendCodec() const {
283 0 : if (!ptr_encoder_) {
284 0 : return kVideoCodecUnknown;
285 : }
286 0 : return send_codec_.codecType;
287 : }
288 :
289 0 : bool VCMCodecDataBase::DeregisterExternalEncoder(uint8_t payload_type,
290 : bool* was_send_codec) {
291 0 : assert(was_send_codec);
292 0 : *was_send_codec = false;
293 0 : if (encoder_payload_type_ != payload_type) {
294 0 : return false;
295 : }
296 0 : if (send_codec_.plType == payload_type) {
297 : // De-register as send codec if needed.
298 0 : DeleteEncoder();
299 0 : memset(&send_codec_, 0, sizeof(VideoCodec));
300 0 : *was_send_codec = true;
301 : }
302 0 : encoder_payload_type_ = 0;
303 0 : external_encoder_ = nullptr;
304 0 : internal_source_ = false;
305 0 : return true;
306 : }
307 :
308 0 : void VCMCodecDataBase::RegisterExternalEncoder(VideoEncoder* external_encoder,
309 : uint8_t payload_type,
310 : bool internal_source) {
311 : // Since only one encoder can be used at a given time, only one external
312 : // encoder can be registered/used.
313 0 : external_encoder_ = external_encoder;
314 0 : encoder_payload_type_ = payload_type;
315 0 : internal_source_ = internal_source;
316 0 : pending_encoder_reset_ = true;
317 0 : }
318 :
319 0 : bool VCMCodecDataBase::RequiresEncoderReset(const VideoCodec& new_send_codec) {
320 0 : if (!ptr_encoder_)
321 0 : return true;
322 :
323 : // Does not check startBitrate or maxFramerate
324 0 : if (new_send_codec.codecType != send_codec_.codecType ||
325 0 : strcmp(new_send_codec.plName, send_codec_.plName) != 0 ||
326 0 : new_send_codec.plType != send_codec_.plType ||
327 0 : new_send_codec.width != send_codec_.width ||
328 0 : new_send_codec.height != send_codec_.height ||
329 0 : new_send_codec.resolution_divisor != send_codec_.resolution_divisor ||
330 0 : new_send_codec.maxBitrate != send_codec_.maxBitrate ||
331 0 : new_send_codec.minBitrate != send_codec_.minBitrate ||
332 0 : new_send_codec.qpMax != send_codec_.qpMax ||
333 0 : new_send_codec.numberOfSimulcastStreams !=
334 0 : send_codec_.numberOfSimulcastStreams ||
335 0 : new_send_codec.mode != send_codec_.mode) {
336 0 : return true;
337 : }
338 :
339 0 : switch (new_send_codec.codecType) {
340 : case kVideoCodecVP8:
341 0 : if (memcmp(&new_send_codec.VP8(), send_codec_.VP8(),
342 : sizeof(new_send_codec.VP8())) != 0) {
343 0 : return true;
344 : }
345 0 : break;
346 : case kVideoCodecVP9:
347 0 : if (memcmp(&new_send_codec.VP9(), send_codec_.VP9(),
348 : sizeof(new_send_codec.VP9())) != 0) {
349 0 : return true;
350 : }
351 0 : break;
352 : case kVideoCodecH264:
353 0 : if (memcmp(&new_send_codec.H264(), send_codec_.H264(),
354 : sizeof(new_send_codec.H264())) != 0) {
355 0 : return true;
356 : }
357 0 : break;
358 : case kVideoCodecGeneric:
359 0 : break;
360 : // Known codecs without payload-specifics
361 : case kVideoCodecI420:
362 : case kVideoCodecRED:
363 : case kVideoCodecULPFEC:
364 : case kVideoCodecFlexfec:
365 0 : break;
366 : // Unknown codec type, reset just to be sure.
367 : case kVideoCodecUnknown:
368 0 : return true;
369 : }
370 :
371 0 : if (new_send_codec.numberOfSimulcastStreams > 0) {
372 0 : for (unsigned char i = 0; i < new_send_codec.numberOfSimulcastStreams;
373 : ++i) {
374 0 : if (memcmp(&new_send_codec.simulcastStream[i],
375 0 : &send_codec_.simulcastStream[i],
376 : sizeof(new_send_codec.simulcastStream[i])) != 0) {
377 0 : return true;
378 : }
379 : }
380 : }
381 0 : return false;
382 : }
383 :
384 0 : VCMGenericEncoder* VCMCodecDataBase::GetEncoder() {
385 0 : return ptr_encoder_.get();
386 : }
387 :
388 0 : bool VCMCodecDataBase::SetPeriodicKeyFrames(bool enable) {
389 0 : periodic_key_frames_ = enable;
390 0 : if (ptr_encoder_) {
391 0 : return (ptr_encoder_->SetPeriodicKeyFrames(periodic_key_frames_) == 0);
392 : }
393 0 : return true;
394 : }
395 :
396 0 : bool VCMCodecDataBase::DeregisterExternalDecoder(uint8_t payload_type) {
397 0 : ExternalDecoderMap::iterator it = dec_external_map_.find(payload_type);
398 0 : if (it == dec_external_map_.end()) {
399 : // Not found
400 0 : return false;
401 : }
402 : // We can't use payload_type to check if the decoder is currently in use,
403 : // because payload type may be out of date (e.g. before we decode the first
404 : // frame after RegisterReceiveCodec)
405 0 : if (ptr_decoder_ != nullptr &&
406 0 : ptr_decoder_->_decoder == (*it).second->external_decoder_instance) {
407 : // Release it if it was registered and in use.
408 0 : ReleaseDecoder(ptr_decoder_);
409 0 : ptr_decoder_ = nullptr;
410 : }
411 0 : DeregisterReceiveCodec(payload_type);
412 0 : delete it->second;
413 0 : dec_external_map_.erase(it);
414 0 : return true;
415 : }
416 :
417 : // Add the external encoder object to the list of external decoders.
418 : // Won't be registered as a receive codec until RegisterReceiveCodec is called.
419 0 : void VCMCodecDataBase::RegisterExternalDecoder(VideoDecoder* external_decoder,
420 : uint8_t payload_type) {
421 : // Check if payload value already exists, if so - erase old and insert new.
422 : VCMExtDecoderMapItem* ext_decoder =
423 0 : new VCMExtDecoderMapItem(external_decoder, payload_type);
424 0 : DeregisterExternalDecoder(payload_type);
425 0 : dec_external_map_[payload_type] = ext_decoder;
426 0 : }
427 :
428 0 : bool VCMCodecDataBase::DecoderRegistered() const {
429 0 : return !dec_map_.empty();
430 : }
431 :
432 0 : bool VCMCodecDataBase::RegisterReceiveCodec(const VideoCodec* receive_codec,
433 : int number_of_cores,
434 : bool require_key_frame) {
435 0 : if (number_of_cores < 0) {
436 0 : return false;
437 : }
438 : // Check if payload value already exists, if so - erase old and insert new.
439 0 : DeregisterReceiveCodec(receive_codec->plType);
440 0 : if (receive_codec->codecType == kVideoCodecUnknown) {
441 0 : return false;
442 : }
443 0 : VideoCodec* new_receive_codec = new VideoCodec(*receive_codec);
444 0 : dec_map_[receive_codec->plType] = new VCMDecoderMapItem(
445 0 : new_receive_codec, number_of_cores, require_key_frame);
446 0 : return true;
447 : }
448 :
449 0 : bool VCMCodecDataBase::DeregisterReceiveCodec(uint8_t payload_type) {
450 0 : DecoderMap::iterator it = dec_map_.find(payload_type);
451 0 : if (it == dec_map_.end()) {
452 0 : return false;
453 : }
454 0 : delete it->second;
455 0 : dec_map_.erase(it);
456 0 : if (receive_codec_.plType == payload_type) {
457 : // This codec is currently in use.
458 0 : memset(&receive_codec_, 0, sizeof(VideoCodec));
459 : }
460 0 : return true;
461 : }
462 :
463 0 : bool VCMCodecDataBase::ReceiveCodec(VideoCodec* current_receive_codec) const {
464 0 : assert(current_receive_codec);
465 0 : if (!ptr_decoder_) {
466 0 : return false;
467 : }
468 0 : memcpy(current_receive_codec, &receive_codec_, sizeof(VideoCodec));
469 0 : return true;
470 : }
471 :
472 0 : VideoCodecType VCMCodecDataBase::ReceiveCodec() const {
473 0 : if (!ptr_decoder_) {
474 0 : return kVideoCodecUnknown;
475 : }
476 0 : return receive_codec_.codecType;
477 : }
478 :
479 0 : VCMGenericDecoder* VCMCodecDataBase::GetDecoder(
480 : const VCMEncodedFrame& frame,
481 : VCMDecodedFrameCallback* decoded_frame_callback) {
482 0 : uint8_t payload_type = frame.PayloadType();
483 0 : if (payload_type == receive_codec_.plType || payload_type == 0) {
484 0 : return ptr_decoder_;
485 : }
486 : // Check for exisitng decoder, if exists - delete.
487 0 : if (ptr_decoder_) {
488 0 : ReleaseDecoder(ptr_decoder_);
489 0 : ptr_decoder_ = nullptr;
490 0 : memset(&receive_codec_, 0, sizeof(VideoCodec));
491 : }
492 0 : ptr_decoder_ = CreateAndInitDecoder(frame, &receive_codec_);
493 0 : if (!ptr_decoder_) {
494 0 : return nullptr;
495 : }
496 0 : VCMReceiveCallback* callback = decoded_frame_callback->UserReceiveCallback();
497 0 : if (callback)
498 0 : callback->OnIncomingPayloadType(receive_codec_.plType);
499 0 : if (ptr_decoder_->RegisterDecodeCompleteCallback(decoded_frame_callback) <
500 : 0) {
501 0 : ReleaseDecoder(ptr_decoder_);
502 0 : ptr_decoder_ = nullptr;
503 0 : memset(&receive_codec_, 0, sizeof(VideoCodec));
504 0 : return nullptr;
505 : }
506 0 : return ptr_decoder_;
507 : }
508 :
509 0 : void VCMCodecDataBase::ReleaseDecoder(VCMGenericDecoder* decoder) const {
510 0 : if (decoder) {
511 0 : assert(decoder->_decoder);
512 0 : decoder->Release();
513 0 : if (!decoder->External()) {
514 0 : delete decoder->_decoder;
515 : }
516 0 : delete decoder;
517 : }
518 0 : }
519 :
520 0 : bool VCMCodecDataBase::PrefersLateDecoding() const {
521 0 : if (!ptr_decoder_)
522 0 : return true;
523 0 : return ptr_decoder_->PrefersLateDecoding();
524 : }
525 :
526 0 : bool VCMCodecDataBase::MatchesCurrentResolution(int width, int height) const {
527 0 : return send_codec_.width == width && send_codec_.height == height;
528 : }
529 :
530 0 : VCMGenericDecoder* VCMCodecDataBase::CreateAndInitDecoder(
531 : const VCMEncodedFrame& frame,
532 : VideoCodec* new_codec) const {
533 0 : uint8_t payload_type = frame.PayloadType();
534 0 : LOG(LS_INFO) << "Initializing decoder with payload type '"
535 0 : << static_cast<int>(payload_type) << "'.";
536 0 : assert(new_codec);
537 0 : const VCMDecoderMapItem* decoder_item = FindDecoderItem(payload_type);
538 0 : if (!decoder_item) {
539 0 : LOG(LS_ERROR) << "Can't find a decoder associated with payload type: "
540 0 : << static_cast<int>(payload_type);
541 0 : return nullptr;
542 : }
543 0 : VCMGenericDecoder* ptr_decoder = nullptr;
544 : const VCMExtDecoderMapItem* external_dec_item =
545 0 : FindExternalDecoderItem(payload_type);
546 0 : if (external_dec_item) {
547 : // External codec.
548 0 : ptr_decoder = new VCMGenericDecoder(
549 0 : external_dec_item->external_decoder_instance, true);
550 : } else {
551 : // Create decoder.
552 0 : ptr_decoder = CreateDecoder(decoder_item->settings->codecType);
553 : }
554 0 : if (!ptr_decoder)
555 0 : return nullptr;
556 :
557 : // Copy over input resolutions to prevent codec reinitialization due to
558 : // the first frame being of a different resolution than the database values.
559 : // This is best effort, since there's no guarantee that width/height have been
560 : // parsed yet (and may be zero).
561 0 : if (frame.EncodedImage()._encodedWidth > 0 &&
562 0 : frame.EncodedImage()._encodedHeight > 0) {
563 0 : decoder_item->settings->width = frame.EncodedImage()._encodedWidth;
564 0 : decoder_item->settings->height = frame.EncodedImage()._encodedHeight;
565 : }
566 0 : if (ptr_decoder->InitDecode(decoder_item->settings.get(),
567 0 : decoder_item->number_of_cores) < 0) {
568 0 : ReleaseDecoder(ptr_decoder);
569 0 : return nullptr;
570 : }
571 0 : memcpy(new_codec, decoder_item->settings.get(), sizeof(VideoCodec));
572 0 : return ptr_decoder;
573 : }
574 :
575 0 : void VCMCodecDataBase::DeleteEncoder() {
576 0 : if (!ptr_encoder_)
577 0 : return;
578 0 : ptr_encoder_->Release();
579 0 : ptr_encoder_.reset();
580 : }
581 :
582 0 : VCMGenericDecoder* VCMCodecDataBase::CreateDecoder(VideoCodecType type) const {
583 0 : switch (type) {
584 : case kVideoCodecVP8:
585 0 : return new VCMGenericDecoder(VP8Decoder::Create());
586 : case kVideoCodecVP9:
587 0 : return new VCMGenericDecoder(VP9Decoder::Create());
588 : case kVideoCodecI420:
589 0 : return new VCMGenericDecoder(new I420Decoder());
590 : case kVideoCodecH264:
591 0 : if (H264Decoder::IsSupported()) {
592 0 : return new VCMGenericDecoder(H264Decoder::Create());
593 : }
594 0 : break;
595 : default:
596 0 : break;
597 : }
598 0 : LOG(LS_WARNING) << "No internal decoder of this type exists.";
599 0 : return nullptr;
600 : }
601 :
602 0 : const VCMDecoderMapItem* VCMCodecDataBase::FindDecoderItem(
603 : uint8_t payload_type) const {
604 0 : DecoderMap::const_iterator it = dec_map_.find(payload_type);
605 0 : if (it != dec_map_.end()) {
606 0 : return (*it).second;
607 : }
608 0 : return nullptr;
609 : }
610 :
611 0 : const VCMExtDecoderMapItem* VCMCodecDataBase::FindExternalDecoderItem(
612 : uint8_t payload_type) const {
613 0 : ExternalDecoderMap::const_iterator it = dec_external_map_.find(payload_type);
614 0 : if (it != dec_external_map_.end()) {
615 0 : return (*it).second;
616 : }
617 0 : return nullptr;
618 : }
619 : } // namespace webrtc
|
