Mercurial > audlegacy-plugins
comparison src/ffmpeg/libavcodec/avcodec.h @ 808:e8776388b02a trunk
[svn] - add ffmpeg
| author | nenolod |
|---|---|
| date | Mon, 12 Mar 2007 11:18:54 -0700 |
| parents | |
| children | 07107d476f32 |
comparison
equal
deleted
inserted
replaced
| 807:0f9c8d4d3ac4 | 808:e8776388b02a |
|---|---|
| 1 /* | |
| 2 * copyright (c) 2001 Fabrice Bellard | |
| 3 * | |
| 4 * This file is part of FFmpeg. | |
| 5 * | |
| 6 * FFmpeg is free software; you can redistribute it and/or | |
| 7 * modify it under the terms of the GNU Lesser General Public | |
| 8 * License as published by the Free Software Foundation; either | |
| 9 * version 2.1 of the License, or (at your option) any later version. | |
| 10 * | |
| 11 * FFmpeg is distributed in the hope that it will be useful, | |
| 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 14 * Lesser General Public License for more details. | |
| 15 * | |
| 16 * You should have received a copy of the GNU Lesser General Public | |
| 17 * License along with FFmpeg; if not, write to the Free Software | |
| 18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | |
| 19 */ | |
| 20 | |
| 21 #ifndef AVCODEC_H | |
| 22 #define AVCODEC_H | |
| 23 | |
| 24 /** | |
| 25 * @file avcodec.h | |
| 26 * external api header. | |
| 27 */ | |
| 28 | |
| 29 | |
| 30 #ifdef __cplusplus | |
| 31 extern "C" { | |
| 32 #endif | |
| 33 | |
| 34 #include "avutil.h" | |
| 35 #include <sys/types.h> /* size_t */ | |
| 36 | |
| 37 #define AV_STRINGIFY(s) AV_TOSTRING(s) | |
| 38 #define AV_TOSTRING(s) #s | |
| 39 | |
| 40 #define LIBAVCODEC_VERSION_INT ((51<<16)+(21<<8)+0) | |
| 41 #define LIBAVCODEC_VERSION 51.21.0 | |
| 42 #define LIBAVCODEC_BUILD LIBAVCODEC_VERSION_INT | |
| 43 | |
| 44 #define LIBAVCODEC_IDENT "Lavc" AV_STRINGIFY(LIBAVCODEC_VERSION) | |
| 45 | |
| 46 #define AV_NOPTS_VALUE int64_t_C(0x8000000000000000) | |
| 47 #define AV_TIME_BASE 1000000 | |
| 48 #define AV_TIME_BASE_Q (AVRational){1, AV_TIME_BASE} | |
| 49 | |
| 50 enum CodecID { | |
| 51 CODEC_ID_NONE, | |
| 52 CODEC_ID_MPEG1VIDEO, | |
| 53 CODEC_ID_MPEG2VIDEO, /* prefered ID for MPEG Video 1 or 2 decoding */ | |
| 54 CODEC_ID_MPEG2VIDEO_XVMC, | |
| 55 CODEC_ID_H261, | |
| 56 CODEC_ID_H263, | |
| 57 CODEC_ID_RV10, | |
| 58 CODEC_ID_RV20, | |
| 59 CODEC_ID_MJPEG, | |
| 60 CODEC_ID_MJPEGB, | |
| 61 CODEC_ID_LJPEG, | |
| 62 CODEC_ID_SP5X, | |
| 63 CODEC_ID_JPEGLS, | |
| 64 CODEC_ID_MPEG4, | |
| 65 CODEC_ID_RAWVIDEO, | |
| 66 CODEC_ID_MSMPEG4V1, | |
| 67 CODEC_ID_MSMPEG4V2, | |
| 68 CODEC_ID_MSMPEG4V3, | |
| 69 CODEC_ID_WMV1, | |
| 70 CODEC_ID_WMV2, | |
| 71 CODEC_ID_H263P, | |
| 72 CODEC_ID_H263I, | |
| 73 CODEC_ID_FLV1, | |
| 74 CODEC_ID_SVQ1, | |
| 75 CODEC_ID_SVQ3, | |
| 76 CODEC_ID_DVVIDEO, | |
| 77 CODEC_ID_HUFFYUV, | |
| 78 CODEC_ID_CYUV, | |
| 79 CODEC_ID_H264, | |
| 80 CODEC_ID_INDEO3, | |
| 81 CODEC_ID_VP3, | |
| 82 CODEC_ID_THEORA, | |
| 83 CODEC_ID_ASV1, | |
| 84 CODEC_ID_ASV2, | |
| 85 CODEC_ID_FFV1, | |
| 86 CODEC_ID_4XM, | |
| 87 CODEC_ID_VCR1, | |
| 88 CODEC_ID_CLJR, | |
| 89 CODEC_ID_MDEC, | |
| 90 CODEC_ID_ROQ, | |
| 91 CODEC_ID_INTERPLAY_VIDEO, | |
| 92 CODEC_ID_XAN_WC3, | |
| 93 CODEC_ID_XAN_WC4, | |
| 94 CODEC_ID_RPZA, | |
| 95 CODEC_ID_CINEPAK, | |
| 96 CODEC_ID_WS_VQA, | |
| 97 CODEC_ID_MSRLE, | |
| 98 CODEC_ID_MSVIDEO1, | |
| 99 CODEC_ID_IDCIN, | |
| 100 CODEC_ID_8BPS, | |
| 101 CODEC_ID_SMC, | |
| 102 CODEC_ID_FLIC, | |
| 103 CODEC_ID_TRUEMOTION1, | |
| 104 CODEC_ID_VMDVIDEO, | |
| 105 CODEC_ID_MSZH, | |
| 106 CODEC_ID_ZLIB, | |
| 107 CODEC_ID_QTRLE, | |
| 108 CODEC_ID_SNOW, | |
| 109 CODEC_ID_TSCC, | |
| 110 CODEC_ID_ULTI, | |
| 111 CODEC_ID_QDRAW, | |
| 112 CODEC_ID_VIXL, | |
| 113 CODEC_ID_QPEG, | |
| 114 CODEC_ID_XVID, | |
| 115 CODEC_ID_PNG, | |
| 116 CODEC_ID_PPM, | |
| 117 CODEC_ID_PBM, | |
| 118 CODEC_ID_PGM, | |
| 119 CODEC_ID_PGMYUV, | |
| 120 CODEC_ID_PAM, | |
| 121 CODEC_ID_FFVHUFF, | |
| 122 CODEC_ID_RV30, | |
| 123 CODEC_ID_RV40, | |
| 124 CODEC_ID_VC1, | |
| 125 CODEC_ID_WMV3, | |
| 126 CODEC_ID_LOCO, | |
| 127 CODEC_ID_WNV1, | |
| 128 CODEC_ID_AASC, | |
| 129 CODEC_ID_INDEO2, | |
| 130 CODEC_ID_FRAPS, | |
| 131 CODEC_ID_TRUEMOTION2, | |
| 132 CODEC_ID_BMP, | |
| 133 CODEC_ID_CSCD, | |
| 134 CODEC_ID_MMVIDEO, | |
| 135 CODEC_ID_ZMBV, | |
| 136 CODEC_ID_AVS, | |
| 137 CODEC_ID_SMACKVIDEO, | |
| 138 CODEC_ID_NUV, | |
| 139 CODEC_ID_KMVC, | |
| 140 CODEC_ID_FLASHSV, | |
| 141 CODEC_ID_CAVS, | |
| 142 CODEC_ID_JPEG2000, | |
| 143 CODEC_ID_VMNC, | |
| 144 CODEC_ID_VP5, | |
| 145 CODEC_ID_VP6, | |
| 146 CODEC_ID_VP6F, | |
| 147 CODEC_ID_TARGA, | |
| 148 CODEC_ID_DSICINVIDEO, | |
| 149 CODEC_ID_TIERTEXSEQVIDEO, | |
| 150 CODEC_ID_TIFF, | |
| 151 CODEC_ID_GIF, | |
| 152 | |
| 153 /* various pcm "codecs" */ | |
| 154 CODEC_ID_PCM_S16LE= 0x10000, | |
| 155 CODEC_ID_PCM_S16BE, | |
| 156 CODEC_ID_PCM_U16LE, | |
| 157 CODEC_ID_PCM_U16BE, | |
| 158 CODEC_ID_PCM_S8, | |
| 159 CODEC_ID_PCM_U8, | |
| 160 CODEC_ID_PCM_MULAW, | |
| 161 CODEC_ID_PCM_ALAW, | |
| 162 CODEC_ID_PCM_S32LE, | |
| 163 CODEC_ID_PCM_S32BE, | |
| 164 CODEC_ID_PCM_U32LE, | |
| 165 CODEC_ID_PCM_U32BE, | |
| 166 CODEC_ID_PCM_S24LE, | |
| 167 CODEC_ID_PCM_S24BE, | |
| 168 CODEC_ID_PCM_U24LE, | |
| 169 CODEC_ID_PCM_U24BE, | |
| 170 CODEC_ID_PCM_S24DAUD, | |
| 171 | |
| 172 /* various adpcm codecs */ | |
| 173 CODEC_ID_ADPCM_IMA_QT= 0x11000, | |
| 174 CODEC_ID_ADPCM_IMA_WAV, | |
| 175 CODEC_ID_ADPCM_IMA_DK3, | |
| 176 CODEC_ID_ADPCM_IMA_DK4, | |
| 177 CODEC_ID_ADPCM_IMA_WS, | |
| 178 CODEC_ID_ADPCM_IMA_SMJPEG, | |
| 179 CODEC_ID_ADPCM_MS, | |
| 180 CODEC_ID_ADPCM_4XM, | |
| 181 CODEC_ID_ADPCM_XA, | |
| 182 CODEC_ID_ADPCM_ADX, | |
| 183 CODEC_ID_ADPCM_EA, | |
| 184 CODEC_ID_ADPCM_G726, | |
| 185 CODEC_ID_ADPCM_CT, | |
| 186 CODEC_ID_ADPCM_SWF, | |
| 187 CODEC_ID_ADPCM_YAMAHA, | |
| 188 CODEC_ID_ADPCM_SBPRO_4, | |
| 189 CODEC_ID_ADPCM_SBPRO_3, | |
| 190 CODEC_ID_ADPCM_SBPRO_2, | |
| 191 | |
| 192 /* AMR */ | |
| 193 CODEC_ID_AMR_NB= 0x12000, | |
| 194 CODEC_ID_AMR_WB, | |
| 195 | |
| 196 /* RealAudio codecs*/ | |
| 197 CODEC_ID_RA_144= 0x13000, | |
| 198 CODEC_ID_RA_288, | |
| 199 | |
| 200 /* various DPCM codecs */ | |
| 201 CODEC_ID_ROQ_DPCM= 0x14000, | |
| 202 CODEC_ID_INTERPLAY_DPCM, | |
| 203 CODEC_ID_XAN_DPCM, | |
| 204 CODEC_ID_SOL_DPCM, | |
| 205 | |
| 206 CODEC_ID_MP2= 0x15000, | |
| 207 CODEC_ID_MP3, /* prefered ID for MPEG Audio layer 1, 2 or3 decoding */ | |
| 208 CODEC_ID_AAC, | |
| 209 CODEC_ID_MPEG4AAC, | |
| 210 CODEC_ID_AC3, | |
| 211 CODEC_ID_DTS, | |
| 212 CODEC_ID_VORBIS, | |
| 213 CODEC_ID_DVAUDIO, | |
| 214 CODEC_ID_WMAV1, | |
| 215 CODEC_ID_WMAV2, | |
| 216 CODEC_ID_MACE3, | |
| 217 CODEC_ID_MACE6, | |
| 218 CODEC_ID_VMDAUDIO, | |
| 219 CODEC_ID_SONIC, | |
| 220 CODEC_ID_SONIC_LS, | |
| 221 CODEC_ID_FLAC, | |
| 222 CODEC_ID_MP3ADU, | |
| 223 CODEC_ID_MP3ON4, | |
| 224 CODEC_ID_SHORTEN, | |
| 225 CODEC_ID_ALAC, | |
| 226 CODEC_ID_WESTWOOD_SND1, | |
| 227 CODEC_ID_GSM, | |
| 228 CODEC_ID_QDM2, | |
| 229 CODEC_ID_COOK, | |
| 230 CODEC_ID_TRUESPEECH, | |
| 231 CODEC_ID_TTA, | |
| 232 CODEC_ID_SMACKAUDIO, | |
| 233 CODEC_ID_QCELP, | |
| 234 CODEC_ID_WAVPACK, | |
| 235 CODEC_ID_DSICINAUDIO, | |
| 236 | |
| 237 /* subtitle codecs */ | |
| 238 CODEC_ID_DVD_SUBTITLE= 0x17000, | |
| 239 CODEC_ID_DVB_SUBTITLE, | |
| 240 | |
| 241 CODEC_ID_MPEG2TS= 0x20000, /* _FAKE_ codec to indicate a raw MPEG2 transport | |
| 242 stream (only used by libavformat) */ | |
| 243 }; | |
| 244 | |
| 245 /* CODEC_ID_MP3LAME is absolete */ | |
| 246 #define CODEC_ID_MP3LAME CODEC_ID_MP3 | |
| 247 | |
| 248 enum CodecType { | |
| 249 CODEC_TYPE_UNKNOWN = -1, | |
| 250 CODEC_TYPE_VIDEO, | |
| 251 CODEC_TYPE_AUDIO, | |
| 252 CODEC_TYPE_DATA, | |
| 253 CODEC_TYPE_SUBTITLE, | |
| 254 }; | |
| 255 | |
| 256 /* currently unused, may be used if 24/32 bits samples ever supported */ | |
| 257 /* all in native endian */ | |
| 258 enum SampleFormat { | |
| 259 SAMPLE_FMT_NONE = -1, | |
| 260 SAMPLE_FMT_U8, ///< unsigned 8 bits | |
| 261 SAMPLE_FMT_S16, ///< signed 16 bits | |
| 262 SAMPLE_FMT_S24, ///< signed 24 bits | |
| 263 SAMPLE_FMT_S32, ///< signed 32 bits | |
| 264 SAMPLE_FMT_FLT, ///< float | |
| 265 }; | |
| 266 | |
| 267 /* in bytes */ | |
| 268 #define AVCODEC_MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32bit audio | |
| 269 | |
| 270 /** | |
| 271 * Required number of additionally allocated bytes at the end of the input bitstream for decoding. | |
| 272 * this is mainly needed because some optimized bitstream readers read | |
| 273 * 32 or 64 bit at once and could read over the end<br> | |
| 274 * Note, if the first 23 bits of the additional bytes are not 0 then damaged | |
| 275 * MPEG bitstreams could cause overread and segfault | |
| 276 */ | |
| 277 #define FF_INPUT_BUFFER_PADDING_SIZE 8 | |
| 278 | |
| 279 /** | |
| 280 * minimum encoding buffer size. | |
| 281 * used to avoid some checks during header writing | |
| 282 */ | |
| 283 #define FF_MIN_BUFFER_SIZE 16384 | |
| 284 | |
| 285 /* motion estimation type, EPZS by default */ | |
| 286 enum Motion_Est_ID { | |
| 287 ME_ZERO = 1, | |
| 288 ME_FULL, | |
| 289 ME_LOG, | |
| 290 ME_PHODS, | |
| 291 ME_EPZS, | |
| 292 ME_X1, | |
| 293 ME_HEX, | |
| 294 ME_UMH, | |
| 295 ME_ITER, | |
| 296 }; | |
| 297 | |
| 298 enum AVDiscard{ | |
| 299 //we leave some space between them for extensions (drop some keyframes for intra only or drop just some bidir frames) | |
| 300 AVDISCARD_NONE =-16, ///< discard nothing | |
| 301 AVDISCARD_DEFAULT= 0, ///< discard useless packets like 0 size packets in avi | |
| 302 AVDISCARD_NONREF = 8, ///< discard all non reference | |
| 303 AVDISCARD_BIDIR = 16, ///< discard all bidirectional frames | |
| 304 AVDISCARD_NONKEY = 32, ///< discard all frames except keyframes | |
| 305 AVDISCARD_ALL = 48, ///< discard all | |
| 306 }; | |
| 307 | |
| 308 typedef struct RcOverride{ | |
| 309 int start_frame; | |
| 310 int end_frame; | |
| 311 int qscale; // if this is 0 then quality_factor will be used instead | |
| 312 float quality_factor; | |
| 313 } RcOverride; | |
| 314 | |
| 315 #define FF_MAX_B_FRAMES 16 | |
| 316 | |
| 317 /* encoding support | |
| 318 these flags can be passed in AVCodecContext.flags before initing | |
| 319 Note: not everything is supported yet. | |
| 320 */ | |
| 321 | |
| 322 #define CODEC_FLAG_QSCALE 0x0002 ///< use fixed qscale | |
| 323 #define CODEC_FLAG_4MV 0x0004 ///< 4 MV per MB allowed / Advanced prediction for H263 | |
| 324 #define CODEC_FLAG_QPEL 0x0010 ///< use qpel MC | |
| 325 #define CODEC_FLAG_GMC 0x0020 ///< use GMC | |
| 326 #define CODEC_FLAG_MV0 0x0040 ///< always try a MB with MV=<0,0> | |
| 327 #define CODEC_FLAG_PART 0x0080 ///< use data partitioning | |
| 328 /* parent program gurantees that the input for b-frame containing streams is not written to | |
| 329 for at least s->max_b_frames+1 frames, if this is not set than the input will be copied */ | |
| 330 #define CODEC_FLAG_INPUT_PRESERVED 0x0100 | |
| 331 #define CODEC_FLAG_PASS1 0x0200 ///< use internal 2pass ratecontrol in first pass mode | |
| 332 #define CODEC_FLAG_PASS2 0x0400 ///< use internal 2pass ratecontrol in second pass mode | |
| 333 #define CODEC_FLAG_EXTERN_HUFF 0x1000 ///< use external huffman table (for mjpeg) | |
| 334 #define CODEC_FLAG_GRAY 0x2000 ///< only decode/encode grayscale | |
| 335 #define CODEC_FLAG_EMU_EDGE 0x4000///< don't draw edges | |
| 336 #define CODEC_FLAG_PSNR 0x8000 ///< error[?] variables will be set during encoding | |
| 337 #define CODEC_FLAG_TRUNCATED 0x00010000 /** input bitstream might be truncated at a random location instead | |
| 338 of only at frame boundaries */ | |
| 339 #define CODEC_FLAG_NORMALIZE_AQP 0x00020000 ///< normalize adaptive quantization | |
| 340 #define CODEC_FLAG_INTERLACED_DCT 0x00040000 ///< use interlaced dct | |
| 341 #define CODEC_FLAG_LOW_DELAY 0x00080000 ///< force low delay | |
| 342 #define CODEC_FLAG_ALT_SCAN 0x00100000 ///< use alternate scan | |
| 343 #define CODEC_FLAG_TRELLIS_QUANT 0x00200000 ///< use trellis quantization | |
| 344 #define CODEC_FLAG_GLOBAL_HEADER 0x00400000 ///< place global headers in extradata instead of every keyframe | |
| 345 #define CODEC_FLAG_BITEXACT 0x00800000 ///< use only bitexact stuff (except (i)dct) | |
| 346 /* Fx : Flag for h263+ extra options */ | |
| 347 #define CODEC_FLAG_H263P_AIC 0x01000000 ///< H263 Advanced intra coding / MPEG4 AC prediction (remove this) | |
| 348 #define CODEC_FLAG_AC_PRED 0x01000000 ///< H263 Advanced intra coding / MPEG4 AC prediction | |
| 349 #define CODEC_FLAG_H263P_UMV 0x02000000 ///< Unlimited motion vector | |
| 350 #define CODEC_FLAG_CBP_RD 0x04000000 ///< use rate distortion optimization for cbp | |
| 351 #define CODEC_FLAG_QP_RD 0x08000000 ///< use rate distortion optimization for qp selectioon | |
| 352 #define CODEC_FLAG_H263P_AIV 0x00000008 ///< H263 Alternative inter vlc | |
| 353 #define CODEC_FLAG_OBMC 0x00000001 ///< OBMC | |
| 354 #define CODEC_FLAG_LOOP_FILTER 0x00000800 ///< loop filter | |
| 355 #define CODEC_FLAG_H263P_SLICE_STRUCT 0x10000000 | |
| 356 #define CODEC_FLAG_INTERLACED_ME 0x20000000 ///< interlaced motion estimation | |
| 357 #define CODEC_FLAG_SVCD_SCAN_OFFSET 0x40000000 ///< will reserve space for SVCD scan offset user data | |
| 358 #define CODEC_FLAG_CLOSED_GOP ((int)0x80000000) | |
| 359 #define CODEC_FLAG2_FAST 0x00000001 ///< allow non spec compliant speedup tricks | |
| 360 #define CODEC_FLAG2_STRICT_GOP 0x00000002 ///< strictly enforce GOP size | |
| 361 #define CODEC_FLAG2_NO_OUTPUT 0x00000004 ///< skip bitstream encoding | |
| 362 #define CODEC_FLAG2_LOCAL_HEADER 0x00000008 ///< place global headers at every keyframe instead of in extradata | |
| 363 #define CODEC_FLAG2_BPYRAMID 0x00000010 ///< H.264 allow b-frames to be used as references | |
| 364 #define CODEC_FLAG2_WPRED 0x00000020 ///< H.264 weighted biprediction for b-frames | |
| 365 #define CODEC_FLAG2_MIXED_REFS 0x00000040 ///< H.264 multiple references per partition | |
| 366 #define CODEC_FLAG2_8X8DCT 0x00000080 ///< H.264 high profile 8x8 transform | |
| 367 #define CODEC_FLAG2_FASTPSKIP 0x00000100 ///< H.264 fast pskip | |
| 368 #define CODEC_FLAG2_AUD 0x00000200 ///< H.264 access unit delimiters | |
| 369 #define CODEC_FLAG2_BRDO 0x00000400 ///< b-frame rate-distortion optimization | |
| 370 #define CODEC_FLAG2_INTRA_VLC 0x00000800 ///< use MPEG-2 intra VLC table | |
| 371 #define CODEC_FLAG2_MEMC_ONLY 0x00001000 ///< only do ME/MC (I frames -> ref, P frame -> ME+MC) | |
| 372 | |
| 373 /* Unsupported options : | |
| 374 * Syntax Arithmetic coding (SAC) | |
| 375 * Reference Picture Selection | |
| 376 * Independant Segment Decoding */ | |
| 377 /* /Fx */ | |
| 378 /* codec capabilities */ | |
| 379 | |
| 380 #define CODEC_CAP_DRAW_HORIZ_BAND 0x0001 ///< decoder can use draw_horiz_band callback | |
| 381 /** | |
| 382 * Codec uses get_buffer() for allocating buffers. | |
| 383 * direct rendering method 1 | |
| 384 */ | |
| 385 #define CODEC_CAP_DR1 0x0002 | |
| 386 /* if 'parse_only' field is true, then avcodec_parse_frame() can be | |
| 387 used */ | |
| 388 #define CODEC_CAP_PARSE_ONLY 0x0004 | |
| 389 #define CODEC_CAP_TRUNCATED 0x0008 | |
| 390 /* codec can export data for HW decoding (XvMC) */ | |
| 391 #define CODEC_CAP_HWACCEL 0x0010 | |
| 392 /** | |
| 393 * codec has a non zero delay and needs to be feeded with NULL at the end to get the delayed data. | |
| 394 * if this is not set, the codec is guranteed to never be feeded with NULL data | |
| 395 */ | |
| 396 #define CODEC_CAP_DELAY 0x0020 | |
| 397 /** | |
| 398 * Codec can be fed a final frame with a smaller size. | |
| 399 * This can be used to prevent truncation of the last audio samples. | |
| 400 */ | |
| 401 #define CODEC_CAP_SMALL_LAST_FRAME 0x0040 | |
| 402 | |
| 403 //the following defines may change, don't expect compatibility if you use them | |
| 404 #define MB_TYPE_INTRA4x4 0x0001 | |
| 405 #define MB_TYPE_INTRA16x16 0x0002 //FIXME h264 specific | |
| 406 #define MB_TYPE_INTRA_PCM 0x0004 //FIXME h264 specific | |
| 407 #define MB_TYPE_16x16 0x0008 | |
| 408 #define MB_TYPE_16x8 0x0010 | |
| 409 #define MB_TYPE_8x16 0x0020 | |
| 410 #define MB_TYPE_8x8 0x0040 | |
| 411 #define MB_TYPE_INTERLACED 0x0080 | |
| 412 #define MB_TYPE_DIRECT2 0x0100 //FIXME | |
| 413 #define MB_TYPE_ACPRED 0x0200 | |
| 414 #define MB_TYPE_GMC 0x0400 | |
| 415 #define MB_TYPE_SKIP 0x0800 | |
| 416 #define MB_TYPE_P0L0 0x1000 | |
| 417 #define MB_TYPE_P1L0 0x2000 | |
| 418 #define MB_TYPE_P0L1 0x4000 | |
| 419 #define MB_TYPE_P1L1 0x8000 | |
| 420 #define MB_TYPE_L0 (MB_TYPE_P0L0 | MB_TYPE_P1L0) | |
| 421 #define MB_TYPE_L1 (MB_TYPE_P0L1 | MB_TYPE_P1L1) | |
| 422 #define MB_TYPE_L0L1 (MB_TYPE_L0 | MB_TYPE_L1) | |
| 423 #define MB_TYPE_QUANT 0x00010000 | |
| 424 #define MB_TYPE_CBP 0x00020000 | |
| 425 //Note bits 24-31 are reserved for codec specific use (h264 ref0, mpeg1 0mv, ...) | |
| 426 | |
| 427 /** | |
| 428 * Pan Scan area. | |
| 429 * this specifies the area which should be displayed. Note there may be multiple such areas for one frame | |
| 430 */ | |
| 431 typedef struct AVPanScan{ | |
| 432 /** | |
| 433 * id. | |
| 434 * - encoding: set by user. | |
| 435 * - decoding: set by lavc | |
| 436 */ | |
| 437 int id; | |
| 438 | |
| 439 /** | |
| 440 * width and height in 1/16 pel | |
| 441 * - encoding: set by user. | |
| 442 * - decoding: set by lavc | |
| 443 */ | |
| 444 int width; | |
| 445 int height; | |
| 446 | |
| 447 /** | |
| 448 * position of the top left corner in 1/16 pel for up to 3 fields/frames. | |
| 449 * - encoding: set by user. | |
| 450 * - decoding: set by lavc | |
| 451 */ | |
| 452 int16_t position[3][2]; | |
| 453 }AVPanScan; | |
| 454 | |
| 455 #define FF_COMMON_FRAME \ | |
| 456 /**\ | |
| 457 * pointer to the picture planes.\ | |
| 458 * this might be different from the first allocated byte\ | |
| 459 * - encoding: \ | |
| 460 * - decoding: \ | |
| 461 */\ | |
| 462 uint8_t *data[4];\ | |
| 463 int linesize[4];\ | |
| 464 /**\ | |
| 465 * pointer to the first allocated byte of the picture. can be used in get_buffer/release_buffer\ | |
| 466 * this isn't used by lavc unless the default get/release_buffer() is used\ | |
| 467 * - encoding: \ | |
| 468 * - decoding: \ | |
| 469 */\ | |
| 470 uint8_t *base[4];\ | |
| 471 /**\ | |
| 472 * 1 -> keyframe, 0-> not\ | |
| 473 * - encoding: set by lavc\ | |
| 474 * - decoding: set by lavc\ | |
| 475 */\ | |
| 476 int key_frame;\ | |
| 477 \ | |
| 478 /**\ | |
| 479 * picture type of the frame, see ?_TYPE below.\ | |
| 480 * - encoding: set by lavc for coded_picture (and set by user for input)\ | |
| 481 * - decoding: set by lavc\ | |
| 482 */\ | |
| 483 int pict_type;\ | |
| 484 \ | |
| 485 /**\ | |
| 486 * presentation timestamp in time_base units (time when frame should be shown to user)\ | |
| 487 * if AV_NOPTS_VALUE then frame_rate = 1/time_base will be assumed\ | |
| 488 * - encoding: MUST be set by user\ | |
| 489 * - decoding: set by lavc\ | |
| 490 */\ | |
| 491 int64_t pts;\ | |
| 492 \ | |
| 493 /**\ | |
| 494 * picture number in bitstream order.\ | |
| 495 * - encoding: set by\ | |
| 496 * - decoding: set by lavc\ | |
| 497 */\ | |
| 498 int coded_picture_number;\ | |
| 499 /**\ | |
| 500 * picture number in display order.\ | |
| 501 * - encoding: set by\ | |
| 502 * - decoding: set by lavc\ | |
| 503 */\ | |
| 504 int display_picture_number;\ | |
| 505 \ | |
| 506 /**\ | |
| 507 * quality (between 1 (good) and FF_LAMBDA_MAX (bad)) \ | |
| 508 * - encoding: set by lavc for coded_picture (and set by user for input)\ | |
| 509 * - decoding: set by lavc\ | |
| 510 */\ | |
| 511 int quality; \ | |
| 512 \ | |
| 513 /**\ | |
| 514 * buffer age (1->was last buffer and dint change, 2->..., ...).\ | |
| 515 * set to INT_MAX if the buffer has not been used yet \ | |
| 516 * - encoding: unused\ | |
| 517 * - decoding: MUST be set by get_buffer()\ | |
| 518 */\ | |
| 519 int age;\ | |
| 520 \ | |
| 521 /**\ | |
| 522 * is this picture used as reference\ | |
| 523 * - encoding: unused\ | |
| 524 * - decoding: set by lavc (before get_buffer() call))\ | |
| 525 */\ | |
| 526 int reference;\ | |
| 527 \ | |
| 528 /**\ | |
| 529 * QP table\ | |
| 530 * - encoding: unused\ | |
| 531 * - decoding: set by lavc\ | |
| 532 */\ | |
| 533 int8_t *qscale_table;\ | |
| 534 /**\ | |
| 535 * QP store stride\ | |
| 536 * - encoding: unused\ | |
| 537 * - decoding: set by lavc\ | |
| 538 */\ | |
| 539 int qstride;\ | |
| 540 \ | |
| 541 /**\ | |
| 542 * mbskip_table[mb]>=1 if MB didnt change\ | |
| 543 * stride= mb_width = (width+15)>>4\ | |
| 544 * - encoding: unused\ | |
| 545 * - decoding: set by lavc\ | |
| 546 */\ | |
| 547 uint8_t *mbskip_table;\ | |
| 548 \ | |
| 549 /**\ | |
| 550 * Motion vector table.\ | |
| 551 * @code\ | |
| 552 * example:\ | |
| 553 * int mv_sample_log2= 4 - motion_subsample_log2;\ | |
| 554 * int mb_width= (width+15)>>4;\ | |
| 555 * int mv_stride= (mb_width << mv_sample_log2) + 1;\ | |
| 556 * motion_val[direction][x + y*mv_stride][0->mv_x, 1->mv_y];\ | |
| 557 * @endcode\ | |
| 558 * - encoding: set by user\ | |
| 559 * - decoding: set by lavc\ | |
| 560 */\ | |
| 561 int16_t (*motion_val[2])[2];\ | |
| 562 \ | |
| 563 /**\ | |
| 564 * Macroblock type table\ | |
| 565 * mb_type_base + mb_width + 2\ | |
| 566 * - encoding: set by user\ | |
| 567 * - decoding: set by lavc\ | |
| 568 */\ | |
| 569 uint32_t *mb_type;\ | |
| 570 \ | |
| 571 /**\ | |
| 572 * log2 of the size of the block which a single vector in motion_val represents: \ | |
| 573 * (4->16x16, 3->8x8, 2-> 4x4, 1-> 2x2)\ | |
| 574 * - encoding: unused\ | |
| 575 * - decoding: set by lavc\ | |
| 576 */\ | |
| 577 uint8_t motion_subsample_log2;\ | |
| 578 \ | |
| 579 /**\ | |
| 580 * for some private data of the user\ | |
| 581 * - encoding: unused\ | |
| 582 * - decoding: set by user\ | |
| 583 */\ | |
| 584 void *opaque;\ | |
| 585 \ | |
| 586 /**\ | |
| 587 * error\ | |
| 588 * - encoding: set by lavc if flags&CODEC_FLAG_PSNR\ | |
| 589 * - decoding: unused\ | |
| 590 */\ | |
| 591 uint64_t error[4];\ | |
| 592 \ | |
| 593 /**\ | |
| 594 * type of the buffer (to keep track of who has to dealloc data[*])\ | |
| 595 * - encoding: set by the one who allocs it\ | |
| 596 * - decoding: set by the one who allocs it\ | |
| 597 * Note: user allocated (direct rendering) & internal buffers can not coexist currently\ | |
| 598 */\ | |
| 599 int type;\ | |
| 600 \ | |
| 601 /**\ | |
| 602 * when decoding, this signal how much the picture must be delayed.\ | |
| 603 * extra_delay = repeat_pict / (2*fps)\ | |
| 604 * - encoding: unused\ | |
| 605 * - decoding: set by lavc\ | |
| 606 */\ | |
| 607 int repeat_pict;\ | |
| 608 \ | |
| 609 /**\ | |
| 610 * \ | |
| 611 */\ | |
| 612 int qscale_type;\ | |
| 613 \ | |
| 614 /**\ | |
| 615 * The content of the picture is interlaced.\ | |
| 616 * - encoding: set by user\ | |
| 617 * - decoding: set by lavc (default 0)\ | |
| 618 */\ | |
| 619 int interlaced_frame;\ | |
| 620 \ | |
| 621 /**\ | |
| 622 * if the content is interlaced, is top field displayed first.\ | |
| 623 * - encoding: set by user\ | |
| 624 * - decoding: set by lavc\ | |
| 625 */\ | |
| 626 int top_field_first;\ | |
| 627 \ | |
| 628 /**\ | |
| 629 * Pan scan.\ | |
| 630 * - encoding: set by user\ | |
| 631 * - decoding: set by lavc\ | |
| 632 */\ | |
| 633 AVPanScan *pan_scan;\ | |
| 634 \ | |
| 635 /**\ | |
| 636 * tell user application that palette has changed from previous frame.\ | |
| 637 * - encoding: ??? (no palette-enabled encoder yet)\ | |
| 638 * - decoding: set by lavc (default 0)\ | |
| 639 */\ | |
| 640 int palette_has_changed;\ | |
| 641 \ | |
| 642 /**\ | |
| 643 * Codec suggestion on buffer type if != 0\ | |
| 644 * - encoding: unused\ | |
| 645 * - decoding: set by lavc (before get_buffer() call))\ | |
| 646 */\ | |
| 647 int buffer_hints;\ | |
| 648 \ | |
| 649 /**\ | |
| 650 * DCT coeffitients\ | |
| 651 * - encoding: unused\ | |
| 652 * - decoding: set by lavc\ | |
| 653 */\ | |
| 654 short *dct_coeff;\ | |
| 655 \ | |
| 656 /**\ | |
| 657 * Motion referece frame index\ | |
| 658 * - encoding: set by user\ | |
| 659 * - decoding: set by lavc\ | |
| 660 */\ | |
| 661 int8_t *ref_index[2]; | |
| 662 | |
| 663 #define FF_QSCALE_TYPE_MPEG1 0 | |
| 664 #define FF_QSCALE_TYPE_MPEG2 1 | |
| 665 #define FF_QSCALE_TYPE_H264 2 | |
| 666 | |
| 667 #define FF_BUFFER_TYPE_INTERNAL 1 | |
| 668 #define FF_BUFFER_TYPE_USER 2 ///< Direct rendering buffers (image is (de)allocated by user) | |
| 669 #define FF_BUFFER_TYPE_SHARED 4 ///< buffer from somewhere else, don't dealloc image (data/base), all other tables are not shared | |
| 670 #define FF_BUFFER_TYPE_COPY 8 ///< just a (modified) copy of some other buffer, don't dealloc anything | |
| 671 | |
| 672 | |
| 673 #define FF_I_TYPE 1 // Intra | |
| 674 #define FF_P_TYPE 2 // Predicted | |
| 675 #define FF_B_TYPE 3 // Bi-dir predicted | |
| 676 #define FF_S_TYPE 4 // S(GMC)-VOP MPEG4 | |
| 677 #define FF_SI_TYPE 5 | |
| 678 #define FF_SP_TYPE 6 | |
| 679 | |
| 680 #define FF_BUFFER_HINTS_VALID 0x01 // Buffer hints value is meaningful (if 0 ignore) | |
| 681 #define FF_BUFFER_HINTS_READABLE 0x02 // Codec will read from buffer | |
| 682 #define FF_BUFFER_HINTS_PRESERVE 0x04 // User must not alter buffer content | |
| 683 #define FF_BUFFER_HINTS_REUSABLE 0x08 // Codec will reuse the buffer (update) | |
| 684 | |
| 685 /** | |
| 686 * Audio Video Frame. | |
| 687 */ | |
| 688 typedef struct AVFrame { | |
| 689 FF_COMMON_FRAME | |
| 690 } AVFrame; | |
| 691 | |
| 692 #define DEFAULT_FRAME_RATE_BASE 1001000 | |
| 693 | |
| 694 /** | |
| 695 * main external api structure. | |
| 696 */ | |
| 697 typedef struct AVCodecContext { | |
| 698 /** | |
| 699 * Info on struct for av_log | |
| 700 * - set by avcodec_alloc_context | |
| 701 */ | |
| 702 AVClass *av_class; | |
| 703 /** | |
| 704 * the average bitrate. | |
| 705 * - encoding: set by user. unused for constant quantizer encoding | |
| 706 * - decoding: set by lavc. 0 or some bitrate if this info is available in the stream | |
| 707 */ | |
| 708 int bit_rate; | |
| 709 | |
| 710 /** | |
| 711 * number of bits the bitstream is allowed to diverge from the reference. | |
| 712 * the reference can be CBR (for CBR pass1) or VBR (for pass2) | |
| 713 * - encoding: set by user. unused for constant quantizer encoding | |
| 714 * - decoding: unused | |
| 715 */ | |
| 716 int bit_rate_tolerance; | |
| 717 | |
| 718 /** | |
| 719 * CODEC_FLAG_*. | |
| 720 * - encoding: set by user. | |
| 721 * - decoding: set by user. | |
| 722 */ | |
| 723 int flags; | |
| 724 | |
| 725 /** | |
| 726 * some codecs needs additionnal format info. It is stored here | |
| 727 * - encoding: set by user. | |
| 728 * - decoding: set by lavc. (FIXME is this ok?) | |
| 729 */ | |
| 730 int sub_id; | |
| 731 | |
| 732 /** | |
| 733 * motion estimation algorithm used for video coding. | |
| 734 * 1 (zero), 2 (full), 3 (log), 4 (phods), 5 (epzs), 6 (x1), 7 (hex), | |
| 735 * 8 (umh), 9 (iter) [7, 8 are x264 specific, 9 is snow specific] | |
| 736 * - encoding: MUST be set by user. | |
| 737 * - decoding: unused | |
| 738 */ | |
| 739 int me_method; | |
| 740 | |
| 741 /** | |
| 742 * some codecs need / can use extra-data like huffman tables. | |
| 743 * mjpeg: huffman tables | |
| 744 * rv10: additional flags | |
| 745 * mpeg4: global headers (they can be in the bitstream or here) | |
| 746 * the allocated memory should be FF_INPUT_BUFFER_PADDING_SIZE bytes larger | |
| 747 * then extradata_size to avoid prolems if its read with the bitstream reader | |
| 748 * the bytewise contents of extradata must not depend on the architecture or cpu endianness | |
| 749 * - encoding: set/allocated/freed by lavc. | |
| 750 * - decoding: set/allocated/freed by user. | |
| 751 */ | |
| 752 uint8_t *extradata; | |
| 753 int extradata_size; | |
| 754 | |
| 755 /** | |
| 756 * this is the fundamental unit of time (in seconds) in terms | |
| 757 * of which frame timestamps are represented. for fixed-fps content, | |
| 758 * timebase should be 1/framerate and timestamp increments should be | |
| 759 * identically 1. | |
| 760 * - encoding: MUST be set by user | |
| 761 * - decoding: set by lavc. | |
| 762 */ | |
| 763 AVRational time_base; | |
| 764 | |
| 765 /* video only */ | |
| 766 /** | |
| 767 * picture width / height. | |
| 768 * - encoding: MUST be set by user. | |
| 769 * - decoding: set by lavc. | |
| 770 * Note, for compatibility its possible to set this instead of | |
| 771 * coded_width/height before decoding | |
| 772 */ | |
| 773 int width, height; | |
| 774 | |
| 775 #define FF_ASPECT_EXTENDED 15 | |
| 776 | |
| 777 /** | |
| 778 * the number of pictures in a group of pitures, or 0 for intra_only. | |
| 779 * - encoding: set by user. | |
| 780 * - decoding: unused | |
| 781 */ | |
| 782 int gop_size; | |
| 783 | |
| 784 /** | |
| 785 * pixel format, see PIX_FMT_xxx. | |
| 786 * - encoding: set by user. | |
| 787 * - decoding: set by lavc. | |
| 788 */ | |
| 789 enum PixelFormat pix_fmt; | |
| 790 | |
| 791 /** | |
| 792 * Frame rate emulation. If not zero lower layer (i.e. format handler) | |
| 793 * has to read frames at native frame rate. | |
| 794 * - encoding: set by user. | |
| 795 * - decoding: unused. | |
| 796 */ | |
| 797 int rate_emu; | |
| 798 | |
| 799 /** | |
| 800 * if non NULL, 'draw_horiz_band' is called by the libavcodec | |
| 801 * decoder to draw an horizontal band. It improve cache usage. Not | |
| 802 * all codecs can do that. You must check the codec capabilities | |
| 803 * before | |
| 804 * - encoding: unused | |
| 805 * - decoding: set by user. | |
| 806 * @param height the height of the slice | |
| 807 * @param y the y position of the slice | |
| 808 * @param type 1->top field, 2->bottom field, 3->frame | |
| 809 * @param offset offset into the AVFrame.data from which the slice should be read | |
| 810 */ | |
| 811 void (*draw_horiz_band)(struct AVCodecContext *s, | |
| 812 const AVFrame *src, int offset[4], | |
| 813 int y, int type, int height); | |
| 814 | |
| 815 /* audio only */ | |
| 816 int sample_rate; ///< samples per sec | |
| 817 int channels; | |
| 818 | |
| 819 /** | |
| 820 * audio sample format. | |
| 821 * - encoding: set by user. | |
| 822 * - decoding: set by lavc. | |
| 823 */ | |
| 824 enum SampleFormat sample_fmt; ///< sample format, currenly unused | |
| 825 | |
| 826 /* the following data should not be initialized */ | |
| 827 /** | |
| 828 * samples per packet. initialized when calling 'init' | |
| 829 */ | |
| 830 int frame_size; | |
| 831 int frame_number; ///< audio or video frame number | |
| 832 int real_pict_num; ///< returns the real picture number of previous encoded frame | |
| 833 | |
| 834 /** | |
| 835 * number of frames the decoded output will be delayed relative to | |
| 836 * the encoded input. | |
| 837 * - encoding: set by lavc. | |
| 838 * - decoding: unused | |
| 839 */ | |
| 840 int delay; | |
| 841 | |
| 842 /* - encoding parameters */ | |
| 843 float qcompress; ///< amount of qscale change between easy & hard scenes (0.0-1.0) | |
| 844 float qblur; ///< amount of qscale smoothing over time (0.0-1.0) | |
| 845 | |
| 846 /** | |
| 847 * minimum quantizer. | |
| 848 * - encoding: set by user. | |
| 849 * - decoding: unused | |
| 850 */ | |
| 851 int qmin; | |
| 852 | |
| 853 /** | |
| 854 * maximum quantizer. | |
| 855 * - encoding: set by user. | |
| 856 * - decoding: unused | |
| 857 */ | |
| 858 int qmax; | |
| 859 | |
| 860 /** | |
| 861 * maximum quantizer difference etween frames. | |
| 862 * - encoding: set by user. | |
| 863 * - decoding: unused | |
| 864 */ | |
| 865 int max_qdiff; | |
| 866 | |
| 867 /** | |
| 868 * maximum number of b frames between non b frames. | |
| 869 * note: the output will be delayed by max_b_frames+1 relative to the input | |
| 870 * - encoding: set by user. | |
| 871 * - decoding: unused | |
| 872 */ | |
| 873 int max_b_frames; | |
| 874 | |
| 875 /** | |
| 876 * qscale factor between ip and b frames. | |
| 877 * - encoding: set by user. | |
| 878 * - decoding: unused | |
| 879 */ | |
| 880 float b_quant_factor; | |
| 881 | |
| 882 /** obsolete FIXME remove */ | |
| 883 int rc_strategy; | |
| 884 #define FF_RC_STRATEGY_XVID 1 | |
| 885 | |
| 886 int b_frame_strategy; | |
| 887 | |
| 888 /** | |
| 889 * hurry up amount. | |
| 890 * deprecated in favor of skip_idct and skip_frame | |
| 891 * - encoding: unused | |
| 892 * - decoding: set by user. 1-> skip b frames, 2-> skip idct/dequant too, 5-> skip everything except header | |
| 893 */ | |
| 894 int hurry_up; | |
| 895 | |
| 896 struct AVCodec *codec; | |
| 897 | |
| 898 void *priv_data; | |
| 899 | |
| 900 /* unused, FIXME remove*/ | |
| 901 int rtp_mode; | |
| 902 | |
| 903 int rtp_payload_size; /* The size of the RTP payload: the coder will */ | |
| 904 /* do it's best to deliver a chunk with size */ | |
| 905 /* below rtp_payload_size, the chunk will start */ | |
| 906 /* with a start code on some codecs like H.263 */ | |
| 907 /* This doesn't take account of any particular */ | |
| 908 /* headers inside the transmited RTP payload */ | |
| 909 | |
| 910 | |
| 911 /* The RTP callback: This function is called */ | |
| 912 /* every time the encoder has a packet to send */ | |
| 913 /* Depends on the encoder if the data starts */ | |
| 914 /* with a Start Code (it should) H.263 does. */ | |
| 915 /* mb_nb contains the number of macroblocks */ | |
| 916 /* encoded in the RTP payload */ | |
| 917 void (*rtp_callback)(struct AVCodecContext *avctx, void *data, int size, int mb_nb); | |
| 918 | |
| 919 /* statistics, used for 2-pass encoding */ | |
| 920 int mv_bits; | |
| 921 int header_bits; | |
| 922 int i_tex_bits; | |
| 923 int p_tex_bits; | |
| 924 int i_count; | |
| 925 int p_count; | |
| 926 int skip_count; | |
| 927 int misc_bits; | |
| 928 | |
| 929 /** | |
| 930 * number of bits used for the previously encoded frame. | |
| 931 * - encoding: set by lavc | |
| 932 * - decoding: unused | |
| 933 */ | |
| 934 int frame_bits; | |
| 935 | |
| 936 /** | |
| 937 * private data of the user, can be used to carry app specific stuff. | |
| 938 * - encoding: set by user | |
| 939 * - decoding: set by user | |
| 940 */ | |
| 941 void *opaque; | |
| 942 | |
| 943 char codec_name[32]; | |
| 944 enum CodecType codec_type; /* see CODEC_TYPE_xxx */ | |
| 945 enum CodecID codec_id; /* see CODEC_ID_xxx */ | |
| 946 | |
| 947 /** | |
| 948 * fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A'). | |
| 949 * this is used to workaround some encoder bugs | |
| 950 * - encoding: set by user, if not then the default based on codec_id will be used | |
| 951 * - decoding: set by user, will be converted to upper case by lavc during init | |
| 952 */ | |
| 953 unsigned int codec_tag; | |
| 954 | |
| 955 /** | |
| 956 * workaround bugs in encoders which sometimes cannot be detected automatically. | |
| 957 * - encoding: set by user | |
| 958 * - decoding: set by user | |
| 959 */ | |
| 960 int workaround_bugs; | |
| 961 #define FF_BUG_AUTODETECT 1 ///< autodetection | |
| 962 #define FF_BUG_OLD_MSMPEG4 2 | |
| 963 #define FF_BUG_XVID_ILACE 4 | |
| 964 #define FF_BUG_UMP4 8 | |
| 965 #define FF_BUG_NO_PADDING 16 | |
| 966 #define FF_BUG_AMV 32 | |
| 967 #define FF_BUG_AC_VLC 0 ///< will be removed, libavcodec can now handle these non compliant files by default | |
| 968 #define FF_BUG_QPEL_CHROMA 64 | |
| 969 #define FF_BUG_STD_QPEL 128 | |
| 970 #define FF_BUG_QPEL_CHROMA2 256 | |
| 971 #define FF_BUG_DIRECT_BLOCKSIZE 512 | |
| 972 #define FF_BUG_EDGE 1024 | |
| 973 #define FF_BUG_HPEL_CHROMA 2048 | |
| 974 #define FF_BUG_DC_CLIP 4096 | |
| 975 #define FF_BUG_MS 8192 ///< workaround various bugs in microsofts broken decoders | |
| 976 //#define FF_BUG_FAKE_SCALABILITY 16 //autodetection should work 100% | |
| 977 | |
| 978 /** | |
| 979 * luma single coeff elimination threshold. | |
| 980 * - encoding: set by user | |
| 981 * - decoding: unused | |
| 982 */ | |
| 983 int luma_elim_threshold; | |
| 984 | |
| 985 /** | |
| 986 * chroma single coeff elimination threshold. | |
| 987 * - encoding: set by user | |
| 988 * - decoding: unused | |
| 989 */ | |
| 990 int chroma_elim_threshold; | |
| 991 | |
| 992 /** | |
| 993 * strictly follow the std (MPEG4, ...). | |
| 994 * - encoding: set by user | |
| 995 * - decoding: unused | |
| 996 */ | |
| 997 int strict_std_compliance; | |
| 998 #define FF_COMPLIANCE_VERY_STRICT 2 ///< strictly conform to a older more strict version of the spec or reference software | |
| 999 #define FF_COMPLIANCE_STRICT 1 ///< strictly conform to all the things in the spec no matter what consequences | |
| 1000 #define FF_COMPLIANCE_NORMAL 0 | |
| 1001 #define FF_COMPLIANCE_INOFFICIAL -1 ///< allow inofficial extensions | |
| 1002 #define FF_COMPLIANCE_EXPERIMENTAL -2 ///< allow non standarized experimental things | |
| 1003 | |
| 1004 /** | |
| 1005 * qscale offset between ip and b frames. | |
| 1006 * if > 0 then the last p frame quantizer will be used (q= lastp_q*factor+offset) | |
| 1007 * if < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset) | |
| 1008 * - encoding: set by user. | |
| 1009 * - decoding: unused | |
| 1010 */ | |
| 1011 float b_quant_offset; | |
| 1012 | |
| 1013 /** | |
| 1014 * error resilience higher values will detect more errors but may missdetect | |
| 1015 * some more or less valid parts as errors. | |
| 1016 * - encoding: unused | |
| 1017 * - decoding: set by user | |
| 1018 */ | |
| 1019 int error_resilience; | |
| 1020 #define FF_ER_CAREFUL 1 | |
| 1021 #define FF_ER_COMPLIANT 2 | |
| 1022 #define FF_ER_AGGRESSIVE 3 | |
| 1023 #define FF_ER_VERY_AGGRESSIVE 4 | |
| 1024 | |
| 1025 /** | |
| 1026 * called at the beginning of each frame to get a buffer for it. | |
| 1027 * if pic.reference is set then the frame will be read later by lavc | |
| 1028 * avcodec_align_dimensions() should be used to find the required width and | |
| 1029 * height, as they normally need to be rounded up to the next multiple of 16 | |
| 1030 * - encoding: unused | |
| 1031 * - decoding: set by lavc, user can override | |
| 1032 */ | |
| 1033 int (*get_buffer)(struct AVCodecContext *c, AVFrame *pic); | |
| 1034 | |
| 1035 /** | |
| 1036 * called to release buffers which where allocated with get_buffer. | |
| 1037 * a released buffer can be reused in get_buffer() | |
| 1038 * pic.data[*] must be set to NULL | |
| 1039 * - encoding: unused | |
| 1040 * - decoding: set by lavc, user can override | |
| 1041 */ | |
| 1042 void (*release_buffer)(struct AVCodecContext *c, AVFrame *pic); | |
| 1043 | |
| 1044 /** | |
| 1045 * if 1 the stream has a 1 frame delay during decoding. | |
| 1046 * - encoding: set by lavc | |
| 1047 * - decoding: set by lavc | |
| 1048 */ | |
| 1049 int has_b_frames; | |
| 1050 | |
| 1051 /** | |
| 1052 * number of bytes per packet if constant and known or 0 | |
| 1053 * used by some WAV based audio codecs | |
| 1054 */ | |
| 1055 int block_align; | |
| 1056 | |
| 1057 int parse_only; /* - decoding only: if true, only parsing is done | |
| 1058 (function avcodec_parse_frame()). The frame | |
| 1059 data is returned. Only MPEG codecs support this now. */ | |
| 1060 | |
| 1061 /** | |
| 1062 * 0-> h263 quant 1-> mpeg quant. | |
| 1063 * - encoding: set by user. | |
| 1064 * - decoding: unused | |
| 1065 */ | |
| 1066 int mpeg_quant; | |
| 1067 | |
| 1068 /** | |
| 1069 * pass1 encoding statistics output buffer. | |
| 1070 * - encoding: set by lavc | |
| 1071 * - decoding: unused | |
| 1072 */ | |
| 1073 char *stats_out; | |
| 1074 | |
| 1075 /** | |
| 1076 * pass2 encoding statistics input buffer. | |
| 1077 * concatenated stuff from stats_out of pass1 should be placed here | |
| 1078 * - encoding: allocated/set/freed by user | |
| 1079 * - decoding: unused | |
| 1080 */ | |
| 1081 char *stats_in; | |
| 1082 | |
| 1083 /** | |
| 1084 * ratecontrol qmin qmax limiting method. | |
| 1085 * 0-> clipping, 1-> use a nice continous function to limit qscale wthin qmin/qmax | |
| 1086 * - encoding: set by user. | |
| 1087 * - decoding: unused | |
| 1088 */ | |
| 1089 float rc_qsquish; | |
| 1090 | |
| 1091 float rc_qmod_amp; | |
| 1092 int rc_qmod_freq; | |
| 1093 | |
| 1094 /** | |
| 1095 * ratecontrol override, see RcOverride. | |
| 1096 * - encoding: allocated/set/freed by user. | |
| 1097 * - decoding: unused | |
| 1098 */ | |
| 1099 RcOverride *rc_override; | |
| 1100 int rc_override_count; | |
| 1101 | |
| 1102 /** | |
| 1103 * rate control equation. | |
| 1104 * - encoding: set by user | |
| 1105 * - decoding: unused | |
| 1106 */ | |
| 1107 char *rc_eq; | |
| 1108 | |
| 1109 /** | |
| 1110 * maximum bitrate. | |
| 1111 * - encoding: set by user. | |
| 1112 * - decoding: unused | |
| 1113 */ | |
| 1114 int rc_max_rate; | |
| 1115 | |
| 1116 /** | |
| 1117 * minimum bitrate. | |
| 1118 * - encoding: set by user. | |
| 1119 * - decoding: unused | |
| 1120 */ | |
| 1121 int rc_min_rate; | |
| 1122 | |
| 1123 /** | |
| 1124 * decoder bitstream buffer size. | |
| 1125 * - encoding: set by user. | |
| 1126 * - decoding: unused | |
| 1127 */ | |
| 1128 int rc_buffer_size; | |
| 1129 float rc_buffer_aggressivity; | |
| 1130 | |
| 1131 /** | |
| 1132 * qscale factor between p and i frames. | |
| 1133 * if > 0 then the last p frame quantizer will be used (q= lastp_q*factor+offset) | |
| 1134 * if < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset) | |
| 1135 * - encoding: set by user. | |
| 1136 * - decoding: unused | |
| 1137 */ | |
| 1138 float i_quant_factor; | |
| 1139 | |
| 1140 /** | |
| 1141 * qscale offset between p and i frames. | |
| 1142 * - encoding: set by user. | |
| 1143 * - decoding: unused | |
| 1144 */ | |
| 1145 float i_quant_offset; | |
| 1146 | |
| 1147 /** | |
| 1148 * initial complexity for pass1 ratecontrol. | |
| 1149 * - encoding: set by user. | |
| 1150 * - decoding: unused | |
| 1151 */ | |
| 1152 float rc_initial_cplx; | |
| 1153 | |
| 1154 /** | |
| 1155 * dct algorithm, see FF_DCT_* below. | |
| 1156 * - encoding: set by user | |
| 1157 * - decoding: unused | |
| 1158 */ | |
| 1159 int dct_algo; | |
| 1160 #define FF_DCT_AUTO 0 | |
| 1161 #define FF_DCT_FASTINT 1 | |
| 1162 #define FF_DCT_INT 2 | |
| 1163 #define FF_DCT_MMX 3 | |
| 1164 #define FF_DCT_MLIB 4 | |
| 1165 #define FF_DCT_ALTIVEC 5 | |
| 1166 #define FF_DCT_FAAN 6 | |
| 1167 | |
| 1168 /** | |
| 1169 * luminance masking (0-> disabled). | |
| 1170 * - encoding: set by user | |
| 1171 * - decoding: unused | |
| 1172 */ | |
| 1173 float lumi_masking; | |
| 1174 | |
| 1175 /** | |
| 1176 * temporary complexity masking (0-> disabled). | |
| 1177 * - encoding: set by user | |
| 1178 * - decoding: unused | |
| 1179 */ | |
| 1180 float temporal_cplx_masking; | |
| 1181 | |
| 1182 /** | |
| 1183 * spatial complexity masking (0-> disabled). | |
| 1184 * - encoding: set by user | |
| 1185 * - decoding: unused | |
| 1186 */ | |
| 1187 float spatial_cplx_masking; | |
| 1188 | |
| 1189 /** | |
| 1190 * p block masking (0-> disabled). | |
| 1191 * - encoding: set by user | |
| 1192 * - decoding: unused | |
| 1193 */ | |
| 1194 float p_masking; | |
| 1195 | |
| 1196 /** | |
| 1197 * darkness masking (0-> disabled). | |
| 1198 * - encoding: set by user | |
| 1199 * - decoding: unused | |
| 1200 */ | |
| 1201 float dark_masking; | |
| 1202 | |
| 1203 | |
| 1204 /* for binary compatibility */ | |
| 1205 int unused; | |
| 1206 | |
| 1207 /** | |
| 1208 * idct algorithm, see FF_IDCT_* below. | |
| 1209 * - encoding: set by user | |
| 1210 * - decoding: set by user | |
| 1211 */ | |
| 1212 int idct_algo; | |
| 1213 #define FF_IDCT_AUTO 0 | |
| 1214 #define FF_IDCT_INT 1 | |
| 1215 #define FF_IDCT_SIMPLE 2 | |
| 1216 #define FF_IDCT_SIMPLEMMX 3 | |
| 1217 #define FF_IDCT_LIBMPEG2MMX 4 | |
| 1218 #define FF_IDCT_PS2 5 | |
| 1219 #define FF_IDCT_MLIB 6 | |
| 1220 #define FF_IDCT_ARM 7 | |
| 1221 #define FF_IDCT_ALTIVEC 8 | |
| 1222 #define FF_IDCT_SH4 9 | |
| 1223 #define FF_IDCT_SIMPLEARM 10 | |
| 1224 #define FF_IDCT_H264 11 | |
| 1225 #define FF_IDCT_VP3 12 | |
| 1226 #define FF_IDCT_IPP 13 | |
| 1227 #define FF_IDCT_XVIDMMX 14 | |
| 1228 #define FF_IDCT_CAVS 15 | |
| 1229 #define FF_IDCT_SIMPLEARMV5TE 16 | |
| 1230 | |
| 1231 /** | |
| 1232 * slice count. | |
| 1233 * - encoding: set by lavc | |
| 1234 * - decoding: set by user (or 0) | |
| 1235 */ | |
| 1236 int slice_count; | |
| 1237 /** | |
| 1238 * slice offsets in the frame in bytes. | |
| 1239 * - encoding: set/allocated by lavc | |
| 1240 * - decoding: set/allocated by user (or NULL) | |
| 1241 */ | |
| 1242 int *slice_offset; | |
| 1243 | |
| 1244 /** | |
| 1245 * error concealment flags. | |
| 1246 * - encoding: unused | |
| 1247 * - decoding: set by user | |
| 1248 */ | |
| 1249 int error_concealment; | |
| 1250 #define FF_EC_GUESS_MVS 1 | |
| 1251 #define FF_EC_DEBLOCK 2 | |
| 1252 | |
| 1253 /** | |
| 1254 * dsp_mask could be add used to disable unwanted CPU features | |
| 1255 * CPU features (i.e. MMX, SSE. ...) | |
| 1256 * | |
| 1257 * with FORCE flag you may instead enable given CPU features | |
| 1258 * (Dangerous: usable in case of misdetection, improper usage however will | |
| 1259 * result into program crash) | |
| 1260 */ | |
| 1261 unsigned dsp_mask; | |
| 1262 #define FF_MM_FORCE 0x80000000 /* force usage of selected flags (OR) */ | |
| 1263 /* lower 16 bits - CPU features */ | |
| 1264 #ifdef HAVE_MMX | |
| 1265 #define FF_MM_MMX 0x0001 /* standard MMX */ | |
| 1266 #define FF_MM_3DNOW 0x0004 /* AMD 3DNOW */ | |
| 1267 #define FF_MM_MMXEXT 0x0002 /* SSE integer functions or AMD MMX ext */ | |
| 1268 #define FF_MM_SSE 0x0008 /* SSE functions */ | |
| 1269 #define FF_MM_SSE2 0x0010 /* PIV SSE2 functions */ | |
| 1270 #define FF_MM_3DNOWEXT 0x0020 /* AMD 3DNowExt */ | |
| 1271 #endif /* HAVE_MMX */ | |
| 1272 #ifdef HAVE_IWMMXT | |
| 1273 #define FF_MM_IWMMXT 0x0100 /* XScale IWMMXT */ | |
| 1274 #endif /* HAVE_IWMMXT */ | |
| 1275 | |
| 1276 /** | |
| 1277 * bits per sample/pixel from the demuxer (needed for huffyuv). | |
| 1278 * - encoding: set by lavc | |
| 1279 * - decoding: set by user | |
| 1280 */ | |
| 1281 int bits_per_sample; | |
| 1282 | |
| 1283 /** | |
| 1284 * prediction method (needed for huffyuv). | |
| 1285 * - encoding: set by user | |
| 1286 * - decoding: unused | |
| 1287 */ | |
| 1288 int prediction_method; | |
| 1289 #define FF_PRED_LEFT 0 | |
| 1290 #define FF_PRED_PLANE 1 | |
| 1291 #define FF_PRED_MEDIAN 2 | |
| 1292 | |
| 1293 /** | |
| 1294 * sample aspect ratio (0 if unknown). | |
| 1295 * numerator and denominator must be relative prime and smaller then 256 for some video standards | |
| 1296 * - encoding: set by user. | |
| 1297 * - decoding: set by lavc. | |
| 1298 */ | |
| 1299 AVRational sample_aspect_ratio; | |
| 1300 | |
| 1301 /** | |
| 1302 * the picture in the bitstream. | |
| 1303 * - encoding: set by lavc | |
| 1304 * - decoding: set by lavc | |
| 1305 */ | |
| 1306 AVFrame *coded_frame; | |
| 1307 | |
| 1308 /** | |
| 1309 * debug. | |
| 1310 * - encoding: set by user. | |
| 1311 * - decoding: set by user. | |
| 1312 */ | |
| 1313 int debug; | |
| 1314 #define FF_DEBUG_PICT_INFO 1 | |
| 1315 #define FF_DEBUG_RC 2 | |
| 1316 #define FF_DEBUG_BITSTREAM 4 | |
| 1317 #define FF_DEBUG_MB_TYPE 8 | |
| 1318 #define FF_DEBUG_QP 16 | |
| 1319 #define FF_DEBUG_MV 32 | |
| 1320 #define FF_DEBUG_DCT_COEFF 0x00000040 | |
| 1321 #define FF_DEBUG_SKIP 0x00000080 | |
| 1322 #define FF_DEBUG_STARTCODE 0x00000100 | |
| 1323 #define FF_DEBUG_PTS 0x00000200 | |
| 1324 #define FF_DEBUG_ER 0x00000400 | |
| 1325 #define FF_DEBUG_MMCO 0x00000800 | |
| 1326 #define FF_DEBUG_BUGS 0x00001000 | |
| 1327 #define FF_DEBUG_VIS_QP 0x00002000 | |
| 1328 #define FF_DEBUG_VIS_MB_TYPE 0x00004000 | |
| 1329 | |
| 1330 /** | |
| 1331 * debug. | |
| 1332 * - encoding: set by user. | |
| 1333 * - decoding: set by user. | |
| 1334 */ | |
| 1335 int debug_mv; | |
| 1336 #define FF_DEBUG_VIS_MV_P_FOR 0x00000001 //visualize forward predicted MVs of P frames | |
| 1337 #define FF_DEBUG_VIS_MV_B_FOR 0x00000002 //visualize forward predicted MVs of B frames | |
| 1338 #define FF_DEBUG_VIS_MV_B_BACK 0x00000004 //visualize backward predicted MVs of B frames | |
| 1339 | |
| 1340 /** | |
| 1341 * error. | |
| 1342 * - encoding: set by lavc if flags&CODEC_FLAG_PSNR | |
| 1343 * - decoding: unused | |
| 1344 */ | |
| 1345 uint64_t error[4]; | |
| 1346 | |
| 1347 /** | |
| 1348 * minimum MB quantizer. | |
| 1349 * - encoding: unused | |
| 1350 * - decoding: unused | |
| 1351 */ | |
| 1352 int mb_qmin; | |
| 1353 | |
| 1354 /** | |
| 1355 * maximum MB quantizer. | |
| 1356 * - encoding: unused | |
| 1357 * - decoding: unused | |
| 1358 */ | |
| 1359 int mb_qmax; | |
| 1360 | |
| 1361 /** | |
| 1362 * motion estimation compare function. | |
| 1363 * - encoding: set by user. | |
| 1364 * - decoding: unused | |
| 1365 */ | |
| 1366 int me_cmp; | |
| 1367 /** | |
| 1368 * subpixel motion estimation compare function. | |
| 1369 * - encoding: set by user. | |
| 1370 * - decoding: unused | |
| 1371 */ | |
| 1372 int me_sub_cmp; | |
| 1373 /** | |
| 1374 * macroblock compare function (not supported yet). | |
| 1375 * - encoding: set by user. | |
| 1376 * - decoding: unused | |
| 1377 */ | |
| 1378 int mb_cmp; | |
| 1379 /** | |
| 1380 * interlaced dct compare function | |
| 1381 * - encoding: set by user. | |
| 1382 * - decoding: unused | |
| 1383 */ | |
| 1384 int ildct_cmp; | |
| 1385 #define FF_CMP_SAD 0 | |
| 1386 #define FF_CMP_SSE 1 | |
| 1387 #define FF_CMP_SATD 2 | |
| 1388 #define FF_CMP_DCT 3 | |
| 1389 #define FF_CMP_PSNR 4 | |
| 1390 #define FF_CMP_BIT 5 | |
| 1391 #define FF_CMP_RD 6 | |
| 1392 #define FF_CMP_ZERO 7 | |
| 1393 #define FF_CMP_VSAD 8 | |
| 1394 #define FF_CMP_VSSE 9 | |
| 1395 #define FF_CMP_NSSE 10 | |
| 1396 #define FF_CMP_W53 11 | |
| 1397 #define FF_CMP_W97 12 | |
| 1398 #define FF_CMP_DCTMAX 13 | |
| 1399 #define FF_CMP_DCT264 14 | |
| 1400 #define FF_CMP_CHROMA 256 | |
| 1401 | |
| 1402 /** | |
| 1403 * ME diamond size & shape. | |
| 1404 * - encoding: set by user. | |
| 1405 * - decoding: unused | |
| 1406 */ | |
| 1407 int dia_size; | |
| 1408 | |
| 1409 /** | |
| 1410 * amount of previous MV predictors (2a+1 x 2a+1 square). | |
| 1411 * - encoding: set by user. | |
| 1412 * - decoding: unused | |
| 1413 */ | |
| 1414 int last_predictor_count; | |
| 1415 | |
| 1416 /** | |
| 1417 * pre pass for motion estimation. | |
| 1418 * - encoding: set by user. | |
| 1419 * - decoding: unused | |
| 1420 */ | |
| 1421 int pre_me; | |
| 1422 | |
| 1423 /** | |
| 1424 * motion estimation pre pass compare function. | |
| 1425 * - encoding: set by user. | |
| 1426 * - decoding: unused | |
| 1427 */ | |
| 1428 int me_pre_cmp; | |
| 1429 | |
| 1430 /** | |
| 1431 * ME pre pass diamond size & shape. | |
| 1432 * - encoding: set by user. | |
| 1433 * - decoding: unused | |
| 1434 */ | |
| 1435 int pre_dia_size; | |
| 1436 | |
| 1437 /** | |
| 1438 * subpel ME quality. | |
| 1439 * - encoding: set by user. | |
| 1440 * - decoding: unused | |
| 1441 */ | |
| 1442 int me_subpel_quality; | |
| 1443 | |
| 1444 /** | |
| 1445 * callback to negotiate the pixelFormat. | |
| 1446 * @param fmt is the list of formats which are supported by the codec, | |
| 1447 * its terminated by -1 as 0 is a valid format, the formats are ordered by quality | |
| 1448 * the first is allways the native one | |
| 1449 * @return the choosen format | |
| 1450 * - encoding: unused | |
| 1451 * - decoding: set by user, if not set then the native format will always be choosen | |
| 1452 */ | |
| 1453 enum PixelFormat (*get_format)(struct AVCodecContext *s, const enum PixelFormat * fmt); | |
| 1454 | |
| 1455 /** | |
| 1456 * DTG active format information (additionnal aspect ratio | |
| 1457 * information only used in DVB MPEG2 transport streams). 0 if | |
| 1458 * not set. | |
| 1459 * | |
| 1460 * - encoding: unused. | |
| 1461 * - decoding: set by decoder | |
| 1462 */ | |
| 1463 int dtg_active_format; | |
| 1464 #define FF_DTG_AFD_SAME 8 | |
| 1465 #define FF_DTG_AFD_4_3 9 | |
| 1466 #define FF_DTG_AFD_16_9 10 | |
| 1467 #define FF_DTG_AFD_14_9 11 | |
| 1468 #define FF_DTG_AFD_4_3_SP_14_9 13 | |
| 1469 #define FF_DTG_AFD_16_9_SP_14_9 14 | |
| 1470 #define FF_DTG_AFD_SP_4_3 15 | |
| 1471 | |
| 1472 /** | |
| 1473 * Maximum motion estimation search range in subpel units. | |
| 1474 * if 0 then no limit | |
| 1475 * | |
| 1476 * - encoding: set by user. | |
| 1477 * - decoding: unused. | |
| 1478 */ | |
| 1479 int me_range; | |
| 1480 | |
| 1481 /** | |
| 1482 * intra quantizer bias. | |
| 1483 * - encoding: set by user. | |
| 1484 * - decoding: unused | |
| 1485 */ | |
| 1486 int intra_quant_bias; | |
| 1487 #define FF_DEFAULT_QUANT_BIAS 999999 | |
| 1488 | |
| 1489 /** | |
| 1490 * inter quantizer bias. | |
| 1491 * - encoding: set by user. | |
| 1492 * - decoding: unused | |
| 1493 */ | |
| 1494 int inter_quant_bias; | |
| 1495 | |
| 1496 /** | |
| 1497 * color table ID. | |
| 1498 * - encoding: unused. | |
| 1499 * - decoding: which clrtable should be used for 8bit RGB images | |
| 1500 * table have to be stored somewhere FIXME | |
| 1501 */ | |
| 1502 int color_table_id; | |
| 1503 | |
| 1504 /** | |
| 1505 * internal_buffer count. | |
| 1506 * Don't touch, used by lavc default_get_buffer() | |
| 1507 */ | |
| 1508 int internal_buffer_count; | |
| 1509 | |
| 1510 /** | |
| 1511 * internal_buffers. | |
| 1512 * Don't touch, used by lavc default_get_buffer() | |
| 1513 */ | |
| 1514 void *internal_buffer; | |
| 1515 | |
| 1516 #define FF_LAMBDA_SHIFT 7 | |
| 1517 #define FF_LAMBDA_SCALE (1<<FF_LAMBDA_SHIFT) | |
| 1518 #define FF_QP2LAMBDA 118 ///< factor to convert from H.263 QP to lambda | |
| 1519 #define FF_LAMBDA_MAX (256*128-1) | |
| 1520 | |
| 1521 #define FF_QUALITY_SCALE FF_LAMBDA_SCALE //FIXME maybe remove | |
| 1522 /** | |
| 1523 * global quality for codecs which cannot change it per frame. | |
| 1524 * this should be proportional to MPEG1/2/4 qscale. | |
| 1525 * - encoding: set by user. | |
| 1526 * - decoding: unused | |
| 1527 */ | |
| 1528 int global_quality; | |
| 1529 | |
| 1530 #define FF_CODER_TYPE_VLC 0 | |
| 1531 #define FF_CODER_TYPE_AC 1 | |
| 1532 /** | |
| 1533 * coder type | |
| 1534 * - encoding: set by user. | |
| 1535 * - decoding: unused | |
| 1536 */ | |
| 1537 int coder_type; | |
| 1538 | |
| 1539 /** | |
| 1540 * context model | |
| 1541 * - encoding: set by user. | |
| 1542 * - decoding: unused | |
| 1543 */ | |
| 1544 int context_model; | |
| 1545 #if 0 | |
| 1546 /** | |
| 1547 * | |
| 1548 * - encoding: unused | |
| 1549 * - decoding: set by user. | |
| 1550 */ | |
| 1551 uint8_t * (*realloc)(struct AVCodecContext *s, uint8_t *buf, int buf_size); | |
| 1552 #endif | |
| 1553 | |
| 1554 /** | |
| 1555 * slice flags | |
| 1556 * - encoding: unused | |
| 1557 * - decoding: set by user. | |
| 1558 */ | |
| 1559 int slice_flags; | |
| 1560 #define SLICE_FLAG_CODED_ORDER 0x0001 ///< draw_horiz_band() is called in coded order instead of display | |
| 1561 #define SLICE_FLAG_ALLOW_FIELD 0x0002 ///< allow draw_horiz_band() with field slices (MPEG2 field pics) | |
| 1562 #define SLICE_FLAG_ALLOW_PLANE 0x0004 ///< allow draw_horiz_band() with 1 component at a time (SVQ1) | |
| 1563 | |
| 1564 /** | |
| 1565 * XVideo Motion Acceleration | |
| 1566 * - encoding: forbidden | |
| 1567 * - decoding: set by decoder | |
| 1568 */ | |
| 1569 int xvmc_acceleration; | |
| 1570 | |
| 1571 /** | |
| 1572 * macroblock decision mode | |
| 1573 * - encoding: set by user. | |
| 1574 * - decoding: unused | |
| 1575 */ | |
| 1576 int mb_decision; | |
| 1577 #define FF_MB_DECISION_SIMPLE 0 ///< uses mb_cmp | |
| 1578 #define FF_MB_DECISION_BITS 1 ///< chooses the one which needs the fewest bits | |
| 1579 #define FF_MB_DECISION_RD 2 ///< rate distoration | |
| 1580 | |
| 1581 /** | |
| 1582 * custom intra quantization matrix | |
| 1583 * - encoding: set by user, can be NULL | |
| 1584 * - decoding: set by lavc | |
| 1585 */ | |
| 1586 uint16_t *intra_matrix; | |
| 1587 | |
| 1588 /** | |
| 1589 * custom inter quantization matrix | |
| 1590 * - encoding: set by user, can be NULL | |
| 1591 * - decoding: set by lavc | |
| 1592 */ | |
| 1593 uint16_t *inter_matrix; | |
| 1594 | |
| 1595 /** | |
| 1596 * fourcc from the AVI stream header (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A'). | |
| 1597 * this is used to workaround some encoder bugs | |
| 1598 * - encoding: unused | |
| 1599 * - decoding: set by user, will be converted to upper case by lavc during init | |
| 1600 */ | |
| 1601 unsigned int stream_codec_tag; | |
| 1602 | |
| 1603 /** | |
| 1604 * scene change detection threshold. | |
| 1605 * 0 is default, larger means fewer detected scene changes | |
| 1606 * - encoding: set by user. | |
| 1607 * - decoding: unused | |
| 1608 */ | |
| 1609 int scenechange_threshold; | |
| 1610 | |
| 1611 /** | |
| 1612 * minimum lagrange multipler | |
| 1613 * - encoding: set by user. | |
| 1614 * - decoding: unused | |
| 1615 */ | |
| 1616 int lmin; | |
| 1617 | |
| 1618 /** | |
| 1619 * maximum lagrange multipler | |
| 1620 * - encoding: set by user. | |
| 1621 * - decoding: unused | |
| 1622 */ | |
| 1623 int lmax; | |
| 1624 | |
| 1625 /** | |
| 1626 * Palette control structure | |
| 1627 * - encoding: ??? (no palette-enabled encoder yet) | |
| 1628 * - decoding: set by user. | |
| 1629 */ | |
| 1630 struct AVPaletteControl *palctrl; | |
| 1631 | |
| 1632 /** | |
| 1633 * noise reduction strength | |
| 1634 * - encoding: set by user. | |
| 1635 * - decoding: unused | |
| 1636 */ | |
| 1637 int noise_reduction; | |
| 1638 | |
| 1639 /** | |
| 1640 * called at the beginning of a frame to get cr buffer for it. | |
| 1641 * buffer type (size, hints) must be the same. lavc won't check it. | |
| 1642 * lavc will pass previous buffer in pic, function should return | |
| 1643 * same buffer or new buffer with old frame "painted" into it. | |
| 1644 * if pic.data[0] == NULL must behave like get_buffer(). | |
| 1645 * - encoding: unused | |
| 1646 * - decoding: set by lavc, user can override | |
| 1647 */ | |
| 1648 int (*reget_buffer)(struct AVCodecContext *c, AVFrame *pic); | |
| 1649 | |
| 1650 /** | |
| 1651 * number of bits which should be loaded into the rc buffer before decoding starts | |
| 1652 * - encoding: set by user. | |
| 1653 * - decoding: unused | |
| 1654 */ | |
| 1655 int rc_initial_buffer_occupancy; | |
| 1656 | |
| 1657 /** | |
| 1658 * | |
| 1659 * - encoding: set by user. | |
| 1660 * - decoding: unused | |
| 1661 */ | |
| 1662 int inter_threshold; | |
| 1663 | |
| 1664 /** | |
| 1665 * CODEC_FLAG2_*. | |
| 1666 * - encoding: set by user. | |
| 1667 * - decoding: set by user. | |
| 1668 */ | |
| 1669 int flags2; | |
| 1670 | |
| 1671 /** | |
| 1672 * simulates errors in the bitstream to test error concealment. | |
| 1673 * - encoding: set by user. | |
| 1674 * - decoding: unused. | |
| 1675 */ | |
| 1676 int error_rate; | |
| 1677 | |
| 1678 /** | |
| 1679 * MP3 antialias algorithm, see FF_AA_* below. | |
| 1680 * - encoding: unused | |
| 1681 * - decoding: set by user | |
| 1682 */ | |
| 1683 int antialias_algo; | |
| 1684 #define FF_AA_AUTO 0 | |
| 1685 #define FF_AA_FASTINT 1 //not implemented yet | |
| 1686 #define FF_AA_INT 2 | |
| 1687 #define FF_AA_FLOAT 3 | |
| 1688 /** | |
| 1689 * Quantizer noise shaping. | |
| 1690 * - encoding: set by user | |
| 1691 * - decoding: unused | |
| 1692 */ | |
| 1693 int quantizer_noise_shaping; | |
| 1694 | |
| 1695 /** | |
| 1696 * Thread count. | |
| 1697 * is used to decide how many independant tasks should be passed to execute() | |
| 1698 * - encoding: set by user | |
| 1699 * - decoding: set by user | |
| 1700 */ | |
| 1701 int thread_count; | |
| 1702 | |
| 1703 /** | |
| 1704 * the codec may call this to execute several independant things. it will return only after | |
| 1705 * finishing all tasks, the user may replace this with some multithreaded implementation, the | |
| 1706 * default implementation will execute the parts serially | |
| 1707 * @param count the number of things to execute | |
| 1708 * - encoding: set by lavc, user can override | |
| 1709 * - decoding: set by lavc, user can override | |
| 1710 */ | |
| 1711 int (*execute)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg), void **arg2, int *ret, int count); | |
| 1712 | |
| 1713 /** | |
| 1714 * Thread opaque. | |
| 1715 * can be used by execute() to store some per AVCodecContext stuff. | |
| 1716 * - encoding: set by execute() | |
| 1717 * - decoding: set by execute() | |
| 1718 */ | |
| 1719 void *thread_opaque; | |
| 1720 | |
| 1721 /** | |
| 1722 * Motion estimation threshold. under which no motion estimation is | |
| 1723 * performed, but instead the user specified motion vectors are used | |
| 1724 * | |
| 1725 * - encoding: set by user | |
| 1726 * - decoding: unused | |
| 1727 */ | |
| 1728 int me_threshold; | |
| 1729 | |
| 1730 /** | |
| 1731 * Macroblock threshold. under which the user specified macroblock types will be used | |
| 1732 * - encoding: set by user | |
| 1733 * - decoding: unused | |
| 1734 */ | |
| 1735 int mb_threshold; | |
| 1736 | |
| 1737 /** | |
| 1738 * precision of the intra dc coefficient - 8. | |
| 1739 * - encoding: set by user | |
| 1740 * - decoding: unused | |
| 1741 */ | |
| 1742 int intra_dc_precision; | |
| 1743 | |
| 1744 /** | |
| 1745 * noise vs. sse weight for the nsse comparsion function. | |
| 1746 * - encoding: set by user | |
| 1747 * - decoding: unused | |
| 1748 */ | |
| 1749 int nsse_weight; | |
| 1750 | |
| 1751 /** | |
| 1752 * number of macroblock rows at the top which are skipped. | |
| 1753 * - encoding: unused | |
| 1754 * - decoding: set by user | |
| 1755 */ | |
| 1756 int skip_top; | |
| 1757 | |
| 1758 /** | |
| 1759 * number of macroblock rows at the bottom which are skipped. | |
| 1760 * - encoding: unused | |
| 1761 * - decoding: set by user | |
| 1762 */ | |
| 1763 int skip_bottom; | |
| 1764 | |
| 1765 /** | |
| 1766 * profile | |
| 1767 * - encoding: set by user | |
| 1768 * - decoding: set by lavc | |
| 1769 */ | |
| 1770 int profile; | |
| 1771 #define FF_PROFILE_UNKNOWN -99 | |
| 1772 | |
| 1773 /** | |
| 1774 * level | |
| 1775 * - encoding: set by user | |
| 1776 * - decoding: set by lavc | |
| 1777 */ | |
| 1778 int level; | |
| 1779 #define FF_LEVEL_UNKNOWN -99 | |
| 1780 | |
| 1781 /** | |
| 1782 * low resolution decoding. 1-> 1/2 size, 2->1/4 size | |
| 1783 * - encoding: unused | |
| 1784 * - decoding: set by user | |
| 1785 */ | |
| 1786 int lowres; | |
| 1787 | |
| 1788 /** | |
| 1789 * bitsream width / height. may be different from width/height if lowres | |
| 1790 * or other things are used | |
| 1791 * - encoding: unused | |
| 1792 * - decoding: set by user before init if known, codec should override / dynamically change if needed | |
| 1793 */ | |
| 1794 int coded_width, coded_height; | |
| 1795 | |
| 1796 /** | |
| 1797 * frame skip threshold | |
| 1798 * - encoding: set by user | |
| 1799 * - decoding: unused | |
| 1800 */ | |
| 1801 int frame_skip_threshold; | |
| 1802 | |
| 1803 /** | |
| 1804 * frame skip factor | |
| 1805 * - encoding: set by user | |
| 1806 * - decoding: unused | |
| 1807 */ | |
| 1808 int frame_skip_factor; | |
| 1809 | |
| 1810 /** | |
| 1811 * frame skip exponent | |
| 1812 * - encoding: set by user | |
| 1813 * - decoding: unused | |
| 1814 */ | |
| 1815 int frame_skip_exp; | |
| 1816 | |
| 1817 /** | |
| 1818 * frame skip comparission function | |
| 1819 * - encoding: set by user. | |
| 1820 * - decoding: unused | |
| 1821 */ | |
| 1822 int frame_skip_cmp; | |
| 1823 | |
| 1824 /** | |
| 1825 * border processing masking. raises the quantizer for mbs on the borders | |
| 1826 * of the picture. | |
| 1827 * - encoding: set by user | |
| 1828 * - decoding: unused | |
| 1829 */ | |
| 1830 float border_masking; | |
| 1831 | |
| 1832 /** | |
| 1833 * minimum MB lagrange multipler. | |
| 1834 * - encoding: set by user. | |
| 1835 * - decoding: unused | |
| 1836 */ | |
| 1837 int mb_lmin; | |
| 1838 | |
| 1839 /** | |
| 1840 * maximum MB lagrange multipler. | |
| 1841 * - encoding: set by user. | |
| 1842 * - decoding: unused | |
| 1843 */ | |
| 1844 int mb_lmax; | |
| 1845 | |
| 1846 /** | |
| 1847 * | |
| 1848 * - encoding: set by user. | |
| 1849 * - decoding: unused | |
| 1850 */ | |
| 1851 int me_penalty_compensation; | |
| 1852 | |
| 1853 /** | |
| 1854 * | |
| 1855 * - encoding: unused | |
| 1856 * - decoding: set by user. | |
| 1857 */ | |
| 1858 enum AVDiscard skip_loop_filter; | |
| 1859 | |
| 1860 /** | |
| 1861 * | |
| 1862 * - encoding: unused | |
| 1863 * - decoding: set by user. | |
| 1864 */ | |
| 1865 enum AVDiscard skip_idct; | |
| 1866 | |
| 1867 /** | |
| 1868 * | |
| 1869 * - encoding: unused | |
| 1870 * - decoding: set by user. | |
| 1871 */ | |
| 1872 enum AVDiscard skip_frame; | |
| 1873 | |
| 1874 /** | |
| 1875 * | |
| 1876 * - encoding: set by user. | |
| 1877 * - decoding: unused | |
| 1878 */ | |
| 1879 int bidir_refine; | |
| 1880 | |
| 1881 /** | |
| 1882 * | |
| 1883 * - encoding: set by user. | |
| 1884 * - decoding: unused | |
| 1885 */ | |
| 1886 int brd_scale; | |
| 1887 | |
| 1888 /** | |
| 1889 * constant rate factor - quality-based VBR - values ~correspond to qps | |
| 1890 * - encoding: set by user. | |
| 1891 * - decoding: unused | |
| 1892 */ | |
| 1893 float crf; | |
| 1894 | |
| 1895 /** | |
| 1896 * constant quantization parameter rate control method | |
| 1897 * - encoding: set by user. | |
| 1898 * - decoding: unused | |
| 1899 */ | |
| 1900 int cqp; | |
| 1901 | |
| 1902 /** | |
| 1903 * minimum gop size | |
| 1904 * - encoding: set by user. | |
| 1905 * - decoding: unused | |
| 1906 */ | |
| 1907 int keyint_min; | |
| 1908 | |
| 1909 /** | |
| 1910 * number of reference frames | |
| 1911 * - encoding: set by user. | |
| 1912 * - decoding: unused | |
| 1913 */ | |
| 1914 int refs; | |
| 1915 | |
| 1916 /** | |
| 1917 * chroma qp offset from luma | |
| 1918 * - encoding: set by user. | |
| 1919 * - decoding: unused | |
| 1920 */ | |
| 1921 int chromaoffset; | |
| 1922 | |
| 1923 /** | |
| 1924 * influences how often b-frames are used | |
| 1925 * - encoding: set by user. | |
| 1926 * - decoding: unused | |
| 1927 */ | |
| 1928 int bframebias; | |
| 1929 | |
| 1930 /** | |
| 1931 * trellis RD quantization | |
| 1932 * - encoding: set by user. | |
| 1933 * - decoding: unused | |
| 1934 */ | |
| 1935 int trellis; | |
| 1936 | |
| 1937 /** | |
| 1938 * reduce fluctuations in qp (before curve compression) | |
| 1939 * - encoding: set by user. | |
| 1940 * - decoding: unused | |
| 1941 */ | |
| 1942 float complexityblur; | |
| 1943 | |
| 1944 /** | |
| 1945 * in-loop deblocking filter alphac0 parameter | |
| 1946 * alpha is in the range -6...6 | |
| 1947 * - encoding: set by user. | |
| 1948 * - decoding: unused | |
| 1949 */ | |
| 1950 int deblockalpha; | |
| 1951 | |
| 1952 /** | |
| 1953 * in-loop deblocking filter beta parameter | |
| 1954 * beta is in the range -6...6 | |
| 1955 * - encoding: set by user. | |
| 1956 * - decoding: unused | |
| 1957 */ | |
| 1958 int deblockbeta; | |
| 1959 | |
| 1960 /** | |
| 1961 * macroblock subpartition sizes to consider - p8x8, p4x4, b8x8, i8x8, i4x4 | |
| 1962 * - encoding: set by user. | |
| 1963 * - decoding: unused | |
| 1964 */ | |
| 1965 int partitions; | |
| 1966 #define X264_PART_I4X4 0x001 /* Analyse i4x4 */ | |
| 1967 #define X264_PART_I8X8 0x002 /* Analyse i8x8 (requires 8x8 transform) */ | |
| 1968 #define X264_PART_P8X8 0x010 /* Analyse p16x8, p8x16 and p8x8 */ | |
| 1969 #define X264_PART_P4X4 0x020 /* Analyse p8x4, p4x8, p4x4 */ | |
| 1970 #define X264_PART_B8X8 0x100 /* Analyse b16x8, b8x16 and b8x8 */ | |
| 1971 | |
| 1972 /** | |
| 1973 * direct mv prediction mode - 0 (none), 1 (spatial), 2 (temporal) | |
| 1974 * - encoding: set by user. | |
| 1975 * - decoding: unused | |
| 1976 */ | |
| 1977 int directpred; | |
| 1978 | |
| 1979 /** | |
| 1980 * audio cutoff bandwidth (0 means "automatic") . Currently used only by FAAC | |
| 1981 * - encoding: set by user. | |
| 1982 * - decoding: unused | |
| 1983 */ | |
| 1984 int cutoff; | |
| 1985 | |
| 1986 /** | |
| 1987 * multiplied by qscale for each frame and added to scene_change_score | |
| 1988 * - encoding: set by user. | |
| 1989 * - decoding: unused | |
| 1990 */ | |
| 1991 int scenechange_factor; | |
| 1992 | |
| 1993 /** | |
| 1994 * | |
| 1995 * note: value depends upon the compare functin used for fullpel ME | |
| 1996 * - encoding: set by user. | |
| 1997 * - decoding: unused | |
| 1998 */ | |
| 1999 int mv0_threshold; | |
| 2000 | |
| 2001 /** | |
| 2002 * adjusts sensitivity of b_frame_strategy 1 | |
| 2003 * - encoding: set by user. | |
| 2004 * - decoding: unused | |
| 2005 */ | |
| 2006 int b_sensitivity; | |
| 2007 | |
| 2008 /** | |
| 2009 * - encoding: set by user. | |
| 2010 * - decoding: unused | |
| 2011 */ | |
| 2012 int compression_level; | |
| 2013 #define FF_COMPRESSION_DEFAULT -1 | |
| 2014 | |
| 2015 /** | |
| 2016 * sets whether to use LPC mode - used by FLAC encoder | |
| 2017 * - encoding: set by user. | |
| 2018 * - decoding: unused. | |
| 2019 */ | |
| 2020 int use_lpc; | |
| 2021 | |
| 2022 /** | |
| 2023 * LPC coefficient precision - used by FLAC encoder | |
| 2024 * - encoding: set by user. | |
| 2025 * - decoding: unused. | |
| 2026 */ | |
| 2027 int lpc_coeff_precision; | |
| 2028 | |
| 2029 /** | |
| 2030 * - encoding: set by user. | |
| 2031 * - decoding: unused. | |
| 2032 */ | |
| 2033 int min_prediction_order; | |
| 2034 | |
| 2035 /** | |
| 2036 * - encoding: set by user. | |
| 2037 * - decoding: unused. | |
| 2038 */ | |
| 2039 int max_prediction_order; | |
| 2040 | |
| 2041 /** | |
| 2042 * search method for selecting prediction order | |
| 2043 * - encoding: set by user. | |
| 2044 * - decoding: unused. | |
| 2045 */ | |
| 2046 int prediction_order_method; | |
| 2047 | |
| 2048 /** | |
| 2049 * - encoding: set by user. | |
| 2050 * - decoding: unused. | |
| 2051 */ | |
| 2052 int min_partition_order; | |
| 2053 | |
| 2054 /** | |
| 2055 * - encoding: set by user. | |
| 2056 * - decoding: unused. | |
| 2057 */ | |
| 2058 int max_partition_order; | |
| 2059 } AVCodecContext; | |
| 2060 | |
| 2061 /** | |
| 2062 * AVCodec. | |
| 2063 */ | |
| 2064 typedef struct AVCodec { | |
| 2065 const char *name; | |
| 2066 enum CodecType type; | |
| 2067 enum CodecID id; | |
| 2068 int priv_data_size; | |
| 2069 int (*init)(AVCodecContext *); | |
| 2070 int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data); | |
| 2071 int (*close)(AVCodecContext *); | |
| 2072 int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, | |
| 2073 uint8_t *buf, int buf_size); | |
| 2074 int capabilities; | |
| 2075 #if LIBAVCODEC_VERSION_INT < ((50<<16)+(0<<8)+0) | |
| 2076 void *dummy; // FIXME remove next time we break binary compatibility | |
| 2077 #endif | |
| 2078 struct AVCodec *next; | |
| 2079 void (*flush)(AVCodecContext *); | |
| 2080 const AVRational *supported_framerates; ///array of supported framerates, or NULL if any, array is terminated by {0,0} | |
| 2081 const enum PixelFormat *pix_fmts; ///array of supported pixel formats, or NULL if unknown, array is terminanted by -1 | |
| 2082 } AVCodec; | |
| 2083 | |
| 2084 /** | |
| 2085 * four components are given, that's all. | |
| 2086 * the last component is alpha | |
| 2087 */ | |
| 2088 typedef struct AVPicture { | |
| 2089 uint8_t *data[4]; | |
| 2090 int linesize[4]; ///< number of bytes per line | |
| 2091 } AVPicture; | |
| 2092 | |
| 2093 /** | |
| 2094 * AVPaletteControl | |
| 2095 * This structure defines a method for communicating palette changes | |
| 2096 * between and demuxer and a decoder. | |
| 2097 * this is totally broken, palette changes should be sent as AVPackets | |
| 2098 */ | |
| 2099 #define AVPALETTE_SIZE 1024 | |
| 2100 #define AVPALETTE_COUNT 256 | |
| 2101 typedef struct AVPaletteControl { | |
| 2102 | |
| 2103 /* demuxer sets this to 1 to indicate the palette has changed; | |
| 2104 * decoder resets to 0 */ | |
| 2105 int palette_changed; | |
| 2106 | |
| 2107 /* 4-byte ARGB palette entries, stored in native byte order; note that | |
| 2108 * the individual palette components should be on a 8-bit scale; if | |
| 2109 * the palette data comes from a IBM VGA native format, the component | |
| 2110 * data is probably 6 bits in size and needs to be scaled */ | |
| 2111 unsigned int palette[AVPALETTE_COUNT]; | |
| 2112 | |
| 2113 } AVPaletteControl attribute_deprecated; | |
| 2114 | |
| 2115 typedef struct AVSubtitleRect { | |
| 2116 uint16_t x; | |
| 2117 uint16_t y; | |
| 2118 uint16_t w; | |
| 2119 uint16_t h; | |
| 2120 uint16_t nb_colors; | |
| 2121 int linesize; | |
| 2122 uint32_t *rgba_palette; | |
| 2123 uint8_t *bitmap; | |
| 2124 } AVSubtitleRect; | |
| 2125 | |
| 2126 typedef struct AVSubtitle { | |
| 2127 uint16_t format; /* 0 = graphics */ | |
| 2128 uint32_t start_display_time; /* relative to packet pts, in ms */ | |
| 2129 uint32_t end_display_time; /* relative to packet pts, in ms */ | |
| 2130 uint32_t num_rects; | |
| 2131 AVSubtitleRect *rects; | |
| 2132 } AVSubtitle; | |
| 2133 | |
| 2134 extern AVCodec ac3_encoder; | |
| 2135 extern AVCodec mp2_encoder; | |
| 2136 extern AVCodec mp3lame_encoder; | |
| 2137 extern AVCodec oggvorbis_encoder; | |
| 2138 extern AVCodec faac_encoder; | |
| 2139 extern AVCodec flac_encoder; | |
| 2140 extern AVCodec xvid_encoder; | |
| 2141 extern AVCodec mpeg1video_encoder; | |
| 2142 extern AVCodec mpeg2video_encoder; | |
| 2143 extern AVCodec h261_encoder; | |
| 2144 extern AVCodec h263_encoder; | |
| 2145 extern AVCodec h263p_encoder; | |
| 2146 extern AVCodec flv_encoder; | |
| 2147 extern AVCodec rv10_encoder; | |
| 2148 extern AVCodec rv20_encoder; | |
| 2149 extern AVCodec dvvideo_encoder; | |
| 2150 extern AVCodec mjpeg_encoder; | |
| 2151 extern AVCodec ljpeg_encoder; | |
| 2152 extern AVCodec jpegls_encoder; | |
| 2153 extern AVCodec png_encoder; | |
| 2154 extern AVCodec ppm_encoder; | |
| 2155 extern AVCodec pgm_encoder; | |
| 2156 extern AVCodec pgmyuv_encoder; | |
| 2157 extern AVCodec pbm_encoder; | |
| 2158 extern AVCodec pam_encoder; | |
| 2159 extern AVCodec mpeg4_encoder; | |
| 2160 extern AVCodec msmpeg4v1_encoder; | |
| 2161 extern AVCodec msmpeg4v2_encoder; | |
| 2162 extern AVCodec msmpeg4v3_encoder; | |
| 2163 extern AVCodec wmv1_encoder; | |
| 2164 extern AVCodec wmv2_encoder; | |
| 2165 extern AVCodec huffyuv_encoder; | |
| 2166 extern AVCodec ffvhuff_encoder; | |
| 2167 extern AVCodec h264_encoder; | |
| 2168 extern AVCodec asv1_encoder; | |
| 2169 extern AVCodec asv2_encoder; | |
| 2170 extern AVCodec vcr1_encoder; | |
| 2171 extern AVCodec ffv1_encoder; | |
| 2172 extern AVCodec snow_encoder; | |
| 2173 extern AVCodec vorbis_encoder; | |
| 2174 extern AVCodec mdec_encoder; | |
| 2175 extern AVCodec zlib_encoder; | |
| 2176 extern AVCodec sonic_encoder; | |
| 2177 extern AVCodec sonic_ls_encoder; | |
| 2178 extern AVCodec svq1_encoder; | |
| 2179 extern AVCodec x264_encoder; | |
| 2180 | |
| 2181 extern AVCodec gif_decoder; | |
| 2182 extern AVCodec h263_decoder; | |
| 2183 extern AVCodec h261_decoder; | |
| 2184 extern AVCodec mpeg4_decoder; | |
| 2185 extern AVCodec msmpeg4v1_decoder; | |
| 2186 extern AVCodec msmpeg4v2_decoder; | |
| 2187 extern AVCodec msmpeg4v3_decoder; | |
| 2188 extern AVCodec wmv1_decoder; | |
| 2189 extern AVCodec wmv2_decoder; | |
| 2190 extern AVCodec vc1_decoder; | |
| 2191 extern AVCodec wmv3_decoder; | |
| 2192 extern AVCodec mpeg1video_decoder; | |
| 2193 extern AVCodec mpeg2video_decoder; | |
| 2194 extern AVCodec mpegvideo_decoder; | |
| 2195 extern AVCodec mpeg_xvmc_decoder; | |
| 2196 extern AVCodec h263i_decoder; | |
| 2197 extern AVCodec flv_decoder; | |
| 2198 extern AVCodec rv10_decoder; | |
| 2199 extern AVCodec rv20_decoder; | |
| 2200 extern AVCodec rv30_decoder; | |
| 2201 extern AVCodec rv40_decoder; | |
| 2202 extern AVCodec svq1_decoder; | |
| 2203 extern AVCodec svq3_decoder; | |
| 2204 extern AVCodec dvvideo_decoder; | |
| 2205 extern AVCodec wmav1_decoder; | |
| 2206 extern AVCodec wmav2_decoder; | |
| 2207 extern AVCodec mjpeg_decoder; | |
| 2208 extern AVCodec mjpegb_decoder; | |
| 2209 extern AVCodec sp5x_decoder; | |
| 2210 extern AVCodec png_decoder; | |
| 2211 extern AVCodec mp2_decoder; | |
| 2212 extern AVCodec mp3_decoder; | |
| 2213 extern AVCodec mp3adu_decoder; | |
| 2214 extern AVCodec mp3on4_decoder; | |
| 2215 extern AVCodec qdm2_decoder; | |
| 2216 extern AVCodec cook_decoder; | |
| 2217 extern AVCodec truespeech_decoder; | |
| 2218 extern AVCodec tta_decoder; | |
| 2219 extern AVCodec mace3_decoder; | |
| 2220 extern AVCodec mace6_decoder; | |
| 2221 extern AVCodec huffyuv_decoder; | |
| 2222 extern AVCodec ffvhuff_decoder; | |
| 2223 extern AVCodec oggvorbis_decoder; | |
| 2224 extern AVCodec cyuv_decoder; | |
| 2225 extern AVCodec h264_decoder; | |
| 2226 extern AVCodec indeo3_decoder; | |
| 2227 extern AVCodec vp3_decoder; | |
| 2228 extern AVCodec theora_decoder; | |
| 2229 extern AVCodec vp5_decoder; | |
| 2230 extern AVCodec vp6_decoder; | |
| 2231 extern AVCodec vp6f_decoder; | |
| 2232 extern AVCodec amr_nb_decoder; | |
| 2233 extern AVCodec amr_nb_encoder; | |
| 2234 extern AVCodec amr_wb_encoder; | |
| 2235 extern AVCodec amr_wb_decoder; | |
| 2236 extern AVCodec aac_decoder; | |
| 2237 extern AVCodec mpeg4aac_decoder; | |
| 2238 extern AVCodec asv1_decoder; | |
| 2239 extern AVCodec asv2_decoder; | |
| 2240 extern AVCodec vcr1_decoder; | |
| 2241 extern AVCodec cljr_decoder; | |
| 2242 extern AVCodec ffv1_decoder; | |
| 2243 extern AVCodec snow_decoder; | |
| 2244 extern AVCodec fourxm_decoder; | |
| 2245 extern AVCodec mdec_decoder; | |
| 2246 extern AVCodec roq_decoder; | |
| 2247 extern AVCodec interplay_video_decoder; | |
| 2248 extern AVCodec xan_wc3_decoder; | |
| 2249 extern AVCodec rpza_decoder; | |
| 2250 extern AVCodec cinepak_decoder; | |
| 2251 extern AVCodec msrle_decoder; | |
| 2252 extern AVCodec msvideo1_decoder; | |
| 2253 extern AVCodec vqa_decoder; | |
| 2254 extern AVCodec idcin_decoder; | |
| 2255 extern AVCodec eightbps_decoder; | |
| 2256 extern AVCodec smc_decoder; | |
| 2257 extern AVCodec flic_decoder; | |
| 2258 extern AVCodec vmdvideo_decoder; | |
| 2259 extern AVCodec vmdaudio_decoder; | |
| 2260 extern AVCodec truemotion1_decoder; | |
| 2261 extern AVCodec truemotion2_decoder; | |
| 2262 extern AVCodec mszh_decoder; | |
| 2263 extern AVCodec zlib_decoder; | |
| 2264 extern AVCodec ra_144_decoder; | |
| 2265 extern AVCodec ra_288_decoder; | |
| 2266 extern AVCodec roq_dpcm_decoder; | |
| 2267 extern AVCodec interplay_dpcm_decoder; | |
| 2268 extern AVCodec xan_dpcm_decoder; | |
| 2269 extern AVCodec sol_dpcm_decoder; | |
| 2270 extern AVCodec sonic_decoder; | |
| 2271 extern AVCodec qtrle_decoder; | |
| 2272 extern AVCodec flac_decoder; | |
| 2273 extern AVCodec tscc_decoder; | |
| 2274 extern AVCodec cscd_decoder; | |
| 2275 extern AVCodec nuv_decoder; | |
| 2276 extern AVCodec ulti_decoder; | |
| 2277 extern AVCodec qdraw_decoder; | |
| 2278 extern AVCodec xl_decoder; | |
| 2279 extern AVCodec qpeg_decoder; | |
| 2280 extern AVCodec shorten_decoder; | |
| 2281 extern AVCodec loco_decoder; | |
| 2282 extern AVCodec wnv1_decoder; | |
| 2283 extern AVCodec aasc_decoder; | |
| 2284 extern AVCodec alac_decoder; | |
| 2285 extern AVCodec ws_snd1_decoder; | |
| 2286 extern AVCodec indeo2_decoder; | |
| 2287 extern AVCodec vorbis_decoder; | |
| 2288 extern AVCodec fraps_decoder; | |
| 2289 extern AVCodec libgsm_encoder; | |
| 2290 extern AVCodec libgsm_decoder; | |
| 2291 extern AVCodec bmp_decoder; | |
| 2292 extern AVCodec mmvideo_decoder; | |
| 2293 extern AVCodec zmbv_decoder; | |
| 2294 extern AVCodec avs_decoder; | |
| 2295 extern AVCodec smacker_decoder; | |
| 2296 extern AVCodec smackaud_decoder; | |
| 2297 extern AVCodec kmvc_decoder; | |
| 2298 extern AVCodec flashsv_decoder; | |
| 2299 extern AVCodec cavs_decoder; | |
| 2300 extern AVCodec vmnc_decoder; | |
| 2301 extern AVCodec wavpack_decoder; | |
| 2302 extern AVCodec targa_decoder; | |
| 2303 extern AVCodec dsicinvideo_decoder; | |
| 2304 extern AVCodec dsicinaudio_decoder; | |
| 2305 extern AVCodec tiertexseqvideo_decoder; | |
| 2306 extern AVCodec tiff_decoder; | |
| 2307 | |
| 2308 /* pcm codecs */ | |
| 2309 #define PCM_CODEC(id, name) \ | |
| 2310 extern AVCodec name ## _decoder; \ | |
| 2311 extern AVCodec name ## _encoder | |
| 2312 | |
| 2313 PCM_CODEC(CODEC_ID_PCM_S32LE, pcm_s32le); | |
| 2314 PCM_CODEC(CODEC_ID_PCM_S32BE, pcm_s32be); | |
| 2315 PCM_CODEC(CODEC_ID_PCM_U32LE, pcm_u32le); | |
| 2316 PCM_CODEC(CODEC_ID_PCM_U32BE, pcm_u32be); | |
| 2317 PCM_CODEC(CODEC_ID_PCM_S24LE, pcm_s24le); | |
| 2318 PCM_CODEC(CODEC_ID_PCM_S24BE, pcm_s24be); | |
| 2319 PCM_CODEC(CODEC_ID_PCM_U24LE, pcm_u24le); | |
| 2320 PCM_CODEC(CODEC_ID_PCM_U24BE, pcm_u24be); | |
| 2321 PCM_CODEC(CODEC_ID_PCM_S24DAUD, pcm_s24daud); | |
| 2322 PCM_CODEC(CODEC_ID_PCM_S16LE, pcm_s16le); | |
| 2323 PCM_CODEC(CODEC_ID_PCM_S16BE, pcm_s16be); | |
| 2324 PCM_CODEC(CODEC_ID_PCM_U16LE, pcm_u16le); | |
| 2325 PCM_CODEC(CODEC_ID_PCM_U16BE, pcm_u16be); | |
| 2326 PCM_CODEC(CODEC_ID_PCM_S8, pcm_s8); | |
| 2327 PCM_CODEC(CODEC_ID_PCM_U8, pcm_u8); | |
| 2328 PCM_CODEC(CODEC_ID_PCM_ALAW, pcm_alaw); | |
| 2329 PCM_CODEC(CODEC_ID_PCM_MULAW, pcm_mulaw); | |
| 2330 | |
| 2331 /* adpcm codecs */ | |
| 2332 | |
| 2333 PCM_CODEC(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt); | |
| 2334 PCM_CODEC(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav); | |
| 2335 PCM_CODEC(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3); | |
| 2336 PCM_CODEC(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4); | |
| 2337 PCM_CODEC(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws); | |
| 2338 PCM_CODEC(CODEC_ID_ADPCM_SMJPEG, adpcm_ima_smjpeg); | |
| 2339 PCM_CODEC(CODEC_ID_ADPCM_MS, adpcm_ms); | |
| 2340 PCM_CODEC(CODEC_ID_ADPCM_4XM, adpcm_4xm); | |
| 2341 PCM_CODEC(CODEC_ID_ADPCM_XA, adpcm_xa); | |
| 2342 PCM_CODEC(CODEC_ID_ADPCM_ADX, adpcm_adx); | |
| 2343 PCM_CODEC(CODEC_ID_ADPCM_EA, adpcm_ea); | |
| 2344 PCM_CODEC(CODEC_ID_ADPCM_G726, adpcm_g726); | |
| 2345 PCM_CODEC(CODEC_ID_ADPCM_CT, adpcm_ct); | |
| 2346 PCM_CODEC(CODEC_ID_ADPCM_SWF, adpcm_swf); | |
| 2347 PCM_CODEC(CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha); | |
| 2348 PCM_CODEC(CODEC_ID_ADPCM_SBPRO_4, adpcm_sbpro_4); | |
| 2349 PCM_CODEC(CODEC_ID_ADPCM_SBPRO_3, adpcm_sbpro_3); | |
| 2350 PCM_CODEC(CODEC_ID_ADPCM_SBPRO_2, adpcm_sbpro_2); | |
| 2351 | |
| 2352 #undef PCM_CODEC | |
| 2353 | |
| 2354 /* dummy raw video codec */ | |
| 2355 extern AVCodec rawvideo_encoder; | |
| 2356 extern AVCodec rawvideo_decoder; | |
| 2357 | |
| 2358 /* the following codecs use external GPL libs */ | |
| 2359 extern AVCodec ac3_decoder; | |
| 2360 extern AVCodec dts_decoder; | |
| 2361 | |
| 2362 /* subtitles */ | |
| 2363 extern AVCodec dvdsub_encoder; | |
| 2364 extern AVCodec dvdsub_decoder; | |
| 2365 extern AVCodec dvbsub_encoder; | |
| 2366 extern AVCodec dvbsub_decoder; | |
| 2367 | |
| 2368 /* resample.c */ | |
| 2369 | |
| 2370 struct ReSampleContext; | |
| 2371 struct AVResampleContext; | |
| 2372 | |
| 2373 typedef struct ReSampleContext ReSampleContext; | |
| 2374 | |
| 2375 ReSampleContext *audio_resample_init(int output_channels, int input_channels, | |
| 2376 int output_rate, int input_rate); | |
| 2377 int audio_resample(ReSampleContext *s, short *output, short *input, int nb_samples); | |
| 2378 void audio_resample_close(ReSampleContext *s); | |
| 2379 | |
| 2380 struct AVResampleContext *av_resample_init(int out_rate, int in_rate, int filter_length, int log2_phase_count, int linear, double cutoff); | |
| 2381 int av_resample(struct AVResampleContext *c, short *dst, short *src, int *consumed, int src_size, int dst_size, int update_ctx); | |
| 2382 void av_resample_compensate(struct AVResampleContext *c, int sample_delta, int compensation_distance); | |
| 2383 void av_resample_close(struct AVResampleContext *c); | |
| 2384 | |
| 2385 /* YUV420 format is assumed ! */ | |
| 2386 | |
| 2387 struct ImgReSampleContext; | |
| 2388 | |
| 2389 typedef struct ImgReSampleContext ImgReSampleContext; | |
| 2390 | |
| 2391 ImgReSampleContext *img_resample_init(int output_width, int output_height, | |
| 2392 int input_width, int input_height); | |
| 2393 | |
| 2394 ImgReSampleContext *img_resample_full_init(int owidth, int oheight, | |
| 2395 int iwidth, int iheight, | |
| 2396 int topBand, int bottomBand, | |
| 2397 int leftBand, int rightBand, | |
| 2398 int padtop, int padbottom, | |
| 2399 int padleft, int padright); | |
| 2400 | |
| 2401 | |
| 2402 void img_resample(ImgReSampleContext *s, | |
| 2403 AVPicture *output, const AVPicture *input); | |
| 2404 | |
| 2405 void img_resample_close(ImgReSampleContext *s); | |
| 2406 | |
| 2407 /** | |
| 2408 * Allocate memory for a picture. Call avpicture_free to free it. | |
| 2409 * | |
| 2410 * @param picture the picture to be filled in. | |
| 2411 * @param pix_fmt the format of the picture. | |
| 2412 * @param width the width of the picture. | |
| 2413 * @param height the height of the picture. | |
| 2414 * @return 0 if successful, -1 if not. | |
| 2415 */ | |
| 2416 int avpicture_alloc(AVPicture *picture, int pix_fmt, int width, int height); | |
| 2417 | |
| 2418 /* Free a picture previously allocated by avpicture_alloc. */ | |
| 2419 void avpicture_free(AVPicture *picture); | |
| 2420 | |
| 2421 int avpicture_fill(AVPicture *picture, uint8_t *ptr, | |
| 2422 int pix_fmt, int width, int height); | |
| 2423 int avpicture_layout(const AVPicture* src, int pix_fmt, int width, int height, | |
| 2424 unsigned char *dest, int dest_size); | |
| 2425 int avpicture_get_size(int pix_fmt, int width, int height); | |
| 2426 void avcodec_get_chroma_sub_sample(int pix_fmt, int *h_shift, int *v_shift); | |
| 2427 const char *avcodec_get_pix_fmt_name(int pix_fmt); | |
| 2428 void avcodec_set_dimensions(AVCodecContext *s, int width, int height); | |
| 2429 enum PixelFormat avcodec_get_pix_fmt(const char* name); | |
| 2430 unsigned int avcodec_pix_fmt_to_codec_tag(enum PixelFormat p); | |
| 2431 | |
| 2432 #define FF_LOSS_RESOLUTION 0x0001 /* loss due to resolution change */ | |
| 2433 #define FF_LOSS_DEPTH 0x0002 /* loss due to color depth change */ | |
| 2434 #define FF_LOSS_COLORSPACE 0x0004 /* loss due to color space conversion */ | |
| 2435 #define FF_LOSS_ALPHA 0x0008 /* loss of alpha bits */ | |
| 2436 #define FF_LOSS_COLORQUANT 0x0010 /* loss due to color quantization */ | |
| 2437 #define FF_LOSS_CHROMA 0x0020 /* loss of chroma (e.g. rgb to gray conversion) */ | |
| 2438 | |
| 2439 int avcodec_get_pix_fmt_loss(int dst_pix_fmt, int src_pix_fmt, | |
| 2440 int has_alpha); | |
| 2441 int avcodec_find_best_pix_fmt(int pix_fmt_mask, int src_pix_fmt, | |
| 2442 int has_alpha, int *loss_ptr); | |
| 2443 | |
| 2444 #define FF_ALPHA_TRANSP 0x0001 /* image has some totally transparent pixels */ | |
| 2445 #define FF_ALPHA_SEMI_TRANSP 0x0002 /* image has some transparent pixels */ | |
| 2446 int img_get_alpha_info(const AVPicture *src, | |
| 2447 int pix_fmt, int width, int height); | |
| 2448 | |
| 2449 /* convert among pixel formats */ | |
| 2450 int img_convert(AVPicture *dst, int dst_pix_fmt, | |
| 2451 const AVPicture *src, int pix_fmt, | |
| 2452 int width, int height); | |
| 2453 | |
| 2454 /* deinterlace a picture */ | |
| 2455 int avpicture_deinterlace(AVPicture *dst, const AVPicture *src, | |
| 2456 int pix_fmt, int width, int height); | |
| 2457 | |
| 2458 /* external high level API */ | |
| 2459 | |
| 2460 extern AVCodec *first_avcodec; | |
| 2461 | |
| 2462 /* returns LIBAVCODEC_VERSION_INT constant */ | |
| 2463 unsigned avcodec_version(void); | |
| 2464 /* returns LIBAVCODEC_BUILD constant */ | |
| 2465 unsigned avcodec_build(void); | |
| 2466 void avcodec_init(void); | |
| 2467 | |
| 2468 void register_avcodec(AVCodec *format); | |
| 2469 AVCodec *avcodec_find_encoder(enum CodecID id); | |
| 2470 AVCodec *avcodec_find_encoder_by_name(const char *name); | |
| 2471 AVCodec *avcodec_find_decoder(enum CodecID id); | |
| 2472 AVCodec *avcodec_find_decoder_by_name(const char *name); | |
| 2473 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode); | |
| 2474 | |
| 2475 void avcodec_get_context_defaults(AVCodecContext *s); | |
| 2476 AVCodecContext *avcodec_alloc_context(void); | |
| 2477 void avcodec_get_frame_defaults(AVFrame *pic); | |
| 2478 AVFrame *avcodec_alloc_frame(void); | |
| 2479 | |
| 2480 int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic); | |
| 2481 void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic); | |
| 2482 int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic); | |
| 2483 void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height); | |
| 2484 int avcodec_check_dimensions(void *av_log_ctx, unsigned int w, unsigned int h); | |
| 2485 enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum PixelFormat * fmt); | |
| 2486 | |
| 2487 int avcodec_thread_init(AVCodecContext *s, int thread_count); | |
| 2488 void avcodec_thread_free(AVCodecContext *s); | |
| 2489 int avcodec_thread_execute(AVCodecContext *s, int (*func)(AVCodecContext *c2, void *arg2),void **arg, int *ret, int count); | |
| 2490 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void **arg, int *ret, int count); | |
| 2491 //FIXME func typedef | |
| 2492 | |
| 2493 /** | |
| 2494 * opens / inits the AVCodecContext. | |
| 2495 * not thread save! | |
| 2496 */ | |
| 2497 int avcodec_open(AVCodecContext *avctx, AVCodec *codec); | |
| 2498 | |
| 2499 /** | |
| 2500 * Decode an audio frame. | |
| 2501 * | |
| 2502 * @param avctx the codec context. | |
| 2503 * @param samples output buffer, 16 byte aligned | |
| 2504 * @param frame_size_ptr the output buffer size in bytes, zero if no frame could be compressed | |
| 2505 * @param buf input buffer, 16 byte aligned | |
| 2506 * @param buf_size the input buffer size | |
| 2507 * @return 0 if successful, -1 if not. | |
| 2508 */ | |
| 2509 | |
| 2510 int avcodec_decode_audio(AVCodecContext *avctx, int16_t *samples, | |
| 2511 int *frame_size_ptr, | |
| 2512 uint8_t *buf, int buf_size); | |
| 2513 int avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture, | |
| 2514 int *got_picture_ptr, | |
| 2515 uint8_t *buf, int buf_size); | |
| 2516 int avcodec_decode_subtitle(AVCodecContext *avctx, AVSubtitle *sub, | |
| 2517 int *got_sub_ptr, | |
| 2518 const uint8_t *buf, int buf_size); | |
| 2519 int avcodec_parse_frame(AVCodecContext *avctx, uint8_t **pdata, | |
| 2520 int *data_size_ptr, | |
| 2521 uint8_t *buf, int buf_size); | |
| 2522 int avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size, | |
| 2523 const short *samples); | |
| 2524 int avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size, | |
| 2525 const AVFrame *pict); | |
| 2526 int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size, | |
| 2527 const AVSubtitle *sub); | |
| 2528 | |
| 2529 int avcodec_close(AVCodecContext *avctx); | |
| 2530 | |
| 2531 void avcodec_register_all(void); | |
| 2532 | |
| 2533 void avcodec_flush_buffers(AVCodecContext *avctx); | |
| 2534 | |
| 2535 void avcodec_default_free_buffers(AVCodecContext *s); | |
| 2536 | |
| 2537 /* misc usefull functions */ | |
| 2538 | |
| 2539 /** | |
| 2540 * returns a single letter to describe the picture type | |
| 2541 */ | |
| 2542 char av_get_pict_type_char(int pict_type); | |
| 2543 | |
| 2544 /** | |
| 2545 * returns codec bits per sample | |
| 2546 */ | |
| 2547 int av_get_bits_per_sample(enum CodecID codec_id); | |
| 2548 | |
| 2549 /* frame parsing */ | |
| 2550 typedef struct AVCodecParserContext { | |
| 2551 void *priv_data; | |
| 2552 struct AVCodecParser *parser; | |
| 2553 int64_t frame_offset; /* offset of the current frame */ | |
| 2554 int64_t cur_offset; /* current offset | |
| 2555 (incremented by each av_parser_parse()) */ | |
| 2556 int64_t last_frame_offset; /* offset of the last frame */ | |
| 2557 /* video info */ | |
| 2558 int pict_type; /* XXX: put it back in AVCodecContext */ | |
| 2559 int repeat_pict; /* XXX: put it back in AVCodecContext */ | |
| 2560 int64_t pts; /* pts of the current frame */ | |
| 2561 int64_t dts; /* dts of the current frame */ | |
| 2562 | |
| 2563 /* private data */ | |
| 2564 int64_t last_pts; | |
| 2565 int64_t last_dts; | |
| 2566 int fetch_timestamp; | |
| 2567 | |
| 2568 #define AV_PARSER_PTS_NB 4 | |
| 2569 int cur_frame_start_index; | |
| 2570 int64_t cur_frame_offset[AV_PARSER_PTS_NB]; | |
| 2571 int64_t cur_frame_pts[AV_PARSER_PTS_NB]; | |
| 2572 int64_t cur_frame_dts[AV_PARSER_PTS_NB]; | |
| 2573 | |
| 2574 int flags; | |
| 2575 #define PARSER_FLAG_COMPLETE_FRAMES 0x0001 | |
| 2576 } AVCodecParserContext; | |
| 2577 | |
| 2578 typedef struct AVCodecParser { | |
| 2579 int codec_ids[5]; /* several codec IDs are permitted */ | |
| 2580 int priv_data_size; | |
| 2581 int (*parser_init)(AVCodecParserContext *s); | |
| 2582 int (*parser_parse)(AVCodecParserContext *s, | |
| 2583 AVCodecContext *avctx, | |
| 2584 uint8_t **poutbuf, int *poutbuf_size, | |
| 2585 const uint8_t *buf, int buf_size); | |
| 2586 void (*parser_close)(AVCodecParserContext *s); | |
| 2587 int (*split)(AVCodecContext *avctx, const uint8_t *buf, int buf_size); | |
| 2588 struct AVCodecParser *next; | |
| 2589 } AVCodecParser; | |
| 2590 | |
| 2591 extern AVCodecParser *av_first_parser; | |
| 2592 | |
| 2593 void av_register_codec_parser(AVCodecParser *parser); | |
| 2594 AVCodecParserContext *av_parser_init(int codec_id); | |
| 2595 int av_parser_parse(AVCodecParserContext *s, | |
| 2596 AVCodecContext *avctx, | |
| 2597 uint8_t **poutbuf, int *poutbuf_size, | |
| 2598 const uint8_t *buf, int buf_size, | |
| 2599 int64_t pts, int64_t dts); | |
| 2600 int av_parser_change(AVCodecParserContext *s, | |
| 2601 AVCodecContext *avctx, | |
| 2602 uint8_t **poutbuf, int *poutbuf_size, | |
| 2603 const uint8_t *buf, int buf_size, int keyframe); | |
| 2604 void av_parser_close(AVCodecParserContext *s); | |
| 2605 | |
| 2606 extern AVCodecParser mpegvideo_parser; | |
| 2607 extern AVCodecParser mpeg4video_parser; | |
| 2608 extern AVCodecParser cavsvideo_parser; | |
| 2609 extern AVCodecParser h261_parser; | |
| 2610 extern AVCodecParser h263_parser; | |
| 2611 extern AVCodecParser h264_parser; | |
| 2612 extern AVCodecParser mjpeg_parser; | |
| 2613 extern AVCodecParser pnm_parser; | |
| 2614 extern AVCodecParser mpegaudio_parser; | |
| 2615 extern AVCodecParser ac3_parser; | |
| 2616 extern AVCodecParser dvdsub_parser; | |
| 2617 extern AVCodecParser dvbsub_parser; | |
| 2618 extern AVCodecParser aac_parser; | |
| 2619 | |
| 2620 | |
| 2621 typedef struct AVBitStreamFilterContext { | |
| 2622 void *priv_data; | |
| 2623 struct AVBitStreamFilter *filter; | |
| 2624 AVCodecParserContext *parser; | |
| 2625 struct AVBitStreamFilterContext *next; | |
| 2626 } AVBitStreamFilterContext; | |
| 2627 | |
| 2628 | |
| 2629 typedef struct AVBitStreamFilter { | |
| 2630 const char *name; | |
| 2631 int priv_data_size; | |
| 2632 int (*filter)(AVBitStreamFilterContext *bsfc, | |
| 2633 AVCodecContext *avctx, const char *args, | |
| 2634 uint8_t **poutbuf, int *poutbuf_size, | |
| 2635 const uint8_t *buf, int buf_size, int keyframe); | |
| 2636 struct AVBitStreamFilter *next; | |
| 2637 } AVBitStreamFilter; | |
| 2638 | |
| 2639 extern AVBitStreamFilter *av_first_bitstream_filter; | |
| 2640 | |
| 2641 void av_register_bitstream_filter(AVBitStreamFilter *bsf); | |
| 2642 AVBitStreamFilterContext *av_bitstream_filter_init(const char *name); | |
| 2643 int av_bitstream_filter_filter(AVBitStreamFilterContext *bsfc, | |
| 2644 AVCodecContext *avctx, const char *args, | |
| 2645 uint8_t **poutbuf, int *poutbuf_size, | |
| 2646 const uint8_t *buf, int buf_size, int keyframe); | |
| 2647 void av_bitstream_filter_close(AVBitStreamFilterContext *bsf); | |
| 2648 | |
| 2649 extern AVBitStreamFilter dump_extradata_bsf; | |
| 2650 extern AVBitStreamFilter remove_extradata_bsf; | |
| 2651 extern AVBitStreamFilter noise_bsf; | |
| 2652 | |
| 2653 | |
| 2654 /* memory */ | |
| 2655 void *av_fast_realloc(void *ptr, unsigned int *size, unsigned int min_size); | |
| 2656 /* for static data only */ | |
| 2657 /* call av_free_static to release all staticaly allocated tables */ | |
| 2658 void av_free_static(void); | |
| 2659 void *av_mallocz_static(unsigned int size); | |
| 2660 void *av_realloc_static(void *ptr, unsigned int size); | |
| 2661 | |
| 2662 void img_copy(AVPicture *dst, const AVPicture *src, | |
| 2663 int pix_fmt, int width, int height); | |
| 2664 | |
| 2665 int img_crop(AVPicture *dst, const AVPicture *src, | |
| 2666 int pix_fmt, int top_band, int left_band); | |
| 2667 | |
| 2668 int img_pad(AVPicture *dst, const AVPicture *src, int height, int width, int pix_fmt, | |
| 2669 int padtop, int padbottom, int padleft, int padright, int *color); | |
| 2670 | |
| 2671 /* endian macros */ | |
| 2672 #if !defined(BE_16) || !defined(BE_32) || !defined(LE_16) || !defined(LE_32) | |
| 2673 #define BE_16(x) ((((uint8_t*)(x))[0] << 8) | ((uint8_t*)(x))[1]) | |
| 2674 #define BE_32(x) ((((uint8_t*)(x))[0] << 24) | \ | |
| 2675 (((uint8_t*)(x))[1] << 16) | \ | |
| 2676 (((uint8_t*)(x))[2] << 8) | \ | |
| 2677 ((uint8_t*)(x))[3]) | |
| 2678 #define LE_16(x) ((((uint8_t*)(x))[1] << 8) | ((uint8_t*)(x))[0]) | |
| 2679 #define LE_32(x) ((((uint8_t*)(x))[3] << 24) | \ | |
| 2680 (((uint8_t*)(x))[2] << 16) | \ | |
| 2681 (((uint8_t*)(x))[1] << 8) | \ | |
| 2682 ((uint8_t*)(x))[0]) | |
| 2683 #endif | |
| 2684 | |
| 2685 extern unsigned int av_xiphlacing(unsigned char *s, unsigned int v); | |
| 2686 | |
| 2687 #ifdef __cplusplus | |
| 2688 } | |
| 2689 #endif | |
| 2690 | |
| 2691 #endif /* AVCODEC_H */ |
