ffmpeg / libavutil / common.h @ 27af15dc
History | View | Annotate | Download (9.24 KB)
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 common.h
|
23 |
* common internal and external api header.
|
24 |
*/
|
25 |
|
26 |
#ifndef FFMPEG_COMMON_H
|
27 |
#define FFMPEG_COMMON_H
|
28 |
|
29 |
#include <inttypes.h> |
30 |
|
31 |
#ifdef HAVE_AV_CONFIG_H
|
32 |
/* only include the following when compiling package */
|
33 |
# include "config.h" |
34 |
|
35 |
# include <stdlib.h> |
36 |
# include <stdio.h> |
37 |
# include <string.h> |
38 |
# include <ctype.h> |
39 |
# include <limits.h> |
40 |
# include <errno.h> |
41 |
# include <math.h> |
42 |
#endif /* HAVE_AV_CONFIG_H */ |
43 |
|
44 |
#ifndef av_always_inline
|
45 |
#if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0) |
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 defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0) |
54 |
# define av_noinline __attribute__((noinline))
|
55 |
#else
|
56 |
# define av_noinline
|
57 |
#endif
|
58 |
#endif
|
59 |
|
60 |
#ifdef HAVE_AV_CONFIG_H
|
61 |
# include "internal.h" |
62 |
#endif /* HAVE_AV_CONFIG_H */ |
63 |
|
64 |
#ifndef attribute_deprecated
|
65 |
#if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0) |
66 |
# define attribute_deprecated __attribute__((deprecated))
|
67 |
#else
|
68 |
# define attribute_deprecated
|
69 |
#endif
|
70 |
#endif
|
71 |
|
72 |
#ifndef av_unused
|
73 |
#if defined(__GNUC__)
|
74 |
# define av_unused __attribute__((unused))
|
75 |
#else
|
76 |
# define av_unused
|
77 |
#endif
|
78 |
#endif
|
79 |
|
80 |
#include "mem.h" |
81 |
|
82 |
//rounded divison & shift
|
83 |
#define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b)) |
84 |
/* assume b>0 */
|
85 |
#define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b)) |
86 |
#define FFABS(a) ((a) >= 0 ? (a) : (-(a))) |
87 |
#define FFSIGN(a) ((a) > 0 ? 1 : -1) |
88 |
|
89 |
#define FFMAX(a,b) ((a) > (b) ? (a) : (b))
|
90 |
#define FFMIN(a,b) ((a) > (b) ? (b) : (a))
|
91 |
|
92 |
#define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0) |
93 |
|
94 |
/* misc math functions */
|
95 |
extern const uint8_t ff_log2_tab[256]; |
96 |
|
97 |
static inline int av_log2(unsigned int v) |
98 |
{ |
99 |
int n = 0; |
100 |
if (v & 0xffff0000) { |
101 |
v >>= 16;
|
102 |
n += 16;
|
103 |
} |
104 |
if (v & 0xff00) { |
105 |
v >>= 8;
|
106 |
n += 8;
|
107 |
} |
108 |
n += ff_log2_tab[v]; |
109 |
|
110 |
return n;
|
111 |
} |
112 |
|
113 |
static inline int av_log2_16bit(unsigned int v) |
114 |
{ |
115 |
int n = 0; |
116 |
if (v & 0xff00) { |
117 |
v >>= 8;
|
118 |
n += 8;
|
119 |
} |
120 |
n += ff_log2_tab[v]; |
121 |
|
122 |
return n;
|
123 |
} |
124 |
|
125 |
/* median of 3 */
|
126 |
static inline int mid_pred(int a, int b, int c) |
127 |
{ |
128 |
#ifdef HAVE_CMOV
|
129 |
int i=b;
|
130 |
asm volatile( |
131 |
"cmp %2, %1 \n\t"
|
132 |
"cmovg %1, %0 \n\t"
|
133 |
"cmovg %2, %1 \n\t"
|
134 |
"cmp %3, %1 \n\t"
|
135 |
"cmovl %3, %1 \n\t"
|
136 |
"cmp %1, %0 \n\t"
|
137 |
"cmovg %1, %0 \n\t"
|
138 |
:"+&r"(i), "+&r"(a) |
139 |
:"r"(b), "r"(c) |
140 |
); |
141 |
return i;
|
142 |
#elif 0 |
143 |
int t= (a-b)&((a-b)>>31); |
144 |
a-=t; |
145 |
b+=t; |
146 |
b-= (b-c)&((b-c)>>31);
|
147 |
b+= (a-b)&((a-b)>>31);
|
148 |
|
149 |
return b;
|
150 |
#else
|
151 |
if(a>b){
|
152 |
if(c>b){
|
153 |
if(c>a) b=a;
|
154 |
else b=c;
|
155 |
} |
156 |
}else{
|
157 |
if(b>c){
|
158 |
if(c>a) b=c;
|
159 |
else b=a;
|
160 |
} |
161 |
} |
162 |
return b;
|
163 |
#endif
|
164 |
} |
165 |
|
166 |
/**
|
167 |
* clip a signed integer value into the amin-amax range
|
168 |
* @param a value to clip
|
169 |
* @param amin minimum value of the clip range
|
170 |
* @param amax maximum value of the clip range
|
171 |
* @return clipped value
|
172 |
*/
|
173 |
static inline int av_clip(int a, int amin, int amax) |
174 |
{ |
175 |
if (a < amin) return amin; |
176 |
else if (a > amax) return amax; |
177 |
else return a; |
178 |
} |
179 |
|
180 |
/**
|
181 |
* clip a signed integer value into the 0-255 range
|
182 |
* @param a value to clip
|
183 |
* @return clipped value
|
184 |
*/
|
185 |
static inline uint8_t av_clip_uint8(int a) |
186 |
{ |
187 |
if (a&(~255)) return (-a)>>31; |
188 |
else return a; |
189 |
} |
190 |
|
191 |
/**
|
192 |
* clip a signed integer value into the -32768,32767 range
|
193 |
* @param a value to clip
|
194 |
* @return clipped value
|
195 |
*/
|
196 |
static inline int16_t av_clip_int16(int a) |
197 |
{ |
198 |
if ((a+32768) & ~65535) return (a>>31) ^ 32767; |
199 |
else return a; |
200 |
} |
201 |
|
202 |
/* math */
|
203 |
int64_t ff_gcd(int64_t a, int64_t b); |
204 |
|
205 |
/**
|
206 |
* converts fourcc string to int
|
207 |
*/
|
208 |
static inline int ff_get_fourcc(const char *s){ |
209 |
#ifdef HAVE_AV_CONFIG_H
|
210 |
assert( strlen(s)==4 );
|
211 |
#endif
|
212 |
|
213 |
return (s[0]) + (s[1]<<8) + (s[2]<<16) + (s[3]<<24); |
214 |
} |
215 |
|
216 |
#define MKTAG(a,b,c,d) (a | (b << 8) | (c << 16) | (d << 24)) |
217 |
#define MKBETAG(a,b,c,d) (d | (c << 8) | (b << 16) | (a << 24)) |
218 |
|
219 |
/*!
|
220 |
* \def GET_UTF8(val, GET_BYTE, ERROR)
|
221 |
* converts a UTF-8 character (up to 4 bytes long) to its 32-bit UCS-4 encoded form
|
222 |
* \param val is the output and should be of type uint32_t. It holds the converted
|
223 |
* UCS-4 character and should be a left value.
|
224 |
* \param GET_BYTE gets UTF-8 encoded bytes from any proper source. It can be
|
225 |
* a function or a statement whose return value or evaluated value is of type
|
226 |
* uint8_t. It will be executed up to 4 times for values in the valid UTF-8 range,
|
227 |
* and up to 7 times in the general case.
|
228 |
* \param ERROR action that should be taken when an invalid UTF-8 byte is returned
|
229 |
* from GET_BYTE. It should be a statement that jumps out of the macro,
|
230 |
* like exit(), goto, return, break, or continue.
|
231 |
*/
|
232 |
#define GET_UTF8(val, GET_BYTE, ERROR)\
|
233 |
val= GET_BYTE;\ |
234 |
{\ |
235 |
int ones= 7 - av_log2(val ^ 255);\ |
236 |
if(ones==1)\ |
237 |
ERROR\ |
238 |
val&= 127>>ones;\
|
239 |
while(--ones > 0){\ |
240 |
int tmp= GET_BYTE - 128;\ |
241 |
if(tmp>>6)\ |
242 |
ERROR\ |
243 |
val= (val<<6) + tmp;\
|
244 |
}\ |
245 |
} |
246 |
|
247 |
/*!
|
248 |
* \def PUT_UTF8(val, tmp, PUT_BYTE)
|
249 |
* converts a 32-bit unicode character to its UTF-8 encoded form (up to 4 bytes long).
|
250 |
* \param val is an input only argument and should be of type uint32_t. It holds
|
251 |
* a ucs4 encoded unicode character that is to be converted to UTF-8. If
|
252 |
* val is given as a function it's executed only once.
|
253 |
* \param tmp is a temporary variable and should be of type uint8_t. It
|
254 |
* represents an intermediate value during conversion that is to be
|
255 |
* outputted by PUT_BYTE.
|
256 |
* \param PUT_BYTE writes the converted UTF-8 bytes to any proper destination.
|
257 |
* It could be a function or a statement, and uses tmp as the input byte.
|
258 |
* For example, PUT_BYTE could be "*output++ = tmp;" PUT_BYTE will be
|
259 |
* executed up to 4 times for values in the valid UTF-8 range and up to
|
260 |
* 7 times in the general case, depending on the length of the converted
|
261 |
* unicode character.
|
262 |
*/
|
263 |
#define PUT_UTF8(val, tmp, PUT_BYTE)\
|
264 |
{\ |
265 |
int bytes, shift;\
|
266 |
uint32_t in = val;\ |
267 |
if (in < 0x80) {\ |
268 |
tmp = in;\ |
269 |
PUT_BYTE\ |
270 |
} else {\
|
271 |
bytes = (av_log2(in) + 4) / 5;\ |
272 |
shift = (bytes - 1) * 6;\ |
273 |
tmp = (256 - (256 >> bytes)) | (in >> shift);\ |
274 |
PUT_BYTE\ |
275 |
while (shift >= 6) {\ |
276 |
shift -= 6;\
|
277 |
tmp = 0x80 | ((in >> shift) & 0x3f);\ |
278 |
PUT_BYTE\ |
279 |
}\ |
280 |
}\ |
281 |
} |
282 |
|
283 |
#if defined(ARCH_X86) || defined(ARCH_POWERPC) || defined(ARCH_BFIN)
|
284 |
#define AV_READ_TIME read_time
|
285 |
#if defined(ARCH_X86_64)
|
286 |
static inline uint64_t read_time(void) |
287 |
{ |
288 |
uint64_t a, d; |
289 |
asm volatile("rdtsc\n\t" |
290 |
: "=a" (a), "=d" (d)); |
291 |
return (d << 32) | (a & 0xffffffff); |
292 |
} |
293 |
#elif defined(ARCH_X86_32)
|
294 |
static inline long long read_time(void) |
295 |
{ |
296 |
long long l; |
297 |
asm volatile("rdtsc\n\t" |
298 |
: "=A" (l));
|
299 |
return l;
|
300 |
} |
301 |
#elif ARCH_BFIN
|
302 |
static inline uint64_t read_time(void) |
303 |
{ |
304 |
union {
|
305 |
struct {
|
306 |
unsigned lo;
|
307 |
unsigned hi;
|
308 |
} p; |
309 |
unsigned long long c; |
310 |
} t; |
311 |
asm volatile ("%0=cycles; %1=cycles2;" : "=d" (t.p.lo), "=d" (t.p.hi)); |
312 |
return t.c;
|
313 |
} |
314 |
#else //FIXME check ppc64 |
315 |
static inline uint64_t read_time(void) |
316 |
{ |
317 |
uint32_t tbu, tbl, temp; |
318 |
|
319 |
/* from section 2.2.1 of the 32-bit PowerPC PEM */
|
320 |
__asm__ __volatile__( |
321 |
"1:\n"
|
322 |
"mftbu %2\n"
|
323 |
"mftb %0\n"
|
324 |
"mftbu %1\n"
|
325 |
"cmpw %2,%1\n"
|
326 |
"bne 1b\n"
|
327 |
: "=r"(tbl), "=r"(tbu), "=r"(temp) |
328 |
: |
329 |
: "cc");
|
330 |
|
331 |
return (((uint64_t)tbu)<<32) | (uint64_t)tbl; |
332 |
} |
333 |
#endif
|
334 |
#elif defined(HAVE_GETHRTIME)
|
335 |
#define AV_READ_TIME gethrtime
|
336 |
#endif
|
337 |
|
338 |
#ifdef AV_READ_TIME
|
339 |
#define START_TIMER \
|
340 |
uint64_t tend;\ |
341 |
uint64_t tstart= AV_READ_TIME();\ |
342 |
|
343 |
#define STOP_TIMER(id) \
|
344 |
tend= AV_READ_TIME();\ |
345 |
{\ |
346 |
static uint64_t tsum=0;\ |
347 |
static int tcount=0;\ |
348 |
static int tskip_count=0;\ |
349 |
if(tcount<2 || tend - tstart < FFMAX(8*tsum/tcount, 2000)){\ |
350 |
tsum+= tend - tstart;\ |
351 |
tcount++;\ |
352 |
}else\
|
353 |
tskip_count++;\ |
354 |
if(((tcount+tskip_count)&(tcount+tskip_count-1))==0){\ |
355 |
av_log(NULL, AV_LOG_DEBUG, "%"PRIu64" dezicycles in %s, %d runs, %d skips\n",\ |
356 |
tsum*10/tcount, id, tcount, tskip_count);\
|
357 |
}\ |
358 |
} |
359 |
#else
|
360 |
#define START_TIMER
|
361 |
#define STOP_TIMER(id) {}
|
362 |
#endif
|
363 |
|
364 |
#endif /* FFMPEG_COMMON_H */ |