include/vlc_bits.h

   1 /*****************************************************************************
   2  * bits.h : Bit handling helpers
   3  *****************************************************************************
   4  * Copyright (C) 2003 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 #if !defined( __LIBVLC__ )
  25   #error You are not libvlc or one of its plugins. You cannot include this file
  26 #endif
  27
  28 #ifndef _VLC_BITS_H
  29 #define _VLC_BITS_H 1
  30
  31 typedef struct bs_s
  32 {
  33     uint8_t *p_start;
  34     uint8_t *p;
  35     uint8_t *p_end;
  36
  37     int     i_left;    /* i_count number of available bits */
  38 } bs_t;
  39
  40 static inline void bs_init( bs_t *s, void *p_data, int i_data )
  41 {
  42     s->p_start = p_data;
  43     s->p       = p_data;
  44     s->p_end   = s->p + i_data;
  45     s->i_left  = 8;
  46 }
  47 static inline int bs_pos( bs_t *s )
  48 {
  49     return( 8 * ( s->p - s->p_start ) + 8 - s->i_left );
  50 }
  51 static inline int bs_eof( bs_t *s )
  52 {
  53     return( s->p >= s->p_end ? 1: 0 );
  54 }
  55 static inline uint32_t bs_read( bs_t *s, int i_count )
  56 {
  57      static uint32_t i_mask[33] =
  58      {  0x00,
  59         0x01,      0x03,      0x07,      0x0f,
  60         0x1f,      0x3f,      0x7f,      0xff,
  61         0x1ff,     0x3ff,     0x7ff,     0xfff,
  62         0x1fff,    0x3fff,    0x7fff,    0xffff,
  63         0x1ffff,   0x3ffff,   0x7ffff,   0xfffff,
  64         0x1fffff,  0x3fffff,  0x7fffff,  0xffffff,
  65         0x1ffffff, 0x3ffffff, 0x7ffffff, 0xfffffff,
  66         0x1fffffff,0x3fffffff,0x7fffffff,0xffffffff};
  67     int      i_shr;
  68     uint32_t i_result = 0;
  69
  70     while( i_count > 0 )
  71     {
  72         if( s->p >= s->p_end )
  73         {
  74             break;
  75         }
  76
  77         if( ( i_shr = s->i_left - i_count ) >= 0 )
  78         {
  79             /* more in the buffer than requested */
  80             i_result |= ( *s->p >> i_shr )&i_mask[i_count];
  81             s->i_left -= i_count;
  82             if( s->i_left == 0 )
  83             {
  84                 s->p++;
  85                 s->i_left = 8;
  86             }
  87             return( i_result );
  88         }
  89         else
  90         {
  91             /* less in the buffer than requested */
  92            i_result |= (*s->p&i_mask[s->i_left]) << -i_shr;
  93            i_count  -= s->i_left;
  94            s->p++;
  95            s->i_left = 8;
  96         }
  97     }
  98
  99     return( i_result );
 100 }
 101
 102 static inline uint32_t bs_read1( bs_t *s )
 103 {
 104     if( s->p < s->p_end )
 105     {
 106         unsigned int i_result;
 107
 108         s->i_left--;
 109         i_result = ( *s->p >> s->i_left )&0x01;
 110         if( s->i_left == 0 )
 111         {
 112             s->p++;
 113             s->i_left = 8;
 114         }
 115         return i_result;
 116     }
 117
 118     return 0;
 119 }
 120
 121 static inline uint32_t bs_show( bs_t *s, int i_count )
 122 {
 123     bs_t     s_tmp = *s;
 124     return bs_read( &s_tmp, i_count );
 125 }
 126
 127 static inline void bs_skip( bs_t *s, int i_count )
 128 {
 129     s->i_left -= i_count;
 130
 131     while( s->i_left <= 0 )
 132     {
 133         s->p++;
 134         s->i_left += 8;
 135     }
 136 }
 137
 138 static inline void bs_write( bs_t *s, int i_count, uint32_t i_bits )
 139 {
 140     while( i_count > 0 )
 141     {
 142         if( s->p >= s->p_end )
 143         {
 144             break;
 145         }
 146
 147         i_count--;
 148
 149         if( ( i_bits >> i_count )&0x01 )
 150         {
 151             *s->p |= 1 << ( s->i_left - 1 );
 152         }
 153         else
 154         {
 155             *s->p &= ~( 1 << ( s->i_left - 1 ) );
 156         }
 157         s->i_left--;
 158         if( s->i_left == 0 )
 159         {
 160             s->p++;
 161             s->i_left = 8;
 162         }
 163     }
 164 }
 165
 166 static inline void bs_align( bs_t *s )
 167 {
 168     if( s->i_left != 8 )
 169     {
 170         s->i_left = 8;
 171         s->p++;
 172     }
 173 }
 174 static inline void bs_align_0( bs_t *s )
 175 {
 176     if( s->i_left != 8 )
 177     {
 178         bs_write( s, s->i_left, 0 );
 179     }
 180 }
 181 static inline void bs_align_1( bs_t *s )
 182 {
 183     while( s->i_left != 8 )
 184     {
 185         bs_write( s, 1, 1 );
 186     }
 187 }
 188
 189 #endif