fbase.h

这是一个用VC++开发的flashsource端的程序

#ifndef FBASE_H_FILE
#define FBASE_H_FILE


#pragma warning( disable : 4996 )
#pragma warning( disable : 4786 )

#include <iostream>
#include <vector>
#include <math.h>

/*static unsigned long arr1[] = {
		0x0, 0x1, 0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f, 0xff,
        0x1ff, 0x3ff, 0x7ff, 0xfff, 0x1fff, 0x3fff, 0x7fff, 0xffff,
        0x1ffff, 0x3ffff, 0x7ffff, 0xfffff, 0x1fffff, 0x3fffff, 0x7fffff, 0xffffff,
        0x1ffffff, 0x3ffffff, 0x7ffffff, 0xfffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff, 0xffffffff
};*/

class FlashImporter;

typedef unsigned char UBYTE;
typedef char SBYTE;

typedef unsigned short UWORD;
typedef short SWORD;

typedef unsigned int UDWORD;
typedef int SDWORD;

#define WRITE_UBYTE(x) { UBYTE s = (x); out.write((char*)&s,1); }
#define WRITE_SBYTE(x) { SBYTE s = (x); out.write((char*)&s,1); }

#define WRITE_UWORD(x) { UWORD s = (x); out.write((char*)&s,2); }
#define WRITE_SWORD(x) { SWORD s = (x); out.write((char*)&s,2); }

#define WRITE_UDWORD(x) { UDWORD s = (x); out.write((char*)&s,4); }
#define WRITE_SDWORD(x) { SDWORD s = (x); out.write((char*)&s,4); }

#define WRITE_UBYTE2(x,f) { UBYTE s = (x); f.write((char*)&s,1); }
#define WRITE_SBYTE2(x,f) { SBYTE s = (x); f.write((char*)&s,1); }

#define WRITE_UWORD2(x,f) { UWORD s = (x); f.write((char*)&s,2); }
#define WRITE_SWORD2(x,f) { SWORD s = (x); f.write((char*)&s,2); }

#define WRITE_UDWORD2(x,f) { UDWORD s = (x); f.write((char*)&s,4); }
#define WRITE_SDWORD2(x,f) { SDWORD s = (x); f.write((char*)&s,4); }

#define READ_UBYTE(x) { in.read((char*)&x,1); }
#define READ_SBYTE(x) { in.read((char*)&x,1); }

#define READ_UWORD(x) { in.read((char*)&x,2); }
#define READ_SWORD(x) { in.read((char*)&x,2); }

#define READ_UDWORD(x) { in.read((char*)&x,4); }
#define READ_SDWORD(x) { in.read((char*)&x,4); }

#define READ_UBYTE2(x,f) { f.read((char*)&x,1); }
#define READ_SBYTE2(x,f) { f.read((char*)&x,1); }

#define READ_UWORD2(x,f) { f.read((char*)&x,2); }
#define READ_SWORD2(x,f) { f.read((char*)&x,2); }

#define READ_UDWORD2(x,f) { f.read((char*)&x,4); }
#define READ_SDWORD2(x,f) { f.read((char*)&x,4); }

#define DEFINE_RW_INTERFACE								\
public:													\
virtual void Write(std::ostream &out) { out << *this; } \
virtual void Read(std::istream &in) { in >> *this; }

template <class T> T fbase_max(T a, T b)  {return ((a > b) ? a : b); } 
template <class T> T fbase_min(T a, T b)  {return ((a < b) ? a : b); } 

template<class T, class U>
    struct flash_pair {
    typedef T first_type;
    typedef U second_type;
    T first;
    U second;
    flash_pair() {}
    flash_pair(const T& x, const U& y) : first(x), second(y) {}
    template<class V, class W>
        flash_pair(const flash_pair<V, W>& pr) : first(pr.first), second(pr.second) {}
    };

class FlashVersionEnabled
{
public:
    FlashVersionEnabled() : version(1) {}
    virtual void SetTagVersion(int v) { version = v; }
    virtual int GetTagVersion(void) const { return version; }
private:
    int version;
};

template<class T> T LSHR(T x, int num);

template<class T> int GetBitSize(T x)
{
    int size=0;
    while(x > 0)
    {
      x=LSHR(x,1);
      size++;
    } 
    return size;
}

template<class T> int GetBitSizeSigned(T x)
{
    int size=0;
    int sign = (long(x) < 0);
    T tmp=x;
    if(sign) tmp = tmp*(-1);
    size = GetBitSize(tmp);
    return (size+1);
}

template<class T> T PackBitsSigned(T x)
{    
    UDWORD v=0x0;
    int sign = (long(x) < 0);
    if(sign) x=~x + 1;

    int i = GetBitSizeSigned(x);
//    v = arr1[i];
    for(int b=0; b < i; b++)
    {
        v = (v << 1) | 0x01;
    }
    v = (x & v) | (GetBit(x,sizeof(T)*8-1));
    if(sign) return (T)(~v + 1);
    return (v); 
}

template<class T> T UnPackBitsSigned(T x, int size)
{
    int sign = GetBit(x,size-1);
    
    x = GetIsolatedBits(x,0,size);
    
    T v = 0;
    if(sign == 1) 
    {
        int bit1 = size;
        int bit2 = sizeof(T)*8;
//		v = arr1[bit2-bit1];
        for(int b=0; b < bit2-bit1; b++)
		  {
            v = (v << 1) | 0x01;
        }
//		v <<= bit1;
        for(int b2=0; b2 < bit1; b2++)
        {
            v = (v << 1);
        }

    }
    return (x | v); 
}

template<class T> char GetBit(T x, int bit)
{   
    T y = 1 << bit;
    if((x & y)==0) return (char)0;
    return((char)1);
}

template<class T> T IsolateBits(T x, int bit1, int bit2)
{
    T v=0;
    //v = arr1[bit2-bit1];
    for(int b=0; b < bit2-bit1; b++)
    {
        v = (v << 1) | 0x01;
    }
	//v <<= bit1;
    for(int b2=0; b2 < bit1; b2++)
    {
        v = (v << 1);
    }   
    return (x & v);
}
template<class T> T LSHR(T x, int num)
{
    char sign = (GetBit(x,sizeof(T)*8-1));
    T v = IsolateBits(x, 0, sizeof(T)*8-1);
    v >>= num;
    if(sign==1) 
    {
        v |= (((T)0x1) << (sizeof(T)*8-1));
    }
    return v;
}

template<class T> T GetIsolatedBits(T x, int bit1, int bit2)
{
    T r = IsolateBits(x,bit1,bit2);
    return ((T)(LSHR(r, bit1)));
}



class BitStreamIn
{
public:
    BitStreamIn(std::istream *i, int off=0) :
      in(i), offset(off) {}
    ~BitStreamIn()
    {
        Align();
    }
    //TODO Add Exception handling for nbits > bitsizeof()
    template <class T> void Read(T &r, int nbits)
    {
        if (nbits == 0) return;
		std::vector<int> tmp;

        int count   = 0;
        int read     = 0-offset;
        int to_go    = nbits;
        int last;
        do
        {       
            last = in->get();
            tmp.push_back(last);
            read += 8;
            count++;
        } while(read < to_go);
        
        
        UDWORD bits=0;

        int bitsleft = (count*8)-(offset+nbits);
        int bitsright = (count*8)-offset;
        
        int count2 = 0;
        for(std::vector<int>::iterator i = tmp.begin(); i != tmp.end(); i++)
        {

            count2++;
            int shift = 8*(count-(count2));

            int b1 = fbase_max(bitsleft-shift,0);
            int b2 = fbase_min(bitsright-shift,8);
            
            int c = GetIsolatedBits(*i, b1, b2);
            
            bits = bits << (b2-b1);
            bits |= (T)(c & 0xff);
            
        }
        offset = (offset+nbits)%8;
        
        if(offset != 0)
        {       
            in->putback(last);      
        }
        r = (T)bits;
    }
    
    void Align() 
	{ 
		if(offset != 0) { 
			in->get(); 
			offset = 0;
		}
	}
	
	std::istream &GetStream() { return *in; }
private:
    std::istream *in;
    int offset;
};

class BitStreamOut
{

public:
    

    BitStreamOut(std::ostream *o) :
      out (o), displace(0), curchar(0), remaining(false){ }
    ~BitStreamOut() 
    { 
        if(remaining) (*out).put(curchar); 
    }
    
    std::ostream *out;
public:
    template <class T>
    void Write(T data, int bitsize)
    {

        for(int i = 0; i < bitsize; i++)
        {           
            remaining = true;
            int offset = 7-(displace%8);

            unsigned char val = GetBit(data, (bitsize)-1-i);        
            unsigned char set = 0x01 << (offset);

            curchar = (curchar & ~set) | (val << (offset));
            displace++;         
            
            offset = 7-(displace%8);
            if(offset%8==7)
            {
                (*out).put((char)curchar);
                curchar=0;
                remaining=false;
                displace=0;
            }

        }

    }
    void Align()
    {
        int offset = 7-(displace%8);
        displace+=offset;
        (*out).put((char)curchar);
        curchar=0;      
        remaining=false;
        displace=0;
    }
    
private:
    int displace;
    char curchar;
    bool remaining; 
};

template<class T> BitStreamOut &operator<< (BitStreamOut &o, const T t)
{
    o.Write(t,sizeof(T)*8);
}

class BitBuffer
{
public:
    BitBuffer() : displace(0) {}
    ~BitBuffer() {}

    void WriteBytes(char *c, int numbytes)
    {
        for(int i=0; i < numbytes; i++)
        {
            Write(c[i],8);
        }
    }
    void Write(UDWORD data, int bitsize)
    {
        for(int i = 0; i < bitsize; i++)
        {
            int pos    = displace/8;
            int offset = 7-(displace%8);

            if(offset==7)
            {
                v.push_back(0);
            }
            unsigned char val = GetBit(data, (bitsize)-1-i);        
            unsigned char set = 0x01 << (offset);

			int size = (int)v.size();

            v[pos] = (v[pos] & ~set) | (val << (offset));
            displace++;         
        }
    }
    void Align()
    {
		int	bitsleft = displace % 8;
		if ( bitsleft != 0 )
		{
	        int offset = 8-(bitsleft);

		    displace += offset;
		}
    }

private:
    long displace;
    std::vector<char> v;
    
    friend BitStreamOut &operator<< (BitStreamOut &out, BitBuffer &data);
    friend std::ostream &operator<< (std::ostream &out, BitBuffer &data);
    friend std::istream &operator>> (std::istream &in,  BitBuffer &data);
};

class FlashFixed
{
//private:
public:
    SWORD upperval;
    UWORD lowerval;
public: 
    FlashFixed(void); 
    FlashFixed(SWORD u, UWORD l); 
    FlashFixed(double f); 

    UDWORD ConvertToRaw () const
    {
        UDWORD r = ((SDWORD)upperval)<<16;
        r |= lowerval;
        return r;
    }
    void GetFromRaw(SDWORD raw)
    {
        upperval = raw >> 16;
        lowerval = (raw & 0xffff);
    }
    double ConvertToDouble() const
    {
        return upperval + double(lowerval) / 0x10000;
    }
    void GetFromDouble(double x)
    {
        upperval = (UWORD)floor(x);
        lowerval = (UWORD)((x-floor(x))*0x10000);
    }
    
    friend std::ostream &operator<< (std::ostream &out, const FlashFixed &data);
    friend std::istream &operator>> (std::istream &in,  FlashFixed &data);

};