Java BitSource.readBits方法代码示例

import com.google.zxing.common.BitSource; //导入方法依赖的package包/类
private static void decodeEdifactSegment(BitSource bits, StringBuilder result) {
    while (bits.available() > 16) {
        for (int i = 0; i < 4; i++) {
            int edifactValue = bits.readBits(6);
            if (edifactValue == 31) {
                int bitsLeft = 8 - bits.getBitOffset();
                if (bitsLeft != 8) {
                    bits.readBits(bitsLeft);
                    return;
                }
                return;
            }
            if ((edifactValue & 32) == 0) {
                edifactValue |= 64;
            }
            result.append((char) edifactValue);
        }
        if (bits.available() <= 0) {
            return;
        }
    }
}
 

import com.google.zxing.common.BitSource; //导入方法依赖的package包/类
private static int parseECIValue(BitSource bits) throws FormatException {
  int firstByte = bits.readBits(8);
  if ((firstByte & 0x80) == 0) {
    // just one byte
    return firstByte & 0x7F;
  }
  if ((firstByte & 0xC0) == 0x80) {
    // two bytes
    int secondByte = bits.readBits(8);
    return ((firstByte & 0x3F) << 8) | secondByte;
  }
  if ((firstByte & 0xE0) == 0xC0) {
    // three bytes
    int secondThirdBytes = bits.readBits(16);
    return ((firstByte & 0x1F) << 16) | secondThirdBytes;
  }
  throw FormatException.getFormatInstance();
}
 

import com.google.zxing.common.BitSource; //导入方法依赖的package包/类
private static void decodeKanjiSegment(BitSource bits, StringBuilder result, int count)
        throws FormatException {
    if (count * 13 > bits.available()) {
        throw FormatException.getFormatInstance();
    }
    byte[] buffer = new byte[(count * 2)];
    int offset = 0;
    while (count > 0) {
        int twoBytes = bits.readBits(13);
        int assembledTwoBytes = ((twoBytes / 192) << 8) | (twoBytes % 192);
        if (assembledTwoBytes < 7936) {
            assembledTwoBytes += 33088;
        } else {
            assembledTwoBytes += 49472;
        }
        buffer[offset] = (byte) (assembledTwoBytes >> 8);
        buffer[offset + 1] = (byte) assembledTwoBytes;
        offset += 2;
        count--;
    }
    try {
        result.append(new String(buffer, StringUtils.SHIFT_JIS));
    } catch (UnsupportedEncodingException e) {
        throw FormatException.getFormatInstance();
    }
}
 

import com.google.zxing.common.BitSource; //导入方法依赖的package包/类
private static void decodeByteSegment(BitSource bits, StringBuilder result, int count,
                                      CharacterSetECI currentCharacterSetECI,
                                      Collection<byte[]> byteSegments, Map<DecodeHintType, ?>
                                              hints) throws FormatException {
    if (count * 8 > bits.available()) {
        throw FormatException.getFormatInstance();
    }
    String encoding;
    byte[] readBytes = new byte[count];
    for (int i = 0; i < count; i++) {
        readBytes[i] = (byte) bits.readBits(8);
    }
    if (currentCharacterSetECI == null) {
        encoding = StringUtils.guessEncoding(readBytes, hints);
    } else {
        encoding = currentCharacterSetECI.name();
    }
    try {
        result.append(new String(readBytes, encoding));
        byteSegments.add(readBytes);
    } catch (UnsupportedEncodingException e) {
        throw FormatException.getFormatInstance();
    }
}
 

import com.google.zxing.common.BitSource; //导入方法依赖的package包/类
/**
 * See specification GBT 18284-2000
 */
private static void decodeHanziSegment(BitSource bits,
                                       StringBuilder result,
                                       int count) throws FormatException {
  // Don't crash trying to read more bits than we have available.
  if (count * 13 > bits.available()) {
    throw FormatException.getFormatInstance();
  }

  // Each character will require 2 bytes. Read the characters as 2-byte pairs
  // and decode as GB2312 afterwards
  byte[] buffer = new byte[2 * count];
  int offset = 0;
  while (count > 0) {
    // Each 13 bits encodes a 2-byte character
    int twoBytes = bits.readBits(13);
    int assembledTwoBytes = ((twoBytes / 0x060) << 8) | (twoBytes % 0x060);
    if (assembledTwoBytes < 0x003BF) {
      // In the 0xA1A1 to 0xAAFE range
      assembledTwoBytes += 0x0A1A1;
    } else {
      // In the 0xB0A1 to 0xFAFE range
      assembledTwoBytes += 0x0A6A1;
    }
    buffer[offset] = (byte) ((assembledTwoBytes >> 8) & 0xFF);
    buffer[offset + 1] = (byte) (assembledTwoBytes & 0xFF);
    offset += 2;
    count--;
  }

  try {
    result.append(new String(buffer, StringUtils.GB2312));
  } catch (UnsupportedEncodingException ignored) {
    throw FormatException.getFormatInstance();
  }
}
 

import com.google.zxing.common.BitSource; //导入方法依赖的package包/类
private static void decodeAlphanumericSegment(BitSource bits, StringBuilder result, int
        count, boolean fc1InEffect) throws FormatException {
    int start = result.length();
    while (count > 1) {
        if (bits.available() < 11) {
            throw FormatException.getFormatInstance();
        }
        int nextTwoCharsBits = bits.readBits(11);
        result.append(toAlphaNumericChar(nextTwoCharsBits / 45));
        result.append(toAlphaNumericChar(nextTwoCharsBits % 45));
        count -= 2;
    }
    if (count == 1) {
        if (bits.available() < 6) {
            throw FormatException.getFormatInstance();
        }
        result.append(toAlphaNumericChar(bits.readBits(6)));
    }
    if (fc1InEffect) {
        int i = start;
        while (i < result.length()) {
            if (result.charAt(i) == '%') {
                if (i >= result.length() - 1 || result.charAt(i + 1) != '%') {
                    result.setCharAt(i, '\u001d');
                } else {
                    result.deleteCharAt(i + 1);
                }
            }
            i++;
        }
    }
}
 

import com.google.zxing.common.BitSource; //导入方法依赖的package包/类
private static void decodeByteSegment(BitSource bits,
                                      StringBuilder result,
                                      int count,
                                      CharacterSetECI currentCharacterSetECI,
                                      Collection<byte[]> byteSegments,
                                      Map<DecodeHintType,?> hints) throws FormatException {
  // Don't crash trying to read more bits than we have available.
  if (8 * count > bits.available()) {
    throw FormatException.getFormatInstance();
  }

  byte[] readBytes = new byte[count];
  for (int i = 0; i < count; i++) {
    readBytes[i] = (byte) bits.readBits(8);
  }
  String encoding;
  if (currentCharacterSetECI == null) {
    // The spec isn't clear on this mode; see
    // section 6.4.5: t does not say which encoding to assuming
    // upon decoding. I have seen ISO-8859-1 used as well as
    // Shift_JIS -- without anything like an ECI designator to
    // give a hint.
    encoding = StringUtils.guessEncoding(readBytes, hints);
  } else {
    encoding = currentCharacterSetECI.name();
  }
  try {
    result.append(new String(readBytes, encoding));
  } catch (UnsupportedEncodingException ignored) {
    throw FormatException.getFormatInstance();
  }
  byteSegments.add(readBytes);
}
 

import com.google.zxing.common.BitSource; //导入方法依赖的package包/类
private static void decodeAlphanumericSegment(BitSource bits,
                                              StringBuilder result,
                                              int count,
                                              boolean fc1InEffect) throws FormatException {
  // Read two characters at a time
  int start = result.length();
  while (count > 1) {
    if (bits.available() < 11) {
      throw FormatException.getFormatInstance();
    }
    int nextTwoCharsBits = bits.readBits(11);
    result.append(toAlphaNumericChar(nextTwoCharsBits / 45));
    result.append(toAlphaNumericChar(nextTwoCharsBits % 45));
    count -= 2;
  }
  if (count == 1) {
    // special case: one character left
    if (bits.available() < 6) {
      throw FormatException.getFormatInstance();
    }
    result.append(toAlphaNumericChar(bits.readBits(6)));
  }
  // See section 6.4.8.1, 6.4.8.2
  if (fc1InEffect) {
    // We need to massage the result a bit if in an FNC1 mode:
    for (int i = start; i < result.length(); i++) {
      if (result.charAt(i) == '%') {
        if (i < result.length() - 1 && result.charAt(i + 1) == '%') {
          // %% is rendered as %
          result.deleteCharAt(i + 1);
        } else {
          // In alpha mode, % should be converted to FNC1 separator 0x1D
          result.setCharAt(i, (char) 0x1D);
        }
      }
    }
  }
}
 

import com.google.zxing.common.BitSource; //导入方法依赖的package包/类
/**
 * See ISO 16022:2006, 5.2.7
 */
private static void decodeAnsiX12Segment(BitSource bits,
                                         StringBuilder result) throws FormatException {
  // Three ANSI X12 values are encoded in a 16-bit value as
  // (1600 * C1) + (40 * C2) + C3 + 1

  int[] cValues = new int[3];
  do {
    // If there is only one byte left then it will be encoded as ASCII
    if (bits.available() == 8) {
      return;
    }
    int firstByte = bits.readBits(8);
    if (firstByte == 254) {  // Unlatch codeword
      return;
    }

    parseTwoBytes(firstByte, bits.readBits(8), cValues);

    for (int i = 0; i < 3; i++) {
      int cValue = cValues[i];
      if (cValue == 0) {  // X12 segment terminator <CR>
        result.append('\r');
      } else if (cValue == 1) {  // X12 segment separator *
        result.append('*');
      } else if (cValue == 2) {  // X12 sub-element separator >
        result.append('>');
      } else if (cValue == 3) {  // space
        result.append(' ');
      } else if (cValue < 14) {  // 0 - 9
        result.append((char) (cValue + 44));
      } else if (cValue < 40) {  // A - Z
        result.append((char) (cValue + 51));
      } else {
        throw FormatException.getFormatInstance();
      }
    }
  } while (bits.available() > 0);
}
 

import com.google.zxing.common.BitSource; //导入方法依赖的package包/类
private static void decodeNumericSegment(BitSource bits, StringBuilder result, int count)
        throws FormatException {
    while (count >= 3) {
        if (bits.available() < 10) {
            throw FormatException.getFormatInstance();
        }
        int threeDigitsBits = bits.readBits(10);
        if (threeDigitsBits >= 1000) {
            throw FormatException.getFormatInstance();
        }
        result.append(toAlphaNumericChar(threeDigitsBits / 100));
        result.append(toAlphaNumericChar((threeDigitsBits / 10) % 10));
        result.append(toAlphaNumericChar(threeDigitsBits % 10));
        count -= 3;
    }
    if (count == 2) {
        if (bits.available() < 7) {
            throw FormatException.getFormatInstance();
        }
        int twoDigitsBits = bits.readBits(7);
        if (twoDigitsBits >= 100) {
            throw FormatException.getFormatInstance();
        }
        result.append(toAlphaNumericChar(twoDigitsBits / 10));
        result.append(toAlphaNumericChar(twoDigitsBits % 10));
    } else if (count != 1) {
    } else {
        if (bits.available() < 4) {
            throw FormatException.getFormatInstance();
        }
        int digitBits = bits.readBits(4);
        if (digitBits >= 10) {
            throw FormatException.getFormatInstance();
        }
        result.append(toAlphaNumericChar(digitBits));
    }
}
 

import com.google.zxing.common.BitSource; //导入方法依赖的package包/类
private static void decodeKanjiSegment(BitSource bits,
                                       StringBuilder result,
                                       int count) throws FormatException {
  // Don't crash trying to read more bits than we have available.
  if (count * 13 > bits.available()) {
    throw FormatException.getFormatInstance();
  }

  // Each character will require 2 bytes. Read the characters as 2-byte pairs
  // and decode as Shift_JIS afterwards
  byte[] buffer = new byte[2 * count];
  int offset = 0;
  while (count > 0) {
    // Each 13 bits encodes a 2-byte character
    int twoBytes = bits.readBits(13);
    int assembledTwoBytes = ((twoBytes / 0x0C0) << 8) | (twoBytes % 0x0C0);
    if (assembledTwoBytes < 0x01F00) {
      // In the 0x8140 to 0x9FFC range
      assembledTwoBytes += 0x08140;
    } else {
      // In the 0xE040 to 0xEBBF range
      assembledTwoBytes += 0x0C140;
    }
    buffer[offset] = (byte) (assembledTwoBytes >> 8);
    buffer[offset + 1] = (byte) assembledTwoBytes;
    offset += 2;
    count--;
  }
  // Shift_JIS may not be supported in some environments:
  try {
    result.append(new String(buffer, StringUtils.SHIFT_JIS));
  } catch (UnsupportedEncodingException ignored) {
    throw FormatException.getFormatInstance();
  }
}
 

import com.google.zxing.common.BitSource; //导入方法依赖的package包/类
/**
 * See ISO 16022:2006, 5.2.8 and Annex C Table C.3
 */
private static void decodeEdifactSegment(BitSource bits, StringBuilder result) {
  do {
    // If there is only two or less bytes left then it will be encoded as ASCII
    if (bits.available() <= 16) {
      return;
    }

    for (int i = 0; i < 4; i++) {
      int edifactValue = bits.readBits(6);

      // Check for the unlatch character
      if (edifactValue == 0x1F) {  // 011111
        // Read rest of byte, which should be 0, and stop
        int bitsLeft = 8 - bits.getBitOffset();
        if (bitsLeft != 8) {
          bits.readBits(bitsLeft);
        }
        return;
      }

      if ((edifactValue & 0x20) == 0) {  // no 1 in the leading (6th) bit
        edifactValue |= 0x40;  // Add a leading 01 to the 6 bit binary value
      }
      result.append((char) edifactValue);
    }
  } while (bits.available() > 0);
}
 

import com.google.zxing.common.BitSource; //导入方法依赖的package包/类
static DecoderResult decode(byte[] bytes,
                            Version version,
                            ErrorCorrectionLevel ecLevel,
                            Map<DecodeHintType,?> hints) throws FormatException {
  BitSource bits = new BitSource(bytes);
  StringBuilder result = new StringBuilder(50);
  List<byte[]> byteSegments = new ArrayList<>(1);
  int symbolSequence = -1;
  int parityData = -1;
  
  try {
    CharacterSetECI currentCharacterSetECI = null;
    boolean fc1InEffect = false;
    Mode mode;
    do {
      // While still another segment to read...
      if (bits.available() < 4) {
        // OK, assume we're done. Really, a TERMINATOR mode should have been recorded here
        mode = Mode.TERMINATOR;
      } else {
        mode = Mode.forBits(bits.readBits(4)); // mode is encoded by 4 bits
      }
      if (mode != Mode.TERMINATOR) {
        if (mode == Mode.FNC1_FIRST_POSITION || mode == Mode.FNC1_SECOND_POSITION) {
          // We do little with FNC1 except alter the parsed result a bit according to the spec
          fc1InEffect = true;
        } else if (mode == Mode.STRUCTURED_APPEND) {
          if (bits.available() < 16) {
            throw FormatException.getFormatInstance();
          }
          // sequence number and parity is added later to the result metadata
          // Read next 8 bits (symbol sequence #) and 8 bits (parity data), then continue
          symbolSequence = bits.readBits(8);
          parityData = bits.readBits(8);
        } else if (mode == Mode.ECI) {
          // Count doesn't apply to ECI
          int value = parseECIValue(bits);
          currentCharacterSetECI = CharacterSetECI.getCharacterSetECIByValue(value);
          if (currentCharacterSetECI == null) {
            throw FormatException.getFormatInstance();
          }
        } else {
          // First handle Hanzi mode which does not start with character count
          if (mode == Mode.HANZI) {
            //chinese mode contains a sub set indicator right after mode indicator
            int subset = bits.readBits(4);
            int countHanzi = bits.readBits(mode.getCharacterCountBits(version));
            if (subset == GB2312_SUBSET) {
              decodeHanziSegment(bits, result, countHanzi);
            }
          } else {
            // "Normal" QR code modes:
            // How many characters will follow, encoded in this mode?
            int count = bits.readBits(mode.getCharacterCountBits(version));
            if (mode == Mode.NUMERIC) {
              decodeNumericSegment(bits, result, count);
            } else if (mode == Mode.ALPHANUMERIC) {
              decodeAlphanumericSegment(bits, result, count, fc1InEffect);
            } else if (mode == Mode.BYTE) {
              decodeByteSegment(bits, result, count, currentCharacterSetECI, byteSegments, hints);
            } else if (mode == Mode.KANJI) {
              decodeKanjiSegment(bits, result, count);
            } else {
              throw FormatException.getFormatInstance();
            }
          }
        }
      }
    } while (mode != Mode.TERMINATOR);
  } catch (IllegalArgumentException iae) {
    // from readBits() calls
    throw FormatException.getFormatInstance();
  }

  return new DecoderResult(bytes,
                           result.toString(),
                           byteSegments.isEmpty() ? null : byteSegments,
                           ecLevel == null ? null : ecLevel.toString(),
                           symbolSequence,
                           parityData);
}
 

import com.google.zxing.common.BitSource; //导入方法依赖的package包/类
private static void decodeC40Segment(BitSource bits, StringBuilder result) throws
        FormatException {
    boolean upperShift = false;
    int[] cValues = new int[3];
    int shift = 0;
    while (bits.available() != 8) {
        int firstByte = bits.readBits(8);
        if (firstByte != 254) {
            parseTwoBytes(firstByte, bits.readBits(8), cValues);
            for (int i = 0; i < 3; i++) {
                int cValue = cValues[i];
                char c40char;
                switch (shift) {
                    case 0:
                        if (cValue < 3) {
                            shift = cValue + 1;
                            break;
                        } else if (cValue < C40_BASIC_SET_CHARS.length) {
                            c40char = C40_BASIC_SET_CHARS[cValue];
                            if (!upperShift) {
                                result.append(c40char);
                                break;
                            }
                            result.append((char) (c40char + 128));
                            upperShift = false;
                            break;
                        } else {
                            throw FormatException.getFormatInstance();
                        }
                    case 1:
                        if (upperShift) {
                            result.append((char) (cValue + 128));
                            upperShift = false;
                        } else {
                            result.append((char) cValue);
                        }
                        shift = 0;
                        break;
                    case 2:
                        if (cValue < C40_SHIFT2_SET_CHARS.length) {
                            c40char = C40_SHIFT2_SET_CHARS[cValue];
                            if (upperShift) {
                                result.append((char) (c40char + 128));
                                upperShift = false;
                            } else {
                                result.append(c40char);
                            }
                        } else if (cValue == 27) {
                            result.append('\u001d');
                        } else if (cValue == 30) {
                            upperShift = true;
                        } else {
                            throw FormatException.getFormatInstance();
                        }
                        shift = 0;
                        break;
                    case 3:
                        if (upperShift) {
                            result.append((char) (cValue + Opcodes.SHL_INT_LIT8));
                            upperShift = false;
                        } else {
                            result.append((char) (cValue + 96));
                        }
                        shift = 0;
                        break;
                    default:
                        throw FormatException.getFormatInstance();
                }
            }
            if (bits.available() <= 0) {
                return;
            }
        }
        return;
    }
}
 

import com.google.zxing.common.BitSource; //导入方法依赖的package包/类
private static void decodeNumericSegment(BitSource bits,
                                         StringBuilder result,
                                         int count) throws FormatException {
  // Read three digits at a time
  while (count >= 3) {
    // Each 10 bits encodes three digits
    if (bits.available() < 10) {
      throw FormatException.getFormatInstance();
    }
    int threeDigitsBits = bits.readBits(10);
    if (threeDigitsBits >= 1000) {
      throw FormatException.getFormatInstance();
    }
    result.append(toAlphaNumericChar(threeDigitsBits / 100));
    result.append(toAlphaNumericChar((threeDigitsBits / 10) % 10));
    result.append(toAlphaNumericChar(threeDigitsBits % 10));
    count -= 3;
  }
  if (count == 2) {
    // Two digits left over to read, encoded in 7 bits
    if (bits.available() < 7) {
      throw FormatException.getFormatInstance();
    }
    int twoDigitsBits = bits.readBits(7);
    if (twoDigitsBits >= 100) {
      throw FormatException.getFormatInstance();
    }
    result.append(toAlphaNumericChar(twoDigitsBits / 10));
    result.append(toAlphaNumericChar(twoDigitsBits % 10));
  } else if (count == 1) {
    // One digit left over to read
    if (bits.available() < 4) {
      throw FormatException.getFormatInstance();
    }
    int digitBits = bits.readBits(4);
    if (digitBits >= 10) {
      throw FormatException.getFormatInstance();
    }
    result.append(toAlphaNumericChar(digitBits));
  }
}