ZenLib
BitStream_Fast.h
Go to the documentation of this file.
1/* Copyright (c) MediaArea.net SARL. All Rights Reserved.
2 *
3 * Use of this source code is governed by a zlib-style license that can
4 * be found in the License.txt file in the root of the source tree.
5 */
6
7//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
8//
9// Read a stream bit per bit
10// Can read up to 32 bits at once
11//
12//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
13
14//---------------------------------------------------------------------------
15#ifndef ZenBitStream_FastH
16#define ZenBitStream_FastH
17//---------------------------------------------------------------------------
18
19//---------------------------------------------------------------------------
20#include "ZenLib/Conf.h"
21//---------------------------------------------------------------------------
22
23namespace ZenLib
24{
25
26#ifndef MIN
27 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
28#endif
29
31{
32public:
33 BitStream_Fast () { Buffer = NULL;
34 Buffer_Size = 0;
35 Buffer_Size_Init = 0;
36 LastByte = 0;
37 BufferUnderRun = false; }
38 BitStream_Fast (const int8u* Buffer_, size_t Size_) { Buffer = Buffer_;
39 Buffer_Size = Size_ * 8; //Size is in bits
40 Buffer_Size_Init = Size_ * 8; //Size is in bits
41 LastByte = 0;
42 BufferUnderRun = false; }
44
45 void Attach(const int8u* Buffer_, size_t Size_)
46 {
47 Buffer=Buffer_;
48 Buffer_Size=Buffer_Size_Init=Size_*8; //Size is in bits
49 BufferUnderRun=false;
50 }
51
52 bool GetB ()
53 {
54 if (Buffer_Size%8)
55 {
56 Buffer_Size--;
57 return ((LastByte>>(Buffer_Size%8))&0x1)?true:false;
58 }
59
60 if (!Buffer_Size)
61 {
62 Buffer_Size=0;
63 BufferUnderRun=true;
64 return false;
65 }
66
67 LastByte=*Buffer;
68 Buffer++;
69 Buffer_Size--;
70 return (LastByte&0x80)?true:false;
71 }
72
73 int8u Get1 (int8u HowMany)
74 {
75 int8u ToReturn;
76 static const int8u Mask[9]=
77 {
78 0x00,
79 0x01, 0x03, 0x07, 0x0f,
80 0x1f, 0x3f, 0x7f, 0xff,
81 };
82
83 if (HowMany==0 || HowMany>8)
84 return 0;
85
86 if (HowMany<=(Buffer_Size%8))
87 {
88 Buffer_Size-=HowMany;
89 return (LastByte>>(Buffer_Size%8))&Mask[HowMany];
90 }
91
92 if (HowMany>Buffer_Size)
93 {
94 Buffer_Size=0;
95 BufferUnderRun=true;
96 return 0;
97 }
98
99 int8u NewBits=HowMany-(Buffer_Size%8);
100 if (NewBits==8)
101 ToReturn=0;
102 else
103 ToReturn=LastByte<<NewBits;
104 LastByte=*Buffer;
105 Buffer++;
106 Buffer_Size-=HowMany;
107 ToReturn|=(LastByte>>(Buffer_Size%8))&Mask[NewBits];
108 return ToReturn&Mask[HowMany];
109 }
110
111 int16u Get2 (int8u HowMany)
112 {
113 int16u ToReturn;
114 static const int16u Mask[17]=
115 {
116 0x0000,
117 0x0001, 0x0003, 0x0007, 0x000f,
118 0x001f, 0x003f, 0x007f, 0x00ff,
119 0x01ff, 0x03ff, 0x07ff, 0x0fff,
120 0x1fff, 0x3fff, 0x7fff, 0xffff,
121 };
122
123 if (HowMany==0 || HowMany>16)
124 return 0;
125
126 if (HowMany<=(Buffer_Size%8))
127 {
128 Buffer_Size-=HowMany;
129 return (LastByte>>(Buffer_Size%8))&Mask[HowMany];
130 }
131
132 if (HowMany>Buffer_Size)
133 {
134 Buffer_Size=0;
135 BufferUnderRun=true;
136 return 0;
137 }
138
139 int8u NewBits=HowMany-(Buffer_Size%8);
140 if (NewBits==16)
141 ToReturn=0;
142 else
143 ToReturn=LastByte<<NewBits;
144 if ((NewBits-1)>>3)
145 {
146 NewBits-=8;
147 ToReturn|=*Buffer<<NewBits;
148 Buffer++;
149 }
150 LastByte=*Buffer;
151 Buffer++;
152 Buffer_Size-=HowMany;
153 ToReturn|=(LastByte>>(Buffer_Size%8))&Mask[NewBits];
154 return ToReturn&Mask[HowMany];
155 }
156
157 int32u Get4 (int8u HowMany)
158 {
159 int32u ToReturn;
160 static const int32u Mask[33]=
161 {
162 0x00000000,
163 0x00000001, 0x00000003, 0x00000007, 0x0000000f,
164 0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff,
165 0x000001ff, 0x000003ff, 0x000007ff, 0x00000fff,
166 0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff,
167 0x0001ffff, 0x0003ffff, 0x0007ffff, 0x000fffff,
168 0x001fffff, 0x003fffff, 0x007fffff, 0x00ffffff,
169 0x01ffffff, 0x03ffffff, 0x07ffffff, 0x0fffffff,
170 0x1fffffff, 0x3fffffff, 0x7fffffff, 0xffffffff,
171 };
172
173 if (HowMany==0 || HowMany>32)
174 return 0;
175
176 if (HowMany<=(Buffer_Size%8))
177 {
178 Buffer_Size-=HowMany;
179 return (LastByte>>(Buffer_Size%8))&Mask[HowMany];
180 }
181
182 if (HowMany>Buffer_Size)
183 {
184 Buffer_Size=0;
185 BufferUnderRun=true;
186 return 0;
187 }
188
189 int8u NewBits=HowMany-(Buffer_Size%8);
190 if (NewBits==32)
191 ToReturn=0;
192 else
193 ToReturn=LastByte<<NewBits;
194 switch ((NewBits-1)>>3)
195 {
196 case 3 : NewBits-=8;
197 ToReturn|=*(Buffer++)<<NewBits;
198 [[fallthrough]];
199 case 2 : NewBits-=8;
200 ToReturn|=*(Buffer++)<<NewBits;
201 [[fallthrough]];
202 case 1 : NewBits-=8;
203 ToReturn|=*(Buffer++)<<NewBits;
204 }
205 LastByte=*(Buffer++);
206 Buffer_Size-=HowMany;
207 ToReturn|=(LastByte>>(Buffer_Size%8))&Mask[NewBits];
208 return ToReturn&Mask[HowMany];
209 }
210
211 int64u Get8 (int8u HowMany)
212 {
213 if (HowMany>64)
214 return 0; //Not supported
215 int8u HowMany1, HowMany2;
216 int64u Value1, Value2;
217 if (HowMany>32)
218 HowMany1=HowMany-32;
219 else
220 HowMany1=0;
221 HowMany2=HowMany-HowMany1;
222 Value1=Get4(HowMany1);
223 Value2=Get4(HowMany2);
224 if (BufferUnderRun)
225 return 0;
226 return Value1*0x100000000LL+Value2;
227 }
228
229 void Skip (size_t HowMany)
230 {
231 if (HowMany<=(Buffer_Size%8))
232 {
233 Buffer_Size-=HowMany;
234 return;
235 }
236
237 if (HowMany>Buffer_Size)
238 {
239 Buffer_Size=0;
240 BufferUnderRun=true;
241 return;
242 }
243
244 Buffer+=(HowMany-(Buffer_Size%8)-1)>>3;
245 LastByte=*Buffer;
246 Buffer++;
247 Buffer_Size-=HowMany;
248 }
249
250 bool PeekB()
251 {
252 if (Buffer_Size%8)
253 return ((LastByte>>((Buffer_Size-1)%8))&0x1)?true:false;
254
255 if (!Buffer_Size)
256 {
257 Buffer_Size=0;
258 BufferUnderRun=true;
259 return false;
260 }
261
262 return ((*Buffer)&0x80)?true:false;
263 }
264
265 int8u Peek1(int8u HowMany)
266 {
267 int8u ToReturn;
268 static const int8u Mask[9]=
269 {
270 0x00,
271 0x01, 0x03, 0x07, 0x0f,
272 0x1f, 0x3f, 0x7f, 0xff,
273 };
274
275 if (HowMany==0 || HowMany>8)
276 return 0;
277
278 if (HowMany<=(Buffer_Size%8))
279 return (LastByte>>((Buffer_Size-HowMany)%8))&Mask[HowMany];
280
281 if (HowMany>Buffer_Size)
282 {
283 Buffer_Size=0;
284 BufferUnderRun=true;
285 return 0;
286 }
287
288 int8u NewBits=HowMany-(Buffer_Size%8);
289 if (NewBits==8)
290 ToReturn=0;
291 else
292 ToReturn=LastByte<<NewBits;
293 ToReturn|=((*Buffer)>>((Buffer_Size-HowMany)%8))&Mask[NewBits];
294
295 return ToReturn&Mask[HowMany];
296 }
297
298 int16u Peek2(int8u HowMany)
299 {
300 int16u ToReturn;
301 static const int16u Mask[17]=
302 {
303 0x0000,
304 0x0001, 0x0003, 0x0007, 0x000f,
305 0x001f, 0x003f, 0x007f, 0x00ff,
306 0x01ff, 0x03ff, 0x07ff, 0x0fff,
307 0x1fff, 0x3fff, 0x7fff, 0xffff,
308 };
309
310 if (HowMany==0 || HowMany>16)
311 return 0;
312
313 if (HowMany<=(Buffer_Size%8))
314 return (LastByte>>((Buffer_Size-HowMany)%8))&Mask[HowMany];
315
316 if (HowMany>Buffer_Size)
317 {
318 Buffer_Size=0;
319 BufferUnderRun=true;
320 return 0;
321 }
322
323 const int8u* Buffer_Save=Buffer;
324
325 int8u NewBits=HowMany-(Buffer_Size%8);
326 if (NewBits==16)
327 ToReturn=0;
328 else
329 ToReturn=LastByte<<NewBits;
330 if ((NewBits-1)>>3)
331 {
332 NewBits-=8;
333 ToReturn|=*Buffer<<NewBits;
334 Buffer++;
335 }
336 ToReturn|=((*Buffer)>>((Buffer_Size-HowMany)%8))&Mask[NewBits];
337
338 Buffer=Buffer_Save;
339
340 return ToReturn&Mask[HowMany];
341 }
342
343 int32u Peek4(int8u HowMany)
344 {
345 int32u ToReturn;
346 static const int32u Mask[33]=
347 {
348 0x00000000,
349 0x00000001, 0x00000003, 0x00000007, 0x0000000f,
350 0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff,
351 0x000001ff, 0x000003ff, 0x000007ff, 0x00000fff,
352 0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff,
353 0x0001ffff, 0x0003ffff, 0x0007ffff, 0x000fffff,
354 0x001fffff, 0x003fffff, 0x007fffff, 0x00ffffff,
355 0x01ffffff, 0x03ffffff, 0x07ffffff, 0x0fffffff,
356 0x1fffffff, 0x3fffffff, 0x7fffffff, 0xffffffff,
357 };
358
359 if (HowMany==0 || HowMany>32)
360 return 0;
361
362 if (HowMany<=(Buffer_Size%8))
363 return (LastByte>>((Buffer_Size-HowMany)%8))&Mask[HowMany];
364
365 if (HowMany>Buffer_Size)
366 {
367 Buffer_Size=0;
368 BufferUnderRun=true;
369 return 0;
370 }
371
372 const int8u* Buffer_Save=Buffer;
373
374 int8u NewBits=HowMany-(Buffer_Size%8);
375 if (NewBits==32)
376 ToReturn=0;
377 else
378 ToReturn=LastByte<<NewBits;
379 switch ((NewBits-1)>>3)
380 {
381 case 3 : NewBits-=8;
382 ToReturn|=*Buffer<<NewBits;
383 Buffer++;
384 [[fallthrough]];
385 case 2 : NewBits-=8;
386 ToReturn|=*Buffer<<NewBits;
387 Buffer++;
388 [[fallthrough]];
389 case 1 : NewBits-=8;
390 ToReturn|=*Buffer<<NewBits;
391 Buffer++;
392 }
393 ToReturn|=((*Buffer)>>((Buffer_Size-HowMany)%8))&Mask[NewBits];
394
395 Buffer=Buffer_Save;
396
397 return ToReturn&Mask[HowMany];
398 }
399
400 int64u Peek8(int8u HowMany)
401 {
402 return (int64u)Peek4(HowMany); //Not yet implemented
403 }
404
405 inline size_t Remain () const //How many bits remain?
406 {
407 return Buffer_Size;
408 }
409
410 inline void Byte_Align()
411 {
412 Skip (Buffer_Size%8);
413 }
414
415 inline size_t Offset_Get() const
416 {
417 return (Buffer_Size_Init-Buffer_Size)/8;
418 }
419
420 inline size_t BitOffset_Get() const
421 {
422 return Buffer_Size%8;
423 }
424
425 inline size_t OffsetBeforeLastCall_Get() const //No more valid
426 {
427 return Buffer_Size%8;
428 }
429
430 inline void Resize(size_t Size_) //Size_ is the new count of remaining bits, must have the same alignment as Remain()
431 {
432 if (BufferUnderRun && Size_>Buffer_Size)
433 BufferUnderRun=false;
434 Buffer_Size=Size_;
435 }
436
437private :
438 const int8u* Buffer;
439 size_t Buffer_Size;
440 size_t Buffer_Size_Init;
441 int8u LastByte;
442public :
444};
445
446} //namespace ZenLib
447#endif
#define NULL
Definition HTTPClientWrapper.h:98
BitStream_Fast(const int8u *Buffer_, size_t Size_)
Definition BitStream_Fast.h:38
int64u Get8(int8u HowMany)
Definition BitStream_Fast.h:211
void Skip(size_t HowMany)
Definition BitStream_Fast.h:229
int32u Get4(int8u HowMany)
Definition BitStream_Fast.h:157
bool GetB()
Definition BitStream_Fast.h:52
size_t OffsetBeforeLastCall_Get() const
Definition BitStream_Fast.h:425
int16u Peek2(int8u HowMany)
Definition BitStream_Fast.h:298
bool BufferUnderRun
Definition BitStream_Fast.h:443
size_t BitOffset_Get() const
Definition BitStream_Fast.h:420
void Resize(size_t Size_)
Definition BitStream_Fast.h:430
int8u Peek1(int8u HowMany)
Definition BitStream_Fast.h:265
bool PeekB()
Definition BitStream_Fast.h:250
~BitStream_Fast()
Definition BitStream_Fast.h:43
size_t Offset_Get() const
Definition BitStream_Fast.h:415
int64u Peek8(int8u HowMany)
Definition BitStream_Fast.h:400
void Byte_Align()
Definition BitStream_Fast.h:410
void Attach(const int8u *Buffer_, size_t Size_)
Definition BitStream_Fast.h:45
int32u Peek4(int8u HowMany)
Definition BitStream_Fast.h:343
int16u Get2(int8u HowMany)
Definition BitStream_Fast.h:111
BitStream_Fast()
Definition BitStream_Fast.h:33
size_t Remain() const
Definition BitStream_Fast.h:405
int8u Get1(int8u HowMany)
Definition BitStream_Fast.h:73
Definition BitStream.h:24