Statistics
| Branch: | Revision:

ffmpeg / libavutil / common.h @ 34d33769

History | View | Annotate | Download (10.3 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 COMMON_H
27
#define COMMON_H
28

    
29
#ifndef M_PI
30
#define M_PI    3.14159265358979323846
31
#endif
32

    
33
#ifdef HAVE_AV_CONFIG_H
34
/* only include the following when compiling package */
35
#    include "config.h"
36

    
37
#    include <stdlib.h>
38
#    include <stdio.h>
39
#    include <string.h>
40
#    include <ctype.h>
41
#    include <limits.h>
42
#    ifndef __BEOS__
43
#        include <errno.h>
44
#    else
45
#        include "berrno.h"
46
#    endif
47
#    include <math.h>
48
#endif /* HAVE_AV_CONFIG_H */
49

    
50
/* Suppress restrict if it was not defined in config.h.  */
51
#ifndef restrict
52
#    define restrict
53
#endif
54

    
55
#ifndef always_inline
56
#if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0)
57
#    define always_inline __attribute__((always_inline)) inline
58
#else
59
#    define always_inline inline
60
#endif
61
#endif
62

    
63
#ifndef attribute_used
64
#if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0)
65
#    define attribute_used __attribute__((used))
66
#else
67
#    define attribute_used
68
#endif
69
#endif
70

    
71
#ifndef attribute_unused
72
#if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0)
73
#    define attribute_unused __attribute__((unused))
74
#else
75
#    define attribute_unused
76
#endif
77
#endif
78

    
79
#ifndef attribute_deprecated
80
#if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0)
81
#    define attribute_deprecated __attribute__((deprecated))
82
#else
83
#    define attribute_deprecated
84
#endif
85
#endif
86

    
87
#ifndef EMULATE_INTTYPES
88
#   include <inttypes.h>
89
#else
90
    typedef signed char  int8_t;
91
    typedef signed short int16_t;
92
    typedef signed int   int32_t;
93
    typedef unsigned char  uint8_t;
94
    typedef unsigned short uint16_t;
95
    typedef unsigned int   uint32_t;
96
    typedef signed long long   int64_t;
97
    typedef unsigned long long uint64_t;
98
#endif /* EMULATE_INTTYPES */
99

    
100
#ifndef PRId64
101
#define PRId64 "lld"
102
#endif
103

    
104
#ifndef PRIu64
105
#define PRIu64 "llu"
106
#endif
107

    
108
#ifndef PRIx64
109
#define PRIx64 "llx"
110
#endif
111

    
112
#ifndef PRIX64
113
#define PRIX64 "llX"
114
#endif
115

    
116
#ifndef PRId32
117
#define PRId32 "d"
118
#endif
119

    
120
#ifndef PRIdFAST16
121
#define PRIdFAST16 PRId32
122
#endif
123

    
124
#ifndef PRIdFAST32
125
#define PRIdFAST32 PRId32
126
#endif
127

    
128
#ifndef INT16_MIN
129
#define INT16_MIN       (-0x7fff-1)
130
#endif
131

    
132
#ifndef INT16_MAX
133
#define INT16_MAX       0x7fff
134
#endif
135

    
136
#ifndef INT32_MIN
137
#define INT32_MIN       (-0x7fffffff-1)
138
#endif
139

    
140
#ifndef INT32_MAX
141
#define INT32_MAX       0x7fffffff
142
#endif
143

    
144
#ifndef UINT32_MAX
145
#define UINT32_MAX      0xffffffff
146
#endif
147

    
148
#ifndef INT64_MIN
149
#define INT64_MIN       (-0x7fffffffffffffffLL-1)
150
#endif
151

    
152
#ifndef INT64_MAX
153
#define INT64_MAX int64_t_C(9223372036854775807)
154
#endif
155

    
156
#ifndef UINT64_MAX
157
#define UINT64_MAX uint64_t_C(0xFFFFFFFFFFFFFFFF)
158
#endif
159

    
160
#ifdef EMULATE_FAST_INT
161
typedef signed char int_fast8_t;
162
typedef signed int  int_fast16_t;
163
typedef signed int  int_fast32_t;
164
typedef unsigned char uint_fast8_t;
165
typedef unsigned int  uint_fast16_t;
166
typedef unsigned int  uint_fast32_t;
167
typedef uint64_t      uint_fast64_t;
168
#endif
169

    
170
#ifndef INT_BIT
171
#    if INT_MAX != 2147483647
172
#        define INT_BIT 64
173
#    else
174
#        define INT_BIT 32
175
#    endif
176
#endif
177

    
178
#ifndef int64_t_C
179
#define int64_t_C(c)     (c ## LL)
180
#define uint64_t_C(c)    (c ## ULL)
181
#endif
182

    
183
#if defined(__MINGW32__) && !defined(BUILD_AVUTIL) && defined(BUILD_SHARED_AV)
184
#  define FF_IMPORT_ATTR __declspec(dllimport)
185
#else
186
#  define FF_IMPORT_ATTR
187
#endif
188

    
189

    
190
#ifdef HAVE_AV_CONFIG_H
191
/* only include the following when compiling package */
192
#    include "internal.h"
193
#endif
194

    
195
//rounded divison & shift
196
#define RSHIFT(a,b) ((a) > 0 ? ((a) + ((1<<(b))>>1))>>(b) : ((a) + ((1<<(b))>>1)-1)>>(b))
197
/* assume b>0 */
198
#define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))
199
#define FFABS(a) ((a) >= 0 ? (a) : (-(a)))
200
#define FFSIGN(a) ((a) > 0 ? 1 : -1)
201

    
202
#define FFMAX(a,b) ((a) > (b) ? (a) : (b))
203
#define FFMIN(a,b) ((a) > (b) ? (b) : (a))
204

    
205
#define FFSWAP(type,a,b) do{type SWAP_tmp= b; b= a; a= SWAP_tmp;}while(0)
206

    
207
/* misc math functions */
208
extern FF_IMPORT_ATTR const uint8_t ff_log2_tab[256];
209

    
210
static inline int av_log2(unsigned int v)
211
{
212
    int n;
213

    
214
    n = 0;
215
    if (v & 0xffff0000) {
216
        v >>= 16;
217
        n += 16;
218
    }
219
    if (v & 0xff00) {
220
        v >>= 8;
221
        n += 8;
222
    }
223
    n += ff_log2_tab[v];
224

    
225
    return n;
226
}
227

    
228
static inline int av_log2_16bit(unsigned int v)
229
{
230
    int n;
231

    
232
    n = 0;
233
    if (v & 0xff00) {
234
        v >>= 8;
235
        n += 8;
236
    }
237
    n += ff_log2_tab[v];
238

    
239
    return n;
240
}
241

    
242
/* median of 3 */
243
static inline int mid_pred(int a, int b, int c)
244
{
245
#if HAVE_CMOV
246
    int i=b;
247
    asm volatile(
248
        "cmp    %2, %1 \n\t"
249
        "cmovg  %1, %0 \n\t"
250
        "cmovg  %2, %1 \n\t"
251
        "cmp    %3, %1 \n\t"
252
        "cmovl  %3, %1 \n\t"
253
        "cmp    %1, %0 \n\t"
254
        "cmovg  %1, %0 \n\t"
255
        :"+&r"(i), "+&r"(a)
256
        :"r"(b), "r"(c)
257
    );
258
    return i;
259
#elif 0
260
    int t= (a-b)&((a-b)>>31);
261
    a-=t;
262
    b+=t;
263
    b-= (b-c)&((b-c)>>31);
264
    b+= (a-b)&((a-b)>>31);
265

    
266
    return b;
267
#else
268
    if(a>b){
269
        if(c>b){
270
            if(c>a) b=a;
271
            else    b=c;
272
        }
273
    }else{
274
        if(b>c){
275
            if(c>a) b=c;
276
            else    b=a;
277
        }
278
    }
279
    return b;
280
#endif
281
}
282

    
283
/**
284
 * clip a signed integer value into the amin-amax range
285
 * @param a value to clip
286
 * @param amin minimum value of the clip range
287
 * @param amax maximum value of the clip range
288
 * @return cliped value
289
 */
290
static inline int clip(int a, int amin, int amax)
291
{
292
    if (a < amin)      return amin;
293
    else if (a > amax) return amax;
294
    else               return a;
295
}
296

    
297
/**
298
 * clip a signed integer value into the 0-255 range
299
 * @param a value to clip
300
 * @return cliped value
301
 */
302
static inline uint8_t clip_uint8(int a)
303
{
304
    if (a&(~255)) return (-a)>>31;
305
    else          return a;
306
}
307

    
308
/* math */
309
int64_t ff_gcd(int64_t a, int64_t b);
310

    
311
/**
312
 * converts fourcc string to int
313
 */
314
static inline int ff_get_fourcc(const char *s){
315
#ifdef HAVE_AV_CONFIG_H
316
    assert( strlen(s)==4 );
317
#endif
318

    
319
    return (s[0]) + (s[1]<<8) + (s[2]<<16) + (s[3]<<24);
320
}
321

    
322
#define MKTAG(a,b,c,d) (a | (b << 8) | (c << 16) | (d << 24))
323
#define MKBETAG(a,b,c,d) (d | (c << 8) | (b << 16) | (a << 24))
324

    
325
#define GET_UTF8(val, GET_BYTE, ERROR)\
326
    val= GET_BYTE;\
327
    {\
328
        int ones= 7 - av_log2(val ^ 255);\
329
        if(ones==1)\
330
            ERROR\
331
        val&= 127>>ones;\
332
        while(--ones > 0){\
333
            int tmp= GET_BYTE - 128;\
334
            if(tmp>>6)\
335
                ERROR\
336
            val= (val<<6) + tmp;\
337
        }\
338
    }
339

    
340
/*!
341
 * \def PUT_UTF8(val, tmp, PUT_BYTE)
342
 * converts a 32-bit unicode character to its utf-8 encoded form (up to 6 bytes long).
343
 * \param val is an input only argument and should be of type uint32_t. It holds
344
 * a ucs4 encoded unicode character that is to be converted to utf-8. If
345
 * val is given as a function it's executed only once.
346
 * \param tmp is a temporary variable and should be of type uint8_t. It
347
 * represents an intermediate value during conversion that is to be
348
 * outputted by PUT_BYTE.
349
 * \param PUT_BYTE writes the converted utf-8 bytes to any proper destination.
350
 * It could be a function or a statement, and uses tmp as the input byte.
351
 * For example, PUT_BYTE could be "*output++ = tmp;" PUT_BYTE will be
352
 * executed up to 6 times, depending on the length of the converted
353
 * unicode character.
354
 */
355
#define PUT_UTF8(val, tmp, PUT_BYTE)\
356
    {\
357
        int bytes, shift;\
358
        uint32_t in = val;\
359
        if (in < 0x80) {\
360
            tmp = in;\
361
            PUT_BYTE\
362
        } else {\
363
            bytes = (av_log2(in) + 4) / 5;\
364
            shift = (bytes - 1) * 6;\
365
            tmp = (256 - (256 >> bytes)) | (in >> shift);\
366
            PUT_BYTE\
367
            while (shift >= 6) {\
368
                shift -= 6;\
369
                tmp = 0x80 | ((in >> shift) & 0x3f);\
370
                PUT_BYTE\
371
            }\
372
        }\
373
    }
374

    
375
#if defined(ARCH_X86) || defined(ARCH_POWERPC)
376
#if defined(ARCH_X86_64)
377
static inline uint64_t read_time(void)
378
{
379
        uint64_t a, d;
380
        asm volatile(   "rdtsc\n\t"
381
                : "=a" (a), "=d" (d)
382
        );
383
        return (d << 32) | (a & 0xffffffff);
384
}
385
#elif defined(ARCH_X86_32)
386
static inline long long read_time(void)
387
{
388
        long long l;
389
        asm volatile(   "rdtsc\n\t"
390
                : "=A" (l)
391
        );
392
        return l;
393
}
394
#else //FIXME check ppc64
395
static inline uint64_t read_time(void)
396
{
397
    uint32_t tbu, tbl, temp;
398

    
399
     /* from section 2.2.1 of the 32-bit PowerPC PEM */
400
     __asm__ __volatile__(
401
         "1:\n"
402
         "mftbu  %2\n"
403
         "mftb   %0\n"
404
         "mftbu  %1\n"
405
         "cmpw   %2,%1\n"
406
         "bne    1b\n"
407
     : "=r"(tbl), "=r"(tbu), "=r"(temp)
408
     :
409
     : "cc");
410

    
411
     return (((uint64_t)tbu)<<32) | (uint64_t)tbl;
412
}
413
#endif
414

    
415
#define START_TIMER \
416
uint64_t tend;\
417
uint64_t tstart= read_time();\
418

    
419
#define STOP_TIMER(id) \
420
tend= read_time();\
421
{\
422
  static uint64_t tsum=0;\
423
  static int tcount=0;\
424
  static int tskip_count=0;\
425
  if(tcount<2 || tend - tstart < 8*tsum/tcount){\
426
      tsum+= tend - tstart;\
427
      tcount++;\
428
  }else\
429
      tskip_count++;\
430
  if(((tcount+tskip_count)&(tcount+tskip_count-1))==0){\
431
      av_log(NULL, AV_LOG_DEBUG, "%"PRIu64" dezicycles in %s, %d runs, %d skips\n", tsum*10/tcount, id, tcount, tskip_count);\
432
  }\
433
}
434
#else
435
#define START_TIMER
436
#define STOP_TIMER(id) {}
437
#endif
438

    
439
/* memory */
440

    
441
#ifdef __GNUC__
442
  #define DECLARE_ALIGNED(n,t,v)       t v __attribute__ ((aligned (n)))
443
#else
444
  #define DECLARE_ALIGNED(n,t,v)      __declspec(align(n)) t v
445
#endif
446

    
447
/* memory */
448
void *av_malloc(unsigned int size);
449
void *av_realloc(void *ptr, unsigned int size);
450
void av_free(void *ptr);
451

    
452
void *av_mallocz(unsigned int size);
453
char *av_strdup(const char *s);
454
void av_freep(void *ptr);
455

    
456
#endif /* COMMON_H */