+}+#    elif defined(__DECC)+#    define unaligned(x)                                        \+static inline uint##x##_t unaligned##x(const void *v) {         \+    return *(const __unaligned uint##x##_t *) v;                \+}+#    else+#    define unaligned(x)                                        \+static inline uint##x##_t unaligned##x(const void *v) {         \+    return *(const uint##x##_t *) v;                            \+}+#    endif+unaligned(16)+unaligned(32)+unaligned(64)+#undef unaligned+#endif /* defined(ARCH_X86) */++#ifndef ALT_BITSTREAM_WRITER+static inline void put_bits(PutBitContext *s, int n, unsigned int value)+{+    unsigned int bit_buf;+    int bit_left;++    //    printf("put_bits=%d %x\n", n, value);+   // 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);+#ifdef UNALIGNED_STORES_ARE_BAD+        if (3 & (intptr_t) 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;+        bit_buf = value;+    }++    s->bit_buf = bit_buf;+    s->bit_left = bit_left;+}+#endif+++#ifdef ALT_BITSTREAM_WRITER+static inline void put_bits(PutBitContext *s, int n, unsigned int value)+{+#    ifdef ALIGNED_BITSTREAM_WRITER+#        if defined(ARCH_X86)+    asm volatile(+        "movl %0, %%ecx                 \n\t"+        "xorl %%eax, %%eax              \n\t"+        "shrdl %%cl, %1, %%eax          \n\t"+        "shrl %%cl, %1                  \n\t"+        "movl %0, %%ecx                 \n\t"+        "shrl $3, %%ecx                 \n\t"+        "andl $0xFFFFFFFC, %%ecx        \n\t"+        "bswapl %1                      \n\t"+        "orl %1, (%2, %%ecx)            \n\t"+        "bswapl %%eax                   \n\t"+        "addl %3, %0                    \n\t"+        "movl %%eax, 4(%2, %%ecx)       \n\t"+        : "=&r" (s->index), "=&r" (value)+        : "r" (s->buf), "r" (n), "0" (s->index), "1" (value<<(-n))+        : "%eax", "%ecx"+    );+#        else+    int index= s->index;+    uint32_t *ptr= ((uint32_t *)s->buf)+(index>>5);++    value<<= 32-n;++    ptr[0] |= be2me_32(value>>(index&31));+    ptr[1]  = be2me_32(value<<(32-(index&31)));+//if(n>24) printf("%d %d\n", n, value);+    index+= n;+    s->index= index;+#        endif+#    else //ALIGNED_BITSTREAM_WRITER+#        if defined(ARCH_X86)+    asm volatile(+        "movl $7, %%ecx                 \n\t"+        "andl %0, %%ecx                 \n\t"+        "addl %3, %%ecx                 \n\t"+        "negl %%ecx                     \n\t"+        "shll %%cl, %1                  \n\t"+        "bswapl %1                      \n\t"+        "movl %0, %%ecx                 \n\t"+        "shrl $3, %%ecx                 \n\t"+        "orl %1, (%%ecx, %2)            \n\t"+        "addl %3, %0                    \n\t"+        "movl $0, 4(%%ecx, %2)          \n\t"+        : "=&r" (s->index), "=&r" (value)+        : "r" (s->buf), "r" (n), "0" (s->index), "1" (value)+        : "%ecx"+    );+#        else+    int index= s->index;+    uint32_t *ptr= (uint32_t*)(((uint8_t *)s->buf)+(index>>3));++    ptr[0] |= be2me_32(value<<(32-n-(index&7) ));+    ptr[1] = 0;+//if(n>24) printf("%d %d\n", n, value);+    index+= n;+    s->index= index;+#        endif+#    endif //!ALIGNED_BITSTREAM_WRITER+}+#endif+++static inline uint8_t* pbBufPtr(PutBitContext *s)+{+#ifdef ALT_BITSTREAM_WRITER+        return s->buf + (s->index>>3);+#else+        return s->buf_ptr;+#endif+}++/**+ *+ * PutBitContext must be flushed & aligned to a byte boundary before calling this.+ */+static inline void skip_put_bytes(PutBitContext *s, int n){+       // assert((put_bits_count(s)&7)==0);+#ifdef ALT_BITSTREAM_WRITER+        FIXME may need some cleaning of the buffer+        s->index += n<<3;+#else+       // assert(s->bit_left==32);+        s->buf_ptr += n;+#endif+}++/**+ * skips the given number of bits.+ * must only be used if the actual values in the bitstream dont matter+ */+static inline void skip_put_bits(PutBitContext *s, int n){+#ifdef ALT_BITSTREAM_WRITER+    s->index += n;+#else+    s->bit_left -= n;+    s->buf_ptr-= s->bit_left>>5;+    s->bit_left &= 31;+#endif+}++/**+ * Changes the end of the buffer.+ */+static inline void set_put_bits_buffer_size(PutBitContext *s, int size){+    s->buf_end= s->buf + size;+}++/* Bitstream reader API docs:+name+    abritary name which is used as prefix for the internal variables++gb+    getbitcontext++OPEN_READER(name, gb)+    loads gb into local variables++CLOSE_READER(name, gb)+    stores local vars in gb++UPDATE_CACHE(name, gb)+    refills the internal cache from the bitstream+    after this call at least MIN_CACHE_BITS will be available,++GET_CACHE(name, gb)+    will output the contents of the internal cache, next bit is MSB of 32 or 64 bit (FIXME 64bit)++SHOW_UBITS(name, gb, num)+    will return the next num bits++SHOW_SBITS(name, gb, num)+    will return the next num bits and do sign extension++SKIP_BITS(name, gb, num)+    will skip over the next num bits+    note, this is equivalent to SKIP_CACHE; SKIP_COUNTER++SKIP_CACHE(name, gb, num)+    will remove the next num bits from the cache (note SKIP_COUNTER MUST be called before UPDATE_CACHE / CLOSE_READER)++SKIP_COUNTER(name, gb, num)+    will increment the internal bit counter (see SKIP_CACHE & SKIP_BITS)++LAST_SKIP_CACHE(name, gb, num)+    will remove the next num bits from the cache if it is needed for UPDATE_CACHE otherwise it will do nothing++LAST_SKIP_BITS(name, gb, num)+    is equivalent to SKIP_LAST_CACHE; SKIP_COUNTER++for examples see get_bits, show_bits, skip_bits, get_vlc+*/++static inline int unaligned32_be(const void *v)+{+#ifdef CONFIG_ALIGN+        const uint8_t *p=v;+        return (((p[0]<<8) | p[1])<<16) | (p[2]<<8) | (p[3]);+#else+        return be2me_32( unaligned32(v)); //original+#endif+}++static inline int unaligned32_le(const void *v)+{+#ifdef CONFIG_ALIGN+       const uint8_t *p=v;+       return (((p[3]<<8) | p[2])<<16) | (p[1]<<8) | (p[0]);+#else+       return le2me_32( unaligned32(v)); //original+#endif+}++#ifdef ALT_BITSTREAM_READER+#   define MIN_CACHE_BITS 25++#   define OPEN_READER(name, gb)\+        int name##_index= (gb)->index;\+        int name##_cache= 0;\++#   define CLOSE_READER(name, gb)\+        (gb)->index= name##_index;\++# ifdef ALT_BITSTREAM_READER_LE+#   define UPDATE_CACHE(name, gb)\+        name##_cache= unaligned32_le( ((const uint8_t *)(gb)->buffer)+(name##_index>>3) ) >> (name##_index&0x07);\++#   define SKIP_CACHE(name, gb, num)\+        name##_cache >>= (num);+# else+#   define UPDATE_CACHE(name, gb)\+        name##_cache= unaligned32_be( ((const uint8_t *)(gb)->buffer)+(name##_index>>3) ) << (name##_index&0x07);\++#   define SKIP_CACHE(name, gb, num)\+        name##_cache <<= (num);+# endif++// FIXME name?+#   define SKIP_COUNTER(name, gb, num)\+        name##_index += (num);\++#   define SKIP_BITS(name, gb, num)\+        {\+            SKIP_CACHE(name, gb, num)\+            SKIP_COUNTER(name, gb, num)\+        }\++#   define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num)+#   define LAST_SKIP_CACHE(name, gb, num) ;++# ifdef ALT_BITSTREAM_READER_LE+#   define SHOW_UBITS(name, gb, num)\+        ((name##_cache) & (NEG_USR32(0xffffffff,num)))++#   define SHOW_SBITS(name, gb, num)\+        NEG_SSR32((name##_cache)<<(32-(num)), num)+# else+#   define SHOW_UBITS(name, gb, num)\+        NEG_USR32(name##_cache, num)++#   define SHOW_SBITS(name, gb, num)\+        NEG_SSR32(name##_cache, num)+# endif++#   define GET_CACHE(name, gb)\+        ((uint32_t)name##_cache)++static inline int get_bits_count(GetBitContext *s){+    return s->index;+}++static inline void skip_bits_long(GetBitContext *s, int n){+    s->index += n;+}++#elif defined LIBMPEG2_BITSTREAM_READER+//libmpeg2 like reader++#   define MIN_CACHE_BITS 17++#   define OPEN_READER(name, gb)\+        int name##_bit_count=(gb)->bit_count;\+        int name##_cache= (gb)->cache;\+        uint8_t * name##_buffer_ptr=(gb)->buffer_ptr;\++#   define CLOSE_READER(name, gb)\+        (gb)->bit_count= name##_bit_count;\+        (gb)->cache= name##_cache;\+        (gb)->buffer_ptr= name##_buffer_ptr;\++#ifdef LIBMPEG2_BITSTREAM_READER_HACK++#   define UPDATE_CACHE(name, gb)\+    if(name##_bit_count >= 0){\+        name##_cache+= (int)be2me_16(*(uint16_t*)name##_buffer_ptr) << name##_bit_count;\+        name##_buffer_ptr += 2;\+        name##_bit_count-= 16;\+    }\++#else++#   define UPDATE_CACHE(name, gb)\+    if(name##_bit_count >= 0){\+        name##_cache+= ((name##_buffer_ptr[0]<<8) + name##_buffer_ptr[1]) << name##_bit_count;\+        name##_buffer_ptr+=2;\+        name##_bit_count-= 16;\+    }\++#endif++#   define SKIP_CACHE(name, gb, num)\+        name##_cache <<= (num);\++#   define SKIP_COUNTER(name, gb, num)\+        name##_bit_count += (num);\++#   define SKIP_BITS(name, gb, num)\+        {\+            SKIP_CACHE(name, gb, num)\+            SKIP_COUNTER(name, gb, num)\+        }\++#   define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num)+#   define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num)++#   define SHOW_UBITS(name, gb, num)\+        NEG_USR32(name##_cache, num)++#   define SHOW_SBITS(name, gb, num)\+        NEG_SSR32(name##_cache, num)++#   define GET_CACHE(name, gb)\+        ((uint32_t)name##_cache)++static inline int get_bits_count(GetBitContext *s){+    return (s->buffer_ptr - s->buffer)*8 - 16 + s->bit_count;+}++static inline void skip_bits_long(GetBitContext *s, int n){+    OPEN_READER(re, s)+    re_bit_count += n;+    re_buffer_ptr += 2*(re_bit_count>>4);+    re_bit_count &= 15;+    re_cache = ((re_buffer_ptr[-2]<<8) + re_buffer_ptr[-1]) << (16+re_bit_count);+    UPDATE_CACHE(re, s)+    CLOSE_READER(re, s)+}++#elif defined A32_BITSTREAM_READER++#   define MIN_CACHE_BITS 32++#   define OPEN_READER(name, gb)\+        int name##_bit_count=(gb)->bit_count;\+        uint32_t name##_cache0= (gb)->cache0;\+        uint32_t name##_cache1= (gb)->cache1;\+        uint32_t * name##_buffer_ptr=(gb)->buffer_ptr;\++#   define CLOSE_READER(name, gb)\+        (gb)->bit_count= name##_bit_count;\+        (gb)->cache0= name##_cache0;\+        (gb)->cache1= name##_cache1;\+        (gb)->buffer_ptr= name##_buffer_ptr;\++#   define UPDATE_CACHE(name, gb)\+    if(name##_bit_count > 0){\+        const uint32_t next= be2me_32( *name##_buffer_ptr );\+        name##_cache0 |= NEG_USR32(next,name##_bit_count);\+        name##_cache1 |= next<<name##_bit_count;\+        name##_buffer_ptr++;\+        name##_bit_count-= 32;\+    }\++#if defined(ARCH_X86)+#   define SKIP_CACHE(name, gb, num)\+        asm(\+            "shldl %2, %1, %0          \n\t"\+            "shll %2, %1               \n\t"\+            : "+r" (name##_cache0), "+r" (name##_cache1)\+            : "Ic" ((uint8_t)(num))\+           );+#else+#   define SKIP_CACHE(name, gb, num)\+        name##_cache0 <<= (num);\+        name##_cache0 |= NEG_USR32(name##_cache1,num);\+        name##_cache1 <<= (num);+#endif++#   define SKIP_COUNTER(name, gb, num)\+        name##_bit_count += (num);\++#   define SKIP_BITS(name, gb, num)\+        {\+            SKIP_CACHE(name, gb, num)\+            SKIP_COUNTER(name, gb, num)\+        }\++#   define LAST_SKIP_BITS(name, gb, num) SKIP_BITS(name, gb, num)+#   define LAST_SKIP_CACHE(name, gb, num) SKIP_CACHE(name, gb, num)++#   define SHOW_UBITS(name, gb, num)\+        NEG_USR32(name##_cache0, num)++#   define SHOW_SBITS(name, gb, num)\+        NEG_SSR32(name##_cache0, num)++#   define GET_CACHE(name, gb)\+        (name##_cache0)++static inline int get_bits_count(GetBitContext *s){+    return ((uint8_t*)s->buffer_ptr - s->buffer)*8 - 32 + s->bit_count;+}++static inline void skip_bits_long(GetBitContext *s, int n){+    OPEN_READER(re, s)+    re_bit_count += n;+    re_buffer_ptr += re_bit_count>>5;+    re_bit_count &= 31;+    re_cache0 = be2me_32( re_buffer_ptr[-1] ) << re_bit_count;+    re_cache1 = 0;+    UPDATE_CACHE(re, s)+    CLOSE_READER(re, s)+}++#endif++/**+ * read mpeg1 dc style vlc (sign bit + mantisse with no MSB).+ * if MSB not set it is negative