Octane v1.01.20 - The Open Compression Toolkit for C++

http://octane.sourceforge.net/

bitio/bitreader.hpp

Go to the documentation of this file.

//
// bitreader  --  wrapper class for bit input
//
// Copyright (c) 2003 by Jørgen Ibsen / Jibz
// All Rights Reserved
//
// http://www.ibsensoftware.com/
//


#ifndef BITREADER_HPP_INCLUDED
#define BITREADER_HPP_INCLUDED

#include <iostream>
#include <string>
#include <cstddef>
#include <climits>

// ms vc (.net2003) warning about performance loss when casting int to bool
#ifdef _MSC_VER
#pragma warning(disable:4800)
#endif

class bitreader {

public:
    bitreader(size_t size_in_bits=0)
        : offs(0), length(size_in_bits), current(0), mask(0) { ; }

    virtual ~bitreader() { ; }

public:
    virtual bool error() const { return false; }

    void align_byte() { offs = (offs + 7) & ~0x0007; mask = 0; }

public:

    bool empty() const { return offs >= length; }
    size_t bits_left() const { return length - offs; }
    size_t bytes_left() const { return bits_left() / 8; }

    size_t get_bit_length() const { return length; }

    size_t get_byte_length() const { return get_bit_length() / 8; }

    size_t tell_bit() const { return offs; }

    size_t tell_byte() const { return tell_bit() / 8; }


public:

    virtual bool supports_seek() const = 0;

    size_t seek_bit(size_t pos) { offs = pos; reposition(); return offs; }

    size_t seek_byte(size_t pos) { return seek_bit(8 * pos); }

    size_t seek_bit(int pos, std::ios::seekdir rpos)
    {
        switch (rpos)
        {
        case std::ios::beg:
            return seek_bit(pos);
            break;
        case std::ios::cur:
            return seek_bit(offs + pos);
            break;
        case std::ios::end:
            return seek_bit(length - pos);
            break;
        }
        return 0;
    }

    size_t seek_byte(int pos, std::ios::seekdir rpos)
    {
        return seek_bit(8 * pos, rpos);
    }


public:

    bool get_bit()
    {
        ++offs;

        if (!mask)
        {
            current = read_next_byte();
            mask = 0x80;
        }

        const bool bit = (bool)(current & mask);
        mask >>= 1;

        return bit;
    }

    unsigned char get_byte()
    {
        offs += 8;

        if (!mask) return read_next_byte();

        size_t bit_offs = offs & 0x0007;
        unsigned char tmp = current << (unsigned char)bit_offs;
        current = read_next_byte();

        return tmp | (current >> (8 - (unsigned char)bit_offs));
    }

    unsigned short get_word()
    {
        unsigned short v = get_byte();
        v = (v << 8) | get_byte();

        return v;
    }

    unsigned long get_dword()
    {
        unsigned long v = get_byte();
        v = (v << 8) | get_byte();
        v = (v << 8) | get_byte();
        v = (v << 8) | get_byte();

        return v;
    }

    float get_float()
    {
        float v;
        read((char*)&v, sizeof(float));
        return v;
    }

    double get_double()
    {
        double v;
        read((char*)&v, sizeof(double));
        return v;
    }

    std::string get_string()
    {
        size_t len = get_word();

        if (len == 0) len = get_dword();

        std::string s;

        s.reserve(len);
        for ( ; len; --len) s += get_byte();

        return s;
    }

    void read(char *buffer, size_t len)
    {
        for ( ; len; --len) *buffer++ = get_byte();
    }


public:

    void get(bool &v) { v = get_bit(); }
    void get(char &v) { v = get_byte(); }
    void get(unsigned char &v) { v = get_byte(); }
    void get(short &v) { v = get_word(); }
    void get(unsigned short &v) { v = get_word(); }
#if UINT_MAX == 0xffff
    void get(int &v) { v = get_word(); }
    void get(unsigned int &v) { v = get_word(); }
#else
    void get(int &v) { v = get_dword(); }
    void get(unsigned int &v) { v = get_dword(); }
#endif
    void get(long &v) { v = get_dword(); }
    void get(unsigned long &v) { v = get_dword(); }

    void get(float &v) { read((char*)&v, sizeof(float)); }
    void get(double &v) { read((char*)&v, sizeof(double)); }
    void get(std::string &s) { s = get_string(); }


protected:
    void finalize() { align_byte(); }

    virtual char read_next_byte() = 0;

    virtual void set_position(size_t pos) { ; }

    void reposition()
    {
        size_t byte_offs = offs / 8;
        size_t bit_offs = offs & 0x0007;

        set_position(byte_offs);

        mask = 0;

        if (bit_offs)
        {
            mask = 1 << (7 - (unsigned int)bit_offs);

            current = read_next_byte();
        }
    }

    size_t offs;    
    size_t length;  

private:
    unsigned char current;  
    unsigned char mask;     
};

#endif // __BITREADER_HPP_INCLUDED

 

Generated on 20 May 2004 by doxygen 1.3.3