From 6e17ab3c2b7a9f62f0712b2a61c5de1fe45c1a5d Mon Sep 17 00:00:00 2001 From: Diego Waxemberg Date: Sat, 7 Dec 2013 20:02:01 -0500 Subject: [PATCH] dat video and audio works --- limelight-pc/jni/nv_avc_dec/.DS_Store | Bin 0 -> 6148 bytes limelight-pc/jni/nv_avc_dec/inc/.DS_Store | Bin 0 -> 6148 bytes .../jni/nv_avc_dec/inc/libavcodec/.DS_Store | Bin 0 -> 6148 bytes .../jni/nv_avc_dec/inc/libavcodec/avcodec.h | 5017 +++++++++++++++++ .../jni/nv_avc_dec/inc/libavcodec/avfft.h | 116 + .../jni/nv_avc_dec/inc/libavcodec/dxva2.h | 95 + .../nv_avc_dec/inc/libavcodec/old_codec_ids.h | 399 ++ .../jni/nv_avc_dec/inc/libavcodec/vaapi.h | 173 + .../jni/nv_avc_dec/inc/libavcodec/vda.h | 162 + .../jni/nv_avc_dec/inc/libavcodec/vdpau.h | 215 + .../jni/nv_avc_dec/inc/libavcodec/version.h | 142 + .../jni/nv_avc_dec/inc/libavcodec/xvmc.h | 174 + .../nv_avc_dec/inc/libavfilter/asrc_abuffer.h | 91 + .../jni/nv_avc_dec/inc/libavfilter/avcodec.h | 110 + .../jni/nv_avc_dec/inc/libavfilter/avfilter.h | 1523 +++++ .../inc/libavfilter/avfiltergraph.h | 28 + .../nv_avc_dec/inc/libavfilter/buffersink.h | 186 + .../nv_avc_dec/inc/libavfilter/buffersrc.h | 148 + .../jni/nv_avc_dec/inc/libavfilter/version.h | 92 + .../jni/nv_avc_dec/inc/libavformat/avformat.h | 2243 ++++++++ .../jni/nv_avc_dec/inc/libavformat/avio.h | 481 ++ .../jni/nv_avc_dec/inc/libavformat/version.h | 79 + .../jni/nv_avc_dec/inc/libavutil/adler32.h | 55 + .../jni/nv_avc_dec/inc/libavutil/aes.h | 65 + .../jni/nv_avc_dec/inc/libavutil/attributes.h | 160 + .../jni/nv_avc_dec/inc/libavutil/audio_fifo.h | 149 + .../nv_avc_dec/inc/libavutil/audioconvert.h | 6 + .../jni/nv_avc_dec/inc/libavutil/avassert.h | 66 + .../jni/nv_avc_dec/inc/libavutil/avconfig.h | 8 + .../jni/nv_avc_dec/inc/libavutil/avstring.h | 302 + .../jni/nv_avc_dec/inc/libavutil/avutil.h | 327 ++ .../jni/nv_avc_dec/inc/libavutil/base64.h | 67 + .../jni/nv_avc_dec/inc/libavutil/blowfish.h | 77 + .../jni/nv_avc_dec/inc/libavutil/bprint.h | 216 + .../jni/nv_avc_dec/inc/libavutil/bswap.h | 109 + .../jni/nv_avc_dec/inc/libavutil/buffer.h | 274 + .../nv_avc_dec/inc/libavutil/channel_layout.h | 221 + .../jni/nv_avc_dec/inc/libavutil/common.h | 468 ++ .../jni/nv_avc_dec/inc/libavutil/cpu.h | 111 + .../jni/nv_avc_dec/inc/libavutil/crc.h | 85 + .../jni/nv_avc_dec/inc/libavutil/dict.h | 152 + .../jni/nv_avc_dec/inc/libavutil/error.h | 117 + .../jni/nv_avc_dec/inc/libavutil/eval.h | 113 + .../jni/nv_avc_dec/inc/libavutil/fifo.h | 144 + .../jni/nv_avc_dec/inc/libavutil/file.h | 66 + .../jni/nv_avc_dec/inc/libavutil/frame.h | 672 +++ .../jni/nv_avc_dec/inc/libavutil/hmac.h | 99 + .../jni/nv_avc_dec/inc/libavutil/imgutils.h | 200 + .../jni/nv_avc_dec/inc/libavutil/intfloat.h | 77 + .../inc/libavutil/intfloat_readwrite.h | 40 + .../nv_avc_dec/inc/libavutil/intreadwrite.h | 621 ++ .../jni/nv_avc_dec/inc/libavutil/lfg.h | 62 + .../jni/nv_avc_dec/inc/libavutil/log.h | 313 + .../jni/nv_avc_dec/inc/libavutil/lzo.h | 66 + .../nv_avc_dec/inc/libavutil/mathematics.h | 147 + .../jni/nv_avc_dec/inc/libavutil/md5.h | 81 + .../jni/nv_avc_dec/inc/libavutil/mem.h | 363 ++ .../jni/nv_avc_dec/inc/libavutil/murmur3.h | 32 + .../nv_avc_dec/inc/libavutil/old_pix_fmts.h | 177 + .../jni/nv_avc_dec/inc/libavutil/opt.h | 757 +++ .../jni/nv_avc_dec/inc/libavutil/parseutils.h | 187 + .../jni/nv_avc_dec/inc/libavutil/pixdesc.h | 291 + .../jni/nv_avc_dec/inc/libavutil/pixfmt.h | 399 ++ .../nv_avc_dec/inc/libavutil/random_seed.h | 43 + .../jni/nv_avc_dec/inc/libavutil/rational.h | 155 + .../jni/nv_avc_dec/inc/libavutil/ripemd.h | 75 + .../jni/nv_avc_dec/inc/libavutil/samplefmt.h | 256 + .../jni/nv_avc_dec/inc/libavutil/sha.h | 74 + .../jni/nv_avc_dec/inc/libavutil/sha512.h | 75 + .../jni/nv_avc_dec/inc/libavutil/time.h | 41 + .../jni/nv_avc_dec/inc/libavutil/timecode.h | 140 + .../jni/nv_avc_dec/inc/libavutil/timestamp.h | 74 + .../jni/nv_avc_dec/inc/libavutil/version.h | 159 + .../jni/nv_avc_dec/inc/libavutil/xtea.h | 64 + .../nv_avc_dec/inc/libswresample/swresample.h | 311 + .../nv_avc_dec/inc/libswresample/version.h | 45 + .../jni/nv_avc_dec/inc/libswscale/swscale.h | 362 ++ .../jni/nv_avc_dec/inc/libswscale/version.h | 59 + limelight-pc/jni/nv_avc_dec/nv_avc_dec.c | 400 ++ limelight-pc/jni/nv_avc_dec/nv_avc_dec.h | 14 + limelight-pc/jni/nv_avc_dec/nv_avc_dec_jni.c | 115 + limelight-pc/jni/nv_opus_dec/.DS_Store | Bin 0 -> 6148 bytes .../jni/nv_opus_dec/{libopus => }/inc/opus.h | 0 .../{libopus => }/inc/opus_custom.h | 0 .../{libopus => }/inc/opus_defines.h | 0 .../{libopus => }/inc/opus_multistream.h | 0 .../{libopus => }/inc/opus_types.h | 0 .../jni/nv_opus_dec/libopus/libopus-0.dll | Bin 282624 -> 0 bytes .../nv_opus_dec/{libopus => }/nv_opus_dec.c | 0 .../nv_opus_dec/{libopus => }/nv_opus_dec.h | 0 .../{libopus => }/nv_opus_dec_jni.c | 0 limelight-pc/libs/limelight-common.jar | Bin 54875 -> 166896 bytes limelight-pc/src/com/limelight/Limelight.java | 2 +- .../binding/audio/JavaxAudioRenderer.java | 3 +- .../video/SwingCpuDecoderRenderer.java | 17 +- 95 files changed, 21887 insertions(+), 13 deletions(-) create mode 100644 limelight-pc/jni/nv_avc_dec/.DS_Store create mode 100644 limelight-pc/jni/nv_avc_dec/inc/.DS_Store create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavcodec/.DS_Store create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavcodec/avcodec.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavcodec/avfft.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavcodec/dxva2.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavcodec/old_codec_ids.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavcodec/vaapi.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavcodec/vda.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavcodec/vdpau.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavcodec/version.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavcodec/xvmc.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavfilter/asrc_abuffer.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavfilter/avcodec.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavfilter/avfilter.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavfilter/avfiltergraph.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavfilter/buffersink.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavfilter/buffersrc.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavfilter/version.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavformat/avformat.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavformat/avio.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavformat/version.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/adler32.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/aes.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/attributes.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/audio_fifo.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/audioconvert.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/avassert.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/avconfig.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/avstring.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/avutil.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/base64.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/blowfish.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/bprint.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/bswap.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/buffer.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/channel_layout.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/common.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/cpu.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/crc.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/dict.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/error.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/eval.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/fifo.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/file.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/frame.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/hmac.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/imgutils.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/intfloat.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/intfloat_readwrite.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/intreadwrite.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/lfg.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/log.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/lzo.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/mathematics.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/md5.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/mem.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/murmur3.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/old_pix_fmts.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/opt.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/parseutils.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/pixdesc.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/pixfmt.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/random_seed.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/rational.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/ripemd.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/samplefmt.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/sha.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/sha512.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/time.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/timecode.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/timestamp.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/version.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libavutil/xtea.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libswresample/swresample.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libswresample/version.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libswscale/swscale.h create mode 100644 limelight-pc/jni/nv_avc_dec/inc/libswscale/version.h create mode 100755 limelight-pc/jni/nv_avc_dec/nv_avc_dec.c create mode 100755 limelight-pc/jni/nv_avc_dec/nv_avc_dec.h create mode 100755 limelight-pc/jni/nv_avc_dec/nv_avc_dec_jni.c create mode 100644 limelight-pc/jni/nv_opus_dec/.DS_Store rename limelight-pc/jni/nv_opus_dec/{libopus => }/inc/opus.h (100%) rename limelight-pc/jni/nv_opus_dec/{libopus => }/inc/opus_custom.h (100%) rename limelight-pc/jni/nv_opus_dec/{libopus => }/inc/opus_defines.h (100%) rename limelight-pc/jni/nv_opus_dec/{libopus => }/inc/opus_multistream.h (100%) rename limelight-pc/jni/nv_opus_dec/{libopus => }/inc/opus_types.h (100%) delete mode 100755 limelight-pc/jni/nv_opus_dec/libopus/libopus-0.dll rename limelight-pc/jni/nv_opus_dec/{libopus => }/nv_opus_dec.c (100%) rename limelight-pc/jni/nv_opus_dec/{libopus => }/nv_opus_dec.h (100%) rename limelight-pc/jni/nv_opus_dec/{libopus => }/nv_opus_dec_jni.c (100%) diff --git a/limelight-pc/jni/nv_avc_dec/.DS_Store b/limelight-pc/jni/nv_avc_dec/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..3782e9d489f8bcaaf07a4e547d8024100597d98f GIT binary patch literal 6148 zcmeHKJ5Iwu5S<|@A|aualzRkn03<6iC&&emYzdGsPC_oJdp@ z zL7t>}yc_dh-+p$wzOLKdb0hNce*NhOC8z7#BRkvs(P_;?()@uv=7XEFh^>PGn#XxVxSXe8*9Mu(j#(tGJ1Uemgrvv#TV7kz# Iz+Wiv1-_LfSpWb4 literal 0 HcmV?d00001 diff --git a/limelight-pc/jni/nv_avc_dec/inc/.DS_Store b/limelight-pc/jni/nv_avc_dec/inc/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..44536688e0f100634603696d3366365e6beda2b9 GIT binary patch literal 6148 zcmeHLOHRWu5FOJ9N-L!9pu1e55)y2XqAHxA7iek9M>M4B2evr{YmUH{1zQjs&cHp` z@WwV#tT-(zgwTv+zr=YSzdR+GxHVEv^akTBo#`8BjBe_9X%@%HYKiy#{q5vcv%UG! zEcp>{c3EEcffKe%`p%(rN=tlU=8i&j^i}}#C6ybPj!reK=FDhLDLh@e zI`6M5s~60TI!nyLO~1~9>FRuBox3GJSMU;!IvRt|8kR?&Czr=V56jWD{lP2lSzQad zgLe~Jz`c}a7@au!=x}E}+oN+$ZjatIY)3amto!?UXWa`_zEM^2@qQi8qt%%|VEdVgUunrvaUV`U@79)$fL0my7 zGZkp2D!au{W;(`0%Zn`L2F-L*dS&FXD=WK0QF?WZhnh|*GAO+`AP%?=G|Xv->;Gx} z{@XX1c3@UI+DK|F~2xFuU#D>uirHbfhuaWF48sHdQ_H1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3 zem<@ulZcFPQ@L2!n>{z**++&mCkOWA81W14cNZlEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ zLs35+`xjp>T0 +#include "libavutil/samplefmt.h" +#include "libavutil/attributes.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" +#if FF_API_FAST_MALLOC +// to provide fast_*alloc +#include "libavutil/mem.h" +#endif +#include "libavutil/pixfmt.h" +#include "libavutil/rational.h" + +#include "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 +#if FF_API_XVMC + AV_CODEC_ID_MPEG2VIDEO_XVMC, +#endif /* FF_API_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_WEBP_DEPRECATED, + AV_CODEC_ID_HNM4_VIDEO, + AV_CODEC_ID_HEVC_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'), + AV_CODEC_ID_HEVC = MKBETAG('H','2','6','5'), +#define AV_CODEC_ID_H265 AV_CODEC_ID_HEVC + + /* 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_DEPRECATED, + AV_CODEC_ID_PCM_S32LE_PLANAR_DEPRECATED, + 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',' '), + AV_CODEC_ID_ADPCM_G726LE = MKBETAG('6','2','7','G'), + + /* 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, +#if FF_API_VOXWARE + AV_CODEC_ID_VOXWARE, +#endif + 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_METASOUND, + 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.
+ * 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_BT2020 = 9, ///< ITU-R BT2020 + 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_SMPTE170M = 6, ///< also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC + AVCOL_TRC_SMPTE240M = 7, + AVCOL_TRC_LINEAR = 8, ///< "Linear transfer characteristics" + AVCOL_TRC_LOG = 9, ///< "Logarithmic transfer characteristic (100:1 range)" + AVCOL_TRC_LOG_SQRT = 10, ///< "Logarithmic transfer characteristic (100 * Sqrt( 10 ) : 1 range)" + AVCOL_TRC_IEC61966_2_4 = 11, ///< IEC 61966-2-4 + AVCOL_TRC_BT1361_ECG = 12, ///< ITU-R BT1361 Extended Colour Gamut + AVCOL_TRC_IEC61966_2_1 = 13, ///< IEC 61966-2-1 (sRGB or sYCC) + AVCOL_TRC_BT2020_10 = 14, ///< ITU-R BT2020 for 10 bit system + AVCOL_TRC_BT2020_12 = 15, ///< ITU-R BT2020 for 12 bit system + AVCOL_TRC_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; + +#if FF_API_MAX_BFRAMES +/** + * @deprecated there is no libavcodec-wide limit on the number of B-frames + */ +#define FF_MAX_B_FRAMES 16 +#endif + +/* 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_OUTPUT_CORRUPT 0x0008 ///< Output even those frames that might be corrupted +#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 +#if FF_API_XVMC +/* Codec can export data for HW decoding (XvMC). */ +#define CODEC_CAP_HWACCEL 0x0010 +#endif /* FF_API_XVMC */ +/** + * 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 +#if FF_API_CAP_VDPAU +/** + * Codec can export data for HW decoding (VDPAU). + */ +#define CODEC_CAP_HWACCEL_VDPAU 0x0080 +#endif +/** + * 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 +#if FF_API_NEG_LINESIZES +/** + * @deprecated no codecs use this capability + */ +#define CODEC_CAP_NEG_LINESIZES 0x0800 +#endif +/** + * 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 + +#if FF_API_MB_TYPE +//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, ...) +#endif + +/** + * 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; + +#if FF_API_QSCALE_TYPE +#define FF_QSCALE_TYPE_MPEG1 0 +#define FF_QSCALE_TYPE_MPEG2 1 +#define FF_QSCALE_TYPE_H264 2 +#define FF_QSCALE_TYPE_VP56 3 +#endif + +#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; + +#if FF_API_ASPECT_EXTENDED +#define FF_ASPECT_EXTENDED 15 +#endif + + /** + * 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 (2a+1 x 2a+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) + +#if FF_API_XVMC + /** + * XVideo Motion Acceleration + * - encoding: forbidden + * - decoding: set by decoder + * @deprecated XvMC support is slated for removal. + */ + attribute_deprecated int xvmc_acceleration; +#endif /* FF_API_XVMC */ + + /** + * 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. + */ + attribute_deprecated 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, 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, 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 +#if FF_API_OLD_MSMPEG4 +#define FF_BUG_OLD_MSMPEG4 2 +#endif +#define FF_BUG_XVID_ILACE 4 +#define FF_BUG_UMP4 8 +#define FF_BUG_NO_PADDING 16 +#define FF_BUG_AMV 32 +#if FF_API_AC_VLC +#define FF_BUG_AC_VLC 0 ///< Will be removed, libavcodec can now handle these non-compliant files by default. +#endif +#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 +#if FF_API_DEBUG_MV +/** + * @deprecated this option does nothing + */ +#define FF_DEBUG_MV 32 +#endif +#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 +#if FF_API_DEBUG_MV +#define FF_DEBUG_VIS_QP 0x00002000 ///< only access through AVOptions from outside libavcodec +#define FF_DEBUG_VIS_MB_TYPE 0x00004000 ///< only access through AVOptions from outside libavcodec +#endif +#define FF_DEBUG_BUFFERS 0x00008000 +#define FF_DEBUG_THREADS 0x00010000 + +#if FF_API_DEBUG_MV + /** + * debug + * Code outside libavcodec should access this field using AVOptions + * - 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 +#endif + + /** + * Error recognition; may misdetect some more or less valid parts as errors. + * - encoding: unused + * - decoding: Set by user. + */ + int err_recognition; + +/** + * Verify checksums embedded in the bitstream (could be of either encoded or + * decoded data, depending on the codec) and print an error message on mismatch. + * If AV_EF_EXPLODE is also set, a mismatching checksum will result in the + * decoder returning an error. + */ +#define AV_EF_CRCCHECK (1<<0) +#define AV_EF_BITSTREAM (1<<1) ///< detect bitstream specification deviations +#define AV_EF_BUFFER (1<<2) ///< detect improper bitstream length +#define AV_EF_EXPLODE (1<<3) ///< abort decoding on minor error detection + +#define AV_EF_CAREFUL (1<<16) ///< consider things that violate the spec, are fast to calculate and have not been seen in the wild as errors +#define AV_EF_COMPLIANT (1<<17) ///< consider all spec non compliancies as errors +#define AV_EF_AGGRESSIVE (1<<18) ///< consider things that a sane encoder should not do as an error + + + /** + * opaque 64bit 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 +#if FF_API_ARCH_ALPHA +#define FF_IDCT_SIMPLEALPHA 23 +#endif + + /** + * 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: unused + */ + 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); + +#if FF_API_THREAD_OPAQUE + /** + * @deprecated this field should not be used from outside of lavc + */ + attribute_deprecated + void *thread_opaque; +#endif + + /** + * 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; + +#if FF_API_ERROR_RATE + /** + * @deprecated use the 'error_rate' private AVOption of the mpegvideo + * encoders + */ + attribute_deprecated + int error_rate; +#endif + +#if FF_API_CODEC_PKT + /** + * @deprecated this field is not supposed to be accessed from outside lavc + */ + attribute_deprecated + AVPacket *pkt; +#endif + + /** + * 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 + + /** + * Skip processing alpha if supported by codec. + * Note that if the format uses pre-multiplied alpha (common with VP6, + * and recommended due to better video quality/compression) + * the image will look as if alpha-blended onto a black background. + * However for formats that do not use pre-multiplied alpha + * there might be serious artefacts (though e.g. libswscale currently + * assumes pre-multiplied alpha anyway). + * Code outside libavcodec should access this field using AVOptions + * + * - decoding: set by user + * - encoding: unused + */ + int skip_alpha; + + /** + * Number of samples to skip after a discontinuity + * - decoding: unused + * - encoding: set by libavcodec + */ + int seek_preroll; + +#if !FF_API_DEBUG_MV + /** + * debug motion vectors + * Code outside libavcodec should access this field using AVOptions + * - 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 +#endif +} 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); + +int av_codec_get_seek_preroll(const AVCodecContext *avctx); +void av_codec_set_seek_preroll(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 +#if FF_API_LOWRES + uint8_t max_lowres; ///< maximum value for lowres supported by the decoder, no direct access, use av_codec_get_max_lowres() +#endif + 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; + +int av_codec_get_max_lowres(const AVCodec *codec); + +/** + * 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 + * @{ + */ + +/** + * Picture data structure. + * + * Up to four components can be stored into it, the last component is + * alpha. + */ +typedef struct AVPicture { + uint8_t *data[AV_NUM_DATA_POINTERS]; ///< pointers to the image data planes + 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); + +/** + * 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(NULL), 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); + +#if FF_API_AVFRAME_LAVC +/** + * @deprecated use av_frame_alloc() + */ +attribute_deprecated +AVFrame *avcodec_alloc_frame(void); +#endif + +/** + * 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); + +/** + * 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); + + +/** + * Convenience function to free all the side data stored. + * All the other fields stay untouched. + * + * @param pkt packet + */ +void av_packet_free_side_data(AVPacket *pkt); + +/** + * Setup a new reference to the data described by a given packet + * + * If src is reference-counted, setup dst as a new reference to the + * buffer in src. Otherwise allocate a new buffer in dst and copy the + * data from src into it. + * + * All the other fields are copied from src. + * + * @see av_packet_unref + * + * @param dst Destination packet + * @param src Source packet + * + * @return 0 on success, a negative AVERROR on error. + */ +int av_packet_ref(AVPacket *dst, AVPacket *src); + +/** + * Wipe the packet. + * + * Unreference the buffer referenced by the packet and reset the + * remaining packet fields to their default values. + * + * @param pkt The packet to be unreferenced. + */ +void av_packet_unref(AVPacket *pkt); + +/** + * Move every field in src to dst and reset src. + * + * @see av_packet_unref + * + * @param src Source packet, will be reset + * @param dst Destination packet + */ +void av_packet_move_ref(AVPacket *dst, AVPacket *src); + +/** + * Copy only "properties" fields from src to dst. + * + * Properties for the purpose of this function are all the fields + * beside those related to the packet data (buf, data, size) + * + * @param dst Destination packet + * @param src Source packet + * + * @return 0 on success AVERROR on failure. + * + */ +int av_packet_copy_props(AVPacket *dst, const AVPacket *src); + +/** + * @} + */ + +/** + * @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]); + +/** + * Converts AVChromaLocation to swscale x/y chroma position. + * + * The positions represent the chroma (0,0) position in a coordinates system + * with luma (0,0) representing the origin and luma(1,1) representing 256,256 + * + * @param xpos horizontal chroma sample position + * @param ypos vertical chroma sample position + */ +int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos); + +/** + * Converts swscale x/y chroma position to AVChromaLocation. + * + * The positions represent the chroma (0,0) position in a coordinates system + * with luma (0,0) representing the origin and luma(1,1) representing 256,256 + * + * @param xpos horizontal chroma sample position + * @param ypos vertical chroma sample position + */ +enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos); + +#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 and the return value would be + * less than the packet size. 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. + * + * Some decoders (those marked with CODEC_CAP_DELAY) have a delay between input + * and output. This means that for some packets they will not immediately + * produce decoded output and need to be flushed at the end of decoding to get + * all the decoded data. Flushing is done by calling this function with packets + * with avpkt->data set to NULL and avpkt->size set to 0 until it stops + * returning samples. It is safe to flush even those decoders that are not + * marked with CODEC_CAP_DELAY, then no samples will be returned. + * + * @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. + * + * @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 or flushing 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. Note that this field being set to zero + * does not mean that an error has occurred. For + * decoders with CODEC_CAP_DELAY set, no given decode + * call is guaranteed to produce a frame. + * @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 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 or flushing 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. + * + * Some decoders (those marked with CODEC_CAP_DELAY) have a delay between input + * and output. This means that for some packets they will not immediately + * produce decoded output and need to be flushed at the end of decoding to get + * all the decoded data. Flushing is done by calling this function with packets + * with avpkt->data set to NULL and avpkt->size set to 0 until it stops + * returning subtitles. It is safe to flush even those decoders that are not + * marked with CODEC_CAP_DELAY, then no subtitles will be returned. + * + * @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; + + /** + * Picture number incremented in presentation or output order. + * This field may be reinitialized at the first picture of a new sequence. + * + * For example, this corresponds to H.264 PicOrderCnt. + */ + int output_picture_number; +} 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 the pixels of a picture and setup the AVPicture + * fields for it. + * + * Call avpicture_free() to free it. + * + * @param picture the picture structure to be filled in + * @param pix_fmt the pixel format of the picture + * @param width the width of the picture + * @param height the height of the picture + * @return zero if successful, a negative error code otherwise + * + * @see av_image_alloc(), avpicture_fill() + */ +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); + +/** + * Setup the picture fields based on the specified image parameters + * and the provided image data buffer. + * + * The picture fields are filled in by using the image data buffer + * pointed to by ptr. + * + * If ptr is NULL, the function will fill only the picture linesize + * array and return the required size for the image buffer. + * + * To allocate an image buffer and fill the picture data in one call, + * use avpicture_alloc(). + * + * @param picture the picture to be filled in + * @param ptr buffer where the image data is stored, or NULL + * @param pix_fmt the pixel format of the image + * @param width the width of the image in pixels + * @param height the height of the image in pixels + * @return the size in bytes required for src, a negative error code + * in case of failure + * + * @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. + * + * avpicture_get_size() can be used to compute the required size for + * the buffer to fill. + * + * @param src source picture with filled data + * @param pix_fmt picture pixel format + * @param width picture width + * @param height picture height + * @param dest destination buffer + * @param dest_size destination buffer size in bytes + * @return the number of bytes written to dest, or a negative value + * (error code) on error, for example if the destination buffer is not + * big enough + * + * @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. + * + * @param pix_fmt picture pixel format + * @param width picture width + * @param height picture height + * @return the computed picture buffer size or a negative error code + * in case of error + * + * @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(const 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(const 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); + +/** + * @} + */ + +#if FF_API_SET_DIMENSIONS +/** + * @deprecated this function is not supposed to be used from outside of lavc + */ +attribute_deprecated +void avcodec_set_dimensions(AVCodecContext *s, int width, int height); +#endif + +/** + * 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); + +/** + * Reset the internal decoder state / flush internal buffers. Should be called + * e.g. when seeking or when switching to a different stream. + * + * @note when refcounted frames are not used (i.e. avctx->refcounted_frames is 0), + * this invalidates the frames previously returned from the decoder. When + * refcounted frames are used, the decoder just releases any references it might + * keep internally, but the caller's reference remains valid. + */ +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 buffer is not allocated and + * 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 */ + +/** + * Same behaviour av_fast_malloc but the buffer has additional + * FF_INPUT_BUFFER_PADDING_SIZE at the end which 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 */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavcodec/avfft.h b/limelight-pc/jni/nv_avc_dec/inc/libavcodec/avfft.h new file mode 100644 index 0000000..2d20a45 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavcodec/avfft.h @@ -0,0 +1,116 @@ +/* + * 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_AVFFT_H +#define AVCODEC_AVFFT_H + +/** + * @file + * @ingroup lavc_fft + * FFT functions + */ + +/** + * @defgroup lavc_fft FFT functions + * @ingroup lavc_misc + * + * @{ + */ + +typedef float FFTSample; + +typedef struct FFTComplex { + FFTSample re, im; +} FFTComplex; + +typedef struct FFTContext FFTContext; + +/** + * Set up a complex FFT. + * @param nbits log2 of the length of the input array + * @param inverse if 0 perform the forward transform, if 1 perform the inverse + */ +FFTContext *av_fft_init(int nbits, int inverse); + +/** + * Do the permutation needed BEFORE calling ff_fft_calc(). + */ +void av_fft_permute(FFTContext *s, FFTComplex *z); + +/** + * Do a complex FFT with the parameters defined in av_fft_init(). The + * input data must be permuted before. No 1.0/sqrt(n) normalization is done. + */ +void av_fft_calc(FFTContext *s, FFTComplex *z); + +void av_fft_end(FFTContext *s); + +FFTContext *av_mdct_init(int nbits, int inverse, double scale); +void av_imdct_calc(FFTContext *s, FFTSample *output, const FFTSample *input); +void av_imdct_half(FFTContext *s, FFTSample *output, const FFTSample *input); +void av_mdct_calc(FFTContext *s, FFTSample *output, const FFTSample *input); +void av_mdct_end(FFTContext *s); + +/* Real Discrete Fourier Transform */ + +enum RDFTransformType { + DFT_R2C, + IDFT_C2R, + IDFT_R2C, + DFT_C2R, +}; + +typedef struct RDFTContext RDFTContext; + +/** + * Set up a real FFT. + * @param nbits log2 of the length of the input array + * @param trans the type of transform + */ +RDFTContext *av_rdft_init(int nbits, enum RDFTransformType trans); +void av_rdft_calc(RDFTContext *s, FFTSample *data); +void av_rdft_end(RDFTContext *s); + +/* Discrete Cosine Transform */ + +typedef struct DCTContext DCTContext; + +enum DCTTransformType { + DCT_II = 0, + DCT_III, + DCT_I, + DST_I, +}; + +/** + * Set up DCT. + * @param nbits size of the input array: + * (1 << nbits) for DCT-II, DCT-III and DST-I + * (1 << nbits) + 1 for DCT-I + * + * @note the first element of the input of DST-I is ignored + */ +DCTContext *av_dct_init(int nbits, enum DCTTransformType type); +void av_dct_calc(DCTContext *s, FFTSample *data); +void av_dct_end (DCTContext *s); + +/** + * @} + */ + +#endif /* AVCODEC_AVFFT_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavcodec/dxva2.h b/limelight-pc/jni/nv_avc_dec/inc/libavcodec/dxva2.h new file mode 100644 index 0000000..ac39e06 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavcodec/dxva2.h @@ -0,0 +1,95 @@ +/* + * DXVA2 HW acceleration + * + * copyright (c) 2009 Laurent Aimar + * + * 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_DXVA_H +#define AVCODEC_DXVA_H + +/** + * @file + * @ingroup lavc_codec_hwaccel_dxva2 + * Public libavcodec DXVA2 header. + */ + +#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0600 +#undef _WIN32_WINNT +#endif + +#if !defined(_WIN32_WINNT) +#define _WIN32_WINNT 0x0600 +#endif + +#include +#include +#include + +/** + * @defgroup lavc_codec_hwaccel_dxva2 DXVA2 + * @ingroup lavc_codec_hwaccel + * + * @{ + */ + +#define FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG 1 ///< Work around for DXVA2 and old UVD/UVD+ ATI video cards + +/** + * This structure is used to provides the necessary configurations and data + * to the DXVA2 FFmpeg HWAccel implementation. + * + * The application must make it available as AVCodecContext.hwaccel_context. + */ +struct dxva_context { + /** + * DXVA2 decoder object + */ + IDirectXVideoDecoder *decoder; + + /** + * DXVA2 configuration used to create the decoder + */ + const DXVA2_ConfigPictureDecode *cfg; + + /** + * The number of surface in the surface array + */ + unsigned surface_count; + + /** + * The array of Direct3D surfaces used to create the decoder + */ + LPDIRECT3DSURFACE9 *surface; + + /** + * A bit field configuring the workarounds needed for using the decoder + */ + uint64_t workaround; + + /** + * Private to the FFmpeg AVHWAccel implementation + */ + unsigned report_id; +}; + +/** + * @} + */ + +#endif /* AVCODEC_DXVA_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavcodec/old_codec_ids.h b/limelight-pc/jni/nv_avc_dec/inc/libavcodec/old_codec_ids.h new file mode 100644 index 0000000..b956264 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavcodec/old_codec_ids.h @@ -0,0 +1,399 @@ +/* + * 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_OLD_CODEC_IDS_H +#define AVCODEC_OLD_CODEC_IDS_H + +#include "libavutil/common.h" + +/* + * This header exists to prevent new codec IDs from being accidentally added to + * the deprecated list. + * Do not include it directly. It will be removed on next major bump + * + * Do not add new items to this list. Use the AVCodecID enum instead. + */ + + CODEC_ID_NONE = AV_CODEC_ID_NONE, + + /* video codecs */ + CODEC_ID_MPEG1VIDEO, + CODEC_ID_MPEG2VIDEO, ///< preferred ID for MPEG-1/2 video decoding +#if FF_API_XVMC + CODEC_ID_MPEG2VIDEO_XVMC, +#endif + CODEC_ID_H261, + CODEC_ID_H263, + CODEC_ID_RV10, + CODEC_ID_RV20, + CODEC_ID_MJPEG, + CODEC_ID_MJPEGB, + CODEC_ID_LJPEG, + CODEC_ID_SP5X, + CODEC_ID_JPEGLS, + CODEC_ID_MPEG4, + CODEC_ID_RAWVIDEO, + CODEC_ID_MSMPEG4V1, + CODEC_ID_MSMPEG4V2, + CODEC_ID_MSMPEG4V3, + CODEC_ID_WMV1, + CODEC_ID_WMV2, + CODEC_ID_H263P, + CODEC_ID_H263I, + CODEC_ID_FLV1, + CODEC_ID_SVQ1, + CODEC_ID_SVQ3, + CODEC_ID_DVVIDEO, + CODEC_ID_HUFFYUV, + CODEC_ID_CYUV, + CODEC_ID_H264, + CODEC_ID_INDEO3, + CODEC_ID_VP3, + CODEC_ID_THEORA, + CODEC_ID_ASV1, + CODEC_ID_ASV2, + CODEC_ID_FFV1, + CODEC_ID_4XM, + CODEC_ID_VCR1, + CODEC_ID_CLJR, + CODEC_ID_MDEC, + CODEC_ID_ROQ, + CODEC_ID_INTERPLAY_VIDEO, + CODEC_ID_XAN_WC3, + CODEC_ID_XAN_WC4, + CODEC_ID_RPZA, + CODEC_ID_CINEPAK, + CODEC_ID_WS_VQA, + CODEC_ID_MSRLE, + CODEC_ID_MSVIDEO1, + CODEC_ID_IDCIN, + CODEC_ID_8BPS, + CODEC_ID_SMC, + CODEC_ID_FLIC, + CODEC_ID_TRUEMOTION1, + CODEC_ID_VMDVIDEO, + CODEC_ID_MSZH, + CODEC_ID_ZLIB, + CODEC_ID_QTRLE, + CODEC_ID_TSCC, + CODEC_ID_ULTI, + CODEC_ID_QDRAW, + CODEC_ID_VIXL, + CODEC_ID_QPEG, + CODEC_ID_PNG, + CODEC_ID_PPM, + CODEC_ID_PBM, + CODEC_ID_PGM, + CODEC_ID_PGMYUV, + CODEC_ID_PAM, + CODEC_ID_FFVHUFF, + CODEC_ID_RV30, + CODEC_ID_RV40, + CODEC_ID_VC1, + CODEC_ID_WMV3, + CODEC_ID_LOCO, + CODEC_ID_WNV1, + CODEC_ID_AASC, + CODEC_ID_INDEO2, + CODEC_ID_FRAPS, + CODEC_ID_TRUEMOTION2, + CODEC_ID_BMP, + CODEC_ID_CSCD, + CODEC_ID_MMVIDEO, + CODEC_ID_ZMBV, + CODEC_ID_AVS, + CODEC_ID_SMACKVIDEO, + CODEC_ID_NUV, + CODEC_ID_KMVC, + CODEC_ID_FLASHSV, + CODEC_ID_CAVS, + CODEC_ID_JPEG2000, + CODEC_ID_VMNC, + CODEC_ID_VP5, + CODEC_ID_VP6, + CODEC_ID_VP6F, + CODEC_ID_TARGA, + CODEC_ID_DSICINVIDEO, + CODEC_ID_TIERTEXSEQVIDEO, + CODEC_ID_TIFF, + CODEC_ID_GIF, + CODEC_ID_DXA, + CODEC_ID_DNXHD, + CODEC_ID_THP, + CODEC_ID_SGI, + CODEC_ID_C93, + CODEC_ID_BETHSOFTVID, + CODEC_ID_PTX, + CODEC_ID_TXD, + CODEC_ID_VP6A, + CODEC_ID_AMV, + CODEC_ID_VB, + CODEC_ID_PCX, + CODEC_ID_SUNRAST, + CODEC_ID_INDEO4, + CODEC_ID_INDEO5, + CODEC_ID_MIMIC, + CODEC_ID_RL2, + CODEC_ID_ESCAPE124, + CODEC_ID_DIRAC, + CODEC_ID_BFI, + CODEC_ID_CMV, + CODEC_ID_MOTIONPIXELS, + CODEC_ID_TGV, + CODEC_ID_TGQ, + CODEC_ID_TQI, + CODEC_ID_AURA, + CODEC_ID_AURA2, + CODEC_ID_V210X, + CODEC_ID_TMV, + CODEC_ID_V210, + CODEC_ID_DPX, + CODEC_ID_MAD, + CODEC_ID_FRWU, + CODEC_ID_FLASHSV2, + CODEC_ID_CDGRAPHICS, + CODEC_ID_R210, + CODEC_ID_ANM, + CODEC_ID_BINKVIDEO, + CODEC_ID_IFF_ILBM, + CODEC_ID_IFF_BYTERUN1, + CODEC_ID_KGV1, + CODEC_ID_YOP, + CODEC_ID_VP8, + CODEC_ID_PICTOR, + CODEC_ID_ANSI, + CODEC_ID_A64_MULTI, + CODEC_ID_A64_MULTI5, + CODEC_ID_R10K, + CODEC_ID_MXPEG, + CODEC_ID_LAGARITH, + CODEC_ID_PRORES, + CODEC_ID_JV, + CODEC_ID_DFA, + CODEC_ID_WMV3IMAGE, + CODEC_ID_VC1IMAGE, + CODEC_ID_UTVIDEO, + CODEC_ID_BMV_VIDEO, + CODEC_ID_VBLE, + CODEC_ID_DXTORY, + CODEC_ID_V410, + CODEC_ID_XWD, + CODEC_ID_CDXL, + CODEC_ID_XBM, + CODEC_ID_ZEROCODEC, + CODEC_ID_MSS1, + CODEC_ID_MSA1, + CODEC_ID_TSCC2, + CODEC_ID_MTS2, + CODEC_ID_CLLC, + CODEC_ID_Y41P = MKBETAG('Y','4','1','P'), + CODEC_ID_ESCAPE130 = MKBETAG('E','1','3','0'), + CODEC_ID_EXR = MKBETAG('0','E','X','R'), + CODEC_ID_AVRP = MKBETAG('A','V','R','P'), + + CODEC_ID_G2M = MKBETAG( 0 ,'G','2','M'), + CODEC_ID_AVUI = MKBETAG('A','V','U','I'), + CODEC_ID_AYUV = MKBETAG('A','Y','U','V'), + CODEC_ID_V308 = MKBETAG('V','3','0','8'), + CODEC_ID_V408 = MKBETAG('V','4','0','8'), + CODEC_ID_YUV4 = MKBETAG('Y','U','V','4'), + CODEC_ID_SANM = MKBETAG('S','A','N','M'), + CODEC_ID_PAF_VIDEO = MKBETAG('P','A','F','V'), + CODEC_ID_SNOW = AV_CODEC_ID_SNOW, + + /* various PCM "codecs" */ + CODEC_ID_FIRST_AUDIO = 0x10000, ///< A dummy id pointing at the start of audio codecs + CODEC_ID_PCM_S16LE = 0x10000, + CODEC_ID_PCM_S16BE, + CODEC_ID_PCM_U16LE, + CODEC_ID_PCM_U16BE, + CODEC_ID_PCM_S8, + CODEC_ID_PCM_U8, + CODEC_ID_PCM_MULAW, + CODEC_ID_PCM_ALAW, + CODEC_ID_PCM_S32LE, + CODEC_ID_PCM_S32BE, + CODEC_ID_PCM_U32LE, + CODEC_ID_PCM_U32BE, + CODEC_ID_PCM_S24LE, + CODEC_ID_PCM_S24BE, + CODEC_ID_PCM_U24LE, + CODEC_ID_PCM_U24BE, + CODEC_ID_PCM_S24DAUD, + CODEC_ID_PCM_ZORK, + CODEC_ID_PCM_S16LE_PLANAR, + CODEC_ID_PCM_DVD, + CODEC_ID_PCM_F32BE, + CODEC_ID_PCM_F32LE, + CODEC_ID_PCM_F64BE, + CODEC_ID_PCM_F64LE, + CODEC_ID_PCM_BLURAY, + CODEC_ID_PCM_LXF, + CODEC_ID_S302M, + CODEC_ID_PCM_S8_PLANAR, + + /* various ADPCM codecs */ + CODEC_ID_ADPCM_IMA_QT = 0x11000, + CODEC_ID_ADPCM_IMA_WAV, + CODEC_ID_ADPCM_IMA_DK3, + CODEC_ID_ADPCM_IMA_DK4, + CODEC_ID_ADPCM_IMA_WS, + CODEC_ID_ADPCM_IMA_SMJPEG, + CODEC_ID_ADPCM_MS, + CODEC_ID_ADPCM_4XM, + CODEC_ID_ADPCM_XA, + CODEC_ID_ADPCM_ADX, + CODEC_ID_ADPCM_EA, + CODEC_ID_ADPCM_G726, + CODEC_ID_ADPCM_CT, + CODEC_ID_ADPCM_SWF, + CODEC_ID_ADPCM_YAMAHA, + CODEC_ID_ADPCM_SBPRO_4, + CODEC_ID_ADPCM_SBPRO_3, + CODEC_ID_ADPCM_SBPRO_2, + CODEC_ID_ADPCM_THP, + CODEC_ID_ADPCM_IMA_AMV, + CODEC_ID_ADPCM_EA_R1, + CODEC_ID_ADPCM_EA_R3, + CODEC_ID_ADPCM_EA_R2, + CODEC_ID_ADPCM_IMA_EA_SEAD, + CODEC_ID_ADPCM_IMA_EA_EACS, + CODEC_ID_ADPCM_EA_XAS, + CODEC_ID_ADPCM_EA_MAXIS_XA, + CODEC_ID_ADPCM_IMA_ISS, + CODEC_ID_ADPCM_G722, + CODEC_ID_ADPCM_IMA_APC, + CODEC_ID_VIMA = MKBETAG('V','I','M','A'), + + /* AMR */ + CODEC_ID_AMR_NB = 0x12000, + CODEC_ID_AMR_WB, + + /* RealAudio codecs*/ + CODEC_ID_RA_144 = 0x13000, + CODEC_ID_RA_288, + + /* various DPCM codecs */ + CODEC_ID_ROQ_DPCM = 0x14000, + CODEC_ID_INTERPLAY_DPCM, + CODEC_ID_XAN_DPCM, + CODEC_ID_SOL_DPCM, + + /* audio codecs */ + CODEC_ID_MP2 = 0x15000, + CODEC_ID_MP3, ///< preferred ID for decoding MPEG audio layer 1, 2 or 3 + CODEC_ID_AAC, + CODEC_ID_AC3, + CODEC_ID_DTS, + CODEC_ID_VORBIS, + CODEC_ID_DVAUDIO, + CODEC_ID_WMAV1, + CODEC_ID_WMAV2, + CODEC_ID_MACE3, + CODEC_ID_MACE6, + CODEC_ID_VMDAUDIO, + CODEC_ID_FLAC, + CODEC_ID_MP3ADU, + CODEC_ID_MP3ON4, + CODEC_ID_SHORTEN, + CODEC_ID_ALAC, + CODEC_ID_WESTWOOD_SND1, + CODEC_ID_GSM, ///< as in Berlin toast format + CODEC_ID_QDM2, + CODEC_ID_COOK, + CODEC_ID_TRUESPEECH, + CODEC_ID_TTA, + CODEC_ID_SMACKAUDIO, + CODEC_ID_QCELP, + CODEC_ID_WAVPACK, + CODEC_ID_DSICINAUDIO, + CODEC_ID_IMC, + CODEC_ID_MUSEPACK7, + CODEC_ID_MLP, + CODEC_ID_GSM_MS, /* as found in WAV */ + CODEC_ID_ATRAC3, + CODEC_ID_VOXWARE, + CODEC_ID_APE, + CODEC_ID_NELLYMOSER, + CODEC_ID_MUSEPACK8, + CODEC_ID_SPEEX, + CODEC_ID_WMAVOICE, + CODEC_ID_WMAPRO, + CODEC_ID_WMALOSSLESS, + CODEC_ID_ATRAC3P, + CODEC_ID_EAC3, + CODEC_ID_SIPR, + CODEC_ID_MP1, + CODEC_ID_TWINVQ, + CODEC_ID_TRUEHD, + CODEC_ID_MP4ALS, + CODEC_ID_ATRAC1, + CODEC_ID_BINKAUDIO_RDFT, + CODEC_ID_BINKAUDIO_DCT, + CODEC_ID_AAC_LATM, + CODEC_ID_QDMC, + CODEC_ID_CELT, + CODEC_ID_G723_1, + CODEC_ID_G729, + CODEC_ID_8SVX_EXP, + CODEC_ID_8SVX_FIB, + CODEC_ID_BMV_AUDIO, + CODEC_ID_RALF, + CODEC_ID_IAC, + CODEC_ID_ILBC, + CODEC_ID_FFWAVESYNTH = MKBETAG('F','F','W','S'), + CODEC_ID_SONIC = MKBETAG('S','O','N','C'), + CODEC_ID_SONIC_LS = MKBETAG('S','O','N','L'), + CODEC_ID_PAF_AUDIO = MKBETAG('P','A','F','A'), + CODEC_ID_OPUS = MKBETAG('O','P','U','S'), + + /* subtitle codecs */ + CODEC_ID_FIRST_SUBTITLE = 0x17000, ///< A dummy ID pointing at the start of subtitle codecs. + CODEC_ID_DVD_SUBTITLE = 0x17000, + CODEC_ID_DVB_SUBTITLE, + CODEC_ID_TEXT, ///< raw UTF-8 text + CODEC_ID_XSUB, + CODEC_ID_SSA, + CODEC_ID_MOV_TEXT, + CODEC_ID_HDMV_PGS_SUBTITLE, + CODEC_ID_DVB_TELETEXT, + CODEC_ID_SRT, + CODEC_ID_MICRODVD = MKBETAG('m','D','V','D'), + CODEC_ID_EIA_608 = MKBETAG('c','6','0','8'), + CODEC_ID_JACOSUB = MKBETAG('J','S','U','B'), + CODEC_ID_SAMI = MKBETAG('S','A','M','I'), + CODEC_ID_REALTEXT = MKBETAG('R','T','X','T'), + CODEC_ID_SUBVIEWER = MKBETAG('S','u','b','V'), + + /* other specific kind of codecs (generally used for attachments) */ + CODEC_ID_FIRST_UNKNOWN = 0x18000, ///< A dummy ID pointing at the start of various fake codecs. + CODEC_ID_TTF = 0x18000, + CODEC_ID_BINTEXT = MKBETAG('B','T','X','T'), + CODEC_ID_XBIN = MKBETAG('X','B','I','N'), + CODEC_ID_IDF = MKBETAG( 0 ,'I','D','F'), + CODEC_ID_OTF = MKBETAG( 0 ,'O','T','F'), + + CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like CODEC_ID_NONE) but lavf should attempt to identify it + + CODEC_ID_MPEG2TS = 0x20000, /**< _FAKE_ codec to indicate a raw MPEG-2 TS + * stream (only used by libavformat) */ + CODEC_ID_MPEG4SYSTEMS = 0x20001, /**< _FAKE_ codec to indicate a MPEG-4 Systems + * stream (only used by libavformat) */ + CODEC_ID_FFMETADATA = 0x21000, ///< Dummy codec for streams containing only metadata information. + +#endif /* AVCODEC_OLD_CODEC_IDS_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavcodec/vaapi.h b/limelight-pc/jni/nv_avc_dec/inc/libavcodec/vaapi.h new file mode 100644 index 0000000..815a27e --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavcodec/vaapi.h @@ -0,0 +1,173 @@ +/* + * Video Acceleration API (shared data between FFmpeg and the video player) + * HW decode acceleration for MPEG-2, MPEG-4, H.264 and VC-1 + * + * Copyright (C) 2008-2009 Splitted-Desktop Systems + * + * 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_VAAPI_H +#define AVCODEC_VAAPI_H + +/** + * @file + * @ingroup lavc_codec_hwaccel_vaapi + * Public libavcodec VA API header. + */ + +#include + +/** + * @defgroup lavc_codec_hwaccel_vaapi VA API Decoding + * @ingroup lavc_codec_hwaccel + * @{ + */ + +/** + * This structure is used to share data between the FFmpeg library and + * the client video application. + * This shall be zero-allocated and available as + * AVCodecContext.hwaccel_context. All user members can be set once + * during initialization or through each AVCodecContext.get_buffer() + * function call. In any case, they must be valid prior to calling + * decoding functions. + */ +struct vaapi_context { + /** + * Window system dependent data + * + * - encoding: unused + * - decoding: Set by user + */ + void *display; + + /** + * Configuration ID + * + * - encoding: unused + * - decoding: Set by user + */ + uint32_t config_id; + + /** + * Context ID (video decode pipeline) + * + * - encoding: unused + * - decoding: Set by user + */ + uint32_t context_id; + + /** + * VAPictureParameterBuffer ID + * + * - encoding: unused + * - decoding: Set by libavcodec + */ + uint32_t pic_param_buf_id; + + /** + * VAIQMatrixBuffer ID + * + * - encoding: unused + * - decoding: Set by libavcodec + */ + uint32_t iq_matrix_buf_id; + + /** + * VABitPlaneBuffer ID (for VC-1 decoding) + * + * - encoding: unused + * - decoding: Set by libavcodec + */ + uint32_t bitplane_buf_id; + + /** + * Slice parameter/data buffer IDs + * + * - encoding: unused + * - decoding: Set by libavcodec + */ + uint32_t *slice_buf_ids; + + /** + * Number of effective slice buffer IDs to send to the HW + * + * - encoding: unused + * - decoding: Set by libavcodec + */ + unsigned int n_slice_buf_ids; + + /** + * Size of pre-allocated slice_buf_ids + * + * - encoding: unused + * - decoding: Set by libavcodec + */ + unsigned int slice_buf_ids_alloc; + + /** + * Pointer to VASliceParameterBuffers + * + * - encoding: unused + * - decoding: Set by libavcodec + */ + void *slice_params; + + /** + * Size of a VASliceParameterBuffer element + * + * - encoding: unused + * - decoding: Set by libavcodec + */ + unsigned int slice_param_size; + + /** + * Size of pre-allocated slice_params + * + * - encoding: unused + * - decoding: Set by libavcodec + */ + unsigned int slice_params_alloc; + + /** + * Number of slices currently filled in + * + * - encoding: unused + * - decoding: Set by libavcodec + */ + unsigned int slice_count; + + /** + * Pointer to slice data buffer base + * - encoding: unused + * - decoding: Set by libavcodec + */ + const uint8_t *slice_data; + + /** + * Current size of slice data + * + * - encoding: unused + * - decoding: Set by libavcodec + */ + uint32_t slice_data_size; +}; + +/* @} */ + +#endif /* AVCODEC_VAAPI_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavcodec/vda.h b/limelight-pc/jni/nv_avc_dec/inc/libavcodec/vda.h new file mode 100644 index 0000000..b3d6399 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavcodec/vda.h @@ -0,0 +1,162 @@ +/* + * VDA HW acceleration + * + * copyright (c) 2011 Sebastien Zwickert + * + * 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_VDA_H +#define AVCODEC_VDA_H + +/** + * @file + * @ingroup lavc_codec_hwaccel_vda + * Public libavcodec VDA header. + */ + +#include + +// emmintrin.h is unable to compile with -std=c99 -Werror=missing-prototypes +// http://openradar.appspot.com/8026390 +#undef __GNUC_STDC_INLINE__ + +#define Picture QuickdrawPicture +#include +#undef Picture + +#include "libavcodec/version.h" + +/** + * @defgroup lavc_codec_hwaccel_vda VDA + * @ingroup lavc_codec_hwaccel + * + * @{ + */ + +/** + * This structure is used to provide the necessary configurations and data + * to the VDA FFmpeg HWAccel implementation. + * + * The application must make it available as AVCodecContext.hwaccel_context. + */ +struct vda_context { + /** + * VDA decoder object. + * + * - encoding: unused + * - decoding: Set/Unset by libavcodec. + */ + VDADecoder decoder; + + /** + * The Core Video pixel buffer that contains the current image data. + * + * encoding: unused + * decoding: Set by libavcodec. Unset by user. + */ + CVPixelBufferRef cv_buffer; + + /** + * Use the hardware decoder in synchronous mode. + * + * encoding: unused + * decoding: Set by user. + */ + int use_sync_decoding; + + /** + * The frame width. + * + * - encoding: unused + * - decoding: Set/Unset by user. + */ + int width; + + /** + * The frame height. + * + * - encoding: unused + * - decoding: Set/Unset by user. + */ + int height; + + /** + * The frame format. + * + * - encoding: unused + * - decoding: Set/Unset by user. + */ + int format; + + /** + * The pixel format for output image buffers. + * + * - encoding: unused + * - decoding: Set/Unset by user. + */ + OSType cv_pix_fmt_type; + + /** + * The current bitstream buffer. + * + * - encoding: unused + * - decoding: Set/Unset by libavcodec. + */ + uint8_t *priv_bitstream; + + /** + * The current size of the bitstream. + * + * - encoding: unused + * - decoding: Set/Unset by libavcodec. + */ + int priv_bitstream_size; + + /** + * The reference size used for fast reallocation. + * + * - encoding: unused + * - decoding: Set/Unset by libavcodec. + */ + int priv_allocated_size; + + /** + * Use av_buffer to manage buffer. + * When the flag is set, the CVPixelBuffers returned by the decoder will + * be released automatically, so you have to retain them if necessary. + * Not setting this flag may cause memory leak. + * + * encoding: unused + * decoding: Set by user. + */ + int use_ref_buffer; +}; + +/** Create the video decoder. */ +int ff_vda_create_decoder(struct vda_context *vda_ctx, + uint8_t *extradata, + int extradata_size); + +/** Destroy the video decoder. */ +int ff_vda_destroy_decoder(struct vda_context *vda_ctx); + +/** + * @} + */ + +#endif /* AVCODEC_VDA_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavcodec/vdpau.h b/limelight-pc/jni/nv_avc_dec/inc/libavcodec/vdpau.h new file mode 100644 index 0000000..e25cc42 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavcodec/vdpau.h @@ -0,0 +1,215 @@ +/* + * The Video Decode and Presentation API for UNIX (VDPAU) is used for + * hardware-accelerated decoding of MPEG-1/2, H.264 and VC-1. + * + * Copyright (C) 2008 NVIDIA + * + * 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_VDPAU_H +#define AVCODEC_VDPAU_H + +/** + * @file + * @ingroup lavc_codec_hwaccel_vdpau + * Public libavcodec VDPAU header. + */ + + +/** + * @defgroup lavc_codec_hwaccel_vdpau VDPAU Decoder and Renderer + * @ingroup lavc_codec_hwaccel + * + * VDPAU hardware acceleration has two modules + * - VDPAU decoding + * - VDPAU presentation + * + * The VDPAU decoding module parses all headers using FFmpeg + * parsing mechanisms and uses VDPAU for the actual decoding. + * + * As per the current implementation, the actual decoding + * and rendering (API calls) are done as part of the VDPAU + * presentation (vo_vdpau.c) module. + * + * @{ + */ + +#include +#include +#include "libavutil/avconfig.h" +#include "libavutil/attributes.h" + +#include "avcodec.h" +#include "version.h" + +#if FF_API_BUFS_VDPAU +union AVVDPAUPictureInfo { + VdpPictureInfoH264 h264; + VdpPictureInfoMPEG1Or2 mpeg; + VdpPictureInfoVC1 vc1; + VdpPictureInfoMPEG4Part2 mpeg4; +}; +#endif + +struct AVCodecContext; +struct AVFrame; + +typedef int (*AVVDPAU_Render2)(struct AVCodecContext *, struct AVFrame *, + const VdpPictureInfo *, uint32_t, + const VdpBitstreamBuffer *); + +/** + * This structure is used to share data between the libavcodec library and + * the client video application. + * The user shall allocate the structure via the av_alloc_vdpau_hwaccel + * function and make it available as + * AVCodecContext.hwaccel_context. Members can be set by the user once + * during initialization or through each AVCodecContext.get_buffer() + * function call. In any case, they must be valid prior to calling + * decoding functions. + * + * The size of this structure is not a part of the public ABI and must not + * be used outside of libavcodec. Use av_vdpau_alloc_context() to allocate an + * AVVDPAUContext. + */ +typedef struct AVVDPAUContext { + /** + * VDPAU decoder handle + * + * Set by user. + */ + VdpDecoder decoder; + + /** + * VDPAU decoder render callback + * + * Set by the user. + */ + VdpDecoderRender *render; + +#if FF_API_BUFS_VDPAU + /** + * VDPAU picture information + * + * Set by libavcodec. + */ + attribute_deprecated + union AVVDPAUPictureInfo info; + + /** + * Allocated size of the bitstream_buffers table. + * + * Set by libavcodec. + */ + attribute_deprecated + int bitstream_buffers_allocated; + + /** + * Useful bitstream buffers in the bitstream buffers table. + * + * Set by libavcodec. + */ + attribute_deprecated + int bitstream_buffers_used; + + /** + * Table of bitstream buffers. + * The user is responsible for freeing this buffer using av_freep(). + * + * Set by libavcodec. + */ + attribute_deprecated + VdpBitstreamBuffer *bitstream_buffers; +#endif + AVVDPAU_Render2 render2; +} AVVDPAUContext; + +/** + * @brief allocation function for AVVDPAUContext + * + * Allows extending the struct without breaking API/ABI + */ +AVVDPAUContext *av_alloc_vdpaucontext(void); + +AVVDPAU_Render2 av_vdpau_hwaccel_get_render2(const AVVDPAUContext *); +void av_vdpau_hwaccel_set_render2(AVVDPAUContext *, AVVDPAU_Render2); + +/** + * Allocate an AVVDPAUContext. + * + * @return Newly-allocated AVVDPAUContext or NULL on failure. + */ +AVVDPAUContext *av_vdpau_alloc_context(void); + +/** + * Get a decoder profile that should be used for initializing a VDPAU decoder. + * Should be called from the AVCodecContext.get_format() callback. + * + * @param avctx the codec context being used for decoding the stream + * @param profile a pointer into which the result will be written on success. + * The contents of profile are undefined if this function returns + * an error. + * + * @return 0 on success (non-negative), a negative AVERROR on failure. + */ +int av_vdpau_get_profile(AVCodecContext *avctx, VdpDecoderProfile *profile); + +#if FF_API_CAP_VDPAU +/** @brief The videoSurface is used for rendering. */ +#define FF_VDPAU_STATE_USED_FOR_RENDER 1 + +/** + * @brief The videoSurface is needed for reference/prediction. + * The codec manipulates this. + */ +#define FF_VDPAU_STATE_USED_FOR_REFERENCE 2 + +/** + * @brief This structure is used as a callback between the FFmpeg + * decoder (vd_) and presentation (vo_) module. + * This is used for defining a video frame containing surface, + * picture parameter, bitstream information etc which are passed + * between the FFmpeg decoder and its clients. + */ +struct vdpau_render_state { + VdpVideoSurface surface; ///< Used as rendered surface, never changed. + + int state; ///< Holds FF_VDPAU_STATE_* values. + +#if AV_HAVE_INCOMPATIBLE_LIBAV_ABI + /** picture parameter information for all supported codecs */ + union AVVDPAUPictureInfo info; +#endif + + /** Describe size/location of the compressed video data. + Set to 0 when freeing bitstream_buffers. */ + int bitstream_buffers_allocated; + int bitstream_buffers_used; + /** The user is responsible for freeing this buffer using av_freep(). */ + VdpBitstreamBuffer *bitstream_buffers; + +#if !AV_HAVE_INCOMPATIBLE_LIBAV_ABI + /** picture parameter information for all supported codecs */ + union AVVDPAUPictureInfo info; +#endif +}; +#endif + +/* @}*/ + +#endif /* AVCODEC_VDPAU_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavcodec/version.h b/limelight-pc/jni/nv_avc_dec/inc/libavcodec/version.h new file mode 100644 index 0000000..8db0270 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavcodec/version.h @@ -0,0 +1,142 @@ +/* + * + * 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_VERSION_H +#define AVCODEC_VERSION_H + +/** + * @file + * @ingroup libavc + * Libavcodec version macros. + */ + +#include "libavutil/avutil.h" + +#define LIBAVCODEC_VERSION_MAJOR 55 +#define LIBAVCODEC_VERSION_MINOR 43 +#define LIBAVCODEC_VERSION_MICRO 101 + +#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \ + LIBAVCODEC_VERSION_MINOR, \ + LIBAVCODEC_VERSION_MICRO) +#define LIBAVCODEC_VERSION AV_VERSION(LIBAVCODEC_VERSION_MAJOR, \ + LIBAVCODEC_VERSION_MINOR, \ + LIBAVCODEC_VERSION_MICRO) +#define LIBAVCODEC_BUILD LIBAVCODEC_VERSION_INT + +#define LIBAVCODEC_IDENT "Lavc" AV_STRINGIFY(LIBAVCODEC_VERSION) + +/** + * FF_API_* defines may be placed below to indicate public API that will be + * dropped at a future version bump. The defines themselves are not part of + * the public API and may change, break or disappear at any time. + */ + +#ifndef FF_API_REQUEST_CHANNELS +#define FF_API_REQUEST_CHANNELS (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_OLD_DECODE_AUDIO +#define FF_API_OLD_DECODE_AUDIO (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_OLD_ENCODE_AUDIO +#define FF_API_OLD_ENCODE_AUDIO (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_OLD_ENCODE_VIDEO +#define FF_API_OLD_ENCODE_VIDEO (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_CODEC_ID +#define FF_API_CODEC_ID (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_AUDIO_CONVERT +#define FF_API_AUDIO_CONVERT (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_AVCODEC_RESAMPLE +#define FF_API_AVCODEC_RESAMPLE FF_API_AUDIO_CONVERT +#endif +#ifndef FF_API_DEINTERLACE +#define FF_API_DEINTERLACE (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_DESTRUCT_PACKET +#define FF_API_DESTRUCT_PACKET (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_GET_BUFFER +#define FF_API_GET_BUFFER (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_MISSING_SAMPLE +#define FF_API_MISSING_SAMPLE (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_LOWRES +#define FF_API_LOWRES (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_CAP_VDPAU +#define FF_API_CAP_VDPAU (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_BUFS_VDPAU +#define FF_API_BUFS_VDPAU (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_VOXWARE +#define FF_API_VOXWARE (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_SET_DIMENSIONS +#define FF_API_SET_DIMENSIONS (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_DEBUG_MV +#define FF_API_DEBUG_MV (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_AC_VLC +#define FF_API_AC_VLC (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_OLD_MSMPEG4 +#define FF_API_OLD_MSMPEG4 (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_ASPECT_EXTENDED +#define FF_API_ASPECT_EXTENDED (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_THREAD_OPAQUE +#define FF_API_THREAD_OPAQUE (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_CODEC_PKT +#define FF_API_CODEC_PKT (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_ARCH_ALPHA +#define FF_API_ARCH_ALPHA (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_XVMC +#define FF_API_XVMC (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_ERROR_RATE +#define FF_API_ERROR_RATE (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_QSCALE_TYPE +#define FF_API_QSCALE_TYPE (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_MB_TYPE +#define FF_API_MB_TYPE (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_MAX_BFRAMES +#define FF_API_MAX_BFRAMES (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_FAST_MALLOC +#define FF_API_FAST_MALLOC (LIBAVCODEC_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_NEG_LINESIZES +#define FF_API_NEG_LINESIZES (LIBAVCODEC_VERSION_MAJOR < 56) +#endif + +#endif /* AVCODEC_VERSION_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavcodec/xvmc.h b/limelight-pc/jni/nv_avc_dec/inc/libavcodec/xvmc.h new file mode 100644 index 0000000..efd69fc --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavcodec/xvmc.h @@ -0,0 +1,174 @@ +/* + * Copyright (C) 2003 Ivan Kalvachev + * + * 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_XVMC_H +#define AVCODEC_XVMC_H + +/** + * @file + * @ingroup lavc_codec_hwaccel_xvmc + * Public libavcodec XvMC header. + */ + +#include + +#include "libavutil/attributes.h" +#include "version.h" +#include "avcodec.h" + +#if FF_API_XVMC + +/** + * @defgroup lavc_codec_hwaccel_xvmc XvMC + * @ingroup lavc_codec_hwaccel + * + * @{ + */ + +#define AV_XVMC_ID 0x1DC711C0 /**< special value to ensure that regular pixel routines haven't corrupted the struct + the number is 1337 speak for the letters IDCT MCo (motion compensation) */ + +attribute_deprecated struct xvmc_pix_fmt { + /** The field contains the special constant value AV_XVMC_ID. + It is used as a test that the application correctly uses the API, + and that there is no corruption caused by pixel routines. + - application - set during initialization + - libavcodec - unchanged + */ + int xvmc_id; + + /** Pointer to the block array allocated by XvMCCreateBlocks(). + The array has to be freed by XvMCDestroyBlocks(). + Each group of 64 values represents one data block of differential + pixel information (in MoCo mode) or coefficients for IDCT. + - application - set the pointer during initialization + - libavcodec - fills coefficients/pixel data into the array + */ + short* data_blocks; + + /** Pointer to the macroblock description array allocated by + XvMCCreateMacroBlocks() and freed by XvMCDestroyMacroBlocks(). + - application - set the pointer during initialization + - libavcodec - fills description data into the array + */ + XvMCMacroBlock* mv_blocks; + + /** Number of macroblock descriptions that can be stored in the mv_blocks + array. + - application - set during initialization + - libavcodec - unchanged + */ + int allocated_mv_blocks; + + /** Number of blocks that can be stored at once in the data_blocks array. + - application - set during initialization + - libavcodec - unchanged + */ + int allocated_data_blocks; + + /** Indicate that the hardware would interpret data_blocks as IDCT + coefficients and perform IDCT on them. + - application - set during initialization + - libavcodec - unchanged + */ + int idct; + + /** In MoCo mode it indicates that intra macroblocks are assumed to be in + unsigned format; same as the XVMC_INTRA_UNSIGNED flag. + - application - set during initialization + - libavcodec - unchanged + */ + int unsigned_intra; + + /** Pointer to the surface allocated by XvMCCreateSurface(). + It has to be freed by XvMCDestroySurface() on application exit. + It identifies the frame and its state on the video hardware. + - application - set during initialization + - libavcodec - unchanged + */ + XvMCSurface* p_surface; + +/** Set by the decoder before calling ff_draw_horiz_band(), + needed by the XvMCRenderSurface function. */ +//@{ + /** Pointer to the surface used as past reference + - application - unchanged + - libavcodec - set + */ + XvMCSurface* p_past_surface; + + /** Pointer to the surface used as future reference + - application - unchanged + - libavcodec - set + */ + XvMCSurface* p_future_surface; + + /** top/bottom field or frame + - application - unchanged + - libavcodec - set + */ + unsigned int picture_structure; + + /** XVMC_SECOND_FIELD - 1st or 2nd field in the sequence + - application - unchanged + - libavcodec - set + */ + unsigned int flags; +//}@ + + /** Number of macroblock descriptions in the mv_blocks array + that have already been passed to the hardware. + - application - zeroes it on get_buffer(). + A successful ff_draw_horiz_band() may increment it + with filled_mb_block_num or zero both. + - libavcodec - unchanged + */ + int start_mv_blocks_num; + + /** Number of new macroblock descriptions in the mv_blocks array (after + start_mv_blocks_num) that are filled by libavcodec and have to be + passed to the hardware. + - application - zeroes it on get_buffer() or after successful + ff_draw_horiz_band(). + - libavcodec - increment with one of each stored MB + */ + int filled_mv_blocks_num; + + /** Number of the next free data block; one data block consists of + 64 short values in the data_blocks array. + All blocks before this one have already been claimed by placing their + position into the corresponding block description structure field, + that are part of the mv_blocks array. + - application - zeroes it on get_buffer(). + A successful ff_draw_horiz_band() may zero it together + with start_mb_blocks_num. + - libavcodec - each decoded macroblock increases it by the number + of coded blocks it contains. + */ + int next_free_data_block_num; +}; + +/** + * @} + */ + +#endif /* FF_API_XVMC */ + +#endif /* AVCODEC_XVMC_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavfilter/asrc_abuffer.h b/limelight-pc/jni/nv_avc_dec/inc/libavfilter/asrc_abuffer.h new file mode 100644 index 0000000..aa34461 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavfilter/asrc_abuffer.h @@ -0,0 +1,91 @@ +/* + * 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 AVFILTER_ASRC_ABUFFER_H +#define AVFILTER_ASRC_ABUFFER_H + +#include "avfilter.h" + +/** + * @file + * memory buffer source for audio + * + * @deprecated use buffersrc.h instead. + */ + +/** + * Queue an audio buffer to the audio buffer source. + * + * @param abuffersrc audio source buffer context + * @param data pointers to the samples planes + * @param linesize linesizes of each audio buffer plane + * @param nb_samples number of samples per channel + * @param sample_fmt sample format of the audio data + * @param ch_layout channel layout of the audio data + * @param planar flag to indicate if audio data is planar or packed + * @param pts presentation timestamp of the audio buffer + * @param flags unused + * + * @deprecated use av_buffersrc_add_ref() instead. + */ +attribute_deprecated +int av_asrc_buffer_add_samples(AVFilterContext *abuffersrc, + uint8_t *data[8], int linesize[8], + int nb_samples, int sample_rate, + int sample_fmt, int64_t ch_layout, int planar, + int64_t pts, int av_unused flags); + +/** + * Queue an audio buffer to the audio buffer source. + * + * This is similar to av_asrc_buffer_add_samples(), but the samples + * are stored in a buffer with known size. + * + * @param abuffersrc audio source buffer context + * @param buf pointer to the samples data, packed is assumed + * @param size the size in bytes of the buffer, it must contain an + * integer number of samples + * @param sample_fmt sample format of the audio data + * @param ch_layout channel layout of the audio data + * @param pts presentation timestamp of the audio buffer + * @param flags unused + * + * @deprecated use av_buffersrc_add_ref() instead. + */ +attribute_deprecated +int av_asrc_buffer_add_buffer(AVFilterContext *abuffersrc, + uint8_t *buf, int buf_size, + int sample_rate, + int sample_fmt, int64_t ch_layout, int planar, + int64_t pts, int av_unused flags); + +/** + * Queue an audio buffer to the audio buffer source. + * + * @param abuffersrc audio source buffer context + * @param samplesref buffer ref to queue + * @param flags unused + * + * @deprecated use av_buffersrc_add_ref() instead. + */ +attribute_deprecated +int av_asrc_buffer_add_audio_buffer_ref(AVFilterContext *abuffersrc, + AVFilterBufferRef *samplesref, + int av_unused flags); + +#endif /* AVFILTER_ASRC_ABUFFER_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavfilter/avcodec.h b/limelight-pc/jni/nv_avc_dec/inc/libavfilter/avcodec.h new file mode 100644 index 0000000..8bbdad2 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavfilter/avcodec.h @@ -0,0 +1,110 @@ +/* + * 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 AVFILTER_AVCODEC_H +#define AVFILTER_AVCODEC_H + +/** + * @file + * libavcodec/libavfilter gluing utilities + * + * This should be included in an application ONLY if the installed + * libavfilter has been compiled with libavcodec support, otherwise + * symbols defined below will not be available. + */ + +#include "avfilter.h" + +#if FF_API_AVFILTERBUFFER +/** + * Create and return a picref reference from the data and properties + * contained in frame. + * + * @param perms permissions to assign to the new buffer reference + * @deprecated avfilter APIs work natively with AVFrame instead. + */ +attribute_deprecated +AVFilterBufferRef *avfilter_get_video_buffer_ref_from_frame(const AVFrame *frame, int perms); + + +/** + * Create and return a picref reference from the data and properties + * contained in frame. + * + * @param perms permissions to assign to the new buffer reference + * @deprecated avfilter APIs work natively with AVFrame instead. + */ +attribute_deprecated +AVFilterBufferRef *avfilter_get_audio_buffer_ref_from_frame(const AVFrame *frame, + int perms); + +/** + * Create and return a buffer reference from the data and properties + * contained in frame. + * + * @param perms permissions to assign to the new buffer reference + * @deprecated avfilter APIs work natively with AVFrame instead. + */ +attribute_deprecated +AVFilterBufferRef *avfilter_get_buffer_ref_from_frame(enum AVMediaType type, + const AVFrame *frame, + int perms); +#endif + +#if FF_API_FILL_FRAME +/** + * Fill an AVFrame with the information stored in samplesref. + * + * @param frame an already allocated AVFrame + * @param samplesref an audio buffer reference + * @return >= 0 in case of success, a negative AVERROR code in case of + * failure + * @deprecated Use avfilter_copy_buf_props() instead. + */ +attribute_deprecated +int avfilter_fill_frame_from_audio_buffer_ref(AVFrame *frame, + const AVFilterBufferRef *samplesref); + +/** + * Fill an AVFrame with the information stored in picref. + * + * @param frame an already allocated AVFrame + * @param picref a video buffer reference + * @return >= 0 in case of success, a negative AVERROR code in case of + * failure + * @deprecated Use avfilter_copy_buf_props() instead. + */ +attribute_deprecated +int avfilter_fill_frame_from_video_buffer_ref(AVFrame *frame, + const AVFilterBufferRef *picref); + +/** + * Fill an AVFrame with information stored in ref. + * + * @param frame an already allocated AVFrame + * @param ref a video or audio buffer reference + * @return >= 0 in case of success, a negative AVERROR code in case of + * failure + * @deprecated Use avfilter_copy_buf_props() instead. + */ +attribute_deprecated +int avfilter_fill_frame_from_buffer_ref(AVFrame *frame, + const AVFilterBufferRef *ref); +#endif + +#endif /* AVFILTER_AVCODEC_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavfilter/avfilter.h b/limelight-pc/jni/nv_avc_dec/inc/libavfilter/avfilter.h new file mode 100644 index 0000000..3518ad8 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavfilter/avfilter.h @@ -0,0 +1,1523 @@ +/* + * filter layer + * Copyright (c) 2007 Bobby Bingham + * + * 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 AVFILTER_AVFILTER_H +#define AVFILTER_AVFILTER_H + +/** + * @file + * @ingroup lavfi + * Main libavfilter public API header + */ + +/** + * @defgroup lavfi Libavfilter - graph-based frame editing library + * @{ + */ + +#include + +#include "libavutil/attributes.h" +#include "libavutil/avutil.h" +#include "libavutil/dict.h" +#include "libavutil/frame.h" +#include "libavutil/log.h" +#include "libavutil/samplefmt.h" +#include "libavutil/pixfmt.h" +#include "libavutil/rational.h" + +#include "libavfilter/version.h" + +/** + * Return the LIBAVFILTER_VERSION_INT constant. + */ +unsigned avfilter_version(void); + +/** + * Return the libavfilter build-time configuration. + */ +const char *avfilter_configuration(void); + +/** + * Return the libavfilter license. + */ +const char *avfilter_license(void); + +typedef struct AVFilterContext AVFilterContext; +typedef struct AVFilterLink AVFilterLink; +typedef struct AVFilterPad AVFilterPad; +typedef struct AVFilterFormats AVFilterFormats; + +#if FF_API_AVFILTERBUFFER +/** + * A reference-counted buffer data type used by the filter system. Filters + * should not store pointers to this structure directly, but instead use the + * AVFilterBufferRef structure below. + */ +typedef struct AVFilterBuffer { + uint8_t *data[8]; ///< buffer data for each plane/channel + + /** + * pointers to the data planes/channels. + * + * For video, this should simply point to data[]. + * + * For planar audio, each channel has a separate data pointer, and + * linesize[0] contains the size of each channel buffer. + * For packed audio, there is just one data pointer, and linesize[0] + * contains the total size of the buffer for all channels. + * + * Note: Both data and extended_data will always be set, but for planar + * audio with more channels that can fit in data, extended_data must be used + * in order to access all channels. + */ + uint8_t **extended_data; + int linesize[8]; ///< number of bytes per line + + /** private data to be used by a custom free function */ + void *priv; + /** + * A pointer to the function to deallocate this buffer if the default + * function is not sufficient. This could, for example, add the memory + * back into a memory pool to be reused later without the overhead of + * reallocating it from scratch. + */ + void (*free)(struct AVFilterBuffer *buf); + + int format; ///< media format + int w, h; ///< width and height of the allocated buffer + unsigned refcount; ///< number of references to this buffer +} AVFilterBuffer; + +#define AV_PERM_READ 0x01 ///< can read from the buffer +#define AV_PERM_WRITE 0x02 ///< can write to the buffer +#define AV_PERM_PRESERVE 0x04 ///< nobody else can overwrite the buffer +#define AV_PERM_REUSE 0x08 ///< can output the buffer multiple times, with the same contents each time +#define AV_PERM_REUSE2 0x10 ///< can output the buffer multiple times, modified each time +#define AV_PERM_NEG_LINESIZES 0x20 ///< the buffer requested can have negative linesizes +#define AV_PERM_ALIGN 0x40 ///< the buffer must be aligned + +#define AVFILTER_ALIGN 16 //not part of ABI + +/** + * Audio specific properties in a reference to an AVFilterBuffer. Since + * AVFilterBufferRef is common to different media formats, audio specific + * per reference properties must be separated out. + */ +typedef struct AVFilterBufferRefAudioProps { + uint64_t channel_layout; ///< channel layout of audio buffer + int nb_samples; ///< number of audio samples per channel + int sample_rate; ///< audio buffer sample rate + int channels; ///< number of channels (do not access directly) +} AVFilterBufferRefAudioProps; + +/** + * Video specific properties in a reference to an AVFilterBuffer. Since + * AVFilterBufferRef is common to different media formats, video specific + * per reference properties must be separated out. + */ +typedef struct AVFilterBufferRefVideoProps { + int w; ///< image width + int h; ///< image height + AVRational sample_aspect_ratio; ///< sample aspect ratio + int interlaced; ///< is frame interlaced + int top_field_first; ///< field order + enum AVPictureType pict_type; ///< picture type of the frame + int key_frame; ///< 1 -> keyframe, 0-> not + int qp_table_linesize; ///< qp_table stride + int qp_table_size; ///< qp_table size + int8_t *qp_table; ///< array of Quantization Parameters +} AVFilterBufferRefVideoProps; + +/** + * A reference to an AVFilterBuffer. Since filters can manipulate the origin of + * a buffer to, for example, crop image without any memcpy, the buffer origin + * and dimensions are per-reference properties. Linesize is also useful for + * image flipping, frame to field filters, etc, and so is also per-reference. + * + * TODO: add anything necessary for frame reordering + */ +typedef struct AVFilterBufferRef { + AVFilterBuffer *buf; ///< the buffer that this is a reference to + uint8_t *data[8]; ///< picture/audio data for each plane + /** + * pointers to the data planes/channels. + * + * For video, this should simply point to data[]. + * + * For planar audio, each channel has a separate data pointer, and + * linesize[0] contains the size of each channel buffer. + * For packed audio, there is just one data pointer, and linesize[0] + * contains the total size of the buffer for all channels. + * + * Note: Both data and extended_data will always be set, but for planar + * audio with more channels that can fit in data, extended_data must be used + * in order to access all channels. + */ + uint8_t **extended_data; + int linesize[8]; ///< number of bytes per line + + AVFilterBufferRefVideoProps *video; ///< video buffer specific properties + AVFilterBufferRefAudioProps *audio; ///< audio buffer specific properties + + /** + * presentation timestamp. The time unit may change during + * filtering, as it is specified in the link and the filter code + * may need to rescale the PTS accordingly. + */ + int64_t pts; + int64_t pos; ///< byte position in stream, -1 if unknown + + int format; ///< media format + + int perms; ///< permissions, see the AV_PERM_* flags + + enum AVMediaType type; ///< media type of buffer data + + AVDictionary *metadata; ///< dictionary containing metadata key=value tags +} AVFilterBufferRef; + +/** + * Copy properties of src to dst, without copying the actual data + */ +attribute_deprecated +void avfilter_copy_buffer_ref_props(AVFilterBufferRef *dst, AVFilterBufferRef *src); + +/** + * Add a new reference to a buffer. + * + * @param ref an existing reference to the buffer + * @param pmask a bitmask containing the allowable permissions in the new + * reference + * @return a new reference to the buffer with the same properties as the + * old, excluding any permissions denied by pmask + */ +attribute_deprecated +AVFilterBufferRef *avfilter_ref_buffer(AVFilterBufferRef *ref, int pmask); + +/** + * Remove a reference to a buffer. If this is the last reference to the + * buffer, the buffer itself is also automatically freed. + * + * @param ref reference to the buffer, may be NULL + * + * @note it is recommended to use avfilter_unref_bufferp() instead of this + * function + */ +attribute_deprecated +void avfilter_unref_buffer(AVFilterBufferRef *ref); + +/** + * Remove a reference to a buffer and set the pointer to NULL. + * If this is the last reference to the buffer, the buffer itself + * is also automatically freed. + * + * @param ref pointer to the buffer reference + */ +attribute_deprecated +void avfilter_unref_bufferp(AVFilterBufferRef **ref); +#endif + +/** + * Get the number of channels of a buffer reference. + */ +attribute_deprecated +int avfilter_ref_get_channels(AVFilterBufferRef *ref); + +#if FF_API_AVFILTERPAD_PUBLIC +/** + * A filter pad used for either input or output. + * + * See doc/filter_design.txt for details on how to implement the methods. + * + * @warning this struct might be removed from public API. + * users should call avfilter_pad_get_name() and avfilter_pad_get_type() + * to access the name and type fields; there should be no need to access + * any other fields from outside of libavfilter. + */ +struct AVFilterPad { + /** + * Pad name. The name is unique among inputs and among outputs, but an + * input may have the same name as an output. This may be NULL if this + * pad has no need to ever be referenced by name. + */ + const char *name; + + /** + * AVFilterPad type. + */ + enum AVMediaType type; + + /** + * Input pads: + * Minimum required permissions on incoming buffers. Any buffer with + * insufficient permissions will be automatically copied by the filter + * system to a new buffer which provides the needed access permissions. + * + * Output pads: + * Guaranteed permissions on outgoing buffers. Any buffer pushed on the + * link must have at least these permissions; this fact is checked by + * asserts. It can be used to optimize buffer allocation. + */ + attribute_deprecated int min_perms; + + /** + * Input pads: + * Permissions which are not accepted on incoming buffers. Any buffer + * which has any of these permissions set will be automatically copied + * by the filter system to a new buffer which does not have those + * permissions. This can be used to easily disallow buffers with + * AV_PERM_REUSE. + * + * Output pads: + * Permissions which are automatically removed on outgoing buffers. It + * can be used to optimize buffer allocation. + */ + attribute_deprecated int rej_perms; + + /** + * @deprecated unused + */ + int (*start_frame)(AVFilterLink *link, AVFilterBufferRef *picref); + + /** + * Callback function to get a video buffer. If NULL, the filter system will + * use ff_default_get_video_buffer(). + * + * Input video pads only. + */ + AVFrame *(*get_video_buffer)(AVFilterLink *link, int w, int h); + + /** + * Callback function to get an audio buffer. If NULL, the filter system will + * use ff_default_get_audio_buffer(). + * + * Input audio pads only. + */ + AVFrame *(*get_audio_buffer)(AVFilterLink *link, int nb_samples); + + /** + * @deprecated unused + */ + int (*end_frame)(AVFilterLink *link); + + /** + * @deprecated unused + */ + int (*draw_slice)(AVFilterLink *link, int y, int height, int slice_dir); + + /** + * Filtering callback. This is where a filter receives a frame with + * audio/video data and should do its processing. + * + * Input pads only. + * + * @return >= 0 on success, a negative AVERROR on error. This function + * must ensure that frame is properly unreferenced on error if it + * hasn't been passed on to another filter. + */ + int (*filter_frame)(AVFilterLink *link, AVFrame *frame); + + /** + * Frame poll callback. This returns the number of immediately available + * samples. It should return a positive value if the next request_frame() + * is guaranteed to return one frame (with no delay). + * + * Defaults to just calling the source poll_frame() method. + * + * Output pads only. + */ + int (*poll_frame)(AVFilterLink *link); + + /** + * Frame request callback. A call to this should result in at least one + * frame being output over the given link. This should return zero on + * success, and another value on error. + * See ff_request_frame() for the error codes with a specific + * meaning. + * + * Output pads only. + */ + int (*request_frame)(AVFilterLink *link); + + /** + * Link configuration callback. + * + * For output pads, this should set the following link properties: + * video: width, height, sample_aspect_ratio, time_base + * audio: sample_rate. + * + * This should NOT set properties such as format, channel_layout, etc which + * are negotiated between filters by the filter system using the + * query_formats() callback before this function is called. + * + * For input pads, this should check the properties of the link, and update + * the filter's internal state as necessary. + * + * For both input and output pads, this should return zero on success, + * and another value on error. + */ + int (*config_props)(AVFilterLink *link); + + /** + * The filter expects a fifo to be inserted on its input link, + * typically because it has a delay. + * + * input pads only. + */ + int needs_fifo; + + int needs_writable; +}; +#endif + +/** + * Get the number of elements in a NULL-terminated array of AVFilterPads (e.g. + * AVFilter.inputs/outputs). + */ +int avfilter_pad_count(const AVFilterPad *pads); + +/** + * Get the name of an AVFilterPad. + * + * @param pads an array of AVFilterPads + * @param pad_idx index of the pad in the array it; is the caller's + * responsibility to ensure the index is valid + * + * @return name of the pad_idx'th pad in pads + */ +const char *avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx); + +/** + * Get the type of an AVFilterPad. + * + * @param pads an array of AVFilterPads + * @param pad_idx index of the pad in the array; it is the caller's + * responsibility to ensure the index is valid + * + * @return type of the pad_idx'th pad in pads + */ +enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx); + +/** + * The number of the filter inputs is not determined just by AVFilter.inputs. + * The filter might add additional inputs during initialization depending on the + * options supplied to it. + */ +#define AVFILTER_FLAG_DYNAMIC_INPUTS (1 << 0) +/** + * The number of the filter outputs is not determined just by AVFilter.outputs. + * The filter might add additional outputs during initialization depending on + * the options supplied to it. + */ +#define AVFILTER_FLAG_DYNAMIC_OUTPUTS (1 << 1) +/** + * The filter supports multithreading by splitting frames into multiple parts + * and processing them concurrently. + */ +#define AVFILTER_FLAG_SLICE_THREADS (1 << 2) +/** + * Some filters support a generic "enable" expression option that can be used + * to enable or disable a filter in the timeline. Filters supporting this + * option have this flag set. When the enable expression is false, the default + * no-op filter_frame() function is called in place of the filter_frame() + * callback defined on each input pad, thus the frame is passed unchanged to + * the next filters. + */ +#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC (1 << 16) +/** + * Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will + * have its filter_frame() callback(s) called as usual even when the enable + * expression is false. The filter will disable filtering within the + * filter_frame() callback(s) itself, for example executing code depending on + * the AVFilterContext->is_disabled value. + */ +#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL (1 << 17) +/** + * Handy mask to test whether the filter supports or no the timeline feature + * (internally or generically). + */ +#define AVFILTER_FLAG_SUPPORT_TIMELINE (AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL) + +/** + * Filter definition. This defines the pads a filter contains, and all the + * callback functions used to interact with the filter. + */ +typedef struct AVFilter { + /** + * Filter name. Must be non-NULL and unique among filters. + */ + const char *name; + + /** + * A description of the filter. May be NULL. + * + * You should use the NULL_IF_CONFIG_SMALL() macro to define it. + */ + const char *description; + + /** + * List of inputs, terminated by a zeroed element. + * + * NULL if there are no (static) inputs. Instances of filters with + * AVFILTER_FLAG_DYNAMIC_INPUTS set may have more inputs than present in + * this list. + */ + const AVFilterPad *inputs; + /** + * List of outputs, terminated by a zeroed element. + * + * NULL if there are no (static) outputs. Instances of filters with + * AVFILTER_FLAG_DYNAMIC_OUTPUTS set may have more outputs than present in + * this list. + */ + const AVFilterPad *outputs; + + /** + * A class for the private data, used to declare filter private AVOptions. + * This field is NULL for filters that do not declare any options. + * + * If this field is non-NULL, the first member of the filter private data + * must be a pointer to AVClass, which will be set by libavfilter generic + * code to this class. + */ + const AVClass *priv_class; + + /** + * A combination of AVFILTER_FLAG_* + */ + int flags; + + /***************************************************************** + * All fields below this line are not part of the public API. They + * may not be used outside of libavfilter and can be changed and + * removed at will. + * New public fields should be added right above. + ***************************************************************** + */ + + /** + * Filter initialization function. + * + * This callback will be called only once during the filter lifetime, after + * all the options have been set, but before links between filters are + * established and format negotiation is done. + * + * Basic filter initialization should be done here. Filters with dynamic + * inputs and/or outputs should create those inputs/outputs here based on + * provided options. No more changes to this filter's inputs/outputs can be + * done after this callback. + * + * This callback must not assume that the filter links exist or frame + * parameters are known. + * + * @ref AVFilter.uninit "uninit" is guaranteed to be called even if + * initialization fails, so this callback does not have to clean up on + * failure. + * + * @return 0 on success, a negative AVERROR on failure + */ + int (*init)(AVFilterContext *ctx); + + /** + * Should be set instead of @ref AVFilter.init "init" by the filters that + * want to pass a dictionary of AVOptions to nested contexts that are + * allocated during init. + * + * On return, the options dict should be freed and replaced with one that + * contains all the options which could not be processed by this filter (or + * with NULL if all the options were processed). + * + * Otherwise the semantics is the same as for @ref AVFilter.init "init". + */ + int (*init_dict)(AVFilterContext *ctx, AVDictionary **options); + + /** + * Filter uninitialization function. + * + * Called only once right before the filter is freed. Should deallocate any + * memory held by the filter, release any buffer references, etc. It does + * not need to deallocate the AVFilterContext.priv memory itself. + * + * This callback may be called even if @ref AVFilter.init "init" was not + * called or failed, so it must be prepared to handle such a situation. + */ + void (*uninit)(AVFilterContext *ctx); + + /** + * Query formats supported by the filter on its inputs and outputs. + * + * This callback is called after the filter is initialized (so the inputs + * and outputs are fixed), shortly before the format negotiation. This + * callback may be called more than once. + * + * This callback must set AVFilterLink.out_formats on every input link and + * AVFilterLink.in_formats on every output link to a list of pixel/sample + * formats that the filter supports on that link. For audio links, this + * filter must also set @ref AVFilterLink.in_samplerates "in_samplerates" / + * @ref AVFilterLink.out_samplerates "out_samplerates" and + * @ref AVFilterLink.in_channel_layouts "in_channel_layouts" / + * @ref AVFilterLink.out_channel_layouts "out_channel_layouts" analogously. + * + * This callback may be NULL for filters with one input, in which case + * libavfilter assumes that it supports all input formats and preserves + * them on output. + * + * @return zero on success, a negative value corresponding to an + * AVERROR code otherwise + */ + int (*query_formats)(AVFilterContext *); + + int priv_size; ///< size of private data to allocate for the filter + + /** + * Used by the filter registration system. Must not be touched by any other + * code. + */ + struct AVFilter *next; + + /** + * Make the filter instance process a command. + * + * @param cmd the command to process, for handling simplicity all commands must be alphanumeric only + * @param arg the argument for the command + * @param res a buffer with size res_size where the filter(s) can return a response. This must not change when the command is not supported. + * @param flags if AVFILTER_CMD_FLAG_FAST is set and the command would be + * time consuming then a filter should treat it like an unsupported command + * + * @returns >=0 on success otherwise an error code. + * AVERROR(ENOSYS) on unsupported commands + */ + int (*process_command)(AVFilterContext *, const char *cmd, const char *arg, char *res, int res_len, int flags); + + /** + * Filter initialization function, alternative to the init() + * callback. Args contains the user-supplied parameters, opaque is + * used for providing binary data. + */ + int (*init_opaque)(AVFilterContext *ctx, void *opaque); +} AVFilter; + +/** + * Process multiple parts of the frame concurrently. + */ +#define AVFILTER_THREAD_SLICE (1 << 0) + +typedef struct AVFilterInternal AVFilterInternal; + +/** An instance of a filter */ +struct AVFilterContext { + const AVClass *av_class; ///< needed for av_log() and filters common options + + const AVFilter *filter; ///< the AVFilter of which this is an instance + + char *name; ///< name of this filter instance + + AVFilterPad *input_pads; ///< array of input pads + AVFilterLink **inputs; ///< array of pointers to input links +#if FF_API_FOO_COUNT + attribute_deprecated unsigned input_count; ///< @deprecated use nb_inputs +#endif + unsigned nb_inputs; ///< number of input pads + + AVFilterPad *output_pads; ///< array of output pads + AVFilterLink **outputs; ///< array of pointers to output links +#if FF_API_FOO_COUNT + attribute_deprecated unsigned output_count; ///< @deprecated use nb_outputs +#endif + unsigned nb_outputs; ///< number of output pads + + void *priv; ///< private data for use by the filter + + struct AVFilterGraph *graph; ///< filtergraph this filter belongs to + + /** + * Type of multithreading being allowed/used. A combination of + * AVFILTER_THREAD_* flags. + * + * May be set by the caller before initializing the filter to forbid some + * or all kinds of multithreading for this filter. The default is allowing + * everything. + * + * When the filter is initialized, this field is combined using bit AND with + * AVFilterGraph.thread_type to get the final mask used for determining + * allowed threading types. I.e. a threading type needs to be set in both + * to be allowed. + * + * After the filter is initialzed, libavfilter sets this field to the + * threading type that is actually used (0 for no multithreading). + */ + int thread_type; + + /** + * An opaque struct for libavfilter internal use. + */ + AVFilterInternal *internal; + + struct AVFilterCommand *command_queue; + + char *enable_str; ///< enable expression string + void *enable; ///< parsed expression (AVExpr*) + double *var_values; ///< variable values for the enable expression + int is_disabled; ///< the enabled state from the last expression evaluation +}; + +/** + * A link between two filters. This contains pointers to the source and + * destination filters between which this link exists, and the indexes of + * the pads involved. In addition, this link also contains the parameters + * which have been negotiated and agreed upon between the filter, such as + * image dimensions, format, etc. + */ +struct AVFilterLink { + AVFilterContext *src; ///< source filter + AVFilterPad *srcpad; ///< output pad on the source filter + + AVFilterContext *dst; ///< dest filter + AVFilterPad *dstpad; ///< input pad on the dest filter + + enum AVMediaType type; ///< filter media type + + /* These parameters apply only to video */ + int w; ///< agreed upon image width + int h; ///< agreed upon image height + AVRational sample_aspect_ratio; ///< agreed upon sample aspect ratio + /* These parameters apply only to audio */ + uint64_t channel_layout; ///< channel layout of current buffer (see libavutil/channel_layout.h) + int sample_rate; ///< samples per second + + int format; ///< agreed upon media format + + /** + * Define the time base used by the PTS of the frames/samples + * which will pass through this link. + * During the configuration stage, each filter is supposed to + * change only the output timebase, while the timebase of the + * input link is assumed to be an unchangeable property. + */ + AVRational time_base; + + /***************************************************************** + * All fields below this line are not part of the public API. They + * may not be used outside of libavfilter and can be changed and + * removed at will. + * New public fields should be added right above. + ***************************************************************** + */ + /** + * Lists of formats and channel layouts supported by the input and output + * filters respectively. These lists are used for negotiating the format + * to actually be used, which will be loaded into the format and + * channel_layout members, above, when chosen. + * + */ + AVFilterFormats *in_formats; + AVFilterFormats *out_formats; + + /** + * Lists of channel layouts and sample rates used for automatic + * negotiation. + */ + AVFilterFormats *in_samplerates; + AVFilterFormats *out_samplerates; + struct AVFilterChannelLayouts *in_channel_layouts; + struct AVFilterChannelLayouts *out_channel_layouts; + + /** + * Audio only, the destination filter sets this to a non-zero value to + * request that buffers with the given number of samples should be sent to + * it. AVFilterPad.needs_fifo must also be set on the corresponding input + * pad. + * Last buffer before EOF will be padded with silence. + */ + int request_samples; + + /** stage of the initialization of the link properties (dimensions, etc) */ + enum { + AVLINK_UNINIT = 0, ///< not started + AVLINK_STARTINIT, ///< started, but incomplete + AVLINK_INIT ///< complete + } init_state; + + struct AVFilterPool *pool; + + /** + * Graph the filter belongs to. + */ + struct AVFilterGraph *graph; + + /** + * Current timestamp of the link, as defined by the most recent + * frame(s), in AV_TIME_BASE units. + */ + int64_t current_pts; + + /** + * Index in the age array. + */ + int age_index; + + /** + * Frame rate of the stream on the link, or 1/0 if unknown; + * if left to 0/0, will be automatically be copied from the first input + * of the source filter if it exists. + * + * Sources should set it to the best estimation of the real frame rate. + * Filters should update it if necessary depending on their function. + * Sinks can use it to set a default output frame rate. + * It is similar to the r_frame_rate field in AVStream. + */ + AVRational frame_rate; + + /** + * Buffer partially filled with samples to achieve a fixed/minimum size. + */ + AVFrame *partial_buf; + + /** + * Size of the partial buffer to allocate. + * Must be between min_samples and max_samples. + */ + int partial_buf_size; + + /** + * Minimum number of samples to filter at once. If filter_frame() is + * called with fewer samples, it will accumulate them in partial_buf. + * This field and the related ones must not be changed after filtering + * has started. + * If 0, all related fields are ignored. + */ + int min_samples; + + /** + * Maximum number of samples to filter at once. If filter_frame() is + * called with more samples, it will split them. + */ + int max_samples; + + /** + * The buffer reference currently being received across the link by the + * destination filter. This is used internally by the filter system to + * allow automatic copying of buffers which do not have sufficient + * permissions for the destination. This should not be accessed directly + * by the filters. + */ + AVFilterBufferRef *cur_buf_copy; + + /** + * True if the link is closed. + * If set, all attemps of start_frame, filter_frame or request_frame + * will fail with AVERROR_EOF, and if necessary the reference will be + * destroyed. + * If request_frame returns AVERROR_EOF, this flag is set on the + * corresponding link. + * It can be set also be set by either the source or the destination + * filter. + */ + int closed; + + /** + * Number of channels. + */ + int channels; + + /** + * True if a frame is being requested on the link. + * Used internally by the framework. + */ + unsigned frame_requested; + + /** + * Link processing flags. + */ + unsigned flags; + + /** + * Number of past frames sent through the link. + */ + int64_t frame_count; +}; + +/** + * Link two filters together. + * + * @param src the source filter + * @param srcpad index of the output pad on the source filter + * @param dst the destination filter + * @param dstpad index of the input pad on the destination filter + * @return zero on success + */ +int avfilter_link(AVFilterContext *src, unsigned srcpad, + AVFilterContext *dst, unsigned dstpad); + +/** + * Free the link in *link, and set its pointer to NULL. + */ +void avfilter_link_free(AVFilterLink **link); + +/** + * Get the number of channels of a link. + */ +int avfilter_link_get_channels(AVFilterLink *link); + +/** + * Set the closed field of a link. + */ +void avfilter_link_set_closed(AVFilterLink *link, int closed); + +/** + * Negotiate the media format, dimensions, etc of all inputs to a filter. + * + * @param filter the filter to negotiate the properties for its inputs + * @return zero on successful negotiation + */ +int avfilter_config_links(AVFilterContext *filter); + +#if FF_API_AVFILTERBUFFER +/** + * Create a buffer reference wrapped around an already allocated image + * buffer. + * + * @param data pointers to the planes of the image to reference + * @param linesize linesizes for the planes of the image to reference + * @param perms the required access permissions + * @param w the width of the image specified by the data and linesize arrays + * @param h the height of the image specified by the data and linesize arrays + * @param format the pixel format of the image specified by the data and linesize arrays + */ +attribute_deprecated +AVFilterBufferRef * +avfilter_get_video_buffer_ref_from_arrays(uint8_t * const data[4], const int linesize[4], int perms, + int w, int h, enum AVPixelFormat format); + +/** + * Create an audio buffer reference wrapped around an already + * allocated samples buffer. + * + * See avfilter_get_audio_buffer_ref_from_arrays_channels() for a version + * that can handle unknown channel layouts. + * + * @param data pointers to the samples plane buffers + * @param linesize linesize for the samples plane buffers + * @param perms the required access permissions + * @param nb_samples number of samples per channel + * @param sample_fmt the format of each sample in the buffer to allocate + * @param channel_layout the channel layout of the buffer + */ +attribute_deprecated +AVFilterBufferRef *avfilter_get_audio_buffer_ref_from_arrays(uint8_t **data, + int linesize, + int perms, + int nb_samples, + enum AVSampleFormat sample_fmt, + uint64_t channel_layout); +/** + * Create an audio buffer reference wrapped around an already + * allocated samples buffer. + * + * @param data pointers to the samples plane buffers + * @param linesize linesize for the samples plane buffers + * @param perms the required access permissions + * @param nb_samples number of samples per channel + * @param sample_fmt the format of each sample in the buffer to allocate + * @param channels the number of channels of the buffer + * @param channel_layout the channel layout of the buffer, + * must be either 0 or consistent with channels + */ +attribute_deprecated +AVFilterBufferRef *avfilter_get_audio_buffer_ref_from_arrays_channels(uint8_t **data, + int linesize, + int perms, + int nb_samples, + enum AVSampleFormat sample_fmt, + int channels, + uint64_t channel_layout); + +#endif + + +#define AVFILTER_CMD_FLAG_ONE 1 ///< Stop once a filter understood the command (for target=all for example), fast filters are favored automatically +#define AVFILTER_CMD_FLAG_FAST 2 ///< Only execute command when its fast (like a video out that supports contrast adjustment in hw) + +/** + * Make the filter instance process a command. + * It is recommended to use avfilter_graph_send_command(). + */ +int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags); + +/** Initialize the filter system. Register all builtin filters. */ +void avfilter_register_all(void); + +#if FF_API_OLD_FILTER_REGISTER +/** Uninitialize the filter system. Unregister all filters. */ +attribute_deprecated +void avfilter_uninit(void); +#endif + +/** + * Register a filter. This is only needed if you plan to use + * avfilter_get_by_name later to lookup the AVFilter structure by name. A + * filter can still by instantiated with avfilter_graph_alloc_filter even if it + * is not registered. + * + * @param filter the filter to register + * @return 0 if the registration was successful, a negative value + * otherwise + */ +int avfilter_register(AVFilter *filter); + +/** + * Get a filter definition matching the given name. + * + * @param name the filter name to find + * @return the filter definition, if any matching one is registered. + * NULL if none found. + */ +#if !FF_API_NOCONST_GET_NAME +const +#endif +AVFilter *avfilter_get_by_name(const char *name); + +/** + * Iterate over all registered filters. + * @return If prev is non-NULL, next registered filter after prev or NULL if + * prev is the last filter. If prev is NULL, return the first registered filter. + */ +const AVFilter *avfilter_next(const AVFilter *prev); + +#if FF_API_OLD_FILTER_REGISTER +/** + * If filter is NULL, returns a pointer to the first registered filter pointer, + * if filter is non-NULL, returns the next pointer after filter. + * If the returned pointer points to NULL, the last registered filter + * was already reached. + * @deprecated use avfilter_next() + */ +attribute_deprecated +AVFilter **av_filter_next(AVFilter **filter); +#endif + +#if FF_API_AVFILTER_OPEN +/** + * Create a filter instance. + * + * @param filter_ctx put here a pointer to the created filter context + * on success, NULL on failure + * @param filter the filter to create an instance of + * @param inst_name Name to give to the new instance. Can be NULL for none. + * @return >= 0 in case of success, a negative error code otherwise + * @deprecated use avfilter_graph_alloc_filter() instead + */ +attribute_deprecated +int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name); +#endif + + +#if FF_API_AVFILTER_INIT_FILTER +/** + * Initialize a filter. + * + * @param filter the filter to initialize + * @param args A string of parameters to use when initializing the filter. + * The format and meaning of this string varies by filter. + * @param opaque Any extra non-string data needed by the filter. The meaning + * of this parameter varies by filter. + * @return zero on success + */ +attribute_deprecated +int avfilter_init_filter(AVFilterContext *filter, const char *args, void *opaque); +#endif + +/** + * Initialize a filter with the supplied parameters. + * + * @param ctx uninitialized filter context to initialize + * @param args Options to initialize the filter with. This must be a + * ':'-separated list of options in the 'key=value' form. + * May be NULL if the options have been set directly using the + * AVOptions API or there are no options that need to be set. + * @return 0 on success, a negative AVERROR on failure + */ +int avfilter_init_str(AVFilterContext *ctx, const char *args); + +/** + * Initialize a filter with the supplied dictionary of options. + * + * @param ctx uninitialized filter context to initialize + * @param options An AVDictionary filled with options for this filter. On + * return this parameter will be destroyed and replaced with + * a dict containing options that were not found. This dictionary + * must be freed by the caller. + * May be NULL, then this function is equivalent to + * avfilter_init_str() with the second parameter set to NULL. + * @return 0 on success, a negative AVERROR on failure + * + * @note This function and avfilter_init_str() do essentially the same thing, + * the difference is in manner in which the options are passed. It is up to the + * calling code to choose whichever is more preferable. The two functions also + * behave differently when some of the provided options are not declared as + * supported by the filter. In such a case, avfilter_init_str() will fail, but + * this function will leave those extra options in the options AVDictionary and + * continue as usual. + */ +int avfilter_init_dict(AVFilterContext *ctx, AVDictionary **options); + +/** + * Free a filter context. This will also remove the filter from its + * filtergraph's list of filters. + * + * @param filter the filter to free + */ +void avfilter_free(AVFilterContext *filter); + +/** + * Insert a filter in the middle of an existing link. + * + * @param link the link into which the filter should be inserted + * @param filt the filter to be inserted + * @param filt_srcpad_idx the input pad on the filter to connect + * @param filt_dstpad_idx the output pad on the filter to connect + * @return zero on success + */ +int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt, + unsigned filt_srcpad_idx, unsigned filt_dstpad_idx); + +#if FF_API_AVFILTERBUFFER +/** + * Copy the frame properties of src to dst, without copying the actual + * image data. + * + * @return 0 on success, a negative number on error. + */ +attribute_deprecated +int avfilter_copy_frame_props(AVFilterBufferRef *dst, const AVFrame *src); + +/** + * Copy the frame properties and data pointers of src to dst, without copying + * the actual data. + * + * @return 0 on success, a negative number on error. + */ +attribute_deprecated +int avfilter_copy_buf_props(AVFrame *dst, const AVFilterBufferRef *src); +#endif + +/** + * @return AVClass for AVFilterContext. + * + * @see av_opt_find(). + */ +const AVClass *avfilter_get_class(void); + +typedef struct AVFilterGraphInternal AVFilterGraphInternal; + +/** + * A function pointer passed to the @ref AVFilterGraph.execute callback to be + * executed multiple times, possibly in parallel. + * + * @param ctx the filter context the job belongs to + * @param arg an opaque parameter passed through from @ref + * AVFilterGraph.execute + * @param jobnr the index of the job being executed + * @param nb_jobs the total number of jobs + * + * @return 0 on success, a negative AVERROR on error + */ +typedef int (avfilter_action_func)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs); + +/** + * A function executing multiple jobs, possibly in parallel. + * + * @param ctx the filter context to which the jobs belong + * @param func the function to be called multiple times + * @param arg the argument to be passed to func + * @param ret a nb_jobs-sized array to be filled with return values from each + * invocation of func + * @param nb_jobs the number of jobs to execute + * + * @return 0 on success, a negative AVERROR on error + */ +typedef int (avfilter_execute_func)(AVFilterContext *ctx, avfilter_action_func *func, + void *arg, int *ret, int nb_jobs); + +typedef struct AVFilterGraph { + const AVClass *av_class; +#if FF_API_FOO_COUNT + attribute_deprecated + unsigned filter_count_unused; +#endif + AVFilterContext **filters; +#if !FF_API_FOO_COUNT + unsigned nb_filters; +#endif + + char *scale_sws_opts; ///< sws options to use for the auto-inserted scale filters + char *resample_lavr_opts; ///< libavresample options to use for the auto-inserted resample filters +#if FF_API_FOO_COUNT + unsigned nb_filters; +#endif + + /** + * Type of multithreading allowed for filters in this graph. A combination + * of AVFILTER_THREAD_* flags. + * + * May be set by the caller at any point, the setting will apply to all + * filters initialized after that. The default is allowing everything. + * + * When a filter in this graph is initialized, this field is combined using + * bit AND with AVFilterContext.thread_type to get the final mask used for + * determining allowed threading types. I.e. a threading type needs to be + * set in both to be allowed. + */ + int thread_type; + + /** + * Maximum number of threads used by filters in this graph. May be set by + * the caller before adding any filters to the filtergraph. Zero (the + * default) means that the number of threads is determined automatically. + */ + int nb_threads; + + /** + * Opaque object for libavfilter internal use. + */ + AVFilterGraphInternal *internal; + + /** + * Opaque user data. May be set by the caller to an arbitrary value, e.g. to + * be used from callbacks like @ref AVFilterGraph.execute. + * Libavfilter will not touch this field in any way. + */ + void *opaque; + + /** + * This callback may be set by the caller immediately after allocating the + * graph and before adding any filters to it, to provide a custom + * multithreading implementation. + * + * If set, filters with slice threading capability will call this callback + * to execute multiple jobs in parallel. + * + * If this field is left unset, libavfilter will use its internal + * implementation, which may or may not be multithreaded depending on the + * platform and build options. + */ + avfilter_execute_func *execute; + + char *aresample_swr_opts; ///< swr options to use for the auto-inserted aresample filters, Access ONLY through AVOptions + + /** + * Private fields + * + * The following fields are for internal use only. + * Their type, offset, number and semantic can change without notice. + */ + + AVFilterLink **sink_links; + int sink_links_count; + + unsigned disable_auto_convert; +} AVFilterGraph; + +/** + * Allocate a filter graph. + */ +AVFilterGraph *avfilter_graph_alloc(void); + +/** + * Create a new filter instance in a filter graph. + * + * @param graph graph in which the new filter will be used + * @param filter the filter to create an instance of + * @param name Name to give to the new instance (will be copied to + * AVFilterContext.name). This may be used by the caller to identify + * different filters, libavfilter itself assigns no semantics to + * this parameter. May be NULL. + * + * @return the context of the newly created filter instance (note that it is + * also retrievable directly through AVFilterGraph.filters or with + * avfilter_graph_get_filter()) on success or NULL or failure. + */ +AVFilterContext *avfilter_graph_alloc_filter(AVFilterGraph *graph, + const AVFilter *filter, + const char *name); + +/** + * Get a filter instance with name name from graph. + * + * @return the pointer to the found filter instance or NULL if it + * cannot be found. + */ +AVFilterContext *avfilter_graph_get_filter(AVFilterGraph *graph, char *name); + +#if FF_API_AVFILTER_OPEN +/** + * Add an existing filter instance to a filter graph. + * + * @param graphctx the filter graph + * @param filter the filter to be added + * + * @deprecated use avfilter_graph_alloc_filter() to allocate a filter in a + * filter graph + */ +attribute_deprecated +int avfilter_graph_add_filter(AVFilterGraph *graphctx, AVFilterContext *filter); +#endif + +/** + * Create and add a filter instance into an existing graph. + * The filter instance is created from the filter filt and inited + * with the parameters args and opaque. + * + * In case of success put in *filt_ctx the pointer to the created + * filter instance, otherwise set *filt_ctx to NULL. + * + * @param name the instance name to give to the created filter instance + * @param graph_ctx the filter graph + * @return a negative AVERROR error code in case of failure, a non + * negative value otherwise + */ +int avfilter_graph_create_filter(AVFilterContext **filt_ctx, const AVFilter *filt, + const char *name, const char *args, void *opaque, + AVFilterGraph *graph_ctx); + +/** + * Enable or disable automatic format conversion inside the graph. + * + * Note that format conversion can still happen inside explicitly inserted + * scale and aresample filters. + * + * @param flags any of the AVFILTER_AUTO_CONVERT_* constants + */ +void avfilter_graph_set_auto_convert(AVFilterGraph *graph, unsigned flags); + +enum { + AVFILTER_AUTO_CONVERT_ALL = 0, /**< all automatic conversions enabled */ + AVFILTER_AUTO_CONVERT_NONE = -1, /**< all automatic conversions disabled */ +}; + +/** + * Check validity and configure all the links and formats in the graph. + * + * @param graphctx the filter graph + * @param log_ctx context used for logging + * @return >= 0 in case of success, a negative AVERROR code otherwise + */ +int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx); + +/** + * Free a graph, destroy its links, and set *graph to NULL. + * If *graph is NULL, do nothing. + */ +void avfilter_graph_free(AVFilterGraph **graph); + +/** + * A linked-list of the inputs/outputs of the filter chain. + * + * This is mainly useful for avfilter_graph_parse() / avfilter_graph_parse2(), + * where it is used to communicate open (unlinked) inputs and outputs from and + * to the caller. + * This struct specifies, per each not connected pad contained in the graph, the + * filter context and the pad index required for establishing a link. + */ +typedef struct AVFilterInOut { + /** unique name for this input/output in the list */ + char *name; + + /** filter context associated to this input/output */ + AVFilterContext *filter_ctx; + + /** index of the filt_ctx pad to use for linking */ + int pad_idx; + + /** next input/input in the list, NULL if this is the last */ + struct AVFilterInOut *next; +} AVFilterInOut; + +/** + * Allocate a single AVFilterInOut entry. + * Must be freed with avfilter_inout_free(). + * @return allocated AVFilterInOut on success, NULL on failure. + */ +AVFilterInOut *avfilter_inout_alloc(void); + +/** + * Free the supplied list of AVFilterInOut and set *inout to NULL. + * If *inout is NULL, do nothing. + */ +void avfilter_inout_free(AVFilterInOut **inout); + +#if AV_HAVE_INCOMPATIBLE_LIBAV_ABI || !FF_API_OLD_GRAPH_PARSE +/** + * Add a graph described by a string to a graph. + * + * @note The caller must provide the lists of inputs and outputs, + * which therefore must be known before calling the function. + * + * @note The inputs parameter describes inputs of the already existing + * part of the graph; i.e. from the point of view of the newly created + * part, they are outputs. Similarly the outputs parameter describes + * outputs of the already existing filters, which are provided as + * inputs to the parsed filters. + * + * @param graph the filter graph where to link the parsed grap context + * @param filters string to be parsed + * @param inputs linked list to the inputs of the graph + * @param outputs linked list to the outputs of the graph + * @return zero on success, a negative AVERROR code on error + */ +int avfilter_graph_parse(AVFilterGraph *graph, const char *filters, + AVFilterInOut *inputs, AVFilterInOut *outputs, + void *log_ctx); +#else +/** + * Add a graph described by a string to a graph. + * + * @param graph the filter graph where to link the parsed graph context + * @param filters string to be parsed + * @param inputs pointer to a linked list to the inputs of the graph, may be NULL. + * If non-NULL, *inputs is updated to contain the list of open inputs + * after the parsing, should be freed with avfilter_inout_free(). + * @param outputs pointer to a linked list to the outputs of the graph, may be NULL. + * If non-NULL, *outputs is updated to contain the list of open outputs + * after the parsing, should be freed with avfilter_inout_free(). + * @return non negative on success, a negative AVERROR code on error + * @deprecated Use avfilter_graph_parse_ptr() instead. + */ +attribute_deprecated +int avfilter_graph_parse(AVFilterGraph *graph, const char *filters, + AVFilterInOut **inputs, AVFilterInOut **outputs, + void *log_ctx); +#endif + +/** + * Add a graph described by a string to a graph. + * + * @param graph the filter graph where to link the parsed graph context + * @param filters string to be parsed + * @param inputs pointer to a linked list to the inputs of the graph, may be NULL. + * If non-NULL, *inputs is updated to contain the list of open inputs + * after the parsing, should be freed with avfilter_inout_free(). + * @param outputs pointer to a linked list to the outputs of the graph, may be NULL. + * If non-NULL, *outputs is updated to contain the list of open outputs + * after the parsing, should be freed with avfilter_inout_free(). + * @return non negative on success, a negative AVERROR code on error + */ +int avfilter_graph_parse_ptr(AVFilterGraph *graph, const char *filters, + AVFilterInOut **inputs, AVFilterInOut **outputs, + void *log_ctx); + +/** + * Add a graph described by a string to a graph. + * + * @param[in] graph the filter graph where to link the parsed graph context + * @param[in] filters string to be parsed + * @param[out] inputs a linked list of all free (unlinked) inputs of the + * parsed graph will be returned here. It is to be freed + * by the caller using avfilter_inout_free(). + * @param[out] outputs a linked list of all free (unlinked) outputs of the + * parsed graph will be returned here. It is to be freed by the + * caller using avfilter_inout_free(). + * @return zero on success, a negative AVERROR code on error + * + * @note This function returns the inputs and outputs that are left + * unlinked after parsing the graph and the caller then deals with + * them. + * @note This function makes no reference whatsoever to already + * existing parts of the graph and the inputs parameter will on return + * contain inputs of the newly parsed part of the graph. Analogously + * the outputs parameter will contain outputs of the newly created + * filters. + */ +int avfilter_graph_parse2(AVFilterGraph *graph, const char *filters, + AVFilterInOut **inputs, + AVFilterInOut **outputs); + +/** + * Send a command to one or more filter instances. + * + * @param graph the filter graph + * @param target the filter(s) to which the command should be sent + * "all" sends to all filters + * otherwise it can be a filter or filter instance name + * which will send the command to all matching filters. + * @param cmd the command to send, for handling simplicity all commands must be alphanumeric only + * @param arg the argument for the command + * @param res a buffer with size res_size where the filter(s) can return a response. + * + * @returns >=0 on success otherwise an error code. + * AVERROR(ENOSYS) on unsupported commands + */ +int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags); + +/** + * Queue a command for one or more filter instances. + * + * @param graph the filter graph + * @param target the filter(s) to which the command should be sent + * "all" sends to all filters + * otherwise it can be a filter or filter instance name + * which will send the command to all matching filters. + * @param cmd the command to sent, for handling simplicity all commands must be alphanummeric only + * @param arg the argument for the command + * @param ts time at which the command should be sent to the filter + * + * @note As this executes commands after this function returns, no return code + * from the filter is provided, also AVFILTER_CMD_FLAG_ONE is not supported. + */ +int avfilter_graph_queue_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, int flags, double ts); + + +/** + * Dump a graph into a human-readable string representation. + * + * @param graph the graph to dump + * @param options formatting options; currently ignored + * @return a string, or NULL in case of memory allocation failure; + * the string must be freed using av_free + */ +char *avfilter_graph_dump(AVFilterGraph *graph, const char *options); + +/** + * Request a frame on the oldest sink link. + * + * If the request returns AVERROR_EOF, try the next. + * + * Note that this function is not meant to be the sole scheduling mechanism + * of a filtergraph, only a convenience function to help drain a filtergraph + * in a balanced way under normal circumstances. + * + * Also note that AVERROR_EOF does not mean that frames did not arrive on + * some of the sinks during the process. + * When there are multiple sink links, in case the requested link + * returns an EOF, this may cause a filter to flush pending frames + * which are sent to another sink link, although unrequested. + * + * @return the return value of ff_request_frame(), + * or AVERROR_EOF if all links returned AVERROR_EOF + */ +int avfilter_graph_request_oldest(AVFilterGraph *graph); + +/** + * @} + */ + +#endif /* AVFILTER_AVFILTER_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavfilter/avfiltergraph.h b/limelight-pc/jni/nv_avc_dec/inc/libavfilter/avfiltergraph.h new file mode 100644 index 0000000..b31d581 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavfilter/avfiltergraph.h @@ -0,0 +1,28 @@ +/* + * Filter graphs + * copyright (c) 2007 Bobby Bingham + * + * 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 AVFILTER_AVFILTERGRAPH_H +#define AVFILTER_AVFILTERGRAPH_H + +#include "avfilter.h" +#include "libavutil/log.h" + +#endif /* AVFILTER_AVFILTERGRAPH_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavfilter/buffersink.h b/limelight-pc/jni/nv_avc_dec/inc/libavfilter/buffersink.h new file mode 100644 index 0000000..ce96d08 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavfilter/buffersink.h @@ -0,0 +1,186 @@ +/* + * 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 AVFILTER_BUFFERSINK_H +#define AVFILTER_BUFFERSINK_H + +/** + * @file + * memory buffer sink API for audio and video + */ + +#include "avfilter.h" + +#if FF_API_AVFILTERBUFFER +/** + * Get an audio/video buffer data from buffer_sink and put it in bufref. + * + * This function works with both audio and video buffer sinks. + * + * @param buffer_sink pointer to a buffersink or abuffersink context + * @param flags a combination of AV_BUFFERSINK_FLAG_* flags + * @return >= 0 in case of success, a negative AVERROR code in case of + * failure + */ +attribute_deprecated +int av_buffersink_get_buffer_ref(AVFilterContext *buffer_sink, + AVFilterBufferRef **bufref, int flags); + +/** + * Get the number of immediately available frames. + */ +attribute_deprecated +int av_buffersink_poll_frame(AVFilterContext *ctx); + +/** + * Get a buffer with filtered data from sink and put it in buf. + * + * @param ctx pointer to a context of a buffersink or abuffersink AVFilter. + * @param buf pointer to the buffer will be written here if buf is non-NULL. buf + * must be freed by the caller using avfilter_unref_buffer(). + * Buf may also be NULL to query whether a buffer is ready to be + * output. + * + * @return >= 0 in case of success, a negative AVERROR code in case of + * failure. + */ +attribute_deprecated +int av_buffersink_read(AVFilterContext *ctx, AVFilterBufferRef **buf); + +/** + * Same as av_buffersink_read, but with the ability to specify the number of + * samples read. This function is less efficient than av_buffersink_read(), + * because it copies the data around. + * + * @param ctx pointer to a context of the abuffersink AVFilter. + * @param buf pointer to the buffer will be written here if buf is non-NULL. buf + * must be freed by the caller using avfilter_unref_buffer(). buf + * will contain exactly nb_samples audio samples, except at the end + * of stream, when it can contain less than nb_samples. + * Buf may also be NULL to query whether a buffer is ready to be + * output. + * + * @warning do not mix this function with av_buffersink_read(). Use only one or + * the other with a single sink, not both. + */ +attribute_deprecated +int av_buffersink_read_samples(AVFilterContext *ctx, AVFilterBufferRef **buf, + int nb_samples); +#endif + +/** + * Get a frame with filtered data from sink and put it in frame. + * + * @param ctx pointer to a buffersink or abuffersink filter context. + * @param frame pointer to an allocated frame that will be filled with data. + * The data must be freed using av_frame_unref() / av_frame_free() + * @param flags a combination of AV_BUFFERSINK_FLAG_* flags + * + * @return >= 0 in for success, a negative AVERROR code for failure. + */ +int av_buffersink_get_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flags); + +/** + * Tell av_buffersink_get_buffer_ref() to read video/samples buffer + * reference, but not remove it from the buffer. This is useful if you + * need only to read a video/samples buffer, without to fetch it. + */ +#define AV_BUFFERSINK_FLAG_PEEK 1 + +/** + * Tell av_buffersink_get_buffer_ref() not to request a frame from its input. + * If a frame is already buffered, it is read (and removed from the buffer), + * but if no frame is present, return AVERROR(EAGAIN). + */ +#define AV_BUFFERSINK_FLAG_NO_REQUEST 2 + +/** + * Struct to use for initializing a buffersink context. + */ +typedef struct { + const enum AVPixelFormat *pixel_fmts; ///< list of allowed pixel formats, terminated by AV_PIX_FMT_NONE +} AVBufferSinkParams; + +/** + * Create an AVBufferSinkParams structure. + * + * Must be freed with av_free(). + */ +AVBufferSinkParams *av_buffersink_params_alloc(void); + +/** + * Struct to use for initializing an abuffersink context. + */ +typedef struct { + const enum AVSampleFormat *sample_fmts; ///< list of allowed sample formats, terminated by AV_SAMPLE_FMT_NONE + const int64_t *channel_layouts; ///< list of allowed channel layouts, terminated by -1 + const int *channel_counts; ///< list of allowed channel counts, terminated by -1 + int all_channel_counts; ///< if not 0, accept any channel count or layout + int *sample_rates; ///< list of allowed sample rates, terminated by -1 +} AVABufferSinkParams; + +/** + * Create an AVABufferSinkParams structure. + * + * Must be freed with av_free(). + */ +AVABufferSinkParams *av_abuffersink_params_alloc(void); + +/** + * Set the frame size for an audio buffer sink. + * + * All calls to av_buffersink_get_buffer_ref will return a buffer with + * exactly the specified number of samples, or AVERROR(EAGAIN) if there is + * not enough. The last buffer at EOF will be padded with 0. + */ +void av_buffersink_set_frame_size(AVFilterContext *ctx, unsigned frame_size); + +/** + * Get the frame rate of the input. + */ +AVRational av_buffersink_get_frame_rate(AVFilterContext *ctx); + +/** + * Get a frame with filtered data from sink and put it in frame. + * + * @param ctx pointer to a context of a buffersink or abuffersink AVFilter. + * @param frame pointer to an allocated frame that will be filled with data. + * The data must be freed using av_frame_unref() / av_frame_free() + * + * @return >= 0 in case of success, a negative AVERROR code in case of + * failure. + */ +int av_buffersink_get_frame(AVFilterContext *ctx, AVFrame *frame); + +/** + * Same as av_buffersink_get_frame(), but with the ability to specify the number + * of samples read. This function is less efficient than + * av_buffersink_get_frame(), because it copies the data around. + * + * @param ctx pointer to a context of the abuffersink AVFilter. + * @param frame pointer to an allocated frame that will be filled with data. + * The data must be freed using av_frame_unref() / av_frame_free() + * frame will contain exactly nb_samples audio samples, except at + * the end of stream, when it can contain less than nb_samples. + * + * @warning do not mix this function with av_buffersink_get_frame(). Use only one or + * the other with a single sink, not both. + */ +int av_buffersink_get_samples(AVFilterContext *ctx, AVFrame *frame, int nb_samples); + +#endif /* AVFILTER_BUFFERSINK_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavfilter/buffersrc.h b/limelight-pc/jni/nv_avc_dec/inc/libavfilter/buffersrc.h new file mode 100644 index 0000000..89613e1 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavfilter/buffersrc.h @@ -0,0 +1,148 @@ +/* + * + * 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 AVFILTER_BUFFERSRC_H +#define AVFILTER_BUFFERSRC_H + +/** + * @file + * Memory buffer source API. + */ + +#include "libavcodec/avcodec.h" +#include "avfilter.h" + +enum { + + /** + * Do not check for format changes. + */ + AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT = 1, + +#if FF_API_AVFILTERBUFFER + /** + * Ignored + */ + AV_BUFFERSRC_FLAG_NO_COPY = 2, +#endif + + /** + * Immediately push the frame to the output. + */ + AV_BUFFERSRC_FLAG_PUSH = 4, + + /** + * Keep a reference to the frame. + * If the frame if reference-counted, create a new reference; otherwise + * copy the frame data. + */ + AV_BUFFERSRC_FLAG_KEEP_REF = 8, + +}; + +/** + * Add buffer data in picref to buffer_src. + * + * @param buffer_src pointer to a buffer source context + * @param picref a buffer reference, or NULL to mark EOF + * @param flags a combination of AV_BUFFERSRC_FLAG_* + * @return >= 0 in case of success, a negative AVERROR code + * in case of failure + */ +int av_buffersrc_add_ref(AVFilterContext *buffer_src, + AVFilterBufferRef *picref, int flags); + +/** + * Get the number of failed requests. + * + * A failed request is when the request_frame method is called while no + * frame is present in the buffer. + * The number is reset when a frame is added. + */ +unsigned av_buffersrc_get_nb_failed_requests(AVFilterContext *buffer_src); + +#if FF_API_AVFILTERBUFFER +/** + * Add a buffer to the filtergraph s. + * + * @param buf buffer containing frame data to be passed down the filtergraph. + * This function will take ownership of buf, the user must not free it. + * A NULL buf signals EOF -- i.e. no more frames will be sent to this filter. + * + * @deprecated use av_buffersrc_write_frame() or av_buffersrc_add_frame() + */ +attribute_deprecated +int av_buffersrc_buffer(AVFilterContext *s, AVFilterBufferRef *buf); +#endif + +/** + * Add a frame to the buffer source. + * + * @param s an instance of the buffersrc filter. + * @param frame frame to be added. If the frame is reference counted, this + * function will make a new reference to it. Otherwise the frame data will be + * copied. + * + * @return 0 on success, a negative AVERROR on error + * + * This function is equivalent to av_buffersrc_add_frame_flags() with the + * AV_BUFFERSRC_FLAG_KEEP_REF flag. + */ +int av_buffersrc_write_frame(AVFilterContext *s, const AVFrame *frame); + +/** + * Add a frame to the buffer source. + * + * @param s an instance of the buffersrc filter. + * @param frame frame to be added. If the frame is reference counted, this + * function will take ownership of the reference(s) and reset the frame. + * Otherwise the frame data will be copied. If this function returns an error, + * the input frame is not touched. + * + * @return 0 on success, a negative AVERROR on error. + * + * @note the difference between this function and av_buffersrc_write_frame() is + * that av_buffersrc_write_frame() creates a new reference to the input frame, + * while this function takes ownership of the reference passed to it. + * + * This function is equivalent to av_buffersrc_add_frame_flags() without the + * AV_BUFFERSRC_FLAG_KEEP_REF flag. + */ +int av_buffersrc_add_frame(AVFilterContext *ctx, AVFrame *frame); + +/** + * Add a frame to the buffer source. + * + * By default, if the frame is reference-counted, this function will take + * ownership of the reference(s) and reset the frame. This can be controled + * using the flags. + * + * If this function returns an error, the input frame is not touched. + * + * @param buffer_src pointer to a buffer source context + * @param frame a frame, or NULL to mark EOF + * @param flags a combination of AV_BUFFERSRC_FLAG_* + * @return >= 0 in case of success, a negative AVERROR code + * in case of failure + */ +int av_buffersrc_add_frame_flags(AVFilterContext *buffer_src, + AVFrame *frame, int flags); + + +#endif /* AVFILTER_BUFFERSRC_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavfilter/version.h b/limelight-pc/jni/nv_avc_dec/inc/libavfilter/version.h new file mode 100644 index 0000000..bbc1208 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavfilter/version.h @@ -0,0 +1,92 @@ +/* + * Version macros. + * + * 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 AVFILTER_VERSION_H +#define AVFILTER_VERSION_H + +/** + * @file + * @ingroup lavfi + * Libavfilter version macros + */ + +#include "libavutil/avutil.h" + +#define LIBAVFILTER_VERSION_MAJOR 3 +#define LIBAVFILTER_VERSION_MINOR 91 +#define LIBAVFILTER_VERSION_MICRO 100 + +#define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \ + LIBAVFILTER_VERSION_MINOR, \ + LIBAVFILTER_VERSION_MICRO) +#define LIBAVFILTER_VERSION AV_VERSION(LIBAVFILTER_VERSION_MAJOR, \ + LIBAVFILTER_VERSION_MINOR, \ + LIBAVFILTER_VERSION_MICRO) +#define LIBAVFILTER_BUILD LIBAVFILTER_VERSION_INT + +#define LIBAVFILTER_IDENT "Lavfi" AV_STRINGIFY(LIBAVFILTER_VERSION) + +/** + * FF_API_* defines may be placed below to indicate public API that will be + * dropped at a future version bump. The defines themselves are not part of + * the public API and may change, break or disappear at any time. + */ + +#ifndef FF_API_AVFILTERPAD_PUBLIC +#define FF_API_AVFILTERPAD_PUBLIC (LIBAVFILTER_VERSION_MAJOR < 4) +#endif +#ifndef FF_API_FOO_COUNT +#define FF_API_FOO_COUNT (LIBAVFILTER_VERSION_MAJOR < 4) +#endif +#ifndef FF_API_FILL_FRAME +#define FF_API_FILL_FRAME (LIBAVFILTER_VERSION_MAJOR < 4) +#endif +#ifndef FF_API_BUFFERSRC_BUFFER +#define FF_API_BUFFERSRC_BUFFER (LIBAVFILTER_VERSION_MAJOR < 4) +#endif +#ifndef FF_API_AVFILTERBUFFER +#define FF_API_AVFILTERBUFFER (LIBAVFILTER_VERSION_MAJOR < 4) +#endif +#ifndef FF_API_OLD_FILTER_OPTS +#define FF_API_OLD_FILTER_OPTS (LIBAVFILTER_VERSION_MAJOR < 4) +#endif +#ifndef FF_API_ACONVERT_FILTER +#define FF_API_ACONVERT_FILTER (LIBAVFILTER_VERSION_MAJOR < 4) +#endif +#ifndef FF_API_AVFILTER_OPEN +#define FF_API_AVFILTER_OPEN (LIBAVFILTER_VERSION_MAJOR < 4) +#endif +#ifndef FF_API_AVFILTER_INIT_FILTER +#define FF_API_AVFILTER_INIT_FILTER (LIBAVFILTER_VERSION_MAJOR < 4) +#endif +#ifndef FF_API_OLD_FILTER_REGISTER +#define FF_API_OLD_FILTER_REGISTER (LIBAVFILTER_VERSION_MAJOR < 4) +#endif +#ifndef FF_API_OLD_GRAPH_PARSE +#define FF_API_OLD_GRAPH_PARSE (LIBAVFILTER_VERSION_MAJOR < 4) +#endif +#ifndef FF_API_DRAWTEXT_OLD_TIMELINE +#define FF_API_DRAWTEXT_OLD_TIMELINE (LIBAVFILTER_VERSION_MAJOR < 4) +#endif +#ifndef FF_API_NOCONST_GET_NAME +#define FF_API_NOCONST_GET_NAME (LIBAVFILTER_VERSION_MAJOR < 4) +#endif + +#endif /* AVFILTER_VERSION_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavformat/avformat.h b/limelight-pc/jni/nv_avc_dec/inc/libavformat/avformat.h new file mode 100644 index 0000000..6bd54ce --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavformat/avformat.h @@ -0,0 +1,2243 @@ +/* + * copyright (c) 2001 Fabrice Bellard + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVFORMAT_AVFORMAT_H +#define AVFORMAT_AVFORMAT_H + +/** + * @file + * @ingroup libavf + * Main libavformat public API header + */ + +/** + * @defgroup libavf I/O and Muxing/Demuxing Library + * @{ + * + * Libavformat (lavf) is a library for dealing with various media container + * formats. Its main two purposes are demuxing - i.e. splitting a media file + * into component streams, and the reverse process of muxing - writing supplied + * data in a specified container format. It also has an @ref lavf_io + * "I/O module" which supports a number of protocols for accessing the data (e.g. + * file, tcp, http and others). Before using lavf, you need to call + * av_register_all() to register all compiled muxers, demuxers and protocols. + * Unless you are absolutely sure you won't use libavformat's network + * capabilities, you should also call avformat_network_init(). + * + * A supported input format is described by an AVInputFormat struct, conversely + * an output format is described by AVOutputFormat. You can iterate over all + * registered input/output formats using the av_iformat_next() / + * av_oformat_next() functions. The protocols layer is not part of the public + * API, so you can only get the names of supported protocols with the + * avio_enum_protocols() function. + * + * Main lavf structure used for both muxing and demuxing is AVFormatContext, + * which exports all information about the file being read or written. As with + * most Libavformat structures, its size is not part of public ABI, so it cannot be + * allocated on stack or directly with av_malloc(). To create an + * AVFormatContext, use avformat_alloc_context() (some functions, like + * avformat_open_input() might do that for you). + * + * Most importantly an AVFormatContext contains: + * @li the @ref AVFormatContext.iformat "input" or @ref AVFormatContext.oformat + * "output" format. It is either autodetected or set by user for input; + * always set by user for output. + * @li an @ref AVFormatContext.streams "array" of AVStreams, which describe all + * elementary streams stored in the file. AVStreams are typically referred to + * using their index in this array. + * @li an @ref AVFormatContext.pb "I/O context". It is either opened by lavf or + * set by user for input, always set by user for output (unless you are dealing + * with an AVFMT_NOFILE format). + * + * @section lavf_options Passing options to (de)muxers + * Lavf allows to configure muxers and demuxers using the @ref avoptions + * mechanism. Generic (format-independent) libavformat options are provided by + * AVFormatContext, they can be examined from a user program by calling + * av_opt_next() / av_opt_find() on an allocated AVFormatContext (or its AVClass + * from avformat_get_class()). Private (format-specific) options are provided by + * AVFormatContext.priv_data if and only if AVInputFormat.priv_class / + * AVOutputFormat.priv_class of the corresponding format struct is non-NULL. + * Further options may be provided by the @ref AVFormatContext.pb "I/O context", + * if its AVClass is non-NULL, and the protocols layer. See the discussion on + * nesting in @ref avoptions documentation to learn how to access those. + * + * @defgroup lavf_decoding Demuxing + * @{ + * Demuxers read a media file and split it into chunks of data (@em packets). A + * @ref AVPacket "packet" contains one or more encoded frames which belongs to a + * single elementary stream. In the lavf API this process is represented by the + * avformat_open_input() function for opening a file, av_read_frame() for + * reading a single packet and finally avformat_close_input(), which does the + * cleanup. + * + * @section lavf_decoding_open Opening a media file + * The minimum information required to open a file is its URL or filename, which + * is passed to avformat_open_input(), as in the following code: + * @code + * const char *url = "in.mp3"; + * AVFormatContext *s = NULL; + * int ret = avformat_open_input(&s, url, NULL, NULL); + * if (ret < 0) + * abort(); + * @endcode + * The above code attempts to allocate an AVFormatContext, open the + * specified file (autodetecting the format) and read the header, exporting the + * information stored there into s. Some formats do not have a header or do not + * store enough information there, so it is recommended that you call the + * avformat_find_stream_info() function which tries to read and decode a few + * frames to find missing information. + * + * In some cases you might want to preallocate an AVFormatContext yourself with + * avformat_alloc_context() and do some tweaking on it before passing it to + * avformat_open_input(). One such case is when you want to use custom functions + * for reading input data instead of lavf internal I/O layer. + * To do that, create your own AVIOContext with avio_alloc_context(), passing + * your reading callbacks to it. Then set the @em pb field of your + * AVFormatContext to newly created AVIOContext. + * + * Since the format of the opened file is in general not known until after + * avformat_open_input() has returned, it is not possible to set demuxer private + * options on a preallocated context. Instead, the options should be passed to + * avformat_open_input() wrapped in an AVDictionary: + * @code + * AVDictionary *options = NULL; + * av_dict_set(&options, "video_size", "640x480", 0); + * av_dict_set(&options, "pixel_format", "rgb24", 0); + * + * if (avformat_open_input(&s, url, NULL, &options) < 0) + * abort(); + * av_dict_free(&options); + * @endcode + * This code passes the private options 'video_size' and 'pixel_format' to the + * demuxer. They would be necessary for e.g. the rawvideo demuxer, since it + * cannot know how to interpret raw video data otherwise. If the format turns + * out to be something different than raw video, those options will not be + * recognized by the demuxer and therefore will not be applied. Such unrecognized + * options are then returned in the options dictionary (recognized options are + * consumed). The calling program can handle such unrecognized options as it + * wishes, e.g. + * @code + * AVDictionaryEntry *e; + * if (e = av_dict_get(options, "", NULL, AV_DICT_IGNORE_SUFFIX)) { + * fprintf(stderr, "Option %s not recognized by the demuxer.\n", e->key); + * abort(); + * } + * @endcode + * + * After you have finished reading the file, you must close it with + * avformat_close_input(). It will free everything associated with the file. + * + * @section lavf_decoding_read Reading from an opened file + * Reading data from an opened AVFormatContext is done by repeatedly calling + * av_read_frame() on it. Each call, if successful, will return an AVPacket + * containing encoded data for one AVStream, identified by + * AVPacket.stream_index. This packet may be passed straight into the libavcodec + * decoding functions avcodec_decode_video2(), avcodec_decode_audio4() or + * avcodec_decode_subtitle2() if the caller wishes to decode the data. + * + * AVPacket.pts, AVPacket.dts and AVPacket.duration timing information will be + * set if known. They may also be unset (i.e. AV_NOPTS_VALUE for + * pts/dts, 0 for duration) if the stream does not provide them. The timing + * information will be in AVStream.time_base units, i.e. it has to be + * multiplied by the timebase to convert them to seconds. + * + * If AVPacket.buf is set on the returned packet, then the packet is + * allocated dynamically and the user may keep it indefinitely. + * Otherwise, if AVPacket.buf is NULL, the packet data is backed by a + * static storage somewhere inside the demuxer and the packet is only valid + * until the next av_read_frame() call or closing the file. If the caller + * requires a longer lifetime, av_dup_packet() will make an av_malloc()ed copy + * of it. + * In both cases, the packet must be freed with av_free_packet() when it is no + * longer needed. + * + * @section lavf_decoding_seek Seeking + * @} + * + * @defgroup lavf_encoding Muxing + * @{ + * @} + * + * @defgroup lavf_io I/O Read/Write + * @{ + * @} + * + * @defgroup lavf_codec Demuxers + * @{ + * @defgroup lavf_codec_native Native Demuxers + * @{ + * @} + * @defgroup lavf_codec_wrappers External library wrappers + * @{ + * @} + * @} + * @defgroup lavf_protos I/O Protocols + * @{ + * @} + * @defgroup lavf_internal Internal + * @{ + * @} + * @} + * + */ + +#include +#include /* FILE */ +#include "libavcodec/avcodec.h" +#include "libavutil/dict.h" +#include "libavutil/log.h" + +#include "avio.h" +#include "libavformat/version.h" + +struct AVFormatContext; + + +/** + * @defgroup metadata_api Public Metadata API + * @{ + * @ingroup libavf + * The metadata API allows libavformat to export metadata tags to a client + * application when demuxing. Conversely it allows a client application to + * set metadata when muxing. + * + * Metadata is exported or set as pairs of key/value strings in the 'metadata' + * fields of the AVFormatContext, AVStream, AVChapter and AVProgram structs + * using the @ref lavu_dict "AVDictionary" API. Like all strings in FFmpeg, + * metadata is assumed to be UTF-8 encoded Unicode. Note that metadata + * exported by demuxers isn't checked to be valid UTF-8 in most cases. + * + * Important concepts to keep in mind: + * - Keys are unique; there can never be 2 tags with the same key. This is + * also meant semantically, i.e., a demuxer should not knowingly produce + * several keys that are literally different but semantically identical. + * E.g., key=Author5, key=Author6. In this example, all authors must be + * placed in the same tag. + * - Metadata is flat, not hierarchical; there are no subtags. If you + * want to store, e.g., the email address of the child of producer Alice + * and actor Bob, that could have key=alice_and_bobs_childs_email_address. + * - Several modifiers can be applied to the tag name. This is done by + * appending a dash character ('-') and the modifier name in the order + * they appear in the list below -- e.g. foo-eng-sort, not foo-sort-eng. + * - language -- a tag whose value is localized for a particular language + * is appended with the ISO 639-2/B 3-letter language code. + * For example: Author-ger=Michael, Author-eng=Mike + * The original/default language is in the unqualified "Author" tag. + * A demuxer should set a default if it sets any translated tag. + * - sorting -- a modified version of a tag that should be used for + * sorting will have '-sort' appended. E.g. artist="The Beatles", + * artist-sort="Beatles, The". + * + * - Demuxers attempt to export metadata in a generic format, however tags + * with no generic equivalents are left as they are stored in the container. + * Follows a list of generic tag names: + * + @verbatim + album -- name of the set this work belongs to + album_artist -- main creator of the set/album, if different from artist. + e.g. "Various Artists" for compilation albums. + artist -- main creator of the work + comment -- any additional description of the file. + composer -- who composed the work, if different from artist. + copyright -- name of copyright holder. + creation_time-- date when the file was created, preferably in ISO 8601. + date -- date when the work was created, preferably in ISO 8601. + disc -- number of a subset, e.g. disc in a multi-disc collection. + encoder -- name/settings of the software/hardware that produced the file. + encoded_by -- person/group who created the file. + filename -- original name of the file. + genre -- . + language -- main language in which the work is performed, preferably + in ISO 639-2 format. Multiple languages can be specified by + separating them with commas. + performer -- artist who performed the work, if different from artist. + E.g for "Also sprach Zarathustra", artist would be "Richard + Strauss" and performer "London Philharmonic Orchestra". + publisher -- name of the label/publisher. + service_name -- name of the service in broadcasting (channel name). + service_provider -- name of the service provider in broadcasting. + title -- name of the work. + track -- number of this work in the set, can be in form current/total. + variant_bitrate -- the total bitrate of the bitrate variant that the current stream is part of + @endverbatim + * + * Look in the examples section for an application example how to use the Metadata API. + * + * @} + */ + +/* packet functions */ + + +/** + * Allocate and read the payload of a packet and initialize its + * fields with default values. + * + * @param pkt packet + * @param size desired payload size + * @return >0 (read size) if OK, AVERROR_xxx otherwise + */ +int av_get_packet(AVIOContext *s, AVPacket *pkt, int size); + + +/** + * Read data and append it to the current content of the AVPacket. + * If pkt->size is 0 this is identical to av_get_packet. + * Note that this uses av_grow_packet and thus involves a realloc + * which is inefficient. Thus this function should only be used + * when there is no reasonable way to know (an upper bound of) + * the final size. + * + * @param pkt packet + * @param size amount of data to read + * @return >0 (read size) if OK, AVERROR_xxx otherwise, previous data + * will not be lost even if an error occurs. + */ +int av_append_packet(AVIOContext *s, AVPacket *pkt, int size); + +/*************************************************/ +/* fractional numbers for exact pts handling */ + +/** + * The exact value of the fractional number is: 'val + num / den'. + * num is assumed to be 0 <= num < den. + */ +typedef struct AVFrac { + int64_t val, num, den; +} AVFrac; + +/*************************************************/ +/* input/output formats */ + +struct AVCodecTag; + +/** + * This structure contains the data a format has to probe a file. + */ +typedef struct AVProbeData { + const char *filename; + unsigned char *buf; /**< Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero. */ + int buf_size; /**< Size of buf except extra allocated bytes */ +} AVProbeData; + +#define AVPROBE_SCORE_RETRY (AVPROBE_SCORE_MAX/4) +#define AVPROBE_SCORE_EXTENSION 50 ///< score for file extension +#define AVPROBE_SCORE_MAX 100 ///< maximum score + +#define AVPROBE_PADDING_SIZE 32 ///< extra allocated bytes at the end of the probe buffer + +/// Demuxer will use avio_open, no opened file should be provided by the caller. +#define AVFMT_NOFILE 0x0001 +#define AVFMT_NEEDNUMBER 0x0002 /**< Needs '%d' in filename. */ +#define AVFMT_SHOW_IDS 0x0008 /**< Show format stream IDs numbers. */ +#define AVFMT_RAWPICTURE 0x0020 /**< Format wants AVPicture structure for + raw picture data. */ +#define AVFMT_GLOBALHEADER 0x0040 /**< Format wants global header. */ +#define AVFMT_NOTIMESTAMPS 0x0080 /**< Format does not need / have any timestamps. */ +#define AVFMT_GENERIC_INDEX 0x0100 /**< Use generic index building code. */ +#define AVFMT_TS_DISCONT 0x0200 /**< Format allows timestamp discontinuities. Note, muxers always require valid (monotone) timestamps */ +#define AVFMT_VARIABLE_FPS 0x0400 /**< Format allows variable fps. */ +#define AVFMT_NODIMENSIONS 0x0800 /**< Format does not need width/height */ +#define AVFMT_NOSTREAMS 0x1000 /**< Format does not require any streams */ +#define AVFMT_NOBINSEARCH 0x2000 /**< Format does not allow to fall back on binary search via read_timestamp */ +#define AVFMT_NOGENSEARCH 0x4000 /**< Format does not allow to fall back on generic search */ +#define AVFMT_NO_BYTE_SEEK 0x8000 /**< Format does not allow seeking by bytes */ +#define AVFMT_ALLOW_FLUSH 0x10000 /**< Format allows flushing. If not set, the muxer will not receive a NULL packet in the write_packet function. */ +#if LIBAVFORMAT_VERSION_MAJOR <= 54 +#define AVFMT_TS_NONSTRICT 0x8020000 //we try to be compatible to the ABIs of ffmpeg and major forks +#else +#define AVFMT_TS_NONSTRICT 0x20000 +#endif + /**< Format does not require strictly + increasing timestamps, but they must + still be monotonic */ +#define AVFMT_TS_NEGATIVE 0x40000 /**< Format allows muxing negative + timestamps. If not set the timestamp + will be shifted in av_write_frame and + av_interleaved_write_frame so they + start from 0. + The user or muxer can override this through + AVFormatContext.avoid_negative_ts + */ + +#define AVFMT_SEEK_TO_PTS 0x4000000 /**< Seeking is based on PTS */ + +/** + * @addtogroup lavf_encoding + * @{ + */ +typedef struct AVOutputFormat { + const char *name; + /** + * Descriptive name for the format, meant to be more human-readable + * than name. You should use the NULL_IF_CONFIG_SMALL() macro + * to define it. + */ + const char *long_name; + const char *mime_type; + const char *extensions; /**< comma-separated filename extensions */ + /* output support */ + enum AVCodecID audio_codec; /**< default audio codec */ + enum AVCodecID video_codec; /**< default video codec */ + enum AVCodecID subtitle_codec; /**< default subtitle codec */ + /** + * can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_RAWPICTURE, + * AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS, AVFMT_VARIABLE_FPS, + * AVFMT_NODIMENSIONS, AVFMT_NOSTREAMS, AVFMT_ALLOW_FLUSH, + * AVFMT_TS_NONSTRICT + */ + int flags; + + /** + * List of supported codec_id-codec_tag pairs, ordered by "better + * choice first". The arrays are all terminated by AV_CODEC_ID_NONE. + */ + const struct AVCodecTag * const *codec_tag; + + + const AVClass *priv_class; ///< AVClass for the private context + + /***************************************************************** + * No fields below this line are part of the public API. They + * may not be used outside of libavformat and can be changed and + * removed at will. + * New public fields should be added right above. + ***************************************************************** + */ + struct AVOutputFormat *next; + /** + * size of private data so that it can be allocated in the wrapper + */ + int priv_data_size; + + int (*write_header)(struct AVFormatContext *); + /** + * Write a packet. If AVFMT_ALLOW_FLUSH is set in flags, + * pkt can be NULL in order to flush data buffered in the muxer. + * When flushing, return 0 if there still is more data to flush, + * or 1 if everything was flushed and there is no more buffered + * data. + */ + int (*write_packet)(struct AVFormatContext *, AVPacket *pkt); + int (*write_trailer)(struct AVFormatContext *); + /** + * Currently only used to set pixel format if not YUV420P. + */ + int (*interleave_packet)(struct AVFormatContext *, AVPacket *out, + AVPacket *in, int flush); + /** + * Test if the given codec can be stored in this container. + * + * @return 1 if the codec is supported, 0 if it is not. + * A negative number if unknown. + * MKTAG('A', 'P', 'I', 'C') if the codec is only supported as AV_DISPOSITION_ATTACHED_PIC + */ + int (*query_codec)(enum AVCodecID id, int std_compliance); + + void (*get_output_timestamp)(struct AVFormatContext *s, int stream, + int64_t *dts, int64_t *wall); +} AVOutputFormat; +/** + * @} + */ + +/** + * @addtogroup lavf_decoding + * @{ + */ +typedef struct AVInputFormat { + /** + * A comma separated list of short names for the format. New names + * may be appended with a minor bump. + */ + const char *name; + + /** + * Descriptive name for the format, meant to be more human-readable + * than name. You should use the NULL_IF_CONFIG_SMALL() macro + * to define it. + */ + const char *long_name; + + /** + * Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, + * AVFMT_GENERIC_INDEX, AVFMT_TS_DISCONT, AVFMT_NOBINSEARCH, + * AVFMT_NOGENSEARCH, AVFMT_NO_BYTE_SEEK, AVFMT_SEEK_TO_PTS. + */ + int flags; + + /** + * If extensions are defined, then no probe is done. You should + * usually not use extension format guessing because it is not + * reliable enough + */ + const char *extensions; + + const struct AVCodecTag * const *codec_tag; + + const AVClass *priv_class; ///< AVClass for the private context + + /***************************************************************** + * No fields below this line are part of the public API. They + * may not be used outside of libavformat and can be changed and + * removed at will. + * New public fields should be added right above. + ***************************************************************** + */ + struct AVInputFormat *next; + + /** + * Raw demuxers store their codec ID here. + */ + int raw_codec_id; + + /** + * Size of private data so that it can be allocated in the wrapper. + */ + int priv_data_size; + + /** + * Tell if a given file has a chance of being parsed as this format. + * The buffer provided is guaranteed to be AVPROBE_PADDING_SIZE bytes + * big so you do not have to check for that unless you need more. + */ + int (*read_probe)(AVProbeData *); + + /** + * Read the format header and initialize the AVFormatContext + * structure. Return 0 if OK. Only used in raw format right + * now. 'avformat_new_stream' should be called to create new streams. + */ + int (*read_header)(struct AVFormatContext *); + + /** + * Read one packet and put it in 'pkt'. pts and flags are also + * set. 'avformat_new_stream' can be called only if the flag + * AVFMTCTX_NOHEADER is used and only in the calling thread (not in a + * background thread). + * @return 0 on success, < 0 on error. + * When returning an error, pkt must not have been allocated + * or must be freed before returning + */ + int (*read_packet)(struct AVFormatContext *, AVPacket *pkt); + + /** + * Close the stream. The AVFormatContext and AVStreams are not + * freed by this function + */ + int (*read_close)(struct AVFormatContext *); + + /** + * Seek to a given timestamp relative to the frames in + * stream component stream_index. + * @param stream_index Must not be -1. + * @param flags Selects which direction should be preferred if no exact + * match is available. + * @return >= 0 on success (but not necessarily the new offset) + */ + int (*read_seek)(struct AVFormatContext *, + int stream_index, int64_t timestamp, int flags); + + /** + * Get the next timestamp in stream[stream_index].time_base units. + * @return the timestamp or AV_NOPTS_VALUE if an error occurred + */ + int64_t (*read_timestamp)(struct AVFormatContext *s, int stream_index, + int64_t *pos, int64_t pos_limit); + + /** + * Start/resume playing - only meaningful if using a network-based format + * (RTSP). + */ + int (*read_play)(struct AVFormatContext *); + + /** + * Pause playing - only meaningful if using a network-based format + * (RTSP). + */ + int (*read_pause)(struct AVFormatContext *); + + /** + * Seek to timestamp ts. + * Seeking will be done so that the point from which all active streams + * can be presented successfully will be closest to ts and within min/max_ts. + * Active streams are all streams that have AVStream.discard < AVDISCARD_ALL. + */ + int (*read_seek2)(struct AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags); +} AVInputFormat; +/** + * @} + */ + +enum AVStreamParseType { + AVSTREAM_PARSE_NONE, + AVSTREAM_PARSE_FULL, /**< full parsing and repack */ + AVSTREAM_PARSE_HEADERS, /**< Only parse headers, do not repack. */ + AVSTREAM_PARSE_TIMESTAMPS, /**< full parsing and interpolation of timestamps for frames not starting on a packet boundary */ + AVSTREAM_PARSE_FULL_ONCE, /**< full parsing and repack of the first frame only, only implemented for H.264 currently */ + AVSTREAM_PARSE_FULL_RAW=MKTAG(0,'R','A','W'), /**< full parsing and repack with timestamp and position generation by parser for raw + this assumes that each packet in the file contains no demuxer level headers and + just codec level data, otherwise position generation would fail */ +}; + +typedef struct AVIndexEntry { + int64_t pos; + int64_t timestamp; /**< + * Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are available + * when seeking to this entry. That means preferable PTS on keyframe based formats. + * But demuxers can choose to store a different timestamp, if it is more convenient for the implementation or nothing better + * is known + */ +#define AVINDEX_KEYFRAME 0x0001 + int flags:2; + int size:30; //Yeah, trying to keep the size of this small to reduce memory requirements (it is 24 vs. 32 bytes due to possible 8-byte alignment). + int min_distance; /**< Minimum distance between this and the previous keyframe, used to avoid unneeded searching. */ +} AVIndexEntry; + +#define AV_DISPOSITION_DEFAULT 0x0001 +#define AV_DISPOSITION_DUB 0x0002 +#define AV_DISPOSITION_ORIGINAL 0x0004 +#define AV_DISPOSITION_COMMENT 0x0008 +#define AV_DISPOSITION_LYRICS 0x0010 +#define AV_DISPOSITION_KARAOKE 0x0020 + +/** + * Track should be used during playback by default. + * Useful for subtitle track that should be displayed + * even when user did not explicitly ask for subtitles. + */ +#define AV_DISPOSITION_FORCED 0x0040 +#define AV_DISPOSITION_HEARING_IMPAIRED 0x0080 /**< stream for hearing impaired audiences */ +#define AV_DISPOSITION_VISUAL_IMPAIRED 0x0100 /**< stream for visual impaired audiences */ +#define AV_DISPOSITION_CLEAN_EFFECTS 0x0200 /**< stream without voice */ +/** + * The stream is stored in the file as an attached picture/"cover art" (e.g. + * APIC frame in ID3v2). The single packet associated with it will be returned + * among the first few packets read from the file unless seeking takes place. + * It can also be accessed at any time in AVStream.attached_pic. + */ +#define AV_DISPOSITION_ATTACHED_PIC 0x0400 + +/** + * To specify text track kind (different from subtitles default). + */ +#define AV_DISPOSITION_CAPTIONS 0x10000 +#define AV_DISPOSITION_DESCRIPTIONS 0x20000 +#define AV_DISPOSITION_METADATA 0x40000 + +/** + * Options for behavior on timestamp wrap detection. + */ +#define AV_PTS_WRAP_IGNORE 0 ///< ignore the wrap +#define AV_PTS_WRAP_ADD_OFFSET 1 ///< add the format specific offset on wrap detection +#define AV_PTS_WRAP_SUB_OFFSET -1 ///< subtract the format specific offset on wrap detection + +/** + * Stream 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. + * sizeof(AVStream) must not be used outside libav*. + */ +typedef struct AVStream { + int index; /**< stream index in AVFormatContext */ + /** + * Format-specific stream ID. + * decoding: set by libavformat + * encoding: set by the user, replaced by libavformat if left unset + */ + int id; + /** + * Codec context associated with this stream. Allocated and freed by + * libavformat. + * + * - decoding: The demuxer exports codec information stored in the headers + * here. + * - encoding: The user sets codec information, the muxer writes it to the + * output. Mandatory fields as specified in AVCodecContext + * documentation must be set even if this AVCodecContext is + * not actually used for encoding. + */ + AVCodecContext *codec; + void *priv_data; + + /** + * encoding: pts generation when outputting stream + */ + struct AVFrac pts; + + /** + * This is the fundamental unit of time (in seconds) in terms + * of which frame timestamps are represented. + * + * decoding: set by libavformat + * encoding: set by libavformat in avformat_write_header. The muxer may use the + * user-provided value of @ref AVCodecContext.time_base "codec->time_base" + * as a hint. + */ + AVRational time_base; + + /** + * Decoding: pts of the first frame of the stream in presentation order, in stream time base. + * Only set this if you are absolutely 100% sure that the value you set + * it to really is the pts of the first frame. + * This may be undefined (AV_NOPTS_VALUE). + * @note The ASF header does NOT contain a correct start_time the ASF + * demuxer must NOT set this. + */ + int64_t start_time; + + /** + * Decoding: duration of the stream, in stream time base. + * If a source file does not specify a duration, but does specify + * a bitrate, this value will be estimated from bitrate and file size. + */ + int64_t duration; + + int64_t nb_frames; ///< number of frames in this stream if known or 0 + + int disposition; /**< AV_DISPOSITION_* bit field */ + + enum AVDiscard discard; ///< Selects which packets can be discarded at will and do not need to be demuxed. + + /** + * sample aspect ratio (0 if unknown) + * - encoding: Set by user. + * - decoding: Set by libavformat. + */ + AVRational sample_aspect_ratio; + + AVDictionary *metadata; + + /** + * Average framerate + */ + AVRational avg_frame_rate; + + /** + * For streams with AV_DISPOSITION_ATTACHED_PIC disposition, this packet + * will contain the attached picture. + * + * decoding: set by libavformat, must not be modified by the caller. + * encoding: unused + */ + AVPacket attached_pic; + + /***************************************************************** + * All fields below this line are not part of the public API. They + * may not be used outside of libavformat and can be changed and + * removed at will. + * New public fields should be added right above. + ***************************************************************** + */ + + /** + * Stream information used internally by av_find_stream_info() + */ +#define MAX_STD_TIMEBASES (60*12+6) + struct { + int64_t last_dts; + int64_t duration_gcd; + int duration_count; + double (*duration_error)[2][MAX_STD_TIMEBASES]; + int64_t codec_info_duration; + int64_t codec_info_duration_fields; + int found_decoder; + + int64_t last_duration; + + /** + * Those are used for average framerate estimation. + */ + int64_t fps_first_dts; + int fps_first_dts_idx; + int64_t fps_last_dts; + int fps_last_dts_idx; + + } *info; + + int pts_wrap_bits; /**< number of bits in pts (used for wrapping control) */ + +#if FF_API_REFERENCE_DTS + /* a hack to keep ABI compatibility for ffmpeg and other applications, which accesses parser even + * though it should not */ + int64_t do_not_use; +#endif + // Timestamp generation support: + /** + * Timestamp corresponding to the last dts sync point. + * + * Initialized when AVCodecParserContext.dts_sync_point >= 0 and + * a DTS is received from the underlying container. Otherwise set to + * AV_NOPTS_VALUE by default. + */ + int64_t first_dts; + int64_t cur_dts; + int64_t last_IP_pts; + int last_IP_duration; + + /** + * Number of packets to buffer for codec probing + */ +#define MAX_PROBE_PACKETS 2500 + int probe_packets; + + /** + * Number of frames that have been demuxed during av_find_stream_info() + */ + int codec_info_nb_frames; + + /* av_read_frame() support */ + enum AVStreamParseType need_parsing; + struct AVCodecParserContext *parser; + + /** + * last packet in packet_buffer for this stream when muxing. + */ + struct AVPacketList *last_in_packet_buffer; + AVProbeData probe_data; +#define MAX_REORDER_DELAY 16 + int64_t pts_buffer[MAX_REORDER_DELAY+1]; + + AVIndexEntry *index_entries; /**< Only used if the format does not + support seeking natively. */ + int nb_index_entries; + unsigned int index_entries_allocated_size; + + /** + * Real base framerate of the stream. + * This is the lowest framerate with which all timestamps can be + * represented accurately (it is the least common multiple of all + * framerates in the stream). Note, this value is just a guess! + * For example, if the time base is 1/90000 and all frames have either + * approximately 3600 or 1800 timer ticks, then r_frame_rate will be 50/1. + * + * Code outside avformat should access this field using: + * av_stream_get/set_r_frame_rate(stream) + */ + AVRational r_frame_rate; + + /** + * Stream Identifier + * This is the MPEG-TS stream identifier +1 + * 0 means unknown + */ + int stream_identifier; + + int64_t interleaver_chunk_size; + int64_t interleaver_chunk_duration; + + /** + * stream probing state + * -1 -> probing finished + * 0 -> no probing requested + * rest -> perform probing with request_probe being the minimum score to accept. + * NOT PART OF PUBLIC API + */ + int request_probe; + /** + * Indicates that everything up to the next keyframe + * should be discarded. + */ + int skip_to_keyframe; + + /** + * Number of samples to skip at the start of the frame decoded from the next packet. + */ + int skip_samples; + + /** + * Number of internally decoded frames, used internally in libavformat, do not access + * its lifetime differs from info which is why it is not in that structure. + */ + int nb_decoded_frames; + + /** + * Timestamp offset added to timestamps before muxing + * NOT PART OF PUBLIC API + */ + int64_t mux_ts_offset; + + /** + * Internal data to check for wrapping of the time stamp + */ + int64_t pts_wrap_reference; + + /** + * Options for behavior, when a wrap is detected. + * + * Defined by AV_PTS_WRAP_ values. + * + * If correction is enabled, there are two possibilities: + * If the first time stamp is near the wrap point, the wrap offset + * will be subtracted, which will create negative time stamps. + * Otherwise the offset will be added. + */ + int pts_wrap_behavior; + +} AVStream; + +AVRational av_stream_get_r_frame_rate(const AVStream *s); +void av_stream_set_r_frame_rate(AVStream *s, AVRational r); + +#define AV_PROGRAM_RUNNING 1 + +/** + * New fields can be added to the end with minor version bumps. + * Removal, reordering and changes to existing fields require a major + * version bump. + * sizeof(AVProgram) must not be used outside libav*. + */ +typedef struct AVProgram { + int id; + int flags; + enum AVDiscard discard; ///< selects which program to discard and which to feed to the caller + unsigned int *stream_index; + unsigned int nb_stream_indexes; + AVDictionary *metadata; + + int program_num; + int pmt_pid; + int pcr_pid; + + /***************************************************************** + * All fields below this line are not part of the public API. They + * may not be used outside of libavformat and can be changed and + * removed at will. + * New public fields should be added right above. + ***************************************************************** + */ + int64_t start_time; + int64_t end_time; + + int64_t pts_wrap_reference; ///< reference dts for wrap detection + int pts_wrap_behavior; ///< behavior on wrap detection +} AVProgram; + +#define AVFMTCTX_NOHEADER 0x0001 /**< signal that no header is present + (streams are added dynamically) */ + +typedef struct AVChapter { + int id; ///< unique ID to identify the chapter + AVRational time_base; ///< time base in which the start/end timestamps are specified + int64_t start, end; ///< chapter start/end time in time_base units + AVDictionary *metadata; +} AVChapter; + + +/** + * The duration of a video can be estimated through various ways, and this enum can be used + * to know how the duration was estimated. + */ +enum AVDurationEstimationMethod { + AVFMT_DURATION_FROM_PTS, ///< Duration accurately estimated from PTSes + AVFMT_DURATION_FROM_STREAM, ///< Duration estimated from a stream with a known duration + AVFMT_DURATION_FROM_BITRATE ///< Duration estimated from bitrate (less accurate) +}; + +/** + * Format I/O context. + * New fields can be added to the end with minor version bumps. + * Removal, reordering and changes to existing fields require a major + * version bump. + * sizeof(AVFormatContext) must not be used outside libav*, use + * avformat_alloc_context() to create an AVFormatContext. + */ +typedef struct AVFormatContext { + /** + * A class for logging and AVOptions. Set by avformat_alloc_context(). + * Exports (de)muxer private options if they exist. + */ + const AVClass *av_class; + + /** + * Can only be iformat or oformat, not both at the same time. + * + * decoding: set by avformat_open_input(). + * encoding: set by the user. + */ + struct AVInputFormat *iformat; + struct AVOutputFormat *oformat; + + /** + * Format private data. This is an AVOptions-enabled struct + * if and only if iformat/oformat.priv_class is not NULL. + */ + void *priv_data; + + /** + * I/O context. + * + * decoding: either set by the user before avformat_open_input() (then + * the user must close it manually) or set by avformat_open_input(). + * encoding: set by the user. + * + * Do NOT set this field if AVFMT_NOFILE flag is set in + * iformat/oformat.flags. In such a case, the (de)muxer will handle + * I/O in some other way and this field will be NULL. + */ + AVIOContext *pb; + + /* stream info */ + int ctx_flags; /**< Format-specific flags, see AVFMTCTX_xx */ + + /** + * A list of all streams in the file. New streams are created with + * avformat_new_stream(). + * + * decoding: streams are created by libavformat in avformat_open_input(). + * If AVFMTCTX_NOHEADER is set in ctx_flags, then new streams may also + * appear in av_read_frame(). + * encoding: streams are created by the user before avformat_write_header(). + */ + unsigned int nb_streams; + AVStream **streams; + + char filename[1024]; /**< input or output filename */ + + /** + * Decoding: position of the first frame of the component, in + * AV_TIME_BASE fractional seconds. NEVER set this value directly: + * It is deduced from the AVStream values. + */ + int64_t start_time; + + /** + * Decoding: duration of the stream, in AV_TIME_BASE fractional + * seconds. Only set this value if you know none of the individual stream + * durations and also do not set any of them. This is deduced from the + * AVStream values if not set. + */ + int64_t duration; + + /** + * Decoding: total stream bitrate in bit/s, 0 if not + * available. Never set it directly if the file_size and the + * duration are known as FFmpeg can compute it automatically. + */ + int bit_rate; + + unsigned int packet_size; + int max_delay; + + int flags; +#define AVFMT_FLAG_GENPTS 0x0001 ///< Generate missing pts even if it requires parsing future frames. +#define AVFMT_FLAG_IGNIDX 0x0002 ///< Ignore index. +#define AVFMT_FLAG_NONBLOCK 0x0004 ///< Do not block when reading packets from input. +#define AVFMT_FLAG_IGNDTS 0x0008 ///< Ignore DTS on frames that contain both DTS & PTS +#define AVFMT_FLAG_NOFILLIN 0x0010 ///< Do not infer any values from other values, just return what is stored in the container +#define AVFMT_FLAG_NOPARSE 0x0020 ///< Do not use AVParsers, you also must set AVFMT_FLAG_NOFILLIN as the fillin code works on frames and no parsing -> no frames. Also seeking to frames can not work if parsing to find frame boundaries has been disabled +#define AVFMT_FLAG_NOBUFFER 0x0040 ///< Do not buffer frames when possible +#define AVFMT_FLAG_CUSTOM_IO 0x0080 ///< The caller has supplied a custom AVIOContext, don't avio_close() it. +#define AVFMT_FLAG_DISCARD_CORRUPT 0x0100 ///< Discard frames marked corrupted +#define AVFMT_FLAG_FLUSH_PACKETS 0x0200 ///< Flush the AVIOContext every packet. +#define AVFMT_FLAG_MP4A_LATM 0x8000 ///< Enable RTP MP4A-LATM payload +#define AVFMT_FLAG_SORT_DTS 0x10000 ///< try to interleave outputted packets by dts (using this flag can slow demuxing down) +#define AVFMT_FLAG_PRIV_OPT 0x20000 ///< Enable use of private options by delaying codec open (this could be made default once all code is converted) +#define AVFMT_FLAG_KEEP_SIDE_DATA 0x40000 ///< Don't merge side data but keep it separate. + + /** + * decoding: size of data to probe; encoding: unused. + */ + unsigned int probesize; + + /** + * decoding: maximum time (in AV_TIME_BASE units) during which the input should + * be analyzed in avformat_find_stream_info(). + */ + int max_analyze_duration; + + const uint8_t *key; + int keylen; + + unsigned int nb_programs; + AVProgram **programs; + + /** + * Forced video codec_id. + * Demuxing: Set by user. + */ + enum AVCodecID video_codec_id; + + /** + * Forced audio codec_id. + * Demuxing: Set by user. + */ + enum AVCodecID audio_codec_id; + + /** + * Forced subtitle codec_id. + * Demuxing: Set by user. + */ + enum AVCodecID subtitle_codec_id; + + /** + * Maximum amount of memory in bytes to use for the index of each stream. + * If the index exceeds this size, entries will be discarded as + * needed to maintain a smaller size. This can lead to slower or less + * accurate seeking (depends on demuxer). + * Demuxers for which a full in-memory index is mandatory will ignore + * this. + * muxing : unused + * demuxing: set by user + */ + unsigned int max_index_size; + + /** + * Maximum amount of memory in bytes to use for buffering frames + * obtained from realtime capture devices. + */ + unsigned int max_picture_buffer; + + /** + * Number of chapters in AVChapter array. + * When muxing, chapters are normally written in the file header, + * so nb_chapters should normally be initialized before write_header + * is called. Some muxers (e.g. mov and mkv) can also write chapters + * in the trailer. To write chapters in the trailer, nb_chapters + * must be zero when write_header is called and non-zero when + * write_trailer is called. + * muxing : set by user + * demuxing: set by libavformat + */ + unsigned int nb_chapters; + AVChapter **chapters; + + AVDictionary *metadata; + + /** + * Start time of the stream in real world time, in microseconds + * since the unix epoch (00:00 1st January 1970). That is, pts=0 + * in the stream was captured at this real world time. + * - encoding: Set by user. + * - decoding: Unused. + */ + int64_t start_time_realtime; + + /** + * decoding: number of frames used to probe fps + */ + int fps_probe_size; + + /** + * Error recognition; higher values will detect more errors but may + * misdetect some more or less valid parts as errors. + * - encoding: unused + * - decoding: Set by user. + */ + int error_recognition; + + /** + * Custom interrupt callbacks for the I/O layer. + * + * decoding: set by the user before avformat_open_input(). + * encoding: set by the user before avformat_write_header() + * (mainly useful for AVFMT_NOFILE formats). The callback + * should also be passed to avio_open2() if it's used to + * open the file. + */ + AVIOInterruptCB interrupt_callback; + + /** + * Flags to enable debugging. + */ + int debug; +#define FF_FDEBUG_TS 0x0001 + + /** + * Transport stream id. + * This will be moved into demuxer private options. Thus no API/ABI compatibility + */ + int ts_id; + + /** + * Audio preload in microseconds. + * Note, not all formats support this and unpredictable things may happen if it is used when not supported. + * - encoding: Set by user via AVOptions (NO direct access) + * - decoding: unused + */ + int audio_preload; + + /** + * Max chunk time in microseconds. + * Note, not all formats support this and unpredictable things may happen if it is used when not supported. + * - encoding: Set by user via AVOptions (NO direct access) + * - decoding: unused + */ + int max_chunk_duration; + + /** + * Max chunk size in bytes + * Note, not all formats support this and unpredictable things may happen if it is used when not supported. + * - encoding: Set by user via AVOptions (NO direct access) + * - decoding: unused + */ + int max_chunk_size; + + /** + * forces the use of wallclock timestamps as pts/dts of packets + * This has undefined results in the presence of B frames. + * - encoding: unused + * - decoding: Set by user via AVOptions (NO direct access) + */ + int use_wallclock_as_timestamps; + + /** + * Avoid negative timestamps during muxing. + * 0 -> allow negative timestamps + * 1 -> avoid negative timestamps + * -1 -> choose automatically (default) + * Note, this only works when interleave_packet_per_dts is in use. + * - encoding: Set by user via AVOptions (NO direct access) + * - decoding: unused + */ + int avoid_negative_ts; + + /** + * avio flags, used to force AVIO_FLAG_DIRECT. + * - encoding: unused + * - decoding: Set by user via AVOptions (NO direct access) + */ + int avio_flags; + + /** + * The duration field can be estimated through various ways, and this field can be used + * to know how the duration was estimated. + * - encoding: unused + * - decoding: Read by user via AVOptions (NO direct access) + */ + enum AVDurationEstimationMethod duration_estimation_method; + + /** + * Skip initial bytes when opening stream + * - encoding: unused + * - decoding: Set by user via AVOptions (NO direct access) + */ + unsigned int skip_initial_bytes; + + /** + * Correct single timestamp overflows + * - encoding: unused + * - decoding: Set by user via AVOPtions (NO direct access) + */ + unsigned int correct_ts_overflow; + + /** + * Force seeking to any (also non key) frames. + * - encoding: unused + * - decoding: Set by user via AVOPtions (NO direct access) + */ + int seek2any; + + /** + * Flush the I/O context after each packet. + * - encoding: Set by user via AVOptions (NO direct access) + * - decoding: unused + */ + int flush_packets; + + /** + * format probing score. + * The maximal score is AVPROBE_SCORE_MAX, its set when the demuxer probes + * the format. + * - encoding: unused + * - decoding: set by avformat, read by user via av_format_get_probe_score() (NO direct access) + */ + int probe_score; + + /***************************************************************** + * All fields below this line are not part of the public API. They + * may not be used outside of libavformat and can be changed and + * removed at will. + * New public fields should be added right above. + ***************************************************************** + */ + + /** + * This buffer is only needed when packets were already buffered but + * not decoded, for example to get the codec parameters in MPEG + * streams. + */ + struct AVPacketList *packet_buffer; + struct AVPacketList *packet_buffer_end; + + /* av_seek_frame() support */ + int64_t data_offset; /**< offset of the first packet */ + + /** + * Raw packets from the demuxer, prior to parsing and decoding. + * This buffer is used for buffering packets until the codec can + * be identified, as parsing cannot be done without knowing the + * codec. + */ + struct AVPacketList *raw_packet_buffer; + struct AVPacketList *raw_packet_buffer_end; + /** + * Packets split by the parser get queued here. + */ + struct AVPacketList *parse_queue; + struct AVPacketList *parse_queue_end; + /** + * Remaining size available for raw_packet_buffer, in bytes. + */ +#define RAW_PACKET_BUFFER_SIZE 2500000 + int raw_packet_buffer_remaining_size; + + /** + * Offset to remap timestamps to be non-negative. + * Expressed in timebase units. + * @see AVStream.mux_ts_offset + */ + int64_t offset; + + /** + * Timebase for the timestamp offset. + */ + AVRational offset_timebase; + + /** + * IO repositioned flag. + * This is set by avformat when the underlaying IO context read pointer + * is repositioned, for example when doing byte based seeking. + * Demuxers can use the flag to detect such changes. + */ + int io_repositioned; + + /** + * Forced video codec. + * This allows forcing a specific decoder, even when there are multiple with + * the same codec_id. + * Demuxing: Set by user via av_format_set_video_codec (NO direct access). + */ + AVCodec *video_codec; + + /** + * Forced audio codec. + * This allows forcing a specific decoder, even when there are multiple with + * the same codec_id. + * Demuxing: Set by user via av_format_set_audio_codec (NO direct access). + */ + AVCodec *audio_codec; + + /** + * Forced subtitle codec. + * This allows forcing a specific decoder, even when there are multiple with + * the same codec_id. + * Demuxing: Set by user via av_format_set_subtitle_codec (NO direct access). + */ + AVCodec *subtitle_codec; +} AVFormatContext; + +int av_format_get_probe_score(const AVFormatContext *s); +AVCodec * av_format_get_video_codec(const AVFormatContext *s); +void av_format_set_video_codec(AVFormatContext *s, AVCodec *c); +AVCodec * av_format_get_audio_codec(const AVFormatContext *s); +void av_format_set_audio_codec(AVFormatContext *s, AVCodec *c); +AVCodec * av_format_get_subtitle_codec(const AVFormatContext *s); +void av_format_set_subtitle_codec(AVFormatContext *s, AVCodec *c); + +/** + * Returns the method used to set ctx->duration. + * + * @return AVFMT_DURATION_FROM_PTS, AVFMT_DURATION_FROM_STREAM, or AVFMT_DURATION_FROM_BITRATE. + */ +enum AVDurationEstimationMethod av_fmt_ctx_get_duration_estimation_method(const AVFormatContext* ctx); + +typedef struct AVPacketList { + AVPacket pkt; + struct AVPacketList *next; +} AVPacketList; + + +/** + * @defgroup lavf_core Core functions + * @ingroup libavf + * + * Functions for querying libavformat capabilities, allocating core structures, + * etc. + * @{ + */ + +/** + * Return the LIBAVFORMAT_VERSION_INT constant. + */ +unsigned avformat_version(void); + +/** + * Return the libavformat build-time configuration. + */ +const char *avformat_configuration(void); + +/** + * Return the libavformat license. + */ +const char *avformat_license(void); + +/** + * Initialize libavformat and register all the muxers, demuxers and + * protocols. If you do not call this function, then you can select + * exactly which formats you want to support. + * + * @see av_register_input_format() + * @see av_register_output_format() + */ +void av_register_all(void); + +void av_register_input_format(AVInputFormat *format); +void av_register_output_format(AVOutputFormat *format); + +/** + * Do global initialization of network components. This is optional, + * but recommended, since it avoids the overhead of implicitly + * doing the setup for each session. + * + * Calling this function will become mandatory if using network + * protocols at some major version bump. + */ +int avformat_network_init(void); + +/** + * Undo the initialization done by avformat_network_init. + */ +int avformat_network_deinit(void); + +/** + * If f is NULL, returns the first registered input format, + * if f is non-NULL, returns the next registered input format after f + * or NULL if f is the last one. + */ +AVInputFormat *av_iformat_next(AVInputFormat *f); + +/** + * If f is NULL, returns the first registered output format, + * if f is non-NULL, returns the next registered output format after f + * or NULL if f is the last one. + */ +AVOutputFormat *av_oformat_next(AVOutputFormat *f); + +/** + * Allocate an AVFormatContext. + * avformat_free_context() can be used to free the context and everything + * allocated by the framework within it. + */ +AVFormatContext *avformat_alloc_context(void); + +/** + * Free an AVFormatContext and all its streams. + * @param s context to free + */ +void avformat_free_context(AVFormatContext *s); + +/** + * Get the AVClass for AVFormatContext. It can be used in combination with + * AV_OPT_SEARCH_FAKE_OBJ for examining options. + * + * @see av_opt_find(). + */ +const AVClass *avformat_get_class(void); + +/** + * Add a new stream to a media file. + * + * When demuxing, it is called by the demuxer in read_header(). If the + * flag AVFMTCTX_NOHEADER is set in s.ctx_flags, then it may also + * be called in read_packet(). + * + * When muxing, should be called by the user before avformat_write_header(). + * + * User is required to call avcodec_close() and avformat_free_context() to + * clean up the allocation by avformat_new_stream(). + * + * @param c If non-NULL, the AVCodecContext corresponding to the new stream + * will be initialized to use this codec. This is needed for e.g. codec-specific + * defaults to be set, so codec should be provided if it is known. + * + * @return newly created stream or NULL on error. + */ +AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c); + +AVProgram *av_new_program(AVFormatContext *s, int id); + +/** + * @} + */ + + +#if FF_API_ALLOC_OUTPUT_CONTEXT +/** + * @deprecated deprecated in favor of avformat_alloc_output_context2() + */ +attribute_deprecated +AVFormatContext *avformat_alloc_output_context(const char *format, + AVOutputFormat *oformat, + const char *filename); +#endif + +/** + * Allocate an AVFormatContext for an output format. + * avformat_free_context() can be used to free the context and + * everything allocated by the framework within it. + * + * @param *ctx is set to the created format context, or to NULL in + * case of failure + * @param oformat format to use for allocating the context, if NULL + * format_name and filename are used instead + * @param format_name the name of output format to use for allocating the + * context, if NULL filename is used instead + * @param filename the name of the filename to use for allocating the + * context, may be NULL + * @return >= 0 in case of success, a negative AVERROR code in case of + * failure + */ +int avformat_alloc_output_context2(AVFormatContext **ctx, AVOutputFormat *oformat, + const char *format_name, const char *filename); + +/** + * @addtogroup lavf_decoding + * @{ + */ + +/** + * Find AVInputFormat based on the short name of the input format. + */ +AVInputFormat *av_find_input_format(const char *short_name); + +/** + * Guess the file format. + * + * @param is_opened Whether the file is already opened; determines whether + * demuxers with or without AVFMT_NOFILE are probed. + */ +AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened); + +/** + * Guess the file format. + * + * @param is_opened Whether the file is already opened; determines whether + * demuxers with or without AVFMT_NOFILE are probed. + * @param score_max A probe score larger that this is required to accept a + * detection, the variable is set to the actual detection + * score afterwards. + * If the score is <= AVPROBE_SCORE_MAX / 4 it is recommended + * to retry with a larger probe buffer. + */ +AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max); + +/** + * Guess the file format. + * + * @param is_opened Whether the file is already opened; determines whether + * demuxers with or without AVFMT_NOFILE are probed. + * @param score_ret The score of the best detection. + */ +AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret); + +/** + * Probe a bytestream to determine the input format. Each time a probe returns + * with a score that is too low, the probe buffer size is increased and another + * attempt is made. When the maximum probe size is reached, the input format + * with the highest score is returned. + * + * @param pb the bytestream to probe + * @param fmt the input format is put here + * @param filename the filename of the stream + * @param logctx the log context + * @param offset the offset within the bytestream to probe from + * @param max_probe_size the maximum probe buffer size (zero for default) + * @return the score in case of success, a negative value corresponding to an + * the maximal score is AVPROBE_SCORE_MAX + * AVERROR code otherwise + */ +int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt, + const char *filename, void *logctx, + unsigned int offset, unsigned int max_probe_size); + +/** + * Like av_probe_input_buffer2() but returns 0 on success + */ +int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt, + const char *filename, void *logctx, + unsigned int offset, unsigned int max_probe_size); + +/** + * Open an input stream and read the header. The codecs are not opened. + * The stream must be closed with avformat_close_input(). + * + * @param ps Pointer to user-supplied AVFormatContext (allocated by avformat_alloc_context). + * May be a pointer to NULL, in which case an AVFormatContext is allocated by this + * function and written into ps. + * Note that a user-supplied AVFormatContext will be freed on failure. + * @param filename Name of the stream to open. + * @param fmt If non-NULL, this parameter forces a specific input format. + * Otherwise the format is autodetected. + * @param options A dictionary filled with AVFormatContext and demuxer-private options. + * On return this parameter will be destroyed and replaced with a dict containing + * options that were not found. May be NULL. + * + * @return 0 on success, a negative AVERROR on failure. + * + * @note If you want to use custom IO, preallocate the format context and set its pb field. + */ +int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options); + +attribute_deprecated +int av_demuxer_open(AVFormatContext *ic); + +#if FF_API_FORMAT_PARAMETERS +/** + * Read packets of a media file to get stream information. This + * is useful for file formats with no headers such as MPEG. This + * function also computes the real framerate in case of MPEG-2 repeat + * frame mode. + * The logical file position is not changed by this function; + * examined packets may be buffered for later processing. + * + * @param ic media file handle + * @return >=0 if OK, AVERROR_xxx on error + * @todo Let the user decide somehow what information is needed so that + * we do not waste time getting stuff the user does not need. + * + * @deprecated use avformat_find_stream_info. + */ +attribute_deprecated +int av_find_stream_info(AVFormatContext *ic); +#endif + +/** + * Read packets of a media file to get stream information. This + * is useful for file formats with no headers such as MPEG. This + * function also computes the real framerate in case of MPEG-2 repeat + * frame mode. + * The logical file position is not changed by this function; + * examined packets may be buffered for later processing. + * + * @param ic media file handle + * @param options If non-NULL, an ic.nb_streams long array of pointers to + * dictionaries, where i-th member contains options for + * codec corresponding to i-th stream. + * On return each dictionary will be filled with options that were not found. + * @return >=0 if OK, AVERROR_xxx on error + * + * @note this function isn't guaranteed to open all the codecs, so + * options being non-empty at return is a perfectly normal behavior. + * + * @todo Let the user decide somehow what information is needed so that + * we do not waste time getting stuff the user does not need. + */ +int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options); + +/** + * Find the programs which belong to a given stream. + * + * @param ic media file handle + * @param last the last found program, the search will start after this + * program, or from the beginning if it is NULL + * @param s stream index + * @return the next program which belongs to s, NULL if no program is found or + * the last program is not among the programs of ic. + */ +AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s); + +/** + * Find the "best" stream in the file. + * The best stream is determined according to various heuristics as the most + * likely to be what the user expects. + * If the decoder parameter is non-NULL, av_find_best_stream will find the + * default decoder for the stream's codec; streams for which no decoder can + * be found are ignored. + * + * @param ic media file handle + * @param type stream type: video, audio, subtitles, etc. + * @param wanted_stream_nb user-requested stream number, + * or -1 for automatic selection + * @param related_stream try to find a stream related (eg. in the same + * program) to this one, or -1 if none + * @param decoder_ret if non-NULL, returns the decoder for the + * selected stream + * @param flags flags; none are currently defined + * @return the non-negative stream number in case of success, + * AVERROR_STREAM_NOT_FOUND if no stream with the requested type + * could be found, + * AVERROR_DECODER_NOT_FOUND if streams were found but no decoder + * @note If av_find_best_stream returns successfully and decoder_ret is not + * NULL, then *decoder_ret is guaranteed to be set to a valid AVCodec. + */ +int av_find_best_stream(AVFormatContext *ic, + enum AVMediaType type, + int wanted_stream_nb, + int related_stream, + AVCodec **decoder_ret, + int flags); + +#if FF_API_READ_PACKET +/** + * @deprecated use AVFMT_FLAG_NOFILLIN | AVFMT_FLAG_NOPARSE to read raw + * unprocessed packets + * + * Read a transport packet from a media file. + * + * This function is obsolete and should never be used. + * Use av_read_frame() instead. + * + * @param s media file handle + * @param pkt is filled + * @return 0 if OK, AVERROR_xxx on error + */ +attribute_deprecated +int av_read_packet(AVFormatContext *s, AVPacket *pkt); +#endif + +/** + * Return the next frame of a stream. + * This function returns what is stored in the file, and does not validate + * that what is there are valid frames for the decoder. It will split what is + * stored in the file into frames and return one for each call. It will not + * omit invalid data between valid frames so as to give the decoder the maximum + * information possible for decoding. + * + * If pkt->buf is NULL, then the packet is valid until the next + * av_read_frame() or until avformat_close_input(). Otherwise the packet + * is valid indefinitely. In both cases the packet must be freed with + * av_free_packet when it is no longer needed. For video, the packet contains + * exactly one frame. For audio, it contains an integer number of frames if each + * frame has a known fixed size (e.g. PCM or ADPCM data). If the audio frames + * have a variable size (e.g. MPEG audio), then it contains one frame. + * + * pkt->pts, pkt->dts and pkt->duration are always set to correct + * values in AVStream.time_base units (and guessed if the format cannot + * provide them). pkt->pts can be AV_NOPTS_VALUE if the video format + * has B-frames, so it is better to rely on pkt->dts if you do not + * decompress the payload. + * + * @return 0 if OK, < 0 on error or end of file + */ +int av_read_frame(AVFormatContext *s, AVPacket *pkt); + +/** + * Seek to the keyframe at timestamp. + * 'timestamp' in 'stream_index'. + * @param stream_index If stream_index is (-1), a default + * stream is selected, and timestamp is automatically converted + * from AV_TIME_BASE units to the stream specific time_base. + * @param timestamp Timestamp in AVStream.time_base units + * or, if no stream is specified, in AV_TIME_BASE units. + * @param flags flags which select direction and seeking mode + * @return >= 0 on success + */ +int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, + int flags); + +/** + * Seek to timestamp ts. + * Seeking will be done so that the point from which all active streams + * can be presented successfully will be closest to ts and within min/max_ts. + * Active streams are all streams that have AVStream.discard < AVDISCARD_ALL. + * + * If flags contain AVSEEK_FLAG_BYTE, then all timestamps are in bytes and + * are the file position (this may not be supported by all demuxers). + * If flags contain AVSEEK_FLAG_FRAME, then all timestamps are in frames + * in the stream with stream_index (this may not be supported by all demuxers). + * Otherwise all timestamps are in units of the stream selected by stream_index + * or if stream_index is -1, in AV_TIME_BASE units. + * If flags contain AVSEEK_FLAG_ANY, then non-keyframes are treated as + * keyframes (this may not be supported by all demuxers). + * If flags contain AVSEEK_FLAG_BACKWARD, it is ignored. + * + * @param stream_index index of the stream which is used as time base reference + * @param min_ts smallest acceptable timestamp + * @param ts target timestamp + * @param max_ts largest acceptable timestamp + * @param flags flags + * @return >=0 on success, error code otherwise + * + * @note This is part of the new seek API which is still under construction. + * Thus do not use this yet. It may change at any time, do not expect + * ABI compatibility yet! + */ +int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags); + +/** + * Start playing a network-based stream (e.g. RTSP stream) at the + * current position. + */ +int av_read_play(AVFormatContext *s); + +/** + * Pause a network-based stream (e.g. RTSP stream). + * + * Use av_read_play() to resume it. + */ +int av_read_pause(AVFormatContext *s); + +#if FF_API_CLOSE_INPUT_FILE +/** + * @deprecated use avformat_close_input() + * Close a media file (but not its codecs). + * + * @param s media file handle + */ +attribute_deprecated +void av_close_input_file(AVFormatContext *s); +#endif + +/** + * Close an opened input AVFormatContext. Free it and all its contents + * and set *s to NULL. + */ +void avformat_close_input(AVFormatContext **s); +/** + * @} + */ + +#if FF_API_NEW_STREAM +/** + * Add a new stream to a media file. + * + * Can only be called in the read_header() function. If the flag + * AVFMTCTX_NOHEADER is in the format context, then new streams + * can be added in read_packet too. + * + * @param s media file handle + * @param id file-format-dependent stream ID + */ +attribute_deprecated +AVStream *av_new_stream(AVFormatContext *s, int id); +#endif + +#if FF_API_SET_PTS_INFO +/** + * @deprecated this function is not supposed to be called outside of lavf + */ +attribute_deprecated +void av_set_pts_info(AVStream *s, int pts_wrap_bits, + unsigned int pts_num, unsigned int pts_den); +#endif + +#define AVSEEK_FLAG_BACKWARD 1 ///< seek backward +#define AVSEEK_FLAG_BYTE 2 ///< seeking based on position in bytes +#define AVSEEK_FLAG_ANY 4 ///< seek to any frame, even non-keyframes +#define AVSEEK_FLAG_FRAME 8 ///< seeking based on frame number + +/** + * @addtogroup lavf_encoding + * @{ + */ +/** + * Allocate the stream private data and write the stream header to + * an output media file. + * + * @param s Media file handle, must be allocated with avformat_alloc_context(). + * Its oformat field must be set to the desired output format; + * Its pb field must be set to an already opened AVIOContext. + * @param options An AVDictionary filled with AVFormatContext and muxer-private options. + * On return this parameter will be destroyed and replaced with a dict containing + * options that were not found. May be NULL. + * + * @return 0 on success, negative AVERROR on failure. + * + * @see av_opt_find, av_dict_set, avio_open, av_oformat_next. + */ +int avformat_write_header(AVFormatContext *s, AVDictionary **options); + +/** + * Write a packet to an output media file. + * + * The packet shall contain one audio or video frame. + * The packet must be correctly interleaved according to the container + * specification, if not then av_interleaved_write_frame must be used. + * + * @param s media file handle + * @param pkt The packet, which contains the stream_index, buf/buf_size, + * dts/pts, ... + * This can be NULL (at any time, not just at the end), in + * order to immediately flush data buffered within the muxer, + * for muxers that buffer up data internally before writing it + * to the output. + * @return < 0 on error, = 0 if OK, 1 if flushed and there is no more data to flush + */ +int av_write_frame(AVFormatContext *s, AVPacket *pkt); + +/** + * Write a packet to an output media file ensuring correct interleaving. + * + * The packet must contain one audio or video frame. + * If the packets are already correctly interleaved, the application should + * call av_write_frame() instead as it is slightly faster. It is also important + * to keep in mind that completely non-interleaved input will need huge amounts + * of memory to interleave with this, so it is preferable to interleave at the + * demuxer level. + * + * @param s media file handle + * @param pkt The packet containing the data to be written. pkt->buf must be set + * to a valid AVBufferRef describing the packet data. Libavformat takes + * ownership of this reference and will unref it when it sees fit. The caller + * must not access the data through this reference after this function returns. + * This can be NULL (at any time, not just at the end), to flush the + * interleaving queues. + * Packet's @ref AVPacket.stream_index "stream_index" field must be set to the + * index of the corresponding stream in @ref AVFormatContext.streams + * "s.streams". + * It is very strongly recommended that timing information (@ref AVPacket.pts + * "pts", @ref AVPacket.dts "dts" @ref AVPacket.duration "duration") is set to + * correct values. + * + * @return 0 on success, a negative AVERROR on error. + */ +int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt); + +/** + * Write the stream trailer to an output media file and free the + * file private data. + * + * May only be called after a successful call to avformat_write_header. + * + * @param s media file handle + * @return 0 if OK, AVERROR_xxx on error + */ +int av_write_trailer(AVFormatContext *s); + +/** + * Return the output format in the list of registered output formats + * which best matches the provided parameters, or return NULL if + * there is no match. + * + * @param short_name if non-NULL checks if short_name matches with the + * names of the registered formats + * @param filename if non-NULL checks if filename terminates with the + * extensions of the registered formats + * @param mime_type if non-NULL checks if mime_type matches with the + * MIME type of the registered formats + */ +AVOutputFormat *av_guess_format(const char *short_name, + const char *filename, + const char *mime_type); + +/** + * Guess the codec ID based upon muxer and filename. + */ +enum AVCodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name, + const char *filename, const char *mime_type, + enum AVMediaType type); + +/** + * Get timing information for the data currently output. + * The exact meaning of "currently output" depends on the format. + * It is mostly relevant for devices that have an internal buffer and/or + * work in real time. + * @param s media file handle + * @param stream stream in the media file + * @param[out] dts DTS of the last packet output for the stream, in stream + * time_base units + * @param[out] wall absolute time when that packet whas output, + * in microsecond + * @return 0 if OK, AVERROR(ENOSYS) if the format does not support it + * Note: some formats or devices may not allow to measure dts and wall + * atomically. + */ +int av_get_output_timestamp(struct AVFormatContext *s, int stream, + int64_t *dts, int64_t *wall); + + +/** + * @} + */ + + +/** + * @defgroup lavf_misc Utility functions + * @ingroup libavf + * @{ + * + * Miscellaneous utility functions related to both muxing and demuxing + * (or neither). + */ + +/** + * Send a nice hexadecimal dump of a buffer to the specified file stream. + * + * @param f The file stream pointer where the dump should be sent to. + * @param buf buffer + * @param size buffer size + * + * @see av_hex_dump_log, av_pkt_dump2, av_pkt_dump_log2 + */ +void av_hex_dump(FILE *f, const uint8_t *buf, int size); + +/** + * Send a nice hexadecimal dump of a buffer to the log. + * + * @param avcl A pointer to an arbitrary struct of which the first field is a + * pointer to an AVClass struct. + * @param level The importance level of the message, lower values signifying + * higher importance. + * @param buf buffer + * @param size buffer size + * + * @see av_hex_dump, av_pkt_dump2, av_pkt_dump_log2 + */ +void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size); + +/** + * Send a nice dump of a packet to the specified file stream. + * + * @param f The file stream pointer where the dump should be sent to. + * @param pkt packet to dump + * @param dump_payload True if the payload must be displayed, too. + * @param st AVStream that the packet belongs to + */ +void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st); + + +/** + * Send a nice dump of a packet to the log. + * + * @param avcl A pointer to an arbitrary struct of which the first field is a + * pointer to an AVClass struct. + * @param level The importance level of the message, lower values signifying + * higher importance. + * @param pkt packet to dump + * @param dump_payload True if the payload must be displayed, too. + * @param st AVStream that the packet belongs to + */ +void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload, + AVStream *st); + +/** + * Get the AVCodecID for the given codec tag tag. + * If no codec id is found returns AV_CODEC_ID_NONE. + * + * @param tags list of supported codec_id-codec_tag pairs, as stored + * in AVInputFormat.codec_tag and AVOutputFormat.codec_tag + */ +enum AVCodecID av_codec_get_id(const struct AVCodecTag * const *tags, unsigned int tag); + +/** + * Get the codec tag for the given codec id id. + * If no codec tag is found returns 0. + * + * @param tags list of supported codec_id-codec_tag pairs, as stored + * in AVInputFormat.codec_tag and AVOutputFormat.codec_tag + */ +unsigned int av_codec_get_tag(const struct AVCodecTag * const *tags, enum AVCodecID id); + +/** + * Get the codec tag for the given codec id. + * + * @param tags list of supported codec_id - codec_tag pairs, as stored + * in AVInputFormat.codec_tag and AVOutputFormat.codec_tag + * @param id codec id that should be searched for in the list + * @param tag A pointer to the found tag + * @return 0 if id was not found in tags, > 0 if it was found + */ +int av_codec_get_tag2(const struct AVCodecTag * const *tags, enum AVCodecID id, + unsigned int *tag); + +int av_find_default_stream_index(AVFormatContext *s); + +/** + * Get the index for a specific timestamp. + * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond + * to the timestamp which is <= the requested one, if backward + * is 0, then it will be >= + * if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise + * @return < 0 if no such timestamp could be found + */ +int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags); + +/** + * Add an index entry into a sorted list. Update the entry if the list + * already contains it. + * + * @param timestamp timestamp in the time base of the given stream + */ +int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, + int size, int distance, int flags); + + +/** + * Split a URL string into components. + * + * The pointers to buffers for storing individual components may be null, + * in order to ignore that component. Buffers for components not found are + * set to empty strings. If the port is not found, it is set to a negative + * value. + * + * @param proto the buffer for the protocol + * @param proto_size the size of the proto buffer + * @param authorization the buffer for the authorization + * @param authorization_size the size of the authorization buffer + * @param hostname the buffer for the host name + * @param hostname_size the size of the hostname buffer + * @param port_ptr a pointer to store the port number in + * @param path the buffer for the path + * @param path_size the size of the path buffer + * @param url the URL to split + */ +void av_url_split(char *proto, int proto_size, + char *authorization, int authorization_size, + char *hostname, int hostname_size, + int *port_ptr, + char *path, int path_size, + const char *url); + + +void av_dump_format(AVFormatContext *ic, + int index, + const char *url, + int is_output); + +/** + * Return in 'buf' the path with '%d' replaced by a number. + * + * Also handles the '%0nd' format where 'n' is the total number + * of digits and '%%'. + * + * @param buf destination buffer + * @param buf_size destination buffer size + * @param path numbered sequence string + * @param number frame number + * @return 0 if OK, -1 on format error + */ +int av_get_frame_filename(char *buf, int buf_size, + const char *path, int number); + +/** + * Check whether filename actually is a numbered sequence generator. + * + * @param filename possible numbered sequence string + * @return 1 if a valid numbered sequence string, 0 otherwise + */ +int av_filename_number_test(const char *filename); + +/** + * Generate an SDP for an RTP session. + * + * Note, this overwrites the id values of AVStreams in the muxer contexts + * for getting unique dynamic payload types. + * + * @param ac array of AVFormatContexts describing the RTP streams. If the + * array is composed by only one context, such context can contain + * multiple AVStreams (one AVStream per RTP stream). Otherwise, + * all the contexts in the array (an AVCodecContext per RTP stream) + * must contain only one AVStream. + * @param n_files number of AVCodecContexts contained in ac + * @param buf buffer where the SDP will be stored (must be allocated by + * the caller) + * @param size the size of the buffer + * @return 0 if OK, AVERROR_xxx on error + */ +int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size); + +/** + * Return a positive value if the given filename has one of the given + * extensions, 0 otherwise. + * + * @param extensions a comma-separated list of filename extensions + */ +int av_match_ext(const char *filename, const char *extensions); + +/** + * Test if the given container can store a codec. + * + * @param std_compliance standards compliance level, one of FF_COMPLIANCE_* + * + * @return 1 if codec with ID codec_id can be stored in ofmt, 0 if it cannot. + * A negative number if this information is not available. + */ +int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance); + +/** + * @defgroup riff_fourcc RIFF FourCCs + * @{ + * Get the tables mapping RIFF FourCCs to libavcodec AVCodecIDs. The tables are + * meant to be passed to av_codec_get_id()/av_codec_get_tag() as in the + * following code: + * @code + * uint32_t tag = MKTAG('H', '2', '6', '4'); + * const struct AVCodecTag *table[] = { avformat_get_riff_video_tags(), 0 }; + * enum AVCodecID id = av_codec_get_id(table, tag); + * @endcode + */ +/** + * @return the table mapping RIFF FourCCs for video to libavcodec AVCodecID. + */ +const struct AVCodecTag *avformat_get_riff_video_tags(void); +/** + * @return the table mapping RIFF FourCCs for audio to AVCodecID. + */ +const struct AVCodecTag *avformat_get_riff_audio_tags(void); + +/** + * @} + */ + +/** + * Guess the sample aspect ratio of a frame, based on both the stream and the + * frame aspect ratio. + * + * Since the frame aspect ratio is set by the codec but the stream aspect ratio + * is set by the demuxer, these two may not be equal. This function tries to + * return the value that you should use if you would like to display the frame. + * + * Basic logic is to use the stream aspect ratio if it is set to something sane + * otherwise use the frame aspect ratio. This way a container setting, which is + * usually easy to modify can override the coded value in the frames. + * + * @param format the format context which the stream is part of + * @param stream the stream which the frame is part of + * @param frame the frame with the aspect ratio to be determined + * @return the guessed (valid) sample_aspect_ratio, 0/1 if no idea + */ +AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame); + +/** + * Guess the frame rate, based on both the container and codec information. + * + * @param ctx the format context which the stream is part of + * @param stream the stream which the frame is part of + * @param frame the frame for which the frame rate should be determined, may be NULL + * @return the guessed (valid) frame rate, 0/1 if no idea + */ +AVRational av_guess_frame_rate(AVFormatContext *ctx, AVStream *stream, AVFrame *frame); + +/** + * Check if the stream st contained in s is matched by the stream specifier + * spec. + * + * See the "stream specifiers" chapter in the documentation for the syntax + * of spec. + * + * @return >0 if st is matched by spec; + * 0 if st is not matched by spec; + * AVERROR code if spec is invalid + * + * @note A stream specifier can match several streams in the format. + */ +int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st, + const char *spec); + +int avformat_queue_attached_pictures(AVFormatContext *s); + + +/** + * @} + */ + +#endif /* AVFORMAT_AVFORMAT_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavformat/avio.h b/limelight-pc/jni/nv_avc_dec/inc/libavformat/avio.h new file mode 100644 index 0000000..4f4ac3c --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavformat/avio.h @@ -0,0 +1,481 @@ +/* + * copyright (c) 2001 Fabrice Bellard + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +#ifndef AVFORMAT_AVIO_H +#define AVFORMAT_AVIO_H + +/** + * @file + * @ingroup lavf_io + * Buffered I/O operations + */ + +#include + +#include "libavutil/common.h" +#include "libavutil/dict.h" +#include "libavutil/log.h" + +#include "libavformat/version.h" + + +#define AVIO_SEEKABLE_NORMAL 0x0001 /**< Seeking works like for a local file */ + +/** + * Callback for checking whether to abort blocking functions. + * AVERROR_EXIT is returned in this case by the interrupted + * function. During blocking operations, callback is called with + * opaque as parameter. If the callback returns 1, the + * blocking operation will be aborted. + * + * No members can be added to this struct without a major bump, if + * new elements have been added after this struct in AVFormatContext + * or AVIOContext. + */ +typedef struct AVIOInterruptCB { + int (*callback)(void*); + void *opaque; +} AVIOInterruptCB; + +/** + * Bytestream IO Context. + * New fields can be added to the end with minor version bumps. + * Removal, reordering and changes to existing fields require a major + * version bump. + * sizeof(AVIOContext) must not be used outside libav*. + * + * @note None of the function pointers in AVIOContext should be called + * directly, they should only be set by the client application + * when implementing custom I/O. Normally these are set to the + * function pointers specified in avio_alloc_context() + */ +typedef struct AVIOContext { + /** + * A class for private options. + * + * If this AVIOContext is created by avio_open2(), av_class is set and + * passes the options down to protocols. + * + * If this AVIOContext is manually allocated, then av_class may be set by + * the caller. + * + * warning -- this field can be NULL, be sure to not pass this AVIOContext + * to any av_opt_* functions in that case. + */ + const AVClass *av_class; + unsigned char *buffer; /**< Start of the buffer. */ + int buffer_size; /**< Maximum buffer size */ + unsigned char *buf_ptr; /**< Current position in the buffer */ + unsigned char *buf_end; /**< End of the data, may be less than + buffer+buffer_size if the read function returned + less data than requested, e.g. for streams where + no more data has been received yet. */ + void *opaque; /**< A private pointer, passed to the read/write/seek/... + functions. */ + int (*read_packet)(void *opaque, uint8_t *buf, int buf_size); + int (*write_packet)(void *opaque, uint8_t *buf, int buf_size); + int64_t (*seek)(void *opaque, int64_t offset, int whence); + int64_t pos; /**< position in the file of the current buffer */ + int must_flush; /**< true if the next seek should flush */ + int eof_reached; /**< true if eof reached */ + int write_flag; /**< true if open for writing */ + int max_packet_size; + unsigned long checksum; + unsigned char *checksum_ptr; + unsigned long (*update_checksum)(unsigned long checksum, const uint8_t *buf, unsigned int size); + int error; /**< contains the error code or 0 if no error happened */ + /** + * Pause or resume playback for network streaming protocols - e.g. MMS. + */ + int (*read_pause)(void *opaque, int pause); + /** + * Seek to a given timestamp in stream with the specified stream_index. + * Needed for some network streaming protocols which don't support seeking + * to byte position. + */ + int64_t (*read_seek)(void *opaque, int stream_index, + int64_t timestamp, int flags); + /** + * A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable. + */ + int seekable; + + /** + * max filesize, used to limit allocations + * This field is internal to libavformat and access from outside is not allowed. + */ + int64_t maxsize; + + /** + * avio_read and avio_write should if possible be satisfied directly + * instead of going through a buffer, and avio_seek will always + * call the underlying seek function directly. + */ + int direct; + + /** + * Bytes read statistic + * This field is internal to libavformat and access from outside is not allowed. + */ + int64_t bytes_read; + + /** + * seek statistic + * This field is internal to libavformat and access from outside is not allowed. + */ + int seek_count; + + /** + * writeout statistic + * This field is internal to libavformat and access from outside is not allowed. + */ + int writeout_count; +} AVIOContext; + +/* unbuffered I/O */ + +/** + * Return AVIO_FLAG_* access flags corresponding to the access permissions + * of the resource in url, or a negative value corresponding to an + * AVERROR code in case of failure. The returned access flags are + * masked by the value in flags. + * + * @note This function is intrinsically unsafe, in the sense that the + * checked resource may change its existence or permission status from + * one call to another. Thus you should not trust the returned value, + * unless you are sure that no other processes are accessing the + * checked resource. + */ +int avio_check(const char *url, int flags); + +/** + * Allocate and initialize an AVIOContext for buffered I/O. It must be later + * freed with av_free(). + * + * @param buffer Memory block for input/output operations via AVIOContext. + * The buffer must be allocated with av_malloc() and friends. + * @param buffer_size The buffer size is very important for performance. + * For protocols with fixed blocksize it should be set to this blocksize. + * For others a typical size is a cache page, e.g. 4kb. + * @param write_flag Set to 1 if the buffer should be writable, 0 otherwise. + * @param opaque An opaque pointer to user-specific data. + * @param read_packet A function for refilling the buffer, may be NULL. + * @param write_packet A function for writing the buffer contents, may be NULL. + * The function may not change the input buffers content. + * @param seek A function for seeking to specified byte position, may be NULL. + * + * @return Allocated AVIOContext or NULL on failure. + */ +AVIOContext *avio_alloc_context( + unsigned char *buffer, + int buffer_size, + int write_flag, + void *opaque, + int (*read_packet)(void *opaque, uint8_t *buf, int buf_size), + int (*write_packet)(void *opaque, uint8_t *buf, int buf_size), + int64_t (*seek)(void *opaque, int64_t offset, int whence)); + +void avio_w8(AVIOContext *s, int b); +void avio_write(AVIOContext *s, const unsigned char *buf, int size); +void avio_wl64(AVIOContext *s, uint64_t val); +void avio_wb64(AVIOContext *s, uint64_t val); +void avio_wl32(AVIOContext *s, unsigned int val); +void avio_wb32(AVIOContext *s, unsigned int val); +void avio_wl24(AVIOContext *s, unsigned int val); +void avio_wb24(AVIOContext *s, unsigned int val); +void avio_wl16(AVIOContext *s, unsigned int val); +void avio_wb16(AVIOContext *s, unsigned int val); + +/** + * Write a NULL-terminated string. + * @return number of bytes written. + */ +int avio_put_str(AVIOContext *s, const char *str); + +/** + * Convert an UTF-8 string to UTF-16LE and write it. + * @return number of bytes written. + */ +int avio_put_str16le(AVIOContext *s, const char *str); + +/** + * Passing this as the "whence" parameter to a seek function causes it to + * return the filesize without seeking anywhere. Supporting this is optional. + * If it is not supported then the seek function will return <0. + */ +#define AVSEEK_SIZE 0x10000 + +/** + * Oring this flag as into the "whence" parameter to a seek function causes it to + * seek by any means (like reopening and linear reading) or other normally unreasonable + * means that can be extremely slow. + * This may be ignored by the seek code. + */ +#define AVSEEK_FORCE 0x20000 + +/** + * fseek() equivalent for AVIOContext. + * @return new position or AVERROR. + */ +int64_t avio_seek(AVIOContext *s, int64_t offset, int whence); + +/** + * Skip given number of bytes forward + * @return new position or AVERROR. + */ +int64_t avio_skip(AVIOContext *s, int64_t offset); + +/** + * ftell() equivalent for AVIOContext. + * @return position or AVERROR. + */ +static av_always_inline int64_t avio_tell(AVIOContext *s) +{ + return avio_seek(s, 0, SEEK_CUR); +} + +/** + * Get the filesize. + * @return filesize or AVERROR + */ +int64_t avio_size(AVIOContext *s); + +/** + * feof() equivalent for AVIOContext. + * @return non zero if and only if end of file + */ +int url_feof(AVIOContext *s); + +/** @warning currently size is limited */ +int avio_printf(AVIOContext *s, const char *fmt, ...) av_printf_format(2, 3); + +/** + * Force flushing of buffered data to the output s. + * + * Force the buffered data to be immediately written to the output, + * without to wait to fill the internal buffer. + */ +void avio_flush(AVIOContext *s); + +/** + * Read size bytes from AVIOContext into buf. + * @return number of bytes read or AVERROR + */ +int avio_read(AVIOContext *s, unsigned char *buf, int size); + +/** + * @name Functions for reading from AVIOContext + * @{ + * + * @note return 0 if EOF, so you cannot use it if EOF handling is + * necessary + */ +int avio_r8 (AVIOContext *s); +unsigned int avio_rl16(AVIOContext *s); +unsigned int avio_rl24(AVIOContext *s); +unsigned int avio_rl32(AVIOContext *s); +uint64_t avio_rl64(AVIOContext *s); +unsigned int avio_rb16(AVIOContext *s); +unsigned int avio_rb24(AVIOContext *s); +unsigned int avio_rb32(AVIOContext *s); +uint64_t avio_rb64(AVIOContext *s); +/** + * @} + */ + +/** + * Read a string from pb into buf. The reading will terminate when either + * a NULL character was encountered, maxlen bytes have been read, or nothing + * more can be read from pb. The result is guaranteed to be NULL-terminated, it + * will be truncated if buf is too small. + * Note that the string is not interpreted or validated in any way, it + * might get truncated in the middle of a sequence for multi-byte encodings. + * + * @return number of bytes read (is always <= maxlen). + * If reading ends on EOF or error, the return value will be one more than + * bytes actually read. + */ +int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen); + +/** + * Read a UTF-16 string from pb and convert it to UTF-8. + * The reading will terminate when either a null or invalid character was + * encountered or maxlen bytes have been read. + * @return number of bytes read (is always <= maxlen) + */ +int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen); +int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen); + + +/** + * @name URL open modes + * The flags argument to avio_open must be one of the following + * constants, optionally ORed with other flags. + * @{ + */ +#define AVIO_FLAG_READ 1 /**< read-only */ +#define AVIO_FLAG_WRITE 2 /**< write-only */ +#define AVIO_FLAG_READ_WRITE (AVIO_FLAG_READ|AVIO_FLAG_WRITE) /**< read-write pseudo flag */ +/** + * @} + */ + +/** + * Use non-blocking mode. + * If this flag is set, operations on the context will return + * AVERROR(EAGAIN) if they can not be performed immediately. + * If this flag is not set, operations on the context will never return + * AVERROR(EAGAIN). + * Note that this flag does not affect the opening/connecting of the + * context. Connecting a protocol will always block if necessary (e.g. on + * network protocols) but never hang (e.g. on busy devices). + * Warning: non-blocking protocols is work-in-progress; this flag may be + * silently ignored. + */ +#define AVIO_FLAG_NONBLOCK 8 + +/** + * Use direct mode. + * avio_read and avio_write should if possible be satisfied directly + * instead of going through a buffer, and avio_seek will always + * call the underlying seek function directly. + */ +#define AVIO_FLAG_DIRECT 0x8000 + +/** + * Create and initialize a AVIOContext for accessing the + * resource indicated by url. + * @note When the resource indicated by url has been opened in + * read+write mode, the AVIOContext can be used only for writing. + * + * @param s Used to return the pointer to the created AVIOContext. + * In case of failure the pointed to value is set to NULL. + * @param flags flags which control how the resource indicated by url + * is to be opened + * @return >= 0 in case of success, a negative value corresponding to an + * AVERROR code in case of failure + */ +int avio_open(AVIOContext **s, const char *url, int flags); + +/** + * Create and initialize a AVIOContext for accessing the + * resource indicated by url. + * @note When the resource indicated by url has been opened in + * read+write mode, the AVIOContext can be used only for writing. + * + * @param s Used to return the pointer to the created AVIOContext. + * In case of failure the pointed to value is set to NULL. + * @param flags flags which control how the resource indicated by url + * is to be opened + * @param int_cb an interrupt callback to be used at the protocols level + * @param options A dictionary filled with protocol-private options. On return + * this parameter will be destroyed and replaced with a dict containing options + * that were not found. May be NULL. + * @return >= 0 in case of success, a negative value corresponding to an + * AVERROR code in case of failure + */ +int avio_open2(AVIOContext **s, const char *url, int flags, + const AVIOInterruptCB *int_cb, AVDictionary **options); + +/** + * Close the resource accessed by the AVIOContext s and free it. + * This function can only be used if s was opened by avio_open(). + * + * The internal buffer is automatically flushed before closing the + * resource. + * + * @return 0 on success, an AVERROR < 0 on error. + * @see avio_closep + */ +int avio_close(AVIOContext *s); + +/** + * Close the resource accessed by the AVIOContext *s, free it + * and set the pointer pointing to it to NULL. + * This function can only be used if s was opened by avio_open(). + * + * The internal buffer is automatically flushed before closing the + * resource. + * + * @return 0 on success, an AVERROR < 0 on error. + * @see avio_close + */ +int avio_closep(AVIOContext **s); + + +/** + * Open a write only memory stream. + * + * @param s new IO context + * @return zero if no error. + */ +int avio_open_dyn_buf(AVIOContext **s); + +/** + * Return the written size and a pointer to the buffer. The buffer + * must be freed with av_free(). + * Padding of FF_INPUT_BUFFER_PADDING_SIZE is added to the buffer. + * + * @param s IO context + * @param pbuffer pointer to a byte buffer + * @return the length of the byte buffer + */ +int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer); + +/** + * Iterate through names of available protocols. + * + * @param opaque A private pointer representing current protocol. + * It must be a pointer to NULL on first iteration and will + * be updated by successive calls to avio_enum_protocols. + * @param output If set to 1, iterate over output protocols, + * otherwise over input protocols. + * + * @return A static string containing the name of current protocol or NULL + */ +const char *avio_enum_protocols(void **opaque, int output); + +/** + * Pause and resume playing - only meaningful if using a network streaming + * protocol (e.g. MMS). + * @param pause 1 for pause, 0 for resume + */ +int avio_pause(AVIOContext *h, int pause); + +/** + * Seek to a given timestamp relative to some component stream. + * Only meaningful if using a network streaming protocol (e.g. MMS.). + * @param stream_index The stream index that the timestamp is relative to. + * If stream_index is (-1) the timestamp should be in AV_TIME_BASE + * units from the beginning of the presentation. + * If a stream_index >= 0 is used and the protocol does not support + * seeking based on component streams, the call will fail. + * @param timestamp timestamp in AVStream.time_base units + * or if there is no stream specified then in AV_TIME_BASE units. + * @param flags Optional combination of AVSEEK_FLAG_BACKWARD, AVSEEK_FLAG_BYTE + * and AVSEEK_FLAG_ANY. The protocol may silently ignore + * AVSEEK_FLAG_BACKWARD and AVSEEK_FLAG_ANY, but AVSEEK_FLAG_BYTE will + * fail if used and not supported. + * @return >= 0 on success + * @see AVInputFormat::read_seek + */ +int64_t avio_seek_time(AVIOContext *h, int stream_index, + int64_t timestamp, int flags); + +#endif /* AVFORMAT_AVIO_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavformat/version.h b/limelight-pc/jni/nv_avc_dec/inc/libavformat/version.h new file mode 100644 index 0000000..a27dce3 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavformat/version.h @@ -0,0 +1,79 @@ +/* + * Version macros. + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVFORMAT_VERSION_H +#define AVFORMAT_VERSION_H + +/** + * @file + * @ingroup libavf + * Libavformat version macros + */ + +#include "libavutil/avutil.h" + +#define LIBAVFORMAT_VERSION_MAJOR 55 +#define LIBAVFORMAT_VERSION_MINOR 21 +#define LIBAVFORMAT_VERSION_MICRO 100 + +#define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \ + LIBAVFORMAT_VERSION_MINOR, \ + LIBAVFORMAT_VERSION_MICRO) +#define LIBAVFORMAT_VERSION AV_VERSION(LIBAVFORMAT_VERSION_MAJOR, \ + LIBAVFORMAT_VERSION_MINOR, \ + LIBAVFORMAT_VERSION_MICRO) +#define LIBAVFORMAT_BUILD LIBAVFORMAT_VERSION_INT + +#define LIBAVFORMAT_IDENT "Lavf" AV_STRINGIFY(LIBAVFORMAT_VERSION) + +/** + * FF_API_* defines may be placed below to indicate public API that will be + * dropped at a future version bump. The defines themselves are not part of + * the public API and may change, break or disappear at any time. + */ +#ifndef FF_API_REFERENCE_DTS +#define FF_API_REFERENCE_DTS (LIBAVFORMAT_VERSION_MAJOR < 56) +#endif + +#ifndef FF_API_ALLOC_OUTPUT_CONTEXT +#define FF_API_ALLOC_OUTPUT_CONTEXT (LIBAVFORMAT_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_FORMAT_PARAMETERS +#define FF_API_FORMAT_PARAMETERS (LIBAVFORMAT_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_NEW_STREAM +#define FF_API_NEW_STREAM (LIBAVFORMAT_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_SET_PTS_INFO +#define FF_API_SET_PTS_INFO (LIBAVFORMAT_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_CLOSE_INPUT_FILE +#define FF_API_CLOSE_INPUT_FILE (LIBAVFORMAT_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_READ_PACKET +#define FF_API_READ_PACKET (LIBAVFORMAT_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_ASS_SSA +#define FF_API_ASS_SSA (LIBAVFORMAT_VERSION_MAJOR < 56) +#endif +#ifndef FF_API_R_FRAME_RATE +#define FF_API_R_FRAME_RATE 1 +#endif +#endif /* AVFORMAT_VERSION_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/adler32.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/adler32.h new file mode 100644 index 0000000..0dc69ec --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/adler32.h @@ -0,0 +1,55 @@ +/* + * copyright (c) 2006 Mans Rullgard + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_ADLER32_H +#define AVUTIL_ADLER32_H + +#include +#include "attributes.h" + +/** + * @file + * Public header for libavutil Adler32 hasher + * + * @defgroup lavu_adler32 Adler32 + * @ingroup lavu_crypto + * @{ + */ + +/** + * Calculate the Adler32 checksum of a buffer. + * + * Passing the return value to a subsequent av_adler32_update() call + * allows the checksum of multiple buffers to be calculated as though + * they were concatenated. + * + * @param adler initial checksum value + * @param buf pointer to input buffer + * @param len size of input buffer + * @return updated checksum + */ +unsigned long av_adler32_update(unsigned long adler, const uint8_t *buf, + unsigned int len) av_pure; + +/** + * @} + */ + +#endif /* AVUTIL_ADLER32_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/aes.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/aes.h new file mode 100644 index 0000000..09efbda --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/aes.h @@ -0,0 +1,65 @@ +/* + * copyright (c) 2007 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_AES_H +#define AVUTIL_AES_H + +#include + +#include "attributes.h" +#include "version.h" + +/** + * @defgroup lavu_aes AES + * @ingroup lavu_crypto + * @{ + */ + +extern const int av_aes_size; + +struct AVAES; + +/** + * Allocate an AVAES context. + */ +struct AVAES *av_aes_alloc(void); + +/** + * Initialize an AVAES context. + * @param key_bits 128, 192 or 256 + * @param decrypt 0 for encryption, 1 for decryption + */ +int av_aes_init(struct AVAES *a, const uint8_t *key, int key_bits, int decrypt); + +/** + * Encrypt or decrypt a buffer using a previously initialized context. + * @param count number of 16 byte blocks + * @param dst destination array, can be equal to src + * @param src source array, can be equal to dst + * @param iv initialization vector for CBC mode, if NULL then ECB will be used + * @param decrypt 0 for encryption, 1 for decryption + */ +void av_aes_crypt(struct AVAES *a, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt); + +/** + * @} + */ + +#endif /* AVUTIL_AES_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/attributes.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/attributes.h new file mode 100644 index 0000000..7d3f4a9 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/attributes.h @@ -0,0 +1,160 @@ +/* + * copyright (c) 2006 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file + * Macro definitions for various function/variable attributes + */ + +#ifndef AVUTIL_ATTRIBUTES_H +#define AVUTIL_ATTRIBUTES_H + +#ifdef __GNUC__ +# define AV_GCC_VERSION_AT_LEAST(x,y) (__GNUC__ > x || __GNUC__ == x && __GNUC_MINOR__ >= y) +#else +# define AV_GCC_VERSION_AT_LEAST(x,y) 0 +#endif + +#ifndef av_always_inline +#if AV_GCC_VERSION_AT_LEAST(3,1) +# define av_always_inline __attribute__((always_inline)) inline +#elif defined(_MSC_VER) +# define av_always_inline __forceinline +#else +# define av_always_inline inline +#endif +#endif + +#ifndef av_extern_inline +#if defined(__ICL) && __ICL >= 1210 || defined(__GNUC_STDC_INLINE__) +# define av_extern_inline extern inline +#else +# define av_extern_inline inline +#endif +#endif + +#if AV_GCC_VERSION_AT_LEAST(3,1) +# define av_noinline __attribute__((noinline)) +#elif defined(_MSC_VER) +# define av_noinline __declspec(noinline) +#else +# define av_noinline +#endif + +#if AV_GCC_VERSION_AT_LEAST(3,1) +# define av_pure __attribute__((pure)) +#else +# define av_pure +#endif + +#if AV_GCC_VERSION_AT_LEAST(2,6) +# define av_const __attribute__((const)) +#else +# define av_const +#endif + +#if AV_GCC_VERSION_AT_LEAST(4,3) +# define av_cold __attribute__((cold)) +#else +# define av_cold +#endif + +#if AV_GCC_VERSION_AT_LEAST(4,1) && !defined(__llvm__) +# define av_flatten __attribute__((flatten)) +#else +# define av_flatten +#endif + +#if AV_GCC_VERSION_AT_LEAST(3,1) +# define attribute_deprecated __attribute__((deprecated)) +#elif defined(_MSC_VER) +# define attribute_deprecated __declspec(deprecated) +#else +# define attribute_deprecated +#endif + +/** + * Disable warnings about deprecated features + * This is useful for sections of code kept for backward compatibility and + * scheduled for removal. + */ +#ifndef AV_NOWARN_DEPRECATED +#if AV_GCC_VERSION_AT_LEAST(4,6) +# define AV_NOWARN_DEPRECATED(code) \ + _Pragma("GCC diagnostic push") \ + _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") \ + code \ + _Pragma("GCC diagnostic pop") +#elif defined(_MSC_VER) +# define AV_NOWARN_DEPRECATED(code) \ + __pragma(warning(push)) \ + __pragma(warning(disable : 4996)) \ + code; \ + __pragma(warning(pop)) +#else +# define AV_NOWARN_DEPRECATED(code) code +#endif +#endif + + +#if defined(__GNUC__) +# define av_unused __attribute__((unused)) +#else +# define av_unused +#endif + +/** + * Mark a variable as used and prevent the compiler from optimizing it + * away. This is useful for variables accessed only from inline + * assembler without the compiler being aware. + */ +#if AV_GCC_VERSION_AT_LEAST(3,1) +# define av_used __attribute__((used)) +#else +# define av_used +#endif + +#if AV_GCC_VERSION_AT_LEAST(3,3) +# define av_alias __attribute__((may_alias)) +#else +# define av_alias +#endif + +#if defined(__GNUC__) && !defined(__INTEL_COMPILER) && !defined(__clang__) +# define av_uninit(x) x=x +#else +# define av_uninit(x) x +#endif + +#ifdef __GNUC__ +# define av_builtin_constant_p __builtin_constant_p +# define av_printf_format(fmtpos, attrpos) __attribute__((__format__(__printf__, fmtpos, attrpos))) +#else +# define av_builtin_constant_p(x) 0 +# define av_printf_format(fmtpos, attrpos) +#endif + +#if AV_GCC_VERSION_AT_LEAST(2,5) +# define av_noreturn __attribute__((noreturn)) +#else +# define av_noreturn +#endif + +#endif /* AVUTIL_ATTRIBUTES_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/audio_fifo.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/audio_fifo.h new file mode 100644 index 0000000..903b8f1 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/audio_fifo.h @@ -0,0 +1,149 @@ +/* + * Audio FIFO + * Copyright (c) 2012 Justin Ruggles + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file + * Audio FIFO Buffer + */ + +#ifndef AVUTIL_AUDIO_FIFO_H +#define AVUTIL_AUDIO_FIFO_H + +#include "avutil.h" +#include "fifo.h" +#include "samplefmt.h" + +/** + * @addtogroup lavu_audio + * @{ + */ + +/** + * Context for an Audio FIFO Buffer. + * + * - Operates at the sample level rather than the byte level. + * - Supports multiple channels with either planar or packed sample format. + * - Automatic reallocation when writing to a full buffer. + */ +typedef struct AVAudioFifo AVAudioFifo; + +/** + * Free an AVAudioFifo. + * + * @param af AVAudioFifo to free + */ +void av_audio_fifo_free(AVAudioFifo *af); + +/** + * Allocate an AVAudioFifo. + * + * @param sample_fmt sample format + * @param channels number of channels + * @param nb_samples initial allocation size, in samples + * @return newly allocated AVAudioFifo, or NULL on error + */ +AVAudioFifo *av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels, + int nb_samples); + +/** + * Reallocate an AVAudioFifo. + * + * @param af AVAudioFifo to reallocate + * @param nb_samples new allocation size, in samples + * @return 0 if OK, or negative AVERROR code on failure + */ +int av_audio_fifo_realloc(AVAudioFifo *af, int nb_samples); + +/** + * Write data to an AVAudioFifo. + * + * The AVAudioFifo will be reallocated automatically if the available space + * is less than nb_samples. + * + * @see enum AVSampleFormat + * The documentation for AVSampleFormat describes the data layout. + * + * @param af AVAudioFifo to write to + * @param data audio data plane pointers + * @param nb_samples number of samples to write + * @return number of samples actually written, or negative AVERROR + * code on failure. If successful, the number of samples + * actually written will always be nb_samples. + */ +int av_audio_fifo_write(AVAudioFifo *af, void **data, int nb_samples); + +/** + * Read data from an AVAudioFifo. + * + * @see enum AVSampleFormat + * The documentation for AVSampleFormat describes the data layout. + * + * @param af AVAudioFifo to read from + * @param data audio data plane pointers + * @param nb_samples number of samples to read + * @return number of samples actually read, or negative AVERROR code + * on failure. The number of samples actually read will not + * be greater than nb_samples, and will only be less than + * nb_samples if av_audio_fifo_size is less than nb_samples. + */ +int av_audio_fifo_read(AVAudioFifo *af, void **data, int nb_samples); + +/** + * Drain data from an AVAudioFifo. + * + * Removes the data without reading it. + * + * @param af AVAudioFifo to drain + * @param nb_samples number of samples to drain + * @return 0 if OK, or negative AVERROR code on failure + */ +int av_audio_fifo_drain(AVAudioFifo *af, int nb_samples); + +/** + * Reset the AVAudioFifo buffer. + * + * This empties all data in the buffer. + * + * @param af AVAudioFifo to reset + */ +void av_audio_fifo_reset(AVAudioFifo *af); + +/** + * Get the current number of samples in the AVAudioFifo available for reading. + * + * @param af the AVAudioFifo to query + * @return number of samples available for reading + */ +int av_audio_fifo_size(AVAudioFifo *af); + +/** + * Get the current number of samples in the AVAudioFifo available for writing. + * + * @param af the AVAudioFifo to query + * @return number of samples available for writing + */ +int av_audio_fifo_space(AVAudioFifo *af); + +/** + * @} + */ + +#endif /* AVUTIL_AUDIO_FIFO_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/audioconvert.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/audioconvert.h new file mode 100644 index 0000000..300a67c --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/audioconvert.h @@ -0,0 +1,6 @@ + +#include "version.h" + +#if FF_API_AUDIOCONVERT +#include "channel_layout.h" +#endif diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/avassert.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/avassert.h new file mode 100644 index 0000000..41f5e0e --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/avassert.h @@ -0,0 +1,66 @@ +/* + * copyright (c) 2010 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file + * simple assert() macros that are a bit more flexible than ISO C assert(). + * @author Michael Niedermayer + */ + +#ifndef AVUTIL_AVASSERT_H +#define AVUTIL_AVASSERT_H + +#include +#include "avutil.h" +#include "log.h" + +/** + * assert() equivalent, that is always enabled. + */ +#define av_assert0(cond) do { \ + if (!(cond)) { \ + av_log(NULL, AV_LOG_PANIC, "Assertion %s failed at %s:%d\n", \ + AV_STRINGIFY(cond), __FILE__, __LINE__); \ + abort(); \ + } \ +} while (0) + + +/** + * assert() equivalent, that does not lie in speed critical code. + * These asserts() thus can be enabled without fearing speedloss. + */ +#if defined(ASSERT_LEVEL) && ASSERT_LEVEL > 0 +#define av_assert1(cond) av_assert0(cond) +#else +#define av_assert1(cond) ((void)0) +#endif + + +/** + * assert() equivalent, that does lie in speed critical code. + */ +#if defined(ASSERT_LEVEL) && ASSERT_LEVEL > 1 +#define av_assert2(cond) av_assert0(cond) +#else +#define av_assert2(cond) ((void)0) +#endif + +#endif /* AVUTIL_AVASSERT_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/avconfig.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/avconfig.h new file mode 100644 index 0000000..bac323a --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/avconfig.h @@ -0,0 +1,8 @@ +/* Generated by ffconf */ +#ifndef AVUTIL_AVCONFIG_H +#define AVUTIL_AVCONFIG_H +#define AV_HAVE_BIGENDIAN 0 +#define AV_HAVE_FAST_UNALIGNED 0 +#define AV_HAVE_INCOMPATIBLE_LIBAV_ABI 0 +#define AV_HAVE_INCOMPATIBLE_FORK_ABI 0 +#endif /* AVUTIL_AVCONFIG_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/avstring.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/avstring.h new file mode 100644 index 0000000..438ef79 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/avstring.h @@ -0,0 +1,302 @@ +/* + * Copyright (c) 2007 Mans Rullgard + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_AVSTRING_H +#define AVUTIL_AVSTRING_H + +#include +#include "attributes.h" + +/** + * @addtogroup lavu_string + * @{ + */ + +/** + * Return non-zero if pfx is a prefix of str. If it is, *ptr is set to + * the address of the first character in str after the prefix. + * + * @param str input string + * @param pfx prefix to test + * @param ptr updated if the prefix is matched inside str + * @return non-zero if the prefix matches, zero otherwise + */ +int av_strstart(const char *str, const char *pfx, const char **ptr); + +/** + * Return non-zero if pfx is a prefix of str independent of case. If + * it is, *ptr is set to the address of the first character in str + * after the prefix. + * + * @param str input string + * @param pfx prefix to test + * @param ptr updated if the prefix is matched inside str + * @return non-zero if the prefix matches, zero otherwise + */ +int av_stristart(const char *str, const char *pfx, const char **ptr); + +/** + * Locate the first case-independent occurrence in the string haystack + * of the string needle. A zero-length string needle is considered to + * match at the start of haystack. + * + * This function is a case-insensitive version of the standard strstr(). + * + * @param haystack string to search in + * @param needle string to search for + * @return pointer to the located match within haystack + * or a null pointer if no match + */ +char *av_stristr(const char *haystack, const char *needle); + +/** + * Locate the first occurrence of the string needle in the string haystack + * where not more than hay_length characters are searched. A zero-length + * string needle is considered to match at the start of haystack. + * + * This function is a length-limited version of the standard strstr(). + * + * @param haystack string to search in + * @param needle string to search for + * @param hay_length length of string to search in + * @return pointer to the located match within haystack + * or a null pointer if no match + */ +char *av_strnstr(const char *haystack, const char *needle, size_t hay_length); + +/** + * Copy the string src to dst, but no more than size - 1 bytes, and + * null-terminate dst. + * + * This function is the same as BSD strlcpy(). + * + * @param dst destination buffer + * @param src source string + * @param size size of destination buffer + * @return the length of src + * + * @warning since the return value is the length of src, src absolutely + * _must_ be a properly 0-terminated string, otherwise this will read beyond + * the end of the buffer and possibly crash. + */ +size_t av_strlcpy(char *dst, const char *src, size_t size); + +/** + * Append the string src to the string dst, but to a total length of + * no more than size - 1 bytes, and null-terminate dst. + * + * This function is similar to BSD strlcat(), but differs when + * size <= strlen(dst). + * + * @param dst destination buffer + * @param src source string + * @param size size of destination buffer + * @return the total length of src and dst + * + * @warning since the return value use the length of src and dst, these + * absolutely _must_ be a properly 0-terminated strings, otherwise this + * will read beyond the end of the buffer and possibly crash. + */ +size_t av_strlcat(char *dst, const char *src, size_t size); + +/** + * Append output to a string, according to a format. Never write out of + * the destination buffer, and always put a terminating 0 within + * the buffer. + * @param dst destination buffer (string to which the output is + * appended) + * @param size total size of the destination buffer + * @param fmt printf-compatible format string, specifying how the + * following parameters are used + * @return the length of the string that would have been generated + * if enough space had been available + */ +size_t av_strlcatf(char *dst, size_t size, const char *fmt, ...) av_printf_format(3, 4); + +/** + * Print arguments following specified format into a large enough auto + * allocated buffer. It is similar to GNU asprintf(). + * @param fmt printf-compatible format string, specifying how the + * following parameters are used. + * @return the allocated string + * @note You have to free the string yourself with av_free(). + */ +char *av_asprintf(const char *fmt, ...) av_printf_format(1, 2); + +/** + * Convert a number to a av_malloced string. + */ +char *av_d2str(double d); + +/** + * Unescape the given string until a non escaped terminating char, + * and return the token corresponding to the unescaped string. + * + * The normal \ and ' escaping is supported. Leading and trailing + * whitespaces are removed, unless they are escaped with '\' or are + * enclosed between ''. + * + * @param buf the buffer to parse, buf will be updated to point to the + * terminating char + * @param term a 0-terminated list of terminating chars + * @return the malloced unescaped string, which must be av_freed by + * the user, NULL in case of allocation failure + */ +char *av_get_token(const char **buf, const char *term); + +/** + * Split the string into several tokens which can be accessed by + * successive calls to av_strtok(). + * + * A token is defined as a sequence of characters not belonging to the + * set specified in delim. + * + * On the first call to av_strtok(), s should point to the string to + * parse, and the value of saveptr is ignored. In subsequent calls, s + * should be NULL, and saveptr should be unchanged since the previous + * call. + * + * This function is similar to strtok_r() defined in POSIX.1. + * + * @param s the string to parse, may be NULL + * @param delim 0-terminated list of token delimiters, must be non-NULL + * @param saveptr user-provided pointer which points to stored + * information necessary for av_strtok() to continue scanning the same + * string. saveptr is updated to point to the next character after the + * first delimiter found, or to NULL if the string was terminated + * @return the found token, or NULL when no token is found + */ +char *av_strtok(char *s, const char *delim, char **saveptr); + +/** + * Locale-independent conversion of ASCII isdigit. + */ +int av_isdigit(int c); + +/** + * Locale-independent conversion of ASCII isgraph. + */ +int av_isgraph(int c); + +/** + * Locale-independent conversion of ASCII isspace. + */ +int av_isspace(int c); + +/** + * Locale-independent conversion of ASCII characters to uppercase. + */ +static inline int av_toupper(int c) +{ + if (c >= 'a' && c <= 'z') + c ^= 0x20; + return c; +} + +/** + * Locale-independent conversion of ASCII characters to lowercase. + */ +static inline int av_tolower(int c) +{ + if (c >= 'A' && c <= 'Z') + c ^= 0x20; + return c; +} + +/** + * Locale-independent conversion of ASCII isxdigit. + */ +int av_isxdigit(int c); + +/** + * Locale-independent case-insensitive compare. + * @note This means only ASCII-range characters are case-insensitive + */ +int av_strcasecmp(const char *a, const char *b); + +/** + * Locale-independent case-insensitive compare. + * @note This means only ASCII-range characters are case-insensitive + */ +int av_strncasecmp(const char *a, const char *b, size_t n); + + +/** + * Thread safe basename. + * @param path the path, on DOS both \ and / are considered separators. + * @return pointer to the basename substring. + */ +const char *av_basename(const char *path); + +/** + * Thread safe dirname. + * @param path the path, on DOS both \ and / are considered separators. + * @return the path with the separator replaced by the string terminator or ".". + * @note the function may change the input string. + */ +const char *av_dirname(char *path); + +enum AVEscapeMode { + AV_ESCAPE_MODE_AUTO, ///< Use auto-selected escaping mode. + AV_ESCAPE_MODE_BACKSLASH, ///< Use backslash escaping. + AV_ESCAPE_MODE_QUOTE, ///< Use single-quote escaping. +}; + +/** + * Consider spaces special and escape them even in the middle of the + * string. + * + * This is equivalent to adding the whitespace characters to the special + * characters lists, except it is guaranteed to use the exact same list + * of whitespace characters as the rest of libavutil. + */ +#define AV_ESCAPE_FLAG_WHITESPACE 0x01 + +/** + * Escape only specified special characters. + * Without this flag, escape also any characters that may be considered + * special by av_get_token(), such as the single quote. + */ +#define AV_ESCAPE_FLAG_STRICT 0x02 + +/** + * Escape string in src, and put the escaped string in an allocated + * string in *dst, which must be freed with av_free(). + * + * @param dst pointer where an allocated string is put + * @param src string to escape, must be non-NULL + * @param special_chars string containing the special characters which + * need to be escaped, can be NULL + * @param mode escape mode to employ, see AV_ESCAPE_MODE_* macros. + * Any unknown value for mode will be considered equivalent to + * AV_ESCAPE_MODE_BACKSLASH, but this behaviour can change without + * notice. + * @param flags flags which control how to escape, see AV_ESCAPE_FLAG_ macros + * @return the length of the allocated string, or a negative error code in case of error + * @see av_bprint_escape() + */ +int av_escape(char **dst, const char *src, const char *special_chars, + enum AVEscapeMode mode, int flags); + +/** + * @} + */ + +#endif /* AVUTIL_AVSTRING_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/avutil.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/avutil.h new file mode 100644 index 0000000..4e680ed --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/avutil.h @@ -0,0 +1,327 @@ +/* + * copyright (c) 2006 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_AVUTIL_H +#define AVUTIL_AVUTIL_H + +/** + * @file + * external API header + */ + +/** + * @mainpage + * + * @section ffmpeg_intro Introduction + * + * This document describes the usage of the different libraries + * provided by FFmpeg. + * + * @li @ref libavc "libavcodec" encoding/decoding library + * @li @ref lavfi "libavfilter" graph-based frame editing library + * @li @ref libavf "libavformat" I/O and muxing/demuxing library + * @li @ref lavd "libavdevice" special devices muxing/demuxing library + * @li @ref lavu "libavutil" common utility library + * @li @ref lswr "libswresample" audio resampling, format conversion and mixing + * @li @ref lpp "libpostproc" post processing library + * @li @ref lsws "libswscale" color conversion and scaling library + * + * @section ffmpeg_versioning Versioning and compatibility + * + * Each of the FFmpeg libraries contains a version.h header, which defines a + * major, minor and micro version number with the + * LIBRARYNAME_VERSION_{MAJOR,MINOR,MICRO} macros. The major version + * number is incremented with backward incompatible changes - e.g. removing + * parts of the public API, reordering public struct members, etc. The minor + * version number is incremented for backward compatible API changes or major + * new features - e.g. adding a new public function or a new decoder. The micro + * version number is incremented for smaller changes that a calling program + * might still want to check for - e.g. changing behavior in a previously + * unspecified situation. + * + * FFmpeg guarantees backward API and ABI compatibility for each library as long + * as its major version number is unchanged. This means that no public symbols + * will be removed or renamed. Types and names of the public struct members and + * values of public macros and enums will remain the same (unless they were + * explicitly declared as not part of the public API). Documented behavior will + * not change. + * + * In other words, any correct program that works with a given FFmpeg snapshot + * should work just as well without any changes with any later snapshot with the + * same major versions. This applies to both rebuilding the program against new + * FFmpeg versions or to replacing the dynamic FFmpeg libraries that a program + * links against. + * + * However, new public symbols may be added and new members may be appended to + * public structs whose size is not part of public ABI (most public structs in + * FFmpeg). New macros and enum values may be added. Behavior in undocumented + * situations may change slightly (and be documented). All those are accompanied + * by an entry in doc/APIchanges and incrementing either the minor or micro + * version number. + */ + +/** + * @defgroup lavu Common utility functions + * + * @brief + * libavutil contains the code shared across all the other FFmpeg + * libraries + * + * @note In order to use the functions provided by avutil you must include + * the specific header. + * + * @{ + * + * @defgroup lavu_crypto Crypto and Hashing + * + * @{ + * @} + * + * @defgroup lavu_math Maths + * @{ + * + * @} + * + * @defgroup lavu_string String Manipulation + * + * @{ + * + * @} + * + * @defgroup lavu_mem Memory Management + * + * @{ + * + * @} + * + * @defgroup lavu_data Data Structures + * @{ + * + * @} + * + * @defgroup lavu_audio Audio related + * + * @{ + * + * @} + * + * @defgroup lavu_error Error Codes + * + * @{ + * + * @} + * + * @defgroup lavu_log Logging Facility + * + * @{ + * + * @} + * + * @defgroup lavu_misc Other + * + * @{ + * + * @defgroup lavu_internal Internal + * + * Not exported functions, for internal usage only + * + * @{ + * + * @} + */ + + +/** + * @addtogroup lavu_ver + * @{ + */ + +/** + * Return the LIBAVUTIL_VERSION_INT constant. + */ +unsigned avutil_version(void); + +/** + * Return the libavutil build-time configuration. + */ +const char *avutil_configuration(void); + +/** + * Return the libavutil license. + */ +const char *avutil_license(void); + +/** + * @} + */ + +/** + * @addtogroup lavu_media Media Type + * @brief Media Type + */ + +enum AVMediaType { + AVMEDIA_TYPE_UNKNOWN = -1, ///< Usually treated as AVMEDIA_TYPE_DATA + AVMEDIA_TYPE_VIDEO, + AVMEDIA_TYPE_AUDIO, + AVMEDIA_TYPE_DATA, ///< Opaque data information usually continuous + AVMEDIA_TYPE_SUBTITLE, + AVMEDIA_TYPE_ATTACHMENT, ///< Opaque data information usually sparse + AVMEDIA_TYPE_NB +}; + +/** + * Return a string describing the media_type enum, NULL if media_type + * is unknown. + */ +const char *av_get_media_type_string(enum AVMediaType media_type); + +/** + * @defgroup lavu_const Constants + * @{ + * + * @defgroup lavu_enc Encoding specific + * + * @note those definition should move to avcodec + * @{ + */ + +#define FF_LAMBDA_SHIFT 7 +#define FF_LAMBDA_SCALE (1< + +/** + * @defgroup lavu_base64 Base64 + * @ingroup lavu_crypto + * @{ + */ + + +/** + * Decode a base64-encoded string. + * + * @param out buffer for decoded data + * @param in null-terminated input string + * @param out_size size in bytes of the out buffer, must be at + * least 3/4 of the length of in + * @return number of bytes written, or a negative value in case of + * invalid input + */ +int av_base64_decode(uint8_t *out, const char *in, int out_size); + +/** + * Encode data to base64 and null-terminate. + * + * @param out buffer for encoded data + * @param out_size size in bytes of the out buffer (including the + * null terminator), must be at least AV_BASE64_SIZE(in_size) + * @param in input buffer containing the data to encode + * @param in_size size in bytes of the in buffer + * @return out or NULL in case of error + */ +char *av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size); + +/** + * Calculate the output size needed to base64-encode x bytes to a + * null-terminated string. + */ +#define AV_BASE64_SIZE(x) (((x)+2) / 3 * 4 + 1) + + /** + * @} + */ + +#endif /* AVUTIL_BASE64_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/blowfish.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/blowfish.h new file mode 100644 index 0000000..0b00453 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/blowfish.h @@ -0,0 +1,77 @@ +/* + * Blowfish algorithm + * Copyright (c) 2012 Samuel Pitoiset + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_BLOWFISH_H +#define AVUTIL_BLOWFISH_H + +#include + +/** + * @defgroup lavu_blowfish Blowfish + * @ingroup lavu_crypto + * @{ + */ + +#define AV_BF_ROUNDS 16 + +typedef struct AVBlowfish { + uint32_t p[AV_BF_ROUNDS + 2]; + uint32_t s[4][256]; +} AVBlowfish; + +/** + * Initialize an AVBlowfish context. + * + * @param ctx an AVBlowfish context + * @param key a key + * @param key_len length of the key + */ +void av_blowfish_init(struct AVBlowfish *ctx, const uint8_t *key, int key_len); + +/** + * Encrypt or decrypt a buffer using a previously initialized context. + * + * @param ctx an AVBlowfish context + * @param xl left four bytes halves of input to be encrypted + * @param xr right four bytes halves of input to be encrypted + * @param decrypt 0 for encryption, 1 for decryption + */ +void av_blowfish_crypt_ecb(struct AVBlowfish *ctx, uint32_t *xl, uint32_t *xr, + int decrypt); + +/** + * Encrypt or decrypt a buffer using a previously initialized context. + * + * @param ctx an AVBlowfish context + * @param dst destination array, can be equal to src + * @param src source array, can be equal to dst + * @param count number of 8 byte blocks + * @param iv initialization vector for CBC mode, if NULL ECB will be used + * @param decrypt 0 for encryption, 1 for decryption + */ +void av_blowfish_crypt(struct AVBlowfish *ctx, uint8_t *dst, const uint8_t *src, + int count, uint8_t *iv, int decrypt); + +/** + * @} + */ + +#endif /* AVUTIL_BLOWFISH_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/bprint.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/bprint.h new file mode 100644 index 0000000..839ec1e --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/bprint.h @@ -0,0 +1,216 @@ +/* + * Copyright (c) 2012 Nicolas George + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_BPRINT_H +#define AVUTIL_BPRINT_H + +#include + +#include "attributes.h" +#include "avstring.h" + +/** + * Define a structure with extra padding to a fixed size + * This helps ensuring binary compatibility with future versions. + */ +#define FF_PAD_STRUCTURE(size, ...) \ + __VA_ARGS__ \ + char reserved_padding[size - sizeof(struct { __VA_ARGS__ })]; + +/** + * Buffer to print data progressively + * + * The string buffer grows as necessary and is always 0-terminated. + * The content of the string is never accessed, and thus is + * encoding-agnostic and can even hold binary data. + * + * Small buffers are kept in the structure itself, and thus require no + * memory allocation at all (unless the contents of the buffer is needed + * after the structure goes out of scope). This is almost as lightweight as + * declaring a local "char buf[512]". + * + * The length of the string can go beyond the allocated size: the buffer is + * then truncated, but the functions still keep account of the actual total + * length. + * + * In other words, buf->len can be greater than buf->size and records the + * total length of what would have been to the buffer if there had been + * enough memory. + * + * Append operations do not need to be tested for failure: if a memory + * allocation fails, data stop being appended to the buffer, but the length + * is still updated. This situation can be tested with + * av_bprint_is_complete(). + * + * The size_max field determines several possible behaviours: + * + * size_max = -1 (= UINT_MAX) or any large value will let the buffer be + * reallocated as necessary, with an amortized linear cost. + * + * size_max = 0 prevents writing anything to the buffer: only the total + * length is computed. The write operations can then possibly be repeated in + * a buffer with exactly the necessary size + * (using size_init = size_max = len + 1). + * + * size_max = 1 is automatically replaced by the exact size available in the + * structure itself, thus ensuring no dynamic memory allocation. The + * internal buffer is large enough to hold a reasonable paragraph of text, + * such as the current paragraph. + */ +typedef struct AVBPrint { + FF_PAD_STRUCTURE(1024, + char *str; /**< string so far */ + unsigned len; /**< length so far */ + unsigned size; /**< allocated memory */ + unsigned size_max; /**< maximum allocated memory */ + char reserved_internal_buffer[1]; + ) +} AVBPrint; + +/** + * Convenience macros for special values for av_bprint_init() size_max + * parameter. + */ +#define AV_BPRINT_SIZE_UNLIMITED ((unsigned)-1) +#define AV_BPRINT_SIZE_AUTOMATIC 1 +#define AV_BPRINT_SIZE_COUNT_ONLY 0 + +/** + * Init a print buffer. + * + * @param buf buffer to init + * @param size_init initial size (including the final 0) + * @param size_max maximum size; + * 0 means do not write anything, just count the length; + * 1 is replaced by the maximum value for automatic storage; + * any large value means that the internal buffer will be + * reallocated as needed up to that limit; -1 is converted to + * UINT_MAX, the largest limit possible. + * Check also AV_BPRINT_SIZE_* macros. + */ +void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max); + +/** + * Init a print buffer using a pre-existing buffer. + * + * The buffer will not be reallocated. + * + * @param buf buffer structure to init + * @param buffer byte buffer to use for the string data + * @param size size of buffer + */ +void av_bprint_init_for_buffer(AVBPrint *buf, char *buffer, unsigned size); + +/** + * Append a formatted string to a print buffer. + */ +void av_bprintf(AVBPrint *buf, const char *fmt, ...) av_printf_format(2, 3); + +/** + * Append a formatted string to a print buffer. + */ +void av_vbprintf(AVBPrint *buf, const char *fmt, va_list vl_arg); + +/** + * Append char c n times to a print buffer. + */ +void av_bprint_chars(AVBPrint *buf, char c, unsigned n); + +/** + * Append data to a print buffer. + * + * param buf bprint buffer to use + * param data pointer to data + * param size size of data + */ +void av_bprint_append_data(AVBPrint *buf, const char *data, unsigned size); + +struct tm; +/** + * Append a formatted date and time to a print buffer. + * + * param buf bprint buffer to use + * param fmt date and time format string, see strftime() + * param tm broken-down time structure to translate + * + * @note due to poor design of the standard strftime function, it may + * produce poor results if the format string expands to a very long text and + * the bprint buffer is near the limit stated by the size_max option. + */ +void av_bprint_strftime(AVBPrint *buf, const char *fmt, const struct tm *tm); + +/** + * Allocate bytes in the buffer for external use. + * + * @param[in] buf buffer structure + * @param[in] size required size + * @param[out] mem pointer to the memory area + * @param[out] actual_size size of the memory area after allocation; + * can be larger or smaller than size + */ +void av_bprint_get_buffer(AVBPrint *buf, unsigned size, + unsigned char **mem, unsigned *actual_size); + +/** + * Reset the string to "" but keep internal allocated data. + */ +void av_bprint_clear(AVBPrint *buf); + +/** + * Test if the print buffer is complete (not truncated). + * + * It may have been truncated due to a memory allocation failure + * or the size_max limit (compare size and size_max if necessary). + */ +static inline int av_bprint_is_complete(AVBPrint *buf) +{ + return buf->len < buf->size; +} + +/** + * Finalize a print buffer. + * + * The print buffer can no longer be used afterwards, + * but the len and size fields are still valid. + * + * @arg[out] ret_str if not NULL, used to return a permanent copy of the + * buffer contents, or NULL if memory allocation fails; + * if NULL, the buffer is discarded and freed + * @return 0 for success or error code (probably AVERROR(ENOMEM)) + */ +int av_bprint_finalize(AVBPrint *buf, char **ret_str); + +/** + * Escape the content in src and append it to dstbuf. + * + * @param dstbuf already inited destination bprint buffer + * @param src string containing the text to escape + * @param special_chars string containing the special characters which + * need to be escaped, can be NULL + * @param mode escape mode to employ, see AV_ESCAPE_MODE_* macros. + * Any unknown value for mode will be considered equivalent to + * AV_ESCAPE_MODE_BACKSLASH, but this behaviour can change without + * notice. + * @param flags flags which control how to escape, see AV_ESCAPE_FLAG_* macros + */ +void av_bprint_escape(AVBPrint *dstbuf, const char *src, const char *special_chars, + enum AVEscapeMode mode, int flags); + +#endif /* AVUTIL_BPRINT_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/bswap.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/bswap.h new file mode 100644 index 0000000..06f6548 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/bswap.h @@ -0,0 +1,109 @@ +/* + * copyright (c) 2006 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file + * byte swapping routines + */ + +#ifndef AVUTIL_BSWAP_H +#define AVUTIL_BSWAP_H + +#include +#include "libavutil/avconfig.h" +#include "attributes.h" + +#ifdef HAVE_AV_CONFIG_H + +#include "config.h" + +#if ARCH_ARM +# include "arm/bswap.h" +#elif ARCH_AVR32 +# include "avr32/bswap.h" +#elif ARCH_BFIN +# include "bfin/bswap.h" +#elif ARCH_SH4 +# include "sh4/bswap.h" +#elif ARCH_X86 +# include "x86/bswap.h" +#endif + +#endif /* HAVE_AV_CONFIG_H */ + +#define AV_BSWAP16C(x) (((x) << 8 & 0xff00) | ((x) >> 8 & 0x00ff)) +#define AV_BSWAP32C(x) (AV_BSWAP16C(x) << 16 | AV_BSWAP16C((x) >> 16)) +#define AV_BSWAP64C(x) (AV_BSWAP32C(x) << 32 | AV_BSWAP32C((x) >> 32)) + +#define AV_BSWAPC(s, x) AV_BSWAP##s##C(x) + +#ifndef av_bswap16 +static av_always_inline av_const uint16_t av_bswap16(uint16_t x) +{ + x= (x>>8) | (x<<8); + return x; +} +#endif + +#ifndef av_bswap32 +static av_always_inline av_const uint32_t av_bswap32(uint32_t x) +{ + return AV_BSWAP32C(x); +} +#endif + +#ifndef av_bswap64 +static inline uint64_t av_const av_bswap64(uint64_t x) +{ + return (uint64_t)av_bswap32(x) << 32 | av_bswap32(x >> 32); +} +#endif + +// be2ne ... big-endian to native-endian +// le2ne ... little-endian to native-endian + +#if AV_HAVE_BIGENDIAN +#define av_be2ne16(x) (x) +#define av_be2ne32(x) (x) +#define av_be2ne64(x) (x) +#define av_le2ne16(x) av_bswap16(x) +#define av_le2ne32(x) av_bswap32(x) +#define av_le2ne64(x) av_bswap64(x) +#define AV_BE2NEC(s, x) (x) +#define AV_LE2NEC(s, x) AV_BSWAPC(s, x) +#else +#define av_be2ne16(x) av_bswap16(x) +#define av_be2ne32(x) av_bswap32(x) +#define av_be2ne64(x) av_bswap64(x) +#define av_le2ne16(x) (x) +#define av_le2ne32(x) (x) +#define av_le2ne64(x) (x) +#define AV_BE2NEC(s, x) AV_BSWAPC(s, x) +#define AV_LE2NEC(s, x) (x) +#endif + +#define AV_BE2NE16C(x) AV_BE2NEC(16, x) +#define AV_BE2NE32C(x) AV_BE2NEC(32, x) +#define AV_BE2NE64C(x) AV_BE2NEC(64, x) +#define AV_LE2NE16C(x) AV_LE2NEC(16, x) +#define AV_LE2NE32C(x) AV_LE2NEC(32, x) +#define AV_LE2NE64C(x) AV_LE2NEC(64, x) + +#endif /* AVUTIL_BSWAP_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/buffer.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/buffer.h new file mode 100644 index 0000000..b4399fd --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/buffer.h @@ -0,0 +1,274 @@ +/* + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file + * @ingroup lavu_buffer + * refcounted data buffer API + */ + +#ifndef AVUTIL_BUFFER_H +#define AVUTIL_BUFFER_H + +#include + +/** + * @defgroup lavu_buffer AVBuffer + * @ingroup lavu_data + * + * @{ + * AVBuffer is an API for reference-counted data buffers. + * + * There are two core objects in this API -- AVBuffer and AVBufferRef. AVBuffer + * represents the data buffer itself; it is opaque and not meant to be accessed + * by the caller directly, but only through AVBufferRef. However, the caller may + * e.g. compare two AVBuffer pointers to check whether two different references + * are describing the same data buffer. AVBufferRef represents a single + * reference to an AVBuffer and it is the object that may be manipulated by the + * caller directly. + * + * There are two functions provided for creating a new AVBuffer with a single + * reference -- av_buffer_alloc() to just allocate a new buffer, and + * av_buffer_create() to wrap an existing array in an AVBuffer. From an existing + * reference, additional references may be created with av_buffer_ref(). + * Use av_buffer_unref() to free a reference (this will automatically free the + * data once all the references are freed). + * + * The convention throughout this API and the rest of FFmpeg is such that the + * buffer is considered writable if there exists only one reference to it (and + * it has not been marked as read-only). The av_buffer_is_writable() function is + * provided to check whether this is true and av_buffer_make_writable() will + * automatically create a new writable buffer when necessary. + * Of course nothing prevents the calling code from violating this convention, + * however that is safe only when all the existing references are under its + * control. + * + * @note Referencing and unreferencing the buffers is thread-safe and thus + * may be done from multiple threads simultaneously without any need for + * additional locking. + * + * @note Two different references to the same buffer can point to different + * parts of the buffer (i.e. their AVBufferRef.data will not be equal). + */ + +/** + * A reference counted buffer type. It is opaque and is meant to be used through + * references (AVBufferRef). + */ +typedef struct AVBuffer AVBuffer; + +/** + * A reference to a data buffer. + * + * The size of this struct is not a part of the public ABI and it is not meant + * to be allocated directly. + */ +typedef struct AVBufferRef { + AVBuffer *buffer; + + /** + * The data buffer. It is considered writable if and only if + * this is the only reference to the buffer, in which case + * av_buffer_is_writable() returns 1. + */ + uint8_t *data; + /** + * Size of data in bytes. + */ + int size; +} AVBufferRef; + +/** + * Allocate an AVBuffer of the given size using av_malloc(). + * + * @return an AVBufferRef of given size or NULL when out of memory + */ +AVBufferRef *av_buffer_alloc(int size); + +/** + * Same as av_buffer_alloc(), except the returned buffer will be initialized + * to zero. + */ +AVBufferRef *av_buffer_allocz(int size); + +/** + * Always treat the buffer as read-only, even when it has only one + * reference. + */ +#define AV_BUFFER_FLAG_READONLY (1 << 0) + +/** + * Create an AVBuffer from an existing array. + * + * If this function is successful, data is owned by the AVBuffer. The caller may + * only access data through the returned AVBufferRef and references derived from + * it. + * If this function fails, data is left untouched. + * @param data data array + * @param size size of data in bytes + * @param free a callback for freeing this buffer's data + * @param opaque parameter to be got for processing or passed to free + * @param flags a combination of AV_BUFFER_FLAG_* + * + * @return an AVBufferRef referring to data on success, NULL on failure. + */ +AVBufferRef *av_buffer_create(uint8_t *data, int size, + void (*free)(void *opaque, uint8_t *data), + void *opaque, int flags); + +/** + * Default free callback, which calls av_free() on the buffer data. + * This function is meant to be passed to av_buffer_create(), not called + * directly. + */ +void av_buffer_default_free(void *opaque, uint8_t *data); + +/** + * Create a new reference to an AVBuffer. + * + * @return a new AVBufferRef referring to the same AVBuffer as buf or NULL on + * failure. + */ +AVBufferRef *av_buffer_ref(AVBufferRef *buf); + +/** + * Free a given reference and automatically free the buffer if there are no more + * references to it. + * + * @param buf the reference to be freed. The pointer is set to NULL on return. + */ +void av_buffer_unref(AVBufferRef **buf); + +/** + * @return 1 if the caller may write to the data referred to by buf (which is + * true if and only if buf is the only reference to the underlying AVBuffer). + * Return 0 otherwise. + * A positive answer is valid until av_buffer_ref() is called on buf. + */ +int av_buffer_is_writable(const AVBufferRef *buf); + +/** + * @return the opaque parameter set by av_buffer_create. + */ +void *av_buffer_get_opaque(const AVBufferRef *buf); + +int av_buffer_get_ref_count(const AVBufferRef *buf); + +/** + * Create a writable reference from a given buffer reference, avoiding data copy + * if possible. + * + * @param buf buffer reference to make writable. On success, buf is either left + * untouched, or it is unreferenced and a new writable AVBufferRef is + * written in its place. On failure, buf is left untouched. + * @return 0 on success, a negative AVERROR on failure. + */ +int av_buffer_make_writable(AVBufferRef **buf); + +/** + * Reallocate a given buffer. + * + * @param buf a buffer reference to reallocate. On success, buf will be + * unreferenced and a new reference with the required size will be + * written in its place. On failure buf will be left untouched. *buf + * may be NULL, then a new buffer is allocated. + * @param size required new buffer size. + * @return 0 on success, a negative AVERROR on failure. + * + * @note the buffer is actually reallocated with av_realloc() only if it was + * initially allocated through av_buffer_realloc(NULL) and there is only one + * reference to it (i.e. the one passed to this function). In all other cases + * a new buffer is allocated and the data is copied. + */ +int av_buffer_realloc(AVBufferRef **buf, int size); + +/** + * @} + */ + +/** + * @defgroup lavu_bufferpool AVBufferPool + * @ingroup lavu_data + * + * @{ + * AVBufferPool is an API for a lock-free thread-safe pool of AVBuffers. + * + * Frequently allocating and freeing large buffers may be slow. AVBufferPool is + * meant to solve this in cases when the caller needs a set of buffers of the + * same size (the most obvious use case being buffers for raw video or audio + * frames). + * + * At the beginning, the user must call av_buffer_pool_init() to create the + * buffer pool. Then whenever a buffer is needed, call av_buffer_pool_get() to + * get a reference to a new buffer, similar to av_buffer_alloc(). This new + * reference works in all aspects the same way as the one created by + * av_buffer_alloc(). However, when the last reference to this buffer is + * unreferenced, it is returned to the pool instead of being freed and will be + * reused for subsequent av_buffer_pool_get() calls. + * + * When the caller is done with the pool and no longer needs to allocate any new + * buffers, av_buffer_pool_uninit() must be called to mark the pool as freeable. + * Once all the buffers are released, it will automatically be freed. + * + * Allocating and releasing buffers with this API is thread-safe as long as + * either the default alloc callback is used, or the user-supplied one is + * thread-safe. + */ + +/** + * The buffer pool. This structure is opaque and not meant to be accessed + * directly. It is allocated with av_buffer_pool_init() and freed with + * av_buffer_pool_uninit(). + */ +typedef struct AVBufferPool AVBufferPool; + +/** + * Allocate and initialize a buffer pool. + * + * @param size size of each buffer in this pool + * @param alloc a function that will be used to allocate new buffers when the + * pool is empty. May be NULL, then the default allocator will be used + * (av_buffer_alloc()). + * @return newly created buffer pool on success, NULL on error. + */ +AVBufferPool *av_buffer_pool_init(int size, AVBufferRef* (*alloc)(int size)); + +/** + * Mark the pool as being available for freeing. It will actually be freed only + * once all the allocated buffers associated with the pool are released. Thus it + * is safe to call this function while some of the allocated buffers are still + * in use. + * + * @param pool pointer to the pool to be freed. It will be set to NULL. + * @see av_buffer_pool_can_uninit() + */ +void av_buffer_pool_uninit(AVBufferPool **pool); + +/** + * Allocate a new AVBuffer, reusing an old buffer from the pool when available. + * This function may be called simultaneously from multiple threads. + * + * @return a reference to the new buffer on success, NULL on error. + */ +AVBufferRef *av_buffer_pool_get(AVBufferPool *pool); + +/** + * @} + */ + +#endif /* AVUTIL_BUFFER_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/channel_layout.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/channel_layout.h new file mode 100644 index 0000000..ba4f96d --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/channel_layout.h @@ -0,0 +1,221 @@ +/* + * Copyright (c) 2006 Michael Niedermayer + * Copyright (c) 2008 Peter Ross + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_CHANNEL_LAYOUT_H +#define AVUTIL_CHANNEL_LAYOUT_H + +#include + +/** + * @file + * audio channel layout utility functions + */ + +/** + * @addtogroup lavu_audio + * @{ + */ + +/** + * @defgroup channel_masks Audio channel masks + * + * A channel layout is a 64-bits integer with a bit set for every channel. + * The number of bits set must be equal to the number of channels. + * The value 0 means that the channel layout is not known. + * @note this data structure is not powerful enough to handle channels + * combinations that have the same channel multiple times, such as + * dual-mono. + * + * @{ + */ +#define AV_CH_FRONT_LEFT 0x00000001 +#define AV_CH_FRONT_RIGHT 0x00000002 +#define AV_CH_FRONT_CENTER 0x00000004 +#define AV_CH_LOW_FREQUENCY 0x00000008 +#define AV_CH_BACK_LEFT 0x00000010 +#define AV_CH_BACK_RIGHT 0x00000020 +#define AV_CH_FRONT_LEFT_OF_CENTER 0x00000040 +#define AV_CH_FRONT_RIGHT_OF_CENTER 0x00000080 +#define AV_CH_BACK_CENTER 0x00000100 +#define AV_CH_SIDE_LEFT 0x00000200 +#define AV_CH_SIDE_RIGHT 0x00000400 +#define AV_CH_TOP_CENTER 0x00000800 +#define AV_CH_TOP_FRONT_LEFT 0x00001000 +#define AV_CH_TOP_FRONT_CENTER 0x00002000 +#define AV_CH_TOP_FRONT_RIGHT 0x00004000 +#define AV_CH_TOP_BACK_LEFT 0x00008000 +#define AV_CH_TOP_BACK_CENTER 0x00010000 +#define AV_CH_TOP_BACK_RIGHT 0x00020000 +#define AV_CH_STEREO_LEFT 0x20000000 ///< Stereo downmix. +#define AV_CH_STEREO_RIGHT 0x40000000 ///< See AV_CH_STEREO_LEFT. +#define AV_CH_WIDE_LEFT 0x0000000080000000ULL +#define AV_CH_WIDE_RIGHT 0x0000000100000000ULL +#define AV_CH_SURROUND_DIRECT_LEFT 0x0000000200000000ULL +#define AV_CH_SURROUND_DIRECT_RIGHT 0x0000000400000000ULL +#define AV_CH_LOW_FREQUENCY_2 0x0000000800000000ULL + +/** Channel mask value used for AVCodecContext.request_channel_layout + to indicate that the user requests the channel order of the decoder output + to be the native codec channel order. */ +#define AV_CH_LAYOUT_NATIVE 0x8000000000000000ULL + +/** + * @} + * @defgroup channel_mask_c Audio channel convenience macros + * @{ + * */ +#define AV_CH_LAYOUT_MONO (AV_CH_FRONT_CENTER) +#define AV_CH_LAYOUT_STEREO (AV_CH_FRONT_LEFT|AV_CH_FRONT_RIGHT) +#define AV_CH_LAYOUT_2POINT1 (AV_CH_LAYOUT_STEREO|AV_CH_LOW_FREQUENCY) +#define AV_CH_LAYOUT_2_1 (AV_CH_LAYOUT_STEREO|AV_CH_BACK_CENTER) +#define AV_CH_LAYOUT_SURROUND (AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER) +#define AV_CH_LAYOUT_3POINT1 (AV_CH_LAYOUT_SURROUND|AV_CH_LOW_FREQUENCY) +#define AV_CH_LAYOUT_4POINT0 (AV_CH_LAYOUT_SURROUND|AV_CH_BACK_CENTER) +#define AV_CH_LAYOUT_4POINT1 (AV_CH_LAYOUT_4POINT0|AV_CH_LOW_FREQUENCY) +#define AV_CH_LAYOUT_2_2 (AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT) +#define AV_CH_LAYOUT_QUAD (AV_CH_LAYOUT_STEREO|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT) +#define AV_CH_LAYOUT_5POINT0 (AV_CH_LAYOUT_SURROUND|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT) +#define AV_CH_LAYOUT_5POINT1 (AV_CH_LAYOUT_5POINT0|AV_CH_LOW_FREQUENCY) +#define AV_CH_LAYOUT_5POINT0_BACK (AV_CH_LAYOUT_SURROUND|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT) +#define AV_CH_LAYOUT_5POINT1_BACK (AV_CH_LAYOUT_5POINT0_BACK|AV_CH_LOW_FREQUENCY) +#define AV_CH_LAYOUT_6POINT0 (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_CENTER) +#define AV_CH_LAYOUT_6POINT0_FRONT (AV_CH_LAYOUT_2_2|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER) +#define AV_CH_LAYOUT_HEXAGONAL (AV_CH_LAYOUT_5POINT0_BACK|AV_CH_BACK_CENTER) +#define AV_CH_LAYOUT_6POINT1 (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_CENTER) +#define AV_CH_LAYOUT_6POINT1_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_BACK_CENTER) +#define AV_CH_LAYOUT_6POINT1_FRONT (AV_CH_LAYOUT_6POINT0_FRONT|AV_CH_LOW_FREQUENCY) +#define AV_CH_LAYOUT_7POINT0 (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT) +#define AV_CH_LAYOUT_7POINT0_FRONT (AV_CH_LAYOUT_5POINT0|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER) +#define AV_CH_LAYOUT_7POINT1 (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT) +#define AV_CH_LAYOUT_7POINT1_WIDE (AV_CH_LAYOUT_5POINT1|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER) +#define AV_CH_LAYOUT_7POINT1_WIDE_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER) +#define AV_CH_LAYOUT_OCTAGONAL (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_CENTER|AV_CH_BACK_RIGHT) +#define AV_CH_LAYOUT_STEREO_DOWNMIX (AV_CH_STEREO_LEFT|AV_CH_STEREO_RIGHT) + +enum AVMatrixEncoding { + AV_MATRIX_ENCODING_NONE, + AV_MATRIX_ENCODING_DOLBY, + AV_MATRIX_ENCODING_DPLII, + AV_MATRIX_ENCODING_NB +}; + +/** + * @} + */ + +/** + * Return a channel layout id that matches name, or 0 if no match is found. + * + * name can be one or several of the following notations, + * separated by '+' or '|': + * - the name of an usual channel layout (mono, stereo, 4.0, quad, 5.0, + * 5.0(side), 5.1, 5.1(side), 7.1, 7.1(wide), downmix); + * - the name of a single channel (FL, FR, FC, LFE, BL, BR, FLC, FRC, BC, + * SL, SR, TC, TFL, TFC, TFR, TBL, TBC, TBR, DL, DR); + * - a number of channels, in decimal, optionally followed by 'c', yielding + * the default channel layout for that number of channels (@see + * av_get_default_channel_layout); + * - a channel layout mask, in hexadecimal starting with "0x" (see the + * AV_CH_* macros). + * + * @warning Starting from the next major bump the trailing character + * 'c' to specify a number of channels will be required, while a + * channel layout mask could also be specified as a decimal number + * (if and only if not followed by "c"). + * + * Example: "stereo+FC" = "2c+FC" = "2c+1c" = "0x7" + */ +uint64_t av_get_channel_layout(const char *name); + +/** + * Return a description of a channel layout. + * If nb_channels is <= 0, it is guessed from the channel_layout. + * + * @param buf put here the string containing the channel layout + * @param buf_size size in bytes of the buffer + */ +void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout); + +struct AVBPrint; +/** + * Append a description of a channel layout to a bprint buffer. + */ +void av_bprint_channel_layout(struct AVBPrint *bp, int nb_channels, uint64_t channel_layout); + +/** + * Return the number of channels in the channel layout. + */ +int av_get_channel_layout_nb_channels(uint64_t channel_layout); + +/** + * Return default channel layout for a given number of channels. + */ +int64_t av_get_default_channel_layout(int nb_channels); + +/** + * Get the index of a channel in channel_layout. + * + * @param channel a channel layout describing exactly one channel which must be + * present in channel_layout. + * + * @return index of channel in channel_layout on success, a negative AVERROR + * on error. + */ +int av_get_channel_layout_channel_index(uint64_t channel_layout, + uint64_t channel); + +/** + * Get the channel with the given index in channel_layout. + */ +uint64_t av_channel_layout_extract_channel(uint64_t channel_layout, int index); + +/** + * Get the name of a given channel. + * + * @return channel name on success, NULL on error. + */ +const char *av_get_channel_name(uint64_t channel); + +/** + * Get the description of a given channel. + * + * @param channel a channel layout with a single channel + * @return channel description on success, NULL on error + */ +const char *av_get_channel_description(uint64_t channel); + +/** + * Get the value and name of a standard channel layout. + * + * @param[in] index index in an internal list, starting at 0 + * @param[out] layout channel layout mask + * @param[out] name name of the layout + * @return 0 if the layout exists, + * <0 if index is beyond the limits + */ +int av_get_standard_channel_layout(unsigned index, uint64_t *layout, + const char **name); + +/** + * @} + */ + +#endif /* AVUTIL_CHANNEL_LAYOUT_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/common.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/common.h new file mode 100644 index 0000000..e487218 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/common.h @@ -0,0 +1,468 @@ +/* + * copyright (c) 2006 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file + * common internal and external API header + */ + +#ifndef AVUTIL_COMMON_H +#define AVUTIL_COMMON_H + +#if defined(__cplusplus) && !defined(__STDC_CONSTANT_MACROS) && !defined(UINT64_C) +#error missing -D__STDC_CONSTANT_MACROS / #define __STDC_CONSTANT_MACROS +#endif + +#include +#include +#include +#include +#include +#include +#include + +#include "attributes.h" +#include "version.h" +#include "libavutil/avconfig.h" + +#if AV_HAVE_BIGENDIAN +# define AV_NE(be, le) (be) +#else +# define AV_NE(be, le) (le) +#endif + +//rounded division & shift +#define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b)) +/* assume b>0 */ +#define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b)) +/* assume a>0 and b>0 */ +#define FF_CEIL_RSHIFT(a,b) (!av_builtin_constant_p(b) ? -((-(a)) >> (b)) \ + : ((a) + (1<<(b)) - 1) >> (b)) +#define FFUDIV(a,b) (((a)>0 ?(a):(a)-(b)+1) / (b)) +#define FFUMOD(a,b) ((a)-(b)*FFUDIV(a,b)) +#define FFABS(a) ((a) >= 0 ? (a) : (-(a))) +#define FFSIGN(a) ((a) > 0 ? 1 : -1) + +#define FFMAX(a,b) ((a) > (b) ? (a) : (b)) +#define FFMAX3(a,b,c) FFMAX(FFMAX(a,b),c) +#define FFMIN(a,b) ((a) > (b) ? (b) : (a)) +#define FFMIN3(a,b,c) FFMIN(FFMIN(a,b),c) + +#define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0) +#define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0])) +#define FFALIGN(x, a) (((x)+(a)-1)&~((a)-1)) + +/* misc math functions */ + +/** + * Reverse the order of the bits of an 8-bits unsigned integer. + */ +#if FF_API_AV_REVERSE +extern attribute_deprecated const uint8_t av_reverse[256]; +#endif + +#ifdef HAVE_AV_CONFIG_H +# include "config.h" +# include "intmath.h" +#endif + +/* Pull in unguarded fallback defines at the end of this file. */ +#include "common.h" + +#ifndef av_log2 +av_const int av_log2(unsigned v); +#endif + +#ifndef av_log2_16bit +av_const int av_log2_16bit(unsigned v); +#endif + +/** + * Clip a signed integer value into the amin-amax range. + * @param a value to clip + * @param amin minimum value of the clip range + * @param amax maximum value of the clip range + * @return clipped value + */ +static av_always_inline av_const int av_clip_c(int a, int amin, int amax) +{ +#if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2 + if (amin > amax) abort(); +#endif + if (a < amin) return amin; + else if (a > amax) return amax; + else return a; +} + +/** + * Clip a signed 64bit integer value into the amin-amax range. + * @param a value to clip + * @param amin minimum value of the clip range + * @param amax maximum value of the clip range + * @return clipped value + */ +static av_always_inline av_const int64_t av_clip64_c(int64_t a, int64_t amin, int64_t amax) +{ +#if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2 + if (amin > amax) abort(); +#endif + if (a < amin) return amin; + else if (a > amax) return amax; + else return a; +} + +/** + * Clip a signed integer value into the 0-255 range. + * @param a value to clip + * @return clipped value + */ +static av_always_inline av_const uint8_t av_clip_uint8_c(int a) +{ + if (a&(~0xFF)) return (-a)>>31; + else return a; +} + +/** + * Clip a signed integer value into the -128,127 range. + * @param a value to clip + * @return clipped value + */ +static av_always_inline av_const int8_t av_clip_int8_c(int a) +{ + if ((a+0x80) & ~0xFF) return (a>>31) ^ 0x7F; + else return a; +} + +/** + * Clip a signed integer value into the 0-65535 range. + * @param a value to clip + * @return clipped value + */ +static av_always_inline av_const uint16_t av_clip_uint16_c(int a) +{ + if (a&(~0xFFFF)) return (-a)>>31; + else return a; +} + +/** + * Clip a signed integer value into the -32768,32767 range. + * @param a value to clip + * @return clipped value + */ +static av_always_inline av_const int16_t av_clip_int16_c(int a) +{ + if ((a+0x8000) & ~0xFFFF) return (a>>31) ^ 0x7FFF; + else return a; +} + +/** + * Clip a signed 64-bit integer value into the -2147483648,2147483647 range. + * @param a value to clip + * @return clipped value + */ +static av_always_inline av_const int32_t av_clipl_int32_c(int64_t a) +{ + if ((a+0x80000000u) & ~UINT64_C(0xFFFFFFFF)) return (int32_t)((a>>63) ^ 0x7FFFFFFF); + else return (int32_t)a; +} + +/** + * Clip a signed integer to an unsigned power of two range. + * @param a value to clip + * @param p bit position to clip at + * @return clipped value + */ +static av_always_inline av_const unsigned av_clip_uintp2_c(int a, int p) +{ + if (a & ~((1<> 31 & ((1<= 2 + if (amin > amax) abort(); +#endif + if (a < amin) return amin; + else if (a > amax) return amax; + else return a; +} + +/** + * Clip a double value into the amin-amax range. + * @param a value to clip + * @param amin minimum value of the clip range + * @param amax maximum value of the clip range + * @return clipped value + */ +static av_always_inline av_const double av_clipd_c(double a, double amin, double amax) +{ +#if defined(HAVE_AV_CONFIG_H) && defined(ASSERT_LEVEL) && ASSERT_LEVEL >= 2 + if (amin > amax) abort(); +#endif + if (a < amin) return amin; + else if (a > amax) return amax; + else return a; +} + +/** Compute ceil(log2(x)). + * @param x value used to compute ceil(log2(x)) + * @return computed ceiling of log2(x) + */ +static av_always_inline av_const int av_ceil_log2_c(int x) +{ + return av_log2((x - 1) << 1); +} + +/** + * Count number of bits set to one in x + * @param x value to count bits of + * @return the number of bits set to one in x + */ +static av_always_inline av_const int av_popcount_c(uint32_t x) +{ + x -= (x >> 1) & 0x55555555; + x = (x & 0x33333333) + ((x >> 2) & 0x33333333); + x = (x + (x >> 4)) & 0x0F0F0F0F; + x += x >> 8; + return (x + (x >> 16)) & 0x3F; +} + +/** + * Count number of bits set to one in x + * @param x value to count bits of + * @return the number of bits set to one in x + */ +static av_always_inline av_const int av_popcount64_c(uint64_t x) +{ + return av_popcount((uint32_t)x) + av_popcount((uint32_t)(x >> 32)); +} + +#define MKTAG(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((unsigned)(d) << 24)) +#define MKBETAG(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((unsigned)(a) << 24)) + +/** + * Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form. + * + * @param val Output value, must be an lvalue of type uint32_t. + * @param GET_BYTE Expression reading one byte from the input. + * Evaluated up to 7 times (4 for the currently + * assigned Unicode range). With a memory buffer + * input, this could be *ptr++. + * @param ERROR Expression to be evaluated on invalid input, + * typically a goto statement. + * + * @warning ERROR should not contain a loop control statement which + * could interact with the internal while loop, and should force an + * exit from the macro code (e.g. through a goto or a return) in order + * to prevent undefined results. + */ +#define GET_UTF8(val, GET_BYTE, ERROR)\ + val= GET_BYTE;\ + {\ + uint32_t top = (val & 128) >> 1;\ + if ((val & 0xc0) == 0x80 || val >= 0xFE)\ + ERROR\ + while (val & top) {\ + int tmp= GET_BYTE - 128;\ + if(tmp>>6)\ + ERROR\ + val= (val<<6) + tmp;\ + top <<= 5;\ + }\ + val &= (top << 1) - 1;\ + } + +/** + * Convert a UTF-16 character (2 or 4 bytes) to its 32-bit UCS-4 encoded form. + * + * @param val Output value, must be an lvalue of type uint32_t. + * @param GET_16BIT Expression returning two bytes of UTF-16 data converted + * to native byte order. Evaluated one or two times. + * @param ERROR Expression to be evaluated on invalid input, + * typically a goto statement. + */ +#define GET_UTF16(val, GET_16BIT, ERROR)\ + val = GET_16BIT;\ + {\ + unsigned int hi = val - 0xD800;\ + if (hi < 0x800) {\ + val = GET_16BIT - 0xDC00;\ + if (val > 0x3FFU || hi > 0x3FFU)\ + ERROR\ + val += (hi<<10) + 0x10000;\ + }\ + }\ + +/** + * @def PUT_UTF8(val, tmp, PUT_BYTE) + * Convert a 32-bit Unicode character to its UTF-8 encoded form (up to 4 bytes long). + * @param val is an input-only argument and should be of type uint32_t. It holds + * a UCS-4 encoded Unicode character that is to be converted to UTF-8. If + * val is given as a function it is executed only once. + * @param tmp is a temporary variable and should be of type uint8_t. It + * represents an intermediate value during conversion that is to be + * output by PUT_BYTE. + * @param PUT_BYTE writes the converted UTF-8 bytes to any proper destination. + * It could be a function or a statement, and uses tmp as the input byte. + * For example, PUT_BYTE could be "*output++ = tmp;" PUT_BYTE will be + * executed up to 4 times for values in the valid UTF-8 range and up to + * 7 times in the general case, depending on the length of the converted + * Unicode character. + */ +#define PUT_UTF8(val, tmp, PUT_BYTE)\ + {\ + int bytes, shift;\ + uint32_t in = val;\ + if (in < 0x80) {\ + tmp = in;\ + PUT_BYTE\ + } else {\ + bytes = (av_log2(in) + 4) / 5;\ + shift = (bytes - 1) * 6;\ + tmp = (256 - (256 >> bytes)) | (in >> shift);\ + PUT_BYTE\ + while (shift >= 6) {\ + shift -= 6;\ + tmp = 0x80 | ((in >> shift) & 0x3f);\ + PUT_BYTE\ + }\ + }\ + } + +/** + * @def PUT_UTF16(val, tmp, PUT_16BIT) + * Convert a 32-bit Unicode character to its UTF-16 encoded form (2 or 4 bytes). + * @param val is an input-only argument and should be of type uint32_t. It holds + * a UCS-4 encoded Unicode character that is to be converted to UTF-16. If + * val is given as a function it is executed only once. + * @param tmp is a temporary variable and should be of type uint16_t. It + * represents an intermediate value during conversion that is to be + * output by PUT_16BIT. + * @param PUT_16BIT writes the converted UTF-16 data to any proper destination + * in desired endianness. It could be a function or a statement, and uses tmp + * as the input byte. For example, PUT_BYTE could be "*output++ = tmp;" + * PUT_BYTE will be executed 1 or 2 times depending on input character. + */ +#define PUT_UTF16(val, tmp, PUT_16BIT)\ + {\ + uint32_t in = val;\ + if (in < 0x10000) {\ + tmp = in;\ + PUT_16BIT\ + } else {\ + tmp = 0xD800 | ((in - 0x10000) >> 10);\ + PUT_16BIT\ + tmp = 0xDC00 | ((in - 0x10000) & 0x3FF);\ + PUT_16BIT\ + }\ + }\ + + + +#include "mem.h" + +#ifdef HAVE_AV_CONFIG_H +# include "internal.h" +#endif /* HAVE_AV_CONFIG_H */ + +#endif /* AVUTIL_COMMON_H */ + +/* + * The following definitions are outside the multiple inclusion guard + * to ensure they are immediately available in intmath.h. + */ + +#ifndef av_ceil_log2 +# define av_ceil_log2 av_ceil_log2_c +#endif +#ifndef av_clip +# define av_clip av_clip_c +#endif +#ifndef av_clip64 +# define av_clip64 av_clip64_c +#endif +#ifndef av_clip_uint8 +# define av_clip_uint8 av_clip_uint8_c +#endif +#ifndef av_clip_int8 +# define av_clip_int8 av_clip_int8_c +#endif +#ifndef av_clip_uint16 +# define av_clip_uint16 av_clip_uint16_c +#endif +#ifndef av_clip_int16 +# define av_clip_int16 av_clip_int16_c +#endif +#ifndef av_clipl_int32 +# define av_clipl_int32 av_clipl_int32_c +#endif +#ifndef av_clip_uintp2 +# define av_clip_uintp2 av_clip_uintp2_c +#endif +#ifndef av_sat_add32 +# define av_sat_add32 av_sat_add32_c +#endif +#ifndef av_sat_dadd32 +# define av_sat_dadd32 av_sat_dadd32_c +#endif +#ifndef av_clipf +# define av_clipf av_clipf_c +#endif +#ifndef av_clipd +# define av_clipd av_clipd_c +#endif +#ifndef av_popcount +# define av_popcount av_popcount_c +#endif +#ifndef av_popcount64 +# define av_popcount64 av_popcount64_c +#endif diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/cpu.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/cpu.h new file mode 100644 index 0000000..55c3ec9 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/cpu.h @@ -0,0 +1,111 @@ +/* + * Copyright (c) 2000, 2001, 2002 Fabrice Bellard + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_CPU_H +#define AVUTIL_CPU_H + +#include "attributes.h" + +#define AV_CPU_FLAG_FORCE 0x80000000 /* force usage of selected flags (OR) */ + + /* lower 16 bits - CPU features */ +#define AV_CPU_FLAG_MMX 0x0001 ///< standard MMX +#define AV_CPU_FLAG_MMXEXT 0x0002 ///< SSE integer functions or AMD MMX ext +#define AV_CPU_FLAG_MMX2 0x0002 ///< SSE integer functions or AMD MMX ext +#define AV_CPU_FLAG_3DNOW 0x0004 ///< AMD 3DNOW +#define AV_CPU_FLAG_SSE 0x0008 ///< SSE functions +#define AV_CPU_FLAG_SSE2 0x0010 ///< PIV SSE2 functions +#define AV_CPU_FLAG_SSE2SLOW 0x40000000 ///< SSE2 supported, but usually not faster + ///< than regular MMX/SSE (e.g. Core1) +#define AV_CPU_FLAG_3DNOWEXT 0x0020 ///< AMD 3DNowExt +#define AV_CPU_FLAG_SSE3 0x0040 ///< Prescott SSE3 functions +#define AV_CPU_FLAG_SSE3SLOW 0x20000000 ///< SSE3 supported, but usually not faster + ///< than regular MMX/SSE (e.g. Core1) +#define AV_CPU_FLAG_SSSE3 0x0080 ///< Conroe SSSE3 functions +#define AV_CPU_FLAG_ATOM 0x10000000 ///< Atom processor, some SSSE3 instructions are slower +#define AV_CPU_FLAG_SSE4 0x0100 ///< Penryn SSE4.1 functions +#define AV_CPU_FLAG_SSE42 0x0200 ///< Nehalem SSE4.2 functions +#define AV_CPU_FLAG_AVX 0x4000 ///< AVX functions: requires OS support even if YMM registers aren't used +#define AV_CPU_FLAG_XOP 0x0400 ///< Bulldozer XOP functions +#define AV_CPU_FLAG_FMA4 0x0800 ///< Bulldozer FMA4 functions +// #if LIBAVUTIL_VERSION_MAJOR <52 +#define AV_CPU_FLAG_CMOV 0x1001000 ///< supports cmov instruction +// #else +// #define AV_CPU_FLAG_CMOV 0x1000 ///< supports cmov instruction +// #endif +#define AV_CPU_FLAG_AVX2 0x8000 ///< AVX2 functions: requires OS support even if YMM registers aren't used + +#define AV_CPU_FLAG_ALTIVEC 0x0001 ///< standard + +#define AV_CPU_FLAG_ARMV5TE (1 << 0) +#define AV_CPU_FLAG_ARMV6 (1 << 1) +#define AV_CPU_FLAG_ARMV6T2 (1 << 2) +#define AV_CPU_FLAG_VFP (1 << 3) +#define AV_CPU_FLAG_VFPV3 (1 << 4) +#define AV_CPU_FLAG_NEON (1 << 5) + +/** + * Return the flags which specify extensions supported by the CPU. + * The returned value is affected by av_force_cpu_flags() if that was used + * before. So av_get_cpu_flags() can easily be used in a application to + * detect the enabled cpu flags. + */ +int av_get_cpu_flags(void); + +/** + * Disables cpu detection and forces the specified flags. + * -1 is a special case that disables forcing of specific flags. + */ +void av_force_cpu_flags(int flags); + +/** + * Set a mask on flags returned by av_get_cpu_flags(). + * This function is mainly useful for testing. + * Please use av_force_cpu_flags() and av_get_cpu_flags() instead which are more flexible + * + * @warning this function is not thread safe. + */ +attribute_deprecated void av_set_cpu_flags_mask(int mask); + +/** + * Parse CPU flags from a string. + * + * The returned flags contain the specified flags as well as related unspecified flags. + * + * This function exists only for compatibility with libav. + * Please use av_parse_cpu_caps() when possible. + * @return a combination of AV_CPU_* flags, negative on error. + */ +attribute_deprecated +int av_parse_cpu_flags(const char *s); + +/** + * Parse CPU caps from a string and update the given AV_CPU_* flags based on that. + * + * @return negative on error. + */ +int av_parse_cpu_caps(unsigned *flags, const char *s); + +/** + * @return the number of logical CPU cores present. + */ +int av_cpu_count(void); + +#endif /* AVUTIL_CPU_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/crc.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/crc.h new file mode 100644 index 0000000..f4219ca --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/crc.h @@ -0,0 +1,85 @@ +/* + * copyright (c) 2006 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_CRC_H +#define AVUTIL_CRC_H + +#include +#include +#include "attributes.h" + +/** + * @defgroup lavu_crc32 CRC32 + * @ingroup lavu_crypto + * @{ + */ + +typedef uint32_t AVCRC; + +typedef enum { + AV_CRC_8_ATM, + AV_CRC_16_ANSI, + AV_CRC_16_CCITT, + AV_CRC_32_IEEE, + AV_CRC_32_IEEE_LE, /*< reversed bitorder version of AV_CRC_32_IEEE */ + AV_CRC_24_IEEE = 12, + AV_CRC_MAX, /*< Not part of public API! Do not use outside libavutil. */ +}AVCRCId; + +/** + * Initialize a CRC table. + * @param ctx must be an array of size sizeof(AVCRC)*257 or sizeof(AVCRC)*1024 + * @param le If 1, the lowest bit represents the coefficient for the highest + * exponent of the corresponding polynomial (both for poly and + * actual CRC). + * If 0, you must swap the CRC parameter and the result of av_crc + * if you need the standard representation (can be simplified in + * most cases to e.g. bswap16): + * av_bswap32(crc << (32-bits)) + * @param bits number of bits for the CRC + * @param poly generator polynomial without the x**bits coefficient, in the + * representation as specified by le + * @param ctx_size size of ctx in bytes + * @return <0 on failure + */ +int av_crc_init(AVCRC *ctx, int le, int bits, uint32_t poly, int ctx_size); + +/** + * Get an initialized standard CRC table. + * @param crc_id ID of a standard CRC + * @return a pointer to the CRC table or NULL on failure + */ +const AVCRC *av_crc_get_table(AVCRCId crc_id); + +/** + * Calculate the CRC of a block. + * @param crc CRC of previous blocks if any or initial value for CRC + * @return CRC updated with the data from the given block + * + * @see av_crc_init() "le" parameter + */ +uint32_t av_crc(const AVCRC *ctx, uint32_t crc, + const uint8_t *buffer, size_t length) av_pure; + +/** + * @} + */ + +#endif /* AVUTIL_CRC_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/dict.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/dict.h new file mode 100644 index 0000000..38f03a4 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/dict.h @@ -0,0 +1,152 @@ +/* + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file + * Public dictionary API. + * @deprecated + * AVDictionary is provided for compatibility with libav. It is both in + * implementation as well as API inefficient. It does not scale and is + * extremely slow with large dictionaries. + * It is recommended that new code uses our tree container from tree.c/h + * where applicable, which uses AVL trees to achieve O(log n) performance. + */ + +#ifndef AVUTIL_DICT_H +#define AVUTIL_DICT_H + +/** + * @addtogroup lavu_dict AVDictionary + * @ingroup lavu_data + * + * @brief Simple key:value store + * + * @{ + * Dictionaries are used for storing key:value pairs. To create + * an AVDictionary, simply pass an address of a NULL pointer to + * av_dict_set(). NULL can be used as an empty dictionary wherever + * a pointer to an AVDictionary is required. + * Use av_dict_get() to retrieve an entry or iterate over all + * entries and finally av_dict_free() to free the dictionary + * and all its contents. + * + * @code + * AVDictionary *d = NULL; // "create" an empty dictionary + * av_dict_set(&d, "foo", "bar", 0); // add an entry + * + * char *k = av_strdup("key"); // if your strings are already allocated, + * char *v = av_strdup("value"); // you can avoid copying them like this + * av_dict_set(&d, k, v, AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL); + * + * AVDictionaryEntry *t = NULL; + * while (t = av_dict_get(d, "", t, AV_DICT_IGNORE_SUFFIX)) { + * <....> // iterate over all entries in d + * } + * + * av_dict_free(&d); + * @endcode + * + */ + +#define AV_DICT_MATCH_CASE 1 +#define AV_DICT_IGNORE_SUFFIX 2 +#define AV_DICT_DONT_STRDUP_KEY 4 /**< Take ownership of a key that's been + allocated with av_malloc() and children. */ +#define AV_DICT_DONT_STRDUP_VAL 8 /**< Take ownership of a value that's been + allocated with av_malloc() and chilren. */ +#define AV_DICT_DONT_OVERWRITE 16 ///< Don't overwrite existing entries. +#define AV_DICT_APPEND 32 /**< If the entry already exists, append to it. Note that no + delimiter is added, the strings are simply concatenated. */ + +typedef struct AVDictionaryEntry { + char *key; + char *value; +} AVDictionaryEntry; + +typedef struct AVDictionary AVDictionary; + +/** + * Get a dictionary entry with matching key. + * + * @param prev Set to the previous matching element to find the next. + * If set to NULL the first matching element is returned. + * @param flags Allows case as well as suffix-insensitive comparisons. + * @return Found entry or NULL, changing key or value leads to undefined behavior. + */ +AVDictionaryEntry * +av_dict_get(AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags); + +/** + * Get number of entries in dictionary. + * + * @param m dictionary + * @return number of entries in dictionary + */ +int av_dict_count(const AVDictionary *m); + +/** + * Set the given entry in *pm, overwriting an existing entry. + * + * @param pm pointer to a pointer to a dictionary struct. If *pm is NULL + * a dictionary struct is allocated and put in *pm. + * @param key entry key to add to *pm (will be av_strduped depending on flags) + * @param value entry value to add to *pm (will be av_strduped depending on flags). + * Passing a NULL value will cause an existing entry to be deleted. + * @return >= 0 on success otherwise an error code <0 + */ +int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags); + +/** + * Parse the key/value pairs list and add to a dictionary. + * + * @param key_val_sep a 0-terminated list of characters used to separate + * key from value + * @param pairs_sep a 0-terminated list of characters used to separate + * two pairs from each other + * @param flags flags to use when adding to dictionary. + * AV_DICT_DONT_STRDUP_KEY and AV_DICT_DONT_STRDUP_VAL + * are ignored since the key/value tokens will always + * be duplicated. + * @return 0 on success, negative AVERROR code on failure + */ +int av_dict_parse_string(AVDictionary **pm, const char *str, + const char *key_val_sep, const char *pairs_sep, + int flags); + +/** + * Copy entries from one AVDictionary struct into another. + * @param dst pointer to a pointer to a AVDictionary struct. If *dst is NULL, + * this function will allocate a struct for you and put it in *dst + * @param src pointer to source AVDictionary struct + * @param flags flags to use when setting entries in *dst + * @note metadata is read using the AV_DICT_IGNORE_SUFFIX flag + */ +void av_dict_copy(AVDictionary **dst, AVDictionary *src, int flags); + +/** + * Free all the memory allocated for an AVDictionary struct + * and all keys and values. + */ +void av_dict_free(AVDictionary **m); + +/** + * @} + */ + +#endif /* AVUTIL_DICT_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/error.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/error.h new file mode 100644 index 0000000..f3fd7bb --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/error.h @@ -0,0 +1,117 @@ +/* + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file + * error code definitions + */ + +#ifndef AVUTIL_ERROR_H +#define AVUTIL_ERROR_H + +#include +#include + +/** + * @addtogroup lavu_error + * + * @{ + */ + + +/* error handling */ +#if EDOM > 0 +#define AVERROR(e) (-(e)) ///< Returns a negative error code from a POSIX error code, to return from library functions. +#define AVUNERROR(e) (-(e)) ///< Returns a POSIX error code from a library function error return value. +#else +/* Some platforms have E* and errno already negated. */ +#define AVERROR(e) (e) +#define AVUNERROR(e) (e) +#endif + +#define FFERRTAG(a, b, c, d) (-(int)MKTAG(a, b, c, d)) + +#define AVERROR_BSF_NOT_FOUND FFERRTAG(0xF8,'B','S','F') ///< Bitstream filter not found +#define AVERROR_BUG FFERRTAG( 'B','U','G','!') ///< Internal bug, also see AVERROR_BUG2 +#define AVERROR_BUFFER_TOO_SMALL FFERRTAG( 'B','U','F','S') ///< Buffer too small +#define AVERROR_DECODER_NOT_FOUND FFERRTAG(0xF8,'D','E','C') ///< Decoder not found +#define AVERROR_DEMUXER_NOT_FOUND FFERRTAG(0xF8,'D','E','M') ///< Demuxer not found +#define AVERROR_ENCODER_NOT_FOUND FFERRTAG(0xF8,'E','N','C') ///< Encoder not found +#define AVERROR_EOF FFERRTAG( 'E','O','F',' ') ///< End of file +#define AVERROR_EXIT FFERRTAG( 'E','X','I','T') ///< Immediate exit was requested; the called function should not be restarted +#define AVERROR_EXTERNAL FFERRTAG( 'E','X','T',' ') ///< Generic error in an external library +#define AVERROR_FILTER_NOT_FOUND FFERRTAG(0xF8,'F','I','L') ///< Filter not found +#define AVERROR_INVALIDDATA FFERRTAG( 'I','N','D','A') ///< Invalid data found when processing input +#define AVERROR_MUXER_NOT_FOUND FFERRTAG(0xF8,'M','U','X') ///< Muxer not found +#define AVERROR_OPTION_NOT_FOUND FFERRTAG(0xF8,'O','P','T') ///< Option not found +#define AVERROR_PATCHWELCOME FFERRTAG( 'P','A','W','E') ///< Not yet implemented in FFmpeg, patches welcome +#define AVERROR_PROTOCOL_NOT_FOUND FFERRTAG(0xF8,'P','R','O') ///< Protocol not found + +#define AVERROR_STREAM_NOT_FOUND FFERRTAG(0xF8,'S','T','R') ///< Stream not found +/** + * This is semantically identical to AVERROR_BUG + * it has been introduced in Libav after our AVERROR_BUG and with a modified value. + */ +#define AVERROR_BUG2 FFERRTAG( 'B','U','G',' ') +#define AVERROR_UNKNOWN FFERRTAG( 'U','N','K','N') ///< Unknown error, typically from an external library +#define AVERROR_EXPERIMENTAL (-0x2bb2afa8) ///< Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it. + +#define AV_ERROR_MAX_STRING_SIZE 64 + +/** + * Put a description of the AVERROR code errnum in errbuf. + * In case of failure the global variable errno is set to indicate the + * error. Even in case of failure av_strerror() will print a generic + * error message indicating the errnum provided to errbuf. + * + * @param errnum error code to describe + * @param errbuf buffer to which description is written + * @param errbuf_size the size in bytes of errbuf + * @return 0 on success, a negative value if a description for errnum + * cannot be found + */ +int av_strerror(int errnum, char *errbuf, size_t errbuf_size); + +/** + * Fill the provided buffer with a string containing an error string + * corresponding to the AVERROR code errnum. + * + * @param errbuf a buffer + * @param errbuf_size size in bytes of errbuf + * @param errnum error code to describe + * @return the buffer in input, filled with the error description + * @see av_strerror() + */ +static inline char *av_make_error_string(char *errbuf, size_t errbuf_size, int errnum) +{ + av_strerror(errnum, errbuf, errbuf_size); + return errbuf; +} + +/** + * Convenience macro, the return value should be used only directly in + * function arguments but never stand-alone. + */ +#define av_err2str(errnum) \ + av_make_error_string((char[AV_ERROR_MAX_STRING_SIZE]){0}, AV_ERROR_MAX_STRING_SIZE, errnum) + +/** + * @} + */ + +#endif /* AVUTIL_ERROR_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/eval.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/eval.h new file mode 100644 index 0000000..6159b0f --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/eval.h @@ -0,0 +1,113 @@ +/* + * Copyright (c) 2002 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file + * simple arithmetic expression evaluator + */ + +#ifndef AVUTIL_EVAL_H +#define AVUTIL_EVAL_H + +#include "avutil.h" + +typedef struct AVExpr AVExpr; + +/** + * Parse and evaluate an expression. + * Note, this is significantly slower than av_expr_eval(). + * + * @param res a pointer to a double where is put the result value of + * the expression, or NAN in case of error + * @param s expression as a zero terminated string, for example "1+2^3+5*5+sin(2/3)" + * @param const_names NULL terminated array of zero terminated strings of constant identifiers, for example {"PI", "E", 0} + * @param const_values a zero terminated array of values for the identifiers from const_names + * @param func1_names NULL terminated array of zero terminated strings of funcs1 identifiers + * @param funcs1 NULL terminated array of function pointers for functions which take 1 argument + * @param func2_names NULL terminated array of zero terminated strings of funcs2 identifiers + * @param funcs2 NULL terminated array of function pointers for functions which take 2 arguments + * @param opaque a pointer which will be passed to all functions from funcs1 and funcs2 + * @param log_ctx parent logging context + * @return >= 0 in case of success, a negative value corresponding to an + * AVERROR code otherwise + */ +int av_expr_parse_and_eval(double *res, const char *s, + const char * const *const_names, const double *const_values, + const char * const *func1_names, double (* const *funcs1)(void *, double), + const char * const *func2_names, double (* const *funcs2)(void *, double, double), + void *opaque, int log_offset, void *log_ctx); + +/** + * Parse an expression. + * + * @param expr a pointer where is put an AVExpr containing the parsed + * value in case of successful parsing, or NULL otherwise. + * The pointed to AVExpr must be freed with av_expr_free() by the user + * when it is not needed anymore. + * @param s expression as a zero terminated string, for example "1+2^3+5*5+sin(2/3)" + * @param const_names NULL terminated array of zero terminated strings of constant identifiers, for example {"PI", "E", 0} + * @param func1_names NULL terminated array of zero terminated strings of funcs1 identifiers + * @param funcs1 NULL terminated array of function pointers for functions which take 1 argument + * @param func2_names NULL terminated array of zero terminated strings of funcs2 identifiers + * @param funcs2 NULL terminated array of function pointers for functions which take 2 arguments + * @param log_ctx parent logging context + * @return >= 0 in case of success, a negative value corresponding to an + * AVERROR code otherwise + */ +int av_expr_parse(AVExpr **expr, const char *s, + const char * const *const_names, + const char * const *func1_names, double (* const *funcs1)(void *, double), + const char * const *func2_names, double (* const *funcs2)(void *, double, double), + int log_offset, void *log_ctx); + +/** + * Evaluate a previously parsed expression. + * + * @param const_values a zero terminated array of values for the identifiers from av_expr_parse() const_names + * @param opaque a pointer which will be passed to all functions from funcs1 and funcs2 + * @return the value of the expression + */ +double av_expr_eval(AVExpr *e, const double *const_values, void *opaque); + +/** + * Free a parsed expression previously created with av_expr_parse(). + */ +void av_expr_free(AVExpr *e); + +/** + * Parse the string in numstr and return its value as a double. If + * the string is empty, contains only whitespaces, or does not contain + * an initial substring that has the expected syntax for a + * floating-point number, no conversion is performed. In this case, + * returns a value of zero and the value returned in tail is the value + * of numstr. + * + * @param numstr a string representing a number, may contain one of + * the International System number postfixes, for example 'K', 'M', + * 'G'. If 'i' is appended after the postfix, powers of 2 are used + * instead of powers of 10. The 'B' postfix multiplies the value for + * 8, and can be appended after another postfix or used alone. This + * allows using for example 'KB', 'MiB', 'G' and 'B' as postfix. + * @param tail if non-NULL puts here the pointer to the char next + * after the last parsed character + */ +double av_strtod(const char *numstr, char **tail); + +#endif /* AVUTIL_EVAL_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/fifo.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/fifo.h new file mode 100644 index 0000000..849b9a6 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/fifo.h @@ -0,0 +1,144 @@ +/* + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file + * a very simple circular buffer FIFO implementation + */ + +#ifndef AVUTIL_FIFO_H +#define AVUTIL_FIFO_H + +#include +#include "avutil.h" +#include "attributes.h" + +typedef struct AVFifoBuffer { + uint8_t *buffer; + uint8_t *rptr, *wptr, *end; + uint32_t rndx, wndx; +} AVFifoBuffer; + +/** + * Initialize an AVFifoBuffer. + * @param size of FIFO + * @return AVFifoBuffer or NULL in case of memory allocation failure + */ +AVFifoBuffer *av_fifo_alloc(unsigned int size); + +/** + * Free an AVFifoBuffer. + * @param f AVFifoBuffer to free + */ +void av_fifo_free(AVFifoBuffer *f); + +/** + * Reset the AVFifoBuffer to the state right after av_fifo_alloc, in particular it is emptied. + * @param f AVFifoBuffer to reset + */ +void av_fifo_reset(AVFifoBuffer *f); + +/** + * Return the amount of data in bytes in the AVFifoBuffer, that is the + * amount of data you can read from it. + * @param f AVFifoBuffer to read from + * @return size + */ +int av_fifo_size(AVFifoBuffer *f); + +/** + * Return the amount of space in bytes in the AVFifoBuffer, that is the + * amount of data you can write into it. + * @param f AVFifoBuffer to write into + * @return size + */ +int av_fifo_space(AVFifoBuffer *f); + +/** + * Feed data from an AVFifoBuffer to a user-supplied callback. + * @param f AVFifoBuffer to read from + * @param buf_size number of bytes to read + * @param func generic read function + * @param dest data destination + */ +int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void (*func)(void*, void*, int)); + +/** + * Feed data from a user-supplied callback to an AVFifoBuffer. + * @param f AVFifoBuffer to write to + * @param src data source; non-const since it may be used as a + * modifiable context by the function defined in func + * @param size number of bytes to write + * @param func generic write function; the first parameter is src, + * the second is dest_buf, the third is dest_buf_size. + * func must return the number of bytes written to dest_buf, or <= 0 to + * indicate no more data available to write. + * If func is NULL, src is interpreted as a simple byte array for source data. + * @return the number of bytes written to the FIFO + */ +int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int (*func)(void*, void*, int)); + +/** + * Resize an AVFifoBuffer. + * In case of reallocation failure, the old FIFO is kept unchanged. + * + * @param f AVFifoBuffer to resize + * @param size new AVFifoBuffer size in bytes + * @return <0 for failure, >=0 otherwise + */ +int av_fifo_realloc2(AVFifoBuffer *f, unsigned int size); + +/** + * Enlarge an AVFifoBuffer. + * In case of reallocation failure, the old FIFO is kept unchanged. + * The new fifo size may be larger than the requested size. + * + * @param f AVFifoBuffer to resize + * @param additional_space the amount of space in bytes to allocate in addition to av_fifo_size() + * @return <0 for failure, >=0 otherwise + */ +int av_fifo_grow(AVFifoBuffer *f, unsigned int additional_space); + +/** + * Read and discard the specified amount of data from an AVFifoBuffer. + * @param f AVFifoBuffer to read from + * @param size amount of data to read in bytes + */ +void av_fifo_drain(AVFifoBuffer *f, int size); + +/** + * Return a pointer to the data stored in a FIFO buffer at a certain offset. + * The FIFO buffer is not modified. + * + * @param f AVFifoBuffer to peek at, f must be non-NULL + * @param offs an offset in bytes, its absolute value must be less + * than the used buffer size or the returned pointer will + * point outside to the buffer data. + * The used buffer size can be checked with av_fifo_size(). + */ +static inline uint8_t *av_fifo_peek2(const AVFifoBuffer *f, int offs) +{ + uint8_t *ptr = f->rptr + offs; + if (ptr >= f->end) + ptr = f->buffer + (ptr - f->end); + else if (ptr < f->buffer) + ptr = f->end - (f->buffer - ptr); + return ptr; +} + +#endif /* AVUTIL_FIFO_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/file.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/file.h new file mode 100644 index 0000000..a7364fe --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/file.h @@ -0,0 +1,66 @@ +/* + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_FILE_H +#define AVUTIL_FILE_H + +#include + +#include "avutil.h" + +/** + * @file + * Misc file utilities. + */ + +/** + * Read the file with name filename, and put its content in a newly + * allocated buffer or map it with mmap() when available. + * In case of success set *bufptr to the read or mmapped buffer, and + * *size to the size in bytes of the buffer in *bufptr. + * The returned buffer must be released with av_file_unmap(). + * + * @param log_offset loglevel offset used for logging + * @param log_ctx context used for logging + * @return a non negative number in case of success, a negative value + * corresponding to an AVERROR error code in case of failure + */ +int av_file_map(const char *filename, uint8_t **bufptr, size_t *size, + int log_offset, void *log_ctx); + +/** + * Unmap or free the buffer bufptr created by av_file_map(). + * + * @param size size in bytes of bufptr, must be the same as returned + * by av_file_map() + */ +void av_file_unmap(uint8_t *bufptr, size_t size); + +/** + * Wrapper to work around the lack of mkstemp() on mingw. + * Also, tries to create file in /tmp first, if possible. + * *prefix can be a character constant; *filename will be allocated internally. + * @return file descriptor of opened file (or -1 on error) + * and opened file name in **filename. + * @note On very old libcs it is necessary to set a secure umask before + * calling this, av_tempfile() can't call umask itself as it is used in + * libraries and could interfere with the calling application. + */ +int av_tempfile(const char *prefix, char **filename, int log_offset, void *log_ctx); + +#endif /* AVUTIL_FILE_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/frame.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/frame.h new file mode 100644 index 0000000..a4d4303 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/frame.h @@ -0,0 +1,672 @@ +/* + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_FRAME_H +#define AVUTIL_FRAME_H + +#include + +#include "libavcodec/version.h" + +#include "avutil.h" +#include "buffer.h" +#include "dict.h" +#include "rational.h" +#include "samplefmt.h" + +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_BT2020_NCL = 9, ///< ITU-R BT2020 non-constant luminance system + AVCOL_SPC_BT2020_CL = 10, ///< ITU-R BT2020 constant luminance system + 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 +}; + + +enum AVFrameSideDataType { + /** + * The data is the AVPanScan struct defined in libavcodec. + */ + AV_FRAME_DATA_PANSCAN, +}; + +typedef struct AVFrameSideData { + enum AVFrameSideDataType type; + uint8_t *data; + int size; + AVDictionary *metadata; +} AVFrameSideData; + +/** + * This structure describes decoded (raw) audio or video data. + * + * AVFrame must be allocated using av_frame_alloc(). Note that this only + * allocates the AVFrame itself, the buffers for the data must be managed + * through other means (see below). + * AVFrame must be freed with av_frame_free(). + * + * AVFrame is typically allocated once and then reused multiple times to hold + * different data (e.g. a single AVFrame to hold frames received from a + * decoder). In such a case, av_frame_unref() will free any references held by + * the frame and reset it to its original clean state before it + * is reused again. + * + * The data described by an AVFrame is usually reference counted through the + * AVBuffer API. The underlying buffer references are stored in AVFrame.buf / + * AVFrame.extended_buf. An AVFrame is considered to be reference counted if at + * least one reference is set, i.e. if AVFrame.buf[0] != NULL. In such a case, + * every single data plane must be contained in one of the buffers in + * AVFrame.buf or AVFrame.extended_buf. + * There may be a single buffer for all the data, or one separate buffer for + * each plane, or anything in between. + * + * sizeof(AVFrame) is not a part of the public ABI, so new fields may be added + * to the end with a minor bump. + * Similarly fields that are marked as to be only accessed by + * av_opt_ptr() can be reordered. This allows 2 forks to add fields + * without breaking compatibility with each other. + */ +typedef struct AVFrame { +#define AV_NUM_DATA_POINTERS 8 + /** + * pointer to the picture/channel planes. + * This might be different from the first allocated byte + * + * Some decoders access areas outside 0,0 - width,height, please + * see avcodec_align_dimensions2(). Some filters and swscale can read + * up to 16 bytes beyond the planes, if these filters are to be used, + * then 16 extra bytes must be allocated. + */ + uint8_t *data[AV_NUM_DATA_POINTERS]; + + /** + * For video, size in bytes of each picture line. + * For audio, size in bytes of each plane. + * + * For audio, only linesize[0] may be set. For planar audio, each channel + * plane must be the same size. + * + * For video the linesizes should be multiplies of the CPUs alignment + * preference, this is 16 or 32 for modern desktop CPUs. + * Some code requires such alignment other code can be slower without + * correct alignment, for yet other it makes no difference. + * + * @note The linesize may be larger than the size of usable data -- there + * may be extra padding present for performance reasons. + */ + int linesize[AV_NUM_DATA_POINTERS]; + + /** + * pointers to the data planes/channels. + * + * For video, this should simply point to data[]. + * + * For planar audio, each channel has a separate data pointer, and + * linesize[0] contains the size of each channel buffer. + * For packed audio, there is just one data pointer, and linesize[0] + * contains the total size of the buffer for all channels. + * + * Note: Both data and extended_data should always be set in a valid frame, + * but for planar audio with more channels that can fit in data, + * extended_data must be used in order to access all channels. + */ + uint8_t **extended_data; + + /** + * width and height of the video frame + */ + int width, height; + + /** + * number of audio samples (per channel) described by this frame + */ + int nb_samples; + + /** + * format of the frame, -1 if unknown or unset + * Values correspond to enum AVPixelFormat for video frames, + * enum AVSampleFormat for audio) + */ + int format; + + /** + * 1 -> keyframe, 0-> not + */ + int key_frame; + + /** + * Picture type of the frame. + */ + enum AVPictureType pict_type; + +#if FF_API_AVFRAME_LAVC + attribute_deprecated + uint8_t *base[AV_NUM_DATA_POINTERS]; +#endif + + /** + * Sample aspect ratio for the video frame, 0/1 if unknown/unspecified. + */ + AVRational sample_aspect_ratio; + + /** + * Presentation timestamp in time_base units (time when frame should be shown to user). + */ + int64_t pts; + + /** + * PTS copied from the AVPacket that was decoded to produce this frame. + */ + int64_t pkt_pts; + + /** + * DTS copied from the AVPacket that triggered returning this frame. (if frame threading isnt used) + * This is also the Presentation time of this AVFrame calculated from + * only AVPacket.dts values without pts values. + */ + int64_t pkt_dts; + + /** + * picture number in bitstream order + */ + int coded_picture_number; + /** + * picture number in display order + */ + int display_picture_number; + + /** + * quality (between 1 (good) and FF_LAMBDA_MAX (bad)) + */ + int quality; + +#if FF_API_AVFRAME_LAVC + attribute_deprecated + int reference; + + /** + * QP table + */ + attribute_deprecated + int8_t *qscale_table; + /** + * QP store stride + */ + attribute_deprecated + int qstride; + + attribute_deprecated + int qscale_type; + + /** + * mbskip_table[mb]>=1 if MB didn't change + * stride= mb_width = (width+15)>>4 + */ + attribute_deprecated + uint8_t *mbskip_table; + + /** + * motion vector table + * @code + * example: + * int mv_sample_log2= 4 - motion_subsample_log2; + * int mb_width= (width+15)>>4; + * int mv_stride= (mb_width << mv_sample_log2) + 1; + * motion_val[direction][x + y*mv_stride][0->mv_x, 1->mv_y]; + * @endcode + */ + attribute_deprecated + int16_t (*motion_val[2])[2]; + + /** + * macroblock type table + * mb_type_base + mb_width + 2 + */ + attribute_deprecated + uint32_t *mb_type; + + /** + * DCT coefficients + */ + attribute_deprecated + short *dct_coeff; + + /** + * motion reference frame index + * the order in which these are stored can depend on the codec. + */ + attribute_deprecated + int8_t *ref_index[2]; +#endif + + /** + * for some private data of the user + */ + void *opaque; + + /** + * error + */ + uint64_t error[AV_NUM_DATA_POINTERS]; + +#if FF_API_AVFRAME_LAVC + attribute_deprecated + int type; +#endif + + /** + * When decoding, this signals how much the picture must be delayed. + * extra_delay = repeat_pict / (2*fps) + */ + int repeat_pict; + + /** + * The content of the picture is interlaced. + */ + int interlaced_frame; + + /** + * If the content is interlaced, is top field displayed first. + */ + int top_field_first; + + /** + * Tell user application that palette has changed from previous frame. + */ + int palette_has_changed; + +#if FF_API_AVFRAME_LAVC + attribute_deprecated + int buffer_hints; + + /** + * Pan scan. + */ + attribute_deprecated + struct AVPanScan *pan_scan; +#endif + + /** + * reordered opaque 64bit (generally an integer or a double precision float + * PTS but can be anything). + * The user sets AVCodecContext.reordered_opaque to represent the input at + * that time, + * the decoder reorders values as needed and sets AVFrame.reordered_opaque + * to exactly one of the values provided by the user through AVCodecContext.reordered_opaque + * @deprecated in favor of pkt_pts + */ + int64_t reordered_opaque; + +#if FF_API_AVFRAME_LAVC + /** + * @deprecated this field is unused + */ + attribute_deprecated void *hwaccel_picture_private; + + attribute_deprecated + struct AVCodecContext *owner; + attribute_deprecated + void *thread_opaque; + + /** + * log2 of the size of the block which a single vector in motion_val represents: + * (4->16x16, 3->8x8, 2-> 4x4, 1-> 2x2) + */ + attribute_deprecated + uint8_t motion_subsample_log2; +#endif + + /** + * Sample rate of the audio data. + */ + int sample_rate; + + /** + * Channel layout of the audio data. + */ + uint64_t channel_layout; + + /** + * AVBuffer references backing the data for this frame. If all elements of + * this array are NULL, then this frame is not reference counted. + * + * There may be at most one AVBuffer per data plane, so for video this array + * always contains all the references. For planar audio with more than + * AV_NUM_DATA_POINTERS channels, there may be more buffers than can fit in + * this array. Then the extra AVBufferRef pointers are stored in the + * extended_buf array. + */ + AVBufferRef *buf[AV_NUM_DATA_POINTERS]; + + /** + * For planar audio which requires more than AV_NUM_DATA_POINTERS + * AVBufferRef pointers, this array will hold all the references which + * cannot fit into AVFrame.buf. + * + * Note that this is different from AVFrame.extended_data, which always + * contains all the pointers. This array only contains the extra pointers, + * which cannot fit into AVFrame.buf. + * + * This array is always allocated using av_malloc() by whoever constructs + * the frame. It is freed in av_frame_unref(). + */ + AVBufferRef **extended_buf; + /** + * Number of elements in extended_buf. + */ + int nb_extended_buf; + + AVFrameSideData **side_data; + int nb_side_data; + +/** + * The frame data may be corrupted, e.g. due to decoding errors. + */ +#define AV_FRAME_FLAG_CORRUPT (1 << 0) + + /** + * Frame flags, a combination of AV_FRAME_FLAG_* + */ + int flags; + + /** + * frame timestamp estimated using various heuristics, in stream time base + * Code outside libavcodec should access this field using: + * av_frame_get_best_effort_timestamp(frame) + * - encoding: unused + * - decoding: set by libavcodec, read by user. + */ + int64_t best_effort_timestamp; + + /** + * reordered pos from the last AVPacket that has been input into the decoder + * Code outside libavcodec should access this field using: + * av_frame_get_pkt_pos(frame) + * - encoding: unused + * - decoding: Read by user. + */ + int64_t pkt_pos; + + /** + * duration of the corresponding packet, expressed in + * AVStream->time_base units, 0 if unknown. + * Code outside libavcodec should access this field using: + * av_frame_get_pkt_duration(frame) + * - encoding: unused + * - decoding: Read by user. + */ + int64_t pkt_duration; + + /** + * metadata. + * Code outside libavcodec should access this field using: + * av_frame_get_metadata(frame) + * - encoding: Set by user. + * - decoding: Set by libavcodec. + */ + AVDictionary *metadata; + + /** + * decode error flags of the frame, set to a combination of + * FF_DECODE_ERROR_xxx flags if the decoder produced a frame, but there + * were errors during the decoding. + * Code outside libavcodec should access this field using: + * av_frame_get_decode_error_flags(frame) + * - encoding: unused + * - decoding: set by libavcodec, read by user. + */ + int decode_error_flags; +#define FF_DECODE_ERROR_INVALID_BITSTREAM 1 +#define FF_DECODE_ERROR_MISSING_REFERENCE 2 + + /** + * number of audio channels, only used for audio. + * Code outside libavcodec should access this field using: + * av_frame_get_channels(frame) + * - encoding: unused + * - decoding: Read by user. + */ + int channels; + + /** + * size of the corresponding packet containing the compressed + * frame. It must be accessed using av_frame_get_pkt_size() and + * av_frame_set_pkt_size(). + * It is set to a negative value if unknown. + * - encoding: unused + * - decoding: set by libavcodec, read by user. + */ + int pkt_size; + + /** + * YUV colorspace type. + * It must be accessed using av_frame_get_colorspace() and + * av_frame_set_colorspace(). + * - encoding: Set by user + * - decoding: Set by libavcodec + */ + enum AVColorSpace colorspace; + + /** + * MPEG vs JPEG YUV range. + * It must be accessed using av_frame_get_color_range() and + * av_frame_set_color_range(). + * - encoding: Set by user + * - decoding: Set by libavcodec + */ + enum AVColorRange color_range; + + + /** + * Not to be accessed directly from outside libavutil + */ + AVBufferRef *qp_table_buf; +} AVFrame; + +/** + * Accessors for some AVFrame fields. + * The position of these field in the structure is not part of the ABI, + * they should not be accessed directly outside libavcodec. + */ +int64_t av_frame_get_best_effort_timestamp(const AVFrame *frame); +void av_frame_set_best_effort_timestamp(AVFrame *frame, int64_t val); +int64_t av_frame_get_pkt_duration (const AVFrame *frame); +void av_frame_set_pkt_duration (AVFrame *frame, int64_t val); +int64_t av_frame_get_pkt_pos (const AVFrame *frame); +void av_frame_set_pkt_pos (AVFrame *frame, int64_t val); +int64_t av_frame_get_channel_layout (const AVFrame *frame); +void av_frame_set_channel_layout (AVFrame *frame, int64_t val); +int av_frame_get_channels (const AVFrame *frame); +void av_frame_set_channels (AVFrame *frame, int val); +int av_frame_get_sample_rate (const AVFrame *frame); +void av_frame_set_sample_rate (AVFrame *frame, int val); +AVDictionary *av_frame_get_metadata (const AVFrame *frame); +void av_frame_set_metadata (AVFrame *frame, AVDictionary *val); +int av_frame_get_decode_error_flags (const AVFrame *frame); +void av_frame_set_decode_error_flags (AVFrame *frame, int val); +int av_frame_get_pkt_size(const AVFrame *frame); +void av_frame_set_pkt_size(AVFrame *frame, int val); +AVDictionary **avpriv_frame_get_metadatap(AVFrame *frame); +int8_t *av_frame_get_qp_table(AVFrame *f, int *stride, int *type); +int av_frame_set_qp_table(AVFrame *f, AVBufferRef *buf, int stride, int type); +enum AVColorSpace av_frame_get_colorspace(const AVFrame *frame); +void av_frame_set_colorspace(AVFrame *frame, enum AVColorSpace val); +enum AVColorRange av_frame_get_color_range(const AVFrame *frame); +void av_frame_set_color_range(AVFrame *frame, enum AVColorRange val); + +/** + * Get the name of a colorspace. + * @return a static string identifying the colorspace; can be NULL. + */ +const char *av_get_colorspace_name(enum AVColorSpace val); + +/** + * Allocate an AVFrame and set its fields to default values. The resulting + * struct must be freed using av_frame_free(). + * + * @return An AVFrame filled with default values or NULL on failure. + * + * @note this only allocates the AVFrame itself, not the data buffers. Those + * must be allocated through other means, e.g. with av_frame_get_buffer() or + * manually. + */ +AVFrame *av_frame_alloc(void); + +/** + * Free the frame and any dynamically allocated objects in it, + * e.g. extended_data. If the frame is reference counted, it will be + * unreferenced first. + * + * @param frame frame to be freed. The pointer will be set to NULL. + */ +void av_frame_free(AVFrame **frame); + +/** + * Setup a new reference to the data described by a given frame. + * + * Copy frame properties from src to dst and create a new reference for each + * AVBufferRef from src. + * + * If src is not reference counted, new buffers are allocated and the data is + * copied. + * + * @return 0 on success, a negative AVERROR on error + */ +int av_frame_ref(AVFrame *dst, const AVFrame *src); + +/** + * Create a new frame that references the same data as src. + * + * This is a shortcut for av_frame_alloc()+av_frame_ref(). + * + * @return newly created AVFrame on success, NULL on error. + */ +AVFrame *av_frame_clone(const AVFrame *src); + +/** + * Unreference all the buffers referenced by frame and reset the frame fields. + */ +void av_frame_unref(AVFrame *frame); + +/** + * Move everythnig contained in src to dst and reset src. + */ +void av_frame_move_ref(AVFrame *dst, AVFrame *src); + +/** + * Allocate new buffer(s) for audio or video data. + * + * The following fields must be set on frame before calling this function: + * - format (pixel format for video, sample format for audio) + * - width and height for video + * - nb_samples and channel_layout for audio + * + * This function will fill AVFrame.data and AVFrame.buf arrays and, if + * necessary, allocate and fill AVFrame.extended_data and AVFrame.extended_buf. + * For planar formats, one buffer will be allocated for each plane. + * + * @param frame frame in which to store the new buffers. + * @param align required buffer size alignment + * + * @return 0 on success, a negative AVERROR on error. + */ +int av_frame_get_buffer(AVFrame *frame, int align); + +/** + * Check if the frame data is writable. + * + * @return A positive value if the frame data is writable (which is true if and + * only if each of the underlying buffers has only one reference, namely the one + * stored in this frame). Return 0 otherwise. + * + * If 1 is returned the answer is valid until av_buffer_ref() is called on any + * of the underlying AVBufferRefs (e.g. through av_frame_ref() or directly). + * + * @see av_frame_make_writable(), av_buffer_is_writable() + */ +int av_frame_is_writable(AVFrame *frame); + +/** + * Ensure that the frame data is writable, avoiding data copy if possible. + * + * Do nothing if the frame is writable, allocate new buffers and copy the data + * if it is not. + * + * @return 0 on success, a negative AVERROR on error. + * + * @see av_frame_is_writable(), av_buffer_is_writable(), + * av_buffer_make_writable() + */ +int av_frame_make_writable(AVFrame *frame); + +/** + * Copy only "metadata" fields from src to dst. + * + * Metadata for the purpose of this function are those fields that do not affect + * the data layout in the buffers. E.g. pts, sample rate (for audio) or sample + * aspect ratio (for video), but not width/height or channel layout. + * Side data is also copied. + */ +int av_frame_copy_props(AVFrame *dst, const AVFrame *src); + +/** + * Get the buffer reference a given data plane is stored in. + * + * @param plane index of the data plane of interest in frame->extended_data. + * + * @return the buffer reference that contains the plane or NULL if the input + * frame is not valid. + */ +AVBufferRef *av_frame_get_plane_buffer(AVFrame *frame, int plane); + +/** + * Add a new side data to a frame. + * + * @param frame a frame to which the side data should be added + * @param type type of the added side data + * @param size size of the side data + * + * @return newly added side data on success, NULL on error + */ +AVFrameSideData *av_frame_new_side_data(AVFrame *frame, + enum AVFrameSideDataType type, + int size); + +/** + * @return a pointer to the side data of a given type on success, NULL if there + * is no side data with such type in this frame. + */ +AVFrameSideData *av_frame_get_side_data(const AVFrame *frame, + enum AVFrameSideDataType type); + +#endif /* AVUTIL_FRAME_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/hmac.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/hmac.h new file mode 100644 index 0000000..d36d4de --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/hmac.h @@ -0,0 +1,99 @@ +/* + * Copyright (C) 2012 Martin Storsjo + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_HMAC_H +#define AVUTIL_HMAC_H + +#include + +/** + * @defgroup lavu_hmac HMAC + * @ingroup lavu_crypto + * @{ + */ + +enum AVHMACType { + AV_HMAC_MD5, + AV_HMAC_SHA1, + AV_HMAC_SHA224 = 10, + AV_HMAC_SHA256, + AV_HMAC_SHA384, + AV_HMAC_SHA512, +}; + +typedef struct AVHMAC AVHMAC; + +/** + * Allocate an AVHMAC context. + * @param type The hash function used for the HMAC. + */ +AVHMAC *av_hmac_alloc(enum AVHMACType type); + +/** + * Free an AVHMAC context. + * @param ctx The context to free, may be NULL + */ +void av_hmac_free(AVHMAC *ctx); + +/** + * Initialize an AVHMAC context with an authentication key. + * @param ctx The HMAC context + * @param key The authentication key + * @param keylen The length of the key, in bytes + */ +void av_hmac_init(AVHMAC *ctx, const uint8_t *key, unsigned int keylen); + +/** + * Hash data with the HMAC. + * @param ctx The HMAC context + * @param data The data to hash + * @param len The length of the data, in bytes + */ +void av_hmac_update(AVHMAC *ctx, const uint8_t *data, unsigned int len); + +/** + * Finish hashing and output the HMAC digest. + * @param ctx The HMAC context + * @param out The output buffer to write the digest into + * @param outlen The length of the out buffer, in bytes + * @return The number of bytes written to out, or a negative error code. + */ +int av_hmac_final(AVHMAC *ctx, uint8_t *out, unsigned int outlen); + +/** + * Hash an array of data with a key. + * @param ctx The HMAC context + * @param data The data to hash + * @param len The length of the data, in bytes + * @param key The authentication key + * @param keylen The length of the key, in bytes + * @param out The output buffer to write the digest into + * @param outlen The length of the out buffer, in bytes + * @return The number of bytes written to out, or a negative error code. + */ +int av_hmac_calc(AVHMAC *ctx, const uint8_t *data, unsigned int len, + const uint8_t *key, unsigned int keylen, + uint8_t *out, unsigned int outlen); + +/** + * @} + */ + +#endif /* AVUTIL_HMAC_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/imgutils.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/imgutils.h new file mode 100644 index 0000000..ab32d66 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/imgutils.h @@ -0,0 +1,200 @@ +/* + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_IMGUTILS_H +#define AVUTIL_IMGUTILS_H + +/** + * @file + * misc image utilities + * + * @addtogroup lavu_picture + * @{ + */ + +#include "avutil.h" +#include "pixdesc.h" + +/** + * Compute the max pixel step for each plane of an image with a + * format described by pixdesc. + * + * The pixel step is the distance in bytes between the first byte of + * the group of bytes which describe a pixel component and the first + * byte of the successive group in the same plane for the same + * component. + * + * @param max_pixsteps an array which is filled with the max pixel step + * for each plane. Since a plane may contain different pixel + * components, the computed max_pixsteps[plane] is relative to the + * component in the plane with the max pixel step. + * @param max_pixstep_comps an array which is filled with the component + * for each plane which has the max pixel step. May be NULL. + */ +void av_image_fill_max_pixsteps(int max_pixsteps[4], int max_pixstep_comps[4], + const AVPixFmtDescriptor *pixdesc); + +/** + * Compute the size of an image line with format pix_fmt and width + * width for the plane plane. + * + * @return the computed size in bytes + */ +int av_image_get_linesize(enum AVPixelFormat pix_fmt, int width, int plane); + +/** + * Fill plane linesizes for an image with pixel format pix_fmt and + * width width. + * + * @param linesizes array to be filled with the linesize for each plane + * @return >= 0 in case of success, a negative error code otherwise + */ +int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width); + +/** + * Fill plane data pointers for an image with pixel format pix_fmt and + * height height. + * + * @param data pointers array to be filled with the pointer for each image plane + * @param ptr the pointer to a buffer which will contain the image + * @param linesizes the array containing the linesize for each + * plane, should be filled by av_image_fill_linesizes() + * @return the size in bytes required for the image buffer, a negative + * error code in case of failure + */ +int av_image_fill_pointers(uint8_t *data[4], enum AVPixelFormat pix_fmt, int height, + uint8_t *ptr, const int linesizes[4]); + +/** + * Allocate an image with size w and h and pixel format pix_fmt, and + * fill pointers and linesizes accordingly. + * The allocated image buffer has to be freed by using + * av_freep(&pointers[0]). + * + * @param align the value to use for buffer size alignment + * @return the size in bytes required for the image buffer, a negative + * error code in case of failure + */ +int av_image_alloc(uint8_t *pointers[4], int linesizes[4], + int w, int h, enum AVPixelFormat pix_fmt, int align); + +/** + * Copy image plane from src to dst. + * That is, copy "height" number of lines of "bytewidth" bytes each. + * The first byte of each successive line is separated by *_linesize + * bytes. + * + * bytewidth must be contained by both absolute values of dst_linesize + * and src_linesize, otherwise the function behavior is undefined. + * + * @param dst_linesize linesize for the image plane in dst + * @param src_linesize linesize for the image plane in src + */ +void av_image_copy_plane(uint8_t *dst, int dst_linesize, + const uint8_t *src, int src_linesize, + int bytewidth, int height); + +/** + * Copy image in src_data to dst_data. + * + * @param dst_linesizes linesizes for the image in dst_data + * @param src_linesizes linesizes for the image in src_data + */ +void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4], + const uint8_t *src_data[4], const int src_linesizes[4], + enum AVPixelFormat pix_fmt, int width, int height); + +/** + * Setup the data pointers and linesizes based on the specified image + * parameters and the provided array. + * + * The fields of the given image are filled in by using the src + * address which points to the image data buffer. Depending on the + * specified pixel format, one or multiple image data pointers and + * line sizes will be set. If a planar format is specified, several + * pointers will be set pointing to the different picture planes and + * the line sizes of the different planes will be stored in the + * lines_sizes array. Call with src == NULL to get the required + * size for the src buffer. + * + * To allocate the buffer and fill in the dst_data and dst_linesize in + * one call, use av_image_alloc(). + * + * @param dst_data data pointers to be filled in + * @param dst_linesizes linesizes for the image in dst_data to be filled in + * @param src buffer which will contain or contains the actual image data, can be NULL + * @param pix_fmt the pixel format of the image + * @param width the width of the image in pixels + * @param height the height of the image in pixels + * @param align the value used in src for linesize alignment + * @return the size in bytes required for src, a negative error code + * in case of failure + */ +int av_image_fill_arrays(uint8_t *dst_data[4], int dst_linesize[4], + const uint8_t *src, + enum AVPixelFormat pix_fmt, int width, int height, int align); + +/** + * Return the size in bytes of the amount of data required to store an + * image with the given parameters. + * + * @param[in] align the assumed linesize alignment + */ +int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align); + +/** + * Copy image data from an image into a buffer. + * + * av_image_get_buffer_size() can be used to compute the required size + * for the buffer to fill. + * + * @param dst a buffer into which picture data will be copied + * @param dst_size the size in bytes of dst + * @param src_data pointers containing the source image data + * @param src_linesizes linesizes for the image in src_data + * @param pix_fmt the pixel format of the source image + * @param width the width of the source image in pixels + * @param height the height of the source image in pixels + * @param align the assumed linesize alignment for dst + * @return the number of bytes written to dst, or a negative value + * (error code) on error + */ +int av_image_copy_to_buffer(uint8_t *dst, int dst_size, + const uint8_t * const src_data[4], const int src_linesize[4], + enum AVPixelFormat pix_fmt, int width, int height, int align); + +/** + * Check if the given dimension of an image is valid, meaning that all + * bytes of the image can be addressed with a signed int. + * + * @param w the width of the picture + * @param h the height of the picture + * @param log_offset the offset to sum to the log level for logging with log_ctx + * @param log_ctx the parent logging context, it may be NULL + * @return >= 0 if valid, a negative error code otherwise + */ +int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx); + +int avpriv_set_systematic_pal2(uint32_t pal[256], enum AVPixelFormat pix_fmt); + +/** + * @} + */ + + +#endif /* AVUTIL_IMGUTILS_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/intfloat.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/intfloat.h new file mode 100644 index 0000000..fe3d7ec --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/intfloat.h @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2011 Mans Rullgard + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_INTFLOAT_H +#define AVUTIL_INTFLOAT_H + +#include +#include "attributes.h" + +union av_intfloat32 { + uint32_t i; + float f; +}; + +union av_intfloat64 { + uint64_t i; + double f; +}; + +/** + * Reinterpret a 32-bit integer as a float. + */ +static av_always_inline float av_int2float(uint32_t i) +{ + union av_intfloat32 v; + v.i = i; + return v.f; +} + +/** + * Reinterpret a float as a 32-bit integer. + */ +static av_always_inline uint32_t av_float2int(float f) +{ + union av_intfloat32 v; + v.f = f; + return v.i; +} + +/** + * Reinterpret a 64-bit integer as a double. + */ +static av_always_inline double av_int2double(uint64_t i) +{ + union av_intfloat64 v; + v.i = i; + return v.f; +} + +/** + * Reinterpret a double as a 64-bit integer. + */ +static av_always_inline uint64_t av_double2int(double f) +{ + union av_intfloat64 v; + v.f = f; + return v.i; +} + +#endif /* AVUTIL_INTFLOAT_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/intfloat_readwrite.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/intfloat_readwrite.h new file mode 100644 index 0000000..9709f4d --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/intfloat_readwrite.h @@ -0,0 +1,40 @@ +/* + * copyright (c) 2005 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_INTFLOAT_READWRITE_H +#define AVUTIL_INTFLOAT_READWRITE_H + +#include +#include "attributes.h" + +/* IEEE 80 bits extended float */ +typedef struct AVExtFloat { + uint8_t exponent[2]; + uint8_t mantissa[8]; +} AVExtFloat; + +attribute_deprecated double av_int2dbl(int64_t v) av_const; +attribute_deprecated float av_int2flt(int32_t v) av_const; +attribute_deprecated double av_ext2dbl(const AVExtFloat ext) av_const; +attribute_deprecated int64_t av_dbl2int(double d) av_const; +attribute_deprecated int32_t av_flt2int(float d) av_const; +attribute_deprecated AVExtFloat av_dbl2ext(double d) av_const; + +#endif /* AVUTIL_INTFLOAT_READWRITE_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/intreadwrite.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/intreadwrite.h new file mode 100644 index 0000000..7ee6977 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/intreadwrite.h @@ -0,0 +1,621 @@ +/* + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_INTREADWRITE_H +#define AVUTIL_INTREADWRITE_H + +#include +#include "libavutil/avconfig.h" +#include "attributes.h" +#include "bswap.h" + +typedef union { + uint64_t u64; + uint32_t u32[2]; + uint16_t u16[4]; + uint8_t u8 [8]; + double f64; + float f32[2]; +} av_alias av_alias64; + +typedef union { + uint32_t u32; + uint16_t u16[2]; + uint8_t u8 [4]; + float f32; +} av_alias av_alias32; + +typedef union { + uint16_t u16; + uint8_t u8 [2]; +} av_alias av_alias16; + +/* + * Arch-specific headers can provide any combination of + * AV_[RW][BLN](16|24|32|48|64) and AV_(COPY|SWAP|ZERO)(64|128) macros. + * Preprocessor symbols must be defined, even if these are implemented + * as inline functions. + */ + +#ifdef HAVE_AV_CONFIG_H + +#include "config.h" + +#if ARCH_ARM +# include "arm/intreadwrite.h" +#elif ARCH_AVR32 +# include "avr32/intreadwrite.h" +#elif ARCH_MIPS +# include "mips/intreadwrite.h" +#elif ARCH_PPC +# include "ppc/intreadwrite.h" +#elif ARCH_TOMI +# include "tomi/intreadwrite.h" +#elif ARCH_X86 +# include "x86/intreadwrite.h" +#endif + +#endif /* HAVE_AV_CONFIG_H */ + +/* + * Map AV_RNXX <-> AV_R[BL]XX for all variants provided by per-arch headers. + */ + +#if AV_HAVE_BIGENDIAN + +# if defined(AV_RN16) && !defined(AV_RB16) +# define AV_RB16(p) AV_RN16(p) +# elif !defined(AV_RN16) && defined(AV_RB16) +# define AV_RN16(p) AV_RB16(p) +# endif + +# if defined(AV_WN16) && !defined(AV_WB16) +# define AV_WB16(p, v) AV_WN16(p, v) +# elif !defined(AV_WN16) && defined(AV_WB16) +# define AV_WN16(p, v) AV_WB16(p, v) +# endif + +# if defined(AV_RN24) && !defined(AV_RB24) +# define AV_RB24(p) AV_RN24(p) +# elif !defined(AV_RN24) && defined(AV_RB24) +# define AV_RN24(p) AV_RB24(p) +# endif + +# if defined(AV_WN24) && !defined(AV_WB24) +# define AV_WB24(p, v) AV_WN24(p, v) +# elif !defined(AV_WN24) && defined(AV_WB24) +# define AV_WN24(p, v) AV_WB24(p, v) +# endif + +# if defined(AV_RN32) && !defined(AV_RB32) +# define AV_RB32(p) AV_RN32(p) +# elif !defined(AV_RN32) && defined(AV_RB32) +# define AV_RN32(p) AV_RB32(p) +# endif + +# if defined(AV_WN32) && !defined(AV_WB32) +# define AV_WB32(p, v) AV_WN32(p, v) +# elif !defined(AV_WN32) && defined(AV_WB32) +# define AV_WN32(p, v) AV_WB32(p, v) +# endif + +# if defined(AV_RN48) && !defined(AV_RB48) +# define AV_RB48(p) AV_RN48(p) +# elif !defined(AV_RN48) && defined(AV_RB48) +# define AV_RN48(p) AV_RB48(p) +# endif + +# if defined(AV_WN48) && !defined(AV_WB48) +# define AV_WB48(p, v) AV_WN48(p, v) +# elif !defined(AV_WN48) && defined(AV_WB48) +# define AV_WN48(p, v) AV_WB48(p, v) +# endif + +# if defined(AV_RN64) && !defined(AV_RB64) +# define AV_RB64(p) AV_RN64(p) +# elif !defined(AV_RN64) && defined(AV_RB64) +# define AV_RN64(p) AV_RB64(p) +# endif + +# if defined(AV_WN64) && !defined(AV_WB64) +# define AV_WB64(p, v) AV_WN64(p, v) +# elif !defined(AV_WN64) && defined(AV_WB64) +# define AV_WN64(p, v) AV_WB64(p, v) +# endif + +#else /* AV_HAVE_BIGENDIAN */ + +# if defined(AV_RN16) && !defined(AV_RL16) +# define AV_RL16(p) AV_RN16(p) +# elif !defined(AV_RN16) && defined(AV_RL16) +# define AV_RN16(p) AV_RL16(p) +# endif + +# if defined(AV_WN16) && !defined(AV_WL16) +# define AV_WL16(p, v) AV_WN16(p, v) +# elif !defined(AV_WN16) && defined(AV_WL16) +# define AV_WN16(p, v) AV_WL16(p, v) +# endif + +# if defined(AV_RN24) && !defined(AV_RL24) +# define AV_RL24(p) AV_RN24(p) +# elif !defined(AV_RN24) && defined(AV_RL24) +# define AV_RN24(p) AV_RL24(p) +# endif + +# if defined(AV_WN24) && !defined(AV_WL24) +# define AV_WL24(p, v) AV_WN24(p, v) +# elif !defined(AV_WN24) && defined(AV_WL24) +# define AV_WN24(p, v) AV_WL24(p, v) +# endif + +# if defined(AV_RN32) && !defined(AV_RL32) +# define AV_RL32(p) AV_RN32(p) +# elif !defined(AV_RN32) && defined(AV_RL32) +# define AV_RN32(p) AV_RL32(p) +# endif + +# if defined(AV_WN32) && !defined(AV_WL32) +# define AV_WL32(p, v) AV_WN32(p, v) +# elif !defined(AV_WN32) && defined(AV_WL32) +# define AV_WN32(p, v) AV_WL32(p, v) +# endif + +# if defined(AV_RN48) && !defined(AV_RL48) +# define AV_RL48(p) AV_RN48(p) +# elif !defined(AV_RN48) && defined(AV_RL48) +# define AV_RN48(p) AV_RL48(p) +# endif + +# if defined(AV_WN48) && !defined(AV_WL48) +# define AV_WL48(p, v) AV_WN48(p, v) +# elif !defined(AV_WN48) && defined(AV_WL48) +# define AV_WN48(p, v) AV_WL48(p, v) +# endif + +# if defined(AV_RN64) && !defined(AV_RL64) +# define AV_RL64(p) AV_RN64(p) +# elif !defined(AV_RN64) && defined(AV_RL64) +# define AV_RN64(p) AV_RL64(p) +# endif + +# if defined(AV_WN64) && !defined(AV_WL64) +# define AV_WL64(p, v) AV_WN64(p, v) +# elif !defined(AV_WN64) && defined(AV_WL64) +# define AV_WN64(p, v) AV_WL64(p, v) +# endif + +#endif /* !AV_HAVE_BIGENDIAN */ + +/* + * Define AV_[RW]N helper macros to simplify definitions not provided + * by per-arch headers. + */ + +#if defined(__GNUC__) && !defined(__TI_COMPILER_VERSION__) + +union unaligned_64 { uint64_t l; } __attribute__((packed)) av_alias; +union unaligned_32 { uint32_t l; } __attribute__((packed)) av_alias; +union unaligned_16 { uint16_t l; } __attribute__((packed)) av_alias; + +# define AV_RN(s, p) (((const union unaligned_##s *) (p))->l) +# define AV_WN(s, p, v) ((((union unaligned_##s *) (p))->l) = (v)) + +#elif defined(__DECC) + +# define AV_RN(s, p) (*((const __unaligned uint##s##_t*)(p))) +# define AV_WN(s, p, v) (*((__unaligned uint##s##_t*)(p)) = (v)) + +#elif AV_HAVE_FAST_UNALIGNED + +# define AV_RN(s, p) (((const av_alias##s*)(p))->u##s) +# define AV_WN(s, p, v) (((av_alias##s*)(p))->u##s = (v)) + +#else + +#ifndef AV_RB16 +# define AV_RB16(x) \ + ((((const uint8_t*)(x))[0] << 8) | \ + ((const uint8_t*)(x))[1]) +#endif +#ifndef AV_WB16 +# define AV_WB16(p, darg) do { \ + unsigned d = (darg); \ + ((uint8_t*)(p))[1] = (d); \ + ((uint8_t*)(p))[0] = (d)>>8; \ + } while(0) +#endif + +#ifndef AV_RL16 +# define AV_RL16(x) \ + ((((const uint8_t*)(x))[1] << 8) | \ + ((const uint8_t*)(x))[0]) +#endif +#ifndef AV_WL16 +# define AV_WL16(p, darg) do { \ + unsigned d = (darg); \ + ((uint8_t*)(p))[0] = (d); \ + ((uint8_t*)(p))[1] = (d)>>8; \ + } while(0) +#endif + +#ifndef AV_RB32 +# define AV_RB32(x) \ + (((uint32_t)((const uint8_t*)(x))[0] << 24) | \ + (((const uint8_t*)(x))[1] << 16) | \ + (((const uint8_t*)(x))[2] << 8) | \ + ((const uint8_t*)(x))[3]) +#endif +#ifndef AV_WB32 +# define AV_WB32(p, darg) do { \ + unsigned d = (darg); \ + ((uint8_t*)(p))[3] = (d); \ + ((uint8_t*)(p))[2] = (d)>>8; \ + ((uint8_t*)(p))[1] = (d)>>16; \ + ((uint8_t*)(p))[0] = (d)>>24; \ + } while(0) +#endif + +#ifndef AV_RL32 +# define AV_RL32(x) \ + (((uint32_t)((const uint8_t*)(x))[3] << 24) | \ + (((const uint8_t*)(x))[2] << 16) | \ + (((const uint8_t*)(x))[1] << 8) | \ + ((const uint8_t*)(x))[0]) +#endif +#ifndef AV_WL32 +# define AV_WL32(p, darg) do { \ + unsigned d = (darg); \ + ((uint8_t*)(p))[0] = (d); \ + ((uint8_t*)(p))[1] = (d)>>8; \ + ((uint8_t*)(p))[2] = (d)>>16; \ + ((uint8_t*)(p))[3] = (d)>>24; \ + } while(0) +#endif + +#ifndef AV_RB64 +# define AV_RB64(x) \ + (((uint64_t)((const uint8_t*)(x))[0] << 56) | \ + ((uint64_t)((const uint8_t*)(x))[1] << 48) | \ + ((uint64_t)((const uint8_t*)(x))[2] << 40) | \ + ((uint64_t)((const uint8_t*)(x))[3] << 32) | \ + ((uint64_t)((const uint8_t*)(x))[4] << 24) | \ + ((uint64_t)((const uint8_t*)(x))[5] << 16) | \ + ((uint64_t)((const uint8_t*)(x))[6] << 8) | \ + (uint64_t)((const uint8_t*)(x))[7]) +#endif +#ifndef AV_WB64 +# define AV_WB64(p, darg) do { \ + uint64_t d = (darg); \ + ((uint8_t*)(p))[7] = (d); \ + ((uint8_t*)(p))[6] = (d)>>8; \ + ((uint8_t*)(p))[5] = (d)>>16; \ + ((uint8_t*)(p))[4] = (d)>>24; \ + ((uint8_t*)(p))[3] = (d)>>32; \ + ((uint8_t*)(p))[2] = (d)>>40; \ + ((uint8_t*)(p))[1] = (d)>>48; \ + ((uint8_t*)(p))[0] = (d)>>56; \ + } while(0) +#endif + +#ifndef AV_RL64 +# define AV_RL64(x) \ + (((uint64_t)((const uint8_t*)(x))[7] << 56) | \ + ((uint64_t)((const uint8_t*)(x))[6] << 48) | \ + ((uint64_t)((const uint8_t*)(x))[5] << 40) | \ + ((uint64_t)((const uint8_t*)(x))[4] << 32) | \ + ((uint64_t)((const uint8_t*)(x))[3] << 24) | \ + ((uint64_t)((const uint8_t*)(x))[2] << 16) | \ + ((uint64_t)((const uint8_t*)(x))[1] << 8) | \ + (uint64_t)((const uint8_t*)(x))[0]) +#endif +#ifndef AV_WL64 +# define AV_WL64(p, darg) do { \ + uint64_t d = (darg); \ + ((uint8_t*)(p))[0] = (d); \ + ((uint8_t*)(p))[1] = (d)>>8; \ + ((uint8_t*)(p))[2] = (d)>>16; \ + ((uint8_t*)(p))[3] = (d)>>24; \ + ((uint8_t*)(p))[4] = (d)>>32; \ + ((uint8_t*)(p))[5] = (d)>>40; \ + ((uint8_t*)(p))[6] = (d)>>48; \ + ((uint8_t*)(p))[7] = (d)>>56; \ + } while(0) +#endif + +#if AV_HAVE_BIGENDIAN +# define AV_RN(s, p) AV_RB##s(p) +# define AV_WN(s, p, v) AV_WB##s(p, v) +#else +# define AV_RN(s, p) AV_RL##s(p) +# define AV_WN(s, p, v) AV_WL##s(p, v) +#endif + +#endif /* HAVE_FAST_UNALIGNED */ + +#ifndef AV_RN16 +# define AV_RN16(p) AV_RN(16, p) +#endif + +#ifndef AV_RN32 +# define AV_RN32(p) AV_RN(32, p) +#endif + +#ifndef AV_RN64 +# define AV_RN64(p) AV_RN(64, p) +#endif + +#ifndef AV_WN16 +# define AV_WN16(p, v) AV_WN(16, p, v) +#endif + +#ifndef AV_WN32 +# define AV_WN32(p, v) AV_WN(32, p, v) +#endif + +#ifndef AV_WN64 +# define AV_WN64(p, v) AV_WN(64, p, v) +#endif + +#if AV_HAVE_BIGENDIAN +# define AV_RB(s, p) AV_RN##s(p) +# define AV_WB(s, p, v) AV_WN##s(p, v) +# define AV_RL(s, p) av_bswap##s(AV_RN##s(p)) +# define AV_WL(s, p, v) AV_WN##s(p, av_bswap##s(v)) +#else +# define AV_RB(s, p) av_bswap##s(AV_RN##s(p)) +# define AV_WB(s, p, v) AV_WN##s(p, av_bswap##s(v)) +# define AV_RL(s, p) AV_RN##s(p) +# define AV_WL(s, p, v) AV_WN##s(p, v) +#endif + +#define AV_RB8(x) (((const uint8_t*)(x))[0]) +#define AV_WB8(p, d) do { ((uint8_t*)(p))[0] = (d); } while(0) + +#define AV_RL8(x) AV_RB8(x) +#define AV_WL8(p, d) AV_WB8(p, d) + +#ifndef AV_RB16 +# define AV_RB16(p) AV_RB(16, p) +#endif +#ifndef AV_WB16 +# define AV_WB16(p, v) AV_WB(16, p, v) +#endif + +#ifndef AV_RL16 +# define AV_RL16(p) AV_RL(16, p) +#endif +#ifndef AV_WL16 +# define AV_WL16(p, v) AV_WL(16, p, v) +#endif + +#ifndef AV_RB32 +# define AV_RB32(p) AV_RB(32, p) +#endif +#ifndef AV_WB32 +# define AV_WB32(p, v) AV_WB(32, p, v) +#endif + +#ifndef AV_RL32 +# define AV_RL32(p) AV_RL(32, p) +#endif +#ifndef AV_WL32 +# define AV_WL32(p, v) AV_WL(32, p, v) +#endif + +#ifndef AV_RB64 +# define AV_RB64(p) AV_RB(64, p) +#endif +#ifndef AV_WB64 +# define AV_WB64(p, v) AV_WB(64, p, v) +#endif + +#ifndef AV_RL64 +# define AV_RL64(p) AV_RL(64, p) +#endif +#ifndef AV_WL64 +# define AV_WL64(p, v) AV_WL(64, p, v) +#endif + +#ifndef AV_RB24 +# define AV_RB24(x) \ + ((((const uint8_t*)(x))[0] << 16) | \ + (((const uint8_t*)(x))[1] << 8) | \ + ((const uint8_t*)(x))[2]) +#endif +#ifndef AV_WB24 +# define AV_WB24(p, d) do { \ + ((uint8_t*)(p))[2] = (d); \ + ((uint8_t*)(p))[1] = (d)>>8; \ + ((uint8_t*)(p))[0] = (d)>>16; \ + } while(0) +#endif + +#ifndef AV_RL24 +# define AV_RL24(x) \ + ((((const uint8_t*)(x))[2] << 16) | \ + (((const uint8_t*)(x))[1] << 8) | \ + ((const uint8_t*)(x))[0]) +#endif +#ifndef AV_WL24 +# define AV_WL24(p, d) do { \ + ((uint8_t*)(p))[0] = (d); \ + ((uint8_t*)(p))[1] = (d)>>8; \ + ((uint8_t*)(p))[2] = (d)>>16; \ + } while(0) +#endif + +#ifndef AV_RB48 +# define AV_RB48(x) \ + (((uint64_t)((const uint8_t*)(x))[0] << 40) | \ + ((uint64_t)((const uint8_t*)(x))[1] << 32) | \ + ((uint64_t)((const uint8_t*)(x))[2] << 24) | \ + ((uint64_t)((const uint8_t*)(x))[3] << 16) | \ + ((uint64_t)((const uint8_t*)(x))[4] << 8) | \ + (uint64_t)((const uint8_t*)(x))[5]) +#endif +#ifndef AV_WB48 +# define AV_WB48(p, darg) do { \ + uint64_t d = (darg); \ + ((uint8_t*)(p))[5] = (d); \ + ((uint8_t*)(p))[4] = (d)>>8; \ + ((uint8_t*)(p))[3] = (d)>>16; \ + ((uint8_t*)(p))[2] = (d)>>24; \ + ((uint8_t*)(p))[1] = (d)>>32; \ + ((uint8_t*)(p))[0] = (d)>>40; \ + } while(0) +#endif + +#ifndef AV_RL48 +# define AV_RL48(x) \ + (((uint64_t)((const uint8_t*)(x))[5] << 40) | \ + ((uint64_t)((const uint8_t*)(x))[4] << 32) | \ + ((uint64_t)((const uint8_t*)(x))[3] << 24) | \ + ((uint64_t)((const uint8_t*)(x))[2] << 16) | \ + ((uint64_t)((const uint8_t*)(x))[1] << 8) | \ + (uint64_t)((const uint8_t*)(x))[0]) +#endif +#ifndef AV_WL48 +# define AV_WL48(p, darg) do { \ + uint64_t d = (darg); \ + ((uint8_t*)(p))[0] = (d); \ + ((uint8_t*)(p))[1] = (d)>>8; \ + ((uint8_t*)(p))[2] = (d)>>16; \ + ((uint8_t*)(p))[3] = (d)>>24; \ + ((uint8_t*)(p))[4] = (d)>>32; \ + ((uint8_t*)(p))[5] = (d)>>40; \ + } while(0) +#endif + +/* + * The AV_[RW]NA macros access naturally aligned data + * in a type-safe way. + */ + +#define AV_RNA(s, p) (((const av_alias##s*)(p))->u##s) +#define AV_WNA(s, p, v) (((av_alias##s*)(p))->u##s = (v)) + +#ifndef AV_RN16A +# define AV_RN16A(p) AV_RNA(16, p) +#endif + +#ifndef AV_RN32A +# define AV_RN32A(p) AV_RNA(32, p) +#endif + +#ifndef AV_RN64A +# define AV_RN64A(p) AV_RNA(64, p) +#endif + +#ifndef AV_WN16A +# define AV_WN16A(p, v) AV_WNA(16, p, v) +#endif + +#ifndef AV_WN32A +# define AV_WN32A(p, v) AV_WNA(32, p, v) +#endif + +#ifndef AV_WN64A +# define AV_WN64A(p, v) AV_WNA(64, p, v) +#endif + +/* + * The AV_COPYxxU macros are suitable for copying data to/from unaligned + * memory locations. + */ + +#define AV_COPYU(n, d, s) AV_WN##n(d, AV_RN##n(s)); + +#ifndef AV_COPY16U +# define AV_COPY16U(d, s) AV_COPYU(16, d, s) +#endif + +#ifndef AV_COPY32U +# define AV_COPY32U(d, s) AV_COPYU(32, d, s) +#endif + +#ifndef AV_COPY64U +# define AV_COPY64U(d, s) AV_COPYU(64, d, s) +#endif + +#ifndef AV_COPY128U +# define AV_COPY128U(d, s) \ + do { \ + AV_COPY64U(d, s); \ + AV_COPY64U((char *)(d) + 8, (const char *)(s) + 8); \ + } while(0) +#endif + +/* Parameters for AV_COPY*, AV_SWAP*, AV_ZERO* must be + * naturally aligned. They may be implemented using MMX, + * so emms_c() must be called before using any float code + * afterwards. + */ + +#define AV_COPY(n, d, s) \ + (((av_alias##n*)(d))->u##n = ((const av_alias##n*)(s))->u##n) + +#ifndef AV_COPY16 +# define AV_COPY16(d, s) AV_COPY(16, d, s) +#endif + +#ifndef AV_COPY32 +# define AV_COPY32(d, s) AV_COPY(32, d, s) +#endif + +#ifndef AV_COPY64 +# define AV_COPY64(d, s) AV_COPY(64, d, s) +#endif + +#ifndef AV_COPY128 +# define AV_COPY128(d, s) \ + do { \ + AV_COPY64(d, s); \ + AV_COPY64((char*)(d)+8, (char*)(s)+8); \ + } while(0) +#endif + +#define AV_SWAP(n, a, b) FFSWAP(av_alias##n, *(av_alias##n*)(a), *(av_alias##n*)(b)) + +#ifndef AV_SWAP64 +# define AV_SWAP64(a, b) AV_SWAP(64, a, b) +#endif + +#define AV_ZERO(n, d) (((av_alias##n*)(d))->u##n = 0) + +#ifndef AV_ZERO16 +# define AV_ZERO16(d) AV_ZERO(16, d) +#endif + +#ifndef AV_ZERO32 +# define AV_ZERO32(d) AV_ZERO(32, d) +#endif + +#ifndef AV_ZERO64 +# define AV_ZERO64(d) AV_ZERO(64, d) +#endif + +#ifndef AV_ZERO128 +# define AV_ZERO128(d) \ + do { \ + AV_ZERO64(d); \ + AV_ZERO64((char*)(d)+8); \ + } while(0) +#endif + +#endif /* AVUTIL_INTREADWRITE_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/lfg.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/lfg.h new file mode 100644 index 0000000..ec90562 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/lfg.h @@ -0,0 +1,62 @@ +/* + * Lagged Fibonacci PRNG + * Copyright (c) 2008 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_LFG_H +#define AVUTIL_LFG_H + +typedef struct AVLFG { + unsigned int state[64]; + int index; +} AVLFG; + +void av_lfg_init(AVLFG *c, unsigned int seed); + +/** + * Get the next random unsigned 32-bit number using an ALFG. + * + * Please also consider a simple LCG like state= state*1664525+1013904223, + * it may be good enough and faster for your specific use case. + */ +static inline unsigned int av_lfg_get(AVLFG *c){ + c->state[c->index & 63] = c->state[(c->index-24) & 63] + c->state[(c->index-55) & 63]; + return c->state[c->index++ & 63]; +} + +/** + * Get the next random unsigned 32-bit number using a MLFG. + * + * Please also consider av_lfg_get() above, it is faster. + */ +static inline unsigned int av_mlfg_get(AVLFG *c){ + unsigned int a= c->state[(c->index-55) & 63]; + unsigned int b= c->state[(c->index-24) & 63]; + return c->state[c->index++ & 63] = 2*a*b+a+b; +} + +/** + * Get the next two numbers generated by a Box-Muller Gaussian + * generator using the random numbers issued by lfg. + * + * @param out array where the two generated numbers are placed + */ +void av_bmg_get(AVLFG *lfg, double out[2]); + +#endif /* AVUTIL_LFG_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/log.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/log.h new file mode 100644 index 0000000..55459e8 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/log.h @@ -0,0 +1,313 @@ +/* + * copyright (c) 2006 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_LOG_H +#define AVUTIL_LOG_H + +#include +#include "avutil.h" +#include "attributes.h" + +typedef enum { + AV_CLASS_CATEGORY_NA = 0, + AV_CLASS_CATEGORY_INPUT, + AV_CLASS_CATEGORY_OUTPUT, + AV_CLASS_CATEGORY_MUXER, + AV_CLASS_CATEGORY_DEMUXER, + AV_CLASS_CATEGORY_ENCODER, + AV_CLASS_CATEGORY_DECODER, + AV_CLASS_CATEGORY_FILTER, + AV_CLASS_CATEGORY_BITSTREAM_FILTER, + AV_CLASS_CATEGORY_SWSCALER, + AV_CLASS_CATEGORY_SWRESAMPLER, + AV_CLASS_CATEGORY_NB, ///< not part of ABI/API +}AVClassCategory; + +struct AVOptionRanges; + +/** + * Describe the class of an AVClass context structure. That is an + * arbitrary struct of which the first field is a pointer to an + * AVClass struct (e.g. AVCodecContext, AVFormatContext etc.). + */ +typedef struct AVClass { + /** + * The name of the class; usually it is the same name as the + * context structure type to which the AVClass is associated. + */ + const char* class_name; + + /** + * A pointer to a function which returns the name of a context + * instance ctx associated with the class. + */ + const char* (*item_name)(void* ctx); + + /** + * a pointer to the first option specified in the class if any or NULL + * + * @see av_set_default_options() + */ + const struct AVOption *option; + + /** + * LIBAVUTIL_VERSION with which this structure was created. + * This is used to allow fields to be added without requiring major + * version bumps everywhere. + */ + + int version; + + /** + * Offset in the structure where log_level_offset is stored. + * 0 means there is no such variable + */ + int log_level_offset_offset; + + /** + * Offset in the structure where a pointer to the parent context for + * logging is stored. For example a decoder could pass its AVCodecContext + * to eval as such a parent context, which an av_log() implementation + * could then leverage to display the parent context. + * The offset can be NULL. + */ + int parent_log_context_offset; + + /** + * Return next AVOptions-enabled child or NULL + */ + void* (*child_next)(void *obj, void *prev); + + /** + * Return an AVClass corresponding to the next potential + * AVOptions-enabled child. + * + * The difference between child_next and this is that + * child_next iterates over _already existing_ objects, while + * child_class_next iterates over _all possible_ children. + */ + const struct AVClass* (*child_class_next)(const struct AVClass *prev); + + /** + * Category used for visualization (like color) + * This is only set if the category is equal for all objects using this class. + * available since version (51 << 16 | 56 << 8 | 100) + */ + AVClassCategory category; + + /** + * Callback to return the category. + * available since version (51 << 16 | 59 << 8 | 100) + */ + AVClassCategory (*get_category)(void* ctx); + + /** + * Callback to return the supported/allowed ranges. + * available since version (52.12) + */ + int (*query_ranges)(struct AVOptionRanges **, void *obj, const char *key, int flags); +} AVClass; + +/** + * @addtogroup lavu_log + * + * @{ + * + * @defgroup lavu_log_constants Logging Constants + * + * @{ + */ + +/** + * Print no output. + */ +#define AV_LOG_QUIET -8 + +/** + * Something went really wrong and we will crash now. + */ +#define AV_LOG_PANIC 0 + +/** + * Something went wrong and recovery is not possible. + * For example, no header was found for a format which depends + * on headers or an illegal combination of parameters is used. + */ +#define AV_LOG_FATAL 8 + +/** + * Something went wrong and cannot losslessly be recovered. + * However, not all future data is affected. + */ +#define AV_LOG_ERROR 16 + +/** + * Something somehow does not look correct. This may or may not + * lead to problems. An example would be the use of '-vstrict -2'. + */ +#define AV_LOG_WARNING 24 + +/** + * Standard information. + */ +#define AV_LOG_INFO 32 + +/** + * Detailed information. + */ +#define AV_LOG_VERBOSE 40 + +/** + * Stuff which is only useful for libav* developers. + */ +#define AV_LOG_DEBUG 48 + +#define AV_LOG_MAX_OFFSET (AV_LOG_DEBUG - AV_LOG_QUIET) + +/** + * @} + */ + +/** + * Send the specified message to the log if the level is less than or equal + * to the current av_log_level. By default, all logging messages are sent to + * stderr. This behavior can be altered by setting a different logging callback + * function. + * @see av_log_set_callback + * + * @param avcl A pointer to an arbitrary struct of which the first field is a + * pointer to an AVClass struct. + * @param level The importance level of the message expressed using a @ref + * lavu_log_constants "Logging Constant". + * @param fmt The format string (printf-compatible) that specifies how + * subsequent arguments are converted to output. + */ +void av_log(void *avcl, int level, const char *fmt, ...) av_printf_format(3, 4); + + +/** + * Send the specified message to the log if the level is less than or equal + * to the current av_log_level. By default, all logging messages are sent to + * stderr. This behavior can be altered by setting a different logging callback + * function. + * @see av_log_set_callback + * + * @param avcl A pointer to an arbitrary struct of which the first field is a + * pointer to an AVClass struct. + * @param level The importance level of the message expressed using a @ref + * lavu_log_constants "Logging Constant". + * @param fmt The format string (printf-compatible) that specifies how + * subsequent arguments are converted to output. + * @param vl The arguments referenced by the format string. + */ +void av_vlog(void *avcl, int level, const char *fmt, va_list vl); + +/** + * Get the current log level + * + * @see lavu_log_constants + * + * @return Current log level + */ +int av_log_get_level(void); + +/** + * Set the log level + * + * @see lavu_log_constants + * + * @param level Logging level + */ +void av_log_set_level(int level); + +/** + * Set the logging callback + * + * @note The callback must be thread safe, even if the application does not use + * threads itself as some codecs are multithreaded. + * + * @see av_log_default_callback + * + * @param callback A logging function with a compatible signature. + */ +void av_log_set_callback(void (*callback)(void*, int, const char*, va_list)); + +/** + * Default logging callback + * + * It prints the message to stderr, optionally colorizing it. + * + * @param avcl A pointer to an arbitrary struct of which the first field is a + * pointer to an AVClass struct. + * @param level The importance level of the message expressed using a @ref + * lavu_log_constants "Logging Constant". + * @param fmt The format string (printf-compatible) that specifies how + * subsequent arguments are converted to output. + * @param ap The arguments referenced by the format string. + */ +void av_log_default_callback(void* ptr, int level, const char* fmt, va_list vl); + +/** + * Return the context name + * + * @param ctx The AVClass context + * + * @return The AVClass class_name + */ +const char* av_default_item_name(void* ctx); +AVClassCategory av_default_get_category(void *ptr); + +/** + * Format a line of log the same way as the default callback. + * @param line buffer to receive the formated line + * @param line_size size of the buffer + * @param print_prefix used to store whether the prefix must be printed; + * must point to a persistent integer initially set to 1 + */ +void av_log_format_line(void *ptr, int level, const char *fmt, va_list vl, + char *line, int line_size, int *print_prefix); + +/** + * av_dlog macros + * Useful to print debug messages that shouldn't get compiled in normally. + */ + +#ifdef DEBUG +# define av_dlog(pctx, ...) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__) +#else +# define av_dlog(pctx, ...) do { if (0) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__); } while (0) +#endif + +/** + * Skip repeated messages, this requires the user app to use av_log() instead of + * (f)printf as the 2 would otherwise interfere and lead to + * "Last message repeated x times" messages below (f)printf messages with some + * bad luck. + * Also to receive the last, "last repeated" line if any, the user app must + * call av_log(NULL, AV_LOG_QUIET, "%s", ""); at the end + */ +#define AV_LOG_SKIP_REPEATED 1 +void av_log_set_flags(int arg); + +/** + * @} + */ + +#endif /* AVUTIL_LOG_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/lzo.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/lzo.h new file mode 100644 index 0000000..c034039 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/lzo.h @@ -0,0 +1,66 @@ +/* + * LZO 1x decompression + * copyright (c) 2006 Reimar Doeffinger + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_LZO_H +#define AVUTIL_LZO_H + +/** + * @defgroup lavu_lzo LZO + * @ingroup lavu_crypto + * + * @{ + */ + +#include + +/** @name Error flags returned by av_lzo1x_decode + * @{ */ +/// end of the input buffer reached before decoding finished +#define AV_LZO_INPUT_DEPLETED 1 +/// decoded data did not fit into output buffer +#define AV_LZO_OUTPUT_FULL 2 +/// a reference to previously decoded data was wrong +#define AV_LZO_INVALID_BACKPTR 4 +/// a non-specific error in the compressed bitstream +#define AV_LZO_ERROR 8 +/** @} */ + +#define AV_LZO_INPUT_PADDING 8 +#define AV_LZO_OUTPUT_PADDING 12 + +/** + * @brief Decodes LZO 1x compressed data. + * @param out output buffer + * @param outlen size of output buffer, number of bytes left are returned here + * @param in input buffer + * @param inlen size of input buffer, number of bytes left are returned here + * @return 0 on success, otherwise a combination of the error flags above + * + * Make sure all buffers are appropriately padded, in must provide + * AV_LZO_INPUT_PADDING, out must provide AV_LZO_OUTPUT_PADDING additional bytes. + */ +int av_lzo1x_decode(void *out, int *outlen, const void *in, int *inlen); + +/** + * @} + */ + +#endif /* AVUTIL_LZO_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/mathematics.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/mathematics.h new file mode 100644 index 0000000..71f0392 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/mathematics.h @@ -0,0 +1,147 @@ +/* + * copyright (c) 2005-2012 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_MATHEMATICS_H +#define AVUTIL_MATHEMATICS_H + +#include +#include +#include "attributes.h" +#include "rational.h" +#include "intfloat.h" + +#ifndef M_E +#define M_E 2.7182818284590452354 /* e */ +#endif +#ifndef M_LN2 +#define M_LN2 0.69314718055994530942 /* log_e 2 */ +#endif +#ifndef M_LN10 +#define M_LN10 2.30258509299404568402 /* log_e 10 */ +#endif +#ifndef M_LOG2_10 +#define M_LOG2_10 3.32192809488736234787 /* log_2 10 */ +#endif +#ifndef M_PHI +#define M_PHI 1.61803398874989484820 /* phi / golden ratio */ +#endif +#ifndef M_PI +#define M_PI 3.14159265358979323846 /* pi */ +#endif +#ifndef M_SQRT1_2 +#define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */ +#endif +#ifndef M_SQRT2 +#define M_SQRT2 1.41421356237309504880 /* sqrt(2) */ +#endif +#ifndef NAN +#define NAN av_int2float(0x7fc00000) +#endif +#ifndef INFINITY +#define INFINITY av_int2float(0x7f800000) +#endif + +/** + * @addtogroup lavu_math + * @{ + */ + + +enum AVRounding { + AV_ROUND_ZERO = 0, ///< Round toward zero. + AV_ROUND_INF = 1, ///< Round away from zero. + AV_ROUND_DOWN = 2, ///< Round toward -infinity. + AV_ROUND_UP = 3, ///< Round toward +infinity. + AV_ROUND_NEAR_INF = 5, ///< Round to nearest and halfway cases away from zero. + AV_ROUND_PASS_MINMAX = 8192, ///< Flag to pass INT64_MIN/MAX through instead of rescaling, this avoids special cases for AV_NOPTS_VALUE +}; + +/** + * Return the greatest common divisor of a and b. + * If both a and b are 0 or either or both are <0 then behavior is + * undefined. + */ +int64_t av_const av_gcd(int64_t a, int64_t b); + +/** + * Rescale a 64-bit integer with rounding to nearest. + * A simple a*b/c isn't possible as it can overflow. + */ +int64_t av_rescale(int64_t a, int64_t b, int64_t c) av_const; + +/** + * Rescale a 64-bit integer with specified rounding. + * A simple a*b/c isn't possible as it can overflow. + * + * @return rescaled value a, or if AV_ROUND_PASS_MINMAX is set and a is + * INT64_MIN or INT64_MAX then a is passed through unchanged. + */ +int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding) av_const; + +/** + * Rescale a 64-bit integer by 2 rational numbers. + */ +int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const; + +/** + * Rescale a 64-bit integer by 2 rational numbers with specified rounding. + * + * @return rescaled value a, or if AV_ROUND_PASS_MINMAX is set and a is + * INT64_MIN or INT64_MAX then a is passed through unchanged. + */ +int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq, + enum AVRounding) av_const; + +/** + * Compare 2 timestamps each in its own timebases. + * The result of the function is undefined if one of the timestamps + * is outside the int64_t range when represented in the others timebase. + * @return -1 if ts_a is before ts_b, 1 if ts_a is after ts_b or 0 if they represent the same position + */ +int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b); + +/** + * Compare 2 integers modulo mod. + * That is we compare integers a and b for which only the least + * significant log2(mod) bits are known. + * + * @param mod must be a power of 2 + * @return a negative value if a is smaller than b + * a positive value if a is greater than b + * 0 if a equals b + */ +int64_t av_compare_mod(uint64_t a, uint64_t b, uint64_t mod); + +/** + * Rescale a timestamp while preserving known durations. + * + * @param in_ts Input timestamp + * @param in_tb Input timesbase + * @param fs_tb Duration and *last timebase + * @param duration duration till the next call + * @param out_tb Output timesbase + */ +int64_t av_rescale_delta(AVRational in_tb, int64_t in_ts, AVRational fs_tb, int duration, int64_t *last, AVRational out_tb); + +/** + * @} + */ + +#endif /* AVUTIL_MATHEMATICS_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/md5.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/md5.h new file mode 100644 index 0000000..79702c8 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/md5.h @@ -0,0 +1,81 @@ +/* + * copyright (c) 2006 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_MD5_H +#define AVUTIL_MD5_H + +#include + +#include "attributes.h" +#include "version.h" + +/** + * @defgroup lavu_md5 MD5 + * @ingroup lavu_crypto + * @{ + */ + +extern const int av_md5_size; + +struct AVMD5; + +/** + * Allocate an AVMD5 context. + */ +struct AVMD5 *av_md5_alloc(void); + +/** + * Initialize MD5 hashing. + * + * @param ctx pointer to the function context (of size av_md5_size) + */ +void av_md5_init(struct AVMD5 *ctx); + +/** + * Update hash value. + * + * @param ctx hash function context + * @param src input data to update hash with + * @param len input data length + */ +void av_md5_update(struct AVMD5 *ctx, const uint8_t *src, int len); + +/** + * Finish hashing and output digest value. + * + * @param ctx hash function context + * @param dst buffer where output digest value is stored + */ +void av_md5_final(struct AVMD5 *ctx, uint8_t *dst); + +/** + * Hash an array of data. + * + * @param dst The output buffer to write the digest into + * @param src The data to hash + * @param len The length of the data, in bytes + */ +void av_md5_sum(uint8_t *dst, const uint8_t *src, const int len); + +/** + * @} + */ + +#endif /* AVUTIL_MD5_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/mem.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/mem.h new file mode 100644 index 0000000..703ce81 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/mem.h @@ -0,0 +1,363 @@ +/* + * copyright (c) 2006 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file + * memory handling functions + */ + +#ifndef AVUTIL_MEM_H +#define AVUTIL_MEM_H + +#include +#include + +#include "attributes.h" +#include "error.h" +#include "avutil.h" + +/** + * @addtogroup lavu_mem + * @{ + */ + + +#if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1110 || defined(__SUNPRO_C) + #define DECLARE_ALIGNED(n,t,v) t __attribute__ ((aligned (n))) v + #define DECLARE_ASM_CONST(n,t,v) const t __attribute__ ((aligned (n))) v +#elif defined(__TI_COMPILER_VERSION__) + #define DECLARE_ALIGNED(n,t,v) \ + AV_PRAGMA(DATA_ALIGN(v,n)) \ + t __attribute__((aligned(n))) v + #define DECLARE_ASM_CONST(n,t,v) \ + AV_PRAGMA(DATA_ALIGN(v,n)) \ + static const t __attribute__((aligned(n))) v +#elif defined(__GNUC__) + #define DECLARE_ALIGNED(n,t,v) t __attribute__ ((aligned (n))) v + #define DECLARE_ASM_CONST(n,t,v) static const t av_used __attribute__ ((aligned (n))) v +#elif defined(_MSC_VER) + #define DECLARE_ALIGNED(n,t,v) __declspec(align(n)) t v + #define DECLARE_ASM_CONST(n,t,v) __declspec(align(n)) static const t v +#else + #define DECLARE_ALIGNED(n,t,v) t v + #define DECLARE_ASM_CONST(n,t,v) static const t v +#endif + +#if AV_GCC_VERSION_AT_LEAST(3,1) + #define av_malloc_attrib __attribute__((__malloc__)) +#else + #define av_malloc_attrib +#endif + +#if AV_GCC_VERSION_AT_LEAST(4,3) + #define av_alloc_size(...) __attribute__((alloc_size(__VA_ARGS__))) +#else + #define av_alloc_size(...) +#endif + +/** + * Allocate a block of size bytes with alignment suitable for all + * memory accesses (including vectors if available on the CPU). + * @param size Size in bytes for the memory block to be allocated. + * @return Pointer to the allocated block, NULL if the block cannot + * be allocated. + * @see av_mallocz() + */ +void *av_malloc(size_t size) av_malloc_attrib av_alloc_size(1); + +/** + * Allocate a block of size * nmemb bytes with av_malloc(). + * @param nmemb Number of elements + * @param size Size of the single element + * @return Pointer to the allocated block, NULL if the block cannot + * be allocated. + * @see av_malloc() + */ +av_alloc_size(1, 2) static inline void *av_malloc_array(size_t nmemb, size_t size) +{ + if (!size || nmemb >= INT_MAX / size) + return NULL; + return av_malloc(nmemb * size); +} + +/** + * Allocate or reallocate a block of memory. + * If ptr is NULL and size > 0, allocate a new block. If + * size is zero, free the memory block pointed to by ptr. + * @param ptr Pointer to a memory block already allocated with + * av_realloc() or NULL. + * @param size Size in bytes of the memory block to be allocated or + * reallocated. + * @return Pointer to a newly-reallocated block or NULL if the block + * cannot be reallocated or the function is used to free the memory block. + * @warning Pointers originating from the av_malloc() family of functions must + * not be passed to av_realloc(). The former can be implemented using + * memalign() (or other functions), and there is no guarantee that + * pointers from such functions can be passed to realloc() at all. + * The situation is undefined according to POSIX and may crash with + * some libc implementations. + * @see av_fast_realloc() + */ +void *av_realloc(void *ptr, size_t size) av_alloc_size(2); + +/** + * Allocate or reallocate a block of memory. + * This function does the same thing as av_realloc, except: + * - It takes two arguments and checks the result of the multiplication for + * integer overflow. + * - It frees the input block in case of failure, thus avoiding the memory + * leak with the classic "buf = realloc(buf); if (!buf) return -1;". + */ +void *av_realloc_f(void *ptr, size_t nelem, size_t elsize); + +/** + * Allocate or reallocate a block of memory. + * If *ptr is NULL and size > 0, allocate a new block. If + * size is zero, free the memory block pointed to by ptr. + * @param ptr Pointer to a pointer to a memory block already allocated + * with av_realloc(), or pointer to a pointer to NULL. + * The pointer is updated on success, or freed on failure. + * @param size Size in bytes for the memory block to be allocated or + * reallocated + * @return Zero on success, an AVERROR error code on failure. + * @warning Pointers originating from the av_malloc() family of functions must + * not be passed to av_reallocp(). The former can be implemented using + * memalign() (or other functions), and there is no guarantee that + * pointers from such functions can be passed to realloc() at all. + * The situation is undefined according to POSIX and may crash with + * some libc implementations. + */ +int av_reallocp(void *ptr, size_t size); + +/** + * Allocate or reallocate an array. + * If ptr is NULL and nmemb > 0, allocate a new block. If + * nmemb is zero, free the memory block pointed to by ptr. + * @param ptr Pointer to a memory block already allocated with + * av_realloc() or NULL. + * @param nmemb Number of elements + * @param size Size of the single element + * @return Pointer to a newly-reallocated block or NULL if the block + * cannot be reallocated or the function is used to free the memory block. + * @warning Pointers originating from the av_malloc() family of functions must + * not be passed to av_realloc(). The former can be implemented using + * memalign() (or other functions), and there is no guarantee that + * pointers from such functions can be passed to realloc() at all. + * The situation is undefined according to POSIX and may crash with + * some libc implementations. + */ +av_alloc_size(2, 3) void *av_realloc_array(void *ptr, size_t nmemb, size_t size); + +/** + * Allocate or reallocate an array through a pointer to a pointer. + * If *ptr is NULL and nmemb > 0, allocate a new block. If + * nmemb is zero, free the memory block pointed to by ptr. + * @param ptr Pointer to a pointer to a memory block already allocated + * with av_realloc(), or pointer to a pointer to NULL. + * The pointer is updated on success, or freed on failure. + * @param nmemb Number of elements + * @param size Size of the single element + * @return Zero on success, an AVERROR error code on failure. + * @warning Pointers originating from the av_malloc() family of functions must + * not be passed to av_realloc(). The former can be implemented using + * memalign() (or other functions), and there is no guarantee that + * pointers from such functions can be passed to realloc() at all. + * The situation is undefined according to POSIX and may crash with + * some libc implementations. + */ +av_alloc_size(2, 3) int av_reallocp_array(void *ptr, size_t nmemb, size_t size); + +/** + * Free a memory block which has been allocated with av_malloc(z)() or + * av_realloc(). + * @param ptr Pointer to the memory block which should be freed. + * @note ptr = NULL is explicitly allowed. + * @note It is recommended that you use av_freep() instead. + * @see av_freep() + */ +void av_free(void *ptr); + +/** + * Allocate a block of size bytes with alignment suitable for all + * memory accesses (including vectors if available on the CPU) and + * zero all the bytes of the block. + * @param size Size in bytes for the memory block to be allocated. + * @return Pointer to the allocated block, NULL if it cannot be allocated. + * @see av_malloc() + */ +void *av_mallocz(size_t size) av_malloc_attrib av_alloc_size(1); + +/** + * Allocate a block of nmemb * size bytes with alignment suitable for all + * memory accesses (including vectors if available on the CPU) and + * zero all the bytes of the block. + * The allocation will fail if nmemb * size is greater than or equal + * to INT_MAX. + * @param nmemb + * @param size + * @return Pointer to the allocated block, NULL if it cannot be allocated. + */ +void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib; + +/** + * Allocate a block of size * nmemb bytes with av_mallocz(). + * @param nmemb Number of elements + * @param size Size of the single element + * @return Pointer to the allocated block, NULL if the block cannot + * be allocated. + * @see av_mallocz() + * @see av_malloc_array() + */ +av_alloc_size(1, 2) static inline void *av_mallocz_array(size_t nmemb, size_t size) +{ + if (!size || nmemb >= INT_MAX / size) + return NULL; + return av_mallocz(nmemb * size); +} + +/** + * Duplicate the string s. + * @param s string to be duplicated + * @return Pointer to a newly-allocated string containing a + * copy of s or NULL if the string cannot be allocated. + */ +char *av_strdup(const char *s) av_malloc_attrib; + +/** + * Duplicate the buffer p. + * @param p buffer to be duplicated + * @return Pointer to a newly allocated buffer containing a + * copy of p or NULL if the buffer cannot be allocated. + */ +void *av_memdup(const void *p, size_t size); + +/** + * Free a memory block which has been allocated with av_malloc(z)() or + * av_realloc() and set the pointer pointing to it to NULL. + * @param ptr Pointer to the pointer to the memory block which should + * be freed. + * @see av_free() + */ +void av_freep(void *ptr); + +/** + * Add an element to a dynamic array. + * + * The array to grow is supposed to be an array of pointers to + * structures, and the element to add must be a pointer to an already + * allocated structure. + * + * The array is reallocated when its size reaches powers of 2. + * Therefore, the amortized cost of adding an element is constant. + * + * In case of success, the pointer to the array is updated in order to + * point to the new grown array, and the number pointed to by nb_ptr + * is incremented. + * In case of failure, the array is freed, *tab_ptr is set to NULL and + * *nb_ptr is set to 0. + * + * @param tab_ptr pointer to the array to grow + * @param nb_ptr pointer to the number of elements in the array + * @param elem element to add + * @see av_dynarray2_add() + */ +void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem); + +/** + * Add an element of size elem_size to a dynamic array. + * + * The array is reallocated when its number of elements reaches powers of 2. + * Therefore, the amortized cost of adding an element is constant. + * + * In case of success, the pointer to the array is updated in order to + * point to the new grown array, and the number pointed to by nb_ptr + * is incremented. + * In case of failure, the array is freed, *tab_ptr is set to NULL and + * *nb_ptr is set to 0. + * + * @param tab_ptr pointer to the array to grow + * @param nb_ptr pointer to the number of elements in the array + * @param elem_size size in bytes of the elements in the array + * @param elem_data pointer to the data of the element to add. If NULL, the space of + * the new added element is not filled. + * @return pointer to the data of the element to copy in the new allocated space. + * If NULL, the new allocated space is left uninitialized." + * @see av_dynarray_add() + */ +void *av_dynarray2_add(void **tab_ptr, int *nb_ptr, size_t elem_size, + const uint8_t *elem_data); + +/** + * Multiply two size_t values checking for overflow. + * @return 0 if success, AVERROR(EINVAL) if overflow. + */ +static inline int av_size_mult(size_t a, size_t b, size_t *r) +{ + size_t t = a * b; + /* Hack inspired from glibc: only try the division if nelem and elsize + * are both greater than sqrt(SIZE_MAX). */ + if ((a | b) >= ((size_t)1 << (sizeof(size_t) * 4)) && a && t / a != b) + return AVERROR(EINVAL); + *r = t; + return 0; +} + +/** + * Set the maximum size that may me allocated in one block. + */ +void av_max_alloc(size_t max); + +/** + * deliberately overlapping memcpy implementation + * @param dst destination buffer + * @param back how many bytes back we start (the initial size of the overlapping window), must be > 0 + * @param cnt number of bytes to copy, must be >= 0 + * + * cnt > back is valid, this will copy the bytes we just copied, + * thus creating a repeating pattern with a period length of back. + */ +void av_memcpy_backptr(uint8_t *dst, int back, int cnt); + +/** + * 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); + +/** + * @} + */ + +#endif /* AVUTIL_MEM_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/murmur3.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/murmur3.h new file mode 100644 index 0000000..f29ed97 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/murmur3.h @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2013 Reimar Döffinger + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_MURMUR3_H +#define AVUTIL_MURMUR3_H + +#include + +struct AVMurMur3 *av_murmur3_alloc(void); +void av_murmur3_init_seeded(struct AVMurMur3 *c, uint64_t seed); +void av_murmur3_init(struct AVMurMur3 *c); +void av_murmur3_update(struct AVMurMur3 *c, const uint8_t *src, int len); +void av_murmur3_final(struct AVMurMur3 *c, uint8_t dst[16]); + +#endif /* AVUTIL_MURMUR3_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/old_pix_fmts.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/old_pix_fmts.h new file mode 100644 index 0000000..cd1ed7c --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/old_pix_fmts.h @@ -0,0 +1,177 @@ +/* + * copyright (c) 2006-2012 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_OLD_PIX_FMTS_H +#define AVUTIL_OLD_PIX_FMTS_H + +/* + * This header exists to prevent new pixel formats from being accidentally added + * to the deprecated list. + * Do not include it directly. It will be removed on next major bump + * + * Do not add new items to this list. Use the AVPixelFormat enum instead. + */ + PIX_FMT_NONE = AV_PIX_FMT_NONE, + PIX_FMT_YUV420P, ///< planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples) + PIX_FMT_YUYV422, ///< packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr + PIX_FMT_RGB24, ///< packed RGB 8:8:8, 24bpp, RGBRGB... + PIX_FMT_BGR24, ///< packed RGB 8:8:8, 24bpp, BGRBGR... + PIX_FMT_YUV422P, ///< planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples) + PIX_FMT_YUV444P, ///< planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples) + PIX_FMT_YUV410P, ///< planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples) + PIX_FMT_YUV411P, ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) + PIX_FMT_GRAY8, ///< Y , 8bpp + PIX_FMT_MONOWHITE, ///< Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb + PIX_FMT_MONOBLACK, ///< Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb + PIX_FMT_PAL8, ///< 8 bit with PIX_FMT_RGB32 palette + PIX_FMT_YUVJ420P, ///< planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV420P and setting color_range + PIX_FMT_YUVJ422P, ///< planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV422P and setting color_range + PIX_FMT_YUVJ444P, ///< planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV444P and setting color_range +#if FF_API_XVMC + PIX_FMT_XVMC_MPEG2_MC,///< XVideo Motion Acceleration via common packet passing + PIX_FMT_XVMC_MPEG2_IDCT, +#endif /* FF_API_XVMC */ + PIX_FMT_UYVY422, ///< packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1 + PIX_FMT_UYYVYY411, ///< packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3 + PIX_FMT_BGR8, ///< packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb) + PIX_FMT_BGR4, ///< packed RGB 1:2:1 bitstream, 4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits + PIX_FMT_BGR4_BYTE, ///< packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb) + PIX_FMT_RGB8, ///< packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb) + PIX_FMT_RGB4, ///< packed RGB 1:2:1 bitstream, 4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits + PIX_FMT_RGB4_BYTE, ///< packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb) + PIX_FMT_NV12, ///< planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V) + PIX_FMT_NV21, ///< as above, but U and V bytes are swapped + + PIX_FMT_ARGB, ///< packed ARGB 8:8:8:8, 32bpp, ARGBARGB... + PIX_FMT_RGBA, ///< packed RGBA 8:8:8:8, 32bpp, RGBARGBA... + PIX_FMT_ABGR, ///< packed ABGR 8:8:8:8, 32bpp, ABGRABGR... + PIX_FMT_BGRA, ///< packed BGRA 8:8:8:8, 32bpp, BGRABGRA... + + PIX_FMT_GRAY16BE, ///< Y , 16bpp, big-endian + PIX_FMT_GRAY16LE, ///< Y , 16bpp, little-endian + PIX_FMT_YUV440P, ///< planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples) + PIX_FMT_YUVJ440P, ///< planar YUV 4:4:0 full scale (JPEG), deprecated in favor of PIX_FMT_YUV440P and setting color_range + PIX_FMT_YUVA420P, ///< planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples) +#if FF_API_VDPAU + PIX_FMT_VDPAU_H264,///< H.264 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers + PIX_FMT_VDPAU_MPEG1,///< MPEG-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers + PIX_FMT_VDPAU_MPEG2,///< MPEG-2 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers + PIX_FMT_VDPAU_WMV3,///< WMV3 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers + PIX_FMT_VDPAU_VC1, ///< VC-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers +#endif + PIX_FMT_RGB48BE, ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big-endian + PIX_FMT_RGB48LE, ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as little-endian + + PIX_FMT_RGB565BE, ///< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian + PIX_FMT_RGB565LE, ///< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian + PIX_FMT_RGB555BE, ///< packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), big-endian, most significant bit to 0 + PIX_FMT_RGB555LE, ///< packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), little-endian, most significant bit to 0 + + PIX_FMT_BGR565BE, ///< packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian + PIX_FMT_BGR565LE, ///< packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian + PIX_FMT_BGR555BE, ///< packed BGR 5:5:5, 16bpp, (msb)1A 5B 5G 5R(lsb), big-endian, most significant bit to 1 + PIX_FMT_BGR555LE, ///< packed BGR 5:5:5, 16bpp, (msb)1A 5B 5G 5R(lsb), little-endian, most significant bit to 1 + + PIX_FMT_VAAPI_MOCO, ///< HW acceleration through VA API at motion compensation entry-point, Picture.data[3] contains a vaapi_render_state struct which contains macroblocks as well as various fields extracted from headers + PIX_FMT_VAAPI_IDCT, ///< HW acceleration through VA API at IDCT entry-point, Picture.data[3] contains a vaapi_render_state struct which contains fields extracted from headers + PIX_FMT_VAAPI_VLD, ///< HW decoding through VA API, Picture.data[3] contains a vaapi_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers + + PIX_FMT_YUV420P16LE, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian + PIX_FMT_YUV420P16BE, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian + PIX_FMT_YUV422P16LE, ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian + PIX_FMT_YUV422P16BE, ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian + PIX_FMT_YUV444P16LE, ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian + PIX_FMT_YUV444P16BE, ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian +#if FF_API_VDPAU + PIX_FMT_VDPAU_MPEG4, ///< MPEG4 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers +#endif + PIX_FMT_DXVA2_VLD, ///< HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer + + PIX_FMT_RGB444LE, ///< packed RGB 4:4:4, 16bpp, (msb)4A 4R 4G 4B(lsb), little-endian, most significant bits to 0 + PIX_FMT_RGB444BE, ///< packed RGB 4:4:4, 16bpp, (msb)4A 4R 4G 4B(lsb), big-endian, most significant bits to 0 + PIX_FMT_BGR444LE, ///< packed BGR 4:4:4, 16bpp, (msb)4A 4B 4G 4R(lsb), little-endian, most significant bits to 1 + PIX_FMT_BGR444BE, ///< packed BGR 4:4:4, 16bpp, (msb)4A 4B 4G 4R(lsb), big-endian, most significant bits to 1 + PIX_FMT_GRAY8A, ///< 8bit gray, 8bit alpha + PIX_FMT_BGR48BE, ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big-endian + PIX_FMT_BGR48LE, ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as little-endian + + //the following 10 formats have the disadvantage of needing 1 format for each bit depth, thus + //If you want to support multiple bit depths, then using PIX_FMT_YUV420P16* with the bpp stored separately + //is better + PIX_FMT_YUV420P9BE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian + PIX_FMT_YUV420P9LE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian + PIX_FMT_YUV420P10BE,///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian + PIX_FMT_YUV420P10LE,///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian + PIX_FMT_YUV422P10BE,///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian + PIX_FMT_YUV422P10LE,///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian + PIX_FMT_YUV444P9BE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian + PIX_FMT_YUV444P9LE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian + PIX_FMT_YUV444P10BE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian + PIX_FMT_YUV444P10LE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian + PIX_FMT_YUV422P9BE, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian + PIX_FMT_YUV422P9LE, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian + PIX_FMT_VDA_VLD, ///< hardware decoding through VDA + +#ifdef AV_PIX_FMT_ABI_GIT_MASTER + PIX_FMT_RGBA64BE, ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian + PIX_FMT_RGBA64LE, ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian + PIX_FMT_BGRA64BE, ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian + PIX_FMT_BGRA64LE, ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian +#endif + PIX_FMT_GBRP, ///< planar GBR 4:4:4 24bpp + PIX_FMT_GBRP9BE, ///< planar GBR 4:4:4 27bpp, big endian + PIX_FMT_GBRP9LE, ///< planar GBR 4:4:4 27bpp, little endian + PIX_FMT_GBRP10BE, ///< planar GBR 4:4:4 30bpp, big endian + PIX_FMT_GBRP10LE, ///< planar GBR 4:4:4 30bpp, little endian + PIX_FMT_GBRP16BE, ///< planar GBR 4:4:4 48bpp, big endian + PIX_FMT_GBRP16LE, ///< planar GBR 4:4:4 48bpp, little endian + +#ifndef AV_PIX_FMT_ABI_GIT_MASTER + PIX_FMT_RGBA64BE=0x123, ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian + PIX_FMT_RGBA64LE, ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian + PIX_FMT_BGRA64BE, ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian + PIX_FMT_BGRA64LE, ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian +#endif + PIX_FMT_0RGB=0x123+4, ///< packed RGB 8:8:8, 32bpp, 0RGB0RGB... + PIX_FMT_RGB0, ///< packed RGB 8:8:8, 32bpp, RGB0RGB0... + PIX_FMT_0BGR, ///< packed BGR 8:8:8, 32bpp, 0BGR0BGR... + PIX_FMT_BGR0, ///< packed BGR 8:8:8, 32bpp, BGR0BGR0... + PIX_FMT_YUVA444P, ///< planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples) + PIX_FMT_YUVA422P, ///< planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples) + + PIX_FMT_YUV420P12BE, ///< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian + PIX_FMT_YUV420P12LE, ///< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian + PIX_FMT_YUV420P14BE, ///< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian + PIX_FMT_YUV420P14LE, ///< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian + PIX_FMT_YUV422P12BE, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian + PIX_FMT_YUV422P12LE, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian + PIX_FMT_YUV422P14BE, ///< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian + PIX_FMT_YUV422P14LE, ///< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian + PIX_FMT_YUV444P12BE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian + PIX_FMT_YUV444P12LE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian + PIX_FMT_YUV444P14BE, ///< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian + PIX_FMT_YUV444P14LE, ///< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian + PIX_FMT_GBRP12BE, ///< planar GBR 4:4:4 36bpp, big endian + PIX_FMT_GBRP12LE, ///< planar GBR 4:4:4 36bpp, little endian + PIX_FMT_GBRP14BE, ///< planar GBR 4:4:4 42bpp, big endian + PIX_FMT_GBRP14LE, ///< planar GBR 4:4:4 42bpp, little endian + + PIX_FMT_NB, ///< number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions +#endif /* AVUTIL_OLD_PIX_FMTS_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/opt.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/opt.h new file mode 100644 index 0000000..14faa6e --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/opt.h @@ -0,0 +1,757 @@ +/* + * AVOptions + * copyright (c) 2005 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_OPT_H +#define AVUTIL_OPT_H + +/** + * @file + * AVOptions + */ + +#include "rational.h" +#include "avutil.h" +#include "dict.h" +#include "log.h" +#include "pixfmt.h" +#include "samplefmt.h" + +/** + * @defgroup avoptions AVOptions + * @ingroup lavu_data + * @{ + * AVOptions provide a generic system to declare options on arbitrary structs + * ("objects"). An option can have a help text, a type and a range of possible + * values. Options may then be enumerated, read and written to. + * + * @section avoptions_implement Implementing AVOptions + * This section describes how to add AVOptions capabilities to a struct. + * + * All AVOptions-related information is stored in an AVClass. Therefore + * the first member of the struct should be a pointer to an AVClass describing it. + * The option field of the AVClass must be set to a NULL-terminated static array + * of AVOptions. Each AVOption must have a non-empty name, a type, a default + * value and for number-type AVOptions also a range of allowed values. It must + * also declare an offset in bytes from the start of the struct, where the field + * associated with this AVOption is located. Other fields in the AVOption struct + * should also be set when applicable, but are not required. + * + * The following example illustrates an AVOptions-enabled struct: + * @code + * typedef struct test_struct { + * AVClass *class; + * int int_opt; + * char *str_opt; + * uint8_t *bin_opt; + * int bin_len; + * } test_struct; + * + * static const AVOption test_options[] = { + * { "test_int", "This is a test option of int type.", offsetof(test_struct, int_opt), + * AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX }, + * { "test_str", "This is a test option of string type.", offsetof(test_struct, str_opt), + * AV_OPT_TYPE_STRING }, + * { "test_bin", "This is a test option of binary type.", offsetof(test_struct, bin_opt), + * AV_OPT_TYPE_BINARY }, + * { NULL }, + * }; + * + * static const AVClass test_class = { + * .class_name = "test class", + * .item_name = av_default_item_name, + * .option = test_options, + * .version = LIBAVUTIL_VERSION_INT, + * }; + * @endcode + * + * Next, when allocating your struct, you must ensure that the AVClass pointer + * is set to the correct value. Then, av_opt_set_defaults() can be called to + * initialize defaults. After that the struct is ready to be used with the + * AVOptions API. + * + * When cleaning up, you may use the av_opt_free() function to automatically + * free all the allocated string and binary options. + * + * Continuing with the above example: + * + * @code + * test_struct *alloc_test_struct(void) + * { + * test_struct *ret = av_malloc(sizeof(*ret)); + * ret->class = &test_class; + * av_opt_set_defaults(ret); + * return ret; + * } + * void free_test_struct(test_struct **foo) + * { + * av_opt_free(*foo); + * av_freep(foo); + * } + * @endcode + * + * @subsection avoptions_implement_nesting Nesting + * It may happen that an AVOptions-enabled struct contains another + * AVOptions-enabled struct as a member (e.g. AVCodecContext in + * libavcodec exports generic options, while its priv_data field exports + * codec-specific options). In such a case, it is possible to set up the + * parent struct to export a child's options. To do that, simply + * implement AVClass.child_next() and AVClass.child_class_next() in the + * parent struct's AVClass. + * Assuming that the test_struct from above now also contains a + * child_struct field: + * + * @code + * typedef struct child_struct { + * AVClass *class; + * int flags_opt; + * } child_struct; + * static const AVOption child_opts[] = { + * { "test_flags", "This is a test option of flags type.", + * offsetof(child_struct, flags_opt), AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT_MIN, INT_MAX }, + * { NULL }, + * }; + * static const AVClass child_class = { + * .class_name = "child class", + * .item_name = av_default_item_name, + * .option = child_opts, + * .version = LIBAVUTIL_VERSION_INT, + * }; + * + * void *child_next(void *obj, void *prev) + * { + * test_struct *t = obj; + * if (!prev && t->child_struct) + * return t->child_struct; + * return NULL + * } + * const AVClass child_class_next(const AVClass *prev) + * { + * return prev ? NULL : &child_class; + * } + * @endcode + * Putting child_next() and child_class_next() as defined above into + * test_class will now make child_struct's options accessible through + * test_struct (again, proper setup as described above needs to be done on + * child_struct right after it is created). + * + * From the above example it might not be clear why both child_next() + * and child_class_next() are needed. The distinction is that child_next() + * iterates over actually existing objects, while child_class_next() + * iterates over all possible child classes. E.g. if an AVCodecContext + * was initialized to use a codec which has private options, then its + * child_next() will return AVCodecContext.priv_data and finish + * iterating. OTOH child_class_next() on AVCodecContext.av_class will + * iterate over all available codecs with private options. + * + * @subsection avoptions_implement_named_constants Named constants + * It is possible to create named constants for options. Simply set the unit + * field of the option the constants should apply to a string and + * create the constants themselves as options of type AV_OPT_TYPE_CONST + * with their unit field set to the same string. + * Their default_val field should contain the value of the named + * constant. + * For example, to add some named constants for the test_flags option + * above, put the following into the child_opts array: + * @code + * { "test_flags", "This is a test option of flags type.", + * offsetof(child_struct, flags_opt), AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT_MIN, INT_MAX, "test_unit" }, + * { "flag1", "This is a flag with value 16", 0, AV_OPT_TYPE_CONST, { .i64 = 16 }, 0, 0, "test_unit" }, + * @endcode + * + * @section avoptions_use Using AVOptions + * This section deals with accessing options in an AVOptions-enabled struct. + * Such structs in FFmpeg are e.g. AVCodecContext in libavcodec or + * AVFormatContext in libavformat. + * + * @subsection avoptions_use_examine Examining AVOptions + * The basic functions for examining options are av_opt_next(), which iterates + * over all options defined for one object, and av_opt_find(), which searches + * for an option with the given name. + * + * The situation is more complicated with nesting. An AVOptions-enabled struct + * may have AVOptions-enabled children. Passing the AV_OPT_SEARCH_CHILDREN flag + * to av_opt_find() will make the function search children recursively. + * + * For enumerating there are basically two cases. The first is when you want to + * get all options that may potentially exist on the struct and its children + * (e.g. when constructing documentation). In that case you should call + * av_opt_child_class_next() recursively on the parent struct's AVClass. The + * second case is when you have an already initialized struct with all its + * children and you want to get all options that can be actually written or read + * from it. In that case you should call av_opt_child_next() recursively (and + * av_opt_next() on each result). + * + * @subsection avoptions_use_get_set Reading and writing AVOptions + * When setting options, you often have a string read directly from the + * user. In such a case, simply passing it to av_opt_set() is enough. For + * non-string type options, av_opt_set() will parse the string according to the + * option type. + * + * Similarly av_opt_get() will read any option type and convert it to a string + * which will be returned. Do not forget that the string is allocated, so you + * have to free it with av_free(). + * + * In some cases it may be more convenient to put all options into an + * AVDictionary and call av_opt_set_dict() on it. A specific case of this + * are the format/codec open functions in lavf/lavc which take a dictionary + * filled with option as a parameter. This allows to set some options + * that cannot be set otherwise, since e.g. the input file format is not known + * before the file is actually opened. + */ + +enum AVOptionType{ + AV_OPT_TYPE_FLAGS, + AV_OPT_TYPE_INT, + AV_OPT_TYPE_INT64, + AV_OPT_TYPE_DOUBLE, + AV_OPT_TYPE_FLOAT, + AV_OPT_TYPE_STRING, + AV_OPT_TYPE_RATIONAL, + AV_OPT_TYPE_BINARY, ///< offset must point to a pointer immediately followed by an int for the length + AV_OPT_TYPE_CONST = 128, + AV_OPT_TYPE_IMAGE_SIZE = MKBETAG('S','I','Z','E'), ///< offset must point to two consecutive integers + AV_OPT_TYPE_PIXEL_FMT = MKBETAG('P','F','M','T'), + AV_OPT_TYPE_SAMPLE_FMT = MKBETAG('S','F','M','T'), + AV_OPT_TYPE_VIDEO_RATE = MKBETAG('V','R','A','T'), ///< offset must point to AVRational + AV_OPT_TYPE_DURATION = MKBETAG('D','U','R',' '), + AV_OPT_TYPE_COLOR = MKBETAG('C','O','L','R'), + AV_OPT_TYPE_CHANNEL_LAYOUT = MKBETAG('C','H','L','A'), +#if FF_API_OLD_AVOPTIONS + FF_OPT_TYPE_FLAGS = 0, + FF_OPT_TYPE_INT, + FF_OPT_TYPE_INT64, + FF_OPT_TYPE_DOUBLE, + FF_OPT_TYPE_FLOAT, + FF_OPT_TYPE_STRING, + FF_OPT_TYPE_RATIONAL, + FF_OPT_TYPE_BINARY, ///< offset must point to a pointer immediately followed by an int for the length + FF_OPT_TYPE_CONST=128, +#endif +}; + +/** + * AVOption + */ +typedef struct AVOption { + const char *name; + + /** + * short English help text + * @todo What about other languages? + */ + const char *help; + + /** + * The offset relative to the context structure where the option + * value is stored. It should be 0 for named constants. + */ + int offset; + enum AVOptionType type; + + /** + * the default value for scalar options + */ + union { + int64_t i64; + double dbl; + const char *str; + /* TODO those are unused now */ + AVRational q; + } default_val; + double min; ///< minimum valid value for the option + double max; ///< maximum valid value for the option + + int flags; +#define AV_OPT_FLAG_ENCODING_PARAM 1 ///< a generic parameter which can be set by the user for muxing or encoding +#define AV_OPT_FLAG_DECODING_PARAM 2 ///< a generic parameter which can be set by the user for demuxing or decoding +#define AV_OPT_FLAG_METADATA 4 ///< some data extracted or inserted into the file like title, comment, ... +#define AV_OPT_FLAG_AUDIO_PARAM 8 +#define AV_OPT_FLAG_VIDEO_PARAM 16 +#define AV_OPT_FLAG_SUBTITLE_PARAM 32 +#define AV_OPT_FLAG_FILTERING_PARAM (1<<16) ///< a generic parameter which can be set by the user for filtering +//FIXME think about enc-audio, ... style flags + + /** + * The logical unit to which the option belongs. Non-constant + * options and corresponding named constants share the same + * unit. May be NULL. + */ + const char *unit; +} AVOption; + +/** + * A single allowed range of values, or a single allowed value. + */ +typedef struct AVOptionRange { + const char *str; + double value_min, value_max; ///< For string ranges this represents the min/max length, for dimensions this represents the min/max pixel count + double component_min, component_max; ///< For string this represents the unicode range for chars, 0-127 limits to ASCII + int is_range; ///< if set to 1 the struct encodes a range, if set to 0 a single value +} AVOptionRange; + +/** + * List of AVOptionRange structs + */ +typedef struct AVOptionRanges { + AVOptionRange **range; + int nb_ranges; +} AVOptionRanges; + + +#if FF_API_FIND_OPT +/** + * Look for an option in obj. Look only for the options which + * have the flags set as specified in mask and flags (that is, + * for which it is the case that (opt->flags & mask) == flags). + * + * @param[in] obj a pointer to a struct whose first element is a + * pointer to an AVClass + * @param[in] name the name of the option to look for + * @param[in] unit the unit of the option to look for, or any if NULL + * @return a pointer to the option found, or NULL if no option + * has been found + * + * @deprecated use av_opt_find. + */ +attribute_deprecated +const AVOption *av_find_opt(void *obj, const char *name, const char *unit, int mask, int flags); +#endif + +#if FF_API_OLD_AVOPTIONS +/** + * Set the field of obj with the given name to value. + * + * @param[in] obj A struct whose first element is a pointer to an + * AVClass. + * @param[in] name the name of the field to set + * @param[in] val The value to set. If the field is not of a string + * type, then the given string is parsed. + * SI postfixes and some named scalars are supported. + * If the field is of a numeric type, it has to be a numeric or named + * scalar. Behavior with more than one scalar and +- infix operators + * is undefined. + * If the field is of a flags type, it has to be a sequence of numeric + * scalars or named flags separated by '+' or '-'. Prefixing a flag + * with '+' causes it to be set without affecting the other flags; + * similarly, '-' unsets a flag. + * @param[out] o_out if non-NULL put here a pointer to the AVOption + * found + * @param alloc this parameter is currently ignored + * @return 0 if the value has been set, or an AVERROR code in case of + * error: + * AVERROR_OPTION_NOT_FOUND if no matching option exists + * AVERROR(ERANGE) if the value is out of range + * AVERROR(EINVAL) if the value is not valid + * @deprecated use av_opt_set() + */ +attribute_deprecated +int av_set_string3(void *obj, const char *name, const char *val, int alloc, const AVOption **o_out); + +attribute_deprecated const AVOption *av_set_double(void *obj, const char *name, double n); +attribute_deprecated const AVOption *av_set_q(void *obj, const char *name, AVRational n); +attribute_deprecated const AVOption *av_set_int(void *obj, const char *name, int64_t n); + +double av_get_double(void *obj, const char *name, const AVOption **o_out); +AVRational av_get_q(void *obj, const char *name, const AVOption **o_out); +int64_t av_get_int(void *obj, const char *name, const AVOption **o_out); +attribute_deprecated const char *av_get_string(void *obj, const char *name, const AVOption **o_out, char *buf, int buf_len); +attribute_deprecated const AVOption *av_next_option(void *obj, const AVOption *last); +#endif + +/** + * Show the obj options. + * + * @param req_flags requested flags for the options to show. Show only the + * options for which it is opt->flags & req_flags. + * @param rej_flags rejected flags for the options to show. Show only the + * options for which it is !(opt->flags & req_flags). + * @param av_log_obj log context to use for showing the options + */ +int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags); + +/** + * Set the values of all AVOption fields to their default values. + * + * @param s an AVOption-enabled struct (its first member must be a pointer to AVClass) + */ +void av_opt_set_defaults(void *s); + +#if FF_API_OLD_AVOPTIONS +attribute_deprecated +void av_opt_set_defaults2(void *s, int mask, int flags); +#endif + +/** + * Parse the key/value pairs list in opts. For each key/value pair + * found, stores the value in the field in ctx that is named like the + * key. ctx must be an AVClass context, storing is done using + * AVOptions. + * + * @param opts options string to parse, may be NULL + * @param key_val_sep a 0-terminated list of characters used to + * separate key from value + * @param pairs_sep a 0-terminated list of characters used to separate + * two pairs from each other + * @return the number of successfully set key/value pairs, or a negative + * value corresponding to an AVERROR code in case of error: + * AVERROR(EINVAL) if opts cannot be parsed, + * the error code issued by av_set_string3() if a key/value pair + * cannot be set + */ +int av_set_options_string(void *ctx, const char *opts, + const char *key_val_sep, const char *pairs_sep); + +/** + * Parse the key-value pairs list in opts. For each key=value pair found, + * set the value of the corresponding option in ctx. + * + * @param ctx the AVClass object to set options on + * @param opts the options string, key-value pairs separated by a + * delimiter + * @param shorthand a NULL-terminated array of options names for shorthand + * notation: if the first field in opts has no key part, + * the key is taken from the first element of shorthand; + * then again for the second, etc., until either opts is + * finished, shorthand is finished or a named option is + * found; after that, all options must be named + * @param key_val_sep a 0-terminated list of characters used to separate + * key from value, for example '=' + * @param pairs_sep a 0-terminated list of characters used to separate + * two pairs from each other, for example ':' or ',' + * @return the number of successfully set key=value pairs, or a negative + * value corresponding to an AVERROR code in case of error: + * AVERROR(EINVAL) if opts cannot be parsed, + * the error code issued by av_set_string3() if a key/value pair + * cannot be set + * + * Options names must use only the following characters: a-z A-Z 0-9 - . / _ + * Separators must use characters distinct from option names and from each + * other. + */ +int av_opt_set_from_string(void *ctx, const char *opts, + const char *const *shorthand, + const char *key_val_sep, const char *pairs_sep); +/** + * Free all string and binary options in obj. + */ +void av_opt_free(void *obj); + +/** + * Check whether a particular flag is set in a flags field. + * + * @param field_name the name of the flag field option + * @param flag_name the name of the flag to check + * @return non-zero if the flag is set, zero if the flag isn't set, + * isn't of the right type, or the flags field doesn't exist. + */ +int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name); + +/** + * Set all the options from a given dictionary on an object. + * + * @param obj a struct whose first element is a pointer to AVClass + * @param options options to process. This dictionary will be freed and replaced + * by a new one containing all options not found in obj. + * Of course this new dictionary needs to be freed by caller + * with av_dict_free(). + * + * @return 0 on success, a negative AVERROR if some option was found in obj, + * but could not be set. + * + * @see av_dict_copy() + */ +int av_opt_set_dict(void *obj, struct AVDictionary **options); + +/** + * Extract a key-value pair from the beginning of a string. + * + * @param ropts pointer to the options string, will be updated to + * point to the rest of the string (one of the pairs_sep + * or the final NUL) + * @param key_val_sep a 0-terminated list of characters used to separate + * key from value, for example '=' + * @param pairs_sep a 0-terminated list of characters used to separate + * two pairs from each other, for example ':' or ',' + * @param flags flags; see the AV_OPT_FLAG_* values below + * @param rkey parsed key; must be freed using av_free() + * @param rval parsed value; must be freed using av_free() + * + * @return >=0 for success, or a negative value corresponding to an + * AVERROR code in case of error; in particular: + * AVERROR(EINVAL) if no key is present + * + */ +int av_opt_get_key_value(const char **ropts, + const char *key_val_sep, const char *pairs_sep, + unsigned flags, + char **rkey, char **rval); + +enum { + + /** + * Accept to parse a value without a key; the key will then be returned + * as NULL. + */ + AV_OPT_FLAG_IMPLICIT_KEY = 1, +}; + +/** + * @defgroup opt_eval_funcs Evaluating option strings + * @{ + * This group of functions can be used to evaluate option strings + * and get numbers out of them. They do the same thing as av_opt_set(), + * except the result is written into the caller-supplied pointer. + * + * @param obj a struct whose first element is a pointer to AVClass. + * @param o an option for which the string is to be evaluated. + * @param val string to be evaluated. + * @param *_out value of the string will be written here. + * + * @return 0 on success, a negative number on failure. + */ +int av_opt_eval_flags (void *obj, const AVOption *o, const char *val, int *flags_out); +int av_opt_eval_int (void *obj, const AVOption *o, const char *val, int *int_out); +int av_opt_eval_int64 (void *obj, const AVOption *o, const char *val, int64_t *int64_out); +int av_opt_eval_float (void *obj, const AVOption *o, const char *val, float *float_out); +int av_opt_eval_double(void *obj, const AVOption *o, const char *val, double *double_out); +int av_opt_eval_q (void *obj, const AVOption *o, const char *val, AVRational *q_out); +/** + * @} + */ + +#define AV_OPT_SEARCH_CHILDREN 0x0001 /**< Search in possible children of the + given object first. */ +/** + * The obj passed to av_opt_find() is fake -- only a double pointer to AVClass + * instead of a required pointer to a struct containing AVClass. This is + * useful for searching for options without needing to allocate the corresponding + * object. + */ +#define AV_OPT_SEARCH_FAKE_OBJ 0x0002 + +/** + * Look for an option in an object. Consider only options which + * have all the specified flags set. + * + * @param[in] obj A pointer to a struct whose first element is a + * pointer to an AVClass. + * Alternatively a double pointer to an AVClass, if + * AV_OPT_SEARCH_FAKE_OBJ search flag is set. + * @param[in] name The name of the option to look for. + * @param[in] unit When searching for named constants, name of the unit + * it belongs to. + * @param opt_flags Find only options with all the specified flags set (AV_OPT_FLAG). + * @param search_flags A combination of AV_OPT_SEARCH_*. + * + * @return A pointer to the option found, or NULL if no option + * was found. + * + * @note Options found with AV_OPT_SEARCH_CHILDREN flag may not be settable + * directly with av_set_string3(). Use special calls which take an options + * AVDictionary (e.g. avformat_open_input()) to set options found with this + * flag. + */ +const AVOption *av_opt_find(void *obj, const char *name, const char *unit, + int opt_flags, int search_flags); + +/** + * Look for an option in an object. Consider only options which + * have all the specified flags set. + * + * @param[in] obj A pointer to a struct whose first element is a + * pointer to an AVClass. + * Alternatively a double pointer to an AVClass, if + * AV_OPT_SEARCH_FAKE_OBJ search flag is set. + * @param[in] name The name of the option to look for. + * @param[in] unit When searching for named constants, name of the unit + * it belongs to. + * @param opt_flags Find only options with all the specified flags set (AV_OPT_FLAG). + * @param search_flags A combination of AV_OPT_SEARCH_*. + * @param[out] target_obj if non-NULL, an object to which the option belongs will be + * written here. It may be different from obj if AV_OPT_SEARCH_CHILDREN is present + * in search_flags. This parameter is ignored if search_flags contain + * AV_OPT_SEARCH_FAKE_OBJ. + * + * @return A pointer to the option found, or NULL if no option + * was found. + */ +const AVOption *av_opt_find2(void *obj, const char *name, const char *unit, + int opt_flags, int search_flags, void **target_obj); + +/** + * Iterate over all AVOptions belonging to obj. + * + * @param obj an AVOptions-enabled struct or a double pointer to an + * AVClass describing it. + * @param prev result of the previous call to av_opt_next() on this object + * or NULL + * @return next AVOption or NULL + */ +const AVOption *av_opt_next(void *obj, const AVOption *prev); + +/** + * Iterate over AVOptions-enabled children of obj. + * + * @param prev result of a previous call to this function or NULL + * @return next AVOptions-enabled child or NULL + */ +void *av_opt_child_next(void *obj, void *prev); + +/** + * Iterate over potential AVOptions-enabled children of parent. + * + * @param prev result of a previous call to this function or NULL + * @return AVClass corresponding to next potential child or NULL + */ +const AVClass *av_opt_child_class_next(const AVClass *parent, const AVClass *prev); + +/** + * @defgroup opt_set_funcs Option setting functions + * @{ + * Those functions set the field of obj with the given name to value. + * + * @param[in] obj A struct whose first element is a pointer to an AVClass. + * @param[in] name the name of the field to set + * @param[in] val The value to set. In case of av_opt_set() if the field is not + * of a string type, then the given string is parsed. + * SI postfixes and some named scalars are supported. + * If the field is of a numeric type, it has to be a numeric or named + * scalar. Behavior with more than one scalar and +- infix operators + * is undefined. + * If the field is of a flags type, it has to be a sequence of numeric + * scalars or named flags separated by '+' or '-'. Prefixing a flag + * with '+' causes it to be set without affecting the other flags; + * similarly, '-' unsets a flag. + * @param search_flags flags passed to av_opt_find2. I.e. if AV_OPT_SEARCH_CHILDREN + * is passed here, then the option may be set on a child of obj. + * + * @return 0 if the value has been set, or an AVERROR code in case of + * error: + * AVERROR_OPTION_NOT_FOUND if no matching option exists + * AVERROR(ERANGE) if the value is out of range + * AVERROR(EINVAL) if the value is not valid + */ +int av_opt_set (void *obj, const char *name, const char *val, int search_flags); +int av_opt_set_int (void *obj, const char *name, int64_t val, int search_flags); +int av_opt_set_double(void *obj, const char *name, double val, int search_flags); +int av_opt_set_q (void *obj, const char *name, AVRational val, int search_flags); +int av_opt_set_bin (void *obj, const char *name, const uint8_t *val, int size, int search_flags); +int av_opt_set_image_size(void *obj, const char *name, int w, int h, int search_flags); +int av_opt_set_pixel_fmt (void *obj, const char *name, enum AVPixelFormat fmt, int search_flags); +int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags); +int av_opt_set_video_rate(void *obj, const char *name, AVRational val, int search_flags); +int av_opt_set_channel_layout(void *obj, const char *name, int64_t ch_layout, int search_flags); + +/** + * Set a binary option to an integer list. + * + * @param obj AVClass object to set options on + * @param name name of the binary option + * @param val pointer to an integer list (must have the correct type with + * regard to the contents of the list) + * @param term list terminator (usually 0 or -1) + * @param flags search flags + */ +#define av_opt_set_int_list(obj, name, val, term, flags) \ + (av_int_list_length(val, term) > INT_MAX / sizeof(*(val)) ? \ + AVERROR(EINVAL) : \ + av_opt_set_bin(obj, name, (const uint8_t *)(val), \ + av_int_list_length(val, term) * sizeof(*(val)), flags)) +/** + * @} + */ + +/** + * @defgroup opt_get_funcs Option getting functions + * @{ + * Those functions get a value of the option with the given name from an object. + * + * @param[in] obj a struct whose first element is a pointer to an AVClass. + * @param[in] name name of the option to get. + * @param[in] search_flags flags passed to av_opt_find2. I.e. if AV_OPT_SEARCH_CHILDREN + * is passed here, then the option may be found in a child of obj. + * @param[out] out_val value of the option will be written here + * @return >=0 on success, a negative error code otherwise + */ +/** + * @note the returned string will be av_malloc()ed and must be av_free()ed by the caller + */ +int av_opt_get (void *obj, const char *name, int search_flags, uint8_t **out_val); +int av_opt_get_int (void *obj, const char *name, int search_flags, int64_t *out_val); +int av_opt_get_double(void *obj, const char *name, int search_flags, double *out_val); +int av_opt_get_q (void *obj, const char *name, int search_flags, AVRational *out_val); +int av_opt_get_image_size(void *obj, const char *name, int search_flags, int *w_out, int *h_out); +int av_opt_get_pixel_fmt (void *obj, const char *name, int search_flags, enum AVPixelFormat *out_fmt); +int av_opt_get_sample_fmt(void *obj, const char *name, int search_flags, enum AVSampleFormat *out_fmt); +int av_opt_get_video_rate(void *obj, const char *name, int search_flags, AVRational *out_val); +int av_opt_get_channel_layout(void *obj, const char *name, int search_flags, int64_t *ch_layout); +/** + * @} + */ +/** + * Gets a pointer to the requested field in a struct. + * This function allows accessing a struct even when its fields are moved or + * renamed since the application making the access has been compiled, + * + * @returns a pointer to the field, it can be cast to the correct type and read + * or written to. + */ +void *av_opt_ptr(const AVClass *avclass, void *obj, const char *name); + +/** + * Free an AVOptionRanges struct and set it to NULL. + */ +void av_opt_freep_ranges(AVOptionRanges **ranges); + +/** + * Get a list of allowed ranges for the given option. + * + * The returned list may depend on other fields in obj like for example profile. + * + * @param flags is a bitmask of flags, undefined flags should not be set and should be ignored + * AV_OPT_SEARCH_FAKE_OBJ indicates that the obj is a double pointer to a AVClass instead of a full instance + * + * The result must be freed with av_opt_freep_ranges. + * + * @return >= 0 on success, a negative errro code otherwise + */ +int av_opt_query_ranges(AVOptionRanges **, void *obj, const char *key, int flags); + +/** + * Get a default list of allowed ranges for the given option. + * + * This list is constructed without using the AVClass.query_ranges() callback + * and can be used as fallback from within the callback. + * + * @param flags is a bitmask of flags, undefined flags should not be set and should be ignored + * AV_OPT_SEARCH_FAKE_OBJ indicates that the obj is a double pointer to a AVClass instead of a full instance + * + * The result must be freed with av_opt_free_ranges. + * + * @return >= 0 on success, a negative errro code otherwise + */ +int av_opt_query_ranges_default(AVOptionRanges **, void *obj, const char *key, int flags); + +/** + * @} + */ + +#endif /* AVUTIL_OPT_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/parseutils.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/parseutils.h new file mode 100644 index 0000000..c80f0de --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/parseutils.h @@ -0,0 +1,187 @@ +/* + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_PARSEUTILS_H +#define AVUTIL_PARSEUTILS_H + +#include + +#include "rational.h" + +/** + * @file + * misc parsing utilities + */ + +/** + * Parse str and store the parsed ratio in q. + * + * Note that a ratio with infinite (1/0) or negative value is + * considered valid, so you should check on the returned value if you + * want to exclude those values. + * + * The undefined value can be expressed using the "0:0" string. + * + * @param[in,out] q pointer to the AVRational which will contain the ratio + * @param[in] str the string to parse: it has to be a string in the format + * num:den, a float number or an expression + * @param[in] max the maximum allowed numerator and denominator + * @param[in] log_offset log level offset which is applied to the log + * level of log_ctx + * @param[in] log_ctx parent logging context + * @return >= 0 on success, a negative error code otherwise + */ +int av_parse_ratio(AVRational *q, const char *str, int max, + int log_offset, void *log_ctx); + +#define av_parse_ratio_quiet(rate, str, max) \ + av_parse_ratio(rate, str, max, AV_LOG_MAX_OFFSET, NULL) + +/** + * Parse str and put in width_ptr and height_ptr the detected values. + * + * @param[in,out] width_ptr pointer to the variable which will contain the detected + * width value + * @param[in,out] height_ptr pointer to the variable which will contain the detected + * height value + * @param[in] str the string to parse: it has to be a string in the format + * width x height or a valid video size abbreviation. + * @return >= 0 on success, a negative error code otherwise + */ +int av_parse_video_size(int *width_ptr, int *height_ptr, const char *str); + +/** + * Parse str and store the detected values in *rate. + * + * @param[in,out] rate pointer to the AVRational which will contain the detected + * frame rate + * @param[in] str the string to parse: it has to be a string in the format + * rate_num / rate_den, a float number or a valid video rate abbreviation + * @return >= 0 on success, a negative error code otherwise + */ +int av_parse_video_rate(AVRational *rate, const char *str); + +/** + * Put the RGBA values that correspond to color_string in rgba_color. + * + * @param color_string a string specifying a color. It can be the name of + * a color (case insensitive match) or a [0x|#]RRGGBB[AA] sequence, + * possibly followed by "@" and a string representing the alpha + * component. + * The alpha component may be a string composed by "0x" followed by an + * hexadecimal number or a decimal number between 0.0 and 1.0, which + * represents the opacity value (0x00/0.0 means completely transparent, + * 0xff/1.0 completely opaque). + * If the alpha component is not specified then 0xff is assumed. + * The string "random" will result in a random color. + * @param slen length of the initial part of color_string containing the + * color. It can be set to -1 if color_string is a null terminated string + * containing nothing else than the color. + * @return >= 0 in case of success, a negative value in case of + * failure (for example if color_string cannot be parsed). + */ +int av_parse_color(uint8_t *rgba_color, const char *color_string, int slen, + void *log_ctx); + +/** + * Get the name of a color from the internal table of hard-coded named + * colors. + * + * This function is meant to enumerate the color names recognized by + * av_parse_color(). + * + * @param color_idx index of the requested color, starting from 0 + * @param rgbp if not NULL, will point to a 3-elements array with the color value in RGB + * @return the color name string or NULL if color_idx is not in the array + */ +const char *av_get_known_color_name(int color_idx, const uint8_t **rgb); + +/** + * Parse timestr and return in *time a corresponding number of + * microseconds. + * + * @param timeval puts here the number of microseconds corresponding + * to the string in timestr. If the string represents a duration, it + * is the number of microseconds contained in the time interval. If + * the string is a date, is the number of microseconds since 1st of + * January, 1970 up to the time of the parsed date. If timestr cannot + * be successfully parsed, set *time to INT64_MIN. + + * @param timestr a string representing a date or a duration. + * - If a date the syntax is: + * @code + * [{YYYY-MM-DD|YYYYMMDD}[T|t| ]]{{HH:MM:SS[.m...]]]}|{HHMMSS[.m...]]]}}[Z] + * now + * @endcode + * If the value is "now" it takes the current time. + * Time is local time unless Z is appended, in which case it is + * interpreted as UTC. + * If the year-month-day part is not specified it takes the current + * year-month-day. + * - If a duration the syntax is: + * @code + * [-][HH:]MM:SS[.m...] + * [-]S+[.m...] + * @endcode + * @param duration flag which tells how to interpret timestr, if not + * zero timestr is interpreted as a duration, otherwise as a date + * @return >= 0 in case of success, a negative value corresponding to an + * AVERROR code otherwise + */ +int av_parse_time(int64_t *timeval, const char *timestr, int duration); + +/** + * Parse the input string p according to the format string fmt and + * store its results in the structure dt. + * This implementation supports only a subset of the formats supported + * by the standard strptime(). + * + * In particular it actually supports the parameters: + * - %H: the hour as a decimal number, using a 24-hour clock, in the + * range '00' through '23' + * - %J: hours as a decimal number, in the range '0' through INT_MAX + * - %M: the minute as a decimal number, using a 24-hour clock, in the + * range '00' through '59' + * - %S: the second as a decimal number, using a 24-hour clock, in the + * range '00' through '59' + * - %Y: the year as a decimal number, using the Gregorian calendar + * - %m: the month as a decimal number, in the range '1' through '12' + * - %d: the day of the month as a decimal number, in the range '1' + * through '31' + * - %%: a literal '%' + * + * @return a pointer to the first character not processed in this + * function call, or NULL in case the function fails to match all of + * the fmt string and therefore an error occurred + */ +char *av_small_strptime(const char *p, const char *fmt, struct tm *dt); + +/** + * Attempt to find a specific tag in a URL. + * + * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. + * Return 1 if found. + */ +int av_find_info_tag(char *arg, int arg_size, const char *tag1, const char *info); + +/** + * Convert the decomposed UTC time in tm to a time_t value. + */ +time_t av_timegm(struct tm *tm); + +#endif /* AVUTIL_PARSEUTILS_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/pixdesc.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/pixdesc.h new file mode 100644 index 0000000..e88bf9b --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/pixdesc.h @@ -0,0 +1,291 @@ +/* + * pixel format descriptor + * Copyright (c) 2009 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_PIXDESC_H +#define AVUTIL_PIXDESC_H + +#include + +#include "attributes.h" +#include "pixfmt.h" + +typedef struct AVComponentDescriptor{ + uint16_t plane :2; ///< which of the 4 planes contains the component + + /** + * Number of elements between 2 horizontally consecutive pixels minus 1. + * Elements are bits for bitstream formats, bytes otherwise. + */ + uint16_t step_minus1 :3; + + /** + * Number of elements before the component of the first pixel plus 1. + * Elements are bits for bitstream formats, bytes otherwise. + */ + uint16_t offset_plus1 :3; + uint16_t shift :3; ///< number of least significant bits that must be shifted away to get the value + uint16_t depth_minus1 :4; ///< number of bits in the component minus 1 +}AVComponentDescriptor; + +/** + * Descriptor that unambiguously describes how the bits of a pixel are + * stored in the up to 4 data planes of an image. It also stores the + * subsampling factors and number of components. + * + * @note This is separate of the colorspace (RGB, YCbCr, YPbPr, JPEG-style YUV + * and all the YUV variants) AVPixFmtDescriptor just stores how values + * are stored not what these values represent. + */ +typedef struct AVPixFmtDescriptor{ + const char *name; + uint8_t nb_components; ///< The number of components each pixel has, (1-4) + + /** + * Amount to shift the luma width right to find the chroma width. + * For YV12 this is 1 for example. + * chroma_width = -((-luma_width) >> log2_chroma_w) + * The note above is needed to ensure rounding up. + * This value only refers to the chroma components. + */ + uint8_t log2_chroma_w; ///< chroma_width = -((-luma_width )>>log2_chroma_w) + + /** + * Amount to shift the luma height right to find the chroma height. + * For YV12 this is 1 for example. + * chroma_height= -((-luma_height) >> log2_chroma_h) + * The note above is needed to ensure rounding up. + * This value only refers to the chroma components. + */ + uint8_t log2_chroma_h; + uint8_t flags; + + /** + * Parameters that describe how pixels are packed. + * If the format has 2 or 4 components, then alpha is last. + * If the format has 1 or 2 components, then luma is 0. + * If the format has 3 or 4 components, + * if the RGB flag is set then 0 is red, 1 is green and 2 is blue; + * otherwise 0 is luma, 1 is chroma-U and 2 is chroma-V. + */ + AVComponentDescriptor comp[4]; +}AVPixFmtDescriptor; + +/** + * Pixel format is big-endian. + */ +#define AV_PIX_FMT_FLAG_BE (1 << 0) +/** + * Pixel format has a palette in data[1], values are indexes in this palette. + */ +#define AV_PIX_FMT_FLAG_PAL (1 << 1) +/** + * All values of a component are bit-wise packed end to end. + */ +#define AV_PIX_FMT_FLAG_BITSTREAM (1 << 2) +/** + * Pixel format is an HW accelerated format. + */ +#define AV_PIX_FMT_FLAG_HWACCEL (1 << 3) +/** + * At least one pixel component is not in the first data plane. + */ +#define AV_PIX_FMT_FLAG_PLANAR (1 << 4) +/** + * The pixel format contains RGB-like data (as opposed to YUV/grayscale). + */ +#define AV_PIX_FMT_FLAG_RGB (1 << 5) +/** + * The pixel format is "pseudo-paletted". This means that FFmpeg treats it as + * paletted internally, but the palette is generated by the decoder and is not + * stored in the file. + */ +#define AV_PIX_FMT_FLAG_PSEUDOPAL (1 << 6) +/** + * The pixel format has an alpha channel. + */ +#define AV_PIX_FMT_FLAG_ALPHA (1 << 7) + +#if FF_API_PIX_FMT +/** + * @deprecated use the AV_PIX_FMT_FLAG_* flags + */ +#define PIX_FMT_BE AV_PIX_FMT_FLAG_BE +#define PIX_FMT_PAL AV_PIX_FMT_FLAG_PAL +#define PIX_FMT_BITSTREAM AV_PIX_FMT_FLAG_BITSTREAM +#define PIX_FMT_HWACCEL AV_PIX_FMT_FLAG_HWACCEL +#define PIX_FMT_PLANAR AV_PIX_FMT_FLAG_PLANAR +#define PIX_FMT_RGB AV_PIX_FMT_FLAG_RGB +#define PIX_FMT_PSEUDOPAL AV_PIX_FMT_FLAG_PSEUDOPAL +#define PIX_FMT_ALPHA AV_PIX_FMT_FLAG_ALPHA +#endif + +#if FF_API_PIX_FMT_DESC +/** + * The array of all the pixel format descriptors. + */ +extern attribute_deprecated const AVPixFmtDescriptor av_pix_fmt_descriptors[]; +#endif + +/** + * Read a line from an image, and write the values of the + * pixel format component c to dst. + * + * @param data the array containing the pointers to the planes of the image + * @param linesize the array containing the linesizes of the image + * @param desc the pixel format descriptor for the image + * @param x the horizontal coordinate of the first pixel to read + * @param y the vertical coordinate of the first pixel to read + * @param w the width of the line to read, that is the number of + * values to write to dst + * @param read_pal_component if not zero and the format is a paletted + * format writes the values corresponding to the palette + * component c in data[1] to dst, rather than the palette indexes in + * data[0]. The behavior is undefined if the format is not paletted. + */ +void av_read_image_line(uint16_t *dst, const uint8_t *data[4], const int linesize[4], + const AVPixFmtDescriptor *desc, int x, int y, int c, int w, int read_pal_component); + +/** + * Write the values from src to the pixel format component c of an + * image line. + * + * @param src array containing the values to write + * @param data the array containing the pointers to the planes of the + * image to write into. It is supposed to be zeroed. + * @param linesize the array containing the linesizes of the image + * @param desc the pixel format descriptor for the image + * @param x the horizontal coordinate of the first pixel to write + * @param y the vertical coordinate of the first pixel to write + * @param w the width of the line to write, that is the number of + * values to write to the image line + */ +void av_write_image_line(const uint16_t *src, uint8_t *data[4], const int linesize[4], + const AVPixFmtDescriptor *desc, int x, int y, int c, int w); + +/** + * Return the pixel format corresponding to name. + * + * If there is no pixel format with name name, then looks for a + * pixel format with the name corresponding to the native endian + * format of name. + * For example in a little-endian system, first looks for "gray16", + * then for "gray16le". + * + * Finally if no pixel format has been found, returns AV_PIX_FMT_NONE. + */ +enum AVPixelFormat av_get_pix_fmt(const char *name); + +/** + * Return the short name for a pixel format, NULL in case pix_fmt is + * unknown. + * + * @see av_get_pix_fmt(), av_get_pix_fmt_string() + */ +const char *av_get_pix_fmt_name(enum AVPixelFormat pix_fmt); + +/** + * Print in buf the string corresponding to the pixel format with + * number pix_fmt, or a header if pix_fmt is negative. + * + * @param buf the buffer where to write the string + * @param buf_size the size of buf + * @param pix_fmt the number of the pixel format to print the + * corresponding info string, or a negative value to print the + * corresponding header. + */ +char *av_get_pix_fmt_string (char *buf, int buf_size, enum AVPixelFormat pix_fmt); + +/** + * Return the number of bits per pixel used by the pixel format + * described by pixdesc. Note that this is not the same as the number + * of bits per sample. + * + * The returned number of bits refers to the number of bits actually + * used for storing the pixel information, that is padding bits are + * not counted. + */ +int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc); + +/** + * Return the number of bits per pixel for the pixel format + * described by pixdesc, including any padding or unused bits. + */ +int av_get_padded_bits_per_pixel(const AVPixFmtDescriptor *pixdesc); + +/** + * @return a pixel format descriptor for provided pixel format or NULL if + * this pixel format is unknown. + */ +const AVPixFmtDescriptor *av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt); + +/** + * Iterate over all pixel format descriptors known to libavutil. + * + * @param prev previous descriptor. NULL to get the first descriptor. + * + * @return next descriptor or NULL after the last descriptor + */ +const AVPixFmtDescriptor *av_pix_fmt_desc_next(const AVPixFmtDescriptor *prev); + +/** + * @return an AVPixelFormat id described by desc, or AV_PIX_FMT_NONE if desc + * is not a valid pointer to a pixel format descriptor. + */ +enum AVPixelFormat av_pix_fmt_desc_get_id(const AVPixFmtDescriptor *desc); + +/** + * Utility function to access log2_chroma_w log2_chroma_h from + * the pixel format AVPixFmtDescriptor. + * + * See avcodec_get_chroma_sub_sample() for a function that asserts a + * valid pixel format instead of returning an error code. + * Its recommanded that you use avcodec_get_chroma_sub_sample unless + * you do check the return code! + * + * @param[in] pix_fmt the pixel format + * @param[out] h_shift store log2_chroma_w + * @param[out] v_shift store log2_chroma_h + * + * @return 0 on success, AVERROR(ENOSYS) on invalid or unknown pixel format + */ +int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, + int *h_shift, int *v_shift); + +/** + * @return number of planes in pix_fmt, a negative AVERROR if pix_fmt is not a + * valid pixel format. + */ +int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt); + +void ff_check_pixfmt_descriptors(void); + +/** + * Utility function to swap the endianness of a pixel format. + * + * @param[in] pix_fmt the pixel format + * + * @return pixel format with swapped endianness if it exists, + * otherwise AV_PIX_FMT_NONE + */ +enum AVPixelFormat av_pix_fmt_swap_endianness(enum AVPixelFormat pix_fmt); + + +#endif /* AVUTIL_PIXDESC_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/pixfmt.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/pixfmt.h new file mode 100644 index 0000000..3d32d3e --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/pixfmt.h @@ -0,0 +1,399 @@ +/* + * copyright (c) 2006 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_PIXFMT_H +#define AVUTIL_PIXFMT_H + +/** + * @file + * pixel format definitions + * + */ + +#include "libavutil/avconfig.h" +#include "version.h" + +#define AVPALETTE_SIZE 1024 +#define AVPALETTE_COUNT 256 + +/** + * Pixel format. + * + * @note + * AV_PIX_FMT_RGB32 is handled in an endian-specific manner. An RGBA + * color is put together as: + * (A << 24) | (R << 16) | (G << 8) | B + * This is stored as BGRA on little-endian CPU architectures and ARGB on + * big-endian CPUs. + * + * @par + * When the pixel format is palettized RGB (AV_PIX_FMT_PAL8), the palettized + * image data is stored in AVFrame.data[0]. The palette is transported in + * AVFrame.data[1], is 1024 bytes long (256 4-byte entries) and is + * formatted the same as in AV_PIX_FMT_RGB32 described above (i.e., it is + * also endian-specific). Note also that the individual RGB palette + * components stored in AVFrame.data[1] should be in the range 0..255. + * This is important as many custom PAL8 video codecs that were designed + * to run on the IBM VGA graphics adapter use 6-bit palette components. + * + * @par + * For all the 8bit per pixel formats, an RGB32 palette is in data[1] like + * for pal8. This palette is filled in automatically by the function + * allocating the picture. + * + * @note + * Make sure that all newly added big-endian formats have (pix_fmt & 1) == 1 + * and that all newly added little-endian formats have (pix_fmt & 1) == 0. + * This allows simpler detection of big vs little-endian. + */ +enum AVPixelFormat { + AV_PIX_FMT_NONE = -1, + AV_PIX_FMT_YUV420P, ///< planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples) + AV_PIX_FMT_YUYV422, ///< packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr + AV_PIX_FMT_RGB24, ///< packed RGB 8:8:8, 24bpp, RGBRGB... + AV_PIX_FMT_BGR24, ///< packed RGB 8:8:8, 24bpp, BGRBGR... + AV_PIX_FMT_YUV422P, ///< planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples) + AV_PIX_FMT_YUV444P, ///< planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples) + AV_PIX_FMT_YUV410P, ///< planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples) + AV_PIX_FMT_YUV411P, ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) + AV_PIX_FMT_GRAY8, ///< Y , 8bpp + AV_PIX_FMT_MONOWHITE, ///< Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb + AV_PIX_FMT_MONOBLACK, ///< Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb + AV_PIX_FMT_PAL8, ///< 8 bit with PIX_FMT_RGB32 palette + AV_PIX_FMT_YUVJ420P, ///< planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV420P and setting color_range + AV_PIX_FMT_YUVJ422P, ///< planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV422P and setting color_range + AV_PIX_FMT_YUVJ444P, ///< planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV444P and setting color_range +#if FF_API_XVMC + AV_PIX_FMT_XVMC_MPEG2_MC,///< XVideo Motion Acceleration via common packet passing + AV_PIX_FMT_XVMC_MPEG2_IDCT, +#endif /* FF_API_XVMC */ + AV_PIX_FMT_UYVY422, ///< packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1 + AV_PIX_FMT_UYYVYY411, ///< packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3 + AV_PIX_FMT_BGR8, ///< packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb) + AV_PIX_FMT_BGR4, ///< packed RGB 1:2:1 bitstream, 4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits + AV_PIX_FMT_BGR4_BYTE, ///< packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb) + AV_PIX_FMT_RGB8, ///< packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb) + AV_PIX_FMT_RGB4, ///< packed RGB 1:2:1 bitstream, 4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in the byte is the one composed by the 4 msb bits + AV_PIX_FMT_RGB4_BYTE, ///< packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb) + AV_PIX_FMT_NV12, ///< planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (first byte U and the following byte V) + AV_PIX_FMT_NV21, ///< as above, but U and V bytes are swapped + + AV_PIX_FMT_ARGB, ///< packed ARGB 8:8:8:8, 32bpp, ARGBARGB... + AV_PIX_FMT_RGBA, ///< packed RGBA 8:8:8:8, 32bpp, RGBARGBA... + AV_PIX_FMT_ABGR, ///< packed ABGR 8:8:8:8, 32bpp, ABGRABGR... + AV_PIX_FMT_BGRA, ///< packed BGRA 8:8:8:8, 32bpp, BGRABGRA... + + AV_PIX_FMT_GRAY16BE, ///< Y , 16bpp, big-endian + AV_PIX_FMT_GRAY16LE, ///< Y , 16bpp, little-endian + AV_PIX_FMT_YUV440P, ///< planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples) + AV_PIX_FMT_YUVJ440P, ///< planar YUV 4:4:0 full scale (JPEG), deprecated in favor of PIX_FMT_YUV440P and setting color_range + AV_PIX_FMT_YUVA420P, ///< planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples) +#if FF_API_VDPAU + AV_PIX_FMT_VDPAU_H264,///< H.264 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers + AV_PIX_FMT_VDPAU_MPEG1,///< MPEG-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers + AV_PIX_FMT_VDPAU_MPEG2,///< MPEG-2 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers + AV_PIX_FMT_VDPAU_WMV3,///< WMV3 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers + AV_PIX_FMT_VDPAU_VC1, ///< VC-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers +#endif + AV_PIX_FMT_RGB48BE, ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big-endian + AV_PIX_FMT_RGB48LE, ///< packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as little-endian + + AV_PIX_FMT_RGB565BE, ///< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian + AV_PIX_FMT_RGB565LE, ///< packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian + AV_PIX_FMT_RGB555BE, ///< packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), big-endian, most significant bit to 0 + AV_PIX_FMT_RGB555LE, ///< packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), little-endian, most significant bit to 0 + + AV_PIX_FMT_BGR565BE, ///< packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian + AV_PIX_FMT_BGR565LE, ///< packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian + AV_PIX_FMT_BGR555BE, ///< packed BGR 5:5:5, 16bpp, (msb)1A 5B 5G 5R(lsb), big-endian, most significant bit to 1 + AV_PIX_FMT_BGR555LE, ///< packed BGR 5:5:5, 16bpp, (msb)1A 5B 5G 5R(lsb), little-endian, most significant bit to 1 + + AV_PIX_FMT_VAAPI_MOCO, ///< HW acceleration through VA API at motion compensation entry-point, Picture.data[3] contains a vaapi_render_state struct which contains macroblocks as well as various fields extracted from headers + AV_PIX_FMT_VAAPI_IDCT, ///< HW acceleration through VA API at IDCT entry-point, Picture.data[3] contains a vaapi_render_state struct which contains fields extracted from headers + AV_PIX_FMT_VAAPI_VLD, ///< HW decoding through VA API, Picture.data[3] contains a vaapi_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers + + AV_PIX_FMT_YUV420P16LE, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian + AV_PIX_FMT_YUV420P16BE, ///< planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian + AV_PIX_FMT_YUV422P16LE, ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian + AV_PIX_FMT_YUV422P16BE, ///< planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian + AV_PIX_FMT_YUV444P16LE, ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian + AV_PIX_FMT_YUV444P16BE, ///< planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian +#if FF_API_VDPAU + AV_PIX_FMT_VDPAU_MPEG4, ///< MPEG4 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstream of the slices as well as various fields extracted from headers +#endif + AV_PIX_FMT_DXVA2_VLD, ///< HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer + + AV_PIX_FMT_RGB444LE, ///< packed RGB 4:4:4, 16bpp, (msb)4A 4R 4G 4B(lsb), little-endian, most significant bits to 0 + AV_PIX_FMT_RGB444BE, ///< packed RGB 4:4:4, 16bpp, (msb)4A 4R 4G 4B(lsb), big-endian, most significant bits to 0 + AV_PIX_FMT_BGR444LE, ///< packed BGR 4:4:4, 16bpp, (msb)4A 4B 4G 4R(lsb), little-endian, most significant bits to 1 + AV_PIX_FMT_BGR444BE, ///< packed BGR 4:4:4, 16bpp, (msb)4A 4B 4G 4R(lsb), big-endian, most significant bits to 1 + AV_PIX_FMT_GRAY8A, ///< 8bit gray, 8bit alpha + AV_PIX_FMT_BGR48BE, ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big-endian + AV_PIX_FMT_BGR48LE, ///< packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as little-endian + + /** + * The following 12 formats have the disadvantage of needing 1 format for each bit depth. + * Notice that each 9/10 bits sample is stored in 16 bits with extra padding. + * If you want to support multiple bit depths, then using AV_PIX_FMT_YUV420P16* with the bpp stored separately is better. + */ + AV_PIX_FMT_YUV420P9BE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian + AV_PIX_FMT_YUV420P9LE, ///< planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian + AV_PIX_FMT_YUV420P10BE,///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian + AV_PIX_FMT_YUV420P10LE,///< planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian + AV_PIX_FMT_YUV422P10BE,///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian + AV_PIX_FMT_YUV422P10LE,///< planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian + AV_PIX_FMT_YUV444P9BE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian + AV_PIX_FMT_YUV444P9LE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian + AV_PIX_FMT_YUV444P10BE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian + AV_PIX_FMT_YUV444P10LE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian + AV_PIX_FMT_YUV422P9BE, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian + AV_PIX_FMT_YUV422P9LE, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian + AV_PIX_FMT_VDA_VLD, ///< hardware decoding through VDA + +#ifdef AV_PIX_FMT_ABI_GIT_MASTER + AV_PIX_FMT_RGBA64BE, ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian + AV_PIX_FMT_RGBA64LE, ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian + AV_PIX_FMT_BGRA64BE, ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian + AV_PIX_FMT_BGRA64LE, ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian +#endif + AV_PIX_FMT_GBRP, ///< planar GBR 4:4:4 24bpp + AV_PIX_FMT_GBRP9BE, ///< planar GBR 4:4:4 27bpp, big-endian + AV_PIX_FMT_GBRP9LE, ///< planar GBR 4:4:4 27bpp, little-endian + AV_PIX_FMT_GBRP10BE, ///< planar GBR 4:4:4 30bpp, big-endian + AV_PIX_FMT_GBRP10LE, ///< planar GBR 4:4:4 30bpp, little-endian + AV_PIX_FMT_GBRP16BE, ///< planar GBR 4:4:4 48bpp, big-endian + AV_PIX_FMT_GBRP16LE, ///< planar GBR 4:4:4 48bpp, little-endian + + /** + * duplicated pixel formats for compatibility with libav. + * FFmpeg supports these formats since May 8 2012 and Jan 28 2012 (commits f9ca1ac7 and 143a5c55) + * Libav added them Oct 12 2012 with incompatible values (commit 6d5600e85) + */ + AV_PIX_FMT_YUVA422P_LIBAV, ///< planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples) + AV_PIX_FMT_YUVA444P_LIBAV, ///< planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples) + + AV_PIX_FMT_YUVA420P9BE, ///< planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), big-endian + AV_PIX_FMT_YUVA420P9LE, ///< planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian + AV_PIX_FMT_YUVA422P9BE, ///< planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian + AV_PIX_FMT_YUVA422P9LE, ///< planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian + AV_PIX_FMT_YUVA444P9BE, ///< planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian + AV_PIX_FMT_YUVA444P9LE, ///< planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian + AV_PIX_FMT_YUVA420P10BE, ///< planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian) + AV_PIX_FMT_YUVA420P10LE, ///< planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian) + AV_PIX_FMT_YUVA422P10BE, ///< planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian) + AV_PIX_FMT_YUVA422P10LE, ///< planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian) + AV_PIX_FMT_YUVA444P10BE, ///< planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian) + AV_PIX_FMT_YUVA444P10LE, ///< planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian) + AV_PIX_FMT_YUVA420P16BE, ///< planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian) + AV_PIX_FMT_YUVA420P16LE, ///< planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian) + AV_PIX_FMT_YUVA422P16BE, ///< planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian) + AV_PIX_FMT_YUVA422P16LE, ///< planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian) + AV_PIX_FMT_YUVA444P16BE, ///< planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian) + AV_PIX_FMT_YUVA444P16LE, ///< planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian) + + AV_PIX_FMT_VDPAU, ///< HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface + + AV_PIX_FMT_XYZ12LE, ///< packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as little-endian, the 4 lower bits are set to 0 + AV_PIX_FMT_XYZ12BE, ///< packed XYZ 4:4:4, 36 bpp, (msb) 12X, 12Y, 12Z (lsb), the 2-byte value for each X/Y/Z is stored as big-endian, the 4 lower bits are set to 0 + AV_PIX_FMT_NV16, ///< interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples) + AV_PIX_FMT_NV20LE, ///< interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian + AV_PIX_FMT_NV20BE, ///< interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian + +#ifndef AV_PIX_FMT_ABI_GIT_MASTER + AV_PIX_FMT_RGBA64BE=0x123, ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian + AV_PIX_FMT_RGBA64LE, ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian + AV_PIX_FMT_BGRA64BE, ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian + AV_PIX_FMT_BGRA64LE, ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian +#endif + AV_PIX_FMT_0RGB=0x123+4, ///< packed RGB 8:8:8, 32bpp, 0RGB0RGB... + AV_PIX_FMT_RGB0, ///< packed RGB 8:8:8, 32bpp, RGB0RGB0... + AV_PIX_FMT_0BGR, ///< packed BGR 8:8:8, 32bpp, 0BGR0BGR... + AV_PIX_FMT_BGR0, ///< packed BGR 8:8:8, 32bpp, BGR0BGR0... + AV_PIX_FMT_YUVA444P, ///< planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples) + AV_PIX_FMT_YUVA422P, ///< planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples) + + AV_PIX_FMT_YUV420P12BE, ///< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian + AV_PIX_FMT_YUV420P12LE, ///< planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian + AV_PIX_FMT_YUV420P14BE, ///< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian + AV_PIX_FMT_YUV420P14LE, ///< planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian + AV_PIX_FMT_YUV422P12BE, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian + AV_PIX_FMT_YUV422P12LE, ///< planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian + AV_PIX_FMT_YUV422P14BE, ///< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian + AV_PIX_FMT_YUV422P14LE, ///< planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian + AV_PIX_FMT_YUV444P12BE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian + AV_PIX_FMT_YUV444P12LE, ///< planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian + AV_PIX_FMT_YUV444P14BE, ///< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian + AV_PIX_FMT_YUV444P14LE, ///< planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian + AV_PIX_FMT_GBRP12BE, ///< planar GBR 4:4:4 36bpp, big-endian + AV_PIX_FMT_GBRP12LE, ///< planar GBR 4:4:4 36bpp, little-endian + AV_PIX_FMT_GBRP14BE, ///< planar GBR 4:4:4 42bpp, big-endian + AV_PIX_FMT_GBRP14LE, ///< planar GBR 4:4:4 42bpp, little-endian + AV_PIX_FMT_GBRAP, ///< planar GBRA 4:4:4:4 32bpp + AV_PIX_FMT_GBRAP16BE, ///< planar GBRA 4:4:4:4 64bpp, big-endian + AV_PIX_FMT_GBRAP16LE, ///< planar GBRA 4:4:4:4 64bpp, little-endian + AV_PIX_FMT_YUVJ411P, ///< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor of PIX_FMT_YUV411P and setting color_range + + AV_PIX_FMT_BAYER_BGGR8, ///< bayer, BGBG..(odd line), GRGR..(even line), 8-bit samples */ + AV_PIX_FMT_BAYER_RGGB8, ///< bayer, RGRG..(odd line), GBGB..(even line), 8-bit samples */ + AV_PIX_FMT_BAYER_GBRG8, ///< bayer, GBGB..(odd line), RGRG..(even line), 8-bit samples */ + AV_PIX_FMT_BAYER_GRBG8, ///< bayer, GRGR..(odd line), BGBG..(even line), 8-bit samples */ + AV_PIX_FMT_BAYER_BGGR16LE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, little-endian */ + AV_PIX_FMT_BAYER_BGGR16BE, ///< bayer, BGBG..(odd line), GRGR..(even line), 16-bit samples, big-endian */ + AV_PIX_FMT_BAYER_RGGB16LE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, little-endian */ + AV_PIX_FMT_BAYER_RGGB16BE, ///< bayer, RGRG..(odd line), GBGB..(even line), 16-bit samples, big-endian */ + AV_PIX_FMT_BAYER_GBRG16LE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, little-endian */ + AV_PIX_FMT_BAYER_GBRG16BE, ///< bayer, GBGB..(odd line), RGRG..(even line), 16-bit samples, big-endian */ + AV_PIX_FMT_BAYER_GRBG16LE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, little-endian */ + AV_PIX_FMT_BAYER_GRBG16BE, ///< bayer, GRGR..(odd line), BGBG..(even line), 16-bit samples, big-endian */ + + AV_PIX_FMT_NB, ///< number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions + +#if FF_API_PIX_FMT +#include "old_pix_fmts.h" +#endif +}; + +#if AV_HAVE_INCOMPATIBLE_LIBAV_ABI +#define AV_PIX_FMT_YUVA422P AV_PIX_FMT_YUVA422P_LIBAV +#define AV_PIX_FMT_YUVA444P AV_PIX_FMT_YUVA444P_LIBAV +#endif + + +#define AV_PIX_FMT_Y400A AV_PIX_FMT_GRAY8A +#define AV_PIX_FMT_GBR24P AV_PIX_FMT_GBRP + +#if AV_HAVE_BIGENDIAN +# define AV_PIX_FMT_NE(be, le) AV_PIX_FMT_##be +#else +# define AV_PIX_FMT_NE(be, le) AV_PIX_FMT_##le +#endif + +#define AV_PIX_FMT_RGB32 AV_PIX_FMT_NE(ARGB, BGRA) +#define AV_PIX_FMT_RGB32_1 AV_PIX_FMT_NE(RGBA, ABGR) +#define AV_PIX_FMT_BGR32 AV_PIX_FMT_NE(ABGR, RGBA) +#define AV_PIX_FMT_BGR32_1 AV_PIX_FMT_NE(BGRA, ARGB) +#define AV_PIX_FMT_0RGB32 AV_PIX_FMT_NE(0RGB, BGR0) +#define AV_PIX_FMT_0BGR32 AV_PIX_FMT_NE(0BGR, RGB0) + +#define AV_PIX_FMT_GRAY16 AV_PIX_FMT_NE(GRAY16BE, GRAY16LE) +#define AV_PIX_FMT_RGB48 AV_PIX_FMT_NE(RGB48BE, RGB48LE) +#define AV_PIX_FMT_RGB565 AV_PIX_FMT_NE(RGB565BE, RGB565LE) +#define AV_PIX_FMT_RGB555 AV_PIX_FMT_NE(RGB555BE, RGB555LE) +#define AV_PIX_FMT_RGB444 AV_PIX_FMT_NE(RGB444BE, RGB444LE) +#define AV_PIX_FMT_BGR48 AV_PIX_FMT_NE(BGR48BE, BGR48LE) +#define AV_PIX_FMT_BGR565 AV_PIX_FMT_NE(BGR565BE, BGR565LE) +#define AV_PIX_FMT_BGR555 AV_PIX_FMT_NE(BGR555BE, BGR555LE) +#define AV_PIX_FMT_BGR444 AV_PIX_FMT_NE(BGR444BE, BGR444LE) + +#define AV_PIX_FMT_YUV420P9 AV_PIX_FMT_NE(YUV420P9BE , YUV420P9LE) +#define AV_PIX_FMT_YUV422P9 AV_PIX_FMT_NE(YUV422P9BE , YUV422P9LE) +#define AV_PIX_FMT_YUV444P9 AV_PIX_FMT_NE(YUV444P9BE , YUV444P9LE) +#define AV_PIX_FMT_YUV420P10 AV_PIX_FMT_NE(YUV420P10BE, YUV420P10LE) +#define AV_PIX_FMT_YUV422P10 AV_PIX_FMT_NE(YUV422P10BE, YUV422P10LE) +#define AV_PIX_FMT_YUV444P10 AV_PIX_FMT_NE(YUV444P10BE, YUV444P10LE) +#define AV_PIX_FMT_YUV420P12 AV_PIX_FMT_NE(YUV420P12BE, YUV420P12LE) +#define AV_PIX_FMT_YUV422P12 AV_PIX_FMT_NE(YUV422P12BE, YUV422P12LE) +#define AV_PIX_FMT_YUV444P12 AV_PIX_FMT_NE(YUV444P12BE, YUV444P12LE) +#define AV_PIX_FMT_YUV420P14 AV_PIX_FMT_NE(YUV420P14BE, YUV420P14LE) +#define AV_PIX_FMT_YUV422P14 AV_PIX_FMT_NE(YUV422P14BE, YUV422P14LE) +#define AV_PIX_FMT_YUV444P14 AV_PIX_FMT_NE(YUV444P14BE, YUV444P14LE) +#define AV_PIX_FMT_YUV420P16 AV_PIX_FMT_NE(YUV420P16BE, YUV420P16LE) +#define AV_PIX_FMT_YUV422P16 AV_PIX_FMT_NE(YUV422P16BE, YUV422P16LE) +#define AV_PIX_FMT_YUV444P16 AV_PIX_FMT_NE(YUV444P16BE, YUV444P16LE) + +#define AV_PIX_FMT_RGBA64 AV_PIX_FMT_NE(RGBA64BE, RGBA64LE) +#define AV_PIX_FMT_BGRA64 AV_PIX_FMT_NE(BGRA64BE, BGRA64LE) +#define AV_PIX_FMT_GBRP9 AV_PIX_FMT_NE(GBRP9BE , GBRP9LE) +#define AV_PIX_FMT_GBRP10 AV_PIX_FMT_NE(GBRP10BE, GBRP10LE) +#define AV_PIX_FMT_GBRP12 AV_PIX_FMT_NE(GBRP12BE, GBRP12LE) +#define AV_PIX_FMT_GBRP14 AV_PIX_FMT_NE(GBRP14BE, GBRP14LE) +#define AV_PIX_FMT_GBRP16 AV_PIX_FMT_NE(GBRP16BE, GBRP16LE) +#define AV_PIX_FMT_GBRAP16 AV_PIX_FMT_NE(GBRAP16BE, GBRAP16LE) + +#define AV_PIX_FMT_BAYER_BGGR16 AV_PIX_FMT_NE(BAYER_BGGR16BE, BAYER_BGGR16LE) +#define AV_PIX_FMT_BAYER_RGGB16 AV_PIX_FMT_NE(BAYER_RGGB16BE, BAYER_RGGB16LE) +#define AV_PIX_FMT_BAYER_GBRG16 AV_PIX_FMT_NE(BAYER_GBRG16BE, BAYER_GBRG16LE) +#define AV_PIX_FMT_BAYER_GRBG16 AV_PIX_FMT_NE(BAYER_GRBG16BE, BAYER_GRBG16LE) + + +#define AV_PIX_FMT_YUVA420P9 AV_PIX_FMT_NE(YUVA420P9BE , YUVA420P9LE) +#define AV_PIX_FMT_YUVA422P9 AV_PIX_FMT_NE(YUVA422P9BE , YUVA422P9LE) +#define AV_PIX_FMT_YUVA444P9 AV_PIX_FMT_NE(YUVA444P9BE , YUVA444P9LE) +#define AV_PIX_FMT_YUVA420P10 AV_PIX_FMT_NE(YUVA420P10BE, YUVA420P10LE) +#define AV_PIX_FMT_YUVA422P10 AV_PIX_FMT_NE(YUVA422P10BE, YUVA422P10LE) +#define AV_PIX_FMT_YUVA444P10 AV_PIX_FMT_NE(YUVA444P10BE, YUVA444P10LE) +#define AV_PIX_FMT_YUVA420P16 AV_PIX_FMT_NE(YUVA420P16BE, YUVA420P16LE) +#define AV_PIX_FMT_YUVA422P16 AV_PIX_FMT_NE(YUVA422P16BE, YUVA422P16LE) +#define AV_PIX_FMT_YUVA444P16 AV_PIX_FMT_NE(YUVA444P16BE, YUVA444P16LE) + +#define AV_PIX_FMT_XYZ12 AV_PIX_FMT_NE(XYZ12BE, XYZ12LE) +#define AV_PIX_FMT_NV20 AV_PIX_FMT_NE(NV20BE, NV20LE) + +#if FF_API_PIX_FMT +#define PixelFormat AVPixelFormat + +#define PIX_FMT_Y400A AV_PIX_FMT_Y400A +#define PIX_FMT_GBR24P AV_PIX_FMT_GBR24P + +#define PIX_FMT_NE(be, le) AV_PIX_FMT_NE(be, le) + +#define PIX_FMT_RGB32 AV_PIX_FMT_RGB32 +#define PIX_FMT_RGB32_1 AV_PIX_FMT_RGB32_1 +#define PIX_FMT_BGR32 AV_PIX_FMT_BGR32 +#define PIX_FMT_BGR32_1 AV_PIX_FMT_BGR32_1 +#define PIX_FMT_0RGB32 AV_PIX_FMT_0RGB32 +#define PIX_FMT_0BGR32 AV_PIX_FMT_0BGR32 + +#define PIX_FMT_GRAY16 AV_PIX_FMT_GRAY16 +#define PIX_FMT_RGB48 AV_PIX_FMT_RGB48 +#define PIX_FMT_RGB565 AV_PIX_FMT_RGB565 +#define PIX_FMT_RGB555 AV_PIX_FMT_RGB555 +#define PIX_FMT_RGB444 AV_PIX_FMT_RGB444 +#define PIX_FMT_BGR48 AV_PIX_FMT_BGR48 +#define PIX_FMT_BGR565 AV_PIX_FMT_BGR565 +#define PIX_FMT_BGR555 AV_PIX_FMT_BGR555 +#define PIX_FMT_BGR444 AV_PIX_FMT_BGR444 + +#define PIX_FMT_YUV420P9 AV_PIX_FMT_YUV420P9 +#define PIX_FMT_YUV422P9 AV_PIX_FMT_YUV422P9 +#define PIX_FMT_YUV444P9 AV_PIX_FMT_YUV444P9 +#define PIX_FMT_YUV420P10 AV_PIX_FMT_YUV420P10 +#define PIX_FMT_YUV422P10 AV_PIX_FMT_YUV422P10 +#define PIX_FMT_YUV444P10 AV_PIX_FMT_YUV444P10 +#define PIX_FMT_YUV420P12 AV_PIX_FMT_YUV420P12 +#define PIX_FMT_YUV422P12 AV_PIX_FMT_YUV422P12 +#define PIX_FMT_YUV444P12 AV_PIX_FMT_YUV444P12 +#define PIX_FMT_YUV420P14 AV_PIX_FMT_YUV420P14 +#define PIX_FMT_YUV422P14 AV_PIX_FMT_YUV422P14 +#define PIX_FMT_YUV444P14 AV_PIX_FMT_YUV444P14 +#define PIX_FMT_YUV420P16 AV_PIX_FMT_YUV420P16 +#define PIX_FMT_YUV422P16 AV_PIX_FMT_YUV422P16 +#define PIX_FMT_YUV444P16 AV_PIX_FMT_YUV444P16 + +#define PIX_FMT_RGBA64 AV_PIX_FMT_RGBA64 +#define PIX_FMT_BGRA64 AV_PIX_FMT_BGRA64 +#define PIX_FMT_GBRP9 AV_PIX_FMT_GBRP9 +#define PIX_FMT_GBRP10 AV_PIX_FMT_GBRP10 +#define PIX_FMT_GBRP12 AV_PIX_FMT_GBRP12 +#define PIX_FMT_GBRP14 AV_PIX_FMT_GBRP14 +#define PIX_FMT_GBRP16 AV_PIX_FMT_GBRP16 +#endif + +#endif /* AVUTIL_PIXFMT_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/random_seed.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/random_seed.h new file mode 100644 index 0000000..0462a04 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/random_seed.h @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2009 Baptiste Coudurier + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_RANDOM_SEED_H +#define AVUTIL_RANDOM_SEED_H + +#include +/** + * @addtogroup lavu_crypto + * @{ + */ + +/** + * Get a seed to use in conjunction with random functions. + * This function tries to provide a good seed at a best effort bases. + * Its possible to call this function multiple times if more bits are needed. + * It can be quite slow, which is why it should only be used as seed for a faster + * PRNG. The quality of the seed depends on the platform. + */ +uint32_t av_get_random_seed(void); + +/** + * @} + */ + +#endif /* AVUTIL_RANDOM_SEED_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/rational.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/rational.h new file mode 100644 index 0000000..b9800ee --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/rational.h @@ -0,0 +1,155 @@ +/* + * rational numbers + * Copyright (c) 2003 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file + * rational numbers + * @author Michael Niedermayer + */ + +#ifndef AVUTIL_RATIONAL_H +#define AVUTIL_RATIONAL_H + +#include +#include +#include "attributes.h" + +/** + * @addtogroup lavu_math + * @{ + */ + +/** + * rational number numerator/denominator + */ +typedef struct AVRational{ + int num; ///< numerator + int den; ///< denominator +} AVRational; + +/** + * Compare two rationals. + * @param a first rational + * @param b second rational + * @return 0 if a==b, 1 if a>b, -1 if a>63)|1; + else if(b.den && a.den) return 0; + else if(a.num && b.num) return (a.num>>31) - (b.num>>31); + else return INT_MIN; +} + +/** + * Convert rational to double. + * @param a rational to convert + * @return (double) a + */ +static inline double av_q2d(AVRational a){ + return a.num / (double) a.den; +} + +/** + * Reduce a fraction. + * This is useful for framerate calculations. + * @param dst_num destination numerator + * @param dst_den destination denominator + * @param num source numerator + * @param den source denominator + * @param max the maximum allowed for dst_num & dst_den + * @return 1 if exact, 0 otherwise + */ +int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max); + +/** + * Multiply two rationals. + * @param b first rational + * @param c second rational + * @return b*c + */ +AVRational av_mul_q(AVRational b, AVRational c) av_const; + +/** + * Divide one rational by another. + * @param b first rational + * @param c second rational + * @return b/c + */ +AVRational av_div_q(AVRational b, AVRational c) av_const; + +/** + * Add two rationals. + * @param b first rational + * @param c second rational + * @return b+c + */ +AVRational av_add_q(AVRational b, AVRational c) av_const; + +/** + * Subtract one rational from another. + * @param b first rational + * @param c second rational + * @return b-c + */ +AVRational av_sub_q(AVRational b, AVRational c) av_const; + +/** + * Invert a rational. + * @param q value + * @return 1 / q + */ +static av_always_inline AVRational av_inv_q(AVRational q) +{ + AVRational r = { q.den, q.num }; + return r; +} + +/** + * Convert a double precision floating point number to a rational. + * inf is expressed as {1,0} or {-1,0} depending on the sign. + * + * @param d double to convert + * @param max the maximum allowed numerator and denominator + * @return (AVRational) d + */ +AVRational av_d2q(double d, int max) av_const; + +/** + * @return 1 if q1 is nearer to q than q2, -1 if q2 is nearer + * than q1, 0 if they have the same distance. + */ +int av_nearer_q(AVRational q, AVRational q1, AVRational q2); + +/** + * Find the nearest value in q_list to q. + * @param q_list an array of rationals terminated by {0, 0} + * @return the index of the nearest value found in the array + */ +int av_find_nearest_q_idx(AVRational q, const AVRational* q_list); + +/** + * @} + */ + +#endif /* AVUTIL_RATIONAL_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/ripemd.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/ripemd.h new file mode 100644 index 0000000..7b0c8bc --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/ripemd.h @@ -0,0 +1,75 @@ +/* + * Copyright (C) 2007 Michael Niedermayer + * Copyright (C) 2013 James Almer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_RIPEMD_H +#define AVUTIL_RIPEMD_H + +#include + +#include "attributes.h" +#include "version.h" + +/** + * @defgroup lavu_ripemd RIPEMD + * @ingroup lavu_crypto + * @{ + */ + +extern const int av_ripemd_size; + +struct AVRIPEMD; + +/** + * Allocate an AVRIPEMD context. + */ +struct AVRIPEMD *av_ripemd_alloc(void); + +/** + * Initialize RIPEMD hashing. + * + * @param context pointer to the function context (of size av_ripemd_size) + * @param bits number of bits in digest (128, 160, 256 or 320 bits) + * @return zero if initialization succeeded, -1 otherwise + */ +int av_ripemd_init(struct AVRIPEMD* context, int bits); + +/** + * Update hash value. + * + * @param context hash function context + * @param data input data to update hash with + * @param len input data length + */ +void av_ripemd_update(struct AVRIPEMD* context, const uint8_t* data, unsigned int len); + +/** + * Finish hashing and output digest value. + * + * @param context hash function context + * @param digest buffer where output digest value is stored + */ +void av_ripemd_final(struct AVRIPEMD* context, uint8_t *digest); + +/** + * @} + */ + +#endif /* AVUTIL_RIPEMD_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/samplefmt.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/samplefmt.h new file mode 100644 index 0000000..db17d43 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/samplefmt.h @@ -0,0 +1,256 @@ +/* + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_SAMPLEFMT_H +#define AVUTIL_SAMPLEFMT_H + +#include + +#include "avutil.h" +#include "attributes.h" + +/** + * Audio Sample Formats + * + * @par + * The data described by the sample format is always in native-endian order. + * Sample values can be expressed by native C types, hence the lack of a signed + * 24-bit sample format even though it is a common raw audio data format. + * + * @par + * The floating-point formats are based on full volume being in the range + * [-1.0, 1.0]. Any values outside this range are beyond full volume level. + * + * @par + * The data layout as used in av_samples_fill_arrays() and elsewhere in FFmpeg + * (such as AVFrame in libavcodec) is as follows: + * + * For planar sample formats, each audio channel is in a separate data plane, + * and linesize is the buffer size, in bytes, for a single plane. All data + * planes must be the same size. For packed sample formats, only the first data + * plane is used, and samples for each channel are interleaved. In this case, + * linesize is the buffer size, in bytes, for the 1 plane. + */ +enum AVSampleFormat { + AV_SAMPLE_FMT_NONE = -1, + AV_SAMPLE_FMT_U8, ///< unsigned 8 bits + AV_SAMPLE_FMT_S16, ///< signed 16 bits + AV_SAMPLE_FMT_S32, ///< signed 32 bits + AV_SAMPLE_FMT_FLT, ///< float + AV_SAMPLE_FMT_DBL, ///< double + + AV_SAMPLE_FMT_U8P, ///< unsigned 8 bits, planar + AV_SAMPLE_FMT_S16P, ///< signed 16 bits, planar + AV_SAMPLE_FMT_S32P, ///< signed 32 bits, planar + AV_SAMPLE_FMT_FLTP, ///< float, planar + AV_SAMPLE_FMT_DBLP, ///< double, planar + + AV_SAMPLE_FMT_NB ///< Number of sample formats. DO NOT USE if linking dynamically +}; + +/** + * Return the name of sample_fmt, or NULL if sample_fmt is not + * recognized. + */ +const char *av_get_sample_fmt_name(enum AVSampleFormat sample_fmt); + +/** + * Return a sample format corresponding to name, or AV_SAMPLE_FMT_NONE + * on error. + */ +enum AVSampleFormat av_get_sample_fmt(const char *name); + +/** + * Return the planar<->packed alternative form of the given sample format, or + * AV_SAMPLE_FMT_NONE on error. If the passed sample_fmt is already in the + * requested planar/packed format, the format returned is the same as the + * input. + */ +enum AVSampleFormat av_get_alt_sample_fmt(enum AVSampleFormat sample_fmt, int planar); + +/** + * Get the packed alternative form of the given sample format. + * + * If the passed sample_fmt is already in packed format, the format returned is + * the same as the input. + * + * @return the packed alternative form of the given sample format or + AV_SAMPLE_FMT_NONE on error. + */ +enum AVSampleFormat av_get_packed_sample_fmt(enum AVSampleFormat sample_fmt); + +/** + * Get the planar alternative form of the given sample format. + * + * If the passed sample_fmt is already in planar format, the format returned is + * the same as the input. + * + * @return the planar alternative form of the given sample format or + AV_SAMPLE_FMT_NONE on error. + */ +enum AVSampleFormat av_get_planar_sample_fmt(enum AVSampleFormat sample_fmt); + +/** + * Generate a string corresponding to the sample format with + * sample_fmt, or a header if sample_fmt is negative. + * + * @param buf the buffer where to write the string + * @param buf_size the size of buf + * @param sample_fmt the number of the sample format to print the + * corresponding info string, or a negative value to print the + * corresponding header. + * @return the pointer to the filled buffer or NULL if sample_fmt is + * unknown or in case of other errors + */ +char *av_get_sample_fmt_string(char *buf, int buf_size, enum AVSampleFormat sample_fmt); + +#if FF_API_GET_BITS_PER_SAMPLE_FMT +/** + * @deprecated Use av_get_bytes_per_sample() instead. + */ +attribute_deprecated +int av_get_bits_per_sample_fmt(enum AVSampleFormat sample_fmt); +#endif + +/** + * Return number of bytes per sample. + * + * @param sample_fmt the sample format + * @return number of bytes per sample or zero if unknown for the given + * sample format + */ +int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt); + +/** + * Check if the sample format is planar. + * + * @param sample_fmt the sample format to inspect + * @return 1 if the sample format is planar, 0 if it is interleaved + */ +int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt); + +/** + * Get the required buffer size for the given audio parameters. + * + * @param[out] linesize calculated linesize, may be NULL + * @param nb_channels the number of channels + * @param nb_samples the number of samples in a single channel + * @param sample_fmt the sample format + * @param align buffer size alignment (0 = default, 1 = no alignment) + * @return required buffer size, or negative error code on failure + */ +int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples, + enum AVSampleFormat sample_fmt, int align); + +/** + * Fill plane data pointers and linesize for samples with sample + * format sample_fmt. + * + * The audio_data array is filled with the pointers to the samples data planes: + * for planar, set the start point of each channel's data within the buffer, + * for packed, set the start point of the entire buffer only. + * + * The value pointed to by linesize is set to the aligned size of each + * channel's data buffer for planar layout, or to the aligned size of the + * buffer for all channels for packed layout. + * + * The buffer in buf must be big enough to contain all the samples + * (use av_samples_get_buffer_size() to compute its minimum size), + * otherwise the audio_data pointers will point to invalid data. + * + * @see enum AVSampleFormat + * The documentation for AVSampleFormat describes the data layout. + * + * @param[out] audio_data array to be filled with the pointer for each channel + * @param[out] linesize calculated linesize, may be NULL + * @param buf the pointer to a buffer containing the samples + * @param nb_channels the number of channels + * @param nb_samples the number of samples in a single channel + * @param sample_fmt the sample format + * @param align buffer size alignment (0 = default, 1 = no alignment) + * @return >=0 on success or a negative error code on failure + * @todo return minimum size in bytes required for the buffer in case + * of success at the next bump + */ +int av_samples_fill_arrays(uint8_t **audio_data, int *linesize, + const uint8_t *buf, + int nb_channels, int nb_samples, + enum AVSampleFormat sample_fmt, int align); + +/** + * Allocate a samples buffer for nb_samples samples, and fill data pointers and + * linesize accordingly. + * The allocated samples buffer can be freed by using av_freep(&audio_data[0]) + * Allocated data will be initialized to silence. + * + * @see enum AVSampleFormat + * The documentation for AVSampleFormat describes the data layout. + * + * @param[out] audio_data array to be filled with the pointer for each channel + * @param[out] linesize aligned size for audio buffer(s), may be NULL + * @param nb_channels number of audio channels + * @param nb_samples number of samples per channel + * @param align buffer size alignment (0 = default, 1 = no alignment) + * @return >=0 on success or a negative error code on failure + * @todo return the size of the allocated buffer in case of success at the next bump + * @see av_samples_fill_arrays() + * @see av_samples_alloc_array_and_samples() + */ +int av_samples_alloc(uint8_t **audio_data, int *linesize, int nb_channels, + int nb_samples, enum AVSampleFormat sample_fmt, int align); + +/** + * Allocate a data pointers array, samples buffer for nb_samples + * samples, and fill data pointers and linesize accordingly. + * + * This is the same as av_samples_alloc(), but also allocates the data + * pointers array. + * + * @see av_samples_alloc() + */ +int av_samples_alloc_array_and_samples(uint8_t ***audio_data, int *linesize, int nb_channels, + int nb_samples, enum AVSampleFormat sample_fmt, int align); + +/** + * Copy samples from src to dst. + * + * @param dst destination array of pointers to data planes + * @param src source array of pointers to data planes + * @param dst_offset offset in samples at which the data will be written to dst + * @param src_offset offset in samples at which the data will be read from src + * @param nb_samples number of samples to be copied + * @param nb_channels number of audio channels + * @param sample_fmt audio sample format + */ +int av_samples_copy(uint8_t **dst, uint8_t * const *src, int dst_offset, + int src_offset, int nb_samples, int nb_channels, + enum AVSampleFormat sample_fmt); + +/** + * Fill an audio buffer with silence. + * + * @param audio_data array of pointers to data planes + * @param offset offset in samples at which to start filling + * @param nb_samples number of samples to fill + * @param nb_channels number of audio channels + * @param sample_fmt audio sample format + */ +int av_samples_set_silence(uint8_t **audio_data, int offset, int nb_samples, + int nb_channels, enum AVSampleFormat sample_fmt); + +#endif /* AVUTIL_SAMPLEFMT_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/sha.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/sha.h new file mode 100644 index 0000000..bf4377e --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/sha.h @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2007 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_SHA_H +#define AVUTIL_SHA_H + +#include + +#include "attributes.h" +#include "version.h" + +/** + * @defgroup lavu_sha SHA + * @ingroup lavu_crypto + * @{ + */ + +extern const int av_sha_size; + +struct AVSHA; + +/** + * Allocate an AVSHA context. + */ +struct AVSHA *av_sha_alloc(void); + +/** + * Initialize SHA-1 or SHA-2 hashing. + * + * @param context pointer to the function context (of size av_sha_size) + * @param bits number of bits in digest (SHA-1 - 160 bits, SHA-2 224 or 256 bits) + * @return zero if initialization succeeded, -1 otherwise + */ +int av_sha_init(struct AVSHA* context, int bits); + +/** + * Update hash value. + * + * @param context hash function context + * @param data input data to update hash with + * @param len input data length + */ +void av_sha_update(struct AVSHA* context, const uint8_t* data, unsigned int len); + +/** + * Finish hashing and output digest value. + * + * @param context hash function context + * @param digest buffer where output digest value is stored + */ +void av_sha_final(struct AVSHA* context, uint8_t *digest); + +/** + * @} + */ + +#endif /* AVUTIL_SHA_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/sha512.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/sha512.h new file mode 100644 index 0000000..7b08701 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/sha512.h @@ -0,0 +1,75 @@ +/* + * Copyright (C) 2007 Michael Niedermayer + * Copyright (C) 2013 James Almer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_SHA512_H +#define AVUTIL_SHA512_H + +#include + +#include "attributes.h" +#include "version.h" + +/** + * @defgroup lavu_sha512 SHA512 + * @ingroup lavu_crypto + * @{ + */ + +extern const int av_sha512_size; + +struct AVSHA512; + +/** + * Allocate an AVSHA512 context. + */ +struct AVSHA512 *av_sha512_alloc(void); + +/** + * Initialize SHA-2 512 hashing. + * + * @param context pointer to the function context (of size av_sha512_size) + * @param bits number of bits in digest (224, 256, 384 or 512 bits) + * @return zero if initialization succeeded, -1 otherwise + */ +int av_sha512_init(struct AVSHA512* context, int bits); + +/** + * Update hash value. + * + * @param context hash function context + * @param data input data to update hash with + * @param len input data length + */ +void av_sha512_update(struct AVSHA512* context, const uint8_t* data, unsigned int len); + +/** + * Finish hashing and output digest value. + * + * @param context hash function context + * @param digest buffer where output digest value is stored + */ +void av_sha512_final(struct AVSHA512* context, uint8_t *digest); + +/** + * @} + */ + +#endif /* AVUTIL_SHA512_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/time.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/time.h new file mode 100644 index 0000000..90eb436 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/time.h @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2000-2003 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 AVUTIL_TIME_H +#define AVUTIL_TIME_H + +#include + +/** + * Get the current time in microseconds. + */ +int64_t av_gettime(void); + +/** + * Sleep for a period of time. Although the duration is expressed in + * microseconds, the actual delay may be rounded to the precision of the + * system timer. + * + * @param usec Number of microseconds to sleep. + * @return zero on success or (negative) error code. + */ +int av_usleep(unsigned usec); + +#endif /* AVUTIL_TIME_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/timecode.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/timecode.h new file mode 100644 index 0000000..56e3975 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/timecode.h @@ -0,0 +1,140 @@ +/* + * Copyright (c) 2006 Smartjog S.A.S, Baptiste Coudurier + * Copyright (c) 2011-2012 Smartjog S.A.S, Clément Bœsch + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file + * Timecode helpers header + */ + +#ifndef AVUTIL_TIMECODE_H +#define AVUTIL_TIMECODE_H + +#include +#include "rational.h" + +#define AV_TIMECODE_STR_SIZE 16 + +enum AVTimecodeFlag { + AV_TIMECODE_FLAG_DROPFRAME = 1<<0, ///< timecode is drop frame + AV_TIMECODE_FLAG_24HOURSMAX = 1<<1, ///< timecode wraps after 24 hours + AV_TIMECODE_FLAG_ALLOWNEGATIVE = 1<<2, ///< negative time values are allowed +}; + +typedef struct { + int start; ///< timecode frame start (first base frame number) + uint32_t flags; ///< flags such as drop frame, +24 hours support, ... + AVRational rate; ///< frame rate in rational form + unsigned fps; ///< frame per second; must be consistent with the rate field +} AVTimecode; + +/** + * Adjust frame number for NTSC drop frame time code. + * + * @param framenum frame number to adjust + * @param fps frame per second, 30 or 60 + * @return adjusted frame number + * @warning adjustment is only valid in NTSC 29.97 and 59.94 + */ +int av_timecode_adjust_ntsc_framenum2(int framenum, int fps); + +/** + * Convert frame number to SMPTE 12M binary representation. + * + * @param tc timecode data correctly initialized + * @param framenum frame number + * @return the SMPTE binary representation + * + * @note Frame number adjustment is automatically done in case of drop timecode, + * you do NOT have to call av_timecode_adjust_ntsc_framenum2(). + * @note The frame number is relative to tc->start. + * @note Color frame (CF), binary group flags (BGF) and biphase mark polarity + * correction (PC) bits are set to zero. + */ +uint32_t av_timecode_get_smpte_from_framenum(const AVTimecode *tc, int framenum); + +/** + * Load timecode string in buf. + * + * @param buf destination buffer, must be at least AV_TIMECODE_STR_SIZE long + * @param tc timecode data correctly initialized + * @param framenum frame number + * @return the buf parameter + * + * @note Timecode representation can be a negative timecode and have more than + * 24 hours, but will only be honored if the flags are correctly set. + * @note The frame number is relative to tc->start. + */ +char *av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum); + +/** + * Get the timecode string from the SMPTE timecode format. + * + * @param buf destination buffer, must be at least AV_TIMECODE_STR_SIZE long + * @param tcsmpte the 32-bit SMPTE timecode + * @param prevent_df prevent the use of a drop flag when it is known the DF bit + * is arbitrary + * @return the buf parameter + */ +char *av_timecode_make_smpte_tc_string(char *buf, uint32_t tcsmpte, int prevent_df); + +/** + * Get the timecode string from the 25-bit timecode format (MPEG GOP format). + * + * @param buf destination buffer, must be at least AV_TIMECODE_STR_SIZE long + * @param tc25bit the 25-bits timecode + * @return the buf parameter + */ +char *av_timecode_make_mpeg_tc_string(char *buf, uint32_t tc25bit); + +/** + * Init a timecode struct with the passed parameters. + * + * @param log_ctx a pointer to an arbitrary struct of which the first field + * is a pointer to an AVClass struct (used for av_log) + * @param tc pointer to an allocated AVTimecode + * @param rate frame rate in rational form + * @param flags miscellaneous flags such as drop frame, +24 hours, ... + * (see AVTimecodeFlag) + * @param frame_start the first frame number + * @return 0 on success, AVERROR otherwise + */ +int av_timecode_init(AVTimecode *tc, AVRational rate, int flags, int frame_start, void *log_ctx); + +/** + * Parse timecode representation (hh:mm:ss[:;.]ff). + * + * @param log_ctx a pointer to an arbitrary struct of which the first field is a + * pointer to an AVClass struct (used for av_log). + * @param tc pointer to an allocated AVTimecode + * @param rate frame rate in rational form + * @param str timecode string which will determine the frame start + * @return 0 on success, AVERROR otherwise + */ +int av_timecode_init_from_string(AVTimecode *tc, AVRational rate, const char *str, void *log_ctx); + +/** + * Check if the timecode feature is available for the given frame rate + * + * @return 0 if supported, <0 otherwise + */ +int av_timecode_check_frame_rate(AVRational rate); + +#endif /* AVUTIL_TIMECODE_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/timestamp.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/timestamp.h new file mode 100644 index 0000000..f63a08c --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/timestamp.h @@ -0,0 +1,74 @@ +/* + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file + * timestamp utils, mostly useful for debugging/logging purposes + */ + +#ifndef AVUTIL_TIMESTAMP_H +#define AVUTIL_TIMESTAMP_H + +#include "common.h" + +#define AV_TS_MAX_STRING_SIZE 32 + +/** + * Fill the provided buffer with a string containing a timestamp + * representation. + * + * @param buf a buffer with size in bytes of at least AV_TS_MAX_STRING_SIZE + * @param ts the timestamp to represent + * @return the buffer in input + */ +static inline char *av_ts_make_string(char *buf, int64_t ts) +{ + if (ts == AV_NOPTS_VALUE) snprintf(buf, AV_TS_MAX_STRING_SIZE, "NOPTS"); + else snprintf(buf, AV_TS_MAX_STRING_SIZE, "%"PRId64, ts); + return buf; +} + +/** + * Convenience macro, the return value should be used only directly in + * function arguments but never stand-alone. + */ +#define av_ts2str(ts) av_ts_make_string((char[AV_TS_MAX_STRING_SIZE]){0}, ts) + +/** + * Fill the provided buffer with a string containing a timestamp time + * representation. + * + * @param buf a buffer with size in bytes of at least AV_TS_MAX_STRING_SIZE + * @param ts the timestamp to represent + * @param tb the timebase of the timestamp + * @return the buffer in input + */ +static inline char *av_ts_make_time_string(char *buf, int64_t ts, AVRational *tb) +{ + if (ts == AV_NOPTS_VALUE) snprintf(buf, AV_TS_MAX_STRING_SIZE, "NOPTS"); + else snprintf(buf, AV_TS_MAX_STRING_SIZE, "%.6g", av_q2d(*tb) * ts); + return buf; +} + +/** + * Convenience macro, the return value should be used only directly in + * function arguments but never stand-alone. + */ +#define av_ts2timestr(ts, tb) av_ts_make_time_string((char[AV_TS_MAX_STRING_SIZE]){0}, ts, tb) + +#endif /* AVUTIL_TIMESTAMP_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/version.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/version.h new file mode 100644 index 0000000..3e64a20 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/version.h @@ -0,0 +1,159 @@ +/* + * copyright (c) 2003 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 AVUTIL_VERSION_H +#define AVUTIL_VERSION_H + +/** + * @defgroup preproc_misc Preprocessor String Macros + * + * String manipulation macros + * + * @{ + */ + +#define AV_STRINGIFY(s) AV_TOSTRING(s) +#define AV_TOSTRING(s) #s + +#define AV_GLUE(a, b) a ## b +#define AV_JOIN(a, b) AV_GLUE(a, b) + +#define AV_PRAGMA(s) _Pragma(#s) + +/** + * @} + */ + +/** + * @defgroup version_utils Library Version Macros + * + * Useful to check and match library version in order to maintain + * backward compatibility. + * + * @{ + */ + +#define AV_VERSION_INT(a, b, c) (a<<16 | b<<8 | c) +#define AV_VERSION_DOT(a, b, c) a ##.## b ##.## c +#define AV_VERSION(a, b, c) AV_VERSION_DOT(a, b, c) + +/** + * @} + */ + + +/** + * @file + * @ingroup lavu + * Libavutil version macros + */ + +/** + * @defgroup lavu_ver Version and Build diagnostics + * + * Macros and function useful to check at compiletime and at runtime + * which version of libavutil is in use. + * + * @{ + */ + +#define LIBAVUTIL_VERSION_MAJOR 52 +#define LIBAVUTIL_VERSION_MINOR 53 +#define LIBAVUTIL_VERSION_MICRO 100 + +#define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \ + LIBAVUTIL_VERSION_MINOR, \ + LIBAVUTIL_VERSION_MICRO) +#define LIBAVUTIL_VERSION AV_VERSION(LIBAVUTIL_VERSION_MAJOR, \ + LIBAVUTIL_VERSION_MINOR, \ + LIBAVUTIL_VERSION_MICRO) +#define LIBAVUTIL_BUILD LIBAVUTIL_VERSION_INT + +#define LIBAVUTIL_IDENT "Lavu" AV_STRINGIFY(LIBAVUTIL_VERSION) + +/** + * @} + * + * @defgroup depr_guards Deprecation guards + * FF_API_* defines may be placed below to indicate public API that will be + * dropped at a future version bump. The defines themselves are not part of + * the public API and may change, break or disappear at any time. + * + * @{ + */ + +#ifndef FF_API_GET_BITS_PER_SAMPLE_FMT +#define FF_API_GET_BITS_PER_SAMPLE_FMT (LIBAVUTIL_VERSION_MAJOR < 53) +#endif +#ifndef FF_API_FIND_OPT +#define FF_API_FIND_OPT (LIBAVUTIL_VERSION_MAJOR < 53) +#endif +#ifndef FF_API_OLD_AVOPTIONS +#define FF_API_OLD_AVOPTIONS (LIBAVUTIL_VERSION_MAJOR < 53) +#endif +#ifndef FF_API_PIX_FMT +#define FF_API_PIX_FMT (LIBAVUTIL_VERSION_MAJOR < 53) +#endif +#ifndef FF_API_CONTEXT_SIZE +#define FF_API_CONTEXT_SIZE (LIBAVUTIL_VERSION_MAJOR < 53) +#endif +#ifndef FF_API_PIX_FMT_DESC +#define FF_API_PIX_FMT_DESC (LIBAVUTIL_VERSION_MAJOR < 53) +#endif +#ifndef FF_API_AV_REVERSE +#define FF_API_AV_REVERSE (LIBAVUTIL_VERSION_MAJOR < 53) +#endif +#ifndef FF_API_AUDIOCONVERT +#define FF_API_AUDIOCONVERT (LIBAVUTIL_VERSION_MAJOR < 53) +#endif +#ifndef FF_API_CPU_FLAG_MMX2 +#define FF_API_CPU_FLAG_MMX2 (LIBAVUTIL_VERSION_MAJOR < 53) +#endif +#ifndef FF_API_SAMPLES_UTILS_RETURN_ZERO +#define FF_API_SAMPLES_UTILS_RETURN_ZERO (LIBAVUTIL_VERSION_MAJOR < 53) +#endif +#ifndef FF_API_LLS_PRIVATE +#define FF_API_LLS_PRIVATE (LIBAVUTIL_VERSION_MAJOR < 53) +#endif +#ifndef FF_API_LLS1 +#define FF_API_LLS1 (LIBAVUTIL_VERSION_MAJOR < 53) +#endif +#ifndef FF_API_AVFRAME_LAVC +#define FF_API_AVFRAME_LAVC (LIBAVUTIL_VERSION_MAJOR < 53) +#endif +#ifndef FF_API_VDPAU +#define FF_API_VDPAU (LIBAVUTIL_VERSION_MAJOR < 53) +#endif +#ifndef FF_API_GET_CHANNEL_LAYOUT_COMPAT +#define FF_API_GET_CHANNEL_LAYOUT_COMPAT (LIBAVUTIL_VERSION_MAJOR < 53) +#endif +#ifndef FF_API_OLD_OPENCL +#define FF_API_OLD_OPENCL (LIBAVUTIL_VERSION_MAJOR < 53) +#endif +#ifndef FF_API_XVMC +#define FF_API_XVMC (LIBAVUTIL_VERSION_MAJOR < 53) +#endif + +/** + * @} + */ + +#endif /* AVUTIL_VERSION_H */ + diff --git a/limelight-pc/jni/nv_avc_dec/inc/libavutil/xtea.h b/limelight-pc/jni/nv_avc_dec/inc/libavutil/xtea.h new file mode 100644 index 0000000..6f1e71e --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libavutil/xtea.h @@ -0,0 +1,64 @@ +/* + * A 32-bit implementation of the XTEA algorithm + * Copyright (c) 2012 Samuel Pitoiset + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVUTIL_XTEA_H +#define AVUTIL_XTEA_H + +#include + +/** + * @file + * @brief Public header for libavutil XTEA algorithm + * @defgroup lavu_xtea XTEA + * @ingroup lavu_crypto + * @{ + */ + +typedef struct AVXTEA { + uint32_t key[16]; +} AVXTEA; + +/** + * Initialize an AVXTEA context. + * + * @param ctx an AVXTEA context + * @param key a key of 16 bytes used for encryption/decryption + */ +void av_xtea_init(struct AVXTEA *ctx, const uint8_t key[16]); + +/** + * Encrypt or decrypt a buffer using a previously initialized context. + * + * @param ctx an AVXTEA context + * @param dst destination array, can be equal to src + * @param src source array, can be equal to dst + * @param count number of 8 byte blocks + * @param iv initialization vector for CBC mode, if NULL then ECB will be used + * @param decrypt 0 for encryption, 1 for decryption + */ +void av_xtea_crypt(struct AVXTEA *ctx, uint8_t *dst, const uint8_t *src, + int count, uint8_t *iv, int decrypt); + +/** + * @} + */ + +#endif /* AVUTIL_XTEA_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libswresample/swresample.h b/limelight-pc/jni/nv_avc_dec/inc/libswresample/swresample.h new file mode 100644 index 0000000..3811301 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libswresample/swresample.h @@ -0,0 +1,311 @@ +/* + * Copyright (C) 2011-2013 Michael Niedermayer (michaelni@gmx.at) + * + * This file is part of libswresample + * + * libswresample 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. + * + * libswresample 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 libswresample; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef SWRESAMPLE_SWRESAMPLE_H +#define SWRESAMPLE_SWRESAMPLE_H + +/** + * @file + * @ingroup lswr + * libswresample public header + */ + +/** + * @defgroup lswr Libswresample + * @{ + * + * Libswresample (lswr) is a library that handles audio resampling, sample + * format conversion and mixing. + * + * Interaction with lswr is done through SwrContext, which is + * allocated with swr_alloc() or swr_alloc_set_opts(). It is opaque, so all parameters + * must be set with the @ref avoptions API. + * + * For example the following code will setup conversion from planar float sample + * format to interleaved signed 16-bit integer, downsampling from 48kHz to + * 44.1kHz and downmixing from 5.1 channels to stereo (using the default mixing + * matrix): + * @code + * SwrContext *swr = swr_alloc(); + * av_opt_set_channel_layout(swr, "in_channel_layout", AV_CH_LAYOUT_5POINT1, 0); + * av_opt_set_channel_layout(swr, "out_channel_layout", AV_CH_LAYOUT_STEREO, 0); + * av_opt_set_int(swr, "in_sample_rate", 48000, 0); + * av_opt_set_int(swr, "out_sample_rate", 44100, 0); + * av_opt_set_sample_fmt(swr, "in_sample_fmt", AV_SAMPLE_FMT_FLTP, 0); + * av_opt_set_sample_fmt(swr, "out_sample_fmt", AV_SAMPLE_FMT_S16, 0); + * @endcode + * + * Once all values have been set, it must be initialized with swr_init(). If + * you need to change the conversion parameters, you can change the parameters + * as described above, or by using swr_alloc_set_opts(), then call swr_init() + * again. + * + * The conversion itself is done by repeatedly calling swr_convert(). + * Note that the samples may get buffered in swr if you provide insufficient + * output space or if sample rate conversion is done, which requires "future" + * samples. Samples that do not require future input can be retrieved at any + * time by using swr_convert() (in_count can be set to 0). + * At the end of conversion the resampling buffer can be flushed by calling + * swr_convert() with NULL in and 0 in_count. + * + * The delay between input and output, can at any time be found by using + * swr_get_delay(). + * + * The following code demonstrates the conversion loop assuming the parameters + * from above and caller-defined functions get_input() and handle_output(): + * @code + * uint8_t **input; + * int in_samples; + * + * while (get_input(&input, &in_samples)) { + * uint8_t *output; + * int out_samples = av_rescale_rnd(swr_get_delay(swr, 48000) + + * in_samples, 44100, 48000, AV_ROUND_UP); + * av_samples_alloc(&output, NULL, 2, out_samples, + * AV_SAMPLE_FMT_S16, 0); + * out_samples = swr_convert(swr, &output, out_samples, + * input, in_samples); + * handle_output(output, out_samples); + * av_freep(&output); + * } + * @endcode + * + * When the conversion is finished, the conversion + * context and everything associated with it must be freed with swr_free(). + * There will be no memory leak if the data is not completely flushed before + * swr_free(). + */ + +#include +#include "libavutil/samplefmt.h" + +#include "libswresample/version.h" + +#if LIBSWRESAMPLE_VERSION_MAJOR < 1 +#define SWR_CH_MAX 32 ///< Maximum number of channels +#endif + +#define SWR_FLAG_RESAMPLE 1 ///< Force resampling even if equal sample rate +//TODO use int resample ? +//long term TODO can we enable this dynamically? + +enum SwrDitherType { + SWR_DITHER_NONE = 0, + SWR_DITHER_RECTANGULAR, + SWR_DITHER_TRIANGULAR, + SWR_DITHER_TRIANGULAR_HIGHPASS, + + SWR_DITHER_NS = 64, ///< not part of API/ABI + SWR_DITHER_NS_LIPSHITZ, + SWR_DITHER_NS_F_WEIGHTED, + SWR_DITHER_NS_MODIFIED_E_WEIGHTED, + SWR_DITHER_NS_IMPROVED_E_WEIGHTED, + SWR_DITHER_NS_SHIBATA, + SWR_DITHER_NS_LOW_SHIBATA, + SWR_DITHER_NS_HIGH_SHIBATA, + SWR_DITHER_NB, ///< not part of API/ABI +}; + +/** Resampling Engines */ +enum SwrEngine { + SWR_ENGINE_SWR, /**< SW Resampler */ + SWR_ENGINE_SOXR, /**< SoX Resampler */ + SWR_ENGINE_NB, ///< not part of API/ABI +}; + +/** Resampling Filter Types */ +enum SwrFilterType { + SWR_FILTER_TYPE_CUBIC, /**< Cubic */ + SWR_FILTER_TYPE_BLACKMAN_NUTTALL, /**< Blackman Nuttall Windowed Sinc */ + SWR_FILTER_TYPE_KAISER, /**< Kaiser Windowed Sinc */ +}; + +typedef struct SwrContext SwrContext; + +/** + * Get the AVClass for swrContext. It can be used in combination with + * AV_OPT_SEARCH_FAKE_OBJ for examining options. + * + * @see av_opt_find(). + */ +const AVClass *swr_get_class(void); + +/** + * Allocate SwrContext. + * + * If you use this function you will need to set the parameters (manually or + * with swr_alloc_set_opts()) before calling swr_init(). + * + * @see swr_alloc_set_opts(), swr_init(), swr_free() + * @return NULL on error, allocated context otherwise + */ +struct SwrContext *swr_alloc(void); + +/** + * Initialize context after user parameters have been set. + * + * @return AVERROR error code in case of failure. + */ +int swr_init(struct SwrContext *s); + +/** + * Allocate SwrContext if needed and set/reset common parameters. + * + * This function does not require s to be allocated with swr_alloc(). On the + * other hand, swr_alloc() can use swr_alloc_set_opts() to set the parameters + * on the allocated context. + * + * @param s Swr context, can be NULL + * @param out_ch_layout output channel layout (AV_CH_LAYOUT_*) + * @param out_sample_fmt output sample format (AV_SAMPLE_FMT_*). + * @param out_sample_rate output sample rate (frequency in Hz) + * @param in_ch_layout input channel layout (AV_CH_LAYOUT_*) + * @param in_sample_fmt input sample format (AV_SAMPLE_FMT_*). + * @param in_sample_rate input sample rate (frequency in Hz) + * @param log_offset logging level offset + * @param log_ctx parent logging context, can be NULL + * + * @see swr_init(), swr_free() + * @return NULL on error, allocated context otherwise + */ +struct SwrContext *swr_alloc_set_opts(struct SwrContext *s, + int64_t out_ch_layout, enum AVSampleFormat out_sample_fmt, int out_sample_rate, + int64_t in_ch_layout, enum AVSampleFormat in_sample_fmt, int in_sample_rate, + int log_offset, void *log_ctx); + +/** + * Free the given SwrContext and set the pointer to NULL. + */ +void swr_free(struct SwrContext **s); + +/** + * Convert audio. + * + * in and in_count can be set to 0 to flush the last few samples out at the + * end. + * + * If more input is provided than output space then the input will be buffered. + * You can avoid this buffering by providing more output space than input. + * Convertion will run directly without copying whenever possible. + * + * @param s allocated Swr context, with parameters set + * @param out output buffers, only the first one need be set in case of packed audio + * @param out_count amount of space available for output in samples per channel + * @param in input buffers, only the first one need to be set in case of packed audio + * @param in_count number of input samples available in one channel + * + * @return number of samples output per channel, negative value on error + */ +int swr_convert(struct SwrContext *s, uint8_t **out, int out_count, + const uint8_t **in , int in_count); + +/** + * Convert the next timestamp from input to output + * timestamps are in 1/(in_sample_rate * out_sample_rate) units. + * + * @note There are 2 slightly differently behaving modes. + * First is when automatic timestamp compensation is not used, (min_compensation >= FLT_MAX) + * in this case timestamps will be passed through with delays compensated + * Second is when automatic timestamp compensation is used, (min_compensation < FLT_MAX) + * in this case the output timestamps will match output sample numbers + * + * @param pts timestamp for the next input sample, INT64_MIN if unknown + * @return the output timestamp for the next output sample + */ +int64_t swr_next_pts(struct SwrContext *s, int64_t pts); + +/** + * Activate resampling compensation. + */ +int swr_set_compensation(struct SwrContext *s, int sample_delta, int compensation_distance); + +/** + * Set a customized input channel mapping. + * + * @param s allocated Swr context, not yet initialized + * @param channel_map customized input channel mapping (array of channel + * indexes, -1 for a muted channel) + * @return AVERROR error code in case of failure. + */ +int swr_set_channel_mapping(struct SwrContext *s, const int *channel_map); + +/** + * Set a customized remix matrix. + * + * @param s allocated Swr context, not yet initialized + * @param matrix remix coefficients; matrix[i + stride * o] is + * the weight of input channel i in output channel o + * @param stride offset between lines of the matrix + * @return AVERROR error code in case of failure. + */ +int swr_set_matrix(struct SwrContext *s, const double *matrix, int stride); + +/** + * Drops the specified number of output samples. + */ +int swr_drop_output(struct SwrContext *s, int count); + +/** + * Injects the specified number of silence samples. + */ +int swr_inject_silence(struct SwrContext *s, int count); + +/** + * Gets the delay the next input sample will experience relative to the next output sample. + * + * Swresample can buffer data if more input has been provided than available + * output space, also converting between sample rates needs a delay. + * This function returns the sum of all such delays. + * The exact delay is not necessarily an integer value in either input or + * output sample rate. Especially when downsampling by a large value, the + * output sample rate may be a poor choice to represent the delay, similarly + * for upsampling and the input sample rate. + * + * @param s swr context + * @param base timebase in which the returned delay will be + * if its set to 1 the returned delay is in seconds + * if its set to 1000 the returned delay is in milli seconds + * if its set to the input sample rate then the returned delay is in input samples + * if its set to the output sample rate then the returned delay is in output samples + * an exact rounding free delay can be found by using LCM(in_sample_rate, out_sample_rate) + * @returns the delay in 1/base units. + */ +int64_t swr_get_delay(struct SwrContext *s, int64_t base); + +/** + * Return the LIBSWRESAMPLE_VERSION_INT constant. + */ +unsigned swresample_version(void); + +/** + * Return the swr build-time configuration. + */ +const char *swresample_configuration(void); + +/** + * Return the swr license. + */ +const char *swresample_license(void); + +/** + * @} + */ + +#endif /* SWRESAMPLE_SWRESAMPLE_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libswresample/version.h b/limelight-pc/jni/nv_avc_dec/inc/libswresample/version.h new file mode 100644 index 0000000..464c86d --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libswresample/version.h @@ -0,0 +1,45 @@ +/* + * Version macros. + * + * This file is part of libswresample + * + * libswresample 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. + * + * libswresample 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 libswresample; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef SWR_VERSION_H +#define SWR_VERSION_H + +/** + * @file + * Libswresample version macros + */ + +#include "libavutil/avutil.h" + +#define LIBSWRESAMPLE_VERSION_MAJOR 0 +#define LIBSWRESAMPLE_VERSION_MINOR 17 +#define LIBSWRESAMPLE_VERSION_MICRO 104 + +#define LIBSWRESAMPLE_VERSION_INT AV_VERSION_INT(LIBSWRESAMPLE_VERSION_MAJOR, \ + LIBSWRESAMPLE_VERSION_MINOR, \ + LIBSWRESAMPLE_VERSION_MICRO) +#define LIBSWRESAMPLE_VERSION AV_VERSION(LIBSWRESAMPLE_VERSION_MAJOR, \ + LIBSWRESAMPLE_VERSION_MINOR, \ + LIBSWRESAMPLE_VERSION_MICRO) +#define LIBSWRESAMPLE_BUILD LIBSWRESAMPLE_VERSION_INT + +#define LIBSWRESAMPLE_IDENT "SwR" AV_STRINGIFY(LIBSWRESAMPLE_VERSION) + +#endif /* SWR_VERSION_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libswscale/swscale.h b/limelight-pc/jni/nv_avc_dec/inc/libswscale/swscale.h new file mode 100644 index 0000000..42702b7 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libswscale/swscale.h @@ -0,0 +1,362 @@ +/* + * Copyright (C) 2001-2011 Michael Niedermayer + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef SWSCALE_SWSCALE_H +#define SWSCALE_SWSCALE_H + +/** + * @file + * @ingroup lsws + * external API header + */ + +/** + * @defgroup lsws Libswscale + * @{ + */ + +#include + +#include "libavutil/avutil.h" +#include "libavutil/log.h" +#include "libavutil/pixfmt.h" +#include "version.h" + +/** + * Return the LIBSWSCALE_VERSION_INT constant. + */ +unsigned swscale_version(void); + +/** + * Return the libswscale build-time configuration. + */ +const char *swscale_configuration(void); + +/** + * Return the libswscale license. + */ +const char *swscale_license(void); + +/* values for the flags, the stuff on the command line is different */ +#define SWS_FAST_BILINEAR 1 +#define SWS_BILINEAR 2 +#define SWS_BICUBIC 4 +#define SWS_X 8 +#define SWS_POINT 0x10 +#define SWS_AREA 0x20 +#define SWS_BICUBLIN 0x40 +#define SWS_GAUSS 0x80 +#define SWS_SINC 0x100 +#define SWS_LANCZOS 0x200 +#define SWS_SPLINE 0x400 + +#define SWS_SRC_V_CHR_DROP_MASK 0x30000 +#define SWS_SRC_V_CHR_DROP_SHIFT 16 + +#define SWS_PARAM_DEFAULT 123456 + +#define SWS_PRINT_INFO 0x1000 + +//the following 3 flags are not completely implemented +//internal chrominace subsampling info +#define SWS_FULL_CHR_H_INT 0x2000 +//input subsampling info +#define SWS_FULL_CHR_H_INP 0x4000 +#define SWS_DIRECT_BGR 0x8000 +#define SWS_ACCURATE_RND 0x40000 +#define SWS_BITEXACT 0x80000 +#define SWS_ERROR_DIFFUSION 0x800000 + +#if FF_API_SWS_CPU_CAPS +/** + * CPU caps are autodetected now, those flags + * are only provided for API compatibility. + */ +#define SWS_CPU_CAPS_MMX 0x80000000 +#define SWS_CPU_CAPS_MMXEXT 0x20000000 +#define SWS_CPU_CAPS_MMX2 0x20000000 +#define SWS_CPU_CAPS_3DNOW 0x40000000 +#define SWS_CPU_CAPS_ALTIVEC 0x10000000 +#define SWS_CPU_CAPS_BFIN 0x01000000 +#define SWS_CPU_CAPS_SSE2 0x02000000 +#endif + +#define SWS_MAX_REDUCE_CUTOFF 0.002 + +#define SWS_CS_ITU709 1 +#define SWS_CS_FCC 4 +#define SWS_CS_ITU601 5 +#define SWS_CS_ITU624 5 +#define SWS_CS_SMPTE170M 5 +#define SWS_CS_SMPTE240M 7 +#define SWS_CS_DEFAULT 5 + +/** + * Return a pointer to yuv<->rgb coefficients for the given colorspace + * suitable for sws_setColorspaceDetails(). + * + * @param colorspace One of the SWS_CS_* macros. If invalid, + * SWS_CS_DEFAULT is used. + */ +const int *sws_getCoefficients(int colorspace); + +// when used for filters they must have an odd number of elements +// coeffs cannot be shared between vectors +typedef struct SwsVector { + double *coeff; ///< pointer to the list of coefficients + int length; ///< number of coefficients in the vector +} SwsVector; + +// vectors can be shared +typedef struct SwsFilter { + SwsVector *lumH; + SwsVector *lumV; + SwsVector *chrH; + SwsVector *chrV; +} SwsFilter; + +struct SwsContext; + +/** + * Return a positive value if pix_fmt is a supported input format, 0 + * otherwise. + */ +int sws_isSupportedInput(enum AVPixelFormat pix_fmt); + +/** + * Return a positive value if pix_fmt is a supported output format, 0 + * otherwise. + */ +int sws_isSupportedOutput(enum AVPixelFormat pix_fmt); + +/** + * @param[in] pix_fmt the pixel format + * @return a positive value if an endianness conversion for pix_fmt is + * supported, 0 otherwise. + */ +int sws_isSupportedEndiannessConversion(enum AVPixelFormat pix_fmt); + +/** + * Allocate an empty SwsContext. This must be filled and passed to + * sws_init_context(). For filling see AVOptions, options.c and + * sws_setColorspaceDetails(). + */ +struct SwsContext *sws_alloc_context(void); + +/** + * Initialize the swscaler context sws_context. + * + * @return zero or positive value on success, a negative value on + * error + */ +int sws_init_context(struct SwsContext *sws_context, SwsFilter *srcFilter, SwsFilter *dstFilter); + +/** + * Free the swscaler context swsContext. + * If swsContext is NULL, then does nothing. + */ +void sws_freeContext(struct SwsContext *swsContext); + +#if FF_API_SWS_GETCONTEXT +/** + * Allocate and return an SwsContext. You need it to perform + * scaling/conversion operations using sws_scale(). + * + * @param srcW the width of the source image + * @param srcH the height of the source image + * @param srcFormat the source image format + * @param dstW the width of the destination image + * @param dstH the height of the destination image + * @param dstFormat the destination image format + * @param flags specify which algorithm and options to use for rescaling + * @return a pointer to an allocated context, or NULL in case of error + * @note this function is to be removed after a saner alternative is + * written + * @deprecated Use sws_getCachedContext() instead. + */ +struct SwsContext *sws_getContext(int srcW, int srcH, enum AVPixelFormat srcFormat, + int dstW, int dstH, enum AVPixelFormat dstFormat, + int flags, SwsFilter *srcFilter, + SwsFilter *dstFilter, const double *param); +#endif + +/** + * Scale the image slice in srcSlice and put the resulting scaled + * slice in the image in dst. A slice is a sequence of consecutive + * rows in an image. + * + * Slices have to be provided in sequential order, either in + * top-bottom or bottom-top order. If slices are provided in + * non-sequential order the behavior of the function is undefined. + * + * @param c the scaling context previously created with + * sws_getContext() + * @param srcSlice the array containing the pointers to the planes of + * the source slice + * @param srcStride the array containing the strides for each plane of + * the source image + * @param srcSliceY the position in the source image of the slice to + * process, that is the number (counted starting from + * zero) in the image of the first row of the slice + * @param srcSliceH the height of the source slice, that is the number + * of rows in the slice + * @param dst the array containing the pointers to the planes of + * the destination image + * @param dstStride the array containing the strides for each plane of + * the destination image + * @return the height of the output slice + */ +int sws_scale(struct SwsContext *c, const uint8_t *const srcSlice[], + const int srcStride[], int srcSliceY, int srcSliceH, + uint8_t *const dst[], const int dstStride[]); + +/** + * @param dstRange flag indicating the while-black range of the output (1=jpeg / 0=mpeg) + * @param srcRange flag indicating the while-black range of the input (1=jpeg / 0=mpeg) + * @param table the yuv2rgb coefficients describing the output yuv space, normally ff_yuv2rgb_coeffs[x] + * @param inv_table the yuv2rgb coefficients describing the input yuv space, normally ff_yuv2rgb_coeffs[x] + * @param brightness 16.16 fixed point brightness correction + * @param contrast 16.16 fixed point contrast correction + * @param saturation 16.16 fixed point saturation correction + * @return -1 if not supported + */ +int sws_setColorspaceDetails(struct SwsContext *c, const int inv_table[4], + int srcRange, const int table[4], int dstRange, + int brightness, int contrast, int saturation); + +/** + * @return -1 if not supported + */ +int sws_getColorspaceDetails(struct SwsContext *c, int **inv_table, + int *srcRange, int **table, int *dstRange, + int *brightness, int *contrast, int *saturation); + +/** + * Allocate and return an uninitialized vector with length coefficients. + */ +SwsVector *sws_allocVec(int length); + +/** + * Return a normalized Gaussian curve used to filter stuff + * quality = 3 is high quality, lower is lower quality. + */ +SwsVector *sws_getGaussianVec(double variance, double quality); + +/** + * Allocate and return a vector with length coefficients, all + * with the same value c. + */ +SwsVector *sws_getConstVec(double c, int length); + +/** + * Allocate and return a vector with just one coefficient, with + * value 1.0. + */ +SwsVector *sws_getIdentityVec(void); + +/** + * Scale all the coefficients of a by the scalar value. + */ +void sws_scaleVec(SwsVector *a, double scalar); + +/** + * Scale all the coefficients of a so that their sum equals height. + */ +void sws_normalizeVec(SwsVector *a, double height); +void sws_convVec(SwsVector *a, SwsVector *b); +void sws_addVec(SwsVector *a, SwsVector *b); +void sws_subVec(SwsVector *a, SwsVector *b); +void sws_shiftVec(SwsVector *a, int shift); + +/** + * Allocate and return a clone of the vector a, that is a vector + * with the same coefficients as a. + */ +SwsVector *sws_cloneVec(SwsVector *a); + +/** + * Print with av_log() a textual representation of the vector a + * if log_level <= av_log_level. + */ +void sws_printVec2(SwsVector *a, AVClass *log_ctx, int log_level); + +void sws_freeVec(SwsVector *a); + +SwsFilter *sws_getDefaultFilter(float lumaGBlur, float chromaGBlur, + float lumaSharpen, float chromaSharpen, + float chromaHShift, float chromaVShift, + int verbose); +void sws_freeFilter(SwsFilter *filter); + +/** + * Check if context can be reused, otherwise reallocate a new one. + * + * If context is NULL, just calls sws_getContext() to get a new + * context. Otherwise, checks if the parameters are the ones already + * saved in context. If that is the case, returns the current + * context. Otherwise, frees context and gets a new context with + * the new parameters. + * + * Be warned that srcFilter and dstFilter are not checked, they + * are assumed to remain the same. + */ +struct SwsContext *sws_getCachedContext(struct SwsContext *context, + int srcW, int srcH, enum AVPixelFormat srcFormat, + int dstW, int dstH, enum AVPixelFormat dstFormat, + int flags, SwsFilter *srcFilter, + SwsFilter *dstFilter, const double *param); + +/** + * Convert an 8-bit paletted frame into a frame with a color depth of 32 bits. + * + * The output frame will have the same packed format as the palette. + * + * @param src source frame buffer + * @param dst destination frame buffer + * @param num_pixels number of pixels to convert + * @param palette array with [256] entries, which must match color arrangement (RGB or BGR) of src + */ +void sws_convertPalette8ToPacked32(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette); + +/** + * Convert an 8-bit paletted frame into a frame with a color depth of 24 bits. + * + * With the palette format "ABCD", the destination frame ends up with the format "ABC". + * + * @param src source frame buffer + * @param dst destination frame buffer + * @param num_pixels number of pixels to convert + * @param palette array with [256] entries, which must match color arrangement (RGB or BGR) of src + */ +void sws_convertPalette8ToPacked24(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette); + +/** + * Get the AVClass for swsContext. It can be used in combination with + * AV_OPT_SEARCH_FAKE_OBJ for examining options. + * + * @see av_opt_find(). + */ +const AVClass *sws_get_class(void); + +/** + * @} + */ + +#endif /* SWSCALE_SWSCALE_H */ diff --git a/limelight-pc/jni/nv_avc_dec/inc/libswscale/version.h b/limelight-pc/jni/nv_avc_dec/inc/libswscale/version.h new file mode 100644 index 0000000..360ec82 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/inc/libswscale/version.h @@ -0,0 +1,59 @@ +/* + * 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 SWSCALE_VERSION_H +#define SWSCALE_VERSION_H + +/** + * @file + * swscale version macros + */ + +#include "libavutil/avutil.h" + +#define LIBSWSCALE_VERSION_MAJOR 2 +#define LIBSWSCALE_VERSION_MINOR 5 +#define LIBSWSCALE_VERSION_MICRO 101 + +#define LIBSWSCALE_VERSION_INT AV_VERSION_INT(LIBSWSCALE_VERSION_MAJOR, \ + LIBSWSCALE_VERSION_MINOR, \ + LIBSWSCALE_VERSION_MICRO) +#define LIBSWSCALE_VERSION AV_VERSION(LIBSWSCALE_VERSION_MAJOR, \ + LIBSWSCALE_VERSION_MINOR, \ + LIBSWSCALE_VERSION_MICRO) +#define LIBSWSCALE_BUILD LIBSWSCALE_VERSION_INT + +#define LIBSWSCALE_IDENT "SwS" AV_STRINGIFY(LIBSWSCALE_VERSION) + +/** + * FF_API_* defines may be placed below to indicate public API that will be + * dropped at a future version bump. The defines themselves are not part of + * the public API and may change, break or disappear at any time. + */ + +#ifndef FF_API_SWS_GETCONTEXT +#define FF_API_SWS_GETCONTEXT (LIBSWSCALE_VERSION_MAJOR < 3) +#endif +#ifndef FF_API_SWS_CPU_CAPS +#define FF_API_SWS_CPU_CAPS (LIBSWSCALE_VERSION_MAJOR < 3) +#endif +#ifndef FF_API_SWS_FORMAT_NAME +#define FF_API_SWS_FORMAT_NAME (LIBSWSCALE_VERSION_MAJOR < 3) +#endif + +#endif /* SWSCALE_VERSION_H */ diff --git a/limelight-pc/jni/nv_avc_dec/nv_avc_dec.c b/limelight-pc/jni/nv_avc_dec/nv_avc_dec.c new file mode 100755 index 0000000..bb417d6 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/nv_avc_dec.c @@ -0,0 +1,400 @@ +#include +#include +#include +#include + + +#include "nv_avc_dec.h" + +#include + +#ifdef __ANDROID_API__ +#include +#include +#else +#include +#define __android_log_write(x,y,z) printf(z) +#endif + +// General decoder and renderer state +AVPacket pkt; +AVCodec* decoder; +AVCodecContext* decoder_ctx; +AVFrame* yuv_frame; +AVFrame* dec_frame; +pthread_mutex_t mutex; + +// Color conversion and rendering +AVFrame* rgb_frame; +char* rgb_frame_buf; +struct SwsContext* scaler_ctx; +#ifdef __ANDROID_API__ +ANativeWindow* window; +#endif + +#define RENDER_PIX_FMT AV_PIX_FMT_RGBA +#define BYTES_PER_PIXEL 4 + +// Disables the deblocking filter at the cost of image quality +#define DISABLE_LOOP_FILTER 0x1 +// Uses the low latency decode flag (disables multithreading) +#define LOW_LATENCY_DECODE 0x2 +// Threads process each slice, rather than each frame +#define SLICE_THREADING 0x4 +// Uses nonstandard speedup tricks +#define FAST_DECODE 0x8 +// Uses bilinear filtering instead of bicubic +#define BILINEAR_FILTERING 0x10 +// Uses a faster bilinear filtering with lower image quality +#define FAST_BILINEAR_FILTERING 0x20 +// Disables color conversion (output is NV21) +#define NO_COLOR_CONVERSION 0x40 + +// This function must be called before +// any other decoding functions +int nv_avc_init(int width, int height, int perf_lvl, int thread_count) { + int err; + int filtering; + + pthread_mutex_init(&mutex, NULL); + + // Initialize the avcodec library and register codecs + av_log_set_level(AV_LOG_QUIET); + avcodec_register_all(); + + av_init_packet(&pkt); + + decoder = avcodec_find_decoder(AV_CODEC_ID_H264); + if (decoder == NULL) { + __android_log_write(ANDROID_LOG_ERROR, "NVAVCDEC", + "Couldn't find H264 decoder"); + return -1; + } + + decoder_ctx = avcodec_alloc_context3(decoder); + if (decoder_ctx == NULL) { + __android_log_write(ANDROID_LOG_ERROR, "NVAVCDEC", + "Couldn't allocate context"); + return -1; + } + + // Show frames even before a reference frame + decoder_ctx->flags2 |= CODEC_FLAG2_SHOW_ALL; + + if (perf_lvl & DISABLE_LOOP_FILTER) { + // Skip the loop filter for performance reasons + decoder_ctx->skip_loop_filter = AVDISCARD_ALL; + } + + if (perf_lvl & LOW_LATENCY_DECODE) { + // Use low delay single threaded encoding + decoder_ctx->flags |= CODEC_FLAG_LOW_DELAY; + } + + if (perf_lvl & SLICE_THREADING) { + decoder_ctx->thread_type = FF_THREAD_SLICE; + } + else { + decoder_ctx->thread_type = FF_THREAD_FRAME; + } + + decoder_ctx->thread_count = thread_count; + + decoder_ctx->width = width; + decoder_ctx->height = height; + decoder_ctx->pix_fmt = PIX_FMT_YUV420P; + + err = avcodec_open2(decoder_ctx, decoder, NULL); + if (err < 0) { + __android_log_write(ANDROID_LOG_ERROR, "NVAVCDEC", + "Couldn't open codec"); + return err; + } + + dec_frame = av_frame_alloc(); + if (dec_frame == NULL) { + __android_log_write(ANDROID_LOG_ERROR, "NVAVCDEC", + "Couldn't allocate frame"); + return -1; + } + + if (!(perf_lvl & NO_COLOR_CONVERSION)) { + rgb_frame = av_frame_alloc(); + if (rgb_frame == NULL) { + __android_log_write(ANDROID_LOG_ERROR, "NVAVCDEC", + "Couldn't allocate frame"); + return -1; + } + + rgb_frame_buf = (char*)av_malloc(width * height * BYTES_PER_PIXEL); + if (rgb_frame_buf == NULL) { + __android_log_write(ANDROID_LOG_ERROR, "NVAVCDEC", + "Couldn't allocate picture"); + return -1; + } + + err = avpicture_fill((AVPicture*)rgb_frame, + rgb_frame_buf, + RENDER_PIX_FMT, + decoder_ctx->width, + decoder_ctx->height); + if (err < 0) { + __android_log_write(ANDROID_LOG_ERROR, "NVAVCDEC", + "Couldn't fill picture"); + return err; + } + + if (perf_lvl & FAST_BILINEAR_FILTERING) { + filtering = SWS_FAST_BILINEAR; + } + else if (perf_lvl & BILINEAR_FILTERING) { + filtering = SWS_BILINEAR; + } + else { + filtering = SWS_BICUBIC; + } + + scaler_ctx = sws_getContext(decoder_ctx->width, + decoder_ctx->height, + decoder_ctx->pix_fmt, + decoder_ctx->width, + decoder_ctx->height, + RENDER_PIX_FMT, + filtering, + NULL, NULL, NULL); + if (scaler_ctx == NULL) { + __android_log_write(ANDROID_LOG_ERROR, "NVAVCDEC", + "Couldn't get scaler context"); + return -1; + } + } + + return 0; +} + +// This function must be called after +// decoding is finished +void nv_avc_destroy(void) { + if (decoder_ctx) { + avcodec_close(decoder_ctx); + av_free(decoder_ctx); + decoder_ctx = NULL; + } + if (scaler_ctx) { + sws_freeContext(scaler_ctx); + scaler_ctx = NULL; + } + if (dec_frame) { + av_frame_free(&dec_frame); + dec_frame = NULL; + } + if (yuv_frame) { + av_frame_free(&yuv_frame); + yuv_frame = NULL; + } + if (rgb_frame) { + av_frame_free(&rgb_frame); + rgb_frame = NULL; + } + if (rgb_frame_buf) { + av_free(rgb_frame_buf); + rgb_frame_buf = NULL; + } +#ifdef __ANDROID_API__ + if (window) { + ANativeWindow_release(window); + window = NULL; + } +#endif + pthread_mutex_destroy(&mutex); +} + +static AVFrame* dequeue_new_frame(void) { + AVFrame *our_yuv_frame = NULL; + + pthread_mutex_lock(&mutex); + + // Check if there's a new frame + if (yuv_frame) { + // We now own the decoder's frame and are + // responsible for freeing it when we're done + our_yuv_frame = yuv_frame; + yuv_frame = NULL; + } + + pthread_mutex_unlock(&mutex); + + return our_yuv_frame; +} + +static int update_rgb_frame(void) { + AVFrame *our_yuv_frame; + int err; + + our_yuv_frame = dequeue_new_frame(); + if (our_yuv_frame == NULL) { + return 0; + } + + // Convert the YUV image to RGB + err = sws_scale(scaler_ctx, + our_yuv_frame->data, + our_yuv_frame->linesize, + 0, + decoder_ctx->height, + rgb_frame->data, + rgb_frame->linesize); + + av_frame_free(&our_yuv_frame); + + if (err != decoder_ctx->height) { + __android_log_write(ANDROID_LOG_ERROR, "NVAVCDEC", + "Scaling failed"); + return 0; + } + + return 1; +} + +static int render_rgb_to_buffer(char* buffer, int size) { + int err; + + // Draw the frame to the buffer + err = avpicture_layout((AVPicture*)rgb_frame, + RENDER_PIX_FMT, + decoder_ctx->width, + decoder_ctx->height, + buffer, + size); + if (err < 0) { + __android_log_write(ANDROID_LOG_ERROR, "NVAVCDEC", + "Picture fill failed"); + return 0; + } + + return 1; +} + +int nv_avc_get_raw_frame(char* buffer, int size) { + AVFrame *our_yuv_frame; + int err; + + our_yuv_frame = dequeue_new_frame(); + if (our_yuv_frame == NULL) { + return 0; + } + + err = avpicture_layout((AVPicture*)our_yuv_frame, + decoder_ctx->pix_fmt, + decoder_ctx->width, + decoder_ctx->height, + buffer, + size); + + av_frame_free(&our_yuv_frame); + + return (err >= 0); +} + +int nv_avc_get_rgb_frame(char* buffer, int size) { + return (update_rgb_frame() && render_rgb_to_buffer(buffer, size)); +} + +#ifdef __ANDROID_API__ +int nv_avc_set_render_target(JNIEnv *env, jobject surface) { + // Release the old window + if (window) { + ANativeWindow_release(window); + window = NULL; + } + + // If no new surface was supplied, we're done + if (surface == NULL) { + return 1; + } + + // Get a window from the surface + window = ANativeWindow_fromSurface(env, surface); + if (window == NULL) { + __android_log_write(ANDROID_LOG_ERROR, "NVAVCDEC", + "Failed to get window from surface"); + return 0; + } + + return 1; +} + +int nv_avc_redraw(void) { + ANativeWindow_Buffer buffer; + int ret = 0; + + // Check if there's a new frame + if (update_rgb_frame()) { + // Lock down a render buffer + if (ANativeWindow_lock(window, &buffer, NULL) >= 0) { + // Draw the frame to the buffer + if (render_rgb_to_buffer(buffer.bits, + decoder_ctx->width * + decoder_ctx->height * + BYTES_PER_PIXEL)) { + // A new frame will be drawn + ret = 1; + } + + // Draw the frame to the surface + ANativeWindow_unlockAndPost(window); + } + } + + return ret; +} +#endif + +int nv_avc_get_input_padding_size(void) { + return FF_INPUT_BUFFER_PADDING_SIZE; +} + +// packets must be decoded in order +// indata must be inlen + FF_INPUT_BUFFER_PADDING_SIZE in length +int nv_avc_decode(unsigned char* indata, int inlen) { + int err; + int got_pic = 0; + + pkt.data = indata; + pkt.size = inlen; + + while (pkt.size > 0) { + got_pic = 0; + err = avcodec_decode_video2( + decoder_ctx, + dec_frame, + &got_pic, + &pkt); + if (err < 0) { + __android_log_write(ANDROID_LOG_ERROR, "NVAVCDEC", + "Decode failed"); + got_pic = 0; + break; + } + + pkt.size -= err; + pkt.data += err; + } + + // Only copy the picture at the end of decoding the packet + if (got_pic) { + pthread_mutex_lock(&mutex); + + // Only clone this frame if the last frame was taken. + // This saves on extra copies for frames that don't get + // rendered. + if (yuv_frame == NULL) { + // Clone a new frame + yuv_frame = av_frame_clone(dec_frame); + } + + pthread_mutex_unlock(&mutex); + } + + return err < 0 ? err : 0; +} diff --git a/limelight-pc/jni/nv_avc_dec/nv_avc_dec.h b/limelight-pc/jni/nv_avc_dec/nv_avc_dec.h new file mode 100755 index 0000000..f6d2d96 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/nv_avc_dec.h @@ -0,0 +1,14 @@ +#include + +int nv_avc_init(int width, int height, int perf_lvl, int thread_count); +void nv_avc_destroy(void); + +int nv_avc_get_raw_frame(char* buffer, int size); + +int nv_avc_get_rgb_frame(char* buffer, int size); +int nv_avc_get_rgb_frame_int(int* buffer, int size); +int nv_avc_set_render_target(JNIEnv *env, jobject surface); +int nv_avc_redraw(void); + +int nv_avc_get_input_padding_size(void); +int nv_avc_decode(unsigned char* indata, int inlen); diff --git a/limelight-pc/jni/nv_avc_dec/nv_avc_dec_jni.c b/limelight-pc/jni/nv_avc_dec/nv_avc_dec_jni.c new file mode 100755 index 0000000..fda82e5 --- /dev/null +++ b/limelight-pc/jni/nv_avc_dec/nv_avc_dec_jni.c @@ -0,0 +1,115 @@ +#include "nv_avc_dec.h" + +#include +#include + +// This function must be called before +// any other decoding functions +JNIEXPORT jint JNICALL +Java_com_limelight_nvstream_av_video_cpu_AvcDecoder_init(JNIEnv *env, jobject this, jint width, + jint height, jint perflvl, jint threadcount) +{ + return nv_avc_init(width, height, perflvl, threadcount); +} + +// This function must be called after +// decoding is finished +JNIEXPORT void JNICALL +Java_com_limelight_nvstream_av_video_cpu_AvcDecoder_destroy(JNIEnv *env, jobject this) { + nv_avc_destroy(); +} + +// fills the output buffer with a raw YUV frame +JNIEXPORT jboolean JNICALL +Java_com_limelight_nvstream_av_video_cpu_AvcDecoder_getRawFrame( + JNIEnv *env, jobject this, // JNI parameters + jbyteArray outdata, jint outlen) // Output data +{ + jint ret; + jbyte* jni_output_data; + + jni_output_data = (*env)->GetByteArrayElements(env, outdata, 0); + + ret = nv_avc_get_raw_frame(jni_output_data, outlen); + + (*env)->ReleaseByteArrayElements(env, outdata, jni_output_data, 0); + + return ret != 0 ? JNI_TRUE : JNI_FALSE; +} + +// fills the output buffer with an RGB frame +JNIEXPORT jboolean JNICALL +Java_com_limelight_nvstream_av_video_cpu_AvcDecoder_getRgbFrame( + JNIEnv *env, jobject this, // JNI parameters + jbyteArray outdata, jint outlen) // Output data +{ + jint ret; + jbyte* jni_output_data; + + jni_output_data = (*env)->GetByteArrayElements(env, outdata, 0); + + ret = nv_avc_get_rgb_frame(jni_output_data, outlen); + + (*env)->ReleaseByteArrayElements(env, outdata, jni_output_data, 0); + + return ret != 0 ? JNI_TRUE : JNI_FALSE; +} + +// fills the output buffer with an RGB frame +JNIEXPORT jboolean JNICALL +Java_com_limelight_nvstream_av_video_cpu_AvcDecoder_getRgbFrameInt( + JNIEnv *env, jobject this, // JNI parameters + jintArray outdata, jint outlen) // Output data +{ + jint ret; + jint* jni_output_data; + + jni_output_data = (*env)->GetIntArrayElements(env, outdata, 0); + + ret = nv_avc_get_rgb_frame(jni_output_data, outlen * 4); + + (*env)->ReleaseIntArrayElements(env, outdata, jni_output_data, 0); + + return ret != 0 ? JNI_TRUE : JNI_FALSE; +} + +#ifdef __ANDROID_API__ +// This function sets the rendering target for redraw +JNIEXPORT jboolean JNICALL +Java_com_limelight_nvstream_av_video_cpu_AvcDecoder_setRenderTarget(JNIEnv *env, jobject this, jobject surface) { + return nv_avc_set_render_target(env, surface) != 0 ? JNI_TRUE : JNI_FALSE; +} + +// This function redraws the surface +JNIEXPORT jboolean JNICALL +Java_com_limelight_nvstream_av_video_cpu_AvcDecoder_redraw(JNIEnv *env, jobject this) { + return nv_avc_redraw() != 0 ? JNI_TRUE : JNI_FALSE; +} +#endif + +// This function returns the required input buffer padding +JNIEXPORT jint JNICALL +Java_com_limelight_nvstream_av_video_cpu_AvcDecoder_getInputPaddingSize(JNIEnv *env, jobject this) { + return nv_avc_get_input_padding_size(); +} + +// packets must be decoded in order +// the input buffer must have proper padding +// returns 0 on success, < 0 on error +JNIEXPORT jint JNICALL +Java_com_limelight_nvstream_av_video_cpu_AvcDecoder_decode( + JNIEnv *env, jobject this, // JNI parameters + jbyteArray indata, jint inoff, jint inlen) +{ + jint ret; + jbyte* jni_input_data; + + jni_input_data = (*env)->GetByteArrayElements(env, indata, 0); + + ret = nv_avc_decode(&jni_input_data[inoff], inlen); + + // The input data isn't changed so it can be safely aborted + (*env)->ReleaseByteArrayElements(env, indata, jni_input_data, JNI_ABORT); + + return ret; +} diff --git a/limelight-pc/jni/nv_opus_dec/.DS_Store b/limelight-pc/jni/nv_opus_dec/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..5008ddfcf53c02e82d7eee2e57c38e5672ef89f6 GIT binary patch literal 6148 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
K-jXkb0_cZsqto9#6 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 azUxUUG0$O!{L}7qLt^vq-~Xp2@IL^}d~_iI diff --git a/limelight-pc/jni/nv_opus_dec/libopus/nv_opus_dec.c b/limelight-pc/jni/nv_opus_dec/nv_opus_dec.c similarity index 100% rename from limelight-pc/jni/nv_opus_dec/libopus/nv_opus_dec.c rename to limelight-pc/jni/nv_opus_dec/nv_opus_dec.c diff --git a/limelight-pc/jni/nv_opus_dec/libopus/nv_opus_dec.h b/limelight-pc/jni/nv_opus_dec/nv_opus_dec.h similarity index 100% rename from limelight-pc/jni/nv_opus_dec/libopus/nv_opus_dec.h rename to limelight-pc/jni/nv_opus_dec/nv_opus_dec.h diff --git a/limelight-pc/jni/nv_opus_dec/libopus/nv_opus_dec_jni.c b/limelight-pc/jni/nv_opus_dec/nv_opus_dec_jni.c similarity index 100% rename from limelight-pc/jni/nv_opus_dec/libopus/nv_opus_dec_jni.c rename to limelight-pc/jni/nv_opus_dec/nv_opus_dec_jni.c diff --git a/limelight-pc/libs/limelight-common.jar b/limelight-pc/libs/limelight-common.jar index 95c7a6d4a8a86064620a65274bbac2ef613e285c..27433592e1ee651e06f62eeeaf05ff9b0c54a464 100644 GIT binary patch delta 115142 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

uhVb`J}p-!l{ztBtD)b)tcq0<9%Z2Uch?7%PuS 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 N6cCUB_s_9`{2#bv_$&Yb delta 2253 zcmY+FcR&+Y9LJ9bCWK`eE))nt1PsH$uxKl&hzPYop@M@1ih~su#Q}jM2nov(Q#c8V z6(uSn!&8L1umQ1xTSSFo1zc4t!y<}eFTlHt$v>a>`~Ked_q%uRz3aksT1qtaxxSiO zCWyASHqx1&Ce>d_BPc9CP3A#!!B!^#dPQ+PP>bOun!Di`_n?U(tMYLT2KSqBwyv=z zoLil1i*XZx9{$Kc%2WlNrD^y^i%&xdLu|E0VBFUfenYs_dEk6O5N6!h+QwZ%%3fiXVli;~GZml#8ql@)TZND(l_pK?9P zsyfcLGH$?AXi}Za!NUT($vK`pSJ|GR=TP2gL1eEr!2U}CMz}I~J1mZS@|Ka7p1kkz z<}lxH#%tDEXh9Q|ULSdZ)Hhn$Vz*O?z8VBGwP6wwBq}kmS!uu!U%2f!xrClPj*Krf z!l&;TRO^z1^My{NBawsGpl)gvhv&Gbo*{EoRk>ndf=^4Q>#A2}$_+47LcCB^<_xp( z>Rda>GGY;MrreG`G6|o1IFjtHtk4^65!~}&9%RR~E9~rE?E(%LHGC}NA{ggP);k&m zoo=6+k&-MauQ+#t!<*W&DPSLxm)}O@?7mxa z@pV&DnM>Um|t2ja*megqr!|#6A10#Fm{e^d?op}=$ z;iT^t${uxYaQuRSIof$LQDD`s$e2BHdDDjz=n}qVSzXV(C$aQr^OmQ?fjoXEp6tHP zmGkf7@{E`ie?B)g!Kl@8ufp)qd4KyH>ncg3vwNRVBA(1;GU{{9W?Zgvx{`?23hpcA z<`4d!=F+g{#^HPGk|cdGSLyF86R=NX>pS>89dUI#wXARx2rZ?&wb9CQz%eOx^eLwMsxT;H^CB@g3 zK8NytFw4MtXJ_rc8oW6@;6wCybAR++?Sylue)0=16d$#FzbSYTJG`i+?Y3KxvfcPv zNJyweHzlrSX={dwz0%s+u&6%?lmfrHji%jO^wu$N)piBeJ{n)(C3FyPPJa=$-FyN& zDA_C9KD5&+elYr3DVjF1+C|`6^{D;1quUNaf2evnLpuTHC|FJH= z{ukV_gZyk>jqg+5mBZ^p3|ALlM!3Fo?aTN~v+DpsaH zTKXEm1R-yC?0!7(P@P8Ne#cA`z%t02)wofO*+MEONsXI@z<=aaV~&Y{2U(T~f+6=L zf&j>VNfaw6&P728ObJH;AM$k+EQLHd87zUkHJOUvOa`lAe7Xp%f-DnJJ|9I?o7@yI z^l2mB23C