|
1 /* |
|
2 * Copyright (c) 2010 Ixonos Plc. |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of the "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - Initial contribution |
|
11 * |
|
12 * Contributors: |
|
13 * Ixonos Plc |
|
14 * |
|
15 * Description: |
|
16 * |
|
17 */ |
|
18 |
|
19 |
|
20 #ifndef _BITBUFFER_H_ |
|
21 #define _BITBUFFER_H_ |
|
22 |
|
23 |
|
24 #include "globals.h" |
|
25 #include "nrctyp32.h" |
|
26 |
|
27 |
|
28 #define BIB_ERR_BIT_ERROR -4 |
|
29 #define BIB_INCORRECT_TRAILING_BIT -3 |
|
30 #define BIB_ERR_NO_BITS -2 |
|
31 #define BIB_ERROR -1 |
|
32 #define BIB_OK 0 |
|
33 |
|
34 |
|
35 typedef struct _bitbuffer_s |
|
36 { |
|
37 u_int8 *data; /* point to the bit buffer. The physical buffer is allocated by the main module */ |
|
38 int dataLen; |
|
39 int bytePos; |
|
40 int bitpos; |
|
41 int32 currentBits; |
|
42 int errorStatus; |
|
43 } bitbuffer_s; |
|
44 |
|
45 |
|
46 #define bibRaiseError(bitbuf, error) ((bitbuf)->errorStatus = (error)) |
|
47 |
|
48 #define bibGetStatus(bitbuf) (bitbuf)->errorStatus |
|
49 |
|
50 |
|
51 bitbuffer_s *bibOpen(); |
|
52 |
|
53 int bibInit(bitbuffer_s *bitbuf, u_int8 *streamBytes, int length); |
|
54 |
|
55 int bibEnd(bitbuffer_s *bitbuf); |
|
56 |
|
57 void bibEndSlice(bitbuffer_s *bitbuf); |
|
58 |
|
59 void bibClose(bitbuffer_s *bitbuf); |
|
60 |
|
61 int bibGetBitFunc(bitbuffer_s *bitbuf); |
|
62 |
|
63 int32 bibGetBitsFunc(bitbuffer_s *bitbuf, int n); |
|
64 |
|
65 int32 bibShowBitsFunc(bitbuffer_s *bitbuf, int n); |
|
66 |
|
67 int bibSkipBitsFunc(bitbuffer_s *bitbuf, int n); |
|
68 |
|
69 int bibGetByte(bitbuffer_s *bitbuf, int *byteRet); |
|
70 |
|
71 int bibByteAlign(bitbuffer_s *bitbuf); |
|
72 |
|
73 int bibSkipTrailingBits(bitbuffer_s *bitbuf); |
|
74 |
|
75 int bibMoreRbspData(bitbuffer_s *bitbuf); |
|
76 |
|
77 int32 bibGetNumRemainingBits(bitbuffer_s *bitbuf); |
|
78 |
|
79 //int bibGetMax16bits(bitbuffer_s *bitbuf, TInt n, u_int32* retValue); |
|
80 void syncBitBufferBitpos(bitbuffer_s *bitbuf); |
|
81 |
|
82 |
|
83 /* |
|
84 * |
|
85 * bibGetBit |
|
86 * |
|
87 * Parameters: |
|
88 * bitbuf Bitbuffer object |
|
89 * bit Return pointer for bit |
|
90 * |
|
91 * Function: |
|
92 * Get next bit from bitbuffer. |
|
93 * |
|
94 * Returns: |
|
95 * - |
|
96 * |
|
97 */ |
|
98 #define bibGetBit(bitbuf, bit) \ |
|
99 if ((bitbuf)->bitpos <= 0) { \ |
|
100 if ((bitbuf)->bytePos < (bitbuf)->dataLen) { \ |
|
101 (bitbuf)->currentBits = (bitbuf)->data[(bitbuf)->bytePos++]; \ |
|
102 (bitbuf)->bitpos = 7; \ |
|
103 *(bit) = ((bitbuf)->currentBits >> (bitbuf)->bitpos) & 1; \ |
|
104 } \ |
|
105 else { \ |
|
106 (bitbuf)->errorStatus = BIB_ERR_NO_BITS; \ |
|
107 *(bit) = 0; \ |
|
108 } \ |
|
109 } \ |
|
110 else { \ |
|
111 (bitbuf)->bitpos--; \ |
|
112 *(bit) = ((bitbuf)->currentBits >> (bitbuf)->bitpos) & 1; \ |
|
113 } |
|
114 |
|
115 |
|
116 /* |
|
117 * |
|
118 * bibGetBits |
|
119 * |
|
120 * Parameters: |
|
121 * bitbuf Bitbuffer object |
|
122 * n Number of bits requested |
|
123 * bits Return pointer for bits |
|
124 * |
|
125 * Function: |
|
126 * Get next n bits from bitbuffer. If bitbuffer is low on bits, |
|
127 * call bibGetBitsFunc to get more. |
|
128 * |
|
129 * NOTE: maximum of 24 bits can be fetched |
|
130 * |
|
131 * Returns: |
|
132 * - |
|
133 * |
|
134 */ |
|
135 #define bibGetBits(bitbuf, n, bits) \ |
|
136 if ((n) > (bitbuf)->bitpos) { \ |
|
137 if ((bitbuf)->bytePos+2 >= (bitbuf)->dataLen) \ |
|
138 *(bits) = bibGetBitsFunc(bitbuf, n); \ |
|
139 else { \ |
|
140 do { \ |
|
141 (bitbuf)->currentBits = ((bitbuf)->currentBits << 8) | (bitbuf)->data[(bitbuf)->bytePos++]; \ |
|
142 (bitbuf)->bitpos += 8; \ |
|
143 } while ((n) > (bitbuf)->bitpos); \ |
|
144 (bitbuf)->bitpos -= (n); \ |
|
145 *(bits) = ((bitbuf)->currentBits >> (bitbuf)->bitpos) & ~(((u_int32)-1)<<(n)); \ |
|
146 } \ |
|
147 } \ |
|
148 else { \ |
|
149 (bitbuf)->bitpos -= (n); \ |
|
150 *(bits) = ((bitbuf)->currentBits >> (bitbuf)->bitpos) & ~(((u_int32)-1)<<(n)); \ |
|
151 } |
|
152 |
|
153 |
|
154 /* |
|
155 * |
|
156 * bibGetMax16bits |
|
157 * |
|
158 * Parameters: |
|
159 * bitbuf Bitbuffer object |
|
160 * n Number of bits requested |
|
161 * bits Return pointer for bits |
|
162 * |
|
163 * Function: |
|
164 * Get next n bits from bitbuffer. If bitbuffer is low on bits, |
|
165 * call bibGetBitsFunc to get more. |
|
166 * |
|
167 * NOTE: maximum of 16 bits can be fetched |
|
168 * |
|
169 * Returns: |
|
170 * - |
|
171 * |
|
172 */ |
|
173 #define bibGetMax16bits(bitbuf, n, bits) \ |
|
174 if ((n) > (bitbuf)->bitpos) { \ |
|
175 if ((bitbuf)->bytePos+1 >= (bitbuf)->dataLen) \ |
|
176 *(bits) = bibGetBitsFunc(bitbuf, n); \ |
|
177 else { \ |
|
178 (bitbuf)->currentBits = ((bitbuf)->currentBits << 8) | (bitbuf)->data[(bitbuf)->bytePos++]; \ |
|
179 (bitbuf)->currentBits = ((bitbuf)->currentBits << 8) | (bitbuf)->data[(bitbuf)->bytePos++]; \ |
|
180 (bitbuf)->bitpos += 16; \ |
|
181 (bitbuf)->bitpos -= (n); \ |
|
182 *(bits) = ((bitbuf)->currentBits >> (bitbuf)->bitpos) & ~(((u_int32)-1)<<(n)); \ |
|
183 } \ |
|
184 } \ |
|
185 else { \ |
|
186 (bitbuf)->bitpos -= (n); \ |
|
187 *(bits) = ((bitbuf)->currentBits >> (bitbuf)->bitpos) & ~(((u_int32)-1)<<(n)); \ |
|
188 } |
|
189 |
|
190 |
|
191 /* |
|
192 * |
|
193 * bibGetMax8bits |
|
194 * |
|
195 * Parameters: |
|
196 * bitbuf Bitbuffer object |
|
197 * n Number of bits requested |
|
198 * bits Return pointer for bits |
|
199 * |
|
200 * Function: |
|
201 * Get next n bits from bitbuffer. If bitbuffer is low on bits, |
|
202 * call bibGetBitsFunc to get more. |
|
203 * |
|
204 * NOTE: maximum of 8 bits can be fetched |
|
205 * |
|
206 * Returns: |
|
207 * - |
|
208 * |
|
209 */ |
|
210 #define bibGetMax8bits(bitbuf, n, bits) \ |
|
211 if ((n) > (bitbuf)->bitpos) { \ |
|
212 if ((bitbuf)->bytePos >= (bitbuf)->dataLen) \ |
|
213 *(bits) = bibGetBitsFunc(bitbuf, n); \ |
|
214 else { \ |
|
215 (bitbuf)->currentBits = ((bitbuf)->currentBits << 8) | (bitbuf)->data[(bitbuf)->bytePos++]; \ |
|
216 (bitbuf)->bitpos += 8; \ |
|
217 (bitbuf)->bitpos -= (n); \ |
|
218 *(bits) = ((bitbuf)->currentBits >> (bitbuf)->bitpos) & ~(((u_int32)-1)<<(n)); \ |
|
219 } \ |
|
220 } \ |
|
221 else { \ |
|
222 (bitbuf)->bitpos -= (n); \ |
|
223 *(bits) = ((bitbuf)->currentBits >> (bitbuf)->bitpos) & ~(((u_int32)-1)<<(n)); \ |
|
224 } |
|
225 |
|
226 |
|
227 /* |
|
228 * |
|
229 * bibShowBits |
|
230 * |
|
231 * Parameters: |
|
232 * bitbuf Bitbuffer object |
|
233 * n Number of bits requested |
|
234 * bits Return pointer for bits |
|
235 * |
|
236 * Function: |
|
237 * Get next n bits from bitbuffer without advancing bitbuffer pointer. |
|
238 * If bitbuffer is low on bits, call bibShowBitsFunc to get more. |
|
239 * |
|
240 * NOTE: maximum of 24 bits can be fetched |
|
241 * |
|
242 * Returns: |
|
243 * - |
|
244 * |
|
245 */ |
|
246 #define bibShowBits(bitbuf, n, bits) \ |
|
247 if ((n) > (bitbuf)->bitpos) { \ |
|
248 if ((bitbuf)->bytePos+2 >= (bitbuf)->dataLen) \ |
|
249 *(bits) = bibShowBitsFunc(bitbuf, n); \ |
|
250 else { \ |
|
251 do { \ |
|
252 (bitbuf)->currentBits = ((bitbuf)->currentBits << 8) | (bitbuf)->data[(bitbuf)->bytePos++]; \ |
|
253 (bitbuf)->bitpos += 8; \ |
|
254 } while ((n) > (bitbuf)->bitpos); \ |
|
255 *(bits) = ((bitbuf)->currentBits >> ((bitbuf)->bitpos-(n))) & ~(((u_int32)-1)<<(n)); \ |
|
256 } \ |
|
257 } \ |
|
258 else \ |
|
259 *(bits) = ((bitbuf)->currentBits >> ((bitbuf)->bitpos-(n))) & ~(((u_int32)-1)<<(n)); |
|
260 |
|
261 |
|
262 /* |
|
263 * |
|
264 * bibShowMax16bits |
|
265 * |
|
266 * Parameters: |
|
267 * bitbuf Bitbuffer object |
|
268 * n Number of bits requested |
|
269 * bits Return pointer for bits |
|
270 * |
|
271 * Function: |
|
272 * Get next n bits from bitbuffer without advancing bitbuffer pointer. |
|
273 * If bitbuffer is low on bits, call bibShowBitsFunc to get more. |
|
274 * |
|
275 * NOTE: maximum of 16 bits can be fetched |
|
276 * |
|
277 * Returns: |
|
278 * - |
|
279 * |
|
280 */ |
|
281 #define bibShowMax16bits(bitbuf, n, bits) \ |
|
282 if ((n) > (bitbuf)->bitpos) { \ |
|
283 if ((bitbuf)->bytePos+1 >= (bitbuf)->dataLen) \ |
|
284 *(bits) = bibShowBitsFunc(bitbuf, n); \ |
|
285 else { \ |
|
286 (bitbuf)->currentBits = ((bitbuf)->currentBits << 8) | (bitbuf)->data[(bitbuf)->bytePos++]; \ |
|
287 (bitbuf)->currentBits = ((bitbuf)->currentBits << 8) | (bitbuf)->data[(bitbuf)->bytePos++]; \ |
|
288 (bitbuf)->bitpos += 16; \ |
|
289 *(bits) = ((bitbuf)->currentBits >> ((bitbuf)->bitpos-(n))) & ~(((u_int32)-1)<<(n)); \ |
|
290 } \ |
|
291 } \ |
|
292 else \ |
|
293 *(bits) = ((bitbuf)->currentBits >> ((bitbuf)->bitpos-(n))) & ~(((u_int32)-1)<<(n)); |
|
294 |
|
295 |
|
296 /* |
|
297 * |
|
298 * bibShowMax8bits |
|
299 * |
|
300 * Parameters: |
|
301 * bitbuf Bitbuffer object |
|
302 * n Number of bits requested |
|
303 * bits Return pointer for bits |
|
304 * |
|
305 * Function: |
|
306 * Get next n bits from bitbuffer without advancing bitbuffer pointer. |
|
307 * If bitbuffer is low on bits, call bibShowBitsFunc to get more. |
|
308 * |
|
309 * NOTE: maximum of 8 bits can be fetched |
|
310 * |
|
311 * Returns: |
|
312 * - |
|
313 * |
|
314 */ |
|
315 #define bibShowMax8bits(bitbuf, n, bits) \ |
|
316 if ((n) > (bitbuf)->bitpos) { \ |
|
317 if ((bitbuf)->bytePos >= (bitbuf)->dataLen) \ |
|
318 *(bits) = bibShowBitsFunc(bitbuf, n); \ |
|
319 else { \ |
|
320 (bitbuf)->currentBits = ((bitbuf)->currentBits << 8) | (bitbuf)->data[(bitbuf)->bytePos++]; \ |
|
321 (bitbuf)->bitpos += 8; \ |
|
322 *(bits) = ((bitbuf)->currentBits >> ((bitbuf)->bitpos-(n))) & ~(((u_int32)-1)<<(n)); \ |
|
323 } \ |
|
324 } \ |
|
325 else \ |
|
326 *(bits) = ((bitbuf)->currentBits >> ((bitbuf)->bitpos-(n))) & ~(((u_int32)-1)<<(n)); |
|
327 |
|
328 |
|
329 /* |
|
330 * |
|
331 * bibSkipBits |
|
332 * |
|
333 * Parameters: |
|
334 * bitbuf Bitbuffer object |
|
335 * n Number of bits to be skipped |
|
336 * |
|
337 * Function: |
|
338 * Called after calling bibShowBits to skip the number of bits that |
|
339 * were actually needed. If bibShowBits fetched more bits than there were |
|
340 * bits in bitbuf->currentBits, calls bibSkipBitsFunc to clean up. |
|
341 * |
|
342 * Returns: |
|
343 * - |
|
344 * |
|
345 */ |
|
346 #define bibSkipBits(bitbuf, n) \ |
|
347 (bitbuf)->bitpos -= (n); \ |
|
348 if ((bitbuf)->bitpos < 0) { \ |
|
349 (bitbuf)->bitpos += (n); \ |
|
350 bibSkipBitsFunc(bitbuf, n); \ |
|
351 } |
|
352 |
|
353 |
|
354 |
|
355 #endif /* #ifndef _BITBUFFER_H_ */ |