virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2025-12-25 22:17:24 +02:00
Code Issues Releases Activity
Files
ec2ceefcfa0d9e340eb0d3ecaef9be3040bddc4d
FFmpeg/libavcodec/tests/avcodec.c
Andreas Rheinhardt 946a1dbd94 avcodec/tests/avcodec: Check codec {pix,sample}_fmt etc. arrays 
E.g. check that the ordinary entries are valid (e.g. no negative sample
rates, must have pix fmt descriptor) and also that the sentinels
are valid where they contain redundant information.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
2025-11-07 17:55:43 +00:00

245 lines
12 KiB
C
Raw Blame History

/*
* 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;
}
Reference in New Issue View Git Blame Copy Permalink