git.sesse.net Git - vlc/blob - include/vlc_bits.h

   1 /*****************************************************************************
   2  * bits.h :
   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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22  *****************************************************************************/
  23
  24 #ifndef _VLC_BITS_H
  25 #define _VLC_BITS_H 1
  26
  27 typedef struct bs_s
  28 {
  29     uint8_t *p_start;
  30     uint8_t *p;
  31     uint8_t *p_end;
  32
  33     int     i_left;    /* i_count number of available bits */
  34 } bs_t;
  35
  36 static inline void bs_init( bs_t *s, void *p_data, int i_data )
  37 {
  38     s->p_start = p_data;
  39     s->p       = p_data;
  40     s->p_end   = s->p + i_data;
  41     s->i_left  = 8;
  42 }
  43 static inline int bs_pos( bs_t *s )
  44 {
  45     return( 8 * ( s->p - s->p_start ) + 8 - s->i_left );
  46 }
  47 static inline int bs_eof( bs_t *s )
  48 {
  49     return( s->p >= s->p_end ? 1: 0 );
  50 }
  51 static inline uint32_t bs_read( bs_t *s, int i_count )
  52 {
  53      static uint32_t i_mask[33] =
  54      {  0x00,
  55         0x01,      0x03,      0x07,      0x0f,
  56         0x1f,      0x3f,      0x7f,      0xff,
  57         0x1ff,     0x3ff,     0x7ff,     0xfff,
  58         0x1fff,    0x3fff,    0x7fff,    0xffff,
  59         0x1ffff,   0x3ffff,   0x7ffff,   0xfffff,
  60         0x1fffff,  0x3fffff,  0x7fffff,  0xffffff,
  61         0x1ffffff, 0x3ffffff, 0x7ffffff, 0xfffffff,
  62         0x1fffffff,0x3fffffff,0x7fffffff,0xffffffff};
  63     int      i_shr;
  64     uint32_t i_result = 0;
  65
  66     while( i_count > 0 )
  67     {
  68         if( s->p >= s->p_end )
  69         {
  70             break;
  71         }
  72
  73         if( ( i_shr = s->i_left - i_count ) >= 0 )
  74         {
  75             /* more in the buffer than requested */
  76             i_result |= ( *s->p >> i_shr )&i_mask[i_count];
  77             s->i_left -= i_count;
  78             if( s->i_left == 0 )
  79             {
  80                 s->p++;
  81                 s->i_left = 8;
  82             }
  83             return( i_result );
  84         }
  85         else
  86         {
  87             /* less in the buffer than requested */
  88            i_result |= (*s->p&i_mask[s->i_left]) << -i_shr;
  89            i_count  -= s->i_left;
  90            s->p++;
  91            s->i_left = 8;
  92         }
  93     }
  94
  95     return( i_result );
  96 }
  97
  98 static inline uint32_t bs_read1( bs_t *s )
  99 {
 100     if( s->p < s->p_end )
 101     {
 102         unsigned int i_result;
 103
 104         s->i_left--;
 105         i_result = ( *s->p >> s->i_left )&0x01;
 106         if( s->i_left == 0 )
 107         {
 108             s->p++;
 109             s->i_left = 8;
 110         }
 111         return i_result;
 112     }
 113
 114     return 0;
 115 }
 116
 117 static inline uint32_t bs_show( bs_t *s, int i_count )
 118 {
 119     bs_t     s_tmp = *s;
 120     return bs_read( &s_tmp, i_count );
 121 }
 122
 123 static inline void bs_skip( bs_t *s, int i_count )
 124 {
 125     s->i_left -= i_count;
 126
 127     while( s->i_left <= 0 )
 128     {
 129         s->p++;
 130         s->i_left += 8;
 131     }
 132 }
 133
 134 static inline void bs_write( bs_t *s, int i_count, uint32_t i_bits )
 135 {
 136     while( i_count > 0 )
 137     {
 138         if( s->p >= s->p_end )
 139         {
 140             break;
 141         }
 142
 143         i_count--;
 144
 145         if( ( i_bits >> i_count )&0x01 )
 146         {
 147             *s->p |= 1 << ( s->i_left - 1 );
 148         }
 149         else
 150         {
 151             *s->p &= ~( 1 << ( s->i_left - 1 ) );
 152         }
 153         s->i_left--;
 154         if( s->i_left == 0 )
 155         {
 156             s->p++;
 157             s->i_left = 8;
 158         }
 159     }
 160 }
 161
 162 static inline void bs_align( bs_t *s )
 163 {
 164     if( s->i_left != 8 )
 165     {
 166         s->i_left = 8;
 167         s->p++;
 168     }
 169 }
 170 static inline void bs_align_0( bs_t *s )
 171 {
 172     if( s->i_left != 8 )
 173     {
 174         bs_write( s, s->i_left, 0 );
 175     }
 176 }
 177 static inline void bs_align_1( bs_t *s )
 178 {
 179     while( s->i_left != 8 )
 180     {
 181         bs_write( s, 1, 1 );
 182     }
 183 }
 184
 185 #endif