compiler/src/org/apache/flex/swf/io/InputBitStream.java - royale-compiler - Git at Google

 /*
  *
  *  Licensed to the Apache Software Foundation (ASF) under one or more
  *  contributor license agreements.  See the NOTICE file distributed with
  *  this work for additional information regarding copyright ownership.
  *  The ASF licenses this file to You under the Apache License, Version 2.0
  *  (the "License"); you may not use this file except in compliance with
  *  the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  *
  */

 package org.apache.flex.swf.io;

 import java.io.BufferedInputStream;
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.UnsupportedEncodingException;
 import java.util.zip.InflaterInputStream;

 import org.apache.commons.io.IOUtils;

 import org.apache.flex.swf.Header;
 import org.apache.flex.utils.DAByteArrayOutputStream;

 /**
  * Implementation of {@link InputBitStream}. This implementation allows you to
  * swap the underlying {@code InputStream} source with another one.
  * <p>
  * {@code InputBitStream} doesn't buffer the source InputStream internally. It
  * has one byte buffer for reading SWF bit-values. The buffer is filled 8 bits
  * at a time. All the bit value methods read from this buffer.
  * <p>
  * If a SWF file is compressed, InputBitStream uses an
  * {@link InflaterInputStream} to decompress the source input.
  */
 public class InputBitStream extends InputStream implements IInputBitStream
 {
     // source
     private InputStream in;

     // bit value cache
     private int bitPos = 0;

     private int bitBuf = 0;
     private long offset = 0;
     private long readBoundary = 0;

     /**
      * Create an {@code InputBitStream}.
      *
      * @param in source {@code InputStream}
      */
     public InputBitStream(InputStream in)
     {
         this.in = in;
     }

     public InputBitStream(byte[] bytes)
     {
         this.in = new ByteArrayInputStream(bytes);
     }

     /**
      * Discard the data left in the bit value cache. Always call this method
      * after reading bit values and before reading other byte-aligned data.
      */
     @Override
     public void byteAlign()
     {
         bitPos = 0;
     }

     @Override
     public int read() throws IOException
     {
         return readByte();
     }

     @Override
     public byte[] read(int length)
     {
         final byte[] data = new byte[length];
         try
         {
             read(data);
         }
         catch (IOException e)
         {
             throw new RuntimeException(e);
         }
         return data;
     }

     @Override
     public boolean readBit()
     {
         return readBits(1) != 0;
     }

     /**
      * Read multiple bits as a padded int.
      *
      * @param length number of bits to read
      * @return The value that was read.
      */
     protected int readBits(int length)
     {
         if (length == 0)
         {
             return 0;
         }

         int bitsLeft = length;
         int result = 0;

         if (bitPos == 0) // no value in the buffer - read a byte
         {
             bitBuf = readUI8();
             bitPos = 8;
         }

         while (true)
         {
             int shift = bitsLeft - bitPos;
             if (shift > 0)
             {
                 // Consume the entire buffer
                 result |= bitBuf << shift;
                 bitsLeft -= bitPos;

                 // Get the next byte from the input stream
                 bitBuf = readUI8();
                 bitPos = 8;
             }
             else
             {
                 // Consume a portion of the buffer
                 result |= bitBuf >> -shift;
                 bitPos -= bitsLeft;
                 bitBuf &= 0xff >> (8 - bitPos); // mask off the consumed bits
                 return result;
             }
         }
     }

     // The following are SWF primitive type decoder methods.

     /**
      * This helps to mute the {@code IOException}. If there's no data in the
      * source input stream, calling this method will raise an runtime exception.
      * <p>
      * All the methods implementing {@code IInputBitStream} should call this
      * method when consuming the next byte from the input stream.
      *
      * @return next byte in the input stream
      */
     protected int readByte()
     {
         byteAlign();
         try
         {
             if (offset >= readBoundary)
             {
                 throw new RuntimeException(String.format("About to read over or reading over the boundary: %d -> %d.", offset, readBoundary));
             }

             final int n = in.read();
             offset++;
             if (-1 == n)
             {
                 throw new RuntimeException("No more data to read.");
             }
             else
             {
                 return n;
             }
         }
         catch (IOException e)
         {
             throw new RuntimeException(e);
         }
     }

     @Override
     public double readDOUBLE()
     {
         return Double.longBitsToDouble(readSI64());
     }

     @Override
     public long readEncodedU32()
     {
         long decoded = 0;
         for (int i = 0; i < 5; i++)
         {
             final int nextByte = readByte();
             decoded = (decoded << 7) | (nextByte & 0x7f);
             if ((nextByte & 0x80) == 0)
             {
                 break;
             }
         }
         return decoded & 0x000000ff << 24 |
                decoded & 0x0000ff00 << 8 |
                decoded & 0x00ff0000 >>> 8 |
                decoded & 0xff000000 >>> 24;
     }

     @Override
     public float readFB(int length)
     {
         // Convert bits to x.16 FIXED point number
         return readSB(length) / (float)0x10000;
     }

     @Override
     public float readFIXED()
     {
         // Convert 32-bit int to 16.16 FIXED point number
         return readSI32() / (float)0x10000;
     }

     @Override
     public float readFIXED8()
     {
         // Convert 16-bit int to 8.8 FIXED point number
         return (short)readSI16() / (float)0x100;
     }

     @Override
     public float readFLOAT()
     {
         return Float.intBitsToFloat(readSI32());
     }

     @Override
     public int readSB(int length)
     {
         int bits = readBits(length);
         return bits << 32 - length >> 32 - length;
     }

     @Override
     public short readSI16()
     {
         return (short)(readByte() | readByte() << 8);
     }

     @Override
     public int readSI32()
     {
         return readByte() |
                readByte() << 8 |
                readByte() << 16 |
                readByte() << 24;
     }

     @Override
     public long readSI64()
     {
         return (readUI32() & 0xFFFFFFFFL) | (readUI32() << 32);
     }

     @Override
     public byte readSI8()
     {
         return (byte)readByte();
     }

     @Override
     public String readString()
     {
         final DAByteArrayOutputStream buffer = new DAByteArrayOutputStream();
         for (int nextByte = readUI8(); nextByte != 0; nextByte = readUI8())
         {
             buffer.write(nextByte);
         }

         try
         {
             return new String(buffer.getDirectByteArray(), 0, buffer.size(), "UTF-8");
         }
         catch (UnsupportedEncodingException e)
         {
             throw new RuntimeException(e);
         }
         finally
         {
             IOUtils.closeQuietly(buffer);
         }
     }

     @Override
     public int readUB(int length)
     {
         return readBits(length);
     }

     @Override
     public int readUI16()
     {
         return 0xFFFF & readSI16();
     }

     @Override
     public int readUI24()
     {
         return 0xFFFFFF & (readByte() | readByte() << 8 | readByte() << 16);
     }

     @Override
     public long readUI32()
     {
         return 0xFFFFFFFFl & readSI32();
     }

     @Override
     public short readUI8()
     {
         return (short)(0xFF & readSI8());
     }

     /**
      * Set if the InputStream is a compressed SWF stream.
      */
     public void setCompress(Header.Compression compression) throws IOException
     {
         switch (compression)
         {
             case NONE:
                 break;
             case ZLIB:
                 this.in = new BufferedInputStream(new InflaterInputStream(in));
                 break;
             case LZMA:
                 this.in = new LZMAInputStream(in);
                 break;
             default:
                 assert false;
         }
     }

     @Override
     public byte[] readToBoundary()
     {
         assert readBoundary > 0 : "Must set boundary before readToBoundary";

         // The conversion is safe because a tag length is SI32.
         final int len = (int)(readBoundary - offset);
         final byte[] result = this.read(len);
         return result;
     }

     @Override
     public long getOffset()
     {
         return offset;
     }

     @Override
     public void setReadBoundary(long offset)
     {
         assert offset > 0 : "Read boundary must > 0.";
         this.readBoundary = offset;
     }

     @Override
     public long getReadBoundary()
     {
         return this.readBoundary;
     }
 }
	/*
	*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	*/

	package org.apache.flex.swf.io;

	import java.io.BufferedInputStream;
	import java.io.ByteArrayInputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.UnsupportedEncodingException;
	import java.util.zip.InflaterInputStream;

	import org.apache.commons.io.IOUtils;

	import org.apache.flex.swf.Header;
	import org.apache.flex.utils.DAByteArrayOutputStream;

	/**
	* Implementation of {@link InputBitStream}. This implementation allows you to
	* swap the underlying {@code InputStream} source with another one.
	* <p>
	* {@code InputBitStream} doesn't buffer the source InputStream internally. It
	* has one byte buffer for reading SWF bit-values. The buffer is filled 8 bits
	* at a time. All the bit value methods read from this buffer.
	* <p>
	* If a SWF file is compressed, InputBitStream uses an
	* {@link InflaterInputStream} to decompress the source input.
	*/
	public class InputBitStream extends InputStream implements IInputBitStream
	{
	// source
	private InputStream in;

	// bit value cache
	private int bitPos = 0;

	private int bitBuf = 0;
	private long offset = 0;
	private long readBoundary = 0;

	/**
	* Create an {@code InputBitStream}.
	*
	* @param in source {@code InputStream}
	*/
	public InputBitStream(InputStream in)
	{
	this.in = in;
	}

	public InputBitStream(byte[] bytes)
	{
	this.in = new ByteArrayInputStream(bytes);
	}

	/**
	* Discard the data left in the bit value cache. Always call this method
	* after reading bit values and before reading other byte-aligned data.
	*/
	@Override
	public void byteAlign()
	{
	bitPos = 0;
	}

	@Override
	public int read() throws IOException
	{
	return readByte();
	}

	@Override
	public byte[] read(int length)
	{
	final byte[] data = new byte[length];
	try
	{
	read(data);
	}
	catch (IOException e)
	{
	throw new RuntimeException(e);
	}
	return data;
	}

	@Override
	public boolean readBit()
	{
	return readBits(1) != 0;
	}

	/**
	* Read multiple bits as a padded int.
	*
	* @param length number of bits to read
	* @return The value that was read.
	*/
	protected int readBits(int length)
	{
	if (length == 0)
	{
	return 0;
	}

	int bitsLeft = length;
	int result = 0;

	if (bitPos == 0) // no value in the buffer - read a byte
	{
	bitBuf = readUI8();
	bitPos = 8;
	}

	while (true)
	{
	int shift = bitsLeft - bitPos;
	if (shift > 0)
	{
	// Consume the entire buffer
	result \|= bitBuf << shift;
	bitsLeft -= bitPos;

	// Get the next byte from the input stream
	bitBuf = readUI8();
	bitPos = 8;
	}
	else
	{
	// Consume a portion of the buffer
	result \|= bitBuf >> -shift;
	bitPos -= bitsLeft;
	bitBuf &= 0xff >> (8 - bitPos); // mask off the consumed bits
	return result;
	}
	}
	}

	// The following are SWF primitive type decoder methods.

	/**
	* This helps to mute the {@code IOException}. If there's no data in the
	* source input stream, calling this method will raise an runtime exception.
	* <p>
	* All the methods implementing {@code IInputBitStream} should call this
	* method when consuming the next byte from the input stream.
	*
	* @return next byte in the input stream
	*/
	protected int readByte()
	{
	byteAlign();
	try
	{
	if (offset >= readBoundary)
	{
	throw new RuntimeException(String.format("About to read over or reading over the boundary: %d -> %d.", offset, readBoundary));
	}

	final int n = in.read();
	offset++;
	if (-1 == n)
	{
	throw new RuntimeException("No more data to read.");
	}
	else
	{
	return n;
	}
	}
	catch (IOException e)
	{
	throw new RuntimeException(e);
	}
	}

	@Override
	public double readDOUBLE()
	{
	return Double.longBitsToDouble(readSI64());
	}

	@Override
	public long readEncodedU32()
	{
	long decoded = 0;
	for (int i = 0; i < 5; i++)
	{
	final int nextByte = readByte();
	decoded = (decoded << 7) \| (nextByte & 0x7f);
	if ((nextByte & 0x80) == 0)
	{
	break;
	}
	}
	return decoded & 0x000000ff << 24 \|
	decoded & 0x0000ff00 << 8 \|
	decoded & 0x00ff0000 >>> 8 \|
	decoded & 0xff000000 >>> 24;
	}

	@Override
	public float readFB(int length)
	{
	// Convert bits to x.16 FIXED point number
	return readSB(length) / (float)0x10000;
	}

	@Override
	public float readFIXED()
	{
	// Convert 32-bit int to 16.16 FIXED point number
	return readSI32() / (float)0x10000;
	}

	@Override
	public float readFIXED8()
	{
	// Convert 16-bit int to 8.8 FIXED point number
	return (short)readSI16() / (float)0x100;
	}

	@Override
	public float readFLOAT()
	{
	return Float.intBitsToFloat(readSI32());
	}

	@Override
	public int readSB(int length)
	{
	int bits = readBits(length);
	return bits << 32 - length >> 32 - length;
	}

	@Override
	public short readSI16()
	{
	return (short)(readByte() \| readByte() << 8);
	}

	@Override
	public int readSI32()
	{
	return readByte() \|
	readByte() << 8 \|
	readByte() << 16 \|
	readByte() << 24;
	}

	@Override
	public long readSI64()
	{
	return (readUI32() & 0xFFFFFFFFL) \| (readUI32() << 32);
	}

	@Override
	public byte readSI8()
	{
	return (byte)readByte();
	}

	@Override
	public String readString()
	{
	final DAByteArrayOutputStream buffer = new DAByteArrayOutputStream();
	for (int nextByte = readUI8(); nextByte != 0; nextByte = readUI8())
	{
	buffer.write(nextByte);
	}

	try
	{
	return new String(buffer.getDirectByteArray(), 0, buffer.size(), "UTF-8");
	}
	catch (UnsupportedEncodingException e)
	{
	throw new RuntimeException(e);
	}
	finally
	{
	IOUtils.closeQuietly(buffer);
	}
	}

	@Override
	public int readUB(int length)
	{
	return readBits(length);
	}

	@Override
	public int readUI16()
	{
	return 0xFFFF & readSI16();
	}

	@Override
	public int readUI24()
	{
	return 0xFFFFFF & (readByte() \| readByte() << 8 \| readByte() << 16);
	}

	@Override
	public long readUI32()
	{
	return 0xFFFFFFFFl & readSI32();
	}

	@Override
	public short readUI8()
	{
	return (short)(0xFF & readSI8());
	}

	/**
	* Set if the InputStream is a compressed SWF stream.
	*/
	public void setCompress(Header.Compression compression) throws IOException
	{
	switch (compression)
	{
	case NONE:
	break;
	case ZLIB:
	this.in = new BufferedInputStream(new InflaterInputStream(in));
	break;
	case LZMA:
	this.in = new LZMAInputStream(in);
	break;
	default:
	assert false;
	}
	}

	@Override
	public byte[] readToBoundary()
	{
	assert readBoundary > 0 : "Must set boundary before readToBoundary";

	// The conversion is safe because a tag length is SI32.
	final int len = (int)(readBoundary - offset);
	final byte[] result = this.read(len);
	return result;
	}

	@Override
	public long getOffset()
	{
	return offset;
	}

	@Override
	public void setReadBoundary(long offset)
	{
	assert offset > 0 : "Read boundary must > 0.";
	this.readBoundary = offset;
	}

	@Override
	public long getReadBoundary()
	{
	return this.readBoundary;
	}
	}