5c4cb0e405f5186d81a95801663c203eb7062340
[speexdsp.git] / libspeex / bits.c
1 /* Copyright (C) 2002 Jean-Marc Valin 
2    File: speex_bits.c
3
4    Handles bit packing/unpacking
5
6    Redistribution and use in source and binary forms, with or without
7    modification, are permitted provided that the following conditions
8    are met:
9    
10    - Redistributions of source code must retain the above copyright
11    notice, this list of conditions and the following disclaimer.
12    
13    - Redistributions in binary form must reproduce the above copyright
14    notice, this list of conditions and the following disclaimer in the
15    documentation and/or other materials provided with the distribution.
16    
17    - Neither the name of the Xiph.org Foundation nor the names of its
18    contributors may be used to endorse or promote products derived from
19    this software without specific prior written permission.
20    
21    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
25    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
26    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
27    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
28    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
29    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32
33 */
34
35 #ifdef HAVE_CONFIG_H
36 #include "config.h"
37 #endif
38
39 #include <speex/speex_bits.h>
40 #include "misc.h"
41
42 /* Maximum size of the bit-stream (for fixed-size allocation) */
43 #ifndef MAX_CHARS_PER_FRAME
44 #define MAX_CHARS_PER_FRAME (2000/BYTES_PER_CHAR)
45 #endif
46
47 void speex_bits_init(SpeexBits *bits)
48 {
49    bits->chars = (char*)speex_alloc(MAX_CHARS_PER_FRAME);
50    if (!bits->chars)
51       return;
52
53    bits->buf_size = MAX_CHARS_PER_FRAME;
54
55    bits->owner=1;
56
57    speex_bits_reset(bits);
58 }
59
60 void speex_bits_init_buffer(SpeexBits *bits, void *buff, int buf_size)
61 {
62    bits->chars = (char*)buff;
63    bits->buf_size = buf_size;
64
65    bits->owner=0;
66
67    speex_bits_reset(bits);
68 }
69
70 void speex_bits_destroy(SpeexBits *bits)
71 {
72    if (bits->owner)
73       speex_free(bits->chars);
74    /* Will do something once the allocation is dynamic */
75 }
76
77 void speex_bits_reset(SpeexBits *bits)
78 {
79    /* We only need to clear the first byte now */
80    bits->chars[0]=0;
81    bits->nbBits=0;
82    bits->charPtr=0;
83    bits->bitPtr=0;
84    bits->overflow=0;
85 }
86
87 void speex_bits_rewind(SpeexBits *bits)
88 {
89    bits->charPtr=0;
90    bits->bitPtr=0;
91    bits->overflow=0;
92 }
93
94 void speex_bits_read_from(SpeexBits *bits, char *chars, int len)
95 {
96    int i;
97    int nchars = len / BYTES_PER_CHAR;
98    if (nchars > bits->buf_size)
99    {
100       speex_notify("Packet is larger than allocated buffer");
101       if (bits->owner)
102       {
103          char *tmp = (char*)speex_realloc(bits->chars, nchars);
104          if (tmp)
105          {
106             bits->buf_size=nchars;
107             bits->chars=tmp;
108          } else {
109             nchars=bits->buf_size;
110             speex_warning("Could not resize input buffer: truncating input");
111          }
112       } else {
113          speex_warning("Do not own input buffer: truncating oversize input");
114          nchars=bits->buf_size;
115       }
116    }
117 #if (BYTES_PER_CHAR==2)
118 /* Swap bytes to proper endian order (could be done externally) */
119 #define HTOLS(A) ((((A) >> 8)&0xff)|(((A) & 0xff)<<8))
120 #else
121 #define HTOLS(A) (A)
122 #endif
123    for (i=0;i<nchars;i++)
124       bits->chars[i]=HTOLS(chars[i]);
125
126    bits->nbBits=nchars<<LOG2_BITS_PER_CHAR;
127    bits->charPtr=0;
128    bits->bitPtr=0;
129    bits->overflow=0;
130 }
131
132 static void speex_bits_flush(SpeexBits *bits)
133 {
134    int i;
135    int nchars = ((bits->nbBits+BITS_PER_CHAR-1)>>LOG2_BITS_PER_CHAR);
136    if (bits->charPtr>0)
137    {
138      for (i=bits->charPtr;i<nchars; i++) 
139        bits->chars[i-bits->charPtr]=bits->chars[i];
140    }
141    bits->nbBits -= bits->charPtr<<LOG2_BITS_PER_CHAR;
142    bits->charPtr=0;
143 }
144
145 void speex_bits_read_whole_bytes(SpeexBits *bits, char *chars, int nbytes)
146 {
147    int i,pos;
148    int nchars = nbytes/BYTES_PER_CHAR;
149
150    if (((bits->nbBits+BITS_PER_CHAR-1)>>LOG2_BITS_PER_CHAR)+nchars > bits->buf_size)
151    {
152       /* Packet is larger than allocated buffer */
153       if (bits->owner)
154       {
155          char *tmp = (char*)speex_realloc(bits->chars, (bits->nbBits>>LOG2_BITS_PER_CHAR)+nchars+1);
156          if (tmp)
157          {
158             bits->buf_size=(bits->nbBits>>LOG2_BITS_PER_CHAR)+nchars+1;
159             bits->chars=tmp;
160          } else {
161             nchars=bits->buf_size-(bits->nbBits>>LOG2_BITS_PER_CHAR)-1;
162             speex_warning("Could not resize input buffer: truncating oversize input");
163          }
164       } else {
165          speex_warning("Do not own input buffer: truncating oversize input");
166          nchars=bits->buf_size;
167       }
168    }
169
170    speex_bits_flush(bits);
171    pos=bits->nbBits>>LOG2_BITS_PER_CHAR;
172    for (i=0;i<nchars;i++)
173       bits->chars[pos+i]=HTOLS(chars[i]);
174    bits->nbBits+=nchars<<LOG2_BITS_PER_CHAR;
175 }
176
177 int speex_bits_write(SpeexBits *bits, char *chars, int max_nbytes)
178 {
179    int i;
180    int max_nchars = max_nbytes/BYTES_PER_CHAR;
181    int charPtr, bitPtr, nbBits;
182
183    /* Insert terminator, but save the data so we can put it back after */
184    bitPtr=bits->bitPtr;
185    charPtr=bits->charPtr;
186    nbBits=bits->nbBits;
187    speex_bits_insert_terminator(bits);
188    bits->bitPtr=bitPtr;
189    bits->charPtr=charPtr;
190    bits->nbBits=nbBits;
191
192    if (max_nchars > ((bits->nbBits+BITS_PER_CHAR-1)>>LOG2_BITS_PER_CHAR))
193       max_nchars = ((bits->nbBits+BITS_PER_CHAR-1)>>LOG2_BITS_PER_CHAR);
194
195    for (i=0;i<max_nchars;i++)
196       chars[i]=HTOLS(bits->chars[i]);
197    return max_nchars*BYTES_PER_CHAR;
198 }
199
200 int speex_bits_write_whole_bytes(SpeexBits *bits, char *chars, int max_nbytes)
201 {
202    int max_nchars = max_nbytes/BYTES_PER_CHAR;
203    int i;
204    if (max_nchars > ((bits->nbBits)>>LOG2_BITS_PER_CHAR))
205       max_nchars = ((bits->nbBits)>>LOG2_BITS_PER_CHAR);
206    for (i=0;i<max_nchars;i++)
207       chars[i]=HTOLS(bits->chars[i]);
208
209    if (bits->bitPtr>0)
210       bits->chars[0]=bits->chars[max_nchars];
211    else
212       bits->chars[0]=0;
213    for (i=1;i<((bits->nbBits)>>LOG2_BITS_PER_CHAR)+1;i++)
214       bits->chars[i]=0;
215    bits->charPtr=0;
216    bits->nbBits &= (BITS_PER_CHAR-1);
217    return max_nchars*BYTES_PER_CHAR;
218 }
219
220 void speex_bits_pack(SpeexBits *bits, int data, int nbBits)
221 {
222    unsigned int d=data;
223
224    if (bits->charPtr+((nbBits+bits->bitPtr)>>LOG2_BITS_PER_CHAR) >= bits->buf_size)
225    {
226       speex_notify("Buffer too small to pack bits");
227       if (bits->owner)
228       {
229          int new_nchars = ((bits->buf_size+5)*3)>>1;
230          char *tmp = (char*)speex_realloc(bits->chars, new_nchars);
231          if (tmp)
232          {
233             bits->buf_size=new_nchars;
234             bits->chars=tmp;
235          } else {
236             speex_warning("Could not resize input buffer: not packing");
237             return;
238          }
239       } else {
240          speex_warning("Do not own input buffer: not packing");
241          return;
242       }
243    }
244
245    while(nbBits)
246    {
247       int bit;
248       bit = (d>>(nbBits-1))&1;
249       bits->chars[bits->charPtr] |= bit<<(BITS_PER_CHAR-1-bits->bitPtr);
250       bits->bitPtr++;
251
252       if (bits->bitPtr==BITS_PER_CHAR)
253       {
254          bits->bitPtr=0;
255          bits->charPtr++;
256          bits->chars[bits->charPtr] = 0;
257       }
258       bits->nbBits++;
259       nbBits--;
260    }
261 }
262
263 int speex_bits_unpack_signed(SpeexBits *bits, int nbBits)
264 {
265    unsigned int d=speex_bits_unpack_unsigned(bits,nbBits);
266    /* If number is negative */
267    if (d>>(nbBits-1))
268    {
269       d |= (-1)<<nbBits;
270    }
271    return d;
272 }
273
274 unsigned int speex_bits_unpack_unsigned(SpeexBits *bits, int nbBits)
275 {
276    unsigned int d=0;
277    if ((bits->charPtr<<LOG2_BITS_PER_CHAR)+bits->bitPtr+nbBits>bits->nbBits)
278       bits->overflow=1;
279    if (bits->overflow)
280       return 0;
281    while(nbBits)
282    {
283       d<<=1;
284       d |= (bits->chars[bits->charPtr]>>(BITS_PER_CHAR-1 - bits->bitPtr))&1;
285       bits->bitPtr++;
286       if (bits->bitPtr==BITS_PER_CHAR)
287       {
288          bits->bitPtr=0;
289          bits->charPtr++;
290       }
291       nbBits--;
292    }
293    return d;
294 }
295
296 unsigned int speex_bits_peek_unsigned(SpeexBits *bits, int nbBits)
297 {
298    unsigned int d=0;
299    int bitPtr, charPtr;
300    char *chars;
301
302    if ((bits->charPtr<<LOG2_BITS_PER_CHAR)+bits->bitPtr+nbBits>bits->nbBits)
303      bits->overflow=1;
304    if (bits->overflow)
305       return 0;
306
307    bitPtr=bits->bitPtr;
308    charPtr=bits->charPtr;
309    chars = bits->chars;
310    while(nbBits)
311    {
312       d<<=1;
313       d |= (chars[charPtr]>>(BITS_PER_CHAR-1 - bitPtr))&1;
314       bitPtr++;
315       if (bitPtr==BITS_PER_CHAR)
316       {
317          bitPtr=0;
318          charPtr++;
319       }
320       nbBits--;
321    }
322    return d;
323 }
324
325 int speex_bits_peek(SpeexBits *bits)
326 {
327    if ((bits->charPtr<<LOG2_BITS_PER_CHAR)+bits->bitPtr+1>bits->nbBits)
328       bits->overflow=1;
329    if (bits->overflow)
330       return 0;
331    return (bits->chars[bits->charPtr]>>(BITS_PER_CHAR-1 - bits->bitPtr))&1;
332 }
333
334 void speex_bits_advance(SpeexBits *bits, int n)
335 {
336     if (((bits->charPtr<<LOG2_BITS_PER_CHAR)+bits->bitPtr+n>bits->nbBits) || bits->overflow){
337       bits->overflow=1;
338       return;
339     }
340    bits->charPtr += (bits->bitPtr+n) >> LOG2_BITS_PER_CHAR; /* divide by BITS_PER_CHAR */
341    bits->bitPtr = (bits->bitPtr+n) & (BITS_PER_CHAR-1);       /* modulo by BITS_PER_CHAR */
342 }
343
344 int speex_bits_remaining(SpeexBits *bits)
345 {
346    if (bits->overflow)
347       return -1;
348    else
349       return bits->nbBits-((bits->charPtr<<LOG2_BITS_PER_CHAR)+bits->bitPtr);
350 }
351
352 int speex_bits_nbytes(SpeexBits *bits)
353 {
354    return ((bits->nbBits+BITS_PER_CHAR-1)>>LOG2_BITS_PER_CHAR);
355 }
356
357 void speex_bits_insert_terminator(SpeexBits *bits)
358 {
359    if (bits->bitPtr)
360       speex_bits_pack(bits, 0, 1);
361    while (bits->bitPtr)
362       speex_bits_pack(bits, 1, 1);
363 }