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(); }
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(); } }
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(); } }
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(); } }
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; } } }
/** * 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(); } }
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(); } }
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); }
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); } } } } }
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); }
/** * 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); }
/** * 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); }
/** * 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); } }
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++; } } }
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)); } }
private static int parseECIValue(BitSource bits) throws FormatException { int firstByte = bits.readBits(8); if ((firstByte & 128) == 0) { return firstByte & 127; } if ((firstByte & 192) == 128) { return ((firstByte & 63) << 8) | bits.readBits(8); } else if ((firstByte & Opcodes.SHL_INT_LIT8) == 192) { return ((firstByte & 31) << 16) | bits.readBits(16); } else { throw FormatException.getFormatInstance(); } }
private static void decodeAnsiX12Segment(BitSource bits, StringBuilder result) throws FormatException { int[] cValues = new int[3]; 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]; if (cValue == 0) { result.append('\r'); } else if (cValue == 1) { result.append('*'); } else if (cValue == 2) { result.append('>'); } else if (cValue == 3) { result.append(' '); } else if (cValue < 14) { result.append((char) (cValue + 44)); } else if (cValue < 40) { result.append((char) (cValue + 51)); } else { throw FormatException.getFormatInstance(); } } if (bits.available() <= 0) { return; } } return; } }
private static void decodeBase256Segment(BitSource bits, StringBuilder result, Collection<byte[]> byteSegments) throws FormatException { int count; int codewordPosition = bits.getByteOffset() + 1; int codewordPosition2 = codewordPosition + 1; int d1 = unrandomize255State(bits.readBits(8), codewordPosition); if (d1 == 0) { count = bits.available() / 8; codewordPosition = codewordPosition2; } else if (d1 < 250) { count = d1; codewordPosition = codewordPosition2; } else { codewordPosition = codewordPosition2 + 1; count = ((d1 - 249) * 250) + unrandomize255State(bits.readBits(8), codewordPosition2); } if (count < 0) { throw FormatException.getFormatInstance(); } byte[] bytes = new byte[count]; int i = 0; codewordPosition2 = codewordPosition; while (i < count) { if (bits.available() < 8) { throw FormatException.getFormatInstance(); } codewordPosition = codewordPosition2 + 1; bytes[i] = (byte) unrandomize255State(bits.readBits(8), codewordPosition2); i++; codewordPosition2 = 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); } }
