Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

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

Browse Source 
It's more readable and less prone to breakage.
pull/2/head
Anton Khirnov 14 years ago
parent 6270995667
commit dfc2c4d900
132 changed files with 1311 additions and 1466 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 14
      libavformat/4xm.c
  2. 6
      libavformat/a64.c
  3. 11
      libavformat/aacdec.c
  4. 22
      libavformat/ac3dec.c
  5. 18
      libavformat/adtsenc.c
  6. 14
      libavformat/aea.c
  7. 15
      libavformat/aiffdec.c
  8. 20
      libavformat/aiffenc.c
  9. 30
      libavformat/amr.c
  10. 12
      libavformat/anm.c
  11. 11
      libavformat/apc.c
  12. 16
      libavformat/ape.c
  13. 16
      libavformat/applehttp.c
  14. 18
      libavformat/asfdec.c
  15. 44
      libavformat/asfenc.c
  16. 33
      libavformat/au.c
  17. 16
      libavformat/avidec.c
  18. 20
      libavformat/avienc.c
  19. 19
      libavformat/avisynth.c
  20. 14
      libavformat/avs.c
  21. 12
      libavformat/bethsoftvid.c
  22. 12
      libavformat/bfi.c
  23. 15
      libavformat/bink.c
  24. 12
      libavformat/c93.c
  25. 15
      libavformat/cafdec.c
  26. 10
      libavformat/cdg.c
  27. 19
      libavformat/crcenc.c
  28. 12
      libavformat/daud.c
  29. 11
      libavformat/dfa.c
  30. 12
      libavformat/dsicin.c
  31. 11
      libavformat/dtsdec.c
  32. 16
      libavformat/dv.c
  33. 19
      libavformat/dvenc.c
  34. 12
      libavformat/dxa.c
  35. 12
      libavformat/eacdata.c
  36. 12
      libavformat/electronicarts.c
  37. 16
      libavformat/ffmdec.c
  38. 21
      libavformat/ffmenc.c
  39. 14
      libavformat/filmstripdec.c
  40. 19
      libavformat/filmstripenc.c
  41. 11
      libavformat/flacdec.c
  42. 19
      libavformat/flacenc.c
  43. 12
      libavformat/flic.c
  44. 12
      libavformat/flvdec.c
  45. 22
      libavformat/flvenc.c
  46. 16
      libavformat/framecrcenc.c
  47. 20
      libavformat/gif.c
  48. 17
      libavformat/gxf.c
  49. 23
      libavformat/gxfenc.c
  50. 12
      libavformat/idcin.c
  51. 12
      libavformat/idroqdec.c
  52. 12
      libavformat/iff.c
  53. 11
      libavformat/ingenientdec.c
  54. 12
      libavformat/ipmovie.c
  55. 12
      libavformat/iss.c
  56. 11
      libavformat/iv8.c
  57. 11
      libavformat/ivfdec.c
  58. 36
      libavformat/libnut.c
  59. 11
      libavformat/lmlm4.c
  60. 16
      libavformat/matroskadec.c
  61. 60
      libavformat/matroskaenc.c
  62. 36
      libavformat/md5enc.c
  63. 12
      libavformat/mm.c
  64. 35
      libavformat/mmf.c
  65. 16
      libavformat/mov.c
  66. 116
      libavformat/movenc.c
  67. 11
      libavformat/mp3dec.c
  68. 40
      libavformat/mp3enc.c
  69. 16
      libavformat/mpc.c
  70. 15
      libavformat/mpc8.c
  71. 17
      libavformat/mpeg.c
  72. 99
      libavformat/mpegenc.c
  73. 35
      libavformat/mpegts.c
  74. 20
      libavformat/mpegtsenc.c
  75. 19
      libavformat/mpjpeg.c
  76. 11
      libavformat/msnwc_tcp.c
  77. 12
      libavformat/mtv.c
  78. 11
      libavformat/mvi.c
  79. 16
      libavformat/mxfdec.c
  80. 49
      libavformat/mxfenc.c
  81. 11
      libavformat/ncdec.c
  82. 16
      libavformat/nsvdec.c
  83. 14
      libavformat/nullenc.c
  84. 16
      libavformat/nutdec.c
  85. 24
      libavformat/nutenc.c
  86. 14
      libavformat/nuv.c
  87. 20
      libavformat/oggenc.c
  88. 14
      libavformat/oma.c
  89. 14
      libavformat/psxstr.c
  90. 12
      libavformat/pva.c
  91. 16
      libavformat/r3d.c
  92. 51
      libavformat/rawdec.c
  93. 263
      libavformat/rawenc.c
  94. 11
      libavformat/rawvideodec.c
  95. 15
      libavformat/rl2.c
  96. 28
      libavformat/rmdec.c
  97. 20
      libavformat/rmenc.c
  98. 12
      libavformat/rpl.c
  99. 18
      libavformat/rtpenc.c
  100. 28
      libavformat/rtsp.c
  101. Some files were not shown because too many files have changed in this diff Show More

14
libavformat/4xm.c
Unescape View File

@ -345,11 +345,11 @@ static int fourxm_read_close(AVFormatContext *s)
} }
AVInputFormat ff_fourxm_demuxer = { AVInputFormat ff_fourxm_demuxer = {
"4xm", .name = "4xm",
NULL_IF_CONFIG_SMALL("4X Technologies format"), .long_name = NULL_IF_CONFIG_SMALL("4X Technologies format"),
sizeof(FourxmDemuxContext), .priv_data_size = sizeof(FourxmDemuxContext),
fourxm_probe, .read_probe = fourxm_probe,
fourxm_read_header, .read_header = fourxm_read_header,
fourxm_read_packet, .read_packet = fourxm_read_packet,
fourxm_read_close, .read_close = fourxm_read_close,
}; };

6
libavformat/a64.c
Unescape View File

@ -170,7 +170,7 @@ AVOutputFormat ff_a64_muxer = {
.extensions = "a64, A64", .extensions = "a64, A64",
.priv_data_size = sizeof (A64Context), .priv_data_size = sizeof (A64Context),
.video_codec = CODEC_ID_A64_MULTI, .video_codec = CODEC_ID_A64_MULTI,
a64_write_header, .write_header = a64_write_header,
a64_write_packet, .write_packet = a64_write_packet,
a64_write_trailer .write_trailer = a64_write_trailer
}; };

11
libavformat/aacdec.c
Unescape View File

@ -82,12 +82,11 @@ static int adts_aac_read_header(AVFormatContext *s,
} }
AVInputFormat ff_aac_demuxer = { AVInputFormat ff_aac_demuxer = {
"aac", .name = "aac",
NULL_IF_CONFIG_SMALL("raw ADTS AAC"), .long_name = NULL_IF_CONFIG_SMALL("raw ADTS AAC"),
0, .read_probe = adts_aac_probe,
adts_aac_probe, .read_header = adts_aac_read_header,
adts_aac_read_header, .read_packet = ff_raw_read_partial_packet,
ff_raw_read_partial_packet,
.flags= AVFMT_GENERIC_INDEX, .flags= AVFMT_GENERIC_INDEX,
.extensions = "aac", .extensions = "aac",
.value = CODEC_ID_AAC, .value = CODEC_ID_AAC,

22
libavformat/ac3dec.c
Unescape View File

@ -71,12 +71,11 @@ static int ac3_probe(AVProbeData *p)
} }
AVInputFormat ff_ac3_demuxer = { AVInputFormat ff_ac3_demuxer = {
"ac3", .name = "ac3",
NULL_IF_CONFIG_SMALL("raw AC-3"), .long_name = NULL_IF_CONFIG_SMALL("raw AC-3"),
0, .read_probe = ac3_probe,
ac3_probe, .read_header = ff_raw_audio_read_header,
ff_raw_audio_read_header, .read_packet = ff_raw_read_partial_packet,
ff_raw_read_partial_packet,
.flags= AVFMT_GENERIC_INDEX, .flags= AVFMT_GENERIC_INDEX,
.extensions = "ac3", .extensions = "ac3",
.value = CODEC_ID_AC3, .value = CODEC_ID_AC3,
@ -90,12 +89,11 @@ static int eac3_probe(AVProbeData *p)
} }
AVInputFormat ff_eac3_demuxer = { AVInputFormat ff_eac3_demuxer = {
"eac3", .name = "eac3",
NULL_IF_CONFIG_SMALL("raw E-AC-3"), .long_name = NULL_IF_CONFIG_SMALL("raw E-AC-3"),
0, .read_probe = eac3_probe,
eac3_probe, .read_header = ff_raw_audio_read_header,
ff_raw_audio_read_header, .read_packet = ff_raw_read_partial_packet,
ff_raw_read_partial_packet,
.flags= AVFMT_GENERIC_INDEX, .flags= AVFMT_GENERIC_INDEX,
.extensions = "eac3", .extensions = "eac3",
.value = CODEC_ID_EAC3, .value = CODEC_ID_EAC3,

18
libavformat/adtsenc.c
Unescape View File

@ -142,13 +142,13 @@ static int adts_write_packet(AVFormatContext *s, AVPacket *pkt)
} }
AVOutputFormat ff_adts_muxer = { AVOutputFormat ff_adts_muxer = {
"adts", .name = "adts",
NULL_IF_CONFIG_SMALL("ADTS AAC"), .long_name = NULL_IF_CONFIG_SMALL("ADTS AAC"),
"audio/aac", .mime_type = "audio/aac",
"aac,adts", .extensions = "aac,adts",
sizeof(ADTSContext), .priv_data_size = sizeof(ADTSContext),
CODEC_ID_AAC, .audio_codec = CODEC_ID_AAC,
CODEC_ID_NONE, .video_codec = CODEC_ID_NONE,
adts_write_header, .write_header = adts_write_header,
adts_write_packet, .write_packet = adts_write_packet,
}; };

14
libavformat/aea.c
Unescape View File

@ -95,14 +95,12 @@ static int aea_read_packet(AVFormatContext *s, AVPacket *pkt)
} }
AVInputFormat ff_aea_demuxer = { AVInputFormat ff_aea_demuxer = {
"aea", .name = "aea",
NULL_IF_CONFIG_SMALL("MD STUDIO audio"), .long_name = NULL_IF_CONFIG_SMALL("MD STUDIO audio"),
0, .read_probe = aea_read_probe,
aea_read_probe, .read_header = aea_read_header,
aea_read_header, .read_packet = aea_read_packet,
aea_read_packet, .read_seek = pcm_read_seek,
0,
pcm_read_seek,
.flags= AVFMT_GENERIC_INDEX, .flags= AVFMT_GENERIC_INDEX,
.extensions = "aea", .extensions = "aea",
}; };

15
libavformat/aiffdec.c
Unescape View File

@ -313,13 +313,12 @@ static int aiff_read_packet(AVFormatContext *s,
} }
AVInputFormat ff_aiff_demuxer = { AVInputFormat ff_aiff_demuxer = {
"aiff", .name = "aiff",
NULL_IF_CONFIG_SMALL("Audio IFF"), .long_name = NULL_IF_CONFIG_SMALL("Audio IFF"),
sizeof(AIFFInputContext), .priv_data_size = sizeof(AIFFInputContext),
aiff_probe, .read_probe = aiff_probe,
aiff_read_header, .read_header = aiff_read_header,
aiff_read_packet, .read_packet = aiff_read_packet,
NULL, .read_seek = pcm_read_seek,
pcm_read_seek,
.codec_tag= (const AVCodecTag* const []){ff_codec_aiff_tags, 0}, .codec_tag= (const AVCodecTag* const []){ff_codec_aiff_tags, 0},
}; };

20
libavformat/aiffenc.c
Unescape View File

@ -148,15 +148,15 @@ static int aiff_write_trailer(AVFormatContext *s)
} }
AVOutputFormat ff_aiff_muxer = { AVOutputFormat ff_aiff_muxer = {
"aiff", .name = "aiff",
NULL_IF_CONFIG_SMALL("Audio IFF"), .long_name = NULL_IF_CONFIG_SMALL("Audio IFF"),
"audio/aiff", .mime_type = "audio/aiff",
"aif,aiff,afc,aifc", .extensions = "aif,aiff,afc,aifc",
sizeof(AIFFOutputContext), .priv_data_size = sizeof(AIFFOutputContext),
CODEC_ID_PCM_S16BE, .audio_codec = CODEC_ID_PCM_S16BE,
CODEC_ID_NONE, .video_codec = CODEC_ID_NONE,
aiff_write_header, .write_header = aiff_write_header,
aiff_write_packet, .write_packet = aiff_write_packet,
aiff_write_trailer, .write_trailer = aiff_write_trailer,
.codec_tag= (const AVCodecTag* const []){ff_codec_aiff_tags, 0}, .codec_tag= (const AVCodecTag* const []){ff_codec_aiff_tags, 0},
}; };

30
libavformat/amr.c
Unescape View File

@ -174,27 +174,25 @@ static int amr_read_packet(AVFormatContext *s,
#if CONFIG_AMR_DEMUXER #if CONFIG_AMR_DEMUXER
AVInputFormat ff_amr_demuxer = { AVInputFormat ff_amr_demuxer = {
"amr", .name = "amr",
NULL_IF_CONFIG_SMALL("3GPP AMR file format"), .long_name = NULL_IF_CONFIG_SMALL("3GPP AMR file format"),
0, /*priv_data_size*/ .priv_data_size = 0, /*priv_data_size*/
amr_probe, .read_probe = amr_probe,
amr_read_header, .read_header = amr_read_header,
amr_read_packet, .read_packet = amr_read_packet,
NULL,
.flags = AVFMT_GENERIC_INDEX, .flags = AVFMT_GENERIC_INDEX,
}; };
#endif #endif
#if CONFIG_AMR_MUXER #if CONFIG_AMR_MUXER
AVOutputFormat ff_amr_muxer = { AVOutputFormat ff_amr_muxer = {
"amr", .name = "amr",
NULL_IF_CONFIG_SMALL("3GPP AMR file format"), .long_name = NULL_IF_CONFIG_SMALL("3GPP AMR file format"),
"audio/amr", .mime_type = "audio/amr",
"amr", .extensions = "amr",
0, .audio_codec = CODEC_ID_AMR_NB,
CODEC_ID_AMR_NB, .video_codec = CODEC_ID_NONE,
CODEC_ID_NONE, .write_header = amr_write_header,
amr_write_header, .write_packet = amr_write_packet,
amr_write_packet,
}; };
#endif #endif

12
libavformat/anm.c
Unescape View File

@ -226,10 +226,10 @@ repeat:
} }
AVInputFormat ff_anm_demuxer = { AVInputFormat ff_anm_demuxer = {
"anm", .name = "anm",
NULL_IF_CONFIG_SMALL("Deluxe Paint Animation"), .long_name = NULL_IF_CONFIG_SMALL("Deluxe Paint Animation"),
sizeof(AnmDemuxContext), .priv_data_size = sizeof(AnmDemuxContext),
probe, .read_probe = probe,
read_header, .read_header = read_header,
read_packet, .read_packet = read_packet,
}; };

11
libavformat/apc.c
Unescape View File

@ -81,10 +81,9 @@ static int apc_read_packet(AVFormatContext *s, AVPacket *pkt)
} }
AVInputFormat ff_apc_demuxer = { AVInputFormat ff_apc_demuxer = {
"apc", .name = "apc",
NULL_IF_CONFIG_SMALL("CRYO APC format"), .long_name = NULL_IF_CONFIG_SMALL("CRYO APC format"),
0, .read_probe = apc_probe,
apc_probe, .read_header = apc_read_header,
apc_read_header, .read_packet = apc_read_packet,
apc_read_packet,
}; };

16
libavformat/ape.c
Unescape View File

@ -405,13 +405,13 @@ static int ape_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp
} }
AVInputFormat ff_ape_demuxer = { AVInputFormat ff_ape_demuxer = {
"ape", .name = "ape",
NULL_IF_CONFIG_SMALL("Monkey's Audio"), .long_name = NULL_IF_CONFIG_SMALL("Monkey's Audio"),
sizeof(APEContext), .priv_data_size = sizeof(APEContext),
ape_probe, .read_probe = ape_probe,
ape_read_header, .read_header = ape_read_header,
ape_read_packet, .read_packet = ape_read_packet,
ape_read_close, .read_close = ape_read_close,
ape_read_seek, .read_seek = ape_read_seek,
.extensions = "ape,apl,mac" .extensions = "ape,apl,mac"
}; };

16
libavformat/applehttp.c
Unescape View File

@ -668,12 +668,12 @@ static int applehttp_probe(AVProbeData *p)
} }
AVInputFormat ff_applehttp_demuxer = { AVInputFormat ff_applehttp_demuxer = {
"applehttp", .name = "applehttp",
NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming format"), .long_name = NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming format"),
sizeof(AppleHTTPContext), .priv_data_size = sizeof(AppleHTTPContext),
applehttp_probe, .read_probe = applehttp_probe,
applehttp_read_header, .read_header = applehttp_read_header,
applehttp_read_packet, .read_packet = applehttp_read_packet,
applehttp_close, .read_close = applehttp_close,
applehttp_read_seek, .read_seek = applehttp_read_seek,
}; };

18
libavformat/asfdec.c
Unescape View File

@ -1289,14 +1289,14 @@ static int asf_read_seek(AVFormatContext *s, int stream_index, int64_t pts, int
} }
AVInputFormat ff_asf_demuxer = { AVInputFormat ff_asf_demuxer = {
"asf", .name = "asf",
NULL_IF_CONFIG_SMALL("ASF format"), .long_name = NULL_IF_CONFIG_SMALL("ASF format"),
sizeof(ASFContext), .priv_data_size = sizeof(ASFContext),
asf_probe, .read_probe = asf_probe,
asf_read_header, .read_header = asf_read_header,
asf_read_packet, .read_packet = asf_read_packet,
asf_read_close, .read_close = asf_read_close,
asf_read_seek, .read_seek = asf_read_seek,
asf_read_pts, .read_timestamp = asf_read_pts,
.flags = AVFMT_NOBINSEARCH | AVFMT_NOGENSEARCH, .flags = AVFMT_NOBINSEARCH | AVFMT_NOGENSEARCH,
}; };

44
libavformat/asfenc.c
Unescape View File

@ -882,20 +882,20 @@ static int asf_write_trailer(AVFormatContext *s)
#if CONFIG_ASF_MUXER #if CONFIG_ASF_MUXER
AVOutputFormat ff_asf_muxer = { AVOutputFormat ff_asf_muxer = {
"asf", .name = "asf",
NULL_IF_CONFIG_SMALL("ASF format"), .long_name = NULL_IF_CONFIG_SMALL("ASF format"),
"video/x-ms-asf", .mime_type = "video/x-ms-asf",
"asf,wmv,wma", .extensions = "asf,wmv,wma",
sizeof(ASFContext), .priv_data_size = sizeof(ASFContext),
#if CONFIG_LIBMP3LAME #if CONFIG_LIBMP3LAME
CODEC_ID_MP3, .audio_codec = CODEC_ID_MP3,
#else #else
CODEC_ID_MP2, .audio_codec = CODEC_ID_MP2,
#endif #endif
CODEC_ID_MSMPEG4V3, .video_codec = CODEC_ID_MSMPEG4V3,
asf_write_header, .write_header = asf_write_header,
asf_write_packet, .write_packet = asf_write_packet,
asf_write_trailer, .write_trailer = asf_write_trailer,
.flags = AVFMT_GLOBALHEADER, .flags = AVFMT_GLOBALHEADER,
.codec_tag= (const AVCodecTag* const []){codec_asf_bmp_tags, ff_codec_bmp_tags, ff_codec_wav_tags, 0}, .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 #if CONFIG_ASF_STREAM_MUXER
AVOutputFormat ff_asf_stream_muxer = { AVOutputFormat ff_asf_stream_muxer = {
"asf_stream", .name = "asf_stream",
NULL_IF_CONFIG_SMALL("ASF format"), .long_name = NULL_IF_CONFIG_SMALL("ASF format"),
"video/x-ms-asf", .mime_type = "video/x-ms-asf",
"asf,wmv,wma", .extensions = "asf,wmv,wma",
sizeof(ASFContext), .priv_data_size = sizeof(ASFContext),
#if CONFIG_LIBMP3LAME #if CONFIG_LIBMP3LAME
CODEC_ID_MP3, .audio_codec = CODEC_ID_MP3,
#else #else
CODEC_ID_MP2, .audio_codec = CODEC_ID_MP2,
#endif #endif
CODEC_ID_MSMPEG4V3, .video_codec = CODEC_ID_MSMPEG4V3,
asf_write_stream_header, .write_header = asf_write_stream_header,
asf_write_packet, .write_packet = asf_write_packet,
asf_write_trailer, .write_trailer = asf_write_trailer,
.flags = AVFMT_GLOBALHEADER, .flags = AVFMT_GLOBALHEADER,
.codec_tag= (const AVCodecTag* const []){codec_asf_bmp_tags, ff_codec_bmp_tags, ff_codec_wav_tags, 0}, .codec_tag= (const AVCodecTag* const []){codec_asf_bmp_tags, ff_codec_bmp_tags, ff_codec_wav_tags, 0},
}; };

33
libavformat/au.c
Unescape View File

@ -185,30 +185,27 @@ static int au_read_packet(AVFormatContext *s,
#if CONFIG_AU_DEMUXER #if CONFIG_AU_DEMUXER
AVInputFormat ff_au_demuxer = { AVInputFormat ff_au_demuxer = {
"au", .name = "au",
NULL_IF_CONFIG_SMALL("SUN AU format"), .long_name = NULL_IF_CONFIG_SMALL("SUN AU format"),
0, .read_probe = au_probe,
au_probe, .read_header = au_read_header,
au_read_header, .read_packet = au_read_packet,
au_read_packet, .read_seek = pcm_read_seek,
NULL,
pcm_read_seek,
.codec_tag= (const AVCodecTag* const []){codec_au_tags, 0}, .codec_tag= (const AVCodecTag* const []){codec_au_tags, 0},
}; };
#endif #endif
#if CONFIG_AU_MUXER #if CONFIG_AU_MUXER
AVOutputFormat ff_au_muxer = { AVOutputFormat ff_au_muxer = {
"au", .name = "au",
NULL_IF_CONFIG_SMALL("SUN AU format"), .long_name = NULL_IF_CONFIG_SMALL("SUN AU format"),
"audio/basic", .mime_type = "audio/basic",
"au", .extensions = "au",
0, .audio_codec = CODEC_ID_PCM_S16BE,
CODEC_ID_PCM_S16BE, .video_codec = CODEC_ID_NONE,
CODEC_ID_NONE, .write_header = au_write_header,
au_write_header, .write_packet = au_write_packet,
au_write_packet, .write_trailer = au_write_trailer,
au_write_trailer,
.codec_tag= (const AVCodecTag* const []){codec_au_tags, 0}, .codec_tag= (const AVCodecTag* const []){codec_au_tags, 0},
}; };
#endif //CONFIG_AU_MUXER #endif //CONFIG_AU_MUXER

16
libavformat/avidec.c
Unescape View File

@ -1389,12 +1389,12 @@ static int avi_probe(AVProbeData *p)
} }
AVInputFormat ff_avi_demuxer = { AVInputFormat ff_avi_demuxer = {
"avi", .name = "avi",
NULL_IF_CONFIG_SMALL("AVI format"), .long_name = NULL_IF_CONFIG_SMALL("AVI format"),
sizeof(AVIContext), .priv_data_size = sizeof(AVIContext),
avi_probe, .read_probe = avi_probe,
avi_read_header, .read_header = avi_read_header,
avi_read_packet, .read_packet = avi_read_packet,
avi_read_close, .read_close = avi_read_close,
avi_read_seek, .read_seek = avi_read_seek,
}; };

20
libavformat/avienc.c
Unescape View File

@ -639,16 +639,16 @@ static int avi_write_trailer(AVFormatContext *s)
} }
AVOutputFormat ff_avi_muxer = { AVOutputFormat ff_avi_muxer = {
"avi", .name = "avi",
NULL_IF_CONFIG_SMALL("AVI format"), .long_name = NULL_IF_CONFIG_SMALL("AVI format"),
"video/x-msvideo", .mime_type = "video/x-msvideo",
"avi", .extensions = "avi",
sizeof(AVIContext), .priv_data_size = sizeof(AVIContext),
CODEC_ID_MP2, .audio_codec = CODEC_ID_MP2,
CODEC_ID_MPEG4, .video_codec = CODEC_ID_MPEG4,
avi_write_header, .write_header = avi_write_header,
avi_write_packet, .write_packet = avi_write_packet,
avi_write_trailer, .write_trailer = avi_write_trailer,
.codec_tag= (const AVCodecTag* const []){ff_codec_bmp_tags, ff_codec_wav_tags, 0}, .codec_tag= (const AVCodecTag* const []){ff_codec_bmp_tags, ff_codec_wav_tags, 0},
.flags= AVFMT_VARIABLE_FPS, .flags= AVFMT_VARIABLE_FPS,
}; };

19
libavformat/avisynth.c
Unescape View File

@ -208,15 +208,12 @@ static int avisynth_read_seek(AVFormatContext *s, int stream_index, int64_t pts,
} }
AVInputFormat ff_avisynth_demuxer = { AVInputFormat ff_avisynth_demuxer = {
"avs", .name = "avs",
NULL_IF_CONFIG_SMALL("AVISynth"), .long_name = NULL_IF_CONFIG_SMALL("AVISynth"),
sizeof(AVISynthContext), .priv_data_size = sizeof(AVISynthContext),
NULL, .read_header = avisynth_read_header,
avisynth_read_header, .read_packet = avisynth_read_packet,
avisynth_read_packet, .read_close = avisynth_read_close,
avisynth_read_close, .read_seek = avisynth_read_seek,
avisynth_read_seek, .extensions = "avs",
NULL,
0,
"avs",
}; };

14
libavformat/avs.c
Unescape View File

@ -216,11 +216,11 @@ static int avs_read_close(AVFormatContext * s)
} }
AVInputFormat ff_avs_demuxer = { AVInputFormat ff_avs_demuxer = {
"avs", .name = "avs",
NULL_IF_CONFIG_SMALL("AVS format"), .long_name = NULL_IF_CONFIG_SMALL("AVS format"),
sizeof(AvsFormat), .priv_data_size = sizeof(AvsFormat),
avs_probe, .read_probe = avs_probe,
avs_read_header, .read_header = avs_read_header,
avs_read_packet, .read_packet = avs_read_packet,
avs_read_close, .read_close = avs_read_close,
}; };

12
libavformat/bethsoftvid.c
Unescape View File

@ -223,10 +223,10 @@ static int vid_read_packet(AVFormatContext *s,
} }
AVInputFormat ff_bethsoftvid_demuxer = { AVInputFormat ff_bethsoftvid_demuxer = {
"bethsoftvid", .name = "bethsoftvid",
NULL_IF_CONFIG_SMALL("Bethesda Softworks VID format"), .long_name = NULL_IF_CONFIG_SMALL("Bethesda Softworks VID format"),
sizeof(BVID_DemuxContext), .priv_data_size = sizeof(BVID_DemuxContext),
vid_probe, .read_probe = vid_probe,
vid_read_header, .read_header = vid_read_header,
vid_read_packet, .read_packet = vid_read_packet,
}; };

12
libavformat/bfi.c
Unescape View File

@ -159,10 +159,10 @@ static int bfi_read_packet(AVFormatContext * s, AVPacket * pkt)
} }
AVInputFormat ff_bfi_demuxer = { AVInputFormat ff_bfi_demuxer = {
"bfi", .name = "bfi",
NULL_IF_CONFIG_SMALL("Brute Force & Ignorance"), .long_name = NULL_IF_CONFIG_SMALL("Brute Force & Ignorance"),
sizeof(BFIContext), .priv_data_size = sizeof(BFIContext),
bfi_probe, .read_probe = bfi_probe,
bfi_read_header, .read_header = bfi_read_header,
bfi_read_packet, .read_packet = bfi_read_packet,
}; };

15
libavformat/bink.c
Unescape View File

@ -264,12 +264,11 @@ static int read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, in
} }
AVInputFormat ff_bink_demuxer = { AVInputFormat ff_bink_demuxer = {
"bink", .name = "bink",
NULL_IF_CONFIG_SMALL("Bink"), .long_name = NULL_IF_CONFIG_SMALL("Bink"),
sizeof(BinkDemuxContext), .priv_data_size = sizeof(BinkDemuxContext),
probe, .read_probe = probe,
read_header, .read_header = read_header,
read_packet, .read_packet = read_packet,
NULL, .read_seek = read_seek,
read_seek,
}; };

12
libavformat/c93.c
Unescape View File

@ -193,10 +193,10 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
} }
AVInputFormat ff_c93_demuxer = { AVInputFormat ff_c93_demuxer = {
"c93", .name = "c93",
NULL_IF_CONFIG_SMALL("Interplay C93"), .long_name = NULL_IF_CONFIG_SMALL("Interplay C93"),
sizeof(C93DemuxContext), .priv_data_size = sizeof(C93DemuxContext),
probe, .read_probe = probe,
read_header, .read_header = read_header,
read_packet, .read_packet = read_packet,
}; };

15
libavformat/cafdec.c
Unescape View File

@ -384,13 +384,12 @@ static int read_seek(AVFormatContext *s, int stream_index,
} }
AVInputFormat ff_caf_demuxer = { AVInputFormat ff_caf_demuxer = {
"caf", .name = "caf",
NULL_IF_CONFIG_SMALL("Apple Core Audio Format"), .long_name = NULL_IF_CONFIG_SMALL("Apple Core Audio Format"),
sizeof(CaffContext), .priv_data_size = sizeof(CaffContext),
probe, .read_probe = probe,
read_header, .read_header = read_header,
read_packet, .read_packet = read_packet,
NULL, .read_seek = read_seek,
read_seek,
.codec_tag = (const AVCodecTag*[]){ff_codec_caf_tags, 0}, .codec_tag = (const AVCodecTag*[]){ff_codec_caf_tags, 0},
}; };

10
libavformat/cdg.c
Unescape View File

@ -56,11 +56,9 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
} }
AVInputFormat ff_cdg_demuxer = { AVInputFormat ff_cdg_demuxer = {
"cdg", .name = "cdg",
NULL_IF_CONFIG_SMALL("CD Graphics Format"), .long_name = NULL_IF_CONFIG_SMALL("CD Graphics Format"),
0, .read_header = read_header,
NULL, .read_packet = read_packet,
read_header,
read_packet,
.extensions = "cdg" .extensions = "cdg"
}; };

19
libavformat/crcenc.c
Unescape View File

@ -55,14 +55,13 @@ static int crc_write_trailer(struct AVFormatContext *s)
} }
AVOutputFormat ff_crc_muxer = { AVOutputFormat ff_crc_muxer = {
"crc", .name = "crc",
NULL_IF_CONFIG_SMALL("CRC testing format"), .long_name = NULL_IF_CONFIG_SMALL("CRC testing format"),
NULL, .extensions = "",
"", .priv_data_size = sizeof(CRCState),
sizeof(CRCState), .audio_codec = CODEC_ID_PCM_S16LE,
CODEC_ID_PCM_S16LE, .video_codec = CODEC_ID_RAWVIDEO,
CODEC_ID_RAWVIDEO, .write_header = crc_write_header,
crc_write_header, .write_packet = crc_write_packet,
crc_write_packet, .write_trailer = crc_write_trailer,
crc_write_trailer,
}; };

12
libavformat/daud.c
Unescape View File

@ -71,14 +71,10 @@ static int daud_write_packet(struct AVFormatContext *s, AVPacket *pkt)
#if CONFIG_DAUD_DEMUXER #if CONFIG_DAUD_DEMUXER
AVInputFormat ff_daud_demuxer = { AVInputFormat ff_daud_demuxer = {
"daud", .name = "daud",
NULL_IF_CONFIG_SMALL("D-Cinema audio format"), .long_name = NULL_IF_CONFIG_SMALL("D-Cinema audio format"),
0, .read_header = daud_header,
NULL, .read_packet = daud_packet,
daud_header,
daud_packet,
NULL,
NULL,
.extensions = "302", .extensions = "302",
}; };
#endif #endif

11
libavformat/dfa.c
Unescape View File

@ -109,11 +109,10 @@ static int dfa_read_packet(AVFormatContext *s, AVPacket *pkt)
} }
AVInputFormat ff_dfa_demuxer = { AVInputFormat ff_dfa_demuxer = {
"dfa", .name = "dfa",
NULL_IF_CONFIG_SMALL("Chronomaster DFA"), .long_name = NULL_IF_CONFIG_SMALL("Chronomaster DFA"),
0, .read_probe = dfa_probe,
dfa_probe, .read_header = dfa_read_header,
dfa_read_header, .read_packet = dfa_read_packet,
dfa_read_packet,
.flags = AVFMT_GENERIC_INDEX, .flags = AVFMT_GENERIC_INDEX,
}; };

12
libavformat/dsicin.c
Unescape View File

@ -217,10 +217,10 @@ static int cin_read_packet(AVFormatContext *s, AVPacket *pkt)
} }
AVInputFormat ff_dsicin_demuxer = { AVInputFormat ff_dsicin_demuxer = {
"dsicin", .name = "dsicin",
NULL_IF_CONFIG_SMALL("Delphine Software International CIN format"), .long_name = NULL_IF_CONFIG_SMALL("Delphine Software International CIN format"),
sizeof(CinDemuxContext), .priv_data_size = sizeof(CinDemuxContext),
cin_probe, .read_probe = cin_probe,
cin_read_header, .read_header = cin_read_header,
cin_read_packet, .read_packet = cin_read_packet,
}; };

11
libavformat/dtsdec.c
Unescape View File

@ -66,12 +66,11 @@ static int dts_probe(AVProbeData *p)
} }
AVInputFormat ff_dts_demuxer = { AVInputFormat ff_dts_demuxer = {
"dts", .name = "dts",
NULL_IF_CONFIG_SMALL("raw DTS"), .long_name = NULL_IF_CONFIG_SMALL("raw DTS"),
0, .read_probe = dts_probe,
dts_probe, .read_header = ff_raw_audio_read_header,
ff_raw_audio_read_header, .read_packet = ff_raw_read_partial_packet,
ff_raw_read_partial_packet,
.flags= AVFMT_GENERIC_INDEX, .flags= AVFMT_GENERIC_INDEX,
.extensions = "dts", .extensions = "dts",
.value = CODEC_ID_DTS, .value = CODEC_ID_DTS,

16
libavformat/dv.c
Unescape View File

@ -520,14 +520,14 @@ static int dv_probe(AVProbeData *p)
#if CONFIG_DV_DEMUXER #if CONFIG_DV_DEMUXER
AVInputFormat ff_dv_demuxer = { AVInputFormat ff_dv_demuxer = {
"dv", .name = "dv",
NULL_IF_CONFIG_SMALL("DV video format"), .long_name = NULL_IF_CONFIG_SMALL("DV video format"),
sizeof(RawDVContext), .priv_data_size = sizeof(RawDVContext),
dv_probe, .read_probe = dv_probe,
dv_read_header, .read_header = dv_read_header,
dv_read_packet, .read_packet = dv_read_packet,
dv_read_close, .read_close = dv_read_close,
dv_read_seek, .read_seek = dv_read_seek,
.extensions = "dv,dif", .extensions = "dv,dif",
}; };
#endif #endif

19
libavformat/dvenc.c
Unescape View File

@ -408,14 +408,13 @@ static int dv_write_trailer(struct AVFormatContext *s)
} }
AVOutputFormat ff_dv_muxer = { AVOutputFormat ff_dv_muxer = {
"dv", .name = "dv",
NULL_IF_CONFIG_SMALL("DV video format"), .long_name = NULL_IF_CONFIG_SMALL("DV video format"),
NULL, .extensions = "dv",
"dv", .priv_data_size = sizeof(DVMuxContext),
sizeof(DVMuxContext), .audio_codec = CODEC_ID_PCM_S16LE,
CODEC_ID_PCM_S16LE, .video_codec = CODEC_ID_DVVIDEO,
CODEC_ID_DVVIDEO, .write_header = dv_write_header,
dv_write_header, .write_packet = dv_write_packet,
dv_write_packet, .write_trailer = dv_write_trailer,
dv_write_trailer,
}; };

12
libavformat/dxa.c
Unescape View File

@ -213,10 +213,10 @@ static int dxa_read_packet(AVFormatContext *s, AVPacket *pkt)
} }
AVInputFormat ff_dxa_demuxer = { AVInputFormat ff_dxa_demuxer = {
"dxa", .name = "dxa",
NULL_IF_CONFIG_SMALL("DXA"), .long_name = NULL_IF_CONFIG_SMALL("DXA"),
sizeof(DXAContext), .priv_data_size = sizeof(DXAContext),
dxa_probe, .read_probe = dxa_probe,
dxa_read_header, .read_header = dxa_read_header,
dxa_read_packet, .read_packet = dxa_read_packet,
}; };

12
libavformat/eacdata.c
Unescape View File

@ -91,11 +91,11 @@ static int cdata_read_packet(AVFormatContext *s, AVPacket *pkt)
} }
AVInputFormat ff_ea_cdata_demuxer = { AVInputFormat ff_ea_cdata_demuxer = {
"ea_cdata", .name = "ea_cdata",
NULL_IF_CONFIG_SMALL("Electronic Arts cdata"), .long_name = NULL_IF_CONFIG_SMALL("Electronic Arts cdata"),
sizeof(CdataDemuxContext), .priv_data_size = sizeof(CdataDemuxContext),
cdata_probe, .read_probe = cdata_probe,
cdata_read_header, .read_header = cdata_read_header,
cdata_read_packet, .read_packet = cdata_read_packet,
.extensions = "cdata", .extensions = "cdata",
}; };

12
libavformat/electronicarts.c
Unescape View File

@ -569,10 +569,10 @@ get_video_packet:
} }
AVInputFormat ff_ea_demuxer = { AVInputFormat ff_ea_demuxer = {
"ea", .name = "ea",
NULL_IF_CONFIG_SMALL("Electronic Arts Multimedia Format"), .long_name = NULL_IF_CONFIG_SMALL("Electronic Arts Multimedia Format"),
sizeof(EaDemuxContext), .priv_data_size = sizeof(EaDemuxContext),
ea_probe, .read_probe = ea_probe,
ea_read_header, .read_header = ea_read_header,
ea_read_packet, .read_packet = ea_read_packet,
}; };

16
libavformat/ffmdec.c
Unescape View File

@ -509,12 +509,12 @@ static int ffm_probe(AVProbeData *p)
} }
AVInputFormat ff_ffm_demuxer = { AVInputFormat ff_ffm_demuxer = {
"ffm", .name = "ffm",
NULL_IF_CONFIG_SMALL("FFM (FFserver live feed) format"), .long_name = NULL_IF_CONFIG_SMALL("FFM (FFserver live feed) format"),
sizeof(FFMContext), .priv_data_size = sizeof(FFMContext),
ffm_probe, .read_probe = ffm_probe,
ffm_read_header, .read_header = ffm_read_header,
ffm_read_packet, .read_packet = ffm_read_packet,
ffm_close, .read_close = ffm_close,
ffm_seek, .read_seek = ffm_seek,
}; };

21
libavformat/ffmenc.c
Unescape View File

@ -241,15 +241,14 @@ static int ffm_write_trailer(AVFormatContext *s)
} }
AVOutputFormat ff_ffm_muxer = { AVOutputFormat ff_ffm_muxer = {
"ffm", .name = "ffm",
NULL_IF_CONFIG_SMALL("FFM (FFserver live feed) format"), .long_name = NULL_IF_CONFIG_SMALL("FFM (FFserver live feed) format"),
"", .mime_type = "",
"ffm", .extensions = "ffm",
sizeof(FFMContext), .priv_data_size = sizeof(FFMContext),
/* not really used */ .audio_codec = CODEC_ID_MP2,
CODEC_ID_MP2, .video_codec = CODEC_ID_MPEG1VIDEO,
CODEC_ID_MPEG1VIDEO, .write_header = ffm_write_header,
ffm_write_header, .write_packet = ffm_write_packet,
ffm_write_packet, .write_trailer = ffm_write_trailer,
ffm_write_trailer,
}; };

14
libavformat/filmstripdec.c
Unescape View File

@ -99,13 +99,11 @@ static int read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, in
} }
AVInputFormat ff_filmstrip_demuxer = { AVInputFormat ff_filmstrip_demuxer = {
"filmstrip", .name = "filmstrip",
NULL_IF_CONFIG_SMALL("Adobe Filmstrip"), .long_name = NULL_IF_CONFIG_SMALL("Adobe Filmstrip"),
sizeof(FilmstripDemuxContext), .priv_data_size = sizeof(FilmstripDemuxContext),
NULL, .read_header = read_header,
read_header, .read_packet = read_packet,
read_packet, .read_seek = read_seek,
NULL,
read_seek,
.extensions = "flm", .extensions = "flm",
}; };

19
libavformat/filmstripenc.c
Unescape View File

@ -72,14 +72,13 @@ static int write_trailer(AVFormatContext *s)
} }
AVOutputFormat ff_filmstrip_muxer = { AVOutputFormat ff_filmstrip_muxer = {
"filmstrip", .name = "filmstrip",
NULL_IF_CONFIG_SMALL("Adobe Filmstrip"), .long_name = NULL_IF_CONFIG_SMALL("Adobe Filmstrip"),
NULL, .extensions = "flm",
"flm", .priv_data_size = sizeof(FilmstripMuxContext),
sizeof(FilmstripMuxContext), .audio_codec = CODEC_ID_NONE,
CODEC_ID_NONE, .video_codec = CODEC_ID_RAWVIDEO,
CODEC_ID_RAWVIDEO, .write_header = write_header,
write_header, .write_packet = write_packet,
write_packet, .write_trailer = write_trailer,
write_trailer,
}; };

11
libavformat/flacdec.c
Unescape View File

@ -124,12 +124,11 @@ static int flac_probe(AVProbeData *p)
} }
AVInputFormat ff_flac_demuxer = { AVInputFormat ff_flac_demuxer = {
"flac", .name = "flac",
NULL_IF_CONFIG_SMALL("raw FLAC"), .long_name = NULL_IF_CONFIG_SMALL("raw FLAC"),
0, .read_probe = flac_probe,
flac_probe, .read_header = flac_read_header,
flac_read_header, .read_packet = ff_raw_read_partial_packet,
ff_raw_read_partial_packet,
.flags= AVFMT_GENERIC_INDEX, .flags= AVFMT_GENERIC_INDEX,
.extensions = "flac", .extensions = "flac",
.value = CODEC_ID_FLAC, .value = CODEC_ID_FLAC,

19
libavformat/flacenc.c
Unescape View File

@ -118,15 +118,14 @@ static int flac_write_packet(struct AVFormatContext *s, AVPacket *pkt)
} }
AVOutputFormat ff_flac_muxer = { AVOutputFormat ff_flac_muxer = {
"flac", .name = "flac",
NULL_IF_CONFIG_SMALL("raw FLAC"), .long_name = NULL_IF_CONFIG_SMALL("raw FLAC"),
"audio/x-flac", .mime_type = "audio/x-flac",
"flac", .extensions = "flac",
0, .audio_codec = CODEC_ID_FLAC,
CODEC_ID_FLAC, .video_codec = CODEC_ID_NONE,
CODEC_ID_NONE, .write_header = flac_write_header,
flac_write_header, .write_packet = flac_write_packet,
flac_write_packet, .write_trailer = flac_write_trailer,
flac_write_trailer,
.flags= AVFMT_NOTIMESTAMPS, .flags= AVFMT_NOTIMESTAMPS,
}; };

12
libavformat/flic.c
Unescape View File

@ -261,10 +261,10 @@ static int flic_read_packet(AVFormatContext *s,
} }
AVInputFormat ff_flic_demuxer = { AVInputFormat ff_flic_demuxer = {
"flic", .name = "flic",
NULL_IF_CONFIG_SMALL("FLI/FLC/FLX animation format"), .long_name = NULL_IF_CONFIG_SMALL("FLI/FLC/FLX animation format"),
sizeof(FlicDemuxContext), .priv_data_size = sizeof(FlicDemuxContext),
flic_probe, .read_probe = flic_probe,
flic_read_header, .read_header = flic_read_header,
flic_read_packet, .read_packet = flic_read_packet,
}; };

12
libavformat/flvdec.c
Unescape View File

@ -572,12 +572,12 @@ static int flv_read_seek2(AVFormatContext *s, int stream_index,
#endif #endif
AVInputFormat ff_flv_demuxer = { AVInputFormat ff_flv_demuxer = {
"flv", .name = "flv",
NULL_IF_CONFIG_SMALL("FLV format"), .long_name = NULL_IF_CONFIG_SMALL("FLV format"),
sizeof(FLVContext), .priv_data_size = sizeof(FLVContext),
flv_probe, .read_probe = flv_probe,
flv_read_header, .read_header = flv_read_header,
flv_read_packet, .read_packet = flv_read_packet,
.read_seek = flv_read_seek, .read_seek = flv_read_seek,
#if 0 #if 0
.read_seek2 = flv_read_seek2, .read_seek2 = flv_read_seek2,

22
libavformat/flvenc.c
Unescape View File

@ -441,20 +441,20 @@ static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
} }
AVOutputFormat ff_flv_muxer = { AVOutputFormat ff_flv_muxer = {
"flv", .name = "flv",
NULL_IF_CONFIG_SMALL("FLV format"), .long_name = NULL_IF_CONFIG_SMALL("FLV format"),
"video/x-flv", .mime_type = "video/x-flv",
"flv", .extensions = "flv",
sizeof(FLVContext), .priv_data_size = sizeof(FLVContext),
#if CONFIG_LIBMP3LAME #if CONFIG_LIBMP3LAME
CODEC_ID_MP3, .audio_codec = CODEC_ID_MP3,
#else // CONFIG_LIBMP3LAME #else // CONFIG_LIBMP3LAME
CODEC_ID_ADPCM_SWF, .audio_codec = CODEC_ID_ADPCM_SWF,
#endif // CONFIG_LIBMP3LAME #endif // CONFIG_LIBMP3LAME
CODEC_ID_FLV1, .video_codec = CODEC_ID_FLV1,
flv_write_header, .write_header = flv_write_header,
flv_write_packet, .write_packet = flv_write_packet,
flv_write_trailer, .write_trailer = flv_write_trailer,
.codec_tag= (const AVCodecTag* const []){flv_video_codec_ids, flv_audio_codec_ids, 0}, .codec_tag= (const AVCodecTag* const []){flv_video_codec_ids, flv_audio_codec_ids, 0},
.flags= AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS, .flags= AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS,
}; };

16
libavformat/framecrcenc.c
Unescape View File

@ -34,14 +34,10 @@ static int framecrc_write_packet(struct AVFormatContext *s, AVPacket *pkt)
} }
AVOutputFormat ff_framecrc_muxer = { AVOutputFormat ff_framecrc_muxer = {
"framecrc", .name = "framecrc",
NULL_IF_CONFIG_SMALL("framecrc testing format"), .long_name = NULL_IF_CONFIG_SMALL("framecrc testing format"),
NULL, .extensions = "",
"", .audio_codec = CODEC_ID_PCM_S16LE,
0, .video_codec = CODEC_ID_RAWVIDEO,
CODEC_ID_PCM_S16LE, .write_packet = framecrc_write_packet,
CODEC_ID_RAWVIDEO,
NULL,
framecrc_write_packet,
NULL,
}; };

20
libavformat/gif.c
Unescape View File

@ -363,15 +363,15 @@ static const AVClass gif_muxer_class = {
}; };
AVOutputFormat ff_gif_muxer = { AVOutputFormat ff_gif_muxer = {
"gif", .name = "gif",
NULL_IF_CONFIG_SMALL("GIF Animation"), .long_name = NULL_IF_CONFIG_SMALL("GIF Animation"),
"image/gif", .mime_type = "image/gif",
"gif", .extensions = "gif",
sizeof(GIFContext), .priv_data_size = sizeof(GIFContext),
CODEC_ID_NONE, .audio_codec = CODEC_ID_NONE,
CODEC_ID_RAWVIDEO, .video_codec = CODEC_ID_RAWVIDEO,
gif_write_header, .write_header = gif_write_header,
gif_write_packet, .write_packet = gif_write_packet,
gif_write_trailer, .write_trailer = gif_write_trailer,
.priv_class = &gif_muxer_class, .priv_class = &gif_muxer_class,
}; };

17
libavformat/gxf.c
Unescape View File

@ -523,13 +523,12 @@ static int64_t gxf_read_timestamp(AVFormatContext *s, int stream_index,
} }
AVInputFormat ff_gxf_demuxer = { AVInputFormat ff_gxf_demuxer = {
"gxf", .name = "gxf",
NULL_IF_CONFIG_SMALL("GXF format"), .long_name = NULL_IF_CONFIG_SMALL("GXF format"),
sizeof(struct gxf_stream_info), .priv_data_size = sizeof(struct gxf_stream_info),
gxf_probe, .read_probe = gxf_probe,
gxf_header, .read_header = gxf_header,
gxf_packet, .read_packet = gxf_packet,
NULL, .read_seek = gxf_seek,
gxf_seek, .read_timestamp = gxf_read_timestamp,
gxf_read_timestamp,
}; };

23
libavformat/gxfenc.c
Unescape View File

@ -943,17 +943,14 @@ static int gxf_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *pk
} }
AVOutputFormat ff_gxf_muxer = { AVOutputFormat ff_gxf_muxer = {
"gxf", .name = "gxf",
NULL_IF_CONFIG_SMALL("GXF format"), .long_name = NULL_IF_CONFIG_SMALL("GXF format"),
NULL, .extensions = "gxf",
"gxf", .priv_data_size = sizeof(GXFContext),
sizeof(GXFContext), .audio_codec = CODEC_ID_PCM_S16LE,
CODEC_ID_PCM_S16LE, .video_codec = CODEC_ID_MPEG2VIDEO,
CODEC_ID_MPEG2VIDEO, .write_header = gxf_write_header,
gxf_write_header, .write_packet = gxf_write_packet,
gxf_write_packet, .write_trailer = gxf_write_trailer,
gxf_write_trailer, .interleave_packet = gxf_interleave_packet,
0,
NULL,
gxf_interleave_packet,
}; };

12
libavformat/idcin.c
Unescape View File

@ -292,10 +292,10 @@ static int idcin_read_packet(AVFormatContext *s,
} }
AVInputFormat ff_idcin_demuxer = { AVInputFormat ff_idcin_demuxer = {
"idcin", .name = "idcin",
NULL_IF_CONFIG_SMALL("id Cinematic format"), .long_name = NULL_IF_CONFIG_SMALL("id Cinematic format"),
sizeof(IdcinDemuxContext), .priv_data_size = sizeof(IdcinDemuxContext),
idcin_probe, .read_probe = idcin_probe,
idcin_read_header, .read_header = idcin_read_header,
idcin_read_packet, .read_packet = idcin_read_packet,
}; };

12
libavformat/idroqdec.c
Unescape View File

@ -216,10 +216,10 @@ static int roq_read_packet(AVFormatContext *s,
} }
AVInputFormat ff_roq_demuxer = { AVInputFormat ff_roq_demuxer = {
"RoQ", .name = "RoQ",
NULL_IF_CONFIG_SMALL("id RoQ format"), .long_name = NULL_IF_CONFIG_SMALL("id RoQ format"),
sizeof(RoqDemuxContext), .priv_data_size = sizeof(RoqDemuxContext),
roq_probe, .read_probe = roq_probe,
roq_read_header, .read_header = roq_read_header,
roq_read_packet, .read_packet = roq_read_packet,
}; };

12
libavformat/iff.c
Unescape View File

@ -316,10 +316,10 @@ static int iff_read_packet(AVFormatContext *s,
} }
AVInputFormat ff_iff_demuxer = { AVInputFormat ff_iff_demuxer = {
"IFF", .name = "IFF",
NULL_IF_CONFIG_SMALL("IFF format"), .long_name = NULL_IF_CONFIG_SMALL("IFF format"),
sizeof(IffDemuxContext), .priv_data_size = sizeof(IffDemuxContext),
iff_probe, .read_probe = iff_probe,
iff_read_header, .read_header = iff_read_header,
iff_read_packet, .read_packet = iff_read_packet,
}; };

11
libavformat/ingenientdec.c
Unescape View File

@ -59,12 +59,11 @@ static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt)
} }
AVInputFormat ff_ingenient_demuxer = { AVInputFormat ff_ingenient_demuxer = {
"ingenient", .name = "ingenient",
NULL_IF_CONFIG_SMALL("raw Ingenient MJPEG"), .long_name = NULL_IF_CONFIG_SMALL("raw Ingenient MJPEG"),
sizeof(FFRawVideoDemuxerContext), .priv_data_size = sizeof(FFRawVideoDemuxerContext),
NULL, .read_header = ff_raw_video_read_header,
ff_raw_video_read_header, .read_packet = ingenient_read_packet,
ingenient_read_packet,
.flags= AVFMT_GENERIC_INDEX, .flags= AVFMT_GENERIC_INDEX,
.extensions = "cgi", // FIXME .extensions = "cgi", // FIXME
.value = CODEC_ID_MJPEG, .value = CODEC_ID_MJPEG,

12
libavformat/ipmovie.c
Unescape View File

@ -616,10 +616,10 @@ static int ipmovie_read_packet(AVFormatContext *s,
} }
AVInputFormat ff_ipmovie_demuxer = { AVInputFormat ff_ipmovie_demuxer = {
"ipmovie", .name = "ipmovie",
NULL_IF_CONFIG_SMALL("Interplay MVE format"), .long_name = NULL_IF_CONFIG_SMALL("Interplay MVE format"),
sizeof(IPMVEContext), .priv_data_size = sizeof(IPMVEContext),
ipmovie_probe, .read_probe = ipmovie_probe,
ipmovie_read_header, .read_header = ipmovie_read_header,
ipmovie_read_packet, .read_packet = ipmovie_read_packet,
}; };

12
libavformat/iss.c
Unescape View File

@ -122,11 +122,11 @@ static int iss_read_packet(AVFormatContext *s, AVPacket *pkt)
} }
AVInputFormat ff_iss_demuxer = { AVInputFormat ff_iss_demuxer = {
"ISS", .name = "ISS",
NULL_IF_CONFIG_SMALL("Funcom ISS format"), .long_name = NULL_IF_CONFIG_SMALL("Funcom ISS format"),
sizeof(IssDemuxContext), .priv_data_size = sizeof(IssDemuxContext),
iss_probe, .read_probe = iss_probe,
iss_read_header, .read_header = iss_read_header,
iss_read_packet, .read_packet = iss_read_packet,
}; };

11
libavformat/iv8.c
Unescape View File

@ -85,12 +85,11 @@ retry:
} }
AVInputFormat ff_iv8_demuxer = { AVInputFormat ff_iv8_demuxer = {
"iv8", .name = "iv8",
NULL_IF_CONFIG_SMALL("A format generated by IndigoVision 8000 video server"), .long_name = NULL_IF_CONFIG_SMALL("A format generated by IndigoVision 8000 video server"),
0, .read_probe = probe,
probe, .read_header = read_header,
read_header, .read_packet = read_packet,
read_packet,
.flags= AVFMT_GENERIC_INDEX, .flags= AVFMT_GENERIC_INDEX,
.value = CODEC_ID_MPEG4, .value = CODEC_ID_MPEG4,
}; };

11
libavformat/ivfdec.c
Unescape View File

@ -80,12 +80,11 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
} }
AVInputFormat ff_ivf_demuxer = { AVInputFormat ff_ivf_demuxer = {
"ivf", .name = "ivf",
NULL_IF_CONFIG_SMALL("On2 IVF"), .long_name = NULL_IF_CONFIG_SMALL("On2 IVF"),
0, .read_probe = probe,
probe, .read_header = read_header,
read_header, .read_packet = read_packet,
read_packet,
.flags= AVFMT_GENERIC_INDEX, .flags= AVFMT_GENERIC_INDEX,
.codec_tag = (const AVCodecTag*[]){ff_codec_bmp_tags, 0}, .codec_tag = (const AVCodecTag*[]){ff_codec_bmp_tags, 0},
}; };

36
libavformat/libnut.c
Unescape View File

@ -151,16 +151,16 @@ static int nut_write_trailer(AVFormatContext * avf) {
} }
AVOutputFormat ff_libnut_muxer = { AVOutputFormat ff_libnut_muxer = {
"libnut", .name = "libnut",
"nut format", .long_name = "nut format",
"video/x-nut", .mime_type = "video/x-nut",
"nut", .extensions = "nut",
sizeof(NUTContext), .priv_data_size = sizeof(NUTContext),
CODEC_ID_VORBIS, .audio_codec = CODEC_ID_VORBIS,
CODEC_ID_MPEG4, .video_codec = CODEC_ID_MPEG4,
nut_write_header, .write_header = nut_write_header,
nut_write_packet, .write_packet = nut_write_packet,
nut_write_trailer, .write_trailer = nut_write_trailer,
.flags = AVFMT_GLOBALHEADER, .flags = AVFMT_GLOBALHEADER,
}; };
#endif /* CONFIG_LIBNUT_MUXER */ #endif /* CONFIG_LIBNUT_MUXER */
@ -298,13 +298,13 @@ static int nut_read_close(AVFormatContext *s) {
} }
AVInputFormat ff_libnut_demuxer = { AVInputFormat ff_libnut_demuxer = {
"libnut", .name = "libnut",
NULL_IF_CONFIG_SMALL("NUT format"), .long_name = NULL_IF_CONFIG_SMALL("NUT format"),
sizeof(NUTContext), .priv_data_size = sizeof(NUTContext),
nut_probe, .read_probe = nut_probe,
nut_read_header, .read_header = nut_read_header,
nut_read_packet, .read_packet = nut_read_packet,
nut_read_close, .read_close = nut_read_close,
nut_read_seek, .read_seek = nut_read_seek,
.extensions = "nut", .extensions = "nut",
}; };

11
libavformat/lmlm4.c
Unescape View File

@ -118,10 +118,9 @@ static int lmlm4_read_packet(AVFormatContext *s, AVPacket *pkt) {
} }
AVInputFormat ff_lmlm4_demuxer = { AVInputFormat ff_lmlm4_demuxer = {
"lmlm4", .name = "lmlm4",
NULL_IF_CONFIG_SMALL("lmlm4 raw format"), .long_name = NULL_IF_CONFIG_SMALL("lmlm4 raw format"),
0, .read_probe = lmlm4_probe,
lmlm4_probe, .read_header = lmlm4_read_header,
lmlm4_read_header, .read_packet = lmlm4_read_packet,
lmlm4_read_packet,
}; };

16
libavformat/matroskadec.c
Unescape View File

@ -1999,12 +1999,12 @@ static int matroska_read_close(AVFormatContext *s)
} }
AVInputFormat ff_matroska_demuxer = { AVInputFormat ff_matroska_demuxer = {
"matroska,webm", .name = "matroska,webm",
NULL_IF_CONFIG_SMALL("Matroska/WebM file format"), .long_name = NULL_IF_CONFIG_SMALL("Matroska/WebM file format"),
sizeof(MatroskaDemuxContext), .priv_data_size = sizeof(MatroskaDemuxContext),
matroska_probe, .read_probe = matroska_probe,
matroska_read_header, .read_header = matroska_read_header,
matroska_read_packet, .read_packet = matroska_read_packet,
matroska_read_close, .read_close = matroska_read_close,
matroska_read_seek, .read_seek = matroska_read_seek,
}; };

60
libavformat/matroskaenc.c
Unescape View File

@ -1193,16 +1193,16 @@ static int mkv_write_trailer(AVFormatContext *s)
#if CONFIG_MATROSKA_MUXER #if CONFIG_MATROSKA_MUXER
AVOutputFormat ff_matroska_muxer = { AVOutputFormat ff_matroska_muxer = {
"matroska", .name = "matroska",
NULL_IF_CONFIG_SMALL("Matroska file format"), .long_name = NULL_IF_CONFIG_SMALL("Matroska file format"),
"video/x-matroska", .mime_type = "video/x-matroska",
"mkv", .extensions = "mkv",
sizeof(MatroskaMuxContext), .priv_data_size = sizeof(MatroskaMuxContext),
CODEC_ID_MP2, .audio_codec = CODEC_ID_MP2,
CODEC_ID_MPEG4, .video_codec = CODEC_ID_MPEG4,
mkv_write_header, .write_header = mkv_write_header,
mkv_write_packet, .write_packet = mkv_write_packet,
mkv_write_trailer, .write_trailer = mkv_write_trailer,
.flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS, .flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS,
.codec_tag = (const AVCodecTag* const []){ff_codec_bmp_tags, ff_codec_wav_tags, 0}, .codec_tag = (const AVCodecTag* const []){ff_codec_bmp_tags, ff_codec_wav_tags, 0},
.subtitle_codec = CODEC_ID_SSA, .subtitle_codec = CODEC_ID_SSA,
@ -1211,32 +1211,32 @@ AVOutputFormat ff_matroska_muxer = {
#if CONFIG_WEBM_MUXER #if CONFIG_WEBM_MUXER
AVOutputFormat ff_webm_muxer = { AVOutputFormat ff_webm_muxer = {
"webm", .name = "webm",
NULL_IF_CONFIG_SMALL("WebM file format"), .long_name = NULL_IF_CONFIG_SMALL("WebM file format"),
"video/webm", .mime_type = "video/webm",
"webm", .extensions = "webm",
sizeof(MatroskaMuxContext), .priv_data_size = sizeof(MatroskaMuxContext),
CODEC_ID_VORBIS, .audio_codec = CODEC_ID_VORBIS,
CODEC_ID_VP8, .video_codec = CODEC_ID_VP8,
mkv_write_header, .write_header = mkv_write_header,
mkv_write_packet, .write_packet = mkv_write_packet,
mkv_write_trailer, .write_trailer = mkv_write_trailer,
.flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS, .flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS,
}; };
#endif #endif
#if CONFIG_MATROSKA_AUDIO_MUXER #if CONFIG_MATROSKA_AUDIO_MUXER
AVOutputFormat ff_matroska_audio_muxer = { AVOutputFormat ff_matroska_audio_muxer = {
"matroska", .name = "matroska",
NULL_IF_CONFIG_SMALL("Matroska file format"), .long_name = NULL_IF_CONFIG_SMALL("Matroska file format"),
"audio/x-matroska", .mime_type = "audio/x-matroska",
"mka", .extensions = "mka",
sizeof(MatroskaMuxContext), .priv_data_size = sizeof(MatroskaMuxContext),
CODEC_ID_MP2, .audio_codec = CODEC_ID_MP2,
CODEC_ID_NONE, .video_codec = CODEC_ID_NONE,
mkv_write_header, .write_header = mkv_write_header,
mkv_write_packet, .write_packet = mkv_write_packet,
mkv_write_trailer, .write_trailer = mkv_write_trailer,
.flags = AVFMT_GLOBALHEADER, .flags = AVFMT_GLOBALHEADER,
.codec_tag = (const AVCodecTag* const []){ff_codec_wav_tags, 0}, .codec_tag = (const AVCodecTag* const []){ff_codec_wav_tags, 0},
}; };

36
libavformat/md5enc.c
Unescape View File

@ -66,16 +66,15 @@ static int write_trailer(struct AVFormatContext *s)
} }
AVOutputFormat ff_md5_muxer = { AVOutputFormat ff_md5_muxer = {
"md5", .name = "md5",
NULL_IF_CONFIG_SMALL("MD5 testing format"), .long_name = NULL_IF_CONFIG_SMALL("MD5 testing format"),
NULL, .extensions = "",
"", .priv_data_size = PRIVSIZE,
PRIVSIZE, .audio_codec = CODEC_ID_PCM_S16LE,
CODEC_ID_PCM_S16LE, .video_codec = CODEC_ID_RAWVIDEO,
CODEC_ID_RAWVIDEO, .write_header = write_header,
write_header, .write_packet = write_packet,
write_packet, .write_trailer = write_trailer,
write_trailer,
}; };
#endif #endif
@ -96,15 +95,12 @@ static int framemd5_write_packet(struct AVFormatContext *s, AVPacket *pkt)
} }
AVOutputFormat ff_framemd5_muxer = { AVOutputFormat ff_framemd5_muxer = {
"framemd5", .name = "framemd5",
NULL_IF_CONFIG_SMALL("Per-frame MD5 testing format"), .long_name = NULL_IF_CONFIG_SMALL("Per-frame MD5 testing format"),
NULL, .extensions = "",
"", .priv_data_size = PRIVSIZE,
PRIVSIZE, .audio_codec = CODEC_ID_PCM_S16LE,
CODEC_ID_PCM_S16LE, .video_codec = CODEC_ID_RAWVIDEO,
CODEC_ID_RAWVIDEO, .write_packet = framemd5_write_packet,
NULL,
framemd5_write_packet,
NULL,
}; };
#endif #endif

12
libavformat/mm.c
Unescape View File

@ -187,10 +187,10 @@ static int read_packet(AVFormatContext *s,
} }
AVInputFormat ff_mm_demuxer = { AVInputFormat ff_mm_demuxer = {
"mm", .name = "mm",
NULL_IF_CONFIG_SMALL("American Laser Games MM format"), .long_name = NULL_IF_CONFIG_SMALL("American Laser Games MM format"),
sizeof(MmDemuxContext), .priv_data_size = sizeof(MmDemuxContext),
probe, .read_probe = probe,
read_header, .read_header = read_header,
read_packet, .read_packet = read_packet,
}; };

35
libavformat/mmf.c
Unescape View File

@ -291,27 +291,26 @@ static int mmf_read_packet(AVFormatContext *s,
#if CONFIG_MMF_DEMUXER #if CONFIG_MMF_DEMUXER
AVInputFormat ff_mmf_demuxer = { AVInputFormat ff_mmf_demuxer = {
"mmf", .name = "mmf",
NULL_IF_CONFIG_SMALL("Yamaha SMAF"), .long_name = NULL_IF_CONFIG_SMALL("Yamaha SMAF"),
sizeof(MMFContext), .priv_data_size = sizeof(MMFContext),
mmf_probe, .read_probe = mmf_probe,
mmf_read_header, .read_header = mmf_read_header,
mmf_read_packet, .read_packet = mmf_read_packet,
NULL, .read_seek = pcm_read_seek,
pcm_read_seek,
}; };
#endif #endif
#if CONFIG_MMF_MUXER #if CONFIG_MMF_MUXER
AVOutputFormat ff_mmf_muxer = { AVOutputFormat ff_mmf_muxer = {
"mmf", .name = "mmf",
NULL_IF_CONFIG_SMALL("Yamaha SMAF"), .long_name = NULL_IF_CONFIG_SMALL("Yamaha SMAF"),
"application/vnd.smaf", .mime_type = "application/vnd.smaf",
"mmf", .extensions = "mmf",
sizeof(MMFContext), .priv_data_size = sizeof(MMFContext),
CODEC_ID_ADPCM_YAMAHA, .audio_codec = CODEC_ID_ADPCM_YAMAHA,
CODEC_ID_NONE, .video_codec = CODEC_ID_NONE,
mmf_write_header, .write_header = mmf_write_header,
mmf_write_packet, .write_packet = mmf_write_packet,
mmf_write_trailer, .write_trailer = mmf_write_trailer,
}; };
#endif #endif

16
libavformat/mov.c
Unescape View File

@ -2611,12 +2611,12 @@ static int mov_read_close(AVFormatContext *s)
} }
AVInputFormat ff_mov_demuxer = { AVInputFormat ff_mov_demuxer = {
"mov,mp4,m4a,3gp,3g2,mj2", .name = "mov,mp4,m4a,3gp,3g2,mj2",
NULL_IF_CONFIG_SMALL("QuickTime/MPEG-4/Motion JPEG 2000 format"), .long_name = NULL_IF_CONFIG_SMALL("QuickTime/MPEG-4/Motion JPEG 2000 format"),
sizeof(MOVContext), .priv_data_size = sizeof(MOVContext),
mov_probe, .read_probe = mov_probe,
mov_read_header, .read_header = mov_read_header,
mov_read_packet, .read_packet = mov_read_packet,
mov_read_close, .read_close = mov_read_close,
mov_read_seek, .read_seek = mov_read_seek,
}; };

116
libavformat/movenc.c
Unescape View File

@ -2338,16 +2338,15 @@ static int mov_write_trailer(AVFormatContext *s)
#if CONFIG_MOV_MUXER #if CONFIG_MOV_MUXER
AVOutputFormat ff_mov_muxer = { AVOutputFormat ff_mov_muxer = {
"mov", .name = "mov",
NULL_IF_CONFIG_SMALL("MOV format"), .long_name = NULL_IF_CONFIG_SMALL("MOV format"),
NULL, .extensions = "mov",
"mov", .priv_data_size = sizeof(MOVMuxContext),
sizeof(MOVMuxContext), .audio_codec = CODEC_ID_AAC,
CODEC_ID_AAC, .video_codec = CODEC_ID_MPEG4,
CODEC_ID_MPEG4, .write_header = mov_write_header,
mov_write_header, .write_packet = ff_mov_write_packet,
ff_mov_write_packet, .write_trailer = mov_write_trailer,
mov_write_trailer,
.flags = AVFMT_GLOBALHEADER, .flags = AVFMT_GLOBALHEADER,
.codec_tag = (const AVCodecTag* const []){codec_movvideo_tags, codec_movaudio_tags, 0}, .codec_tag = (const AVCodecTag* const []){codec_movvideo_tags, codec_movaudio_tags, 0},
.priv_class = &mov_muxer_class, .priv_class = &mov_muxer_class,
@ -2355,16 +2354,15 @@ AVOutputFormat ff_mov_muxer = {
#endif #endif
#if CONFIG_TGP_MUXER #if CONFIG_TGP_MUXER
AVOutputFormat ff_tgp_muxer = { AVOutputFormat ff_tgp_muxer = {
"3gp", .name = "3gp",
NULL_IF_CONFIG_SMALL("3GP format"), .long_name = NULL_IF_CONFIG_SMALL("3GP format"),
NULL, .extensions = "3gp",
"3gp", .priv_data_size = sizeof(MOVMuxContext),
sizeof(MOVMuxContext), .audio_codec = CODEC_ID_AMR_NB,
CODEC_ID_AMR_NB, .video_codec = CODEC_ID_H263,
CODEC_ID_H263, .write_header = mov_write_header,
mov_write_header, .write_packet = ff_mov_write_packet,
ff_mov_write_packet, .write_trailer = mov_write_trailer,
mov_write_trailer,
.flags = AVFMT_GLOBALHEADER, .flags = AVFMT_GLOBALHEADER,
.codec_tag = (const AVCodecTag* const []){codec_3gp_tags, 0}, .codec_tag = (const AVCodecTag* const []){codec_3gp_tags, 0},
.priv_class = &mov_muxer_class, .priv_class = &mov_muxer_class,
@ -2372,16 +2370,16 @@ AVOutputFormat ff_tgp_muxer = {
#endif #endif
#if CONFIG_MP4_MUXER #if CONFIG_MP4_MUXER
AVOutputFormat ff_mp4_muxer = { AVOutputFormat ff_mp4_muxer = {
"mp4", .name = "mp4",
NULL_IF_CONFIG_SMALL("MP4 format"), .long_name = NULL_IF_CONFIG_SMALL("MP4 format"),
"application/mp4", .mime_type = "application/mp4",
"mp4", .extensions = "mp4",
sizeof(MOVMuxContext), .priv_data_size = sizeof(MOVMuxContext),
CODEC_ID_AAC, .audio_codec = CODEC_ID_AAC,
CODEC_ID_MPEG4, .video_codec = CODEC_ID_MPEG4,
mov_write_header, .write_header = mov_write_header,
ff_mov_write_packet, .write_packet = ff_mov_write_packet,
mov_write_trailer, .write_trailer = mov_write_trailer,
.flags = AVFMT_GLOBALHEADER, .flags = AVFMT_GLOBALHEADER,
.codec_tag = (const AVCodecTag* const []){ff_mp4_obj_type, 0}, .codec_tag = (const AVCodecTag* const []){ff_mp4_obj_type, 0},
.priv_class = &mov_muxer_class, .priv_class = &mov_muxer_class,
@ -2389,16 +2387,15 @@ AVOutputFormat ff_mp4_muxer = {
#endif #endif
#if CONFIG_PSP_MUXER #if CONFIG_PSP_MUXER
AVOutputFormat ff_psp_muxer = { AVOutputFormat ff_psp_muxer = {
"psp", .name = "psp",
NULL_IF_CONFIG_SMALL("PSP MP4 format"), .long_name = NULL_IF_CONFIG_SMALL("PSP MP4 format"),
NULL, .extensions = "mp4,psp",
"mp4,psp", .priv_data_size = sizeof(MOVMuxContext),
sizeof(MOVMuxContext), .audio_codec = CODEC_ID_AAC,
CODEC_ID_AAC, .video_codec = CODEC_ID_MPEG4,
CODEC_ID_MPEG4, .write_header = mov_write_header,
mov_write_header, .write_packet = ff_mov_write_packet,
ff_mov_write_packet, .write_trailer = mov_write_trailer,
mov_write_trailer,
.flags = AVFMT_GLOBALHEADER, .flags = AVFMT_GLOBALHEADER,
.codec_tag = (const AVCodecTag* const []){ff_mp4_obj_type, 0}, .codec_tag = (const AVCodecTag* const []){ff_mp4_obj_type, 0},
.priv_class = &mov_muxer_class, .priv_class = &mov_muxer_class,
@ -2406,16 +2403,15 @@ AVOutputFormat ff_psp_muxer = {
#endif #endif
#if CONFIG_TG2_MUXER #if CONFIG_TG2_MUXER
AVOutputFormat ff_tg2_muxer = { AVOutputFormat ff_tg2_muxer = {
"3g2", .name = "3g2",
NULL_IF_CONFIG_SMALL("3GP2 format"), .long_name = NULL_IF_CONFIG_SMALL("3GP2 format"),
NULL, .extensions = "3g2",
"3g2", .priv_data_size = sizeof(MOVMuxContext),
sizeof(MOVMuxContext), .audio_codec = CODEC_ID_AMR_NB,
CODEC_ID_AMR_NB, .video_codec = CODEC_ID_H263,
CODEC_ID_H263, .write_header = mov_write_header,
mov_write_header, .write_packet = ff_mov_write_packet,
ff_mov_write_packet, .write_trailer = mov_write_trailer,
mov_write_trailer,
.flags = AVFMT_GLOBALHEADER, .flags = AVFMT_GLOBALHEADER,
.codec_tag = (const AVCodecTag* const []){codec_3gp_tags, 0}, .codec_tag = (const AVCodecTag* const []){codec_3gp_tags, 0},
.priv_class = &mov_muxer_class, .priv_class = &mov_muxer_class,
@ -2423,16 +2419,16 @@ AVOutputFormat ff_tg2_muxer = {
#endif #endif
#if CONFIG_IPOD_MUXER #if CONFIG_IPOD_MUXER
AVOutputFormat ff_ipod_muxer = { AVOutputFormat ff_ipod_muxer = {
"ipod", .name = "ipod",
NULL_IF_CONFIG_SMALL("iPod H.264 MP4 format"), .long_name = NULL_IF_CONFIG_SMALL("iPod H.264 MP4 format"),
"application/mp4", .mime_type = "application/mp4",
"m4v,m4a", .extensions = "m4v,m4a",
sizeof(MOVMuxContext), .priv_data_size = sizeof(MOVMuxContext),
CODEC_ID_AAC, .audio_codec = CODEC_ID_AAC,
CODEC_ID_H264, .video_codec = CODEC_ID_H264,
mov_write_header, .write_header = mov_write_header,
ff_mov_write_packet, .write_packet = ff_mov_write_packet,
mov_write_trailer, .write_trailer = mov_write_trailer,
.flags = AVFMT_GLOBALHEADER, .flags = AVFMT_GLOBALHEADER,
.codec_tag = (const AVCodecTag* const []){codec_ipod_tags, 0}, .codec_tag = (const AVCodecTag* const []){codec_ipod_tags, 0},
.priv_class = &mov_muxer_class, .priv_class = &mov_muxer_class,

11
libavformat/mp3dec.c
Unescape View File

@ -188,12 +188,11 @@ static int mp3_read_packet(AVFormatContext *s, AVPacket *pkt)
} }
AVInputFormat ff_mp3_demuxer = { AVInputFormat ff_mp3_demuxer = {
"mp3", .name = "mp3",
NULL_IF_CONFIG_SMALL("MPEG audio layer 2/3"), .long_name = NULL_IF_CONFIG_SMALL("MPEG audio layer 2/3"),
0, .read_probe = mp3_read_probe,
mp3_read_probe, .read_header = mp3_read_header,
mp3_read_header, .read_packet = mp3_read_packet,
mp3_read_packet,
.flags= AVFMT_GENERIC_INDEX, .flags= AVFMT_GENERIC_INDEX,
.extensions = "mp2,mp3,m2a", /* XXX: use probe */ .extensions = "mp2,mp3,m2a", /* XXX: use probe */
}; };

40
libavformat/mp3enc.c
Unescape View File

@ -162,16 +162,14 @@ static int mp3_write_trailer(struct AVFormatContext *s)
#if CONFIG_MP2_MUXER #if CONFIG_MP2_MUXER
AVOutputFormat ff_mp2_muxer = { AVOutputFormat ff_mp2_muxer = {
"mp2", .name = "mp2",
NULL_IF_CONFIG_SMALL("MPEG audio layer 2"), .long_name = NULL_IF_CONFIG_SMALL("MPEG audio layer 2"),
"audio/x-mpeg", .mime_type = "audio/x-mpeg",
"mp2,m2a", .extensions = "mp2,m2a",
0, .audio_codec = CODEC_ID_MP2,
CODEC_ID_MP2, .video_codec = CODEC_ID_NONE,
CODEC_ID_NONE, .write_packet = ff_raw_write_packet,
NULL, .write_trailer = mp3_write_trailer,
ff_raw_write_packet,
mp3_write_trailer,
}; };
#endif #endif
@ -306,17 +304,17 @@ static int mp3_write_header(struct AVFormatContext *s)
} }
AVOutputFormat ff_mp3_muxer = { AVOutputFormat ff_mp3_muxer = {
"mp3", .name = "mp3",
NULL_IF_CONFIG_SMALL("MPEG audio layer 3"), .long_name = NULL_IF_CONFIG_SMALL("MPEG audio layer 3"),
"audio/x-mpeg", .mime_type = "audio/x-mpeg",
"mp3", .extensions = "mp3",
sizeof(MP3Context), .priv_data_size = sizeof(MP3Context),
CODEC_ID_MP3, .audio_codec = CODEC_ID_MP3,
CODEC_ID_NONE, .video_codec = CODEC_ID_NONE,
mp3_write_header, .write_header = mp3_write_header,
ff_raw_write_packet, .write_packet = ff_raw_write_packet,
mp3_write_trailer, .write_trailer = mp3_write_trailer,
AVFMT_NOTIMESTAMPS, .flags = AVFMT_NOTIMESTAMPS,
.priv_class = &mp3_muxer_class, .priv_class = &mp3_muxer_class,
}; };
#endif #endif

16
libavformat/mpc.c
Unescape View File

@ -222,13 +222,13 @@ static int mpc_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp
AVInputFormat ff_mpc_demuxer = { AVInputFormat ff_mpc_demuxer = {
"mpc", .name = "mpc",
NULL_IF_CONFIG_SMALL("Musepack"), .long_name = NULL_IF_CONFIG_SMALL("Musepack"),
sizeof(MPCContext), .priv_data_size = sizeof(MPCContext),
mpc_probe, .read_probe = mpc_probe,
mpc_read_header, .read_header = mpc_read_header,
mpc_read_packet, .read_packet = mpc_read_packet,
mpc_read_close, .read_close = mpc_read_close,
mpc_read_seek, .read_seek = mpc_read_seek,
.extensions = "mpc", .extensions = "mpc",
}; };

15
libavformat/mpc8.c
Unescape View File

@ -281,12 +281,11 @@ static int mpc8_read_seek(AVFormatContext *s, int stream_index, int64_t timestam
AVInputFormat ff_mpc8_demuxer = { AVInputFormat ff_mpc8_demuxer = {
"mpc8", .name = "mpc8",
NULL_IF_CONFIG_SMALL("Musepack SV8"), .long_name = NULL_IF_CONFIG_SMALL("Musepack SV8"),
sizeof(MPCContext), .priv_data_size = sizeof(MPCContext),
mpc8_probe, .read_probe = mpc8_probe,
mpc8_read_header, .read_header = mpc8_read_header,
mpc8_read_packet, .read_packet = mpc8_read_packet,
NULL, .read_seek = mpc8_read_seek,
mpc8_read_seek,
}; };

17
libavformat/mpeg.c
Unescape View File

@ -603,14 +603,13 @@ static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
} }
AVInputFormat ff_mpegps_demuxer = { AVInputFormat ff_mpegps_demuxer = {
"mpeg", .name = "mpeg",
NULL_IF_CONFIG_SMALL("MPEG-PS format"), .long_name = NULL_IF_CONFIG_SMALL("MPEG-PS format"),
sizeof(MpegDemuxContext), .priv_data_size = sizeof(MpegDemuxContext),
mpegps_probe, .read_probe = mpegps_probe,
mpegps_read_header, .read_header = mpegps_read_header,
mpegps_read_packet, .read_packet = mpegps_read_packet,
NULL, .read_seek = NULL, //mpegps_read_seek,
NULL, //mpegps_read_seek, .read_timestamp = mpegps_read_dts,
mpegps_read_dts,
.flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT, .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
}; };

99
libavformat/mpegenc.c
Unescape View File

@ -1229,75 +1229,74 @@ static int mpeg_mux_end(AVFormatContext *ctx)
#if CONFIG_MPEG1SYSTEM_MUXER #if CONFIG_MPEG1SYSTEM_MUXER
AVOutputFormat ff_mpeg1system_muxer = { AVOutputFormat ff_mpeg1system_muxer = {
"mpeg", .name = "mpeg",
NULL_IF_CONFIG_SMALL("MPEG-1 System format"), .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 System format"),
"video/mpeg", .mime_type = "video/mpeg",
"mpg,mpeg", .extensions = "mpg,mpeg",
sizeof(MpegMuxContext), .priv_data_size = sizeof(MpegMuxContext),
CODEC_ID_MP2, .audio_codec = CODEC_ID_MP2,
CODEC_ID_MPEG1VIDEO, .video_codec = CODEC_ID_MPEG1VIDEO,
mpeg_mux_init, .write_header = mpeg_mux_init,
mpeg_mux_write_packet, .write_packet = mpeg_mux_write_packet,
mpeg_mux_end, .write_trailer = mpeg_mux_end,
}; };
#endif #endif
#if CONFIG_MPEG1VCD_MUXER #if CONFIG_MPEG1VCD_MUXER
AVOutputFormat ff_mpeg1vcd_muxer = { AVOutputFormat ff_mpeg1vcd_muxer = {
"vcd", .name = "vcd",
NULL_IF_CONFIG_SMALL("MPEG-1 System format (VCD)"), .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 System format (VCD)"),
"video/mpeg", .mime_type = "video/mpeg",
NULL, .priv_data_size = sizeof(MpegMuxContext),
sizeof(MpegMuxContext), .audio_codec = CODEC_ID_MP2,
CODEC_ID_MP2, .video_codec = CODEC_ID_MPEG1VIDEO,
CODEC_ID_MPEG1VIDEO, .write_header = mpeg_mux_init,
mpeg_mux_init, .write_packet = mpeg_mux_write_packet,
mpeg_mux_write_packet, .write_trailer = mpeg_mux_end,
mpeg_mux_end,
}; };
#endif #endif
#if CONFIG_MPEG2VOB_MUXER #if CONFIG_MPEG2VOB_MUXER
AVOutputFormat ff_mpeg2vob_muxer = { AVOutputFormat ff_mpeg2vob_muxer = {
"vob", .name = "vob",
NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"), .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
"video/mpeg", .mime_type = "video/mpeg",
"vob", .extensions = "vob",
sizeof(MpegMuxContext), .priv_data_size = sizeof(MpegMuxContext),
CODEC_ID_MP2, .audio_codec = CODEC_ID_MP2,
CODEC_ID_MPEG2VIDEO, .video_codec = CODEC_ID_MPEG2VIDEO,
mpeg_mux_init, .write_header = mpeg_mux_init,
mpeg_mux_write_packet, .write_packet = mpeg_mux_write_packet,
mpeg_mux_end, .write_trailer = mpeg_mux_end,
}; };
#endif #endif
/* Same as mpeg2vob_mux except that the pack size is 2324 */ /* Same as mpeg2vob_mux except that the pack size is 2324 */
#if CONFIG_MPEG2SVCD_MUXER #if CONFIG_MPEG2SVCD_MUXER
AVOutputFormat ff_mpeg2svcd_muxer = { AVOutputFormat ff_mpeg2svcd_muxer = {
"svcd", .name = "svcd",
NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"), .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
"video/mpeg", .mime_type = "video/mpeg",
"vob", .extensions = "vob",
sizeof(MpegMuxContext), .priv_data_size = sizeof(MpegMuxContext),
CODEC_ID_MP2, .audio_codec = CODEC_ID_MP2,
CODEC_ID_MPEG2VIDEO, .video_codec = CODEC_ID_MPEG2VIDEO,
mpeg_mux_init, .write_header = mpeg_mux_init,
mpeg_mux_write_packet, .write_packet = mpeg_mux_write_packet,
mpeg_mux_end, .write_trailer = mpeg_mux_end,
}; };
#endif #endif
/* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */ /* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
#if CONFIG_MPEG2DVD_MUXER #if CONFIG_MPEG2DVD_MUXER
AVOutputFormat ff_mpeg2dvd_muxer = { AVOutputFormat ff_mpeg2dvd_muxer = {
"dvd", .name = "dvd",
NULL_IF_CONFIG_SMALL("MPEG-2 PS format (DVD VOB)"), .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS format (DVD VOB)"),
"video/mpeg", .mime_type = "video/mpeg",
"dvd", .extensions = "dvd",
sizeof(MpegMuxContext), .priv_data_size = sizeof(MpegMuxContext),
CODEC_ID_MP2, .audio_codec = CODEC_ID_MP2,
CODEC_ID_MPEG2VIDEO, .video_codec = CODEC_ID_MPEG2VIDEO,
mpeg_mux_init, .write_header = mpeg_mux_init,
mpeg_mux_write_packet, .write_packet = mpeg_mux_write_packet,
mpeg_mux_end, .write_trailer = mpeg_mux_end,
}; };
#endif #endif

35
libavformat/mpegts.c
Unescape View File

@ -1864,15 +1864,15 @@ void ff_mpegts_parse_close(MpegTSContext *ts)
} }
AVInputFormat ff_mpegts_demuxer = { AVInputFormat ff_mpegts_demuxer = {
"mpegts", .name = "mpegts",
NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"), .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
sizeof(MpegTSContext), .priv_data_size = sizeof(MpegTSContext),
mpegts_probe, .read_probe = mpegts_probe,
mpegts_read_header, .read_header = mpegts_read_header,
mpegts_read_packet, .read_packet = mpegts_read_packet,
mpegts_read_close, .read_close = mpegts_read_close,
read_seek, .read_seek = read_seek,
mpegts_get_pcr, .read_timestamp = mpegts_get_pcr,
.flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT, .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
#ifdef USE_SYNCPOINT_SEARCH #ifdef USE_SYNCPOINT_SEARCH
.read_seek2 = read_seek2, .read_seek2 = read_seek2,
@ -1880,15 +1880,14 @@ AVInputFormat ff_mpegts_demuxer = {
}; };
AVInputFormat ff_mpegtsraw_demuxer = { AVInputFormat ff_mpegtsraw_demuxer = {
"mpegtsraw", .name = "mpegtsraw",
NULL_IF_CONFIG_SMALL("MPEG-2 raw transport stream format"), .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 raw transport stream format"),
sizeof(MpegTSContext), .priv_data_size = sizeof(MpegTSContext),
NULL, .read_header = mpegts_read_header,
mpegts_read_header, .read_packet = mpegts_raw_read_packet,
mpegts_raw_read_packet, .read_close = mpegts_read_close,
mpegts_read_close, .read_seek = read_seek,
read_seek, .read_timestamp = mpegts_get_pcr,
mpegts_get_pcr,
.flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT, .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
#ifdef USE_SYNCPOINT_SEARCH #ifdef USE_SYNCPOINT_SEARCH
.read_seek2 = read_seek2, .read_seek2 = read_seek2,

20
libavformat/mpegtsenc.c
Unescape View File

@ -1051,15 +1051,15 @@ static int mpegts_write_end(AVFormatContext *s)
} }
AVOutputFormat ff_mpegts_muxer = { AVOutputFormat ff_mpegts_muxer = {
"mpegts", .name = "mpegts",
NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"), .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
"video/x-mpegts", .mime_type = "video/x-mpegts",
"ts,m2t", .extensions = "ts,m2t",
sizeof(MpegTSWrite), .priv_data_size = sizeof(MpegTSWrite),
CODEC_ID_MP2, .audio_codec = CODEC_ID_MP2,
CODEC_ID_MPEG2VIDEO, .video_codec = CODEC_ID_MPEG2VIDEO,
mpegts_write_header, .write_header = mpegts_write_header,
mpegts_write_packet, .write_packet = mpegts_write_packet,
mpegts_write_end, .write_trailer = mpegts_write_end,
.priv_class = &mpegts_muxer_class, .priv_class = &mpegts_muxer_class,
}; };

19
libavformat/mpjpeg.c
Unescape View File

@ -54,14 +54,13 @@ static int mpjpeg_write_trailer(AVFormatContext *s)
} }
AVOutputFormat ff_mpjpeg_muxer = { AVOutputFormat ff_mpjpeg_muxer = {
"mpjpeg", .name = "mpjpeg",
NULL_IF_CONFIG_SMALL("MIME multipart JPEG format"), .long_name = NULL_IF_CONFIG_SMALL("MIME multipart JPEG format"),
"multipart/x-mixed-replace;boundary=" BOUNDARY_TAG, .mime_type = "multipart/x-mixed-replace;boundary=" BOUNDARY_TAG,
"mjpg", .extensions = "mjpg",
0, .audio_codec = CODEC_ID_NONE,
CODEC_ID_NONE, .video_codec = CODEC_ID_MJPEG,
CODEC_ID_MJPEG, .write_header = mpjpeg_write_header,
mpjpeg_write_header, .write_packet = mpjpeg_write_packet,
mpjpeg_write_packet, .write_trailer = mpjpeg_write_trailer,
mpjpeg_write_trailer,
}; };

11
libavformat/msnwc_tcp.c
Unescape View File

@ -131,10 +131,9 @@ static int msnwc_tcp_read_packet(AVFormatContext *ctx, AVPacket *pkt)
} }
AVInputFormat ff_msnwc_tcp_demuxer = { AVInputFormat ff_msnwc_tcp_demuxer = {
"msnwctcp", .name = "msnwctcp",
NULL_IF_CONFIG_SMALL("MSN TCP Webcam stream"), .long_name = NULL_IF_CONFIG_SMALL("MSN TCP Webcam stream"),
0, .read_probe = msnwc_tcp_probe,
msnwc_tcp_probe, .read_header = msnwc_tcp_read_header,
msnwc_tcp_read_header, .read_packet = msnwc_tcp_read_packet,
msnwc_tcp_read_packet,
}; };

12
libavformat/mtv.c
Unescape View File

@ -197,10 +197,10 @@ static int mtv_read_packet(AVFormatContext *s, AVPacket *pkt)
} }
AVInputFormat ff_mtv_demuxer = { AVInputFormat ff_mtv_demuxer = {
"MTV", .name = "MTV",
NULL_IF_CONFIG_SMALL("MTV format"), .long_name = NULL_IF_CONFIG_SMALL("MTV format"),
sizeof(MTVDemuxContext), .priv_data_size = sizeof(MTVDemuxContext),
mtv_probe, .read_probe = mtv_probe,
mtv_read_header, .read_header = mtv_read_header,
mtv_read_packet, .read_packet = mtv_read_packet,
}; };

11
libavformat/mvi.c
Unescape View File

@ -124,11 +124,10 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
} }
AVInputFormat ff_mvi_demuxer = { AVInputFormat ff_mvi_demuxer = {
"mvi", .name = "mvi",
NULL_IF_CONFIG_SMALL("Motion Pixels MVI format"), .long_name = NULL_IF_CONFIG_SMALL("Motion Pixels MVI format"),
sizeof(MviDemuxContext), .priv_data_size = sizeof(MviDemuxContext),
NULL, .read_header = read_header,
read_header, .read_packet = read_packet,
read_packet,
.extensions = "mvi" .extensions = "mvi"
}; };

16
libavformat/mxfdec.c
Unescape View File

@ -1016,12 +1016,12 @@ static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_ti
} }
AVInputFormat ff_mxf_demuxer = { AVInputFormat ff_mxf_demuxer = {
"mxf", .name = "mxf",
NULL_IF_CONFIG_SMALL("Material eXchange Format"), .long_name = NULL_IF_CONFIG_SMALL("Material eXchange Format"),
sizeof(MXFContext), .priv_data_size = sizeof(MXFContext),
mxf_probe, .read_probe = mxf_probe,
mxf_read_header, .read_header = mxf_read_header,
mxf_read_packet, .read_packet = mxf_read_packet,
mxf_read_close, .read_close = mxf_read_close,
mxf_read_seek, .read_seek = mxf_read_seek,
}; };

49
libavformat/mxfenc.c
Unescape View File

@ -1890,33 +1890,30 @@ static int mxf_interleave(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int
} }
AVOutputFormat ff_mxf_muxer = { AVOutputFormat ff_mxf_muxer = {
"mxf", .name = "mxf",
NULL_IF_CONFIG_SMALL("Material eXchange Format"), .long_name = NULL_IF_CONFIG_SMALL("Material eXchange Format"),
"application/mxf", .mime_type = "application/mxf",
"mxf", .extensions = "mxf",
sizeof(MXFContext), .priv_data_size = sizeof(MXFContext),
CODEC_ID_PCM_S16LE, .audio_codec = CODEC_ID_PCM_S16LE,
CODEC_ID_MPEG2VIDEO, .video_codec = CODEC_ID_MPEG2VIDEO,
mxf_write_header, .write_header = mxf_write_header,
mxf_write_packet, .write_packet = mxf_write_packet,
mxf_write_footer, .write_trailer = mxf_write_footer,
AVFMT_NOTIMESTAMPS, .flags = AVFMT_NOTIMESTAMPS,
NULL, .interleave_packet = mxf_interleave,
mxf_interleave,
}; };
AVOutputFormat ff_mxf_d10_muxer = { AVOutputFormat ff_mxf_d10_muxer = {
"mxf_d10", .name = "mxf_d10",
NULL_IF_CONFIG_SMALL("Material eXchange Format, D-10 Mapping"), .long_name = NULL_IF_CONFIG_SMALL("Material eXchange Format, D-10 Mapping"),
"application/mxf", .mime_type = "application/mxf",
NULL, .priv_data_size = sizeof(MXFContext),
sizeof(MXFContext), .audio_codec = CODEC_ID_PCM_S16LE,
CODEC_ID_PCM_S16LE, .video_codec = CODEC_ID_MPEG2VIDEO,
CODEC_ID_MPEG2VIDEO, .write_header = mxf_write_header,
mxf_write_header, .write_packet = mxf_write_packet,
mxf_write_packet, .write_trailer = mxf_write_footer,
mxf_write_footer, .flags = AVFMT_NOTIMESTAMPS,
AVFMT_NOTIMESTAMPS, .interleave_packet = mxf_interleave,
NULL,
mxf_interleave,
}; };

11
libavformat/ncdec.c
Unescape View File

@ -91,11 +91,10 @@ static int nc_read_packet(AVFormatContext *s, AVPacket *pkt)
} }
AVInputFormat ff_nc_demuxer = { AVInputFormat ff_nc_demuxer = {
"nc", .name = "nc",
NULL_IF_CONFIG_SMALL("NC camera feed format"), .long_name = NULL_IF_CONFIG_SMALL("NC camera feed format"),
0, .read_probe = nc_probe,
nc_probe, .read_header = nc_read_header,
nc_read_header, .read_packet = nc_read_packet,
nc_read_packet,
.extensions = "v", .extensions = "v",
}; };

16
libavformat/nsvdec.c
Unescape View File

@ -776,12 +776,12 @@ static int nsv_probe(AVProbeData *p)
} }
AVInputFormat ff_nsv_demuxer = { AVInputFormat ff_nsv_demuxer = {
"nsv", .name = "nsv",
NULL_IF_CONFIG_SMALL("Nullsoft Streaming Video"), .long_name = NULL_IF_CONFIG_SMALL("Nullsoft Streaming Video"),
sizeof(NSVContext), .priv_data_size = sizeof(NSVContext),
nsv_probe, .read_probe = nsv_probe,
nsv_read_header, .read_header = nsv_read_header,
nsv_read_packet, .read_packet = nsv_read_packet,
nsv_read_close, .read_close = nsv_read_close,
nsv_read_seek, .read_seek = nsv_read_seek,
}; };

14
libavformat/nullenc.c
Unescape View File

@ -27,14 +27,10 @@ static int null_write_packet(struct AVFormatContext *s, AVPacket *pkt)
} }
AVOutputFormat ff_null_muxer = { AVOutputFormat ff_null_muxer = {
"null", .name = "null",
NULL_IF_CONFIG_SMALL("raw null video format"), .long_name = NULL_IF_CONFIG_SMALL("raw null video format"),
NULL, .audio_codec = AV_NE(CODEC_ID_PCM_S16BE, CODEC_ID_PCM_S16LE),
NULL, .video_codec = CODEC_ID_RAWVIDEO,
0, .write_packet = null_write_packet,
AV_NE(CODEC_ID_PCM_S16BE, CODEC_ID_PCM_S16LE),
CODEC_ID_RAWVIDEO,
NULL,
null_write_packet,
.flags = AVFMT_NOFILE | AVFMT_RAWPICTURE | AVFMT_NOTIMESTAMPS, .flags = AVFMT_NOFILE | AVFMT_RAWPICTURE | AVFMT_NOTIMESTAMPS,
}; };

16
libavformat/nutdec.c
Unescape View File

@ -924,14 +924,14 @@ static int nut_read_close(AVFormatContext *s)
#if CONFIG_NUT_DEMUXER #if CONFIG_NUT_DEMUXER
AVInputFormat ff_nut_demuxer = { AVInputFormat ff_nut_demuxer = {
"nut", .name = "nut",
NULL_IF_CONFIG_SMALL("NUT format"), .long_name = NULL_IF_CONFIG_SMALL("NUT format"),
sizeof(NUTContext), .priv_data_size = sizeof(NUTContext),
nut_probe, .read_probe = nut_probe,
nut_read_header, .read_header = nut_read_header,
nut_read_packet, .read_packet = nut_read_packet,
nut_read_close, .read_close = nut_read_close,
read_seek, .read_seek = read_seek,
.extensions = "nut", .extensions = "nut",
.codec_tag = (const AVCodecTag * const []) { ff_codec_bmp_tags, ff_nut_video_tags, ff_codec_wav_tags, ff_nut_subtitle_tags, 0 }, .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
Unescape View File

@ -861,22 +861,22 @@ static int write_trailer(AVFormatContext *s){
} }
AVOutputFormat ff_nut_muxer = { AVOutputFormat ff_nut_muxer = {
"nut", .name = "nut",
NULL_IF_CONFIG_SMALL("NUT format"), .long_name = NULL_IF_CONFIG_SMALL("NUT format"),
"video/x-nut", .mime_type = "video/x-nut",
"nut", .extensions = "nut",
sizeof(NUTContext), .priv_data_size = sizeof(NUTContext),
#if CONFIG_LIBVORBIS #if CONFIG_LIBVORBIS
CODEC_ID_VORBIS, .audio_codec = CODEC_ID_VORBIS,
#elif CONFIG_LIBMP3LAME #elif CONFIG_LIBMP3LAME
CODEC_ID_MP3, .audio_codec = CODEC_ID_MP3,
#else #else
CODEC_ID_MP2, .audio_codec = CODEC_ID_MP2,
#endif #endif
CODEC_ID_MPEG4, .video_codec = CODEC_ID_MPEG4,
write_header, .write_header = write_header,
write_packet, .write_packet = write_packet,
write_trailer, .write_trailer = write_trailer,
.flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS, .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 }, .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
Unescape View File

@ -259,13 +259,11 @@ static int nuv_packet(AVFormatContext *s, AVPacket *pkt) {
} }
AVInputFormat ff_nuv_demuxer = { AVInputFormat ff_nuv_demuxer = {
"nuv", .name = "nuv",
NULL_IF_CONFIG_SMALL("NuppelVideo format"), .long_name = NULL_IF_CONFIG_SMALL("NuppelVideo format"),
sizeof(NUVContext), .priv_data_size = sizeof(NUVContext),
nuv_probe, .read_probe = nuv_probe,
nuv_header, .read_header = nuv_header,
nuv_packet, .read_packet = nuv_packet,
NULL,
NULL,
.flags = AVFMT_GENERIC_INDEX, .flags = AVFMT_GENERIC_INDEX,
}; };

20
libavformat/oggenc.c
Unescape View File

@ -505,14 +505,14 @@ static int ogg_write_trailer(AVFormatContext *s)
} }
AVOutputFormat ff_ogg_muxer = { AVOutputFormat ff_ogg_muxer = {
"ogg", .name = "ogg",
NULL_IF_CONFIG_SMALL("Ogg"), .long_name = NULL_IF_CONFIG_SMALL("Ogg"),
"application/ogg", .mime_type = "application/ogg",
"ogg,ogv,spx", .extensions = "ogg,ogv,spx",
sizeof(OGGContext), .priv_data_size = sizeof(OGGContext),
CODEC_ID_FLAC, .audio_codec = CODEC_ID_FLAC,
CODEC_ID_THEORA, .video_codec = CODEC_ID_THEORA,
ogg_write_header, .write_header = ogg_write_header,
ogg_write_packet, .write_packet = ogg_write_packet,
ogg_write_trailer, .write_trailer = ogg_write_trailer,
}; };

14
libavformat/oma.c
Unescape View File

@ -192,14 +192,12 @@ static int oma_read_probe(AVProbeData *p)
AVInputFormat ff_oma_demuxer = { AVInputFormat ff_oma_demuxer = {
"oma", .name = "oma",
NULL_IF_CONFIG_SMALL("Sony OpenMG audio"), .long_name = NULL_IF_CONFIG_SMALL("Sony OpenMG audio"),
0, .read_probe = oma_read_probe,
oma_read_probe, .read_header = oma_read_header,
oma_read_header, .read_packet = oma_read_packet,
oma_read_packet, .read_seek = pcm_read_seek,
0,
pcm_read_seek,
.flags= AVFMT_GENERIC_INDEX, .flags= AVFMT_GENERIC_INDEX,
.extensions = "oma,aa3", .extensions = "oma,aa3",
.codec_tag= (const AVCodecTag* const []){codec_oma_tags, 0}, .codec_tag= (const AVCodecTag* const []){codec_oma_tags, 0},

14
libavformat/psxstr.c
Unescape View File

@ -258,11 +258,11 @@ static int str_read_close(AVFormatContext *s)
} }
AVInputFormat ff_str_demuxer = { AVInputFormat ff_str_demuxer = {
"psxstr", .name = "psxstr",
NULL_IF_CONFIG_SMALL("Sony Playstation STR format"), .long_name = NULL_IF_CONFIG_SMALL("Sony Playstation STR format"),
sizeof(StrDemuxContext), .priv_data_size = sizeof(StrDemuxContext),
str_probe, .read_probe = str_probe,
str_read_header, .read_header = str_read_header,
str_read_packet, .read_packet = str_read_packet,
str_read_close, .read_close = str_read_close,
}; };

12
libavformat/pva.c
Unescape View File

@ -201,11 +201,11 @@ static int64_t pva_read_timestamp(struct AVFormatContext *s, int stream_index,
} }
AVInputFormat ff_pva_demuxer = { AVInputFormat ff_pva_demuxer = {
"pva", .name = "pva",
NULL_IF_CONFIG_SMALL("TechnoTrend PVA file and stream format"), .long_name = NULL_IF_CONFIG_SMALL("TechnoTrend PVA file and stream format"),
sizeof(PVAContext), .priv_data_size = sizeof(PVAContext),
pva_probe, .read_probe = pva_probe,
pva_read_header, .read_header = pva_read_header,
pva_read_packet, .read_packet = pva_read_packet,
.read_timestamp = pva_read_timestamp .read_timestamp = pva_read_timestamp
}; };

16
libavformat/r3d.c
Unescape View File

@ -384,12 +384,12 @@ static int r3d_close(AVFormatContext *s)
} }
AVInputFormat ff_r3d_demuxer = { AVInputFormat ff_r3d_demuxer = {
"r3d", .name = "r3d",
NULL_IF_CONFIG_SMALL("REDCODE R3D format"), .long_name = NULL_IF_CONFIG_SMALL("REDCODE R3D format"),
sizeof(R3DContext), .priv_data_size = sizeof(R3DContext),
r3d_probe, .read_probe = r3d_probe,
r3d_read_header, .read_header = r3d_read_header,
r3d_read_packet, .read_packet = r3d_read_packet,
r3d_close, .read_close = r3d_close,
r3d_seek, .read_seek = r3d_seek,
}; };

51
libavformat/rawdec.c
Unescape View File

@ -217,12 +217,11 @@ const AVClass ff_rawvideo_demuxer_class = {
#if CONFIG_G722_DEMUXER #if CONFIG_G722_DEMUXER
AVInputFormat ff_g722_demuxer = { AVInputFormat ff_g722_demuxer = {
"g722", .name = "g722",
NULL_IF_CONFIG_SMALL("raw G.722"), .long_name = NULL_IF_CONFIG_SMALL("raw G.722"),
sizeof(RawAudioDemuxerContext), .priv_data_size = sizeof(RawAudioDemuxerContext),
NULL, .read_header = ff_raw_read_header,
ff_raw_read_header, .read_packet = ff_raw_read_partial_packet,
ff_raw_read_partial_packet,
.flags= AVFMT_GENERIC_INDEX, .flags= AVFMT_GENERIC_INDEX,
.extensions = "g722,722", .extensions = "g722,722",
.value = CODEC_ID_ADPCM_G722, .value = CODEC_ID_ADPCM_G722,
@ -232,12 +231,10 @@ AVInputFormat ff_g722_demuxer = {
#if CONFIG_GSM_DEMUXER #if CONFIG_GSM_DEMUXER
AVInputFormat ff_gsm_demuxer = { AVInputFormat ff_gsm_demuxer = {
"gsm", .name = "gsm",
NULL_IF_CONFIG_SMALL("raw GSM"), .long_name = NULL_IF_CONFIG_SMALL("raw GSM"),
0, .read_header = ff_raw_audio_read_header,
NULL, .read_packet = ff_raw_read_partial_packet,
ff_raw_audio_read_header,
ff_raw_read_partial_packet,
.flags= AVFMT_GENERIC_INDEX, .flags= AVFMT_GENERIC_INDEX,
.extensions = "gsm", .extensions = "gsm",
.value = CODEC_ID_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 #if CONFIG_MLP_DEMUXER
AVInputFormat ff_mlp_demuxer = { AVInputFormat ff_mlp_demuxer = {
"mlp", .name = "mlp",
NULL_IF_CONFIG_SMALL("raw MLP"), .long_name = NULL_IF_CONFIG_SMALL("raw MLP"),
0, .read_header = ff_raw_audio_read_header,
NULL, .read_packet = ff_raw_read_partial_packet,
ff_raw_audio_read_header,
ff_raw_read_partial_packet,
.flags= AVFMT_GENERIC_INDEX, .flags= AVFMT_GENERIC_INDEX,
.extensions = "mlp", .extensions = "mlp",
.value = CODEC_ID_MLP, .value = CODEC_ID_MLP,
@ -264,12 +259,10 @@ AVInputFormat ff_mlp_demuxer = {
#if CONFIG_TRUEHD_DEMUXER #if CONFIG_TRUEHD_DEMUXER
AVInputFormat ff_truehd_demuxer = { AVInputFormat ff_truehd_demuxer = {
"truehd", .name = "truehd",
NULL_IF_CONFIG_SMALL("raw TrueHD"), .long_name = NULL_IF_CONFIG_SMALL("raw TrueHD"),
0, .read_header = ff_raw_audio_read_header,
NULL, .read_packet = ff_raw_read_partial_packet,
ff_raw_audio_read_header,
ff_raw_read_partial_packet,
.flags= AVFMT_GENERIC_INDEX, .flags= AVFMT_GENERIC_INDEX,
.extensions = "thd", .extensions = "thd",
.value = CODEC_ID_TRUEHD, .value = CODEC_ID_TRUEHD,
@ -278,12 +271,10 @@ AVInputFormat ff_truehd_demuxer = {
#if CONFIG_SHORTEN_DEMUXER #if CONFIG_SHORTEN_DEMUXER
AVInputFormat ff_shorten_demuxer = { AVInputFormat ff_shorten_demuxer = {
"shn", .name = "shn",
NULL_IF_CONFIG_SMALL("raw Shorten"), .long_name = NULL_IF_CONFIG_SMALL("raw Shorten"),
0, .read_header = ff_raw_audio_read_header,
NULL, .read_packet = ff_raw_read_partial_packet,
ff_raw_audio_read_header,
ff_raw_read_partial_packet,
.flags= AVFMT_GENERIC_INDEX, .flags= AVFMT_GENERIC_INDEX,
.extensions = "shn", .extensions = "shn",
.value = CODEC_ID_SHORTEN, .value = CODEC_ID_SHORTEN,

263
libavformat/rawenc.c
Unescape View File

@ -34,195 +34,163 @@ int ff_raw_write_packet(AVFormatContext *s, AVPacket *pkt)
#if CONFIG_AC3_MUXER #if CONFIG_AC3_MUXER
AVOutputFormat ff_ac3_muxer = { AVOutputFormat ff_ac3_muxer = {
"ac3", .name = "ac3",
NULL_IF_CONFIG_SMALL("raw AC-3"), .long_name = NULL_IF_CONFIG_SMALL("raw AC-3"),
"audio/x-ac3", .mime_type = "audio/x-ac3",
"ac3", .extensions = "ac3",
0, .audio_codec = CODEC_ID_AC3,
CODEC_ID_AC3, .video_codec = CODEC_ID_NONE,
CODEC_ID_NONE, .write_packet = ff_raw_write_packet,
NULL,
ff_raw_write_packet,
.flags= AVFMT_NOTIMESTAMPS, .flags= AVFMT_NOTIMESTAMPS,
}; };
#endif #endif
#if CONFIG_DIRAC_MUXER #if CONFIG_DIRAC_MUXER
AVOutputFormat ff_dirac_muxer = { AVOutputFormat ff_dirac_muxer = {
"dirac", .name = "dirac",
NULL_IF_CONFIG_SMALL("raw Dirac"), .long_name = NULL_IF_CONFIG_SMALL("raw Dirac"),
NULL, .extensions = "drc",
"drc", .audio_codec = CODEC_ID_NONE,
0, .video_codec = CODEC_ID_DIRAC,
CODEC_ID_NONE, .write_packet = ff_raw_write_packet,
CODEC_ID_DIRAC,
NULL,
ff_raw_write_packet,
.flags= AVFMT_NOTIMESTAMPS, .flags= AVFMT_NOTIMESTAMPS,
}; };
#endif #endif
#if CONFIG_DNXHD_MUXER #if CONFIG_DNXHD_MUXER
AVOutputFormat ff_dnxhd_muxer = { AVOutputFormat ff_dnxhd_muxer = {
"dnxhd", .name = "dnxhd",
NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"), .long_name = NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),
NULL, .extensions = "dnxhd",
"dnxhd", .audio_codec = CODEC_ID_NONE,
0, .video_codec = CODEC_ID_DNXHD,
CODEC_ID_NONE, .write_packet = ff_raw_write_packet,
CODEC_ID_DNXHD,
NULL,
ff_raw_write_packet,
.flags= AVFMT_NOTIMESTAMPS, .flags= AVFMT_NOTIMESTAMPS,
}; };
#endif #endif
#if CONFIG_DTS_MUXER #if CONFIG_DTS_MUXER
AVOutputFormat ff_dts_muxer = { AVOutputFormat ff_dts_muxer = {
"dts", .name = "dts",
NULL_IF_CONFIG_SMALL("raw DTS"), .long_name = NULL_IF_CONFIG_SMALL("raw DTS"),
"audio/x-dca", .mime_type = "audio/x-dca",
"dts", .extensions = "dts",
0, .audio_codec = CODEC_ID_DTS,
CODEC_ID_DTS, .video_codec = CODEC_ID_NONE,
CODEC_ID_NONE, .write_packet = ff_raw_write_packet,
NULL,
ff_raw_write_packet,
.flags= AVFMT_NOTIMESTAMPS, .flags= AVFMT_NOTIMESTAMPS,
}; };
#endif #endif
#if CONFIG_EAC3_MUXER #if CONFIG_EAC3_MUXER
AVOutputFormat ff_eac3_muxer = { AVOutputFormat ff_eac3_muxer = {
"eac3", .name = "eac3",
NULL_IF_CONFIG_SMALL("raw E-AC-3"), .long_name = NULL_IF_CONFIG_SMALL("raw E-AC-3"),
"audio/x-eac3", .mime_type = "audio/x-eac3",
"eac3", .extensions = "eac3",
0, .audio_codec = CODEC_ID_EAC3,
CODEC_ID_EAC3, .video_codec = CODEC_ID_NONE,
CODEC_ID_NONE, .write_packet = ff_raw_write_packet,
NULL,
ff_raw_write_packet,
.flags= AVFMT_NOTIMESTAMPS, .flags= AVFMT_NOTIMESTAMPS,
}; };
#endif #endif
#if CONFIG_G722_MUXER #if CONFIG_G722_MUXER
AVOutputFormat ff_g722_muxer = { AVOutputFormat ff_g722_muxer = {
"g722", .name = "g722",
NULL_IF_CONFIG_SMALL("raw G.722"), .long_name = NULL_IF_CONFIG_SMALL("raw G.722"),
"audio/G722", .mime_type = "audio/G722",
"g722", .extensions = "g722",
0, .audio_codec = CODEC_ID_ADPCM_G722,
CODEC_ID_ADPCM_G722, .video_codec = CODEC_ID_NONE,
CODEC_ID_NONE, .write_packet = ff_raw_write_packet,
NULL,
ff_raw_write_packet,
.flags= AVFMT_NOTIMESTAMPS, .flags= AVFMT_NOTIMESTAMPS,
}; };
#endif #endif
#if CONFIG_H261_MUXER #if CONFIG_H261_MUXER
AVOutputFormat ff_h261_muxer = { AVOutputFormat ff_h261_muxer = {
"h261", .name = "h261",
NULL_IF_CONFIG_SMALL("raw H.261"), .long_name = NULL_IF_CONFIG_SMALL("raw H.261"),
"video/x-h261", .mime_type = "video/x-h261",
"h261", .extensions = "h261",
0, .audio_codec = CODEC_ID_NONE,
CODEC_ID_NONE, .video_codec = CODEC_ID_H261,
CODEC_ID_H261, .write_packet = ff_raw_write_packet,
NULL,
ff_raw_write_packet,
.flags= AVFMT_NOTIMESTAMPS, .flags= AVFMT_NOTIMESTAMPS,
}; };
#endif #endif
#if CONFIG_H263_MUXER #if CONFIG_H263_MUXER
AVOutputFormat ff_h263_muxer = { AVOutputFormat ff_h263_muxer = {
"h263", .name = "h263",
NULL_IF_CONFIG_SMALL("raw H.263"), .long_name = NULL_IF_CONFIG_SMALL("raw H.263"),
"video/x-h263", .mime_type = "video/x-h263",
"h263", .extensions = "h263",
0, .audio_codec = CODEC_ID_NONE,
CODEC_ID_NONE, .video_codec = CODEC_ID_H263,
CODEC_ID_H263, .write_packet = ff_raw_write_packet,
NULL,
ff_raw_write_packet,
.flags= AVFMT_NOTIMESTAMPS, .flags= AVFMT_NOTIMESTAMPS,
}; };
#endif #endif
#if CONFIG_H264_MUXER #if CONFIG_H264_MUXER
AVOutputFormat ff_h264_muxer = { AVOutputFormat ff_h264_muxer = {
"h264", .name = "h264",
NULL_IF_CONFIG_SMALL("raw H.264 video format"), .long_name = NULL_IF_CONFIG_SMALL("raw H.264 video format"),
NULL, .extensions = "h264",
"h264", .audio_codec = CODEC_ID_NONE,
0, .video_codec = CODEC_ID_H264,
CODEC_ID_NONE, .write_packet = ff_raw_write_packet,
CODEC_ID_H264,
NULL,
ff_raw_write_packet,
.flags= AVFMT_NOTIMESTAMPS, .flags= AVFMT_NOTIMESTAMPS,
}; };
#endif #endif
#if CONFIG_CAVSVIDEO_MUXER #if CONFIG_CAVSVIDEO_MUXER
AVOutputFormat ff_cavsvideo_muxer = { AVOutputFormat ff_cavsvideo_muxer = {
"cavsvideo", .name = "cavsvideo",
NULL_IF_CONFIG_SMALL("raw Chinese AVS video"), .long_name = NULL_IF_CONFIG_SMALL("raw Chinese AVS video"),
NULL, .extensions = "cavs",
"cavs", .audio_codec = CODEC_ID_NONE,
0, .video_codec = CODEC_ID_CAVS,
CODEC_ID_NONE, .write_packet = ff_raw_write_packet,
CODEC_ID_CAVS,
NULL,
ff_raw_write_packet,
.flags= AVFMT_NOTIMESTAMPS, .flags= AVFMT_NOTIMESTAMPS,
}; };
#endif #endif
#if CONFIG_M4V_MUXER #if CONFIG_M4V_MUXER
AVOutputFormat ff_m4v_muxer = { AVOutputFormat ff_m4v_muxer = {
"m4v", .name = "m4v",
NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"), .long_name = NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
NULL, .extensions = "m4v",
"m4v", .audio_codec = CODEC_ID_NONE,
0, .video_codec = CODEC_ID_MPEG4,
CODEC_ID_NONE, .write_packet = ff_raw_write_packet,
CODEC_ID_MPEG4,
NULL,
ff_raw_write_packet,
.flags= AVFMT_NOTIMESTAMPS, .flags= AVFMT_NOTIMESTAMPS,
}; };
#endif #endif
#if CONFIG_MJPEG_MUXER #if CONFIG_MJPEG_MUXER
AVOutputFormat ff_mjpeg_muxer = { AVOutputFormat ff_mjpeg_muxer = {
"mjpeg", .name = "mjpeg",
NULL_IF_CONFIG_SMALL("raw MJPEG video"), .long_name = NULL_IF_CONFIG_SMALL("raw MJPEG video"),
"video/x-mjpeg", .mime_type = "video/x-mjpeg",
"mjpg,mjpeg", .extensions = "mjpg,mjpeg",
0, .audio_codec = CODEC_ID_NONE,
CODEC_ID_NONE, .video_codec = CODEC_ID_MJPEG,
CODEC_ID_MJPEG, .write_packet = ff_raw_write_packet,
NULL,
ff_raw_write_packet,
.flags= AVFMT_NOTIMESTAMPS, .flags= AVFMT_NOTIMESTAMPS,
}; };
#endif #endif
#if CONFIG_MLP_MUXER #if CONFIG_MLP_MUXER
AVOutputFormat ff_mlp_muxer = { AVOutputFormat ff_mlp_muxer = {
"mlp", .name = "mlp",
NULL_IF_CONFIG_SMALL("raw MLP"), .long_name = NULL_IF_CONFIG_SMALL("raw MLP"),
NULL, .extensions = "mlp",
"mlp", .audio_codec = CODEC_ID_MLP,
0, .video_codec = CODEC_ID_NONE,
CODEC_ID_MLP, .write_packet = ff_raw_write_packet,
CODEC_ID_NONE,
NULL,
ff_raw_write_packet,
.flags= AVFMT_NOTIMESTAMPS, .flags= AVFMT_NOTIMESTAMPS,
}; };
#endif #endif
@ -241,60 +209,49 @@ AVOutputFormat ff_srt_muxer = {
#if CONFIG_TRUEHD_MUXER #if CONFIG_TRUEHD_MUXER
AVOutputFormat ff_truehd_muxer = { AVOutputFormat ff_truehd_muxer = {
"truehd", .name = "truehd",
NULL_IF_CONFIG_SMALL("raw TrueHD"), .long_name = NULL_IF_CONFIG_SMALL("raw TrueHD"),
NULL, .extensions = "thd",
"thd", .audio_codec = CODEC_ID_TRUEHD,
0, .video_codec = CODEC_ID_NONE,
CODEC_ID_TRUEHD, .write_packet = ff_raw_write_packet,
CODEC_ID_NONE,
NULL,
ff_raw_write_packet,
.flags= AVFMT_NOTIMESTAMPS, .flags= AVFMT_NOTIMESTAMPS,
}; };
#endif #endif
#if CONFIG_MPEG1VIDEO_MUXER #if CONFIG_MPEG1VIDEO_MUXER
AVOutputFormat ff_mpeg1video_muxer = { AVOutputFormat ff_mpeg1video_muxer = {
"mpeg1video", .name = "mpeg1video",
NULL_IF_CONFIG_SMALL("raw MPEG-1 video"), .long_name = NULL_IF_CONFIG_SMALL("raw MPEG-1 video"),
"video/x-mpeg", .mime_type = "video/x-mpeg",
"mpg,mpeg,m1v", .extensions = "mpg,mpeg,m1v",
0, .audio_codec = CODEC_ID_NONE,
CODEC_ID_NONE, .video_codec = CODEC_ID_MPEG1VIDEO,
CODEC_ID_MPEG1VIDEO, .write_packet = ff_raw_write_packet,
NULL,
ff_raw_write_packet,
.flags= AVFMT_NOTIMESTAMPS, .flags= AVFMT_NOTIMESTAMPS,
}; };
#endif #endif
#if CONFIG_MPEG2VIDEO_MUXER #if CONFIG_MPEG2VIDEO_MUXER
AVOutputFormat ff_mpeg2video_muxer = { AVOutputFormat ff_mpeg2video_muxer = {
"mpeg2video", .name = "mpeg2video",
NULL_IF_CONFIG_SMALL("raw MPEG-2 video"), .long_name = NULL_IF_CONFIG_SMALL("raw MPEG-2 video"),
NULL, .extensions = "m2v",
"m2v", .audio_codec = CODEC_ID_NONE,
0, .video_codec = CODEC_ID_MPEG2VIDEO,
CODEC_ID_NONE, .write_packet = ff_raw_write_packet,
CODEC_ID_MPEG2VIDEO,
NULL,
ff_raw_write_packet,
.flags= AVFMT_NOTIMESTAMPS, .flags= AVFMT_NOTIMESTAMPS,
}; };
#endif #endif
#if CONFIG_RAWVIDEO_MUXER #if CONFIG_RAWVIDEO_MUXER
AVOutputFormat ff_rawvideo_muxer = { AVOutputFormat ff_rawvideo_muxer = {
"rawvideo", .name = "rawvideo",
NULL_IF_CONFIG_SMALL("raw video format"), .long_name = NULL_IF_CONFIG_SMALL("raw video format"),
NULL, .extensions = "yuv,rgb",
"yuv,rgb", .audio_codec = CODEC_ID_NONE,
0, .video_codec = CODEC_ID_RAWVIDEO,
CODEC_ID_NONE, .write_packet = ff_raw_write_packet,
CODEC_ID_RAWVIDEO,
NULL,
ff_raw_write_packet,
.flags= AVFMT_NOTIMESTAMPS, .flags= AVFMT_NOTIMESTAMPS,
}; };
#endif #endif

11
libavformat/rawvideodec.c
Unescape View File

@ -45,12 +45,11 @@ static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt)
} }
AVInputFormat ff_rawvideo_demuxer = { AVInputFormat ff_rawvideo_demuxer = {
"rawvideo", .name = "rawvideo",
NULL_IF_CONFIG_SMALL("raw video format"), .long_name = NULL_IF_CONFIG_SMALL("raw video format"),
sizeof(FFRawVideoDemuxerContext), .priv_data_size = sizeof(FFRawVideoDemuxerContext),
NULL, .read_header = ff_raw_read_header,
ff_raw_read_header, .read_packet = rawvideo_read_packet,
rawvideo_read_packet,
.flags= AVFMT_GENERIC_INDEX, .flags= AVFMT_GENERIC_INDEX,
.extensions = "yuv,cif,qcif,rgb", .extensions = "yuv,cif,qcif,rgb",
.value = CODEC_ID_RAWVIDEO, .value = CODEC_ID_RAWVIDEO,

15
libavformat/rl2.c
Unescape View File

@ -286,13 +286,12 @@ static int rl2_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp
} }
AVInputFormat ff_rl2_demuxer = { AVInputFormat ff_rl2_demuxer = {
"rl2", .name = "rl2",
NULL_IF_CONFIG_SMALL("RL2 format"), .long_name = NULL_IF_CONFIG_SMALL("RL2 format"),
sizeof(Rl2DemuxContext), .priv_data_size = sizeof(Rl2DemuxContext),
rl2_probe, .read_probe = rl2_probe,
rl2_read_header, .read_header = rl2_read_header,
rl2_read_packet, .read_packet = rl2_read_packet,
NULL, .read_seek = rl2_read_seek,
rl2_read_seek,
}; };

28
libavformat/rmdec.c
Unescape View File

@ -935,23 +935,19 @@ static int64_t rm_read_dts(AVFormatContext *s, int stream_index,
} }
AVInputFormat ff_rm_demuxer = { AVInputFormat ff_rm_demuxer = {
"rm", .name = "rm",
NULL_IF_CONFIG_SMALL("RealMedia format"), .long_name = NULL_IF_CONFIG_SMALL("RealMedia format"),
sizeof(RMDemuxContext), .priv_data_size = sizeof(RMDemuxContext),
rm_probe, .read_probe = rm_probe,
rm_read_header, .read_header = rm_read_header,
rm_read_packet, .read_packet = rm_read_packet,
rm_read_close, .read_close = rm_read_close,
NULL, .read_timestamp = rm_read_dts,
rm_read_dts,
}; };
AVInputFormat ff_rdt_demuxer = { AVInputFormat ff_rdt_demuxer = {
"rdt", .name = "rdt",
NULL_IF_CONFIG_SMALL("RDT demuxer"), .long_name = NULL_IF_CONFIG_SMALL("RDT demuxer"),
sizeof(RMDemuxContext), .priv_data_size = sizeof(RMDemuxContext),
NULL, .read_close = rm_read_close,
NULL,
NULL,
rm_read_close,
}; };

20
libavformat/rmenc.c
Unescape View File

@ -461,15 +461,15 @@ static int rm_write_trailer(AVFormatContext *s)
AVOutputFormat ff_rm_muxer = { AVOutputFormat ff_rm_muxer = {
"rm", .name = "rm",
NULL_IF_CONFIG_SMALL("RealMedia format"), .long_name = NULL_IF_CONFIG_SMALL("RealMedia format"),
"application/vnd.rn-realmedia", .mime_type = "application/vnd.rn-realmedia",
"rm,ra", .extensions = "rm,ra",
sizeof(RMMuxContext), .priv_data_size = sizeof(RMMuxContext),
CODEC_ID_AC3, .audio_codec = CODEC_ID_AC3,
CODEC_ID_RV10, .video_codec = CODEC_ID_RV10,
rm_write_header, .write_header = rm_write_header,
rm_write_packet, .write_packet = rm_write_packet,
rm_write_trailer, .write_trailer = rm_write_trailer,
.codec_tag= (const AVCodecTag* const []){ff_rm_codec_tags, 0}, .codec_tag= (const AVCodecTag* const []){ff_rm_codec_tags, 0},
}; };

12
libavformat/rpl.c
Unescape View File

@ -351,10 +351,10 @@ static int rpl_read_packet(AVFormatContext *s, AVPacket *pkt)
} }
AVInputFormat ff_rpl_demuxer = { AVInputFormat ff_rpl_demuxer = {
"rpl", .name = "rpl",
NULL_IF_CONFIG_SMALL("RPL/ARMovie format"), .long_name = NULL_IF_CONFIG_SMALL("RPL/ARMovie format"),
sizeof(RPLContext), .priv_data_size = sizeof(RPLContext),
rpl_probe, .read_probe = rpl_probe,
rpl_read_header, .read_header = rpl_read_header,
rpl_read_packet, .read_packet = rpl_read_packet,
}; };

18
libavformat/rtpenc.c
Unescape View File

@ -462,15 +462,13 @@ static int rtp_write_trailer(AVFormatContext *s1)
} }
AVOutputFormat ff_rtp_muxer = { AVOutputFormat ff_rtp_muxer = {
"rtp", .name = "rtp",
NULL_IF_CONFIG_SMALL("RTP output format"), .long_name = NULL_IF_CONFIG_SMALL("RTP output format"),
NULL, .priv_data_size = sizeof(RTPMuxContext),
NULL, .audio_codec = CODEC_ID_PCM_MULAW,
sizeof(RTPMuxContext), .video_codec = CODEC_ID_NONE,
CODEC_ID_PCM_MULAW, .write_header = rtp_write_header,
CODEC_ID_NONE, .write_packet = rtp_write_packet,
rtp_write_header, .write_trailer = rtp_write_trailer,
rtp_write_packet,
rtp_write_trailer,
.priv_class = &rtp_muxer_class, .priv_class = &rtp_muxer_class,
}; };

28
libavformat/rtsp.c
Unescape View File

@ -1824,13 +1824,13 @@ static int sdp_read_close(AVFormatContext *s)
} }
AVInputFormat ff_sdp_demuxer = { AVInputFormat ff_sdp_demuxer = {
"sdp", .name = "sdp",
NULL_IF_CONFIG_SMALL("SDP"), .long_name = NULL_IF_CONFIG_SMALL("SDP"),
sizeof(RTSPState), .priv_data_size = sizeof(RTSPState),
sdp_probe, .read_probe = sdp_probe,
sdp_read_header, .read_header = sdp_read_header,
ff_rtsp_fetch_packet, .read_packet = ff_rtsp_fetch_packet,
sdp_read_close, .read_close = sdp_read_close,
}; };
#endif /* CONFIG_SDP_DEMUXER */ #endif /* CONFIG_SDP_DEMUXER */
@ -1928,13 +1928,13 @@ fail:
} }
AVInputFormat ff_rtp_demuxer = { AVInputFormat ff_rtp_demuxer = {
"rtp", .name = "rtp",
NULL_IF_CONFIG_SMALL("RTP input format"), .long_name = NULL_IF_CONFIG_SMALL("RTP input format"),
sizeof(RTSPState), .priv_data_size = sizeof(RTSPState),
rtp_probe, .read_probe = rtp_probe,
rtp_read_header, .read_header = rtp_read_header,
ff_rtsp_fetch_packet, .read_packet = ff_rtsp_fetch_packet,
sdp_read_close, .read_close = sdp_read_close,
.flags = AVFMT_NOFILE, .flags = AVFMT_NOFILE,
}; };
#endif /* CONFIG_RTP_DEMUXER */ #endif /* CONFIG_RTP_DEMUXER */

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

Write Preview
Loading…
Cancel
Save