diff options
Diffstat (limited to 'lib/rbcodec/codecs/libwmavoice/libavutil/common.h')
-rw-r--r-- | lib/rbcodec/codecs/libwmavoice/libavutil/common.h | 346 |
1 files changed, 346 insertions, 0 deletions
diff --git a/lib/rbcodec/codecs/libwmavoice/libavutil/common.h b/lib/rbcodec/codecs/libwmavoice/libavutil/common.h new file mode 100644 index 0000000000..f9c03db559 --- /dev/null +++ b/lib/rbcodec/codecs/libwmavoice/libavutil/common.h | |||
@@ -0,0 +1,346 @@ | |||
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 | ||
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 | #include "attributes.h" | ||
38 | |||
39 | //rounded division & shift | ||
40 | #define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b)) | ||
41 | /* assume b>0 */ | ||
42 | #define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b)) | ||
43 | #define FFABS(a) ((a) >= 0 ? (a) : (-(a))) | ||
44 | #define FFSIGN(a) ((a) > 0 ? 1 : -1) | ||
45 | |||
46 | #define FFMAX(a,b) ((a) > (b) ? (a) : (b)) | ||
47 | #define FFMAX3(a,b,c) FFMAX(FFMAX(a,b),c) | ||
48 | #define FFMIN(a,b) ((a) > (b) ? (b) : (a)) | ||
49 | #define FFMIN3(a,b,c) FFMIN(FFMIN(a,b),c) | ||
50 | |||
51 | #define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0) | ||
52 | #define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)[0])) | ||
53 | #define FFALIGN(x, a) (((x)+(a)-1)&~((a)-1)) | ||
54 | |||
55 | /* misc math functions */ | ||
56 | extern const uint8_t ff_log2_tab[256]; | ||
57 | |||
58 | extern const uint8_t av_reverse[256]; | ||
59 | |||
60 | static inline av_const int av_log2_c(unsigned int v) | ||
61 | { | ||
62 | int n = 0; | ||
63 | if (v & 0xffff0000) { | ||
64 | v >>= 16; | ||
65 | n += 16; | ||
66 | } | ||
67 | if (v & 0xff00) { | ||
68 | v >>= 8; | ||
69 | n += 8; | ||
70 | } | ||
71 | n += ff_log2_tab[v]; | ||
72 | |||
73 | return n; | ||
74 | } | ||
75 | |||
76 | static inline av_const int av_log2_16bit_c(unsigned int v) | ||
77 | { | ||
78 | int n = 0; | ||
79 | if (v & 0xff00) { | ||
80 | v >>= 8; | ||
81 | n += 8; | ||
82 | } | ||
83 | n += ff_log2_tab[v]; | ||
84 | |||
85 | return n; | ||
86 | } | ||
87 | |||
88 | #ifdef HAVE_AV_CONFIG_H | ||
89 | # include "config.h" | ||
90 | # include "intmath.h" | ||
91 | #endif | ||
92 | |||
93 | /* Pull in unguarded fallback defines at the end of this file. */ | ||
94 | #include "common.h" | ||
95 | |||
96 | /** | ||
97 | * Clip a signed integer value into the amin-amax range. | ||
98 | * @param a value to clip | ||
99 | * @param amin minimum value of the clip range | ||
100 | * @param amax maximum value of the clip range | ||
101 | * @return clipped value | ||
102 | */ | ||
103 | static inline av_const int av_clip_c(int a, int amin, int amax) | ||
104 | { | ||
105 | if (a < amin) return amin; | ||
106 | else if (a > amax) return amax; | ||
107 | else return a; | ||
108 | } | ||
109 | |||
110 | /** | ||
111 | * Clip a signed integer value into the 0-255 range. | ||
112 | * @param a value to clip | ||
113 | * @return clipped value | ||
114 | */ | ||
115 | static inline av_const uint8_t av_clip_uint8_c(int a) | ||
116 | { | ||
117 | if (a&(~0xFF)) return (-a)>>31; | ||
118 | else return a; | ||
119 | } | ||
120 | |||
121 | /** | ||
122 | * Clip a signed integer value into the -128,127 range. | ||
123 | * @param a value to clip | ||
124 | * @return clipped value | ||
125 | */ | ||
126 | static inline av_const int8_t av_clip_int8_c(int a) | ||
127 | { | ||
128 | if ((a+0x80) & ~0xFF) return (a>>31) ^ 0x7F; | ||
129 | else return a; | ||
130 | } | ||
131 | |||
132 | /** | ||
133 | * Clip a signed integer value into the 0-65535 range. | ||
134 | * @param a value to clip | ||
135 | * @return clipped value | ||
136 | */ | ||
137 | static inline av_const uint16_t av_clip_uint16_c(int a) | ||
138 | { | ||
139 | if (a&(~0xFFFF)) return (-a)>>31; | ||
140 | else return a; | ||
141 | } | ||
142 | |||
143 | /** | ||
144 | * Clip a signed integer value into the -32768,32767 range. | ||
145 | * @param a value to clip | ||
146 | * @return clipped value | ||
147 | */ | ||
148 | static inline av_const int16_t av_clip_int16_c(int a) | ||
149 | { | ||
150 | if ((a+0x8000) & ~0xFFFF) return (a>>31) ^ 0x7FFF; | ||
151 | else return a; | ||
152 | } | ||
153 | |||
154 | /** | ||
155 | * Clip a signed 64-bit integer value into the -2147483648,2147483647 range. | ||
156 | * @param a value to clip | ||
157 | * @return clipped value | ||
158 | */ | ||
159 | static inline av_const int32_t av_clipl_int32_c(int64_t a) | ||
160 | { | ||
161 | if ((a+0x80000000u) & ~UINT64_C(0xFFFFFFFF)) return (a>>63) ^ 0x7FFFFFFF; | ||
162 | else return a; | ||
163 | } | ||
164 | |||
165 | /** | ||
166 | * Clip a float value into the amin-amax range. | ||
167 | * @param a value to clip | ||
168 | * @param amin minimum value of the clip range | ||
169 | * @param amax maximum value of the clip range | ||
170 | * @return clipped value | ||
171 | */ | ||
172 | static inline av_const float av_clipf_c(float a, float amin, float amax) | ||
173 | { | ||
174 | if (a < amin) return amin; | ||
175 | else if (a > amax) return amax; | ||
176 | else return a; | ||
177 | } | ||
178 | |||
179 | /** Compute ceil(log2(x)). | ||
180 | * @param x value used to compute ceil(log2(x)) | ||
181 | * @return computed ceiling of log2(x) | ||
182 | */ | ||
183 | static inline av_const int av_ceil_log2_c(int x) | ||
184 | { | ||
185 | return av_log2((x - 1) << 1); | ||
186 | } | ||
187 | |||
188 | #define MKTAG(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((d) << 24)) | ||
189 | #define MKBETAG(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((a) << 24)) | ||
190 | |||
191 | /** | ||
192 | * Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form. | ||
193 | * | ||
194 | * @param val Output value, must be an lvalue of type uint32_t. | ||
195 | * @param GET_BYTE Expression reading one byte from the input. | ||
196 | * Evaluated up to 7 times (4 for the currently | ||
197 | * assigned Unicode range). With a memory buffer | ||
198 | * input, this could be *ptr++. | ||
199 | * @param ERROR Expression to be evaluated on invalid input, | ||
200 | * typically a goto statement. | ||
201 | */ | ||
202 | #define GET_UTF8(val, GET_BYTE, ERROR)\ | ||
203 | val= GET_BYTE;\ | ||
204 | {\ | ||
205 | int ones= 7 - av_log2(val ^ 255);\ | ||
206 | if(ones==1)\ | ||
207 | ERROR\ | ||
208 | val&= 127>>ones;\ | ||
209 | while(--ones > 0){\ | ||
210 | int tmp= GET_BYTE - 128;\ | ||
211 | if(tmp>>6)\ | ||
212 | ERROR\ | ||
213 | val= (val<<6) + tmp;\ | ||
214 | }\ | ||
215 | } | ||
216 | |||
217 | /** | ||
218 | * Convert a UTF-16 character (2 or 4 bytes) to its 32-bit UCS-4 encoded form. | ||
219 | * | ||
220 | * @param val Output value, must be an lvalue of type uint32_t. | ||
221 | * @param GET_16BIT Expression returning two bytes of UTF-16 data converted | ||
222 | * to native byte order. Evaluated one or two times. | ||
223 | * @param ERROR Expression to be evaluated on invalid input, | ||
224 | * typically a goto statement. | ||
225 | */ | ||
226 | #define GET_UTF16(val, GET_16BIT, ERROR)\ | ||
227 | val = GET_16BIT;\ | ||
228 | {\ | ||
229 | unsigned int hi = val - 0xD800;\ | ||
230 | if (hi < 0x800) {\ | ||
231 | val = GET_16BIT - 0xDC00;\ | ||
232 | if (val > 0x3FFU || hi > 0x3FFU)\ | ||
233 | ERROR\ | ||
234 | val += (hi<<10) + 0x10000;\ | ||
235 | }\ | ||
236 | }\ | ||
237 | |||
238 | /*! | ||
239 | * \def PUT_UTF8(val, tmp, PUT_BYTE) | ||
240 | * Convert a 32-bit Unicode character to its UTF-8 encoded form (up to 4 bytes long). | ||
241 | * \param val is an input-only argument and should be of type uint32_t. It holds | ||
242 | * a UCS-4 encoded Unicode character that is to be converted to UTF-8. If | ||
243 | * val is given as a function it is executed only once. | ||
244 | * \param tmp is a temporary variable and should be of type uint8_t. It | ||
245 | * represents an intermediate value during conversion that is to be | ||
246 | * output by PUT_BYTE. | ||
247 | * \param PUT_BYTE writes the converted UTF-8 bytes to any proper destination. | ||
248 | * It could be a function or a statement, and uses tmp as the input byte. | ||
249 | * For example, PUT_BYTE could be "*output++ = tmp;" PUT_BYTE will be | ||
250 | * executed up to 4 times for values in the valid UTF-8 range and up to | ||
251 | * 7 times in the general case, depending on the length of the converted | ||
252 | * Unicode character. | ||
253 | */ | ||
254 | #define PUT_UTF8(val, tmp, PUT_BYTE)\ | ||
255 | {\ | ||
256 | int bytes, shift;\ | ||
257 | uint32_t in = val;\ | ||
258 | if (in < 0x80) {\ | ||
259 | tmp = in;\ | ||
260 | PUT_BYTE\ | ||
261 | } else {\ | ||
262 | bytes = (av_log2(in) + 4) / 5;\ | ||
263 | shift = (bytes - 1) * 6;\ | ||
264 | tmp = (256 - (256 >> bytes)) | (in >> shift);\ | ||
265 | PUT_BYTE\ | ||
266 | while (shift >= 6) {\ | ||
267 | shift -= 6;\ | ||
268 | tmp = 0x80 | ((in >> shift) & 0x3f);\ | ||
269 | PUT_BYTE\ | ||
270 | }\ | ||
271 | }\ | ||
272 | } | ||
273 | |||
274 | /*! | ||
275 | * \def PUT_UTF16(val, tmp, PUT_16BIT) | ||
276 | * Convert a 32-bit Unicode character to its UTF-16 encoded form (2 or 4 bytes). | ||
277 | * \param val is an input-only argument and should be of type uint32_t. It holds | ||
278 | * a UCS-4 encoded Unicode character that is to be converted to UTF-16. If | ||
279 | * val is given as a function it is executed only once. | ||
280 | * \param tmp is a temporary variable and should be of type uint16_t. It | ||
281 | * represents an intermediate value during conversion that is to be | ||
282 | * output by PUT_16BIT. | ||
283 | * \param PUT_16BIT writes the converted UTF-16 data to any proper destination | ||
284 | * in desired endianness. It could be a function or a statement, and uses tmp | ||
285 | * as the input byte. For example, PUT_BYTE could be "*output++ = tmp;" | ||
286 | * PUT_BYTE will be executed 1 or 2 times depending on input character. | ||
287 | */ | ||
288 | #define PUT_UTF16(val, tmp, PUT_16BIT)\ | ||
289 | {\ | ||
290 | uint32_t in = val;\ | ||
291 | if (in < 0x10000) {\ | ||
292 | tmp = in;\ | ||
293 | PUT_16BIT\ | ||
294 | } else {\ | ||
295 | tmp = 0xD800 | ((in - 0x10000) >> 10);\ | ||
296 | PUT_16BIT\ | ||
297 | tmp = 0xDC00 | ((in - 0x10000) & 0x3FF);\ | ||
298 | PUT_16BIT\ | ||
299 | }\ | ||
300 | }\ | ||
301 | |||
302 | |||
303 | |||
304 | #include "mem.h" | ||
305 | |||
306 | #ifdef HAVE_AV_CONFIG_H | ||
307 | # include "internal.h" | ||
308 | #endif /* HAVE_AV_CONFIG_H */ | ||
309 | |||
310 | #endif /* AVUTIL_COMMON_H */ | ||
311 | |||
312 | /* | ||
313 | * The following definitions are outside the multiple inclusion guard | ||
314 | * to ensure they are immediately available in intmath.h. | ||
315 | */ | ||
316 | |||
317 | #ifndef av_log2 | ||
318 | # define av_log2 av_log2_c | ||
319 | #endif | ||
320 | #ifndef av_log2_16bit | ||
321 | # define av_log2_16bit av_log2_16bit_c | ||
322 | #endif | ||
323 | #ifndef av_ceil_log2 | ||
324 | # define av_ceil_log2 av_ceil_log2_c | ||
325 | #endif | ||
326 | #ifndef av_clip | ||
327 | # define av_clip av_clip_c | ||
328 | #endif | ||
329 | #ifndef av_clip_uint8 | ||
330 | # define av_clip_uint8 av_clip_uint8_c | ||
331 | #endif | ||
332 | #ifndef av_clip_int8 | ||
333 | # define av_clip_int8 av_clip_int8_c | ||
334 | #endif | ||
335 | #ifndef av_clip_uint16 | ||
336 | # define av_clip_uint16 av_clip_uint16_c | ||
337 | #endif | ||
338 | #ifndef av_clip_int16 | ||
339 | # define av_clip_int16 av_clip_int16_c | ||
340 | #endif | ||
341 | #ifndef av_clipl_int32 | ||
342 | # define av_clipl_int32 av_clipl_int32_c | ||
343 | #endif | ||
344 | #ifndef av_clipf | ||
345 | # define av_clipf av_clipf_c | ||
346 | #endif | ||