RepoMirrors
/
ffmpeg
mirror of https://git.ffmpeg.org/ffmpeg.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

lavf: use designated initialisers for all (de)muxers. 

It's more readable and less prone to breakage.
This commit is contained in:
Anton Khirnov 2011-07-16 22:18:12 +02:00
parent 6270995667
commit dfc2c4d900
132 changed files with 1311 additions and 1466 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
libavformat/4xm.c
View 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,
};

6
libavformat/a64.c
View 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
};

11
libavformat/aacdec.c
View 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,

22
libavformat/ac3dec.c
View 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,

18
libavformat/adtsenc.c
View 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,
};

14
libavformat/aea.c
View 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",
};

15
libavformat/aiffdec.c
View 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},
};

20
libavformat/aiffenc.c
View 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},
};

30
libavformat/amr.c
View 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

12
libavformat/anm.c
View 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,
};

11
libavformat/apc.c
View 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,
};

16
libavformat/ape.c
View 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"
};

16
libavformat/applehttp.c
View 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,
};

18
libavformat/asfdec.c
View 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,
};

44
libavformat/asfenc.c
View 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},
};

33
libavformat/au.c
View 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

16
libavformat/avidec.c
View 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,
};

20
libavformat/avienc.c
View 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,
};

19
libavformat/avisynth.c
View 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",
};

14
libavformat/avs.c
View 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,
};

12
libavformat/bethsoftvid.c
View 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,
};

12
libavformat/bfi.c
View 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,
};

15
libavformat/bink.c
View 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,
};

12
libavformat/c93.c
View 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,
};

15
libavformat/cafdec.c
View 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},
};

10
libavformat/cdg.c
View 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"
};

19
libavformat/crcenc.c
View 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,
};

12
libavformat/daud.c
View 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

11
libavformat/dfa.c
View 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,
};

12
libavformat/dsicin.c
View 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,
};

11
libavformat/dtsdec.c
View 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,

16
libavformat/dv.c
View 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

19
libavformat/dvenc.c
View 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,
};

12
libavformat/dxa.c
View 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,
};

12
libavformat/eacdata.c
View 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",
};

12
libavformat/electronicarts.c
View 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,
};

16
libavformat/ffmdec.c
View 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,
};

21
libavformat/ffmenc.c
View 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,
};

14
libavformat/filmstripdec.c
View 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",
};

19
libavformat/filmstripenc.c
View 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,
};

11
libavformat/flacdec.c
View 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,

19
libavformat/flacenc.c
View 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,
};

12
libavformat/flic.c
View 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,
};

12
libavformat/flvdec.c
View 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,

22
libavformat/flvenc.c
View 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,
};

16
libavformat/framecrcenc.c
View 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,
};

20
libavformat/gif.c
View 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,
};

17
libavformat/gxf.c
View 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,
};

23
libavformat/gxfenc.c
View 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,
};

12
libavformat/idcin.c
View 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,
};

12
libavformat/idroqdec.c
View 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,
};

12
libavformat/iff.c
View 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,
};

11
libavformat/ingenientdec.c
View 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,

12
libavformat/ipmovie.c
View 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,
};

12
libavformat/iss.c
View 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,
};

11
libavformat/iv8.c
View 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,
};

11
libavformat/ivfdec.c
View 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},
};

36
libavformat/libnut.c
View 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",
};

11
libavformat/lmlm4.c
View 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,
};

16
libavformat/matroskadec.c
View 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,
};

60
libavformat/matroskaenc.c
View 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},
};

36
libavformat/md5enc.c
View 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

12
libavformat/mm.c
View 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,
};

35
libavformat/mmf.c
View 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

16
libavformat/mov.c
View 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,
};

116
libavformat/movenc.c
View 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,

11
libavformat/mp3dec.c
View 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 */
};

40
libavformat/mp3enc.c
View 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

16
libavformat/mpc.c
View 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",
};

15
libavformat/mpc8.c
View 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,
};

17
libavformat/mpeg.c
View 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,
};

99
libavformat/mpegenc.c
View 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

35
libavformat/mpegts.c
View 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,

20
libavformat/mpegtsenc.c
View 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,
};

19
libavformat/mpjpeg.c
View 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,
};

11
libavformat/msnwc_tcp.c
View 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,
};

12
libavformat/mtv.c
View 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,
};

11
libavformat/mvi.c
View 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"
};

16
libavformat/mxfdec.c
View 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,
};

49
libavformat/mxfenc.c
View 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,
};

11
libavformat/ncdec.c
View 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",
};

16
libavformat/nsvdec.c
View 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,
};

14
libavformat/nullenc.c
View 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,
};

16
libavformat/nutdec.c
View 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 },
};

24
libavformat/nutenc.c
View 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 },
};

14
libavformat/nuv.c
View 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,
};

20
libavformat/oggenc.c
View 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,
};

14
libavformat/oma.c
View 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},

14
libavformat/psxstr.c
View 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,
};

12
libavformat/pva.c
View 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
};

16
libavformat/r3d.c
View 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,
};

51
libavformat/rawdec.c
View 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,

263
libavformat/rawenc.c
View 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

11
libavformat/rawvideodec.c
View 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,

15
libavformat/rl2.c
View 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,
};

28
libavformat/rmdec.c
View 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,
};

20
libavformat/rmenc.c
View 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},
};

12
libavformat/rpl.c
View 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,
};

18
libavformat/rtpenc.c
View 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,
};

28
libavformat/rtsp.c
View 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 */

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