| /* |
| * Copyright (C) 2008 The Android Open Source Project |
| * |
| * Licensed 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 com.android.internal.util; |
| |
| /** |
| * An object that rovides bitwise incremental write access to a byte array. |
| * |
| * This is useful, for example, when writing a series of fields that |
| * may not be aligned on byte boundaries. |
| * |
| * NOTE -- This class is not threadsafe. |
| */ |
| public class BitwiseOutputStream { |
| |
| // The byte array being written to, which will be grown as needed. |
| private byte[] mBuf; |
| |
| // The current position offset, in bits, from the msb in byte 0. |
| private int mPos; |
| |
| // The last bit offset, given the current buf length. |
| private int mEnd; |
| |
| /** |
| * An exception to report access problems. |
| */ |
| public static class AccessException extends Exception { |
| public AccessException(String s) { |
| super("BitwiseOutputStream access failed: " + s); |
| } |
| } |
| |
| /** |
| * Create object from hint at desired size. |
| * |
| * @param startingLength initial internal byte array length in bytes |
| */ |
| public BitwiseOutputStream(int startingLength) { |
| mBuf = new byte[startingLength]; |
| mEnd = startingLength << 3; |
| mPos = 0; |
| } |
| |
| /** |
| * Return byte array containing accumulated data, sized to just fit. |
| * |
| * @return newly allocated byte array |
| */ |
| public byte[] toByteArray() { |
| int len = (mPos >>> 3) + ((mPos & 0x07) > 0 ? 1 : 0); // &7==%8 |
| byte[] newBuf = new byte[len]; |
| System.arraycopy(mBuf, 0, newBuf, 0, len); |
| return newBuf; |
| } |
| |
| /** |
| * Allocate a new internal buffer, if needed. |
| * |
| * @param bits additional bits to be accommodated |
| */ |
| private void possExpand(int bits) { |
| if ((mPos + bits) < mEnd) return; |
| byte[] newBuf = new byte[(mPos + bits) >>> 2]; |
| System.arraycopy(mBuf, 0, newBuf, 0, mEnd >>> 3); |
| mBuf = newBuf; |
| } |
| |
| /** |
| * Write some data and increment the current position. |
| * |
| * @param bits the amount of data to write (gte 0, lte 8) |
| * @param data to write, will be masked to expose only bits param from lsb |
| */ |
| public void write(int bits, int data) throws AccessException { |
| if ((bits < 0) || (bits > 8)) { |
| throw new AccessException("illegal write (" + bits + " bits)"); |
| } |
| possExpand(bits); |
| data &= (-1 >>> (32 - bits)); |
| int index = mPos >>> 3; |
| int offset = 16 - (mPos & 0x07) - bits; // &7==%8 |
| data <<= offset; |
| mPos += bits; |
| mBuf[index] |= (data >>> 8); |
| if (offset < 8) mBuf[index + 1] |= (data & 0x00FF); |
| } |
| |
| /** |
| * Write data in bulk from a byte array and increment the current position. |
| * |
| * @param bits the amount of data to write |
| * @param arr the byte array containing data to be written |
| */ |
| public void writeByteArray(int bits, byte[] arr) throws AccessException { |
| for (int i = 0; i < arr.length; i++) { |
| int increment = Math.min(8, bits - (i << 3)); |
| if (increment > 0) { |
| write(increment, (byte)(arr[i] >>> (8 - increment))); |
| } |
| } |
| } |
| |
| /** |
| * Increment the current position, implicitly writing zeros. |
| * |
| * @param bits the amount by which to increment the position |
| */ |
| public void skip(int bits) { |
| possExpand(bits); |
| mPos += bits; |
| } |
| } |