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"

// 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 != nil, 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