Statistics
| Branch: | Revision:

ffmpeg / libavcodec / avcodec.h @ 18f77016

History | View | Annotate | Download (28.6 KB)

1
#ifndef AVCODEC_H
2
#define AVCODEC_H
3

    
4
#include "common.h"
5

    
6
#define LIBAVCODEC_VERSION_INT 0x000406
7
#define LIBAVCODEC_VERSION     "0.4.6"
8
#define LIBAVCODEC_BUILD       4638
9
#define LIBAVCODEC_BUILD_STR   "4638"
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_MPEG4,
22
    CODEC_ID_RAWVIDEO,
23
    CODEC_ID_MSMPEG4V1,
24
    CODEC_ID_MSMPEG4V2,
25
    CODEC_ID_MSMPEG4V3,
26
    CODEC_ID_WMV1,
27
    CODEC_ID_WMV2,
28
    CODEC_ID_H263P,
29
    CODEC_ID_H263I,
30
    CODEC_ID_SVQ1,
31
    CODEC_ID_DVVIDEO,
32
    CODEC_ID_DVAUDIO,
33
    CODEC_ID_WMAV1,
34
    CODEC_ID_WMAV2,
35
    CODEC_ID_MACE3,
36
    CODEC_ID_MACE6,
37

    
38
    /* various pcm "codecs" */
39
    CODEC_ID_PCM_S16LE,
40
    CODEC_ID_PCM_S16BE,
41
    CODEC_ID_PCM_U16LE,
42
    CODEC_ID_PCM_U16BE,
43
    CODEC_ID_PCM_S8,
44
    CODEC_ID_PCM_U8,
45
    CODEC_ID_PCM_MULAW,
46
    CODEC_ID_PCM_ALAW,
47

    
48
    /* various adpcm codecs */
49
    CODEC_ID_ADPCM_IMA_QT,
50
    CODEC_ID_ADPCM_IMA_WAV,
51
    CODEC_ID_ADPCM_MS,
52
};
53

    
54
enum CodecType {
55
    CODEC_TYPE_UNKNOWN = -1,
56
    CODEC_TYPE_VIDEO,
57
    CODEC_TYPE_AUDIO,
58
};
59

    
60
enum PixelFormat {
61
    PIX_FMT_ANY = -1,
62
    PIX_FMT_YUV420P,
63
    PIX_FMT_YUV422,
64
    PIX_FMT_RGB24,
65
    PIX_FMT_BGR24,
66
    PIX_FMT_YUV422P,
67
    PIX_FMT_YUV444P,
68
    PIX_FMT_RGBA32,
69
    PIX_FMT_BGRA32,
70
    PIX_FMT_YUV410P,
71
    PIX_FMT_YUV411P
72
};
73

    
74
/* currently unused, may be used if 24/32 bits samples ever supported */
75
enum SampleFormat {
76
    SAMPLE_FMT_S16 = 0,         /* signed 16 bits */
77
};
78

    
79
/* in bytes */
80
#define AVCODEC_MAX_AUDIO_FRAME_SIZE 131072
81

    
82
/**
83
 * Required number of zero bytes at the end of the input bitstream for decoding.
84
 * to avoid overreading (and possibly segfaulting)
85
 */
86
#define FF_INPUT_BUFFER_PADDING_SIZE 8
87

    
88
/* motion estimation type, EPZS by default */
89
enum Motion_Est_ID {
90
    ME_ZERO = 1,
91
    ME_FULL,
92
    ME_LOG,
93
    ME_PHODS,
94
    ME_EPZS,
95
    ME_X1
96
};
97

    
98
typedef struct RcOverride{
99
    int start_frame;
100
    int end_frame;
101
    int qscale; // if this is 0 then quality_factor will be used instead
102
    float quality_factor;
103
} RcOverride;
104

    
105
/* only for ME compatiblity with old apps */
106
extern int motion_estimation_method;
107

    
108
/* ME algos sorted by quality */
109
static const int Motion_Est_QTab[] = { ME_ZERO, ME_PHODS, ME_LOG, 
110
                                       ME_X1, ME_EPZS, ME_FULL };
111

    
112

    
113
#define FF_MAX_B_FRAMES 4
114

    
115
/* encoding support
116
   these flags can be passed in AVCodecContext.flags before initing 
117
   Note: note not everything is supported yet 
118
*/
119

    
120
#define CODEC_FLAG_HQ     0x0001  /* brute force MB-type decission mode (slow) */
121
#define CODEC_FLAG_QSCALE 0x0002  /* use fixed qscale */
122
#define CODEC_FLAG_4MV    0x0004  /* 4 MV per MB allowed */
123
#define CODEC_FLAG_QPEL   0x0010  /* use qpel MC */
124
#define CODEC_FLAG_GMC    0x0020  /* use GMC */
125
#define CODEC_FLAG_PART   0x0080  /* use data partitioning */
126
/* parent program gurantees that the input for b-frame containing streams is not written to 
127
   for at least s->max_b_frames+1 frames, if this is not set than the input will be copied */
128
#define CODEC_FLAG_INPUT_PRESERVED 0x0100
129
#define CODEC_FLAG_PASS1 0x0200   /* use internal 2pass ratecontrol in first  pass mode */
130
#define CODEC_FLAG_PASS2 0x0400   /* use internal 2pass ratecontrol in second pass mode */
131
#define CODEC_FLAG_EXTERN_HUFF 0x1000 /* use external huffman table (for mjpeg) */
132
#define CODEC_FLAG_GRAY  0x2000   /* only decode/encode grayscale */
133
#define CODEC_FLAG_EMU_EDGE 0x4000/* dont draw edges */
134
#define CODEC_FLAG_DR1    0x8000  /* direct renderig type 1 (store internal frames in external buffers) */
135
#define CODEC_FLAG_TRUNCATED  0x00010000 /* input bitstream might be truncated at a random location instead 
136
                                            of only at frame boundaries */
137
#define CODEC_FLAG_NORMALIZE_AQP  0x00020000 /* normalize adaptive quantization */
138
#define CODEC_FLAG_INTERLACED_DCT 0x00040000 /* use interlaced dct */
139
#define CODEC_FLAG_LOW_DELAY      0x00080000 /* force low delay / will fail on b frames */
140

    
141
/* codec capabilities */
142

    
143
#define CODEC_CAP_DRAW_HORIZ_BAND 0x0001 /* decoder can use draw_horiz_band callback */
144
#define CODEC_CAP_DR1             0x0002 /* direct rendering method 1 */
145
/* if 'parse_only' field is true, then avcodec_parse_frame() can be
146
   used */
147
#define CODEC_CAP_PARSE_ONLY      0x0004
148
#define CODEC_CAP_TRUNCATED       0x0008
149

    
150
#define FRAME_RATE_BASE 10000
151

    
152
typedef struct AVCodecContext {
153
    /**
154
     * the average bitrate
155
     * encoding: set by user. unused for constant quantizer encoding
156
     * decoding: set by lavc. 0 or some bitrate if this info is available in the stream 
157
     */
158
    int bit_rate;
159

    
160
    /**
161
     * number of bits the bitstream is allowed to diverge from the reference
162
     *           the reference can be CBR (for CBR pass1) or VBR (for pass2)
163
     * encoding: set by user. unused for constant quantizer encoding
164
     * decoding: unused
165
     */
166
    int bit_rate_tolerance; 
167

    
168
    /**
169
     * CODEC_FLAG_*
170
     * encoding: set by user.
171
     * decoding: set by user.
172
     */
173
    int flags;
174

    
175
    /**
176
     * some codecs needs additionnal format info. It is stored here
177
     * encoding: set by user. 
178
     * decoding: set by lavc. (FIXME is this ok?)
179
     */
180
    int sub_id;
181

    
182
    /**
183
     * motion estimation algorithm used for video coding
184
     * encoding: set by user.
185
     * decoding: unused
186
     */
187
    int me_method;
188

    
189
    /**
190
     * some codecs need / can use extra-data like huffman tables
191
     * mjpeg: huffman tables
192
     * rv10: additional flags
193
     * mpeg4: global headers (they can be in the bitstream or here)
194
     * encoding: set/allocated/freed by lavc.
195
     * decoding: set/allocated/freed by user.
196
     */
197
    void *extradata;
198
    int extradata_size;
199
    
200
    /* video only */
201
    /**
202
     * frames per sec multiplied by FRAME_RATE_BASE
203
     * for variable fps this is the precission, so if the timestamps 
204
     * can be specified in msec precssion then this is 1000*FRAME_RATE_BASE
205
     * encoding: set by user
206
     * decoding: set by lavc. 0 or the frame_rate if available
207
     */
208
    int frame_rate;
209

    
210
    /**
211
     * encoding: set by user.
212
     * decoding: set by user, some codecs might override / change it during playback
213
     */
214
    int width, height;
215
    
216
    /**
217
     * encoding: set by user. 0 if not known
218
     * decoding: set by lavc. 0 if not known
219
     */
220
    int aspect_ratio_info;
221
#define FF_ASPECT_SQUARE 1
222
#define FF_ASPECT_4_3_625 2
223
#define FF_ASPECT_4_3_525 3
224
#define FF_ASPECT_16_9_625 4
225
#define FF_ASPECT_16_9_525 5
226
#define FF_ASPECT_EXTENDED 15
227

    
228
    /**
229
     * the number of pictures in a group of pitures, or 0 for intra_only
230
     * encoding: set by user.
231
     * decoding: unused
232
     */
233
    int gop_size;
234

    
235
    /**
236
     * pixel format, see PIX_FMT_xxx
237
     * encoding: unused
238
     * decoding: set by lavc.
239
     */
240
    enum PixelFormat pix_fmt;
241
    
242
    int repeat_pict; /* when decoding, this signal how much the picture */
243
                     /* must be delayed.                                */
244
                     /* extra_delay = (repeat_pict / 2) * (1/fps)       */
245
    
246
    /**
247
     * if non NULL, 'draw_horiz_band' is called by the libavcodec
248
     * decoder to draw an horizontal band. It improve cache usage. Not
249
     * all codecs can do that. You must check the codec capabilities
250
     * before
251
     * encoding: unused
252
     * decoding: set by user.
253
     */
254
    void (*draw_horiz_band)(struct AVCodecContext *s,
255
                            UINT8 **src_ptr, int linesize,
256
                            int y, int width, int height);
257

    
258
    /* audio only */
259
    int sample_rate; /* samples per sec */
260
    int channels;
261
    int sample_fmt;  /* sample format, currenly unused */
262

    
263
    /* the following data should not be initialized */
264
    int frame_size;     /* in samples, initialized when calling 'init' */
265
    int frame_number;   /* audio or video frame number */
266
    int real_pict_num;  /* returns the real picture number of
267
                           previous encoded frame */
268
                           
269
    /**
270
     * 1 -> keyframe, 0-> not
271
     * encoding: set by lavc (for the outputed bitstream, not the input frame)
272
     * decoding: set by lavc (for the decoded  bitstream, not the displayed frame)
273
     */
274
    int key_frame;
275

    
276
    /**
277
     * picture type of the previous en/decoded frame, see ?_TYPE below
278
     * encoding: set by lavc (for the outputed bitstream, not the input frame)
279
     * decoding: set by lavc (for the decoded  bitstream, not the displayed frame)
280
     */
281
    int pict_type;
282
/* FIXME: these should have FF_ */
283
#define I_TYPE 1 // Intra
284
#define P_TYPE 2 // Predicted
285
#define B_TYPE 3 // Bi-dir predicted
286
#define S_TYPE 4 // S(GMC)-VOP MPEG4
287

    
288
    /**
289
     * number of frames the decoded output will be delayed relative to 
290
     * the encoded input
291
     * encoding: set by lavc.
292
     * decoding: unused
293
     */
294
    int delay;
295

    
296
    /**
297
     * mbskip_table[mb]=1 if MB didnt change, is only valid for I/P frames 
298
     * stride= mb_width = (width+15)>>4 (FIXME export stride?)
299
     * encoding: unused
300
     * decoding: set by lavc
301
     */
302
    uint8_t *mbskip_table;
303
    
304
    /* encoding parameters */
305
    /**
306
     * quality (between 1 (good) and 31 (bad)) 
307
     * encoding: set by user if CODEC_FLAG_QSCALE is set otherwise set by lavc
308
     * decoding: set by lavc
309
     */
310
    int quality;      /* quality of the previous encoded frame 
311
                         
312
                         this is allso used to set the quality in vbr mode
313
                         and the per frame quality in CODEC_FLAG_TYPE (second pass mode) */
314
    float qcompress;  /* amount of qscale change between easy & hard scenes (0.0-1.0)*/
315
    float qblur;      /* amount of qscale smoothing over time (0.0-1.0) */
316
    
317
    /**
318
     * minimum quantizer
319
     * encoding: set by user.
320
     * decoding: unused
321
     */
322
    int qmin;
323

    
324
    /**
325
     * maximum quantizer
326
     * encoding: set by user.
327
     * decoding: unused
328
     */
329
    int qmax;
330

    
331
    /**
332
     * maximum quantizer difference etween frames
333
     * encoding: set by user.
334
     * decoding: unused
335
     */
336
    int max_qdiff;
337

    
338
    /**
339
     * maximum number of b frames between non b frames
340
     * note: the output will be delayed by max_b_frames+1 relative to the input
341
     * encoding: set by user.
342
     * decoding: unused
343
     */
344
    int max_b_frames;
345

    
346
    /**
347
     * qscale factor between ip and b frames
348
     * encoding: set by user.
349
     * decoding: unused
350
     */
351
    float b_quant_factor;
352
    
353
    /** obsolete FIXME remove */
354
    int rc_strategy;
355
    int b_frame_strategy;
356

    
357
    /**
358
     * encoding: unused
359
     * decoding: set by user. 1-> skip b frames, 2-> skip idct/dequant too, 5-> skip everything except header
360
     */
361
    int hurry_up;
362
    
363
    struct AVCodec *codec;
364
    
365
    void *priv_data;
366

    
367
    /* The following data is for RTP friendly coding */
368
    /* By now only H.263/H.263+/MPEG4 coder honours this   */
369
    int rtp_mode;   /* 1 for activate RTP friendly-mode           */
370
                    /* highers numbers represent more error-prone */
371
                    /* enviroments, by now just "1" exist         */
372
    
373
    int rtp_payload_size;   /* The size of the RTP payload, the coder will  */
374
                            /* do it's best to deliver a chunk with size    */
375
                            /* below rtp_payload_size, the chunk will start */
376
                            /* with a start code on some codecs like H.263  */
377
                            /* This doesn't take account of any particular  */
378
                            /* headers inside the transmited RTP payload    */
379

    
380
    
381
    /* The RTP callcack: This function is called  */
382
    /* every time the encoder as a packet to send */
383
    /* Depends on the encoder if the data starts  */
384
    /* with a Start Code (it should) H.263 does   */
385
    void (*rtp_callback)(void *data, int size, int packet_number); 
386

    
387
    /**
388
     * if you set get_psnr to 1 then after encoding you will have the 
389
     * PSNR on psnr_y/cb/cr
390
     * encoding: set by user (1-> on, 0-> off)
391
     * decoding: unused
392
     */
393
    int get_psnr;
394
    float psnr_y;
395
    float psnr_cb;
396
    float psnr_cr;
397
    
398
    /* statistics, used for 2-pass encoding */
399
    int mv_bits;
400
    int header_bits;
401
    int i_tex_bits;
402
    int p_tex_bits;
403
    int i_count;
404
    int p_count;
405
    int skip_count;
406
    int misc_bits;
407
    
408
    /**
409
     * number of bits used for the previously encoded frame
410
     * encoding: set by lavc
411
     * decoding: - for audio - bits_per_sample
412
     */
413
    int frame_bits;
414
                 
415
    /**
416
     * private data of the user, can be used to carry app specific stuff
417
     * encoding: set by user
418
     * decoding: set by user
419
     */
420
    void *opaque;
421

    
422
    char codec_name[32];
423
    enum CodecType codec_type; /* see CODEC_TYPE_xxx */
424
    enum CodecID codec_id; /* see CODEC_ID_xxx */
425
    unsigned int codec_tag;  /* codec tag, only used if unknown codec */
426
    
427
    /**
428
     * workaround bugs in encoders which sometimes cannot be detected automatically
429
     * encoding: unused
430
     * decoding: set by user
431
     */
432
    int workaround_bugs;
433
#define FF_BUG_AUTODETECT       1  //autodetection
434
#define FF_BUG_OLD_MSMPEG4      2
435
#define FF_BUG_XVID_ILACE       4
436
#define FF_BUG_UMP4             8
437
#define FF_BUG_NO_PADDING       16
438
#define FF_BUG_AC_VLC           32
439
#define FF_BUG_QPEL_CHROMA      64
440
//#define FF_BUG_FAKE_SCALABILITY 16 //autodetection should work 100%
441
        
442
    /**
443
     * encoding: set by user
444
     * decoding: unused
445
     */
446
    int luma_elim_threshold;
447
    
448
    /**
449
     * encoding: set by user
450
     * decoding: unused
451
     */
452
    int chroma_elim_threshold;
453
    
454
    /**
455
     * strictly follow the std (MPEG4, ...)
456
     * encoding: set by user
457
     * decoding: unused
458
     */
459
    int strict_std_compliance;
460
    
461
    /**
462
     * qscale offset between ip and b frames
463
     * if > 0 then the last p frame quantizer will be used (q= lastp_q*factor+offset)
464
     * if < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset)
465
     * encoding: set by user.
466
     * decoding: unused
467
     */
468
    float b_quant_offset;
469
    
470
    /**
471
     * error resilience {-1,0,1} higher values will detect more errors but may missdetect
472
     * some more or less valid parts as errors
473
     * encoding: unused
474
     * decoding: set by user
475
     */
476
    int error_resilience;
477
    
478
    /**
479
     * obsolete, just here to keep ABI compatible (should be removed perhaps, dunno)
480
     */
481
    int *quant_store;
482

    
483
    /**
484
     * QP store stride
485
     * encoding: unused
486
     * decoding: set by lavc
487
     */
488
    int qstride;
489
    
490
    /**
491
     * buffer, where the next picture should be decoded into
492
     * encoding: unused
493
     * decoding: set by user in get_buffer_callback to a buffer into which the next part
494
     *           of the bitstream will be decoded, and set by lavc at end of frame to the
495
     *           next frame which needs to be displayed
496
     */
497
    uint8_t *dr_buffer[3];
498
    
499
    /**
500
     * stride of the luminance part of the dr buffer
501
     * encoding: unused
502
     * decoding: set by user
503
     */
504
    int dr_stride;
505
    
506
    /**
507
     * same behavior as dr_buffer, just for some private data of the user
508
     * encoding: unused
509
     * decoding: set by user in get_buffer_callback, and set by lavc at end of frame
510
     */
511
    void *dr_opaque_frame;
512
    
513
    /**
514
     * called at the beginning of each frame to get a buffer for it
515
     * encoding: unused
516
     * decoding: set by user
517
     */
518
    int (*get_buffer_callback)(struct AVCodecContext *c, int width, int height, int pict_type);
519

    
520
    /**
521
     * is 1 if the decoded stream contains b frames, 0 otherwise
522
     * encoding: unused
523
     * decoding: set by lavc
524
     */
525
    int has_b_frames;
526

    
527
    /**
528
     * stride of the chrominance part of the dr buffer
529
     * encoding: unused
530
     * decoding: set by user
531
     */
532
    int dr_uvstride;
533
    
534
    /**
535
     * number of dr buffers
536
     * encoding: unused
537
     * decoding: set by user
538
     */
539
    int dr_ip_buffer_count;
540
    
541
    int block_align; /* used by some WAV based audio codecs */
542
    
543
    int parse_only; /* decoding only: if true, only parsing is done
544
                       (function avcodec_parse_frame()). The frame
545
                       data is returned. Only MPEG codecs support this now. */
546
    
547
    /**
548
     * 0-> h263 quant 1-> mpeg quant
549
     * encoding: set by user.
550
     * decoding: unused
551
     */
552
    int mpeg_quant;
553
    
554
    /**
555
     * pass1 encoding statistics output buffer
556
     * encoding: set by lavc
557
     * decoding: unused
558
     */
559
    char *stats_out; /* encoding statistics output buffer */
560
    
561
    /**
562
     * pass2 encoding statistics input buffer.
563
     * concatenated stuff from stats_out of pass1 should be placed here
564
     * encoding: allocated/set/freed by user
565
     * decoding: unused
566
     */
567
    char *stats_in;
568
    
569
    /**
570
     * ratecontrol qmin qmax limiting method
571
     * 0-> clipping, 1-> use a nice continous function to limit qscale wthin qmin/qmax
572
     * encoding: set by user.
573
     * decoding: unused
574
     */
575
    float rc_qsquish;
576

    
577
    float rc_qmod_amp;
578
    int rc_qmod_freq;
579
    
580
    /**
581
     * ratecontrol override, see RcOverride
582
     * encoding: allocated/set/freed by user.
583
     * decoding: unused
584
     */
585
    RcOverride *rc_override;
586
    int rc_override_count;
587
    
588
    /**
589
     * rate control equation
590
     * encoding: set by user
591
     * decoding: unused
592
     */
593
    char *rc_eq;
594
    
595
    /**
596
     * maximum bitrate
597
     * encoding: set by user.
598
     * decoding: unused
599
     */
600
    int rc_max_rate;
601
    
602
    /**
603
     * minimum bitrate
604
     * encoding: set by user.
605
     * decoding: unused
606
     */
607
    int rc_min_rate;
608
    
609
    /**
610
     * decoder bitstream buffer size
611
     * encoding: set by user.
612
     * decoding: unused
613
     */
614
    int rc_buffer_size;
615
    float rc_buffer_aggressivity;
616

    
617
    /**
618
     * qscale factor between p and i frames
619
     * encoding: set by user.
620
     * decoding: unused
621
     */
622
    float i_quant_factor;
623
    
624
    /**
625
     * qscale offset between p and i frames
626
     * if > 0 then the last p frame quantizer will be used (q= lastp_q*factor+offset)
627
     * if < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset)
628
     * encoding: set by user.
629
     * decoding: unused
630
     */
631
    float i_quant_offset;
632
    
633
    /**
634
     * initial complexity for pass1 ratecontrol
635
     * encoding: set by user.
636
     * decoding: unused
637
     */
638
    float rc_initial_cplx;
639

    
640
    /**
641
     * custom aspect ratio, used if aspect_info==FF_ASPECT_EXTENDED
642
     * encoding: set by user.
643
     * decoding: set by lavc.
644
     */
645
    int aspected_width;
646
    int aspected_height;
647

    
648
    /**
649
     * dct algorithm, see FF_DCT_* below
650
     * encoding: set by user
651
     * decoding: unused
652
     */
653
    int dct_algo;
654
#define FF_DCT_AUTO    0
655
#define FF_DCT_FASTINT 1
656
#define FF_DCT_INT     2
657
#define FF_DCT_MMX     3
658
#define FF_DCT_MLIB    4
659
#define FF_DCT_ALTIVEC 5
660

    
661
    /**
662
     * presentation timestamp in micro seconds (time when frame should be shown to user)
663
     * if 0 then the frame_rate will be used as reference
664
     * encoding: set by user
665
     * decoding; set by lavc
666
     */
667
    long long int pts;
668
    
669
    /**
670
     * luminance masking (0-> disabled)
671
     * encoding: set by user
672
     * decoding: unused
673
     */
674
    float lumi_masking;
675
    
676
    /**
677
     * temporary complexity masking (0-> disabled)
678
     * encoding: set by user
679
     * decoding: unused
680
     */
681
    float temporal_cplx_masking;
682
    
683
    /**
684
     * spatial complexity masking (0-> disabled)
685
     * encoding: set by user
686
     * decoding: unused
687
     */
688
    float spatial_cplx_masking;
689
    
690
    /**
691
     * p block masking (0-> disabled)
692
     * encoding: set by user
693
     * decoding: unused
694
     */
695
    float p_masking;
696

    
697
    /**
698
     * darkness masking (0-> disabled)
699
     * encoding: set by user
700
     * decoding: unused
701
     */
702
    float dark_masking;
703
    
704
    /**
705
     * fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A')
706
     * this is used to workaround some encoder bugs
707
     * encoding: unused
708
     * decoding: set by user, will be converted to upper case by lavc during init
709
     */
710
    int fourcc;
711

    
712
    /**
713
     * idct algorithm, see FF_IDCT_* below
714
     * encoding: set by user
715
     * decoding: set by user
716
     */
717
    int idct_algo;
718
#define FF_IDCT_AUTO         0
719
#define FF_IDCT_INT          1
720
#define FF_IDCT_SIMPLE       2
721
#define FF_IDCT_SIMPLEMMX    3
722
#define FF_IDCT_LIBMPEG2MMX  4
723
#define FF_IDCT_PS2          5
724
#define FF_IDCT_MLIB         6
725
#define FF_IDCT_ARM          7
726
#define FF_IDCT_ALTIVEC      8
727

    
728
    /**
729
     * slice count
730
     * encoding: set by lavc
731
     * decoding: set by user (or 0)
732
     */
733
    int slice_count;
734
    /**
735
     * slice offsets in the frame in bytes
736
     * encoding: set/allocated by lavc
737
     * decoding: set/allocated by user (or NULL)
738
     */
739
    int *slice_offset;
740

    
741
    /**
742
     * error concealment flags
743
     * encoding: unused
744
     * decoding: set by user
745
     */
746
    int error_concealment;
747
#define FF_EC_GUESS_MVS   1
748
#define FF_EC_DEBLOCK     2
749

    
750
    /**
751
     * QP table of the currently decoded frame
752
     * encoding; unused
753
     * decoding: set by lavc
754
     */
755
    int8_t *current_qscale_table;
756
    /**
757
     * QP table of the currently displayed frame
758
     * encoding; unused
759
     * decoding: set by lavc
760
     */
761
    int8_t *display_qscale_table;
762
    /**
763
     * force specific pict_type.
764
     * encoding; set by user (I/P/B_TYPE)
765
     * decoding: unused
766
     */
767
    int force_type;
768
    /**
769
     * dsp_mask could be used to disable unwanted
770
     * CPU features (i.e. MMX, SSE. ...)
771
     */
772
     unsigned dsp_mask;
773
} AVCodecContext;
774

    
775
typedef struct AVCodec {
776
    const char *name;
777
    int type;
778
    int id;
779
    int priv_data_size;
780
    int (*init)(AVCodecContext *);
781
    int (*encode)(AVCodecContext *, UINT8 *buf, int buf_size, void *data);
782
    int (*close)(AVCodecContext *);
783
    int (*decode)(AVCodecContext *, void *outdata, int *outdata_size,
784
                  UINT8 *buf, int buf_size);
785
    int capabilities;
786
    struct AVCodec *next;
787
} AVCodec;
788

    
789
/** 
790
 * four components are given, that's all.
791
 * the last component is alpha
792
 */
793
typedef struct AVPicture {
794
    UINT8 *data[4];
795
    int linesize[4];
796
} AVPicture;
797

    
798
extern AVCodec ac3_encoder;
799
extern AVCodec mp2_encoder;
800
extern AVCodec mp3lame_encoder;
801
extern AVCodec oggvorbis_encoder;
802
extern AVCodec mpeg1video_encoder;
803
extern AVCodec h263_encoder;
804
extern AVCodec h263p_encoder;
805
extern AVCodec rv10_encoder;
806
extern AVCodec mjpeg_encoder;
807
extern AVCodec mpeg4_encoder;
808
extern AVCodec msmpeg4v1_encoder;
809
extern AVCodec msmpeg4v2_encoder;
810
extern AVCodec msmpeg4v3_encoder;
811
extern AVCodec wmv1_encoder;
812
extern AVCodec wmv2_encoder;
813

    
814
extern AVCodec h263_decoder;
815
extern AVCodec mpeg4_decoder;
816
extern AVCodec msmpeg4v1_decoder;
817
extern AVCodec msmpeg4v2_decoder;
818
extern AVCodec msmpeg4v3_decoder;
819
extern AVCodec wmv1_decoder;
820
extern AVCodec wmv2_decoder;
821
extern AVCodec mpeg_decoder;
822
extern AVCodec h263i_decoder;
823
extern AVCodec rv10_decoder;
824
extern AVCodec svq1_decoder;
825
extern AVCodec dvvideo_decoder;
826
extern AVCodec dvaudio_decoder;
827
extern AVCodec wmav1_decoder;
828
extern AVCodec wmav2_decoder;
829
extern AVCodec mjpeg_decoder;
830
extern AVCodec mp2_decoder;
831
extern AVCodec mp3_decoder;
832
extern AVCodec mace3_decoder;
833
extern AVCodec mace6_decoder;
834

    
835
/* pcm codecs */
836
#define PCM_CODEC(id, name) \
837
extern AVCodec name ## _decoder; \
838
extern AVCodec name ## _encoder
839

    
840
PCM_CODEC(CODEC_ID_PCM_S16LE, pcm_s16le);
841
PCM_CODEC(CODEC_ID_PCM_S16BE, pcm_s16be);
842
PCM_CODEC(CODEC_ID_PCM_U16LE, pcm_u16le);
843
PCM_CODEC(CODEC_ID_PCM_U16BE, pcm_u16be);
844
PCM_CODEC(CODEC_ID_PCM_S8, pcm_s8);
845
PCM_CODEC(CODEC_ID_PCM_U8, pcm_u8);
846
PCM_CODEC(CODEC_ID_PCM_ALAW, pcm_alaw);
847
PCM_CODEC(CODEC_ID_PCM_MULAW, pcm_mulaw);
848

    
849
/* adpcm codecs */
850

    
851
PCM_CODEC(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt);
852
PCM_CODEC(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav);
853
PCM_CODEC(CODEC_ID_ADPCM_MS, adpcm_ms);
854

    
855
#undef PCM_CODEC
856

    
857
/* dummy raw video codec */
858
extern AVCodec rawvideo_codec;
859

    
860
/* the following codecs use external GPL libs */
861
extern AVCodec ac3_decoder;
862

    
863
/* resample.c */
864

    
865
struct ReSampleContext;
866

    
867
typedef struct ReSampleContext ReSampleContext;
868

    
869
ReSampleContext *audio_resample_init(int output_channels, int input_channels, 
870
                                     int output_rate, int input_rate);
871
int audio_resample(ReSampleContext *s, short *output, short *input, int nb_samples);
872
void audio_resample_close(ReSampleContext *s);
873

    
874
/* YUV420 format is assumed ! */
875

    
876
struct ImgReSampleContext;
877

    
878
typedef struct ImgReSampleContext ImgReSampleContext;
879

    
880
ImgReSampleContext *img_resample_init(int output_width, int output_height,
881
                                      int input_width, int input_height);
882

    
883
ImgReSampleContext *img_resample_full_init(int owidth, int oheight,
884
                                      int iwidth, int iheight,
885
                                      int topBand, int bottomBand,
886
                                      int leftBand, int rightBand);
887

    
888
void img_resample(ImgReSampleContext *s, 
889
                  AVPicture *output, AVPicture *input);
890

    
891
void img_resample_close(ImgReSampleContext *s);
892

    
893
void avpicture_fill(AVPicture *picture, UINT8 *ptr,
894
                    int pix_fmt, int width, int height);
895
int avpicture_get_size(int pix_fmt, int width, int height);
896

    
897
/* convert among pixel formats */
898
int img_convert(AVPicture *dst, int dst_pix_fmt,
899
                AVPicture *src, int pix_fmt, 
900
                int width, int height);
901

    
902
/* deinterlace a picture */
903
int avpicture_deinterlace(AVPicture *dst, AVPicture *src,
904
                          int pix_fmt, int width, int height);
905

    
906
/* external high level API */
907

    
908
extern AVCodec *first_avcodec;
909

    
910
/* returns LIBAVCODEC_VERSION_INT constant */
911
unsigned avcodec_version(void);
912
/* returns LIBAVCODEC_BUILD constant */
913
unsigned avcodec_build(void);
914
void avcodec_init(void);
915

    
916
void avcodec_set_bit_exact(void);
917

    
918
void register_avcodec(AVCodec *format);
919
AVCodec *avcodec_find_encoder(enum CodecID id);
920
AVCodec *avcodec_find_encoder_by_name(const char *name);
921
AVCodec *avcodec_find_decoder(enum CodecID id);
922
AVCodec *avcodec_find_decoder_by_name(const char *name);
923
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode);
924

    
925
AVCodecContext *avcodec_alloc_context(void);
926
int avcodec_open(AVCodecContext *avctx, AVCodec *codec);
927
int avcodec_decode_audio(AVCodecContext *avctx, INT16 *samples, 
928
                         int *frame_size_ptr,
929
                         UINT8 *buf, int buf_size);
930
int avcodec_decode_video(AVCodecContext *avctx, AVPicture *picture, 
931
                         int *got_picture_ptr,
932
                         UINT8 *buf, int buf_size);
933
int avcodec_parse_frame(AVCodecContext *avctx, UINT8 **pdata, 
934
                        int *data_size_ptr,
935
                        UINT8 *buf, int buf_size);
936
int avcodec_encode_audio(AVCodecContext *avctx, UINT8 *buf, int buf_size, 
937
                         const short *samples);
938
int avcodec_encode_video(AVCodecContext *avctx, UINT8 *buf, int buf_size, 
939
                         const AVPicture *pict);
940

    
941
int avcodec_close(AVCodecContext *avctx);
942

    
943
void avcodec_register_all(void);
944

    
945
void avcodec_flush_buffers(AVCodecContext *avctx);
946

    
947
/**
948
 * Interface for 0.5.0 version
949
 *
950
 * do not even think about it's usage for this moment
951
 */
952

    
953
typedef struct {
954
    // compressed size used from given memory buffer
955
    int size;
956
    /// I/P/B frame type
957
    int frame_type;
958
} avc_enc_result_t;
959

    
960
/**
961
 * Commands
962
 * order can't be changed - once it was defined
963
 */
964
typedef enum {
965
    // general commands
966
    AVC_OPEN_BY_NAME = 0xACA000,
967
    AVC_OPEN_BY_CODEC_ID,
968
    AVC_OPEN_BY_FOURCC,
969
    AVC_CLOSE,
970

    
971
    AVC_FLUSH,
972
    // pin - struct { uint8_t* src, uint_t src_size }
973
    // pout - struct { AVPicture* img, consumed_bytes,
974
    AVC_DECODE,
975
    // pin - struct { AVPicture* img, uint8_t* dest, uint_t dest_size }
976
    // pout - uint_t used_from_dest_size
977
    AVC_ENCODE, 
978

    
979
    // query/get video commands
980
    AVC_GET_VERSION = 0xACB000,
981
    AVC_GET_WIDTH,
982
    AVC_GET_HEIGHT,
983
    AVC_GET_DELAY,
984
    AVC_GET_QUANT_TABLE,
985
    // ...
986

    
987
    // query/get audio commands
988
    AVC_GET_FRAME_SIZE = 0xABC000,
989

    
990
    // maybe define some simple structure which
991
    // might be passed to the user - but they can't
992
    // contain any codec specific parts and these
993
    // calls are usualy necessary only few times
994

    
995
    // set video commands
996
    AVC_SET_WIDTH = 0xACD000,
997
    AVC_SET_HEIGHT,
998

    
999
    // set video encoding commands
1000
    AVC_SET_FRAME_RATE = 0xACD800,
1001
    AVC_SET_QUALITY,
1002
    AVC_SET_HURRY_UP,
1003

    
1004
    // set audio commands
1005
    AVC_SET_SAMPLE_RATE = 0xACE000,
1006
    AVC_SET_CHANNELS,
1007

    
1008
} avc_cmd_t;
1009

    
1010
/**
1011
 * \param handle  allocated private structure by libavcodec
1012
 *                for initialization pass NULL - will be returned pout
1013
 *                user is supposed to know nothing about its structure
1014
 * \param cmd     type of operation to be performed
1015
 * \param pint    input parameter
1016
 * \param pout    output parameter
1017
 *
1018
 * \returns  command status - eventually for query command it might return
1019
 * integer resulting value
1020
 */
1021
int avcodec(void* handle, avc_cmd_t cmd, void* pin, void* pout);
1022

    
1023
/* memory */
1024
void *av_malloc(unsigned int size);
1025
void *av_mallocz(unsigned int size);
1026
void av_free(void *ptr);
1027
void __av_freep(void **ptr);
1028
#define av_freep(p) __av_freep((void **)(p))
1029

    
1030
#endif /* AVCODEC_H */