/*
* 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 AVCODEC_AVCODEC_H
# define AVCODEC_AVCODEC_H
/**
* @ file
* @ ingroup libavc
* Libavcodec external API header
*/
# include <errno.h>
# include "libavutil/samplefmt.h"
# include "libavutil/avutil.h"
# include "libavutil/buffer.h"
# include "libavutil/cpu.h"
# include "libavutil/channel_layout.h"
# include "libavutil/dict.h"
# include "libavutil/frame.h"
# include "libavutil/log.h"
# include "libavutil/pixfmt.h"
# include "libavutil/rational.h"
# include "libavcodec/version.h"
/**
* @ defgroup libavc Encoding / Decoding Library
* @ {
*
* @ defgroup lavc_decoding Decoding
* @ {
* @ }
*
* @ defgroup lavc_encoding Encoding
* @ {
* @ }
*
* @ defgroup lavc_codec Codecs
* @ {
* @ defgroup lavc_codec_native Native Codecs
* @ {
* @ }
* @ defgroup lavc_codec_wrappers External library wrappers
* @ {
* @ }
* @ defgroup lavc_codec_hwaccel Hardware Accelerators bridge
* @ {
* @ }
* @ }
* @ defgroup lavc_internal Internal
* @ {
* @ }
* @ }
*
*/
/**
* @ defgroup lavc_core Core functions / structures .
* @ ingroup libavc
*
* Basic definitions , functions for querying libavcodec capabilities ,
* allocating core structures , etc .
* @ {
*/
/**
* Identify the syntax and semantics of the bitstream .
* The principle is roughly :
* Two decoders with the same ID can decode the same streams .
* Two encoders with the same ID can encode compatible streams .
* There may be slight deviations from the principle due to implementation
* details .
*
* If you add a codec ID to this list , add it so that
* 1. no value of a existing codec ID changes ( that would break ABI ) ,
* 2. Give it a value which when taken as ASCII is recognized uniquely by a human as this specific codec .
* This ensures that 2 forks can independently add AVCodecIDs without producing conflicts .
*
* After adding new codec IDs , do not forget to add an entry to the codec
* descriptor list and bump libavcodec minor version .
*/
enum AVCodecID {
AV_CODEC_ID_NONE ,
/* video codecs */
AV_CODEC_ID_MPEG1VIDEO ,
AV_CODEC_ID_MPEG2VIDEO , ///< preferred ID for MPEG-1/2 video decoding
AV_CODEC_ID_MPEG2VIDEO_XVMC ,
AV_CODEC_ID_H261 ,
AV_CODEC_ID_H263 ,
AV_CODEC_ID_RV10 ,
AV_CODEC_ID_RV20 ,
AV_CODEC_ID_MJPEG ,
AV_CODEC_ID_MJPEGB ,
AV_CODEC_ID_LJPEG ,
AV_CODEC_ID_SP5X ,
AV_CODEC_ID_JPEGLS ,
AV_CODEC_ID_MPEG4 ,
AV_CODEC_ID_RAWVIDEO ,
AV_CODEC_ID_MSMPEG4V1 ,
AV_CODEC_ID_MSMPEG4V2 ,
AV_CODEC_ID_MSMPEG4V3 ,
AV_CODEC_ID_WMV1 ,
AV_CODEC_ID_WMV2 ,
AV_CODEC_ID_H263P ,
AV_CODEC_ID_H263I ,
AV_CODEC_ID_FLV1 ,
AV_CODEC_ID_SVQ1 ,
AV_CODEC_ID_SVQ3 ,
AV_CODEC_ID_DVVIDEO ,
AV_CODEC_ID_HUFFYUV ,
AV_CODEC_ID_CYUV ,
AV_CODEC_ID_H264 ,
AV_CODEC_ID_INDEO3 ,
AV_CODEC_ID_VP3 ,
AV_CODEC_ID_THEORA ,
AV_CODEC_ID_ASV1 ,
AV_CODEC_ID_ASV2 ,
AV_CODEC_ID_FFV1 ,
AV_CODEC_ID_4XM ,
AV_CODEC_ID_VCR1 ,
AV_CODEC_ID_CLJR ,
AV_CODEC_ID_MDEC ,
AV_CODEC_ID_ROQ ,
AV_CODEC_ID_INTERPLAY_VIDEO ,
AV_CODEC_ID_XAN_WC3 ,
AV_CODEC_ID_XAN_WC4 ,
AV_CODEC_ID_RPZA ,
AV_CODEC_ID_CINEPAK ,
AV_CODEC_ID_WS_VQA ,
AV_CODEC_ID_MSRLE ,
AV_CODEC_ID_MSVIDEO1 ,
AV_CODEC_ID_IDCIN ,
AV_CODEC_ID_8BPS ,
AV_CODEC_ID_SMC ,
AV_CODEC_ID_FLIC ,
AV_CODEC_ID_TRUEMOTION1 ,
AV_CODEC_ID_VMDVIDEO ,
AV_CODEC_ID_MSZH ,
AV_CODEC_ID_ZLIB ,
AV_CODEC_ID_QTRLE ,
AV_CODEC_ID_TSCC ,
AV_CODEC_ID_ULTI ,
AV_CODEC_ID_QDRAW ,
AV_CODEC_ID_VIXL ,
AV_CODEC_ID_QPEG ,
AV_CODEC_ID_PNG ,
AV_CODEC_ID_PPM ,
AV_CODEC_ID_PBM ,
AV_CODEC_ID_PGM ,
AV_CODEC_ID_PGMYUV ,
AV_CODEC_ID_PAM ,
AV_CODEC_ID_FFVHUFF ,
AV_CODEC_ID_RV30 ,
AV_CODEC_ID_RV40 ,
AV_CODEC_ID_VC1 ,
AV_CODEC_ID_WMV3 ,
AV_CODEC_ID_LOCO ,
AV_CODEC_ID_WNV1 ,
AV_CODEC_ID_AASC ,
AV_CODEC_ID_INDEO2 ,
AV_CODEC_ID_FRAPS ,
AV_CODEC_ID_TRUEMOTION2 ,
AV_CODEC_ID_BMP ,
AV_CODEC_ID_CSCD ,
AV_CODEC_ID_MMVIDEO ,
AV_CODEC_ID_ZMBV ,
AV_CODEC_ID_AVS ,
AV_CODEC_ID_SMACKVIDEO ,
AV_CODEC_ID_NUV ,
AV_CODEC_ID_KMVC ,
AV_CODEC_ID_FLASHSV ,
AV_CODEC_ID_CAVS ,
AV_CODEC_ID_JPEG2000 ,
AV_CODEC_ID_VMNC ,
AV_CODEC_ID_VP5 ,
AV_CODEC_ID_VP6 ,
AV_CODEC_ID_VP6F ,
AV_CODEC_ID_TARGA ,
AV_CODEC_ID_DSICINVIDEO ,
AV_CODEC_ID_TIERTEXSEQVIDEO ,
AV_CODEC_ID_TIFF ,
AV_CODEC_ID_GIF ,
AV_CODEC_ID_DXA ,
AV_CODEC_ID_DNXHD ,
AV_CODEC_ID_THP ,
AV_CODEC_ID_SGI ,
AV_CODEC_ID_C93 ,
AV_CODEC_ID_BETHSOFTVID ,
AV_CODEC_ID_PTX ,
AV_CODEC_ID_TXD ,
AV_CODEC_ID_VP6A ,
AV_CODEC_ID_AMV ,
AV_CODEC_ID_VB ,
AV_CODEC_ID_PCX ,
AV_CODEC_ID_SUNRAST ,
AV_CODEC_ID_INDEO4 ,
AV_CODEC_ID_INDEO5 ,
AV_CODEC_ID_MIMIC ,
AV_CODEC_ID_RL2 ,
AV_CODEC_ID_ESCAPE124 ,
AV_CODEC_ID_DIRAC ,
AV_CODEC_ID_BFI ,
AV_CODEC_ID_CMV ,
AV_CODEC_ID_MOTIONPIXELS ,
AV_CODEC_ID_TGV ,
AV_CODEC_ID_TGQ ,
AV_CODEC_ID_TQI ,
AV_CODEC_ID_AURA ,
AV_CODEC_ID_AURA2 ,
AV_CODEC_ID_V210X ,
AV_CODEC_ID_TMV ,
AV_CODEC_ID_V210 ,
AV_CODEC_ID_DPX ,
AV_CODEC_ID_MAD ,
AV_CODEC_ID_FRWU ,
AV_CODEC_ID_FLASHSV2 ,
AV_CODEC_ID_CDGRAPHICS ,
AV_CODEC_ID_R210 ,
AV_CODEC_ID_ANM ,
AV_CODEC_ID_BINKVIDEO ,
AV_CODEC_ID_IFF_ILBM ,
AV_CODEC_ID_IFF_BYTERUN1 ,
AV_CODEC_ID_KGV1 ,
AV_CODEC_ID_YOP ,
AV_CODEC_ID_VP8 ,
AV_CODEC_ID_PICTOR ,
AV_CODEC_ID_ANSI ,
AV_CODEC_ID_A64_MULTI ,
AV_CODEC_ID_A64_MULTI5 ,
AV_CODEC_ID_R10K ,
AV_CODEC_ID_MXPEG ,
AV_CODEC_ID_LAGARITH ,
AV_CODEC_ID_PRORES ,
AV_CODEC_ID_JV ,
AV_CODEC_ID_DFA ,
AV_CODEC_ID_WMV3IMAGE ,
AV_CODEC_ID_VC1IMAGE ,
AV_CODEC_ID_UTVIDEO ,
AV_CODEC_ID_BMV_VIDEO ,
AV_CODEC_ID_VBLE ,
AV_CODEC_ID_DXTORY ,
AV_CODEC_ID_V410 ,
AV_CODEC_ID_XWD ,
AV_CODEC_ID_CDXL ,
AV_CODEC_ID_XBM ,
AV_CODEC_ID_ZEROCODEC ,
AV_CODEC_ID_MSS1 ,
AV_CODEC_ID_MSA1 ,
AV_CODEC_ID_TSCC2 ,
AV_CODEC_ID_MTS2 ,
AV_CODEC_ID_CLLC ,
AV_CODEC_ID_MSS2 ,
AV_CODEC_ID_VP9 ,
AV_CODEC_ID_AIC ,
AV_CODEC_ID_ESCAPE130_DEPRECATED ,
AV_CODEC_ID_G2M_DEPRECATED ,
AV_CODEC_ID_BRENDER_PIX = MKBETAG ( ' B ' , ' P ' , ' I ' , ' X ' ) ,
AV_CODEC_ID_Y41P = MKBETAG ( ' Y ' , ' 4 ' , ' 1 ' , ' P ' ) ,
AV_CODEC_ID_ESCAPE130 = MKBETAG ( ' E ' , ' 1 ' , ' 3 ' , ' 0 ' ) ,
AV_CODEC_ID_EXR = MKBETAG ( ' 0 ' , ' E ' , ' X ' , ' R ' ) ,
AV_CODEC_ID_AVRP = MKBETAG ( ' A ' , ' V ' , ' R ' , ' P ' ) ,
AV_CODEC_ID_012V = MKBETAG ( ' 0 ' , ' 1 ' , ' 2 ' , ' V ' ) ,
AV_CODEC_ID_G2M = MKBETAG ( 0 , ' G ' , ' 2 ' , ' M ' ) ,
AV_CODEC_ID_AVUI = MKBETAG ( ' A ' , ' V ' , ' U ' , ' I ' ) ,
AV_CODEC_ID_AYUV = MKBETAG ( ' A ' , ' Y ' , ' U ' , ' V ' ) ,
AV_CODEC_ID_TARGA_Y216 = MKBETAG ( ' T ' , ' 2 ' , ' 1 ' , ' 6 ' ) ,
AV_CODEC_ID_V308 = MKBETAG ( ' V ' , ' 3 ' , ' 0 ' , ' 8 ' ) ,
AV_CODEC_ID_V408 = MKBETAG ( ' V ' , ' 4 ' , ' 0 ' , ' 8 ' ) ,
AV_CODEC_ID_YUV4 = MKBETAG ( ' Y ' , ' U ' , ' V ' , ' 4 ' ) ,
AV_CODEC_ID_SANM = MKBETAG ( ' S ' , ' A ' , ' N ' , ' M ' ) ,
AV_CODEC_ID_PAF_VIDEO = MKBETAG ( ' P ' , ' A ' , ' F ' , ' V ' ) ,
AV_CODEC_ID_AVRN = MKBETAG ( ' A ' , ' V ' , ' R ' , ' n ' ) ,
AV_CODEC_ID_CPIA = MKBETAG ( ' C ' , ' P ' , ' I ' , ' A ' ) ,
AV_CODEC_ID_XFACE = MKBETAG ( ' X ' , ' F ' , ' A ' , ' C ' ) ,
AV_CODEC_ID_SGIRLE = MKBETAG ( ' S ' , ' G ' , ' I ' , ' R ' ) ,
AV_CODEC_ID_MVC1 = MKBETAG ( ' M ' , ' V ' , ' C ' , ' 1 ' ) ,
AV_CODEC_ID_MVC2 = MKBETAG ( ' M ' , ' V ' , ' C ' , ' 2 ' ) ,
AV_CODEC_ID_SNOW = MKBETAG ( ' S ' , ' N ' , ' O ' , ' W ' ) ,
AV_CODEC_ID_WEBP = MKBETAG ( ' W ' , ' E ' , ' B ' , ' P ' ) ,
AV_CODEC_ID_SMVJPEG = MKBETAG ( ' S ' , ' M ' , ' V ' , ' J ' ) ,
/* various PCM "codecs" */
AV_CODEC_ID_FIRST_AUDIO = 0x10000 , ///< A dummy id pointing at the start of audio codecs
AV_CODEC_ID_PCM_S16LE = 0x10000 ,
AV_CODEC_ID_PCM_S16BE ,
AV_CODEC_ID_PCM_U16LE ,
AV_CODEC_ID_PCM_U16BE ,
AV_CODEC_ID_PCM_S8 ,
AV_CODEC_ID_PCM_U8 ,
AV_CODEC_ID_PCM_MULAW ,
AV_CODEC_ID_PCM_ALAW ,
AV_CODEC_ID_PCM_S32LE ,
AV_CODEC_ID_PCM_S32BE ,
AV_CODEC_ID_PCM_U32LE ,
AV_CODEC_ID_PCM_U32BE ,
AV_CODEC_ID_PCM_S24LE ,
AV_CODEC_ID_PCM_S24BE ,
AV_CODEC_ID_PCM_U24LE ,
AV_CODEC_ID_PCM_U24BE ,
AV_CODEC_ID_PCM_S24DAUD ,
AV_CODEC_ID_PCM_ZORK ,
AV_CODEC_ID_PCM_S16LE_PLANAR ,
AV_CODEC_ID_PCM_DVD ,
AV_CODEC_ID_PCM_F32BE ,
AV_CODEC_ID_PCM_F32LE ,
AV_CODEC_ID_PCM_F64BE ,
AV_CODEC_ID_PCM_F64LE ,
AV_CODEC_ID_PCM_BLURAY ,
AV_CODEC_ID_PCM_LXF ,
AV_CODEC_ID_S302M ,
AV_CODEC_ID_PCM_S8_PLANAR ,
AV_CODEC_ID_PCM_S24LE_PLANAR = MKBETAG ( 24 , ' P ' , ' S ' , ' P ' ) ,
AV_CODEC_ID_PCM_S32LE_PLANAR = MKBETAG ( 32 , ' P ' , ' S ' , ' P ' ) ,
AV_CODEC_ID_PCM_S16BE_PLANAR = MKBETAG ( ' P ' , ' S ' , ' P ' , 16 ) ,
/* various ADPCM codecs */
AV_CODEC_ID_ADPCM_IMA_QT = 0x11000 ,
AV_CODEC_ID_ADPCM_IMA_WAV ,
AV_CODEC_ID_ADPCM_IMA_DK3 ,
AV_CODEC_ID_ADPCM_IMA_DK4 ,
AV_CODEC_ID_ADPCM_IMA_WS ,
AV_CODEC_ID_ADPCM_IMA_SMJPEG ,
AV_CODEC_ID_ADPCM_MS ,
AV_CODEC_ID_ADPCM_4XM ,
AV_CODEC_ID_ADPCM_XA ,
AV_CODEC_ID_ADPCM_ADX ,
AV_CODEC_ID_ADPCM_EA ,
AV_CODEC_ID_ADPCM_G726 ,
AV_CODEC_ID_ADPCM_CT ,
AV_CODEC_ID_ADPCM_SWF ,
AV_CODEC_ID_ADPCM_YAMAHA ,
AV_CODEC_ID_ADPCM_SBPRO_4 ,
AV_CODEC_ID_ADPCM_SBPRO_3 ,
AV_CODEC_ID_ADPCM_SBPRO_2 ,
AV_CODEC_ID_ADPCM_THP ,
AV_CODEC_ID_ADPCM_IMA_AMV ,
AV_CODEC_ID_ADPCM_EA_R1 ,
AV_CODEC_ID_ADPCM_EA_R3 ,
AV_CODEC_ID_ADPCM_EA_R2 ,
AV_CODEC_ID_ADPCM_IMA_EA_SEAD ,
AV_CODEC_ID_ADPCM_IMA_EA_EACS ,
AV_CODEC_ID_ADPCM_EA_XAS ,
AV_CODEC_ID_ADPCM_EA_MAXIS_XA ,
AV_CODEC_ID_ADPCM_IMA_ISS ,
AV_CODEC_ID_ADPCM_G722 ,
AV_CODEC_ID_ADPCM_IMA_APC ,
AV_CODEC_ID_VIMA = MKBETAG ( ' V ' , ' I ' , ' M ' , ' A ' ) ,
AV_CODEC_ID_ADPCM_AFC = MKBETAG ( ' A ' , ' F ' , ' C ' , ' ' ) ,
AV_CODEC_ID_ADPCM_IMA_OKI = MKBETAG ( ' O ' , ' K ' , ' I ' , ' ' ) ,
AV_CODEC_ID_ADPCM_DTK = MKBETAG ( ' D ' , ' T ' , ' K ' , ' ' ) ,
AV_CODEC_ID_ADPCM_IMA_RAD = MKBETAG ( ' R ' , ' A ' , ' D ' , ' ' ) ,
/* AMR */
AV_CODEC_ID_AMR_NB = 0x12000 ,
AV_CODEC_ID_AMR_WB ,
/* RealAudio codecs*/
AV_CODEC_ID_RA_144 = 0x13000 ,
AV_CODEC_ID_RA_288 ,
/* various DPCM codecs */
AV_CODEC_ID_ROQ_DPCM = 0x14000 ,
AV_CODEC_ID_INTERPLAY_DPCM ,
AV_CODEC_ID_XAN_DPCM ,
AV_CODEC_ID_SOL_DPCM ,
/* audio codecs */
AV_CODEC_ID_MP2 = 0x15000 ,
AV_CODEC_ID_MP3 , ///< preferred ID for decoding MPEG audio layer 1, 2 or 3
AV_CODEC_ID_AAC ,
AV_CODEC_ID_AC3 ,
AV_CODEC_ID_DTS ,
AV_CODEC_ID_VORBIS ,
AV_CODEC_ID_DVAUDIO ,
AV_CODEC_ID_WMAV1 ,
AV_CODEC_ID_WMAV2 ,
AV_CODEC_ID_MACE3 ,
AV_CODEC_ID_MACE6 ,
AV_CODEC_ID_VMDAUDIO ,
AV_CODEC_ID_FLAC ,
AV_CODEC_ID_MP3ADU ,
AV_CODEC_ID_MP3ON4 ,
AV_CODEC_ID_SHORTEN ,
AV_CODEC_ID_ALAC ,
AV_CODEC_ID_WESTWOOD_SND1 ,
AV_CODEC_ID_GSM , ///< as in Berlin toast format
AV_CODEC_ID_QDM2 ,
AV_CODEC_ID_COOK ,
AV_CODEC_ID_TRUESPEECH ,
AV_CODEC_ID_TTA ,
AV_CODEC_ID_SMACKAUDIO ,
AV_CODEC_ID_QCELP ,
AV_CODEC_ID_WAVPACK ,
AV_CODEC_ID_DSICINAUDIO ,
AV_CODEC_ID_IMC ,
AV_CODEC_ID_MUSEPACK7 ,
AV_CODEC_ID_MLP ,
AV_CODEC_ID_GSM_MS , /* as found in WAV */
AV_CODEC_ID_ATRAC3 ,
AV_CODEC_ID_VOXWARE ,
AV_CODEC_ID_APE ,
AV_CODEC_ID_NELLYMOSER ,
AV_CODEC_ID_MUSEPACK8 ,
AV_CODEC_ID_SPEEX ,
AV_CODEC_ID_WMAVOICE ,
AV_CODEC_ID_WMAPRO ,
AV_CODEC_ID_WMALOSSLESS ,
AV_CODEC_ID_ATRAC3P ,
AV_CODEC_ID_EAC3 ,
AV_CODEC_ID_SIPR ,
AV_CODEC_ID_MP1 ,
AV_CODEC_ID_TWINVQ ,
AV_CODEC_ID_TRUEHD ,
AV_CODEC_ID_MP4ALS ,
AV_CODEC_ID_ATRAC1 ,
AV_CODEC_ID_BINKAUDIO_RDFT ,
AV_CODEC_ID_BINKAUDIO_DCT ,
AV_CODEC_ID_AAC_LATM ,
AV_CODEC_ID_QDMC ,
AV_CODEC_ID_CELT ,
AV_CODEC_ID_G723_1 ,
AV_CODEC_ID_G729 ,
AV_CODEC_ID_8SVX_EXP ,
AV_CODEC_ID_8SVX_FIB ,
AV_CODEC_ID_BMV_AUDIO ,
AV_CODEC_ID_RALF ,
AV_CODEC_ID_IAC ,
AV_CODEC_ID_ILBC ,
AV_CODEC_ID_OPUS_DEPRECATED ,
AV_CODEC_ID_COMFORT_NOISE ,
AV_CODEC_ID_TAK_DEPRECATED ,
AV_CODEC_ID_FFWAVESYNTH = MKBETAG ( ' F ' , ' F ' , ' W ' , ' S ' ) ,
AV_CODEC_ID_SONIC = MKBETAG ( ' S ' , ' O ' , ' N ' , ' C ' ) ,
AV_CODEC_ID_SONIC_LS = MKBETAG ( ' S ' , ' O ' , ' N ' , ' L ' ) ,
AV_CODEC_ID_PAF_AUDIO = MKBETAG ( ' P ' , ' A ' , ' F ' , ' A ' ) ,
AV_CODEC_ID_OPUS = MKBETAG ( ' O ' , ' P ' , ' U ' , ' S ' ) ,
AV_CODEC_ID_TAK = MKBETAG ( ' t ' , ' B ' , ' a ' , ' K ' ) ,
AV_CODEC_ID_EVRC = MKBETAG ( ' s ' , ' e ' , ' v ' , ' c ' ) ,
AV_CODEC_ID_SMV = MKBETAG ( ' s ' , ' s ' , ' m ' , ' v ' ) ,
/* subtitle codecs */
AV_CODEC_ID_FIRST_SUBTITLE = 0x17000 , ///< A dummy ID pointing at the start of subtitle codecs.
AV_CODEC_ID_DVD_SUBTITLE = 0x17000 ,
AV_CODEC_ID_DVB_SUBTITLE ,
AV_CODEC_ID_TEXT , ///< raw UTF-8 text
AV_CODEC_ID_XSUB ,
AV_CODEC_ID_SSA ,
AV_CODEC_ID_MOV_TEXT ,
AV_CODEC_ID_HDMV_PGS_SUBTITLE ,
AV_CODEC_ID_DVB_TELETEXT ,
AV_CODEC_ID_SRT ,
AV_CODEC_ID_MICRODVD = MKBETAG ( ' m ' , ' D ' , ' V ' , ' D ' ) ,
AV_CODEC_ID_EIA_608 = MKBETAG ( ' c ' , ' 6 ' , ' 0 ' , ' 8 ' ) ,
AV_CODEC_ID_JACOSUB = MKBETAG ( ' J ' , ' S ' , ' U ' , ' B ' ) ,
AV_CODEC_ID_SAMI = MKBETAG ( ' S ' , ' A ' , ' M ' , ' I ' ) ,
AV_CODEC_ID_REALTEXT = MKBETAG ( ' R ' , ' T ' , ' X ' , ' T ' ) ,
AV_CODEC_ID_SUBVIEWER1 = MKBETAG ( ' S ' , ' b ' , ' V ' , ' 1 ' ) ,
AV_CODEC_ID_SUBVIEWER = MKBETAG ( ' S ' , ' u ' , ' b ' , ' V ' ) ,
AV_CODEC_ID_SUBRIP = MKBETAG ( ' S ' , ' R ' , ' i ' , ' p ' ) ,
AV_CODEC_ID_WEBVTT = MKBETAG ( ' W ' , ' V ' , ' T ' , ' T ' ) ,
AV_CODEC_ID_MPL2 = MKBETAG ( ' M ' , ' P ' , ' L ' , ' 2 ' ) ,
AV_CODEC_ID_VPLAYER = MKBETAG ( ' V ' , ' P ' , ' l ' , ' r ' ) ,
AV_CODEC_ID_PJS = MKBETAG ( ' P ' , ' h ' , ' J ' , ' S ' ) ,
AV_CODEC_ID_ASS = MKBETAG ( ' A ' , ' S ' , ' S ' , ' ' ) , ///< ASS as defined in Matroska
/* other specific kind of codecs (generally used for attachments) */
AV_CODEC_ID_FIRST_UNKNOWN = 0x18000 , ///< A dummy ID pointing at the start of various fake codecs.
AV_CODEC_ID_TTF = 0x18000 ,
AV_CODEC_ID_BINTEXT = MKBETAG ( ' B ' , ' T ' , ' X ' , ' T ' ) ,
AV_CODEC_ID_XBIN = MKBETAG ( ' X ' , ' B ' , ' I ' , ' N ' ) ,
AV_CODEC_ID_IDF = MKBETAG ( 0 , ' I ' , ' D ' , ' F ' ) ,
AV_CODEC_ID_OTF = MKBETAG ( 0 , ' O ' , ' T ' , ' F ' ) ,
AV_CODEC_ID_SMPTE_KLV = MKBETAG ( ' K ' , ' L ' , ' V ' , ' A ' ) ,
AV_CODEC_ID_DVD_NAV = MKBETAG ( ' D ' , ' N ' , ' A ' , ' V ' ) ,
AV_CODEC_ID_PROBE = 0x19000 , ///< codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it
AV_CODEC_ID_MPEG2TS = 0x20000 , /**< _FAKE_ codec to indicate a raw MPEG-2 TS
* stream ( only used by libavformat ) */
AV_CODEC_ID_MPEG4SYSTEMS = 0x20001 , /**< _FAKE_ codec to indicate a MPEG-4 Systems
* stream ( only used by libavformat ) */
AV_CODEC_ID_FFMETADATA = 0x21000 , ///< Dummy codec for streams containing only metadata information.
# if FF_API_CODEC_ID
# include "old_codec_ids.h"
# endif
} ;
/**
* This struct describes the properties of a single codec described by an
* AVCodecID .
* @ see avcodec_get_descriptor ( )
*/
typedef struct AVCodecDescriptor {
enum AVCodecID id ;
enum AVMediaType type ;
/**
* Name of the codec described by this descriptor . It is non - empty and
* unique for each codec descriptor . It should contain alphanumeric
* characters and ' _ ' only .
*/
const char * name ;
/**
* A more descriptive name for this codec . May be NULL .
*/
const char * long_name ;
/**
* Codec properties , a combination of AV_CODEC_PROP_ * flags .
*/
int props ;
} AVCodecDescriptor ;
/**
* Codec uses only intra compression .
* Video codecs only .
*/
# define AV_CODEC_PROP_INTRA_ONLY (1 << 0)
/**
* Codec supports lossy compression . Audio and video codecs only .
* @ note a codec may support both lossy and lossless
* compression modes
*/
# define AV_CODEC_PROP_LOSSY (1 << 1)
/**
* Codec supports lossless compression . Audio and video codecs only .
*/
# define AV_CODEC_PROP_LOSSLESS (1 << 2)
/**
* Subtitle codec is bitmap based
* Decoded AVSubtitle data can be read from the AVSubtitleRect - > pict field .
*/
# define AV_CODEC_PROP_BITMAP_SUB (1 << 16)
/**
* Subtitle codec is text based .
* Decoded AVSubtitle data can be read from the AVSubtitleRect - > ass field .
*/
# define AV_CODEC_PROP_TEXT_SUB (1 << 17)
/**
* @ ingroup lavc_decoding
* 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 . < br >
* 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 16
/**
* @ ingroup lavc_encoding
* minimum encoding buffer size
* Used to avoid some checks during header writing .
*/
# define FF_MIN_BUFFER_SIZE 16384
/**
* @ ingroup lavc_encoding
* motion estimation type .
*/
enum Motion_Est_ID {
ME_ZERO = 1 , ///< no search, that is use 0,0 vector whenever one is needed
ME_FULL ,
ME_LOG ,
ME_PHODS ,
ME_EPZS , ///< enhanced predictive zonal search
ME_X1 , ///< reserved for experiments
ME_HEX , ///< hexagon based search
ME_UMH , ///< uneven multi-hexagon search
ME_TESA , ///< transformed exhaustive search algorithm
ME_ITER = 50 , ///< iterative search
} ;
/**
* @ ingroup lavc_decoding
*/
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
} ;
enum AVColorPrimaries {
AVCOL_PRI_BT709 = 1 , ///< also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
AVCOL_PRI_UNSPECIFIED = 2 ,
AVCOL_PRI_BT470M = 4 ,
AVCOL_PRI_BT470BG = 5 , ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
AVCOL_PRI_SMPTE170M = 6 , ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
AVCOL_PRI_SMPTE240M = 7 , ///< functionally identical to above
AVCOL_PRI_FILM = 8 ,
AVCOL_PRI_NB , ///< Not part of ABI
} ;
enum AVColorTransferCharacteristic {
AVCOL_TRC_BT709 = 1 , ///< also ITU-R BT1361
AVCOL_TRC_UNSPECIFIED = 2 ,
AVCOL_TRC_GAMMA22 = 4 , ///< also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
AVCOL_TRC_GAMMA28 = 5 , ///< also ITU-R BT470BG
AVCOL_TRC_SMPTE240M = 7 ,
AVCOL_TRC_NB , ///< Not part of ABI
} ;
enum AVColorSpace {
AVCOL_SPC_RGB = 0 ,
AVCOL_SPC_BT709 = 1 , ///< also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
AVCOL_SPC_UNSPECIFIED = 2 ,
AVCOL_SPC_FCC = 4 ,
AVCOL_SPC_BT470BG = 5 , ///< also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
AVCOL_SPC_SMPTE170M = 6 , ///< also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above
AVCOL_SPC_SMPTE240M = 7 ,
AVCOL_SPC_YCOCG = 8 , ///< Used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16
AVCOL_SPC_NB , ///< Not part of ABI
} ;
# define AVCOL_SPC_YCGCO AVCOL_SPC_YCOCG
enum AVColorRange {
AVCOL_RANGE_UNSPECIFIED = 0 ,
AVCOL_RANGE_MPEG = 1 , ///< the normal 219*2^(n-8) "MPEG" YUV ranges
AVCOL_RANGE_JPEG = 2 , ///< the normal 2^n-1 "JPEG" YUV ranges
AVCOL_RANGE_NB , ///< Not part of ABI
} ;
/**
* X X 3 4 X X are luma samples ,
* 1 2 1 - 6 are possible chroma positions
* X X 5 6 X 0 is undefined / unknown position
*/
enum AVChromaLocation {
AVCHROMA_LOC_UNSPECIFIED = 0 ,
AVCHROMA_LOC_LEFT = 1 , ///< mpeg2/4, h264 default
AVCHROMA_LOC_CENTER = 2 , ///< mpeg1, jpeg, h263
AVCHROMA_LOC_TOPLEFT = 3 , ///< DV
AVCHROMA_LOC_TOP = 4 ,
AVCHROMA_LOC_BOTTOMLEFT = 5 ,
AVCHROMA_LOC_BOTTOM = 6 ,
AVCHROMA_LOC_NB , ///< Not part of ABI
} ;
enum AVAudioServiceType {
AV_AUDIO_SERVICE_TYPE_MAIN = 0 ,
AV_AUDIO_SERVICE_TYPE_EFFECTS = 1 ,
AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED = 2 ,
AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED = 3 ,
AV_AUDIO_SERVICE_TYPE_DIALOGUE = 4 ,
AV_AUDIO_SERVICE_TYPE_COMMENTARY = 5 ,
AV_AUDIO_SERVICE_TYPE_EMERGENCY = 6 ,
AV_AUDIO_SERVICE_TYPE_VOICE_OVER = 7 ,
AV_AUDIO_SERVICE_TYPE_KARAOKE = 8 ,
AV_AUDIO_SERVICE_TYPE_NB , ///< Not part of ABI
} ;
/**
* @ ingroup lavc_encoding
*/
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 initialization .
Note : Not everything is supported yet .
*/
/**
* Allow decoders to produce frames with data planes that are not aligned
* to CPU requirements ( e . g . due to cropping ) .
*/
# define CODEC_FLAG_UNALIGNED 0x0001
# define CODEC_FLAG_QSCALE 0x0002 ///< Use fixed qscale.
# define CODEC_FLAG_4MV 0x0004 ///< 4 MV per MB allowed / advanced prediction for H.263.
# 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>.
/**
* The parent program guarantees that the input for B - frames containing
* streams is not written to for at least s - > max_b_frames + 1 frames , if
* this is not set 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_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_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 */
# define CODEC_FLAG_AC_PRED 0x01000000 ///< H.263 advanced intra coding / MPEG-4 AC prediction
# define CODEC_FLAG_LOOP_FILTER 0x00000800 ///< loop filter
# define CODEC_FLAG_INTERLACED_ME 0x20000000 ///< interlaced motion estimation
# define CODEC_FLAG_CLOSED_GOP 0x80000000
# define CODEC_FLAG2_FAST 0x00000001 ///< Allow non spec compliant speedup tricks.
# 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_DROP_FRAME_TIMECODE 0x00002000 ///< timecode is in drop frame format. DEPRECATED!!!!
# define CODEC_FLAG2_IGNORE_CROP 0x00010000 ///< Discard cropping information from SPS.
# define CODEC_FLAG2_CHUNKS 0x00008000 ///< Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries.
# define CODEC_FLAG2_SHOW_ALL 0x00400000 ///< Show all frames before the first keyframe
/* 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 and supports custom allocators .
* If not set , it might not use get_buffer ( ) at all or use operations that
* assume the buffer was allocated by avcodec_default_get_buffer .
*/
# define CODEC_CAP_DR1 0x0002
# define CODEC_CAP_TRUNCATED 0x0008
/* Codec can export data for HW decoding (XvMC). */
# define CODEC_CAP_HWACCEL 0x0010
/**
* Encoder or decoder requires flushing with NULL input at the end in order to
* give the complete and correct output .
*
* NOTE : If this flag is not set , the codec is guaranteed to never be fed with
* with NULL data . The user can still send NULL data to the public encode
* or decode function , but libavcodec will not pass it along to the codec
* unless this flag is set .
*
* Decoders :
* The decoder has a non - zero delay and needs to be fed with avpkt - > data = NULL ,
* avpkt - > size = 0 at the end to get the delayed data until the decoder no longer
* returns frames .
*
* Encoders :
* The encoder needs to be fed with NULL data at the end of encoding until the
* encoder no longer returns data .
*
* NOTE : For encoders implementing the AVCodec . encode2 ( ) function , setting this
* flag also means that the encoder must set the pts and duration for
* each output packet . If this flag is not set , the pts and duration will
* be determined by libavcodec from the input frame .
*/
# 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
/**
* Codec can export data for HW decoding ( VDPAU ) .
*/
# define CODEC_CAP_HWACCEL_VDPAU 0x0080
/**
* Codec can output multiple frames per AVPacket
* Normally demuxers return one frame at a time , demuxers which do not do
* are connected to a parser to split what they return into proper frames .
* This flag is reserved to the very rare category of codecs which have a
* bitstream that cannot be split into frames without timeconsuming
* operations like full decoding . Demuxers carring such bitstreams thus
* may return multiple frames in a packet . This has many disadvantages like
* prohibiting stream copy in many cases thus it should only be considered
* as a last resort .
*/
# define CODEC_CAP_SUBFRAMES 0x0100
/**
* Codec is experimental and is thus avoided in favor of non experimental
* encoders
*/
# define CODEC_CAP_EXPERIMENTAL 0x0200
/**
* Codec should fill in channel configuration and samplerate instead of container
*/
# define CODEC_CAP_CHANNEL_CONF 0x0400
/**
* Codec is able to deal with negative linesizes
*/
# define CODEC_CAP_NEG_LINESIZES 0x0800
/**
* Codec supports frame - level multithreading .
*/
# define CODEC_CAP_FRAME_THREADS 0x1000
/**
* Codec supports slice - based ( or partition - based ) multithreading .
*/
# define CODEC_CAP_SLICE_THREADS 0x2000
/**
* Codec supports changed parameters at any point .
*/
# define CODEC_CAP_PARAM_CHANGE 0x4000
/**
* Codec supports avctx - > thread_count = = 0 ( auto ) .
*/
# define CODEC_CAP_AUTO_THREADS 0x8000
/**
* Audio encoder supports receiving a different number of samples in each call .
*/
# define CODEC_CAP_VARIABLE_FRAME_SIZE 0x10000
/**
* Codec is intra only .
*/
# define CODEC_CAP_INTRA_ONLY 0x40000000
/**
* Codec is lossless .
*/
# define CODEC_CAP_LOSSLESS 0x80000000
//The following defines may change, don't expect compatibility if you use them.
# define MB_TYPE_INTRA4x4 0x0001
# define MB_TYPE_INTRA16x16 0x0002 //FIXME H.264-specific
# define MB_TYPE_INTRA_PCM 0x0004 //FIXME H.264-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 libavcodec .
*/
int id ;
/**
* width and height in 1 / 16 pel
* - encoding : Set by user .
* - decoding : Set by libavcodec .
*/
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 libavcodec .
*/
int16_t position [ 3 ] [ 2 ] ;
} AVPanScan ;
# define FF_QSCALE_TYPE_MPEG1 0
# define FF_QSCALE_TYPE_MPEG2 1
# define FF_QSCALE_TYPE_H264 2
# define FF_QSCALE_TYPE_VP56 3
# if FF_API_GET_BUFFER
# 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 deallocate 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 deallocate anything.
# 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).
# endif
/**
* The decoder will keep a reference to the frame and may reuse it later .
*/
# define AV_GET_BUFFER_FLAG_REF (1 << 0)
/**
* @ defgroup lavc_packet AVPacket
*
* Types and functions for working with AVPacket .
* @ {
*/
enum AVPacketSideDataType {
AV_PKT_DATA_PALETTE ,
AV_PKT_DATA_NEW_EXTRADATA ,
/**
* An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows :
* @ code
* u32le param_flags
* if ( param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT )
* s32le channel_count
* if ( param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT )
* u64le channel_layout
* if ( param_flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE )
* s32le sample_rate
* if ( param_flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS )
* s32le width
* s32le height
* @ endcode
*/
AV_PKT_DATA_PARAM_CHANGE ,
/**
* An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of
* structures with info about macroblocks relevant to splitting the
* packet into smaller packets on macroblock edges ( e . g . as for RFC 2190 ) .
* That is , it does not necessarily contain info about all macroblocks ,
* as long as the distance between macroblocks in the info is smaller
* than the target payload size .
* Each MB info structure is 12 bytes , and is laid out as follows :
* @ code
* u32le bit offset from the start of the packet
* u8 current quantizer at the start of the macroblock
* u8 GOB number
* u16le macroblock address within the GOB
* u8 horizontal MV predictor
* u8 vertical MV predictor
* u8 horizontal MV predictor for block number 3
* u8 vertical MV predictor for block number 3
* @ endcode
*/
AV_PKT_DATA_H263_MB_INFO ,
/**
* Recommmends skipping the specified number of samples
* @ code
* u32le number of samples to skip from start of this packet
* u32le number of samples to skip from end of this packet
* u8 reason for start skip
* u8 reason for end skip ( 0 = padding silence , 1 = convergence )
* @ endcode
*/
AV_PKT_DATA_SKIP_SAMPLES = 70 ,
/**
* An AV_PKT_DATA_JP_DUALMONO side data packet indicates that
* the packet may contain " dual mono " audio specific to Japanese DTV
* and if it is true , recommends only the selected channel to be used .
* @ code
* u8 selected channels ( 0 = mail / left , 1 = sub / right , 2 = both )
* @ endcode
*/
AV_PKT_DATA_JP_DUALMONO ,
/**
* A list of zero terminated key / value strings . There is no end marker for
* the list , so it is required to rely on the side data size to stop .
*/
AV_PKT_DATA_STRINGS_METADATA ,
/**
* Subtitle event position
* @ code
* u32le x1
* u32le y1
* u32le x2
* u32le y2
* @ endcode
*/
AV_PKT_DATA_SUBTITLE_POSITION ,
/**
* Data found in BlockAdditional element of matroska container . There is
* no end marker for the data , so it is required to rely on the side data
* size to recognize the end . 8 byte id ( as found in BlockAddId ) followed
* by data .
*/
AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL ,
/**
* The optional first identifier line of a WebVTT cue .
*/
AV_PKT_DATA_WEBVTT_IDENTIFIER ,
/**
* The optional settings ( rendering instructions ) that immediately
* follow the timestamp specifier of a WebVTT cue .
*/
AV_PKT_DATA_WEBVTT_SETTINGS ,
} ;
/**
* This structure stores compressed data . It is typically exported by demuxers
* and then passed as input to decoders , or received as output from encoders and
* then passed to muxers .
*
* For video , it should typically contain one compressed frame . For audio it may
* contain several compressed frames .
*
* AVPacket is one of the few structs in FFmpeg , whose size is a part of public
* ABI . Thus it may be allocated on stack and no new fields can be added to it
* without libavcodec and libavformat major bump .
*
* The semantics of data ownership depends on the buf or destruct ( deprecated )
* fields . If either is set , the packet data is dynamically allocated and is
* valid indefinitely until av_free_packet ( ) is called ( which in turn calls
* av_buffer_unref ( ) / the destruct callback to free the data ) . If neither is set ,
* the packet data is typically backed by some static buffer somewhere and is
* only valid for a limited time ( e . g . until the next read call when demuxing ) .
*
* The side data is always allocated with av_malloc ( ) and is freed in
* av_free_packet ( ) .
*/
typedef struct AVPacket {
/**
* A reference to the reference - counted buffer where the packet data is
* stored .
* May be NULL , then the packet data is not reference - counted .
*/
AVBufferRef * buf ;
/**
* Presentation timestamp in AVStream - > time_base units ; the time at which
* the decompressed packet will be presented to the user .
* Can be AV_NOPTS_VALUE if it is not stored in the file .
* pts MUST be larger or equal to dts as presentation cannot happen before
* decompression , unless one wants to view hex dumps . Some formats misuse
* the terms dts and pts / cts to mean something different . Such timestamps
* must be converted to true pts / dts before they are stored in AVPacket .
*/
int64_t pts ;
/**
* Decompression timestamp in AVStream - > time_base units ; the time at which
* the packet is decompressed .
* Can be AV_NOPTS_VALUE if it is not stored in the file .
*/
int64_t dts ;
uint8_t * data ;
int size ;
int stream_index ;
/**
* A combination of AV_PKT_FLAG values
*/
int flags ;
/**
* Additional packet data that can be provided by the container .
* Packet can contain several types of side information .
*/
struct {
uint8_t * data ;
int size ;
enum AVPacketSideDataType type ;
} * side_data ;
int side_data_elems ;
/**
* Duration of this packet in AVStream - > time_base units , 0 if unknown .
* Equals next_pts - this_pts in presentation order .
*/
int duration ;
# if FF_API_DESTRUCT_PACKET
attribute_deprecated
void ( * destruct ) ( struct AVPacket * ) ;
attribute_deprecated
void * priv ;
# endif
int64_t pos ; ///< byte position in stream, -1 if unknown
/**
* Time difference in AVStream - > time_base units from the pts of this
* packet to the point at which the output from the decoder has converged
* independent from the availability of previous frames . That is , the
* frames are virtually identical no matter if decoding started from
* the very first frame or from this keyframe .
* Is AV_NOPTS_VALUE if unknown .
* This field is not the display duration of the current packet .
* This field has no meaning if the packet does not have AV_PKT_FLAG_KEY
* set .
*
* The purpose of this field is to allow seeking in streams that have no
* keyframes in the conventional sense . It corresponds to the
* recovery point SEI in H .264 and match_time_delta in NUT . It is also
* essential for some types of subtitle streams to ensure that all
* subtitles are correctly displayed after seeking .
*/
int64_t convergence_duration ;
} AVPacket ;
# define AV_PKT_FLAG_KEY 0x0001 ///< The packet contains a keyframe
# define AV_PKT_FLAG_CORRUPT 0x0002 ///< The packet content is corrupted
enum AVSideDataParamChangeFlags {
AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT = 0x0001 ,
AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT = 0x0002 ,
AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE = 0x0004 ,
AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS = 0x0008 ,
} ;
/**
* @ }
*/
struct AVCodecInternal ;
enum AVFieldOrder {
AV_FIELD_UNKNOWN ,
AV_FIELD_PROGRESSIVE ,
AV_FIELD_TT , //< Top coded_first, top displayed first
AV_FIELD_BB , //< Bottom coded first, bottom displayed first
AV_FIELD_TB , //< Top coded first, bottom displayed first
AV_FIELD_BT , //< Bottom coded first, top displayed first
} ;
/**
* main external API structure .
* New fields can be added to the end with minor version bumps .
* Removal , reordering and changes to existing fields require a major
* version bump .
* Please use AVOptions ( av_opt * / av_set / get * ( ) ) to access these fields from user
* applications .
* sizeof ( AVCodecContext ) must not be used outside libav * .
*/
typedef struct AVCodecContext {
/**
* information on struct for av_log
* - set by avcodec_alloc_context3
*/
const AVClass * av_class ;
int log_level_offset ;
enum AVMediaType codec_type ; /* see AVMEDIA_TYPE_xxx */
const struct AVCodec * codec ;
char codec_name [ 32 ] ;
enum AVCodecID codec_id ; /* see AV_CODEC_ID_xxx */
/**
* fourcc ( LSB first , so " ABCD " - > ( ' D ' < < 24 ) + ( ' C ' < < 16 ) + ( ' B ' < < 8 ) + ' A ' ) .
* This is used to work around some encoder bugs .
* A demuxer should set this to what is stored in the field used to identify the codec .
* If there are multiple such fields in a container then the demuxer should choose the one
* which maximizes the information about the used codec .
* If the codec tag field in a container is larger than 32 bits then the demuxer should
* remap the longer ID to 32 bits with a table or other structure . Alternatively a new
* extra_codec_tag + size could be added but for this a clear advantage must be demonstrated
* first .
* - encoding : Set by user , if not then the default based on codec_id will be used .
* - decoding : Set by user , will be converted to uppercase by libavcodec during init .
*/
unsigned int codec_tag ;
/**
* fourcc from the AVI stream header ( LSB first , so " ABCD " - > ( ' D ' < < 24 ) + ( ' C ' < < 16 ) + ( ' B ' < < 8 ) + ' A ' ) .
* This is used to work around some encoder bugs .
* - encoding : unused
* - decoding : Set by user , will be converted to uppercase by libavcodec during init .
*/
unsigned int stream_codec_tag ;
void * priv_data ;
/**
* Private context used for internal data .
*
* Unlike priv_data , this is not codec - specific . It is used in general
* libavcodec functions .
*/
struct AVCodecInternal * internal ;
/**
* Private data of the user , can be used to carry app specific stuff .
* - encoding : Set by user .
* - decoding : Set by user .
*/
void * opaque ;
/**
* the average bitrate
* - encoding : Set by user ; unused for constant quantizer encoding .
* - decoding : Set by libavcodec . 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 ;
/**
* Global quality for codecs which cannot change it per frame .
* This should be proportional to MPEG - 1 / 2 / 4 qscale .
* - encoding : Set by user .
* - decoding : unused
*/
int global_quality ;
/**
* - encoding : Set by user .
* - decoding : unused
*/
int compression_level ;
# define FF_COMPRESSION_DEFAULT -1
/**
* CODEC_FLAG_ * .
* - encoding : Set by user .
* - decoding : Set by user .
*/
int flags ;
/**
* CODEC_FLAG2_ *
* - encoding : Set by user .
* - decoding : Set by user .
*/
int flags2 ;
/**
* some codecs need / can use extradata 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
* than extradata_size to avoid problems if it is read with the bitstream reader .
* The bytewise contents of extradata must not depend on the architecture or CPU endianness .
* - encoding : Set / allocated / freed by libavcodec .
* - 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 libavcodec .
*/
AVRational time_base ;
/**
* For some codecs , the time base is closer to the field rate than the frame rate .
* Most notably , H .264 and MPEG - 2 specify time_base as half of frame duration
* if no telecine is used . . .
*
* Set to time_base ticks per frame . Default 1 , e . g . , H .264 / MPEG - 2 set it to 2.
*/
int ticks_per_frame ;
/**
* Codec delay .
*
* Encoding : Number of frames delay there will be from the encoder input to
* the decoder output . ( we assume the decoder matches the spec )
* Decoding : Number of frames delay in addition to what a standard decoder
* as specified in the spec would produce .
*
* Video :
* Number of frames the decoded output will be delayed relative to the
* encoded input .
*
* Audio :
* For encoding , this is the number of " priming " samples added to the
* beginning of the stream . The decoded output will be delayed by this
* many samples relative to the input to the encoder . Note that this
* field is purely informational and does not directly affect the pts
* output by the encoder , which should always be based on the actual
* presentation time , including any delay .
* For decoding , this is the number of samples the decoder needs to
* output before the decoder ' s output is valid . When seeking , you should
* start decoding this many samples prior to your desired seek point .
*
* - encoding : Set by libavcodec .
* - decoding : Set by libavcodec .
*/
int delay ;
/* video only */
/**
* picture width / height .
* - encoding : MUST be set by user .
* - decoding : May be set by the user before opening the decoder if known e . g .
* from the container . Some decoders will require the dimensions
* to be set by the caller . During decoding , the decoder may
* overwrite those values as required .
*/
int width , height ;
/**
* Bitstream width / height , may be different from width / height e . g . when
* the decoded frame is cropped before being output or lowres is enabled .
* - encoding : unused
* - decoding : May be set by the user before opening the decoder if known
* e . g . from the container . During decoding , the decoder may
* overwrite those values as required .
*/
int coded_width , coded_height ;
# define FF_ASPECT_EXTENDED 15
/**
* the number of pictures in a group of pictures , or 0 for intra_only
* - encoding : Set by user .
* - decoding : unused
*/
int gop_size ;
/**
* Pixel format , see AV_PIX_FMT_xxx .
* May be set by the demuxer if known from headers .
* May be overridden by the decoder if it knows better .
* - encoding : Set by user .
* - decoding : Set by user if known , overridden by libavcodec if known
*/
enum AVPixelFormat pix_fmt ;
/**
* 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 ) , 10 ( tesa ) [ 7 , 8 , 10 are x264 specific , 9 is snow specific ]
* - encoding : MUST be set by user .
* - decoding : unused
*/
int me_method ;
/**
* If non NULL , ' draw_horiz_band ' is called by the libavcodec
* decoder to draw a horizontal band . It improves cache usage . Not
* all codecs can do that . You must check the codec capabilities
* beforehand .
* When multithreading is used , it may be called from multiple threads
* at the same time ; threads might draw different parts of the same AVFrame ,
* or multiple AVFrames , and there is no guarantee that slices will be drawn
* in order .
* The function is also used by hardware acceleration APIs .
* It is called at least once during frame decoding to pass
* the data needed for hardware render .
* In that mode instead of pixel data , AVFrame points to
* a structure specific to the acceleration API . The application
* reads the structure and can change some fields to indicate progress
* or mark state .
* - 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 [ AV_NUM_DATA_POINTERS ] ,
int y , int type , int height ) ;
/**
* callback to negotiate the pixelFormat
* @ param fmt is the list of formats which are supported by the codec ,
* it is terminated by - 1 as 0 is a valid format , the formats are ordered by quality .
* The first is always the native one .
* @ return the chosen format
* - encoding : unused
* - decoding : Set by user , if not set the native format will be chosen .
*/
enum AVPixelFormat ( * get_format ) ( struct AVCodecContext * s , const enum AVPixelFormat * fmt ) ;
/**
* 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
* 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_factor ;
/** obsolete FIXME remove */
int rc_strategy ;
# define FF_RC_STRATEGY_XVID 1
int b_frame_strategy ;
/**
* qscale offset between IP and B - frames
* - encoding : Set by user .
* - decoding : unused
*/
float b_quant_offset ;
/**
* Size of the frame reordering buffer in the decoder .
* For MPEG - 2 it is 1 IPB or 0 low delay IP .
* - encoding : Set by libavcodec .
* - decoding : Set by libavcodec .
*/
int has_b_frames ;
/**
* 0 - > h263 quant 1 - > mpeg quant
* - encoding : Set by user .
* - decoding : unused
*/
int mpeg_quant ;
/**
* 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 ;
/**
* 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 ;
/**
* slice count
* - encoding : Set by libavcodec .
* - decoding : Set by user ( or 0 ) .
*/
int slice_count ;
/**
* 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
/**
* slice offsets in the frame in bytes
* - encoding : Set / allocated by libavcodec .
* - decoding : Set / allocated by user ( or NULL ) .
*/
int * slice_offset ;
/**
* sample aspect ratio ( 0 if unknown )
* That is the width of a pixel divided by the height of the pixel .
* Numerator and denominator must be relatively prime and smaller than 256 for some video standards .
* - encoding : Set by user .
* - decoding : Set by libavcodec .
*/
AVRational sample_aspect_ratio ;
/**
* motion estimation comparison function
* - encoding : Set by user .
* - decoding : unused
*/
int me_cmp ;
/**
* subpixel motion estimation comparison function
* - encoding : Set by user .
* - decoding : unused
*/
int me_sub_cmp ;
/**
* macroblock comparison function ( not supported yet )
* - encoding : Set by user .
* - decoding : unused
*/
int mb_cmp ;
/**
* interlaced DCT comparison 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 ( 2 a + 1 x 2 a + 1 square )
* - encoding : Set by user .
* - decoding : unused
*/
int last_predictor_count ;
/**
* prepass for motion estimation
* - encoding : Set by user .
* - decoding : unused
*/
int pre_me ;
/**
* motion estimation prepass comparison function
* - encoding : Set by user .
* - decoding : unused
*/
int me_pre_cmp ;
/**
* ME prepass 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 ;
/**
* DTG active format information ( additional aspect ratio
* information only used in DVB MPEG - 2 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 ;
/**
* slice flags
* - encoding : unused
* - decoding : Set by user .
*/
int slice_flags ;
# define SLICE_FLAG_CODED_ORDER 0x0001 ///< draw_horiz_band() is called in coded order instead of display
# define SLICE_FLAG_ALLOW_FIELD 0x0002 ///< allow draw_horiz_band() with field slices (MPEG2 field pics)
# define SLICE_FLAG_ALLOW_PLANE 0x0004 ///< allow draw_horiz_band() with 1 component at a time (SVQ1)
/**
* XVideo Motion Acceleration
* - encoding : forbidden
* - decoding : set by decoder
*/
int xvmc_acceleration ;
/**
* macroblock decision mode
* - encoding : Set by user .
* - decoding : unused
*/
int mb_decision ;
# define FF_MB_DECISION_SIMPLE 0 ///< uses mb_cmp
# define FF_MB_DECISION_BITS 1 ///< chooses the one which needs the fewest bits
# define FF_MB_DECISION_RD 2 ///< rate distortion
/**
* custom intra quantization matrix
* - encoding : Set by user , can be NULL .
* - decoding : Set by libavcodec .
*/
uint16_t * intra_matrix ;
/**
* custom inter quantization matrix
* - encoding : Set by user , can be NULL .
* - decoding : Set by libavcodec .
*/
uint16_t * inter_matrix ;
/**
* scene change detection threshold
* 0 is default , larger means fewer detected scene changes .
* - encoding : Set by user .
* - decoding : unused
*/
int scenechange_threshold ;
/**
* noise reduction strength
* - encoding : Set by user .
* - decoding : unused
*/
int noise_reduction ;
/**
* Motion estimation threshold below 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 below 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 ;
/**
* 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 ;
/**
* 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 : Set by user .
* - decoding : unused
*/
int bidir_refine ;
/**
*
* - encoding : Set by user .
* - decoding : unused
*/
int brd_scale ;
/**
* minimum GOP size
* - encoding : Set by user .
* - decoding : unused
*/
int keyint_min ;
/**
* number of reference frames
* - encoding : Set by user .
* - decoding : Set by lavc .
*/
int refs ;
/**
* chroma qp offset from luma
* - encoding : Set by user .
* - decoding : unused
*/
int chromaoffset ;
/**
* 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 function used for fullpel ME .
* - encoding : Set by user .
* - decoding : unused
*/
int mv0_threshold ;
/**
* Adjust sensitivity of b_frame_strategy 1.
* - encoding : Set by user .
* - decoding : unused
*/
int b_sensitivity ;
/**
* Chromaticity coordinates of the source primaries .
* - encoding : Set by user
* - decoding : Set by libavcodec
*/
enum AVColorPrimaries color_primaries ;
/**
* Color Transfer Characteristic .
* - encoding : Set by user
* - decoding : Set by libavcodec
*/
enum AVColorTransferCharacteristic color_trc ;
/**
* YUV colorspace type .
* - encoding : Set by user
* - decoding : Set by libavcodec
*/
enum AVColorSpace colorspace ;
/**
* MPEG vs JPEG YUV range .
* - encoding : Set by user
* - decoding : Set by libavcodec
*/
enum AVColorRange color_range ;
/**
* This defines the location of chroma samples .
* - encoding : Set by user
* - decoding : Set by libavcodec
*/
enum AVChromaLocation chroma_sample_location ;
/**
* Number of slices .
* Indicates number of picture subdivisions . Used for parallelized
* decoding .
* - encoding : Set by user
* - decoding : unused
*/
int slices ;
/** Field order
* - encoding : set by libavcodec
* - decoding : Set by user .
*/
enum AVFieldOrder field_order ;
/* audio only */
int sample_rate ; ///< samples per second
int channels ; ///< number of audio channels
/**
* audio sample format
* - encoding : Set by user .
* - decoding : Set by libavcodec .
*/
enum AVSampleFormat sample_fmt ; ///< sample format
/* The following data should not be initialized. */
/**
* Number of samples per channel in an audio frame .
*
* - encoding : set by libavcodec in avcodec_open2 ( ) . Each submitted frame
* except the last must contain exactly frame_size samples per channel .
* May be 0 when the codec has CODEC_CAP_VARIABLE_FRAME_SIZE set , then the
* frame size is not restricted .
* - decoding : may be set by some decoders to indicate constant frame size
*/
int frame_size ;
/**
* Frame counter , set by libavcodec .
*
* - decoding : total number of frames returned from the decoder so far .
* - encoding : total number of frames passed to the encoder so far .
*
* @ note the counter is not incremented if encoding / decoding resulted in
* an error .
*/
int frame_number ;
/**
* number of bytes per packet if constant and known or 0
* Used by some WAV based audio codecs .
*/
int block_align ;
/**
* Audio cutoff bandwidth ( 0 means " automatic " )
* - encoding : Set by user .
* - decoding : unused
*/
int cutoff ;
# if FF_API_REQUEST_CHANNELS
/**
* Decoder should decode to this many channels if it can ( 0 for default )
* - encoding : unused
* - decoding : Set by user .
* @ deprecated Deprecated in favor of request_channel_layout .
*/
int request_channels ;
# endif
/**
* Audio channel layout .
* - encoding : set by user .
* - decoding : set by user , may be overwritten by libavcodec .
*/
uint64_t channel_layout ;
/**
* Request decoder to use this channel layout if it can ( 0 for default )
* - encoding : unused
* - decoding : Set by user .
*/
uint64_t request_channel_layout ;
/**
* Type of service that the audio stream conveys .
* - encoding : Set by user .
* - decoding : Set by libavcodec .
*/
enum AVAudioServiceType audio_service_type ;
/**
* desired sample format
* - encoding : Not used .
* - decoding : Set by user .
* Decoder will decode to this format if it can .
*/
enum AVSampleFormat request_sample_fmt ;
# if FF_API_GET_BUFFER
/**
* Called at the beginning of each frame to get a buffer for it .
*
* The function will set AVFrame . data [ ] , AVFrame . linesize [ ] .
* AVFrame . extended_data [ ] must also be set , but it should be the same as
* AVFrame . data [ ] except for planar audio with more channels than can fit
* in AVFrame . data [ ] . In that case , AVFrame . data [ ] shall still contain as
* many data pointers as it can hold .
*
* if CODEC_CAP_DR1 is not set then get_buffer ( ) must call
* avcodec_default_get_buffer ( ) instead of providing buffers allocated by
* some other means .
*
* AVFrame . data [ ] should be 32 - or 16 - byte - aligned unless the CPU doesn ' t
* need it . avcodec_default_get_buffer ( ) aligns the output buffer properly ,
* but if get_buffer ( ) is overridden then alignment considerations should
* be taken into account .
*
* @ see avcodec_default_get_buffer ( )
*
* Video :
*
* If pic . reference is set then the frame will be read later by libavcodec .
* avcodec_align_dimensions2 ( ) should be used to find the required width and
* height , as they normally need to be rounded up to the next multiple of 16.
*
* If frame multithreading is used and thread_safe_callbacks is set ,
* it may be called from a different thread , but not from more than one at
* once . Does not need to be reentrant .
*
* @ see release_buffer ( ) , reget_buffer ( )
* @ see avcodec_align_dimensions2 ( )
*
* Audio :
*
* Decoders request a buffer of a particular size by setting
* AVFrame . nb_samples prior to calling get_buffer ( ) . The decoder may ,
* however , utilize only part of the buffer by setting AVFrame . nb_samples
* to a smaller value in the output frame .
*
* Decoders cannot use the buffer after returning from
* avcodec_decode_audio4 ( ) , so they will not call release_buffer ( ) , as it
* is assumed to be released immediately upon return . In some rare cases ,
* a decoder may need to call get_buffer ( ) more than once in a single
* call to avcodec_decode_audio4 ( ) . In that case , when get_buffer ( ) is
* called again after it has already been called once , the previously
* acquired buffer is assumed to be released at that time and may not be
* reused by the decoder .
*
* As a convenience , av_samples_get_buffer_size ( ) and
* av_samples_fill_arrays ( ) in libavutil may be used by custom get_buffer ( )
* functions to find the required data size and to fill data pointers and
* linesize . In AVFrame . linesize , only linesize [ 0 ] may be set for audio
* since all planes must be the same size .
*
* @ see av_samples_get_buffer_size ( ) , av_samples_fill_arrays ( )
*
* - encoding : unused
* - decoding : Set by libavcodec , user can override .
*
* @ deprecated use get_buffer2 ( )
*/
attribute_deprecated
int ( * get_buffer ) ( struct AVCodecContext * c , AVFrame * pic ) ;
/**
* Called to release buffers which were allocated with get_buffer .
* A released buffer can be reused in get_buffer ( ) .
* pic . data [ * ] must be set to NULL .
* May be called from a different thread if frame multithreading is used ,
* but not by more than one thread at once , so does not need to be reentrant .
* - encoding : unused
* - decoding : Set by libavcodec , user can override .
*
* @ deprecated custom freeing callbacks should be set from get_buffer2 ( )
*/
attribute_deprecated
void ( * release_buffer ) ( struct AVCodecContext * c , AVFrame * pic ) ;
/**
* Called at the beginning of a frame to get cr buffer for it .
* Buffer type ( size , hints ) must be the same . libavcodec won ' t check it .
* libavcodec 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 ( ) .
* if CODEC_CAP_DR1 is not set then reget_buffer ( ) must call
* avcodec_default_reget_buffer ( ) instead of providing buffers allocated by
* some other means .
* - encoding : unused
* - decoding : Set by libavcodec , user can override .
*/
attribute_deprecated
int ( * reget_buffer ) ( struct AVCodecContext * c , AVFrame * pic ) ;
# endif
/**
* This callback is called at the beginning of each frame to get data
* buffer ( s ) for it . There may be one contiguous buffer for all the data or
* there may be a buffer per each data plane or anything in between . What
* this means is , you may set however many entries in buf [ ] you feel necessary .
* Each buffer must be reference - counted using the AVBuffer API ( see description
* of buf [ ] below ) .
*
* The following fields will be set in the frame before this callback is
* called :
* - format
* - width , height ( video only )
* - sample_rate , channel_layout , nb_samples ( audio only )
* Their values may differ from the corresponding values in
* AVCodecContext . This callback must use the frame values , not the codec
* context values , to calculate the required buffer size .
*
* This callback must fill the following fields in the frame :
* - data [ ]
* - linesize [ ]
* - extended_data :
* * if the data is planar audio with more than 8 channels , then this
* callback must allocate and fill extended_data to contain all pointers
* to all data planes . data [ ] must hold as many pointers as it can .
* extended_data must be allocated with av_malloc ( ) and will be freed in
* av_frame_unref ( ) .
* * otherwise exended_data must point to data
* - buf [ ] must contain one or more pointers to AVBufferRef structures . Each of
* the frame ' s data and extended_data pointers must be contained in these . That
* is , one AVBufferRef for each allocated chunk of memory , not necessarily one
* AVBufferRef per data [ ] entry . See : av_buffer_create ( ) , av_buffer_alloc ( ) ,
* and av_buffer_ref ( ) .
* - extended_buf and nb_extended_buf must be allocated with av_malloc ( ) by
* this callback and filled with the extra buffers if there are more
* buffers than buf [ ] can hold . extended_buf will be freed in
* av_frame_unref ( ) .
*
* If CODEC_CAP_DR1 is not set then get_buffer2 ( ) must call
* avcodec_default_get_buffer2 ( ) instead of providing buffers allocated by
* some other means .
*
* Each data plane must be aligned to the maximum required by the target
* CPU .
*
* @ see avcodec_default_get_buffer2 ( )
*
* Video :
*
* If AV_GET_BUFFER_FLAG_REF is set in flags then the frame may be reused
* ( read and / or written to if it is writable ) later by libavcodec .
*
* If CODEC_FLAG_EMU_EDGE is not set in s - > flags , the buffer must contain an
* edge of the size returned by avcodec_get_edge_width ( ) on all sides .
*
* avcodec_align_dimensions2 ( ) should be used to find the required width and
* height , as they normally need to be rounded up to the next multiple of 16.
*
* If frame multithreading is used and thread_safe_callbacks is set ,
* this callback may be called from a different thread , but not from more
* than one at once . Does not need to be reentrant .
*
* @ see avcodec_align_dimensions2 ( )
*
* Audio :
*
* Decoders request a buffer of a particular size by setting
* AVFrame . nb_samples prior to calling get_buffer2 ( ) . The decoder may ,
* however , utilize only part of the buffer by setting AVFrame . nb_samples
* to a smaller value in the output frame .
*
* As a convenience , av_samples_get_buffer_size ( ) and
* av_samples_fill_arrays ( ) in libavutil may be used by custom get_buffer2 ( )
* functions to find the required data size and to fill data pointers and
* linesize . In AVFrame . linesize , only linesize [ 0 ] may be set for audio
* since all planes must be the same size .
*
* @ see av_samples_get_buffer_size ( ) , av_samples_fill_arrays ( )
*
* - encoding : unused
* - decoding : Set by libavcodec , user can override .
*/
int ( * get_buffer2 ) ( struct AVCodecContext * s , AVFrame * frame , int flags ) ;
/**
* If non - zero , the decoded audio and video frames returned from
* avcodec_decode_video2 ( ) and avcodec_decode_audio4 ( ) are reference - counted
* and are valid indefinitely . The caller must free them with
* av_frame_unref ( ) when they are not needed anymore .
* Otherwise , the decoded frames must not be freed by the caller and are
* only valid until the next decode call .
*
* - encoding : unused
* - decoding : set by the caller before avcodec_open2 ( ) .
*/
int refcounted_frames ;
/* - 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 ;
/**
* ratecontrol qmin qmax limiting method
* 0 - > clipping , 1 - > use a nice continuous function to limit qscale wthin qmin / qmax .
* - encoding : Set by user .
* - decoding : unused
*/
float rc_qsquish ;
float rc_qmod_amp ;
int rc_qmod_freq ;
/**
* decoder bitstream buffer size
* - encoding : Set by user .
* - decoding : unused
*/
int rc_buffer_size ;
/**
* ratecontrol override , see RcOverride
* - encoding : Allocated / set / freed by user .
* - decoding : unused
*/
int rc_override_count ;
RcOverride * rc_override ;
/**
* rate control equation
* - encoding : Set by user
* - decoding : unused
*/
const 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 ;
float rc_buffer_aggressivity ;
/**
* initial complexity for pass1 ratecontrol
* - encoding : Set by user .
* - decoding : unused
*/
float rc_initial_cplx ;
/**
* Ratecontrol attempt to use , at maximum , < value > of what can be used without an underflow .
* - encoding : Set by user .
* - decoding : unused .
*/
float rc_max_available_vbv_use ;
/**
* Ratecontrol attempt to use , at least , < value > times the amount needed to prevent a vbv overflow .
* - encoding : Set by user .
* - decoding : unused .
*/
float rc_min_vbv_overflow_use ;
/**
* 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 ;
# define FF_CODER_TYPE_VLC 0
# define FF_CODER_TYPE_AC 1
# define FF_CODER_TYPE_RAW 2
# define FF_CODER_TYPE_RLE 3
# define FF_CODER_TYPE_DEFLATE 4
/**
* coder type
* - encoding : Set by user .
* - decoding : unused
*/
int coder_type ;
/**
* context model
* - encoding : Set by user .
* - decoding : unused
*/
int context_model ;
/**
* minimum Lagrange multipler
* - encoding : Set by user .
* - decoding : unused
*/
int lmin ;
/**
* maximum Lagrange multipler
* - encoding : Set by user .
* - decoding : unused
*/
int lmax ;
/**
* 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 comparison function
* - encoding : Set by user .
* - decoding : unused
*/
int frame_skip_cmp ;
/**
* trellis RD quantization
* - encoding : Set by user .
* - decoding : unused
*/
int trellis ;
/**
* - encoding : Set by user .
* - decoding : unused
*/
int min_prediction_order ;
/**
* - encoding : Set by user .
* - decoding : unused
*/
int max_prediction_order ;
/**
* GOP timecode frame start number
* - encoding : Set by user , in non drop frame format
* - decoding : Set by libavcodec ( timecode in the 25 bits format , - 1 if unset )
*/
int64_t timecode_frame_start ;
/* The RTP callback: This function is called */
/* every time the encoder has a packet to send. */
/* It 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 ) ;
int rtp_payload_size ; /* The size of the RTP payload: the coder will */
/* do its 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 transmitted RTP payload. */
/* 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 libavcodec .
* - decoding : unused
*/
int frame_bits ;
/**
* pass1 encoding statistics output buffer
* - encoding : Set by libavcodec .
* - 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 ;
/**
* Work around 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 ///< Work around various bugs in Microsoft's broken decoders.
# define FF_BUG_TRUNCATED 16384
/**
* strictly follow the standard ( MPEG4 , . . . ) .
* - encoding : Set by user .
* - decoding : Set by user .
* Setting this to STRICT or higher means the encoder and decoder will
* generally do stupid things , whereas setting it to unofficial or lower
* will mean the encoder might produce output that is not supported by all
* spec - compliant decoders . Decoders don ' t differentiate between normal ,
* unofficial and experimental ( that is , they always try to decode things
* when they can ) unless they are explicitly asked to behave stupidly
* ( = strictly conform to the specs )
*/
int strict_std_compliance ;
# define FF_COMPLIANCE_VERY_STRICT 2 ///< Strictly conform to an 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_UNOFFICIAL -1 ///< Allow unofficial extensions
# define FF_COMPLIANCE_EXPERIMENTAL -2 ///< Allow nonstandardized experimental things.
/**
* error concealment flags
* - encoding : unused
* - decoding : Set by user .
*/
int error_concealment ;
# define FF_EC_GUESS_MVS 1
# define FF_EC_DEBLOCK 2
/**
* 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
# define FF_DEBUG_BUFFERS 0x00008000
# define FF_DEBUG_THREADS 0x00010000
/**
* 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 recognition ; may misdetect some more or less valid parts as errors .
* - encoding : unused
* - decoding : Set by user .
*/
int err_recognition ;
# define AV_EF_CRCCHECK (1<<0)
# define AV_EF_BITSTREAM (1<<1)
# define AV_EF_BUFFER (1<<2)
# define AV_EF_EXPLODE (1<<3)
# define AV_EF_CAREFUL (1<<16)
# define AV_EF_COMPLIANT (1<<17)
# define AV_EF_AGGRESSIVE (1<<18)
/**
* opaque 64 bit number ( generally a PTS ) that will be reordered and
* output in AVFrame . reordered_opaque
* @ deprecated in favor of pkt_pts
* - encoding : unused
* - decoding : Set by user .
*/
int64_t reordered_opaque ;
/**
* Hardware accelerator in use
* - encoding : unused .
* - decoding : Set by libavcodec
*/
struct AVHWAccel * hwaccel ;
/**
* Hardware accelerator context .
* For some hardware accelerators , a global context needs to be
* provided by the user . In that case , this holds display - dependent
* data FFmpeg cannot instantiate itself . Please refer to the
* FFmpeg HW accelerator documentation to know how to fill this
* is . e . g . for VA API , this is a struct vaapi_context .
* - encoding : unused
* - decoding : Set by user
*/
void * hwaccel_context ;
/**
* error
* - encoding : Set by libavcodec if flags & CODEC_FLAG_PSNR .
* - decoding : unused
*/
uint64_t error [ AV_NUM_DATA_POINTERS ] ;
/**
* 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_ALTIVEC 5
# define FF_DCT_FAAN 6
/**
* 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_ARM 7
# define FF_IDCT_ALTIVEC 8
# define FF_IDCT_SH4 9
# define FF_IDCT_SIMPLEARM 10
# define FF_IDCT_IPP 13
# define FF_IDCT_XVIDMMX 14
# define FF_IDCT_SIMPLEARMV5TE 16
# define FF_IDCT_SIMPLEARMV6 17
# define FF_IDCT_SIMPLEVIS 18
# define FF_IDCT_FAAN 20
# define FF_IDCT_SIMPLENEON 22
# define FF_IDCT_SIMPLEALPHA 23
/**
* bits per sample / pixel from the demuxer ( needed for huffyuv ) .
* - encoding : Set by libavcodec .
* - decoding : Set by user .
*/
int bits_per_coded_sample ;
/**
* Bits per sample / pixel of internal libavcodec pixel / sample format .
* - encoding : set by user .
* - decoding : set by libavcodec .
*/
int bits_per_raw_sample ;
# if FF_API_LOWRES
/**
* low resolution decoding , 1 - > 1 / 2 size , 2 - > 1 / 4 size
* - encoding : unused
* - decoding : Set by user .
* Code outside libavcodec should access this field using :
* av_codec_ { get , set } _lowres ( avctx )
*/
int lowres ;
# endif
/**
* the picture in the bitstream
* - encoding : Set by libavcodec .
* - decoding : Set by libavcodec .
*/
AVFrame * coded_frame ;
/**
* 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 ;
/**
* Which multithreading methods to use .
* Use of FF_THREAD_FRAME will increase decoding delay by one frame per thread ,
* so clients which cannot provide future frames should not use it .
*
* - encoding : Set by user , otherwise the default is used .
* - decoding : Set by user , otherwise the default is used .
*/
int thread_type ;
# define FF_THREAD_FRAME 1 ///< Decode more than one frame at once
# define FF_THREAD_SLICE 2 ///< Decode more than one part of a single frame at once
/**
* Which multithreading methods are in use by the codec .
* - encoding : Set by libavcodec .
* - decoding : Set by libavcodec .
*/
int active_thread_type ;
/**
* Set by the client if its custom get_buffer ( ) callback can be called
* synchronously from another thread , which allows faster multithreaded decoding .
* draw_horiz_band ( ) will be called from other threads regardless of this setting .
* Ignored if the default get_buffer ( ) is used .
* - encoding : Set by user .
* - decoding : Set by user .
*/
int thread_safe_callbacks ;
/**
* 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 libavcodec , user can override .
* - decoding : Set by libavcodec , user can override .
*/
int ( * execute ) ( struct AVCodecContext * c , int ( * func ) ( struct AVCodecContext * c2 , void * arg ) , void * arg2 , int * ret , int count , int size ) ;
/**
* 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 .
* Also see avcodec_thread_init and e . g . the - - enable - pthread configure option .
* @ param c context passed also to func
* @ param count the number of things to execute
* @ param arg2 argument passed unchanged to func
* @ param ret return values of executed functions , must have space for " count " values . May be NULL .
* @ param func function that will be called count times , with jobnr from 0 to count - 1.
* threadnr will be in the range 0 to c - > thread_count - 1 < MAX_THREADS and so that no
* two instances of func executing at the same time will have the same threadnr .
* @ return always 0 currently , but code should handle a future improvement where when any call to func
* returns < 0 no further calls to func may be done and < 0 is returned .
* - encoding : Set by libavcodec , user can override .
* - decoding : Set by libavcodec , user can override .
*/
int ( * execute2 ) ( struct AVCodecContext * c , int ( * func ) ( struct AVCodecContext * c2 , void * arg , int jobnr , int threadnr ) , 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 ;
/**
* noise vs . sse weight for the nsse comparsion function
* - encoding : Set by user .
* - decoding : unused
*/
int nsse_weight ;
/**
* profile
* - encoding : Set by user .
* - decoding : Set by libavcodec .
*/
int profile ;
# define FF_PROFILE_UNKNOWN -99
# define FF_PROFILE_RESERVED -100
# define FF_PROFILE_AAC_MAIN 0
# define FF_PROFILE_AAC_LOW 1
# define FF_PROFILE_AAC_SSR 2
# define FF_PROFILE_AAC_LTP 3
# define FF_PROFILE_AAC_HE 4
# define FF_PROFILE_AAC_HE_V2 28
# define FF_PROFILE_AAC_LD 22
# define FF_PROFILE_AAC_ELD 38
# define FF_PROFILE_MPEG2_AAC_LOW 128
# define FF_PROFILE_MPEG2_AAC_HE 131
# define FF_PROFILE_DTS 20
# define FF_PROFILE_DTS_ES 30
# define FF_PROFILE_DTS_96_24 40
# define FF_PROFILE_DTS_HD_HRA 50
# define FF_PROFILE_DTS_HD_MA 60
# define FF_PROFILE_MPEG2_422 0
# define FF_PROFILE_MPEG2_HIGH 1
# define FF_PROFILE_MPEG2_SS 2
# define FF_PROFILE_MPEG2_SNR_SCALABLE 3
# define FF_PROFILE_MPEG2_MAIN 4
# define FF_PROFILE_MPEG2_SIMPLE 5
# define FF_PROFILE_H264_CONSTRAINED (1<<9) // 8+1; constraint_set1_flag
# define FF_PROFILE_H264_INTRA (1<<11) // 8+3; constraint_set3_flag
# define FF_PROFILE_H264_BASELINE 66
# define FF_PROFILE_H264_CONSTRAINED_BASELINE (66|FF_PROFILE_H264_CONSTRAINED)
# define FF_PROFILE_H264_MAIN 77
# define FF_PROFILE_H264_EXTENDED 88
# define FF_PROFILE_H264_HIGH 100
# define FF_PROFILE_H264_HIGH_10 110
# define FF_PROFILE_H264_HIGH_10_INTRA (110|FF_PROFILE_H264_INTRA)
# define FF_PROFILE_H264_HIGH_422 122
# define FF_PROFILE_H264_HIGH_422_INTRA (122|FF_PROFILE_H264_INTRA)
# define FF_PROFILE_H264_HIGH_444 144
# define FF_PROFILE_H264_HIGH_444_PREDICTIVE 244
# define FF_PROFILE_H264_HIGH_444_INTRA (244|FF_PROFILE_H264_INTRA)
# define FF_PROFILE_H264_CAVLC_444 44
# define FF_PROFILE_VC1_SIMPLE 0
# define FF_PROFILE_VC1_MAIN 1
# define FF_PROFILE_VC1_COMPLEX 2
# define FF_PROFILE_VC1_ADVANCED 3
# define FF_PROFILE_MPEG4_SIMPLE 0
# define FF_PROFILE_MPEG4_SIMPLE_SCALABLE 1
# define FF_PROFILE_MPEG4_CORE 2
# define FF_PROFILE_MPEG4_MAIN 3
# define FF_PROFILE_MPEG4_N_BIT 4
# define FF_PROFILE_MPEG4_SCALABLE_TEXTURE 5
# define FF_PROFILE_MPEG4_SIMPLE_FACE_ANIMATION 6
# define FF_PROFILE_MPEG4_BASIC_ANIMATED_TEXTURE 7
# define FF_PROFILE_MPEG4_HYBRID 8
# define FF_PROFILE_MPEG4_ADVANCED_REAL_TIME 9
# define FF_PROFILE_MPEG4_CORE_SCALABLE 10
# define FF_PROFILE_MPEG4_ADVANCED_CODING 11
# define FF_PROFILE_MPEG4_ADVANCED_CORE 12
# define FF_PROFILE_MPEG4_ADVANCED_SCALABLE_TEXTURE 13
# define FF_PROFILE_MPEG4_SIMPLE_STUDIO 14
# define FF_PROFILE_MPEG4_ADVANCED_SIMPLE 15
# define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_0 0
# define FF_PROFILE_JPEG2000_CSTREAM_RESTRICTION_1 1
# define FF_PROFILE_JPEG2000_CSTREAM_NO_RESTRICTION 2
# define FF_PROFILE_JPEG2000_DCINEMA_2K 3
# define FF_PROFILE_JPEG2000_DCINEMA_4K 4
/**
* level
* - encoding : Set by user .
* - decoding : Set by libavcodec .
*/
int level ;
# define FF_LEVEL_UNKNOWN -99
/**
* Skip loop filtering for selected frames .
* - encoding : unused
* - decoding : Set by user .
*/
enum AVDiscard skip_loop_filter ;
/**
* Skip IDCT / dequantization for selected frames .
* - encoding : unused
* - decoding : Set by user .
*/
enum AVDiscard skip_idct ;
/**
* Skip decoding for selected frames .
* - encoding : unused
* - decoding : Set by user .
*/
enum AVDiscard skip_frame ;
/**
* Header containing style information for text subtitles .
* For SUBTITLE_ASS subtitle type , it should contain the whole ASS
* [ Script Info ] and [ V4 + Styles ] section , plus the [ Events ] line and
* the Format line following . It shouldn ' t include any Dialogue line .
* - encoding : Set / allocated / freed by user ( before avcodec_open2 ( ) )
* - decoding : Set / allocated / freed by libavcodec ( by avcodec_open2 ( ) )
*/
uint8_t * subtitle_header ;
int subtitle_header_size ;
/**
* Simulates errors in the bitstream to test error concealment .
* - encoding : Set by user .
* - decoding : unused
*/
int error_rate ;
/**
* Current packet as passed into the decoder , to avoid having
* to pass the packet into every function . Currently only valid
* inside lavc and get / release_buffer callbacks .
* - decoding : set by avcodec_decode_ * , read by get_buffer ( ) for setting pkt_pts
* - encoding : unused
*/
AVPacket * pkt ;
/**
* VBV delay coded in the last frame ( in periods of a 27 MHz clock ) .
* Used for compliant TS muxing .
* - encoding : Set by libavcodec .
* - decoding : unused .
*/
uint64_t vbv_delay ;
/**
* Timebase in which pkt_dts / pts and AVPacket . dts / pts are .
* Code outside libavcodec should access this field using :
* av_codec_ { get , set } _pkt_timebase ( avctx )
* - encoding unused .
* - decoding set by user .
*/
AVRational pkt_timebase ;
/**
* AVCodecDescriptor
* Code outside libavcodec should access this field using :
* av_codec_ { get , set } _codec_descriptor ( avctx )
* - encoding : unused .
* - decoding : set by libavcodec .
*/
const AVCodecDescriptor * codec_descriptor ;
# if !FF_API_LOWRES
/**
* low resolution decoding , 1 - > 1 / 2 size , 2 - > 1 / 4 size
* - encoding : unused
* - decoding : Set by user .
* Code outside libavcodec should access this field using :
* av_codec_ { get , set } _lowres ( avctx )
*/
int lowres ;
# endif
/**
* Current statistics for PTS correction .
* - decoding : maintained and used by libavcodec , not intended to be used by user apps
* - encoding : unused
*/
int64_t pts_correction_num_faulty_pts ; /// Number of incorrect PTS values so far
int64_t pts_correction_num_faulty_dts ; /// Number of incorrect DTS values so far
int64_t pts_correction_last_pts ; /// PTS of the last frame
int64_t pts_correction_last_dts ; /// DTS of the last frame
/**
* Character encoding of the input subtitles file .
* - decoding : set by user
* - encoding : unused
*/
char * sub_charenc ;
/**
* Subtitles character encoding mode . Formats or codecs might be adjusting
* this setting ( if they are doing the conversion themselves for instance ) .
* - decoding : set by libavcodec
* - encoding : unused
*/
int sub_charenc_mode ;
# define FF_SUB_CHARENC_MODE_DO_NOTHING -1 ///< do nothing (demuxer outputs a stream supposed to be already in UTF-8, or the codec is bitmap for instance)
# define FF_SUB_CHARENC_MODE_AUTOMATIC 0 ///< libavcodec will select the mode itself
# define FF_SUB_CHARENC_MODE_PRE_DECODER 1 ///< the AVPacket data needs to be recoded to UTF-8 before being fed to the decoder, requires iconv
} AVCodecContext ;
AVRational av_codec_get_pkt_timebase ( const AVCodecContext * avctx ) ;
void av_codec_set_pkt_timebase ( AVCodecContext * avctx , AVRational val ) ;
const AVCodecDescriptor * av_codec_get_codec_descriptor ( const AVCodecContext * avctx ) ;
void av_codec_set_codec_descriptor ( AVCodecContext * avctx , const AVCodecDescriptor * desc ) ;
int av_codec_get_lowres ( const AVCodecContext * avctx ) ;
void av_codec_set_lowres ( AVCodecContext * avctx , int val ) ;
/**
* AVProfile .
*/
typedef struct AVProfile {
int profile ;
const char * name ; ///< short name for the profile
} AVProfile ;
typedef struct AVCodecDefault AVCodecDefault ;
struct AVSubtitle ;
/**
* AVCodec .
*/
typedef struct AVCodec {
/**
* Name of the codec implementation .
* The name is globally unique among encoders and among decoders ( but an
* encoder and a decoder can share the same name ) .
* This is the primary way to find a codec from the user perspective .
*/
const char * name ;
/**
* Descriptive name for the codec , meant to be more human readable than name .
* You should use the NULL_IF_CONFIG_SMALL ( ) macro to define it .
*/
const char * long_name ;
enum AVMediaType type ;
enum AVCodecID id ;
/**
* Codec capabilities .
* see CODEC_CAP_ *
*/
int capabilities ;
const AVRational * supported_framerates ; ///< array of supported framerates, or NULL if any, array is terminated by {0,0}
const enum AVPixelFormat * pix_fmts ; ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1
const int * supported_samplerates ; ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
const enum AVSampleFormat * sample_fmts ; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
const uint64_t * channel_layouts ; ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
uint8_t max_lowres ; ///< maximum value for lowres supported by the decoder
const AVClass * priv_class ; ///< AVClass for the private context
const AVProfile * profiles ; ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
/*****************************************************************
* No fields below this line are part of the public API . They
* may not be used outside of libavcodec and can be changed and
* removed at will .
* New public fields should be added right above .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
int priv_data_size ;
struct AVCodec * next ;
/**
* @ name Frame - level threading support functions
* @ {
*/
/**
* If defined , called on thread contexts when they are created .
* If the codec allocates writable tables in init ( ) , re - allocate them here .
* priv_data will be set to a copy of the original .
*/
int ( * init_thread_copy ) ( AVCodecContext * ) ;
/**
* Copy necessary context variables from a previous thread context to the current one .
* If not defined , the next thread will start automatically ; otherwise , the codec
* must call ff_thread_finish_setup ( ) .
*
* dst and src will ( rarely ) point to the same context , in which case memcpy should be skipped .
*/
int ( * update_thread_context ) ( AVCodecContext * dst , const AVCodecContext * src ) ;
/** @} */
/**
* Private codec - specific defaults .
*/
const AVCodecDefault * defaults ;
/**
* Initialize codec static data , called from avcodec_register ( ) .
*/
void ( * init_static_data ) ( struct AVCodec * codec ) ;
int ( * init ) ( AVCodecContext * ) ;
int ( * encode_sub ) ( AVCodecContext * , uint8_t * buf , int buf_size ,
const struct AVSubtitle * sub ) ;
/**
* Encode data to an AVPacket .
*
* @ param avctx codec context
* @ param avpkt output AVPacket ( may contain a user - provided buffer )
* @ param [ in ] frame AVFrame containing the raw data to be encoded
* @ param [ out ] got_packet_ptr encoder sets to 0 or 1 to indicate that a
* non - empty packet was returned in avpkt .
* @ return 0 on success , negative error code on failure
*/
int ( * encode2 ) ( AVCodecContext * avctx , AVPacket * avpkt , const AVFrame * frame ,
int * got_packet_ptr ) ;
int ( * decode ) ( AVCodecContext * , void * outdata , int * outdata_size , AVPacket * avpkt ) ;
int ( * close ) ( AVCodecContext * ) ;
/**
* Flush buffers .
* Will be called when seeking
*/
void ( * flush ) ( AVCodecContext * ) ;
} AVCodec ;
/**
* AVHWAccel .
*/
typedef struct AVHWAccel {
/**
* Name of the hardware accelerated codec .
* The name is globally unique among encoders and among decoders ( but an
* encoder and a decoder can share the same name ) .
*/
const char * name ;
/**
* Type of codec implemented by the hardware accelerator .
*
* See AVMEDIA_TYPE_xxx
*/
enum AVMediaType type ;
/**
* Codec implemented by the hardware accelerator .
*
* See AV_CODEC_ID_xxx
*/
enum AVCodecID id ;
/**
* Supported pixel format .
*
* Only hardware accelerated formats are supported here .
*/
enum AVPixelFormat pix_fmt ;
/**
* Hardware accelerated codec capabilities .
* see FF_HWACCEL_CODEC_CAP_ *
*/
int capabilities ;
struct AVHWAccel * next ;
/**
* Called at the beginning of each frame or field picture .
*
* Meaningful frame information ( codec specific ) is guaranteed to
* be parsed at this point . This function is mandatory .
*
* Note that buf can be NULL along with buf_size set to 0.
* Otherwise , this means the whole frame is available at this point .
*
* @ param avctx the codec context
* @ param buf the frame data buffer base
* @ param buf_size the size of the frame in bytes
* @ return zero if successful , a negative value otherwise
*/
int ( * start_frame ) ( AVCodecContext * avctx , const uint8_t * buf , uint32_t buf_size ) ;
/**
* Callback for each slice .
*
* Meaningful slice information ( codec specific ) is guaranteed to
* be parsed at this point . This function is mandatory .
*
* @ param avctx the codec context
* @ param buf the slice data buffer base
* @ param buf_size the size of the slice in bytes
* @ return zero if successful , a negative value otherwise
*/
int ( * decode_slice ) ( AVCodecContext * avctx , const uint8_t * buf , uint32_t buf_size ) ;
/**
* Called at the end of each frame or field picture .
*
* The whole picture is parsed at this point and can now be sent
* to the hardware accelerator . This function is mandatory .
*
* @ param avctx the codec context
* @ return zero if successful , a negative value otherwise
*/
int ( * end_frame ) ( AVCodecContext * avctx ) ;
/**
* Size of HW accelerator private data .
*
* Private data is allocated with av_mallocz ( ) before
* AVCodecContext . get_buffer ( ) and deallocated after
* AVCodecContext . release_buffer ( ) .
*/
int priv_data_size ;
} AVHWAccel ;
/**
* @ defgroup lavc_picture AVPicture
*
* Functions for working with AVPicture
* @ {
*/
/**
* four components are given , that ' s all .
* the last component is alpha
*/
typedef struct AVPicture {
uint8_t * data [ AV_NUM_DATA_POINTERS ] ;
int linesize [ AV_NUM_DATA_POINTERS ] ; ///< number of bytes per line
} AVPicture ;
/**
* @ }
*/
enum AVSubtitleType {
SUBTITLE_NONE ,
SUBTITLE_BITMAP , ///< A bitmap, pict will be set
/**
* Plain text , the text field must be set by the decoder and is
* authoritative . ass and pict fields may contain approximations .
*/
SUBTITLE_TEXT ,
/**
* Formatted text , the ass field must be set by the decoder and is
* authoritative . pict and text fields may contain approximations .
*/
SUBTITLE_ASS ,
} ;
# define AV_SUBTITLE_FLAG_FORCED 0x00000001
typedef struct AVSubtitleRect {
int x ; ///< top left corner of pict, undefined when pict is not set
int y ; ///< top left corner of pict, undefined when pict is not set
int w ; ///< width of pict, undefined when pict is not set
int h ; ///< height of pict, undefined when pict is not set
int nb_colors ; ///< number of colors in pict, undefined when pict is not set
/**
* data + linesize for the bitmap of this subtitle .
* can be set for text / ass as well once they where rendered
*/
AVPicture pict ;
enum AVSubtitleType type ;
char * text ; ///< 0 terminated plain UTF-8 text
/**
* 0 terminated ASS / SSA compatible event line .
* The presentation of this is unaffected by the other values in this
* struct .
*/
char * ass ;
int flags ;
} 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 */
unsigned num_rects ;
AVSubtitleRect * * rects ;
int64_t pts ; ///< Same as packet pts, in AV_TIME_BASE
} AVSubtitle ;
/**
* If c is NULL , returns the first registered codec ,
* if c is non - NULL , returns the next registered codec after c ,
* or NULL if c is the last one .
*/
AVCodec * av_codec_next ( const AVCodec * c ) ;
/**
* Return the LIBAVCODEC_VERSION_INT constant .
*/
unsigned avcodec_version ( void ) ;
/**
* Return the libavcodec build - time configuration .
*/
const char * avcodec_configuration ( void ) ;
/**
* Return the libavcodec license .
*/
const char * avcodec_license ( void ) ;
/**
* Register the codec codec and initialize libavcodec .
*
* @ warning either this function or avcodec_register_all ( ) must be called
* before any other libavcodec functions .
*
* @ see avcodec_register_all ( )
*/
void avcodec_register ( AVCodec * codec ) ;
/**
* Register all the codecs , parsers and bitstream filters which were enabled at
* configuration time . If you do not call this function you can select exactly
* which formats you want to support , by using the individual registration
* functions .
*
* @ see avcodec_register
* @ see av_register_codec_parser
* @ see av_register_bitstream_filter
*/
void avcodec_register_all ( void ) ;
# if FF_API_ALLOC_CONTEXT
/**
* Allocate an AVCodecContext and set 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
*
* @ deprecated use avcodec_alloc_context3 ( )
*/
attribute_deprecated
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 ! */
attribute_deprecated
AVCodecContext * avcodec_alloc_context2 ( enum AVMediaType ) ;
/**
* Set the fields of the given AVCodecContext to default values .
*
* @ param s The AVCodecContext of which the fields should be set to default values .
* @ deprecated use avcodec_get_context_defaults3
*/
attribute_deprecated
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 ! */
attribute_deprecated
void avcodec_get_context_defaults2 ( AVCodecContext * s , enum AVMediaType ) ;
# endif
/**
* Allocate an AVCodecContext and set its fields to default values . The
* resulting struct can be deallocated by calling avcodec_close ( ) on it followed
* by av_free ( ) .
*
* @ param codec if non - NULL , allocate private data and initialize defaults
* for the given codec . It is illegal to then call avcodec_open2 ( )
* with a different codec .
* If NULL , then the codec - specific defaults won ' t be initialized ,
* which may result in suboptimal default settings ( this is
* important mainly for encoders , e . g . libx264 ) .
*
* @ return An AVCodecContext filled with default values or NULL on failure .
* @ see avcodec_get_context_defaults
*/
AVCodecContext * avcodec_alloc_context3 ( const AVCodec * codec ) ;
/**
* Set the fields of the given AVCodecContext to default values corresponding
* to the given codec ( defaults may be codec - dependent ) .
*
* Do not call this function if a non - NULL codec has been passed
* to avcodec_alloc_context3 ( ) that allocated this AVCodecContext .
* If codec is non - NULL , it is illegal to call avcodec_open2 ( ) with a
* different codec on this AVCodecContext .
*/
int avcodec_get_context_defaults3 ( AVCodecContext * s , const AVCodec * codec ) ;
/**
* Get the AVClass for AVCodecContext . It can be used in combination with
* AV_OPT_SEARCH_FAKE_OBJ for examining options .
*
* @ see av_opt_find ( ) .
*/
const AVClass * avcodec_get_class ( void ) ;
/**
* Get the AVClass for AVFrame . It can be used in combination with
* AV_OPT_SEARCH_FAKE_OBJ for examining options .
*
* @ see av_opt_find ( ) .
*/
const AVClass * avcodec_get_frame_class ( void ) ;
/**
* Get the AVClass for AVSubtitleRect . It can be used in combination with
* AV_OPT_SEARCH_FAKE_OBJ for examining options .
*
* @ see av_opt_find ( ) .
*/
const AVClass * avcodec_get_subtitle_rect_class ( void ) ;
/**
* Copy the settings of the source AVCodecContext into the destination
* AVCodecContext . The resulting destination codec context will be
* unopened , i . e . you are required to call avcodec_open2 ( ) before you
* can use this AVCodecContext to decode / encode video / audio data .
*
* @ param dest target codec context , should be initialized with
* avcodec_alloc_context3 ( ) , but otherwise uninitialized
* @ param src source codec context
* @ return AVERROR ( ) on error ( e . g . memory allocation error ) , 0 on success
*/
int avcodec_copy_context ( AVCodecContext * dest , const AVCodecContext * src ) ;
/**
* Allocate an AVFrame and set its fields to default values . The resulting
* struct must be freed using avcodec_free_frame ( ) .
*
* @ return An AVFrame filled with default values or NULL on failure .
* @ see avcodec_get_frame_defaults
*/
AVFrame * avcodec_alloc_frame ( void ) ;
/**
* Set the fields of the given AVFrame to default values .
*
* @ param frame The AVFrame of which the fields should be set to default values .
*/
void avcodec_get_frame_defaults ( AVFrame * frame ) ;
/**
* Free the frame and any dynamically allocated objects in it ,
* e . g . extended_data .
*
* @ param frame frame to be freed . The pointer will be set to NULL .
*
* @ warning this function does NOT free the data buffers themselves
* ( it does not know how , since they might have been allocated with
* a custom get_buffer ( ) ) .
*/
void avcodec_free_frame ( AVFrame * * frame ) ;
# if FF_API_AVCODEC_OPEN
/**
* Initialize 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 safe !
*
* @ code
* avcodec_register_all ( ) ;
* codec = avcodec_find_decoder ( AV_CODEC_ID_H264 ) ;
* if ( ! codec )
* exit ( 1 ) ;
*
* context = avcodec_alloc_context3 ( codec ) ;
*
* if ( avcodec_open ( context , codec ) < 0 )
* exit ( 1 ) ;
* @ endcode
*
* @ param avctx The context which will be set up 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_context3 , avcodec_find_decoder , avcodec_find_encoder , avcodec_close
*
* @ deprecated use avcodec_open2
*/
attribute_deprecated
int avcodec_open ( AVCodecContext * avctx , AVCodec * codec ) ;
# endif
/**
* Initialize the AVCodecContext to use the given AVCodec . Prior to using this
* function the context has to be allocated with avcodec_alloc_context3 ( ) .
*
* 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 safe !
*
* @ code
* avcodec_register_all ( ) ;
* av_dict_set ( & opts , " b " , " 2.5M " , 0 ) ;
* codec = avcodec_find_decoder ( AV_CODEC_ID_H264 ) ;
* if ( ! codec )
* exit ( 1 ) ;
*
* context = avcodec_alloc_context3 ( codec ) ;
*
* if ( avcodec_open2 ( context , codec , opts ) < 0 )
* exit ( 1 ) ;
* @ endcode
*
* @ param avctx The context to initialize .
* @ param codec The codec to open this context for . If a non - NULL codec has been
* previously passed to avcodec_alloc_context3 ( ) or
* avcodec_get_context_defaults3 ( ) for this context , then this
* parameter MUST be either NULL or equal to the previously passed
* codec .
* @ param options A dictionary filled with AVCodecContext and codec - private options .
* On return this object will be filled with options that were not found .
*
* @ return zero on success , a negative value on error
* @ see avcodec_alloc_context3 ( ) , avcodec_find_decoder ( ) , avcodec_find_encoder ( ) ,
* av_dict_set ( ) , av_opt_find ( ) .
*/
int avcodec_open2 ( AVCodecContext * avctx , const AVCodec * codec , AVDictionary * * options ) ;
/**
* Close a given AVCodecContext and free all the data associated with it
* ( but not the AVCodecContext itself ) .
*
* Calling this function on an AVCodecContext that hasn ' t been opened will free
* the codec - specific data allocated in avcodec_alloc_context3 ( ) /
* avcodec_get_context_defaults3 ( ) with a non - NULL codec . Subsequent calls will
* do nothing .
*/
int avcodec_close ( AVCodecContext * avctx ) ;
/**
* Free all allocated data in the given subtitle struct .
*
* @ param sub AVSubtitle to free .
*/
void avsubtitle_free ( AVSubtitle * sub ) ;
/**
* @ }
*/
/**
* @ addtogroup lavc_packet
* @ {
*/
# if FF_API_DESTRUCT_PACKET
/**
* Default packet destructor .
* @ deprecated use the AVBuffer API instead
*/
attribute_deprecated
void av_destruct_packet ( AVPacket * pkt ) ;
# endif
/**
* Initialize optional fields of a packet with default values .
*
* Note , this does not touch the data and size members , which have to be
* initialized separately .
*
* @ param pkt packet
*/
void av_init_packet ( AVPacket * pkt ) ;
/**
* Allocate the payload of a packet and initialize its fields with
* 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 ) ;
/**
* Reduce packet size , correctly zeroing padding
*
* @ param pkt packet
* @ param size new size
*/
void av_shrink_packet ( AVPacket * pkt , int size ) ;
/**
* Increase packet size , correctly zeroing padding
*
* @ param pkt packet
* @ param grow_by number of bytes by which to increase the size of the packet
*/
int av_grow_packet ( AVPacket * pkt , int grow_by ) ;
/**
* Initialize a reference - counted packet from av_malloc ( ) ed data .
*
* @ param pkt packet to be initialized . This function will set the data , size ,
* buf and destruct fields , all others are left untouched .
* @ param data Data allocated by av_malloc ( ) to be used as packet data . If this
* function returns successfully , the data is owned by the underlying AVBuffer .
* The caller may not access the data through other means .
* @ param size size of data in bytes , without the padding . I . e . the full buffer
* size is assumed to be size + FF_INPUT_BUFFER_PADDING_SIZE .
*
* @ return 0 on success , a negative AVERROR on error
*/
int av_packet_from_data ( AVPacket * pkt , uint8_t * data , 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 ) ;
/**
* Copy packet , including contents
*
* @ return 0 on success , negative AVERROR on fail
*/
int av_copy_packet ( AVPacket * dst , AVPacket * src ) ;
/**
* Copy packet side data
*
* @ return 0 on success , negative AVERROR on fail
*/
int av_copy_packet_side_data ( AVPacket * dst , AVPacket * src ) ;
/**
* Free a packet .
*
* @ param pkt packet to free
*/
void av_free_packet ( AVPacket * pkt ) ;
/**
* Allocate new information of a packet .
*
* @ param pkt packet
* @ param type side information type
* @ param size side information size
* @ return pointer to fresh allocated data or NULL otherwise
*/
uint8_t * av_packet_new_side_data ( AVPacket * pkt , enum AVPacketSideDataType type ,
int size ) ;
/**
* Shrink the already allocated side data buffer
*
* @ param pkt packet
* @ param type side information type
* @ param size new side information size
* @ return 0 on success , < 0 on failure
*/
int av_packet_shrink_side_data ( AVPacket * pkt , enum AVPacketSideDataType type ,
int size ) ;
/**
* Get side information from packet .
*
* @ param pkt packet
* @ param type desired side information type
* @ param size pointer for side information size to store ( optional )
* @ return pointer to data if present or NULL otherwise
*/
uint8_t * av_packet_get_side_data ( AVPacket * pkt , enum AVPacketSideDataType type ,
int * size ) ;
int av_packet_merge_side_data ( AVPacket * pkt ) ;
int av_packet_split_side_data ( AVPacket * pkt ) ;
/**
* @ }
*/
/**
* @ addtogroup lavc_decoding
* @ {
*/
/**
* Find a registered decoder with a matching codec ID .
*
* @ param id AVCodecID of the requested decoder
* @ return A decoder if one was found , NULL otherwise .
*/
AVCodec * avcodec_find_decoder ( enum AVCodecID id ) ;
/**
* Find a registered 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 ) ;
# if FF_API_GET_BUFFER
attribute_deprecated int avcodec_default_get_buffer ( AVCodecContext * s , AVFrame * pic ) ;
attribute_deprecated void avcodec_default_release_buffer ( AVCodecContext * s , AVFrame * pic ) ;
attribute_deprecated int avcodec_default_reget_buffer ( AVCodecContext * s , AVFrame * pic ) ;
# endif
/**
* The default callback for AVCodecContext . get_buffer2 ( ) . It is made public so
* it can be called by custom get_buffer2 ( ) implementations for decoders without
* CODEC_CAP_DR1 set .
*/
int avcodec_default_get_buffer2 ( AVCodecContext * s , AVFrame * frame , int flags ) ;
/**
* Return the amount of padding in pixels which the get_buffer callback must
* provide around the edge of the image for codecs which do not have the
* CODEC_FLAG_EMU_EDGE flag .
*
* @ return Required padding in pixels .
*/
unsigned avcodec_get_edge_width ( void ) ;
/**
* Modify width and height values so that they will result in a memory
* buffer that is acceptable for the codec if you do not use any horizontal
* padding .
*
* May only be used if a codec with CODEC_CAP_DR1 has been opened .
* If CODEC_FLAG_EMU_EDGE is not set , the dimensions must have been increased
* according to avcodec_get_edge_width ( ) before .
*/
void avcodec_align_dimensions ( AVCodecContext * s , int * width , int * height ) ;
/**
* Modify width and height values so that they will result in a memory
* buffer that is acceptable for the codec if you also ensure that all
* line sizes are a multiple of the respective linesize_align [ i ] .
*
* May only be used if a codec with CODEC_CAP_DR1 has been opened .
* If CODEC_FLAG_EMU_EDGE is not set , the dimensions must have been increased
* according to avcodec_get_edge_width ( ) before .
*/
void avcodec_align_dimensions2 ( AVCodecContext * s , int * width , int * height ,
int linesize_align [ AV_NUM_DATA_POINTERS ] ) ;
# if FF_API_OLD_DECODE_AUDIO
/**
* Wrapper function which calls avcodec_decode_audio4 .
*
* @ deprecated Use avcodec_decode_audio4 instead .
*
* Decode the audio frame of size avpkt - > size from avpkt - > data into samples .
* Some decoders may support multiple frames in a single AVPacket , such
* decoders would then just decode the first frame . In this case ,
* avcodec_decode_audio3 has to be called again with an AVPacket that contains
* the remaining data in order to decode the second frame etc .
* If no frame
* could be outputted , frame_size_ptr is zero . Otherwise , it is the
* decompressed frame size in bytes .
*
* @ warning You must set frame_size_ptr to the allocated size of the
* output buffer before calling avcodec_decode_audio3 ( ) .
*
* @ warning The input buffer must be 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 avpkt - > data should be set to 0 to ensure that
* no overreading happens for damaged MPEG streams .
*
* @ warning You must not provide a custom get_buffer ( ) when using
* avcodec_decode_audio3 ( ) . Doing so will override it with
* avcodec_default_get_buffer . Use avcodec_decode_audio4 ( ) instead ,
* which does allow the application to provide a custom get_buffer ( ) .
*
* @ note You might have to align the input buffer avpkt - > data and output buffer
* 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 , avpkt - > data should have 4 byte alignment at minimum and
* samples should be 16 byte aligned unless the CPU doesn ' t need it
* ( AltiVec and SSE do ) .
*
* @ note Codecs which have the CODEC_CAP_DELAY capability set have a delay
* between input and output , these need to be fed with avpkt - > data = NULL ,
* avpkt - > size = 0 at the end to return the remaining frames .
*
* @ param avctx the codec context
* @ param [ out ] samples the output buffer , sample type in avctx - > sample_fmt
* If the sample format is planar , each channel plane will
* be the same size , with no padding between channels .
* @ param [ in , out ] frame_size_ptr the output buffer size in bytes
* @ param [ in ] avpkt The input AVPacket containing the input buffer .
* You can create such packet with av_init_packet ( ) and by then setting
* data and size , some decoders might in addition need other fields .
* All decoders are designed to use the least fields possible though .
* @ return On error a negative value is returned , otherwise the number of bytes
* used or zero if no frame data was decompressed ( used ) from the input AVPacket .
*/
attribute_deprecated int avcodec_decode_audio3 ( AVCodecContext * avctx , int16_t * samples ,
int * frame_size_ptr ,
AVPacket * avpkt ) ;
# endif
/**
* Decode the audio frame of size avpkt - > size from avpkt - > data into frame .
*
* Some decoders may support multiple frames in a single AVPacket . Such
* decoders would then just decode the first frame . In this case ,
* avcodec_decode_audio4 has to be called again with an AVPacket containing
* the remaining data in order to decode the second frame , etc . . .
* Even if no frames are returned , the packet needs to be fed to the decoder
* with remaining data until it is completely consumed or an error occurs .
*
* @ warning The input buffer , avpkt - > data must be 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 .
*
* @ note You might have to align the input buffer . The alignment requirements
* depend on the CPU and the decoder .
*
* @ param avctx the codec context
* @ param [ out ] frame The AVFrame in which to store decoded audio samples .
* The decoder will allocate a buffer for the decoded frame by
* calling the AVCodecContext . get_buffer2 ( ) callback .
* When AVCodecContext . refcounted_frames is set to 1 , the frame is
* reference counted and the returned reference belongs to the
* caller . The caller must release the frame using av_frame_unref ( )
* when the frame is no longer needed . The caller may safely write
* to the frame if av_frame_is_writable ( ) returns 1.
* When AVCodecContext . refcounted_frames is set to 0 , the returned
* reference belongs to the decoder and is valid only until the
* next call to this function or until closing the decoder .
* The caller may not write to it .
* @ param [ out ] got_frame_ptr Zero if no frame could be decoded , otherwise it is
* non - zero .
* @ param [ in ] avpkt The input AVPacket containing the input buffer .
* At least avpkt - > data and avpkt - > size should be set . Some
* decoders might also require additional fields to be set .
* @ return A negative error code is returned if an error occurred during
* decoding , otherwise the number of bytes consumed from the input
* AVPacket is returned .
*/
int avcodec_decode_audio4 ( AVCodecContext * avctx , AVFrame * frame ,
int * got_frame_ptr , const AVPacket * avpkt ) ;
/**
* Decode the video frame of size avpkt - > size from avpkt - > data into picture .
* Some decoders may support multiple frames in a single AVPacket , such
* decoders would then just decode the first frame .
*
* @ warning The input buffer must be 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 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 avpkt - > data .
* 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 , avpkt - > data should have 4 byte alignment at minimum .
*
* @ note Codecs which have the CODEC_CAP_DELAY capability set have a delay
* between input and output , these need to be fed with avpkt - > data = NULL ,
* avpkt - > size = 0 at the end to return the remaining frames .
*
* @ param avctx the codec context
* @ param [ out ] picture The AVFrame in which the decoded video frame will be stored .
* Use av_frame_alloc ( ) to get an AVFrame . The codec will
* allocate memory for the actual bitmap by calling the
* AVCodecContext . get_buffer2 ( ) callback .
* When AVCodecContext . refcounted_frames is set to 1 , the frame is
* reference counted and the returned reference belongs to the
* caller . The caller must release the frame using av_frame_unref ( )
* when the frame is no longer needed . The caller may safely write
* to the frame if av_frame_is_writable ( ) returns 1.
* When AVCodecContext . refcounted_frames is set to 0 , the returned
* reference belongs to the decoder and is valid only until the
* next call to this function or until closing the decoder . The
* caller may not write to it .
*
* @ param [ in ] avpkt The input AVpacket containing the input buffer .
* You can create such packet with av_init_packet ( ) and by then setting
* data and size , some decoders might in addition need other fields like
* flags & AV_PKT_FLAG_KEY . All decoders are designed to use the least
* fields possible .
* @ param [ in , out ] got_picture_ptr Zero if no frame could be decompressed , otherwise , it is nonzero .
* @ 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_video2 ( AVCodecContext * avctx , AVFrame * picture ,
int * got_picture_ptr ,
const AVPacket * avpkt ) ;
/**
* Decode a subtitle message .
* Return a negative value on 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 .
* Note that CODEC_CAP_DR1 is not available for subtitle codecs . This is for
* simplicity , because the performance difference is expect to be negligible
* and reusing a get_buffer written for video codecs would probably perform badly
* due to a potentially very different allocation pattern .
*
* @ param avctx the codec context
* @ param [ out ] sub The AVSubtitle in which the decoded subtitle will be stored , must be
freed with avsubtitle_free if * got_sub_ptr is set .
* @ param [ in , out ] got_sub_ptr Zero if no subtitle could be decompressed , otherwise , it is nonzero .
* @ param [ in ] avpkt The input AVPacket containing the input buffer .
*/
int avcodec_decode_subtitle2 ( AVCodecContext * avctx , AVSubtitle * sub ,
int * got_sub_ptr ,
AVPacket * avpkt ) ;
/**
* @ defgroup lavc_parsing Frame parsing
* @ {
*/
enum AVPictureStructure {
AV_PICTURE_STRUCTURE_UNKNOWN , //< unknown
AV_PICTURE_STRUCTURE_TOP_FIELD , //< coded as top field
AV_PICTURE_STRUCTURE_BOTTOM_FIELD , //< coded as bottom field
AV_PICTURE_STRUCTURE_FRAME , //< coded as frame
} ;
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 next_frame_offset ; /* offset of the next frame */
/* video info */
int pict_type ; /* XXX: Put it back in AVCodecContext. */
/**
* This field is used for proper frame duration computation in lavf .
* It signals , how much longer the frame duration of the current frame
* is compared to normal frame duration .
*
* frame_duration = ( 1 + repeat_pict ) * time_base
*
* It is used by codecs like H .264 to display telecined material .
*/
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
# define PARSER_FLAG_ONCE 0x0002
/// Set if the parser has a valid file offset
# define PARSER_FLAG_FETCHED_OFFSET 0x0004
# define PARSER_FLAG_USE_CODEC_TS 0x1000
int64_t offset ; ///< byte offset from starting packet start
int64_t cur_frame_end [ AV_PARSER_PTS_NB ] ;
/**
* Set by parser to 1 for key frames and 0 for non - key frames .
* It is initialized to - 1 , so if the parser doesn ' t set this flag ,
* old - style fallback using AV_PICTURE_TYPE_I picture type as key frames
* will be used .
*/
int key_frame ;
/**
* Time difference in stream time base units from the pts of this
* packet to the point at which the output from the decoder has converged
* independent from the availability of previous frames . That is , the
* frames are virtually identical no matter if decoding started from
* the very first frame or from this keyframe .
* Is AV_NOPTS_VALUE if unknown .
* This field is not the display duration of the current frame .
* This field has no meaning if the packet does not have AV_PKT_FLAG_KEY
* set .
*
* The purpose of this field is to allow seeking in streams that have no
* keyframes in the conventional sense . It corresponds to the
* recovery point SEI in H .264 and match_time_delta in NUT . It is also
* essential for some types of subtitle streams to ensure that all
* subtitles are correctly displayed after seeking .
*/
int64_t convergence_duration ;
// Timestamp generation support:
/**
* Synchronization point for start of timestamp generation .
*
* Set to > 0 for sync point , 0 for no sync point and < 0 for undefined
* ( default ) .
*
* For example , this corresponds to presence of H .264 buffering period
* SEI message .
*/
int dts_sync_point ;
/**
* Offset of the current timestamp against last timestamp sync point in
* units of AVCodecContext . time_base .
*
* Set to INT_MIN when dts_sync_point unused . Otherwise , it must
* contain a valid timestamp offset .
*
* Note that the timestamp of sync point has usually a nonzero
* dts_ref_dts_delta , which refers to the previous sync point . Offset of
* the next frame after timestamp sync point will be usually 1.
*
* For example , this corresponds to H .264 cpb_removal_delay .
*/
int dts_ref_dts_delta ;
/**
* Presentation delay of current frame in units of AVCodecContext . time_base .
*
* Set to INT_MIN when dts_sync_point unused . Otherwise , it must
* contain valid non - negative timestamp delta ( presentation time of a frame
* must not lie in the past ) .
*
* This delay represents the difference between decoding and presentation
* time of the frame .
*
* For example , this corresponds to H .264 dpb_output_delay .
*/
int pts_dts_delta ;
/**
* Position of the packet in file .
*
* Analogous to cur_frame_pts / dts
*/
int64_t cur_frame_pos [ AV_PARSER_PTS_NB ] ;
/**
* Byte position of currently parsed frame in stream .
*/
int64_t pos ;
/**
* Previous frame byte position .
*/
int64_t last_pos ;
/**
* Duration of the current frame .
* For audio , this is in units of 1 / AVCodecContext . sample_rate .
* For all other types , this is in units of AVCodecContext . time_base .
*/
int duration ;
enum AVFieldOrder field_order ;
/**
* Indicate whether a picture is coded as a frame , top field or bottom field .
*
* For example , H .264 field_pic_flag equal to 0 corresponds to
* AV_PICTURE_STRUCTURE_FRAME . An H .264 picture with field_pic_flag
* equal to 1 and bottom_field_flag equal to 0 corresponds to
* AV_PICTURE_STRUCTURE_TOP_FIELD .
*/
enum AVPictureStructure picture_structure ;
} 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 ,
const 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 ;
AVCodecParser * av_parser_next ( AVCodecParser * c ) ;
void av_register_codec_parser ( AVCodecParser * parser ) ;
AVCodecParserContext * av_parser_init ( int codec_id ) ;
/**
* Parse a packet .
*
* @ param s parser context .
* @ param avctx codec context .
* @ param poutbuf set to pointer to parsed buffer or NULL if not yet finished .
* @ param poutbuf_size set to size of parsed buffer or zero if not yet finished .
* @ param buf input buffer .
* @ param buf_size input length , to signal EOF , this should be 0 ( so that the last frame can be output ) .
* @ param pts input presentation timestamp .
* @ param dts input decoding timestamp .
* @ param pos input byte position in stream .
* @ return the number of bytes of the input bitstream used .
*
* Example :
* @ code
* while ( in_len ) {
* len = av_parser_parse2 ( myparser , AVCodecContext , & data , & size ,
* in_data , in_len ,
* pts , dts , pos ) ;
* in_data + = len ;
* in_len - = len ;
*
* if ( size )
* decode_frame ( data , size ) ;
* }
* @ endcode
*/
int av_parser_parse2 ( AVCodecParserContext * s ,
AVCodecContext * avctx ,
uint8_t * * poutbuf , int * poutbuf_size ,
const uint8_t * buf , int buf_size ,
int64_t pts , int64_t dts ,
int64_t pos ) ;
/**
* @ return 0 if the output buffer is a subset of the input , 1 if it is allocated and must be freed
* @ deprecated use AVBitStreamFilter
*/
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 ) ;
/**
* @ }
* @ }
*/
/**
* @ addtogroup lavc_encoding
* @ {
*/
/**
* Find a registered encoder with a matching codec ID .
*
* @ param id AVCodecID of the requested encoder
* @ return An encoder if one was found , NULL otherwise .
*/
AVCodec * avcodec_find_encoder ( enum AVCodecID id ) ;
/**
* Find a registered 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 ) ;
# if FF_API_OLD_ENCODE_AUDIO
/**
* Encode an audio frame from samples into buf .
*
* @ deprecated Use avcodec_encode_audio2 instead .
*
* @ note The output buffer should be at least FF_MIN_BUFFER_SIZE bytes large .
* However , for codecs with avctx - > frame_size equal to 0 ( e . g . PCM ) the user
* will know how much space is needed because it depends on the value passed
* in buf_size as described below . In that case a lower value can be used .
*
* @ 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
* The number of samples read from this buffer is frame_size * channels ,
* both of which are defined in avctx .
* For codecs which have avctx - > frame_size equal to 0 ( e . g . PCM ) the number of
* samples read from samples is equal to :
* buf_size * 8 / ( avctx - > channels * av_get_bits_per_sample ( avctx - > codec_id ) )
* This also implies that av_get_bits_per_sample ( ) must not return 0 for these
* codecs .
* @ return On error a negative value is returned , on success zero or the number
* of bytes used to encode the data read from the input buffer .
*/
int attribute_deprecated avcodec_encode_audio ( AVCodecContext * avctx ,
uint8_t * buf , int buf_size ,
const short * samples ) ;
# endif
/**
* Encode a frame of audio .
*
* Takes input samples from frame and writes the next output packet , if
* available , to avpkt . The output packet does not necessarily contain data for
* the most recent frame , as encoders can delay , split , and combine input frames
* internally as needed .
*
* @ param avctx codec context
* @ param avpkt output AVPacket .
* The user can supply an output buffer by setting
* avpkt - > data and avpkt - > size prior to calling the
* function , but if the size of the user - provided data is not
* large enough , encoding will fail . If avpkt - > data and
* avpkt - > size are set , avpkt - > destruct must also be set . All
* other AVPacket fields will be reset by the encoder using
* av_init_packet ( ) . If avpkt - > data is NULL , the encoder will
* allocate it . The encoder will set avpkt - > size to the size
* of the output packet .
*
* If this function fails or produces no output , avpkt will be
* freed using av_free_packet ( ) ( i . e . avpkt - > destruct will be
* called to free the user supplied buffer ) .
* @ param [ in ] frame AVFrame containing the raw audio data to be encoded .
* May be NULL when flushing an encoder that has the
* CODEC_CAP_DELAY capability set .
* If CODEC_CAP_VARIABLE_FRAME_SIZE is set , then each frame
* can have any number of samples .
* If it is not set , frame - > nb_samples must be equal to
* avctx - > frame_size for all frames except the last .
* The final frame may be smaller than avctx - > frame_size .
* @ param [ out ] got_packet_ptr This field is set to 1 by libavcodec if the
* output packet is non - empty , and to 0 if it is
* empty . If the function returns an error , the
* packet can be assumed to be invalid , and the
* value of got_packet_ptr is undefined and should
* not be used .
* @ return 0 on success , negative error code on failure
*/
int avcodec_encode_audio2 ( AVCodecContext * avctx , AVPacket * avpkt ,
const AVFrame * frame , int * got_packet_ptr ) ;
# if FF_API_OLD_ENCODE_VIDEO
/**
* @ deprecated use avcodec_encode_video2 ( ) instead .
*
* Encode a video frame from pict into buf .
* The input picture should be
* stored using a specific format , namely 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 output buffer 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 output buffer .
*/
attribute_deprecated
int avcodec_encode_video ( AVCodecContext * avctx , uint8_t * buf , int buf_size ,
const AVFrame * pict ) ;
# endif
/**
* Encode a frame of video .
*
* Takes input raw video data from frame and writes the next output packet , if
* available , to avpkt . The output packet does not necessarily contain data for
* the most recent frame , as encoders can delay and reorder input frames
* internally as needed .
*
* @ param avctx codec context
* @ param avpkt output AVPacket .
* The user can supply an output buffer by setting
* avpkt - > data and avpkt - > size prior to calling the
* function , but if the size of the user - provided data is not
* large enough , encoding will fail . All other AVPacket fields
* will be reset by the encoder using av_init_packet ( ) . If
* avpkt - > data is NULL , the encoder will allocate it .
* The encoder will set avpkt - > size to the size of the
* output packet . The returned data ( if any ) belongs to the
* caller , he is responsible for freeing it .
*
* If this function fails or produces no output , avpkt will be
* freed using av_free_packet ( ) ( i . e . avpkt - > destruct will be
* called to free the user supplied buffer ) .
* @ param [ in ] frame AVFrame containing the raw video data to be encoded .
* May be NULL when flushing an encoder that has the
* CODEC_CAP_DELAY capability set .
* @ param [ out ] got_packet_ptr This field is set to 1 by libavcodec if the
* output packet is non - empty , and to 0 if it is
* empty . If the function returns an error , the
* packet can be assumed to be invalid , and the
* value of got_packet_ptr is undefined and should
* not be used .
* @ return 0 on success , negative error code on failure
*/
int avcodec_encode_video2 ( AVCodecContext * avctx , AVPacket * avpkt ,
const AVFrame * frame , int * got_packet_ptr ) ;
int avcodec_encode_subtitle ( AVCodecContext * avctx , uint8_t * buf , int buf_size ,
const AVSubtitle * sub ) ;
/**
* @ }
*/
# if FF_API_AVCODEC_RESAMPLE
/**
* @ defgroup lavc_resample Audio resampling
* @ ingroup libavc
* @ deprecated use libswresample instead
*
* @ {
*/
struct ReSampleContext ;
struct AVResampleContext ;
typedef struct ReSampleContext ReSampleContext ;
/**
* Initialize audio resampling context .
*
* @ param output_channels number of output channels
* @ param input_channels number of input channels
* @ param output_rate output sample rate
* @ param input_rate input sample rate
* @ param sample_fmt_out requested output sample format
* @ param sample_fmt_in input sample format
* @ param filter_length length of each FIR filter in the filterbank relative to the cutoff frequency
* @ param log2_phase_count log2 of the number of entries in the polyphase filterbank
* @ param linear if 1 then the used FIR filter will be linearly interpolated
between the 2 closest , if 0 the closest will be used
* @ param cutoff cutoff frequency , 1.0 corresponds to half the output sampling rate
* @ return allocated ReSampleContext , NULL if error occurred
*/
attribute_deprecated
ReSampleContext * av_audio_resample_init ( int output_channels , int input_channels ,
int output_rate , int input_rate ,
enum AVSampleFormat sample_fmt_out ,
enum AVSampleFormat sample_fmt_in ,
int filter_length , int log2_phase_count ,
int linear , double cutoff ) ;
attribute_deprecated
int audio_resample ( ReSampleContext * s , short * output , short * input , int nb_samples ) ;
/**
* Free resample context .
*
* @ param s a non - NULL pointer to a resample context previously
* created with av_audio_resample_init ( )
*/
attribute_deprecated
void audio_resample_close ( ReSampleContext * s ) ;
/**
* Initialize an audio resampler .
* Note , if either rate is not an integer then simply scale both rates up so they are .
* @ param filter_length length of each FIR filter in the filterbank relative to the cutoff freq
* @ param log2_phase_count log2 of the number of entries in the polyphase filterbank
* @ param linear If 1 then the used FIR filter will be linearly interpolated
between the 2 closest , if 0 the closest will be used
* @ param cutoff cutoff frequency , 1.0 corresponds to half the output sampling rate
*/
attribute_deprecated
struct AVResampleContext * av_resample_init ( int out_rate , int in_rate , int filter_length , int log2_phase_count , int linear , double cutoff ) ;
/**
* Resample an array of samples using a previously configured context .
* @ param src an array of unconsumed samples
* @ param consumed the number of samples of src which have been consumed are returned here
* @ param src_size the number of unconsumed samples available
* @ param dst_size the amount of space in samples available in dst
* @ param update_ctx If this is 0 then the context will not be modified , that way several channels can be resampled with the same context .
* @ return the number of samples written in dst or - 1 if an error occurred
*/
attribute_deprecated
int av_resample ( struct AVResampleContext * c , short * dst , short * src , int * consumed , int src_size , int dst_size , int update_ctx ) ;
/**
* Compensate samplerate / timestamp drift . The compensation is done by changing
* the resampler parameters , so no audible clicks or similar distortions occur
* @ param compensation_distance distance in output samples over which the compensation should be performed
* @ param sample_delta number of output samples which should be output less
*
* example : av_resample_compensate ( c , 10 , 500 )
* here instead of 510 samples only 500 samples would be output
*
* note , due to rounding the actual compensation might be slightly different ,
* especially if the compensation_distance is large and the in_rate used during init is small
*/
attribute_deprecated
void av_resample_compensate ( struct AVResampleContext * c , int sample_delta , int compensation_distance ) ;
attribute_deprecated
void av_resample_close ( struct AVResampleContext * c ) ;
/**
* @ }
*/
# endif
/**
* @ addtogroup lavc_picture
* @ {
*/
/**
* Allocate memory for a picture . Call avpicture_free ( ) to free it .
*
* @ see avpicture_fill ( )
*
* @ 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 , enum AVPixelFormat pix_fmt , int width , int height ) ;
/**
* Free a picture previously allocated by avpicture_alloc ( ) .
* The data buffer used by the AVPicture is freed , but the AVPicture structure
* itself is not .
*
* @ param picture the AVPicture to be freed
*/
void avpicture_free ( AVPicture * picture ) ;
/**
* Fill in the AVPicture fields , always assume a linesize alignment of
* 1.
*
* @ see av_image_fill_arrays ( )
*/
int avpicture_fill ( AVPicture * picture , const uint8_t * ptr ,
enum AVPixelFormat pix_fmt , int width , int height ) ;
/**
* Copy pixel data from an AVPicture into a buffer , always assume a
* linesize alignment of 1.
*
* @ see av_image_copy_to_buffer ( )
*/
int avpicture_layout ( const AVPicture * src , enum AVPixelFormat 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 .
* Always assume a linesize alignment of 1.
*
* @ see av_image_get_buffer_size ( ) .
*/
int avpicture_get_size ( enum AVPixelFormat pix_fmt , int width , int height ) ;
# if FF_API_DEINTERLACE
/**
* deinterlace - if not supported return - 1
*
* @ deprecated - use yadif ( in libavfilter ) instead
*/
attribute_deprecated
int avpicture_deinterlace ( AVPicture * dst , const AVPicture * src ,
enum AVPixelFormat pix_fmt , int width , int height ) ;
# endif
/**
* Copy image src to dst . Wraps av_image_copy ( ) .
*/
void av_picture_copy ( AVPicture * dst , const AVPicture * src ,
enum AVPixelFormat pix_fmt , int width , int height ) ;
/**
* Crop image top and left side .
*/
int av_picture_crop ( AVPicture * dst , const AVPicture * src ,
enum AVPixelFormat pix_fmt , int top_band , int left_band ) ;
/**
* Pad image .
*/
int av_picture_pad ( AVPicture * dst , const AVPicture * src , int height , int width , enum AVPixelFormat pix_fmt ,
int padtop , int padbottom , int padleft , int padright , int * color ) ;
/**
* @ }
*/
/**
* @ defgroup lavc_misc Utility functions
* @ ingroup libavc
*
* Miscellaneous utility functions related to both encoding and decoding
* ( or neither ) .
* @ {
*/
/**
* @ defgroup lavc_misc_pixfmt Pixel formats
*
* Functions for working with pixel formats .
* @ {
*/
/**
* Utility function to access log2_chroma_w log2_chroma_h from
* the pixel format AVPixFmtDescriptor .
*
* This function asserts that pix_fmt is valid . See av_pix_fmt_get_chroma_sub_sample
* for one that returns a failure code and continues in case of invalid
* pix_fmts .
*
* @ param [ in ] pix_fmt the pixel format
* @ param [ out ] h_shift store log2_chroma_w
* @ param [ out ] v_shift store log2_chroma_h
*
* @ see av_pix_fmt_get_chroma_sub_sample
*/
void avcodec_get_chroma_sub_sample ( enum AVPixelFormat pix_fmt , int * h_shift , int * v_shift ) ;
/**
* Return a value representing the fourCC code associated to the
* pixel format pix_fmt , or 0 if no associated fourCC code can be
* found .
*/
unsigned int avcodec_pix_fmt_to_codec_tag ( enum AVPixelFormat pix_fmt ) ;
# 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) */
/**
* Compute 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 about 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
* ( maximum loss for an invalid dst_pix_fmt ) .
*/
int avcodec_get_pix_fmt_loss ( enum AVPixelFormat dst_pix_fmt , enum AVPixelFormat src_pix_fmt ,
int has_alpha ) ;
/**
* Find 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_of_2 ( ) searches which of
* the given pixel formats should be used to suffer the least amount of loss .
* The pixel formats from which it chooses one , are determined by the
* pix_fmt_list parameter .
*
*
* @ param [ in ] pix_fmt_list AV_PIX_FMT_NONE terminated array of pixel formats 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 .
*/
enum AVPixelFormat avcodec_find_best_pix_fmt_of_list ( enum AVPixelFormat * pix_fmt_list ,
enum AVPixelFormat src_pix_fmt ,
int has_alpha , int * loss_ptr ) ;
/**
* Find the best pixel format to convert to given a certain source pixel
* format and a selection of two destination pixel formats . 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_of_2 ( ) selects which of
* the given pixel formats should be used to suffer the least amount of loss .
*
* If one of the destination formats is AV_PIX_FMT_NONE the other pixel format ( if valid ) will be
* returned .
*
* @ code
* src_pix_fmt = AV_PIX_FMT_YUV420P ;
* dst_pix_fmt1 = AV_PIX_FMT_RGB24 ;
* dst_pix_fmt2 = AV_PIX_FMT_GRAY8 ;
* dst_pix_fmt3 = AV_PIX_FMT_RGB8 ;
* loss = FF_LOSS_CHROMA ; // don't care about chroma loss, so chroma loss will be ignored.
* dst_pix_fmt = avcodec_find_best_pix_fmt_of_2 ( dst_pix_fmt1 , dst_pix_fmt2 , src_pix_fmt , alpha , & loss ) ;
* dst_pix_fmt = avcodec_find_best_pix_fmt_of_2 ( dst_pix_fmt , dst_pix_fmt3 , src_pix_fmt , alpha , & loss ) ;
* @ endcode
*
* @ param [ in ] dst_pix_fmt1 One of the two destination pixel formats to choose from
* @ param [ in ] dst_pix_fmt2 The other of the two destination pixel formats 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 [ in , out ] loss_ptr Combination of loss flags . In : selects which of the losses to ignore , i . e .
* NULL or value of zero means we care about all losses . Out : the loss
* that occurs when converting from src to selected dst pixel format .
* @ return The best pixel format to convert to or - 1 if none was found .
*/
enum AVPixelFormat avcodec_find_best_pix_fmt_of_2 ( enum AVPixelFormat dst_pix_fmt1 , enum AVPixelFormat dst_pix_fmt2 ,
enum AVPixelFormat src_pix_fmt , int has_alpha , int * loss_ptr ) ;
attribute_deprecated
# if AV_HAVE_INCOMPATIBLE_LIBAV_ABI
enum AVPixelFormat avcodec_find_best_pix_fmt2 ( enum AVPixelFormat * pix_fmt_list ,
enum AVPixelFormat src_pix_fmt ,
int has_alpha , int * loss_ptr ) ;
# else
enum AVPixelFormat avcodec_find_best_pix_fmt2 ( enum AVPixelFormat dst_pix_fmt1 , enum AVPixelFormat dst_pix_fmt2 ,
enum AVPixelFormat src_pix_fmt , int has_alpha , int * loss_ptr ) ;
# endif
enum AVPixelFormat avcodec_default_get_format ( struct AVCodecContext * s , const enum AVPixelFormat * fmt ) ;
/**
* @ }
*/
void avcodec_set_dimensions ( AVCodecContext * s , int width , int height ) ;
/**
* Put a string representing the codec tag codec_tag in buf .
*
* @ param buf_size size in bytes of buf
* @ return the length of the string that would have been generated if
* enough space had been available , excluding the trailing null
*/
size_t av_get_codec_tag_string ( char * buf , size_t buf_size , unsigned int codec_tag ) ;
void avcodec_string ( char * buf , int buf_size , AVCodecContext * enc , int encode ) ;
/**
* Return a name for the specified profile , if available .
*
* @ param codec the codec that is searched for the given profile
* @ param profile the profile value for which a name is requested
* @ return A name for the profile if found , NULL otherwise .
*/
const char * av_get_profile_name ( const AVCodec * codec , int profile ) ;
int avcodec_default_execute ( AVCodecContext * c , int ( * func ) ( AVCodecContext * c2 , void * arg2 ) , void * arg , int * ret , int count , int size ) ;
int avcodec_default_execute2 ( AVCodecContext * c , int ( * func ) ( AVCodecContext * c2 , void * arg2 , int , int ) , void * arg , int * ret , int count ) ;
//FIXME func typedef
/**
* Fill AVFrame audio data and linesize pointers .
*
* The buffer buf must be a preallocated buffer with a size big enough
* to contain the specified samples amount . The filled AVFrame data
* pointers will point to this buffer .
*
* AVFrame extended_data channel pointers are allocated if necessary for
* planar audio .
*
* @ param frame the AVFrame
* frame - > nb_samples must be set prior to calling the
* function . This function fills in frame - > data ,
* frame - > extended_data , frame - > linesize [ 0 ] .
* @ param nb_channels channel count
* @ param sample_fmt sample format
* @ param buf buffer to use for frame data
* @ param buf_size size of buffer
* @ param align plane size sample alignment ( 0 = default )
* @ return > = 0 on success , negative error code on failure
* @ todo return the size in bytes required to store the samples in
* case of success , at the next libavutil bump
*/
int avcodec_fill_audio_frame ( AVFrame * frame , int nb_channels ,
enum AVSampleFormat sample_fmt , const uint8_t * buf ,
int buf_size , int align ) ;
/**
* Flush buffers , should be called when seeking or when switching to a different stream .
*/
void avcodec_flush_buffers ( AVCodecContext * avctx ) ;
/**
* Return 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 AVCodecID codec_id ) ;
/**
* Return the PCM codec associated with a sample format .
* @ param be endianness , 0 for little , 1 for big ,
* - 1 ( or anything else ) for native
* @ return AV_CODEC_ID_PCM_ * or AV_CODEC_ID_NONE
*/
enum AVCodecID av_get_pcm_codec ( enum AVSampleFormat fmt , int be ) ;
/**
* Return codec bits per sample .
* Only return non - zero if the bits per sample is exactly correct , not an
* approximation .
*
* @ param [ in ] codec_id the codec
* @ return Number of bits per sample or zero if unknown for the given codec .
*/
int av_get_exact_bits_per_sample ( enum AVCodecID codec_id ) ;
/**
* Return audio frame duration .
*
* @ param avctx codec context
* @ param frame_bytes size of the frame , or 0 if unknown
* @ return frame duration , in samples , if known . 0 if not able to
* determine .
*/
int av_get_audio_frame_duration ( AVCodecContext * avctx , int frame_bytes ) ;
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 ) ;
void ( * close ) ( AVBitStreamFilterContext * bsfc ) ;
struct AVBitStreamFilter * next ;
} AVBitStreamFilter ;
/**
* Register a bitstream filter .
*
* The filter will be accessible to the application code through
* av_bitstream_filter_next ( ) or can be directly initialized with
* av_bitstream_filter_init ( ) .
*
* @ see avcodec_register_all ( )
*/
void av_register_bitstream_filter ( AVBitStreamFilter * bsf ) ;
/**
* Create and initialize a bitstream filter context given a bitstream
* filter name .
*
* The returned context must be freed with av_bitstream_filter_close ( ) .
*
* @ param name the name of the bitstream filter
* @ return a bitstream filter context if a matching filter was found
* and successfully initialized , NULL otherwise
*/
AVBitStreamFilterContext * av_bitstream_filter_init ( const char * name ) ;
/**
* Filter bitstream .
*
* This function filters the buffer buf with size buf_size , and places the
* filtered buffer in the buffer pointed to by poutbuf .
*
* The output buffer must be freed by the caller .
*
* @ param bsfc bitstream filter context created by av_bitstream_filter_init ( )
* @ param avctx AVCodecContext accessed by the filter , may be NULL .
* If specified , this must point to the encoder context of the
* output stream the packet is sent to .
* @ param args arguments which specify the filter configuration , may be NULL
* @ param poutbuf pointer which is updated to point to the filtered buffer
* @ param poutbuf_size pointer which is updated to the filtered buffer size in bytes
* @ param buf buffer containing the data to filter
* @ param buf_size size in bytes of buf
* @ param keyframe set to non - zero if the buffer to filter corresponds to a key - frame packet data
* @ return > = 0 in case of success , or a negative error code in case of failure
*
* If the return value is positive , an output buffer is allocated and
* is availble in * poutbuf , and is distinct from the input buffer .
*
* If the return value is 0 , the output output buffer is not allocated
* and the output buffer should be considered identical to the input
* buffer , or in case * poutbuf was set it points to the input buffer
* ( not necessarily to its starting address ) .
*/
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 ) ;
/**
* Release bitstream filter context .
*
* @ param bsf the bitstream filter context created with
* av_bitstream_filter_init ( ) , can be NULL
*/
void av_bitstream_filter_close ( AVBitStreamFilterContext * bsf ) ;
/**
* If f is NULL , return the first registered bitstream filter ,
* if f is non - NULL , return the next registered bitstream filter
* after f , or NULL if f is the last one .
*
* This function can be used to iterate over all registered bitstream
* filters .
*/
AVBitStreamFilter * av_bitstream_filter_next ( AVBitStreamFilter * f ) ;
/* memory */
/**
* Reallocate the given block if it is not large enough , otherwise do nothing .
*
* @ see av_realloc
*/
void * av_fast_realloc ( void * ptr , unsigned int * size , size_t min_size ) ;
/**
* Allocate a buffer , reusing the given one if large enough .
*
* Contrary to av_fast_realloc the current buffer contents might not be
* preserved and on error the old buffer is freed , thus no special
* handling to avoid memleaks is necessary .
*
* @ param ptr pointer to pointer to already allocated buffer , overwritten with pointer to new buffer
* @ param size size of the buffer * ptr points to
* @ param min_size minimum size of * ptr buffer after returning , * ptr will be NULL and
* * size 0 if an error occurred .
*/
void av_fast_malloc ( void * ptr , unsigned int * size , size_t min_size ) ;
/**
* Same behaviour av_fast_malloc but the buffer has additional
* FF_INPUT_BUFFER_PADDING_SIZE at the end which will will always be 0.
*
* In addition the whole buffer will initially and after resizes
* be 0 - initialized so that no uninitialized data will ever appear .
*/
void av_fast_padded_malloc ( void * ptr , unsigned int * size , size_t min_size ) ;
/**
* Same behaviour av_fast_padded_malloc except that buffer will always
* be 0 - initialized after call .
*/
void av_fast_padded_mallocz ( void * ptr , unsigned int * size , size_t min_size ) ;
/**
* Encode extradata length to a buffer . Used by xiph codecs .
*
* @ param s buffer to write to ; must be at least ( v / 255 + 1 ) bytes long
* @ param v size of extradata in bytes
* @ return number of bytes written to the buffer .
*/
unsigned int av_xiphlacing ( unsigned char * s , unsigned int v ) ;
# if FF_API_MISSING_SAMPLE
/**
* Log a generic warning message about a missing feature . This function is
* intended to be used internally by FFmpeg ( libavcodec , libavformat , etc . )
* only , and would normally not be used by applications .
* @ param [ in ] avc a pointer to an arbitrary struct of which the first field is
* a pointer to an AVClass struct
* @ param [ in ] feature string containing the name of the missing feature
* @ param [ in ] want_sample indicates if samples are wanted which exhibit this feature .
* If want_sample is non - zero , additional verbage will be added to the log
* message which tells the user how to report samples to the development
* mailing list .
* @ deprecated Use avpriv_report_missing_feature ( ) instead .
*/
attribute_deprecated
void av_log_missing_feature ( void * avc , const char * feature , int want_sample ) ;
/**
* Log a generic warning message asking for a sample . This function is
* intended to be used internally by FFmpeg ( libavcodec , libavformat , etc . )
* only , and would normally not be used by applications .
* @ param [ in ] avc a pointer to an arbitrary struct of which the first field is
* a pointer to an AVClass struct
* @ param [ in ] msg string containing an optional message , or NULL if no message
* @ deprecated Use avpriv_request_sample ( ) instead .
*/
attribute_deprecated
void av_log_ask_for_sample ( void * avc , const char * msg , . . . ) av_printf_format ( 2 , 3 ) ;
# endif /* FF_API_MISSING_SAMPLE */
/**
* Register the hardware accelerator hwaccel .
*/
void av_register_hwaccel ( AVHWAccel * hwaccel ) ;
/**
* If hwaccel is NULL , returns the first registered hardware accelerator ,
* if hwaccel is non - NULL , returns the next registered hardware accelerator
* after hwaccel , or NULL if hwaccel is the last one .
*/
AVHWAccel * av_hwaccel_next ( AVHWAccel * hwaccel ) ;
/**
* Lock operation used by lockmgr
*/
enum AVLockOp {
AV_LOCK_CREATE , ///< Create a mutex
AV_LOCK_OBTAIN , ///< Lock the mutex
AV_LOCK_RELEASE , ///< Unlock the mutex
AV_LOCK_DESTROY , ///< Free mutex resources
} ;
/**
* Register a user provided lock manager supporting the operations
* specified by AVLockOp . mutex points to a ( void * ) where the
* lockmgr should store / get a pointer to a user allocated mutex . It ' s
* NULL upon AV_LOCK_CREATE and ! = NULL for all other ops .
*
* @ param cb User defined callback . Note : FFmpeg may invoke calls to this
* callback during the call to av_lockmgr_register ( ) .
* Thus , the application must be prepared to handle that .
* If cb is set to NULL the lockmgr will be unregistered .
* Also note that during unregistration the previously registered
* lockmgr callback may also be invoked .
*/
int av_lockmgr_register ( int ( * cb ) ( void * * mutex , enum AVLockOp op ) ) ;
/**
* Get the type of the given codec .
*/
enum AVMediaType avcodec_get_type ( enum AVCodecID codec_id ) ;
/**
* Get the name of a codec .
* @ return a static string identifying the codec ; never NULL
*/
const char * avcodec_get_name ( enum AVCodecID id ) ;
/**
* @ return a positive value if s is open ( i . e . avcodec_open2 ( ) was called on it
* with no corresponding avcodec_close ( ) ) , 0 otherwise .
*/
int avcodec_is_open ( AVCodecContext * s ) ;
/**
* @ return a non - zero number if codec is an encoder , zero otherwise
*/
int av_codec_is_encoder ( const AVCodec * codec ) ;
/**
* @ return a non - zero number if codec is a decoder , zero otherwise
*/
int av_codec_is_decoder ( const AVCodec * codec ) ;
/**
* @ return descriptor for given codec ID or NULL if no descriptor exists .
*/
const AVCodecDescriptor * avcodec_descriptor_get ( enum AVCodecID id ) ;
/**
* Iterate over all codec descriptors known to libavcodec .
*
* @ param prev previous descriptor . NULL to get the first descriptor .
*
* @ return next descriptor or NULL after the last descriptor
*/
const AVCodecDescriptor * avcodec_descriptor_next ( const AVCodecDescriptor * prev ) ;
/**
* @ return codec descriptor with the given name or NULL if no such descriptor
* exists .
*/
const AVCodecDescriptor * avcodec_descriptor_get_by_name ( const char * name ) ;
/**
* @ }
*/
# endif /* AVCODEC_AVCODEC_H */
