fscodec.java

利用opensource的开源jar实现生成flash文件

        if (ptr > (data.length << 3))
            ptr = data.length << 3;

        return value;
    }
    
    /**
     * Write a bit value to the internal buffer. The buffer will resize automatically
     * if required.
     * 
     * @param value an integer containing the value to be written.
     * @param numberOfBits the least significant n bits from the value that will be 
     * written to the buffer.
     */
    public void writeBits(int value, int numberOfBits)
    {
        if (ptr + numberOfBits + 24 > end)
        {
            int length = ((numberOfBits > data.length) ? numberOfBits : data.length) + data.length;
            byte[] bytes = new byte[length];
            
            System.arraycopy(data, 0, bytes, 0, data.length);
            data = bytes;
        }
        
        if (numberOfBits < 1 || numberOfBits > 32)
            throw new IllegalArgumentException("Number of bits must be in the range 1..32.");
        
        int index = ptr >> 3;

        value <<= (32 - numberOfBits);    
        value = value >>> (ptr % 8);
        value = value | (data[index] << 24);

        for (int i=24; i>=0; i-=8, index++)
            data[index] = (byte)(value >>> i);
        
        ptr += numberOfBits;

        if (ptr > (data.length << 3))
            ptr = data.length << 3;
    }
    
    /**
     * Read a word from the internal buffer.
     * 
     * If a buffer overflow occurs then the number of bytes which cause the overflow will 
     * be set to zero.
     * 
     * @param numberOfBytes the number of bytes read in the range 1..4.
     * @param signed a boolean flag indicating whether the value read should be sign extended.
     * @return the value read.
     */
    public int readWord(int numberOfBytes, boolean signed)
    {
        int value = 0;
    
        if (numberOfBytes < 1 || numberOfBytes > 4)
            throw new IllegalArgumentException("Number of bytes must be in the range 1..4.");
        
        int index = ptr >> 3;
        
        if (index + numberOfBytes > data.length)
            numberOfBytes = data.length - index;
        
        int numberOfBits = numberOfBytes*8;

        if (byteOrder == LITTLE_ENDIAN)
        {
            for (int i=0; i<numberOfBits; i+=8, ptr+=8, index++)
                value += (data[index] & 0x000000FF) << i;
        }
        else
        {
            for (int i=0; i<numberOfBits; i+=8, ptr+=8, index++)
            {
                value = value << 8;
                value += data[index] & 0x000000FF;
            }
        }
        
        if (signed)
        {
            value <<= 32 - numberOfBits;
            value >>= 32 - numberOfBits;
        }

        return value;
    }

    /**
     * Write a word to the internal buffer. The buffer will resize automatically
     * if required.
     * 
     * @param value an integer containing the value to be written.
     * @param numberOfBytes the least significant n bytes from the value that will be 
     * written to the buffer.
     */
    public void writeWord(int value, int numberOfBytes)
    {
        if (numberOfBytes < 1 || numberOfBytes > 4)
            throw new IllegalArgumentException("Number of bytes must be in the range 1..4.");
            
        int numberOfBits = numberOfBytes*8;
        
        if (ptr + numberOfBits > end)
        {
            int length = ((numberOfBits > data.length) ? numberOfBits : data.length) + data.length;
            byte[] bytes = new byte[length];
            
            System.arraycopy(data, 0, bytes, 0, data.length);
            data = bytes;
            end = data.length << 3;
        }
        
        if (byteOrder == LITTLE_ENDIAN)
        {
            int index = ptr >>> 3;
            
            for (int i=0; i<numberOfBits; i+=8, ptr+=8, value >>>= 8, index++)
                data[index] = (byte)value;
        }
        else
        {
            int index = (ptr + numberOfBits - 8) >>> 3;
            
            for (int i=0; i<numberOfBits; i+=8, ptr+=8, value >>>= 8, index--)
                data[index] = (byte)value;
        }
    }

    /**
     * Reads an array of bytes from the internal buffer. If a read overflow occurs
     * while reading the internal buffer then the remaining bytes in the array will
     * not be filled. The method returns the number of bytes read.
     * 
     * @param bytes the array that will contain the bytes read.
     * @return the number of bytes read from the buffer.
     */
    public int readBytes(byte[] bytes)
    {
        int bytesRead = 0;
    
        if (bytes == null || bytes.length == 0)
            return bytesRead;

        int index = ptr >>> 3;
        int numberOfBytes = bytes.length;
        
        if (index + numberOfBytes > data.length)
            numberOfBytes = data.length - index;

        for (int i=0; i<numberOfBytes; i++, ptr+=8, index++, bytesRead++)
            bytes[i] = data[index];

        return bytesRead;
    }

    /**
     * Writes an array of bytes from the internal buffer. The internal buffer will
     * be resized automatically if required.
     * 
     * @param bytes the array containing the data to be written.
     * @return the number of bytes written to the buffer.
     */
    public int writeBytes(byte[] bytes)
    {
        int bytesWritten = 0;
    
        if (ptr + (bytes.length << 3) > end)
        {
            int length = ((bytes.length > data.length) ? bytes.length : data.length) + data.length;
            byte[] buffer = new byte[length];
            
            System.arraycopy(data, 0, buffer, 0, data.length);
            data = bytes;
            end = data.length << 3;
        }
        
        if (bytes == null || bytes.length == 0)
            return bytesWritten;

        int index = ptr >>> 3;
        int numberOfBytes = bytes.length;

        for (int i=0; i<numberOfBytes; i++, ptr+=8, index++, bytesWritten++)
            data[index] = bytes[i];
        
        return bytesWritten;
    }
    
    byte[] getBuffer()
    {
        return data;
    }

    int getPointer()
    {
        return ptr;
    }

    void setPointer(int location)
    {
        if (location < 0)
            location = 0;
        else if (location > end)
            location = end;

        ptr = location;
    }

    void adjustPointer(int offset)
    {
        ptr += offset;
        
        if (ptr < 0)
            ptr = 0;
        else if (ptr >= end)
            ptr = end;
    }
    
    int readBits(int numberOfBits)
    {
        int value = 0;
    
        if (numberOfBits == 0)
            return value;
        
        int index = ptr >> 3;
        int base = (data.length - index > 4) ? 0  : (4 - (data.length - index))*8;
        
        for (int i=32; i>base; i-=8, index++)
            value |= (data[index] & 0x000000FF) << (i-8);

        value <<= ptr % 8;
        value >>>= 32 - numberOfBits;

        ptr += numberOfBits;

        if (ptr > (data.length << 3))
            ptr = data.length << 3;

        return value;
    }
    
    int readByte()
    {
        int value = data[ptr>>3] & 0xFF;
    
        ptr += 8;
        
        return value;
    }

    int readShort(boolean signed)
    {
        int value = 0;
        int index = ptr >> 3;
        
        if (byteOrder == LITTLE_ENDIAN)
        {
            value = (data[index++] & 0xFF);    
            value += (data[index] & 0xFF) << 8;
        }
        else
        {
            value = (data[index++] & 0xFF) << 8;
            value += (data[index] & 0xFF);    
        }

        if (signed)
        {
            value <<= 16;
            value >>= 16;
        }
        ptr += 16;
        
        return value;
    }

    int readInt()
    {
        int value = 0;
        int index = ptr >> 3;
        
        if (byteOrder == LITTLE_ENDIAN)
        {
            value = (data[index++] & 0xFF);    
            value += (data[index++] & 0xFF) << 8;
            value += (data[index++] & 0xFF) << 16;
            value += (data[index] & 0xFF) << 24;
        }
        else
        {
            value = (data[index++] & 0xFF) << 24;
            value += (data[index++] & 0xFF) << 16;
            value += (data[index++] & 0xFF) << 8;
            value += (data[index] & 0xFF);    
        }
        ptr += 32;
        
        return value;
    }

    float readFixedBits(int numberOfBits, int fractionSize)
    {
        float value = 0;
        float divisor = (float)(1 << fractionSize);
    
        value = ((float)readBits(numberOfBits, true)) / divisor;
        
        return value;
    }
}