Remove unused structures from vlc_common.h
[vlc.git] / 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., 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