summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/SDL2/Xcode-iOS/SDLtest/SDL2test.xcodeproj
diff options
context:
space:
mode:
author ajrhacker <ajrhacker@users.noreply.github.com>2020-10-15 14:19:46 -0400
committer GitHub <noreply@github.com>2020-10-15 14:19:46 -0400
commitfc8330e65cb0713a1931b7b3d771c37d5ffd020b (patch)
tree682d95a450f88e1572b24e5fcfc4943cd76ac579 /3rdparty/SDL2/Xcode-iOS/SDLtest/SDL2test.xcodeproj
parent24d5367e8f65feb24bc763dbf0679854d773e03e (diff)
parenta75bbae7906420de48a145979bd3c761980b3557 (diff)
Merge pull request #7346 from felipesanches/sony_video_equipment
New non-working driver: SONY DFS-500 DME Video Mixer (1994)
Diffstat (limited to '3rdparty/SDL2/Xcode-iOS/SDLtest/SDL2test.xcodeproj')
0 files changed, 0 insertions, 0 deletions
148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242
// license:BSD-3-Clause
// copyright-holders:Aaron Giles
/***************************************************************************

    bitstream.h

    Helper classes for reading/writing at the bit level.

***************************************************************************/

#pragma once

#ifndef __BITSTREAM_H__
#define __BITSTREAM_H__

#include "osdcore.h"


//**************************************************************************
//  TYPE DEFINITIONS
//**************************************************************************

// helper class for reading from a bit buffer
class bitstream_in
{
public:
	// construction/destruction
	bitstream_in(const void *src, UINT32 srclength);

	// getters
	bool overflow() const { return ((m_doffset - m_bits / 8) > m_dlength); }
	UINT32 read_offset() const;

	// operations
	UINT32 read(int numbits);
	UINT32 peek(int numbits);
	void remove(int numbits);
	UINT32 flush();

private:
	// internal state
	UINT32          m_buffer;       // current bit accumulator
	int             m_bits;         // number of bits in the accumulator
	const UINT8 *   m_read;         // read pointer
	UINT32          m_doffset;      // byte offset within the data
	UINT32          m_dlength;      // length of the data
};


// helper class for writing to a bit buffer
class bitstream_out
{
public:
	// construction/destruction
	bitstream_out(void *dest, UINT32 destlength);

	// getters
	bool overflow() const { return (m_doffset > m_dlength); }

	// operations
	void write(UINT32 newbits, int numbits);
	UINT32 flush();

private:
	// internal state
	UINT32          m_buffer;           // current bit accumulator
	int             m_bits;             // number of bits in the accumulator
	UINT8 *         m_write;            // write pointer
	UINT32          m_doffset;          // byte offset within the data
	UINT32          m_dlength;          // length of the data
};



//**************************************************************************
//  INLINE FUNCTIONS
//**************************************************************************

//-------------------------------------------------
//  bitstream_in - constructor
//-------------------------------------------------

inline bitstream_in::bitstream_in(const void *src, UINT32 srclength)
	: m_buffer(0),
		m_bits(0),
		m_read(reinterpret_cast<const UINT8 *>(src)),
		m_doffset(0),
		m_dlength(srclength)
{
}


//-------------------------------------------------
//  peek - fetch the requested number of bits
//  but don't advance the input pointer
//-------------------------------------------------

inline UINT32 bitstream_in::peek(int numbits)
{
	if (numbits == 0)
		return 0;

	// fetch data if we need more
	if (numbits > m_bits)
	{
		while (m_bits <= 24)
		{
			if (m_doffset < m_dlength)
				m_buffer |= m_read[m_doffset] << (24 - m_bits);
			m_doffset++;
			m_bits += 8;
		}
	}

	// return the data
	return m_buffer >> (32 - numbits);
}


//-------------------------------------------------
//  remove - advance the input pointer by the
//  specified number of bits
//-------------------------------------------------

inline void bitstream_in::remove(int numbits)
{
	m_buffer <<= numbits;
	m_bits -= numbits;
}


//-------------------------------------------------
//  read - fetch the requested number of bits
//-------------------------------------------------

inline UINT32 bitstream_in::read(int numbits)
{
	UINT32 result = peek(numbits);
	remove(numbits);
	return result;
}


//-------------------------------------------------
//  read_offset - return the current read offset
//-------------------------------------------------

inline UINT32 bitstream_in::read_offset() const
{
	UINT32 result = m_doffset;
	int bits = m_bits;
	while (bits >= 8)
	{
		result--;
		bits -= 8;
	}
	return result;
}


//-------------------------------------------------
//  flush - flush to the nearest byte
//-------------------------------------------------

inline UINT32 bitstream_in::flush()
{
	while (m_bits >= 8)
	{
		m_doffset--;
		m_bits -= 8;
	}
	m_bits = m_buffer = 0;
	return m_doffset;
}


//-------------------------------------------------
//  bitstream_out - constructor
//-------------------------------------------------

inline bitstream_out::bitstream_out(void *dest, UINT32 destlength)
	: m_buffer(0),
		m_bits(0),
		m_write(reinterpret_cast<UINT8 *>(dest)),
		m_doffset(0),
		m_dlength(destlength)
{
}



//-------------------------------------------------
//  write - write the given number of bits to the
//  data stream
//-------------------------------------------------

inline void bitstream_out::write(UINT32 newbits, int numbits)
{
	// flush the buffer if we're going to overflow it
	if (m_bits + numbits > 32)
		while (m_bits >= 8)
		{
			if (m_doffset < m_dlength)
				m_write[m_doffset] = m_buffer >> 24;
			m_doffset++;
			m_buffer <<= 8;
			m_bits -= 8;
		}

	// shift the bits to the top
	if (numbits == 0)
		newbits = 0;
	else
		newbits <<= 32 - numbits;

	// now shift it down to account for the number of bits we already have and OR them in
	m_buffer |= newbits >> m_bits;
	m_bits += numbits;
}


//-------------------------------------------------
//  flush - output remaining bits and return the
//  final output size in bytes
//-------------------------------------------------

inline UINT32 bitstream_out::flush()
{
	while (m_bits > 0)
	{
		if (m_doffset < m_dlength)
			m_write[m_doffset] = m_buffer >> 24;
		m_doffset++;
		m_buffer <<= 8;
		m_bits -= 8;
	}
	m_bits = m_buffer = 0;
	return m_doffset;
}


#endif