virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
Code Issues Releases Activity

Merge remote-tracking branch 'qatar/master'

Browse Source 
* qatar/master:
  mxfdec: Include FF_INPUT_BUFFER_PADDING_SIZE when allocating extradata.
  H.264: tweak some other x86 asm for Atom
  probe: Fix insane flow control.
  mpegts: remove invalid error check
  s302m: use nondeprecated audio sample format API
  lavc: use designated initialisers for all codecs.
  x86: cabac: add operand size suffixes missing from 6c32576

Conflicts:
	libavcodec/ac3enc_float.c
	libavcodec/flacenc.c
	libavcodec/frwu.c
	libavcodec/pictordec.c
	libavcodec/qtrleenc.c
	libavcodec/v210enc.c
	libavcodec/wmv2dec.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Michael Niedermayer 2011-07-30 06:39:57 +02:00
commit faba79e080
202 changed files with 1882 additions and 2171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
libavcodec/4xm.c
View File

@ -865,15 +865,14 @@ static av_cold int decode_end(AVCodecContext *avctx){
} }
AVCodec ff_fourxm_decoder = { AVCodec ff_fourxm_decoder = {
"4xm", .name = "4xm",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_4XM, .id = CODEC_ID_4XM,
sizeof(FourXContext), .priv_data_size = sizeof(FourXContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("4X Movie"), .long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
}; };

17
libavcodec/8bps.c
View File

@ -222,14 +222,13 @@ static av_cold int decode_end(AVCodecContext *avctx)
AVCodec ff_eightbps_decoder = { AVCodec ff_eightbps_decoder = {
"8bps", .name = "8bps",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_8BPS, .id = CODEC_ID_8BPS,
sizeof(EightBpsContext), .priv_data_size = sizeof(EightBpsContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("QuickTime 8BPS video"), .long_name = NULL_IF_CONFIG_SMALL("QuickTime 8BPS video"),
}; };

15
libavcodec/aacdec.c
View File

@ -2541,14 +2541,13 @@ av_cold static int latm_decode_init(AVCodecContext *avctx)
AVCodec ff_aac_decoder = { AVCodec ff_aac_decoder = {
"aac", .name = "aac",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_AAC, .id = CODEC_ID_AAC,
sizeof(AACContext), .priv_data_size = sizeof(AACContext),
aac_decode_init, .init = aac_decode_init,
NULL, .close = aac_decode_close,
aac_decode_close, .decode = aac_decode_frame,
aac_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("Advanced Audio Coding"), .long_name = NULL_IF_CONFIG_SMALL("Advanced Audio Coding"),
.sample_fmts = (const enum AVSampleFormat[]) { .sample_fmts = (const enum AVSampleFormat[]) {
AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE

14
libavcodec/aacenc.c
View File

@ -692,13 +692,13 @@ static const AVClass aacenc_class = {
}; };
AVCodec ff_aac_encoder = { AVCodec ff_aac_encoder = {
"aac", .name = "aac",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_AAC, .id = CODEC_ID_AAC,
sizeof(AACEncContext), .priv_data_size = sizeof(AACEncContext),
aac_encode_init, .init = aac_encode_init,
aac_encode_frame, .encode = aac_encode_frame,
aac_encode_end, .close = aac_encode_end,
.capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY | CODEC_CAP_EXPERIMENTAL, .capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY | CODEC_CAP_EXPERIMENTAL,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("Advanced Audio Coding"), .long_name = NULL_IF_CONFIG_SMALL("Advanced Audio Coding"),

17
libavcodec/aasc.c
View File

@ -110,14 +110,13 @@ static av_cold int aasc_decode_end(AVCodecContext *avctx)
} }
AVCodec ff_aasc_decoder = { AVCodec ff_aasc_decoder = {
"aasc", .name = "aasc",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_AASC, .id = CODEC_ID_AASC,
sizeof(AascContext), .priv_data_size = sizeof(AascContext),
aasc_decode_init, .init = aasc_decode_init,
NULL, .close = aasc_decode_end,
aasc_decode_end, .decode = aasc_decode_frame,
aasc_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Autodesk RLE"), .long_name = NULL_IF_CONFIG_SMALL("Autodesk RLE"),
}; };

15
libavcodec/ac3enc_fixed.c
View File

@ -121,14 +121,13 @@ static av_cold int ac3_fixed_encode_init(AVCodecContext *avctx)
AVCodec ff_ac3_fixed_encoder = { AVCodec ff_ac3_fixed_encoder = {
"ac3_fixed", .name = "ac3_fixed",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_AC3, .id = CODEC_ID_AC3,
sizeof(AC3EncodeContext), .priv_data_size = sizeof(AC3EncodeContext),
ac3_fixed_encode_init, .init = ac3_fixed_encode_init,
ff_ac3_fixed_encode_frame, .encode = ff_ac3_fixed_encode_frame,
ff_ac3_encode_close, .close = ff_ac3_encode_close,
NULL,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"), .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
.priv_class = &ac3enc_class, .priv_class = &ac3enc_class,

15
libavcodec/ac3enc_float.c
View File

@ -121,14 +121,13 @@ static void clip_coefficients(DSPContext *dsp, float *coef, unsigned int len)
#if CONFIG_AC3_ENCODER #if CONFIG_AC3_ENCODER
AVCodec ff_ac3_float_encoder = { AVCodec ff_ac3_float_encoder = {
"ac3_float", .name = "ac3 float",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_AC3, .id = CODEC_ID_AC3,
sizeof(AC3EncodeContext), .priv_data_size = sizeof(AC3EncodeContext),
ff_ac3_encode_init, .init = ff_ac3_encode_init,
ff_ac3_float_encode_frame, .encode = ff_ac3_float_encode_frame,
ff_ac3_encode_close, .close = ff_ac3_encode_close,
NULL,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_FLT,AV_SAMPLE_FMT_NONE}, .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_FLT,AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"), .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
.priv_class = &ac3enc_class, .priv_class = &ac3enc_class,

14
libavcodec/adxdec.c
View File

@ -167,14 +167,12 @@ static int adx_decode_frame(AVCodecContext *avctx,
} }
AVCodec ff_adpcm_adx_decoder = { AVCodec ff_adpcm_adx_decoder = {
"adpcm_adx", .name = "adpcm_adx",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_ADPCM_ADX, .id = CODEC_ID_ADPCM_ADX,
sizeof(ADXContext), .priv_data_size = sizeof(ADXContext),
adx_decode_init, .init = adx_decode_init,
NULL, .decode = adx_decode_frame,
NULL,
adx_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("SEGA CRI ADX ADPCM"), .long_name = NULL_IF_CONFIG_SMALL("SEGA CRI ADX ADPCM"),
}; };

15
libavcodec/adxenc.c
View File

@ -184,14 +184,13 @@ static int adx_encode_frame(AVCodecContext *avctx,
} }
AVCodec ff_adpcm_adx_encoder = { AVCodec ff_adpcm_adx_encoder = {
"adpcm_adx", .name = "adpcm_adx",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_ADPCM_ADX, .id = CODEC_ID_ADPCM_ADX,
sizeof(ADXContext), .priv_data_size = sizeof(ADXContext),
adx_encode_init, .init = adx_encode_init,
adx_encode_frame, .encode = adx_encode_frame,
adx_encode_close, .close = adx_encode_close,
NULL,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("SEGA CRI ADX ADPCM"), .long_name = NULL_IF_CONFIG_SMALL("SEGA CRI ADX ADPCM"),
}; };

15
libavcodec/alac.c
View File

@ -679,13 +679,12 @@ static av_cold int alac_decode_close(AVCodecContext *avctx)
} }
AVCodec ff_alac_decoder = { AVCodec ff_alac_decoder = {
"alac", .name = "alac",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_ALAC, .id = CODEC_ID_ALAC,
sizeof(ALACContext), .priv_data_size = sizeof(ALACContext),
alac_decode_init, .init = alac_decode_init,
NULL, .close = alac_decode_close,
alac_decode_close, .decode = alac_decode_frame,
alac_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"), .long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
}; };

14
libavcodec/alacenc.c
View File

@ -529,13 +529,13 @@ static av_cold int alac_encode_close(AVCodecContext *avctx)
} }
AVCodec ff_alac_encoder = { AVCodec ff_alac_encoder = {
"alac", .name = "alac",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_ALAC, .id = CODEC_ID_ALAC,
sizeof(AlacEncodeContext), .priv_data_size = sizeof(AlacEncodeContext),
alac_encode_init, .init = alac_encode_init,
alac_encode_frame, .encode = alac_encode_frame,
alac_encode_close, .close = alac_encode_close,
.capabilities = CODEC_CAP_SMALL_LAST_FRAME, .capabilities = CODEC_CAP_SMALL_LAST_FRAME,
.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE}, .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"), .long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),

15
libavcodec/alsdec.c
View File

@ -1739,14 +1739,13 @@ static av_cold void flush(AVCodecContext *avctx)
AVCodec ff_als_decoder = { AVCodec ff_als_decoder = {
"als", .name = "als",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_MP4ALS, .id = CODEC_ID_MP4ALS,
sizeof(ALSDecContext), .priv_data_size = sizeof(ALSDecContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame,
.flush = flush, .flush = flush,
.capabilities = CODEC_CAP_SUBFRAMES, .capabilities = CODEC_CAP_SUBFRAMES,
.long_name = NULL_IF_CONFIG_SMALL("MPEG-4 Audio Lossless Coding (ALS)"), .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 Audio Lossless Coding (ALS)"),

17
libavcodec/anm.c
View File

@ -184,14 +184,13 @@ static av_cold int decode_end(AVCodecContext *avctx)
} }
AVCodec ff_anm_decoder = { AVCodec ff_anm_decoder = {
"anm", .name = "anm",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_ANM, .id = CODEC_ID_ANM,
sizeof(AnmContext), .priv_data_size = sizeof(AnmContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Deluxe Paint Animation"), .long_name = NULL_IF_CONFIG_SMALL("Deluxe Paint Animation"),
}; };

15
libavcodec/apedec.c
View File

@ -885,14 +885,13 @@ static void ape_flush(AVCodecContext *avctx)
} }
AVCodec ff_ape_decoder = { AVCodec ff_ape_decoder = {
"ape", .name = "ape",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_APE, .id = CODEC_ID_APE,
sizeof(APEContext), .priv_data_size = sizeof(APEContext),
ape_decode_init, .init = ape_decode_init,
NULL, .close = ape_decode_close,
ape_decode_close, .decode = ape_decode_frame,
ape_decode_frame,
.capabilities = CODEC_CAP_SUBFRAMES, .capabilities = CODEC_CAP_SUBFRAMES,
.flush = ape_flush, .flush = ape_flush,
.long_name = NULL_IF_CONFIG_SMALL("Monkey's Audio"), .long_name = NULL_IF_CONFIG_SMALL("Monkey's Audio"),

58
libavcodec/asv1.c
View File

@ -603,39 +603,37 @@ static av_cold int decode_end(AVCodecContext *avctx){
} }
AVCodec ff_asv1_decoder = { AVCodec ff_asv1_decoder = {
"asv1", .name = "asv1",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_ASV1, .id = CODEC_ID_ASV1,
sizeof(ASV1Context), .priv_data_size = sizeof(ASV1Context),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name= NULL_IF_CONFIG_SMALL("ASUS V1"), .long_name= NULL_IF_CONFIG_SMALL("ASUS V1"),
}; };
AVCodec ff_asv2_decoder = { AVCodec ff_asv2_decoder = {
"asv2", .name = "asv2",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_ASV2, .id = CODEC_ID_ASV2,
sizeof(ASV1Context), .priv_data_size = sizeof(ASV1Context),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name= NULL_IF_CONFIG_SMALL("ASUS V2"), .long_name= NULL_IF_CONFIG_SMALL("ASUS V2"),
}; };
#if CONFIG_ASV1_ENCODER #if CONFIG_ASV1_ENCODER
AVCodec ff_asv1_encoder = { AVCodec ff_asv1_encoder = {
"asv1", .name = "asv1",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_ASV1, .id = CODEC_ID_ASV1,
sizeof(ASV1Context), .priv_data_size = sizeof(ASV1Context),
encode_init, .init = encode_init,
encode_frame, .encode = encode_frame,
//encode_end, //encode_end,
.pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
.long_name= NULL_IF_CONFIG_SMALL("ASUS V1"), .long_name= NULL_IF_CONFIG_SMALL("ASUS V1"),
@ -644,12 +642,12 @@ AVCodec ff_asv1_encoder = {
#if CONFIG_ASV2_ENCODER #if CONFIG_ASV2_ENCODER
AVCodec ff_asv2_encoder = { AVCodec ff_asv2_encoder = {
"asv2", .name = "asv2",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_ASV2, .id = CODEC_ID_ASV2,
sizeof(ASV1Context), .priv_data_size = sizeof(ASV1Context),
encode_init, .init = encode_init,
encode_frame, .encode = encode_frame,
//encode_end, //encode_end,
.pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
.long_name= NULL_IF_CONFIG_SMALL("ASUS V2"), .long_name= NULL_IF_CONFIG_SMALL("ASUS V2"),

18
libavcodec/aura.c
View File

@ -124,16 +124,14 @@ static av_cold int aura_decode_end(AVCodecContext *avctx)
} }
AVCodec ff_aura2_decoder = { AVCodec ff_aura2_decoder = {
"aura2", .name = "aura2",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_AURA2, .id = CODEC_ID_AURA2,
sizeof(AuraDecodeContext), .priv_data_size = sizeof(AuraDecodeContext),
aura_decode_init, .init = aura_decode_init,
NULL, .close = aura_decode_end,
aura_decode_end, .decode = aura_decode_frame,
aura_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
NULL,
.long_name = NULL_IF_CONFIG_SMALL("Auravision Aura 2"), .long_name = NULL_IF_CONFIG_SMALL("Auravision Aura 2"),
}; };

16
libavcodec/avs.c
View File

@ -153,14 +153,12 @@ static av_cold int avs_decode_init(AVCodecContext * avctx)
} }
AVCodec ff_avs_decoder = { AVCodec ff_avs_decoder = {
"avs", .name = "avs",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_AVS, .id = CODEC_ID_AVS,
sizeof(AvsContext), .priv_data_size = sizeof(AvsContext),
avs_decode_init, .init = avs_decode_init,
NULL, .decode = avs_decode_frame,
NULL, .capabilities = CODEC_CAP_DR1,
avs_decode_frame,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("AVS (Audio Video Standard) video"), .long_name = NULL_IF_CONFIG_SMALL("AVS (Audio Video Standard) video"),
}; };

15
libavcodec/bink.c
View File

@ -1334,13 +1334,12 @@ static av_cold int decode_end(AVCodecContext *avctx)
} }
AVCodec ff_bink_decoder = { AVCodec ff_bink_decoder = {
"binkvideo", .name = "binkvideo",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_BINKVIDEO, .id = CODEC_ID_BINKVIDEO,
sizeof(BinkContext), .priv_data_size = sizeof(BinkContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("Bink video"), .long_name = NULL_IF_CONFIG_SMALL("Bink video"),
}; };

30
libavcodec/binkaudio.c
View File

@ -292,25 +292,23 @@ static int decode_frame(AVCodecContext *avctx,
} }
AVCodec ff_binkaudio_rdft_decoder = { AVCodec ff_binkaudio_rdft_decoder = {
"binkaudio_rdft", .name = "binkaudio_rdft",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_BINKAUDIO_RDFT, .id = CODEC_ID_BINKAUDIO_RDFT,
sizeof(BinkAudioContext), .priv_data_size = sizeof(BinkAudioContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("Bink Audio (RDFT)") .long_name = NULL_IF_CONFIG_SMALL("Bink Audio (RDFT)")
}; };
AVCodec ff_binkaudio_dct_decoder = { AVCodec ff_binkaudio_dct_decoder = {
"binkaudio_dct", .name = "binkaudio_dct",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_BINKAUDIO_DCT, .id = CODEC_ID_BINKAUDIO_DCT,
sizeof(BinkAudioContext), .priv_data_size = sizeof(BinkAudioContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("Bink Audio (DCT)") .long_name = NULL_IF_CONFIG_SMALL("Bink Audio (DCT)")
}; };

17
libavcodec/bmp.c
View File

@ -336,14 +336,13 @@ static av_cold int bmp_decode_end(AVCodecContext *avctx)
} }
AVCodec ff_bmp_decoder = { AVCodec ff_bmp_decoder = {
"bmp", .name = "bmp",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_BMP, .id = CODEC_ID_BMP,
sizeof(BMPContext), .priv_data_size = sizeof(BMPContext),
bmp_decode_init, .init = bmp_decode_init,
NULL, .close = bmp_decode_end,
bmp_decode_end, .decode = bmp_decode_frame,
bmp_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("BMP image"), .long_name = NULL_IF_CONFIG_SMALL("BMP image"),
}; };

13
libavcodec/bmpenc.c
View File

@ -150,13 +150,12 @@ static int bmp_encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_s
} }
AVCodec ff_bmp_encoder = { AVCodec ff_bmp_encoder = {
"bmp", .name = "bmp",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_BMP, .id = CODEC_ID_BMP,
sizeof(BMPContext), .priv_data_size = sizeof(BMPContext),
bmp_encode_init, .init = bmp_encode_init,
bmp_encode_frame, .encode = bmp_encode_frame,
NULL, //encode_end,
.pix_fmts = (const enum PixelFormat[]){ .pix_fmts = (const enum PixelFormat[]){
PIX_FMT_BGR24, PIX_FMT_BGR24,
PIX_FMT_RGB555, PIX_FMT_RGB565, PIX_FMT_RGB555, PIX_FMT_RGB565,

17
libavcodec/c93.c
View File

@ -247,14 +247,13 @@ static int decode_frame(AVCodecContext *avctx, void *data,
} }
AVCodec ff_c93_decoder = { AVCodec ff_c93_decoder = {
"c93", .name = "c93",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_C93, .id = CODEC_ID_C93,
sizeof(C93DecoderContext), .priv_data_size = sizeof(C93DecoderContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Interplay C93"), .long_name = NULL_IF_CONFIG_SMALL("Interplay C93"),
}; };

17
libavcodec/cavsdec.c
View File

@ -710,15 +710,14 @@ static int cavs_decode_frame(AVCodecContext * avctx,void *data, int *data_size,
} }
AVCodec ff_cavs_decoder = { AVCodec ff_cavs_decoder = {
"cavs", .name = "cavs",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_CAVS, .id = CODEC_ID_CAVS,
sizeof(AVSContext), .priv_data_size = sizeof(AVSContext),
ff_cavs_init, .init = ff_cavs_init,
NULL, .close = ff_cavs_end,
ff_cavs_end, .decode = cavs_decode_frame,
cavs_decode_frame, .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
CODEC_CAP_DR1 | CODEC_CAP_DELAY,
.flush= cavs_flush, .flush= cavs_flush,
.long_name= NULL_IF_CONFIG_SMALL("Chinese AVS video (AVS1-P2, JiZhun profile)"), .long_name= NULL_IF_CONFIG_SMALL("Chinese AVS video (AVS1-P2, JiZhun profile)"),
}; };

17
libavcodec/cdgraphics.c
View File

@ -368,14 +368,13 @@ static av_cold int cdg_decode_end(AVCodecContext *avctx)
} }
AVCodec ff_cdgraphics_decoder = { AVCodec ff_cdgraphics_decoder = {
"cdgraphics", .name = "cdgraphics",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_CDGRAPHICS, .id = CODEC_ID_CDGRAPHICS,
sizeof(CDGraphicsContext), .priv_data_size = sizeof(CDGraphicsContext),
cdg_decode_init, .init = cdg_decode_init,
NULL, .close = cdg_decode_end,
cdg_decode_end, .decode = cdg_decode_frame,
cdg_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("CD Graphics video"), .long_name = NULL_IF_CONFIG_SMALL("CD Graphics video"),
}; };

17
libavcodec/cinepak.c
View File

@ -460,14 +460,13 @@ static av_cold int cinepak_decode_end(AVCodecContext *avctx)
} }
AVCodec ff_cinepak_decoder = { AVCodec ff_cinepak_decoder = {
"cinepak", .name = "cinepak",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_CINEPAK, .id = CODEC_ID_CINEPAK,
sizeof(CinepakContext), .priv_data_size = sizeof(CinepakContext),
cinepak_decode_init, .init = cinepak_decode_init,
NULL, .close = cinepak_decode_end,
cinepak_decode_end, .decode = cinepak_decode_frame,
cinepak_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Cinepak"), .long_name = NULL_IF_CONFIG_SMALL("Cinepak"),
}; };

28
libavcodec/cljr.c
View File

@ -142,26 +142,24 @@ static av_cold int encode_init(AVCodecContext *avctx){
#endif #endif
AVCodec ff_cljr_decoder = { AVCodec ff_cljr_decoder = {
"cljr", .name = "cljr",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_CLJR, .id = CODEC_ID_CLJR,
sizeof(CLJRContext), .priv_data_size = sizeof(CLJRContext),
decode_init, .init = decode_init,
NULL, .decode = decode_frame,
NULL, .capabilities = CODEC_CAP_DR1,
decode_frame,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Cirrus Logic AccuPak"), .long_name = NULL_IF_CONFIG_SMALL("Cirrus Logic AccuPak"),
}; };
#if CONFIG_CLJR_ENCODER #if CONFIG_CLJR_ENCODER
AVCodec ff_cljr_encoder = { AVCodec ff_cljr_encoder = {
"cljr", .name = "cljr",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_CLJR, .id = CODEC_ID_CLJR,
sizeof(CLJRContext), .priv_data_size = sizeof(CLJRContext),
encode_init, .init = encode_init,
encode_frame, .encode = encode_frame,
//encode_end, //encode_end,
.long_name = NULL_IF_CONFIG_SMALL("Cirrus Logic AccuPak"), .long_name = NULL_IF_CONFIG_SMALL("Cirrus Logic AccuPak"),
}; };

17
libavcodec/cscd.c
View File

@ -256,15 +256,14 @@ static av_cold int decode_end(AVCodecContext *avctx) {
} }
AVCodec ff_cscd_decoder = { AVCodec ff_cscd_decoder = {
"camstudio", .name = "camstudio",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_CSCD, .id = CODEC_ID_CSCD,
sizeof(CamStudioContext), .priv_data_size = sizeof(CamStudioContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("CamStudio"), .long_name = NULL_IF_CONFIG_SMALL("CamStudio"),
}; };

36
libavcodec/cyuv.c
View File

@ -180,32 +180,28 @@ static av_cold int cyuv_decode_end(AVCodecContext *avctx)
#if CONFIG_AURA_DECODER #if CONFIG_AURA_DECODER
AVCodec ff_aura_decoder = { AVCodec ff_aura_decoder = {
"aura", .name = "aura",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_AURA, .id = CODEC_ID_AURA,
sizeof(CyuvDecodeContext), .priv_data_size = sizeof(CyuvDecodeContext),
cyuv_decode_init, .init = cyuv_decode_init,
NULL, .close = cyuv_decode_end,
cyuv_decode_end, .decode = cyuv_decode_frame,
cyuv_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
NULL,
.long_name = NULL_IF_CONFIG_SMALL("Auravision AURA"), .long_name = NULL_IF_CONFIG_SMALL("Auravision AURA"),
}; };
#endif #endif
#if CONFIG_CYUV_DECODER #if CONFIG_CYUV_DECODER
AVCodec ff_cyuv_decoder = { AVCodec ff_cyuv_decoder = {
"cyuv", .name = "cyuv",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_CYUV, .id = CODEC_ID_CYUV,
sizeof(CyuvDecodeContext), .priv_data_size = sizeof(CyuvDecodeContext),
cyuv_decode_init, .init = cyuv_decode_init,
NULL, .close = cyuv_decode_end,
cyuv_decode_end, .decode = cyuv_decode_frame,
cyuv_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
NULL,
.long_name = NULL_IF_CONFIG_SMALL("Creative YUV (CYUV)"), .long_name = NULL_IF_CONFIG_SMALL("Creative YUV (CYUV)"),
}; };
#endif #endif

17
libavcodec/dfa.c
View File

@ -384,14 +384,13 @@ static av_cold int dfa_decode_end(AVCodecContext *avctx)
} }
AVCodec ff_dfa_decoder = { AVCodec ff_dfa_decoder = {
"dfa", .name = "dfa",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_DFA, .id = CODEC_ID_DFA,
sizeof(DfaContext), .priv_data_size = sizeof(DfaContext),
dfa_decode_init, .init = dfa_decode_init,
NULL, .close = dfa_decode_end,
dfa_decode_end, .decode = dfa_decode_frame,
dfa_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Chronomaster DFA"), .long_name = NULL_IF_CONFIG_SMALL("Chronomaster DFA"),
}; };

17
libavcodec/dnxhddec.c
View File

@ -399,14 +399,13 @@ static av_cold int dnxhd_decode_close(AVCodecContext *avctx)
} }
AVCodec ff_dnxhd_decoder = { AVCodec ff_dnxhd_decoder = {
"dnxhd", .name = "dnxhd",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_DNXHD, .id = CODEC_ID_DNXHD,
sizeof(DNXHDContext), .priv_data_size = sizeof(DNXHDContext),
dnxhd_decode_init, .init = dnxhd_decode_init,
NULL, .close = dnxhd_decode_close,
dnxhd_decode_close, .decode = dnxhd_decode_frame,
dnxhd_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("VC3/DNxHD"), .long_name = NULL_IF_CONFIG_SMALL("VC3/DNxHD"),
}; };

14
libavcodec/dnxhdenc.c
View File

@ -993,13 +993,13 @@ static int dnxhd_encode_end(AVCodecContext *avctx)
} }
AVCodec ff_dnxhd_encoder = { AVCodec ff_dnxhd_encoder = {
"dnxhd", .name = "dnxhd",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_DNXHD, .id = CODEC_ID_DNXHD,
sizeof(DNXHDEncContext), .priv_data_size = sizeof(DNXHDEncContext),
dnxhd_encode_init, .init = dnxhd_encode_init,
dnxhd_encode_picture, .encode = dnxhd_encode_picture,
dnxhd_encode_end, .close = dnxhd_encode_end,
.capabilities = CODEC_CAP_SLICE_THREADS, .capabilities = CODEC_CAP_SLICE_THREADS,
.pix_fmts = (const enum PixelFormat[]){PIX_FMT_YUV422P, PIX_FMT_YUV422P10, PIX_FMT_NONE}, .pix_fmts = (const enum PixelFormat[]){PIX_FMT_YUV422P, PIX_FMT_YUV422P10, PIX_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("VC3/DNxHD"), .long_name = NULL_IF_CONFIG_SMALL("VC3/DNxHD"),

17
libavcodec/dpx.c
View File

@ -234,15 +234,12 @@ static av_cold int decode_end(AVCodecContext *avctx)
} }
AVCodec ff_dpx_decoder = { AVCodec ff_dpx_decoder = {
"dpx", .name = "dpx",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_DPX, .id = CODEC_ID_DPX,
sizeof(DPXContext), .priv_data_size = sizeof(DPXContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame,
0,
NULL,
.long_name = NULL_IF_CONFIG_SMALL("DPX image"), .long_name = NULL_IF_CONFIG_SMALL("DPX image"),
}; };

31
libavcodec/dsicinav.c
View File

@ -345,26 +345,23 @@ static int cinaudio_decode_frame(AVCodecContext *avctx,
AVCodec ff_dsicinvideo_decoder = { AVCodec ff_dsicinvideo_decoder = {
"dsicinvideo", .name = "dsicinvideo",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_DSICINVIDEO, .id = CODEC_ID_DSICINVIDEO,
sizeof(CinVideoContext), .priv_data_size = sizeof(CinVideoContext),
cinvideo_decode_init, .init = cinvideo_decode_init,
NULL, .close = cinvideo_decode_end,
cinvideo_decode_end, .decode = cinvideo_decode_frame,
cinvideo_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Delphine Software International CIN video"), .long_name = NULL_IF_CONFIG_SMALL("Delphine Software International CIN video"),
}; };
AVCodec ff_dsicinaudio_decoder = { AVCodec ff_dsicinaudio_decoder = {
"dsicinaudio", .name = "dsicinaudio",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_DSICINAUDIO, .id = CODEC_ID_DSICINAUDIO,
sizeof(CinAudioContext), .priv_data_size = sizeof(CinAudioContext),
cinaudio_decode_init, .init = cinaudio_decode_init,
NULL, .decode = cinaudio_decode_frame,
NULL,
cinaudio_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("Delphine Software International CIN audio"), .long_name = NULL_IF_CONFIG_SMALL("Delphine Software International CIN audio"),
}; };

30
libavcodec/dv.c
View File

@ -1280,12 +1280,12 @@ static int dvvideo_close(AVCodecContext *c)
#if CONFIG_DVVIDEO_ENCODER #if CONFIG_DVVIDEO_ENCODER
AVCodec ff_dvvideo_encoder = { AVCodec ff_dvvideo_encoder = {
"dvvideo", .name = "dvvideo",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_DVVIDEO, .id = CODEC_ID_DVVIDEO,
sizeof(DVVideoContext), .priv_data_size = sizeof(DVVideoContext),
dvvideo_init_encoder, .init = dvvideo_init_encoder,
dvvideo_encode_frame, .encode = dvvideo_encode_frame,
.capabilities = CODEC_CAP_SLICE_THREADS, .capabilities = CODEC_CAP_SLICE_THREADS,
.pix_fmts = (const enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE}, .pix_fmts = (const enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"), .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
@ -1294,16 +1294,14 @@ AVCodec ff_dvvideo_encoder = {
#if CONFIG_DVVIDEO_DECODER #if CONFIG_DVVIDEO_DECODER
AVCodec ff_dvvideo_decoder = { AVCodec ff_dvvideo_decoder = {
"dvvideo", .name = "dvvideo",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_DVVIDEO, .id = CODEC_ID_DVVIDEO,
sizeof(DVVideoContext), .priv_data_size = sizeof(DVVideoContext),
dvvideo_init, .init = dvvideo_init,
NULL, .close = dvvideo_close,
dvvideo_close, .decode = dvvideo_decode_frame,
dvvideo_decode_frame, .capabilities = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
NULL,
.max_lowres = 3, .max_lowres = 3,
.long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"), .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
}; };

11
libavcodec/dvbsub.c
View File

@ -403,11 +403,10 @@ static int dvbsub_encode(AVCodecContext *avctx,
} }
AVCodec ff_dvbsub_encoder = { AVCodec ff_dvbsub_encoder = {
"dvbsub", .name = "dvbsub",
AVMEDIA_TYPE_SUBTITLE, .type = AVMEDIA_TYPE_SUBTITLE,
CODEC_ID_DVB_SUBTITLE, .id = CODEC_ID_DVB_SUBTITLE,
sizeof(DVBSubtitleContext), .priv_data_size = sizeof(DVBSubtitleContext),
NULL, .encode = dvbsub_encode,
dvbsub_encode,
.long_name = NULL_IF_CONFIG_SMALL("DVB subtitles"), .long_name = NULL_IF_CONFIG_SMALL("DVB subtitles"),
}; };

15
libavcodec/dvbsubdec.c
View File

@ -1482,13 +1482,12 @@ static int dvbsub_decode(AVCodecContext *avctx,
AVCodec ff_dvbsub_decoder = { AVCodec ff_dvbsub_decoder = {
"dvbsub", .name = "dvbsub",
AVMEDIA_TYPE_SUBTITLE, .type = AVMEDIA_TYPE_SUBTITLE,
CODEC_ID_DVB_SUBTITLE, .id = CODEC_ID_DVB_SUBTITLE,
sizeof(DVBSubContext), .priv_data_size = sizeof(DVBSubContext),
dvbsub_init_decoder, .init = dvbsub_init_decoder,
NULL, .close = dvbsub_close_decoder,
dvbsub_close_decoder, .decode = dvbsub_decode,
dvbsub_decode,
.long_name = NULL_IF_CONFIG_SMALL("DVB subtitles"), .long_name = NULL_IF_CONFIG_SMALL("DVB subtitles"),
}; };

12
libavcodec/dvdsubdec.c
View File

@ -494,13 +494,9 @@ static int dvdsub_decode(AVCodecContext *avctx,
} }
AVCodec ff_dvdsub_decoder = { AVCodec ff_dvdsub_decoder = {
"dvdsub", .name = "dvdsub",
AVMEDIA_TYPE_SUBTITLE, .type = AVMEDIA_TYPE_SUBTITLE,
CODEC_ID_DVD_SUBTITLE, .id = CODEC_ID_DVD_SUBTITLE,
0, .decode = dvdsub_decode,
NULL,
NULL,
NULL,
dvdsub_decode,
.long_name = NULL_IF_CONFIG_SMALL("DVD subtitles"), .long_name = NULL_IF_CONFIG_SMALL("DVD subtitles"),
}; };

10
libavcodec/dvdsubenc.c
View File

@ -216,11 +216,9 @@ static int dvdsub_encode(AVCodecContext *avctx,
} }
AVCodec ff_dvdsub_encoder = { AVCodec ff_dvdsub_encoder = {
"dvdsub", .name = "dvdsub",
AVMEDIA_TYPE_SUBTITLE, .type = AVMEDIA_TYPE_SUBTITLE,
CODEC_ID_DVD_SUBTITLE, .id = CODEC_ID_DVD_SUBTITLE,
0, .encode = dvdsub_encode,
NULL,
dvdsub_encode,
.long_name = NULL_IF_CONFIG_SMALL("DVD subtitles"), .long_name = NULL_IF_CONFIG_SMALL("DVD subtitles"),
}; };

17
libavcodec/dxa.c
View File

@ -321,15 +321,14 @@ static av_cold int decode_end(AVCodecContext *avctx)
} }
AVCodec ff_dxa_decoder = { AVCodec ff_dxa_decoder = {
"dxa", .name = "dxa",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_DXA, .id = CODEC_ID_DXA,
sizeof(DxaDecContext), .priv_data_size = sizeof(DxaDecContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Feeble Files/ScummVM DXA"), .long_name = NULL_IF_CONFIG_SMALL("Feeble Files/ScummVM DXA"),
}; };

17
libavcodec/eacmv.c
View File

@ -210,14 +210,13 @@ static av_cold int cmv_decode_end(AVCodecContext *avctx){
} }
AVCodec ff_eacmv_decoder = { AVCodec ff_eacmv_decoder = {
"eacmv", .name = "eacmv",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_CMV, .id = CODEC_ID_CMV,
sizeof(CmvContext), .priv_data_size = sizeof(CmvContext),
cmv_decode_init, .init = cmv_decode_init,
NULL, .close = cmv_decode_end,
cmv_decode_end, .decode = cmv_decode_frame,
cmv_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Electronic Arts CMV video"), .long_name = NULL_IF_CONFIG_SMALL("Electronic Arts CMV video"),
}; };

17
libavcodec/eamad.c
View File

@ -307,14 +307,13 @@ static av_cold int decode_end(AVCodecContext *avctx)
} }
AVCodec ff_eamad_decoder = { AVCodec ff_eamad_decoder = {
"eamad", .name = "eamad",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_MAD, .id = CODEC_ID_MAD,
sizeof(MadContext), .priv_data_size = sizeof(MadContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Electronic Arts Madcow Video") .long_name = NULL_IF_CONFIG_SMALL("Electronic Arts Madcow Video")
}; };

17
libavcodec/eatgq.c
View File

@ -244,14 +244,13 @@ static av_cold int tgq_decode_end(AVCodecContext *avctx){
} }
AVCodec ff_eatgq_decoder = { AVCodec ff_eatgq_decoder = {
"eatgq", .name = "eatgq",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_TGQ, .id = CODEC_ID_TGQ,
sizeof(TgqContext), .priv_data_size = sizeof(TgqContext),
tgq_decode_init, .init = tgq_decode_init,
NULL, .close = tgq_decode_end,
tgq_decode_end, .decode = tgq_decode_frame,
tgq_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Electronic Arts TGQ video"), .long_name = NULL_IF_CONFIG_SMALL("Electronic Arts TGQ video"),
}; };

15
libavcodec/eatgv.c
View File

@ -337,13 +337,12 @@ static av_cold int tgv_decode_end(AVCodecContext *avctx)
} }
AVCodec ff_eatgv_decoder = { AVCodec ff_eatgv_decoder = {
"eatgv", .name = "eatgv",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_TGV, .id = CODEC_ID_TGV,
sizeof(TgvContext), .priv_data_size = sizeof(TgvContext),
tgv_decode_init, .init = tgv_decode_init,
NULL, .close = tgv_decode_end,
tgv_decode_end, .decode = tgv_decode_frame,
tgv_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("Electronic Arts TGV video"), .long_name = NULL_IF_CONFIG_SMALL("Electronic Arts TGV video"),
}; };

17
libavcodec/eatqi.c
View File

@ -153,14 +153,13 @@ static av_cold int tqi_decode_end(AVCodecContext *avctx)
} }
AVCodec ff_eatqi_decoder = { AVCodec ff_eatqi_decoder = {
"eatqi", .name = "eatqi",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_TQI, .id = CODEC_ID_TQI,
sizeof(TqiContext), .priv_data_size = sizeof(TqiContext),
tqi_decode_init, .init = tqi_decode_init,
NULL, .close = tqi_decode_end,
tqi_decode_end, .decode = tqi_decode_frame,
tqi_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Electronic Arts TQI Video"), .long_name = NULL_IF_CONFIG_SMALL("Electronic Arts TQI Video"),
}; };

17
libavcodec/escape124.c
View File

@ -366,15 +366,14 @@ static int escape124_decode_frame(AVCodecContext *avctx,
AVCodec ff_escape124_decoder = { AVCodec ff_escape124_decoder = {
"escape124", .name = "escape124",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_ESCAPE124, .id = CODEC_ID_ESCAPE124,
sizeof(Escape124Context), .priv_data_size = sizeof(Escape124Context),
escape124_decode_init, .init = escape124_decode_init,
NULL, .close = escape124_decode_close,
escape124_decode_close, .decode = escape124_decode_frame,
escape124_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Escape 124"), .long_name = NULL_IF_CONFIG_SMALL("Escape 124"),
}; };

32
libavcodec/ffv1.c
View File

@ -1764,28 +1764,26 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPac
} }
AVCodec ff_ffv1_decoder = { AVCodec ff_ffv1_decoder = {
"ffv1", .name = "ffv1",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_FFV1, .id = CODEC_ID_FFV1,
sizeof(FFV1Context), .priv_data_size = sizeof(FFV1Context),
decode_init, .init = decode_init,
NULL, .close = common_end,
common_end, .decode = decode_frame,
decode_frame, .capabilities = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ | CODEC_CAP_SLICE_THREADS,
CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ | CODEC_CAP_SLICE_THREADS,
NULL,
.long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"), .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
}; };
#if CONFIG_FFV1_ENCODER #if CONFIG_FFV1_ENCODER
AVCodec ff_ffv1_encoder = { AVCodec ff_ffv1_encoder = {
"ffv1", .name = "ffv1",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_FFV1, .id = CODEC_ID_FFV1,
sizeof(FFV1Context), .priv_data_size = sizeof(FFV1Context),
encode_init, .init = encode_init,
encode_frame, .encode = encode_frame,
common_end, .close = common_end,
.capabilities = CODEC_CAP_SLICE_THREADS, .capabilities = CODEC_CAP_SLICE_THREADS,
.pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV444P, PIX_FMT_YUV422P, PIX_FMT_YUV411P, PIX_FMT_YUV410P, PIX_FMT_RGB32, PIX_FMT_YUV420P16, PIX_FMT_YUV422P16, PIX_FMT_YUV444P16, PIX_FMT_YUV420P9, PIX_FMT_YUV420P10, PIX_FMT_YUV422P10, PIX_FMT_NONE}, .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV444P, PIX_FMT_YUV422P, PIX_FMT_YUV411P, PIX_FMT_YUV410P, PIX_FMT_RGB32, PIX_FMT_YUV420P16, PIX_FMT_YUV422P16, PIX_FMT_YUV444P16, PIX_FMT_YUV420P9, PIX_FMT_YUV420P10, PIX_FMT_YUV422P10, PIX_FMT_NONE},
.long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"), .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),

15
libavcodec/flacdec.c
View File

@ -652,13 +652,12 @@ static av_cold int flac_decode_close(AVCodecContext *avctx)
} }
AVCodec ff_flac_decoder = { AVCodec ff_flac_decoder = {
"flac", .name = "flac",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_FLAC, .id = CODEC_ID_FLAC,
sizeof(FLACContext), .priv_data_size = sizeof(FLACContext),
flac_decode_init, .init = flac_decode_init,
NULL, .close = flac_decode_close,
flac_decode_close, .decode = flac_decode_frame,
flac_decode_frame,
.long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"), .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
}; };

15
libavcodec/flacenc.c
View File

@ -1379,14 +1379,13 @@ static const AVClass flac_encoder_class = {
}; };
AVCodec ff_flac_encoder = { AVCodec ff_flac_encoder = {
"flac", .name = "flac",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_FLAC, .id = CODEC_ID_FLAC,
sizeof(FlacEncodeContext), .priv_data_size = sizeof(FlacEncodeContext),
flac_encode_init, .init = flac_encode_init,
flac_encode_frame, .encode = flac_encode_frame,
flac_encode_close, .close = flac_encode_close,
NULL,
.capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY | CODEC_CAP_LOSSLESS, .capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY | CODEC_CAP_LOSSLESS,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"), .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),

21
libavcodec/flicvideo.c
View File

@ -748,18 +748,13 @@ static av_cold int flic_decode_end(AVCodecContext *avctx)
} }
AVCodec ff_flic_decoder = { AVCodec ff_flic_decoder = {
"flic", .name = "flic",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_FLIC, .id = CODEC_ID_FLIC,
sizeof(FlicDecodeContext), .priv_data_size = sizeof(FlicDecodeContext),
flic_decode_init, .init = flic_decode_init,
NULL, .close = flic_decode_end,
flic_decode_end, .decode = flic_decode_frame,
flic_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
NULL,
NULL,
NULL,
NULL,
.long_name = NULL_IF_CONFIG_SMALL("Autodesk Animator Flic video"), .long_name = NULL_IF_CONFIG_SMALL("Autodesk Animator Flic video"),
}; };

17
libavcodec/flvdec.c
View File

@ -119,15 +119,14 @@ int ff_flv_decode_picture_header(MpegEncContext *s)
} }
AVCodec ff_flv_decoder = { AVCodec ff_flv_decoder = {
"flv", .name = "flv",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_FLV1, .id = CODEC_ID_FLV1,
sizeof(MpegEncContext), .priv_data_size = sizeof(MpegEncContext),
ff_h263_decode_init, .init = ff_h263_decode_init,
NULL, .close = ff_h263_decode_end,
ff_h263_decode_end, .decode = ff_h263_decode_frame,
ff_h263_decode_frame, .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
.max_lowres= 3, .max_lowres= 3,
.long_name= NULL_IF_CONFIG_SMALL("Flash Video (FLV) / Sorenson Spark / Sorenson H.263"), .long_name= NULL_IF_CONFIG_SMALL("Flash Video (FLV) / Sorenson Spark / Sorenson H.263"),
.pix_fmts= ff_pixfmt_list_420, .pix_fmts= ff_pixfmt_list_420,

14
libavcodec/flvenc.c
View File

@ -85,13 +85,13 @@ void ff_flv2_encode_ac_esc(PutBitContext *pb, int slevel, int level, int run, in
} }
AVCodec ff_flv_encoder = { AVCodec ff_flv_encoder = {
"flv", .name = "flv",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_FLV1, .id = CODEC_ID_FLV1,
sizeof(MpegEncContext), .priv_data_size = sizeof(MpegEncContext),
MPV_encode_init, .init = MPV_encode_init,
MPV_encode_picture, .encode = MPV_encode_picture,
MPV_encode_end, .close = MPV_encode_end,
.pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
.long_name= NULL_IF_CONFIG_SMALL("Flash Video (FLV) / Sorenson Spark / Sorenson H.263"), .long_name= NULL_IF_CONFIG_SMALL("Flash Video (FLV) / Sorenson Spark / Sorenson H.263"),
}; };

17
libavcodec/fraps.c
View File

@ -361,14 +361,13 @@ static av_cold int decode_end(AVCodecContext *avctx)
AVCodec ff_fraps_decoder = { AVCodec ff_fraps_decoder = {
"fraps", .name = "fraps",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_FRAPS, .id = CODEC_ID_FRAPS,
sizeof(FrapsContext), .priv_data_size = sizeof(FrapsContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Fraps"), .long_name = NULL_IF_CONFIG_SMALL("Fraps"),
}; };

16
libavcodec/frwu.c
View File

@ -110,14 +110,12 @@ static av_cold int decode_close(AVCodecContext *avctx)
} }
AVCodec ff_frwu_decoder = { AVCodec ff_frwu_decoder = {
"frwu", .name = "FRWU",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_FRWU, .id = CODEC_ID_FRWU,
0, .init = decode_init,
decode_init, .close = decode_close,
NULL, .decode = decode_frame,
decode_close, .capabilities = CODEC_CAP_DR1,
decode_frame,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Forward Uncompressed"), .long_name = NULL_IF_CONFIG_SMALL("Forward Uncompressed"),
}; };

30
libavcodec/g726.c
View File

@ -392,14 +392,13 @@ static int g726_decode_frame(AVCodecContext *avctx,
#if CONFIG_ADPCM_G726_ENCODER #if CONFIG_ADPCM_G726_ENCODER
AVCodec ff_adpcm_g726_encoder = { AVCodec ff_adpcm_g726_encoder = {
"g726", .name = "g726",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_ADPCM_G726, .id = CODEC_ID_ADPCM_G726,
sizeof(G726Context), .priv_data_size = sizeof(G726Context),
g726_init, .init = g726_init,
g726_encode_frame, .encode = g726_encode_frame,
g726_close, .close = g726_close,
NULL,
.capabilities = CODEC_CAP_SMALL_LAST_FRAME, .capabilities = CODEC_CAP_SMALL_LAST_FRAME,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("G.726 ADPCM"), .long_name = NULL_IF_CONFIG_SMALL("G.726 ADPCM"),
@ -407,13 +406,12 @@ AVCodec ff_adpcm_g726_encoder = {
#endif #endif
AVCodec ff_adpcm_g726_decoder = { AVCodec ff_adpcm_g726_decoder = {
"g726", .name = "g726",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_ADPCM_G726, .id = CODEC_ID_ADPCM_G726,
sizeof(G726Context), .priv_data_size = sizeof(G726Context),
g726_init, .init = g726_init,
NULL, .close = g726_close,
g726_close, .decode = g726_decode_frame,
g726_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("G.726 ADPCM"), .long_name = NULL_IF_CONFIG_SMALL("G.726 ADPCM"),
}; };

14
libavcodec/gif.c
View File

@ -167,13 +167,13 @@ static int gif_encode_close(AVCodecContext *avctx)
} }
AVCodec ff_gif_encoder = { AVCodec ff_gif_encoder = {
"gif", .name = "gif",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_GIF, .id = CODEC_ID_GIF,
sizeof(GIFContext), .priv_data_size = sizeof(GIFContext),
gif_encode_init, .init = gif_encode_init,
gif_encode_frame, .encode = gif_encode_frame,
gif_encode_close, .close = gif_encode_close,
.pix_fmts= (const enum PixelFormat[]){PIX_FMT_RGB8, PIX_FMT_BGR8, PIX_FMT_RGB4_BYTE, PIX_FMT_BGR4_BYTE, PIX_FMT_GRAY8, PIX_FMT_PAL8, PIX_FMT_NONE}, .pix_fmts= (const enum PixelFormat[]){PIX_FMT_RGB8, PIX_FMT_BGR8, PIX_FMT_RGB4_BYTE, PIX_FMT_BGR4_BYTE, PIX_FMT_GRAY8, PIX_FMT_PAL8, PIX_FMT_NONE},
.long_name= NULL_IF_CONFIG_SMALL("GIF (Graphics Interchange Format)"), .long_name= NULL_IF_CONFIG_SMALL("GIF (Graphics Interchange Format)"),
}; };

17
libavcodec/gifdec.c
View File

@ -326,14 +326,13 @@ static av_cold int gif_decode_close(AVCodecContext *avctx)
} }
AVCodec ff_gif_decoder = { AVCodec ff_gif_decoder = {
"gif", .name = "gif",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_GIF, .id = CODEC_ID_GIF,
sizeof(GifState), .priv_data_size = sizeof(GifState),
gif_decode_init, .init = gif_decode_init,
NULL, .close = gif_decode_close,
gif_decode_close, .decode = gif_decode_frame,
gif_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("GIF (Graphics Interchange Format)"), .long_name = NULL_IF_CONFIG_SMALL("GIF (Graphics Interchange Format)"),
}; };

28
libavcodec/gsmdec.c
View File

@ -85,25 +85,21 @@ static int gsm_decode_frame(AVCodecContext *avctx, void *data,
} }
AVCodec ff_gsm_decoder = { AVCodec ff_gsm_decoder = {
"gsm", .name = "gsm",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_GSM, .id = CODEC_ID_GSM,
sizeof(GSMContext), .priv_data_size = sizeof(GSMContext),
gsm_init, .init = gsm_init,
NULL, .decode = gsm_decode_frame,
NULL,
gsm_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("GSM"), .long_name = NULL_IF_CONFIG_SMALL("GSM"),
}; };
AVCodec ff_gsm_ms_decoder = { AVCodec ff_gsm_ms_decoder = {
"gsm_ms", .name = "gsm_ms",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_GSM_MS, .id = CODEC_ID_GSM_MS,
sizeof(GSMContext), .priv_data_size = sizeof(GSMContext),
gsm_init, .init = gsm_init,
NULL, .decode = gsm_decode_frame,
NULL,
gsm_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("GSM Microsoft variant"), .long_name = NULL_IF_CONFIG_SMALL("GSM Microsoft variant"),
}; };

17
libavcodec/h261dec.c
View File

@ -640,15 +640,14 @@ static av_cold int h261_decode_end(AVCodecContext *avctx)
} }
AVCodec ff_h261_decoder = { AVCodec ff_h261_decoder = {
"h261", .name = "h261",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_H261, .id = CODEC_ID_H261,
sizeof(H261Context), .priv_data_size = sizeof(H261Context),
h261_decode_init, .init = h261_decode_init,
NULL, .close = h261_decode_end,
h261_decode_end, .decode = h261_decode_frame,
h261_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.max_lowres = 3, .max_lowres = 3,
.long_name = NULL_IF_CONFIG_SMALL("H.261"), .long_name = NULL_IF_CONFIG_SMALL("H.261"),
}; };

14
libavcodec/h261enc.c
View File

@ -322,13 +322,13 @@ static void h261_encode_block(H261Context * h, DCTELEM * block, int n){
} }
AVCodec ff_h261_encoder = { AVCodec ff_h261_encoder = {
"h261", .name = "h261",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_H261, .id = CODEC_ID_H261,
sizeof(H261Context), .priv_data_size = sizeof(H261Context),
MPV_encode_init, .init = MPV_encode_init,
MPV_encode_picture, .encode = MPV_encode_picture,
MPV_encode_end, .close = MPV_encode_end,
.pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
.long_name= NULL_IF_CONFIG_SMALL("H.261"), .long_name= NULL_IF_CONFIG_SMALL("H.261"),
}; };

17
libavcodec/h263dec.c
View File

@ -734,15 +734,14 @@ av_log(avctx, AV_LOG_DEBUG, "%"PRId64"\n", rdtsc()-time);
} }
AVCodec ff_h263_decoder = { AVCodec ff_h263_decoder = {
"h263", .name = "h263",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_H263, .id = CODEC_ID_H263,
sizeof(MpegEncContext), .priv_data_size = sizeof(MpegEncContext),
ff_h263_decode_init, .init = ff_h263_decode_init,
NULL, .close = ff_h263_decode_end,
ff_h263_decode_end, .decode = ff_h263_decode_frame,
ff_h263_decode_frame, .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
.flush= ff_mpeg_flush, .flush= ff_mpeg_flush,
.max_lowres= 3, .max_lowres= 3,
.long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"), .long_name= NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),

36
libavcodec/h264.c
View File

@ -4006,16 +4006,15 @@ static const AVProfile profiles[] = {
}; };
AVCodec ff_h264_decoder = { AVCodec ff_h264_decoder = {
"h264", .name = "h264",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_H264, .id = CODEC_ID_H264,
sizeof(H264Context), .priv_data_size = sizeof(H264Context),
ff_h264_decode_init, .init = ff_h264_decode_init,
NULL, .close = ff_h264_decode_end,
ff_h264_decode_end, .decode = decode_frame,
decode_frame, .capabilities = /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_DELAY |
/*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
.flush= flush_dpb, .flush= flush_dpb,
.long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"), .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
.init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy), .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
@ -4025,15 +4024,14 @@ AVCodec ff_h264_decoder = {
#if CONFIG_H264_VDPAU_DECODER #if CONFIG_H264_VDPAU_DECODER
AVCodec ff_h264_vdpau_decoder = { AVCodec ff_h264_vdpau_decoder = {
"h264_vdpau", .name = "h264_vdpau",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_H264, .id = CODEC_ID_H264,
sizeof(H264Context), .priv_data_size = sizeof(H264Context),
ff_h264_decode_init, .init = ff_h264_decode_init,
NULL, .close = ff_h264_decode_end,
ff_h264_decode_end, .decode = decode_frame,
decode_frame, .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
.flush= flush_dpb, .flush= flush_dpb,
.long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (VDPAU acceleration)"), .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (VDPAU acceleration)"),
.pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_H264, PIX_FMT_NONE}, .pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_H264, PIX_FMT_NONE},

64
libavcodec/huffyuv.c
View File

@ -1436,16 +1436,14 @@ static av_cold int encode_end(AVCodecContext *avctx)
#if CONFIG_HUFFYUV_DECODER #if CONFIG_HUFFYUV_DECODER
AVCodec ff_huffyuv_decoder = { AVCodec ff_huffyuv_decoder = {
"huffyuv", .name = "huffyuv",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_HUFFYUV, .id = CODEC_ID_HUFFYUV,
sizeof(HYuvContext), .priv_data_size = sizeof(HYuvContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame, .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_FRAME_THREADS,
CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_FRAME_THREADS,
NULL,
.init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy), .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
.long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"), .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
}; };
@ -1453,16 +1451,14 @@ AVCodec ff_huffyuv_decoder = {
#if CONFIG_FFVHUFF_DECODER #if CONFIG_FFVHUFF_DECODER
AVCodec ff_ffvhuff_decoder = { AVCodec ff_ffvhuff_decoder = {
"ffvhuff", .name = "ffvhuff",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_FFVHUFF, .id = CODEC_ID_FFVHUFF,
sizeof(HYuvContext), .priv_data_size = sizeof(HYuvContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame, .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_FRAME_THREADS,
CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_FRAME_THREADS,
NULL,
.init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy), .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
.long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"), .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
}; };
@ -1470,13 +1466,13 @@ AVCodec ff_ffvhuff_decoder = {
#if CONFIG_HUFFYUV_ENCODER #if CONFIG_HUFFYUV_ENCODER
AVCodec ff_huffyuv_encoder = { AVCodec ff_huffyuv_encoder = {
"huffyuv", .name = "huffyuv",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_HUFFYUV, .id = CODEC_ID_HUFFYUV,
sizeof(HYuvContext), .priv_data_size = sizeof(HYuvContext),
encode_init, .init = encode_init,
encode_frame, .encode = encode_frame,
encode_end, .close = encode_end,
.pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV422P, PIX_FMT_RGB32, PIX_FMT_NONE}, .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV422P, PIX_FMT_RGB32, PIX_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"), .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
}; };
@ -1484,13 +1480,13 @@ AVCodec ff_huffyuv_encoder = {
#if CONFIG_FFVHUFF_ENCODER #if CONFIG_FFVHUFF_ENCODER
AVCodec ff_ffvhuff_encoder = { AVCodec ff_ffvhuff_encoder = {
"ffvhuff", .name = "ffvhuff",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_FFVHUFF, .id = CODEC_ID_FFVHUFF,
sizeof(HYuvContext), .priv_data_size = sizeof(HYuvContext),
encode_init, .init = encode_init,
encode_frame, .encode = encode_frame,
encode_end, .close = encode_end,
.pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_RGB32, PIX_FMT_NONE}, .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_RGB32, PIX_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"), .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
}; };

17
libavcodec/idcinvideo.c
View File

@ -255,15 +255,14 @@ static av_cold int idcin_decode_end(AVCodecContext *avctx)
} }
AVCodec ff_idcin_decoder = { AVCodec ff_idcin_decoder = {
"idcinvideo", .name = "idcinvideo",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_IDCIN, .id = CODEC_ID_IDCIN,
sizeof(IdcinContext), .priv_data_size = sizeof(IdcinContext),
idcin_decode_init, .init = idcin_decode_init,
NULL, .close = idcin_decode_end,
idcin_decode_end, .decode = idcin_decode_frame,
idcin_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("id Quake II CIN video"), .long_name = NULL_IF_CONFIG_SMALL("id Quake II CIN video"),
}; };

34
libavcodec/iff.c
View File

@ -576,27 +576,25 @@ static av_cold int decode_end(AVCodecContext *avctx)
} }
AVCodec ff_iff_ilbm_decoder = { AVCodec ff_iff_ilbm_decoder = {
"iff_ilbm", .name = "iff_ilbm",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_IFF_ILBM, .id = CODEC_ID_IFF_ILBM,
sizeof(IffContext), .priv_data_size = sizeof(IffContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame_ilbm,
decode_frame_ilbm, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("IFF ILBM"), .long_name = NULL_IF_CONFIG_SMALL("IFF ILBM"),
}; };
AVCodec ff_iff_byterun1_decoder = { AVCodec ff_iff_byterun1_decoder = {
"iff_byterun1", .name = "iff_byterun1",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_IFF_BYTERUN1, .id = CODEC_ID_IFF_BYTERUN1,
sizeof(IffContext), .priv_data_size = sizeof(IffContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame_byterun1,
decode_frame_byterun1, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("IFF ByteRun1"), .long_name = NULL_IF_CONFIG_SMALL("IFF ByteRun1"),
}; };

17
libavcodec/indeo2.c
View File

@ -223,14 +223,13 @@ static av_cold int ir2_decode_end(AVCodecContext *avctx){
} }
AVCodec ff_indeo2_decoder = { AVCodec ff_indeo2_decoder = {
"indeo2", .name = "indeo2",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_INDEO2, .id = CODEC_ID_INDEO2,
sizeof(Ir2Context), .priv_data_size = sizeof(Ir2Context),
ir2_decode_init, .init = ir2_decode_init,
NULL, .close = ir2_decode_end,
ir2_decode_end, .decode = ir2_decode_frame,
ir2_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Intel Indeo 2"), .long_name = NULL_IF_CONFIG_SMALL("Intel Indeo 2"),
}; };

18
libavcodec/indeo3.c
View File

@ -1147,15 +1147,13 @@ static av_cold int indeo3_decode_end(AVCodecContext *avctx)
} }
AVCodec ff_indeo3_decoder = { AVCodec ff_indeo3_decoder = {
"indeo3", .name = "indeo3",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_INDEO3, .id = CODEC_ID_INDEO3,
sizeof(Indeo3DecodeContext), .priv_data_size = sizeof(Indeo3DecodeContext),
indeo3_decode_init, .init = indeo3_decode_init,
NULL, .close = indeo3_decode_end,
indeo3_decode_end, .decode = indeo3_decode_frame,
indeo3_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
NULL,
.long_name = NULL_IF_CONFIG_SMALL("Intel Indeo 3"), .long_name = NULL_IF_CONFIG_SMALL("Intel Indeo 3"),
}; };

17
libavcodec/intelh263dec.c
View File

@ -125,15 +125,14 @@ int ff_intel_h263_decode_picture_header(MpegEncContext *s)
} }
AVCodec ff_h263i_decoder = { AVCodec ff_h263i_decoder = {
"h263i", .name = "h263i",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_H263I, .id = CODEC_ID_H263I,
sizeof(MpegEncContext), .priv_data_size = sizeof(MpegEncContext),
ff_h263_decode_init, .init = ff_h263_decode_init,
NULL, .close = ff_h263_decode_end,
ff_h263_decode_end, .decode = ff_h263_decode_frame,
ff_h263_decode_frame, .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Intel H.263"), .long_name = NULL_IF_CONFIG_SMALL("Intel H.263"),
.pix_fmts= ff_pixfmt_list_420, .pix_fmts= ff_pixfmt_list_420,
}; };

17
libavcodec/interplayvideo.c
View File

@ -1092,14 +1092,13 @@ static av_cold int ipvideo_decode_end(AVCodecContext *avctx)
} }
AVCodec ff_interplay_video_decoder = { AVCodec ff_interplay_video_decoder = {
"interplayvideo", .name = "interplayvideo",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_INTERPLAY_VIDEO, .id = CODEC_ID_INTERPLAY_VIDEO,
sizeof(IpvideoContext), .priv_data_size = sizeof(IpvideoContext),
ipvideo_decode_init, .init = ipvideo_decode_init,
NULL, .close = ipvideo_decode_end,
ipvideo_decode_end, .decode = ipvideo_decode_frame,
ipvideo_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Interplay MVE video"), .long_name = NULL_IF_CONFIG_SMALL("Interplay MVE video"),
}; };

17
libavcodec/jpeglsdec.c
View File

@ -364,14 +364,13 @@ int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transfor
AVCodec ff_jpegls_decoder = { AVCodec ff_jpegls_decoder = {
"jpegls", .name = "jpegls",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_JPEGLS, .id = CODEC_ID_JPEGLS,
sizeof(MJpegDecodeContext), .priv_data_size = sizeof(MJpegDecodeContext),
ff_mjpeg_decode_init, .init = ff_mjpeg_decode_init,
NULL, .close = ff_mjpeg_decode_end,
ff_mjpeg_decode_end, .decode = ff_mjpeg_decode_frame,
ff_mjpeg_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("JPEG-LS"), .long_name = NULL_IF_CONFIG_SMALL("JPEG-LS"),
}; };

15
libavcodec/kgv1dec.c
View File

@ -166,13 +166,12 @@ static av_cold int decode_end(AVCodecContext *avctx)
} }
AVCodec ff_kgv1_decoder = { AVCodec ff_kgv1_decoder = {
"kgv1", .name = "kgv1",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_KGV1, .id = CODEC_ID_KGV1,
sizeof(KgvContext), .priv_data_size = sizeof(KgvContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("Kega Game Video"), .long_name = NULL_IF_CONFIG_SMALL("Kega Game Video"),
}; };

17
libavcodec/kmvc.c
View File

@ -399,14 +399,13 @@ static av_cold int decode_end(AVCodecContext * avctx)
} }
AVCodec ff_kmvc_decoder = { AVCodec ff_kmvc_decoder = {
"kmvc", .name = "kmvc",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_KMVC, .id = CODEC_ID_KMVC,
sizeof(KmvcContext), .priv_data_size = sizeof(KmvcContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Karl Morton's video codec"), .long_name = NULL_IF_CONFIG_SMALL("Karl Morton's video codec"),
}; };

17
libavcodec/lagarith.c
View File

@ -509,14 +509,13 @@ static av_cold int lag_decode_end(AVCodecContext *avctx)
} }
AVCodec ff_lagarith_decoder = { AVCodec ff_lagarith_decoder = {
"lagarith", .name = "lagarith",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_LAGARITH, .id = CODEC_ID_LAGARITH,
sizeof(LagarithContext), .priv_data_size = sizeof(LagarithContext),
lag_decode_init, .init = lag_decode_init,
NULL, .close = lag_decode_end,
lag_decode_end, .decode = lag_decode_frame,
lag_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Lagarith lossless"), .long_name = NULL_IF_CONFIG_SMALL("Lagarith lossless"),
}; };

34
libavcodec/lcldec.c
View File

@ -611,30 +611,28 @@ static av_cold int decode_end(AVCodecContext *avctx)
#if CONFIG_MSZH_DECODER #if CONFIG_MSZH_DECODER
AVCodec ff_mszh_decoder = { AVCodec ff_mszh_decoder = {
"mszh", .name = "mszh",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_MSZH, .id = CODEC_ID_MSZH,
sizeof(LclDecContext), .priv_data_size = sizeof(LclDecContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("LCL (LossLess Codec Library) MSZH"), .long_name = NULL_IF_CONFIG_SMALL("LCL (LossLess Codec Library) MSZH"),
}; };
#endif #endif
#if CONFIG_ZLIB_DECODER #if CONFIG_ZLIB_DECODER
AVCodec ff_zlib_decoder = { AVCodec ff_zlib_decoder = {
"zlib", .name = "zlib",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_ZLIB, .id = CODEC_ID_ZLIB,
sizeof(LclDecContext), .priv_data_size = sizeof(LclDecContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("LCL (LossLess Codec Library) ZLIB"), .long_name = NULL_IF_CONFIG_SMALL("LCL (LossLess Codec Library) ZLIB"),
}; };
#endif #endif

14
libavcodec/lclenc.c
View File

@ -171,13 +171,13 @@ static av_cold int encode_end(AVCodecContext *avctx)
} }
AVCodec ff_zlib_encoder = { AVCodec ff_zlib_encoder = {
"zlib", .name = "zlib",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_ZLIB, .id = CODEC_ID_ZLIB,
sizeof(LclEncContext), .priv_data_size = sizeof(LclEncContext),
encode_init, .init = encode_init,
encode_frame, .encode = encode_frame,
encode_end, .close = encode_end,
.pix_fmts = (const enum PixelFormat[]) { PIX_FMT_BGR24, PIX_FMT_NONE }, .pix_fmts = (const enum PixelFormat[]) { PIX_FMT_BGR24, PIX_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("LCL (LossLess Codec Library) ZLIB"), .long_name = NULL_IF_CONFIG_SMALL("LCL (LossLess Codec Library) ZLIB"),
}; };

17
libavcodec/libdiracdec.c
View File

@ -195,15 +195,14 @@ static void libdirac_flush(AVCodecContext *avccontext)
AVCodec ff_libdirac_decoder = { AVCodec ff_libdirac_decoder = {
"libdirac", .name = "libdirac",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_DIRAC, .id = CODEC_ID_DIRAC,
sizeof(FfmpegDiracDecoderParams), .priv_data_size = sizeof(FfmpegDiracDecoderParams),
libdirac_decode_init, .init = libdirac_decode_init,
NULL, .close = libdirac_decode_close,
libdirac_decode_close, .decode = libdirac_decode_frame,
libdirac_decode_frame, .capabilities = CODEC_CAP_DELAY,
CODEC_CAP_DELAY,
.flush = libdirac_flush, .flush = libdirac_flush,
.long_name = NULL_IF_CONFIG_SMALL("libdirac Dirac 2.2"), .long_name = NULL_IF_CONFIG_SMALL("libdirac Dirac 2.2"),
}; };

14
libavcodec/libdiracenc.c
View File

@ -392,13 +392,13 @@ static av_cold int libdirac_encode_close(AVCodecContext *avccontext)
AVCodec ff_libdirac_encoder = { AVCodec ff_libdirac_encoder = {
"libdirac", .name = "libdirac",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_DIRAC, .id = CODEC_ID_DIRAC,
sizeof(FfmpegDiracEncoderParams), .priv_data_size = sizeof(FfmpegDiracEncoderParams),
libdirac_encode_init, .init = libdirac_encode_init,
libdirac_encode_frame, .encode = libdirac_encode_frame,
libdirac_encode_close, .close = libdirac_encode_close,
.capabilities = CODEC_CAP_DELAY, .capabilities = CODEC_CAP_DELAY,
.pix_fmts = (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_NONE}, .pix_fmts = (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("libdirac Dirac 2.2"), .long_name = NULL_IF_CONFIG_SMALL("libdirac Dirac 2.2"),

14
libavcodec/libfaac.c
View File

@ -165,13 +165,13 @@ static const AVProfile profiles[] = {
}; };
AVCodec ff_libfaac_encoder = { AVCodec ff_libfaac_encoder = {
"libfaac", .name = "libfaac",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_AAC, .id = CODEC_ID_AAC,
sizeof(FaacAudioContext), .priv_data_size = sizeof(FaacAudioContext),
Faac_encode_init, .init = Faac_encode_init,
Faac_encode_frame, .encode = Faac_encode_frame,
Faac_encode_close, .close = Faac_encode_close,
.capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY, .capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("libfaac AAC (Advanced Audio Codec)"), .long_name = NULL_IF_CONFIG_SMALL("libfaac AAC (Advanced Audio Codec)"),

54
libavcodec/libgsm.c
View File

@ -113,25 +113,23 @@ static int libgsm_encode_frame(AVCodecContext *avctx,
AVCodec ff_libgsm_encoder = { AVCodec ff_libgsm_encoder = {
"libgsm", .name = "libgsm",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_GSM, .id = CODEC_ID_GSM,
0, .init = libgsm_init,
libgsm_init, .encode = libgsm_encode_frame,
libgsm_encode_frame, .close = libgsm_close,
libgsm_close,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("libgsm GSM"), .long_name = NULL_IF_CONFIG_SMALL("libgsm GSM"),
}; };
AVCodec ff_libgsm_ms_encoder = { AVCodec ff_libgsm_ms_encoder = {
"libgsm_ms", .name = "libgsm_ms",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_GSM_MS, .id = CODEC_ID_GSM_MS,
0, .init = libgsm_init,
libgsm_init, .encode = libgsm_encode_frame,
libgsm_encode_frame, .close = libgsm_close,
libgsm_close,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("libgsm GSM Microsoft variant"), .long_name = NULL_IF_CONFIG_SMALL("libgsm GSM Microsoft variant"),
}; };
@ -157,25 +155,21 @@ static int libgsm_decode_frame(AVCodecContext *avctx,
} }
AVCodec ff_libgsm_decoder = { AVCodec ff_libgsm_decoder = {
"libgsm", .name = "libgsm",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_GSM, .id = CODEC_ID_GSM,
0, .init = libgsm_init,
libgsm_init, .close = libgsm_close,
NULL, .decode = libgsm_decode_frame,
libgsm_close,
libgsm_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("libgsm GSM"), .long_name = NULL_IF_CONFIG_SMALL("libgsm GSM"),
}; };
AVCodec ff_libgsm_ms_decoder = { AVCodec ff_libgsm_ms_decoder = {
"libgsm_ms", .name = "libgsm_ms",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_GSM_MS, .id = CODEC_ID_GSM_MS,
0, .init = libgsm_init,
libgsm_init, .close = libgsm_close,
NULL, .decode = libgsm_decode_frame,
libgsm_close,
libgsm_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("libgsm GSM Microsoft variant"), .long_name = NULL_IF_CONFIG_SMALL("libgsm GSM Microsoft variant"),
}; };

14
libavcodec/libmp3lame.c
View File

@ -269,13 +269,13 @@ static av_cold int MP3lame_encode_close(AVCodecContext *avctx)
AVCodec ff_libmp3lame_encoder = { AVCodec ff_libmp3lame_encoder = {
"libmp3lame", .name = "libmp3lame",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_MP3, .id = CODEC_ID_MP3,
sizeof(Mp3AudioContext), .priv_data_size = sizeof(Mp3AudioContext),
MP3lame_encode_init, .init = MP3lame_encode_init,
MP3lame_encode_frame, .encode = MP3lame_encode_frame,
MP3lame_encode_close, .close = MP3lame_encode_close,
.capabilities= CODEC_CAP_DELAY, .capabilities= CODEC_CAP_DELAY,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16, .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,
#if 2147483647 == INT_MAX #if 2147483647 == INT_MAX

45
libavcodec/libopencore-amr.c
View File

@ -158,14 +158,13 @@ static int amr_nb_decode_frame(AVCodecContext *avctx, void *data,
} }
AVCodec ff_libopencore_amrnb_decoder = { AVCodec ff_libopencore_amrnb_decoder = {
"libopencore_amrnb", .name = "libopencore_amrnb",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_AMR_NB, .id = CODEC_ID_AMR_NB,
sizeof(AMRContext), .priv_data_size = sizeof(AMRContext),
amr_nb_decode_init, .init = amr_nb_decode_init,
NULL, .close = amr_nb_decode_close,
amr_nb_decode_close, .decode = amr_nb_decode_frame,
amr_nb_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Narrow-Band"), .long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Narrow-Band"),
}; };
@ -230,14 +229,13 @@ static int amr_nb_encode_frame(AVCodecContext *avctx,
} }
AVCodec ff_libopencore_amrnb_encoder = { AVCodec ff_libopencore_amrnb_encoder = {
"libopencore_amrnb", .name = "libopencore_amrnb",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_AMR_NB, .id = CODEC_ID_AMR_NB,
sizeof(AMRContext), .priv_data_size = sizeof(AMRContext),
amr_nb_encode_init, .init = amr_nb_encode_init,
amr_nb_encode_frame, .encode = amr_nb_encode_frame,
amr_nb_encode_close, .close = amr_nb_encode_close,
NULL,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Narrow-Band"), .long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Narrow-Band"),
.priv_class = &class, .priv_class = &class,
@ -308,14 +306,13 @@ static int amr_wb_decode_close(AVCodecContext *avctx)
} }
AVCodec ff_libopencore_amrwb_decoder = { AVCodec ff_libopencore_amrwb_decoder = {
"libopencore_amrwb", .name = "libopencore_amrwb",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_AMR_WB, .id = CODEC_ID_AMR_WB,
sizeof(AMRWBContext), .priv_data_size = sizeof(AMRWBContext),
amr_wb_decode_init, .init = amr_wb_decode_init,
NULL, .close = amr_wb_decode_close,
amr_wb_decode_close, .decode = amr_wb_decode_frame,
amr_wb_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Wide-Band"), .long_name = NULL_IF_CONFIG_SMALL("OpenCORE Adaptive Multi-Rate (AMR) Wide-Band"),
}; };

17
libavcodec/libschroedingerdec.c
View File

@ -345,15 +345,14 @@ static void libschroedinger_flush(AVCodecContext *avccontext)
} }
AVCodec ff_libschroedinger_decoder = { AVCodec ff_libschroedinger_decoder = {
"libschroedinger", .name = "libschroedinger",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_DIRAC, .id = CODEC_ID_DIRAC,
sizeof(FfmpegSchroDecoderParams), .priv_data_size = sizeof(FfmpegSchroDecoderParams),
libschroedinger_decode_init, .init = libschroedinger_decode_init,
NULL, .close = libschroedinger_decode_close,
libschroedinger_decode_close, .decode = libschroedinger_decode_frame,
libschroedinger_decode_frame, .capabilities = CODEC_CAP_DELAY,
CODEC_CAP_DELAY,
.flush = libschroedinger_flush, .flush = libschroedinger_flush,
.long_name = NULL_IF_CONFIG_SMALL("libschroedinger Dirac 2.2"), .long_name = NULL_IF_CONFIG_SMALL("libschroedinger Dirac 2.2"),
}; };

14
libavcodec/libschroedingerenc.c
View File

@ -423,13 +423,13 @@ static int libschroedinger_encode_close(AVCodecContext *avccontext)
AVCodec ff_libschroedinger_encoder = { AVCodec ff_libschroedinger_encoder = {
"libschroedinger", .name = "libschroedinger",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_DIRAC, .id = CODEC_ID_DIRAC,
sizeof(FfmpegSchroEncoderParams), .priv_data_size = sizeof(FfmpegSchroEncoderParams),
libschroedinger_encode_init, .init = libschroedinger_encode_init,
libschroedinger_encode_frame, .encode = libschroedinger_encode_frame,
libschroedinger_encode_close, .close = libschroedinger_encode_close,
.capabilities = CODEC_CAP_DELAY, .capabilities = CODEC_CAP_DELAY,
.pix_fmts = (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_NONE}, .pix_fmts = (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("libschroedinger Dirac 2.2"), .long_name = NULL_IF_CONFIG_SMALL("libschroedinger Dirac 2.2"),

15
libavcodec/libspeexdec.c
View File

@ -139,13 +139,12 @@ static av_cold int libspeex_decode_close(AVCodecContext *avctx)
} }
AVCodec ff_libspeex_decoder = { AVCodec ff_libspeex_decoder = {
"libspeex", .name = "libspeex",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_SPEEX, .id = CODEC_ID_SPEEX,
sizeof(LibSpeexContext), .priv_data_size = sizeof(LibSpeexContext),
libspeex_decode_init, .init = libspeex_decode_init,
NULL, .close = libspeex_decode_close,
libspeex_decode_close, .decode = libspeex_decode_frame,
libspeex_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("libspeex Speex"), .long_name = NULL_IF_CONFIG_SMALL("libspeex Speex"),
}; };

15
libavcodec/libvo-aacenc.c
View File

@ -116,14 +116,13 @@ static int aac_encode_frame(AVCodecContext *avctx,
} }
AVCodec ff_libvo_aacenc_encoder = { AVCodec ff_libvo_aacenc_encoder = {
"libvo_aacenc", .name = "libvo_aacenc",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_AAC, .id = CODEC_ID_AAC,
sizeof(AACContext), .priv_data_size = sizeof(AACContext),
aac_encode_init, .init = aac_encode_init,
aac_encode_frame, .encode = aac_encode_frame,
aac_encode_close, .close = aac_encode_close,
NULL,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("Android VisualOn AAC"), .long_name = NULL_IF_CONFIG_SMALL("Android VisualOn AAC"),
}; };

15
libavcodec/libvo-amrwbenc.c
View File

@ -118,14 +118,13 @@ static int amr_wb_encode_frame(AVCodecContext *avctx,
} }
AVCodec ff_libvo_amrwbenc_encoder = { AVCodec ff_libvo_amrwbenc_encoder = {
"libvo_amrwbenc", .name = "libvo_amrwbenc",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_AMR_WB, .id = CODEC_ID_AMR_WB,
sizeof(AMRWBContext), .priv_data_size = sizeof(AMRWBContext),
amr_wb_encode_init, .init = amr_wb_encode_init,
amr_wb_encode_frame, .encode = amr_wb_encode_frame,
amr_wb_encode_close, .close = amr_wb_encode_close,
NULL,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("Android VisualOn Adaptive Multi-Rate " .long_name = NULL_IF_CONFIG_SMALL("Android VisualOn Adaptive Multi-Rate "
"(AMR) Wide-Band"), "(AMR) Wide-Band"),

16
libavcodec/libvpxdec.c
View File

@ -112,14 +112,12 @@ static av_cold int vp8_free(AVCodecContext *avctx)
} }
AVCodec ff_libvpx_decoder = { AVCodec ff_libvpx_decoder = {
"libvpx", .name = "libvpx",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_VP8, .id = CODEC_ID_VP8,
sizeof(VP8Context), .priv_data_size = sizeof(VP8Context),
vp8_init, .init = vp8_init,
NULL, /* encode */ .close = vp8_free,
vp8_free, .decode = vp8_decode,
vp8_decode,
0, /* capabilities */
.long_name = NULL_IF_CONFIG_SMALL("libvpx VP8"), .long_name = NULL_IF_CONFIG_SMALL("libvpx VP8"),
}; };

17
libavcodec/libvpxenc.c
View File

@ -546,15 +546,14 @@ static int vp8_encode(AVCodecContext *avctx, uint8_t *buf, int buf_size,
} }
AVCodec ff_libvpx_encoder = { AVCodec ff_libvpx_encoder = {
"libvpx", .name = "libvpx",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_VP8, .id = CODEC_ID_VP8,
sizeof(VP8Context), .priv_data_size = sizeof(VP8Context),
vp8_init, .init = vp8_init,
vp8_encode, .encode = vp8_encode,
vp8_free, .close = vp8_free,
NULL, .capabilities = CODEC_CAP_DELAY,
CODEC_CAP_DELAY,
.pix_fmts = (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, .pix_fmts = (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("libvpx VP8"), .long_name = NULL_IF_CONFIG_SMALL("libvpx VP8"),
.priv_class= &class, .priv_class= &class,

14
libavcodec/libxvidff.c
View File

@ -810,13 +810,13 @@ int xvid_ff_2pass(void *ref, int cmd, void *p1, void *p2) {
* Xvid codec definition for libavcodec. * Xvid codec definition for libavcodec.
*/ */
AVCodec ff_libxvid_encoder = { AVCodec ff_libxvid_encoder = {
"libxvid", .name = "libxvid",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG4, .id = CODEC_ID_MPEG4,
sizeof(struct xvid_context), .priv_data_size = sizeof(struct xvid_context),
xvid_encode_init, .init = xvid_encode_init,
xvid_encode_frame, .encode = xvid_encode_frame,
xvid_encode_close, .close = xvid_encode_close,
.pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE}, .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
.long_name= NULL_IF_CONFIG_SMALL("libxvidcore MPEG-4 part 2"), .long_name= NULL_IF_CONFIG_SMALL("libxvidcore MPEG-4 part 2"),
}; };

17
libavcodec/loco.c
View File

@ -288,14 +288,13 @@ static av_cold int decode_end(AVCodecContext *avctx){
} }
AVCodec ff_loco_decoder = { AVCodec ff_loco_decoder = {
"loco", .name = "loco",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_LOCO, .id = CODEC_ID_LOCO,
sizeof(LOCOContext), .priv_data_size = sizeof(LOCOContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("LOCO"), .long_name = NULL_IF_CONFIG_SMALL("LOCO"),
}; };

28
libavcodec/mace.c
View File

@ -280,26 +280,22 @@ static int mace_decode_frame(AVCodecContext *avctx,
} }
AVCodec ff_mace3_decoder = { AVCodec ff_mace3_decoder = {
"mace3", .name = "mace3",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_MACE3, .id = CODEC_ID_MACE3,
sizeof(MACEContext), .priv_data_size = sizeof(MACEContext),
mace_decode_init, .init = mace_decode_init,
NULL, .decode = mace_decode_frame,
NULL,
mace_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("MACE (Macintosh Audio Compression/Expansion) 3:1"), .long_name = NULL_IF_CONFIG_SMALL("MACE (Macintosh Audio Compression/Expansion) 3:1"),
}; };
AVCodec ff_mace6_decoder = { AVCodec ff_mace6_decoder = {
"mace6", .name = "mace6",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_MACE6, .id = CODEC_ID_MACE6,
sizeof(MACEContext), .priv_data_size = sizeof(MACEContext),
mace_decode_init, .init = mace_decode_init,
NULL, .decode = mace_decode_frame,
NULL,
mace_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("MACE (Macintosh Audio Compression/Expansion) 6:1"), .long_name = NULL_IF_CONFIG_SMALL("MACE (Macintosh Audio Compression/Expansion) 6:1"),
}; };

17
libavcodec/mdec.c
View File

@ -267,15 +267,14 @@ static av_cold int decode_end(AVCodecContext *avctx){
} }
AVCodec ff_mdec_decoder = { AVCodec ff_mdec_decoder = {
"mdec", .name = "mdec",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_MDEC, .id = CODEC_ID_MDEC,
sizeof(MDECContext), .priv_data_size = sizeof(MDECContext),
decode_init, .init = decode_init,
NULL, .close = decode_end,
decode_end, .decode = decode_frame,
decode_frame, .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
.long_name= NULL_IF_CONFIG_SMALL("Sony PlayStation MDEC (Motion DECoder)"), .long_name= NULL_IF_CONFIG_SMALL("Sony PlayStation MDEC (Motion DECoder)"),
.init_thread_copy= ONLY_IF_THREADS_ENABLED(decode_init_thread_copy) .init_thread_copy= ONLY_IF_THREADS_ENABLED(decode_init_thread_copy)
}; };

17
libavcodec/mimic.c
View File

@ -416,15 +416,14 @@ static av_cold int mimic_decode_end(AVCodecContext *avctx)
} }
AVCodec ff_mimic_decoder = { AVCodec ff_mimic_decoder = {
"mimic", .name = "mimic",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_MIMIC, .id = CODEC_ID_MIMIC,
sizeof(MimicContext), .priv_data_size = sizeof(MimicContext),
mimic_decode_init, .init = mimic_decode_init,
NULL, .close = mimic_decode_end,
mimic_decode_end, .decode = mimic_decode_frame,
mimic_decode_frame, .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
.long_name = NULL_IF_CONFIG_SMALL("Mimic"), .long_name = NULL_IF_CONFIG_SMALL("Mimic"),
.update_thread_context = ONLY_IF_THREADS_ENABLED(mimic_decode_update_thread_context) .update_thread_context = ONLY_IF_THREADS_ENABLED(mimic_decode_update_thread_context)
}; };

18
libavcodec/mjpegbdec.c
View File

@ -146,16 +146,14 @@ read_header:
} }
AVCodec ff_mjpegb_decoder = { AVCodec ff_mjpegb_decoder = {
"mjpegb", .name = "mjpegb",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_MJPEGB, .id = CODEC_ID_MJPEGB,
sizeof(MJpegDecodeContext), .priv_data_size = sizeof(MJpegDecodeContext),
ff_mjpeg_decode_init, .init = ff_mjpeg_decode_init,
NULL, .close = ff_mjpeg_decode_end,
ff_mjpeg_decode_end, .decode = mjpegb_decode_frame,
mjpegb_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
NULL,
.max_lowres = 3, .max_lowres = 3,
.long_name = NULL_IF_CONFIG_SMALL("Apple MJPEG-B"), .long_name = NULL_IF_CONFIG_SMALL("Apple MJPEG-B"),
}; };

36
libavcodec/mjpegdec.c
View File

@ -1578,31 +1578,27 @@ av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
} }
AVCodec ff_mjpeg_decoder = { AVCodec ff_mjpeg_decoder = {
"mjpeg", .name = "mjpeg",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_MJPEG, .id = CODEC_ID_MJPEG,
sizeof(MJpegDecodeContext), .priv_data_size = sizeof(MJpegDecodeContext),
ff_mjpeg_decode_init, .init = ff_mjpeg_decode_init,
NULL, .close = ff_mjpeg_decode_end,
ff_mjpeg_decode_end, .decode = ff_mjpeg_decode_frame,
ff_mjpeg_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
NULL,
.max_lowres = 3, .max_lowres = 3,
.long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"), .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
}; };
AVCodec ff_thp_decoder = { AVCodec ff_thp_decoder = {
"thp", .name = "thp",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_THP, .id = CODEC_ID_THP,
sizeof(MJpegDecodeContext), .priv_data_size = sizeof(MJpegDecodeContext),
ff_mjpeg_decode_init, .init = ff_mjpeg_decode_init,
NULL, .close = ff_mjpeg_decode_end,
ff_mjpeg_decode_end, .decode = ff_mjpeg_decode_frame,
ff_mjpeg_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
NULL,
.max_lowres = 3, .max_lowres = 3,
.long_name = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"), .long_name = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
}; };

14
libavcodec/mjpegenc.c
View File

@ -446,13 +446,13 @@ void ff_mjpeg_encode_mb(MpegEncContext *s, DCTELEM block[6][64])
} }
AVCodec ff_mjpeg_encoder = { AVCodec ff_mjpeg_encoder = {
"mjpeg", .name = "mjpeg",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_MJPEG, .id = CODEC_ID_MJPEG,
sizeof(MpegEncContext), .priv_data_size = sizeof(MpegEncContext),
MPV_encode_init, .init = MPV_encode_init,
MPV_encode_picture, .encode = MPV_encode_picture,
MPV_encode_end, .close = MPV_encode_end,
.pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_NONE}, .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_NONE},
.long_name= NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"), .long_name= NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
}; };

28
libavcodec/mlpdec.c
View File

@ -1179,27 +1179,23 @@ error:
} }
AVCodec ff_mlp_decoder = { AVCodec ff_mlp_decoder = {
"mlp", .name = "mlp",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_MLP, .id = CODEC_ID_MLP,
sizeof(MLPDecodeContext), .priv_data_size = sizeof(MLPDecodeContext),
mlp_decode_init, .init = mlp_decode_init,
NULL, .decode = read_access_unit,
NULL,
read_access_unit,
.long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"), .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
}; };
#if CONFIG_TRUEHD_DECODER #if CONFIG_TRUEHD_DECODER
AVCodec ff_truehd_decoder = { AVCodec ff_truehd_decoder = {
"truehd", .name = "truehd",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_TRUEHD, .id = CODEC_ID_TRUEHD,
sizeof(MLPDecodeContext), .priv_data_size = sizeof(MLPDecodeContext),
mlp_decode_init, .init = mlp_decode_init,
NULL, .decode = read_access_unit,
NULL,
read_access_unit,
.long_name = NULL_IF_CONFIG_SMALL("TrueHD"), .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
}; };
#endif /* CONFIG_TRUEHD_DECODER */ #endif /* CONFIG_TRUEHD_DECODER */

17
libavcodec/mmvideo.c
View File

@ -215,14 +215,13 @@ static av_cold int mm_decode_end(AVCodecContext *avctx)
} }
AVCodec ff_mmvideo_decoder = { AVCodec ff_mmvideo_decoder = {
"mmvideo", .name = "mmvideo",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_MMVIDEO, .id = CODEC_ID_MMVIDEO,
sizeof(MmContext), .priv_data_size = sizeof(MmContext),
mm_decode_init, .init = mm_decode_init,
NULL, .close = mm_decode_end,
mm_decode_end, .decode = mm_decode_frame,
mm_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("American Laser Games MM Video"), .long_name = NULL_IF_CONFIG_SMALL("American Laser Games MM Video"),
}; };

17
libavcodec/motionpixels.c
View File

@ -304,14 +304,13 @@ static av_cold int mp_decode_end(AVCodecContext *avctx)
} }
AVCodec ff_motionpixels_decoder = { AVCodec ff_motionpixels_decoder = {
"motionpixels", .name = "motionpixels",
AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
CODEC_ID_MOTIONPIXELS, .id = CODEC_ID_MOTIONPIXELS,
sizeof(MotionPixelsContext), .priv_data_size = sizeof(MotionPixelsContext),
mp_decode_init, .init = mp_decode_init,
NULL, .close = mp_decode_end,
mp_decode_end, .decode = mp_decode_frame,
mp_decode_frame, .capabilities = CODEC_CAP_DR1,
CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Motion Pixels video"), .long_name = NULL_IF_CONFIG_SMALL("Motion Pixels video"),
}; };

14
libavcodec/mpc7.c
View File

@ -291,14 +291,12 @@ static void mpc7_decode_flush(AVCodecContext *avctx)
} }
AVCodec ff_mpc7_decoder = { AVCodec ff_mpc7_decoder = {
"mpc7", .name = "mpc7",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_MUSEPACK7, .id = CODEC_ID_MUSEPACK7,
sizeof(MPCContext), .priv_data_size = sizeof(MPCContext),
mpc7_decode_init, .init = mpc7_decode_init,
NULL, .decode = mpc7_decode_frame,
NULL,
mpc7_decode_frame,
.flush = mpc7_decode_flush, .flush = mpc7_decode_flush,
.long_name = NULL_IF_CONFIG_SMALL("Musepack SV7"), .long_name = NULL_IF_CONFIG_SMALL("Musepack SV7"),
}; };

14
libavcodec/mpc8.c
View File

@ -406,13 +406,11 @@ static int mpc8_decode_frame(AVCodecContext * avctx,
} }
AVCodec ff_mpc8_decoder = { AVCodec ff_mpc8_decoder = {
"mpc8", .name = "mpc8",
AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
CODEC_ID_MUSEPACK8, .id = CODEC_ID_MUSEPACK8,
sizeof(MPCContext), .priv_data_size = sizeof(MPCContext),
mpc8_decode_init, .init = mpc8_decode_init,
NULL, .decode = mpc8_decode_frame,
NULL,
mpc8_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("Musepack SV8"), .long_name = NULL_IF_CONFIG_SMALL("Musepack SV8"),
}; };

Some files were not shown because too many files have changed in this diff Show More