├── .gitignore ├── README.md ├── ffmpeg_0.8.10_without_dolby └── FFEngine.framework │ ├── FFEngine │ └── Headers │ ├── ELMediaPlayerSDK.h │ ├── ELMediaUtil.h │ ├── FFEngine.h │ └── IELMediaPlayer.h └── ffmpeg_1.0_without_dolby ├── FFEngine.framework ├── FFEngine └── Headers │ ├── ELMediaPlayerSDK.h │ ├── ELMediaUtil.h │ ├── FFEngine.h │ └── IELMediaPlayer.h └── FFmpeg.framework ├── FFmpeg └── Headers ├── FFmpeg.h ├── libavcodec ├── audioconvert.h ├── avcodec.h ├── avfft.h ├── dxva2.h ├── old_codec_ids.h ├── vaapi.h ├── vda.h ├── vdpau.h ├── version.h └── xvmc.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 ├── common.h ├── cpu.h ├── crc.h ├── dict.h ├── error.h ├── eval.h ├── fifo.h ├── file.h ├── imgutils.h ├── intfloat.h ├── intfloat_readwrite.h ├── intreadwrite.h ├── lfg.h ├── log.h ├── lzo.h ├── mathematics.h ├── md5.h ├── mem.h ├── opt.h ├── parseutils.h ├── pixdesc.h ├── pixfmt.h ├── random_seed.h ├── rational.h ├── samplefmt.h ├── sha.h ├── time.h ├── timecode.h ├── timestamp.h ├── version.h └── xtea.h ├── libswresample └── swresample.h └── libswscale ├── swscale.h └── version.h /.gitignore: -------------------------------------------------------------------------------- 1 | 2 | .DS_Store 3 | 4 | project.xcworkspace 5 | 6 | xcuserdata 7 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | FFEngine.framework 2 | ================== 3 | 4 | FFEngine framework is a high performance player sdk for iOS based on ffmpeg. 5 | 6 | 7 | ffengine is free now 8 | ================== 9 | Please get the source code at: 10 | https://github.com/ffengine/libffengine 11 | 12 | 13 | NOTICE 14 | ================== 15 | 1. If your app is free, you may use FFEngine.framework as free with the register key between [[[ and ]]]: 16 | [[[yQ2oiBQRbXoo35veDico9lNUP9V/jbmLAso2PSgcLxyg7LfjrCSv+VrRNBQ3t5RrPvxcVussCXAX8gLxlVkYyXVfLcNVilpP0MvBkARKP8Y=]]] 17 | 18 | If you think it's useful for you, please donate to us, paypal: xiewei.max@gmail.com . 19 | 20 | 2. Source code is for sell. 21 | 22 | 3. Thanks again! 23 | 24 | -------------------------------------------------------------------------------- /ffmpeg_0.8.10_without_dolby/FFEngine.framework/FFEngine: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiewei-wayne/FFEngine.framework/7ddf2b8d5c6085160986d6d89025900c5c39c5a9/ffmpeg_0.8.10_without_dolby/FFEngine.framework/FFEngine -------------------------------------------------------------------------------- /ffmpeg_0.8.10_without_dolby/FFEngine.framework/Headers/ELMediaPlayerSDK.h: -------------------------------------------------------------------------------- 1 | // 2 | // Created by xiewei.max@gmail.com on 11-10-01. 3 | // Copyright (c) 2012年 www.e-linkway.com. All rights reserved. 4 | // 5 | 6 | #import "IELMediaPlayer.h" 7 | 8 | @protocol IELMediaPlayer; 9 | 10 | // 注册lib库,在调用任何其他操作前调用 : 0: 成功; 1:注册码错误; 11 | int registerLib(char * registerCode); 12 | 13 | // 获取MediaPlayer接口 14 | id loadELMediaPlayer(); 15 | 16 | // 释放mediaPlayer, 调用loadELMediaPlayer之后释放 17 | void releaseELMediaPlayer(); 18 | -------------------------------------------------------------------------------- /ffmpeg_0.8.10_without_dolby/FFEngine.framework/Headers/ELMediaUtil.h: -------------------------------------------------------------------------------- 1 | // 2 | // ELMediaUtil.h 3 | // ELMediaLib 4 | // 5 | // Created by Wei Xie on 12-7-11. 6 | // Copyright (c) 2012年 __MyCompanyName__. All rights reserved. 7 | // 8 | 9 | #import 10 | 11 | // Advanced Version 12 | @interface ELMediaUtil : NSObject // 13 | 14 | +(NSDictionary *) getMediaDescription: (NSString *) mediaPath; 15 | 16 | +(NSData *) thumbnailPNGDataWithVideoPath: (NSString *) videoPath; 17 | 18 | @end 19 | -------------------------------------------------------------------------------- /ffmpeg_0.8.10_without_dolby/FFEngine.framework/Headers/FFEngine.h: -------------------------------------------------------------------------------- 1 | // 2 | // Created by xiewei.max@gmail.com on 11-10-01. 3 | // Copyright (c) 2012年 www.e-linkway.com. All rights reserved. 4 | // 5 | 6 | #import 7 | 8 | #import "IELMediaPlayer.h" 9 | #import "ELMediaPlayerSDK.h" 10 | #import "ELMediaUtil.h" -------------------------------------------------------------------------------- /ffmpeg_0.8.10_without_dolby/FFEngine.framework/Headers/IELMediaPlayer.h: -------------------------------------------------------------------------------- 1 | // 2 | // Created by xiewei.max@gmail.com on 11-10-01. 3 | // Copyright (c) 2012年 www.e-linkway.com. All rights reserved. 4 | // 5 | 6 | #import 7 | 8 | #ifndef IELMeidaPlayer_H 9 | #define IELMeidaPlayer_H 10 | 11 | typedef enum ELScreenType_e 12 | { 13 | ELScreenType_ASPECT_FULL_SCR = 0, 14 | ELScreenType_FULL_SCR, 15 | ELScreenType_ORIGINAL_SCR 16 | }ELScreenType_e; 17 | 18 | 19 | @protocol ELPlayerMessageProtocol; 20 | 21 | @protocol IELMediaPlayer 22 | 23 | -(void) setDelegate:(id)delegate; 24 | 25 | - (void)setVideoContainerView:(UIView *)containerView; 26 | - (void)setPlayerScreenType:(ELScreenType_e ) screenType; 27 | - (void)refreshViewFrame; 28 | 29 | - (void)setAutoPlayAfterOpen:(BOOL) autoPlay; 30 | 31 | - (BOOL)openMedia:(NSString *)path; 32 | - (BOOL)openMedia:(NSString *)path seekTo:(size_t)time; 33 | 34 | - (BOOL)closeMedia; 35 | 36 | - (void)startPlay; 37 | - (void)stopPlay; 38 | 39 | - (void)pausePlay; 40 | - (void)resumePlay; 41 | 42 | - (size_t)seekTo:(size_t)pos; 43 | 44 | @end 45 | 46 | @protocol ELPlayerMessageProtocol 47 | 48 | @optional 49 | 50 | - (void)openOk; 51 | - (void)openFailed; 52 | 53 | - (void)bufferingStart; 54 | - (void)bufferPercent:(int)percentage; 55 | 56 | - (void)readyToPlay; 57 | 58 | - (void)mediaDuration:(size_t)duration; 59 | - (void)mediaPosition:(size_t)position; 60 | - (void)mediaWidth: (size_t) width height: (size_t) height; 61 | 62 | - (void)playToEnd; 63 | 64 | @end 65 | 66 | #endif 67 | 68 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFEngine.framework/FFEngine: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiewei-wayne/FFEngine.framework/7ddf2b8d5c6085160986d6d89025900c5c39c5a9/ffmpeg_1.0_without_dolby/FFEngine.framework/FFEngine -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFEngine.framework/Headers/ELMediaPlayerSDK.h: -------------------------------------------------------------------------------- 1 | // 2 | // Created by xiewei.max@gmail.com on 11-10-01. 3 | // Copyright (c) 2012年 www.e-linkway.com. All rights reserved. 4 | // 5 | 6 | #import "IELMediaPlayer.h" 7 | 8 | @protocol IELMediaPlayer; 9 | 10 | // 注册lib库,在调用任何其他操作前调用 : 0: 成功; 1:注册码错误; 11 | int RegisterFFEngine(NSString *registerCode); 12 | 13 | // 获取MediaPlayer接口 14 | id loadELMediaPlayer(); 15 | 16 | // 释放mediaPlayer, 调用loadELMediaPlayer之后释放 17 | void releaseELMediaPlayer(); 18 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFEngine.framework/Headers/ELMediaUtil.h: -------------------------------------------------------------------------------- 1 | // 2 | // ELMediaUtil.h 3 | // ELMediaLib 4 | // 5 | // Created by Wei Xie on 12-7-11. 6 | // Copyright (c) 2012年 __MyCompanyName__. All rights reserved. 7 | // 8 | 9 | #import 10 | 11 | // Advanced Version 12 | @interface ELMediaUtil : NSObject // 13 | 14 | +(NSDictionary *) getMediaDescription: (NSString *) mediaPath; 15 | 16 | +(NSData *) thumbnailPNGDataWithVideoPath: (NSString *) videoPath; 17 | 18 | @end 19 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFEngine.framework/Headers/FFEngine.h: -------------------------------------------------------------------------------- 1 | // 2 | // Created by xiewei.max@gmail.com on 11-10-01. 3 | // Copyright (c) 2012年 www.e-linkway.com. All rights reserved. 4 | // 5 | 6 | #import 7 | 8 | #import "IELMediaPlayer.h" 9 | #import "ELMediaPlayerSDK.h" 10 | #import "ELMediaUtil.h" -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFEngine.framework/Headers/IELMediaPlayer.h: -------------------------------------------------------------------------------- 1 | // 2 | // Created by xiewei.max@gmail.com on 11-10-01. 3 | // Copyright (c) 2012年 www.e-linkway.com. All rights reserved. 4 | // 5 | 6 | #import 7 | 8 | #ifndef IELMeidaPlayer_H 9 | #define IELMeidaPlayer_H 10 | 11 | typedef enum ELScreenType_e 12 | { 13 | ELScreenType_ASPECT_FULL_SCR = 0, 14 | ELScreenType_FULL_SCR, 15 | ELScreenType_ORIGINAL_SCR 16 | }ELScreenType_e; 17 | 18 | 19 | @protocol ELPlayerMessageProtocol; 20 | 21 | @protocol IELMediaPlayer 22 | 23 | @property (nonatomic, assign) BOOL shouldUpdateVideoPicture; // default: YES 24 | 25 | -(void) setDelegate:(id)delegate; 26 | 27 | - (void)setVideoContainerView:(UIView *)containerView; 28 | - (void)setPlayerScreenType:(ELScreenType_e ) screenType; 29 | - (void)refreshViewFrame; 30 | 31 | - (void)setAutoPlayAfterOpen:(BOOL) autoPlay; 32 | 33 | - (BOOL)openMedia:(NSString *)path; 34 | - (BOOL)openMedia:(NSString *)path seekTo:(size_t)time; 35 | 36 | - (BOOL)closeMedia; 37 | 38 | - (void)startPlay; 39 | - (void)stopPlay; 40 | 41 | - (void)pausePlay; 42 | - (void)resumePlay; 43 | 44 | - (size_t)seekTo:(size_t)pos; 45 | 46 | @end 47 | 48 | @protocol ELPlayerMessageProtocol 49 | 50 | @optional 51 | 52 | - (void)openOk; 53 | - (void)openFailed; 54 | 55 | - (void)bufferingStart; 56 | - (void)bufferPercent:(int)percentage; 57 | 58 | - (void)readyToPlay; 59 | 60 | - (void)mediaDuration:(size_t)duration; 61 | - (void)mediaPosition:(size_t)position; 62 | - (void)mediaWidth: (size_t) width height: (size_t) height; 63 | 64 | - (void)playToEnd; 65 | 66 | @end 67 | 68 | #endif 69 | 70 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/FFmpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xiewei-wayne/FFEngine.framework/7ddf2b8d5c6085160986d6d89025900c5c39c5a9/ffmpeg_1.0_without_dolby/FFmpeg.framework/FFmpeg -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/FFmpeg.h: -------------------------------------------------------------------------------- 1 | 2 | #import 3 | 4 | #import "libavformat/avformat.h" 5 | #import "libswscale/swscale.h" 6 | #import "libavcodec/avcodec.h" 7 | #import "libavutil/avutil.h" 8 | #import "libavcodec/audioconvert.h" 9 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/libavcodec/audioconvert.h: -------------------------------------------------------------------------------- 1 | /* 2 | * audio conversion 3 | * Copyright (c) 2006 Michael Niedermayer 4 | * Copyright (c) 2008 Peter Ross 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_AUDIOCONVERT_H 24 | #define AVCODEC_AUDIOCONVERT_H 25 | 26 | /** 27 | * @file 28 | * Audio format conversion routines 29 | */ 30 | 31 | 32 | #include "libavutil/cpu.h" 33 | #include "avcodec.h" 34 | #include "libavutil/audioconvert.h" 35 | 36 | struct AVAudioConvert; 37 | typedef struct AVAudioConvert AVAudioConvert; 38 | 39 | /** 40 | * Create an audio sample format converter context 41 | * @param out_fmt Output sample format 42 | * @param out_channels Number of output channels 43 | * @param in_fmt Input sample format 44 | * @param in_channels Number of input channels 45 | * @param[in] matrix Channel mixing matrix (of dimension in_channel*out_channels). Set to NULL to ignore. 46 | * @param flags See AV_CPU_FLAG_xx 47 | * @return NULL on error 48 | */ 49 | AVAudioConvert *av_audio_convert_alloc(enum AVSampleFormat out_fmt, int out_channels, 50 | enum AVSampleFormat in_fmt, int in_channels, 51 | const float *matrix, int flags); 52 | 53 | /** 54 | * Free audio sample format converter context 55 | */ 56 | void av_audio_convert_free(AVAudioConvert *ctx); 57 | 58 | /** 59 | * Convert between audio sample formats 60 | * @param[in] out array of output buffers for each channel. set to NULL to ignore processing of the given channel. 61 | * @param[in] out_stride distance between consecutive output samples (measured in bytes) 62 | * @param[in] in array of input buffers for each channel 63 | * @param[in] in_stride distance between consecutive input samples (measured in bytes) 64 | * @param len length of audio frame size (measured in samples) 65 | */ 66 | int av_audio_convert(AVAudioConvert *ctx, 67 | void * const out[6], const int out_stride[6], 68 | const void * const in[6], const int in_stride[6], int len); 69 | 70 | #endif /* AVCODEC_AUDIOCONVERT_H */ 71 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 | * @param nbits size of the input array: 103 | * (1 << nbits) for DCT-II, DCT-III and DST-I 104 | * (1 << nbits) + 1 for DCT-I 105 | * 106 | * @note the first element of the input of DST-I is ignored 107 | */ 108 | DCTContext *av_dct_init(int nbits, enum DCTTransformType type); 109 | void av_dct_calc(DCTContext *s, FFTSample *data); 110 | void av_dct_end (DCTContext *s); 111 | 112 | /** 113 | * @} 114 | */ 115 | 116 | #endif /* AVCODEC_AVFFT_H */ 117 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 | #include 33 | 34 | #include 35 | #include 36 | 37 | /** 38 | * @defgroup lavc_codec_hwaccel_dxva2 DXVA2 39 | * @ingroup lavc_codec_hwaccel 40 | * 41 | * @{ 42 | */ 43 | 44 | #define FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG 1 ///< Work around for DXVA2 and old UVD/UVD+ ATI video cards 45 | 46 | /** 47 | * This structure is used to provides the necessary configurations and data 48 | * to the DXVA2 FFmpeg HWAccel implementation. 49 | * 50 | * The application must make it available as AVCodecContext.hwaccel_context. 51 | */ 52 | struct dxva_context { 53 | /** 54 | * DXVA2 decoder object 55 | */ 56 | IDirectXVideoDecoder *decoder; 57 | 58 | /** 59 | * DXVA2 configuration used to create the decoder 60 | */ 61 | const DXVA2_ConfigPictureDecode *cfg; 62 | 63 | /** 64 | * The number of surface in the surface array 65 | */ 66 | unsigned surface_count; 67 | 68 | /** 69 | * The array of Direct3D surfaces used to create the decoder 70 | */ 71 | LPDIRECT3DSURFACE9 *surface; 72 | 73 | /** 74 | * A bit field configuring the workarounds needed for using the decoder 75 | */ 76 | uint64_t workaround; 77 | 78 | /** 79 | * Private to the FFmpeg AVHWAccel implementation 80 | */ 81 | unsigned report_id; 82 | }; 83 | 84 | /** 85 | * @} 86 | */ 87 | 88 | #endif /* AVCODEC_DXVA_H */ 89 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/libavcodec/vda.h: -------------------------------------------------------------------------------- 1 | /* 2 | * VDA HW acceleration 3 | * 4 | * copyright (c) 2011 Sebastien Zwickert 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_VDA_H 24 | #define AVCODEC_VDA_H 25 | 26 | /** 27 | * @file 28 | * @ingroup lavc_codec_hwaccel_vda 29 | * Public libavcodec VDA header. 30 | */ 31 | 32 | #include "libavcodec/version.h" 33 | 34 | #if FF_API_VDA_ASYNC 35 | #include 36 | #endif 37 | 38 | #include 39 | 40 | // emmintrin.h is unable to compile with -std=c99 -Werror=missing-prototypes 41 | // http://openradar.appspot.com/8026390 42 | #undef __GNUC_STDC_INLINE__ 43 | 44 | #define Picture QuickdrawPicture 45 | #include 46 | #undef Picture 47 | 48 | /** 49 | * @defgroup lavc_codec_hwaccel_vda VDA 50 | * @ingroup lavc_codec_hwaccel 51 | * 52 | * @{ 53 | */ 54 | 55 | #if FF_API_VDA_ASYNC 56 | /** 57 | * This structure is used to store decoded frame information and data. 58 | * 59 | * @deprecated Use synchronous decoding mode. 60 | */ 61 | typedef struct { 62 | /** 63 | * The PTS of the frame. 64 | * 65 | * - encoding: unused 66 | * - decoding: Set/Unset by libavcodec. 67 | */ 68 | int64_t pts; 69 | 70 | /** 71 | * The CoreVideo buffer that contains the decoded data. 72 | * 73 | * - encoding: unused 74 | * - decoding: Set/Unset by libavcodec. 75 | */ 76 | CVPixelBufferRef cv_buffer; 77 | 78 | /** 79 | * A pointer to the next frame. 80 | * 81 | * - encoding: unused 82 | * - decoding: Set/Unset by libavcodec. 83 | */ 84 | struct vda_frame *next_frame; 85 | } vda_frame; 86 | #endif 87 | 88 | /** 89 | * This structure is used to provide the necessary configurations and data 90 | * to the VDA FFmpeg HWAccel implementation. 91 | * 92 | * The application must make it available as AVCodecContext.hwaccel_context. 93 | */ 94 | struct vda_context { 95 | /** 96 | * VDA decoder object. 97 | * 98 | * - encoding: unused 99 | * - decoding: Set/Unset by libavcodec. 100 | */ 101 | VDADecoder decoder; 102 | 103 | /** 104 | * The Core Video pixel buffer that contains the current image data. 105 | * 106 | * encoding: unused 107 | * decoding: Set by libavcodec. Unset by user. 108 | */ 109 | CVPixelBufferRef cv_buffer; 110 | 111 | /** 112 | * Use the hardware decoder in synchronous mode. 113 | * 114 | * encoding: unused 115 | * decoding: Set by user. 116 | */ 117 | int use_sync_decoding; 118 | 119 | #if FF_API_VDA_ASYNC 120 | /** 121 | * VDA frames queue ordered by presentation timestamp. 122 | * 123 | * @deprecated Use synchronous decoding mode. 124 | * 125 | * - encoding: unused 126 | * - decoding: Set/Unset by libavcodec. 127 | */ 128 | vda_frame *queue; 129 | 130 | /** 131 | * Mutex for locking queue operations. 132 | * 133 | * @deprecated Use synchronous decoding mode. 134 | * 135 | * - encoding: unused 136 | * - decoding: Set/Unset by libavcodec. 137 | */ 138 | pthread_mutex_t queue_mutex; 139 | #endif 140 | 141 | /** 142 | * The frame width. 143 | * 144 | * - encoding: unused 145 | * - decoding: Set/Unset by user. 146 | */ 147 | int width; 148 | 149 | /** 150 | * The frame height. 151 | * 152 | * - encoding: unused 153 | * - decoding: Set/Unset by user. 154 | */ 155 | int height; 156 | 157 | /** 158 | * The frame format. 159 | * 160 | * - encoding: unused 161 | * - decoding: Set/Unset by user. 162 | */ 163 | int format; 164 | 165 | /** 166 | * The pixel format for output image buffers. 167 | * 168 | * - encoding: unused 169 | * - decoding: Set/Unset by user. 170 | */ 171 | OSType cv_pix_fmt_type; 172 | 173 | /** 174 | * The current bitstream buffer. 175 | * 176 | * - encoding: unused 177 | * - decoding: Set/Unset by libavcodec. 178 | */ 179 | uint8_t *priv_bitstream; 180 | 181 | /** 182 | * The current size of the bitstream. 183 | * 184 | * - encoding: unused 185 | * - decoding: Set/Unset by libavcodec. 186 | */ 187 | int priv_bitstream_size; 188 | 189 | /** 190 | * The reference size used for fast reallocation. 191 | * 192 | * - encoding: unused 193 | * - decoding: Set/Unset by libavcodec. 194 | */ 195 | int priv_allocated_size; 196 | }; 197 | 198 | /** Create the video decoder. */ 199 | int ff_vda_create_decoder(struct vda_context *vda_ctx, 200 | uint8_t *extradata, 201 | int extradata_size); 202 | 203 | /** Destroy the video decoder. */ 204 | int ff_vda_destroy_decoder(struct vda_context *vda_ctx); 205 | 206 | #if FF_API_VDA_ASYNC 207 | /** 208 | * Return the top frame of the queue. 209 | * 210 | * @deprecated Use synchronous decoding mode. 211 | */ 212 | vda_frame *ff_vda_queue_pop(struct vda_context *vda_ctx); 213 | 214 | /** 215 | * Release the given frame. 216 | * 217 | * @deprecated Use synchronous decoding mode. 218 | */ 219 | void ff_vda_release_vda_frame(vda_frame *frame); 220 | #endif 221 | 222 | /** 223 | * @} 224 | */ 225 | 226 | #endif /* AVCODEC_VDA_H */ 227 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/libavcodec/vdpau.h: -------------------------------------------------------------------------------- 1 | /* 2 | * The Video Decode and Presentation API for UNIX (VDPAU) is used for 3 | * hardware-accelerated decoding of MPEG-1/2, H.264 and VC-1. 4 | * 5 | * Copyright (C) 2008 NVIDIA 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_VDPAU_H 25 | #define AVCODEC_VDPAU_H 26 | 27 | /** 28 | * @file 29 | * @ingroup lavc_codec_hwaccel_vdpau 30 | * Public libavcodec VDPAU header. 31 | */ 32 | 33 | 34 | /** 35 | * @defgroup lavc_codec_hwaccel_vdpau VDPAU Decoder and Renderer 36 | * @ingroup lavc_codec_hwaccel 37 | * 38 | * VDPAU hardware acceleration has two modules 39 | * - VDPAU decoding 40 | * - VDPAU presentation 41 | * 42 | * The VDPAU decoding module parses all headers using FFmpeg 43 | * parsing mechanisms and uses VDPAU for the actual decoding. 44 | * 45 | * As per the current implementation, the actual decoding 46 | * and rendering (API calls) are done as part of the VDPAU 47 | * presentation (vo_vdpau.c) module. 48 | * 49 | * @{ 50 | */ 51 | 52 | #include 53 | #include 54 | 55 | /** @brief The videoSurface is used for rendering. */ 56 | #define FF_VDPAU_STATE_USED_FOR_RENDER 1 57 | 58 | /** 59 | * @brief The videoSurface is needed for reference/prediction. 60 | * The codec manipulates this. 61 | */ 62 | #define FF_VDPAU_STATE_USED_FOR_REFERENCE 2 63 | 64 | /** 65 | * @brief This structure is used as a callback between the FFmpeg 66 | * decoder (vd_) and presentation (vo_) module. 67 | * This is used for defining a video frame containing surface, 68 | * picture parameter, bitstream information etc which are passed 69 | * between the FFmpeg decoder and its clients. 70 | */ 71 | struct vdpau_render_state { 72 | VdpVideoSurface surface; ///< Used as rendered surface, never changed. 73 | 74 | int state; ///< Holds FF_VDPAU_STATE_* values. 75 | 76 | /** Describe size/location of the compressed video data. 77 | Set to 0 when freeing bitstream_buffers. */ 78 | int bitstream_buffers_allocated; 79 | int bitstream_buffers_used; 80 | /** The user is responsible for freeing this buffer using av_freep(). */ 81 | VdpBitstreamBuffer *bitstream_buffers; 82 | 83 | /** picture parameter information for all supported codecs */ 84 | union VdpPictureInfo { 85 | VdpPictureInfoH264 h264; 86 | VdpPictureInfoMPEG1Or2 mpeg; 87 | VdpPictureInfoVC1 vc1; 88 | VdpPictureInfoMPEG4Part2 mpeg4; 89 | } info; 90 | }; 91 | 92 | /* @}*/ 93 | 94 | #endif /* AVCODEC_VDPAU_H */ 95 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/libavcodec/version.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 AVCODEC_VERSION_H 21 | #define AVCODEC_VERSION_H 22 | 23 | /** 24 | * @file 25 | * @ingroup libavc 26 | * Libavcodec version macros. 27 | */ 28 | 29 | #define LIBAVCODEC_VERSION_MAJOR 54 30 | #define LIBAVCODEC_VERSION_MINOR 59 31 | #define LIBAVCODEC_VERSION_MICRO 100 32 | 33 | #define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \ 34 | LIBAVCODEC_VERSION_MINOR, \ 35 | LIBAVCODEC_VERSION_MICRO) 36 | #define LIBAVCODEC_VERSION AV_VERSION(LIBAVCODEC_VERSION_MAJOR, \ 37 | LIBAVCODEC_VERSION_MINOR, \ 38 | LIBAVCODEC_VERSION_MICRO) 39 | #define LIBAVCODEC_BUILD LIBAVCODEC_VERSION_INT 40 | 41 | #define LIBAVCODEC_IDENT "Lavc" AV_STRINGIFY(LIBAVCODEC_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_REQUEST_CHANNELS 50 | #define FF_API_REQUEST_CHANNELS (LIBAVCODEC_VERSION_MAJOR < 55) 51 | #endif 52 | #ifndef FF_API_ALLOC_CONTEXT 53 | #define FF_API_ALLOC_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 55) 54 | #endif 55 | #ifndef FF_API_AVCODEC_OPEN 56 | #define FF_API_AVCODEC_OPEN (LIBAVCODEC_VERSION_MAJOR < 55) 57 | #endif 58 | #ifndef FF_API_OLD_DECODE_AUDIO 59 | #define FF_API_OLD_DECODE_AUDIO (LIBAVCODEC_VERSION_MAJOR < 55) 60 | #endif 61 | #ifndef FF_API_OLD_TIMECODE 62 | #define FF_API_OLD_TIMECODE (LIBAVCODEC_VERSION_MAJOR < 55) 63 | #endif 64 | 65 | #ifndef FF_API_OLD_ENCODE_AUDIO 66 | #define FF_API_OLD_ENCODE_AUDIO (LIBAVCODEC_VERSION_MAJOR < 55) 67 | #endif 68 | #ifndef FF_API_OLD_ENCODE_VIDEO 69 | #define FF_API_OLD_ENCODE_VIDEO (LIBAVCODEC_VERSION_MAJOR < 55) 70 | #endif 71 | #ifndef FF_API_MPV_GLOBAL_OPTS 72 | #define FF_API_MPV_GLOBAL_OPTS (LIBAVCODEC_VERSION_MAJOR < 55) 73 | #endif 74 | #ifndef FF_API_COLOR_TABLE_ID 75 | #define FF_API_COLOR_TABLE_ID (LIBAVCODEC_VERSION_MAJOR < 55) 76 | #endif 77 | #ifndef FF_API_INTER_THRESHOLD 78 | #define FF_API_INTER_THRESHOLD (LIBAVCODEC_VERSION_MAJOR < 55) 79 | #endif 80 | #ifndef FF_API_SUB_ID 81 | #define FF_API_SUB_ID (LIBAVCODEC_VERSION_MAJOR < 55) 82 | #endif 83 | #ifndef FF_API_DSP_MASK 84 | #define FF_API_DSP_MASK (LIBAVCODEC_VERSION_MAJOR < 55) 85 | #endif 86 | #ifndef FF_API_FIND_BEST_PIX_FMT 87 | #define FF_API_FIND_BEST_PIX_FMT (LIBAVCODEC_VERSION_MAJOR < 55) 88 | #endif 89 | #ifndef FF_API_CODEC_ID 90 | #define FF_API_CODEC_ID (LIBAVCODEC_VERSION_MAJOR < 55) 91 | #endif 92 | #ifndef FF_API_VDA_ASYNC 93 | #define FF_API_VDA_ASYNC (LIBAVCODEC_VERSION_MAJOR < 55) 94 | #endif 95 | 96 | #endif /* AVCODEC_VERSION_H */ 97 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/libavcodec/xvmc.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2003 Ivan Kalvachev 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_XVMC_H 22 | #define AVCODEC_XVMC_H 23 | 24 | /** 25 | * @file 26 | * @ingroup lavc_codec_hwaccel_xvmc 27 | * Public libavcodec XvMC header. 28 | */ 29 | 30 | #include 31 | 32 | #include "avcodec.h" 33 | 34 | /** 35 | * @defgroup lavc_codec_hwaccel_xvmc XvMC 36 | * @ingroup lavc_codec_hwaccel 37 | * 38 | * @{ 39 | */ 40 | 41 | #define AV_XVMC_ID 0x1DC711C0 /**< special value to ensure that regular pixel routines haven't corrupted the struct 42 | the number is 1337 speak for the letters IDCT MCo (motion compensation) */ 43 | 44 | struct xvmc_pix_fmt { 45 | /** The field contains the special constant value AV_XVMC_ID. 46 | It is used as a test that the application correctly uses the API, 47 | and that there is no corruption caused by pixel routines. 48 | - application - set during initialization 49 | - libavcodec - unchanged 50 | */ 51 | int xvmc_id; 52 | 53 | /** Pointer to the block array allocated by XvMCCreateBlocks(). 54 | The array has to be freed by XvMCDestroyBlocks(). 55 | Each group of 64 values represents one data block of differential 56 | pixel information (in MoCo mode) or coefficients for IDCT. 57 | - application - set the pointer during initialization 58 | - libavcodec - fills coefficients/pixel data into the array 59 | */ 60 | short* data_blocks; 61 | 62 | /** Pointer to the macroblock description array allocated by 63 | XvMCCreateMacroBlocks() and freed by XvMCDestroyMacroBlocks(). 64 | - application - set the pointer during initialization 65 | - libavcodec - fills description data into the array 66 | */ 67 | XvMCMacroBlock* mv_blocks; 68 | 69 | /** Number of macroblock descriptions that can be stored in the mv_blocks 70 | array. 71 | - application - set during initialization 72 | - libavcodec - unchanged 73 | */ 74 | int allocated_mv_blocks; 75 | 76 | /** Number of blocks that can be stored at once in the data_blocks array. 77 | - application - set during initialization 78 | - libavcodec - unchanged 79 | */ 80 | int allocated_data_blocks; 81 | 82 | /** Indicate that the hardware would interpret data_blocks as IDCT 83 | coefficients and perform IDCT on them. 84 | - application - set during initialization 85 | - libavcodec - unchanged 86 | */ 87 | int idct; 88 | 89 | /** In MoCo mode it indicates that intra macroblocks are assumed to be in 90 | unsigned format; same as the XVMC_INTRA_UNSIGNED flag. 91 | - application - set during initialization 92 | - libavcodec - unchanged 93 | */ 94 | int unsigned_intra; 95 | 96 | /** Pointer to the surface allocated by XvMCCreateSurface(). 97 | It has to be freed by XvMCDestroySurface() on application exit. 98 | It identifies the frame and its state on the video hardware. 99 | - application - set during initialization 100 | - libavcodec - unchanged 101 | */ 102 | XvMCSurface* p_surface; 103 | 104 | /** Set by the decoder before calling ff_draw_horiz_band(), 105 | needed by the XvMCRenderSurface function. */ 106 | //@{ 107 | /** Pointer to the surface used as past reference 108 | - application - unchanged 109 | - libavcodec - set 110 | */ 111 | XvMCSurface* p_past_surface; 112 | 113 | /** Pointer to the surface used as future reference 114 | - application - unchanged 115 | - libavcodec - set 116 | */ 117 | XvMCSurface* p_future_surface; 118 | 119 | /** top/bottom field or frame 120 | - application - unchanged 121 | - libavcodec - set 122 | */ 123 | unsigned int picture_structure; 124 | 125 | /** XVMC_SECOND_FIELD - 1st or 2nd field in the sequence 126 | - application - unchanged 127 | - libavcodec - set 128 | */ 129 | unsigned int flags; 130 | //}@ 131 | 132 | /** Number of macroblock descriptions in the mv_blocks array 133 | that have already been passed to the hardware. 134 | - application - zeroes it on get_buffer(). 135 | A successful ff_draw_horiz_band() may increment it 136 | with filled_mb_block_num or zero both. 137 | - libavcodec - unchanged 138 | */ 139 | int start_mv_blocks_num; 140 | 141 | /** Number of new macroblock descriptions in the mv_blocks array (after 142 | start_mv_blocks_num) that are filled by libavcodec and have to be 143 | passed to the hardware. 144 | - application - zeroes it on get_buffer() or after successful 145 | ff_draw_horiz_band(). 146 | - libavcodec - increment with one of each stored MB 147 | */ 148 | int filled_mv_blocks_num; 149 | 150 | /** Number of the next free data block; one data block consists of 151 | 64 short values in the data_blocks array. 152 | All blocks before this one have already been claimed by placing their 153 | position into the corresponding block description structure field, 154 | that are part of the mv_blocks array. 155 | - application - zeroes it on get_buffer(). 156 | A successful ff_draw_horiz_band() may zero it together 157 | with start_mb_blocks_num. 158 | - libavcodec - each decoded macroblock increases it by the number 159 | of coded blocks it contains. 160 | */ 161 | int next_free_data_block_num; 162 | }; 163 | 164 | /** 165 | * @} 166 | */ 167 | 168 | #endif /* AVCODEC_XVMC_H */ 169 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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/avutil.h" 31 | 32 | #define LIBAVFORMAT_VERSION_MAJOR 54 33 | #define LIBAVFORMAT_VERSION_MINOR 29 34 | #define LIBAVFORMAT_VERSION_MICRO 104 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 | 52 | #ifndef FF_API_OLD_AVIO 53 | #define FF_API_OLD_AVIO (LIBAVFORMAT_VERSION_MAJOR < 55) 54 | #endif 55 | #ifndef FF_API_PKT_DUMP 56 | #define FF_API_PKT_DUMP (LIBAVFORMAT_VERSION_MAJOR < 54) 57 | #endif 58 | #ifndef FF_API_ALLOC_OUTPUT_CONTEXT 59 | #define FF_API_ALLOC_OUTPUT_CONTEXT (LIBAVFORMAT_VERSION_MAJOR < 55) 60 | #endif 61 | #ifndef FF_API_FORMAT_PARAMETERS 62 | #define FF_API_FORMAT_PARAMETERS (LIBAVFORMAT_VERSION_MAJOR < 55) 63 | #endif 64 | #ifndef FF_API_NEW_STREAM 65 | #define FF_API_NEW_STREAM (LIBAVFORMAT_VERSION_MAJOR < 55) 66 | #endif 67 | #ifndef FF_API_SET_PTS_INFO 68 | #define FF_API_SET_PTS_INFO (LIBAVFORMAT_VERSION_MAJOR < 55) 69 | #endif 70 | #ifndef FF_API_CLOSE_INPUT_FILE 71 | #define FF_API_CLOSE_INPUT_FILE (LIBAVFORMAT_VERSION_MAJOR < 55) 72 | #endif 73 | #ifndef FF_API_APPLEHTTP_PROTO 74 | #define FF_API_APPLEHTTP_PROTO (LIBAVFORMAT_VERSION_MAJOR < 55) 75 | #endif 76 | #ifndef FF_API_READ_PACKET 77 | #define FF_API_READ_PACKET (LIBAVFORMAT_VERSION_MAJOR < 55) 78 | #endif 79 | #ifndef FF_API_INTERLEAVE_PACKET 80 | #define FF_API_INTERLEAVE_PACKET (LIBAVFORMAT_VERSION_MAJOR < 55) 81 | #endif 82 | #ifndef FF_API_AV_GETTIME 83 | #define FF_API_AV_GETTIME (LIBAVFORMAT_VERSION_MAJOR < 55) 84 | #endif 85 | #ifndef FF_API_R_FRAME_RATE 86 | #define FF_API_R_FRAME_RATE (LIBAVFORMAT_VERSION_MAJOR < 55) 87 | #endif 88 | 89 | #endif /* AVFORMAT_VERSION_H */ 90 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 | * @ingroup lavu_crypto 29 | * Calculate the Adler32 checksum of a buffer. 30 | * 31 | * Passing the return value to a subsequent av_adler32_update() call 32 | * allows the checksum of multiple buffers to be calculated as though 33 | * they were concatenated. 34 | * 35 | * @param adler initial checksum value 36 | * @param buf pointer to input buffer 37 | * @param len size of input buffer 38 | * @return updated checksum 39 | */ 40 | unsigned long av_adler32_update(unsigned long adler, const uint8_t *buf, 41 | unsigned int len) av_pure; 42 | 43 | #endif /* AVUTIL_ADLER32_H */ 44 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 | /** 27 | * @defgroup lavu_aes AES 28 | * @ingroup lavu_crypto 29 | * @{ 30 | */ 31 | 32 | extern const int av_aes_size; 33 | 34 | struct AVAES; 35 | 36 | /** 37 | * Initialize an AVAES context. 38 | * @param key_bits 128, 192 or 256 39 | * @param decrypt 0 for encryption, 1 for decryption 40 | */ 41 | int av_aes_init(struct AVAES *a, const uint8_t *key, int key_bits, int decrypt); 42 | 43 | /** 44 | * Encrypt or decrypt a buffer using a previously initialized context. 45 | * @param count number of 16 byte blocks 46 | * @param dst destination array, can be equal to src 47 | * @param src source array, can be equal to dst 48 | * @param iv initialization vector for CBC mode, if NULL then ECB will be used 49 | * @param decrypt 0 for encryption, 1 for decryption 50 | */ 51 | void av_aes_crypt(struct AVAES *a, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt); 52 | 53 | /** 54 | * @} 55 | */ 56 | 57 | #endif /* AVUTIL_AES_H */ 58 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 | #else 56 | # define av_noinline 57 | #endif 58 | 59 | #if AV_GCC_VERSION_AT_LEAST(3,1) 60 | # define av_pure __attribute__((pure)) 61 | #else 62 | # define av_pure 63 | #endif 64 | 65 | #ifndef av_restrict 66 | #define av_restrict restrict 67 | #endif 68 | 69 | #if AV_GCC_VERSION_AT_LEAST(2,6) 70 | # define av_const __attribute__((const)) 71 | #else 72 | # define av_const 73 | #endif 74 | 75 | #if AV_GCC_VERSION_AT_LEAST(4,3) 76 | # define av_cold __attribute__((cold)) 77 | #else 78 | # define av_cold 79 | #endif 80 | 81 | #if AV_GCC_VERSION_AT_LEAST(4,1) 82 | # define av_flatten __attribute__((flatten)) 83 | #else 84 | # define av_flatten 85 | #endif 86 | 87 | #if AV_GCC_VERSION_AT_LEAST(3,1) 88 | # define attribute_deprecated __attribute__((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 | #else 106 | # define AV_NOWARN_DEPRECATED(code) code 107 | #endif 108 | #endif 109 | 110 | 111 | #if defined(__GNUC__) 112 | # define av_unused __attribute__((unused)) 113 | #else 114 | # define av_unused 115 | #endif 116 | 117 | /** 118 | * Mark a variable as used and prevent the compiler from optimizing it 119 | * away. This is useful for variables accessed only from inline 120 | * assembler without the compiler being aware. 121 | */ 122 | #if AV_GCC_VERSION_AT_LEAST(3,1) 123 | # define av_used __attribute__((used)) 124 | #else 125 | # define av_used 126 | #endif 127 | 128 | #if AV_GCC_VERSION_AT_LEAST(3,3) 129 | # define av_alias __attribute__((may_alias)) 130 | #else 131 | # define av_alias 132 | #endif 133 | 134 | #if defined(__GNUC__) && !defined(__INTEL_COMPILER) && !defined(__clang__) 135 | # define av_uninit(x) x=x 136 | #else 137 | # define av_uninit(x) x 138 | #endif 139 | 140 | #ifdef __GNUC__ 141 | # define av_builtin_constant_p __builtin_constant_p 142 | # define av_printf_format(fmtpos, attrpos) __attribute__((__format__(__printf__, fmtpos, attrpos))) 143 | #else 144 | # define av_builtin_constant_p(x) 0 145 | # define av_printf_format(fmtpos, attrpos) 146 | #endif 147 | 148 | #if AV_GCC_VERSION_AT_LEAST(2,5) 149 | # define av_noreturn __attribute__((noreturn)) 150 | #else 151 | # define av_noreturn 152 | #endif 153 | 154 | #endif /* AVUTIL_ATTRIBUTES_H */ 155 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/libavutil/audio_fifo.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Audio FIFO 3 | * Copyright (c) 2012 Justin Ruggles 4 | * 5 | * This file is part of Libav. 6 | * 7 | * Libav 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 | * Libav 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 Libav; 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 | 39 | /** 40 | * Context for an Audio FIFO Buffer. 41 | * 42 | * - Operates at the sample level rather than the byte level. 43 | * - Supports multiple channels with either planar or packed sample format. 44 | * - Automatic reallocation when writing to a full buffer. 45 | */ 46 | typedef struct AVAudioFifo AVAudioFifo; 47 | 48 | /** 49 | * Free an AVAudioFifo. 50 | * 51 | * @param af AVAudioFifo to free 52 | */ 53 | void av_audio_fifo_free(AVAudioFifo *af); 54 | 55 | /** 56 | * Allocate an AVAudioFifo. 57 | * 58 | * @param sample_fmt sample format 59 | * @param channels number of channels 60 | * @param nb_samples initial allocation size, in samples 61 | * @return newly allocated AVAudioFifo, or NULL on error 62 | */ 63 | AVAudioFifo *av_audio_fifo_alloc(enum AVSampleFormat sample_fmt, int channels, 64 | int nb_samples); 65 | 66 | /** 67 | * Reallocate an AVAudioFifo. 68 | * 69 | * @param af AVAudioFifo to reallocate 70 | * @param nb_samples new allocation size, in samples 71 | * @return 0 if OK, or negative AVERROR code on failure 72 | */ 73 | int av_audio_fifo_realloc(AVAudioFifo *af, int nb_samples); 74 | 75 | /** 76 | * Write data to an AVAudioFifo. 77 | * 78 | * The AVAudioFifo will be reallocated automatically if the available space 79 | * is less than nb_samples. 80 | * 81 | * @see enum AVSampleFormat 82 | * The documentation for AVSampleFormat describes the data layout. 83 | * 84 | * @param af AVAudioFifo to write to 85 | * @param data audio data plane pointers 86 | * @param nb_samples number of samples to write 87 | * @return number of samples actually written, or negative AVERROR 88 | * code on failure. 89 | */ 90 | int av_audio_fifo_write(AVAudioFifo *af, void **data, int nb_samples); 91 | 92 | /** 93 | * Read data from an AVAudioFifo. 94 | * 95 | * @see enum AVSampleFormat 96 | * The documentation for AVSampleFormat describes the data layout. 97 | * 98 | * @param af AVAudioFifo to read from 99 | * @param data audio data plane pointers 100 | * @param nb_samples number of samples to read 101 | * @return number of samples actually read, or negative AVERROR code 102 | * on failure. 103 | */ 104 | int av_audio_fifo_read(AVAudioFifo *af, void **data, int nb_samples); 105 | 106 | /** 107 | * Drain data from an AVAudioFifo. 108 | * 109 | * Removes the data without reading it. 110 | * 111 | * @param af AVAudioFifo to drain 112 | * @param nb_samples number of samples to drain 113 | * @return 0 if OK, or negative AVERROR code on failure 114 | */ 115 | int av_audio_fifo_drain(AVAudioFifo *af, int nb_samples); 116 | 117 | /** 118 | * Reset the AVAudioFifo buffer. 119 | * 120 | * This empties all data in the buffer. 121 | * 122 | * @param af AVAudioFifo to reset 123 | */ 124 | void av_audio_fifo_reset(AVAudioFifo *af); 125 | 126 | /** 127 | * Get the current number of samples in the AVAudioFifo available for reading. 128 | * 129 | * @param af the AVAudioFifo to query 130 | * @return number of samples available for reading 131 | */ 132 | int av_audio_fifo_size(AVAudioFifo *af); 133 | 134 | /** 135 | * Get the current number of samples in the AVAudioFifo available for writing. 136 | * 137 | * @param af the AVAudioFifo to query 138 | * @return number of samples available for writing 139 | */ 140 | int av_audio_fifo_space(AVAudioFifo *af); 141 | 142 | /** 143 | * @} 144 | */ 145 | 146 | #endif /* AVUTIL_AUDIO_FIFO_H */ 147 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/libavutil/audioconvert.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2006 Michael Niedermayer 3 | * Copyright (c) 2008 Peter Ross 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_AUDIOCONVERT_H 23 | #define AVUTIL_AUDIOCONVERT_H 24 | 25 | #include 26 | 27 | /** 28 | * @file 29 | * audio conversion routines 30 | */ 31 | 32 | /** 33 | * @addtogroup lavu_audio 34 | * @{ 35 | */ 36 | 37 | /** 38 | * @defgroup channel_masks Audio channel masks 39 | * @{ 40 | */ 41 | #define AV_CH_FRONT_LEFT 0x00000001 42 | #define AV_CH_FRONT_RIGHT 0x00000002 43 | #define AV_CH_FRONT_CENTER 0x00000004 44 | #define AV_CH_LOW_FREQUENCY 0x00000008 45 | #define AV_CH_BACK_LEFT 0x00000010 46 | #define AV_CH_BACK_RIGHT 0x00000020 47 | #define AV_CH_FRONT_LEFT_OF_CENTER 0x00000040 48 | #define AV_CH_FRONT_RIGHT_OF_CENTER 0x00000080 49 | #define AV_CH_BACK_CENTER 0x00000100 50 | #define AV_CH_SIDE_LEFT 0x00000200 51 | #define AV_CH_SIDE_RIGHT 0x00000400 52 | #define AV_CH_TOP_CENTER 0x00000800 53 | #define AV_CH_TOP_FRONT_LEFT 0x00001000 54 | #define AV_CH_TOP_FRONT_CENTER 0x00002000 55 | #define AV_CH_TOP_FRONT_RIGHT 0x00004000 56 | #define AV_CH_TOP_BACK_LEFT 0x00008000 57 | #define AV_CH_TOP_BACK_CENTER 0x00010000 58 | #define AV_CH_TOP_BACK_RIGHT 0x00020000 59 | #define AV_CH_STEREO_LEFT 0x20000000 ///< Stereo downmix. 60 | #define AV_CH_STEREO_RIGHT 0x40000000 ///< See AV_CH_STEREO_LEFT. 61 | #define AV_CH_WIDE_LEFT 0x0000000080000000ULL 62 | #define AV_CH_WIDE_RIGHT 0x0000000100000000ULL 63 | #define AV_CH_SURROUND_DIRECT_LEFT 0x0000000200000000ULL 64 | #define AV_CH_SURROUND_DIRECT_RIGHT 0x0000000400000000ULL 65 | #define AV_CH_LOW_FREQUENCY_2 0x0000000800000000ULL 66 | 67 | /** Channel mask value used for AVCodecContext.request_channel_layout 68 | to indicate that the user requests the channel order of the decoder output 69 | to be the native codec channel order. */ 70 | #define AV_CH_LAYOUT_NATIVE 0x8000000000000000ULL 71 | 72 | /** 73 | * @} 74 | * @defgroup channel_mask_c Audio channel convenience macros 75 | * @{ 76 | * */ 77 | #define AV_CH_LAYOUT_MONO (AV_CH_FRONT_CENTER) 78 | #define AV_CH_LAYOUT_STEREO (AV_CH_FRONT_LEFT|AV_CH_FRONT_RIGHT) 79 | #define AV_CH_LAYOUT_2POINT1 (AV_CH_LAYOUT_STEREO|AV_CH_LOW_FREQUENCY) 80 | #define AV_CH_LAYOUT_2_1 (AV_CH_LAYOUT_STEREO|AV_CH_BACK_CENTER) 81 | #define AV_CH_LAYOUT_SURROUND (AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER) 82 | #define AV_CH_LAYOUT_3POINT1 (AV_CH_LAYOUT_SURROUND|AV_CH_LOW_FREQUENCY) 83 | #define AV_CH_LAYOUT_4POINT0 (AV_CH_LAYOUT_SURROUND|AV_CH_BACK_CENTER) 84 | #define AV_CH_LAYOUT_4POINT1 (AV_CH_LAYOUT_4POINT0|AV_CH_LOW_FREQUENCY) 85 | #define AV_CH_LAYOUT_2_2 (AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT) 86 | #define AV_CH_LAYOUT_QUAD (AV_CH_LAYOUT_STEREO|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT) 87 | #define AV_CH_LAYOUT_5POINT0 (AV_CH_LAYOUT_SURROUND|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT) 88 | #define AV_CH_LAYOUT_5POINT1 (AV_CH_LAYOUT_5POINT0|AV_CH_LOW_FREQUENCY) 89 | #define AV_CH_LAYOUT_5POINT0_BACK (AV_CH_LAYOUT_SURROUND|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT) 90 | #define AV_CH_LAYOUT_5POINT1_BACK (AV_CH_LAYOUT_5POINT0_BACK|AV_CH_LOW_FREQUENCY) 91 | #define AV_CH_LAYOUT_6POINT0 (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_CENTER) 92 | #define AV_CH_LAYOUT_6POINT0_FRONT (AV_CH_LAYOUT_2_2|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER) 93 | #define AV_CH_LAYOUT_HEXAGONAL (AV_CH_LAYOUT_5POINT0_BACK|AV_CH_BACK_CENTER) 94 | #define AV_CH_LAYOUT_6POINT1 (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_CENTER) 95 | #define AV_CH_LAYOUT_6POINT1_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_BACK_CENTER) 96 | #define AV_CH_LAYOUT_6POINT1_FRONT (AV_CH_LAYOUT_6POINT0_FRONT|AV_CH_LOW_FREQUENCY) 97 | #define AV_CH_LAYOUT_7POINT0 (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT) 98 | #define AV_CH_LAYOUT_7POINT0_FRONT (AV_CH_LAYOUT_5POINT0|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER) 99 | #define AV_CH_LAYOUT_7POINT1 (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT) 100 | #define AV_CH_LAYOUT_7POINT1_WIDE (AV_CH_LAYOUT_5POINT1|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER) 101 | #define AV_CH_LAYOUT_7POINT1_WIDE_BACK (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER) 102 | #define AV_CH_LAYOUT_OCTAGONAL (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_CENTER|AV_CH_BACK_RIGHT) 103 | #define AV_CH_LAYOUT_STEREO_DOWNMIX (AV_CH_STEREO_LEFT|AV_CH_STEREO_RIGHT) 104 | 105 | enum AVMatrixEncoding { 106 | AV_MATRIX_ENCODING_NONE, 107 | AV_MATRIX_ENCODING_DOLBY, 108 | AV_MATRIX_ENCODING_DPLII, 109 | AV_MATRIX_ENCODING_NB 110 | }; 111 | 112 | /** 113 | * @} 114 | */ 115 | 116 | /** 117 | * Return a channel layout id that matches name, or 0 if no match is found. 118 | * 119 | * name can be one or several of the following notations, 120 | * separated by '+' or '|': 121 | * - the name of an usual channel layout (mono, stereo, 4.0, quad, 5.0, 122 | * 5.0(side), 5.1, 5.1(side), 7.1, 7.1(wide), downmix); 123 | * - the name of a single channel (FL, FR, FC, LFE, BL, BR, FLC, FRC, BC, 124 | * SL, SR, TC, TFL, TFC, TFR, TBL, TBC, TBR, DL, DR); 125 | * - a number of channels, in decimal, optionally followed by 'c', yielding 126 | * the default channel layout for that number of channels (@see 127 | * av_get_default_channel_layout); 128 | * - a channel layout mask, in hexadecimal starting with "0x" (see the 129 | * AV_CH_* macros). 130 | * 131 | * Example: "stereo+FC" = "2+FC" = "2c+1c" = "0x7" 132 | */ 133 | uint64_t av_get_channel_layout(const char *name); 134 | 135 | /** 136 | * Return a description of a channel layout. 137 | * If nb_channels is <= 0, it is guessed from the channel_layout. 138 | * 139 | * @param buf put here the string containing the channel layout 140 | * @param buf_size size in bytes of the buffer 141 | */ 142 | void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout); 143 | 144 | struct AVBPrint; 145 | /** 146 | * Append a description of a channel layout to a bprint buffer. 147 | */ 148 | void av_bprint_channel_layout(struct AVBPrint *bp, int nb_channels, uint64_t channel_layout); 149 | 150 | /** 151 | * Return the number of channels in the channel layout. 152 | */ 153 | int av_get_channel_layout_nb_channels(uint64_t channel_layout); 154 | 155 | /** 156 | * Return default channel layout for a given number of channels. 157 | */ 158 | int64_t av_get_default_channel_layout(int nb_channels); 159 | 160 | /** 161 | * Get the index of a channel in channel_layout. 162 | * 163 | * @param channel a channel layout describing exactly one channel which must be 164 | * present in channel_layout. 165 | * 166 | * @return index of channel in channel_layout on success, a negative AVERROR 167 | * on error. 168 | */ 169 | int av_get_channel_layout_channel_index(uint64_t channel_layout, 170 | uint64_t channel); 171 | 172 | /** 173 | * Get the channel with the given index in channel_layout. 174 | */ 175 | uint64_t av_channel_layout_extract_channel(uint64_t channel_layout, int index); 176 | 177 | /** 178 | * Get the name of a given channel. 179 | * 180 | * @return channel name on success, NULL on error. 181 | */ 182 | const char *av_get_channel_name(uint64_t channel); 183 | 184 | /** 185 | * Get the description of a given channel. 186 | * 187 | * @param channel a channel layout with a single channel 188 | * @return channel description on success, NULL on error 189 | */ 190 | const char *av_get_channel_description(uint64_t channel); 191 | 192 | /** 193 | * Get the value and name of a standard channel layout. 194 | * 195 | * @param[in] index index in an internal list, starting at 0 196 | * @param[out] layout channel layout mask 197 | * @param[out] name name of the layout 198 | * @return 0 if the layout exists, 199 | * <0 if index is beyond the limits 200 | */ 201 | int av_get_standard_channel_layout(unsigned index, uint64_t *layout, 202 | const char **name); 203 | 204 | /** 205 | * @} 206 | */ 207 | 208 | #endif /* AVUTIL_AUDIOCONVERT_H */ 209 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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_FATAL, "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 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 1 6 | #define AV_HAVE_INCOMPATIBLE_FORK_ABI 0 7 | #endif /* AVUTIL_AVCONFIG_H */ 8 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/libavutil/avstring.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2007 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_AVSTRING_H 22 | #define AVUTIL_AVSTRING_H 23 | 24 | #include 25 | #include "attributes.h" 26 | 27 | /** 28 | * @addtogroup lavu_string 29 | * @{ 30 | */ 31 | 32 | /** 33 | * Return non-zero if pfx is a prefix of str. If it is, *ptr is set to 34 | * the address of the first character in str after the prefix. 35 | * 36 | * @param str input string 37 | * @param pfx prefix to test 38 | * @param ptr updated if the prefix is matched inside str 39 | * @return non-zero if the prefix matches, zero otherwise 40 | */ 41 | int av_strstart(const char *str, const char *pfx, const char **ptr); 42 | 43 | /** 44 | * Return non-zero if pfx is a prefix of str independent of case. If 45 | * it is, *ptr is set to the address of the first character in str 46 | * after the prefix. 47 | * 48 | * @param str input string 49 | * @param pfx prefix to test 50 | * @param ptr updated if the prefix is matched inside str 51 | * @return non-zero if the prefix matches, zero otherwise 52 | */ 53 | int av_stristart(const char *str, const char *pfx, const char **ptr); 54 | 55 | /** 56 | * Locate the first case-independent occurrence in the string haystack 57 | * of the string needle. A zero-length string needle is considered to 58 | * match at the start of haystack. 59 | * 60 | * This function is a case-insensitive version of the standard strstr(). 61 | * 62 | * @param haystack string to search in 63 | * @param needle string to search for 64 | * @return pointer to the located match within haystack 65 | * or a null pointer if no match 66 | */ 67 | char *av_stristr(const char *haystack, const char *needle); 68 | 69 | /** 70 | * Copy the string src to dst, but no more than size - 1 bytes, and 71 | * null-terminate dst. 72 | * 73 | * This function is the same as BSD strlcpy(). 74 | * 75 | * @param dst destination buffer 76 | * @param src source string 77 | * @param size size of destination buffer 78 | * @return the length of src 79 | * 80 | * @warning since the return value is the length of src, src absolutely 81 | * _must_ be a properly 0-terminated string, otherwise this will read beyond 82 | * the end of the buffer and possibly crash. 83 | */ 84 | size_t av_strlcpy(char *dst, const char *src, size_t size); 85 | 86 | /** 87 | * Append the string src to the string dst, but to a total length of 88 | * no more than size - 1 bytes, and null-terminate dst. 89 | * 90 | * This function is similar to BSD strlcat(), but differs when 91 | * size <= strlen(dst). 92 | * 93 | * @param dst destination buffer 94 | * @param src source string 95 | * @param size size of destination buffer 96 | * @return the total length of src and dst 97 | * 98 | * @warning since the return value use the length of src and dst, these 99 | * absolutely _must_ be a properly 0-terminated strings, otherwise this 100 | * will read beyond the end of the buffer and possibly crash. 101 | */ 102 | size_t av_strlcat(char *dst, const char *src, size_t size); 103 | 104 | /** 105 | * Append output to a string, according to a format. Never write out of 106 | * the destination buffer, and always put a terminating 0 within 107 | * the buffer. 108 | * @param dst destination buffer (string to which the output is 109 | * appended) 110 | * @param size total size of the destination buffer 111 | * @param fmt printf-compatible format string, specifying how the 112 | * following parameters are used 113 | * @return the length of the string that would have been generated 114 | * if enough space had been available 115 | */ 116 | size_t av_strlcatf(char *dst, size_t size, const char *fmt, ...) av_printf_format(3, 4); 117 | 118 | /** 119 | * Print arguments following specified format into a large enough auto 120 | * allocated buffer. It is similar to GNU asprintf(). 121 | * @param fmt printf-compatible format string, specifying how the 122 | * following parameters are used. 123 | * @return the allocated string 124 | * @note You have to free the string yourself with av_free(). 125 | */ 126 | char *av_asprintf(const char *fmt, ...) av_printf_format(1, 2); 127 | 128 | /** 129 | * Convert a number to a av_malloced string. 130 | */ 131 | char *av_d2str(double d); 132 | 133 | /** 134 | * Unescape the given string until a non escaped terminating char, 135 | * and return the token corresponding to the unescaped string. 136 | * 137 | * The normal \ and ' escaping is supported. Leading and trailing 138 | * whitespaces are removed, unless they are escaped with '\' or are 139 | * enclosed between ''. 140 | * 141 | * @param buf the buffer to parse, buf will be updated to point to the 142 | * terminating char 143 | * @param term a 0-terminated list of terminating chars 144 | * @return the malloced unescaped string, which must be av_freed by 145 | * the user, NULL in case of allocation failure 146 | */ 147 | char *av_get_token(const char **buf, const char *term); 148 | 149 | /** 150 | * Split the string into several tokens which can be accessed by 151 | * successive calls to av_strtok(). 152 | * 153 | * A token is defined as a sequence of characters not belonging to the 154 | * set specified in delim. 155 | * 156 | * On the first call to av_strtok(), s should point to the string to 157 | * parse, and the value of saveptr is ignored. In subsequent calls, s 158 | * should be NULL, and saveptr should be unchanged since the previous 159 | * call. 160 | * 161 | * This function is similar to strtok_r() defined in POSIX.1. 162 | * 163 | * @param s the string to parse, may be NULL 164 | * @param delim 0-terminated list of token delimiters, must be non-NULL 165 | * @param saveptr user-provided pointer which points to stored 166 | * information necessary for av_strtok() to continue scanning the same 167 | * string. saveptr is updated to point to the next character after the 168 | * first delimiter found, or to NULL if the string was terminated 169 | * @return the found token, or NULL when no token is found 170 | */ 171 | char *av_strtok(char *s, const char *delim, char **saveptr); 172 | 173 | /** 174 | * Locale-independent conversion of ASCII characters to uppercase. 175 | */ 176 | static inline int av_toupper(int c) 177 | { 178 | if (c >= 'a' && c <= 'z') 179 | c ^= 0x20; 180 | return c; 181 | } 182 | 183 | /** 184 | * Locale-independent conversion of ASCII characters to lowercase. 185 | */ 186 | static inline int av_tolower(int c) 187 | { 188 | if (c >= 'A' && c <= 'Z') 189 | c ^= 0x20; 190 | return c; 191 | } 192 | 193 | /** 194 | * Locale-independent case-insensitive compare. 195 | * @note This means only ASCII-range characters are case-insensitive 196 | */ 197 | int av_strcasecmp(const char *a, const char *b); 198 | 199 | /** 200 | * Locale-independent case-insensitive compare. 201 | * @note This means only ASCII-range characters are case-insensitive 202 | */ 203 | int av_strncasecmp(const char *a, const char *b, size_t n); 204 | 205 | /** 206 | * @} 207 | */ 208 | 209 | #endif /* AVUTIL_AVSTRING_H */ 210 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/libavutil/avutil.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_AVUTIL_H 22 | #define AVUTIL_AVUTIL_H 23 | 24 | /** 25 | * @file 26 | * external API header 27 | */ 28 | 29 | /* 30 | * @mainpage 31 | * 32 | * @section ffmpeg_intro Introduction 33 | * 34 | * This document describes the usage of the different libraries 35 | * provided by FFmpeg. 36 | * 37 | * @li @ref libavc "libavcodec" encoding/decoding library 38 | * @li @subpage libavfilter graph based frame editing library 39 | * @li @ref libavf "libavformat" I/O and muxing/demuxing library 40 | * @li @ref lavd "libavdevice" special devices muxing/demuxing library 41 | * @li @ref lavu "libavutil" common utility library 42 | * @li @subpage libpostproc post processing library 43 | * @li @subpage libswscale color conversion and scaling library 44 | */ 45 | 46 | /** 47 | * @defgroup lavu Common utility functions 48 | * 49 | * @brief 50 | * libavutil contains the code shared across all the other FFmpeg 51 | * libraries 52 | * 53 | * @note In order to use the functions provided by avutil you must include 54 | * the specific header. 55 | * 56 | * @{ 57 | * 58 | * @defgroup lavu_crypto Crypto and Hashing 59 | * 60 | * @{ 61 | * @} 62 | * 63 | * @defgroup lavu_math Maths 64 | * @{ 65 | * 66 | * @} 67 | * 68 | * @defgroup lavu_string String Manipulation 69 | * 70 | * @{ 71 | * 72 | * @} 73 | * 74 | * @defgroup lavu_mem Memory Management 75 | * 76 | * @{ 77 | * 78 | * @} 79 | * 80 | * @defgroup lavu_data Data Structures 81 | * @{ 82 | * 83 | * @} 84 | * 85 | * @defgroup lavu_audio Audio related 86 | * 87 | * @{ 88 | * 89 | * @} 90 | * 91 | * @defgroup lavu_error Error Codes 92 | * 93 | * @{ 94 | * 95 | * @} 96 | * 97 | * @defgroup lavu_misc Other 98 | * 99 | * @{ 100 | * 101 | * @defgroup lavu_internal Internal 102 | * 103 | * Not exported functions, for internal usage only 104 | * 105 | * @{ 106 | * 107 | * @} 108 | */ 109 | 110 | 111 | /** 112 | * @defgroup preproc_misc Preprocessor String Macros 113 | * 114 | * String manipulation macros 115 | * 116 | * @{ 117 | */ 118 | 119 | #define AV_STRINGIFY(s) AV_TOSTRING(s) 120 | #define AV_TOSTRING(s) #s 121 | 122 | #define AV_GLUE(a, b) a ## b 123 | #define AV_JOIN(a, b) AV_GLUE(a, b) 124 | 125 | #define AV_PRAGMA(s) _Pragma(#s) 126 | 127 | /** 128 | * @} 129 | */ 130 | 131 | /** 132 | * @defgroup version_utils Library Version Macros 133 | * 134 | * Useful to check and match library version in order to maintain 135 | * backward compatibility. 136 | * 137 | * @{ 138 | */ 139 | 140 | #define AV_VERSION_INT(a, b, c) (a<<16 | b<<8 | c) 141 | #define AV_VERSION_DOT(a, b, c) a ##.## b ##.## c 142 | #define AV_VERSION(a, b, c) AV_VERSION_DOT(a, b, c) 143 | 144 | /** 145 | * @} 146 | */ 147 | 148 | /** 149 | * @addtogroup lavu_ver 150 | * @{ 151 | */ 152 | 153 | /** 154 | * Return the LIBAVUTIL_VERSION_INT constant. 155 | */ 156 | unsigned avutil_version(void); 157 | 158 | /** 159 | * Return the libavutil build-time configuration. 160 | */ 161 | const char *avutil_configuration(void); 162 | 163 | /** 164 | * Return the libavutil license. 165 | */ 166 | const char *avutil_license(void); 167 | 168 | /** 169 | * @} 170 | */ 171 | 172 | /** 173 | * @addtogroup lavu_media Media Type 174 | * @brief Media Type 175 | */ 176 | 177 | enum AVMediaType { 178 | AVMEDIA_TYPE_UNKNOWN = -1, ///< Usually treated as AVMEDIA_TYPE_DATA 179 | AVMEDIA_TYPE_VIDEO, 180 | AVMEDIA_TYPE_AUDIO, 181 | AVMEDIA_TYPE_DATA, ///< Opaque data information usually continuous 182 | AVMEDIA_TYPE_SUBTITLE, 183 | AVMEDIA_TYPE_ATTACHMENT, ///< Opaque data information usually sparse 184 | AVMEDIA_TYPE_NB 185 | }; 186 | 187 | /** 188 | * Return a string describing the media_type enum, NULL if media_type 189 | * is unknown. 190 | */ 191 | const char *av_get_media_type_string(enum AVMediaType media_type); 192 | 193 | /** 194 | * @defgroup lavu_const Constants 195 | * @{ 196 | * 197 | * @defgroup lavu_enc Encoding specific 198 | * 199 | * @note those definition should move to avcodec 200 | * @{ 201 | */ 202 | 203 | #define FF_LAMBDA_SHIFT 7 204 | #define FF_LAMBDA_SCALE (1< 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 output buffer, must be at 50 | * least AV_BASE64_SIZE(in_size) 51 | * @param in_size size in bytes of the 'in' buffer 52 | * @return 'out' or NULL in case of error 53 | */ 54 | char *av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size); 55 | 56 | /** 57 | * Calculate the output size needed to base64-encode x bytes. 58 | */ 59 | #define AV_BASE64_SIZE(x) (((x)+2) / 3 * 4 + 1) 60 | 61 | /** 62 | * @} 63 | */ 64 | 65 | #endif /* AVUTIL_BASE64_H */ 66 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/libavutil/bprint.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2012 Nicolas George 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_BPRINT_H 22 | #define AVUTIL_BPRINT_H 23 | 24 | #include "attributes.h" 25 | 26 | /** 27 | * Define a structure with extra padding to a fixed size 28 | * This helps ensuring binary compatibility with future versions. 29 | */ 30 | #define FF_PAD_STRUCTURE(size, ...) \ 31 | __VA_ARGS__ \ 32 | char reserved_padding[size - sizeof(struct { __VA_ARGS__ })]; 33 | 34 | /** 35 | * Buffer to print data progressively 36 | * 37 | * The string buffer grows as necessary and is always 0-terminated. 38 | * The content of the string is never accessed, and thus is 39 | * encoding-agnostic and can even hold binary data. 40 | * 41 | * Small buffers are kept in the structure itself, and thus require no 42 | * memory allocation at all (unless the contents of the buffer is needed 43 | * after the structure goes out of scope). This is almost as lightweight as 44 | * declaring a local "char buf[512]". 45 | * 46 | * The length of the string can go beyond the allocated size: the buffer is 47 | * then truncated, but the functions still keep account of the actual total 48 | * length. 49 | * 50 | * In other words, buf->len can be greater than buf->size and records the 51 | * total length of what would have been to the buffer if there had been 52 | * enough memory. 53 | * 54 | * Append operations do not need to be tested for failure: if a memory 55 | * allocation fails, data stop being appended to the buffer, but the length 56 | * is still updated. This situation can be tested with 57 | * av_bprint_is_complete(). 58 | * 59 | * The size_max field determines several possible behaviours: 60 | * 61 | * size_max = -1 (= UINT_MAX) or any large value will let the buffer be 62 | * reallocated as necessary, with an amortized linear cost. 63 | * 64 | * size_max = 0 prevents writing anything to the buffer: only the total 65 | * length is computed. The write operations can then possibly be repeated in 66 | * a buffer with exactly the necessary size 67 | * (using size_init = size_max = len + 1). 68 | * 69 | * size_max = 1 is automatically replaced by the exact size available in the 70 | * structure itself, thus ensuring no dynamic memory allocation. The 71 | * internal buffer is large enough to hold a reasonable paragraph of text, 72 | * such as the current paragraph. 73 | */ 74 | typedef struct AVBPrint { 75 | FF_PAD_STRUCTURE(1024, 76 | char *str; /** string so far */ 77 | unsigned len; /** length so far */ 78 | unsigned size; /** allocated memory */ 79 | unsigned size_max; /** maximum allocated memory */ 80 | char reserved_internal_buffer[1]; 81 | ) 82 | } AVBPrint; 83 | 84 | /** 85 | * Convenience macros for special values for av_bprint_init() size_max 86 | * parameter. 87 | */ 88 | #define AV_BPRINT_SIZE_UNLIMITED ((unsigned)-1) 89 | #define AV_BPRINT_SIZE_AUTOMATIC 1 90 | #define AV_BPRINT_SIZE_COUNT_ONLY 0 91 | 92 | /** 93 | * Init a print buffer. 94 | * 95 | * @param buf buffer to init 96 | * @param size_init initial size (including the final 0) 97 | * @param size_max maximum size; 98 | * 0 means do not write anything, just count the length; 99 | * 1 is replaced by the maximum value for automatic storage; 100 | * any large value means that the internal buffer will be 101 | * reallocated as needed up to that limit; -1 is converted to 102 | * UINT_MAX, the largest limit possible. 103 | * Check also AV_BPRINT_SIZE_* macros. 104 | */ 105 | void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max); 106 | 107 | /** 108 | * Init a print buffer using a pre-existing buffer. 109 | * 110 | * The buffer will not be reallocated. 111 | * 112 | * @param buf buffer structure to init 113 | * @param buffer byte buffer to use for the string data 114 | * @param size size of buffer 115 | */ 116 | void av_bprint_init_for_buffer(AVBPrint *buf, char *buffer, unsigned size); 117 | 118 | /** 119 | * Append a formated string to a print buffer. 120 | */ 121 | void av_bprintf(AVBPrint *buf, const char *fmt, ...) av_printf_format(2, 3); 122 | 123 | /** 124 | * Append char c n times to a print buffer. 125 | */ 126 | void av_bprint_chars(AVBPrint *buf, char c, unsigned n); 127 | 128 | /** 129 | * Reset the string to "" but keep internal allocated data. 130 | */ 131 | void av_bprint_clear(AVBPrint *buf); 132 | 133 | /** 134 | * Test if the print buffer is complete (not truncated). 135 | * 136 | * It may have been truncated due to a memory allocation failure 137 | * or the size_max limit (compare size and size_max if necessary). 138 | */ 139 | static inline int av_bprint_is_complete(AVBPrint *buf) 140 | { 141 | return buf->len < buf->size; 142 | } 143 | 144 | /** 145 | * Finalize a print buffer. 146 | * 147 | * The print buffer can no longer be used afterwards, 148 | * but the len and size fields are still valid. 149 | * 150 | * @arg[out] ret_str if not NULL, used to return a permanent copy of the 151 | * buffer contents, or NULL if memory allocation fails; 152 | * if NULL, the buffer is discarded and freed 153 | * @return 0 for success or error code (probably AVERROR(ENOMEM)) 154 | */ 155 | int av_bprint_finalize(AVBPrint *buf, char **ret_str); 156 | 157 | #endif /* AVUTIL_BPRINT_H */ 158 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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_ARM 38 | # include "arm/bswap.h" 39 | #elif ARCH_AVR32 40 | # include "avr32/bswap.h" 41 | #elif ARCH_BFIN 42 | # include "bfin/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 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 | #define AV_CPU_FLAG_3DNOWEXT 0x0020 ///< AMD 3DNowExt 37 | #define AV_CPU_FLAG_SSE3 0x0040 ///< Prescott SSE3 functions 38 | #define AV_CPU_FLAG_SSE3SLOW 0x20000000 ///< SSE3 supported, but usually not faster 39 | #define AV_CPU_FLAG_SSSE3 0x0080 ///< Conroe SSSE3 functions 40 | #define AV_CPU_FLAG_ATOM 0x10000000 ///< Atom processor, some SSSE3 instructions are slower 41 | #define AV_CPU_FLAG_SSE4 0x0100 ///< Penryn SSE4.1 functions 42 | #define AV_CPU_FLAG_SSE42 0x0200 ///< Nehalem SSE4.2 functions 43 | #define AV_CPU_FLAG_AVX 0x4000 ///< AVX functions: requires OS support even if YMM registers aren't used 44 | #define AV_CPU_FLAG_XOP 0x0400 ///< Bulldozer XOP functions 45 | #define AV_CPU_FLAG_FMA4 0x0800 ///< Bulldozer FMA4 functions 46 | // #if LIBAVUTIL_VERSION_MAJOR <52 47 | #define AV_CPU_FLAG_CMOV 0x1001000 ///< supports cmov instruction 48 | // #else 49 | // #define AV_CPU_FLAG_CMOV 0x1000 ///< supports cmov instruction 50 | // #endif 51 | 52 | #define AV_CPU_FLAG_ALTIVEC 0x0001 ///< standard 53 | 54 | #define AV_CPU_FLAG_ARMV5TE (1 << 0) 55 | #define AV_CPU_FLAG_ARMV6 (1 << 1) 56 | #define AV_CPU_FLAG_ARMV6T2 (1 << 2) 57 | #define AV_CPU_FLAG_VFP (1 << 3) 58 | #define AV_CPU_FLAG_VFPV3 (1 << 4) 59 | #define AV_CPU_FLAG_NEON (1 << 5) 60 | 61 | /** 62 | * Return the flags which specify extensions supported by the CPU. 63 | */ 64 | int av_get_cpu_flags(void); 65 | 66 | /** 67 | * Disables cpu detection and forces the specified flags. 68 | * -1 is a special case that disables forcing of specific flags. 69 | */ 70 | void av_force_cpu_flags(int flags); 71 | 72 | /** 73 | * Set a mask on flags returned by av_get_cpu_flags(). 74 | * This function is mainly useful for testing. 75 | * Please use av_force_cpu_flags() and av_get_cpu_flags() instead which are more flexible 76 | * 77 | * @warning this function is not thread safe. 78 | */ 79 | attribute_deprecated void av_set_cpu_flags_mask(int mask); 80 | 81 | /** 82 | * Parse CPU flags from a string. 83 | * 84 | * The returned flags contain the specified flags as well as related unspecified flags. 85 | * 86 | * This function exists only for compatibility with libav. 87 | * Please use av_parse_cpu_caps() when possible. 88 | * @return a combination of AV_CPU_* flags, negative on error. 89 | */ 90 | attribute_deprecated 91 | int av_parse_cpu_flags(const char *s); 92 | 93 | /** 94 | * Parse CPU caps from a string and update the given AV_CPU_* flags based on that. 95 | * 96 | * @return negative on error. 97 | */ 98 | int av_parse_cpu_caps(unsigned *flags, const char *s); 99 | 100 | /* The following CPU-specific functions shall not be called directly. */ 101 | int ff_get_cpu_flags_arm(void); 102 | int ff_get_cpu_flags_ppc(void); 103 | int ff_get_cpu_flags_x86(void); 104 | 105 | #endif /* AVUTIL_CPU_H */ 106 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 | typedef uint32_t AVCRC; 29 | 30 | typedef enum { 31 | AV_CRC_8_ATM, 32 | AV_CRC_16_ANSI, 33 | AV_CRC_16_CCITT, 34 | AV_CRC_32_IEEE, 35 | AV_CRC_32_IEEE_LE, /*< reversed bitorder version of AV_CRC_32_IEEE */ 36 | AV_CRC_MAX, /*< Not part of public API! Do not use outside libavutil. */ 37 | }AVCRCId; 38 | 39 | int av_crc_init(AVCRC *ctx, int le, int bits, uint32_t poly, int ctx_size); 40 | const AVCRC *av_crc_get_table(AVCRCId crc_id); 41 | uint32_t av_crc(const AVCRC *ctx, uint32_t start_crc, const uint8_t *buffer, size_t length) av_pure; 42 | 43 | #endif /* AVUTIL_CRC_H */ 44 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/libavutil/dict.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 | * Public dictionary API. 23 | * @deprecated 24 | * AVDictionary is provided for compatibility with libav. It is both in 25 | * implementation as well as API inefficient. It does not scale and is 26 | * extremely slow with large dictionaries. 27 | * It is recommended that new code uses our tree container from tree.c/h 28 | * where applicable, which uses AVL trees to achieve O(log n) performance. 29 | */ 30 | 31 | #ifndef AVUTIL_DICT_H 32 | #define AVUTIL_DICT_H 33 | 34 | /** 35 | * @addtogroup lavu_dict AVDictionary 36 | * @ingroup lavu_data 37 | * 38 | * @brief Simple key:value store 39 | * 40 | * @{ 41 | * Dictionaries are used for storing key:value pairs. To create 42 | * an AVDictionary, simply pass an address of a NULL pointer to 43 | * av_dict_set(). NULL can be used as an empty dictionary wherever 44 | * a pointer to an AVDictionary is required. 45 | * Use av_dict_get() to retrieve an entry or iterate over all 46 | * entries and finally av_dict_free() to free the dictionary 47 | * and all its contents. 48 | * 49 | * @code 50 | * AVDictionary *d = NULL; // "create" an empty dictionary 51 | * av_dict_set(&d, "foo", "bar", 0); // add an entry 52 | * 53 | * char *k = av_strdup("key"); // if your strings are already allocated, 54 | * char *v = av_strdup("value"); // you can avoid copying them like this 55 | * av_dict_set(&d, k, v, AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL); 56 | * 57 | * AVDictionaryEntry *t = NULL; 58 | * while (t = av_dict_get(d, "", t, AV_DICT_IGNORE_SUFFIX)) { 59 | * <....> // iterate over all entries in d 60 | * } 61 | * 62 | * av_dict_free(&d); 63 | * @endcode 64 | * 65 | */ 66 | 67 | #define AV_DICT_MATCH_CASE 1 68 | #define AV_DICT_IGNORE_SUFFIX 2 69 | #define AV_DICT_DONT_STRDUP_KEY 4 /**< Take ownership of a key that's been 70 | allocated with av_malloc() and children. */ 71 | #define AV_DICT_DONT_STRDUP_VAL 8 /**< Take ownership of a value that's been 72 | allocated with av_malloc() and chilren. */ 73 | #define AV_DICT_DONT_OVERWRITE 16 ///< Don't overwrite existing entries. 74 | #define AV_DICT_APPEND 32 /**< If the entry already exists, append to it. Note that no 75 | delimiter is added, the strings are simply concatenated. */ 76 | 77 | typedef struct { 78 | char *key; 79 | char *value; 80 | } AVDictionaryEntry; 81 | 82 | typedef struct AVDictionary AVDictionary; 83 | 84 | /** 85 | * Get a dictionary entry with matching key. 86 | * 87 | * @param prev Set to the previous matching element to find the next. 88 | * If set to NULL the first matching element is returned. 89 | * @param flags Allows case as well as suffix-insensitive comparisons. 90 | * @return Found entry or NULL, changing key or value leads to undefined behavior. 91 | */ 92 | AVDictionaryEntry * 93 | av_dict_get(AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags); 94 | 95 | /** 96 | * Get number of entries in dictionary. 97 | * 98 | * @param m dictionary 99 | * @return number of entries in dictionary 100 | */ 101 | int av_dict_count(const AVDictionary *m); 102 | 103 | /** 104 | * Set the given entry in *pm, overwriting an existing entry. 105 | * 106 | * @param pm pointer to a pointer to a dictionary struct. If *pm is NULL 107 | * a dictionary struct is allocated and put in *pm. 108 | * @param key entry key to add to *pm (will be av_strduped depending on flags) 109 | * @param value entry value to add to *pm (will be av_strduped depending on flags). 110 | * Passing a NULL value will cause an existing entry to be deleted. 111 | * @return >= 0 on success otherwise an error code <0 112 | */ 113 | int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags); 114 | 115 | /** 116 | * Copy entries from one AVDictionary struct into another. 117 | * @param dst pointer to a pointer to a AVDictionary struct. If *dst is NULL, 118 | * this function will allocate a struct for you and put it in *dst 119 | * @param src pointer to source AVDictionary struct 120 | * @param flags flags to use when setting entries in *dst 121 | * @note metadata is read using the AV_DICT_IGNORE_SUFFIX flag 122 | */ 123 | void av_dict_copy(AVDictionary **dst, AVDictionary *src, int flags); 124 | 125 | /** 126 | * Free all the memory allocated for an AVDictionary struct 127 | * and all keys and values. 128 | */ 129 | void av_dict_free(AVDictionary **m); 130 | 131 | /** 132 | * @} 133 | */ 134 | 135 | #endif /* AVUTIL_DICT_H */ 136 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/libavutil/error.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 | * error code definitions 22 | */ 23 | 24 | #ifndef AVUTIL_ERROR_H 25 | #define AVUTIL_ERROR_H 26 | 27 | #include 28 | #include 29 | 30 | /** 31 | * @addtogroup lavu_error 32 | * 33 | * @{ 34 | */ 35 | 36 | 37 | /* error handling */ 38 | #if EDOM > 0 39 | #define AVERROR(e) (-(e)) ///< Returns a negative error code from a POSIX error code, to return from library functions. 40 | #define AVUNERROR(e) (-(e)) ///< Returns a POSIX error code from a library function error return value. 41 | #else 42 | /* Some platforms have E* and errno already negated. */ 43 | #define AVERROR(e) (e) 44 | #define AVUNERROR(e) (e) 45 | #endif 46 | 47 | #define FFERRTAG(a, b, c, d) (-(int)MKTAG(a, b, c, d)) 48 | 49 | #define AVERROR_BSF_NOT_FOUND FFERRTAG(0xF8,'B','S','F') ///< Bitstream filter not found 50 | #define AVERROR_BUG FFERRTAG( 'B','U','G','!') ///< Internal bug, also see AVERROR_BUG2 51 | #define AVERROR_BUFFER_TOO_SMALL FFERRTAG( 'B','U','F','S') ///< Buffer too small 52 | #define AVERROR_DECODER_NOT_FOUND FFERRTAG(0xF8,'D','E','C') ///< Decoder not found 53 | #define AVERROR_DEMUXER_NOT_FOUND FFERRTAG(0xF8,'D','E','M') ///< Demuxer not found 54 | #define AVERROR_ENCODER_NOT_FOUND FFERRTAG(0xF8,'E','N','C') ///< Encoder not found 55 | #define AVERROR_EOF FFERRTAG( 'E','O','F',' ') ///< End of file 56 | #define AVERROR_EXIT FFERRTAG( 'E','X','I','T') ///< Immediate exit was requested; the called function should not be restarted 57 | #define AVERROR_EXTERNAL FFERRTAG( 'E','X','T',' ') ///< Generic error in an external library 58 | #define AVERROR_FILTER_NOT_FOUND FFERRTAG(0xF8,'F','I','L') ///< Filter not found 59 | #define AVERROR_INVALIDDATA FFERRTAG( 'I','N','D','A') ///< Invalid data found when processing input 60 | #define AVERROR_MUXER_NOT_FOUND FFERRTAG(0xF8,'M','U','X') ///< Muxer not found 61 | #define AVERROR_OPTION_NOT_FOUND FFERRTAG(0xF8,'O','P','T') ///< Option not found 62 | #define AVERROR_PATCHWELCOME FFERRTAG( 'P','A','W','E') ///< Not yet implemented in FFmpeg, patches welcome 63 | #define AVERROR_PROTOCOL_NOT_FOUND FFERRTAG(0xF8,'P','R','O') ///< Protocol not found 64 | #define AVERROR_STREAM_NOT_FOUND FFERRTAG(0xF8,'S','T','R') ///< Stream not found 65 | 66 | /** 67 | * This is semantically identical to AVERROR_BUG 68 | * it has been introduced in Libav after our AVERROR_BUG and with a modified value. 69 | */ 70 | #define AVERROR_BUG2 FFERRTAG( 'B','U','G',' ') 71 | #define AVERROR_UNKNOWN FFERRTAG( 'U','N','K','N') ///< Unknown error, typically from an external library 72 | 73 | #define AV_ERROR_MAX_STRING_SIZE 64 74 | 75 | /** 76 | * Put a description of the AVERROR code errnum in errbuf. 77 | * In case of failure the global variable errno is set to indicate the 78 | * error. Even in case of failure av_strerror() will print a generic 79 | * error message indicating the errnum provided to errbuf. 80 | * 81 | * @param errnum error code to describe 82 | * @param errbuf buffer to which description is written 83 | * @param errbuf_size the size in bytes of errbuf 84 | * @return 0 on success, a negative value if a description for errnum 85 | * cannot be found 86 | */ 87 | int av_strerror(int errnum, char *errbuf, size_t errbuf_size); 88 | 89 | /** 90 | * Fill the provided buffer with a string containing an error string 91 | * corresponding to the AVERROR code errnum. 92 | * 93 | * @param errbuf a buffer 94 | * @param errbuf_size size in bytes of errbuf 95 | * @param errnum error code to describe 96 | * @return the buffer in input, filled with the error description 97 | * @see av_strerror() 98 | */ 99 | static inline char *av_make_error_string(char *errbuf, size_t errbuf_size, int errnum) 100 | { 101 | av_strerror(errnum, errbuf, errbuf_size); 102 | return errbuf; 103 | } 104 | 105 | /** 106 | * Convenience macro, the return value should be used only directly in 107 | * function arguments but never stand-alone. 108 | */ 109 | #define av_err2str(errnum) \ 110 | av_make_error_string((char[AV_ERROR_MAX_STRING_SIZE]){0}, AV_ERROR_MAX_STRING_SIZE, errnum) 111 | 112 | /** 113 | * @} 114 | */ 115 | 116 | #endif /* AVUTIL_ERROR_H */ 117 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 | #if FF_API_OLD_EVAL_NAMES 95 | /** 96 | * @deprecated Deprecated in favor of av_expr_parse_and_eval(). 97 | */ 98 | attribute_deprecated 99 | int av_parse_and_eval_expr(double *res, const char *s, 100 | const char * const *const_names, const double *const_values, 101 | const char * const *func1_names, double (* const *funcs1)(void *, double), 102 | const char * const *func2_names, double (* const *funcs2)(void *, double, double), 103 | void *opaque, int log_offset, void *log_ctx); 104 | 105 | /** 106 | * @deprecated Deprecated in favor of av_expr_parse(). 107 | */ 108 | attribute_deprecated 109 | int av_parse_expr(AVExpr **expr, const char *s, 110 | const char * const *const_names, 111 | const char * const *func1_names, double (* const *funcs1)(void *, double), 112 | const char * const *func2_names, double (* const *funcs2)(void *, double, double), 113 | int log_offset, void *log_ctx); 114 | /** 115 | * @deprecated Deprecated in favor of av_expr_eval(). 116 | */ 117 | attribute_deprecated 118 | double av_eval_expr(AVExpr *e, const double *const_values, void *opaque); 119 | 120 | /** 121 | * @deprecated Deprecated in favor of av_expr_free(). 122 | */ 123 | attribute_deprecated 124 | void av_free_expr(AVExpr *e); 125 | #endif /* FF_API_OLD_EVAL_NAMES */ 126 | 127 | /** 128 | * Parse the string in numstr and return its value as a double. If 129 | * the string is empty, contains only whitespaces, or does not contain 130 | * an initial substring that has the expected syntax for a 131 | * floating-point number, no conversion is performed. In this case, 132 | * returns a value of zero and the value returned in tail is the value 133 | * of numstr. 134 | * 135 | * @param numstr a string representing a number, may contain one of 136 | * the International System number postfixes, for example 'K', 'M', 137 | * 'G'. If 'i' is appended after the postfix, powers of 2 are used 138 | * instead of powers of 10. The 'B' postfix multiplies the value for 139 | * 8, and can be appended after another postfix or used alone. This 140 | * allows using for example 'KB', 'MiB', 'G' and 'B' as postfix. 141 | * @param tail if non-NULL puts here the pointer to the char next 142 | * after the last parsed character 143 | */ 144 | double av_strtod(const char *numstr, char **tail); 145 | 146 | #endif /* AVUTIL_EVAL_H */ 147 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 | * Free an AVFifoBuffer. 46 | * @param f AVFifoBuffer to free 47 | */ 48 | void av_fifo_free(AVFifoBuffer *f); 49 | 50 | /** 51 | * Reset the AVFifoBuffer to the state right after av_fifo_alloc, in particular it is emptied. 52 | * @param f AVFifoBuffer to reset 53 | */ 54 | void av_fifo_reset(AVFifoBuffer *f); 55 | 56 | /** 57 | * Return the amount of data in bytes in the AVFifoBuffer, that is the 58 | * amount of data you can read from it. 59 | * @param f AVFifoBuffer to read from 60 | * @return size 61 | */ 62 | int av_fifo_size(AVFifoBuffer *f); 63 | 64 | /** 65 | * Return the amount of space in bytes in the AVFifoBuffer, that is the 66 | * amount of data you can write into it. 67 | * @param f AVFifoBuffer to write into 68 | * @return size 69 | */ 70 | int av_fifo_space(AVFifoBuffer *f); 71 | 72 | /** 73 | * Feed data from an AVFifoBuffer to a user-supplied callback. 74 | * @param f AVFifoBuffer to read from 75 | * @param buf_size number of bytes to read 76 | * @param func generic read function 77 | * @param dest data destination 78 | */ 79 | int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void (*func)(void*, void*, int)); 80 | 81 | /** 82 | * Feed data from a user-supplied callback to an AVFifoBuffer. 83 | * @param f AVFifoBuffer to write to 84 | * @param src data source; non-const since it may be used as a 85 | * modifiable context by the function defined in func 86 | * @param size number of bytes to write 87 | * @param func generic write function; the first parameter is src, 88 | * the second is dest_buf, the third is dest_buf_size. 89 | * func must return the number of bytes written to dest_buf, or <= 0 to 90 | * indicate no more data available to write. 91 | * If func is NULL, src is interpreted as a simple byte array for source data. 92 | * @return the number of bytes written to the FIFO 93 | */ 94 | int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int (*func)(void*, void*, int)); 95 | 96 | /** 97 | * Resize an AVFifoBuffer. 98 | * In case of reallocation failure, the old FIFO is kept unchanged. 99 | * 100 | * @param f AVFifoBuffer to resize 101 | * @param size new AVFifoBuffer size in bytes 102 | * @return <0 for failure, >=0 otherwise 103 | */ 104 | int av_fifo_realloc2(AVFifoBuffer *f, unsigned int size); 105 | 106 | /** 107 | * Enlarge an AVFifoBuffer. 108 | * In case of reallocation failure, the old FIFO is kept unchanged. 109 | * The new fifo size may be larger than the requested size. 110 | * 111 | * @param f AVFifoBuffer to resize 112 | * @param additional_space the amount of space in bytes to allocate in addition to av_fifo_size() 113 | * @return <0 for failure, >=0 otherwise 114 | */ 115 | int av_fifo_grow(AVFifoBuffer *f, unsigned int additional_space); 116 | 117 | /** 118 | * Read and discard the specified amount of data from an AVFifoBuffer. 119 | * @param f AVFifoBuffer to read from 120 | * @param size amount of data to read in bytes 121 | */ 122 | void av_fifo_drain(AVFifoBuffer *f, int size); 123 | 124 | /** 125 | * Return a pointer to the data stored in a FIFO buffer at a certain offset. 126 | * The FIFO buffer is not modified. 127 | * 128 | * @param f AVFifoBuffer to peek at, f must be non-NULL 129 | * @param offs an offset in bytes, its absolute value must be less 130 | * than the used buffer size or the returned pointer will 131 | * point outside to the buffer data. 132 | * The used buffer size can be checked with av_fifo_size(). 133 | */ 134 | static inline uint8_t *av_fifo_peek2(const AVFifoBuffer *f, int offs) 135 | { 136 | uint8_t *ptr = f->rptr + offs; 137 | if (ptr >= f->end) 138 | ptr = f->buffer + (ptr - f->end); 139 | else if (ptr < f->buffer) 140 | ptr = f->end - (f->buffer - ptr); 141 | return ptr; 142 | } 143 | 144 | #if FF_API_AV_FIFO_PEEK 145 | /** 146 | * @deprecated Use av_fifo_peek2() instead. 147 | */ 148 | attribute_deprecated 149 | static inline uint8_t av_fifo_peek(AVFifoBuffer *f, int offs) 150 | { 151 | return *av_fifo_peek2(f, offs); 152 | } 153 | #endif 154 | 155 | #endif /* AVUTIL_FIFO_H */ 156 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 -1 on error) 59 | * and opened file name in **filename. 60 | */ 61 | int av_tempfile(const char *prefix, char **filename, int log_offset, void *log_ctx); 62 | 63 | #endif /* AVUTIL_FILE_H */ 64 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/libavutil/imgutils.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_IMGUTILS_H 20 | #define AVUTIL_IMGUTILS_H 21 | 22 | /** 23 | * @file 24 | * misc image utilities 25 | * 26 | * @addtogroup lavu_picture 27 | * @{ 28 | */ 29 | 30 | #include "avutil.h" 31 | #include "pixdesc.h" 32 | 33 | /** 34 | * Compute the max pixel step for each plane of an image with a 35 | * format described by pixdesc. 36 | * 37 | * The pixel step is the distance in bytes between the first byte of 38 | * the group of bytes which describe a pixel component and the first 39 | * byte of the successive group in the same plane for the same 40 | * component. 41 | * 42 | * @param max_pixsteps an array which is filled with the max pixel step 43 | * for each plane. Since a plane may contain different pixel 44 | * components, the computed max_pixsteps[plane] is relative to the 45 | * component in the plane with the max pixel step. 46 | * @param max_pixstep_comps an array which is filled with the component 47 | * for each plane which has the max pixel step. May be NULL. 48 | */ 49 | void av_image_fill_max_pixsteps(int max_pixsteps[4], int max_pixstep_comps[4], 50 | const AVPixFmtDescriptor *pixdesc); 51 | 52 | /** 53 | * Compute the size of an image line with format pix_fmt and width 54 | * width for the plane plane. 55 | * 56 | * @return the computed size in bytes 57 | */ 58 | int av_image_get_linesize(enum PixelFormat pix_fmt, int width, int plane); 59 | 60 | /** 61 | * Fill plane linesizes for an image with pixel format pix_fmt and 62 | * width width. 63 | * 64 | * @param linesizes array to be filled with the linesize for each plane 65 | * @return >= 0 in case of success, a negative error code otherwise 66 | */ 67 | int av_image_fill_linesizes(int linesizes[4], enum PixelFormat pix_fmt, int width); 68 | 69 | /** 70 | * Fill plane data pointers for an image with pixel format pix_fmt and 71 | * height height. 72 | * 73 | * @param data pointers array to be filled with the pointer for each image plane 74 | * @param ptr the pointer to a buffer which will contain the image 75 | * @param linesizes the array containing the linesize for each 76 | * plane, should be filled by av_image_fill_linesizes() 77 | * @return the size in bytes required for the image buffer, a negative 78 | * error code in case of failure 79 | */ 80 | int av_image_fill_pointers(uint8_t *data[4], enum PixelFormat pix_fmt, int height, 81 | uint8_t *ptr, const int linesizes[4]); 82 | 83 | /** 84 | * Allocate an image with size w and h and pixel format pix_fmt, and 85 | * fill pointers and linesizes accordingly. 86 | * The allocated image buffer has to be freed by using 87 | * av_freep(&pointers[0]). 88 | * 89 | * @param align the value to use for buffer size alignment 90 | * @return the size in bytes required for the image buffer, a negative 91 | * error code in case of failure 92 | */ 93 | int av_image_alloc(uint8_t *pointers[4], int linesizes[4], 94 | int w, int h, enum PixelFormat pix_fmt, int align); 95 | 96 | /** 97 | * Copy image plane from src to dst. 98 | * That is, copy "height" number of lines of "bytewidth" bytes each. 99 | * The first byte of each successive line is separated by *_linesize 100 | * bytes. 101 | * 102 | * @param dst_linesize linesize for the image plane in dst 103 | * @param src_linesize linesize for the image plane in src 104 | */ 105 | void av_image_copy_plane(uint8_t *dst, int dst_linesize, 106 | const uint8_t *src, int src_linesize, 107 | int bytewidth, int height); 108 | 109 | /** 110 | * Copy image in src_data to dst_data. 111 | * 112 | * @param dst_linesizes linesizes for the image in dst_data 113 | * @param src_linesizes linesizes for the image in src_data 114 | */ 115 | void av_image_copy(uint8_t *dst_data[4], int dst_linesizes[4], 116 | const uint8_t *src_data[4], const int src_linesizes[4], 117 | enum PixelFormat pix_fmt, int width, int height); 118 | 119 | /** 120 | * Setup the data pointers and linesizes based on the specified image 121 | * parameters and the provided array. 122 | * 123 | * The fields of the given image are filled in by using the src 124 | * address which points to the image data buffer. Depending on the 125 | * specified pixel format, one or multiple image data pointers and 126 | * line sizes will be set. If a planar format is specified, several 127 | * pointers will be set pointing to the different picture planes and 128 | * the line sizes of the different planes will be stored in the 129 | * lines_sizes array. Call with src == NULL to get the required 130 | * size for the src buffer. 131 | * 132 | * To allocate the buffer and fill in the dst_data and dst_linesize in 133 | * one call, use av_image_alloc(). 134 | * 135 | * @param dst_data data pointers to be filled in 136 | * @param dst_linesizes linesizes for the image in dst_data to be filled in 137 | * @param src buffer which will contain or contains the actual image data, can be NULL 138 | * @param pix_fmt the pixel format of the image 139 | * @param width the width of the image in pixels 140 | * @param height the height of the image in pixels 141 | * @param align the value used in src for linesize alignment 142 | * @return the size in bytes required for src, a negative error code 143 | * in case of failure 144 | */ 145 | int av_image_fill_arrays(uint8_t *dst_data[4], int dst_linesize[4], 146 | const uint8_t *src, 147 | enum PixelFormat pix_fmt, int width, int height, int align); 148 | 149 | /** 150 | * Return the size in bytes of the amount of data required to store an 151 | * image with the given parameters. 152 | * 153 | * @param[in] align the assumed linesize alignment 154 | */ 155 | int av_image_get_buffer_size(enum PixelFormat pix_fmt, int width, int height, int align); 156 | 157 | /** 158 | * Copy image data from an image into a buffer. 159 | * 160 | * av_image_get_buffer_size() can be used to compute the required size 161 | * for the buffer to fill. 162 | * 163 | * @param dst a buffer into which picture data will be copied 164 | * @param dst_size the size in bytes of dst 165 | * @param src_data pointers containing the source image data 166 | * @param src_linesizes linesizes for the image in src_data 167 | * @param pix_fmt the pixel format of the source image 168 | * @param width the width of the source image in pixels 169 | * @param height the height of the source image in pixels 170 | * @param align the assumed linesize alignment for dst 171 | * @return the number of bytes written to dst, or a negative value 172 | * (error code) on error 173 | */ 174 | int av_image_copy_to_buffer(uint8_t *dst, int dst_size, 175 | const uint8_t * const src_data[4], const int src_linesize[4], 176 | enum PixelFormat pix_fmt, int width, int height, int align); 177 | 178 | /** 179 | * Check if the given dimension of an image is valid, meaning that all 180 | * bytes of the image can be addressed with a signed int. 181 | * 182 | * @param w the width of the picture 183 | * @param h the height of the picture 184 | * @param log_offset the offset to sum to the log level for logging with log_ctx 185 | * @param log_ctx the parent logging context, it may be NULL 186 | * @return >= 0 if valid, a negative error code otherwise 187 | */ 188 | int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx); 189 | 190 | int ff_set_systematic_pal2(uint32_t pal[256], enum PixelFormat pix_fmt); 191 | 192 | /** 193 | * @} 194 | */ 195 | 196 | 197 | #endif /* AVUTIL_IMGUTILS_H */ 198 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/libavutil/intfloat.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2011 Mans Rullgard 3 | * 4 | * This file is part of Libav. 5 | * 6 | * Libav 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 | * Libav 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 Libav; 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 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/libavutil/intfloat_readwrite.h: -------------------------------------------------------------------------------- 1 | /* 2 | * copyright (c) 2005 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_INTFLOAT_READWRITE_H 22 | #define AVUTIL_INTFLOAT_READWRITE_H 23 | 24 | #include 25 | #include "attributes.h" 26 | 27 | /* IEEE 80 bits extended float */ 28 | typedef struct AVExtFloat { 29 | uint8_t exponent[2]; 30 | uint8_t mantissa[8]; 31 | } AVExtFloat; 32 | 33 | attribute_deprecated double av_int2dbl(int64_t v) av_const; 34 | attribute_deprecated float av_int2flt(int32_t v) av_const; 35 | attribute_deprecated double av_ext2dbl(const AVExtFloat ext) av_const; 36 | attribute_deprecated int64_t av_dbl2int(double d) av_const; 37 | attribute_deprecated int32_t av_flt2int(float d) av_const; 38 | attribute_deprecated AVExtFloat av_dbl2ext(double d) av_const; 39 | 40 | #endif /* AVUTIL_INTFLOAT_READWRITE_H */ 41 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 { 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 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/libavutil/log.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_LOG_H 22 | #define AVUTIL_LOG_H 23 | 24 | #include 25 | #include "avutil.h" 26 | #include "attributes.h" 27 | 28 | typedef enum { 29 | AV_CLASS_CATEGORY_NA = 0, 30 | AV_CLASS_CATEGORY_INPUT, 31 | AV_CLASS_CATEGORY_OUTPUT, 32 | AV_CLASS_CATEGORY_MUXER, 33 | AV_CLASS_CATEGORY_DEMUXER, 34 | AV_CLASS_CATEGORY_ENCODER, 35 | AV_CLASS_CATEGORY_DECODER, 36 | AV_CLASS_CATEGORY_FILTER, 37 | AV_CLASS_CATEGORY_BITSTREAM_FILTER, 38 | AV_CLASS_CATEGORY_SWSCALER, 39 | AV_CLASS_CATEGORY_SWRESAMPLER, 40 | AV_CLASS_CATEGORY_NB, ///< not part of ABI/API 41 | }AVClassCategory; 42 | 43 | /** 44 | * Describe the class of an AVClass context structure. That is an 45 | * arbitrary struct of which the first field is a pointer to an 46 | * AVClass struct (e.g. AVCodecContext, AVFormatContext etc.). 47 | */ 48 | typedef struct AVClass { 49 | /** 50 | * The name of the class; usually it is the same name as the 51 | * context structure type to which the AVClass is associated. 52 | */ 53 | const char* class_name; 54 | 55 | /** 56 | * A pointer to a function which returns the name of a context 57 | * instance ctx associated with the class. 58 | */ 59 | const char* (*item_name)(void* ctx); 60 | 61 | /** 62 | * a pointer to the first option specified in the class if any or NULL 63 | * 64 | * @see av_set_default_options() 65 | */ 66 | const struct AVOption *option; 67 | 68 | /** 69 | * LIBAVUTIL_VERSION with which this structure was created. 70 | * This is used to allow fields to be added without requiring major 71 | * version bumps everywhere. 72 | */ 73 | 74 | int version; 75 | 76 | /** 77 | * Offset in the structure where log_level_offset is stored. 78 | * 0 means there is no such variable 79 | */ 80 | int log_level_offset_offset; 81 | 82 | /** 83 | * Offset in the structure where a pointer to the parent context for loging is stored. 84 | * for example a decoder that uses eval.c could pass its AVCodecContext to eval as such 85 | * parent context. And a av_log() implementation could then display the parent context 86 | * can be NULL of course 87 | */ 88 | int parent_log_context_offset; 89 | 90 | /** 91 | * Return next AVOptions-enabled child or NULL 92 | */ 93 | void* (*child_next)(void *obj, void *prev); 94 | 95 | /** 96 | * Return an AVClass corresponding to next potential 97 | * AVOptions-enabled child. 98 | * 99 | * The difference between child_next and this is that 100 | * child_next iterates over _already existing_ objects, while 101 | * child_class_next iterates over _all possible_ children. 102 | */ 103 | const struct AVClass* (*child_class_next)(const struct AVClass *prev); 104 | 105 | /** 106 | * Category used for visualization (like color) 107 | * This is only set if the category is equal for all objects using this class. 108 | * available since version (51 << 16 | 56 << 8 | 100) 109 | */ 110 | AVClassCategory category; 111 | 112 | /** 113 | * Callback to return the category. 114 | * available since version (51 << 16 | 59 << 8 | 100) 115 | */ 116 | AVClassCategory (*get_category)(void* ctx); 117 | } AVClass; 118 | 119 | /* av_log API */ 120 | 121 | #define AV_LOG_QUIET -8 122 | 123 | /** 124 | * Something went really wrong and we will crash now. 125 | */ 126 | #define AV_LOG_PANIC 0 127 | 128 | /** 129 | * Something went wrong and recovery is not possible. 130 | * For example, no header was found for a format which depends 131 | * on headers or an illegal combination of parameters is used. 132 | */ 133 | #define AV_LOG_FATAL 8 134 | 135 | /** 136 | * Something went wrong and cannot losslessly be recovered. 137 | * However, not all future data is affected. 138 | */ 139 | #define AV_LOG_ERROR 16 140 | 141 | /** 142 | * Something somehow does not look correct. This may or may not 143 | * lead to problems. An example would be the use of '-vstrict -2'. 144 | */ 145 | #define AV_LOG_WARNING 24 146 | 147 | #define AV_LOG_INFO 32 148 | #define AV_LOG_VERBOSE 40 149 | 150 | /** 151 | * Stuff which is only useful for libav* developers. 152 | */ 153 | #define AV_LOG_DEBUG 48 154 | 155 | #define AV_LOG_MAX_OFFSET (AV_LOG_DEBUG - AV_LOG_QUIET) 156 | 157 | /** 158 | * Send the specified message to the log if the level is less than or equal 159 | * to the current av_log_level. By default, all logging messages are sent to 160 | * stderr. This behavior can be altered by setting a different av_vlog callback 161 | * function. 162 | * 163 | * @param avcl A pointer to an arbitrary struct of which the first field is a 164 | * pointer to an AVClass struct. 165 | * @param level The importance level of the message, lower values signifying 166 | * higher importance. 167 | * @param fmt The format string (printf-compatible) that specifies how 168 | * subsequent arguments are converted to output. 169 | * @see av_vlog 170 | */ 171 | void av_log(void *avcl, int level, const char *fmt, ...) av_printf_format(3, 4); 172 | 173 | void av_vlog(void *avcl, int level, const char *fmt, va_list); 174 | int av_log_get_level(void); 175 | void av_log_set_level(int); 176 | void av_log_set_callback(void (*)(void*, int, const char*, va_list)); 177 | void av_log_default_callback(void* ptr, int level, const char* fmt, va_list vl); 178 | const char* av_default_item_name(void* ctx); 179 | AVClassCategory av_default_get_category(void *ptr); 180 | 181 | /** 182 | * Format a line of log the same way as the default callback. 183 | * @param line buffer to receive the formated line 184 | * @param line_size size of the buffer 185 | * @param print_prefix used to store whether the prefix must be printed; 186 | * must point to a persistent integer initially set to 1 187 | */ 188 | void av_log_format_line(void *ptr, int level, const char *fmt, va_list vl, 189 | char *line, int line_size, int *print_prefix); 190 | 191 | /** 192 | * av_dlog macros 193 | * Useful to print debug messages that shouldn't get compiled in normally. 194 | */ 195 | 196 | #ifdef DEBUG 197 | # define av_dlog(pctx, ...) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__) 198 | #else 199 | # define av_dlog(pctx, ...) do { if (0) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__); } while (0) 200 | #endif 201 | 202 | /** 203 | * Skip repeated messages, this requires the user app to use av_log() instead of 204 | * (f)printf as the 2 would otherwise interfere and lead to 205 | * "Last message repeated x times" messages below (f)printf messages with some 206 | * bad luck. 207 | * Also to receive the last, "last repeated" line if any, the user app must 208 | * call av_log(NULL, AV_LOG_QUIET, "%s", ""); at the end 209 | */ 210 | #define AV_LOG_SKIP_REPEATED 1 211 | void av_log_set_flags(int arg); 212 | 213 | #endif /* AVUTIL_LOG_H */ 214 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 | * @brief deliberately overlapping memcpy implementation 64 | * @param dst destination buffer; must be padded with 12 additional bytes 65 | * @param back how many bytes back we start (the initial size of the overlapping window), must be > 0 66 | * @param cnt number of bytes to copy, must be >= 0 67 | * 68 | * cnt > back is valid, this will copy the bytes we just copied, 69 | * thus creating a repeating pattern with a period length of back. 70 | */ 71 | void av_memcpy_backptr(uint8_t *dst, int back, int cnt); 72 | 73 | /** 74 | * @} 75 | */ 76 | 77 | #endif /* AVUTIL_LZO_H */ 78 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/libavutil/mathematics.h: -------------------------------------------------------------------------------- 1 | /* 2 | * copyright (c) 2005 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_MATHEMATICS_H 22 | #define AVUTIL_MATHEMATICS_H 23 | 24 | #include 25 | #include 26 | #include "attributes.h" 27 | #include "rational.h" 28 | #include "intfloat.h" 29 | 30 | #ifndef M_E 31 | #define M_E 2.7182818284590452354 /* e */ 32 | #endif 33 | #ifndef M_LN2 34 | #define M_LN2 0.69314718055994530942 /* log_e 2 */ 35 | #endif 36 | #ifndef M_LN10 37 | #define M_LN10 2.30258509299404568402 /* log_e 10 */ 38 | #endif 39 | #ifndef M_LOG2_10 40 | #define M_LOG2_10 3.32192809488736234787 /* log_2 10 */ 41 | #endif 42 | #ifndef M_PHI 43 | #define M_PHI 1.61803398874989484820 /* phi / golden ratio */ 44 | #endif 45 | #ifndef M_PI 46 | #define M_PI 3.14159265358979323846 /* pi */ 47 | #endif 48 | #ifndef M_SQRT1_2 49 | #define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */ 50 | #endif 51 | #ifndef M_SQRT2 52 | #define M_SQRT2 1.41421356237309504880 /* sqrt(2) */ 53 | #endif 54 | #ifndef NAN 55 | #define NAN av_int2float(0x7fc00000) 56 | #endif 57 | #ifndef INFINITY 58 | #define INFINITY av_int2float(0x7f800000) 59 | #endif 60 | 61 | /** 62 | * @addtogroup lavu_math 63 | * @{ 64 | */ 65 | 66 | 67 | enum AVRounding { 68 | AV_ROUND_ZERO = 0, ///< Round toward zero. 69 | AV_ROUND_INF = 1, ///< Round away from zero. 70 | AV_ROUND_DOWN = 2, ///< Round toward -infinity. 71 | AV_ROUND_UP = 3, ///< Round toward +infinity. 72 | AV_ROUND_NEAR_INF = 5, ///< Round to nearest and halfway cases away from zero. 73 | }; 74 | 75 | /** 76 | * Return the greatest common divisor of a and b. 77 | * If both a and b are 0 or either or both are <0 then behavior is 78 | * undefined. 79 | */ 80 | int64_t av_const av_gcd(int64_t a, int64_t b); 81 | 82 | /** 83 | * Rescale a 64-bit integer with rounding to nearest. 84 | * A simple a*b/c isn't possible as it can overflow. 85 | */ 86 | int64_t av_rescale(int64_t a, int64_t b, int64_t c) av_const; 87 | 88 | /** 89 | * Rescale a 64-bit integer with specified rounding. 90 | * A simple a*b/c isn't possible as it can overflow. 91 | */ 92 | int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding) av_const; 93 | 94 | /** 95 | * Rescale a 64-bit integer by 2 rational numbers. 96 | */ 97 | int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq) av_const; 98 | 99 | /** 100 | * Rescale a 64-bit integer by 2 rational numbers with specified rounding. 101 | */ 102 | int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq, 103 | enum AVRounding) av_const; 104 | 105 | /** 106 | * Compare 2 timestamps each in its own timebases. 107 | * The result of the function is undefined if one of the timestamps 108 | * is outside the int64_t range when represented in the others timebase. 109 | * @return -1 if ts_a is before ts_b, 1 if ts_a is after ts_b or 0 if they represent the same position 110 | */ 111 | int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b); 112 | 113 | /** 114 | * Compare 2 integers modulo mod. 115 | * That is we compare integers a and b for which only the least 116 | * significant log2(mod) bits are known. 117 | * 118 | * @param mod must be a power of 2 119 | * @return a negative value if a is smaller than b 120 | * a positive value if a is greater than b 121 | * 0 if a equals b 122 | */ 123 | int64_t av_compare_mod(uint64_t a, uint64_t b, uint64_t mod); 124 | 125 | /** 126 | * @} 127 | */ 128 | 129 | #endif /* AVUTIL_MATHEMATICS_H */ 130 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 | /** 27 | * @defgroup lavu_md5 MD5 28 | * @ingroup lavu_crypto 29 | * @{ 30 | */ 31 | 32 | extern const int av_md5_size; 33 | 34 | struct AVMD5; 35 | 36 | void av_md5_init(struct AVMD5 *ctx); 37 | void av_md5_update(struct AVMD5 *ctx, const uint8_t *src, const int len); 38 | void av_md5_final(struct AVMD5 *ctx, uint8_t *dst); 39 | void av_md5_sum(uint8_t *dst, const uint8_t *src, const int len); 40 | 41 | /** 42 | * @} 43 | */ 44 | 45 | #endif /* AVUTIL_MD5_H */ 46 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/libavutil/mem.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 | * memory handling functions 24 | */ 25 | 26 | #ifndef AVUTIL_MEM_H 27 | #define AVUTIL_MEM_H 28 | 29 | #include 30 | 31 | #include "attributes.h" 32 | #include "error.h" 33 | #include "avutil.h" 34 | 35 | /** 36 | * @addtogroup lavu_mem 37 | * @{ 38 | */ 39 | 40 | 41 | #if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1110 || defined(__SUNPRO_C) 42 | #define DECLARE_ALIGNED(n,t,v) t __attribute__ ((aligned (n))) v 43 | #define DECLARE_ASM_CONST(n,t,v) const t __attribute__ ((aligned (n))) v 44 | #elif defined(__TI_COMPILER_VERSION__) 45 | #define DECLARE_ALIGNED(n,t,v) \ 46 | AV_PRAGMA(DATA_ALIGN(v,n)) \ 47 | t __attribute__((aligned(n))) v 48 | #define DECLARE_ASM_CONST(n,t,v) \ 49 | AV_PRAGMA(DATA_ALIGN(v,n)) \ 50 | static const t __attribute__((aligned(n))) v 51 | #elif defined(__GNUC__) 52 | #define DECLARE_ALIGNED(n,t,v) t __attribute__ ((aligned (n))) v 53 | #define DECLARE_ASM_CONST(n,t,v) static const t av_used __attribute__ ((aligned (n))) v 54 | #elif defined(_MSC_VER) 55 | #define DECLARE_ALIGNED(n,t,v) __declspec(align(n)) t v 56 | #define DECLARE_ASM_CONST(n,t,v) __declspec(align(n)) static const t v 57 | #else 58 | #define DECLARE_ALIGNED(n,t,v) t v 59 | #define DECLARE_ASM_CONST(n,t,v) static const t v 60 | #endif 61 | 62 | #if AV_GCC_VERSION_AT_LEAST(3,1) 63 | #define av_malloc_attrib __attribute__((__malloc__)) 64 | #else 65 | #define av_malloc_attrib 66 | #endif 67 | 68 | #if AV_GCC_VERSION_AT_LEAST(4,3) 69 | #define av_alloc_size(...) __attribute__((alloc_size(__VA_ARGS__))) 70 | #else 71 | #define av_alloc_size(...) 72 | #endif 73 | 74 | /** 75 | * Allocate a block of size bytes with alignment suitable for all 76 | * memory accesses (including vectors if available on the CPU). 77 | * @param size Size in bytes for the memory block to be allocated. 78 | * @return Pointer to the allocated block, NULL if the block cannot 79 | * be allocated. 80 | * @see av_mallocz() 81 | */ 82 | void *av_malloc(size_t size) av_malloc_attrib av_alloc_size(1); 83 | 84 | /** 85 | * Helper function to allocate a block of size * nmemb bytes with 86 | * using av_malloc() 87 | * @param nmemb Number of elements 88 | * @param size Size of the single element 89 | * @return Pointer to the allocated block, NULL if the block cannot 90 | * be allocated. 91 | * @see av_malloc() 92 | */ 93 | av_alloc_size(1,2) static inline void *av_malloc_array(size_t nmemb, size_t size) 94 | { 95 | if (size <= 0 || nmemb >= INT_MAX / size) 96 | return NULL; 97 | return av_malloc(nmemb * size); 98 | } 99 | 100 | /** 101 | * Allocate or reallocate a block of memory. 102 | * If ptr is NULL and size > 0, allocate a new block. If 103 | * size is zero, free the memory block pointed to by ptr. 104 | * @param ptr Pointer to a memory block already allocated with 105 | * av_malloc(z)() or av_realloc() or NULL. 106 | * @param size Size in bytes for the memory block to be allocated or 107 | * reallocated. 108 | * @return Pointer to a newly reallocated block or NULL if the block 109 | * cannot be reallocated or the function is used to free the memory block. 110 | * @see av_fast_realloc() 111 | */ 112 | void *av_realloc(void *ptr, size_t size) av_alloc_size(2); 113 | 114 | /** 115 | * Allocate or reallocate a block of memory. 116 | * This function does the same thing as av_realloc, except: 117 | * - It takes two arguments and checks the result of the multiplication for 118 | * integer overflow. 119 | * - It frees the input block in case of failure, thus avoiding the memory 120 | * leak with the classic "buf = realloc(buf); if (!buf) return -1;". 121 | */ 122 | void *av_realloc_f(void *ptr, size_t nelem, size_t elsize); 123 | 124 | /** 125 | * Free a memory block which has been allocated with av_malloc(z)() or 126 | * av_realloc(). 127 | * @param ptr Pointer to the memory block which should be freed. 128 | * @note ptr = NULL is explicitly allowed. 129 | * @note It is recommended that you use av_freep() instead. 130 | * @see av_freep() 131 | */ 132 | void av_free(void *ptr); 133 | 134 | /** 135 | * Allocate a block of size bytes with alignment suitable for all 136 | * memory accesses (including vectors if available on the CPU) and 137 | * zero all the bytes of the block. 138 | * @param size Size in bytes for the memory block to be allocated. 139 | * @return Pointer to the allocated block, NULL if it cannot be allocated. 140 | * @see av_malloc() 141 | */ 142 | void *av_mallocz(size_t size) av_malloc_attrib av_alloc_size(1); 143 | 144 | /** 145 | * Allocate a block of nmemb * size bytes with alignment suitable for all 146 | * memory accesses (including vectors if available on the CPU) and 147 | * zero all the bytes of the block. 148 | * The allocation will fail if nmemb * size is greater than or equal 149 | * to INT_MAX. 150 | * @param nmemb 151 | * @param size 152 | * @return Pointer to the allocated block, NULL if it cannot be allocated. 153 | */ 154 | void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib; 155 | 156 | /** 157 | * Helper function to allocate a block of size * nmemb bytes with 158 | * using av_mallocz() 159 | * @param nmemb Number of elements 160 | * @param size Size of the single element 161 | * @return Pointer to the allocated block, NULL if the block cannot 162 | * be allocated. 163 | * @see av_mallocz() 164 | * @see av_malloc_array() 165 | */ 166 | av_alloc_size(1,2) static inline void *av_mallocz_array(size_t nmemb, size_t size) 167 | { 168 | if (size <= 0 || nmemb >= INT_MAX / size) 169 | return NULL; 170 | return av_mallocz(nmemb * size); 171 | } 172 | 173 | /** 174 | * Duplicate the string s. 175 | * @param s string to be duplicated 176 | * @return Pointer to a newly allocated string containing a 177 | * copy of s or NULL if the string cannot be allocated. 178 | */ 179 | char *av_strdup(const char *s) av_malloc_attrib; 180 | 181 | /** 182 | * Free a memory block which has been allocated with av_malloc(z)() or 183 | * av_realloc() and set the pointer pointing to it to NULL. 184 | * @param ptr Pointer to the pointer to the memory block which should 185 | * be freed. 186 | * @see av_free() 187 | */ 188 | void av_freep(void *ptr); 189 | 190 | /** 191 | * Add an element to a dynamic array. 192 | * 193 | * @param tab_ptr Pointer to the array. 194 | * @param nb_ptr Pointer to the number of elements in the array. 195 | * @param elem Element to be added. 196 | */ 197 | void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem); 198 | 199 | /** 200 | * Multiply two size_t values checking for overflow. 201 | * @return 0 if success, AVERROR(EINVAL) if overflow. 202 | */ 203 | static inline int av_size_mult(size_t a, size_t b, size_t *r) 204 | { 205 | size_t t = a * b; 206 | /* Hack inspired from glibc: only try the division if nelem and elsize 207 | * are both greater than sqrt(SIZE_MAX). */ 208 | if ((a | b) >= ((size_t)1 << (sizeof(size_t) * 4)) && a && t / a != b) 209 | return AVERROR(EINVAL); 210 | *r = t; 211 | return 0; 212 | } 213 | 214 | /** 215 | * Set the maximum size that may me allocated in one block. 216 | */ 217 | void av_max_alloc(size_t max); 218 | 219 | /** 220 | * @} 221 | */ 222 | 223 | #endif /* AVUTIL_MEM_H */ 224 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/libavutil/parseutils.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_PARSEUTILS_H 20 | #define AVUTIL_PARSEUTILS_H 21 | 22 | #include 23 | 24 | #include "rational.h" 25 | 26 | /** 27 | * @file 28 | * misc parsing utilities 29 | */ 30 | 31 | /** 32 | * Parse str and store the parsed ratio in q. 33 | * 34 | * Note that a ratio with infinite (1/0) or negative value is 35 | * considered valid, so you should check on the returned value if you 36 | * want to exclude those values. 37 | * 38 | * The undefined value can be expressed using the "0:0" string. 39 | * 40 | * @param[in,out] q pointer to the AVRational which will contain the ratio 41 | * @param[in] str the string to parse: it has to be a string in the format 42 | * num:den, a float number or an expression 43 | * @param[in] max the maximum allowed numerator and denominator 44 | * @param[in] log_offset log level offset which is applied to the log 45 | * level of log_ctx 46 | * @param[in] log_ctx parent logging context 47 | * @return >= 0 on success, a negative error code otherwise 48 | */ 49 | int av_parse_ratio(AVRational *q, const char *str, int max, 50 | int log_offset, void *log_ctx); 51 | 52 | #define av_parse_ratio_quiet(rate, str, max) \ 53 | av_parse_ratio(rate, str, max, AV_LOG_MAX_OFFSET, NULL) 54 | 55 | /** 56 | * Parse str and put in width_ptr and height_ptr the detected values. 57 | * 58 | * @param[in,out] width_ptr pointer to the variable which will contain the detected 59 | * width value 60 | * @param[in,out] height_ptr pointer to the variable which will contain the detected 61 | * height value 62 | * @param[in] str the string to parse: it has to be a string in the format 63 | * width x height or a valid video size abbreviation. 64 | * @return >= 0 on success, a negative error code otherwise 65 | */ 66 | int av_parse_video_size(int *width_ptr, int *height_ptr, const char *str); 67 | 68 | /** 69 | * Parse str and store the detected values in *rate. 70 | * 71 | * @param[in,out] rate pointer to the AVRational which will contain the detected 72 | * frame rate 73 | * @param[in] str the string to parse: it has to be a string in the format 74 | * rate_num / rate_den, a float number or a valid video rate abbreviation 75 | * @return >= 0 on success, a negative error code otherwise 76 | */ 77 | int av_parse_video_rate(AVRational *rate, const char *str); 78 | 79 | /** 80 | * Put the RGBA values that correspond to color_string in rgba_color. 81 | * 82 | * @param color_string a string specifying a color. It can be the name of 83 | * a color (case insensitive match) or a [0x|#]RRGGBB[AA] sequence, 84 | * possibly followed by "@" and a string representing the alpha 85 | * component. 86 | * The alpha component may be a string composed by "0x" followed by an 87 | * hexadecimal number or a decimal number between 0.0 and 1.0, which 88 | * represents the opacity value (0x00/0.0 means completely transparent, 89 | * 0xff/1.0 completely opaque). 90 | * If the alpha component is not specified then 0xff is assumed. 91 | * The string "random" will result in a random color. 92 | * @param slen length of the initial part of color_string containing the 93 | * color. It can be set to -1 if color_string is a null terminated string 94 | * containing nothing else than the color. 95 | * @return >= 0 in case of success, a negative value in case of 96 | * failure (for example if color_string cannot be parsed). 97 | */ 98 | int av_parse_color(uint8_t *rgba_color, const char *color_string, int slen, 99 | void *log_ctx); 100 | 101 | /** 102 | * Parse timestr and return in *time a corresponding number of 103 | * microseconds. 104 | * 105 | * @param timeval puts here the number of microseconds corresponding 106 | * to the string in timestr. If the string represents a duration, it 107 | * is the number of microseconds contained in the time interval. If 108 | * the string is a date, is the number of microseconds since 1st of 109 | * January, 1970 up to the time of the parsed date. If timestr cannot 110 | * be successfully parsed, set *time to INT64_MIN. 111 | 112 | * @param timestr a string representing a date or a duration. 113 | * - If a date the syntax is: 114 | * @code 115 | * [{YYYY-MM-DD|YYYYMMDD}[T|t| ]]{{HH:MM:SS[.m...]]]}|{HHMMSS[.m...]]]}}[Z] 116 | * now 117 | * @endcode 118 | * If the value is "now" it takes the current time. 119 | * Time is local time unless Z is appended, in which case it is 120 | * interpreted as UTC. 121 | * If the year-month-day part is not specified it takes the current 122 | * year-month-day. 123 | * - If a duration the syntax is: 124 | * @code 125 | * [-]HH:MM:SS[.m...]]] 126 | * [-]S+[.m...] 127 | * @endcode 128 | * @param duration flag which tells how to interpret timestr, if not 129 | * zero timestr is interpreted as a duration, otherwise as a date 130 | * @return 0 in case of success, a negative value corresponding to an 131 | * AVERROR code otherwise 132 | */ 133 | int av_parse_time(int64_t *timeval, const char *timestr, int duration); 134 | 135 | /** 136 | * Parse the input string p according to the format string fmt and 137 | * store its results in the structure dt. 138 | * This implementation supports only a subset of the formats supported 139 | * by the standard strptime(). 140 | * 141 | * In particular it actually supports the parameters: 142 | * - %H: the hour as a decimal number, using a 24-hour clock, in the 143 | * range '00' through '23' 144 | * - %M: the minute as a decimal number, using a 24-hour clock, in the 145 | * range '00' through '59' 146 | * - %S: the second as a decimal number, using a 24-hour clock, in the 147 | * range '00' through '59' 148 | * - %Y: the year as a decimal number, using the Gregorian calendar 149 | * - %m: the month as a decimal number, in the range '1' through '12' 150 | * - %d: the day of the month as a decimal number, in the range '1' 151 | * through '31' 152 | * - %%: a literal '%' 153 | * 154 | * @return a pointer to the first character not processed in this 155 | * function call, or NULL in case the function fails to match all of 156 | * the fmt string and therefore an error occurred 157 | */ 158 | char *av_small_strptime(const char *p, const char *fmt, struct tm *dt); 159 | 160 | /** 161 | * Attempt to find a specific tag in a URL. 162 | * 163 | * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. 164 | * Return 1 if found. 165 | */ 166 | int av_find_info_tag(char *arg, int arg_size, const char *tag1, const char *info); 167 | 168 | /** 169 | * Convert the decomposed UTC time in tm to a time_t value. 170 | */ 171 | time_t av_timegm(struct tm *tm); 172 | 173 | #endif /* AVUTIL_PARSEUTILS_H */ 174 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/libavutil/pixdesc.h: -------------------------------------------------------------------------------- 1 | /* 2 | * pixel format descriptor 3 | * Copyright (c) 2009 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_PIXDESC_H 23 | #define AVUTIL_PIXDESC_H 24 | 25 | #include 26 | #include "pixfmt.h" 27 | 28 | typedef struct AVComponentDescriptor{ 29 | uint16_t plane :2; ///< which of the 4 planes contains the component 30 | 31 | /** 32 | * Number of elements between 2 horizontally consecutive pixels minus 1. 33 | * Elements are bits for bitstream formats, bytes otherwise. 34 | */ 35 | uint16_t step_minus1 :3; 36 | 37 | /** 38 | * Number of elements before the component of the first pixel plus 1. 39 | * Elements are bits for bitstream formats, bytes otherwise. 40 | */ 41 | uint16_t offset_plus1 :3; 42 | uint16_t shift :3; ///< number of least significant bits that must be shifted away to get the value 43 | uint16_t depth_minus1 :4; ///< number of bits in the component minus 1 44 | }AVComponentDescriptor; 45 | 46 | /** 47 | * Descriptor that unambiguously describes how the bits of a pixel are 48 | * stored in the up to 4 data planes of an image. It also stores the 49 | * subsampling factors and number of components. 50 | * 51 | * @note This is separate of the colorspace (RGB, YCbCr, YPbPr, JPEG-style YUV 52 | * and all the YUV variants) AVPixFmtDescriptor just stores how values 53 | * are stored not what these values represent. 54 | */ 55 | typedef struct AVPixFmtDescriptor{ 56 | const char *name; 57 | uint8_t nb_components; ///< The number of components each pixel has, (1-4) 58 | 59 | /** 60 | * Amount to shift the luma width right to find the chroma width. 61 | * For YV12 this is 1 for example. 62 | * chroma_width = -((-luma_width) >> log2_chroma_w) 63 | * The note above is needed to ensure rounding up. 64 | * This value only refers to the chroma components. 65 | */ 66 | uint8_t log2_chroma_w; ///< chroma_width = -((-luma_width )>>log2_chroma_w) 67 | 68 | /** 69 | * Amount to shift the luma height right to find the chroma height. 70 | * For YV12 this is 1 for example. 71 | * chroma_height= -((-luma_height) >> log2_chroma_h) 72 | * The note above is needed to ensure rounding up. 73 | * This value only refers to the chroma components. 74 | */ 75 | uint8_t log2_chroma_h; 76 | uint8_t flags; 77 | 78 | /** 79 | * Parameters that describe how pixels are packed. 80 | * If the format has 2 or 4 components, then alpha is last. 81 | * If the format has 1 or 2 components, then luma is 0. 82 | * If the format has 3 or 4 components, 83 | * if the RGB flag is set then 0 is red, 1 is green and 2 is blue; 84 | * otherwise 0 is luma, 1 is chroma-U and 2 is chroma-V. 85 | */ 86 | AVComponentDescriptor comp[4]; 87 | }AVPixFmtDescriptor; 88 | 89 | #define PIX_FMT_BE 1 ///< Pixel format is big-endian. 90 | #define PIX_FMT_PAL 2 ///< Pixel format has a palette in data[1], values are indexes in this palette. 91 | #define PIX_FMT_BITSTREAM 4 ///< All values of a component are bit-wise packed end to end. 92 | #define PIX_FMT_HWACCEL 8 ///< Pixel format is an HW accelerated format. 93 | #define PIX_FMT_PLANAR 16 ///< At least one pixel component is not in the first data plane 94 | #define PIX_FMT_RGB 32 ///< The pixel format contains RGB-like data (as opposed to YUV/grayscale) 95 | /** 96 | * The pixel format is "pseudo-paletted". This means that FFmpeg treats it as 97 | * paletted internally, but the palette is generated by the decoder and is not 98 | * stored in the file. 99 | */ 100 | #define PIX_FMT_PSEUDOPAL 64 101 | 102 | /** 103 | * The array of all the pixel format descriptors. 104 | */ 105 | extern const AVPixFmtDescriptor av_pix_fmt_descriptors[]; 106 | 107 | /** 108 | * Read a line from an image, and write the values of the 109 | * pixel format component c to dst. 110 | * 111 | * @param data the array containing the pointers to the planes of the image 112 | * @param linesize the array containing the linesizes of the image 113 | * @param desc the pixel format descriptor for the image 114 | * @param x the horizontal coordinate of the first pixel to read 115 | * @param y the vertical coordinate of the first pixel to read 116 | * @param w the width of the line to read, that is the number of 117 | * values to write to dst 118 | * @param read_pal_component if not zero and the format is a paletted 119 | * format writes the values corresponding to the palette 120 | * component c in data[1] to dst, rather than the palette indexes in 121 | * data[0]. The behavior is undefined if the format is not paletted. 122 | */ 123 | void av_read_image_line(uint16_t *dst, const uint8_t *data[4], const int linesize[4], 124 | const AVPixFmtDescriptor *desc, int x, int y, int c, int w, int read_pal_component); 125 | 126 | /** 127 | * Write the values from src to the pixel format component c of an 128 | * image line. 129 | * 130 | * @param src array containing the values to write 131 | * @param data the array containing the pointers to the planes of the 132 | * image to write into. It is supposed to be zeroed. 133 | * @param linesize the array containing the linesizes of the image 134 | * @param desc the pixel format descriptor for the image 135 | * @param x the horizontal coordinate of the first pixel to write 136 | * @param y the vertical coordinate of the first pixel to write 137 | * @param w the width of the line to write, that is the number of 138 | * values to write to the image line 139 | */ 140 | void av_write_image_line(const uint16_t *src, uint8_t *data[4], const int linesize[4], 141 | const AVPixFmtDescriptor *desc, int x, int y, int c, int w); 142 | 143 | /** 144 | * Return the pixel format corresponding to name. 145 | * 146 | * If there is no pixel format with name name, then looks for a 147 | * pixel format with the name corresponding to the native endian 148 | * format of name. 149 | * For example in a little-endian system, first looks for "gray16", 150 | * then for "gray16le". 151 | * 152 | * Finally if no pixel format has been found, returns PIX_FMT_NONE. 153 | */ 154 | enum PixelFormat av_get_pix_fmt(const char *name); 155 | 156 | /** 157 | * Return the short name for a pixel format, NULL in case pix_fmt is 158 | * unknown. 159 | * 160 | * @see av_get_pix_fmt(), av_get_pix_fmt_string() 161 | */ 162 | const char *av_get_pix_fmt_name(enum PixelFormat pix_fmt); 163 | 164 | /** 165 | * Print in buf the string corresponding to the pixel format with 166 | * number pix_fmt, or an header if pix_fmt is negative. 167 | * 168 | * @param buf the buffer where to write the string 169 | * @param buf_size the size of buf 170 | * @param pix_fmt the number of the pixel format to print the 171 | * corresponding info string, or a negative value to print the 172 | * corresponding header. 173 | */ 174 | char *av_get_pix_fmt_string (char *buf, int buf_size, enum PixelFormat pix_fmt); 175 | 176 | /** 177 | * Return the number of bits per pixel used by the pixel format 178 | * described by pixdesc. 179 | * 180 | * The returned number of bits refers to the number of bits actually 181 | * used for storing the pixel information, that is padding bits are 182 | * not counted. 183 | */ 184 | int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc); 185 | 186 | #endif /* AVUTIL_PIXDESC_H */ 187 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/libavutil/random_seed.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2009 Baptiste Coudurier 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 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 | * Compare two rationals. 50 | * @param a first rational 51 | * @param b second rational 52 | * @return 0 if a==b, 1 if a>b, -1 if a>63)|1; 59 | else if(b.den && a.den) return 0; 60 | else if(a.num && b.num) return (a.num>>31) - (b.num>>31); 61 | else return INT_MIN; 62 | } 63 | 64 | /** 65 | * Convert rational to double. 66 | * @param a rational to convert 67 | * @return (double) a 68 | */ 69 | static inline double av_q2d(AVRational a){ 70 | return a.num / (double) a.den; 71 | } 72 | 73 | /** 74 | * Reduce a fraction. 75 | * This is useful for framerate calculations. 76 | * @param dst_num destination numerator 77 | * @param dst_den destination denominator 78 | * @param num source numerator 79 | * @param den source denominator 80 | * @param max the maximum allowed for dst_num & dst_den 81 | * @return 1 if exact, 0 otherwise 82 | */ 83 | int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max); 84 | 85 | /** 86 | * Multiply two rationals. 87 | * @param b first rational 88 | * @param c second rational 89 | * @return b*c 90 | */ 91 | AVRational av_mul_q(AVRational b, AVRational c) av_const; 92 | 93 | /** 94 | * Divide one rational by another. 95 | * @param b first rational 96 | * @param c second rational 97 | * @return b/c 98 | */ 99 | AVRational av_div_q(AVRational b, AVRational c) av_const; 100 | 101 | /** 102 | * Add two rationals. 103 | * @param b first rational 104 | * @param c second rational 105 | * @return b+c 106 | */ 107 | AVRational av_add_q(AVRational b, AVRational c) av_const; 108 | 109 | /** 110 | * Subtract one rational from another. 111 | * @param b first rational 112 | * @param c second rational 113 | * @return b-c 114 | */ 115 | AVRational av_sub_q(AVRational b, AVRational c) av_const; 116 | 117 | /** 118 | * Invert a rational. 119 | * @param q value 120 | * @return 1 / q 121 | */ 122 | static av_always_inline AVRational av_inv_q(AVRational q) 123 | { 124 | AVRational r = { q.den, q.num }; 125 | return r; 126 | } 127 | 128 | /** 129 | * Convert a double precision floating point number to a rational. 130 | * inf is expressed as {1,0} or {-1,0} depending on the sign. 131 | * 132 | * @param d double to convert 133 | * @param max the maximum allowed numerator and denominator 134 | * @return (AVRational) d 135 | */ 136 | AVRational av_d2q(double d, int max) av_const; 137 | 138 | /** 139 | * @return 1 if q1 is nearer to q than q2, -1 if q2 is nearer 140 | * than q1, 0 if they have the same distance. 141 | */ 142 | int av_nearer_q(AVRational q, AVRational q1, AVRational q2); 143 | 144 | /** 145 | * Find the nearest value in q_list to q. 146 | * @param q_list an array of rationals terminated by {0, 0} 147 | * @return the index of the nearest value found in the array 148 | */ 149 | int av_find_nearest_q_idx(AVRational q, const AVRational* q_list); 150 | 151 | /** 152 | * @} 153 | */ 154 | 155 | #endif /* AVUTIL_RATIONAL_H */ 156 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 | /** 27 | * @defgroup lavu_sha SHA 28 | * @ingroup lavu_crypto 29 | * @{ 30 | */ 31 | 32 | extern const int av_sha_size; 33 | 34 | struct AVSHA; 35 | 36 | /** 37 | * Initialize SHA-1 or SHA-2 hashing. 38 | * 39 | * @param context pointer to the function context (of size av_sha_size) 40 | * @param bits number of bits in digest (SHA-1 - 160 bits, SHA-2 224 or 256 bits) 41 | * @return zero if initialization succeeded, -1 otherwise 42 | */ 43 | int av_sha_init(struct AVSHA* context, int bits); 44 | 45 | /** 46 | * Update hash value. 47 | * 48 | * @param context hash function context 49 | * @param data input data to update hash with 50 | * @param len input data length 51 | */ 52 | void av_sha_update(struct AVSHA* context, const uint8_t* data, unsigned int len); 53 | 54 | /** 55 | * Finish hashing and output digest value. 56 | * 57 | * @param context hash function context 58 | * @param digest buffer where output digest value is stored 59 | */ 60 | void av_sha_final(struct AVSHA* context, uint8_t *digest); 61 | 62 | /** 63 | * @} 64 | */ 65 | 66 | #endif /* AVUTIL_SHA_H */ 67 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 | * Sleep for a period of time. Although the duration is expressed in 33 | * microseconds, the actual delay may be rounded to the precision of the 34 | * system timer. 35 | * 36 | * @param usec Number of microseconds to sleep. 37 | * @return zero on success or (negative) error code. 38 | */ 39 | int av_usleep(unsigned usec); 40 | 41 | #endif /* AVUTIL_TIME_H */ 42 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 | * @return adjusted frame number 53 | * @warning adjustment is only valid in NTSC 29.97 54 | * @deprecated use av_timecode_adjust_ntsc_framenum2 instead 55 | */ 56 | attribute_deprecated int av_timecode_adjust_ntsc_framenum(int framenum); 57 | 58 | /** 59 | * Adjust frame number for NTSC drop frame time code. 60 | * 61 | * @param framenum frame number to adjust 62 | * @param fps frame per second, 30 or 60 63 | * @return adjusted frame number 64 | * @warning adjustment is only valid in NTSC 29.97 and 59.94 65 | */ 66 | int av_timecode_adjust_ntsc_framenum2(int framenum, int fps); 67 | 68 | /** 69 | * Convert frame number to SMPTE 12M binary representation. 70 | * 71 | * @param tc timecode data correctly initialized 72 | * @param framenum frame number 73 | * @return the SMPTE binary representation 74 | * 75 | * @note Frame number adjustment is automatically done in case of drop timecode, 76 | * you do NOT have to call av_timecode_adjust_ntsc_framenum(). 77 | * @note The frame number is relative to tc->start. 78 | * @note Color frame (CF), binary group flags (BGF) and biphase mark polarity 79 | * correction (PC) bits are set to zero. 80 | */ 81 | uint32_t av_timecode_get_smpte_from_framenum(const AVTimecode *tc, int framenum); 82 | 83 | /** 84 | * Load timecode string in buf. 85 | * 86 | * @param buf destination buffer, must be at least AV_TIMECODE_STR_SIZE long 87 | * @param tc timecode data correctly initialized 88 | * @param framenum frame number 89 | * @return the buf parameter 90 | * 91 | * @note Timecode representation can be a negative timecode and have more than 92 | * 24 hours, but will only be honored if the flags are correctly set. 93 | * @note The frame number is relative to tc->start. 94 | */ 95 | char *av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum); 96 | 97 | /** 98 | * Get the timecode string from the SMPTE timecode format. 99 | * 100 | * @param buf destination buffer, must be at least AV_TIMECODE_STR_SIZE long 101 | * @param tcsmpte the 32-bit SMPTE timecode 102 | * @param prevent_df prevent the use of a drop flag when it is known the DF bit 103 | * is arbitrary 104 | * @return the buf parameter 105 | */ 106 | char *av_timecode_make_smpte_tc_string(char *buf, uint32_t tcsmpte, int prevent_df); 107 | 108 | /** 109 | * Get the timecode string from the 25-bit timecode format (MPEG GOP format). 110 | * 111 | * @param buf destination buffer, must be at least AV_TIMECODE_STR_SIZE long 112 | * @param tc25bit the 25-bits timecode 113 | * @return the buf parameter 114 | */ 115 | char *av_timecode_make_mpeg_tc_string(char *buf, uint32_t tc25bit); 116 | 117 | /** 118 | * Init a timecode struct with the passed parameters. 119 | * 120 | * @param log_ctx a pointer to an arbitrary struct of which the first field 121 | * is a pointer to an AVClass struct (used for av_log) 122 | * @param tc pointer to an allocated AVTimecode 123 | * @param rate frame rate in rational form 124 | * @param flags miscellaneous flags such as drop frame, +24 hours, ... 125 | * (see AVTimecodeFlag) 126 | * @param frame_start the first frame number 127 | * @return 0 on success, AVERROR otherwise 128 | */ 129 | int av_timecode_init(AVTimecode *tc, AVRational rate, int flags, int frame_start, void *log_ctx); 130 | 131 | /** 132 | * Parse timecode representation (hh:mm:ss[:;.]ff). 133 | * 134 | * @param log_ctx a pointer to an arbitrary struct of which the first field is a 135 | * pointer to an AVClass struct (used for av_log). 136 | * @param tc pointer to an allocated AVTimecode 137 | * @param rate frame rate in rational form 138 | * @param str timecode string which will determine the frame start 139 | * @return 0 on success, AVERROR otherwise 140 | */ 141 | int av_timecode_init_from_string(AVTimecode *tc, AVRational rate, const char *str, void *log_ctx); 142 | 143 | /** 144 | * Check if the timecode feature is available for the given frame rate 145 | * 146 | * @return 0 if supported, <0 otherwise 147 | */ 148 | int av_timecode_check_frame_rate(AVRational rate); 149 | 150 | #endif /* AVUTIL_TIMECODE_H */ 151 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 | #define AV_TS_MAX_STRING_SIZE 32 30 | 31 | /** 32 | * Fill the provided buffer with a string containing a timestamp 33 | * representation. 34 | * 35 | * @param buf a buffer with size in bytes of at least AV_TS_MAX_STRING_SIZE 36 | * @param ts the timestamp to represent 37 | * @return the buffer in input 38 | */ 39 | static inline char *av_ts_make_string(char *buf, int64_t ts) 40 | { 41 | if (ts == AV_NOPTS_VALUE) snprintf(buf, AV_TS_MAX_STRING_SIZE, "NOPTS"); 42 | else snprintf(buf, AV_TS_MAX_STRING_SIZE, "%"PRId64"", ts); 43 | return buf; 44 | } 45 | 46 | /** 47 | * Convenience macro, the return value should be used only directly in 48 | * function arguments but never stand-alone. 49 | */ 50 | #define av_ts2str(ts) av_ts_make_string((char[AV_TS_MAX_STRING_SIZE]){0}, ts) 51 | 52 | /** 53 | * Fill the provided buffer with a string containing a timestamp time 54 | * representation. 55 | * 56 | * @param buf a buffer with size in bytes of at least AV_TS_MAX_STRING_SIZE 57 | * @param ts the timestamp to represent 58 | * @param tb the timebase of the timestamp 59 | * @return the buffer in input 60 | */ 61 | static inline char *av_ts_make_time_string(char *buf, int64_t ts, AVRational *tb) 62 | { 63 | if (ts == AV_NOPTS_VALUE) snprintf(buf, AV_TS_MAX_STRING_SIZE, "NOPTS"); 64 | else snprintf(buf, AV_TS_MAX_STRING_SIZE, "%.6g", av_q2d(*tb) * ts); 65 | return buf; 66 | } 67 | 68 | /** 69 | * Convenience macro, the return value should be used only directly in 70 | * function arguments but never stand-alone. 71 | */ 72 | #define av_ts2timestr(ts, tb) av_ts_make_time_string((char[AV_TS_MAX_STRING_SIZE]){0}, ts, tb) 73 | 74 | #endif /* AVUTIL_TIMESTAMP_H */ 75 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 "avutil.h" 25 | 26 | /** 27 | * @file 28 | * @ingroup lavu 29 | * Libavutil version macros 30 | */ 31 | 32 | /** 33 | * @defgroup lavu_ver Version and Build diagnostics 34 | * 35 | * Macros and function useful to check at compiletime and at runtime 36 | * which version of libavutil is in use. 37 | * 38 | * @{ 39 | */ 40 | 41 | #define LIBAVUTIL_VERSION_MAJOR 51 42 | #define LIBAVUTIL_VERSION_MINOR 73 43 | #define LIBAVUTIL_VERSION_MICRO 101 44 | 45 | #define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \ 46 | LIBAVUTIL_VERSION_MINOR, \ 47 | LIBAVUTIL_VERSION_MICRO) 48 | #define LIBAVUTIL_VERSION AV_VERSION(LIBAVUTIL_VERSION_MAJOR, \ 49 | LIBAVUTIL_VERSION_MINOR, \ 50 | LIBAVUTIL_VERSION_MICRO) 51 | #define LIBAVUTIL_BUILD LIBAVUTIL_VERSION_INT 52 | 53 | #define LIBAVUTIL_IDENT "Lavu" AV_STRINGIFY(LIBAVUTIL_VERSION) 54 | 55 | /** 56 | * @} 57 | * 58 | * @defgroup depr_guards Deprecation guards 59 | * FF_API_* defines may be placed below to indicate public API that will be 60 | * dropped at a future version bump. The defines themselves are not part of 61 | * the public API and may change, break or disappear at any time. 62 | * 63 | * @{ 64 | */ 65 | 66 | #ifndef FF_API_OLD_EVAL_NAMES 67 | #define FF_API_OLD_EVAL_NAMES (LIBAVUTIL_VERSION_MAJOR < 52) 68 | #endif 69 | #ifndef FF_API_GET_BITS_PER_SAMPLE_FMT 70 | #define FF_API_GET_BITS_PER_SAMPLE_FMT (LIBAVUTIL_VERSION_MAJOR < 52) 71 | #endif 72 | #ifndef FF_API_FIND_OPT 73 | #define FF_API_FIND_OPT (LIBAVUTIL_VERSION_MAJOR < 52) 74 | #endif 75 | #ifndef FF_API_AV_FIFO_PEEK 76 | #define FF_API_AV_FIFO_PEEK (LIBAVUTIL_VERSION_MAJOR < 52) 77 | #endif 78 | #ifndef FF_API_OLD_AVOPTIONS 79 | #define FF_API_OLD_AVOPTIONS (LIBAVUTIL_VERSION_MAJOR < 52) 80 | #endif 81 | #ifndef FF_API_OLD_TC_ADJUST_FRAMENUM 82 | #define FF_API_OLD_TC_ADJUST_FRAMENUM (LIBAVUTIL_VERSION_MAJOR < 52) 83 | #endif 84 | 85 | /** 86 | * @} 87 | */ 88 | 89 | #endif /* AVUTIL_VERSION_H */ 90 | 91 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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 | * @defgroup lavu_xtea XTEA 29 | * @ingroup lavu_crypto 30 | * @{ 31 | */ 32 | 33 | typedef struct AVXTEA { 34 | uint32_t key[16]; 35 | } AVXTEA; 36 | 37 | /** 38 | * Initialize an AVXTEA context. 39 | * 40 | * @param ctx an AVXTEA context 41 | * @param key a key of 16 bytes used for encryption/decryption 42 | */ 43 | void av_xtea_init(struct AVXTEA *ctx, const uint8_t key[16]); 44 | 45 | /** 46 | * Encrypt or decrypt a buffer using a previously initialized context. 47 | * 48 | * @param ctx an AVXTEA context 49 | * @param dst destination array, can be equal to src 50 | * @param src source array, can be equal to dst 51 | * @param count number of 8 byte blocks 52 | * @param iv initialization vector for CBC mode, if NULL then ECB will be used 53 | * @param decrypt 0 for encryption, 1 for decryption 54 | */ 55 | void av_xtea_crypt(struct AVXTEA *ctx, uint8_t *dst, const uint8_t *src, 56 | int count, uint8_t *iv, int decrypt); 57 | 58 | /** 59 | * @} 60 | */ 61 | 62 | #endif /* AVUTIL_XTEA_H */ 63 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/libswresample/swresample.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2011-2012 Michael Niedermayer (michaelni@gmx.at) 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 | /** 22 | * @file 23 | * libswresample public header 24 | */ 25 | 26 | #ifndef SWR_H 27 | #define SWR_H 28 | 29 | #include 30 | #include "libavutil/samplefmt.h" 31 | 32 | #define LIBSWRESAMPLE_VERSION_MAJOR 0 33 | #define LIBSWRESAMPLE_VERSION_MINOR 15 34 | #define LIBSWRESAMPLE_VERSION_MICRO 100 35 | 36 | #define LIBSWRESAMPLE_VERSION_INT AV_VERSION_INT(LIBSWRESAMPLE_VERSION_MAJOR, \ 37 | LIBSWRESAMPLE_VERSION_MINOR, \ 38 | LIBSWRESAMPLE_VERSION_MICRO) 39 | 40 | #if LIBSWRESAMPLE_VERSION_MAJOR < 1 41 | #define SWR_CH_MAX 32 ///< Maximum number of channels 42 | #endif 43 | 44 | #define SWR_FLAG_RESAMPLE 1 ///< Force resampling even if equal sample rate 45 | //TODO use int resample ? 46 | //long term TODO can we enable this dynamically? 47 | 48 | enum SwrDitherType { 49 | SWR_DITHER_NONE = 0, 50 | SWR_DITHER_RECTANGULAR, 51 | SWR_DITHER_TRIANGULAR, 52 | SWR_DITHER_TRIANGULAR_HIGHPASS, 53 | SWR_DITHER_NB, ///< not part of API/ABI 54 | }; 55 | 56 | /** Resampling Filter Types */ 57 | enum SwrFilterType { 58 | SWR_FILTER_TYPE_CUBIC, /**< Cubic */ 59 | SWR_FILTER_TYPE_BLACKMAN_NUTTALL, /**< Blackman Nuttall Windowed Sinc */ 60 | SWR_FILTER_TYPE_KAISER, /**< Kaiser Windowed Sinc */ 61 | }; 62 | 63 | typedef struct SwrContext SwrContext; 64 | 65 | /** 66 | * Get the AVClass for swrContext. It can be used in combination with 67 | * AV_OPT_SEARCH_FAKE_OBJ for examining options. 68 | * 69 | * @see av_opt_find(). 70 | */ 71 | const AVClass *swr_get_class(void); 72 | 73 | /** 74 | * Allocate SwrContext. 75 | * 76 | * If you use this function you will need to set the parameters (manually or 77 | * with swr_alloc_set_opts()) before calling swr_init(). 78 | * 79 | * @see swr_alloc_set_opts(), swr_init(), swr_free() 80 | * @return NULL on error, allocated context otherwise 81 | */ 82 | struct SwrContext *swr_alloc(void); 83 | 84 | /** 85 | * Initialize context after user parameters have been set. 86 | * 87 | * @return AVERROR error code in case of failure. 88 | */ 89 | int swr_init(struct SwrContext *s); 90 | 91 | /** 92 | * Allocate SwrContext if needed and set/reset common parameters. 93 | * 94 | * This function does not require s to be allocated with swr_alloc(). On the 95 | * other hand, swr_alloc() can use swr_alloc_set_opts() to set the parameters 96 | * on the allocated context. 97 | * 98 | * @param s Swr context, can be NULL 99 | * @param out_ch_layout output channel layout (AV_CH_LAYOUT_*) 100 | * @param out_sample_fmt output sample format (AV_SAMPLE_FMT_*). 101 | * @param out_sample_rate output sample rate (frequency in Hz) 102 | * @param in_ch_layout input channel layout (AV_CH_LAYOUT_*) 103 | * @param in_sample_fmt input sample format (AV_SAMPLE_FMT_*). 104 | * @param in_sample_rate input sample rate (frequency in Hz) 105 | * @param log_offset logging level offset 106 | * @param log_ctx parent logging context, can be NULL 107 | * 108 | * @see swr_init(), swr_free() 109 | * @return NULL on error, allocated context otherwise 110 | */ 111 | struct SwrContext *swr_alloc_set_opts(struct SwrContext *s, 112 | int64_t out_ch_layout, enum AVSampleFormat out_sample_fmt, int out_sample_rate, 113 | int64_t in_ch_layout, enum AVSampleFormat in_sample_fmt, int in_sample_rate, 114 | int log_offset, void *log_ctx); 115 | 116 | /** 117 | * Free the given SwrContext and set the pointer to NULL. 118 | */ 119 | void swr_free(struct SwrContext **s); 120 | 121 | /** 122 | * Convert audio. 123 | * 124 | * in and in_count can be set to 0 to flush the last few samples out at the 125 | * end. 126 | * 127 | * If more input is provided than output space then the input will be buffered. 128 | * You can avoid this buffering by providing more output space than input. 129 | * Convertion will run directly without copying whenever possible. 130 | * 131 | * @param s allocated Swr context, with parameters set 132 | * @param out output buffers, only the first one need be set in case of packed audio 133 | * @param out_count amount of space available for output in samples per channel 134 | * @param in input buffers, only the first one need to be set in case of packed audio 135 | * @param in_count number of input samples available in one channel 136 | * 137 | * @return number of samples output per channel, negative value on error 138 | */ 139 | int swr_convert(struct SwrContext *s, uint8_t **out, int out_count, 140 | const uint8_t **in , int in_count); 141 | 142 | /** 143 | * Convert the next timestamp from input to output 144 | * timestampe are in 1/(in_sample_rate * out_sample_rate) units. 145 | * 146 | * @note There are 2 slightly differently behaving modes. 147 | * First is when automatic timestamp compensation is not used, (min_compensation >= FLT_MAX) 148 | * in this case timestamps will be passed through with delays compensated 149 | * Second is when automatic timestamp compensation is used, (min_compensation < FLT_MAX) 150 | * in this case the output timestamps will match output sample numbers 151 | * 152 | * @param pts timstamp for the next input sample, INT64_MIN if unknown 153 | * @returns the output timestamp for the next output sample 154 | */ 155 | int64_t swr_next_pts(struct SwrContext *s, int64_t pts); 156 | 157 | /** 158 | * Activate resampling compensation. 159 | */ 160 | int swr_set_compensation(struct SwrContext *s, int sample_delta, int compensation_distance); 161 | 162 | /** 163 | * Set a customized input channel mapping. 164 | * 165 | * @param s allocated Swr context, not yet initialized 166 | * @param channel_map customized input channel mapping (array of channel 167 | * indexes, -1 for a muted channel) 168 | * @return AVERROR error code in case of failure. 169 | */ 170 | int swr_set_channel_mapping(struct SwrContext *s, const int *channel_map); 171 | 172 | /** 173 | * Set a customized remix matrix. 174 | * 175 | * @param s allocated Swr context, not yet initialized 176 | * @param matrix remix coefficients; matrix[i + stride * o] is 177 | * the weight of input channel i in output channel o 178 | * @param stride offset between lines of the matrix 179 | * @return AVERROR error code in case of failure. 180 | */ 181 | int swr_set_matrix(struct SwrContext *s, const double *matrix, int stride); 182 | 183 | /** 184 | * Drops the specified number of output samples. 185 | */ 186 | int swr_drop_output(struct SwrContext *s, int count); 187 | 188 | /** 189 | * Injects the specified number of silence samples. 190 | */ 191 | int swr_inject_silence(struct SwrContext *s, int count); 192 | 193 | /** 194 | * Gets the delay the next input sample will experience relative to the next output sample. 195 | * 196 | * Swresample can buffer data if more input has been provided than available 197 | * output space, also converting between sample rates needs a delay. 198 | * This function returns the sum of all such delays. 199 | * 200 | * @param s swr context 201 | * @param base timebase in which the returned delay will be 202 | * if its set to 1 the returned delay is in seconds 203 | * if its set to 1000 the returned delay is in milli seconds 204 | * if its set to the input sample rate then the returned delay is in input samples 205 | * if its set to the output sample rate then the returned delay is in output samples 206 | * an exact rounding free delay can be found by using LCM(in_sample_rate, out_sample_rate) 207 | * @returns the delay in 1/base units. 208 | */ 209 | int64_t swr_get_delay(struct SwrContext *s, int64_t base); 210 | 211 | /** 212 | * Return the LIBSWRESAMPLE_VERSION_INT constant. 213 | */ 214 | unsigned swresample_version(void); 215 | 216 | /** 217 | * Return the swr build-time configuration. 218 | */ 219 | const char *swresample_configuration(void); 220 | 221 | /** 222 | * Return the swr license. 223 | */ 224 | const char *swresample_license(void); 225 | 226 | #endif 227 | -------------------------------------------------------------------------------- /ffmpeg_1.0_without_dolby/FFmpeg.framework/Headers/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/avutil.h" 28 | 29 | #define LIBSWSCALE_VERSION_MAJOR 2 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_GETCONTEXT 50 | #define FF_API_SWS_GETCONTEXT (LIBSWSCALE_VERSION_MAJOR < 3) 51 | #endif 52 | #ifndef FF_API_SWS_CPU_CAPS 53 | #define FF_API_SWS_CPU_CAPS (LIBSWSCALE_VERSION_MAJOR < 3) 54 | #endif 55 | #ifndef FF_API_SWS_FORMAT_NAME 56 | #define FF_API_SWS_FORMAT_NAME (LIBSWSCALE_VERSION_MAJOR < 3) 57 | #endif 58 | 59 | #endif /* SWSCALE_VERSION_H */ 60 | --------------------------------------------------------------------------------