diff options
Diffstat (limited to 'apps/codecs/libcook/libavutil')
-rw-r--r-- | apps/codecs/libcook/libavutil/avutil.h | 63 | ||||
-rw-r--r-- | apps/codecs/libcook/libavutil/bswap.h | 99 | ||||
-rw-r--r-- | apps/codecs/libcook/libavutil/common.h | 286 | ||||
-rw-r--r-- | apps/codecs/libcook/libavutil/internal.h | 328 | ||||
-rw-r--r-- | apps/codecs/libcook/libavutil/intreadwrite.h | 192 | ||||
-rw-r--r-- | apps/codecs/libcook/libavutil/lfg.c | 64 | ||||
-rw-r--r-- | apps/codecs/libcook/libavutil/lfg.h | 54 | ||||
-rw-r--r-- | apps/codecs/libcook/libavutil/log.c | 89 | ||||
-rw-r--r-- | apps/codecs/libcook/libavutil/log.h | 116 | ||||
-rw-r--r-- | apps/codecs/libcook/libavutil/md5.c | 182 | ||||
-rw-r--r-- | apps/codecs/libcook/libavutil/md5.h | 36 | ||||
-rw-r--r-- | apps/codecs/libcook/libavutil/mem.c | 159 | ||||
-rw-r--r-- | apps/codecs/libcook/libavutil/mem.h | 104 |
13 files changed, 1772 insertions, 0 deletions
diff --git a/apps/codecs/libcook/libavutil/avutil.h b/apps/codecs/libcook/libavutil/avutil.h new file mode 100644 index 0000000000..c57e69f10c --- /dev/null +++ b/apps/codecs/libcook/libavutil/avutil.h | |||
@@ -0,0 +1,63 @@ | |||
1 | /* | ||
2 | * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> | ||
3 | * | ||
4 | * This file is part of FFmpeg. | ||
5 | * | ||
6 | * FFmpeg is free software; you can redistribute it and/or | ||
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 libavutil/avutil.h | ||
26 | * external API header | ||
27 | */ | ||
28 | |||
29 | |||
30 | #define AV_STRINGIFY(s) AV_TOSTRING(s) | ||
31 | #define AV_TOSTRING(s) #s | ||
32 | |||
33 | #define AV_VERSION_INT(a, b, c) (a<<16 | b<<8 | c) | ||
34 | #define AV_VERSION_DOT(a, b, c) a ##.## b ##.## c | ||
35 | #define AV_VERSION(a, b, c) AV_VERSION_DOT(a, b, c) | ||
36 | |||
37 | #define LIBAVUTIL_VERSION_MAJOR 50 | ||
38 | #define LIBAVUTIL_VERSION_MINOR 0 | ||
39 | #define LIBAVUTIL_VERSION_MICRO 0 | ||
40 | |||
41 | #define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \ | ||
42 | LIBAVUTIL_VERSION_MINOR, \ | ||
43 | LIBAVUTIL_VERSION_MICRO) | ||
44 | #define LIBAVUTIL_VERSION AV_VERSION(LIBAVUTIL_VERSION_MAJOR, \ | ||
45 | LIBAVUTIL_VERSION_MINOR, \ | ||
46 | LIBAVUTIL_VERSION_MICRO) | ||
47 | #define LIBAVUTIL_BUILD LIBAVUTIL_VERSION_INT | ||
48 | |||
49 | #define LIBAVUTIL_IDENT "Lavu" AV_STRINGIFY(LIBAVUTIL_VERSION) | ||
50 | |||
51 | /** | ||
52 | * Returns the LIBAVUTIL_VERSION_INT constant. | ||
53 | */ | ||
54 | unsigned avutil_version(void); | ||
55 | |||
56 | #include "common.h" | ||
57 | #include "mathematics.h" | ||
58 | #include "rational.h" | ||
59 | #include "intfloat_readwrite.h" | ||
60 | #include "log.h" | ||
61 | #include "pixfmt.h" | ||
62 | |||
63 | #endif /* AVUTIL_AVUTIL_H */ | ||
diff --git a/apps/codecs/libcook/libavutil/bswap.h b/apps/codecs/libcook/libavutil/bswap.h new file mode 100644 index 0000000000..cf68c43c72 --- /dev/null +++ b/apps/codecs/libcook/libavutil/bswap.h | |||
@@ -0,0 +1,99 @@ | |||
1 | /* | ||
2 | * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> | ||
3 | * | ||
4 | * This file is part of FFmpeg. | ||
5 | * | ||
6 | * FFmpeg is free software; you can redistribute it and/or | ||
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 libavutil/bswap.h | ||
23 | * byte swapping routines | ||
24 | */ | ||
25 | |||
26 | #ifndef AVUTIL_BSWAP_H | ||
27 | #define AVUTIL_BSWAP_H | ||
28 | |||
29 | #include <stdint.h> | ||
30 | #include "config.h" | ||
31 | #include "common.h" | ||
32 | |||
33 | #if ARCH_ARM | ||
34 | # include "arm/bswap.h" | ||
35 | #elif ARCH_BFIN | ||
36 | # include "bfin/bswap.h" | ||
37 | #elif ARCH_SH4 | ||
38 | # include "sh4/bswap.h" | ||
39 | #elif ARCH_X86 | ||
40 | # include "x86/bswap.h" | ||
41 | #endif | ||
42 | |||
43 | #ifndef bswap_16 | ||
44 | static av_always_inline av_const uint16_t bswap_16(uint16_t x) | ||
45 | { | ||
46 | x= (x>>8) | (x<<8); | ||
47 | return x; | ||
48 | } | ||
49 | #endif | ||
50 | |||
51 | #ifndef bswap_32 | ||
52 | static av_always_inline av_const uint32_t bswap_32(uint32_t x) | ||
53 | { | ||
54 | x= ((x<<8)&0xFF00FF00) | ((x>>8)&0x00FF00FF); | ||
55 | x= (x>>16) | (x<<16); | ||
56 | return x; | ||
57 | } | ||
58 | #endif | ||
59 | |||
60 | #ifndef bswap_64 | ||
61 | static inline uint64_t av_const bswap_64(uint64_t x) | ||
62 | { | ||
63 | #if 0 | ||
64 | x= ((x<< 8)&0xFF00FF00FF00FF00ULL) | ((x>> 8)&0x00FF00FF00FF00FFULL); | ||
65 | x= ((x<<16)&0xFFFF0000FFFF0000ULL) | ((x>>16)&0x0000FFFF0000FFFFULL); | ||
66 | return (x>>32) | (x<<32); | ||
67 | #else | ||
68 | union { | ||
69 | uint64_t ll; | ||
70 | uint32_t l[2]; | ||
71 | } w, r; | ||
72 | w.ll = x; | ||
73 | r.l[0] = bswap_32 (w.l[1]); | ||
74 | r.l[1] = bswap_32 (w.l[0]); | ||
75 | return r.ll; | ||
76 | #endif | ||
77 | } | ||
78 | #endif | ||
79 | |||
80 | // be2me ... big-endian to machine-endian | ||
81 | // le2me ... little-endian to machine-endian | ||
82 | |||
83 | #ifdef WORDS_BIGENDIAN | ||
84 | #define be2me_16(x) (x) | ||
85 | #define be2me_32(x) (x) | ||
86 | #define be2me_64(x) (x) | ||
87 | #define le2me_16(x) bswap_16(x) | ||
88 | #define le2me_32(x) bswap_32(x) | ||
89 | #define le2me_64(x) bswap_64(x) | ||
90 | #else | ||
91 | #define be2me_16(x) bswap_16(x) | ||
92 | #define be2me_32(x) bswap_32(x) | ||
93 | #define be2me_64(x) bswap_64(x) | ||
94 | #define le2me_16(x) (x) | ||
95 | #define le2me_32(x) (x) | ||
96 | #define le2me_64(x) (x) | ||
97 | #endif | ||
98 | |||
99 | #endif /* AVUTIL_BSWAP_H */ | ||
diff --git a/apps/codecs/libcook/libavutil/common.h b/apps/codecs/libcook/libavutil/common.h new file mode 100644 index 0000000000..15eaf9849d --- /dev/null +++ b/apps/codecs/libcook/libavutil/common.h | |||
@@ -0,0 +1,286 @@ | |||
1 | /* | ||
2 | * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> | ||
3 | * | ||
4 | * This file is part of FFmpeg. | ||
5 | * | ||
6 | * FFmpeg is free software; you can redistribute it and/or | ||
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 libavutil/common.h | ||
23 | * common internal and external API header | ||
24 | */ | ||
25 | |||
26 | #ifndef AVUTIL_COMMON_H | ||
27 | #define AVUTIL_COMMON_H | ||
28 | |||
29 | #include <ctype.h> | ||
30 | #include <errno.h> | ||
31 | #include <inttypes.h> | ||
32 | #include <limits.h> | ||
33 | #include <math.h> | ||
34 | #include <stdio.h> | ||
35 | #include <stdlib.h> | ||
36 | #include <string.h> | ||
37 | |||
38 | #ifdef __GNUC__ | ||
39 | # define AV_GCC_VERSION_AT_LEAST(x,y) (__GNUC__ > x || __GNUC__ == x && __GNUC_MINOR__ >= y) | ||
40 | #else | ||
41 | # define AV_GCC_VERSION_AT_LEAST(x,y) 0 | ||
42 | #endif | ||
43 | |||
44 | #ifndef av_always_inline | ||
45 | #if AV_GCC_VERSION_AT_LEAST(3,1) | ||
46 | # define av_always_inline __attribute__((always_inline)) inline | ||
47 | #else | ||
48 | # define av_always_inline inline | ||
49 | #endif | ||
50 | #endif | ||
51 | |||
52 | #ifndef av_noinline | ||
53 | #if AV_GCC_VERSION_AT_LEAST(3,1) | ||
54 | # define av_noinline __attribute__((noinline)) | ||
55 | #else | ||
56 | # define av_noinline | ||
57 | #endif | ||
58 | #endif | ||
59 | |||
60 | #ifndef av_pure | ||
61 | #if AV_GCC_VERSION_AT_LEAST(3,1) | ||
62 | # define av_pure __attribute__((pure)) | ||
63 | #else | ||
64 | # define av_pure | ||
65 | #endif | ||
66 | #endif | ||
67 | |||
68 | #ifndef av_const | ||
69 | #if AV_GCC_VERSION_AT_LEAST(2,6) | ||
70 | # define av_const __attribute__((const)) | ||
71 | #else | ||
72 | # define av_const | ||
73 | #endif | ||
74 | #endif | ||
75 | |||
76 | #ifndef av_cold | ||
77 | #if (!defined(__ICC) || __ICC > 1100) && AV_GCC_VERSION_AT_LEAST(4,3) | ||
78 | # define av_cold __attribute__((cold)) | ||
79 | #else | ||
80 | # define av_cold | ||
81 | #endif | ||
82 | #endif | ||
83 | |||
84 | #ifndef av_flatten | ||
85 | #if AV_GCC_VERSION_AT_LEAST(4,1) | ||
86 | # define av_flatten __attribute__((flatten)) | ||
87 | #else | ||
88 | # define av_flatten | ||
89 | #endif | ||
90 | #endif | ||
91 | |||
92 | #ifndef attribute_deprecated | ||
93 | #if AV_GCC_VERSION_AT_LEAST(3,1) | ||
94 | # define attribute_deprecated __attribute__((deprecated)) | ||
95 | #else | ||
96 | # define attribute_deprecated | ||
97 | #endif | ||
98 | #endif | ||
99 | |||
100 | #ifndef av_unused | ||
101 | #if defined(__GNUC__) | ||
102 | # define av_unused __attribute__((unused)) | ||
103 | #else | ||
104 | # define av_unused | ||
105 | #endif | ||
106 | #endif | ||
107 | |||
108 | #ifndef av_uninit | ||
109 | #if defined(__GNUC__) && !defined(__ICC) | ||
110 | # define av_uninit(x) x=x | ||
111 | #else | ||
112 | # define av_uninit(x) x | ||
113 | #endif | ||
114 | #endif | ||
115 | |||
116 | //rounded division & shift | ||
117 | #define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b)) | ||
118 | /* assume b>0 */ | ||
119 | #define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b)) | ||
120 | #define FFABS(a) ((a) >= 0 ? (a) : (-(a))) | ||
121 | #define FFSIGN(a) ((a) > 0 ? 1 : -1) | ||
122 | |||
123 | #define FFMAX(a,b) ((a) > (b) ? (a) : (b)) | ||
124 | #define FFMAX3(a,b,c) FFMAX(FFMAX(a,b),c) | ||
125 | #define FFMIN(a,b) ((a) > (b) ? (b) : (a)) | ||
126 | #define FFMIN3(a,b,c) FFMIN(FFMIN(a,b),c) | ||
127 | |||
128 | #define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0) | ||
129 | #define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0])) | ||
130 | |||
131 | /* misc math functions */ | ||
132 | extern const uint8_t ff_log2_tab[256]; | ||
133 | |||
134 | static inline av_const int av_log2(unsigned int v) | ||
135 | { | ||
136 | int n = 0; | ||
137 | if (v & 0xffff0000) { | ||
138 | v >>= 16; | ||
139 | n += 16; | ||
140 | } | ||
141 | if (v & 0xff00) { | ||
142 | v >>= 8; | ||
143 | n += 8; | ||
144 | } | ||
145 | n += ff_log2_tab[v]; | ||
146 | |||
147 | return n; | ||
148 | } | ||
149 | |||
150 | static inline av_const int av_log2_16bit(unsigned int v) | ||
151 | { | ||
152 | int n = 0; | ||
153 | if (v & 0xff00) { | ||
154 | v >>= 8; | ||
155 | n += 8; | ||
156 | } | ||
157 | n += ff_log2_tab[v]; | ||
158 | |||
159 | return n; | ||
160 | } | ||
161 | |||
162 | /** | ||
163 | * Clips a signed integer value into the amin-amax range. | ||
164 | * @param a value to clip | ||
165 | * @param amin minimum value of the clip range | ||
166 | * @param amax maximum value of the clip range | ||
167 | * @return clipped value | ||
168 | */ | ||
169 | static inline av_const int av_clip(int a, int amin, int amax) | ||
170 | { | ||
171 | if (a < amin) return amin; | ||
172 | else if (a > amax) return amax; | ||
173 | else return a; | ||
174 | } | ||
175 | |||
176 | /** | ||
177 | * Clips a signed integer value into the 0-255 range. | ||
178 | * @param a value to clip | ||
179 | * @return clipped value | ||
180 | */ | ||
181 | static inline av_const uint8_t av_clip_uint8(int a) | ||
182 | { | ||
183 | if (a&(~255)) return (-a)>>31; | ||
184 | else return a; | ||
185 | } | ||
186 | |||
187 | /** | ||
188 | * Clips a signed integer value into the -32768,32767 range. | ||
189 | * @param a value to clip | ||
190 | * @return clipped value | ||
191 | */ | ||
192 | static inline av_const int16_t av_clip_int16(int a) | ||
193 | { | ||
194 | if ((a+32768) & ~65535) return (a>>31) ^ 32767; | ||
195 | else return a; | ||
196 | } | ||
197 | |||
198 | /** | ||
199 | * Clips a float value into the amin-amax range. | ||
200 | * @param a value to clip | ||
201 | * @param amin minimum value of the clip range | ||
202 | * @param amax maximum value of the clip range | ||
203 | * @return clipped value | ||
204 | */ | ||
205 | static inline av_const float av_clipf(float a, float amin, float amax) | ||
206 | { | ||
207 | if (a < amin) return amin; | ||
208 | else if (a > amax) return amax; | ||
209 | else return a; | ||
210 | } | ||
211 | |||
212 | #define MKTAG(a,b,c,d) (a | (b << 8) | (c << 16) | (d << 24)) | ||
213 | #define MKBETAG(a,b,c,d) (d | (c << 8) | (b << 16) | (a << 24)) | ||
214 | |||
215 | /*! | ||
216 | * \def GET_UTF8(val, GET_BYTE, ERROR) | ||
217 | * Converts a UTF-8 character (up to 4 bytes long) to its 32-bit UCS-4 encoded form | ||
218 | * \param val is the output and should be of type uint32_t. It holds the converted | ||
219 | * UCS-4 character and should be a left value. | ||
220 | * \param GET_BYTE gets UTF-8 encoded bytes from any proper source. It can be | ||
221 | * a function or a statement whose return value or evaluated value is of type | ||
222 | * uint8_t. It will be executed up to 4 times for values in the valid UTF-8 range, | ||
223 | * and up to 7 times in the general case. | ||
224 | * \param ERROR action that should be taken when an invalid UTF-8 byte is returned | ||
225 | * from GET_BYTE. It should be a statement that jumps out of the macro, | ||
226 | * like exit(), goto, return, break, or continue. | ||
227 | */ | ||
228 | #define GET_UTF8(val, GET_BYTE, ERROR)\ | ||
229 | val= GET_BYTE;\ | ||
230 | {\ | ||
231 | int ones= 7 - av_log2(val ^ 255);\ | ||
232 | if(ones==1)\ | ||
233 | ERROR\ | ||
234 | val&= 127>>ones;\ | ||
235 | while(--ones > 0){\ | ||
236 | int tmp= GET_BYTE - 128;\ | ||
237 | if(tmp>>6)\ | ||
238 | ERROR\ | ||
239 | val= (val<<6) + tmp;\ | ||
240 | }\ | ||
241 | } | ||
242 | |||
243 | /*! | ||
244 | * \def PUT_UTF8(val, tmp, PUT_BYTE) | ||
245 | * Converts a 32-bit Unicode character to its UTF-8 encoded form (up to 4 bytes long). | ||
246 | * \param val is an input-only argument and should be of type uint32_t. It holds | ||
247 | * a UCS-4 encoded Unicode character that is to be converted to UTF-8. If | ||
248 | * val is given as a function it is executed only once. | ||
249 | * \param tmp is a temporary variable and should be of type uint8_t. It | ||
250 | * represents an intermediate value during conversion that is to be | ||
251 | * output by PUT_BYTE. | ||
252 | * \param PUT_BYTE writes the converted UTF-8 bytes to any proper destination. | ||
253 | * It could be a function or a statement, and uses tmp as the input byte. | ||
254 | * For example, PUT_BYTE could be "*output++ = tmp;" PUT_BYTE will be | ||
255 | * executed up to 4 times for values in the valid UTF-8 range and up to | ||
256 | * 7 times in the general case, depending on the length of the converted | ||
257 | * Unicode character. | ||
258 | */ | ||
259 | #define PUT_UTF8(val, tmp, PUT_BYTE)\ | ||
260 | {\ | ||
261 | int bytes, shift;\ | ||
262 | uint32_t in = val;\ | ||
263 | if (in < 0x80) {\ | ||
264 | tmp = in;\ | ||
265 | PUT_BYTE\ | ||
266 | } else {\ | ||
267 | bytes = (av_log2(in) + 4) / 5;\ | ||
268 | shift = (bytes - 1) * 6;\ | ||
269 | tmp = (256 - (256 >> bytes)) | (in >> shift);\ | ||
270 | PUT_BYTE\ | ||
271 | while (shift >= 6) {\ | ||
272 | shift -= 6;\ | ||
273 | tmp = 0x80 | ((in >> shift) & 0x3f);\ | ||
274 | PUT_BYTE\ | ||
275 | }\ | ||
276 | }\ | ||
277 | } | ||
278 | |||
279 | #include "mem.h" | ||
280 | |||
281 | #ifdef HAVE_AV_CONFIG_H | ||
282 | # include "config.h" | ||
283 | # include "internal.h" | ||
284 | #endif /* HAVE_AV_CONFIG_H */ | ||
285 | |||
286 | #endif /* AVUTIL_COMMON_H */ | ||
diff --git a/apps/codecs/libcook/libavutil/internal.h b/apps/codecs/libcook/libavutil/internal.h new file mode 100644 index 0000000000..4191aa8e52 --- /dev/null +++ b/apps/codecs/libcook/libavutil/internal.h | |||
@@ -0,0 +1,328 @@ | |||
1 | /* | ||
2 | * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> | ||
3 | * | ||
4 | * This file is part of FFmpeg. | ||
5 | * | ||
6 | * FFmpeg is free software; you can redistribute it and/or | ||
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 libavutil/internal.h | ||
23 | * common internal API header | ||
24 | */ | ||
25 | |||
26 | #ifndef AVUTIL_INTERNAL_H | ||
27 | #define AVUTIL_INTERNAL_H | ||
28 | |||
29 | #if !defined(DEBUG) && !defined(NDEBUG) | ||
30 | # define NDEBUG | ||
31 | #endif | ||
32 | |||
33 | #include <limits.h> | ||
34 | #include <stdint.h> | ||
35 | #include <stddef.h> | ||
36 | #include <assert.h> | ||
37 | #include "config.h" | ||
38 | #include "common.h" | ||
39 | #include "mem.h" | ||
40 | #include "timer.h" | ||
41 | |||
42 | #ifndef attribute_align_arg | ||
43 | #if (!defined(__ICC) || __ICC > 1100) && AV_GCC_VERSION_AT_LEAST(4,2) | ||
44 | # define attribute_align_arg __attribute__((force_align_arg_pointer)) | ||
45 | #else | ||
46 | # define attribute_align_arg | ||
47 | #endif | ||
48 | #endif | ||
49 | |||
50 | #ifndef attribute_used | ||
51 | #if AV_GCC_VERSION_AT_LEAST(3,1) | ||
52 | # define attribute_used __attribute__((used)) | ||
53 | #else | ||
54 | # define attribute_used | ||
55 | #endif | ||
56 | #endif | ||
57 | |||
58 | #ifndef INT16_MIN | ||
59 | #define INT16_MIN (-0x7fff-1) | ||
60 | #endif | ||
61 | |||
62 | #ifndef INT16_MAX | ||
63 | #define INT16_MAX 0x7fff | ||
64 | #endif | ||
65 | |||
66 | #ifndef INT32_MIN | ||
67 | #define INT32_MIN (-0x7fffffff-1) | ||
68 | #endif | ||
69 | |||
70 | #ifndef INT32_MAX | ||
71 | #define INT32_MAX 0x7fffffff | ||
72 | #endif | ||
73 | |||
74 | #ifndef UINT32_MAX | ||
75 | #define UINT32_MAX 0xffffffff | ||
76 | #endif | ||
77 | |||
78 | #ifndef INT64_MIN | ||
79 | #define INT64_MIN (-0x7fffffffffffffffLL-1) | ||
80 | #endif | ||
81 | |||
82 | #ifndef INT64_MAX | ||
83 | #define INT64_MAX INT64_C(9223372036854775807) | ||
84 | #endif | ||
85 | |||
86 | #ifndef UINT64_MAX | ||
87 | #define UINT64_MAX UINT64_C(0xFFFFFFFFFFFFFFFF) | ||
88 | #endif | ||
89 | |||
90 | #ifndef INT_BIT | ||
91 | # define INT_BIT (CHAR_BIT * sizeof(int)) | ||
92 | #endif | ||
93 | |||
94 | #if ( defined(__PIC__) || defined(__pic__) ) && ! defined(PIC) | ||
95 | # define PIC | ||
96 | #endif | ||
97 | |||
98 | #ifndef offsetof | ||
99 | # define offsetof(T,F) ((unsigned int)((char *)&((T *)0)->F)) | ||
100 | #endif | ||
101 | |||
102 | // Use rip-relative addressing if compiling PIC code on x86-64. | ||
103 | #if ARCH_X86_64 && defined(PIC) | ||
104 | # define LOCAL_MANGLE(a) #a "(%%rip)" | ||
105 | #else | ||
106 | # define LOCAL_MANGLE(a) #a | ||
107 | #endif | ||
108 | |||
109 | #define MANGLE(a) EXTERN_PREFIX LOCAL_MANGLE(a) | ||
110 | |||
111 | /* debug stuff */ | ||
112 | |||
113 | /* dprintf macros */ | ||
114 | #ifdef DEBUG | ||
115 | # define dprintf(pctx, ...) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__) | ||
116 | #else | ||
117 | # define dprintf(pctx, ...) | ||
118 | #endif | ||
119 | |||
120 | #define av_abort() do { av_log(NULL, AV_LOG_ERROR, "Abort at %s:%d\n", __FILE__, __LINE__); abort(); } while (0) | ||
121 | |||
122 | /* math */ | ||
123 | |||
124 | extern const uint32_t ff_inverse[256]; | ||
125 | |||
126 | #if ARCH_X86 | ||
127 | # define FASTDIV(a,b) \ | ||
128 | ({\ | ||
129 | int ret,dmy;\ | ||
130 | __asm__ volatile(\ | ||
131 | "mull %3"\ | ||
132 | :"=d"(ret),"=a"(dmy)\ | ||
133 | :"1"(a),"g"(ff_inverse[b])\ | ||
134 | );\ | ||
135 | ret;\ | ||
136 | }) | ||
137 | #elif HAVE_ARMV6 && HAVE_INLINE_ASM | ||
138 | static inline av_const int FASTDIV(int a, int b) | ||
139 | { | ||
140 | int r, t; | ||
141 | __asm__ volatile("cmp %3, #2 \n\t" | ||
142 | "ldr %1, [%4, %3, lsl #2] \n\t" | ||
143 | "lsrle %0, %2, #1 \n\t" | ||
144 | "smmulgt %0, %1, %2 \n\t" | ||
145 | : "=&r"(r), "=&r"(t) : "r"(a), "r"(b), "r"(ff_inverse)); | ||
146 | return r; | ||
147 | } | ||
148 | #elif ARCH_ARM && HAVE_INLINE_ASM | ||
149 | static inline av_const int FASTDIV(int a, int b) | ||
150 | { | ||
151 | int r, t; | ||
152 | __asm__ volatile ("umull %1, %0, %2, %3" | ||
153 | : "=&r"(r), "=&r"(t) : "r"(a), "r"(ff_inverse[b])); | ||
154 | return r; | ||
155 | } | ||
156 | #elif CONFIG_FASTDIV | ||
157 | # define FASTDIV(a,b) ((uint32_t)((((uint64_t)a)*ff_inverse[b])>>32)) | ||
158 | #else | ||
159 | # define FASTDIV(a,b) ((a)/(b)) | ||
160 | #endif | ||
161 | |||
162 | extern const uint8_t ff_sqrt_tab[256]; | ||
163 | |||
164 | static inline av_const unsigned int ff_sqrt(unsigned int a) | ||
165 | { | ||
166 | unsigned int b; | ||
167 | |||
168 | if(a<255) return (ff_sqrt_tab[a+1]-1)>>4; | ||
169 | else if(a<(1<<12)) b= ff_sqrt_tab[a>>4 ]>>2; | ||
170 | #if !CONFIG_SMALL | ||
171 | else if(a<(1<<14)) b= ff_sqrt_tab[a>>6 ]>>1; | ||
172 | else if(a<(1<<16)) b= ff_sqrt_tab[a>>8 ] ; | ||
173 | #endif | ||
174 | else{ | ||
175 | int s= av_log2_16bit(a>>16)>>1; | ||
176 | unsigned int c= a>>(s+2); | ||
177 | b= ff_sqrt_tab[c>>(s+8)]; | ||
178 | b= FASTDIV(c,b) + (b<<s); | ||
179 | } | ||
180 | |||
181 | return b - (a<b*b); | ||
182 | } | ||
183 | |||
184 | #if ARCH_X86 | ||
185 | #define MASK_ABS(mask, level)\ | ||
186 | __asm__ volatile(\ | ||
187 | "cltd \n\t"\ | ||
188 | "xorl %1, %0 \n\t"\ | ||
189 | "subl %1, %0 \n\t"\ | ||
190 | : "+a" (level), "=&d" (mask)\ | ||
191 | ); | ||
192 | #else | ||
193 | #define MASK_ABS(mask, level)\ | ||
194 | mask= level>>31;\ | ||
195 | level= (level^mask)-mask; | ||
196 | #endif | ||
197 | |||
198 | #if HAVE_CMOV | ||
199 | #define COPY3_IF_LT(x,y,a,b,c,d)\ | ||
200 | __asm__ volatile (\ | ||
201 | "cmpl %0, %3 \n\t"\ | ||
202 | "cmovl %3, %0 \n\t"\ | ||
203 | "cmovl %4, %1 \n\t"\ | ||
204 | "cmovl %5, %2 \n\t"\ | ||
205 | : "+&r" (x), "+&r" (a), "+r" (c)\ | ||
206 | : "r" (y), "r" (b), "r" (d)\ | ||
207 | ); | ||
208 | #else | ||
209 | #define COPY3_IF_LT(x,y,a,b,c,d)\ | ||
210 | if((y)<(x)){\ | ||
211 | (x)=(y);\ | ||
212 | (a)=(b);\ | ||
213 | (c)=(d);\ | ||
214 | } | ||
215 | #endif | ||
216 | |||
217 | /* avoid usage of dangerous/inappropriate system functions */ | ||
218 | #undef malloc | ||
219 | #define malloc please_use_av_malloc | ||
220 | #undef free | ||
221 | #define free please_use_av_free | ||
222 | #undef realloc | ||
223 | #define realloc please_use_av_realloc | ||
224 | #undef time | ||
225 | #define time time_is_forbidden_due_to_security_issues | ||
226 | #undef rand | ||
227 | #define rand rand_is_forbidden_due_to_state_trashing_use_av_random | ||
228 | #undef srand | ||
229 | #define srand srand_is_forbidden_due_to_state_trashing_use_av_random_init | ||
230 | #undef random | ||
231 | #define random random_is_forbidden_due_to_state_trashing_use_av_random | ||
232 | #undef sprintf | ||
233 | #define sprintf sprintf_is_forbidden_due_to_security_issues_use_snprintf | ||
234 | #undef strcat | ||
235 | #define strcat strcat_is_forbidden_due_to_security_issues_use_av_strlcat | ||
236 | #undef exit | ||
237 | #define exit exit_is_forbidden | ||
238 | #ifndef LIBAVFORMAT_BUILD | ||
239 | #undef printf | ||
240 | #define printf please_use_av_log_instead_of_printf | ||
241 | #undef fprintf | ||
242 | #define fprintf please_use_av_log_instead_of_fprintf | ||
243 | #undef puts | ||
244 | #define puts please_use_av_log_instead_of_puts | ||
245 | #undef perror | ||
246 | #define perror please_use_av_log_instead_of_perror | ||
247 | #endif | ||
248 | |||
249 | #define CHECKED_ALLOCZ(p, size)\ | ||
250 | {\ | ||
251 | p= av_mallocz(size);\ | ||
252 | if(p==NULL && (size)!=0){\ | ||
253 | av_log(NULL, AV_LOG_ERROR, "Cannot allocate memory.");\ | ||
254 | goto fail;\ | ||
255 | }\ | ||
256 | } | ||
257 | |||
258 | #if defined(__ICC) || defined(__SUNPRO_C) | ||
259 | #define DECLARE_ALIGNED(n,t,v) t v __attribute__ ((aligned (n))) | ||
260 | #define DECLARE_ASM_CONST(n,t,v) const t __attribute__ ((aligned (n))) v | ||
261 | #elif defined(__GNUC__) | ||
262 | #define DECLARE_ALIGNED(n,t,v) t v __attribute__ ((aligned (n))) | ||
263 | #define DECLARE_ASM_CONST(n,t,v) static const t v attribute_used __attribute__ ((aligned (n))) | ||
264 | #elif defined(_MSC_VER) | ||
265 | #define DECLARE_ALIGNED(n,t,v) __declspec(align(n)) t v | ||
266 | #define DECLARE_ASM_CONST(n,t,v) __declspec(align(n)) static const t v | ||
267 | #elif HAVE_INLINE_ASM | ||
268 | #error The asm code needs alignment, but we do not know how to do it for this compiler. | ||
269 | #else | ||
270 | #define DECLARE_ALIGNED(n,t,v) t v | ||
271 | #define DECLARE_ASM_CONST(n,t,v) static const t v | ||
272 | #endif | ||
273 | |||
274 | |||
275 | #if !HAVE_LLRINT | ||
276 | static av_always_inline av_const long long llrint(double x) | ||
277 | { | ||
278 | return rint(x); | ||
279 | } | ||
280 | #endif /* HAVE_LLRINT */ | ||
281 | |||
282 | #if !HAVE_LRINT | ||
283 | static av_always_inline av_const long int lrint(double x) | ||
284 | { | ||
285 | return rint(x); | ||
286 | } | ||
287 | #endif /* HAVE_LRINT */ | ||
288 | |||
289 | #if !HAVE_LRINTF | ||
290 | static av_always_inline av_const long int lrintf(float x) | ||
291 | { | ||
292 | return (int)(rint(x)); | ||
293 | } | ||
294 | #endif /* HAVE_LRINTF */ | ||
295 | |||
296 | #if !HAVE_ROUND | ||
297 | static av_always_inline av_const double round(double x) | ||
298 | { | ||
299 | return (x > 0) ? floor(x + 0.5) : ceil(x - 0.5); | ||
300 | } | ||
301 | #endif /* HAVE_ROUND */ | ||
302 | |||
303 | #if !HAVE_ROUNDF | ||
304 | static av_always_inline av_const float roundf(float x) | ||
305 | { | ||
306 | return (x > 0) ? floor(x + 0.5) : ceil(x - 0.5); | ||
307 | } | ||
308 | #endif /* HAVE_ROUNDF */ | ||
309 | |||
310 | #if !HAVE_TRUNCF | ||
311 | static av_always_inline av_const float truncf(float x) | ||
312 | { | ||
313 | return (x > 0) ? floor(x) : ceil(x); | ||
314 | } | ||
315 | #endif /* HAVE_TRUNCF */ | ||
316 | |||
317 | /** | ||
318 | * Returns NULL if CONFIG_SMALL is true, otherwise the argument | ||
319 | * without modification. Used to disable the definition of strings | ||
320 | * (for example AVCodec long_names). | ||
321 | */ | ||
322 | #if CONFIG_SMALL | ||
323 | # define NULL_IF_CONFIG_SMALL(x) NULL | ||
324 | #else | ||
325 | # define NULL_IF_CONFIG_SMALL(x) x | ||
326 | #endif | ||
327 | |||
328 | #endif /* AVUTIL_INTERNAL_H */ | ||
diff --git a/apps/codecs/libcook/libavutil/intreadwrite.h b/apps/codecs/libcook/libavutil/intreadwrite.h new file mode 100644 index 0000000000..7c5909ea51 --- /dev/null +++ b/apps/codecs/libcook/libavutil/intreadwrite.h | |||
@@ -0,0 +1,192 @@ | |||
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_INTREADWRITE_H | ||
20 | #define AVUTIL_INTREADWRITE_H | ||
21 | |||
22 | #include <stdint.h> | ||
23 | #include "config.h" | ||
24 | #include "bswap.h" | ||
25 | |||
26 | #ifdef __GNUC__ | ||
27 | |||
28 | struct unaligned_64 { uint64_t l; } __attribute__((packed)); | ||
29 | struct unaligned_32 { uint32_t l; } __attribute__((packed)); | ||
30 | struct unaligned_16 { uint16_t l; } __attribute__((packed)); | ||
31 | |||
32 | #define AV_RN16(a) (((const struct unaligned_16 *) (a))->l) | ||
33 | #define AV_RN32(a) (((const struct unaligned_32 *) (a))->l) | ||
34 | #define AV_RN64(a) (((const struct unaligned_64 *) (a))->l) | ||
35 | |||
36 | #define AV_WN16(a, b) (((struct unaligned_16 *) (a))->l) = (b) | ||
37 | #define AV_WN32(a, b) (((struct unaligned_32 *) (a))->l) = (b) | ||
38 | #define AV_WN64(a, b) (((struct unaligned_64 *) (a))->l) = (b) | ||
39 | |||
40 | #elif defined(__DECC) | ||
41 | |||
42 | #define AV_RN16(a) (*((const __unaligned uint16_t*)(a))) | ||
43 | #define AV_RN32(a) (*((const __unaligned uint32_t*)(a))) | ||
44 | #define AV_RN64(a) (*((const __unaligned uint64_t*)(a))) | ||
45 | |||
46 | #define AV_WN16(a, b) *((__unaligned uint16_t*)(a)) = (b) | ||
47 | #define AV_WN32(a, b) *((__unaligned uint32_t*)(a)) = (b) | ||
48 | #define AV_WN64(a, b) *((__unaligned uint64_t*)(a)) = (b) | ||
49 | |||
50 | #else | ||
51 | |||
52 | #define AV_RN16(a) (*((const uint16_t*)(a))) | ||
53 | #define AV_RN32(a) (*((const uint32_t*)(a))) | ||
54 | #define AV_RN64(a) (*((const uint64_t*)(a))) | ||
55 | |||
56 | #define AV_WN16(a, b) *((uint16_t*)(a)) = (b) | ||
57 | #define AV_WN32(a, b) *((uint32_t*)(a)) = (b) | ||
58 | #define AV_WN64(a, b) *((uint64_t*)(a)) = (b) | ||
59 | |||
60 | #endif /* !__GNUC__ */ | ||
61 | |||
62 | /* endian macros */ | ||
63 | #define AV_RB8(x) (((const uint8_t*)(x))[0]) | ||
64 | #define AV_WB8(p, d) do { ((uint8_t*)(p))[0] = (d); } while(0) | ||
65 | |||
66 | #define AV_RL8(x) AV_RB8(x) | ||
67 | #define AV_WL8(p, d) AV_WB8(p, d) | ||
68 | |||
69 | #if HAVE_FAST_UNALIGNED | ||
70 | # ifdef WORDS_BIGENDIAN | ||
71 | # define AV_RB16(x) AV_RN16(x) | ||
72 | # define AV_WB16(p, d) AV_WN16(p, d) | ||
73 | |||
74 | # define AV_RL16(x) bswap_16(AV_RN16(x)) | ||
75 | # define AV_WL16(p, d) AV_WN16(p, bswap_16(d)) | ||
76 | |||
77 | # define AV_RB32(x) AV_RN32(x) | ||
78 | # define AV_WB32(p, d) AV_WN32(p, d) | ||
79 | |||
80 | # define AV_RL32(x) bswap_32(AV_RN32(x)) | ||
81 | # define AV_WL32(p, d) AV_WN32(p, bswap_32(d)) | ||
82 | |||
83 | # define AV_RB64(x) AV_RN64(x) | ||
84 | # define AV_WB64(p, d) AV_WN64(p, d) | ||
85 | |||
86 | # define AV_RL64(x) bswap_64(AV_RN64(x)) | ||
87 | # define AV_WL64(p, d) AV_WN64(p, bswap_64(d)) | ||
88 | # else /* WORDS_BIGENDIAN */ | ||
89 | # define AV_RB16(x) bswap_16(AV_RN16(x)) | ||
90 | # define AV_WB16(p, d) AV_WN16(p, bswap_16(d)) | ||
91 | |||
92 | # define AV_RL16(x) AV_RN16(x) | ||
93 | # define AV_WL16(p, d) AV_WN16(p, d) | ||
94 | |||
95 | # define AV_RB32(x) bswap_32(AV_RN32(x)) | ||
96 | # define AV_WB32(p, d) AV_WN32(p, bswap_32(d)) | ||
97 | |||
98 | # define AV_RL32(x) AV_RN32(x) | ||
99 | # define AV_WL32(p, d) AV_WN32(p, d) | ||
100 | |||
101 | # define AV_RB64(x) bswap_64(AV_RN64(x)) | ||
102 | # define AV_WB64(p, d) AV_WN64(p, bswap_64(d)) | ||
103 | |||
104 | # define AV_RL64(x) AV_RN64(x) | ||
105 | # define AV_WL64(p, d) AV_WN64(p, d) | ||
106 | # endif | ||
107 | #else /* HAVE_FAST_UNALIGNED */ | ||
108 | #define AV_RB16(x) ((((const uint8_t*)(x))[0] << 8) | ((const uint8_t*)(x))[1]) | ||
109 | #define AV_WB16(p, d) do { \ | ||
110 | ((uint8_t*)(p))[1] = (d); \ | ||
111 | ((uint8_t*)(p))[0] = (d)>>8; } while(0) | ||
112 | |||
113 | #define AV_RL16(x) ((((const uint8_t*)(x))[1] << 8) | \ | ||
114 | ((const uint8_t*)(x))[0]) | ||
115 | #define AV_WL16(p, d) do { \ | ||
116 | ((uint8_t*)(p))[0] = (d); \ | ||
117 | ((uint8_t*)(p))[1] = (d)>>8; } while(0) | ||
118 | |||
119 | #define AV_RB32(x) ((((const uint8_t*)(x))[0] << 24) | \ | ||
120 | (((const uint8_t*)(x))[1] << 16) | \ | ||
121 | (((const uint8_t*)(x))[2] << 8) | \ | ||
122 | ((const uint8_t*)(x))[3]) | ||
123 | #define AV_WB32(p, d) do { \ | ||
124 | ((uint8_t*)(p))[3] = (d); \ | ||
125 | ((uint8_t*)(p))[2] = (d)>>8; \ | ||
126 | ((uint8_t*)(p))[1] = (d)>>16; \ | ||
127 | ((uint8_t*)(p))[0] = (d)>>24; } while(0) | ||
128 | |||
129 | #define AV_RL32(x) ((((const uint8_t*)(x))[3] << 24) | \ | ||
130 | (((const uint8_t*)(x))[2] << 16) | \ | ||
131 | (((const uint8_t*)(x))[1] << 8) | \ | ||
132 | ((const uint8_t*)(x))[0]) | ||
133 | #define AV_WL32(p, d) do { \ | ||
134 | ((uint8_t*)(p))[0] = (d); \ | ||
135 | ((uint8_t*)(p))[1] = (d)>>8; \ | ||
136 | ((uint8_t*)(p))[2] = (d)>>16; \ | ||
137 | ((uint8_t*)(p))[3] = (d)>>24; } while(0) | ||
138 | |||
139 | #define AV_RB64(x) (((uint64_t)((const uint8_t*)(x))[0] << 56) | \ | ||
140 | ((uint64_t)((const uint8_t*)(x))[1] << 48) | \ | ||
141 | ((uint64_t)((const uint8_t*)(x))[2] << 40) | \ | ||
142 | ((uint64_t)((const uint8_t*)(x))[3] << 32) | \ | ||
143 | ((uint64_t)((const uint8_t*)(x))[4] << 24) | \ | ||
144 | ((uint64_t)((const uint8_t*)(x))[5] << 16) | \ | ||
145 | ((uint64_t)((const uint8_t*)(x))[6] << 8) | \ | ||
146 | (uint64_t)((const uint8_t*)(x))[7]) | ||
147 | #define AV_WB64(p, d) do { \ | ||
148 | ((uint8_t*)(p))[7] = (d); \ | ||
149 | ((uint8_t*)(p))[6] = (d)>>8; \ | ||
150 | ((uint8_t*)(p))[5] = (d)>>16; \ | ||
151 | ((uint8_t*)(p))[4] = (d)>>24; \ | ||
152 | ((uint8_t*)(p))[3] = (d)>>32; \ | ||
153 | ((uint8_t*)(p))[2] = (d)>>40; \ | ||
154 | ((uint8_t*)(p))[1] = (d)>>48; \ | ||
155 | ((uint8_t*)(p))[0] = (d)>>56; } while(0) | ||
156 | |||
157 | #define AV_RL64(x) (((uint64_t)((const uint8_t*)(x))[7] << 56) | \ | ||
158 | ((uint64_t)((const uint8_t*)(x))[6] << 48) | \ | ||
159 | ((uint64_t)((const uint8_t*)(x))[5] << 40) | \ | ||
160 | ((uint64_t)((const uint8_t*)(x))[4] << 32) | \ | ||
161 | ((uint64_t)((const uint8_t*)(x))[3] << 24) | \ | ||
162 | ((uint64_t)((const uint8_t*)(x))[2] << 16) | \ | ||
163 | ((uint64_t)((const uint8_t*)(x))[1] << 8) | \ | ||
164 | (uint64_t)((const uint8_t*)(x))[0]) | ||
165 | #define AV_WL64(p, d) do { \ | ||
166 | ((uint8_t*)(p))[0] = (d); \ | ||
167 | ((uint8_t*)(p))[1] = (d)>>8; \ | ||
168 | ((uint8_t*)(p))[2] = (d)>>16; \ | ||
169 | ((uint8_t*)(p))[3] = (d)>>24; \ | ||
170 | ((uint8_t*)(p))[4] = (d)>>32; \ | ||
171 | ((uint8_t*)(p))[5] = (d)>>40; \ | ||
172 | ((uint8_t*)(p))[6] = (d)>>48; \ | ||
173 | ((uint8_t*)(p))[7] = (d)>>56; } while(0) | ||
174 | #endif /* HAVE_FAST_UNALIGNED */ | ||
175 | |||
176 | #define AV_RB24(x) ((((const uint8_t*)(x))[0] << 16) | \ | ||
177 | (((const uint8_t*)(x))[1] << 8) | \ | ||
178 | ((const uint8_t*)(x))[2]) | ||
179 | #define AV_WB24(p, d) do { \ | ||
180 | ((uint8_t*)(p))[2] = (d); \ | ||
181 | ((uint8_t*)(p))[1] = (d)>>8; \ | ||
182 | ((uint8_t*)(p))[0] = (d)>>16; } while(0) | ||
183 | |||
184 | #define AV_RL24(x) ((((const uint8_t*)(x))[2] << 16) | \ | ||
185 | (((const uint8_t*)(x))[1] << 8) | \ | ||
186 | ((const uint8_t*)(x))[0]) | ||
187 | #define AV_WL24(p, d) do { \ | ||
188 | ((uint8_t*)(p))[0] = (d); \ | ||
189 | ((uint8_t*)(p))[1] = (d)>>8; \ | ||
190 | ((uint8_t*)(p))[2] = (d)>>16; } while(0) | ||
191 | |||
192 | #endif /* AVUTIL_INTREADWRITE_H */ | ||
diff --git a/apps/codecs/libcook/libavutil/lfg.c b/apps/codecs/libcook/libavutil/lfg.c new file mode 100644 index 0000000000..337ee9e41c --- /dev/null +++ b/apps/codecs/libcook/libavutil/lfg.c | |||
@@ -0,0 +1,64 @@ | |||
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 | #include <inttypes.h> | ||
23 | #include "lfg.h" | ||
24 | #include "md5.h" | ||
25 | #include "intreadwrite.h" | ||
26 | |||
27 | void av_cold av_lfg_init(AVLFG *c, unsigned int seed){ | ||
28 | uint8_t tmp[16]={0}; | ||
29 | int i; | ||
30 | |||
31 | for(i=8; i<64; i+=4){ | ||
32 | AV_WL32(tmp, seed); tmp[4]=i; | ||
33 | av_md5_sum(tmp, tmp, 16); | ||
34 | c->state[i ]= AV_RL32(tmp); | ||
35 | c->state[i+1]= AV_RL32(tmp+4); | ||
36 | c->state[i+2]= AV_RL32(tmp+8); | ||
37 | c->state[i+3]= AV_RL32(tmp+12); | ||
38 | } | ||
39 | c->index=0; | ||
40 | } | ||
41 | |||
42 | #ifdef TEST | ||
43 | #include "log.h" | ||
44 | #include "common.h" | ||
45 | |||
46 | int main(void) | ||
47 | { | ||
48 | int x=0; | ||
49 | int i, j; | ||
50 | AVLFG state; | ||
51 | |||
52 | av_lfg_init(&state, 0xdeadbeef); | ||
53 | for (j = 0; j < 10000; j++) { | ||
54 | START_TIMER | ||
55 | for (i = 0; i < 624; i++) { | ||
56 | // av_log(NULL,AV_LOG_ERROR, "%X\n", av_lfg_get(&state)); | ||
57 | x+=av_lfg_get(&state); | ||
58 | } | ||
59 | STOP_TIMER("624 calls of av_random"); | ||
60 | } | ||
61 | av_log(NULL, AV_LOG_ERROR, "final value:%X\n", x); | ||
62 | return 0; | ||
63 | } | ||
64 | #endif | ||
diff --git a/apps/codecs/libcook/libavutil/lfg.h b/apps/codecs/libcook/libavutil/lfg.h new file mode 100644 index 0000000000..3250c18e79 --- /dev/null +++ b/apps/codecs/libcook/libavutil/lfg.h | |||
@@ -0,0 +1,54 @@ | |||
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 | * Gets 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 | * Gets 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 | #endif /* AVUTIL_LFG_H */ | ||
diff --git a/apps/codecs/libcook/libavutil/log.c b/apps/codecs/libcook/libavutil/log.c new file mode 100644 index 0000000000..4bb9652c2c --- /dev/null +++ b/apps/codecs/libcook/libavutil/log.c | |||
@@ -0,0 +1,89 @@ | |||
1 | /* | ||
2 | * log functions | ||
3 | * Copyright (c) 2003 Michel Bardiaux | ||
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 libavutil/log.c | ||
24 | * logging functions | ||
25 | */ | ||
26 | |||
27 | #include "avutil.h" | ||
28 | #include "log.h" | ||
29 | |||
30 | int av_log_level = AV_LOG_INFO; | ||
31 | |||
32 | void av_log_default_callback(void* ptr, int level, const char* fmt, va_list vl) | ||
33 | { | ||
34 | static int print_prefix=1; | ||
35 | static int count; | ||
36 | static char line[1024], prev[1024]; | ||
37 | AVClass* avc= ptr ? *(AVClass**)ptr : NULL; | ||
38 | if(level>av_log_level) | ||
39 | return; | ||
40 | #undef fprintf | ||
41 | if(print_prefix && avc) { | ||
42 | snprintf(line, sizeof(line), "[%s @ %p]", avc->item_name(ptr), ptr); | ||
43 | }else | ||
44 | line[0]=0; | ||
45 | |||
46 | vsnprintf(line + strlen(line), sizeof(line) - strlen(line), fmt, vl); | ||
47 | |||
48 | print_prefix= line[strlen(line)-1] == '\n'; | ||
49 | if(print_prefix && !strcmp(line, prev)){ | ||
50 | count++; | ||
51 | return; | ||
52 | } | ||
53 | if(count>0){ | ||
54 | fprintf(stderr, " Last message repeated %d times\n", count); | ||
55 | count=0; | ||
56 | } | ||
57 | fputs(line, stderr); | ||
58 | strcpy(prev, line); | ||
59 | } | ||
60 | |||
61 | static void (*av_log_callback)(void*, int, const char*, va_list) = av_log_default_callback; | ||
62 | |||
63 | void av_log(void* avcl, int level, const char *fmt, ...) | ||
64 | { | ||
65 | va_list vl; | ||
66 | va_start(vl, fmt); | ||
67 | av_vlog(avcl, level, fmt, vl); | ||
68 | va_end(vl); | ||
69 | } | ||
70 | |||
71 | void av_vlog(void* avcl, int level, const char *fmt, va_list vl) | ||
72 | { | ||
73 | av_log_callback(avcl, level, fmt, vl); | ||
74 | } | ||
75 | |||
76 | int av_log_get_level(void) | ||
77 | { | ||
78 | return av_log_level; | ||
79 | } | ||
80 | |||
81 | void av_log_set_level(int level) | ||
82 | { | ||
83 | av_log_level = level; | ||
84 | } | ||
85 | |||
86 | void av_log_set_callback(void (*callback)(void*, int, const char*, va_list)) | ||
87 | { | ||
88 | av_log_callback = callback; | ||
89 | } | ||
diff --git a/apps/codecs/libcook/libavutil/log.h b/apps/codecs/libcook/libavutil/log.h new file mode 100644 index 0000000000..1206a2fc38 --- /dev/null +++ b/apps/codecs/libcook/libavutil/log.h | |||
@@ -0,0 +1,116 @@ | |||
1 | /* | ||
2 | * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> | ||
3 | * | ||
4 | * This file is part of FFmpeg. | ||
5 | * | ||
6 | * FFmpeg is free software; you can redistribute it and/or | ||
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 <stdarg.h> | ||
25 | #include "avutil.h" | ||
26 | |||
27 | /** | ||
28 | * Describes the class of an AVClass context structure. That is an | ||
29 | * arbitrary struct of which the first field is a pointer to an | ||
30 | * AVClass struct (e.g. AVCodecContext, AVFormatContext etc.). | ||
31 | */ | ||
32 | typedef struct AVCLASS AVClass; | ||
33 | struct AVCLASS { | ||
34 | /** | ||
35 | * The name of the class; usually it is the same name as the | ||
36 | * context structure type to which the AVClass is associated. | ||
37 | */ | ||
38 | const char* class_name; | ||
39 | |||
40 | /** | ||
41 | * A pointer to a function which returns the name of a context | ||
42 | * instance \p ctx associated with the class. | ||
43 | */ | ||
44 | const char* (*item_name)(void* ctx); | ||
45 | |||
46 | /** | ||
47 | * a pointer to the first option specified in the class if any or NULL | ||
48 | * | ||
49 | * @see av_set_default_options() | ||
50 | */ | ||
51 | const struct AVOption *option; | ||
52 | }; | ||
53 | |||
54 | /* av_log API */ | ||
55 | |||
56 | #define AV_LOG_QUIET -8 | ||
57 | |||
58 | /** | ||
59 | * Something went really wrong and we will crash now. | ||
60 | */ | ||
61 | #define AV_LOG_PANIC 0 | ||
62 | |||
63 | /** | ||
64 | * Something went wrong and recovery is not possible. | ||
65 | * For example, no header was found for a format which depends | ||
66 | * on headers or an illegal combination of parameters is used. | ||
67 | */ | ||
68 | #define AV_LOG_FATAL 8 | ||
69 | |||
70 | /** | ||
71 | * Something went wrong and cannot losslessly be recovered. | ||
72 | * However, not all future data is affected. | ||
73 | */ | ||
74 | #define AV_LOG_ERROR 16 | ||
75 | |||
76 | /** | ||
77 | * Something somehow does not look correct. This may or may not | ||
78 | * lead to problems. An example would be the use of '-vstrict -2'. | ||
79 | */ | ||
80 | #define AV_LOG_WARNING 24 | ||
81 | |||
82 | #define AV_LOG_INFO 32 | ||
83 | #define AV_LOG_VERBOSE 40 | ||
84 | |||
85 | /** | ||
86 | * Stuff which is only useful for libav* developers. | ||
87 | */ | ||
88 | #define AV_LOG_DEBUG 48 | ||
89 | |||
90 | /** | ||
91 | * Sends the specified message to the log if the level is less than or equal | ||
92 | * to the current av_log_level. By default, all logging messages are sent to | ||
93 | * stderr. This behavior can be altered by setting a different av_vlog callback | ||
94 | * function. | ||
95 | * | ||
96 | * @param avcl A pointer to an arbitrary struct of which the first field is a | ||
97 | * pointer to an AVClass struct. | ||
98 | * @param level The importance level of the message, lower values signifying | ||
99 | * higher importance. | ||
100 | * @param fmt The format string (printf-compatible) that specifies how | ||
101 | * subsequent arguments are converted to output. | ||
102 | * @see av_vlog | ||
103 | */ | ||
104 | #ifdef __GNUC__ | ||
105 | void av_log(void*, int level, const char *fmt, ...) __attribute__ ((__format__ (__printf__, 3, 4))); | ||
106 | #else | ||
107 | void av_log(void*, int level, const char *fmt, ...); | ||
108 | #endif | ||
109 | |||
110 | void av_vlog(void*, int level, const char *fmt, va_list); | ||
111 | int av_log_get_level(void); | ||
112 | void av_log_set_level(int); | ||
113 | void av_log_set_callback(void (*)(void*, int, const char*, va_list)); | ||
114 | void av_log_default_callback(void* ptr, int level, const char* fmt, va_list vl); | ||
115 | |||
116 | #endif /* AVUTIL_LOG_H */ | ||
diff --git a/apps/codecs/libcook/libavutil/md5.c b/apps/codecs/libcook/libavutil/md5.c new file mode 100644 index 0000000000..26d1fb3874 --- /dev/null +++ b/apps/codecs/libcook/libavutil/md5.c | |||
@@ -0,0 +1,182 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2006 Michael Niedermayer (michaelni@gmx.at) | ||
3 | * Copyright (C) 2003-2005 by Christopher R. Hertel (crh@ubiqx.mn.org) | ||
4 | * | ||
5 | * References: | ||
6 | * IETF RFC 1321: The MD5 Message-Digest Algorithm | ||
7 | * Ron Rivest. IETF, April, 1992 | ||
8 | * | ||
9 | * based on http://ubiqx.org/libcifs/source/Auth/MD5.c | ||
10 | * from Christopher R. Hertel (crh@ubiqx.mn.org) | ||
11 | * Simplified, cleaned and IMO redundant comments removed by michael. | ||
12 | * | ||
13 | * If you use gcc, then version 4.1 or later and -fomit-frame-pointer is | ||
14 | * strongly recommended. | ||
15 | * | ||
16 | * This file is part of FFmpeg. | ||
17 | * | ||
18 | * FFmpeg is free software; you can redistribute it and/or | ||
19 | * modify it under the terms of the GNU Lesser General Public | ||
20 | * License as published by the Free Software Foundation; either | ||
21 | * version 2.1 of the License, or (at your option) any later version. | ||
22 | * | ||
23 | * FFmpeg is distributed in the hope that it will be useful, | ||
24 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
25 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
26 | * Lesser General Public License for more details. | ||
27 | * | ||
28 | * You should have received a copy of the GNU Lesser General Public | ||
29 | * License along with FFmpeg; if not, write to the Free Software | ||
30 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
31 | */ | ||
32 | |||
33 | #include <string.h> | ||
34 | #include "bswap.h" | ||
35 | #include "md5.h" | ||
36 | |||
37 | typedef struct AVMD5{ | ||
38 | uint64_t len; | ||
39 | uint8_t block[64]; | ||
40 | uint32_t ABCD[4]; | ||
41 | } AVMD5; | ||
42 | |||
43 | const int av_md5_size= sizeof(AVMD5); | ||
44 | |||
45 | static const uint8_t S[4][4] = { | ||
46 | { 7, 12, 17, 22 }, /* round 1 */ | ||
47 | { 5, 9, 14, 20 }, /* round 2 */ | ||
48 | { 4, 11, 16, 23 }, /* round 3 */ | ||
49 | { 6, 10, 15, 21 } /* round 4 */ | ||
50 | }; | ||
51 | |||
52 | static const uint32_t T[64] = { // T[i]= fabs(sin(i+1)<<32) | ||
53 | 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, /* round 1 */ | ||
54 | 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501, | ||
55 | 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, | ||
56 | 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821, | ||
57 | |||
58 | 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, /* round 2 */ | ||
59 | 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8, | ||
60 | 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, | ||
61 | 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a, | ||
62 | |||
63 | 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, /* round 3 */ | ||
64 | 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70, | ||
65 | 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, | ||
66 | 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665, | ||
67 | |||
68 | 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, /* round 4 */ | ||
69 | 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1, | ||
70 | 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, | ||
71 | 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391, | ||
72 | }; | ||
73 | |||
74 | #define CORE(i, a, b, c, d) \ | ||
75 | t = S[i>>4][i&3];\ | ||
76 | a += T[i];\ | ||
77 | \ | ||
78 | if(i<32){\ | ||
79 | if(i<16) a += (d ^ (b&(c^d))) + X[ i &15 ];\ | ||
80 | else a += (c ^ (d&(c^b))) + X[ (1+5*i)&15 ];\ | ||
81 | }else{\ | ||
82 | if(i<48) a += (b^c^d) + X[ (5+3*i)&15 ];\ | ||
83 | else a += (c^(b|~d)) + X[ ( 7*i)&15 ];\ | ||
84 | }\ | ||
85 | a = b + (( a << t ) | ( a >> (32 - t) )); | ||
86 | |||
87 | static void body(uint32_t ABCD[4], uint32_t X[16]){ | ||
88 | |||
89 | int t; | ||
90 | int i av_unused; | ||
91 | unsigned int a= ABCD[3]; | ||
92 | unsigned int b= ABCD[2]; | ||
93 | unsigned int c= ABCD[1]; | ||
94 | unsigned int d= ABCD[0]; | ||
95 | |||
96 | #ifdef WORDS_BIGENDIAN | ||
97 | for(i=0; i<16; i++) | ||
98 | X[i]= bswap_32(X[i]); | ||
99 | #endif | ||
100 | |||
101 | #if CONFIG_SMALL | ||
102 | for( i = 0; i < 64; i++ ){ | ||
103 | CORE(i,a,b,c,d) | ||
104 | t=d; d=c; c=b; b=a; a=t; | ||
105 | } | ||
106 | #else | ||
107 | #define CORE2(i) CORE(i,a,b,c,d) CORE((i+1),d,a,b,c) CORE((i+2),c,d,a,b) CORE((i+3),b,c,d,a) | ||
108 | #define CORE4(i) CORE2(i) CORE2((i+4)) CORE2((i+8)) CORE2((i+12)) | ||
109 | CORE4(0) CORE4(16) CORE4(32) CORE4(48) | ||
110 | #endif | ||
111 | |||
112 | ABCD[0] += d; | ||
113 | ABCD[1] += c; | ||
114 | ABCD[2] += b; | ||
115 | ABCD[3] += a; | ||
116 | } | ||
117 | |||
118 | void av_md5_init(AVMD5 *ctx){ | ||
119 | ctx->len = 0; | ||
120 | |||
121 | ctx->ABCD[0] = 0x10325476; | ||
122 | ctx->ABCD[1] = 0x98badcfe; | ||
123 | ctx->ABCD[2] = 0xefcdab89; | ||
124 | ctx->ABCD[3] = 0x67452301; | ||
125 | } | ||
126 | |||
127 | void av_md5_update(AVMD5 *ctx, const uint8_t *src, const int len){ | ||
128 | int i, j; | ||
129 | |||
130 | j= ctx->len & 63; | ||
131 | ctx->len += len; | ||
132 | |||
133 | for( i = 0; i < len; i++ ){ | ||
134 | ctx->block[j++] = src[i]; | ||
135 | if( 64 == j ){ | ||
136 | body(ctx->ABCD, (uint32_t*) ctx->block); | ||
137 | j = 0; | ||
138 | } | ||
139 | } | ||
140 | } | ||
141 | |||
142 | void av_md5_final(AVMD5 *ctx, uint8_t *dst){ | ||
143 | int i; | ||
144 | uint64_t finalcount= le2me_64(ctx->len<<3); | ||
145 | |||
146 | av_md5_update(ctx, "\200", 1); | ||
147 | while((ctx->len & 63)!=56) | ||
148 | av_md5_update(ctx, "", 1); | ||
149 | |||
150 | av_md5_update(ctx, (uint8_t*)&finalcount, 8); | ||
151 | |||
152 | for(i=0; i<4; i++) | ||
153 | ((uint32_t*)dst)[i]= le2me_32(ctx->ABCD[3-i]); | ||
154 | } | ||
155 | |||
156 | void av_md5_sum(uint8_t *dst, const uint8_t *src, const int len){ | ||
157 | AVMD5 ctx[1]; | ||
158 | |||
159 | av_md5_init(ctx); | ||
160 | av_md5_update(ctx, src, len); | ||
161 | av_md5_final(ctx, dst); | ||
162 | } | ||
163 | |||
164 | #ifdef TEST | ||
165 | #include <stdio.h> | ||
166 | #undef printf | ||
167 | int main(void){ | ||
168 | uint64_t md5val; | ||
169 | int i; | ||
170 | uint8_t in[1000]; | ||
171 | |||
172 | for(i=0; i<1000; i++) in[i]= i*i; | ||
173 | av_md5_sum( (uint8_t*)&md5val, in, 1000); printf("%"PRId64"\n", md5val); | ||
174 | av_md5_sum( (uint8_t*)&md5val, in, 63); printf("%"PRId64"\n", md5val); | ||
175 | av_md5_sum( (uint8_t*)&md5val, in, 64); printf("%"PRId64"\n", md5val); | ||
176 | av_md5_sum( (uint8_t*)&md5val, in, 65); printf("%"PRId64"\n", md5val); | ||
177 | for(i=0; i<1000; i++) in[i]= i % 127; | ||
178 | av_md5_sum( (uint8_t*)&md5val, in, 999); printf("%"PRId64"\n", md5val); | ||
179 | |||
180 | return 0; | ||
181 | } | ||
182 | #endif | ||
diff --git a/apps/codecs/libcook/libavutil/md5.h b/apps/codecs/libcook/libavutil/md5.h new file mode 100644 index 0000000000..969202a807 --- /dev/null +++ b/apps/codecs/libcook/libavutil/md5.h | |||
@@ -0,0 +1,36 @@ | |||
1 | /* | ||
2 | * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> | ||
3 | * | ||
4 | * This file is part of FFmpeg. | ||
5 | * | ||
6 | * FFmpeg is free software; you can redistribute it and/or | ||
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 <stdint.h> | ||
25 | |||
26 | extern const int av_md5_size; | ||
27 | |||
28 | struct AVMD5; | ||
29 | |||
30 | void av_md5_init(struct AVMD5 *ctx); | ||
31 | void av_md5_update(struct AVMD5 *ctx, const uint8_t *src, const int len); | ||
32 | void av_md5_final(struct AVMD5 *ctx, uint8_t *dst); | ||
33 | void av_md5_sum(uint8_t *dst, const uint8_t *src, const int len); | ||
34 | |||
35 | #endif /* AVUTIL_MD5_H */ | ||
36 | |||
diff --git a/apps/codecs/libcook/libavutil/mem.c b/apps/codecs/libcook/libavutil/mem.c new file mode 100644 index 0000000000..741450b53f --- /dev/null +++ b/apps/codecs/libcook/libavutil/mem.c | |||
@@ -0,0 +1,159 @@ | |||
1 | /* | ||
2 | * default memory allocator for libavutil | ||
3 | * Copyright (c) 2002 Fabrice Bellard | ||
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 libavutil/mem.c | ||
24 | * default memory allocator for libavutil | ||
25 | */ | ||
26 | |||
27 | #include "config.h" | ||
28 | |||
29 | #include <limits.h> | ||
30 | #include <stdlib.h> | ||
31 | #include <string.h> | ||
32 | #if HAVE_MALLOC_H | ||
33 | #include <malloc.h> | ||
34 | #endif | ||
35 | |||
36 | #include "mem.h" | ||
37 | |||
38 | /* here we can use OS-dependent allocation functions */ | ||
39 | #undef free | ||
40 | #undef malloc | ||
41 | #undef realloc | ||
42 | |||
43 | /* You can redefine av_malloc and av_free in your project to use your | ||
44 | memory allocator. You do not need to suppress this file because the | ||
45 | linker will do it automatically. */ | ||
46 | |||
47 | void *av_malloc(unsigned int size) | ||
48 | { | ||
49 | void *ptr = NULL; | ||
50 | #if CONFIG_MEMALIGN_HACK | ||
51 | long diff; | ||
52 | #endif | ||
53 | |||
54 | /* let's disallow possible ambiguous cases */ | ||
55 | if(size > (INT_MAX-16) ) | ||
56 | return NULL; | ||
57 | |||
58 | #if CONFIG_MEMALIGN_HACK | ||
59 | ptr = malloc(size+16); | ||
60 | if(!ptr) | ||
61 | return ptr; | ||
62 | diff= ((-(long)ptr - 1)&15) + 1; | ||
63 | ptr = (char*)ptr + diff; | ||
64 | ((char*)ptr)[-1]= diff; | ||
65 | #elif HAVE_POSIX_MEMALIGN | ||
66 | if (posix_memalign(&ptr,16,size)) | ||
67 | ptr = NULL; | ||
68 | #elif HAVE_MEMALIGN | ||
69 | ptr = memalign(16,size); | ||
70 | /* Why 64? | ||
71 | Indeed, we should align it: | ||
72 | on 4 for 386 | ||
73 | on 16 for 486 | ||
74 | on 32 for 586, PPro - K6-III | ||
75 | on 64 for K7 (maybe for P3 too). | ||
76 | Because L1 and L2 caches are aligned on those values. | ||
77 | But I don't want to code such logic here! | ||
78 | */ | ||
79 | /* Why 16? | ||
80 | Because some CPUs need alignment, for example SSE2 on P4, & most RISC CPUs | ||
81 | it will just trigger an exception and the unaligned load will be done in the | ||
82 | exception handler or it will just segfault (SSE2 on P4). | ||
83 | Why not larger? Because I did not see a difference in benchmarks ... | ||
84 | */ | ||
85 | /* benchmarks with P3 | ||
86 | memalign(64)+1 3071,3051,3032 | ||
87 | memalign(64)+2 3051,3032,3041 | ||
88 | memalign(64)+4 2911,2896,2915 | ||
89 | memalign(64)+8 2545,2554,2550 | ||
90 | memalign(64)+16 2543,2572,2563 | ||
91 | memalign(64)+32 2546,2545,2571 | ||
92 | memalign(64)+64 2570,2533,2558 | ||
93 | |||
94 | BTW, malloc seems to do 8-byte alignment by default here. | ||
95 | */ | ||
96 | #else | ||
97 | ptr = malloc(size); | ||
98 | #endif | ||
99 | return ptr; | ||
100 | } | ||
101 | |||
102 | void *av_realloc(void *ptr, unsigned int size) | ||
103 | { | ||
104 | #if CONFIG_MEMALIGN_HACK | ||
105 | int diff; | ||
106 | #endif | ||
107 | |||
108 | /* let's disallow possible ambiguous cases */ | ||
109 | if(size > (INT_MAX-16) ) | ||
110 | return NULL; | ||
111 | |||
112 | #if CONFIG_MEMALIGN_HACK | ||
113 | //FIXME this isn't aligned correctly, though it probably isn't needed | ||
114 | if(!ptr) return av_malloc(size); | ||
115 | diff= ((char*)ptr)[-1]; | ||
116 | return (char*)realloc((char*)ptr - diff, size + diff) + diff; | ||
117 | #else | ||
118 | return realloc(ptr, size); | ||
119 | #endif | ||
120 | } | ||
121 | |||
122 | void av_free(void *ptr) | ||
123 | { | ||
124 | /* XXX: this test should not be needed on most libcs */ | ||
125 | if (ptr) | ||
126 | #if CONFIG_MEMALIGN_HACK | ||
127 | free((char*)ptr - ((char*)ptr)[-1]); | ||
128 | #else | ||
129 | free(ptr); | ||
130 | #endif | ||
131 | } | ||
132 | |||
133 | void av_freep(void *arg) | ||
134 | { | ||
135 | void **ptr= (void**)arg; | ||
136 | av_free(*ptr); | ||
137 | *ptr = NULL; | ||
138 | } | ||
139 | |||
140 | void *av_mallocz(unsigned int size) | ||
141 | { | ||
142 | void *ptr = av_malloc(size); | ||
143 | if (ptr) | ||
144 | memset(ptr, 0, size); | ||
145 | return ptr; | ||
146 | } | ||
147 | |||
148 | char *av_strdup(const char *s) | ||
149 | { | ||
150 | char *ptr= NULL; | ||
151 | if(s){ | ||
152 | int len = strlen(s) + 1; | ||
153 | ptr = av_malloc(len); | ||
154 | if (ptr) | ||
155 | memcpy(ptr, s, len); | ||
156 | } | ||
157 | return ptr; | ||
158 | } | ||
159 | |||
diff --git a/apps/codecs/libcook/libavutil/mem.h b/apps/codecs/libcook/libavutil/mem.h new file mode 100644 index 0000000000..e50553aefe --- /dev/null +++ b/apps/codecs/libcook/libavutil/mem.h | |||
@@ -0,0 +1,104 @@ | |||
1 | /* | ||
2 | * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> | ||
3 | * | ||
4 | * This file is part of FFmpeg. | ||
5 | * | ||
6 | * FFmpeg is free software; you can redistribute it and/or | ||
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 libavutil/mem.h | ||
23 | * memory handling functions | ||
24 | */ | ||
25 | |||
26 | #ifndef AVUTIL_MEM_H | ||
27 | #define AVUTIL_MEM_H | ||
28 | |||
29 | #include "common.h" | ||
30 | |||
31 | #if AV_GCC_VERSION_AT_LEAST(3,1) | ||
32 | #define av_malloc_attrib __attribute__((__malloc__)) | ||
33 | #else | ||
34 | #define av_malloc_attrib | ||
35 | #endif | ||
36 | |||
37 | #if (!defined(__ICC) || __ICC > 1100) && AV_GCC_VERSION_AT_LEAST(4,3) | ||
38 | #define av_alloc_size(n) __attribute__((alloc_size(n))) | ||
39 | #else | ||
40 | #define av_alloc_size(n) | ||
41 | #endif | ||
42 | |||
43 | /** | ||
44 | * Allocates a block of \p size bytes with alignment suitable for all | ||
45 | * memory accesses (including vectors if available on the CPU). | ||
46 | * @param size Size in bytes for the memory block to be allocated. | ||
47 | * @return Pointer to the allocated block, NULL if the block cannot | ||
48 | * be allocated. | ||
49 | * @see av_mallocz() | ||
50 | */ | ||
51 | void *av_malloc(unsigned int size) av_malloc_attrib av_alloc_size(1); | ||
52 | |||
53 | /** | ||
54 | * Allocates or reallocates a block of memory. | ||
55 | * If \p ptr is NULL and \p size > 0, allocates a new block. If \p | ||
56 | * size is zero, frees the memory block pointed to by \p ptr. | ||
57 | * @param size Size in bytes for the memory block to be allocated or | ||
58 | * reallocated. | ||
59 | * @param ptr Pointer to a memory block already allocated with | ||
60 | * av_malloc(z)() or av_realloc() or NULL. | ||
61 | * @return Pointer to a newly reallocated block or NULL if the block | ||
62 | * cannot be reallocated or the function is used to free the memory block. | ||
63 | * @see av_fast_realloc() | ||
64 | */ | ||
65 | void *av_realloc(void *ptr, unsigned int size) av_alloc_size(2); | ||
66 | |||
67 | /** | ||
68 | * Frees a memory block which has been allocated with av_malloc(z)() or | ||
69 | * av_realloc(). | ||
70 | * @param ptr Pointer to the memory block which should be freed. | ||
71 | * @note ptr = NULL is explicitly allowed. | ||
72 | * @note It is recommended that you use av_freep() instead. | ||
73 | * @see av_freep() | ||
74 | */ | ||
75 | void av_free(void *ptr); | ||
76 | |||
77 | /** | ||
78 | * Allocates a block of \p size bytes with alignment suitable for all | ||
79 | * memory accesses (including vectors if available on the CPU) and | ||
80 | * zeroes all the bytes of the block. | ||
81 | * @param size Size in bytes for the memory block to be allocated. | ||
82 | * @return Pointer to the allocated block, NULL if it cannot be allocated. | ||
83 | * @see av_malloc() | ||
84 | */ | ||
85 | void *av_mallocz(unsigned int size) av_malloc_attrib av_alloc_size(1); | ||
86 | |||
87 | /** | ||
88 | * Duplicates the string \p s. | ||
89 | * @param s string to be duplicated | ||
90 | * @return Pointer to a newly allocated string containing a | ||
91 | * copy of \p s or NULL if the string cannot be allocated. | ||
92 | */ | ||
93 | char *av_strdup(const char *s) av_malloc_attrib; | ||
94 | |||
95 | /** | ||
96 | * Frees a memory block which has been allocated with av_malloc(z)() or | ||
97 | * av_realloc() and set the pointer pointing to it to NULL. | ||
98 | * @param ptr Pointer to the pointer to the memory block which should | ||
99 | * be freed. | ||
100 | * @see av_free() | ||
101 | */ | ||
102 | void av_freep(void *ptr); | ||
103 | |||
104 | #endif /* AVUTIL_MEM_H */ | ||