X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fcommon.h;h=1d0be032436f60129f7822706abeb3d5e2b80178;hb=d5a21172283572af587b3d939eba0091484d3263;hp=35c04a875858e51a6c4151a9f7e8117a28078465;hpb=cceabc8656118f2a5478a17264df434a63838691;p=ffmpeg

diff --git a/libavcodec/common.h b/libavcodec/common.h
index 35c04a87585..1d0be032436 100644
--- a/libavcodec/common.h
+++ b/libavcodec/common.h
@@ -1,11 +1,13 @@
+/**
+ * @file common.h
+ * common internal api header.
+ */
+
 #ifndef COMMON_H
 #define COMMON_H
 
-#define FFMPEG_VERSION_INT 0x000406
-#define FFMPEG_VERSION     "0.4.6"
-
 #if defined(WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
-#define CONFIG_WIN32
+#    define CONFIG_WIN32
 #endif
 
 //#define ALT_BITSTREAM_WRITER
@@ -15,155 +17,184 @@
 //#define LIBMPEG2_BITSTREAM_READER
 //#define A32_BITSTREAM_READER
 
-#ifdef ARCH_ALPHA
-#define ALT_BITSTREAM_READER
-#endif
-
-//#define ALIGNED_BITSTREAM
-#define FAST_GET_FIRST_VLC
-//#define DUMP_STREAM
-
 #ifdef HAVE_AV_CONFIG_H
 /* only include the following when compiling package */
-#include "config.h"
+#    include "config.h"
+
+#    include <stdlib.h>
+#    include <stdio.h>
+#    include <string.h>
+#    ifndef __BEOS__
+#        include <errno.h>
+#    else
+#        include "berrno.h"
+#    endif
+#    include <math.h>
+
+#    ifndef ENODATA
+#        define ENODATA  61
+#    endif
+
+#ifndef M_PI
+#define M_PI    3.14159265358979323846
+#endif
 
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <errno.h>
-#include <math.h>
+#include <stddef.h>
+#ifndef offsetof
+# define offsetof(T,F) ((unsigned int)((char *)&((T *)0)->F))
+#endif
 
-#ifndef ENODATA
-#define ENODATA  61
+#define AVOPTION_CODEC_BOOL(name, help, field) \
+    { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_BOOL }
+#define AVOPTION_CODEC_DOUBLE(name, help, field, minv, maxv, defval) \
+    { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_DOUBLE, minv, maxv, defval }
+#define AVOPTION_CODEC_FLAG(name, help, field, flag, defval) \
+    { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_FLAG, flag, 0, defval }
+#define AVOPTION_CODEC_INT(name, help, field, minv, maxv, defval) \
+    { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_INT, minv, maxv, defval }
+#define AVOPTION_CODEC_STRING(name, help, field, str, val) \
+    { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_STRING, .defval = val, .defstr = str }
+#define AVOPTION_CODEC_RCOVERRIDE(name, help, field) \
+    { name, help, offsetof(AVCodecContext, field), FF_OPT_TYPE_RCOVERRIDE, .defval = 0, .defstr = NULL }
+#define AVOPTION_SUB(ptr) { .name = NULL, .help = (const char*)ptr }
+#define AVOPTION_END() AVOPTION_SUB(NULL)
+
+struct AVOption;
+#ifdef HAVE_MMX
+extern const struct AVOption avoptions_common[3 + 5];
+#else
+extern const struct AVOption avoptions_common[3];
 #endif
+extern const struct AVOption avoptions_workaround_bug[11];
 
 #endif /* HAVE_AV_CONFIG_H */
 
 /* Suppress restrict if it was not defined in config.h.  */
 #ifndef restrict
-#define restrict
+#    define restrict
+#endif
+
+#if defined(__GNUC__) && (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ > 0)
+#    define always_inline __attribute__((always_inline)) inline
+#else
+#    define always_inline inline
 #endif
 
 #ifdef CONFIG_WIN32
 
 /* windows */
 
-typedef unsigned short UINT16;
-typedef signed short INT16;
-typedef unsigned char UINT8;
-typedef unsigned int UINT32;
-typedef unsigned __int64 UINT64;
-typedef signed char INT8;
-typedef signed int INT32;
-typedef signed __int64 INT64;
-
-typedef UINT8 uint8_t;
-typedef INT8 int8_t;
-typedef UINT16 uint16_t;
-typedef INT16 int16_t;
-typedef UINT32 uint32_t;
-typedef INT32 int32_t;
-typedef UINT64 uint64_t;
-typedef INT64 int64_t;
-
-#ifndef __MINGW32__
-#define INT64_C(c)     (c ## i64)
-#define UINT64_C(c)    (c ## i64)
-
-#define inline __inline
+typedef unsigned short uint16_t;
+typedef signed short int16_t;
+typedef unsigned char uint8_t;
+typedef unsigned int uint32_t;
+typedef unsigned __int64 uint64_t;
+typedef signed char int8_t;
+typedef signed int int32_t;
+typedef signed __int64 int64_t;
 
-#else
-#define INT64_C(c)     (c ## LL)
-#define UINT64_C(c)    (c ## ULL)
-#endif /* __MINGW32__ */
+#    ifndef __MINGW32__
+#        define int64_t_C(c)     (c ## i64)
+#        define uint64_t_C(c)    (c ## i64)
 
-#define M_PI    3.14159265358979323846
-#define M_SQRT2 1.41421356237309504880  /* sqrt(2) */
+#        define inline __inline
 
-#ifdef _DEBUG
-#define DEBUG
-#endif
+#    else
+#        define int64_t_C(c)     (c ## LL)
+#        define uint64_t_C(c)    (c ## ULL)
+#    endif /* __MINGW32__ */
 
-#define snprintf _snprintf
+#    ifdef _DEBUG
+#        define DEBUG
+#    endif
 
-#else /* CONFIG_WIN32 */
+#    define snprintf _snprintf
+#    define vsnprintf _vsnprintf
 
-/* unix */
+/* CONFIG_WIN32 end */
+#elif defined (CONFIG_OS2)
+/* OS/2 EMX */
 
 #include <inttypes.h>
 
-#ifndef __WINE_WINDEF16_H
-/* workaround for typedef conflict in MPlayer (wine typedefs) */
-typedef unsigned short UINT16;
-typedef signed short INT16;
-#endif
-
-typedef unsigned char UINT8;
-typedef unsigned int UINT32;
-typedef unsigned long long UINT64;
-typedef signed char INT8;
-typedef signed int INT32;
-typedef signed long long INT64;
-
 #ifdef HAVE_AV_CONFIG_H
 
-#ifdef __FreeBSD__
-#include <sys/param.h>
-#endif
-
-#ifndef INT64_C
-#define INT64_C(c)     (c ## LL)
-#define UINT64_C(c)    (c ## ULL)
+#ifndef int64_t_C
+#define int64_t_C(c)     (c ## LL)
+#define uint64_t_C(c)    (c ## ULL)
 #endif
 
 #ifdef USE_FASTMEMCPY
 #include "fastmemcpy.h"
 #endif
 
+#include <float.h>
+
 #endif /* HAVE_AV_CONFIG_H */
 
-#endif /* !CONFIG_WIN32 */
+/* CONFIG_OS2 end */
+#else
+
+/* unix */
+
+#    include <inttypes.h>
+
+#    ifdef HAVE_AV_CONFIG_H
+#        ifndef int64_t_C
+#            define int64_t_C(c)     (c ## LL)
+#            define uint64_t_C(c)    (c ## ULL)
+#        endif
+
+#        ifdef USE_FASTMEMCPY
+#            include "fastmemcpy.h"
+#        endif
+#    endif /* HAVE_AV_CONFIG_H */
+
+#endif /* !CONFIG_WIN32 && !CONFIG_OS2 */
 
 #ifdef HAVE_AV_CONFIG_H
 
-#include "bswap.h"
+#    include "bswap.h"
 
-#if defined(__MINGW32__) || defined(__CYGWIN__) || \
-    defined(__OS2__) || defined (__OpenBSD__)
-#define MANGLE(a) "_" #a
-#else
-#define MANGLE(a) #a
-#endif
+#    if defined(__MINGW32__) || defined(__CYGWIN__) || \
+        defined(__OS2__) || defined (__OpenBSD__)
+#        define MANGLE(a) "_" #a
+#    else
+#        define MANGLE(a) #a
+#    endif
 
 /* debug stuff */
 
-#ifndef DEBUG
-#define NDEBUG
-#endif
-#include <assert.h>
+#    ifndef DEBUG
+#        define NDEBUG
+#    endif
+#    include <assert.h>
 
 /* dprintf macros */
-#if defined(CONFIG_WIN32) && !defined(__MINGW32__)
+#    if defined(CONFIG_WIN32) && !defined(__MINGW32__)
 
 inline void dprintf(const char* fmt,...) {}
 
-#else
+#    else
 
-#ifdef DEBUG
-#define dprintf(fmt,args...) printf(fmt, ## args)
-#else
-#define dprintf(fmt,args...)
-#endif
+#        ifdef DEBUG
+#            define dprintf(fmt,args...) printf(fmt, ## args)
+#        else
+#            define dprintf(fmt,args...)
+#        endif
 
-#endif /* !CONFIG_WIN32 */
+#    endif /* !CONFIG_WIN32 */
 
-#define av_abort()      do { fprintf(stderr, "Abort at %s:%d\n", __FILE__, __LINE__); abort(); } while (0)
+#    define av_abort()      do { fprintf(stderr, "Abort at %s:%d\n", __FILE__, __LINE__); abort(); } while (0)
 
+//rounded divison & shift
+#define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b))
 /* assume b>0 */
 #define ROUNDED_DIV(a,b) (((a)>0 ? (a) + ((b)>>1) : (a) - ((b)>>1))/(b))
 #define ABS(a) ((a) >= 0 ? (a) : (-(a)))
-#define MAX(a,b) ((a) > (b) ? (a) : (b))
-#define MIN(a,b) ((a) > (b) ? (b) : (a))
+
+#define FFMAX(a,b) ((a) > (b) ? (a) : (b))
+#define FFMIN(a,b) ((a) > (b) ? (b) : (a))
 
 #ifdef ARCH_X86
 // avoid +32 for shift optimization (gcc should do that ...)
@@ -182,75 +213,82 @@ static inline uint32_t NEG_USR32(uint32_t a, int8_t s){
     return a;
 }
 #else
-#define NEG_SSR32(a,s) ((( int32_t)(a))>>(32-(s)))
-#define NEG_USR32(a,s) (((uint32_t)(a))>>(32-(s)))
+#    define NEG_SSR32(a,s) ((( int32_t)(a))>>(32-(s)))
+#    define NEG_USR32(a,s) (((uint32_t)(a))>>(32-(s)))
 #endif
 
 /* bit output */
 
 struct PutBitContext;
 
-typedef void (*WriteDataFunc)(void *, UINT8 *, int);
+typedef void (*WriteDataFunc)(void *, uint8_t *, int);
 
 typedef struct PutBitContext {
 #ifdef ALT_BITSTREAM_WRITER
-    UINT8 *buf, *buf_end;
+    uint8_t *buf, *buf_end;
     int index;
 #else
-    UINT32 bit_buf;
+    uint32_t bit_buf;
     int bit_left;
-    UINT8 *buf, *buf_ptr, *buf_end;
+    uint8_t *buf, *buf_ptr, *buf_end;
 #endif
-    INT64 data_out_size; /* in bytes */
+    int64_t data_out_size; /* in bytes */
 } PutBitContext;
 
 void init_put_bits(PutBitContext *s, 
-                   UINT8 *buffer, int buffer_size,
+                   uint8_t *buffer, int buffer_size,
                    void *opaque,
-                   void (*write_data)(void *, UINT8 *, int));
+                   void (*write_data)(void *, uint8_t *, int));
 
-INT64 get_bit_count(PutBitContext *s); /* XXX: change function name */
+int64_t get_bit_count(PutBitContext *s); /* XXX: change function name */
 void align_put_bits(PutBitContext *s);
 void flush_put_bits(PutBitContext *s);
 void put_string(PutBitContext * pbc, char *s);
 
-/* jpeg specific put_bits */
-void jflush_put_bits(PutBitContext *s);
-
 /* bit input */
 
 typedef struct GetBitContext {
-    UINT8 *buffer, *buffer_end;
+    const uint8_t *buffer, *buffer_end;
 #ifdef ALT_BITSTREAM_READER
     int index;
 #elif defined LIBMPEG2_BITSTREAM_READER
-    UINT8 *buffer_ptr;
-    UINT32 cache;
+    uint8_t *buffer_ptr;
+    uint32_t cache;
     int bit_count;
 #elif defined A32_BITSTREAM_READER
-    UINT32 *buffer_ptr;
-    UINT32 cache0;
-    UINT32 cache1;
+    uint32_t *buffer_ptr;
+    uint32_t cache0;
+    uint32_t cache1;
     int bit_count;
 #endif
-    int size;
+    int size_in_bits;
 } GetBitContext;
 
 static inline int get_bits_count(GetBitContext *s);
 
-#define VLC_TYPE INT16
+#define VLC_TYPE int16_t
 
 typedef struct VLC {
     int bits;
-    VLC_TYPE (*table)[2]; // code, bits
+    VLC_TYPE (*table)[2]; ///< code, bits
     int table_size, table_allocated;
 } VLC;
 
+typedef struct RL_VLC_ELEM {
+    int16_t level;
+    int8_t len;
+    uint8_t run;
+} RL_VLC_ELEM;
+
+#ifdef ARCH_SPARC64
+#define UNALIGNED_STORES_ARE_BAD
+#endif
+
 /* used to avoid missaligned exceptions on some archs (alpha, ...) */
 #ifdef ARCH_X86
-#define unaligned32(a) (*(UINT32*)(a))
+#    define unaligned32(a) (*(uint32_t*)(a))
 #else
-#ifdef __GNUC__
+#    ifdef __GNUC__
 static inline uint32_t unaligned32(const void *v) {
     struct Unaligned {
 	uint32_t i;
@@ -258,15 +296,15 @@ static inline uint32_t unaligned32(const void *v) {
 
     return ((const struct Unaligned *) v)->i;
 }
-#elif defined(__DECC)
+#    elif defined(__DECC)
 static inline uint32_t unaligned32(const void *v) {
     return *(const __unaligned uint32_t *) v;
 }
-#else
+#    else
 static inline uint32_t unaligned32(const void *v) {
     return *(const uint32_t *) v;
 }
-#endif
+#    endif
 #endif //!ARCH_X86
 
 #ifndef ALT_BITSTREAM_WRITER
@@ -292,7 +330,15 @@ static inline void put_bits(PutBitContext *s, int n, unsigned int value)
     } else {
 	bit_buf<<=bit_left;
         bit_buf |= value >> (n - bit_left);
-        *(UINT32 *)s->buf_ptr = be2me_32(bit_buf);
+#ifdef UNALIGNED_STORES_ARE_BAD
+        if (3 & (int) s->buf_ptr) {
+            s->buf_ptr[0] = bit_buf >> 24;
+            s->buf_ptr[1] = bit_buf >> 16;
+            s->buf_ptr[2] = bit_buf >>  8;
+            s->buf_ptr[3] = bit_buf      ;
+        } else
+#endif
+        *(uint32_t *)s->buf_ptr = be2me_32(bit_buf);
         //printf("bitbuf = %08x\n", bit_buf);
         s->buf_ptr+=4;
 	bit_left+=32 - n;
@@ -308,8 +354,8 @@ static inline void put_bits(PutBitContext *s, int n, unsigned int value)
 #ifdef ALT_BITSTREAM_WRITER
 static inline void put_bits(PutBitContext *s, int n, unsigned int value)
 {
-#ifdef ALIGNED_BITSTREAM_WRITER
-#ifdef ARCH_X86
+#    ifdef ALIGNED_BITSTREAM_WRITER
+#        ifdef ARCH_X86
     asm volatile(
 	"movl %0, %%ecx			\n\t"
 	"xorl %%eax, %%eax		\n\t"
@@ -327,7 +373,7 @@ static inline void put_bits(PutBitContext *s, int n, unsigned int value)
 	: "r" (s->buf), "r" (n), "0" (s->index), "1" (value<<(-n))
 	: "%eax", "%ecx"
     );
-#else
+#        else
     int index= s->index;
     uint32_t *ptr= ((uint32_t *)s->buf)+(index>>5);
     
@@ -338,9 +384,9 @@ static inline void put_bits(PutBitContext *s, int n, unsigned int value)
 //if(n>24) printf("%d %d\n", n, value);
     index+= n;
     s->index= index;
-#endif
-#else //ALIGNED_BITSTREAM_WRITER
-#ifdef ARCH_X86
+#        endif
+#    else //ALIGNED_BITSTREAM_WRITER
+#        ifdef ARCH_X86
     asm volatile(
 	"movl $7, %%ecx			\n\t"
 	"andl %0, %%ecx			\n\t"
@@ -357,7 +403,7 @@ static inline void put_bits(PutBitContext *s, int n, unsigned int value)
 	: "r" (s->buf), "r" (n), "0" (s->index), "1" (value)
 	: "%ecx"
     );
-#else
+#        else
     int index= s->index;
     uint32_t *ptr= (uint32_t*)(((uint8_t *)s->buf)+(index>>3));
     
@@ -366,100 +412,12 @@ static inline void put_bits(PutBitContext *s, int n, unsigned int value)
 //if(n>24) printf("%d %d\n", n, value);
     index+= n;
     s->index= index;
-#endif
-#endif //!ALIGNED_BITSTREAM_WRITER
-}
-#endif
-
-#ifndef ALT_BITSTREAM_WRITER
-/* for jpeg : escape 0xff with 0x00 after it */
-static inline void jput_bits(PutBitContext *s, int n, unsigned int value)
-{
-    unsigned int bit_buf, b;
-    int bit_left, i;
-    
-    assert(n == 32 || value < (1U << n));
-
-    bit_buf = s->bit_buf;
-    bit_left = s->bit_left;
-
-    //printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf);
-    /* XXX: optimize */
-    if (n < bit_left) {
-        bit_buf = (bit_buf<<n) | value;
-        bit_left-=n;
-    } else {
-	bit_buf<<=bit_left;
-        bit_buf |= value >> (n - bit_left);
-        /* handle escape */
-        for(i=0;i<4;i++) {
-            b = (bit_buf >> 24);
-            *(s->buf_ptr++) = b;
-            if (b == 0xff)
-                *(s->buf_ptr++) = 0;
-            bit_buf <<= 8;
-        }
-
-	bit_left+= 32 - n;
-        bit_buf = value;
-    }
-    
-    s->bit_buf = bit_buf;
-    s->bit_left = bit_left;
+#        endif
+#    endif //!ALIGNED_BITSTREAM_WRITER
 }
 #endif
 
 
-#ifdef ALT_BITSTREAM_WRITER
-static inline void jput_bits(PutBitContext *s, int n, int value)
-{
-    int index= s->index;
-    uint32_t *ptr= (uint32_t*)(((uint8_t *)s->buf)+(index>>3));
-    int v= ptr[0];
-//if(n>24) printf("%d %d\n", n, value);
-    
-    v |= be2me_32(value<<(32-n-(index&7) ));
-    if(((v+0x01010101)^0xFFFFFFFF)&v&0x80808080)
-    {
-	/* handle idiotic (m)jpeg escapes */
-	uint8_t *bPtr= (uint8_t*)ptr;
-	int numChecked= ((index+n)>>3) - (index>>3);
-	
-	v= be2me_32(v);
-
-	*(bPtr++)= v>>24;
-	if((v&0xFF000000)==0xFF000000 && numChecked>0){
-		*(bPtr++)= 0x00;
-		index+=8;
-	}
-	*(bPtr++)= (v>>16)&0xFF;
-	if((v&0x00FF0000)==0x00FF0000 && numChecked>1){
-		*(bPtr++)= 0x00;
-		index+=8;
-	}
-	*(bPtr++)= (v>>8)&0xFF;
-	if((v&0x0000FF00)==0x0000FF00 && numChecked>2){
-		*(bPtr++)= 0x00;
-		index+=8;
-	}
-	*(bPtr++)= v&0xFF;
-	if((v&0x000000FF)==0x000000FF && numChecked>3){
-		*(bPtr++)= 0x00;
-		index+=8;
-	}
-	*((uint32_t*)bPtr)= 0;
-    }
-    else
-    {
-	ptr[0] = v;
-	ptr[1] = 0;
-    }
-
-    index+= n;
-    s->index= index;
- }
-#endif
-
 static inline uint8_t* pbBufPtr(PutBitContext *s)
 {
 #ifdef ALT_BITSTREAM_WRITER
@@ -723,16 +681,21 @@ static inline void skip_bits1(GetBitContext *s){
 }
 
 void init_get_bits(GetBitContext *s,
-                   UINT8 *buffer, int buffer_size);
+                   const uint8_t *buffer, int buffer_size);
 
-int check_marker(GetBitContext *s, char *msg);
+int check_marker(GetBitContext *s, const char *msg);
 void align_get_bits(GetBitContext *s);
 int init_vlc(VLC *vlc, int nb_bits, int nb_codes,
              const void *bits, int bits_wrap, int bits_size,
              const void *codes, int codes_wrap, int codes_size);
 void free_vlc(VLC *vlc);
 
-//note table will be trashed (pointer increased)
+/**
+ *
+ * if the vlc code is invalid and max_depth=1 than no bits will be removed
+ * if the vlc code is invalid and max_depth>1 than the number of bits removed
+ * is undefined
+ */
 #define GET_VLC(code, name, gb, table, bits, max_depth)\
 {\
     int n, index, nb_bits;\
@@ -746,9 +709,8 @@ void free_vlc(VLC *vlc);
         UPDATE_CACHE(name, gb)\
 \
         nb_bits = -n;\
-        table += code;\
 \
-        index= SHOW_UBITS(name, gb, nb_bits);\
+        index= SHOW_UBITS(name, gb, nb_bits) + code;\
         code = table[index][0];\
         n    = table[index][1];\
         if(max_depth > 2 && n < 0){\
@@ -756,9 +718,8 @@ void free_vlc(VLC *vlc);
             UPDATE_CACHE(name, gb)\
 \
             nb_bits = -n;\
-            table += code;\
 \
-            index= SHOW_UBITS(name, gb, nb_bits);\
+            index= SHOW_UBITS(name, gb, nb_bits) + code;\
             code = table[index][0];\
             n    = table[index][1];\
         }\
@@ -766,6 +727,29 @@ void free_vlc(VLC *vlc);
     SKIP_BITS(name, gb, n)\
 }
 
+#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth)\
+{\
+    int n, index, nb_bits;\
+\
+    index= SHOW_UBITS(name, gb, bits);\
+    level = table[index].level;\
+    n     = table[index].len;\
+\
+    if(max_depth > 1 && n < 0){\
+        LAST_SKIP_BITS(name, gb, bits)\
+        UPDATE_CACHE(name, gb)\
+\
+        nb_bits = -n;\
+\
+        index= SHOW_UBITS(name, gb, nb_bits) + level;\
+        level = table[index].level;\
+        n     = table[index].len;\
+    }\
+    run= table[index].run;\
+    SKIP_BITS(name, gb, n)\
+}
+
+// deprecated, dont use get_vlc for new code, use get_vlc2 instead or use GET_VLC directly
 static inline int get_vlc(GetBitContext *s, VLC *vlc)
 {
     int code;
@@ -780,6 +764,29 @@ static inline int get_vlc(GetBitContext *s, VLC *vlc)
     return code;
 }
 
+/**
+ * parses a vlc code, faster then get_vlc()
+ * @param bits is the number of bits which will be read at once, must be 
+ *             identical to nb_bits in init_vlc()
+ * @param max_depth is the number of times bits bits must be readed to completly
+ *                  read the longest vlc code 
+ *                  = (max_vlc_length + bits - 1) / bits
+ */
+static always_inline int get_vlc2(GetBitContext *s, VLC_TYPE (*table)[2],
+                                  int bits, int max_depth)
+{
+    int code;
+    
+    OPEN_READER(re, s)
+    UPDATE_CACHE(re, s)
+
+    GET_VLC(code, re, s, table, bits, max_depth)
+
+    CLOSE_READER(re, s)
+    return code;
+}
+
+
 /* define it to include statistics code (useful only for optimizing
    codec efficiency */
 //#define STATS
@@ -805,6 +812,7 @@ void print_stats(void);
 #endif
 
 /* misc math functions */
+extern const uint8_t ff_log2_tab[256];
 
 static inline int av_log2(unsigned int v)
 {
@@ -819,20 +827,26 @@ static inline int av_log2(unsigned int v)
         v >>= 8;
         n += 8;
     }
-    if (v & 0xf0) {
-        v >>= 4;
-        n += 4;
-    }
-    if (v & 0xc) {
-        v >>= 2;
-        n += 2;
-    }
-    if (v & 0x2) {
-        n++;
+    n += ff_log2_tab[v];
+
+    return n;
+}
+
+static inline int av_log2_16bit(unsigned int v)
+{
+    int n;
+
+    n = 0;
+    if (v & 0xff00) {
+        v >>= 8;
+        n += 8;
     }
+    n += ff_log2_tab[v];
+
     return n;
 }
 
+
 /* median of 3 */
 static inline int mid_pred(int a, int b, int c)
 {
@@ -862,14 +876,18 @@ static inline int clip(int a, int amin, int amax)
 }
 
 /* math */
-int ff_gcd(int a, int b);
+extern const uint8_t ff_sqrt_tab[128];
+
+int64_t ff_gcd(int64_t a, int64_t b);
 
 static inline int ff_sqrt(int a)
 {
     int ret=0;
     int s;
     int ret_sq=0;
-
+    
+    if(a<128) return ff_sqrt_tab[a];
+    
     for(s=15; s>=0; s--){
         int b= ret_sq + (1<<(s*2)) + (ret<<s)*2;
         if(b<=a){
@@ -879,6 +897,38 @@ static inline int ff_sqrt(int a)
     }
     return ret;
 }
+
+/**
+ * converts fourcc string to int
+ */
+static inline int ff_get_fourcc(const char *s){
+    assert( strlen(s)==4 );
+    
+    return (s[0]) + (s[1]<<8) + (s[2]<<16) + (s[3]<<24);
+}
+
+#define MKTAG(a,b,c,d) (a | (b << 8) | (c << 16) | (d << 24))
+#define MKBETAG(a,b,c,d) (d | (c << 8) | (b << 16) | (a << 24))
+
+
+void ff_float2fraction(int *nom_arg, int *denom_arg, double f, int max);
+
+
+#ifdef ARCH_X86
+#define MASK_ABS(mask, level)\
+            asm volatile(\
+		"cdq			\n\t"\
+		"xorl %1, %0		\n\t"\
+		"subl %1, %0		\n\t"\
+		: "+a" (level), "=&d" (mask)\
+	    );
+#else
+#define MASK_ABS(mask, level)\
+            mask= level>>31;\
+            level= (level^mask)-mask;
+#endif
+
+
 #if __CPU__ >= 686 && !defined(RUNTIME_CPUDETECT)
 #define COPY3_IF_LT(x,y,a,b,c,d)\
 asm volatile (\
@@ -900,6 +950,11 @@ if((y)<(x)){\
 
 #define CLAMP_TO_8BIT(d) ((d > 0xff) ? 0xff : (d < 0) ? 0 : d)
 
+/* avoid usage of various functions */
+#define malloc please_use_av_malloc
+#define free please_use_av_free
+#define realloc please_use_av_realloc
+
 #endif /* HAVE_AV_CONFIG_H */
 
 #endif /* COMMON_H */