}
is->ic = ic;
#ifdef CONFIG_NETWORK
- use_play = (ic->iformat == &rtsp_demux);
+ use_play = (ic->iformat == &rtsp_demuxer);
#else
use_play = 0;
#endif
else
av_read_play(ic);
}
- if (is->paused && ic->iformat == &rtsp_demux) {
+ if (is->paused && ic->iformat == &rtsp_demuxer) {
/* wait 10 ms to avoid trying to get another packet */
/* XXX: horrible */
SDL_Delay(10);
strcpy(eosf - 4, ".asx");
} else if (strcmp(eosf - 3, ".rm") == 0) {
strcpy(eosf - 3, ".ram");
- } else if (stream->fmt == &rtp_mux) {
+ } else if (stream->fmt == &rtp_muxer) {
/* generate a sample RTSP director if
unicast. Generate an SDP redirector if
multicast */
path++;
for(stream = first_stream; stream != NULL; stream = stream->next) {
- if (!stream->is_feed && stream->fmt == &rtp_mux &&
+ if (!stream->is_feed && stream->fmt == &rtp_muxer &&
!strcmp(path, stream->filename)) {
goto found;
}
/* now check each stream */
for(stream = first_stream; stream != NULL; stream = stream->next) {
- if (!stream->is_feed && stream->fmt == &rtp_mux) {
+ if (!stream->is_feed && stream->fmt == &rtp_muxer) {
/* accept aggregate filenames only if single stream */
if (!strcmp(path, stream->filename)) {
if (stream->nb_streams != 1) {
ctx = av_alloc_format_context();
if (!ctx)
return -1;
- ctx->oformat = &rtp_mux;
+ ctx->oformat = &rtp_muxer;
st = av_mallocz(sizeof(AVStream));
if (!st)
/* try to open the file */
/* open stream */
stream->ap_in = av_mallocz(sizeof(AVFormatParameters));
- if (stream->fmt == &rtp_mux) {
+ if (stream->fmt == &rtp_muxer) {
/* specific case : if transport stream output to RTP,
we use a raw transport stream reader */
stream->ap_in->mpeg2ts_raw = 1;
return 0;
}
-static AVInputFormat fourxm_iformat = {
+static AVInputFormat fourxm_demuxer = {
"4xm",
"4X Technologies format",
sizeof(FourxmDemuxContext),
int fourxm_init(void)
{
- av_register_input_format(&fourxm_iformat);
+ av_register_input_format(&fourxm_demuxer);
return 0;
}
return 0;
}
-static AVOutputFormat adts_oformat = {
+static AVOutputFormat adts_muxer = {
"adts",
"ADTS AAC",
"audio/aac",
int ff_adts_init(void)
{
- av_register_output_format(&adts_oformat);
+ av_register_output_format(&adts_muxer);
return 0;
}
}
-static AVInputFormat aiff_iformat = {
+static AVInputFormat aiff_demuxer = {
"aiff",
"Audio IFF",
0,
};
#ifdef CONFIG_MUXERS
-static AVOutputFormat aiff_oformat = {
+static AVOutputFormat aiff_muxer = {
"aiff",
"Audio IFF",
"audio/aiff",
int ff_aiff_init(void)
{
- av_register_input_format(&aiff_iformat);
+ av_register_input_format(&aiff_demuxer);
#ifdef CONFIG_MUXERS
- av_register_output_format(&aiff_oformat);
+ av_register_output_format(&aiff_muxer);
#endif //CONFIG_MUXERS
return 0;
}
#define ALLFORMATS_H
/* mpeg.c */
-extern AVInputFormat mpegps_demux;
+extern AVInputFormat mpegps_demuxer;
int mpegps_init(void);
/* mpegts.c */
-extern AVInputFormat mpegts_demux;
+extern AVInputFormat mpegts_demuxer;
int mpegts_init(void);
/* rm.c */
int ffm_init(void);
/* rtsp.c */
-extern AVInputFormat redir_demux;
+extern AVInputFormat redir_demuxer;
int redir_open(AVFormatContext **ic_ptr, ByteIOContext *f);
/* 4xm.c */
return 0;
}
-static AVInputFormat amr_iformat = {
+static AVInputFormat amr_demuxer = {
"amr",
"3gpp amr file format",
0, /*priv_data_size*/
};
#ifdef CONFIG_MUXERS
-static AVOutputFormat amr_oformat = {
+static AVOutputFormat amr_muxer = {
"amr",
"3gpp amr file format",
"audio/amr",
int amr_init(void)
{
- av_register_input_format(&amr_iformat);
+ av_register_input_format(&amr_demuxer);
#ifdef CONFIG_MUXERS
- av_register_output_format(&amr_oformat);
+ av_register_output_format(&amr_muxer);
#endif
return 0;
}
return 0;
}
-AVOutputFormat asf_oformat = {
+AVOutputFormat asf_muxer = {
"asf",
"asf format",
"video/x-ms-asf",
.flags = AVFMT_GLOBALHEADER,
};
-AVOutputFormat asf_stream_oformat = {
+AVOutputFormat asf_stream_muxer = {
"asf_stream",
"asf format",
"video/x-ms-asf",
return 0;
}
-static AVInputFormat asf_iformat = {
+static AVInputFormat asf_demuxer = {
"asf",
"asf format",
sizeof(ASFContext),
};
#ifdef CONFIG_MUXERS
- extern AVOutputFormat asf_oformat;
- extern AVOutputFormat asf_stream_oformat;
+ extern AVOutputFormat asf_muxer;
+ extern AVOutputFormat asf_stream_muxer;
#endif //CONFIG_MUXERS
int asf_init(void)
{
- av_register_input_format(&asf_iformat);
+ av_register_input_format(&asf_demuxer);
#ifdef CONFIG_MUXERS
- av_register_output_format(&asf_oformat);
- av_register_output_format(&asf_stream_oformat);
+ av_register_output_format(&asf_muxer);
+ av_register_output_format(&asf_stream_muxer);
#endif //CONFIG_MUXERS
return 0;
}
return 0;
}
-static AVInputFormat au_iformat = {
+static AVInputFormat au_demuxer = {
"au",
"SUN AU Format",
0,
};
#ifdef CONFIG_MUXERS
-static AVOutputFormat au_oformat = {
+static AVOutputFormat au_muxer = {
"au",
"SUN AU Format",
"audio/basic",
int au_init(void)
{
- av_register_input_format(&au_iformat);
+ av_register_input_format(&au_demuxer);
#ifdef CONFIG_MUXERS
- av_register_output_format(&au_oformat);
+ av_register_output_format(&au_muxer);
#endif //CONFIG_MUXERS
return 0;
}
return 0;
}
-static AVInputFormat audio_in_format = {
+static AVInputFormat audio_demuxer = {
"audio_device",
"audio grab and output",
sizeof(AudioData),
.flags = AVFMT_NOFILE,
};
-static AVOutputFormat audio_out_format = {
+static AVOutputFormat audio_muxer = {
"audio_device",
"audio grab and output",
"",
int audio_init(void)
{
- av_register_input_format(&audio_in_format);
- av_register_output_format(&audio_out_format);
+ av_register_input_format(&audio_demuxer);
+ av_register_output_format(&audio_muxer);
return 0;
}
#include "rtsp.h"
/* yuv4mpeg.c */
-extern AVOutputFormat yuv4mpegpipe_oformat;
+extern AVOutputFormat yuv4mpegpipe_muxer;
/* utils.c */
void av_register_input_format(AVInputFormat *format);
return 0;
}
-static AVInputFormat avi_iformat = {
+static AVInputFormat avi_demuxer = {
"avi",
"avi format",
sizeof(AVIContext),
int avidec_init(void)
{
- av_register_input_format(&avi_iformat);
+ av_register_input_format(&avi_demuxer);
return 0;
}
return res;
}
-static AVOutputFormat avi_oformat = {
+static AVOutputFormat avi_muxer = {
"avi",
"avi format",
"video/x-msvideo",
int avienc_init(void)
{
- av_register_output_format(&avi_oformat);
+ av_register_output_format(&avi_muxer);
return 0;
}
#endif //CONFIG_MUXERS
return 0;
}
-static AVInputFormat avs_iformat = {
+static AVInputFormat avs_demuxer = {
"avs",
"avs format",
sizeof(avs_format_t),
int avs_init(void)
{
#ifdef CONFIG_DEMUXERS
- av_register_input_format(&avs_iformat);
+ av_register_input_format(&avs_demuxer);
#endif /* CONFIG_DEMUXERS */
return 0;
}
return 0;
}
-static AVInputFormat audio_in_format = {
+static AVInputFormat audio_demuxer = {
"audio_device",
"audio grab and output",
sizeof(AudioData),
AVFMT_NOFILE,
};
-AVOutputFormat audio_out_format = {
+AVOutputFormat audio_muxer = {
"audio_device",
"audio grab and output",
"",
int audio_init(void)
{
main_thid = find_thread(NULL);
- av_register_input_format(&audio_in_format);
- av_register_output_format(&audio_out_format);
+ av_register_input_format(&audio_demuxer);
+ av_register_output_format(&audio_muxer);
return 0;
}
return 0;
}
-static AVOutputFormat crc_format = {
+static AVOutputFormat crc_muxer = {
"crc",
"crc testing format",
NULL,
crc_write_trailer,
};
-static AVOutputFormat framecrc_format = {
+static AVOutputFormat framecrc_muxer = {
"framecrc",
"framecrc testing format",
NULL,
int crc_init(void)
{
- av_register_output_format(&crc_format);
- av_register_output_format(&framecrc_format);
+ av_register_output_format(&crc_muxer);
+ av_register_output_format(&framecrc_muxer);
return 0;
}
#endif /* CONFIG_MUXERS */
return ret;
}
-static AVInputFormat daud_iformat = {
+static AVInputFormat daud_demuxer = {
"daud",
"D-Cinema audio format",
0,
int daud_init(void)
{
- av_register_input_format(&daud_iformat);
+ av_register_input_format(&daud_demuxer);
return 0;
}
return 0;
}
-static AVInputFormat dc1394_format = {
+static AVInputFormat dc1394_demuxer = {
.name = "dc1394",
.long_name = "dc1394 A/V grab",
.priv_data_size = sizeof(struct dc1394_data),
int dc1394_init(void)
{
- av_register_input_format(&dc1394_format);
+ av_register_input_format(&dc1394_demuxer);
return 0;
}
}
#endif /* CONFIG_MUXERS */
-static AVInputFormat dv_iformat = {
+static AVInputFormat dv_demuxer = {
"dv",
"DV video format",
sizeof(RawDVContext),
};
#ifdef CONFIG_MUXERS
-static AVOutputFormat dv_oformat = {
+static AVOutputFormat dv_muxer = {
"dv",
"DV video format",
NULL,
int ff_dv_init(void)
{
- av_register_input_format(&dv_iformat);
+ av_register_input_format(&dv_demuxer);
#ifdef CONFIG_MUXERS
- av_register_output_format(&dv_oformat);
+ av_register_output_format(&dv_muxer);
#endif
return 0;
}
return 0;
}
-static AVInputFormat dv1394_format = {
+static AVInputFormat dv1394_demuxer = {
.name = "dv1394",
.long_name = "dv1394 A/V grab",
.priv_data_size = sizeof(struct dv1394_data),
int dv1394_init(void)
{
- av_register_input_format(&dv1394_format);
+ av_register_input_format(&dv1394_demuxer);
return 0;
}
return 0;
}
-static AVInputFormat ea_iformat = {
+static AVInputFormat ea_demuxer = {
"ea",
"Electronic Arts Multimedia Format",
sizeof(EaDemuxContext),
int ea_init(void)
{
- av_register_input_format(&ea_iformat);
+ av_register_input_format(&ea_demuxer);
return 0;
}
return 0;
}
-static AVInputFormat ffm_iformat = {
+static AVInputFormat ffm_demuxer = {
"ffm",
"ffm format",
sizeof(FFMContext),
};
#ifdef CONFIG_MUXERS
-static AVOutputFormat ffm_oformat = {
+static AVOutputFormat ffm_muxer = {
"ffm",
"ffm format",
"",
int ffm_init(void)
{
- av_register_input_format(&ffm_iformat);
+ av_register_input_format(&ffm_demuxer);
#ifdef CONFIG_MUXERS
- av_register_output_format(&ffm_oformat);
+ av_register_output_format(&ffm_muxer);
#endif //CONFIG_MUXERS
return 0;
}
return 0;
}
-static AVInputFormat flic_iformat = {
+static AVInputFormat flic_demuxer = {
"flic",
"FLI/FLC/FLX animation format",
sizeof(FlicDemuxContext),
int flic_init(void)
{
- av_register_input_format(&flic_iformat);
+ av_register_input_format(&flic_demuxer);
return 0;
}
return 0;
}
-AVInputFormat flv_iformat = {
+AVInputFormat flv_demuxer = {
"flv",
"flv format",
0,
int flvdec_init(void)
{
- av_register_input_format(&flv_iformat);
+ av_register_input_format(&flv_demuxer);
return 0;
}
return 0;
}
-static AVOutputFormat flv_oformat = {
+static AVOutputFormat flv_muxer = {
"flv",
"flv format",
"video/x-flv",
int flvenc_init(void)
{
- av_register_output_format(&flv_oformat);
+ av_register_output_format(&flv_muxer);
return 0;
}
return 0;
}
-static AVOutputFormat gif_oformat = {
+static AVOutputFormat gif_muxer = {
"gif",
"GIF Animation",
"image/gif",
gif_write_trailer,
};
-extern AVInputFormat gif_iformat;
+extern AVInputFormat gif_demuxer;
int gif_init(void)
{
- av_register_output_format(&gif_oformat);
- av_register_input_format(&gif_iformat);
+ av_register_output_format(&gif_muxer);
+ av_register_input_format(&gif_demuxer);
return 0;
}
return 0;
}
-AVInputFormat gif_iformat =
+AVInputFormat gif_demuxer =
{
"gif",
"gif format",
return 0;
}
-static AVInputFormat video_grab_device_format = {
+static AVInputFormat video_grab_device_demuxer = {
"video4linux",
"video grab",
sizeof(VideoData),
int video_grab_init(void)
{
- av_register_input_format(&video_grab_device_format);
+ av_register_input_format(&video_grab_device_demuxer);
return 0;
}
return 0;
}
-AVInputFormat video_grab_device_format = {
+AVInputFormat video_grab_device_demuxer = {
"bktr",
"video grab",
sizeof(VideoData),
int video_grab_init(void)
{
- av_register_input_format(&video_grab_device_format);
+ av_register_input_format(&video_grab_device_demuxer);
return 0;
}
return AVERROR_IO;
}
-static AVInputFormat gxf_iformat = {
+static AVInputFormat gxf_demuxer = {
"gxf",
"GXF format",
0,
};
int gxf_init(void) {
- av_register_input_format(&gxf_iformat);
+ av_register_input_format(&gxf_demuxer);
return 0;
}
return 0;
}
-static AVInputFormat idcin_iformat = {
+static AVInputFormat idcin_demuxer = {
"idcin",
"Id CIN format",
sizeof(IdcinDemuxContext),
int idcin_init(void)
{
- av_register_input_format(&idcin_iformat);
+ av_register_input_format(&idcin_demuxer);
return 0;
}
return 0;
}
-static AVInputFormat roq_iformat = {
+static AVInputFormat roq_demuxer = {
"RoQ",
"Id RoQ format",
sizeof(RoqDemuxContext),
int roq_init(void)
{
- av_register_input_format(&roq_iformat);
+ av_register_input_format(&roq_demuxer);
return 0;
}
/* input */
-static AVInputFormat image_iformat = {
+static AVInputFormat image_demuxer = {
"image",
"image sequence",
sizeof(VideoData),
AVFMT_NOFILE | AVFMT_NEEDNUMBER,
};
-static AVInputFormat imagepipe_iformat = {
+static AVInputFormat imagepipe_demuxer = {
"imagepipe",
"piped image sequence",
sizeof(VideoData),
/* output */
-static AVOutputFormat image_oformat = {
+static AVOutputFormat image_muxer = {
"image",
"image sequence",
"",
img_set_parameters,
};
-static AVOutputFormat imagepipe_oformat = {
+static AVOutputFormat imagepipe_muxer = {
"imagepipe",
"piped image sequence",
"",
int img_init(void)
{
- av_register_input_format(&image_iformat);
- av_register_output_format(&image_oformat);
+ av_register_input_format(&image_demuxer);
+ av_register_output_format(&image_muxer);
- av_register_input_format(&imagepipe_iformat);
- av_register_output_format(&imagepipe_oformat);
+ av_register_input_format(&imagepipe_demuxer);
+ av_register_output_format(&imagepipe_muxer);
return 0;
}
/* input */
-static AVInputFormat image2_iformat = {
+static AVInputFormat image2_demuxer = {
"image2",
"image2 sequence",
sizeof(VideoData),
AVFMT_NOFILE,
};
-static AVInputFormat image2pipe_iformat = {
+static AVInputFormat image2pipe_demuxer = {
"image2pipe",
"piped image2 sequence",
sizeof(VideoData),
#ifdef CONFIG_MUXERS
/* output */
-static AVOutputFormat image2_oformat = {
+static AVOutputFormat image2_muxer = {
"image2",
"image2 sequence",
"",
AVFMT_NOFILE,
};
-static AVOutputFormat image2pipe_oformat = {
+static AVOutputFormat image2pipe_muxer = {
"image2pipe",
"piped image2 sequence",
"",
int img2_init(void)
{
- av_register_input_format(&image2_iformat);
- av_register_input_format(&image2pipe_iformat);
+ av_register_input_format(&image2_demuxer);
+ av_register_input_format(&image2pipe_demuxer);
#ifdef CONFIG_MUXERS
- av_register_output_format(&image2_oformat);
- av_register_output_format(&image2pipe_oformat);
+ av_register_output_format(&image2_muxer);
+ av_register_output_format(&image2pipe_muxer);
#endif
return 0;
return 0;
}
-static AVInputFormat ipmovie_iformat = {
+static AVInputFormat ipmovie_demuxer = {
"ipmovie",
"Interplay MVE format",
sizeof(IPMVEContext),
int ipmovie_init(void)
{
- av_register_input_format(&ipmovie_iformat);
+ av_register_input_format(&ipmovie_demuxer);
return 0;
}
return 0;
}
-static AVInputFormat matroska_iformat = {
+static AVInputFormat matroska_demuxer = {
"matroska",
"Matroska file format",
sizeof(MatroskaDemuxContext),
int
matroska_init(void)
{
- av_register_input_format(&matroska_iformat);
+ av_register_input_format(&matroska_demuxer);
return 0;
}
return 0;
}
-static AVInputFormat mm_iformat = {
+static AVInputFormat mm_demuxer = {
"mm",
"American Laser Games MM format",
sizeof(MmDemuxContext),
int mm_init(void)
{
- av_register_input_format(&mm_iformat);
+ av_register_input_format(&mm_demuxer);
return 0;
}
}
-static AVInputFormat mmf_iformat = {
+static AVInputFormat mmf_demuxer = {
"mmf",
"mmf format",
sizeof(MMFContext),
};
#ifdef CONFIG_MUXERS
-static AVOutputFormat mmf_oformat = {
+static AVOutputFormat mmf_muxer = {
"mmf",
"mmf format",
"application/vnd.smaf",
int ff_mmf_init(void)
{
- av_register_input_format(&mmf_iformat);
+ av_register_input_format(&mmf_demuxer);
#ifdef CONFIG_MUXERS
- av_register_output_format(&mmf_oformat);
+ av_register_output_format(&mmf_muxer);
#endif //CONFIG_MUXERS
return 0;
}
return 0;
}
-static AVInputFormat mov_iformat = {
+static AVInputFormat mov_demuxer = {
"mov,mp4,m4a,3gp,3g2,mj2",
"QuickTime/MPEG4/Motion JPEG 2000 format",
sizeof(MOVContext),
int mov_init(void)
{
- av_register_input_format(&mov_iformat);
+ av_register_input_format(&mov_demuxer);
return 0;
}
return res;
}
-static AVOutputFormat mov_oformat = {
+static AVOutputFormat mov_muxer = {
"mov",
"mov format",
NULL,
.flags = AVFMT_GLOBALHEADER,
};
-static AVOutputFormat _3gp_oformat = {
+static AVOutputFormat _3gp_muxer = {
"3gp",
"3gp format",
NULL,
.flags = AVFMT_GLOBALHEADER,
};
-static AVOutputFormat mp4_oformat = {
+static AVOutputFormat mp4_muxer = {
"mp4",
"mp4 format",
"application/mp4",
.flags = AVFMT_GLOBALHEADER,
};
-static AVOutputFormat psp_oformat = {
+static AVOutputFormat psp_muxer = {
"psp",
"psp mp4 format",
NULL,
.flags = AVFMT_GLOBALHEADER,
};
-static AVOutputFormat _3g2_oformat = {
+static AVOutputFormat _3g2_muxer = {
"3g2",
"3gp2 format",
NULL,
int movenc_init(void)
{
- av_register_output_format(&mov_oformat);
- av_register_output_format(&_3gp_oformat);
- av_register_output_format(&mp4_oformat);
- av_register_output_format(&psp_oformat);
- av_register_output_format(&_3g2_oformat);
+ av_register_output_format(&mov_muxer);
+ av_register_output_format(&_3gp_muxer);
+ av_register_output_format(&mp4_muxer);
+ av_register_output_format(&psp_muxer);
+ av_register_output_format(&_3g2_muxer);
return 0;
}
}
#endif //CONFIG_MUXERS
-AVInputFormat mp3_iformat = {
+AVInputFormat mp3_demuxer = {
"mp3",
"MPEG audio",
0,
};
#ifdef CONFIG_MUXERS
-AVOutputFormat mp2_oformat = {
+AVOutputFormat mp2_muxer = {
"mp2",
"MPEG audio layer 2",
"audio/x-mpeg",
};
#ifdef CONFIG_MP3LAME
-AVOutputFormat mp3_oformat = {
+AVOutputFormat mp3_muxer = {
"mp3",
"MPEG audio layer 3",
"audio/x-mpeg",
int mp3_init(void)
{
- av_register_input_format(&mp3_iformat);
+ av_register_input_format(&mp3_demuxer);
#ifdef CONFIG_MUXERS
- av_register_output_format(&mp2_oformat);
+ av_register_output_format(&mp2_muxer);
#ifdef CONFIG_MP3LAME
- av_register_output_format(&mp3_oformat);
+ av_register_output_format(&mp3_muxer);
#endif
#endif //CONFIG_MUXERS
return 0;
static const int lpcm_freq_tab[4] = { 48000, 96000, 44100, 32000 };
#ifdef CONFIG_MUXERS
-static AVOutputFormat mpeg1system_mux;
-static AVOutputFormat mpeg1vcd_mux;
-static AVOutputFormat mpeg2vob_mux;
-static AVOutputFormat mpeg2svcd_mux;
-static AVOutputFormat mpeg2dvd_mux;
+static AVOutputFormat mpeg1system_muxer;
+static AVOutputFormat mpeg1vcd_muxer;
+static AVOutputFormat mpeg2vob_muxer;
+static AVOutputFormat mpeg2svcd_muxer;
+static AVOutputFormat mpeg2dvd_muxer;
static int put_pack_header(AVFormatContext *ctx,
uint8_t *buf, int64_t timestamp)
int video_bitrate;
s->packet_number = 0;
- s->is_vcd = (ctx->oformat == &mpeg1vcd_mux);
- s->is_svcd = (ctx->oformat == &mpeg2svcd_mux);
- s->is_mpeg2 = (ctx->oformat == &mpeg2vob_mux || ctx->oformat == &mpeg2svcd_mux || ctx->oformat == &mpeg2dvd_mux);
- s->is_dvd = (ctx->oformat == &mpeg2dvd_mux);
+ s->is_vcd = (ctx->oformat == &mpeg1vcd_muxer);
+ s->is_svcd = (ctx->oformat == &mpeg2svcd_muxer);
+ s->is_mpeg2 = (ctx->oformat == &mpeg2vob_muxer || ctx->oformat == &mpeg2svcd_muxer || ctx->oformat == &mpeg2dvd_muxer);
+ s->is_dvd = (ctx->oformat == &mpeg2dvd_muxer);
if(ctx->packet_size)
s->packet_size = ctx->packet_size;
}
#ifdef CONFIG_MUXERS
-static AVOutputFormat mpeg1system_mux = {
+static AVOutputFormat mpeg1system_muxer = {
"mpeg",
"MPEG1 System format",
"video/mpeg",
mpeg_mux_end,
};
-static AVOutputFormat mpeg1vcd_mux = {
+static AVOutputFormat mpeg1vcd_muxer = {
"vcd",
"MPEG1 System format (VCD)",
"video/mpeg",
mpeg_mux_end,
};
-static AVOutputFormat mpeg2vob_mux = {
+static AVOutputFormat mpeg2vob_muxer = {
"vob",
"MPEG2 PS format (VOB)",
"video/mpeg",
mpeg_mux_end,
};
-/* Same as mpeg2vob_mux except that the pack size is 2324 */
-static AVOutputFormat mpeg2svcd_mux = {
+/* Same as mpeg2vob_muxer except that the pack size is 2324 */
+static AVOutputFormat mpeg2svcd_muxer = {
"svcd",
"MPEG2 PS format (VOB)",
"video/mpeg",
mpeg_mux_end,
};
-/* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
-static AVOutputFormat mpeg2dvd_mux = {
+/* Same as mpeg2vob_muxer except the 'is_dvd' flag is set to produce NAV pkts */
+static AVOutputFormat mpeg2dvd_muxer = {
"dvd",
"MPEG2 PS format (DVD VOB)",
"video/mpeg",
#endif //CONFIG_MUXERS
-AVInputFormat mpegps_demux = {
+AVInputFormat mpegps_demuxer = {
"mpeg",
"MPEG PS format",
sizeof(MpegDemuxContext),
int mpegps_init(void)
{
#ifdef CONFIG_MUXERS
- av_register_output_format(&mpeg1system_mux);
- av_register_output_format(&mpeg1vcd_mux);
- av_register_output_format(&mpeg2vob_mux);
- av_register_output_format(&mpeg2svcd_mux);
- av_register_output_format(&mpeg2dvd_mux);
+ av_register_output_format(&mpeg1system_muxer);
+ av_register_output_format(&mpeg1vcd_muxer);
+ av_register_output_format(&mpeg2vob_muxer);
+ av_register_output_format(&mpeg2svcd_muxer);
+ av_register_output_format(&mpeg2dvd_muxer);
#endif //CONFIG_MUXERS
- av_register_input_format(&mpegps_demux);
+ av_register_input_format(&mpegps_demuxer);
return 0;
}
av_free(ts);
}
-AVInputFormat mpegts_demux = {
+AVInputFormat mpegts_demuxer = {
"mpegts",
"MPEG2 transport stream format",
sizeof(MpegTSContext),
int mpegts_init(void)
{
- av_register_input_format(&mpegts_demux);
+ av_register_input_format(&mpegts_demuxer);
#ifdef CONFIG_MUXERS
- av_register_output_format(&mpegts_mux);
+ av_register_output_format(&mpegts_muxer);
#endif
return 0;
}
#define STREAM_TYPE_SUBTITLE_DVB 0x100
unsigned int mpegts_crc32(const uint8_t *data, int len);
-extern AVOutputFormat mpegts_mux;
+extern AVOutputFormat mpegts_muxer;
typedef struct MpegTSContext MpegTSContext;
return 0;
}
-AVOutputFormat mpegts_mux = {
+AVOutputFormat mpegts_muxer = {
"mpegts",
"MPEG2 transport stream format",
"video/x-mpegts",
return 0;
}
-static AVOutputFormat mpjpeg_format = {
+static AVOutputFormat mpjpeg_muxer = {
"mpjpeg",
"Mime multipart JPEG format",
"multipart/x-mixed-replace;boundary=" BOUNDARY_TAG,
int jpeg_init(void)
{
- av_register_output_format(&mpjpeg_format);
+ av_register_output_format(&mpjpeg_muxer);
return 0;
}
#endif //CONFIG_MUXERS
return 0;
}
-static AVInputFormat nsv_iformat = {
+static AVInputFormat nsv_demuxer = {
"nsv",
"NullSoft Video format",
sizeof(NSVContext),
int nsvdec_init(void)
{
- av_register_input_format(&nsv_iformat);
+ av_register_input_format(&nsv_demuxer);
return 0;
}
return 0;
}
-static AVInputFormat nut_iformat = {
+static AVInputFormat nut_demuxer = {
"nut",
"nut format",
sizeof(NUTContext),
};
#ifdef CONFIG_MUXERS
-static AVOutputFormat nut_oformat = {
+static AVOutputFormat nut_muxer = {
"nut",
"nut format",
"video/x-nut",
int nut_init(void)
{
- av_register_input_format(&nut_iformat);
+ av_register_input_format(&nut_demuxer);
#ifdef CONFIG_MUXERS
- av_register_output_format(&nut_oformat);
+ av_register_output_format(&nut_muxer);
#endif //CONFIG_MUXERS
return 0;
}
return AVERROR_IO;
}
-static AVInputFormat nuv_iformat = {
+static AVInputFormat nuv_demuxer = {
"nuv",
"NuppelVideo format",
sizeof(NUVContext),
};
int nuv_init(void) {
- av_register_input_format(&nuv_iformat);
+ av_register_input_format(&nuv_demuxer);
return 0;
}
}
-static AVOutputFormat ogg_oformat = {
+static AVOutputFormat ogg_muxer = {
"ogg",
"Ogg Vorbis",
"audio/x-vorbis",
}
-static AVInputFormat ogg_iformat = {
+static AVInputFormat ogg_demuxer = {
"ogg",
"Ogg Vorbis",
sizeof(OggContext),
int libogg_init(void) {
#ifdef CONFIG_MUXERS
- av_register_output_format(&ogg_oformat) ;
+ av_register_output_format(&ogg_muxer) ;
#endif
-/* av_register_input_format(&ogg_iformat); */
+/* av_register_input_format(&ogg_demuxer); */
return 0 ;
}
}
-static AVOutputFormat ogg_oformat = {
+static AVOutputFormat ogg_muxer = {
"ogg",
"Ogg Vorbis",
"audio/x-vorbis",
return 0;
}
-static AVInputFormat ogg_iformat = {
+static AVInputFormat ogg_demuxer = {
"ogg",
"Ogg",
sizeof (ogg_t),
ogg_init (void)
{
#if 0 // CONFIG_MUXERS
- av_register_output_format (&ogg_oformat);
+ av_register_output_format (&ogg_muxer);
#endif
- av_register_input_format (&ogg_iformat);
+ av_register_input_format (&ogg_demuxer);
return 0;
}
return 0;
}
-static AVInputFormat str_iformat = {
+static AVInputFormat str_demuxer = {
"psxstr",
"Sony Playstation STR format",
sizeof(StrDemuxContext),
int str_init(void)
{
- av_register_input_format(&str_iformat);
+ av_register_input_format(&str_demuxer);
return 0;
}
return 0;
}
-AVInputFormat shorten_iformat = {
+AVInputFormat shorten_demuxer = {
"shn",
"raw shorten",
0,
.extensions = "shn",
};
-AVInputFormat flac_iformat = {
+AVInputFormat flac_demuxer = {
"flac",
"raw flac",
0,
};
#ifdef CONFIG_MUXERS
-AVOutputFormat flac_oformat = {
+AVOutputFormat flac_muxer = {
"flac",
"raw flac",
"audio/x-flac",
};
#endif //CONFIG_MUXERS
-AVInputFormat ac3_iformat = {
+AVInputFormat ac3_demuxer = {
"ac3",
"raw ac3",
0,
};
#ifdef CONFIG_MUXERS
-AVOutputFormat ac3_oformat = {
+AVOutputFormat ac3_muxer = {
"ac3",
"raw ac3",
"audio/x-ac3",
};
#endif //CONFIG_MUXERS
-AVInputFormat dts_iformat = {
+AVInputFormat dts_demuxer = {
"dts",
"raw dts",
0,
.extensions = "dts",
};
-AVInputFormat aac_iformat = {
+AVInputFormat aac_demuxer = {
"aac",
"ADTS AAC",
0,
.extensions = "aac",
};
-AVInputFormat h261_iformat = {
+AVInputFormat h261_demuxer = {
"h261",
"raw h261",
0,
};
#ifdef CONFIG_MUXERS
-AVOutputFormat h261_oformat = {
+AVOutputFormat h261_muxer = {
"h261",
"raw h261",
"video/x-h261",
};
#endif //CONFIG_MUXERS
-AVInputFormat h263_iformat = {
+AVInputFormat h263_demuxer = {
"h263",
"raw h263",
0,
};
#ifdef CONFIG_MUXERS
-AVOutputFormat h263_oformat = {
+AVOutputFormat h263_muxer = {
"h263",
"raw h263",
"video/x-h263",
};
#endif //CONFIG_MUXERS
-AVInputFormat m4v_iformat = {
+AVInputFormat m4v_demuxer = {
"m4v",
"raw MPEG4 video format",
0,
};
#ifdef CONFIG_MUXERS
-AVOutputFormat m4v_oformat = {
+AVOutputFormat m4v_muxer = {
"m4v",
"raw MPEG4 video format",
NULL,
};
#endif //CONFIG_MUXERS
-AVInputFormat h264_iformat = {
+AVInputFormat h264_demuxer = {
"h264",
"raw H264 video format",
0,
};
#ifdef CONFIG_MUXERS
-AVOutputFormat h264_oformat = {
+AVOutputFormat h264_muxer = {
"h264",
"raw H264 video format",
NULL,
};
#endif //CONFIG_MUXERS
-AVInputFormat mpegvideo_iformat = {
+AVInputFormat mpegvideo_demuxer = {
"mpegvideo",
"MPEG video",
0,
};
#ifdef CONFIG_MUXERS
-AVOutputFormat mpeg1video_oformat = {
+AVOutputFormat mpeg1video_muxer = {
"mpeg1video",
"MPEG video",
"video/x-mpeg",
#endif //CONFIG_MUXERS
#ifdef CONFIG_MUXERS
-AVOutputFormat mpeg2video_oformat = {
+AVOutputFormat mpeg2video_muxer = {
"mpeg2video",
"MPEG2 video",
NULL,
};
#endif //CONFIG_MUXERS
-AVInputFormat mjpeg_iformat = {
+AVInputFormat mjpeg_demuxer = {
"mjpeg",
"MJPEG video",
0,
.value = CODEC_ID_MJPEG,
};
-AVInputFormat ingenient_iformat = {
+AVInputFormat ingenient_demuxer = {
"ingenient",
"Ingenient MJPEG",
0,
};
#ifdef CONFIG_MUXERS
-AVOutputFormat mjpeg_oformat = {
+AVOutputFormat mjpeg_muxer = {
"mjpeg",
"MJPEG video",
"video/x-mjpeg",
/* pcm formats */
#define PCMINPUTDEF(name, long_name, ext, codec) \
-AVInputFormat pcm_ ## name ## _iformat = {\
+AVInputFormat pcm_ ## name ## _demuxer = {\
#name,\
long_name,\
0,\
};
#define PCMOUTPUTDEF(name, long_name, ext, codec) \
-AVOutputFormat pcm_ ## name ## _oformat = {\
+AVOutputFormat pcm_ ## name ## _muxer = {\
#name,\
long_name,\
NULL,\
}
}
-AVInputFormat rawvideo_iformat = {
+AVInputFormat rawvideo_demuxer = {
"rawvideo",
"raw video format",
0,
};
#ifdef CONFIG_MUXERS
-AVOutputFormat rawvideo_oformat = {
+AVOutputFormat rawvideo_muxer = {
"rawvideo",
"raw video format",
NULL,
return 0;
}
-AVOutputFormat null_oformat = {
+AVOutputFormat null_muxer = {
"null",
"null video format",
NULL,
int raw_init(void)
{
- av_register_input_format(&shorten_iformat);
- av_register_input_format(&flac_iformat);
- av_register_output_format(&flac_oformat);
+ av_register_input_format(&shorten_demuxer);
+ av_register_input_format(&flac_demuxer);
+ av_register_output_format(&flac_muxer);
- av_register_input_format(&ac3_iformat);
- av_register_output_format(&ac3_oformat);
+ av_register_input_format(&ac3_demuxer);
+ av_register_output_format(&ac3_muxer);
- av_register_input_format(&aac_iformat);
+ av_register_input_format(&aac_demuxer);
- av_register_input_format(&dts_iformat);
+ av_register_input_format(&dts_demuxer);
- av_register_input_format(&h261_iformat);
- av_register_output_format(&h261_oformat);
+ av_register_input_format(&h261_demuxer);
+ av_register_output_format(&h261_muxer);
- av_register_input_format(&h263_iformat);
- av_register_output_format(&h263_oformat);
+ av_register_input_format(&h263_demuxer);
+ av_register_output_format(&h263_muxer);
- av_register_input_format(&m4v_iformat);
- av_register_output_format(&m4v_oformat);
+ av_register_input_format(&m4v_demuxer);
+ av_register_output_format(&m4v_muxer);
- av_register_input_format(&h264_iformat);
- av_register_output_format(&h264_oformat);
+ av_register_input_format(&h264_demuxer);
+ av_register_output_format(&h264_muxer);
- av_register_input_format(&mpegvideo_iformat);
- av_register_output_format(&mpeg1video_oformat);
+ av_register_input_format(&mpegvideo_demuxer);
+ av_register_output_format(&mpeg1video_muxer);
- av_register_output_format(&mpeg2video_oformat);
+ av_register_output_format(&mpeg2video_muxer);
- av_register_input_format(&mjpeg_iformat);
- av_register_output_format(&mjpeg_oformat);
+ av_register_input_format(&mjpeg_demuxer);
+ av_register_output_format(&mjpeg_muxer);
- av_register_input_format(&ingenient_iformat);
+ av_register_input_format(&ingenient_demuxer);
- av_register_input_format(&pcm_s16le_iformat);
- av_register_output_format(&pcm_s16le_oformat);
- av_register_input_format(&pcm_s16be_iformat);
- av_register_output_format(&pcm_s16be_oformat);
- av_register_input_format(&pcm_u16le_iformat);
- av_register_output_format(&pcm_u16le_oformat);
- av_register_input_format(&pcm_u16be_iformat);
- av_register_output_format(&pcm_u16be_oformat);
- av_register_input_format(&pcm_s8_iformat);
- av_register_output_format(&pcm_s8_oformat);
- av_register_input_format(&pcm_u8_iformat);
- av_register_output_format(&pcm_u8_oformat);
- av_register_input_format(&pcm_mulaw_iformat);
- av_register_output_format(&pcm_mulaw_oformat);
- av_register_input_format(&pcm_alaw_iformat);
- av_register_output_format(&pcm_alaw_oformat);
+ av_register_input_format(&pcm_s16le_demuxer);
+ av_register_output_format(&pcm_s16le_muxer);
+ av_register_input_format(&pcm_s16be_demuxer);
+ av_register_output_format(&pcm_s16be_muxer);
+ av_register_input_format(&pcm_u16le_demuxer);
+ av_register_output_format(&pcm_u16le_muxer);
+ av_register_input_format(&pcm_u16be_demuxer);
+ av_register_output_format(&pcm_u16be_muxer);
+ av_register_input_format(&pcm_s8_demuxer);
+ av_register_output_format(&pcm_s8_muxer);
+ av_register_input_format(&pcm_u8_demuxer);
+ av_register_output_format(&pcm_u8_muxer);
+ av_register_input_format(&pcm_mulaw_demuxer);
+ av_register_output_format(&pcm_mulaw_muxer);
+ av_register_input_format(&pcm_alaw_demuxer);
+ av_register_output_format(&pcm_alaw_muxer);
- av_register_input_format(&rawvideo_iformat);
- av_register_output_format(&rawvideo_oformat);
+ av_register_input_format(&rawvideo_demuxer);
+ av_register_output_format(&rawvideo_muxer);
- av_register_output_format(&null_oformat);
+ av_register_output_format(&null_muxer);
return 0;
}
return dts;
}
-static AVInputFormat rm_iformat = {
+static AVInputFormat rm_demuxer = {
"rm",
"rm format",
sizeof(RMContext),
};
#ifdef CONFIG_MUXERS
-static AVOutputFormat rm_oformat = {
+static AVOutputFormat rm_muxer = {
"rm",
"rm format",
"application/vnd.rn-realmedia",
int rm_init(void)
{
- av_register_input_format(&rm_iformat);
+ av_register_input_format(&rm_demuxer);
#ifdef CONFIG_MUXERS
- av_register_output_format(&rm_oformat);
+ av_register_output_format(&rm_muxer);
#endif //CONFIG_MUXERS
return 0;
}
return 0;
}
-AVOutputFormat rtp_mux = {
+AVOutputFormat rtp_muxer = {
"rtp",
"RTP output format",
NULL,
int rtp_init(void)
{
- av_register_output_format(&rtp_mux);
+ av_register_output_format(&rtp_muxer);
return 0;
}
const uint8_t *buf, int len);
void rtp_parse_close(RTPDemuxContext *s);
-extern AVOutputFormat rtp_mux;
-extern AVInputFormat rtp_demux;
+extern AVOutputFormat rtp_muxer;
+extern AVInputFormat rtp_demuxer;
int rtp_get_local_port(URLContext *h);
int rtp_set_remote_url(URLContext *h, const char *uri);
return 0;
}
-AVInputFormat rtsp_demux = {
+AVInputFormat rtsp_demuxer = {
"rtsp",
"RTSP input format",
sizeof(RTSPState),
}
-static AVInputFormat sdp_demux = {
+static AVInputFormat sdp_demuxer = {
"sdp",
"SDP",
sizeof(RTSPState),
return 0;
}
-AVInputFormat redir_demux = {
+AVInputFormat redir_demuxer = {
"redir",
"Redirector format",
0,
int rtsp_init(void)
{
- av_register_input_format(&rtsp_demux);
- av_register_input_format(&redir_demux);
- av_register_input_format(&sdp_demux);
+ av_register_input_format(&rtsp_demuxer);
+ av_register_input_format(&redir_demuxer);
+ av_register_input_format(&sdp_demuxer);
return 0;
}
extern int rtsp_rtp_port_min;
extern int rtsp_rtp_port_max;
extern FFRTSPCallback *ff_rtsp_callback;
-extern AVInputFormat rtsp_demux;
+extern AVInputFormat rtsp_demuxer;
int rtsp_pause(AVFormatContext *s);
int rtsp_resume(AVFormatContext *s);
return 0;
}
-static AVInputFormat film_iformat = {
+static AVInputFormat film_demuxer = {
"film_cpk",
"Sega FILM/CPK format",
sizeof(FilmDemuxContext),
int film_init(void)
{
- av_register_input_format(&film_iformat);
+ av_register_input_format(&film_demuxer);
return 0;
}
return 0;
}
-static AVInputFormat vmd_iformat = {
+static AVInputFormat vmd_demuxer = {
"vmd",
"Sierra VMD format",
sizeof(VmdDemuxContext),
int vmd_init(void)
{
- av_register_input_format(&vmd_iformat);
+ av_register_input_format(&vmd_demuxer);
return 0;
}
return 0;
}
-static AVInputFormat smacker_iformat = {
+static AVInputFormat smacker_demuxer = {
"smk",
"Smacker Video",
sizeof(SmackerContext),
int smacker_init(void)
{
- av_register_input_format(&smacker_iformat);
+ av_register_input_format(&smacker_demuxer);
return 0;
}
return 0;
}
-static AVInputFormat sol_iformat = {
+static AVInputFormat sol_demuxer = {
"sol",
"Sierra SOL Format",
0,
int sol_init(void)
{
- av_register_input_format(&sol_iformat);
+ av_register_input_format(&sol_demuxer);
return 0;
}
return 0;
}
-static AVInputFormat swf_iformat = {
+static AVInputFormat swf_demuxer = {
"swf",
"Flash format",
sizeof(SWFContext),
};
#ifdef CONFIG_MUXERS
-static AVOutputFormat swf_oformat = {
+static AVOutputFormat swf_muxer = {
"swf",
"Flash format",
"application/x-shockwave-flash",
int swf_init(void)
{
- av_register_input_format(&swf_iformat);
+ av_register_input_format(&swf_demuxer);
#ifdef CONFIG_MUXERS
- av_register_output_format(&swf_oformat);
+ av_register_output_format(&swf_muxer);
#endif //CONFIG_MUXERS
return 0;
}
return 0;
}
-AVInputFormat tta_iformat = {
+AVInputFormat tta_demuxer = {
"tta",
"true-audio",
sizeof(TTAContext),
int tta_init(void)
{
- av_register_input_format(&tta_iformat);
+ av_register_input_format(&tta_demuxer);
return 0;
}
/* XXX: suppress this hack for redirectors */
#ifdef CONFIG_NETWORK
- if (fmt == &redir_demux) {
+ if (fmt == &redir_demuxer) {
err = redir_open(ic_ptr, pb);
url_fclose(pb);
return err;
}
ic->file_size = file_size;
- if ((ic->iformat == &mpegps_demux || ic->iformat == &mpegts_demux) && file_size && !ic->pb.is_streamed) {
+ if ((ic->iformat == &mpegps_demuxer || ic->iformat == &mpegts_demuxer) && file_size && !ic->pb.is_streamed) {
/* get accurate estimate from the PTSes */
av_estimate_timings_from_pts(ic);
} else if (av_has_timings(ic)) {
return 0;
}
-static AVInputFormat v4l2_format = {
+static AVInputFormat v4l2_demuxer = {
"video4linux2",
"video grab",
sizeof(struct video_data),
int v4l2_init(void)
{
- av_register_input_format(&v4l2_format);
+ av_register_input_format(&v4l2_demuxer);
return 0;
}
return 0;
}
-static AVInputFormat voc_iformat = {
+static AVInputFormat voc_demuxer = {
"voc",
"Creative Voice File format",
sizeof(voc_dec_context_t),
return 0;
}
-static AVOutputFormat voc_oformat = {
+static AVOutputFormat voc_muxer = {
"voc",
"Creative Voice File format",
"audio/x-voc",
int voc_init(void)
{
#ifdef CONFIG_DEMUXERS
- av_register_input_format(&voc_iformat);
+ av_register_input_format(&voc_demuxer);
#endif /* CONFIG_DEMUXERS */
#ifdef CONFIG_MUXERS
- av_register_output_format(&voc_oformat);
+ av_register_output_format(&voc_muxer);
#endif /* CONFIG_MUXERS */
return 0;
}
}
-static AVInputFormat wav_iformat = {
+static AVInputFormat wav_demuxer = {
"wav",
"wav format",
sizeof(WAVContext),
};
#ifdef CONFIG_MUXERS
-static AVOutputFormat wav_oformat = {
+static AVOutputFormat wav_muxer = {
"wav",
"wav format",
"audio/x-wav",
int ff_wav_init(void)
{
- av_register_input_format(&wav_iformat);
+ av_register_input_format(&wav_demuxer);
#ifdef CONFIG_MUXERS
- av_register_output_format(&wav_oformat);
+ av_register_output_format(&wav_muxer);
#endif //CONFIG_MUXERS
return 0;
}
return 0;
}
-static AVInputFormat wc3_iformat = {
+static AVInputFormat wc3_demuxer = {
"wc3movie",
"Wing Commander III movie format",
sizeof(Wc3DemuxContext),
int wc3_init(void)
{
- av_register_input_format(&wc3_iformat);
+ av_register_input_format(&wc3_demuxer);
return 0;
}
return 0;
}
-static AVInputFormat wsaud_iformat = {
+static AVInputFormat wsaud_demuxer = {
"wsaud",
"Westwood Studios audio format",
sizeof(WsAudDemuxContext),
wsaud_read_close,
};
-static AVInputFormat wsvqa_iformat = {
+static AVInputFormat wsvqa_demuxer = {
"wsvqa",
"Westwood Studios VQA format",
sizeof(WsVqaDemuxContext),
int westwood_init(void)
{
- av_register_input_format(&wsaud_iformat);
- av_register_input_format(&wsvqa_iformat);
+ av_register_input_format(&wsaud_demuxer);
+ av_register_input_format(&wsvqa_demuxer);
return 0;
}
return 0;
}
-AVOutputFormat yuv4mpegpipe_oformat = {
+AVOutputFormat yuv4mpegpipe_muxer = {
"yuv4mpegpipe",
"YUV4MPEG pipe format",
"",
return 0;
}
-AVInputFormat yuv4mpegpipe_iformat = {
+AVInputFormat yuv4mpegpipe_demuxer = {
"yuv4mpegpipe",
"YUV4MPEG pipe format",
sizeof(struct frame_attributes),
int yuv4mpeg_init(void)
{
- av_register_input_format(&yuv4mpegpipe_iformat);
+ av_register_input_format(&yuv4mpegpipe_demuxer);
#ifdef CONFIG_MUXERS
- av_register_output_format(&yuv4mpegpipe_oformat);
+ av_register_output_format(&yuv4mpegpipe_muxer);
#endif //CONFIG_MUXERS
return 0;
}