BitPacker.java

package com.example.bip39.bit;

import java.util.Objects;

public final class BitPacker {

  private static final int ELEVEN_BIT_GROUP_SIZE = 11;

  private BitPacker() {}

  public static int readBits(byte[] source, int bitOffset, int bitLength) {
    Objects.requireNonNull(source, "source must not be null");
    validateBitAccess(source.length, bitOffset, bitLength);
    if (bitLength > Integer.SIZE - 1) {
      throw new IllegalArgumentException("bitLength must be at most 31");
    }

    int value = 0;
    for (int bitIndex = 0; bitIndex < bitLength; bitIndex++) {
      int absoluteBitIndex = bitOffset + bitIndex;
      int byteIndex = absoluteBitIndex / Byte.SIZE;
      int bitIndexInByte = 7 - (absoluteBitIndex % Byte.SIZE);
      int bit = ((source[byteIndex] & 0xff) >> bitIndexInByte) & 0x01;
      value = (value << 1) | bit;
    }
    return value;
  }

  public static void writeBits(byte[] target, int bitOffset, int bitLength, int value) {
    Objects.requireNonNull(target, "target must not be null");
    validateBitAccess(target.length, bitOffset, bitLength);
    if (bitLength > Integer.SIZE - 1) {
      throw new IllegalArgumentException("bitLength must be at most 31");
    }
    if (bitLength != 0 && value >>> bitLength != 0) {
      throw new IllegalArgumentException("value does not fit into the requested bit length");
    }

    for (int bitIndex = 0; bitIndex < bitLength; bitIndex++) {
      int absoluteBitIndex = bitOffset + bitIndex;
      int byteIndex = absoluteBitIndex / Byte.SIZE;
      int bitIndexInByte = 7 - (absoluteBitIndex % Byte.SIZE);
      int bitMask = 1 << bitIndexInByte;
      int bit = (value >> (bitLength - 1 - bitIndex)) & 0x01;
      int clearedByte = target[byteIndex] & ~bitMask;
      target[byteIndex] = (byte) (clearedByte | (bit << bitIndexInByte));
    }
  }

  public static int[] splitTo11BitValues(byte[] source, int totalBitLength) {
    Objects.requireNonNull(source, "source must not be null");
    validateTotalBitLength(source.length, totalBitLength);
    if (totalBitLength % ELEVEN_BIT_GROUP_SIZE != 0) {
      throw new IllegalArgumentException("totalBitLength must be divisible by 11");
    }

    int[] values = new int[totalBitLength / ELEVEN_BIT_GROUP_SIZE];
    for (int valueIndex = 0; valueIndex < values.length; valueIndex++) {
      values[valueIndex] =
          readBits(source, valueIndex * ELEVEN_BIT_GROUP_SIZE, ELEVEN_BIT_GROUP_SIZE);
    }
    return values;
  }

  public static byte[] pack11BitValues(int[] values) {
    Objects.requireNonNull(values, "values must not be null");
    byte[] packed = new byte[(values.length * ELEVEN_BIT_GROUP_SIZE + 7) / Byte.SIZE];
    for (int valueIndex = 0; valueIndex < values.length; valueIndex++) {
      int value = values[valueIndex];
      if (value < 0 || value > 0x7ff) {
        throw new IllegalArgumentException("11-bit value out of range: " + value);
      }
      writeBits(packed, valueIndex * ELEVEN_BIT_GROUP_SIZE, ELEVEN_BIT_GROUP_SIZE, value);
    }
    return packed;
  }

  public static byte[] extractBytes(byte[] source, int bitOffset, int bitLength) {
    Objects.requireNonNull(source, "source must not be null");
    validateBitAccess(source.length, bitOffset, bitLength);
    if (bitLength % Byte.SIZE != 0) {
      throw new IllegalArgumentException("bitLength must be divisible by 8");
    }

    byte[] bytes = new byte[bitLength / Byte.SIZE];
    for (int byteIndex = 0; byteIndex < bytes.length; byteIndex++) {
      bytes[byteIndex] = (byte) readBits(source, bitOffset + byteIndex * Byte.SIZE, Byte.SIZE);
    }
    return bytes;
  }

  private static void validateTotalBitLength(int sourceLengthBytes, int totalBitLength) {
    validateBitAccess(sourceLengthBytes, 0, totalBitLength);
  }

  private static void validateBitAccess(int sourceLengthBytes, int bitOffset, int bitLength) {
    if (bitOffset < 0) {
      throw new IllegalArgumentException("bitOffset must not be negative");
    }
    if (bitLength < 0) {
      throw new IllegalArgumentException("bitLength must not be negative");
    }
    if (bitOffset + bitLength > sourceLengthBytes * Byte.SIZE) {
      throw new IllegalArgumentException("Requested bits exceed source length");
    }
  }
}