From 90a2450fb3429d6977047a6654bc0ddbdbd52f30 Mon Sep 17 00:00:00 2001 From: Colby Klein Date: Wed, 27 Jan 2010 15:14:13 -0800 Subject: [PATCH] Add missing ffmpeg files. --- src/ffmpeg/include/ffmpeg/avcodec.h | 3073 +++++++++++++++++ src/ffmpeg/include/ffmpeg/avformat.h | 888 +++++ src/ffmpeg/include/ffmpeg/avio.h | 272 ++ src/ffmpeg/include/ffmpeg/avutil.h | 137 + src/ffmpeg/include/ffmpeg/common.h | 328 ++ src/ffmpeg/include/ffmpeg/integer.h | 82 + .../include/ffmpeg/intfloat_readwrite.h | 39 + src/ffmpeg/include/ffmpeg/log.h | 116 + src/ffmpeg/include/ffmpeg/mathematics.h | 51 + src/ffmpeg/include/ffmpeg/mem.h | 65 + src/ffmpeg/include/ffmpeg/rational.h | 114 + src/ffmpeg/include/ffmpeg/rtp.h | 127 + src/ffmpeg/include/ffmpeg/rtsp.h | 94 + src/ffmpeg/include/ffmpeg/rtspcodes.h | 36 + src/ffmpeg/lib/avcodec.lib | Bin 0 -> 97486 bytes src/ffmpeg/lib/avformat.lib | Bin 0 -> 36664 bytes src/ffmpeg/lib/avutil.lib | Bin 0 -> 13946 bytes 17 files changed, 5422 insertions(+) create mode 100644 src/ffmpeg/include/ffmpeg/avcodec.h create mode 100644 src/ffmpeg/include/ffmpeg/avformat.h create mode 100644 src/ffmpeg/include/ffmpeg/avio.h create mode 100644 src/ffmpeg/include/ffmpeg/avutil.h create mode 100644 src/ffmpeg/include/ffmpeg/common.h create mode 100644 src/ffmpeg/include/ffmpeg/integer.h create mode 100644 src/ffmpeg/include/ffmpeg/intfloat_readwrite.h create mode 100644 src/ffmpeg/include/ffmpeg/log.h create mode 100644 src/ffmpeg/include/ffmpeg/mathematics.h create mode 100644 src/ffmpeg/include/ffmpeg/mem.h create mode 100644 src/ffmpeg/include/ffmpeg/rational.h create mode 100644 src/ffmpeg/include/ffmpeg/rtp.h create mode 100644 src/ffmpeg/include/ffmpeg/rtsp.h create mode 100644 src/ffmpeg/include/ffmpeg/rtspcodes.h create mode 100644 src/ffmpeg/lib/avcodec.lib create mode 100644 src/ffmpeg/lib/avformat.lib create mode 100644 src/ffmpeg/lib/avutil.lib diff --git a/src/ffmpeg/include/ffmpeg/avcodec.h b/src/ffmpeg/include/ffmpeg/avcodec.h new file mode 100644 index 0000000000..ead4dc8dfe --- /dev/null +++ b/src/ffmpeg/include/ffmpeg/avcodec.h @@ -0,0 +1,3073 @@ +/* + * copyright (c) 2001 Fabrice Bellard + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVCODEC_H +#define AVCODEC_H + +/** + * @file avcodec.h + * external api header. + */ + + +#ifdef __cplusplus +extern "C" { +#endif + +#include "avutil.h" +#include /* size_t */ + +#define AV_STRINGIFY(s) AV_TOSTRING(s) +#define AV_TOSTRING(s) #s + +#define LIBAVCODEC_VERSION_INT ((51<<16)+(40<<8)+0) +#define LIBAVCODEC_VERSION 51.40.0 +#define LIBAVCODEC_BUILD LIBAVCODEC_VERSION_INT + +#define LIBAVCODEC_IDENT "Lavc" AV_STRINGIFY(LIBAVCODEC_VERSION) + +#define AV_NOPTS_VALUE INT64_C(0x8000000000000000) +#define AV_TIME_BASE 1000000 +#define AV_TIME_BASE_Q (AVRational){1, AV_TIME_BASE} + +enum CodecID { + CODEC_ID_NONE, + CODEC_ID_MPEG1VIDEO, + CODEC_ID_MPEG2VIDEO, /* prefered ID for MPEG Video 1 or 2 decoding */ + CODEC_ID_MPEG2VIDEO_XVMC, + CODEC_ID_H261, + CODEC_ID_H263, + CODEC_ID_RV10, + CODEC_ID_RV20, + CODEC_ID_MJPEG, + CODEC_ID_MJPEGB, + CODEC_ID_LJPEG, + CODEC_ID_SP5X, + CODEC_ID_JPEGLS, + CODEC_ID_MPEG4, + CODEC_ID_RAWVIDEO, + CODEC_ID_MSMPEG4V1, + CODEC_ID_MSMPEG4V2, + CODEC_ID_MSMPEG4V3, + CODEC_ID_WMV1, + CODEC_ID_WMV2, + CODEC_ID_H263P, + CODEC_ID_H263I, + CODEC_ID_FLV1, + CODEC_ID_SVQ1, + CODEC_ID_SVQ3, + CODEC_ID_DVVIDEO, + CODEC_ID_HUFFYUV, + CODEC_ID_CYUV, + CODEC_ID_H264, + CODEC_ID_INDEO3, + CODEC_ID_VP3, + CODEC_ID_THEORA, + CODEC_ID_ASV1, + CODEC_ID_ASV2, + CODEC_ID_FFV1, + CODEC_ID_4XM, + CODEC_ID_VCR1, + CODEC_ID_CLJR, + CODEC_ID_MDEC, + CODEC_ID_ROQ, + CODEC_ID_INTERPLAY_VIDEO, + CODEC_ID_XAN_WC3, + CODEC_ID_XAN_WC4, + CODEC_ID_RPZA, + CODEC_ID_CINEPAK, + CODEC_ID_WS_VQA, + CODEC_ID_MSRLE, + CODEC_ID_MSVIDEO1, + CODEC_ID_IDCIN, + CODEC_ID_8BPS, + CODEC_ID_SMC, + CODEC_ID_FLIC, + CODEC_ID_TRUEMOTION1, + CODEC_ID_VMDVIDEO, + CODEC_ID_MSZH, + CODEC_ID_ZLIB, + CODEC_ID_QTRLE, + CODEC_ID_SNOW, + CODEC_ID_TSCC, + CODEC_ID_ULTI, + CODEC_ID_QDRAW, + CODEC_ID_VIXL, + CODEC_ID_QPEG, + CODEC_ID_XVID, + CODEC_ID_PNG, + CODEC_ID_PPM, + CODEC_ID_PBM, + CODEC_ID_PGM, + CODEC_ID_PGMYUV, + CODEC_ID_PAM, + CODEC_ID_FFVHUFF, + CODEC_ID_RV30, + CODEC_ID_RV40, + CODEC_ID_VC1, + CODEC_ID_WMV3, + CODEC_ID_LOCO, + CODEC_ID_WNV1, + CODEC_ID_AASC, + CODEC_ID_INDEO2, + CODEC_ID_FRAPS, + CODEC_ID_TRUEMOTION2, + CODEC_ID_BMP, + CODEC_ID_CSCD, + CODEC_ID_MMVIDEO, + CODEC_ID_ZMBV, + CODEC_ID_AVS, + CODEC_ID_SMACKVIDEO, + CODEC_ID_NUV, + CODEC_ID_KMVC, + CODEC_ID_FLASHSV, + CODEC_ID_CAVS, + CODEC_ID_JPEG2000, + CODEC_ID_VMNC, + CODEC_ID_VP5, + CODEC_ID_VP6, + CODEC_ID_VP6F, + CODEC_ID_TARGA, + CODEC_ID_DSICINVIDEO, + CODEC_ID_TIERTEXSEQVIDEO, + CODEC_ID_TIFF, + CODEC_ID_GIF, + CODEC_ID_FFH264, + CODEC_ID_DXA, + CODEC_ID_DNXHD, + + /* various pcm "codecs" */ + CODEC_ID_PCM_S16LE= 0x10000, + CODEC_ID_PCM_S16BE, + CODEC_ID_PCM_U16LE, + CODEC_ID_PCM_U16BE, + CODEC_ID_PCM_S8, + CODEC_ID_PCM_U8, + CODEC_ID_PCM_MULAW, + CODEC_ID_PCM_ALAW, + CODEC_ID_PCM_S32LE, + CODEC_ID_PCM_S32BE, + CODEC_ID_PCM_U32LE, + CODEC_ID_PCM_U32BE, + CODEC_ID_PCM_S24LE, + CODEC_ID_PCM_S24BE, + CODEC_ID_PCM_U24LE, + CODEC_ID_PCM_U24BE, + CODEC_ID_PCM_S24DAUD, + + /* various adpcm codecs */ + CODEC_ID_ADPCM_IMA_QT= 0x11000, + CODEC_ID_ADPCM_IMA_WAV, + CODEC_ID_ADPCM_IMA_DK3, + CODEC_ID_ADPCM_IMA_DK4, + CODEC_ID_ADPCM_IMA_WS, + CODEC_ID_ADPCM_IMA_SMJPEG, + CODEC_ID_ADPCM_MS, + CODEC_ID_ADPCM_4XM, + CODEC_ID_ADPCM_XA, + CODEC_ID_ADPCM_ADX, + CODEC_ID_ADPCM_EA, + CODEC_ID_ADPCM_G726, + CODEC_ID_ADPCM_CT, + CODEC_ID_ADPCM_SWF, + CODEC_ID_ADPCM_YAMAHA, + CODEC_ID_ADPCM_SBPRO_4, + CODEC_ID_ADPCM_SBPRO_3, + CODEC_ID_ADPCM_SBPRO_2, + + /* AMR */ + CODEC_ID_AMR_NB= 0x12000, + CODEC_ID_AMR_WB, + + /* RealAudio codecs*/ + CODEC_ID_RA_144= 0x13000, + CODEC_ID_RA_288, + + /* various DPCM codecs */ + CODEC_ID_ROQ_DPCM= 0x14000, + CODEC_ID_INTERPLAY_DPCM, + CODEC_ID_XAN_DPCM, + CODEC_ID_SOL_DPCM, + + CODEC_ID_MP2= 0x15000, + CODEC_ID_MP3, /* prefered ID for MPEG Audio layer 1, 2 or3 decoding */ + CODEC_ID_AAC, +#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0) + CODEC_ID_MPEG4AAC, +#endif + CODEC_ID_AC3, + CODEC_ID_DTS, + CODEC_ID_VORBIS, + CODEC_ID_DVAUDIO, + CODEC_ID_WMAV1, + CODEC_ID_WMAV2, + CODEC_ID_MACE3, + CODEC_ID_MACE6, + CODEC_ID_VMDAUDIO, + CODEC_ID_SONIC, + CODEC_ID_SONIC_LS, + CODEC_ID_FLAC, + CODEC_ID_MP3ADU, + CODEC_ID_MP3ON4, + CODEC_ID_SHORTEN, + CODEC_ID_ALAC, + CODEC_ID_WESTWOOD_SND1, + CODEC_ID_GSM, /* As in Berlin toast format */ + CODEC_ID_QDM2, + CODEC_ID_COOK, + CODEC_ID_TRUESPEECH, + CODEC_ID_TTA, + CODEC_ID_SMACKAUDIO, + CODEC_ID_QCELP, + CODEC_ID_WAVPACK, + CODEC_ID_DSICINAUDIO, + CODEC_ID_IMC, + CODEC_ID_MUSEPACK7, + CODEC_ID_MLP, + CODEC_ID_GSM_MS, /* As found in WAV */ + + /* subtitle codecs */ + CODEC_ID_DVD_SUBTITLE= 0x17000, + CODEC_ID_DVB_SUBTITLE, + + CODEC_ID_MPEG2TS= 0x20000, /* _FAKE_ codec to indicate a raw MPEG2 transport + stream (only used by libavformat) */ +}; + +#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0) +/* CODEC_ID_MP3LAME is absolete */ +#define CODEC_ID_MP3LAME CODEC_ID_MP3 +#define CODEC_ID_MPEG4AAC CODEC_ID_AAC +#endif + +enum CodecType { + CODEC_TYPE_UNKNOWN = -1, + CODEC_TYPE_VIDEO, + CODEC_TYPE_AUDIO, + CODEC_TYPE_DATA, + CODEC_TYPE_SUBTITLE, + CODEC_TYPE_NB +}; + +/* currently unused, may be used if 24/32 bits samples ever supported */ +/* all in native endian */ +enum SampleFormat { + SAMPLE_FMT_NONE = -1, + SAMPLE_FMT_U8, ///< unsigned 8 bits + SAMPLE_FMT_S16, ///< signed 16 bits + SAMPLE_FMT_S24, ///< signed 24 bits + SAMPLE_FMT_S32, ///< signed 32 bits + SAMPLE_FMT_FLT, ///< float +}; + +/* in bytes */ +#define AVCODEC_MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32bit audio + +/** + * Required number of additionally allocated bytes at the end of the input bitstream for decoding. + * this is mainly needed because some optimized bitstream readers read + * 32 or 64 bit at once and could read over the end
+ * Note, if the first 23 bits of the additional bytes are not 0 then damaged + * MPEG bitstreams could cause overread and segfault + */ +#define FF_INPUT_BUFFER_PADDING_SIZE 8 + +/** + * minimum encoding buffer size. + * used to avoid some checks during header writing + */ +#define FF_MIN_BUFFER_SIZE 16384 + +/* motion estimation type, EPZS by default */ +enum Motion_Est_ID { + ME_ZERO = 1, + ME_FULL, + ME_LOG, + ME_PHODS, + ME_EPZS, + ME_X1, + ME_HEX, + ME_UMH, + ME_ITER, +}; + +enum AVDiscard{ +//we leave some space between them for extensions (drop some keyframes for intra only or drop just some bidir frames) + AVDISCARD_NONE =-16, ///< discard nothing + AVDISCARD_DEFAULT= 0, ///< discard useless packets like 0 size packets in avi + AVDISCARD_NONREF = 8, ///< discard all non reference + AVDISCARD_BIDIR = 16, ///< discard all bidirectional frames + AVDISCARD_NONKEY = 32, ///< discard all frames except keyframes + AVDISCARD_ALL = 48, ///< discard all +}; + +typedef struct RcOverride{ + int start_frame; + int end_frame; + int qscale; // if this is 0 then quality_factor will be used instead + float quality_factor; +} RcOverride; + +#define FF_MAX_B_FRAMES 16 + +/* encoding support + these flags can be passed in AVCodecContext.flags before initing + Note: not everything is supported yet. +*/ + +#define CODEC_FLAG_QSCALE 0x0002 ///< use fixed qscale +#define CODEC_FLAG_4MV 0x0004 ///< 4 MV per MB allowed / Advanced prediction for H263 +#define CODEC_FLAG_QPEL 0x0010 ///< use qpel MC +#define CODEC_FLAG_GMC 0x0020 ///< use GMC +#define CODEC_FLAG_MV0 0x0040 ///< always try a MB with MV=<0,0> +#define CODEC_FLAG_PART 0x0080 ///< use data partitioning +/* parent program guarantees that the input for b-frame containing streams is not written to + for at least s->max_b_frames+1 frames, if this is not set than the input will be copied */ +#define CODEC_FLAG_INPUT_PRESERVED 0x0100 +#define CODEC_FLAG_PASS1 0x0200 ///< use internal 2pass ratecontrol in first pass mode +#define CODEC_FLAG_PASS2 0x0400 ///< use internal 2pass ratecontrol in second pass mode +#define CODEC_FLAG_EXTERN_HUFF 0x1000 ///< use external huffman table (for mjpeg) +#define CODEC_FLAG_GRAY 0x2000 ///< only decode/encode grayscale +#define CODEC_FLAG_EMU_EDGE 0x4000///< don't draw edges +#define CODEC_FLAG_PSNR 0x8000 ///< error[?] variables will be set during encoding +#define CODEC_FLAG_TRUNCATED 0x00010000 /** input bitstream might be truncated at a random location instead + of only at frame boundaries */ +#define CODEC_FLAG_NORMALIZE_AQP 0x00020000 ///< normalize adaptive quantization +#define CODEC_FLAG_INTERLACED_DCT 0x00040000 ///< use interlaced dct +#define CODEC_FLAG_LOW_DELAY 0x00080000 ///< force low delay +#define CODEC_FLAG_ALT_SCAN 0x00100000 ///< use alternate scan +#define CODEC_FLAG_TRELLIS_QUANT 0x00200000 ///< use trellis quantization +#define CODEC_FLAG_GLOBAL_HEADER 0x00400000 ///< place global headers in extradata instead of every keyframe +#define CODEC_FLAG_BITEXACT 0x00800000 ///< use only bitexact stuff (except (i)dct) +/* Fx : Flag for h263+ extra options */ +#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0) +#define CODEC_FLAG_H263P_AIC 0x01000000 ///< H263 Advanced intra coding / MPEG4 AC prediction (remove this) +#endif +#define CODEC_FLAG_AC_PRED 0x01000000 ///< H263 Advanced intra coding / MPEG4 AC prediction +#define CODEC_FLAG_H263P_UMV 0x02000000 ///< Unlimited motion vector +#define CODEC_FLAG_CBP_RD 0x04000000 ///< use rate distortion optimization for cbp +#define CODEC_FLAG_QP_RD 0x08000000 ///< use rate distortion optimization for qp selectioon +#define CODEC_FLAG_H263P_AIV 0x00000008 ///< H263 Alternative inter vlc +#define CODEC_FLAG_OBMC 0x00000001 ///< OBMC +#define CODEC_FLAG_LOOP_FILTER 0x00000800 ///< loop filter +#define CODEC_FLAG_H263P_SLICE_STRUCT 0x10000000 +#define CODEC_FLAG_INTERLACED_ME 0x20000000 ///< interlaced motion estimation +#define CODEC_FLAG_SVCD_SCAN_OFFSET 0x40000000 ///< will reserve space for SVCD scan offset user data +#define CODEC_FLAG_CLOSED_GOP ((int)0x80000000) +#define CODEC_FLAG2_FAST 0x00000001 ///< allow non spec compliant speedup tricks +#define CODEC_FLAG2_STRICT_GOP 0x00000002 ///< strictly enforce GOP size +#define CODEC_FLAG2_NO_OUTPUT 0x00000004 ///< skip bitstream encoding +#define CODEC_FLAG2_LOCAL_HEADER 0x00000008 ///< place global headers at every keyframe instead of in extradata +#define CODEC_FLAG2_BPYRAMID 0x00000010 ///< H.264 allow b-frames to be used as references +#define CODEC_FLAG2_WPRED 0x00000020 ///< H.264 weighted biprediction for b-frames +#define CODEC_FLAG2_MIXED_REFS 0x00000040 ///< H.264 one reference per partition, as opposed to one reference per macroblock +#define CODEC_FLAG2_8X8DCT 0x00000080 ///< H.264 high profile 8x8 transform +#define CODEC_FLAG2_FASTPSKIP 0x00000100 ///< H.264 fast pskip +#define CODEC_FLAG2_AUD 0x00000200 ///< H.264 access unit delimiters +#define CODEC_FLAG2_BRDO 0x00000400 ///< b-frame rate-distortion optimization +#define CODEC_FLAG2_INTRA_VLC 0x00000800 ///< use MPEG-2 intra VLC table +#define CODEC_FLAG2_MEMC_ONLY 0x00001000 ///< only do ME/MC (I frames -> ref, P frame -> ME+MC) +#define CODEC_FLAG2_DROP_FRAME_TIMECODE 0x00002000 ///< timecode is in drop frame format +#define CODEC_FLAG2_SKIP_RD 0x00004000 ///< RD optimal MB level residual skiping +#define CODEC_FLAG2_CHUNKS 0x00008000 ///< input bitstream might be truncated at a packet boundaries instead of only at frame boundaries +#define CODEC_FLAG2_NON_LINEAR_QUANT 0x00010000 ///< use MPEG-2 non linear quantizer + +/* Unsupported options : + * Syntax Arithmetic coding (SAC) + * Reference Picture Selection + * Independent Segment Decoding */ +/* /Fx */ +/* codec capabilities */ + +#define CODEC_CAP_DRAW_HORIZ_BAND 0x0001 ///< decoder can use draw_horiz_band callback +/** + * Codec uses get_buffer() for allocating buffers. + * direct rendering method 1 + */ +#define CODEC_CAP_DR1 0x0002 +/* if 'parse_only' field is true, then avcodec_parse_frame() can be + used */ +#define CODEC_CAP_PARSE_ONLY 0x0004 +#define CODEC_CAP_TRUNCATED 0x0008 +/* codec can export data for HW decoding (XvMC) */ +#define CODEC_CAP_HWACCEL 0x0010 +/** + * codec has a non zero delay and needs to be feeded with NULL at the end to get the delayed data. + * if this is not set, the codec is guaranteed to never be feeded with NULL data + */ +#define CODEC_CAP_DELAY 0x0020 +/** + * Codec can be fed a final frame with a smaller size. + * This can be used to prevent truncation of the last audio samples. + */ +#define CODEC_CAP_SMALL_LAST_FRAME 0x0040 + +//the following defines may change, don't expect compatibility if you use them +#define MB_TYPE_INTRA4x4 0x0001 +#define MB_TYPE_INTRA16x16 0x0002 //FIXME h264 specific +#define MB_TYPE_INTRA_PCM 0x0004 //FIXME h264 specific +#define MB_TYPE_16x16 0x0008 +#define MB_TYPE_16x8 0x0010 +#define MB_TYPE_8x16 0x0020 +#define MB_TYPE_8x8 0x0040 +#define MB_TYPE_INTERLACED 0x0080 +#define MB_TYPE_DIRECT2 0x0100 //FIXME +#define MB_TYPE_ACPRED 0x0200 +#define MB_TYPE_GMC 0x0400 +#define MB_TYPE_SKIP 0x0800 +#define MB_TYPE_P0L0 0x1000 +#define MB_TYPE_P1L0 0x2000 +#define MB_TYPE_P0L1 0x4000 +#define MB_TYPE_P1L1 0x8000 +#define MB_TYPE_L0 (MB_TYPE_P0L0 | MB_TYPE_P1L0) +#define MB_TYPE_L1 (MB_TYPE_P0L1 | MB_TYPE_P1L1) +#define MB_TYPE_L0L1 (MB_TYPE_L0 | MB_TYPE_L1) +#define MB_TYPE_QUANT 0x00010000 +#define MB_TYPE_CBP 0x00020000 +//Note bits 24-31 are reserved for codec specific use (h264 ref0, mpeg1 0mv, ...) + +/** + * Pan Scan area. + * this specifies the area which should be displayed. Note there may be multiple such areas for one frame + */ +typedef struct AVPanScan{ + /** + * id. + * - encoding: set by user. + * - decoding: set by lavc + */ + int id; + + /** + * width and height in 1/16 pel + * - encoding: set by user. + * - decoding: set by lavc + */ + int width; + int height; + + /** + * position of the top left corner in 1/16 pel for up to 3 fields/frames. + * - encoding: set by user. + * - decoding: set by lavc + */ + int16_t position[3][2]; +}AVPanScan; + +#define FF_COMMON_FRAME \ + /**\ + * pointer to the picture planes.\ + * this might be different from the first allocated byte\ + * - encoding: \ + * - decoding: \ + */\ + uint8_t *data[4];\ + int linesize[4];\ + /**\ + * pointer to the first allocated byte of the picture. can be used in get_buffer/release_buffer\ + * this isn't used by lavc unless the default get/release_buffer() is used\ + * - encoding: \ + * - decoding: \ + */\ + uint8_t *base[4];\ + /**\ + * 1 -> keyframe, 0-> not\ + * - encoding: set by lavc\ + * - decoding: set by lavc\ + */\ + int key_frame;\ +\ + /**\ + * picture type of the frame, see ?_TYPE below.\ + * - encoding: set by lavc for coded_picture (and set by user for input)\ + * - decoding: set by lavc\ + */\ + int pict_type;\ +\ + /**\ + * presentation timestamp in time_base units (time when frame should be shown to user)\ + * if AV_NOPTS_VALUE then frame_rate = 1/time_base will be assumed\ + * - encoding: MUST be set by user\ + * - decoding: set by lavc\ + */\ + int64_t pts;\ +\ + /**\ + * picture number in bitstream order.\ + * - encoding: set by\ + * - decoding: set by lavc\ + */\ + int coded_picture_number;\ + /**\ + * picture number in display order.\ + * - encoding: set by\ + * - decoding: set by lavc\ + */\ + int display_picture_number;\ +\ + /**\ + * quality (between 1 (good) and FF_LAMBDA_MAX (bad)) \ + * - encoding: set by lavc for coded_picture (and set by user for input)\ + * - decoding: set by lavc\ + */\ + int quality; \ +\ + /**\ + * buffer age (1->was last buffer and dint change, 2->..., ...).\ + * set to INT_MAX if the buffer has not been used yet \ + * - encoding: unused\ + * - decoding: MUST be set by get_buffer()\ + */\ + int age;\ +\ + /**\ + * is this picture used as reference\ + * - encoding: unused\ + * - decoding: set by lavc (before get_buffer() call))\ + */\ + int reference;\ +\ + /**\ + * QP table\ + * - encoding: unused\ + * - decoding: set by lavc\ + */\ + int8_t *qscale_table;\ + /**\ + * QP store stride\ + * - encoding: unused\ + * - decoding: set by lavc\ + */\ + int qstride;\ +\ + /**\ + * mbskip_table[mb]>=1 if MB didnt change\ + * stride= mb_width = (width+15)>>4\ + * - encoding: unused\ + * - decoding: set by lavc\ + */\ + uint8_t *mbskip_table;\ +\ + /**\ + * Motion vector table.\ + * @code\ + * example:\ + * int mv_sample_log2= 4 - motion_subsample_log2;\ + * int mb_width= (width+15)>>4;\ + * int mv_stride= (mb_width << mv_sample_log2) + 1;\ + * motion_val[direction][x + y*mv_stride][0->mv_x, 1->mv_y];\ + * @endcode\ + * - encoding: set by user\ + * - decoding: set by lavc\ + */\ + int16_t (*motion_val[2])[2];\ +\ + /**\ + * Macroblock type table\ + * mb_type_base + mb_width + 2\ + * - encoding: set by user\ + * - decoding: set by lavc\ + */\ + uint32_t *mb_type;\ +\ + /**\ + * log2 of the size of the block which a single vector in motion_val represents: \ + * (4->16x16, 3->8x8, 2-> 4x4, 1-> 2x2)\ + * - encoding: unused\ + * - decoding: set by lavc\ + */\ + uint8_t motion_subsample_log2;\ +\ + /**\ + * for some private data of the user\ + * - encoding: unused\ + * - decoding: set by user\ + */\ + void *opaque;\ +\ + /**\ + * error\ + * - encoding: set by lavc if flags&CODEC_FLAG_PSNR\ + * - decoding: unused\ + */\ + uint64_t error[4];\ +\ + /**\ + * type of the buffer (to keep track of who has to dealloc data[*])\ + * - encoding: set by the one who allocs it\ + * - decoding: set by the one who allocs it\ + * Note: user allocated (direct rendering) & internal buffers can not coexist currently\ + */\ + int type;\ + \ + /**\ + * when decoding, this signal how much the picture must be delayed.\ + * extra_delay = repeat_pict / (2*fps)\ + * - encoding: unused\ + * - decoding: set by lavc\ + */\ + int repeat_pict;\ + \ + /**\ + * \ + */\ + int qscale_type;\ + \ + /**\ + * The content of the picture is interlaced.\ + * - encoding: set by user\ + * - decoding: set by lavc (default 0)\ + */\ + int interlaced_frame;\ + \ + /**\ + * if the content is interlaced, is top field displayed first.\ + * - encoding: set by user\ + * - decoding: set by lavc\ + */\ + int top_field_first;\ + \ + /**\ + * Pan scan.\ + * - encoding: set by user\ + * - decoding: set by lavc\ + */\ + AVPanScan *pan_scan;\ + \ + /**\ + * tell user application that palette has changed from previous frame.\ + * - encoding: ??? (no palette-enabled encoder yet)\ + * - decoding: set by lavc (default 0)\ + */\ + int palette_has_changed;\ + \ + /**\ + * Codec suggestion on buffer type if != 0\ + * - encoding: unused\ + * - decoding: set by lavc (before get_buffer() call))\ + */\ + int buffer_hints;\ +\ + /**\ + * DCT coeffitients\ + * - encoding: unused\ + * - decoding: set by lavc\ + */\ + short *dct_coeff;\ +\ + /**\ + * Motion referece frame index\ + * - encoding: set by user\ + * - decoding: set by lavc\ + */\ + int8_t *ref_index[2]; + +#define FF_QSCALE_TYPE_MPEG1 0 +#define FF_QSCALE_TYPE_MPEG2 1 +#define FF_QSCALE_TYPE_H264 2 + +#define FF_BUFFER_TYPE_INTERNAL 1 +#define FF_BUFFER_TYPE_USER 2 ///< Direct rendering buffers (image is (de)allocated by user) +#define FF_BUFFER_TYPE_SHARED 4 ///< buffer from somewhere else, don't dealloc image (data/base), all other tables are not shared +#define FF_BUFFER_TYPE_COPY 8 ///< just a (modified) copy of some other buffer, don't dealloc anything + + +#define FF_I_TYPE 1 // Intra +#define FF_P_TYPE 2 // Predicted +#define FF_B_TYPE 3 // Bi-dir predicted +#define FF_S_TYPE 4 // S(GMC)-VOP MPEG4 +#define FF_SI_TYPE 5 +#define FF_SP_TYPE 6 + +#define FF_BUFFER_HINTS_VALID 0x01 // Buffer hints value is meaningful (if 0 ignore) +#define FF_BUFFER_HINTS_READABLE 0x02 // Codec will read from buffer +#define FF_BUFFER_HINTS_PRESERVE 0x04 // User must not alter buffer content +#define FF_BUFFER_HINTS_REUSABLE 0x08 // Codec will reuse the buffer (update) + +/** + * Audio Video Frame. + */ +typedef struct AVFrame { + FF_COMMON_FRAME +} AVFrame; + +#define DEFAULT_FRAME_RATE_BASE 1001000 + +/** + * main external api structure. + */ +typedef struct AVCodecContext { + /** + * Info on struct for av_log + * - set by avcodec_alloc_context + */ + AVClass *av_class; + /** + * the average bitrate. + * - encoding: set by user. unused for constant quantizer encoding + * - decoding: set by lavc. 0 or some bitrate if this info is available in the stream + */ + int bit_rate; + + /** + * number of bits the bitstream is allowed to diverge from the reference. + * the reference can be CBR (for CBR pass1) or VBR (for pass2) + * - encoding: set by user. unused for constant quantizer encoding + * - decoding: unused + */ + int bit_rate_tolerance; + + /** + * CODEC_FLAG_*. + * - encoding: set by user. + * - decoding: set by user. + */ + int flags; + + /** + * some codecs needs additionnal format info. It is stored here + * - encoding: set by user. + * - decoding: set by lavc. (FIXME is this ok?) + */ + int sub_id; + + /** + * motion estimation algorithm used for video coding. + * 1 (zero), 2 (full), 3 (log), 4 (phods), 5 (epzs), 6 (x1), 7 (hex), + * 8 (umh), 9 (iter) [7, 8 are x264 specific, 9 is snow specific] + * - encoding: MUST be set by user. + * - decoding: unused + */ + int me_method; + + /** + * some codecs need / can use extra-data like huffman tables. + * mjpeg: huffman tables + * rv10: additional flags + * mpeg4: global headers (they can be in the bitstream or here) + * the allocated memory should be FF_INPUT_BUFFER_PADDING_SIZE bytes larger + * then extradata_size to avoid prolems if its read with the bitstream reader + * the bytewise contents of extradata must not depend on the architecture or cpu endianness + * - encoding: set/allocated/freed by lavc. + * - decoding: set/allocated/freed by user. + */ + uint8_t *extradata; + int extradata_size; + + /** + * this is the fundamental unit of time (in seconds) in terms + * of which frame timestamps are represented. for fixed-fps content, + * timebase should be 1/framerate and timestamp increments should be + * identically 1. + * - encoding: MUST be set by user + * - decoding: set by lavc. + */ + AVRational time_base; + + /* video only */ + /** + * picture width / height. + * - encoding: MUST be set by user. + * - decoding: set by lavc. + * Note, for compatibility its possible to set this instead of + * coded_width/height before decoding + */ + int width, height; + +#define FF_ASPECT_EXTENDED 15 + + /** + * the number of pictures in a group of pitures, or 0 for intra_only. + * - encoding: set by user. + * - decoding: unused + */ + int gop_size; + + /** + * pixel format, see PIX_FMT_xxx. + * - encoding: set by user. + * - decoding: set by lavc. + */ + enum PixelFormat pix_fmt; + + /** + * Frame rate emulation. If not zero lower layer (i.e. format handler) + * has to read frames at native frame rate. + * - encoding: set by user. + * - decoding: unused. + */ + int rate_emu; + + /** + * if non NULL, 'draw_horiz_band' is called by the libavcodec + * decoder to draw an horizontal band. It improve cache usage. Not + * all codecs can do that. You must check the codec capabilities + * before + * - encoding: unused + * - decoding: set by user. + * @param height the height of the slice + * @param y the y position of the slice + * @param type 1->top field, 2->bottom field, 3->frame + * @param offset offset into the AVFrame.data from which the slice should be read + */ + void (*draw_horiz_band)(struct AVCodecContext *s, + const AVFrame *src, int offset[4], + int y, int type, int height); + + /* audio only */ + int sample_rate; ///< samples per sec + int channels; + + /** + * audio sample format. + * - encoding: set by user. + * - decoding: set by lavc. + */ + enum SampleFormat sample_fmt; ///< sample format, currenly unused + + /* the following data should not be initialized */ + /** + * samples per packet. initialized when calling 'init' + */ + int frame_size; + int frame_number; ///< audio or video frame number + int real_pict_num; ///< returns the real picture number of previous encoded frame + + /** + * number of frames the decoded output will be delayed relative to + * the encoded input. + * - encoding: set by lavc. + * - decoding: unused + */ + int delay; + + /* - encoding parameters */ + float qcompress; ///< amount of qscale change between easy & hard scenes (0.0-1.0) + float qblur; ///< amount of qscale smoothing over time (0.0-1.0) + + /** + * minimum quantizer. + * - encoding: set by user. + * - decoding: unused + */ + int qmin; + + /** + * maximum quantizer. + * - encoding: set by user. + * - decoding: unused + */ + int qmax; + + /** + * maximum quantizer difference between frames. + * - encoding: set by user. + * - decoding: unused + */ + int max_qdiff; + + /** + * maximum number of b frames between non b frames. + * note: the output will be delayed by max_b_frames+1 relative to the input + * - encoding: set by user. + * - decoding: unused + */ + int max_b_frames; + + /** + * qscale factor between ip and b frames. + * - encoding: set by user. + * - decoding: unused + */ + float b_quant_factor; + + /** obsolete FIXME remove */ + int rc_strategy; +#define FF_RC_STRATEGY_XVID 1 + + int b_frame_strategy; + + /** + * hurry up amount. + * - encoding: unused + * - decoding: set by user. 1-> skip b frames, 2-> skip idct/dequant too, 5-> skip everything except header + * @deprecated Deprecated in favor of skip_idct and skip_frame. + */ + int hurry_up; + + struct AVCodec *codec; + + void *priv_data; + +#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0) + /* unused, FIXME remove*/ + int rtp_mode; +#endif + + int rtp_payload_size; /* The size of the RTP payload: the coder will */ + /* do it's best to deliver a chunk with size */ + /* below rtp_payload_size, the chunk will start */ + /* with a start code on some codecs like H.263 */ + /* This doesn't take account of any particular */ + /* headers inside the transmited RTP payload */ + + + /* The RTP callback: This function is called */ + /* every time the encoder has a packet to send */ + /* Depends on the encoder if the data starts */ + /* with a Start Code (it should) H.263 does. */ + /* mb_nb contains the number of macroblocks */ + /* encoded in the RTP payload */ + void (*rtp_callback)(struct AVCodecContext *avctx, void *data, int size, int mb_nb); + + /* statistics, used for 2-pass encoding */ + int mv_bits; + int header_bits; + int i_tex_bits; + int p_tex_bits; + int i_count; + int p_count; + int skip_count; + int misc_bits; + + /** + * number of bits used for the previously encoded frame. + * - encoding: set by lavc + * - decoding: unused + */ + int frame_bits; + + /** + * private data of the user, can be used to carry app specific stuff. + * - encoding: set by user + * - decoding: set by user + */ + void *opaque; + + char codec_name[32]; + enum CodecType codec_type; /* see CODEC_TYPE_xxx */ + enum CodecID codec_id; /* see CODEC_ID_xxx */ + + /** + * fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A'). + * this is used to workaround some encoder bugs + * - encoding: set by user, if not then the default based on codec_id will be used + * - decoding: set by user, will be converted to upper case by lavc during init + */ + unsigned int codec_tag; + + /** + * workaround bugs in encoders which sometimes cannot be detected automatically. + * - encoding: set by user + * - decoding: set by user + */ + int workaround_bugs; +#define FF_BUG_AUTODETECT 1 ///< autodetection +#define FF_BUG_OLD_MSMPEG4 2 +#define FF_BUG_XVID_ILACE 4 +#define FF_BUG_UMP4 8 +#define FF_BUG_NO_PADDING 16 +#define FF_BUG_AMV 32 +#define FF_BUG_AC_VLC 0 ///< will be removed, libavcodec can now handle these non compliant files by default +#define FF_BUG_QPEL_CHROMA 64 +#define FF_BUG_STD_QPEL 128 +#define FF_BUG_QPEL_CHROMA2 256 +#define FF_BUG_DIRECT_BLOCKSIZE 512 +#define FF_BUG_EDGE 1024 +#define FF_BUG_HPEL_CHROMA 2048 +#define FF_BUG_DC_CLIP 4096 +#define FF_BUG_MS 8192 ///< workaround various bugs in microsofts broken decoders +//#define FF_BUG_FAKE_SCALABILITY 16 //autodetection should work 100% + + /** + * luma single coeff elimination threshold. + * - encoding: set by user + * - decoding: unused + */ + int luma_elim_threshold; + + /** + * chroma single coeff elimination threshold. + * - encoding: set by user + * - decoding: unused + */ + int chroma_elim_threshold; + + /** + * strictly follow the std (MPEG4, ...). + * - encoding: set by user + * - decoding: unused + */ + int strict_std_compliance; +#define FF_COMPLIANCE_VERY_STRICT 2 ///< strictly conform to a older more strict version of the spec or reference software +#define FF_COMPLIANCE_STRICT 1 ///< strictly conform to all the things in the spec no matter what consequences +#define FF_COMPLIANCE_NORMAL 0 +#define FF_COMPLIANCE_INOFFICIAL -1 ///< allow inofficial extensions +#define FF_COMPLIANCE_EXPERIMENTAL -2 ///< allow non standarized experimental things + + /** + * qscale offset between ip and b frames. + * if > 0 then the last p frame quantizer will be used (q= lastp_q*factor+offset) + * if < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset) + * - encoding: set by user. + * - decoding: unused + */ + float b_quant_offset; + + /** + * error resilience higher values will detect more errors but may missdetect + * some more or less valid parts as errors. + * - encoding: unused + * - decoding: set by user + */ + int error_resilience; +#define FF_ER_CAREFUL 1 +#define FF_ER_COMPLIANT 2 +#define FF_ER_AGGRESSIVE 3 +#define FF_ER_VERY_AGGRESSIVE 4 + + /** + * called at the beginning of each frame to get a buffer for it. + * if pic.reference is set then the frame will be read later by lavc + * avcodec_align_dimensions() should be used to find the required width and + * height, as they normally need to be rounded up to the next multiple of 16 + * - encoding: unused + * - decoding: set by lavc, user can override + */ + int (*get_buffer)(struct AVCodecContext *c, AVFrame *pic); + + /** + * called to release buffers which where allocated with get_buffer. + * a released buffer can be reused in get_buffer() + * pic.data[*] must be set to NULL + * - encoding: unused + * - decoding: set by lavc, user can override + */ + void (*release_buffer)(struct AVCodecContext *c, AVFrame *pic); + + /** + * if 1 the stream has a 1 frame delay during decoding. + * - encoding: set by lavc + * - decoding: set by lavc + */ + int has_b_frames; + + /** + * number of bytes per packet if constant and known or 0 + * used by some WAV based audio codecs + */ + int block_align; + + int parse_only; /* - decoding only: if true, only parsing is done + (function avcodec_parse_frame()). The frame + data is returned. Only MPEG codecs support this now. */ + + /** + * 0-> h263 quant 1-> mpeg quant. + * - encoding: set by user. + * - decoding: unused + */ + int mpeg_quant; + + /** + * pass1 encoding statistics output buffer. + * - encoding: set by lavc + * - decoding: unused + */ + char *stats_out; + + /** + * pass2 encoding statistics input buffer. + * concatenated stuff from stats_out of pass1 should be placed here + * - encoding: allocated/set/freed by user + * - decoding: unused + */ + char *stats_in; + + /** + * ratecontrol qmin qmax limiting method. + * 0-> clipping, 1-> use a nice continous function to limit qscale wthin qmin/qmax + * - encoding: set by user. + * - decoding: unused + */ + float rc_qsquish; + + float rc_qmod_amp; + int rc_qmod_freq; + + /** + * ratecontrol override, see RcOverride. + * - encoding: allocated/set/freed by user. + * - decoding: unused + */ + RcOverride *rc_override; + int rc_override_count; + + /** + * rate control equation. + * - encoding: set by user + * - decoding: unused + */ + char *rc_eq; + + /** + * maximum bitrate. + * - encoding: set by user. + * - decoding: unused + */ + int rc_max_rate; + + /** + * minimum bitrate. + * - encoding: set by user. + * - decoding: unused + */ + int rc_min_rate; + + /** + * decoder bitstream buffer size. + * - encoding: set by user. + * - decoding: unused + */ + int rc_buffer_size; + float rc_buffer_aggressivity; + + /** + * qscale factor between p and i frames. + * if > 0 then the last p frame quantizer will be used (q= lastp_q*factor+offset) + * if < 0 then normal ratecontrol will be done (q= -normal_q*factor+offset) + * - encoding: set by user. + * - decoding: unused + */ + float i_quant_factor; + + /** + * qscale offset between p and i frames. + * - encoding: set by user. + * - decoding: unused + */ + float i_quant_offset; + + /** + * initial complexity for pass1 ratecontrol. + * - encoding: set by user. + * - decoding: unused + */ + float rc_initial_cplx; + + /** + * dct algorithm, see FF_DCT_* below. + * - encoding: set by user + * - decoding: unused + */ + int dct_algo; +#define FF_DCT_AUTO 0 +#define FF_DCT_FASTINT 1 +#define FF_DCT_INT 2 +#define FF_DCT_MMX 3 +#define FF_DCT_MLIB 4 +#define FF_DCT_ALTIVEC 5 +#define FF_DCT_FAAN 6 + + /** + * luminance masking (0-> disabled). + * - encoding: set by user + * - decoding: unused + */ + float lumi_masking; + + /** + * temporary complexity masking (0-> disabled). + * - encoding: set by user + * - decoding: unused + */ + float temporal_cplx_masking; + + /** + * spatial complexity masking (0-> disabled). + * - encoding: set by user + * - decoding: unused + */ + float spatial_cplx_masking; + + /** + * p block masking (0-> disabled). + * - encoding: set by user + * - decoding: unused + */ + float p_masking; + + /** + * darkness masking (0-> disabled). + * - encoding: set by user + * - decoding: unused + */ + float dark_masking; + + + /* for binary compatibility */ + int unused; + + /** + * idct algorithm, see FF_IDCT_* below. + * - encoding: set by user + * - decoding: set by user + */ + int idct_algo; +#define FF_IDCT_AUTO 0 +#define FF_IDCT_INT 1 +#define FF_IDCT_SIMPLE 2 +#define FF_IDCT_SIMPLEMMX 3 +#define FF_IDCT_LIBMPEG2MMX 4 +#define FF_IDCT_PS2 5 +#define FF_IDCT_MLIB 6 +#define FF_IDCT_ARM 7 +#define FF_IDCT_ALTIVEC 8 +#define FF_IDCT_SH4 9 +#define FF_IDCT_SIMPLEARM 10 +#define FF_IDCT_H264 11 +#define FF_IDCT_VP3 12 +#define FF_IDCT_IPP 13 +#define FF_IDCT_XVIDMMX 14 +#define FF_IDCT_CAVS 15 +#define FF_IDCT_SIMPLEARMV5TE 16 +#define FF_IDCT_SIMPLEARMV6 17 + + /** + * slice count. + * - encoding: set by lavc + * - decoding: set by user (or 0) + */ + int slice_count; + /** + * slice offsets in the frame in bytes. + * - encoding: set/allocated by lavc + * - decoding: set/allocated by user (or NULL) + */ + int *slice_offset; + + /** + * error concealment flags. + * - encoding: unused + * - decoding: set by user + */ + int error_concealment; +#define FF_EC_GUESS_MVS 1 +#define FF_EC_DEBLOCK 2 + + /** + * dsp_mask could be add used to disable unwanted CPU features + * CPU features (i.e. MMX, SSE. ...) + * + * with FORCE flag you may instead enable given CPU features + * (Dangerous: usable in case of misdetection, improper usage however will + * result into program crash) + */ + unsigned dsp_mask; +#define FF_MM_FORCE 0x80000000 /* force usage of selected flags (OR) */ + /* lower 16 bits - CPU features */ +#ifdef HAVE_MMX +#define FF_MM_MMX 0x0001 /* standard MMX */ +#define FF_MM_3DNOW 0x0004 /* AMD 3DNOW */ +#define FF_MM_MMXEXT 0x0002 /* SSE integer functions or AMD MMX ext */ +#define FF_MM_SSE 0x0008 /* SSE functions */ +#define FF_MM_SSE2 0x0010 /* PIV SSE2 functions */ +#define FF_MM_3DNOWEXT 0x0020 /* AMD 3DNowExt */ +#endif /* HAVE_MMX */ +#ifdef HAVE_IWMMXT +#define FF_MM_IWMMXT 0x0100 /* XScale IWMMXT */ +#endif /* HAVE_IWMMXT */ + + /** + * bits per sample/pixel from the demuxer (needed for huffyuv). + * - encoding: set by lavc + * - decoding: set by user + */ + int bits_per_sample; + + /** + * prediction method (needed for huffyuv). + * - encoding: set by user + * - decoding: unused + */ + int prediction_method; +#define FF_PRED_LEFT 0 +#define FF_PRED_PLANE 1 +#define FF_PRED_MEDIAN 2 + + /** + * sample aspect ratio (0 if unknown). + * numerator and denominator must be relative prime and smaller then 256 for some video standards + * - encoding: set by user. + * - decoding: set by lavc. + */ + AVRational sample_aspect_ratio; + + /** + * the picture in the bitstream. + * - encoding: set by lavc + * - decoding: set by lavc + */ + AVFrame *coded_frame; + + /** + * debug. + * - encoding: set by user. + * - decoding: set by user. + */ + int debug; +#define FF_DEBUG_PICT_INFO 1 +#define FF_DEBUG_RC 2 +#define FF_DEBUG_BITSTREAM 4 +#define FF_DEBUG_MB_TYPE 8 +#define FF_DEBUG_QP 16 +#define FF_DEBUG_MV 32 +#define FF_DEBUG_DCT_COEFF 0x00000040 +#define FF_DEBUG_SKIP 0x00000080 +#define FF_DEBUG_STARTCODE 0x00000100 +#define FF_DEBUG_PTS 0x00000200 +#define FF_DEBUG_ER 0x00000400 +#define FF_DEBUG_MMCO 0x00000800 +#define FF_DEBUG_BUGS 0x00001000 +#define FF_DEBUG_VIS_QP 0x00002000 +#define FF_DEBUG_VIS_MB_TYPE 0x00004000 + + /** + * debug. + * - encoding: set by user. + * - decoding: set by user. + */ + int debug_mv; +#define FF_DEBUG_VIS_MV_P_FOR 0x00000001 //visualize forward predicted MVs of P frames +#define FF_DEBUG_VIS_MV_B_FOR 0x00000002 //visualize forward predicted MVs of B frames +#define FF_DEBUG_VIS_MV_B_BACK 0x00000004 //visualize backward predicted MVs of B frames + + /** + * error. + * - encoding: set by lavc if flags&CODEC_FLAG_PSNR + * - decoding: unused + */ + uint64_t error[4]; + + /** + * minimum MB quantizer. + * - encoding: unused + * - decoding: unused + */ + int mb_qmin; + + /** + * maximum MB quantizer. + * - encoding: unused + * - decoding: unused + */ + int mb_qmax; + + /** + * motion estimation compare function. + * - encoding: set by user. + * - decoding: unused + */ + int me_cmp; + /** + * subpixel motion estimation compare function. + * - encoding: set by user. + * - decoding: unused + */ + int me_sub_cmp; + /** + * macroblock compare function (not supported yet). + * - encoding: set by user. + * - decoding: unused + */ + int mb_cmp; + /** + * interlaced dct compare function + * - encoding: set by user. + * - decoding: unused + */ + int ildct_cmp; +#define FF_CMP_SAD 0 +#define FF_CMP_SSE 1 +#define FF_CMP_SATD 2 +#define FF_CMP_DCT 3 +#define FF_CMP_PSNR 4 +#define FF_CMP_BIT 5 +#define FF_CMP_RD 6 +#define FF_CMP_ZERO 7 +#define FF_CMP_VSAD 8 +#define FF_CMP_VSSE 9 +#define FF_CMP_NSSE 10 +#define FF_CMP_W53 11 +#define FF_CMP_W97 12 +#define FF_CMP_DCTMAX 13 +#define FF_CMP_DCT264 14 +#define FF_CMP_CHROMA 256 + + /** + * ME diamond size & shape. + * - encoding: set by user. + * - decoding: unused + */ + int dia_size; + + /** + * amount of previous MV predictors (2a+1 x 2a+1 square). + * - encoding: set by user. + * - decoding: unused + */ + int last_predictor_count; + + /** + * pre pass for motion estimation. + * - encoding: set by user. + * - decoding: unused + */ + int pre_me; + + /** + * motion estimation pre pass compare function. + * - encoding: set by user. + * - decoding: unused + */ + int me_pre_cmp; + + /** + * ME pre pass diamond size & shape. + * - encoding: set by user. + * - decoding: unused + */ + int pre_dia_size; + + /** + * subpel ME quality. + * - encoding: set by user. + * - decoding: unused + */ + int me_subpel_quality; + + /** + * callback to negotiate the pixelFormat. + * @param fmt is the list of formats which are supported by the codec, + * its terminated by -1 as 0 is a valid format, the formats are ordered by quality + * the first is allways the native one + * @return the choosen format + * - encoding: unused + * - decoding: set by user, if not set then the native format will always be choosen + */ + enum PixelFormat (*get_format)(struct AVCodecContext *s, const enum PixelFormat * fmt); + + /** + * DTG active format information (additionnal aspect ratio + * information only used in DVB MPEG2 transport streams). 0 if + * not set. + * + * - encoding: unused. + * - decoding: set by decoder + */ + int dtg_active_format; +#define FF_DTG_AFD_SAME 8 +#define FF_DTG_AFD_4_3 9 +#define FF_DTG_AFD_16_9 10 +#define FF_DTG_AFD_14_9 11 +#define FF_DTG_AFD_4_3_SP_14_9 13 +#define FF_DTG_AFD_16_9_SP_14_9 14 +#define FF_DTG_AFD_SP_4_3 15 + + /** + * Maximum motion estimation search range in subpel units. + * if 0 then no limit + * + * - encoding: set by user. + * - decoding: unused. + */ + int me_range; + + /** + * intra quantizer bias. + * - encoding: set by user. + * - decoding: unused + */ + int intra_quant_bias; +#define FF_DEFAULT_QUANT_BIAS 999999 + + /** + * inter quantizer bias. + * - encoding: set by user. + * - decoding: unused + */ + int inter_quant_bias; + + /** + * color table ID. + * - encoding: unused. + * - decoding: which clrtable should be used for 8bit RGB images + * table have to be stored somewhere FIXME + */ + int color_table_id; + + /** + * internal_buffer count. + * Don't touch, used by lavc default_get_buffer() + */ + int internal_buffer_count; + + /** + * internal_buffers. + * Don't touch, used by lavc default_get_buffer() + */ + void *internal_buffer; + +#define FF_LAMBDA_SHIFT 7 +#define FF_LAMBDA_SCALE (1< ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A'). + * this is used to workaround some encoder bugs + * - encoding: unused + * - decoding: set by user, will be converted to upper case by lavc during init + */ + unsigned int stream_codec_tag; + + /** + * scene change detection threshold. + * 0 is default, larger means fewer detected scene changes + * - encoding: set by user. + * - decoding: unused + */ + int scenechange_threshold; + + /** + * minimum lagrange multipler + * - encoding: set by user. + * - decoding: unused + */ + int lmin; + + /** + * maximum lagrange multipler + * - encoding: set by user. + * - decoding: unused + */ + int lmax; + + /** + * Palette control structure + * - encoding: ??? (no palette-enabled encoder yet) + * - decoding: set by user. + */ + struct AVPaletteControl *palctrl; + + /** + * noise reduction strength + * - encoding: set by user. + * - decoding: unused + */ + int noise_reduction; + + /** + * called at the beginning of a frame to get cr buffer for it. + * buffer type (size, hints) must be the same. lavc won't check it. + * lavc will pass previous buffer in pic, function should return + * same buffer or new buffer with old frame "painted" into it. + * if pic.data[0] == NULL must behave like get_buffer(). + * - encoding: unused + * - decoding: set by lavc, user can override + */ + int (*reget_buffer)(struct AVCodecContext *c, AVFrame *pic); + + /** + * number of bits which should be loaded into the rc buffer before decoding starts + * - encoding: set by user. + * - decoding: unused + */ + int rc_initial_buffer_occupancy; + + /** + * + * - encoding: set by user. + * - decoding: unused + */ + int inter_threshold; + + /** + * CODEC_FLAG2_*. + * - encoding: set by user. + * - decoding: set by user. + */ + int flags2; + + /** + * simulates errors in the bitstream to test error concealment. + * - encoding: set by user. + * - decoding: unused. + */ + int error_rate; + + /** + * MP3 antialias algorithm, see FF_AA_* below. + * - encoding: unused + * - decoding: set by user + */ + int antialias_algo; +#define FF_AA_AUTO 0 +#define FF_AA_FASTINT 1 //not implemented yet +#define FF_AA_INT 2 +#define FF_AA_FLOAT 3 + /** + * Quantizer noise shaping. + * - encoding: set by user + * - decoding: unused + */ + int quantizer_noise_shaping; + + /** + * Thread count. + * is used to decide how many independent tasks should be passed to execute() + * - encoding: set by user + * - decoding: set by user + */ + int thread_count; + + /** + * the codec may call this to execute several independent things. it will return only after + * finishing all tasks, the user may replace this with some multithreaded implementation, the + * default implementation will execute the parts serially + * @param count the number of things to execute + * - encoding: set by lavc, user can override + * - decoding: set by lavc, user can override + */ + int (*execute)(struct AVCodecContext *c, int (*func)(struct AVCodecContext *c2, void *arg), void **arg2, int *ret, int count); + + /** + * Thread opaque. + * can be used by execute() to store some per AVCodecContext stuff. + * - encoding: set by execute() + * - decoding: set by execute() + */ + void *thread_opaque; + + /** + * Motion estimation threshold. under which no motion estimation is + * performed, but instead the user specified motion vectors are used + * + * - encoding: set by user + * - decoding: unused + */ + int me_threshold; + + /** + * Macroblock threshold. under which the user specified macroblock types will be used + * - encoding: set by user + * - decoding: unused + */ + int mb_threshold; + + /** + * precision of the intra dc coefficient - 8. + * - encoding: set by user + * - decoding: unused + */ + int intra_dc_precision; + + /** + * noise vs. sse weight for the nsse comparsion function. + * - encoding: set by user + * - decoding: unused + */ + int nsse_weight; + + /** + * number of macroblock rows at the top which are skipped. + * - encoding: unused + * - decoding: set by user + */ + int skip_top; + + /** + * number of macroblock rows at the bottom which are skipped. + * - encoding: unused + * - decoding: set by user + */ + int skip_bottom; + + /** + * profile + * - encoding: set by user + * - decoding: set by lavc + */ + int profile; +#define FF_PROFILE_UNKNOWN -99 + + /** + * level + * - encoding: set by user + * - decoding: set by lavc + */ + int level; +#define FF_LEVEL_UNKNOWN -99 + + /** + * low resolution decoding. 1-> 1/2 size, 2->1/4 size + * - encoding: unused + * - decoding: set by user + */ + int lowres; + + /** + * bitsream width / height. may be different from width/height if lowres + * or other things are used + * - encoding: unused + * - decoding: set by user before init if known, codec should override / dynamically change if needed + */ + int coded_width, coded_height; + + /** + * frame skip threshold + * - encoding: set by user + * - decoding: unused + */ + int frame_skip_threshold; + + /** + * frame skip factor + * - encoding: set by user + * - decoding: unused + */ + int frame_skip_factor; + + /** + * frame skip exponent + * - encoding: set by user + * - decoding: unused + */ + int frame_skip_exp; + + /** + * frame skip comparission function + * - encoding: set by user. + * - decoding: unused + */ + int frame_skip_cmp; + + /** + * border processing masking. raises the quantizer for mbs on the borders + * of the picture. + * - encoding: set by user + * - decoding: unused + */ + float border_masking; + + /** + * minimum MB lagrange multipler. + * - encoding: set by user. + * - decoding: unused + */ + int mb_lmin; + + /** + * maximum MB lagrange multipler. + * - encoding: set by user. + * - decoding: unused + */ + int mb_lmax; + + /** + * + * - encoding: set by user. + * - decoding: unused + */ + int me_penalty_compensation; + + /** + * + * - encoding: unused + * - decoding: set by user. + */ + enum AVDiscard skip_loop_filter; + + /** + * + * - encoding: unused + * - decoding: set by user. + */ + enum AVDiscard skip_idct; + + /** + * + * - encoding: unused + * - decoding: set by user. + */ + enum AVDiscard skip_frame; + + /** + * + * - encoding: set by user. + * - decoding: unused + */ + int bidir_refine; + + /** + * + * - encoding: set by user. + * - decoding: unused + */ + int brd_scale; + + /** + * constant rate factor - quality-based VBR - values ~correspond to qps + * - encoding: set by user. + * - decoding: unused + */ + float crf; + + /** + * constant quantization parameter rate control method + * - encoding: set by user. + * - decoding: unused + */ + int cqp; + + /** + * minimum gop size + * - encoding: set by user. + * - decoding: unused + */ + int keyint_min; + + /** + * number of reference frames + * - encoding: set by user. + * - decoding: unused + */ + int refs; + + /** + * chroma qp offset from luma + * - encoding: set by user. + * - decoding: unused + */ + int chromaoffset; + + /** + * influences how often b-frames are used + * - encoding: set by user. + * - decoding: unused + */ + int bframebias; + + /** + * trellis RD quantization + * - encoding: set by user. + * - decoding: unused + */ + int trellis; + + /** + * reduce fluctuations in qp (before curve compression) + * - encoding: set by user. + * - decoding: unused + */ + float complexityblur; + + /** + * in-loop deblocking filter alphac0 parameter + * alpha is in the range -6...6 + * - encoding: set by user. + * - decoding: unused + */ + int deblockalpha; + + /** + * in-loop deblocking filter beta parameter + * beta is in the range -6...6 + * - encoding: set by user. + * - decoding: unused + */ + int deblockbeta; + + /** + * macroblock subpartition sizes to consider - p8x8, p4x4, b8x8, i8x8, i4x4 + * - encoding: set by user. + * - decoding: unused + */ + int partitions; +#define X264_PART_I4X4 0x001 /* Analyse i4x4 */ +#define X264_PART_I8X8 0x002 /* Analyse i8x8 (requires 8x8 transform) */ +#define X264_PART_P8X8 0x010 /* Analyse p16x8, p8x16 and p8x8 */ +#define X264_PART_P4X4 0x020 /* Analyse p8x4, p4x8, p4x4 */ +#define X264_PART_B8X8 0x100 /* Analyse b16x8, b8x16 and b8x8 */ + + /** + * direct mv prediction mode - 0 (none), 1 (spatial), 2 (temporal) + * - encoding: set by user. + * - decoding: unused + */ + int directpred; + + /** + * audio cutoff bandwidth (0 means "automatic") . Currently used only by FAAC + * - encoding: set by user. + * - decoding: unused + */ + int cutoff; + + /** + * multiplied by qscale for each frame and added to scene_change_score + * - encoding: set by user. + * - decoding: unused + */ + int scenechange_factor; + + /** + * + * note: value depends upon the compare functin used for fullpel ME + * - encoding: set by user. + * - decoding: unused + */ + int mv0_threshold; + + /** + * adjusts sensitivity of b_frame_strategy 1 + * - encoding: set by user. + * - decoding: unused + */ + int b_sensitivity; + + /** + * - encoding: set by user. + * - decoding: unused + */ + int compression_level; +#define FF_COMPRESSION_DEFAULT -1 + + /** + * sets whether to use LPC mode - used by FLAC encoder + * - encoding: set by user. + * - decoding: unused. + */ + int use_lpc; + + /** + * LPC coefficient precision - used by FLAC encoder + * - encoding: set by user. + * - decoding: unused. + */ + int lpc_coeff_precision; + + /** + * - encoding: set by user. + * - decoding: unused. + */ + int min_prediction_order; + + /** + * - encoding: set by user. + * - decoding: unused. + */ + int max_prediction_order; + + /** + * search method for selecting prediction order + * - encoding: set by user. + * - decoding: unused. + */ + int prediction_order_method; + + /** + * - encoding: set by user. + * - decoding: unused. + */ + int min_partition_order; + + /** + * - encoding: set by user. + * - decoding: unused. + */ + int max_partition_order; + + /** + * GOP timecode frame start number, in non drop frame format + * - encoding: set by user. + * - decoding: unused. + */ + int64_t timecode_frame_start; +} AVCodecContext; + +/** + * AVCodec. + */ +typedef struct AVCodec { + const char *name; + enum CodecType type; + enum CodecID id; + int priv_data_size; + int (*init)(AVCodecContext *); + int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data); + int (*close)(AVCodecContext *); + int (*decode)(AVCodecContext *, void *outdata, int *outdata_size, + uint8_t *buf, int buf_size); + int capabilities; + struct AVCodec *next; + void (*flush)(AVCodecContext *); + const AVRational *supported_framerates; ///array of supported framerates, or NULL if any, array is terminated by {0,0} + const enum PixelFormat *pix_fmts; ///array of supported pixel formats, or NULL if unknown, array is terminanted by -1 +} AVCodec; + +/** + * four components are given, that's all. + * the last component is alpha + */ +typedef struct AVPicture { + uint8_t *data[4]; + int linesize[4]; ///< number of bytes per line +} AVPicture; + +/** + * AVPaletteControl + * This structure defines a method for communicating palette changes + * between and demuxer and a decoder. + * this is totally broken, palette changes should be sent as AVPackets + */ +#define AVPALETTE_SIZE 1024 +#define AVPALETTE_COUNT 256 +typedef struct AVPaletteControl { + + /* demuxer sets this to 1 to indicate the palette has changed; + * decoder resets to 0 */ + int palette_changed; + + /* 4-byte ARGB palette entries, stored in native byte order; note that + * the individual palette components should be on a 8-bit scale; if + * the palette data comes from a IBM VGA native format, the component + * data is probably 6 bits in size and needs to be scaled */ + unsigned int palette[AVPALETTE_COUNT]; + +} AVPaletteControl attribute_deprecated; + +typedef struct AVSubtitleRect { + uint16_t x; + uint16_t y; + uint16_t w; + uint16_t h; + uint16_t nb_colors; + int linesize; + uint32_t *rgba_palette; + uint8_t *bitmap; +} AVSubtitleRect; + +typedef struct AVSubtitle { + uint16_t format; /* 0 = graphics */ + uint32_t start_display_time; /* relative to packet pts, in ms */ + uint32_t end_display_time; /* relative to packet pts, in ms */ + uint32_t num_rects; + AVSubtitleRect *rects; +} AVSubtitle; + +extern AVCodec ac3_encoder; +extern AVCodec amr_nb_encoder; +extern AVCodec amr_wb_encoder; +extern AVCodec asv1_encoder; +extern AVCodec asv2_encoder; +extern AVCodec bmp_encoder; +extern AVCodec dvvideo_encoder; +extern AVCodec faac_encoder; +extern AVCodec ffv1_encoder; +extern AVCodec ffvhuff_encoder; +extern AVCodec flac_encoder; +extern AVCodec flashsv_encoder; +extern AVCodec flv_encoder; +extern AVCodec gif_encoder; +extern AVCodec h261_encoder; +extern AVCodec h263_encoder; +extern AVCodec h263p_encoder; +extern AVCodec h264_encoder; +extern AVCodec huffyuv_encoder; +extern AVCodec jpegls_encoder; +extern AVCodec libgsm_encoder; +extern AVCodec libgsm_ms_encoder; +extern AVCodec libtheora_encoder; +extern AVCodec ljpeg_encoder; +extern AVCodec mdec_encoder; +extern AVCodec mjpeg_encoder; +extern AVCodec mp2_encoder; +extern AVCodec mp3lame_encoder; +extern AVCodec mpeg1video_encoder; +extern AVCodec mpeg2video_encoder; +extern AVCodec mpeg4_encoder; +extern AVCodec msmpeg4v1_encoder; +extern AVCodec msmpeg4v2_encoder; +extern AVCodec msmpeg4v3_encoder; +extern AVCodec oggvorbis_encoder; +extern AVCodec pam_encoder; +extern AVCodec pbm_encoder; +extern AVCodec pgm_encoder; +extern AVCodec pgmyuv_encoder; +extern AVCodec png_encoder; +extern AVCodec ppm_encoder; +extern AVCodec rv10_encoder; +extern AVCodec rv20_encoder; +extern AVCodec snow_encoder; +extern AVCodec sonic_encoder; +extern AVCodec sonic_ls_encoder; +extern AVCodec svq1_encoder; +extern AVCodec targa_encoder; +extern AVCodec vcr1_encoder; +extern AVCodec vorbis_encoder; +extern AVCodec wmav1_encoder; +extern AVCodec wmav2_encoder; +extern AVCodec wmv1_encoder; +extern AVCodec wmv2_encoder; +extern AVCodec x264_encoder; +extern AVCodec xvid_encoder; +extern AVCodec zlib_encoder; +extern AVCodec zmbv_encoder; + +extern AVCodec aac_decoder; +extern AVCodec aasc_decoder; +extern AVCodec alac_decoder; +extern AVCodec amr_nb_decoder; +extern AVCodec amr_wb_decoder; +extern AVCodec asv1_decoder; +extern AVCodec asv2_decoder; +extern AVCodec avs_decoder; +extern AVCodec bmp_decoder; +extern AVCodec cavs_decoder; +extern AVCodec cinepak_decoder; +extern AVCodec cljr_decoder; +extern AVCodec cook_decoder; +extern AVCodec cscd_decoder; +extern AVCodec cyuv_decoder; +extern AVCodec dca_decoder; +extern AVCodec dnxhd_decoder; +extern AVCodec dsicinaudio_decoder; +extern AVCodec dsicinvideo_decoder; +extern AVCodec dvvideo_decoder; +extern AVCodec dxa_decoder; +extern AVCodec eightbps_decoder; +extern AVCodec ffv1_decoder; +extern AVCodec ffvhuff_decoder; +extern AVCodec flac_decoder; +extern AVCodec flashsv_decoder; +extern AVCodec flic_decoder; +extern AVCodec flv_decoder; +extern AVCodec fourxm_decoder; +extern AVCodec fraps_decoder; +extern AVCodec gif_decoder; +extern AVCodec h261_decoder; +extern AVCodec h263_decoder; +extern AVCodec h263i_decoder; +extern AVCodec h264_decoder; +extern AVCodec huffyuv_decoder; +extern AVCodec idcin_decoder; +extern AVCodec imc_decoder; +extern AVCodec indeo2_decoder; +extern AVCodec indeo3_decoder; +extern AVCodec interplay_dpcm_decoder; +extern AVCodec interplay_video_decoder; +extern AVCodec kmvc_decoder; +extern AVCodec libgsm_decoder; +extern AVCodec libgsm_ms_decoder; +extern AVCodec loco_decoder; +extern AVCodec mace3_decoder; +extern AVCodec mace6_decoder; +extern AVCodec mdec_decoder; +extern AVCodec mjpeg_decoder; +extern AVCodec mjpegb_decoder; +extern AVCodec mmvideo_decoder; +extern AVCodec mp2_decoder; +extern AVCodec mp3_decoder; +extern AVCodec mp3adu_decoder; +extern AVCodec mp3on4_decoder; +extern AVCodec mpc7_decoder; +extern AVCodec mpeg1video_decoder; +extern AVCodec mpeg2video_decoder; +extern AVCodec mpeg4_decoder; +extern AVCodec mpeg4aac_decoder; +extern AVCodec mpeg_xvmc_decoder; +extern AVCodec mpegvideo_decoder; +extern AVCodec msmpeg4v1_decoder; +extern AVCodec msmpeg4v2_decoder; +extern AVCodec msmpeg4v3_decoder; +extern AVCodec msrle_decoder; +extern AVCodec msvideo1_decoder; +extern AVCodec mszh_decoder; +extern AVCodec nuv_decoder; +extern AVCodec oggvorbis_decoder; +extern AVCodec png_decoder; +extern AVCodec qdm2_decoder; +extern AVCodec qdraw_decoder; +extern AVCodec qpeg_decoder; +extern AVCodec qtrle_decoder; +extern AVCodec ra_144_decoder; +extern AVCodec ra_288_decoder; +extern AVCodec roq_decoder; +extern AVCodec roq_dpcm_decoder; +extern AVCodec rpza_decoder; +extern AVCodec rv10_decoder; +extern AVCodec rv20_decoder; +extern AVCodec rv30_decoder; +extern AVCodec rv40_decoder; +extern AVCodec shorten_decoder; +extern AVCodec smackaud_decoder; +extern AVCodec smacker_decoder; +extern AVCodec smc_decoder; +extern AVCodec snow_decoder; +extern AVCodec sol_dpcm_decoder; +extern AVCodec sonic_decoder; +extern AVCodec sp5x_decoder; +extern AVCodec svq1_decoder; +extern AVCodec svq3_decoder; +extern AVCodec targa_decoder; +extern AVCodec theora_decoder; +extern AVCodec tiertexseqvideo_decoder; +extern AVCodec tiff_decoder; +extern AVCodec truemotion1_decoder; +extern AVCodec truemotion2_decoder; +extern AVCodec truespeech_decoder; +extern AVCodec tscc_decoder; +extern AVCodec tta_decoder; +extern AVCodec ulti_decoder; +extern AVCodec vc1_decoder; +extern AVCodec vcr1_decoder; +extern AVCodec vmdaudio_decoder; +extern AVCodec vmdvideo_decoder; +extern AVCodec vmnc_decoder; +extern AVCodec vorbis_decoder; +extern AVCodec vp3_decoder; +extern AVCodec vp5_decoder; +extern AVCodec vp6_decoder; +extern AVCodec vp6f_decoder; +extern AVCodec vqa_decoder; +extern AVCodec wavpack_decoder; +extern AVCodec wmav1_decoder; +extern AVCodec wmav2_decoder; +extern AVCodec wmv1_decoder; +extern AVCodec wmv2_decoder; +extern AVCodec wmv3_decoder; +extern AVCodec wnv1_decoder; +extern AVCodec ws_snd1_decoder; +extern AVCodec xan_dpcm_decoder; +extern AVCodec xan_wc3_decoder; +extern AVCodec xl_decoder; +extern AVCodec zlib_decoder; +extern AVCodec zmbv_decoder; + +/* pcm codecs */ +#define PCM_CODEC(id, name) \ +extern AVCodec name ## _decoder; \ +extern AVCodec name ## _encoder + +PCM_CODEC(CODEC_ID_PCM_ALAW, pcm_alaw); +PCM_CODEC(CODEC_ID_PCM_MULAW, pcm_mulaw); +PCM_CODEC(CODEC_ID_PCM_S8, pcm_s8); +PCM_CODEC(CODEC_ID_PCM_S16BE, pcm_s16be); +PCM_CODEC(CODEC_ID_PCM_S16LE, pcm_s16le); +PCM_CODEC(CODEC_ID_PCM_S24BE, pcm_s24be); +PCM_CODEC(CODEC_ID_PCM_S24DAUD, pcm_s24daud); +PCM_CODEC(CODEC_ID_PCM_S24LE, pcm_s24le); +PCM_CODEC(CODEC_ID_PCM_S32BE, pcm_s32be); +PCM_CODEC(CODEC_ID_PCM_S32LE, pcm_s32le); +PCM_CODEC(CODEC_ID_PCM_U8, pcm_u8); +PCM_CODEC(CODEC_ID_PCM_U16BE, pcm_u16be); +PCM_CODEC(CODEC_ID_PCM_U16LE, pcm_u16le); +PCM_CODEC(CODEC_ID_PCM_U24BE, pcm_u24be); +PCM_CODEC(CODEC_ID_PCM_U24LE, pcm_u24le); +PCM_CODEC(CODEC_ID_PCM_U32BE, pcm_u32be); +PCM_CODEC(CODEC_ID_PCM_U32LE, pcm_u32le); + +/* adpcm codecs */ + +PCM_CODEC(CODEC_ID_ADPCM_4XM, adpcm_4xm); +PCM_CODEC(CODEC_ID_ADPCM_ADX, adpcm_adx); +PCM_CODEC(CODEC_ID_ADPCM_CT, adpcm_ct); +PCM_CODEC(CODEC_ID_ADPCM_EA, adpcm_ea); +PCM_CODEC(CODEC_ID_ADPCM_G726, adpcm_g726); +PCM_CODEC(CODEC_ID_ADPCM_IMA_DK3, adpcm_ima_dk3); +PCM_CODEC(CODEC_ID_ADPCM_IMA_DK4, adpcm_ima_dk4); +PCM_CODEC(CODEC_ID_ADPCM_IMA_QT, adpcm_ima_qt); +PCM_CODEC(CODEC_ID_ADPCM_IMA_WAV, adpcm_ima_wav); +PCM_CODEC(CODEC_ID_ADPCM_IMA_WS, adpcm_ima_ws); +PCM_CODEC(CODEC_ID_ADPCM_MS, adpcm_ms); +PCM_CODEC(CODEC_ID_ADPCM_SBPRO_2, adpcm_sbpro_2); +PCM_CODEC(CODEC_ID_ADPCM_SBPRO_3, adpcm_sbpro_3); +PCM_CODEC(CODEC_ID_ADPCM_SBPRO_4, adpcm_sbpro_4); +PCM_CODEC(CODEC_ID_ADPCM_SMJPEG, adpcm_ima_smjpeg); +PCM_CODEC(CODEC_ID_ADPCM_SWF, adpcm_swf); +PCM_CODEC(CODEC_ID_ADPCM_XA, adpcm_xa); +PCM_CODEC(CODEC_ID_ADPCM_YAMAHA, adpcm_yamaha); + +#undef PCM_CODEC + +/* dummy raw video codec */ +extern AVCodec rawvideo_decoder; +extern AVCodec rawvideo_encoder; + +/* the following codecs use external GPL libs */ +extern AVCodec dts_decoder; +extern AVCodec liba52_decoder; + +/* subtitles */ +extern AVCodec dvbsub_decoder; +extern AVCodec dvbsub_encoder; +extern AVCodec dvdsub_decoder; +extern AVCodec dvdsub_encoder; + +/* resample.c */ + +struct ReSampleContext; +struct AVResampleContext; + +typedef struct ReSampleContext ReSampleContext; + +ReSampleContext *audio_resample_init(int output_channels, int input_channels, + int output_rate, int input_rate); +int audio_resample(ReSampleContext *s, short *output, short *input, int nb_samples); +void audio_resample_close(ReSampleContext *s); + +struct AVResampleContext *av_resample_init(int out_rate, int in_rate, int filter_length, int log2_phase_count, int linear, double cutoff); +int av_resample(struct AVResampleContext *c, short *dst, short *src, int *consumed, int src_size, int dst_size, int update_ctx); +void av_resample_compensate(struct AVResampleContext *c, int sample_delta, int compensation_distance); +void av_resample_close(struct AVResampleContext *c); + +#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0) +/* YUV420 format is assumed ! */ + +struct ImgReSampleContext attribute_deprecated; + +typedef struct ImgReSampleContext ImgReSampleContext attribute_deprecated; + +attribute_deprecated ImgReSampleContext *img_resample_init(int output_width, int output_height, + int input_width, int input_height); + +attribute_deprecated ImgReSampleContext *img_resample_full_init(int owidth, int oheight, + int iwidth, int iheight, + int topBand, int bottomBand, + int leftBand, int rightBand, + int padtop, int padbottom, + int padleft, int padright); + + +attribute_deprecated void img_resample(ImgReSampleContext *s, + AVPicture *output, const AVPicture *input); + +attribute_deprecated void img_resample_close(ImgReSampleContext *s); + +#endif + +/** + * Allocate memory for a picture. Call avpicture_free to free it. + * + * @param picture the picture to be filled in. + * @param pix_fmt the format of the picture. + * @param width the width of the picture. + * @param height the height of the picture. + * @return Zero if successful, a negative value if not. + */ +int avpicture_alloc(AVPicture *picture, int pix_fmt, int width, int height); + +/** + * Free a picture previously allocated by avpicture_alloc(). + * + * @param picture The AVPicture to be freed. + */ +void avpicture_free(AVPicture *picture); + +/** + * Fill in AVPicture's fields. + * The fields of the given AVPicture are filled in by using the 'ptr' address + * which points to the image data buffer. Depending on the specified picture + * format, one or multiple image data pointers and line sizes will be set. + * If a planar format is specified, several pointers will be set pointing to + * the different picture planes and the line sizes of the different planes + * will be stored in the lines_sizes array. + * + * @param picture AVPicture who's fields are to be filled in + * @param ptr Buffer which will contain or contains the actual image data + * @param pix_fmt The format in which the picture data is stored + * @param width The width of the image in pixels + * @param height The height of the image in pixels + * @return Size of the image data in bytes. + */ +int avpicture_fill(AVPicture *picture, uint8_t *ptr, + int pix_fmt, int width, int height); +int avpicture_layout(const AVPicture* src, int pix_fmt, int width, int height, + unsigned char *dest, int dest_size); + +/** + * Calculate the size in bytes that a picture of the given width and height + * would occupy if stored in the given picture format. + * + * @param pix_fmt The given picture format + * @param width The width of the image + * @param height The height of the image + * @return Image data size in bytes + */ +int avpicture_get_size(int pix_fmt, int width, int height); +void avcodec_get_chroma_sub_sample(int pix_fmt, int *h_shift, int *v_shift); +const char *avcodec_get_pix_fmt_name(int pix_fmt); +void avcodec_set_dimensions(AVCodecContext *s, int width, int height); +enum PixelFormat avcodec_get_pix_fmt(const char* name); +unsigned int avcodec_pix_fmt_to_codec_tag(enum PixelFormat p); + +#define FF_LOSS_RESOLUTION 0x0001 /**< loss due to resolution change */ +#define FF_LOSS_DEPTH 0x0002 /**< loss due to color depth change */ +#define FF_LOSS_COLORSPACE 0x0004 /**< loss due to color space conversion */ +#define FF_LOSS_ALPHA 0x0008 /**< loss of alpha bits */ +#define FF_LOSS_COLORQUANT 0x0010 /**< loss due to color quantization */ +#define FF_LOSS_CHROMA 0x0020 /**< loss of chroma (e.g. RGB to gray conversion) */ + +/** + * Computes what kind of losses will occur when converting from one specific + * pixel format to another. + * When converting from one pixel format to another, information loss may occur. + * For example, when converting from RGB24 to GRAY, the color information will + * be lost. Similarly, other losses occur when converting from some formats to + * other formats. These losses can involve loss of chroma, but also loss of + * resolution, loss of color depth, loss due to the color space conversion, loss + * of the alpha bits or loss due to color quantization. + * avcodec_get_fix_fmt_loss() informs you on the various types of losses which + * will occur when converting from one pixel format to another. + * + * @param[in] dst_pix_fmt Destination pixel format. + * @param[in] src_pix_fmt Source pixel format. + * @param[in] has_alpha Whether the source pixel format alpha channel is used. + * @return Combination of flags informing you what kind of losses will occur. + */ +int avcodec_get_pix_fmt_loss(int dst_pix_fmt, int src_pix_fmt, + int has_alpha); + +/** + * Finds the best pixel format to convert to given a certain source pixel + * format. When converting from one pixel format to another, information loss + * may occur. For example, when converting from RGB24 to GRAY, the color + * information will be lost. Similarly, other losses occur when converting from + * some formats to other formats. avcodec_find_best_pix_fmt() searches which of + * the given pixel formats should be used to undergo the least amount of losses. + * The pixel formats from which it choses one, are determined by the + * \p pix_fmt_mask parameter. + * + * @code + * src_pix_fmt = PIX_FMT_YUV420P; + * pix_fmt_mask = (1 << PIX_FMT_YUV422P) || (1 << PIX_FMT_RGB24); + * dst_pix_fmt = avcodec_find_best_pix_fmt(pix_fmt_mask, src_pix_fmt, alpha, &loss); + * @endcode + * + * @param[in] pix_fmt_mask Bitmask determining which pixel format to choose from. + * @param[in] src_pix_fmt Source pixel format. + * @param[in] has_alpha Whether the source pixel format alpha channel is used. + * @param[out] loss_ptr Combination of flags informing you what kind of losses will occur. + * @return The best pixel format to convert to or -1 if none was found. + */ +int avcodec_find_best_pix_fmt(int pix_fmt_mask, int src_pix_fmt, + int has_alpha, int *loss_ptr); + +#define FF_ALPHA_TRANSP 0x0001 /* image has some totally transparent pixels */ +#define FF_ALPHA_SEMI_TRANSP 0x0002 /* image has some transparent pixels */ + +/** + * Tell if an image really has transparent alpha values. + * @return ored mask of FF_ALPHA_xxx constants + */ +int img_get_alpha_info(const AVPicture *src, + int pix_fmt, int width, int height); + +#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0) +/* convert among pixel formats */ +attribute_deprecated int img_convert(AVPicture *dst, int dst_pix_fmt, + const AVPicture *src, int pix_fmt, + int width, int height); +#endif + +/* deinterlace a picture */ +/* deinterlace - if not supported return -1 */ +int avpicture_deinterlace(AVPicture *dst, const AVPicture *src, + int pix_fmt, int width, int height); + +/* external high level API */ + +extern AVCodec *first_avcodec; + +/* returns LIBAVCODEC_VERSION_INT constant */ +unsigned avcodec_version(void); +/* returns LIBAVCODEC_BUILD constant */ +unsigned avcodec_build(void); + +/** + * Initializes libavcodec. + * + * @warning This function \e must be called before any other libavcodec + * function. + */ +void avcodec_init(void); + +void register_avcodec(AVCodec *format); + +/** + * Finds an encoder with a matching codec ID. + * + * @param id CodecID of the requested encoder. + * @return An encoder if one was found, NULL otherwise. + */ +AVCodec *avcodec_find_encoder(enum CodecID id); + +/** + * Finds an encoder with the specified name. + * + * @param name Name of the requested encoder. + * @return An encoder if one was found, NULL otherwise. + */ +AVCodec *avcodec_find_encoder_by_name(const char *name); + +/** + * Finds a decoder with a matching codec ID. + * + * @param id CodecID of the requested decoder. + * @return A decoder if one was found, NULL otherwise. + */ +AVCodec *avcodec_find_decoder(enum CodecID id); + +/** + * Finds an decoder with the specified name. + * + * @param name Name of the requested decoder. + * @return A decoder if one was found, NULL otherwise. + */ +AVCodec *avcodec_find_decoder_by_name(const char *name); +void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode); + +/** + * Sets the fields of the given AVCodecContext to default values. + * + * @param s The AVCodecContext of which the fields should be set to default values. + */ +void avcodec_get_context_defaults(AVCodecContext *s); + +/** THIS FUNCTION IS NOT YET PART OF THE PUBLIC API! + * we WILL change its arguments and name a few times! */ +void avcodec_get_context_defaults2(AVCodecContext *s, enum CodecType); + +/** + * Allocates an AVCodecContext and sets its fields to default values. The + * resulting struct can be deallocated by simply calling av_free(). + * + * @return An AVCodecContext filled with default values or NULL on failure. + * @see avcodec_get_context_defaults + */ +AVCodecContext *avcodec_alloc_context(void); + +/** THIS FUNCTION IS NOT YET PART OF THE PUBLIC API! + * we WILL change its arguments and name a few times! */ +AVCodecContext *avcodec_alloc_context2(enum CodecType); + +/** + * Sets the fields of the given AVFrame to default values. + * + * @param pic The AVFrame of which the fields should be set to default values. + */ +void avcodec_get_frame_defaults(AVFrame *pic); + +/** + * Allocates an AVFrame and sets its fields to default values. The resulting + * struct can be deallocated by simply calling av_free(). + * + * @return An AVFrame filled with default values or NULL on failure. + * @see avcodec_get_frame_defaults + */ +AVFrame *avcodec_alloc_frame(void); + +int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic); +void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic); +int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic); +void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height); + +/** + * Checks if the given dimension of a picture is valid, meaning that all + * bytes of the picture can be addressed with a signed int. + * + * @param[in] w Width of the picture. + * @param[in] h Height of the picture. + * @return Zero if valid, a negative value if invalid. + */ +int avcodec_check_dimensions(void *av_log_ctx, unsigned int w, unsigned int h); +enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum PixelFormat * fmt); + +int avcodec_thread_init(AVCodecContext *s, int thread_count); +void avcodec_thread_free(AVCodecContext *s); +int avcodec_thread_execute(AVCodecContext *s, int (*func)(AVCodecContext *c2, void *arg2),void **arg, int *ret, int count); +int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void **arg, int *ret, int count); +//FIXME func typedef + +/** + * Initializes the AVCodecContext to use the given AVCodec. Prior to using this + * function the context has to be allocated. + * + * The functions avcodec_find_decoder_by_name(), avcodec_find_encoder_by_name(), + * avcodec_find_decoder() and avcodec_find_encoder() provide an easy way for + * retrieving a codec. + * + * @warning This function is not thread save! + * + * @code + * codec = avcodec_find_decoder(CODEC_ID_H264); + * if (!codec) + * exit(1); + * + * context = avcodec_alloc_context(); + * + * if (avcodec_open(context, codec) < 0) + * exit(1); + * @endcode + * + * @param avctx The context which will be setup to use the given codec. + * @param codec The codec to use within the context. + * @return Zero on success, a negative value on error. + * @see avcodec_alloc_context, avcodec_find_decoder, avcodec_find_encoder + */ +int avcodec_open(AVCodecContext *avctx, AVCodec *codec); + +/** + * @deprecated Use avcodec_decode_audio2() instead. + */ +attribute_deprecated int avcodec_decode_audio(AVCodecContext *avctx, int16_t *samples, + int *frame_size_ptr, + uint8_t *buf, int buf_size); + +/** + * Decodes an audio frame from \p buf into \p samples. + * The avcodec_decode_audio2() function decodes a frame of audio from the input + * buffer \p buf of size \p buf_size. To decode it, it makes use of the + * audiocodec which was coupled with \p avctx using avcodec_open(). The + * resulting decoded frame is stored in output buffer \p samples. If no frame + * could be decompressed, \p frame_size_ptr is zero. Otherwise, it is the + * decompressed frame size in \e bytes. + * + * @warning You \e must set \p frame_size_ptr to the allocated size of the + * output buffer before calling avcodec_decode_audio2(). + * + * @warning The input buffer must be \c FF_INPUT_BUFFER_PADDING_SIZE larger than + * the actual read bytes because some optimized bitstream readers read 32 or 64 + * bits at once and could read over the end. + * + * @warning The end of the input buffer \p buf should be set to 0 to ensure that + * no overreading happens for damaged MPEG streams. + * + * @note You might have to align the input buffer \p buf and output buffer \p + * samples. The alignment requirements depend on the CPU: on some CPUs it isn't + * necessary at all, on others it won't work at all if not aligned and on others + * it will work but it will have an impact on performance. In practice, the + * bitstream should have 4 byte alignment at minimum and all sample data should + * be 16 byte aligned unless the CPU doesn't need it (AltiVec and SSE do). If + * the linesize is not a multiple of 16 then there's no sense in aligning the + * start of the buffer to 16. + * + * @param avctx The codec context. + * @param[out] samples The output buffer. + * @param[in,out] frame_size_ptr The output buffer size in bytes. + * @param[in] buf The input buffer. + * @param[in] buf_size The input buffer size in bytes. + * @return On error a negative value is returned, otherwise the number of bytes + * used or zero if no frame could be decompressed. + */ +int avcodec_decode_audio2(AVCodecContext *avctx, int16_t *samples, + int *frame_size_ptr, + uint8_t *buf, int buf_size); + +/** + * Decodes a video frame from \p buf into \p picture. + * The avcodec_decode_video() function decodes a frame of video from the input + * buffer \p buf of size \p buf_size. To decode it, it makes use of the + * videocodec which was coupled with \p avctx using avcodec_open(). The + * resulting decoded frame is stored in \p picture. + * + * @warning The input buffer must be \c FF_INPUT_BUFFER_PADDING_SIZE larger than + * the actual read bytes because some optimized bitstream readers read 32 or 64 + * bits at once and could read over the end. + * + * @warning The end of the input buffer \p buf should be set to 0 to ensure that + * no overreading happens for damaged MPEG streams. + * + * @note You might have to align the input buffer \p buf and output buffer \p + * samples. The alignment requirements depend on the CPU: on some CPUs it isn't + * necessary at all, on others it won't work at all if not aligned and on others + * it will work but it will have an impact on performance. In practice, the + * bitstream should have 4 byte alignment at minimum and all sample data should + * be 16 byte aligned unless the CPU doesn't need it (AltiVec and SSE do). If + * the linesize is not a multiple of 16 then there's no sense in aligning the + * start of the buffer to 16. + * + * @param avctx The codec context. + * @param[out] picture The AVFrame in which the decoded video frame will be stored. + * @param[in] buf The input buffer. + * @param[in] buf_size The size of the input buffer in bytes. + * @param[in,out] got_picture_ptr Zero if no frame could be decompressed, otherwise, it is non zero. + * @return On error a negative value is returned, otherwise the number of bytes + * used or zero if no frame could be decompressed. + */ +int avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture, + int *got_picture_ptr, + uint8_t *buf, int buf_size); + +/* decode a subtitle message. return -1 if error, otherwise return the + *number of bytes used. If no subtitle could be decompressed, + *got_sub_ptr is zero. Otherwise, the subtitle is stored in *sub. */ +int avcodec_decode_subtitle(AVCodecContext *avctx, AVSubtitle *sub, + int *got_sub_ptr, + const uint8_t *buf, int buf_size); +int avcodec_parse_frame(AVCodecContext *avctx, uint8_t **pdata, + int *data_size_ptr, + uint8_t *buf, int buf_size); + +/** + * Encodes an audio frame from \p samples into \p buf. + * The avcodec_encode_audio() function encodes a frame of audio from the input + * buffer \p samples. To encode it, it makes use of the audiocodec which was + * coupled with \p avctx using avcodec_open(). The resulting encoded frame is + * stored in output buffer \p buf. + * + * @note The output buffer should be at least \c FF_MIN_BUFFER_SIZE bytes large. + * + * @param avctx The codec context. + * @param[out] buf The output buffer. + * @param[in] buf_size The output buffer size. + * @param[in] samples The input buffer containing the samples. + * @return On error a negative value is returned, on succes zero or the number + * of bytes used from the input buffer. + */ +int avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size, + const short *samples); + +/** + * Encodes a video frame from \p pict into \p buf. + * The avcodec_encode_video() function encodes a frame of video from the input + * \p pict. To encode it, it makes use of the videocodec which was coupled with + * \p avctx using avcodec_open(). The resulting encoded bytes representing the + * frame are stored in the output buffer \p buf. The input picture should be + * stored using a specific format, namely \c avctx.pix_fmt. + * + * @param avctx The codec context. + * @param[out] buf The output buffer for the bitstream of encoded frame. + * @param[in] buf_size The size of the outputbuffer in bytes. + * @param[in] pict The input picture to encode. + * @return On error a negative value is returned, on success zero or the number + * of bytes used from the input buffer. + */ +int avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size, + const AVFrame *pict); +int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size, + const AVSubtitle *sub); + +int avcodec_close(AVCodecContext *avctx); + +void avcodec_register_all(void); + +/** + * Flush buffers, should be called when seeking or when switching to a different stream. + */ +void avcodec_flush_buffers(AVCodecContext *avctx); + +void avcodec_default_free_buffers(AVCodecContext *s); + +/* misc useful functions */ + +/** + * Returns a single letter to describe the given picture type \p pict_type. + * + * @param[in] pict_type The picture type. + * @return A single character representing the picture type. + */ +char av_get_pict_type_char(int pict_type); + +/** + * Returns codec bits per sample. + * + * @param[in] codec_id The codec. + * @return Number of bits per sample or zero if unknown for the given codec. + */ +int av_get_bits_per_sample(enum CodecID codec_id); + +/* frame parsing */ +typedef struct AVCodecParserContext { + void *priv_data; + struct AVCodecParser *parser; + int64_t frame_offset; /* offset of the current frame */ + int64_t cur_offset; /* current offset + (incremented by each av_parser_parse()) */ + int64_t last_frame_offset; /* offset of the last frame */ + /* video info */ + int pict_type; /* XXX: put it back in AVCodecContext */ + int repeat_pict; /* XXX: put it back in AVCodecContext */ + int64_t pts; /* pts of the current frame */ + int64_t dts; /* dts of the current frame */ + + /* private data */ + int64_t last_pts; + int64_t last_dts; + int fetch_timestamp; + +#define AV_PARSER_PTS_NB 4 + int cur_frame_start_index; + int64_t cur_frame_offset[AV_PARSER_PTS_NB]; + int64_t cur_frame_pts[AV_PARSER_PTS_NB]; + int64_t cur_frame_dts[AV_PARSER_PTS_NB]; + + int flags; +#define PARSER_FLAG_COMPLETE_FRAMES 0x0001 +} AVCodecParserContext; + +typedef struct AVCodecParser { + int codec_ids[5]; /* several codec IDs are permitted */ + int priv_data_size; + int (*parser_init)(AVCodecParserContext *s); + int (*parser_parse)(AVCodecParserContext *s, + AVCodecContext *avctx, + uint8_t **poutbuf, int *poutbuf_size, + const uint8_t *buf, int buf_size); + void (*parser_close)(AVCodecParserContext *s); + int (*split)(AVCodecContext *avctx, const uint8_t *buf, int buf_size); + struct AVCodecParser *next; +} AVCodecParser; + +extern AVCodecParser *av_first_parser; + +void av_register_codec_parser(AVCodecParser *parser); +AVCodecParserContext *av_parser_init(int codec_id); +int av_parser_parse(AVCodecParserContext *s, + AVCodecContext *avctx, + uint8_t **poutbuf, int *poutbuf_size, + const uint8_t *buf, int buf_size, + int64_t pts, int64_t dts); +int av_parser_change(AVCodecParserContext *s, + AVCodecContext *avctx, + uint8_t **poutbuf, int *poutbuf_size, + const uint8_t *buf, int buf_size, int keyframe); +void av_parser_close(AVCodecParserContext *s); + +extern AVCodecParser aac_parser; +extern AVCodecParser ac3_parser; +extern AVCodecParser cavsvideo_parser; +extern AVCodecParser dca_parser; +extern AVCodecParser dvbsub_parser; +extern AVCodecParser dvdsub_parser; +extern AVCodecParser h261_parser; +extern AVCodecParser h263_parser; +extern AVCodecParser h264_parser; +extern AVCodecParser mjpeg_parser; +extern AVCodecParser mpeg4video_parser; +extern AVCodecParser mpegaudio_parser; +extern AVCodecParser mpegvideo_parser; +extern AVCodecParser pnm_parser; +extern AVCodecParser vc1_parser; + + +typedef struct AVBitStreamFilterContext { + void *priv_data; + struct AVBitStreamFilter *filter; + AVCodecParserContext *parser; + struct AVBitStreamFilterContext *next; +} AVBitStreamFilterContext; + + +typedef struct AVBitStreamFilter { + const char *name; + int priv_data_size; + int (*filter)(AVBitStreamFilterContext *bsfc, + AVCodecContext *avctx, const char *args, + uint8_t **poutbuf, int *poutbuf_size, + const uint8_t *buf, int buf_size, int keyframe); + struct AVBitStreamFilter *next; +} AVBitStreamFilter; + +extern AVBitStreamFilter *av_first_bitstream_filter; + +void av_register_bitstream_filter(AVBitStreamFilter *bsf); +AVBitStreamFilterContext *av_bitstream_filter_init(const char *name); +int av_bitstream_filter_filter(AVBitStreamFilterContext *bsfc, + AVCodecContext *avctx, const char *args, + uint8_t **poutbuf, int *poutbuf_size, + const uint8_t *buf, int buf_size, int keyframe); +void av_bitstream_filter_close(AVBitStreamFilterContext *bsf); + +extern AVBitStreamFilter dump_extradata_bsf; +extern AVBitStreamFilter remove_extradata_bsf; +extern AVBitStreamFilter noise_bsf; +extern AVBitStreamFilter mp3_header_compress_bsf; +extern AVBitStreamFilter mp3_header_decompress_bsf; +extern AVBitStreamFilter mjpega_dump_header_bsf; +extern AVBitStreamFilter imx_dump_header_bsf; + + +/* memory */ + +/** + * Reallocates the given block if it is not large enough, otherwise it + * does nothing. + * + * @see av_realloc + */ +void *av_fast_realloc(void *ptr, unsigned int *size, unsigned int min_size); + +/* for static data only */ + +/** + * Frees all static arrays and reset their pointers to 0. + * Call this function to release all statically allocated tables. + */ +attribute_deprecated void av_free_static(void); + +/** + * Allocation of static arrays. + * + * @warning Do not use for normal allocation. + * + * @param[in] size The amount of memory you need in bytes. + * @return Block of memory of the requested size. + */ +attribute_deprecated void *av_mallocz_static(unsigned int size); + +/** + * Copy image 'src' to 'dst'. + */ +void av_picture_copy(AVPicture *dst, const AVPicture *src, + int pix_fmt, int width, int height); + +/** + * Crop image top and left side + */ +int av_picture_crop(AVPicture *dst, const AVPicture *src, + int pix_fmt, int top_band, int left_band); + +/** + * Pad image + */ +int av_picture_pad(AVPicture *dst, const AVPicture *src, int height, int width, int pix_fmt, + int padtop, int padbottom, int padleft, int padright, int *color); + +#if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0) +attribute_deprecated void img_copy(AVPicture *dst, const AVPicture *src, + int pix_fmt, int width, int height); + +attribute_deprecated int img_crop(AVPicture *dst, const AVPicture *src, + int pix_fmt, int top_band, int left_band); + +attribute_deprecated int img_pad(AVPicture *dst, const AVPicture *src, int height, int width, int pix_fmt, + int padtop, int padbottom, int padleft, int padright, int *color); +#endif + +extern unsigned int av_xiphlacing(unsigned char *s, unsigned int v); + +/* error handling */ +#if EINVAL > 0 +#define AVERROR(e) (-(e)) /**< returns a negative error code from a POSIX error code, to return from library functions. */ +#define AVUNERROR(e) (-(e)) /**< returns a POSIX error code from a library function error return value. */ +#else +/* some platforms have E* and errno already negated. */ +#define AVERROR(e) (e) +#define AVUNERROR(e) (e) +#endif +#define AVERROR_UNKNOWN AVERROR(EINVAL) /**< unknown error */ +#define AVERROR_IO AVERROR(EIO) /**< i/o error */ +#define AVERROR_NUMEXPECTED AVERROR(EDOM) /**< number syntax expected in filename */ +#define AVERROR_INVALIDDATA AVERROR(EINVAL) /**< invalid data found */ +#define AVERROR_NOMEM AVERROR(ENOMEM) /**< not enough memory */ +#define AVERROR_NOFMT AVERROR(EILSEQ) /**< unknown format */ +#define AVERROR_NOTSUPP AVERROR(ENOSYS) /**< operation not supported */ + +#ifdef __cplusplus +} +#endif + +#endif /* AVCODEC_H */ diff --git a/src/ffmpeg/include/ffmpeg/avformat.h b/src/ffmpeg/include/ffmpeg/avformat.h new file mode 100644 index 0000000000..eb8c4e1534 --- /dev/null +++ b/src/ffmpeg/include/ffmpeg/avformat.h @@ -0,0 +1,888 @@ +/* + * copyright (c) 2001 Fabrice Bellard + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVFORMAT_H +#define AVFORMAT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#define LIBAVFORMAT_VERSION_INT ((51<<16)+(11<<8)+0) +#define LIBAVFORMAT_VERSION 51.11.0 +#define LIBAVFORMAT_BUILD LIBAVFORMAT_VERSION_INT + +#define LIBAVFORMAT_IDENT "Lavf" AV_STRINGIFY(LIBAVFORMAT_VERSION) + +#include +#include /* FILE */ +#include "avcodec.h" + +#include "avio.h" + +/* packet functions */ + +typedef struct AVPacket { + int64_t pts; ///< presentation time stamp in time_base units + int64_t dts; ///< decompression time stamp in time_base units + uint8_t *data; + int size; + int stream_index; + int flags; + int duration; ///< presentation duration in time_base units (0 if not available) + void (*destruct)(struct AVPacket *); + void *priv; + int64_t pos; ///< byte position in stream, -1 if unknown +} AVPacket; +#define PKT_FLAG_KEY 0x0001 + +void av_destruct_packet_nofree(AVPacket *pkt); + +/** + * Default packet destructor. + */ +void av_destruct_packet(AVPacket *pkt); + +/* initialize optional fields of a packet */ +static inline void av_init_packet(AVPacket *pkt) +{ + pkt->pts = AV_NOPTS_VALUE; + pkt->dts = AV_NOPTS_VALUE; + pkt->pos = -1; + pkt->duration = 0; + pkt->flags = 0; + pkt->stream_index = 0; + pkt->destruct= av_destruct_packet_nofree; +} + +/** + * Allocate the payload of a packet and intialized its fields to default values. + * + * @param pkt packet + * @param size wanted payload size + * @return 0 if OK. AVERROR_xxx otherwise. + */ +int av_new_packet(AVPacket *pkt, int size); + +/** + * Allocate and read the payload of a packet and intialized its fields to default values. + * + * @param pkt packet + * @param size wanted payload size + * @return >0 (read size) if OK. AVERROR_xxx otherwise. + */ +int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size); + +/** + * @warning This is a hack - the packet memory allocation stuff is broken. The + * packet is allocated if it was not really allocated + */ +int av_dup_packet(AVPacket *pkt); + +/** + * Free a packet + * + * @param pkt packet to free + */ +static inline void av_free_packet(AVPacket *pkt) +{ + if (pkt && pkt->destruct) { + pkt->destruct(pkt); + } +} + +/*************************************************/ +/* fractional numbers for exact pts handling */ + +/* the exact value of the fractional number is: 'val + num / den'. num + is assumed to be such as 0 <= num < den */ +typedef struct AVFrac { + int64_t val, num, den; +} AVFrac attribute_deprecated; + +/*************************************************/ +/* input/output formats */ + +struct AVCodecTag; + +struct AVFormatContext; + +/** this structure contains the data a format has to probe a file */ +typedef struct AVProbeData { + const char *filename; + unsigned char *buf; + int buf_size; +} AVProbeData; + +#define AVPROBE_SCORE_MAX 100 ///< max score, half of that is used for file extension based detection + +typedef struct AVFormatParameters { + AVRational time_base; + int sample_rate; + int channels; + int width; + int height; + enum PixelFormat pix_fmt; + int channel; /**< used to select dv channel */ +#if LIBAVFORMAT_VERSION_INT < (52<<16) + const char *device; /**< video, audio or DV device */ +#endif + const char *standard; /**< tv standard, NTSC, PAL, SECAM */ + int mpeg2ts_raw:1; /**< force raw MPEG2 transport stream output, if possible */ + int mpeg2ts_compute_pcr:1; /**< compute exact PCR for each transport + stream packet (only meaningful if + mpeg2ts_raw is TRUE */ + int initial_pause:1; /**< do not begin to play the stream + immediately (RTSP only) */ + int prealloced_context:1; + enum CodecID video_codec_id; + enum CodecID audio_codec_id; +} AVFormatParameters; + +//! demuxer will use url_fopen, no opened file should be provided by the caller +#define AVFMT_NOFILE 0x0001 +#define AVFMT_NEEDNUMBER 0x0002 /**< needs '%d' in filename */ +#define AVFMT_SHOW_IDS 0x0008 /**< show format stream IDs numbers */ +#define AVFMT_RAWPICTURE 0x0020 /**< format wants AVPicture structure for + raw picture data */ +#define AVFMT_GLOBALHEADER 0x0040 /**< format wants global header */ +#define AVFMT_NOTIMESTAMPS 0x0080 /**< format doesnt need / has any timestamps */ +#define AVFMT_GENERIC_INDEX 0x0100 /**< use generic index building code */ + +typedef struct AVOutputFormat { + const char *name; + const char *long_name; + const char *mime_type; + const char *extensions; /**< comma separated filename extensions */ + /** size of private data so that it can be allocated in the wrapper */ + int priv_data_size; + /* output support */ + enum CodecID audio_codec; /**< default audio codec */ + enum CodecID video_codec; /**< default video codec */ + int (*write_header)(struct AVFormatContext *); + int (*write_packet)(struct AVFormatContext *, AVPacket *pkt); + int (*write_trailer)(struct AVFormatContext *); + /** can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER */ + int flags; + /** currently only used to set pixel format if not YUV420P */ + int (*set_parameters)(struct AVFormatContext *, AVFormatParameters *); + int (*interleave_packet)(struct AVFormatContext *, AVPacket *out, AVPacket *in, int flush); + + /** + * list of supported codec_id-codec_tag pairs, ordered by "better choice first" + * the arrays are all CODEC_ID_NONE terminated + */ + const struct AVCodecTag **codec_tag; + + /* private fields */ + struct AVOutputFormat *next; +} AVOutputFormat; + +typedef struct AVInputFormat { + const char *name; + const char *long_name; + /** size of private data so that it can be allocated in the wrapper */ + int priv_data_size; + /** tell if a given file has a chance of being parsing by this format */ + int (*read_probe)(AVProbeData *); + /** read the format header and initialize the AVFormatContext + structure. Return 0 if OK. 'ap' if non NULL contains + additionnal paramters. Only used in raw format right + now. 'av_new_stream' should be called to create new streams. */ + int (*read_header)(struct AVFormatContext *, + AVFormatParameters *ap); + /** read one packet and put it in 'pkt'. pts and flags are also + set. 'av_new_stream' can be called only if the flag + AVFMTCTX_NOHEADER is used. */ + int (*read_packet)(struct AVFormatContext *, AVPacket *pkt); + /** close the stream. The AVFormatContext and AVStreams are not + freed by this function */ + int (*read_close)(struct AVFormatContext *); + /** + * seek to a given timestamp relative to the frames in + * stream component stream_index + * @param stream_index must not be -1 + * @param flags selects which direction should be preferred if no exact + * match is available + */ + int (*read_seek)(struct AVFormatContext *, + int stream_index, int64_t timestamp, int flags); + /** + * gets the next timestamp in AV_TIME_BASE units. + */ + int64_t (*read_timestamp)(struct AVFormatContext *s, int stream_index, + int64_t *pos, int64_t pos_limit); + /** can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER */ + int flags; + /** if extensions are defined, then no probe is done. You should + usually not use extension format guessing because it is not + reliable enough */ + const char *extensions; + /** general purpose read only value that the format can use */ + int value; + + /** start/resume playing - only meaningful if using a network based format + (RTSP) */ + int (*read_play)(struct AVFormatContext *); + + /** pause playing - only meaningful if using a network based format + (RTSP) */ + int (*read_pause)(struct AVFormatContext *); + + const struct AVCodecTag **codec_tag; + + /* private fields */ + struct AVInputFormat *next; +} AVInputFormat; + +typedef struct AVIndexEntry { + int64_t pos; + int64_t timestamp; +#define AVINDEX_KEYFRAME 0x0001 + int flags:2; + int size:30; //yeah trying to keep the size of this small to reduce memory requirements (its 24 vs 32 byte due to possible 8byte align) + int min_distance; /**< min distance between this and the previous keyframe, used to avoid unneeded searching */ +} AVIndexEntry; + +typedef struct AVStream { + int index; /**< stream index in AVFormatContext */ + int id; /**< format specific stream id */ + AVCodecContext *codec; /**< codec context */ + /** + * real base frame rate of the stream. + * this is the lowest framerate with which all timestamps can be + * represented accurately (its the least common multiple of all + * framerates in the stream), Note, this value is just a guess! + * for example if the timebase is 1/90000 and all frames have either + * approximately 3600 or 1800 timer ticks then r_frame_rate will be 50/1 + */ + AVRational r_frame_rate; + void *priv_data; +#if LIBAVFORMAT_VERSION_INT < (52<<16) + /* internal data used in av_find_stream_info() */ + int64_t codec_info_duration; + int codec_info_nb_frames; +#endif + /** encoding: PTS generation when outputing stream */ + AVFrac pts; + + /** + * this is the fundamental unit of time (in seconds) in terms + * of which frame timestamps are represented. for fixed-fps content, + * timebase should be 1/framerate and timestamp increments should be + * identically 1. + */ + AVRational time_base; + int pts_wrap_bits; /**< number of bits in pts (used for wrapping control) */ + /* ffmpeg.c private use */ + int stream_copy; /**< if set, just copy stream */ + enum AVDiscard discard; ///< selects which packets can be discarded at will and dont need to be demuxed + //FIXME move stuff to a flags field? + /** quality, as it has been removed from AVCodecContext and put in AVVideoFrame + * MN:dunno if thats the right place, for it */ + float quality; + /** decoding: position of the first frame of the component, in + AV_TIME_BASE fractional seconds. */ + int64_t start_time; + /** decoding: duration of the stream, in AV_TIME_BASE fractional + seconds. */ + int64_t duration; + + char language[4]; /** ISO 639 3-letter language code (empty string if undefined) */ + + /* av_read_frame() support */ + int need_parsing; ///< 1->full parsing needed, 2->only parse headers dont repack + struct AVCodecParserContext *parser; + + int64_t cur_dts; + int last_IP_duration; + int64_t last_IP_pts; + /* av_seek_frame() support */ + AVIndexEntry *index_entries; /**< only used if the format does not + support seeking natively */ + int nb_index_entries; + unsigned int index_entries_allocated_size; + + int64_t nb_frames; ///< number of frames in this stream if known or 0 + +#define MAX_REORDER_DELAY 4 + int64_t pts_buffer[MAX_REORDER_DELAY+1]; +} AVStream; + +#define AVFMTCTX_NOHEADER 0x0001 /**< signal that no header is present + (streams are added dynamically) */ + +#define MAX_STREAMS 20 + +/* format I/O context */ +typedef struct AVFormatContext { + const AVClass *av_class; /**< set by av_alloc_format_context */ + /* can only be iformat or oformat, not both at the same time */ + struct AVInputFormat *iformat; + struct AVOutputFormat *oformat; + void *priv_data; + ByteIOContext pb; + unsigned int nb_streams; + AVStream *streams[MAX_STREAMS]; + char filename[1024]; /**< input or output filename */ + /* stream info */ + int64_t timestamp; + char title[512]; + char author[512]; + char copyright[512]; + char comment[512]; + char album[512]; + int year; /**< ID3 year, 0 if none */ + int track; /**< track number, 0 if none */ + char genre[32]; /**< ID3 genre */ + + int ctx_flags; /**< format specific flags, see AVFMTCTX_xx */ + /* private data for pts handling (do not modify directly) */ + /** This buffer is only needed when packets were already buffered but + not decoded, for example to get the codec parameters in mpeg + streams */ + struct AVPacketList *packet_buffer; + + /** decoding: position of the first frame of the component, in + AV_TIME_BASE fractional seconds. NEVER set this value directly: + it is deduced from the AVStream values. */ + int64_t start_time; + /** decoding: duration of the stream, in AV_TIME_BASE fractional + seconds. NEVER set this value directly: it is deduced from the + AVStream values. */ + int64_t duration; + /** decoding: total file size. 0 if unknown */ + int64_t file_size; + /** decoding: total stream bitrate in bit/s, 0 if not + available. Never set it directly if the file_size and the + duration are known as ffmpeg can compute it automatically. */ + int bit_rate; + + /* av_read_frame() support */ + AVStream *cur_st; + const uint8_t *cur_ptr; + int cur_len; + AVPacket cur_pkt; + + /* av_seek_frame() support */ + int64_t data_offset; /** offset of the first packet */ + int index_built; + + int mux_rate; + int packet_size; + int preload; + int max_delay; + +#define AVFMT_NOOUTPUTLOOP -1 +#define AVFMT_INFINITEOUTPUTLOOP 0 + /** number of times to loop output in formats that support it */ + int loop_output; + + int flags; +#define AVFMT_FLAG_GENPTS 0x0001 ///< generate pts if missing even if it requires parsing future frames +#define AVFMT_FLAG_IGNIDX 0x0002 ///< ignore index + + int loop_input; + /** decoding: size of data to probe; encoding unused */ + unsigned int probesize; + + /** + * maximum duration in AV_TIME_BASE units over which the input should be analyzed in av_find_stream_info() + */ + int max_analyze_duration; + + const uint8_t *key; + int keylen; +} AVFormatContext; + +typedef struct AVPacketList { + AVPacket pkt; + struct AVPacketList *next; +} AVPacketList; + +extern AVInputFormat *first_iformat; +extern AVOutputFormat *first_oformat; + +enum CodecID av_guess_image2_codec(const char *filename); + +/* XXX: use automatic init with either ELF sections or C file parser */ +/* modules */ + +#include "rtp.h" + +#include "rtsp.h" + +/* utils.c */ +void av_register_input_format(AVInputFormat *format); +void av_register_output_format(AVOutputFormat *format); +AVOutputFormat *guess_stream_format(const char *short_name, + const char *filename, const char *mime_type); +AVOutputFormat *guess_format(const char *short_name, + const char *filename, const char *mime_type); + +/** + * Guesses the codec id based upon muxer and filename. + */ +enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name, + const char *filename, const char *mime_type, enum CodecType type); + +/** + * Send a nice hexadecimal dump of a buffer to the specified file stream. + * + * @param f The file stream pointer where the dump should be sent to. + * @param buf buffer + * @param size buffer size + * + * @see av_hex_dump_log, av_pkt_dump, av_pkt_dump_log + */ +void av_hex_dump(FILE *f, uint8_t *buf, int size); + +/** + * Send a nice hexadecimal dump of a buffer to the log. + * + * @param avcl A pointer to an arbitrary struct of which the first field is a + * pointer to an AVClass struct. + * @param level The importance level of the message, lower values signifying + * higher importance. + * @param buf buffer + * @param size buffer size + * + * @see av_hex_dump, av_pkt_dump, av_pkt_dump_log + */ +void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size); + +/** + * Send a nice dump of a packet to the specified file stream. + * + * @param f The file stream pointer where the dump should be sent to. + * @param pkt packet to dump + * @param dump_payload true if the payload must be displayed too + */ +void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload); + +/** + * Send a nice dump of a packet to the log. + * + * @param avcl A pointer to an arbitrary struct of which the first field is a + * pointer to an AVClass struct. + * @param level The importance level of the message, lower values signifying + * higher importance. + * @param pkt packet to dump + * @param dump_payload true if the payload must be displayed too + */ +void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload); + +void av_register_all(void); + +/** codec tag <-> codec id */ +enum CodecID av_codec_get_id(const struct AVCodecTag **tags, unsigned int tag); +unsigned int av_codec_get_tag(const struct AVCodecTag **tags, enum CodecID id); + +/* media file input */ + +/** + * finds AVInputFormat based on input format's short name. + */ +AVInputFormat *av_find_input_format(const char *short_name); + +/** + * Guess file format. + * + * @param is_opened whether the file is already opened, determines whether + * demuxers with or without AVFMT_NOFILE are probed + */ +AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened); + +/** + * Allocates all the structures needed to read an input stream. + * This does not open the needed codecs for decoding the stream[s]. + */ +int av_open_input_stream(AVFormatContext **ic_ptr, + ByteIOContext *pb, const char *filename, + AVInputFormat *fmt, AVFormatParameters *ap); + +/** + * Open a media file as input. The codec are not opened. Only the file + * header (if present) is read. + * + * @param ic_ptr the opened media file handle is put here + * @param filename filename to open. + * @param fmt if non NULL, force the file format to use + * @param buf_size optional buffer size (zero if default is OK) + * @param ap additionnal parameters needed when opening the file (NULL if default) + * @return 0 if OK. AVERROR_xxx otherwise. + */ +int av_open_input_file(AVFormatContext **ic_ptr, const char *filename, + AVInputFormat *fmt, + int buf_size, + AVFormatParameters *ap); +/** no av_open for output, so applications will need this: */ +AVFormatContext *av_alloc_format_context(void); + +/** + * Read packets of a media file to get stream information. This + * is useful for file formats with no headers such as MPEG. This + * function also computes the real frame rate in case of mpeg2 repeat + * frame mode. + * The logical file position is not changed by this function; + * examined packets may be buffered for later processing. + * + * @param ic media file handle + * @return >=0 if OK. AVERROR_xxx if error. + * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need + */ +int av_find_stream_info(AVFormatContext *ic); + +/** + * Read a transport packet from a media file. + * + * This function is absolete and should never be used. + * Use av_read_frame() instead. + * + * @param s media file handle + * @param pkt is filled + * @return 0 if OK. AVERROR_xxx if error. + */ +int av_read_packet(AVFormatContext *s, AVPacket *pkt); + +/** + * Return the next frame of a stream. + * + * The returned packet is valid + * until the next av_read_frame() or until av_close_input_file() and + * must be freed with av_free_packet. For video, the packet contains + * exactly one frame. For audio, it contains an integer number of + * frames if each frame has a known fixed size (e.g. PCM or ADPCM + * data). If the audio frames have a variable size (e.g. MPEG audio), + * then it contains one frame. + * + * pkt->pts, pkt->dts and pkt->duration are always set to correct + * values in AVStream.timebase units (and guessed if the format cannot + * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format + * has B frames, so it is better to rely on pkt->dts if you do not + * decompress the payload. + * + * @return 0 if OK, < 0 if error or end of file. + */ +int av_read_frame(AVFormatContext *s, AVPacket *pkt); + +/** + * Seek to the key frame at timestamp. + * 'timestamp' in 'stream_index'. + * @param stream_index If stream_index is (-1), a default + * stream is selected, and timestamp is automatically converted + * from AV_TIME_BASE units to the stream specific time_base. + * @param timestamp timestamp in AVStream.time_base units + * or if there is no stream specified then in AV_TIME_BASE units + * @param flags flags which select direction and seeking mode + * @return >= 0 on success + */ +int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags); + +/** + * start playing a network based stream (e.g. RTSP stream) at the + * current position + */ +int av_read_play(AVFormatContext *s); + +/** + * Pause a network based stream (e.g. RTSP stream). + * + * Use av_read_play() to resume it. + */ +int av_read_pause(AVFormatContext *s); + +/** + * Close a media file (but not its codecs). + * + * @param s media file handle + */ +void av_close_input_file(AVFormatContext *s); + +/** + * Add a new stream to a media file. + * + * Can only be called in the read_header() function. If the flag + * AVFMTCTX_NOHEADER is in the format context, then new streams + * can be added in read_packet too. + * + * @param s media file handle + * @param id file format dependent stream id + */ +AVStream *av_new_stream(AVFormatContext *s, int id); + +/** + * Set the pts for a given stream. + * + * @param s stream + * @param pts_wrap_bits number of bits effectively used by the pts + * (used for wrap control, 33 is the value for MPEG) + * @param pts_num numerator to convert to seconds (MPEG: 1) + * @param pts_den denominator to convert to seconds (MPEG: 90000) + */ +void av_set_pts_info(AVStream *s, int pts_wrap_bits, + int pts_num, int pts_den); + +#define AVSEEK_FLAG_BACKWARD 1 ///< seek backward +#define AVSEEK_FLAG_BYTE 2 ///< seeking based on position in bytes +#define AVSEEK_FLAG_ANY 4 ///< seek to any frame, even non keyframes + +int av_find_default_stream_index(AVFormatContext *s); + +/** + * Gets the index for a specific timestamp. + * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to + * the timestamp which is <= the requested one, if backward is 0 + * then it will be >= + * if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise + * @return < 0 if no such timestamp could be found + */ +int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags); + +/** + * Add a index entry into a sorted list updateing if it is already there. + * + * @param timestamp timestamp in the timebase of the given stream + */ +int av_add_index_entry(AVStream *st, + int64_t pos, int64_t timestamp, int size, int distance, int flags); + +/** + * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp(). + * this isnt supposed to be called directly by a user application, but by demuxers + * @param target_ts target timestamp in the time base of the given stream + * @param stream_index stream number + */ +int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags); + +/** + * Updates cur_dts of all streams based on given timestamp and AVStream. + * + * Stream ref_st unchanged, others set cur_dts in their native timebase + * only needed for timestamp wrapping or if (dts not set and pts!=dts) + * @param timestamp new dts expressed in time_base of param ref_st + * @param ref_st reference stream giving time_base of param timestamp + */ +void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp); + +/** + * Does a binary search using read_timestamp(). + * this isnt supposed to be called directly by a user application, but by demuxers + * @param target_ts target timestamp in the time base of the given stream + * @param stream_index stream number + */ +int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )); + +/** media file output */ +int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap); + +/** + * allocate the stream private data and write the stream header to an + * output media file + * + * @param s media file handle + * @return 0 if OK. AVERROR_xxx if error. + */ +int av_write_header(AVFormatContext *s); + +/** + * Write a packet to an output media file. + * + * The packet shall contain one audio or video frame. + * The packet must be correctly interleaved according to the container specification, + * if not then av_interleaved_write_frame must be used + * + * @param s media file handle + * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ... + * @return < 0 if error, = 0 if OK, 1 if end of stream wanted. + */ +int av_write_frame(AVFormatContext *s, AVPacket *pkt); + +/** + * Writes a packet to an output media file ensuring correct interleaving. + * + * The packet must contain one audio or video frame. + * If the packets are already correctly interleaved the application should + * call av_write_frame() instead as its slightly faster, its also important + * to keep in mind that completly non interleaved input will need huge amounts + * of memory to interleave with this, so its prefereable to interleave at the + * demuxer level + * + * @param s media file handle + * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ... + * @return < 0 if error, = 0 if OK, 1 if end of stream wanted. + */ +int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt); + +/** + * Interleave a packet per DTS in an output media file. + * + * Packets with pkt->destruct == av_destruct_packet will be freed inside this function, + * so they cannot be used after it, note calling av_free_packet() on them is still safe. + * + * @param s media file handle + * @param out the interleaved packet will be output here + * @param in the input packet + * @param flush 1 if no further packets are available as input and all + * remaining packets should be output + * @return 1 if a packet was output, 0 if no packet could be output, + * < 0 if an error occured + */ +int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush); + +/** + * @brief Write the stream trailer to an output media file and + * free the file private data. + * + * @param s media file handle + * @return 0 if OK. AVERROR_xxx if error. + */ +int av_write_trailer(AVFormatContext *s); + +void dump_format(AVFormatContext *ic, + int index, + const char *url, + int is_output); + +/** + * parses width and height out of string str. + */ +int parse_image_size(int *width_ptr, int *height_ptr, const char *str); + +/** + * Converts frame rate from string to a fraction. + */ +int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg); + +/** + * Converts date string to number of seconds since Jan 1st, 1970. + * + * @code + * Syntax: + * - If not a duration: + * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]} + * Time is localtime unless Z is suffixed to the end. In this case GMT + * Return the date in micro seconds since 1970 + * + * - If a duration: + * HH[:MM[:SS[.m...]]] + * S+[.m...] + * @endcode + */ +int64_t parse_date(const char *datestr, int duration); + +int64_t av_gettime(void); + +/* ffm specific for ffserver */ +#define FFM_PACKET_SIZE 4096 +offset_t ffm_read_write_index(int fd); +void ffm_write_write_index(int fd, offset_t pos); +void ffm_set_write_index(AVFormatContext *s, offset_t pos, offset_t file_size); + +/** + * Attempts to find a specific tag in a URL. + * + * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. + * Return 1 if found. + */ +int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info); + +/** + * Returns in 'buf' the path with '%d' replaced by number. + + * Also handles the '%0nd' format where 'n' is the total number + * of digits and '%%'. + * + * @param buf destination buffer + * @param buf_size destination buffer size + * @param path numbered sequence string + * @number frame number + * @return 0 if OK, -1 if format error. + */ +int av_get_frame_filename(char *buf, int buf_size, + const char *path, int number); + +/** + * Check whether filename actually is a numbered sequence generator. + * + * @param filename possible numbered sequence string + * @return 1 if a valid numbered sequence string, 0 otherwise. + */ +int av_filename_number_test(const char *filename); + +/* grab specific */ +int video_grab_init(void); +int audio_init(void); + +/* DV1394 */ +int dv1394_init(void); +int dc1394_init(void); + +#ifdef HAVE_AV_CONFIG_H + +#include "os_support.h" + +int strstart(const char *str, const char *val, const char **ptr); +int stristart(const char *str, const char *val, const char **ptr); +void pstrcpy(char *buf, int buf_size, const char *str); +char *pstrcat(char *buf, int buf_size, const char *s); + +void __dynarray_add(unsigned long **tab_ptr, int *nb_ptr, unsigned long elem); + +#ifdef __GNUC__ +#define dynarray_add(tab, nb_ptr, elem)\ +do {\ + typeof(tab) _tab = (tab);\ + typeof(elem) _elem = (elem);\ + (void)sizeof(**_tab == _elem); /* check that types are compatible */\ + __dynarray_add((unsigned long **)_tab, nb_ptr, (unsigned long)_elem);\ +} while(0) +#else +#define dynarray_add(tab, nb_ptr, elem)\ +do {\ + __dynarray_add((unsigned long **)(tab), nb_ptr, (unsigned long)(elem));\ +} while(0) +#endif + +time_t mktimegm(struct tm *tm); +struct tm *brktimegm(time_t secs, struct tm *tm); +const char *small_strptime(const char *p, const char *fmt, + struct tm *dt); + +struct in_addr; +int resolve_host(struct in_addr *sin_addr, const char *hostname); + +void url_split(char *proto, int proto_size, + char *authorization, int authorization_size, + char *hostname, int hostname_size, + int *port_ptr, + char *path, int path_size, + const char *url); + +int match_ext(const char *filename, const char *extensions); + +#endif /* HAVE_AV_CONFIG_H */ + +#ifdef __cplusplus +} +#endif + +#endif /* AVFORMAT_H */ + diff --git a/src/ffmpeg/include/ffmpeg/avio.h b/src/ffmpeg/include/ffmpeg/avio.h new file mode 100644 index 0000000000..be78c9a7b4 --- /dev/null +++ b/src/ffmpeg/include/ffmpeg/avio.h @@ -0,0 +1,272 @@ +/* + * unbuffered io for ffmpeg system + * copyright (c) 2001 Fabrice Bellard + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +#ifndef AVIO_H +#define AVIO_H + +/* output byte stream handling */ + +typedef int64_t offset_t; + +/* unbuffered I/O */ + +struct URLContext { + struct URLProtocol *prot; + int flags; + int is_streamed; /**< true if streamed (no seek possible), default = false */ + int max_packet_size; /**< if non zero, the stream is packetized with this max packet size */ + void *priv_data; +#if LIBAVFORMAT_VERSION_INT >= (52<<16) + char *filename; /**< specified filename */ +#else + char filename[1]; /**< specified filename */ +#endif +}; + +typedef struct URLContext URLContext; + +typedef struct URLPollEntry { + URLContext *handle; + int events; + int revents; +} URLPollEntry; + +#define URL_RDONLY 0 +#define URL_WRONLY 1 +#define URL_RDWR 2 + +typedef int URLInterruptCB(void); + +int url_open(URLContext **h, const char *filename, int flags); +int url_read(URLContext *h, unsigned char *buf, int size); +int url_write(URLContext *h, unsigned char *buf, int size); +offset_t url_seek(URLContext *h, offset_t pos, int whence); +int url_close(URLContext *h); +int url_exist(const char *filename); +offset_t url_filesize(URLContext *h); + +/** + * Return the maximum packet size associated to packetized file + * handle. If the file is not packetized (stream like http or file on + * disk), then 0 is returned. + * + * @param h file handle + * @return maximum packet size in bytes + */ +int url_get_max_packet_size(URLContext *h); +void url_get_filename(URLContext *h, char *buf, int buf_size); + +/** + * the callback is called in blocking functions to test regulary if + * asynchronous interruption is needed. AVERROR(EINTR) is returned + * in this case by the interrupted function. 'NULL' means no interrupt + * callback is given. i + */ +void url_set_interrupt_cb(URLInterruptCB *interrupt_cb); + +/* not implemented */ +int url_poll(URLPollEntry *poll_table, int n, int timeout); + +/** + * passing this as the "whence" parameter to a seek function causes it to + * return the filesize without seeking anywhere, supporting this is optional + * if its not supprted then the seek function will return <0 + */ +#define AVSEEK_SIZE 0x10000 + +typedef struct URLProtocol { + const char *name; + int (*url_open)(URLContext *h, const char *filename, int flags); + int (*url_read)(URLContext *h, unsigned char *buf, int size); + int (*url_write)(URLContext *h, unsigned char *buf, int size); + offset_t (*url_seek)(URLContext *h, offset_t pos, int whence); + int (*url_close)(URLContext *h); + struct URLProtocol *next; +} URLProtocol; + +extern URLProtocol *first_protocol; +extern URLInterruptCB *url_interrupt_cb; + +int register_protocol(URLProtocol *protocol); + +typedef struct { + unsigned char *buffer; + int buffer_size; + unsigned char *buf_ptr, *buf_end; + void *opaque; + int (*read_packet)(void *opaque, uint8_t *buf, int buf_size); + int (*write_packet)(void *opaque, uint8_t *buf, int buf_size); + offset_t (*seek)(void *opaque, offset_t offset, int whence); + offset_t pos; /**< position in the file of the current buffer */ + int must_flush; /**< true if the next seek should flush */ + int eof_reached; /**< true if eof reached */ + int write_flag; /**< true if open for writing */ + int is_streamed; + int max_packet_size; + unsigned long checksum; + unsigned char *checksum_ptr; + unsigned long (*update_checksum)(unsigned long checksum, const uint8_t *buf, unsigned int size); + int error; ///< contains the error code or 0 if no error happened +} ByteIOContext; + +int init_put_byte(ByteIOContext *s, + unsigned char *buffer, + int buffer_size, + int write_flag, + void *opaque, + int (*read_packet)(void *opaque, uint8_t *buf, int buf_size), + int (*write_packet)(void *opaque, uint8_t *buf, int buf_size), + offset_t (*seek)(void *opaque, offset_t offset, int whence)); + +void put_byte(ByteIOContext *s, int b); +void put_buffer(ByteIOContext *s, const unsigned char *buf, int size); +void put_le64(ByteIOContext *s, uint64_t val); +void put_be64(ByteIOContext *s, uint64_t val); +void put_le32(ByteIOContext *s, unsigned int val); +void put_be32(ByteIOContext *s, unsigned int val); +void put_le24(ByteIOContext *s, unsigned int val); +void put_be24(ByteIOContext *s, unsigned int val); +void put_le16(ByteIOContext *s, unsigned int val); +void put_be16(ByteIOContext *s, unsigned int val); +void put_tag(ByteIOContext *s, const char *tag); + +void put_strz(ByteIOContext *s, const char *buf); + +offset_t url_fseek(ByteIOContext *s, offset_t offset, int whence); +void url_fskip(ByteIOContext *s, offset_t offset); +offset_t url_ftell(ByteIOContext *s); +offset_t url_fsize(ByteIOContext *s); +int url_feof(ByteIOContext *s); +int url_ferror(ByteIOContext *s); + +#define URL_EOF (-1) +/** @note return URL_EOF (-1) if EOF */ +int url_fgetc(ByteIOContext *s); + +/** @warning currently size is limited */ +#ifdef __GNUC__ +int url_fprintf(ByteIOContext *s, const char *fmt, ...) __attribute__ ((__format__ (__printf__, 2, 3))); +#else +int url_fprintf(ByteIOContext *s, const char *fmt, ...); +#endif + +/** @note unlike fgets, the EOL character is not returned and a whole + line is parsed. return NULL if first char read was EOF */ +char *url_fgets(ByteIOContext *s, char *buf, int buf_size); + +void put_flush_packet(ByteIOContext *s); + +int get_buffer(ByteIOContext *s, unsigned char *buf, int size); +int get_partial_buffer(ByteIOContext *s, unsigned char *buf, int size); + +/** @note return 0 if EOF, so you cannot use it if EOF handling is + necessary */ +int get_byte(ByteIOContext *s); +unsigned int get_le24(ByteIOContext *s); +unsigned int get_le32(ByteIOContext *s); +uint64_t get_le64(ByteIOContext *s); +unsigned int get_le16(ByteIOContext *s); + +char *get_strz(ByteIOContext *s, char *buf, int maxlen); +unsigned int get_be16(ByteIOContext *s); +unsigned int get_be24(ByteIOContext *s); +unsigned int get_be32(ByteIOContext *s); +uint64_t get_be64(ByteIOContext *s); + +static inline int url_is_streamed(ByteIOContext *s) +{ + return s->is_streamed; +} + +int url_fdopen(ByteIOContext *s, URLContext *h); + +/** @warning must be called before any I/O */ +int url_setbufsize(ByteIOContext *s, int buf_size); + +/** @note when opened as read/write, the buffers are only used for + reading */ +int url_fopen(ByteIOContext *s, const char *filename, int flags); +int url_fclose(ByteIOContext *s); +URLContext *url_fileno(ByteIOContext *s); + +/** + * Return the maximum packet size associated to packetized buffered file + * handle. If the file is not packetized (stream like http or file on + * disk), then 0 is returned. + * + * @param h buffered file handle + * @return maximum packet size in bytes + */ +int url_fget_max_packet_size(ByteIOContext *s); + +int url_open_buf(ByteIOContext *s, uint8_t *buf, int buf_size, int flags); + +/** return the written or read size */ +int url_close_buf(ByteIOContext *s); + +/** + * Open a write only memory stream. + * + * @param s new IO context + * @return zero if no error. + */ +int url_open_dyn_buf(ByteIOContext *s); + +/** + * Open a write only packetized memory stream with a maximum packet + * size of 'max_packet_size'. The stream is stored in a memory buffer + * with a big endian 4 byte header giving the packet size in bytes. + * + * @param s new IO context + * @param max_packet_size maximum packet size (must be > 0) + * @return zero if no error. + */ +int url_open_dyn_packet_buf(ByteIOContext *s, int max_packet_size); + +/** + * Return the written size and a pointer to the buffer. The buffer + * must be freed with av_free(). + * @param s IO context + * @param pointer to a byte buffer + * @return the length of the byte buffer + */ +int url_close_dyn_buf(ByteIOContext *s, uint8_t **pbuffer); + +unsigned long get_checksum(ByteIOContext *s); +void init_checksum(ByteIOContext *s, unsigned long (*update_checksum)(unsigned long c, const uint8_t *p, unsigned int len), unsigned long checksum); + +/* file.c */ +extern URLProtocol file_protocol; +extern URLProtocol pipe_protocol; + +/* udp.c */ +extern URLProtocol udp_protocol; +int udp_set_remote_url(URLContext *h, const char *uri); +int udp_get_local_port(URLContext *h); +int udp_get_file_handle(URLContext *h); + +/* tcp.c */ +extern URLProtocol tcp_protocol; + +/* http.c */ +extern URLProtocol http_protocol; + +#endif + diff --git a/src/ffmpeg/include/ffmpeg/avutil.h b/src/ffmpeg/include/ffmpeg/avutil.h new file mode 100644 index 0000000000..32bc40bfbf --- /dev/null +++ b/src/ffmpeg/include/ffmpeg/avutil.h @@ -0,0 +1,137 @@ +/* + * copyright (c) 2006 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_H +#define AVUTIL_H + +/** + * @file avutil.h + * external api header. + */ + + +#ifdef __cplusplus +extern "C" { +#endif + +#define AV_STRINGIFY(s) AV_TOSTRING(s) +#define AV_TOSTRING(s) #s + +#define LIBAVUTIL_VERSION_INT ((49<<16)+(4<<8)+0) +#define LIBAVUTIL_VERSION 49.4.0 +#define LIBAVUTIL_BUILD LIBAVUTIL_VERSION_INT + +#define LIBAVUTIL_IDENT "Lavu" AV_STRINGIFY(LIBAVUTIL_VERSION) + + +#include "common.h" +#include "mathematics.h" +#include "rational.h" +#include "integer.h" +#include "intfloat_readwrite.h" +#include "log.h" + +/** + * Pixel format. Notes: + * + * PIX_FMT_RGB32 is handled in an endian-specific manner. A RGBA + * color is put together as: + * (A << 24) | (R << 16) | (G << 8) | B + * This is stored as BGRA on little endian CPU architectures and ARGB on + * big endian CPUs. + * + * When the pixel format is palettized RGB (PIX_FMT_PAL8), the palettized + * image data is stored in AVFrame.data[0]. The palette is transported in + * AVFrame.data[1] and, is 1024 bytes long (256 4-byte entries) and is + * formatted the same as in PIX_FMT_RGB32 described above (i.e., it is + * also endian-specific). Note also that the individual RGB palette + * components stored in AVFrame.data[1] should be in the range 0..255. + * This is important as many custom PAL8 video codecs that were designed + * to run on the IBM VGA graphics adapter use 6-bit palette components. + */ +enum PixelFormat { + PIX_FMT_NONE= -1, + PIX_FMT_YUV420P, ///< Planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples) + PIX_FMT_YUYV422, ///< Packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr + PIX_FMT_RGB24, ///< Packed RGB 8:8:8, 24bpp, RGBRGB... + PIX_FMT_BGR24, ///< Packed RGB 8:8:8, 24bpp, BGRBGR... + PIX_FMT_YUV422P, ///< Planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples) + PIX_FMT_YUV444P, ///< Planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples) + PIX_FMT_RGB32, ///< Packed RGB 8:8:8, 32bpp, (msb)8A 8R 8G 8B(lsb), in cpu endianness + PIX_FMT_YUV410P, ///< Planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples) + PIX_FMT_YUV411P, ///< Planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) + PIX_FMT_RGB565, ///< Packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), in cpu endianness + PIX_FMT_RGB555, ///< Packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), in cpu endianness most significant bit to 0 + PIX_FMT_GRAY8, ///< Y , 8bpp + PIX_FMT_MONOWHITE, ///< Y , 1bpp, 1 is white + PIX_FMT_MONOBLACK, ///< Y , 1bpp, 0 is black + PIX_FMT_PAL8, ///< 8 bit with PIX_FMT_RGB32 palette + PIX_FMT_YUVJ420P, ///< Planar YUV 4:2:0, 12bpp, full scale (jpeg) + PIX_FMT_YUVJ422P, ///< Planar YUV 4:2:2, 16bpp, full scale (jpeg) + PIX_FMT_YUVJ444P, ///< Planar YUV 4:4:4, 24bpp, full scale (jpeg) + PIX_FMT_XVMC_MPEG2_MC,///< XVideo Motion Acceleration via common packet passing(xvmc_render.h) + PIX_FMT_XVMC_MPEG2_IDCT, + PIX_FMT_UYVY422, ///< Packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1 + PIX_FMT_UYYVYY411, ///< Packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3 + PIX_FMT_BGR32, ///< Packed RGB 8:8:8, 32bpp, (msb)8A 8B 8G 8R(lsb), in cpu endianness + PIX_FMT_BGR565, ///< Packed RGB 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), in cpu endianness + PIX_FMT_BGR555, ///< Packed RGB 5:5:5, 16bpp, (msb)1A 5B 5G 5R(lsb), in cpu endianness most significant bit to 1 + PIX_FMT_BGR8, ///< Packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb) + PIX_FMT_BGR4, ///< Packed RGB 1:2:1, 4bpp, (msb)1B 2G 1R(lsb) + PIX_FMT_BGR4_BYTE, ///< Packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb) + PIX_FMT_RGB8, ///< Packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb) + PIX_FMT_RGB4, ///< Packed RGB 1:2:1, 4bpp, (msb)2R 3G 3B(lsb) + PIX_FMT_RGB4_BYTE, ///< Packed RGB 1:2:1, 8bpp, (msb)2R 3G 3B(lsb) + PIX_FMT_NV12, ///< Planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 for UV + PIX_FMT_NV21, ///< as above, but U and V bytes are swapped + + PIX_FMT_RGB32_1, ///< Packed RGB 8:8:8, 32bpp, (msb)8R 8G 8B 8A(lsb), in cpu endianness + PIX_FMT_BGR32_1, ///< Packed RGB 8:8:8, 32bpp, (msb)8B 8G 8R 8A(lsb), in cpu endianness + + PIX_FMT_GRAY16BE, ///< Y , 16bpp, big-endian + PIX_FMT_GRAY16LE, ///< Y , 16bpp, little-endian + PIX_FMT_NB, ///< number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions +}; + +#ifdef WORDS_BIGENDIAN +#define PIX_FMT_RGBA PIX_FMT_RGB32_1 +#define PIX_FMT_BGRA PIX_FMT_BGR32_1 +#define PIX_FMT_ARGB PIX_FMT_RGB32 +#define PIX_FMT_ABGR PIX_FMT_BGR32 +#define PIX_FMT_GRAY16 PIX_FMT_GRAY16BE +#else +#define PIX_FMT_RGBA PIX_FMT_BGR32 +#define PIX_FMT_BGRA PIX_FMT_RGB32 +#define PIX_FMT_ARGB PIX_FMT_BGR32_1 +#define PIX_FMT_ABGR PIX_FMT_RGB32_1 +#define PIX_FMT_GRAY16 PIX_FMT_GRAY16LE +#endif + +#if LIBAVUTIL_VERSION_INT < (50<<16) +#define PIX_FMT_UYVY411 PIX_FMT_UYYVYY411 +#define PIX_FMT_RGBA32 PIX_FMT_RGB32 +#define PIX_FMT_YUV422 PIX_FMT_YUYV422 +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* AVUTIL_H */ diff --git a/src/ffmpeg/include/ffmpeg/common.h b/src/ffmpeg/include/ffmpeg/common.h new file mode 100644 index 0000000000..07c4276faf --- /dev/null +++ b/src/ffmpeg/include/ffmpeg/common.h @@ -0,0 +1,328 @@ +/* + * copyright (c) 2006 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file common.h + * common internal and external api header. + */ + +#ifndef COMMON_H +#define COMMON_H + +#if 0 +#include +#endif + +#ifdef HAVE_AV_CONFIG_H +/* only include the following when compiling package */ +# include "config.h" + +# include +# include +# include +# include +# include +# include +# include +#endif /* HAVE_AV_CONFIG_H */ + +#ifndef av_always_inline +#if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0) +# define av_always_inline __attribute__((always_inline)) inline +# define av_noinline __attribute__((noinline)) +#else +# define av_always_inline inline +# define av_noinline +#endif +#endif + +#ifdef HAVE_AV_CONFIG_H +# include "internal.h" +#endif /* HAVE_AV_CONFIG_H */ + +#ifndef attribute_deprecated +#if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0) +# define attribute_deprecated __attribute__((deprecated)) +#else +# define attribute_deprecated +#endif +#endif + +#include "mem.h" + +//rounded divison & shift +#define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b)) +/* assume b>0 */ +#define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b)) +#define FFABS(a) ((a) >= 0 ? (a) : (-(a))) +#define FFSIGN(a) ((a) > 0 ? 1 : -1) + +#define FFMAX(a,b) ((a) > (b) ? (a) : (b)) +#define FFMIN(a,b) ((a) > (b) ? (b) : (a)) + +#define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0) + +/* misc math functions */ +extern const uint8_t ff_log2_tab[256]; + +static inline int av_log2(unsigned int v) +{ + int n; + + n = 0; + if (v & 0xffff0000) { + v >>= 16; + n += 16; + } + if (v & 0xff00) { + v >>= 8; + n += 8; + } + n += ff_log2_tab[v]; + + return n; +} + +static inline int av_log2_16bit(unsigned int v) +{ + int n; + + n = 0; + if (v & 0xff00) { + v >>= 8; + n += 8; + } + n += ff_log2_tab[v]; + + return n; +} + +/* median of 3 */ +static inline int mid_pred(int a, int b, int c) +{ +#ifdef HAVE_CMOV + int i=b; + asm volatile( + "cmp %2, %1 \n\t" + "cmovg %1, %0 \n\t" + "cmovg %2, %1 \n\t" + "cmp %3, %1 \n\t" + "cmovl %3, %1 \n\t" + "cmp %1, %0 \n\t" + "cmovg %1, %0 \n\t" + :"+&r"(i), "+&r"(a) + :"r"(b), "r"(c) + ); + return i; +#elif 0 + int t= (a-b)&((a-b)>>31); + a-=t; + b+=t; + b-= (b-c)&((b-c)>>31); + b+= (a-b)&((a-b)>>31); + + return b; +#else + if(a>b){ + if(c>b){ + if(c>a) b=a; + else b=c; + } + }else{ + if(b>c){ + if(c>a) b=c; + else b=a; + } + } + return b; +#endif +} + +/** + * clip a signed integer value into the amin-amax range + * @param a value to clip + * @param amin minimum value of the clip range + * @param amax maximum value of the clip range + * @return clipped value + */ +static inline int av_clip(int a, int amin, int amax) +{ + if (a < amin) return amin; + else if (a > amax) return amax; + else return a; +} + +/** + * clip a signed integer value into the 0-255 range + * @param a value to clip + * @return clipped value + */ +static inline uint8_t av_clip_uint8(int a) +{ + if (a&(~255)) return (-a)>>31; + else return a; +} + +/* math */ +int64_t ff_gcd(int64_t a, int64_t b); + +/** + * converts fourcc string to int + */ +static inline int ff_get_fourcc(const char *s){ +#ifdef HAVE_AV_CONFIG_H + assert( strlen(s)==4 ); +#endif + + return (s[0]) + (s[1]<<8) + (s[2]<<16) + (s[3]<<24); +} + +#define MKTAG(a,b,c,d) (a | (b << 8) | (c << 16) | (d << 24)) +#define MKBETAG(a,b,c,d) (d | (c << 8) | (b << 16) | (a << 24)) + +/*! + * \def GET_UTF8(val, GET_BYTE, ERROR) + * converts a utf-8 character (up to 4 bytes long) to its 32-bit ucs-4 encoded form + * \param val is the output and should be of type uint32_t. It holds the converted + * ucs-4 character and should be a left value. + * \param GET_BYTE gets utf-8 encoded bytes from any proper source. It can be + * a function or a statement whose return value or evaluated value is of type + * uint8_t. It will be executed up to 4 times for values in the valid utf-8 range, + * and up to 7 times in the general case. + * \param ERROR action that should be taken when an invalid utf-8 byte is returned + * from GET_BYTE. It should be a statement that jumps out of the macro, + * like exit(), goto, return, break, or continue. + */ +#define GET_UTF8(val, GET_BYTE, ERROR)\ + val= GET_BYTE;\ + {\ + int ones= 7 - av_log2(val ^ 255);\ + if(ones==1)\ + ERROR\ + val&= 127>>ones;\ + while(--ones > 0){\ + int tmp= GET_BYTE - 128;\ + if(tmp>>6)\ + ERROR\ + val= (val<<6) + tmp;\ + }\ + } + +/*! + * \def PUT_UTF8(val, tmp, PUT_BYTE) + * converts a 32-bit unicode character to its utf-8 encoded form (up to 4 bytes long). + * \param val is an input only argument and should be of type uint32_t. It holds + * a ucs4 encoded unicode character that is to be converted to utf-8. If + * val is given as a function it's executed only once. + * \param tmp is a temporary variable and should be of type uint8_t. It + * represents an intermediate value during conversion that is to be + * outputted by PUT_BYTE. + * \param PUT_BYTE writes the converted utf-8 bytes to any proper destination. + * It could be a function or a statement, and uses tmp as the input byte. + * For example, PUT_BYTE could be "*output++ = tmp;" PUT_BYTE will be + * executed up to 4 times for values in the valid utf-8 range and up to + * 7 times in the general case, depending on the length of the converted + * unicode character. + */ +#define PUT_UTF8(val, tmp, PUT_BYTE)\ + {\ + int bytes, shift;\ + uint32_t in = val;\ + if (in < 0x80) {\ + tmp = in;\ + PUT_BYTE\ + } else {\ + bytes = (av_log2(in) + 4) / 5;\ + shift = (bytes - 1) * 6;\ + tmp = (256 - (256 >> bytes)) | (in >> shift);\ + PUT_BYTE\ + while (shift >= 6) {\ + shift -= 6;\ + tmp = 0x80 | ((in >> shift) & 0x3f);\ + PUT_BYTE\ + }\ + }\ + } + +#if defined(ARCH_X86) || defined(ARCH_POWERPC) +#if defined(ARCH_X86_64) +static inline uint64_t read_time(void) +{ + uint64_t a, d; + asm volatile( "rdtsc\n\t" + : "=a" (a), "=d" (d) + ); + return (d << 32) | (a & 0xffffffff); +} +#elif defined(ARCH_X86_32) +static inline long long read_time(void) +{ + long long l; + asm volatile( "rdtsc\n\t" + : "=A" (l) + ); + return l; +} +#else //FIXME check ppc64 +static inline uint64_t read_time(void) +{ + uint32_t tbu, tbl, temp; + + /* from section 2.2.1 of the 32-bit PowerPC PEM */ + __asm__ __volatile__( + "1:\n" + "mftbu %2\n" + "mftb %0\n" + "mftbu %1\n" + "cmpw %2,%1\n" + "bne 1b\n" + : "=r"(tbl), "=r"(tbu), "=r"(temp) + : + : "cc"); + + return (((uint64_t)tbu)<<32) | (uint64_t)tbl; +} +#endif + +#define START_TIMER \ +uint64_t tend;\ +uint64_t tstart= read_time();\ + +#define STOP_TIMER(id) \ +tend= read_time();\ +{\ + static uint64_t tsum=0;\ + static int tcount=0;\ + static int tskip_count=0;\ + if(tcount<2 || tend - tstart < FFMAX(8*tsum/tcount, 2000)){\ + tsum+= tend - tstart;\ + tcount++;\ + }else\ + tskip_count++;\ + if(((tcount+tskip_count)&(tcount+tskip_count-1))==0){\ + av_log(NULL, AV_LOG_DEBUG, "%"PRIu64" dezicycles in %s, %d runs, %d skips\n", tsum*10/tcount, id, tcount, tskip_count);\ + }\ +} +#else +#define START_TIMER +#define STOP_TIMER(id) {} +#endif + +#endif /* COMMON_H */ diff --git a/src/ffmpeg/include/ffmpeg/integer.h b/src/ffmpeg/include/ffmpeg/integer.h new file mode 100644 index 0000000000..2a4d703166 --- /dev/null +++ b/src/ffmpeg/include/ffmpeg/integer.h @@ -0,0 +1,82 @@ +/* + * arbitrary precision integers + * Copyright (c) 2004 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +/** + * @file integer.h + * arbitrary precision integers + * @author Michael Niedermayer + */ + +#ifndef INTEGER_H +#define INTEGER_H + +#define AV_INTEGER_SIZE 8 + +typedef struct AVInteger{ + uint16_t v[AV_INTEGER_SIZE]; +} AVInteger; + +AVInteger av_add_i(AVInteger a, AVInteger b); +AVInteger av_sub_i(AVInteger a, AVInteger b); + +/** + * returns the rounded down value of the logarithm of base 2 of the given AVInteger. + * this is simply the index of the most significant bit which is 1. Or 0 of all bits are 0 + */ +int av_log2_i(AVInteger a); +AVInteger av_mul_i(AVInteger a, AVInteger b); + +/** + * returns 0 if a==b, 1 if a>b and -1 if a + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef INTFLOAT_READWRITE_H +#define INTFLOAT_READWRITE_H + +#include "common.h" + +/* IEEE 80 bits extended float */ +typedef struct AVExtFloat { + uint8_t exponent[2]; + uint8_t mantissa[8]; +} AVExtFloat; + +double av_int2dbl(int64_t v); +float av_int2flt(int32_t v); +double av_ext2dbl(const AVExtFloat ext); +int64_t av_dbl2int(double d); +int32_t av_flt2int(float d); +AVExtFloat av_dbl2ext(double d); + +#endif /* INTFLOAT_READWRITE_H */ diff --git a/src/ffmpeg/include/ffmpeg/log.h b/src/ffmpeg/include/ffmpeg/log.h new file mode 100644 index 0000000000..fa88f5fb25 --- /dev/null +++ b/src/ffmpeg/include/ffmpeg/log.h @@ -0,0 +1,116 @@ +/* + * copyright (c) 2006 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef LOG_H +#define LOG_H + +#include + +/** + * Used by av_log + */ +typedef struct AVCLASS AVClass; +struct AVCLASS { + const char* class_name; + const char* (*item_name)(void*); /* actually passing a pointer to an AVCodecContext + or AVFormatContext, which begin with an AVClass. + Needed because av_log is in libavcodec and has no visibility + of AVIn/OutputFormat */ + const struct AVOption *option; +}; + +/* av_log API */ + +#if LIBAVUTIL_VERSION_INT < (50<<16) +#define AV_LOG_QUIET -1 +#define AV_LOG_FATAL 0 +#define AV_LOG_ERROR 0 +#define AV_LOG_WARNING 1 +#define AV_LOG_INFO 1 +#define AV_LOG_VERBOSE 1 +#define AV_LOG_DEBUG 2 +#else +#define AV_LOG_QUIET -8 + +/** + * something went really wrong and we will crash now + */ +#define AV_LOG_PANIC 0 + +/** + * something went wrong and recovery is not possible + * like no header in a format which depends on it or a combination + * of parameters which are not allowed + */ +#define AV_LOG_FATAL 8 + +/** + * something went wrong and cannot losslessly be recovered + * but not all future data is affected + */ +#define AV_LOG_ERROR 16 + +/** + * something somehow does not look correct / something which may or may not + * lead to some problems like use of -vstrict -2 + */ +#define AV_LOG_WARNING 24 + +#define AV_LOG_INFO 32 +#define AV_LOG_VERBOSE 40 + +/** + * stuff which is only useful for libav* developers + */ +#define AV_LOG_DEBUG 48 +#endif +extern int av_log_level; + +/** + * Send the specified message to the log if the level is less than or equal to + * the current av_log_level. By default, all logging messages are sent to + * stderr. This behavior can be altered by setting a different av_vlog callback + * function. + * + * @param avcl A pointer to an arbitrary struct of which the first field is a + * pointer to an AVClass struct. + * @param level The importance level of the message, lower values signifying + * higher importance. + * @param fmt The format string (printf-compatible) that specifies how + * subsequent arguments are converted to output. + * @see av_vlog + */ +#ifdef __GNUC__ +extern void av_log(void*, int level, const char *fmt, ...) __attribute__ ((__format__ (__printf__, 3, 4))); +#else +extern void av_log(void*, int level, const char *fmt, ...); +#endif + +#if LIBAVUTIL_VERSION_INT < (50<<16) +extern void av_vlog(void*, int level, const char *fmt, va_list); +extern int av_log_get_level(void); +extern void av_log_set_level(int); +extern void av_log_set_callback(void (*)(void*, int, const char*, va_list)); +extern void av_log_default_callback(void* ptr, int level, const char* fmt, va_list vl); +#else +extern void (*av_vlog)(void*, int, const char*, va_list); +#endif + +#endif /* LOG_H */ diff --git a/src/ffmpeg/include/ffmpeg/mathematics.h b/src/ffmpeg/include/ffmpeg/mathematics.h new file mode 100644 index 0000000000..0b74b254b9 --- /dev/null +++ b/src/ffmpeg/include/ffmpeg/mathematics.h @@ -0,0 +1,51 @@ +/* + * copyright (c) 2005 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef MATHEMATICS_H +#define MATHEMATICS_H + +#include "rational.h" + +enum AVRounding { + AV_ROUND_ZERO = 0, ///< round toward zero + AV_ROUND_INF = 1, ///< round away from zero + AV_ROUND_DOWN = 2, ///< round toward -infinity + AV_ROUND_UP = 3, ///< round toward +infinity + AV_ROUND_NEAR_INF = 5, ///< round to nearest and halfway cases away from zero +}; + +/** + * rescale a 64bit integer with rounding to nearest. + * a simple a*b/c isn't possible as it can overflow + */ +int64_t av_rescale(int64_t a, int64_t b, int64_t c); + +/** + * rescale a 64bit integer with specified rounding. + * a simple a*b/c isn't possible as it can overflow + */ +int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding); + +/** + * rescale a 64bit integer by 2 rational numbers. + */ +int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq); + +#endif /* MATHEMATICS_H */ diff --git a/src/ffmpeg/include/ffmpeg/mem.h b/src/ffmpeg/include/ffmpeg/mem.h new file mode 100644 index 0000000000..4ebdad8f57 --- /dev/null +++ b/src/ffmpeg/include/ffmpeg/mem.h @@ -0,0 +1,65 @@ +/* + * copyright (c) 2006 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file mem.h + * Memory handling functions. + */ + +#ifndef AV_MEM_H +#define AV_MEM_H + +#ifdef __GNUC__ + #define DECLARE_ALIGNED(n,t,v) t v __attribute__ ((aligned (n))) +#else + #define DECLARE_ALIGNED(n,t,v) __declspec(align(n)) t v +#endif + +/** + * Memory allocation of size byte with alignment suitable for all + * memory accesses (including vectors if available on the + * CPU). av_malloc(0) must return a non NULL pointer. + */ +void *av_malloc(unsigned int size); + +/** + * av_realloc semantics (same as glibc): if ptr is NULL and size > 0, + * identical to malloc(size). If size is zero, it is identical to + * free(ptr) and NULL is returned. + */ +void *av_realloc(void *ptr, unsigned int size); + +/** + * Free memory which has been allocated with av_malloc(z)() or av_realloc(). + * NOTE: ptr = NULL is explicetly allowed + * Note2: it is recommended that you use av_freep() instead + */ +void av_free(void *ptr); + +void *av_mallocz(unsigned int size); +char *av_strdup(const char *s); + +/** + * Frees memory and sets the pointer to NULL. + * @param ptr pointer to the pointer which should be freed + */ +void av_freep(void *ptr); + +#endif /* AV_MEM_H */ diff --git a/src/ffmpeg/include/ffmpeg/rational.h b/src/ffmpeg/include/ffmpeg/rational.h new file mode 100644 index 0000000000..63c0b150f2 --- /dev/null +++ b/src/ffmpeg/include/ffmpeg/rational.h @@ -0,0 +1,114 @@ +/* + * Rational numbers + * Copyright (c) 2003 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +/** + * @file rational.h + * Rational numbers. + * @author Michael Niedermayer + */ + +#ifndef RATIONAL_H +#define RATIONAL_H + +/** + * Rational number num/den. + */ +typedef struct AVRational{ + int num; ///< numerator + int den; ///< denominator +} AVRational; + +/** + * Compare two rationals. + * @param a first rational + * @param b second rational + * @return 0 if a==b, 1 if a>b and -1 if a>63)|1; + else return 0; +} + +/** + * Rational to double conversion. + * @param a rational to convert + * @return (double) a + */ +static inline double av_q2d(AVRational a){ + return a.num / (double) a.den; +} + +/** + * Reduce a fraction. + * This is useful for framerate calculations. + * @param dst_nom destination numerator + * @param dst_den destination denominator + * @param nom source numerator + * @param den source denominator + * @param max the maximum allowed for dst_nom & dst_den + * @return 1 if exact, 0 otherwise + */ +int av_reduce(int *dst_nom, int *dst_den, int64_t nom, int64_t den, int64_t max); + +/** + * Multiplies two rationals. + * @param b first rational. + * @param c second rational. + * @return b*c. + */ +AVRational av_mul_q(AVRational b, AVRational c); + +/** + * Divides one rational by another. + * @param b first rational. + * @param c second rational. + * @return b/c. + */ +AVRational av_div_q(AVRational b, AVRational c); + +/** + * Adds two rationals. + * @param b first rational. + * @param c second rational. + * @return b+c. + */ +AVRational av_add_q(AVRational b, AVRational c); + +/** + * Subtracts one rational from another. + * @param b first rational. + * @param c second rational. + * returns b-c. + */ +AVRational av_sub_q(AVRational b, AVRational c); + +/** + * Converts a double precision floating point number to a rational. + * @param d double to convert + * @param max the maximum allowed numerator and denominator + * @return (AVRational) d. + */ +AVRational av_d2q(double d, int max); + +#endif // RATIONAL_H diff --git a/src/ffmpeg/include/ffmpeg/rtp.h b/src/ffmpeg/include/ffmpeg/rtp.h new file mode 100644 index 0000000000..fec7630517 --- /dev/null +++ b/src/ffmpeg/include/ffmpeg/rtp.h @@ -0,0 +1,127 @@ +/* + * RTP definitions + * Copyright (c) 2002 Fabrice Bellard. + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +#ifndef RTP_H +#define RTP_H + +#define RTP_MIN_PACKET_LENGTH 12 +#define RTP_MAX_PACKET_LENGTH 1500 /* XXX: suppress this define */ + +int rtp_init(void); +int rtp_get_codec_info(AVCodecContext *codec, int payload_type); + +/** return < 0 if unknown payload type */ +int rtp_get_payload_type(AVCodecContext *codec); + +typedef struct RTPDemuxContext RTPDemuxContext; +typedef struct rtp_payload_data_s rtp_payload_data_s; +RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, rtp_payload_data_s *rtp_payload_data); +int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt, + const uint8_t *buf, int len); +void rtp_parse_close(RTPDemuxContext *s); + +extern AVOutputFormat rtp_muxer; +extern AVInputFormat rtp_demuxer; + +int rtp_get_local_port(URLContext *h); +int rtp_set_remote_url(URLContext *h, const char *uri); +void rtp_get_file_handles(URLContext *h, int *prtp_fd, int *prtcp_fd); + +/** + * some rtp servers assume client is dead if they don't hear from them... + * so we send a Receiver Report to the provided ByteIO context + * (we don't have access to the rtcp handle from here) + */ +int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count); + +extern URLProtocol rtp_protocol; + +#define RTP_PT_PRIVATE 96 +#define RTP_VERSION 2 +#define RTP_MAX_SDES 256 /**< maximum text length for SDES */ + +/* RTCP paquets use 0.5 % of the bandwidth */ +#define RTCP_TX_RATIO_NUM 5 +#define RTCP_TX_RATIO_DEN 1000 + +/** Structure listing useful vars to parse RTP packet payload*/ +typedef struct rtp_payload_data_s +{ + int sizelength; + int indexlength; + int indexdeltalength; + int profile_level_id; + int streamtype; + int objecttype; + char *mode; + + /** mpeg 4 AU headers */ + struct AUHeaders { + int size; + int index; + int cts_flag; + int cts; + int dts_flag; + int dts; + int rap_flag; + int streamstate; + } *au_headers; + int nb_au_headers; + int au_headers_length_bytes; + int cur_au_index; +} rtp_payload_data_t; + +typedef struct AVRtpPayloadType_s +{ + int pt; + const char enc_name[50]; /* XXX: why 50 ? */ + enum CodecType codec_type; + enum CodecID codec_id; + int clock_rate; + int audio_channels; +} AVRtpPayloadType_t; + +#if 0 +typedef enum { + RTCP_SR = 200, + RTCP_RR = 201, + RTCP_SDES = 202, + RTCP_BYE = 203, + RTCP_APP = 204 +} rtcp_type_t; + +typedef enum { + RTCP_SDES_END = 0, + RTCP_SDES_CNAME = 1, + RTCP_SDES_NAME = 2, + RTCP_SDES_EMAIL = 3, + RTCP_SDES_PHONE = 4, + RTCP_SDES_LOC = 5, + RTCP_SDES_TOOL = 6, + RTCP_SDES_NOTE = 7, + RTCP_SDES_PRIV = 8, + RTCP_SDES_IMG = 9, + RTCP_SDES_DOOR = 10, + RTCP_SDES_SOURCE = 11 +} rtcp_sdes_type_t; +#endif + +extern AVRtpPayloadType_t AVRtpPayloadTypes[]; +#endif /* RTP_H */ diff --git a/src/ffmpeg/include/ffmpeg/rtsp.h b/src/ffmpeg/include/ffmpeg/rtsp.h new file mode 100644 index 0000000000..481e2ba499 --- /dev/null +++ b/src/ffmpeg/include/ffmpeg/rtsp.h @@ -0,0 +1,94 @@ +/* + * RTSP definitions + * Copyright (c) 2002 Fabrice Bellard. + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +#ifndef RTSP_H +#define RTSP_H + +#include "rtspcodes.h" + +enum RTSPProtocol { + RTSP_PROTOCOL_RTP_UDP = 0, + RTSP_PROTOCOL_RTP_TCP = 1, + RTSP_PROTOCOL_RTP_UDP_MULTICAST = 2, +}; + +#define RTSP_DEFAULT_PORT 554 +#define RTSP_MAX_TRANSPORTS 8 +#define RTSP_TCP_MAX_PACKET_SIZE 1472 +#define RTSP_DEFAULT_NB_AUDIO_CHANNELS 2 +#define RTSP_DEFAULT_AUDIO_SAMPLERATE 44100 +#define RTSP_RTP_PORT_MIN 5000 +#define RTSP_RTP_PORT_MAX 10000 + +typedef struct RTSPTransportField { + int interleaved_min, interleaved_max; /**< interleave ids, if TCP transport */ + int port_min, port_max; /**< RTP ports */ + int client_port_min, client_port_max; /**< RTP ports */ + int server_port_min, server_port_max; /**< RTP ports */ + int ttl; /**< ttl value */ + uint32_t destination; /**< destination IP address */ + enum RTSPProtocol protocol; +} RTSPTransportField; + +typedef struct RTSPHeader { + int content_length; + enum RTSPStatusCode status_code; /**< response code from server */ + int nb_transports; + /** in AV_TIME_BASE unit, AV_NOPTS_VALUE if not used */ + int64_t range_start, range_end; + RTSPTransportField transports[RTSP_MAX_TRANSPORTS]; + int seq; /**< sequence number */ + char session_id[512]; +} RTSPHeader; + +/** the callback can be used to extend the connection setup/teardown step */ +enum RTSPCallbackAction { + RTSP_ACTION_SERVER_SETUP, + RTSP_ACTION_SERVER_TEARDOWN, + RTSP_ACTION_CLIENT_SETUP, + RTSP_ACTION_CLIENT_TEARDOWN, +}; + +typedef struct RTSPActionServerSetup { + uint32_t ipaddr; + char transport_option[512]; +} RTSPActionServerSetup; + +typedef int FFRTSPCallback(enum RTSPCallbackAction action, + const char *session_id, + char *buf, int buf_size, + void *arg); + +/** useful for modules: set RTSP callback function */ +void rtsp_set_callback(FFRTSPCallback *rtsp_cb); + +int rtsp_init(void); +void rtsp_parse_line(RTSPHeader *reply, const char *buf); + +extern int rtsp_default_protocols; +extern int rtsp_rtp_port_min; +extern int rtsp_rtp_port_max; +extern FFRTSPCallback *ff_rtsp_callback; +extern AVInputFormat rtsp_demuxer; + +int rtsp_pause(AVFormatContext *s); +int rtsp_resume(AVFormatContext *s); + +#endif /* RTSP_H */ diff --git a/src/ffmpeg/include/ffmpeg/rtspcodes.h b/src/ffmpeg/include/ffmpeg/rtspcodes.h new file mode 100644 index 0000000000..74cfb5d5b9 --- /dev/null +++ b/src/ffmpeg/include/ffmpeg/rtspcodes.h @@ -0,0 +1,36 @@ +/* + * RTSP definitions + * copyright (c) 2002 Fabrice Bellard + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** RTSP handling */ +enum RTSPStatusCode { +RTSP_STATUS_OK =200, /**< OK */ +RTSP_STATUS_METHOD =405, /**< Method Not Allowed */ +RTSP_STATUS_BANDWIDTH =453, /**< Not Enough Bandwidth */ +RTSP_STATUS_SESSION =454, /**< Session Not Found */ +RTSP_STATUS_STATE =455, /**< Method Not Valid in This State */ +RTSP_STATUS_AGGREGATE =459, /**< Aggregate operation not allowed */ +RTSP_STATUS_ONLY_AGGREGATE =460, /**< Only aggregate operation allowed */ +RTSP_STATUS_TRANSPORT =461, /**< Unsupported transport */ +RTSP_STATUS_INTERNAL =500, /**< Internal Server Error */ +RTSP_STATUS_SERVICE =503, /**< Service Unavailable */ +RTSP_STATUS_VERSION =505, /**< RTSP Version not supported */ +}; + diff --git a/src/ffmpeg/lib/avcodec.lib b/src/ffmpeg/lib/avcodec.lib new file mode 100644 index 0000000000000000000000000000000000000000..ec51531a818c767d9b95d63fec36853695ec8832 GIT binary patch literal 97486 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