xref: /third_party/libsnd/src/ALAC/ALACBitUtilities.c

/*
 * Copyright (c) 2011 Apple Inc. All rights reserved.
 *
 * @APPLE_APACHE_LICENSE_HEADER_START@
 *
 * 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.
 *
 * @APPLE_APACHE_LICENSE_HEADER_END@
 */

/*=============================================================================
	File:		ALACBitUtilities.c

	$NoKeywords: $
=============================================================================*/

#include <stdio.h>
#include "ALACBitUtilities.h"

#define PRAGMA_MARK 0

// BitBufferInit
//
void BitBufferInit (BitBuffer * bits, uint8_t * buffer, uint32_t byteSize)
{
	bits->cur		= buffer ;
	bits->end		= bits->cur + byteSize ;
	bits->bitIndex	= 0 ;
	bits->byteSize	= byteSize ;
}

// BitBufferRead
//
uint32_t BitBufferRead (BitBuffer * bits, uint8_t numBits)
{
	uint32_t		returnBits ;

	//Assert (numBits <= 16) ;

	returnBits = ((uint32_t) bits->cur [0] << 16) | ((uint32_t) bits->cur [1] << 8) | ((uint32_t) bits->cur [2]) ;
	returnBits = returnBits << bits->bitIndex ;
	returnBits &= 0x00FFFFFF ;

	bits->bitIndex += numBits ;

	returnBits = returnBits >> (24 - numBits) ;

	bits->cur		+= (bits->bitIndex >> 3) ;
	bits->bitIndex	&= 7 ;

	//Assert (bits->cur <= bits->end) ;

	return returnBits ;
}

// BitBufferReadSmall
//
// Reads up to 8 bits
uint8_t BitBufferReadSmall (BitBuffer * bits, uint8_t numBits)
{
	uint16_t		returnBits ;

	//Assert (numBits <= 8) ;

	returnBits = (bits->cur [0] << 8) | bits->cur [1] ;
	returnBits = returnBits << bits->bitIndex ;

	bits->bitIndex += numBits ;

	returnBits = returnBits >> (16 - numBits) ;

	bits->cur		+= (bits->bitIndex >> 3) ;
	bits->bitIndex	&= 7 ;

	//Assert (bits->cur <= bits->end) ;

	return (uint8_t) returnBits ;
}

// BitBufferReadOne
//
// Reads one byte
uint8_t BitBufferReadOne (BitBuffer * bits)
{
	uint8_t		returnBits ;

	returnBits = (bits->cur [0] >> (7 - bits->bitIndex)) & 1 ;

	bits->bitIndex++ ;

	bits->cur		+= (bits->bitIndex >> 3) ;
	bits->bitIndex	&= 7 ;

	//Assert (bits->cur <= bits->end) ;

	return returnBits ;
}

// BitBufferPeek
//
uint32_t BitBufferPeek (BitBuffer * bits, uint8_t numBits)
{
	return ((((((uint32_t) bits->cur [0] << 16) | ((uint32_t) bits->cur [1] << 8) |
			((uint32_t) bits->cur [2])) << bits->bitIndex) & 0x00FFFFFF) >> (24 - numBits)) ;
}

// BitBufferPeekOne
//
uint32_t BitBufferPeekOne (BitBuffer * bits)
{
	return ((bits->cur [0] >> (7 - bits->bitIndex)) & 1) ;
}

// BitBufferUnpackBERSize
//
uint32_t BitBufferUnpackBERSize (BitBuffer * bits)
{
	uint32_t		size ;
	uint8_t		tmp ;

	for (size = 0, tmp = 0x80u ; tmp &= 0x80u ; size = (size << 7u) | (tmp & 0x7fu))
		tmp = (uint8_t) BitBufferReadSmall (bits, 8) ;

	return size ;
}

// BitBufferGetPosition
//
uint32_t BitBufferGetPosition (BitBuffer * bits)
{
	uint8_t *		begin ;

	begin = bits->end - bits->byteSize ;

	return ((uint32_t) (bits->cur - begin) * 8) + bits->bitIndex ;
}

// BitBufferByteAlign
//
void BitBufferByteAlign (BitBuffer * bits, int32_t addZeros)
{
	// align bit buffer to next byte boundary, writing zeros if requested
	if (bits->bitIndex == 0)
		return ;

	if (addZeros)
		BitBufferWrite (bits, 0, 8 - bits->bitIndex) ;
	else
		BitBufferAdvance (bits, 8 - bits->bitIndex) ;
}

// BitBufferAdvance
//
void BitBufferAdvance (BitBuffer * bits, uint32_t numBits)
{
	if (numBits)
	{
		bits->bitIndex += numBits ;
		bits->cur += (bits->bitIndex >> 3) ;
		bits->bitIndex &= 7 ;
	}
}

// BitBufferRewind
//
void BitBufferRewind (BitBuffer * bits, uint32_t numBits)
{
	uint32_t	numBytes ;

	if (numBits == 0)
		return ;

	if (bits->bitIndex >= numBits)
	{
		bits->bitIndex -= numBits ;
		return ;
	}

	numBits -= bits->bitIndex ;
	bits->bitIndex = 0 ;

	numBytes	= numBits / 8 ;
	numBits		= numBits % 8 ;

	bits->cur -= numBytes ;

	if (numBits > 0)
	{
		bits->bitIndex = 8 - numBits ;
		bits->cur-- ;
	}

	if (bits->cur < (bits->end - bits->byteSize))
	{
		//DebugCMsg ("BitBufferRewind: Rewound too far.") ;

		bits->cur		= (bits->end - bits->byteSize) ;
		bits->bitIndex	= 0 ;
	}
}

// BitBufferWrite
//
void BitBufferWrite (BitBuffer * bits, uint32_t bitValues, uint32_t numBits)
{
	uint32_t				invBitIndex ;

	RequireAction (bits != NULL, return ;) ;
	RequireActionSilent (numBits > 0, return ;) ;

	invBitIndex = 8 - bits->bitIndex ;

	while (numBits > 0)
	{
		uint32_t		tmp ;
		uint8_t		shift ;
		uint8_t		mask ;
		uint32_t		curNum ;

		curNum = MIN (invBitIndex, numBits) ;

		tmp = bitValues >> (numBits - curNum) ;

		shift = (uint8_t) (invBitIndex - curNum) ;
		mask = 0xffu >> (8 - curNum) ;		// must be done in two steps to avoid compiler sequencing ambiguity
		mask <<= shift ;

		bits->cur [0] = (bits->cur [0] & ~mask) | (((uint8_t) tmp << shift) & mask) ;
		numBits -= curNum ;

		// increment to next byte if need be
		invBitIndex -= curNum ;
		if (invBitIndex == 0)
		{
			invBitIndex = 8 ;
			bits->cur++ ;
		}
	}

	bits->bitIndex = 8 - invBitIndex ;
}

void	BitBufferReset (BitBuffer * bits)
//void BitBufferInit (BitBuffer * bits, uint8_t * buffer, uint32_t byteSize)
{
	bits->cur = bits->end - bits->byteSize ;
	bits->bitIndex = 0 ;
}

#if PRAGMA_MARK
#pragma mark -
#endif