Statistics
| Branch: | Revision:

ffmpeg / libavcodec / common.h @ d8cf5aea

History | View | Annotate | Download (17.5 KB)

1
#ifndef COMMON_H
2
#define COMMON_H
3

    
4
#define FFMPEG_VERSION_INT 0x000406
5
#define FFMPEG_VERSION     "0.4.6"
6

    
7
#if defined(WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
8
#define CONFIG_WIN32
9
#endif
10

    
11
//#define ALT_BITSTREAM_WRITER
12
//#define ALIGNED_BITSTREAM_WRITER
13
//#define ALT_BITSTREAM_READER
14
//#define ALIGNED_BITSTREAM
15
#define FAST_GET_FIRST_VLC
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 <errno.h>
25

    
26
#ifndef ENODATA
27
#define ENODATA  61
28
#endif
29

    
30
#endif
31

    
32
#ifdef CONFIG_WIN32
33

    
34
/* windows */
35

    
36
typedef unsigned short UINT16;
37
typedef signed short INT16;
38
typedef unsigned char UINT8;
39
typedef unsigned int UINT32;
40
typedef unsigned __int64 UINT64;
41
typedef signed char INT8;
42
typedef signed int INT32;
43
typedef signed __int64 INT64;
44

    
45
typedef UINT8 uint8_t;
46
typedef INT8 int8_t;
47
typedef UINT16 uint16_t;
48
typedef INT16 int16_t;
49
typedef UINT32 uint32_t;
50
typedef INT32 int32_t;
51

    
52
#ifndef __MINGW32__
53
#define INT64_C(c)     (c ## i64)
54
#define UINT64_C(c)    (c ## i64)
55

    
56
#define inline __inline
57

    
58
/*
59
  Disable warning messages:
60
    warning C4244: '=' : conversion from 'double' to 'float', possible loss of data
61
    warning C4305: 'argument' : truncation from 'const double' to 'float'
62
*/
63
#pragma warning( disable : 4244 )
64
#pragma warning( disable : 4305 )
65

    
66
#else
67
#define INT64_C(c)     (c ## LL)
68
#define UINT64_C(c)    (c ## ULL)
69
#endif /* __MINGW32__ */
70

    
71
#define M_PI    3.14159265358979323846
72
#define M_SQRT2 1.41421356237309504880  /* sqrt(2) */
73

    
74
#ifdef _DEBUG
75
#define DEBUG
76
#endif
77

    
78
// code from bits/byteswap.h (C) 1997, 1998 Free Software Foundation, Inc.
79
#define bswap_32(x) \
80
     ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >>  8) | \
81
      (((x) & 0x0000ff00) <<  8) | (((x) & 0x000000ff) << 24))
82
#define be2me_32(x) bswap_32(x)
83

    
84
#define snprintf _snprintf
85

    
86
#ifndef __MINGW32__
87
/* no config.h with VC */
88
#define CONFIG_ENCODERS 1
89
#define CONFIG_DECODERS 1
90
#define CONFIG_AC3      1
91
#endif
92

    
93
#else
94

    
95
/* unix */
96

    
97
#include <inttypes.h>
98

    
99
#ifndef __WINE_WINDEF16_H
100
/* workaround for typedef conflict in MPlayer (wine typedefs) */
101
typedef unsigned short UINT16;
102
typedef signed short INT16;
103
#endif
104

    
105
typedef unsigned char UINT8;
106
typedef unsigned int UINT32;
107
typedef unsigned long long UINT64;
108
typedef signed char INT8;
109
typedef signed int INT32;
110
typedef signed long long INT64;
111

    
112
#ifdef HAVE_AV_CONFIG_H
113

    
114
#ifdef __FreeBSD__
115
#include <sys/param.h>
116
#endif
117

    
118
#ifndef INT64_C
119
#define INT64_C(c)     (c ## LL)
120
#define UINT64_C(c)    (c ## ULL)
121
#endif
122

    
123
#include "../bswap.h"
124

    
125
#ifdef USE_FASTMEMCPY
126
#include "fastmemcpy.h"
127
#endif
128

    
129
#endif /* HAVE_AV_CONFIG_H */
130

    
131
#endif /* !CONFIG_WIN32 */
132

    
133

    
134
/* debug stuff */
135
#ifdef HAVE_AV_CONFIG_H
136

    
137
#ifndef DEBUG
138
#define NDEBUG
139
#endif
140
#include <assert.h>
141

    
142
/* dprintf macros */
143
#if defined(CONFIG_WIN32) && !defined(__MINGW32__)
144

    
145
inline void dprintf(const char* fmt,...) {}
146

    
147
#else
148

    
149
#ifdef DEBUG
150
#define dprintf(fmt,args...) printf(fmt, ## args)
151
#else
152
#define dprintf(fmt,args...)
153
#endif
154

    
155
#endif /* !CONFIG_WIN32 */
156

    
157
#endif /* HAVE_AV_CONFIG_H */
158

    
159
/* bit output */
160

    
161
struct PutBitContext;
162

    
163
typedef void (*WriteDataFunc)(void *, UINT8 *, int);
164

    
165
typedef struct PutBitContext {
166
#ifdef ALT_BITSTREAM_WRITER
167
    UINT8 *buf, *buf_end;
168
    int index;
169
#else
170
    UINT32 bit_buf;
171
    int bit_left;
172
    UINT8 *buf, *buf_ptr, *buf_end;
173
#endif
174
    INT64 data_out_size; /* in bytes */
175
} PutBitContext;
176

    
177
void init_put_bits(PutBitContext *s, 
178
                   UINT8 *buffer, int buffer_size,
179
                   void *opaque,
180
                   void (*write_data)(void *, UINT8 *, int));
181

    
182
INT64 get_bit_count(PutBitContext *s); /* XXX: change function name */
183
void align_put_bits(PutBitContext *s);
184
void flush_put_bits(PutBitContext *s);
185

    
186
/* jpeg specific put_bits */
187
void jflush_put_bits(PutBitContext *s);
188

    
189
/* bit input */
190

    
191
typedef struct GetBitContext {
192
#ifdef ALT_BITSTREAM_READER
193
    int index;
194
    UINT8 *buffer;
195
#else
196
    UINT32 bit_buf;
197
    int bit_cnt;
198
    UINT8 *buf, *buf_ptr, *buf_end;
199
#endif
200
} GetBitContext;
201

    
202
typedef struct VLC {
203
    int bits;
204
    INT16 *table_codes;
205
    INT8 *table_bits;
206
    int table_size, table_allocated;
207
} VLC;
208

    
209
/* used to avoid missaligned exceptions on some archs (alpha, ...) */
210
#ifdef ARCH_X86
211
#define unaligned32(a) (*(UINT32*)(a))
212
#else
213
#ifdef __GNUC__
214
static inline uint32_t unaligned32(const void *v) {
215
    struct Unaligned {
216
        uint32_t i;
217
    } __attribute__((packed));
218

    
219
    return ((const struct Unaligned *) v)->i;
220
}
221
#elif defined(__DECC)
222
static inline uint32_t unaligned32(const void *v) {
223
    return *(const __unaligned uint32_t *) v;
224
}
225
#else
226
static inline uint32_t unaligned32(const void *v) {
227
    return *(const uint32_t *) v;
228
}
229
#endif
230
#endif //!ARCH_X86
231

    
232
#ifndef ALT_BITSTREAM_WRITER
233
static inline void put_bits(PutBitContext *s, int n, unsigned int value)
234
{
235
    unsigned int bit_buf;
236
    int bit_left;
237

    
238
#ifdef STATS
239
    st_out_bit_counts[st_current_index] += n;
240
#endif
241
    //    printf("put_bits=%d %x\n", n, value);
242
    assert(n == 32 || value < (1U << n));
243

    
244
    bit_buf = s->bit_buf;
245
    bit_left = s->bit_left;
246

    
247
    //    printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf);
248
    /* XXX: optimize */
249
    if (n < bit_left) {
250
        bit_buf = (bit_buf<<n) | value;
251
        bit_left-=n;
252
    } else {
253
        bit_buf<<=bit_left;
254
        bit_buf |= value >> (n - bit_left);
255
        *(UINT32 *)s->buf_ptr = be2me_32(bit_buf);
256
        //printf("bitbuf = %08x\n", bit_buf);
257
        s->buf_ptr+=4;
258
        bit_left+=32 - n;
259
        bit_buf = value;
260
    }
261

    
262
    s->bit_buf = bit_buf;
263
    s->bit_left = bit_left;
264
}
265
#endif
266

    
267

    
268
#ifdef ALT_BITSTREAM_WRITER
269
static inline void put_bits(PutBitContext *s, int n, unsigned int value)
270
{
271
#ifdef ALIGNED_BITSTREAM_WRITER
272
#ifdef ARCH_X86
273
    asm volatile(
274
        "movl %0, %%ecx                        \n\t"
275
        "xorl %%eax, %%eax                \n\t"
276
        "shrdl %%cl, %1, %%eax                \n\t"
277
        "shrl %%cl, %1                        \n\t"
278
        "movl %0, %%ecx                        \n\t"
279
        "shrl $3, %%ecx                        \n\t"
280
        "andl $0xFFFFFFFC, %%ecx        \n\t"
281
        "bswapl %1                        \n\t"
282
        "orl %1, (%2, %%ecx)                \n\t"
283
        "bswapl %%eax                        \n\t"
284
        "addl %3, %0                        \n\t"
285
        "movl %%eax, 4(%2, %%ecx)        \n\t"
286
        : "=&r" (s->index), "=&r" (value)
287
        : "r" (s->buf), "r" (n), "0" (s->index), "1" (value<<(-n))
288
        : "%eax", "%ecx"
289
    );
290
#else
291
    int index= s->index;
292
    uint32_t *ptr= ((uint32_t *)s->buf)+(index>>5);
293
    
294
    value<<= 32-n; 
295
    
296
    ptr[0] |= be2me_32(value>>(index&31));
297
    ptr[1]  = be2me_32(value<<(32-(index&31)));
298
//if(n>24) printf("%d %d\n", n, value);
299
    index+= n;
300
    s->index= index;
301
#endif
302
#else //ALIGNED_BITSTREAM_WRITER
303
#ifdef ARCH_X86
304
    asm volatile(
305
        "movl $7, %%ecx                        \n\t"
306
        "andl %0, %%ecx                        \n\t"
307
        "addl %3, %%ecx                        \n\t"
308
        "negl %%ecx                        \n\t"
309
        "shll %%cl, %1                        \n\t"
310
        "bswapl %1                        \n\t"
311
        "movl %0, %%ecx                        \n\t"
312
        "shrl $3, %%ecx                        \n\t"
313
        "orl %1, (%%ecx, %2)                \n\t"
314
        "addl %3, %0                        \n\t"
315
        "movl $0, 4(%%ecx, %2)                \n\t"
316
        : "=&r" (s->index), "=&r" (value)
317
        : "r" (s->buf), "r" (n), "0" (s->index), "1" (value)
318
        : "%ecx"
319
    );
320
#else
321
    int index= s->index;
322
    uint32_t *ptr= (uint32_t*)(((uint8_t *)s->buf)+(index>>3));
323
    
324
    ptr[0] |= be2me_32(value<<(32-n-(index&7) ));
325
    ptr[1] = 0;
326
//if(n>24) printf("%d %d\n", n, value);
327
    index+= n;
328
    s->index= index;
329
#endif
330
#endif //!ALIGNED_BITSTREAM_WRITER
331
}
332
#endif
333

    
334
#ifndef ALT_BITSTREAM_WRITER
335
/* for jpeg : escape 0xff with 0x00 after it */
336
static inline void jput_bits(PutBitContext *s, int n, unsigned int value)
337
{
338
    unsigned int bit_buf, b;
339
    int bit_left, i;
340
    
341
    assert(n == 32 || value < (1U << n));
342

    
343
    bit_buf = s->bit_buf;
344
    bit_left = s->bit_left;
345

    
346
    //printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf);
347
    /* XXX: optimize */
348
    if (n < bit_left) {
349
        bit_buf = (bit_buf<<n) | value;
350
        bit_left-=n;
351
    } else {
352
        bit_buf<<=bit_left;
353
        bit_buf |= value >> (n - bit_left);
354
        /* handle escape */
355
        for(i=0;i<4;i++) {
356
            b = (bit_buf >> 24);
357
            *(s->buf_ptr++) = b;
358
            if (b == 0xff)
359
                *(s->buf_ptr++) = 0;
360
            bit_buf <<= 8;
361
        }
362

    
363
        bit_left+= 32 - n;
364
        bit_buf = value;
365
    }
366
    
367
    s->bit_buf = bit_buf;
368
    s->bit_left = bit_left;
369
}
370
#endif
371

    
372

    
373
#ifdef ALT_BITSTREAM_WRITER
374
static inline void jput_bits(PutBitContext *s, int n, int value)
375
{
376
    int index= s->index;
377
    uint32_t *ptr= (uint32_t*)(((uint8_t *)s->buf)+(index>>3));
378
    int v= ptr[0];
379
//if(n>24) printf("%d %d\n", n, value);
380
    
381
    v |= be2me_32(value<<(32-n-(index&7) ));
382
    if(((v+0x01010101)^0xFFFFFFFF)&v&0x80808080)
383
    {
384
        /* handle idiotic (m)jpeg escapes */
385
        uint8_t *bPtr= (uint8_t*)ptr;
386
        int numChecked= ((index+n)>>3) - (index>>3);
387
        
388
        v= be2me_32(v);
389

    
390
        *(bPtr++)= v>>24;
391
        if((v&0xFF000000)==0xFF000000 && numChecked>0){
392
                *(bPtr++)= 0x00;
393
                index+=8;
394
        }
395
        *(bPtr++)= (v>>16)&0xFF;
396
        if((v&0x00FF0000)==0x00FF0000 && numChecked>1){
397
                *(bPtr++)= 0x00;
398
                index+=8;
399
        }
400
        *(bPtr++)= (v>>8)&0xFF;
401
        if((v&0x0000FF00)==0x0000FF00 && numChecked>2){
402
                *(bPtr++)= 0x00;
403
                index+=8;
404
        }
405
        *(bPtr++)= v&0xFF;
406
        if((v&0x000000FF)==0x000000FF && numChecked>3){
407
                *(bPtr++)= 0x00;
408
                index+=8;
409
        }
410
        *((uint32_t*)bPtr)= 0;
411
    }
412
    else
413
    {
414
        ptr[0] = v;
415
        ptr[1] = 0;
416
    }
417

    
418
    index+= n;
419
    s->index= index;
420
 }
421
#endif
422

    
423

    
424
static inline uint8_t* pbBufPtr(PutBitContext *s)
425
{
426
#ifdef ALT_BITSTREAM_WRITER
427
        return s->buf + (s->index>>3);
428
#else
429
        return s->buf_ptr;
430
#endif
431
}
432

    
433
void init_get_bits(GetBitContext *s, 
434
                   UINT8 *buffer, int buffer_size);
435

    
436
#ifndef ALT_BITSTREAM_READER
437
unsigned int get_bits_long(GetBitContext *s, int n);
438
unsigned int show_bits_long(GetBitContext *s, int n);
439
#endif
440

    
441
static inline unsigned int get_bits(GetBitContext *s, int n){
442
#ifdef ALT_BITSTREAM_READER
443
#ifdef ALIGNED_BITSTREAM
444
    int index= s->index;
445
    uint32_t result1= be2me_32( ((uint32_t *)s->buffer)[index>>5] );
446
    uint32_t result2= be2me_32( ((uint32_t *)s->buffer)[(index>>5) + 1] );
447
#ifdef ARCH_X86
448
    asm ("shldl %%cl, %2, %0\n\t"
449
         : "=r" (result1)
450
         : "0" (result1), "r" (result2), "c" (index));
451
#else
452
    result1<<= (index&0x1F);
453
    result2= (result2>>1) >> (31-(index&0x1F));
454
    result1|= result2;
455
#endif
456
    result1>>= 32 - n;
457
    index+= n;
458
    s->index= index;
459
    
460
    return result1;
461
#else //ALIGNED_BITSTREAM
462
    int index= s->index;
463
    uint32_t result= be2me_32( unaligned32( ((uint8_t *)s->buffer)+(index>>3) ) );
464

    
465
    result<<= (index&0x07);
466
    result>>= 32 - n;
467
    index+= n;
468
    s->index= index;
469
    
470
    return result;
471
#endif //!ALIGNED_BITSTREAM
472
#else //ALT_BITSTREAM_READER
473
    if(s->bit_cnt>=n){
474
        /* most common case here */
475
        unsigned int val = s->bit_buf >> (32 - n);
476
        s->bit_buf <<= n;
477
        s->bit_cnt -= n;
478
#ifdef STATS
479
        st_bit_counts[st_current_index] += n;
480
#endif
481
        return val;
482
    }
483
    return get_bits_long(s,n);
484
#endif //!ALT_BITSTREAM_READER
485
}
486

    
487
static inline unsigned int get_bits1(GetBitContext *s){
488
#ifdef ALT_BITSTREAM_READER
489
    int index= s->index;
490
    uint8_t result= s->buffer[ index>>3 ];
491
    result<<= (index&0x07);
492
    result>>= 8 - 1;
493
    index++;
494
    s->index= index;
495
    
496
    return result;
497
#else
498
    if(s->bit_cnt>0){
499
        /* most common case here */
500
        unsigned int val = s->bit_buf >> 31;
501
        s->bit_buf <<= 1;
502
        s->bit_cnt--;
503
#ifdef STATS
504
        st_bit_counts[st_current_index]++;
505
#endif
506
        return val;
507
    }
508
    return get_bits_long(s,1);
509
#endif
510
}
511

    
512
/* This function is identical to get_bits(), the only */
513
/* diference is that it doesn't touch the buffer      */
514
/* it is usefull to see the buffer.                   */
515
static inline unsigned int show_bits(GetBitContext *s, int n)
516
{
517
#ifdef ALT_BITSTREAM_READER
518
#ifdef ALIGNED_BITSTREAM
519
    int index= s->index;
520
    uint32_t result1= be2me_32( ((uint32_t *)s->buffer)[index>>5] );
521
    uint32_t result2= be2me_32( ((uint32_t *)s->buffer)[(index>>5) + 1] );
522
#ifdef ARCH_X86
523
    asm ("shldl %%cl, %2, %0\n\t"
524
         : "=r" (result1)
525
         : "0" (result1), "r" (result2), "c" (index));
526
#else
527
    result1<<= (index&0x1F);
528
    result2= (result2>>1) >> (31-(index&0x1F));
529
    result1|= result2;
530
#endif
531
    result1>>= 32 - n;
532
    
533
    return result1;
534
#else //ALIGNED_BITSTREAM
535
    int index= s->index;
536
    uint32_t result= be2me_32( unaligned32( ((uint8_t *)s->buffer)+(index>>3) ) );
537

    
538
    result<<= (index&0x07);
539
    result>>= 32 - n;
540
    
541
    return result;
542
#endif //!ALIGNED_BITSTREAM
543
#else //ALT_BITSTREAM_READER
544
    if(s->bit_cnt>=n) {
545
        /* most common case here */
546
        unsigned int val = s->bit_buf >> (32 - n);
547
        return val;
548
    }
549
    return show_bits_long(s,n);
550
#endif //!ALT_BITSTREAM_READER
551
}
552

    
553
static inline void skip_bits(GetBitContext *s, int n){
554
#ifdef ALT_BITSTREAM_READER
555
    s->index+= n;
556
#else
557
    if(s->bit_cnt>=n){
558
        /* most common case here */
559
        s->bit_buf <<= n;
560
        s->bit_cnt -= n;
561
#ifdef STATS
562
        st_bit_counts[st_current_index] += n;
563
#endif
564
    } else {
565
        get_bits_long(s,n);
566
    }
567
#endif
568
}
569

    
570
static inline void skip_bits1(GetBitContext *s){
571
#ifdef ALT_BITSTREAM_READER
572
    s->index++;
573
#else
574
    if(s->bit_cnt>0){
575
        /* most common case here */
576
        s->bit_buf <<= 1;
577
        s->bit_cnt--;
578
#ifdef STATS
579
        st_bit_counts[st_current_index]++;
580
#endif
581
    } else {
582
        get_bits_long(s,1);
583
    }
584
#endif
585
}
586

    
587
static inline int get_bits_count(GetBitContext *s)
588
{
589
#ifdef ALT_BITSTREAM_READER
590
    return s->index;
591
#else
592
    return (s->buf_ptr - s->buf) * 8 - s->bit_cnt;
593
#endif
594
}
595

    
596
void align_get_bits(GetBitContext *s);
597
int init_vlc(VLC *vlc, int nb_bits, int nb_codes,
598
             const void *bits, int bits_wrap, int bits_size,
599
             const void *codes, int codes_wrap, int codes_size);
600
void free_vlc(VLC *vlc);
601

    
602
#ifdef ALT_BITSTREAM_READER
603
#ifdef ALIGNED_BITSTREAM
604
#ifdef ARCH_X86
605
#define SHOW_BITS(s, val, n) \
606
    val= be2me_32( ((uint32_t *)(s)->buffer)[bit_cnt>>5] );\
607
    {uint32_t result2= be2me_32( ((uint32_t *)(s)->buffer)[(bit_cnt>>5) + 1] );\
608
    asm ("shldl %%cl, %2, %0\n\t"\
609
         : "=r" (val)\
610
         : "0" (val), "r" (result2), "c" (bit_cnt));\
611
    ((uint32_t)val)>>= 32 - n;}
612
#else //ARCH_X86
613
#define SHOW_BITS(s, val, n) \
614
    val= be2me_32( ((uint32_t *)(s)->buffer)[bit_cnt>>5] );\
615
    {uint32_t result2= be2me_32( ((uint32_t *)(s)->buffer)[(bit_cnt>>5) + 1] );\
616
    val<<= (bit_cnt&0x1F);\
617
    result2= (result2>>1) >> (31-(bit_cnt&0x1F));\
618
    val|= result2;\
619
    ((uint32_t)val)>>= 32 - n;}
620
#endif //!ARCH_X86
621
#else //ALIGNED_BITSTREAM
622
#define SHOW_BITS(s, val, n) \
623
    val= be2me_32( unaligned32( ((uint8_t *)(s)->buffer)+(bit_cnt>>3) ) );\
624
    val<<= (bit_cnt&0x07);\
625
    ((uint32_t)val)>>= 32 - n;
626
#endif // !ALIGNED_BITSTREAM
627
#define FLUSH_BITS(n) bit_cnt+=n; 
628
#define SAVE_BITS(s) bit_cnt= (s)->index;
629
#define RESTORE_BITS(s) (s)->index= bit_cnt;
630
#else
631

    
632
/* macro to go faster */
633
/* n must be <= 24 */
634
/* XXX: optimize buffer end test */
635
#define SHOW_BITS(s, val, n)\
636
{\
637
    if (bit_cnt < n && buf_ptr < (s)->buf_end) {\
638
        bit_buf |= *buf_ptr++ << (24 - bit_cnt);\
639
        bit_cnt += 8;\
640
        if (bit_cnt < n && buf_ptr < (s)->buf_end) {\
641
            bit_buf |= *buf_ptr++ << (24 - bit_cnt);\
642
            bit_cnt += 8;\
643
            if (bit_cnt < n && buf_ptr < (s)->buf_end) {\
644
                bit_buf |= *buf_ptr++ << (24 - bit_cnt);\
645
                bit_cnt += 8;\
646
            }\
647
        }\
648
    }\
649
    val = bit_buf >> (32 - n);\
650
}
651

    
652
/* SHOW_BITS with n1 >= n must be been done before */
653
#define FLUSH_BITS(n)\
654
{\
655
    bit_buf <<= n;\
656
    bit_cnt -= n;\
657
}
658

    
659
#define SAVE_BITS(s) \
660
{\
661
    bit_cnt = (s)->bit_cnt;\
662
    bit_buf = (s)->bit_buf;\
663
    buf_ptr = (s)->buf_ptr;\
664
}
665

    
666
#define RESTORE_BITS(s) \
667
{\
668
    (s)->buf_ptr = buf_ptr;\
669
    (s)->bit_buf = bit_buf;\
670
    (s)->bit_cnt = bit_cnt;\
671
}
672
#endif // !ALT_BITSTREAM_READER
673

    
674
static inline int get_vlc(GetBitContext *s, VLC *vlc)
675
{
676
    int code, n, nb_bits, index;
677
    INT16 *table_codes;
678
    INT8 *table_bits;
679
    int bit_cnt;
680
#ifndef ALT_BITSTREAM_READER
681
    UINT32 bit_buf;
682
    UINT8 *buf_ptr;
683
#endif
684

    
685
    SAVE_BITS(s);
686
    nb_bits = vlc->bits;
687
    table_codes = vlc->table_codes;
688
    table_bits = vlc->table_bits;
689

    
690
#ifdef FAST_GET_FIRST_VLC
691
    SHOW_BITS(s, index, nb_bits);
692
    code = table_codes[index];
693
    n = table_bits[index];
694
    if (n > 0) {
695
        /* most common case (90%)*/
696
        FLUSH_BITS(n);
697
        RESTORE_BITS(s);
698
        return code;
699
    } else if (n == 0) {
700
        return -1;
701
    } else {
702
        FLUSH_BITS(nb_bits);
703
        nb_bits = -n;
704
        table_codes = vlc->table_codes + code;
705
        table_bits = vlc->table_bits + code;
706
    }
707
#endif
708
    for(;;) {
709
        SHOW_BITS(s, index, nb_bits);
710
        code = table_codes[index];
711
        n = table_bits[index];
712
        if (n > 0) {
713
            /* most common case */
714
            FLUSH_BITS(n);
715
#ifdef STATS
716
            st_bit_counts[st_current_index] += n;
717
#endif
718
            break;
719
        } else if (n == 0) {
720
            return -1;
721
        } else {
722
            FLUSH_BITS(nb_bits);
723
#ifdef STATS
724
            st_bit_counts[st_current_index] += nb_bits;
725
#endif
726
            nb_bits = -n;
727
            table_codes = vlc->table_codes + code;
728
            table_bits = vlc->table_bits + code;
729
        }
730
    }
731
    RESTORE_BITS(s);
732
    return code;
733
}
734

    
735

    
736
/* define it to include statistics code (useful only for optimizing
737
   codec efficiency */
738
//#define STATS
739

    
740
#ifdef STATS
741

    
742
enum {
743
    ST_UNKNOWN,
744
    ST_DC,
745
    ST_INTRA_AC,
746
    ST_INTER_AC,
747
    ST_INTRA_MB,
748
    ST_INTER_MB,
749
    ST_MV,
750
    ST_NB,
751
};
752

    
753
extern int st_current_index;
754
extern unsigned int st_bit_counts[ST_NB];
755
extern unsigned int st_out_bit_counts[ST_NB];
756

    
757
void print_stats(void);
758
#endif
759

    
760
/* misc math functions */
761

    
762
static inline int av_log2(unsigned int v)
763
{
764
    int n;
765

    
766
    n = 0;
767
    if (v & 0xffff0000) {
768
        v >>= 16;
769
        n += 16;
770
    }
771
    if (v & 0xff00) {
772
        v >>= 8;
773
        n += 8;
774
    }
775
    if (v & 0xf0) {
776
        v >>= 4;
777
        n += 4;
778
    }
779
    if (v & 0xc) {
780
        v >>= 2;
781
        n += 2;
782
    }
783
    if (v & 0x2) {
784
        n++;
785
    }
786
    return n;
787
}
788

    
789
/* memory */
790
void *av_mallocz(int size);
791

    
792
#endif