remove impossible #ifdef case
[ffmpeg.git] / libavutil / common.h
1 /**
2  * @file common.h
3  * common internal api header.
4  */
5
6 #ifndef COMMON_H
7 #define COMMON_H
8
9 #ifndef M_PI
10 #define M_PI    3.14159265358979323846
11 #endif
12
13 #if ( defined(__PIC__) || defined(__pic__) ) && ! defined(PIC)
14 #    define PIC
15 #endif
16
17 #ifdef HAVE_AV_CONFIG_H
18 /* only include the following when compiling package */
19 #    include "config.h"
20
21 #    include <stdlib.h>
22 #    include <stdio.h>
23 #    include <string.h>
24 #    include <ctype.h>
25 #    include <limits.h>
26 #    ifndef __BEOS__
27 #        include <errno.h>
28 #    else
29 #        include "berrno.h"
30 #    endif
31 #    include <math.h>
32
33 #    ifndef ENODATA
34 #        define ENODATA  61
35 #    endif
36
37 #include <stddef.h>
38 #ifndef offsetof
39 # define offsetof(T,F) ((unsigned int)((char *)&((T *)0)->F))
40 #endif
41
42 #define AVOPTION_CODEC_BOOL(name, help, field) \
43     { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_BOOL }
44 #define AVOPTION_CODEC_DOUBLE(name, help, field, minv, maxv, defval) \
45     { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_DOUBLE, minv, maxv, defval }
46 #define AVOPTION_CODEC_FLAG(name, help, field, flag, defval) \
47     { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_FLAG, flag, 0, defval }
48 #define AVOPTION_CODEC_INT(name, help, field, minv, maxv, defval) \
49     { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_INT, minv, maxv, defval }
50 #define AVOPTION_CODEC_STRING(name, help, field, str, val) \
51     { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_STRING, .defval = val, .defstr = str }
52 #define AVOPTION_CODEC_RCOVERRIDE(name, help, field) \
53     { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_RCOVERRIDE, .defval = 0, .defstr = NULL }
54 #define AVOPTION_SUB(ptr) { .name = NULL, .help = (const char*)ptr }
55 #define AVOPTION_END() AVOPTION_SUB(NULL)
56
57 #endif /* HAVE_AV_CONFIG_H */
58
59 /* Suppress restrict if it was not defined in config.h.  */
60 #ifndef restrict
61 #    define restrict
62 #endif
63
64 #ifndef always_inline
65 #if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0)
66 #    define always_inline __attribute__((always_inline)) inline
67 #else
68 #    define always_inline inline
69 #endif
70 #endif
71
72 #ifndef attribute_used
73 #if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0)
74 #    define attribute_used __attribute__((used))
75 #else
76 #    define attribute_used
77 #endif
78 #endif
79
80 #ifndef attribute_unused
81 #if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0)
82 #    define attribute_unused __attribute__((unused))
83 #else
84 #    define attribute_unused
85 #endif
86 #endif
87
88 #ifndef EMULATE_INTTYPES
89 #   include <inttypes.h>
90 #else
91     typedef signed char  int8_t;
92     typedef signed short int16_t;
93     typedef signed int   int32_t;
94     typedef unsigned char  uint8_t;
95     typedef unsigned short uint16_t;
96     typedef unsigned int   uint32_t;
97     typedef signed long long   int64_t;
98     typedef unsigned long long uint64_t;
99 #endif /* EMULATE_INTTYPES */
100
101 #ifndef PRId64
102 #define PRId64 "lld"
103 #endif
104
105 #ifndef PRIu64
106 #define PRIu64 "llu"
107 #endif
108
109 #ifndef PRIx64
110 #define PRIx64 "llx"
111 #endif
112
113 #ifndef PRId32
114 #define PRId32 "d"
115 #endif
116
117 #ifndef PRIdFAST16
118 #define PRIdFAST16 PRId32
119 #endif
120
121 #ifndef PRIdFAST32
122 #define PRIdFAST32 PRId32
123 #endif
124
125 #ifndef INT16_MIN
126 #define INT16_MIN       (-0x7fff-1)
127 #endif
128
129 #ifndef INT16_MAX
130 #define INT16_MAX       0x7fff
131 #endif
132
133 #ifndef INT32_MIN
134 #define INT32_MIN       (-0x7fffffff-1)
135 #endif
136
137 #ifndef INT32_MAX
138 #define INT32_MAX       0x7fffffff
139 #endif
140
141 #ifndef UINT32_MAX
142 #define UINT32_MAX      0xffffffff
143 #endif
144
145 #ifndef INT64_MIN
146 #define INT64_MIN       (-0x7fffffffffffffffLL-1)
147 #endif
148
149 #ifndef INT64_MAX
150 #define INT64_MAX int64_t_C(9223372036854775807)
151 #endif
152
153 #ifndef UINT64_MAX
154 #define UINT64_MAX uint64_t_C(0xFFFFFFFFFFFFFFFF)
155 #endif
156
157 #ifdef EMULATE_FAST_INT
158 typedef signed char int_fast8_t;
159 typedef signed int  int_fast16_t;
160 typedef signed int  int_fast32_t;
161 typedef unsigned char uint_fast8_t;
162 typedef unsigned int  uint_fast16_t;
163 typedef unsigned int  uint_fast32_t;
164 typedef uint64_t      uint_fast64_t;
165 #endif
166
167 #ifndef INT_BIT
168 #    if INT_MAX != 2147483647
169 #        define INT_BIT 64
170 #    else
171 #        define INT_BIT 32
172 #    endif
173 #endif
174
175 #ifdef __MINGW32__
176
177 /* windows */
178
179 #    define int64_t_C(c)     (c ## LL)
180 #    define uint64_t_C(c)    (c ## ULL)
181
182 #    ifdef HAVE_AV_CONFIG_H
183 #        ifdef _DEBUG
184 #            define DEBUG
185 #        endif
186
187 #        define snprintf _snprintf
188 #        define vsnprintf _vsnprintf
189
190 #        ifdef CONFIG_WINCE
191 #            define perror(a)
192 #        endif
193
194 #    endif
195
196 /* __MINGW32__ end */
197 #elif defined (CONFIG_OS2)
198 /* OS/2 EMX */
199
200 #ifndef int64_t_C
201 #define int64_t_C(c)     (c ## LL)
202 #define uint64_t_C(c)    (c ## ULL)
203 #endif
204
205 #ifdef HAVE_AV_CONFIG_H
206
207 #ifdef USE_FASTMEMCPY
208 #include "fastmemcpy.h"
209 #endif
210
211 #include <float.h>
212
213 #endif /* HAVE_AV_CONFIG_H */
214
215 /* CONFIG_OS2 end */
216 #else
217
218 /* unix */
219
220 #ifndef int64_t_C
221 #define int64_t_C(c)     (c ## LL)
222 #define uint64_t_C(c)    (c ## ULL)
223 #endif
224
225 #ifdef HAVE_AV_CONFIG_H
226
227 #        ifdef USE_FASTMEMCPY
228 #            include "fastmemcpy.h"
229 #        endif
230 #    endif /* HAVE_AV_CONFIG_H */
231
232 #endif /* !__MINGW32__ && !CONFIG_OS2 */
233
234 #ifdef HAVE_AV_CONFIG_H
235
236 #if defined(__MINGW32__) && !defined(BUILD_AVUTIL) && defined(BUILD_SHARED_AV)
237 #  define FF_IMPORT_ATTR __declspec(dllimport)
238 #else
239 #  define FF_IMPORT_ATTR
240 #endif
241
242
243 #    include "bswap.h"
244
245 // Use rip-relative addressing if compiling PIC code on x86-64.
246 #    if defined(__MINGW32__) || defined(__CYGWIN__) || \
247         defined(__OS2__) || (defined (__OpenBSD__) && !defined(__ELF__))
248 #        if defined(ARCH_X86_64) && defined(PIC)
249 #            define MANGLE(a) "_" #a"(%%rip)"
250 #        else
251 #            define MANGLE(a) "_" #a
252 #        endif
253 #    else
254 #        if defined(ARCH_X86_64) && defined(PIC)
255 #            define MANGLE(a) #a"(%%rip)"
256 #        elif defined(CONFIG_DARWIN)
257 #            define MANGLE(a) "_" #a
258 #        else
259 #            define MANGLE(a) #a
260 #        endif
261 #    endif
262
263 /* debug stuff */
264
265 #    if !defined(DEBUG) && !defined(NDEBUG)
266 #        define NDEBUG
267 #    endif
268 #    include <assert.h>
269
270 /* dprintf macros */
271 #    ifdef DEBUG
272 #        define dprintf(fmt,...) av_log(NULL, AV_LOG_DEBUG, fmt, __VA_ARGS__)
273 #    else
274 #        define dprintf(fmt,...)
275 #    endif
276
277 #    ifdef CONFIG_WINCE
278 #            define abort()
279 #    endif
280
281 #    define av_abort()      do { av_log(NULL, AV_LOG_ERROR, "Abort at %s:%d\n", __FILE__, __LINE__); abort(); } while (0)
282
283 //rounded divison & shift
284 #define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b))
285 /* assume b>0 */
286 #define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))
287 #define ABS(a) ((a) >= 0 ? (a) : (-(a)))
288
289 #define FFMAX(a,b) ((a) > (b) ? (a) : (b))
290 #define FFMIN(a,b) ((a) > (b) ? (b) : (a))
291
292 extern const uint32_t inverse[256];
293
294 #if defined(ARCH_X86) || defined(ARCH_X86_64)
295 #    define FASTDIV(a,b) \
296     ({\
297         int ret,dmy;\
298         asm volatile(\
299             "mull %3"\
300             :"=d"(ret),"=a"(dmy)\
301             :"1"(a),"g"(inverse[b])\
302             );\
303         ret;\
304     })
305 #elif defined(CONFIG_FASTDIV)
306 #    define FASTDIV(a,b)   ((uint32_t)((((uint64_t)a)*inverse[b])>>32))
307 #else
308 #    define FASTDIV(a,b)   ((a)/(b))
309 #endif
310
311 /* misc math functions */
312 extern FF_IMPORT_ATTR const uint8_t ff_log2_tab[256];
313
314 static inline int av_log2(unsigned int v)
315 {
316     int n;
317
318     n = 0;
319     if (v & 0xffff0000) {
320         v >>= 16;
321         n += 16;
322     }
323     if (v & 0xff00) {
324         v >>= 8;
325         n += 8;
326     }
327     n += ff_log2_tab[v];
328
329     return n;
330 }
331
332 static inline int av_log2_16bit(unsigned int v)
333 {
334     int n;
335
336     n = 0;
337     if (v & 0xff00) {
338         v >>= 8;
339         n += 8;
340     }
341     n += ff_log2_tab[v];
342
343     return n;
344 }
345
346 /* median of 3 */
347 static inline int mid_pred(int a, int b, int c)
348 {
349 #if 0
350     int t= (a-b)&((a-b)>>31);
351     a-=t;
352     b+=t;
353     b-= (b-c)&((b-c)>>31);
354     b+= (a-b)&((a-b)>>31);
355
356     return b;
357 #else
358     if(a>b){
359         if(c>b){
360             if(c>a) b=a;
361             else    b=c;
362         }
363     }else{
364         if(b>c){
365             if(c>a) b=c;
366             else    b=a;
367         }
368     }
369     return b;
370 #endif
371 }
372
373 /**
374  * clip a signed integer value into the amin-amax range
375  * @param a value to clip
376  * @param amin minimum value of the clip range
377  * @param amax maximum value of the clip range
378  * @return cliped value
379  */
380 static inline int clip(int a, int amin, int amax)
381 {
382     if (a < amin)      return amin;
383     else if (a > amax) return amax;
384     else               return a;
385 }
386
387 /**
388  * clip a signed integer value into the 0-255 range
389  * @param a value to clip
390  * @return cliped value
391  */
392 static inline uint8_t clip_uint8(int a)
393 {
394     if (a&(~255)) return (-a)>>31;
395     else          return a;
396 }
397
398 /* math */
399 extern FF_IMPORT_ATTR const uint8_t ff_sqrt_tab[128];
400
401 int64_t ff_gcd(int64_t a, int64_t b);
402
403 static inline int ff_sqrt(int a)
404 {
405     int ret=0;
406     int s;
407     int ret_sq=0;
408
409     if(a<128) return ff_sqrt_tab[a];
410
411     for(s=15; s>=0; s--){
412         int b= ret_sq + (1<<(s*2)) + (ret<<s)*2;
413         if(b<=a){
414             ret_sq=b;
415             ret+= 1<<s;
416         }
417     }
418     return ret;
419 }
420
421 /**
422  * converts fourcc string to int
423  */
424 static inline int ff_get_fourcc(const char *s){
425     assert( strlen(s)==4 );
426
427     return (s[0]) + (s[1]<<8) + (s[2]<<16) + (s[3]<<24);
428 }
429
430 #define MKTAG(a,b,c,d) (a | (b << 8) | (c << 16) | (d << 24))
431 #define MKBETAG(a,b,c,d) (d | (c << 8) | (b << 16) | (a << 24))
432
433
434 #if defined(ARCH_X86) || defined(ARCH_X86_64)
435 #define MASK_ABS(mask, level)\
436             asm volatile(\
437                 "cdq                    \n\t"\
438                 "xorl %1, %0            \n\t"\
439                 "subl %1, %0            \n\t"\
440                 : "+a" (level), "=&d" (mask)\
441             );
442 #else
443 #define MASK_ABS(mask, level)\
444             mask= level>>31;\
445             level= (level^mask)-mask;
446 #endif
447
448 #define GET_UTF8(val, GET_BYTE, ERROR)\
449     val= GET_BYTE;\
450     {\
451         int ones= 7 - av_log2(val ^ 255);\
452         if(ones==1)\
453             ERROR\
454         val&= 127>>ones;\
455         while(--ones > 0){\
456             int tmp= GET_BYTE - 128;\
457             if(tmp>>6)\
458                 ERROR\
459             val= (val<<6) + tmp;\
460         }\
461     }
462
463 #if __CPU__ >= 686 && !defined(RUNTIME_CPUDETECT)
464 #define COPY3_IF_LT(x,y,a,b,c,d)\
465 asm volatile (\
466     "cmpl %0, %3        \n\t"\
467     "cmovl %3, %0       \n\t"\
468     "cmovl %4, %1       \n\t"\
469     "cmovl %5, %2       \n\t"\
470     : "+r" (x), "+r" (a), "+r" (c)\
471     : "r" (y), "r" (b), "r" (d)\
472 );
473 #else
474 #define COPY3_IF_LT(x,y,a,b,c,d)\
475 if((y)<(x)){\
476      (x)=(y);\
477      (a)=(b);\
478      (c)=(d);\
479 }
480 #endif
481
482 #if defined(ARCH_X86) || defined(ARCH_X86_64) || defined(ARCH_POWERPC)
483 #if defined(ARCH_X86_64)
484 static inline uint64_t read_time(void)
485 {
486         uint64_t a, d;
487         asm volatile(   "rdtsc\n\t"
488                 : "=a" (a), "=d" (d)
489         );
490         return (d << 32) | (a & 0xffffffff);
491 }
492 #elif defined(ARCH_X86)
493 static inline long long read_time(void)
494 {
495         long long l;
496         asm volatile(   "rdtsc\n\t"
497                 : "=A" (l)
498         );
499         return l;
500 }
501 #else //FIXME check ppc64
502 static inline uint64_t read_time(void)
503 {
504     uint32_t tbu, tbl, temp;
505
506      /* from section 2.2.1 of the 32-bit PowerPC PEM */
507      __asm__ __volatile__(
508          "1:\n"
509          "mftbu  %2\n"
510          "mftb   %0\n"
511          "mftbu  %1\n"
512          "cmpw   %2,%1\n"
513          "bne    1b\n"
514      : "=r"(tbl), "=r"(tbu), "=r"(temp)
515      :
516      : "cc");
517
518      return (((uint64_t)tbu)<<32) | (uint64_t)tbl;
519 }
520 #endif
521
522 #define START_TIMER \
523 uint64_t tend;\
524 uint64_t tstart= read_time();\
525
526 #define STOP_TIMER(id) \
527 tend= read_time();\
528 {\
529   static uint64_t tsum=0;\
530   static int tcount=0;\
531   static int tskip_count=0;\
532   if(tcount<2 || tend - tstart < 8*tsum/tcount){\
533       tsum+= tend - tstart;\
534       tcount++;\
535   }else\
536       tskip_count++;\
537   if(256*256*256*64%(tcount+tskip_count)==0){\
538       av_log(NULL, AV_LOG_DEBUG, "%"PRIu64" dezicycles in %s, %d runs, %d skips\n", tsum*10/tcount, id, tcount, tskip_count);\
539   }\
540 }
541 #else
542 #define START_TIMER
543 #define STOP_TIMER(id) {}
544 #endif
545
546 /* avoid usage of various functions */
547 #define malloc please_use_av_malloc
548 #define free please_use_av_free
549 #define realloc please_use_av_realloc
550 #define time time_is_forbidden_due_to_security_issues
551 #define rand rand_is_forbidden_due_to_state_trashing
552 #define srand srand_is_forbidden_due_to_state_trashing
553 #define sprintf sprintf_is_forbidden_due_to_security_issues_use_snprintf
554 #define strcat strcat_is_forbidden_due_to_security_issues_use_pstrcat
555 #if !(defined(LIBAVFORMAT_BUILD) || defined(_FRAMEHOOK_H))
556 #define printf please_use_av_log
557 #define fprintf please_use_av_log
558 #endif
559
560 #define CHECKED_ALLOCZ(p, size)\
561 {\
562     p= av_mallocz(size);\
563     if(p==NULL && (size)!=0){\
564         perror("malloc");\
565         goto fail;\
566     }\
567 }
568
569 #ifndef HAVE_LRINTF
570 /* XXX: add ISOC specific test to avoid specific BSD testing. */
571 /* better than nothing implementation. */
572 /* btw, rintf() is existing on fbsd too -- alex */
573 static always_inline long int lrintf(float x)
574 {
575 #ifdef __MINGW32__
576 #  ifdef ARCH_X86
577     int32_t i;
578     asm volatile(
579         "fistpl %0\n\t"
580         : "=m" (i) : "t" (x) : "st"
581     );
582     return i;
583 #  else
584     /* XXX: incorrect, but make it compile */
585     return (int)(x + (x < 0 ? -0.5 : 0.5));
586 #  endif /* ARCH_X86 */
587 #else
588     return (int)(rint(x));
589 #endif /* __MINGW32__ */
590 }
591 #endif /* HAVE_LRINTF */
592
593 #endif /* HAVE_AV_CONFIG_H */
594
595 #endif /* COMMON_H */