/* XXX: implement encoding */
+#ifdef CONFIG_ENCODERS
static int adpcm_encode_init(AVCodecContext *avctx)
{
if (avctx->channels > 2)
}
return dst - frame;
}
+#endif //CONFIG_ENCODERS
static int adpcm_decode_init(AVCodecContext * avctx)
{
return src - buf;
}
-#define ADPCM_CODEC(id, name) \
+
+
+#ifdef CONFIG_ENCODERS
+#define ADPCM_ENCODER(id,name) \
AVCodec name ## _encoder = { \
#name, \
CODEC_TYPE_AUDIO, \
adpcm_encode_frame, \
adpcm_encode_close, \
NULL, \
-}; \
+};
+#else
+#define ADPCM_ENCODER(id,name)
+#endif
+
+#ifdef CONFIG_DECODERS
+#define ADPCM_DECODER(id,name) \
AVCodec name ## _decoder = { \
#name, \
CODEC_TYPE_AUDIO, \
NULL, \
adpcm_decode_frame, \
};
+#else
+#define ADPCM_DECODER(id,name)
+#endif
+
+#define ADPCM_CODEC(id, name) \
+ADPCM_ENCODER(id,name) ADPCM_DECODER(id,name)
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt);
ADPCM_CODEC(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav);
/***********************************/
/* standard MMX */
+#ifdef CONFIG_ENCODERS
static void get_pixels_mmx(DCTELEM *block, const uint8_t *pixels, int line_size)
{
asm volatile(
: "%eax"
);
}
+#endif //CONFIG_ENCODERS
void put_pixels_clamped_mmx(const DCTELEM *block, uint8_t *pixels, int line_size)
{
);
}
+#ifdef CONFIG_ENCODERS
static int pix_sum16_mmx(uint8_t * pix, int line_size){
const int h=16;
int sum;
return sum;
}
+#endif //CONFIG_ENCODERS
static void add_bytes_mmx(uint8_t *dst, uint8_t *src, int w){
int i=0;
dst[i+0] += src[i+0];
}
+#ifdef CONFIG_ENCODERS
static int pix_norm1_mmx(uint8_t *pix, int line_size) {
int tmp;
asm volatile (
WARPER88_1616(hadamard8_diff_mmx, hadamard8_diff16_mmx)
WARPER88_1616(hadamard8_diff_mmx2, hadamard8_diff16_mmx2)
+#endif //CONFIG_ENCODERS
#define put_no_rnd_pixels8_mmx(a,b,c,d) put_pixels8_mmx(a,b,c,d)
#define put_no_rnd_pixels16_mmx(a,b,c,d) put_pixels16_mmx(a,b,c,d)
c->idct_permutation_type= FF_LIBMPEG2_IDCT_PERM;
}
+#ifdef CONFIG_ENCODERS
c->get_pixels = get_pixels_mmx;
c->diff_pixels = diff_pixels_mmx;
+#endif //CONFIG_ENCODERS
c->put_pixels_clamped = put_pixels_clamped_mmx;
c->add_pixels_clamped = add_pixels_clamped_mmx;
c->clear_blocks = clear_blocks_mmx;
+#ifdef CONFIG_ENCODERS
c->pix_sum = pix_sum16_mmx;
+#endif //CONFIG_ENCODERS
c->put_pixels_tab[0][0] = put_pixels16_mmx;
c->put_pixels_tab[0][1] = put_pixels16_x2_mmx;
c->avg_no_rnd_pixels_tab[1][3] = avg_no_rnd_pixels8_xy2_mmx;
c->add_bytes= add_bytes_mmx;
+#ifdef CONFIG_ENCODERS
c->diff_bytes= diff_bytes_mmx;
c->hadamard8_diff[0]= hadamard8_diff16_mmx;
c->pix_norm1 = pix_norm1_mmx;
c->sse[0] = sse16_mmx;
+#endif //CONFIG_ENCODERS
if (mm_flags & MM_MMXEXT) {
c->put_pixels_tab[0][1] = put_pixels16_x2_mmx2;
c->avg_pixels_tab[1][1] = avg_pixels8_x2_mmx2;
c->avg_pixels_tab[1][2] = avg_pixels8_y2_mmx2;
+#ifdef CONFIG_ENCODERS
c->hadamard8_diff[0]= hadamard8_diff16_mmx2;
c->hadamard8_diff[1]= hadamard8_diff_mmx2;
+#endif //CONFIG_ENCODERS
if(!(avctx->flags & CODEC_FLAG_BITEXACT)){
c->put_no_rnd_pixels_tab[0][1] = put_no_rnd_pixels16_x2_mmx2;
}
}
+#ifdef CONFIG_ENCODERS
dsputil_init_pix_mmx(c, avctx);
+#endif //CONFIG_ENCODERS
#if 0
// for speed testing
get_pixels = just_return;
}
}
+#ifdef CONFIG_ENCODERS
int mjpeg_init(MpegEncContext *s)
{
MJpegContext *m;
{
av_free(s->mjpeg_ctx);
}
+#endif //CONFIG_ENCODERS
#define PREDICT(ret, topleft, top, left, predictor)\
switch(predictor){\
#define MB_BTYPE_VLC_BITS 6
#define TEX_VLC_BITS 9
+#ifdef CONFIG_ENCODERS
static void mpeg1_encode_block(MpegEncContext *s,
DCTELEM *block,
int component);
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code); // RAL: f_code parameter added
+#endif //CONFIG_ENCODERS
static void mpeg1_skip_picture(MpegEncContext *s, int pict_num);
static inline int mpeg1_decode_block_inter(MpegEncContext *s,
DCTELEM *block,
static uint8_t mpeg1_index_run[2][64];
static int8_t mpeg1_max_level[2][64];
-#endif
+#endif //CONFIG_ENCODERS
static void init_2d_vlc_rl(RLTable *rl)
{
put_bits(&s->pb, 1, 1);
put_bits(&s->pb, 1, 1);
}
-#endif
+#endif //CONFIG_ENCODERS
static void common_init(MpegEncContext *s)
{
}
}
+#ifdef CONFIG_ENCODERS
void ff_write_quant_matrix(PutBitContext *pb, int16_t *matrix){
int i;
}else
put_bits(pb, 1, 0);
}
+#endif //CONFIG_ENCODERS
/* init common dct for both encoder and decoder */
int DCT_common_init(MpegEncContext *s)
mpegps_init();
mpegts_init();
+#ifdef CONFIG_ENCODERS
crc_init();
img_init();
+#endif //CONFIG_ENCODERS
raw_init();
mp3_init();
rm_init();
#ifdef CONFIG_RISKY
asf_init();
#endif
+#ifdef CONFIG_ENCODERS
avienc_init();
+#endif //CONFIG_ENCODERS
avidec_init();
wav_init();
swf_init();
au_init();
+#ifdef CONFIG_ENCODERS
gif_init();
+#endif //CONFIG_ENCODERS
mov_init();
+#ifdef CONFIG_ENCODERS
movenc_init();
jpeg_init();
+#endif //CONFIG_ENCODERS
dv_init();
fourxm_init();
+#ifdef CONFIG_ENCODERS
flvenc_init();
+#endif //CONFIG_ENCODERS
flvdec_init();
str_init();
roq_init();
westwood_init();
film_init();
idcin_init();
+ vmd_init();
#if defined(AMR_NB) || defined(AMR_NB_FIXED) || defined(AMR_WB)
amr_init();
nut_init();
+#ifdef CONFIG_ENCODERS
/* image formats */
av_register_image_format(&pnm_image_format);
av_register_image_format(&pbm_image_format);
#endif
av_register_image_format(&jpeg_image_format);
av_register_image_format(&gif_image_format);
+#endif //CONFIG_ENCODERS
/* file protocols */
register_protocol(&file_protocol);
0, 0, 0, { 0, 0, 0, 0, 0, 0, 0, 0 },
};
+#ifdef CONFIG_ENCODERS
static void put_guid(ByteIOContext *s, const GUID *g)
{
int i;
put_flush_packet(&s->pb);
return 0;
}
+#endif //CONFIG_ENCODERS
/**********************************/
/* decoding */
asf_read_seek,
};
+#ifdef CONFIG_ENCODERS
static AVOutputFormat asf_oformat = {
"asf",
"asf format",
asf_write_packet,
asf_write_trailer,
};
+#endif //CONFIG_ENCODERS
int asf_init(void)
{
av_register_input_format(&asf_iformat);
+#ifdef CONFIG_ENCODERS
av_register_output_format(&asf_oformat);
av_register_output_format(&asf_stream_oformat);
+#endif //CONFIG_ENCODERS
return 0;
}
{ 0, 0 },
};
+#ifdef CONFIG_ENCODERS
/* AUDIO_FILE header */
static int put_au_header(ByteIOContext *pb, AVCodecContext *enc)
{
return 0;
}
+#endif //CONFIG_ENCODERS
static int au_probe(AVProbeData *p)
{
au_read_close,
};
+#ifdef CONFIG_ENCODERS
static AVOutputFormat au_oformat = {
"au",
"SUN AU Format",
au_write_packet,
au_write_trailer,
};
+#endif //CONFIG_ENCODERS
int au_init(void)
{
av_register_input_format(&au_iformat);
+#ifdef CONFIG_ENCODERS
av_register_output_format(&au_oformat);
+#endif //CONFIG_ENCODERS
return 0;
}
* - fill all fields if non streamed (nb_frames for example)
*/
+#ifdef CONFIG_ENCODERS
typedef struct AVIIentry {
unsigned int flags, pos, len;
} AVIIentry;
put_le32(pb, (uint32_t)(pos - start));
url_fseek(pb, pos, SEEK_SET);
}
+#endif //CONFIG_ENCODERS
/* Note: when encoding, the first matching tag is used, so order is
important if multiple tags possible for a given codec. */
return codec_get_id(codec_wav_tags, tag);
}
+#ifdef CONFIG_ENCODERS
/* BITMAPINFOHEADER header */
void put_bmp_header(ByteIOContext *pb, AVCodecContext *enc, const CodecTag *tags, int for_asf)
{
av_register_output_format(&avi_oformat);
return 0;
}
+#endif //CONFIG_ENCODERS
return ret;
}
+#ifdef CONFIG_ENCODERS
int url_write(URLContext *h, unsigned char *buf, int size)
{
int ret;
ret = h->prot->url_write(h, buf, size);
return ret;
}
+#endif //CONFIG_ENCODERS
offset_t url_seek(URLContext *h, offset_t pos, int whence)
{
}
+#ifdef CONFIG_ENCODERS
static void flush_buffer(ByteIOContext *s)
{
if (s->buf_ptr > s->buffer) {
flush_buffer(s);
s->must_flush = 0;
}
+#endif //CONFIG_ENCODERS
offset_t url_fseek(ByteIOContext *s, offset_t offset, int whence)
{
if (whence != SEEK_CUR && whence != SEEK_SET)
return -EINVAL;
+#ifdef CONFIG_ENCODERS
if (s->write_flag) {
if (whence == SEEK_CUR) {
offset1 = s->pos + (s->buf_ptr - s->buffer);
s->seek(s->opaque, offset, SEEK_SET);
s->pos = offset;
}
- } else {
+ } else
+#endif //CONFIG_ENCODERS
+ {
if (whence == SEEK_CUR) {
offset1 = s->pos - (s->buf_end - s->buffer) + (s->buf_ptr - s->buffer);
if (offset == 0)
return s->eof_reached;
}
+#ifdef CONFIG_ENCODERS
void put_le32(ByteIOContext *s, unsigned int val)
{
put_byte(s, val);
put_byte(s, *tag++);
}
}
+#endif //CONFIG_ENCODERS
/* Input stream */
/* link with avio functions */
+#ifdef CONFIG_ENCODERS
static void url_write_packet(void *opaque, uint8_t *buf, int buf_size)
{
URLContext *h = opaque;
url_write(h, buf, buf_size);
}
+#else
+#define url_write_packet NULL
+#endif //CONFIG_ENCODERS
static int url_read_packet(void *opaque, uint8_t *buf, int buf_size)
{
return s->opaque;
}
+#ifdef CONFIG_ENCODERS
/* XXX: currently size is limited */
int url_fprintf(ByteIOContext *s, const char *fmt, ...)
{
put_buffer(s, buf, strlen(buf));
return ret;
}
+#endif //CONFIG_ENCODERS
/* note: unlike fgets, the EOL character is not returned and a whole
line is parsed. return NULL if first char read was EOF */
return s->max_packet_size;
}
+#ifdef CONFIG_ENCODERS
/* buffer handling */
int url_open_buf(ByteIOContext *s, uint8_t *buf, int buf_size, int flags)
{
av_free(d);
return size;
}
+#endif //CONFIG_ENCODERS
/* disable pts hack for testing */
int ffm_nopts = 0;
+#ifdef CONFIG_ENCODERS
static void flush_packet(AVFormatContext *s)
{
FFMContext *ffm = s->priv_data;
av_freep(&s->streams[i]->priv_data);
return 0;
}
+#endif //CONFIG_ENCODERS
/* ffm demux */
ffm_seek,
};
+#ifdef CONFIG_ENCODERS
static AVOutputFormat ffm_oformat = {
"ffm",
"ffm format",
ffm_write_packet,
ffm_write_trailer,
};
+#endif //CONFIG_ENCODERS
int ffm_init(void)
{
av_register_input_format(&ffm_iformat);
+#ifdef CONFIG_ENCODERS
av_register_output_format(&ffm_oformat);
+#endif //CONFIG_ENCODERS
return 0;
}
return 0;
}
+#ifdef CONFIG_ENCODERS
/* simple formats */
static int mp3_write_header(struct AVFormatContext *s)
{
}
return 0;
}
+#endif //CONFIG_ENCODERS
AVInputFormat mp3_iformat = {
"mp3",
.extensions = "mp2,mp3", /* XXX: use probe */
};
+#ifdef CONFIG_ENCODERS
AVOutputFormat mp2_oformat = {
"mp2",
"MPEG audio layer 2",
mp3_write_trailer,
};
#endif
+#endif //CONFIG_ENCODERS
int mp3_init(void)
{
av_register_input_format(&mp3_iformat);
+#ifdef CONFIG_ENCODERS
av_register_output_format(&mp2_oformat);
#ifdef CONFIG_MP3LAME
av_register_output_format(&mp3_oformat);
#endif
+#endif //CONFIG_ENCODERS
return 0;
}
#define AUDIO_ID 0xc0
#define VIDEO_ID 0xe0
+#ifdef CONFIG_ENCODERS
extern AVOutputFormat mpeg1system_mux;
extern AVOutputFormat mpeg1vcd_mux;
extern AVOutputFormat mpeg2vob_mux;
return 0;
}
+#endif //CONFIG_ENCODERS
/*********************************************/
/* demux code */
return 0;
}
+#ifdef CONFIG_ENCODERS
static AVOutputFormat mpeg1system_mux = {
"mpeg",
"MPEG1 System format",
mpeg_mux_write_packet,
mpeg_mux_end,
};
+#endif //CONFIG_ENCODERS
AVInputFormat mpegps_demux = {
"mpeg",
int mpegps_init(void)
{
+#ifdef CONFIG_ENCODERS
av_register_output_format(&mpeg1system_mux);
av_register_output_format(&mpeg1vcd_mux);
av_register_output_format(&mpeg2vob_mux);
+#endif //CONFIG_ENCODERS
av_register_input_format(&mpegps_demux);
return 0;
}
int mpegts_init(void)
{
av_register_input_format(&mpegts_demux);
+#ifdef CONFIG_ENCODERS
av_register_output_format(&mpegts_mux);
+#endif
return 0;
}
#define BOUNDARY_TAG "ffserver"
+#ifdef CONFIG_ENCODERS
static int mpjpeg_write_header(AVFormatContext *s)
{
uint8_t buf1[256];
av_register_output_format(&single_jpeg_format);
return 0;
}
+#endif //CONFIG_ENCODERS
return 7; //not reached
}
+#ifdef CONFIG_ENCODERS
static int put_v(ByteIOContext *bc, uint64_t val)
{
int i;
return 0;
}
+#endif //CONFIG_ENCODERS
static int nut_probe(AVProbeData *p)
{
.extensions = "nut",
};
+#ifdef CONFIG_ENCODERS
static AVOutputFormat nut_oformat = {
"nut",
"nut format",
nut_write_packet,
nut_write_trailer,
};
+#endif //CONFIG_ENCODERS
int nut_init(void)
{
av_register_input_format(&nut_iformat);
+#ifdef CONFIG_ENCODERS
av_register_output_format(&nut_oformat);
+#endif //CONFIG_ENCODERS
return 0;
}
} OggContext ;
+#ifdef CONFIG_ENCODERS
static int ogg_write_header(AVFormatContext *avfcontext)
{
OggContext *context = avfcontext->priv_data;
ogg_write_packet,
ogg_write_trailer,
} ;
+#endif //CONFIG_ENCODERS
static int next_packet(AVFormatContext *avfcontext, ogg_packet *op) {
int ogg_init(void) {
+#ifdef CONFIG_ENCODERS
av_register_output_format(&ogg_oformat) ;
+#endif
av_register_input_format(&ogg_iformat);
return 0 ;
}
*/
#include "avformat.h"
+#ifdef CONFIG_ENCODERS
/* simple formats */
static int raw_write_header(struct AVFormatContext *s)
{
{
return 0;
}
+#endif //CONFIG_ENCODERS
/* raw input */
static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap)
.extensions = "ac3",
};
+#ifdef CONFIG_ENCODERS
AVOutputFormat ac3_oformat = {
"ac3",
"raw ac3",
raw_write_packet,
raw_write_trailer,
};
+#endif //CONFIG_ENCODERS
AVInputFormat h263_iformat = {
"h263",
.value = CODEC_ID_H263,
};
+#ifdef CONFIG_ENCODERS
AVOutputFormat h263_oformat = {
"h263",
"raw h263",
raw_write_packet,
raw_write_trailer,
};
+#endif //CONFIG_ENCODERS
AVInputFormat m4v_iformat = {
"m4v",
.value = CODEC_ID_MPEG4,
};
+#ifdef CONFIG_ENCODERS
AVOutputFormat m4v_oformat = {
"m4v",
"raw MPEG4 video format",
raw_write_packet,
raw_write_trailer,
};
+#endif //CONFIG_ENCODERS
AVInputFormat h264_iformat = {
"h264",
.value = CODEC_ID_H264,
};
+#ifdef CONFIG_ENCODERS
AVOutputFormat h264_oformat = {
"h264",
"raw H264 video format",
raw_write_packet,
raw_write_trailer,
};
+#endif //CONFIG_ENCODERS
AVInputFormat mpegvideo_iformat = {
"mpegvideo",
.value = CODEC_ID_MPEG1VIDEO,
};
+#ifdef CONFIG_ENCODERS
AVOutputFormat mpeg1video_oformat = {
"mpeg1video",
"MPEG video",
raw_write_packet,
raw_write_trailer,
};
+#endif //CONFIG_ENCODERS
AVInputFormat mjpeg_iformat = {
"mjpeg",
.value = CODEC_ID_MJPEG,
};
+#ifdef CONFIG_ENCODERS
AVOutputFormat mjpeg_oformat = {
"mjpeg",
"MJPEG video",
raw_write_packet,
raw_write_trailer,
};
+#endif //CONFIG_ENCODERS
/* pcm formats */
+#if !defined(CONFIG_ENCODERS) && defined(CONFIG_DECODERS)
+
+#define PCMDEF(name, long_name, ext, codec) \
+AVInputFormat pcm_ ## name ## _iformat = {\
+ #name,\
+ long_name,\
+ 0,\
+ NULL,\
+ raw_read_header,\
+ raw_read_packet,\
+ raw_read_close,\
+ .extensions = ext,\
+ .value = codec,\
+};
+
+#else
#define PCMDEF(name, long_name, ext, codec) \
AVInputFormat pcm_ ## name ## _iformat = {\
raw_write_packet,\
raw_write_trailer,\
};
+#endif //CONFIG_ENCODERS
#ifdef WORDS_BIGENDIAN
#define BE_DEF(s) s
.value = CODEC_ID_RAWVIDEO,
};
+#ifdef CONFIG_ENCODERS
AVOutputFormat rawvideo_oformat = {
"rawvideo",
"raw video format",
raw_write_packet,
raw_write_trailer,
};
+#endif //CONFIG_ENCODERS
+#ifdef CONFIG_ENCODERS
static int null_write_packet(struct AVFormatContext *s,
int stream_index,
const uint8_t *buf, int size, int64_t pts)
raw_write_trailer,
.flags = AVFMT_NOFILE | AVFMT_RAWPICTURE,
};
+#endif //CONFIG_ENCODERS
+
+#ifndef CONFIG_ENCODERS
+#define av_register_output_format(format)
+#endif
+#ifndef CONFIG_DECODERS
+#define av_register_input_format(format)
+#endif
int raw_init(void)
{
int old_format;
} RMContext;
+#ifdef CONFIG_ENCODERS
static void put_str(ByteIOContext *s, const char *tag)
{
put_be16(s,strlen(tag));
put_flush_packet(pb);
return 0;
}
+#endif //CONFIG_ENCODERS
/***************************************************/
rm_read_close,
};
+#ifdef CONFIG_ENCODERS
static AVOutputFormat rm_oformat = {
"rm",
"rm format",
rm_write_packet,
rm_write_trailer,
};
+#endif //CONFIG_ENCODERS
int rm_init(void)
{
av_register_input_format(&rm_iformat);
+#ifdef CONFIG_ENCODERS
av_register_output_format(&rm_oformat);
+#endif //CONFIG_ENCODERS
return 0;
}
int tag;
} SWFContext;
+#ifdef CONFIG_ENCODERS
static void put_swf_tag(AVFormatContext *s, int tag)
{
SWFContext *swf = s->priv_data;
}
return 0;
}
+#endif //CONFIG_ENCODERS
/***********************************/
/* just to extract MP3 from swf */
swf_read_close,
};
+#ifdef CONFIG_ENCODERS
static AVOutputFormat swf_oformat = {
"swf",
"Flash format",
swf_write_packet,
swf_write_trailer,
};
+#endif //CONFIG_ENCODERS
int swf_init(void)
{
av_register_input_format(&swf_iformat);
+#ifdef CONFIG_ENCODERS
av_register_output_format(&swf_oformat);
+#endif //CONFIG_ENCODERS
return 0;
}
{ 0, 0 },
};
+#ifdef CONFIG_ENCODERS
/* WAVEFORMATEX header */
/* returns the size or -1 on error */
int put_wav_header(ByteIOContext *pb, AVCodecContext *enc)
return hdrsize;
}
+#endif //CONFIG_ENCODERS
/* We could be given one of the three possible structures here:
* WAVEFORMAT, PCMWAVEFORMAT or WAVEFORMATEX. Each structure
return id;
}
+#ifdef CONFIG_ENCODERS
typedef struct {
offset_t data;
} WAVContext;
}
return 0;
}
+#endif //CONFIG_ENCODERS
/* return the size of the found tag */
/* XXX: > 2GB ? */
wav_read_close,
};
+#ifdef CONFIG_ENCODERS
static AVOutputFormat wav_oformat = {
"wav",
"wav format",
wav_write_packet,
wav_write_trailer,
};
+#endif //CONFIG_ENCODERS
int wav_init(void)
{
av_register_input_format(&wav_iformat);
+#ifdef CONFIG_ENCODERS
av_register_output_format(&wav_oformat);
+#endif //CONFIG_ENCODERS
return 0;
}
#define Y4M_FRAME_MAGIC "FRAME"
#define Y4M_LINE_MAX 256
+#ifdef CONFIG_ENCODERS
static int yuv4_write_header(AVFormatContext *s)
{
AVStream *st;
yuv4_write_trailer,
.flags = AVFMT_RAWPICTURE,
};
+#endif //CONFIG_ENCODERS
/* Header size increased to allow room for optional flags */
#define MAX_YUV4_HEADER 80
int yuv4mpeg_init(void)
{
av_register_input_format(&yuv4mpegpipe_iformat);
+#ifdef CONFIG_ENCODERS
av_register_output_format(&yuv4mpegpipe_oformat);
+#endif //CONFIG_ENCODERS
return 0;
}