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