#include "avdevice.h"
#define REGISTER_OUTDEV(X,x) { \
- extern AVOutputFormat x##_muxer; \
- if(CONFIG_##X##_OUTDEV) av_register_output_format(&x##_muxer); }
+ extern AVOutputFormat ff_##x##_muxer; \
+ if(CONFIG_##X##_OUTDEV) av_register_output_format(&ff_##x##_muxer); }
#define REGISTER_INDEV(X,x) { \
- extern AVInputFormat x##_demuxer; \
- if(CONFIG_##X##_INDEV) av_register_input_format(&x##_demuxer); }
+ extern AVInputFormat ff_##x##_demuxer; \
+ if(CONFIG_##X##_INDEV) av_register_input_format(&ff_##x##_demuxer); }
#define REGISTER_INOUTDEV(X,x) REGISTER_OUTDEV(X,x); REGISTER_INDEV(X,x)
void avdevice_register_all(void)
return 0;
}
-AVInputFormat alsa_demuxer = {
+AVInputFormat ff_alsa_demuxer = {
"alsa",
NULL_IF_CONFIG_SMALL("ALSA audio input"),
sizeof(AlsaData),
return 0;
}
-AVOutputFormat alsa_muxer = {
+AVOutputFormat ff_alsa_muxer = {
"alsa",
NULL_IF_CONFIG_SMALL("ALSA audio output"),
"",
return 0;
}
-AVInputFormat bktr_demuxer = {
+AVInputFormat ff_bktr_demuxer = {
"bktr",
NULL_IF_CONFIG_SMALL("video grab"),
sizeof(VideoData),
return 0;
}
-AVInputFormat dv1394_demuxer = {
+AVInputFormat ff_dv1394_demuxer = {
.name = "dv1394",
.long_name = NULL_IF_CONFIG_SMALL("DV1394 A/V grab"),
.priv_data_size = sizeof(struct dv1394_data),
return 0;
}
-AVInputFormat jack_demuxer = {
+AVInputFormat ff_jack_demuxer = {
"jack",
NULL_IF_CONFIG_SMALL("JACK Audio Connection Kit"),
sizeof(JackData),
return 0;
}
-AVInputFormat libdc1394_demuxer = {
+AVInputFormat ff_libdc1394_demuxer = {
.name = "libdc1394",
.long_name = NULL_IF_CONFIG_SMALL("dc1394 v.2 A/V grab"),
.priv_data_size = sizeof(struct dc1394_data),
#endif
#if HAVE_LIBDC1394_1
-AVInputFormat libdc1394_demuxer = {
+AVInputFormat ff_libdc1394_demuxer = {
.name = "libdc1394",
.long_name = NULL_IF_CONFIG_SMALL("dc1394 v.1 A/V grab"),
.priv_data_size = sizeof(struct dc1394_data),
}
#if CONFIG_OSS_INDEV
-AVInputFormat oss_demuxer = {
+AVInputFormat ff_oss_demuxer = {
"oss",
NULL_IF_CONFIG_SMALL("Open Sound System capture"),
sizeof(AudioData),
#endif
#if CONFIG_OSS_OUTDEV
-AVOutputFormat oss_muxer = {
+AVOutputFormat ff_oss_muxer = {
"oss",
NULL_IF_CONFIG_SMALL("Open Sound System playback"),
"",
return 0;
}
-AVInputFormat v4l_demuxer = {
+AVInputFormat ff_v4l_demuxer = {
"video4linux",
NULL_IF_CONFIG_SMALL("Video4Linux device grab"),
sizeof(VideoData),
return 0;
}
-AVInputFormat v4l2_demuxer = {
+AVInputFormat ff_v4l2_demuxer = {
"video4linux2",
NULL_IF_CONFIG_SMALL("Video4Linux2 device grab"),
sizeof(struct video_data),
return pkt->size;
}
-AVInputFormat vfwcap_demuxer = {
+AVInputFormat ff_vfwcap_demuxer = {
"vfwcap",
NULL_IF_CONFIG_SMALL("VFW video capture"),
sizeof(struct vfw_ctx),
}
/** x11 grabber device demuxer declaration */
-AVInputFormat x11_grab_device_demuxer =
+AVInputFormat ff_x11_grab_device_demuxer =
{
"x11grab",
NULL_IF_CONFIG_SMALL("X11grab"),
return 0;
}
-AVInputFormat fourxm_demuxer = {
+AVInputFormat ff_fourxm_demuxer = {
"4xm",
NULL_IF_CONFIG_SMALL("4X Technologies format"),
sizeof(FourxmDemuxContext),
return 0;
}
-AVOutputFormat a64_muxer = {
+AVOutputFormat ff_a64_muxer = {
.name = "a64",
.long_name = NULL_IF_CONFIG_SMALL("a64 - video for Commodore 64"),
.mime_type = NULL,
return 0;
}
-AVInputFormat aac_demuxer = {
+AVInputFormat ff_aac_demuxer = {
"aac",
NULL_IF_CONFIG_SMALL("raw ADTS AAC"),
0,
return ac3_eac3_probe(p, CODEC_ID_AC3);
}
-AVInputFormat ac3_demuxer = {
+AVInputFormat ff_ac3_demuxer = {
"ac3",
NULL_IF_CONFIG_SMALL("raw AC-3"),
0,
return ac3_eac3_probe(p, CODEC_ID_EAC3);
}
-AVInputFormat eac3_demuxer = {
+AVInputFormat ff_eac3_demuxer = {
"eac3",
NULL_IF_CONFIG_SMALL("raw E-AC-3"),
0,
return 0;
}
-AVOutputFormat adts_muxer = {
+AVOutputFormat ff_adts_muxer = {
"adts",
NULL_IF_CONFIG_SMALL("ADTS AAC"),
"audio/aac",
return ret;
}
-AVInputFormat aea_demuxer = {
+AVInputFormat ff_aea_demuxer = {
"aea",
NULL_IF_CONFIG_SMALL("MD STUDIO audio"),
0,
return 0;
}
-AVInputFormat aiff_demuxer = {
+AVInputFormat ff_aiff_demuxer = {
"aiff",
NULL_IF_CONFIG_SMALL("Audio IFF"),
sizeof(AIFFInputContext),
return 0;
}
-AVOutputFormat aiff_muxer = {
+AVOutputFormat ff_aiff_muxer = {
"aiff",
NULL_IF_CONFIG_SMALL("Audio IFF"),
"audio/aiff",
#include "rdt.h"
#define REGISTER_MUXER(X,x) { \
- extern AVOutputFormat x##_muxer; \
- if(CONFIG_##X##_MUXER) av_register_output_format(&x##_muxer); }
+ extern AVOutputFormat ff_##x##_muxer; \
+ if(CONFIG_##X##_MUXER) av_register_output_format(&ff_##x##_muxer); }
#define REGISTER_DEMUXER(X,x) { \
- extern AVInputFormat x##_demuxer; \
- if(CONFIG_##X##_DEMUXER) av_register_input_format(&x##_demuxer); }
+ extern AVInputFormat ff_##x##_demuxer; \
+ if(CONFIG_##X##_DEMUXER) av_register_input_format(&ff_##x##_demuxer); }
#define REGISTER_MUXDEMUX(X,x) REGISTER_MUXER(X,x); REGISTER_DEMUXER(X,x)
#define REGISTER_PROTOCOL(X,x) { \
- extern URLProtocol x##_protocol; \
- if(CONFIG_##X##_PROTOCOL) av_register_protocol2(&x##_protocol, sizeof(x##_protocol)); }
+ extern URLProtocol ff_##x##_protocol; \
+ if(CONFIG_##X##_PROTOCOL) av_register_protocol2(&ff_##x##_protocol, sizeof(ff_##x##_protocol)); }
void av_register_all(void)
{
}
#if CONFIG_AMR_DEMUXER
-AVInputFormat amr_demuxer = {
+AVInputFormat ff_amr_demuxer = {
"amr",
NULL_IF_CONFIG_SMALL("3GPP AMR file format"),
0, /*priv_data_size*/
#endif
#if CONFIG_AMR_MUXER
-AVOutputFormat amr_muxer = {
+AVOutputFormat ff_amr_muxer = {
"amr",
NULL_IF_CONFIG_SMALL("3GPP AMR file format"),
"audio/amr",
return 0;
}
-AVInputFormat anm_demuxer = {
+AVInputFormat ff_anm_demuxer = {
"anm",
NULL_IF_CONFIG_SMALL("Deluxe Paint Animation"),
sizeof(AnmDemuxContext),
return 0;
}
-AVInputFormat apc_demuxer = {
+AVInputFormat ff_apc_demuxer = {
"apc",
NULL_IF_CONFIG_SMALL("CRYO APC format"),
0,
return 0;
}
-AVInputFormat ape_demuxer = {
+AVInputFormat ff_ape_demuxer = {
"ape",
NULL_IF_CONFIG_SMALL("Monkey's Audio"),
sizeof(APEContext),
return 0;
}
-AVInputFormat applehttp_demuxer = {
+AVInputFormat ff_applehttp_demuxer = {
"applehttp",
NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming format"),
sizeof(AppleHTTPContext),
#define ASF_PL_FLAG_KEY_FRAME 0x80 //1000 0000
-extern AVInputFormat asf_demuxer;
+extern AVInputFormat ff_asf_demuxer;
int ff_guidcmp(const void *g1, const void *g2);
void ff_get_guid(ByteIOContext *s, ff_asf_guid *g);
return 0;
}
-AVInputFormat asf_demuxer = {
+AVInputFormat ff_asf_demuxer = {
"asf",
NULL_IF_CONFIG_SMALL("ASF format"),
sizeof(ASFContext),
}
#if CONFIG_ASF_MUXER
-AVOutputFormat asf_muxer = {
+AVOutputFormat ff_asf_muxer = {
"asf",
NULL_IF_CONFIG_SMALL("ASF format"),
"video/x-ms-asf",
#endif
#if CONFIG_ASF_STREAM_MUXER
-AVOutputFormat asf_stream_muxer = {
+AVOutputFormat ff_asf_stream_muxer = {
"asf_stream",
NULL_IF_CONFIG_SMALL("ASF format"),
"video/x-ms-asf",
return 0;
}
-AVInputFormat ass_demuxer = {
+AVInputFormat ff_ass_demuxer = {
.name = "ass",
.long_name = NULL_IF_CONFIG_SMALL("Advanced SubStation Alpha subtitle format"),
.priv_data_size = sizeof(ASSContext),
return 0;
}
-AVOutputFormat ass_muxer = {
+AVOutputFormat ff_ass_muxer = {
.name = "ass",
.long_name = NULL_IF_CONFIG_SMALL("Advanced SubStation Alpha subtitle format"),
.mime_type = "text/x-ssa",
}
#if CONFIG_AU_DEMUXER
-AVInputFormat au_demuxer = {
+AVInputFormat ff_au_demuxer = {
"au",
NULL_IF_CONFIG_SMALL("SUN AU format"),
0,
#endif
#if CONFIG_AU_MUXER
-AVOutputFormat au_muxer = {
+AVOutputFormat ff_au_muxer = {
"au",
NULL_IF_CONFIG_SMALL("SUN AU format"),
"audio/basic",
return 0;
}
-AVInputFormat avi_demuxer = {
+AVInputFormat ff_avi_demuxer = {
"avi",
NULL_IF_CONFIG_SMALL("AVI format"),
sizeof(AVIContext),
return res;
}
-AVOutputFormat avi_muxer = {
+AVOutputFormat ff_avi_muxer = {
"avi",
NULL_IF_CONFIG_SMALL("AVI format"),
"video/x-msvideo",
return 0;
}
-AVInputFormat avisynth_demuxer = {
+AVInputFormat ff_avisynth_demuxer = {
"avs",
NULL_IF_CONFIG_SMALL("AVISynth"),
sizeof(AVISynthContext),
return 0;
}
-AVInputFormat avs_demuxer = {
+AVInputFormat ff_avs_demuxer = {
"avs",
NULL_IF_CONFIG_SMALL("AVS format"),
sizeof(AvsFormat),
return 0;
}
-AVInputFormat bethsoftvid_demuxer = {
+AVInputFormat ff_bethsoftvid_demuxer = {
"bethsoftvid",
NULL_IF_CONFIG_SMALL("Bethesda Softworks VID format"),
sizeof(BVID_DemuxContext),
return ret;
}
-AVInputFormat bfi_demuxer = {
+AVInputFormat ff_bfi_demuxer = {
"bfi",
NULL_IF_CONFIG_SMALL("Brute Force & Ignorance"),
sizeof(BFIContext),
return 0;
}
-AVInputFormat bink_demuxer = {
+AVInputFormat ff_bink_demuxer = {
"bink",
NULL_IF_CONFIG_SMALL("Bink"),
sizeof(BinkDemuxContext),
return ret;
}
-AVInputFormat c93_demuxer = {
+AVInputFormat ff_c93_demuxer = {
"c93",
NULL_IF_CONFIG_SMALL("Interplay C93"),
sizeof(C93DemuxContext),
return 0;
}
-AVInputFormat caf_demuxer = {
+AVInputFormat ff_caf_demuxer = {
"caf",
NULL_IF_CONFIG_SMALL("Apple Core Audio Format"),
sizeof(CaffContext),
return 0;
}
-AVInputFormat cavsvideo_demuxer = {
+AVInputFormat ff_cavsvideo_demuxer = {
"cavsvideo",
NULL_IF_CONFIG_SMALL("raw Chinese AVS video"),
0,
return ret;
}
-AVInputFormat cdg_demuxer = {
+AVInputFormat ff_cdg_demuxer = {
"cdg",
NULL_IF_CONFIG_SMALL("CD Graphics Format"),
0,
return result;
}
-URLProtocol concat_protocol = {
+URLProtocol ff_concat_protocol = {
"concat",
concat_open,
concat_read,
return 0;
}
-AVOutputFormat crc_muxer = {
+AVOutputFormat ff_crc_muxer = {
"crc",
NULL_IF_CONFIG_SMALL("CRC testing format"),
NULL,
}
#if CONFIG_DAUD_DEMUXER
-AVInputFormat daud_demuxer = {
+AVInputFormat ff_daud_demuxer = {
"daud",
NULL_IF_CONFIG_SMALL("D-Cinema audio format"),
0,
#endif
#if CONFIG_DAUD_MUXER
-AVOutputFormat daud_muxer =
+AVOutputFormat ff_daud_muxer =
{
"daud",
NULL_IF_CONFIG_SMALL("D-Cinema audio format"),
return 0;
}
-AVInputFormat dirac_demuxer = {
+AVInputFormat ff_dirac_demuxer = {
"dirac",
NULL_IF_CONFIG_SMALL("raw Dirac"),
0,
return AVPROBE_SCORE_MAX;
}
-AVInputFormat dnxhd_demuxer = {
+AVInputFormat ff_dnxhd_demuxer = {
"dnxhd",
NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),
0,
return 0;
}
-AVInputFormat dsicin_demuxer = {
+AVInputFormat ff_dsicin_demuxer = {
"dsicin",
NULL_IF_CONFIG_SMALL("Delphine Software International CIN format"),
sizeof(CinDemuxContext),
return 0;
}
-AVInputFormat dts_demuxer = {
+AVInputFormat ff_dts_demuxer = {
"dts",
NULL_IF_CONFIG_SMALL("raw DTS"),
0,
}
#if CONFIG_DV_DEMUXER
-AVInputFormat dv_demuxer = {
+AVInputFormat ff_dv_demuxer = {
"dv",
NULL_IF_CONFIG_SMALL("DV video format"),
sizeof(RawDVContext),
return 0;
}
-AVOutputFormat dv_muxer = {
+AVOutputFormat ff_dv_muxer = {
"dv",
NULL_IF_CONFIG_SMALL("DV video format"),
NULL,
return AVERROR(EIO);
}
-AVInputFormat dxa_demuxer = {
+AVInputFormat ff_dxa_demuxer = {
"dxa",
NULL_IF_CONFIG_SMALL("DXA"),
sizeof(DXAContext),
return 0;
}
-AVInputFormat ea_cdata_demuxer = {
+AVInputFormat ff_ea_cdata_demuxer = {
"ea_cdata",
NULL_IF_CONFIG_SMALL("Electronic Arts cdata"),
sizeof(CdataDemuxContext),
return ret;
}
-AVInputFormat ea_demuxer = {
+AVInputFormat ff_ea_demuxer = {
"ea",
NULL_IF_CONFIG_SMALL("Electronic Arts Multimedia Format"),
sizeof(EaDemuxContext),
return 0;
}
-AVInputFormat ffm_demuxer = {
+AVInputFormat ff_ffm_demuxer = {
"ffm",
NULL_IF_CONFIG_SMALL("FFM (FFserver live feed) format"),
sizeof(FFMContext),
return 0;
}
-AVOutputFormat ffm_muxer = {
+AVOutputFormat ff_ffm_muxer = {
"ffm",
NULL_IF_CONFIG_SMALL("FFM (FFserver live feed) format"),
"",
return AVERROR_EOF;
}
-AVInputFormat ffmetadata_demuxer = {
+AVInputFormat ff_ffmetadata_demuxer = {
.name = "ffmetadata",
.long_name = NULL_IF_CONFIG_SMALL("FFmpeg metadata in text format"),
.read_probe = probe,
return 0;
}
-AVOutputFormat ffmetadata_muxer = {
+AVOutputFormat ff_ffmetadata_muxer = {
.name = "ffmetadata",
.long_name = NULL_IF_CONFIG_SMALL("FFmpeg metadata in text format"),
.extensions = "ffmeta",
return close(fd);
}
-URLProtocol file_protocol = {
+URLProtocol ff_file_protocol = {
"file",
file_open,
file_read,
return 0;
}
-URLProtocol pipe_protocol = {
+URLProtocol ff_pipe_protocol = {
"pipe",
pipe_open,
file_read,
return 0;
}
-AVInputFormat filmstrip_demuxer = {
+AVInputFormat ff_filmstrip_demuxer = {
"filmstrip",
NULL_IF_CONFIG_SMALL("Adobe Filmstrip"),
sizeof(FilmstripDemuxContext),
return 0;
}
-AVOutputFormat filmstrip_muxer = {
+AVOutputFormat ff_filmstrip_muxer = {
"filmstrip",
NULL_IF_CONFIG_SMALL("Adobe Filmstrip"),
NULL,
else return AVPROBE_SCORE_MAX/2;
}
-AVInputFormat flac_demuxer = {
+AVInputFormat ff_flac_demuxer = {
"flac",
NULL_IF_CONFIG_SMALL("raw FLAC"),
0,
return 0;
}
-AVOutputFormat flac_muxer = {
+AVOutputFormat ff_flac_muxer = {
"flac",
NULL_IF_CONFIG_SMALL("raw FLAC"),
"audio/x-flac",
return ret;
}
-AVInputFormat flic_demuxer = {
+AVInputFormat ff_flic_demuxer = {
"flic",
NULL_IF_CONFIG_SMALL("FLI/FLC/FLX animation format"),
sizeof(FlicDemuxContext),
}
#endif
-AVInputFormat flv_demuxer = {
+AVInputFormat ff_flv_demuxer = {
"flv",
NULL_IF_CONFIG_SMALL("FLV format"),
sizeof(FLVContext),
return 0;
}
-AVOutputFormat flv_muxer = {
+AVOutputFormat ff_flv_muxer = {
"flv",
NULL_IF_CONFIG_SMALL("FLV format"),
"video/x-flv",
return 0;
}
-AVOutputFormat framecrc_muxer = {
+AVOutputFormat ff_framecrc_muxer = {
"framecrc",
NULL_IF_CONFIG_SMALL("framecrc testing format"),
NULL,
return 0;
}
-AVOutputFormat gif_muxer = {
+AVOutputFormat ff_gif_muxer = {
"gif",
NULL_IF_CONFIG_SMALL("GIF Animation"),
"image/gif",
}
-URLProtocol gopher_protocol = {
+URLProtocol ff_gopher_protocol = {
"gopher",
gopher_open,
gopher_read,
return res;
}
-AVInputFormat gxf_demuxer = {
+AVInputFormat ff_gxf_demuxer = {
"gxf",
NULL_IF_CONFIG_SMALL("GXF format"),
0,
av_interleave_packet_per_dts, gxf_compare_field_nb);
}
-AVOutputFormat gxf_muxer = {
+AVOutputFormat ff_gxf_muxer = {
"gxf",
NULL_IF_CONFIG_SMALL("GXF format"),
NULL,
return 0;
}
-AVInputFormat h261_demuxer = {
+AVInputFormat ff_h261_demuxer = {
"h261",
NULL_IF_CONFIG_SMALL("raw H.261"),
0,
return 0;
}
-AVInputFormat h263_demuxer = {
+AVInputFormat ff_h263_demuxer = {
"h263",
NULL_IF_CONFIG_SMALL("raw H.263"),
0,
return 0;
}
-AVInputFormat h264_demuxer = {
+AVInputFormat ff_h264_demuxer = {
"h264",
NULL_IF_CONFIG_SMALL("raw H.264 video format"),
0,
return url_get_file_handle(s->hd);
}
-URLProtocol http_protocol = {
+URLProtocol ff_http_protocol = {
"http",
http_open,
http_read,
return ret;
}
-AVInputFormat idcin_demuxer = {
+AVInputFormat ff_idcin_demuxer = {
"idcin",
NULL_IF_CONFIG_SMALL("id Cinematic format"),
sizeof(IdcinDemuxContext),
return ret;
}
-AVInputFormat roq_demuxer = {
+AVInputFormat ff_roq_demuxer = {
"RoQ",
NULL_IF_CONFIG_SMALL("id RoQ format"),
sizeof(RoqDemuxContext),
return 0;
}
-AVOutputFormat roq_muxer =
+AVOutputFormat ff_roq_muxer =
{
"RoQ",
NULL_IF_CONFIG_SMALL("raw id RoQ format"),
return ret;
}
-AVInputFormat iff_demuxer = {
+AVInputFormat ff_iff_demuxer = {
"IFF",
NULL_IF_CONFIG_SMALL("IFF format"),
sizeof(IffDemuxContext),
/* input */
#if CONFIG_IMAGE2_DEMUXER
-AVInputFormat image2_demuxer = {
+AVInputFormat ff_image2_demuxer = {
.name = "image2",
.long_name = NULL_IF_CONFIG_SMALL("image2 sequence"),
.priv_data_size = sizeof(VideoData),
};
#endif
#if CONFIG_IMAGE2PIPE_DEMUXER
-AVInputFormat image2pipe_demuxer = {
+AVInputFormat ff_image2pipe_demuxer = {
.name = "image2pipe",
.long_name = NULL_IF_CONFIG_SMALL("piped image2 sequence"),
.priv_data_size = sizeof(VideoData),
/* output */
#if CONFIG_IMAGE2_MUXER
-AVOutputFormat image2_muxer = {
+AVOutputFormat ff_image2_muxer = {
.name = "image2",
.long_name = NULL_IF_CONFIG_SMALL("image2 sequence"),
.extensions = "bmp,jpeg,jpg,ljpg,pam,pbm,pcx,pgm,pgmyuv,png,"
};
#endif
#if CONFIG_IMAGE2PIPE_MUXER
-AVOutputFormat image2pipe_muxer = {
+AVOutputFormat ff_image2pipe_muxer = {
.name = "image2pipe",
.long_name = NULL_IF_CONFIG_SMALL("piped image2 sequence"),
.priv_data_size = sizeof(VideoData),
return ret;
}
-AVInputFormat ingenient_demuxer = {
+AVInputFormat ff_ingenient_demuxer = {
"ingenient",
NULL_IF_CONFIG_SMALL("raw Ingenient MJPEG"),
0,
return ret;
}
-AVInputFormat ipmovie_demuxer = {
+AVInputFormat ff_ipmovie_demuxer = {
"ipmovie",
NULL_IF_CONFIG_SMALL("Interplay MVE format"),
sizeof(IPMVEContext),
return 0;
}
-AVInputFormat iss_demuxer = {
+AVInputFormat ff_iss_demuxer = {
"ISS",
NULL_IF_CONFIG_SMALL("Funcom ISS format"),
sizeof(IssDemuxContext),
return ret;
}
-AVInputFormat iv8_demuxer = {
+AVInputFormat ff_iv8_demuxer = {
"iv8",
NULL_IF_CONFIG_SMALL("A format generated by IndigoVision 8000 video server"),
0,
return ret;
}
-AVInputFormat ivf_demuxer = {
+AVInputFormat ff_ivf_demuxer = {
"ivf",
NULL_IF_CONFIG_SMALL("On2 IVF"),
0,
return 0;
}
-AVOutputFormat ivf_muxer = {
+AVOutputFormat ff_ivf_muxer = {
.name = "ivf",
.long_name = NULL_IF_CONFIG_SMALL("On2 IVF"),
.extensions = "ivf",
return 0;
}
-AVOutputFormat libnut_muxer = {
+AVOutputFormat ff_libnut_muxer = {
"libnut",
"nut format",
"video/x-nut",
return 0;
}
-AVInputFormat libnut_demuxer = {
+AVInputFormat ff_libnut_demuxer = {
"libnut",
NULL_IF_CONFIG_SMALL("NUT format"),
sizeof(NUTContext),
return RTMP_Socket(r);
}
-URLProtocol rtmp_protocol = {
+URLProtocol ff_rtmp_protocol = {
"rtmp",
rtmp_open,
rtmp_read,
rtmp_get_file_handle
};
-URLProtocol rtmpt_protocol = {
+URLProtocol ff_rtmpt_protocol = {
"rtmpt",
rtmp_open,
rtmp_read,
rtmp_get_file_handle
};
-URLProtocol rtmpe_protocol = {
+URLProtocol ff_rtmpe_protocol = {
"rtmpe",
rtmp_open,
rtmp_read,
rtmp_get_file_handle
};
-URLProtocol rtmpte_protocol = {
+URLProtocol ff_rtmpte_protocol = {
"rtmpte",
rtmp_open,
rtmp_read,
rtmp_get_file_handle
};
-URLProtocol rtmps_protocol = {
+URLProtocol ff_rtmps_protocol = {
"rtmps",
rtmp_open,
rtmp_read,
return ret;
}
-AVInputFormat lmlm4_demuxer = {
+AVInputFormat ff_lmlm4_demuxer = {
"lmlm4",
NULL_IF_CONFIG_SMALL("lmlm4 raw format"),
0,
return ret;
}
-AVInputFormat lxf_demuxer = {
+AVInputFormat ff_lxf_demuxer = {
.name = "lxf",
.long_name = NULL_IF_CONFIG_SMALL("VR native stream format (LXF)"),
.priv_data_size = sizeof(LXFDemuxContext),
return 0;
}
-AVInputFormat m4v_demuxer = {
+AVInputFormat ff_m4v_demuxer = {
"m4v",
NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
0,
return 0;
}
-AVInputFormat matroska_demuxer = {
+AVInputFormat ff_matroska_demuxer = {
"matroska,webm",
NULL_IF_CONFIG_SMALL("Matroska/WebM file format"),
sizeof(MatroskaDemuxContext),
}
#if CONFIG_MATROSKA_MUXER
-AVOutputFormat matroska_muxer = {
+AVOutputFormat ff_matroska_muxer = {
"matroska",
NULL_IF_CONFIG_SMALL("Matroska file format"),
"video/x-matroska",
#endif
#if CONFIG_WEBM_MUXER
-AVOutputFormat webm_muxer = {
+AVOutputFormat ff_webm_muxer = {
"webm",
NULL_IF_CONFIG_SMALL("WebM file format"),
"video/webm",
#endif
#if CONFIG_MATROSKA_AUDIO_MUXER
-AVOutputFormat matroska_audio_muxer = {
+AVOutputFormat ff_matroska_audio_muxer = {
"matroska",
NULL_IF_CONFIG_SMALL("Matroska file format"),
"audio/x-matroska",
return 0;
}
-AVOutputFormat md5_muxer = {
+AVOutputFormat ff_md5_muxer = {
"md5",
NULL_IF_CONFIG_SMALL("MD5 testing format"),
NULL,
return 0;
}
-AVOutputFormat framemd5_muxer = {
+AVOutputFormat ff_framemd5_muxer = {
"framemd5",
NULL_IF_CONFIG_SMALL("Per-frame MD5 testing format"),
NULL,
return (intptr_t)h->priv_data;
}
-URLProtocol md5_protocol = {
+URLProtocol ff_md5_protocol = {
.name = "md5",
.url_open = md5_open,
.url_write = md5_write,
return 0;
}
-AVInputFormat mm_demuxer = {
+AVInputFormat ff_mm_demuxer = {
"mm",
NULL_IF_CONFIG_SMALL("American Laser Games MM format"),
sizeof(MmDemuxContext),
}
#if CONFIG_MMF_DEMUXER
-AVInputFormat mmf_demuxer = {
+AVInputFormat ff_mmf_demuxer = {
"mmf",
NULL_IF_CONFIG_SMALL("Yamaha SMAF"),
sizeof(MMFContext),
};
#endif
#if CONFIG_MMF_MUXER
-AVOutputFormat mmf_muxer = {
+AVOutputFormat ff_mmf_muxer = {
"mmf",
NULL_IF_CONFIG_SMALL("Yamaha SMAF"),
"application/vnd.smaf",
return res;
}
-URLProtocol mmsh_protocol = {
+URLProtocol ff_mmsh_protocol = {
.name = "mmsh",
.url_open = mmsh_open,
.url_read = mmsh_read,
return result;
}
-URLProtocol mmst_protocol = {
+URLProtocol ff_mmst_protocol = {
"mmst",
mms_open,
mms_read,
return 0;
}
-AVInputFormat mov_demuxer = {
+AVInputFormat ff_mov_demuxer = {
"mov,mp4,m4a,3gp,3g2,mj2",
NULL_IF_CONFIG_SMALL("QuickTime/MPEG-4/Motion JPEG 2000 format"),
sizeof(MOVContext),
}
#if CONFIG_MOV_MUXER
-AVOutputFormat mov_muxer = {
+AVOutputFormat ff_mov_muxer = {
"mov",
NULL_IF_CONFIG_SMALL("MOV format"),
NULL,
};
#endif
#if CONFIG_TGP_MUXER
-AVOutputFormat tgp_muxer = {
+AVOutputFormat ff_tgp_muxer = {
"3gp",
NULL_IF_CONFIG_SMALL("3GP format"),
NULL,
};
#endif
#if CONFIG_MP4_MUXER
-AVOutputFormat mp4_muxer = {
+AVOutputFormat ff_mp4_muxer = {
"mp4",
NULL_IF_CONFIG_SMALL("MP4 format"),
"application/mp4",
};
#endif
#if CONFIG_PSP_MUXER
-AVOutputFormat psp_muxer = {
+AVOutputFormat ff_psp_muxer = {
"psp",
NULL_IF_CONFIG_SMALL("PSP MP4 format"),
NULL,
};
#endif
#if CONFIG_TG2_MUXER
-AVOutputFormat tg2_muxer = {
+AVOutputFormat ff_tg2_muxer = {
"3g2",
NULL_IF_CONFIG_SMALL("3GP2 format"),
NULL,
};
#endif
#if CONFIG_IPOD_MUXER
-AVOutputFormat ipod_muxer = {
+AVOutputFormat ff_ipod_muxer = {
"ipod",
NULL_IF_CONFIG_SMALL("iPod H.264 MP4 format"),
"application/mp4",
return ret;
}
-AVInputFormat mp3_demuxer = {
+AVInputFormat ff_mp3_demuxer = {
"mp3",
NULL_IF_CONFIG_SMALL("MPEG audio layer 2/3"),
0,
}
#if CONFIG_MP2_MUXER
-AVOutputFormat mp2_muxer = {
+AVOutputFormat ff_mp2_muxer = {
"mp2",
NULL_IF_CONFIG_SMALL("MPEG audio layer 2"),
"audio/x-mpeg",
return 0;
}
-AVOutputFormat mp3_muxer = {
+AVOutputFormat ff_mp3_muxer = {
"mp3",
NULL_IF_CONFIG_SMALL("MPEG audio layer 3"),
"audio/x-mpeg",
}
-AVInputFormat mpc_demuxer = {
+AVInputFormat ff_mpc_demuxer = {
"mpc",
NULL_IF_CONFIG_SMALL("Musepack"),
sizeof(MPCContext),
}
-AVInputFormat mpc8_demuxer = {
+AVInputFormat ff_mpc8_demuxer = {
"mpc8",
NULL_IF_CONFIG_SMALL("Musepack SV8"),
sizeof(MPCContext),
return dts;
}
-AVInputFormat mpegps_demuxer = {
+AVInputFormat ff_mpegps_demuxer = {
"mpeg",
NULL_IF_CONFIG_SMALL("MPEG-PS format"),
sizeof(MpegDemuxContext),
} MpegMuxContext;
-extern AVOutputFormat mpeg1vcd_muxer;
-extern AVOutputFormat mpeg2dvd_muxer;
-extern AVOutputFormat mpeg2svcd_muxer;
-extern AVOutputFormat mpeg2vob_muxer;
+extern AVOutputFormat ff_mpeg1vcd_muxer;
+extern AVOutputFormat ff_mpeg2dvd_muxer;
+extern AVOutputFormat ff_mpeg2svcd_muxer;
+extern AVOutputFormat ff_mpeg2vob_muxer;
static int put_pack_header(AVFormatContext *ctx,
uint8_t *buf, int64_t timestamp)
int video_bitrate;
s->packet_number = 0;
- s->is_vcd = (CONFIG_MPEG1VCD_MUXER && ctx->oformat == &mpeg1vcd_muxer);
- s->is_svcd = (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &mpeg2svcd_muxer);
- s->is_mpeg2 = ((CONFIG_MPEG2VOB_MUXER && ctx->oformat == &mpeg2vob_muxer) ||
- (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &mpeg2dvd_muxer) ||
- (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &mpeg2svcd_muxer));
- s->is_dvd = (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &mpeg2dvd_muxer);
+ s->is_vcd = (CONFIG_MPEG1VCD_MUXER && ctx->oformat == &ff_mpeg1vcd_muxer);
+ s->is_svcd = (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer);
+ s->is_mpeg2 = ((CONFIG_MPEG2VOB_MUXER && ctx->oformat == &ff_mpeg2vob_muxer) ||
+ (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer) ||
+ (CONFIG_MPEG2SVCD_MUXER && ctx->oformat == &ff_mpeg2svcd_muxer));
+ s->is_dvd = (CONFIG_MPEG2DVD_MUXER && ctx->oformat == &ff_mpeg2dvd_muxer);
if(ctx->packet_size) {
if (ctx->packet_size < 20 || ctx->packet_size > (1 << 23) + 10) {
}
#if CONFIG_MPEG1SYSTEM_MUXER
-AVOutputFormat mpeg1system_muxer = {
+AVOutputFormat ff_mpeg1system_muxer = {
"mpeg",
NULL_IF_CONFIG_SMALL("MPEG-1 System format"),
"video/mpeg",
};
#endif
#if CONFIG_MPEG1VCD_MUXER
-AVOutputFormat mpeg1vcd_muxer = {
+AVOutputFormat ff_mpeg1vcd_muxer = {
"vcd",
NULL_IF_CONFIG_SMALL("MPEG-1 System format (VCD)"),
"video/mpeg",
};
#endif
#if CONFIG_MPEG2VOB_MUXER
-AVOutputFormat mpeg2vob_muxer = {
+AVOutputFormat ff_mpeg2vob_muxer = {
"vob",
NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
"video/mpeg",
/* Same as mpeg2vob_mux except that the pack size is 2324 */
#if CONFIG_MPEG2SVCD_MUXER
-AVOutputFormat mpeg2svcd_muxer = {
+AVOutputFormat ff_mpeg2svcd_muxer = {
"svcd",
NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
"video/mpeg",
/* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
#if CONFIG_MPEG2DVD_MUXER
-AVOutputFormat mpeg2dvd_muxer = {
+AVOutputFormat ff_mpeg2dvd_muxer = {
"dvd",
NULL_IF_CONFIG_SMALL("MPEG-2 PS format (DVD VOB)"),
"video/mpeg",
uint8_t *buffer;
} PESContext;
-extern AVInputFormat mpegts_demuxer;
+extern AVInputFormat ff_mpegts_demuxer;
static void clear_program(MpegTSContext *ts, unsigned int programid)
{
ts->stream = s;
ts->auto_guess = 0;
- if (s->iformat == &mpegts_demuxer) {
+ if (s->iformat == &ff_mpegts_demuxer) {
/* normal demux */
/* first do a scaning to get all the services */
av_free(ts);
}
-AVInputFormat mpegts_demuxer = {
+AVInputFormat ff_mpegts_demuxer = {
"mpegts",
NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
sizeof(MpegTSContext),
#endif
};
-AVInputFormat mpegtsraw_demuxer = {
+AVInputFormat ff_mpegtsraw_demuxer = {
"mpegtsraw",
NULL_IF_CONFIG_SMALL("MPEG-2 raw transport stream format"),
sizeof(MpegTSContext),
return 0;
}
-AVOutputFormat mpegts_muxer = {
+AVOutputFormat ff_mpegts_muxer = {
"mpegts",
NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
"video/x-mpegts",
return 0;
}
-AVInputFormat mpegvideo_demuxer = {
+AVInputFormat ff_mpegvideo_demuxer = {
"mpegvideo",
NULL_IF_CONFIG_SMALL("raw MPEG video"),
0,
return 0;
}
-AVOutputFormat mpjpeg_muxer = {
+AVOutputFormat ff_mpjpeg_muxer = {
"mpjpeg",
NULL_IF_CONFIG_SMALL("MIME multipart JPEG format"),
"multipart/x-mixed-replace;boundary=" BOUNDARY_TAG,
return HEADER_SIZE + size;
}
-AVInputFormat msnwc_tcp_demuxer = {
+AVInputFormat ff_msnwc_tcp_demuxer = {
"msnwctcp",
NULL_IF_CONFIG_SMALL("MSN TCP Webcam stream"),
0,
return ret;
}
-AVInputFormat mtv_demuxer = {
+AVInputFormat ff_mtv_demuxer = {
"MTV",
NULL_IF_CONFIG_SMALL("MTV format"),
sizeof(MTVDemuxContext),
return 0;
}
-AVInputFormat mvi_demuxer = {
+AVInputFormat ff_mvi_demuxer = {
"mvi",
NULL_IF_CONFIG_SMALL("Motion Pixels MVI format"),
sizeof(MviDemuxContext),
return 0;
}
-AVInputFormat mxf_demuxer = {
+AVInputFormat ff_mxf_demuxer = {
"mxf",
NULL_IF_CONFIG_SMALL("Material eXchange Format"),
sizeof(MXFContext),
static const int NTSC_samples_per_frame[] = { 1602, 1601, 1602, 1601, 1602, 0 };
static const int PAL_samples_per_frame[] = { 1920, 0 };
-extern AVOutputFormat mxf_d10_muxer;
+extern AVOutputFormat ff_mxf_d10_muxer;
#define EDIT_UNITS_PER_BODY 250
#define KAG_SIZE 512
}
}
}
- if (s->oformat != &mxf_d10_muxer)
+ if (s->oformat != &ff_mxf_d10_muxer)
sc->codec_ul = mxf_get_mpeg2_codec_ul(st->codec);
return !!sc->codec_ul;
}
return -1;
}
av_set_pts_info(st, 64, mxf->time_base.num, mxf->time_base.den);
- if (s->oformat == &mxf_d10_muxer) {
+ if (s->oformat == &ff_mxf_d10_muxer) {
if (st->codec->bit_rate == 50000000)
if (mxf->time_base.den == 25) sc->index = 3;
else sc->index = 5;
return -1;
}
av_set_pts_info(st, 64, 1, st->codec->sample_rate);
- if (s->oformat == &mxf_d10_muxer) {
+ if (s->oformat == &ff_mxf_d10_muxer) {
if (st->index != 1) {
av_log(s, AV_LOG_ERROR, "MXF D-10 only support one audio track\n");
return -1;
present[sc->index]++;
}
- if (s->oformat == &mxf_d10_muxer) {
+ if (s->oformat == &ff_mxf_d10_muxer) {
mxf->essence_container_count = 1;
}
mxf_write_klv_fill(s);
put_buffer(pb, sc->track_essence_element_key, 16); // write key
- if (s->oformat == &mxf_d10_muxer) {
+ if (s->oformat == &ff_mxf_d10_muxer) {
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
mxf_write_d10_video_packet(s, st, pkt);
else
mxf_interleave_get_packet, mxf_compare_timestamps);
}
-AVOutputFormat mxf_muxer = {
+AVOutputFormat ff_mxf_muxer = {
"mxf",
NULL_IF_CONFIG_SMALL("Material eXchange Format"),
"application/mxf",
mxf_interleave,
};
-AVOutputFormat mxf_d10_muxer = {
+AVOutputFormat ff_mxf_d10_muxer = {
"mxf_d10",
NULL_IF_CONFIG_SMALL("Material eXchange Format, D-10 Mapping"),
"application/mxf",
return 0;
}
-AVInputFormat mxg_demuxer = {
+AVInputFormat ff_mxg_demuxer = {
.name = "mxg",
.long_name = NULL_IF_CONFIG_SMALL("MxPEG clip file format"),
.priv_data_size = sizeof(MXGContext),
return size;
}
-AVInputFormat nc_demuxer = {
+AVInputFormat ff_nc_demuxer = {
"nc",
NULL_IF_CONFIG_SMALL("NC camera feed format"),
0,
return 0;
}
-AVInputFormat nsv_demuxer = {
+AVInputFormat ff_nsv_demuxer = {
"nsv",
NULL_IF_CONFIG_SMALL("Nullsoft Streaming Video"),
sizeof(NSVContext),
return 0;
}
-AVOutputFormat null_muxer = {
+AVOutputFormat ff_null_muxer = {
"null",
NULL_IF_CONFIG_SMALL("raw null video format"),
NULL,
}
#if CONFIG_NUT_DEMUXER
-AVInputFormat nut_demuxer = {
+AVInputFormat ff_nut_demuxer = {
"nut",
NULL_IF_CONFIG_SMALL("NUT format"),
sizeof(NUTContext),
return 0;
}
-AVOutputFormat nut_muxer = {
+AVOutputFormat ff_nut_muxer = {
"nut",
NULL_IF_CONFIG_SMALL("NUT format"),
"video/x-nut",
return AVERROR(EIO);
}
-AVInputFormat nuv_demuxer = {
+AVInputFormat ff_nuv_demuxer = {
"nuv",
NULL_IF_CONFIG_SMALL("NuppelVideo format"),
sizeof(NUVContext),
return 0;
}
-AVInputFormat ogg_demuxer = {
+AVInputFormat ff_ogg_demuxer = {
"ogg",
NULL_IF_CONFIG_SMALL("Ogg"),
sizeof (struct ogg),
return 0;
}
-AVOutputFormat ogg_muxer = {
+AVOutputFormat ff_ogg_muxer = {
"ogg",
NULL_IF_CONFIG_SMALL("Ogg"),
"application/ogg",
}
-AVInputFormat oma_demuxer = {
+AVInputFormat ff_oma_demuxer = {
"oma",
NULL_IF_CONFIG_SMALL("Sony OpenMG audio"),
0,
}
#define PCMDEF(name, long_name, ext, codec) \
-AVInputFormat pcm_ ## name ## _demuxer = {\
+AVInputFormat ff_pcm_ ## name ## _demuxer = {\
#name,\
NULL_IF_CONFIG_SMALL(long_name),\
0,\
#include "rawenc.h"
#define PCMDEF(name, long_name, ext, codec) \
-AVOutputFormat pcm_ ## name ## _muxer = {\
+AVOutputFormat ff_pcm_ ## name ## _muxer = {\
#name,\
NULL_IF_CONFIG_SMALL(long_name),\
NULL,\
return 0;
}
-AVInputFormat str_demuxer = {
+AVInputFormat ff_str_demuxer = {
"psxstr",
NULL_IF_CONFIG_SMALL("Sony Playstation STR format"),
sizeof(StrDemuxContext),
return res;
}
-AVInputFormat pva_demuxer = {
+AVInputFormat ff_pva_demuxer = {
"pva",
NULL_IF_CONFIG_SMALL("TechnoTrend PVA file and stream format"),
sizeof(PVAContext),
return AVERROR_EOF;
}
-AVInputFormat qcp_demuxer = {
+AVInputFormat ff_qcp_demuxer = {
.name = "qcp",
.long_name = NULL_IF_CONFIG_SMALL("QCP format"),
.priv_data_size = sizeof(QCPContext),
return 0;
}
-AVInputFormat r3d_demuxer = {
+AVInputFormat ff_r3d_demuxer = {
"r3d",
NULL_IF_CONFIG_SMALL("REDCODE R3D format"),
sizeof(R3DContext),
/* Note: Do not forget to add new entries to the Makefile as well. */
#if CONFIG_G722_DEMUXER
-AVInputFormat g722_demuxer = {
+AVInputFormat ff_g722_demuxer = {
"g722",
NULL_IF_CONFIG_SMALL("raw G.722"),
0,
#endif
#if CONFIG_GSM_DEMUXER
-AVInputFormat gsm_demuxer = {
+AVInputFormat ff_gsm_demuxer = {
"gsm",
NULL_IF_CONFIG_SMALL("raw GSM"),
0,
#endif
#if CONFIG_MJPEG_DEMUXER
-AVInputFormat mjpeg_demuxer = {
+AVInputFormat ff_mjpeg_demuxer = {
"mjpeg",
NULL_IF_CONFIG_SMALL("raw MJPEG video"),
0,
#endif
#if CONFIG_MLP_DEMUXER
-AVInputFormat mlp_demuxer = {
+AVInputFormat ff_mlp_demuxer = {
"mlp",
NULL_IF_CONFIG_SMALL("raw MLP"),
0,
#endif
#if CONFIG_TRUEHD_DEMUXER
-AVInputFormat truehd_demuxer = {
+AVInputFormat ff_truehd_demuxer = {
"truehd",
NULL_IF_CONFIG_SMALL("raw TrueHD"),
0,
#endif
#if CONFIG_SHORTEN_DEMUXER
-AVInputFormat shorten_demuxer = {
+AVInputFormat ff_shorten_demuxer = {
"shn",
NULL_IF_CONFIG_SMALL("raw Shorten"),
0,
#endif
#if CONFIG_VC1_DEMUXER
-AVInputFormat vc1_demuxer = {
+AVInputFormat ff_vc1_demuxer = {
"vc1",
NULL_IF_CONFIG_SMALL("raw VC-1"),
0,
/* Note: Do not forget to add new entries to the Makefile as well. */
#if CONFIG_AC3_MUXER
-AVOutputFormat ac3_muxer = {
+AVOutputFormat ff_ac3_muxer = {
"ac3",
NULL_IF_CONFIG_SMALL("raw AC-3"),
"audio/x-ac3",
#endif
#if CONFIG_DIRAC_MUXER
-AVOutputFormat dirac_muxer = {
+AVOutputFormat ff_dirac_muxer = {
"dirac",
NULL_IF_CONFIG_SMALL("raw Dirac"),
NULL,
#endif
#if CONFIG_DNXHD_MUXER
-AVOutputFormat dnxhd_muxer = {
+AVOutputFormat ff_dnxhd_muxer = {
"dnxhd",
NULL_IF_CONFIG_SMALL("raw DNxHD (SMPTE VC-3)"),
NULL,
#endif
#if CONFIG_DTS_MUXER
-AVOutputFormat dts_muxer = {
+AVOutputFormat ff_dts_muxer = {
"dts",
NULL_IF_CONFIG_SMALL("raw DTS"),
"audio/x-dca",
#endif
#if CONFIG_EAC3_MUXER
-AVOutputFormat eac3_muxer = {
+AVOutputFormat ff_eac3_muxer = {
"eac3",
NULL_IF_CONFIG_SMALL("raw E-AC-3"),
"audio/x-eac3",
#endif
#if CONFIG_G722_MUXER
-AVOutputFormat g722_muxer = {
+AVOutputFormat ff_g722_muxer = {
"g722",
NULL_IF_CONFIG_SMALL("raw G.722"),
"audio/G722",
#endif
#if CONFIG_H261_MUXER
-AVOutputFormat h261_muxer = {
+AVOutputFormat ff_h261_muxer = {
"h261",
NULL_IF_CONFIG_SMALL("raw H.261"),
"video/x-h261",
#endif
#if CONFIG_H263_MUXER
-AVOutputFormat h263_muxer = {
+AVOutputFormat ff_h263_muxer = {
"h263",
NULL_IF_CONFIG_SMALL("raw H.263"),
"video/x-h263",
#endif
#if CONFIG_H264_MUXER
-AVOutputFormat h264_muxer = {
+AVOutputFormat ff_h264_muxer = {
"h264",
NULL_IF_CONFIG_SMALL("raw H.264 video format"),
NULL,
#endif
#if CONFIG_CAVSVIDEO_MUXER
-AVOutputFormat cavsvideo_muxer = {
+AVOutputFormat ff_cavsvideo_muxer = {
"cavsvideo",
NULL_IF_CONFIG_SMALL("raw Chinese AVS video"),
NULL,
#endif
#if CONFIG_M4V_MUXER
-AVOutputFormat m4v_muxer = {
+AVOutputFormat ff_m4v_muxer = {
"m4v",
NULL_IF_CONFIG_SMALL("raw MPEG-4 video format"),
NULL,
#endif
#if CONFIG_MJPEG_MUXER
-AVOutputFormat mjpeg_muxer = {
+AVOutputFormat ff_mjpeg_muxer = {
"mjpeg",
NULL_IF_CONFIG_SMALL("raw MJPEG video"),
"video/x-mjpeg",
#endif
#if CONFIG_MLP_MUXER
-AVOutputFormat mlp_muxer = {
+AVOutputFormat ff_mlp_muxer = {
"mlp",
NULL_IF_CONFIG_SMALL("raw MLP"),
NULL,
#endif
#if CONFIG_SRT_MUXER
-AVOutputFormat srt_muxer = {
+AVOutputFormat ff_srt_muxer = {
.name = "srt",
.long_name = NULL_IF_CONFIG_SMALL("SubRip subtitle format"),
.mime_type = "application/x-subrip",
#endif
#if CONFIG_TRUEHD_MUXER
-AVOutputFormat truehd_muxer = {
+AVOutputFormat ff_truehd_muxer = {
"truehd",
NULL_IF_CONFIG_SMALL("raw TrueHD"),
NULL,
#endif
#if CONFIG_MPEG1VIDEO_MUXER
-AVOutputFormat mpeg1video_muxer = {
+AVOutputFormat ff_mpeg1video_muxer = {
"mpeg1video",
NULL_IF_CONFIG_SMALL("raw MPEG-1 video"),
"video/x-mpeg",
#endif
#if CONFIG_MPEG2VIDEO_MUXER
-AVOutputFormat mpeg2video_muxer = {
+AVOutputFormat ff_mpeg2video_muxer = {
"mpeg2video",
NULL_IF_CONFIG_SMALL("raw MPEG-2 video"),
NULL,
#endif
#if CONFIG_RAWVIDEO_MUXER
-AVOutputFormat rawvideo_muxer = {
+AVOutputFormat ff_rawvideo_muxer = {
"rawvideo",
NULL_IF_CONFIG_SMALL("raw video format"),
NULL,
return 0;
}
-AVInputFormat rawvideo_demuxer = {
+AVInputFormat ff_rawvideo_demuxer = {
"rawvideo",
NULL_IF_CONFIG_SMALL("raw video format"),
0,
{
PayloadContext *rdt = av_mallocz(sizeof(PayloadContext));
- av_open_input_stream(&rdt->rmctx, NULL, "", &rdt_demuxer, NULL);
+ av_open_input_stream(&rdt->rmctx, NULL, "", &ff_rdt_demuxer, NULL);
return rdt;
}
return 0;
}
-AVInputFormat rl2_demuxer = {
+AVInputFormat ff_rl2_demuxer = {
"rl2",
NULL_IF_CONFIG_SMALL("RL2 format"),
sizeof(Rl2DemuxContext),
void ff_rm_free_rmstream (RMStream *rms);
/*< input format for Realmedia-style RTSP streams */
-extern AVInputFormat rdt_demuxer;
+extern AVInputFormat ff_rdt_demuxer;
/**
* Read the MDPR chunk, which contains stream-specific codec initialization
return dts;
}
-AVInputFormat rm_demuxer = {
+AVInputFormat ff_rm_demuxer = {
"rm",
NULL_IF_CONFIG_SMALL("RealMedia format"),
sizeof(RMDemuxContext),
rm_read_dts,
};
-AVInputFormat rdt_demuxer = {
+AVInputFormat ff_rdt_demuxer = {
"rdt",
NULL_IF_CONFIG_SMALL("RDT demuxer"),
sizeof(RMDemuxContext),
}
-AVOutputFormat rm_muxer = {
+AVOutputFormat ff_rm_muxer = {
"rm",
NULL_IF_CONFIG_SMALL("RealMedia format"),
"application/vnd.rn-realmedia",
return ret;
}
-AVInputFormat rpl_demuxer = {
+AVInputFormat ff_rpl_demuxer = {
"rpl",
NULL_IF_CONFIG_SMALL("RPL/ARMovie format"),
sizeof(RPLContext),
return 0;
}
-AVInputFormat rso_demuxer = {
+AVInputFormat ff_rso_demuxer = {
.name = "rso",
.long_name = NULL_IF_CONFIG_SMALL("Lego Mindstorms RSO format"),
.extensions = "rso",
return 0;
}
-AVOutputFormat rso_muxer = {
+AVOutputFormat ff_rso_muxer = {
.name = "rso",
.long_name = NULL_IF_CONFIG_SMALL("Lego Mindstorms RSO format"),
.extensions = "rso",
return size;
}
-URLProtocol rtmp_protocol = {
+URLProtocol ff_rtmp_protocol = {
"rtmp",
rtmp_open,
rtmp_read,
av_close_input_stream(rt->asf_ctx);
rt->asf_ctx = NULL;
}
- ret = av_open_input_stream(&rt->asf_ctx, &pb, "", &asf_demuxer, NULL);
+ ret = av_open_input_stream(&rt->asf_ctx, &pb, "", &ff_asf_demuxer, NULL);
if (ret < 0)
return ret;
av_metadata_copy(&s->metadata, rt->asf_ctx->metadata, 0);
return 0;
}
-AVOutputFormat rtp_muxer = {
+AVOutputFormat ff_rtp_muxer = {
"rtp",
NULL_IF_CONFIG_SMALL("RTP output format"),
NULL,
return s->rtcp_fd;
}
-URLProtocol rtp_protocol = {
+URLProtocol ff_rtp_protocol = {
"rtp",
rtp_open,
rtp_read,
return 0;
}
-AVInputFormat sdp_demuxer = {
+AVInputFormat ff_sdp_demuxer = {
"sdp",
NULL_IF_CONFIG_SMALL("SDP"),
sizeof(RTSPState),
return ret;
}
-AVInputFormat rtp_demuxer = {
+AVInputFormat ff_rtp_demuxer = {
"rtp",
NULL_IF_CONFIG_SMALL("RTP input format"),
sizeof(RTSPState),
return 0;
}
-AVInputFormat rtsp_demuxer = {
+AVInputFormat ff_rtsp_demuxer = {
"rtsp",
NULL_IF_CONFIG_SMALL("RTSP input format"),
sizeof(RTSPState),
return 0;
}
-AVOutputFormat rtsp_muxer = {
+AVOutputFormat ff_rtsp_muxer = {
"rtsp",
NULL_IF_CONFIG_SMALL("RTSP output format"),
NULL,
return ret;
}
-AVInputFormat sap_demuxer = {
+AVInputFormat ff_sap_demuxer = {
"sap",
NULL_IF_CONFIG_SMALL("SAP input format"),
sizeof(struct SAPState),
return ff_write_chained(rtpctx, 0, pkt, s);
}
-AVOutputFormat sap_muxer = {
+AVOutputFormat ff_sap_muxer = {
"sap",
NULL_IF_CONFIG_SMALL("SAP output format"),
NULL,
return 0;
}
-AVInputFormat segafilm_demuxer = {
+AVInputFormat ff_segafilm_demuxer = {
"film_cpk",
NULL_IF_CONFIG_SMALL("Sega FILM/CPK format"),
sizeof(FilmDemuxContext),
return 0;
}
-AVInputFormat vmd_demuxer = {
+AVInputFormat ff_vmd_demuxer = {
"vmd",
NULL_IF_CONFIG_SMALL("Sierra VMD format"),
sizeof(VmdDemuxContext),
return pkt->size;
}
-AVInputFormat siff_demuxer = {
+AVInputFormat ff_siff_demuxer = {
"siff",
NULL_IF_CONFIG_SMALL("Beam Software SIFF"),
sizeof(SIFFContext),
return 0;
}
-AVInputFormat smacker_demuxer = {
+AVInputFormat ff_smacker_demuxer = {
"smk",
NULL_IF_CONFIG_SMALL("Smacker video"),
sizeof(SmackerContext),
return 0;
}
-AVInputFormat sol_demuxer = {
+AVInputFormat ff_sol_demuxer = {
"sol",
NULL_IF_CONFIG_SMALL("Sierra SOL format"),
0,
return 0;
}
-AVInputFormat sox_demuxer = {
+AVInputFormat ff_sox_demuxer = {
"sox",
NULL_IF_CONFIG_SMALL("SoX native format"),
0,
return 0;
}
-AVOutputFormat sox_muxer = {
+AVOutputFormat ff_sox_muxer = {
"sox",
NULL_IF_CONFIG_SMALL("SoX native format"),
NULL,
return 0;
}
-AVInputFormat spdif_demuxer = {
+AVInputFormat ff_spdif_demuxer = {
"spdif",
NULL_IF_CONFIG_SMALL("IEC 61937 (compressed data in S/PDIF)"),
0,
return 0;
}
-AVOutputFormat spdif_muxer = {
+AVOutputFormat ff_spdif_muxer = {
"spdif",
NULL_IF_CONFIG_SMALL("IEC 61937 (used on S/PDIF - IEC958)"),
NULL,
return res;
}
-AVInputFormat srt_demuxer = {
+AVInputFormat ff_srt_demuxer = {
.name = "srt",
.long_name = NULL_IF_CONFIG_SMALL("SubRip subtitle format"),
.read_probe = srt_probe,
return 0;
}
-AVInputFormat swf_demuxer = {
+AVInputFormat ff_swf_demuxer = {
"swf",
NULL_IF_CONFIG_SMALL("Flash format"),
sizeof(SWFContext),
}
#if CONFIG_SWF_MUXER
-AVOutputFormat swf_muxer = {
+AVOutputFormat ff_swf_muxer = {
"swf",
NULL_IF_CONFIG_SMALL("Flash format"),
"application/x-shockwave-flash",
};
#endif
#if CONFIG_AVM2_MUXER
-AVOutputFormat avm2_muxer = {
+AVOutputFormat ff_avm2_muxer = {
"avm2",
NULL_IF_CONFIG_SMALL("Flash 9 (AVM2) format"),
"application/x-shockwave-flash",
return s->fd;
}
-URLProtocol tcp_protocol = {
+URLProtocol ff_tcp_protocol = {
"tcp",
tcp_open,
tcp_read,
return 0;
}
-AVInputFormat thp_demuxer = {
+AVInputFormat ff_thp_demuxer = {
"thp",
NULL_IF_CONFIG_SMALL("THP"),
sizeof(ThpDemuxContext),
return 0;
}
-AVInputFormat tiertexseq_demuxer = {
+AVInputFormat ff_tiertexseq_demuxer = {
"tiertexseq",
NULL_IF_CONFIG_SMALL("Tiertex Limited SEQ format"),
sizeof(SeqDemuxContext),
return 0;
}
-AVInputFormat tmv_demuxer = {
+AVInputFormat ff_tmv_demuxer = {
"tmv",
NULL_IF_CONFIG_SMALL("8088flex TMV"),
sizeof(TMVContext),
return 0;
}
-AVInputFormat tta_demuxer = {
+AVInputFormat ff_tta_demuxer = {
"tta",
NULL_IF_CONFIG_SMALL("True Audio"),
sizeof(TTAContext),
return 0;
}
-AVInputFormat tty_demuxer = {
+AVInputFormat ff_tty_demuxer = {
.name = "tty",
.long_name = NULL_IF_CONFIG_SMALL("Tele-typewriter"),
.priv_data_size = sizeof(TtyDemuxContext),
return 0;
}
-AVInputFormat txd_demuxer =
+AVInputFormat ff_txd_demuxer =
{
"txd",
NULL_IF_CONFIG_SMALL("Renderware TeXture Dictionary"),
return 0;
}
-URLProtocol udp_protocol = {
+URLProtocol ff_udp_protocol = {
"udp",
udp_open,
udp_read,
return pkt->size;
}
-AVInputFormat vc1t_demuxer = {
+AVInputFormat ff_vc1t_demuxer = {
"vc1test",
NULL_IF_CONFIG_SMALL("VC-1 test bitstream format"),
0,
return 0;
}
-AVOutputFormat vc1t_muxer = {
+AVOutputFormat ff_vc1t_muxer = {
"rcv",
NULL_IF_CONFIG_SMALL("VC-1 test bitstream"),
"",
return voc_get_packet(s, pkt, s->streams[0], 0);
}
-AVInputFormat voc_demuxer = {
+AVInputFormat ff_voc_demuxer = {
"voc",
NULL_IF_CONFIG_SMALL("Creative Voice file format"),
sizeof(VocDecContext),
return 0;
}
-AVOutputFormat voc_muxer = {
+AVOutputFormat ff_voc_muxer = {
"voc",
NULL_IF_CONFIG_SMALL("Creative Voice file format"),
"audio/x-voc",
return 0;
}
-AVInputFormat vqf_demuxer = {
+AVInputFormat ff_vqf_demuxer = {
"vqf",
NULL_IF_CONFIG_SMALL("Nippon Telegraph and Telephone Corporation (NTT) TwinVQ"),
sizeof(VqfContext),
return 0;
}
-AVOutputFormat wav_muxer = {
+AVOutputFormat ff_wav_muxer = {
"wav",
NULL_IF_CONFIG_SMALL("WAV format"),
"audio/x-wav",
return pcm_read_seek(s, stream_index, timestamp, flags);
}
-AVInputFormat wav_demuxer = {
+AVInputFormat ff_wav_demuxer = {
"wav",
NULL_IF_CONFIG_SMALL("WAV format"),
sizeof(WAVContext),
return 0;
}
-AVInputFormat w64_demuxer = {
+AVInputFormat ff_w64_demuxer = {
"w64",
NULL_IF_CONFIG_SMALL("Sony Wave64 format"),
sizeof(WAVContext),
return 0;
}
-AVInputFormat wc3_demuxer = {
+AVInputFormat ff_wc3_demuxer = {
"wc3movie",
NULL_IF_CONFIG_SMALL("Wing Commander III movie format"),
sizeof(Wc3DemuxContext),
}
#if CONFIG_WSAUD_DEMUXER
-AVInputFormat wsaud_demuxer = {
+AVInputFormat ff_wsaud_demuxer = {
"wsaud",
NULL_IF_CONFIG_SMALL("Westwood Studios audio format"),
sizeof(WsAudDemuxContext),
};
#endif
#if CONFIG_WSVQA_DEMUXER
-AVInputFormat wsvqa_demuxer = {
+AVInputFormat ff_wsvqa_demuxer = {
"wsvqa",
NULL_IF_CONFIG_SMALL("Westwood Studios VQA format"),
sizeof(WsVqaDemuxContext),
}
}
-AVInputFormat wtv_demuxer = {
+AVInputFormat ff_wtv_demuxer = {
.name = "wtv",
.long_name = NULL_IF_CONFIG_SMALL("Windows Television (WTV)"),
.priv_data_size = sizeof(WtvContext),
return 0;
}
-AVInputFormat wv_demuxer = {
+AVInputFormat ff_wv_demuxer = {
"wv",
NULL_IF_CONFIG_SMALL("WavPack"),
sizeof(WVContext),
return ret;
}
-AVInputFormat xa_demuxer = {
+AVInputFormat ff_xa_demuxer = {
"xa",
NULL_IF_CONFIG_SMALL("Maxis XA File Format"),
sizeof(MaxisXADemuxContext),
return 0;
}
-AVInputFormat yop_demuxer = {
+AVInputFormat ff_yop_demuxer = {
"yop",
NULL_IF_CONFIG_SMALL("Psygnosis YOP Format"),
sizeof(YopDecContext),
return 0;
}
-AVOutputFormat yuv4mpegpipe_muxer = {
+AVOutputFormat ff_yuv4mpegpipe_muxer = {
"yuv4mpegpipe",
NULL_IF_CONFIG_SMALL("YUV4MPEG pipe format"),
"",
}
#if CONFIG_YUV4MPEGPIPE_DEMUXER
-AVInputFormat yuv4mpegpipe_demuxer = {
+AVInputFormat ff_yuv4mpegpipe_demuxer = {
"yuv4mpegpipe",
NULL_IF_CONFIG_SMALL("YUV4MPEG pipe format"),
sizeof(struct frame_attributes),
projects / ffmpeg / commitdiff