lavf: use designated initialisers for all (de)muxers.
authorAnton Khirnov <anton@khirnov.net>
Sat, 16 Jul 2011 20:18:12 +0000 (22:18 +0200)
committerAnton Khirnov <anton@khirnov.net>
Sun, 17 Jul 2011 04:58:37 +0000 (06:58 +0200)
It's more readable and less prone to breakage.

132 files changed:
libavformat/4xm.c
libavformat/a64.c
libavformat/aacdec.c
libavformat/ac3dec.c
libavformat/adtsenc.c
libavformat/aea.c
libavformat/aiffdec.c
libavformat/aiffenc.c
libavformat/amr.c
libavformat/anm.c
libavformat/apc.c
libavformat/ape.c
libavformat/applehttp.c
libavformat/asfdec.c
libavformat/asfenc.c
libavformat/au.c
libavformat/avidec.c
libavformat/avienc.c
libavformat/avisynth.c
libavformat/avs.c
libavformat/bethsoftvid.c
libavformat/bfi.c
libavformat/bink.c
libavformat/c93.c
libavformat/cafdec.c
libavformat/cdg.c
libavformat/crcenc.c
libavformat/daud.c
libavformat/dfa.c
libavformat/dsicin.c
libavformat/dtsdec.c
libavformat/dv.c
libavformat/dvenc.c
libavformat/dxa.c
libavformat/eacdata.c
libavformat/electronicarts.c
libavformat/ffmdec.c
libavformat/ffmenc.c
libavformat/filmstripdec.c
libavformat/filmstripenc.c
libavformat/flacdec.c
libavformat/flacenc.c
libavformat/flic.c
libavformat/flvdec.c
libavformat/flvenc.c
libavformat/framecrcenc.c
libavformat/gif.c
libavformat/gxf.c
libavformat/gxfenc.c
libavformat/idcin.c
libavformat/idroqdec.c
libavformat/iff.c
libavformat/ingenientdec.c
libavformat/ipmovie.c
libavformat/iss.c
libavformat/iv8.c
libavformat/ivfdec.c
libavformat/libnut.c
libavformat/lmlm4.c
libavformat/matroskadec.c
libavformat/matroskaenc.c
libavformat/md5enc.c
libavformat/mm.c
libavformat/mmf.c
libavformat/mov.c
libavformat/movenc.c
libavformat/mp3dec.c
libavformat/mp3enc.c
libavformat/mpc.c
libavformat/mpc8.c
libavformat/mpeg.c
libavformat/mpegenc.c
libavformat/mpegts.c
libavformat/mpegtsenc.c
libavformat/mpjpeg.c
libavformat/msnwc_tcp.c
libavformat/mtv.c
libavformat/mvi.c
libavformat/mxfdec.c
libavformat/mxfenc.c
libavformat/ncdec.c
libavformat/nsvdec.c
libavformat/nullenc.c
libavformat/nutdec.c
libavformat/nutenc.c
libavformat/nuv.c
libavformat/oggenc.c
libavformat/oma.c
libavformat/psxstr.c
libavformat/pva.c
libavformat/r3d.c
libavformat/rawdec.c
libavformat/rawenc.c
libavformat/rawvideodec.c
libavformat/rl2.c
libavformat/rmdec.c
libavformat/rmenc.c
libavformat/rpl.c
libavformat/rtpenc.c
libavformat/rtsp.c
libavformat/rtspdec.c
libavformat/rtspenc.c
libavformat/sapdec.c
libavformat/sapenc.c
libavformat/segafilm.c
libavformat/sierravmd.c
libavformat/siff.c
libavformat/smacker.c
libavformat/sol.c
libavformat/soxdec.c
libavformat/soxenc.c
libavformat/spdifdec.c
libavformat/spdifenc.c
libavformat/swfdec.c
libavformat/swfenc.c
libavformat/thp.c
libavformat/tiertexseq.c
libavformat/tmv.c
libavformat/tta.c
libavformat/vc1test.c
libavformat/vc1testenc.c
libavformat/vocdec.c
libavformat/vocenc.c
libavformat/vqf.c
libavformat/wav.c
libavformat/wc3movie.c
libavformat/westwood.c
libavformat/wv.c
libavformat/xa.c
libavformat/xwma.c
libavformat/yop.c
libavformat/yuv4mpeg.c

index 32699da..6224134 100644 (file)
@@ -345,11 +345,11 @@ static int fourxm_read_close(AVFormatContext *s)
 }
 
 AVInputFormat ff_fourxm_demuxer = {
-    "4xm",
-    NULL_IF_CONFIG_SMALL("4X Technologies format"),
-    sizeof(FourxmDemuxContext),
-    fourxm_probe,
-    fourxm_read_header,
-    fourxm_read_packet,
-    fourxm_read_close,
+    .name           = "4xm",
+    .long_name      = NULL_IF_CONFIG_SMALL("4X Technologies format"),
+    .priv_data_size = sizeof(FourxmDemuxContext),
+    .read_probe     = fourxm_probe,
+    .read_header    = fourxm_read_header,
+    .read_packet    = fourxm_read_packet,
+    .read_close     = fourxm_read_close,
 };
index 3d313e5..4b4981e 100644 (file)
@@ -170,7 +170,7 @@ AVOutputFormat ff_a64_muxer = {
     .extensions = "a64, A64",
     .priv_data_size = sizeof (A64Context),
     .video_codec = CODEC_ID_A64_MULTI,
-    a64_write_header,
-    a64_write_packet,
-    a64_write_trailer
+    .write_header  = a64_write_header,
+    .write_packet  = a64_write_packet,
+    .write_trailer = a64_write_trailer
 };
index 6a184c7..0c96fa4 100644 (file)
@@ -82,12 +82,11 @@ static int adts_aac_read_header(AVFormatContext *s,
 }
 
 AVInputFormat ff_aac_demuxer = {
-    "aac",
-    NULL_IF_CONFIG_SMALL("raw ADTS AAC"),
-    0,
-    adts_aac_probe,
-    adts_aac_read_header,
-    ff_raw_read_partial_packet,
+    .name           = "aac",
+    .long_name      = NULL_IF_CONFIG_SMALL("raw ADTS AAC"),
+    .read_probe     = adts_aac_probe,
+    .read_header    = adts_aac_read_header,
+    .read_packet    = ff_raw_read_partial_packet,
     .flags= AVFMT_GENERIC_INDEX,
     .extensions = "aac",
     .value = CODEC_ID_AAC,
index 7ed0102..2cb068e 100644 (file)
@@ -71,12 +71,11 @@ static int ac3_probe(AVProbeData *p)
 }
 
 AVInputFormat ff_ac3_demuxer = {
-    "ac3",
-    NULL_IF_CONFIG_SMALL("raw AC-3"),
-    0,
-    ac3_probe,
-    ff_raw_audio_read_header,
-    ff_raw_read_partial_packet,
+    .name           = "ac3",
+    .long_name      = NULL_IF_CONFIG_SMALL("raw AC-3"),
+    .read_probe     = ac3_probe,
+    .read_header    = ff_raw_audio_read_header,
+    .read_packet    = ff_raw_read_partial_packet,
     .flags= AVFMT_GENERIC_INDEX,
     .extensions = "ac3",
     .value = CODEC_ID_AC3,
@@ -90,12 +89,11 @@ static int eac3_probe(AVProbeData *p)
 }
 
 AVInputFormat ff_eac3_demuxer = {
-    "eac3",
-    NULL_IF_CONFIG_SMALL("raw E-AC-3"),
-    0,
-    eac3_probe,
-    ff_raw_audio_read_header,
-    ff_raw_read_partial_packet,
+    .name           = "eac3",
+    .long_name      = NULL_IF_CONFIG_SMALL("raw E-AC-3"),
+    .read_probe     = eac3_probe,
+    .read_header    = ff_raw_audio_read_header,
+    .read_packet    = ff_raw_read_partial_packet,
     .flags= AVFMT_GENERIC_INDEX,
     .extensions = "eac3",
     .value = CODEC_ID_EAC3,
index 75649e2..7f61e94 100644 (file)
@@ -142,13 +142,13 @@ static int adts_write_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVOutputFormat ff_adts_muxer = {
-    "adts",
-    NULL_IF_CONFIG_SMALL("ADTS AAC"),
-    "audio/aac",
-    "aac,adts",
-    sizeof(ADTSContext),
-    CODEC_ID_AAC,
-    CODEC_ID_NONE,
-    adts_write_header,
-    adts_write_packet,
+    .name              = "adts",
+    .long_name         = NULL_IF_CONFIG_SMALL("ADTS AAC"),
+    .mime_type         = "audio/aac",
+    .extensions        = "aac,adts",
+    .priv_data_size    = sizeof(ADTSContext),
+    .audio_codec       = CODEC_ID_AAC,
+    .video_codec       = CODEC_ID_NONE,
+    .write_header      = adts_write_header,
+    .write_packet      = adts_write_packet,
 };
index c6dfbb1..e2d853b 100644 (file)
@@ -95,14 +95,12 @@ static int aea_read_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_aea_demuxer = {
-    "aea",
-    NULL_IF_CONFIG_SMALL("MD STUDIO audio"),
-    0,
-    aea_read_probe,
-    aea_read_header,
-    aea_read_packet,
-    0,
-    pcm_read_seek,
+    .name           = "aea",
+    .long_name      = NULL_IF_CONFIG_SMALL("MD STUDIO audio"),
+    .read_probe     = aea_read_probe,
+    .read_header    = aea_read_header,
+    .read_packet    = aea_read_packet,
+    .read_seek      = pcm_read_seek,
     .flags= AVFMT_GENERIC_INDEX,
     .extensions = "aea",
 };
index 0e81542..34e6d88 100644 (file)
@@ -313,13 +313,12 @@ static int aiff_read_packet(AVFormatContext *s,
 }
 
 AVInputFormat ff_aiff_demuxer = {
-    "aiff",
-    NULL_IF_CONFIG_SMALL("Audio IFF"),
-    sizeof(AIFFInputContext),
-    aiff_probe,
-    aiff_read_header,
-    aiff_read_packet,
-    NULL,
-    pcm_read_seek,
+    .name           = "aiff",
+    .long_name      = NULL_IF_CONFIG_SMALL("Audio IFF"),
+    .priv_data_size = sizeof(AIFFInputContext),
+    .read_probe     = aiff_probe,
+    .read_header    = aiff_read_header,
+    .read_packet    = aiff_read_packet,
+    .read_seek      = pcm_read_seek,
     .codec_tag= (const AVCodecTag* const []){ff_codec_aiff_tags, 0},
 };
index 5a64688..fbe1491 100644 (file)
@@ -148,15 +148,15 @@ static int aiff_write_trailer(AVFormatContext *s)
 }
 
 AVOutputFormat ff_aiff_muxer = {
-    "aiff",
-    NULL_IF_CONFIG_SMALL("Audio IFF"),
-    "audio/aiff",
-    "aif,aiff,afc,aifc",
-    sizeof(AIFFOutputContext),
-    CODEC_ID_PCM_S16BE,
-    CODEC_ID_NONE,
-    aiff_write_header,
-    aiff_write_packet,
-    aiff_write_trailer,
+    .name              = "aiff",
+    .long_name         = NULL_IF_CONFIG_SMALL("Audio IFF"),
+    .mime_type         = "audio/aiff",
+    .extensions        = "aif,aiff,afc,aifc",
+    .priv_data_size    = sizeof(AIFFOutputContext),
+    .audio_codec       = CODEC_ID_PCM_S16BE,
+    .video_codec       = CODEC_ID_NONE,
+    .write_header      = aiff_write_header,
+    .write_packet      = aiff_write_packet,
+    .write_trailer     = aiff_write_trailer,
     .codec_tag= (const AVCodecTag* const []){ff_codec_aiff_tags, 0},
 };
index 260bd6a..e9c74ca 100644 (file)
@@ -174,27 +174,25 @@ static int amr_read_packet(AVFormatContext *s,
 
 #if CONFIG_AMR_DEMUXER
 AVInputFormat ff_amr_demuxer = {
-    "amr",
-    NULL_IF_CONFIG_SMALL("3GPP AMR file format"),
-    0, /*priv_data_size*/
-    amr_probe,
-    amr_read_header,
-    amr_read_packet,
-    NULL,
+    .name           = "amr",
+    .long_name      = NULL_IF_CONFIG_SMALL("3GPP AMR file format"),
+    .priv_data_size = 0, /*priv_data_size*/
+    .read_probe     = amr_probe,
+    .read_header    = amr_read_header,
+    .read_packet    = amr_read_packet,
     .flags = AVFMT_GENERIC_INDEX,
 };
 #endif
 
 #if CONFIG_AMR_MUXER
 AVOutputFormat ff_amr_muxer = {
-    "amr",
-    NULL_IF_CONFIG_SMALL("3GPP AMR file format"),
-    "audio/amr",
-    "amr",
-    0,
-    CODEC_ID_AMR_NB,
-    CODEC_ID_NONE,
-    amr_write_header,
-    amr_write_packet,
+    .name              = "amr",
+    .long_name         = NULL_IF_CONFIG_SMALL("3GPP AMR file format"),
+    .mime_type         = "audio/amr",
+    .extensions        = "amr",
+    .audio_codec       = CODEC_ID_AMR_NB,
+    .video_codec       = CODEC_ID_NONE,
+    .write_header      = amr_write_header,
+    .write_packet      = amr_write_packet,
 };
 #endif
index 4d1b5f7..f24caf1 100644 (file)
@@ -226,10 +226,10 @@ repeat:
 }
 
 AVInputFormat ff_anm_demuxer = {
-    "anm",
-    NULL_IF_CONFIG_SMALL("Deluxe Paint Animation"),
-    sizeof(AnmDemuxContext),
-    probe,
-    read_header,
-    read_packet,
+    .name           = "anm",
+    .long_name      = NULL_IF_CONFIG_SMALL("Deluxe Paint Animation"),
+    .priv_data_size = sizeof(AnmDemuxContext),
+    .read_probe     = probe,
+    .read_header    = read_header,
+    .read_packet    = read_packet,
 };
index 40c6f0c..1098516 100644 (file)
@@ -81,10 +81,9 @@ static int apc_read_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_apc_demuxer = {
-    "apc",
-    NULL_IF_CONFIG_SMALL("CRYO APC format"),
-    0,
-    apc_probe,
-    apc_read_header,
-    apc_read_packet,
+    .name           = "apc",
+    .long_name      = NULL_IF_CONFIG_SMALL("CRYO APC format"),
+    .read_probe     = apc_probe,
+    .read_header    = apc_read_header,
+    .read_packet    = apc_read_packet,
 };
index 90b0261..6787416 100644 (file)
@@ -405,13 +405,13 @@ static int ape_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp
 }
 
 AVInputFormat ff_ape_demuxer = {
-    "ape",
-    NULL_IF_CONFIG_SMALL("Monkey's Audio"),
-    sizeof(APEContext),
-    ape_probe,
-    ape_read_header,
-    ape_read_packet,
-    ape_read_close,
-    ape_read_seek,
+    .name           = "ape",
+    .long_name      = NULL_IF_CONFIG_SMALL("Monkey's Audio"),
+    .priv_data_size = sizeof(APEContext),
+    .read_probe     = ape_probe,
+    .read_header    = ape_read_header,
+    .read_packet    = ape_read_packet,
+    .read_close     = ape_read_close,
+    .read_seek      = ape_read_seek,
     .extensions = "ape,apl,mac"
 };
index 7e0c930..906511e 100644 (file)
@@ -668,12 +668,12 @@ static int applehttp_probe(AVProbeData *p)
 }
 
 AVInputFormat ff_applehttp_demuxer = {
-    "applehttp",
-    NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming format"),
-    sizeof(AppleHTTPContext),
-    applehttp_probe,
-    applehttp_read_header,
-    applehttp_read_packet,
-    applehttp_close,
-    applehttp_read_seek,
+    .name           = "applehttp",
+    .long_name      = NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming format"),
+    .priv_data_size = sizeof(AppleHTTPContext),
+    .read_probe     = applehttp_probe,
+    .read_header    = applehttp_read_header,
+    .read_packet    = applehttp_read_packet,
+    .read_close     = applehttp_close,
+    .read_seek      = applehttp_read_seek,
 };
index ac559a0..a35290b 100644 (file)
@@ -1289,14 +1289,14 @@ static int asf_read_seek(AVFormatContext *s, int stream_index, int64_t pts, int
 }
 
 AVInputFormat ff_asf_demuxer = {
-    "asf",
-    NULL_IF_CONFIG_SMALL("ASF format"),
-    sizeof(ASFContext),
-    asf_probe,
-    asf_read_header,
-    asf_read_packet,
-    asf_read_close,
-    asf_read_seek,
-    asf_read_pts,
+    .name           = "asf",
+    .long_name      = NULL_IF_CONFIG_SMALL("ASF format"),
+    .priv_data_size = sizeof(ASFContext),
+    .read_probe     = asf_probe,
+    .read_header    = asf_read_header,
+    .read_packet    = asf_read_packet,
+    .read_close     = asf_read_close,
+    .read_seek      = asf_read_seek,
+    .read_timestamp = asf_read_pts,
     .flags = AVFMT_NOBINSEARCH | AVFMT_NOGENSEARCH,
 };
index f9b9b3c..cbd9cb6 100644 (file)
@@ -882,20 +882,20 @@ static int asf_write_trailer(AVFormatContext *s)
 
 #if CONFIG_ASF_MUXER
 AVOutputFormat ff_asf_muxer = {
-    "asf",
-    NULL_IF_CONFIG_SMALL("ASF format"),
-    "video/x-ms-asf",
-    "asf,wmv,wma",
-    sizeof(ASFContext),
+    .name           = "asf",
+    .long_name      = NULL_IF_CONFIG_SMALL("ASF format"),
+    .mime_type      = "video/x-ms-asf",
+    .extensions     = "asf,wmv,wma",
+    .priv_data_size = sizeof(ASFContext),
 #if CONFIG_LIBMP3LAME
-    CODEC_ID_MP3,
+    .audio_codec    = CODEC_ID_MP3,
 #else
-    CODEC_ID_MP2,
+    .audio_codec    = CODEC_ID_MP2,
 #endif
-    CODEC_ID_MSMPEG4V3,
-    asf_write_header,
-    asf_write_packet,
-    asf_write_trailer,
+    .video_codec    = CODEC_ID_MSMPEG4V3,
+    .write_header   = asf_write_header,
+    .write_packet   = asf_write_packet,
+    .write_trailer  = asf_write_trailer,
     .flags = AVFMT_GLOBALHEADER,
     .codec_tag= (const AVCodecTag* const []){codec_asf_bmp_tags, ff_codec_bmp_tags, ff_codec_wav_tags, 0},
 };
@@ -903,20 +903,20 @@ AVOutputFormat ff_asf_muxer = {
 
 #if CONFIG_ASF_STREAM_MUXER
 AVOutputFormat ff_asf_stream_muxer = {
-    "asf_stream",
-    NULL_IF_CONFIG_SMALL("ASF format"),
-    "video/x-ms-asf",
-    "asf,wmv,wma",
-    sizeof(ASFContext),
+    .name           = "asf_stream",
+    .long_name      = NULL_IF_CONFIG_SMALL("ASF format"),
+    .mime_type      = "video/x-ms-asf",
+    .extensions     = "asf,wmv,wma",
+    .priv_data_size = sizeof(ASFContext),
 #if CONFIG_LIBMP3LAME
-    CODEC_ID_MP3,
+    .audio_codec    = CODEC_ID_MP3,
 #else
-    CODEC_ID_MP2,
+    .audio_codec    = CODEC_ID_MP2,
 #endif
-    CODEC_ID_MSMPEG4V3,
-    asf_write_stream_header,
-    asf_write_packet,
-    asf_write_trailer,
+    .video_codec    = CODEC_ID_MSMPEG4V3,
+    .write_header   = asf_write_stream_header,
+    .write_packet   = asf_write_packet,
+    .write_trailer  = asf_write_trailer,
     .flags = AVFMT_GLOBALHEADER,
     .codec_tag= (const AVCodecTag* const []){codec_asf_bmp_tags, ff_codec_bmp_tags, ff_codec_wav_tags, 0},
 };
index 6cffe1c..d8765e3 100644 (file)
@@ -185,30 +185,27 @@ static int au_read_packet(AVFormatContext *s,
 
 #if CONFIG_AU_DEMUXER
 AVInputFormat ff_au_demuxer = {
-    "au",
-    NULL_IF_CONFIG_SMALL("SUN AU format"),
-    0,
-    au_probe,
-    au_read_header,
-    au_read_packet,
-    NULL,
-    pcm_read_seek,
+    .name           = "au",
+    .long_name      = NULL_IF_CONFIG_SMALL("SUN AU format"),
+    .read_probe     = au_probe,
+    .read_header    = au_read_header,
+    .read_packet    = au_read_packet,
+    .read_seek      = pcm_read_seek,
     .codec_tag= (const AVCodecTag* const []){codec_au_tags, 0},
 };
 #endif
 
 #if CONFIG_AU_MUXER
 AVOutputFormat ff_au_muxer = {
-    "au",
-    NULL_IF_CONFIG_SMALL("SUN AU format"),
-    "audio/basic",
-    "au",
-    0,
-    CODEC_ID_PCM_S16BE,
-    CODEC_ID_NONE,
-    au_write_header,
-    au_write_packet,
-    au_write_trailer,
+    .name              = "au",
+    .long_name         = NULL_IF_CONFIG_SMALL("SUN AU format"),
+    .mime_type         = "audio/basic",
+    .extensions        = "au",
+    .audio_codec       = CODEC_ID_PCM_S16BE,
+    .video_codec       = CODEC_ID_NONE,
+    .write_header      = au_write_header,
+    .write_packet      = au_write_packet,
+    .write_trailer     = au_write_trailer,
     .codec_tag= (const AVCodecTag* const []){codec_au_tags, 0},
 };
 #endif //CONFIG_AU_MUXER
index 2ea156e..0ea093c 100644 (file)
@@ -1389,12 +1389,12 @@ static int avi_probe(AVProbeData *p)
 }
 
 AVInputFormat ff_avi_demuxer = {
-    "avi",
-    NULL_IF_CONFIG_SMALL("AVI format"),
-    sizeof(AVIContext),
-    avi_probe,
-    avi_read_header,
-    avi_read_packet,
-    avi_read_close,
-    avi_read_seek,
+    .name           = "avi",
+    .long_name      = NULL_IF_CONFIG_SMALL("AVI format"),
+    .priv_data_size = sizeof(AVIContext),
+    .read_probe     = avi_probe,
+    .read_header    = avi_read_header,
+    .read_packet    = avi_read_packet,
+    .read_close     = avi_read_close,
+    .read_seek      = avi_read_seek,
 };
index 343396c..1dbed8b 100644 (file)
@@ -639,16 +639,16 @@ static int avi_write_trailer(AVFormatContext *s)
 }
 
 AVOutputFormat ff_avi_muxer = {
-    "avi",
-    NULL_IF_CONFIG_SMALL("AVI format"),
-    "video/x-msvideo",
-    "avi",
-    sizeof(AVIContext),
-    CODEC_ID_MP2,
-    CODEC_ID_MPEG4,
-    avi_write_header,
-    avi_write_packet,
-    avi_write_trailer,
+    .name              = "avi",
+    .long_name         = NULL_IF_CONFIG_SMALL("AVI format"),
+    .mime_type         = "video/x-msvideo",
+    .extensions        = "avi",
+    .priv_data_size    = sizeof(AVIContext),
+    .audio_codec       = CODEC_ID_MP2,
+    .video_codec       = CODEC_ID_MPEG4,
+    .write_header      = avi_write_header,
+    .write_packet      = avi_write_packet,
+    .write_trailer     = avi_write_trailer,
     .codec_tag= (const AVCodecTag* const []){ff_codec_bmp_tags, ff_codec_wav_tags, 0},
     .flags= AVFMT_VARIABLE_FPS,
 };
index 5e6f6bf..b615796 100644 (file)
@@ -208,15 +208,12 @@ static int avisynth_read_seek(AVFormatContext *s, int stream_index, int64_t pts,
 }
 
 AVInputFormat ff_avisynth_demuxer = {
-  "avs",
-  NULL_IF_CONFIG_SMALL("AVISynth"),
-  sizeof(AVISynthContext),
-  NULL,
-  avisynth_read_header,
-  avisynth_read_packet,
-  avisynth_read_close,
-  avisynth_read_seek,
-  NULL,
-  0,
-  "avs",
+    .name           = "avs",
+    .long_name      = NULL_IF_CONFIG_SMALL("AVISynth"),
+    .priv_data_size = sizeof(AVISynthContext),
+    .read_header    = avisynth_read_header,
+    .read_packet    = avisynth_read_packet,
+    .read_close     = avisynth_read_close,
+    .read_seek      = avisynth_read_seek,
+    .extensions     = "avs",
 };
index bd9b31d..bf3d4f9 100644 (file)
@@ -216,11 +216,11 @@ static int avs_read_close(AVFormatContext * s)
 }
 
 AVInputFormat ff_avs_demuxer = {
-    "avs",
-    NULL_IF_CONFIG_SMALL("AVS format"),
-    sizeof(AvsFormat),
-    avs_probe,
-    avs_read_header,
-    avs_read_packet,
-    avs_read_close,
+    .name           = "avs",
+    .long_name      = NULL_IF_CONFIG_SMALL("AVS format"),
+    .priv_data_size = sizeof(AvsFormat),
+    .read_probe     = avs_probe,
+    .read_header    = avs_read_header,
+    .read_packet    = avs_read_packet,
+    .read_close     = avs_read_close,
 };
index 73564c9..05243cc 100644 (file)
@@ -223,10 +223,10 @@ static int vid_read_packet(AVFormatContext *s,
 }
 
 AVInputFormat ff_bethsoftvid_demuxer = {
-    "bethsoftvid",
-    NULL_IF_CONFIG_SMALL("Bethesda Softworks VID format"),
-    sizeof(BVID_DemuxContext),
-    vid_probe,
-    vid_read_header,
-    vid_read_packet,
+    .name           = "bethsoftvid",
+    .long_name      = NULL_IF_CONFIG_SMALL("Bethesda Softworks VID format"),
+    .priv_data_size = sizeof(BVID_DemuxContext),
+    .read_probe     = vid_probe,
+    .read_header    = vid_read_header,
+    .read_packet    = vid_read_packet,
 };
index 72df8b2..7a02c23 100644 (file)
@@ -159,10 +159,10 @@ static int bfi_read_packet(AVFormatContext * s, AVPacket * pkt)
 }
 
 AVInputFormat ff_bfi_demuxer = {
-    "bfi",
-    NULL_IF_CONFIG_SMALL("Brute Force & Ignorance"),
-    sizeof(BFIContext),
-    bfi_probe,
-    bfi_read_header,
-    bfi_read_packet,
+    .name           = "bfi",
+    .long_name      = NULL_IF_CONFIG_SMALL("Brute Force & Ignorance"),
+    .priv_data_size = sizeof(BFIContext),
+    .read_probe     = bfi_probe,
+    .read_header    = bfi_read_header,
+    .read_packet    = bfi_read_packet,
 };
index 0676738..b576555 100644 (file)
@@ -264,12 +264,11 @@ static int read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, in
 }
 
 AVInputFormat ff_bink_demuxer = {
-    "bink",
-    NULL_IF_CONFIG_SMALL("Bink"),
-    sizeof(BinkDemuxContext),
-    probe,
-    read_header,
-    read_packet,
-    NULL,
-    read_seek,
+    .name           = "bink",
+    .long_name      = NULL_IF_CONFIG_SMALL("Bink"),
+    .priv_data_size = sizeof(BinkDemuxContext),
+    .read_probe     = probe,
+    .read_header    = read_header,
+    .read_packet    = read_packet,
+    .read_seek      = read_seek,
 };
index 097565a..6cf448f 100644 (file)
@@ -193,10 +193,10 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_c93_demuxer = {
-    "c93",
-    NULL_IF_CONFIG_SMALL("Interplay C93"),
-    sizeof(C93DemuxContext),
-    probe,
-    read_header,
-    read_packet,
+    .name           = "c93",
+    .long_name      = NULL_IF_CONFIG_SMALL("Interplay C93"),
+    .priv_data_size = sizeof(C93DemuxContext),
+    .read_probe     = probe,
+    .read_header    = read_header,
+    .read_packet    = read_packet,
 };
index 68686ca..38cde3b 100644 (file)
@@ -384,13 +384,12 @@ static int read_seek(AVFormatContext *s, int stream_index,
 }
 
 AVInputFormat ff_caf_demuxer = {
-    "caf",
-    NULL_IF_CONFIG_SMALL("Apple Core Audio Format"),
-    sizeof(CaffContext),
-    probe,
-    read_header,
-    read_packet,
-    NULL,
-    read_seek,
+    .name           = "caf",
+    .long_name      = NULL_IF_CONFIG_SMALL("Apple Core Audio Format"),
+    .priv_data_size = sizeof(CaffContext),
+    .read_probe     = probe,
+    .read_header    = read_header,
+    .read_packet    = read_packet,
+    .read_seek      = read_seek,
     .codec_tag = (const AVCodecTag*[]){ff_codec_caf_tags, 0},
 };
index b47a20e..1504967 100644 (file)
@@ -56,11 +56,9 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_cdg_demuxer = {
-    "cdg",
-    NULL_IF_CONFIG_SMALL("CD Graphics Format"),
-    0,
-    NULL,
-    read_header,
-    read_packet,
+    .name           = "cdg",
+    .long_name      = NULL_IF_CONFIG_SMALL("CD Graphics Format"),
+    .read_header    = read_header,
+    .read_packet    = read_packet,
     .extensions = "cdg"
 };
index 55c99d9..ae688e4 100644 (file)
@@ -55,14 +55,13 @@ static int crc_write_trailer(struct AVFormatContext *s)
 }
 
 AVOutputFormat ff_crc_muxer = {
-    "crc",
-    NULL_IF_CONFIG_SMALL("CRC testing format"),
-    NULL,
-    "",
-    sizeof(CRCState),
-    CODEC_ID_PCM_S16LE,
-    CODEC_ID_RAWVIDEO,
-    crc_write_header,
-    crc_write_packet,
-    crc_write_trailer,
+    .name              = "crc",
+    .long_name         = NULL_IF_CONFIG_SMALL("CRC testing format"),
+    .extensions        = "",
+    .priv_data_size    = sizeof(CRCState),
+    .audio_codec       = CODEC_ID_PCM_S16LE,
+    .video_codec       = CODEC_ID_RAWVIDEO,
+    .write_header      = crc_write_header,
+    .write_packet      = crc_write_packet,
+    .write_trailer     = crc_write_trailer,
 };
index 1b3cfcf..9421d18 100644 (file)
@@ -71,14 +71,10 @@ static int daud_write_packet(struct AVFormatContext *s, AVPacket *pkt)
 
 #if CONFIG_DAUD_DEMUXER
 AVInputFormat ff_daud_demuxer = {
-    "daud",
-    NULL_IF_CONFIG_SMALL("D-Cinema audio format"),
-    0,
-    NULL,
-    daud_header,
-    daud_packet,
-    NULL,
-    NULL,
+    .name           = "daud",
+    .long_name      = NULL_IF_CONFIG_SMALL("D-Cinema audio format"),
+    .read_header    = daud_header,
+    .read_packet    = daud_packet,
     .extensions = "302",
 };
 #endif
index 8108535..cd925e0 100644 (file)
@@ -109,11 +109,10 @@ static int dfa_read_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_dfa_demuxer = {
-    "dfa",
-    NULL_IF_CONFIG_SMALL("Chronomaster DFA"),
-    0,
-    dfa_probe,
-    dfa_read_header,
-    dfa_read_packet,
+    .name           = "dfa",
+    .long_name      = NULL_IF_CONFIG_SMALL("Chronomaster DFA"),
+    .read_probe     = dfa_probe,
+    .read_header    = dfa_read_header,
+    .read_packet    = dfa_read_packet,
     .flags = AVFMT_GENERIC_INDEX,
 };
index d02de46..a82ac4c 100644 (file)
@@ -217,10 +217,10 @@ static int cin_read_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_dsicin_demuxer = {
-    "dsicin",
-    NULL_IF_CONFIG_SMALL("Delphine Software International CIN format"),
-    sizeof(CinDemuxContext),
-    cin_probe,
-    cin_read_header,
-    cin_read_packet,
+    .name           = "dsicin",
+    .long_name      = NULL_IF_CONFIG_SMALL("Delphine Software International CIN format"),
+    .priv_data_size = sizeof(CinDemuxContext),
+    .read_probe     = cin_probe,
+    .read_header    = cin_read_header,
+    .read_packet    = cin_read_packet,
 };
index 943f6a5..d61855d 100644 (file)
@@ -66,12 +66,11 @@ static int dts_probe(AVProbeData *p)
 }
 
 AVInputFormat ff_dts_demuxer = {
-    "dts",
-    NULL_IF_CONFIG_SMALL("raw DTS"),
-    0,
-    dts_probe,
-    ff_raw_audio_read_header,
-    ff_raw_read_partial_packet,
+    .name           = "dts",
+    .long_name      = NULL_IF_CONFIG_SMALL("raw DTS"),
+    .read_probe     = dts_probe,
+    .read_header    = ff_raw_audio_read_header,
+    .read_packet    = ff_raw_read_partial_packet,
     .flags= AVFMT_GENERIC_INDEX,
     .extensions = "dts",
     .value = CODEC_ID_DTS,
index f38b954..384e4dc 100644 (file)
@@ -520,14 +520,14 @@ static int dv_probe(AVProbeData *p)
 
 #if CONFIG_DV_DEMUXER
 AVInputFormat ff_dv_demuxer = {
-    "dv",
-    NULL_IF_CONFIG_SMALL("DV video format"),
-    sizeof(RawDVContext),
-    dv_probe,
-    dv_read_header,
-    dv_read_packet,
-    dv_read_close,
-    dv_read_seek,
+    .name           = "dv",
+    .long_name      = NULL_IF_CONFIG_SMALL("DV video format"),
+    .priv_data_size = sizeof(RawDVContext),
+    .read_probe     = dv_probe,
+    .read_header    = dv_read_header,
+    .read_packet    = dv_read_packet,
+    .read_close     = dv_read_close,
+    .read_seek      = dv_read_seek,
     .extensions = "dv,dif",
 };
 #endif
index 5aab683..15b659b 100644 (file)
@@ -408,14 +408,13 @@ static int dv_write_trailer(struct AVFormatContext *s)
 }
 
 AVOutputFormat ff_dv_muxer = {
-    "dv",
-    NULL_IF_CONFIG_SMALL("DV video format"),
-    NULL,
-    "dv",
-    sizeof(DVMuxContext),
-    CODEC_ID_PCM_S16LE,
-    CODEC_ID_DVVIDEO,
-    dv_write_header,
-    dv_write_packet,
-    dv_write_trailer,
+    .name              = "dv",
+    .long_name         = NULL_IF_CONFIG_SMALL("DV video format"),
+    .extensions        = "dv",
+    .priv_data_size    = sizeof(DVMuxContext),
+    .audio_codec       = CODEC_ID_PCM_S16LE,
+    .video_codec       = CODEC_ID_DVVIDEO,
+    .write_header      = dv_write_header,
+    .write_packet      = dv_write_packet,
+    .write_trailer     = dv_write_trailer,
 };
index 1e1d505..375b039 100644 (file)
@@ -213,10 +213,10 @@ static int dxa_read_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_dxa_demuxer = {
-    "dxa",
-    NULL_IF_CONFIG_SMALL("DXA"),
-    sizeof(DXAContext),
-    dxa_probe,
-    dxa_read_header,
-    dxa_read_packet,
+    .name           = "dxa",
+    .long_name      = NULL_IF_CONFIG_SMALL("DXA"),
+    .priv_data_size = sizeof(DXAContext),
+    .read_probe     = dxa_probe,
+    .read_header    = dxa_read_header,
+    .read_packet    = dxa_read_packet,
 };
index 5c89559..56f4e27 100644 (file)
@@ -91,11 +91,11 @@ static int cdata_read_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_ea_cdata_demuxer = {
-    "ea_cdata",
-    NULL_IF_CONFIG_SMALL("Electronic Arts cdata"),
-    sizeof(CdataDemuxContext),
-    cdata_probe,
-    cdata_read_header,
-    cdata_read_packet,
+    .name           = "ea_cdata",
+    .long_name      = NULL_IF_CONFIG_SMALL("Electronic Arts cdata"),
+    .priv_data_size = sizeof(CdataDemuxContext),
+    .read_probe     = cdata_probe,
+    .read_header    = cdata_read_header,
+    .read_packet    = cdata_read_packet,
     .extensions = "cdata",
 };
index 06689dd..b6d6a84 100644 (file)
@@ -569,10 +569,10 @@ get_video_packet:
 }
 
 AVInputFormat ff_ea_demuxer = {
-    "ea",
-    NULL_IF_CONFIG_SMALL("Electronic Arts Multimedia Format"),
-    sizeof(EaDemuxContext),
-    ea_probe,
-    ea_read_header,
-    ea_read_packet,
+    .name           = "ea",
+    .long_name      = NULL_IF_CONFIG_SMALL("Electronic Arts Multimedia Format"),
+    .priv_data_size = sizeof(EaDemuxContext),
+    .read_probe     = ea_probe,
+    .read_header    = ea_read_header,
+    .read_packet    = ea_read_packet,
 };
index ed93270..9168ac5 100644 (file)
@@ -509,12 +509,12 @@ static int ffm_probe(AVProbeData *p)
 }
 
 AVInputFormat ff_ffm_demuxer = {
-    "ffm",
-    NULL_IF_CONFIG_SMALL("FFM (FFserver live feed) format"),
-    sizeof(FFMContext),
-    ffm_probe,
-    ffm_read_header,
-    ffm_read_packet,
-    ffm_close,
-    ffm_seek,
+    .name           = "ffm",
+    .long_name      = NULL_IF_CONFIG_SMALL("FFM (FFserver live feed) format"),
+    .priv_data_size = sizeof(FFMContext),
+    .read_probe     = ffm_probe,
+    .read_header    = ffm_read_header,
+    .read_packet    = ffm_read_packet,
+    .read_close     = ffm_close,
+    .read_seek      = ffm_seek,
 };
index a31ac8e..87a477f 100644 (file)
@@ -241,15 +241,14 @@ static int ffm_write_trailer(AVFormatContext *s)
 }
 
 AVOutputFormat ff_ffm_muxer = {
-    "ffm",
-    NULL_IF_CONFIG_SMALL("FFM (FFserver live feed) format"),
-    "",
-    "ffm",
-    sizeof(FFMContext),
-    /* not really used */
-    CODEC_ID_MP2,
-    CODEC_ID_MPEG1VIDEO,
-    ffm_write_header,
-    ffm_write_packet,
-    ffm_write_trailer,
+    .name              = "ffm",
+    .long_name         = NULL_IF_CONFIG_SMALL("FFM (FFserver live feed) format"),
+    .mime_type         = "",
+    .extensions        = "ffm",
+    .priv_data_size    = sizeof(FFMContext),
+    .audio_codec       = CODEC_ID_MP2,
+    .video_codec       = CODEC_ID_MPEG1VIDEO,
+    .write_header      = ffm_write_header,
+    .write_packet      = ffm_write_packet,
+    .write_trailer     = ffm_write_trailer,
 };
index 095bf9e..e672ba0 100644 (file)
@@ -99,13 +99,11 @@ static int read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, in
 }
 
 AVInputFormat ff_filmstrip_demuxer = {
-    "filmstrip",
-    NULL_IF_CONFIG_SMALL("Adobe Filmstrip"),
-    sizeof(FilmstripDemuxContext),
-    NULL,
-    read_header,
-    read_packet,
-    NULL,
-    read_seek,
+    .name           = "filmstrip",
+    .long_name      = NULL_IF_CONFIG_SMALL("Adobe Filmstrip"),
+    .priv_data_size = sizeof(FilmstripDemuxContext),
+    .read_header    = read_header,
+    .read_packet    = read_packet,
+    .read_seek      = read_seek,
     .extensions = "flm",
 };
index 21f4755..0e55408 100644 (file)
@@ -72,14 +72,13 @@ static int write_trailer(AVFormatContext *s)
 }
 
 AVOutputFormat ff_filmstrip_muxer = {
-    "filmstrip",
-    NULL_IF_CONFIG_SMALL("Adobe Filmstrip"),
-    NULL,
-    "flm",
-    sizeof(FilmstripMuxContext),
-    CODEC_ID_NONE,
-    CODEC_ID_RAWVIDEO,
-    write_header,
-    write_packet,
-    write_trailer,
+    .name              = "filmstrip",
+    .long_name         = NULL_IF_CONFIG_SMALL("Adobe Filmstrip"),
+    .extensions        = "flm",
+    .priv_data_size    = sizeof(FilmstripMuxContext),
+    .audio_codec       = CODEC_ID_NONE,
+    .video_codec       = CODEC_ID_RAWVIDEO,
+    .write_header      = write_header,
+    .write_packet      = write_packet,
+    .write_trailer     = write_trailer,
 };
index 02452b4..1cae9f0 100644 (file)
@@ -124,12 +124,11 @@ static int flac_probe(AVProbeData *p)
 }
 
 AVInputFormat ff_flac_demuxer = {
-    "flac",
-    NULL_IF_CONFIG_SMALL("raw FLAC"),
-    0,
-    flac_probe,
-    flac_read_header,
-    ff_raw_read_partial_packet,
+    .name           = "flac",
+    .long_name      = NULL_IF_CONFIG_SMALL("raw FLAC"),
+    .read_probe     = flac_probe,
+    .read_header    = flac_read_header,
+    .read_packet    = ff_raw_read_partial_packet,
     .flags= AVFMT_GENERIC_INDEX,
     .extensions = "flac",
     .value = CODEC_ID_FLAC,
index fb28a6e..f14b30b 100644 (file)
@@ -118,15 +118,14 @@ static int flac_write_packet(struct AVFormatContext *s, AVPacket *pkt)
 }
 
 AVOutputFormat ff_flac_muxer = {
-    "flac",
-    NULL_IF_CONFIG_SMALL("raw FLAC"),
-    "audio/x-flac",
-    "flac",
-    0,
-    CODEC_ID_FLAC,
-    CODEC_ID_NONE,
-    flac_write_header,
-    flac_write_packet,
-    flac_write_trailer,
+    .name              = "flac",
+    .long_name         = NULL_IF_CONFIG_SMALL("raw FLAC"),
+    .mime_type         = "audio/x-flac",
+    .extensions        = "flac",
+    .audio_codec       = CODEC_ID_FLAC,
+    .video_codec       = CODEC_ID_NONE,
+    .write_header      = flac_write_header,
+    .write_packet      = flac_write_packet,
+    .write_trailer     = flac_write_trailer,
     .flags= AVFMT_NOTIMESTAMPS,
 };
index fcdf4c8..3cea79e 100644 (file)
@@ -261,10 +261,10 @@ static int flic_read_packet(AVFormatContext *s,
 }
 
 AVInputFormat ff_flic_demuxer = {
-    "flic",
-    NULL_IF_CONFIG_SMALL("FLI/FLC/FLX animation format"),
-    sizeof(FlicDemuxContext),
-    flic_probe,
-    flic_read_header,
-    flic_read_packet,
+    .name           = "flic",
+    .long_name      = NULL_IF_CONFIG_SMALL("FLI/FLC/FLX animation format"),
+    .priv_data_size = sizeof(FlicDemuxContext),
+    .read_probe     = flic_probe,
+    .read_header    = flic_read_header,
+    .read_packet    = flic_read_packet,
 };
index 57eaa84..cafbeb5 100644 (file)
@@ -572,12 +572,12 @@ static int flv_read_seek2(AVFormatContext *s, int stream_index,
 #endif
 
 AVInputFormat ff_flv_demuxer = {
-    "flv",
-    NULL_IF_CONFIG_SMALL("FLV format"),
-    sizeof(FLVContext),
-    flv_probe,
-    flv_read_header,
-    flv_read_packet,
+    .name           = "flv",
+    .long_name      = NULL_IF_CONFIG_SMALL("FLV format"),
+    .priv_data_size = sizeof(FLVContext),
+    .read_probe     = flv_probe,
+    .read_header    = flv_read_header,
+    .read_packet    = flv_read_packet,
     .read_seek = flv_read_seek,
 #if 0
     .read_seek2 = flv_read_seek2,
index a3e7e25..36f7e1f 100644 (file)
@@ -441,20 +441,20 @@ static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVOutputFormat ff_flv_muxer = {
-    "flv",
-    NULL_IF_CONFIG_SMALL("FLV format"),
-    "video/x-flv",
-    "flv",
-    sizeof(FLVContext),
+    .name           = "flv",
+    .long_name      = NULL_IF_CONFIG_SMALL("FLV format"),
+    .mime_type      = "video/x-flv",
+    .extensions     = "flv",
+    .priv_data_size = sizeof(FLVContext),
 #if CONFIG_LIBMP3LAME
-    CODEC_ID_MP3,
+    .audio_codec    = CODEC_ID_MP3,
 #else // CONFIG_LIBMP3LAME
-    CODEC_ID_ADPCM_SWF,
+    .audio_codec    = CODEC_ID_ADPCM_SWF,
 #endif // CONFIG_LIBMP3LAME
-    CODEC_ID_FLV1,
-    flv_write_header,
-    flv_write_packet,
-    flv_write_trailer,
+    .video_codec    = CODEC_ID_FLV1,
+    .write_header   = flv_write_header,
+    .write_packet   = flv_write_packet,
+    .write_trailer  = flv_write_trailer,
     .codec_tag= (const AVCodecTag* const []){flv_video_codec_ids, flv_audio_codec_ids, 0},
     .flags= AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS,
 };
index 2bd3f54..f875620 100644 (file)
@@ -34,14 +34,10 @@ static int framecrc_write_packet(struct AVFormatContext *s, AVPacket *pkt)
 }
 
 AVOutputFormat ff_framecrc_muxer = {
-    "framecrc",
-    NULL_IF_CONFIG_SMALL("framecrc testing format"),
-    NULL,
-    "",
-    0,
-    CODEC_ID_PCM_S16LE,
-    CODEC_ID_RAWVIDEO,
-    NULL,
-    framecrc_write_packet,
-    NULL,
+    .name              = "framecrc",
+    .long_name         = NULL_IF_CONFIG_SMALL("framecrc testing format"),
+    .extensions        = "",
+    .audio_codec       = CODEC_ID_PCM_S16LE,
+    .video_codec       = CODEC_ID_RAWVIDEO,
+    .write_packet      = framecrc_write_packet,
 };
index cf87857..f831787 100644 (file)
@@ -363,15 +363,15 @@ static const AVClass gif_muxer_class = {
 };
 
 AVOutputFormat ff_gif_muxer = {
-    "gif",
-    NULL_IF_CONFIG_SMALL("GIF Animation"),
-    "image/gif",
-    "gif",
-    sizeof(GIFContext),
-    CODEC_ID_NONE,
-    CODEC_ID_RAWVIDEO,
-    gif_write_header,
-    gif_write_packet,
-    gif_write_trailer,
+    .name              = "gif",
+    .long_name         = NULL_IF_CONFIG_SMALL("GIF Animation"),
+    .mime_type         = "image/gif",
+    .extensions        = "gif",
+    .priv_data_size    = sizeof(GIFContext),
+    .audio_codec       = CODEC_ID_NONE,
+    .video_codec       = CODEC_ID_RAWVIDEO,
+    .write_header      = gif_write_header,
+    .write_packet      = gif_write_packet,
+    .write_trailer     = gif_write_trailer,
     .priv_class = &gif_muxer_class,
 };
index 062a147..8077d80 100644 (file)
@@ -523,13 +523,12 @@ static int64_t gxf_read_timestamp(AVFormatContext *s, int stream_index,
 }
 
 AVInputFormat ff_gxf_demuxer = {
-    "gxf",
-    NULL_IF_CONFIG_SMALL("GXF format"),
-    sizeof(struct gxf_stream_info),
-    gxf_probe,
-    gxf_header,
-    gxf_packet,
-    NULL,
-    gxf_seek,
-    gxf_read_timestamp,
+    .name           = "gxf",
+    .long_name      = NULL_IF_CONFIG_SMALL("GXF format"),
+    .priv_data_size = sizeof(struct gxf_stream_info),
+    .read_probe     = gxf_probe,
+    .read_header    = gxf_header,
+    .read_packet    = gxf_packet,
+    .read_seek      = gxf_seek,
+    .read_timestamp = gxf_read_timestamp,
 };
index 99bd719..11e1ea5 100644 (file)
@@ -943,17 +943,14 @@ static int gxf_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *pk
 }
 
 AVOutputFormat ff_gxf_muxer = {
-    "gxf",
-    NULL_IF_CONFIG_SMALL("GXF format"),
-    NULL,
-    "gxf",
-    sizeof(GXFContext),
-    CODEC_ID_PCM_S16LE,
-    CODEC_ID_MPEG2VIDEO,
-    gxf_write_header,
-    gxf_write_packet,
-    gxf_write_trailer,
-    0,
-    NULL,
-    gxf_interleave_packet,
+    .name              = "gxf",
+    .long_name         = NULL_IF_CONFIG_SMALL("GXF format"),
+    .extensions        = "gxf",
+    .priv_data_size    = sizeof(GXFContext),
+    .audio_codec       = CODEC_ID_PCM_S16LE,
+    .video_codec       = CODEC_ID_MPEG2VIDEO,
+    .write_header      = gxf_write_header,
+    .write_packet      = gxf_write_packet,
+    .write_trailer     = gxf_write_trailer,
+    .interleave_packet = gxf_interleave_packet,
 };
index 04ae687..ca67e69 100644 (file)
@@ -292,10 +292,10 @@ static int idcin_read_packet(AVFormatContext *s,
 }
 
 AVInputFormat ff_idcin_demuxer = {
-    "idcin",
-    NULL_IF_CONFIG_SMALL("id Cinematic format"),
-    sizeof(IdcinDemuxContext),
-    idcin_probe,
-    idcin_read_header,
-    idcin_read_packet,
+    .name           = "idcin",
+    .long_name      = NULL_IF_CONFIG_SMALL("id Cinematic format"),
+    .priv_data_size = sizeof(IdcinDemuxContext),
+    .read_probe     = idcin_probe,
+    .read_header    = idcin_read_header,
+    .read_packet    = idcin_read_packet,
 };
index d931596..1175c22 100644 (file)
@@ -216,10 +216,10 @@ static int roq_read_packet(AVFormatContext *s,
 }
 
 AVInputFormat ff_roq_demuxer = {
-    "RoQ",
-    NULL_IF_CONFIG_SMALL("id RoQ format"),
-    sizeof(RoqDemuxContext),
-    roq_probe,
-    roq_read_header,
-    roq_read_packet,
+    .name           = "RoQ",
+    .long_name      = NULL_IF_CONFIG_SMALL("id RoQ format"),
+    .priv_data_size = sizeof(RoqDemuxContext),
+    .read_probe     = roq_probe,
+    .read_header    = roq_read_header,
+    .read_packet    = roq_read_packet,
 };
index 2b84986..f388ca9 100644 (file)
@@ -316,10 +316,10 @@ static int iff_read_packet(AVFormatContext *s,
 }
 
 AVInputFormat ff_iff_demuxer = {
-    "IFF",
-    NULL_IF_CONFIG_SMALL("IFF format"),
-    sizeof(IffDemuxContext),
-    iff_probe,
-    iff_read_header,
-    iff_read_packet,
+    .name           = "IFF",
+    .long_name      = NULL_IF_CONFIG_SMALL("IFF format"),
+    .priv_data_size = sizeof(IffDemuxContext),
+    .read_probe     = iff_probe,
+    .read_header    = iff_read_header,
+    .read_packet    = iff_read_packet,
 };
index febeb2e..50a4357 100644 (file)
@@ -59,12 +59,11 @@ static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_ingenient_demuxer = {
-    "ingenient",
-    NULL_IF_CONFIG_SMALL("raw Ingenient MJPEG"),
-    sizeof(FFRawVideoDemuxerContext),
-    NULL,
-    ff_raw_video_read_header,
-    ingenient_read_packet,
+    .name           = "ingenient",
+    .long_name      = NULL_IF_CONFIG_SMALL("raw Ingenient MJPEG"),
+    .priv_data_size = sizeof(FFRawVideoDemuxerContext),
+    .read_header    = ff_raw_video_read_header,
+    .read_packet    = ingenient_read_packet,
     .flags= AVFMT_GENERIC_INDEX,
     .extensions = "cgi", // FIXME
     .value = CODEC_ID_MJPEG,
index e8ba064..067ab15 100644 (file)
@@ -616,10 +616,10 @@ static int ipmovie_read_packet(AVFormatContext *s,
 }
 
 AVInputFormat ff_ipmovie_demuxer = {
-    "ipmovie",
-    NULL_IF_CONFIG_SMALL("Interplay MVE format"),
-    sizeof(IPMVEContext),
-    ipmovie_probe,
-    ipmovie_read_header,
-    ipmovie_read_packet,
+    .name           = "ipmovie",
+    .long_name      = NULL_IF_CONFIG_SMALL("Interplay MVE format"),
+    .priv_data_size = sizeof(IPMVEContext),
+    .read_probe     = ipmovie_probe,
+    .read_header    = ipmovie_read_header,
+    .read_packet    = ipmovie_read_packet,
 };
index 7989194..c1dd478 100644 (file)
@@ -122,11 +122,11 @@ static int iss_read_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_iss_demuxer = {
-    "ISS",
-    NULL_IF_CONFIG_SMALL("Funcom ISS format"),
-    sizeof(IssDemuxContext),
-    iss_probe,
-    iss_read_header,
-    iss_read_packet,
+    .name           = "ISS",
+    .long_name      = NULL_IF_CONFIG_SMALL("Funcom ISS format"),
+    .priv_data_size = sizeof(IssDemuxContext),
+    .read_probe     = iss_probe,
+    .read_header    = iss_read_header,
+    .read_packet    = iss_read_packet,
 };
 
index 22e60cf..bca31dc 100644 (file)
@@ -85,12 +85,11 @@ retry:
 }
 
 AVInputFormat ff_iv8_demuxer = {
-    "iv8",
-    NULL_IF_CONFIG_SMALL("A format generated by IndigoVision 8000 video server"),
-    0,
-    probe,
-    read_header,
-    read_packet,
+    .name           = "iv8",
+    .long_name      = NULL_IF_CONFIG_SMALL("A format generated by IndigoVision 8000 video server"),
+    .read_probe     = probe,
+    .read_header    = read_header,
+    .read_packet    = read_packet,
     .flags= AVFMT_GENERIC_INDEX,
     .value = CODEC_ID_MPEG4,
 };
index 3901731..9211881 100644 (file)
@@ -80,12 +80,11 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_ivf_demuxer = {
-    "ivf",
-    NULL_IF_CONFIG_SMALL("On2 IVF"),
-    0,
-    probe,
-    read_header,
-    read_packet,
+    .name           = "ivf",
+    .long_name      = NULL_IF_CONFIG_SMALL("On2 IVF"),
+    .read_probe     = probe,
+    .read_header    = read_header,
+    .read_packet    = read_packet,
     .flags= AVFMT_GENERIC_INDEX,
     .codec_tag = (const AVCodecTag*[]){ff_codec_bmp_tags, 0},
 };
index 76a621a..a618c53 100644 (file)
@@ -151,16 +151,16 @@ static int nut_write_trailer(AVFormatContext * avf) {
 }
 
 AVOutputFormat ff_libnut_muxer = {
-    "libnut",
-    "nut format",
-    "video/x-nut",
-    "nut",
-    sizeof(NUTContext),
-    CODEC_ID_VORBIS,
-    CODEC_ID_MPEG4,
-    nut_write_header,
-    nut_write_packet,
-    nut_write_trailer,
+    .name              = "libnut",
+    .long_name         = "nut format",
+    .mime_type         = "video/x-nut",
+    .extensions        = "nut",
+    .priv_data_size    = sizeof(NUTContext),
+    .audio_codec       = CODEC_ID_VORBIS,
+    .video_codec       = CODEC_ID_MPEG4,
+    .write_header      = nut_write_header,
+    .write_packet      = nut_write_packet,
+    .write_trailer     = nut_write_trailer,
     .flags = AVFMT_GLOBALHEADER,
 };
 #endif /* CONFIG_LIBNUT_MUXER */
@@ -298,13 +298,13 @@ static int nut_read_close(AVFormatContext *s) {
 }
 
 AVInputFormat ff_libnut_demuxer = {
-    "libnut",
-    NULL_IF_CONFIG_SMALL("NUT format"),
-    sizeof(NUTContext),
-    nut_probe,
-    nut_read_header,
-    nut_read_packet,
-    nut_read_close,
-    nut_read_seek,
+    .name           = "libnut",
+    .long_name      = NULL_IF_CONFIG_SMALL("NUT format"),
+    .priv_data_size = sizeof(NUTContext),
+    .read_probe     = nut_probe,
+    .read_header    = nut_read_header,
+    .read_packet    = nut_read_packet,
+    .read_close     = nut_read_close,
+    .read_seek      = nut_read_seek,
     .extensions = "nut",
 };
index eafc1b6..0d905e4 100644 (file)
@@ -118,10 +118,9 @@ static int lmlm4_read_packet(AVFormatContext *s, AVPacket *pkt) {
 }
 
 AVInputFormat ff_lmlm4_demuxer = {
-    "lmlm4",
-    NULL_IF_CONFIG_SMALL("lmlm4 raw format"),
-    0,
-    lmlm4_probe,
-    lmlm4_read_header,
-    lmlm4_read_packet,
+    .name           = "lmlm4",
+    .long_name      = NULL_IF_CONFIG_SMALL("lmlm4 raw format"),
+    .read_probe     = lmlm4_probe,
+    .read_header    = lmlm4_read_header,
+    .read_packet    = lmlm4_read_packet,
 };
index 70bb765..852760c 100644 (file)
@@ -1999,12 +1999,12 @@ static int matroska_read_close(AVFormatContext *s)
 }
 
 AVInputFormat ff_matroska_demuxer = {
-    "matroska,webm",
-    NULL_IF_CONFIG_SMALL("Matroska/WebM file format"),
-    sizeof(MatroskaDemuxContext),
-    matroska_probe,
-    matroska_read_header,
-    matroska_read_packet,
-    matroska_read_close,
-    matroska_read_seek,
+    .name           = "matroska,webm",
+    .long_name      = NULL_IF_CONFIG_SMALL("Matroska/WebM file format"),
+    .priv_data_size = sizeof(MatroskaDemuxContext),
+    .read_probe     = matroska_probe,
+    .read_header    = matroska_read_header,
+    .read_packet    = matroska_read_packet,
+    .read_close     = matroska_read_close,
+    .read_seek      = matroska_read_seek,
 };
index d0e3c17..b08f546 100644 (file)
@@ -1193,16 +1193,16 @@ static int mkv_write_trailer(AVFormatContext *s)
 
 #if CONFIG_MATROSKA_MUXER
 AVOutputFormat ff_matroska_muxer = {
-    "matroska",
-    NULL_IF_CONFIG_SMALL("Matroska file format"),
-    "video/x-matroska",
-    "mkv",
-    sizeof(MatroskaMuxContext),
-    CODEC_ID_MP2,
-    CODEC_ID_MPEG4,
-    mkv_write_header,
-    mkv_write_packet,
-    mkv_write_trailer,
+    .name              = "matroska",
+    .long_name         = NULL_IF_CONFIG_SMALL("Matroska file format"),
+    .mime_type         = "video/x-matroska",
+    .extensions        = "mkv",
+    .priv_data_size    = sizeof(MatroskaMuxContext),
+    .audio_codec       = CODEC_ID_MP2,
+    .video_codec       = CODEC_ID_MPEG4,
+    .write_header      = mkv_write_header,
+    .write_packet      = mkv_write_packet,
+    .write_trailer     = mkv_write_trailer,
     .flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS,
     .codec_tag = (const AVCodecTag* const []){ff_codec_bmp_tags, ff_codec_wav_tags, 0},
     .subtitle_codec = CODEC_ID_SSA,
@@ -1211,32 +1211,32 @@ AVOutputFormat ff_matroska_muxer = {
 
 #if CONFIG_WEBM_MUXER
 AVOutputFormat ff_webm_muxer = {
-    "webm",
-    NULL_IF_CONFIG_SMALL("WebM file format"),
-    "video/webm",
-    "webm",
-    sizeof(MatroskaMuxContext),
-    CODEC_ID_VORBIS,
-    CODEC_ID_VP8,
-    mkv_write_header,
-    mkv_write_packet,
-    mkv_write_trailer,
+    .name              = "webm",
+    .long_name         = NULL_IF_CONFIG_SMALL("WebM file format"),
+    .mime_type         = "video/webm",
+    .extensions        = "webm",
+    .priv_data_size    = sizeof(MatroskaMuxContext),
+    .audio_codec       = CODEC_ID_VORBIS,
+    .video_codec       = CODEC_ID_VP8,
+    .write_header      = mkv_write_header,
+    .write_packet      = mkv_write_packet,
+    .write_trailer     = mkv_write_trailer,
     .flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS,
 };
 #endif
 
 #if CONFIG_MATROSKA_AUDIO_MUXER
 AVOutputFormat ff_matroska_audio_muxer = {
-    "matroska",
-    NULL_IF_CONFIG_SMALL("Matroska file format"),
-    "audio/x-matroska",
-    "mka",
-    sizeof(MatroskaMuxContext),
-    CODEC_ID_MP2,
-    CODEC_ID_NONE,
-    mkv_write_header,
-    mkv_write_packet,
-    mkv_write_trailer,
+    .name              = "matroska",
+    .long_name         = NULL_IF_CONFIG_SMALL("Matroska file format"),
+    .mime_type         = "audio/x-matroska",
+    .extensions        = "mka",
+    .priv_data_size    = sizeof(MatroskaMuxContext),
+    .audio_codec       = CODEC_ID_MP2,
+    .video_codec       = CODEC_ID_NONE,
+    .write_header      = mkv_write_header,
+    .write_packet      = mkv_write_packet,
+    .write_trailer     = mkv_write_trailer,
     .flags = AVFMT_GLOBALHEADER,
     .codec_tag = (const AVCodecTag* const []){ff_codec_wav_tags, 0},
 };
index 3b7d0ea..dc8919a 100644 (file)
@@ -66,16 +66,15 @@ static int write_trailer(struct AVFormatContext *s)
 }
 
 AVOutputFormat ff_md5_muxer = {
-    "md5",
-    NULL_IF_CONFIG_SMALL("MD5 testing format"),
-    NULL,
-    "",
-    PRIVSIZE,
-    CODEC_ID_PCM_S16LE,
-    CODEC_ID_RAWVIDEO,
-    write_header,
-    write_packet,
-    write_trailer,
+    .name              = "md5",
+    .long_name         = NULL_IF_CONFIG_SMALL("MD5 testing format"),
+    .extensions        = "",
+    .priv_data_size    = PRIVSIZE,
+    .audio_codec       = CODEC_ID_PCM_S16LE,
+    .video_codec       = CODEC_ID_RAWVIDEO,
+    .write_header      = write_header,
+    .write_packet      = write_packet,
+    .write_trailer     = write_trailer,
 };
 #endif
 
@@ -96,15 +95,12 @@ static int framemd5_write_packet(struct AVFormatContext *s, AVPacket *pkt)
 }
 
 AVOutputFormat ff_framemd5_muxer = {
-    "framemd5",
-    NULL_IF_CONFIG_SMALL("Per-frame MD5 testing format"),
-    NULL,
-    "",
-    PRIVSIZE,
-    CODEC_ID_PCM_S16LE,
-    CODEC_ID_RAWVIDEO,
-    NULL,
-    framemd5_write_packet,
-    NULL,
+    .name              = "framemd5",
+    .long_name         = NULL_IF_CONFIG_SMALL("Per-frame MD5 testing format"),
+    .extensions        = "",
+    .priv_data_size    = PRIVSIZE,
+    .audio_codec       = CODEC_ID_PCM_S16LE,
+    .video_codec       = CODEC_ID_RAWVIDEO,
+    .write_packet      = framemd5_write_packet,
 };
 #endif
index dae659f..20118a9 100644 (file)
@@ -187,10 +187,10 @@ static int read_packet(AVFormatContext *s,
 }
 
 AVInputFormat ff_mm_demuxer = {
-    "mm",
-    NULL_IF_CONFIG_SMALL("American Laser Games MM format"),
-    sizeof(MmDemuxContext),
-    probe,
-    read_header,
-    read_packet,
+    .name           = "mm",
+    .long_name      = NULL_IF_CONFIG_SMALL("American Laser Games MM format"),
+    .priv_data_size = sizeof(MmDemuxContext),
+    .read_probe     = probe,
+    .read_header    = read_header,
+    .read_packet    = read_packet,
 };
index 3848d5c..ffa6916 100644 (file)
@@ -291,27 +291,26 @@ static int mmf_read_packet(AVFormatContext *s,
 
 #if CONFIG_MMF_DEMUXER
 AVInputFormat ff_mmf_demuxer = {
-    "mmf",
-    NULL_IF_CONFIG_SMALL("Yamaha SMAF"),
-    sizeof(MMFContext),
-    mmf_probe,
-    mmf_read_header,
-    mmf_read_packet,
-    NULL,
-    pcm_read_seek,
+    .name           = "mmf",
+    .long_name      = NULL_IF_CONFIG_SMALL("Yamaha SMAF"),
+    .priv_data_size = sizeof(MMFContext),
+    .read_probe     = mmf_probe,
+    .read_header    = mmf_read_header,
+    .read_packet    = mmf_read_packet,
+    .read_seek      = pcm_read_seek,
 };
 #endif
 #if CONFIG_MMF_MUXER
 AVOutputFormat ff_mmf_muxer = {
-    "mmf",
-    NULL_IF_CONFIG_SMALL("Yamaha SMAF"),
-    "application/vnd.smaf",
-    "mmf",
-    sizeof(MMFContext),
-    CODEC_ID_ADPCM_YAMAHA,
-    CODEC_ID_NONE,
-    mmf_write_header,
-    mmf_write_packet,
-    mmf_write_trailer,
+    .name              = "mmf",
+    .long_name         = NULL_IF_CONFIG_SMALL("Yamaha SMAF"),
+    .mime_type         = "application/vnd.smaf",
+    .extensions        = "mmf",
+    .priv_data_size    = sizeof(MMFContext),
+    .audio_codec       = CODEC_ID_ADPCM_YAMAHA,
+    .video_codec       = CODEC_ID_NONE,
+    .write_header      = mmf_write_header,
+    .write_packet      = mmf_write_packet,
+    .write_trailer     = mmf_write_trailer,
 };
 #endif
index acde35d..0de2bfc 100644 (file)
@@ -2611,12 +2611,12 @@ static int mov_read_close(AVFormatContext *s)
 }
 
 AVInputFormat ff_mov_demuxer = {
-    "mov,mp4,m4a,3gp,3g2,mj2",
-    NULL_IF_CONFIG_SMALL("QuickTime/MPEG-4/Motion JPEG 2000 format"),
-    sizeof(MOVContext),
-    mov_probe,
-    mov_read_header,
-    mov_read_packet,
-    mov_read_close,
-    mov_read_seek,
+    .name           = "mov,mp4,m4a,3gp,3g2,mj2",
+    .long_name      = NULL_IF_CONFIG_SMALL("QuickTime/MPEG-4/Motion JPEG 2000 format"),
+    .priv_data_size = sizeof(MOVContext),
+    .read_probe     = mov_probe,
+    .read_header    = mov_read_header,
+    .read_packet    = mov_read_packet,
+    .read_close     = mov_read_close,
+    .read_seek      = mov_read_seek,
 };
index 12ebef5..185d89f 100644 (file)
@@ -2338,16 +2338,15 @@ static int mov_write_trailer(AVFormatContext *s)
 
 #if CONFIG_MOV_MUXER
 AVOutputFormat ff_mov_muxer = {
-    "mov",
-    NULL_IF_CONFIG_SMALL("MOV format"),
-    NULL,
-    "mov",
-    sizeof(MOVMuxContext),
-    CODEC_ID_AAC,
-    CODEC_ID_MPEG4,
-    mov_write_header,
-    ff_mov_write_packet,
-    mov_write_trailer,
+    .name              = "mov",
+    .long_name         = NULL_IF_CONFIG_SMALL("MOV format"),
+    .extensions        = "mov",
+    .priv_data_size    = sizeof(MOVMuxContext),
+    .audio_codec       = CODEC_ID_AAC,
+    .video_codec       = CODEC_ID_MPEG4,
+    .write_header      = mov_write_header,
+    .write_packet      = ff_mov_write_packet,
+    .write_trailer     = mov_write_trailer,
     .flags = AVFMT_GLOBALHEADER,
     .codec_tag = (const AVCodecTag* const []){codec_movvideo_tags, codec_movaudio_tags, 0},
     .priv_class = &mov_muxer_class,
@@ -2355,16 +2354,15 @@ AVOutputFormat ff_mov_muxer = {
 #endif
 #if CONFIG_TGP_MUXER
 AVOutputFormat ff_tgp_muxer = {
-    "3gp",
-    NULL_IF_CONFIG_SMALL("3GP format"),
-    NULL,
-    "3gp",
-    sizeof(MOVMuxContext),
-    CODEC_ID_AMR_NB,
-    CODEC_ID_H263,
-    mov_write_header,
-    ff_mov_write_packet,
-    mov_write_trailer,
+    .name              = "3gp",
+    .long_name         = NULL_IF_CONFIG_SMALL("3GP format"),
+    .extensions        = "3gp",
+    .priv_data_size    = sizeof(MOVMuxContext),
+    .audio_codec       = CODEC_ID_AMR_NB,
+    .video_codec       = CODEC_ID_H263,
+    .write_header      = mov_write_header,
+    .write_packet      = ff_mov_write_packet,
+    .write_trailer     = mov_write_trailer,
     .flags = AVFMT_GLOBALHEADER,
     .codec_tag = (const AVCodecTag* const []){codec_3gp_tags, 0},
     .priv_class = &mov_muxer_class,
@@ -2372,16 +2370,16 @@ AVOutputFormat ff_tgp_muxer = {
 #endif
 #if CONFIG_MP4_MUXER
 AVOutputFormat ff_mp4_muxer = {
-    "mp4",
-    NULL_IF_CONFIG_SMALL("MP4 format"),
-    "application/mp4",
-    "mp4",
-    sizeof(MOVMuxContext),
-    CODEC_ID_AAC,
-    CODEC_ID_MPEG4,
-    mov_write_header,
-    ff_mov_write_packet,
-    mov_write_trailer,
+    .name              = "mp4",
+    .long_name         = NULL_IF_CONFIG_SMALL("MP4 format"),
+    .mime_type         = "application/mp4",
+    .extensions        = "mp4",
+    .priv_data_size    = sizeof(MOVMuxContext),
+    .audio_codec       = CODEC_ID_AAC,
+    .video_codec       = CODEC_ID_MPEG4,
+    .write_header      = mov_write_header,
+    .write_packet      = ff_mov_write_packet,
+    .write_trailer     = mov_write_trailer,
     .flags = AVFMT_GLOBALHEADER,
     .codec_tag = (const AVCodecTag* const []){ff_mp4_obj_type, 0},
     .priv_class = &mov_muxer_class,
@@ -2389,16 +2387,15 @@ AVOutputFormat ff_mp4_muxer = {
 #endif
 #if CONFIG_PSP_MUXER
 AVOutputFormat ff_psp_muxer = {
-    "psp",
-    NULL_IF_CONFIG_SMALL("PSP MP4 format"),
-    NULL,
-    "mp4,psp",
-    sizeof(MOVMuxContext),
-    CODEC_ID_AAC,
-    CODEC_ID_MPEG4,
-    mov_write_header,
-    ff_mov_write_packet,
-    mov_write_trailer,
+    .name              = "psp",
+    .long_name         = NULL_IF_CONFIG_SMALL("PSP MP4 format"),
+    .extensions        = "mp4,psp",
+    .priv_data_size    = sizeof(MOVMuxContext),
+    .audio_codec       = CODEC_ID_AAC,
+    .video_codec       = CODEC_ID_MPEG4,
+    .write_header      = mov_write_header,
+    .write_packet      = ff_mov_write_packet,
+    .write_trailer     = mov_write_trailer,
     .flags = AVFMT_GLOBALHEADER,
     .codec_tag = (const AVCodecTag* const []){ff_mp4_obj_type, 0},
     .priv_class = &mov_muxer_class,
@@ -2406,16 +2403,15 @@ AVOutputFormat ff_psp_muxer = {
 #endif
 #if CONFIG_TG2_MUXER
 AVOutputFormat ff_tg2_muxer = {
-    "3g2",
-    NULL_IF_CONFIG_SMALL("3GP2 format"),
-    NULL,
-    "3g2",
-    sizeof(MOVMuxContext),
-    CODEC_ID_AMR_NB,
-    CODEC_ID_H263,
-    mov_write_header,
-    ff_mov_write_packet,
-    mov_write_trailer,
+    .name              = "3g2",
+    .long_name         = NULL_IF_CONFIG_SMALL("3GP2 format"),
+    .extensions        = "3g2",
+    .priv_data_size    = sizeof(MOVMuxContext),
+    .audio_codec       = CODEC_ID_AMR_NB,
+    .video_codec       = CODEC_ID_H263,
+    .write_header      = mov_write_header,
+    .write_packet      = ff_mov_write_packet,
+    .write_trailer     = mov_write_trailer,
     .flags = AVFMT_GLOBALHEADER,
     .codec_tag = (const AVCodecTag* const []){codec_3gp_tags, 0},
     .priv_class = &mov_muxer_class,
@@ -2423,16 +2419,16 @@ AVOutputFormat ff_tg2_muxer = {
 #endif
 #if CONFIG_IPOD_MUXER
 AVOutputFormat ff_ipod_muxer = {
-    "ipod",
-    NULL_IF_CONFIG_SMALL("iPod H.264 MP4 format"),
-    "application/mp4",
-    "m4v,m4a",
-    sizeof(MOVMuxContext),
-    CODEC_ID_AAC,
-    CODEC_ID_H264,
-    mov_write_header,
-    ff_mov_write_packet,
-    mov_write_trailer,
+    .name              = "ipod",
+    .long_name         = NULL_IF_CONFIG_SMALL("iPod H.264 MP4 format"),
+    .mime_type         = "application/mp4",
+    .extensions        = "m4v,m4a",
+    .priv_data_size    = sizeof(MOVMuxContext),
+    .audio_codec       = CODEC_ID_AAC,
+    .video_codec       = CODEC_ID_H264,
+    .write_header      = mov_write_header,
+    .write_packet      = ff_mov_write_packet,
+    .write_trailer     = mov_write_trailer,
     .flags = AVFMT_GLOBALHEADER,
     .codec_tag = (const AVCodecTag* const []){codec_ipod_tags, 0},
     .priv_class = &mov_muxer_class,
index 70ced02..dbd1c1e 100644 (file)
@@ -188,12 +188,11 @@ static int mp3_read_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_mp3_demuxer = {
-    "mp3",
-    NULL_IF_CONFIG_SMALL("MPEG audio layer 2/3"),
-    0,
-    mp3_read_probe,
-    mp3_read_header,
-    mp3_read_packet,
+    .name           = "mp3",
+    .long_name      = NULL_IF_CONFIG_SMALL("MPEG audio layer 2/3"),
+    .read_probe     = mp3_read_probe,
+    .read_header    = mp3_read_header,
+    .read_packet    = mp3_read_packet,
     .flags= AVFMT_GENERIC_INDEX,
     .extensions = "mp2,mp3,m2a", /* XXX: use probe */
 };
index 9d0ec5d..e702e3b 100644 (file)
@@ -162,16 +162,14 @@ static int mp3_write_trailer(struct AVFormatContext *s)
 
 #if CONFIG_MP2_MUXER
 AVOutputFormat ff_mp2_muxer = {
-    "mp2",
-    NULL_IF_CONFIG_SMALL("MPEG audio layer 2"),
-    "audio/x-mpeg",
-    "mp2,m2a",
-    0,
-    CODEC_ID_MP2,
-    CODEC_ID_NONE,
-    NULL,
-    ff_raw_write_packet,
-    mp3_write_trailer,
+    .name              = "mp2",
+    .long_name         = NULL_IF_CONFIG_SMALL("MPEG audio layer 2"),
+    .mime_type         = "audio/x-mpeg",
+    .extensions        = "mp2,m2a",
+    .audio_codec       = CODEC_ID_MP2,
+    .video_codec       = CODEC_ID_NONE,
+    .write_packet      = ff_raw_write_packet,
+    .write_trailer     = mp3_write_trailer,
 };
 #endif
 
@@ -306,17 +304,17 @@ static int mp3_write_header(struct AVFormatContext *s)
 }
 
 AVOutputFormat ff_mp3_muxer = {
-    "mp3",
-    NULL_IF_CONFIG_SMALL("MPEG audio layer 3"),
-    "audio/x-mpeg",
-    "mp3",
-    sizeof(MP3Context),
-    CODEC_ID_MP3,
-    CODEC_ID_NONE,
-    mp3_write_header,
-    ff_raw_write_packet,
-    mp3_write_trailer,
-    AVFMT_NOTIMESTAMPS,
+    .name              = "mp3",
+    .long_name         = NULL_IF_CONFIG_SMALL("MPEG audio layer 3"),
+    .mime_type         = "audio/x-mpeg",
+    .extensions        = "mp3",
+    .priv_data_size    = sizeof(MP3Context),
+    .audio_codec       = CODEC_ID_MP3,
+    .video_codec       = CODEC_ID_NONE,
+    .write_header      = mp3_write_header,
+    .write_packet      = ff_raw_write_packet,
+    .write_trailer     = mp3_write_trailer,
+    .flags             = AVFMT_NOTIMESTAMPS,
     .priv_class = &mp3_muxer_class,
 };
 #endif
index 75b59e1..8faa0f7 100644 (file)
@@ -222,13 +222,13 @@ static int mpc_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp
 
 
 AVInputFormat ff_mpc_demuxer = {
-    "mpc",
-    NULL_IF_CONFIG_SMALL("Musepack"),
-    sizeof(MPCContext),
-    mpc_probe,
-    mpc_read_header,
-    mpc_read_packet,
-    mpc_read_close,
-    mpc_read_seek,
+    .name           = "mpc",
+    .long_name      = NULL_IF_CONFIG_SMALL("Musepack"),
+    .priv_data_size = sizeof(MPCContext),
+    .read_probe     = mpc_probe,
+    .read_header    = mpc_read_header,
+    .read_packet    = mpc_read_packet,
+    .read_close     = mpc_read_close,
+    .read_seek      = mpc_read_seek,
     .extensions = "mpc",
 };
index c4810f6..d7a7d6a 100644 (file)
@@ -281,12 +281,11 @@ static int mpc8_read_seek(AVFormatContext *s, int stream_index, int64_t timestam
 
 
 AVInputFormat ff_mpc8_demuxer = {
-    "mpc8",
-    NULL_IF_CONFIG_SMALL("Musepack SV8"),
-    sizeof(MPCContext),
-    mpc8_probe,
-    mpc8_read_header,
-    mpc8_read_packet,
-    NULL,
-    mpc8_read_seek,
+    .name           = "mpc8",
+    .long_name      = NULL_IF_CONFIG_SMALL("Musepack SV8"),
+    .priv_data_size = sizeof(MPCContext),
+    .read_probe     = mpc8_probe,
+    .read_header    = mpc8_read_header,
+    .read_packet    = mpc8_read_packet,
+    .read_seek      = mpc8_read_seek,
 };
index 496b9d4..bc45049 100644 (file)
@@ -603,14 +603,13 @@ static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
 }
 
 AVInputFormat ff_mpegps_demuxer = {
-    "mpeg",
-    NULL_IF_CONFIG_SMALL("MPEG-PS format"),
-    sizeof(MpegDemuxContext),
-    mpegps_probe,
-    mpegps_read_header,
-    mpegps_read_packet,
-    NULL,
-    NULL, //mpegps_read_seek,
-    mpegps_read_dts,
+    .name           = "mpeg",
+    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-PS format"),
+    .priv_data_size = sizeof(MpegDemuxContext),
+    .read_probe     = mpegps_probe,
+    .read_header    = mpegps_read_header,
+    .read_packet    = mpegps_read_packet,
+    .read_seek      = NULL, //mpegps_read_seek,
+    .read_timestamp = mpegps_read_dts,
     .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
 };
index 5859254..5824206 100644 (file)
@@ -1229,75 +1229,74 @@ static int mpeg_mux_end(AVFormatContext *ctx)
 
 #if CONFIG_MPEG1SYSTEM_MUXER
 AVOutputFormat ff_mpeg1system_muxer = {
-    "mpeg",
-    NULL_IF_CONFIG_SMALL("MPEG-1 System format"),
-    "video/mpeg",
-    "mpg,mpeg",
-    sizeof(MpegMuxContext),
-    CODEC_ID_MP2,
-    CODEC_ID_MPEG1VIDEO,
-    mpeg_mux_init,
-    mpeg_mux_write_packet,
-    mpeg_mux_end,
+    .name              = "mpeg",
+    .long_name         = NULL_IF_CONFIG_SMALL("MPEG-1 System format"),
+    .mime_type         = "video/mpeg",
+    .extensions        = "mpg,mpeg",
+    .priv_data_size    = sizeof(MpegMuxContext),
+    .audio_codec       = CODEC_ID_MP2,
+    .video_codec       = CODEC_ID_MPEG1VIDEO,
+    .write_header      = mpeg_mux_init,
+    .write_packet      = mpeg_mux_write_packet,
+    .write_trailer     = mpeg_mux_end,
 };
 #endif
 #if CONFIG_MPEG1VCD_MUXER
 AVOutputFormat ff_mpeg1vcd_muxer = {
-    "vcd",
-    NULL_IF_CONFIG_SMALL("MPEG-1 System format (VCD)"),
-    "video/mpeg",
-    NULL,
-    sizeof(MpegMuxContext),
-    CODEC_ID_MP2,
-    CODEC_ID_MPEG1VIDEO,
-    mpeg_mux_init,
-    mpeg_mux_write_packet,
-    mpeg_mux_end,
+    .name              = "vcd",
+    .long_name         = NULL_IF_CONFIG_SMALL("MPEG-1 System format (VCD)"),
+    .mime_type         = "video/mpeg",
+    .priv_data_size    = sizeof(MpegMuxContext),
+    .audio_codec       = CODEC_ID_MP2,
+    .video_codec       = CODEC_ID_MPEG1VIDEO,
+    .write_header      = mpeg_mux_init,
+    .write_packet      = mpeg_mux_write_packet,
+    .write_trailer     = mpeg_mux_end,
 };
 #endif
 #if CONFIG_MPEG2VOB_MUXER
 AVOutputFormat ff_mpeg2vob_muxer = {
-    "vob",
-    NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
-    "video/mpeg",
-    "vob",
-    sizeof(MpegMuxContext),
-    CODEC_ID_MP2,
-    CODEC_ID_MPEG2VIDEO,
-    mpeg_mux_init,
-    mpeg_mux_write_packet,
-    mpeg_mux_end,
+    .name              = "vob",
+    .long_name         = NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
+    .mime_type         = "video/mpeg",
+    .extensions        = "vob",
+    .priv_data_size    = sizeof(MpegMuxContext),
+    .audio_codec       = CODEC_ID_MP2,
+    .video_codec       = CODEC_ID_MPEG2VIDEO,
+    .write_header      = mpeg_mux_init,
+    .write_packet      = mpeg_mux_write_packet,
+    .write_trailer     = mpeg_mux_end,
 };
 #endif
 
 /* Same as mpeg2vob_mux except that the pack size is 2324 */
 #if CONFIG_MPEG2SVCD_MUXER
 AVOutputFormat ff_mpeg2svcd_muxer = {
-    "svcd",
-    NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
-    "video/mpeg",
-    "vob",
-    sizeof(MpegMuxContext),
-    CODEC_ID_MP2,
-    CODEC_ID_MPEG2VIDEO,
-    mpeg_mux_init,
-    mpeg_mux_write_packet,
-    mpeg_mux_end,
+    .name              = "svcd",
+    .long_name         = NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
+    .mime_type         = "video/mpeg",
+    .extensions        = "vob",
+    .priv_data_size    = sizeof(MpegMuxContext),
+    .audio_codec       = CODEC_ID_MP2,
+    .video_codec       = CODEC_ID_MPEG2VIDEO,
+    .write_header      = mpeg_mux_init,
+    .write_packet      = mpeg_mux_write_packet,
+    .write_trailer     = mpeg_mux_end,
 };
 #endif
 
 /*  Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
 #if CONFIG_MPEG2DVD_MUXER
 AVOutputFormat ff_mpeg2dvd_muxer = {
-    "dvd",
-    NULL_IF_CONFIG_SMALL("MPEG-2 PS format (DVD VOB)"),
-    "video/mpeg",
-    "dvd",
-    sizeof(MpegMuxContext),
-    CODEC_ID_MP2,
-    CODEC_ID_MPEG2VIDEO,
-    mpeg_mux_init,
-    mpeg_mux_write_packet,
-    mpeg_mux_end,
+    .name              = "dvd",
+    .long_name         = NULL_IF_CONFIG_SMALL("MPEG-2 PS format (DVD VOB)"),
+    .mime_type         = "video/mpeg",
+    .extensions        = "dvd",
+    .priv_data_size    = sizeof(MpegMuxContext),
+    .audio_codec       = CODEC_ID_MP2,
+    .video_codec       = CODEC_ID_MPEG2VIDEO,
+    .write_header      = mpeg_mux_init,
+    .write_packet      = mpeg_mux_write_packet,
+    .write_trailer     = mpeg_mux_end,
 };
 #endif
index 228f48b..b8f02ab 100644 (file)
@@ -1864,15 +1864,15 @@ void ff_mpegts_parse_close(MpegTSContext *ts)
 }
 
 AVInputFormat ff_mpegts_demuxer = {
-    "mpegts",
-    NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
-    sizeof(MpegTSContext),
-    mpegts_probe,
-    mpegts_read_header,
-    mpegts_read_packet,
-    mpegts_read_close,
-    read_seek,
-    mpegts_get_pcr,
+    .name           = "mpegts",
+    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
+    .priv_data_size = sizeof(MpegTSContext),
+    .read_probe     = mpegts_probe,
+    .read_header    = mpegts_read_header,
+    .read_packet    = mpegts_read_packet,
+    .read_close     = mpegts_read_close,
+    .read_seek      = read_seek,
+    .read_timestamp = mpegts_get_pcr,
     .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
 #ifdef USE_SYNCPOINT_SEARCH
     .read_seek2 = read_seek2,
@@ -1880,15 +1880,14 @@ AVInputFormat ff_mpegts_demuxer = {
 };
 
 AVInputFormat ff_mpegtsraw_demuxer = {
-    "mpegtsraw",
-    NULL_IF_CONFIG_SMALL("MPEG-2 raw transport stream format"),
-    sizeof(MpegTSContext),
-    NULL,
-    mpegts_read_header,
-    mpegts_raw_read_packet,
-    mpegts_read_close,
-    read_seek,
-    mpegts_get_pcr,
+    .name           = "mpegtsraw",
+    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-2 raw transport stream format"),
+    .priv_data_size = sizeof(MpegTSContext),
+    .read_header    = mpegts_read_header,
+    .read_packet    = mpegts_raw_read_packet,
+    .read_close     = mpegts_read_close,
+    .read_seek      = read_seek,
+    .read_timestamp = mpegts_get_pcr,
     .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
 #ifdef USE_SYNCPOINT_SEARCH
     .read_seek2 = read_seek2,
index 72ff289..cc40743 100644 (file)
@@ -1051,15 +1051,15 @@ static int mpegts_write_end(AVFormatContext *s)
 }
 
 AVOutputFormat ff_mpegts_muxer = {
-    "mpegts",
-    NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
-    "video/x-mpegts",
-    "ts,m2t",
-    sizeof(MpegTSWrite),
-    CODEC_ID_MP2,
-    CODEC_ID_MPEG2VIDEO,
-    mpegts_write_header,
-    mpegts_write_packet,
-    mpegts_write_end,
+    .name              = "mpegts",
+    .long_name         = NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
+    .mime_type         = "video/x-mpegts",
+    .extensions        = "ts,m2t",
+    .priv_data_size    = sizeof(MpegTSWrite),
+    .audio_codec       = CODEC_ID_MP2,
+    .video_codec       = CODEC_ID_MPEG2VIDEO,
+    .write_header      = mpegts_write_header,
+    .write_packet      = mpegts_write_packet,
+    .write_trailer     = mpegts_write_end,
     .priv_class = &mpegts_muxer_class,
 };
index ebb57bf..6580904 100644 (file)
@@ -54,14 +54,13 @@ static int mpjpeg_write_trailer(AVFormatContext *s)
 }
 
 AVOutputFormat ff_mpjpeg_muxer = {
-    "mpjpeg",
-    NULL_IF_CONFIG_SMALL("MIME multipart JPEG format"),
-    "multipart/x-mixed-replace;boundary=" BOUNDARY_TAG,
-    "mjpg",
-    0,
-    CODEC_ID_NONE,
-    CODEC_ID_MJPEG,
-    mpjpeg_write_header,
-    mpjpeg_write_packet,
-    mpjpeg_write_trailer,
+    .name              = "mpjpeg",
+    .long_name         = NULL_IF_CONFIG_SMALL("MIME multipart JPEG format"),
+    .mime_type         = "multipart/x-mixed-replace;boundary=" BOUNDARY_TAG,
+    .extensions        = "mjpg",
+    .audio_codec       = CODEC_ID_NONE,
+    .video_codec       = CODEC_ID_MJPEG,
+    .write_header      = mpjpeg_write_header,
+    .write_packet      = mpjpeg_write_packet,
+    .write_trailer     = mpjpeg_write_trailer,
 };
index d9d8000..9ac724e 100644 (file)
@@ -131,10 +131,9 @@ static int msnwc_tcp_read_packet(AVFormatContext *ctx, AVPacket *pkt)
 }
 
 AVInputFormat ff_msnwc_tcp_demuxer = {
-    "msnwctcp",
-    NULL_IF_CONFIG_SMALL("MSN TCP Webcam stream"),
-    0,
-    msnwc_tcp_probe,
-    msnwc_tcp_read_header,
-    msnwc_tcp_read_packet,
+    .name           = "msnwctcp",
+    .long_name      = NULL_IF_CONFIG_SMALL("MSN TCP Webcam stream"),
+    .read_probe     = msnwc_tcp_probe,
+    .read_header    = msnwc_tcp_read_header,
+    .read_packet    = msnwc_tcp_read_packet,
 };
index 92d38e1..59f13fe 100644 (file)
@@ -197,10 +197,10 @@ static int mtv_read_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_mtv_demuxer = {
-    "MTV",
-    NULL_IF_CONFIG_SMALL("MTV format"),
-    sizeof(MTVDemuxContext),
-    mtv_probe,
-    mtv_read_header,
-    mtv_read_packet,
+    .name           = "MTV",
+    .long_name      = NULL_IF_CONFIG_SMALL("MTV format"),
+    .priv_data_size = sizeof(MTVDemuxContext),
+    .read_probe     = mtv_probe,
+    .read_header    = mtv_read_header,
+    .read_packet    = mtv_read_packet,
 };
index 809cdf5..532c0c4 100644 (file)
@@ -124,11 +124,10 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_mvi_demuxer = {
-    "mvi",
-    NULL_IF_CONFIG_SMALL("Motion Pixels MVI format"),
-    sizeof(MviDemuxContext),
-    NULL,
-    read_header,
-    read_packet,
+    .name           = "mvi",
+    .long_name      = NULL_IF_CONFIG_SMALL("Motion Pixels MVI format"),
+    .priv_data_size = sizeof(MviDemuxContext),
+    .read_header    = read_header,
+    .read_packet    = read_packet,
     .extensions = "mvi"
 };
index cf2bb6c..e2688b1 100644 (file)
@@ -1016,12 +1016,12 @@ static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_ti
 }
 
 AVInputFormat ff_mxf_demuxer = {
-    "mxf",
-    NULL_IF_CONFIG_SMALL("Material eXchange Format"),
-    sizeof(MXFContext),
-    mxf_probe,
-    mxf_read_header,
-    mxf_read_packet,
-    mxf_read_close,
-    mxf_read_seek,
+    .name           = "mxf",
+    .long_name      = NULL_IF_CONFIG_SMALL("Material eXchange Format"),
+    .priv_data_size = sizeof(MXFContext),
+    .read_probe     = mxf_probe,
+    .read_header    = mxf_read_header,
+    .read_packet    = mxf_read_packet,
+    .read_close     = mxf_read_close,
+    .read_seek      = mxf_read_seek,
 };
index 7dadec0..d375e3f 100644 (file)
@@ -1890,33 +1890,30 @@ static int mxf_interleave(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int
 }
 
 AVOutputFormat ff_mxf_muxer = {
-    "mxf",
-    NULL_IF_CONFIG_SMALL("Material eXchange Format"),
-    "application/mxf",
-    "mxf",
-    sizeof(MXFContext),
-    CODEC_ID_PCM_S16LE,
-    CODEC_ID_MPEG2VIDEO,
-    mxf_write_header,
-    mxf_write_packet,
-    mxf_write_footer,
-    AVFMT_NOTIMESTAMPS,
-    NULL,
-    mxf_interleave,
+    .name              = "mxf",
+    .long_name         = NULL_IF_CONFIG_SMALL("Material eXchange Format"),
+    .mime_type         = "application/mxf",
+    .extensions        = "mxf",
+    .priv_data_size    = sizeof(MXFContext),
+    .audio_codec       = CODEC_ID_PCM_S16LE,
+    .video_codec       = CODEC_ID_MPEG2VIDEO,
+    .write_header      = mxf_write_header,
+    .write_packet      = mxf_write_packet,
+    .write_trailer     = mxf_write_footer,
+    .flags             = AVFMT_NOTIMESTAMPS,
+    .interleave_packet = mxf_interleave,
 };
 
 AVOutputFormat ff_mxf_d10_muxer = {
-    "mxf_d10",
-    NULL_IF_CONFIG_SMALL("Material eXchange Format, D-10 Mapping"),
-    "application/mxf",
-    NULL,
-    sizeof(MXFContext),
-    CODEC_ID_PCM_S16LE,
-    CODEC_ID_MPEG2VIDEO,
-    mxf_write_header,
-    mxf_write_packet,
-    mxf_write_footer,
-    AVFMT_NOTIMESTAMPS,
-    NULL,
-    mxf_interleave,
+    .name              = "mxf_d10",
+    .long_name         = NULL_IF_CONFIG_SMALL("Material eXchange Format, D-10 Mapping"),
+    .mime_type         = "application/mxf",
+    .priv_data_size    = sizeof(MXFContext),
+    .audio_codec       = CODEC_ID_PCM_S16LE,
+    .video_codec       = CODEC_ID_MPEG2VIDEO,
+    .write_header      = mxf_write_header,
+    .write_packet      = mxf_write_packet,
+    .write_trailer     = mxf_write_footer,
+    .flags             = AVFMT_NOTIMESTAMPS,
+    .interleave_packet = mxf_interleave,
 };
index 7e43adc..8feda75 100644 (file)
@@ -91,11 +91,10 @@ static int nc_read_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_nc_demuxer = {
-    "nc",
-    NULL_IF_CONFIG_SMALL("NC camera feed format"),
-    0,
-    nc_probe,
-    nc_read_header,
-    nc_read_packet,
+    .name           = "nc",
+    .long_name      = NULL_IF_CONFIG_SMALL("NC camera feed format"),
+    .read_probe     = nc_probe,
+    .read_header    = nc_read_header,
+    .read_packet    = nc_read_packet,
     .extensions = "v",
 };
index 4787331..08c4b10 100644 (file)
@@ -776,12 +776,12 @@ static int nsv_probe(AVProbeData *p)
 }
 
 AVInputFormat ff_nsv_demuxer = {
-    "nsv",
-    NULL_IF_CONFIG_SMALL("Nullsoft Streaming Video"),
-    sizeof(NSVContext),
-    nsv_probe,
-    nsv_read_header,
-    nsv_read_packet,
-    nsv_read_close,
-    nsv_read_seek,
+    .name           = "nsv",
+    .long_name      = NULL_IF_CONFIG_SMALL("Nullsoft Streaming Video"),
+    .priv_data_size = sizeof(NSVContext),
+    .read_probe     = nsv_probe,
+    .read_header    = nsv_read_header,
+    .read_packet    = nsv_read_packet,
+    .read_close     = nsv_read_close,
+    .read_seek      = nsv_read_seek,
 };
index 8e38b27..79fc02e 100644 (file)
@@ -27,14 +27,10 @@ static int null_write_packet(struct AVFormatContext *s, AVPacket *pkt)
 }
 
 AVOutputFormat ff_null_muxer = {
-    "null",
-    NULL_IF_CONFIG_SMALL("raw null video format"),
-    NULL,
-    NULL,
-    0,
-    AV_NE(CODEC_ID_PCM_S16BE, CODEC_ID_PCM_S16LE),
-    CODEC_ID_RAWVIDEO,
-    NULL,
-    null_write_packet,
+    .name              = "null",
+    .long_name         = NULL_IF_CONFIG_SMALL("raw null video format"),
+    .audio_codec       = AV_NE(CODEC_ID_PCM_S16BE, CODEC_ID_PCM_S16LE),
+    .video_codec       = CODEC_ID_RAWVIDEO,
+    .write_packet      = null_write_packet,
     .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE | AVFMT_NOTIMESTAMPS,
 };
index 93888a2..493ca7e 100644 (file)
@@ -924,14 +924,14 @@ static int nut_read_close(AVFormatContext *s)
 
 #if CONFIG_NUT_DEMUXER
 AVInputFormat ff_nut_demuxer = {
-    "nut",
-    NULL_IF_CONFIG_SMALL("NUT format"),
-    sizeof(NUTContext),
-    nut_probe,
-    nut_read_header,
-    nut_read_packet,
-    nut_read_close,
-    read_seek,
+    .name           = "nut",
+    .long_name      = NULL_IF_CONFIG_SMALL("NUT format"),
+    .priv_data_size = sizeof(NUTContext),
+    .read_probe     = nut_probe,
+    .read_header    = nut_read_header,
+    .read_packet    = nut_read_packet,
+    .read_close     = nut_read_close,
+    .read_seek      = read_seek,
     .extensions = "nut",
     .codec_tag = (const AVCodecTag * const []) { ff_codec_bmp_tags, ff_nut_video_tags, ff_codec_wav_tags, ff_nut_subtitle_tags, 0 },
 };
index 412c670..1ed073f 100644 (file)
@@ -861,22 +861,22 @@ static int write_trailer(AVFormatContext *s){
 }
 
 AVOutputFormat ff_nut_muxer = {
-    "nut",
-    NULL_IF_CONFIG_SMALL("NUT format"),
-    "video/x-nut",
-    "nut",
-    sizeof(NUTContext),
+    .name           = "nut",
+    .long_name      = NULL_IF_CONFIG_SMALL("NUT format"),
+    .mime_type      = "video/x-nut",
+    .extensions     = "nut",
+    .priv_data_size = sizeof(NUTContext),
 #if   CONFIG_LIBVORBIS
-    CODEC_ID_VORBIS,
+    .audio_codec    = CODEC_ID_VORBIS,
 #elif CONFIG_LIBMP3LAME
-    CODEC_ID_MP3,
+    .audio_codec    = CODEC_ID_MP3,
 #else
-    CODEC_ID_MP2,
+    .audio_codec    = CODEC_ID_MP2,
 #endif
-    CODEC_ID_MPEG4,
-    write_header,
-    write_packet,
-    write_trailer,
+    .video_codec    = CODEC_ID_MPEG4,
+    .write_header   = write_header,
+    .write_packet   = write_packet,
+    .write_trailer  = write_trailer,
     .flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS,
     .codec_tag = (const AVCodecTag * const []){ ff_codec_bmp_tags, ff_nut_video_tags, ff_codec_wav_tags, ff_nut_subtitle_tags, 0 },
 };
index 854aadd..36ec8fa 100644 (file)
@@ -259,13 +259,11 @@ static int nuv_packet(AVFormatContext *s, AVPacket *pkt) {
 }
 
 AVInputFormat ff_nuv_demuxer = {
-    "nuv",
-    NULL_IF_CONFIG_SMALL("NuppelVideo format"),
-    sizeof(NUVContext),
-    nuv_probe,
-    nuv_header,
-    nuv_packet,
-    NULL,
-    NULL,
+    .name           = "nuv",
+    .long_name      = NULL_IF_CONFIG_SMALL("NuppelVideo format"),
+    .priv_data_size = sizeof(NUVContext),
+    .read_probe     = nuv_probe,
+    .read_header    = nuv_header,
+    .read_packet    = nuv_packet,
     .flags = AVFMT_GENERIC_INDEX,
 };
index 2b2189c..49dedb3 100644 (file)
@@ -505,14 +505,14 @@ static int ogg_write_trailer(AVFormatContext *s)
 }
 
 AVOutputFormat ff_ogg_muxer = {
-    "ogg",
-    NULL_IF_CONFIG_SMALL("Ogg"),
-    "application/ogg",
-    "ogg,ogv,spx",
-    sizeof(OGGContext),
-    CODEC_ID_FLAC,
-    CODEC_ID_THEORA,
-    ogg_write_header,
-    ogg_write_packet,
-    ogg_write_trailer,
+    .name              = "ogg",
+    .long_name         = NULL_IF_CONFIG_SMALL("Ogg"),
+    .mime_type         = "application/ogg",
+    .extensions        = "ogg,ogv,spx",
+    .priv_data_size    = sizeof(OGGContext),
+    .audio_codec       = CODEC_ID_FLAC,
+    .video_codec       = CODEC_ID_THEORA,
+    .write_header      = ogg_write_header,
+    .write_packet      = ogg_write_packet,
+    .write_trailer     = ogg_write_trailer,
 };
index 0ec81eb..7675841 100644 (file)
@@ -192,14 +192,12 @@ static int oma_read_probe(AVProbeData *p)
 
 
 AVInputFormat ff_oma_demuxer = {
-    "oma",
-    NULL_IF_CONFIG_SMALL("Sony OpenMG audio"),
-    0,
-    oma_read_probe,
-    oma_read_header,
-    oma_read_packet,
-    0,
-    pcm_read_seek,
+    .name           = "oma",
+    .long_name      = NULL_IF_CONFIG_SMALL("Sony OpenMG audio"),
+    .read_probe     = oma_read_probe,
+    .read_header    = oma_read_header,
+    .read_packet    = oma_read_packet,
+    .read_seek      = pcm_read_seek,
     .flags= AVFMT_GENERIC_INDEX,
     .extensions = "oma,aa3",
     .codec_tag= (const AVCodecTag* const []){codec_oma_tags, 0},
index 6462442..ac6104f 100644 (file)
@@ -258,11 +258,11 @@ static int str_read_close(AVFormatContext *s)
 }
 
 AVInputFormat ff_str_demuxer = {
-    "psxstr",
-    NULL_IF_CONFIG_SMALL("Sony Playstation STR format"),
-    sizeof(StrDemuxContext),
-    str_probe,
-    str_read_header,
-    str_read_packet,
-    str_read_close,
+    .name           = "psxstr",
+    .long_name      = NULL_IF_CONFIG_SMALL("Sony Playstation STR format"),
+    .priv_data_size = sizeof(StrDemuxContext),
+    .read_probe     = str_probe,
+    .read_header    = str_read_header,
+    .read_packet    = str_read_packet,
+    .read_close     = str_read_close,
 };
index 79b959c..22fea40 100644 (file)
@@ -201,11 +201,11 @@ static int64_t pva_read_timestamp(struct AVFormatContext *s, int stream_index,
 }
 
 AVInputFormat ff_pva_demuxer = {
-    "pva",
-    NULL_IF_CONFIG_SMALL("TechnoTrend PVA file and stream format"),
-    sizeof(PVAContext),
-    pva_probe,
-    pva_read_header,
-    pva_read_packet,
+    .name           = "pva",
+    .long_name      = NULL_IF_CONFIG_SMALL("TechnoTrend PVA file and stream format"),
+    .priv_data_size = sizeof(PVAContext),
+    .read_probe     = pva_probe,
+    .read_header    = pva_read_header,
+    .read_packet    = pva_read_packet,
     .read_timestamp = pva_read_timestamp
 };
index 5dd7f99..890b3b9 100644 (file)
@@ -384,12 +384,12 @@ static int r3d_close(AVFormatContext *s)
 }
 
 AVInputFormat ff_r3d_demuxer = {
-    "r3d",
-    NULL_IF_CONFIG_SMALL("REDCODE R3D format"),
-    sizeof(R3DContext),
-    r3d_probe,
-    r3d_read_header,
-    r3d_read_packet,
-    r3d_close,
-    r3d_seek,
+    .name           = "r3d",
+    .long_name      = NULL_IF_CONFIG_SMALL("REDCODE R3D format"),
+    .priv_data_size = sizeof(R3DContext),
+    .read_probe     = r3d_probe,
+    .read_header    = r3d_read_header,
+    .read_packet    = r3d_read_packet,
+    .read_close     = r3d_close,
+    .read_seek      = r3d_seek,
 };
index cc05c35..8f3fecb 100644 (file)
@@ -217,12 +217,11 @@ const AVClass ff_rawvideo_demuxer_class = {
 
 #if CONFIG_G722_DEMUXER
 AVInputFormat ff_g722_demuxer = {
-    "g722",
-    NULL_IF_CONFIG_SMALL("raw G.722"),
-    sizeof(RawAudioDemuxerContext),
-    NULL,
-    ff_raw_read_header,
-    ff_raw_read_partial_packet,
+    .name           = "g722",
+    .long_name      = NULL_IF_CONFIG_SMALL("raw G.722"),
+    .priv_data_size = sizeof(RawAudioDemuxerContext),
+    .read_header    = ff_raw_read_header,
+    .read_packet    = ff_raw_read_partial_packet,
     .flags= AVFMT_GENERIC_INDEX,
     .extensions = "g722,722",
     .value = CODEC_ID_ADPCM_G722,
@@ -232,12 +231,10 @@ AVInputFormat ff_g722_demuxer = {
 
 #if CONFIG_GSM_DEMUXER
 AVInputFormat ff_gsm_demuxer = {
-    "gsm",
-    NULL_IF_CONFIG_SMALL("raw GSM"),
-    0,
-    NULL,
-    ff_raw_audio_read_header,
-    ff_raw_read_partial_packet,
+    .name           = "gsm",
+    .long_name      = NULL_IF_CONFIG_SMALL("raw GSM"),
+    .read_header    = ff_raw_audio_read_header,
+    .read_packet    = ff_raw_read_partial_packet,
     .flags= AVFMT_GENERIC_INDEX,
     .extensions = "gsm",
     .value = CODEC_ID_GSM,
@@ -250,12 +247,10 @@ FF_DEF_RAWVIDEO_DEMUXER(mjpeg, "raw MJPEG video", NULL, "mjpg,mjpeg", CODEC_ID_M
 
 #if CONFIG_MLP_DEMUXER
 AVInputFormat ff_mlp_demuxer = {
-    "mlp",
-    NULL_IF_CONFIG_SMALL("raw MLP"),
-    0,
-    NULL,
-    ff_raw_audio_read_header,
-    ff_raw_read_partial_packet,
+    .name           = "mlp",
+    .long_name      = NULL_IF_CONFIG_SMALL("raw MLP"),
+    .read_header    = ff_raw_audio_read_header,
+    .read_packet    = ff_raw_read_partial_packet,
     .flags= AVFMT_GENERIC_INDEX,
     .extensions = "mlp",
     .value = CODEC_ID_MLP,
@@ -264,12 +259,10 @@ AVInputFormat ff_mlp_demuxer = {
 
 #if CONFIG_TRUEHD_DEMUXER
 AVInputFormat ff_truehd_demuxer = {
-    "truehd",
-    NULL_IF_CONFIG_SMALL("raw TrueHD"),
-    0,
-    NULL,
-    ff_raw_audio_read_header,
-    ff_raw_read_partial_packet,
+    .name           = "truehd",
+    .long_name      = NULL_IF_CONFIG_SMALL("raw TrueHD"),
+    .read_header    = ff_raw_audio_read_header,
+    .read_packet    = ff_raw_read_partial_packet,
     .flags= AVFMT_GENERIC_INDEX,
     .extensions = "thd",
     .value = CODEC_ID_TRUEHD,
@@ -278,12 +271,10 @@ AVInputFormat ff_truehd_demuxer = {
 
 #if CONFIG_SHORTEN_DEMUXER
 AVInputFormat ff_shorten_demuxer = {
-    "shn",
-    NULL_IF_CONFIG_SMALL("raw Shorten"),
-    0,
-    NULL,
-    ff_raw_audio_read_header,
-    ff_raw_read_partial_packet,
+    .name           = "shn",
+    .long_name      = NULL_IF_CONFIG_SMALL("raw Shorten"),
+    .read_header    = ff_raw_audio_read_header,
+    .read_packet    = ff_raw_read_partial_packet,
     .flags= AVFMT_GENERIC_INDEX,
     .extensions = "shn",
     .value = CODEC_ID_SHORTEN,
index 00e43df..5f2065e 100644 (file)
@@ -34,195 +34,163 @@ int ff_raw_write_packet(AVFormatContext *s, AVPacket *pkt)
 
 #if CONFIG_AC3_MUXER
 AVOutputFormat ff_ac3_muxer = {
-    "ac3",
-    NULL_IF_CONFIG_SMALL("raw AC-3"),
-    "audio/x-ac3",
-    "ac3",
-    0,
-    CODEC_ID_AC3,
-    CODEC_ID_NONE,
-    NULL,
-    ff_raw_write_packet,
+    .name              = "ac3",
+    .long_name         = NULL_IF_CONFIG_SMALL("raw AC-3"),
+    .mime_type         = "audio/x-ac3",
+    .extensions        = "ac3",
+    .audio_codec       = CODEC_ID_AC3,
+    .video_codec       = CODEC_ID_NONE,
+    .write_packet      = ff_raw_write_packet,
     .flags= AVFMT_NOTIMESTAMPS,
 };
 #endif
 
 #if CONFIG_DIRAC_MUXER
 AVOutputFormat ff_dirac_muxer = {
-    "dirac",
-    NULL_IF_CONFIG_SMALL("raw Dirac"),
-    NULL,
-    "drc",
-    0,
-    CODEC_ID_NONE,
-    CODEC_ID_DIRAC,
-    NULL,
-    ff_raw_write_packet,
+    .name              = "dirac",
+    .long_name         = NULL_IF_CONFIG_SMALL("raw Dirac"),
+    .extensions        = "drc",
+    .audio_codec       = CODEC_ID_NONE,
+    .video_codec       = CODEC_ID_DIRAC,
+    .write_packet      = ff_raw_write_packet,
     .flags= AVFMT_NOTIMESTAMPS,
 };
 #endif
 
 #if CONFIG_DNXHD_MUXER
 AVOutputFormat ff_dnxhd_muxer = {
-    "dnxhd",
-    NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),
-    NULL,
-    "dnxhd",
-    0,
-    CODEC_ID_NONE,
-    CODEC_ID_DNXHD,
-    NULL,
-    ff_raw_write_packet,
+    .name              = "dnxhd",
+    .long_name         = NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),
+    .extensions        = "dnxhd",
+    .audio_codec       = CODEC_ID_NONE,
+    .video_codec       = CODEC_ID_DNXHD,
+    .write_packet      = ff_raw_write_packet,
     .flags= AVFMT_NOTIMESTAMPS,
 };
 #endif
 
 #if CONFIG_DTS_MUXER
 AVOutputFormat ff_dts_muxer = {
-    "dts",
-    NULL_IF_CONFIG_SMALL("raw DTS"),
-    "audio/x-dca",
-    "dts",
-    0,
-    CODEC_ID_DTS,
-    CODEC_ID_NONE,
-    NULL,
-    ff_raw_write_packet,
+    .name              = "dts",
+    .long_name         = NULL_IF_CONFIG_SMALL("raw DTS"),
+    .mime_type         = "audio/x-dca",
+    .extensions        = "dts",
+    .audio_codec       = CODEC_ID_DTS,
+    .video_codec       = CODEC_ID_NONE,
+    .write_packet      = ff_raw_write_packet,
     .flags= AVFMT_NOTIMESTAMPS,
 };
 #endif
 
 #if CONFIG_EAC3_MUXER
 AVOutputFormat ff_eac3_muxer = {
-    "eac3",
-    NULL_IF_CONFIG_SMALL("raw E-AC-3"),
-    "audio/x-eac3",
-    "eac3",
-    0,
-    CODEC_ID_EAC3,
-    CODEC_ID_NONE,
-    NULL,
-    ff_raw_write_packet,
+    .name              = "eac3",
+    .long_name         = NULL_IF_CONFIG_SMALL("raw E-AC-3"),
+    .mime_type         = "audio/x-eac3",
+    .extensions        = "eac3",
+    .audio_codec       = CODEC_ID_EAC3,
+    .video_codec       = CODEC_ID_NONE,
+    .write_packet      = ff_raw_write_packet,
     .flags= AVFMT_NOTIMESTAMPS,
 };
 #endif
 
 #if CONFIG_G722_MUXER
 AVOutputFormat ff_g722_muxer = {
-    "g722",
-    NULL_IF_CONFIG_SMALL("raw G.722"),
-    "audio/G722",
-    "g722",
-    0,
-    CODEC_ID_ADPCM_G722,
-    CODEC_ID_NONE,
-    NULL,
-    ff_raw_write_packet,
+    .name              = "g722",
+    .long_name         = NULL_IF_CONFIG_SMALL("raw G.722"),
+    .mime_type         = "audio/G722",
+    .extensions        = "g722",
+    .audio_codec       = CODEC_ID_ADPCM_G722,
+    .video_codec       = CODEC_ID_NONE,
+    .write_packet      = ff_raw_write_packet,
     .flags= AVFMT_NOTIMESTAMPS,
 };
 #endif
 
 #if CONFIG_H261_MUXER
 AVOutputFormat ff_h261_muxer = {
-    "h261",
-    NULL_IF_CONFIG_SMALL("raw H.261"),
-    "video/x-h261",
-    "h261",
-    0,
-    CODEC_ID_NONE,
-    CODEC_ID_H261,
-    NULL,
-    ff_raw_write_packet,
+    .name              = "h261",
+    .long_name         = NULL_IF_CONFIG_SMALL("raw H.261"),
+    .mime_type         = "video/x-h261",
+    .extensions        = "h261",
+    .audio_codec       = CODEC_ID_NONE,
+    .video_codec       = CODEC_ID_H261,
+    .write_packet      = ff_raw_write_packet,
     .flags= AVFMT_NOTIMESTAMPS,
 };
 #endif
 
 #if CONFIG_H263_MUXER
 AVOutputFormat ff_h263_muxer = {
-    "h263",
-    NULL_IF_CONFIG_SMALL("raw H.263"),
-    "video/x-h263",
-    "h263",
-    0,
-    CODEC_ID_NONE,
-    CODEC_ID_H263,
-    NULL,
-    ff_raw_write_packet,
+    .name              = "h263",
+    .long_name         = NULL_IF_CONFIG_SMALL("raw H.263"),
+    .mime_type         = "video/x-h263",
+    .extensions        = "h263",
+    .audio_codec       = CODEC_ID_NONE,
+    .video_codec       = CODEC_ID_H263,
+    .write_packet      = ff_raw_write_packet,
     .flags= AVFMT_NOTIMESTAMPS,
 };
 #endif
 
 #if CONFIG_H264_MUXER
 AVOutputFormat ff_h264_muxer = {
-    "h264",
-    NULL_IF_CONFIG_SMALL("raw H.264 video format"),
-    NULL,
-    "h264",
-    0,
-    CODEC_ID_NONE,
-    CODEC_ID_H264,
-    NULL,
-    ff_raw_write_packet,
+    .name              = "h264",
+    .long_name         = NULL_IF_CONFIG_SMALL("raw H.264 video format"),
+    .extensions        = "h264",
+    .audio_codec       = CODEC_ID_NONE,
+    .video_codec       = CODEC_ID_H264,
+    .write_packet      = ff_raw_write_packet,
     .flags= AVFMT_NOTIMESTAMPS,
 };
 #endif
 
 #if CONFIG_CAVSVIDEO_MUXER
 AVOutputFormat ff_cavsvideo_muxer = {
-    "cavsvideo",
-    NULL_IF_CONFIG_SMALL("raw Chinese AVS video"),
-    NULL,
-    "cavs",
-    0,
-    CODEC_ID_NONE,
-    CODEC_ID_CAVS,
-    NULL,
-    ff_raw_write_packet,
+    .name              = "cavsvideo",
+    .long_name         = NULL_IF_CONFIG_SMALL("raw Chinese AVS video"),
+    .extensions        = "cavs",
+    .audio_codec       = CODEC_ID_NONE,
+    .video_codec       = CODEC_ID_CAVS,
+    .write_packet      = ff_raw_write_packet,
     .flags= AVFMT_NOTIMESTAMPS,
 };
 #endif
 
 #if CONFIG_M4V_MUXER
 AVOutputFormat ff_m4v_muxer = {
-    "m4v",
-    NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
-    NULL,
-    "m4v",
-    0,
-    CODEC_ID_NONE,
-    CODEC_ID_MPEG4,
-    NULL,
-    ff_raw_write_packet,
+    .name              = "m4v",
+    .long_name         = NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
+    .extensions        = "m4v",
+    .audio_codec       = CODEC_ID_NONE,
+    .video_codec       = CODEC_ID_MPEG4,
+    .write_packet      = ff_raw_write_packet,
     .flags= AVFMT_NOTIMESTAMPS,
 };
 #endif
 
 #if CONFIG_MJPEG_MUXER
 AVOutputFormat ff_mjpeg_muxer = {
-    "mjpeg",
-    NULL_IF_CONFIG_SMALL("raw MJPEG video"),
-    "video/x-mjpeg",
-    "mjpg,mjpeg",
-    0,
-    CODEC_ID_NONE,
-    CODEC_ID_MJPEG,
-    NULL,
-    ff_raw_write_packet,
+    .name              = "mjpeg",
+    .long_name         = NULL_IF_CONFIG_SMALL("raw MJPEG video"),
+    .mime_type         = "video/x-mjpeg",
+    .extensions        = "mjpg,mjpeg",
+    .audio_codec       = CODEC_ID_NONE,
+    .video_codec       = CODEC_ID_MJPEG,
+    .write_packet      = ff_raw_write_packet,
     .flags= AVFMT_NOTIMESTAMPS,
 };
 #endif
 
 #if CONFIG_MLP_MUXER
 AVOutputFormat ff_mlp_muxer = {
-    "mlp",
-    NULL_IF_CONFIG_SMALL("raw MLP"),
-    NULL,
-    "mlp",
-    0,
-    CODEC_ID_MLP,
-    CODEC_ID_NONE,
-    NULL,
-    ff_raw_write_packet,
+    .name              = "mlp",
+    .long_name         = NULL_IF_CONFIG_SMALL("raw MLP"),
+    .extensions        = "mlp",
+    .audio_codec       = CODEC_ID_MLP,
+    .video_codec       = CODEC_ID_NONE,
+    .write_packet      = ff_raw_write_packet,
     .flags= AVFMT_NOTIMESTAMPS,
 };
 #endif
@@ -241,60 +209,49 @@ AVOutputFormat ff_srt_muxer = {
 
 #if CONFIG_TRUEHD_MUXER
 AVOutputFormat ff_truehd_muxer = {
-    "truehd",
-    NULL_IF_CONFIG_SMALL("raw TrueHD"),
-    NULL,
-    "thd",
-    0,
-    CODEC_ID_TRUEHD,
-    CODEC_ID_NONE,
-    NULL,
-    ff_raw_write_packet,
+    .name              = "truehd",
+    .long_name         = NULL_IF_CONFIG_SMALL("raw TrueHD"),
+    .extensions        = "thd",
+    .audio_codec       = CODEC_ID_TRUEHD,
+    .video_codec       = CODEC_ID_NONE,
+    .write_packet      = ff_raw_write_packet,
     .flags= AVFMT_NOTIMESTAMPS,
 };
 #endif
 
 #if CONFIG_MPEG1VIDEO_MUXER
 AVOutputFormat ff_mpeg1video_muxer = {
-    "mpeg1video",
-    NULL_IF_CONFIG_SMALL("raw MPEG-1 video"),
-    "video/x-mpeg",
-    "mpg,mpeg,m1v",
-    0,
-    CODEC_ID_NONE,
-    CODEC_ID_MPEG1VIDEO,
-    NULL,
-    ff_raw_write_packet,
+    .name              = "mpeg1video",
+    .long_name         = NULL_IF_CONFIG_SMALL("raw MPEG-1 video"),
+    .mime_type         = "video/x-mpeg",
+    .extensions        = "mpg,mpeg,m1v",
+    .audio_codec       = CODEC_ID_NONE,
+    .video_codec       = CODEC_ID_MPEG1VIDEO,
+    .write_packet      = ff_raw_write_packet,
     .flags= AVFMT_NOTIMESTAMPS,
 };
 #endif
 
 #if CONFIG_MPEG2VIDEO_MUXER
 AVOutputFormat ff_mpeg2video_muxer = {
-    "mpeg2video",
-    NULL_IF_CONFIG_SMALL("raw MPEG-2 video"),
-    NULL,
-    "m2v",
-    0,
-    CODEC_ID_NONE,
-    CODEC_ID_MPEG2VIDEO,
-    NULL,
-    ff_raw_write_packet,
+    .name              = "mpeg2video",
+    .long_name         = NULL_IF_CONFIG_SMALL("raw MPEG-2 video"),
+    .extensions        = "m2v",
+    .audio_codec       = CODEC_ID_NONE,
+    .video_codec       = CODEC_ID_MPEG2VIDEO,
+    .write_packet      = ff_raw_write_packet,
     .flags= AVFMT_NOTIMESTAMPS,
 };
 #endif
 
 #if CONFIG_RAWVIDEO_MUXER
 AVOutputFormat ff_rawvideo_muxer = {
-    "rawvideo",
-    NULL_IF_CONFIG_SMALL("raw video format"),
-    NULL,
-    "yuv,rgb",
-    0,
-    CODEC_ID_NONE,
-    CODEC_ID_RAWVIDEO,
-    NULL,
-    ff_raw_write_packet,
+    .name              = "rawvideo",
+    .long_name         = NULL_IF_CONFIG_SMALL("raw video format"),
+    .extensions        = "yuv,rgb",
+    .audio_codec       = CODEC_ID_NONE,
+    .video_codec       = CODEC_ID_RAWVIDEO,
+    .write_packet      = ff_raw_write_packet,
     .flags= AVFMT_NOTIMESTAMPS,
 };
 #endif
index f8d9b65..e1c52ab 100644 (file)
@@ -45,12 +45,11 @@ static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_rawvideo_demuxer = {
-    "rawvideo",
-    NULL_IF_CONFIG_SMALL("raw video format"),
-    sizeof(FFRawVideoDemuxerContext),
-    NULL,
-    ff_raw_read_header,
-    rawvideo_read_packet,
+    .name           = "rawvideo",
+    .long_name      = NULL_IF_CONFIG_SMALL("raw video format"),
+    .priv_data_size = sizeof(FFRawVideoDemuxerContext),
+    .read_header    = ff_raw_read_header,
+    .read_packet    = rawvideo_read_packet,
     .flags= AVFMT_GENERIC_INDEX,
     .extensions = "yuv,cif,qcif,rgb",
     .value = CODEC_ID_RAWVIDEO,
index c84e4e1..42b46a8 100644 (file)
@@ -286,13 +286,12 @@ static int rl2_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp
 }
 
 AVInputFormat ff_rl2_demuxer = {
-    "rl2",
-    NULL_IF_CONFIG_SMALL("RL2 format"),
-    sizeof(Rl2DemuxContext),
-    rl2_probe,
-    rl2_read_header,
-    rl2_read_packet,
-    NULL,
-    rl2_read_seek,
+    .name           = "rl2",
+    .long_name      = NULL_IF_CONFIG_SMALL("RL2 format"),
+    .priv_data_size = sizeof(Rl2DemuxContext),
+    .read_probe     = rl2_probe,
+    .read_header    = rl2_read_header,
+    .read_packet    = rl2_read_packet,
+    .read_seek      = rl2_read_seek,
 };
 
index 69c4ffe..3f4d333 100644 (file)
@@ -935,23 +935,19 @@ static int64_t rm_read_dts(AVFormatContext *s, int stream_index,
 }
 
 AVInputFormat ff_rm_demuxer = {
-    "rm",
-    NULL_IF_CONFIG_SMALL("RealMedia format"),
-    sizeof(RMDemuxContext),
-    rm_probe,
-    rm_read_header,
-    rm_read_packet,
-    rm_read_close,
-    NULL,
-    rm_read_dts,
+    .name           = "rm",
+    .long_name      = NULL_IF_CONFIG_SMALL("RealMedia format"),
+    .priv_data_size = sizeof(RMDemuxContext),
+    .read_probe     = rm_probe,
+    .read_header    = rm_read_header,
+    .read_packet    = rm_read_packet,
+    .read_close     = rm_read_close,
+    .read_timestamp = rm_read_dts,
 };
 
 AVInputFormat ff_rdt_demuxer = {
-    "rdt",
-    NULL_IF_CONFIG_SMALL("RDT demuxer"),
-    sizeof(RMDemuxContext),
-    NULL,
-    NULL,
-    NULL,
-    rm_read_close,
+    .name           = "rdt",
+    .long_name      = NULL_IF_CONFIG_SMALL("RDT demuxer"),
+    .priv_data_size = sizeof(RMDemuxContext),
+    .read_close     = rm_read_close,
 };
index 2476cb0..0846a0a 100644 (file)
@@ -461,15 +461,15 @@ static int rm_write_trailer(AVFormatContext *s)
 
 
 AVOutputFormat ff_rm_muxer = {
-    "rm",
-    NULL_IF_CONFIG_SMALL("RealMedia format"),
-    "application/vnd.rn-realmedia",
-    "rm,ra",
-    sizeof(RMMuxContext),
-    CODEC_ID_AC3,
-    CODEC_ID_RV10,
-    rm_write_header,
-    rm_write_packet,
-    rm_write_trailer,
+    .name              = "rm",
+    .long_name         = NULL_IF_CONFIG_SMALL("RealMedia format"),
+    .mime_type         = "application/vnd.rn-realmedia",
+    .extensions        = "rm,ra",
+    .priv_data_size    = sizeof(RMMuxContext),
+    .audio_codec       = CODEC_ID_AC3,
+    .video_codec       = CODEC_ID_RV10,
+    .write_header      = rm_write_header,
+    .write_packet      = rm_write_packet,
+    .write_trailer     = rm_write_trailer,
     .codec_tag= (const AVCodecTag* const []){ff_rm_codec_tags, 0},
 };
index f67d3cd..1e2f65f 100644 (file)
@@ -351,10 +351,10 @@ static int rpl_read_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_rpl_demuxer = {
-    "rpl",
-    NULL_IF_CONFIG_SMALL("RPL/ARMovie format"),
-    sizeof(RPLContext),
-    rpl_probe,
-    rpl_read_header,
-    rpl_read_packet,
+    .name           = "rpl",
+    .long_name      = NULL_IF_CONFIG_SMALL("RPL/ARMovie format"),
+    .priv_data_size = sizeof(RPLContext),
+    .read_probe     = rpl_probe,
+    .read_header    = rpl_read_header,
+    .read_packet    = rpl_read_packet,
 };
index c412158..ef261c3 100644 (file)
@@ -462,15 +462,13 @@ static int rtp_write_trailer(AVFormatContext *s1)
 }
 
 AVOutputFormat ff_rtp_muxer = {
-    "rtp",
-    NULL_IF_CONFIG_SMALL("RTP output format"),
-    NULL,
-    NULL,
-    sizeof(RTPMuxContext),
-    CODEC_ID_PCM_MULAW,
-    CODEC_ID_NONE,
-    rtp_write_header,
-    rtp_write_packet,
-    rtp_write_trailer,
+    .name              = "rtp",
+    .long_name         = NULL_IF_CONFIG_SMALL("RTP output format"),
+    .priv_data_size    = sizeof(RTPMuxContext),
+    .audio_codec       = CODEC_ID_PCM_MULAW,
+    .video_codec       = CODEC_ID_NONE,
+    .write_header      = rtp_write_header,
+    .write_packet      = rtp_write_packet,
+    .write_trailer     = rtp_write_trailer,
     .priv_class = &rtp_muxer_class,
 };
index ce9bf1e..949c174 100644 (file)
@@ -1824,13 +1824,13 @@ static int sdp_read_close(AVFormatContext *s)
 }
 
 AVInputFormat ff_sdp_demuxer = {
-    "sdp",
-    NULL_IF_CONFIG_SMALL("SDP"),
-    sizeof(RTSPState),
-    sdp_probe,
-    sdp_read_header,
-    ff_rtsp_fetch_packet,
-    sdp_read_close,
+    .name           = "sdp",
+    .long_name      = NULL_IF_CONFIG_SMALL("SDP"),
+    .priv_data_size = sizeof(RTSPState),
+    .read_probe     = sdp_probe,
+    .read_header    = sdp_read_header,
+    .read_packet    = ff_rtsp_fetch_packet,
+    .read_close     = sdp_read_close,
 };
 #endif /* CONFIG_SDP_DEMUXER */
 
@@ -1928,13 +1928,13 @@ fail:
 }
 
 AVInputFormat ff_rtp_demuxer = {
-    "rtp",
-    NULL_IF_CONFIG_SMALL("RTP input format"),
-    sizeof(RTSPState),
-    rtp_probe,
-    rtp_read_header,
-    ff_rtsp_fetch_packet,
-    sdp_read_close,
+    .name           = "rtp",
+    .long_name      = NULL_IF_CONFIG_SMALL("RTP input format"),
+    .priv_data_size = sizeof(RTSPState),
+    .read_probe     = rtp_probe,
+    .read_header    = rtp_read_header,
+    .read_packet    = ff_rtsp_fetch_packet,
+    .read_close     = sdp_read_close,
     .flags = AVFMT_NOFILE,
 };
 #endif /* CONFIG_RTP_DEMUXER */
index 2dff46d..d154615 100644 (file)
@@ -412,14 +412,14 @@ const AVClass rtsp_demuxer_class = {
 };
 
 AVInputFormat ff_rtsp_demuxer = {
-    "rtsp",
-    NULL_IF_CONFIG_SMALL("RTSP input format"),
-    sizeof(RTSPState),
-    rtsp_probe,
-    rtsp_read_header,
-    rtsp_read_packet,
-    rtsp_read_close,
-    rtsp_read_seek,
+    .name           = "rtsp",
+    .long_name      = NULL_IF_CONFIG_SMALL("RTSP input format"),
+    .priv_data_size = sizeof(RTSPState),
+    .read_probe     = rtsp_probe,
+    .read_header    = rtsp_read_header,
+    .read_packet    = rtsp_read_packet,
+    .read_close     = rtsp_read_close,
+    .read_seek      = rtsp_read_seek,
     .flags = AVFMT_NOFILE,
     .read_play = rtsp_read_play,
     .read_pause = rtsp_read_pause,
index b76b6ad..faf76c0 100644 (file)
@@ -241,16 +241,14 @@ static int rtsp_write_close(AVFormatContext *s)
 }
 
 AVOutputFormat ff_rtsp_muxer = {
-    "rtsp",
-    NULL_IF_CONFIG_SMALL("RTSP output format"),
-    NULL,
-    NULL,
-    sizeof(RTSPState),
-    CODEC_ID_AAC,
-    CODEC_ID_MPEG4,
-    rtsp_write_header,
-    rtsp_write_packet,
-    rtsp_write_close,
+    .name              = "rtsp",
+    .long_name         = NULL_IF_CONFIG_SMALL("RTSP output format"),
+    .priv_data_size    = sizeof(RTSPState),
+    .audio_codec       = CODEC_ID_AAC,
+    .video_codec       = CODEC_ID_MPEG4,
+    .write_header      = rtsp_write_header,
+    .write_packet      = rtsp_write_packet,
+    .write_trailer     = rtsp_write_close,
     .flags = AVFMT_NOFILE | AVFMT_GLOBALHEADER,
     .priv_class = &rtsp_muxer_class,
 };
index 15d772c..c317821 100644 (file)
@@ -224,13 +224,13 @@ static int sap_fetch_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_sap_demuxer = {
-    "sap",
-    NULL_IF_CONFIG_SMALL("SAP input format"),
-    sizeof(struct SAPState),
-    sap_probe,
-    sap_read_header,
-    sap_fetch_packet,
-    sap_read_close,
+    .name           = "sap",
+    .long_name      = NULL_IF_CONFIG_SMALL("SAP input format"),
+    .priv_data_size = sizeof(struct SAPState),
+    .read_probe     = sap_probe,
+    .read_header    = sap_read_header,
+    .read_packet    = sap_fetch_packet,
+    .read_close     = sap_read_close,
     .flags = AVFMT_NOFILE,
 };
 
index 3abd79e..06cac93 100644 (file)
@@ -250,16 +250,14 @@ static int sap_write_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVOutputFormat ff_sap_muxer = {
-    "sap",
-    NULL_IF_CONFIG_SMALL("SAP output format"),
-    NULL,
-    NULL,
-    sizeof(struct SAPState),
-    CODEC_ID_AAC,
-    CODEC_ID_MPEG4,
-    sap_write_header,
-    sap_write_packet,
-    sap_write_close,
+    .name              = "sap",
+    .long_name         = NULL_IF_CONFIG_SMALL("SAP output format"),
+    .priv_data_size    = sizeof(struct SAPState),
+    .audio_codec       = CODEC_ID_AAC,
+    .video_codec       = CODEC_ID_MPEG4,
+    .write_header      = sap_write_header,
+    .write_packet      = sap_write_packet,
+    .write_trailer     = sap_write_close,
     .flags = AVFMT_NOFILE | AVFMT_GLOBALHEADER,
 };
 
index 0886825..81f04c6 100644 (file)
@@ -297,11 +297,11 @@ static int film_read_close(AVFormatContext *s)
 }
 
 AVInputFormat ff_segafilm_demuxer = {
-    "film_cpk",
-    NULL_IF_CONFIG_SMALL("Sega FILM/CPK format"),
-    sizeof(FilmDemuxContext),
-    film_probe,
-    film_read_header,
-    film_read_packet,
-    film_read_close,
+    .name           = "film_cpk",
+    .long_name      = NULL_IF_CONFIG_SMALL("Sega FILM/CPK format"),
+    .priv_data_size = sizeof(FilmDemuxContext),
+    .read_probe     = film_probe,
+    .read_header    = film_read_header,
+    .read_packet    = film_read_packet,
+    .read_close     = film_read_close,
 };
index c0fb222..4539cfb 100644 (file)
@@ -281,11 +281,11 @@ static int vmd_read_close(AVFormatContext *s)
 }
 
 AVInputFormat ff_vmd_demuxer = {
-    "vmd",
-    NULL_IF_CONFIG_SMALL("Sierra VMD format"),
-    sizeof(VmdDemuxContext),
-    vmd_probe,
-    vmd_read_header,
-    vmd_read_packet,
-    vmd_read_close,
+    .name           = "vmd",
+    .long_name      = NULL_IF_CONFIG_SMALL("Sierra VMD format"),
+    .priv_data_size = sizeof(VmdDemuxContext),
+    .read_probe     = vmd_probe,
+    .read_header    = vmd_read_header,
+    .read_packet    = vmd_read_packet,
+    .read_close     = vmd_read_close,
 };
index 23c122f..cdb6452 100644 (file)
@@ -228,11 +228,11 @@ static int siff_read_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_siff_demuxer = {
-    "siff",
-    NULL_IF_CONFIG_SMALL("Beam Software SIFF"),
-    sizeof(SIFFContext),
-    siff_probe,
-    siff_read_header,
-    siff_read_packet,
+    .name           = "siff",
+    .long_name      = NULL_IF_CONFIG_SMALL("Beam Software SIFF"),
+    .priv_data_size = sizeof(SIFFContext),
+    .read_probe     = siff_probe,
+    .read_header    = siff_read_header,
+    .read_packet    = siff_read_packet,
     .extensions = "vb,son"
 };
index db9a02b..51a3b1b 100644 (file)
@@ -340,11 +340,11 @@ static int smacker_read_close(AVFormatContext *s)
 }
 
 AVInputFormat ff_smacker_demuxer = {
-    "smk",
-    NULL_IF_CONFIG_SMALL("Smacker video"),
-    sizeof(SmackerContext),
-    smacker_probe,
-    smacker_read_header,
-    smacker_read_packet,
-    smacker_read_close,
+    .name           = "smk",
+    .long_name      = NULL_IF_CONFIG_SMALL("Smacker video"),
+    .priv_data_size = sizeof(SmackerContext),
+    .read_probe     = smacker_probe,
+    .read_header    = smacker_read_header,
+    .read_packet    = smacker_read_packet,
+    .read_close     = smacker_read_close,
 };
index 1ebb4d2..6ca8d1c 100644 (file)
@@ -141,12 +141,10 @@ static int sol_read_packet(AVFormatContext *s,
 }
 
 AVInputFormat ff_sol_demuxer = {
-    "sol",
-    NULL_IF_CONFIG_SMALL("Sierra SOL format"),
-    0,
-    sol_probe,
-    sol_read_header,
-    sol_read_packet,
-    NULL,
-    pcm_read_seek,
+    .name           = "sol",
+    .long_name      = NULL_IF_CONFIG_SMALL("Sierra SOL format"),
+    .read_probe     = sol_probe,
+    .read_header    = sol_read_header,
+    .read_packet    = sol_read_packet,
+    .read_seek      = pcm_read_seek,
 };
index 7661bf1..504c837 100644 (file)
@@ -143,12 +143,10 @@ static int sox_read_packet(AVFormatContext *s,
 }
 
 AVInputFormat ff_sox_demuxer = {
-    "sox",
-    NULL_IF_CONFIG_SMALL("SoX native format"),
-    0,
-    sox_probe,
-    sox_read_header,
-    sox_read_packet,
-    NULL,
-    pcm_read_seek,
+    .name           = "sox",
+    .long_name      = NULL_IF_CONFIG_SMALL("SoX native format"),
+    .read_probe     = sox_probe,
+    .read_header    = sox_read_header,
+    .read_packet    = sox_read_packet,
+    .read_seek      = pcm_read_seek,
 };
index d7afe70..b89203c 100644 (file)
@@ -116,14 +116,13 @@ static int sox_write_trailer(AVFormatContext *s)
 }
 
 AVOutputFormat ff_sox_muxer = {
-    "sox",
-    NULL_IF_CONFIG_SMALL("SoX native format"),
-    NULL,
-    "sox",
-    sizeof(SoXContext),
-    CODEC_ID_PCM_S32LE,
-    CODEC_ID_NONE,
-    sox_write_header,
-    sox_write_packet,
-    sox_write_trailer,
+    .name              = "sox",
+    .long_name         = NULL_IF_CONFIG_SMALL("SoX native format"),
+    .extensions        = "sox",
+    .priv_data_size    = sizeof(SoXContext),
+    .audio_codec       = CODEC_ID_PCM_S32LE,
+    .video_codec       = CODEC_ID_NONE,
+    .write_header      = sox_write_header,
+    .write_packet      = sox_write_packet,
+    .write_trailer     = sox_write_trailer,
 };
index 1c09025..fa2ddeb 100644 (file)
@@ -226,11 +226,10 @@ static int spdif_read_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_spdif_demuxer = {
-    "spdif",
-    NULL_IF_CONFIG_SMALL("IEC 61937 (compressed data in S/PDIF)"),
-    0,
-    spdif_probe,
-    spdif_read_header,
-    spdif_read_packet,
+    .name           = "spdif",
+    .long_name      = NULL_IF_CONFIG_SMALL("IEC 61937 (compressed data in S/PDIF)"),
+    .read_probe     = spdif_probe,
+    .read_header    = spdif_read_header,
+    .read_packet    = spdif_read_packet,
     .flags = AVFMT_GENERIC_INDEX,
 };
index 7355460..4773483 100644 (file)
@@ -541,16 +541,15 @@ static int spdif_write_packet(struct AVFormatContext *s, AVPacket *pkt)
 }
 
 AVOutputFormat ff_spdif_muxer = {
-    "spdif",
-    NULL_IF_CONFIG_SMALL("IEC 61937 (used on S/PDIF - IEC958)"),
-    NULL,
-    "spdif",
-    sizeof(IEC61937Context),
-    CODEC_ID_AC3,
-    CODEC_ID_NONE,
-    spdif_write_header,
-    spdif_write_packet,
-    spdif_write_trailer,
+    .name              = "spdif",
+    .long_name         = NULL_IF_CONFIG_SMALL("IEC 61937 (used on S/PDIF - IEC958)"),
+    .extensions        = "spdif",
+    .priv_data_size    = sizeof(IEC61937Context),
+    .audio_codec       = CODEC_ID_AC3,
+    .video_codec       = CODEC_ID_NONE,
+    .write_header      = spdif_write_header,
+    .write_packet      = spdif_write_packet,
+    .write_trailer     = spdif_write_trailer,
     .flags = AVFMT_NOTIMESTAMPS,
     .priv_class = &class,
 };
index c838fa8..59977a9 100644 (file)
@@ -207,10 +207,10 @@ static int swf_read_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_swf_demuxer = {
-    "swf",
-    NULL_IF_CONFIG_SMALL("Flash format"),
-    sizeof(SWFContext),
-    swf_probe,
-    swf_read_header,
-    swf_read_packet,
+    .name           = "swf",
+    .long_name      = NULL_IF_CONFIG_SMALL("Flash format"),
+    .priv_data_size = sizeof(SWFContext),
+    .read_probe     = swf_probe,
+    .read_header    = swf_read_header,
+    .read_packet    = swf_read_packet,
 };
index 4c5c315..f4494cd 100644 (file)
@@ -507,29 +507,28 @@ static int swf_write_trailer(AVFormatContext *s)
 
 #if CONFIG_SWF_MUXER
 AVOutputFormat ff_swf_muxer = {
-    "swf",
-    NULL_IF_CONFIG_SMALL("Flash format"),
-    "application/x-shockwave-flash",
-    "swf",
-    sizeof(SWFContext),
-    CODEC_ID_MP3,
-    CODEC_ID_FLV1,
-    swf_write_header,
-    swf_write_packet,
-    swf_write_trailer,
+    .name              = "swf",
+    .long_name         = NULL_IF_CONFIG_SMALL("Flash format"),
+    .mime_type         = "application/x-shockwave-flash",
+    .extensions        = "swf",
+    .priv_data_size    = sizeof(SWFContext),
+    .audio_codec       = CODEC_ID_MP3,
+    .video_codec       = CODEC_ID_FLV1,
+    .write_header      = swf_write_header,
+    .write_packet      = swf_write_packet,
+    .write_trailer     = swf_write_trailer,
 };
 #endif
 #if CONFIG_AVM2_MUXER
 AVOutputFormat ff_avm2_muxer = {
-    "avm2",
-    NULL_IF_CONFIG_SMALL("Flash 9 (AVM2) format"),
-    "application/x-shockwave-flash",
-    NULL,
-    sizeof(SWFContext),
-    CODEC_ID_MP3,
-    CODEC_ID_FLV1,
-    swf_write_header,
-    swf_write_packet,
-    swf_write_trailer,
+    .name              = "avm2",
+    .long_name         = NULL_IF_CONFIG_SMALL("Flash 9 (AVM2) format"),
+    .mime_type         = "application/x-shockwave-flash",
+    .priv_data_size    = sizeof(SWFContext),
+    .audio_codec       = CODEC_ID_MP3,
+    .video_codec       = CODEC_ID_FLV1,
+    .write_header      = swf_write_header,
+    .write_packet      = swf_write_packet,
+    .write_trailer     = swf_write_trailer,
 };
 #endif
index 51dbd81..3941977 100644 (file)
@@ -189,10 +189,10 @@ static int thp_read_packet(AVFormatContext *s,
 }
 
 AVInputFormat ff_thp_demuxer = {
-    "thp",
-    NULL_IF_CONFIG_SMALL("THP"),
-    sizeof(ThpDemuxContext),
-    thp_probe,
-    thp_read_header,
-    thp_read_packet
+    .name           = "thp",
+    .long_name      = NULL_IF_CONFIG_SMALL("THP"),
+    .priv_data_size = sizeof(ThpDemuxContext),
+    .read_probe     = thp_probe,
+    .read_header    = thp_read_header,
+    .read_packet    = thp_read_packet
 };
index 7ca0464..41ee3c6 100644 (file)
@@ -303,11 +303,11 @@ static int seq_read_close(AVFormatContext *s)
 }
 
 AVInputFormat ff_tiertexseq_demuxer = {
-    "tiertexseq",
-    NULL_IF_CONFIG_SMALL("Tiertex Limited SEQ format"),
-    sizeof(SeqDemuxContext),
-    seq_probe,
-    seq_read_header,
-    seq_read_packet,
-    seq_read_close,
+    .name           = "tiertexseq",
+    .long_name      = NULL_IF_CONFIG_SMALL("Tiertex Limited SEQ format"),
+    .priv_data_size = sizeof(SeqDemuxContext),
+    .read_probe     = seq_probe,
+    .read_header    = seq_read_header,
+    .read_packet    = seq_read_packet,
+    .read_close     = seq_read_close,
 };
index fe8b64b..10d78e1 100644 (file)
@@ -179,13 +179,12 @@ static int tmv_read_seek(AVFormatContext *s, int stream_index,
 }
 
 AVInputFormat ff_tmv_demuxer = {
-    "tmv",
-    NULL_IF_CONFIG_SMALL("8088flex TMV"),
-    sizeof(TMVContext),
-    tmv_probe,
-    tmv_read_header,
-    tmv_read_packet,
-    NULL,
-    tmv_read_seek,
+    .name           = "tmv",
+    .long_name      = NULL_IF_CONFIG_SMALL("8088flex TMV"),
+    .priv_data_size = sizeof(TMVContext),
+    .read_probe     = tmv_probe,
+    .read_header    = tmv_read_header,
+    .read_packet    = tmv_read_packet,
+    .read_seek      = tmv_read_seek,
     .flags = AVFMT_GENERIC_INDEX,
 };
index 49234a8..d049d5e 100644 (file)
@@ -145,13 +145,12 @@ static int tta_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp
 }
 
 AVInputFormat ff_tta_demuxer = {
-    "tta",
-    NULL_IF_CONFIG_SMALL("True Audio"),
-    sizeof(TTAContext),
-    tta_probe,
-    tta_read_header,
-    tta_read_packet,
-    NULL,
-    tta_read_seek,
+    .name           = "tta",
+    .long_name      = NULL_IF_CONFIG_SMALL("True Audio"),
+    .priv_data_size = sizeof(TTAContext),
+    .read_probe     = tta_probe,
+    .read_header    = tta_read_header,
+    .read_packet    = tta_read_packet,
+    .read_seek      = tta_read_seek,
     .extensions = "tta",
 };
index 07f3247..564b5eb 100644 (file)
@@ -110,11 +110,10 @@ static int vc1t_read_packet(AVFormatContext *s,
 }
 
 AVInputFormat ff_vc1t_demuxer = {
-    "vc1test",
-    NULL_IF_CONFIG_SMALL("VC-1 test bitstream format"),
-    0,
-    vc1t_probe,
-    vc1t_read_header,
-    vc1t_read_packet,
+    .name           = "vc1test",
+    .long_name      = NULL_IF_CONFIG_SMALL("VC-1 test bitstream format"),
+    .read_probe     = vc1t_probe,
+    .read_header    = vc1t_read_header,
+    .read_packet    = vc1t_read_packet,
     .flags = AVFMT_GENERIC_INDEX,
 };
index 2b0728d..0ee9b90 100644 (file)
@@ -82,14 +82,14 @@ static int vc1test_write_trailer(AVFormatContext *s)
 }
 
 AVOutputFormat ff_vc1t_muxer = {
-    "rcv",
-    NULL_IF_CONFIG_SMALL("VC-1 test bitstream"),
-    "",
-    "rcv",
-    sizeof(RCVContext),
-    CODEC_ID_NONE,
-    CODEC_ID_WMV3,
-    vc1test_write_header,
-    vc1test_write_packet,
-    vc1test_write_trailer,
+    .name              = "rcv",
+    .long_name         = NULL_IF_CONFIG_SMALL("VC-1 test bitstream"),
+    .mime_type         = "",
+    .extensions        = "rcv",
+    .priv_data_size    = sizeof(RCVContext),
+    .audio_codec       = CODEC_ID_NONE,
+    .video_codec       = CODEC_ID_WMV3,
+    .write_header      = vc1test_write_header,
+    .write_packet      = vc1test_write_packet,
+    .write_trailer     = vc1test_write_trailer,
 };
index eaa2f25..23f1b0d 100644 (file)
@@ -157,11 +157,11 @@ static int voc_read_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_voc_demuxer = {
-    "voc",
-    NULL_IF_CONFIG_SMALL("Creative Voice file format"),
-    sizeof(VocDecContext),
-    voc_probe,
-    voc_read_header,
-    voc_read_packet,
+    .name           = "voc",
+    .long_name      = NULL_IF_CONFIG_SMALL("Creative Voice file format"),
+    .priv_data_size = sizeof(VocDecContext),
+    .read_probe     = voc_probe,
+    .read_header    = voc_read_header,
+    .read_packet    = voc_read_packet,
     .codec_tag=(const AVCodecTag* const []){ff_voc_codec_tags, 0},
 };
index bbb69c8..d0986bb 100644 (file)
@@ -90,15 +90,15 @@ static int voc_write_trailer(AVFormatContext *s)
 }
 
 AVOutputFormat ff_voc_muxer = {
-    "voc",
-    NULL_IF_CONFIG_SMALL("Creative Voice file format"),
-    "audio/x-voc",
-    "voc",
-    sizeof(VocEncContext),
-    CODEC_ID_PCM_U8,
-    CODEC_ID_NONE,
-    voc_write_header,
-    voc_write_packet,
-    voc_write_trailer,
+    .name              = "voc",
+    .long_name         = NULL_IF_CONFIG_SMALL("Creative Voice file format"),
+    .mime_type         = "audio/x-voc",
+    .extensions        = "voc",
+    .priv_data_size    = sizeof(VocEncContext),
+    .audio_codec       = CODEC_ID_PCM_U8,
+    .video_codec       = CODEC_ID_NONE,
+    .write_header      = voc_write_header,
+    .write_packet      = voc_write_packet,
+    .write_trailer     = voc_write_trailer,
     .codec_tag=(const AVCodecTag* const []){ff_voc_codec_tags, 0},
 };
index dd02abd..590d465 100644 (file)
@@ -250,13 +250,12 @@ static int vqf_read_seek(AVFormatContext *s,
 }
 
 AVInputFormat ff_vqf_demuxer = {
-    "vqf",
-    NULL_IF_CONFIG_SMALL("Nippon Telegraph and Telephone Corporation (NTT) TwinVQ"),
-    sizeof(VqfContext),
-    vqf_probe,
-    vqf_read_header,
-    vqf_read_packet,
-    NULL,
-    vqf_read_seek,
+    .name           = "vqf",
+    .long_name      = NULL_IF_CONFIG_SMALL("Nippon Telegraph and Telephone Corporation (NTT) TwinVQ"),
+    .priv_data_size = sizeof(VqfContext),
+    .read_probe     = vqf_probe,
+    .read_header    = vqf_read_header,
+    .read_packet    = vqf_read_packet,
+    .read_seek      = vqf_read_seek,
     .extensions = "vqf",
 };
index 1f12ad1..ce8bec2 100644 (file)
@@ -206,16 +206,16 @@ static const AVClass wav_muxer_class = {
 };
 
 AVOutputFormat ff_wav_muxer = {
-    "wav",
-    NULL_IF_CONFIG_SMALL("WAV format"),
-    "audio/x-wav",
-    "wav",
-    sizeof(WAVContext),
-    CODEC_ID_PCM_S16LE,
-    CODEC_ID_NONE,
-    wav_write_header,
-    wav_write_packet,
-    wav_write_trailer,
+    .name              = "wav",
+    .long_name         = NULL_IF_CONFIG_SMALL("WAV format"),
+    .mime_type         = "audio/x-wav",
+    .extensions        = "wav",
+    .priv_data_size    = sizeof(WAVContext),
+    .audio_codec       = CODEC_ID_PCM_S16LE,
+    .video_codec       = CODEC_ID_NONE,
+    .write_header      = wav_write_header,
+    .write_packet      = wav_write_packet,
+    .write_trailer     = wav_write_trailer,
     .codec_tag= (const AVCodecTag* const []){ff_codec_wav_tags, 0},
     .priv_class = &wav_muxer_class,
 };
@@ -574,14 +574,13 @@ static int wav_read_seek(AVFormatContext *s,
 }
 
 AVInputFormat ff_wav_demuxer = {
-    "wav",
-    NULL_IF_CONFIG_SMALL("WAV format"),
-    sizeof(WAVContext),
-    wav_probe,
-    wav_read_header,
-    wav_read_packet,
-    NULL,
-    wav_read_seek,
+    .name           = "wav",
+    .long_name      = NULL_IF_CONFIG_SMALL("WAV format"),
+    .priv_data_size = sizeof(WAVContext),
+    .read_probe     = wav_probe,
+    .read_header    = wav_read_header,
+    .read_packet    = wav_read_packet,
+    .read_seek      = wav_read_seek,
     .flags= AVFMT_GENERIC_INDEX,
     .codec_tag= (const AVCodecTag* const []){ff_codec_wav_tags, 0},
 };
@@ -663,14 +662,13 @@ static int w64_read_header(AVFormatContext *s, AVFormatParameters *ap)
 }
 
 AVInputFormat ff_w64_demuxer = {
-    "w64",
-    NULL_IF_CONFIG_SMALL("Sony Wave64 format"),
-    sizeof(WAVContext),
-    w64_probe,
-    w64_read_header,
-    wav_read_packet,
-    NULL,
-    wav_read_seek,
+    .name           = "w64",
+    .long_name      = NULL_IF_CONFIG_SMALL("Sony Wave64 format"),
+    .priv_data_size = sizeof(WAVContext),
+    .read_probe     = w64_probe,
+    .read_header    = w64_read_header,
+    .read_packet    = wav_read_packet,
+    .read_seek      = wav_read_seek,
     .flags = AVFMT_GENERIC_INDEX,
     .codec_tag = (const AVCodecTag* const []){ff_codec_wav_tags, 0},
 };
index 03483de..0df9881 100644 (file)
@@ -292,11 +292,11 @@ static int wc3_read_close(AVFormatContext *s)
 }
 
 AVInputFormat ff_wc3_demuxer = {
-    "wc3movie",
-    NULL_IF_CONFIG_SMALL("Wing Commander III movie format"),
-    sizeof(Wc3DemuxContext),
-    wc3_probe,
-    wc3_read_header,
-    wc3_read_packet,
-    wc3_read_close,
+    .name           = "wc3movie",
+    .long_name      = NULL_IF_CONFIG_SMALL("Wing Commander III movie format"),
+    .priv_data_size = sizeof(Wc3DemuxContext),
+    .read_probe     = wc3_probe,
+    .read_header    = wc3_read_header,
+    .read_packet    = wc3_read_packet,
+    .read_close     = wc3_read_close,
 };
index 7c2b17d..cd05b5d 100644 (file)
@@ -368,21 +368,21 @@ static int wsvqa_read_packet(AVFormatContext *s,
 
 #if CONFIG_WSAUD_DEMUXER
 AVInputFormat ff_wsaud_demuxer = {
-    "wsaud",
-    NULL_IF_CONFIG_SMALL("Westwood Studios audio format"),
-    sizeof(WsAudDemuxContext),
-    wsaud_probe,
-    wsaud_read_header,
-    wsaud_read_packet,
+    .name           = "wsaud",
+    .long_name      = NULL_IF_CONFIG_SMALL("Westwood Studios audio format"),
+    .priv_data_size = sizeof(WsAudDemuxContext),
+    .read_probe     = wsaud_probe,
+    .read_header    = wsaud_read_header,
+    .read_packet    = wsaud_read_packet,
 };
 #endif
 #if CONFIG_WSVQA_DEMUXER
 AVInputFormat ff_wsvqa_demuxer = {
-    "wsvqa",
-    NULL_IF_CONFIG_SMALL("Westwood Studios VQA format"),
-    sizeof(WsVqaDemuxContext),
-    wsvqa_probe,
-    wsvqa_read_header,
-    wsvqa_read_packet,
+    .name           = "wsvqa",
+    .long_name      = NULL_IF_CONFIG_SMALL("Westwood Studios VQA format"),
+    .priv_data_size = sizeof(WsVqaDemuxContext),
+    .read_probe     = wsvqa_probe,
+    .read_header    = wsvqa_read_header,
+    .read_packet    = wsvqa_read_packet,
 };
 #endif
index d6d7099..7cace17 100644 (file)
@@ -351,12 +351,11 @@ static int wv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp,
 }
 
 AVInputFormat ff_wv_demuxer = {
-    "wv",
-    NULL_IF_CONFIG_SMALL("WavPack"),
-    sizeof(WVContext),
-    wv_probe,
-    wv_read_header,
-    wv_read_packet,
-    NULL,
-    wv_read_seek,
+    .name           = "wv",
+    .long_name      = NULL_IF_CONFIG_SMALL("WavPack"),
+    .priv_data_size = sizeof(WVContext),
+    .read_probe     = wv_probe,
+    .read_header    = wv_read_header,
+    .read_packet    = wv_read_packet,
+    .read_seek      = wv_read_seek,
 };
index c3421a3..7dd1958 100644 (file)
@@ -119,10 +119,10 @@ static int xa_read_packet(AVFormatContext *s,
 }
 
 AVInputFormat ff_xa_demuxer = {
-    "xa",
-    NULL_IF_CONFIG_SMALL("Maxis XA File Format"),
-    sizeof(MaxisXADemuxContext),
-    xa_probe,
-    xa_read_header,
-    xa_read_packet,
+    .name           = "xa",
+    .long_name      = NULL_IF_CONFIG_SMALL("Maxis XA File Format"),
+    .priv_data_size = sizeof(MaxisXADemuxContext),
+    .read_probe     = xa_probe,
+    .read_header    = xa_read_header,
+    .read_packet    = xa_read_packet,
 };
index d18ab48..f383fd2 100644 (file)
@@ -252,10 +252,10 @@ static int xwma_read_packet(AVFormatContext *s, AVPacket *pkt)
 }
 
 AVInputFormat ff_xwma_demuxer = {
-    "xwma",
-    NULL_IF_CONFIG_SMALL("Microsoft xWMA"),
-    sizeof(XWMAContext),
-    xwma_probe,
-    xwma_read_header,
-    xwma_read_packet,
+    .name           = "xwma",
+    .long_name      = NULL_IF_CONFIG_SMALL("Microsoft xWMA"),
+    .priv_data_size = sizeof(XWMAContext),
+    .read_probe     = xwma_probe,
+    .read_header    = xwma_read_header,
+    .read_packet    = xwma_read_packet,
 };
index bc29b08..76116fb 100644 (file)
@@ -202,14 +202,14 @@ static int yop_read_seek(AVFormatContext *s, int stream_index,
 }
 
 AVInputFormat ff_yop_demuxer = {
-    "yop",
-    NULL_IF_CONFIG_SMALL("Psygnosis YOP Format"),
-    sizeof(YopDecContext),
-    yop_probe,
-    yop_read_header,
-    yop_read_packet,
-    yop_read_close,
-    yop_read_seek,
+    .name           = "yop",
+    .long_name      = NULL_IF_CONFIG_SMALL("Psygnosis YOP Format"),
+    .priv_data_size = sizeof(YopDecContext),
+    .read_probe     = yop_probe,
+    .read_header    = yop_read_header,
+    .read_packet    = yop_read_packet,
+    .read_close     = yop_read_close,
+    .read_seek      = yop_read_seek,
     .extensions = "yop",
     .flags = AVFMT_GENERIC_INDEX,
 };
index 9a6a0c8..37d8d8a 100644 (file)
@@ -170,15 +170,15 @@ static int yuv4_write_header(AVFormatContext *s)
 }
 
 AVOutputFormat ff_yuv4mpegpipe_muxer = {
-    "yuv4mpegpipe",
-    NULL_IF_CONFIG_SMALL("YUV4MPEG pipe format"),
-    "",
-    "y4m",
-    sizeof(int),
-    CODEC_ID_NONE,
-    CODEC_ID_RAWVIDEO,
-    yuv4_write_header,
-    yuv4_write_packet,
+    .name              = "yuv4mpegpipe",
+    .long_name         = NULL_IF_CONFIG_SMALL("YUV4MPEG pipe format"),
+    .mime_type         = "",
+    .extensions        = "y4m",
+    .priv_data_size    = sizeof(int),
+    .audio_codec       = CODEC_ID_NONE,
+    .video_codec       = CODEC_ID_RAWVIDEO,
+    .write_header      = yuv4_write_header,
+    .write_packet      = yuv4_write_packet,
     .flags = AVFMT_RAWPICTURE,
 };
 #endif
@@ -391,12 +391,12 @@ static int yuv4_probe(AVProbeData *pd)
 
 #if CONFIG_YUV4MPEGPIPE_DEMUXER
 AVInputFormat ff_yuv4mpegpipe_demuxer = {
-    "yuv4mpegpipe",
-    NULL_IF_CONFIG_SMALL("YUV4MPEG pipe format"),
-    sizeof(struct frame_attributes),
-    yuv4_probe,
-    yuv4_read_header,
-    yuv4_read_packet,
+    .name           = "yuv4mpegpipe",
+    .long_name      = NULL_IF_CONFIG_SMALL("YUV4MPEG pipe format"),
+    .priv_data_size = sizeof(struct frame_attributes),
+    .read_probe     = yuv4_probe,
+    .read_header    = yuv4_read_header,
+    .read_packet    = yuv4_read_packet,
     .extensions = "y4m"
 };
 #endif