Statistics
| Branch: | Revision:

ffmpeg / libavcodec / common.h @ 983e3246

History | View | Annotate | Download (22.3 KB)

1
/**
2
 * @file common.h
3
 * common internal api header.
4
 */
5

    
6
#ifndef COMMON_H
7
#define COMMON_H
8

    
9
#define FFMPEG_VERSION_INT 0x000406
10
#define FFMPEG_VERSION     "0.4.6"
11

    
12
#if defined(WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
13
#    define CONFIG_WIN32
14
#endif
15

    
16
//#define ALT_BITSTREAM_WRITER
17
//#define ALIGNED_BITSTREAM_WRITER
18

    
19
#define ALT_BITSTREAM_READER
20
//#define LIBMPEG2_BITSTREAM_READER
21
//#define A32_BITSTREAM_READER
22

    
23
#ifdef HAVE_AV_CONFIG_H
24
/* only include the following when compiling package */
25
#    include "config.h"
26

    
27
#    include <stdlib.h>
28
#    include <stdio.h>
29
#    include <string.h>
30
#    ifndef __BEOS__
31
#        include <errno.h>
32
#    else
33
#        include "berrno.h"
34
#    endif
35
#    include <math.h>
36

    
37
#    ifndef ENODATA
38
#        define ENODATA  61
39
#    endif
40

    
41
#ifndef M_PI
42
#define M_PI    3.14159265358979323846
43
#endif
44

    
45
#include <stddef.h>
46
#ifndef offsetof
47
# define offsetof(T,F) ((unsigned int)((char *)&((T *)0)->F))
48
#endif
49

    
50
#define AVOPTION_CODEC_BOOL(name, help, field) \
51
    { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_BOOL }
52
#define AVOPTION_CODEC_FLAG(name, help, field, flag, defval) \
53
    { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_FLAG, flag, 0, defval }
54
#define AVOPTION_CODEC_INT(name, help, field, minv, maxv, defval) \
55
    { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_INT, minv, maxv, defval }
56
#define AVOPTION_CODEC_STRING(name, help, field, str, val) \
57
    { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_STRING, .defval = val, .defstr = str }
58
#define AVOPTION_CODEC_RCOVERRIDE(name, help, field) \
59
    { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_RCOVERRIDE, .defval = 0, .defstr = NULL }
60
#define AVOPTION_SUB(ptr) { .name = NULL, .sub = ptr }
61
#define AVOPTION_END() AVOPTION_SUB(NULL)
62

    
63
#endif /* HAVE_AV_CONFIG_H */
64

    
65
/* Suppress restrict if it was not defined in config.h.  */
66
#ifndef restrict
67
#    define restrict
68
#endif
69

    
70
#if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0)
71
#    define always_inline __attribute__((always_inline)) inline
72
#else
73
#    define always_inline inline
74
#endif
75

    
76
#ifdef CONFIG_WIN32
77

    
78
/* windows */
79

    
80
typedef unsigned short uint16_t;
81
typedef signed short int16_t;
82
typedef unsigned char uint8_t;
83
typedef unsigned int uint32_t;
84
typedef unsigned __int64 uint64_t;
85
typedef signed char int8_t;
86
typedef signed int int32_t;
87
typedef signed __int64 int64_t;
88

    
89
#    ifndef __MINGW32__
90
#        define int64_t_C(c)     (c ## i64)
91
#        define uint64_t_C(c)    (c ## i64)
92

    
93
#        define inline __inline
94

    
95
#    else
96
#        define int64_t_C(c)     (c ## LL)
97
#        define uint64_t_C(c)    (c ## ULL)
98
#    endif /* __MINGW32__ */
99

    
100
#    ifdef _DEBUG
101
#        define DEBUG
102
#    endif
103

    
104
#    define snprintf _snprintf
105
#    define vsnprintf _vsnprintf
106

    
107
/* CONFIG_WIN32 end */
108
#elif defined (CONFIG_OS2)
109
/* OS/2 EMX */
110

    
111
#include <inttypes.h>
112

    
113
#ifdef HAVE_AV_CONFIG_H
114

    
115
#ifndef int64_t_C
116
#define int64_t_C(c)     (c ## LL)
117
#define uint64_t_C(c)    (c ## ULL)
118
#endif
119

    
120
#ifdef USE_FASTMEMCPY
121
#include "fastmemcpy.h"
122
#endif
123

    
124
#include <float.h>
125

    
126
#endif /* HAVE_AV_CONFIG_H */
127

    
128
/* CONFIG_OS2 end */
129
#else
130

    
131
/* unix */
132

    
133
#    include <inttypes.h>
134

    
135
#    ifdef HAVE_AV_CONFIG_H
136
#        ifndef int64_t_C
137
#            define int64_t_C(c)     (c ## LL)
138
#            define uint64_t_C(c)    (c ## ULL)
139
#        endif
140

    
141
#        ifdef USE_FASTMEMCPY
142
#            include "fastmemcpy.h"
143
#        endif
144
#    endif /* HAVE_AV_CONFIG_H */
145

    
146
#endif /* !CONFIG_WIN32 && !CONFIG_OS2 */
147

    
148
#ifdef HAVE_AV_CONFIG_H
149

    
150
#    include "bswap.h"
151

    
152
#    if defined(__MINGW32__) || defined(__CYGWIN__) || \
153
        defined(__OS2__) || defined (__OpenBSD__)
154
#        define MANGLE(a) "_" #a
155
#    else
156
#        define MANGLE(a) #a
157
#    endif
158

    
159
/* debug stuff */
160

    
161
#    ifndef DEBUG
162
#        define NDEBUG
163
#    endif
164
#    include <assert.h>
165

    
166
/* dprintf macros */
167
#    if defined(CONFIG_WIN32) && !defined(__MINGW32__)
168

    
169
inline void dprintf(const char* fmt,...) {}
170

    
171
#    else
172

    
173
#        ifdef DEBUG
174
#            define dprintf(fmt,args...) printf(fmt, ## args)
175
#        else
176
#            define dprintf(fmt,args...)
177
#        endif
178

    
179
#    endif /* !CONFIG_WIN32 */
180

    
181
#    define av_abort()      do { fprintf(stderr, "Abort at %s:%d\n", __FILE__, __LINE__); abort(); } while (0)
182

    
183
//rounded divison & shift
184
#define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b))
185
/* assume b>0 */
186
#define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))
187
#define ABS(a) ((a) >= 0 ? (a) : (-(a)))
188

    
189
#define FFMAX(a,b) ((a) > (b) ? (a) : (b))
190
#define FFMIN(a,b) ((a) > (b) ? (b) : (a))
191

    
192
#ifdef ARCH_X86
193
// avoid +32 for shift optimization (gcc should do that ...)
194
static inline  int32_t NEG_SSR32( int32_t a, int8_t s){
195
    asm ("sarl %1, %0\n\t"
196
         : "+r" (a)
197
         : "ic" ((uint8_t)(-s))
198
    );
199
    return a;
200
}
201
static inline uint32_t NEG_USR32(uint32_t a, int8_t s){
202
    asm ("shrl %1, %0\n\t"
203
         : "+r" (a)
204
         : "ic" ((uint8_t)(-s))
205
    );
206
    return a;
207
}
208
#else
209
#    define NEG_SSR32(a,s) ((( int32_t)(a))>>(32-(s)))
210
#    define NEG_USR32(a,s) (((uint32_t)(a))>>(32-(s)))
211
#endif
212

    
213
/* bit output */
214

    
215
struct PutBitContext;
216

    
217
typedef void (*WriteDataFunc)(void *, uint8_t *, int);
218

    
219
typedef struct PutBitContext {
220
#ifdef ALT_BITSTREAM_WRITER
221
    uint8_t *buf, *buf_end;
222
    int index;
223
#else
224
    uint32_t bit_buf;
225
    int bit_left;
226
    uint8_t *buf, *buf_ptr, *buf_end;
227
#endif
228
    int64_t data_out_size; /* in bytes */
229
} PutBitContext;
230

    
231
void init_put_bits(PutBitContext *s, 
232
                   uint8_t *buffer, int buffer_size,
233
                   void *opaque,
234
                   void (*write_data)(void *, uint8_t *, int));
235

    
236
int64_t get_bit_count(PutBitContext *s); /* XXX: change function name */
237
void align_put_bits(PutBitContext *s);
238
void flush_put_bits(PutBitContext *s);
239
void put_string(PutBitContext * pbc, char *s);
240

    
241
/* bit input */
242

    
243
typedef struct GetBitContext {
244
    const uint8_t *buffer, *buffer_end;
245
#ifdef ALT_BITSTREAM_READER
246
    int index;
247
#elif defined LIBMPEG2_BITSTREAM_READER
248
    uint8_t *buffer_ptr;
249
    uint32_t cache;
250
    int bit_count;
251
#elif defined A32_BITSTREAM_READER
252
    uint32_t *buffer_ptr;
253
    uint32_t cache0;
254
    uint32_t cache1;
255
    int bit_count;
256
#endif
257
    int size_in_bits;
258
} GetBitContext;
259

    
260
static inline int get_bits_count(GetBitContext *s);
261

    
262
#define VLC_TYPE int16_t
263

    
264
typedef struct VLC {
265
    int bits;
266
    VLC_TYPE (*table)[2]; // code, bits
267
    int table_size, table_allocated;
268
} VLC;
269

    
270
typedef struct RL_VLC_ELEM {
271
    int16_t level;
272
    int8_t len;
273
    uint8_t run;
274
} RL_VLC_ELEM;
275

    
276
#ifdef ARCH_SPARC64
277
#define UNALIGNED_STORES_ARE_BAD
278
#endif
279

    
280
/* used to avoid missaligned exceptions on some archs (alpha, ...) */
281
#ifdef ARCH_X86
282
#    define unaligned32(a) (*(uint32_t*)(a))
283
#else
284
#    ifdef __GNUC__
285
static inline uint32_t unaligned32(const void *v) {
286
    struct Unaligned {
287
        uint32_t i;
288
    } __attribute__((packed));
289

    
290
    return ((const struct Unaligned *) v)->i;
291
}
292
#    elif defined(__DECC)
293
static inline uint32_t unaligned32(const void *v) {
294
    return *(const __unaligned uint32_t *) v;
295
}
296
#    else
297
static inline uint32_t unaligned32(const void *v) {
298
    return *(const uint32_t *) v;
299
}
300
#    endif
301
#endif //!ARCH_X86
302

    
303
#ifndef ALT_BITSTREAM_WRITER
304
static inline void put_bits(PutBitContext *s, int n, unsigned int value)
305
{
306
    unsigned int bit_buf;
307
    int bit_left;
308

    
309
#ifdef STATS
310
    st_out_bit_counts[st_current_index] += n;
311
#endif
312
    //    printf("put_bits=%d %x\n", n, value);
313
    assert(n == 32 || value < (1U << n));
314
    
315
    bit_buf = s->bit_buf;
316
    bit_left = s->bit_left;
317

    
318
    //    printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf);
319
    /* XXX: optimize */
320
    if (n < bit_left) {
321
        bit_buf = (bit_buf<<n) | value;
322
        bit_left-=n;
323
    } else {
324
        bit_buf<<=bit_left;
325
        bit_buf |= value >> (n - bit_left);
326
#ifdef UNALIGNED_STORES_ARE_BAD
327
        if (3 & (int) s->buf_ptr) {
328
            s->buf_ptr[0] = bit_buf >> 24;
329
            s->buf_ptr[1] = bit_buf >> 16;
330
            s->buf_ptr[2] = bit_buf >>  8;
331
            s->buf_ptr[3] = bit_buf      ;
332
        } else
333
#endif
334
        *(uint32_t *)s->buf_ptr = be2me_32(bit_buf);
335
        //printf("bitbuf = %08x\n", bit_buf);
336
        s->buf_ptr+=4;
337
        bit_left+=32 - n;
338
        bit_buf = value;
339
    }
340

    
341
    s->bit_buf = bit_buf;
342
    s->bit_left = bit_left;
343
}
344
#endif
345

    
346

    
347
#ifdef ALT_BITSTREAM_WRITER
348
static inline void put_bits(PutBitContext *s, int n, unsigned int value)
349
{
350
#    ifdef ALIGNED_BITSTREAM_WRITER
351
#        ifdef ARCH_X86
352
    asm volatile(
353
        "movl %0, %%ecx                        \n\t"
354
        "xorl %%eax, %%eax                \n\t"
355
        "shrdl %%cl, %1, %%eax                \n\t"
356
        "shrl %%cl, %1                        \n\t"
357
        "movl %0, %%ecx                        \n\t"
358
        "shrl $3, %%ecx                        \n\t"
359
        "andl $0xFFFFFFFC, %%ecx        \n\t"
360
        "bswapl %1                        \n\t"
361
        "orl %1, (%2, %%ecx)                \n\t"
362
        "bswapl %%eax                        \n\t"
363
        "addl %3, %0                        \n\t"
364
        "movl %%eax, 4(%2, %%ecx)        \n\t"
365
        : "=&r" (s->index), "=&r" (value)
366
        : "r" (s->buf), "r" (n), "0" (s->index), "1" (value<<(-n))
367
        : "%eax", "%ecx"
368
    );
369
#        else
370
    int index= s->index;
371
    uint32_t *ptr= ((uint32_t *)s->buf)+(index>>5);
372
    
373
    value<<= 32-n; 
374
    
375
    ptr[0] |= be2me_32(value>>(index&31));
376
    ptr[1]  = be2me_32(value<<(32-(index&31)));
377
//if(n>24) printf("%d %d\n", n, value);
378
    index+= n;
379
    s->index= index;
380
#        endif
381
#    else //ALIGNED_BITSTREAM_WRITER
382
#        ifdef ARCH_X86
383
    asm volatile(
384
        "movl $7, %%ecx                        \n\t"
385
        "andl %0, %%ecx                        \n\t"
386
        "addl %3, %%ecx                        \n\t"
387
        "negl %%ecx                        \n\t"
388
        "shll %%cl, %1                        \n\t"
389
        "bswapl %1                        \n\t"
390
        "movl %0, %%ecx                        \n\t"
391
        "shrl $3, %%ecx                        \n\t"
392
        "orl %1, (%%ecx, %2)                \n\t"
393
        "addl %3, %0                        \n\t"
394
        "movl $0, 4(%%ecx, %2)                \n\t"
395
        : "=&r" (s->index), "=&r" (value)
396
        : "r" (s->buf), "r" (n), "0" (s->index), "1" (value)
397
        : "%ecx"
398
    );
399
#        else
400
    int index= s->index;
401
    uint32_t *ptr= (uint32_t*)(((uint8_t *)s->buf)+(index>>3));
402
    
403
    ptr[0] |= be2me_32(value<<(32-n-(index&7) ));
404
    ptr[1] = 0;
405
//if(n>24) printf("%d %d\n", n, value);
406
    index+= n;
407
    s->index= index;
408
#        endif
409
#    endif //!ALIGNED_BITSTREAM_WRITER
410
}
411
#endif
412

    
413

    
414
static inline uint8_t* pbBufPtr(PutBitContext *s)
415
{
416
#ifdef ALT_BITSTREAM_WRITER
417
        return s->buf + (s->index>>3);
418
#else
419
        return s->buf_ptr;
420
#endif
421
}
422

    
423
/* Bitstream reader API docs:
424
name
425
    abritary name which is used as prefix for the internal variables
426

427
gb
428
    getbitcontext
429

430
OPEN_READER(name, gb)
431
    loads gb into local variables
432

433
CLOSE_READER(name, gb)
434
    stores local vars in gb
435

436
UPDATE_CACHE(name, gb)
437
    refills the internal cache from the bitstream
438
    after this call at least MIN_CACHE_BITS will be available,
439

440
GET_CACHE(name, gb)
441
    will output the contents of the internal cache, next bit is MSB of 32 or 64 bit (FIXME 64bit)
442

443
SHOW_UBITS(name, gb, num)
444
    will return the nest num bits
445

446
SHOW_SBITS(name, gb, num)
447
    will return the nest num bits and do sign extension
448

449
SKIP_BITS(name, gb, num)
450
    will skip over the next num bits
451
    note, this is equinvalent to SKIP_CACHE; SKIP_COUNTER
452

453
SKIP_CACHE(name, gb, num)
454
    will remove the next num bits from the cache (note SKIP_COUNTER MUST be called before UPDATE_CACHE / CLOSE_READER)
455

456
SKIP_COUNTER(name, gb, num)
457
    will increment the internal bit counter (see SKIP_CACHE & SKIP_BITS)
458

459
LAST_SKIP_CACHE(name, gb, num)
460
    will remove the next num bits from the cache if it is needed for UPDATE_CACHE otherwise it will do nothing
461

462
LAST_SKIP_BITS(name, gb, num)
463
    is equinvalent to SKIP_LAST_CACHE; SKIP_COUNTER
464

465
for examples see get_bits, show_bits, skip_bits, get_vlc
466
*/
467

    
468
#ifdef ALT_BITSTREAM_READER
469
#   define MIN_CACHE_BITS 25
470

    
471
#   define OPEN_READER(name, gb)\
472
        int name##_index= (gb)->index;\
473
        int name##_cache= 0;\
474

    
475
#   define CLOSE_READER(name, gb)\
476
        (gb)->index= name##_index;\
477

    
478
#   define UPDATE_CACHE(name, gb)\
479
        name##_cache= be2me_32( unaligned32( ((uint8_t *)(gb)->buffer)+(name##_index>>3) ) ) << (name##_index&0x07);\
480

    
481
#   define SKIP_CACHE(name, gb, num)\
482
        name##_cache <<= (num);\
483

    
484
// FIXME name?
485
#   define SKIP_COUNTER(name, gb, num)\
486
        name##_index += (num);\
487

    
488
#   define SKIP_BITS(name, gb, num)\
489
        {\
490
            SKIP_CACHE(name, gb, num)\
491
            SKIP_COUNTER(name, gb, num)\
492
        }\
493

    
494
#   define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num)
495
#   define LAST_SKIP_CACHE(name, gb, num) ;
496

    
497
#   define SHOW_UBITS(name, gb, num)\
498
        NEG_USR32(name##_cache, num)
499

    
500
#   define SHOW_SBITS(name, gb, num)\
501
        NEG_SSR32(name##_cache, num)
502

    
503
#   define GET_CACHE(name, gb)\
504
        ((uint32_t)name##_cache)
505

    
506
static inline int get_bits_count(GetBitContext *s){
507
    return s->index;
508
}
509
#elif defined LIBMPEG2_BITSTREAM_READER
510
//libmpeg2 like reader
511

    
512
#   define MIN_CACHE_BITS 16
513

    
514
#   define OPEN_READER(name, gb)\
515
        int name##_bit_count=(gb)->bit_count;\
516
        int name##_cache= (gb)->cache;\
517
        uint8_t * name##_buffer_ptr=(gb)->buffer_ptr;\
518

    
519
#   define CLOSE_READER(name, gb)\
520
        (gb)->bit_count= name##_bit_count;\
521
        (gb)->cache= name##_cache;\
522
        (gb)->buffer_ptr= name##_buffer_ptr;\
523

    
524
#   define UPDATE_CACHE(name, gb)\
525
    if(name##_bit_count > 0){\
526
        name##_cache+= ((name##_buffer_ptr[0]<<8) + name##_buffer_ptr[1]) << name##_bit_count;\
527
        name##_buffer_ptr+=2;\
528
        name##_bit_count-= 16;\
529
    }\
530

    
531
#   define SKIP_CACHE(name, gb, num)\
532
        name##_cache <<= (num);\
533

    
534
#   define SKIP_COUNTER(name, gb, num)\
535
        name##_bit_count += (num);\
536

    
537
#   define SKIP_BITS(name, gb, num)\
538
        {\
539
            SKIP_CACHE(name, gb, num)\
540
            SKIP_COUNTER(name, gb, num)\
541
        }\
542

    
543
#   define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num)
544
#   define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num)
545

    
546
#   define SHOW_UBITS(name, gb, num)\
547
        NEG_USR32(name##_cache, num)
548

    
549
#   define SHOW_SBITS(name, gb, num)\
550
        NEG_SSR32(name##_cache, num)
551

    
552
#   define GET_CACHE(name, gb)\
553
        ((uint32_t)name##_cache)
554

    
555
static inline int get_bits_count(GetBitContext *s){
556
    return (s->buffer_ptr - s->buffer)*8 - 16 + s->bit_count;
557
}
558

    
559
#elif defined A32_BITSTREAM_READER
560

    
561
#   define MIN_CACHE_BITS 32
562

    
563
#   define OPEN_READER(name, gb)\
564
        int name##_bit_count=(gb)->bit_count;\
565
        uint32_t name##_cache0= (gb)->cache0;\
566
        uint32_t name##_cache1= (gb)->cache1;\
567
        uint32_t * name##_buffer_ptr=(gb)->buffer_ptr;\
568

    
569
#   define CLOSE_READER(name, gb)\
570
        (gb)->bit_count= name##_bit_count;\
571
        (gb)->cache0= name##_cache0;\
572
        (gb)->cache1= name##_cache1;\
573
        (gb)->buffer_ptr= name##_buffer_ptr;\
574

    
575
#   define UPDATE_CACHE(name, gb)\
576
    if(name##_bit_count > 0){\
577
        const uint32_t next= be2me_32( *name##_buffer_ptr );\
578
        name##_cache0 |= NEG_USR32(next,name##_bit_count);\
579
        name##_cache1 |= next<<name##_bit_count;\
580
        name##_buffer_ptr++;\
581
        name##_bit_count-= 32;\
582
    }\
583

    
584
#ifdef ARCH_X86
585
#   define SKIP_CACHE(name, gb, num)\
586
        asm(\
587
            "shldl %2, %1, %0                \n\t"\
588
            "shll %2, %1                \n\t"\
589
            : "+r" (name##_cache0), "+r" (name##_cache1)\
590
            : "Ic" ((uint8_t)num)\
591
           );
592
#else
593
#   define SKIP_CACHE(name, gb, num)\
594
        name##_cache0 <<= (num);\
595
        name##_cache0 |= NEG_USR32(name##_cache1,num);\
596
        name##_cache1 <<= (num);
597
#endif
598

    
599
#   define SKIP_COUNTER(name, gb, num)\
600
        name##_bit_count += (num);\
601

    
602
#   define SKIP_BITS(name, gb, num)\
603
        {\
604
            SKIP_CACHE(name, gb, num)\
605
            SKIP_COUNTER(name, gb, num)\
606
        }\
607

    
608
#   define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num)
609
#   define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num)
610

    
611
#   define SHOW_UBITS(name, gb, num)\
612
        NEG_USR32(name##_cache0, num)
613

    
614
#   define SHOW_SBITS(name, gb, num)\
615
        NEG_SSR32(name##_cache0, num)
616

    
617
#   define GET_CACHE(name, gb)\
618
        (name##_cache0)
619

    
620
static inline int get_bits_count(GetBitContext *s){
621
    return ((uint8_t*)s->buffer_ptr - s->buffer)*8 - 32 + s->bit_count;
622
}
623

    
624
#endif
625

    
626
static inline unsigned int get_bits(GetBitContext *s, int n){
627
    register int tmp;
628
    OPEN_READER(re, s)
629
    UPDATE_CACHE(re, s)
630
    tmp= SHOW_UBITS(re, s, n);
631
    LAST_SKIP_BITS(re, s, n)
632
    CLOSE_READER(re, s)
633
    return tmp;
634
}
635

    
636
static inline unsigned int show_bits(GetBitContext *s, int n){
637
    register int tmp;
638
    OPEN_READER(re, s)
639
    UPDATE_CACHE(re, s)
640
    tmp= SHOW_UBITS(re, s, n);
641
//    CLOSE_READER(re, s)
642
    return tmp;
643
}
644

    
645
static inline void skip_bits(GetBitContext *s, int n){
646
 //Note gcc seems to optimize this to s->index+=n for the ALT_READER :))
647
    OPEN_READER(re, s)
648
    UPDATE_CACHE(re, s)
649
    LAST_SKIP_BITS(re, s, n)
650
    CLOSE_READER(re, s)
651
}
652

    
653
static inline unsigned int get_bits1(GetBitContext *s){
654
#ifdef ALT_BITSTREAM_READER
655
    int index= s->index;
656
    uint8_t result= s->buffer[ index>>3 ];
657
    result<<= (index&0x07);
658
    result>>= 8 - 1;
659
    index++;
660
    s->index= index;
661

    
662
    return result;
663
#else
664
    return get_bits(s, 1);
665
#endif
666
}
667

    
668
static inline unsigned int show_bits1(GetBitContext *s){
669
    return show_bits(s, 1);
670
}
671

    
672
static inline void skip_bits1(GetBitContext *s){
673
    skip_bits(s, 1);
674
}
675

    
676
void init_get_bits(GetBitContext *s,
677
                   const uint8_t *buffer, int buffer_size);
678

    
679
int check_marker(GetBitContext *s, const char *msg);
680
void align_get_bits(GetBitContext *s);
681
int init_vlc(VLC *vlc, int nb_bits, int nb_codes,
682
             const void *bits, int bits_wrap, int bits_size,
683
             const void *codes, int codes_wrap, int codes_size);
684
void free_vlc(VLC *vlc);
685

    
686
/**
687
 *
688
 * if the vlc code is invalid and max_depth=1 than no bits will be removed
689
 * if the vlc code is invalid and max_depth>1 than the number of bits removed
690
 * is undefined
691
 */
692
#define GET_VLC(code, name, gb, table, bits, max_depth)\
693
{\
694
    int n, index, nb_bits;\
695
\
696
    index= SHOW_UBITS(name, gb, bits);\
697
    code = table[index][0];\
698
    n    = table[index][1];\
699
\
700
    if(max_depth > 1 && n < 0){\
701
        LAST_SKIP_BITS(name, gb, bits)\
702
        UPDATE_CACHE(name, gb)\
703
\
704
        nb_bits = -n;\
705
\
706
        index= SHOW_UBITS(name, gb, nb_bits) + code;\
707
        code = table[index][0];\
708
        n    = table[index][1];\
709
        if(max_depth > 2 && n < 0){\
710
            LAST_SKIP_BITS(name, gb, nb_bits)\
711
            UPDATE_CACHE(name, gb)\
712
\
713
            nb_bits = -n;\
714
\
715
            index= SHOW_UBITS(name, gb, nb_bits) + code;\
716
            code = table[index][0];\
717
            n    = table[index][1];\
718
        }\
719
    }\
720
    SKIP_BITS(name, gb, n)\
721
}
722

    
723
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth)\
724
{\
725
    int n, index, nb_bits;\
726
\
727
    index= SHOW_UBITS(name, gb, bits);\
728
    level = table[index].level;\
729
    n     = table[index].len;\
730
\
731
    if(max_depth > 1 && n < 0){\
732
        LAST_SKIP_BITS(name, gb, bits)\
733
        UPDATE_CACHE(name, gb)\
734
\
735
        nb_bits = -n;\
736
\
737
        index= SHOW_UBITS(name, gb, nb_bits) + level;\
738
        level = table[index].level;\
739
        n     = table[index].len;\
740
    }\
741
    run= table[index].run;\
742
    SKIP_BITS(name, gb, n)\
743
}
744

    
745
// deprecated, dont use get_vlc for new code, use get_vlc2 instead or use GET_VLC directly
746
static inline int get_vlc(GetBitContext *s, VLC *vlc)
747
{
748
    int code;
749
    VLC_TYPE (*table)[2]= vlc->table;
750
    
751
    OPEN_READER(re, s)
752
    UPDATE_CACHE(re, s)
753

    
754
    GET_VLC(code, re, s, table, vlc->bits, 3)    
755

    
756
    CLOSE_READER(re, s)
757
    return code;
758
}
759

    
760
/**
761
 * parses a vlc code, faster then get_vlc()
762
 * @param bits is the number of bits which will be read at once, must be 
763
 *             identical to nb_bits in init_vlc()
764
 * @param max_depth is the number of times bits bits must be readed to completly
765
 *                  read the longest vlc code 
766
 *                  = (max_vlc_length + bits - 1) / bits
767
 */
768
static always_inline int get_vlc2(GetBitContext *s, VLC_TYPE (*table)[2],
769
                                  int bits, int max_depth)
770
{
771
    int code;
772
    
773
    OPEN_READER(re, s)
774
    UPDATE_CACHE(re, s)
775

    
776
    GET_VLC(code, re, s, table, bits, max_depth)
777

    
778
    CLOSE_READER(re, s)
779
    return code;
780
}
781

    
782

    
783
/* define it to include statistics code (useful only for optimizing
784
   codec efficiency */
785
//#define STATS
786

    
787
#ifdef STATS
788

    
789
enum {
790
    ST_UNKNOWN,
791
    ST_DC,
792
    ST_INTRA_AC,
793
    ST_INTER_AC,
794
    ST_INTRA_MB,
795
    ST_INTER_MB,
796
    ST_MV,
797
    ST_NB,
798
};
799

    
800
extern int st_current_index;
801
extern unsigned int st_bit_counts[ST_NB];
802
extern unsigned int st_out_bit_counts[ST_NB];
803

    
804
void print_stats(void);
805
#endif
806

    
807
/* misc math functions */
808
extern const uint8_t ff_log2_tab[256];
809

    
810
static inline int av_log2(unsigned int v)
811
{
812
    int n;
813

    
814
    n = 0;
815
    if (v & 0xffff0000) {
816
        v >>= 16;
817
        n += 16;
818
    }
819
    if (v & 0xff00) {
820
        v >>= 8;
821
        n += 8;
822
    }
823
    n += ff_log2_tab[v];
824

    
825
    return n;
826
}
827

    
828
static inline int av_log2_16bit(unsigned int v)
829
{
830
    int n;
831

    
832
    n = 0;
833
    if (v & 0xff00) {
834
        v >>= 8;
835
        n += 8;
836
    }
837
    n += ff_log2_tab[v];
838

    
839
    return n;
840
}
841

    
842

    
843
/* median of 3 */
844
static inline int mid_pred(int a, int b, int c)
845
{
846
    int vmin, vmax;
847
    vmax = vmin = a;
848
    if (b < vmin)
849
        vmin = b;
850
    else
851
        vmax = b;
852

    
853
    if (c < vmin)
854
        vmin = c;
855
    else if (c > vmax)
856
        vmax = c;
857

    
858
    return a + b + c - vmin - vmax;
859
}
860

    
861
static inline int clip(int a, int amin, int amax)
862
{
863
    if (a < amin)
864
        return amin;
865
    else if (a > amax)
866
        return amax;
867
    else
868
        return a;
869
}
870

    
871
/* math */
872
extern const uint8_t ff_sqrt_tab[128];
873

    
874
int ff_gcd(int a, int b);
875

    
876
static inline int ff_sqrt(int a)
877
{
878
    int ret=0;
879
    int s;
880
    int ret_sq=0;
881
    
882
    if(a<128) return ff_sqrt_tab[a];
883
    
884
    for(s=15; s>=0; s--){
885
        int b= ret_sq + (1<<(s*2)) + (ret<<s)*2;
886
        if(b<=a){
887
            ret_sq=b;
888
            ret+= 1<<s;
889
        }
890
    }
891
    return ret;
892
}
893

    
894
/**
895
 * converts fourcc string to int
896
 */
897
static inline int ff_get_fourcc(const char *s){
898
    assert( strlen(s)==4 );
899
    
900
    return (s[0]) + (s[1]<<8) + (s[2]<<16) + (s[3]<<24);
901
}
902

    
903
void ff_float2fraction(int *nom_arg, int *denom_arg, double f, int max);
904

    
905

    
906
#ifdef ARCH_X86
907
#define MASK_ABS(mask, level)\
908
            asm volatile(\
909
                "cdq                        \n\t"\
910
                "xorl %1, %0                \n\t"\
911
                "subl %1, %0                \n\t"\
912
                : "+a" (level), "=&d" (mask)\
913
            );
914
#else
915
#define MASK_ABS(mask, level)\
916
            mask= level>>31;\
917
            level= (level^mask)-mask;
918
#endif
919

    
920

    
921
#if __CPU__ >= 686 && !defined(RUNTIME_CPUDETECT)
922
#define COPY3_IF_LT(x,y,a,b,c,d)\
923
asm volatile (\
924
    "cmpl %0, %3        \n\t"\
925
    "cmovl %3, %0        \n\t"\
926
    "cmovl %4, %1        \n\t"\
927
    "cmovl %5, %2        \n\t"\
928
    : "+r" (x), "+r" (a), "+r" (c)\
929
    : "r" (y), "r" (b), "r" (d)\
930
);
931
#else
932
#define COPY3_IF_LT(x,y,a,b,c,d)\
933
if((y)<(x)){\
934
     (x)=(y);\
935
     (a)=(b);\
936
     (c)=(d);\
937
}
938
#endif
939

    
940
#define CLAMP_TO_8BIT(d) ((d > 0xff) ? 0xff : (d < 0) ? 0 : d)
941

    
942
/* avoid usage of various functions */
943
#define malloc please_use_av_malloc
944
#define free please_use_av_free
945
#define realloc please_use_av_realloc
946

    
947
#endif /* HAVE_AV_CONFIG_H */
948

    
949
#endif /* COMMON_H */