1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
/*
* Fast QR Code generator library
*
* Copyright (c) Project Nayuki. (MIT License)
* https://www.nayuki.io/page/fast-qr-code-generator-library
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
* - The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
* - The Software is provided "as is", without warranty of any kind, express or
* implied, including but not limited to the warranties of merchantability,
* fitness for a particular purpose and noninfringement. In no event shall the
* authors or copyright holders be liable for any claim, damages or other
* liability, whether in an action of contract, tort or otherwise, arising from,
* out of or in connection with the Software or the use or other dealings in the
* Software.
*/
package io.nayuki.fastqrcodegen;
import java.util.Arrays;
import java.util.Objects;
// An appendable sequence of bits (0s and 1s), mainly used by QrSegment.
final class BitBuffer {
/*---- Fields ----*/
int[] data; // In each 32-bit word, bits are filled from top down.
int bitLength; // Always non-negative.
/*---- Constructor ----*/
// Creates an empty bit buffer.
public BitBuffer() {
data = new int[64];
bitLength = 0;
}
/*---- Methods ----*/
// Returns the bit at the given index, yielding 0 or 1.
public int getBit(int index) {
if (index < 0 || index >= bitLength)
throw new IndexOutOfBoundsException();
return (data[index >>> 5] >>> ~index) & 1;
}
// Returns a new array representing this buffer's bits packed into
// bytes in big endian. The current bit length must be a multiple of 8.
public byte[] getBytes() {
if (bitLength % 8 != 0)
throw new IllegalStateException("Data is not a whole number of bytes");
byte[] result = new byte[bitLength / 8];
for (int i = 0; i < result.length; i++)
result[i] = (byte)(data[i >>> 2] >>> (~i << 3));
return result;
}
// Appends the given number of low-order bits of the given value
// to this buffer. Requires 0 <= len <= 31 and 0 <= val < 2^len.
public void appendBits(int val, int len) {
if (len < 0 || len > 31 || val >>> len != 0)
throw new IllegalArgumentException("Value out of range");
if (len > Integer.MAX_VALUE - bitLength)
throw new IllegalStateException("Maximum length reached");
if (bitLength + len + 1 > data.length << 5)
data = Arrays.copyOf(data, data.length * 2);
assert bitLength + len <= data.length << 5;
int remain = 32 - (bitLength & 0x1F);
assert 1 <= remain && remain <= 32;
if (remain < len) {
data[bitLength >>> 5] |= val >>> (len - remain);
bitLength += remain;
assert (bitLength & 0x1F) == 0;
len -= remain;
val &= (1 << len) - 1;
remain = 32;
}
data[bitLength >>> 5] |= val << (remain - len);
bitLength += len;
}
// Appends to this buffer the sequence of bits represented by the given
// word array and given bit length. Requires 0 <= len <= 32 * vals.length.
public void appendBits(int[] vals, int len) {
Objects.requireNonNull(vals);
if (len == 0)
return;
if (len < 0 || len > vals.length * 32L)
throw new IllegalArgumentException("Value out of range");
int wholeWords = len / 32;
int tailBits = len % 32;
if (tailBits > 0 && vals[wholeWords] << tailBits != 0)
throw new IllegalArgumentException("Last word must have low bits clear");
if (len > Integer.MAX_VALUE - bitLength)
throw new IllegalStateException("Maximum length reached");
while (bitLength + len > data.length * 32)
data = Arrays.copyOf(data, data.length * 2);
int shift = bitLength % 32;
if (shift == 0) {
System.arraycopy(vals, 0, data, bitLength / 32, (len + 31) / 32);
bitLength += len;
} else {
for (int i = 0; i < wholeWords; i++) {
int word = vals[i];
data[bitLength >>> 5] |= word >>> shift;
bitLength += 32;
data[bitLength >>> 5] = word << (32 - shift);
}
if (tailBits > 0)
appendBits(vals[wholeWords] >>> (32 - tailBits), tailBits);
}
}
}
|
