generic-library/ffmpeg
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

cosmetics: group remaining .name and .long_name.

Browse Source 
See b2bed9325.
This commit is contained in:
Clément Bœsch 2013-10-04 13:33:20 +00:00 committed by Clément Bœsch
parent ee77140afa
commit b46f19100b
60 changed files with 82 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libavcodec/012v.c
View File

@ -150,10 +150,10 @@ static int zero12v_decode_frame(AVCodecContext *avctx, void *data,
AVCodec ff_zero12v_decoder = { AVCodec ff_zero12v_decoder = {
.name = "012v", .name = "012v",
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed 4:2:2 10-bit"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_012V, .id = AV_CODEC_ID_012V,
.init = zero12v_decode_init, .init = zero12v_decode_init,
.decode = zero12v_decode_frame, .decode = zero12v_decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed 4:2:2 10-bit"),
}; };

3
libavcodec/avrndec.c
View File

@ -119,14 +119,13 @@ static int decode_frame(AVCodecContext *avctx, void *data,
AVCodec ff_avrn_decoder = { AVCodec ff_avrn_decoder = {
.name = "avrn", .name = "avrn",
.long_name = NULL_IF_CONFIG_SMALL("Avid AVI Codec"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_AVRN, .id = AV_CODEC_ID_AVRN,
.priv_data_size = sizeof(AVRnContext), .priv_data_size = sizeof(AVRnContext),
.init = init, .init = init,
.close = end, .close = end,
.decode = decode_frame, .decode = decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("Avid AVI Codec"),
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.max_lowres = 3, .max_lowres = 3,
}; };

2
libavcodec/avuidec.c
View File

@ -121,10 +121,10 @@ static int avui_decode_frame(AVCodecContext *avctx, void *data,
AVCodec ff_avui_decoder = { AVCodec ff_avui_decoder = {
.name = "avui", .name = "avui",
.long_name = NULL_IF_CONFIG_SMALL("Avid Meridien Uncompressed"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_AVUI, .id = AV_CODEC_ID_AVUI,
.init = avui_decode_init, .init = avui_decode_init,
.decode = avui_decode_frame, .decode = avui_decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Avid Meridien Uncompressed"),
}; };

2
libavcodec/avuienc.c
View File

@ -101,6 +101,7 @@ static av_cold int avui_encode_close(AVCodecContext *avctx)
AVCodec ff_avui_encoder = { AVCodec ff_avui_encoder = {
.name = "avui", .name = "avui",
.long_name = NULL_IF_CONFIG_SMALL("Avid Meridien Uncompressed"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_AVUI, .id = AV_CODEC_ID_AVUI,
.init = avui_encode_init, .init = avui_encode_init,
@ -108,5 +109,4 @@ AVCodec ff_avui_encoder = {
.close = avui_encode_close, .close = avui_encode_close,
.capabilities = CODEC_CAP_EXPERIMENTAL, .capabilities = CODEC_CAP_EXPERIMENTAL,
.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_UYVY422, AV_PIX_FMT_NONE }, .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_UYVY422, AV_PIX_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("Avid Meridien Uncompressed"),
}; };

6
libavcodec/bintext.c
View File

@ -220,6 +220,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
#if CONFIG_BINTEXT_DECODER #if CONFIG_BINTEXT_DECODER
AVCodec ff_bintext_decoder = { AVCodec ff_bintext_decoder = {
.name = "bintext", .name = "bintext",
.long_name = NULL_IF_CONFIG_SMALL("Binary text"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_BINTEXT, .id = AV_CODEC_ID_BINTEXT,
.priv_data_size = sizeof(XbinContext), .priv_data_size = sizeof(XbinContext),
@ -227,12 +228,12 @@ AVCodec ff_bintext_decoder = {
.close = decode_end, .close = decode_end,
.decode = decode_frame, .decode = decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Binary text"),
}; };
#endif #endif
#if CONFIG_XBIN_DECODER #if CONFIG_XBIN_DECODER
AVCodec ff_xbin_decoder = { AVCodec ff_xbin_decoder = {
.name = "xbin", .name = "xbin",
.long_name = NULL_IF_CONFIG_SMALL("eXtended BINary text"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_XBIN, .id = AV_CODEC_ID_XBIN,
.priv_data_size = sizeof(XbinContext), .priv_data_size = sizeof(XbinContext),
@ -240,12 +241,12 @@ AVCodec ff_xbin_decoder = {
.close = decode_end, .close = decode_end,
.decode = decode_frame, .decode = decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("eXtended BINary text"),
}; };
#endif #endif
#if CONFIG_IDF_DECODER #if CONFIG_IDF_DECODER
AVCodec ff_idf_decoder = { AVCodec ff_idf_decoder = {
.name = "idf", .name = "idf",
.long_name = NULL_IF_CONFIG_SMALL("iCEDraw text"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_IDF, .id = AV_CODEC_ID_IDF,
.priv_data_size = sizeof(XbinContext), .priv_data_size = sizeof(XbinContext),
@ -253,6 +254,5 @@ AVCodec ff_idf_decoder = {
.close = decode_end, .close = decode_end,
.decode = decode_frame, .decode = decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("iCEDraw text"),
}; };
#endif #endif

2
libavcodec/brender_pix.c
View File

@ -211,9 +211,9 @@ static int brpix_decode_frame(AVCodecContext *avctx,
AVCodec ff_brender_pix_decoder = { AVCodec ff_brender_pix_decoder = {
.name = "brender_pix", .name = "brender_pix",
.long_name = NULL_IF_CONFIG_SMALL("BRender PIX image"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_BRENDER_PIX, .id = AV_CODEC_ID_BRENDER_PIX,
.decode = brpix_decode_frame, .decode = brpix_decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("BRender PIX image"),
}; };

2
libavcodec/cpia.c
View File

@ -222,6 +222,7 @@ static av_cold int cpia_decode_end(AVCodecContext *avctx)
AVCodec ff_cpia_decoder = { AVCodec ff_cpia_decoder = {
.name = "cpia", .name = "cpia",
.long_name = NULL_IF_CONFIG_SMALL("CPiA video format"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_CPIA, .id = AV_CODEC_ID_CPIA,
.priv_data_size = sizeof(CpiaContext), .priv_data_size = sizeof(CpiaContext),
@ -229,5 +230,4 @@ AVCodec ff_cpia_decoder = {
.close = cpia_decode_end, .close = cpia_decode_end,
.decode = cpia_decode_frame, .decode = cpia_decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("CPiA video format"),
}; };

12
libavcodec/crystalhd.c
View File

@ -1088,6 +1088,7 @@ static AVClass h264_class = {
AVCodec ff_h264_crystalhd_decoder = { AVCodec ff_h264_crystalhd_decoder = {
.name = "h264_crystalhd", .name = "h264_crystalhd",
.long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (CrystalHD acceleration)"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_H264, .id = AV_CODEC_ID_H264,
.priv_data_size = sizeof(CHDContext), .priv_data_size = sizeof(CHDContext),
@ -1096,7 +1097,6 @@ AVCodec ff_h264_crystalhd_decoder = {
.decode = decode, .decode = decode,
.capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY, .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
.flush = flush, .flush = flush,
.long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (CrystalHD acceleration)"),
.pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE}, .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE},
.priv_class = &h264_class, .priv_class = &h264_class,
}; };
@ -1112,6 +1112,7 @@ static AVClass mpeg2_class = {
AVCodec ff_mpeg2_crystalhd_decoder = { AVCodec ff_mpeg2_crystalhd_decoder = {
.name = "mpeg2_crystalhd", .name = "mpeg2_crystalhd",
.long_name = NULL_IF_CONFIG_SMALL("MPEG-2 Video (CrystalHD acceleration)"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_MPEG2VIDEO, .id = AV_CODEC_ID_MPEG2VIDEO,
.priv_data_size = sizeof(CHDContext), .priv_data_size = sizeof(CHDContext),
@ -1120,7 +1121,6 @@ AVCodec ff_mpeg2_crystalhd_decoder = {
.decode = decode, .decode = decode,
.capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY, .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
.flush = flush, .flush = flush,
.long_name = NULL_IF_CONFIG_SMALL("MPEG-2 Video (CrystalHD acceleration)"),
.pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE}, .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE},
.priv_class = &mpeg2_class, .priv_class = &mpeg2_class,
}; };
@ -1136,6 +1136,7 @@ static AVClass mpeg4_class = {
AVCodec ff_mpeg4_crystalhd_decoder = { AVCodec ff_mpeg4_crystalhd_decoder = {
.name = "mpeg4_crystalhd", .name = "mpeg4_crystalhd",
.long_name = NULL_IF_CONFIG_SMALL("MPEG-4 Part 2 (CrystalHD acceleration)"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_MPEG4, .id = AV_CODEC_ID_MPEG4,
.priv_data_size = sizeof(CHDContext), .priv_data_size = sizeof(CHDContext),
@ -1144,7 +1145,6 @@ AVCodec ff_mpeg4_crystalhd_decoder = {
.decode = decode, .decode = decode,
.capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY, .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
.flush = flush, .flush = flush,
.long_name = NULL_IF_CONFIG_SMALL("MPEG-4 Part 2 (CrystalHD acceleration)"),
.pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE}, .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE},
.priv_class = &mpeg4_class, .priv_class = &mpeg4_class,
}; };
@ -1160,6 +1160,7 @@ static AVClass msmpeg4_class = {
AVCodec ff_msmpeg4_crystalhd_decoder = { AVCodec ff_msmpeg4_crystalhd_decoder = {
.name = "msmpeg4_crystalhd", .name = "msmpeg4_crystalhd",
.long_name = NULL_IF_CONFIG_SMALL("MPEG-4 Part 2 Microsoft variant version 3 (CrystalHD acceleration)"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_MSMPEG4V3, .id = AV_CODEC_ID_MSMPEG4V3,
.priv_data_size = sizeof(CHDContext), .priv_data_size = sizeof(CHDContext),
@ -1168,7 +1169,6 @@ AVCodec ff_msmpeg4_crystalhd_decoder = {
.decode = decode, .decode = decode,
.capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_EXPERIMENTAL, .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_EXPERIMENTAL,
.flush = flush, .flush = flush,
.long_name = NULL_IF_CONFIG_SMALL("MPEG-4 Part 2 Microsoft variant version 3 (CrystalHD acceleration)"),
.pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE}, .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE},
.priv_class = &msmpeg4_class, .priv_class = &msmpeg4_class,
}; };
@ -1184,6 +1184,7 @@ static AVClass vc1_class = {
AVCodec ff_vc1_crystalhd_decoder = { AVCodec ff_vc1_crystalhd_decoder = {
.name = "vc1_crystalhd", .name = "vc1_crystalhd",
.long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 (CrystalHD acceleration)"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_VC1, .id = AV_CODEC_ID_VC1,
.priv_data_size = sizeof(CHDContext), .priv_data_size = sizeof(CHDContext),
@ -1192,7 +1193,6 @@ AVCodec ff_vc1_crystalhd_decoder = {
.decode = decode, .decode = decode,
.capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY, .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
.flush = flush, .flush = flush,
.long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 (CrystalHD acceleration)"),
.pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE}, .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE},
.priv_class = &vc1_class, .priv_class = &vc1_class,
}; };
@ -1208,6 +1208,7 @@ static AVClass wmv3_class = {
AVCodec ff_wmv3_crystalhd_decoder = { AVCodec ff_wmv3_crystalhd_decoder = {
.name = "wmv3_crystalhd", .name = "wmv3_crystalhd",
.long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 (CrystalHD acceleration)"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_WMV3, .id = AV_CODEC_ID_WMV3,
.priv_data_size = sizeof(CHDContext), .priv_data_size = sizeof(CHDContext),
@ -1216,7 +1217,6 @@ AVCodec ff_wmv3_crystalhd_decoder = {
.decode = decode, .decode = decode,
.capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY, .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
.flush = flush, .flush = flush,
.long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 (CrystalHD acceleration)"),
.pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE}, .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE},
.priv_class = &wmv3_class, .priv_class = &wmv3_class,
}; };

2
libavcodec/dcaenc.c
View File

@ -954,6 +954,7 @@ static const AVCodecDefault defaults[] = {
AVCodec ff_dca_encoder = { AVCodec ff_dca_encoder = {
.name = "dca", .name = "dca",
.long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = AV_CODEC_ID_DTS, .id = AV_CODEC_ID_DTS,
.priv_data_size = sizeof(DCAContext), .priv_data_size = sizeof(DCAContext),
@ -962,7 +963,6 @@ AVCodec ff_dca_encoder = {
.capabilities = CODEC_CAP_EXPERIMENTAL, .capabilities = CODEC_CAP_EXPERIMENTAL,
.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S32, .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S32,
AV_SAMPLE_FMT_NONE }, AV_SAMPLE_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
.supported_samplerates = sample_rates, .supported_samplerates = sample_rates,
.channel_layouts = (const uint64_t[]) { AV_CH_LAYOUT_MONO, .channel_layouts = (const uint64_t[]) { AV_CH_LAYOUT_MONO,
AV_CH_LAYOUT_STEREO, AV_CH_LAYOUT_STEREO,

2
libavcodec/diracdec.c
View File

@ -1927,6 +1927,7 @@ static int dirac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
AVCodec ff_dirac_decoder = { AVCodec ff_dirac_decoder = {
.name = "dirac", .name = "dirac",
.long_name = NULL_IF_CONFIG_SMALL("BBC Dirac VC-2"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_DIRAC, .id = AV_CODEC_ID_DIRAC,
.priv_data_size = sizeof(DiracContext), .priv_data_size = sizeof(DiracContext),
@ -1935,5 +1936,4 @@ AVCodec ff_dirac_decoder = {
.decode = dirac_decode_frame, .decode = dirac_decode_frame,
.capabilities = CODEC_CAP_DELAY, .capabilities = CODEC_CAP_DELAY,
.flush = dirac_decode_flush, .flush = dirac_decode_flush,
.long_name = NULL_IF_CONFIG_SMALL("BBC Dirac VC-2"),
}; };

2
libavcodec/evrcdec.c
View File

@ -907,11 +907,11 @@ erasure:
AVCodec ff_evrc_decoder = { AVCodec ff_evrc_decoder = {
.name = "evrc", .name = "evrc",
.long_name = NULL_IF_CONFIG_SMALL("EVRC (Enhanced Variable Rate Codec)"),
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = AV_CODEC_ID_EVRC, .id = AV_CODEC_ID_EVRC,
.init = evrc_decode_init, .init = evrc_decode_init,
.decode = evrc_decode_frame, .decode = evrc_decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.priv_data_size = sizeof(EVRCContext), .priv_data_size = sizeof(EVRCContext),
.long_name = NULL_IF_CONFIG_SMALL("EVRC (Enhanced Variable Rate Codec)"),
}; };

2
libavcodec/exr.c
View File

@ -804,11 +804,11 @@ static av_cold int decode_end(AVCodecContext *avctx)
AVCodec ff_exr_decoder = { AVCodec ff_exr_decoder = {
.name = "exr", .name = "exr",
.long_name = NULL_IF_CONFIG_SMALL("OpenEXR image"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_EXR, .id = AV_CODEC_ID_EXR,
.priv_data_size = sizeof(EXRContext), .priv_data_size = sizeof(EXRContext),
.close = decode_end, .close = decode_end,
.decode = decode_frame, .decode = decode_frame,
.capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS | CODEC_CAP_SLICE_THREADS, .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS | CODEC_CAP_SLICE_THREADS,
.long_name = NULL_IF_CONFIG_SMALL("OpenEXR image"),
}; };

2
libavcodec/ffwavesynth.c
View File

@ -473,6 +473,7 @@ static av_cold int wavesynth_close(AVCodecContext *avc)
AVCodec ff_ffwavesynth_decoder = { AVCodec ff_ffwavesynth_decoder = {
.name = "wavesynth", .name = "wavesynth",
.long_name = NULL_IF_CONFIG_SMALL("Wave synthesis pseudo-codec"),
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = AV_CODEC_ID_FFWAVESYNTH, .id = AV_CODEC_ID_FFWAVESYNTH,
.priv_data_size = sizeof(struct wavesynth_context), .priv_data_size = sizeof(struct wavesynth_context),
@ -480,5 +481,4 @@ AVCodec ff_ffwavesynth_decoder = {
.close = wavesynth_close, .close = wavesynth_close,
.decode = wavesynth_decode, .decode = wavesynth_decode,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Wave synthesis pseudo-codec"),
}; };

2
libavcodec/flashsv2enc.c
View File

@ -920,6 +920,7 @@ static av_cold int flashsv2_encode_end(AVCodecContext * avctx)
AVCodec ff_flashsv2_encoder = { AVCodec ff_flashsv2_encoder = {
.name = "flashsv2", .name = "flashsv2",
.long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video Version 2"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_FLASHSV2, .id = AV_CODEC_ID_FLASHSV2,
.priv_data_size = sizeof(FlashSV2Context), .priv_data_size = sizeof(FlashSV2Context),
@ -927,5 +928,4 @@ AVCodec ff_flashsv2_encoder = {
.encode2 = flashsv2_encode_frame, .encode2 = flashsv2_encode_frame,
.close = flashsv2_encode_end, .close = flashsv2_encode_end,
.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE }, .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video Version 2"),
}; };

2
libavcodec/g723_1.c
View File

@ -2465,12 +2465,12 @@ static int g723_1_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
AVCodec ff_g723_1_encoder = { AVCodec ff_g723_1_encoder = {
.name = "g723_1", .name = "g723_1",
.long_name = NULL_IF_CONFIG_SMALL("G.723.1"),
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = AV_CODEC_ID_G723_1, .id = AV_CODEC_ID_G723_1,
.priv_data_size = sizeof(G723_1_Context), .priv_data_size = sizeof(G723_1_Context),
.init = g723_1_encode_init, .init = g723_1_encode_init,
.encode2 = g723_1_encode_frame, .encode2 = g723_1_encode_frame,
.long_name = NULL_IF_CONFIG_SMALL("G.723.1"),
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16, .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,
AV_SAMPLE_FMT_NONE}, AV_SAMPLE_FMT_NONE},
}; };

2
libavcodec/g729dec.c
View File

@ -716,11 +716,11 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr,
AVCodec ff_g729_decoder = { AVCodec ff_g729_decoder = {
.name = "g729", .name = "g729",
.long_name = NULL_IF_CONFIG_SMALL("G.729"),
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = AV_CODEC_ID_G729, .id = AV_CODEC_ID_G729,
.priv_data_size = sizeof(G729Context), .priv_data_size = sizeof(G729Context),
.init = decoder_init, .init = decoder_init,
.decode = decode_frame, .decode = decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("G.729"),
}; };

2
libavcodec/h264.c
View File

@ -5204,6 +5204,7 @@ AVCodec ff_h264_decoder = {
#if CONFIG_H264_VDPAU_DECODER #if CONFIG_H264_VDPAU_DECODER
AVCodec ff_h264_vdpau_decoder = { AVCodec ff_h264_vdpau_decoder = {
.name = "h264_vdpau", .name = "h264_vdpau",
.long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (VDPAU acceleration)"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_H264, .id = AV_CODEC_ID_H264,
.priv_data_size = sizeof(H264Context), .priv_data_size = sizeof(H264Context),
@ -5212,7 +5213,6 @@ AVCodec ff_h264_vdpau_decoder = {
.decode = decode_frame, .decode = decode_frame,
.capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU, .capabilities = 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)"),
.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_VDPAU_H264, .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_VDPAU_H264,
AV_PIX_FMT_NONE}, AV_PIX_FMT_NONE},
.profiles = NULL_IF_CONFIG_SMALL(profiles), .profiles = NULL_IF_CONFIG_SMALL(profiles),

2
libavcodec/j2kenc.c
View File

@ -1038,6 +1038,7 @@ static int j2kenc_destroy(AVCodecContext *avctx)
AVCodec ff_jpeg2000_encoder = { AVCodec ff_jpeg2000_encoder = {
.name = "jpeg2000", .name = "jpeg2000",
.long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_JPEG2000, .id = AV_CODEC_ID_JPEG2000,
.priv_data_size = sizeof(Jpeg2000EncoderContext), .priv_data_size = sizeof(Jpeg2000EncoderContext),
@ -1045,7 +1046,6 @@ AVCodec ff_jpeg2000_encoder = {
.encode2 = encode_frame, .encode2 = encode_frame,
.close = j2kenc_destroy, .close = j2kenc_destroy,
.capabilities = CODEC_CAP_EXPERIMENTAL, .capabilities = CODEC_CAP_EXPERIMENTAL,
.long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
.pix_fmts = (const enum AVPixelFormat[]) { .pix_fmts = (const enum AVPixelFormat[]) {
AV_PIX_FMT_RGB24, AV_PIX_FMT_YUV444P, AV_PIX_FMT_GRAY8, AV_PIX_FMT_RGB24, AV_PIX_FMT_YUV444P, AV_PIX_FMT_GRAY8,
/* AV_PIX_FMT_YUV420P, /* AV_PIX_FMT_YUV420P,

2
libavcodec/libaacplus.c
View File

@ -124,6 +124,7 @@ static const AVProfile profiles[] = {
AVCodec ff_libaacplus_encoder = { AVCodec ff_libaacplus_encoder = {
.name = "libaacplus", .name = "libaacplus",
.long_name = NULL_IF_CONFIG_SMALL("libaacplus AAC+ (Advanced Audio Codec with SBR+PS)"),
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = AV_CODEC_ID_AAC, .id = AV_CODEC_ID_AAC,
.priv_data_size = sizeof(aacPlusAudioContext), .priv_data_size = sizeof(aacPlusAudioContext),
@ -133,7 +134,6 @@ AVCodec ff_libaacplus_encoder = {
.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16, .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT,
AV_SAMPLE_FMT_NONE }, AV_SAMPLE_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("libaacplus AAC+ (Advanced Audio Codec with SBR+PS)"),
.profiles = profiles, .profiles = profiles,
.channel_layouts = (const uint64_t[]) { AV_CH_LAYOUT_MONO, .channel_layouts = (const uint64_t[]) { AV_CH_LAYOUT_MONO,
AV_CH_LAYOUT_STEREO, AV_CH_LAYOUT_STEREO,

2
libavcodec/libcelt_dec.c
View File

@ -129,6 +129,7 @@ static int libcelt_dec_decode(AVCodecContext *c, void *data,
AVCodec ff_libcelt_decoder = { AVCodec ff_libcelt_decoder = {
.name = "libcelt", .name = "libcelt",
.long_name = NULL_IF_CONFIG_SMALL("Xiph CELT decoder using libcelt"),
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = AV_CODEC_ID_CELT, .id = AV_CODEC_ID_CELT,
.priv_data_size = sizeof(struct libcelt_context), .priv_data_size = sizeof(struct libcelt_context),
@ -136,5 +137,4 @@ AVCodec ff_libcelt_decoder = {
.close = libcelt_dec_close, .close = libcelt_dec_close,
.decode = libcelt_dec_decode, .decode = libcelt_dec_decode,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Xiph CELT decoder using libcelt"),
}; };

2
libavcodec/libshine.c
View File

@ -132,6 +132,7 @@ static const int libshine_sample_rates[] = {
AVCodec ff_libshine_encoder = { AVCodec ff_libshine_encoder = {
.name = "libshine", .name = "libshine",
.long_name = NULL_IF_CONFIG_SMALL("libshine MP3 (MPEG audio layer 3)"),
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_MP3, .id = CODEC_ID_MP3,
.priv_data_size = sizeof(SHINEContext), .priv_data_size = sizeof(SHINEContext),
@ -145,5 +146,4 @@ AVCodec ff_libshine_encoder = {
.channel_layouts = (const uint64_t[]) { AV_CH_LAYOUT_MONO, .channel_layouts = (const uint64_t[]) { AV_CH_LAYOUT_MONO,
AV_CH_LAYOUT_STEREO, AV_CH_LAYOUT_STEREO,
0 }, 0 },
.long_name = NULL_IF_CONFIG_SMALL("libshine MP3 (MPEG audio layer 3)"),
}; };

2
libavcodec/libtwolame.c
View File

@ -177,6 +177,7 @@ static const AVClass libtwolame_class = {
AVCodec ff_libtwolame_encoder = { AVCodec ff_libtwolame_encoder = {
.name = "libtwolame", .name = "libtwolame",
.long_name = NULL_IF_CONFIG_SMALL("libtwolame MP2 (MPEG audio layer 2)"),
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = AV_CODEC_ID_MP2, .id = AV_CODEC_ID_MP2,
.priv_data_size = sizeof(TWOLAMEContext), .priv_data_size = sizeof(TWOLAMEContext),
@ -193,6 +194,5 @@ AVCodec ff_libtwolame_encoder = {
AV_CH_LAYOUT_STEREO, AV_CH_LAYOUT_STEREO,
0 }, 0 },
.supported_samplerates = (const int[]){ 16000, 22050, 24000, 32000, 44100, 48000, 0 }, .supported_samplerates = (const int[]){ 16000, 22050, 24000, 32000, 44100, 48000, 0 },
.long_name = NULL_IF_CONFIG_SMALL("libtwolame MP2 (MPEG audio layer 2)"),
.priv_class = &libtwolame_class, .priv_class = &libtwolame_class,
}; };

2
libavcodec/libvorbisdec.c
View File

@ -188,6 +188,7 @@ static int oggvorbis_decode_close(AVCodecContext *avccontext) {
AVCodec ff_libvorbis_decoder = { AVCodec ff_libvorbis_decoder = {
.name = "libvorbis", .name = "libvorbis",
.long_name = NULL_IF_CONFIG_SMALL("libvorbis"),
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = AV_CODEC_ID_VORBIS, .id = AV_CODEC_ID_VORBIS,
.priv_data_size = sizeof(OggVorbisDecContext), .priv_data_size = sizeof(OggVorbisDecContext),
@ -195,5 +196,4 @@ AVCodec ff_libvorbis_decoder = {
.decode = oggvorbis_decode_frame, .decode = oggvorbis_decode_frame,
.close = oggvorbis_decode_close, .close = oggvorbis_decode_close,
.capabilities = CODEC_CAP_DELAY, .capabilities = CODEC_CAP_DELAY,
.long_name = NULL_IF_CONFIG_SMALL("libvorbis"),
}; };

2
libavcodec/libx264.c
View File

@ -760,6 +760,7 @@ AVCodec ff_libx264_encoder = {
AVCodec ff_libx264rgb_encoder = { AVCodec ff_libx264rgb_encoder = {
.name = "libx264rgb", .name = "libx264rgb",
.long_name = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 RGB"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_H264, .id = AV_CODEC_ID_H264,
.priv_data_size = sizeof(X264Context), .priv_data_size = sizeof(X264Context),
@ -767,7 +768,6 @@ AVCodec ff_libx264rgb_encoder = {
.encode2 = X264_frame, .encode2 = X264_frame,
.close = X264_close, .close = X264_close,
.capabilities = CODEC_CAP_DELAY | CODEC_CAP_AUTO_THREADS, .capabilities = CODEC_CAP_DELAY | CODEC_CAP_AUTO_THREADS,
.long_name = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 RGB"),
.priv_class = &rgbclass, .priv_class = &rgbclass,
.defaults = x264_defaults, .defaults = x264_defaults,
.pix_fmts = pix_fmts_8bit_rgb, .pix_fmts = pix_fmts_8bit_rgb,

2
libavcodec/libzvbi-teletextdec.c
View File

@ -457,6 +457,7 @@ static const AVClass teletext_class = {
AVCodec ff_libzvbi_teletext_decoder = { AVCodec ff_libzvbi_teletext_decoder = {
.name = "libzvbi_teletextdec", .name = "libzvbi_teletextdec",
.long_name = NULL_IF_CONFIG_SMALL("Libzvbi DVB teletext decoder"),
.type = AVMEDIA_TYPE_SUBTITLE, .type = AVMEDIA_TYPE_SUBTITLE,
.id = CODEC_ID_DVB_TELETEXT, .id = CODEC_ID_DVB_TELETEXT,
.priv_data_size = sizeof(TeletextContext), .priv_data_size = sizeof(TeletextContext),
@ -464,6 +465,5 @@ AVCodec ff_libzvbi_teletext_decoder = {
.close = teletext_close_decoder, .close = teletext_close_decoder,
.decode = teletext_decode_frame, .decode = teletext_decode_frame,
.flush = teletext_flush, .flush = teletext_flush,
.long_name = NULL_IF_CONFIG_SMALL("Libzvbi DVB teletext decoder"),
.priv_class= &teletext_class, .priv_class= &teletext_class,
}; };

2
libavcodec/mjpegenc.c
View File

@ -532,6 +532,7 @@ AVCodec ff_mjpeg_encoder = {
#if CONFIG_AMV_ENCODER #if CONFIG_AMV_ENCODER
AVCodec ff_amv_encoder = { AVCodec ff_amv_encoder = {
.name = "amv", .name = "amv",
.long_name = NULL_IF_CONFIG_SMALL("AMV Video"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_AMV, .id = AV_CODEC_ID_AMV,
.priv_data_size = sizeof(MpegEncContext), .priv_data_size = sizeof(MpegEncContext),
@ -541,6 +542,5 @@ AVCodec ff_amv_encoder = {
.pix_fmts = (const enum AVPixelFormat[]){ .pix_fmts = (const enum AVPixelFormat[]){
AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_NONE AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_NONE
}, },
.long_name = NULL_IF_CONFIG_SMALL("AMV Video"),
}; };
#endif #endif

6
libavcodec/mpeg12dec.c
View File

@ -2579,6 +2579,7 @@ AVCodec ff_mpeg2video_decoder = {
//legacy decoder //legacy decoder
AVCodec ff_mpegvideo_decoder = { AVCodec ff_mpegvideo_decoder = {
.name = "mpegvideo", .name = "mpegvideo",
.long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_MPEG2VIDEO, .id = AV_CODEC_ID_MPEG2VIDEO,
.priv_data_size = sizeof(Mpeg1Context), .priv_data_size = sizeof(Mpeg1Context),
@ -2588,7 +2589,6 @@ AVCodec ff_mpegvideo_decoder = {
.capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY | CODEC_CAP_SLICE_THREADS, .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY | CODEC_CAP_SLICE_THREADS,
.flush = flush, .flush = flush,
.max_lowres = 3, .max_lowres = 3,
.long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
}; };
#if CONFIG_MPEG_XVMC_DECODER #if CONFIG_MPEG_XVMC_DECODER
@ -2628,6 +2628,7 @@ AVCodec ff_mpeg_xvmc_decoder = {
#if CONFIG_MPEG_VDPAU_DECODER #if CONFIG_MPEG_VDPAU_DECODER
AVCodec ff_mpeg_vdpau_decoder = { AVCodec ff_mpeg_vdpau_decoder = {
.name = "mpegvideo_vdpau", .name = "mpegvideo_vdpau",
.long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video (VDPAU acceleration)"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_MPEG2VIDEO, .id = AV_CODEC_ID_MPEG2VIDEO,
.priv_data_size = sizeof(Mpeg1Context), .priv_data_size = sizeof(Mpeg1Context),
@ -2637,13 +2638,13 @@ AVCodec ff_mpeg_vdpau_decoder = {
.capabilities = CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | .capabilities = CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED |
CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY, CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY,
.flush = flush, .flush = flush,
.long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video (VDPAU acceleration)"),
}; };
#endif #endif
#if CONFIG_MPEG1_VDPAU_DECODER #if CONFIG_MPEG1_VDPAU_DECODER
AVCodec ff_mpeg1_vdpau_decoder = { AVCodec ff_mpeg1_vdpau_decoder = {
.name = "mpeg1video_vdpau", .name = "mpeg1video_vdpau",
.long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video (VDPAU acceleration)"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_MPEG1VIDEO, .id = AV_CODEC_ID_MPEG1VIDEO,
.priv_data_size = sizeof(Mpeg1Context), .priv_data_size = sizeof(Mpeg1Context),
@ -2653,6 +2654,5 @@ AVCodec ff_mpeg1_vdpau_decoder = {
.capabilities = CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | .capabilities = CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED |
CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY, CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY,
.flush = flush, .flush = flush,
.long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video (VDPAU acceleration)"),
}; };
#endif #endif

2
libavcodec/mpeg4videodec.c
View File

@ -2390,6 +2390,7 @@ AVCodec ff_mpeg4_decoder = {
#if CONFIG_MPEG4_VDPAU_DECODER #if CONFIG_MPEG4_VDPAU_DECODER
AVCodec ff_mpeg4_vdpau_decoder = { AVCodec ff_mpeg4_vdpau_decoder = {
.name = "mpeg4_vdpau", .name = "mpeg4_vdpau",
.long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 (VDPAU)"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_MPEG4, .id = AV_CODEC_ID_MPEG4,
.priv_data_size = sizeof(MpegEncContext), .priv_data_size = sizeof(MpegEncContext),
@ -2398,7 +2399,6 @@ AVCodec ff_mpeg4_vdpau_decoder = {
.decode = ff_h263_decode_frame, .decode = ff_h263_decode_frame,
.capabilities = CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY | .capabilities = CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY |
CODEC_CAP_HWACCEL_VDPAU, CODEC_CAP_HWACCEL_VDPAU,
.long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 (VDPAU)"),
.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_MPEG4, .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_MPEG4,
AV_PIX_FMT_NONE }, AV_PIX_FMT_NONE },
.priv_class = &mpeg4_vdpau_class, .priv_class = &mpeg4_vdpau_class,

2
libavcodec/msvideo1enc.c
View File

@ -300,6 +300,7 @@ static av_cold int encode_end(AVCodecContext *avctx)
AVCodec ff_msvideo1_encoder = { AVCodec ff_msvideo1_encoder = {
.name = "msvideo1", .name = "msvideo1",
.long_name = NULL_IF_CONFIG_SMALL("Microsoft Video-1"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_MSVIDEO1, .id = AV_CODEC_ID_MSVIDEO1,
.priv_data_size = sizeof(Msvideo1EncContext), .priv_data_size = sizeof(Msvideo1EncContext),
@ -307,5 +308,4 @@ AVCodec ff_msvideo1_encoder = {
.encode2 = encode_frame, .encode2 = encode_frame,
.close = encode_end, .close = encode_end,
.pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_RGB555, AV_PIX_FMT_NONE}, .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_RGB555, AV_PIX_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("Microsoft Video-1"),
}; };

4
libavcodec/mvcdec.c
View File

@ -260,6 +260,7 @@ static av_cold int mvc_decode_end(AVCodecContext *avctx)
#if CONFIG_MVC1_DECODER #if CONFIG_MVC1_DECODER
AVCodec ff_mvc1_decoder = { AVCodec ff_mvc1_decoder = {
.name = "mvc1", .name = "mvc1",
.long_name = NULL_IF_CONFIG_SMALL("Silicon Graphics Motion Video Compressor 1"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_MVC1, .id = AV_CODEC_ID_MVC1,
.priv_data_size = sizeof(MvcContext), .priv_data_size = sizeof(MvcContext),
@ -267,13 +268,13 @@ AVCodec ff_mvc1_decoder = {
.close = mvc_decode_end, .close = mvc_decode_end,
.decode = mvc_decode_frame, .decode = mvc_decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Silicon Graphics Motion Video Compressor 1"),
}; };
#endif #endif
#if CONFIG_MVC2_DECODER #if CONFIG_MVC2_DECODER
AVCodec ff_mvc2_decoder = { AVCodec ff_mvc2_decoder = {
.name = "mvc2", .name = "mvc2",
.long_name = NULL_IF_CONFIG_SMALL("Silicon Graphics Motion Video Compressor 2"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_MVC2, .id = AV_CODEC_ID_MVC2,
.priv_data_size = sizeof(MvcContext), .priv_data_size = sizeof(MvcContext),
@ -281,6 +282,5 @@ AVCodec ff_mvc2_decoder = {
.close = mvc_decode_end, .close = mvc_decode_end,
.decode = mvc_decode_frame, .decode = mvc_decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Silicon Graphics Motion Video Compressor 2"),
}; };
#endif #endif

4
libavcodec/paf.c
View File

@ -430,6 +430,7 @@ static int paf_aud_decode(AVCodecContext *avctx, void *data,
AVCodec ff_paf_video_decoder = { AVCodec ff_paf_video_decoder = {
.name = "paf_video", .name = "paf_video",
.long_name = NULL_IF_CONFIG_SMALL("Amazing Studio Packed Animation File Video"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_PAF_VIDEO, .id = AV_CODEC_ID_PAF_VIDEO,
.priv_data_size = sizeof(PAFVideoDecContext), .priv_data_size = sizeof(PAFVideoDecContext),
@ -437,15 +438,14 @@ AVCodec ff_paf_video_decoder = {
.close = paf_vid_close, .close = paf_vid_close,
.decode = paf_vid_decode, .decode = paf_vid_decode,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Amazing Studio Packed Animation File Video"),
}; };
AVCodec ff_paf_audio_decoder = { AVCodec ff_paf_audio_decoder = {
.name = "paf_audio", .name = "paf_audio",
.long_name = NULL_IF_CONFIG_SMALL("Amazing Studio Packed Animation File Audio"),
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = AV_CODEC_ID_PAF_AUDIO, .id = AV_CODEC_ID_PAF_AUDIO,
.init = paf_aud_init, .init = paf_aud_init,
.decode = paf_aud_decode, .decode = paf_aud_decode,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Amazing Studio Packed Animation File Audio"),
}; };

2
libavcodec/proresdec2.c
View File

@ -662,12 +662,12 @@ static av_cold int decode_close(AVCodecContext *avctx)
AVCodec ff_prores_decoder = { AVCodec ff_prores_decoder = {
.name = "prores", .name = "prores",
.long_name = NULL_IF_CONFIG_SMALL("ProRes"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_PRORES, .id = AV_CODEC_ID_PRORES,
.priv_data_size = sizeof(ProresContext), .priv_data_size = sizeof(ProresContext),
.init = decode_init, .init = decode_init,
.close = decode_close, .close = decode_close,
.decode = decode_frame, .decode = decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("ProRes"),
.capabilities = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS, .capabilities = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
}; };

4
libavcodec/proresenc_anatoliy.c
View File

@ -599,6 +599,7 @@ static av_cold int prores_encode_close(AVCodecContext *avctx)
AVCodec ff_prores_aw_encoder = { AVCodec ff_prores_aw_encoder = {
.name = "prores_aw", .name = "prores_aw",
.long_name = NULL_IF_CONFIG_SMALL("Apple ProRes"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_PRORES, .id = AV_CODEC_ID_PRORES,
.priv_data_size = sizeof(ProresContext), .priv_data_size = sizeof(ProresContext),
@ -606,13 +607,13 @@ AVCodec ff_prores_aw_encoder = {
.close = prores_encode_close, .close = prores_encode_close,
.encode2 = prores_encode_frame, .encode2 = prores_encode_frame,
.pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV422P10, AV_PIX_FMT_NONE}, .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV422P10, AV_PIX_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("Apple ProRes"),
.capabilities = CODEC_CAP_FRAME_THREADS | CODEC_CAP_INTRA_ONLY, .capabilities = CODEC_CAP_FRAME_THREADS | CODEC_CAP_INTRA_ONLY,
.profiles = profiles .profiles = profiles
}; };
AVCodec ff_prores_encoder = { AVCodec ff_prores_encoder = {
.name = "prores", .name = "prores",
.long_name = NULL_IF_CONFIG_SMALL("Apple ProRes"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_PRORES, .id = AV_CODEC_ID_PRORES,
.priv_data_size = sizeof(ProresContext), .priv_data_size = sizeof(ProresContext),
@ -620,7 +621,6 @@ AVCodec ff_prores_encoder = {
.close = prores_encode_close, .close = prores_encode_close,
.encode2 = prores_encode_frame, .encode2 = prores_encode_frame,
.pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV422P10, AV_PIX_FMT_NONE}, .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV422P10, AV_PIX_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("Apple ProRes"),
.capabilities = CODEC_CAP_FRAME_THREADS | CODEC_CAP_INTRA_ONLY, .capabilities = CODEC_CAP_FRAME_THREADS | CODEC_CAP_INTRA_ONLY,
.profiles = profiles .profiles = profiles
}; };

2
libavcodec/r210dec.c
View File

@ -112,11 +112,11 @@ AVCodec ff_r10k_decoder = {
#if CONFIG_AVRP_DECODER #if CONFIG_AVRP_DECODER
AVCodec ff_avrp_decoder = { AVCodec ff_avrp_decoder = {
.name = "avrp", .name = "avrp",
.long_name = NULL_IF_CONFIG_SMALL("Avid 1:1 10-bit RGB Packer"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_AVRP, .id = AV_CODEC_ID_AVRP,
.init = decode_init, .init = decode_init,
.decode = decode_frame, .decode = decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Avid 1:1 10-bit RGB Packer"),
}; };
#endif #endif

6
libavcodec/r210enc.c
View File

@ -88,36 +88,36 @@ static av_cold int encode_close(AVCodecContext *avctx)
#if CONFIG_R210_ENCODER #if CONFIG_R210_ENCODER
AVCodec ff_r210_encoder = { AVCodec ff_r210_encoder = {
.name = "r210", .name = "r210",
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed RGB 10-bit"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_R210, .id = AV_CODEC_ID_R210,
.init = encode_init, .init = encode_init,
.encode2 = encode_frame, .encode2 = encode_frame,
.close = encode_close, .close = encode_close,
.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_RGB48, AV_PIX_FMT_NONE }, .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_RGB48, AV_PIX_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed RGB 10-bit"),
}; };
#endif #endif
#if CONFIG_R10K_ENCODER #if CONFIG_R10K_ENCODER
AVCodec ff_r10k_encoder = { AVCodec ff_r10k_encoder = {
.name = "r10k", .name = "r10k",
.long_name = NULL_IF_CONFIG_SMALL("AJA Kona 10-bit RGB Codec"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_R10K, .id = AV_CODEC_ID_R10K,
.init = encode_init, .init = encode_init,
.encode2 = encode_frame, .encode2 = encode_frame,
.close = encode_close, .close = encode_close,
.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_RGB48, AV_PIX_FMT_NONE }, .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_RGB48, AV_PIX_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("AJA Kona 10-bit RGB Codec"),
}; };
#endif #endif
#if CONFIG_AVRP_ENCODER #if CONFIG_AVRP_ENCODER
AVCodec ff_avrp_encoder = { AVCodec ff_avrp_encoder = {
.name = "avrp", .name = "avrp",
.long_name = NULL_IF_CONFIG_SMALL("Avid 1:1 10-bit RGB Packer"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_AVRP, .id = AV_CODEC_ID_AVRP,
.init = encode_init, .init = encode_init,
.encode2 = encode_frame, .encode2 = encode_frame,
.close = encode_close, .close = encode_close,
.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_RGB48, AV_PIX_FMT_NONE }, .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_RGB48, AV_PIX_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("Avid 1:1 10-bit RGB Packer"),
}; };
#endif #endif

2
libavcodec/s302menc.c
View File

@ -163,12 +163,12 @@ static int s302m_encode2_frame(AVCodecContext *avctx, AVPacket *avpkt,
AVCodec ff_s302m_encoder = { AVCodec ff_s302m_encoder = {
.name = "s302m", .name = "s302m",
.long_name = NULL_IF_CONFIG_SMALL("SMPTE 302M"),
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = CODEC_ID_S302M, .id = CODEC_ID_S302M,
.priv_data_size = sizeof(S302MEncContext), .priv_data_size = sizeof(S302MEncContext),
.init = s302m_encode_init, .init = s302m_encode_init,
.encode2 = s302m_encode2_frame, .encode2 = s302m_encode2_frame,
.long_name = NULL_IF_CONFIG_SMALL("SMPTE 302M"),
.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S32, .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S32,
AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16,
AV_SAMPLE_FMT_NONE }, AV_SAMPLE_FMT_NONE },

2
libavcodec/sanm.c
View File

@ -1296,6 +1296,7 @@ static int decode_frame(AVCodecContext *avctx, void *data,
AVCodec ff_sanm_decoder = { AVCodec ff_sanm_decoder = {
.name = "sanm", .name = "sanm",
.long_name = NULL_IF_CONFIG_SMALL("LucasArts SMUSH video"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_SANM, .id = AV_CODEC_ID_SANM,
.priv_data_size = sizeof(SANMVideoContext), .priv_data_size = sizeof(SANMVideoContext),
@ -1303,5 +1304,4 @@ AVCodec ff_sanm_decoder = {
.close = decode_end, .close = decode_end,
.decode = decode_frame, .decode = decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("LucasArts SMUSH video"),
}; };

2
libavcodec/sgirledec.c
View File

@ -140,6 +140,7 @@ static av_cold int sgirle_decode_end(AVCodecContext *avctx)
AVCodec ff_sgirle_decoder = { AVCodec ff_sgirle_decoder = {
.name = "sgirle", .name = "sgirle",
.long_name = NULL_IF_CONFIG_SMALL("SGI RLE 8-bit"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_SGIRLE, .id = AV_CODEC_ID_SGIRLE,
.priv_data_size = sizeof(SGIRLEContext), .priv_data_size = sizeof(SGIRLEContext),
@ -147,5 +148,4 @@ AVCodec ff_sgirle_decoder = {
.close = sgirle_decode_end, .close = sgirle_decode_end,
.decode = sgirle_decode_frame, .decode = sgirle_decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("SGI RLE 8-bit"),
}; };

2
libavcodec/smvjpegdec.c
View File

@ -194,12 +194,12 @@ static const AVClass smvjpegdec_class = {
AVCodec ff_smvjpeg_decoder = { AVCodec ff_smvjpeg_decoder = {
.name = "smvjpeg", .name = "smvjpeg",
.long_name = NULL_IF_CONFIG_SMALL("SMV JPEG"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_SMVJPEG, .id = AV_CODEC_ID_SMVJPEG,
.priv_data_size = sizeof(SMVJpegDecodeContext), .priv_data_size = sizeof(SMVJpegDecodeContext),
.init = smvjpeg_decode_init, .init = smvjpeg_decode_init,
.close = smvjpeg_decode_end, .close = smvjpeg_decode_end,
.decode = smvjpeg_decode_frame, .decode = smvjpeg_decode_frame,
.long_name = NULL_IF_CONFIG_SMALL("SMV JPEG"),
.priv_class = &smvjpegdec_class, .priv_class = &smvjpegdec_class,
}; };

2
libavcodec/snowdec.c
View File

@ -587,6 +587,7 @@ static av_cold int decode_end(AVCodecContext *avctx)
AVCodec ff_snow_decoder = { AVCodec ff_snow_decoder = {
.name = "snow", .name = "snow",
.long_name = NULL_IF_CONFIG_SMALL("Snow"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_SNOW, .id = AV_CODEC_ID_SNOW,
.priv_data_size = sizeof(SnowContext), .priv_data_size = sizeof(SnowContext),
@ -594,5 +595,4 @@ AVCodec ff_snow_decoder = {
.close = decode_end, .close = decode_end,
.decode = decode_frame, .decode = decode_frame,
.capabilities = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/, .capabilities = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
.long_name = NULL_IF_CONFIG_SMALL("Snow"),
}; };

2
libavcodec/snowenc.c
View File

@ -1878,6 +1878,7 @@ static const AVClass snowenc_class = {
AVCodec ff_snow_encoder = { AVCodec ff_snow_encoder = {
.name = "snow", .name = "snow",
.long_name = NULL_IF_CONFIG_SMALL("Snow"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_SNOW, .id = AV_CODEC_ID_SNOW,
.priv_data_size = sizeof(SnowContext), .priv_data_size = sizeof(SnowContext),
@ -1889,7 +1890,6 @@ AVCodec ff_snow_encoder = {
AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY8,
AV_PIX_FMT_NONE AV_PIX_FMT_NONE
}, },
.long_name = NULL_IF_CONFIG_SMALL("Snow"),
.priv_class = &snowenc_class, .priv_class = &snowenc_class,
}; };

6
libavcodec/sonic.c
View File

@ -947,6 +947,7 @@ static int sonic_decode_frame(AVCodecContext *avctx,
AVCodec ff_sonic_decoder = { AVCodec ff_sonic_decoder = {
.name = "sonic", .name = "sonic",
.long_name = NULL_IF_CONFIG_SMALL("Sonic"),
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = AV_CODEC_ID_SONIC, .id = AV_CODEC_ID_SONIC,
.priv_data_size = sizeof(SonicContext), .priv_data_size = sizeof(SonicContext),
@ -954,13 +955,13 @@ AVCodec ff_sonic_decoder = {
.close = sonic_decode_close, .close = sonic_decode_close,
.decode = sonic_decode_frame, .decode = sonic_decode_frame,
.capabilities = CODEC_CAP_DR1 | CODEC_CAP_EXPERIMENTAL, .capabilities = CODEC_CAP_DR1 | CODEC_CAP_EXPERIMENTAL,
.long_name = NULL_IF_CONFIG_SMALL("Sonic"),
}; };
#endif /* CONFIG_SONIC_DECODER */ #endif /* CONFIG_SONIC_DECODER */
#if CONFIG_SONIC_ENCODER #if CONFIG_SONIC_ENCODER
AVCodec ff_sonic_encoder = { AVCodec ff_sonic_encoder = {
.name = "sonic", .name = "sonic",
.long_name = NULL_IF_CONFIG_SMALL("Sonic"),
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = AV_CODEC_ID_SONIC, .id = AV_CODEC_ID_SONIC,
.priv_data_size = sizeof(SonicContext), .priv_data_size = sizeof(SonicContext),
@ -969,13 +970,13 @@ AVCodec ff_sonic_encoder = {
.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 },
.capabilities = CODEC_CAP_EXPERIMENTAL, .capabilities = CODEC_CAP_EXPERIMENTAL,
.close = sonic_encode_close, .close = sonic_encode_close,
.long_name = NULL_IF_CONFIG_SMALL("Sonic"),
}; };
#endif #endif
#if CONFIG_SONIC_LS_ENCODER #if CONFIG_SONIC_LS_ENCODER
AVCodec ff_sonic_ls_encoder = { AVCodec ff_sonic_ls_encoder = {
.name = "sonicls", .name = "sonicls",
.long_name = NULL_IF_CONFIG_SMALL("Sonic lossless"),
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = AV_CODEC_ID_SONIC_LS, .id = AV_CODEC_ID_SONIC_LS,
.priv_data_size = sizeof(SonicContext), .priv_data_size = sizeof(SonicContext),
@ -984,6 +985,5 @@ AVCodec ff_sonic_ls_encoder = {
.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 },
.capabilities = CODEC_CAP_EXPERIMENTAL, .capabilities = CODEC_CAP_EXPERIMENTAL,
.close = sonic_encode_close, .close = sonic_encode_close,
.long_name = NULL_IF_CONFIG_SMALL("Sonic lossless"),
}; };
#endif #endif

2
libavcodec/targa_y216dec.c
View File

@ -74,10 +74,10 @@ static int y216_decode_frame(AVCodecContext *avctx, void *data,
AVCodec ff_targa_y216_decoder = { AVCodec ff_targa_y216_decoder = {
.name = "targa_y216", .name = "targa_y216",
.long_name = NULL_IF_CONFIG_SMALL("Pinnacle TARGA CineWave YUV16"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_TARGA_Y216, .id = AV_CODEC_ID_TARGA_Y216,
.init = y216_decode_init, .init = y216_decode_init,
.decode = y216_decode_frame, .decode = y216_decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Pinnacle TARGA CineWave YUV16"),
}; };

8
libavcodec/textdec.c
View File

@ -118,8 +118,8 @@ DECLARE_CLASS(text);
AVCodec ff_text_decoder = { AVCodec ff_text_decoder = {
.name = "text", .name = "text",
.priv_data_size = sizeof(TextContext),
.long_name = NULL_IF_CONFIG_SMALL("Raw text subtitle"), .long_name = NULL_IF_CONFIG_SMALL("Raw text subtitle"),
.priv_data_size = sizeof(TextContext),
.type = AVMEDIA_TYPE_SUBTITLE, .type = AVMEDIA_TYPE_SUBTITLE,
.id = AV_CODEC_ID_TEXT, .id = AV_CODEC_ID_TEXT,
.decode = text_decode_frame, .decode = text_decode_frame,
@ -143,8 +143,8 @@ DECLARE_CLASS(vplayer);
AVCodec ff_vplayer_decoder = { AVCodec ff_vplayer_decoder = {
.name = "vplayer", .name = "vplayer",
.priv_data_size = sizeof(TextContext),
.long_name = NULL_IF_CONFIG_SMALL("VPlayer subtitle"), .long_name = NULL_IF_CONFIG_SMALL("VPlayer subtitle"),
.priv_data_size = sizeof(TextContext),
.type = AVMEDIA_TYPE_SUBTITLE, .type = AVMEDIA_TYPE_SUBTITLE,
.id = AV_CODEC_ID_VPLAYER, .id = AV_CODEC_ID_VPLAYER,
.decode = text_decode_frame, .decode = text_decode_frame,
@ -159,8 +159,8 @@ DECLARE_CLASS(pjs);
AVCodec ff_pjs_decoder = { AVCodec ff_pjs_decoder = {
.name = "pjs", .name = "pjs",
.priv_data_size = sizeof(TextContext),
.long_name = NULL_IF_CONFIG_SMALL("PJS subtitle"), .long_name = NULL_IF_CONFIG_SMALL("PJS subtitle"),
.priv_data_size = sizeof(TextContext),
.type = AVMEDIA_TYPE_SUBTITLE, .type = AVMEDIA_TYPE_SUBTITLE,
.id = AV_CODEC_ID_PJS, .id = AV_CODEC_ID_PJS,
.decode = text_decode_frame, .decode = text_decode_frame,
@ -175,8 +175,8 @@ DECLARE_CLASS(subviewer1);
AVCodec ff_subviewer1_decoder = { AVCodec ff_subviewer1_decoder = {
.name = "subviewer1", .name = "subviewer1",
.priv_data_size = sizeof(TextContext),
.long_name = NULL_IF_CONFIG_SMALL("SubViewer1 subtitle"), .long_name = NULL_IF_CONFIG_SMALL("SubViewer1 subtitle"),
.priv_data_size = sizeof(TextContext),
.type = AVMEDIA_TYPE_SUBTITLE, .type = AVMEDIA_TYPE_SUBTITLE,
.id = AV_CODEC_ID_SUBVIEWER1, .id = AV_CODEC_ID_SUBVIEWER1,
.decode = text_decode_frame, .decode = text_decode_frame,

2
libavcodec/ttaenc.c
View File

@ -217,6 +217,7 @@ static av_cold int tta_encode_close(AVCodecContext *avctx)
AVCodec ff_tta_encoder = { AVCodec ff_tta_encoder = {
.name = "tta", .name = "tta",
.long_name = NULL_IF_CONFIG_SMALL("TTA (True Audio)"),
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = AV_CODEC_ID_TTA, .id = AV_CODEC_ID_TTA,
.priv_data_size = sizeof(TTAEncContext), .priv_data_size = sizeof(TTAEncContext),
@ -228,5 +229,4 @@ AVCodec ff_tta_encoder = {
AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16,
AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32,
AV_SAMPLE_FMT_NONE }, AV_SAMPLE_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("TTA (True Audio)"),
}; };

2
libavcodec/v308dec.c
View File

@ -74,10 +74,10 @@ static int v308_decode_frame(AVCodecContext *avctx, void *data,
AVCodec ff_v308_decoder = { AVCodec ff_v308_decoder = {
.name = "v308", .name = "v308",
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed packed 4:4:4"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_V308, .id = AV_CODEC_ID_V308,
.init = v308_decode_init, .init = v308_decode_init,
.decode = v308_decode_frame, .decode = v308_decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed packed 4:4:4"),
}; };

2
libavcodec/v308enc.c
View File

@ -84,11 +84,11 @@ static av_cold int v308_encode_close(AVCodecContext *avctx)
AVCodec ff_v308_encoder = { AVCodec ff_v308_encoder = {
.name = "v308", .name = "v308",
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed packed 4:4:4"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_V308, .id = AV_CODEC_ID_V308,
.init = v308_encode_init, .init = v308_encode_init,
.encode2 = v308_encode_frame, .encode2 = v308_encode_frame,
.close = v308_encode_close, .close = v308_encode_close,
.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV444P, AV_PIX_FMT_NONE }, .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV444P, AV_PIX_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed packed 4:4:4"),
}; };

4
libavcodec/v408dec.c
View File

@ -82,22 +82,22 @@ static int v408_decode_frame(AVCodecContext *avctx, void *data,
#if CONFIG_AYUV_DECODER #if CONFIG_AYUV_DECODER
AVCodec ff_ayuv_decoder = { AVCodec ff_ayuv_decoder = {
.name = "ayuv", .name = "ayuv",
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed packed MS 4:4:4:4"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_AYUV, .id = AV_CODEC_ID_AYUV,
.init = v408_decode_init, .init = v408_decode_init,
.decode = v408_decode_frame, .decode = v408_decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed packed MS 4:4:4:4"),
}; };
#endif #endif
#if CONFIG_V408_DECODER #if CONFIG_V408_DECODER
AVCodec ff_v408_decoder = { AVCodec ff_v408_decoder = {
.name = "v408", .name = "v408",
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed packed QT 4:4:4:4"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_V408, .id = AV_CODEC_ID_V408,
.init = v408_decode_init, .init = v408_decode_init,
.decode = v408_decode_frame, .decode = v408_decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed packed QT 4:4:4:4"),
}; };
#endif #endif

4
libavcodec/v408enc.c
View File

@ -90,24 +90,24 @@ static av_cold int v408_encode_close(AVCodecContext *avctx)
#if CONFIG_AYUV_ENCODER #if CONFIG_AYUV_ENCODER
AVCodec ff_ayuv_encoder = { AVCodec ff_ayuv_encoder = {
.name = "ayuv", .name = "ayuv",
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed packed MS 4:4:4:4"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_AYUV, .id = AV_CODEC_ID_AYUV,
.init = v408_encode_init, .init = v408_encode_init,
.encode2 = v408_encode_frame, .encode2 = v408_encode_frame,
.close = v408_encode_close, .close = v408_encode_close,
.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUVA444P, AV_PIX_FMT_NONE }, .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUVA444P, AV_PIX_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed packed MS 4:4:4:4"),
}; };
#endif #endif
#if CONFIG_V408_ENCODER #if CONFIG_V408_ENCODER
AVCodec ff_v408_encoder = { AVCodec ff_v408_encoder = {
.name = "v408", .name = "v408",
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed packed QT 4:4:4:4"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_V408, .id = AV_CODEC_ID_V408,
.init = v408_encode_init, .init = v408_encode_init,
.encode2 = v408_encode_frame, .encode2 = v408_encode_frame,
.close = v408_encode_close, .close = v408_encode_close,
.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUVA444P, AV_PIX_FMT_NONE }, .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUVA444P, AV_PIX_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed packed QT 4:4:4:4"),
}; };
#endif #endif

4
libavcodec/vc1dec.c
View File

@ -6278,6 +6278,7 @@ AVCodec ff_wmv3_decoder = {
#if CONFIG_WMV3_VDPAU_DECODER #if CONFIG_WMV3_VDPAU_DECODER
AVCodec ff_wmv3_vdpau_decoder = { AVCodec ff_wmv3_vdpau_decoder = {
.name = "wmv3_vdpau", .name = "wmv3_vdpau",
.long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_WMV3, .id = AV_CODEC_ID_WMV3,
.priv_data_size = sizeof(VC1Context), .priv_data_size = sizeof(VC1Context),
@ -6285,7 +6286,6 @@ AVCodec ff_wmv3_vdpau_decoder = {
.close = ff_vc1_decode_end, .close = ff_vc1_decode_end,
.decode = vc1_decode_frame, .decode = vc1_decode_frame,
.capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU, .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
.long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE }, .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
.profiles = NULL_IF_CONFIG_SMALL(profiles) .profiles = NULL_IF_CONFIG_SMALL(profiles)
}; };
@ -6294,6 +6294,7 @@ AVCodec ff_wmv3_vdpau_decoder = {
#if CONFIG_VC1_VDPAU_DECODER #if CONFIG_VC1_VDPAU_DECODER
AVCodec ff_vc1_vdpau_decoder = { AVCodec ff_vc1_vdpau_decoder = {
.name = "vc1_vdpau", .name = "vc1_vdpau",
.long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_VC1, .id = AV_CODEC_ID_VC1,
.priv_data_size = sizeof(VC1Context), .priv_data_size = sizeof(VC1Context),
@ -6301,7 +6302,6 @@ AVCodec ff_vc1_vdpau_decoder = {
.close = ff_vc1_decode_end, .close = ff_vc1_decode_end,
.decode = vc1_decode_frame, .decode = vc1_decode_frame,
.capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU, .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
.long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE }, .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
.profiles = NULL_IF_CONFIG_SMALL(profiles) .profiles = NULL_IF_CONFIG_SMALL(profiles)
}; };

2
libavcodec/vima.c
View File

@ -230,10 +230,10 @@ static int decode_frame(AVCodecContext *avctx, void *data,
AVCodec ff_vima_decoder = { AVCodec ff_vima_decoder = {
.name = "vima", .name = "vima",
.long_name = NULL_IF_CONFIG_SMALL("LucasArts VIMA audio"),
.type = AVMEDIA_TYPE_AUDIO, .type = AVMEDIA_TYPE_AUDIO,
.id = AV_CODEC_ID_VIMA, .id = AV_CODEC_ID_VIMA,
.init = decode_init, .init = decode_init,
.decode = decode_frame, .decode = decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("LucasArts VIMA audio"),
}; };

2
libavcodec/vp8.c
View File

@ -2169,6 +2169,7 @@ AVCodec ff_vp8_decoder = {
// AVCodec ff_webp_decoder = { // AVCodec ff_webp_decoder = {
// .name = "webp", // .name = "webp",
// .long_name = NULL_IF_CONFIG_SMALL("WebP"),
// .type = AVMEDIA_TYPE_VIDEO, // .type = AVMEDIA_TYPE_VIDEO,
// .id = AV_CODEC_ID_WEBP, // .id = AV_CODEC_ID_WEBP,
// .priv_data_size = sizeof(VP8Context), // .priv_data_size = sizeof(VP8Context),
@ -2177,7 +2178,6 @@ AVCodec ff_vp8_decoder = {
// .decode = webp_decode_frame, // .decode = webp_decode_frame,
// .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS | CODEC_CAP_SLICE_THREADS, // .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS | CODEC_CAP_SLICE_THREADS,
// .flush = vp8_decode_flush, // .flush = vp8_decode_flush,
// .long_name = NULL_IF_CONFIG_SMALL("WebP"),
// .init_thread_copy = ONLY_IF_THREADS_ENABLED(vp8_decode_init_thread_copy), // .init_thread_copy = ONLY_IF_THREADS_ENABLED(vp8_decode_init_thread_copy),
// .update_thread_context = ONLY_IF_THREADS_ENABLED(vp8_decode_update_thread_context), // .update_thread_context = ONLY_IF_THREADS_ENABLED(vp8_decode_update_thread_context),
// }; // };

2
libavcodec/vp9.c
View File

@ -3564,6 +3564,7 @@ static av_cold int vp9_decode_free(AVCodecContext *ctx)
AVCodec ff_vp9_decoder = { AVCodec ff_vp9_decoder = {
.name = "vp9", .name = "vp9",
.long_name = NULL_IF_CONFIG_SMALL("Google VP9"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_VP9, .id = AV_CODEC_ID_VP9,
.priv_data_size = sizeof(VP9Context), .priv_data_size = sizeof(VP9Context),
@ -3572,5 +3573,4 @@ AVCodec ff_vp9_decoder = {
.decode = vp9_decode_packet, .decode = vp9_decode_packet,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.flush = vp9_decode_flush, .flush = vp9_decode_flush,
.long_name = NULL_IF_CONFIG_SMALL("Google VP9"),
}; };

2
libavcodec/xbmdec.c
View File

@ -110,10 +110,10 @@ static int xbm_decode_frame(AVCodecContext *avctx, void *data,
AVCodec ff_xbm_decoder = { AVCodec ff_xbm_decoder = {
.name = "xbm", .name = "xbm",
.long_name = NULL_IF_CONFIG_SMALL("XBM (X BitMap) image"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_XBM, .id = AV_CODEC_ID_XBM,
.init = xbm_decode_init, .init = xbm_decode_init,
.decode = xbm_decode_frame, .decode = xbm_decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("XBM (X BitMap) image"),
}; };

2
libavcodec/xfacedec.c
View File

@ -178,11 +178,11 @@ static int xface_decode_frame(AVCodecContext *avctx,
AVCodec ff_xface_decoder = { AVCodec ff_xface_decoder = {
.name = "xface", .name = "xface",
.long_name = NULL_IF_CONFIG_SMALL("X-face image"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_XFACE, .id = AV_CODEC_ID_XFACE,
.priv_data_size = sizeof(XFaceContext), .priv_data_size = sizeof(XFaceContext),
.init = xface_decode_init, .init = xface_decode_init,
.decode = xface_decode_frame, .decode = xface_decode_frame,
.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_MONOWHITE, AV_PIX_FMT_NONE }, .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_MONOWHITE, AV_PIX_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("X-face image"),
}; };

2
libavcodec/xfaceenc.c
View File

@ -227,6 +227,7 @@ static av_cold int xface_encode_close(AVCodecContext *avctx)
AVCodec ff_xface_encoder = { AVCodec ff_xface_encoder = {
.name = "xface", .name = "xface",
.long_name = NULL_IF_CONFIG_SMALL("X-face image"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_XFACE, .id = AV_CODEC_ID_XFACE,
.priv_data_size = sizeof(XFaceContext), .priv_data_size = sizeof(XFaceContext),
@ -234,5 +235,4 @@ AVCodec ff_xface_encoder = {
.close = xface_encode_close, .close = xface_encode_close,
.encode2 = xface_encode_frame, .encode2 = xface_encode_frame,
.pix_fmts = (const enum PixelFormat[]) { AV_PIX_FMT_MONOWHITE, AV_PIX_FMT_NONE }, .pix_fmts = (const enum PixelFormat[]) { AV_PIX_FMT_MONOWHITE, AV_PIX_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("X-face image"),
}; };

2
libavcodec/y41pdec.c
View File

@ -83,10 +83,10 @@ static int y41p_decode_frame(AVCodecContext *avctx, void *data,
AVCodec ff_y41p_decoder = { AVCodec ff_y41p_decoder = {
.name = "y41p", .name = "y41p",
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed YUV 4:1:1 12-bit"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_Y41P, .id = AV_CODEC_ID_Y41P,
.init = y41p_decode_init, .init = y41p_decode_init,
.decode = y41p_decode_frame, .decode = y41p_decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed YUV 4:1:1 12-bit"),
}; };

2
libavcodec/y41penc.c
View File

@ -91,6 +91,7 @@ static av_cold int y41p_encode_close(AVCodecContext *avctx)
AVCodec ff_y41p_encoder = { AVCodec ff_y41p_encoder = {
.name = "y41p", .name = "y41p",
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed YUV 4:1:1 12-bit"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_Y41P, .id = AV_CODEC_ID_Y41P,
.init = y41p_encode_init, .init = y41p_encode_init,
@ -98,5 +99,4 @@ AVCodec ff_y41p_encoder = {
.close = y41p_encode_close, .close = y41p_encode_close,
.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV411P, .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV411P,
AV_PIX_FMT_NONE }, AV_PIX_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed YUV 4:1:1 12-bit"),
}; };

2
libavcodec/yuv4dec.c
View File

@ -75,10 +75,10 @@ static int yuv4_decode_frame(AVCodecContext *avctx, void *data,
AVCodec ff_yuv4_decoder = { AVCodec ff_yuv4_decoder = {
.name = "yuv4", .name = "yuv4",
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed packed 4:2:0"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_YUV4, .id = AV_CODEC_ID_YUV4,
.init = yuv4_decode_init, .init = yuv4_decode_init,
.decode = yuv4_decode_frame, .decode = yuv4_decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed packed 4:2:0"),
}; };

2
libavcodec/yuv4enc.c
View File

@ -81,11 +81,11 @@ static av_cold int yuv4_encode_close(AVCodecContext *avctx)
AVCodec ff_yuv4_encoder = { AVCodec ff_yuv4_encoder = {
.name = "yuv4", .name = "yuv4",
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed packed 4:2:0"),
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_YUV4, .id = AV_CODEC_ID_YUV4,
.init = yuv4_encode_init, .init = yuv4_encode_init,
.encode2 = yuv4_encode_frame, .encode2 = yuv4_encode_frame,
.close = yuv4_encode_close, .close = yuv4_encode_close,
.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE }, .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("Uncompressed packed 4:2:0"),
}; };