Statistics
| Branch: | Revision:

ffmpeg / libavcodec / avcodec.h @ 0151a6f5

History | View | Annotate | Download (17.5 KB)

1
#ifndef AVCODEC_H
2
#define AVCODEC_H
3

    
4
#include "common.h"
5

    
6
#define LIBAVCODEC_VERSION_INT 0x000406
7
#define LIBAVCODEC_VERSION     "0.4.6"
8
#define LIBAVCODEC_BUILD       4614
9
#define LIBAVCODEC_BUILD_STR   "4614"
10

    
11
enum CodecID {
12
    CODEC_ID_NONE, 
13
    CODEC_ID_MPEG1VIDEO,
14
    CODEC_ID_H263,
15
    CODEC_ID_RV10,
16
    CODEC_ID_MP2,
17
    CODEC_ID_MP3LAME,
18
    CODEC_ID_AC3,
19
    CODEC_ID_MJPEG,
20
    CODEC_ID_MPEG4,
21
    CODEC_ID_RAWVIDEO,
22
    CODEC_ID_MSMPEG4V1,
23
    CODEC_ID_MSMPEG4V2,
24
    CODEC_ID_MSMPEG4V3,
25
    CODEC_ID_WMV1,
26
    CODEC_ID_WMV2,
27
    CODEC_ID_H263P,
28
    CODEC_ID_H263I,
29

    
30
    /* various pcm "codecs" */
31
    CODEC_ID_PCM_S16LE,
32
    CODEC_ID_PCM_S16BE,
33
    CODEC_ID_PCM_U16LE,
34
    CODEC_ID_PCM_U16BE,
35
    CODEC_ID_PCM_S8,
36
    CODEC_ID_PCM_U8,
37
    CODEC_ID_PCM_MULAW,
38
    CODEC_ID_PCM_ALAW,
39
};
40
#define CODEC_ID_MSMPEG4 CODEC_ID_MSMPEG4V3
41

    
42
enum CodecType {
43
    CODEC_TYPE_UNKNOWN = -1,
44
    CODEC_TYPE_VIDEO,
45
    CODEC_TYPE_AUDIO,
46
};
47

    
48
enum PixelFormat {
49
    PIX_FMT_ANY = -1,
50
    PIX_FMT_YUV420P,
51
    PIX_FMT_YUV422,
52
    PIX_FMT_RGB24,
53
    PIX_FMT_BGR24,
54
    PIX_FMT_YUV422P,
55
    PIX_FMT_YUV444P,
56
};
57

    
58
/* currently unused, may be used if 24/32 bits samples ever supported */
59
enum SampleFormat {
60
    SAMPLE_FMT_S16 = 0,         /* signed 16 bits */
61
};
62

    
63
/* in bytes */
64
#define AVCODEC_MAX_AUDIO_FRAME_SIZE 18432
65

    
66
/* motion estimation type, EPZS by default */
67
enum Motion_Est_ID {
68
    ME_ZERO = 1,
69
    ME_FULL,
70
    ME_LOG,
71
    ME_PHODS,
72
    ME_EPZS,
73
    ME_X1
74
};
75

    
76
/* only for ME compatiblity with old apps */
77
extern int motion_estimation_method;
78

    
79
/* ME algos sorted by quality */
80
static const int Motion_Est_QTab[] = { ME_ZERO, ME_PHODS, ME_LOG, 
81
                                       ME_X1, ME_EPZS, ME_FULL };
82

    
83
#define FF_MAX_B_FRAMES 4
84

    
85
/* encoding support */
86
/* note not everything is supported yet */
87

    
88
#define CODEC_FLAG_HQ     0x0001 /* high quality (non real time) encoding */
89
#define CODEC_FLAG_QSCALE 0x0002 /* use fixed qscale */
90
#define CODEC_FLAG_4MV    0x0004 /* 4 MV per MB allowed */
91
#define CODEC_FLAG_QPEL   0x0010 /* use qpel MC */
92
#define CODEC_FLAG_GMC    0x0020 /* use GMC */
93
#define CODEC_FLAG_TYPE   0x0040 /* fixed I/P frame type, from avctx->key_frame */
94
#define CODEC_FLAG_PART   0x0080 /* use data partitioning */
95
/* parent program gurantees that the input for b-frame containing streams is not written to 
96
   for at least s->max_b_frames+1 frames, if this is not set than the input will be copied */
97
#define CODEC_FLAG_INPUT_PRESERVED 0x0100
98
#define CODEC_FLAG_PASS1 0x0200  /* use internal 2pass ratecontrol in first  pass mode */
99
#define CODEC_FLAG_PASS2 0x0400  /* use internal 2pass ratecontrol in second pass mode */
100
#define CODEC_FLAG_EXTERN_HUFF 0x1000 /* use external huffman table (for mjpeg) */
101
#define CODEC_FLAG_GRAY  0x2000 /* only decode/encode grayscale */
102

    
103
/* codec capabilities */
104

    
105
/* decoder can use draw_horiz_band callback */
106
#define CODEC_CAP_DRAW_HORIZ_BAND 0x0001
107

    
108
#define FRAME_RATE_BASE 10000
109

    
110
typedef struct AVCodecContext {
111
    int bit_rate;
112
    int bit_rate_tolerance; /* amount of +- bits (>0)*/
113
    int flags;
114
    int sub_id;    /* some codecs needs additionnal format info. It is
115
                      stored there */
116
    
117
    int me_method; /* ME algorithm used for video coding */
118
    
119
    /* extra data from parent application to codec, e.g. huffman table
120
       for mjpeg */
121
    /* the parent should allocate and free this buffer */
122
    void *extradata;
123
    int extradata_size;
124
    
125
    /* video only */
126
    int frame_rate; /* frames per sec multiplied by FRAME_RATE_BASE */
127
    int width, height;
128
    int aspect_ratio_info;
129
#define FF_ASPECT_SQUARE 1
130
#define FF_ASPECT_4_3_625 2
131
#define FF_ASPECT_4_3_525 3
132
#define FF_ASPECT_16_9_625 4
133
#define FF_ASPECT_16_9_525 5
134
    int gop_size; /* 0 = intra only */
135
    enum PixelFormat pix_fmt;  /* pixel format, see PIX_FMT_xxx */
136
    int repeat_pict; /* when decoding, this signal how much the picture */
137
                     /* must be delayed.                                */
138
                     /* extra_delay = (repeat_pict / 2) * (1/fps)       */
139
    /* if non NULL, 'draw_horiz_band' is called by the libavcodec
140
       decoder to draw an horizontal band. It improve cache usage. Not
141
       all codecs can do that. You must check the codec capabilities
142
       before */
143
    void (*draw_horiz_band)(struct AVCodecContext *s,
144
                            UINT8 **src_ptr, int linesize,
145
                            int y, int width, int height);
146

    
147
    /* audio only */
148
    int sample_rate; /* samples per sec */
149
    int channels;
150
    int sample_fmt;  /* sample format, currenly unused */
151

    
152
    /* the following data should not be initialized */
153
    int frame_size;     /* in samples, initialized when calling 'init' */
154
    int frame_number;   /* audio or video frame number */
155
    int real_pict_num;  /* returns the real picture number of
156
                           previous encoded frame */
157
    int key_frame;      /* true if the previous compressed frame was 
158
                           a key frame (intra, or seekable) */
159
    int pict_type;      /* picture type of the previous 
160
                           encoded frame */
161
/* FIXME: these should have FF_ */
162
#define I_TYPE 1 // Intra
163
#define P_TYPE 2 // Predicted
164
#define B_TYPE 3 // Bi-dir predicted
165
#define S_TYPE 4 // S(GMC)-VOP MPEG4
166

    
167
    int delay;          /* number of frames the decoded output 
168
                           will be delayed relative to the encoded input */
169
    uint8_t *mbskip_table; /* =1 if MB didnt change, is only valid for I/P frames 
170
                              stride= mb_width = (width+15)>>4 */
171
    
172
    /* encoding parameters */
173
    int quality;      /* quality of the previous encoded frame 
174
                         (between 1 (good) and 31 (bad)) 
175
                         this is allso used to set the quality in vbr mode
176
                         and the per frame quality in CODEC_FLAG_TYPE (second pass mode) */
177
    float qcompress;  /* amount of qscale change between easy & hard scenes (0.0-1.0)*/
178
    float qblur;      /* amount of qscale smoothing over time (0.0-1.0) */
179
    int qmin;         /* min qscale */
180
    int qmax;         /* max qscale */
181
    int max_qdiff;    /* max qscale difference between frames */
182
    int max_b_frames; /* maximum b frames, the output will be delayed by max_b_frames+1 relative to the input */
183
    float b_quant_factor;/* qscale factor between ips and b frames */
184
    int rc_strategy;
185
    int b_frame_strategy;
186

    
187
    int hurry_up;     /* when set to 1 during decoding, b frames will be skiped
188
                         when set to 2 idct/dequant will be skipped too */
189
    
190
    struct AVCodec *codec;
191
    void *priv_data;
192

    
193
    /* The following data is for RTP friendly coding */
194
    /* By now only H.263/H.263+/MPEG4 coder honours this   */
195
    int rtp_mode;   /* 1 for activate RTP friendly-mode           */
196
                    /* highers numbers represent more error-prone */
197
                    /* enviroments, by now just "1" exist         */
198
    
199
    int rtp_payload_size;   /* The size of the RTP payload, the coder will  */
200
                            /* do it's best to deliver a chunk with size    */
201
                            /* below rtp_payload_size, the chunk will start */
202
                            /* with a start code on some codecs like H.263  */
203
                            /* This doesn't take account of any particular  */
204
                            /* headers inside the transmited RTP payload    */
205

    
206
    
207
    /* The RTP callcack: This function is called  */
208
    /* every time the encoder as a packet to send */
209
    /* Depends on the encoder if the data starts  */
210
    /* with a Start Code (it should) H.263 does   */
211
    void (*rtp_callback)(void *data, int size, int packet_number); 
212

    
213
    /* These are for PSNR calculation, if you set get_psnr to 1 */
214
    /* after encoding you will have the PSNR on psnr_y/cb/cr    */
215
    int get_psnr;
216
    float psnr_y;
217
    float psnr_cb;
218
    float psnr_cr;
219
    
220
    /* statistics, used for 2-pass encoding */
221
    int mv_bits;
222
    int header_bits;
223
    int i_tex_bits;
224
    int p_tex_bits;
225
    int i_count;
226
    int p_count;
227
    int skip_count;
228
    int misc_bits; // cbp, mb_type
229
    int frame_bits;
230
                 
231
    /* the following fields are ignored */
232
    void *opaque;   /* can be used to carry app specific stuff */
233
    char codec_name[32];
234
    enum CodecType codec_type; /* see CODEC_TYPE_xxx */
235
    enum CodecID codec_id; /* see CODEC_ID_xxx */
236
    unsigned int codec_tag;  /* codec tag, only used if unknown codec */
237
    
238
    int workaround_bugs;       /* workaround bugs in encoders which cannot be detected automatically */
239
    int luma_elim_threshold;
240
    int chroma_elim_threshold;
241
    int strict_std_compliance; /* strictly follow the std (MPEG4, ...) */
242
    float b_quant_offset;/* qscale offset between ips and b frames, not implemented yet */
243
    int error_resilience;
244
    
245
#ifndef MBC
246
#define MBC 128
247
#define MBR 96
248
#endif
249
    int *quant_store; /* field for communicating with external postprocessing */
250
    unsigned qstride;
251
    //FIXME this should be reordered after kabis API is finished ...
252
    /*
253
        Note: Below are located reserved fields for further usage
254
        It requires for ABI !!!
255
        If you'll perform some changes then borrow new space from these fields
256
        (void * can be safety replaced with struct * ;)
257
        P L E A S E ! ! !
258
        IMPORTANT: Never change order of already declared fields!!!
259
    */
260
    unsigned long long int
261
            ull_res0,ull_res1,ull_res2,ull_res3,ull_res4,ull_res5,
262
            ull_res6,ull_res7,ull_res8,ull_res9,ull_res10,ull_res11,ull_res12;
263
    float
264
            flt_res0,flt_res1,flt_res2,flt_res3,flt_res4,flt_res5,
265
            flt_res6,flt_res7,flt_res8,flt_res9,flt_res10,flt_res11;
266
    void
267
            *ptr_res0,*ptr_res1,*ptr_res2,*ptr_res3,*ptr_res4,*ptr_res5,
268
            *ptr_res6,*ptr_res7,*ptr_res8,*ptr_res9,*ptr_res10,*ptr_res11;
269
    unsigned long int
270
            ul_res0,ul_res1,ul_res2,ul_res3,ul_res4,ul_res5,
271
            ul_res6,ul_res7,ul_res8,ul_res9,ul_res10,ul_res11,ul_res12;
272
    unsigned int
273
            ui_res0,ui_res1,ui_res2,ui_res3,ui_res4,ui_res5,
274
            ui_res6;
275
    unsigned short int
276
            us_res0,us_res1,us_res2,us_res3,us_res4,us_res5,
277
            us_res6,us_res7,us_res8,us_res9,us_res10,us_res11,us_res12;
278
    unsigned char
279
            uc_res0,uc_res1,uc_res2,uc_res3,uc_res4,uc_res5,
280
            uc_res6,uc_res7,uc_res8,uc_res9,uc_res10,uc_res11,uc_res12;    
281
} AVCodecContext;
282

    
283
typedef struct AVCodec {
284
    char *name;
285
    int type;
286
    int id;
287
    int priv_data_size;
288
    int (*init)(AVCodecContext *);
289
    int (*encode)(AVCodecContext *, UINT8 *buf, int buf_size, void *data);
290
    int (*close)(AVCodecContext *);
291
    int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, 
292
                  UINT8 *buf, int buf_size);
293
    int capabilities;
294
    struct AVCodec *next;
295
    /*
296
        Note: Below are located reserved fields for further usage
297
        It requires for ABI !!!
298
        If you'll perform some changes then borrow new space from these fields
299
        (void * can be safety replaced with struct * ;)
300
        P L E A S E ! ! !
301
        IMPORTANT: Never change order of already declared fields!!!
302
    */
303
    unsigned long long int
304
            ull_res0,ull_res1,ull_res2,ull_res3,ull_res4,ull_res5,
305
            ull_res6,ull_res7,ull_res8,ull_res9,ull_res10,ull_res11,ull_res12;
306
    float
307
            flt_res0,flt_res1,flt_res2,flt_res3,flt_res4,flt_res5,
308
            flt_res6,flt_res7,flt_res8,flt_res9,flt_res10,flt_res11,flt_res12;
309
    void
310
            *ptr_res0,*ptr_res1,*ptr_res2,*ptr_res3,*ptr_res4,*ptr_res5,
311
            *ptr_res6,*ptr_res7,*ptr_res8,*ptr_res9,*ptr_res10,*ptr_res11,*ptr_res12;
312
} AVCodec;
313

    
314
/* three components are given, that's all */
315
typedef struct AVPicture {
316
    UINT8 *data[3];
317
    int linesize[3];
318
} AVPicture;
319

    
320
extern AVCodec ac3_encoder;
321
extern AVCodec mp2_encoder;
322
extern AVCodec mp3lame_encoder;
323
extern AVCodec mpeg1video_encoder;
324
extern AVCodec h263_encoder;
325
extern AVCodec h263p_encoder;
326
extern AVCodec rv10_encoder;
327
extern AVCodec mjpeg_encoder;
328
extern AVCodec mpeg4_encoder;
329
extern AVCodec msmpeg4v1_encoder;
330
extern AVCodec msmpeg4v2_encoder;
331
extern AVCodec msmpeg4v3_encoder;
332
extern AVCodec wmv1_encoder;
333
extern AVCodec wmv2_encoder;
334

    
335
extern AVCodec h263_decoder;
336
extern AVCodec mpeg4_decoder;
337
extern AVCodec msmpeg4v1_decoder;
338
extern AVCodec msmpeg4v2_decoder;
339
extern AVCodec msmpeg4v3_decoder;
340
extern AVCodec wmv1_decoder;
341
extern AVCodec wmv2_decoder;
342
extern AVCodec mpeg_decoder;
343
extern AVCodec h263i_decoder;
344
extern AVCodec rv10_decoder;
345
extern AVCodec mjpeg_decoder;
346
extern AVCodec mp2_decoder;
347
extern AVCodec mp3_decoder;
348

    
349
/* pcm codecs */
350
#define PCM_CODEC(id, name) \
351
extern AVCodec name ## _decoder; \
352
extern AVCodec name ## _encoder;
353

    
354
PCM_CODEC(CODEC_ID_PCM_S16LE, pcm_s16le);
355
PCM_CODEC(CODEC_ID_PCM_S16BE, pcm_s16be);
356
PCM_CODEC(CODEC_ID_PCM_U16LE, pcm_u16le);
357
PCM_CODEC(CODEC_ID_PCM_U16BE, pcm_u16be);
358
PCM_CODEC(CODEC_ID_PCM_S8, pcm_s8);
359
PCM_CODEC(CODEC_ID_PCM_U8, pcm_u8);
360
PCM_CODEC(CODEC_ID_PCM_ALAW, pcm_alaw);
361
PCM_CODEC(CODEC_ID_PCM_MULAW, pcm_mulaw);
362

    
363
#undef PCM_CODEC
364

    
365
/* dummy raw video codec */
366
extern AVCodec rawvideo_codec;
367

    
368
/* the following codecs use external GPL libs */
369
extern AVCodec ac3_decoder;
370

    
371
/* resample.c */
372

    
373
struct ReSampleContext;
374

    
375
typedef struct ReSampleContext ReSampleContext;
376

    
377
ReSampleContext *audio_resample_init(int output_channels, int input_channels, 
378
                                     int output_rate, int input_rate);
379
int audio_resample(ReSampleContext *s, short *output, short *input, int nb_samples);
380
void audio_resample_close(ReSampleContext *s);
381

    
382
/* YUV420 format is assumed ! */
383

    
384
struct ImgReSampleContext;
385

    
386
typedef struct ImgReSampleContext ImgReSampleContext;
387

    
388
ImgReSampleContext *img_resample_init(int output_width, int output_height,
389
                                      int input_width, int input_height);
390
void img_resample(ImgReSampleContext *s, 
391
                  AVPicture *output, AVPicture *input);
392

    
393
void img_resample_close(ImgReSampleContext *s);
394

    
395
void avpicture_fill(AVPicture *picture, UINT8 *ptr,
396
                    int pix_fmt, int width, int height);
397
int avpicture_get_size(int pix_fmt, int width, int height);
398

    
399
/* convert among pixel formats */
400
int img_convert(AVPicture *dst, int dst_pix_fmt,
401
                AVPicture *src, int pix_fmt, 
402
                int width, int height);
403

    
404
/* deinterlace a picture */
405
int avpicture_deinterlace(AVPicture *dst, AVPicture *src,
406
                          int pix_fmt, int width, int height);
407

    
408
/* external high level API */
409

    
410
extern AVCodec *first_avcodec;
411

    
412
/* returns LIBAVCODEC_VERSION_INT constant */
413
unsigned avcodec_version(void);
414
/* returns LIBAVCODEC_BUILD constant */
415
unsigned avcodec_build(void);
416
void avcodec_init(void);
417

    
418
void avcodec_set_bit_exact(void);
419

    
420
void register_avcodec(AVCodec *format);
421
AVCodec *avcodec_find_encoder(enum CodecID id);
422
AVCodec *avcodec_find_encoder_by_name(const char *name);
423
AVCodec *avcodec_find_decoder(enum CodecID id);
424
AVCodec *avcodec_find_decoder_by_name(const char *name);
425
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode);
426

    
427
int avcodec_open(AVCodecContext *avctx, AVCodec *codec);
428
int avcodec_decode_audio(AVCodecContext *avctx, INT16 *samples, 
429
                         int *frame_size_ptr,
430
                         UINT8 *buf, int buf_size);
431
int avcodec_decode_video(AVCodecContext *avctx, AVPicture *picture, 
432
                         int *got_picture_ptr,
433
                         UINT8 *buf, int buf_size);
434
int avcodec_encode_audio(AVCodecContext *avctx, UINT8 *buf, int buf_size, 
435
                         const short *samples);
436
int avcodec_encode_video(AVCodecContext *avctx, UINT8 *buf, int buf_size, 
437
                         const AVPicture *pict);
438

    
439
int avcodec_close(AVCodecContext *avctx);
440

    
441
void avcodec_register_all(void);
442

    
443
void avcodec_flush_buffers(AVCodecContext *avctx);
444

    
445
#ifdef FF_POSTPROCESS
446
extern int quant_store[MBR+1][MBC+1]; // [Review]
447
#endif
448

    
449

    
450
/**
451
 * Interface for 0.5.0 version
452
 *
453
 * do not even think about it's usage for this moment
454
 */
455

    
456
typedef struct {
457
    // compressed size used from given memory buffer
458
    int size;
459
    /// I/P/B frame type
460
    int frame_type;
461
} avc_enc_result_t;
462

    
463
/**
464
 * Commands
465
 * order can't be changed - once it was defined
466
 */
467
typedef enum {
468
    // general commands
469
    AVC_OPEN_BY_NAME = 0xACA000,
470
    AVC_OPEN_BY_CODEC_ID,
471
    AVC_OPEN_BY_FOURCC,
472
    AVC_CLOSE,
473

    
474
    AVC_FLUSH,
475
    // pin - struct { uint8_t* src, uint_t src_size }
476
    // pout - struct { AVPicture* img, consumed_bytes,
477
    AVC_DECODE,
478
    // pin - struct { AVPicture* img, uint8_t* dest, uint_t dest_size }
479
    // pout - uint_t used_from_dest_size
480
    AVC_ENCODE, 
481

    
482
    // query/get video commands
483
    AVC_GET_VERSION = 0xACB000,
484
    AVC_GET_WIDTH,
485
    AVC_GET_HEIGHT,
486
    AVC_GET_DELAY,
487
    AVC_GET_QUANT_TABLE,
488
    // ...
489

    
490
    // query/get audio commands
491
    AVC_GET_FRAME_SIZE = 0xABC000,
492

    
493
    // maybe define some simple structure which
494
    // might be passed to the user - but they can't
495
    // contain any codec specific parts and these
496
    // calls are usualy necessary only few times
497

    
498
    // set video commands
499
    AVC_SET_WIDTH = 0xACD000,
500
    AVC_SET_HEIGHT,
501

    
502
    // set video encoding commands
503
    AVC_SET_FRAME_RATE = 0xACD800,
504
    AVC_SET_QUALITY,
505
    AVC_SET_HURRY_UP,
506

    
507
    // set audio commands
508
    AVC_SET_SAMPLE_RATE = 0xACE000,
509
    AVC_SET_CHANNELS,
510

    
511
} avc_cmd_t;
512

    
513
/**
514
 * \param handle  allocated private structure by libavcodec
515
 *                for initialization pass NULL - will be returned pout
516
 *                user is supposed to know nothing about its structure
517
 * \param cmd     type of operation to be performed
518
 * \param pint    input parameter
519
 * \param pout    output parameter
520
 *
521
 * \returns  command status - eventually for query command it might return
522
 * integer resulting value
523
 */
524
int avcodec(void* handle, avc_cmd_t cmd, void* pin, void* pout);
525

    
526
/* memory */
527
void *av_malloc(int size);
528
void *av_mallocz(int size);
529
void av_free(void *ptr);
530
void __av_freep(void **ptr);
531
#define av_freep(p) __av_freep((void **)(p))
532

    
533
#endif /* AVCODEC_H */