AVVideoFrame -> AVFrame
[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       4645
9 #define LIBAVCODEC_BUILD_STR   "4645"
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_FRAME \
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 AVFrame {
283     FF_COMMON_FRAME
284 } AVFrame;
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      * number of frames the decoded output will be delayed relative to 
400      * the encoded input
401      * encoding: set by lavc.
402      * decoding: unused
403      */
404     int delay;
405     
406     /* encoding parameters */
407     float qcompress;  /* amount of qscale change between easy & hard scenes (0.0-1.0)*/
408     float qblur;      /* amount of qscale smoothing over time (0.0-1.0) */
409     
410     /**
411      * minimum quantizer
412      * encoding: set by user.
413      * decoding: unused
414      */
415     int qmin;
416
417     /**
418      * maximum quantizer
419      * encoding: set by user.
420      * decoding: unused
421      */
422     int qmax;
423
424     /**
425      * maximum quantizer difference etween frames
426      * encoding: set by user.
427      * decoding: unused
428      */
429     int max_qdiff;
430
431     /**
432      * maximum number of b frames between non b frames
433      * note: the output will be delayed by max_b_frames+1 relative to the input
434      * encoding: set by user.
435      * decoding: unused
436      */
437     int max_b_frames;
438
439     /**
440      * qscale factor between ip and b frames
441      * encoding: set by user.
442      * decoding: unused
443      */
444     float b_quant_factor;
445     
446     /** obsolete FIXME remove */
447     int rc_strategy;
448     int b_frame_strategy;
449
450     /**
451      * encoding: unused
452      * decoding: set by user. 1-> skip b frames, 2-> skip idct/dequant too, 5-> skip everything except header
453      */
454     int hurry_up;
455     
456     struct AVCodec *codec;
457     
458     void *priv_data;
459
460     /* The following data is for RTP friendly coding */
461     /* By now only H.263/H.263+/MPEG4 coder honours this   */
462     int rtp_mode;   /* 1 for activate RTP friendly-mode           */
463                     /* highers numbers represent more error-prone */
464                     /* enviroments, by now just "1" exist         */
465     
466     int rtp_payload_size;   /* The size of the RTP payload, the coder will  */
467                             /* do it's best to deliver a chunk with size    */
468                             /* below rtp_payload_size, the chunk will start */
469                             /* with a start code on some codecs like H.263  */
470                             /* This doesn't take account of any particular  */
471                             /* headers inside the transmited RTP payload    */
472
473     
474     /* The RTP callcack: This function is called  */
475     /* every time the encoder as a packet to send */
476     /* Depends on the encoder if the data starts  */
477     /* with a Start Code (it should) H.263 does   */
478     void (*rtp_callback)(void *data, int size, int packet_number); 
479
480     /* statistics, used for 2-pass encoding */
481     int mv_bits;
482     int header_bits;
483     int i_tex_bits;
484     int p_tex_bits;
485     int i_count;
486     int p_count;
487     int skip_count;
488     int misc_bits;
489     
490     /**
491      * number of bits used for the previously encoded frame
492      * encoding: set by lavc
493      * decoding: - for audio - bits_per_sample
494      */
495     int frame_bits;
496                  
497     /**
498      * private data of the user, can be used to carry app specific stuff
499      * encoding: set by user
500      * decoding: set by user
501      */
502     void *opaque;
503
504     char codec_name[32];
505     enum CodecType codec_type; /* see CODEC_TYPE_xxx */
506     enum CodecID codec_id; /* see CODEC_ID_xxx */
507     unsigned int codec_tag;  /* codec tag, only used if unknown codec */
508     
509     /**
510      * workaround bugs in encoders which sometimes cannot be detected automatically
511      * encoding: unused
512      * decoding: set by user
513      */
514     int workaround_bugs;
515 #define FF_BUG_AUTODETECT       1  //autodetection
516 #define FF_BUG_OLD_MSMPEG4      2
517 #define FF_BUG_XVID_ILACE       4
518 #define FF_BUG_UMP4             8
519 #define FF_BUG_NO_PADDING       16
520 #define FF_BUG_AC_VLC           32
521 #define FF_BUG_QPEL_CHROMA      64
522 //#define FF_BUG_FAKE_SCALABILITY 16 //autodetection should work 100%
523         
524     /**
525      * encoding: set by user
526      * decoding: unused
527      */
528     int luma_elim_threshold;
529     
530     /**
531      * encoding: set by user
532      * decoding: unused
533      */
534     int chroma_elim_threshold;
535     
536     /**
537      * strictly follow the std (MPEG4, ...)
538      * encoding: set by user
539      * decoding: unused
540      */
541     int strict_std_compliance;
542     
543     /**
544      * qscale offset between ip and b frames
545      * if > 0 then the last p frame quantizer will be used (q= lastp_q*factor+offset)
546      * if < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset)
547      * encoding: set by user.
548      * decoding: unused
549      */
550     float b_quant_offset;
551     
552     /**
553      * error resilience higher values will detect more errors but may missdetect
554      * some more or less valid parts as errors
555      * encoding: unused
556      * decoding: set by user
557      */
558     int error_resilience;
559 #define FF_ER_CAREFULL        1
560 #define FF_ER_COMPLIANT       2
561 #define FF_ER_AGGRESSIVE      3
562 #define FF_ER_VERY_AGGRESSIVE 4
563     
564     /**
565      * called at the beginning of each frame to get a buffer for it.
566      * if pic.reference is set then the frame will be read later by lavc
567      * encoding: unused
568      * decoding: set by lavc, user can override
569      */
570     int (*get_buffer)(struct AVCodecContext *c, AVFrame *pic);
571     
572     /**
573      * called to release buffers which where allocated with get_buffer.
574      * a released buffer can be reused in get_buffer()
575      * pic.data[*] must be set to NULL
576      * encoding: unused
577      * decoding: set by lavc, user can override
578      */
579     void (*release_buffer)(struct AVCodecContext *c, AVFrame *pic);
580
581     /**
582      * is 1 if the decoded stream contains b frames, 0 otherwise
583      * encoding: unused
584      * decoding: set by lavc
585      */
586     int has_b_frames;
587     
588     int block_align; /* used by some WAV based audio codecs */
589     
590     int parse_only; /* decoding only: if true, only parsing is done
591                        (function avcodec_parse_frame()). The frame
592                        data is returned. Only MPEG codecs support this now. */
593     
594     /**
595      * 0-> h263 quant 1-> mpeg quant
596      * encoding: set by user.
597      * decoding: unused
598      */
599     int mpeg_quant;
600     
601     /**
602      * pass1 encoding statistics output buffer
603      * encoding: set by lavc
604      * decoding: unused
605      */
606     char *stats_out; /* encoding statistics output buffer */
607     
608     /**
609      * pass2 encoding statistics input buffer.
610      * concatenated stuff from stats_out of pass1 should be placed here
611      * encoding: allocated/set/freed by user
612      * decoding: unused
613      */
614     char *stats_in;
615     
616     /**
617      * ratecontrol qmin qmax limiting method
618      * 0-> clipping, 1-> use a nice continous function to limit qscale wthin qmin/qmax
619      * encoding: set by user.
620      * decoding: unused
621      */
622     float rc_qsquish;
623
624     float rc_qmod_amp;
625     int rc_qmod_freq;
626     
627     /**
628      * ratecontrol override, see RcOverride
629      * encoding: allocated/set/freed by user.
630      * decoding: unused
631      */
632     RcOverride *rc_override;
633     int rc_override_count;
634     
635     /**
636      * rate control equation
637      * encoding: set by user
638      * decoding: unused
639      */
640     char *rc_eq;
641     
642     /**
643      * maximum bitrate
644      * encoding: set by user.
645      * decoding: unused
646      */
647     int rc_max_rate;
648     
649     /**
650      * minimum bitrate
651      * encoding: set by user.
652      * decoding: unused
653      */
654     int rc_min_rate;
655     
656     /**
657      * decoder bitstream buffer size
658      * encoding: set by user.
659      * decoding: unused
660      */
661     int rc_buffer_size;
662     float rc_buffer_aggressivity;
663
664     /**
665      * qscale factor between p and i frames
666      * encoding: set by user.
667      * decoding: unused
668      */
669     float i_quant_factor;
670     
671     /**
672      * qscale offset between p and i frames
673      * if > 0 then the last p frame quantizer will be used (q= lastp_q*factor+offset)
674      * if < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset)
675      * encoding: set by user.
676      * decoding: unused
677      */
678     float i_quant_offset;
679     
680     /**
681      * initial complexity for pass1 ratecontrol
682      * encoding: set by user.
683      * decoding: unused
684      */
685     float rc_initial_cplx;
686
687     /**
688      * dct algorithm, see FF_DCT_* below
689      * encoding: set by user
690      * decoding: unused
691      */
692     int dct_algo;
693 #define FF_DCT_AUTO    0
694 #define FF_DCT_FASTINT 1
695 #define FF_DCT_INT     2
696 #define FF_DCT_MMX     3
697 #define FF_DCT_MLIB    4
698 #define FF_DCT_ALTIVEC 5
699     
700     /**
701      * luminance masking (0-> disabled)
702      * encoding: set by user
703      * decoding: unused
704      */
705     float lumi_masking;
706     
707     /**
708      * temporary complexity masking (0-> disabled)
709      * encoding: set by user
710      * decoding: unused
711      */
712     float temporal_cplx_masking;
713     
714     /**
715      * spatial complexity masking (0-> disabled)
716      * encoding: set by user
717      * decoding: unused
718      */
719     float spatial_cplx_masking;
720     
721     /**
722      * p block masking (0-> disabled)
723      * encoding: set by user
724      * decoding: unused
725      */
726     float p_masking;
727
728     /**
729      * darkness masking (0-> disabled)
730      * encoding: set by user
731      * decoding: unused
732      */
733     float dark_masking;
734     
735     /**
736      * fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A')
737      * this is used to workaround some encoder bugs
738      * encoding: unused
739      * decoding: set by user, will be converted to upper case by lavc during init
740      */
741     int fourcc;
742
743     /**
744      * idct algorithm, see FF_IDCT_* below
745      * encoding: set by user
746      * decoding: set by user
747      */
748     int idct_algo;
749 #define FF_IDCT_AUTO         0
750 #define FF_IDCT_INT          1
751 #define FF_IDCT_SIMPLE       2
752 #define FF_IDCT_SIMPLEMMX    3
753 #define FF_IDCT_LIBMPEG2MMX  4
754 #define FF_IDCT_PS2          5
755 #define FF_IDCT_MLIB         6
756 #define FF_IDCT_ARM          7
757 #define FF_IDCT_ALTIVEC      8
758
759     /**
760      * slice count
761      * encoding: set by lavc
762      * decoding: set by user (or 0)
763      */
764     int slice_count;
765     /**
766      * slice offsets in the frame in bytes
767      * encoding: set/allocated by lavc
768      * decoding: set/allocated by user (or NULL)
769      */
770     int *slice_offset;
771
772     /**
773      * error concealment flags
774      * encoding: unused
775      * decoding: set by user
776      */
777     int error_concealment;
778 #define FF_EC_GUESS_MVS   1
779 #define FF_EC_DEBLOCK     2
780
781     /**
782      * dsp_mask could be used to disable unwanted
783      * CPU features (i.e. MMX, SSE. ...)
784      */
785      unsigned dsp_mask;
786
787     /**
788      * bits per sample/pixel from the demuxer (needed for huffyuv)
789      * encoding: set by lavc
790      * decoding: set by user
791      */
792      int bits_per_sample;
793     
794     /**
795      * prediction method (needed for huffyuv)
796      * encoding: set by user
797      * decoding: unused
798      */
799      int prediction_method;
800 #define FF_PRED_LEFT   0
801 #define FF_PRED_PLANE  1
802 #define FF_PRED_MEDIAN 2
803     
804     /**
805      * aspect ratio. (0 if unknown)
806      * encoding: set by user.
807      * decoding: set by lavc.
808      */
809     float aspect_ratio;
810
811     /**
812      * the picture in the bitstream
813      * encoding: set by lavc
814      * decoding: set by lavc
815      */
816     AVFrame *coded_frame;
817
818     /**
819      * debug 
820      * encoding: set by user.
821      * decoding: set by user.
822      */
823     int debug;
824 #define FF_DEBUG_PICT_INFO 1
825 #define FF_DEBUG_RC        2
826 #define FF_DEBUG_BITSTREAM 4
827 #define FF_DEBUG_MB_TYPE   8
828 #define FF_DEBUG_QP        16
829 #define FF_DEBUG_MV        32
830 #define FF_DEBUG_VIS_MV    64
831     
832     /**
833      * error
834      * encoding: set by lavc if flags&CODEC_FLAG_PSNR
835      * decoding: unused
836      */
837     uint64_t error[4];
838 } AVCodecContext;
839
840 typedef struct AVCodec {
841     const char *name;
842     int type;
843     int id;
844     int priv_data_size;
845     int (*init)(AVCodecContext *);
846     int (*encode)(AVCodecContext *, UINT8 *buf, int buf_size, void *data);
847     int (*close)(AVCodecContext *);
848     int (*decode)(AVCodecContext *, void *outdata, int *outdata_size,
849                   UINT8 *buf, int buf_size);
850     int capabilities;
851     struct AVCodec *next;
852 } AVCodec;
853
854 /** 
855  * four components are given, that's all.
856  * the last component is alpha
857  */
858 typedef struct AVPicture {
859     UINT8 *data[4];
860     int linesize[4];
861 } AVPicture;
862
863 extern AVCodec ac3_encoder;
864 extern AVCodec mp2_encoder;
865 extern AVCodec mp3lame_encoder;
866 extern AVCodec oggvorbis_encoder;
867 extern AVCodec mpeg1video_encoder;
868 extern AVCodec h263_encoder;
869 extern AVCodec h263p_encoder;
870 extern AVCodec rv10_encoder;
871 extern AVCodec mjpeg_encoder;
872 extern AVCodec mpeg4_encoder;
873 extern AVCodec msmpeg4v1_encoder;
874 extern AVCodec msmpeg4v2_encoder;
875 extern AVCodec msmpeg4v3_encoder;
876 extern AVCodec wmv1_encoder;
877 extern AVCodec wmv2_encoder;
878 extern AVCodec huffyuv_encoder;
879
880 extern AVCodec h263_decoder;
881 extern AVCodec mpeg4_decoder;
882 extern AVCodec msmpeg4v1_decoder;
883 extern AVCodec msmpeg4v2_decoder;
884 extern AVCodec msmpeg4v3_decoder;
885 extern AVCodec wmv1_decoder;
886 extern AVCodec wmv2_decoder;
887 extern AVCodec mpeg_decoder;
888 extern AVCodec h263i_decoder;
889 extern AVCodec rv10_decoder;
890 extern AVCodec svq1_decoder;
891 extern AVCodec dvvideo_decoder;
892 extern AVCodec dvaudio_decoder;
893 extern AVCodec wmav1_decoder;
894 extern AVCodec wmav2_decoder;
895 extern AVCodec mjpeg_decoder;
896 extern AVCodec mjpegb_decoder;
897 extern AVCodec mp2_decoder;
898 extern AVCodec mp3_decoder;
899 extern AVCodec mace3_decoder;
900 extern AVCodec mace6_decoder;
901 extern AVCodec huffyuv_decoder;
902 extern AVCodec oggvorbis_decoder;
903
904 /* pcm codecs */
905 #define PCM_CODEC(id, name) \
906 extern AVCodec name ## _decoder; \
907 extern AVCodec name ## _encoder
908
909 PCM_CODEC(CODEC_ID_PCM_S16LE, pcm_s16le);
910 PCM_CODEC(CODEC_ID_PCM_S16BE, pcm_s16be);
911 PCM_CODEC(CODEC_ID_PCM_U16LE, pcm_u16le);
912 PCM_CODEC(CODEC_ID_PCM_U16BE, pcm_u16be);
913 PCM_CODEC(CODEC_ID_PCM_S8, pcm_s8);
914 PCM_CODEC(CODEC_ID_PCM_U8, pcm_u8);
915 PCM_CODEC(CODEC_ID_PCM_ALAW, pcm_alaw);
916 PCM_CODEC(CODEC_ID_PCM_MULAW, pcm_mulaw);
917
918 /* adpcm codecs */
919
920 PCM_CODEC(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt);
921 PCM_CODEC(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav);
922 PCM_CODEC(CODEC_ID_ADPCM_MS, adpcm_ms);
923
924 #undef PCM_CODEC
925
926 /* dummy raw video codec */
927 extern AVCodec rawvideo_codec;
928
929 /* the following codecs use external GPL libs */
930 extern AVCodec ac3_decoder;
931
932 /* resample.c */
933
934 struct ReSampleContext;
935
936 typedef struct ReSampleContext ReSampleContext;
937
938 ReSampleContext *audio_resample_init(int output_channels, int input_channels, 
939                                      int output_rate, int input_rate);
940 int audio_resample(ReSampleContext *s, short *output, short *input, int nb_samples);
941 void audio_resample_close(ReSampleContext *s);
942
943 /* YUV420 format is assumed ! */
944
945 struct ImgReSampleContext;
946
947 typedef struct ImgReSampleContext ImgReSampleContext;
948
949 ImgReSampleContext *img_resample_init(int output_width, int output_height,
950                                       int input_width, int input_height);
951
952 ImgReSampleContext *img_resample_full_init(int owidth, int oheight,
953                                       int iwidth, int iheight,
954                                       int topBand, int bottomBand,
955                                       int leftBand, int rightBand);
956
957 void img_resample(ImgReSampleContext *s, 
958                   AVPicture *output, AVPicture *input);
959
960 void img_resample_close(ImgReSampleContext *s);
961
962 void avpicture_fill(AVPicture *picture, UINT8 *ptr,
963                     int pix_fmt, int width, int height);
964 int avpicture_get_size(int pix_fmt, int width, int height);
965 void avcodec_get_chroma_sub_sample(int fmt, int *h_shift, int *v_shift);
966
967 /* convert among pixel formats */
968 int img_convert(AVPicture *dst, int dst_pix_fmt,
969                 AVPicture *src, int pix_fmt, 
970                 int width, int height);
971
972 /* deinterlace a picture */
973 int avpicture_deinterlace(AVPicture *dst, AVPicture *src,
974                           int pix_fmt, int width, int height);
975
976 /* external high level API */
977
978 extern AVCodec *first_avcodec;
979
980 /* returns LIBAVCODEC_VERSION_INT constant */
981 unsigned avcodec_version(void);
982 /* returns LIBAVCODEC_BUILD constant */
983 unsigned avcodec_build(void);
984 void avcodec_init(void);
985
986 void avcodec_set_bit_exact(void);
987
988 void register_avcodec(AVCodec *format);
989 AVCodec *avcodec_find_encoder(enum CodecID id);
990 AVCodec *avcodec_find_encoder_by_name(const char *name);
991 AVCodec *avcodec_find_decoder(enum CodecID id);
992 AVCodec *avcodec_find_decoder_by_name(const char *name);
993 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode);
994
995 void avcodec_get_context_defaults(AVCodecContext *s);
996 AVCodecContext *avcodec_alloc_context(void);
997 AVFrame *avcodec_alloc_frame(void);
998
999 int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic);
1000 void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic);
1001
1002 int avcodec_open(AVCodecContext *avctx, AVCodec *codec);
1003 int avcodec_decode_audio(AVCodecContext *avctx, INT16 *samples, 
1004                          int *frame_size_ptr,
1005                          UINT8 *buf, int buf_size);
1006 int avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture, 
1007                          int *got_picture_ptr,
1008                          UINT8 *buf, int buf_size);
1009 int avcodec_parse_frame(AVCodecContext *avctx, UINT8 **pdata, 
1010                         int *data_size_ptr,
1011                         UINT8 *buf, int buf_size);
1012 int avcodec_encode_audio(AVCodecContext *avctx, UINT8 *buf, int buf_size, 
1013                          const short *samples);
1014 int avcodec_encode_video(AVCodecContext *avctx, UINT8 *buf, int buf_size, 
1015                          const AVFrame *pict);
1016
1017 int avcodec_close(AVCodecContext *avctx);
1018
1019 void avcodec_register_all(void);
1020
1021 void avcodec_flush_buffers(AVCodecContext *avctx);
1022
1023 /**
1024  * Interface for 0.5.0 version
1025  *
1026  * do not even think about it's usage for this moment
1027  */
1028
1029 typedef struct {
1030     // compressed size used from given memory buffer
1031     int size;
1032     /// I/P/B frame type
1033     int frame_type;
1034 } avc_enc_result_t;
1035
1036 /**
1037  * Commands
1038  * order can't be changed - once it was defined
1039  */
1040 typedef enum {
1041     // general commands
1042     AVC_OPEN_BY_NAME = 0xACA000,
1043     AVC_OPEN_BY_CODEC_ID,
1044     AVC_OPEN_BY_FOURCC,
1045     AVC_CLOSE,
1046
1047     AVC_FLUSH,
1048     // pin - struct { uint8_t* src, uint_t src_size }
1049     // pout - struct { AVPicture* img, consumed_bytes,
1050     AVC_DECODE,
1051     // pin - struct { AVPicture* img, uint8_t* dest, uint_t dest_size }
1052     // pout - uint_t used_from_dest_size
1053     AVC_ENCODE, 
1054
1055     // query/get video commands
1056     AVC_GET_VERSION = 0xACB000,
1057     AVC_GET_WIDTH,
1058     AVC_GET_HEIGHT,
1059     AVC_GET_DELAY,
1060     AVC_GET_QUANT_TABLE,
1061     // ...
1062
1063     // query/get audio commands
1064     AVC_GET_FRAME_SIZE = 0xABC000,
1065
1066     // maybe define some simple structure which
1067     // might be passed to the user - but they can't
1068     // contain any codec specific parts and these
1069     // calls are usualy necessary only few times
1070
1071     // set video commands
1072     AVC_SET_WIDTH = 0xACD000,
1073     AVC_SET_HEIGHT,
1074
1075     // set video encoding commands
1076     AVC_SET_FRAME_RATE = 0xACD800,
1077     AVC_SET_QUALITY,
1078     AVC_SET_HURRY_UP,
1079
1080     // set audio commands
1081     AVC_SET_SAMPLE_RATE = 0xACE000,
1082     AVC_SET_CHANNELS,
1083
1084 } avc_cmd_t;
1085
1086 /**
1087  * \param handle  allocated private structure by libavcodec
1088  *                for initialization pass NULL - will be returned pout
1089  *                user is supposed to know nothing about its structure
1090  * \param cmd     type of operation to be performed
1091  * \param pint    input parameter
1092  * \param pout    output parameter
1093  *
1094  * \returns  command status - eventually for query command it might return
1095  * integer resulting value
1096  */
1097 int avcodec(void* handle, avc_cmd_t cmd, void* pin, void* pout);
1098
1099 /* memory */
1100 void *av_malloc(unsigned int size);
1101 void *av_mallocz(unsigned int size);
1102 void av_free(void *ptr);
1103 void __av_freep(void **ptr);
1104 #define av_freep(p) __av_freep((void **)(p))
1105 /* for static data only */
1106 /* call av_free_static to release all staticaly allocated tables */
1107 void av_free_static();
1108 void *__av_mallocz_static(void** location, unsigned int size);
1109 #define av_mallocz_static(p, s) __av_mallocz_static((void **)(p), s)
1110
1111 #endif /* AVCODEC_H */