#ifdef CONFIG_OSS_DEMUXER
AVInputFormat oss_demuxer = {
"oss",
- "audio grab and output",
+ NULL_IF_CONFIG_SMALL("audio grab and output"),
sizeof(AudioData),
NULL,
audio_read_header,
#ifdef CONFIG_OSS_MUXER
AVOutputFormat oss_muxer = {
"oss",
- "audio grab and output",
+ NULL_IF_CONFIG_SMALL("audio grab and output"),
"",
"",
sizeof(AudioData),
AVInputFormat bktr_demuxer = {
"bktr",
- "video grab",
+ NULL_IF_CONFIG_SMALL("video grab"),
sizeof(VideoData),
NULL,
grab_read_header,
AVInputFormat dv1394_demuxer = {
.name = "dv1394",
- .long_name = "dv1394 A/V grab",
+ .long_name = NULL_IF_CONFIG_SMALL("DV1394 A/V grab"),
.priv_data_size = sizeof(struct dv1394_data),
.read_header = dv1394_read_header,
.read_packet = dv1394_read_packet,
AVInputFormat libdc1394_demuxer = {
.name = "libdc1394",
- .long_name = "dc1394 v.2 A/V grab",
+ .long_name = NULL_IF_CONFIG_SMALL("dc1394 v.2 A/V grab"),
.priv_data_size = sizeof(struct dc1394_data),
.read_header = dc1394_v2_read_header,
.read_packet = dc1394_v2_read_packet,
#if ENABLE_LIBDC1394_1
AVInputFormat libdc1394_demuxer = {
.name = "libdc1394",
- .long_name = "dc1394 v.1 A/V grab",
+ .long_name = NULL_IF_CONFIG_SMALL("dc1394 v.1 A/V grab"),
.priv_data_size = sizeof(struct dc1394_data),
.read_header = dc1394_v1_read_header,
.read_packet = dc1394_v1_read_packet,
AVInputFormat v4l_demuxer = {
"video4linux",
- "video grab",
+ NULL_IF_CONFIG_SMALL("video grab"),
sizeof(VideoData),
NULL,
grab_read_header,
AVInputFormat v4l2_demuxer = {
"video4linux2",
- "video grab",
+ NULL_IF_CONFIG_SMALL("video grab"),
sizeof(struct video_data),
NULL,
v4l2_read_header,
AVInputFormat vfwcap_demuxer = {
"vfwcap",
- "VFW video capture",
+ NULL_IF_CONFIG_SMALL("VFW video capture"),
sizeof(struct vfw_ctx),
NULL,
vfw_read_header,
AVInputFormat x11_grab_device_demuxer =
{
"x11grab",
- "X11grab",
+ NULL_IF_CONFIG_SMALL("X11grab"),
sizeof(x11_grab_t),
NULL,
x11grab_read_header,
AVInputFormat fourxm_demuxer = {
"4xm",
- "4X Technologies format",
+ NULL_IF_CONFIG_SMALL("4X Technologies format"),
sizeof(FourxmDemuxContext),
fourxm_probe,
fourxm_read_header,
AVOutputFormat adts_muxer = {
"adts",
- "ADTS AAC",
+ NULL_IF_CONFIG_SMALL("ADTS AAC"),
"audio/aac",
"aac",
sizeof(ADTSContext),
#ifdef CONFIG_AIFF_DEMUXER
AVInputFormat aiff_demuxer = {
"aiff",
- "Audio IFF",
+ NULL_IF_CONFIG_SMALL("Audio IFF"),
0,
aiff_probe,
aiff_read_header,
#ifdef CONFIG_AIFF_MUXER
AVOutputFormat aiff_muxer = {
"aiff",
- "Audio IFF",
+ NULL_IF_CONFIG_SMALL("Audio IFF"),
"audio/aiff",
"aif,aiff,afc,aifc",
sizeof(AIFFOutputContext),
#ifdef CONFIG_AMR_DEMUXER
AVInputFormat amr_demuxer = {
"amr",
- "3gpp amr file format",
+ NULL_IF_CONFIG_SMALL("3GPP AMR file format"),
0, /*priv_data_size*/
amr_probe,
amr_read_header,
#ifdef CONFIG_AMR_MUXER
AVOutputFormat amr_muxer = {
"amr",
- "3gpp amr file format",
+ NULL_IF_CONFIG_SMALL("3GPP AMR file format"),
"audio/amr",
"amr",
0,
AVInputFormat apc_demuxer = {
"apc",
- "CRYO APC format",
+ NULL_IF_CONFIG_SMALL("CRYO APC format"),
0,
apc_probe,
apc_read_header,
AVInputFormat ape_demuxer = {
"ape",
- "Monkey's Audio",
+ NULL_IF_CONFIG_SMALL("Monkey's Audio"),
sizeof(APEContext),
ape_probe,
ape_read_header,
#ifdef CONFIG_ASF_MUXER
AVOutputFormat asf_muxer = {
"asf",
- "asf format",
+ NULL_IF_CONFIG_SMALL("ASF format"),
"video/x-ms-asf",
"asf,wmv,wma",
sizeof(ASFContext),
#ifdef CONFIG_ASF_STREAM_MUXER
AVOutputFormat asf_stream_muxer = {
"asf_stream",
- "asf format",
+ NULL_IF_CONFIG_SMALL("ASF format"),
"video/x-ms-asf",
"asf,wmv,wma",
sizeof(ASFContext),
AVInputFormat asf_demuxer = {
"asf",
- "asf format",
+ NULL_IF_CONFIG_SMALL("ASF format"),
sizeof(ASFContext),
asf_probe,
asf_read_header,
#ifdef CONFIG_AU_DEMUXER
AVInputFormat au_demuxer = {
"au",
- "SUN AU Format",
+ NULL_IF_CONFIG_SMALL("SUN AU format"),
0,
au_probe,
au_read_header,
#ifdef CONFIG_AU_MUXER
AVOutputFormat au_muxer = {
"au",
- "SUN AU Format",
+ NULL_IF_CONFIG_SMALL("SUN AU format"),
"audio/basic",
"au",
0,
typedef struct AVOutputFormat {
const char *name;
+ /**
+ * Descriptive name for the format, meant to be more human-readable
+ * than \p name. You \e should use the NULL_IF_CONFIG_SMALL() macro
+ * to define it.
+ */
const char *long_name;
const char *mime_type;
const char *extensions; /**< comma separated filename extensions */
typedef struct AVInputFormat {
const char *name;
+ /**
+ * Descriptive name for the format, meant to be more human-readable
+ * than \p name. You \e should use the NULL_IF_CONFIG_SMALL() macro
+ * to define it.
+ */
const char *long_name;
/** size of private data so that it can be allocated in the wrapper */
int priv_data_size;
AVInputFormat avi_demuxer = {
"avi",
- "avi format",
+ NULL_IF_CONFIG_SMALL("AVI format"),
sizeof(AVIContext),
avi_probe,
avi_read_header,
AVOutputFormat avi_muxer = {
"avi",
- "avi format",
+ NULL_IF_CONFIG_SMALL("AVI format"),
"video/x-msvideo",
"avi",
sizeof(AVIContext),
AVInputFormat avisynth_demuxer = {
"avs",
- "AVISynth",
+ NULL_IF_CONFIG_SMALL("AVISynth"),
sizeof(AVISynthContext),
NULL,
avisynth_read_header,
AVInputFormat avs_demuxer = {
"avs",
- "avs format",
+ NULL_IF_CONFIG_SMALL("AVS format"),
sizeof(avs_format_t),
avs_probe,
avs_read_header,
AVInputFormat bethsoftvid_demuxer = {
"bethsoftvid",
- "Bethesda Softworks 'Daggerfall' VID format",
+ NULL_IF_CONFIG_SMALL("Bethesda Softworks VID format"),
sizeof(BVID_DemuxContext),
vid_probe,
vid_read_header,
AVInputFormat bfi_demuxer = {
"bfi",
- "Brute Force & Ignorance",
+ NULL_IF_CONFIG_SMALL("Brute Force & Ignorance"),
sizeof(BFIContext),
bfi_probe,
bfi_read_header,
AVInputFormat c93_demuxer = {
"c93",
- "Interplay C93",
+ NULL_IF_CONFIG_SMALL("Interplay C93"),
sizeof(C93DemuxContext),
probe,
read_header,
AVOutputFormat crc_muxer = {
"crc",
- "crc testing format",
+ NULL_IF_CONFIG_SMALL("CRC testing format"),
NULL,
"",
sizeof(CRCState),
AVInputFormat daud_demuxer = {
"daud",
- "D-Cinema audio format",
+ NULL_IF_CONFIG_SMALL("D-Cinema audio format"),
0,
NULL,
daud_header,
AVInputFormat dsicin_demuxer = {
"dsicin",
- "Delphine Software International CIN format",
+ NULL_IF_CONFIG_SMALL("Delphine Software International CIN format"),
sizeof(CinDemuxContext),
cin_probe,
cin_read_header,
#ifdef CONFIG_DV_DEMUXER
AVInputFormat dv_demuxer = {
"dv",
- "DV video format",
+ NULL_IF_CONFIG_SMALL("DV video format"),
sizeof(RawDVContext),
NULL,
dv_read_header,
#ifdef CONFIG_DV_MUXER
AVOutputFormat dv_muxer = {
"dv",
- "DV video format",
+ NULL_IF_CONFIG_SMALL("DV video format"),
NULL,
"dv",
sizeof(DVMuxContext),
AVInputFormat dxa_demuxer = {
"dxa",
- "dxa",
+ NULL_IF_CONFIG_SMALL("DXA"),
sizeof(DXAContext),
dxa_probe,
dxa_read_header,
AVInputFormat ea_cdata_demuxer = {
"ea_cdata",
- "Electronic Arts cdata",
+ NULL_IF_CONFIG_SMALL("Electronic Arts cdata"),
sizeof(CdataDemuxContext),
cdata_probe,
cdata_read_header,
AVInputFormat ea_demuxer = {
"ea",
- "Electronic Arts Multimedia Format",
+ NULL_IF_CONFIG_SMALL("Electronic Arts Multimedia Format"),
sizeof(EaDemuxContext),
ea_probe,
ea_read_header,
AVInputFormat ffm_demuxer = {
"ffm",
- "ffm format",
+ NULL_IF_CONFIG_SMALL("ffm format"),
sizeof(FFMContext),
ffm_probe,
ffm_read_header,
AVOutputFormat ffm_muxer = {
"ffm",
- "ffm format",
+ NULL_IF_CONFIG_SMALL("ffm format"),
"",
"ffm",
sizeof(FFMContext),
AVInputFormat flic_demuxer = {
"flic",
- "FLI/FLC/FLX animation format",
+ NULL_IF_CONFIG_SMALL("FLI/FLC/FLX animation format"),
sizeof(FlicDemuxContext),
flic_probe,
flic_read_header,
AVInputFormat flv_demuxer = {
"flv",
- "flv format",
+ NULL_IF_CONFIG_SMALL("FLV format"),
0,
flv_probe,
flv_read_header,
AVOutputFormat flv_muxer = {
"flv",
- "flv format",
+ NULL_IF_CONFIG_SMALL("FLV format"),
"video/x-flv",
"flv",
sizeof(FLVContext),
AVOutputFormat framecrc_muxer = {
"framecrc",
- "framecrc testing format",
+ NULL_IF_CONFIG_SMALL("framecrc testing format"),
NULL,
"",
0,
AVOutputFormat gif_muxer = {
"gif",
- "GIF Animation",
+ NULL_IF_CONFIG_SMALL("GIF Animation"),
"image/gif",
"gif",
sizeof(GIFContext),
AVInputFormat gif_demuxer =
{
"gif",
- "gif format",
+ NULL_IF_CONFIG_SMALL("GIF format"),
sizeof(GifState),
gif_video_probe,
gif_read_header,
AVInputFormat gxf_demuxer = {
"gxf",
- "GXF format",
+ NULL_IF_CONFIG_SMALL("GXF format"),
0,
gxf_probe,
gxf_header,
AVOutputFormat gxf_muxer = {
"gxf",
- "GXF format",
+ NULL_IF_CONFIG_SMALL("GXF format"),
NULL,
"gxf",
sizeof(GXFContext),
AVInputFormat idcin_demuxer = {
"idcin",
- "Id CIN format",
+ NULL_IF_CONFIG_SMALL("Id CIN format"),
sizeof(IdcinDemuxContext),
idcin_probe,
idcin_read_header,
AVInputFormat roq_demuxer = {
"RoQ",
- "Id RoQ format",
+ NULL_IF_CONFIG_SMALL("Id RoQ format"),
sizeof(RoqDemuxContext),
roq_probe,
roq_read_header,
AVInputFormat iff_demuxer = {
"IFF",
- "IFF format",
+ NULL_IF_CONFIG_SMALL("IFF format"),
sizeof(IffDemuxContext),
iff_probe,
iff_read_header,
#ifdef CONFIG_IMAGE2_DEMUXER
AVInputFormat image2_demuxer = {
"image2",
- "image2 sequence",
+ NULL_IF_CONFIG_SMALL("image2 sequence"),
sizeof(VideoData),
image_probe,
img_read_header,
#ifdef CONFIG_IMAGE2PIPE_DEMUXER
AVInputFormat image2pipe_demuxer = {
"image2pipe",
- "piped image2 sequence",
+ NULL_IF_CONFIG_SMALL("piped image2 sequence"),
sizeof(VideoData),
NULL, /* no probe */
img_read_header,
#ifdef CONFIG_IMAGE2_MUXER
AVOutputFormat image2_muxer = {
"image2",
- "image2 sequence",
+ NULL_IF_CONFIG_SMALL("image2 sequence"),
"",
"",
sizeof(VideoData),
#ifdef CONFIG_IMAGE2PIPE_MUXER
AVOutputFormat image2pipe_muxer = {
"image2pipe",
- "piped image2 sequence",
+ NULL_IF_CONFIG_SMALL("piped image2 sequence"),
"",
"",
sizeof(VideoData),
AVInputFormat ipmovie_demuxer = {
"ipmovie",
- "Interplay MVE format",
+ NULL_IF_CONFIG_SMALL("Interplay MVE format"),
sizeof(IPMVEContext),
ipmovie_probe,
ipmovie_read_header,
AVInputFormat libnut_demuxer = {
"libnut",
- "nut format",
+ NULL_IF_CONFIG_SMALL("NUT format"),
sizeof(NUTContext),
nut_probe,
nut_read_header,
AVInputFormat lmlm4_demuxer = {
"lmlm4",
- "lmlm4 raw format",
+ NULL_IF_CONFIG_SMALL("lmlm4 raw format"),
0,
lmlm4_probe,
lmlm4_read_header,
AVInputFormat matroska_demuxer = {
"matroska",
- "Matroska file format",
+ NULL_IF_CONFIG_SMALL("Matroska file format"),
sizeof(MatroskaDemuxContext),
matroska_probe,
matroska_read_header,
AVOutputFormat matroska_muxer = {
"matroska",
- "Matroska File Format",
+ NULL_IF_CONFIG_SMALL("Matroska file format"),
"video/x-matroska",
"mkv",
sizeof(MatroskaMuxContext),
AVOutputFormat matroska_audio_muxer = {
"matroska",
- "Matroska File Format",
+ NULL_IF_CONFIG_SMALL("Matroska file format"),
"audio/x-matroska",
"mka",
sizeof(MatroskaMuxContext),
AVInputFormat mm_demuxer = {
"mm",
- "American Laser Games MM format",
+ NULL_IF_CONFIG_SMALL("American Laser Games MM format"),
sizeof(MmDemuxContext),
mm_probe,
mm_read_header,
#ifdef CONFIG_MMF_DEMUXER
AVInputFormat mmf_demuxer = {
"mmf",
- "mmf format",
+ NULL_IF_CONFIG_SMALL("mmf format"),
sizeof(MMFContext),
mmf_probe,
mmf_read_header,
#ifdef CONFIG_MMF_MUXER
AVOutputFormat mmf_muxer = {
"mmf",
- "mmf format",
+ NULL_IF_CONFIG_SMALL("mmf format"),
"application/vnd.smaf",
"mmf",
sizeof(MMFContext),
AVInputFormat mov_demuxer = {
"mov,mp4,m4a,3gp,3g2,mj2",
- "QuickTime/MPEG4/Motion JPEG 2000 format",
+ NULL_IF_CONFIG_SMALL("QuickTime/MPEG-4/Motion JPEG 2000 format"),
sizeof(MOVContext),
mov_probe,
mov_read_header,
#ifdef CONFIG_MOV_MUXER
AVOutputFormat mov_muxer = {
"mov",
- "mov format",
+ NULL_IF_CONFIG_SMALL("MOV format"),
NULL,
"mov",
sizeof(MOVContext),
#ifdef CONFIG_TGP_MUXER
AVOutputFormat tgp_muxer = {
"3gp",
- "3gp format",
+ NULL_IF_CONFIG_SMALL("3GP format"),
NULL,
"3gp",
sizeof(MOVContext),
#ifdef CONFIG_MP4_MUXER
AVOutputFormat mp4_muxer = {
"mp4",
- "mp4 format",
+ NULL_IF_CONFIG_SMALL("MP4 format"),
"application/mp4",
"mp4,m4a",
sizeof(MOVContext),
#ifdef CONFIG_PSP_MUXER
AVOutputFormat psp_muxer = {
"psp",
- "psp mp4 format",
+ NULL_IF_CONFIG_SMALL("PSP MP4 format"),
NULL,
"mp4,psp",
sizeof(MOVContext),
#ifdef CONFIG_TG2_MUXER
AVOutputFormat tg2_muxer = {
"3g2",
- "3gp2 format",
+ NULL_IF_CONFIG_SMALL("3GP2 format"),
NULL,
"3g2",
sizeof(MOVContext),
#ifdef CONFIG_IPOD_MUXER
AVOutputFormat ipod_muxer = {
"ipod",
- "iPod H.264 mp4 format",
+ NULL_IF_CONFIG_SMALL("iPod H.264 MP4 format"),
"application/mp4",
NULL,
sizeof(MOVContext),
#ifdef CONFIG_MP3_DEMUXER
AVInputFormat mp3_demuxer = {
"mp3",
- "MPEG audio",
+ NULL_IF_CONFIG_SMALL("MPEG audio"),
0,
mp3_read_probe,
mp3_read_header,
#ifdef CONFIG_MP2_MUXER
AVOutputFormat mp2_muxer = {
"mp2",
- "MPEG audio layer 2",
+ NULL_IF_CONFIG_SMALL("MPEG audio layer 2"),
"audio/x-mpeg",
#ifdef CONFIG_LIBMP3LAME
"mp2,m2a",
#ifdef CONFIG_MP3_MUXER
AVOutputFormat mp3_muxer = {
"mp3",
- "MPEG audio layer 3",
+ NULL_IF_CONFIG_SMALL("MPEG audio layer 3"),
"audio/x-mpeg",
"mp3",
0,
AVInputFormat mpc_demuxer = {
"mpc",
- "musepack",
+ NULL_IF_CONFIG_SMALL("Musepack"),
sizeof(MPCContext),
mpc_probe,
mpc_read_header,
AVInputFormat mpc8_demuxer = {
"mpc8",
- "musepack8",
+ NULL_IF_CONFIG_SMALL("Musepack SV8"),
sizeof(MPCContext),
mpc8_probe,
mpc8_read_header,
AVInputFormat mpegps_demuxer = {
"mpeg",
- "MPEG PS format",
+ NULL_IF_CONFIG_SMALL("MPEG-PS format"),
sizeof(MpegDemuxContext),
mpegps_probe,
mpegps_read_header,
#ifdef CONFIG_MPEG1SYSTEM_MUXER
AVOutputFormat mpeg1system_muxer = {
"mpeg",
- "MPEG1 System format",
+ NULL_IF_CONFIG_SMALL("MPEG-1 System format"),
"video/mpeg",
"mpg,mpeg",
sizeof(MpegMuxContext),
#ifdef CONFIG_MPEG1VCD_MUXER
AVOutputFormat mpeg1vcd_muxer = {
"vcd",
- "MPEG1 System format (VCD)",
+ NULL_IF_CONFIG_SMALL("MPEG-1 System format (VCD)"),
"video/mpeg",
NULL,
sizeof(MpegMuxContext),
#ifdef CONFIG_MPEG2VOB_MUXER
AVOutputFormat mpeg2vob_muxer = {
"vob",
- "MPEG2 PS format (VOB)",
+ NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
"video/mpeg",
"vob",
sizeof(MpegMuxContext),
#ifdef CONFIG_MPEG2SVCD_MUXER
AVOutputFormat mpeg2svcd_muxer = {
"svcd",
- "MPEG2 PS format (VOB)",
+ NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
"video/mpeg",
"vob",
sizeof(MpegMuxContext),
#ifdef CONFIG_MPEG2DVD_MUXER
AVOutputFormat mpeg2dvd_muxer = {
"dvd",
- "MPEG2 PS format (DVD VOB)",
+ NULL_IF_CONFIG_SMALL("MPEG-2 PS format (DVD VOB)"),
"video/mpeg",
"dvd",
sizeof(MpegMuxContext),
AVInputFormat mpegts_demuxer = {
"mpegts",
- "MPEG2 transport stream format",
+ NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
sizeof(MpegTSContext),
mpegts_probe,
mpegts_read_header,
AVInputFormat mpegtsraw_demuxer = {
"mpegtsraw",
- "MPEG2 raw transport stream format",
+ NULL_IF_CONFIG_SMALL("MPEG-2 raw transport stream format"),
sizeof(MpegTSContext),
NULL,
mpegts_read_header,
AVOutputFormat mpegts_muxer = {
"mpegts",
- "MPEG2 transport stream format",
+ NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
"video/x-mpegts",
"ts,m2t",
sizeof(MpegTSWrite),
AVOutputFormat mpjpeg_muxer = {
"mpjpeg",
- "Mime multipart JPEG format",
+ NULL_IF_CONFIG_SMALL("Mime multipart JPEG format"),
"multipart/x-mixed-replace;boundary=" BOUNDARY_TAG,
"mjpg",
0,
AVInputFormat msnwc_tcp_demuxer = {
"msnwctcp",
- "MSN TCP Webcam stream",
+ NULL_IF_CONFIG_SMALL("MSN TCP Webcam stream"),
0,
msnwc_tcp_probe,
msnwc_tcp_read_header,
AVInputFormat mtv_demuxer = {
"MTV",
- "MTV format",
+ NULL_IF_CONFIG_SMALL("MTV format"),
sizeof(MTVDemuxContext),
mtv_probe,
mtv_read_header,
AVInputFormat mxf_demuxer = {
"mxf",
- "MXF format",
+ NULL_IF_CONFIG_SMALL("MXF format"),
sizeof(MXFContext),
mxf_probe,
mxf_read_header,
AVInputFormat nsv_demuxer = {
"nsv",
- "NullSoft Video format",
+ NULL_IF_CONFIG_SMALL("NullSoft Video format"),
sizeof(NSVContext),
nsv_probe,
nsv_read_header,
#ifdef CONFIG_NUT_DEMUXER
AVInputFormat nut_demuxer = {
"nut",
- "nut format",
+ NULL_IF_CONFIG_SMALL("NUT format"),
sizeof(NUTContext),
nut_probe,
nut_read_header,
AVOutputFormat nut_muxer = {
"nut",
- "nut format",
+ NULL_IF_CONFIG_SMALL("NUT format"),
"video/x-nut",
"nut",
sizeof(NUTContext),
AVInputFormat nuv_demuxer = {
"nuv",
- "NuppelVideo format",
+ NULL_IF_CONFIG_SMALL("NuppelVideo format"),
sizeof(NUVContext),
nuv_probe,
nuv_header,
AVInputFormat ogg_demuxer = {
"ogg",
- "Ogg",
+ NULL_IF_CONFIG_SMALL("Ogg"),
sizeof (ogg_t),
ogg_probe,
ogg_read_header,
AVOutputFormat ogg_muxer = {
"ogg",
- "Ogg format",
+ NULL_IF_CONFIG_SMALL("Ogg"),
"application/ogg",
"ogg",
0,
AVInputFormat str_demuxer = {
"psxstr",
- "Sony Playstation STR format",
+ NULL_IF_CONFIG_SMALL("Sony Playstation STR format"),
sizeof(StrDemuxContext),
str_probe,
str_read_header,
AVInputFormat pva_demuxer = {
"pva",
- "pva file and stream format",
+ NULL_IF_CONFIG_SMALL("TechnoTrend PVA file and stream format"),
sizeof(PVAContext),
pva_probe,
pva_read_header,
AVInputFormat shorten_demuxer = {
"shn",
- "raw shorten",
+ NULL_IF_CONFIG_SMALL("raw Shorten"),
0,
NULL,
audio_read_header,
AVInputFormat mlp_demuxer = {
"mlp",
- "raw mlp",
+ NULL_IF_CONFIG_SMALL("raw MLP"),
0,
NULL,
audio_read_header,
AVInputFormat flac_demuxer = {
"flac",
- "raw flac",
+ NULL_IF_CONFIG_SMALL("raw FLAC"),
0,
flac_probe,
audio_read_header,
#ifdef CONFIG_MUXERS
AVOutputFormat flac_muxer = {
"flac",
- "raw flac",
+ NULL_IF_CONFIG_SMALL("raw FLAC"),
"audio/x-flac",
"flac",
0,
#ifdef CONFIG_AC3_DEMUXER
AVInputFormat ac3_demuxer = {
"ac3",
- "raw ac3",
+ NULL_IF_CONFIG_SMALL("raw AC-3"),
0,
ac3_probe,
audio_read_header,
#ifdef CONFIG_MUXERS
AVOutputFormat ac3_muxer = {
"ac3",
- "raw ac3",
+ NULL_IF_CONFIG_SMALL("raw AC-3"),
"audio/x-ac3",
"ac3",
0,
AVOutputFormat dts_muxer = {
"dts",
- "raw dts",
+ NULL_IF_CONFIG_SMALL("raw DTS"),
"audio/x-dca",
"dts",
0,
AVInputFormat dirac_demuxer = {
"dirac",
- "raw dirac",
+ NULL_IF_CONFIG_SMALL("raw Dirac"),
0,
dirac_probe,
video_read_header,
#ifdef CONFIG_MUXERS
AVOutputFormat dirac_muxer = {
"dirac",
- "raw dirac",
+ NULL_IF_CONFIG_SMALL("raw Dirac"),
NULL,
"drc",
0,
AVInputFormat dts_demuxer = {
"dts",
- "raw dts",
+ NULL_IF_CONFIG_SMALL("raw DTS"),
0,
dts_probe,
audio_read_header,
AVInputFormat aac_demuxer = {
"aac",
- "ADTS AAC",
+ NULL_IF_CONFIG_SMALL("ADTS AAC"),
0,
NULL,
audio_read_header,
AVInputFormat gsm_demuxer = {
"gsm",
- "GSM",
+ NULL_IF_CONFIG_SMALL("GSM"),
0,
NULL,
audio_read_header,
AVOutputFormat roq_muxer =
{
"RoQ",
- "Id RoQ format",
+ NULL_IF_CONFIG_SMALL("Id RoQ format"),
NULL,
"roq",
0,
AVInputFormat h261_demuxer = {
"h261",
- "raw h261",
+ NULL_IF_CONFIG_SMALL("raw H.261"),
0,
h261_probe,
video_read_header,
#ifdef CONFIG_MUXERS
AVOutputFormat h261_muxer = {
"h261",
- "raw h261",
+ NULL_IF_CONFIG_SMALL("raw H.261"),
"video/x-h261",
"h261",
0,
AVInputFormat h263_demuxer = {
"h263",
- "raw h263",
+ NULL_IF_CONFIG_SMALL("raw H.263"),
0,
h263_probe,
video_read_header,
#ifdef CONFIG_MUXERS
AVOutputFormat h263_muxer = {
"h263",
- "raw h263",
+ NULL_IF_CONFIG_SMALL("raw H.263"),
"video/x-h263",
"h263",
0,
AVInputFormat m4v_demuxer = {
"m4v",
- "raw MPEG4 video format",
+ NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
0,
mpeg4video_probe, /** probing for mpeg4 data */
video_read_header,
#ifdef CONFIG_MUXERS
AVOutputFormat m4v_muxer = {
"m4v",
- "raw MPEG4 video format",
+ NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
NULL,
"m4v",
0,
AVInputFormat h264_demuxer = {
"h264",
- "raw H264 video format",
+ NULL_IF_CONFIG_SMALL("raw H.264 video format"),
0,
NULL /*mpegvideo_probe*/,
video_read_header,
#ifdef CONFIG_MUXERS
AVOutputFormat h264_muxer = {
"h264",
- "raw H264 video format",
+ NULL_IF_CONFIG_SMALL("raw H.264 video format"),
NULL,
"h264",
0,
AVInputFormat mpegvideo_demuxer = {
"mpegvideo",
- "MPEG video",
+ NULL_IF_CONFIG_SMALL("MPEG video"),
0,
mpegvideo_probe,
video_read_header,
#ifdef CONFIG_MUXERS
AVOutputFormat mpeg1video_muxer = {
"mpeg1video",
- "MPEG video",
+ NULL_IF_CONFIG_SMALL("MPEG video"),
"video/x-mpeg",
"mpg,mpeg,m1v",
0,
#ifdef CONFIG_MUXERS
AVOutputFormat mpeg2video_muxer = {
"mpeg2video",
- "MPEG2 video",
+ NULL_IF_CONFIG_SMALL("MPEG-2 video"),
NULL,
"m2v",
0,
AVInputFormat mjpeg_demuxer = {
"mjpeg",
- "MJPEG video",
+ NULL_IF_CONFIG_SMALL("MJPEG video"),
0,
NULL,
video_read_header,
AVInputFormat ingenient_demuxer = {
"ingenient",
- "Ingenient MJPEG",
+ NULL_IF_CONFIG_SMALL("Ingenient MJPEG"),
0,
NULL,
video_read_header,
#ifdef CONFIG_MUXERS
AVOutputFormat mjpeg_muxer = {
"mjpeg",
- "MJPEG video",
+ NULL_IF_CONFIG_SMALL("MJPEG video"),
"video/x-mjpeg",
"mjpg,mjpeg",
0,
AVInputFormat vc1_demuxer = {
"vc1",
- "raw vc1",
+ NULL_IF_CONFIG_SMALL("raw VC-1"),
0,
NULL /* vc1_probe */,
video_read_header,
#define PCMINPUTDEF(name, long_name, ext, codec) \
AVInputFormat pcm_ ## name ## _demuxer = {\
#name,\
- long_name,\
+ NULL_IF_CONFIG_SMALL(long_name),\
0,\
NULL,\
raw_read_header,\
#define PCMOUTPUTDEF(name, long_name, ext, codec) \
AVOutputFormat pcm_ ## name ## _muxer = {\
#name,\
- long_name,\
+ NULL_IF_CONFIG_SMALL(long_name),\
NULL,\
ext,\
0,\
AVInputFormat rawvideo_demuxer = {
"rawvideo",
- "raw video format",
+ NULL_IF_CONFIG_SMALL("raw video format"),
0,
NULL,
raw_read_header,
#ifdef CONFIG_MUXERS
AVOutputFormat rawvideo_muxer = {
"rawvideo",
- "raw video format",
+ NULL_IF_CONFIG_SMALL("raw video format"),
NULL,
"yuv,rgb",
0,
AVOutputFormat null_muxer = {
"null",
- "null video format",
+ NULL_IF_CONFIG_SMALL("null video format"),
NULL,
NULL,
0,
AVInputFormat rl2_demuxer = {
"rl2",
- "rl2 format",
+ NULL_IF_CONFIG_SMALL("rl2 format"),
sizeof(Rl2DemuxContext),
rl2_probe,
rl2_read_header,
AVInputFormat rm_demuxer = {
"rm",
- "rm format",
+ NULL_IF_CONFIG_SMALL("RM format"),
sizeof(RMContext),
rm_probe,
rm_read_header,
AVOutputFormat rm_muxer = {
"rm",
- "rm format",
+ NULL_IF_CONFIG_SMALL("RM format"),
"application/vnd.rn-realmedia",
"rm,ra",
sizeof(RMContext),
AVInputFormat rpl_demuxer = {
"rpl",
- "RPL/ARMovie format",
+ NULL_IF_CONFIG_SMALL("RPL/ARMovie format"),
sizeof(RPLContext),
rpl_probe,
rpl_read_header,
AVOutputFormat rtp_muxer = {
"rtp",
- "RTP output format",
+ NULL_IF_CONFIG_SMALL("RTP output format"),
NULL,
NULL,
sizeof(RTPDemuxContext),
#ifdef CONFIG_RTSP_DEMUXER
AVInputFormat rtsp_demuxer = {
"rtsp",
- "RTSP input format",
+ NULL_IF_CONFIG_SMALL("RTSP input format"),
sizeof(RTSPState),
rtsp_probe,
rtsp_read_header,
#ifdef CONFIG_SDP_DEMUXER
AVInputFormat sdp_demuxer = {
"sdp",
- "SDP",
+ NULL_IF_CONFIG_SMALL("SDP"),
sizeof(RTSPState),
sdp_probe,
sdp_read_header,
AVInputFormat redir_demuxer = {
"redir",
- "Redirector format",
+ NULL_IF_CONFIG_SMALL("Redirector format"),
0,
redir_probe,
redir_read_header,
AVInputFormat segafilm_demuxer = {
"film_cpk",
- "Sega FILM/CPK format",
+ NULL_IF_CONFIG_SMALL("Sega FILM/CPK format"),
sizeof(FilmDemuxContext),
film_probe,
film_read_header,
AVInputFormat vmd_demuxer = {
"vmd",
- "Sierra VMD format",
+ NULL_IF_CONFIG_SMALL("Sierra VMD format"),
sizeof(VmdDemuxContext),
vmd_probe,
vmd_read_header,
AVInputFormat siff_demuxer = {
"siff",
- "Beam Software SIFF",
+ NULL_IF_CONFIG_SMALL("Beam Software SIFF"),
sizeof(SIFFContext),
siff_probe,
siff_read_header,
AVInputFormat smacker_demuxer = {
"smk",
- "Smacker Video",
+ NULL_IF_CONFIG_SMALL("Smacker video"),
sizeof(SmackerContext),
smacker_probe,
smacker_read_header,
AVInputFormat sol_demuxer = {
"sol",
- "Sierra SOL Format",
+ NULL_IF_CONFIG_SMALL("Sierra SOL format"),
0,
sol_probe,
sol_read_header,
AVInputFormat swf_demuxer = {
"swf",
- "Flash format",
+ NULL_IF_CONFIG_SMALL("Flash format"),
sizeof(SWFContext),
swf_probe,
swf_read_header,
#ifdef CONFIG_SWF_MUXER
AVOutputFormat swf_muxer = {
"swf",
- "Flash format",
+ NULL_IF_CONFIG_SMALL("Flash format"),
"application/x-shockwave-flash",
"swf",
sizeof(SWFContext),
#ifdef CONFIG_AVM2_MUXER
AVOutputFormat avm2_muxer = {
"avm2",
- "Flash 9 (AVM2) format",
+ NULL_IF_CONFIG_SMALL("Flash 9 (AVM2) format"),
"application/x-shockwave-flash",
NULL,
sizeof(SWFContext),
AVInputFormat thp_demuxer = {
"thp",
- "THP",
+ NULL_IF_CONFIG_SMALL("THP"),
sizeof(ThpDemuxContext),
thp_probe,
thp_read_header,
AVInputFormat tiertexseq_demuxer = {
"tiertexseq",
- "Tiertex Limited SEQ format",
+ NULL_IF_CONFIG_SMALL("Tiertex Limited SEQ format"),
sizeof(SeqDemuxContext),
seq_probe,
seq_read_header,
AVInputFormat tta_demuxer = {
"tta",
- "true-audio",
+ NULL_IF_CONFIG_SMALL("True Audio"),
sizeof(TTAContext),
tta_probe,
tta_read_header,
AVInputFormat txd_demuxer =
{
"txd",
- "txd format",
+ NULL_IF_CONFIG_SMALL("txd format"),
0,
txd_probe,
txd_read_header,
AVInputFormat vc1t_demuxer = {
"vc1test",
- "VC1 test bitstream format",
+ NULL_IF_CONFIG_SMALL("VC-1 test bitstream format"),
0,
vc1t_probe,
vc1t_read_header,
AVInputFormat voc_demuxer = {
"voc",
- "Creative Voice File format",
+ NULL_IF_CONFIG_SMALL("Creative Voice file format"),
sizeof(voc_dec_context_t),
voc_probe,
voc_read_header,
AVOutputFormat voc_muxer = {
"voc",
- "Creative Voice File format",
+ NULL_IF_CONFIG_SMALL("Creative Voice file format"),
"audio/x-voc",
"voc",
sizeof(voc_enc_context_t),
#ifdef CONFIG_WAV_DEMUXER
AVInputFormat wav_demuxer = {
"wav",
- "wav format",
+ NULL_IF_CONFIG_SMALL("WAV format"),
sizeof(WAVContext),
wav_probe,
wav_read_header,
#ifdef CONFIG_WAV_MUXER
AVOutputFormat wav_muxer = {
"wav",
- "wav format",
+ NULL_IF_CONFIG_SMALL("WAV format"),
"audio/x-wav",
"wav",
sizeof(WAVContext),
AVInputFormat wc3_demuxer = {
"wc3movie",
- "Wing Commander III movie format",
+ NULL_IF_CONFIG_SMALL("Wing Commander III movie format"),
sizeof(Wc3DemuxContext),
wc3_probe,
wc3_read_header,
#ifdef CONFIG_WSAUD_DEMUXER
AVInputFormat wsaud_demuxer = {
"wsaud",
- "Westwood Studios audio format",
+ NULL_IF_CONFIG_SMALL("Westwood Studios audio format"),
sizeof(WsAudDemuxContext),
wsaud_probe,
wsaud_read_header,
#ifdef CONFIG_WSVQA_DEMUXER
AVInputFormat wsvqa_demuxer = {
"wsvqa",
- "Westwood Studios VQA format",
+ NULL_IF_CONFIG_SMALL("Westwood Studios VQA format"),
sizeof(WsVqaDemuxContext),
wsvqa_probe,
wsvqa_read_header,
AVInputFormat wv_demuxer = {
"wv",
- "WavPack",
+ NULL_IF_CONFIG_SMALL("WavPack"),
sizeof(WVContext),
wv_probe,
wv_read_header,
AVInputFormat xa_demuxer = {
"xa",
- "Maxis XA File Format",
+ NULL_IF_CONFIG_SMALL("Maxis XA File Format"),
sizeof(MaxisXADemuxContext),
xa_probe,
xa_read_header,
#ifdef CONFIG_YUV4MPEGPIPE_MUXER
AVOutputFormat yuv4mpegpipe_muxer = {
"yuv4mpegpipe",
- "YUV4MPEG pipe format",
+ NULL_IF_CONFIG_SMALL("YUV4MPEG pipe format"),
"",
"y4m",
sizeof(int),
#ifdef CONFIG_YUV4MPEGPIPE_DEMUXER
AVInputFormat yuv4mpegpipe_demuxer = {
"yuv4mpegpipe",
- "YUV4MPEG pipe format",
+ NULL_IF_CONFIG_SMALL("YUV4MPEG pipe format"),
sizeof(struct frame_attributes),
yuv4_probe,
yuv4_read_header,