further preparations for Kotlin transpilation

PiperOrigin-RevId: 603638823

8 files changed, 122 insertions, 108 deletions

diff --git a/java/org/brotli/dec/BitReader.java b/java/org/brotli/dec/BitReader.java
index c0a15d2..ce863a0 100644
--- a/java/org/brotli/dec/BitReader.java
+++ b/java/org/brotli/dec/BitReader.java
@@ -146,9 +146,9 @@ final class BitReader {
    * otherwise BitReader will become broken.
    */
   static int readFewBits(State s, int n) {
-    final int val = peekBits(s) & ((1 << n) - 1);
+    final int v = peekBits(s) & ((1 << n) - 1);
     s.bitOffset += n;
-    return val;
+    return v;
   }
 
   static int readBits(State s, int n) {
@@ -212,31 +212,33 @@ final class BitReader {
   }
 
   static void copyRawBytes(State s, byte[] data, int offset, int length) {
+    int pos = offset;
+    int len = length;
     if ((s.bitOffset & 7) != 0) {
       throw new BrotliRuntimeException("Unaligned copyBytes");
     }
 
     // Drain accumulator.
-    while ((s.bitOffset != BITNESS) && (length != 0)) {
-      data[offset++] = (byte) peekBits(s);
+    while ((s.bitOffset != BITNESS) && (len != 0)) {
+      data[pos++] = (byte) peekBits(s);
       s.bitOffset += 8;
-      length--;
+      len--;
     }
-    if (length == 0) {
+    if (len == 0) {
       return;
     }
 
     // Get data from shadow buffer with "sizeof(int)" granularity.
-    final int copyNibbles = Math.min(halfAvailable(s), length >> LOG_HALF_SIZE);
+    final int copyNibbles = Math.min(halfAvailable(s), len >> LOG_HALF_SIZE);
     if (copyNibbles > 0) {
       final int readOffset = s.halfOffset << LOG_HALF_SIZE;
       final int delta = copyNibbles << LOG_HALF_SIZE;
-      System.arraycopy(s.byteBuffer, readOffset, data, offset, delta);
-      offset += delta;
-      length -= delta;
+      System.arraycopy(s.byteBuffer, readOffset, data, pos, delta);
+      pos += delta;
+      len -= delta;
       s.halfOffset += copyNibbles;
     }
-    if (length == 0) {
+    if (len == 0) {
       return;
     }
 
@@ -244,23 +246,23 @@ final class BitReader {
     if (halfAvailable(s) > 0) {
       // length = 1..3
       fillBitWindow(s);
-      while (length != 0) {
-        data[offset++] = (byte) peekBits(s);
+      while (len != 0) {
+        data[pos++] = (byte) peekBits(s);
         s.bitOffset += 8;
-        length--;
+        len--;
       }
       checkHealth(s, 0);
       return;
     }
 
     // Now it is possible to copy bytes directly.
-    while (length > 0) {
-      final int len = Utils.readInput(s, data, offset, length);
-      if (len == -1) {
+    while (len > 0) {
+      final int chunkLen = Utils.readInput(s, data, pos, len);
+      if (chunkLen == -1) {
         throw new BrotliRuntimeException("Unexpected end of input");
       }
-      offset += len;
-      length -= len;
+      pos += chunkLen;
+      len -= chunkLen;
     }
   }
 
@@ -273,16 +275,16 @@ final class BitReader {
     if (BITNESS == 64) {
       final int[] intBuffer = s.intBuffer;
       for (int i = 0; i < halfLen; ++i) {
-        intBuffer[i] = ((byteBuffer[i * 4] & 0xFF))
-            | ((byteBuffer[(i * 4) + 1] & 0xFF) << 8)
-            | ((byteBuffer[(i * 4) + 2] & 0xFF) << 16)
-            | ((byteBuffer[(i * 4) + 3] & 0xFF) << 24);
+        intBuffer[i] = ((int) byteBuffer[i * 4] & 0xFF)
+            | (((int) byteBuffer[(i * 4) + 1] & 0xFF) << 8)
+            | (((int) byteBuffer[(i * 4) + 2] & 0xFF) << 16)
+            | (((int) byteBuffer[(i * 4) + 3] & 0xFF) << 24);
       }
     } else {
       final short[] shortBuffer = s.shortBuffer;
       for (int i = 0; i < halfLen; ++i) {
-        shortBuffer[i] = (short) ((byteBuffer[i * 2] & 0xFF)
-            | ((byteBuffer[(i * 2) + 1] & 0xFF) << 8));
+        shortBuffer[i] = (short) (((int) byteBuffer[i * 2] & 0xFF)
+            | (((int) byteBuffer[(i * 2) + 1] & 0xFF) << 8));
       }
     }
   }
diff --git a/java/org/brotli/dec/Context.java b/java/org/brotli/dec/Context.java
index 10bf0cb..0fa9d52 100644
--- a/java/org/brotli/dec/Context.java
+++ b/java/org/brotli/dec/Context.java
@@ -26,7 +26,7 @@ final class Context {
     }
     // UTF8
     for (int i = 0; i < 128; ++i) {
-      lookup[1024 + i] = 4 * (map.charAt(i) - 32);
+      lookup[1024 + i] = 4 * ((int) map.charAt(i) - 32);
     }
     for (int i = 0; i < 64; ++i) {
       lookup[1152 + i] = i & 1;
@@ -35,7 +35,7 @@ final class Context {
     int offset = 1280;
     for (int k = 0; k < 19; ++k) {
       final int value = k & 3;
-      final int rep = rle.charAt(k) - 32;
+      final int rep = (int) rle.charAt(k) - 32;
       for (int i = 0; i < rep; ++i) {
         lookup[offset++] = value;
       }
diff --git a/java/org/brotli/dec/Decode.java b/java/org/brotli/dec/Decode.java
index 19d7c1e..5c28a4e 100644
--- a/java/org/brotli/dec/Decode.java
+++ b/java/org/brotli/dec/Decode.java
@@ -137,14 +137,16 @@ final class Decode {
   private static int log2floor(int i) {
     int result = -1;
     int step = 16;
+    int v = i;
     while (step > 0) {
-      if ((i >>> step) != 0) {
+      int next = v >>> step;
+      if (next != 0) {
         result += step;
-        i = i >>> step;
+        v = next;
       }
       step = step >> 1;
     }
-    return result + i;
+    return result + v;
   }
 
   private static int calculateDistanceAlphabetSize(int npostfix, int ndirect, int maxndistbits) {
@@ -164,14 +166,12 @@ final class Decode {
   }
 
   private static void unpackCommandLookupTable(short[] cmdLookup) {
-    final short[] insertLengthOffsets = new short[24];
-    final short[] copyLengthOffsets = new short[24];
+    final int[] insertLengthOffsets = new int[24];
+    final int[] copyLengthOffsets = new int[24];
     copyLengthOffsets[0] = 2;
     for (int i = 0; i < 23; ++i) {
-      insertLengthOffsets[i + 1] =
-          (short) (insertLengthOffsets[i] + (1 << INSERT_LENGTH_N_BITS[i]));
-      copyLengthOffsets[i + 1] =
-          (short) (copyLengthOffsets[i] + (1 << COPY_LENGTH_N_BITS[i]));
+      insertLengthOffsets[i + 1] = insertLengthOffsets[i] + (1 << (int) INSERT_LENGTH_N_BITS[i]);
+      copyLengthOffsets[i + 1] = copyLengthOffsets[i] + (1 << (int) COPY_LENGTH_N_BITS[i]);
     }
 
     for (int cmdCode = 0; cmdCode < NUM_COMMAND_CODES; ++cmdCode) {
@@ -184,14 +184,15 @@ final class Decode {
       }
       final int insertCode = (((0x29850 >>> (rangeIdx * 2)) & 0x3) << 3) | ((cmdCode >>> 3) & 7);
       final int copyCode = (((0x26244 >>> (rangeIdx * 2)) & 0x3) << 3) | (cmdCode & 7);
-      final short copyLengthOffset = copyLengthOffsets[copyCode];
+      final int copyLengthOffset = copyLengthOffsets[copyCode];
       final int distanceContext =
-          distanceContextOffset + (copyLengthOffset > 4 ? 3 : copyLengthOffset - 2);
+          distanceContextOffset + (copyLengthOffset > 4 ? 3 : (copyLengthOffset - 2));
       final int index = cmdCode * 4;
       cmdLookup[index + 0] =
-          (short) (INSERT_LENGTH_N_BITS[insertCode] | (COPY_LENGTH_N_BITS[copyCode] << 8));
-      cmdLookup[index + 1] = insertLengthOffsets[insertCode];
-      cmdLookup[index + 2] = copyLengthOffsets[copyCode];
+          (short)
+              ((int) INSERT_LENGTH_N_BITS[insertCode] | ((int) COPY_LENGTH_N_BITS[copyCode] << 8));
+      cmdLookup[index + 1] = (short) insertLengthOffsets[insertCode];
+      cmdLookup[index + 2] = (short) copyLengthOffsets[copyCode];
       cmdLookup[index + 3] = (short) distanceContext;
     }
   }
@@ -357,7 +358,7 @@ final class Decode {
         if (bits == 0 && i + 1 == sizeBytes && sizeBytes > 1) {
           throw new BrotliRuntimeException("Exuberant nibble");
         }
-        s.metaBlockLength |= bits << (i * 8);
+        s.metaBlockLength += bits << (i * 8);
       }
     } else {
       for (int i = 0; i < sizeNibbles; ++i) {
@@ -366,7 +367,7 @@ final class Decode {
         if (bits == 0 && i + 1 == sizeNibbles && sizeNibbles > 4) {
           throw new BrotliRuntimeException("Exuberant nibble");
         }
-        s.metaBlockLength |= bits << (i * 4);
+        s.metaBlockLength += bits << (i * 4);
       }
     }
     s.metaBlockLength++;
@@ -380,8 +381,8 @@ final class Decode {
    */
   private static int readSymbol(int[] tableGroup, int tableIdx, State s) {
     int offset = tableGroup[tableIdx];
-    final int val = BitReader.peekBits(s);
-    offset += val & HUFFMAN_TABLE_MASK;
+    final int v = BitReader.peekBits(s);
+    offset += v & HUFFMAN_TABLE_MASK;
     final int bits = tableGroup[offset] >> 16;
     final int sym = tableGroup[offset] & 0xFFFF;
     if (bits <= HUFFMAN_TABLE_BITS) {
@@ -390,7 +391,7 @@ final class Decode {
     }
     offset += sym;
     final int mask = (1 << bits) - 1;
-    offset += (val & mask) >>> HUFFMAN_TABLE_BITS;
+    offset += (v & mask) >>> HUFFMAN_TABLE_BITS;
     s.bitOffset += ((tableGroup[offset] >> 16) + HUFFMAN_TABLE_BITS);
     return tableGroup[offset] & 0xFFFF;
   }
@@ -404,10 +405,11 @@ final class Decode {
   }
 
   private static void moveToFront(int[] v, int index) {
-    final int value = v[index];
-    while (index > 0) {
-      v[index] = v[index - 1];
-      index--;
+    int i = index;
+    final int value = v[i];
+    while (i > 0) {
+      v[i] = v[i - 1];
+      i--;
     }
     v[0] = value;
   }
@@ -418,7 +420,7 @@ final class Decode {
       mtf[i] = i;
     }
     for (int i = 0; i < vLen; ++i) {
-      final int index = v[i] & 0xFF;
+      final int index = (int) v[i] & 0xFF;
       v[i] = (byte) mtf[index];
       if (index != 0) {
         moveToFront(mtf, index);
@@ -463,7 +465,7 @@ final class Decode {
         final int oldRepeat = repeat;
         if (repeat > 0) {
           repeat -= 2;
-          repeat <<= extraBits;
+          repeat = repeat << extraBits;
         }
         BitReader.fillBitWindow(s);
         repeat += BitReader.readFewBits(s, extraBits) + 3;
@@ -689,8 +691,8 @@ final class Decode {
     s.literalBlockLength = decodeBlockTypeAndLength(s, 0, s.numLiteralBlockTypes);
     final int literalBlockType = s.rings[5];
     s.contextMapSlice = literalBlockType << LITERAL_CONTEXT_BITS;
-    s.literalTreeIdx = s.contextMap[s.contextMapSlice] & 0xFF;
-    final int contextMode = s.contextModes[literalBlockType];
+    s.literalTreeIdx = (int) s.contextMap[s.contextMapSlice] & 0xFF;
+    final int contextMode = (int) s.contextModes[literalBlockType];
     s.contextLookupOffset1 = contextMode << 9;
     s.contextLookupOffset2 = s.contextLookupOffset1 + 256;
   }
@@ -711,7 +713,7 @@ final class Decode {
       /* TODO(eustas): Handle 2GB+ cases more gracefully. */
       final int minimalNewSize = s.expectedTotalSize;
       while ((newSize >> 1) > minimalNewSize) {
-        newSize >>= 1;
+        newSize = newSize >> 1;
       }
       if ((s.inputEnd == 0) && newSize < 16384 && s.maxRingBufferSize >= 16384) {
         newSize = 16384;
@@ -722,8 +724,9 @@ final class Decode {
     }
     final int ringBufferSizeWithSlack = newSize + MAX_TRANSFORMED_WORD_LENGTH;
     final byte[] newBuffer = new byte[ringBufferSizeWithSlack];
-    if (s.ringBuffer.length != 0) {
-      System.arraycopy(s.ringBuffer, 0, newBuffer, 0, s.ringBufferSize);
+    final byte[] oldBuffer = s.ringBuffer;
+    if (oldBuffer.length != 0) {
+      System.arraycopy(oldBuffer, 0, newBuffer, 0, s.ringBufferSize);
     }
     s.ringBuffer = newBuffer;
     s.ringBufferSize = newSize;
@@ -850,7 +853,7 @@ final class Decode {
     final int numLiteralTrees = decodeContextMap(contextMapLength, s.contextMap, s);
     s.trivialLiteralContext = 1;
     for (int j = 0; j < contextMapLength; ++j) {
-      if (s.contextMap[j] != j >> LITERAL_CONTEXT_BITS) {
+      if ((int) s.contextMap[j] != j >> LITERAL_CONTEXT_BITS) {
         s.trivialLiteralContext = 0;
         break;
       }
@@ -1021,7 +1024,7 @@ final class Decode {
     if (s.cdBlockBits == -1) {
       initializeCompoundDictionary(s);
     }
-    int index = s.cdBlockMap[address >>> s.cdBlockBits];
+    int index = (int) s.cdBlockMap[address >>> s.cdBlockBits];
     while (address >= s.cdChunkOffsets[index + 1]) {
       index++;
     }
@@ -1123,10 +1126,10 @@ final class Decode {
           s.commandBlockLength--;
           BitReader.fillBitWindow(s);
           final int cmdCode = readSymbol(s.commandTreeGroup, s.commandTreeIdx, s) << 2;
-          final short insertAndCopyExtraBits = CMD_LOOKUP[cmdCode];
-          final int insertLengthOffset = CMD_LOOKUP[cmdCode + 1];
-          final int copyLengthOffset = CMD_LOOKUP[cmdCode + 2];
-          s.distanceCode = CMD_LOOKUP[cmdCode + 3];
+          final int insertAndCopyExtraBits = (int) CMD_LOOKUP[cmdCode];
+          final int insertLengthOffset = (int) CMD_LOOKUP[cmdCode + 1];
+          final int copyLengthOffset = (int) CMD_LOOKUP[cmdCode + 2];
+          s.distanceCode = (int) CMD_LOOKUP[cmdCode + 3];
           BitReader.fillBitWindow(s);
           {
             final int insertLengthExtraBits = insertAndCopyExtraBits & 0xFF;
@@ -1161,8 +1164,8 @@ final class Decode {
               }
             }
           } else {
-            int prevByte1 = ringBuffer[(s.pos - 1) & ringBufferMask] & 0xFF;
-            int prevByte2 = ringBuffer[(s.pos - 2) & ringBufferMask] & 0xFF;
+            int prevByte1 = (int) ringBuffer[(s.pos - 1) & ringBufferMask] & 0xFF;
+            int prevByte2 = (int) ringBuffer[(s.pos - 2) & ringBufferMask] & 0xFF;
             while (s.j < s.insertLength) {
               BitReader.readMoreInput(s);
               if (s.literalBlockLength == 0) {
@@ -1170,7 +1173,8 @@ final class Decode {
               }
               final int literalContext = Context.LOOKUP[s.contextLookupOffset1 + prevByte1]
                   | Context.LOOKUP[s.contextLookupOffset2 + prevByte2];
-              final int literalTreeIdx = s.contextMap[s.contextMapSlice + literalContext] & 0xFF;
+              final int literalTreeIdx =
+                  (int) s.contextMap[s.contextMapSlice + literalContext] & 0xFF;
               s.literalBlockLength--;
               prevByte2 = prevByte1;
               BitReader.fillBitWindow(s);
@@ -1204,7 +1208,8 @@ final class Decode {
             }
             s.distanceBlockLength--;
             BitReader.fillBitWindow(s);
-            final int distTreeIdx = s.distContextMap[s.distContextMapSlice + distanceCode] & 0xFF;
+            final int distTreeIdx =
+                (int) s.distContextMap[s.distContextMapSlice + distanceCode] & 0xFF;
             distanceCode = readSymbol(s.distanceTreeGroup, distTreeIdx, s);
             if (distanceCode < NUM_DISTANCE_SHORT_CODES) {
               final int index =
@@ -1214,7 +1219,7 @@ final class Decode {
                 throw new BrotliRuntimeException("Negative distance"); // COV_NF_LINE
               }
             } else {
-              final int extraBits = s.distExtraBits[distanceCode];
+              final int extraBits = (int) s.distExtraBits[distanceCode];
               int bits;
               if (s.bitOffset + extraBits <= BitReader.BITNESS) {
                 bits = BitReader.readFewBits(s, extraBits);
@@ -1337,7 +1342,7 @@ final class Decode {
             if (s.pos > s.ringBufferSize) {
               Utils.copyBytesWithin(ringBuffer, 0, s.ringBufferSize, s.pos);
             }
-            s.pos &= ringBufferMask;
+            s.pos = s.pos & ringBufferMask;
             s.ringBufferBytesWritten = 0;
           }
           s.runningState = s.nextRunningState;
diff --git a/java/org/brotli/dec/DictionaryData.java b/java/org/brotli/dec/DictionaryData.java
index 2bc4063..4f5ce96 100644
--- a/java/org/brotli/dec/DictionaryData.java
+++ b/java/org/brotli/dec/DictionaryData.java
@@ -45,20 +45,20 @@ final class DictionaryData {
     int offset = 0;
     final int n = skipFlip.length() >> 1;
     for (int i = 0; i < n; ++i) {
-      final int skip = skipFlip.charAt(2 * i) - 36;
-      final int flip = skipFlip.charAt(2 * i + 1) - 36;
+      final int skip = (int) skipFlip.charAt(2 * i) - 36;
+      final int flip = (int) skipFlip.charAt(2 * i + 1) - 36;
       for (int j = 0; j < skip; ++j) {
-        dict[offset] ^= 3;
+        dict[offset] = (byte) ((int) dict[offset] ^ 3);
         offset++;
       }
       for (int j = 0; j < flip; ++j) {
-        dict[offset] ^= 236;
+        dict[offset] = (byte) ((int) dict[offset] ^ 236);
         offset++;
       }
     }
 
     for (int i = 0; i < sizeBitsData.length(); ++i) {
-      sizeBits[i] = sizeBitsData.charAt(i) - 65;
+      sizeBits[i] = (int) sizeBitsData.charAt(i) - 65;
     }
 
     dictionary.put(dict);
diff --git a/java/org/brotli/dec/Huffman.java b/java/org/brotli/dec/Huffman.java
index 4ba8c1d..110e290 100644
--- a/java/org/brotli/dec/Huffman.java
+++ b/java/org/brotli/dec/Huffman.java
@@ -21,7 +21,7 @@ final class Huffman {
   private static int getNextKey(int key, int len) {
     int step = 1 << (len - 1);
     while ((key & step) != 0) {
-      step >>= 1;
+      step = step >> 1;
     }
     return (key & (step - 1)) + step;
   }
@@ -32,10 +32,11 @@ final class Huffman {
    * <p> Assumes that end is an integer multiple of step.
    */
   private static void replicateValue(int[] table, int offset, int step, int end, int item) {
+    int pos = end;
     do {
-      end -= step;
-      table[offset + end] = item;
-    } while (end > 0);
+      pos -= step;
+      table[offset + pos] = item;
+    } while (pos > 0);
   }
 
   /**
@@ -44,16 +45,17 @@ final class Huffman {
    * @return table width of the next 2nd level table.
    */
   private static int nextTableBitSize(int[] count, int len, int rootBits) {
-    int left = 1 << (len - rootBits);
-    while (len < MAX_LENGTH) {
-      left -= count[len];
+    int bits = len;
+    int left = 1 << (bits - rootBits);
+    while (bits < MAX_LENGTH) {
+      left -= count[bits];
       if (left <= 0) {
         break;
       }
-      len++;
-      left <<= 1;
+      bits++;
+      left = left << 1;
     }
-    return len - rootBits;
+    return bits - rootBits;
   }
 
   /**
@@ -104,7 +106,7 @@ final class Huffman {
     int symbol = 0;
     int step = 1;
     for (int len = 1; len <= rootBits; ++len) {
-      step <<= 1;
+      step = step << 1;
       while (count[len] > 0) {
         replicateValue(tableGroup, tableOffset + key, step, tableSize,
             len << 16 | sorted[symbol++]);
@@ -119,7 +121,7 @@ final class Huffman {
     int currentOffset = tableOffset;
     step = 1;
     for (int len = rootBits + 1; len <= MAX_LENGTH; ++len) {
-      step <<= 1;
+      step = step << 1;
       while (count[len] > 0) {
         if ((key & mask) != low) {
           currentOffset += tableSize;
diff --git a/java/org/brotli/dec/State.java b/java/org/brotli/dec/State.java
index 94db93a..3b654b5 100644
--- a/java/org/brotli/dec/State.java
+++ b/java/org/brotli/dec/State.java
@@ -87,7 +87,7 @@ final class State {
   int cdBlockBits;
   byte[] cdBlockMap;
 
-  InputStream /* @Nullable */ input; // BitReader
+  InputStream input = Utils.makeEmptyInput();  // BitReader
 
   State() {
     this.ringBuffer = new byte[0];
diff --git a/java/org/brotli/dec/Transform.java b/java/org/brotli/dec/Transform.java
index 6a57a9e..15370cd 100644
--- a/java/org/brotli/dec/Transform.java
+++ b/java/org/brotli/dec/Transform.java
@@ -80,7 +80,7 @@ final class Transform {
     int index = 1;
     int j = 0;
     for (int i = 0; i < n; ++i) {
-      final char c = prefixSuffixSrc.charAt(i);
+      final int c = (int) prefixSuffixSrc.charAt(i);
       if (c == 35) { // == #
         prefixSuffixHeads[index++] = j;
       } else {
@@ -89,7 +89,7 @@ final class Transform {
     }
 
     for (int i = 0; i < NUM_RFC_TRANSFORMS * 3; ++i) {
-      transforms[i] = transformsSrc.charAt(i) - 32;
+      transforms[i] = (int) transformsSrc.charAt(i) - 32;
     }
   }
 
@@ -99,7 +99,7 @@ final class Transform {
   }
 
   static int transformDictionaryWord(byte[] dst, int dstOffset, ByteBuffer src, int srcOffset,
-      int len, Transforms transforms, int transformIndex) {
+      int wordLen, Transforms transforms, int transformIndex) {
     int offset = dstOffset;
     final int[] triplets = transforms.triplets;
     final byte[] prefixSuffixStorage = transforms.prefixSuffixStorage;
@@ -127,16 +127,17 @@ final class Transform {
       dst[offset++] = prefixSuffixStorage[prefix++];
     }
 
+    int len = wordLen;
     // Copy trimmed word.
     if (omitFirst > len) {
       omitFirst = len;
     }
-    srcOffset += omitFirst;
+    int dictOffset = srcOffset + omitFirst;
     len -= omitFirst;
     len -= omitLast;
     int i = len;
     while (i > 0) {
-      dst[offset++] = src.get(srcOffset++);
+      dst[offset++] = src.get(dictOffset++);
       i--;
     }
 
@@ -147,31 +148,31 @@ final class Transform {
         len = 1;
       }
       while (len > 0) {
-        final int c0 = dst[uppercaseOffset] & 0xFF;
+        final int c0 = (int) dst[uppercaseOffset] & 0xFF;
         if (c0 < 0xC0) {
           if (c0 >= 97 && c0 <= 122) { // in [a..z] range
-            dst[uppercaseOffset] ^= (byte) 32;
+            dst[uppercaseOffset] = (byte) ((int) dst[uppercaseOffset] ^ 32);
           }
           uppercaseOffset += 1;
           len -= 1;
         } else if (c0 < 0xE0) {
-          dst[uppercaseOffset + 1] ^= (byte) 32;
+          dst[uppercaseOffset + 1] = (byte) ((int) dst[uppercaseOffset + 1] ^ 32);
           uppercaseOffset += 2;
           len -= 2;
         } else {
-          dst[uppercaseOffset + 2] ^= (byte) 5;
+          dst[uppercaseOffset + 2] = (byte) ((int) dst[uppercaseOffset + 2] ^ 5);
           uppercaseOffset += 3;
           len -= 3;
         }
       }
     } else if (transformType == SHIFT_FIRST || transformType == SHIFT_ALL) {
       int shiftOffset = offset - len;
-      final short param = transforms.params[transformIndex];
+      final int param = (int) transforms.params[transformIndex];
       /* Limited sign extension: scalar < (1 << 24). */
       int scalar = (param & 0x7FFF) + (0x1000000 - (param & 0x8000));
       while (len > 0) {
         int step = 1;
-        final int c0 = dst[shiftOffset] & 0xFF;
+        final int c0 = (int) dst[shiftOffset] & 0xFF;
         if (c0 < 0x80) {
           /* 1-byte rune / 0sssssss / 7 bit scalar (ASCII). */
           scalar += c0;
@@ -181,7 +182,7 @@ final class Transform {
         } else if (c0 < 0xE0) {
           /* 2-byte rune / 110sssss AAssssss / 11 bit scalar. */
           if (len >= 2) {
-            final byte c1 = dst[shiftOffset + 1];
+            final int c1 = (int) dst[shiftOffset + 1];
             scalar += (c1 & 0x3F) | ((c0 & 0x1F) << 6);
             dst[shiftOffset] = (byte) (0xC0 | ((scalar >> 6) & 0x1F));
             dst[shiftOffset + 1] = (byte) ((c1 & 0xC0) | (scalar & 0x3F));
@@ -192,8 +193,8 @@ final class Transform {
         } else if (c0 < 0xF0) {
           /* 3-byte rune / 1110ssss AAssssss BBssssss / 16 bit scalar. */
           if (len >= 3) {
-            final byte c1 = dst[shiftOffset + 1];
-            final byte c2 = dst[shiftOffset + 2];
+            final int c1 = (int) dst[shiftOffset + 1];
+            final int c2 = (int) dst[shiftOffset + 2];
             scalar += (c2 & 0x3F) | ((c1 & 0x3F) << 6) | ((c0 & 0x0F) << 12);
             dst[shiftOffset] = (byte) (0xE0 | ((scalar >> 12) & 0x0F));
             dst[shiftOffset + 1] = (byte) ((c1 & 0xC0) | ((scalar >> 6) & 0x3F));
@@ -205,9 +206,9 @@ final class Transform {
         } else if (c0 < 0xF8) {
           /* 4-byte rune / 11110sss AAssssss BBssssss CCssssss / 21 bit scalar. */
           if (len >= 4) {
-            final byte c1 = dst[shiftOffset + 1];
-            final byte c2 = dst[shiftOffset + 2];
-            final byte c3 = dst[shiftOffset + 3];
+            final int c1 = (int) dst[shiftOffset + 1];
+            final int c2 = (int) dst[shiftOffset + 2];
+            final int c3 = (int) dst[shiftOffset + 3];
             scalar += (c3 & 0x3F) | ((c2 & 0x3F) << 6) | ((c1 & 0x3F) << 12) | ((c0 & 0x07) << 18);
             dst[shiftOffset] = (byte) (0xF0 | ((scalar >> 18) & 0x07));
             dst[shiftOffset + 1] = (byte) ((c1 & 0xC0) | ((scalar >> 12) & 0x3F));
diff --git a/java/org/brotli/dec/Utils.java b/java/org/brotli/dec/Utils.java
index ff5f65d..be98c89 100644
--- a/java/org/brotli/dec/Utils.java
+++ b/java/org/brotli/dec/Utils.java
@@ -6,7 +6,9 @@
 
 package org.brotli.dec;
 
+import java.io.ByteArrayInputStream;
 import java.io.IOException;
+import java.io.InputStream;
 import java.io.UnsupportedEncodingException;
 import java.nio.Buffer;
 import java.nio.ByteBuffer;
@@ -74,11 +76,13 @@ final class Utils {
     }
   }
 
+  static InputStream makeEmptyInput() {
+    return new ByteArrayInputStream(new byte[0]);
+  }
+
   static void closeInput(State s) throws IOException {
-    if (s.input != null) {
-      s.input.close();
-      s.input = null;
-    }
+    s.input.close();
+    s.input = makeEmptyInput();
   }
 
   static byte[] toUsAsciiBytes(String src) {