motion estimation pre pass
[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       4650
9 #define LIBAVCODEC_BUILD_STR   "4650"
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_YUV420P,
64     PIX_FMT_YUV422,
65     PIX_FMT_RGB24,
66     PIX_FMT_BGR24,
67     PIX_FMT_YUV422P,
68     PIX_FMT_YUV444P,
69     PIX_FMT_RGBA32,
70     PIX_FMT_BGRA32,
71     PIX_FMT_YUV410P,
72     PIX_FMT_YUV411P,
73     PIX_FMT_RGB565,
74     PIX_FMT_RGB555,
75 //    PIX_FMT_RGB5551,
76     PIX_FMT_BGR565,
77     PIX_FMT_BGR555,
78 //    PIX_FMT_GBR565,
79 //    PIX_FMT_GBR555
80 };
81
82 /* currently unused, may be used if 24/32 bits samples ever supported */
83 enum SampleFormat {
84     SAMPLE_FMT_S16 = 0,         /* signed 16 bits */
85 };
86
87 /* in bytes */
88 #define AVCODEC_MAX_AUDIO_FRAME_SIZE 131072
89
90 /**
91  * Required number of zero bytes at the end of the input bitstream for decoding.
92  * to avoid overreading (and possibly segfaulting)
93  */
94 #define FF_INPUT_BUFFER_PADDING_SIZE 8
95
96 /* motion estimation type, EPZS by default */
97 enum Motion_Est_ID {
98     ME_ZERO = 1,
99     ME_FULL,
100     ME_LOG,
101     ME_PHODS,
102     ME_EPZS,
103     ME_X1
104 };
105
106 typedef struct RcOverride{
107     int start_frame;
108     int end_frame;
109     int qscale; // if this is 0 then quality_factor will be used instead
110     float quality_factor;
111 } RcOverride;
112
113 /* only for ME compatiblity with old apps */
114 extern int motion_estimation_method;
115
116 /* ME algos sorted by quality */
117 static const int Motion_Est_QTab[] = { ME_ZERO, ME_PHODS, ME_LOG, 
118                                        ME_X1, ME_EPZS, ME_FULL };
119
120
121 #define FF_MAX_B_FRAMES 8
122
123 /* encoding support
124    these flags can be passed in AVCodecContext.flags before initing 
125    Note: note not everything is supported yet 
126 */
127
128 #define CODEC_FLAG_HQ     0x0001  /* brute force MB-type decission mode (slow) */
129 #define CODEC_FLAG_QSCALE 0x0002  /* use fixed qscale */
130 #define CODEC_FLAG_4MV    0x0004  /* 4 MV per MB allowed */
131 #define CODEC_FLAG_QPEL   0x0010  /* use qpel MC */
132 #define CODEC_FLAG_GMC    0x0020  /* use GMC */
133 #define CODEC_FLAG_PART   0x0080  /* use data partitioning */
134 /* parent program gurantees that the input for b-frame containing streams is not written to 
135    for at least s->max_b_frames+1 frames, if this is not set than the input will be copied */
136 #define CODEC_FLAG_INPUT_PRESERVED 0x0100
137 #define CODEC_FLAG_PASS1 0x0200   /* use internal 2pass ratecontrol in first  pass mode */
138 #define CODEC_FLAG_PASS2 0x0400   /* use internal 2pass ratecontrol in second pass mode */
139 #define CODEC_FLAG_EXTERN_HUFF 0x1000 /* use external huffman table (for mjpeg) */
140 #define CODEC_FLAG_GRAY  0x2000   /* only decode/encode grayscale */
141 #define CODEC_FLAG_EMU_EDGE 0x4000/* dont draw edges */
142 #define CODEC_FLAG_PSNR           0x8000 /* error[?] variables will be set during encoding */
143 #define CODEC_FLAG_TRUNCATED  0x00010000 /* input bitstream might be truncated at a random location instead 
144                                             of only at frame boundaries */
145 #define CODEC_FLAG_NORMALIZE_AQP  0x00020000 /* normalize adaptive quantization */
146 #define CODEC_FLAG_INTERLACED_DCT 0x00040000 /* use interlaced dct */
147 #define CODEC_FLAG_LOW_DELAY      0x00080000 /* force low delay / will fail on b frames */
148 #define CODEC_FLAG_ALT_SCAN       0x00100000 /* use alternate scan */
149 #define CODEC_FLAG_TRELLIS_QUANT  0x00200000 /* use trellis quantization */
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    0x00000040
831 #define FF_DEBUG_SKIP      0x00000080
832 #define FF_DEBUG_STARTCODE 0x00000100
833 #define FF_DEBUG_PTS       0x00000200
834     
835     /**
836      * error
837      * encoding: set by lavc if flags&CODEC_FLAG_PSNR
838      * decoding: unused
839      */
840     uint64_t error[4];
841     
842     /**
843      * minimum MB quantizer
844      * encoding: set by user.
845      * decoding: unused
846      */
847     int mb_qmin;
848
849     /**
850      * maximum MB quantizer
851      * encoding: set by user.
852      * decoding: unused
853      */
854     int mb_qmax;
855     
856     /**
857      * motion estimation compare function
858      * encoding: set by user.
859      * decoding: unused
860      */
861     int me_cmp;
862     /**
863      * subpixel motion estimation compare function
864      * encoding: set by user.
865      * decoding: unused
866      */
867     int me_sub_cmp;
868     /**
869      * macroblock compare function (not supported yet)
870      * encoding: set by user.
871      * decoding: unused
872      */
873     int mb_cmp;
874 #define FF_CMP_SAD  0
875 #define FF_CMP_SSE  1
876 #define FF_CMP_SATD 2
877 #define FF_CMP_DCT  3
878 #define FF_CMP_PSNR 4
879 #define FF_CMP_BIT  5
880 #define FF_CMP_RD   6
881 #define FF_CMP_ZERO 7
882 #define FF_CMP_CHROMA 256
883     
884     /**
885      * ME diamond size & shape
886      * encoding: set by user.
887      * decoding: unused
888      */
889     int dia_size;
890
891     /**
892      * amount of previous MV predictors (2a+1 x 2a+1 square)
893      * encoding: set by user.
894      * decoding: unused
895      */
896     int last_predictor_count;
897     
898     /**
899      * pre pass for motion estimation
900      * encoding: set by user.
901      * decoding: unused
902      */
903     int pre_me;
904
905 } AVCodecContext;
906
907 typedef struct AVCodec {
908     const char *name;
909     int type;
910     int id;
911     int priv_data_size;
912     int (*init)(AVCodecContext *);
913     int (*encode)(AVCodecContext *, UINT8 *buf, int buf_size, void *data);
914     int (*close)(AVCodecContext *);
915     int (*decode)(AVCodecContext *, void *outdata, int *outdata_size,
916                   UINT8 *buf, int buf_size);
917     int capabilities;
918     struct AVCodec *next;
919 } AVCodec;
920
921 /** 
922  * four components are given, that's all.
923  * the last component is alpha
924  */
925 typedef struct AVPicture {
926     UINT8 *data[4];
927     int linesize[4];
928 } AVPicture;
929
930 extern AVCodec ac3_encoder;
931 extern AVCodec mp2_encoder;
932 extern AVCodec mp3lame_encoder;
933 extern AVCodec oggvorbis_encoder;
934 extern AVCodec mpeg1video_encoder;
935 extern AVCodec h263_encoder;
936 extern AVCodec h263p_encoder;
937 extern AVCodec rv10_encoder;
938 extern AVCodec mjpeg_encoder;
939 extern AVCodec mpeg4_encoder;
940 extern AVCodec msmpeg4v1_encoder;
941 extern AVCodec msmpeg4v2_encoder;
942 extern AVCodec msmpeg4v3_encoder;
943 extern AVCodec wmv1_encoder;
944 extern AVCodec wmv2_encoder;
945 extern AVCodec huffyuv_encoder;
946
947 extern AVCodec h263_decoder;
948 extern AVCodec mpeg4_decoder;
949 extern AVCodec msmpeg4v1_decoder;
950 extern AVCodec msmpeg4v2_decoder;
951 extern AVCodec msmpeg4v3_decoder;
952 extern AVCodec wmv1_decoder;
953 extern AVCodec wmv2_decoder;
954 extern AVCodec mpeg_decoder;
955 extern AVCodec h263i_decoder;
956 extern AVCodec rv10_decoder;
957 extern AVCodec svq1_decoder;
958 extern AVCodec dvvideo_decoder;
959 extern AVCodec dvaudio_decoder;
960 extern AVCodec wmav1_decoder;
961 extern AVCodec wmav2_decoder;
962 extern AVCodec mjpeg_decoder;
963 extern AVCodec mjpegb_decoder;
964 extern AVCodec mp2_decoder;
965 extern AVCodec mp3_decoder;
966 extern AVCodec mace3_decoder;
967 extern AVCodec mace6_decoder;
968 extern AVCodec huffyuv_decoder;
969 extern AVCodec oggvorbis_decoder;
970
971 /* pcm codecs */
972 #define PCM_CODEC(id, name) \
973 extern AVCodec name ## _decoder; \
974 extern AVCodec name ## _encoder
975
976 PCM_CODEC(CODEC_ID_PCM_S16LE, pcm_s16le);
977 PCM_CODEC(CODEC_ID_PCM_S16BE, pcm_s16be);
978 PCM_CODEC(CODEC_ID_PCM_U16LE, pcm_u16le);
979 PCM_CODEC(CODEC_ID_PCM_U16BE, pcm_u16be);
980 PCM_CODEC(CODEC_ID_PCM_S8, pcm_s8);
981 PCM_CODEC(CODEC_ID_PCM_U8, pcm_u8);
982 PCM_CODEC(CODEC_ID_PCM_ALAW, pcm_alaw);
983 PCM_CODEC(CODEC_ID_PCM_MULAW, pcm_mulaw);
984
985 /* adpcm codecs */
986
987 PCM_CODEC(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt);
988 PCM_CODEC(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav);
989 PCM_CODEC(CODEC_ID_ADPCM_MS, adpcm_ms);
990
991 #undef PCM_CODEC
992
993 /* dummy raw video codec */
994 extern AVCodec rawvideo_codec;
995
996 /* the following codecs use external GPL libs */
997 extern AVCodec ac3_decoder;
998
999 /* resample.c */
1000
1001 struct ReSampleContext;
1002
1003 typedef struct ReSampleContext ReSampleContext;
1004
1005 ReSampleContext *audio_resample_init(int output_channels, int input_channels, 
1006                                      int output_rate, int input_rate);
1007 int audio_resample(ReSampleContext *s, short *output, short *input, int nb_samples);
1008 void audio_resample_close(ReSampleContext *s);
1009
1010 /* YUV420 format is assumed ! */
1011
1012 struct ImgReSampleContext;
1013
1014 typedef struct ImgReSampleContext ImgReSampleContext;
1015
1016 ImgReSampleContext *img_resample_init(int output_width, int output_height,
1017                                       int input_width, int input_height);
1018
1019 ImgReSampleContext *img_resample_full_init(int owidth, int oheight,
1020                                       int iwidth, int iheight,
1021                                       int topBand, int bottomBand,
1022                                       int leftBand, int rightBand);
1023
1024 void img_resample(ImgReSampleContext *s, 
1025                   AVPicture *output, AVPicture *input);
1026
1027 void img_resample_close(ImgReSampleContext *s);
1028
1029 void avpicture_fill(AVPicture *picture, UINT8 *ptr,
1030                     int pix_fmt, int width, int height);
1031 int avpicture_get_size(int pix_fmt, int width, int height);
1032 void avcodec_get_chroma_sub_sample(int fmt, int *h_shift, int *v_shift);
1033
1034 /* convert among pixel formats */
1035 int img_convert(AVPicture *dst, int dst_pix_fmt,
1036                 AVPicture *src, int pix_fmt, 
1037                 int width, int height);
1038
1039 /* deinterlace a picture */
1040 int avpicture_deinterlace(AVPicture *dst, AVPicture *src,
1041                           int pix_fmt, int width, int height);
1042
1043 /* external high level API */
1044
1045 extern AVCodec *first_avcodec;
1046
1047 /* returns LIBAVCODEC_VERSION_INT constant */
1048 unsigned avcodec_version(void);
1049 /* returns LIBAVCODEC_BUILD constant */
1050 unsigned avcodec_build(void);
1051 void avcodec_init(void);
1052
1053 void avcodec_set_bit_exact(void);
1054
1055 void register_avcodec(AVCodec *format);
1056 AVCodec *avcodec_find_encoder(enum CodecID id);
1057 AVCodec *avcodec_find_encoder_by_name(const char *name);
1058 AVCodec *avcodec_find_decoder(enum CodecID id);
1059 AVCodec *avcodec_find_decoder_by_name(const char *name);
1060 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode);
1061
1062 void avcodec_get_context_defaults(AVCodecContext *s);
1063 AVCodecContext *avcodec_alloc_context(void);
1064 AVFrame *avcodec_alloc_frame(void);
1065
1066 int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic);
1067 void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic);
1068
1069 int avcodec_open(AVCodecContext *avctx, AVCodec *codec);
1070 int avcodec_decode_audio(AVCodecContext *avctx, INT16 *samples, 
1071                          int *frame_size_ptr,
1072                          UINT8 *buf, int buf_size);
1073 int avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture, 
1074                          int *got_picture_ptr,
1075                          UINT8 *buf, int buf_size);
1076 int avcodec_parse_frame(AVCodecContext *avctx, UINT8 **pdata, 
1077                         int *data_size_ptr,
1078                         UINT8 *buf, int buf_size);
1079 int avcodec_encode_audio(AVCodecContext *avctx, UINT8 *buf, int buf_size, 
1080                          const short *samples);
1081 int avcodec_encode_video(AVCodecContext *avctx, UINT8 *buf, int buf_size, 
1082                          const AVFrame *pict);
1083
1084 int avcodec_close(AVCodecContext *avctx);
1085
1086 void avcodec_register_all(void);
1087
1088 void avcodec_flush_buffers(AVCodecContext *avctx);
1089
1090 /**
1091  * Interface for 0.5.0 version
1092  *
1093  * do not even think about it's usage for this moment
1094  */
1095
1096 typedef struct {
1097     // compressed size used from given memory buffer
1098     int size;
1099     /// I/P/B frame type
1100     int frame_type;
1101 } avc_enc_result_t;
1102
1103 /**
1104  * Commands
1105  * order can't be changed - once it was defined
1106  */
1107 typedef enum {
1108     // general commands
1109     AVC_OPEN_BY_NAME = 0xACA000,
1110     AVC_OPEN_BY_CODEC_ID,
1111     AVC_OPEN_BY_FOURCC,
1112     AVC_CLOSE,
1113
1114     AVC_FLUSH,
1115     // pin - struct { uint8_t* src, uint_t src_size }
1116     // pout - struct { AVPicture* img, consumed_bytes,
1117     AVC_DECODE,
1118     // pin - struct { AVPicture* img, uint8_t* dest, uint_t dest_size }
1119     // pout - uint_t used_from_dest_size
1120     AVC_ENCODE, 
1121
1122     // query/get video commands
1123     AVC_GET_VERSION = 0xACB000,
1124     AVC_GET_WIDTH,
1125     AVC_GET_HEIGHT,
1126     AVC_GET_DELAY,
1127     AVC_GET_QUANT_TABLE,
1128     // ...
1129
1130     // query/get audio commands
1131     AVC_GET_FRAME_SIZE = 0xABC000,
1132
1133     // maybe define some simple structure which
1134     // might be passed to the user - but they can't
1135     // contain any codec specific parts and these
1136     // calls are usualy necessary only few times
1137
1138     // set video commands
1139     AVC_SET_WIDTH = 0xACD000,
1140     AVC_SET_HEIGHT,
1141
1142     // set video encoding commands
1143     AVC_SET_FRAME_RATE = 0xACD800,
1144     AVC_SET_QUALITY,
1145     AVC_SET_HURRY_UP,
1146
1147     // set audio commands
1148     AVC_SET_SAMPLE_RATE = 0xACE000,
1149     AVC_SET_CHANNELS,
1150
1151 } avc_cmd_t;
1152
1153 /**
1154  * \param handle  allocated private structure by libavcodec
1155  *                for initialization pass NULL - will be returned pout
1156  *                user is supposed to know nothing about its structure
1157  * \param cmd     type of operation to be performed
1158  * \param pint    input parameter
1159  * \param pout    output parameter
1160  *
1161  * \returns  command status - eventually for query command it might return
1162  * integer resulting value
1163  */
1164 int avcodec(void* handle, avc_cmd_t cmd, void* pin, void* pout);
1165
1166 /* memory */
1167 void *av_malloc(unsigned int size);
1168 void *av_mallocz(unsigned int size);
1169 void av_free(void *ptr);
1170 void __av_freep(void **ptr);
1171 #define av_freep(p) __av_freep((void **)(p))
1172 /* for static data only */
1173 /* call av_free_static to release all staticaly allocated tables */
1174 void av_free_static();
1175 void *__av_mallocz_static(void** location, unsigned int size);
1176 #define av_mallocz_static(p, s) __av_mallocz_static((void **)(p), s)
1177
1178 #endif /* AVCODEC_H */