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 
23 namespace ZenLib
24 {
25 
26 #ifndef MIN
27  #define MIN(a, b) (((a) < (b)) ? (a) : (b))
28 #endif
29 
31 {
32 public:
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 
437 private :
438  const int8u* Buffer;
439  size_t Buffer_Size;
440  size_t Buffer_Size_Init;
441  int8u LastByte;
442 public :
444 };
445 
446 } //namespace ZenLib
447 #endif
#define NULL
Definition: HTTPClientWrapper.h:98
Definition: BitStream_Fast.h:31
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