It's more readable and less prone to breakage.
}
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,
};
.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
};
}
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,
}
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,
}
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,
}
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,
};
}
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",
};
}
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},
};
}
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},
};
#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
}
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,
};
}
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,
};
}
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"
};
}
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,
};
}
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,
};
#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},
};
#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},
};
#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
}
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,
};
}
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,
};
}
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",
};
}
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,
};
}
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,
};
}
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,
};
}
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,
};
}
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,
};
}
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},
};
}
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"
};
}
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,
};
#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
}
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,
};
}
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,
};
}
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,
#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
}
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,
};
}
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,
};
}
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",
};
}
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,
};
}
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,
};
}
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,
};
}
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",
};
}
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,
};
}
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,
}
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,
};
}
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,
};
#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,
}
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,
};
}
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,
};
};
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,
};
}
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,
};
}
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,
};
}
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,
};
}
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,
};
}
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,
};
}
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,
}
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,
};
}
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,
};
}
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,
};
}
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},
};
}
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 */
}
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",
};
}
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,
};
}
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,
};
#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,
#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},
};
}
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
}
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
}
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,
};
#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
}
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,
};
#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,
#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,
#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,
#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,
#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,
#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,
}
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 */
};
#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
}
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
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",
};
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,
};
}
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,
};
#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
}
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,
};
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,
}
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,
};
}
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,
};
}
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,
};
}
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,
};
}
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"
};
}
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,
};
}
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,
};
}
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",
};
}
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,
};
}
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,
};
#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 },
};
}
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 },
};
}
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,
};
}
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,
};
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},
}
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,
};
}
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
};
}
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,
};
#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,
#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,
#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,
#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,
#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,
#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
#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
}
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,
}
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,
};
}
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,
};
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},
};
}
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,
};
}
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,
};
}
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 */
}
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 */
};
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,
}
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,
};
}
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,
};
}
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,
};
}
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,
};
}
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,
};
}
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"
};
}
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,
};
}
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,
};
}
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,
};
}
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,
};
}
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,
};
}
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,
};
}
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,
};
#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
}
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
};
}
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,
};
}
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,
};
}
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",
};
}
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,
};
}
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,
};
}
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},
};
}
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},
};
}
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",
};
};
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,
};
}
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},
};
}
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},
};
}
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,
};
#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
}
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,
};
}
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,
};
}
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,
};
}
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,
};
}
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
#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
projects / ffmpeg / commitdiff