| /* |
| * This file is part of FFmpeg. |
| * |
| * FFmpeg is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * FFmpeg is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with FFmpeg; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| */ |
| |
| #include "libavutil/opt.h" |
| #include "libavutil/pixdesc.h" |
| #include "libavcodec/codec.h" |
| #include "libavcodec/codec_desc.h" |
| #include "libavcodec/codec_internal.h" |
| |
| static const char *get_type_string(enum AVMediaType type) |
| { |
| const char *ret = av_get_media_type_string(type); |
| return ret ? ret : "unknown"; |
| } |
| |
| #define AV_LOG(...) av_log(NULL, AV_LOG_FATAL, __VA_ARGS__) |
| #define ERR_INTERNAL(msg, ...) \ |
| do { \ |
| AV_LOG(msg, codec->name __VA_ARGS__); \ |
| ret = 1; \ |
| } while (0) |
| #define ERR(msg) ERR_INTERNAL(msg, ) |
| #define ERR_EXT(msg, ...) ERR_INTERNAL(msg, , __VA_ARGS__) |
| |
| static int priv_data_size_wrong(const FFCodec *codec) |
| { |
| if (codec->priv_data_size < 0 || |
| codec->p.priv_class && codec->priv_data_size < sizeof(AVClass*)) |
| return 1; |
| if (!codec->p.priv_class || !codec->p.priv_class->option) |
| return 0; |
| for (const AVOption *opt = codec->p.priv_class->option; opt->name; opt++) { |
| if (opt->offset >= codec->priv_data_size || |
| opt->type == AV_OPT_TYPE_CONST && opt->offset != 0 || |
| opt->type != AV_OPT_TYPE_CONST && (opt->offset < sizeof(AVClass*) || opt->offset < 0)) { |
| AV_LOG("Option %s offset %d nonsensical\n", |
| opt->name, opt->offset); |
| return 1; |
| } |
| } |
| return 0; |
| } |
| |
| #define ARRAY_CHECK(field, var, type, is_sentinel, check, sentinel_check) \ |
| do { \ |
| const type *ptr = codec->field; \ |
| if (!ptr) \ |
| break; \ |
| type var = *ptr; \ |
| if (is_sentinel) { \ |
| ERR("Codec %s sets " #field ", but without valid elements.\n"); \ |
| break; \ |
| } \ |
| do { \ |
| if (!(check)) { \ |
| ERR("Codec's %s " #field " array contains invalid element\n");\ |
| break; \ |
| } \ |
| ++ptr; \ |
| var = *ptr; \ |
| } while (!(is_sentinel)); \ |
| if (!(sentinel_check)) { \ |
| ERR("Codec's %s " #field " array has malformed sentinel\n"); \ |
| break; \ |
| } \ |
| } while (0) |
| |
| int main(void){ |
| void *iter = NULL; |
| const AVCodec *codec = NULL; |
| int ret = 0; |
| |
| while (codec = av_codec_iterate(&iter)) { |
| const FFCodec *const codec2 = ffcodec(codec); |
| const AVCodecDescriptor *desc; |
| int is_decoder = 0, is_encoder = 0; |
| |
| if (!codec->name) { |
| AV_LOG("Codec for format %s has no name\n", |
| avcodec_get_name(codec->id)); |
| ret = 1; |
| continue; |
| } |
| if (codec->type != AVMEDIA_TYPE_VIDEO && |
| codec->type != AVMEDIA_TYPE_AUDIO && |
| codec->type != AVMEDIA_TYPE_SUBTITLE) |
| ERR_EXT("Codec %s has unsupported type %s\n", |
| get_type_string(codec->type)); |
| if (codec->type != AVMEDIA_TYPE_AUDIO) { |
| FF_DISABLE_DEPRECATION_WARNINGS |
| if (codec->ch_layouts || codec->sample_fmts || |
| codec->supported_samplerates) |
| ERR("Non-audio codec %s has audio-only fields set\n"); |
| FF_ENABLE_DEPRECATION_WARNINGS |
| if (codec->capabilities & (AV_CODEC_CAP_SMALL_LAST_FRAME | |
| AV_CODEC_CAP_CHANNEL_CONF | |
| AV_CODEC_CAP_VARIABLE_FRAME_SIZE)) |
| ERR("Non-audio codec %s has audio-only capabilities set\n"); |
| } else { |
| FF_DISABLE_DEPRECATION_WARNINGS |
| ARRAY_CHECK(supported_samplerates, sample_rate, int, sample_rate == 0, |
| sample_rate > 0, 1); |
| ARRAY_CHECK(sample_fmts, sample_fmt, enum AVSampleFormat, sample_fmt == AV_SAMPLE_FMT_NONE, |
| (unsigned)sample_fmt < AV_SAMPLE_FMT_NB, 1); |
| static const AVChannelLayout zero_channel_layout = { 0 }; |
| ARRAY_CHECK(ch_layouts, ch_layout, AVChannelLayout, ch_layout.nb_channels == 0, |
| av_channel_layout_check(&ch_layout), !memcmp(ptr, &zero_channel_layout, sizeof(ch_layout))); |
| FF_ENABLE_DEPRECATION_WARNINGS |
| } |
| if (codec->type != AVMEDIA_TYPE_VIDEO) { |
| FF_DISABLE_DEPRECATION_WARNINGS |
| if (codec->pix_fmts || codec->supported_framerates || |
| codec2->color_ranges || codec2->alpha_modes) |
| ERR("Non-video codec %s has video-only fields set\n"); |
| FF_ENABLE_DEPRECATION_WARNINGS |
| if (codec2->caps_internal & FF_CODEC_CAP_EXPORTS_CROPPING) |
| ERR("Non-video codec %s exports cropping\n"); |
| } |
| if (codec2->caps_internal & FF_CODEC_CAP_SLICE_THREAD_HAS_MF && |
| !(codec->capabilities & AV_CODEC_CAP_SLICE_THREADS)) |
| ERR("Codec %s wants mainfunction despite not being " |
| "slice-threading capable"); |
| if (codec2->caps_internal & FF_CODEC_CAP_AUTO_THREADS && |
| !(codec->capabilities & (AV_CODEC_CAP_FRAME_THREADS | |
| AV_CODEC_CAP_SLICE_THREADS | |
| AV_CODEC_CAP_OTHER_THREADS))) |
| ERR("Codec %s has private-only threading support\n"); |
| |
| switch (codec2->cb_type) { |
| case FF_CODEC_CB_TYPE_DECODE: |
| case FF_CODEC_CB_TYPE_DECODE_SUB: |
| case FF_CODEC_CB_TYPE_RECEIVE_FRAME: |
| is_decoder = 1; |
| break; |
| case FF_CODEC_CB_TYPE_ENCODE: |
| case FF_CODEC_CB_TYPE_ENCODE_SUB: |
| case FF_CODEC_CB_TYPE_RECEIVE_PACKET: |
| is_encoder = 1; |
| break; |
| default: |
| ERR("Codec %s has unknown cb_type\n"); |
| continue; |
| } |
| if (is_decoder != av_codec_is_decoder(codec) || |
| is_encoder != av_codec_is_encoder(codec)) { |
| ERR("Codec %s cb_type and av_codec_is_(de|en)coder inconsistent.\n"); |
| continue; |
| } |
| #define CHECK(TYPE, type) (codec2->cb_type == FF_CODEC_CB_TYPE_ ## TYPE && !codec2->cb.type) |
| if (CHECK(DECODE, decode) || CHECK(DECODE_SUB, decode_sub) || |
| CHECK(RECEIVE_PACKET, receive_packet) || |
| CHECK(ENCODE, encode) || CHECK(ENCODE_SUB, encode_sub) || |
| CHECK(RECEIVE_FRAME, receive_frame)) { |
| ERR_EXT("Codec %s does not implement its %s callback.\n", |
| is_decoder ? "decoding" : "encoding"); |
| } |
| #undef CHECK |
| if (is_encoder) { |
| if ((codec->type == AVMEDIA_TYPE_SUBTITLE) != (codec2->cb_type == FF_CODEC_CB_TYPE_ENCODE_SUB)) |
| ERR("Encoder %s is both subtitle encoder and not subtitle encoder."); |
| if (codec2->update_thread_context || codec2->update_thread_context_for_user || codec2->bsfs) |
| ERR("Encoder %s has decoder-only thread functions or bsf.\n"); |
| if (codec->type == AVMEDIA_TYPE_AUDIO) { |
| FF_DISABLE_DEPRECATION_WARNINGS |
| if (!codec->sample_fmts) { |
| av_log(NULL, AV_LOG_FATAL, "Encoder %s is missing the sample_fmts field\n", codec->name); |
| ret = 1; |
| } |
| } else if (codec->type == AVMEDIA_TYPE_VIDEO) { |
| ARRAY_CHECK(pix_fmts, pix_fmt, enum AVPixelFormat, pix_fmt == AV_PIX_FMT_NONE, |
| av_pix_fmt_desc_get(pix_fmt), 1); |
| ARRAY_CHECK(supported_framerates, framerate, AVRational, framerate.num == 0, |
| framerate.num > 0 && framerate.den > 0, framerate.den == 0); |
| FF_ENABLE_DEPRECATION_WARNINGS |
| } |
| if (codec2->caps_internal & (FF_CODEC_CAP_USES_PROGRESSFRAMES | |
| FF_CODEC_CAP_SETS_PKT_DTS | |
| FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM | |
| FF_CODEC_CAP_EXPORTS_CROPPING | |
| FF_CODEC_CAP_SETS_FRAME_PROPS) || |
| codec->capabilities & (AV_CODEC_CAP_AVOID_PROBING | |
| AV_CODEC_CAP_CHANNEL_CONF | |
| AV_CODEC_CAP_DRAW_HORIZ_BAND)) |
| ERR("Encoder %s has decoder-only capabilities set\n"); |
| if (codec->capabilities & AV_CODEC_CAP_FRAME_THREADS && |
| codec->capabilities & AV_CODEC_CAP_ENCODER_FLUSH) |
| ERR("Frame-threaded encoder %s claims to support flushing\n"); |
| if (codec->capabilities & AV_CODEC_CAP_FRAME_THREADS && |
| codec->capabilities & AV_CODEC_CAP_DELAY) |
| ERR("Frame-threaded encoder %s claims to have delay\n"); |
| |
| if (codec2->caps_internal & FF_CODEC_CAP_EOF_FLUSH && |
| !(codec->capabilities & AV_CODEC_CAP_DELAY)) |
| ERR("EOF_FLUSH encoder %s is not marked as having delay\n"); |
| } else { |
| if ((codec2->update_thread_context || codec2->update_thread_context_for_user) && |
| !(codec->capabilities & AV_CODEC_CAP_FRAME_THREADS)) |
| ERR("Non-frame-threaded decoder %s has update_thread_context set"); |
| if ((codec->type == AVMEDIA_TYPE_SUBTITLE) != (codec2->cb_type == FF_CODEC_CB_TYPE_DECODE_SUB)) |
| ERR("Subtitle decoder %s does not implement decode_sub callback\n"); |
| if (codec->type == AVMEDIA_TYPE_SUBTITLE && codec2->bsfs) |
| ERR("Automatic bitstream filtering unsupported for subtitles; " |
| "yet decoder %s has it set\n"); |
| if (codec->capabilities & (AV_CODEC_CAP_SMALL_LAST_FRAME | |
| AV_CODEC_CAP_VARIABLE_FRAME_SIZE | |
| AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE | |
| AV_CODEC_CAP_ENCODER_FLUSH)) |
| ERR("Decoder %s has encoder-only capabilities\n"); |
| if (codec2->cb_type != FF_CODEC_CB_TYPE_DECODE && |
| codec2->caps_internal & FF_CODEC_CAP_SETS_PKT_DTS) |
| ERR("Decoder %s is marked as setting pkt_dts when it doesn't have" |
| "any effect\n"); |
| FF_DISABLE_DEPRECATION_WARNINGS |
| if (codec->type == AVMEDIA_TYPE_VIDEO && (codec->pix_fmts || codec->supported_framerates)) |
| ERR("Decoder %s sets pix_fmts or supported_framerates.\n"); |
| FF_ENABLE_DEPRECATION_WARNINGS |
| } |
| if (priv_data_size_wrong(codec2)) |
| ERR_EXT("Private context of codec %s is impossibly-sized (size %d).", |
| codec2->priv_data_size); |
| if (!(desc = avcodec_descriptor_get(codec->id))) { |
| ERR("Codec %s lacks a corresponding descriptor\n"); |
| } else if (desc->type != codec->type) |
| ERR_EXT("The type of AVCodec %s and its AVCodecDescriptor differ: " |
| "%s vs %s\n", |
| get_type_string(codec->type), get_type_string(desc->type)); |
| } |
| return ret; |
| } |
