├── ffmpegdemo ├── .gitignore ├── .idea │ ├── gradle.xml │ ├── misc.xml │ ├── modules.xml │ └── runConfigurations.xml ├── app │ ├── .gitignore │ ├── CMakeLists.txt │ ├── build.gradle │ ├── libs │ │ ├── armeabi │ │ │ ├── libavcodec-56.so │ │ │ ├── libavdevice-56.so │ │ │ ├── libavfilter-5.so │ │ │ ├── libavformat-56.so │ │ │ ├── libavutil-54.so │ │ │ ├── libpostproc-53.so │ │ │ ├── libswresample-1.so │ │ │ └── libswscale-3.so │ │ └── include │ │ │ ├── libavcodec │ │ │ ├── avcodec.h │ │ │ ├── avfft.h │ │ │ ├── dv_profile.h │ │ │ ├── dxva2.h │ │ │ ├── old_codec_ids.h │ │ │ ├── qsv.h │ │ │ ├── vaapi.h │ │ │ ├── vda.h │ │ │ ├── vdpau.h │ │ │ ├── version.h │ │ │ ├── vorbis_parser.h │ │ │ └── xvmc.h │ │ │ ├── libavdevice │ │ │ ├── avdevice.h │ │ │ └── version.h │ │ │ ├── libavfilter │ │ │ ├── asrc_abuffer.h │ │ │ ├── avcodec.h │ │ │ ├── avfilter.h │ │ │ ├── avfiltergraph.h │ │ │ ├── buffersink.h │ │ │ ├── buffersrc.h │ │ │ └── version.h │ │ │ ├── libavformat │ │ │ ├── avformat.h │ │ │ ├── avio.h │ │ │ └── version.h │ │ │ ├── libavutil │ │ │ ├── adler32.h │ │ │ ├── aes.h │ │ │ ├── attributes.h │ │ │ ├── audio_fifo.h │ │ │ ├── audioconvert.h │ │ │ ├── avassert.h │ │ │ ├── avconfig.h │ │ │ ├── avstring.h │ │ │ ├── avutil.h │ │ │ ├── base64.h │ │ │ ├── blowfish.h │ │ │ ├── bprint.h │ │ │ ├── bswap.h │ │ │ ├── buffer.h │ │ │ ├── camellia.h │ │ │ ├── cast5.h │ │ │ ├── channel_layout.h │ │ │ ├── common.h │ │ │ ├── cpu.h │ │ │ ├── crc.h │ │ │ ├── dict.h │ │ │ ├── display.h │ │ │ ├── downmix_info.h │ │ │ ├── error.h │ │ │ ├── eval.h │ │ │ ├── ffversion.h │ │ │ ├── fifo.h │ │ │ ├── file.h │ │ │ ├── frame.h │ │ │ ├── hash.h │ │ │ ├── hmac.h │ │ │ ├── imgutils.h │ │ │ ├── intfloat.h │ │ │ ├── intreadwrite.h │ │ │ ├── lfg.h │ │ │ ├── log.h │ │ │ ├── lzo.h │ │ │ ├── macros.h │ │ │ ├── mathematics.h │ │ │ ├── md5.h │ │ │ ├── mem.h │ │ │ ├── motion_vector.h │ │ │ ├── murmur3.h │ │ │ ├── old_pix_fmts.h │ │ │ ├── opt.h │ │ │ ├── parseutils.h │ │ │ ├── pixdesc.h │ │ │ ├── pixelutils.h │ │ │ ├── pixfmt.h │ │ │ ├── random_seed.h │ │ │ ├── rational.h │ │ │ ├── replaygain.h │ │ │ ├── ripemd.h │ │ │ ├── samplefmt.h │ │ │ ├── sha.h │ │ │ ├── sha512.h │ │ │ ├── stereo3d.h │ │ │ ├── threadmessage.h │ │ │ ├── time.h │ │ │ ├── timecode.h │ │ │ ├── timestamp.h │ │ │ ├── twofish.h │ │ │ ├── version.h │ │ │ └── xtea.h │ │ │ ├── libpostproc │ │ │ ├── postprocess.h │ │ │ └── version.h │ │ │ ├── libswresample │ │ │ ├── swresample.h │ │ │ └── version.h │ │ │ └── libswscale │ │ │ ├── swscale.h │ │ │ └── version.h │ ├── proguard-rules.pro │ └── src │ │ ├── androidTest │ │ └── java │ │ │ └── com │ │ │ └── jinhe │ │ │ └── ffmpegdemo │ │ │ └── ExampleInstrumentedTest.kt │ │ ├── main │ │ ├── AndroidManifest.xml │ │ ├── cpp │ │ │ └── native-lib.cpp │ │ ├── java │ │ │ └── com │ │ │ │ └── jinhe │ │ │ │ └── ffmpegdemo │ │ │ │ ├── MainActivity.kt │ │ │ │ └── VideoView.kt │ │ └── res │ │ │ ├── drawable-v24 │ │ │ └── ic_launcher_foreground.xml │ │ │ ├── drawable │ │ │ └── ic_launcher_background.xml │ │ │ ├── layout │ │ │ └── activity_main.xml │ │ │ ├── mipmap-anydpi-v26 │ │ │ ├── ic_launcher.xml │ │ │ └── ic_launcher_round.xml │ │ │ ├── mipmap-hdpi │ │ │ ├── ic_launcher.png │ │ │ └── ic_launcher_round.png │ │ │ ├── mipmap-mdpi │ │ │ ├── ic_launcher.png │ │ │ └── ic_launcher_round.png │ │ │ ├── mipmap-xhdpi │ │ │ ├── ic_launcher.png │ │ │ └── ic_launcher_round.png │ │ │ ├── mipmap-xxhdpi │ │ │ ├── ic_launcher.png │ │ │ └── ic_launcher_round.png │ │ │ ├── mipmap-xxxhdpi │ │ │ ├── ic_launcher.png │ │ │ └── ic_launcher_round.png │ │ │ └── values │ │ │ ├── colors.xml │ │ │ ├── strings.xml │ │ │ └── styles.xml │ │ └── test │ │ └── java │ │ └── com │ │ └── jinhe │ │ └── ffmpegdemo │ │ └── ExampleUnitTest.kt ├── build.gradle ├── gradle.properties ├── gradle │ └── wrapper │ │ ├── gradle-wrapper.jar │ │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat └── settings.gradle └── test.txt /ffmpegdemo/.gitignore: -------------------------------------------------------------------------------- 1 | *.iml 2 | .gradle 3 | /local.properties 4 | /.idea/workspace.xml 5 | /.idea/libraries 6 | .DS_Store 7 | /build 8 | /captures 9 | .externalNativeBuild 10 | -------------------------------------------------------------------------------- /ffmpegdemo/.idea/gradle.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 17 | 18 | -------------------------------------------------------------------------------- /ffmpegdemo/.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 16 | 26 | 27 | 28 | 29 | 30 | 31 | 33 | 34 | 35 | 36 | 37 | 1.8 38 | 39 | 44 | 45 | 46 | 47 | 48 | 49 | -------------------------------------------------------------------------------- /ffmpegdemo/.idea/modules.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /ffmpegdemo/.idea/runConfigurations.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 11 | 12 | -------------------------------------------------------------------------------- /ffmpegdemo/app/.gitignore: -------------------------------------------------------------------------------- 1 | /build 2 | -------------------------------------------------------------------------------- /ffmpegdemo/app/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | cmake_minimum_required(VERSION 3.4.1) 3 | 4 | add_library( native-lib 5 | SHARED 6 | src/main/cpp/native-lib.cpp ) 7 | 8 | find_library( log-lib 9 | log ) 10 | 11 | 12 | include_directories(libs/include) 13 | set(DIR ../../../../libs) 14 | add_library(avcodec-56 15 | SHARED 16 | IMPORTED) 17 | set_target_properties(avcodec-56 18 | PROPERTIES IMPORTED_LOCATION 19 | ${DIR}/armeabi/libavcodec-56.so) 20 | 21 | add_library(avdevice-56 22 | SHARED 23 | IMPORTED) 24 | set_target_properties(avdevice-56 25 | PROPERTIES IMPORTED_LOCATION 26 | ${DIR}/armeabi/libavdevice-56.so) 27 | add_library(avformat-56 28 | SHARED 29 | IMPORTED) 30 | set_target_properties(avformat-56 31 | PROPERTIES IMPORTED_LOCATION 32 | ${DIR}/armeabi/libavformat-56.so) 33 | add_library(avutil-54 34 | SHARED 35 | IMPORTED) 36 | set_target_properties(avutil-54 37 | PROPERTIES IMPORTED_LOCATION 38 | ${DIR}/armeabi/libavutil-54.so) 39 | add_library(postproc-53 40 | SHARED 41 | IMPORTED) 42 | set_target_properties(postproc-53 43 | PROPERTIES IMPORTED_LOCATION 44 | ${DIR}/armeabi/libpostproc-53.so) 45 | add_library(swresample-1 46 | SHARED 47 | IMPORTED) 48 | set_target_properties(swresample-1 49 | PROPERTIES IMPORTED_LOCATION 50 | ${DIR}/armeabi/libswresample-1.so) 51 | add_library(swscale-3 52 | SHARED 53 | IMPORTED) 54 | set_target_properties(swscale-3 55 | PROPERTIES IMPORTED_LOCATION 56 | ${DIR}/armeabi/libswscale-3.so) 57 | add_library(avfilter-5 58 | SHARED 59 | IMPORTED) 60 | set_target_properties(avfilter-5 61 | PROPERTIES IMPORTED_LOCATION 62 | ${DIR}/armeabi/libavfilter-5.so) 63 | target_link_libraries( native-lib 64 | avfilter-5 65 | avcodec-56 66 | avdevice-56 67 | avformat-56 68 | avutil-54 69 | postproc-53 70 | swresample-1 71 | swscale-3 72 | ${log-lib} 73 | android) -------------------------------------------------------------------------------- /ffmpegdemo/app/build.gradle: -------------------------------------------------------------------------------- 1 | apply plugin: 'com.android.application' 2 | 3 | apply plugin: 'kotlin-android' 4 | 5 | apply plugin: 'kotlin-android-extensions' 6 | 7 | android { 8 | compileSdkVersion 26 9 | defaultConfig { 10 | applicationId "com.jinhe.ffmpegdemo" 11 | minSdkVersion 18 12 | targetSdkVersion 26 13 | versionCode 1 14 | versionName "1.0" 15 | testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" 16 | 17 | sourceSets { 18 | main { 19 | jniLibs.srcDirs = ['libs'] 20 | } 21 | } 22 | 23 | externalNativeBuild { 24 | cmake { 25 | cppFlags "-frtti -fexceptions" 26 | abiFilters 'armeabi' 27 | } 28 | } 29 | } 30 | buildTypes { 31 | release { 32 | minifyEnabled false 33 | proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' 34 | } 35 | } 36 | externalNativeBuild { 37 | cmake { 38 | path "CMakeLists.txt" 39 | } 40 | } 41 | } 42 | 43 | dependencies { 44 | implementation fileTree(dir: 'libs', include: ['*.jar']) 45 | implementation"org.jetbrains.kotlin:kotlin-stdlib-jre7:$kotlin_version" 46 | implementation 'com.android.support:appcompat-v7:26.1.0' 47 | implementation 'com.android.support.constraint:constraint-layout:1.0.2' 48 | testImplementation 'junit:junit:4.12' 49 | androidTestImplementation 'com.android.support.test:runner:1.0.1' 50 | androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.1' 51 | } 52 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/armeabi/libavcodec-56.so: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/2016lc/FFmpegDemo/41db37e764a19a8625816aa73a822667e46cc611/ffmpegdemo/app/libs/armeabi/libavcodec-56.so -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/armeabi/libavdevice-56.so: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/2016lc/FFmpegDemo/41db37e764a19a8625816aa73a822667e46cc611/ffmpegdemo/app/libs/armeabi/libavdevice-56.so -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/armeabi/libavfilter-5.so: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/2016lc/FFmpegDemo/41db37e764a19a8625816aa73a822667e46cc611/ffmpegdemo/app/libs/armeabi/libavfilter-5.so -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/armeabi/libavformat-56.so: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/2016lc/FFmpegDemo/41db37e764a19a8625816aa73a822667e46cc611/ffmpegdemo/app/libs/armeabi/libavformat-56.so -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/armeabi/libavutil-54.so: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/2016lc/FFmpegDemo/41db37e764a19a8625816aa73a822667e46cc611/ffmpegdemo/app/libs/armeabi/libavutil-54.so -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/armeabi/libpostproc-53.so: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/2016lc/FFmpegDemo/41db37e764a19a8625816aa73a822667e46cc611/ffmpegdemo/app/libs/armeabi/libpostproc-53.so -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/armeabi/libswresample-1.so: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/2016lc/FFmpegDemo/41db37e764a19a8625816aa73a822667e46cc611/ffmpegdemo/app/libs/armeabi/libswresample-1.so -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/armeabi/libswscale-3.so: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/2016lc/FFmpegDemo/41db37e764a19a8625816aa73a822667e46cc611/ffmpegdemo/app/libs/armeabi/libswscale-3.so -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavcodec/avfft.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of FFmpeg. 3 | * 4 | * FFmpeg is free software; you can redistribute it and/or 5 | * modify it under the terms of the GNU Lesser General Public 6 | * License as published by the Free Software Foundation; either 7 | * version 2.1 of the License, or (at your option) any later version. 8 | * 9 | * FFmpeg is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | * Lesser General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU Lesser General Public 15 | * License along with FFmpeg; if not, write to the Free Software 16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 17 | */ 18 | 19 | #ifndef AVCODEC_AVFFT_H 20 | #define AVCODEC_AVFFT_H 21 | 22 | /** 23 | * @file 24 | * @ingroup lavc_fft 25 | * FFT functions 26 | */ 27 | 28 | /** 29 | * @defgroup lavc_fft FFT functions 30 | * @ingroup lavc_misc 31 | * 32 | * @{ 33 | */ 34 | 35 | typedef float FFTSample; 36 | 37 | typedef struct FFTComplex { 38 | FFTSample re, im; 39 | } FFTComplex; 40 | 41 | typedef struct FFTContext FFTContext; 42 | 43 | /** 44 | * Set up a complex FFT. 45 | * @param nbits log2 of the length of the input array 46 | * @param inverse if 0 perform the forward transform, if 1 perform the inverse 47 | */ 48 | FFTContext *av_fft_init(int nbits, int inverse); 49 | 50 | /** 51 | * Do the permutation needed BEFORE calling ff_fft_calc(). 52 | */ 53 | void av_fft_permute(FFTContext *s, FFTComplex *z); 54 | 55 | /** 56 | * Do a complex FFT with the parameters defined in av_fft_init(). The 57 | * input data must be permuted before. No 1.0/sqrt(n) normalization is done. 58 | */ 59 | void av_fft_calc(FFTContext *s, FFTComplex *z); 60 | 61 | void av_fft_end(FFTContext *s); 62 | 63 | FFTContext *av_mdct_init(int nbits, int inverse, double scale); 64 | void av_imdct_calc(FFTContext *s, FFTSample *output, const FFTSample *input); 65 | void av_imdct_half(FFTContext *s, FFTSample *output, const FFTSample *input); 66 | void av_mdct_calc(FFTContext *s, FFTSample *output, const FFTSample *input); 67 | void av_mdct_end(FFTContext *s); 68 | 69 | /* Real Discrete Fourier Transform */ 70 | 71 | enum RDFTransformType { 72 | DFT_R2C, 73 | IDFT_C2R, 74 | IDFT_R2C, 75 | DFT_C2R, 76 | }; 77 | 78 | typedef struct RDFTContext RDFTContext; 79 | 80 | /** 81 | * Set up a real FFT. 82 | * @param nbits log2 of the length of the input array 83 | * @param trans the type of transform 84 | */ 85 | RDFTContext *av_rdft_init(int nbits, enum RDFTransformType trans); 86 | void av_rdft_calc(RDFTContext *s, FFTSample *data); 87 | void av_rdft_end(RDFTContext *s); 88 | 89 | /* Discrete Cosine Transform */ 90 | 91 | typedef struct DCTContext DCTContext; 92 | 93 | enum DCTTransformType { 94 | DCT_II = 0, 95 | DCT_III, 96 | DCT_I, 97 | DST_I, 98 | }; 99 | 100 | /** 101 | * Set up DCT. 102 | * 103 | * @param nbits size of the input array: 104 | * (1 << nbits) for DCT-II, DCT-III and DST-I 105 | * (1 << nbits) + 1 for DCT-I 106 | * @param type the type of transform 107 | * 108 | * @note the first element of the input of DST-I is ignored 109 | */ 110 | DCTContext *av_dct_init(int nbits, enum DCTTransformType type); 111 | void av_dct_calc(DCTContext *s, FFTSample *data); 112 | void av_dct_end (DCTContext *s); 113 | 114 | /** 115 | * @} 116 | */ 117 | 118 | #endif /* AVCODEC_AVFFT_H */ 119 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavcodec/dv_profile.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of FFmpeg. 3 | * 4 | * FFmpeg is free software; you can redistribute it and/or 5 | * modify it under the terms of the GNU Lesser General Public 6 | * License as published by the Free Software Foundation; either 7 | * version 2.1 of the License, or (at your option) any later version. 8 | * 9 | * FFmpeg is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | * Lesser General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU Lesser General Public 15 | * License along with FFmpeg; if not, write to the Free Software 16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 17 | */ 18 | 19 | #ifndef AVCODEC_DV_PROFILE_H 20 | #define AVCODEC_DV_PROFILE_H 21 | 22 | #include 23 | 24 | #include "libavutil/pixfmt.h" 25 | #include "libavutil/rational.h" 26 | #include "avcodec.h" 27 | 28 | /* minimum number of bytes to read from a DV stream in order to 29 | * determine the profile */ 30 | #define DV_PROFILE_BYTES (6 * 80) /* 6 DIF blocks */ 31 | 32 | 33 | /* 34 | * AVDVProfile is used to express the differences between various 35 | * DV flavors. For now it's primarily used for differentiating 36 | * 525/60 and 625/50, but the plans are to use it for various 37 | * DV specs as well (e.g. SMPTE314M vs. IEC 61834). 38 | */ 39 | typedef struct AVDVProfile { 40 | int dsf; /* value of the dsf in the DV header */ 41 | int video_stype; /* stype for VAUX source pack */ 42 | int frame_size; /* total size of one frame in bytes */ 43 | int difseg_size; /* number of DIF segments per DIF channel */ 44 | int n_difchan; /* number of DIF channels per frame */ 45 | AVRational time_base; /* 1/framerate */ 46 | int ltc_divisor; /* FPS from the LTS standpoint */ 47 | int height; /* picture height in pixels */ 48 | int width; /* picture width in pixels */ 49 | AVRational sar[2]; /* sample aspect ratios for 4:3 and 16:9 */ 50 | enum AVPixelFormat pix_fmt; /* picture pixel format */ 51 | int bpm; /* blocks per macroblock */ 52 | const uint8_t *block_sizes; /* AC block sizes, in bits */ 53 | int audio_stride; /* size of audio_shuffle table */ 54 | int audio_min_samples[3]; /* min amount of audio samples */ 55 | /* for 48kHz, 44.1kHz and 32kHz */ 56 | int audio_samples_dist[5]; /* how many samples are supposed to be */ 57 | /* in each frame in a 5 frames window */ 58 | const uint8_t (*audio_shuffle)[9]; /* PCM shuffling table */ 59 | } AVDVProfile; 60 | 61 | #if FF_API_DV_FRAME_PROFILE 62 | /** 63 | * @deprecated use av_dv_frame_profile() 64 | */ 65 | attribute_deprecated 66 | const AVDVProfile* avpriv_dv_frame_profile2(AVCodecContext* codec, const AVDVProfile *sys, 67 | const uint8_t* frame, unsigned buf_size); 68 | #endif 69 | 70 | /** 71 | * Get a DV profile for the provided compressed frame. 72 | * 73 | * @param sys the profile used for the previous frame, may be NULL 74 | * @param frame the compressed data buffer 75 | * @param buf_size size of the buffer in bytes 76 | * @return the DV profile for the supplied data or NULL on failure 77 | */ 78 | const AVDVProfile *av_dv_frame_profile(const AVDVProfile *sys, 79 | const uint8_t *frame, unsigned buf_size); 80 | 81 | /** 82 | * Get a DV profile for the provided stream parameters. 83 | */ 84 | const AVDVProfile *av_dv_codec_profile(int width, int height, enum AVPixelFormat pix_fmt); 85 | 86 | /** 87 | * Get a DV profile for the provided stream parameters. 88 | * The frame rate is used as a best-effort parameter. 89 | */ 90 | const AVDVProfile *av_dv_codec_profile2(int width, int height, enum AVPixelFormat pix_fmt, AVRational frame_rate); 91 | 92 | #endif /* AVCODEC_DV_PROFILE_H */ 93 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavcodec/dxva2.h: -------------------------------------------------------------------------------- 1 | /* 2 | * DXVA2 HW acceleration 3 | * 4 | * copyright (c) 2009 Laurent Aimar 5 | * 6 | * This file is part of FFmpeg. 7 | * 8 | * FFmpeg is free software; you can redistribute it and/or 9 | * modify it under the terms of the GNU Lesser General Public 10 | * License as published by the Free Software Foundation; either 11 | * version 2.1 of the License, or (at your option) any later version. 12 | * 13 | * FFmpeg is distributed in the hope that it will be useful, 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 | * Lesser General Public License for more details. 17 | * 18 | * You should have received a copy of the GNU Lesser General Public 19 | * License along with FFmpeg; if not, write to the Free Software 20 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 21 | */ 22 | 23 | #ifndef AVCODEC_DXVA_H 24 | #define AVCODEC_DXVA_H 25 | 26 | /** 27 | * @file 28 | * @ingroup lavc_codec_hwaccel_dxva2 29 | * Public libavcodec DXVA2 header. 30 | */ 31 | 32 | #if !defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600 33 | #undef _WIN32_WINNT 34 | #define _WIN32_WINNT 0x0600 35 | #endif 36 | 37 | #include 38 | #include 39 | #include 40 | 41 | /** 42 | * @defgroup lavc_codec_hwaccel_dxva2 DXVA2 43 | * @ingroup lavc_codec_hwaccel 44 | * 45 | * @{ 46 | */ 47 | 48 | #define FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG 1 ///< Work around for DXVA2 and old UVD/UVD+ ATI video cards 49 | #define FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO 2 ///< Work around for DXVA2 and old Intel GPUs with ClearVideo interface 50 | 51 | /** 52 | * This structure is used to provides the necessary configurations and data 53 | * to the DXVA2 FFmpeg HWAccel implementation. 54 | * 55 | * The application must make it available as AVCodecContext.hwaccel_context. 56 | */ 57 | struct dxva_context { 58 | /** 59 | * DXVA2 decoder object 60 | */ 61 | IDirectXVideoDecoder *decoder; 62 | 63 | /** 64 | * DXVA2 configuration used to create the decoder 65 | */ 66 | const DXVA2_ConfigPictureDecode *cfg; 67 | 68 | /** 69 | * The number of surface in the surface array 70 | */ 71 | unsigned surface_count; 72 | 73 | /** 74 | * The array of Direct3D surfaces used to create the decoder 75 | */ 76 | LPDIRECT3DSURFACE9 *surface; 77 | 78 | /** 79 | * A bit field configuring the workarounds needed for using the decoder 80 | */ 81 | uint64_t workaround; 82 | 83 | /** 84 | * Private to the FFmpeg AVHWAccel implementation 85 | */ 86 | unsigned report_id; 87 | }; 88 | 89 | /** 90 | * @} 91 | */ 92 | 93 | #endif /* AVCODEC_DXVA_H */ 94 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavcodec/qsv.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Intel MediaSDK QSV public API 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVCODEC_QSV_H 22 | #define AVCODEC_QSV_H 23 | 24 | #include 25 | 26 | typedef struct AVQSVContext { 27 | mfxSession session; 28 | int iopattern; 29 | 30 | mfxExtBuffer **ext_buffers; 31 | int nb_ext_buffers; 32 | } AVQSVContext; 33 | 34 | /** 35 | * Allocate a new context. 36 | * 37 | * It must be freed by the caller with av_free(). 38 | */ 39 | AVQSVContext *av_qsv_alloc_context(void); 40 | 41 | #endif /* AVCODEC_QSV_H */ 42 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavcodec/vaapi.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Video Acceleration API (shared data between FFmpeg and the video player) 3 | * HW decode acceleration for MPEG-2, MPEG-4, H.264 and VC-1 4 | * 5 | * Copyright (C) 2008-2009 Splitted-Desktop Systems 6 | * 7 | * This file is part of FFmpeg. 8 | * 9 | * FFmpeg is free software; you can redistribute it and/or 10 | * modify it under the terms of the GNU Lesser General Public 11 | * License as published by the Free Software Foundation; either 12 | * version 2.1 of the License, or (at your option) any later version. 13 | * 14 | * FFmpeg is distributed in the hope that it will be useful, 15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 | * Lesser General Public License for more details. 18 | * 19 | * You should have received a copy of the GNU Lesser General Public 20 | * License along with FFmpeg; if not, write to the Free Software 21 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 22 | */ 23 | 24 | #ifndef AVCODEC_VAAPI_H 25 | #define AVCODEC_VAAPI_H 26 | 27 | /** 28 | * @file 29 | * @ingroup lavc_codec_hwaccel_vaapi 30 | * Public libavcodec VA API header. 31 | */ 32 | 33 | #include 34 | 35 | /** 36 | * @defgroup lavc_codec_hwaccel_vaapi VA API Decoding 37 | * @ingroup lavc_codec_hwaccel 38 | * @{ 39 | */ 40 | 41 | /** 42 | * This structure is used to share data between the FFmpeg library and 43 | * the client video application. 44 | * This shall be zero-allocated and available as 45 | * AVCodecContext.hwaccel_context. All user members can be set once 46 | * during initialization or through each AVCodecContext.get_buffer() 47 | * function call. In any case, they must be valid prior to calling 48 | * decoding functions. 49 | */ 50 | struct vaapi_context { 51 | /** 52 | * Window system dependent data 53 | * 54 | * - encoding: unused 55 | * - decoding: Set by user 56 | */ 57 | void *display; 58 | 59 | /** 60 | * Configuration ID 61 | * 62 | * - encoding: unused 63 | * - decoding: Set by user 64 | */ 65 | uint32_t config_id; 66 | 67 | /** 68 | * Context ID (video decode pipeline) 69 | * 70 | * - encoding: unused 71 | * - decoding: Set by user 72 | */ 73 | uint32_t context_id; 74 | 75 | /** 76 | * VAPictureParameterBuffer ID 77 | * 78 | * - encoding: unused 79 | * - decoding: Set by libavcodec 80 | */ 81 | uint32_t pic_param_buf_id; 82 | 83 | /** 84 | * VAIQMatrixBuffer ID 85 | * 86 | * - encoding: unused 87 | * - decoding: Set by libavcodec 88 | */ 89 | uint32_t iq_matrix_buf_id; 90 | 91 | /** 92 | * VABitPlaneBuffer ID (for VC-1 decoding) 93 | * 94 | * - encoding: unused 95 | * - decoding: Set by libavcodec 96 | */ 97 | uint32_t bitplane_buf_id; 98 | 99 | /** 100 | * Slice parameter/data buffer IDs 101 | * 102 | * - encoding: unused 103 | * - decoding: Set by libavcodec 104 | */ 105 | uint32_t *slice_buf_ids; 106 | 107 | /** 108 | * Number of effective slice buffer IDs to send to the HW 109 | * 110 | * - encoding: unused 111 | * - decoding: Set by libavcodec 112 | */ 113 | unsigned int n_slice_buf_ids; 114 | 115 | /** 116 | * Size of pre-allocated slice_buf_ids 117 | * 118 | * - encoding: unused 119 | * - decoding: Set by libavcodec 120 | */ 121 | unsigned int slice_buf_ids_alloc; 122 | 123 | /** 124 | * Pointer to VASliceParameterBuffers 125 | * 126 | * - encoding: unused 127 | * - decoding: Set by libavcodec 128 | */ 129 | void *slice_params; 130 | 131 | /** 132 | * Size of a VASliceParameterBuffer element 133 | * 134 | * - encoding: unused 135 | * - decoding: Set by libavcodec 136 | */ 137 | unsigned int slice_param_size; 138 | 139 | /** 140 | * Size of pre-allocated slice_params 141 | * 142 | * - encoding: unused 143 | * - decoding: Set by libavcodec 144 | */ 145 | unsigned int slice_params_alloc; 146 | 147 | /** 148 | * Number of slices currently filled in 149 | * 150 | * - encoding: unused 151 | * - decoding: Set by libavcodec 152 | */ 153 | unsigned int slice_count; 154 | 155 | /** 156 | * Pointer to slice data buffer base 157 | * - encoding: unused 158 | * - decoding: Set by libavcodec 159 | */ 160 | const uint8_t *slice_data; 161 | 162 | /** 163 | * Current size of slice data 164 | * 165 | * - encoding: unused 166 | * - decoding: Set by libavcodec 167 | */ 168 | uint32_t slice_data_size; 169 | }; 170 | 171 | /* @} */ 172 | 173 | #endif /* AVCODEC_VAAPI_H */ 174 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavcodec/vorbis_parser.h: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * This file is part of FFmpeg. 4 | * 5 | * FFmpeg is free software; you can redistribute it and/or 6 | * modify it under the terms of the GNU Lesser General Public 7 | * License as published by the Free Software Foundation; either 8 | * version 2.1 of the License, or (at your option) any later version. 9 | * 10 | * FFmpeg is distributed in the hope that it will be useful, 11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 | * Lesser General Public License for more details. 14 | * 15 | * You should have received a copy of the GNU Lesser General Public 16 | * License along with FFmpeg; if not, write to the Free Software 17 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 18 | */ 19 | 20 | /** 21 | * @file 22 | * A public API for Vorbis parsing 23 | * 24 | * Determines the duration for each packet. 25 | */ 26 | 27 | #ifndef AVCODEC_VORBIS_PARSE_H 28 | #define AVCODEC_VORBIS_PARSE_H 29 | 30 | #include 31 | 32 | typedef struct AVVorbisParseContext AVVorbisParseContext; 33 | 34 | /** 35 | * Allocate and initialize the Vorbis parser using headers in the extradata. 36 | * 37 | * @param avctx codec context 38 | * @param s Vorbis parser context 39 | */ 40 | AVVorbisParseContext *av_vorbis_parse_init(const uint8_t *extradata, 41 | int extradata_size); 42 | 43 | /** 44 | * Free the parser and everything associated with it. 45 | */ 46 | void av_vorbis_parse_free(AVVorbisParseContext **s); 47 | 48 | #define VORBIS_FLAG_HEADER 0x00000001 49 | #define VORBIS_FLAG_COMMENT 0x00000002 50 | #define VORBIS_FLAG_SETUP 0x00000004 51 | 52 | /** 53 | * Get the duration for a Vorbis packet. 54 | * 55 | * If @p flags is @c NULL, 56 | * special frames are considered invalid. 57 | * 58 | * @param s Vorbis parser context 59 | * @param buf buffer containing a Vorbis frame 60 | * @param buf_size size of the buffer 61 | * @param flags flags for special frames 62 | */ 63 | int av_vorbis_parse_frame_flags(AVVorbisParseContext *s, const uint8_t *buf, 64 | int buf_size, int *flags); 65 | 66 | /** 67 | * Get the duration for a Vorbis packet. 68 | * 69 | * @param s Vorbis parser context 70 | * @param buf buffer containing a Vorbis frame 71 | * @param buf_size size of the buffer 72 | */ 73 | int av_vorbis_parse_frame(AVVorbisParseContext *s, const uint8_t *buf, 74 | int buf_size); 75 | 76 | void av_vorbis_parse_reset(AVVorbisParseContext *s); 77 | 78 | #endif /* AVCODEC_VORBIS_PARSE_H */ 79 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavdevice/version.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of FFmpeg. 3 | * 4 | * FFmpeg is free software; you can redistribute it and/or 5 | * modify it under the terms of the GNU Lesser General Public 6 | * License as published by the Free Software Foundation; either 7 | * version 2.1 of the License, or (at your option) any later version. 8 | * 9 | * FFmpeg is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | * Lesser General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU Lesser General Public 15 | * License along with FFmpeg; if not, write to the Free Software 16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 17 | */ 18 | 19 | #ifndef AVDEVICE_VERSION_H 20 | #define AVDEVICE_VERSION_H 21 | 22 | /** 23 | * @file 24 | * @ingroup lavd 25 | * Libavdevice version macros 26 | */ 27 | 28 | #include "libavutil/version.h" 29 | 30 | #define LIBAVDEVICE_VERSION_MAJOR 56 31 | #define LIBAVDEVICE_VERSION_MINOR 4 32 | #define LIBAVDEVICE_VERSION_MICRO 100 33 | 34 | #define LIBAVDEVICE_VERSION_INT AV_VERSION_INT(LIBAVDEVICE_VERSION_MAJOR, \ 35 | LIBAVDEVICE_VERSION_MINOR, \ 36 | LIBAVDEVICE_VERSION_MICRO) 37 | #define LIBAVDEVICE_VERSION AV_VERSION(LIBAVDEVICE_VERSION_MAJOR, \ 38 | LIBAVDEVICE_VERSION_MINOR, \ 39 | LIBAVDEVICE_VERSION_MICRO) 40 | #define LIBAVDEVICE_BUILD LIBAVDEVICE_VERSION_INT 41 | 42 | #define LIBAVDEVICE_IDENT "Lavd" AV_STRINGIFY(LIBAVDEVICE_VERSION) 43 | 44 | /** 45 | * FF_API_* defines may be placed below to indicate public API that will be 46 | * dropped at a future version bump. The defines themselves are not part of 47 | * the public API and may change, break or disappear at any time. 48 | */ 49 | 50 | #endif /* AVDEVICE_VERSION_H */ 51 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavfilter/asrc_abuffer.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of FFmpeg. 3 | * 4 | * FFmpeg is free software; you can redistribute it and/or 5 | * modify it under the terms of the GNU Lesser General Public 6 | * License as published by the Free Software Foundation; either 7 | * version 2.1 of the License, or (at your option) any later version. 8 | * 9 | * FFmpeg is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | * Lesser General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU Lesser General Public 15 | * License along with FFmpeg; if not, write to the Free Software 16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 17 | */ 18 | 19 | #ifndef AVFILTER_ASRC_ABUFFER_H 20 | #define AVFILTER_ASRC_ABUFFER_H 21 | 22 | #include "avfilter.h" 23 | 24 | /** 25 | * @file 26 | * memory buffer source for audio 27 | * 28 | * @deprecated use buffersrc.h instead. 29 | */ 30 | 31 | /** 32 | * Queue an audio buffer to the audio buffer source. 33 | * 34 | * @param abuffersrc audio source buffer context 35 | * @param data pointers to the samples planes 36 | * @param linesize linesizes of each audio buffer plane 37 | * @param nb_samples number of samples per channel 38 | * @param sample_fmt sample format of the audio data 39 | * @param ch_layout channel layout of the audio data 40 | * @param planar flag to indicate if audio data is planar or packed 41 | * @param pts presentation timestamp of the audio buffer 42 | * @param flags unused 43 | * 44 | * @deprecated use av_buffersrc_add_ref() instead. 45 | */ 46 | attribute_deprecated 47 | int av_asrc_buffer_add_samples(AVFilterContext *abuffersrc, 48 | uint8_t *data[8], int linesize[8], 49 | int nb_samples, int sample_rate, 50 | int sample_fmt, int64_t ch_layout, int planar, 51 | int64_t pts, int av_unused flags); 52 | 53 | /** 54 | * Queue an audio buffer to the audio buffer source. 55 | * 56 | * This is similar to av_asrc_buffer_add_samples(), but the samples 57 | * are stored in a buffer with known size. 58 | * 59 | * @param abuffersrc audio source buffer context 60 | * @param buf pointer to the samples data, packed is assumed 61 | * @param size the size in bytes of the buffer, it must contain an 62 | * integer number of samples 63 | * @param sample_fmt sample format of the audio data 64 | * @param ch_layout channel layout of the audio data 65 | * @param pts presentation timestamp of the audio buffer 66 | * @param flags unused 67 | * 68 | * @deprecated use av_buffersrc_add_ref() instead. 69 | */ 70 | attribute_deprecated 71 | int av_asrc_buffer_add_buffer(AVFilterContext *abuffersrc, 72 | uint8_t *buf, int buf_size, 73 | int sample_rate, 74 | int sample_fmt, int64_t ch_layout, int planar, 75 | int64_t pts, int av_unused flags); 76 | 77 | /** 78 | * Queue an audio buffer to the audio buffer source. 79 | * 80 | * @param abuffersrc audio source buffer context 81 | * @param samplesref buffer ref to queue 82 | * @param flags unused 83 | * 84 | * @deprecated use av_buffersrc_add_ref() instead. 85 | */ 86 | attribute_deprecated 87 | int av_asrc_buffer_add_audio_buffer_ref(AVFilterContext *abuffersrc, 88 | AVFilterBufferRef *samplesref, 89 | int av_unused flags); 90 | 91 | #endif /* AVFILTER_ASRC_ABUFFER_H */ 92 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavfilter/avcodec.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of FFmpeg. 3 | * 4 | * FFmpeg is free software; you can redistribute it and/or 5 | * modify it under the terms of the GNU Lesser General Public 6 | * License as published by the Free Software Foundation; either 7 | * version 2.1 of the License, or (at your option) any later version. 8 | * 9 | * FFmpeg is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | * Lesser General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU Lesser General Public 15 | * License along with FFmpeg; if not, write to the Free Software 16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 17 | */ 18 | 19 | #ifndef AVFILTER_AVCODEC_H 20 | #define AVFILTER_AVCODEC_H 21 | 22 | /** 23 | * @file 24 | * libavcodec/libavfilter gluing utilities 25 | * 26 | * This should be included in an application ONLY if the installed 27 | * libavfilter has been compiled with libavcodec support, otherwise 28 | * symbols defined below will not be available. 29 | */ 30 | 31 | #include "avfilter.h" 32 | 33 | #if FF_API_AVFILTERBUFFER 34 | /** 35 | * Create and return a picref reference from the data and properties 36 | * contained in frame. 37 | * 38 | * @param perms permissions to assign to the new buffer reference 39 | * @deprecated avfilter APIs work natively with AVFrame instead. 40 | */ 41 | attribute_deprecated 42 | AVFilterBufferRef *avfilter_get_video_buffer_ref_from_frame(const AVFrame *frame, int perms); 43 | 44 | 45 | /** 46 | * Create and return a picref reference from the data and properties 47 | * contained in frame. 48 | * 49 | * @param perms permissions to assign to the new buffer reference 50 | * @deprecated avfilter APIs work natively with AVFrame instead. 51 | */ 52 | attribute_deprecated 53 | AVFilterBufferRef *avfilter_get_audio_buffer_ref_from_frame(const AVFrame *frame, 54 | int perms); 55 | 56 | /** 57 | * Create and return a buffer reference from the data and properties 58 | * contained in frame. 59 | * 60 | * @param perms permissions to assign to the new buffer reference 61 | * @deprecated avfilter APIs work natively with AVFrame instead. 62 | */ 63 | attribute_deprecated 64 | AVFilterBufferRef *avfilter_get_buffer_ref_from_frame(enum AVMediaType type, 65 | const AVFrame *frame, 66 | int perms); 67 | #endif 68 | 69 | #endif /* AVFILTER_AVCODEC_H */ 70 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavfilter/avfiltergraph.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Filter graphs 3 | * copyright (c) 2007 Bobby Bingham 4 | * 5 | * This file is part of FFmpeg. 6 | * 7 | * FFmpeg is free software; you can redistribute it and/or 8 | * modify it under the terms of the GNU Lesser General Public 9 | * License as published by the Free Software Foundation; either 10 | * version 2.1 of the License, or (at your option) any later version. 11 | * 12 | * FFmpeg is distributed in the hope that it will be useful, 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 | * Lesser General Public License for more details. 16 | * 17 | * You should have received a copy of the GNU Lesser General Public 18 | * License along with FFmpeg; if not, write to the Free Software 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 | */ 21 | 22 | #ifndef AVFILTER_AVFILTERGRAPH_H 23 | #define AVFILTER_AVFILTERGRAPH_H 24 | 25 | #include "avfilter.h" 26 | #include "libavutil/log.h" 27 | 28 | #endif /* AVFILTER_AVFILTERGRAPH_H */ 29 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavfilter/buffersrc.h: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * This file is part of FFmpeg. 4 | * 5 | * FFmpeg is free software; you can redistribute it and/or 6 | * modify it under the terms of the GNU Lesser General Public 7 | * License as published by the Free Software Foundation; either 8 | * version 2.1 of the License, or (at your option) any later version. 9 | * 10 | * FFmpeg is distributed in the hope that it will be useful, 11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 | * Lesser General Public License for more details. 14 | * 15 | * You should have received a copy of the GNU Lesser General Public 16 | * License along with FFmpeg; if not, write to the Free Software 17 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 18 | */ 19 | 20 | #ifndef AVFILTER_BUFFERSRC_H 21 | #define AVFILTER_BUFFERSRC_H 22 | 23 | /** 24 | * @file 25 | * @ingroup lavfi_buffersrc 26 | * Memory buffer source API. 27 | */ 28 | 29 | #include "libavcodec/avcodec.h" 30 | #include "avfilter.h" 31 | 32 | /** 33 | * @defgroup lavfi_buffersrc Buffer source API 34 | * @ingroup lavfi 35 | * @{ 36 | */ 37 | 38 | enum { 39 | 40 | /** 41 | * Do not check for format changes. 42 | */ 43 | AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT = 1, 44 | 45 | #if FF_API_AVFILTERBUFFER 46 | /** 47 | * Ignored 48 | */ 49 | AV_BUFFERSRC_FLAG_NO_COPY = 2, 50 | #endif 51 | 52 | /** 53 | * Immediately push the frame to the output. 54 | */ 55 | AV_BUFFERSRC_FLAG_PUSH = 4, 56 | 57 | /** 58 | * Keep a reference to the frame. 59 | * If the frame if reference-counted, create a new reference; otherwise 60 | * copy the frame data. 61 | */ 62 | AV_BUFFERSRC_FLAG_KEEP_REF = 8, 63 | 64 | }; 65 | 66 | /** 67 | * Add buffer data in picref to buffer_src. 68 | * 69 | * @param buffer_src pointer to a buffer source context 70 | * @param picref a buffer reference, or NULL to mark EOF 71 | * @param flags a combination of AV_BUFFERSRC_FLAG_* 72 | * @return >= 0 in case of success, a negative AVERROR code 73 | * in case of failure 74 | */ 75 | int av_buffersrc_add_ref(AVFilterContext *buffer_src, 76 | AVFilterBufferRef *picref, int flags); 77 | 78 | /** 79 | * Get the number of failed requests. 80 | * 81 | * A failed request is when the request_frame method is called while no 82 | * frame is present in the buffer. 83 | * The number is reset when a frame is added. 84 | */ 85 | unsigned av_buffersrc_get_nb_failed_requests(AVFilterContext *buffer_src); 86 | 87 | #if FF_API_AVFILTERBUFFER 88 | /** 89 | * Add a buffer to a filtergraph. 90 | * 91 | * @param ctx an instance of the buffersrc filter 92 | * @param buf buffer containing frame data to be passed down the filtergraph. 93 | * This function will take ownership of buf, the user must not free it. 94 | * A NULL buf signals EOF -- i.e. no more frames will be sent to this filter. 95 | * 96 | * @deprecated use av_buffersrc_write_frame() or av_buffersrc_add_frame() 97 | */ 98 | attribute_deprecated 99 | int av_buffersrc_buffer(AVFilterContext *ctx, AVFilterBufferRef *buf); 100 | #endif 101 | 102 | /** 103 | * Add a frame to the buffer source. 104 | * 105 | * @param ctx an instance of the buffersrc filter 106 | * @param frame frame to be added. If the frame is reference counted, this 107 | * function will make a new reference to it. Otherwise the frame data will be 108 | * copied. 109 | * 110 | * @return 0 on success, a negative AVERROR on error 111 | * 112 | * This function is equivalent to av_buffersrc_add_frame_flags() with the 113 | * AV_BUFFERSRC_FLAG_KEEP_REF flag. 114 | */ 115 | int av_buffersrc_write_frame(AVFilterContext *ctx, const AVFrame *frame); 116 | 117 | /** 118 | * Add a frame to the buffer source. 119 | * 120 | * @param ctx an instance of the buffersrc filter 121 | * @param frame frame to be added. If the frame is reference counted, this 122 | * function will take ownership of the reference(s) and reset the frame. 123 | * Otherwise the frame data will be copied. If this function returns an error, 124 | * the input frame is not touched. 125 | * 126 | * @return 0 on success, a negative AVERROR on error. 127 | * 128 | * @note the difference between this function and av_buffersrc_write_frame() is 129 | * that av_buffersrc_write_frame() creates a new reference to the input frame, 130 | * while this function takes ownership of the reference passed to it. 131 | * 132 | * This function is equivalent to av_buffersrc_add_frame_flags() without the 133 | * AV_BUFFERSRC_FLAG_KEEP_REF flag. 134 | */ 135 | int av_buffersrc_add_frame(AVFilterContext *ctx, AVFrame *frame); 136 | 137 | /** 138 | * Add a frame to the buffer source. 139 | * 140 | * By default, if the frame is reference-counted, this function will take 141 | * ownership of the reference(s) and reset the frame. This can be controlled 142 | * using the flags. 143 | * 144 | * If this function returns an error, the input frame is not touched. 145 | * 146 | * @param buffer_src pointer to a buffer source context 147 | * @param frame a frame, or NULL to mark EOF 148 | * @param flags a combination of AV_BUFFERSRC_FLAG_* 149 | * @return >= 0 in case of success, a negative AVERROR code 150 | * in case of failure 151 | */ 152 | int av_buffersrc_add_frame_flags(AVFilterContext *buffer_src, 153 | AVFrame *frame, int flags); 154 | 155 | 156 | /** 157 | * @} 158 | */ 159 | 160 | #endif /* AVFILTER_BUFFERSRC_H */ 161 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavfilter/version.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Version macros. 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVFILTER_VERSION_H 22 | #define AVFILTER_VERSION_H 23 | 24 | /** 25 | * @file 26 | * @ingroup lavfi 27 | * Libavfilter version macros 28 | */ 29 | 30 | #include "libavutil/version.h" 31 | 32 | #define LIBAVFILTER_VERSION_MAJOR 5 33 | #define LIBAVFILTER_VERSION_MINOR 11 34 | #define LIBAVFILTER_VERSION_MICRO 102 35 | 36 | #define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \ 37 | LIBAVFILTER_VERSION_MINOR, \ 38 | LIBAVFILTER_VERSION_MICRO) 39 | #define LIBAVFILTER_VERSION AV_VERSION(LIBAVFILTER_VERSION_MAJOR, \ 40 | LIBAVFILTER_VERSION_MINOR, \ 41 | LIBAVFILTER_VERSION_MICRO) 42 | #define LIBAVFILTER_BUILD LIBAVFILTER_VERSION_INT 43 | 44 | #define LIBAVFILTER_IDENT "Lavfi" AV_STRINGIFY(LIBAVFILTER_VERSION) 45 | 46 | /** 47 | * FF_API_* defines may be placed below to indicate public API that will be 48 | * dropped at a future version bump. The defines themselves are not part of 49 | * the public API and may change, break or disappear at any time. 50 | */ 51 | 52 | #ifndef FF_API_AVFILTERPAD_PUBLIC 53 | #define FF_API_AVFILTERPAD_PUBLIC (LIBAVFILTER_VERSION_MAJOR < 6) 54 | #endif 55 | #ifndef FF_API_FOO_COUNT 56 | #define FF_API_FOO_COUNT (LIBAVFILTER_VERSION_MAJOR < 6) 57 | #endif 58 | #ifndef FF_API_AVFILTERBUFFER 59 | #define FF_API_AVFILTERBUFFER (LIBAVFILTER_VERSION_MAJOR < 6) 60 | #endif 61 | #ifndef FF_API_OLD_FILTER_OPTS 62 | #define FF_API_OLD_FILTER_OPTS (LIBAVFILTER_VERSION_MAJOR < 6) 63 | #endif 64 | #ifndef FF_API_AVFILTER_OPEN 65 | #define FF_API_AVFILTER_OPEN (LIBAVFILTER_VERSION_MAJOR < 6) 66 | #endif 67 | #ifndef FF_API_AVFILTER_INIT_FILTER 68 | #define FF_API_AVFILTER_INIT_FILTER (LIBAVFILTER_VERSION_MAJOR < 6) 69 | #endif 70 | #ifndef FF_API_OLD_FILTER_REGISTER 71 | #define FF_API_OLD_FILTER_REGISTER (LIBAVFILTER_VERSION_MAJOR < 6) 72 | #endif 73 | #ifndef FF_API_OLD_GRAPH_PARSE 74 | #define FF_API_OLD_GRAPH_PARSE (LIBAVFILTER_VERSION_MAJOR < 5) 75 | #endif 76 | #ifndef FF_API_NOCONST_GET_NAME 77 | #define FF_API_NOCONST_GET_NAME (LIBAVFILTER_VERSION_MAJOR < 6) 78 | #endif 79 | 80 | #endif /* AVFILTER_VERSION_H */ 81 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavformat/version.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Version macros. 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVFORMAT_VERSION_H 22 | #define AVFORMAT_VERSION_H 23 | 24 | /** 25 | * @file 26 | * @ingroup libavf 27 | * Libavformat version macros 28 | */ 29 | 30 | #include "libavutil/version.h" 31 | 32 | #define LIBAVFORMAT_VERSION_MAJOR 56 33 | #define LIBAVFORMAT_VERSION_MINOR 25 34 | #define LIBAVFORMAT_VERSION_MICRO 101 35 | 36 | #define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \ 37 | LIBAVFORMAT_VERSION_MINOR, \ 38 | LIBAVFORMAT_VERSION_MICRO) 39 | #define LIBAVFORMAT_VERSION AV_VERSION(LIBAVFORMAT_VERSION_MAJOR, \ 40 | LIBAVFORMAT_VERSION_MINOR, \ 41 | LIBAVFORMAT_VERSION_MICRO) 42 | #define LIBAVFORMAT_BUILD LIBAVFORMAT_VERSION_INT 43 | 44 | #define LIBAVFORMAT_IDENT "Lavf" AV_STRINGIFY(LIBAVFORMAT_VERSION) 45 | 46 | /** 47 | * FF_API_* defines may be placed below to indicate public API that will be 48 | * dropped at a future version bump. The defines themselves are not part of 49 | * the public API and may change, break or disappear at any time. 50 | */ 51 | #ifndef FF_API_LAVF_BITEXACT 52 | #define FF_API_LAVF_BITEXACT (LIBAVFORMAT_VERSION_MAJOR < 57) 53 | #endif 54 | #ifndef FF_API_LAVF_FRAC 55 | #define FF_API_LAVF_FRAC (LIBAVFORMAT_VERSION_MAJOR < 57) 56 | #endif 57 | #ifndef FF_API_LAVF_CODEC_TB 58 | #define FF_API_LAVF_CODEC_TB (LIBAVFORMAT_VERSION_MAJOR < 57) 59 | #endif 60 | #ifndef FF_API_URL_FEOF 61 | #define FF_API_URL_FEOF (LIBAVFORMAT_VERSION_MAJOR < 57) 62 | #endif 63 | 64 | #ifndef FF_API_R_FRAME_RATE 65 | #define FF_API_R_FRAME_RATE 1 66 | #endif 67 | #endif /* AVFORMAT_VERSION_H */ 68 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/adler32.h: -------------------------------------------------------------------------------- 1 | /* 2 | * copyright (c) 2006 Mans Rullgard 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_ADLER32_H 22 | #define AVUTIL_ADLER32_H 23 | 24 | #include 25 | #include "attributes.h" 26 | 27 | /** 28 | * @file 29 | * Public header for libavutil Adler32 hasher 30 | * 31 | * @defgroup lavu_adler32 Adler32 32 | * @ingroup lavu_crypto 33 | * @{ 34 | */ 35 | 36 | /** 37 | * Calculate the Adler32 checksum of a buffer. 38 | * 39 | * Passing the return value to a subsequent av_adler32_update() call 40 | * allows the checksum of multiple buffers to be calculated as though 41 | * they were concatenated. 42 | * 43 | * @param adler initial checksum value 44 | * @param buf pointer to input buffer 45 | * @param len size of input buffer 46 | * @return updated checksum 47 | */ 48 | unsigned long av_adler32_update(unsigned long adler, const uint8_t *buf, 49 | unsigned int len) av_pure; 50 | 51 | /** 52 | * @} 53 | */ 54 | 55 | #endif /* AVUTIL_ADLER32_H */ 56 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/aes.h: -------------------------------------------------------------------------------- 1 | /* 2 | * copyright (c) 2007 Michael Niedermayer 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_AES_H 22 | #define AVUTIL_AES_H 23 | 24 | #include 25 | 26 | #include "attributes.h" 27 | #include "version.h" 28 | 29 | /** 30 | * @defgroup lavu_aes AES 31 | * @ingroup lavu_crypto 32 | * @{ 33 | */ 34 | 35 | extern const int av_aes_size; 36 | 37 | struct AVAES; 38 | 39 | /** 40 | * Allocate an AVAES context. 41 | */ 42 | struct AVAES *av_aes_alloc(void); 43 | 44 | /** 45 | * Initialize an AVAES context. 46 | * @param key_bits 128, 192 or 256 47 | * @param decrypt 0 for encryption, 1 for decryption 48 | */ 49 | int av_aes_init(struct AVAES *a, const uint8_t *key, int key_bits, int decrypt); 50 | 51 | /** 52 | * Encrypt or decrypt a buffer using a previously initialized context. 53 | * @param count number of 16 byte blocks 54 | * @param dst destination array, can be equal to src 55 | * @param src source array, can be equal to dst 56 | * @param iv initialization vector for CBC mode, if NULL then ECB will be used 57 | * @param decrypt 0 for encryption, 1 for decryption 58 | */ 59 | void av_aes_crypt(struct AVAES *a, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt); 60 | 61 | /** 62 | * @} 63 | */ 64 | 65 | #endif /* AVUTIL_AES_H */ 66 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/attributes.h: -------------------------------------------------------------------------------- 1 | /* 2 | * copyright (c) 2006 Michael Niedermayer 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | /** 22 | * @file 23 | * Macro definitions for various function/variable attributes 24 | */ 25 | 26 | #ifndef AVUTIL_ATTRIBUTES_H 27 | #define AVUTIL_ATTRIBUTES_H 28 | 29 | #ifdef __GNUC__ 30 | # define AV_GCC_VERSION_AT_LEAST(x,y) (__GNUC__ > (x) || __GNUC__ == (x) && __GNUC_MINOR__ >= (y)) 31 | #else 32 | # define AV_GCC_VERSION_AT_LEAST(x,y) 0 33 | #endif 34 | 35 | #ifndef av_always_inline 36 | #if AV_GCC_VERSION_AT_LEAST(3,1) 37 | # define av_always_inline __attribute__((always_inline)) inline 38 | #elif defined(_MSC_VER) 39 | # define av_always_inline __forceinline 40 | #else 41 | # define av_always_inline inline 42 | #endif 43 | #endif 44 | 45 | #ifndef av_extern_inline 46 | #if defined(__ICL) && __ICL >= 1210 || defined(__GNUC_STDC_INLINE__) 47 | # define av_extern_inline extern inline 48 | #else 49 | # define av_extern_inline inline 50 | #endif 51 | #endif 52 | 53 | #if AV_GCC_VERSION_AT_LEAST(3,1) 54 | # define av_noinline __attribute__((noinline)) 55 | #elif defined(_MSC_VER) 56 | # define av_noinline __declspec(noinline) 57 | #else 58 | # define av_noinline 59 | #endif 60 | 61 | #if AV_GCC_VERSION_AT_LEAST(3,1) 62 | # define av_pure __attribute__((pure)) 63 | #else 64 | # define av_pure 65 | #endif 66 | 67 | #if AV_GCC_VERSION_AT_LEAST(2,6) 68 | # define av_const __attribute__((const)) 69 | #else 70 | # define av_const 71 | #endif 72 | 73 | #if AV_GCC_VERSION_AT_LEAST(4,3) 74 | # define av_cold __attribute__((cold)) 75 | #else 76 | # define av_cold 77 | #endif 78 | 79 | #if AV_GCC_VERSION_AT_LEAST(4,1) && !defined(__llvm__) 80 | # define av_flatten __attribute__((flatten)) 81 | #else 82 | # define av_flatten 83 | #endif 84 | 85 | #if AV_GCC_VERSION_AT_LEAST(3,1) 86 | # define attribute_deprecated __attribute__((deprecated)) 87 | #elif defined(_MSC_VER) 88 | # define attribute_deprecated __declspec(deprecated) 89 | #else 90 | # define attribute_deprecated 91 | #endif 92 | 93 | /** 94 | * Disable warnings about deprecated features 95 | * This is useful for sections of code kept for backward compatibility and 96 | * scheduled for removal. 97 | */ 98 | #ifndef AV_NOWARN_DEPRECATED 99 | #if AV_GCC_VERSION_AT_LEAST(4,6) 100 | # define AV_NOWARN_DEPRECATED(code) \ 101 | _Pragma("GCC diagnostic push") \ 102 | _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") \ 103 | code \ 104 | _Pragma("GCC diagnostic pop") 105 | #elif defined(_MSC_VER) 106 | # define AV_NOWARN_DEPRECATED(code) \ 107 | __pragma(warning(push)) \ 108 | __pragma(warning(disable : 4996)) \ 109 | code; \ 110 | __pragma(warning(pop)) 111 | #else 112 | # define AV_NOWARN_DEPRECATED(code) code 113 | #endif 114 | #endif 115 | 116 | 117 | #if defined(__GNUC__) 118 | # define av_unused __attribute__((unused)) 119 | #else 120 | # define av_unused 121 | #endif 122 | 123 | /** 124 | * Mark a variable as used and prevent the compiler from optimizing it 125 | * away. This is useful for variables accessed only from inline 126 | * assembler without the compiler being aware. 127 | */ 128 | #if AV_GCC_VERSION_AT_LEAST(3,1) 129 | # define av_used __attribute__((used)) 130 | #else 131 | # define av_used 132 | #endif 133 | 134 | #if AV_GCC_VERSION_AT_LEAST(3,3) 135 | # define av_alias __attribute__((may_alias)) 136 | #else 137 | # define av_alias 138 | #endif 139 | 140 | #if defined(__GNUC__) && !defined(__INTEL_COMPILER) && !defined(__clang__) 141 | # define av_uninit(x) x=x 142 | #else 143 | # define av_uninit(x) x 144 | #endif 145 | 146 | #ifdef __GNUC__ 147 | # define av_builtin_constant_p __builtin_constant_p 148 | # define av_printf_format(fmtpos, attrpos) __attribute__((__format__(__printf__, fmtpos, attrpos))) 149 | #else 150 | # define av_builtin_constant_p(x) 0 151 | # define av_printf_format(fmtpos, attrpos) 152 | #endif 153 | 154 | #if AV_GCC_VERSION_AT_LEAST(2,5) 155 | # define av_noreturn __attribute__((noreturn)) 156 | #else 157 | # define av_noreturn 158 | #endif 159 | 160 | #endif /* AVUTIL_ATTRIBUTES_H */ 161 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/audio_fifo.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Audio FIFO 3 | * Copyright (c) 2012 Justin Ruggles 4 | * 5 | * This file is part of FFmpeg. 6 | * 7 | * FFmpeg is free software; you can redistribute it and/or 8 | * modify it under the terms of the GNU Lesser General Public 9 | * License as published by the Free Software Foundation; either 10 | * version 2.1 of the License, or (at your option) any later version. 11 | * 12 | * FFmpeg is distributed in the hope that it will be useful, 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 | * Lesser General Public License for more details. 16 | * 17 | * You should have received a copy of the GNU Lesser General Public 18 | * License along with FFmpeg; if not, write to the Free Software 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 | */ 21 | 22 | /** 23 | * @file 24 | * Audio FIFO Buffer 25 | */ 26 | 27 | #ifndef AVUTIL_AUDIO_FIFO_H 28 | #define AVUTIL_AUDIO_FIFO_H 29 | 30 | #include "avutil.h" 31 | #include "fifo.h" 32 | #include "samplefmt.h" 33 | 34 | /** 35 | * @addtogroup lavu_audio 36 | * @{ 37 | * 38 | * @defgroup lavu_audiofifo Audio FIFO Buffer 39 | * @{ 40 | */ 41 | 42 | /** 43 | * Context for an Audio FIFO Buffer. 44 | * 45 | * - Operates at the sample level rather than the byte level. 46 | * - Supports multiple channels with either planar or packed sample format. 47 | * - Automatic reallocation when writing to a full buffer. 48 | */ 49 | typedef struct AVAudioFifo AVAudioFifo; 50 | 51 | /** 52 | * Free an AVAudioFifo. 53 | * 54 | * @param af AVAudioFifo to free 55 | */ 56 | void av_audio_fifo_free(AVAudioFifo *af); 57 | 58 | /** 59 | * Allocate an AVAudioFifo. 60 | * 61 | * @param sample_fmt sample format 62 | * @param channels number of channels 63 | * @param nb_samples initial allocation size, in samples 64 | * @return newly allocated AVAudioFifo, or NULL on error 65 | */ 66 | AVAudioFifo *av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels, 67 | int nb_samples); 68 | 69 | /** 70 | * Reallocate an AVAudioFifo. 71 | * 72 | * @param af AVAudioFifo to reallocate 73 | * @param nb_samples new allocation size, in samples 74 | * @return 0 if OK, or negative AVERROR code on failure 75 | */ 76 | int av_audio_fifo_realloc(AVAudioFifo *af, int nb_samples); 77 | 78 | /** 79 | * Write data to an AVAudioFifo. 80 | * 81 | * The AVAudioFifo will be reallocated automatically if the available space 82 | * is less than nb_samples. 83 | * 84 | * @see enum AVSampleFormat 85 | * The documentation for AVSampleFormat describes the data layout. 86 | * 87 | * @param af AVAudioFifo to write to 88 | * @param data audio data plane pointers 89 | * @param nb_samples number of samples to write 90 | * @return number of samples actually written, or negative AVERROR 91 | * code on failure. If successful, the number of samples 92 | * actually written will always be nb_samples. 93 | */ 94 | int av_audio_fifo_write(AVAudioFifo *af, void **data, int nb_samples); 95 | 96 | /** 97 | * Read data from an AVAudioFifo. 98 | * 99 | * @see enum AVSampleFormat 100 | * The documentation for AVSampleFormat describes the data layout. 101 | * 102 | * @param af AVAudioFifo to read from 103 | * @param data audio data plane pointers 104 | * @param nb_samples number of samples to read 105 | * @return number of samples actually read, or negative AVERROR code 106 | * on failure. The number of samples actually read will not 107 | * be greater than nb_samples, and will only be less than 108 | * nb_samples if av_audio_fifo_size is less than nb_samples. 109 | */ 110 | int av_audio_fifo_read(AVAudioFifo *af, void **data, int nb_samples); 111 | 112 | /** 113 | * Drain data from an AVAudioFifo. 114 | * 115 | * Removes the data without reading it. 116 | * 117 | * @param af AVAudioFifo to drain 118 | * @param nb_samples number of samples to drain 119 | * @return 0 if OK, or negative AVERROR code on failure 120 | */ 121 | int av_audio_fifo_drain(AVAudioFifo *af, int nb_samples); 122 | 123 | /** 124 | * Reset the AVAudioFifo buffer. 125 | * 126 | * This empties all data in the buffer. 127 | * 128 | * @param af AVAudioFifo to reset 129 | */ 130 | void av_audio_fifo_reset(AVAudioFifo *af); 131 | 132 | /** 133 | * Get the current number of samples in the AVAudioFifo available for reading. 134 | * 135 | * @param af the AVAudioFifo to query 136 | * @return number of samples available for reading 137 | */ 138 | int av_audio_fifo_size(AVAudioFifo *af); 139 | 140 | /** 141 | * Get the current number of samples in the AVAudioFifo available for writing. 142 | * 143 | * @param af the AVAudioFifo to query 144 | * @return number of samples available for writing 145 | */ 146 | int av_audio_fifo_space(AVAudioFifo *af); 147 | 148 | /** 149 | * @} 150 | * @} 151 | */ 152 | 153 | #endif /* AVUTIL_AUDIO_FIFO_H */ 154 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/audioconvert.h: -------------------------------------------------------------------------------- 1 | 2 | #include "version.h" 3 | 4 | #if FF_API_AUDIOCONVERT 5 | #include "channel_layout.h" 6 | #endif 7 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/avassert.h: -------------------------------------------------------------------------------- 1 | /* 2 | * copyright (c) 2010 Michael Niedermayer 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | /** 22 | * @file 23 | * simple assert() macros that are a bit more flexible than ISO C assert(). 24 | * @author Michael Niedermayer 25 | */ 26 | 27 | #ifndef AVUTIL_AVASSERT_H 28 | #define AVUTIL_AVASSERT_H 29 | 30 | #include 31 | #include "avutil.h" 32 | #include "log.h" 33 | 34 | /** 35 | * assert() equivalent, that is always enabled. 36 | */ 37 | #define av_assert0(cond) do { \ 38 | if (!(cond)) { \ 39 | av_log(NULL, AV_LOG_PANIC, "Assertion %s failed at %s:%d\n", \ 40 | AV_STRINGIFY(cond), __FILE__, __LINE__); \ 41 | abort(); \ 42 | } \ 43 | } while (0) 44 | 45 | 46 | /** 47 | * assert() equivalent, that does not lie in speed critical code. 48 | * These asserts() thus can be enabled without fearing speedloss. 49 | */ 50 | #if defined(ASSERT_LEVEL) && ASSERT_LEVEL > 0 51 | #define av_assert1(cond) av_assert0(cond) 52 | #else 53 | #define av_assert1(cond) ((void)0) 54 | #endif 55 | 56 | 57 | /** 58 | * assert() equivalent, that does lie in speed critical code. 59 | */ 60 | #if defined(ASSERT_LEVEL) && ASSERT_LEVEL > 1 61 | #define av_assert2(cond) av_assert0(cond) 62 | #else 63 | #define av_assert2(cond) ((void)0) 64 | #endif 65 | 66 | #endif /* AVUTIL_AVASSERT_H */ 67 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/avconfig.h: -------------------------------------------------------------------------------- 1 | /* Generated by ffconf */ 2 | #ifndef AVUTIL_AVCONFIG_H 3 | #define AVUTIL_AVCONFIG_H 4 | #define AV_HAVE_BIGENDIAN 0 5 | #define AV_HAVE_FAST_UNALIGNED 0 6 | #define AV_HAVE_INCOMPATIBLE_LIBAV_ABI 0 7 | #endif /* AVUTIL_AVCONFIG_H */ 8 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/base64.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2006 Ryan Martell. (rdm4@martellventures.com) 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_BASE64_H 22 | #define AVUTIL_BASE64_H 23 | 24 | #include 25 | 26 | /** 27 | * @defgroup lavu_base64 Base64 28 | * @ingroup lavu_crypto 29 | * @{ 30 | */ 31 | 32 | 33 | /** 34 | * Decode a base64-encoded string. 35 | * 36 | * @param out buffer for decoded data 37 | * @param in null-terminated input string 38 | * @param out_size size in bytes of the out buffer, must be at 39 | * least 3/4 of the length of in 40 | * @return number of bytes written, or a negative value in case of 41 | * invalid input 42 | */ 43 | int av_base64_decode(uint8_t *out, const char *in, int out_size); 44 | 45 | /** 46 | * Encode data to base64 and null-terminate. 47 | * 48 | * @param out buffer for encoded data 49 | * @param out_size size in bytes of the out buffer (including the 50 | * null terminator), must be at least AV_BASE64_SIZE(in_size) 51 | * @param in input buffer containing the data to encode 52 | * @param in_size size in bytes of the in buffer 53 | * @return out or NULL in case of error 54 | */ 55 | char *av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size); 56 | 57 | /** 58 | * Calculate the output size needed to base64-encode x bytes to a 59 | * null-terminated string. 60 | */ 61 | #define AV_BASE64_SIZE(x) (((x)+2) / 3 * 4 + 1) 62 | 63 | /** 64 | * @} 65 | */ 66 | 67 | #endif /* AVUTIL_BASE64_H */ 68 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/blowfish.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Blowfish algorithm 3 | * Copyright (c) 2012 Samuel Pitoiset 4 | * 5 | * This file is part of FFmpeg. 6 | * 7 | * FFmpeg is free software; you can redistribute it and/or 8 | * modify it under the terms of the GNU Lesser General Public 9 | * License as published by the Free Software Foundation; either 10 | * version 2.1 of the License, or (at your option) any later version. 11 | * 12 | * FFmpeg is distributed in the hope that it will be useful, 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 | * Lesser General Public License for more details. 16 | * 17 | * You should have received a copy of the GNU Lesser General Public 18 | * License along with FFmpeg; if not, write to the Free Software 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 | */ 21 | 22 | #ifndef AVUTIL_BLOWFISH_H 23 | #define AVUTIL_BLOWFISH_H 24 | 25 | #include 26 | 27 | /** 28 | * @defgroup lavu_blowfish Blowfish 29 | * @ingroup lavu_crypto 30 | * @{ 31 | */ 32 | 33 | #define AV_BF_ROUNDS 16 34 | 35 | typedef struct AVBlowfish { 36 | uint32_t p[AV_BF_ROUNDS + 2]; 37 | uint32_t s[4][256]; 38 | } AVBlowfish; 39 | 40 | /** 41 | * Initialize an AVBlowfish context. 42 | * 43 | * @param ctx an AVBlowfish context 44 | * @param key a key 45 | * @param key_len length of the key 46 | */ 47 | void av_blowfish_init(struct AVBlowfish *ctx, const uint8_t *key, int key_len); 48 | 49 | /** 50 | * Encrypt or decrypt a buffer using a previously initialized context. 51 | * 52 | * @param ctx an AVBlowfish context 53 | * @param xl left four bytes halves of input to be encrypted 54 | * @param xr right four bytes halves of input to be encrypted 55 | * @param decrypt 0 for encryption, 1 for decryption 56 | */ 57 | void av_blowfish_crypt_ecb(struct AVBlowfish *ctx, uint32_t *xl, uint32_t *xr, 58 | int decrypt); 59 | 60 | /** 61 | * Encrypt or decrypt a buffer using a previously initialized context. 62 | * 63 | * @param ctx an AVBlowfish context 64 | * @param dst destination array, can be equal to src 65 | * @param src source array, can be equal to dst 66 | * @param count number of 8 byte blocks 67 | * @param iv initialization vector for CBC mode, if NULL ECB will be used 68 | * @param decrypt 0 for encryption, 1 for decryption 69 | */ 70 | void av_blowfish_crypt(struct AVBlowfish *ctx, uint8_t *dst, const uint8_t *src, 71 | int count, uint8_t *iv, int decrypt); 72 | 73 | /** 74 | * @} 75 | */ 76 | 77 | #endif /* AVUTIL_BLOWFISH_H */ 78 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/bswap.h: -------------------------------------------------------------------------------- 1 | /* 2 | * copyright (c) 2006 Michael Niedermayer 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | /** 22 | * @file 23 | * byte swapping routines 24 | */ 25 | 26 | #ifndef AVUTIL_BSWAP_H 27 | #define AVUTIL_BSWAP_H 28 | 29 | #include 30 | #include "libavutil/avconfig.h" 31 | #include "attributes.h" 32 | 33 | #ifdef HAVE_AV_CONFIG_H 34 | 35 | #include "config.h" 36 | 37 | #if ARCH_AARCH64 38 | # include "aarch64/bswap.h" 39 | #elif ARCH_ARM 40 | # include "arm/bswap.h" 41 | #elif ARCH_AVR32 42 | # include "avr32/bswap.h" 43 | #elif ARCH_SH4 44 | # include "sh4/bswap.h" 45 | #elif ARCH_X86 46 | # include "x86/bswap.h" 47 | #endif 48 | 49 | #endif /* HAVE_AV_CONFIG_H */ 50 | 51 | #define AV_BSWAP16C(x) (((x) << 8 & 0xff00) | ((x) >> 8 & 0x00ff)) 52 | #define AV_BSWAP32C(x) (AV_BSWAP16C(x) << 16 | AV_BSWAP16C((x) >> 16)) 53 | #define AV_BSWAP64C(x) (AV_BSWAP32C(x) << 32 | AV_BSWAP32C((x) >> 32)) 54 | 55 | #define AV_BSWAPC(s, x) AV_BSWAP##s##C(x) 56 | 57 | #ifndef av_bswap16 58 | static av_always_inline av_const uint16_t av_bswap16(uint16_t x) 59 | { 60 | x= (x>>8) | (x<<8); 61 | return x; 62 | } 63 | #endif 64 | 65 | #ifndef av_bswap32 66 | static av_always_inline av_const uint32_t av_bswap32(uint32_t x) 67 | { 68 | return AV_BSWAP32C(x); 69 | } 70 | #endif 71 | 72 | #ifndef av_bswap64 73 | static inline uint64_t av_const av_bswap64(uint64_t x) 74 | { 75 | return (uint64_t)av_bswap32(x) << 32 | av_bswap32(x >> 32); 76 | } 77 | #endif 78 | 79 | // be2ne ... big-endian to native-endian 80 | // le2ne ... little-endian to native-endian 81 | 82 | #if AV_HAVE_BIGENDIAN 83 | #define av_be2ne16(x) (x) 84 | #define av_be2ne32(x) (x) 85 | #define av_be2ne64(x) (x) 86 | #define av_le2ne16(x) av_bswap16(x) 87 | #define av_le2ne32(x) av_bswap32(x) 88 | #define av_le2ne64(x) av_bswap64(x) 89 | #define AV_BE2NEC(s, x) (x) 90 | #define AV_LE2NEC(s, x) AV_BSWAPC(s, x) 91 | #else 92 | #define av_be2ne16(x) av_bswap16(x) 93 | #define av_be2ne32(x) av_bswap32(x) 94 | #define av_be2ne64(x) av_bswap64(x) 95 | #define av_le2ne16(x) (x) 96 | #define av_le2ne32(x) (x) 97 | #define av_le2ne64(x) (x) 98 | #define AV_BE2NEC(s, x) AV_BSWAPC(s, x) 99 | #define AV_LE2NEC(s, x) (x) 100 | #endif 101 | 102 | #define AV_BE2NE16C(x) AV_BE2NEC(16, x) 103 | #define AV_BE2NE32C(x) AV_BE2NEC(32, x) 104 | #define AV_BE2NE64C(x) AV_BE2NEC(64, x) 105 | #define AV_LE2NE16C(x) AV_LE2NEC(16, x) 106 | #define AV_LE2NE32C(x) AV_LE2NEC(32, x) 107 | #define AV_LE2NE64C(x) AV_LE2NEC(64, x) 108 | 109 | #endif /* AVUTIL_BSWAP_H */ 110 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/camellia.h: -------------------------------------------------------------------------------- 1 | /* 2 | * An implementation of the CAMELLIA algorithm as mentioned in RFC3713 3 | * Copyright (c) 2014 Supraja Meedinti 4 | * 5 | * This file is part of FFmpeg. 6 | * 7 | * FFmpeg is free software; you can redistribute it and/or 8 | * modify it under the terms of the GNU Lesser General Public 9 | * License as published by the Free Software Foundation; either 10 | * version 2.1 of the License, or (at your option) any later version. 11 | * 12 | * FFmpeg is distributed in the hope that it will be useful, 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 | * Lesser General Public License for more details. 16 | * 17 | * You should have received a copy of the GNU Lesser General Public 18 | * License along with FFmpeg; if not, write to the Free Software 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 | */ 21 | 22 | #ifndef AVUTIL_CAMELLIA_H 23 | #define AVUTIL_CAMELLIA_H 24 | 25 | #include 26 | 27 | 28 | /** 29 | * @file 30 | * @brief Public header for libavutil CAMELLIA algorithm 31 | * @defgroup lavu_camellia CAMELLIA 32 | * @ingroup lavu_crypto 33 | * @{ 34 | */ 35 | 36 | extern const int av_camellia_size; 37 | 38 | struct AVCAMELLIA; 39 | 40 | /** 41 | * Allocate an AVCAMELLIA context 42 | * To free the struct: av_free(ptr) 43 | */ 44 | struct AVCAMELLIA *av_camellia_alloc(void); 45 | 46 | /** 47 | * Initialize an AVCAMELLIA context. 48 | * 49 | * @param ctx an AVCAMELLIA context 50 | * @param key a key of 16, 24, 32 bytes used for encryption/decryption 51 | * @param key_bits number of keybits: possible are 128, 192, 256 52 | */ 53 | int av_camellia_init(struct AVCAMELLIA *ctx, const uint8_t *key, int key_bits); 54 | 55 | /** 56 | * Encrypt or decrypt a buffer using a previously initialized context 57 | * 58 | * @param ctx an AVCAMELLIA context 59 | * @param dst destination array, can be equal to src 60 | * @param src source array, can be equal to dst 61 | * @param count number of 16 byte blocks 62 | * @paran iv initialization vector for CBC mode, NULL for ECB mode 63 | * @param decrypt 0 for encryption, 1 for decryption 64 | */ 65 | void av_camellia_crypt(struct AVCAMELLIA *ctx, uint8_t *dst, const uint8_t *src, int count, uint8_t* iv, int decrypt); 66 | 67 | /** 68 | * @} 69 | */ 70 | #endif /* AVUTIL_CAMELLIA_H */ 71 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/cast5.h: -------------------------------------------------------------------------------- 1 | /* 2 | * An implementation of the CAST128 algorithm as mentioned in RFC2144 3 | * Copyright (c) 2014 Supraja Meedinti 4 | * 5 | * This file is part of FFmpeg. 6 | * 7 | * FFmpeg is free software; you can redistribute it and/or 8 | * modify it under the terms of the GNU Lesser General Public 9 | * License as published by the Free Software Foundation; either 10 | * version 2.1 of the License, or (at your option) any later version. 11 | * 12 | * FFmpeg is distributed in the hope that it will be useful, 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 | * Lesser General Public License for more details. 16 | * 17 | * You should have received a copy of the GNU Lesser General Public 18 | * License along with FFmpeg; if not, write to the Free Software 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 | */ 21 | 22 | #ifndef AVUTIL_CAST5_H 23 | #define AVUTIL_CAST5_H 24 | 25 | #include 26 | 27 | 28 | /** 29 | * @file 30 | * @brief Public header for libavutil CAST5 algorithm 31 | * @defgroup lavu_cast5 CAST5 32 | * @ingroup lavu_crypto 33 | * @{ 34 | */ 35 | 36 | extern const int av_cast5_size; 37 | 38 | struct AVCAST5; 39 | 40 | /** 41 | * Allocate an AVCAST5 context 42 | * To free the struct: av_free(ptr) 43 | */ 44 | struct AVCAST5 *av_cast5_alloc(void); 45 | /** 46 | * Initialize an AVCAST5 context. 47 | * 48 | * @param ctx an AVCAST5 context 49 | * @param key a key of 5,6,...16 bytes used for encryption/decryption 50 | * @param key_bits number of keybits: possible are 40,48,...,128 51 | */ 52 | int av_cast5_init(struct AVCAST5 *ctx, const uint8_t *key, int key_bits); 53 | 54 | /** 55 | * Encrypt or decrypt a buffer using a previously initialized context, ECB mode only 56 | * 57 | * @param ctx an AVCAST5 context 58 | * @param dst destination array, can be equal to src 59 | * @param src source array, can be equal to dst 60 | * @param count number of 8 byte blocks 61 | * @param decrypt 0 for encryption, 1 for decryption 62 | */ 63 | void av_cast5_crypt(struct AVCAST5 *ctx, uint8_t *dst, const uint8_t *src, int count, int decrypt); 64 | 65 | /** 66 | * Encrypt or decrypt a buffer using a previously initialized context 67 | * 68 | * @param ctx an AVCAST5 context 69 | * @param dst destination array, can be equal to src 70 | * @param src source array, can be equal to dst 71 | * @param count number of 8 byte blocks 72 | * @param iv initialization vector for CBC mode, NULL for ECB mode 73 | * @param decrypt 0 for encryption, 1 for decryption 74 | */ 75 | void av_cast5_crypt2(struct AVCAST5 *ctx, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt); 76 | /** 77 | * @} 78 | */ 79 | #endif /* AVUTIL_CAST5_H */ 80 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/cpu.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2000, 2001, 2002 Fabrice Bellard 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_CPU_H 22 | #define AVUTIL_CPU_H 23 | 24 | #include "attributes.h" 25 | 26 | #define AV_CPU_FLAG_FORCE 0x80000000 /* force usage of selected flags (OR) */ 27 | 28 | /* lower 16 bits - CPU features */ 29 | #define AV_CPU_FLAG_MMX 0x0001 ///< standard MMX 30 | #define AV_CPU_FLAG_MMXEXT 0x0002 ///< SSE integer functions or AMD MMX ext 31 | #define AV_CPU_FLAG_MMX2 0x0002 ///< SSE integer functions or AMD MMX ext 32 | #define AV_CPU_FLAG_3DNOW 0x0004 ///< AMD 3DNOW 33 | #define AV_CPU_FLAG_SSE 0x0008 ///< SSE functions 34 | #define AV_CPU_FLAG_SSE2 0x0010 ///< PIV SSE2 functions 35 | #define AV_CPU_FLAG_SSE2SLOW 0x40000000 ///< SSE2 supported, but usually not faster 36 | ///< than regular MMX/SSE (e.g. Core1) 37 | #define AV_CPU_FLAG_3DNOWEXT 0x0020 ///< AMD 3DNowExt 38 | #define AV_CPU_FLAG_SSE3 0x0040 ///< Prescott SSE3 functions 39 | #define AV_CPU_FLAG_SSE3SLOW 0x20000000 ///< SSE3 supported, but usually not faster 40 | ///< than regular MMX/SSE (e.g. Core1) 41 | #define AV_CPU_FLAG_SSSE3 0x0080 ///< Conroe SSSE3 functions 42 | #define AV_CPU_FLAG_ATOM 0x10000000 ///< Atom processor, some SSSE3 instructions are slower 43 | #define AV_CPU_FLAG_SSE4 0x0100 ///< Penryn SSE4.1 functions 44 | #define AV_CPU_FLAG_SSE42 0x0200 ///< Nehalem SSE4.2 functions 45 | #define AV_CPU_FLAG_AVX 0x4000 ///< AVX functions: requires OS support even if YMM registers aren't used 46 | #define AV_CPU_FLAG_XOP 0x0400 ///< Bulldozer XOP functions 47 | #define AV_CPU_FLAG_FMA4 0x0800 ///< Bulldozer FMA4 functions 48 | // #if LIBAVUTIL_VERSION_MAJOR <52 49 | #define AV_CPU_FLAG_CMOV 0x1001000 ///< supports cmov instruction 50 | // #else 51 | // #define AV_CPU_FLAG_CMOV 0x1000 ///< supports cmov instruction 52 | // #endif 53 | #define AV_CPU_FLAG_AVX2 0x8000 ///< AVX2 functions: requires OS support even if YMM registers aren't used 54 | #define AV_CPU_FLAG_FMA3 0x10000 ///< Haswell FMA3 functions 55 | #define AV_CPU_FLAG_BMI1 0x20000 ///< Bit Manipulation Instruction Set 1 56 | #define AV_CPU_FLAG_BMI2 0x40000 ///< Bit Manipulation Instruction Set 2 57 | 58 | #define AV_CPU_FLAG_ALTIVEC 0x0001 ///< standard 59 | 60 | #define AV_CPU_FLAG_ARMV5TE (1 << 0) 61 | #define AV_CPU_FLAG_ARMV6 (1 << 1) 62 | #define AV_CPU_FLAG_ARMV6T2 (1 << 2) 63 | #define AV_CPU_FLAG_VFP (1 << 3) 64 | #define AV_CPU_FLAG_VFPV3 (1 << 4) 65 | #define AV_CPU_FLAG_NEON (1 << 5) 66 | #define AV_CPU_FLAG_ARMV8 (1 << 6) 67 | #define AV_CPU_FLAG_SETEND (1 <<16) 68 | 69 | /** 70 | * Return the flags which specify extensions supported by the CPU. 71 | * The returned value is affected by av_force_cpu_flags() if that was used 72 | * before. So av_get_cpu_flags() can easily be used in a application to 73 | * detect the enabled cpu flags. 74 | */ 75 | int av_get_cpu_flags(void); 76 | 77 | /** 78 | * Disables cpu detection and forces the specified flags. 79 | * -1 is a special case that disables forcing of specific flags. 80 | */ 81 | void av_force_cpu_flags(int flags); 82 | 83 | /** 84 | * Set a mask on flags returned by av_get_cpu_flags(). 85 | * This function is mainly useful for testing. 86 | * Please use av_force_cpu_flags() and av_get_cpu_flags() instead which are more flexible 87 | * 88 | * @warning this function is not thread safe. 89 | */ 90 | attribute_deprecated void av_set_cpu_flags_mask(int mask); 91 | 92 | /** 93 | * Parse CPU flags from a string. 94 | * 95 | * The returned flags contain the specified flags as well as related unspecified flags. 96 | * 97 | * This function exists only for compatibility with libav. 98 | * Please use av_parse_cpu_caps() when possible. 99 | * @return a combination of AV_CPU_* flags, negative on error. 100 | */ 101 | attribute_deprecated 102 | int av_parse_cpu_flags(const char *s); 103 | 104 | /** 105 | * Parse CPU caps from a string and update the given AV_CPU_* flags based on that. 106 | * 107 | * @return negative on error. 108 | */ 109 | int av_parse_cpu_caps(unsigned *flags, const char *s); 110 | 111 | /** 112 | * @return the number of logical CPU cores present. 113 | */ 114 | int av_cpu_count(void); 115 | 116 | #endif /* AVUTIL_CPU_H */ 117 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/crc.h: -------------------------------------------------------------------------------- 1 | /* 2 | * copyright (c) 2006 Michael Niedermayer 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_CRC_H 22 | #define AVUTIL_CRC_H 23 | 24 | #include 25 | #include 26 | #include "attributes.h" 27 | 28 | /** 29 | * @defgroup lavu_crc32 CRC32 30 | * @ingroup lavu_crypto 31 | * @{ 32 | */ 33 | 34 | typedef uint32_t AVCRC; 35 | 36 | typedef enum { 37 | AV_CRC_8_ATM, 38 | AV_CRC_16_ANSI, 39 | AV_CRC_16_CCITT, 40 | AV_CRC_32_IEEE, 41 | AV_CRC_32_IEEE_LE, /*< reversed bitorder version of AV_CRC_32_IEEE */ 42 | AV_CRC_16_ANSI_LE, /*< reversed bitorder version of AV_CRC_16_ANSI */ 43 | AV_CRC_24_IEEE = 12, 44 | AV_CRC_MAX, /*< Not part of public API! Do not use outside libavutil. */ 45 | }AVCRCId; 46 | 47 | /** 48 | * Initialize a CRC table. 49 | * @param ctx must be an array of size sizeof(AVCRC)*257 or sizeof(AVCRC)*1024 50 | * @param le If 1, the lowest bit represents the coefficient for the highest 51 | * exponent of the corresponding polynomial (both for poly and 52 | * actual CRC). 53 | * If 0, you must swap the CRC parameter and the result of av_crc 54 | * if you need the standard representation (can be simplified in 55 | * most cases to e.g. bswap16): 56 | * av_bswap32(crc << (32-bits)) 57 | * @param bits number of bits for the CRC 58 | * @param poly generator polynomial without the x**bits coefficient, in the 59 | * representation as specified by le 60 | * @param ctx_size size of ctx in bytes 61 | * @return <0 on failure 62 | */ 63 | int av_crc_init(AVCRC *ctx, int le, int bits, uint32_t poly, int ctx_size); 64 | 65 | /** 66 | * Get an initialized standard CRC table. 67 | * @param crc_id ID of a standard CRC 68 | * @return a pointer to the CRC table or NULL on failure 69 | */ 70 | const AVCRC *av_crc_get_table(AVCRCId crc_id); 71 | 72 | /** 73 | * Calculate the CRC of a block. 74 | * @param crc CRC of previous blocks if any or initial value for CRC 75 | * @return CRC updated with the data from the given block 76 | * 77 | * @see av_crc_init() "le" parameter 78 | */ 79 | uint32_t av_crc(const AVCRC *ctx, uint32_t crc, 80 | const uint8_t *buffer, size_t length) av_pure; 81 | 82 | /** 83 | * @} 84 | */ 85 | 86 | #endif /* AVUTIL_CRC_H */ 87 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/display.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2014 Vittorio Giovara 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_DISPLAY_H 22 | #define AVUTIL_DISPLAY_H 23 | 24 | #include 25 | 26 | /** 27 | * The display transformation matrix specifies an affine transformation that 28 | * should be applied to video frames for correct presentation. It is compatible 29 | * with the matrices stored in the ISO/IEC 14496-12 container format. 30 | * 31 | * The data is a 3x3 matrix represented as a 9-element array: 32 | * 33 | * | a b u | 34 | * (a, b, u, c, d, v, x, y, w) -> | c d v | 35 | * | x y w | 36 | * 37 | * All numbers are stored in native endianness, as 16.16 fixed-point values, 38 | * except for u, v and w, which are stored as 2.30 fixed-point values. 39 | * 40 | * The transformation maps a point (p, q) in the source (pre-transformation) 41 | * frame to the point (p', q') in the destination (post-transformation) frame as 42 | * follows: 43 | * | a b u | 44 | * (p, q, 1) . | c d v | = z * (p', q', 1) 45 | * | x y w | 46 | * 47 | * The transformation can also be more explicitly written in components as 48 | * follows: 49 | * p' = (a * p + c * q + x) / z; 50 | * q' = (b * p + d * q + y) / z; 51 | * z = u * p + v * q + w 52 | */ 53 | 54 | /** 55 | * Extract the rotation component of the transformation matrix. 56 | * 57 | * @param matrix the transformation matrix 58 | * @return the angle (in degrees) by which the transformation rotates the frame. 59 | * The angle will be in range [-180.0, 180.0], or NaN if the matrix is 60 | * singular. 61 | * 62 | * @note floating point numbers are inherently inexact, so callers are 63 | * recommended to round the return value to nearest integer before use. 64 | */ 65 | double av_display_rotation_get(const int32_t matrix[9]); 66 | 67 | /** 68 | * Initialize a transformation matrix describing a pure rotation by the 69 | * specified angle (in degrees). 70 | * 71 | * @param matrix an allocated transformation matrix (will be fully overwritten 72 | * by this function) 73 | * @param angle rotation angle in degrees. 74 | */ 75 | void av_display_rotation_set(int32_t matrix[9], double angle); 76 | 77 | /** 78 | * Flip the input matrix horizontally and/or vertically. 79 | * 80 | * @param matrix an allocated transformation matrix 81 | * @param hflip whether the matrix should be flipped horizontally 82 | * @param vflip whether the matrix should be flipped vertically 83 | */ 84 | void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip); 85 | 86 | #endif /* AVUTIL_DISPLAY_H */ 87 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/downmix_info.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2014 Tim Walker 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_DOWNMIX_INFO_H 22 | #define AVUTIL_DOWNMIX_INFO_H 23 | 24 | #include "frame.h" 25 | 26 | /** 27 | * @file 28 | * audio downmix medatata 29 | */ 30 | 31 | /** 32 | * @addtogroup lavu_audio 33 | * @{ 34 | */ 35 | 36 | /** 37 | * @defgroup downmix_info Audio downmix metadata 38 | * @{ 39 | */ 40 | 41 | /** 42 | * Possible downmix types. 43 | */ 44 | enum AVDownmixType { 45 | AV_DOWNMIX_TYPE_UNKNOWN, /**< Not indicated. */ 46 | AV_DOWNMIX_TYPE_LORO, /**< Lo/Ro 2-channel downmix (Stereo). */ 47 | AV_DOWNMIX_TYPE_LTRT, /**< Lt/Rt 2-channel downmix, Dolby Surround compatible. */ 48 | AV_DOWNMIX_TYPE_DPLII, /**< Lt/Rt 2-channel downmix, Dolby Pro Logic II compatible. */ 49 | AV_DOWNMIX_TYPE_NB /**< Number of downmix types. Not part of ABI. */ 50 | }; 51 | 52 | /** 53 | * This structure describes optional metadata relevant to a downmix procedure. 54 | * 55 | * All fields are set by the decoder to the value indicated in the audio 56 | * bitstream (if present), or to a "sane" default otherwise. 57 | */ 58 | typedef struct AVDownmixInfo { 59 | /** 60 | * Type of downmix preferred by the mastering engineer. 61 | */ 62 | enum AVDownmixType preferred_downmix_type; 63 | 64 | /** 65 | * Absolute scale factor representing the nominal level of the center 66 | * channel during a regular downmix. 67 | */ 68 | double center_mix_level; 69 | 70 | /** 71 | * Absolute scale factor representing the nominal level of the center 72 | * channel during an Lt/Rt compatible downmix. 73 | */ 74 | double center_mix_level_ltrt; 75 | 76 | /** 77 | * Absolute scale factor representing the nominal level of the surround 78 | * channels during a regular downmix. 79 | */ 80 | double surround_mix_level; 81 | 82 | /** 83 | * Absolute scale factor representing the nominal level of the surround 84 | * channels during an Lt/Rt compatible downmix. 85 | */ 86 | double surround_mix_level_ltrt; 87 | 88 | /** 89 | * Absolute scale factor representing the level at which the LFE data is 90 | * mixed into L/R channels during downmixing. 91 | */ 92 | double lfe_mix_level; 93 | } AVDownmixInfo; 94 | 95 | /** 96 | * Get a frame's AV_FRAME_DATA_DOWNMIX_INFO side data for editing. 97 | * 98 | * If the side data is absent, it is created and added to the frame. 99 | * 100 | * @param frame the frame for which the side data is to be obtained or created 101 | * 102 | * @return the AVDownmixInfo structure to be edited by the caller, or NULL if 103 | * the structure cannot be allocated. 104 | */ 105 | AVDownmixInfo *av_downmix_info_update_side_data(AVFrame *frame); 106 | 107 | /** 108 | * @} 109 | */ 110 | 111 | /** 112 | * @} 113 | */ 114 | 115 | #endif /* AVUTIL_DOWNMIX_INFO_H */ 116 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/eval.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2002 Michael Niedermayer 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | /** 22 | * @file 23 | * simple arithmetic expression evaluator 24 | */ 25 | 26 | #ifndef AVUTIL_EVAL_H 27 | #define AVUTIL_EVAL_H 28 | 29 | #include "avutil.h" 30 | 31 | typedef struct AVExpr AVExpr; 32 | 33 | /** 34 | * Parse and evaluate an expression. 35 | * Note, this is significantly slower than av_expr_eval(). 36 | * 37 | * @param res a pointer to a double where is put the result value of 38 | * the expression, or NAN in case of error 39 | * @param s expression as a zero terminated string, for example "1+2^3+5*5+sin(2/3)" 40 | * @param const_names NULL terminated array of zero terminated strings of constant identifiers, for example {"PI", "E", 0} 41 | * @param const_values a zero terminated array of values for the identifiers from const_names 42 | * @param func1_names NULL terminated array of zero terminated strings of funcs1 identifiers 43 | * @param funcs1 NULL terminated array of function pointers for functions which take 1 argument 44 | * @param func2_names NULL terminated array of zero terminated strings of funcs2 identifiers 45 | * @param funcs2 NULL terminated array of function pointers for functions which take 2 arguments 46 | * @param opaque a pointer which will be passed to all functions from funcs1 and funcs2 47 | * @param log_ctx parent logging context 48 | * @return >= 0 in case of success, a negative value corresponding to an 49 | * AVERROR code otherwise 50 | */ 51 | int av_expr_parse_and_eval(double *res, const char *s, 52 | const char * const *const_names, const double *const_values, 53 | const char * const *func1_names, double (* const *funcs1)(void *, double), 54 | const char * const *func2_names, double (* const *funcs2)(void *, double, double), 55 | void *opaque, int log_offset, void *log_ctx); 56 | 57 | /** 58 | * Parse an expression. 59 | * 60 | * @param expr a pointer where is put an AVExpr containing the parsed 61 | * value in case of successful parsing, or NULL otherwise. 62 | * The pointed to AVExpr must be freed with av_expr_free() by the user 63 | * when it is not needed anymore. 64 | * @param s expression as a zero terminated string, for example "1+2^3+5*5+sin(2/3)" 65 | * @param const_names NULL terminated array of zero terminated strings of constant identifiers, for example {"PI", "E", 0} 66 | * @param func1_names NULL terminated array of zero terminated strings of funcs1 identifiers 67 | * @param funcs1 NULL terminated array of function pointers for functions which take 1 argument 68 | * @param func2_names NULL terminated array of zero terminated strings of funcs2 identifiers 69 | * @param funcs2 NULL terminated array of function pointers for functions which take 2 arguments 70 | * @param log_ctx parent logging context 71 | * @return >= 0 in case of success, a negative value corresponding to an 72 | * AVERROR code otherwise 73 | */ 74 | int av_expr_parse(AVExpr **expr, const char *s, 75 | const char * const *const_names, 76 | const char * const *func1_names, double (* const *funcs1)(void *, double), 77 | const char * const *func2_names, double (* const *funcs2)(void *, double, double), 78 | int log_offset, void *log_ctx); 79 | 80 | /** 81 | * Evaluate a previously parsed expression. 82 | * 83 | * @param const_values a zero terminated array of values for the identifiers from av_expr_parse() const_names 84 | * @param opaque a pointer which will be passed to all functions from funcs1 and funcs2 85 | * @return the value of the expression 86 | */ 87 | double av_expr_eval(AVExpr *e, const double *const_values, void *opaque); 88 | 89 | /** 90 | * Free a parsed expression previously created with av_expr_parse(). 91 | */ 92 | void av_expr_free(AVExpr *e); 93 | 94 | /** 95 | * Parse the string in numstr and return its value as a double. If 96 | * the string is empty, contains only whitespaces, or does not contain 97 | * an initial substring that has the expected syntax for a 98 | * floating-point number, no conversion is performed. In this case, 99 | * returns a value of zero and the value returned in tail is the value 100 | * of numstr. 101 | * 102 | * @param numstr a string representing a number, may contain one of 103 | * the International System number postfixes, for example 'K', 'M', 104 | * 'G'. If 'i' is appended after the postfix, powers of 2 are used 105 | * instead of powers of 10. The 'B' postfix multiplies the value for 106 | * 8, and can be appended after another postfix or used alone. This 107 | * allows using for example 'KB', 'MiB', 'G' and 'B' as postfix. 108 | * @param tail if non-NULL puts here the pointer to the char next 109 | * after the last parsed character 110 | */ 111 | double av_strtod(const char *numstr, char **tail); 112 | 113 | #endif /* AVUTIL_EVAL_H */ 114 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/ffversion.h: -------------------------------------------------------------------------------- 1 | #ifndef AVUTIL_FFVERSION_H 2 | #define AVUTIL_FFVERSION_H 3 | #define FFMPEG_VERSION "2.6.9" 4 | #endif /* AVUTIL_FFVERSION_H */ 5 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/fifo.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of FFmpeg. 3 | * 4 | * FFmpeg is free software; you can redistribute it and/or 5 | * modify it under the terms of the GNU Lesser General Public 6 | * License as published by the Free Software Foundation; either 7 | * version 2.1 of the License, or (at your option) any later version. 8 | * 9 | * FFmpeg is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | * Lesser General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU Lesser General Public 15 | * License along with FFmpeg; if not, write to the Free Software 16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 17 | */ 18 | 19 | /** 20 | * @file 21 | * a very simple circular buffer FIFO implementation 22 | */ 23 | 24 | #ifndef AVUTIL_FIFO_H 25 | #define AVUTIL_FIFO_H 26 | 27 | #include 28 | #include "avutil.h" 29 | #include "attributes.h" 30 | 31 | typedef struct AVFifoBuffer { 32 | uint8_t *buffer; 33 | uint8_t *rptr, *wptr, *end; 34 | uint32_t rndx, wndx; 35 | } AVFifoBuffer; 36 | 37 | /** 38 | * Initialize an AVFifoBuffer. 39 | * @param size of FIFO 40 | * @return AVFifoBuffer or NULL in case of memory allocation failure 41 | */ 42 | AVFifoBuffer *av_fifo_alloc(unsigned int size); 43 | 44 | /** 45 | * Initialize an AVFifoBuffer. 46 | * @param nmemb number of elements 47 | * @param size size of the single element 48 | * @return AVFifoBuffer or NULL in case of memory allocation failure 49 | */ 50 | AVFifoBuffer *av_fifo_alloc_array(size_t nmemb, size_t size); 51 | 52 | /** 53 | * Free an AVFifoBuffer. 54 | * @param f AVFifoBuffer to free 55 | */ 56 | void av_fifo_free(AVFifoBuffer *f); 57 | 58 | /** 59 | * Free an AVFifoBuffer and reset pointer to NULL. 60 | * @param f AVFifoBuffer to free 61 | */ 62 | void av_fifo_freep(AVFifoBuffer **f); 63 | 64 | /** 65 | * Reset the AVFifoBuffer to the state right after av_fifo_alloc, in particular it is emptied. 66 | * @param f AVFifoBuffer to reset 67 | */ 68 | void av_fifo_reset(AVFifoBuffer *f); 69 | 70 | /** 71 | * Return the amount of data in bytes in the AVFifoBuffer, that is the 72 | * amount of data you can read from it. 73 | * @param f AVFifoBuffer to read from 74 | * @return size 75 | */ 76 | int av_fifo_size(const AVFifoBuffer *f); 77 | 78 | /** 79 | * Return the amount of space in bytes in the AVFifoBuffer, that is the 80 | * amount of data you can write into it. 81 | * @param f AVFifoBuffer to write into 82 | * @return size 83 | */ 84 | int av_fifo_space(const AVFifoBuffer *f); 85 | 86 | /** 87 | * Feed data from an AVFifoBuffer to a user-supplied callback. 88 | * @param f AVFifoBuffer to read from 89 | * @param buf_size number of bytes to read 90 | * @param func generic read function 91 | * @param dest data destination 92 | */ 93 | int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void (*func)(void*, void*, int)); 94 | 95 | /** 96 | * Feed data from a user-supplied callback to an AVFifoBuffer. 97 | * @param f AVFifoBuffer to write to 98 | * @param src data source; non-const since it may be used as a 99 | * modifiable context by the function defined in func 100 | * @param size number of bytes to write 101 | * @param func generic write function; the first parameter is src, 102 | * the second is dest_buf, the third is dest_buf_size. 103 | * func must return the number of bytes written to dest_buf, or <= 0 to 104 | * indicate no more data available to write. 105 | * If func is NULL, src is interpreted as a simple byte array for source data. 106 | * @return the number of bytes written to the FIFO 107 | */ 108 | int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int (*func)(void*, void*, int)); 109 | 110 | /** 111 | * Resize an AVFifoBuffer. 112 | * In case of reallocation failure, the old FIFO is kept unchanged. 113 | * 114 | * @param f AVFifoBuffer to resize 115 | * @param size new AVFifoBuffer size in bytes 116 | * @return <0 for failure, >=0 otherwise 117 | */ 118 | int av_fifo_realloc2(AVFifoBuffer *f, unsigned int size); 119 | 120 | /** 121 | * Enlarge an AVFifoBuffer. 122 | * In case of reallocation failure, the old FIFO is kept unchanged. 123 | * The new fifo size may be larger than the requested size. 124 | * 125 | * @param f AVFifoBuffer to resize 126 | * @param additional_space the amount of space in bytes to allocate in addition to av_fifo_size() 127 | * @return <0 for failure, >=0 otherwise 128 | */ 129 | int av_fifo_grow(AVFifoBuffer *f, unsigned int additional_space); 130 | 131 | /** 132 | * Read and discard the specified amount of data from an AVFifoBuffer. 133 | * @param f AVFifoBuffer to read from 134 | * @param size amount of data to read in bytes 135 | */ 136 | void av_fifo_drain(AVFifoBuffer *f, int size); 137 | 138 | /** 139 | * Return a pointer to the data stored in a FIFO buffer at a certain offset. 140 | * The FIFO buffer is not modified. 141 | * 142 | * @param f AVFifoBuffer to peek at, f must be non-NULL 143 | * @param offs an offset in bytes, its absolute value must be less 144 | * than the used buffer size or the returned pointer will 145 | * point outside to the buffer data. 146 | * The used buffer size can be checked with av_fifo_size(). 147 | */ 148 | static inline uint8_t *av_fifo_peek2(const AVFifoBuffer *f, int offs) 149 | { 150 | uint8_t *ptr = f->rptr + offs; 151 | if (ptr >= f->end) 152 | ptr = f->buffer + (ptr - f->end); 153 | else if (ptr < f->buffer) 154 | ptr = f->end - (f->buffer - ptr); 155 | return ptr; 156 | } 157 | 158 | #endif /* AVUTIL_FIFO_H */ 159 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/file.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of FFmpeg. 3 | * 4 | * FFmpeg is free software; you can redistribute it and/or 5 | * modify it under the terms of the GNU Lesser General Public 6 | * License as published by the Free Software Foundation; either 7 | * version 2.1 of the License, or (at your option) any later version. 8 | * 9 | * FFmpeg is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | * Lesser General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU Lesser General Public 15 | * License along with FFmpeg; if not, write to the Free Software 16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 17 | */ 18 | 19 | #ifndef AVUTIL_FILE_H 20 | #define AVUTIL_FILE_H 21 | 22 | #include 23 | 24 | #include "avutil.h" 25 | 26 | /** 27 | * @file 28 | * Misc file utilities. 29 | */ 30 | 31 | /** 32 | * Read the file with name filename, and put its content in a newly 33 | * allocated buffer or map it with mmap() when available. 34 | * In case of success set *bufptr to the read or mmapped buffer, and 35 | * *size to the size in bytes of the buffer in *bufptr. 36 | * The returned buffer must be released with av_file_unmap(). 37 | * 38 | * @param log_offset loglevel offset used for logging 39 | * @param log_ctx context used for logging 40 | * @return a non negative number in case of success, a negative value 41 | * corresponding to an AVERROR error code in case of failure 42 | */ 43 | int av_file_map(const char *filename, uint8_t **bufptr, size_t *size, 44 | int log_offset, void *log_ctx); 45 | 46 | /** 47 | * Unmap or free the buffer bufptr created by av_file_map(). 48 | * 49 | * @param size size in bytes of bufptr, must be the same as returned 50 | * by av_file_map() 51 | */ 52 | void av_file_unmap(uint8_t *bufptr, size_t size); 53 | 54 | /** 55 | * Wrapper to work around the lack of mkstemp() on mingw. 56 | * Also, tries to create file in /tmp first, if possible. 57 | * *prefix can be a character constant; *filename will be allocated internally. 58 | * @return file descriptor of opened file (or negative value corresponding to an 59 | * AVERROR code on error) 60 | * and opened file name in **filename. 61 | * @note On very old libcs it is necessary to set a secure umask before 62 | * calling this, av_tempfile() can't call umask itself as it is used in 63 | * libraries and could interfere with the calling application. 64 | */ 65 | int av_tempfile(const char *prefix, char **filename, int log_offset, void *log_ctx); 66 | 67 | #endif /* AVUTIL_FILE_H */ 68 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/hash.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2013 Reimar Döffinger 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_HASH_H 22 | #define AVUTIL_HASH_H 23 | 24 | #include 25 | 26 | struct AVHashContext; 27 | 28 | /** 29 | * Allocate a hash context for the algorithm specified by name. 30 | * 31 | * @return >= 0 for success, a negative error code for failure 32 | * @note The context is not initialized, you must call av_hash_init(). 33 | */ 34 | int av_hash_alloc(struct AVHashContext **ctx, const char *name); 35 | 36 | /** 37 | * Get the names of available hash algorithms. 38 | * 39 | * This function can be used to enumerate the algorithms. 40 | * 41 | * @param i index of the hash algorithm, starting from 0 42 | * @return a pointer to a static string or NULL if i is out of range 43 | */ 44 | const char *av_hash_names(int i); 45 | 46 | /** 47 | * Get the name of the algorithm corresponding to the given hash context. 48 | */ 49 | const char *av_hash_get_name(const struct AVHashContext *ctx); 50 | 51 | /** 52 | * Maximum value that av_hash_get_size will currently return. 53 | * 54 | * You can use this if you absolutely want or need to use static allocation 55 | * and are fine with not supporting hashes newly added to libavutil without 56 | * recompilation. 57 | * Note that you still need to check against av_hash_get_size, adding new hashes 58 | * with larger sizes will not be considered an ABI change and should not cause 59 | * your code to overflow a buffer. 60 | */ 61 | #define AV_HASH_MAX_SIZE 64 62 | 63 | /** 64 | * Get the size of the resulting hash value in bytes. 65 | * 66 | * The pointer passed to av_hash_final have space for at least this many bytes. 67 | */ 68 | int av_hash_get_size(const struct AVHashContext *ctx); 69 | 70 | /** 71 | * Initialize or reset a hash context. 72 | */ 73 | void av_hash_init(struct AVHashContext *ctx); 74 | 75 | /** 76 | * Update a hash context with additional data. 77 | */ 78 | void av_hash_update(struct AVHashContext *ctx, const uint8_t *src, int len); 79 | 80 | /** 81 | * Finalize a hash context and compute the actual hash value. 82 | */ 83 | void av_hash_final(struct AVHashContext *ctx, uint8_t *dst); 84 | 85 | /** 86 | * Finalize a hash context and compute the actual hash value. 87 | * If size is smaller than the hash size, the hash is truncated; 88 | * if size is larger, the buffer is padded with 0. 89 | */ 90 | void av_hash_final_bin(struct AVHashContext *ctx, uint8_t *dst, int size); 91 | 92 | /** 93 | * Finalize a hash context and compute the actual hash value as a hex string. 94 | * The string is always 0-terminated. 95 | * If size is smaller than 2 * hash_size + 1, the hex string is truncated. 96 | */ 97 | void av_hash_final_hex(struct AVHashContext *ctx, uint8_t *dst, int size); 98 | 99 | /** 100 | * Finalize a hash context and compute the actual hash value as a base64 string. 101 | * The string is always 0-terminated. 102 | * If size is smaller than AV_BASE64_SIZE(hash_size), the base64 string is 103 | * truncated. 104 | */ 105 | void av_hash_final_b64(struct AVHashContext *ctx, uint8_t *dst, int size); 106 | 107 | /** 108 | * Free hash context. 109 | */ 110 | void av_hash_freep(struct AVHashContext **ctx); 111 | 112 | #endif /* AVUTIL_HASH_H */ 113 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/hmac.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2012 Martin Storsjo 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_HMAC_H 22 | #define AVUTIL_HMAC_H 23 | 24 | #include 25 | 26 | /** 27 | * @defgroup lavu_hmac HMAC 28 | * @ingroup lavu_crypto 29 | * @{ 30 | */ 31 | 32 | enum AVHMACType { 33 | AV_HMAC_MD5, 34 | AV_HMAC_SHA1, 35 | AV_HMAC_SHA224 = 10, 36 | AV_HMAC_SHA256, 37 | AV_HMAC_SHA384, 38 | AV_HMAC_SHA512, 39 | }; 40 | 41 | typedef struct AVHMAC AVHMAC; 42 | 43 | /** 44 | * Allocate an AVHMAC context. 45 | * @param type The hash function used for the HMAC. 46 | */ 47 | AVHMAC *av_hmac_alloc(enum AVHMACType type); 48 | 49 | /** 50 | * Free an AVHMAC context. 51 | * @param ctx The context to free, may be NULL 52 | */ 53 | void av_hmac_free(AVHMAC *ctx); 54 | 55 | /** 56 | * Initialize an AVHMAC context with an authentication key. 57 | * @param ctx The HMAC context 58 | * @param key The authentication key 59 | * @param keylen The length of the key, in bytes 60 | */ 61 | void av_hmac_init(AVHMAC *ctx, const uint8_t *key, unsigned int keylen); 62 | 63 | /** 64 | * Hash data with the HMAC. 65 | * @param ctx The HMAC context 66 | * @param data The data to hash 67 | * @param len The length of the data, in bytes 68 | */ 69 | void av_hmac_update(AVHMAC *ctx, const uint8_t *data, unsigned int len); 70 | 71 | /** 72 | * Finish hashing and output the HMAC digest. 73 | * @param ctx The HMAC context 74 | * @param out The output buffer to write the digest into 75 | * @param outlen The length of the out buffer, in bytes 76 | * @return The number of bytes written to out, or a negative error code. 77 | */ 78 | int av_hmac_final(AVHMAC *ctx, uint8_t *out, unsigned int outlen); 79 | 80 | /** 81 | * Hash an array of data with a key. 82 | * @param ctx The HMAC context 83 | * @param data The data to hash 84 | * @param len The length of the data, in bytes 85 | * @param key The authentication key 86 | * @param keylen The length of the key, in bytes 87 | * @param out The output buffer to write the digest into 88 | * @param outlen The length of the out buffer, in bytes 89 | * @return The number of bytes written to out, or a negative error code. 90 | */ 91 | int av_hmac_calc(AVHMAC *ctx, const uint8_t *data, unsigned int len, 92 | const uint8_t *key, unsigned int keylen, 93 | uint8_t *out, unsigned int outlen); 94 | 95 | /** 96 | * @} 97 | */ 98 | 99 | #endif /* AVUTIL_HMAC_H */ 100 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/intfloat.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2011 Mans Rullgard 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_INTFLOAT_H 22 | #define AVUTIL_INTFLOAT_H 23 | 24 | #include 25 | #include "attributes.h" 26 | 27 | union av_intfloat32 { 28 | uint32_t i; 29 | float f; 30 | }; 31 | 32 | union av_intfloat64 { 33 | uint64_t i; 34 | double f; 35 | }; 36 | 37 | /** 38 | * Reinterpret a 32-bit integer as a float. 39 | */ 40 | static av_always_inline float av_int2float(uint32_t i) 41 | { 42 | union av_intfloat32 v; 43 | v.i = i; 44 | return v.f; 45 | } 46 | 47 | /** 48 | * Reinterpret a float as a 32-bit integer. 49 | */ 50 | static av_always_inline uint32_t av_float2int(float f) 51 | { 52 | union av_intfloat32 v; 53 | v.f = f; 54 | return v.i; 55 | } 56 | 57 | /** 58 | * Reinterpret a 64-bit integer as a double. 59 | */ 60 | static av_always_inline double av_int2double(uint64_t i) 61 | { 62 | union av_intfloat64 v; 63 | v.i = i; 64 | return v.f; 65 | } 66 | 67 | /** 68 | * Reinterpret a double as a 64-bit integer. 69 | */ 70 | static av_always_inline uint64_t av_double2int(double f) 71 | { 72 | union av_intfloat64 v; 73 | v.f = f; 74 | return v.i; 75 | } 76 | 77 | #endif /* AVUTIL_INTFLOAT_H */ 78 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/lfg.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Lagged Fibonacci PRNG 3 | * Copyright (c) 2008 Michael Niedermayer 4 | * 5 | * This file is part of FFmpeg. 6 | * 7 | * FFmpeg is free software; you can redistribute it and/or 8 | * modify it under the terms of the GNU Lesser General Public 9 | * License as published by the Free Software Foundation; either 10 | * version 2.1 of the License, or (at your option) any later version. 11 | * 12 | * FFmpeg is distributed in the hope that it will be useful, 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 | * Lesser General Public License for more details. 16 | * 17 | * You should have received a copy of the GNU Lesser General Public 18 | * License along with FFmpeg; if not, write to the Free Software 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 | */ 21 | 22 | #ifndef AVUTIL_LFG_H 23 | #define AVUTIL_LFG_H 24 | 25 | typedef struct AVLFG { 26 | unsigned int state[64]; 27 | int index; 28 | } AVLFG; 29 | 30 | void av_lfg_init(AVLFG *c, unsigned int seed); 31 | 32 | /** 33 | * Get the next random unsigned 32-bit number using an ALFG. 34 | * 35 | * Please also consider a simple LCG like state= state*1664525+1013904223, 36 | * it may be good enough and faster for your specific use case. 37 | */ 38 | static inline unsigned int av_lfg_get(AVLFG *c){ 39 | c->state[c->index & 63] = c->state[(c->index-24) & 63] + c->state[(c->index-55) & 63]; 40 | return c->state[c->index++ & 63]; 41 | } 42 | 43 | /** 44 | * Get the next random unsigned 32-bit number using a MLFG. 45 | * 46 | * Please also consider av_lfg_get() above, it is faster. 47 | */ 48 | static inline unsigned int av_mlfg_get(AVLFG *c){ 49 | unsigned int a= c->state[(c->index-55) & 63]; 50 | unsigned int b= c->state[(c->index-24) & 63]; 51 | return c->state[c->index++ & 63] = 2*a*b+a+b; 52 | } 53 | 54 | /** 55 | * Get the next two numbers generated by a Box-Muller Gaussian 56 | * generator using the random numbers issued by lfg. 57 | * 58 | * @param out array where the two generated numbers are placed 59 | */ 60 | void av_bmg_get(AVLFG *lfg, double out[2]); 61 | 62 | #endif /* AVUTIL_LFG_H */ 63 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/lzo.h: -------------------------------------------------------------------------------- 1 | /* 2 | * LZO 1x decompression 3 | * copyright (c) 2006 Reimar Doeffinger 4 | * 5 | * This file is part of FFmpeg. 6 | * 7 | * FFmpeg is free software; you can redistribute it and/or 8 | * modify it under the terms of the GNU Lesser General Public 9 | * License as published by the Free Software Foundation; either 10 | * version 2.1 of the License, or (at your option) any later version. 11 | * 12 | * FFmpeg is distributed in the hope that it will be useful, 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 | * Lesser General Public License for more details. 16 | * 17 | * You should have received a copy of the GNU Lesser General Public 18 | * License along with FFmpeg; if not, write to the Free Software 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 | */ 21 | 22 | #ifndef AVUTIL_LZO_H 23 | #define AVUTIL_LZO_H 24 | 25 | /** 26 | * @defgroup lavu_lzo LZO 27 | * @ingroup lavu_crypto 28 | * 29 | * @{ 30 | */ 31 | 32 | #include 33 | 34 | /** @name Error flags returned by av_lzo1x_decode 35 | * @{ */ 36 | /// end of the input buffer reached before decoding finished 37 | #define AV_LZO_INPUT_DEPLETED 1 38 | /// decoded data did not fit into output buffer 39 | #define AV_LZO_OUTPUT_FULL 2 40 | /// a reference to previously decoded data was wrong 41 | #define AV_LZO_INVALID_BACKPTR 4 42 | /// a non-specific error in the compressed bitstream 43 | #define AV_LZO_ERROR 8 44 | /** @} */ 45 | 46 | #define AV_LZO_INPUT_PADDING 8 47 | #define AV_LZO_OUTPUT_PADDING 12 48 | 49 | /** 50 | * @brief Decodes LZO 1x compressed data. 51 | * @param out output buffer 52 | * @param outlen size of output buffer, number of bytes left are returned here 53 | * @param in input buffer 54 | * @param inlen size of input buffer, number of bytes left are returned here 55 | * @return 0 on success, otherwise a combination of the error flags above 56 | * 57 | * Make sure all buffers are appropriately padded, in must provide 58 | * AV_LZO_INPUT_PADDING, out must provide AV_LZO_OUTPUT_PADDING additional bytes. 59 | */ 60 | int av_lzo1x_decode(void *out, int *outlen, const void *in, int *inlen); 61 | 62 | /** 63 | * @} 64 | */ 65 | 66 | #endif /* AVUTIL_LZO_H */ 67 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/macros.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of FFmpeg. 3 | * 4 | * FFmpeg is free software; you can redistribute it and/or 5 | * modify it under the terms of the GNU Lesser General Public 6 | * License as published by the Free Software Foundation; either 7 | * version 2.1 of the License, or (at your option) any later version. 8 | * 9 | * FFmpeg is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | * Lesser General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU Lesser General Public 15 | * License along with FFmpeg; if not, write to the Free Software 16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 17 | */ 18 | 19 | /** 20 | * @file 21 | * @ingroup lavu 22 | * Utility Preprocessor macros 23 | */ 24 | 25 | #ifndef AVUTIL_MACROS_H 26 | #define AVUTIL_MACROS_H 27 | 28 | /** 29 | * @addtogroup preproc_misc Preprocessor String Macros 30 | * 31 | * String manipulation macros 32 | * 33 | * @{ 34 | */ 35 | 36 | #define AV_STRINGIFY(s) AV_TOSTRING(s) 37 | #define AV_TOSTRING(s) #s 38 | 39 | #define AV_GLUE(a, b) a ## b 40 | #define AV_JOIN(a, b) AV_GLUE(a, b) 41 | 42 | /** 43 | * @} 44 | */ 45 | 46 | #define AV_PRAGMA(s) _Pragma(#s) 47 | 48 | #endif /* AVUTIL_MACROS_H */ 49 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/md5.h: -------------------------------------------------------------------------------- 1 | /* 2 | * copyright (c) 2006 Michael Niedermayer 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_MD5_H 22 | #define AVUTIL_MD5_H 23 | 24 | #include 25 | 26 | #include "attributes.h" 27 | #include "version.h" 28 | 29 | /** 30 | * @defgroup lavu_md5 MD5 31 | * @ingroup lavu_crypto 32 | * @{ 33 | */ 34 | 35 | extern const int av_md5_size; 36 | 37 | struct AVMD5; 38 | 39 | /** 40 | * Allocate an AVMD5 context. 41 | */ 42 | struct AVMD5 *av_md5_alloc(void); 43 | 44 | /** 45 | * Initialize MD5 hashing. 46 | * 47 | * @param ctx pointer to the function context (of size av_md5_size) 48 | */ 49 | void av_md5_init(struct AVMD5 *ctx); 50 | 51 | /** 52 | * Update hash value. 53 | * 54 | * @param ctx hash function context 55 | * @param src input data to update hash with 56 | * @param len input data length 57 | */ 58 | void av_md5_update(struct AVMD5 *ctx, const uint8_t *src, int len); 59 | 60 | /** 61 | * Finish hashing and output digest value. 62 | * 63 | * @param ctx hash function context 64 | * @param dst buffer where output digest value is stored 65 | */ 66 | void av_md5_final(struct AVMD5 *ctx, uint8_t *dst); 67 | 68 | /** 69 | * Hash an array of data. 70 | * 71 | * @param dst The output buffer to write the digest into 72 | * @param src The data to hash 73 | * @param len The length of the data, in bytes 74 | */ 75 | void av_md5_sum(uint8_t *dst, const uint8_t *src, const int len); 76 | 77 | /** 78 | * @} 79 | */ 80 | 81 | #endif /* AVUTIL_MD5_H */ 82 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/motion_vector.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of FFmpeg. 3 | * 4 | * FFmpeg is free software; you can redistribute it and/or 5 | * modify it under the terms of the GNU Lesser General Public 6 | * License as published by the Free Software Foundation; either 7 | * version 2.1 of the License, or (at your option) any later version. 8 | * 9 | * FFmpeg is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | * Lesser General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU Lesser General Public 15 | * License along with FFmpeg; if not, write to the Free Software 16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 17 | */ 18 | 19 | #ifndef AVUTIL_MOTION_VECTOR_H 20 | #define AVUTIL_MOTION_VECTOR_H 21 | 22 | #include 23 | 24 | typedef struct AVMotionVector { 25 | /** 26 | * Where the current macroblock comes from; negative value when it comes 27 | * from the past, positive value when it comes from the future. 28 | * XXX: set exact relative ref frame reference instead of a +/- 1 "direction". 29 | */ 30 | int32_t source; 31 | /** 32 | * Width and height of the block. 33 | */ 34 | uint8_t w, h; 35 | /** 36 | * Absolute source position. Can be outside the frame area. 37 | */ 38 | int16_t src_x, src_y; 39 | /** 40 | * Absolute destination position. Can be outside the frame area. 41 | */ 42 | int16_t dst_x, dst_y; 43 | /** 44 | * Extra flag information. 45 | * Currently unused. 46 | */ 47 | uint64_t flags; 48 | } AVMotionVector; 49 | 50 | #endif /* AVUTIL_MOTION_VECTOR_H */ 51 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/murmur3.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2013 Reimar Döffinger 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_MURMUR3_H 22 | #define AVUTIL_MURMUR3_H 23 | 24 | #include 25 | 26 | struct AVMurMur3 *av_murmur3_alloc(void); 27 | void av_murmur3_init_seeded(struct AVMurMur3 *c, uint64_t seed); 28 | void av_murmur3_init(struct AVMurMur3 *c); 29 | void av_murmur3_update(struct AVMurMur3 *c, const uint8_t *src, int len); 30 | void av_murmur3_final(struct AVMurMur3 *c, uint8_t dst[16]); 31 | 32 | #endif /* AVUTIL_MURMUR3_H */ 33 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/pixelutils.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of FFmpeg. 3 | * 4 | * FFmpeg is free software; you can redistribute it and/or 5 | * modify it under the terms of the GNU Lesser General Public 6 | * License as published by the Free Software Foundation; either 7 | * version 2.1 of the License, or (at your option) any later version. 8 | * 9 | * FFmpeg is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | * Lesser General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU Lesser General Public 15 | * License along with FFmpeg; if not, write to the Free Software 16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 17 | */ 18 | 19 | #ifndef AVUTIL_PIXELUTILS_H 20 | #define AVUTIL_PIXELUTILS_H 21 | 22 | #include 23 | #include 24 | #include "common.h" 25 | 26 | /** 27 | * Sum of abs(src1[x] - src2[x]) 28 | */ 29 | typedef int (*av_pixelutils_sad_fn)(const uint8_t *src1, ptrdiff_t stride1, 30 | const uint8_t *src2, ptrdiff_t stride2); 31 | 32 | /** 33 | * Get a potentially optimized pointer to a Sum-of-absolute-differences 34 | * function (see the av_pixelutils_sad_fn prototype). 35 | * 36 | * @param w_bits 1< 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_RANDOM_SEED_H 22 | #define AVUTIL_RANDOM_SEED_H 23 | 24 | #include 25 | /** 26 | * @addtogroup lavu_crypto 27 | * @{ 28 | */ 29 | 30 | /** 31 | * Get a seed to use in conjunction with random functions. 32 | * This function tries to provide a good seed at a best effort bases. 33 | * Its possible to call this function multiple times if more bits are needed. 34 | * It can be quite slow, which is why it should only be used as seed for a faster 35 | * PRNG. The quality of the seed depends on the platform. 36 | */ 37 | uint32_t av_get_random_seed(void); 38 | 39 | /** 40 | * @} 41 | */ 42 | 43 | #endif /* AVUTIL_RANDOM_SEED_H */ 44 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/rational.h: -------------------------------------------------------------------------------- 1 | /* 2 | * rational numbers 3 | * Copyright (c) 2003 Michael Niedermayer 4 | * 5 | * This file is part of FFmpeg. 6 | * 7 | * FFmpeg is free software; you can redistribute it and/or 8 | * modify it under the terms of the GNU Lesser General Public 9 | * License as published by the Free Software Foundation; either 10 | * version 2.1 of the License, or (at your option) any later version. 11 | * 12 | * FFmpeg is distributed in the hope that it will be useful, 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 | * Lesser General Public License for more details. 16 | * 17 | * You should have received a copy of the GNU Lesser General Public 18 | * License along with FFmpeg; if not, write to the Free Software 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 | */ 21 | 22 | /** 23 | * @file 24 | * rational numbers 25 | * @author Michael Niedermayer 26 | */ 27 | 28 | #ifndef AVUTIL_RATIONAL_H 29 | #define AVUTIL_RATIONAL_H 30 | 31 | #include 32 | #include 33 | #include "attributes.h" 34 | 35 | /** 36 | * @addtogroup lavu_math 37 | * @{ 38 | */ 39 | 40 | /** 41 | * rational number numerator/denominator 42 | */ 43 | typedef struct AVRational{ 44 | int num; ///< numerator 45 | int den; ///< denominator 46 | } AVRational; 47 | 48 | /** 49 | * Create a rational. 50 | * Useful for compilers that do not support compound literals. 51 | * @note The return value is not reduced. 52 | */ 53 | static inline AVRational av_make_q(int num, int den) 54 | { 55 | AVRational r = { num, den }; 56 | return r; 57 | } 58 | 59 | /** 60 | * Compare two rationals. 61 | * @param a first rational 62 | * @param b second rational 63 | * @return 0 if a==b, 1 if a>b, -1 if a>63)|1; 70 | else if(b.den && a.den) return 0; 71 | else if(a.num && b.num) return (a.num>>31) - (b.num>>31); 72 | else return INT_MIN; 73 | } 74 | 75 | /** 76 | * Convert rational to double. 77 | * @param a rational to convert 78 | * @return (double) a 79 | */ 80 | static inline double av_q2d(AVRational a){ 81 | return a.num / (double) a.den; 82 | } 83 | 84 | /** 85 | * Reduce a fraction. 86 | * This is useful for framerate calculations. 87 | * @param dst_num destination numerator 88 | * @param dst_den destination denominator 89 | * @param num source numerator 90 | * @param den source denominator 91 | * @param max the maximum allowed for dst_num & dst_den 92 | * @return 1 if exact, 0 otherwise 93 | */ 94 | int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max); 95 | 96 | /** 97 | * Multiply two rationals. 98 | * @param b first rational 99 | * @param c second rational 100 | * @return b*c 101 | */ 102 | AVRational av_mul_q(AVRational b, AVRational c) av_const; 103 | 104 | /** 105 | * Divide one rational by another. 106 | * @param b first rational 107 | * @param c second rational 108 | * @return b/c 109 | */ 110 | AVRational av_div_q(AVRational b, AVRational c) av_const; 111 | 112 | /** 113 | * Add two rationals. 114 | * @param b first rational 115 | * @param c second rational 116 | * @return b+c 117 | */ 118 | AVRational av_add_q(AVRational b, AVRational c) av_const; 119 | 120 | /** 121 | * Subtract one rational from another. 122 | * @param b first rational 123 | * @param c second rational 124 | * @return b-c 125 | */ 126 | AVRational av_sub_q(AVRational b, AVRational c) av_const; 127 | 128 | /** 129 | * Invert a rational. 130 | * @param q value 131 | * @return 1 / q 132 | */ 133 | static av_always_inline AVRational av_inv_q(AVRational q) 134 | { 135 | AVRational r = { q.den, q.num }; 136 | return r; 137 | } 138 | 139 | /** 140 | * Convert a double precision floating point number to a rational. 141 | * inf is expressed as {1,0} or {-1,0} depending on the sign. 142 | * 143 | * @param d double to convert 144 | * @param max the maximum allowed numerator and denominator 145 | * @return (AVRational) d 146 | */ 147 | AVRational av_d2q(double d, int max) av_const; 148 | 149 | /** 150 | * @return 1 if q1 is nearer to q than q2, -1 if q2 is nearer 151 | * than q1, 0 if they have the same distance. 152 | */ 153 | int av_nearer_q(AVRational q, AVRational q1, AVRational q2); 154 | 155 | /** 156 | * Find the nearest value in q_list to q. 157 | * @param q_list an array of rationals terminated by {0, 0} 158 | * @return the index of the nearest value found in the array 159 | */ 160 | int av_find_nearest_q_idx(AVRational q, const AVRational* q_list); 161 | 162 | /** 163 | * @} 164 | */ 165 | 166 | #endif /* AVUTIL_RATIONAL_H */ 167 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/replaygain.h: -------------------------------------------------------------------------------- 1 | /* 2 | * 3 | * This file is part of FFmpeg. 4 | * 5 | * FFmpeg is free software; you can redistribute it and/or 6 | * modify it under the terms of the GNU Lesser General Public 7 | * License as published by the Free Software Foundation; either 8 | * version 2.1 of the License, or (at your option) any later version. 9 | * 10 | * FFmpeg is distributed in the hope that it will be useful, 11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 | * Lesser General Public License for more details. 14 | * 15 | * You should have received a copy of the GNU Lesser General Public 16 | * License along with FFmpeg; if not, write to the Free Software 17 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 18 | */ 19 | 20 | #ifndef AVUTIL_REPLAYGAIN_H 21 | #define AVUTIL_REPLAYGAIN_H 22 | 23 | #include 24 | 25 | /** 26 | * ReplayGain information (see 27 | * http://wiki.hydrogenaudio.org/index.php?title=ReplayGain_1.0_specification). 28 | * The size of this struct is a part of the public ABI. 29 | */ 30 | typedef struct AVReplayGain { 31 | /** 32 | * Track replay gain in microbels (divide by 100000 to get the value in dB). 33 | * Should be set to INT32_MIN when unknown. 34 | */ 35 | int32_t track_gain; 36 | /** 37 | * Peak track amplitude, with 100000 representing full scale (but values 38 | * may overflow). 0 when unknown. 39 | */ 40 | uint32_t track_peak; 41 | /** 42 | * Same as track_gain, but for the whole album. 43 | */ 44 | int32_t album_gain; 45 | /** 46 | * Same as track_peak, but for the whole album, 47 | */ 48 | uint32_t album_peak; 49 | } AVReplayGain; 50 | 51 | #endif /* AVUTIL_REPLAYGAIN_H */ 52 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/ripemd.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2007 Michael Niedermayer 3 | * Copyright (C) 2013 James Almer 4 | * 5 | * This file is part of FFmpeg. 6 | * 7 | * FFmpeg is free software; you can redistribute it and/or 8 | * modify it under the terms of the GNU Lesser General Public 9 | * License as published by the Free Software Foundation; either 10 | * version 2.1 of the License, or (at your option) any later version. 11 | * 12 | * FFmpeg is distributed in the hope that it will be useful, 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 | * Lesser General Public License for more details. 16 | * 17 | * You should have received a copy of the GNU Lesser General Public 18 | * License along with FFmpeg; if not, write to the Free Software 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 | */ 21 | 22 | #ifndef AVUTIL_RIPEMD_H 23 | #define AVUTIL_RIPEMD_H 24 | 25 | #include 26 | 27 | #include "attributes.h" 28 | #include "version.h" 29 | 30 | /** 31 | * @defgroup lavu_ripemd RIPEMD 32 | * @ingroup lavu_crypto 33 | * @{ 34 | */ 35 | 36 | extern const int av_ripemd_size; 37 | 38 | struct AVRIPEMD; 39 | 40 | /** 41 | * Allocate an AVRIPEMD context. 42 | */ 43 | struct AVRIPEMD *av_ripemd_alloc(void); 44 | 45 | /** 46 | * Initialize RIPEMD hashing. 47 | * 48 | * @param context pointer to the function context (of size av_ripemd_size) 49 | * @param bits number of bits in digest (128, 160, 256 or 320 bits) 50 | * @return zero if initialization succeeded, -1 otherwise 51 | */ 52 | int av_ripemd_init(struct AVRIPEMD* context, int bits); 53 | 54 | /** 55 | * Update hash value. 56 | * 57 | * @param context hash function context 58 | * @param data input data to update hash with 59 | * @param len input data length 60 | */ 61 | void av_ripemd_update(struct AVRIPEMD* context, const uint8_t* data, unsigned int len); 62 | 63 | /** 64 | * Finish hashing and output digest value. 65 | * 66 | * @param context hash function context 67 | * @param digest buffer where output digest value is stored 68 | */ 69 | void av_ripemd_final(struct AVRIPEMD* context, uint8_t *digest); 70 | 71 | /** 72 | * @} 73 | */ 74 | 75 | #endif /* AVUTIL_RIPEMD_H */ 76 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/sha.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2007 Michael Niedermayer 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_SHA_H 22 | #define AVUTIL_SHA_H 23 | 24 | #include 25 | 26 | #include "attributes.h" 27 | #include "version.h" 28 | 29 | /** 30 | * @defgroup lavu_sha SHA 31 | * @ingroup lavu_crypto 32 | * @{ 33 | */ 34 | 35 | extern const int av_sha_size; 36 | 37 | struct AVSHA; 38 | 39 | /** 40 | * Allocate an AVSHA context. 41 | */ 42 | struct AVSHA *av_sha_alloc(void); 43 | 44 | /** 45 | * Initialize SHA-1 or SHA-2 hashing. 46 | * 47 | * @param context pointer to the function context (of size av_sha_size) 48 | * @param bits number of bits in digest (SHA-1 - 160 bits, SHA-2 224 or 256 bits) 49 | * @return zero if initialization succeeded, -1 otherwise 50 | */ 51 | int av_sha_init(struct AVSHA* context, int bits); 52 | 53 | /** 54 | * Update hash value. 55 | * 56 | * @param context hash function context 57 | * @param data input data to update hash with 58 | * @param len input data length 59 | */ 60 | void av_sha_update(struct AVSHA* context, const uint8_t* data, unsigned int len); 61 | 62 | /** 63 | * Finish hashing and output digest value. 64 | * 65 | * @param context hash function context 66 | * @param digest buffer where output digest value is stored 67 | */ 68 | void av_sha_final(struct AVSHA* context, uint8_t *digest); 69 | 70 | /** 71 | * @} 72 | */ 73 | 74 | #endif /* AVUTIL_SHA_H */ 75 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/sha512.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2007 Michael Niedermayer 3 | * Copyright (C) 2013 James Almer 4 | * 5 | * This file is part of FFmpeg. 6 | * 7 | * FFmpeg is free software; you can redistribute it and/or 8 | * modify it under the terms of the GNU Lesser General Public 9 | * License as published by the Free Software Foundation; either 10 | * version 2.1 of the License, or (at your option) any later version. 11 | * 12 | * FFmpeg is distributed in the hope that it will be useful, 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 | * Lesser General Public License for more details. 16 | * 17 | * You should have received a copy of the GNU Lesser General Public 18 | * License along with FFmpeg; if not, write to the Free Software 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 | */ 21 | 22 | #ifndef AVUTIL_SHA512_H 23 | #define AVUTIL_SHA512_H 24 | 25 | #include 26 | 27 | #include "attributes.h" 28 | #include "version.h" 29 | 30 | /** 31 | * @defgroup lavu_sha512 SHA512 32 | * @ingroup lavu_crypto 33 | * @{ 34 | */ 35 | 36 | extern const int av_sha512_size; 37 | 38 | struct AVSHA512; 39 | 40 | /** 41 | * Allocate an AVSHA512 context. 42 | */ 43 | struct AVSHA512 *av_sha512_alloc(void); 44 | 45 | /** 46 | * Initialize SHA-2 512 hashing. 47 | * 48 | * @param context pointer to the function context (of size av_sha512_size) 49 | * @param bits number of bits in digest (224, 256, 384 or 512 bits) 50 | * @return zero if initialization succeeded, -1 otherwise 51 | */ 52 | int av_sha512_init(struct AVSHA512* context, int bits); 53 | 54 | /** 55 | * Update hash value. 56 | * 57 | * @param context hash function context 58 | * @param data input data to update hash with 59 | * @param len input data length 60 | */ 61 | void av_sha512_update(struct AVSHA512* context, const uint8_t* data, unsigned int len); 62 | 63 | /** 64 | * Finish hashing and output digest value. 65 | * 66 | * @param context hash function context 67 | * @param digest buffer where output digest value is stored 68 | */ 69 | void av_sha512_final(struct AVSHA512* context, uint8_t *digest); 70 | 71 | /** 72 | * @} 73 | */ 74 | 75 | #endif /* AVUTIL_SHA512_H */ 76 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/stereo3d.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2013 Vittorio Giovara 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_STEREO3D_H 22 | #define AVUTIL_STEREO3D_H 23 | 24 | #include 25 | 26 | #include "frame.h" 27 | 28 | /** 29 | * List of possible 3D Types 30 | */ 31 | enum AVStereo3DType { 32 | /** 33 | * Video is not stereoscopic (and metadata has to be there). 34 | */ 35 | AV_STEREO3D_2D, 36 | 37 | /** 38 | * Views are next to each other. 39 | * 40 | * LLLLRRRR 41 | * LLLLRRRR 42 | * LLLLRRRR 43 | * ... 44 | */ 45 | AV_STEREO3D_SIDEBYSIDE, 46 | 47 | /** 48 | * Views are on top of each other. 49 | * 50 | * LLLLLLLL 51 | * LLLLLLLL 52 | * RRRRRRRR 53 | * RRRRRRRR 54 | */ 55 | AV_STEREO3D_TOPBOTTOM, 56 | 57 | /** 58 | * Views are alternated temporally. 59 | * 60 | * frame0 frame1 frame2 ... 61 | * LLLLLLLL RRRRRRRR LLLLLLLL 62 | * LLLLLLLL RRRRRRRR LLLLLLLL 63 | * LLLLLLLL RRRRRRRR LLLLLLLL 64 | * ... ... ... 65 | */ 66 | AV_STEREO3D_FRAMESEQUENCE, 67 | 68 | /** 69 | * Views are packed in a checkerboard-like structure per pixel. 70 | * 71 | * LRLRLRLR 72 | * RLRLRLRL 73 | * LRLRLRLR 74 | * ... 75 | */ 76 | AV_STEREO3D_CHECKERBOARD, 77 | 78 | /** 79 | * Views are next to each other, but when upscaling 80 | * apply a checkerboard pattern. 81 | * 82 | * LLLLRRRR L L L L R R R R 83 | * LLLLRRRR => L L L L R R R R 84 | * LLLLRRRR L L L L R R R R 85 | * LLLLRRRR L L L L R R R R 86 | */ 87 | AV_STEREO3D_SIDEBYSIDE_QUINCUNX, 88 | 89 | /** 90 | * Views are packed per line, as if interlaced. 91 | * 92 | * LLLLLLLL 93 | * RRRRRRRR 94 | * LLLLLLLL 95 | * ... 96 | */ 97 | AV_STEREO3D_LINES, 98 | 99 | /** 100 | * Views are packed per column. 101 | * 102 | * LRLRLRLR 103 | * LRLRLRLR 104 | * LRLRLRLR 105 | * ... 106 | */ 107 | AV_STEREO3D_COLUMNS, 108 | }; 109 | 110 | 111 | /** 112 | * Inverted views, Right/Bottom represents the left view. 113 | */ 114 | #define AV_STEREO3D_FLAG_INVERT (1 << 0) 115 | 116 | /** 117 | * Stereo 3D type: this structure describes how two videos are packed 118 | * within a single video surface, with additional information as needed. 119 | * 120 | * @note The struct must be allocated with av_stereo3d_alloc() and 121 | * its size is not a part of the public ABI. 122 | */ 123 | typedef struct AVStereo3D { 124 | /** 125 | * How views are packed within the video. 126 | */ 127 | enum AVStereo3DType type; 128 | 129 | /** 130 | * Additional information about the frame packing. 131 | */ 132 | int flags; 133 | } AVStereo3D; 134 | 135 | /** 136 | * Allocate an AVStereo3D structure and set its fields to default values. 137 | * The resulting struct can be freed using av_freep(). 138 | * 139 | * @return An AVStereo3D filled with default values or NULL on failure. 140 | */ 141 | AVStereo3D *av_stereo3d_alloc(void); 142 | 143 | /** 144 | * Allocate a complete AVFrameSideData and add it to the frame. 145 | * 146 | * @param frame The frame which side data is added to. 147 | * 148 | * @return The AVStereo3D structure to be filled by caller. 149 | */ 150 | AVStereo3D *av_stereo3d_create_side_data(AVFrame *frame); 151 | 152 | #endif /* AVUTIL_STEREO3D_H */ 153 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/threadmessage.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of FFmpeg. 3 | * 4 | * FFmpeg is free software; you can redistribute it and/or 5 | * modify it under the terms of the GNU Lesser General Public License 6 | * as published by the Free Software Foundation; either 7 | * version 2.1 of the License, or (at your option) any later version. 8 | * 9 | * FFmpeg is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 | * GNU Lesser General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU Lesser General Public License 15 | * along with FFmpeg; if not, write to the Free Software Foundation, Inc., 16 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 17 | */ 18 | 19 | #ifndef AVUTIL_THREADMESSAGE_H 20 | #define AVUTIL_THREADMESSAGE_H 21 | 22 | typedef struct AVThreadMessageQueue AVThreadMessageQueue; 23 | 24 | typedef enum AVThreadMessageFlags { 25 | 26 | /** 27 | * Perform non-blocking operation. 28 | * If this flag is set, send and recv operations are non-blocking and 29 | * return AVERROR(EAGAIN) immediately if they can not proceed. 30 | */ 31 | AV_THREAD_MESSAGE_NONBLOCK = 1, 32 | 33 | } AVThreadMessageFlags; 34 | 35 | /** 36 | * Allocate a new message queue. 37 | * 38 | * @param mq pointer to the message queue 39 | * @param nelem maximum number of elements in the queue 40 | * @param elsize size of each element in the queue 41 | * @return >=0 for success; <0 for error, in particular AVERROR(ENOSYS) if 42 | * lavu was built without thread support 43 | */ 44 | int av_thread_message_queue_alloc(AVThreadMessageQueue **mq, 45 | unsigned nelem, 46 | unsigned elsize); 47 | 48 | /** 49 | * Free a message queue. 50 | * 51 | * The message queue must no longer be in use by another thread. 52 | */ 53 | void av_thread_message_queue_free(AVThreadMessageQueue **mq); 54 | 55 | /** 56 | * Send a message on the queue. 57 | */ 58 | int av_thread_message_queue_send(AVThreadMessageQueue *mq, 59 | void *msg, 60 | unsigned flags); 61 | 62 | /** 63 | * Receive a message from the queue. 64 | */ 65 | int av_thread_message_queue_recv(AVThreadMessageQueue *mq, 66 | void *msg, 67 | unsigned flags); 68 | 69 | /** 70 | * Set the sending error code. 71 | * 72 | * If the error code is set to non-zero, av_thread_message_queue_recv() will 73 | * return it immediately when there are no longer available messages. 74 | * Conventional values, such as AVERROR_EOF or AVERROR(EAGAIN), can be used 75 | * to cause the receiving thread to stop or suspend its operation. 76 | */ 77 | void av_thread_message_queue_set_err_send(AVThreadMessageQueue *mq, 78 | int err); 79 | 80 | /** 81 | * Set the receiving error code. 82 | * 83 | * If the error code is set to non-zero, av_thread_message_queue_send() will 84 | * return it immediately. Conventional values, such as AVERROR_EOF or 85 | * AVERROR(EAGAIN), can be used to cause the sending thread to stop or 86 | * suspend its operation. 87 | */ 88 | void av_thread_message_queue_set_err_recv(AVThreadMessageQueue *mq, 89 | int err); 90 | 91 | #endif /* AVUTIL_THREADMESSAGE_H */ 92 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/time.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2000-2003 Fabrice Bellard 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_TIME_H 22 | #define AVUTIL_TIME_H 23 | 24 | #include 25 | 26 | /** 27 | * Get the current time in microseconds. 28 | */ 29 | int64_t av_gettime(void); 30 | 31 | /** 32 | * Get the current time in microseconds since some unspecified starting point. 33 | * On platforms that support it, the time comes from a monotonic clock 34 | * This property makes this time source ideal for measuring relative time. 35 | * The returned values may not be monotonic on platforms where a monotonic 36 | * clock is not available. 37 | */ 38 | int64_t av_gettime_relative(void); 39 | 40 | /** 41 | * Indicates with a boolean result if the av_gettime_relative() time source 42 | * is monotonic. 43 | */ 44 | int av_gettime_relative_is_monotonic(void); 45 | 46 | /** 47 | * Sleep for a period of time. Although the duration is expressed in 48 | * microseconds, the actual delay may be rounded to the precision of the 49 | * system timer. 50 | * 51 | * @param usec Number of microseconds to sleep. 52 | * @return zero on success or (negative) error code. 53 | */ 54 | int av_usleep(unsigned usec); 55 | 56 | #endif /* AVUTIL_TIME_H */ 57 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/timecode.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2006 Smartjog S.A.S, Baptiste Coudurier 3 | * Copyright (c) 2011-2012 Smartjog S.A.S, Clément Bœsch 4 | * 5 | * This file is part of FFmpeg. 6 | * 7 | * FFmpeg is free software; you can redistribute it and/or 8 | * modify it under the terms of the GNU Lesser General Public 9 | * License as published by the Free Software Foundation; either 10 | * version 2.1 of the License, or (at your option) any later version. 11 | * 12 | * FFmpeg is distributed in the hope that it will be useful, 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 | * Lesser General Public License for more details. 16 | * 17 | * You should have received a copy of the GNU Lesser General Public 18 | * License along with FFmpeg; if not, write to the Free Software 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 | */ 21 | 22 | /** 23 | * @file 24 | * Timecode helpers header 25 | */ 26 | 27 | #ifndef AVUTIL_TIMECODE_H 28 | #define AVUTIL_TIMECODE_H 29 | 30 | #include 31 | #include "rational.h" 32 | 33 | #define AV_TIMECODE_STR_SIZE 16 34 | 35 | enum AVTimecodeFlag { 36 | AV_TIMECODE_FLAG_DROPFRAME = 1<<0, ///< timecode is drop frame 37 | AV_TIMECODE_FLAG_24HOURSMAX = 1<<1, ///< timecode wraps after 24 hours 38 | AV_TIMECODE_FLAG_ALLOWNEGATIVE = 1<<2, ///< negative time values are allowed 39 | }; 40 | 41 | typedef struct { 42 | int start; ///< timecode frame start (first base frame number) 43 | uint32_t flags; ///< flags such as drop frame, +24 hours support, ... 44 | AVRational rate; ///< frame rate in rational form 45 | unsigned fps; ///< frame per second; must be consistent with the rate field 46 | } AVTimecode; 47 | 48 | /** 49 | * Adjust frame number for NTSC drop frame time code. 50 | * 51 | * @param framenum frame number to adjust 52 | * @param fps frame per second, 30 or 60 53 | * @return adjusted frame number 54 | * @warning adjustment is only valid in NTSC 29.97 and 59.94 55 | */ 56 | int av_timecode_adjust_ntsc_framenum2(int framenum, int fps); 57 | 58 | /** 59 | * Convert frame number to SMPTE 12M binary representation. 60 | * 61 | * @param tc timecode data correctly initialized 62 | * @param framenum frame number 63 | * @return the SMPTE binary representation 64 | * 65 | * @note Frame number adjustment is automatically done in case of drop timecode, 66 | * you do NOT have to call av_timecode_adjust_ntsc_framenum2(). 67 | * @note The frame number is relative to tc->start. 68 | * @note Color frame (CF), binary group flags (BGF) and biphase mark polarity 69 | * correction (PC) bits are set to zero. 70 | */ 71 | uint32_t av_timecode_get_smpte_from_framenum(const AVTimecode *tc, int framenum); 72 | 73 | /** 74 | * Load timecode string in buf. 75 | * 76 | * @param buf destination buffer, must be at least AV_TIMECODE_STR_SIZE long 77 | * @param tc timecode data correctly initialized 78 | * @param framenum frame number 79 | * @return the buf parameter 80 | * 81 | * @note Timecode representation can be a negative timecode and have more than 82 | * 24 hours, but will only be honored if the flags are correctly set. 83 | * @note The frame number is relative to tc->start. 84 | */ 85 | char *av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum); 86 | 87 | /** 88 | * Get the timecode string from the SMPTE timecode format. 89 | * 90 | * @param buf destination buffer, must be at least AV_TIMECODE_STR_SIZE long 91 | * @param tcsmpte the 32-bit SMPTE timecode 92 | * @param prevent_df prevent the use of a drop flag when it is known the DF bit 93 | * is arbitrary 94 | * @return the buf parameter 95 | */ 96 | char *av_timecode_make_smpte_tc_string(char *buf, uint32_t tcsmpte, int prevent_df); 97 | 98 | /** 99 | * Get the timecode string from the 25-bit timecode format (MPEG GOP format). 100 | * 101 | * @param buf destination buffer, must be at least AV_TIMECODE_STR_SIZE long 102 | * @param tc25bit the 25-bits timecode 103 | * @return the buf parameter 104 | */ 105 | char *av_timecode_make_mpeg_tc_string(char *buf, uint32_t tc25bit); 106 | 107 | /** 108 | * Init a timecode struct with the passed parameters. 109 | * 110 | * @param log_ctx a pointer to an arbitrary struct of which the first field 111 | * is a pointer to an AVClass struct (used for av_log) 112 | * @param tc pointer to an allocated AVTimecode 113 | * @param rate frame rate in rational form 114 | * @param flags miscellaneous flags such as drop frame, +24 hours, ... 115 | * (see AVTimecodeFlag) 116 | * @param frame_start the first frame number 117 | * @return 0 on success, AVERROR otherwise 118 | */ 119 | int av_timecode_init(AVTimecode *tc, AVRational rate, int flags, int frame_start, void *log_ctx); 120 | 121 | /** 122 | * Parse timecode representation (hh:mm:ss[:;.]ff). 123 | * 124 | * @param log_ctx a pointer to an arbitrary struct of which the first field is a 125 | * pointer to an AVClass struct (used for av_log). 126 | * @param tc pointer to an allocated AVTimecode 127 | * @param rate frame rate in rational form 128 | * @param str timecode string which will determine the frame start 129 | * @return 0 on success, AVERROR otherwise 130 | */ 131 | int av_timecode_init_from_string(AVTimecode *tc, AVRational rate, const char *str, void *log_ctx); 132 | 133 | /** 134 | * Check if the timecode feature is available for the given frame rate 135 | * 136 | * @return 0 if supported, <0 otherwise 137 | */ 138 | int av_timecode_check_frame_rate(AVRational rate); 139 | 140 | #endif /* AVUTIL_TIMECODE_H */ 141 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/timestamp.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of FFmpeg. 3 | * 4 | * FFmpeg is free software; you can redistribute it and/or 5 | * modify it under the terms of the GNU Lesser General Public 6 | * License as published by the Free Software Foundation; either 7 | * version 2.1 of the License, or (at your option) any later version. 8 | * 9 | * FFmpeg is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | * Lesser General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU Lesser General Public 15 | * License along with FFmpeg; if not, write to the Free Software 16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 17 | */ 18 | 19 | /** 20 | * @file 21 | * timestamp utils, mostly useful for debugging/logging purposes 22 | */ 23 | 24 | #ifndef AVUTIL_TIMESTAMP_H 25 | #define AVUTIL_TIMESTAMP_H 26 | 27 | #include "common.h" 28 | 29 | #if defined(__cplusplus) && !defined(__STDC_FORMAT_MACROS) && !defined(PRId64) 30 | #error missing -D__STDC_FORMAT_MACROS / #define __STDC_FORMAT_MACROS 31 | #endif 32 | 33 | #define AV_TS_MAX_STRING_SIZE 32 34 | 35 | /** 36 | * Fill the provided buffer with a string containing a timestamp 37 | * representation. 38 | * 39 | * @param buf a buffer with size in bytes of at least AV_TS_MAX_STRING_SIZE 40 | * @param ts the timestamp to represent 41 | * @return the buffer in input 42 | */ 43 | static inline char *av_ts_make_string(char *buf, int64_t ts) 44 | { 45 | if (ts == AV_NOPTS_VALUE) snprintf(buf, AV_TS_MAX_STRING_SIZE, "NOPTS"); 46 | else snprintf(buf, AV_TS_MAX_STRING_SIZE, "%"PRId64, ts); 47 | return buf; 48 | } 49 | 50 | /** 51 | * Convenience macro, the return value should be used only directly in 52 | * function arguments but never stand-alone. 53 | */ 54 | #define av_ts2str(ts) av_ts_make_string((char[AV_TS_MAX_STRING_SIZE]){0}, ts) 55 | 56 | /** 57 | * Fill the provided buffer with a string containing a timestamp time 58 | * representation. 59 | * 60 | * @param buf a buffer with size in bytes of at least AV_TS_MAX_STRING_SIZE 61 | * @param ts the timestamp to represent 62 | * @param tb the timebase of the timestamp 63 | * @return the buffer in input 64 | */ 65 | static inline char *av_ts_make_time_string(char *buf, int64_t ts, AVRational *tb) 66 | { 67 | if (ts == AV_NOPTS_VALUE) snprintf(buf, AV_TS_MAX_STRING_SIZE, "NOPTS"); 68 | else snprintf(buf, AV_TS_MAX_STRING_SIZE, "%.6g", av_q2d(*tb) * ts); 69 | return buf; 70 | } 71 | 72 | /** 73 | * Convenience macro, the return value should be used only directly in 74 | * function arguments but never stand-alone. 75 | */ 76 | #define av_ts2timestr(ts, tb) av_ts_make_time_string((char[AV_TS_MAX_STRING_SIZE]){0}, ts, tb) 77 | 78 | #endif /* AVUTIL_TIMESTAMP_H */ 79 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/twofish.h: -------------------------------------------------------------------------------- 1 | /* 2 | * An implementation of the TwoFish algorithm 3 | * Copyright (c) 2015 Supraja Meedinti 4 | * 5 | * This file is part of FFmpeg. 6 | * 7 | * FFmpeg is free software; you can redistribute it and/or 8 | * modify it under the terms of the GNU Lesser General Public 9 | * License as published by the Free Software Foundation; either 10 | * version 2.1 of the License, or (at your option) any later version. 11 | * 12 | * FFmpeg is distributed in the hope that it will be useful, 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 | * Lesser General Public License for more details. 16 | * 17 | * You should have received a copy of the GNU Lesser General Public 18 | * License along with FFmpeg; if not, write to the Free Software 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 | */ 21 | 22 | #ifndef AVUTIL_TWOFISH_H 23 | #define AVUTIL_TWOFISH_H 24 | 25 | #include 26 | 27 | 28 | /** 29 | * @file 30 | * @brief Public header for libavutil TWOFISH algorithm 31 | * @defgroup lavu_twofish TWOFISH 32 | * @ingroup lavu_crypto 33 | * @{ 34 | */ 35 | 36 | extern const int av_twofish_size; 37 | 38 | struct AVTWOFISH; 39 | 40 | /** 41 | * Allocate an AVTWOFISH context 42 | * To free the struct: av_free(ptr) 43 | */ 44 | struct AVTWOFISH *av_twofish_alloc(void); 45 | 46 | /** 47 | * Initialize an AVTWOFISH context. 48 | * 49 | * @param ctx an AVTWOFISH context 50 | * @param key a key of size ranging from 1 to 32 bytes used for encryption/decryption 51 | * @param key_bits number of keybits: 128, 192, 256 If less than the required, padded with zeroes to nearest valid value; return value is 0 if key_bits is 128/192/256, -1 if less than 0, 1 otherwise 52 | */ 53 | int av_twofish_init(struct AVTWOFISH *ctx, const uint8_t *key, int key_bits); 54 | 55 | /** 56 | * Encrypt or decrypt a buffer using a previously initialized context 57 | * 58 | * @param ctx an AVTWOFISH context 59 | * @param dst destination array, can be equal to src 60 | * @param src source array, can be equal to dst 61 | * @param count number of 16 byte blocks 62 | * @paran iv initialization vector for CBC mode, NULL for ECB mode 63 | * @param decrypt 0 for encryption, 1 for decryption 64 | */ 65 | void av_twofish_crypt(struct AVTWOFISH *ctx, uint8_t *dst, const uint8_t *src, int count, uint8_t* iv, int decrypt); 66 | 67 | /** 68 | * @} 69 | */ 70 | #endif /* AVUTIL_TWOFISH_H */ 71 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/version.h: -------------------------------------------------------------------------------- 1 | /* 2 | * copyright (c) 2003 Fabrice Bellard 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef AVUTIL_VERSION_H 22 | #define AVUTIL_VERSION_H 23 | 24 | #include "macros.h" 25 | 26 | /** 27 | * @addtogroup version_utils 28 | * 29 | * Useful to check and match library version in order to maintain 30 | * backward compatibility. 31 | * 32 | * @{ 33 | */ 34 | 35 | #define AV_VERSION_INT(a, b, c) ((a)<<16 | (b)<<8 | (c)) 36 | #define AV_VERSION_DOT(a, b, c) a ##.## b ##.## c 37 | #define AV_VERSION(a, b, c) AV_VERSION_DOT(a, b, c) 38 | 39 | /** 40 | * @} 41 | */ 42 | 43 | /** 44 | * @file 45 | * @ingroup lavu 46 | * Libavutil version macros 47 | */ 48 | 49 | /** 50 | * @defgroup lavu_ver Version and Build diagnostics 51 | * 52 | * Macros and function useful to check at compiletime and at runtime 53 | * which version of libavutil is in use. 54 | * 55 | * @{ 56 | */ 57 | 58 | #define LIBAVUTIL_VERSION_MAJOR 54 59 | #define LIBAVUTIL_VERSION_MINOR 20 60 | #define LIBAVUTIL_VERSION_MICRO 100 61 | 62 | #define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \ 63 | LIBAVUTIL_VERSION_MINOR, \ 64 | LIBAVUTIL_VERSION_MICRO) 65 | #define LIBAVUTIL_VERSION AV_VERSION(LIBAVUTIL_VERSION_MAJOR, \ 66 | LIBAVUTIL_VERSION_MINOR, \ 67 | LIBAVUTIL_VERSION_MICRO) 68 | #define LIBAVUTIL_BUILD LIBAVUTIL_VERSION_INT 69 | 70 | #define LIBAVUTIL_IDENT "Lavu" AV_STRINGIFY(LIBAVUTIL_VERSION) 71 | 72 | /** 73 | * @} 74 | * 75 | * @defgroup depr_guards Deprecation guards 76 | * FF_API_* defines may be placed below to indicate public API that will be 77 | * dropped at a future version bump. The defines themselves are not part of 78 | * the public API and may change, break or disappear at any time. 79 | * 80 | * @{ 81 | */ 82 | 83 | #ifndef FF_API_OLD_AVOPTIONS 84 | #define FF_API_OLD_AVOPTIONS (LIBAVUTIL_VERSION_MAJOR < 55) 85 | #endif 86 | #ifndef FF_API_PIX_FMT 87 | #define FF_API_PIX_FMT (LIBAVUTIL_VERSION_MAJOR < 55) 88 | #endif 89 | #ifndef FF_API_CONTEXT_SIZE 90 | #define FF_API_CONTEXT_SIZE (LIBAVUTIL_VERSION_MAJOR < 55) 91 | #endif 92 | #ifndef FF_API_PIX_FMT_DESC 93 | #define FF_API_PIX_FMT_DESC (LIBAVUTIL_VERSION_MAJOR < 55) 94 | #endif 95 | #ifndef FF_API_AV_REVERSE 96 | #define FF_API_AV_REVERSE (LIBAVUTIL_VERSION_MAJOR < 55) 97 | #endif 98 | #ifndef FF_API_AUDIOCONVERT 99 | #define FF_API_AUDIOCONVERT (LIBAVUTIL_VERSION_MAJOR < 55) 100 | #endif 101 | #ifndef FF_API_CPU_FLAG_MMX2 102 | #define FF_API_CPU_FLAG_MMX2 (LIBAVUTIL_VERSION_MAJOR < 55) 103 | #endif 104 | #ifndef FF_API_LLS_PRIVATE 105 | #define FF_API_LLS_PRIVATE (LIBAVUTIL_VERSION_MAJOR < 55) 106 | #endif 107 | #ifndef FF_API_AVFRAME_LAVC 108 | #define FF_API_AVFRAME_LAVC (LIBAVUTIL_VERSION_MAJOR < 55) 109 | #endif 110 | #ifndef FF_API_VDPAU 111 | #define FF_API_VDPAU (LIBAVUTIL_VERSION_MAJOR < 55) 112 | #endif 113 | #ifndef FF_API_GET_CHANNEL_LAYOUT_COMPAT 114 | #define FF_API_GET_CHANNEL_LAYOUT_COMPAT (LIBAVUTIL_VERSION_MAJOR < 55) 115 | #endif 116 | #ifndef FF_API_XVMC 117 | #define FF_API_XVMC (LIBAVUTIL_VERSION_MAJOR < 55) 118 | #endif 119 | #ifndef FF_API_OPT_TYPE_METADATA 120 | #define FF_API_OPT_TYPE_METADATA (LIBAVUTIL_VERSION_MAJOR < 55) 121 | #endif 122 | 123 | #ifndef FF_CONST_AVUTIL55 124 | #if LIBAVUTIL_VERSION_MAJOR >= 55 125 | #define FF_CONST_AVUTIL55 const 126 | #else 127 | #define FF_CONST_AVUTIL55 128 | #endif 129 | #endif 130 | 131 | /** 132 | * @} 133 | */ 134 | 135 | #endif /* AVUTIL_VERSION_H */ 136 | 137 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libavutil/xtea.h: -------------------------------------------------------------------------------- 1 | /* 2 | * A 32-bit implementation of the XTEA algorithm 3 | * Copyright (c) 2012 Samuel Pitoiset 4 | * 5 | * This file is part of FFmpeg. 6 | * 7 | * FFmpeg is free software; you can redistribute it and/or 8 | * modify it under the terms of the GNU Lesser General Public 9 | * License as published by the Free Software Foundation; either 10 | * version 2.1 of the License, or (at your option) any later version. 11 | * 12 | * FFmpeg is distributed in the hope that it will be useful, 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 | * Lesser General Public License for more details. 16 | * 17 | * You should have received a copy of the GNU Lesser General Public 18 | * License along with FFmpeg; if not, write to the Free Software 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 | */ 21 | 22 | #ifndef AVUTIL_XTEA_H 23 | #define AVUTIL_XTEA_H 24 | 25 | #include 26 | 27 | /** 28 | * @file 29 | * @brief Public header for libavutil XTEA algorithm 30 | * @defgroup lavu_xtea XTEA 31 | * @ingroup lavu_crypto 32 | * @{ 33 | */ 34 | 35 | typedef struct AVXTEA { 36 | uint32_t key[16]; 37 | } AVXTEA; 38 | 39 | /** 40 | * Initialize an AVXTEA context. 41 | * 42 | * @param ctx an AVXTEA context 43 | * @param key a key of 16 bytes used for encryption/decryption 44 | */ 45 | void av_xtea_init(struct AVXTEA *ctx, const uint8_t key[16]); 46 | 47 | /** 48 | * Encrypt or decrypt a buffer using a previously initialized context. 49 | * 50 | * @param ctx an AVXTEA context 51 | * @param dst destination array, can be equal to src 52 | * @param src source array, can be equal to dst 53 | * @param count number of 8 byte blocks 54 | * @param iv initialization vector for CBC mode, if NULL then ECB will be used 55 | * @param decrypt 0 for encryption, 1 for decryption 56 | */ 57 | void av_xtea_crypt(struct AVXTEA *ctx, uint8_t *dst, const uint8_t *src, 58 | int count, uint8_t *iv, int decrypt); 59 | 60 | /** 61 | * @} 62 | */ 63 | 64 | #endif /* AVUTIL_XTEA_H */ 65 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libpostproc/postprocess.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2001-2003 Michael Niedermayer (michaelni@gmx.at) 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or modify 7 | * it under the terms of the GNU General Public License as published by 8 | * the Free Software Foundation; either version 2 of the License, or 9 | * (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | * GNU General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU General Public License 17 | * along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef POSTPROC_POSTPROCESS_H 22 | #define POSTPROC_POSTPROCESS_H 23 | 24 | /** 25 | * @file 26 | * @ingroup lpp 27 | * external API header 28 | */ 29 | 30 | /** 31 | * @defgroup lpp Libpostproc 32 | * @{ 33 | */ 34 | 35 | #include "libpostproc/version.h" 36 | 37 | /** 38 | * Return the LIBPOSTPROC_VERSION_INT constant. 39 | */ 40 | unsigned postproc_version(void); 41 | 42 | /** 43 | * Return the libpostproc build-time configuration. 44 | */ 45 | const char *postproc_configuration(void); 46 | 47 | /** 48 | * Return the libpostproc license. 49 | */ 50 | const char *postproc_license(void); 51 | 52 | #define PP_QUALITY_MAX 6 53 | 54 | #define QP_STORE_T int8_t 55 | 56 | #include 57 | 58 | typedef void pp_context; 59 | typedef void pp_mode; 60 | 61 | #if LIBPOSTPROC_VERSION_INT < (52<<16) 62 | typedef pp_context pp_context_t; 63 | typedef pp_mode pp_mode_t; 64 | extern const char *const pp_help; ///< a simple help text 65 | #else 66 | extern const char pp_help[]; ///< a simple help text 67 | #endif 68 | 69 | void pp_postprocess(const uint8_t * src[3], const int srcStride[3], 70 | uint8_t * dst[3], const int dstStride[3], 71 | int horizontalSize, int verticalSize, 72 | const QP_STORE_T *QP_store, int QP_stride, 73 | pp_mode *mode, pp_context *ppContext, int pict_type); 74 | 75 | 76 | /** 77 | * Return a pp_mode or NULL if an error occurred. 78 | * 79 | * @param name the string after "-pp" on the command line 80 | * @param quality a number from 0 to PP_QUALITY_MAX 81 | */ 82 | pp_mode *pp_get_mode_by_name_and_quality(const char *name, int quality); 83 | void pp_free_mode(pp_mode *mode); 84 | 85 | pp_context *pp_get_context(int width, int height, int flags); 86 | void pp_free_context(pp_context *ppContext); 87 | 88 | #define PP_CPU_CAPS_MMX 0x80000000 89 | #define PP_CPU_CAPS_MMX2 0x20000000 90 | #define PP_CPU_CAPS_3DNOW 0x40000000 91 | #define PP_CPU_CAPS_ALTIVEC 0x10000000 92 | #define PP_CPU_CAPS_AUTO 0x00080000 93 | 94 | #define PP_FORMAT 0x00000008 95 | #define PP_FORMAT_420 (0x00000011|PP_FORMAT) 96 | #define PP_FORMAT_422 (0x00000001|PP_FORMAT) 97 | #define PP_FORMAT_411 (0x00000002|PP_FORMAT) 98 | #define PP_FORMAT_444 (0x00000000|PP_FORMAT) 99 | #define PP_FORMAT_440 (0x00000010|PP_FORMAT) 100 | 101 | #define PP_PICT_TYPE_QP2 0x00000010 ///< MPEG2 style QScale 102 | 103 | /** 104 | * @} 105 | */ 106 | 107 | #endif /* POSTPROC_POSTPROCESS_H */ 108 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libpostproc/version.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Version macros. 3 | * 4 | * This file is part of FFmpeg. 5 | * 6 | * FFmpeg is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * FFmpeg is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with FFmpeg; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef POSTPROC_POSTPROCESS_VERSION_H 22 | #define POSTPROC_POSTPROCESS_VERSION_H 23 | 24 | /** 25 | * @file 26 | * Libpostproc version macros 27 | */ 28 | 29 | #include "libavutil/avutil.h" 30 | 31 | #define LIBPOSTPROC_VERSION_MAJOR 53 32 | #define LIBPOSTPROC_VERSION_MINOR 3 33 | #define LIBPOSTPROC_VERSION_MICRO 100 34 | 35 | #define LIBPOSTPROC_VERSION_INT AV_VERSION_INT(LIBPOSTPROC_VERSION_MAJOR, \ 36 | LIBPOSTPROC_VERSION_MINOR, \ 37 | LIBPOSTPROC_VERSION_MICRO) 38 | #define LIBPOSTPROC_VERSION AV_VERSION(LIBPOSTPROC_VERSION_MAJOR, \ 39 | LIBPOSTPROC_VERSION_MINOR, \ 40 | LIBPOSTPROC_VERSION_MICRO) 41 | #define LIBPOSTPROC_BUILD LIBPOSTPROC_VERSION_INT 42 | 43 | #define LIBPOSTPROC_IDENT "postproc" AV_STRINGIFY(LIBPOSTPROC_VERSION) 44 | 45 | #endif /* POSTPROC_POSTPROCESS_VERSION_H */ 46 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libswresample/version.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Version macros. 3 | * 4 | * This file is part of libswresample 5 | * 6 | * libswresample is free software; you can redistribute it and/or 7 | * modify it under the terms of the GNU Lesser General Public 8 | * License as published by the Free Software Foundation; either 9 | * version 2.1 of the License, or (at your option) any later version. 10 | * 11 | * libswresample is distributed in the hope that it will be useful, 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 | * Lesser General Public License for more details. 15 | * 16 | * You should have received a copy of the GNU Lesser General Public 17 | * License along with libswresample; if not, write to the Free Software 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 | */ 20 | 21 | #ifndef SWR_VERSION_H 22 | #define SWR_VERSION_H 23 | 24 | /** 25 | * @file 26 | * Libswresample version macros 27 | */ 28 | 29 | #include "libavutil/avutil.h" 30 | 31 | #define LIBSWRESAMPLE_VERSION_MAJOR 1 32 | #define LIBSWRESAMPLE_VERSION_MINOR 1 33 | #define LIBSWRESAMPLE_VERSION_MICRO 100 34 | 35 | #define LIBSWRESAMPLE_VERSION_INT AV_VERSION_INT(LIBSWRESAMPLE_VERSION_MAJOR, \ 36 | LIBSWRESAMPLE_VERSION_MINOR, \ 37 | LIBSWRESAMPLE_VERSION_MICRO) 38 | #define LIBSWRESAMPLE_VERSION AV_VERSION(LIBSWRESAMPLE_VERSION_MAJOR, \ 39 | LIBSWRESAMPLE_VERSION_MINOR, \ 40 | LIBSWRESAMPLE_VERSION_MICRO) 41 | #define LIBSWRESAMPLE_BUILD LIBSWRESAMPLE_VERSION_INT 42 | 43 | #define LIBSWRESAMPLE_IDENT "SwR" AV_STRINGIFY(LIBSWRESAMPLE_VERSION) 44 | 45 | #endif /* SWR_VERSION_H */ 46 | -------------------------------------------------------------------------------- /ffmpegdemo/app/libs/include/libswscale/version.h: -------------------------------------------------------------------------------- 1 | /* 2 | * This file is part of FFmpeg. 3 | * 4 | * FFmpeg is free software; you can redistribute it and/or 5 | * modify it under the terms of the GNU Lesser General Public 6 | * License as published by the Free Software Foundation; either 7 | * version 2.1 of the License, or (at your option) any later version. 8 | * 9 | * FFmpeg is distributed in the hope that it will be useful, 10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 | * Lesser General Public License for more details. 13 | * 14 | * You should have received a copy of the GNU Lesser General Public 15 | * License along with FFmpeg; if not, write to the Free Software 16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 17 | */ 18 | 19 | #ifndef SWSCALE_VERSION_H 20 | #define SWSCALE_VERSION_H 21 | 22 | /** 23 | * @file 24 | * swscale version macros 25 | */ 26 | 27 | #include "libavutil/version.h" 28 | 29 | #define LIBSWSCALE_VERSION_MAJOR 3 30 | #define LIBSWSCALE_VERSION_MINOR 1 31 | #define LIBSWSCALE_VERSION_MICRO 101 32 | 33 | #define LIBSWSCALE_VERSION_INT AV_VERSION_INT(LIBSWSCALE_VERSION_MAJOR, \ 34 | LIBSWSCALE_VERSION_MINOR, \ 35 | LIBSWSCALE_VERSION_MICRO) 36 | #define LIBSWSCALE_VERSION AV_VERSION(LIBSWSCALE_VERSION_MAJOR, \ 37 | LIBSWSCALE_VERSION_MINOR, \ 38 | LIBSWSCALE_VERSION_MICRO) 39 | #define LIBSWSCALE_BUILD LIBSWSCALE_VERSION_INT 40 | 41 | #define LIBSWSCALE_IDENT "SwS" AV_STRINGIFY(LIBSWSCALE_VERSION) 42 | 43 | /** 44 | * FF_API_* defines may be placed below to indicate public API that will be 45 | * dropped at a future version bump. The defines themselves are not part of 46 | * the public API and may change, break or disappear at any time. 47 | */ 48 | 49 | #ifndef FF_API_SWS_CPU_CAPS 50 | #define FF_API_SWS_CPU_CAPS (LIBSWSCALE_VERSION_MAJOR < 4) 51 | #endif 52 | #ifndef FF_API_ARCH_BFIN 53 | #define FF_API_ARCH_BFIN (LIBSWSCALE_VERSION_MAJOR < 4) 54 | #endif 55 | 56 | #endif /* SWSCALE_VERSION_H */ 57 | -------------------------------------------------------------------------------- /ffmpegdemo/app/proguard-rules.pro: -------------------------------------------------------------------------------- 1 | # Add project specific ProGuard rules here. 2 | # You can control the set of applied configuration files using the 3 | # proguardFiles setting in build.gradle. 4 | # 5 | # For more details, see 6 | # http://developer.android.com/guide/developing/tools/proguard.html 7 | 8 | # If your project uses WebView with JS, uncomment the following 9 | # and specify the fully qualified class name to the JavaScript interface 10 | # class: 11 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview { 12 | # public *; 13 | #} 14 | 15 | # Uncomment this to preserve the line number information for 16 | # debugging stack traces. 17 | #-keepattributes SourceFile,LineNumberTable 18 | 19 | # If you keep the line number information, uncomment this to 20 | # hide the original source file name. 21 | #-renamesourcefileattribute SourceFile 22 | -------------------------------------------------------------------------------- /ffmpegdemo/app/src/androidTest/java/com/jinhe/ffmpegdemo/ExampleInstrumentedTest.kt: -------------------------------------------------------------------------------- 1 | package com.jinhe.ffmpegdemo 2 | 3 | import android.support.test.InstrumentationRegistry 4 | import android.support.test.runner.AndroidJUnit4 5 | 6 | import org.junit.Test 7 | import org.junit.runner.RunWith 8 | 9 | import org.junit.Assert.* 10 | 11 | /** 12 | * Instrumented test, which will execute on an Android device. 13 | * 14 | * See [testing documentation](http://d.android.com/tools/testing). 15 | */ 16 | @RunWith(AndroidJUnit4::class) 17 | class ExampleInstrumentedTest { 18 | @Test 19 | fun useAppContext() { 20 | // Context of the app under test. 21 | val appContext = InstrumentationRegistry.getTargetContext() 22 | assertEquals("com.jinhe.ffmpegdemo", appContext.packageName) 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /ffmpegdemo/app/src/main/AndroidManifest.xml: -------------------------------------------------------------------------------- 1 | 2 | 4 | 5 | 6 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | -------------------------------------------------------------------------------- /ffmpegdemo/app/src/main/cpp/native-lib.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | extern "C"{ 6 | //编码 7 | #include "libavcodec/avcodec.h" 8 | //封装格式处理 9 | #include "libavformat/avformat.h" 10 | //像素处理 11 | #include "libswscale/swscale.h" 12 | #include 13 | #include 14 | } 15 | 16 | 17 | #define LOGE(FORMAT, ...) __android_log_print(ANDROID_LOG_ERROR,"LC",FORMAT,##__VA_ARGS__); 18 | extern "C" 19 | JNIEXPORT void JNICALL 20 | Java_com_jinhe_ffmpegdemo_VideoView_render(JNIEnv *env, jobject obj, jstring inputStr_, 21 | jobject surface) { 22 | 23 | const char *inputPath = env->GetStringUTFChars(inputStr_, false); 24 | //注册各大组件 25 | LOGE("注册成功") 26 | AVFormatContext *avFormatContext = avformat_alloc_context();//获取上下文 27 | int error; 28 | char buf[] = ""; 29 | //打开视频地址并获取里面的内容(解封装) 30 | if (error = avformat_open_input(&avFormatContext, inputPath, NULL, NULL) < 0) { 31 | av_strerror(error, buf, 1024); 32 | // LOGE("%s" ,inputPath) 33 | LOGE("Couldn't open file %s: %d(%s)", inputPath, error, buf); 34 | // LOGE("%d",error) 35 | LOGE("打开视频失败") 36 | return; 37 | } 38 | if (avformat_find_stream_info(avFormatContext, NULL) < 0) { 39 | LOGE("获取内容失败") 40 | return; 41 | } 42 | //获取到整个内容过后找到里面的视频流 43 | int video_index=-1; 44 | for (int i = 0; i < avFormatContext->nb_streams; ++i) { 45 | if (avFormatContext->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) { 46 | //如果是视频流,标记一哈 47 | video_index = i; 48 | } 49 | } 50 | LOGE("成功找到视频流") 51 | //对视频流进行解码 52 | //获取解码器上下文 53 | AVCodecContext *avCodecContext = avFormatContext->streams[video_index]->codec; 54 | //获取解码器 55 | AVCodec *avCodec = avcodec_find_decoder(avCodecContext->codec_id); 56 | //打开解码器 57 | if (avcodec_open2(avCodecContext, avCodec, NULL) < 0) { 58 | LOGE("打开失败") 59 | return; 60 | } 61 | 62 | //申请AVPacket 63 | AVPacket *packet = (AVPacket *) av_malloc(sizeof(AVPacket)); 64 | av_init_packet(packet); 65 | //申请AVFrame 66 | AVFrame *frame = av_frame_alloc();//分配一个AVFrame结构体,AVFrame结构体一般用于存储原始数据，指向解码后的原始帧 67 | AVFrame *rgb_frame = av_frame_alloc();//分配一个AVFrame结构体，指向存放转换成rgb后的帧 68 | //输出文件 69 | //FILE *fp = fopen(outputPath,"wb"); 70 | 71 | 72 | //缓存区 73 | uint8_t *out_buffer= (uint8_t *)av_malloc(avpicture_get_size(AV_PIX_FMT_RGBA, 74 | avCodecContext->width,avCodecContext->height)); 75 | //与缓存区相关联，设置rgb_frame缓存区 76 | avpicture_fill((AVPicture *)rgb_frame,out_buffer,AV_PIX_FMT_RGBA,avCodecContext->width,avCodecContext->height); 77 | 78 | 79 | SwsContext* swsContext = sws_getContext(avCodecContext->width,avCodecContext->height,avCodecContext->pix_fmt, 80 | avCodecContext->width,avCodecContext->height,AV_PIX_FMT_RGBA, 81 | SWS_BICUBIC,NULL,NULL,NULL); 82 | 83 | //取到nativewindow 84 | ANativeWindow *nativeWindow=ANativeWindow_fromSurface(env,surface); 85 | if(nativeWindow==0){ 86 | LOGE("nativewindow取到失败") 87 | return; 88 | } 89 | //视频缓冲区 90 | ANativeWindow_Buffer native_outBuffer; 91 | 92 | 93 | int frameCount; 94 | int h =0; 95 | LOGE("解码 ") 96 | while (av_read_frame(avFormatContext, packet) >= 0) { 97 | LOGE("解码 %d",packet->stream_index) 98 | LOGE("VINDEX %d",video_index) 99 | if(packet->stream_index==video_index){ 100 | LOGE("解码 hhhhh") 101 | //如果是视频流 102 | //解码 103 | avcodec_decode_video2(avCodecContext, frame, &frameCount, packet); 104 | LOGE("解码中.... %d",frameCount) 105 | if (frameCount) { 106 | LOGE("转换并绘制") 107 | //说明有内容 108 | //绘制之前配置nativewindow 109 | ANativeWindow_setBuffersGeometry(nativeWindow,avCodecContext->width,avCodecContext->height,WINDOW_FORMAT_RGBA_8888); 110 | //上锁 111 | ANativeWindow_lock(nativeWindow, &native_outBuffer, NULL); 112 | //转换为rgb格式 113 | sws_scale(swsContext,(const uint8_t *const *)frame->data,frame->linesize,0, 114 | frame->height,rgb_frame->data, 115 | rgb_frame->linesize); 116 | // rgb_frame是有画面数据 117 | uint8_t *dst= (uint8_t *) native_outBuffer.bits; 118 | // 拿到一行有多少个字节 RGBA 119 | int destStride=native_outBuffer.stride*4; 120 | //像素数据的首地址 121 | uint8_t * src= rgb_frame->data[0]; 122 | // 实际内存一行数量 123 | int srcStride = rgb_frame->linesize[0]; 124 | //int i=0; 125 | for (int i = 0; i < avCodecContext->height; ++i) { 126 | // memcpy(void *dest, const void *src, size_t n) 127 | //将rgb_frame中每一行的数据复制给nativewindow 128 | memcpy(dst + i * destStride, src + i * srcStride, srcStride); 129 | } 130 | //解锁 131 | ANativeWindow_unlockAndPost(nativeWindow); 132 | usleep(1000 * 16); 133 | 134 | } 135 | } 136 | av_free_packet(packet); 137 | } 138 | //释放 139 | ANativeWindow_release(nativeWindow); 140 | av_frame_free(&frame); 141 | av_frame_free(&rgb_frame); 142 | avcodec_close(avCodecContext); 143 | avformat_free_context(avFormatContext); 144 | env->ReleaseStringUTFChars(inputStr_, inputPath); 145 | 146 | } -------------------------------------------------------------------------------- /ffmpegdemo/app/src/main/java/com/jinhe/ffmpegdemo/MainActivity.kt: -------------------------------------------------------------------------------- 1 | package com.jinhe.ffmpegdemo 2 | 3 | import android.support.v7.app.AppCompatActivity 4 | import android.os.Bundle 5 | import android.os.Environment 6 | import android.widget.Toast 7 | import kotlinx.android.synthetic.main.activity_main.* 8 | import java.io.File 9 | 10 | class MainActivity : AppCompatActivity() { 11 | 12 | 13 | val input = File(Environment.getExternalStorageDirectory(), "input.mp4").absolutePath!! 14 | //val output = File(Environment.getExternalStorageDirectory(), "output.yuv").absolutePath!! 15 | 16 | override fun onCreate(savedInstanceState: Bundle?) { 17 | super.onCreate(savedInstanceState) 18 | setContentView(R.layout.activity_main) 19 | //Toast.makeText(this,"input"+input,Toast.LENGTH_SHORT).show() 20 | //open(input,output) 21 | //VideoView 22 | play.setOnClickListener { videoView.player(input) } 23 | 24 | } 25 | 26 | 27 | //external fun open(input:String,output:String) 28 | 29 | 30 | } 31 | -------------------------------------------------------------------------------- /ffmpegdemo/app/src/main/java/com/jinhe/ffmpegdemo/VideoView.kt: -------------------------------------------------------------------------------- 1 | package com.jinhe.ffmpegdemo 2 | 3 | import android.content.Context 4 | import android.graphics.PixelFormat 5 | import android.util.AttributeSet 6 | import android.util.Log 7 | import android.view.Surface 8 | import android.view.SurfaceView 9 | import android.widget.Toast 10 | 11 | /** 12 | * Created by LC on 2017/11/8. 13 | */ 14 | 15 | class VideoView : SurfaceView { 16 | constructor(context: Context) : super(context) {} 17 | 18 | constructor(context: Context, attrs: AttributeSet) : super(context, attrs) { 19 | init() 20 | 21 | } 22 | 23 | private fun init() { 24 | val holder = holder 25 | holder.setFormat(PixelFormat.RGBA_8888) 26 | } 27 | 28 | constructor(context: Context, attrs: AttributeSet, defStyleAttr: Int) : super(context, attrs, defStyleAttr) {} 29 | 30 | fun player(input: String) { 31 | Thread(Runnable { 32 | // 绘制功能 不需要交给SurfaveView VideoView.this.getHolder().getSurface() 33 | render(input, this@VideoView.holder.surface) 34 | }).start() 35 | } 36 | 37 | external fun render(input: String, surface: Surface) 38 | 39 | companion object { 40 | init { 41 | System.loadLibrary("avcodec-56") 42 | System.loadLibrary("avdevice-56") 43 | System.loadLibrary("avfilter-5") 44 | System.loadLibrary("avformat-56") 45 | System.loadLibrary("avutil-54") 46 | System.loadLibrary("postproc-53") 47 | System.loadLibrary("swresample-1") 48 | System.loadLibrary("swscale-3") 49 | System.loadLibrary("native-lib") 50 | } 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /ffmpegdemo/app/src/main/res/drawable-v24/ic_launcher_foreground.xml: -------------------------------------------------------------------------------- 1 | 7 | 12 | 13 | 19 | 22 | 25 | 26 | 27 | 28 | 34 | 35 | -------------------------------------------------------------------------------- /ffmpegdemo/app/src/main/res/layout/activity_main.xml: -------------------------------------------------------------------------------- 1 | 2 | 6 | 7 |