Java BitSource类代码示例

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 decodeHanziSegment(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 / 96) << 8) | (twoBytes % 96);
        if (assembledTwoBytes < 959) {
            assembledTwoBytes += 41377;
        } else {
            assembledTwoBytes += 42657;
        }
        buffer[offset] = (byte) ((assembledTwoBytes >> 8) & 255);
        buffer[offset + 1] = (byte) (assembledTwoBytes & 255);
        offset += 2;
        count--;
    }
    try {
        result.append(new String(buffer, StringUtils.GB2312));
    } catch (UnsupportedEncodingException e) {
        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包/类
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包/类
/**
 * 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 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包/类
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包/类
static DecoderResult decode(byte[] bytes) throws FormatException {
  BitSource bits = new BitSource(bytes);
  StringBuilder result = new StringBuilder(100);
  StringBuilder resultTrailer = new StringBuilder(0);
  List<byte[]> byteSegments = new ArrayList<>(1);
  Mode mode = Mode.ASCII_ENCODE;
  do {
    if (mode == Mode.ASCII_ENCODE) {
      mode = decodeAsciiSegment(bits, result, resultTrailer);
    } else {
      switch (mode) {
        case C40_ENCODE:
          decodeC40Segment(bits, result);
          break;
        case TEXT_ENCODE:
          decodeTextSegment(bits, result);
          break;
        case ANSIX12_ENCODE:
          decodeAnsiX12Segment(bits, result);
          break;
        case EDIFACT_ENCODE:
          decodeEdifactSegment(bits, result);
          break;
        case BASE256_ENCODE:
          decodeBase256Segment(bits, result, byteSegments);
          break;
        default:
          throw FormatException.getFormatInstance();
      }
      mode = Mode.ASCII_ENCODE;
    }
  } while (mode != Mode.PAD_ENCODE && bits.available() > 0);
  if (resultTrailer.length() > 0) {
    result.append(resultTrailer);
  }
  return new DecoderResult(bytes, result.toString(), byteSegments.isEmpty() ? null : byteSegments, null);
}
 

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包/类
/**
 * 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包/类
/**
 * See ISO 16022:2006, 5.2.9 and Annex B, B.2
 */
private static void decodeBase256Segment(BitSource bits,
                                         StringBuilder result,
                                         Collection<byte[]> byteSegments)
    throws FormatException {
  // Figure out how long the Base 256 Segment is.
  int codewordPosition = 1 + bits.getByteOffset(); // position is 1-indexed
  int d1 = unrandomize255State(bits.readBits(8), codewordPosition++);
  int count;
  if (d1 == 0) {  // Read the remainder of the symbol
    count = bits.available() / 8;
  } else if (d1 < 250) {
    count = d1;
  } else {
    count = 250 * (d1 - 249) + unrandomize255State(bits.readBits(8), codewordPosition++);
  }

  // We're seeing NegativeArraySizeException errors from users.
  if (count < 0) {
    throw FormatException.getFormatInstance();
  }

  byte[] bytes = new byte[count];
  for (int i = 0; i < count; i++) {
    // Have seen this particular error in the wild, such as at
    // http://www.bcgen.com/demo/IDAutomationStreamingDataMatrix.aspx?MODE=3&D=Fred&PFMT=3&PT=F&X=0.3&O=0&LM=0.2
    if (bits.available() < 8) {
      throw FormatException.getFormatInstance();
    }
    bytes[i] = (byte) unrandomize255State(bits.readBits(8), codewordPosition++);
  }
  byteSegments.add(bytes);
  try {
    result.append(new String(bytes, "ISO8859_1"));
  } catch (UnsupportedEncodingException uee) {
    throw new IllegalStateException("Platform does not support required encoding: " + uee);
  }
}
 

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 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));
    }
}