modules/video_coding refactorings
The main purpose was the interface-> include rename, but other files
were also moved, eliminating the "main" dir.
To avoid breaking downstream, the "interface" directories were copied
into a new "video_coding/include" dir. The old headers got pragma
warnings added about deprecation (a very short deprecation since I plan
to remove them as soon downstream is updated).
Other files also moved:
video_coding/main/source -> video_coding
video_coding/main/test -> video_coding/test
BUG=webrtc:5095
TESTED=Passing compile-trybots with --clobber flag:
git cl try --clobber --bot=win_compile_rel --bot=linux_compile_rel --bot=android_compile_rel --bot=mac_compile_rel --bot=ios_rel --bot=linux_gn_rel --bot=win_x64_gn_rel --bot=mac_x64_gn_rel --bot=android_gn_rel -m tryserver.webrtc
R=stefan@webrtc.org, tommi@webrtc.org
Review URL: https://codereview.webrtc.org/1417283007 .
Cr-Commit-Position: refs/heads/master@{#10694}
diff --git a/webrtc/modules/video_coding/codec_database.cc b/webrtc/modules/video_coding/codec_database.cc
new file mode 100644
index 0000000..d3e2ce4
--- /dev/null
+++ b/webrtc/modules/video_coding/codec_database.cc
@@ -0,0 +1,687 @@
+/*
+ * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "webrtc/modules/video_coding/codec_database.h"
+
+#include <assert.h>
+
+#include "webrtc/base/checks.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/engine_configurations.h"
+#ifdef VIDEOCODEC_H264
+#include "webrtc/modules/video_coding/codecs/h264/include/h264.h"
+#endif
+#ifdef VIDEOCODEC_I420
+#include "webrtc/modules/video_coding/codecs/i420/include/i420.h"
+#endif
+#ifdef VIDEOCODEC_VP8
+#include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h"
+#endif
+#ifdef VIDEOCODEC_VP9
+#include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h"
+#endif
+#include "webrtc/modules/video_coding/internal_defines.h"
+
+namespace {
+const size_t kDefaultPayloadSize = 1440;
+const uint8_t kDefaultPayloadType = 100;
+}
+
+namespace webrtc {
+
+VideoCodecVP8 VideoEncoder::GetDefaultVp8Settings() {
+ VideoCodecVP8 vp8_settings;
+ memset(&vp8_settings, 0, sizeof(vp8_settings));
+
+ vp8_settings.resilience = kResilientStream;
+ vp8_settings.numberOfTemporalLayers = 1;
+ vp8_settings.denoisingOn = true;
+ vp8_settings.errorConcealmentOn = false;
+ vp8_settings.automaticResizeOn = false;
+ vp8_settings.frameDroppingOn = true;
+ vp8_settings.keyFrameInterval = 3000;
+
+ return vp8_settings;
+}
+
+VideoCodecVP9 VideoEncoder::GetDefaultVp9Settings() {
+ VideoCodecVP9 vp9_settings;
+ memset(&vp9_settings, 0, sizeof(vp9_settings));
+
+ vp9_settings.resilience = 1;
+ vp9_settings.numberOfTemporalLayers = 1;
+ vp9_settings.denoisingOn = false;
+ vp9_settings.frameDroppingOn = true;
+ vp9_settings.keyFrameInterval = 3000;
+ vp9_settings.adaptiveQpMode = true;
+ vp9_settings.automaticResizeOn = true;
+ vp9_settings.numberOfSpatialLayers = 1;
+ vp9_settings.flexibleMode = false;
+ return vp9_settings;
+}
+
+VideoCodecH264 VideoEncoder::GetDefaultH264Settings() {
+ VideoCodecH264 h264_settings;
+ memset(&h264_settings, 0, sizeof(h264_settings));
+
+ h264_settings.profile = kProfileBase;
+ h264_settings.frameDroppingOn = true;
+ h264_settings.keyFrameInterval = 3000;
+ h264_settings.spsData = NULL;
+ h264_settings.spsLen = 0;
+ h264_settings.ppsData = NULL;
+ h264_settings.ppsLen = 0;
+
+ return h264_settings;
+}
+
+VCMDecoderMapItem::VCMDecoderMapItem(VideoCodec* settings,
+ int number_of_cores,
+ bool require_key_frame)
+ : settings(settings),
+ number_of_cores(number_of_cores),
+ require_key_frame(require_key_frame) {
+ assert(number_of_cores >= 0);
+}
+
+VCMExtDecoderMapItem::VCMExtDecoderMapItem(
+ VideoDecoder* external_decoder_instance,
+ uint8_t payload_type,
+ bool internal_render_timing)
+ : payload_type(payload_type),
+ external_decoder_instance(external_decoder_instance),
+ internal_render_timing(internal_render_timing) {
+}
+
+VCMCodecDataBase::VCMCodecDataBase(
+ VideoEncoderRateObserver* encoder_rate_observer,
+ VCMEncodedFrameCallback* encoded_frame_callback)
+ : number_of_cores_(0),
+ max_payload_size_(kDefaultPayloadSize),
+ periodic_key_frames_(false),
+ pending_encoder_reset_(true),
+ send_codec_(),
+ receive_codec_(),
+ encoder_payload_type_(0),
+ external_encoder_(NULL),
+ internal_source_(false),
+ encoder_rate_observer_(encoder_rate_observer),
+ encoded_frame_callback_(encoded_frame_callback),
+ ptr_decoder_(NULL),
+ dec_map_(),
+ dec_external_map_() {}
+
+VCMCodecDataBase::~VCMCodecDataBase() {
+ ResetSender();
+ ResetReceiver();
+}
+
+int VCMCodecDataBase::NumberOfCodecs() {
+ return VCM_NUM_VIDEO_CODECS_AVAILABLE;
+}
+
+bool VCMCodecDataBase::Codec(int list_id,
+ VideoCodec* settings) {
+ if (!settings) {
+ return false;
+ }
+ if (list_id >= VCM_NUM_VIDEO_CODECS_AVAILABLE) {
+ return false;
+ }
+ memset(settings, 0, sizeof(VideoCodec));
+ switch (list_id) {
+#ifdef VIDEOCODEC_VP8
+ case VCM_VP8_IDX: {
+ strncpy(settings->plName, "VP8", 4);
+ settings->codecType = kVideoCodecVP8;
+ // 96 to 127 dynamic payload types for video codecs.
+ settings->plType = kDefaultPayloadType;
+ settings->startBitrate = kDefaultStartBitrateKbps;
+ settings->minBitrate = VCM_MIN_BITRATE;
+ settings->maxBitrate = 0;
+ settings->maxFramerate = VCM_DEFAULT_FRAME_RATE;
+ settings->width = VCM_DEFAULT_CODEC_WIDTH;
+ settings->height = VCM_DEFAULT_CODEC_HEIGHT;
+ settings->numberOfSimulcastStreams = 0;
+ settings->qpMax = 56;
+ settings->codecSpecific.VP8 = VideoEncoder::GetDefaultVp8Settings();
+ return true;
+ }
+#endif
+#ifdef VIDEOCODEC_VP9
+ case VCM_VP9_IDX: {
+ strncpy(settings->plName, "VP9", 4);
+ settings->codecType = kVideoCodecVP9;
+ // 96 to 127 dynamic payload types for video codecs.
+ settings->plType = kDefaultPayloadType;
+ settings->startBitrate = 100;
+ settings->minBitrate = VCM_MIN_BITRATE;
+ settings->maxBitrate = 0;
+ settings->maxFramerate = VCM_DEFAULT_FRAME_RATE;
+ settings->width = VCM_DEFAULT_CODEC_WIDTH;
+ settings->height = VCM_DEFAULT_CODEC_HEIGHT;
+ settings->numberOfSimulcastStreams = 0;
+ settings->qpMax = 56;
+ settings->codecSpecific.VP9 = VideoEncoder::GetDefaultVp9Settings();
+ return true;
+ }
+#endif
+#ifdef VIDEOCODEC_H264
+ case VCM_H264_IDX: {
+ strncpy(settings->plName, "H264", 5);
+ settings->codecType = kVideoCodecH264;
+ // 96 to 127 dynamic payload types for video codecs.
+ settings->plType = kDefaultPayloadType;
+ settings->startBitrate = kDefaultStartBitrateKbps;
+ settings->minBitrate = VCM_MIN_BITRATE;
+ settings->maxBitrate = 0;
+ settings->maxFramerate = VCM_DEFAULT_FRAME_RATE;
+ settings->width = VCM_DEFAULT_CODEC_WIDTH;
+ settings->height = VCM_DEFAULT_CODEC_HEIGHT;
+ settings->numberOfSimulcastStreams = 0;
+ settings->qpMax = 56;
+ settings->codecSpecific.H264 = VideoEncoder::GetDefaultH264Settings();
+ return true;
+ }
+#endif
+#ifdef VIDEOCODEC_I420
+ case VCM_I420_IDX: {
+ strncpy(settings->plName, "I420", 5);
+ settings->codecType = kVideoCodecI420;
+ // 96 to 127 dynamic payload types for video codecs.
+ settings->plType = kDefaultPayloadType;
+ // Bitrate needed for this size and framerate.
+ settings->startBitrate = 3 * VCM_DEFAULT_CODEC_WIDTH *
+ VCM_DEFAULT_CODEC_HEIGHT * 8 *
+ VCM_DEFAULT_FRAME_RATE / 1000 / 2;
+ settings->maxBitrate = settings->startBitrate;
+ settings->maxFramerate = VCM_DEFAULT_FRAME_RATE;
+ settings->width = VCM_DEFAULT_CODEC_WIDTH;
+ settings->height = VCM_DEFAULT_CODEC_HEIGHT;
+ settings->minBitrate = VCM_MIN_BITRATE;
+ settings->numberOfSimulcastStreams = 0;
+ return true;
+ }
+#endif
+ default: {
+ return false;
+ }
+ }
+}
+
+bool VCMCodecDataBase::Codec(VideoCodecType codec_type,
+ VideoCodec* settings) {
+ for (int i = 0; i < VCMCodecDataBase::NumberOfCodecs(); i++) {
+ const bool ret = VCMCodecDataBase::Codec(i, settings);
+ if (!ret) {
+ return false;
+ }
+ if (codec_type == settings->codecType) {
+ return true;
+ }
+ }
+ return false;
+}
+
+void VCMCodecDataBase::ResetSender() {
+ DeleteEncoder();
+ periodic_key_frames_ = false;
+}
+
+// Assuming only one registered encoder - since only one used, no need for more.
+bool VCMCodecDataBase::SetSendCodec(const VideoCodec* send_codec,
+ int number_of_cores,
+ size_t max_payload_size) {
+ RTC_DCHECK(send_codec);
+ if (max_payload_size == 0) {
+ max_payload_size = kDefaultPayloadSize;
+ }
+ RTC_DCHECK_GE(number_of_cores, 1);
+ RTC_DCHECK_GE(send_codec->plType, 1);
+ // Make sure the start bit rate is sane...
+ RTC_DCHECK_LE(send_codec->startBitrate, 1000000u);
+ RTC_DCHECK(send_codec->codecType != kVideoCodecUnknown);
+ bool reset_required = pending_encoder_reset_;
+ if (number_of_cores_ != number_of_cores) {
+ number_of_cores_ = number_of_cores;
+ reset_required = true;
+ }
+ if (max_payload_size_ != max_payload_size) {
+ max_payload_size_ = max_payload_size;
+ reset_required = true;
+ }
+
+ VideoCodec new_send_codec;
+ memcpy(&new_send_codec, send_codec, sizeof(new_send_codec));
+
+ if (new_send_codec.maxBitrate == 0) {
+ // max is one bit per pixel
+ new_send_codec.maxBitrate = (static_cast<int>(send_codec->height) *
+ static_cast<int>(send_codec->width) *
+ static_cast<int>(send_codec->maxFramerate)) / 1000;
+ if (send_codec->startBitrate > new_send_codec.maxBitrate) {
+ // But if the user tries to set a higher start bit rate we will
+ // increase the max accordingly.
+ new_send_codec.maxBitrate = send_codec->startBitrate;
+ }
+ }
+
+ if (new_send_codec.startBitrate > new_send_codec.maxBitrate)
+ new_send_codec.startBitrate = new_send_codec.maxBitrate;
+
+ if (!reset_required) {
+ reset_required = RequiresEncoderReset(new_send_codec);
+ }
+
+ memcpy(&send_codec_, &new_send_codec, sizeof(send_codec_));
+
+ if (!reset_required) {
+ encoded_frame_callback_->SetPayloadType(send_codec_.plType);
+ return true;
+ }
+
+ // If encoder exists, will destroy it and create new one.
+ DeleteEncoder();
+ RTC_DCHECK_EQ(encoder_payload_type_, send_codec_.plType)
+ << "Encoder not registered for payload type " << send_codec_.plType;
+ ptr_encoder_.reset(
+ new VCMGenericEncoder(external_encoder_, encoder_rate_observer_,
+ encoded_frame_callback_, internal_source_));
+ encoded_frame_callback_->SetPayloadType(send_codec_.plType);
+ encoded_frame_callback_->SetInternalSource(internal_source_);
+ if (ptr_encoder_->InitEncode(&send_codec_, number_of_cores_,
+ max_payload_size_) < 0) {
+ LOG(LS_ERROR) << "Failed to initialize video encoder.";
+ DeleteEncoder();
+ return false;
+ }
+
+ // Intentionally don't check return value since the encoder registration
+ // shouldn't fail because the codec doesn't support changing the periodic key
+ // frame setting.
+ ptr_encoder_->SetPeriodicKeyFrames(periodic_key_frames_);
+
+ pending_encoder_reset_ = false;
+
+ return true;
+}
+
+bool VCMCodecDataBase::SendCodec(VideoCodec* current_send_codec) const {
+ if (!ptr_encoder_) {
+ return false;
+ }
+ memcpy(current_send_codec, &send_codec_, sizeof(VideoCodec));
+ return true;
+}
+
+VideoCodecType VCMCodecDataBase::SendCodec() const {
+ if (!ptr_encoder_) {
+ return kVideoCodecUnknown;
+ }
+ return send_codec_.codecType;
+}
+
+bool VCMCodecDataBase::DeregisterExternalEncoder(
+ uint8_t payload_type, bool* was_send_codec) {
+ assert(was_send_codec);
+ *was_send_codec = false;
+ if (encoder_payload_type_ != payload_type) {
+ return false;
+ }
+ if (send_codec_.plType == payload_type) {
+ // De-register as send codec if needed.
+ DeleteEncoder();
+ memset(&send_codec_, 0, sizeof(VideoCodec));
+ *was_send_codec = true;
+ }
+ encoder_payload_type_ = 0;
+ external_encoder_ = NULL;
+ internal_source_ = false;
+ return true;
+}
+
+void VCMCodecDataBase::RegisterExternalEncoder(
+ VideoEncoder* external_encoder,
+ uint8_t payload_type,
+ bool internal_source) {
+ // Since only one encoder can be used at a given time, only one external
+ // encoder can be registered/used.
+ external_encoder_ = external_encoder;
+ encoder_payload_type_ = payload_type;
+ internal_source_ = internal_source;
+ pending_encoder_reset_ = true;
+}
+
+bool VCMCodecDataBase::RequiresEncoderReset(const VideoCodec& new_send_codec) {
+ if (ptr_encoder_ == NULL) {
+ return true;
+ }
+
+ // Does not check startBitrate or maxFramerate
+ if (new_send_codec.codecType != send_codec_.codecType ||
+ strcmp(new_send_codec.plName, send_codec_.plName) != 0 ||
+ new_send_codec.plType != send_codec_.plType ||
+ new_send_codec.width != send_codec_.width ||
+ new_send_codec.height != send_codec_.height ||
+ new_send_codec.maxBitrate != send_codec_.maxBitrate ||
+ new_send_codec.minBitrate != send_codec_.minBitrate ||
+ new_send_codec.qpMax != send_codec_.qpMax ||
+ new_send_codec.numberOfSimulcastStreams !=
+ send_codec_.numberOfSimulcastStreams ||
+ new_send_codec.mode != send_codec_.mode ||
+ new_send_codec.extra_options != send_codec_.extra_options) {
+ return true;
+ }
+
+ switch (new_send_codec.codecType) {
+ case kVideoCodecVP8:
+ if (memcmp(&new_send_codec.codecSpecific.VP8,
+ &send_codec_.codecSpecific.VP8,
+ sizeof(new_send_codec.codecSpecific.VP8)) != 0) {
+ return true;
+ }
+ break;
+ case kVideoCodecVP9:
+ if (memcmp(&new_send_codec.codecSpecific.VP9,
+ &send_codec_.codecSpecific.VP9,
+ sizeof(new_send_codec.codecSpecific.VP9)) != 0) {
+ return true;
+ }
+ break;
+ case kVideoCodecH264:
+ if (memcmp(&new_send_codec.codecSpecific.H264,
+ &send_codec_.codecSpecific.H264,
+ sizeof(new_send_codec.codecSpecific.H264)) != 0) {
+ return true;
+ }
+ break;
+ case kVideoCodecGeneric:
+ break;
+ // Known codecs without payload-specifics
+ case kVideoCodecI420:
+ case kVideoCodecRED:
+ case kVideoCodecULPFEC:
+ break;
+ // Unknown codec type, reset just to be sure.
+ case kVideoCodecUnknown:
+ return true;
+ }
+
+ if (new_send_codec.numberOfSimulcastStreams > 0) {
+ for (unsigned char i = 0; i < new_send_codec.numberOfSimulcastStreams;
+ ++i) {
+ if (memcmp(&new_send_codec.simulcastStream[i],
+ &send_codec_.simulcastStream[i],
+ sizeof(new_send_codec.simulcastStream[i])) !=
+ 0) {
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+VCMGenericEncoder* VCMCodecDataBase::GetEncoder() {
+ return ptr_encoder_.get();
+}
+
+bool VCMCodecDataBase::SetPeriodicKeyFrames(bool enable) {
+ periodic_key_frames_ = enable;
+ if (ptr_encoder_) {
+ return (ptr_encoder_->SetPeriodicKeyFrames(periodic_key_frames_) == 0);
+ }
+ return true;
+}
+
+void VCMCodecDataBase::ResetReceiver() {
+ ReleaseDecoder(ptr_decoder_);
+ ptr_decoder_ = NULL;
+ memset(&receive_codec_, 0, sizeof(VideoCodec));
+ while (!dec_map_.empty()) {
+ DecoderMap::iterator it = dec_map_.begin();
+ delete (*it).second;
+ dec_map_.erase(it);
+ }
+ while (!dec_external_map_.empty()) {
+ ExternalDecoderMap::iterator external_it = dec_external_map_.begin();
+ delete (*external_it).second;
+ dec_external_map_.erase(external_it);
+ }
+}
+
+bool VCMCodecDataBase::DeregisterExternalDecoder(uint8_t payload_type) {
+ ExternalDecoderMap::iterator it = dec_external_map_.find(payload_type);
+ if (it == dec_external_map_.end()) {
+ // Not found
+ return false;
+ }
+ // We can't use payload_type to check if the decoder is currently in use,
+ // because payload type may be out of date (e.g. before we decode the first
+ // frame after RegisterReceiveCodec)
+ if (ptr_decoder_ != NULL &&
+ &ptr_decoder_->_decoder == (*it).second->external_decoder_instance) {
+ // Release it if it was registered and in use.
+ ReleaseDecoder(ptr_decoder_);
+ ptr_decoder_ = NULL;
+ }
+ DeregisterReceiveCodec(payload_type);
+ delete (*it).second;
+ dec_external_map_.erase(it);
+ return true;
+}
+
+// Add the external encoder object to the list of external decoders.
+// Won't be registered as a receive codec until RegisterReceiveCodec is called.
+bool VCMCodecDataBase::RegisterExternalDecoder(
+ VideoDecoder* external_decoder,
+ uint8_t payload_type,
+ bool internal_render_timing) {
+ // Check if payload value already exists, if so - erase old and insert new.
+ VCMExtDecoderMapItem* ext_decoder = new VCMExtDecoderMapItem(
+ external_decoder, payload_type, internal_render_timing);
+ if (!ext_decoder) {
+ return false;
+ }
+ DeregisterExternalDecoder(payload_type);
+ dec_external_map_[payload_type] = ext_decoder;
+ return true;
+}
+
+bool VCMCodecDataBase::DecoderRegistered() const {
+ return !dec_map_.empty();
+}
+
+bool VCMCodecDataBase::RegisterReceiveCodec(
+ const VideoCodec* receive_codec,
+ int number_of_cores,
+ bool require_key_frame) {
+ if (number_of_cores < 0) {
+ return false;
+ }
+ // Check if payload value already exists, if so - erase old and insert new.
+ DeregisterReceiveCodec(receive_codec->plType);
+ if (receive_codec->codecType == kVideoCodecUnknown) {
+ return false;
+ }
+ VideoCodec* new_receive_codec = new VideoCodec(*receive_codec);
+ dec_map_[receive_codec->plType] = new VCMDecoderMapItem(new_receive_codec,
+ number_of_cores,
+ require_key_frame);
+ return true;
+}
+
+bool VCMCodecDataBase::DeregisterReceiveCodec(
+ uint8_t payload_type) {
+ DecoderMap::iterator it = dec_map_.find(payload_type);
+ if (it == dec_map_.end()) {
+ return false;
+ }
+ VCMDecoderMapItem* dec_item = (*it).second;
+ delete dec_item;
+ dec_map_.erase(it);
+ if (receive_codec_.plType == payload_type) {
+ // This codec is currently in use.
+ memset(&receive_codec_, 0, sizeof(VideoCodec));
+ }
+ return true;
+}
+
+bool VCMCodecDataBase::ReceiveCodec(VideoCodec* current_receive_codec) const {
+ assert(current_receive_codec);
+ if (!ptr_decoder_) {
+ return false;
+ }
+ memcpy(current_receive_codec, &receive_codec_, sizeof(VideoCodec));
+ return true;
+}
+
+VideoCodecType VCMCodecDataBase::ReceiveCodec() const {
+ if (!ptr_decoder_) {
+ return kVideoCodecUnknown;
+ }
+ return receive_codec_.codecType;
+}
+
+VCMGenericDecoder* VCMCodecDataBase::GetDecoder(
+ uint8_t payload_type, VCMDecodedFrameCallback* decoded_frame_callback) {
+ if (payload_type == receive_codec_.plType || payload_type == 0) {
+ return ptr_decoder_;
+ }
+ // Check for exisitng decoder, if exists - delete.
+ if (ptr_decoder_) {
+ ReleaseDecoder(ptr_decoder_);
+ ptr_decoder_ = NULL;
+ memset(&receive_codec_, 0, sizeof(VideoCodec));
+ }
+ ptr_decoder_ = CreateAndInitDecoder(payload_type, &receive_codec_);
+ if (!ptr_decoder_) {
+ return NULL;
+ }
+ VCMReceiveCallback* callback = decoded_frame_callback->UserReceiveCallback();
+ if (callback) callback->OnIncomingPayloadType(receive_codec_.plType);
+ if (ptr_decoder_->RegisterDecodeCompleteCallback(decoded_frame_callback)
+ < 0) {
+ ReleaseDecoder(ptr_decoder_);
+ ptr_decoder_ = NULL;
+ memset(&receive_codec_, 0, sizeof(VideoCodec));
+ return NULL;
+ }
+ return ptr_decoder_;
+}
+
+void VCMCodecDataBase::ReleaseDecoder(VCMGenericDecoder* decoder) const {
+ if (decoder) {
+ assert(&decoder->_decoder);
+ decoder->Release();
+ if (!decoder->External()) {
+ delete &decoder->_decoder;
+ }
+ delete decoder;
+ }
+}
+
+bool VCMCodecDataBase::SupportsRenderScheduling() const {
+ const VCMExtDecoderMapItem* ext_item = FindExternalDecoderItem(
+ receive_codec_.plType);
+ if (ext_item == nullptr)
+ return true;
+ return ext_item->internal_render_timing;
+}
+
+bool VCMCodecDataBase::MatchesCurrentResolution(int width, int height) const {
+ return send_codec_.width == width && send_codec_.height == height;
+}
+
+VCMGenericDecoder* VCMCodecDataBase::CreateAndInitDecoder(
+ uint8_t payload_type,
+ VideoCodec* new_codec) const {
+ assert(new_codec);
+ const VCMDecoderMapItem* decoder_item = FindDecoderItem(payload_type);
+ if (!decoder_item) {
+ LOG(LS_ERROR) << "Can't find a decoder associated with payload type: "
+ << static_cast<int>(payload_type);
+ return NULL;
+ }
+ VCMGenericDecoder* ptr_decoder = NULL;
+ const VCMExtDecoderMapItem* external_dec_item =
+ FindExternalDecoderItem(payload_type);
+ if (external_dec_item) {
+ // External codec.
+ ptr_decoder = new VCMGenericDecoder(
+ *external_dec_item->external_decoder_instance, true);
+ } else {
+ // Create decoder.
+ ptr_decoder = CreateDecoder(decoder_item->settings->codecType);
+ }
+ if (!ptr_decoder)
+ return NULL;
+
+ if (ptr_decoder->InitDecode(decoder_item->settings.get(),
+ decoder_item->number_of_cores) < 0) {
+ ReleaseDecoder(ptr_decoder);
+ return NULL;
+ }
+ memcpy(new_codec, decoder_item->settings.get(), sizeof(VideoCodec));
+ return ptr_decoder;
+}
+
+void VCMCodecDataBase::DeleteEncoder() {
+ if (!ptr_encoder_)
+ return;
+ ptr_encoder_->Release();
+ ptr_encoder_.reset();
+}
+
+VCMGenericDecoder* VCMCodecDataBase::CreateDecoder(VideoCodecType type) const {
+ switch (type) {
+#ifdef VIDEOCODEC_VP8
+ case kVideoCodecVP8:
+ return new VCMGenericDecoder(*(VP8Decoder::Create()));
+#endif
+#ifdef VIDEOCODEC_VP9
+ case kVideoCodecVP9:
+ return new VCMGenericDecoder(*(VP9Decoder::Create()));
+#endif
+#ifdef VIDEOCODEC_I420
+ case kVideoCodecI420:
+ return new VCMGenericDecoder(*(new I420Decoder));
+#endif
+#ifdef VIDEOCODEC_H264
+ case kVideoCodecH264:
+ if (H264Decoder::IsSupported()) {
+ return new VCMGenericDecoder(*(H264Decoder::Create()));
+ }
+ break;
+#endif
+ default:
+ break;
+ }
+ LOG(LS_WARNING) << "No internal decoder of this type exists.";
+ return NULL;
+}
+
+const VCMDecoderMapItem* VCMCodecDataBase::FindDecoderItem(
+ uint8_t payload_type) const {
+ DecoderMap::const_iterator it = dec_map_.find(payload_type);
+ if (it != dec_map_.end()) {
+ return (*it).second;
+ }
+ return NULL;
+}
+
+const VCMExtDecoderMapItem* VCMCodecDataBase::FindExternalDecoderItem(
+ uint8_t payload_type) const {
+ ExternalDecoderMap::const_iterator it = dec_external_map_.find(payload_type);
+ if (it != dec_external_map_.end()) {
+ return (*it).second;
+ }
+ return NULL;
+}
+} // namespace webrtc