/src/FreeRDP/winpr/include/winpr/bitstream.h

Source (jump to first uncovered line)
/*
 * WinPR: Windows Portable Runtime
 * BitStream Utils
 *
 * Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef WINPR_UTILS_BITSTREAM_H
#define WINPR_UTILS_BITSTREAM_H

#include <winpr/assert.h>
#include <winpr/winpr.h>
#include <winpr/wtypes.h>

#include <winpr/crt.h>
#include <winpr/wlog.h>

typedef struct
{
  const BYTE* buffer;
  BYTE* pointer;
  UINT32 position;
  UINT32 length;
  UINT32 capacity;
  UINT32 mask;
  UINT32 offset;
  UINT32 prefetch;
  UINT32 accumulator;
} wBitStream;

#define BITDUMP_MSB_FIRST 0x00000001
#define BITDUMP_STDERR 0x00000002

#ifdef __cplusplus
extern "C"
{
#endif

  static INLINE void BitStream_Prefetch(wBitStream* _bs)
  {
    WINPR_ASSERT(_bs);

    (_bs->prefetch) = 0;

    const intptr_t diff = _bs->pointer - _bs->buffer;
    if ((diff + 4) < (intptr_t)_bs->capacity)
      (_bs->prefetch) |= ((UINT32)_bs->pointer[4] << 24);
    if ((diff + 5) < (intptr_t)_bs->capacity)
      (_bs->prefetch) |= ((UINT32)_bs->pointer[5] << 16);
    if ((diff + 6) < (intptr_t)_bs->capacity)
      (_bs->prefetch) |= ((UINT32)_bs->pointer[6] << 8);
    if ((diff + 7) < (intptr_t)_bs->capacity)
      (_bs->prefetch) |= ((UINT32)_bs->pointer[7] << 0);
  }

  static INLINE void BitStream_Fetch(wBitStream* _bs)
  {
    WINPR_ASSERT(_bs);
    (_bs->accumulator) = 0;

    const intptr_t diff = _bs->pointer - _bs->buffer;
    if ((diff + 0) < (intptr_t)_bs->capacity)
      (_bs->accumulator) |= ((UINT32)_bs->pointer[0] << 24);
    if ((diff + 1) < (intptr_t)_bs->capacity)
      (_bs->accumulator) |= ((UINT32)_bs->pointer[1] << 16);
    if ((diff + 2) < (intptr_t)_bs->capacity)
      (_bs->accumulator) |= ((UINT32)_bs->pointer[2] << 8);
    if ((diff + 3) < (intptr_t)_bs->capacity)
      (_bs->accumulator) |= ((UINT32)_bs->pointer[3] << 0);
    BitStream_Prefetch(_bs);
  }

  static INLINE void BitStream_Flush(wBitStream* _bs)
  {
    WINPR_ASSERT(_bs);
    const intptr_t diff = _bs->pointer - _bs->buffer;
    if ((diff + 0) < (intptr_t)_bs->capacity)
      _bs->pointer[0] = (_bs->accumulator >> 24) & 0xFF;
    if ((diff + 1) < (intptr_t)_bs->capacity)
      _bs->pointer[1] = (_bs->accumulator >> 16) & 0xFF;
    if ((diff + 2) < (intptr_t)_bs->capacity)
      _bs->pointer[2] = (_bs->accumulator >> 8) & 0xFF;
    if ((diff + 3) < (intptr_t)_bs->capacity)
      _bs->pointer[3] = (_bs->accumulator >> 0) & 0xFF;
  }

  static INLINE void BitStream_Shift(wBitStream* _bs, UINT32 _nbits)
  {
    WINPR_ASSERT(_bs);
    if (_nbits == 0)
    {
    }
    else if ((_nbits > 0) && (_nbits < 32))
    {
      _bs->accumulator <<= _nbits;
      _bs->position += _nbits;
      _bs->offset += _nbits;
      if (_bs->offset < 32)
      {
        _bs->mask = (UINT32)((1UL << _nbits) - 1UL);
        _bs->accumulator |= ((_bs->prefetch >> (32 - _nbits)) & _bs->mask);
        _bs->prefetch <<= _nbits;
      }
      else
      {
        _bs->mask = (UINT32)((1UL << _nbits) - 1UL);
        _bs->accumulator |= ((_bs->prefetch >> (32 - _nbits)) & _bs->mask);
        _bs->prefetch <<= _nbits;
        _bs->offset -= 32;
        _bs->pointer += 4;
        BitStream_Prefetch(_bs);
        if (_bs->offset)
        {
          _bs->mask = (UINT32)((1UL << _bs->offset) - 1UL);
          _bs->accumulator |= ((_bs->prefetch >> (32 - _bs->offset)) & _bs->mask);
          _bs->prefetch <<= _bs->offset;
        }
      }
    }
    else
    {
      WLog_WARN("com.winpr.bitstream", "warning: BitStream_Shift(%u)", (unsigned)_nbits);
    }
  }

  static INLINE void BitStream_Shift32(wBitStream* _bs)
  {
    WINPR_ASSERT(_bs);
    BitStream_Shift(_bs, 16);
    BitStream_Shift(_bs, 16);
  }

  static INLINE void BitStream_Write_Bits(wBitStream* _bs, UINT32 _bits, UINT32 _nbits)
  {
    WINPR_ASSERT(_bs);
    _bs->position += _nbits;
    _bs->offset += _nbits;
    if (_bs->offset < 32)
    {
      _bs->accumulator |= (_bits << (32 - _bs->offset));
    }
    else
    {
      _bs->offset -= 32;
      _bs->mask = ((1 << (_nbits - _bs->offset)) - 1);
      _bs->accumulator |= ((_bits >> _bs->offset) & _bs->mask);
      BitStream_Flush(_bs);
      _bs->accumulator = 0;
      _bs->pointer += 4;
      if (_bs->offset)
      {
        _bs->mask = (UINT32)((1UL << _bs->offset) - 1);
        _bs->accumulator |= ((_bits & _bs->mask) << (32 - _bs->offset));
      }
    }
  }

  static INLINE size_t BitStream_GetRemainingLength(wBitStream* _bs)
  {
    WINPR_ASSERT(_bs);
    return (_bs->length - _bs->position);
  }

  WINPR_API void BitDump(const char* tag, UINT32 level, const BYTE* buffer, UINT32 length,
                         UINT32 flags);
  WINPR_API UINT32 ReverseBits32(UINT32 bits, UINT32 nbits);

  WINPR_API void BitStream_Attach(wBitStream* bs, const BYTE* buffer, UINT32 capacity);

  WINPR_API void BitStream_Free(wBitStream* bs);

  WINPR_ATTR_MALLOC(BitStream_Free, 1)
  WINPR_API wBitStream* BitStream_New(void);

#ifdef __cplusplus
}
#endif

#endif /* WINPR_UTILS_BITSTREAM_H */

Line	Count	Source (jump to first uncovered line)
1		/*
2		* WinPR: Windows Portable Runtime
3		* BitStream Utils
4		*
5		* Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>
6		*
7		* Licensed under the Apache License, Version 2.0 (the "License");
8		* you may not use this file except in compliance with the License.
9		* You may obtain a copy of the License at
10		*
11		* http://www.apache.org/licenses/LICENSE-2.0
12		*
13		* Unless required by applicable law or agreed to in writing, software
14		* distributed under the License is distributed on an "AS IS" BASIS,
15		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16		* See the License for the specific language governing permissions and
17		* limitations under the License.
18		*/
19
20		#ifndef WINPR_UTILS_BITSTREAM_H
21		#define WINPR_UTILS_BITSTREAM_H
22
23		#include <winpr/assert.h>
24		#include <winpr/winpr.h>
25		#include <winpr/wtypes.h>
26
27		#include <winpr/crt.h>
28		#include <winpr/wlog.h>
29
30		typedef struct
31		{
32		const BYTE* buffer;
33		BYTE* pointer;
34		UINT32 position;
35		UINT32 length;
36		UINT32 capacity;
37		UINT32 mask;
38		UINT32 offset;
39		UINT32 prefetch;
40		UINT32 accumulator;
41		} wBitStream;
42
43	0	#define BITDUMP_MSB_FIRST 0x00000001
44		#define BITDUMP_STDERR 0x00000002
45
46		#ifdef __cplusplus
47		extern "C"
48		{
49		#endif
50
51		static INLINE void BitStream_Prefetch(wBitStream* _bs)
52	0	{
53	0	WINPR_ASSERT(_bs);
54
55	0	(_bs->prefetch) = 0;
56
57	0	const intptr_t diff = _bs->pointer - _bs->buffer;
58	0	if ((diff + 4) < (intptr_t)_bs->capacity)
59	0	(_bs->prefetch) \|= ((UINT32)_bs->pointer[4] << 24);
60	0	if ((diff + 5) < (intptr_t)_bs->capacity)
61	0	(_bs->prefetch) \|= ((UINT32)_bs->pointer[5] << 16);
62	0	if ((diff + 6) < (intptr_t)_bs->capacity)
63	0	(_bs->prefetch) \|= ((UINT32)_bs->pointer[6] << 8);
64	0	if ((diff + 7) < (intptr_t)_bs->capacity)
65	0	(_bs->prefetch) \|= ((UINT32)_bs->pointer[7] << 0);
66	0	} Unexecuted instantiation: bulk.c:BitStream_Prefetch Unexecuted instantiation: ncrush.c:BitStream_Prefetch Unexecuted instantiation: xcrush.c:BitStream_Prefetch Unexecuted instantiation: mppc.c:BitStream_Prefetch Unexecuted instantiation: progressive.c:BitStream_Prefetch Unexecuted instantiation: clear.c:BitStream_Prefetch Unexecuted instantiation: rfx_rlgr.c:BitStream_Prefetch Unexecuted instantiation: BitStream.c:BitStream_Prefetch
67
68		static INLINE void BitStream_Fetch(wBitStream* _bs)
69	0	{
70	0	WINPR_ASSERT(_bs);
71	0	(_bs->accumulator) = 0;
72
73	0	const intptr_t diff = _bs->pointer - _bs->buffer;
74	0	if ((diff + 0) < (intptr_t)_bs->capacity)
75	0	(_bs->accumulator) \|= ((UINT32)_bs->pointer[0] << 24);
76	0	if ((diff + 1) < (intptr_t)_bs->capacity)
77	0	(_bs->accumulator) \|= ((UINT32)_bs->pointer[1] << 16);
78	0	if ((diff + 2) < (intptr_t)_bs->capacity)
79	0	(_bs->accumulator) \|= ((UINT32)_bs->pointer[2] << 8);
80	0	if ((diff + 3) < (intptr_t)_bs->capacity)
81	0	(_bs->accumulator) \|= ((UINT32)_bs->pointer[3] << 0);
82	0	BitStream_Prefetch(_bs);
83	0	} Unexecuted instantiation: bulk.c:BitStream_Fetch Unexecuted instantiation: ncrush.c:BitStream_Fetch Unexecuted instantiation: xcrush.c:BitStream_Fetch Unexecuted instantiation: mppc.c:BitStream_Fetch Unexecuted instantiation: progressive.c:BitStream_Fetch Unexecuted instantiation: clear.c:BitStream_Fetch Unexecuted instantiation: rfx_rlgr.c:BitStream_Fetch Unexecuted instantiation: BitStream.c:BitStream_Fetch
84
85		static INLINE void BitStream_Flush(wBitStream* _bs)
86	0	{
87	0	WINPR_ASSERT(_bs);
88	0	const intptr_t diff = _bs->pointer - _bs->buffer;
89	0	if ((diff + 0) < (intptr_t)_bs->capacity)
90	0	_bs->pointer[0] = (_bs->accumulator >> 24) & 0xFF;
91	0	if ((diff + 1) < (intptr_t)_bs->capacity)
92	0	_bs->pointer[1] = (_bs->accumulator >> 16) & 0xFF;
93	0	if ((diff + 2) < (intptr_t)_bs->capacity)
94	0	_bs->pointer[2] = (_bs->accumulator >> 8) & 0xFF;
95	0	if ((diff + 3) < (intptr_t)_bs->capacity)
96	0	_bs->pointer[3] = (_bs->accumulator >> 0) & 0xFF;
97	0	} Unexecuted instantiation: bulk.c:BitStream_Flush Unexecuted instantiation: ncrush.c:BitStream_Flush Unexecuted instantiation: xcrush.c:BitStream_Flush Unexecuted instantiation: mppc.c:BitStream_Flush Unexecuted instantiation: progressive.c:BitStream_Flush Unexecuted instantiation: clear.c:BitStream_Flush Unexecuted instantiation: rfx_rlgr.c:BitStream_Flush Unexecuted instantiation: BitStream.c:BitStream_Flush
98
99		static INLINE void BitStream_Shift(wBitStream* _bs, UINT32 _nbits)
100	0	{
101	0	WINPR_ASSERT(_bs);
102	0	if (_nbits == 0)
103	0	{
104	0	}
105	0	else if ((_nbits > 0) && (_nbits < 32))
106	0	{
107	0	_bs->accumulator <<= _nbits;
108	0	_bs->position += _nbits;
109	0	_bs->offset += _nbits;
110	0	if (_bs->offset < 32)
111	0	{
112	0	_bs->mask = (UINT32)((1UL << _nbits) - 1UL);
113	0	_bs->accumulator \|= ((_bs->prefetch >> (32 - _nbits)) & _bs->mask);
114	0	_bs->prefetch <<= _nbits;
115	0	}
116	0	else
117	0	{
118	0	_bs->mask = (UINT32)((1UL << _nbits) - 1UL);
119	0	_bs->accumulator \|= ((_bs->prefetch >> (32 - _nbits)) & _bs->mask);
120	0	_bs->prefetch <<= _nbits;
121	0	_bs->offset -= 32;
122	0	_bs->pointer += 4;
123	0	BitStream_Prefetch(_bs);
124	0	if (_bs->offset)
125	0	{
126	0	_bs->mask = (UINT32)((1UL << _bs->offset) - 1UL);
127	0	_bs->accumulator \|= ((_bs->prefetch >> (32 - _bs->offset)) & _bs->mask);
128	0	_bs->prefetch <<= _bs->offset;
129	0	}
130	0	}
131	0	}
132	0	else
133	0	{
134	0	WLog_WARN("com.winpr.bitstream", "warning: BitStream_Shift(%u)", (unsigned)_nbits);
135	0	}
136	0	} Unexecuted instantiation: bulk.c:BitStream_Shift Unexecuted instantiation: ncrush.c:BitStream_Shift Unexecuted instantiation: xcrush.c:BitStream_Shift Unexecuted instantiation: mppc.c:BitStream_Shift Unexecuted instantiation: progressive.c:BitStream_Shift Unexecuted instantiation: clear.c:BitStream_Shift Unexecuted instantiation: rfx_rlgr.c:BitStream_Shift Unexecuted instantiation: BitStream.c:BitStream_Shift
137
138		static INLINE void BitStream_Shift32(wBitStream* _bs)
139	0	{
140	0	WINPR_ASSERT(_bs);
141	0	BitStream_Shift(_bs, 16);
142	0	BitStream_Shift(_bs, 16);
143	0	} Unexecuted instantiation: bulk.c:BitStream_Shift32 Unexecuted instantiation: ncrush.c:BitStream_Shift32 Unexecuted instantiation: xcrush.c:BitStream_Shift32 Unexecuted instantiation: mppc.c:BitStream_Shift32 Unexecuted instantiation: progressive.c:BitStream_Shift32 Unexecuted instantiation: clear.c:BitStream_Shift32 Unexecuted instantiation: rfx_rlgr.c:BitStream_Shift32 Unexecuted instantiation: BitStream.c:BitStream_Shift32
144
145		static INLINE void BitStream_Write_Bits(wBitStream* _bs, UINT32 _bits, UINT32 _nbits)
146	0	{
147	0	WINPR_ASSERT(_bs);
148	0	_bs->position += _nbits;
149	0	_bs->offset += _nbits;
150	0	if (_bs->offset < 32)
151	0	{
152	0	_bs->accumulator \|= (_bits << (32 - _bs->offset));
153	0	}
154	0	else
155	0	{
156	0	_bs->offset -= 32;
157	0	_bs->mask = ((1 << (_nbits - _bs->offset)) - 1);
158	0	_bs->accumulator \|= ((_bits >> _bs->offset) & _bs->mask);
159	0	BitStream_Flush(_bs);
160	0	_bs->accumulator = 0;
161	0	_bs->pointer += 4;
162	0	if (_bs->offset)
163	0	{
164	0	_bs->mask = (UINT32)((1UL << _bs->offset) - 1);
165	0	_bs->accumulator \|= ((_bits & _bs->mask) << (32 - _bs->offset));
166	0	}
167	0	}
168	0	} Unexecuted instantiation: bulk.c:BitStream_Write_Bits Unexecuted instantiation: ncrush.c:BitStream_Write_Bits Unexecuted instantiation: xcrush.c:BitStream_Write_Bits Unexecuted instantiation: mppc.c:BitStream_Write_Bits Unexecuted instantiation: progressive.c:BitStream_Write_Bits Unexecuted instantiation: clear.c:BitStream_Write_Bits Unexecuted instantiation: rfx_rlgr.c:BitStream_Write_Bits Unexecuted instantiation: BitStream.c:BitStream_Write_Bits
169
170		static INLINE size_t BitStream_GetRemainingLength(wBitStream* _bs)
171	0	{
172	0	WINPR_ASSERT(_bs);
173	0	return (_bs->length - _bs->position);
174	0	} Unexecuted instantiation: bulk.c:BitStream_GetRemainingLength Unexecuted instantiation: ncrush.c:BitStream_GetRemainingLength Unexecuted instantiation: xcrush.c:BitStream_GetRemainingLength Unexecuted instantiation: mppc.c:BitStream_GetRemainingLength Unexecuted instantiation: progressive.c:BitStream_GetRemainingLength Unexecuted instantiation: clear.c:BitStream_GetRemainingLength Unexecuted instantiation: rfx_rlgr.c:BitStream_GetRemainingLength Unexecuted instantiation: BitStream.c:BitStream_GetRemainingLength
175
176		WINPR_API void BitDump(const char* tag, UINT32 level, const BYTE* buffer, UINT32 length,
177		UINT32 flags);
178		WINPR_API UINT32 ReverseBits32(UINT32 bits, UINT32 nbits);
179
180		WINPR_API void BitStream_Attach(wBitStream* bs, const BYTE* buffer, UINT32 capacity);
181
182		WINPR_API void BitStream_Free(wBitStream* bs);
183
184		WINPR_ATTR_MALLOC(BitStream_Free, 1)
185		WINPR_API wBitStream* BitStream_New(void);
186
187		#ifdef __cplusplus
188		}
189		#endif
190
191		#endif /* WINPR_UTILS_BITSTREAM_H */

Coverage Report

Created: 2025-07-01 06:46