bitstream.h

Go to the documentation of this file.

/* xoreos - A reimplementation of BioWare's Aurora engine
 *
 * xoreos is the legal property of its developers, whose names
 * can be found in the AUTHORS file distributed with this source
 * distribution.
 *
 * xoreos is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 3
 * of the License, or (at your option) any later version.
 *
 * xoreos is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with xoreos. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef COMMON_BITSTREAM_H
#define COMMON_BITSTREAM_H

#include <cassert>

#include <boost/noncopyable.hpp>

#include "src/common/types.h"
#include "src/common/disposableptr.h"
#include "src/common/error.h"
#include "src/common/readstream.h"

namespace Common {

class BitStream {
public:
    virtual ~BitStream() {
    }

    virtual size_t pos() const = 0;

    virtual size_t size() const = 0;

    virtual bool eos() const = 0;

    virtual void rewind() = 0;

    virtual void skip(size_t n) = 0;

    virtual uint32 getBit() = 0;

    virtual uint32 getBits(size_t n) = 0;

    virtual void addBit(uint32 &x, size_t n) = 0;

protected:
    BitStream() {
    }
};

template<int valueBits, bool isLE, bool isMSB2LSB>
class BitStreamImpl : boost::noncopyable, public BitStream {
private:
    DisposablePtr<SeekableReadStream> _stream; 

    uint64 _value;   
    uint8  _inValue; 

    inline uint64 readData() {
        if (isLE) {
            if (valueBits ==  8)
                return _stream->readByte();
            if (valueBits == 16)
                return _stream->readUint16LE();
            if (valueBits == 32)
                return _stream->readUint32LE();
            if (valueBits == 64)
                return _stream->readUint64LE();
        } else {
            if (valueBits ==  8)
                return _stream->readByte();
            if (valueBits == 16)
                return _stream->readUint16BE();
            if (valueBits == 32)
                return _stream->readUint32BE();
            if (valueBits == 64)
                return _stream->readUint64BE();
        }

        assert(false);
        return 0;
    }

    inline void readValue() {
        if ((size() - pos()) < valueBits)
            throw Exception("BitStream::readValue(): End of bit stream reached");

        _value = readData();

        // If we're reading the bits MSB first, we need to shift the value to that position
        if (isMSB2LSB)
            _value <<= 64 - valueBits;
        }

public:
    BitStreamImpl(SeekableReadStream *stream, bool disposeAfterUse = false) :
        _stream(stream, disposeAfterUse), _value(0), _inValue(0) {

        assert(_stream);

        if ((valueBits != 8) && (valueBits != 16) && (valueBits != 32) && (valueBits != 64))
            throw Exception("BitStream: Invalid memory layout %d, %d, %d", valueBits, isLE, isMSB2LSB);
    }

    BitStreamImpl(SeekableReadStream &stream) :
        _stream(&stream, false), _value(0), _inValue(0) {

        if ((valueBits != 8) && (valueBits != 16) && (valueBits != 32) && (valueBits != 64))
            throw Exception("BitStream: Invalid memory layout %d, %d, %d", valueBits, isLE, isMSB2LSB);
    }

    ~BitStreamImpl() {
    }

    uint32 getBit() {
        // Check if we need the next value
        if (_inValue == 0)
            readValue();

        // Get the current bit
        int b = 0;
        if (isMSB2LSB)
            b = ((_value & 0x8000000000000000ULL) == 0) ? 0 : 1;
        else
            b = ((_value & 1) == 0) ? 0 : 1;

        // Shift to the next bit
        if (isMSB2LSB)
            _value <<= 1;
        else
            _value >>= 1;

        // Increase the position within the current value
        _inValue = (_inValue + 1) % valueBits;

        return b;
    }

    uint32 getBits(size_t n) {
        if (n == 0)
            return 0;

        if (n > 32)
            throw Exception("Too many bits requested to be read");

        // Read the number of bits
        uint32 v = 0;

        if (isMSB2LSB) {
            while (n-- > 0)
                v = (v << 1) | getBit();
        } else {
            for (uint32 i = 0; i < n; i++)
                v = (v >> 1) | (((uint32) getBit()) << 31);

            v >>= (32 - n);
        }

        return v;
    }

    void addBit(uint32 &x, size_t n) {
        if (n >= 32)
            throw Exception("Too many bits requested to be read");

        if (isMSB2LSB)
            x = (x << 1) | getBit();
        else
            x = (x & ~(1 << n)) | (getBit() << n);
    }

    void rewind() {
        _stream->seek(0);

        _value   = 0;
        _inValue = 0;
    }

    void skip(size_t n) {
        while (n-- > 0)
            getBit();
    }

    size_t pos() const {
        if (_stream->pos() == 0)
            return 0;

        size_t p = (_inValue == 0) ? _stream->pos() : ((_stream->pos() - 1) & ~((size_t) ((valueBits >> 3) - 1)));
        return p * 8 + _inValue;
    }

    size_t size() const {
        return (_stream->size() & ~((size_t) ((valueBits >> 3) - 1))) * 8;
    }

    bool eos() const {
        return _stream->eos() || (pos() >= size());
    }
};

// typedefs for various memory layouts.

typedef BitStreamImpl<8, false, true > BitStream8MSB;
typedef BitStreamImpl<8, false, false> BitStream8LSB;

typedef BitStreamImpl<16, true , true > BitStream16LEMSB;
typedef BitStreamImpl<16, true , false> BitStream16LELSB;
typedef BitStreamImpl<16, false, true > BitStream16BEMSB;
typedef BitStreamImpl<16, false, false> BitStream16BELSB;

typedef BitStreamImpl<32, true , true > BitStream32LEMSB;
typedef BitStreamImpl<32, true , false> BitStream32LELSB;
typedef BitStreamImpl<32, false, true > BitStream32BEMSB;
typedef BitStreamImpl<32, false, false> BitStream32BELSB;

typedef BitStreamImpl<64, true , true > BitStream64LEMSB;
typedef BitStreamImpl<64, true , false> BitStream64LELSB;
typedef BitStreamImpl<64, false, true > BitStream64BEMSB;
typedef BitStreamImpl<64, false, false> BitStream64BELSB;

} // End of namespace Common

#endif // COMMON_BITSTREAM_H