generic-library/ffmpeg
1
0
Fork 0
Code Issues Pull Requests Releases Wiki 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 = {
"4xm",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_4XM,
sizeof(FourXContext),
decode_init,
NULL,
decode_end,
decode_frame,
CODEC_CAP_DR1,
.name = "4xm",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_4XM,
.priv_data_size = sizeof(FourXContext),
.init = decode_init,
.close = decode_end,
.decode = decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"8bps",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_8BPS,
sizeof(EightBpsContext),
decode_init,
NULL,
decode_end,
decode_frame,
CODEC_CAP_DR1,
.name = "8bps",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_8BPS,
.priv_data_size = sizeof(EightBpsContext),
.init = decode_init,
.close = decode_end,
.decode = decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"aac",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_AAC,
sizeof(AACContext),
aac_decode_init,
NULL,
aac_decode_close,
aac_decode_frame,
.name = "aac",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_AAC,
.priv_data_size = sizeof(AACContext),
.init = aac_decode_init,
.close = aac_decode_close,
.decode = aac_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("Advanced Audio Coding"),
.sample_fmts = (const enum AVSampleFormat[]) {
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 = {
"aac",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_AAC,
sizeof(AACEncContext),
aac_encode_init,
aac_encode_frame,
aac_encode_end,
.name = "aac",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_AAC,
.priv_data_size = sizeof(AACEncContext),
.init = aac_encode_init,
.encode = aac_encode_frame,
.close = aac_encode_end,
.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},
.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 = {
"aasc",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_AASC,
sizeof(AascContext),
aasc_decode_init,
NULL,
aasc_decode_end,
aasc_decode_frame,
CODEC_CAP_DR1,
.name = "aasc",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_AASC,
.priv_data_size = sizeof(AascContext),
.init = aasc_decode_init,
.close = aasc_decode_end,
.decode = aasc_decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"ac3_fixed",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_AC3,
sizeof(AC3EncodeContext),
ac3_fixed_encode_init,
ff_ac3_fixed_encode_frame,
ff_ac3_encode_close,
NULL,
.name = "ac3_fixed",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_AC3,
.priv_data_size = sizeof(AC3EncodeContext),
.init = ac3_fixed_encode_init,
.encode = ff_ac3_fixed_encode_frame,
.close = ff_ac3_encode_close,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
.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
AVCodec ff_ac3_float_encoder = {
"ac3_float",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_AC3,
sizeof(AC3EncodeContext),
ff_ac3_encode_init,
ff_ac3_float_encode_frame,
ff_ac3_encode_close,
NULL,
.name = "ac3 float",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_AC3,
.priv_data_size = sizeof(AC3EncodeContext),
.init = ff_ac3_encode_init,
.encode = ff_ac3_float_encode_frame,
.close = ff_ac3_encode_close,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_FLT,AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
.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 = {
"adpcm_adx",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_ADPCM_ADX,
sizeof(ADXContext),
adx_decode_init,
NULL,
NULL,
adx_decode_frame,
.name = "adpcm_adx",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_ADPCM_ADX,
.priv_data_size = sizeof(ADXContext),
.init = adx_decode_init,
.decode = adx_decode_frame,
.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 = {
"adpcm_adx",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_ADPCM_ADX,
sizeof(ADXContext),
adx_encode_init,
adx_encode_frame,
adx_encode_close,
NULL,
.name = "adpcm_adx",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_ADPCM_ADX,
.priv_data_size = sizeof(ADXContext),
.init = adx_encode_init,
.encode = adx_encode_frame,
.close = adx_encode_close,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.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 = {
"alac",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_ALAC,
sizeof(ALACContext),
alac_decode_init,
NULL,
alac_decode_close,
alac_decode_frame,
.name = "alac",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_ALAC,
.priv_data_size = sizeof(ALACContext),
.init = alac_decode_init,
.close = alac_decode_close,
.decode = alac_decode_frame,
.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 = {
"alac",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_ALAC,
sizeof(AlacEncodeContext),
alac_encode_init,
alac_encode_frame,
alac_encode_close,
.name = "alac",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_ALAC,
.priv_data_size = sizeof(AlacEncodeContext),
.init = alac_encode_init,
.encode = alac_encode_frame,
.close = alac_encode_close,
.capabilities = CODEC_CAP_SMALL_LAST_FRAME,
.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE},
.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 = {
"als",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_MP4ALS,
sizeof(ALSDecContext),
decode_init,
NULL,
decode_end,
decode_frame,
.name = "als",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_MP4ALS,
.priv_data_size = sizeof(ALSDecContext),
.init = decode_init,
.close = decode_end,
.decode = decode_frame,
.flush = flush,
.capabilities = CODEC_CAP_SUBFRAMES,
.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 = {
"anm",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_ANM,
sizeof(AnmContext),
decode_init,
NULL,
decode_end,
decode_frame,
CODEC_CAP_DR1,
.name = "anm",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_ANM,
.priv_data_size = sizeof(AnmContext),
.init = decode_init,
.close = decode_end,
.decode = decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"ape",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_APE,
sizeof(APEContext),
ape_decode_init,
NULL,
ape_decode_close,
ape_decode_frame,
.name = "ape",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_APE,
.priv_data_size = sizeof(APEContext),
.init = ape_decode_init,
.close = ape_decode_close,
.decode = ape_decode_frame,
.capabilities = CODEC_CAP_SUBFRAMES,
.flush = ape_flush,
.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 = {
"asv1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_ASV1,
sizeof(ASV1Context),
decode_init,
NULL,
decode_end,
decode_frame,
CODEC_CAP_DR1,
.name = "asv1",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_ASV1,
.priv_data_size = sizeof(ASV1Context),
.init = decode_init,
.close = decode_end,
.decode = decode_frame,
.capabilities = CODEC_CAP_DR1,
.long_name= NULL_IF_CONFIG_SMALL("ASUS V1"),
};
AVCodec ff_asv2_decoder = {
"asv2",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_ASV2,
sizeof(ASV1Context),
decode_init,
NULL,
decode_end,
decode_frame,
CODEC_CAP_DR1,
.name = "asv2",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_ASV2,
.priv_data_size = sizeof(ASV1Context),
.init = decode_init,
.close = decode_end,
.decode = decode_frame,
.capabilities = CODEC_CAP_DR1,
.long_name= NULL_IF_CONFIG_SMALL("ASUS V2"),
};
#if CONFIG_ASV1_ENCODER
AVCodec ff_asv1_encoder = {
"asv1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_ASV1,
sizeof(ASV1Context),
encode_init,
encode_frame,
.name = "asv1",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_ASV1,
.priv_data_size = sizeof(ASV1Context),
.init = encode_init,
.encode = encode_frame,
//encode_end,
.pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
.long_name= NULL_IF_CONFIG_SMALL("ASUS V1"),
@ -644,12 +642,12 @@ AVCodec ff_asv1_encoder = {
#if CONFIG_ASV2_ENCODER
AVCodec ff_asv2_encoder = {
"asv2",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_ASV2,
sizeof(ASV1Context),
encode_init,
encode_frame,
.name = "asv2",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_ASV2,
.priv_data_size = sizeof(ASV1Context),
.init = encode_init,
.encode = encode_frame,
//encode_end,
.pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
.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 = {
"aura2",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_AURA2,
sizeof(AuraDecodeContext),
aura_decode_init,
NULL,
aura_decode_end,
aura_decode_frame,
CODEC_CAP_DR1,
NULL,
.name = "aura2",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_AURA2,
.priv_data_size = sizeof(AuraDecodeContext),
.init = aura_decode_init,
.close = aura_decode_end,
.decode = aura_decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"avs",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_AVS,
sizeof(AvsContext),
avs_decode_init,
NULL,
NULL,
avs_decode_frame,
CODEC_CAP_DR1,
.name = "avs",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_AVS,
.priv_data_size = sizeof(AvsContext),
.init = avs_decode_init,
.decode = avs_decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"binkvideo",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_BINKVIDEO,
sizeof(BinkContext),
decode_init,
NULL,
decode_end,
decode_frame,
.name = "binkvideo",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_BINKVIDEO,
.priv_data_size = sizeof(BinkContext),
.init = decode_init,
.close = decode_end,
.decode = decode_frame,
.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 = {
"binkaudio_rdft",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_BINKAUDIO_RDFT,
sizeof(BinkAudioContext),
decode_init,
NULL,
decode_end,
decode_frame,
.name = "binkaudio_rdft",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_BINKAUDIO_RDFT,
.priv_data_size = sizeof(BinkAudioContext),
.init = decode_init,
.close = decode_end,
.decode = decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("Bink Audio (RDFT)")
};
AVCodec ff_binkaudio_dct_decoder = {
"binkaudio_dct",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_BINKAUDIO_DCT,
sizeof(BinkAudioContext),
decode_init,
NULL,
decode_end,
decode_frame,
.name = "binkaudio_dct",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_BINKAUDIO_DCT,
.priv_data_size = sizeof(BinkAudioContext),
.init = decode_init,
.close = decode_end,
.decode = decode_frame,
.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 = {
"bmp",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_BMP,
sizeof(BMPContext),
bmp_decode_init,
NULL,
bmp_decode_end,
bmp_decode_frame,
CODEC_CAP_DR1,
.name = "bmp",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_BMP,
.priv_data_size = sizeof(BMPContext),
.init = bmp_decode_init,
.close = bmp_decode_end,
.decode = bmp_decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"bmp",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_BMP,
sizeof(BMPContext),
bmp_encode_init,
bmp_encode_frame,
NULL, //encode_end,
.name = "bmp",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_BMP,
.priv_data_size = sizeof(BMPContext),
.init = bmp_encode_init,
.encode = bmp_encode_frame,
.pix_fmts = (const enum PixelFormat[]){
PIX_FMT_BGR24,
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 = {
"c93",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_C93,
sizeof(C93DecoderContext),
decode_init,
NULL,
decode_end,
decode_frame,
CODEC_CAP_DR1,
.name = "c93",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_C93,
.priv_data_size = sizeof(C93DecoderContext),
.init = decode_init,
.close = decode_end,
.decode = decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"cavs",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_CAVS,
sizeof(AVSContext),
ff_cavs_init,
NULL,
ff_cavs_end,
cavs_decode_frame,
CODEC_CAP_DR1 | CODEC_CAP_DELAY,
.name = "cavs",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_CAVS,
.priv_data_size = sizeof(AVSContext),
.init = ff_cavs_init,
.close = ff_cavs_end,
.decode = cavs_decode_frame,
.capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
.flush= cavs_flush,
.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 = {
"cdgraphics",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_CDGRAPHICS,
sizeof(CDGraphicsContext),
cdg_decode_init,
NULL,
cdg_decode_end,
cdg_decode_frame,
CODEC_CAP_DR1,
.name = "cdgraphics",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_CDGRAPHICS,
.priv_data_size = sizeof(CDGraphicsContext),
.init = cdg_decode_init,
.close = cdg_decode_end,
.decode = cdg_decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"cinepak",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_CINEPAK,
sizeof(CinepakContext),
cinepak_decode_init,
NULL,
cinepak_decode_end,
cinepak_decode_frame,
CODEC_CAP_DR1,
.name = "cinepak",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_CINEPAK,
.priv_data_size = sizeof(CinepakContext),
.init = cinepak_decode_init,
.close = cinepak_decode_end,
.decode = cinepak_decode_frame,
.capabilities = CODEC_CAP_DR1,
.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
AVCodec ff_cljr_decoder = {
"cljr",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_CLJR,
sizeof(CLJRContext),
decode_init,
NULL,
NULL,
decode_frame,
CODEC_CAP_DR1,
.name = "cljr",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_CLJR,
.priv_data_size = sizeof(CLJRContext),
.init = decode_init,
.decode = decode_frame,
.capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Cirrus Logic AccuPak"),
};
#if CONFIG_CLJR_ENCODER
AVCodec ff_cljr_encoder = {
"cljr",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_CLJR,
sizeof(CLJRContext),
encode_init,
encode_frame,
.name = "cljr",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_CLJR,
.priv_data_size = sizeof(CLJRContext),
.init = encode_init,
.encode = encode_frame,
//encode_end,
.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 = {
"camstudio",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_CSCD,
sizeof(CamStudioContext),
decode_init,
NULL,
decode_end,
decode_frame,
CODEC_CAP_DR1,
.name = "camstudio",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_CSCD,
.priv_data_size = sizeof(CamStudioContext),
.init = decode_init,
.close = decode_end,
.decode = decode_frame,
.capabilities = CODEC_CAP_DR1,
.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
AVCodec ff_aura_decoder = {
"aura",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_AURA,
sizeof(CyuvDecodeContext),
cyuv_decode_init,
NULL,
cyuv_decode_end,
cyuv_decode_frame,
CODEC_CAP_DR1,
NULL,
.name = "aura",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_AURA,
.priv_data_size = sizeof(CyuvDecodeContext),
.init = cyuv_decode_init,
.close = cyuv_decode_end,
.decode = cyuv_decode_frame,
.capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Auravision AURA"),
};
#endif
#if CONFIG_CYUV_DECODER
AVCodec ff_cyuv_decoder = {
"cyuv",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_CYUV,
sizeof(CyuvDecodeContext),
cyuv_decode_init,
NULL,
cyuv_decode_end,
cyuv_decode_frame,
CODEC_CAP_DR1,
NULL,
.name = "cyuv",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_CYUV,
.priv_data_size = sizeof(CyuvDecodeContext),
.init = cyuv_decode_init,
.close = cyuv_decode_end,
.decode = cyuv_decode_frame,
.capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Creative YUV (CYUV)"),
};
#endif

17
libavcodec/dfa.c
View File

@ -384,14 +384,13 @@ static av_cold int dfa_decode_end(AVCodecContext *avctx)
}
AVCodec ff_dfa_decoder = {
"dfa",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DFA,
sizeof(DfaContext),
dfa_decode_init,
NULL,
dfa_decode_end,
dfa_decode_frame,
CODEC_CAP_DR1,
.name = "dfa",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DFA,
.priv_data_size = sizeof(DfaContext),
.init = dfa_decode_init,
.close = dfa_decode_end,
.decode = dfa_decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"dnxhd",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DNXHD,
sizeof(DNXHDContext),
dnxhd_decode_init,
NULL,
dnxhd_decode_close,
dnxhd_decode_frame,
CODEC_CAP_DR1,
.name = "dnxhd",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DNXHD,
.priv_data_size = sizeof(DNXHDContext),
.init = dnxhd_decode_init,
.close = dnxhd_decode_close,
.decode = dnxhd_decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"dnxhd",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DNXHD,
sizeof(DNXHDEncContext),
dnxhd_encode_init,
dnxhd_encode_picture,
dnxhd_encode_end,
.name = "dnxhd",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DNXHD,
.priv_data_size = sizeof(DNXHDEncContext),
.init = dnxhd_encode_init,
.encode = dnxhd_encode_picture,
.close = dnxhd_encode_end,
.capabilities = CODEC_CAP_SLICE_THREADS,
.pix_fmts = (const enum PixelFormat[]){PIX_FMT_YUV422P, PIX_FMT_YUV422P10, PIX_FMT_NONE},
.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 = {
"dpx",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DPX,
sizeof(DPXContext),
decode_init,
NULL,
decode_end,
decode_frame,
0,
NULL,
.name = "dpx",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DPX,
.priv_data_size = sizeof(DPXContext),
.init = decode_init,
.close = decode_end,
.decode = decode_frame,
.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 = {
"dsicinvideo",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DSICINVIDEO,
sizeof(CinVideoContext),
cinvideo_decode_init,
NULL,
cinvideo_decode_end,
cinvideo_decode_frame,
CODEC_CAP_DR1,
.name = "dsicinvideo",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DSICINVIDEO,
.priv_data_size = sizeof(CinVideoContext),
.init = cinvideo_decode_init,
.close = cinvideo_decode_end,
.decode = cinvideo_decode_frame,
.capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Delphine Software International CIN video"),
};
AVCodec ff_dsicinaudio_decoder = {
"dsicinaudio",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_DSICINAUDIO,
sizeof(CinAudioContext),
cinaudio_decode_init,
NULL,
NULL,
cinaudio_decode_frame,
.name = "dsicinaudio",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_DSICINAUDIO,
.priv_data_size = sizeof(CinAudioContext),
.init = cinaudio_decode_init,
.decode = cinaudio_decode_frame,
.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
AVCodec ff_dvvideo_encoder = {
"dvvideo",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DVVIDEO,
sizeof(DVVideoContext),
dvvideo_init_encoder,
dvvideo_encode_frame,
.name = "dvvideo",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DVVIDEO,
.priv_data_size = sizeof(DVVideoContext),
.init = dvvideo_init_encoder,
.encode = dvvideo_encode_frame,
.capabilities = CODEC_CAP_SLICE_THREADS,
.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)"),
@ -1294,16 +1294,14 @@ AVCodec ff_dvvideo_encoder = {
#if CONFIG_DVVIDEO_DECODER
AVCodec ff_dvvideo_decoder = {
"dvvideo",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DVVIDEO,
sizeof(DVVideoContext),
dvvideo_init,
NULL,
dvvideo_close,
dvvideo_decode_frame,
CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
NULL,
.name = "dvvideo",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DVVIDEO,
.priv_data_size = sizeof(DVVideoContext),
.init = dvvideo_init,
.close = dvvideo_close,
.decode = dvvideo_decode_frame,
.capabilities = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
.max_lowres = 3,
.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 = {
"dvbsub",
AVMEDIA_TYPE_SUBTITLE,
CODEC_ID_DVB_SUBTITLE,
sizeof(DVBSubtitleContext),
NULL,
dvbsub_encode,
.name = "dvbsub",
.type = AVMEDIA_TYPE_SUBTITLE,
.id = CODEC_ID_DVB_SUBTITLE,
.priv_data_size = sizeof(DVBSubtitleContext),
.encode = dvbsub_encode,
.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 = {
"dvbsub",
AVMEDIA_TYPE_SUBTITLE,
CODEC_ID_DVB_SUBTITLE,
sizeof(DVBSubContext),
dvbsub_init_decoder,
NULL,
dvbsub_close_decoder,
dvbsub_decode,
.name = "dvbsub",
.type = AVMEDIA_TYPE_SUBTITLE,
.id = CODEC_ID_DVB_SUBTITLE,
.priv_data_size = sizeof(DVBSubContext),
.init = dvbsub_init_decoder,
.close = dvbsub_close_decoder,
.decode = dvbsub_decode,
.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 = {
"dvdsub",
AVMEDIA_TYPE_SUBTITLE,
CODEC_ID_DVD_SUBTITLE,
0,
NULL,
NULL,
NULL,
dvdsub_decode,
.name = "dvdsub",
.type = AVMEDIA_TYPE_SUBTITLE,
.id = CODEC_ID_DVD_SUBTITLE,
.decode = dvdsub_decode,
.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 = {
"dvdsub",
AVMEDIA_TYPE_SUBTITLE,
CODEC_ID_DVD_SUBTITLE,
0,
NULL,
dvdsub_encode,
.name = "dvdsub",
.type = AVMEDIA_TYPE_SUBTITLE,
.id = CODEC_ID_DVD_SUBTITLE,
.encode = dvdsub_encode,
.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 = {
"dxa",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DXA,
sizeof(DxaDecContext),
decode_init,
NULL,
decode_end,
decode_frame,
CODEC_CAP_DR1,
.name = "dxa",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DXA,
.priv_data_size = sizeof(DxaDecContext),
.init = decode_init,
.close = decode_end,
.decode = decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"eacmv",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_CMV,
sizeof(CmvContext),
cmv_decode_init,
NULL,
cmv_decode_end,
cmv_decode_frame,
CODEC_CAP_DR1,
.name = "eacmv",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_CMV,
.priv_data_size = sizeof(CmvContext),
.init = cmv_decode_init,
.close = cmv_decode_end,
.decode = cmv_decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"eamad",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MAD,
sizeof(MadContext),
decode_init,
NULL,
decode_end,
decode_frame,
CODEC_CAP_DR1,
.name = "eamad",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_MAD,
.priv_data_size = sizeof(MadContext),
.init = decode_init,
.close = decode_end,
.decode = decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"eatgq",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_TGQ,
sizeof(TgqContext),
tgq_decode_init,
NULL,
tgq_decode_end,
tgq_decode_frame,
CODEC_CAP_DR1,
.name = "eatgq",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_TGQ,
.priv_data_size = sizeof(TgqContext),
.init = tgq_decode_init,
.close = tgq_decode_end,
.decode = tgq_decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"eatgv",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_TGV,
sizeof(TgvContext),
tgv_decode_init,
NULL,
tgv_decode_end,
tgv_decode_frame,
.name = "eatgv",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_TGV,
.priv_data_size = sizeof(TgvContext),
.init = tgv_decode_init,
.close = tgv_decode_end,
.decode = tgv_decode_frame,
.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 = {
"eatqi",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_TQI,
sizeof(TqiContext),
tqi_decode_init,
NULL,
tqi_decode_end,
tqi_decode_frame,
CODEC_CAP_DR1,
.name = "eatqi",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_TQI,
.priv_data_size = sizeof(TqiContext),
.init = tqi_decode_init,
.close = tqi_decode_end,
.decode = tqi_decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"escape124",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_ESCAPE124,
sizeof(Escape124Context),
escape124_decode_init,
NULL,
escape124_decode_close,
escape124_decode_frame,
CODEC_CAP_DR1,
.name = "escape124",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_ESCAPE124,
.priv_data_size = sizeof(Escape124Context),
.init = escape124_decode_init,
.close = escape124_decode_close,
.decode = escape124_decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"ffv1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_FFV1,
sizeof(FFV1Context),
decode_init,
NULL,
common_end,
decode_frame,
CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ | CODEC_CAP_SLICE_THREADS,
NULL,
.name = "ffv1",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_FFV1,
.priv_data_size = sizeof(FFV1Context),
.init = decode_init,
.close = common_end,
.decode = decode_frame,
.capabilities = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ | CODEC_CAP_SLICE_THREADS,
.long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
};
#if CONFIG_FFV1_ENCODER
AVCodec ff_ffv1_encoder = {
"ffv1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_FFV1,
sizeof(FFV1Context),
encode_init,
encode_frame,
common_end,
.name = "ffv1",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_FFV1,
.priv_data_size = sizeof(FFV1Context),
.init = encode_init,
.encode = encode_frame,
.close = common_end,
.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},
.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 = {
"flac",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_FLAC,
sizeof(FLACContext),
flac_decode_init,
NULL,
flac_decode_close,
flac_decode_frame,
.name = "flac",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_FLAC,
.priv_data_size = sizeof(FLACContext),
.init = flac_decode_init,
.close = flac_decode_close,
.decode = flac_decode_frame,
.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 = {
"flac",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_FLAC,
sizeof(FlacEncodeContext),
flac_encode_init,
flac_encode_frame,
flac_encode_close,
NULL,
.name = "flac",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_FLAC,
.priv_data_size = sizeof(FlacEncodeContext),
.init = flac_encode_init,
.encode = flac_encode_frame,
.close = flac_encode_close,
.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},
.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 = {
"flic",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_FLIC,
sizeof(FlicDecodeContext),
flic_decode_init,
NULL,
flic_decode_end,
flic_decode_frame,
CODEC_CAP_DR1,
NULL,
NULL,
NULL,
NULL,
.name = "flic",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_FLIC,
.priv_data_size = sizeof(FlicDecodeContext),
.init = flic_decode_init,
.close = flic_decode_end,
.decode = flic_decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"flv",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_FLV1,
sizeof(MpegEncContext),
ff_h263_decode_init,
NULL,
ff_h263_decode_end,
ff_h263_decode_frame,
CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
.name = "flv",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_FLV1,
.priv_data_size = sizeof(MpegEncContext),
.init = ff_h263_decode_init,
.close = ff_h263_decode_end,
.decode = ff_h263_decode_frame,
.capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
.max_lowres= 3,
.long_name= NULL_IF_CONFIG_SMALL("Flash Video (FLV) / Sorenson Spark / Sorenson H.263"),
.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 = {
"flv",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_FLV1,
sizeof(MpegEncContext),
MPV_encode_init,
MPV_encode_picture,
MPV_encode_end,
.name = "flv",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_FLV1,
.priv_data_size = sizeof(MpegEncContext),
.init = MPV_encode_init,
.encode = MPV_encode_picture,
.close = MPV_encode_end,
.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"),
};

17
libavcodec/fraps.c
View File

@ -361,14 +361,13 @@ static av_cold int decode_end(AVCodecContext *avctx)
AVCodec ff_fraps_decoder = {
"fraps",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_FRAPS,
sizeof(FrapsContext),
decode_init,
NULL,
decode_end,
decode_frame,
CODEC_CAP_DR1,
.name = "fraps",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_FRAPS,
.priv_data_size = sizeof(FrapsContext),
.init = decode_init,
.close = decode_end,
.decode = decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"frwu",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_FRWU,
0,
decode_init,
NULL,
decode_close,
decode_frame,
CODEC_CAP_DR1,
.name = "FRWU",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_FRWU,
.init = decode_init,
.close = decode_close,
.decode = decode_frame,
.capabilities = CODEC_CAP_DR1,
.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
AVCodec ff_adpcm_g726_encoder = {
"g726",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_ADPCM_G726,
sizeof(G726Context),
g726_init,
g726_encode_frame,
g726_close,
NULL,
.name = "g726",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_ADPCM_G726,
.priv_data_size = sizeof(G726Context),
.init = g726_init,
.encode = g726_encode_frame,
.close = g726_close,
.capabilities = CODEC_CAP_SMALL_LAST_FRAME,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("G.726 ADPCM"),
@ -407,13 +406,12 @@ AVCodec ff_adpcm_g726_encoder = {
#endif
AVCodec ff_adpcm_g726_decoder = {
"g726",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_ADPCM_G726,
sizeof(G726Context),
g726_init,
NULL,
g726_close,
g726_decode_frame,
.name = "g726",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_ADPCM_G726,
.priv_data_size = sizeof(G726Context),
.init = g726_init,
.close = g726_close,
.decode = g726_decode_frame,
.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 = {
"gif",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_GIF,
sizeof(GIFContext),
gif_encode_init,
gif_encode_frame,
gif_encode_close,
.name = "gif",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_GIF,
.priv_data_size = sizeof(GIFContext),
.init = gif_encode_init,
.encode = gif_encode_frame,
.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},
.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 = {
"gif",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_GIF,
sizeof(GifState),
gif_decode_init,
NULL,
gif_decode_close,
gif_decode_frame,
CODEC_CAP_DR1,
.name = "gif",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_GIF,
.priv_data_size = sizeof(GifState),
.init = gif_decode_init,
.close = gif_decode_close,
.decode = gif_decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"gsm",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_GSM,
sizeof(GSMContext),
gsm_init,
NULL,
NULL,
gsm_decode_frame,
.name = "gsm",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_GSM,
.priv_data_size = sizeof(GSMContext),
.init = gsm_init,
.decode = gsm_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("GSM"),
};
AVCodec ff_gsm_ms_decoder = {
"gsm_ms",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_GSM_MS,
sizeof(GSMContext),
gsm_init,
NULL,
NULL,
gsm_decode_frame,
.name = "gsm_ms",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_GSM_MS,
.priv_data_size = sizeof(GSMContext),
.init = gsm_init,
.decode = gsm_decode_frame,
.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 = {
"h261",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_H261,
sizeof(H261Context),
h261_decode_init,
NULL,
h261_decode_end,
h261_decode_frame,
CODEC_CAP_DR1,
.name = "h261",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_H261,
.priv_data_size = sizeof(H261Context),
.init = h261_decode_init,
.close = h261_decode_end,
.decode = h261_decode_frame,
.capabilities = CODEC_CAP_DR1,
.max_lowres = 3,
.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 = {
"h261",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_H261,
sizeof(H261Context),
MPV_encode_init,
MPV_encode_picture,
MPV_encode_end,
.name = "h261",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_H261,
.priv_data_size = sizeof(H261Context),
.init = MPV_encode_init,
.encode = MPV_encode_picture,
.close = MPV_encode_end,
.pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
.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 = {
"h263",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_H263,
sizeof(MpegEncContext),
ff_h263_decode_init,
NULL,
ff_h263_decode_end,
ff_h263_decode_frame,
CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
.name = "h263",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_H263,
.priv_data_size = sizeof(MpegEncContext),
.init = ff_h263_decode_init,
.close = ff_h263_decode_end,
.decode = ff_h263_decode_frame,
.capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
.flush= ff_mpeg_flush,
.max_lowres= 3,
.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 = {
"h264",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_H264,
sizeof(H264Context),
ff_h264_decode_init,
NULL,
ff_h264_decode_end,
decode_frame,
/*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_DELAY |
CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
.name = "h264",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_H264,
.priv_data_size = sizeof(H264Context),
.init = ff_h264_decode_init,
.close = ff_h264_decode_end,
.decode = decode_frame,
.capabilities = /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_DELAY |
CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
.flush= flush_dpb,
.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),
@ -4025,15 +4024,14 @@ AVCodec ff_h264_decoder = {
#if CONFIG_H264_VDPAU_DECODER
AVCodec ff_h264_vdpau_decoder = {
"h264_vdpau",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_H264,
sizeof(H264Context),
ff_h264_decode_init,
NULL,
ff_h264_decode_end,
decode_frame,
CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
.name = "h264_vdpau",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_H264,
.priv_data_size = sizeof(H264Context),
.init = ff_h264_decode_init,
.close = ff_h264_decode_end,
.decode = decode_frame,
.capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
.flush= flush_dpb,
.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},

64
libavcodec/huffyuv.c
View File

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

17
libavcodec/idcinvideo.c
View File

@ -255,15 +255,14 @@ static av_cold int idcin_decode_end(AVCodecContext *avctx)
}
AVCodec ff_idcin_decoder = {
"idcinvideo",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_IDCIN,
sizeof(IdcinContext),
idcin_decode_init,
NULL,
idcin_decode_end,
idcin_decode_frame,
CODEC_CAP_DR1,
.name = "idcinvideo",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_IDCIN,
.priv_data_size = sizeof(IdcinContext),
.init = idcin_decode_init,
.close = idcin_decode_end,
.decode = idcin_decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"iff_ilbm",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_IFF_ILBM,
sizeof(IffContext),
decode_init,
NULL,
decode_end,
decode_frame_ilbm,
CODEC_CAP_DR1,
.name = "iff_ilbm",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_IFF_ILBM,
.priv_data_size = sizeof(IffContext),
.init = decode_init,
.close = decode_end,
.decode = decode_frame_ilbm,
.capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("IFF ILBM"),
};
AVCodec ff_iff_byterun1_decoder = {
"iff_byterun1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_IFF_BYTERUN1,
sizeof(IffContext),
decode_init,
NULL,
decode_end,
decode_frame_byterun1,
CODEC_CAP_DR1,
.name = "iff_byterun1",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_IFF_BYTERUN1,
.priv_data_size = sizeof(IffContext),
.init = decode_init,
.close = decode_end,
.decode = decode_frame_byterun1,
.capabilities = CODEC_CAP_DR1,
.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 = {
"indeo2",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_INDEO2,
sizeof(Ir2Context),
ir2_decode_init,
NULL,
ir2_decode_end,
ir2_decode_frame,
CODEC_CAP_DR1,
.name = "indeo2",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_INDEO2,
.priv_data_size = sizeof(Ir2Context),
.init = ir2_decode_init,
.close = ir2_decode_end,
.decode = ir2_decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"indeo3",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_INDEO3,
sizeof(Indeo3DecodeContext),
indeo3_decode_init,
NULL,
indeo3_decode_end,
indeo3_decode_frame,
CODEC_CAP_DR1,
NULL,
.name = "indeo3",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_INDEO3,
.priv_data_size = sizeof(Indeo3DecodeContext),
.init = indeo3_decode_init,
.close = indeo3_decode_end,
.decode = indeo3_decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"h263i",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_H263I,
sizeof(MpegEncContext),
ff_h263_decode_init,
NULL,
ff_h263_decode_end,
ff_h263_decode_frame,
CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
.name = "h263i",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_H263I,
.priv_data_size = sizeof(MpegEncContext),
.init = ff_h263_decode_init,
.close = ff_h263_decode_end,
.decode = ff_h263_decode_frame,
.capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Intel H.263"),
.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 = {
"interplayvideo",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_INTERPLAY_VIDEO,
sizeof(IpvideoContext),
ipvideo_decode_init,
NULL,
ipvideo_decode_end,
ipvideo_decode_frame,
CODEC_CAP_DR1,
.name = "interplayvideo",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_INTERPLAY_VIDEO,
.priv_data_size = sizeof(IpvideoContext),
.init = ipvideo_decode_init,
.close = ipvideo_decode_end,
.decode = ipvideo_decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"jpegls",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_JPEGLS,
sizeof(MJpegDecodeContext),
ff_mjpeg_decode_init,
NULL,
ff_mjpeg_decode_end,
ff_mjpeg_decode_frame,
CODEC_CAP_DR1,
.name = "jpegls",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_JPEGLS,
.priv_data_size = sizeof(MJpegDecodeContext),
.init = ff_mjpeg_decode_init,
.close = ff_mjpeg_decode_end,
.decode = ff_mjpeg_decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"kgv1",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_KGV1,
sizeof(KgvContext),
decode_init,
NULL,
decode_end,
decode_frame,
.name = "kgv1",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_KGV1,
.priv_data_size = sizeof(KgvContext),
.init = decode_init,
.close = decode_end,
.decode = decode_frame,
.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 = {
"kmvc",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_KMVC,
sizeof(KmvcContext),
decode_init,
NULL,
decode_end,
decode_frame,
CODEC_CAP_DR1,
.name = "kmvc",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_KMVC,
.priv_data_size = sizeof(KmvcContext),
.init = decode_init,
.close = decode_end,
.decode = decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"lagarith",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_LAGARITH,
sizeof(LagarithContext),
lag_decode_init,
NULL,
lag_decode_end,
lag_decode_frame,
CODEC_CAP_DR1,
.name = "lagarith",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_LAGARITH,
.priv_data_size = sizeof(LagarithContext),
.init = lag_decode_init,
.close = lag_decode_end,
.decode = lag_decode_frame,
.capabilities = CODEC_CAP_DR1,
.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
AVCodec ff_mszh_decoder = {
"mszh",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MSZH,
sizeof(LclDecContext),
decode_init,
NULL,
decode_end,
decode_frame,
CODEC_CAP_DR1,
.name = "mszh",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_MSZH,
.priv_data_size = sizeof(LclDecContext),
.init = decode_init,
.close = decode_end,
.decode = decode_frame,
.capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("LCL (LossLess Codec Library) MSZH"),
};
#endif
#if CONFIG_ZLIB_DECODER
AVCodec ff_zlib_decoder = {
"zlib",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_ZLIB,
sizeof(LclDecContext),
decode_init,
NULL,
decode_end,
decode_frame,
CODEC_CAP_DR1,
.name = "zlib",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_ZLIB,
.priv_data_size = sizeof(LclDecContext),
.init = decode_init,
.close = decode_end,
.decode = decode_frame,
.capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("LCL (LossLess Codec Library) ZLIB"),
};
#endif

14
libavcodec/lclenc.c
View File

@ -171,13 +171,13 @@ static av_cold int encode_end(AVCodecContext *avctx)
}
AVCodec ff_zlib_encoder = {
"zlib",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_ZLIB,
sizeof(LclEncContext),
encode_init,
encode_frame,
encode_end,
.name = "zlib",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_ZLIB,
.priv_data_size = sizeof(LclEncContext),
.init = encode_init,
.encode = encode_frame,
.close = encode_end,
.pix_fmts = (const enum PixelFormat[]) { PIX_FMT_BGR24, PIX_FMT_NONE },
.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 = {
"libdirac",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DIRAC,
sizeof(FfmpegDiracDecoderParams),
libdirac_decode_init,
NULL,
libdirac_decode_close,
libdirac_decode_frame,
CODEC_CAP_DELAY,
.name = "libdirac",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DIRAC,
.priv_data_size = sizeof(FfmpegDiracDecoderParams),
.init = libdirac_decode_init,
.close = libdirac_decode_close,
.decode = libdirac_decode_frame,
.capabilities = CODEC_CAP_DELAY,
.flush = libdirac_flush,
.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 = {
"libdirac",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DIRAC,
sizeof(FfmpegDiracEncoderParams),
libdirac_encode_init,
libdirac_encode_frame,
libdirac_encode_close,
.name = "libdirac",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DIRAC,
.priv_data_size = sizeof(FfmpegDiracEncoderParams),
.init = libdirac_encode_init,
.encode = libdirac_encode_frame,
.close = libdirac_encode_close,
.capabilities = CODEC_CAP_DELAY,
.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"),

14
libavcodec/libfaac.c
View File

@ -165,13 +165,13 @@ static const AVProfile profiles[] = {
};
AVCodec ff_libfaac_encoder = {
"libfaac",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_AAC,
sizeof(FaacAudioContext),
Faac_encode_init,
Faac_encode_frame,
Faac_encode_close,
.name = "libfaac",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_AAC,
.priv_data_size = sizeof(FaacAudioContext),
.init = Faac_encode_init,
.encode = Faac_encode_frame,
.close = Faac_encode_close,
.capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.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 = {
"libgsm",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_GSM,
0,
libgsm_init,
libgsm_encode_frame,
libgsm_close,
.name = "libgsm",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_GSM,
.init = libgsm_init,
.encode = libgsm_encode_frame,
.close = libgsm_close,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("libgsm GSM"),
};
AVCodec ff_libgsm_ms_encoder = {
"libgsm_ms",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_GSM_MS,
0,
libgsm_init,
libgsm_encode_frame,
libgsm_close,
.name = "libgsm_ms",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_GSM_MS,
.init = libgsm_init,
.encode = libgsm_encode_frame,
.close = libgsm_close,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.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 = {
"libgsm",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_GSM,
0,
libgsm_init,
NULL,
libgsm_close,
libgsm_decode_frame,
.name = "libgsm",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_GSM,
.init = libgsm_init,
.close = libgsm_close,
.decode = libgsm_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("libgsm GSM"),
};
AVCodec ff_libgsm_ms_decoder = {
"libgsm_ms",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_GSM_MS,
0,
libgsm_init,
NULL,
libgsm_close,
libgsm_decode_frame,
.name = "libgsm_ms",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_GSM_MS,
.init = libgsm_init,
.close = libgsm_close,
.decode = libgsm_decode_frame,
.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 = {
"libmp3lame",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_MP3,
sizeof(Mp3AudioContext),
MP3lame_encode_init,
MP3lame_encode_frame,
MP3lame_encode_close,
.name = "libmp3lame",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_MP3,
.priv_data_size = sizeof(Mp3AudioContext),
.init = MP3lame_encode_init,
.encode = MP3lame_encode_frame,
.close = MP3lame_encode_close,
.capabilities= CODEC_CAP_DELAY,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,
#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 = {
"libopencore_amrnb",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_AMR_NB,
sizeof(AMRContext),
amr_nb_decode_init,
NULL,
amr_nb_decode_close,
amr_nb_decode_frame,
.name = "libopencore_amrnb",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_AMR_NB,
.priv_data_size = sizeof(AMRContext),
.init = amr_nb_decode_init,
.close = amr_nb_decode_close,
.decode = amr_nb_decode_frame,
.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 = {
"libopencore_amrnb",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_AMR_NB,
sizeof(AMRContext),
amr_nb_encode_init,
amr_nb_encode_frame,
amr_nb_encode_close,
NULL,
.name = "libopencore_amrnb",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_AMR_NB,
.priv_data_size = sizeof(AMRContext),
.init = amr_nb_encode_init,
.encode = amr_nb_encode_frame,
.close = amr_nb_encode_close,
.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"),
.priv_class = &class,
@ -308,14 +306,13 @@ static int amr_wb_decode_close(AVCodecContext *avctx)
}
AVCodec ff_libopencore_amrwb_decoder = {
"libopencore_amrwb",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_AMR_WB,
sizeof(AMRWBContext),
amr_wb_decode_init,
NULL,
amr_wb_decode_close,
amr_wb_decode_frame,
.name = "libopencore_amrwb",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_AMR_WB,
.priv_data_size = sizeof(AMRWBContext),
.init = amr_wb_decode_init,
.close = amr_wb_decode_close,
.decode = amr_wb_decode_frame,
.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 = {
"libschroedinger",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DIRAC,
sizeof(FfmpegSchroDecoderParams),
libschroedinger_decode_init,
NULL,
libschroedinger_decode_close,
libschroedinger_decode_frame,
CODEC_CAP_DELAY,
.name = "libschroedinger",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DIRAC,
.priv_data_size = sizeof(FfmpegSchroDecoderParams),
.init = libschroedinger_decode_init,
.close = libschroedinger_decode_close,
.decode = libschroedinger_decode_frame,
.capabilities = CODEC_CAP_DELAY,
.flush = libschroedinger_flush,
.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 = {
"libschroedinger",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_DIRAC,
sizeof(FfmpegSchroEncoderParams),
libschroedinger_encode_init,
libschroedinger_encode_frame,
libschroedinger_encode_close,
.name = "libschroedinger",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_DIRAC,
.priv_data_size = sizeof(FfmpegSchroEncoderParams),
.init = libschroedinger_encode_init,
.encode = libschroedinger_encode_frame,
.close = libschroedinger_encode_close,
.capabilities = CODEC_CAP_DELAY,
.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"),

15
libavcodec/libspeexdec.c
View File

@ -139,13 +139,12 @@ static av_cold int libspeex_decode_close(AVCodecContext *avctx)
}
AVCodec ff_libspeex_decoder = {
"libspeex",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_SPEEX,
sizeof(LibSpeexContext),
libspeex_decode_init,
NULL,
libspeex_decode_close,
libspeex_decode_frame,
.name = "libspeex",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_SPEEX,
.priv_data_size = sizeof(LibSpeexContext),
.init = libspeex_decode_init,
.close = libspeex_decode_close,
.decode = libspeex_decode_frame,
.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 = {
"libvo_aacenc",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_AAC,
sizeof(AACContext),
aac_encode_init,
aac_encode_frame,
aac_encode_close,
NULL,
.name = "libvo_aacenc",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_AAC,
.priv_data_size = sizeof(AACContext),
.init = aac_encode_init,
.encode = aac_encode_frame,
.close = aac_encode_close,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.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 = {
"libvo_amrwbenc",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_AMR_WB,
sizeof(AMRWBContext),
amr_wb_encode_init,
amr_wb_encode_frame,
amr_wb_encode_close,
NULL,
.name = "libvo_amrwbenc",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_AMR_WB,
.priv_data_size = sizeof(AMRWBContext),
.init = amr_wb_encode_init,
.encode = amr_wb_encode_frame,
.close = amr_wb_encode_close,
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("Android VisualOn Adaptive Multi-Rate "
"(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 = {
"libvpx",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_VP8,
sizeof(VP8Context),
vp8_init,
NULL, /* encode */
vp8_free,
vp8_decode,
0, /* capabilities */
.name = "libvpx",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_VP8,
.priv_data_size = sizeof(VP8Context),
.init = vp8_init,
.close = vp8_free,
.decode = vp8_decode,
.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 = {
"libvpx",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_VP8,
sizeof(VP8Context),
vp8_init,
vp8_encode,
vp8_free,
NULL,
CODEC_CAP_DELAY,
.name = "libvpx",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_VP8,
.priv_data_size = sizeof(VP8Context),
.init = vp8_init,
.encode = vp8_encode,
.close = vp8_free,
.capabilities = CODEC_CAP_DELAY,
.pix_fmts = (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("libvpx VP8"),
.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.
*/
AVCodec ff_libxvid_encoder = {
"libxvid",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MPEG4,
sizeof(struct xvid_context),
xvid_encode_init,
xvid_encode_frame,
xvid_encode_close,
.name = "libxvid",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_MPEG4,
.priv_data_size = sizeof(struct xvid_context),
.init = xvid_encode_init,
.encode = xvid_encode_frame,
.close = xvid_encode_close,
.pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_NONE},
.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 = {
"loco",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_LOCO,
sizeof(LOCOContext),
decode_init,
NULL,
decode_end,
decode_frame,
CODEC_CAP_DR1,
.name = "loco",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_LOCO,
.priv_data_size = sizeof(LOCOContext),
.init = decode_init,
.close = decode_end,
.decode = decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"mace3",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_MACE3,
sizeof(MACEContext),
mace_decode_init,
NULL,
NULL,
mace_decode_frame,
.name = "mace3",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_MACE3,
.priv_data_size = sizeof(MACEContext),
.init = mace_decode_init,
.decode = mace_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("MACE (Macintosh Audio Compression/Expansion) 3:1"),
};
AVCodec ff_mace6_decoder = {
"mace6",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_MACE6,
sizeof(MACEContext),
mace_decode_init,
NULL,
NULL,
mace_decode_frame,
.name = "mace6",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_MACE6,
.priv_data_size = sizeof(MACEContext),
.init = mace_decode_init,
.decode = mace_decode_frame,
.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 = {
"mdec",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MDEC,
sizeof(MDECContext),
decode_init,
NULL,
decode_end,
decode_frame,
CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
.name = "mdec",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_MDEC,
.priv_data_size = sizeof(MDECContext),
.init = decode_init,
.close = decode_end,
.decode = decode_frame,
.capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
.long_name= NULL_IF_CONFIG_SMALL("Sony PlayStation MDEC (Motion DECoder)"),
.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 = {
"mimic",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MIMIC,
sizeof(MimicContext),
mimic_decode_init,
NULL,
mimic_decode_end,
mimic_decode_frame,
CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
.name = "mimic",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_MIMIC,
.priv_data_size = sizeof(MimicContext),
.init = mimic_decode_init,
.close = mimic_decode_end,
.decode = mimic_decode_frame,
.capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
.long_name = NULL_IF_CONFIG_SMALL("Mimic"),
.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 = {
"mjpegb",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MJPEGB,
sizeof(MJpegDecodeContext),
ff_mjpeg_decode_init,
NULL,
ff_mjpeg_decode_end,
mjpegb_decode_frame,
CODEC_CAP_DR1,
NULL,
.name = "mjpegb",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_MJPEGB,
.priv_data_size = sizeof(MJpegDecodeContext),
.init = ff_mjpeg_decode_init,
.close = ff_mjpeg_decode_end,
.decode = mjpegb_decode_frame,
.capabilities = CODEC_CAP_DR1,
.max_lowres = 3,
.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 = {
"mjpeg",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MJPEG,
sizeof(MJpegDecodeContext),
ff_mjpeg_decode_init,
NULL,
ff_mjpeg_decode_end,
ff_mjpeg_decode_frame,
CODEC_CAP_DR1,
NULL,
.name = "mjpeg",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_MJPEG,
.priv_data_size = sizeof(MJpegDecodeContext),
.init = ff_mjpeg_decode_init,
.close = ff_mjpeg_decode_end,
.decode = ff_mjpeg_decode_frame,
.capabilities = CODEC_CAP_DR1,
.max_lowres = 3,
.long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
};
AVCodec ff_thp_decoder = {
"thp",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_THP,
sizeof(MJpegDecodeContext),
ff_mjpeg_decode_init,
NULL,
ff_mjpeg_decode_end,
ff_mjpeg_decode_frame,
CODEC_CAP_DR1,
NULL,
.name = "thp",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_THP,
.priv_data_size = sizeof(MJpegDecodeContext),
.init = ff_mjpeg_decode_init,
.close = ff_mjpeg_decode_end,
.decode = ff_mjpeg_decode_frame,
.capabilities = CODEC_CAP_DR1,
.max_lowres = 3,
.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 = {
"mjpeg",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MJPEG,
sizeof(MpegEncContext),
MPV_encode_init,
MPV_encode_picture,
MPV_encode_end,
.name = "mjpeg",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_MJPEG,
.priv_data_size = sizeof(MpegEncContext),
.init = MPV_encode_init,
.encode = MPV_encode_picture,
.close = MPV_encode_end,
.pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_NONE},
.long_name= NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
};

28
libavcodec/mlpdec.c
View File

@ -1179,27 +1179,23 @@ error:
}
AVCodec ff_mlp_decoder = {
"mlp",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_MLP,
sizeof(MLPDecodeContext),
mlp_decode_init,
NULL,
NULL,
read_access_unit,
.name = "mlp",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_MLP,
.priv_data_size = sizeof(MLPDecodeContext),
.init = mlp_decode_init,
.decode = read_access_unit,
.long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
};
#if CONFIG_TRUEHD_DECODER
AVCodec ff_truehd_decoder = {
"truehd",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_TRUEHD,
sizeof(MLPDecodeContext),
mlp_decode_init,
NULL,
NULL,
read_access_unit,
.name = "truehd",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_TRUEHD,
.priv_data_size = sizeof(MLPDecodeContext),
.init = mlp_decode_init,
.decode = read_access_unit,
.long_name = NULL_IF_CONFIG_SMALL("TrueHD"),
};
#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 = {
"mmvideo",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MMVIDEO,
sizeof(MmContext),
mm_decode_init,
NULL,
mm_decode_end,
mm_decode_frame,
CODEC_CAP_DR1,
.name = "mmvideo",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_MMVIDEO,
.priv_data_size = sizeof(MmContext),
.init = mm_decode_init,
.close = mm_decode_end,
.decode = mm_decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"motionpixels",
AVMEDIA_TYPE_VIDEO,
CODEC_ID_MOTIONPIXELS,
sizeof(MotionPixelsContext),
mp_decode_init,
NULL,
mp_decode_end,
mp_decode_frame,
CODEC_CAP_DR1,
.name = "motionpixels",
.type = AVMEDIA_TYPE_VIDEO,
.id = CODEC_ID_MOTIONPIXELS,
.priv_data_size = sizeof(MotionPixelsContext),
.init = mp_decode_init,
.close = mp_decode_end,
.decode = mp_decode_frame,
.capabilities = CODEC_CAP_DR1,
.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 = {
"mpc7",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_MUSEPACK7,
sizeof(MPCContext),
mpc7_decode_init,
NULL,
NULL,
mpc7_decode_frame,
.name = "mpc7",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_MUSEPACK7,
.priv_data_size = sizeof(MPCContext),
.init = mpc7_decode_init,
.decode = mpc7_decode_frame,
.flush = mpc7_decode_flush,
.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 = {
"mpc8",
AVMEDIA_TYPE_AUDIO,
CODEC_ID_MUSEPACK8,
sizeof(MPCContext),
mpc8_decode_init,
NULL,
NULL,
mpc8_decode_frame,
.name = "mpc8",
.type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_MUSEPACK8,
.priv_data_size = sizeof(MPCContext),
.init = mpc8_decode_init,
.decode = mpc8_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("Musepack SV8"),
};

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