1 /*
2  * Copyright (C) 2008 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.android.internal.util;
18 
19 import android.compat.annotation.UnsupportedAppUsage;
20 
21 /**
22  * An object that provides bitwise incremental write access to a byte array.
23  *
24  * This is useful, for example, when writing a series of fields that
25  * may not be aligned on byte boundaries.
26  *
27  * NOTE -- This class is not threadsafe.
28  */
29 public class BitwiseOutputStream {
30 
31     // The byte array being written to, which will be grown as needed.
32     private byte[] mBuf;
33 
34     // The current position offset, in bits, from the msb in byte 0.
35     private int mPos;
36 
37     // The last bit offset, given the current buf length.
38     private int mEnd;
39 
40     /**
41      * An exception to report access problems.
42      */
43     public static class AccessException extends Exception {
AccessException(String s)44         public AccessException(String s) {
45             super("BitwiseOutputStream access failed: " + s);
46         }
47     }
48 
49     /**
50      * Create object from hint at desired size.
51      *
52      * @param startingLength initial internal byte array length in bytes
53      */
54     @UnsupportedAppUsage
BitwiseOutputStream(int startingLength)55     public BitwiseOutputStream(int startingLength) {
56         mBuf = new byte[startingLength];
57         mEnd = startingLength << 3;
58         mPos = 0;
59     }
60 
61     /**
62      * Return byte array containing accumulated data, sized to just fit.
63      *
64      * @return newly allocated byte array
65      */
66     @UnsupportedAppUsage
toByteArray()67     public byte[] toByteArray() {
68         int len = (mPos >>> 3) + ((mPos & 0x07) > 0 ? 1 : 0);  // &7==%8
69         byte[] newBuf = new byte[len];
70         System.arraycopy(mBuf, 0, newBuf, 0, len);
71         return newBuf;
72     }
73 
74     /**
75      * Allocate a new internal buffer, if needed.
76      *
77      * @param bits additional bits to be accommodated
78      */
possExpand(int bits)79     private void possExpand(int bits) {
80         if ((mPos + bits) < mEnd) return;
81         byte[] newBuf = new byte[(mPos + bits) >>> 2];
82         System.arraycopy(mBuf, 0, newBuf, 0, mEnd >>> 3);
83         mBuf = newBuf;
84         mEnd = newBuf.length << 3;
85     }
86 
87     /**
88      * Write some data and increment the current position.
89      *
90      * The 8-bit limit on access to bitwise streams is intentional to
91      * avoid endianness issues.
92      *
93      * @param bits the amount of data to write (gte 0, lte 8)
94      * @param data to write, will be masked to expose only bits param from lsb
95      */
96     @UnsupportedAppUsage
write(int bits, int data)97     public void write(int bits, int data) throws AccessException {
98         if ((bits < 0) || (bits > 8)) {
99             throw new AccessException("illegal write (" + bits + " bits)");
100         }
101         possExpand(bits);
102         data &= (-1 >>> (32 - bits));
103         int index = mPos >>> 3;
104         int offset = 16 - (mPos & 0x07) - bits;  // &7==%8
105         data <<= offset;
106         mPos += bits;
107         mBuf[index] |= data >>> 8;
108         if (offset < 8) mBuf[index + 1] |= data & 0xFF;
109     }
110 
111     /**
112      * Write data in bulk from a byte array and increment the current position.
113      *
114      * @param bits the amount of data to write
115      * @param arr the byte array containing data to be written
116      */
117     @UnsupportedAppUsage
writeByteArray(int bits, byte[] arr)118     public void writeByteArray(int bits, byte[] arr) throws AccessException {
119         for (int i = 0; i < arr.length; i++) {
120             int increment = Math.min(8, bits - (i << 3));
121             if (increment > 0) {
122                 write(increment, (byte)(arr[i] >>> (8 - increment)));
123             }
124         }
125     }
126 
127     /**
128      * Increment the current position, implicitly writing zeros.
129      *
130      * @param bits the amount by which to increment the position
131      */
skip(int bits)132     public void skip(int bits) {
133         possExpand(bits);
134         mPos += bits;
135     }
136 }
137