@@ -150,10 +150,10 @@ static int zero12v_decode_frame(AVCodecContext *avctx, void *data,

 AVCodec ff_zero12v_decoder = {

     .name           = "012v",

+    .long_name      = NULL_IF_CONFIG_SMALL("Uncompressed 4:2:2 10-bit"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_012V,

     .init           = zero12v_decode_init,

     .decode         = zero12v_decode_frame,

     .capabilities   = CODEC_CAP_DR1,

-    .long_name      = NULL_IF_CONFIG_SMALL("Uncompressed 4:2:2 10-bit"),

 };

@@ -119,14 +119,13 @@ static int decode_frame(AVCodecContext *avctx, void *data,

 AVCodec ff_avrn_decoder = {

     .name           = "avrn",

+    .long_name      = NULL_IF_CONFIG_SMALL("Avid AVI Codec"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_AVRN,

     .priv_data_size = sizeof(AVRnContext),

     .init           = init,

     .close          = end,

     .decode         = decode_frame,

-    .long_name      = NULL_IF_CONFIG_SMALL("Avid AVI Codec"),

     .capabilities   = CODEC_CAP_DR1,

     .max_lowres     = 3,

 };

-

@@ -121,10 +121,10 @@ static int avui_decode_frame(AVCodecContext *avctx, void *data,

 AVCodec ff_avui_decoder = {

     .name         = "avui",

+    .long_name    = NULL_IF_CONFIG_SMALL("Avid Meridien Uncompressed"),

     .type         = AVMEDIA_TYPE_VIDEO,

     .id           = AV_CODEC_ID_AVUI,

     .init         = avui_decode_init,

     .decode       = avui_decode_frame,

     .capabilities = CODEC_CAP_DR1,

-    .long_name    = NULL_IF_CONFIG_SMALL("Avid Meridien Uncompressed"),

 };

@@ -101,6 +101,7 @@ static av_cold int avui_encode_close(AVCodecContext *avctx)

 AVCodec ff_avui_encoder = {

     .name         = "avui",

+    .long_name    = NULL_IF_CONFIG_SMALL("Avid Meridien Uncompressed"),

     .type         = AVMEDIA_TYPE_VIDEO,

     .id           = AV_CODEC_ID_AVUI,

     .init         = avui_encode_init,

@@ -108,5 +109,4 @@ AVCodec ff_avui_encoder = {

     .close        = avui_encode_close,

     .capabilities = CODEC_CAP_EXPERIMENTAL,

     .pix_fmts     = (const enum AVPixelFormat[]){ AV_PIX_FMT_UYVY422, AV_PIX_FMT_NONE },

-    .long_name    = NULL_IF_CONFIG_SMALL("Avid Meridien Uncompressed"),

 };

@@ -220,6 +220,7 @@ static av_cold int decode_end(AVCodecContext *avctx)

 #if CONFIG_BINTEXT_DECODER

 AVCodec ff_bintext_decoder = {

     .name           = "bintext",

+    .long_name      = NULL_IF_CONFIG_SMALL("Binary text"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_BINTEXT,

     .priv_data_size = sizeof(XbinContext),

@@ -227,12 +228,12 @@ AVCodec ff_bintext_decoder = {

     .close          = decode_end,

     .decode         = decode_frame,

     .capabilities   = CODEC_CAP_DR1,

-    .long_name      = NULL_IF_CONFIG_SMALL("Binary text"),

 };

 #endif

 #if CONFIG_XBIN_DECODER

 AVCodec ff_xbin_decoder = {

     .name           = "xbin",

+    .long_name      = NULL_IF_CONFIG_SMALL("eXtended BINary text"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_XBIN,

     .priv_data_size = sizeof(XbinContext),

@@ -240,12 +241,12 @@ AVCodec ff_xbin_decoder = {

     .close          = decode_end,

     .decode         = decode_frame,

     .capabilities   = CODEC_CAP_DR1,

-    .long_name      = NULL_IF_CONFIG_SMALL("eXtended BINary text"),

 };

 #endif

 #if CONFIG_IDF_DECODER

 AVCodec ff_idf_decoder = {

     .name           = "idf",

+    .long_name      = NULL_IF_CONFIG_SMALL("iCEDraw text"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_IDF,

     .priv_data_size = sizeof(XbinContext),

@@ -253,6 +254,5 @@ AVCodec ff_idf_decoder = {

     .close          = decode_end,

     .decode         = decode_frame,

     .capabilities   = CODEC_CAP_DR1,

-    .long_name      = NULL_IF_CONFIG_SMALL("iCEDraw text"),

 };

 #endif

@@ -211,9 +211,9 @@ static int brpix_decode_frame(AVCodecContext *avctx,

 AVCodec ff_brender_pix_decoder = {

     .name           = "brender_pix",

+    .long_name      = NULL_IF_CONFIG_SMALL("BRender PIX image"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_BRENDER_PIX,

     .decode         = brpix_decode_frame,

     .capabilities   = CODEC_CAP_DR1,

-    .long_name      = NULL_IF_CONFIG_SMALL("BRender PIX image"),

 };

@@ -222,6 +222,7 @@ static av_cold int cpia_decode_end(AVCodecContext *avctx)

 AVCodec ff_cpia_decoder = {

     .name           = "cpia",

+    .long_name      = NULL_IF_CONFIG_SMALL("CPiA video format"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_CPIA,

     .priv_data_size = sizeof(CpiaContext),

@@ -229,5 +230,4 @@ AVCodec ff_cpia_decoder = {

     .close          = cpia_decode_end,

     .decode         = cpia_decode_frame,

     .capabilities   = CODEC_CAP_DR1,

-    .long_name      = NULL_IF_CONFIG_SMALL("CPiA video format"),

 };

@@ -1088,6 +1088,7 @@ static AVClass h264_class = {

 AVCodec ff_h264_crystalhd_decoder = {

     .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,

     .id             = AV_CODEC_ID_H264,

     .priv_data_size = sizeof(CHDContext),

@@ -1096,7 +1097,6 @@ AVCodec ff_h264_crystalhd_decoder = {

     .decode         = decode,

     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,

     .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},

     .priv_class     = &h264_class,

 };

@@ -1112,6 +1112,7 @@ static AVClass mpeg2_class = {

 AVCodec ff_mpeg2_crystalhd_decoder = {

     .name           = "mpeg2_crystalhd",

+    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-2 Video (CrystalHD acceleration)"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_MPEG2VIDEO,

     .priv_data_size = sizeof(CHDContext),

@@ -1120,7 +1121,6 @@ AVCodec ff_mpeg2_crystalhd_decoder = {

     .decode         = decode,

     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,

     .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},

     .priv_class     = &mpeg2_class,

 };

@@ -1136,6 +1136,7 @@ static AVClass mpeg4_class = {

 AVCodec ff_mpeg4_crystalhd_decoder = {

     .name           = "mpeg4_crystalhd",

+    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 Part 2 (CrystalHD acceleration)"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_MPEG4,

     .priv_data_size = sizeof(CHDContext),

@@ -1144,7 +1145,6 @@ AVCodec ff_mpeg4_crystalhd_decoder = {

     .decode         = decode,

     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,

     .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},

     .priv_class     = &mpeg4_class,

 };

@@ -1160,6 +1160,7 @@ static AVClass msmpeg4_class = {

 AVCodec ff_msmpeg4_crystalhd_decoder = {

     .name           = "msmpeg4_crystalhd",

+    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 Part 2 Microsoft variant version 3 (CrystalHD acceleration)"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_MSMPEG4V3,

     .priv_data_size = sizeof(CHDContext),

@@ -1168,7 +1169,6 @@ AVCodec ff_msmpeg4_crystalhd_decoder = {

     .decode         = decode,

     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_EXPERIMENTAL,

     .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},

     .priv_class     = &msmpeg4_class,

 };

@@ -1184,6 +1184,7 @@ static AVClass vc1_class = {

 AVCodec ff_vc1_crystalhd_decoder = {

     .name           = "vc1_crystalhd",

+    .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1 (CrystalHD acceleration)"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_VC1,

     .priv_data_size = sizeof(CHDContext),

@@ -1192,7 +1193,6 @@ AVCodec ff_vc1_crystalhd_decoder = {

     .decode         = decode,

     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,

     .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},

     .priv_class     = &vc1_class,

 };

@@ -1208,6 +1208,7 @@ static AVClass wmv3_class = {

 AVCodec ff_wmv3_crystalhd_decoder = {

     .name           = "wmv3_crystalhd",

+    .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 (CrystalHD acceleration)"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_WMV3,

     .priv_data_size = sizeof(CHDContext),

@@ -1216,7 +1217,6 @@ AVCodec ff_wmv3_crystalhd_decoder = {

     .decode         = decode,

     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,

     .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},

     .priv_class     = &wmv3_class,

 };

@@ -954,6 +954,7 @@ static const AVCodecDefault defaults[] = {

 AVCodec ff_dca_encoder = {

     .name                  = "dca",

+    .long_name             = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),

     .type                  = AVMEDIA_TYPE_AUDIO,

     .id                    = AV_CODEC_ID_DTS,

     .priv_data_size        = sizeof(DCAContext),

@@ -962,7 +963,6 @@ AVCodec ff_dca_encoder = {

     .capabilities          = CODEC_CAP_EXPERIMENTAL,

     .sample_fmts           = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S32,

                                                             AV_SAMPLE_FMT_NONE },

-    .long_name             = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),

     .supported_samplerates = sample_rates,

     .channel_layouts       = (const uint64_t[]) { AV_CH_LAYOUT_MONO,

                                                   AV_CH_LAYOUT_STEREO,

@@ -1927,6 +1927,7 @@ static int dirac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

 AVCodec ff_dirac_decoder = {

     .name           = "dirac",

+    .long_name      = NULL_IF_CONFIG_SMALL("BBC Dirac VC-2"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_DIRAC,

     .priv_data_size = sizeof(DiracContext),

@@ -1935,5 +1936,4 @@ AVCodec ff_dirac_decoder = {

     .decode         = dirac_decode_frame,

     .capabilities   = CODEC_CAP_DELAY,

     .flush          = dirac_decode_flush,

-    .long_name      = NULL_IF_CONFIG_SMALL("BBC Dirac VC-2"),

 };

@@ -907,11 +907,11 @@ erasure:

 AVCodec ff_evrc_decoder = {

     .name           = "evrc",

+    .long_name      = NULL_IF_CONFIG_SMALL("EVRC (Enhanced Variable Rate Codec)"),

     .type           = AVMEDIA_TYPE_AUDIO,

     .id             = AV_CODEC_ID_EVRC,

     .init           = evrc_decode_init,

     .decode         = evrc_decode_frame,

     .capabilities   = CODEC_CAP_DR1,

     .priv_data_size = sizeof(EVRCContext),

-    .long_name      = NULL_IF_CONFIG_SMALL("EVRC (Enhanced Variable Rate Codec)"),

 };

@@ -804,11 +804,11 @@ static av_cold int decode_end(AVCodecContext *avctx)

 AVCodec ff_exr_decoder = {

     .name               = "exr",

+    .long_name          = NULL_IF_CONFIG_SMALL("OpenEXR image"),

     .type               = AVMEDIA_TYPE_VIDEO,

     .id                 = AV_CODEC_ID_EXR,

     .priv_data_size     = sizeof(EXRContext),

     .close              = decode_end,

     .decode             = decode_frame,

     .capabilities       = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS | CODEC_CAP_SLICE_THREADS,

-    .long_name          = NULL_IF_CONFIG_SMALL("OpenEXR image"),

 };

@@ -473,6 +473,7 @@ static av_cold int wavesynth_close(AVCodecContext *avc)

 AVCodec ff_ffwavesynth_decoder = {

     .name           = "wavesynth",

+    .long_name      = NULL_IF_CONFIG_SMALL("Wave synthesis pseudo-codec"),

     .type           = AVMEDIA_TYPE_AUDIO,

     .id             = AV_CODEC_ID_FFWAVESYNTH,

     .priv_data_size = sizeof(struct wavesynth_context),

@@ -480,5 +481,4 @@ AVCodec ff_ffwavesynth_decoder = {

     .close          = wavesynth_close,

     .decode         = wavesynth_decode,

     .capabilities   = CODEC_CAP_DR1,

-    .long_name      = NULL_IF_CONFIG_SMALL("Wave synthesis pseudo-codec"),

 };

@@ -920,6 +920,7 @@ static av_cold int flashsv2_encode_end(AVCodecContext * avctx)

 AVCodec ff_flashsv2_encoder = {

     .name           = "flashsv2",

+    .long_name      = NULL_IF_CONFIG_SMALL("Flash Screen Video Version 2"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_FLASHSV2,

     .priv_data_size = sizeof(FlashSV2Context),

@@ -927,5 +928,4 @@ AVCodec ff_flashsv2_encoder = {

     .encode2        = flashsv2_encode_frame,

     .close          = flashsv2_encode_end,

     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },

-    .long_name      = NULL_IF_CONFIG_SMALL("Flash Screen Video Version 2"),

 };

@@ -2465,12 +2465,12 @@ static int g723_1_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,

 AVCodec ff_g723_1_encoder = {

     .name           = "g723_1",

+    .long_name      = NULL_IF_CONFIG_SMALL("G.723.1"),

     .type           = AVMEDIA_TYPE_AUDIO,

     .id             = AV_CODEC_ID_G723_1,

     .priv_data_size = sizeof(G723_1_Context),

     .init           = g723_1_encode_init,

     .encode2        = g723_1_encode_frame,

-    .long_name      = NULL_IF_CONFIG_SMALL("G.723.1"),

     .sample_fmts    = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,

                                                     AV_SAMPLE_FMT_NONE},

 };

@@ -716,11 +716,11 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr,

 AVCodec ff_g729_decoder = {

     .name           = "g729",

+    .long_name      = NULL_IF_CONFIG_SMALL("G.729"),

     .type           = AVMEDIA_TYPE_AUDIO,

     .id             = AV_CODEC_ID_G729,

     .priv_data_size = sizeof(G729Context),

     .init           = decoder_init,

     .decode         = decode_frame,

     .capabilities   = CODEC_CAP_DR1,

-    .long_name      = NULL_IF_CONFIG_SMALL("G.729"),

 };

@@ -5204,6 +5204,7 @@ AVCodec ff_h264_decoder = {

 #if CONFIG_H264_VDPAU_DECODER

 AVCodec ff_h264_vdpau_decoder = {

     .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,

     .id             = AV_CODEC_ID_H264,

     .priv_data_size = sizeof(H264Context),

@@ -5212,7 +5213,6 @@ AVCodec ff_h264_vdpau_decoder = {

     .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 AVPixelFormat[]) { AV_PIX_FMT_VDPAU_H264,

                                                      AV_PIX_FMT_NONE},

     .profiles       = NULL_IF_CONFIG_SMALL(profiles),

@@ -1038,6 +1038,7 @@ static int j2kenc_destroy(AVCodecContext *avctx)

 AVCodec ff_jpeg2000_encoder = {

     .name           = "jpeg2000",

+    .long_name      = NULL_IF_CONFIG_SMALL("JPEG 2000"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_JPEG2000,

     .priv_data_size = sizeof(Jpeg2000EncoderContext),

@@ -1045,7 +1046,6 @@ AVCodec ff_jpeg2000_encoder = {

     .encode2        = encode_frame,

     .close          = j2kenc_destroy,

     .capabilities   = CODEC_CAP_EXPERIMENTAL,

-    .long_name      = NULL_IF_CONFIG_SMALL("JPEG 2000"),

     .pix_fmts       = (const enum AVPixelFormat[]) {

         AV_PIX_FMT_RGB24, AV_PIX_FMT_YUV444P, AV_PIX_FMT_GRAY8,

 /*      AV_PIX_FMT_YUV420P,

@@ -124,6 +124,7 @@ static const AVProfile profiles[] = {

 AVCodec ff_libaacplus_encoder = {

     .name           = "libaacplus",

+    .long_name      = NULL_IF_CONFIG_SMALL("libaacplus AAC+ (Advanced Audio Codec with SBR+PS)"),

     .type           = AVMEDIA_TYPE_AUDIO,

     .id             = AV_CODEC_ID_AAC,

     .priv_data_size = sizeof(aacPlusAudioContext),

@@ -133,7 +134,6 @@ AVCodec ff_libaacplus_encoder = {

     .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,

                                                      AV_SAMPLE_FMT_FLT,

                                                      AV_SAMPLE_FMT_NONE },

-    .long_name      = NULL_IF_CONFIG_SMALL("libaacplus AAC+ (Advanced Audio Codec with SBR+PS)"),

     .profiles       = profiles,

     .channel_layouts = (const uint64_t[]) { AV_CH_LAYOUT_MONO,

                                             AV_CH_LAYOUT_STEREO,

@@ -129,6 +129,7 @@ static int libcelt_dec_decode(AVCodecContext *c, void *data,

 AVCodec ff_libcelt_decoder = {

     .name           = "libcelt",

+    .long_name      = NULL_IF_CONFIG_SMALL("Xiph CELT decoder using libcelt"),

     .type           = AVMEDIA_TYPE_AUDIO,

     .id             = AV_CODEC_ID_CELT,

     .priv_data_size = sizeof(struct libcelt_context),

@@ -136,5 +137,4 @@ AVCodec ff_libcelt_decoder = {

     .close          = libcelt_dec_close,

     .decode         = libcelt_dec_decode,

     .capabilities   = CODEC_CAP_DR1,

-    .long_name      = NULL_IF_CONFIG_SMALL("Xiph CELT decoder using libcelt"),

 };

@@ -132,6 +132,7 @@ static const int libshine_sample_rates[] = {

 AVCodec ff_libshine_encoder = {

     .name                  = "libshine",

+    .long_name             = NULL_IF_CONFIG_SMALL("libshine MP3 (MPEG audio layer 3)"),

     .type                  = AVMEDIA_TYPE_AUDIO,

     .id                    = CODEC_ID_MP3,

     .priv_data_size        = sizeof(SHINEContext),

@@ -145,5 +146,4 @@ AVCodec ff_libshine_encoder = {

     .channel_layouts       = (const uint64_t[]) { AV_CH_LAYOUT_MONO,

                                                   AV_CH_LAYOUT_STEREO,

                                                   0 },

-    .long_name             = NULL_IF_CONFIG_SMALL("libshine MP3 (MPEG audio layer 3)"),

 };

@@ -177,6 +177,7 @@ static const AVClass libtwolame_class = {

 AVCodec ff_libtwolame_encoder = {

     .name                  = "libtwolame",

+    .long_name             = NULL_IF_CONFIG_SMALL("libtwolame MP2 (MPEG audio layer 2)"),

     .type                  = AVMEDIA_TYPE_AUDIO,

     .id                    = AV_CODEC_ID_MP2,

     .priv_data_size        = sizeof(TWOLAMEContext),

@@ -193,6 +194,5 @@ AVCodec ff_libtwolame_encoder = {

                                                   AV_CH_LAYOUT_STEREO,

                                                   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,

 };

@@ -188,6 +188,7 @@ static int oggvorbis_decode_close(AVCodecContext *avccontext) {

 AVCodec ff_libvorbis_decoder = {

     .name           = "libvorbis",

+    .long_name      = NULL_IF_CONFIG_SMALL("libvorbis"),

     .type           = AVMEDIA_TYPE_AUDIO,

     .id             = AV_CODEC_ID_VORBIS,

     .priv_data_size = sizeof(OggVorbisDecContext),

@@ -195,5 +196,4 @@ AVCodec ff_libvorbis_decoder = {

     .decode         = oggvorbis_decode_frame,

     .close          = oggvorbis_decode_close,

     .capabilities   = CODEC_CAP_DELAY,

-    .long_name      = NULL_IF_CONFIG_SMALL("libvorbis"),

 };

@@ -760,6 +760,7 @@ AVCodec ff_libx264_encoder = {

 AVCodec ff_libx264rgb_encoder = {

     .name           = "libx264rgb",

+    .long_name      = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 RGB"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_H264,

     .priv_data_size = sizeof(X264Context),

@@ -767,7 +768,6 @@ AVCodec ff_libx264rgb_encoder = {

     .encode2        = X264_frame,

     .close          = X264_close,

     .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,

     .defaults       = x264_defaults,

     .pix_fmts       = pix_fmts_8bit_rgb,

@@ -457,6 +457,7 @@ static const AVClass teletext_class = {

 AVCodec ff_libzvbi_teletext_decoder = {

     .name      = "libzvbi_teletextdec",

+    .long_name = NULL_IF_CONFIG_SMALL("Libzvbi DVB teletext decoder"),

     .type      = AVMEDIA_TYPE_SUBTITLE,

     .id        = CODEC_ID_DVB_TELETEXT,

     .priv_data_size = sizeof(TeletextContext),

@@ -464,6 +465,5 @@ AVCodec ff_libzvbi_teletext_decoder = {

     .close     = teletext_close_decoder,

     .decode    = teletext_decode_frame,

     .flush     = teletext_flush,

-    .long_name = NULL_IF_CONFIG_SMALL("Libzvbi DVB teletext decoder"),

     .priv_class= &teletext_class,

 };

@@ -532,6 +532,7 @@ AVCodec ff_mjpeg_encoder = {

 #if CONFIG_AMV_ENCODER

 AVCodec ff_amv_encoder = {

     .name           = "amv",

+    .long_name      = NULL_IF_CONFIG_SMALL("AMV Video"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_AMV,

     .priv_data_size = sizeof(MpegEncContext),

@@ -541,6 +542,5 @@ AVCodec ff_amv_encoder = {

     .pix_fmts       = (const enum AVPixelFormat[]){

         AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_NONE

     },

-    .long_name      = NULL_IF_CONFIG_SMALL("AMV Video"),

 };

 #endif

@@ -2579,6 +2579,7 @@ AVCodec ff_mpeg2video_decoder = {

 //legacy decoder

 AVCodec ff_mpegvideo_decoder = {

     .name           = "mpegvideo",

+    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-1 video"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_MPEG2VIDEO,

     .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,

     .flush          = flush,

     .max_lowres     = 3,

-    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-1 video"),

 };

 #if CONFIG_MPEG_XVMC_DECODER

@@ -2628,6 +2628,7 @@ AVCodec ff_mpeg_xvmc_decoder = {

 #if CONFIG_MPEG_VDPAU_DECODER

 AVCodec ff_mpeg_vdpau_decoder = {

     .name           = "mpegvideo_vdpau",

+    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-1/2 video (VDPAU acceleration)"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_MPEG2VIDEO,

     .priv_data_size = sizeof(Mpeg1Context),

@@ -2637,13 +2638,13 @@ AVCodec ff_mpeg_vdpau_decoder = {

     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED |

                       CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY,

     .flush          = flush,

-    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-1/2 video (VDPAU acceleration)"),

 };

 #endif

 #if CONFIG_MPEG1_VDPAU_DECODER

 AVCodec ff_mpeg1_vdpau_decoder = {

     .name           = "mpeg1video_vdpau",

+    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-1 video (VDPAU acceleration)"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_MPEG1VIDEO,

     .priv_data_size = sizeof(Mpeg1Context),

@@ -2653,6 +2654,5 @@ AVCodec ff_mpeg1_vdpau_decoder = {

     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED |

                       CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY,

     .flush          = flush,

-    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-1 video (VDPAU acceleration)"),

 };

 #endif

@@ -2390,6 +2390,7 @@ AVCodec ff_mpeg4_decoder = {

 #if CONFIG_MPEG4_VDPAU_DECODER

 AVCodec ff_mpeg4_vdpau_decoder = {

     .name           = "mpeg4_vdpau",

+    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 (VDPAU)"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_MPEG4,

     .priv_data_size = sizeof(MpegEncContext),

@@ -2398,7 +2399,6 @@ AVCodec ff_mpeg4_vdpau_decoder = {

     .decode         = ff_h263_decode_frame,

     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY |

                       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,

                                                   AV_PIX_FMT_NONE },

     .priv_class     = &mpeg4_vdpau_class,

@@ -300,6 +300,7 @@ static av_cold int encode_end(AVCodecContext *avctx)

 AVCodec ff_msvideo1_encoder = {

     .name           = "msvideo1",

+    .long_name = NULL_IF_CONFIG_SMALL("Microsoft Video-1"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_MSVIDEO1,

     .priv_data_size = sizeof(Msvideo1EncContext),

@@ -307,5 +308,4 @@ AVCodec ff_msvideo1_encoder = {

     .encode2        = encode_frame,

     .close          = encode_end,

     .pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_RGB555, AV_PIX_FMT_NONE},

-    .long_name = NULL_IF_CONFIG_SMALL("Microsoft Video-1"),

 };

@@ -260,6 +260,7 @@ static av_cold int mvc_decode_end(AVCodecContext *avctx)

 #if CONFIG_MVC1_DECODER

 AVCodec ff_mvc1_decoder = {

     .name           = "mvc1",

+    .long_name      = NULL_IF_CONFIG_SMALL("Silicon Graphics Motion Video Compressor 1"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_MVC1,

     .priv_data_size = sizeof(MvcContext),

@@ -267,13 +268,13 @@ AVCodec ff_mvc1_decoder = {

     .close          = mvc_decode_end,

     .decode         = mvc_decode_frame,

     .capabilities   = CODEC_CAP_DR1,

-    .long_name      = NULL_IF_CONFIG_SMALL("Silicon Graphics Motion Video Compressor 1"),

 };

 #endif

 #if CONFIG_MVC2_DECODER

 AVCodec ff_mvc2_decoder = {

     .name           = "mvc2",

+    .long_name      = NULL_IF_CONFIG_SMALL("Silicon Graphics Motion Video Compressor 2"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_MVC2,

     .priv_data_size = sizeof(MvcContext),

@@ -281,6 +282,5 @@ AVCodec ff_mvc2_decoder = {

     .close          = mvc_decode_end,

     .decode         = mvc_decode_frame,

     .capabilities   = CODEC_CAP_DR1,

-    .long_name      = NULL_IF_CONFIG_SMALL("Silicon Graphics Motion Video Compressor 2"),

 };

 #endif

@@ -430,6 +430,7 @@ static int paf_aud_decode(AVCodecContext *avctx, void *data,

 AVCodec ff_paf_video_decoder = {

     .name           = "paf_video",

+    .long_name      = NULL_IF_CONFIG_SMALL("Amazing Studio Packed Animation File Video"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_PAF_VIDEO,

     .priv_data_size = sizeof(PAFVideoDecContext),

@@ -437,15 +438,14 @@ AVCodec ff_paf_video_decoder = {

     .close          = paf_vid_close,

     .decode         = paf_vid_decode,

     .capabilities   = CODEC_CAP_DR1,

-    .long_name      = NULL_IF_CONFIG_SMALL("Amazing Studio Packed Animation File Video"),

 };

 AVCodec ff_paf_audio_decoder = {

     .name           = "paf_audio",

+    .long_name      = NULL_IF_CONFIG_SMALL("Amazing Studio Packed Animation File Audio"),

     .type           = AVMEDIA_TYPE_AUDIO,

     .id             = AV_CODEC_ID_PAF_AUDIO,

     .init           = paf_aud_init,

     .decode         = paf_aud_decode,

     .capabilities   = CODEC_CAP_DR1,

-    .long_name      = NULL_IF_CONFIG_SMALL("Amazing Studio Packed Animation File Audio"),

 };

@@ -662,12 +662,12 @@ static av_cold int decode_close(AVCodecContext *avctx)

 AVCodec ff_prores_decoder = {

     .name           = "prores",

+    .long_name      = NULL_IF_CONFIG_SMALL("ProRes"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_PRORES,

     .priv_data_size = sizeof(ProresContext),

     .init           = decode_init,

     .close          = decode_close,

     .decode         = decode_frame,

-    .long_name      = NULL_IF_CONFIG_SMALL("ProRes"),

     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,

 };

@@ -599,6 +599,7 @@ static av_cold int prores_encode_close(AVCodecContext *avctx)

 AVCodec ff_prores_aw_encoder = {

     .name           = "prores_aw",

+    .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_PRORES,

     .priv_data_size = sizeof(ProresContext),

@@ -606,13 +607,13 @@ AVCodec ff_prores_aw_encoder = {

     .close          = prores_encode_close,

     .encode2        = prores_encode_frame,

     .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,

     .profiles       = profiles

 };

 AVCodec ff_prores_encoder = {

     .name           = "prores",

+    .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_PRORES,

     .priv_data_size = sizeof(ProresContext),

@@ -620,7 +621,6 @@ AVCodec ff_prores_encoder = {

     .close          = prores_encode_close,

     .encode2        = prores_encode_frame,

     .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,

     .profiles       = profiles

 };

@@ -112,11 +112,11 @@ AVCodec ff_r10k_decoder = {

 #if CONFIG_AVRP_DECODER

 AVCodec ff_avrp_decoder = {

     .name           = "avrp",

+    .long_name      = NULL_IF_CONFIG_SMALL("Avid 1:1 10-bit RGB Packer"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_AVRP,

     .init           = decode_init,

     .decode         = decode_frame,

     .capabilities   = CODEC_CAP_DR1,

-    .long_name = NULL_IF_CONFIG_SMALL("Avid 1:1 10-bit RGB Packer"),

 };

 #endif

@@ -88,36 +88,36 @@ static av_cold int encode_close(AVCodecContext *avctx)

 #if CONFIG_R210_ENCODER

 AVCodec ff_r210_encoder = {

     .name           = "r210",

+    .long_name      = NULL_IF_CONFIG_SMALL("Uncompressed RGB 10-bit"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_R210,

     .init           = encode_init,

     .encode2        = encode_frame,

     .close          = encode_close,

     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_RGB48, AV_PIX_FMT_NONE },

-    .long_name      = NULL_IF_CONFIG_SMALL("Uncompressed RGB 10-bit"),

 };

 #endif

 #if CONFIG_R10K_ENCODER

 AVCodec ff_r10k_encoder = {

     .name           = "r10k",

+    .long_name      = NULL_IF_CONFIG_SMALL("AJA Kona 10-bit RGB Codec"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_R10K,

     .init           = encode_init,

     .encode2        = encode_frame,

     .close          = encode_close,

     .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

 #if CONFIG_AVRP_ENCODER

 AVCodec ff_avrp_encoder = {

     .name           = "avrp",

+    .long_name      = NULL_IF_CONFIG_SMALL("Avid 1:1 10-bit RGB Packer"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_AVRP,

     .init           = encode_init,

     .encode2        = encode_frame,

     .close          = encode_close,

     .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

@@ -163,12 +163,12 @@ static int s302m_encode2_frame(AVCodecContext *avctx, AVPacket *avpkt,

 AVCodec ff_s302m_encoder = {

     .name                  = "s302m",

+    .long_name             = NULL_IF_CONFIG_SMALL("SMPTE 302M"),

     .type                  = AVMEDIA_TYPE_AUDIO,

     .id                    = CODEC_ID_S302M,

     .priv_data_size        = sizeof(S302MEncContext),

     .init                  = s302m_encode_init,

     .encode2               = s302m_encode2_frame,

-    .long_name             = NULL_IF_CONFIG_SMALL("SMPTE 302M"),

     .sample_fmts           = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S32,

                                                             AV_SAMPLE_FMT_S16,

                                                             AV_SAMPLE_FMT_NONE },

@@ -1296,6 +1296,7 @@ static int decode_frame(AVCodecContext *avctx, void *data,

 AVCodec ff_sanm_decoder = {

     .name           = "sanm",

+    .long_name      = NULL_IF_CONFIG_SMALL("LucasArts SMUSH video"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_SANM,

     .priv_data_size = sizeof(SANMVideoContext),

@@ -1303,5 +1304,4 @@ AVCodec ff_sanm_decoder = {

     .close          = decode_end,

     .decode         = decode_frame,

     .capabilities   = CODEC_CAP_DR1,

-    .long_name      = NULL_IF_CONFIG_SMALL("LucasArts SMUSH video"),

 };

@@ -140,6 +140,7 @@ static av_cold int sgirle_decode_end(AVCodecContext *avctx)

 AVCodec ff_sgirle_decoder = {

     .name           = "sgirle",

+    .long_name      = NULL_IF_CONFIG_SMALL("SGI RLE 8-bit"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_SGIRLE,

     .priv_data_size = sizeof(SGIRLEContext),

@@ -147,5 +148,4 @@ AVCodec ff_sgirle_decoder = {

     .close          = sgirle_decode_end,

     .decode         = sgirle_decode_frame,

     .capabilities   = CODEC_CAP_DR1,

-    .long_name      = NULL_IF_CONFIG_SMALL("SGI RLE 8-bit"),

 };

@@ -194,12 +194,12 @@ static const AVClass smvjpegdec_class = {

 AVCodec ff_smvjpeg_decoder = {

     .name           = "smvjpeg",

+    .long_name      = NULL_IF_CONFIG_SMALL("SMV JPEG"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_SMVJPEG,

     .priv_data_size = sizeof(SMVJpegDecodeContext),

     .init           = smvjpeg_decode_init,

     .close          = smvjpeg_decode_end,

     .decode         = smvjpeg_decode_frame,

-    .long_name      = NULL_IF_CONFIG_SMALL("SMV JPEG"),

     .priv_class     = &smvjpegdec_class,

 };

@@ -587,6 +587,7 @@ static av_cold int decode_end(AVCodecContext *avctx)

 AVCodec ff_snow_decoder = {

     .name           = "snow",

+    .long_name      = NULL_IF_CONFIG_SMALL("Snow"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_SNOW,

     .priv_data_size = sizeof(SnowContext),

@@ -594,5 +595,4 @@ AVCodec ff_snow_decoder = {

     .close          = decode_end,

     .decode         = decode_frame,

     .capabilities   = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,

-    .long_name      = NULL_IF_CONFIG_SMALL("Snow"),

 };

@@ -1878,6 +1878,7 @@ static const AVClass snowenc_class = {

 AVCodec ff_snow_encoder = {

     .name           = "snow",

+    .long_name      = NULL_IF_CONFIG_SMALL("Snow"),

     .type           = AVMEDIA_TYPE_VIDEO,

     .id             = AV_CODEC_ID_SNOW,

     .priv_data_size = sizeof(SnowContext),

@@ -1889,7 +1890,6 @@ AVCodec ff_snow_encoder = {

         AV_PIX_FMT_GRAY8,

         AV_PIX_FMT_NONE

     },

-    .long_name      = NULL_IF_CONFIG_SMALL("Snow"),

     .priv_class     = &snowenc_class,

 };

@@ -947,6 +947,7 @@ static int sonic_decode_frame(AVCodecContext *avctx,

 AVCodec ff_sonic_decoder = {

     .name           = "sonic",

+    .long_name      = NULL_IF_CONFIG_SMALL("Sonic"),

     .type           = AVMEDIA_TYPE_AUDIO,

     .id             = AV_CODEC_ID_SONIC,

     .priv_data_size = sizeof(SonicContext),

@@ -954,13 +955,13 @@ AVCodec ff_sonic_decoder = {

     .close          = sonic_decode_close,

     .decode         = sonic_decode_frame,

     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_EXPERIMENTAL,

-    .long_name = NULL_IF_CONFIG_SMALL("Sonic"),

 };

 #endif /* CONFIG_SONIC_DECODER */

 #if CONFIG_SONIC_ENCODER

 AVCodec ff_sonic_encoder = {

     .name           = "sonic",

+    .long_name      = NULL_IF_CONFIG_SMALL("Sonic"),

     .type           = AVMEDIA_TYPE_AUDIO,

     .id             = AV_CODEC_ID_SONIC,

     .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 },

     .capabilities   = CODEC_CAP_EXPERIMENTAL,

     .close          = sonic_encode_close,

-    .long_name = NULL_IF_CONFIG_SMALL("Sonic"),

 };

 #endif

 #if CONFIG_SONIC_LS_ENCODER

 AVCodec ff_sonic_ls_encoder = {

     .name           = "sonicls",

+    .long_name      = NULL_IF_CONFIG_SMALL("Sonic lossless"),

     .type           = AVMEDIA_TYPE_AUDIO,

     .id             = AV_CODEC_ID_SONIC_LS,