bitstreamwriter.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_BITSTREAMWRITER_H
#define COMMON_BITSTREAMWRITER_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/writestream.h"

namespace Common {

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

    virtual void putBit(bool bit) = 0;

    virtual void putBits(uint32 bits, size_t n) = 0;

    virtual void flush() = 0;

protected:
    BitStreamWriter() {
    }
};

template<int valueBits, bool isLE, bool isMSB2LSB>
class BitStreamWriterImpl : boost::noncopyable, public BitStreamWriter {
private:
    DisposablePtr<WriteStream> _stream; 

    uint64 _value;   
    uint8  _inValue; 

    inline void writeData(uint64 data) {
        if (isLE) {
            if (valueBits ==  8)
                _stream->writeByte(data);
            if (valueBits == 16)
                _stream->writeUint16LE(data);
            if (valueBits == 32)
                _stream->writeUint32LE(data);
            if (valueBits == 64)
                _stream->writeUint64LE(data);
        } else {
            if (valueBits ==  8)
                _stream->writeByte(data);
            if (valueBits == 16)
                _stream->writeUint16BE(data);
            if (valueBits == 32)
                _stream->writeUint32BE(data);
            if (valueBits == 64)
                _stream->writeUint64BE(data);
        }
    }

    inline void writeValue() {
        /* If we're writing the bits LSB first, they accumulate at the upper parts of the value data.
         * We need to shift them down before writing it to the byte stream. */
        if (!isMSB2LSB)
            _value >>= 64 - valueBits;

        writeData(_value);
        _value = 0;
    }

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

        assert(_stream);

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

    BitStreamWriterImpl(WriteStream &stream) :
        _stream(&stream, false), _value(0), _inValue(0) {

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

    ~BitStreamWriterImpl() {
    }

    void putBit(bool bit) {
        // Put the bit, according to the writing direction
        if (isMSB2LSB)
            _value = (_value << 1) | (bit ? 1 : 0);
        else
            _value = (_value >> 1) | (static_cast<uint64>(bit ? 1 : 0) << 63);

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

        // Check if we have a full value to write
        if (_inValue == 0)
            writeValue();
    }

    void putBits(uint32 bits, size_t n) {
        if (n == 0)
            return;

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

        if (isMSB2LSB)
            bits <<= 32 - n;

        while (n-- > 0) {
            if (isMSB2LSB) {
                putBit(bits & 0x80000000);
                bits <<= 1;
            } else {
                putBit(bits & 1);
                bits >>= 1;
            }
        }
    }

    void flush() {
        if (_inValue > 0) {
            const size_t padding = valueBits - _inValue;
            if (isMSB2LSB)
                _value <<= padding;
            else
                _value >>= padding;

            writeValue();
            _inValue = 0;
        }

        _stream->flush();
    }
};

// typedefs for various memory layouts.

typedef BitStreamWriterImpl<8, false, true > BitStreamWriter8MSB;
typedef BitStreamWriterImpl<8, false, false> BitStreamWriter8LSB;

typedef BitStreamWriterImpl<16, true , true > BitStreamWriter16LEMSB;
typedef BitStreamWriterImpl<16, true , false> BitStreamWriter16LELSB;
typedef BitStreamWriterImpl<16, false, true > BitStreamWriter16BEMSB;
typedef BitStreamWriterImpl<16, false, false> BitStreamWriter16BELSB;

typedef BitStreamWriterImpl<32, true , true > BitStreamWriter32LEMSB;
typedef BitStreamWriterImpl<32, true , false> BitStreamWriter32LELSB;
typedef BitStreamWriterImpl<32, false, true > BitStreamWriter32BEMSB;
typedef BitStreamWriterImpl<32, false, false> BitStreamWriter32BELSB;

typedef BitStreamWriterImpl<64, true , true > BitStreamWriter64LEMSB;
typedef BitStreamWriterImpl<64, true , false> BitStreamWriter64LELSB;
typedef BitStreamWriterImpl<64, false, true > BitStreamWriter64BEMSB;
typedef BitStreamWriterImpl<64, false, false> BitStreamWriter64BELSB;

} // End of namespace Common

#endif // COMMON_BITSTREAMWRITER_H