/*
* Copyright (C) 2012 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 android.util.proto;
import android.annotation.TestApi;
import android.util.Log;
import java.util.ArrayList;
/**
* A stream of bytes containing a read pointer and a write pointer,
* backed by a set of fixed-size buffers. There are write functions for the
* primitive types stored by protocol buffers, but none of the logic
* for tags, inner objects, or any of that.
*
* Terminology:
* *Pos: Position in the whole data set (as if it were a single buffer).
* *Index: Position within a buffer.
* *BufIndex: Index of a buffer within the mBuffers list
* @hide
*/
@TestApi
public final class EncodedBuffer {
private static final String TAG = "EncodedBuffer";
private final ArrayList<byte[]> mBuffers = new ArrayList<byte[]>();
private final int mChunkSize;
/**
* The number of buffers in mBuffers. Stored separately to avoid the extra
* function call to size() everywhere for bounds checking.
*/
private int mBufferCount;
/**
* The buffer we are currently writing to.
*/
private byte[] mWriteBuffer;
/**
* The index into mWriteBuffer that we will write to next.
* It may point to the end of the buffer, in which case,
* the NEXT write will allocate a new buffer.
*/
private int mWriteIndex;
/**
* The index of mWriteBuffer in mBuffers.
*/
private int mWriteBufIndex;
/**
* The buffer we are currently reading from.
*/
private byte[] mReadBuffer;
/**
* The index of mReadBuffer in mBuffers.
*/
private int mReadBufIndex;
/**
* The index into mReadBuffer that we will read from next.
* It may point to the end of the buffer, in which case,
* the NEXT read will advance to the next buffer.
*/
private int mReadIndex;
/**
* The amount of data in the last buffer.
*/
private int mReadLimit = -1;
/**
* How much data there is total.
*/
private int mReadableSize = -1;
public EncodedBuffer() {
this(0);
}
/**
* Construct an EncodedBuffer object.
*
* @param chunkSize The size of the buffers to use. If chunkSize <= 0, a default
* size will be used instead.
*/
public EncodedBuffer(int chunkSize) {
if (chunkSize <= 0) {
chunkSize = 8 * 1024;
}
mChunkSize = chunkSize;
mWriteBuffer = new byte[mChunkSize];
mBuffers.add(mWriteBuffer);
mBufferCount = 1;
}
//
// Buffer management.
//
/**
* Rewind the read and write pointers, and record how much data was last written.
*/
public void startEditing() {
mReadableSize = ((mWriteBufIndex) * mChunkSize) + mWriteIndex;
mReadLimit = mWriteIndex;
mWriteBuffer = mBuffers.get(0);
mWriteIndex = 0;
mWriteBufIndex = 0;
mReadBuffer = mWriteBuffer;
mReadBufIndex = 0;
mReadIndex = 0;
}
/**
* Rewind the read pointer. Don't touch the write pointer.
*/
public void rewindRead() {
mReadBuffer = mBuffers.get(0);
mReadBufIndex = 0;
mReadIndex = 0;
}
/**
* Only valid after startEditing. Returns -1 before that.
*/
public int getReadableSize() {
return mReadableSize;
}
//
// Reading from the read position.
//
/**
* Only valid after startEditing.
*/
public int getReadPos() {
return ((mReadBufIndex) * mChunkSize) + mReadIndex;
}
/**
* Skip over _amount_ bytes.
*/
public void skipRead(int amount) {
if (amount < 0) {
throw new RuntimeException("skipRead with negative amount=" + amount);
}
if (amount == 0) {
return;
}
if (amount <= mChunkSize - mReadIndex) {
mReadIndex += amount;
} else {
amount -= mChunkSize - mReadIndex;
mReadIndex = amount % mChunkSize;
if (mReadIndex == 0) {
mReadIndex = mChunkSize;
mReadBufIndex += (amount / mChunkSize);
} else {
mReadBufIndex += 1 + (amount / mChunkSize);
}
mReadBuffer = mBuffers.get(mReadBufIndex);
}
}
/**
* Read one byte from the stream and advance the read pointer.
*
* @throws IndexOutOfBoundsException if the read point is past the end of
* the buffer or past the read limit previously set by startEditing().
*/
public byte readRawByte() {
if (mReadBufIndex > mBufferCount
|| (mReadBufIndex == mBufferCount - 1 && mReadIndex >= mReadLimit)) {
throw new IndexOutOfBoundsException("Trying to read too much data"
+ " mReadBufIndex=" + mReadBufIndex + " mBufferCount=" + mBufferCount
+ " mReadIndex=" + mReadIndex + " mReadLimit=" + mReadLimit);
}
if (mReadIndex >= mChunkSize) {
mReadBufIndex++;
mReadBuffer = mBuffers.get(mReadBufIndex);
mReadIndex = 0;
}
return mReadBuffer[mReadIndex++];
}
/**
* Read an unsigned varint. The value will be returend in a java signed long.
*/
public long readRawUnsigned() {
int bits = 0;
long result = 0;
while (true) {
final byte b = readRawByte();
result |= ((long)(b & 0x7F)) << bits;
if ((b & 0x80) == 0) {
return result;
}
bits += 7;
if (bits > 64) {
throw new ProtoParseException("Varint too long -- " + getDebugString());
}
}
}
/**
* Read 32 little endian bits from the stream.
*/
public int readRawFixed32() {
return (readRawByte() & 0x0ff)
| ((readRawByte() & 0x0ff) << 8)
| ((readRawByte() & 0x0ff) << 16)
| ((readRawByte() & 0x0ff) << 24);
}
//
// Writing at a the end of the stream.
//
/**
* Advance to the next write buffer, allocating it if necessary.
*
* Must be called immediately <b>before</b> the next write, not after a write,
* so that a dangling empty buffer is not created. Doing so will interfere
* with the expectation that mWriteIndex will point past the end of the buffer
* until the next read happens.
*/
private void nextWriteBuffer() {
mWriteBufIndex++;
if (mWriteBufIndex >= mBufferCount) {
mWriteBuffer = new byte[mChunkSize];
mBuffers.add(mWriteBuffer);
mBufferCount++;
} else {
mWriteBuffer = mBuffers.get(mWriteBufIndex);
}
mWriteIndex = 0;
}
/**
* Write a single byte to the stream.
*/
public void writeRawByte(byte val) {
if (mWriteIndex >= mChunkSize) {
nextWriteBuffer();
}
mWriteBuffer[mWriteIndex++] = val;
}
/**
* Return how many bytes a 32 bit unsigned varint will take when written to the stream.
*/
public static int getRawVarint32Size(int val) {
if ((val & (0xffffffff << 7)) == 0) return 1;
if ((val & (0xffffffff << 14)) == 0) return 2;
if ((val & (0xffffffff << 21)) == 0) return 3;
if ((val & (0xffffffff << 28)) == 0) return 4;
return 5;
}
/**
* Write an unsigned varint to the stream. A signed value would need to take 10 bytes.
*
* @param val treated as unsigned.
*/
public void writeRawVarint32(int val) {
while (true) {
if ((val & ~0x7F) == 0) {
writeRawByte((byte)val);
return;
} else {
writeRawByte((byte)((val & 0x7F) | 0x80));
val >>>= 7;
}
}
}
/**
* Return how many bytes a 32 bit signed zig zag value will take when written to the stream.
*/
public static int getRawZigZag32Size(int val) {
return getRawVarint32Size(zigZag32(val));
}
/**
* Write a zig-zag encoded value.
*
* @param val treated as signed
*/
public void writeRawZigZag32(int val) {
writeRawVarint32(zigZag32(val));
}
/**
* Return how many bytes a 64 bit varint will take when written to the stream.
*/
public static int getRawVarint64Size(long val) {
if ((val & (0xffffffffffffffffL << 7)) == 0) return 1;
if ((val & (0xffffffffffffffffL << 14)) == 0) return 2;
if ((val & (0xffffffffffffffffL << 21)) == 0) return 3;
if ((val & (0xffffffffffffffffL << 28)) == 0) return 4;
if ((val & (0xffffffffffffffffL << 35)) == 0) return 5;
if ((val & (0xffffffffffffffffL << 42)) == 0) return 6;
if ((val & (0xffffffffffffffffL << 49)) == 0) return 7;
if ((val & (0xffffffffffffffffL << 56)) == 0) return 8;
if ((val & (0xffffffffffffffffL << 63)) == 0) return 9;
return 10;
}
/**
* Write a 64 bit varint to the stream.
*/
public void writeRawVarint64(long val) {
while (true) {
if ((val & ~0x7FL) == 0) {
writeRawByte((byte)val);
return;
} else {
writeRawByte((byte)((val & 0x7F) | 0x80));
val >>>= 7;
}
}
}
/**
* Return how many bytes a signed 64 bit zig zag value will take when written to the stream.
*/
public static int getRawZigZag64Size(long val) {
return getRawVarint64Size(zigZag64(val));
}
/**
* Write a 64 bit signed zig zag value to the stream.
*/
public void writeRawZigZag64(long val) {
writeRawVarint64(zigZag64(val));
}
/**
* Write 4 little endian bytes to the stream.
*/
public void writeRawFixed32(int val) {
writeRawByte((byte)(val));
writeRawByte((byte)(val >> 8));
writeRawByte((byte)(val >> 16));
writeRawByte((byte)(val >> 24));
}
/**
* Write 8 little endian bytes to the stream.
*/
public void writeRawFixed64(long val) {
writeRawByte((byte)(val));
writeRawByte((byte)(val >> 8));
writeRawByte((byte)(val >> 16));
writeRawByte((byte)(val >> 24));
writeRawByte((byte)(val >> 32));
writeRawByte((byte)(val >> 40));
writeRawByte((byte)(val >> 48));
writeRawByte((byte)(val >> 56));
}
/**
* Write a buffer to the stream. Writes nothing if val is null or zero-length.
*/
public void writeRawBuffer(byte[] val) {
if (val != null && val.length > 0) {
writeRawBuffer(val, 0, val.length);
}
}
/**
* Write part of an array of bytes.
*/
public void writeRawBuffer(byte[] val, int offset, int length) {
if (val == null) {
return;
}
// Write up to the amount left in the first chunk to write.
int amt = length < (mChunkSize - mWriteIndex) ? length : (mChunkSize - mWriteIndex);
if (amt > 0) {
System.arraycopy(val, offset, mWriteBuffer, mWriteIndex, amt);
mWriteIndex += amt;
length -= amt;
offset += amt;
}
while (length > 0) {
// We know we're now at the beginning of a chunk
nextWriteBuffer();
amt = length < mChunkSize ? length : mChunkSize;
System.arraycopy(val, offset, mWriteBuffer, mWriteIndex, amt);
mWriteIndex += amt;
length -= amt;
offset += amt;
}
}
/**
* Copies data _size_ bytes of data within this buffer from _srcOffset_
* to the current write position. Like memmov but handles the chunked buffer.
*/
public void writeFromThisBuffer(int srcOffset, int size) {
if (mReadLimit < 0) {
throw new IllegalStateException("writeFromThisBuffer before startEditing");
}
if (srcOffset < getWritePos()) {
throw new IllegalArgumentException("Can only move forward in the buffer --"
+ " srcOffset=" + srcOffset + " size=" + size + " " + getDebugString());
}
if (srcOffset + size > mReadableSize) {
throw new IllegalArgumentException("Trying to move more data than there is --"
+ " srcOffset=" + srcOffset + " size=" + size + " " + getDebugString());
}
if (size == 0) {
return;
}
if (srcOffset == ((mWriteBufIndex) * mChunkSize) + mWriteIndex /* write pos */) {
// Writing to the same location. Just advance the write pointer. We already
// checked that size is in bounds, so we don't need to do any more range
// checking.
if (size <= mChunkSize - mWriteIndex) {
mWriteIndex += size;
} else {
size -= mChunkSize - mWriteIndex;
mWriteIndex = size % mChunkSize;
if (mWriteIndex == 0) {
// Roll it back so nextWriteBuffer can do its job
// on the next call (also makes mBuffers.get() not
// fail if we're at the end).
mWriteIndex = mChunkSize;
mWriteBufIndex += (size / mChunkSize);
} else {
mWriteBufIndex += 1 + (size / mChunkSize);
}
mWriteBuffer = mBuffers.get(mWriteBufIndex);
}
} else {
// Loop through the buffer, copying as much as we can each time.
// We already bounds checked so we don't need to do it again here,
// and nextWriteBuffer will never allocate.
int readBufIndex = srcOffset / mChunkSize;
byte[] readBuffer = mBuffers.get(readBufIndex);
int readIndex = srcOffset % mChunkSize;
while (size > 0) {
if (mWriteIndex >= mChunkSize) {
nextWriteBuffer();
}
if (readIndex >= mChunkSize) {
readBufIndex++;
readBuffer = mBuffers.get(readBufIndex);
readIndex = 0;
}
final int spaceInWriteBuffer = mChunkSize - mWriteIndex;
final int availableInReadBuffer = mChunkSize - readIndex;
final int amt = Math.min(size, Math.min(spaceInWriteBuffer, availableInReadBuffer));
System.arraycopy(readBuffer, readIndex, mWriteBuffer, mWriteIndex, amt);
mWriteIndex += amt;
readIndex += amt;
size -= amt;
}
}
}
//
// Writing at a particular location.
//
/**
* Returns the index into the virtual array of the write pointer.
*/
public int getWritePos() {
return ((mWriteBufIndex) * mChunkSize) + mWriteIndex;
}
/**
* Resets the write pointer to a virtual location as returned by getWritePos.
*/
public void rewindWriteTo(int writePos) {
if (writePos > getWritePos()) {
throw new RuntimeException("rewindWriteTo only can go backwards" + writePos);
}
mWriteBufIndex = writePos / mChunkSize;
mWriteIndex = writePos % mChunkSize;
if (mWriteIndex == 0 && mWriteBufIndex != 0) {
// Roll back so nextWriteBuffer can do its job on the next call
// but at the first write we're at 0.
mWriteIndex = mChunkSize;
mWriteBufIndex--;
}
mWriteBuffer = mBuffers.get(mWriteBufIndex);
}
/**
* Read a 32 bit value from the stream.
*
* Doesn't touch or affect mWritePos.
*/
public int getRawFixed32At(int pos) {
return (0x00ff & (int)mBuffers.get(pos / mChunkSize)[pos % mChunkSize])
| ((0x0ff & (int)mBuffers.get((pos+1) / mChunkSize)[(pos+1) % mChunkSize]) << 8)
| ((0x0ff & (int)mBuffers.get((pos+2) / mChunkSize)[(pos+2) % mChunkSize]) << 16)
| ((0x0ff & (int)mBuffers.get((pos+3) / mChunkSize)[(pos+3) % mChunkSize]) << 24);
}
/**
* Overwrite a 32 bit value in the stream.
*
* Doesn't touch or affect mWritePos.
*/
public void editRawFixed32(int pos, int val) {
mBuffers.get(pos / mChunkSize)[pos % mChunkSize] = (byte)(val);
mBuffers.get((pos+1) / mChunkSize)[(pos+1) % mChunkSize] = (byte)(val >> 8);
mBuffers.get((pos+2) / mChunkSize)[(pos+2) % mChunkSize] = (byte)(val >> 16);
mBuffers.get((pos+3) / mChunkSize)[(pos+3) % mChunkSize] = (byte)(val >> 24);
}
//
// Zigging and zagging
//
/**
* Zig-zag encode a 32 bit value.
*/
private static int zigZag32(int val) {
return (val << 1) ^ (val >> 31);
}
/**
* Zig-zag encode a 64 bit value.
*/
private static long zigZag64(long val) {
return (val << 1) ^ (val >> 63);
}
//
// Debugging / testing
//
// VisibleForTesting
/**
* Get a copy of the first _size_ bytes of data. This is not range
* checked, and if the bounds are outside what has been written you will
* get garbage and if it is outside the buffers that have been allocated,
* you will get an exception.
*/
public byte[] getBytes(int size) {
final byte[] result = new byte[size];
final int bufCount = size / mChunkSize;
int bufIndex;
int writeIndex = 0;
for (bufIndex=0; bufIndex<bufCount; bufIndex++) {
System.arraycopy(mBuffers.get(bufIndex), 0, result, writeIndex, mChunkSize);
writeIndex += mChunkSize;
}
final int lastSize = size - (bufCount * mChunkSize);
if (lastSize > 0) {
System.arraycopy(mBuffers.get(bufIndex), 0, result, writeIndex, lastSize);
}
return result;
}
/**
* Get the number of chunks allocated.
*/
// VisibleForTesting
public int getChunkCount() {
return mBuffers.size();
}
/**
* Get the write position inside the current write chunk.
*/
// VisibleForTesting
public int getWriteIndex() {
return mWriteIndex;
}
/**
* Get the index of the current write chunk in the list of chunks.
*/
// VisibleForTesting
public int getWriteBufIndex() {
return mWriteBufIndex;
}
/**
* Return debugging information about this EncodedBuffer object.
*/
public String getDebugString() {
return "EncodedBuffer( mChunkSize=" + mChunkSize + " mBuffers.size=" + mBuffers.size()
+ " mBufferCount=" + mBufferCount + " mWriteIndex=" + mWriteIndex
+ " mWriteBufIndex=" + mWriteBufIndex + " mReadBufIndex=" + mReadBufIndex
+ " mReadIndex=" + mReadIndex + " mReadableSize=" + mReadableSize
+ " mReadLimit=" + mReadLimit + " )";
}
/**
* Print the internal buffer chunks.
*/
public void dumpBuffers(String tag) {
final int N = mBuffers.size();
int start = 0;
for (int i=0; i<N; i++) {
start += dumpByteString(tag, "{" + i + "} ", start, mBuffers.get(i));
}
}
/**
* Print the internal buffer chunks.
*/
public static void dumpByteString(String tag, String prefix, byte[] buf) {
dumpByteString(tag, prefix, 0, buf);
}
/**
* Print the internal buffer chunks.
*/
private static int dumpByteString(String tag, String prefix, int start, byte[] buf) {
StringBuffer sb = new StringBuffer();
final int length = buf.length;
final int lineLen = 16;
int i;
for (i=0; i<length; i++) {
if (i % lineLen == 0) {
if (i != 0) {
Log.d(tag, sb.toString());
sb = new StringBuffer();
}
sb.append(prefix);
sb.append('[');
sb.append(start + i);
sb.append(']');
sb.append(' ');
} else {
sb.append(' ');
}
byte b = buf[i];
byte c = (byte)((b >> 4) & 0x0f);
if (c < 10) {
sb.append((char)('0' + c));
} else {
sb.append((char)('a' - 10 + c));
}
byte d = (byte)(b & 0x0f);
if (d < 10) {
sb.append((char)('0' + d));
} else {
sb.append((char)('a' - 10 + d));
}
}
Log.d(tag, sb.toString());
return length;
}
}