Java tutorial
/* * * 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; } }