* DV decoder simplifications. Now it looks to be 6% faster. At least
[ffmpeg.git] / libavcodec / common.h
1 /**
2  * @file common.h
3  * common internal api header.
4  */
5
6 #ifndef COMMON_H
7 #define COMMON_H
8
9 #if defined(WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
10 #    define CONFIG_WIN32
11 #endif
12
13 //#define ALT_BITSTREAM_WRITER
14 //#define ALIGNED_BITSTREAM_WRITER
15
16 #define ALT_BITSTREAM_READER
17 //#define LIBMPEG2_BITSTREAM_READER
18 //#define A32_BITSTREAM_READER
19 #define LIBMPEG2_BITSTREAM_READER_HACK //add BERO
20
21 #ifndef M_PI
22 #define M_PI    3.14159265358979323846
23 #endif
24
25 #ifdef HAVE_AV_CONFIG_H
26 /* only include the following when compiling package */
27 #    include "config.h"
28
29 #    include <stdlib.h>
30 #    include <stdio.h>
31 #    include <string.h>
32 #    include <ctype.h>
33 #    ifndef __BEOS__
34 #        include <errno.h>
35 #    else
36 #        include "berrno.h"
37 #    endif
38 #    include <math.h>
39
40 #    ifndef ENODATA
41 #        define ENODATA  61
42 #    endif
43
44 #include <stddef.h>
45 #ifndef offsetof
46 # define offsetof(T,F) ((unsigned int)((char *)&((T *)0)->F))
47 #endif
48
49 #define AVOPTION_CODEC_BOOL(name, help, field) \
50     { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_BOOL }
51 #define AVOPTION_CODEC_DOUBLE(name, help, field, minv, maxv, defval) \
52     { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_DOUBLE, minv, maxv, defval }
53 #define AVOPTION_CODEC_FLAG(name, help, field, flag, defval) \
54     { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_FLAG, flag, 0, defval }
55 #define AVOPTION_CODEC_INT(name, help, field, minv, maxv, defval) \
56     { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_INT, minv, maxv, defval }
57 #define AVOPTION_CODEC_STRING(name, help, field, str, val) \
58     { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_STRING, .defval = val, .defstr = str }
59 #define AVOPTION_CODEC_RCOVERRIDE(name, help, field) \
60     { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_RCOVERRIDE, .defval = 0, .defstr = NULL }
61 #define AVOPTION_SUB(ptr) { .name = NULL, .help = (const char*)ptr }
62 #define AVOPTION_END() AVOPTION_SUB(NULL)
63
64 struct AVOption;
65 #ifdef HAVE_MMX
66 extern const struct AVOption avoptions_common[3 + 5];
67 #else
68 extern const struct AVOption avoptions_common[3];
69 #endif
70 extern const struct AVOption avoptions_workaround_bug[11];
71
72 #endif /* HAVE_AV_CONFIG_H */
73
74 /* Suppress restrict if it was not defined in config.h.  */
75 #ifndef restrict
76 #    define restrict
77 #endif
78
79 #if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0)
80 #    define always_inline __attribute__((always_inline)) inline
81 #else
82 #    define always_inline inline
83 #endif
84
85 #if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0)
86 #    define attribute_used __attribute__((used))
87 #else
88 #    define attribute_used
89 #endif
90
91 #ifndef EMULATE_INTTYPES
92 #   include <inttypes.h>
93 #else
94     typedef signed char  int8_t;
95     typedef signed short int16_t;
96     typedef signed int   int32_t;
97     typedef unsigned char  uint8_t;
98     typedef unsigned short uint16_t;
99     typedef unsigned int   uint32_t;
100
101 #   ifdef CONFIG_WIN32
102         typedef signed __int64   int64_t;
103         typedef unsigned __int64 uint64_t;
104 #   else /* other OS */
105         typedef signed long long   int64_t;
106         typedef unsigned long long uint64_t;
107 #   endif /* other OS */
108 #endif /* HAVE_INTTYPES_H */
109
110 #ifndef INT64_MAX
111 #define INT64_MAX int64_t_C(9223372036854775807)
112 #endif
113
114 #ifdef EMULATE_FAST_INT
115 /* note that we don't emulate 64bit ints */
116 typedef signed char int_fast8_t;
117 typedef signed int  int_fast16_t;
118 typedef signed int  int_fast32_t;
119 typedef unsigned char uint_fast8_t;
120 typedef unsigned int  uint_fast16_t;
121 typedef unsigned int  uint_fast32_t;
122 #endif
123
124 #if defined(CONFIG_OS2) || defined(CONFIG_SUNOS)
125 static inline float floorf(float f) { 
126     return floor(f); 
127 }
128 #endif
129
130 #ifdef CONFIG_WIN32
131
132 /* windows */
133
134 #    ifndef __MINGW32__
135 #        define int64_t_C(c)     (c ## i64)
136 #        define uint64_t_C(c)    (c ## i64)
137
138 #    ifdef HAVE_AV_CONFIG_H
139 #            define inline __inline
140 #    endif
141
142 #    else
143 #        define int64_t_C(c)     (c ## LL)
144 #        define uint64_t_C(c)    (c ## ULL)
145 #    endif /* __MINGW32__ */
146
147 #    ifdef HAVE_AV_CONFIG_H
148 #        ifdef _DEBUG
149 #            define DEBUG
150 #        endif
151
152 #        define snprintf _snprintf
153 #        define vsnprintf _vsnprintf
154 #    endif
155
156 /* CONFIG_WIN32 end */
157 #elif defined (CONFIG_OS2)
158 /* OS/2 EMX */
159
160 #ifndef int64_t_C
161 #define int64_t_C(c)     (c ## LL)
162 #define uint64_t_C(c)    (c ## ULL)
163 #endif
164
165 #ifdef HAVE_AV_CONFIG_H
166
167 #ifdef USE_FASTMEMCPY
168 #include "fastmemcpy.h"
169 #endif
170
171 #include <float.h>
172
173 #endif /* HAVE_AV_CONFIG_H */
174
175 /* CONFIG_OS2 end */
176 #else
177
178 /* unix */
179
180 #ifndef int64_t_C
181 #define int64_t_C(c)     (c ## LL)
182 #define uint64_t_C(c)    (c ## ULL)
183 #endif
184
185 #ifdef HAVE_AV_CONFIG_H
186
187 #        ifdef USE_FASTMEMCPY
188 #            include "fastmemcpy.h"
189 #        endif
190 #    endif /* HAVE_AV_CONFIG_H */
191
192 #endif /* !CONFIG_WIN32 && !CONFIG_OS2 */
193
194 #ifdef HAVE_AV_CONFIG_H
195
196 #    include "bswap.h"
197
198 #    if defined(__MINGW32__) || defined(__CYGWIN__) || \
199         defined(__OS2__) || (defined (__OpenBSD__) && !defined(__ELF__))
200 #        define MANGLE(a) "_" #a
201 #    else
202 #        define MANGLE(a) #a
203 #    endif
204
205 /* debug stuff */
206
207 #    ifndef DEBUG
208 #        define NDEBUG
209 #    endif
210 #    include <assert.h>
211
212 /* dprintf macros */
213 #    if defined(CONFIG_WIN32) && !defined(__MINGW32__)
214
215 inline void dprintf(const char* fmt,...) {}
216
217 #    else
218
219 #        ifdef DEBUG
220 #            define dprintf(fmt,...) printf(fmt, __VA_ARGS__)
221 #        else
222 #            define dprintf(fmt,...)
223 #        endif
224
225 #    endif /* !CONFIG_WIN32 */
226
227 #    define av_abort()      do { av_log(NULL, AV_LOG_ERROR, "Abort at %s:%d\n", __FILE__, __LINE__); abort(); } while (0)
228
229 //rounded divison & shift
230 #define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b))
231 /* assume b>0 */
232 #define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))
233 #define ABS(a) ((a) >= 0 ? (a) : (-(a)))
234
235 #define FFMAX(a,b) ((a) > (b) ? (a) : (b))
236 #define FFMIN(a,b) ((a) > (b) ? (b) : (a))
237
238 extern const uint32_t inverse[256];
239
240 #ifdef ARCH_X86
241 #    define FASTDIV(a,b) \
242     ({\
243         int ret,dmy;\
244         asm volatile(\
245             "mull %3"\
246             :"=d"(ret),"=a"(dmy)\
247             :"1"(a),"g"(inverse[b])\
248             );\
249         ret;\
250     })
251 #elif defined(CONFIG_FASTDIV)
252 #    define FASTDIV(a,b)   ((uint32_t)((((uint64_t)a)*inverse[b])>>32))
253 #else
254 #    define FASTDIV(a,b)   ((a)/(b))
255 #endif
256  
257 #ifdef ARCH_X86
258 // avoid +32 for shift optimization (gcc should do that ...)
259 static inline  int32_t NEG_SSR32( int32_t a, int8_t s){
260     asm ("sarl %1, %0\n\t"
261          : "+r" (a)
262          : "ic" ((uint8_t)(-s))
263     );
264     return a;
265 }
266 static inline uint32_t NEG_USR32(uint32_t a, int8_t s){
267     asm ("shrl %1, %0\n\t"
268          : "+r" (a)
269          : "ic" ((uint8_t)(-s))
270     );
271     return a;
272 }
273 #else
274 #    define NEG_SSR32(a,s) ((( int32_t)(a))>>(32-(s)))
275 #    define NEG_USR32(a,s) (((uint32_t)(a))>>(32-(s)))
276 #endif
277
278 /* bit output */
279
280 struct PutBitContext;
281
282 typedef void (*WriteDataFunc)(void *, uint8_t *, int);
283
284 typedef struct PutBitContext {
285 #ifdef ALT_BITSTREAM_WRITER
286     uint8_t *buf, *buf_end;
287     int index;
288 #else
289     uint32_t bit_buf;
290     int bit_left;
291     uint8_t *buf, *buf_ptr, *buf_end;
292 #endif
293 } PutBitContext;
294
295 static inline void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
296 {
297     s->buf = buffer;
298     s->buf_end = s->buf + buffer_size;
299 #ifdef ALT_BITSTREAM_WRITER
300     s->index=0;
301     ((uint32_t*)(s->buf))[0]=0;
302 //    memset(buffer, 0, buffer_size);
303 #else
304     s->buf_ptr = s->buf;
305     s->bit_left=32;
306     s->bit_buf=0;
307 #endif
308 }
309
310 /* return the number of bits output */
311 static inline int put_bits_count(PutBitContext *s)
312 {
313 #ifdef ALT_BITSTREAM_WRITER
314     return s->index;
315 #else
316     return (s->buf_ptr - s->buf) * 8 + 32 - s->bit_left;
317 #endif
318 }
319
320 static inline int put_bits_left(PutBitContext* s)
321 {
322     return (s->buf_end - s->buf) * 8 - put_bits_count(s);
323 }
324
325 /* pad the end of the output stream with zeros */
326 static inline void flush_put_bits(PutBitContext *s)
327 {
328 #ifdef ALT_BITSTREAM_WRITER
329     align_put_bits(s);
330 #else
331     s->bit_buf<<= s->bit_left;
332     while (s->bit_left < 32) {
333         /* XXX: should test end of buffer */
334         *s->buf_ptr++=s->bit_buf >> 24;
335         s->bit_buf<<=8;
336         s->bit_left+=8;
337     }
338     s->bit_left=32;
339     s->bit_buf=0;
340 #endif
341 }
342
343 void align_put_bits(PutBitContext *s);
344 void put_string(PutBitContext * pbc, char *s, int put_zero);
345
346 /* bit input */
347
348 typedef struct GetBitContext {
349     const uint8_t *buffer, *buffer_end;
350 #ifdef ALT_BITSTREAM_READER
351     int index;
352 #elif defined LIBMPEG2_BITSTREAM_READER
353     uint8_t *buffer_ptr;
354     uint32_t cache;
355     int bit_count;
356 #elif defined A32_BITSTREAM_READER
357     uint32_t *buffer_ptr;
358     uint32_t cache0;
359     uint32_t cache1;
360     int bit_count;
361 #endif
362     int size_in_bits;
363 } GetBitContext;
364
365 #define VLC_TYPE int16_t
366
367 typedef struct VLC {
368     int bits;
369     VLC_TYPE (*table)[2]; ///< code, bits
370     int table_size, table_allocated;
371 } VLC;
372
373 typedef struct RL_VLC_ELEM {
374     int16_t level;
375     int8_t len;
376     uint8_t run;
377 } RL_VLC_ELEM;
378
379 #ifdef ARCH_SPARC64
380 #define UNALIGNED_STORES_ARE_BAD
381 #endif
382
383 /* used to avoid missaligned exceptions on some archs (alpha, ...) */
384 #ifdef ARCH_X86
385 #    define unaligned32(a) (*(uint32_t*)(a))
386 #else
387 #    ifdef __GNUC__
388 static inline uint32_t unaligned32(const void *v) {
389     struct Unaligned {
390         uint32_t i;
391     } __attribute__((packed));
392
393     return ((const struct Unaligned *) v)->i;
394 }
395 #    elif defined(__DECC)
396 static inline uint32_t unaligned32(const void *v) {
397     return *(const __unaligned uint32_t *) v;
398 }
399 #    else
400 static inline uint32_t unaligned32(const void *v) {
401     return *(const uint32_t *) v;
402 }
403 #    endif
404 #endif //!ARCH_X86
405
406 #ifndef ALT_BITSTREAM_WRITER
407 static inline void put_bits(PutBitContext *s, int n, unsigned int value)
408 {
409     unsigned int bit_buf;
410     int bit_left;
411
412 #ifdef STATS
413     st_out_bit_counts[st_current_index] += n;
414 #endif
415     //    printf("put_bits=%d %x\n", n, value);
416     assert(n == 32 || value < (1U << n));
417     
418     bit_buf = s->bit_buf;
419     bit_left = s->bit_left;
420
421     //    printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf);
422     /* XXX: optimize */
423     if (n < bit_left) {
424         bit_buf = (bit_buf<<n) | value;
425         bit_left-=n;
426     } else {
427         bit_buf<<=bit_left;
428         bit_buf |= value >> (n - bit_left);
429 #ifdef UNALIGNED_STORES_ARE_BAD
430         if (3 & (int) s->buf_ptr) {
431             s->buf_ptr[0] = bit_buf >> 24;
432             s->buf_ptr[1] = bit_buf >> 16;
433             s->buf_ptr[2] = bit_buf >>  8;
434             s->buf_ptr[3] = bit_buf      ;
435         } else
436 #endif
437         *(uint32_t *)s->buf_ptr = be2me_32(bit_buf);
438         //printf("bitbuf = %08x\n", bit_buf);
439         s->buf_ptr+=4;
440         bit_left+=32 - n;
441         bit_buf = value;
442     }
443
444     s->bit_buf = bit_buf;
445     s->bit_left = bit_left;
446 }
447 #endif
448
449
450 #ifdef ALT_BITSTREAM_WRITER
451 static inline void put_bits(PutBitContext *s, int n, unsigned int value)
452 {
453 #    ifdef ALIGNED_BITSTREAM_WRITER
454 #        ifdef ARCH_X86
455     asm volatile(
456         "movl %0, %%ecx                 \n\t"
457         "xorl %%eax, %%eax              \n\t"
458         "shrdl %%cl, %1, %%eax          \n\t"
459         "shrl %%cl, %1                  \n\t"
460         "movl %0, %%ecx                 \n\t"
461         "shrl $3, %%ecx                 \n\t"
462         "andl $0xFFFFFFFC, %%ecx        \n\t"
463         "bswapl %1                      \n\t"
464         "orl %1, (%2, %%ecx)            \n\t"
465         "bswapl %%eax                   \n\t"
466         "addl %3, %0                    \n\t"
467         "movl %%eax, 4(%2, %%ecx)       \n\t"
468         : "=&r" (s->index), "=&r" (value)
469         : "r" (s->buf), "r" (n), "0" (s->index), "1" (value<<(-n))
470         : "%eax", "%ecx"
471     );
472 #        else
473     int index= s->index;
474     uint32_t *ptr= ((uint32_t *)s->buf)+(index>>5);
475     
476     value<<= 32-n; 
477     
478     ptr[0] |= be2me_32(value>>(index&31));
479     ptr[1]  = be2me_32(value<<(32-(index&31)));
480 //if(n>24) printf("%d %d\n", n, value);
481     index+= n;
482     s->index= index;
483 #        endif
484 #    else //ALIGNED_BITSTREAM_WRITER
485 #        ifdef ARCH_X86
486     asm volatile(
487         "movl $7, %%ecx                 \n\t"
488         "andl %0, %%ecx                 \n\t"
489         "addl %3, %%ecx                 \n\t"
490         "negl %%ecx                     \n\t"
491         "shll %%cl, %1                  \n\t"
492         "bswapl %1                      \n\t"
493         "movl %0, %%ecx                 \n\t"
494         "shrl $3, %%ecx                 \n\t"
495         "orl %1, (%%ecx, %2)            \n\t"
496         "addl %3, %0                    \n\t"
497         "movl $0, 4(%%ecx, %2)          \n\t"
498         : "=&r" (s->index), "=&r" (value)
499         : "r" (s->buf), "r" (n), "0" (s->index), "1" (value)
500         : "%ecx"
501     );
502 #        else
503     int index= s->index;
504     uint32_t *ptr= (uint32_t*)(((uint8_t *)s->buf)+(index>>3));
505     
506     ptr[0] |= be2me_32(value<<(32-n-(index&7) ));
507     ptr[1] = 0;
508 //if(n>24) printf("%d %d\n", n, value);
509     index+= n;
510     s->index= index;
511 #        endif
512 #    endif //!ALIGNED_BITSTREAM_WRITER
513 }
514 #endif
515
516
517 static inline uint8_t* pbBufPtr(PutBitContext *s)
518 {
519 #ifdef ALT_BITSTREAM_WRITER
520         return s->buf + (s->index>>3);
521 #else
522         return s->buf_ptr;
523 #endif
524 }
525
526 /**
527  *
528  * PutBitContext must be flushed & aligned to a byte boundary before calling this.
529  */
530 static inline void skip_put_bytes(PutBitContext *s, int n){
531         assert((put_bits_count(s)&7)==0);
532 #ifdef ALT_BITSTREAM_WRITER
533         FIXME may need some cleaning of the buffer
534         s->index += n<<3;
535 #else
536         assert(s->bit_left==32);
537         s->buf_ptr += n;
538 #endif    
539 }
540
541 /**
542  * Changes the end of the buffer.
543  */
544 static inline void set_put_bits_buffer_size(PutBitContext *s, int size){
545     s->buf_end= s->buf + size;
546 }
547
548 /* Bitstream reader API docs:
549 name
550     abritary name which is used as prefix for the internal variables
551
552 gb
553     getbitcontext
554
555 OPEN_READER(name, gb)
556     loads gb into local variables
557
558 CLOSE_READER(name, gb)
559     stores local vars in gb
560
561 UPDATE_CACHE(name, gb)
562     refills the internal cache from the bitstream
563     after this call at least MIN_CACHE_BITS will be available,
564
565 GET_CACHE(name, gb)
566     will output the contents of the internal cache, next bit is MSB of 32 or 64 bit (FIXME 64bit)
567
568 SHOW_UBITS(name, gb, num)
569     will return the nest num bits
570
571 SHOW_SBITS(name, gb, num)
572     will return the nest num bits and do sign extension
573
574 SKIP_BITS(name, gb, num)
575     will skip over the next num bits
576     note, this is equinvalent to SKIP_CACHE; SKIP_COUNTER
577
578 SKIP_CACHE(name, gb, num)
579     will remove the next num bits from the cache (note SKIP_COUNTER MUST be called before UPDATE_CACHE / CLOSE_READER)
580
581 SKIP_COUNTER(name, gb, num)
582     will increment the internal bit counter (see SKIP_CACHE & SKIP_BITS)
583
584 LAST_SKIP_CACHE(name, gb, num)
585     will remove the next num bits from the cache if it is needed for UPDATE_CACHE otherwise it will do nothing
586
587 LAST_SKIP_BITS(name, gb, num)
588     is equinvalent to SKIP_LAST_CACHE; SKIP_COUNTER
589
590 for examples see get_bits, show_bits, skip_bits, get_vlc
591 */
592
593 static inline int unaligned32_be(const void *v)
594 {
595 #ifdef CONFIG_ALIGN
596         const uint8_t *p=v;
597         return (((p[0]<<8) | p[1])<<16) | (p[2]<<8) | (p[3]);
598 #else
599         return be2me_32( unaligned32(v)); //original
600 #endif
601 }
602
603 #ifdef ALT_BITSTREAM_READER
604 #   define MIN_CACHE_BITS 25
605
606 #   define OPEN_READER(name, gb)\
607         int name##_index= (gb)->index;\
608         int name##_cache= 0;\
609
610 #   define CLOSE_READER(name, gb)\
611         (gb)->index= name##_index;\
612
613 #   define UPDATE_CACHE(name, gb)\
614         name##_cache= unaligned32_be( ((uint8_t *)(gb)->buffer)+(name##_index>>3) ) << (name##_index&0x07);\
615
616 #   define SKIP_CACHE(name, gb, num)\
617         name##_cache <<= (num);\
618
619 // FIXME name?
620 #   define SKIP_COUNTER(name, gb, num)\
621         name##_index += (num);\
622
623 #   define SKIP_BITS(name, gb, num)\
624         {\
625             SKIP_CACHE(name, gb, num)\
626             SKIP_COUNTER(name, gb, num)\
627         }\
628
629 #   define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num)
630 #   define LAST_SKIP_CACHE(name, gb, num) ;
631
632 #   define SHOW_UBITS(name, gb, num)\
633         NEG_USR32(name##_cache, num)
634
635 #   define SHOW_SBITS(name, gb, num)\
636         NEG_SSR32(name##_cache, num)
637
638 #   define GET_CACHE(name, gb)\
639         ((uint32_t)name##_cache)
640
641 static inline int get_bits_count(GetBitContext *s){
642     return s->index;
643 }
644 #elif defined LIBMPEG2_BITSTREAM_READER
645 //libmpeg2 like reader
646
647 #   define MIN_CACHE_BITS 17
648
649 #   define OPEN_READER(name, gb)\
650         int name##_bit_count=(gb)->bit_count;\
651         int name##_cache= (gb)->cache;\
652         uint8_t * name##_buffer_ptr=(gb)->buffer_ptr;\
653
654 #   define CLOSE_READER(name, gb)\
655         (gb)->bit_count= name##_bit_count;\
656         (gb)->cache= name##_cache;\
657         (gb)->buffer_ptr= name##_buffer_ptr;\
658
659 #ifdef LIBMPEG2_BITSTREAM_READER_HACK
660
661 #   define UPDATE_CACHE(name, gb)\
662     if(name##_bit_count >= 0){\
663         name##_cache+= (int)be2me_16(*(uint16_t*)name##_buffer_ptr) << name##_bit_count;\
664         ((uint16_t*)name##_buffer_ptr)++;\
665         name##_bit_count-= 16;\
666     }\
667
668 #else
669
670 #   define UPDATE_CACHE(name, gb)\
671     if(name##_bit_count >= 0){\
672         name##_cache+= ((name##_buffer_ptr[0]<<8) + name##_buffer_ptr[1]) << name##_bit_count;\
673         name##_buffer_ptr+=2;\
674         name##_bit_count-= 16;\
675     }\
676
677 #endif
678
679 #   define SKIP_CACHE(name, gb, num)\
680         name##_cache <<= (num);\
681
682 #   define SKIP_COUNTER(name, gb, num)\
683         name##_bit_count += (num);\
684
685 #   define SKIP_BITS(name, gb, num)\
686         {\
687             SKIP_CACHE(name, gb, num)\
688             SKIP_COUNTER(name, gb, num)\
689         }\
690
691 #   define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num)
692 #   define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num)
693
694 #   define SHOW_UBITS(name, gb, num)\
695         NEG_USR32(name##_cache, num)
696
697 #   define SHOW_SBITS(name, gb, num)\
698         NEG_SSR32(name##_cache, num)
699
700 #   define GET_CACHE(name, gb)\
701         ((uint32_t)name##_cache)
702
703 static inline int get_bits_count(GetBitContext *s){
704     return (s->buffer_ptr - s->buffer)*8 - 16 + s->bit_count;
705 }
706
707 #elif defined A32_BITSTREAM_READER
708
709 #   define MIN_CACHE_BITS 32
710
711 #   define OPEN_READER(name, gb)\
712         int name##_bit_count=(gb)->bit_count;\
713         uint32_t name##_cache0= (gb)->cache0;\
714         uint32_t name##_cache1= (gb)->cache1;\
715         uint32_t * name##_buffer_ptr=(gb)->buffer_ptr;\
716
717 #   define CLOSE_READER(name, gb)\
718         (gb)->bit_count= name##_bit_count;\
719         (gb)->cache0= name##_cache0;\
720         (gb)->cache1= name##_cache1;\
721         (gb)->buffer_ptr= name##_buffer_ptr;\
722
723 #   define UPDATE_CACHE(name, gb)\
724     if(name##_bit_count > 0){\
725         const uint32_t next= be2me_32( *name##_buffer_ptr );\
726         name##_cache0 |= NEG_USR32(next,name##_bit_count);\
727         name##_cache1 |= next<<name##_bit_count;\
728         name##_buffer_ptr++;\
729         name##_bit_count-= 32;\
730     }\
731
732 #ifdef ARCH_X86
733 #   define SKIP_CACHE(name, gb, num)\
734         asm(\
735             "shldl %2, %1, %0           \n\t"\
736             "shll %2, %1                \n\t"\
737             : "+r" (name##_cache0), "+r" (name##_cache1)\
738             : "Ic" ((uint8_t)num)\
739            );
740 #else
741 #   define SKIP_CACHE(name, gb, num)\
742         name##_cache0 <<= (num);\
743         name##_cache0 |= NEG_USR32(name##_cache1,num);\
744         name##_cache1 <<= (num);
745 #endif
746
747 #   define SKIP_COUNTER(name, gb, num)\
748         name##_bit_count += (num);\
749
750 #   define SKIP_BITS(name, gb, num)\
751         {\
752             SKIP_CACHE(name, gb, num)\
753             SKIP_COUNTER(name, gb, num)\
754         }\
755
756 #   define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num)
757 #   define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num)
758
759 #   define SHOW_UBITS(name, gb, num)\
760         NEG_USR32(name##_cache0, num)
761
762 #   define SHOW_SBITS(name, gb, num)\
763         NEG_SSR32(name##_cache0, num)
764
765 #   define GET_CACHE(name, gb)\
766         (name##_cache0)
767
768 static inline int get_bits_count(GetBitContext *s){
769     return ((uint8_t*)s->buffer_ptr - s->buffer)*8 - 32 + s->bit_count;
770 }
771
772 #endif
773
774 /**
775  * read mpeg1 dc style vlc (sign bit + mantisse with no MSB).
776  * if MSB not set it is negative 
777  * @param n length in bits
778  * @author BERO  
779  */
780 static inline int get_xbits(GetBitContext *s, int n){
781     register int tmp;
782     register int32_t cache;
783     OPEN_READER(re, s)
784     UPDATE_CACHE(re, s)
785     cache = GET_CACHE(re,s);
786     if ((int32_t)cache<0) { //MSB=1
787         tmp = NEG_USR32(cache,n);
788     } else {
789     //   tmp = (-1<<n) | NEG_USR32(cache,n) + 1; mpeg12.c algo
790     //   tmp = - (NEG_USR32(cache,n) ^ ((1 << n) - 1)); h263.c algo
791         tmp = - NEG_USR32(~cache,n);
792     }
793     LAST_SKIP_BITS(re, s, n)
794     CLOSE_READER(re, s)
795     return tmp;
796 }
797
798 static inline int get_sbits(GetBitContext *s, int n){
799     register int tmp;
800     OPEN_READER(re, s)
801     UPDATE_CACHE(re, s)
802     tmp= SHOW_SBITS(re, s, n);
803     LAST_SKIP_BITS(re, s, n)
804     CLOSE_READER(re, s)
805     return tmp;
806 }
807
808 /**
809  * reads 0-17 bits.
810  * Note, the alt bitstream reader can read upto 25 bits, but the libmpeg2 reader cant
811  */
812 static inline unsigned int get_bits(GetBitContext *s, int n){
813     register int tmp;
814     OPEN_READER(re, s)
815     UPDATE_CACHE(re, s)
816     tmp= SHOW_UBITS(re, s, n);
817     LAST_SKIP_BITS(re, s, n)
818     CLOSE_READER(re, s)
819     return tmp;
820 }
821
822 unsigned int get_bits_long(GetBitContext *s, int n);
823
824 /**
825  * shows 0-17 bits.
826  * Note, the alt bitstream reader can read upto 25 bits, but the libmpeg2 reader cant
827  */
828 static inline unsigned int show_bits(GetBitContext *s, int n){
829     register int tmp;
830     OPEN_READER(re, s)
831     UPDATE_CACHE(re, s)
832     tmp= SHOW_UBITS(re, s, n);
833 //    CLOSE_READER(re, s)
834     return tmp;
835 }
836
837 unsigned int show_bits_long(GetBitContext *s, int n);
838
839 static inline void skip_bits(GetBitContext *s, int n){
840  //Note gcc seems to optimize this to s->index+=n for the ALT_READER :))
841     OPEN_READER(re, s)
842     UPDATE_CACHE(re, s)
843     LAST_SKIP_BITS(re, s, n)
844     CLOSE_READER(re, s)
845 }
846
847 static inline unsigned int get_bits1(GetBitContext *s){
848 #ifdef ALT_BITSTREAM_READER
849     int index= s->index;
850     uint8_t result= s->buffer[ index>>3 ];
851     result<<= (index&0x07);
852     result>>= 8 - 1;
853     index++;
854     s->index= index;
855
856     return result;
857 #else
858     return get_bits(s, 1);
859 #endif
860 }
861
862 static inline unsigned int show_bits1(GetBitContext *s){
863     return show_bits(s, 1);
864 }
865
866 static inline void skip_bits1(GetBitContext *s){
867     skip_bits(s, 1);
868 }
869
870 /**
871  * init GetBitContext.
872  * @param buffer bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE bytes larger then the actual read bits
873  * because some optimized bitstream readers read 32 or 64 bit at once and could read over the end
874  * @param bit_size the size of the buffer in bits
875  */
876 static inline void init_get_bits(GetBitContext *s,
877                    const uint8_t *buffer, int bit_size)
878 {
879     const int buffer_size= (bit_size+7)>>3;
880
881     s->buffer= buffer;
882     s->size_in_bits= bit_size;
883     s->buffer_end= buffer + buffer_size;
884 #ifdef ALT_BITSTREAM_READER
885     s->index=0;
886 #elif defined LIBMPEG2_BITSTREAM_READER
887 #ifdef LIBMPEG2_BITSTREAM_READER_HACK
888   if ((int)buffer&1) {
889      /* word alignment */
890     s->cache = (*buffer++)<<24;
891     s->buffer_ptr = buffer;
892     s->bit_count = 16-8;
893   } else
894 #endif
895   {
896     s->buffer_ptr = buffer;
897     s->bit_count = 16;
898     s->cache = 0;
899   }
900 #elif defined A32_BITSTREAM_READER
901     s->buffer_ptr = (uint32_t*)buffer;
902     s->bit_count = 32;
903     s->cache0 = 0;
904     s->cache1 = 0;
905 #endif
906     {
907         OPEN_READER(re, s)
908         UPDATE_CACHE(re, s)
909         UPDATE_CACHE(re, s)
910         CLOSE_READER(re, s)
911     }
912 #ifdef A32_BITSTREAM_READER
913     s->cache1 = 0;
914 #endif
915 }
916
917 static inline int get_bits_left(GetBitContext *s)
918 {
919     return s->size_in_bits - get_bits_count(s);
920 }
921
922 static inline int get_bits_size(GetBitContext *s)
923 {
924     return s->size_in_bits;
925 }
926
927 int check_marker(GetBitContext *s, const char *msg);
928 void align_get_bits(GetBitContext *s);
929 int init_vlc(VLC *vlc, int nb_bits, int nb_codes,
930              const void *bits, int bits_wrap, int bits_size,
931              const void *codes, int codes_wrap, int codes_size);
932 void free_vlc(VLC *vlc);
933
934 /**
935  *
936  * if the vlc code is invalid and max_depth=1 than no bits will be removed
937  * if the vlc code is invalid and max_depth>1 than the number of bits removed
938  * is undefined
939  */
940 #define GET_VLC(code, name, gb, table, bits, max_depth)\
941 {\
942     int n, index, nb_bits;\
943 \
944     index= SHOW_UBITS(name, gb, bits);\
945     code = table[index][0];\
946     n    = table[index][1];\
947 \
948     if(max_depth > 1 && n < 0){\
949         LAST_SKIP_BITS(name, gb, bits)\
950         UPDATE_CACHE(name, gb)\
951 \
952         nb_bits = -n;\
953 \
954         index= SHOW_UBITS(name, gb, nb_bits) + code;\
955         code = table[index][0];\
956         n    = table[index][1];\
957         if(max_depth > 2 && n < 0){\
958             LAST_SKIP_BITS(name, gb, nb_bits)\
959             UPDATE_CACHE(name, gb)\
960 \
961             nb_bits = -n;\
962 \
963             index= SHOW_UBITS(name, gb, nb_bits) + code;\
964             code = table[index][0];\
965             n    = table[index][1];\
966         }\
967     }\
968     SKIP_BITS(name, gb, n)\
969 }
970
971 #define GET_RL_VLC(level, run, name, gb, table, bits, max_depth)\
972 {\
973     int n, index, nb_bits;\
974 \
975     index= SHOW_UBITS(name, gb, bits);\
976     level = table[index].level;\
977     n     = table[index].len;\
978 \
979     if(max_depth > 1 && n < 0){\
980         LAST_SKIP_BITS(name, gb, bits)\
981         UPDATE_CACHE(name, gb)\
982 \
983         nb_bits = -n;\
984 \
985         index= SHOW_UBITS(name, gb, nb_bits) + level;\
986         level = table[index].level;\
987         n     = table[index].len;\
988     }\
989     run= table[index].run;\
990     SKIP_BITS(name, gb, n)\
991 }
992
993 // deprecated, dont use get_vlc for new code, use get_vlc2 instead or use GET_VLC directly
994 static inline int get_vlc(GetBitContext *s, VLC *vlc)
995 {
996     int code;
997     VLC_TYPE (*table)[2]= vlc->table;
998     
999     OPEN_READER(re, s)
1000     UPDATE_CACHE(re, s)
1001
1002     GET_VLC(code, re, s, table, vlc->bits, 3)    
1003
1004     CLOSE_READER(re, s)
1005     return code;
1006 }
1007
1008 /**
1009  * parses a vlc code, faster then get_vlc()
1010  * @param bits is the number of bits which will be read at once, must be 
1011  *             identical to nb_bits in init_vlc()
1012  * @param max_depth is the number of times bits bits must be readed to completly
1013  *                  read the longest vlc code 
1014  *                  = (max_vlc_length + bits - 1) / bits
1015  */
1016 static always_inline int get_vlc2(GetBitContext *s, VLC_TYPE (*table)[2],
1017                                   int bits, int max_depth)
1018 {
1019     int code;
1020     
1021     OPEN_READER(re, s)
1022     UPDATE_CACHE(re, s)
1023
1024     GET_VLC(code, re, s, table, bits, max_depth)
1025
1026     CLOSE_READER(re, s)
1027     return code;
1028 }
1029
1030 //#define TRACE
1031
1032 #ifdef TRACE
1033
1034 static inline void print_bin(int bits, int n){
1035     int i;
1036     
1037     for(i=n-1; i>=0; i--){
1038         printf("%d", (bits>>i)&1);
1039     }
1040     for(i=n; i<24; i++)
1041         printf(" ");
1042 }
1043
1044 static inline int get_bits_trace(GetBitContext *s, int n, char *file, char *func, int line){
1045     int r= get_bits(s, n);
1046     
1047     print_bin(r, n);
1048     printf("%5d %2d %3d bit @%5d in %s %s:%d\n", r, n, r, get_bits_count(s)-n, file, func, line);
1049     return r;
1050 }
1051 static inline int get_vlc_trace(GetBitContext *s, VLC_TYPE (*table)[2], int bits, int max_depth, char *file, char *func, int line){
1052     int show= show_bits(s, 24);
1053     int pos= get_bits_count(s);
1054     int r= get_vlc2(s, table, bits, max_depth);
1055     int len= get_bits_count(s) - pos;
1056     int bits2= show>>(24-len);
1057     
1058     print_bin(bits2, len);
1059     
1060     printf("%5d %2d %3d vlc @%5d in %s %s:%d\n", bits2, len, r, pos, file, func, line);
1061     return r;
1062 }
1063 static inline int get_xbits_trace(GetBitContext *s, int n, char *file, char *func, int line){
1064     int show= show_bits(s, n);
1065     int r= get_xbits(s, n);
1066     
1067     print_bin(show, n);
1068     printf("%5d %2d %3d xbt @%5d in %s %s:%d\n", show, n, r, get_bits_count(s)-n, file, func, line);
1069     return r;
1070 }
1071
1072 #define get_bits(s, n)  get_bits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__)
1073 #define get_bits1(s)    get_bits_trace(s, 1, __FILE__, __PRETTY_FUNCTION__, __LINE__)
1074 #define get_xbits(s, n) get_xbits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__)
1075 #define get_vlc(s, vlc)            get_vlc_trace(s, (vlc)->table, (vlc)->bits, 3, __FILE__, __PRETTY_FUNCTION__, __LINE__)
1076 #define get_vlc2(s, tab, bits, max) get_vlc_trace(s, tab, bits, max, __FILE__, __PRETTY_FUNCTION__, __LINE__)
1077
1078 #define tprintf printf
1079
1080 #else //TRACE
1081 #define tprintf(...) {}
1082 #endif
1083
1084 /* define it to include statistics code (useful only for optimizing
1085    codec efficiency */
1086 //#define STATS
1087
1088 #ifdef STATS
1089
1090 enum {
1091     ST_UNKNOWN,
1092     ST_DC,
1093     ST_INTRA_AC,
1094     ST_INTER_AC,
1095     ST_INTRA_MB,
1096     ST_INTER_MB,
1097     ST_MV,
1098     ST_NB,
1099 };
1100
1101 extern int st_current_index;
1102 extern unsigned int st_bit_counts[ST_NB];
1103 extern unsigned int st_out_bit_counts[ST_NB];
1104
1105 void print_stats(void);
1106 #endif
1107
1108 /* misc math functions */
1109 extern const uint8_t ff_log2_tab[256];
1110
1111 static inline int av_log2(unsigned int v)
1112 {
1113     int n;
1114
1115     n = 0;
1116     if (v & 0xffff0000) {
1117         v >>= 16;
1118         n += 16;
1119     }
1120     if (v & 0xff00) {
1121         v >>= 8;
1122         n += 8;
1123     }
1124     n += ff_log2_tab[v];
1125
1126     return n;
1127 }
1128
1129 static inline int av_log2_16bit(unsigned int v)
1130 {
1131     int n;
1132
1133     n = 0;
1134     if (v & 0xff00) {
1135         v >>= 8;
1136         n += 8;
1137     }
1138     n += ff_log2_tab[v];
1139
1140     return n;
1141 }
1142
1143 /* median of 3 */
1144 static inline int mid_pred(int a, int b, int c)
1145 {
1146 #if 0
1147     int t= (a-b)&((a-b)>>31);
1148     a-=t;
1149     b+=t;
1150     b-= (b-c)&((b-c)>>31);
1151     b+= (a-b)&((a-b)>>31);
1152
1153     return b;
1154 #else
1155     if(a>b){
1156         if(c>b){
1157             if(c>a) b=a;
1158             else    b=c;
1159         }
1160     }else{
1161         if(b>c){
1162             if(c>a) b=c;
1163             else    b=a;
1164         }
1165     }
1166     return b;
1167 #endif
1168 }
1169
1170 static inline int clip(int a, int amin, int amax)
1171 {
1172     if (a < amin)
1173         return amin;
1174     else if (a > amax)
1175         return amax;
1176     else
1177         return a;
1178 }
1179
1180 /* math */
1181 extern const uint8_t ff_sqrt_tab[128];
1182
1183 int64_t ff_gcd(int64_t a, int64_t b);
1184
1185 static inline int ff_sqrt(int a)
1186 {
1187     int ret=0;
1188     int s;
1189     int ret_sq=0;
1190     
1191     if(a<128) return ff_sqrt_tab[a];
1192     
1193     for(s=15; s>=0; s--){
1194         int b= ret_sq + (1<<(s*2)) + (ret<<s)*2;
1195         if(b<=a){
1196             ret_sq=b;
1197             ret+= 1<<s;
1198         }
1199     }
1200     return ret;
1201 }
1202
1203 /**
1204  * converts fourcc string to int
1205  */
1206 static inline int ff_get_fourcc(const char *s){
1207     assert( strlen(s)==4 );
1208
1209     return (s[0]) + (s[1]<<8) + (s[2]<<16) + (s[3]<<24);
1210 }
1211
1212 #define MKTAG(a,b,c,d) (a | (b << 8) | (c << 16) | (d << 24))
1213 #define MKBETAG(a,b,c,d) (d | (c << 8) | (b << 16) | (a << 24))
1214
1215
1216 #ifdef ARCH_X86
1217 #define MASK_ABS(mask, level)\
1218             asm volatile(\
1219                 "cdq                    \n\t"\
1220                 "xorl %1, %0            \n\t"\
1221                 "subl %1, %0            \n\t"\
1222                 : "+a" (level), "=&d" (mask)\
1223             );
1224 #else
1225 #define MASK_ABS(mask, level)\
1226             mask= level>>31;\
1227             level= (level^mask)-mask;
1228 #endif
1229
1230
1231 #if __CPU__ >= 686 && !defined(RUNTIME_CPUDETECT)
1232 #define COPY3_IF_LT(x,y,a,b,c,d)\
1233 asm volatile (\
1234     "cmpl %0, %3        \n\t"\
1235     "cmovl %3, %0       \n\t"\
1236     "cmovl %4, %1       \n\t"\
1237     "cmovl %5, %2       \n\t"\
1238     : "+r" (x), "+r" (a), "+r" (c)\
1239     : "r" (y), "r" (b), "r" (d)\
1240 );
1241 #else
1242 #define COPY3_IF_LT(x,y,a,b,c,d)\
1243 if((y)<(x)){\
1244      (x)=(y);\
1245      (a)=(b);\
1246      (c)=(d);\
1247 }
1248 #endif
1249
1250 #ifdef ARCH_X86
1251 static inline long long rdtsc()
1252 {
1253         long long l;
1254         asm volatile(   "rdtsc\n\t"
1255                 : "=A" (l)
1256         );
1257         return l;
1258 }
1259
1260 #define START_TIMER \
1261 uint64_t tend;\
1262 uint64_t tstart= rdtsc();\
1263
1264 #define STOP_TIMER(id) \
1265 tend= rdtsc();\
1266 {\
1267   static uint64_t tsum=0;\
1268   static int tcount=0;\
1269   static int tskip_count=0;\
1270   if(tcount<2 || tend - tstart < 8*tsum/tcount){\
1271       tsum+= tend - tstart;\
1272       tcount++;\
1273   }else\
1274       tskip_count++;\
1275   if(256*256*256*64%(tcount+tskip_count)==0){\
1276       av_log(NULL, AV_LOG_DEBUG, "%Ld dezicycles in %s, %d runs, %d skips\n", tsum*10/tcount, id, tcount, tskip_count);\
1277   }\
1278 }
1279 #endif
1280
1281 #define CLAMP_TO_8BIT(d) ((d > 0xff) ? 0xff : (d < 0) ? 0 : d)
1282
1283 /* avoid usage of various functions */
1284 #define malloc please_use_av_malloc
1285 #define free please_use_av_free
1286 #define realloc please_use_av_realloc
1287 #if !(defined(LIBAVFORMAT_BUILD) || defined(_FRAMEHOOK_H))
1288 #define printf please_use_av_log
1289 #define fprintf please_use_av_log
1290 #endif
1291
1292 #define CHECKED_ALLOCZ(p, size)\
1293 {\
1294     p= av_mallocz(size);\
1295     if(p==NULL && (size)!=0){\
1296         perror("malloc");\
1297         goto fail;\
1298     }\
1299 }
1300
1301 #endif /* HAVE_AV_CONFIG_H */
1302
1303 #endif /* COMMON_H */