Libav 0.7.1
libavcodec/put_bits.h
Go to the documentation of this file.
00001 /*
00002  * copyright (c) 2004 Michael Niedermayer <michaelni@gmx.at>
00003  *
00004  * This file is part of Libav.
00005  *
00006  * Libav is free software; you can redistribute it and/or
00007  * modify it under the terms of the GNU Lesser General Public
00008  * License as published by the Free Software Foundation; either
00009  * version 2.1 of the License, or (at your option) any later version.
00010  *
00011  * Libav is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014  * Lesser General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU Lesser General Public
00017  * License along with Libav; if not, write to the Free Software
00018  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00019  */
00020 
00026 #ifndef AVCODEC_PUT_BITS_H
00027 #define AVCODEC_PUT_BITS_H
00028 
00029 #include <stdint.h>
00030 #include <stdlib.h>
00031 #include <assert.h>
00032 #include "libavutil/bswap.h"
00033 #include "libavutil/common.h"
00034 #include "libavutil/intreadwrite.h"
00035 #include "libavutil/log.h"
00036 #include "mathops.h"
00037 #include "config.h"
00038 
00039 //#define ALT_BITSTREAM_WRITER
00040 //#define ALIGNED_BITSTREAM_WRITER
00041 
00042 /* buf and buf_end must be present and used by every alternative writer. */
00043 typedef struct PutBitContext {
00044 #ifdef ALT_BITSTREAM_WRITER
00045     uint8_t *buf, *buf_end;
00046     int index;
00047 #else
00048     uint32_t bit_buf;
00049     int bit_left;
00050     uint8_t *buf, *buf_ptr, *buf_end;
00051 #endif
00052     int size_in_bits;
00053 } PutBitContext;
00054 
00061 static inline void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
00062 {
00063     if(buffer_size < 0) {
00064         buffer_size = 0;
00065         buffer = NULL;
00066     }
00067 
00068     s->size_in_bits= 8*buffer_size;
00069     s->buf = buffer;
00070     s->buf_end = s->buf + buffer_size;
00071 #ifdef ALT_BITSTREAM_WRITER
00072     s->index=0;
00073     ((uint32_t*)(s->buf))[0]=0;
00074 //    memset(buffer, 0, buffer_size);
00075 #else
00076     s->buf_ptr = s->buf;
00077     s->bit_left=32;
00078     s->bit_buf=0;
00079 #endif
00080 }
00081 
00085 static inline int put_bits_count(PutBitContext *s)
00086 {
00087 #ifdef ALT_BITSTREAM_WRITER
00088     return s->index;
00089 #else
00090     return (s->buf_ptr - s->buf) * 8 + 32 - s->bit_left;
00091 #endif
00092 }
00093 
00097 static inline void flush_put_bits(PutBitContext *s)
00098 {
00099 #ifdef ALT_BITSTREAM_WRITER
00100     align_put_bits(s);
00101 #else
00102 #ifndef BITSTREAM_WRITER_LE
00103     s->bit_buf<<= s->bit_left;
00104 #endif
00105     while (s->bit_left < 32) {
00106         /* XXX: should test end of buffer */
00107 #ifdef BITSTREAM_WRITER_LE
00108         *s->buf_ptr++=s->bit_buf;
00109         s->bit_buf>>=8;
00110 #else
00111         *s->buf_ptr++=s->bit_buf >> 24;
00112         s->bit_buf<<=8;
00113 #endif
00114         s->bit_left+=8;
00115     }
00116     s->bit_left=32;
00117     s->bit_buf=0;
00118 #endif
00119 }
00120 
00121 #if defined(ALT_BITSTREAM_WRITER) || defined(BITSTREAM_WRITER_LE)
00122 #define align_put_bits align_put_bits_unsupported_here
00123 #define ff_put_string ff_put_string_unsupported_here
00124 #define ff_copy_bits ff_copy_bits_unsupported_here
00125 #else
00126 
00129 void align_put_bits(PutBitContext *s);
00130 
00136 void ff_put_string(PutBitContext *pb, const char *string, int terminate_string);
00137 
00143 void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length);
00144 #endif
00145 
00150 static inline void put_bits(PutBitContext *s, int n, unsigned int value)
00151 #ifndef ALT_BITSTREAM_WRITER
00152 {
00153     unsigned int bit_buf;
00154     int bit_left;
00155 
00156     //    printf("put_bits=%d %x\n", n, value);
00157     assert(n <= 31 && value < (1U << n));
00158 
00159     bit_buf = s->bit_buf;
00160     bit_left = s->bit_left;
00161 
00162     //    printf("n=%d value=%x cnt=%d buf=%x\n", n, value, bit_cnt, bit_buf);
00163     /* XXX: optimize */
00164 #ifdef BITSTREAM_WRITER_LE
00165     bit_buf |= value << (32 - bit_left);
00166     if (n >= bit_left) {
00167 #if !HAVE_FAST_UNALIGNED
00168         if (3 & (intptr_t) s->buf_ptr) {
00169             AV_WL32(s->buf_ptr, bit_buf);
00170         } else
00171 #endif
00172         *(uint32_t *)s->buf_ptr = av_le2ne32(bit_buf);
00173         s->buf_ptr+=4;
00174         bit_buf = (bit_left==32)?0:value >> bit_left;
00175         bit_left+=32;
00176     }
00177     bit_left-=n;
00178 #else
00179     if (n < bit_left) {
00180         bit_buf = (bit_buf<<n) | value;
00181         bit_left-=n;
00182     } else {
00183         bit_buf<<=bit_left;
00184         bit_buf |= value >> (n - bit_left);
00185 #if !HAVE_FAST_UNALIGNED
00186         if (3 & (intptr_t) s->buf_ptr) {
00187             AV_WB32(s->buf_ptr, bit_buf);
00188         } else
00189 #endif
00190         *(uint32_t *)s->buf_ptr = av_be2ne32(bit_buf);
00191         //printf("bitbuf = %08x\n", bit_buf);
00192         s->buf_ptr+=4;
00193         bit_left+=32 - n;
00194         bit_buf = value;
00195     }
00196 #endif
00197 
00198     s->bit_buf = bit_buf;
00199     s->bit_left = bit_left;
00200 }
00201 #else  /* ALT_BITSTREAM_WRITER defined */
00202 {
00203 #    ifdef ALIGNED_BITSTREAM_WRITER
00204 #        if ARCH_X86
00205     __asm__ volatile(
00206         "movl %0, %%ecx                 \n\t"
00207         "xorl %%eax, %%eax              \n\t"
00208         "shrdl %%cl, %1, %%eax          \n\t"
00209         "shrl %%cl, %1                  \n\t"
00210         "movl %0, %%ecx                 \n\t"
00211         "shrl $3, %%ecx                 \n\t"
00212         "andl $0xFFFFFFFC, %%ecx        \n\t"
00213         "bswapl %1                      \n\t"
00214         "orl %1, (%2, %%ecx)            \n\t"
00215         "bswapl %%eax                   \n\t"
00216         "addl %3, %0                    \n\t"
00217         "movl %%eax, 4(%2, %%ecx)       \n\t"
00218         : "=&r" (s->index), "=&r" (value)
00219         : "r" (s->buf), "r" (n), "0" (s->index), "1" (value<<(-n))
00220         : "%eax", "%ecx"
00221     );
00222 #        else
00223     int index= s->index;
00224     uint32_t *ptr= ((uint32_t *)s->buf)+(index>>5);
00225 
00226     value<<= 32-n;
00227 
00228     ptr[0] |= av_be2ne32(value>>(index&31));
00229     ptr[1]  = av_be2ne32(value<<(32-(index&31)));
00230 //if(n>24) printf("%d %d\n", n, value);
00231     index+= n;
00232     s->index= index;
00233 #        endif
00234 #    else //ALIGNED_BITSTREAM_WRITER
00235 #        if ARCH_X86
00236     __asm__ volatile(
00237         "movl $7, %%ecx                 \n\t"
00238         "andl %0, %%ecx                 \n\t"
00239         "addl %3, %%ecx                 \n\t"
00240         "negl %%ecx                     \n\t"
00241         "shll %%cl, %1                  \n\t"
00242         "bswapl %1                      \n\t"
00243         "movl %0, %%ecx                 \n\t"
00244         "shrl $3, %%ecx                 \n\t"
00245         "orl %1, (%%ecx, %2)            \n\t"
00246         "addl %3, %0                    \n\t"
00247         "movl $0, 4(%%ecx, %2)          \n\t"
00248         : "=&r" (s->index), "=&r" (value)
00249         : "r" (s->buf), "r" (n), "0" (s->index), "1" (value)
00250         : "%ecx"
00251     );
00252 #        else
00253     int index= s->index;
00254     uint32_t *ptr= (uint32_t*)(((uint8_t *)s->buf)+(index>>3));
00255 
00256     ptr[0] |= av_be2ne32(value<<(32-n-(index&7) ));
00257     ptr[1] = 0;
00258 //if(n>24) printf("%d %d\n", n, value);
00259     index+= n;
00260     s->index= index;
00261 #        endif
00262 #    endif //!ALIGNED_BITSTREAM_WRITER
00263 }
00264 #endif
00265 
00266 static inline void put_sbits(PutBitContext *pb, int n, int32_t value)
00267 {
00268     assert(n >= 0 && n <= 31);
00269 
00270     put_bits(pb, n, value & ((1<<n)-1));
00271 }
00272 
00276 static void av_unused put_bits32(PutBitContext *s, uint32_t value)
00277 {
00278     int lo = value & 0xffff;
00279     int hi = value >> 16;
00280 #ifdef BITSTREAM_WRITER_LE
00281     put_bits(s, 16, lo);
00282     put_bits(s, 16, hi);
00283 #else
00284     put_bits(s, 16, hi);
00285     put_bits(s, 16, lo);
00286 #endif
00287 }
00288 
00293 static inline uint8_t* put_bits_ptr(PutBitContext *s)
00294 {
00295 #ifdef ALT_BITSTREAM_WRITER
00296         return s->buf + (s->index>>3);
00297 #else
00298         return s->buf_ptr;
00299 #endif
00300 }
00301 
00306 static inline void skip_put_bytes(PutBitContext *s, int n)
00307 {
00308         assert((put_bits_count(s)&7)==0);
00309 #ifdef ALT_BITSTREAM_WRITER
00310         FIXME may need some cleaning of the buffer
00311         s->index += n<<3;
00312 #else
00313         assert(s->bit_left==32);
00314         s->buf_ptr += n;
00315 #endif
00316 }
00317 
00323 static inline void skip_put_bits(PutBitContext *s, int n)
00324 {
00325 #ifdef ALT_BITSTREAM_WRITER
00326     s->index += n;
00327 #else
00328     s->bit_left -= n;
00329     s->buf_ptr-= 4*(s->bit_left>>5);
00330     s->bit_left &= 31;
00331 #endif
00332 }
00333 
00339 static inline void set_put_bits_buffer_size(PutBitContext *s, int size)
00340 {
00341     s->buf_end= s->buf + size;
00342 }
00343 
00344 #endif /* AVCODEC_PUT_BITS_H */