BitsReader.h

Go to the documentation of this file.

// BitsReader.h:  bits reader, for Gnash.
// 
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
//   Free Software Foundation, Inc
// 
// This program 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.
// 
// This program 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 this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//


#ifndef BITSREADER_H
#define BITSREADER_H

#include "dsodefs.h"
#include "log.h"

#include <cassert>
#include <cstdint> // for std::uint32_t used in this file

namespace gnash {

//
class DSOEXPORT BitsReader 
{
public:
        typedef unsigned char byte;

        BitsReader(const byte* input, size_t len)
                :
                start(input),
                ptr(start),
                end(start+len),
                usedBits(0)
        {
        }

        //
        BitsReader(const BitsReader& from, size_t len)
                :
                start(from.ptr),
                ptr(start),
                end(start+len),
                usedBits(from.usedBits) 
        {
        }

        ~BitsReader() {}

        size_t size() const
        {
                return end-start;
        }

        void setBuffer(byte* input, size_t len)
        {
                start = ptr = input;
                end = start+len;
                usedBits = 0;
        }

        unsigned read_uint(unsigned short bitcount);

        bool read_bit();

        std::int32_t read_sint(unsigned short bitcount);

        std::uint8_t  read_u8()
        {
                align();
                return *ptr++;
        }

    std::int8_t read_s8()
        {
                return static_cast<std::int8_t>(read_u8());
        }

        std::uint16_t read_u16()
        {
                align();
                assert(ptr+2 < end);
                std::uint16_t result = *ptr++;
                result |= *ptr++ << 8;
                return result ;
        }

        std::int16_t    read_s16()
        {
                return static_cast<std::int16_t>(read_u16());
        }

        std::uint32_t read_u32()
        {
                align();
                assert(ptr+4 < end);
                std::uint32_t result = *ptr++;
                result |= *ptr++ << 8;
                result |= *ptr++ << 16;
                result |= *ptr++ << 24;
                return(result);
        }

        std::int32_t read_s32()
        {
                return static_cast<std::int32_t>(read_u32());
        }

        void align()
        {
                if ( usedBits ) advanceToNextByte();
        }

        bool gotBits(std::uint32_t nbits) const
        {
                std::uint32_t gotbits = 8-usedBits +8*(end-ptr-1);
                if (gotbits > nbits) return true;
                else return false;
        }

private:

        void advanceToNextByte()
        {
                if ( ++ptr == end )
                {
                        log_debug(_("Going round"));
                        ptr=start;
                }
                usedBits=0;
        }

        const byte* start;

        const byte* ptr;

        const byte* end;

        unsigned usedBits;

};


}       // end namespace gnash


#endif // BITSREADER_H


// Local Variables:
// mode: C++
// c-basic-offset: 8 
// tab-width: 8
// indent-tabs-mode: t
// End: