git.sesse.net Git - ffmpeg/blob - libavcodec/avcodec.h

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