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

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