d02c3e7211bf3fb8b9ab95e3a1b40181714ad92d
[ffmpeg.git] / libavcodec / avcodec.h
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       4644
9 #define LIBAVCODEC_BUILD_STR   "4644"
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_VORBIS,
19     CODEC_ID_AC3,
20     CODEC_ID_MJPEG,
21     CODEC_ID_MJPEGB,
22     CODEC_ID_MPEG4,
23     CODEC_ID_RAWVIDEO,
24     CODEC_ID_MSMPEG4V1,
25     CODEC_ID_MSMPEG4V2,
26     CODEC_ID_MSMPEG4V3,
27     CODEC_ID_WMV1,
28     CODEC_ID_WMV2,
29     CODEC_ID_H263P,
30     CODEC_ID_H263I,
31     CODEC_ID_SVQ1,
32     CODEC_ID_DVVIDEO,
33     CODEC_ID_DVAUDIO,
34     CODEC_ID_WMAV1,
35     CODEC_ID_WMAV2,
36     CODEC_ID_MACE3,
37     CODEC_ID_MACE6,
38     CODEC_ID_HUFFYUV,
39
40     /* various pcm "codecs" */
41     CODEC_ID_PCM_S16LE,
42     CODEC_ID_PCM_S16BE,
43     CODEC_ID_PCM_U16LE,
44     CODEC_ID_PCM_U16BE,
45     CODEC_ID_PCM_S8,
46     CODEC_ID_PCM_U8,
47     CODEC_ID_PCM_MULAW,
48     CODEC_ID_PCM_ALAW,
49
50     /* various adpcm codecs */
51     CODEC_ID_ADPCM_IMA_QT,
52     CODEC_ID_ADPCM_IMA_WAV,
53     CODEC_ID_ADPCM_MS,
54 };
55
56 enum CodecType {
57     CODEC_TYPE_UNKNOWN = -1,
58     CODEC_TYPE_VIDEO,
59     CODEC_TYPE_AUDIO,
60 };
61
62 enum PixelFormat {
63     PIX_FMT_ANY = -1,
64     PIX_FMT_YUV420P,
65     PIX_FMT_YUV422,
66     PIX_FMT_RGB24,
67     PIX_FMT_BGR24,
68     PIX_FMT_YUV422P,
69     PIX_FMT_YUV444P,
70     PIX_FMT_RGBA32,
71     PIX_FMT_BGRA32,
72     PIX_FMT_YUV410P,
73     PIX_FMT_YUV411P,
74     PIX_FMT_RGB565,
75     PIX_FMT_RGB555,
76 //    PIX_FMT_RGB5551,
77     PIX_FMT_BGR565,
78     PIX_FMT_BGR555,
79 //    PIX_FMT_GBR565,
80 //    PIX_FMT_GBR555
81 };
82
83 /* currently unused, may be used if 24/32 bits samples ever supported */
84 enum SampleFormat {
85     SAMPLE_FMT_S16 = 0,         /* signed 16 bits */
86 };
87
88 /* in bytes */
89 #define AVCODEC_MAX_AUDIO_FRAME_SIZE 131072
90
91 /**
92  * Required number of zero bytes at the end of the input bitstream for decoding.
93  * to avoid overreading (and possibly segfaulting)
94  */
95 #define FF_INPUT_BUFFER_PADDING_SIZE 8
96
97 /* motion estimation type, EPZS by default */
98 enum Motion_Est_ID {
99     ME_ZERO = 1,
100     ME_FULL,
101     ME_LOG,
102     ME_PHODS,
103     ME_EPZS,
104     ME_X1
105 };
106
107 typedef struct RcOverride{
108     int start_frame;
109     int end_frame;
110     int qscale; // if this is 0 then quality_factor will be used instead
111     float quality_factor;
112 } RcOverride;
113
114 /* only for ME compatiblity with old apps */
115 extern int motion_estimation_method;
116
117 /* ME algos sorted by quality */
118 static const int Motion_Est_QTab[] = { ME_ZERO, ME_PHODS, ME_LOG, 
119                                        ME_X1, ME_EPZS, ME_FULL };
120
121
122 #define FF_MAX_B_FRAMES 8
123
124 /* encoding support
125    these flags can be passed in AVCodecContext.flags before initing 
126    Note: note not everything is supported yet 
127 */
128
129 #define CODEC_FLAG_HQ     0x0001  /* brute force MB-type decission mode (slow) */
130 #define CODEC_FLAG_QSCALE 0x0002  /* use fixed qscale */
131 #define CODEC_FLAG_4MV    0x0004  /* 4 MV per MB allowed */
132 #define CODEC_FLAG_QPEL   0x0010  /* use qpel MC */
133 #define CODEC_FLAG_GMC    0x0020  /* use GMC */
134 #define CODEC_FLAG_PART   0x0080  /* use data partitioning */
135 /* parent program gurantees that the input for b-frame containing streams is not written to 
136    for at least s->max_b_frames+1 frames, if this is not set than the input will be copied */
137 #define CODEC_FLAG_INPUT_PRESERVED 0x0100
138 #define CODEC_FLAG_PASS1 0x0200   /* use internal 2pass ratecontrol in first  pass mode */
139 #define CODEC_FLAG_PASS2 0x0400   /* use internal 2pass ratecontrol in second pass mode */
140 #define CODEC_FLAG_EXTERN_HUFF 0x1000 /* use external huffman table (for mjpeg) */
141 #define CODEC_FLAG_GRAY  0x2000   /* only decode/encode grayscale */
142 #define CODEC_FLAG_EMU_EDGE 0x4000/* dont draw edges */
143 #define CODEC_FLAG_PSNR           0x8000 /* error[?] variables will be set during encoding */
144 #define CODEC_FLAG_TRUNCATED  0x00010000 /* input bitstream might be truncated at a random location instead 
145                                             of only at frame boundaries */
146 #define CODEC_FLAG_NORMALIZE_AQP  0x00020000 /* normalize adaptive quantization */
147 #define CODEC_FLAG_INTERLACED_DCT 0x00040000 /* use interlaced dct */
148 #define CODEC_FLAG_LOW_DELAY      0x00080000 /* force low delay / will fail on b frames */
149 #define CODEC_FLAG_ALT_SCAN       0x00100000 /* use alternate scan */
150
151 /* codec capabilities */
152
153 #define CODEC_CAP_DRAW_HORIZ_BAND 0x0001 /* decoder can use draw_horiz_band callback */
154 #define CODEC_CAP_DR1             0x0002 /* direct rendering method 1 */
155 /* if 'parse_only' field is true, then avcodec_parse_frame() can be
156    used */
157 #define CODEC_CAP_PARSE_ONLY      0x0004
158 #define CODEC_CAP_TRUNCATED       0x0008
159
160 #define FRAME_RATE_BASE 10000
161
162 #define FF_COMMON_PICTURE \
163     uint8_t *data[4];\
164     int linesize[4];\
165     /**\
166      * pointer to the first allocated byte of the picture. can be used in get_buffer/release_buffer\
167      * this isnt used by lavc unless the default get/release_buffer() is used\
168      * encoding: \
169      * decoding: \
170      */\
171     uint8_t *base[4];\
172     /**\
173      * 1 -> keyframe, 0-> not\
174      * encoding: set by lavc\
175      * decoding: set by lavc\
176      */\
177     int key_frame;\
178 \
179     /**\
180      * picture type of the frame, see ?_TYPE below\
181      * encoding: set by lavc for coded_picture (and set by user for input)\
182      * decoding: set by lavc\
183      */\
184     int pict_type;\
185 \
186     /**\
187      * presentation timestamp in micro seconds (time when frame should be shown to user)\
188      * if 0 then the frame_rate will be used as reference\
189      * encoding: MUST be set by user\
190      * decoding: set by lavc\
191      */\
192     long long int pts;\
193 \
194     /**\
195      * picture number in bitstream order.\
196      * encoding: set by\
197      * decoding: set by lavc\
198      */\
199     int coded_picture_number;\
200     /**\
201      * encoding: set by\
202      * decoding: set by lavc\
203      * picture number in display order.\
204      */\
205     int display_picture_number;\
206 \
207     /**\
208      * quality (between 1 (good) and 31 (bad)) \
209      * encoding: set by lavc for coded_picture (and set by user for input)\
210      * decoding: set by lavc\
211      */\
212     float quality; \
213 \
214     /**\
215      * buffer age (1->was last buffer and dint change, 2->..., ...).\
216      * set to something large if the buffer has not been used yet \
217      * encoding: unused\
218      * decoding: MUST be set by get_buffer()\
219      */\
220     int age;\
221 \
222     /**\
223      * is this picture used as reference\
224      * encoding: unused\
225      * decoding: set by lavc (before get_buffer() call))\
226      */\
227     int reference;\
228 \
229     /**\
230      * QP table\
231      * encoding: unused\
232      * decoding: set by lavc\
233      */\
234     int8_t *qscale_table;\
235     /**\
236      * QP store stride\
237      * encoding: unused\
238      * decoding: set by lavc\
239      */\
240     int qstride;\
241 \
242     /**\
243      * mbskip_table[mb]>=1 if MB didnt change\
244      * stride= mb_width = (width+15)>>4\
245      * encoding: unused\
246      * decoding: set by lavc\
247      */\
248     uint8_t *mbskip_table;\
249 \
250     /**\
251      * for some private data of the user\
252      * encoding: unused\
253      * decoding: set by user\
254      */\
255     void *opaque;\
256 \
257     /**\
258      * error\
259      * encoding: set by lavc if flags&CODEC_FLAG_PSNR\
260      * decoding: unused\
261      */\
262     uint64_t error[4];\
263 \
264     /**\
265      * type of the buffer (to keep track of who has to dealloc data[*])\
266      * encoding: set by the one who allocs it\
267      * decoding: set by the one who allocs it\
268      * Note: user allocated (direct rendering) & internal buffers can not coexist currently\ 
269      */\
270     int type;\
271
272 #define FF_BUFFER_TYPE_INTERNAL 1
273 #define FF_BUFFER_TYPE_USER     2 // Direct rendering buffers
274 #define FF_BUFFER_TYPE_SHARED   4 // input frame for encoding(wont be dealloced)
275
276
277 #define FF_I_TYPE 1 // Intra
278 #define FF_P_TYPE 2 // Predicted
279 #define FF_B_TYPE 3 // Bi-dir predicted
280 #define FF_S_TYPE 4 // S(GMC)-VOP MPEG4
281
282 typedef struct AVVideoFrame {
283     FF_COMMON_PICTURE
284 } AVVideoFrame;
285
286 typedef struct AVCodecContext {
287     /**
288      * the average bitrate
289      * encoding: set by user. unused for constant quantizer encoding
290      * decoding: set by lavc. 0 or some bitrate if this info is available in the stream 
291      */
292     int bit_rate;
293
294     /**
295      * number of bits the bitstream is allowed to diverge from the reference
296      *           the reference can be CBR (for CBR pass1) or VBR (for pass2)
297      * encoding: set by user. unused for constant quantizer encoding
298      * decoding: unused
299      */
300     int bit_rate_tolerance; 
301
302     /**
303      * CODEC_FLAG_*
304      * encoding: set by user.
305      * decoding: set by user.
306      */
307     int flags;
308
309     /**
310      * some codecs needs additionnal format info. It is stored here
311      * encoding: set by user. 
312      * decoding: set by lavc. (FIXME is this ok?)
313      */
314     int sub_id;
315
316     /**
317      * motion estimation algorithm used for video coding
318      * encoding: MUST be set by user.
319      * decoding: unused
320      */
321     int me_method;
322
323     /**
324      * some codecs need / can use extra-data like huffman tables
325      * mjpeg: huffman tables
326      * rv10: additional flags
327      * mpeg4: global headers (they can be in the bitstream or here)
328      * encoding: set/allocated/freed by lavc.
329      * decoding: set/allocated/freed by user.
330      */
331     void *extradata;
332     int extradata_size;
333     
334     /* video only */
335     /**
336      * frames per sec multiplied by FRAME_RATE_BASE
337      * for variable fps this is the precission, so if the timestamps 
338      * can be specified in msec precssion then this is 1000*FRAME_RATE_BASE
339      * encoding: MUST be set by user
340      * decoding: set by lavc. 0 or the frame_rate if available
341      */
342     int frame_rate;
343
344     /**
345      * encoding: MUST be set by user. 
346      * decoding: set by user, some codecs might override / change it during playback
347      */
348     int width, height;
349     
350 #define FF_ASPECT_SQUARE 1
351 #define FF_ASPECT_4_3_625 2
352 #define FF_ASPECT_4_3_525 3
353 #define FF_ASPECT_16_9_625 4
354 #define FF_ASPECT_16_9_525 5
355 #define FF_ASPECT_EXTENDED 15
356
357     /**
358      * the number of pictures in a group of pitures, or 0 for intra_only
359      * encoding: set by user.
360      * decoding: unused
361      */
362     int gop_size;
363
364     /**
365      * pixel format, see PIX_FMT_xxx
366      * encoding: unused
367      * decoding: set by lavc.
368      */
369     enum PixelFormat pix_fmt;
370     
371     int repeat_pict; /* when decoding, this signal how much the picture */
372                      /* must be delayed.                                */
373                      /* extra_delay = (repeat_pict / 2) * (1/fps)       */
374     
375     /**
376      * if non NULL, 'draw_horiz_band' is called by the libavcodec
377      * decoder to draw an horizontal band. It improve cache usage. Not
378      * all codecs can do that. You must check the codec capabilities
379      * before
380      * encoding: unused
381      * decoding: set by user.
382      */
383     void (*draw_horiz_band)(struct AVCodecContext *s,
384                             UINT8 **src_ptr, int linesize,
385                             int y, int width, int height);
386
387     /* audio only */
388     int sample_rate; /* samples per sec */
389     int channels;
390     int sample_fmt;  /* sample format, currenly unused */
391
392     /* the following data should not be initialized */
393     int frame_size;     /* in samples, initialized when calling 'init' */
394     int frame_number;   /* audio or video frame number */
395     int real_pict_num;  /* returns the real picture number of
396                            previous encoded frame */
397     
398     /**
399      * 1 -> keyframe, 0-> not (this if for audio only, for video, AVVideoFrame.key_frame should be used)
400      * encoding: set by lavc (for the outputed bitstream, not the input frame)
401      * decoding: set by lavc (for the decoded  bitstream, not the displayed frame)
402      */
403     int key_frame;
404
405     /**
406      * number of frames the decoded output will be delayed relative to 
407      * the encoded input
408      * encoding: set by lavc.
409      * decoding: unused
410      */
411     int delay;
412     
413     /* encoding parameters */
414     float qcompress;  /* amount of qscale change between easy & hard scenes (0.0-1.0)*/
415     float qblur;      /* amount of qscale smoothing over time (0.0-1.0) */
416     
417     /**
418      * minimum quantizer
419      * encoding: set by user.
420      * decoding: unused
421      */
422     int qmin;
423
424     /**
425      * maximum quantizer
426      * encoding: set by user.
427      * decoding: unused
428      */
429     int qmax;
430
431     /**
432      * maximum quantizer difference etween frames
433      * encoding: set by user.
434      * decoding: unused
435      */
436     int max_qdiff;
437
438     /**
439      * maximum number of b frames between non b frames
440      * note: the output will be delayed by max_b_frames+1 relative to the input
441      * encoding: set by user.
442      * decoding: unused
443      */
444     int max_b_frames;
445
446     /**
447      * qscale factor between ip and b frames
448      * encoding: set by user.
449      * decoding: unused
450      */
451     float b_quant_factor;
452     
453     /** obsolete FIXME remove */
454     int rc_strategy;
455     int b_frame_strategy;
456
457     /**
458      * encoding: unused
459      * decoding: set by user. 1-> skip b frames, 2-> skip idct/dequant too, 5-> skip everything except header
460      */
461     int hurry_up;
462     
463     struct AVCodec *codec;
464     
465     void *priv_data;
466
467     /* The following data is for RTP friendly coding */
468     /* By now only H.263/H.263+/MPEG4 coder honours this   */
469     int rtp_mode;   /* 1 for activate RTP friendly-mode           */
470                     /* highers numbers represent more error-prone */
471                     /* enviroments, by now just "1" exist         */
472     
473     int rtp_payload_size;   /* The size of the RTP payload, the coder will  */
474                             /* do it's best to deliver a chunk with size    */
475                             /* below rtp_payload_size, the chunk will start */
476                             /* with a start code on some codecs like H.263  */
477                             /* This doesn't take account of any particular  */
478                             /* headers inside the transmited RTP payload    */
479
480     
481     /* The RTP callcack: This function is called  */
482     /* every time the encoder as a packet to send */
483     /* Depends on the encoder if the data starts  */
484     /* with a Start Code (it should) H.263 does   */
485     void (*rtp_callback)(void *data, int size, int packet_number); 
486
487     /* statistics, used for 2-pass encoding */
488     int mv_bits;
489     int header_bits;
490     int i_tex_bits;
491     int p_tex_bits;
492     int i_count;
493     int p_count;
494     int skip_count;
495     int misc_bits;
496     
497     /**
498      * number of bits used for the previously encoded frame
499      * encoding: set by lavc
500      * decoding: - for audio - bits_per_sample
501      */
502     int frame_bits;
503                  
504     /**
505      * private data of the user, can be used to carry app specific stuff
506      * encoding: set by user
507      * decoding: set by user
508      */
509     void *opaque;
510
511     char codec_name[32];
512     enum CodecType codec_type; /* see CODEC_TYPE_xxx */
513     enum CodecID codec_id; /* see CODEC_ID_xxx */
514     unsigned int codec_tag;  /* codec tag, only used if unknown codec */
515     
516     /**
517      * workaround bugs in encoders which sometimes cannot be detected automatically
518      * encoding: unused
519      * decoding: set by user
520      */
521     int workaround_bugs;
522 #define FF_BUG_AUTODETECT       1  //autodetection
523 #define FF_BUG_OLD_MSMPEG4      2
524 #define FF_BUG_XVID_ILACE       4
525 #define FF_BUG_UMP4             8
526 #define FF_BUG_NO_PADDING       16
527 #define FF_BUG_AC_VLC           32
528 #define FF_BUG_QPEL_CHROMA      64
529 //#define FF_BUG_FAKE_SCALABILITY 16 //autodetection should work 100%
530         
531     /**
532      * encoding: set by user
533      * decoding: unused
534      */
535     int luma_elim_threshold;
536     
537     /**
538      * encoding: set by user
539      * decoding: unused
540      */
541     int chroma_elim_threshold;
542     
543     /**
544      * strictly follow the std (MPEG4, ...)
545      * encoding: set by user
546      * decoding: unused
547      */
548     int strict_std_compliance;
549     
550     /**
551      * qscale offset between ip and b frames
552      * if > 0 then the last p frame quantizer will be used (q= lastp_q*factor+offset)
553      * if < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset)
554      * encoding: set by user.
555      * decoding: unused
556      */
557     float b_quant_offset;
558     
559     /**
560      * error resilience higher values will detect more errors but may missdetect
561      * some more or less valid parts as errors
562      * encoding: unused
563      * decoding: set by user
564      */
565     int error_resilience;
566 #define FF_ER_CAREFULL        1
567 #define FF_ER_COMPLIANT       2
568 #define FF_ER_AGGRESSIVE      3
569 #define FF_ER_VERY_AGGRESSIVE 4
570     
571     /**
572      * called at the beginning of each frame to get a buffer for it.
573      * if pic.reference is set then the frame will be read later by lavc
574      * encoding: unused
575      * decoding: set by lavc, user can override
576      */
577     int (*get_buffer)(struct AVCodecContext *c, AVVideoFrame *pic);
578     
579     /**
580      * called to release buffers which where allocated with get_buffer.
581      * a released buffer can be reused in get_buffer()
582      * pic.data[*] must be set to NULL
583      * encoding: unused
584      * decoding: set by lavc, user can override
585      */
586     void (*release_buffer)(struct AVCodecContext *c, AVVideoFrame *pic);
587
588     /**
589      * is 1 if the decoded stream contains b frames, 0 otherwise
590      * encoding: unused
591      * decoding: set by lavc
592      */
593     int has_b_frames;
594     
595     int block_align; /* used by some WAV based audio codecs */
596     
597     int parse_only; /* decoding only: if true, only parsing is done
598                        (function avcodec_parse_frame()). The frame
599                        data is returned. Only MPEG codecs support this now. */
600     
601     /**
602      * 0-> h263 quant 1-> mpeg quant
603      * encoding: set by user.
604      * decoding: unused
605      */
606     int mpeg_quant;
607     
608     /**
609      * pass1 encoding statistics output buffer
610      * encoding: set by lavc
611      * decoding: unused
612      */
613     char *stats_out; /* encoding statistics output buffer */
614     
615     /**
616      * pass2 encoding statistics input buffer.
617      * concatenated stuff from stats_out of pass1 should be placed here
618      * encoding: allocated/set/freed by user
619      * decoding: unused
620      */
621     char *stats_in;
622     
623     /**
624      * ratecontrol qmin qmax limiting method
625      * 0-> clipping, 1-> use a nice continous function to limit qscale wthin qmin/qmax
626      * encoding: set by user.
627      * decoding: unused
628      */
629     float rc_qsquish;
630
631     float rc_qmod_amp;
632     int rc_qmod_freq;
633     
634     /**
635      * ratecontrol override, see RcOverride
636      * encoding: allocated/set/freed by user.
637      * decoding: unused
638      */
639     RcOverride *rc_override;
640     int rc_override_count;
641     
642     /**
643      * rate control equation
644      * encoding: set by user
645      * decoding: unused
646      */
647     char *rc_eq;
648     
649     /**
650      * maximum bitrate
651      * encoding: set by user.
652      * decoding: unused
653      */
654     int rc_max_rate;
655     
656     /**
657      * minimum bitrate
658      * encoding: set by user.
659      * decoding: unused
660      */
661     int rc_min_rate;
662     
663     /**
664      * decoder bitstream buffer size
665      * encoding: set by user.
666      * decoding: unused
667      */
668     int rc_buffer_size;
669     float rc_buffer_aggressivity;
670
671     /**
672      * qscale factor between p and i frames
673      * encoding: set by user.
674      * decoding: unused
675      */
676     float i_quant_factor;
677     
678     /**
679      * qscale offset between p and i frames
680      * if > 0 then the last p frame quantizer will be used (q= lastp_q*factor+offset)
681      * if < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset)
682      * encoding: set by user.
683      * decoding: unused
684      */
685     float i_quant_offset;
686     
687     /**
688      * initial complexity for pass1 ratecontrol
689      * encoding: set by user.
690      * decoding: unused
691      */
692     float rc_initial_cplx;
693
694     /**
695      * dct algorithm, see FF_DCT_* below
696      * encoding: set by user
697      * decoding: unused
698      */
699     int dct_algo;
700 #define FF_DCT_AUTO    0
701 #define FF_DCT_FASTINT 1
702 #define FF_DCT_INT     2
703 #define FF_DCT_MMX     3
704 #define FF_DCT_MLIB    4
705 #define FF_DCT_ALTIVEC 5
706     
707     /**
708      * luminance masking (0-> disabled)
709      * encoding: set by user
710      * decoding: unused
711      */
712     float lumi_masking;
713     
714     /**
715      * temporary complexity masking (0-> disabled)
716      * encoding: set by user
717      * decoding: unused
718      */
719     float temporal_cplx_masking;
720     
721     /**
722      * spatial complexity masking (0-> disabled)
723      * encoding: set by user
724      * decoding: unused
725      */
726     float spatial_cplx_masking;
727     
728     /**
729      * p block masking (0-> disabled)
730      * encoding: set by user
731      * decoding: unused
732      */
733     float p_masking;
734
735     /**
736      * darkness masking (0-> disabled)
737      * encoding: set by user
738      * decoding: unused
739      */
740     float dark_masking;
741     
742     /**
743      * fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A')
744      * this is used to workaround some encoder bugs
745      * encoding: unused
746      * decoding: set by user, will be converted to upper case by lavc during init
747      */
748     int fourcc;
749
750     /**
751      * idct algorithm, see FF_IDCT_* below
752      * encoding: set by user
753      * decoding: set by user
754      */
755     int idct_algo;
756 #define FF_IDCT_AUTO         0
757 #define FF_IDCT_INT          1
758 #define FF_IDCT_SIMPLE       2
759 #define FF_IDCT_SIMPLEMMX    3
760 #define FF_IDCT_LIBMPEG2MMX  4
761 #define FF_IDCT_PS2          5
762 #define FF_IDCT_MLIB         6
763 #define FF_IDCT_ARM          7
764 #define FF_IDCT_ALTIVEC      8
765
766     /**
767      * slice count
768      * encoding: set by lavc
769      * decoding: set by user (or 0)
770      */
771     int slice_count;
772     /**
773      * slice offsets in the frame in bytes
774      * encoding: set/allocated by lavc
775      * decoding: set/allocated by user (or NULL)
776      */
777     int *slice_offset;
778
779     /**
780      * error concealment flags
781      * encoding: unused
782      * decoding: set by user
783      */
784     int error_concealment;
785 #define FF_EC_GUESS_MVS   1
786 #define FF_EC_DEBLOCK     2
787
788     /**
789      * dsp_mask could be used to disable unwanted
790      * CPU features (i.e. MMX, SSE. ...)
791      */
792      unsigned dsp_mask;
793
794     /**
795      * bits per sample/pixel from the demuxer (needed for huffyuv)
796      * encoding: set by lavc
797      * decoding: set by user
798      */
799      int bits_per_sample;
800     
801     /**
802      * prediction method (needed for huffyuv)
803      * encoding: set by user
804      * decoding: unused
805      */
806      int prediction_method;
807 #define FF_PRED_LEFT   0
808 #define FF_PRED_PLANE  1
809 #define FF_PRED_MEDIAN 2
810     
811     /**
812      * aspect ratio. (0 if unknown)
813      * encoding: set by user.
814      * decoding: set by lavc.
815      */
816     float aspect_ratio;
817
818     /**
819      * the picture in the bitstream
820      * encoding: set by lavc
821      * decoding: set by lavc
822      */
823     AVVideoFrame *coded_picture;
824
825     /**
826      * debug 
827      * encoding: set by user.
828      * decoding: set by user.
829      */
830     int debug;
831 #define FF_DEBUG_PICT_INFO 1
832 #define FF_DEBUG_RC        2
833 #define FF_DEBUG_BITSTREAM 4
834 #define FF_DEBUG_MB_TYPE   8
835 #define FF_DEBUG_QP        16
836 #define FF_DEBUG_MV        32
837 #define FF_DEBUG_VIS_MV    64
838     
839     /**
840      * error
841      * encoding: set by lavc if flags&CODEC_FLAG_PSNR
842      * decoding: unused
843      */
844     uint64_t error[4];
845 } AVCodecContext;
846
847 typedef struct AVCodec {
848     const char *name;
849     int type;
850     int id;
851     int priv_data_size;
852     int (*init)(AVCodecContext *);
853     int (*encode)(AVCodecContext *, UINT8 *buf, int buf_size, void *data);
854     int (*close)(AVCodecContext *);
855     int (*decode)(AVCodecContext *, void *outdata, int *outdata_size,
856                   UINT8 *buf, int buf_size);
857     int capabilities;
858     struct AVCodec *next;
859 } AVCodec;
860
861 /** 
862  * four components are given, that's all.
863  * the last component is alpha
864  */
865 typedef struct AVPicture {
866     UINT8 *data[4];
867     int linesize[4];
868 } AVPicture;
869
870 extern AVCodec ac3_encoder;
871 extern AVCodec mp2_encoder;
872 extern AVCodec mp3lame_encoder;
873 extern AVCodec oggvorbis_encoder;
874 extern AVCodec mpeg1video_encoder;
875 extern AVCodec h263_encoder;
876 extern AVCodec h263p_encoder;
877 extern AVCodec rv10_encoder;
878 extern AVCodec mjpeg_encoder;
879 extern AVCodec mpeg4_encoder;
880 extern AVCodec msmpeg4v1_encoder;
881 extern AVCodec msmpeg4v2_encoder;
882 extern AVCodec msmpeg4v3_encoder;
883 extern AVCodec wmv1_encoder;
884 extern AVCodec wmv2_encoder;
885 extern AVCodec huffyuv_encoder;
886
887 extern AVCodec h263_decoder;
888 extern AVCodec mpeg4_decoder;
889 extern AVCodec msmpeg4v1_decoder;
890 extern AVCodec msmpeg4v2_decoder;
891 extern AVCodec msmpeg4v3_decoder;
892 extern AVCodec wmv1_decoder;
893 extern AVCodec wmv2_decoder;
894 extern AVCodec mpeg_decoder;
895 extern AVCodec h263i_decoder;
896 extern AVCodec rv10_decoder;
897 extern AVCodec svq1_decoder;
898 extern AVCodec dvvideo_decoder;
899 extern AVCodec dvaudio_decoder;
900 extern AVCodec wmav1_decoder;
901 extern AVCodec wmav2_decoder;
902 extern AVCodec mjpeg_decoder;
903 extern AVCodec mjpegb_decoder;
904 extern AVCodec mp2_decoder;
905 extern AVCodec mp3_decoder;
906 extern AVCodec mace3_decoder;
907 extern AVCodec mace6_decoder;
908 extern AVCodec huffyuv_decoder;
909 extern AVCodec oggvorbis_decoder;
910
911 /* pcm codecs */
912 #define PCM_CODEC(id, name) \
913 extern AVCodec name ## _decoder; \
914 extern AVCodec name ## _encoder
915
916 PCM_CODEC(CODEC_ID_PCM_S16LE, pcm_s16le);
917 PCM_CODEC(CODEC_ID_PCM_S16BE, pcm_s16be);
918 PCM_CODEC(CODEC_ID_PCM_U16LE, pcm_u16le);
919 PCM_CODEC(CODEC_ID_PCM_U16BE, pcm_u16be);
920 PCM_CODEC(CODEC_ID_PCM_S8, pcm_s8);
921 PCM_CODEC(CODEC_ID_PCM_U8, pcm_u8);
922 PCM_CODEC(CODEC_ID_PCM_ALAW, pcm_alaw);
923 PCM_CODEC(CODEC_ID_PCM_MULAW, pcm_mulaw);
924
925 /* adpcm codecs */
926
927 PCM_CODEC(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt);
928 PCM_CODEC(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav);
929 PCM_CODEC(CODEC_ID_ADPCM_MS, adpcm_ms);
930
931 #undef PCM_CODEC
932
933 /* dummy raw video codec */
934 extern AVCodec rawvideo_codec;
935
936 /* the following codecs use external GPL libs */
937 extern AVCodec ac3_decoder;
938
939 /* resample.c */
940
941 struct ReSampleContext;
942
943 typedef struct ReSampleContext ReSampleContext;
944
945 ReSampleContext *audio_resample_init(int output_channels, int input_channels, 
946                                      int output_rate, int input_rate);
947 int audio_resample(ReSampleContext *s, short *output, short *input, int nb_samples);
948 void audio_resample_close(ReSampleContext *s);
949
950 /* YUV420 format is assumed ! */
951
952 struct ImgReSampleContext;
953
954 typedef struct ImgReSampleContext ImgReSampleContext;
955
956 ImgReSampleContext *img_resample_init(int output_width, int output_height,
957                                       int input_width, int input_height);
958
959 ImgReSampleContext *img_resample_full_init(int owidth, int oheight,
960                                       int iwidth, int iheight,
961                                       int topBand, int bottomBand,
962                                       int leftBand, int rightBand);
963
964 void img_resample(ImgReSampleContext *s, 
965                   AVPicture *output, AVPicture *input);
966
967 void img_resample_close(ImgReSampleContext *s);
968
969 void avpicture_fill(AVPicture *picture, UINT8 *ptr,
970                     int pix_fmt, int width, int height);
971 int avpicture_get_size(int pix_fmt, int width, int height);
972 void avcodec_get_chroma_sub_sample(int fmt, int *h_shift, int *v_shift);
973
974 /* convert among pixel formats */
975 int img_convert(AVPicture *dst, int dst_pix_fmt,
976                 AVPicture *src, int pix_fmt, 
977                 int width, int height);
978
979 /* deinterlace a picture */
980 int avpicture_deinterlace(AVPicture *dst, AVPicture *src,
981                           int pix_fmt, int width, int height);
982
983 /* external high level API */
984
985 extern AVCodec *first_avcodec;
986
987 /* returns LIBAVCODEC_VERSION_INT constant */
988 unsigned avcodec_version(void);
989 /* returns LIBAVCODEC_BUILD constant */
990 unsigned avcodec_build(void);
991 void avcodec_init(void);
992
993 void avcodec_set_bit_exact(void);
994
995 void register_avcodec(AVCodec *format);
996 AVCodec *avcodec_find_encoder(enum CodecID id);
997 AVCodec *avcodec_find_encoder_by_name(const char *name);
998 AVCodec *avcodec_find_decoder(enum CodecID id);
999 AVCodec *avcodec_find_decoder_by_name(const char *name);
1000 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode);
1001
1002 void avcodec_get_context_defaults(AVCodecContext *s);
1003 AVCodecContext *avcodec_alloc_context(void);
1004 AVVideoFrame *avcodec_alloc_picture(void);
1005
1006 int avcodec_default_get_buffer(AVCodecContext *s, AVVideoFrame *pic);
1007 void avcodec_default_release_buffer(AVCodecContext *s, AVVideoFrame *pic);
1008
1009 int avcodec_open(AVCodecContext *avctx, AVCodec *codec);
1010 int avcodec_decode_audio(AVCodecContext *avctx, INT16 *samples, 
1011                          int *frame_size_ptr,
1012                          UINT8 *buf, int buf_size);
1013 int avcodec_decode_video(AVCodecContext *avctx, AVVideoFrame *picture, 
1014                          int *got_picture_ptr,
1015                          UINT8 *buf, int buf_size);
1016 int avcodec_parse_frame(AVCodecContext *avctx, UINT8 **pdata, 
1017                         int *data_size_ptr,
1018                         UINT8 *buf, int buf_size);
1019 int avcodec_encode_audio(AVCodecContext *avctx, UINT8 *buf, int buf_size, 
1020                          const short *samples);
1021 int avcodec_encode_video(AVCodecContext *avctx, UINT8 *buf, int buf_size, 
1022                          const AVVideoFrame *pict);
1023
1024 int avcodec_close(AVCodecContext *avctx);
1025
1026 void avcodec_register_all(void);
1027
1028 void avcodec_flush_buffers(AVCodecContext *avctx);
1029
1030 /**
1031  * Interface for 0.5.0 version
1032  *
1033  * do not even think about it's usage for this moment
1034  */
1035
1036 typedef struct {
1037     // compressed size used from given memory buffer
1038     int size;
1039     /// I/P/B frame type
1040     int frame_type;
1041 } avc_enc_result_t;
1042
1043 /**
1044  * Commands
1045  * order can't be changed - once it was defined
1046  */
1047 typedef enum {
1048     // general commands
1049     AVC_OPEN_BY_NAME = 0xACA000,
1050     AVC_OPEN_BY_CODEC_ID,
1051     AVC_OPEN_BY_FOURCC,
1052     AVC_CLOSE,
1053
1054     AVC_FLUSH,
1055     // pin - struct { uint8_t* src, uint_t src_size }
1056     // pout - struct { AVPicture* img, consumed_bytes,
1057     AVC_DECODE,
1058     // pin - struct { AVPicture* img, uint8_t* dest, uint_t dest_size }
1059     // pout - uint_t used_from_dest_size
1060     AVC_ENCODE, 
1061
1062     // query/get video commands
1063     AVC_GET_VERSION = 0xACB000,
1064     AVC_GET_WIDTH,
1065     AVC_GET_HEIGHT,
1066     AVC_GET_DELAY,
1067     AVC_GET_QUANT_TABLE,
1068     // ...
1069
1070     // query/get audio commands
1071     AVC_GET_FRAME_SIZE = 0xABC000,
1072
1073     // maybe define some simple structure which
1074     // might be passed to the user - but they can't
1075     // contain any codec specific parts and these
1076     // calls are usualy necessary only few times
1077
1078     // set video commands
1079     AVC_SET_WIDTH = 0xACD000,
1080     AVC_SET_HEIGHT,
1081
1082     // set video encoding commands
1083     AVC_SET_FRAME_RATE = 0xACD800,
1084     AVC_SET_QUALITY,
1085     AVC_SET_HURRY_UP,
1086
1087     // set audio commands
1088     AVC_SET_SAMPLE_RATE = 0xACE000,
1089     AVC_SET_CHANNELS,
1090
1091 } avc_cmd_t;
1092
1093 /**
1094  * \param handle  allocated private structure by libavcodec
1095  *                for initialization pass NULL - will be returned pout
1096  *                user is supposed to know nothing about its structure
1097  * \param cmd     type of operation to be performed
1098  * \param pint    input parameter
1099  * \param pout    output parameter
1100  *
1101  * \returns  command status - eventually for query command it might return
1102  * integer resulting value
1103  */
1104 int avcodec(void* handle, avc_cmd_t cmd, void* pin, void* pout);
1105
1106 /* memory */
1107 void *av_malloc(unsigned int size);
1108 void *av_mallocz(unsigned int size);
1109 void av_free(void *ptr);
1110 void __av_freep(void **ptr);
1111 #define av_freep(p) __av_freep((void **)(p))
1112 /* for static data only */
1113 /* call av_free_static to release all staticaly allocated tables */
1114 void av_free_static();
1115 void *__av_mallocz_static(void** location, unsigned int size);
1116 #define av_mallocz_static(p, s) __av_mallocz_static((void **)(p), s)
1117
1118 #endif /* AVCODEC_H */