moved java files for pre-convert

src/BarcodeFormat.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+/**
+ * Enumerates barcode formats known to this package. Please keep alphabetized.
+ *
+ * @author Sean Owen
+ */
+public enum BarcodeFormat {
+
+  /** Aztec 2D barcode format. */
+  AZTEC,
+
+  /** CODABAR 1D format. */
+  CODABAR,
+
+  /** Code 39 1D format. */
+  CODE_39,
+
+  /** Code 93 1D format. */
+  CODE_93,
+
+  /** Code 128 1D format. */
+  CODE_128,
+
+  /** Data Matrix 2D barcode format. */
+  DATA_MATRIX,
+
+  /** EAN-8 1D format. */
+  EAN_8,
+
+  /** EAN-13 1D format. */
+  EAN_13,
+
+  /** ITF (Interleaved Two of Five) 1D format. */
+  ITF,
+
+  /** MaxiCode 2D barcode format. */
+  MAXICODE,
+
+  /** PDF417 format. */
+  PDF_417,
+
+  /** QR Code 2D barcode format. */
+  QR_CODE,
+
+  /** RSS 14 */
+  RSS_14,
+
+  /** RSS EXPANDED */
+  RSS_EXPANDED,
+
+  /** UPC-A 1D format. */
+  UPC_A,
+
+  /** UPC-E 1D format. */
+  UPC_E,
+
+  /** UPC/EAN extension format. Not a stand-alone format. */
+  UPC_EAN_EXTENSION
+
+}

src/Binarizer.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2009 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+import com.google.zxing.common.BitArray;
+import com.google.zxing.common.BitMatrix;
+
+/**
+ * This class hierarchy provides a set of methods to convert luminance data to 1 bit data.
+ * It allows the algorithm to vary polymorphically, for example allowing a very expensive
+ * thresholding technique for servers and a fast one for mobile. It also permits the implementation
+ * to vary, e.g. a JNI version for Android and a Java fallback version for other platforms.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+public abstract class Binarizer {
+
+  private final LuminanceSource source;
+
+  protected Binarizer(LuminanceSource source) {
+    this.source = source;
+  }
+
+  public final LuminanceSource getLuminanceSource() {
+    return source;
+  }
+
+  /**
+   * Converts one row of luminance data to 1 bit data. May actually do the conversion, or return
+   * cached data. Callers should assume this method is expensive and call it as seldom as possible.
+   * This method is intended for decoding 1D barcodes and may choose to apply sharpening.
+   * For callers which only examine one row of pixels at a time, the same BitArray should be reused
+   * and passed in with each call for performance. However it is legal to keep more than one row
+   * at a time if needed.
+   *
+   * @param y The row to fetch, which must be in [0, bitmap height)
+   * @param row An optional preallocated array. If null or too small, it will be ignored.
+   *            If used, the Binarizer will call BitArray.clear(). Always use the returned object.
+   * @return The array of bits for this row (true means black).
+   * @throws NotFoundException if row can't be binarized
+   */
+  public abstract BitArray getBlackRow(int y, BitArray row) throws NotFoundException;
+
+  /**
+   * Converts a 2D array of luminance data to 1 bit data. As above, assume this method is expensive
+   * and do not call it repeatedly. This method is intended for decoding 2D barcodes and may or
+   * may not apply sharpening. Therefore, a row from this matrix may not be identical to one
+   * fetched using getBlackRow(), so don't mix and match between them.
+   *
+   * @return The 2D array of bits for the image (true means black).
+   * @throws NotFoundException if image can't be binarized to make a matrix
+   */
+  public abstract BitMatrix getBlackMatrix() throws NotFoundException;
+
+  /**
+   * Creates a new object with the same type as this Binarizer implementation, but with pristine
+   * state. This is needed because Binarizer implementations may be stateful, e.g. keeping a cache
+   * of 1 bit data. See Effective Java for why we can't use Java's clone() method.
+   *
+   * @param source The LuminanceSource this Binarizer will operate on.
+   * @return A new concrete Binarizer implementation object.
+   */
+  public abstract Binarizer createBinarizer(LuminanceSource source);
+
+  public final int getWidth() {
+    return source.getWidth();
+  }
+
+  public final int getHeight() {
+    return source.getHeight();
+  }
+
+}

src/BinaryBitmap.java

@@ -0,0 +1,150 @@
+/*
+ * Copyright 2009 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+import com.google.zxing.common.BitArray;
+import com.google.zxing.common.BitMatrix;
+
+/**
+ * This class is the core bitmap class used by ZXing to represent 1 bit data. Reader objects
+ * accept a BinaryBitmap and attempt to decode it.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+public final class BinaryBitmap {
+
+  private final Binarizer binarizer;
+  private BitMatrix matrix;
+
+  public BinaryBitmap(Binarizer binarizer) {
+    if (binarizer == null) {
+      throw new IllegalArgumentException("Binarizer must be non-null.");
+    }
+    this.binarizer = binarizer;
+  }
+
+  /**
+   * @return The width of the bitmap.
+   */
+  public int getWidth() {
+    return binarizer.getWidth();
+  }
+
+  /**
+   * @return The height of the bitmap.
+   */
+  public int getHeight() {
+    return binarizer.getHeight();
+  }
+
+  /**
+   * Converts one row of luminance data to 1 bit data. May actually do the conversion, or return
+   * cached data. Callers should assume this method is expensive and call it as seldom as possible.
+   * This method is intended for decoding 1D barcodes and may choose to apply sharpening.
+   *
+   * @param y The row to fetch, which must be in [0, bitmap height)
+   * @param row An optional preallocated array. If null or too small, it will be ignored.
+   *            If used, the Binarizer will call BitArray.clear(). Always use the returned object.
+   * @return The array of bits for this row (true means black).
+   * @throws NotFoundException if row can't be binarized
+   */
+  public BitArray getBlackRow(int y, BitArray row) throws NotFoundException {
+    return binarizer.getBlackRow(y, row);
+  }
+
+  /**
+   * Converts a 2D array of luminance data to 1 bit. As above, assume this method is expensive
+   * and do not call it repeatedly. This method is intended for decoding 2D barcodes and may or
+   * may not apply sharpening. Therefore, a row from this matrix may not be identical to one
+   * fetched using getBlackRow(), so don't mix and match between them.
+   *
+   * @return The 2D array of bits for the image (true means black).
+   * @throws NotFoundException if image can't be binarized to make a matrix
+   */
+  public BitMatrix getBlackMatrix() throws NotFoundException {
+    // The matrix is created on demand the first time it is requested, then cached. There are two
+    // reasons for this:
+    // 1. This work will never be done if the caller only installs 1D Reader objects, or if a
+    //    1D Reader finds a barcode before the 2D Readers run.
+    // 2. This work will only be done once even if the caller installs multiple 2D Readers.
+    if (matrix == null) {
+      matrix = binarizer.getBlackMatrix();
+    }
+    return matrix;
+  }
+
+  /**
+   * @return Whether this bitmap can be cropped.
+   */
+  public boolean isCropSupported() {
+    return binarizer.getLuminanceSource().isCropSupported();
+  }
+
+  /**
+   * Returns a new object with cropped image data. Implementations may keep a reference to the
+   * original data rather than a copy. Only callable if isCropSupported() is true.
+   *
+   * @param left The left coordinate, which must be in [0,getWidth())
+   * @param top The top coordinate, which must be in [0,getHeight())
+   * @param width The width of the rectangle to crop.
+   * @param height The height of the rectangle to crop.
+   * @return A cropped version of this object.
+   */
+  public BinaryBitmap crop(int left, int top, int width, int height) {
+    LuminanceSource newSource = binarizer.getLuminanceSource().crop(left, top, width, height);
+    return new BinaryBitmap(binarizer.createBinarizer(newSource));
+  }
+
+  /**
+   * @return Whether this bitmap supports counter-clockwise rotation.
+   */
+  public boolean isRotateSupported() {
+    return binarizer.getLuminanceSource().isRotateSupported();
+  }
+
+  /**
+   * Returns a new object with rotated image data by 90 degrees counterclockwise.
+   * Only callable if {@link #isRotateSupported()} is true.
+   *
+   * @return A rotated version of this object.
+   */
+  public BinaryBitmap rotateCounterClockwise() {
+    LuminanceSource newSource = binarizer.getLuminanceSource().rotateCounterClockwise();
+    return new BinaryBitmap(binarizer.createBinarizer(newSource));
+  }
+
+  /**
+   * Returns a new object with rotated image data by 45 degrees counterclockwise.
+   * Only callable if {@link #isRotateSupported()} is true.
+   *
+   * @return A rotated version of this object.
+   */
+  public BinaryBitmap rotateCounterClockwise45() {
+    LuminanceSource newSource = binarizer.getLuminanceSource().rotateCounterClockwise45();
+    return new BinaryBitmap(binarizer.createBinarizer(newSource));
+  }
+
+  @Override
+  public String toString() {
+    try {
+      return getBlackMatrix().toString();
+    } catch (NotFoundException e) {
+      return "";
+    }
+  }
+
+}

src/ChecksumException.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+/**
+ * Thrown when a barcode was successfully detected and decoded, but
+ * was not returned because its checksum feature failed.
+ *
+ * @author Sean Owen
+ */
+public final class ChecksumException extends ReaderException {
+
+  private static final ChecksumException INSTANCE = new ChecksumException();
+  static {
+    INSTANCE.setStackTrace(NO_TRACE); // since it's meaningless
+  }
+
+  private ChecksumException() {
+    // do nothing
+  }
+
+  private ChecksumException(Throwable cause) {
+    super(cause);
+  }
+
+  public static ChecksumException getChecksumInstance() {
+    return isStackTrace ? new ChecksumException() : INSTANCE;
+  }
+
+  public static ChecksumException getChecksumInstance(Throwable cause) {
+    return isStackTrace ? new ChecksumException(cause) : INSTANCE;
+  }
+}

src/DecodeHintType.java

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+import java.util.List;
+
+/**
+ * Encapsulates a type of hint that a caller may pass to a barcode reader to help it
+ * more quickly or accurately decode it. It is up to implementations to decide what,
+ * if anything, to do with the information that is supplied.
+ *
+ * @author Sean Owen
+ * @author dswitkin@google.com (Daniel Switkin)
+ * @see Reader#decode(BinaryBitmap,java.util.Map)
+ */
+public enum DecodeHintType {
+
+  /**
+   * Unspecified, application-specific hint. Maps to an unspecified {@link Object}.
+   */
+  OTHER(Object.class),
+
+  /**
+   * Image is a pure monochrome image of a barcode. Doesn't matter what it maps to;
+   * use {@link Boolean#TRUE}.
+   */
+  PURE_BARCODE(Void.class),
+
+  /**
+   * Image is known to be of one of a few possible formats.
+   * Maps to a {@link List} of {@link BarcodeFormat}s.
+   */
+  POSSIBLE_FORMATS(List.class),
+
+  /**
+   * Spend more time to try to find a barcode; optimize for accuracy, not speed.
+   * Doesn't matter what it maps to; use {@link Boolean#TRUE}.
+   */
+  TRY_HARDER(Void.class),
+
+  /**
+   * Specifies what character encoding to use when decoding, where applicable (type String)
+   */
+  CHARACTER_SET(String.class),
+
+  /**
+   * Allowed lengths of encoded data -- reject anything else. Maps to an {@code int[]}.
+   */
+  ALLOWED_LENGTHS(int[].class),
+
+  /**
+   * Assume Code 39 codes employ a check digit. Doesn't matter what it maps to;
+   * use {@link Boolean#TRUE}.
+   */
+  ASSUME_CODE_39_CHECK_DIGIT(Void.class),
+
+  /**
+   * Assume the barcode is being processed as a GS1 barcode, and modify behavior as needed.
+   * For example this affects FNC1 handling for Code 128 (aka GS1-128). Doesn't matter what it maps to;
+   * use {@link Boolean#TRUE}.
+   */
+  ASSUME_GS1(Void.class),
+
+  /**
+   * If true, return the start and end digits in a Codabar barcode instead of stripping them. They
+   * are alpha, whereas the rest are numeric. By default, they are stripped, but this causes them
+   * to not be. Doesn't matter what it maps to; use {@link Boolean#TRUE}.
+   */
+  RETURN_CODABAR_START_END(Void.class),
+
+  /**
+   * The caller needs to be notified via callback when a possible {@link ResultPoint}
+   * is found. Maps to a {@link ResultPointCallback}.
+   */
+  NEED_RESULT_POINT_CALLBACK(ResultPointCallback.class),
+
+
+  /**
+   * Allowed extension lengths for EAN or UPC barcodes. Other formats will ignore this.
+   * Maps to an {@code int[]} of the allowed extension lengths, for example [2], [5], or [2, 5].
+   * If it is optional to have an extension, do not set this hint. If this is set,
+   * and a UPC or EAN barcode is found but an extension is not, then no result will be returned
+   * at all.
+   */
+  ALLOWED_EAN_EXTENSIONS(int[].class),
+
+  /**
+   * If true, also tries to decode as inverted image. All configured decoders are simply called a
+   * second time with an inverted image. Doesn't matter what it maps to; use {@link Boolean#TRUE}.
+   */
+  ALSO_INVERTED(Void.class),
+
+  // End of enumeration values.
+  ;
+
+  /**
+   * Data type the hint is expecting.
+   * Among the possible values the {@link Void} stands out as being used for
+   * hints that do not expect a value to be supplied (flag hints). Such hints
+   * will possibly have their value ignored, or replaced by a
+   * {@link Boolean#TRUE}. Hint suppliers should probably use
+   * {@link Boolean#TRUE} as directed by the actual hint documentation.
+   */
+  private final Class<?> valueType;
+
+  DecodeHintType(Class<?> valueType) {
+    this.valueType = valueType;
+  }
+
+  public Class<?> getValueType() {
+    return valueType;
+  }
+
+}

src/Dimension.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+/**
+ * Simply encapsulates a width and height.
+ */
+public final class Dimension {
+
+  private final int width;
+  private final int height;
+
+  public Dimension(int width, int height) {
+    if (width < 0 || height < 0) {
+      throw new IllegalArgumentException();
+    }
+    this.width = width;
+    this.height = height;
+  }
+
+  public int getWidth() {
+    return width;
+  }
+
+  public int getHeight() {
+    return height;
+  }
+
+  @Override
+  public boolean equals(Object other) {
+    if (other instanceof Dimension) {
+      Dimension d = (Dimension) other;
+      return width == d.width && height == d.height;
+    }
+    return false;
+  }
+
+  @Override
+  public int hashCode() {
+    return width * 32713 + height;
+  }
+
+  @Override
+  public String toString() {
+    return width + "x" + height;
+  }
+
+}

src/EncodeHintType.java

@@ -0,0 +1,177 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+/**
+ * These are a set of hints that you may pass to Writers to specify their behavior.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+public enum EncodeHintType {
+
+  /**
+   * Specifies what degree of error correction to use, for example in QR Codes.
+   * Type depends on the encoder. For example for QR codes it's type
+   * {@link com.google.zxing.qrcode.decoder.ErrorCorrectionLevel ErrorCorrectionLevel}.
+   * For Aztec it is of type {@link Integer}, representing the minimal percentage of error correction words.
+   * For PDF417 it is of type {@link Integer}, valid values being 0 to 8.
+   * In all cases, it can also be a {@link String} representation of the desired value as well.
+   * Note: an Aztec symbol should have a minimum of 25% EC words.
+   */
+  ERROR_CORRECTION,
+
+  /**
+   * Specifies what character encoding to use where applicable (type {@link String})
+   */
+  CHARACTER_SET,
+
+  /**
+   * Specifies the matrix shape for Data Matrix (type {@link com.google.zxing.datamatrix.encoder.SymbolShapeHint})
+   */
+  DATA_MATRIX_SHAPE,
+
+  /**
+   * Specifies whether to use compact mode for Data Matrix (type {@link Boolean}, or "true" or "false" 
+   * {@link String } value).
+   * The compact encoding mode also supports the encoding of characters that are not in the ISO-8859-1
+   * character set via ECIs.
+   * Please note that in that case, the most compact character encoding is chosen for characters in
+   * the input that are not in the ISO-8859-1 character set. Based on experience, some scanners do not
+   * support encodings like cp-1256 (Arabic). In such cases the encoding can be forced to UTF-8 by
+   * means of the {@link #CHARACTER_SET} encoding hint.
+   * Compact encoding also provides GS1-FNC1 support when {@link #GS1_FORMAT} is selected. In this case
+   * group-separator character (ASCII 29 decimal) can be used to encode the positions of FNC1 codewords
+   * for the purpose of delimiting AIs.
+   * This option and {@link #FORCE_C40} are mutually exclusive.
+   */
+  DATA_MATRIX_COMPACT,
+
+  /**
+   * Specifies a minimum barcode size (type {@link Dimension}). Only applicable to Data Matrix now.
+   *
+   * @deprecated use width/height params in
+   * {@link com.google.zxing.datamatrix.DataMatrixWriter#encode(String, BarcodeFormat, int, int)}
+   */
+  @Deprecated
+  MIN_SIZE,
+
+  /**
+   * Specifies a maximum barcode size (type {@link Dimension}). Only applicable to Data Matrix now.
+   *
+   * @deprecated without replacement
+   */
+  @Deprecated
+  MAX_SIZE,
+
+  /**
+   * Specifies margin, in pixels, to use when generating the barcode. The meaning can vary
+   * by format; for example it controls margin before and after the barcode horizontally for
+   * most 1D formats. (Type {@link Integer}, or {@link String} representation of the integer value).
+   */
+  MARGIN,
+
+  /**
+   * Specifies whether to use compact mode for PDF417 (type {@link Boolean}, or "true" or "false"
+   * {@link String} value).
+   */
+  PDF417_COMPACT,
+
+  /**
+   * Specifies what compaction mode to use for PDF417 (type
+   * {@link com.google.zxing.pdf417.encoder.Compaction Compaction} or {@link String} value of one of its
+   * enum values).
+   */
+  PDF417_COMPACTION,
+
+  /**
+   * Specifies the minimum and maximum number of rows and columns for PDF417 (type
+   * {@link com.google.zxing.pdf417.encoder.Dimensions Dimensions}).
+   */
+  PDF417_DIMENSIONS,
+
+  /**
+   * Specifies whether to automatically insert ECIs when encoding PDF417 (type {@link Boolean}, or "true" or "false"
+   * {@link String} value). 
+   * Please note that in that case, the most compact character encoding is chosen for characters in
+   * the input that are not in the ISO-8859-1 character set. Based on experience, some scanners do not
+   * support encodings like cp-1256 (Arabic). In such cases the encoding can be forced to UTF-8 by
+   * means of the {@link #CHARACTER_SET} encoding hint.
+   */
+  PDF417_AUTO_ECI,
+
+  /**
+   * Specifies the required number of layers for an Aztec code.
+   * A negative number (-1, -2, -3, -4) specifies a compact Aztec code.
+   * 0 indicates to use the minimum number of layers (the default).
+   * A positive number (1, 2, .. 32) specifies a normal (non-compact) Aztec code.
+   * (Type {@link Integer}, or {@link String} representation of the integer value).
+   */
+   AZTEC_LAYERS,
+
+   /**
+    * Specifies the exact version of QR code to be encoded.
+    * (Type {@link Integer}, or {@link String} representation of the integer value).
+    */
+   QR_VERSION,
+
+  /**
+   * Specifies the QR code mask pattern to be used. Allowed values are
+   * 0..QRCode.NUM_MASK_PATTERNS-1. By default the code will automatically select
+   * the optimal mask pattern.
+   * * (Type {@link Integer}, or {@link String} representation of the integer value).
+   */
+  QR_MASK_PATTERN,
+
+
+  /**
+   * Specifies whether to use compact mode for QR code (type {@link Boolean}, or "true" or "false"
+   * {@link String } value).
+   * Please note that when compaction is performed, the most compact character encoding is chosen
+   * for characters in the input that are not in the ISO-8859-1 character set. Based on experience,
+   * some scanners do not support encodings like cp-1256 (Arabic). In such cases the encoding can
+   * be forced to UTF-8 by means of the {@link #CHARACTER_SET} encoding hint.
+   */
+  QR_COMPACT,
+
+  /**
+   * Specifies whether the data should be encoded to the GS1 standard (type {@link Boolean}, or "true" or "false"
+   * {@link String } value).
+   */
+  GS1_FORMAT,
+
+  /**
+   * Forces which encoding will be used. Currently only used for Code-128 code sets (Type {@link String}).
+   * Valid values are "A", "B", "C".
+   * This option and {@link #CODE128_COMPACT} are mutually exclusive.
+   */
+  FORCE_CODE_SET,
+
+  /**
+   * Forces C40 encoding for data-matrix (type {@link Boolean}, or "true" or "false") {@link String } value). This 
+   * option and {@link #DATA_MATRIX_COMPACT} are mutually exclusive.
+   */
+  FORCE_C40,
+
+  /**
+   * Specifies whether to use compact mode for Code-128 code (type {@link Boolean}, or "true" or "false" 
+   * {@link String } value).
+   * This can yield slightly smaller bar codes. This option and {@link #FORCE_CODE_SET} are mutually
+   * exclusive.
+   */
+  CODE128_COMPACT,
+
+}

src/FormatException.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+/**
+ * Thrown when a barcode was successfully detected, but some aspect of
+ * the content did not conform to the barcode's format rules. This could have
+ * been due to a mis-detection.
+ *
+ * @author Sean Owen
+ */
+public final class FormatException extends ReaderException {
+
+  private static final FormatException INSTANCE = new FormatException();
+  static {
+    INSTANCE.setStackTrace(NO_TRACE); // since it's meaningless
+  }
+
+  private FormatException() {
+  }
+
+  private FormatException(Throwable cause) {
+    super(cause);
+  }
+
+  public static FormatException getFormatInstance() {
+    return isStackTrace ? new FormatException() : INSTANCE;
+  }
+
+  public static FormatException getFormatInstance(Throwable cause) {
+    return isStackTrace ? new FormatException(cause) : INSTANCE;
+  }
+}

src/InvertedLuminanceSource.java

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+/**
+ * A wrapper implementation of {@link LuminanceSource} which inverts the luminances it returns -- black becomes
+ * white and vice versa, and each value becomes (255-value).
+ *
+ * @author Sean Owen
+ */
+public final class InvertedLuminanceSource extends LuminanceSource {
+
+  private final LuminanceSource delegate;
+
+  public InvertedLuminanceSource(LuminanceSource delegate) {
+    super(delegate.getWidth(), delegate.getHeight());
+    this.delegate = delegate;
+  }
+
+  @Override
+  public byte[] getRow(int y, byte[] row) {
+    row = delegate.getRow(y, row);
+    int width = getWidth();
+    for (int i = 0; i < width; i++) {
+      row[i] = (byte) (255 - (row[i] & 0xFF));
+    }
+    return row;
+  }
+
+  @Override
+  public byte[] getMatrix() {
+    byte[] matrix = delegate.getMatrix();
+    int length = getWidth() * getHeight();
+    byte[] invertedMatrix = new byte[length];
+    for (int i = 0; i < length; i++) {
+      invertedMatrix[i] = (byte) (255 - (matrix[i] & 0xFF));
+    }
+    return invertedMatrix;
+  }
+
+  @Override
+  public boolean isCropSupported() {
+    return delegate.isCropSupported();
+  }
+
+  @Override
+  public LuminanceSource crop(int left, int top, int width, int height) {
+    return new InvertedLuminanceSource(delegate.crop(left, top, width, height));
+  }
+
+  @Override
+  public boolean isRotateSupported() {
+    return delegate.isRotateSupported();
+  }
+
+  /**
+   * @return original delegate {@link LuminanceSource} since invert undoes itself
+   */
+  @Override
+  public LuminanceSource invert() {
+    return delegate;
+  }
+
+  @Override
+  public LuminanceSource rotateCounterClockwise() {
+    return new InvertedLuminanceSource(delegate.rotateCounterClockwise());
+  }
+
+  @Override
+  public LuminanceSource rotateCounterClockwise45() {
+    return new InvertedLuminanceSource(delegate.rotateCounterClockwise45());
+  }
+
+}

src/LuminanceSource.java

@@ -0,0 +1,157 @@
+/*
+ * Copyright 2009 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+/**
+ * The purpose of this class hierarchy is to abstract different bitmap implementations across
+ * platforms into a standard interface for requesting greyscale luminance values. The interface
+ * only provides immutable methods; therefore crop and rotation create copies. This is to ensure
+ * that one Reader does not modify the original luminance source and leave it in an unknown state
+ * for other Readers in the chain.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+public abstract class LuminanceSource {
+
+  private final int width;
+  private final int height;
+
+  protected LuminanceSource(int width, int height) {
+    this.width = width;
+    this.height = height;
+  }
+
+  /**
+   * Fetches one row of luminance data from the underlying platform's bitmap. Values range from
+   * 0 (black) to 255 (white). Because Java does not have an unsigned byte type, callers will have
+   * to bitwise and with 0xff for each value. It is preferable for implementations of this method
+   * to only fetch this row rather than the whole image, since no 2D Readers may be installed and
+   * getMatrix() may never be called.
+   *
+   * @param y The row to fetch, which must be in [0,getHeight())
+   * @param row An optional preallocated array. If null or too small, it will be ignored.
+   *            Always use the returned object, and ignore the .length of the array.
+   * @return An array containing the luminance data.
+   */
+  public abstract byte[] getRow(int y, byte[] row);
+
+  /**
+   * Fetches luminance data for the underlying bitmap. Values should be fetched using:
+   * {@code int luminance = array[y * width + x] & 0xff}
+   *
+   * @return A row-major 2D array of luminance values. Do not use result.length as it may be
+   *         larger than width * height bytes on some platforms. Do not modify the contents
+   *         of the result.
+   */
+  public abstract byte[] getMatrix();
+
+  /**
+   * @return The width of the bitmap.
+   */
+  public final int getWidth() {
+    return width;
+  }
+
+  /**
+   * @return The height of the bitmap.
+   */
+  public final int getHeight() {
+    return height;
+  }
+
+  /**
+   * @return Whether this subclass supports cropping.
+   */
+  public boolean isCropSupported() {
+    return false;
+  }
+
+  /**
+   * Returns a new object with cropped image data. Implementations may keep a reference to the
+   * original data rather than a copy. Only callable if isCropSupported() is true.
+   *
+   * @param left The left coordinate, which must be in [0,getWidth())
+   * @param top The top coordinate, which must be in [0,getHeight())
+   * @param width The width of the rectangle to crop.
+   * @param height The height of the rectangle to crop.
+   * @return A cropped version of this object.
+   */
+  public LuminanceSource crop(int left, int top, int width, int height) {
+    throw new UnsupportedOperationException("This luminance source does not support cropping.");
+  }
+
+  /**
+   * @return Whether this subclass supports counter-clockwise rotation.
+   */
+  public boolean isRotateSupported() {
+    return false;
+  }
+
+  /**
+   * @return a wrapper of this {@code LuminanceSource} which inverts the luminances it returns -- black becomes
+   *  white and vice versa, and each value becomes (255-value).
+   */
+  public LuminanceSource invert() {
+    return new InvertedLuminanceSource(this);
+  }
+
+  /**
+   * Returns a new object with rotated image data by 90 degrees counterclockwise.
+   * Only callable if {@link #isRotateSupported()} is true.
+   *
+   * @return A rotated version of this object.
+   */
+  public LuminanceSource rotateCounterClockwise() {
+    throw new UnsupportedOperationException("This luminance source does not support rotation by 90 degrees.");
+  }
+
+  /**
+   * Returns a new object with rotated image data by 45 degrees counterclockwise.
+   * Only callable if {@link #isRotateSupported()} is true.
+   *
+   * @return A rotated version of this object.
+   */
+  public LuminanceSource rotateCounterClockwise45() {
+    throw new UnsupportedOperationException("This luminance source does not support rotation by 45 degrees.");
+  }
+
+  @Override
+  public final String toString() {
+    byte[] row = new byte[width];
+    StringBuilder result = new StringBuilder(height * (width + 1));
+    for (int y = 0; y < height; y++) {
+      row = getRow(y, row);
+      for (int x = 0; x < width; x++) {
+        int luminance = row[x] & 0xFF;
+        char c;
+        if (luminance < 0x40) {
+          c = '#';
+        } else if (luminance < 0x80) {
+          c = '+';
+        } else if (luminance < 0xC0) {
+          c = '.';
+        } else {
+          c = ' ';
+        }
+        result.append(c);
+      }
+      result.append('\n');
+    }
+    return result.toString();
+  }
+
+}

src/MultiFormatReader.java

@@ -0,0 +1,199 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+import com.google.zxing.aztec.AztecReader;
+import com.google.zxing.datamatrix.DataMatrixReader;
+import com.google.zxing.maxicode.MaxiCodeReader;
+import com.google.zxing.oned.MultiFormatOneDReader;
+import com.google.zxing.pdf417.PDF417Reader;
+import com.google.zxing.qrcode.QRCodeReader;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Map;
+
+/**
+ * MultiFormatReader is a convenience class and the main entry point into the library for most uses.
+ * By default it attempts to decode all barcode formats that the library supports. Optionally, you
+ * can provide a hints object to request different behavior, for example only decoding QR codes.
+ *
+ * @author Sean Owen
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+public final class MultiFormatReader implements Reader {
+
+  private static final Reader[] EMPTY_READER_ARRAY = new Reader[0];
+
+  private Map<DecodeHintType,?> hints;
+  private Reader[] readers;
+
+  /**
+   * This version of decode honors the intent of Reader.decode(BinaryBitmap) in that it
+   * passes null as a hint to the decoders. However, that makes it inefficient to call repeatedly.
+   * Use setHints() followed by decodeWithState() for continuous scan applications.
+   *
+   * @param image The pixel data to decode
+   * @return The contents of the image
+   * @throws NotFoundException Any errors which occurred
+   */
+  @Override
+  public Result decode(BinaryBitmap image) throws NotFoundException {
+    setHints(null);
+    return decodeInternal(image);
+  }
+
+  /**
+   * Decode an image using the hints provided. Does not honor existing state.
+   *
+   * @param image The pixel data to decode
+   * @param hints The hints to use, clearing the previous state.
+   * @return The contents of the image
+   * @throws NotFoundException Any errors which occurred
+   */
+  @Override
+  public Result decode(BinaryBitmap image, Map<DecodeHintType,?> hints) throws NotFoundException {
+    setHints(hints);
+    return decodeInternal(image);
+  }
+
+  /**
+   * Decode an image using the state set up by calling setHints() previously. Continuous scan
+   * clients will get a <b>large</b> speed increase by using this instead of decode().
+   *
+   * @param image The pixel data to decode
+   * @return The contents of the image
+   * @throws NotFoundException Any errors which occurred
+   */
+  public Result decodeWithState(BinaryBitmap image) throws NotFoundException {
+    // Make sure to set up the default state so we don't crash
+    if (readers == null) {
+      setHints(null);
+    }
+    return decodeInternal(image);
+  }
+
+  /**
+   * This method adds state to the MultiFormatReader. By setting the hints once, subsequent calls
+   * to decodeWithState(image) can reuse the same set of readers without reallocating memory. This
+   * is important for performance in continuous scan clients.
+   *
+   * @param hints The set of hints to use for subsequent calls to decode(image)
+   */
+  public void setHints(Map<DecodeHintType,?> hints) {
+    this.hints = hints;
+
+    boolean tryHarder = hints != null && hints.containsKey(DecodeHintType.TRY_HARDER);
+    @SuppressWarnings("unchecked")
+    Collection<BarcodeFormat> formats =
+        hints == null ? null : (Collection<BarcodeFormat>) hints.get(DecodeHintType.POSSIBLE_FORMATS);
+    Collection<Reader> readers = new ArrayList<>();
+    if (formats != null) {
+      boolean addOneDReader =
+          formats.contains(BarcodeFormat.UPC_A) ||
+          formats.contains(BarcodeFormat.UPC_E) ||
+          formats.contains(BarcodeFormat.EAN_13) ||
+          formats.contains(BarcodeFormat.EAN_8) ||
+          formats.contains(BarcodeFormat.CODABAR) ||
+          formats.contains(BarcodeFormat.CODE_39) ||
+          formats.contains(BarcodeFormat.CODE_93) ||
+          formats.contains(BarcodeFormat.CODE_128) ||
+          formats.contains(BarcodeFormat.ITF) ||
+          formats.contains(BarcodeFormat.RSS_14) ||
+          formats.contains(BarcodeFormat.RSS_EXPANDED);
+      // Put 1D readers upfront in "normal" mode
+      if (addOneDReader && !tryHarder) {
+        readers.add(new MultiFormatOneDReader(hints));
+      }
+      if (formats.contains(BarcodeFormat.QR_CODE)) {
+        readers.add(new QRCodeReader());
+      }
+      if (formats.contains(BarcodeFormat.DATA_MATRIX)) {
+        readers.add(new DataMatrixReader());
+      }
+      if (formats.contains(BarcodeFormat.AZTEC)) {
+        readers.add(new AztecReader());
+      }
+      if (formats.contains(BarcodeFormat.PDF_417)) {
+        readers.add(new PDF417Reader());
+      }
+      if (formats.contains(BarcodeFormat.MAXICODE)) {
+        readers.add(new MaxiCodeReader());
+      }
+      // At end in "try harder" mode
+      if (addOneDReader && tryHarder) {
+        readers.add(new MultiFormatOneDReader(hints));
+      }
+    }
+    if (readers.isEmpty()) {
+      if (!tryHarder) {
+        readers.add(new MultiFormatOneDReader(hints));
+      }
+
+      readers.add(new QRCodeReader());
+      readers.add(new DataMatrixReader());
+      readers.add(new AztecReader());
+      readers.add(new PDF417Reader());
+      readers.add(new MaxiCodeReader());
+
+      if (tryHarder) {
+        readers.add(new MultiFormatOneDReader(hints));
+      }
+    }
+    this.readers = readers.toArray(EMPTY_READER_ARRAY);
+  }
+
+  @Override
+  public void reset() {
+    if (readers != null) {
+      for (Reader reader : readers) {
+        reader.reset();
+      }
+    }
+  }
+
+  private Result decodeInternal(BinaryBitmap image) throws NotFoundException {
+    if (readers != null) {
+      for (Reader reader : readers) {
+        if (Thread.currentThread().isInterrupted()) {
+          throw NotFoundException.getNotFoundInstance();
+        }
+        try {
+          return reader.decode(image, hints);
+        } catch (ReaderException re) {
+          // continue
+        }
+      }
+      if (hints != null && hints.containsKey(DecodeHintType.ALSO_INVERTED)) {
+        // Calling all readers again with inverted image
+        image.getBlackMatrix().flip();
+        for (Reader reader : readers) {
+          if (Thread.currentThread().isInterrupted()) {
+            throw NotFoundException.getNotFoundInstance();
+          }
+          try {
+            return reader.decode(image, hints);
+          } catch (ReaderException re) {
+            // continue
+          }
+        }
+      }
+    }
+    throw NotFoundException.getNotFoundInstance();
+  }
+
+}

src/MultiFormatWriter.java

@@ -0,0 +1,105 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+import com.google.zxing.aztec.AztecWriter;
+import com.google.zxing.common.BitMatrix;
+import com.google.zxing.datamatrix.DataMatrixWriter;
+import com.google.zxing.oned.CodaBarWriter;
+import com.google.zxing.oned.Code128Writer;
+import com.google.zxing.oned.Code39Writer;
+import com.google.zxing.oned.Code93Writer;
+import com.google.zxing.oned.EAN13Writer;
+import com.google.zxing.oned.EAN8Writer;
+import com.google.zxing.oned.ITFWriter;
+import com.google.zxing.oned.UPCAWriter;
+import com.google.zxing.oned.UPCEWriter;
+import com.google.zxing.pdf417.PDF417Writer;
+import com.google.zxing.qrcode.QRCodeWriter;
+
+import java.util.Map;
+
+/**
+ * This is a factory class which finds the appropriate Writer subclass for the BarcodeFormat
+ * requested and encodes the barcode with the supplied contents.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+public final class MultiFormatWriter implements Writer {
+
+  @Override
+  public BitMatrix encode(String contents,
+                          BarcodeFormat format,
+                          int width,
+                          int height) throws WriterException {
+    return encode(contents, format, width, height, null);
+  }
+
+  @Override
+  public BitMatrix encode(String contents,
+                          BarcodeFormat format,
+                          int width, int height,
+                          Map<EncodeHintType,?> hints) throws WriterException {
+
+    Writer writer;
+    switch (format) {
+      case EAN_8:
+        writer = new EAN8Writer();
+        break;
+      case UPC_E:
+        writer = new UPCEWriter();
+        break;
+      case EAN_13:
+        writer = new EAN13Writer();
+        break;
+      case UPC_A:
+        writer = new UPCAWriter();
+        break;
+      case QR_CODE:
+        writer = new QRCodeWriter();
+        break;
+      case CODE_39:
+        writer = new Code39Writer();
+        break;
+      case CODE_93:
+        writer = new Code93Writer();
+        break;
+      case CODE_128:
+        writer = new Code128Writer();
+        break;
+      case ITF:
+        writer = new ITFWriter();
+        break;
+      case PDF_417:
+        writer = new PDF417Writer();
+        break;
+      case CODABAR:
+        writer = new CodaBarWriter();
+        break;
+      case DATA_MATRIX:
+        writer = new DataMatrixWriter();
+        break;
+      case AZTEC:
+        writer = new AztecWriter();
+        break;
+      default:
+        throw new IllegalArgumentException("No encoder available for format " + format);
+    }
+    return writer.encode(contents, format, width, height, hints);
+  }
+
+}

src/NotFoundException.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+/**
+ * Thrown when a barcode was not found in the image. It might have been
+ * partially detected but could not be confirmed.
+ *
+ * @author Sean Owen
+ */
+public final class NotFoundException extends ReaderException {
+
+  private static final NotFoundException INSTANCE = new NotFoundException();
+  static {
+    INSTANCE.setStackTrace(NO_TRACE); // since it's meaningless
+  }
+
+  private NotFoundException() {
+    // do nothing
+  }
+
+  public static NotFoundException getNotFoundInstance() {
+    return isStackTrace ? new NotFoundException() : INSTANCE;
+  }
+
+}

src/PlanarYUVLuminanceSource.java

@@ -0,0 +1,168 @@
+/*
+ * Copyright 2009 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+/**
+ * This object extends LuminanceSource around an array of YUV data returned from the camera driver,
+ * with the option to crop to a rectangle within the full data. This can be used to exclude
+ * superfluous pixels around the perimeter and speed up decoding.
+ *
+ * It works for any pixel format where the Y channel is planar and appears first, including
+ * YCbCr_420_SP and YCbCr_422_SP.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+public final class PlanarYUVLuminanceSource extends LuminanceSource {
+
+  private static final int THUMBNAIL_SCALE_FACTOR = 2;
+
+  private final byte[] yuvData;
+  private final int dataWidth;
+  private final int dataHeight;
+  private final int left;
+  private final int top;
+
+  public PlanarYUVLuminanceSource(byte[] yuvData,
+                                  int dataWidth,
+                                  int dataHeight,
+                                  int left,
+                                  int top,
+                                  int width,
+                                  int height,
+                                  boolean reverseHorizontal) {
+    super(width, height);
+
+    if (left + width > dataWidth || top + height > dataHeight) {
+      throw new IllegalArgumentException("Crop rectangle does not fit within image data.");
+    }
+
+    this.yuvData = yuvData;
+    this.dataWidth = dataWidth;
+    this.dataHeight = dataHeight;
+    this.left = left;
+    this.top = top;
+    if (reverseHorizontal) {
+      reverseHorizontal(width, height);
+    }
+  }
+
+  @Override
+  public byte[] getRow(int y, byte[] row) {
+    if (y < 0 || y >= getHeight()) {
+      throw new IllegalArgumentException("Requested row is outside the image: " + y);
+    }
+    int width = getWidth();
+    if (row == null || row.length < width) {
+      row = new byte[width];
+    }
+    int offset = (y + top) * dataWidth + left;
+    System.arraycopy(yuvData, offset, row, 0, width);
+    return row;
+  }
+
+  @Override
+  public byte[] getMatrix() {
+    int width = getWidth();
+    int height = getHeight();
+
+    // If the caller asks for the entire underlying image, save the copy and give them the
+    // original data. The docs specifically warn that result.length must be ignored.
+    if (width == dataWidth && height == dataHeight) {
+      return yuvData;
+    }
+
+    int area = width * height;
+    byte[] matrix = new byte[area];
+    int inputOffset = top * dataWidth + left;
+
+    // If the width matches the full width of the underlying data, perform a single copy.
+    if (width == dataWidth) {
+      System.arraycopy(yuvData, inputOffset, matrix, 0, area);
+      return matrix;
+    }
+
+    // Otherwise copy one cropped row at a time.
+    for (int y = 0; y < height; y++) {
+      int outputOffset = y * width;
+      System.arraycopy(yuvData, inputOffset, matrix, outputOffset, width);
+      inputOffset += dataWidth;
+    }
+    return matrix;
+  }
+
+  @Override
+  public boolean isCropSupported() {
+    return true;
+  }
+
+  @Override
+  public LuminanceSource crop(int left, int top, int width, int height) {
+    return new PlanarYUVLuminanceSource(yuvData,
+                                        dataWidth,
+                                        dataHeight,
+                                        this.left + left,
+                                        this.top + top,
+                                        width,
+                                        height,
+                                        false);
+  }
+
+  public int[] renderThumbnail() {
+    int width = getWidth() / THUMBNAIL_SCALE_FACTOR;
+    int height = getHeight() / THUMBNAIL_SCALE_FACTOR;
+    int[] pixels = new int[width * height];
+    byte[] yuv = yuvData;
+    int inputOffset = top * dataWidth + left;
+
+    for (int y = 0; y < height; y++) {
+      int outputOffset = y * width;
+      for (int x = 0; x < width; x++) {
+        int grey = yuv[inputOffset + x * THUMBNAIL_SCALE_FACTOR] & 0xff;
+        pixels[outputOffset + x] = 0xFF000000 | (grey * 0x00010101);
+      }
+      inputOffset += dataWidth * THUMBNAIL_SCALE_FACTOR;
+    }
+    return pixels;
+  }
+
+  /**
+   * @return width of image from {@link #renderThumbnail()}
+   */
+  public int getThumbnailWidth() {
+    return getWidth() / THUMBNAIL_SCALE_FACTOR;
+  }
+
+  /**
+   * @return height of image from {@link #renderThumbnail()}
+   */
+  public int getThumbnailHeight() {
+    return getHeight() / THUMBNAIL_SCALE_FACTOR;
+  }
+
+  private void reverseHorizontal(int width, int height) {
+    byte[] yuvData = this.yuvData;
+    for (int y = 0, rowStart = top * dataWidth + left; y < height; y++, rowStart += dataWidth) {
+      int middle = rowStart + width / 2;
+      for (int x1 = rowStart, x2 = rowStart + width - 1; x1 < middle; x1++, x2--) {
+        byte temp = yuvData[x1];
+        yuvData[x1] = yuvData[x2];
+        yuvData[x2] = temp;
+      }
+    }
+  }
+
+}

src/RGBLuminanceSource.java

@@ -0,0 +1,136 @@
+/*
+ * Copyright 2009 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+/**
+ * This class is used to help decode images from files which arrive as RGB data from
+ * an ARGB pixel array. It does not support rotation.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ * @author Betaminos
+ */
+public final class RGBLuminanceSource extends LuminanceSource {
+
+  private final byte[] luminances;
+  private final int dataWidth;
+  private final int dataHeight;
+  private final int left;
+  private final int top;
+
+  public RGBLuminanceSource(int width, int height, int[] pixels) {
+    super(width, height);
+
+    dataWidth = width;
+    dataHeight = height;
+    left = 0;
+    top = 0;
+
+    // In order to measure pure decoding speed, we convert the entire image to a greyscale array
+    // up front, which is the same as the Y channel of the YUVLuminanceSource in the real app.
+    //
+    // Total number of pixels suffices, can ignore shape
+    int size = width * height;
+    luminances = new byte[size];
+    for (int offset = 0; offset < size; offset++) {
+      int pixel = pixels[offset];
+      int r = (pixel >> 16) & 0xff; // red
+      int g2 = (pixel >> 7) & 0x1fe; // 2 * green
+      int b = pixel & 0xff; // blue
+      // Calculate green-favouring average cheaply
+      luminances[offset] = (byte) ((r + g2 + b) / 4);
+    }
+  }
+
+  private RGBLuminanceSource(byte[] pixels,
+                             int dataWidth,
+                             int dataHeight,
+                             int left,
+                             int top,
+                             int width,
+                             int height) {
+    super(width, height);
+    if (left + width > dataWidth || top + height > dataHeight) {
+      throw new IllegalArgumentException("Crop rectangle does not fit within image data.");
+    }
+    this.luminances = pixels;
+    this.dataWidth = dataWidth;
+    this.dataHeight = dataHeight;
+    this.left = left;
+    this.top = top;
+  }
+
+  @Override
+  public byte[] getRow(int y, byte[] row) {
+    if (y < 0 || y >= getHeight()) {
+      throw new IllegalArgumentException("Requested row is outside the image: " + y);
+    }
+    int width = getWidth();
+    if (row == null || row.length < width) {
+      row = new byte[width];
+    }
+    int offset = (y + top) * dataWidth + left;
+    System.arraycopy(luminances, offset, row, 0, width);
+    return row;
+  }
+
+  @Override
+  public byte[] getMatrix() {
+    int width = getWidth();
+    int height = getHeight();
+
+    // If the caller asks for the entire underlying image, save the copy and give them the
+    // original data. The docs specifically warn that result.length must be ignored.
+    if (width == dataWidth && height == dataHeight) {
+      return luminances;
+    }
+
+    int area = width * height;
+    byte[] matrix = new byte[area];
+    int inputOffset = top * dataWidth + left;
+
+    // If the width matches the full width of the underlying data, perform a single copy.
+    if (width == dataWidth) {
+      System.arraycopy(luminances, inputOffset, matrix, 0, area);
+      return matrix;
+    }
+
+    // Otherwise copy one cropped row at a time.
+    for (int y = 0; y < height; y++) {
+      int outputOffset = y * width;
+      System.arraycopy(luminances, inputOffset, matrix, outputOffset, width);
+      inputOffset += dataWidth;
+    }
+    return matrix;
+  }
+
+  @Override
+  public boolean isCropSupported() {
+    return true;
+  }
+
+  @Override
+  public LuminanceSource crop(int left, int top, int width, int height) {
+    return new RGBLuminanceSource(luminances,
+                                  dataWidth,
+                                  dataHeight,
+                                  this.left + left,
+                                  this.top + top,
+                                  width,
+                                  height);
+  }
+
+}

src/Reader.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+import java.util.Map;
+
+/**
+ * Implementations of this interface can decode an image of a barcode in some format into
+ * the String it encodes. For example, {@link com.google.zxing.qrcode.QRCodeReader} can
+ * decode a QR code. The decoder may optionally receive hints from the caller which may help
+ * it decode more quickly or accurately.
+ *
+ * See {@link MultiFormatReader}, which attempts to determine what barcode
+ * format is present within the image as well, and then decodes it accordingly.
+ *
+ * @author Sean Owen
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+public interface Reader {
+
+  /**
+   * Locates and decodes a barcode in some format within an image.
+   *
+   * @param image image of barcode to decode
+   * @return String which the barcode encodes
+   * @throws NotFoundException if no potential barcode is found
+   * @throws ChecksumException if a potential barcode is found but does not pass its checksum
+   * @throws FormatException if a potential barcode is found but format is invalid
+   */
+  Result decode(BinaryBitmap image) throws NotFoundException, ChecksumException, FormatException;
+
+  /**
+   * Locates and decodes a barcode in some format within an image. This method also accepts
+   * hints, each possibly associated to some data, which may help the implementation decode.
+   *
+   * @param image image of barcode to decode
+   * @param hints passed as a {@link Map} from {@link DecodeHintType}
+   * to arbitrary data. The
+   * meaning of the data depends upon the hint type. The implementation may or may not do
+   * anything with these hints.
+   * @return String which the barcode encodes
+   * @throws NotFoundException if no potential barcode is found
+   * @throws ChecksumException if a potential barcode is found but does not pass its checksum
+   * @throws FormatException if a potential barcode is found but format is invalid
+   */
+  Result decode(BinaryBitmap image, Map<DecodeHintType,?> hints)
+      throws NotFoundException, ChecksumException, FormatException;
+
+  /**
+   * Resets any internal state the implementation has after a decode, to prepare it
+   * for reuse.
+   */
+  void reset();
+
+}

src/ReaderException.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+/**
+ * The general exception class throw when something goes wrong during decoding of a barcode.
+ * This includes, but is not limited to, failing checksums / error correction algorithms, being
+ * unable to locate finder timing patterns, and so on.
+ *
+ * @author Sean Owen
+ */
+public abstract class ReaderException extends Exception {
+
+  // disable stack traces when not running inside test units
+  protected static boolean isStackTrace =
+      System.getProperty("surefire.test.class.path") != null;
+  protected static final StackTraceElement[] NO_TRACE = new StackTraceElement[0];
+
+  ReaderException() {
+    // do nothing
+  }
+
+  ReaderException(Throwable cause) {
+    super(cause);
+  }
+
+  // Prevent stack traces from being taken
+  @Override
+  public final synchronized Throwable fillInStackTrace() {
+    return null;
+  }
+
+  /**
+   * For testing only. Controls whether library exception classes include stack traces or not.
+   * Defaults to false, unless running in the project's unit testing harness.
+   *
+   * @param enabled if true, enables stack traces in library exception classes
+   * @since 3.5.0
+   */
+  public static void setStackTrace(boolean enabled) {
+    isStackTrace = enabled;
+  }
+
+}

src/Result.java

@@ -0,0 +1,153 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+import java.util.EnumMap;
+import java.util.Map;
+
+/**
+ * <p>Encapsulates the result of decoding a barcode within an image.</p>
+ *
+ * @author Sean Owen
+ */
+public final class Result {
+
+  private final String text;
+  private final byte[] rawBytes;
+  private final int numBits;
+  private ResultPoint[] resultPoints;
+  private final BarcodeFormat format;
+  private Map<ResultMetadataType,Object> resultMetadata;
+  private final long timestamp;
+
+  public Result(String text,
+                byte[] rawBytes,
+                ResultPoint[] resultPoints,
+                BarcodeFormat format) {
+    this(text, rawBytes, resultPoints, format, System.currentTimeMillis());
+  }
+
+  public Result(String text,
+                byte[] rawBytes,
+                ResultPoint[] resultPoints,
+                BarcodeFormat format,
+                long timestamp) {
+    this(text, rawBytes, rawBytes == null ? 0 : 8 * rawBytes.length,
+         resultPoints, format, timestamp);
+  }
+
+  public Result(String text,
+                byte[] rawBytes,
+                int numBits,
+                ResultPoint[] resultPoints,
+                BarcodeFormat format,
+                long timestamp) {
+    this.text = text;
+    this.rawBytes = rawBytes;
+    this.numBits = numBits;
+    this.resultPoints = resultPoints;
+    this.format = format;
+    this.resultMetadata = null;
+    this.timestamp = timestamp;
+  }
+
+  /**
+   * @return raw text encoded by the barcode
+   */
+  public String getText() {
+    return text;
+  }
+
+  /**
+   * @return raw bytes encoded by the barcode, if applicable, otherwise {@code null}
+   */
+  public byte[] getRawBytes() {
+    return rawBytes;
+  }
+
+  /**
+   * @return how many bits of {@link #getRawBytes()} are valid; typically 8 times its length
+   * @since 3.3.0
+   */
+  public int getNumBits() {
+    return numBits;
+  }
+
+  /**
+   * @return points related to the barcode in the image. These are typically points
+   *         identifying finder patterns or the corners of the barcode. The exact meaning is
+   *         specific to the type of barcode that was decoded.
+   */
+  public ResultPoint[] getResultPoints() {
+    return resultPoints;
+  }
+
+  /**
+   * @return {@link BarcodeFormat} representing the format of the barcode that was decoded
+   */
+  public BarcodeFormat getBarcodeFormat() {
+    return format;
+  }
+
+  /**
+   * @return {@link Map} mapping {@link ResultMetadataType} keys to values. May be
+   *   {@code null}. This contains optional metadata about what was detected about the barcode,
+   *   like orientation.
+   */
+  public Map<ResultMetadataType,Object> getResultMetadata() {
+    return resultMetadata;
+  }
+
+  public void putMetadata(ResultMetadataType type, Object value) {
+    if (resultMetadata == null) {
+      resultMetadata = new EnumMap<>(ResultMetadataType.class);
+    }
+    resultMetadata.put(type, value);
+  }
+
+  public void putAllMetadata(Map<ResultMetadataType,Object> metadata) {
+    if (metadata != null) {
+      if (resultMetadata == null) {
+        resultMetadata = metadata;
+      } else {
+        resultMetadata.putAll(metadata);
+      }
+    }
+  }
+
+  public void addResultPoints(ResultPoint[] newPoints) {
+    ResultPoint[] oldPoints = resultPoints;
+    if (oldPoints == null) {
+      resultPoints = newPoints;
+    } else if (newPoints != null && newPoints.length > 0) {
+      ResultPoint[] allPoints = new ResultPoint[oldPoints.length + newPoints.length];
+      System.arraycopy(oldPoints, 0, allPoints, 0, oldPoints.length);
+      System.arraycopy(newPoints, 0, allPoints, oldPoints.length, newPoints.length);
+      resultPoints = allPoints;
+    }
+  }
+
+  public long getTimestamp() {
+    return timestamp;
+  }
+
+  @Override
+  public String toString() {
+    return text;
+  }
+
+}

src/ResultMetadataType.java

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+/**
+ * Represents some type of metadata about the result of the decoding that the decoder
+ * wishes to communicate back to the caller.
+ *
+ * @author Sean Owen
+ */
+public enum ResultMetadataType {
+
+  /**
+   * Unspecified, application-specific metadata. Maps to an unspecified {@link Object}.
+   */
+  OTHER,
+
+  /**
+   * Denotes the likely approximate orientation of the barcode in the image. This value
+   * is given as degrees rotated clockwise from the normal, upright orientation.
+   * For example a 1D barcode which was found by reading top-to-bottom would be
+   * said to have orientation "90". This key maps to an {@link Integer} whose
+   * value is in the range [0,360).
+   */
+  ORIENTATION,
+
+  /**
+   * <p>2D barcode formats typically encode text, but allow for a sort of 'byte mode'
+   * which is sometimes used to encode binary data. While {@link Result} makes available
+   * the complete raw bytes in the barcode for these formats, it does not offer the bytes
+   * from the byte segments alone.</p>
+   *
+   * <p>This maps to a {@link java.util.List} of byte arrays corresponding to the
+   * raw bytes in the byte segments in the barcode, in order.</p>
+   */
+  BYTE_SEGMENTS,
+
+  /**
+   * Error correction level used, if applicable. The value type depends on the
+   * format, but is typically a String.
+   */
+  ERROR_CORRECTION_LEVEL,
+
+  /**
+   * For some periodicals, indicates the issue number as an {@link Integer}.
+   */
+  ISSUE_NUMBER,
+
+  /**
+   * For some products, indicates the suggested retail price in the barcode as a
+   * formatted {@link String}.
+   */
+  SUGGESTED_PRICE,
+
+  /**
+   * For some products, the possible country of manufacture as a {@link String} denoting the
+   * ISO country code. Some map to multiple possible countries, like "US/CA".
+   */
+  POSSIBLE_COUNTRY,
+
+  /**
+   * For some products, the extension text
+   */
+  UPC_EAN_EXTENSION,
+
+  /**
+   * PDF417-specific metadata
+   */
+  PDF417_EXTRA_METADATA,
+
+  /**
+   * If the code format supports structured append and the current scanned code is part of one then the
+   * sequence number is given with it.
+   */
+  STRUCTURED_APPEND_SEQUENCE,
+
+  /**
+   * If the code format supports structured append and the current scanned code is part of one then the
+   * parity is given with it.
+   */
+  STRUCTURED_APPEND_PARITY,
+
+  /**
+   * Barcode Symbology Identifier.
+   * Note: According to the GS1 specification the identifier may have to replace a leading FNC1/GS character
+   * when prepending to the barcode content.
+   */
+  SYMBOLOGY_IDENTIFIER,
+}

src/ResultPoint.java

@@ -0,0 +1,130 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+import com.google.zxing.common.detector.MathUtils;
+
+/**
+ * <p>Encapsulates a point of interest in an image containing a barcode. Typically, this
+ * would be the location of a finder pattern or the corner of the barcode, for example.</p>
+ *
+ * @author Sean Owen
+ */
+public class ResultPoint {
+
+  private final float x;
+  private final float y;
+
+  public ResultPoint(float x, float y) {
+    this.x = x;
+    this.y = y;
+  }
+
+  public final float getX() {
+    return x;
+  }
+
+  public final float getY() {
+    return y;
+  }
+
+  @Override
+  public final boolean equals(Object other) {
+    if (other instanceof ResultPoint) {
+      ResultPoint otherPoint = (ResultPoint) other;
+      return x == otherPoint.x && y == otherPoint.y;
+    }
+    return false;
+  }
+
+  @Override
+  public final int hashCode() {
+    return 31 * Float.floatToIntBits(x) + Float.floatToIntBits(y);
+  }
+
+  @Override
+  public final String toString() {
+    return "(" + x + ',' + y + ')';
+  }
+
+  /**
+   * Orders an array of three ResultPoints in an order [A,B,C] such that AB is less than AC
+   * and BC is less than AC, and the angle between BC and BA is less than 180 degrees.
+   *
+   * @param patterns array of three {@code ResultPoint} to order
+   */
+  public static void orderBestPatterns(ResultPoint[] patterns) {
+
+    // Find distances between pattern centers
+    float zeroOneDistance = distance(patterns[0], patterns[1]);
+    float oneTwoDistance = distance(patterns[1], patterns[2]);
+    float zeroTwoDistance = distance(patterns[0], patterns[2]);
+
+    ResultPoint pointA;
+    ResultPoint pointB;
+    ResultPoint pointC;
+    // Assume one closest to other two is B; A and C will just be guesses at first
+    if (oneTwoDistance >= zeroOneDistance && oneTwoDistance >= zeroTwoDistance) {
+      pointB = patterns[0];
+      pointA = patterns[1];
+      pointC = patterns[2];
+    } else if (zeroTwoDistance >= oneTwoDistance && zeroTwoDistance >= zeroOneDistance) {
+      pointB = patterns[1];
+      pointA = patterns[0];
+      pointC = patterns[2];
+    } else {
+      pointB = patterns[2];
+      pointA = patterns[0];
+      pointC = patterns[1];
+    }
+
+    // Use cross product to figure out whether A and C are correct or flipped.
+    // This asks whether BC x BA has a positive z component, which is the arrangement
+    // we want for A, B, C. If it's negative, then we've got it flipped around and
+    // should swap A and C.
+    if (crossProductZ(pointA, pointB, pointC) < 0.0f) {
+      ResultPoint temp = pointA;
+      pointA = pointC;
+      pointC = temp;
+    }
+
+    patterns[0] = pointA;
+    patterns[1] = pointB;
+    patterns[2] = pointC;
+  }
+
+  /**
+   * @param pattern1 first pattern
+   * @param pattern2 second pattern
+   * @return distance between two points
+   */
+  public static float distance(ResultPoint pattern1, ResultPoint pattern2) {
+    return MathUtils.distance(pattern1.x, pattern1.y, pattern2.x, pattern2.y);
+  }
+
+  /**
+   * Returns the z component of the cross product between vectors BC and BA.
+   */
+  private static float crossProductZ(ResultPoint pointA,
+                                     ResultPoint pointB,
+                                     ResultPoint pointC) {
+    float bX = pointB.x;
+    float bY = pointB.y;
+    return ((pointC.x - bX) * (pointA.y - bY)) - ((pointC.y - bY) * (pointA.x - bX));
+  }
+
+}

src/ResultPointCallback.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2009 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+/**
+ * Callback which is invoked when a possible result point (significant
+ * point in the barcode image such as a corner) is found.
+ *
+ * @see DecodeHintType#NEED_RESULT_POINT_CALLBACK
+ */
+public interface ResultPointCallback {
+
+  void foundPossibleResultPoint(ResultPoint point);
+
+}

src/Writer.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+import com.google.zxing.common.BitMatrix;
+
+import java.util.Map;
+
+/**
+ * The base class for all objects which encode/generate a barcode image.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+public interface Writer {
+
+  /**
+   * Encode a barcode using the default settings.
+   *
+   * @param contents The contents to encode in the barcode
+   * @param format The barcode format to generate
+   * @param width The preferred width in pixels
+   * @param height The preferred height in pixels
+   * @return {@link BitMatrix} representing encoded barcode image
+   * @throws WriterException if contents cannot be encoded legally in a format
+   */
+  BitMatrix encode(String contents, BarcodeFormat format, int width, int height)
+      throws WriterException;
+
+  /**
+   * @param contents The contents to encode in the barcode
+   * @param format The barcode format to generate
+   * @param width The preferred width in pixels
+   * @param height The preferred height in pixels
+   * @param hints Additional parameters to supply to the encoder
+   * @return {@link BitMatrix} representing encoded barcode image
+   * @throws WriterException if contents cannot be encoded legally in a format
+   */
+  BitMatrix encode(String contents,
+                   BarcodeFormat format,
+                   int width,
+                   int height,
+                   Map<EncodeHintType,?> hints)
+      throws WriterException;
+
+}

src/WriterException.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing;
+
+/**
+ * A base class which covers the range of exceptions which may occur when encoding a barcode using
+ * the Writer framework.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+public final class WriterException extends Exception {
+
+  public WriterException() {
+  }
+
+  public WriterException(String message) {
+    super(message);
+  }
+ 
+  public WriterException(Throwable cause) {
+    super(cause);
+  }
+
+}

src/aztec/AztecDetectorResult.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.aztec;
+
+import com.google.zxing.ResultPoint;
+import com.google.zxing.common.BitMatrix;
+import com.google.zxing.common.DetectorResult;
+
+/**
+ * <p>Extends {@link DetectorResult} with more information specific to the Aztec format,
+ * like the number of layers and whether it's compact.</p>
+ *
+ * @author Sean Owen
+ */
+public final class AztecDetectorResult extends DetectorResult {
+
+  private final boolean compact;
+  private final int nbDatablocks;
+  private final int nbLayers;
+
+  public AztecDetectorResult(BitMatrix bits,
+                             ResultPoint[] points,
+                             boolean compact,
+                             int nbDatablocks,
+                             int nbLayers) {
+    super(bits, points);
+    this.compact = compact;
+    this.nbDatablocks = nbDatablocks;
+    this.nbLayers = nbLayers;
+  }
+
+  public int getNbLayers() {
+    return nbLayers;
+  }
+
+  public int getNbDatablocks() {
+    return nbDatablocks;
+  }
+
+  public boolean isCompact() {
+    return compact;
+  }
+
+}

src/aztec/AztecReader.java

@@ -0,0 +1,123 @@
+/*
+ * Copyright 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.aztec;
+
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.BinaryBitmap;
+import com.google.zxing.DecodeHintType;
+import com.google.zxing.FormatException;
+import com.google.zxing.NotFoundException;
+import com.google.zxing.Reader;
+import com.google.zxing.Result;
+import com.google.zxing.ResultMetadataType;
+import com.google.zxing.ResultPoint;
+import com.google.zxing.ResultPointCallback;
+import com.google.zxing.aztec.decoder.Decoder;
+import com.google.zxing.aztec.detector.Detector;
+import com.google.zxing.common.DecoderResult;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * This implementation can detect and decode Aztec codes in an image.
+ *
+ * @author David Olivier
+ */
+public final class AztecReader implements Reader {
+
+  /**
+   * Locates and decodes a Data Matrix code in an image.
+   *
+   * @return a String representing the content encoded by the Data Matrix code
+   * @throws NotFoundException if a Data Matrix code cannot be found
+   * @throws FormatException if a Data Matrix code cannot be decoded
+   */
+  @Override
+  public Result decode(BinaryBitmap image) throws NotFoundException, FormatException {
+    return decode(image, null);
+  }
+
+  @Override
+  public Result decode(BinaryBitmap image, Map<DecodeHintType,?> hints)
+      throws NotFoundException, FormatException {
+
+    NotFoundException notFoundException = null;
+    FormatException formatException = null;
+    Detector detector = new Detector(image.getBlackMatrix());
+    ResultPoint[] points = null;
+    DecoderResult decoderResult = null;
+    try {
+      AztecDetectorResult detectorResult = detector.detect(false);
+      points = detectorResult.getPoints();
+      decoderResult = new Decoder().decode(detectorResult);
+    } catch (NotFoundException e) {
+      notFoundException = e;
+    } catch (FormatException e) {
+      formatException = e;
+    }
+    if (decoderResult == null) {
+      try {
+        AztecDetectorResult detectorResult = detector.detect(true);
+        points = detectorResult.getPoints();
+        decoderResult = new Decoder().decode(detectorResult);
+      } catch (NotFoundException | FormatException e) {
+        if (notFoundException != null) {
+          throw notFoundException;
+        }
+        if (formatException != null) {
+          throw formatException;
+        }
+        throw e;
+      }
+    }
+
+    if (hints != null) {
+      ResultPointCallback rpcb = (ResultPointCallback) hints.get(DecodeHintType.NEED_RESULT_POINT_CALLBACK);
+      if (rpcb != null) {
+        for (ResultPoint point : points) {
+          rpcb.foundPossibleResultPoint(point);
+        }
+      }
+    }
+
+    Result result = new Result(decoderResult.getText(),
+                               decoderResult.getRawBytes(),
+                               decoderResult.getNumBits(),
+                               points,
+                               BarcodeFormat.AZTEC,
+                               System.currentTimeMillis());
+
+    List<byte[]> byteSegments = decoderResult.getByteSegments();
+    if (byteSegments != null) {
+      result.putMetadata(ResultMetadataType.BYTE_SEGMENTS, byteSegments);
+    }
+    String ecLevel = decoderResult.getECLevel();
+    if (ecLevel != null) {
+      result.putMetadata(ResultMetadataType.ERROR_CORRECTION_LEVEL, ecLevel);
+    }
+    result.putMetadata(ResultMetadataType.SYMBOLOGY_IDENTIFIER, "]z" + decoderResult.getSymbologyModifier());
+
+    return result;
+  }
+
+  @Override
+  public void reset() {
+    // do nothing
+  }
+
+}

src/aztec/AztecWriter.java

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.aztec;
+
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.EncodeHintType;
+import com.google.zxing.Writer;
+import com.google.zxing.aztec.encoder.AztecCode;
+import com.google.zxing.aztec.encoder.Encoder;
+import com.google.zxing.common.BitMatrix;
+
+import java.nio.charset.Charset;
+import java.util.Map;
+
+/**
+ * Renders an Aztec code as a {@link BitMatrix}.
+ */
+public final class AztecWriter implements Writer {
+
+  @Override
+  public BitMatrix encode(String contents, BarcodeFormat format, int width, int height) {
+    return encode(contents, format, width, height, null);
+  }
+
+  @Override
+  public BitMatrix encode(String contents, BarcodeFormat format, int width, int height, Map<EncodeHintType,?> hints) {
+    Charset charset = null; // Do not add any ECI code by default
+    int eccPercent = Encoder.DEFAULT_EC_PERCENT;
+    int layers = Encoder.DEFAULT_AZTEC_LAYERS;
+    if (hints != null) {
+      if (hints.containsKey(EncodeHintType.CHARACTER_SET)) {
+        charset = Charset.forName(hints.get(EncodeHintType.CHARACTER_SET).toString());
+      }
+      if (hints.containsKey(EncodeHintType.ERROR_CORRECTION)) {
+        eccPercent = Integer.parseInt(hints.get(EncodeHintType.ERROR_CORRECTION).toString());
+      }
+      if (hints.containsKey(EncodeHintType.AZTEC_LAYERS)) {
+        layers = Integer.parseInt(hints.get(EncodeHintType.AZTEC_LAYERS).toString());
+      }
+    }
+    return encode(contents, format, width, height, charset, eccPercent, layers);
+  }
+
+  private static BitMatrix encode(String contents, BarcodeFormat format,
+                                  int width, int height,
+                                  Charset charset, int eccPercent, int layers) {
+    if (format != BarcodeFormat.AZTEC) {
+      throw new IllegalArgumentException("Can only encode AZTEC, but got " + format);
+    }
+    AztecCode aztec = Encoder.encode(contents, eccPercent, layers, charset);
+    return renderResult(aztec, width, height);
+  }
+
+  private static BitMatrix renderResult(AztecCode code, int width, int height) {
+    BitMatrix input = code.getMatrix();
+    if (input == null) {
+      throw new IllegalStateException();
+    }
+    int inputWidth = input.getWidth();
+    int inputHeight = input.getHeight();
+    int outputWidth = Math.max(width, inputWidth);
+    int outputHeight = Math.max(height, inputHeight);
+
+    int multiple = Math.min(outputWidth / inputWidth, outputHeight / inputHeight);
+    int leftPadding = (outputWidth - (inputWidth * multiple)) / 2;
+    int topPadding = (outputHeight - (inputHeight * multiple)) / 2;
+
+    BitMatrix output = new BitMatrix(outputWidth, outputHeight);
+
+    for (int inputY = 0, outputY = topPadding; inputY < inputHeight; inputY++, outputY += multiple) {
+      // Write the contents of this row of the barcode
+      for (int inputX = 0, outputX = leftPadding; inputX < inputWidth; inputX++, outputX += multiple) {
+        if (input.get(inputX, inputY)) {
+          output.setRegion(outputX, outputY, multiple, multiple);
+        }
+      }
+    }
+    return output;
+  }
+}

src/aztec/decoder/Decoder.java

@@ -0,0 +1,443 @@
+/*
+ * Copyright 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.aztec.decoder;
+
+import com.google.zxing.FormatException;
+import com.google.zxing.aztec.AztecDetectorResult;
+import com.google.zxing.common.BitMatrix;
+import com.google.zxing.common.CharacterSetECI;
+import com.google.zxing.common.DecoderResult;
+import com.google.zxing.common.reedsolomon.GenericGF;
+import com.google.zxing.common.reedsolomon.ReedSolomonDecoder;
+import com.google.zxing.common.reedsolomon.ReedSolomonException;
+
+import java.io.ByteArrayOutputStream;
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+
+/**
+ * <p>The main class which implements Aztec Code decoding -- as opposed to locating and extracting
+ * the Aztec Code from an image.</p>
+ *
+ * @author David Olivier
+ */
+public final class Decoder {
+
+  private enum Table {
+    UPPER,
+    LOWER,
+    MIXED,
+    DIGIT,
+    PUNCT,
+    BINARY
+  }
+
+  private static final String[] UPPER_TABLE = {
+      "CTRL_PS", " ", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P",
+      "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "CTRL_LL", "CTRL_ML", "CTRL_DL", "CTRL_BS"
+  };
+
+  private static final String[] LOWER_TABLE = {
+      "CTRL_PS", " ", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p",
+      "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "CTRL_US", "CTRL_ML", "CTRL_DL", "CTRL_BS"
+  };
+
+  private static final String[] MIXED_TABLE = {
+      "CTRL_PS", " ", "\1", "\2", "\3", "\4", "\5", "\6", "\7", "\b", "\t", "\n",
+      "\13", "\f", "\r", "\33", "\34", "\35", "\36", "\37", "@", "\\", "^", "_",
+      "`", "|", "~", "\177", "CTRL_LL", "CTRL_UL", "CTRL_PL", "CTRL_BS"
+  };
+
+  private static final String[] PUNCT_TABLE = {
+      "FLG(n)", "\r", "\r\n", ". ", ", ", ": ", "!", "\"", "#", "$", "%", "&", "'", "(", ")",
+      "*", "+", ",", "-", ".", "/", ":", ";", "<", "=", ">", "?", "[", "]", "{", "}", "CTRL_UL"
+  };
+
+  private static final String[] DIGIT_TABLE = {
+      "CTRL_PS", " ", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", ",", ".", "CTRL_UL", "CTRL_US"
+  };
+
+  private static final Charset DEFAULT_ENCODING = StandardCharsets.ISO_8859_1;
+
+  private AztecDetectorResult ddata;
+
+  public DecoderResult decode(AztecDetectorResult detectorResult) throws FormatException {
+    ddata = detectorResult;
+    BitMatrix matrix = detectorResult.getBits();
+    boolean[] rawbits = extractBits(matrix);
+    CorrectedBitsResult correctedBits = correctBits(rawbits);
+    byte[] rawBytes = convertBoolArrayToByteArray(correctedBits.correctBits);
+    String result = getEncodedData(correctedBits.correctBits);
+    DecoderResult decoderResult =
+        new DecoderResult(rawBytes, result, null, String.format("%d%%", correctedBits.ecLevel));
+    decoderResult.setNumBits(correctedBits.correctBits.length);
+    return decoderResult;
+  }
+
+  // This method is used for testing the high-level encoder
+  public static String highLevelDecode(boolean[] correctedBits) throws FormatException {
+    return getEncodedData(correctedBits);
+  }
+
+  /**
+   * Gets the string encoded in the aztec code bits
+   *
+   * @return the decoded string
+   */
+  private static String getEncodedData(boolean[] correctedBits) throws FormatException {
+    int endIndex = correctedBits.length;
+    Table latchTable = Table.UPPER; // table most recently latched to
+    Table shiftTable = Table.UPPER; // table to use for the next read
+
+    // Final decoded string result
+    // (correctedBits-5) / 4 is an upper bound on the size (all-digit result)
+    StringBuilder result = new StringBuilder((correctedBits.length - 5) / 4);
+
+    // Intermediary buffer of decoded bytes, which is decoded into a string and flushed
+    // when character encoding changes (ECI) or input ends.
+    ByteArrayOutputStream decodedBytes = new ByteArrayOutputStream();
+    Charset encoding = DEFAULT_ENCODING;
+
+    int index = 0;
+    while (index < endIndex) {
+      if (shiftTable == Table.BINARY) {
+        if (endIndex - index < 5) {
+          break;
+        }
+        int length = readCode(correctedBits, index, 5);
+        index += 5;
+        if (length == 0) {
+          if (endIndex - index < 11) {
+            break;
+          }
+          length = readCode(correctedBits, index, 11) + 31;
+          index += 11;
+        }
+        for (int charCount = 0; charCount < length; charCount++) {
+          if (endIndex - index < 8) {
+            index = endIndex;  // Force outer loop to exit
+            break;
+          }
+          int code = readCode(correctedBits, index, 8);
+          decodedBytes.write((byte) code);
+          index += 8;
+        }
+        // Go back to whatever mode we had been in
+        shiftTable = latchTable;
+      } else {
+        int size = shiftTable == Table.DIGIT ? 4 : 5;
+        if (endIndex - index < size) {
+          break;
+        }
+        int code = readCode(correctedBits, index, size);
+        index += size;
+        String str = getCharacter(shiftTable, code);
+        if ("FLG(n)".equals(str)) {
+          if (endIndex - index < 3) {
+            break;
+          }
+          int n = readCode(correctedBits, index, 3);
+          index += 3;
+          //  flush bytes, FLG changes state
+          try {
+            result.append(decodedBytes.toString(encoding.name()));
+          } catch (UnsupportedEncodingException uee) {
+            throw new IllegalStateException(uee);
+          }
+          decodedBytes.reset();
+          switch (n) {
+            case 0:
+              result.append((char) 29);  // translate FNC1 as ASCII 29
+              break;
+            case 7:
+              throw FormatException.getFormatInstance(); // FLG(7) is reserved and illegal
+            default:
+              // ECI is decimal integer encoded as 1-6 codes in DIGIT mode
+              int eci = 0;
+              if (endIndex - index < 4 * n) {
+                break;
+              }
+              while (n-- > 0) {
+                int nextDigit = readCode(correctedBits, index, 4);
+                index += 4;
+                if (nextDigit < 2 || nextDigit > 11) {
+                  throw FormatException.getFormatInstance(); // Not a decimal digit
+                }
+                eci = eci * 10 + (nextDigit - 2);
+              }
+              CharacterSetECI charsetECI = CharacterSetECI.getCharacterSetECIByValue(eci);
+              if (charsetECI == null) {
+                throw FormatException.getFormatInstance();
+              }
+              encoding = charsetECI.getCharset();
+          }
+          // Go back to whatever mode we had been in
+          shiftTable = latchTable;
+        } else if (str.startsWith("CTRL_")) {
+          // Table changes
+          // ISO/IEC 24778:2008 prescribes ending a shift sequence in the mode from which it was invoked.
+          // That's including when that mode is a shift.
+          // Our test case dlusbs.png for issue #642 exercises that.
+          latchTable = shiftTable;  // Latch the current mode, so as to return to Upper after U/S B/S
+          shiftTable = getTable(str.charAt(5));
+          if (str.charAt(6) == 'L') {
+            latchTable = shiftTable;
+          }
+        } else {
+          // Though stored as a table of strings for convenience, codes actually represent 1 or 2 *bytes*.
+          byte[] b = str.getBytes(StandardCharsets.US_ASCII);
+          decodedBytes.write(b, 0, b.length);
+          // Go back to whatever mode we had been in
+          shiftTable = latchTable;
+        }
+      }
+    }
+    try {
+      result.append(decodedBytes.toString(encoding.name()));
+    } catch (UnsupportedEncodingException uee) {
+      // can't happen
+      throw new IllegalStateException(uee);
+    }
+    return result.toString();
+  }
+
+  /**
+   * gets the table corresponding to the char passed
+   */
+  private static Table getTable(char t) {
+    switch (t) {
+      case 'L':
+        return Table.LOWER;
+      case 'P':
+        return Table.PUNCT;
+      case 'M':
+        return Table.MIXED;
+      case 'D':
+        return Table.DIGIT;
+      case 'B':
+        return Table.BINARY;
+      case 'U':
+      default:
+        return Table.UPPER;
+    }
+  }
+
+  /**
+   * Gets the character (or string) corresponding to the passed code in the given table
+   *
+   * @param table the table used
+   * @param code the code of the character
+   */
+  private static String getCharacter(Table table, int code) {
+    switch (table) {
+      case UPPER:
+        return UPPER_TABLE[code];
+      case LOWER:
+        return LOWER_TABLE[code];
+      case MIXED:
+        return MIXED_TABLE[code];
+      case PUNCT:
+        return PUNCT_TABLE[code];
+      case DIGIT:
+        return DIGIT_TABLE[code];
+      default:
+        // Should not reach here.
+        throw new IllegalStateException("Bad table");
+    }
+  }
+
+  static final class CorrectedBitsResult {
+    private final boolean[] correctBits;
+    private final int ecLevel;
+
+    CorrectedBitsResult(boolean[] correctBits, int ecLevel) {
+      this.correctBits = correctBits;
+      this.ecLevel = ecLevel;
+    }
+  }
+
+  /**
+   * <p>Performs RS error correction on an array of bits.</p>
+   *
+   * @return the corrected array
+   * @throws FormatException if the input contains too many errors
+   */
+  private CorrectedBitsResult correctBits(boolean[] rawbits) throws FormatException {
+    GenericGF gf;
+    int codewordSize;
+
+    if (ddata.getNbLayers() <= 2) {
+      codewordSize = 6;
+      gf = GenericGF.AZTEC_DATA_6;
+    } else if (ddata.getNbLayers() <= 8) {
+      codewordSize = 8;
+      gf = GenericGF.AZTEC_DATA_8;
+    } else if (ddata.getNbLayers() <= 22) {
+      codewordSize = 10;
+      gf = GenericGF.AZTEC_DATA_10;
+    } else {
+      codewordSize = 12;
+      gf = GenericGF.AZTEC_DATA_12;
+    }
+
+    int numDataCodewords = ddata.getNbDatablocks();
+    int numCodewords = rawbits.length / codewordSize;
+    if (numCodewords < numDataCodewords) {
+      throw FormatException.getFormatInstance();
+    }
+    int offset = rawbits.length % codewordSize;
+
+    int[] dataWords = new int[numCodewords];
+    for (int i = 0; i < numCodewords; i++, offset += codewordSize) {
+      dataWords[i] = readCode(rawbits, offset, codewordSize);
+    }
+
+    try {
+      ReedSolomonDecoder rsDecoder = new ReedSolomonDecoder(gf);
+      rsDecoder.decode(dataWords, numCodewords - numDataCodewords);
+    } catch (ReedSolomonException ex) {
+      throw FormatException.getFormatInstance(ex);
+    }
+
+    // Now perform the unstuffing operation.
+    // First, count how many bits are going to be thrown out as stuffing
+    int mask = (1 << codewordSize) - 1;
+    int stuffedBits = 0;
+    for (int i = 0; i < numDataCodewords; i++) {
+      int dataWord = dataWords[i];
+      if (dataWord == 0 || dataWord == mask) {
+        throw FormatException.getFormatInstance();
+      } else if (dataWord == 1 || dataWord == mask - 1) {
+        stuffedBits++;
+      }
+    }
+    // Now, actually unpack the bits and remove the stuffing
+    boolean[] correctedBits = new boolean[numDataCodewords * codewordSize - stuffedBits];
+    int index = 0;
+    for (int i = 0; i < numDataCodewords; i++) {
+      int dataWord = dataWords[i];
+      if (dataWord == 1 || dataWord == mask - 1) {
+        // next codewordSize-1 bits are all zeros or all ones
+        Arrays.fill(correctedBits, index, index + codewordSize - 1, dataWord > 1);
+        index += codewordSize - 1;
+      } else {
+        for (int bit = codewordSize - 1; bit >= 0; --bit) {
+          correctedBits[index++] = (dataWord & (1 << bit)) != 0;
+        }
+      }
+    }
+
+    return new CorrectedBitsResult(correctedBits, 100 * (numCodewords - numDataCodewords) / numCodewords);
+  }
+
+  /**
+   * Gets the array of bits from an Aztec Code matrix
+   *
+   * @return the array of bits
+   */
+  private boolean[] extractBits(BitMatrix matrix) {
+    boolean compact = ddata.isCompact();
+    int layers = ddata.getNbLayers();
+    int baseMatrixSize = (compact ? 11 : 14) + layers * 4; // not including alignment lines
+    int[] alignmentMap = new int[baseMatrixSize];
+    boolean[] rawbits = new boolean[totalBitsInLayer(layers, compact)];
+
+    if (compact) {
+      for (int i = 0; i < alignmentMap.length; i++) {
+        alignmentMap[i] = i;
+      }
+    } else {
+      int matrixSize = baseMatrixSize + 1 + 2 * ((baseMatrixSize / 2 - 1) / 15);
+      int origCenter = baseMatrixSize / 2;
+      int center = matrixSize / 2;
+      for (int i = 0; i < origCenter; i++) {
+        int newOffset = i + i / 15;
+        alignmentMap[origCenter - i - 1] = center - newOffset - 1;
+        alignmentMap[origCenter + i] = center + newOffset + 1;
+      }
+    }
+    for (int i = 0, rowOffset = 0; i < layers; i++) {
+      int rowSize = (layers - i) * 4 + (compact ? 9 : 12);
+      // The top-left most point of this layer is <low, low> (not including alignment lines)
+      int low = i * 2;
+      // The bottom-right most point of this layer is <high, high> (not including alignment lines)
+      int high = baseMatrixSize - 1 - low;
+      // We pull bits from the two 2 x rowSize columns and two rowSize x 2 rows
+      for (int j = 0; j < rowSize; j++) {
+        int columnOffset = j * 2;
+        for (int k = 0; k < 2; k++) {
+          // left column
+          rawbits[rowOffset + columnOffset + k] =
+              matrix.get(alignmentMap[low + k], alignmentMap[low + j]);
+          // bottom row
+          rawbits[rowOffset + 2 * rowSize + columnOffset + k] =
+              matrix.get(alignmentMap[low + j], alignmentMap[high - k]);
+          // right column
+          rawbits[rowOffset + 4 * rowSize + columnOffset + k] =
+              matrix.get(alignmentMap[high - k], alignmentMap[high - j]);
+          // top row
+          rawbits[rowOffset + 6 * rowSize + columnOffset + k] =
+              matrix.get(alignmentMap[high - j], alignmentMap[low + k]);
+        }
+      }
+      rowOffset += rowSize * 8;
+    }
+    return rawbits;
+  }
+
+  /**
+   * Reads a code of given length and at given index in an array of bits
+   */
+  private static int readCode(boolean[] rawbits, int startIndex, int length) {
+    int res = 0;
+    for (int i = startIndex; i < startIndex + length; i++) {
+      res <<= 1;
+      if (rawbits[i]) {
+        res |= 0x01;
+      }
+    }
+    return res;
+  }
+
+  /**
+   * Reads a code of length 8 in an array of bits, padding with zeros
+   */
+  private static byte readByte(boolean[] rawbits, int startIndex) {
+    int n = rawbits.length - startIndex;
+    if (n >= 8) {
+      return (byte) readCode(rawbits, startIndex, 8);
+    }
+    return (byte) (readCode(rawbits, startIndex, n) << (8 - n));
+  }
+
+  /**
+   * Packs a bit array into bytes, most significant bit first
+   */
+  static byte[] convertBoolArrayToByteArray(boolean[] boolArr) {
+    byte[] byteArr = new byte[(boolArr.length + 7) / 8];
+    for (int i = 0; i < byteArr.length; i++) {
+      byteArr[i] = readByte(boolArr, 8 * i);
+    }
+    return byteArr;
+  }
+
+  private static int totalBitsInLayer(int layers, boolean compact) {
+    return ((compact ? 88 : 112) + 16 * layers) * layers;
+  }
+}

src/aztec/detector/Detector.java

@@ -0,0 +1,603 @@
+/*
+ * Copyright 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.aztec.detector;
+
+import com.google.zxing.NotFoundException;
+import com.google.zxing.ResultPoint;
+import com.google.zxing.aztec.AztecDetectorResult;
+import com.google.zxing.common.BitMatrix;
+import com.google.zxing.common.GridSampler;
+import com.google.zxing.common.detector.MathUtils;
+import com.google.zxing.common.detector.WhiteRectangleDetector;
+import com.google.zxing.common.reedsolomon.GenericGF;
+import com.google.zxing.common.reedsolomon.ReedSolomonDecoder;
+import com.google.zxing.common.reedsolomon.ReedSolomonException;
+
+/**
+ * Encapsulates logic that can detect an Aztec Code in an image, even if the Aztec Code
+ * is rotated or skewed, or partially obscured.
+ *
+ * @author David Olivier
+ * @author Frank Yellin
+ */
+public final class Detector {
+
+  private static final int[] EXPECTED_CORNER_BITS = {
+      0xee0,  // 07340  XXX .XX X.. ...
+      0x1dc,  // 00734  ... XXX .XX X..
+      0x83b,  // 04073  X.. ... XXX .XX
+      0x707,  // 03407 .XX X.. ... XXX
+  };
+
+  private final BitMatrix image;
+
+  private boolean compact;
+  private int nbLayers;
+  private int nbDataBlocks;
+  private int nbCenterLayers;
+  private int shift;
+
+  public Detector(BitMatrix image) {
+    this.image = image;
+  }
+
+  public AztecDetectorResult detect() throws NotFoundException {
+    return detect(false);
+  }
+
+  /**
+   * Detects an Aztec Code in an image.
+   *
+   * @param isMirror if true, image is a mirror-image of original
+   * @return {@link AztecDetectorResult} encapsulating results of detecting an Aztec Code
+   * @throws NotFoundException if no Aztec Code can be found
+   */
+  public AztecDetectorResult detect(boolean isMirror) throws NotFoundException {
+
+    // 1. Get the center of the aztec matrix
+    Point pCenter = getMatrixCenter();
+
+    // 2. Get the center points of the four diagonal points just outside the bull's eye
+    //  [topRight, bottomRight, bottomLeft, topLeft]
+    ResultPoint[] bullsEyeCorners = getBullsEyeCorners(pCenter);
+
+    if (isMirror) {
+      ResultPoint temp = bullsEyeCorners[0];
+      bullsEyeCorners[0] = bullsEyeCorners[2];
+      bullsEyeCorners[2] = temp;
+    }
+
+    // 3. Get the size of the matrix and other parameters from the bull's eye
+    extractParameters(bullsEyeCorners);
+
+    // 4. Sample the grid
+    BitMatrix bits = sampleGrid(image,
+                                bullsEyeCorners[shift % 4],
+                                bullsEyeCorners[(shift + 1) % 4],
+                                bullsEyeCorners[(shift + 2) % 4],
+                                bullsEyeCorners[(shift + 3) % 4]);
+
+    // 5. Get the corners of the matrix.
+    ResultPoint[] corners = getMatrixCornerPoints(bullsEyeCorners);
+
+    return new AztecDetectorResult(bits, corners, compact, nbDataBlocks, nbLayers);
+  }
+
+  /**
+   * Extracts the number of data layers and data blocks from the layer around the bull's eye.
+   *
+   * @param bullsEyeCorners the array of bull's eye corners
+   * @throws NotFoundException in case of too many errors or invalid parameters
+   */
+  private void extractParameters(ResultPoint[] bullsEyeCorners) throws NotFoundException {
+    if (!isValid(bullsEyeCorners[0]) || !isValid(bullsEyeCorners[1]) ||
+        !isValid(bullsEyeCorners[2]) || !isValid(bullsEyeCorners[3])) {
+      throw NotFoundException.getNotFoundInstance();
+    }
+    int length = 2 * nbCenterLayers;
+    // Get the bits around the bull's eye
+    int[] sides = {
+        sampleLine(bullsEyeCorners[0], bullsEyeCorners[1], length), // Right side
+        sampleLine(bullsEyeCorners[1], bullsEyeCorners[2], length), // Bottom
+        sampleLine(bullsEyeCorners[2], bullsEyeCorners[3], length), // Left side
+        sampleLine(bullsEyeCorners[3], bullsEyeCorners[0], length)  // Top
+    };
+
+    // bullsEyeCorners[shift] is the corner of the bulls'eye that has three
+    // orientation marks.
+    // sides[shift] is the row/column that goes from the corner with three
+    // orientation marks to the corner with two.
+    shift = getRotation(sides, length);
+
+    // Flatten the parameter bits into a single 28- or 40-bit long
+    long parameterData = 0;
+    for (int i = 0; i < 4; i++) {
+      int side = sides[(shift + i) % 4];
+      if (compact) {
+        // Each side of the form ..XXXXXXX. where Xs are parameter data
+        parameterData <<= 7;
+        parameterData += (side >> 1) & 0x7F;
+      } else {
+        // Each side of the form ..XXXXX.XXXXX. where Xs are parameter data
+        parameterData <<= 10;
+        parameterData += ((side >> 2) & (0x1f << 5)) + ((side >> 1) & 0x1F);
+      }
+    }
+
+    // Corrects parameter data using RS.  Returns just the data portion
+    // without the error correction.
+    int correctedData = getCorrectedParameterData(parameterData, compact);
+
+    if (compact) {
+      // 8 bits:  2 bits layers and 6 bits data blocks
+      nbLayers = (correctedData >> 6) + 1;
+      nbDataBlocks = (correctedData & 0x3F) + 1;
+    } else {
+      // 16 bits:  5 bits layers and 11 bits data blocks
+      nbLayers = (correctedData >> 11) + 1;
+      nbDataBlocks = (correctedData & 0x7FF) + 1;
+    }
+  }
+
+  private static int getRotation(int[] sides, int length) throws NotFoundException {
+    // In a normal pattern, we expect to See
+    //   **    .*             D       A
+    //   *      *
+    //
+    //   .      *
+    //   ..    ..             C       B
+    //
+    // Grab the 3 bits from each of the sides the form the locator pattern and concatenate
+    // into a 12-bit integer.  Start with the bit at A
+    int cornerBits = 0;
+    for (int side : sides) {
+      // XX......X where X's are orientation marks
+      int t = ((side >> (length - 2)) << 1) + (side & 1);
+      cornerBits = (cornerBits << 3) + t;
+    }
+    // Mov the bottom bit to the top, so that the three bits of the locator pattern at A are
+    // together.  cornerBits is now:
+    //  3 orientation bits at A || 3 orientation bits at B || ... || 3 orientation bits at D
+    cornerBits = ((cornerBits & 1) << 11) + (cornerBits >> 1);
+    // The result shift indicates which element of BullsEyeCorners[] goes into the top-left
+    // corner. Since the four rotation values have a Hamming distance of 8, we
+    // can easily tolerate two errors.
+    for (int shift = 0; shift < 4; shift++) {
+      if (Integer.bitCount(cornerBits ^ EXPECTED_CORNER_BITS[shift]) <= 2) {
+        return shift;
+      }
+    }
+    throw NotFoundException.getNotFoundInstance();
+  }
+
+  /**
+   * Corrects the parameter bits using Reed-Solomon algorithm.
+   *
+   * @param parameterData parameter bits
+   * @param compact true if this is a compact Aztec code
+   * @throws NotFoundException if the array contains too many errors
+   */
+  private static int getCorrectedParameterData(long parameterData, boolean compact) throws NotFoundException {
+    int numCodewords;
+    int numDataCodewords;
+
+    if (compact) {
+      numCodewords = 7;
+      numDataCodewords = 2;
+    } else {
+      numCodewords = 10;
+      numDataCodewords = 4;
+    }
+
+    int numECCodewords = numCodewords - numDataCodewords;
+    int[] parameterWords = new int[numCodewords];
+    for (int i = numCodewords - 1; i >= 0; --i) {
+      parameterWords[i] = (int) parameterData & 0xF;
+      parameterData >>= 4;
+    }
+    try {
+      ReedSolomonDecoder rsDecoder = new ReedSolomonDecoder(GenericGF.AZTEC_PARAM);
+      rsDecoder.decode(parameterWords, numECCodewords);
+    } catch (ReedSolomonException ignored) {
+      throw NotFoundException.getNotFoundInstance();
+    }
+    // Toss the error correction.  Just return the data as an integer
+    int result = 0;
+    for (int i = 0; i < numDataCodewords; i++) {
+      result = (result << 4) + parameterWords[i];
+    }
+    return result;
+  }
+
+  /**
+   * Finds the corners of a bull-eye centered on the passed point.
+   * This returns the centers of the diagonal points just outside the bull's eye
+   * Returns [topRight, bottomRight, bottomLeft, topLeft]
+   *
+   * @param pCenter Center point
+   * @return The corners of the bull-eye
+   * @throws NotFoundException If no valid bull-eye can be found
+   */
+  private ResultPoint[] getBullsEyeCorners(Point pCenter) throws NotFoundException {
+
+    Point pina = pCenter;
+    Point pinb = pCenter;
+    Point pinc = pCenter;
+    Point pind = pCenter;
+
+    boolean color = true;
+
+    for (nbCenterLayers = 1; nbCenterLayers < 9; nbCenterLayers++) {
+      Point pouta = getFirstDifferent(pina, color, 1, -1);
+      Point poutb = getFirstDifferent(pinb, color, 1, 1);
+      Point poutc = getFirstDifferent(pinc, color, -1, 1);
+      Point poutd = getFirstDifferent(pind, color, -1, -1);
+
+      //d      a
+      //
+      //c      b
+
+      if (nbCenterLayers > 2) {
+        float q = distance(poutd, pouta) * nbCenterLayers / (distance(pind, pina) * (nbCenterLayers + 2));
+        if (q < 0.75 || q > 1.25 || !isWhiteOrBlackRectangle(pouta, poutb, poutc, poutd)) {
+          break;
+        }
+      }
+
+      pina = pouta;
+      pinb = poutb;
+      pinc = poutc;
+      pind = poutd;
+
+      color = !color;
+    }
+
+    if (nbCenterLayers != 5 && nbCenterLayers != 7) {
+      throw NotFoundException.getNotFoundInstance();
+    }
+
+    compact = nbCenterLayers == 5;
+
+    // Expand the square by .5 pixel in each direction so that we're on the border
+    // between the white square and the black square
+    ResultPoint pinax = new ResultPoint(pina.getX() + 0.5f, pina.getY() - 0.5f);
+    ResultPoint pinbx = new ResultPoint(pinb.getX() + 0.5f, pinb.getY() + 0.5f);
+    ResultPoint pincx = new ResultPoint(pinc.getX() - 0.5f, pinc.getY() + 0.5f);
+    ResultPoint pindx = new ResultPoint(pind.getX() - 0.5f, pind.getY() - 0.5f);
+
+    // Expand the square so that its corners are the centers of the points
+    // just outside the bull's eye.
+    return expandSquare(new ResultPoint[]{pinax, pinbx, pincx, pindx},
+                        2 * nbCenterLayers - 3,
+                        2 * nbCenterLayers);
+  }
+
+  /**
+   * Finds a candidate center point of an Aztec code from an image
+   *
+   * @return the center point
+   */
+  private Point getMatrixCenter() {
+
+    ResultPoint pointA;
+    ResultPoint pointB;
+    ResultPoint pointC;
+    ResultPoint pointD;
+
+    //Get a white rectangle that can be the border of the matrix in center bull's eye or
+    try {
+
+      ResultPoint[] cornerPoints = new WhiteRectangleDetector(image).detect();
+      pointA = cornerPoints[0];
+      pointB = cornerPoints[1];
+      pointC = cornerPoints[2];
+      pointD = cornerPoints[3];
+
+    } catch (NotFoundException e) {
+
+      // This exception can be in case the initial rectangle is white
+      // In that case, surely in the bull's eye, we try to expand the rectangle.
+      int cx = image.getWidth() / 2;
+      int cy = image.getHeight() / 2;
+      pointA = getFirstDifferent(new Point(cx + 7, cy - 7), false, 1, -1).toResultPoint();
+      pointB = getFirstDifferent(new Point(cx + 7, cy + 7), false, 1, 1).toResultPoint();
+      pointC = getFirstDifferent(new Point(cx - 7, cy + 7), false, -1, 1).toResultPoint();
+      pointD = getFirstDifferent(new Point(cx - 7, cy - 7), false, -1, -1).toResultPoint();
+
+    }
+
+    //Compute the center of the rectangle
+    int cx = MathUtils.round((pointA.getX() + pointD.getX() + pointB.getX() + pointC.getX()) / 4.0f);
+    int cy = MathUtils.round((pointA.getY() + pointD.getY() + pointB.getY() + pointC.getY()) / 4.0f);
+
+    // Redetermine the white rectangle starting from previously computed center.
+    // This will ensure that we end up with a white rectangle in center bull's eye
+    // in order to compute a more accurate center.
+    try {
+      ResultPoint[] cornerPoints = new WhiteRectangleDetector(image, 15, cx, cy).detect();
+      pointA = cornerPoints[0];
+      pointB = cornerPoints[1];
+      pointC = cornerPoints[2];
+      pointD = cornerPoints[3];
+    } catch (NotFoundException e) {
+      // This exception can be in case the initial rectangle is white
+      // In that case we try to expand the rectangle.
+      pointA = getFirstDifferent(new Point(cx + 7, cy - 7), false, 1, -1).toResultPoint();
+      pointB = getFirstDifferent(new Point(cx + 7, cy + 7), false, 1, 1).toResultPoint();
+      pointC = getFirstDifferent(new Point(cx - 7, cy + 7), false, -1, 1).toResultPoint();
+      pointD = getFirstDifferent(new Point(cx - 7, cy - 7), false, -1, -1).toResultPoint();
+    }
+
+    // Recompute the center of the rectangle
+    cx = MathUtils.round((pointA.getX() + pointD.getX() + pointB.getX() + pointC.getX()) / 4.0f);
+    cy = MathUtils.round((pointA.getY() + pointD.getY() + pointB.getY() + pointC.getY()) / 4.0f);
+
+    return new Point(cx, cy);
+  }
+
+  /**
+   * Gets the Aztec code corners from the bull's eye corners and the parameters.
+   *
+   * @param bullsEyeCorners the array of bull's eye corners
+   * @return the array of aztec code corners
+   */
+  private ResultPoint[] getMatrixCornerPoints(ResultPoint[] bullsEyeCorners) {
+    return expandSquare(bullsEyeCorners, 2 * nbCenterLayers, getDimension());
+  }
+
+  /**
+   * Creates a BitMatrix by sampling the provided image.
+   * topLeft, topRight, bottomRight, and bottomLeft are the centers of the squares on the
+   * diagonal just outside the bull's eye.
+   */
+  private BitMatrix sampleGrid(BitMatrix image,
+                               ResultPoint topLeft,
+                               ResultPoint topRight,
+                               ResultPoint bottomRight,
+                               ResultPoint bottomLeft) throws NotFoundException {
+
+    GridSampler sampler = GridSampler.getInstance();
+    int dimension = getDimension();
+
+    float low = dimension / 2.0f - nbCenterLayers;
+    float high = dimension / 2.0f + nbCenterLayers;
+
+    return sampler.sampleGrid(image,
+                              dimension,
+                              dimension,
+                              low, low,   // topleft
+                              high, low,  // topright
+                              high, high, // bottomright
+                              low, high,  // bottomleft
+                              topLeft.getX(), topLeft.getY(),
+                              topRight.getX(), topRight.getY(),
+                              bottomRight.getX(), bottomRight.getY(),
+                              bottomLeft.getX(), bottomLeft.getY());
+  }
+
+  /**
+   * Samples a line.
+   *
+   * @param p1   start point (inclusive)
+   * @param p2   end point (exclusive)
+   * @param size number of bits
+   * @return the array of bits as an int (first bit is high-order bit of result)
+   */
+  private int sampleLine(ResultPoint p1, ResultPoint p2, int size) {
+    int result = 0;
+
+    float d = distance(p1, p2);
+    float moduleSize = d / size;
+    float px = p1.getX();
+    float py = p1.getY();
+    float dx = moduleSize * (p2.getX() - p1.getX()) / d;
+    float dy = moduleSize * (p2.getY() - p1.getY()) / d;
+    for (int i = 0; i < size; i++) {
+      if (image.get(MathUtils.round(px + i * dx), MathUtils.round(py + i * dy))) {
+        result |= 1 << (size - i - 1);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * @return true if the border of the rectangle passed in parameter is compound of white points only
+   *         or black points only
+   */
+  private boolean isWhiteOrBlackRectangle(Point p1,
+                                          Point p2,
+                                          Point p3,
+                                          Point p4) {
+
+    int corr = 3;
+
+    p1 = new Point(Math.max(0, p1.getX() - corr), Math.min(image.getHeight() - 1, p1.getY() + corr));
+    p2 = new Point(Math.max(0, p2.getX() - corr), Math.max(0, p2.getY() - corr));
+    p3 = new Point(Math.min(image.getWidth() - 1, p3.getX() + corr),
+                   Math.max(0, Math.min(image.getHeight() - 1, p3.getY() - corr)));
+    p4 = new Point(Math.min(image.getWidth() - 1, p4.getX() + corr),
+                   Math.min(image.getHeight() - 1, p4.getY() + corr));
+
+    int cInit = getColor(p4, p1);
+
+    if (cInit == 0) {
+      return false;
+    }
+
+    int c = getColor(p1, p2);
+
+    if (c != cInit) {
+      return false;
+    }
+
+    c = getColor(p2, p3);
+
+    if (c != cInit) {
+      return false;
+    }
+
+    c = getColor(p3, p4);
+
+    return c == cInit;
+
+  }
+
+  /**
+   * Gets the color of a segment
+   *
+   * @return 1 if segment more than 90% black, -1 if segment is more than 90% white, 0 else
+   */
+  private int getColor(Point p1, Point p2) {
+    float d = distance(p1, p2);
+    if (d == 0.0f) {
+      return 0;
+    }
+    float dx = (p2.getX() - p1.getX()) / d;
+    float dy = (p2.getY() - p1.getY()) / d;
+    int error = 0;
+
+    float px = p1.getX();
+    float py = p1.getY();
+
+    boolean colorModel = image.get(p1.getX(), p1.getY());
+
+    int iMax = (int) Math.floor(d);
+    for (int i = 0; i < iMax; i++) {
+      if (image.get(MathUtils.round(px), MathUtils.round(py)) != colorModel) {
+        error++;
+      }
+      px += dx;
+      py += dy;
+    }
+
+    float errRatio = error / d;
+
+    if (errRatio > 0.1f && errRatio < 0.9f) {
+      return 0;
+    }
+
+    return (errRatio <= 0.1f) == colorModel ? 1 : -1;
+  }
+
+  /**
+   * Gets the coordinate of the first point with a different color in the given direction
+   */
+  private Point getFirstDifferent(Point init, boolean color, int dx, int dy) {
+    int x = init.getX() + dx;
+    int y = init.getY() + dy;
+
+    while (isValid(x, y) && image.get(x, y) == color) {
+      x += dx;
+      y += dy;
+    }
+
+    x -= dx;
+    y -= dy;
+
+    while (isValid(x, y) && image.get(x, y) == color) {
+      x += dx;
+    }
+    x -= dx;
+
+    while (isValid(x, y) && image.get(x, y) == color) {
+      y += dy;
+    }
+    y -= dy;
+
+    return new Point(x, y);
+  }
+
+  /**
+   * Expand the square represented by the corner points by pushing out equally in all directions
+   *
+   * @param cornerPoints the corners of the square, which has the bull's eye at its center
+   * @param oldSide the original length of the side of the square in the target bit matrix
+   * @param newSide the new length of the size of the square in the target bit matrix
+   * @return the corners of the expanded square
+   */
+  private static ResultPoint[] expandSquare(ResultPoint[] cornerPoints, int oldSide, int newSide) {
+    float ratio = newSide / (2.0f * oldSide);
+    float dx = cornerPoints[0].getX() - cornerPoints[2].getX();
+    float dy = cornerPoints[0].getY() - cornerPoints[2].getY();
+    float centerx = (cornerPoints[0].getX() + cornerPoints[2].getX()) / 2.0f;
+    float centery = (cornerPoints[0].getY() + cornerPoints[2].getY()) / 2.0f;
+
+    ResultPoint result0 = new ResultPoint(centerx + ratio * dx, centery + ratio * dy);
+    ResultPoint result2 = new ResultPoint(centerx - ratio * dx, centery - ratio * dy);
+
+    dx = cornerPoints[1].getX() - cornerPoints[3].getX();
+    dy = cornerPoints[1].getY() - cornerPoints[3].getY();
+    centerx = (cornerPoints[1].getX() + cornerPoints[3].getX()) / 2.0f;
+    centery = (cornerPoints[1].getY() + cornerPoints[3].getY()) / 2.0f;
+    ResultPoint result1 = new ResultPoint(centerx + ratio * dx, centery + ratio * dy);
+    ResultPoint result3 = new ResultPoint(centerx - ratio * dx, centery - ratio * dy);
+
+    return new ResultPoint[]{result0, result1, result2, result3};
+  }
+
+  private boolean isValid(int x, int y) {
+    return x >= 0 && x < image.getWidth() && y >= 0 && y < image.getHeight();
+  }
+
+  private boolean isValid(ResultPoint point) {
+    int x = MathUtils.round(point.getX());
+    int y = MathUtils.round(point.getY());
+    return isValid(x, y);
+  }
+
+  private static float distance(Point a, Point b) {
+    return MathUtils.distance(a.getX(), a.getY(), b.getX(), b.getY());
+  }
+
+  private static float distance(ResultPoint a, ResultPoint b) {
+    return MathUtils.distance(a.getX(), a.getY(), b.getX(), b.getY());
+  }
+
+  private int getDimension() {
+    if (compact) {
+      return 4 * nbLayers + 11;
+    }
+    return 4 * nbLayers + 2 * ((2 * nbLayers + 6) / 15) + 15;
+  }
+
+  static final class Point {
+    private final int x;
+    private final int y;
+
+    ResultPoint toResultPoint() {
+      return new ResultPoint(x, y);
+    }
+
+    Point(int x, int y) {
+      this.x = x;
+      this.y = y;
+    }
+
+    int getX() {
+      return x;
+    }
+
+    int getY() {
+      return y;
+    }
+
+    @Override
+    public String toString() {
+      return "<" + x + ' ' + y + '>';
+    }
+  }
+}

src/aztec/encoder/AztecCode.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.aztec.encoder;
+
+import com.google.zxing.common.BitMatrix;
+
+/**
+ * Aztec 2D code representation
+ *
+ * @author Rustam Abdullaev
+ */
+public final class AztecCode {
+
+  private boolean compact;
+  private int size;
+  private int layers;
+  private int codeWords;
+  private BitMatrix matrix;
+
+  /**
+   * @return {@code true} if compact instead of full mode
+   */
+  public boolean isCompact() {
+    return compact;
+  }
+
+  public void setCompact(boolean compact) {
+    this.compact = compact;
+  }
+
+  /**
+   * @return size in pixels (width and height)
+   */
+  public int getSize() {
+    return size;
+  }
+
+  public void setSize(int size) {
+    this.size = size;
+  }
+
+  /**
+   * @return number of levels
+   */
+  public int getLayers() {
+    return layers;
+  }
+
+  public void setLayers(int layers) {
+    this.layers = layers;
+  }
+
+  /**
+   * @return number of data codewords
+   */
+  public int getCodeWords() {
+    return codeWords;
+  }
+
+  public void setCodeWords(int codeWords) {
+    this.codeWords = codeWords;
+  }
+
+  /**
+   * @return the symbol image
+   */
+  public BitMatrix getMatrix() {
+    return matrix;
+  }
+
+  public void setMatrix(BitMatrix matrix) {
+    this.matrix = matrix;
+  }
+
+}

src/aztec/encoder/BinaryShiftToken.java

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.aztec.encoder;
+
+import com.google.zxing.common.BitArray;
+
+final class BinaryShiftToken extends Token {
+
+  private final int binaryShiftStart;
+  private final int binaryShiftByteCount;
+
+  BinaryShiftToken(Token previous,
+                   int binaryShiftStart,
+                   int binaryShiftByteCount) {
+    super(previous);
+    this.binaryShiftStart = binaryShiftStart;
+    this.binaryShiftByteCount = binaryShiftByteCount;
+  }
+
+  @Override
+  public void appendTo(BitArray bitArray, byte[] text) {
+    int bsbc = binaryShiftByteCount;
+    for (int i = 0; i < bsbc; i++) {
+      if (i == 0 || (i == 31 && bsbc <= 62)) {
+        // We need a header before the first character, and before
+        // character 31 when the total byte code is <= 62
+        bitArray.appendBits(31, 5);  // BINARY_SHIFT
+        if (bsbc > 62) {
+          bitArray.appendBits(bsbc - 31, 16);
+        } else if (i == 0) {
+          // 1 <= binaryShiftByteCode <= 62
+          bitArray.appendBits(Math.min(bsbc, 31), 5);
+        } else {
+          // 32 <= binaryShiftCount <= 62 and i == 31
+          bitArray.appendBits(bsbc - 31, 5);
+        }
+      }
+      bitArray.appendBits(text[binaryShiftStart + i], 8);
+    }
+  }
+
+  @Override
+  public String toString() {
+    return "<" + binaryShiftStart + "::" + (binaryShiftStart + binaryShiftByteCount - 1) + '>';
+  }
+
+}

src/aztec/encoder/Encoder.java

@@ -0,0 +1,404 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.aztec.encoder;
+
+import com.google.zxing.common.BitArray;
+import com.google.zxing.common.BitMatrix;
+import com.google.zxing.common.reedsolomon.GenericGF;
+import com.google.zxing.common.reedsolomon.ReedSolomonEncoder;
+
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * Generates Aztec 2D barcodes.
+ *
+ * @author Rustam Abdullaev
+ */
+public final class Encoder {
+
+  public static final int DEFAULT_EC_PERCENT = 33; // default minimal percentage of error check words
+  public static final int DEFAULT_AZTEC_LAYERS = 0;
+  private static final int MAX_NB_BITS = 32;
+  private static final int MAX_NB_BITS_COMPACT = 4;
+
+  private static final int[] WORD_SIZE = {
+    4, 6, 6, 8, 8, 8, 8, 8, 8, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+    12, 12, 12, 12, 12, 12, 12, 12, 12, 12
+  };
+
+  private Encoder() {
+  }
+
+  /**
+   * Encodes the given string content as an Aztec symbol (without ECI code)
+   *
+   * @param data input data string; must be encodable as ISO/IEC 8859-1 (Latin-1)
+   * @return Aztec symbol matrix with metadata
+   */
+  public static AztecCode encode(String data) {
+    return encode(data.getBytes(StandardCharsets.ISO_8859_1));
+  }
+
+  /**
+   * Encodes the given string content as an Aztec symbol (without ECI code)
+   *
+   * @param data input data string; must be encodable as ISO/IEC 8859-1 (Latin-1)
+   * @param minECCPercent minimal percentage of error check words (According to ISO/IEC 24778:2008,
+   *                      a minimum of 23% + 3 words is recommended)
+   * @param userSpecifiedLayers if non-zero, a user-specified value for the number of layers
+   * @return Aztec symbol matrix with metadata
+   */
+  public static AztecCode encode(String data, int minECCPercent, int userSpecifiedLayers) {
+    return encode(data.getBytes(StandardCharsets.ISO_8859_1), minECCPercent, userSpecifiedLayers, null);
+  }
+
+  /**
+   * Encodes the given string content as an Aztec symbol
+   *
+   * @param data input data string
+   * @param minECCPercent minimal percentage of error check words (According to ISO/IEC 24778:2008,
+   *                      a minimum of 23% + 3 words is recommended)
+   * @param userSpecifiedLayers if non-zero, a user-specified value for the number of layers
+   * @param charset character set in which to encode string using ECI; if null, no ECI code
+   *                will be inserted, and the string must be encodable as ISO/IEC 8859-1
+   *                (Latin-1), the default encoding of the symbol.
+   * @return Aztec symbol matrix with metadata
+   */
+  public static AztecCode encode(String data, int minECCPercent, int userSpecifiedLayers, Charset charset) {
+    byte[] bytes = data.getBytes(null != charset ? charset : StandardCharsets.ISO_8859_1);
+    return encode(bytes, minECCPercent, userSpecifiedLayers, charset);
+  }
+
+  /**
+   * Encodes the given binary content as an Aztec symbol (without ECI code)
+   *
+   * @param data input data string
+   * @return Aztec symbol matrix with metadata
+   */
+  public static AztecCode encode(byte[] data) {
+    return encode(data, DEFAULT_EC_PERCENT, DEFAULT_AZTEC_LAYERS, null);
+  }
+
+  /**
+   * Encodes the given binary content as an Aztec symbol (without ECI code)
+   *
+   * @param data input data string
+   * @param minECCPercent minimal percentage of error check words (According to ISO/IEC 24778:2008,
+   *                      a minimum of 23% + 3 words is recommended)
+   * @param userSpecifiedLayers if non-zero, a user-specified value for the number of layers
+   * @return Aztec symbol matrix with metadata
+   */
+  public static AztecCode encode(byte[] data, int minECCPercent, int userSpecifiedLayers) {
+    return encode(data, minECCPercent, userSpecifiedLayers, null);
+  }
+
+  /**
+   * Encodes the given binary content as an Aztec symbol
+   *
+   * @param data input data string
+   * @param minECCPercent minimal percentage of error check words (According to ISO/IEC 24778:2008,
+   *                      a minimum of 23% + 3 words is recommended)
+   * @param userSpecifiedLayers if non-zero, a user-specified value for the number of layers
+   * @param charset character set to mark using ECI; if null, no ECI code will be inserted, and the
+   *                default encoding of ISO/IEC 8859-1 will be assuming by readers.
+   * @return Aztec symbol matrix with metadata
+   */
+  public static AztecCode encode(byte[] data, int minECCPercent, int userSpecifiedLayers, Charset charset) {
+    // High-level encode
+    BitArray bits = new HighLevelEncoder(data, charset).encode();
+
+    // stuff bits and choose symbol size
+    int eccBits = bits.getSize() * minECCPercent / 100 + 11;
+    int totalSizeBits = bits.getSize() + eccBits;
+    boolean compact;
+    int layers;
+    int totalBitsInLayer;
+    int wordSize;
+    BitArray stuffedBits;
+    if (userSpecifiedLayers != DEFAULT_AZTEC_LAYERS) {
+      compact = userSpecifiedLayers < 0;
+      layers = Math.abs(userSpecifiedLayers);
+      if (layers > (compact ? MAX_NB_BITS_COMPACT : MAX_NB_BITS)) {
+        throw new IllegalArgumentException(
+            String.format("Illegal value %s for layers", userSpecifiedLayers));
+      }
+      totalBitsInLayer = totalBitsInLayer(layers, compact);
+      wordSize = WORD_SIZE[layers];
+      int usableBitsInLayers = totalBitsInLayer - (totalBitsInLayer % wordSize);
+      stuffedBits = stuffBits(bits, wordSize);
+      if (stuffedBits.getSize() + eccBits > usableBitsInLayers) {
+        throw new IllegalArgumentException("Data to large for user specified layer");
+      }
+      if (compact && stuffedBits.getSize() > wordSize * 64) {
+        // Compact format only allows 64 data words, though C4 can hold more words than that
+        throw new IllegalArgumentException("Data to large for user specified layer");
+      }
+    } else {
+      wordSize = 0;
+      stuffedBits = null;
+      // We look at the possible table sizes in the order Compact1, Compact2, Compact3,
+      // Compact4, Normal4,...  Normal(i) for i < 4 isn't typically used since Compact(i+1)
+      // is the same size, but has more data.
+      for (int i = 0; ; i++) {
+        if (i > MAX_NB_BITS) {
+          throw new IllegalArgumentException("Data too large for an Aztec code");
+        }
+        compact = i <= 3;
+        layers = compact ? i + 1 : i;
+        totalBitsInLayer = totalBitsInLayer(layers, compact);
+        if (totalSizeBits > totalBitsInLayer) {
+          continue;
+        }
+        // [Re]stuff the bits if this is the first opportunity, or if the
+        // wordSize has changed
+        if (stuffedBits == null || wordSize != WORD_SIZE[layers]) {
+          wordSize = WORD_SIZE[layers];
+          stuffedBits = stuffBits(bits, wordSize);
+        }
+        int usableBitsInLayers = totalBitsInLayer - (totalBitsInLayer % wordSize);
+        if (compact && stuffedBits.getSize() > wordSize * 64) {
+          // Compact format only allows 64 data words, though C4 can hold more words than that
+          continue;
+        }
+        if (stuffedBits.getSize() + eccBits <= usableBitsInLayers) {
+          break;
+        }
+      }
+    }
+    BitArray messageBits = generateCheckWords(stuffedBits, totalBitsInLayer, wordSize);
+
+    // generate mode message
+    int messageSizeInWords = stuffedBits.getSize() / wordSize;
+    BitArray modeMessage = generateModeMessage(compact, layers, messageSizeInWords);
+
+    // allocate symbol
+    int baseMatrixSize = (compact ? 11 : 14) + layers * 4; // not including alignment lines
+    int[] alignmentMap = new int[baseMatrixSize];
+    int matrixSize;
+    if (compact) {
+      // no alignment marks in compact mode, alignmentMap is a no-op
+      matrixSize = baseMatrixSize;
+      for (int i = 0; i < alignmentMap.length; i++) {
+        alignmentMap[i] = i;
+      }
+    } else {
+      matrixSize = baseMatrixSize + 1 + 2 * ((baseMatrixSize / 2 - 1) / 15);
+      int origCenter = baseMatrixSize / 2;
+      int center = matrixSize / 2;
+      for (int i = 0; i < origCenter; i++) {
+        int newOffset = i + i / 15;
+        alignmentMap[origCenter - i - 1] = center - newOffset - 1;
+        alignmentMap[origCenter + i] = center + newOffset + 1;
+      }
+    }
+    BitMatrix matrix = new BitMatrix(matrixSize);
+
+    // draw data bits
+    for (int i = 0, rowOffset = 0; i < layers; i++) {
+      int rowSize = (layers - i) * 4 + (compact ? 9 : 12);
+      for (int j = 0; j < rowSize; j++) {
+        int columnOffset = j * 2;
+        for (int k = 0; k < 2; k++) {
+          if (messageBits.get(rowOffset + columnOffset + k)) {
+            matrix.set(alignmentMap[i * 2 + k], alignmentMap[i * 2 + j]);
+          }
+          if (messageBits.get(rowOffset + rowSize * 2 + columnOffset + k)) {
+            matrix.set(alignmentMap[i * 2 + j], alignmentMap[baseMatrixSize - 1 - i * 2 - k]);
+          }
+          if (messageBits.get(rowOffset + rowSize * 4 + columnOffset + k)) {
+            matrix.set(alignmentMap[baseMatrixSize - 1 - i * 2 - k], alignmentMap[baseMatrixSize - 1 - i * 2 - j]);
+          }
+          if (messageBits.get(rowOffset + rowSize * 6 + columnOffset + k)) {
+            matrix.set(alignmentMap[baseMatrixSize - 1 - i * 2 - j], alignmentMap[i * 2 + k]);
+          }
+        }
+      }
+      rowOffset += rowSize * 8;
+    }
+
+    // draw mode message
+    drawModeMessage(matrix, compact, matrixSize, modeMessage);
+
+    // draw alignment marks
+    if (compact) {
+      drawBullsEye(matrix, matrixSize / 2, 5);
+    } else {
+      drawBullsEye(matrix, matrixSize / 2, 7);
+      for (int i = 0, j = 0; i < baseMatrixSize / 2 - 1; i += 15, j += 16) {
+        for (int k = (matrixSize / 2) & 1; k < matrixSize; k += 2) {
+          matrix.set(matrixSize / 2 - j, k);
+          matrix.set(matrixSize / 2 + j, k);
+          matrix.set(k, matrixSize / 2 - j);
+          matrix.set(k, matrixSize / 2 + j);
+        }
+      }
+    }
+
+    AztecCode aztec = new AztecCode();
+    aztec.setCompact(compact);
+    aztec.setSize(matrixSize);
+    aztec.setLayers(layers);
+    aztec.setCodeWords(messageSizeInWords);
+    aztec.setMatrix(matrix);
+    return aztec;
+  }
+
+  private static void drawBullsEye(BitMatrix matrix, int center, int size) {
+    for (int i = 0; i < size; i += 2) {
+      for (int j = center - i; j <= center + i; j++) {
+        matrix.set(j, center - i);
+        matrix.set(j, center + i);
+        matrix.set(center - i, j);
+        matrix.set(center + i, j);
+      }
+    }
+    matrix.set(center - size, center - size);
+    matrix.set(center - size + 1, center - size);
+    matrix.set(center - size, center - size + 1);
+    matrix.set(center + size, center - size);
+    matrix.set(center + size, center - size + 1);
+    matrix.set(center + size, center + size - 1);
+  }
+
+  static BitArray generateModeMessage(boolean compact, int layers, int messageSizeInWords) {
+    BitArray modeMessage = new BitArray();
+    if (compact) {
+      modeMessage.appendBits(layers - 1, 2);
+      modeMessage.appendBits(messageSizeInWords - 1, 6);
+      modeMessage = generateCheckWords(modeMessage, 28, 4);
+    } else {
+      modeMessage.appendBits(layers - 1, 5);
+      modeMessage.appendBits(messageSizeInWords - 1, 11);
+      modeMessage = generateCheckWords(modeMessage, 40, 4);
+    }
+    return modeMessage;
+  }
+
+  private static void drawModeMessage(BitMatrix matrix, boolean compact, int matrixSize, BitArray modeMessage) {
+    int center = matrixSize / 2;
+    if (compact) {
+      for (int i = 0; i < 7; i++) {
+        int offset = center - 3 + i;
+        if (modeMessage.get(i)) {
+          matrix.set(offset, center - 5);
+        }
+        if (modeMessage.get(i + 7)) {
+          matrix.set(center + 5, offset);
+        }
+        if (modeMessage.get(20 - i)) {
+          matrix.set(offset, center + 5);
+        }
+        if (modeMessage.get(27 - i)) {
+          matrix.set(center - 5, offset);
+        }
+      }
+    } else {
+      for (int i = 0; i < 10; i++) {
+        int offset = center - 5 + i + i / 5;
+        if (modeMessage.get(i)) {
+          matrix.set(offset, center - 7);
+        }
+        if (modeMessage.get(i + 10)) {
+          matrix.set(center + 7, offset);
+        }
+        if (modeMessage.get(29 - i)) {
+          matrix.set(offset, center + 7);
+        }
+        if (modeMessage.get(39 - i)) {
+          matrix.set(center - 7, offset);
+        }
+      }
+    }
+  }
+
+  private static BitArray generateCheckWords(BitArray bitArray, int totalBits, int wordSize) {
+    // bitArray is guaranteed to be a multiple of the wordSize, so no padding needed
+    int messageSizeInWords = bitArray.getSize() / wordSize;
+    ReedSolomonEncoder rs = new ReedSolomonEncoder(getGF(wordSize));
+    int totalWords = totalBits / wordSize;
+    int[] messageWords = bitsToWords(bitArray, wordSize, totalWords);
+    rs.encode(messageWords, totalWords - messageSizeInWords);
+    int startPad = totalBits % wordSize;
+    BitArray messageBits = new BitArray();
+    messageBits.appendBits(0, startPad);
+    for (int messageWord : messageWords) {
+      messageBits.appendBits(messageWord, wordSize);
+    }
+    return messageBits;
+  }
+
+  private static int[] bitsToWords(BitArray stuffedBits, int wordSize, int totalWords) {
+    int[] message = new int[totalWords];
+    int i;
+    int n;
+    for (i = 0, n = stuffedBits.getSize() / wordSize; i < n; i++) {
+      int value = 0;
+      for (int j = 0; j < wordSize; j++) {
+        value |= stuffedBits.get(i * wordSize + j) ? (1 << wordSize - j - 1) : 0;
+      }
+      message[i] = value;
+    }
+    return message;
+  }
+
+  private static GenericGF getGF(int wordSize) {
+    switch (wordSize) {
+      case 4:
+        return GenericGF.AZTEC_PARAM;
+      case 6:
+        return GenericGF.AZTEC_DATA_6;
+      case 8:
+        return GenericGF.AZTEC_DATA_8;
+      case 10:
+        return GenericGF.AZTEC_DATA_10;
+      case 12:
+        return GenericGF.AZTEC_DATA_12;
+      default:
+        throw new IllegalArgumentException("Unsupported word size " + wordSize);
+    }
+  }
+
+  static BitArray stuffBits(BitArray bits, int wordSize) {
+    BitArray out = new BitArray();
+
+    int n = bits.getSize();
+    int mask = (1 << wordSize) - 2;
+    for (int i = 0; i < n; i += wordSize) {
+      int word = 0;
+      for (int j = 0; j < wordSize; j++) {
+        if (i + j >= n || bits.get(i + j)) {
+          word |= 1 << (wordSize - 1 - j);
+        }
+      }
+      if ((word & mask) == mask) {
+        out.appendBits(word & mask, wordSize);
+        i--;
+      } else if ((word & mask) == 0) {
+        out.appendBits(word | 1, wordSize);
+        i--;
+      } else {
+        out.appendBits(word, wordSize);
+      }
+    }
+    return out;
+  }
+
+  private static int totalBitsInLayer(int layers, boolean compact) {
+    return ((compact ? 88 : 112) + 16 * layers) * layers;
+  }
+}

src/aztec/encoder/HighLevelEncoder.java

@@ -0,0 +1,325 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.aztec.encoder;
+
+import com.google.zxing.common.BitArray;
+import com.google.zxing.common.CharacterSetECI;
+
+import java.nio.charset.Charset;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Deque;
+import java.util.Iterator;
+import java.util.LinkedList;
+
+/**
+ * This produces nearly optimal encodings of text into the first-level of
+ * encoding used by Aztec code.
+ *
+ * It uses a dynamic algorithm.  For each prefix of the string, it determines
+ * a set of encodings that could lead to this prefix.  We repeatedly add a
+ * character and generate a new set of optimal encodings until we have read
+ * through the entire input.
+ *
+ * @author Frank Yellin
+ * @author Rustam Abdullaev
+ */
+public final class HighLevelEncoder {
+
+  static final String[] MODE_NAMES = {"UPPER", "LOWER", "DIGIT", "MIXED", "PUNCT"};
+
+  static final int MODE_UPPER = 0; // 5 bits
+  static final int MODE_LOWER = 1; // 5 bits
+  static final int MODE_DIGIT = 2; // 4 bits
+  static final int MODE_MIXED = 3; // 5 bits
+  static final int MODE_PUNCT = 4; // 5 bits
+
+  // The Latch Table shows, for each pair of Modes, the optimal method for
+  // getting from one mode to another.  In the worst possible case, this can
+  // be up to 14 bits.  In the best possible case, we are already there!
+  // The high half-word of each entry gives the number of bits.
+  // The low half-word of each entry are the actual bits necessary to change
+  static final int[][] LATCH_TABLE = {
+    {
+      0,
+      (5 << 16) + 28,              // UPPER -> LOWER
+      (5 << 16) + 30,              // UPPER -> DIGIT
+      (5 << 16) + 29,              // UPPER -> MIXED
+      (10 << 16) + (29 << 5) + 30, // UPPER -> MIXED -> PUNCT
+    },
+    {
+      (9 << 16) + (30 << 4) + 14,  // LOWER -> DIGIT -> UPPER
+      0,
+      (5 << 16) + 30,              // LOWER -> DIGIT
+      (5 << 16) + 29,              // LOWER -> MIXED
+      (10 << 16) + (29 << 5) + 30, // LOWER -> MIXED -> PUNCT
+    },
+    {
+      (4 << 16) + 14,              // DIGIT -> UPPER
+      (9 << 16) + (14 << 5) + 28,  // DIGIT -> UPPER -> LOWER
+      0,
+      (9 << 16) + (14 << 5) + 29,  // DIGIT -> UPPER -> MIXED
+      (14 << 16) + (14 << 10) + (29 << 5) + 30,
+                                   // DIGIT -> UPPER -> MIXED -> PUNCT
+    },
+    {
+      (5 << 16) + 29,              // MIXED -> UPPER
+      (5 << 16) + 28,              // MIXED -> LOWER
+      (10 << 16) + (29 << 5) + 30, // MIXED -> UPPER -> DIGIT
+      0,
+      (5 << 16) + 30,              // MIXED -> PUNCT
+    },
+    {
+      (5 << 16) + 31,              // PUNCT -> UPPER
+      (10 << 16) + (31 << 5) + 28, // PUNCT -> UPPER -> LOWER
+      (10 << 16) + (31 << 5) + 30, // PUNCT -> UPPER -> DIGIT
+      (10 << 16) + (31 << 5) + 29, // PUNCT -> UPPER -> MIXED
+      0,
+    },
+  };
+
+  // A reverse mapping from [mode][char] to the encoding for that character
+  // in that mode.  An entry of 0 indicates no mapping exists.
+  private static final int[][] CHAR_MAP = new int[5][256];
+  static {
+    CHAR_MAP[MODE_UPPER][' '] = 1;
+    for (int c = 'A'; c <= 'Z'; c++) {
+      CHAR_MAP[MODE_UPPER][c] = c - 'A' + 2;
+    }
+    CHAR_MAP[MODE_LOWER][' '] = 1;
+    for (int c = 'a'; c <= 'z'; c++) {
+      CHAR_MAP[MODE_LOWER][c] = c - 'a' + 2;
+    }
+    CHAR_MAP[MODE_DIGIT][' '] = 1;
+    for (int c = '0'; c <= '9'; c++) {
+      CHAR_MAP[MODE_DIGIT][c] = c - '0' + 2;
+    }
+    CHAR_MAP[MODE_DIGIT][','] = 12;
+    CHAR_MAP[MODE_DIGIT]['.'] = 13;
+    int[] mixedTable = {
+        '\0', ' ', '\1', '\2', '\3', '\4', '\5', '\6', '\7', '\b', '\t', '\n',
+        '\13', '\f', '\r', '\33', '\34', '\35', '\36', '\37', '@', '\\', '^',
+        '_', '`', '|', '~', '\177'
+    };
+    for (int i = 0; i < mixedTable.length; i++) {
+      CHAR_MAP[MODE_MIXED][mixedTable[i]] = i;
+    }
+    int[] punctTable = {
+        '\0', '\r', '\0', '\0', '\0', '\0', '!', '\'', '#', '$', '%', '&', '\'',
+        '(', ')', '*', '+', ',', '-', '.', '/', ':', ';', '<', '=', '>', '?',
+        '[', ']', '{', '}'
+    };
+    for (int i = 0; i < punctTable.length; i++) {
+      if (punctTable[i] > 0) {
+        CHAR_MAP[MODE_PUNCT][punctTable[i]] = i;
+      }
+    }
+  }
+
+  // A map showing the available shift codes.  (The shifts to BINARY are not
+  // shown
+  static final int[][] SHIFT_TABLE = new int[6][6]; // mode shift codes, per table
+  static {
+    for (int[] table : SHIFT_TABLE) {
+      Arrays.fill(table, -1);
+    }
+    SHIFT_TABLE[MODE_UPPER][MODE_PUNCT] = 0;
+
+    SHIFT_TABLE[MODE_LOWER][MODE_PUNCT] = 0;
+    SHIFT_TABLE[MODE_LOWER][MODE_UPPER] = 28;
+
+    SHIFT_TABLE[MODE_MIXED][MODE_PUNCT] = 0;
+
+    SHIFT_TABLE[MODE_DIGIT][MODE_PUNCT] = 0;
+    SHIFT_TABLE[MODE_DIGIT][MODE_UPPER] = 15;
+  }
+
+  private final byte[] text;
+  private final Charset charset;
+
+  public HighLevelEncoder(byte[] text) {
+    this.text = text;
+    this.charset = null;
+  }
+
+  public HighLevelEncoder(byte[] text, Charset charset) {
+    this.text = text;
+    this.charset = charset;
+  }
+
+  /**
+   * @return text represented by this encoder encoded as a {@link BitArray}
+   */
+  public BitArray encode() {
+    State initialState = State.INITIAL_STATE;
+    if (charset != null) {
+      CharacterSetECI eci = CharacterSetECI.getCharacterSetECI(charset);
+      if (null == eci) {
+        throw new IllegalArgumentException("No ECI code for character set " + charset);
+      }
+      initialState = initialState.appendFLGn(eci.getValue());
+    }
+    Collection<State> states = Collections.singletonList(initialState);
+    for (int index = 0; index < text.length; index++) {
+      int pairCode;
+      int nextChar = index + 1 < text.length ? text[index + 1] : 0;
+      switch (text[index]) {
+        case '\r':
+          pairCode = nextChar == '\n' ? 2 : 0;
+          break;
+        case '.' :
+          pairCode = nextChar == ' ' ? 3 : 0;
+          break;
+        case ',' :
+          pairCode = nextChar == ' ' ? 4 : 0;
+          break;
+        case ':' :
+          pairCode = nextChar == ' ' ? 5 : 0;
+          break;
+        default:
+          pairCode = 0;
+      }
+      if (pairCode > 0) {
+        // We have one of the four special PUNCT pairs.  Treat them specially.
+        // Get a new set of states for the two new characters.
+        states = updateStateListForPair(states, index, pairCode);
+        index++;
+      } else {
+        // Get a new set of states for the new character.
+        states = updateStateListForChar(states, index);
+      }
+    }
+    // We are left with a set of states.  Find the shortest one.
+    State minState = Collections.min(states, new Comparator<State>() {
+      @Override
+      public int compare(State a, State b) {
+        return a.getBitCount() - b.getBitCount();
+      }
+    });
+    // Convert it to a bit array, and return.
+    return minState.toBitArray(text);
+  }
+
+  // We update a set of states for a new character by updating each state
+  // for the new character, merging the results, and then removing the
+  // non-optimal states.
+  private Collection<State> updateStateListForChar(Iterable<State> states, int index) {
+    Collection<State> result = new LinkedList<>();
+    for (State state : states) {
+      updateStateForChar(state, index, result);
+    }
+    return simplifyStates(result);
+  }
+
+  // Return a set of states that represent the possible ways of updating this
+  // state for the next character.  The resulting set of states are added to
+  // the "result" list.
+  private void updateStateForChar(State state, int index, Collection<State> result) {
+    char ch = (char) (text[index] & 0xFF);
+    boolean charInCurrentTable = CHAR_MAP[state.getMode()][ch] > 0;
+    State stateNoBinary = null;
+    for (int mode = 0; mode <= MODE_PUNCT; mode++) {
+      int charInMode = CHAR_MAP[mode][ch];
+      if (charInMode > 0) {
+        if (stateNoBinary == null) {
+          // Only create stateNoBinary the first time it's required.
+          stateNoBinary = state.endBinaryShift(index);
+        }
+        // Try generating the character by latching to its mode
+        if (!charInCurrentTable || mode == state.getMode() || mode == MODE_DIGIT) {
+          // If the character is in the current table, we don't want to latch to
+          // any other mode except possibly digit (which uses only 4 bits).  Any
+          // other latch would be equally successful *after* this character, and
+          // so wouldn't save any bits.
+          State latchState = stateNoBinary.latchAndAppend(mode, charInMode);
+          result.add(latchState);
+        }
+        // Try generating the character by switching to its mode.
+        if (!charInCurrentTable && SHIFT_TABLE[state.getMode()][mode] >= 0) {
+          // It never makes sense to temporarily shift to another mode if the
+          // character exists in the current mode.  That can never save bits.
+          State shiftState = stateNoBinary.shiftAndAppend(mode, charInMode);
+          result.add(shiftState);
+        }
+      }
+    }
+    if (state.getBinaryShiftByteCount() > 0 || CHAR_MAP[state.getMode()][ch] == 0) {
+      // It's never worthwhile to go into binary shift mode if you're not already
+      // in binary shift mode, and the character exists in your current mode.
+      // That can never save bits over just outputting the char in the current mode.
+      State binaryState = state.addBinaryShiftChar(index);
+      result.add(binaryState);
+    }
+  }
+
+  private static Collection<State> updateStateListForPair(Iterable<State> states, int index, int pairCode) {
+    Collection<State> result = new LinkedList<>();
+    for (State state : states) {
+      updateStateForPair(state, index, pairCode, result);
+    }
+    return simplifyStates(result);
+  }
+
+  private static void updateStateForPair(State state, int index, int pairCode, Collection<State> result) {
+    State stateNoBinary = state.endBinaryShift(index);
+    // Possibility 1.  Latch to MODE_PUNCT, and then append this code
+    result.add(stateNoBinary.latchAndAppend(MODE_PUNCT, pairCode));
+    if (state.getMode() != MODE_PUNCT) {
+      // Possibility 2.  Shift to MODE_PUNCT, and then append this code.
+      // Every state except MODE_PUNCT (handled above) can shift
+      result.add(stateNoBinary.shiftAndAppend(MODE_PUNCT, pairCode));
+    }
+    if (pairCode == 3 || pairCode == 4) {
+      // both characters are in DIGITS.  Sometimes better to just add two digits
+      State digitState = stateNoBinary
+          .latchAndAppend(MODE_DIGIT, 16 - pairCode)  // period or comma in DIGIT
+          .latchAndAppend(MODE_DIGIT, 1);             // space in DIGIT
+      result.add(digitState);
+    }
+    if (state.getBinaryShiftByteCount() > 0) {
+      // It only makes sense to do the characters as binary if we're already
+      // in binary mode.
+      State binaryState = state.addBinaryShiftChar(index).addBinaryShiftChar(index + 1);
+      result.add(binaryState);
+    }
+  }
+
+  private static Collection<State> simplifyStates(Iterable<State> states) {
+    Deque<State> result = new LinkedList<>();
+    for (State newState : states) {
+      boolean add = true;
+      for (Iterator<State> iterator = result.iterator(); iterator.hasNext();) {
+        State oldState = iterator.next();
+        if (oldState.isBetterThanOrEqualTo(newState)) {
+          add = false;
+          break;
+        }
+        if (newState.isBetterThanOrEqualTo(oldState)) {
+          iterator.remove();
+        }
+      }
+      if (add) {
+        result.addFirst(newState);
+      }
+    }
+    return result;
+  }
+
+}

src/aztec/encoder/SimpleToken.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.aztec.encoder;
+
+import com.google.zxing.common.BitArray;
+
+final class SimpleToken extends Token {
+
+  // For normal words, indicates value and bitCount
+  private final short value;
+  private final short bitCount;
+
+  SimpleToken(Token previous, int value, int bitCount) {
+    super(previous);
+    this.value = (short) value;
+    this.bitCount = (short) bitCount;
+  }
+
+  @Override
+  void appendTo(BitArray bitArray, byte[] text) {
+    bitArray.appendBits(value, bitCount);
+  }
+
+  @Override
+  public String toString() {
+    int value = this.value & ((1 << bitCount) - 1);
+    value |= 1 << bitCount;
+    return '<' + Integer.toBinaryString(value | (1 << bitCount)).substring(1) + '>';
+  }
+
+}

src/aztec/encoder/State.java

@@ -0,0 +1,195 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.aztec.encoder;
+
+import java.nio.charset.StandardCharsets;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.google.zxing.common.BitArray;
+
+/**
+ * State represents all information about a sequence necessary to generate the current output.
+ * Note that a state is immutable.
+ */
+final class State {
+
+  static final State INITIAL_STATE = new State(Token.EMPTY, HighLevelEncoder.MODE_UPPER, 0, 0);
+
+  // The current mode of the encoding (or the mode to which we'll return if
+  // we're in Binary Shift mode.
+  private final int mode;
+  // The list of tokens that we output.  If we are in Binary Shift mode, this
+  // token list does *not* yet included the token for those bytes
+  private final Token token;
+  // If non-zero, the number of most recent bytes that should be output
+  // in Binary Shift mode.
+  private final int binaryShiftByteCount;
+  // The total number of bits generated (including Binary Shift).
+  private final int bitCount;
+  private final int binaryShiftCost;
+
+  private State(Token token, int mode, int binaryBytes, int bitCount) {
+    this.token = token;
+    this.mode = mode;
+    this.binaryShiftByteCount = binaryBytes;
+    this.bitCount = bitCount;
+    this.binaryShiftCost = calculateBinaryShiftCost(binaryBytes);
+  }
+
+  int getMode() {
+    return mode;
+  }
+
+  Token getToken() {
+    return token;
+  }
+
+  int getBinaryShiftByteCount() {
+    return binaryShiftByteCount;
+  }
+
+  int getBitCount() {
+    return bitCount;
+  }
+
+  State appendFLGn(int eci) {
+    State result = shiftAndAppend(HighLevelEncoder.MODE_PUNCT, 0); // 0: FLG(n)
+    Token token = result.token;
+    int bitsAdded = 3;
+    if (eci < 0) {
+      token = token.add(0, 3); // 0: FNC1
+    } else if (eci > 999999) {
+      throw new IllegalArgumentException("ECI code must be between 0 and 999999");
+    } else {
+      byte[] eciDigits = Integer.toString(eci).getBytes(StandardCharsets.ISO_8859_1);
+      token = token.add(eciDigits.length, 3); // 1-6: number of ECI digits
+      for (byte eciDigit : eciDigits) {
+        token = token.add(eciDigit - '0' + 2, 4);
+      }
+      bitsAdded += eciDigits.length * 4;
+    }
+    return new State(token, mode, 0, bitCount + bitsAdded);
+  }
+
+  // Create a new state representing this state with a latch to a (not
+  // necessary different) mode, and then a code.
+  State latchAndAppend(int mode, int value) {
+    int bitCount = this.bitCount;
+    Token token = this.token;
+    if (mode != this.mode) {
+      int latch = HighLevelEncoder.LATCH_TABLE[this.mode][mode];
+      token = token.add(latch & 0xFFFF, latch >> 16);
+      bitCount += latch >> 16;
+    }
+    int latchModeBitCount = mode == HighLevelEncoder.MODE_DIGIT ? 4 : 5;
+    token = token.add(value, latchModeBitCount);
+    return new State(token, mode, 0, bitCount + latchModeBitCount);
+  }
+
+  // Create a new state representing this state, with a temporary shift
+  // to a different mode to output a single value.
+  State shiftAndAppend(int mode, int value) {
+    Token token = this.token;
+    int thisModeBitCount = this.mode == HighLevelEncoder.MODE_DIGIT ? 4 : 5;
+    // Shifts exist only to UPPER and PUNCT, both with tokens size 5.
+    token = token.add(HighLevelEncoder.SHIFT_TABLE[this.mode][mode], thisModeBitCount);
+    token = token.add(value, 5);
+    return new State(token, this.mode, 0, this.bitCount + thisModeBitCount + 5);
+  }
+
+  // Create a new state representing this state, but an additional character
+  // output in Binary Shift mode.
+  State addBinaryShiftChar(int index) {
+    Token token = this.token;
+    int mode = this.mode;
+    int bitCount = this.bitCount;
+    if (this.mode == HighLevelEncoder.MODE_PUNCT || this.mode == HighLevelEncoder.MODE_DIGIT) {
+      int latch = HighLevelEncoder.LATCH_TABLE[mode][HighLevelEncoder.MODE_UPPER];
+      token = token.add(latch & 0xFFFF, latch >> 16);
+      bitCount += latch >> 16;
+      mode = HighLevelEncoder.MODE_UPPER;
+    }
+    int deltaBitCount =
+        (binaryShiftByteCount == 0 || binaryShiftByteCount == 31) ? 18 :
+        (binaryShiftByteCount == 62) ? 9 : 8;
+    State result = new State(token, mode, binaryShiftByteCount + 1, bitCount + deltaBitCount);
+    if (result.binaryShiftByteCount == 2047 + 31) {
+      // The string is as long as it's allowed to be.  We should end it.
+      result = result.endBinaryShift(index + 1);
+    }
+    return result;
+  }
+
+  // Create the state identical to this one, but we are no longer in
+  // Binary Shift mode.
+  State endBinaryShift(int index) {
+    if (binaryShiftByteCount == 0) {
+      return this;
+    }
+    Token token = this.token;
+    token = token.addBinaryShift(index - binaryShiftByteCount, binaryShiftByteCount);
+    return new State(token, mode, 0, this.bitCount);
+  }
+
+  // Returns true if "this" state is better (or equal) to be in than "that"
+  // state under all possible circumstances.
+  boolean isBetterThanOrEqualTo(State other) {
+    int newModeBitCount = this.bitCount + (HighLevelEncoder.LATCH_TABLE[this.mode][other.mode] >> 16);
+    if (this.binaryShiftByteCount < other.binaryShiftByteCount) {
+      // add additional B/S encoding cost of other, if any
+      newModeBitCount += other.binaryShiftCost - this.binaryShiftCost;
+    } else if (this.binaryShiftByteCount > other.binaryShiftByteCount && other.binaryShiftByteCount > 0) {
+      // maximum possible additional cost (we end up exceeding the 31 byte boundary and other state can stay beneath it)
+      newModeBitCount += 10;
+    }
+    return newModeBitCount <= other.bitCount;
+  }
+
+  BitArray toBitArray(byte[] text) {
+    List<Token> symbols = new ArrayList<>();
+    for (Token token = endBinaryShift(text.length).token; token != null; token = token.getPrevious()) {
+      symbols.add(token);
+    }
+    BitArray bitArray = new BitArray();
+    // Add each token to the result in forward order
+    for (int i = symbols.size() - 1; i >= 0; i--) {
+      symbols.get(i).appendTo(bitArray, text);
+    }
+    return bitArray;
+  }
+
+  @Override
+  public String toString() {
+    return String.format("%s bits=%d bytes=%d", HighLevelEncoder.MODE_NAMES[mode], bitCount, binaryShiftByteCount);
+  }
+
+  private static int calculateBinaryShiftCost(int binaryShiftByteCount) {
+    if (binaryShiftByteCount > 62) {
+      return 21; // B/S with extended length
+    }
+    if (binaryShiftByteCount > 31) {
+      return 20; // two B/S
+    }
+    if (binaryShiftByteCount > 0) {
+      return 10; // one B/S
+    }
+    return 0;
+  }
+
+}

src/aztec/encoder/Token.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2013 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.aztec.encoder;
+
+import com.google.zxing.common.BitArray;
+
+abstract class Token {
+
+  static final Token EMPTY = new SimpleToken(null, 0, 0);
+
+  private final Token previous;
+
+  Token(Token previous) {
+    this.previous = previous;
+  }
+
+  final Token getPrevious() {
+    return previous;
+  }
+
+  final Token add(int value, int bitCount) {
+    return new SimpleToken(this, value, bitCount);
+  }
+
+  final Token addBinaryShift(int start, int byteCount) {
+    //int bitCount = (byteCount * 8) + (byteCount <= 31 ? 10 : byteCount <= 62 ? 20 : 21);
+    return new BinaryShiftToken(this, start, byteCount);
+  }
+
+  abstract void appendTo(BitArray bitArray, byte[] text);
+
+}

src/client/result/AbstractDoCoMoResultParser.java

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+/**
+ * <p>See
+ * <a href="http://www.nttdocomo.co.jp/english/service/imode/make/content/barcode/about/s2.html">
+ * DoCoMo's documentation</a> about the result types represented by subclasses of this class.</p>
+ *
+ * <p>Thanks to Jeff Griffin for proposing rewrite of these classes that relies less
+ * on exception-based mechanisms during parsing.</p>
+ *
+ * @author Sean Owen
+ */
+abstract class AbstractDoCoMoResultParser extends ResultParser {
+
+  static String[] matchDoCoMoPrefixedField(String prefix, String rawText) {
+    return matchPrefixedField(prefix, rawText, ';', true);
+  }
+
+  static String matchSingleDoCoMoPrefixedField(String prefix, String rawText, boolean trim) {
+    return matchSinglePrefixedField(prefix, rawText, ';', trim);
+  }
+
+}

src/client/result/AddressBookAUResultParser.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+import com.google.zxing.Result;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Implements KDDI AU's address book format. See
+ * <a href="http://www.au.kddi.com/ezfactory/tec/two_dimensions/index.html">
+ * http://www.au.kddi.com/ezfactory/tec/two_dimensions/index.html</a>.
+ * (Thanks to Yuzo for translating!)
+ *
+ * @author Sean Owen
+ */
+public final class AddressBookAUResultParser extends ResultParser {
+
+  @Override
+  public AddressBookParsedResult parse(Result result) {
+    String rawText = getMassagedText(result);
+    // MEMORY is mandatory; seems like a decent indicator, as does end-of-record separator CR/LF
+    if (!rawText.contains("MEMORY") || !rawText.contains("\r\n")) {
+      return null;
+    }
+
+    // NAME1 and NAME2 have specific uses, namely written name and pronunciation, respectively.
+    // Therefore we treat them specially instead of as an array of names.
+    String name = matchSinglePrefixedField("NAME1:", rawText, '\r', true);
+    String pronunciation = matchSinglePrefixedField("NAME2:", rawText, '\r', true);
+
+    String[] phoneNumbers = matchMultipleValuePrefix("TEL", rawText);
+    String[] emails = matchMultipleValuePrefix("MAIL", rawText);
+    String note = matchSinglePrefixedField("MEMORY:", rawText, '\r', false);
+    String address = matchSinglePrefixedField("ADD:", rawText, '\r', true);
+    String[] addresses = address == null ? null : new String[] {address};
+    return new AddressBookParsedResult(maybeWrap(name),
+                                       null,
+                                       pronunciation,
+                                       phoneNumbers,
+                                       null,
+                                       emails,
+                                       null,
+                                       null,
+                                       note,
+                                       addresses,
+                                       null,
+                                       null,
+                                       null,
+                                       null,
+                                       null,
+                                       null);
+  }
+
+  private static String[] matchMultipleValuePrefix(String prefix, String rawText) {
+    List<String> values = null;
+    // For now, always 3, and always trim
+    for (int i = 1; i <= 3; i++) {
+      String value = matchSinglePrefixedField(prefix + i + ':', rawText, '\r', true);
+      if (value == null) {
+        break;
+      }
+      if (values == null) {
+        values = new ArrayList<>(3); // lazy init
+      }
+      values.add(value);
+    }
+    if (values == null) {
+      return null;
+    }
+    return values.toArray(EMPTY_STR_ARRAY);
+  }
+
+}

src/client/result/AddressBookDoCoMoResultParser.java

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+import com.google.zxing.Result;
+
+/**
+ * Implements the "MECARD" address book entry format.
+ *
+ * Supported keys: N, SOUND, TEL, EMAIL, NOTE, ADR, BDAY, URL, plus ORG
+ * Unsupported keys: TEL-AV, NICKNAME
+ *
+ * Except for TEL, multiple values for keys are also not supported;
+ * the first one found takes precedence.
+ *
+ * Our understanding of the MECARD format is based on this document:
+ *
+ * http://www.mobicode.org.tw/files/OMIA%20Mobile%20Bar%20Code%20Standard%20v3.2.1.doc
+ *
+ * @author Sean Owen
+ */
+public final class AddressBookDoCoMoResultParser extends AbstractDoCoMoResultParser {
+
+  @Override
+  public AddressBookParsedResult parse(Result result) {
+    String rawText = getMassagedText(result);
+    if (!rawText.startsWith("MECARD:")) {
+      return null;
+    }
+    String[] rawName = matchDoCoMoPrefixedField("N:", rawText);
+    if (rawName == null) {
+      return null;
+    }
+    String name = parseName(rawName[0]);
+    String pronunciation = matchSingleDoCoMoPrefixedField("SOUND:", rawText, true);
+    String[] phoneNumbers = matchDoCoMoPrefixedField("TEL:", rawText);
+    String[] emails = matchDoCoMoPrefixedField("EMAIL:", rawText);
+    String note = matchSingleDoCoMoPrefixedField("NOTE:", rawText, false);
+    String[] addresses = matchDoCoMoPrefixedField("ADR:", rawText);
+    String birthday = matchSingleDoCoMoPrefixedField("BDAY:", rawText, true);
+    if (!isStringOfDigits(birthday, 8)) {
+      // No reason to throw out the whole card because the birthday is formatted wrong.
+      birthday = null;
+    }
+    String[] urls = matchDoCoMoPrefixedField("URL:", rawText);
+
+    // Although ORG may not be strictly legal in MECARD, it does exist in VCARD and we might as well
+    // honor it when found in the wild.
+    String org = matchSingleDoCoMoPrefixedField("ORG:", rawText, true);
+
+    return new AddressBookParsedResult(maybeWrap(name),
+                                       null,
+                                       pronunciation,
+                                       phoneNumbers,
+                                       null,
+                                       emails,
+                                       null,
+                                       null,
+                                       note,
+                                       addresses,
+                                       null,
+                                       org,
+                                       birthday,
+                                       null,
+                                       urls,
+                                       null);
+  }
+
+  private static String parseName(String name) {
+    int comma = name.indexOf(',');
+    if (comma >= 0) {
+      // Format may be last,first; switch it around
+      return name.substring(comma + 1) + ' ' + name.substring(0, comma);
+    }
+    return name;
+  }
+
+}

src/client/result/AddressBookParsedResult.java

@@ -0,0 +1,220 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+/**
+ * Represents a parsed result that encodes contact information, like that in an address book
+ * entry.
+ *
+ * @author Sean Owen
+ */
+public final class AddressBookParsedResult extends ParsedResult {
+
+  private final String[] names;
+  private final String[] nicknames;
+  private final String pronunciation;
+  private final String[] phoneNumbers;
+  private final String[] phoneTypes;
+  private final String[] emails;
+  private final String[] emailTypes;
+  private final String instantMessenger;
+  private final String note;
+  private final String[] addresses;
+  private final String[] addressTypes;
+  private final String org;
+  private final String birthday;
+  private final String title;
+  private final String[] urls;
+  private final String[] geo;
+
+  public AddressBookParsedResult(String[] names,
+                                 String[] phoneNumbers,
+                                 String[] phoneTypes,
+                                 String[] emails,
+                                 String[] emailTypes,
+                                 String[] addresses,
+                                 String[] addressTypes) {
+    this(names,
+         null,
+         null,
+         phoneNumbers,
+         phoneTypes,
+         emails,
+         emailTypes,
+         null,
+         null,
+         addresses,
+         addressTypes,
+         null,
+         null,
+         null,
+         null,
+         null);
+  }
+
+  public AddressBookParsedResult(String[] names,
+                                 String[] nicknames,
+                                 String pronunciation,
+                                 String[] phoneNumbers,
+                                 String[] phoneTypes,
+                                 String[] emails,
+                                 String[] emailTypes,
+                                 String instantMessenger,
+                                 String note,
+                                 String[] addresses,
+                                 String[] addressTypes,
+                                 String org,
+                                 String birthday,
+                                 String title,
+                                 String[] urls,
+                                 String[] geo) {
+    super(ParsedResultType.ADDRESSBOOK);
+    if (phoneNumbers != null && phoneTypes != null && phoneNumbers.length != phoneTypes.length) {
+      throw new IllegalArgumentException("Phone numbers and types lengths differ");
+    }
+    if (emails != null && emailTypes != null && emails.length != emailTypes.length) {
+      throw new IllegalArgumentException("Emails and types lengths differ");
+    }
+    if (addresses != null && addressTypes != null && addresses.length != addressTypes.length) {
+      throw new IllegalArgumentException("Addresses and types lengths differ");
+    }
+    this.names = names;
+    this.nicknames = nicknames;
+    this.pronunciation = pronunciation;
+    this.phoneNumbers = phoneNumbers;
+    this.phoneTypes = phoneTypes;
+    this.emails = emails;
+    this.emailTypes = emailTypes;
+    this.instantMessenger = instantMessenger;
+    this.note = note;
+    this.addresses = addresses;
+    this.addressTypes = addressTypes;
+    this.org = org;
+    this.birthday = birthday;
+    this.title = title;
+    this.urls = urls;
+    this.geo = geo;
+  }
+
+  public String[] getNames() {
+    return names;
+  }
+
+  public String[] getNicknames() {
+    return nicknames;
+  }
+
+  /**
+   * In Japanese, the name is written in kanji, which can have multiple readings. Therefore a hint
+   * is often provided, called furigana, which spells the name phonetically.
+   *
+   * @return The pronunciation of the getNames() field, often in hiragana or katakana.
+   */
+  public String getPronunciation() {
+    return pronunciation;
+  }
+
+  public String[] getPhoneNumbers() {
+    return phoneNumbers;
+  }
+
+  /**
+   * @return optional descriptions of the type of each phone number. It could be like "HOME", but,
+   *  there is no guaranteed or standard format.
+   */
+  public String[] getPhoneTypes() {
+    return phoneTypes;
+  }
+
+  public String[] getEmails() {
+    return emails;
+  }
+
+  /**
+   * @return optional descriptions of the type of each e-mail. It could be like "WORK", but,
+   *  there is no guaranteed or standard format.
+   */
+  public String[] getEmailTypes() {
+    return emailTypes;
+  }
+  
+  public String getInstantMessenger() {
+    return instantMessenger;
+  }
+
+  public String getNote() {
+    return note;
+  }
+
+  public String[] getAddresses() {
+    return addresses;
+  }
+
+  /**
+   * @return optional descriptions of the type of each e-mail. It could be like "WORK", but,
+   *  there is no guaranteed or standard format.
+   */
+  public String[] getAddressTypes() {
+    return addressTypes;
+  }
+
+  public String getTitle() {
+    return title;
+  }
+
+  public String getOrg() {
+    return org;
+  }
+
+  public String[] getURLs() {
+    return urls;
+  }
+
+  /**
+   * @return birthday formatted as yyyyMMdd (e.g. 19780917)
+   */
+  public String getBirthday() {
+    return birthday;
+  }
+
+  /**
+   * @return a location as a latitude/longitude pair
+   */
+  public String[] getGeo() {
+    return geo;
+  }
+
+  @Override
+  public String getDisplayResult() {
+    StringBuilder result = new StringBuilder(100);
+    maybeAppend(names, result);
+    maybeAppend(nicknames, result);
+    maybeAppend(pronunciation, result);
+    maybeAppend(title, result);
+    maybeAppend(org, result);
+    maybeAppend(addresses, result);
+    maybeAppend(phoneNumbers, result);
+    maybeAppend(emails, result);
+    maybeAppend(instantMessenger, result);
+    maybeAppend(urls, result);
+    maybeAppend(birthday, result);
+    maybeAppend(geo, result);
+    maybeAppend(note, result);
+    return result.toString();
+  }
+
+}

src/client/result/BizcardResultParser.java

@@ -0,0 +1,100 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+import com.google.zxing.Result;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Implements the "BIZCARD" address book entry format, though this has been
+ * largely reverse-engineered from examples observed in the wild -- still
+ * looking for a definitive reference.
+ *
+ * @author Sean Owen
+ */
+public final class BizcardResultParser extends AbstractDoCoMoResultParser {
+
+  // Yes, we extend AbstractDoCoMoResultParser since the format is very much
+  // like the DoCoMo MECARD format, but this is not technically one of
+  // DoCoMo's proposed formats
+
+  @Override
+  public AddressBookParsedResult parse(Result result) {
+    String rawText = getMassagedText(result);
+    if (!rawText.startsWith("BIZCARD:")) {
+      return null;
+    }
+    String firstName = matchSingleDoCoMoPrefixedField("N:", rawText, true);
+    String lastName = matchSingleDoCoMoPrefixedField("X:", rawText, true);
+    String fullName = buildName(firstName, lastName);
+    String title = matchSingleDoCoMoPrefixedField("T:", rawText, true);
+    String org = matchSingleDoCoMoPrefixedField("C:", rawText, true);
+    String[] addresses = matchDoCoMoPrefixedField("A:", rawText);
+    String phoneNumber1 = matchSingleDoCoMoPrefixedField("B:", rawText, true);
+    String phoneNumber2 = matchSingleDoCoMoPrefixedField("M:", rawText, true);
+    String phoneNumber3 = matchSingleDoCoMoPrefixedField("F:", rawText, true);
+    String email = matchSingleDoCoMoPrefixedField("E:", rawText, true);
+
+    return new AddressBookParsedResult(maybeWrap(fullName),
+                                       null,
+                                       null,
+                                       buildPhoneNumbers(phoneNumber1, phoneNumber2, phoneNumber3),
+                                       null,
+                                       maybeWrap(email),
+                                       null,
+                                       null,
+                                       null,
+                                       addresses,
+                                       null,
+                                       org,
+                                       null,
+                                       title,
+                                       null,
+                                       null);
+  }
+
+  private static String[] buildPhoneNumbers(String number1,
+                                            String number2,
+                                            String number3) {
+    List<String> numbers = new ArrayList<>(3);
+    if (number1 != null) {
+      numbers.add(number1);
+    }
+    if (number2 != null) {
+      numbers.add(number2);
+    }
+    if (number3 != null) {
+      numbers.add(number3);
+    }
+    int size = numbers.size();
+    if (size == 0) {
+      return null;
+    }
+    return numbers.toArray(new String[size]);
+  }
+
+  private static String buildName(String firstName, String lastName) {
+    if (firstName == null) {
+      return lastName;
+    } else {
+      return lastName == null ? firstName : firstName + ' ' + lastName;
+    }
+  }
+
+}

src/client/result/BookmarkDoCoMoResultParser.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+import com.google.zxing.Result;
+
+/**
+ * @author Sean Owen
+ */
+public final class BookmarkDoCoMoResultParser extends AbstractDoCoMoResultParser {
+
+  @Override
+  public URIParsedResult parse(Result result) {
+    String rawText = result.getText();
+    if (!rawText.startsWith("MEBKM:")) {
+      return null;
+    }
+    String title = matchSingleDoCoMoPrefixedField("TITLE:", rawText, true);
+    String[] rawUri = matchDoCoMoPrefixedField("URL:", rawText);
+    if (rawUri == null) {
+      return null;
+    }
+    String uri = rawUri[0];
+    return URIResultParser.isBasicallyValidURI(uri) ? new URIParsedResult(uri, title) : null;
+  }
+
+}

src/client/result/CalendarParsedResult.java

@@ -0,0 +1,259 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.Locale;
+import java.util.TimeZone;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Represents a parsed result that encodes a calendar event at a certain time, optionally
+ * with attendees and a location.
+ *
+ * @author Sean Owen
+ */
+public final class CalendarParsedResult extends ParsedResult {
+
+  private static final Pattern RFC2445_DURATION =
+      Pattern.compile("P(?:(\\d+)W)?(?:(\\d+)D)?(?:T(?:(\\d+)H)?(?:(\\d+)M)?(?:(\\d+)S)?)?");
+  private static final long[] RFC2445_DURATION_FIELD_UNITS = {
+      7 * 24 * 60 * 60 * 1000L, // 1 week
+      24 * 60 * 60 * 1000L, // 1 day
+      60 * 60 * 1000L, // 1 hour
+      60 * 1000L, // 1 minute
+      1000L, // 1 second
+  };
+
+  private static final Pattern DATE_TIME = Pattern.compile("[0-9]{8}(T[0-9]{6}Z?)?");
+
+  private final String summary;
+  private final long start;
+  private final boolean startAllDay;
+  private final long end;
+  private final boolean endAllDay;
+  private final String location;
+  private final String organizer;
+  private final String[] attendees;
+  private final String description;
+  private final double latitude;
+  private final double longitude;
+
+  public CalendarParsedResult(String summary,
+                              String startString,
+                              String endString,
+                              String durationString,
+                              String location,
+                              String organizer,
+                              String[] attendees,
+                              String description,
+                              double latitude,
+                              double longitude) {
+    super(ParsedResultType.CALENDAR);
+    this.summary = summary;
+
+    try {
+      this.start = parseDate(startString);
+    } catch (ParseException pe) {
+      throw new IllegalArgumentException(pe.toString());
+    }
+
+    if (endString == null) {
+      long durationMS = parseDurationMS(durationString);
+      end = durationMS < 0L ? -1L : start + durationMS;
+    } else {
+      try {
+        this.end = parseDate(endString);
+      } catch (ParseException pe) {
+        throw new IllegalArgumentException(pe.toString());
+      }
+    }
+
+    this.startAllDay = startString.length() == 8;
+    this.endAllDay = endString != null && endString.length() == 8;
+
+    this.location = location;
+    this.organizer = organizer;
+    this.attendees = attendees;
+    this.description = description;
+    this.latitude = latitude;
+    this.longitude = longitude;
+  }
+
+  public String getSummary() {
+    return summary;
+  }
+
+  /**
+   * @return start time
+   * @deprecated use {@link #getStartTimestamp()}
+   */
+  @Deprecated
+  public Date getStart() {
+    return new Date(start);
+  }
+
+  /**
+   * @return start time
+   * @see #getEndTimestamp()
+   */
+  public long getStartTimestamp() {
+    return start;
+  }
+
+  /**
+   * @return true if start time was specified as a whole day
+   */
+  public boolean isStartAllDay() {
+    return startAllDay;
+  }
+
+  /**
+   * @return event end {@link Date}, or {@code null} if event has no duration
+   * @deprecated use {@link #getEndTimestamp()}
+   */
+  @Deprecated
+  public Date getEnd() {
+    return end < 0L ? null : new Date(end);
+  }
+
+  /**
+   * @return event end {@link Date}, or -1 if event has no duration
+   * @see #getStartTimestamp()
+   */
+  public long getEndTimestamp() {
+    return end;
+  }
+
+  /**
+   * @return true if end time was specified as a whole day
+   */
+  public boolean isEndAllDay() {
+    return endAllDay;
+  }
+
+  public String getLocation() {
+    return location;
+  }
+
+  public String getOrganizer() {
+    return organizer;
+  }
+
+  public String[] getAttendees() {
+    return attendees;
+  }
+
+  public String getDescription() {
+    return description;
+  }
+
+  public double getLatitude() {
+    return latitude;
+  }
+
+  public double getLongitude() {
+    return longitude;
+  }
+
+  @Override
+  public String getDisplayResult() {
+    StringBuilder result = new StringBuilder(100);
+    maybeAppend(summary, result);
+    maybeAppend(format(startAllDay, start), result);
+    maybeAppend(format(endAllDay, end), result);
+    maybeAppend(location, result);
+    maybeAppend(organizer, result);
+    maybeAppend(attendees, result);
+    maybeAppend(description, result);
+    return result.toString();
+  }
+
+  /**
+   * Parses a string as a date. RFC 2445 allows the start and end fields to be of type DATE (e.g. 20081021)
+   * or DATE-TIME (e.g. 20081021T123000 for local time, or 20081021T123000Z for UTC).
+   *
+   * @param when The string to parse
+   * @throws ParseException if not able to parse as a date
+   */
+  private static long parseDate(String when) throws ParseException {
+    if (!DATE_TIME.matcher(when).matches()) {
+      throw new ParseException(when, 0);
+    }
+    if (when.length() == 8) {
+      // Show only year/month/day
+      DateFormat format = new SimpleDateFormat("yyyyMMdd", Locale.ENGLISH);
+      // For dates without a time, for purposes of interacting with Android, the resulting timestamp
+      // needs to be midnight of that day in GMT. See:
+      // http://code.google.com/p/android/issues/detail?id=8330
+      format.setTimeZone(TimeZone.getTimeZone("GMT"));
+      return format.parse(when).getTime();
+    }
+    // The when string can be local time, or UTC if it ends with a Z
+    if (when.length() == 16 && when.charAt(15) == 'Z') {
+      long milliseconds = parseDateTimeString(when.substring(0, 15));
+      Calendar calendar = new GregorianCalendar();
+      // Account for time zone difference
+      milliseconds += calendar.get(Calendar.ZONE_OFFSET);
+      // Might need to correct for daylight savings time, but use target time since
+      // now might be in DST but not then, or vice versa
+      calendar.setTime(new Date(milliseconds));
+      return milliseconds + calendar.get(Calendar.DST_OFFSET);
+    }
+    return parseDateTimeString(when);
+  }
+
+  private static String format(boolean allDay, long date) {
+    if (date < 0L) {
+      return null;
+    }
+    DateFormat format = allDay
+        ? DateFormat.getDateInstance(DateFormat.MEDIUM)
+        : DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM);
+    return format.format(date);
+  }
+
+  private static long parseDurationMS(CharSequence durationString) {
+    if (durationString == null) {
+      return -1L;
+    }
+    Matcher m = RFC2445_DURATION.matcher(durationString);
+    if (!m.matches()) {
+      return -1L;
+    }
+    long durationMS = 0L;
+    for (int i = 0; i < RFC2445_DURATION_FIELD_UNITS.length; i++) {
+      String fieldValue = m.group(i + 1);
+      if (fieldValue != null) {
+        durationMS += RFC2445_DURATION_FIELD_UNITS[i] * Integer.parseInt(fieldValue);
+      }
+    }
+    return durationMS;
+  }
+
+  private static long parseDateTimeString(String dateTimeString) throws ParseException {
+    DateFormat format = new SimpleDateFormat("yyyyMMdd'T'HHmmss", Locale.ENGLISH);
+    return format.parse(dateTimeString).getTime();
+  }
+
+}

src/client/result/EmailAddressParsedResult.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+/**
+ * Represents a parsed result that encodes an email message including recipients, subject
+ * and body text.
+ *
+ * @author Sean Owen
+ */
+public final class EmailAddressParsedResult extends ParsedResult {
+
+  private final String[] tos;
+  private final String[] ccs;
+  private final String[] bccs;
+  private final String subject;
+  private final String body;
+
+  EmailAddressParsedResult(String to) {
+    this(new String[] {to}, null, null, null, null);
+  }
+
+  EmailAddressParsedResult(String[] tos,
+                           String[] ccs,
+                           String[] bccs,
+                           String subject,
+                           String body) {
+    super(ParsedResultType.EMAIL_ADDRESS);
+    this.tos = tos;
+    this.ccs = ccs;
+    this.bccs = bccs;
+    this.subject = subject;
+    this.body = body;
+  }
+
+  /**
+   * @return first elements of {@link #getTos()} or {@code null} if none
+   * @deprecated use {@link #getTos()}
+   */
+  @Deprecated
+  public String getEmailAddress() {
+    return tos == null || tos.length == 0 ? null : tos[0];
+  }
+
+  public String[] getTos() {
+    return tos;
+  }
+
+  public String[] getCCs() {
+    return ccs;
+  }
+
+  public String[] getBCCs() {
+    return bccs;
+  }
+
+  public String getSubject() {
+    return subject;
+  }
+
+  public String getBody() {
+    return body;
+  }
+
+  /**
+   * @return "mailto:"
+   * @deprecated without replacement
+   */
+  @Deprecated
+  public String getMailtoURI() {
+    return "mailto:";
+  }
+
+  @Override
+  public String getDisplayResult() {
+    StringBuilder result = new StringBuilder(30);
+    maybeAppend(tos, result);
+    maybeAppend(ccs, result);
+    maybeAppend(bccs, result);
+    maybeAppend(subject, result);
+    maybeAppend(body, result);
+    return result.toString();
+  }
+
+}

src/client/result/EmailAddressResultParser.java

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+import com.google.zxing.Result;
+
+import java.util.Map;
+import java.util.regex.Pattern;
+
+/**
+ * Represents a result that encodes an e-mail address, either as a plain address
+ * like "joe@example.org" or a mailto: URL like "mailto:joe@example.org".
+ *
+ * @author Sean Owen
+ */
+public final class EmailAddressResultParser extends ResultParser {
+
+  private static final Pattern COMMA = Pattern.compile(",");
+
+  @Override
+  public EmailAddressParsedResult parse(Result result) {
+    String rawText = getMassagedText(result);
+    if (rawText.startsWith("mailto:") || rawText.startsWith("MAILTO:")) {
+      // If it starts with mailto:, assume it is definitely trying to be an email address
+      String hostEmail = rawText.substring(7);
+      int queryStart = hostEmail.indexOf('?');
+      if (queryStart >= 0) {
+        hostEmail = hostEmail.substring(0, queryStart);
+      }
+      try {
+        hostEmail = urlDecode(hostEmail);
+      } catch (IllegalArgumentException iae) {
+        return null;
+      }
+      String[] tos = null;
+      if (!hostEmail.isEmpty()) {
+        tos = COMMA.split(hostEmail);
+      }
+      Map<String,String> nameValues = parseNameValuePairs(rawText);
+      String[] ccs = null;
+      String[] bccs = null;
+      String subject = null;
+      String body = null;
+      if (nameValues != null) {
+        if (tos == null) {
+          String tosString = nameValues.get("to");
+          if (tosString != null) {
+            tos = COMMA.split(tosString);
+          }
+        }
+        String ccString = nameValues.get("cc");
+        if (ccString != null) {
+          ccs = COMMA.split(ccString);
+        }
+        String bccString = nameValues.get("bcc");
+        if (bccString != null) {
+          bccs = COMMA.split(bccString);
+        }
+        subject = nameValues.get("subject");
+        body = nameValues.get("body");
+      }
+      return new EmailAddressParsedResult(tos, ccs, bccs, subject, body);
+    } else {
+      if (!EmailDoCoMoResultParser.isBasicallyValidEmailAddress(rawText)) {
+        return null;
+      }
+      return new EmailAddressParsedResult(rawText);
+    }
+  }
+
+}

src/client/result/EmailDoCoMoResultParser.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+import com.google.zxing.Result;
+
+import java.util.regex.Pattern;
+
+/**
+ * Implements the "MATMSG" email message entry format.
+ *
+ * Supported keys: TO, SUB, BODY
+ *
+ * @author Sean Owen
+ */
+public final class EmailDoCoMoResultParser extends AbstractDoCoMoResultParser {
+
+  private static final Pattern ATEXT_ALPHANUMERIC = Pattern.compile("[a-zA-Z0-9@.!#$%&'*+\\-/=?^_`{|}~]+");
+
+  @Override
+  public EmailAddressParsedResult parse(Result result) {
+    String rawText = getMassagedText(result);
+    if (!rawText.startsWith("MATMSG:")) {
+      return null;
+    }
+    String[] tos = matchDoCoMoPrefixedField("TO:", rawText);
+    if (tos == null) {
+      return null;
+    }
+    for (String to : tos) {
+      if (!isBasicallyValidEmailAddress(to)) {
+        return null;
+      }
+    }
+    String subject = matchSingleDoCoMoPrefixedField("SUB:", rawText, false);
+    String body = matchSingleDoCoMoPrefixedField("BODY:", rawText, false);
+    return new EmailAddressParsedResult(tos, null, null, subject, body);
+  }
+
+  /**
+   * This implements only the most basic checking for an email address's validity -- that it contains
+   * an '@' and contains no characters disallowed by RFC 2822. This is an overly lenient definition of
+   * validity. We want to generally be lenient here since this class is only intended to encapsulate what's
+   * in a barcode, not "judge" it.
+   */
+  static boolean isBasicallyValidEmailAddress(String email) {
+    return email != null && ATEXT_ALPHANUMERIC.matcher(email).matches() && email.indexOf('@') >= 0;
+  }
+
+}

src/client/result/ExpandedProductParsedResult.java

@@ -0,0 +1,199 @@
+/*
+ * Copyright (C) 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * These authors would like to acknowledge the Spanish Ministry of Industry,
+ * Tourism and Trade, for the support in the project TSI020301-2008-2
+ * "PIRAmIDE: Personalizable Interactions with Resources on AmI-enabled
+ * Mobile Dynamic Environments", led by Treelogic
+ * ( http://www.treelogic.com/ ):
+ *
+ *   http://www.piramidepse.com/
+ */
+
+package com.google.zxing.client.result;
+
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Represents a parsed result that encodes extended product information as encoded
+ * by the RSS format, like weight, price, dates, etc.
+ *
+ * @author Antonio Manuel Benjumea Conde, Servinform, S.A.
+ * @author Agustín Delgado, Servinform, S.A.
+ */
+public final class ExpandedProductParsedResult extends ParsedResult {
+
+  public static final String KILOGRAM = "KG";
+  public static final String POUND = "LB";
+
+  private final String rawText;
+  private final String productID;
+  private final String sscc;
+  private final String lotNumber;
+  private final String productionDate;
+  private final String packagingDate;
+  private final String bestBeforeDate;
+  private final String expirationDate;
+  private final String weight;
+  private final String weightType;
+  private final String weightIncrement;
+  private final String price;
+  private final String priceIncrement;
+  private final String priceCurrency;
+  // For AIS that not exist in this object
+  private final Map<String,String> uncommonAIs;
+
+  public ExpandedProductParsedResult(String rawText,
+                                     String productID,
+                                     String sscc,
+                                     String lotNumber,
+                                     String productionDate,
+                                     String packagingDate,
+                                     String bestBeforeDate,
+                                     String expirationDate,
+                                     String weight,
+                                     String weightType,
+                                     String weightIncrement,
+                                     String price,
+                                     String priceIncrement,
+                                     String priceCurrency,
+                                     Map<String,String> uncommonAIs) {
+    super(ParsedResultType.PRODUCT);
+    this.rawText = rawText;
+    this.productID = productID;
+    this.sscc = sscc;
+    this.lotNumber = lotNumber;
+    this.productionDate = productionDate;
+    this.packagingDate = packagingDate;
+    this.bestBeforeDate = bestBeforeDate;
+    this.expirationDate = expirationDate;
+    this.weight = weight;
+    this.weightType = weightType;
+    this.weightIncrement = weightIncrement;
+    this.price = price;
+    this.priceIncrement = priceIncrement;
+    this.priceCurrency = priceCurrency;
+    this.uncommonAIs = uncommonAIs;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (!(o instanceof ExpandedProductParsedResult)) {
+      return false;
+    }
+
+    ExpandedProductParsedResult other = (ExpandedProductParsedResult) o;
+
+    return Objects.equals(productID, other.productID)
+        && Objects.equals(sscc, other.sscc)
+        && Objects.equals(lotNumber, other.lotNumber)
+        && Objects.equals(productionDate, other.productionDate)
+        && Objects.equals(bestBeforeDate, other.bestBeforeDate)
+        && Objects.equals(expirationDate, other.expirationDate)
+        && Objects.equals(weight, other.weight)
+        && Objects.equals(weightType, other.weightType)
+        && Objects.equals(weightIncrement, other.weightIncrement)
+        && Objects.equals(price, other.price)
+        && Objects.equals(priceIncrement, other.priceIncrement)
+        && Objects.equals(priceCurrency, other.priceCurrency)
+        && Objects.equals(uncommonAIs, other.uncommonAIs);
+  }
+
+  @Override
+  public int hashCode() {
+    int hash = Objects.hashCode(productID);
+    hash ^= Objects.hashCode(sscc);
+    hash ^= Objects.hashCode(lotNumber);
+    hash ^= Objects.hashCode(productionDate);
+    hash ^= Objects.hashCode(bestBeforeDate);
+    hash ^= Objects.hashCode(expirationDate);
+    hash ^= Objects.hashCode(weight);
+    hash ^= Objects.hashCode(weightType);
+    hash ^= Objects.hashCode(weightIncrement);
+    hash ^= Objects.hashCode(price);
+    hash ^= Objects.hashCode(priceIncrement);
+    hash ^= Objects.hashCode(priceCurrency);
+    hash ^= Objects.hashCode(uncommonAIs);
+    return hash;
+  }
+
+  public String getRawText() {
+    return rawText;
+  }
+
+  public String getProductID() {
+    return productID;
+  }
+
+  public String getSscc() {
+    return sscc;
+  }
+
+  public String getLotNumber() {
+    return lotNumber;
+  }
+
+  public String getProductionDate() {
+    return productionDate;
+  }
+
+  public String getPackagingDate() {
+    return packagingDate;
+  }
+
+  public String getBestBeforeDate() {
+    return bestBeforeDate;
+  }
+
+  public String getExpirationDate() {
+    return expirationDate;
+  }
+
+  public String getWeight() {
+    return weight;
+  }
+
+  public String getWeightType() {
+    return weightType;
+  }
+
+  public String getWeightIncrement() {
+    return weightIncrement;
+  }
+
+  public String getPrice() {
+    return price;
+  }
+
+  public String getPriceIncrement() {
+    return priceIncrement;
+  }
+
+  public String getPriceCurrency() {
+    return priceCurrency;
+  }
+
+  public Map<String,String> getUncommonAIs() {
+    return uncommonAIs;
+  }
+
+  @Override
+  public String getDisplayResult() {
+    return String.valueOf(rawText);
+  }
+}

src/client/result/ExpandedProductResultParser.java

@@ -0,0 +1,217 @@
+/*
+ * Copyright (C) 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * These authors would like to acknowledge the Spanish Ministry of Industry,
+ * Tourism and Trade, for the support in the project TSI020301-2008-2
+ * "PIRAmIDE: Personalizable Interactions with Resources on AmI-enabled
+ * Mobile Dynamic Environments", led by Treelogic
+ * ( http://www.treelogic.com/ ):
+ *
+ *   http://www.piramidepse.com/
+ */
+
+package com.google.zxing.client.result;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.Result;
+
+/**
+ * Parses strings of digits that represent a RSS Extended code.
+ * 
+ * @author Antonio Manuel Benjumea Conde, Servinform, S.A.
+ * @author Agustín Delgado, Servinform, S.A.
+ */
+public final class ExpandedProductResultParser extends ResultParser {
+
+  @Override
+  public ExpandedProductParsedResult parse(Result result) {
+    BarcodeFormat format = result.getBarcodeFormat();
+    if (format != BarcodeFormat.RSS_EXPANDED) {
+      // ExtendedProductParsedResult NOT created. Not a RSS Expanded barcode
+      return null;
+    }
+    String rawText = getMassagedText(result);
+
+    String productID = null;
+    String sscc = null;
+    String lotNumber = null;
+    String productionDate = null;
+    String packagingDate = null;
+    String bestBeforeDate = null;
+    String expirationDate = null;
+    String weight = null;
+    String weightType = null;
+    String weightIncrement = null;
+    String price = null;
+    String priceIncrement = null;
+    String priceCurrency = null;
+    Map<String,String> uncommonAIs = new HashMap<>();
+
+    int i = 0;
+
+    while (i < rawText.length()) {
+      String ai = findAIvalue(i, rawText);
+      if (ai == null) {
+        // Error. Code doesn't match with RSS expanded pattern
+        // ExtendedProductParsedResult NOT created. Not match with RSS Expanded pattern
+        return null;
+      }
+      i += ai.length() + 2;
+      String value = findValue(i, rawText);
+      i += value.length();
+
+      switch (ai) {
+        case "00":
+          sscc = value;
+          break;
+        case "01":
+          productID = value;
+          break;
+        case "10":
+          lotNumber = value;
+          break;
+        case "11":
+          productionDate = value;
+          break;
+        case "13":
+          packagingDate = value;
+          break;
+        case "15":
+          bestBeforeDate = value;
+          break;
+        case "17":
+          expirationDate = value;
+          break;
+        case "3100":
+        case "3101":
+        case "3102":
+        case "3103":
+        case "3104":
+        case "3105":
+        case "3106":
+        case "3107":
+        case "3108":
+        case "3109":
+          weight = value;
+          weightType = ExpandedProductParsedResult.KILOGRAM;
+          weightIncrement = ai.substring(3);
+          break;
+        case "3200":
+        case "3201":
+        case "3202":
+        case "3203":
+        case "3204":
+        case "3205":
+        case "3206":
+        case "3207":
+        case "3208":
+        case "3209":
+          weight = value;
+          weightType = ExpandedProductParsedResult.POUND;
+          weightIncrement = ai.substring(3);
+          break;
+        case "3920":
+        case "3921":
+        case "3922":
+        case "3923":
+          price = value;
+          priceIncrement = ai.substring(3);
+          break;
+        case "3930":
+        case "3931":
+        case "3932":
+        case "3933":
+          if (value.length() < 4) {
+            // The value must have more of 3 symbols (3 for currency and
+            // 1 at least for the price)
+            // ExtendedProductParsedResult NOT created. Not match with RSS Expanded pattern
+            return null;
+          }
+          price = value.substring(3);
+          priceCurrency = value.substring(0, 3);
+          priceIncrement = ai.substring(3);
+          break;
+        default:
+          // No match with common AIs
+          uncommonAIs.put(ai, value);
+          break;
+      }
+    }
+
+    return new ExpandedProductParsedResult(rawText,
+                                           productID,
+                                           sscc,
+                                           lotNumber,
+                                           productionDate,
+                                           packagingDate,
+                                           bestBeforeDate,
+                                           expirationDate,
+                                           weight,
+                                           weightType,
+                                           weightIncrement,
+                                           price,
+                                           priceIncrement,
+                                           priceCurrency,
+                                           uncommonAIs);
+  }
+
+  private static String findAIvalue(int i, String rawText) {
+    char c = rawText.charAt(i);
+    // First character must be a open parenthesis.If not, ERROR
+    if (c != '(') {
+      return null;
+    }
+
+    CharSequence rawTextAux = rawText.substring(i + 1);
+
+    StringBuilder buf = new StringBuilder();
+    for (int index = 0; index < rawTextAux.length(); index++) {
+      char currentChar = rawTextAux.charAt(index);
+      if (currentChar == ')') {
+        return buf.toString();
+      }
+      if (currentChar < '0' || currentChar > '9') {
+        return null;
+      }
+      buf.append(currentChar);
+    }
+    return buf.toString();
+  }
+
+  private static String findValue(int i, String rawText) {
+    StringBuilder buf = new StringBuilder();
+    String rawTextAux = rawText.substring(i);
+
+    for (int index = 0; index < rawTextAux.length(); index++) {
+      char c = rawTextAux.charAt(index);
+      if (c == '(') {
+        // We look for a new AI. If it doesn't exist (ERROR), we continue
+        // with the iteration
+        if (findAIvalue(index, rawTextAux) != null) {
+          break;
+        }
+        buf.append('(');
+      } else {
+        buf.append(c);
+      }
+    }
+    return buf.toString();
+  }
+}

src/client/result/GeoParsedResult.java

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+/**
+ * Represents a parsed result that encodes a geographic coordinate, with latitude,
+ * longitude and altitude.
+ *
+ * @author Sean Owen
+ */
+public final class GeoParsedResult extends ParsedResult {
+
+  private final double latitude;
+  private final double longitude;
+  private final double altitude;
+  private final String query;
+
+  GeoParsedResult(double latitude, double longitude, double altitude, String query) {
+    super(ParsedResultType.GEO);
+    this.latitude = latitude;
+    this.longitude = longitude;
+    this.altitude = altitude;
+    this.query = query;
+  }
+
+  public String getGeoURI() {
+    StringBuilder result = new StringBuilder();
+    result.append("geo:");
+    result.append(latitude);
+    result.append(',');
+    result.append(longitude);
+    if (altitude > 0) {
+      result.append(',');
+      result.append(altitude);
+    }
+    if (query != null) {
+      result.append('?');
+      result.append(query);
+    }
+    return result.toString();
+  }
+
+  /**
+   * @return latitude in degrees
+   */
+  public double getLatitude() {
+    return latitude;
+  }
+
+  /**
+   * @return longitude in degrees
+   */
+  public double getLongitude() {
+    return longitude;
+  }
+
+  /**
+   * @return altitude in meters. If not specified, in the geo URI, returns 0.0
+   */
+  public double getAltitude() {
+    return altitude;
+  }
+
+  /**
+   * @return query string associated with geo URI or null if none exists
+   */
+  public String getQuery() {
+    return query;
+  }
+
+  @Override
+  public String getDisplayResult() {
+    StringBuilder result = new StringBuilder(20);
+    result.append(latitude);
+    result.append(", ");
+    result.append(longitude);
+    if (altitude > 0.0) {
+      result.append(", ");
+      result.append(altitude);
+      result.append('m');
+    }
+    if (query != null) {
+      result.append(" (");
+      result.append(query);
+      result.append(')');
+    }
+    return result.toString();
+  }
+
+}

src/client/result/GeoResultParser.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+import com.google.zxing.Result;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Parses a "geo:" URI result, which specifies a location on the surface of
+ * the Earth as well as an optional altitude above the surface. See
+ * <a href="http://tools.ietf.org/html/draft-mayrhofer-geo-uri-00">
+ * http://tools.ietf.org/html/draft-mayrhofer-geo-uri-00</a>.
+ *
+ * @author Sean Owen
+ */
+public final class GeoResultParser extends ResultParser {
+
+  private static final Pattern GEO_URL_PATTERN = 
+      Pattern.compile("geo:([\\-0-9.]+),([\\-0-9.]+)(?:,([\\-0-9.]+))?(?:\\?(.*))?", Pattern.CASE_INSENSITIVE);
+  
+  @Override
+  public GeoParsedResult parse(Result result) {
+    CharSequence rawText = getMassagedText(result);
+    Matcher matcher = GEO_URL_PATTERN.matcher(rawText);
+    if (!matcher.matches()) {
+      return null;
+    }
+
+    String query = matcher.group(4);
+
+    double latitude;
+    double longitude;
+    double altitude;
+    try {
+      latitude = Double.parseDouble(matcher.group(1));
+      if (latitude > 90.0 || latitude < -90.0) {
+        return null;
+      }
+      longitude = Double.parseDouble(matcher.group(2));
+      if (longitude > 180.0 || longitude < -180.0) {
+        return null;
+      }
+      if (matcher.group(3) == null) {
+        altitude = 0.0;
+      } else {
+        altitude = Double.parseDouble(matcher.group(3));
+        if (altitude < 0.0) {
+          return null;
+        }
+      }
+    } catch (NumberFormatException ignored) {
+      return null;
+    }
+    return new GeoParsedResult(latitude, longitude, altitude, query);
+  }
+
+}

src/client/result/ISBNParsedResult.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+/**
+ * Represents a parsed result that encodes a product ISBN number.
+ *
+ * @author jbreiden@google.com (Jeff Breidenbach)
+ */
+public final class ISBNParsedResult extends ParsedResult {
+
+  private final String isbn;
+
+  ISBNParsedResult(String isbn) {
+    super(ParsedResultType.ISBN);
+    this.isbn = isbn;
+  }
+
+  public String getISBN() {
+    return isbn;
+  }
+
+  @Override
+  public String getDisplayResult() {
+    return isbn;
+  }
+
+}

src/client/result/ISBNResultParser.java

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.Result;
+
+/**
+ * Parses strings of digits that represent a ISBN.
+ * 
+ * @author jbreiden@google.com (Jeff Breidenbach)
+ */
+public final class ISBNResultParser extends ResultParser {
+
+  /**
+   * See <a href="http://www.bisg.org/isbn-13/for.dummies.html">ISBN-13 For Dummies</a>
+   */
+  @Override
+  public ISBNParsedResult parse(Result result) {
+    BarcodeFormat format = result.getBarcodeFormat();
+    if (format != BarcodeFormat.EAN_13) {
+      return null;
+    }
+    String rawText = getMassagedText(result);
+    int length = rawText.length();
+    if (length != 13) {
+      return null;
+    }
+    if (!rawText.startsWith("978") && !rawText.startsWith("979")) {
+      return null;
+    }
+   
+    return new ISBNParsedResult(rawText);
+  }
+
+}

src/client/result/ParsedResult.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+/**
+ * <p>Abstract class representing the result of decoding a barcode, as more than
+ * a String -- as some type of structured data. This might be a subclass which represents
+ * a URL, or an e-mail address. {@link ResultParser#parseResult(com.google.zxing.Result)} will turn a raw
+ * decoded string into the most appropriate type of structured representation.</p>
+ *
+ * <p>Thanks to Jeff Griffin for proposing rewrite of these classes that relies less
+ * on exception-based mechanisms during parsing.</p>
+ *
+ * @author Sean Owen
+ */
+public abstract class ParsedResult {
+
+  private final ParsedResultType type;
+
+  protected ParsedResult(ParsedResultType type) {
+    this.type = type;
+  }
+
+  public final ParsedResultType getType() {
+    return type;
+  }
+
+  public abstract String getDisplayResult();
+
+  @Override
+  public final String toString() {
+    return getDisplayResult();
+  }
+
+  public static void maybeAppend(String value, StringBuilder result) {
+    if (value != null && !value.isEmpty()) {
+      // Don't add a newline before the first value
+      if (result.length() > 0) {
+        result.append('\n');
+      }
+      result.append(value);
+    }
+  }
+
+  public static void maybeAppend(String[] values, StringBuilder result) {
+    if (values != null) {
+      for (String value : values) {
+        maybeAppend(value, result);
+      }
+    }
+  }
+
+}

src/client/result/ParsedResultType.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+/**
+ * Represents the type of data encoded by a barcode -- from plain text, to a
+ * URI, to an e-mail address, etc.
+ *
+ * @author Sean Owen
+ */
+public enum ParsedResultType {
+
+  ADDRESSBOOK,
+  EMAIL_ADDRESS,
+  PRODUCT,
+  URI,
+  TEXT,
+  GEO,
+  TEL,
+  SMS,
+  CALENDAR,
+  WIFI,
+  ISBN,
+  VIN,
+
+}

src/client/result/ProductParsedResult.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+/**
+ * Represents a parsed result that encodes a product by an identifier of some kind.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+public final class ProductParsedResult extends ParsedResult {
+
+  private final String productID;
+  private final String normalizedProductID;
+
+  ProductParsedResult(String productID) {
+    this(productID, productID);
+  }
+
+  ProductParsedResult(String productID, String normalizedProductID) {
+    super(ParsedResultType.PRODUCT);
+    this.productID = productID;
+    this.normalizedProductID = normalizedProductID;
+  }
+
+  public String getProductID() {
+    return productID;
+  }
+
+  public String getNormalizedProductID() {
+    return normalizedProductID;
+  }
+
+  @Override
+  public String getDisplayResult() {
+    return productID;
+  }
+
+}

src/client/result/ProductResultParser.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.Result;
+import com.google.zxing.oned.UPCEReader;
+
+/**
+ * Parses strings of digits that represent a UPC code.
+ * 
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+public final class ProductResultParser extends ResultParser {
+
+  // Treat all UPC and EAN variants as UPCs, in the sense that they are all product barcodes.
+  @Override
+  public ProductParsedResult parse(Result result) {
+    BarcodeFormat format = result.getBarcodeFormat();
+    if (!(format == BarcodeFormat.UPC_A || format == BarcodeFormat.UPC_E ||
+          format == BarcodeFormat.EAN_8 || format == BarcodeFormat.EAN_13)) {
+      return null;
+    }
+    String rawText = getMassagedText(result);
+    if (!isStringOfDigits(rawText, rawText.length())) {
+      return null;
+    }
+    // Not actually checking the checksum again here    
+
+    String normalizedProductID;
+    // Expand UPC-E for purposes of searching
+    if (format == BarcodeFormat.UPC_E && rawText.length() == 8) {
+      normalizedProductID = UPCEReader.convertUPCEtoUPCA(rawText);
+    } else {
+      normalizedProductID = rawText;
+    }
+
+    return new ProductParsedResult(rawText, normalizedProductID);
+  }
+
+}

src/client/result/ResultParser.java

@@ -0,0 +1,261 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+import com.google.zxing.Result;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+/**
+ * <p>Abstract class representing the result of decoding a barcode, as more than
+ * a String -- as some type of structured data. This might be a subclass which represents
+ * a URL, or an e-mail address. {@link #parseResult(Result)} will turn a raw
+ * decoded string into the most appropriate type of structured representation.</p>
+ *
+ * <p>Thanks to Jeff Griffin for proposing rewrite of these classes that relies less
+ * on exception-based mechanisms during parsing.</p>
+ *
+ * @author Sean Owen
+ */
+public abstract class ResultParser {
+
+  private static final ResultParser[] PARSERS = {
+      new BookmarkDoCoMoResultParser(),
+      new AddressBookDoCoMoResultParser(),
+      new EmailDoCoMoResultParser(),
+      new AddressBookAUResultParser(),
+      new VCardResultParser(),
+      new BizcardResultParser(),
+      new VEventResultParser(),
+      new EmailAddressResultParser(),
+      new SMTPResultParser(),
+      new TelResultParser(),
+      new SMSMMSResultParser(),
+      new SMSTOMMSTOResultParser(),
+      new GeoResultParser(),
+      new WifiResultParser(),
+      new URLTOResultParser(),
+      new URIResultParser(),
+      new ISBNResultParser(),
+      new ProductResultParser(),
+      new ExpandedProductResultParser(),
+      new VINResultParser(),
+  };
+
+  private static final Pattern DIGITS = Pattern.compile("\\d+");
+  private static final Pattern AMPERSAND = Pattern.compile("&");
+  private static final Pattern EQUALS = Pattern.compile("=");
+  private static final String BYTE_ORDER_MARK = "\ufeff";
+
+  static final String[] EMPTY_STR_ARRAY = new String[0];
+
+  /**
+   * Attempts to parse the raw {@link Result}'s contents as a particular type
+   * of information (email, URL, etc.) and return a {@link ParsedResult} encapsulating
+   * the result of parsing.
+   *
+   * @param theResult the raw {@link Result} to parse
+   * @return {@link ParsedResult} encapsulating the parsing result
+   */
+  public abstract ParsedResult parse(Result theResult);
+
+  protected static String getMassagedText(Result result) {
+    String text = result.getText();
+    if (text.startsWith(BYTE_ORDER_MARK)) {
+      text = text.substring(1);
+    }
+    return text;
+  }
+
+  public static ParsedResult parseResult(Result theResult) {
+    for (ResultParser parser : PARSERS) {
+      ParsedResult result = parser.parse(theResult);
+      if (result != null) {
+        return result;
+      }
+    }
+    return new TextParsedResult(theResult.getText(), null);
+  }
+
+  protected static void maybeAppend(String value, StringBuilder result) {
+    if (value != null) {
+      result.append('\n');
+      result.append(value);
+    }
+  }
+
+  protected static void maybeAppend(String[] value, StringBuilder result) {
+    if (value != null) {
+      for (String s : value) {
+        result.append('\n');
+        result.append(s);
+      }
+    }
+  }
+
+  protected static String[] maybeWrap(String value) {
+    return value == null ? null : new String[] { value };
+  }
+
+  protected static String unescapeBackslash(String escaped) {
+    int backslash = escaped.indexOf('\\');
+    if (backslash < 0) {
+      return escaped;
+    }
+    int max = escaped.length();
+    StringBuilder unescaped = new StringBuilder(max - 1);
+    unescaped.append(escaped.toCharArray(), 0, backslash);
+    boolean nextIsEscaped = false;
+    for (int i = backslash; i < max; i++) {
+      char c = escaped.charAt(i);
+      if (nextIsEscaped || c != '\\') {
+        unescaped.append(c);
+        nextIsEscaped = false;
+      } else {
+        nextIsEscaped = true;
+      }
+    }
+    return unescaped.toString();
+  }
+
+  protected static int parseHexDigit(char c) {
+    if (c >= '0' && c <= '9') {
+      return c - '0';
+    }
+    if (c >= 'a' && c <= 'f') {
+      return 10 + (c - 'a');
+    }
+    if (c >= 'A' && c <= 'F') {
+      return 10 + (c - 'A');
+    }
+    return -1;
+  }
+
+  protected static boolean isStringOfDigits(CharSequence value, int length) {
+    return value != null && length > 0 && length == value.length() && DIGITS.matcher(value).matches();
+  }
+
+  protected static boolean isSubstringOfDigits(CharSequence value, int offset, int length) {
+    if (value == null || length <= 0) {
+      return false;
+    }
+    int max = offset + length;
+    return value.length() >= max && DIGITS.matcher(value.subSequence(offset, max)).matches();
+  }
+
+  static Map<String,String> parseNameValuePairs(String uri) {
+    int paramStart = uri.indexOf('?');
+    if (paramStart < 0) {
+      return null;
+    }
+    Map<String,String> result = new HashMap<>(3);
+    for (String keyValue : AMPERSAND.split(uri.substring(paramStart + 1))) {
+      appendKeyValue(keyValue, result);
+    }
+    return result;
+  }
+
+  private static void appendKeyValue(CharSequence keyValue, Map<String,String> result) {
+    String[] keyValueTokens = EQUALS.split(keyValue, 2);
+    if (keyValueTokens.length == 2) {
+      String key = keyValueTokens[0];
+      String value = keyValueTokens[1];
+      try {
+        value = urlDecode(value);
+        result.put(key, value);
+      } catch (IllegalArgumentException iae) {
+        // continue; invalid data such as an escape like %0t
+      }
+    }
+  }
+
+  static String urlDecode(String encoded) {
+    try {
+      return URLDecoder.decode(encoded, "UTF-8");
+    } catch (UnsupportedEncodingException uee) {
+      throw new IllegalStateException(uee); // can't happen
+    }
+  }
+
+  static String[] matchPrefixedField(String prefix, String rawText, char endChar, boolean trim) {
+    List<String> matches = null;
+    int i = 0;
+    int max = rawText.length();
+    while (i < max) {
+      i = rawText.indexOf(prefix, i);
+      if (i < 0) {
+        break;
+      }
+      i += prefix.length(); // Skip past this prefix we found to start
+      int start = i; // Found the start of a match here
+      boolean more = true;
+      while (more) {
+        i = rawText.indexOf(endChar, i);
+        if (i < 0) {
+          // No terminating end character? uh, done. Set i such that loop terminates and break
+          i = rawText.length();
+          more = false;
+        } else if (countPrecedingBackslashes(rawText, i) % 2 != 0) {
+          // semicolon was escaped (odd count of preceding backslashes) so continue
+          i++;
+        } else {
+          // found a match
+          if (matches == null) {
+            matches = new ArrayList<>(3); // lazy init
+          }
+          String element = unescapeBackslash(rawText.substring(start, i));
+          if (trim) {
+            element = element.trim();
+          }
+          if (!element.isEmpty()) {
+            matches.add(element);
+          }
+          i++;
+          more = false;
+        }
+      }
+    }
+    if (matches == null || matches.isEmpty()) {
+      return null;
+    }
+    return matches.toArray(EMPTY_STR_ARRAY);
+  }
+
+  private static int countPrecedingBackslashes(CharSequence s, int pos) {
+    int count = 0;
+    for (int i = pos - 1; i >= 0; i--) {
+      if (s.charAt(i) == '\\') {
+        count++;
+      } else {
+        break;
+      }
+    }
+    return count;
+  }
+
+  static String matchSinglePrefixedField(String prefix, String rawText, char endChar, boolean trim) {
+    String[] matches = matchPrefixedField(prefix, rawText, endChar, trim);
+    return matches == null ? null : matches[0];
+  }
+
+}

src/client/result/SMSMMSResultParser.java

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+import com.google.zxing.Result;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * <p>Parses an "sms:" URI result, which specifies a number to SMS.
+ * See <a href="http://tools.ietf.org/html/rfc5724"> RFC 5724</a> on this.</p>
+ *
+ * <p>This class supports "via" syntax for numbers, which is not part of the spec.
+ * For example "+12125551212;via=+12124440101" may appear as a number.
+ * It also supports a "subject" query parameter, which is not mentioned in the spec.
+ * These are included since they were mentioned in earlier IETF drafts and might be
+ * used.</p>
+ *
+ * <p>This actually also parses URIs starting with "mms:" and treats them all the same way,
+ * and effectively converts them to an "sms:" URI for purposes of forwarding to the platform.</p>
+ *
+ * @author Sean Owen
+ */
+public final class SMSMMSResultParser extends ResultParser {
+
+  @Override
+  public SMSParsedResult parse(Result result) {
+    String rawText = getMassagedText(result);
+    if (!(rawText.startsWith("sms:") || rawText.startsWith("SMS:") ||
+          rawText.startsWith("mms:") || rawText.startsWith("MMS:"))) {
+      return null;
+    }
+
+    // Check up front if this is a URI syntax string with query arguments
+    Map<String,String> nameValuePairs = parseNameValuePairs(rawText);
+    String subject = null;
+    String body = null;
+    boolean querySyntax = false;
+    if (nameValuePairs != null && !nameValuePairs.isEmpty()) {
+      subject = nameValuePairs.get("subject");
+      body = nameValuePairs.get("body");
+      querySyntax = true;
+    }
+
+    // Drop sms, query portion
+    int queryStart = rawText.indexOf('?', 4);
+    String smsURIWithoutQuery;
+    // If it's not query syntax, the question mark is part of the subject or message
+    if (queryStart < 0 || !querySyntax) {
+      smsURIWithoutQuery = rawText.substring(4);
+    } else {
+      smsURIWithoutQuery = rawText.substring(4, queryStart);
+    }
+
+    int lastComma = -1;
+    int comma;
+    List<String> numbers = new ArrayList<>(1);
+    List<String> vias = new ArrayList<>(1);
+    while ((comma = smsURIWithoutQuery.indexOf(',', lastComma + 1)) > lastComma) {
+      String numberPart = smsURIWithoutQuery.substring(lastComma + 1, comma);
+      addNumberVia(numbers, vias, numberPart);
+      lastComma = comma;
+    }
+    addNumberVia(numbers, vias, smsURIWithoutQuery.substring(lastComma + 1));    
+
+    return new SMSParsedResult(numbers.toArray(EMPTY_STR_ARRAY),
+                               vias.toArray(EMPTY_STR_ARRAY),
+                               subject,
+                               body);
+  }
+
+  private static void addNumberVia(Collection<String> numbers,
+                                   Collection<String> vias,
+                                   String numberPart) {
+    int numberEnd = numberPart.indexOf(';');
+    if (numberEnd < 0) {
+      numbers.add(numberPart);
+      vias.add(null);
+    } else {
+      numbers.add(numberPart.substring(0, numberEnd));
+      String maybeVia = numberPart.substring(numberEnd + 1);
+      String via;
+      if (maybeVia.startsWith("via=")) {
+        via = maybeVia.substring(4);
+      } else {
+        via = null;
+      }
+      vias.add(via);
+    }
+  }
+
+}

src/client/result/SMSParsedResult.java

@@ -0,0 +1,114 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+/**
+ * Represents a parsed result that encodes an SMS message, including recipients, subject
+ * and body text.
+ *
+ * @author Sean Owen
+ */
+public final class SMSParsedResult extends ParsedResult {
+
+  private final String[] numbers;
+  private final String[] vias;
+  private final String subject;
+  private final String body;
+
+  public SMSParsedResult(String number,
+                         String via,
+                         String subject,
+                         String body) {
+    super(ParsedResultType.SMS);
+    this.numbers = new String[] {number};
+    this.vias = new String[] {via};
+    this.subject = subject;
+    this.body = body;
+  }
+
+  public SMSParsedResult(String[] numbers,
+                         String[] vias,
+                         String subject,
+                         String body) {
+    super(ParsedResultType.SMS);
+    this.numbers = numbers;
+    this.vias = vias;
+    this.subject = subject;
+    this.body = body;
+  }
+
+  public String getSMSURI() {
+    StringBuilder result = new StringBuilder();
+    result.append("sms:");
+    boolean first = true;
+    for (int i = 0; i < numbers.length; i++) {
+      if (first) {
+        first = false;
+      } else {
+        result.append(',');
+      }
+      result.append(numbers[i]);
+      if (vias != null && vias[i] != null) {
+        result.append(";via=");
+        result.append(vias[i]);
+      }
+    }
+    boolean hasBody = body != null;
+    boolean hasSubject = subject != null;
+    if (hasBody || hasSubject) {
+      result.append('?');
+      if (hasBody) {
+        result.append("body=");
+        result.append(body);
+      }
+      if (hasSubject) {
+        if (hasBody) {
+          result.append('&');
+        }
+        result.append("subject=");
+        result.append(subject);
+      }
+    }
+    return result.toString();
+  }
+
+  public String[] getNumbers() {
+    return numbers;
+  }
+
+  public String[] getVias() {
+    return vias;
+  }
+
+  public String getSubject() {
+    return subject;
+  }
+
+  public String getBody() {
+    return body;
+  }
+
+  @Override
+  public String getDisplayResult() {
+    StringBuilder result = new StringBuilder(100);
+    maybeAppend(numbers, result);
+    maybeAppend(subject, result);
+    maybeAppend(body, result);
+    return result.toString();
+  }
+
+}

src/client/result/SMSTOMMSTOResultParser.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+import com.google.zxing.Result;
+
+/**
+ * <p>Parses an "smsto:" URI result, whose format is not standardized but appears to be like:
+ * {@code smsto:number(:body)}.</p>
+ *
+ * <p>This actually also parses URIs starting with "smsto:", "mmsto:", "SMSTO:", and
+ * "MMSTO:", and treats them all the same way, and effectively converts them to an "sms:" URI
+ * for purposes of forwarding to the platform.</p>
+ *
+ * @author Sean Owen
+ */
+public final class SMSTOMMSTOResultParser extends ResultParser {
+
+  @Override
+  public SMSParsedResult parse(Result result) {
+    String rawText = getMassagedText(result);
+    if (!(rawText.startsWith("smsto:") || rawText.startsWith("SMSTO:") ||
+          rawText.startsWith("mmsto:") || rawText.startsWith("MMSTO:"))) {
+      return null;
+    }
+    // Thanks to dominik.wild for suggesting this enhancement to support
+    // smsto:number:body URIs
+    String number = rawText.substring(6);
+    String body = null;
+    int bodyStart = number.indexOf(':');
+    if (bodyStart >= 0) {
+      body = number.substring(bodyStart + 1);
+      number = number.substring(0, bodyStart);
+    }
+    return new SMSParsedResult(number, null, null, body);
+  }
+
+}

src/client/result/SMTPResultParser.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+import com.google.zxing.Result;
+
+/**
+ * <p>Parses an "smtp:" URI result, whose format is not standardized but appears to be like:
+ * {@code smtp[:subject[:body]]}.</p>
+ *
+ * @author Sean Owen
+ */
+public final class SMTPResultParser extends ResultParser {
+
+  @Override
+  public EmailAddressParsedResult parse(Result result) {
+    String rawText = getMassagedText(result);
+    if (!(rawText.startsWith("smtp:") || rawText.startsWith("SMTP:"))) {
+      return null;
+    }
+    String emailAddress = rawText.substring(5);
+    String subject = null;
+    String body = null;
+    int colon = emailAddress.indexOf(':');
+    if (colon >= 0) {
+      subject = emailAddress.substring(colon + 1);
+      emailAddress = emailAddress.substring(0, colon);
+      colon = subject.indexOf(':');
+      if (colon >= 0) {
+        body = subject.substring(colon + 1);
+        subject = subject.substring(0, colon);
+      }
+    }
+    return new EmailAddressParsedResult(new String[] {emailAddress},
+                                        null,
+                                        null,
+                                        subject,
+                                        body);
+  }
+}

src/client/result/TelParsedResult.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+/**
+ * Represents a parsed result that encodes a telephone number.
+ *
+ * @author Sean Owen
+ */
+public final class TelParsedResult extends ParsedResult {
+
+  private final String number;
+  private final String telURI;
+  private final String title;
+
+  public TelParsedResult(String number, String telURI, String title) {
+    super(ParsedResultType.TEL);
+    this.number = number;
+    this.telURI = telURI;
+    this.title = title;
+  }
+
+  public String getNumber() {
+    return number;
+  }
+
+  public String getTelURI() {
+    return telURI;
+  }
+
+  public String getTitle() {
+    return title;
+  }
+
+  @Override
+  public String getDisplayResult() {
+    StringBuilder result = new StringBuilder(20);
+    maybeAppend(number, result);
+    maybeAppend(title, result);
+    return result.toString();
+  }
+
+}

src/client/result/TelResultParser.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+import com.google.zxing.Result;
+
+/**
+ * Parses a "tel:" URI result, which specifies a phone number.
+ *
+ * @author Sean Owen
+ */
+public final class TelResultParser extends ResultParser {
+
+  @Override
+  public TelParsedResult parse(Result result) {
+    String rawText = getMassagedText(result);
+    if (!rawText.startsWith("tel:") && !rawText.startsWith("TEL:")) {
+      return null;
+    }
+    // Normalize "TEL:" to "tel:"
+    String telURI = rawText.startsWith("TEL:") ? "tel:" + rawText.substring(4) : rawText;
+    // Drop tel, query portion
+    int queryStart = rawText.indexOf('?', 4);
+    String number = queryStart < 0 ? rawText.substring(4) : rawText.substring(4, queryStart);
+    return new TelParsedResult(number, telURI, null);
+  }
+
+}

src/client/result/TextParsedResult.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+/**
+ * A simple result type encapsulating a string that has no further
+ * interpretation.
+ * 
+ * @author Sean Owen
+ */
+public final class TextParsedResult extends ParsedResult {
+
+  private final String text;
+  private final String language;
+
+  public TextParsedResult(String text, String language) {
+    super(ParsedResultType.TEXT);
+    this.text = text;
+    this.language = language;
+  }
+
+  public String getText() {
+    return text;
+  }
+
+  public String getLanguage() {
+    return language;
+  }
+
+  @Override
+  public String getDisplayResult() {
+    return text;
+  }
+
+}

src/client/result/URIParsedResult.java

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+/**
+ * A simple result type encapsulating a URI that has no further interpretation.
+ *
+ * @author Sean Owen
+ */
+public final class URIParsedResult extends ParsedResult {
+
+  private final String uri;
+  private final String title;
+
+  public URIParsedResult(String uri, String title) {
+    super(ParsedResultType.URI);
+    this.uri = massageURI(uri);
+    this.title = title;
+  }
+
+  public String getURI() {
+    return uri;
+  }
+
+  public String getTitle() {
+    return title;
+  }
+
+  /**
+   * @return true if the URI contains suspicious patterns that may suggest it intends to
+   *  mislead the user about its true nature
+   * @deprecated see {@link URIResultParser#isPossiblyMaliciousURI(String)}
+   */
+  @Deprecated
+  public boolean isPossiblyMaliciousURI() {
+    return URIResultParser.isPossiblyMaliciousURI(uri);
+  }
+
+  @Override
+  public String getDisplayResult() {
+    StringBuilder result = new StringBuilder(30);
+    maybeAppend(title, result);
+    maybeAppend(uri, result);
+    return result.toString();
+  }
+
+  /**
+   * Transforms a string that represents a URI into something more proper, by adding or canonicalizing
+   * the protocol.
+   */
+  private static String massageURI(String uri) {
+    uri = uri.trim();
+    int protocolEnd = uri.indexOf(':');
+    if (protocolEnd < 0 || isColonFollowedByPortNumber(uri, protocolEnd)) {
+      // No protocol, or found a colon, but it looks like it is after the host, so the protocol is still missing,
+      // so assume http
+      uri = "http://" + uri;
+    }
+    return uri;
+  }
+
+  private static boolean isColonFollowedByPortNumber(String uri, int protocolEnd) {
+    int start = protocolEnd + 1;
+    int nextSlash = uri.indexOf('/', start);
+    if (nextSlash < 0) {
+      nextSlash = uri.length();
+    }
+    return ResultParser.isSubstringOfDigits(uri, start, nextSlash - start);
+  }
+
+
+}

src/client/result/URIResultParser.java

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+import com.google.zxing.Result;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Tries to parse results that are a URI of some kind.
+ * 
+ * @author Sean Owen
+ */
+public final class URIResultParser extends ResultParser {
+
+  private static final Pattern ALLOWED_URI_CHARS_PATTERN =
+      Pattern.compile("[-._~:/?#\\[\\]@!$&'()*+,;=%A-Za-z0-9]+");
+  private static final Pattern USER_IN_HOST = Pattern.compile(":/*([^/@]+)@[^/]+");
+  // See http://www.ietf.org/rfc/rfc2396.txt
+  private static final Pattern URL_WITH_PROTOCOL_PATTERN = Pattern.compile("[a-zA-Z][a-zA-Z0-9+-.]+:");
+  private static final Pattern URL_WITHOUT_PROTOCOL_PATTERN = Pattern.compile(
+      "([a-zA-Z0-9\\-]+\\.){1,6}[a-zA-Z]{2,}" + // host name elements; allow up to say 6 domain elements
+      "(:\\d{1,5})?" + // maybe port
+      "(/|\\?|$)"); // query, path or nothing
+
+  @Override
+  public URIParsedResult parse(Result result) {
+    String rawText = getMassagedText(result);
+    // We specifically handle the odd "URL" scheme here for simplicity and add "URI" for fun
+    // Assume anything starting this way really means to be a URI
+    if (rawText.startsWith("URL:") || rawText.startsWith("URI:")) {
+      return new URIParsedResult(rawText.substring(4).trim(), null);
+    }
+    rawText = rawText.trim();
+    if (!isBasicallyValidURI(rawText) || isPossiblyMaliciousURI(rawText)) {
+      return null;
+    }
+    return new URIParsedResult(rawText, null);
+  }
+
+  /**
+   * @return true if the URI contains suspicious patterns that may suggest it intends to
+   *  mislead the user about its true nature. At the moment this looks for the presence
+   *  of user/password syntax in the host/authority portion of a URI which may be used
+   *  in attempts to make the URI's host appear to be other than it is. Example:
+   *  http://yourbank.com@phisher.com  This URI connects to phisher.com but may appear
+   *  to connect to yourbank.com at first glance.
+   */
+  static boolean isPossiblyMaliciousURI(String uri) {
+    return !ALLOWED_URI_CHARS_PATTERN.matcher(uri).matches() || USER_IN_HOST.matcher(uri).find();
+  }
+
+  static boolean isBasicallyValidURI(String uri) {
+    if (uri.contains(" ")) {
+      // Quick hack check for a common case
+      return false;
+    }
+    Matcher m = URL_WITH_PROTOCOL_PATTERN.matcher(uri);
+    if (m.find() && m.start() == 0) { // match at start only
+      return true;
+    }
+    m = URL_WITHOUT_PROTOCOL_PATTERN.matcher(uri);
+    return m.find() && m.start() == 0;
+  }
+
+}

src/client/result/URLTOResultParser.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+import com.google.zxing.Result;
+
+/**
+ * Parses the "URLTO" result format, which is of the form "URLTO:[title]:[url]".
+ * This seems to be used sometimes, but I am not able to find documentation
+ * on its origin or official format?
+ *
+ * @author Sean Owen
+ */
+public final class URLTOResultParser extends ResultParser {
+
+  @Override
+  public URIParsedResult parse(Result result) {
+    String rawText = getMassagedText(result);
+    if (!rawText.startsWith("urlto:") && !rawText.startsWith("URLTO:")) {
+      return null;
+    }
+    int titleEnd = rawText.indexOf(':', 6);
+    if (titleEnd < 0) {
+      return null;
+    }
+    String title = titleEnd <= 6 ? null : rawText.substring(6, titleEnd);
+    String uri = rawText.substring(titleEnd + 1);
+    return new URIParsedResult(uri, title);
+  }
+
+}

src/client/result/VCardResultParser.java

@@ -0,0 +1,374 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+import com.google.zxing.Result;
+
+import java.io.ByteArrayOutputStream;
+import java.io.UnsupportedEncodingException;
+import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Parses contact information formatted according to the VCard (2.1) format. This is not a complete
+ * implementation but should parse information as commonly encoded in 2D barcodes.
+ *
+ * @author Sean Owen
+ */
+public final class VCardResultParser extends ResultParser {
+
+  private static final Pattern BEGIN_VCARD = Pattern.compile("BEGIN:VCARD", Pattern.CASE_INSENSITIVE);
+  private static final Pattern VCARD_LIKE_DATE = Pattern.compile("\\d{4}-?\\d{2}-?\\d{2}");
+  private static final Pattern CR_LF_SPACE_TAB = Pattern.compile("\r\n[ \t]");
+  private static final Pattern NEWLINE_ESCAPE = Pattern.compile("\\\\[nN]");
+  private static final Pattern VCARD_ESCAPES = Pattern.compile("\\\\([,;\\\\])");
+  private static final Pattern EQUALS = Pattern.compile("=");
+  private static final Pattern SEMICOLON = Pattern.compile(";");
+  private static final Pattern UNESCAPED_SEMICOLONS = Pattern.compile("(?<!\\\\);+");
+  private static final Pattern COMMA = Pattern.compile(",");
+  private static final Pattern SEMICOLON_OR_COMMA = Pattern.compile("[;,]");
+
+  @Override
+  public AddressBookParsedResult parse(Result result) {
+    // Although we should insist on the raw text ending with "END:VCARD", there's no reason
+    // to throw out everything else we parsed just because this was omitted. In fact, Eclair
+    // is doing just that, and we can't parse its contacts without this leniency.
+    String rawText = getMassagedText(result);
+    Matcher m = BEGIN_VCARD.matcher(rawText);
+    if (!m.find() || m.start() != 0) {
+      return null;
+    }
+    List<List<String>> names = matchVCardPrefixedField("FN", rawText, true, false);
+    if (names == null) {
+      // If no display names found, look for regular name fields and format them
+      names = matchVCardPrefixedField("N", rawText, true, false);
+      formatNames(names);
+    }
+    List<String> nicknameString = matchSingleVCardPrefixedField("NICKNAME", rawText, true, false);
+    String[] nicknames = nicknameString == null ? null : COMMA.split(nicknameString.get(0));
+    List<List<String>> phoneNumbers = matchVCardPrefixedField("TEL", rawText, true, false);
+    List<List<String>> emails = matchVCardPrefixedField("EMAIL", rawText, true, false);
+    List<String> note = matchSingleVCardPrefixedField("NOTE", rawText, false, false);
+    List<List<String>> addresses = matchVCardPrefixedField("ADR", rawText, true, true);
+    List<String> org = matchSingleVCardPrefixedField("ORG", rawText, true, true);
+    List<String> birthday = matchSingleVCardPrefixedField("BDAY", rawText, true, false);
+    if (birthday != null && !isLikeVCardDate(birthday.get(0))) {
+      birthday = null;
+    }
+    List<String> title = matchSingleVCardPrefixedField("TITLE", rawText, true, false);
+    List<List<String>> urls = matchVCardPrefixedField("URL", rawText, true, false);
+    List<String> instantMessenger = matchSingleVCardPrefixedField("IMPP", rawText, true, false);
+    List<String> geoString = matchSingleVCardPrefixedField("GEO", rawText, true, false);
+    String[] geo = geoString == null ? null : SEMICOLON_OR_COMMA.split(geoString.get(0));
+    if (geo != null && geo.length != 2) {
+      geo = null;
+    }
+    return new AddressBookParsedResult(toPrimaryValues(names),
+                                       nicknames,
+                                       null, 
+                                       toPrimaryValues(phoneNumbers), 
+                                       toTypes(phoneNumbers),
+                                       toPrimaryValues(emails),
+                                       toTypes(emails),
+                                       toPrimaryValue(instantMessenger),
+                                       toPrimaryValue(note),
+                                       toPrimaryValues(addresses),
+                                       toTypes(addresses),
+                                       toPrimaryValue(org),
+                                       toPrimaryValue(birthday),
+                                       toPrimaryValue(title),
+                                       toPrimaryValues(urls),
+                                       geo);
+  }
+
+  static List<List<String>> matchVCardPrefixedField(CharSequence prefix,
+                                                    String rawText,
+                                                    boolean trim,
+                                                    boolean parseFieldDivider) {
+    List<List<String>> matches = null;
+    int i = 0;
+    int max = rawText.length();
+
+    while (i < max) {
+
+      // At start or after newline, match prefix, followed by optional metadata 
+      // (led by ;) ultimately ending in colon
+      Matcher matcher = Pattern.compile("(?:^|\n)" + prefix + "(?:;([^:]*))?:",
+                                        Pattern.CASE_INSENSITIVE).matcher(rawText);
+      if (i > 0) {
+        i--; // Find from i-1 not i since looking at the preceding character
+      }
+      if (!matcher.find(i)) {
+        break;
+      }
+      i = matcher.end(0); // group 0 = whole pattern; end(0) is past final colon
+
+      String metadataString = matcher.group(1); // group 1 = metadata substring
+      List<String> metadata = null;
+      boolean quotedPrintable = false;
+      String quotedPrintableCharset = null;
+      String valueType = null;
+      if (metadataString != null) {
+        for (String metadatum : SEMICOLON.split(metadataString)) {
+          if (metadata == null) {
+            metadata = new ArrayList<>(1);
+          }
+          metadata.add(metadatum);
+          String[] metadatumTokens = EQUALS.split(metadatum, 2);
+          if (metadatumTokens.length > 1) {
+            String key = metadatumTokens[0];
+            String value = metadatumTokens[1];
+            if ("ENCODING".equalsIgnoreCase(key) && "QUOTED-PRINTABLE".equalsIgnoreCase(value)) {
+              quotedPrintable = true;
+            } else if ("CHARSET".equalsIgnoreCase(key)) {
+              quotedPrintableCharset = value;
+            } else if ("VALUE".equalsIgnoreCase(key)) {
+              valueType = value;
+            }
+          }
+        }
+      }
+
+      int matchStart = i; // Found the start of a match here
+
+      while ((i = rawText.indexOf('\n', i)) >= 0) { // Really, end in \r\n
+        if (i < rawText.length() - 1 &&           // But if followed by tab or space,
+            (rawText.charAt(i + 1) == ' ' ||        // this is only a continuation
+             rawText.charAt(i + 1) == '\t')) {
+          i += 2; // Skip \n and continutation whitespace
+        } else if (quotedPrintable &&             // If preceded by = in quoted printable
+                   ((i >= 1 && rawText.charAt(i - 1) == '=') || // this is a continuation
+                    (i >= 2 && rawText.charAt(i - 2) == '='))) {
+          i++; // Skip \n
+        } else {
+          break;
+        }
+      }
+
+      if (i < 0) {
+        // No terminating end character? uh, done. Set i such that loop terminates and break
+        i = max;
+      } else if (i > matchStart) {
+        // found a match
+        if (matches == null) {
+          matches = new ArrayList<>(1); // lazy init
+        }
+        if (i >= 1 && rawText.charAt(i - 1) == '\r') {
+          i--; // Back up over \r, which really should be there
+        }
+        String element = rawText.substring(matchStart, i);
+        if (trim) {
+          element = element.trim();
+        }
+        if (quotedPrintable) {
+          element = decodeQuotedPrintable(element, quotedPrintableCharset);
+          if (parseFieldDivider) {
+            element = UNESCAPED_SEMICOLONS.matcher(element).replaceAll("\n").trim();
+          }
+        } else {
+          if (parseFieldDivider) {
+            element = UNESCAPED_SEMICOLONS.matcher(element).replaceAll("\n").trim();
+          }
+          element = CR_LF_SPACE_TAB.matcher(element).replaceAll("");
+          element = NEWLINE_ESCAPE.matcher(element).replaceAll("\n");
+          element = VCARD_ESCAPES.matcher(element).replaceAll("$1");
+        }
+        // Only handle VALUE=uri specially
+        if ("uri".equals(valueType)) {
+          // Don't actually support dereferencing URIs, but use scheme-specific part not URI
+          // as value, to support tel: and mailto:
+          try {
+            element = URI.create(element).getSchemeSpecificPart();
+          } catch (IllegalArgumentException iae) {
+            // ignore
+          }
+        }
+        if (metadata == null) {
+          List<String> match = new ArrayList<>(1);
+          match.add(element);
+          matches.add(match);
+        } else {
+          metadata.add(0, element);
+          matches.add(metadata);
+        }
+        i++;
+      } else {
+        i++;
+      }
+
+    }
+
+    return matches;
+  }
+
+  private static String decodeQuotedPrintable(CharSequence value, String charset) {
+    int length = value.length();
+    StringBuilder result = new StringBuilder(length);
+    ByteArrayOutputStream fragmentBuffer = new ByteArrayOutputStream();
+    for (int i = 0; i < length; i++) {
+      char c = value.charAt(i);
+      switch (c) {
+        case '\r':
+        case '\n':
+          break;
+        case '=':
+          if (i < length - 2) {
+            char nextChar = value.charAt(i + 1);
+            if (nextChar != '\r' && nextChar != '\n') {
+              char nextNextChar = value.charAt(i + 2);
+              int firstDigit = parseHexDigit(nextChar);
+              int secondDigit = parseHexDigit(nextNextChar);
+              if (firstDigit >= 0 && secondDigit >= 0) {
+                fragmentBuffer.write((firstDigit << 4) + secondDigit);
+              } // else ignore it, assume it was incorrectly encoded
+              i += 2;
+            }
+          }
+          break;
+        default:
+          maybeAppendFragment(fragmentBuffer, charset, result);
+          result.append(c);
+      }
+    }
+    maybeAppendFragment(fragmentBuffer, charset, result);
+    return result.toString();
+  }
+
+  private static void maybeAppendFragment(ByteArrayOutputStream fragmentBuffer,
+                                          String charset,
+                                          StringBuilder result) {
+    if (fragmentBuffer.size() > 0) {
+      byte[] fragmentBytes = fragmentBuffer.toByteArray();
+      String fragment;
+      if (charset == null) {
+        fragment = new String(fragmentBytes, StandardCharsets.UTF_8);
+      } else {
+        try {
+          fragment = new String(fragmentBytes, charset);
+        } catch (UnsupportedEncodingException e) {
+          fragment = new String(fragmentBytes, StandardCharsets.UTF_8);
+        }
+      }
+      fragmentBuffer.reset();
+      result.append(fragment);
+    }
+  }
+
+  static List<String> matchSingleVCardPrefixedField(CharSequence prefix,
+                                                    String rawText,
+                                                    boolean trim,
+                                                    boolean parseFieldDivider) {
+    List<List<String>> values = matchVCardPrefixedField(prefix, rawText, trim, parseFieldDivider);
+    return values == null || values.isEmpty() ? null : values.get(0);
+  }
+  
+  private static String toPrimaryValue(List<String> list) {
+    return list == null || list.isEmpty() ? null : list.get(0);
+  }
+  
+  private static String[] toPrimaryValues(Collection<List<String>> lists) {
+    if (lists == null || lists.isEmpty()) {
+      return null;
+    }
+    List<String> result = new ArrayList<>(lists.size());
+    for (List<String> list : lists) {
+      String value = list.get(0);
+      if (value != null && !value.isEmpty()) {
+        result.add(value);
+      }
+    }
+    return result.toArray(EMPTY_STR_ARRAY);
+  }
+  
+  private static String[] toTypes(Collection<List<String>> lists) {
+    if (lists == null || lists.isEmpty()) {
+      return null;
+    }
+    List<String> result = new ArrayList<>(lists.size());
+    for (List<String> list : lists) {
+      String value = list.get(0);
+      if (value != null && !value.isEmpty()) {
+        String type = null;
+        for (int i = 1; i < list.size(); i++) {
+          String metadatum = list.get(i);
+          int equals = metadatum.indexOf('=');
+          if (equals < 0) {
+            // take the whole thing as a usable label
+            type = metadatum;
+            break;
+          }
+          if ("TYPE".equalsIgnoreCase(metadatum.substring(0, equals))) {
+            type = metadatum.substring(equals + 1);
+            break;
+          }
+        }
+        result.add(type);
+      }
+    }
+    return result.toArray(EMPTY_STR_ARRAY);
+  }
+
+  private static boolean isLikeVCardDate(CharSequence value) {
+    return value == null || VCARD_LIKE_DATE.matcher(value).matches();
+  }
+
+  /**
+   * Formats name fields of the form "Public;John;Q.;Reverend;III" into a form like
+   * "Reverend John Q. Public III".
+   *
+   * @param names name values to format, in place
+   */
+  private static void formatNames(Iterable<List<String>> names) {
+    if (names != null) {
+      for (List<String> list : names) {
+        String name = list.get(0);
+        String[] components = new String[5];
+        int start = 0;
+        int end;
+        int componentIndex = 0;
+        while (componentIndex < components.length - 1 && (end = name.indexOf(';', start)) >= 0) {
+          components[componentIndex] = name.substring(start, end);
+          componentIndex++;
+          start = end + 1;
+        }
+        components[componentIndex] = name.substring(start);
+        StringBuilder newName = new StringBuilder(100);
+        maybeAppendComponent(components, 3, newName);
+        maybeAppendComponent(components, 1, newName);
+        maybeAppendComponent(components, 2, newName);
+        maybeAppendComponent(components, 0, newName);
+        maybeAppendComponent(components, 4, newName);
+        list.set(0, newName.toString().trim());
+      }
+    }
+  }
+
+  private static void maybeAppendComponent(String[] components, int i, StringBuilder newName) {
+    if (components[i] != null && !components[i].isEmpty()) {
+      if (newName.length() > 0) {
+        newName.append(' ');
+      }
+      newName.append(components[i]);
+    }
+  }
+
+}

src/client/result/VEventResultParser.java

@@ -0,0 +1,118 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+import com.google.zxing.Result;
+
+import java.util.List;
+
+/**
+ * Partially implements the iCalendar format's "VEVENT" format for specifying a
+ * calendar event. See RFC 2445. This supports SUMMARY, LOCATION, GEO, DTSTART and DTEND fields.
+ *
+ * @author Sean Owen
+ */
+public final class VEventResultParser extends ResultParser {
+
+  @Override
+  public CalendarParsedResult parse(Result result) {
+    String rawText = getMassagedText(result);
+    int vEventStart = rawText.indexOf("BEGIN:VEVENT");
+    if (vEventStart < 0) {
+      return null;
+    }
+
+    String summary = matchSingleVCardPrefixedField("SUMMARY", rawText);
+    String start = matchSingleVCardPrefixedField("DTSTART", rawText);
+    if (start == null) {
+      return null;
+    }
+    String end = matchSingleVCardPrefixedField("DTEND", rawText);
+    String duration = matchSingleVCardPrefixedField("DURATION", rawText);
+    String location = matchSingleVCardPrefixedField("LOCATION", rawText);
+    String organizer = stripMailto(matchSingleVCardPrefixedField("ORGANIZER", rawText));
+
+    String[] attendees = matchVCardPrefixedField("ATTENDEE", rawText);
+    if (attendees != null) {
+      for (int i = 0; i < attendees.length; i++) {
+        attendees[i] = stripMailto(attendees[i]);
+      }
+    }
+    String description = matchSingleVCardPrefixedField("DESCRIPTION", rawText);
+
+    String geoString = matchSingleVCardPrefixedField("GEO", rawText);
+    double latitude;
+    double longitude;
+    if (geoString == null) {
+      latitude = Double.NaN;
+      longitude = Double.NaN;
+    } else {
+      int semicolon = geoString.indexOf(';');
+      if (semicolon < 0) {
+        return null;
+      }
+      try {
+        latitude = Double.parseDouble(geoString.substring(0, semicolon));
+        longitude = Double.parseDouble(geoString.substring(semicolon + 1));
+      } catch (NumberFormatException ignored) {
+        return null;
+      }
+    }
+
+    try {
+      return new CalendarParsedResult(summary,
+                                      start,
+                                      end,
+                                      duration,
+                                      location,
+                                      organizer,
+                                      attendees,
+                                      description,
+                                      latitude,
+                                      longitude);
+    } catch (IllegalArgumentException ignored) {
+      return null;
+    }
+  }
+
+  private static String matchSingleVCardPrefixedField(CharSequence prefix,
+                                                      String rawText) {
+    List<String> values = VCardResultParser.matchSingleVCardPrefixedField(prefix, rawText, true, false);
+    return values == null || values.isEmpty() ? null : values.get(0);
+  }
+
+  private static String[] matchVCardPrefixedField(CharSequence prefix, String rawText) {
+    List<List<String>> values = VCardResultParser.matchVCardPrefixedField(prefix, rawText, true, false);
+    if (values == null || values.isEmpty()) {
+      return null;
+    }
+    int size = values.size();
+    String[] result = new String[size];
+    for (int i = 0; i < size; i++) {
+      result[i] = values.get(i).get(0);
+    }
+    return result;
+  }
+
+  private static String stripMailto(String s) {
+    if (s != null && (s.startsWith("mailto:") || s.startsWith("MAILTO:"))) {
+      s = s.substring(7);
+    }
+    return s;
+  }
+
+}

src/client/result/VINParsedResult.java

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2014 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package com.google.zxing.client.result;
+
+/**
+ * Represents a parsed result that encodes a Vehicle Identification Number (VIN).
+ */
+public final class VINParsedResult extends ParsedResult {
+
+  private final String vin;
+  private final String worldManufacturerID;
+  private final String vehicleDescriptorSection;
+  private final String vehicleIdentifierSection;
+  private final String countryCode;
+  private final String vehicleAttributes;
+  private final int modelYear;
+  private final char plantCode;
+  private final String sequentialNumber;
+
+  public VINParsedResult(String vin,
+                         String worldManufacturerID,
+                         String vehicleDescriptorSection,
+                         String vehicleIdentifierSection,
+                         String countryCode,
+                         String vehicleAttributes,
+                         int modelYear,
+                         char plantCode,
+                         String sequentialNumber) {
+    super(ParsedResultType.VIN);
+    this.vin = vin;
+    this.worldManufacturerID = worldManufacturerID;
+    this.vehicleDescriptorSection = vehicleDescriptorSection;
+    this.vehicleIdentifierSection = vehicleIdentifierSection;
+    this.countryCode = countryCode;
+    this.vehicleAttributes = vehicleAttributes;
+    this.modelYear = modelYear;
+    this.plantCode = plantCode;
+    this.sequentialNumber = sequentialNumber;
+  }
+  
+  public String getVIN() {
+    return vin;
+  }
+
+  public String getWorldManufacturerID() {
+    return worldManufacturerID;
+  }
+
+  public String getVehicleDescriptorSection() {
+    return vehicleDescriptorSection;
+  }
+
+  public String getVehicleIdentifierSection() {
+    return vehicleIdentifierSection;
+  }
+
+  public String getCountryCode() {
+    return countryCode;
+  }
+
+  public String getVehicleAttributes() {
+    return vehicleAttributes;
+  }
+
+  public int getModelYear() {
+    return modelYear;
+  }
+
+  public char getPlantCode() {
+    return plantCode;
+  }
+
+  public String getSequentialNumber() {
+    return sequentialNumber;
+  }
+
+  @Override
+  public String getDisplayResult() {
+    StringBuilder result = new StringBuilder(50);
+    result.append(worldManufacturerID).append(' ');
+    result.append(vehicleDescriptorSection).append(' ');
+    result.append(vehicleIdentifierSection).append('\n');
+    if (countryCode != null) {
+      result.append(countryCode).append(' ');
+    }
+    result.append(modelYear).append(' ');
+    result.append(plantCode).append(' ');
+    result.append(sequentialNumber).append('\n');
+    return result.toString();
+  }
+}

src/client/result/VINResultParser.java

@@ -0,0 +1,209 @@
+/*
+ * Copyright 2014 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.Result;
+
+import java.util.regex.Pattern;
+
+/**
+ * Detects a result that is likely a vehicle identification number.
+ *
+ * @author Sean Owen
+ */
+public final class VINResultParser extends ResultParser {
+
+  private static final Pattern IOQ = Pattern.compile("[IOQ]");
+  private static final Pattern AZ09 = Pattern.compile("[A-Z0-9]{17}");
+
+  @Override
+  public VINParsedResult parse(Result result) {
+    if (result.getBarcodeFormat() != BarcodeFormat.CODE_39) {
+      return null;
+    }
+    String rawText = result.getText();
+    rawText = IOQ.matcher(rawText).replaceAll("").trim();
+    if (!AZ09.matcher(rawText).matches()) {
+      return null;
+    }
+    try {
+      if (!checkChecksum(rawText)) {
+        return null;
+      }
+      String wmi = rawText.substring(0, 3);
+      return new VINParsedResult(rawText,
+          wmi,
+          rawText.substring(3, 9),
+          rawText.substring(9, 17),
+          countryCode(wmi),
+          rawText.substring(3, 8),
+          modelYear(rawText.charAt(9)),
+          rawText.charAt(10),
+          rawText.substring(11));
+    } catch (IllegalArgumentException iae) {
+      return null;
+    }
+  }
+
+  private static boolean checkChecksum(CharSequence vin) {
+    int sum = 0;
+    for (int i = 0; i < vin.length(); i++) {
+      sum += vinPositionWeight(i + 1) * vinCharValue(vin.charAt(i));
+    }
+    char checkChar = vin.charAt(8);
+    char expectedCheckChar = checkChar(sum % 11);
+    return checkChar == expectedCheckChar;
+  }
+  
+  private static int vinCharValue(char c) {
+    if (c >= 'A' && c <= 'I') {
+      return (c - 'A') + 1;
+    }
+    if (c >= 'J' && c <= 'R') {
+      return (c - 'J') + 1;
+    }
+    if (c >= 'S' && c <= 'Z') {
+      return (c - 'S') + 2;
+    }
+    if (c >= '0' && c <= '9') {
+      return c - '0';
+    }
+    throw new IllegalArgumentException();
+  }
+  
+  private static int vinPositionWeight(int position) {
+    if (position >= 1 && position <= 7) {
+      return 9 - position;
+    }
+    if (position == 8) {
+      return 10;
+    }
+    if (position == 9) {
+      return 0;
+    }
+    if (position >= 10 && position <= 17) {
+      return 19 - position;
+    }
+    throw new IllegalArgumentException();
+  }
+
+  private static char checkChar(int remainder) {
+    if (remainder < 10) {
+      return (char) ('0' + remainder);
+    }
+    if (remainder == 10) {
+      return 'X';
+    }
+    throw new IllegalArgumentException();
+  }
+  
+  private static int modelYear(char c) {
+    if (c >= 'E' && c <= 'H') {
+      return (c - 'E') + 1984;
+    }
+    if (c >= 'J' && c <= 'N') {
+      return (c - 'J') + 1988;
+    }
+    if (c == 'P') {
+      return 1993;
+    }
+    if (c >= 'R' && c <= 'T') {
+      return (c - 'R') + 1994;
+    }
+    if (c >= 'V' && c <= 'Y') {
+      return (c - 'V') + 1997;
+    }
+    if (c >= '1' && c <= '9') {
+      return (c - '1') + 2001;
+    }
+    if (c >= 'A' && c <= 'D') {
+      return (c - 'A') + 2010;
+    }
+    throw new IllegalArgumentException();
+  }
+
+  private static String countryCode(CharSequence wmi) {
+    char c1 = wmi.charAt(0);
+    char c2 = wmi.charAt(1);
+    switch (c1) {
+      case '1':
+      case '4':
+      case '5':
+        return "US";
+      case '2':
+        return "CA";
+      case '3':
+        if (c2 >= 'A' && c2 <= 'W') {
+          return "MX";
+        }
+        break;
+      case '9':
+        if ((c2 >= 'A' && c2 <= 'E') || (c2 >= '3' && c2 <= '9')) {
+          return "BR";
+        }
+        break;
+      case 'J':
+        if (c2 >= 'A' && c2 <= 'T') {
+          return "JP";
+        }
+        break;
+      case 'K':
+        if (c2 >= 'L' && c2 <= 'R') {
+          return "KO";
+        }
+        break;
+      case 'L':
+        return "CN";
+      case 'M':
+        if (c2 >= 'A' && c2 <= 'E') {
+          return "IN";
+        }
+        break;
+      case 'S':
+        if (c2 >= 'A' && c2 <= 'M') {
+          return "UK";
+        }
+        if (c2 >= 'N' && c2 <= 'T') {
+          return "DE";
+        }
+        break;
+      case 'V':
+        if (c2 >= 'F' && c2 <= 'R') {
+          return "FR";
+        }
+        if (c2 >= 'S' && c2 <= 'W') {
+          return "ES";
+        }
+        break;
+      case 'W':
+        return "DE";
+      case 'X':
+        if (c2 == '0' || (c2 >= '3' && c2 <= '9')) {
+          return "RU";
+        }
+        break;
+      case 'Z':
+        if (c2 >= 'A' && c2 <= 'R') {
+          return "IT";
+        }
+        break;
+    }
+    return null;
+  }
+
+}

src/client/result/WifiParsedResult.java

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+/**
+ * Represents a parsed result that encodes wifi network information, like SSID and password.
+ *
+ * @author Vikram Aggarwal
+ */
+public final class WifiParsedResult extends ParsedResult {
+
+  private final String ssid;
+  private final String networkEncryption;
+  private final String password;
+  private final boolean hidden;
+  private final String identity;
+  private final String anonymousIdentity;
+  private final String eapMethod;
+  private final String phase2Method;
+
+  public WifiParsedResult(String networkEncryption, String ssid, String password) {
+    this(networkEncryption, ssid, password, false);
+  }
+
+  public WifiParsedResult(String networkEncryption, String ssid, String password, boolean hidden) {
+    this(networkEncryption, ssid, password, hidden, null, null, null, null);
+  }
+
+  public WifiParsedResult(String networkEncryption,
+                          String ssid,
+                          String password,
+                          boolean hidden,
+                          String identity,
+                          String anonymousIdentity,
+                          String eapMethod,
+                          String phase2Method) {
+    super(ParsedResultType.WIFI);
+    this.ssid = ssid;
+    this.networkEncryption = networkEncryption;
+    this.password = password;
+    this.hidden = hidden;
+    this.identity = identity;
+    this.anonymousIdentity = anonymousIdentity;
+    this.eapMethod = eapMethod;
+    this.phase2Method = phase2Method;
+  }
+
+  public String getSsid() {
+    return ssid;
+  }
+
+  public String getNetworkEncryption() {
+    return networkEncryption;
+  }
+
+  public String getPassword() {
+    return password;
+  }
+
+  public boolean isHidden() {
+    return hidden;
+  }
+
+  public String getIdentity() {
+    return identity;
+  }
+
+  public String getAnonymousIdentity() {
+    return anonymousIdentity;
+  }
+
+  public String getEapMethod() {
+    return eapMethod;
+  }
+
+  public String getPhase2Method() {
+    return phase2Method;
+  }
+
+  @Override
+  public String getDisplayResult() {
+    StringBuilder result = new StringBuilder(80);
+    maybeAppend(ssid, result);
+    maybeAppend(networkEncryption, result);
+    maybeAppend(password, result);
+    maybeAppend(Boolean.toString(hidden), result);
+    return result.toString();
+  }
+
+}

src/client/result/WifiResultParser.java

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.client.result;
+
+import com.google.zxing.Result;
+
+@SuppressWarnings("checkstyle:lineLength")
+/**
+ * <p>Parses a WIFI configuration string. Strings will be of the form:</p>
+ *
+ * <p>{@code WIFI:T:[network type];S:[network SSID];P:[network password];H:[hidden?];;}</p>
+ *
+ * <p>For WPA2 enterprise (EAP), strings will be of the form:</p>
+ *
+ * <p>{@code WIFI:T:WPA2-EAP;S:[network SSID];H:[hidden?];E:[EAP method];PH2:[Phase 2 method];A:[anonymous identity];I:[username];P:[password];;}</p>
+ *
+ * <p>"EAP method" can e.g. be "TTLS" or "PWD" or one of the other fields in <a href="https://developer.android.com/reference/android/net/wifi/WifiEnterpriseConfig.Eap.html">WifiEnterpriseConfig.Eap</a> and "Phase 2 method" can e.g. be "MSCHAPV2" or any of the other fields in <a href="https://developer.android.com/reference/android/net/wifi/WifiEnterpriseConfig.Phase2.html">WifiEnterpriseConfig.Phase2</a></p>
+ *
+ * <p>The fields can appear in any order. Only "S:" is required.</p>
+ *
+ * @author Vikram Aggarwal
+ * @author Sean Owen
+ * @author Steffen Kieß
+ */
+public final class WifiResultParser extends ResultParser {
+
+  @Override
+  public WifiParsedResult parse(Result result) {
+    String rawText = getMassagedText(result);
+    if (!rawText.startsWith("WIFI:")) {
+      return null;
+    }
+    rawText = rawText.substring("WIFI:".length());
+    String ssid = matchSinglePrefixedField("S:", rawText, ';', false);
+    if (ssid == null || ssid.isEmpty()) {
+      return null;
+    }
+    String pass = matchSinglePrefixedField("P:", rawText, ';', false);
+    String type = matchSinglePrefixedField("T:", rawText, ';', false);
+    if (type == null) {
+      type = "nopass";
+    }
+
+    // Unfortunately, in the past, H: was not just used for boolean 'hidden', but 'phase 2 method'.
+    // To try to retain backwards compatibility, we set one or the other based on whether the string
+    // is 'true' or 'false':
+    boolean hidden = false;
+    String phase2Method = matchSinglePrefixedField("PH2:", rawText, ';', false);
+    String hValue = matchSinglePrefixedField("H:", rawText, ';', false);
+    if (hValue != null) {
+      // If PH2 was specified separately, or if the value is clearly boolean, interpret it as 'hidden'
+      if (phase2Method != null || "true".equalsIgnoreCase(hValue) || "false".equalsIgnoreCase(hValue)) {
+        hidden = Boolean.parseBoolean(hValue);
+      } else {
+        phase2Method = hValue;
+      }
+    }
+
+    String identity = matchSinglePrefixedField("I:", rawText, ';', false);
+    String anonymousIdentity = matchSinglePrefixedField("A:", rawText, ';', false);
+    String eapMethod = matchSinglePrefixedField("E:", rawText, ';', false);
+
+    return new WifiParsedResult(type, ssid, pass, hidden, identity, anonymousIdentity, eapMethod, phase2Method);
+  }
+}

src/common/BitArray.java

@@ -0,0 +1,359 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common;
+
+import java.util.Arrays;
+
+/**
+ * <p>A simple, fast array of bits, represented compactly by an array of ints internally.</p>
+ *
+ * @author Sean Owen
+ */
+public final class BitArray implements Cloneable {
+
+  private static final int[] EMPTY_BITS = {};
+  private static final float LOAD_FACTOR = 0.75f;
+
+  private int[] bits;
+  private int size;
+
+  public BitArray() {
+    this.size = 0;
+    this.bits = EMPTY_BITS;
+  }
+
+  public BitArray(int size) {
+    this.size = size;
+    this.bits = makeArray(size);
+  }
+
+  // For testing only
+  BitArray(int[] bits, int size) {
+    this.bits = bits;
+    this.size = size;
+  }
+
+  public int getSize() {
+    return size;
+  }
+
+  public int getSizeInBytes() {
+    return (size + 7) / 8;
+  }
+
+  private void ensureCapacity(int newSize) {
+    if (newSize > bits.length * 32) {
+      int[] newBits = makeArray((int) Math.ceil(newSize / LOAD_FACTOR));
+      System.arraycopy(bits, 0, newBits, 0, bits.length);
+      this.bits = newBits;
+    }
+  }
+
+  /**
+   * @param i bit to get
+   * @return true iff bit i is set
+   */
+  public boolean get(int i) {
+    return (bits[i / 32] & (1 << (i & 0x1F))) != 0;
+  }
+
+  /**
+   * Sets bit i.
+   *
+   * @param i bit to set
+   */
+  public void set(int i) {
+    bits[i / 32] |= 1 << (i & 0x1F);
+  }
+
+  /**
+   * Flips bit i.
+   *
+   * @param i bit to set
+   */
+  public void flip(int i) {
+    bits[i / 32] ^= 1 << (i & 0x1F);
+  }
+
+  /**
+   * @param from first bit to check
+   * @return index of first bit that is set, starting from the given index, or size if none are set
+   *  at or beyond this given index
+   * @see #getNextUnset(int)
+   */
+  public int getNextSet(int from) {
+    if (from >= size) {
+      return size;
+    }
+    int bitsOffset = from / 32;
+    int currentBits = bits[bitsOffset];
+    // mask off lesser bits first
+    currentBits &= -(1 << (from & 0x1F));
+    while (currentBits == 0) {
+      if (++bitsOffset == bits.length) {
+        return size;
+      }
+      currentBits = bits[bitsOffset];
+    }
+    int result = (bitsOffset * 32) + Integer.numberOfTrailingZeros(currentBits);
+    return Math.min(result, size);
+  }
+
+  /**
+   * @param from index to start looking for unset bit
+   * @return index of next unset bit, or {@code size} if none are unset until the end
+   * @see #getNextSet(int)
+   */
+  public int getNextUnset(int from) {
+    if (from >= size) {
+      return size;
+    }
+    int bitsOffset = from / 32;
+    int currentBits = ~bits[bitsOffset];
+    // mask off lesser bits first
+    currentBits &= -(1 << (from & 0x1F));
+    while (currentBits == 0) {
+      if (++bitsOffset == bits.length) {
+        return size;
+      }
+      currentBits = ~bits[bitsOffset];
+    }
+    int result = (bitsOffset * 32) + Integer.numberOfTrailingZeros(currentBits);
+    return Math.min(result, size);
+  }
+
+  /**
+   * Sets a block of 32 bits, starting at bit i.
+   *
+   * @param i first bit to set
+   * @param newBits the new value of the next 32 bits. Note again that the least-significant bit
+   * corresponds to bit i, the next-least-significant to i+1, and so on.
+   */
+  public void setBulk(int i, int newBits) {
+    bits[i / 32] = newBits;
+  }
+
+  /**
+   * Sets a range of bits.
+   *
+   * @param start start of range, inclusive.
+   * @param end end of range, exclusive
+   */
+  public void setRange(int start, int end) {
+    if (end < start || start < 0 || end > size) {
+      throw new IllegalArgumentException();
+    }
+    if (end == start) {
+      return;
+    }
+    end--; // will be easier to treat this as the last actually set bit -- inclusive
+    int firstInt = start / 32;
+    int lastInt = end / 32;
+    for (int i = firstInt; i <= lastInt; i++) {
+      int firstBit = i > firstInt ? 0 : start & 0x1F;
+      int lastBit = i < lastInt ? 31 : end & 0x1F;
+      // Ones from firstBit to lastBit, inclusive
+      int mask = (2 << lastBit) - (1 << firstBit);
+      bits[i] |= mask;
+    }
+  }
+
+  /**
+   * Clears all bits (sets to false).
+   */
+  public void clear() {
+    int max = bits.length;
+    for (int i = 0; i < max; i++) {
+      bits[i] = 0;
+    }
+  }
+
+  /**
+   * Efficient method to check if a range of bits is set, or not set.
+   *
+   * @param start start of range, inclusive.
+   * @param end end of range, exclusive
+   * @param value if true, checks that bits in range are set, otherwise checks that they are not set
+   * @return true iff all bits are set or not set in range, according to value argument
+   * @throws IllegalArgumentException if end is less than start or the range is not contained in the array
+   */
+  public boolean isRange(int start, int end, boolean value) {
+    if (end < start || start < 0 || end > size) {
+      throw new IllegalArgumentException();
+    }
+    if (end == start) {
+      return true; // empty range matches
+    }
+    end--; // will be easier to treat this as the last actually set bit -- inclusive
+    int firstInt = start / 32;
+    int lastInt = end / 32;
+    for (int i = firstInt; i <= lastInt; i++) {
+      int firstBit = i > firstInt ? 0 : start & 0x1F;
+      int lastBit = i < lastInt ? 31 : end & 0x1F;
+      // Ones from firstBit to lastBit, inclusive
+      int mask = (2 << lastBit) - (1 << firstBit);
+
+      // Return false if we're looking for 1s and the masked bits[i] isn't all 1s (that is,
+      // equals the mask, or we're looking for 0s and the masked portion is not all 0s
+      if ((bits[i] & mask) != (value ? mask : 0)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  public void appendBit(boolean bit) {
+    ensureCapacity(size + 1);
+    if (bit) {
+      bits[size / 32] |= 1 << (size & 0x1F);
+    }
+    size++;
+  }
+
+  /**
+   * Appends the least-significant bits, from value, in order from most-significant to
+   * least-significant. For example, appending 6 bits from 0x000001E will append the bits
+   * 0, 1, 1, 1, 1, 0 in that order.
+   *
+   * @param value {@code int} containing bits to append
+   * @param numBits bits from value to append
+   */
+  public void appendBits(int value, int numBits) {
+    if (numBits < 0 || numBits > 32) {
+      throw new IllegalArgumentException("Num bits must be between 0 and 32");
+    }
+    int nextSize = size;
+    ensureCapacity(nextSize + numBits);
+    for (int numBitsLeft = numBits - 1; numBitsLeft >= 0; numBitsLeft--) {
+      if ((value & (1 << numBitsLeft)) != 0) {
+        bits[nextSize / 32] |= 1 << (nextSize & 0x1F);
+      }
+      nextSize++;
+    }
+    size = nextSize;
+  }
+
+  public void appendBitArray(BitArray other) {
+    int otherSize = other.size;
+    ensureCapacity(size + otherSize);
+    for (int i = 0; i < otherSize; i++) {
+      appendBit(other.get(i));
+    }
+  }
+
+  public void xor(BitArray other) {
+    if (size != other.size) {
+      throw new IllegalArgumentException("Sizes don't match");
+    }
+    for (int i = 0; i < bits.length; i++) {
+      // The last int could be incomplete (i.e. not have 32 bits in
+      // it) but there is no problem since 0 XOR 0 == 0.
+      bits[i] ^= other.bits[i];
+    }
+  }
+
+  /**
+   *
+   * @param bitOffset first bit to start writing
+   * @param array array to write into. Bytes are written most-significant byte first. This is the opposite
+   *  of the internal representation, which is exposed by {@link #getBitArray()}
+   * @param offset position in array to start writing
+   * @param numBytes how many bytes to write
+   */
+  public void toBytes(int bitOffset, byte[] array, int offset, int numBytes) {
+    for (int i = 0; i < numBytes; i++) {
+      int theByte = 0;
+      for (int j = 0; j < 8; j++) {
+        if (get(bitOffset)) {
+          theByte |= 1 << (7 - j);
+        }
+        bitOffset++;
+      }
+      array[offset + i] = (byte) theByte;
+    }
+  }
+
+  /**
+   * @return underlying array of ints. The first element holds the first 32 bits, and the least
+   *         significant bit is bit 0.
+   */
+  public int[] getBitArray() {
+    return bits;
+  }
+
+  /**
+   * Reverses all bits in the array.
+   */
+  public void reverse() {
+    int[] newBits = new int[bits.length];
+    // reverse all int's first
+    int len = (size - 1) / 32;
+    int oldBitsLen = len + 1;
+    for (int i = 0; i < oldBitsLen; i++) {
+      newBits[len - i] = Integer.reverse(bits[i]);
+    }
+    // now correct the int's if the bit size isn't a multiple of 32
+    if (size != oldBitsLen * 32) {
+      int leftOffset = oldBitsLen * 32 - size;
+      int currentInt = newBits[0] >>> leftOffset;
+      for (int i = 1; i < oldBitsLen; i++) {
+        int nextInt = newBits[i];
+        currentInt |= nextInt << (32 - leftOffset);
+        newBits[i - 1] = currentInt;
+        currentInt = nextInt >>> leftOffset;
+      }
+      newBits[oldBitsLen - 1] = currentInt;
+    }
+    bits = newBits;
+  }
+
+  private static int[] makeArray(int size) {
+    return new int[(size + 31) / 32];
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (!(o instanceof BitArray)) {
+      return false;
+    }
+    BitArray other = (BitArray) o;
+    return size == other.size && Arrays.equals(bits, other.bits);
+  }
+
+  @Override
+  public int hashCode() {
+    return 31 * size + Arrays.hashCode(bits);
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder result = new StringBuilder(size + (size / 8) + 1);
+    for (int i = 0; i < size; i++) {
+      if ((i & 0x07) == 0) {
+        result.append(' ');
+      }
+      result.append(get(i) ? 'X' : '.');
+    }
+    return result.toString();
+  }
+
+  @Override
+  public BitArray clone() {
+    return new BitArray(bits.clone(), size);
+  }
+
+}

src/common/BitMatrix.java

@@ -0,0 +1,537 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common;
+
+import java.util.Arrays;
+
+/**
+ * <p>Represents a 2D matrix of bits. In function arguments below, and throughout the common
+ * module, x is the column position, and y is the row position. The ordering is always x, y.
+ * The origin is at the top-left.</p>
+ *
+ * <p>Internally the bits are represented in a 1-D array of 32-bit ints. However, each row begins
+ * with a new int. This is done intentionally so that we can copy out a row into a BitArray very
+ * efficiently.</p>
+ *
+ * <p>The ordering of bits is row-major. Within each int, the least significant bits are used first,
+ * meaning they represent lower x values. This is compatible with BitArray's implementation.</p>
+ *
+ * @author Sean Owen
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+public final class BitMatrix implements Cloneable {
+
+  private int width;
+  private int height;
+  private int rowSize;
+  private int[] bits;
+
+  /**
+   * Creates an empty square {@code BitMatrix}.
+   *
+   * @param dimension height and width
+   */
+  public BitMatrix(int dimension) {
+    this(dimension, dimension);
+  }
+
+  /**
+   * Creates an empty {@code BitMatrix}.
+   *
+   * @param width bit matrix width
+   * @param height bit matrix height
+   */
+  public BitMatrix(int width, int height) {
+    if (width < 1 || height < 1) {
+      throw new IllegalArgumentException("Both dimensions must be greater than 0");
+    }
+    this.width = width;
+    this.height = height;
+    this.rowSize = (width + 31) / 32;
+    bits = new int[rowSize * height];
+  }
+
+  private BitMatrix(int width, int height, int rowSize, int[] bits) {
+    this.width = width;
+    this.height = height;
+    this.rowSize = rowSize;
+    this.bits = bits;
+  }
+
+  /**
+   * Interprets a 2D array of booleans as a {@code BitMatrix}, where "true" means an "on" bit.
+   *
+   * @param image bits of the image, as a row-major 2D array. Elements are arrays representing rows
+   * @return {@code BitMatrix} representation of image
+   */
+  public static BitMatrix parse(boolean[][] image) {
+    int height = image.length;
+    int width = image[0].length;
+    BitMatrix bits = new BitMatrix(width, height);
+    for (int i = 0; i < height; i++) {
+      boolean[] imageI = image[i];
+      for (int j = 0; j < width; j++) {
+        if (imageI[j]) {
+          bits.set(j, i);
+        }
+      }
+    }
+    return bits;
+  }
+
+  public static BitMatrix parse(String stringRepresentation, String setString, String unsetString) {
+    if (stringRepresentation == null) {
+      throw new IllegalArgumentException();
+    }
+
+    boolean[] bits = new boolean[stringRepresentation.length()];
+    int bitsPos = 0;
+    int rowStartPos = 0;
+    int rowLength = -1;
+    int nRows = 0;
+    int pos = 0;
+    while (pos < stringRepresentation.length()) {
+      if (stringRepresentation.charAt(pos) == '\n' ||
+          stringRepresentation.charAt(pos) == '\r') {
+        if (bitsPos > rowStartPos) {
+          if (rowLength == -1) {
+            rowLength = bitsPos - rowStartPos;
+          } else if (bitsPos - rowStartPos != rowLength) {
+            throw new IllegalArgumentException("row lengths do not match");
+          }
+          rowStartPos = bitsPos;
+          nRows++;
+        }
+        pos++;
+      }  else if (stringRepresentation.startsWith(setString, pos)) {
+        pos += setString.length();
+        bits[bitsPos] = true;
+        bitsPos++;
+      } else if (stringRepresentation.startsWith(unsetString, pos)) {
+        pos += unsetString.length();
+        bits[bitsPos] = false;
+        bitsPos++;
+      } else {
+        throw new IllegalArgumentException(
+            "illegal character encountered: " + stringRepresentation.substring(pos));
+      }
+    }
+
+    // no EOL at end?
+    if (bitsPos > rowStartPos) {
+      if (rowLength == -1) {
+        rowLength = bitsPos - rowStartPos;
+      } else if (bitsPos - rowStartPos != rowLength) {
+        throw new IllegalArgumentException("row lengths do not match");
+      }
+      nRows++;
+    }
+
+    BitMatrix matrix = new BitMatrix(rowLength, nRows);
+    for (int i = 0; i < bitsPos; i++) {
+      if (bits[i]) {
+        matrix.set(i % rowLength, i / rowLength);
+      }
+    }
+    return matrix;
+  }
+
+  /**
+   * <p>Gets the requested bit, where true means black.</p>
+   *
+   * @param x The horizontal component (i.e. which column)
+   * @param y The vertical component (i.e. which row)
+   * @return value of given bit in matrix
+   */
+  public boolean get(int x, int y) {
+    int offset = y * rowSize + (x / 32);
+    return ((bits[offset] >>> (x & 0x1f)) & 1) != 0;
+  }
+
+  /**
+   * <p>Sets the given bit to true.</p>
+   *
+   * @param x The horizontal component (i.e. which column)
+   * @param y The vertical component (i.e. which row)
+   */
+  public void set(int x, int y) {
+    int offset = y * rowSize + (x / 32);
+    bits[offset] |= 1 << (x & 0x1f);
+  }
+
+  public void unset(int x, int y) {
+    int offset = y * rowSize + (x / 32);
+    bits[offset] &= ~(1 << (x & 0x1f));
+  }
+
+  /**
+   * <p>Flips the given bit.</p>
+   *
+   * @param x The horizontal component (i.e. which column)
+   * @param y The vertical component (i.e. which row)
+   */
+  public void flip(int x, int y) {
+    int offset = y * rowSize + (x / 32);
+    bits[offset] ^= 1 << (x & 0x1f);
+  }
+
+  /**
+   * <p>Flips every bit in the matrix.</p>
+   */
+  public void flip() {
+    int max = bits.length;
+    for (int i = 0; i < max; i++) {
+      bits[i] = ~bits[i];
+    }
+  }
+
+  /**
+   * Exclusive-or (XOR): Flip the bit in this {@code BitMatrix} if the corresponding
+   * mask bit is set.
+   *
+   * @param mask XOR mask
+   */
+  public void xor(BitMatrix mask) {
+    if (width != mask.width || height != mask.height || rowSize != mask.rowSize) {
+      throw new IllegalArgumentException("input matrix dimensions do not match");
+    }
+    BitArray rowArray = new BitArray(width);
+    for (int y = 0; y < height; y++) {
+      int offset = y * rowSize;
+      int[] row = mask.getRow(y, rowArray).getBitArray();
+      for (int x = 0; x < rowSize; x++) {
+        bits[offset + x] ^= row[x];
+      }
+    }
+  }
+
+  /**
+   * Clears all bits (sets to false).
+   */
+  public void clear() {
+    int max = bits.length;
+    for (int i = 0; i < max; i++) {
+      bits[i] = 0;
+    }
+  }
+
+  /**
+   * <p>Sets a square region of the bit matrix to true.</p>
+   *
+   * @param left The horizontal position to begin at (inclusive)
+   * @param top The vertical position to begin at (inclusive)
+   * @param width The width of the region
+   * @param height The height of the region
+   */
+  public void setRegion(int left, int top, int width, int height) {
+    if (top < 0 || left < 0) {
+      throw new IllegalArgumentException("Left and top must be nonnegative");
+    }
+    if (height < 1 || width < 1) {
+      throw new IllegalArgumentException("Height and width must be at least 1");
+    }
+    int right = left + width;
+    int bottom = top + height;
+    if (bottom > this.height || right > this.width) {
+      throw new IllegalArgumentException("The region must fit inside the matrix");
+    }
+    for (int y = top; y < bottom; y++) {
+      int offset = y * rowSize;
+      for (int x = left; x < right; x++) {
+        bits[offset + (x / 32)] |= 1 << (x & 0x1f);
+      }
+    }
+  }
+
+  /**
+   * A fast method to retrieve one row of data from the matrix as a BitArray.
+   *
+   * @param y The row to retrieve
+   * @param row An optional caller-allocated BitArray, will be allocated if null or too small
+   * @return The resulting BitArray - this reference should always be used even when passing
+   *         your own row
+   */
+  public BitArray getRow(int y, BitArray row) {
+    if (row == null || row.getSize() < width) {
+      row = new BitArray(width);
+    } else {
+      row.clear();
+    }
+    int offset = y * rowSize;
+    for (int x = 0; x < rowSize; x++) {
+      row.setBulk(x * 32, bits[offset + x]);
+    }
+    return row;
+  }
+
+  /**
+   * @param y row to set
+   * @param row {@link BitArray} to copy from
+   */
+  public void setRow(int y, BitArray row) {
+    System.arraycopy(row.getBitArray(), 0, bits, y * rowSize, rowSize);
+  }
+
+  /**
+   * Modifies this {@code BitMatrix} to represent the same but rotated the given degrees (0, 90, 180, 270)
+   *
+   * @param degrees number of degrees to rotate through counter-clockwise (0, 90, 180, 270)
+   */
+  public void rotate(int degrees) {
+    switch (degrees % 360) {
+      case 0:
+        return;
+      case 90:
+        rotate90();
+        return;
+      case 180:
+        rotate180();
+        return;
+      case 270:
+        rotate90();
+        rotate180();
+        return;
+    }
+    throw new IllegalArgumentException("degrees must be a multiple of 0, 90, 180, or 270");
+  }
+
+  /**
+   * Modifies this {@code BitMatrix} to represent the same but rotated 180 degrees
+   */
+  public void rotate180() {
+    BitArray topRow = new BitArray(width);
+    BitArray bottomRow = new BitArray(width);
+    int maxHeight = (height + 1) / 2;
+    for (int i = 0; i < maxHeight; i++) {
+      topRow = getRow(i, topRow);
+      int bottomRowIndex = height - 1 - i;
+      bottomRow = getRow(bottomRowIndex, bottomRow);
+      topRow.reverse();
+      bottomRow.reverse();
+      setRow(i, bottomRow);
+      setRow(bottomRowIndex, topRow);
+    }
+  }
+
+  /**
+   * Modifies this {@code BitMatrix} to represent the same but rotated 90 degrees counterclockwise
+   */
+  public void rotate90() {
+    int newWidth = height;
+    int newHeight = width;
+    int newRowSize = (newWidth + 31) / 32;
+    int[] newBits = new int[newRowSize * newHeight];
+
+    for (int y = 0; y < height; y++) {
+      for (int x = 0; x < width; x++) {
+        int offset = y * rowSize + (x / 32);
+        if (((bits[offset] >>> (x & 0x1f)) & 1) != 0) {
+          int newOffset = (newHeight - 1 - x) * newRowSize + (y / 32);
+          newBits[newOffset] |= 1 << (y & 0x1f);
+        }
+      }
+    }
+    width = newWidth;
+    height = newHeight;
+    rowSize = newRowSize;
+    bits = newBits;
+  }
+
+  /**
+   * This is useful in detecting the enclosing rectangle of a 'pure' barcode.
+   *
+   * @return {@code left,top,width,height} enclosing rectangle of all 1 bits, or null if it is all white
+   */
+  public int[] getEnclosingRectangle() {
+    int left = width;
+    int top = height;
+    int right = -1;
+    int bottom = -1;
+
+    for (int y = 0; y < height; y++) {
+      for (int x32 = 0; x32 < rowSize; x32++) {
+        int theBits = bits[y * rowSize + x32];
+        if (theBits != 0) {
+          if (y < top) {
+            top = y;
+          }
+          if (y > bottom) {
+            bottom = y;
+          }
+          if (x32 * 32 < left) {
+            int bit = 0;
+            while ((theBits << (31 - bit)) == 0) {
+              bit++;
+            }
+            if ((x32 * 32 + bit) < left) {
+              left = x32 * 32 + bit;
+            }
+          }
+          if (x32 * 32 + 31 > right) {
+            int bit = 31;
+            while ((theBits >>> bit) == 0) {
+              bit--;
+            }
+            if ((x32 * 32 + bit) > right) {
+              right = x32 * 32 + bit;
+            }
+          }
+        }
+      }
+    }
+
+    if (right < left || bottom < top) {
+      return null;
+    }
+
+    return new int[] {left, top, right - left + 1, bottom - top + 1};
+  }
+
+  /**
+   * This is useful in detecting a corner of a 'pure' barcode.
+   *
+   * @return {@code x,y} coordinate of top-left-most 1 bit, or null if it is all white
+   */
+  public int[] getTopLeftOnBit() {
+    int bitsOffset = 0;
+    while (bitsOffset < bits.length && bits[bitsOffset] == 0) {
+      bitsOffset++;
+    }
+    if (bitsOffset == bits.length) {
+      return null;
+    }
+    int y = bitsOffset / rowSize;
+    int x = (bitsOffset % rowSize) * 32;
+
+    int theBits = bits[bitsOffset];
+    int bit = 0;
+    while ((theBits << (31 - bit)) == 0) {
+      bit++;
+    }
+    x += bit;
+    return new int[] {x, y};
+  }
+
+  public int[] getBottomRightOnBit() {
+    int bitsOffset = bits.length - 1;
+    while (bitsOffset >= 0 && bits[bitsOffset] == 0) {
+      bitsOffset--;
+    }
+    if (bitsOffset < 0) {
+      return null;
+    }
+
+    int y = bitsOffset / rowSize;
+    int x = (bitsOffset % rowSize) * 32;
+
+    int theBits = bits[bitsOffset];
+    int bit = 31;
+    while ((theBits >>> bit) == 0) {
+      bit--;
+    }
+    x += bit;
+
+    return new int[] {x, y};
+  }
+
+  /**
+   * @return The width of the matrix
+   */
+  public int getWidth() {
+    return width;
+  }
+
+  /**
+   * @return The height of the matrix
+   */
+  public int getHeight() {
+    return height;
+  }
+
+  /**
+   * @return The row size of the matrix
+   */
+  public int getRowSize() {
+    return rowSize;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (!(o instanceof BitMatrix)) {
+      return false;
+    }
+    BitMatrix other = (BitMatrix) o;
+    return width == other.width && height == other.height && rowSize == other.rowSize &&
+    Arrays.equals(bits, other.bits);
+  }
+
+  @Override
+  public int hashCode() {
+    int hash = width;
+    hash = 31 * hash + width;
+    hash = 31 * hash + height;
+    hash = 31 * hash + rowSize;
+    hash = 31 * hash + Arrays.hashCode(bits);
+    return hash;
+  }
+
+  /**
+   * @return string representation using "X" for set and " " for unset bits
+   */
+  @Override
+  public String toString() {
+    return toString("X ", "  ");
+  }
+
+  /**
+   * @param setString representation of a set bit
+   * @param unsetString representation of an unset bit
+   * @return string representation of entire matrix utilizing given strings
+   */
+  public String toString(String setString, String unsetString) {
+    return buildToString(setString, unsetString, "\n");
+  }
+
+  /**
+   * @param setString representation of a set bit
+   * @param unsetString representation of an unset bit
+   * @param lineSeparator newline character in string representation
+   * @return string representation of entire matrix utilizing given strings and line separator
+   * @deprecated call {@link #toString(String,String)} only, which uses \n line separator always
+   */
+  @Deprecated
+  public String toString(String setString, String unsetString, String lineSeparator) {
+    return buildToString(setString, unsetString, lineSeparator);
+  }
+
+  private String buildToString(String setString, String unsetString, String lineSeparator) {
+    StringBuilder result = new StringBuilder(height * (width + 1));
+    for (int y = 0; y < height; y++) {
+      for (int x = 0; x < width; x++) {
+        result.append(get(x, y) ? setString : unsetString);
+      }
+      result.append(lineSeparator);
+    }
+    return result.toString();
+  }
+
+  @Override
+  public BitMatrix clone() {
+    return new BitMatrix(width, height, rowSize, bits.clone());
+  }
+
+}

src/common/BitSource.java

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common;
+
+/**
+ * <p>This provides an easy abstraction to read bits at a time from a sequence of bytes, where the
+ * number of bits read is not often a multiple of 8.</p>
+ *
+ * <p>This class is thread-safe but not reentrant -- unless the caller modifies the bytes array
+ * it passed in, in which case all bets are off.</p>
+ *
+ * @author Sean Owen
+ */
+public final class BitSource {
+
+  private final byte[] bytes;
+  private int byteOffset;
+  private int bitOffset;
+
+  /**
+   * @param bytes bytes from which this will read bits. Bits will be read from the first byte first.
+   * Bits are read within a byte from most-significant to least-significant bit.
+   */
+  public BitSource(byte[] bytes) {
+    this.bytes = bytes;
+  }
+
+  /**
+   * @return index of next bit in current byte which would be read by the next call to {@link #readBits(int)}.
+   */
+  public int getBitOffset() {
+    return bitOffset;
+  }
+
+  /**
+   * @return index of next byte in input byte array which would be read by the next call to {@link #readBits(int)}.
+   */
+  public int getByteOffset() {
+    return byteOffset;
+  }
+
+  /**
+   * @param numBits number of bits to read
+   * @return int representing the bits read. The bits will appear as the least-significant
+   *         bits of the int
+   * @throws IllegalArgumentException if numBits isn't in [1,32] or more than is available
+   */
+  public int readBits(int numBits) {
+    if (numBits < 1 || numBits > 32 || numBits > available()) {
+      throw new IllegalArgumentException(String.valueOf(numBits));
+    }
+
+    int result = 0;
+
+    // First, read remainder from current byte
+    if (bitOffset > 0) {
+      int bitsLeft = 8 - bitOffset;
+      int toRead = Math.min(numBits, bitsLeft);
+      int bitsToNotRead = bitsLeft - toRead;
+      int mask = (0xFF >> (8 - toRead)) << bitsToNotRead;
+      result = (bytes[byteOffset] & mask) >> bitsToNotRead;
+      numBits -= toRead;
+      bitOffset += toRead;
+      if (bitOffset == 8) {
+        bitOffset = 0;
+        byteOffset++;
+      }
+    }
+
+    // Next read whole bytes
+    if (numBits > 0) {
+      while (numBits >= 8) {
+        result = (result << 8) | (bytes[byteOffset] & 0xFF);
+        byteOffset++;
+        numBits -= 8;
+      }
+
+      // Finally read a partial byte
+      if (numBits > 0) {
+        int bitsToNotRead = 8 - numBits;
+        int mask = (0xFF >> bitsToNotRead) << bitsToNotRead;
+        result = (result << numBits) | ((bytes[byteOffset] & mask) >> bitsToNotRead);
+        bitOffset += numBits;
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * @return number of bits that can be read successfully
+   */
+  public int available() {
+    return 8 * (bytes.length - byteOffset) - bitOffset;
+  }
+
+}

src/common/CharacterSetECI.java

@@ -0,0 +1,133 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common;
+
+import com.google.zxing.FormatException;
+
+import java.nio.charset.Charset;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Encapsulates a Character Set ECI, according to "Extended Channel Interpretations" 5.3.1.1
+ * of ISO 18004.
+ *
+ * @author Sean Owen
+ */
+public enum CharacterSetECI {
+
+  // Enum name is a Java encoding valid for java.lang and java.io
+  Cp437(new int[]{0,2}),
+  ISO8859_1(new int[]{1,3}, "ISO-8859-1"),
+  ISO8859_2(4, "ISO-8859-2"),
+  ISO8859_3(5, "ISO-8859-3"),
+  ISO8859_4(6, "ISO-8859-4"),
+  ISO8859_5(7, "ISO-8859-5"),
+  // ISO8859_6(8, "ISO-8859-6"),
+  ISO8859_7(9, "ISO-8859-7"),
+  // ISO8859_8(10, "ISO-8859-8"),
+  ISO8859_9(11, "ISO-8859-9"),
+  // ISO8859_10(12, "ISO-8859-10"),
+  // ISO8859_11(13, "ISO-8859-11"),
+  ISO8859_13(15, "ISO-8859-13"),
+  // ISO8859_14(16, "ISO-8859-14"),
+  ISO8859_15(17, "ISO-8859-15"),
+  ISO8859_16(18, "ISO-8859-16"),
+  SJIS(20, "Shift_JIS"),
+  Cp1250(21, "windows-1250"),
+  Cp1251(22, "windows-1251"),
+  Cp1252(23, "windows-1252"),
+  Cp1256(24, "windows-1256"),
+  UnicodeBigUnmarked(25, "UTF-16BE", "UnicodeBig"),
+  UTF8(26, "UTF-8"),
+  ASCII(new int[] {27, 170}, "US-ASCII"),
+  Big5(28),
+  GB18030(29, "GB2312", "EUC_CN", "GBK"),
+  EUC_KR(30, "EUC-KR");
+
+  private static final Map<Integer,CharacterSetECI> VALUE_TO_ECI = new HashMap<>();
+  private static final Map<String,CharacterSetECI> NAME_TO_ECI = new HashMap<>();
+  static {
+    for (CharacterSetECI eci : values()) {
+      for (int value : eci.values) {
+        VALUE_TO_ECI.put(value, eci);
+      }
+      NAME_TO_ECI.put(eci.name(), eci);
+      for (String name : eci.otherEncodingNames) {
+        NAME_TO_ECI.put(name, eci);
+      }
+    }
+  }
+
+  private final int[] values;
+  private final String[] otherEncodingNames;
+
+  CharacterSetECI(int value) {
+    this(new int[] {value});
+  }
+
+  CharacterSetECI(int value, String... otherEncodingNames) {
+    this.values = new int[] {value};
+    this.otherEncodingNames = otherEncodingNames;
+  }
+
+  CharacterSetECI(int[] values, String... otherEncodingNames) {
+    this.values = values;
+    this.otherEncodingNames = otherEncodingNames;
+  }
+
+  public int getValue() {
+    return values[0];
+  }
+
+  public Charset getCharset() {
+    return Charset.forName(name());
+  }
+
+  /**
+   * @param charset Java character set object
+   * @return CharacterSetECI representing ECI for character encoding, or null if it is legal
+   *   but unsupported
+   */
+  public static CharacterSetECI getCharacterSetECI(Charset charset) {
+    return NAME_TO_ECI.get(charset.name());
+  }
+
+  /**
+   * @param value character set ECI value
+   * @return {@code CharacterSetECI} representing ECI of given value, or null if it is legal but
+   *   unsupported
+   * @throws FormatException if ECI value is invalid
+   */
+  public static CharacterSetECI getCharacterSetECIByValue(int value) throws FormatException {
+    if (value < 0 || value >= 900) {
+      throw FormatException.getFormatInstance();
+    }
+    return VALUE_TO_ECI.get(value);
+  }
+
+  /**
+   * @param name character set ECI encoding name
+   * @return CharacterSetECI representing ECI for character encoding, or null if it is legal
+   *   but unsupported
+   */
+  public static CharacterSetECI getCharacterSetECIByName(String name) {
+    return NAME_TO_ECI.get(name);
+  }
+
+}

src/common/DecoderResult.java

@@ -0,0 +1,176 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common;
+
+import java.util.List;
+
+/**
+ * <p>Encapsulates the result of decoding a matrix of bits. This typically
+ * applies to 2D barcode formats. For now it contains the raw bytes obtained,
+ * as well as a String interpretation of those bytes, if applicable.</p>
+ *
+ * @author Sean Owen
+ */
+public final class DecoderResult {
+
+  private final byte[] rawBytes;
+  private int numBits;
+  private final String text;
+  private final List<byte[]> byteSegments;
+  private final String ecLevel;
+  private Integer errorsCorrected;
+  private Integer erasures;
+  private Object other;
+  private final int structuredAppendParity;
+  private final int structuredAppendSequenceNumber;
+  private final int symbologyModifier;
+
+  public DecoderResult(byte[] rawBytes,
+                       String text,
+                       List<byte[]> byteSegments,
+                       String ecLevel) {
+    this(rawBytes, text, byteSegments, ecLevel, -1, -1, 0);
+  }
+
+  public DecoderResult(byte[] rawBytes,
+                       String text,
+                       List<byte[]> byteSegments,
+                       String ecLevel,
+                       int symbologyModifier) {
+    this(rawBytes, text, byteSegments, ecLevel, -1, -1, symbologyModifier);
+  }
+
+  public DecoderResult(byte[] rawBytes,
+                       String text,
+                       List<byte[]> byteSegments,
+                       String ecLevel,
+                       int saSequence,
+                       int saParity) {
+    this(rawBytes, text, byteSegments, ecLevel, saSequence, saParity, 0);
+  }
+
+  public DecoderResult(byte[] rawBytes,
+                       String text,
+                       List<byte[]> byteSegments,
+                       String ecLevel,
+                       int saSequence,
+                       int saParity,
+                       int symbologyModifier) {
+    this.rawBytes = rawBytes;
+    this.numBits = rawBytes == null ? 0 : 8 * rawBytes.length;
+    this.text = text;
+    this.byteSegments = byteSegments;
+    this.ecLevel = ecLevel;
+    this.structuredAppendParity = saParity;
+    this.structuredAppendSequenceNumber = saSequence;
+    this.symbologyModifier = symbologyModifier;
+  }
+
+  /**
+   * @return raw bytes representing the result, or {@code null} if not applicable
+   */
+  public byte[] getRawBytes() {
+    return rawBytes;
+  }
+
+  /**
+   * @return how many bits of {@link #getRawBytes()} are valid; typically 8 times its length
+   * @since 3.3.0
+   */
+  public int getNumBits() {
+    return numBits;
+  }
+
+  /**
+   * @param numBits overrides the number of bits that are valid in {@link #getRawBytes()}
+   * @since 3.3.0
+   */
+  public void setNumBits(int numBits) {
+    this.numBits = numBits;
+  }
+
+  /**
+   * @return text representation of the result
+   */
+  public String getText() {
+    return text;
+  }
+
+  /**
+   * @return list of byte segments in the result, or {@code null} if not applicable
+   */
+  public List<byte[]> getByteSegments() {
+    return byteSegments;
+  }
+
+  /**
+   * @return name of error correction level used, or {@code null} if not applicable
+   */
+  public String getECLevel() {
+    return ecLevel;
+  }
+
+  /**
+   * @return number of errors corrected, or {@code null} if not applicable
+   */
+  public Integer getErrorsCorrected() {
+    return errorsCorrected;
+  }
+
+  public void setErrorsCorrected(Integer errorsCorrected) {
+    this.errorsCorrected = errorsCorrected;
+  }
+
+  /**
+   * @return number of erasures corrected, or {@code null} if not applicable
+   */
+  public Integer getErasures() {
+    return erasures;
+  }
+
+  public void setErasures(Integer erasures) {
+    this.erasures = erasures;
+  }
+
+  /**
+   * @return arbitrary additional metadata
+   */
+  public Object getOther() {
+    return other;
+  }
+
+  public void setOther(Object other) {
+    this.other = other;
+  }
+
+  public boolean hasStructuredAppend() {
+    return structuredAppendParity >= 0 && structuredAppendSequenceNumber >= 0;
+  }
+
+  public int getStructuredAppendParity() {
+    return structuredAppendParity;
+  }
+
+  public int getStructuredAppendSequenceNumber() {
+    return structuredAppendSequenceNumber;
+  }
+
+  public int getSymbologyModifier() {
+    return symbologyModifier;
+  }
+
+}

src/common/DefaultGridSampler.java

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common;
+
+import com.google.zxing.NotFoundException;
+
+/**
+ * @author Sean Owen
+ */
+public final class DefaultGridSampler extends GridSampler {
+
+  @Override
+  public BitMatrix sampleGrid(BitMatrix image,
+                              int dimensionX,
+                              int dimensionY,
+                              float p1ToX, float p1ToY,
+                              float p2ToX, float p2ToY,
+                              float p3ToX, float p3ToY,
+                              float p4ToX, float p4ToY,
+                              float p1FromX, float p1FromY,
+                              float p2FromX, float p2FromY,
+                              float p3FromX, float p3FromY,
+                              float p4FromX, float p4FromY) throws NotFoundException {
+
+    PerspectiveTransform transform = PerspectiveTransform.quadrilateralToQuadrilateral(
+        p1ToX, p1ToY, p2ToX, p2ToY, p3ToX, p3ToY, p4ToX, p4ToY,
+        p1FromX, p1FromY, p2FromX, p2FromY, p3FromX, p3FromY, p4FromX, p4FromY);
+
+    return sampleGrid(image, dimensionX, dimensionY, transform);
+  }
+
+  @Override
+  public BitMatrix sampleGrid(BitMatrix image,
+                              int dimensionX,
+                              int dimensionY,
+                              PerspectiveTransform transform) throws NotFoundException {
+    if (dimensionX <= 0 || dimensionY <= 0) {
+      throw NotFoundException.getNotFoundInstance();
+    }
+    BitMatrix bits = new BitMatrix(dimensionX, dimensionY);
+    float[] points = new float[2 * dimensionX];
+    for (int y = 0; y < dimensionY; y++) {
+      int max = points.length;
+      float iValue = y + 0.5f;
+      for (int x = 0; x < max; x += 2) {
+        points[x] = (float) (x / 2) + 0.5f;
+        points[x + 1] = iValue;
+      }
+      transform.transformPoints(points);
+      // Quick check to see if points transformed to something inside the image;
+      // sufficient to check the endpoints
+      checkAndNudgePoints(image, points);
+      try {
+        for (int x = 0; x < max; x += 2) {
+          if (image.get((int) points[x], (int) points[x + 1])) {
+            // Black(-ish) pixel
+            bits.set(x / 2, y);
+          }
+        }
+      } catch (ArrayIndexOutOfBoundsException aioobe) {
+        // This feels wrong, but, sometimes if the finder patterns are misidentified, the resulting
+        // transform gets "twisted" such that it maps a straight line of points to a set of points
+        // whose endpoints are in bounds, but others are not. There is probably some mathematical
+        // way to detect this about the transformation that I don't know yet.
+        // This results in an ugly runtime exception despite our clever checks above -- can't have
+        // that. We could check each point's coordinates but that feels duplicative. We settle for
+        // catching and wrapping ArrayIndexOutOfBoundsException.
+        throw NotFoundException.getNotFoundInstance();
+      }
+    }
+    return bits;
+  }
+
+}

src/common/DetectorResult.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common;
+
+import com.google.zxing.ResultPoint;
+
+/**
+ * <p>Encapsulates the result of detecting a barcode in an image. This includes the raw
+ * matrix of black/white pixels corresponding to the barcode, and possibly points of interest
+ * in the image, like the location of finder patterns or corners of the barcode in the image.</p>
+ *
+ * @author Sean Owen
+ */
+public class DetectorResult {
+
+  private final BitMatrix bits;
+  private final ResultPoint[] points;
+
+  public DetectorResult(BitMatrix bits, ResultPoint[] points) {
+    this.bits = bits;
+    this.points = points;
+  }
+
+  public final BitMatrix getBits() {
+    return bits;
+  }
+
+  public final ResultPoint[] getPoints() {
+    return points;
+  }
+
+}

src/common/ECIEncoderSet.java

@@ -0,0 +1,199 @@
+/*
+ * Copyright 2021 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common;
+
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetEncoder;
+import java.nio.charset.StandardCharsets;
+import java.nio.charset.UnsupportedCharsetException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Set of CharsetEncoders for a given input string
+ *
+ * Invariants:
+ * - The list contains only encoders from CharacterSetECI (list is shorter then the list of encoders available on
+ *   the platform for which ECI values are defined).
+ * - The list contains encoders at least one encoder for every character in the input.
+ * - The first encoder in the list is always the ISO-8859-1 encoder even of no character in the input can be encoded
+ *       by it.
+ * - If the input contains a character that is not in ISO-8859-1 then the last two entries in the list will be the
+ *   UTF-8 encoder and the UTF-16BE encoder.
+ *
+ * @author Alex Geller
+ */
+public final class ECIEncoderSet {
+
+  // List of encoders that potentially encode characters not in ISO-8859-1 in one byte.
+  private static final List<CharsetEncoder> ENCODERS = new ArrayList<>();
+  static {
+    String[] names = { "IBM437",
+                       "ISO-8859-2",
+                       "ISO-8859-3",
+                       "ISO-8859-4",
+                       "ISO-8859-5",
+                       "ISO-8859-6",
+                       "ISO-8859-7",
+                       "ISO-8859-8",
+                       "ISO-8859-9",
+                       "ISO-8859-10",
+                       "ISO-8859-11",
+                       "ISO-8859-13",
+                       "ISO-8859-14",
+                       "ISO-8859-15",
+                       "ISO-8859-16",
+                       "windows-1250",
+                       "windows-1251",
+                       "windows-1252",
+                       "windows-1256",
+                       "Shift_JIS" };
+    for (String name : names) {
+      if (CharacterSetECI.getCharacterSetECIByName(name) != null) {
+        try {
+          ENCODERS.add(Charset.forName(name).newEncoder());
+        } catch (UnsupportedCharsetException e) {
+          // continue
+        }
+      }
+    }
+  }
+
+  private final CharsetEncoder[] encoders;
+  private final int priorityEncoderIndex;
+
+  /**
+   * Constructs an encoder set
+   *
+   * @param stringToEncode the string that needs to be encoded
+   * @param priorityCharset The preferred {@link Charset} or null.
+   * @param fnc1 fnc1 denotes the character in the input that represents the FNC1 character or -1 for a non-GS1 bar
+   * code. When specified, it is considered an error to pass it as argument to the methods canEncode() or encode().
+   */
+  public ECIEncoderSet(String stringToEncode, Charset priorityCharset, int fnc1) {
+    List<CharsetEncoder> neededEncoders = new ArrayList<>();
+
+    //we always need the ISO-8859-1 encoder. It is the default encoding
+    neededEncoders.add(StandardCharsets.ISO_8859_1.newEncoder());
+    boolean needUnicodeEncoder = priorityCharset != null && priorityCharset.name().startsWith("UTF");
+
+    //Walk over the input string and see if all characters can be encoded with the list of encoders 
+    for (int i = 0; i < stringToEncode.length(); i++) {
+      boolean canEncode = false;
+      for (CharsetEncoder encoder : neededEncoders) {
+        char c = stringToEncode.charAt(i);
+        if (c == fnc1 || encoder.canEncode(c)) {
+          canEncode = true;
+          break;
+        }
+      }
+
+      if (!canEncode) {
+        //for the character at position i we don't yet have an encoder in the list
+        for (CharsetEncoder encoder : ENCODERS) {
+          if (encoder.canEncode(stringToEncode.charAt(i))) {
+            //Good, we found an encoder that can encode the character. We add him to the list and continue scanning
+            //the input
+            neededEncoders.add(encoder);
+            canEncode = true;
+            break;
+          }
+        }
+      }
+
+      if (!canEncode) {
+        //The character is not encodeable by any of the single byte encoders so we remember that we will need a
+        //Unicode encoder.
+        needUnicodeEncoder = true;
+      }
+    }
+  
+    if (neededEncoders.size() == 1 && !needUnicodeEncoder) {
+      //the entire input can be encoded by the ISO-8859-1 encoder
+      encoders = new CharsetEncoder[] { neededEncoders.get(0) };
+    } else {
+      // we need more than one single byte encoder or we need a Unicode encoder.
+      // In this case we append a UTF-8 and UTF-16 encoder to the list
+      encoders = new CharsetEncoder[neededEncoders.size() + 2];
+      int index = 0;
+      for (CharsetEncoder encoder : neededEncoders) {
+        encoders[index++] = encoder;
+      }
+
+      encoders[index] = StandardCharsets.UTF_8.newEncoder();
+      encoders[index + 1] = StandardCharsets.UTF_16BE.newEncoder();
+    }
+  
+    //Compute priorityEncoderIndex by looking up priorityCharset in encoders
+    int priorityEncoderIndexValue = -1;
+    if (priorityCharset != null) {
+      for (int i = 0; i < encoders.length; i++) {
+        if (encoders[i] != null && priorityCharset.name().equals(encoders[i].charset().name())) {
+          priorityEncoderIndexValue = i;
+          break;
+        }
+      }
+    }
+    priorityEncoderIndex = priorityEncoderIndexValue;
+    //invariants
+    assert encoders[0].charset().equals(StandardCharsets.ISO_8859_1);
+  }
+
+  public int length() {
+    return encoders.length;
+  }
+
+  public String getCharsetName(int index) {
+    assert index < length();
+    return encoders[index].charset().name();
+  }
+
+  public Charset getCharset(int index) {
+    assert index < length();
+    return encoders[index].charset();
+  }
+
+  public int getECIValue(int encoderIndex) {
+    return CharacterSetECI.getCharacterSetECI(encoders[encoderIndex].charset()).getValue();
+  }
+
+  /*
+   *  returns -1 if no priority charset was defined
+   */
+  public int getPriorityEncoderIndex() {
+    return priorityEncoderIndex;
+  }
+
+  public boolean canEncode(char c, int encoderIndex) {
+    assert encoderIndex < length();
+    CharsetEncoder encoder = encoders[encoderIndex];
+    return encoder.canEncode("" + c);
+  }
+
+  public byte[] encode(char c, int encoderIndex) {
+    assert encoderIndex < length();
+    CharsetEncoder encoder = encoders[encoderIndex];
+    assert encoder.canEncode("" + c);
+    return ("" + c).getBytes(encoder.charset());
+  }
+
+  public byte[] encode(String s, int encoderIndex) {
+    assert encoderIndex < length();
+    CharsetEncoder encoder = encoders[encoderIndex];
+    return s.getBytes(encoder.charset());
+  }
+}

src/common/ECIInput.java

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2021 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common;
+
+/**
+ * Interface to navigate a sequence of ECIs and bytes.
+ *
+ * @author Alex Geller
+ */
+public interface ECIInput {
+
+ /**
+  * Returns the length of this input.  The length is the number
+  * of {@code byte}s in or ECIs in the sequence.
+  *
+  * @return  the number of {@code char}s in this sequence
+  */
+  int length();
+
+ /**
+  * Returns the {@code byte} value at the specified index.  An index ranges from zero
+  * to {@code length() - 1}.  The first {@code byte} value of the sequence is at
+  * index zero, the next at index one, and so on, as for array
+  * indexing.
+  *
+  * @param   index the index of the {@code byte} value to be returned
+  *
+  * @return  the specified {@code byte} value as character or the FNC1 character
+  *
+  * @throws  IndexOutOfBoundsException
+  *          if the {@code index} argument is negative or not less than
+  *          {@code length()}
+  * @throws  IllegalArgumentException
+  *          if the value at the {@code index} argument is an ECI (@see #isECI)
+  */
+  char charAt(int index);
+
+ /**
+  * Returns a {@code CharSequence} that is a subsequence of this sequence.
+  * The subsequence starts with the {@code char} value at the specified index and
+  * ends with the {@code char} value at index {@code end - 1}.  The length
+  * (in {@code char}s) of the
+  * returned sequence is {@code end - start}, so if {@code start == end}
+  * then an empty sequence is returned.
+  *
+  * @param   start   the start index, inclusive
+  * @param   end     the end index, exclusive
+  *
+  * @return  the specified subsequence
+  *
+  * @throws  IndexOutOfBoundsException
+  *          if {@code start} or {@code end} are negative,
+  *          if {@code end} is greater than {@code length()},
+  *          or if {@code start} is greater than {@code end}
+  * @throws  IllegalArgumentException
+  *          if a value in the range {@code start}-{@code end} is an ECI (@see #isECI)
+  */
+  CharSequence subSequence(int start, int end);
+
+ /**
+  * Determines if a value is an ECI
+  *
+  * @param   index the index of the value
+  *
+  * @return  true if the value at position {@code index} is an ECI
+  *
+  * @throws  IndexOutOfBoundsException
+  *          if the {@code index} argument is negative or not less than
+  *          {@code length()}
+  */
+  boolean isECI(int index);
+
+ /**
+  * Returns the {@code int} ECI value at the specified index.  An index ranges from zero
+  * to {@code length() - 1}.  The first {@code byte} value of the sequence is at
+  * index zero, the next at index one, and so on, as for array
+  * indexing.
+  *
+  * @param   index the index of the {@code int} value to be returned
+  *
+  * @return  the specified {@code int} ECI value. 
+  *          The ECI specified the encoding of all bytes with a higher index until the
+  *          next ECI or until the end of the input if no other ECI follows.
+  *
+  * @throws  IndexOutOfBoundsException
+  *          if the {@code index} argument is negative or not less than
+  *          {@code length()}
+  * @throws  IllegalArgumentException
+  *          if the value at the {@code index} argument is not an ECI (@see #isECI)
+  */
+  int getECIValue(int index);
+  boolean haveNCharacters(int index, int n);
+}

src/common/ECIStringBuilder.java

@@ -0,0 +1,145 @@
+/*
+ * Copyright 2022 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common;
+
+import com.google.zxing.FormatException;
+
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * Class that converts a sequence of ECIs and bytes into a string
+ *
+ * @author Alex Geller
+ */
+public final class ECIStringBuilder {
+  private StringBuilder currentBytes;
+  private StringBuilder result;
+  private Charset currentCharset = StandardCharsets.ISO_8859_1;
+
+  public ECIStringBuilder() {
+    currentBytes = new StringBuilder();
+  }
+  public ECIStringBuilder(int initialCapacity) {
+    currentBytes = new StringBuilder(initialCapacity);
+  }
+
+  /**
+   * Appends {@code value} as a byte value
+   *
+   * @param value character whose lowest byte is to be appended
+   */
+  public void append(char value) {
+    currentBytes.append((char) (value & 0xff));
+  }
+
+  /**
+   * Appends {@code value} as a byte value
+   *
+   * @param value byte to append
+   */
+  public void append(byte value) {
+    currentBytes.append((char) (value & 0xff));
+  }
+
+  /**
+   * Appends the characters in {@code value} as bytes values
+   *
+   * @param value string to append
+   */
+  public void append(String value) {
+    currentBytes.append(value);
+  }
+
+  /**
+   * Append the string repesentation of {@code value} (short for {@code append(String.valueOf(value))})
+   *
+   * @param value int to append as a string
+   */
+  public void append(int value) {
+    append(String.valueOf(value));
+  }
+
+  /**
+   * Appends ECI value to output.
+   *
+   * @param value ECI value to append, as an int
+   * @throws FormatException on invalid ECI value
+   */
+  public void appendECI(int value) throws FormatException {
+    encodeCurrentBytesIfAny();
+    CharacterSetECI characterSetECI = CharacterSetECI.getCharacterSetECIByValue(value);
+    if (characterSetECI == null) {
+      throw FormatException.getFormatInstance();
+    }
+    currentCharset = characterSetECI.getCharset();
+  }
+
+  private void encodeCurrentBytesIfAny() {
+    if (currentCharset.equals(StandardCharsets.ISO_8859_1)) {
+      if (currentBytes.length() > 0) {
+        if (result == null) {
+          result = currentBytes;
+          currentBytes = new StringBuilder();
+        } else {
+          result.append(currentBytes);
+          currentBytes = new StringBuilder();
+        }
+      }
+    } else if (currentBytes.length() > 0) {
+      byte[] bytes = currentBytes.toString().getBytes(StandardCharsets.ISO_8859_1);
+      currentBytes = new StringBuilder();
+      if (result == null) {
+        result = new StringBuilder(new String(bytes, currentCharset));
+      } else {
+        result.append(new String(bytes, currentCharset));
+      }
+    }
+  }
+
+  /**
+   * Appends the characters from {@code value} (unlike all other append methods of this class who append bytes)
+   *
+   * @param value characters to append
+   */
+  public void appendCharacters(StringBuilder value) {
+    encodeCurrentBytesIfAny();
+    result.append(value);
+  }
+
+  /**
+   * Short for {@code toString().length()} (if possible, use {@link #isEmpty()} instead)
+   *
+   * @return length of string representation in characters
+   */
+  public int length() {
+    return toString().length();
+  }
+
+  /**
+   * @return true iff nothing has been appended
+   */
+  public boolean isEmpty() {
+    return currentBytes.length() == 0 && (result == null || result.length() == 0);
+  }
+
+  @Override
+  public String toString() {
+    encodeCurrentBytesIfAny();
+    return result == null ? "" : result.toString();
+  }
+}

src/common/GlobalHistogramBinarizer.java

@@ -0,0 +1,203 @@
+/*
+ * Copyright 2009 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common;
+
+import com.google.zxing.Binarizer;
+import com.google.zxing.LuminanceSource;
+import com.google.zxing.NotFoundException;
+
+/**
+ * This Binarizer implementation uses the old ZXing global histogram approach. It is suitable
+ * for low-end mobile devices which don't have enough CPU or memory to use a local thresholding
+ * algorithm. However, because it picks a global black point, it cannot handle difficult shadows
+ * and gradients.
+ *
+ * Faster mobile devices and all desktop applications should probably use HybridBinarizer instead.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ * @author Sean Owen
+ */
+public class GlobalHistogramBinarizer extends Binarizer {
+
+  private static final int LUMINANCE_BITS = 5;
+  private static final int LUMINANCE_SHIFT = 8 - LUMINANCE_BITS;
+  private static final int LUMINANCE_BUCKETS = 1 << LUMINANCE_BITS;
+  private static final byte[] EMPTY = new byte[0];
+
+  private byte[] luminances;
+  private final int[] buckets;
+
+  public GlobalHistogramBinarizer(LuminanceSource source) {
+    super(source);
+    luminances = EMPTY;
+    buckets = new int[LUMINANCE_BUCKETS];
+  }
+
+  // Applies simple sharpening to the row data to improve performance of the 1D Readers.
+  @Override
+  public BitArray getBlackRow(int y, BitArray row) throws NotFoundException {
+    LuminanceSource source = getLuminanceSource();
+    int width = source.getWidth();
+    if (row == null || row.getSize() < width) {
+      row = new BitArray(width);
+    } else {
+      row.clear();
+    }
+
+    initArrays(width);
+    byte[] localLuminances = source.getRow(y, luminances);
+    int[] localBuckets = buckets;
+    for (int x = 0; x < width; x++) {
+      localBuckets[(localLuminances[x] & 0xff) >> LUMINANCE_SHIFT]++;
+    }
+    int blackPoint = estimateBlackPoint(localBuckets);
+
+    if (width < 3) {
+      // Special case for very small images
+      for (int x = 0; x < width; x++) {
+        if ((localLuminances[x] & 0xff) < blackPoint) {
+          row.set(x);
+        }
+      }
+    } else {
+      int left = localLuminances[0] & 0xff;
+      int center = localLuminances[1] & 0xff;
+      for (int x = 1; x < width - 1; x++) {
+        int right = localLuminances[x + 1] & 0xff;
+        // A simple -1 4 -1 box filter with a weight of 2.
+        if (((center * 4) - left - right) / 2 < blackPoint) {
+          row.set(x);
+        }
+        left = center;
+        center = right;
+      }
+    }
+    return row;
+  }
+
+  // Does not sharpen the data, as this call is intended to only be used by 2D Readers.
+  @Override
+  public BitMatrix getBlackMatrix() throws NotFoundException {
+    LuminanceSource source = getLuminanceSource();
+    int width = source.getWidth();
+    int height = source.getHeight();
+    BitMatrix matrix = new BitMatrix(width, height);
+
+    // Quickly calculates the histogram by sampling four rows from the image. This proved to be
+    // more robust on the blackbox tests than sampling a diagonal as we used to do.
+    initArrays(width);
+    int[] localBuckets = buckets;
+    for (int y = 1; y < 5; y++) {
+      int row = height * y / 5;
+      byte[] localLuminances = source.getRow(row, luminances);
+      int right = (width * 4) / 5;
+      for (int x = width / 5; x < right; x++) {
+        int pixel = localLuminances[x] & 0xff;
+        localBuckets[pixel >> LUMINANCE_SHIFT]++;
+      }
+    }
+    int blackPoint = estimateBlackPoint(localBuckets);
+
+    // We delay reading the entire image luminance until the black point estimation succeeds.
+    // Although we end up reading four rows twice, it is consistent with our motto of
+    // "fail quickly" which is necessary for continuous scanning.
+    byte[] localLuminances = source.getMatrix();
+    for (int y = 0; y < height; y++) {
+      int offset = y * width;
+      for (int x = 0; x < width; x++) {
+        int pixel = localLuminances[offset + x] & 0xff;
+        if (pixel < blackPoint) {
+          matrix.set(x, y);
+        }
+      }
+    }
+
+    return matrix;
+  }
+
+  @Override
+  public Binarizer createBinarizer(LuminanceSource source) {
+    return new GlobalHistogramBinarizer(source);
+  }
+
+  private void initArrays(int luminanceSize) {
+    if (luminances.length < luminanceSize) {
+      luminances = new byte[luminanceSize];
+    }
+    for (int x = 0; x < LUMINANCE_BUCKETS; x++) {
+      buckets[x] = 0;
+    }
+  }
+
+  private static int estimateBlackPoint(int[] buckets) throws NotFoundException {
+    // Find the tallest peak in the histogram.
+    int numBuckets = buckets.length;
+    int maxBucketCount = 0;
+    int firstPeak = 0;
+    int firstPeakSize = 0;
+    for (int x = 0; x < numBuckets; x++) {
+      if (buckets[x] > firstPeakSize) {
+        firstPeak = x;
+        firstPeakSize = buckets[x];
+      }
+      if (buckets[x] > maxBucketCount) {
+        maxBucketCount = buckets[x];
+      }
+    }
+
+    // Find the second-tallest peak which is somewhat far from the tallest peak.
+    int secondPeak = 0;
+    int secondPeakScore = 0;
+    for (int x = 0; x < numBuckets; x++) {
+      int distanceToBiggest = x - firstPeak;
+      // Encourage more distant second peaks by multiplying by square of distance.
+      int score = buckets[x] * distanceToBiggest * distanceToBiggest;
+      if (score > secondPeakScore) {
+        secondPeak = x;
+        secondPeakScore = score;
+      }
+    }
+
+    // Make sure firstPeak corresponds to the black peak.
+    if (firstPeak > secondPeak) {
+      int temp = firstPeak;
+      firstPeak = secondPeak;
+      secondPeak = temp;
+    }
+
+    // If there is too little contrast in the image to pick a meaningful black point, throw rather
+    // than waste time trying to decode the image, and risk false positives.
+    if (secondPeak - firstPeak <= numBuckets / 16) {
+      throw NotFoundException.getNotFoundInstance();
+    }
+
+    // Find a valley between them that is low and closer to the white peak.
+    int bestValley = secondPeak - 1;
+    int bestValleyScore = -1;
+    for (int x = secondPeak - 1; x > firstPeak; x--) {
+      int fromFirst = x - firstPeak;
+      int score = fromFirst * fromFirst * (secondPeak - x) * (maxBucketCount - buckets[x]);
+      if (score > bestValleyScore) {
+        bestValley = x;
+        bestValleyScore = score;
+      }
+    }
+
+    return bestValley << LUMINANCE_SHIFT;
+  }
+
+}

src/common/GridSampler.java

@@ -0,0 +1,174 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common;
+
+import com.google.zxing.NotFoundException;
+
+/**
+ * Implementations of this class can, given locations of finder patterns for a QR code in an
+ * image, sample the right points in the image to reconstruct the QR code, accounting for
+ * perspective distortion. It is abstracted since it is relatively expensive and should be allowed
+ * to take advantage of platform-specific optimized implementations, like Sun's Java Advanced
+ * Imaging library, but which may not be available in other environments such as J2ME, and vice
+ * versa.
+ *
+ * The implementation used can be controlled by calling {@link #setGridSampler(GridSampler)}
+ * with an instance of a class which implements this interface.
+ *
+ * @author Sean Owen
+ */
+public abstract class GridSampler {
+
+  private static GridSampler gridSampler = new DefaultGridSampler();
+
+  /**
+   * Sets the implementation of GridSampler used by the library. One global
+   * instance is stored, which may sound problematic. But, the implementation provided
+   * ought to be appropriate for the entire platform, and all uses of this library
+   * in the whole lifetime of the JVM. For instance, an Android activity can swap in
+   * an implementation that takes advantage of native platform libraries.
+   *
+   * @param newGridSampler The platform-specific object to install.
+   */
+  public static void setGridSampler(GridSampler newGridSampler) {
+    gridSampler = newGridSampler;
+  }
+
+  /**
+   * @return the current implementation of GridSampler
+   */
+  public static GridSampler getInstance() {
+    return gridSampler;
+  }
+
+  /**
+   * Samples an image for a rectangular matrix of bits of the given dimension. The sampling
+   * transformation is determined by the coordinates of 4 points, in the original and transformed
+   * image space.
+   *
+   * @param image image to sample
+   * @param dimensionX width of {@link BitMatrix} to sample from image
+   * @param dimensionY height of {@link BitMatrix} to sample from image
+   * @param p1ToX point 1 preimage X
+   * @param p1ToY point 1 preimage Y
+   * @param p2ToX point 2 preimage X
+   * @param p2ToY point 2 preimage Y
+   * @param p3ToX point 3 preimage X
+   * @param p3ToY point 3 preimage Y
+   * @param p4ToX point 4 preimage X
+   * @param p4ToY point 4 preimage Y
+   * @param p1FromX point 1 image X
+   * @param p1FromY point 1 image Y
+   * @param p2FromX point 2 image X
+   * @param p2FromY point 2 image Y
+   * @param p3FromX point 3 image X
+   * @param p3FromY point 3 image Y
+   * @param p4FromX point 4 image X
+   * @param p4FromY point 4 image Y
+   * @return {@link BitMatrix} representing a grid of points sampled from the image within a region
+   *   defined by the "from" parameters
+   * @throws NotFoundException if image can't be sampled, for example, if the transformation defined
+   *   by the given points is invalid or results in sampling outside the image boundaries
+   */
+  public abstract BitMatrix sampleGrid(BitMatrix image,
+                                       int dimensionX,
+                                       int dimensionY,
+                                       float p1ToX, float p1ToY,
+                                       float p2ToX, float p2ToY,
+                                       float p3ToX, float p3ToY,
+                                       float p4ToX, float p4ToY,
+                                       float p1FromX, float p1FromY,
+                                       float p2FromX, float p2FromY,
+                                       float p3FromX, float p3FromY,
+                                       float p4FromX, float p4FromY) throws NotFoundException;
+
+  public abstract BitMatrix sampleGrid(BitMatrix image,
+                                       int dimensionX,
+                                       int dimensionY,
+                                       PerspectiveTransform transform) throws NotFoundException;
+
+  /**
+   * <p>Checks a set of points that have been transformed to sample points on an image against
+   * the image's dimensions to see if the point are even within the image.</p>
+   *
+   * <p>This method will actually "nudge" the endpoints back onto the image if they are found to be
+   * barely (less than 1 pixel) off the image. This accounts for imperfect detection of finder
+   * patterns in an image where the QR Code runs all the way to the image border.</p>
+   *
+   * <p>For efficiency, the method will check points from either end of the line until one is found
+   * to be within the image. Because the set of points are assumed to be linear, this is valid.</p>
+   *
+   * @param image image into which the points should map
+   * @param points actual points in x1,y1,...,xn,yn form
+   * @throws NotFoundException if an endpoint is lies outside the image boundaries
+   */
+  protected static void checkAndNudgePoints(BitMatrix image,
+                                            float[] points) throws NotFoundException {
+    int width = image.getWidth();
+    int height = image.getHeight();
+    // Check and nudge points from start until we see some that are OK:
+    boolean nudged = true;
+    int maxOffset = points.length - 1; // points.length must be even
+    for (int offset = 0; offset < maxOffset && nudged; offset += 2) {
+      int x = (int) points[offset];
+      int y = (int) points[offset + 1];
+      if (x < -1 || x > width || y < -1 || y > height) {
+        throw NotFoundException.getNotFoundInstance();
+      }
+      nudged = false;
+      if (x == -1) {
+        points[offset] = 0.0f;
+        nudged = true;
+      } else if (x == width) {
+        points[offset] = width - 1;
+        nudged = true;
+      }
+      if (y == -1) {
+        points[offset + 1] = 0.0f;
+        nudged = true;
+      } else if (y == height) {
+        points[offset + 1] = height - 1;
+        nudged = true;
+      }
+    }
+    // Check and nudge points from end:
+    nudged = true;
+    for (int offset = points.length - 2; offset >= 0 && nudged; offset -= 2) {
+      int x = (int) points[offset];
+      int y = (int) points[offset + 1];
+      if (x < -1 || x > width || y < -1 || y > height) {
+        throw NotFoundException.getNotFoundInstance();
+      }
+      nudged = false;
+      if (x == -1) {
+        points[offset] = 0.0f;
+        nudged = true;
+      } else if (x == width) {
+        points[offset] = width - 1;
+        nudged = true;
+      }
+      if (y == -1) {
+        points[offset + 1] = 0.0f;
+        nudged = true;
+      } else if (y == height) {
+        points[offset + 1] = height - 1;
+        nudged = true;
+      }
+    }
+  }
+
+}

src/common/HybridBinarizer.java

@@ -0,0 +1,237 @@
+/*
+ * Copyright 2009 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common;
+
+import com.google.zxing.Binarizer;
+import com.google.zxing.LuminanceSource;
+import com.google.zxing.NotFoundException;
+
+/**
+ * This class implements a local thresholding algorithm, which while slower than the
+ * GlobalHistogramBinarizer, is fairly efficient for what it does. It is designed for
+ * high frequency images of barcodes with black data on white backgrounds. For this application,
+ * it does a much better job than a global blackpoint with severe shadows and gradients.
+ * However it tends to produce artifacts on lower frequency images and is therefore not
+ * a good general purpose binarizer for uses outside ZXing.
+ *
+ * This class extends GlobalHistogramBinarizer, using the older histogram approach for 1D readers,
+ * and the newer local approach for 2D readers. 1D decoding using a per-row histogram is already
+ * inherently local, and only fails for horizontal gradients. We can revisit that problem later,
+ * but for now it was not a win to use local blocks for 1D.
+ *
+ * This Binarizer is the default for the unit tests and the recommended class for library users.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+public final class HybridBinarizer extends GlobalHistogramBinarizer {
+
+  // This class uses 5x5 blocks to compute local luminance, where each block is 8x8 pixels.
+  // So this is the smallest dimension in each axis we can accept.
+  private static final int BLOCK_SIZE_POWER = 3;
+  private static final int BLOCK_SIZE = 1 << BLOCK_SIZE_POWER; // ...0100...00
+  private static final int BLOCK_SIZE_MASK = BLOCK_SIZE - 1;   // ...0011...11
+  private static final int MINIMUM_DIMENSION = BLOCK_SIZE * 5;
+  private static final int MIN_DYNAMIC_RANGE = 24;
+
+  private BitMatrix matrix;
+
+  public HybridBinarizer(LuminanceSource source) {
+    super(source);
+  }
+
+  /**
+   * Calculates the final BitMatrix once for all requests. This could be called once from the
+   * constructor instead, but there are some advantages to doing it lazily, such as making
+   * profiling easier, and not doing heavy lifting when callers don't expect it.
+   */
+  @Override
+  public BitMatrix getBlackMatrix() throws NotFoundException {
+    if (matrix != null) {
+      return matrix;
+    }
+    LuminanceSource source = getLuminanceSource();
+    int width = source.getWidth();
+    int height = source.getHeight();
+    if (width >= MINIMUM_DIMENSION && height >= MINIMUM_DIMENSION) {
+      byte[] luminances = source.getMatrix();
+      int subWidth = width >> BLOCK_SIZE_POWER;
+      if ((width & BLOCK_SIZE_MASK) != 0) {
+        subWidth++;
+      }
+      int subHeight = height >> BLOCK_SIZE_POWER;
+      if ((height & BLOCK_SIZE_MASK) != 0) {
+        subHeight++;
+      }
+      int[][] blackPoints = calculateBlackPoints(luminances, subWidth, subHeight, width, height);
+
+      BitMatrix newMatrix = new BitMatrix(width, height);
+      calculateThresholdForBlock(luminances, subWidth, subHeight, width, height, blackPoints, newMatrix);
+      matrix = newMatrix;
+    } else {
+      // If the image is too small, fall back to the global histogram approach.
+      matrix = super.getBlackMatrix();
+    }
+    return matrix;
+  }
+
+  @Override
+  public Binarizer createBinarizer(LuminanceSource source) {
+    return new HybridBinarizer(source);
+  }
+
+  /**
+   * For each block in the image, calculate the average black point using a 5x5 grid
+   * of the blocks around it. Also handles the corner cases (fractional blocks are computed based
+   * on the last pixels in the row/column which are also used in the previous block).
+   */
+  private static void calculateThresholdForBlock(byte[] luminances,
+                                                 int subWidth,
+                                                 int subHeight,
+                                                 int width,
+                                                 int height,
+                                                 int[][] blackPoints,
+                                                 BitMatrix matrix) {
+    int maxYOffset = height - BLOCK_SIZE;
+    int maxXOffset = width - BLOCK_SIZE;
+    for (int y = 0; y < subHeight; y++) {
+      int yoffset = y << BLOCK_SIZE_POWER;
+      if (yoffset > maxYOffset) {
+        yoffset = maxYOffset;
+      }
+      int top = cap(y, subHeight - 3);
+      for (int x = 0; x < subWidth; x++) {
+        int xoffset = x << BLOCK_SIZE_POWER;
+        if (xoffset > maxXOffset) {
+          xoffset = maxXOffset;
+        }
+        int left = cap(x, subWidth - 3);
+        int sum = 0;
+        for (int z = -2; z <= 2; z++) {
+          int[] blackRow = blackPoints[top + z];
+          sum += blackRow[left - 2] + blackRow[left - 1] + blackRow[left] + blackRow[left + 1] + blackRow[left + 2];
+        }
+        int average = sum / 25;
+        thresholdBlock(luminances, xoffset, yoffset, average, width, matrix);
+      }
+    }
+  }
+
+  private static int cap(int value, int max) {
+    return value < 2 ? 2 : Math.min(value, max);
+  }
+
+  /**
+   * Applies a single threshold to a block of pixels.
+   */
+  private static void thresholdBlock(byte[] luminances,
+                                     int xoffset,
+                                     int yoffset,
+                                     int threshold,
+                                     int stride,
+                                     BitMatrix matrix) {
+    for (int y = 0, offset = yoffset * stride + xoffset; y < BLOCK_SIZE; y++, offset += stride) {
+      for (int x = 0; x < BLOCK_SIZE; x++) {
+        // Comparison needs to be <= so that black == 0 pixels are black even if the threshold is 0.
+        if ((luminances[offset + x] & 0xFF) <= threshold) {
+          matrix.set(xoffset + x, yoffset + y);
+        }
+      }
+    }
+  }
+
+  /**
+   * Calculates a single black point for each block of pixels and saves it away.
+   * See the following thread for a discussion of this algorithm:
+   *  http://groups.google.com/group/zxing/browse_thread/thread/d06efa2c35a7ddc0
+   */
+  private static int[][] calculateBlackPoints(byte[] luminances,
+                                              int subWidth,
+                                              int subHeight,
+                                              int width,
+                                              int height) {
+    int maxYOffset = height - BLOCK_SIZE;
+    int maxXOffset = width - BLOCK_SIZE;
+    int[][] blackPoints = new int[subHeight][subWidth];
+    for (int y = 0; y < subHeight; y++) {
+      int yoffset = y << BLOCK_SIZE_POWER;
+      if (yoffset > maxYOffset) {
+        yoffset = maxYOffset;
+      }
+      for (int x = 0; x < subWidth; x++) {
+        int xoffset = x << BLOCK_SIZE_POWER;
+        if (xoffset > maxXOffset) {
+          xoffset = maxXOffset;
+        }
+        int sum = 0;
+        int min = 0xFF;
+        int max = 0;
+        for (int yy = 0, offset = yoffset * width + xoffset; yy < BLOCK_SIZE; yy++, offset += width) {
+          for (int xx = 0; xx < BLOCK_SIZE; xx++) {
+            int pixel = luminances[offset + xx] & 0xFF;
+            sum += pixel;
+            // still looking for good contrast
+            if (pixel < min) {
+              min = pixel;
+            }
+            if (pixel > max) {
+              max = pixel;
+            }
+          }
+          // short-circuit min/max tests once dynamic range is met
+          if (max - min > MIN_DYNAMIC_RANGE) {
+            // finish the rest of the rows quickly
+            for (yy++, offset += width; yy < BLOCK_SIZE; yy++, offset += width) {
+              for (int xx = 0; xx < BLOCK_SIZE; xx++) {
+                sum += luminances[offset + xx] & 0xFF;
+              }
+            }
+          }
+        }
+
+        // The default estimate is the average of the values in the block.
+        int average = sum >> (BLOCK_SIZE_POWER * 2);
+        if (max - min <= MIN_DYNAMIC_RANGE) {
+          // If variation within the block is low, assume this is a block with only light or only
+          // dark pixels. In that case we do not want to use the average, as it would divide this
+          // low contrast area into black and white pixels, essentially creating data out of noise.
+          //
+          // The default assumption is that the block is light/background. Since no estimate for
+          // the level of dark pixels exists locally, use half the min for the block.
+          average = min / 2;
+
+          if (y > 0 && x > 0) {
+            // Correct the "white background" assumption for blocks that have neighbors by comparing
+            // the pixels in this block to the previously calculated black points. This is based on
+            // the fact that dark barcode symbology is always surrounded by some amount of light
+            // background for which reasonable black point estimates were made. The bp estimated at
+            // the boundaries is used for the interior.
+
+            // The (min < bp) is arbitrary but works better than other heuristics that were tried.
+            int averageNeighborBlackPoint =
+                (blackPoints[y - 1][x] + (2 * blackPoints[y][x - 1]) + blackPoints[y - 1][x - 1]) / 4;
+            if (min < averageNeighborBlackPoint) {
+              average = averageNeighborBlackPoint;
+            }
+          }
+        }
+        blackPoints[y][x] = average;
+      }
+    }
+    return blackPoints;
+  }
+
+}

src/common/MinimalECIInput.java

@@ -0,0 +1,346 @@
+/*
+ * Copyright 2021 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common;
+
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Class that converts a character string into a sequence of ECIs and bytes
+ *
+ * The implementation uses the Dijkstra algorithm to produce minimal encodings
+ *
+ * @author Alex Geller
+ */
+public class MinimalECIInput implements ECIInput {
+
+  private static final int COST_PER_ECI = 3; // approximated (latch + 2 codewords)
+  private final int[] bytes;
+  private final int fnc1;
+
+ /**
+  * Constructs a minimal input
+  *
+  * @param stringToEncode the character string to encode
+  * @param priorityCharset The preferred {@link Charset}. When the value of the argument is null, the algorithm
+  *   chooses charsets that leads to a minimal representation. Otherwise the algorithm will use the priority
+  *   charset to encode any character in the input that can be encoded by it if the charset is among the
+  *   supported charsets.
+  * @param fnc1 denotes the character in the input that represents the FNC1 character or -1 if this is not GS1
+  *   input.
+  */
+  public MinimalECIInput(String stringToEncode, Charset priorityCharset, int fnc1) {
+    this.fnc1 = fnc1;
+    ECIEncoderSet encoderSet = new ECIEncoderSet(stringToEncode, priorityCharset, fnc1);
+    if (encoderSet.length() == 1) { //optimization for the case when all can be encoded without ECI in ISO-8859-1
+      bytes = new int[stringToEncode.length()];
+      for (int i = 0; i < bytes.length; i++) {
+        char c = stringToEncode.charAt(i);
+        bytes[i] = c == fnc1 ? 1000 : (int) c;
+      }
+    } else {
+      bytes = encodeMinimally(stringToEncode, encoderSet, fnc1);
+    }
+  }
+
+  public int getFNC1Character() {
+    return fnc1;
+  }
+
+ /**
+  * Returns the length of this input.  The length is the number
+  * of {@code byte}s, FNC1 characters or ECIs in the sequence.
+  *
+  * @return  the number of {@code char}s in this sequence
+  */
+  public int length() {
+    return bytes.length;
+  }
+
+  public boolean haveNCharacters(int index, int n) {
+    if (index + n - 1 >= bytes.length) {
+      return false;
+    }
+    for (int i = 0; i < n; i++) {
+      if (isECI(index + i)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+ /**
+  * Returns the {@code byte} value at the specified index.  An index ranges from zero
+  * to {@code length() - 1}.  The first {@code byte} value of the sequence is at
+  * index zero, the next at index one, and so on, as for array
+  * indexing.
+  *
+  * @param   index the index of the {@code byte} value to be returned
+  *
+  * @return  the specified {@code byte} value as character or the FNC1 character
+  *
+  * @throws  IndexOutOfBoundsException
+  *          if the {@code index} argument is negative or not less than
+  *          {@code length()}
+  * @throws  IllegalArgumentException
+  *          if the value at the {@code index} argument is an ECI (@see #isECI)
+  */
+  public char charAt(int index) {
+    if (index < 0 || index >= length()) {
+      throw new IndexOutOfBoundsException("" + index);
+    }
+    if (isECI(index)) {
+      throw new IllegalArgumentException("value at " + index + " is not a character but an ECI");
+    }
+    return isFNC1(index) ? (char) fnc1 : (char) bytes[index];
+  }
+
+ /**
+  * Returns a {@code CharSequence} that is a subsequence of this sequence.
+  * The subsequence starts with the {@code char} value at the specified index and
+  * ends with the {@code char} value at index {@code end - 1}.  The length
+  * (in {@code char}s) of the
+  * returned sequence is {@code end - start}, so if {@code start == end}
+  * then an empty sequence is returned.
+  *
+  * @param   start   the start index, inclusive
+  * @param   end     the end index, exclusive
+  *
+  * @return  the specified subsequence
+  *
+  * @throws  IndexOutOfBoundsException
+  *          if {@code start} or {@code end} are negative,
+  *          if {@code end} is greater than {@code length()},
+  *          or if {@code start} is greater than {@code end}
+  * @throws  IllegalArgumentException
+  *          if a value in the range {@code start}-{@code end} is an ECI (@see #isECI)
+  */
+  public CharSequence subSequence(int start, int end) {
+    if (start < 0 || start > end || end > length()) {
+      throw new IndexOutOfBoundsException("" + start);
+    }
+    StringBuilder result = new StringBuilder();
+    for (int i = start; i < end; i++) {
+      if (isECI(i)) {
+        throw new IllegalArgumentException("value at " + i + " is not a character but an ECI");
+      }
+      result.append(charAt(i));
+    }
+    return result;
+  }
+
+ /**
+  * Determines if a value is an ECI
+  *
+  * @param   index the index of the value
+  *
+  * @return  true if the value at position {@code index} is an ECI
+  *
+  * @throws  IndexOutOfBoundsException
+  *          if the {@code index} argument is negative or not less than
+  *          {@code length()}
+  */
+  public boolean isECI(int index) {
+    if (index < 0 || index >= length()) {
+      throw new IndexOutOfBoundsException("" + index);
+    }
+    return bytes[index] > 255 && bytes[index] <= 999;
+  }
+
+ /**
+  * Determines if a value is the FNC1 character
+  *
+  * @param   index the index of the value
+  *
+  * @return  true if the value at position {@code index} is the FNC1 character
+  *
+  * @throws  IndexOutOfBoundsException
+  *          if the {@code index} argument is negative or not less than
+  *          {@code length()}
+  */
+  public boolean isFNC1(int index) {
+    if (index < 0 || index >= length()) {
+      throw new IndexOutOfBoundsException("" + index);
+    }
+    return bytes[index] == 1000;
+  }
+
+ /**
+  * Returns the {@code int} ECI value at the specified index.  An index ranges from zero
+  * to {@code length() - 1}.  The first {@code byte} value of the sequence is at
+  * index zero, the next at index one, and so on, as for array
+  * indexing.
+  *
+  * @param   index the index of the {@code int} value to be returned
+  *
+  * @return  the specified {@code int} ECI value. 
+  *          The ECI specified the encoding of all bytes with a higher index until the
+  *          next ECI or until the end of the input if no other ECI follows.
+  *
+  * @throws  IndexOutOfBoundsException
+  *          if the {@code index} argument is negative or not less than
+  *          {@code length()}
+  * @throws  IllegalArgumentException
+  *          if the value at the {@code index} argument is not an ECI (@see #isECI)
+  */
+  public int getECIValue(int index) {
+    if (index < 0 || index >= length()) {
+      throw new IndexOutOfBoundsException("" + index);
+    }
+    if (!isECI(index)) {
+      throw new IllegalArgumentException("value at " + index + " is not an ECI but a character");
+    }
+    return bytes[index] - 256;
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder result = new StringBuilder();
+    for (int i = 0; i < length(); i++) {
+      if (i > 0) {
+        result.append(", ");
+      }
+      if (isECI(i)) {
+        result.append("ECI(");
+        result.append(getECIValue(i));
+        result.append(')');
+      } else if (charAt(i) < 128) {
+        result.append('\'');
+        result.append(charAt(i));
+        result.append('\'');
+      } else {
+        result.append((int) charAt(i));
+      }
+    }
+    return result.toString();
+  }
+  static void addEdge(InputEdge[][] edges, int to, InputEdge edge) {
+    if (edges[to][edge.encoderIndex] == null ||
+        edges[to][edge.encoderIndex].cachedTotalSize > edge.cachedTotalSize) {
+      edges[to][edge.encoderIndex] = edge;
+    }
+  }
+
+  static void addEdges(String stringToEncode, 
+                       ECIEncoderSet encoderSet, 
+                       InputEdge[][] edges, 
+                       int from, 
+                       InputEdge previous, 
+                       int fnc1) {
+
+    char ch = stringToEncode.charAt(from);
+
+    int start = 0;
+    int end = encoderSet.length();
+    if (encoderSet.getPriorityEncoderIndex() >= 0 && (ch == fnc1 || encoderSet.canEncode(ch,
+        encoderSet.getPriorityEncoderIndex()))) {
+      start = encoderSet.getPriorityEncoderIndex();
+      end = start + 1;
+    }
+
+    for (int i = start; i < end; i++) {
+      if (ch == fnc1 || encoderSet.canEncode(ch,i)) {
+        addEdge(edges, from + 1, new InputEdge(ch, encoderSet, i, previous, fnc1));
+      }
+    }
+  }
+
+  static int[] encodeMinimally(String stringToEncode, ECIEncoderSet encoderSet, int fnc1) {
+    int inputLength = stringToEncode.length();
+
+    // Array that represents vertices. There is a vertex for every character and encoding.
+    InputEdge[][] edges = new InputEdge[inputLength + 1][encoderSet.length()];
+    addEdges(stringToEncode, encoderSet, edges, 0, null, fnc1);
+
+    for (int i = 1; i <= inputLength; i++) {
+      for (int j = 0; j < encoderSet.length(); j++) {
+        if (edges[i][j] != null && i < inputLength) {
+          addEdges(stringToEncode, encoderSet, edges, i, edges[i][j], fnc1);
+        }
+      }
+      //optimize memory by removing edges that have been passed.
+      for (int j = 0; j < encoderSet.length(); j++) {
+        edges[i - 1][j] = null;
+      }
+    }
+    int minimalJ = -1;
+    int minimalSize = Integer.MAX_VALUE;
+    for (int j = 0; j < encoderSet.length(); j++) {
+      if (edges[inputLength][j] != null) {
+        InputEdge edge = edges[inputLength][j];
+        if (edge.cachedTotalSize < minimalSize) {
+          minimalSize = edge.cachedTotalSize;
+          minimalJ = j;
+        }
+      }
+    }
+    if (minimalJ < 0) {
+      throw new RuntimeException("Internal error: failed to encode \"" + stringToEncode + "\"");
+    }
+    List<Integer> intsAL = new ArrayList<>();
+    InputEdge current = edges[inputLength][minimalJ];
+    while (current != null) {
+      if (current.isFNC1()) {
+        intsAL.add(0, 1000);
+      } else {
+        byte[] bytes = encoderSet.encode(current.c,current.encoderIndex);
+        for (int i = bytes.length - 1; i >= 0; i--) {
+          intsAL.add(0, (bytes[i] & 0xFF));
+        }
+      }
+      int previousEncoderIndex = current.previous == null ? 0 : current.previous.encoderIndex;
+      if (previousEncoderIndex != current.encoderIndex) {
+        intsAL.add(0,256 + encoderSet.getECIValue(current.encoderIndex));
+      }
+      current = current.previous;
+    }
+    int[] ints = new int[intsAL.size()];
+    for (int i = 0; i < ints.length; i++) {
+      ints[i] = intsAL.get(i);
+    }
+    return ints;
+  }
+
+  private static final class InputEdge {
+    private final char c;
+    private final int encoderIndex; //the encoding of this edge
+    private final InputEdge previous;
+    private final int cachedTotalSize;
+
+    private InputEdge(char c, ECIEncoderSet encoderSet, int encoderIndex, InputEdge previous, int fnc1) {
+      this.c = c == fnc1 ? 1000 : c;
+      this.encoderIndex = encoderIndex;
+      this.previous = previous;
+
+      int size = this.c == 1000 ? 1 : encoderSet.encode(c, encoderIndex).length;
+      int previousEncoderIndex = previous == null ? 0 : previous.encoderIndex;
+      if (previousEncoderIndex != encoderIndex) {
+        size += COST_PER_ECI;
+      }
+      if (previous != null) {
+        size += previous.cachedTotalSize;
+      }
+      this.cachedTotalSize = size;
+    }
+
+    boolean isFNC1() {
+      return c == 1000;
+    }
+
+  }
+}

src/common/PerspectiveTransform.java

@@ -0,0 +1,156 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common;
+
+/**
+ * <p>This class implements a perspective transform in two dimensions. Given four source and four
+ * destination points, it will compute the transformation implied between them. The code is based
+ * directly upon section 3.4.2 of George Wolberg's "Digital Image Warping"; see pages 54-56.</p>
+ *
+ * @author Sean Owen
+ */
+public final class PerspectiveTransform {
+
+  private final float a11;
+  private final float a12;
+  private final float a13;
+  private final float a21;
+  private final float a22;
+  private final float a23;
+  private final float a31;
+  private final float a32;
+  private final float a33;
+
+  private PerspectiveTransform(float a11, float a21, float a31,
+                               float a12, float a22, float a32,
+                               float a13, float a23, float a33) {
+    this.a11 = a11;
+    this.a12 = a12;
+    this.a13 = a13;
+    this.a21 = a21;
+    this.a22 = a22;
+    this.a23 = a23;
+    this.a31 = a31;
+    this.a32 = a32;
+    this.a33 = a33;
+  }
+
+  public static PerspectiveTransform quadrilateralToQuadrilateral(float x0, float y0,
+                                                                  float x1, float y1,
+                                                                  float x2, float y2,
+                                                                  float x3, float y3,
+                                                                  float x0p, float y0p,
+                                                                  float x1p, float y1p,
+                                                                  float x2p, float y2p,
+                                                                  float x3p, float y3p) {
+
+    PerspectiveTransform qToS = quadrilateralToSquare(x0, y0, x1, y1, x2, y2, x3, y3);
+    PerspectiveTransform sToQ = squareToQuadrilateral(x0p, y0p, x1p, y1p, x2p, y2p, x3p, y3p);
+    return sToQ.times(qToS);
+  }
+
+  public void transformPoints(float[] points) {
+    float a11 = this.a11;
+    float a12 = this.a12;
+    float a13 = this.a13;
+    float a21 = this.a21;
+    float a22 = this.a22;
+    float a23 = this.a23;
+    float a31 = this.a31;
+    float a32 = this.a32;
+    float a33 = this.a33;
+    int maxI = points.length - 1; // points.length must be even
+    for (int i = 0; i < maxI; i += 2) {
+      float x = points[i];
+      float y = points[i + 1];
+      float denominator = a13 * x + a23 * y + a33;
+      points[i] = (a11 * x + a21 * y + a31) / denominator;
+      points[i + 1] = (a12 * x + a22 * y + a32) / denominator;
+    }
+  }
+
+  public void transformPoints(float[] xValues, float[] yValues) {
+    int n = xValues.length;
+    for (int i = 0; i < n; i++) {
+      float x = xValues[i];
+      float y = yValues[i];
+      float denominator = a13 * x + a23 * y + a33;
+      xValues[i] = (a11 * x + a21 * y + a31) / denominator;
+      yValues[i] = (a12 * x + a22 * y + a32) / denominator;
+    }
+  }
+
+  public static PerspectiveTransform squareToQuadrilateral(float x0, float y0,
+                                                           float x1, float y1,
+                                                           float x2, float y2,
+                                                           float x3, float y3) {
+    float dx3 = x0 - x1 + x2 - x3;
+    float dy3 = y0 - y1 + y2 - y3;
+    if (dx3 == 0.0f && dy3 == 0.0f) {
+      // Affine
+      return new PerspectiveTransform(x1 - x0, x2 - x1, x0,
+                                      y1 - y0, y2 - y1, y0,
+                                      0.0f,    0.0f,    1.0f);
+    } else {
+      float dx1 = x1 - x2;
+      float dx2 = x3 - x2;
+      float dy1 = y1 - y2;
+      float dy2 = y3 - y2;
+      float denominator = dx1 * dy2 - dx2 * dy1;
+      float a13 = (dx3 * dy2 - dx2 * dy3) / denominator;
+      float a23 = (dx1 * dy3 - dx3 * dy1) / denominator;
+      return new PerspectiveTransform(x1 - x0 + a13 * x1, x3 - x0 + a23 * x3, x0,
+                                      y1 - y0 + a13 * y1, y3 - y0 + a23 * y3, y0,
+                                      a13,                a23,                1.0f);
+    }
+  }
+
+  public static PerspectiveTransform quadrilateralToSquare(float x0, float y0,
+                                                           float x1, float y1,
+                                                           float x2, float y2,
+                                                           float x3, float y3) {
+    // Here, the adjoint serves as the inverse:
+    return squareToQuadrilateral(x0, y0, x1, y1, x2, y2, x3, y3).buildAdjoint();
+  }
+
+  PerspectiveTransform buildAdjoint() {
+    // Adjoint is the transpose of the cofactor matrix:
+    return new PerspectiveTransform(a22 * a33 - a23 * a32,
+        a23 * a31 - a21 * a33,
+        a21 * a32 - a22 * a31,
+        a13 * a32 - a12 * a33,
+        a11 * a33 - a13 * a31,
+        a12 * a31 - a11 * a32,
+        a12 * a23 - a13 * a22,
+        a13 * a21 - a11 * a23,
+        a11 * a22 - a12 * a21);
+  }
+
+  PerspectiveTransform times(PerspectiveTransform other) {
+    return new PerspectiveTransform(a11 * other.a11 + a21 * other.a12 + a31 * other.a13,
+        a11 * other.a21 + a21 * other.a22 + a31 * other.a23,
+        a11 * other.a31 + a21 * other.a32 + a31 * other.a33,
+        a12 * other.a11 + a22 * other.a12 + a32 * other.a13,
+        a12 * other.a21 + a22 * other.a22 + a32 * other.a23,
+        a12 * other.a31 + a22 * other.a32 + a32 * other.a33,
+        a13 * other.a11 + a23 * other.a12 + a33 * other.a13,
+        a13 * other.a21 + a23 * other.a22 + a33 * other.a23,
+        a13 * other.a31 + a23 * other.a32 + a33 * other.a33);
+
+  }
+
+}

src/common/StringUtils.java

@@ -0,0 +1,229 @@
+/*
+ * Copyright (C) 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common;
+
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+
+import com.google.zxing.DecodeHintType;
+
+/**
+ * Common string-related functions.
+ *
+ * @author Sean Owen
+ * @author Alex Dupre
+ */
+public final class StringUtils {
+
+  private static final Charset PLATFORM_DEFAULT_ENCODING = Charset.defaultCharset();
+  public static final Charset SHIFT_JIS_CHARSET = Charset.forName("SJIS");
+  public static final Charset GB2312_CHARSET = Charset.forName("GB2312");
+  private static final Charset EUC_JP = Charset.forName("EUC_JP");
+  private static final boolean ASSUME_SHIFT_JIS =
+      SHIFT_JIS_CHARSET.equals(PLATFORM_DEFAULT_ENCODING) ||
+      EUC_JP.equals(PLATFORM_DEFAULT_ENCODING);
+
+  // Retained for ABI compatibility with earlier versions
+  public static final String SHIFT_JIS = "SJIS";
+  public static final String GB2312 = "GB2312";
+
+  private StringUtils() { }
+
+  /**
+   * @param bytes bytes encoding a string, whose encoding should be guessed
+   * @param hints decode hints if applicable
+   * @return name of guessed encoding; at the moment will only guess one of:
+   *  "SJIS", "UTF8", "ISO8859_1", or the platform default encoding if none
+   *  of these can possibly be correct
+   */
+  public static String guessEncoding(byte[] bytes, Map<DecodeHintType,?> hints) {
+    Charset c = guessCharset(bytes, hints);
+    if (c == SHIFT_JIS_CHARSET) {
+      return "SJIS";
+    } else if (c == StandardCharsets.UTF_8) {
+      return "UTF8";
+    } else if (c == StandardCharsets.ISO_8859_1) {
+      return "ISO8859_1";
+    }
+    return c.name();
+  }
+
+  /**
+   * @param bytes bytes encoding a string, whose encoding should be guessed
+   * @param hints decode hints if applicable
+   * @return Charset of guessed encoding; at the moment will only guess one of:
+   *  {@link #SHIFT_JIS_CHARSET}, {@link StandardCharsets#UTF_8},
+   *  {@link StandardCharsets#ISO_8859_1}, {@link StandardCharsets#UTF_16},
+   *  or the platform default encoding if
+   *  none of these can possibly be correct
+   */
+  public static Charset guessCharset(byte[] bytes, Map<DecodeHintType,?> hints) {
+    if (hints != null && hints.containsKey(DecodeHintType.CHARACTER_SET)) {
+      return Charset.forName(hints.get(DecodeHintType.CHARACTER_SET).toString());
+    }
+
+    // First try UTF-16, assuming anything with its BOM is UTF-16
+    if (bytes.length > 2 &&
+        ((bytes[0] == (byte) 0xFE && bytes[1] == (byte) 0xFF) ||
+         (bytes[0] == (byte) 0xFF && bytes[1] == (byte) 0xFE))) {
+      return StandardCharsets.UTF_16;
+    }
+
+    // For now, merely tries to distinguish ISO-8859-1, UTF-8 and Shift_JIS,
+    // which should be by far the most common encodings.
+    int length = bytes.length;
+    boolean canBeISO88591 = true;
+    boolean canBeShiftJIS = true;
+    boolean canBeUTF8 = true;
+    int utf8BytesLeft = 0;
+    int utf2BytesChars = 0;
+    int utf3BytesChars = 0;
+    int utf4BytesChars = 0;
+    int sjisBytesLeft = 0;
+    int sjisKatakanaChars = 0;
+    int sjisCurKatakanaWordLength = 0;
+    int sjisCurDoubleBytesWordLength = 0;
+    int sjisMaxKatakanaWordLength = 0;
+    int sjisMaxDoubleBytesWordLength = 0;
+    int isoHighOther = 0;
+
+    boolean utf8bom = bytes.length > 3 &&
+        bytes[0] == (byte) 0xEF &&
+        bytes[1] == (byte) 0xBB &&
+        bytes[2] == (byte) 0xBF;
+
+    for (int i = 0;
+         i < length && (canBeISO88591 || canBeShiftJIS || canBeUTF8);
+         i++) {
+
+      int value = bytes[i] & 0xFF;
+
+      // UTF-8 stuff
+      if (canBeUTF8) {
+        if (utf8BytesLeft > 0) {
+          if ((value & 0x80) == 0) {
+            canBeUTF8 = false;
+          } else {
+            utf8BytesLeft--;
+          }
+        } else if ((value & 0x80) != 0) {
+          if ((value & 0x40) == 0) {
+            canBeUTF8 = false;
+          } else {
+            utf8BytesLeft++;
+            if ((value & 0x20) == 0) {
+              utf2BytesChars++;
+            } else {
+              utf8BytesLeft++;
+              if ((value & 0x10) == 0) {
+                utf3BytesChars++;
+              } else {
+                utf8BytesLeft++;
+                if ((value & 0x08) == 0) {
+                  utf4BytesChars++;
+                } else {
+                  canBeUTF8 = false;
+                }
+              }
+            }
+          }
+        }
+      }
+
+      // ISO-8859-1 stuff
+      if (canBeISO88591) {
+        if (value > 0x7F && value < 0xA0) {
+          canBeISO88591 = false;
+        } else if (value > 0x9F && (value < 0xC0 || value == 0xD7 || value == 0xF7)) {
+          isoHighOther++;
+        }
+      }
+
+      // Shift_JIS stuff
+      if (canBeShiftJIS) {
+        if (sjisBytesLeft > 0) {
+          if (value < 0x40 || value == 0x7F || value > 0xFC) {
+            canBeShiftJIS = false;
+          } else {
+            sjisBytesLeft--;
+          }
+        } else if (value == 0x80 || value == 0xA0 || value > 0xEF) {
+          canBeShiftJIS = false;
+        } else if (value > 0xA0 && value < 0xE0) {
+          sjisKatakanaChars++;
+          sjisCurDoubleBytesWordLength = 0;
+          sjisCurKatakanaWordLength++;
+          if (sjisCurKatakanaWordLength > sjisMaxKatakanaWordLength) {
+            sjisMaxKatakanaWordLength = sjisCurKatakanaWordLength;
+          }
+        } else if (value > 0x7F) {
+          sjisBytesLeft++;
+          //sjisDoubleBytesChars++;
+          sjisCurKatakanaWordLength = 0;
+          sjisCurDoubleBytesWordLength++;
+          if (sjisCurDoubleBytesWordLength > sjisMaxDoubleBytesWordLength) {
+            sjisMaxDoubleBytesWordLength = sjisCurDoubleBytesWordLength;
+          }
+        } else {
+          //sjisLowChars++;
+          sjisCurKatakanaWordLength = 0;
+          sjisCurDoubleBytesWordLength = 0;
+        }
+      }
+    }
+
+    if (canBeUTF8 && utf8BytesLeft > 0) {
+      canBeUTF8 = false;
+    }
+    if (canBeShiftJIS && sjisBytesLeft > 0) {
+      canBeShiftJIS = false;
+    }
+
+    // Easy -- if there is BOM or at least 1 valid not-single byte character (and no evidence it can't be UTF-8), done
+    if (canBeUTF8 && (utf8bom || utf2BytesChars + utf3BytesChars + utf4BytesChars > 0)) {
+      return StandardCharsets.UTF_8;
+    }
+    // Easy -- if assuming Shift_JIS or >= 3 valid consecutive not-ascii characters (and no evidence it can't be), done
+    if (canBeShiftJIS && (ASSUME_SHIFT_JIS || sjisMaxKatakanaWordLength >= 3 || sjisMaxDoubleBytesWordLength >= 3)) {
+      return SHIFT_JIS_CHARSET;
+    }
+    // Distinguishing Shift_JIS and ISO-8859-1 can be a little tough for short words. The crude heuristic is:
+    // - If we saw
+    //   - only two consecutive katakana chars in the whole text, or
+    //   - at least 10% of bytes that could be "upper" not-alphanumeric Latin1,
+    // - then we conclude Shift_JIS, else ISO-8859-1
+    if (canBeISO88591 && canBeShiftJIS) {
+      return (sjisMaxKatakanaWordLength == 2 && sjisKatakanaChars == 2) || isoHighOther * 10 >= length
+          ? SHIFT_JIS_CHARSET : StandardCharsets.ISO_8859_1;
+    }
+
+    // Otherwise, try in order ISO-8859-1, Shift JIS, UTF-8 and fall back to default platform encoding
+    if (canBeISO88591) {
+      return StandardCharsets.ISO_8859_1;
+    }
+    if (canBeShiftJIS) {
+      return SHIFT_JIS_CHARSET;
+    }
+    if (canBeUTF8) {
+      return StandardCharsets.UTF_8;
+    }
+    // Otherwise, we take a wild guess with platform encoding
+    return PLATFORM_DEFAULT_ENCODING;
+  }
+
+}

src/common/detector/MathUtils.java

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2012 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common.detector;
+
+/**
+ * General math-related and numeric utility functions.
+ */
+public final class MathUtils {
+
+  private MathUtils() {
+  }
+
+  /**
+   * Ends up being a bit faster than {@link Math#round(float)}. This merely rounds its
+   * argument to the nearest int, where x.5 rounds up to x+1. Semantics of this shortcut
+   * differ slightly from {@link Math#round(float)} in that half rounds down for negative
+   * values. -2.5 rounds to -3, not -2. For purposes here it makes no difference.
+   *
+   * @param d real value to round
+   * @return nearest {@code int}
+   */
+  public static int round(float d) {
+    return (int) (d + (d < 0.0f ? -0.5f : 0.5f));
+  }
+
+  /**
+   * @param aX point A x coordinate
+   * @param aY point A y coordinate
+   * @param bX point B x coordinate
+   * @param bY point B y coordinate
+   * @return Euclidean distance between points A and B
+   */
+  public static float distance(float aX, float aY, float bX, float bY) {
+    double xDiff = aX - bX;
+    double yDiff = aY - bY;
+    return (float) Math.sqrt(xDiff * xDiff + yDiff * yDiff);
+  }
+
+  /**
+   * @param aX point A x coordinate
+   * @param aY point A y coordinate
+   * @param bX point B x coordinate
+   * @param bY point B y coordinate
+   * @return Euclidean distance between points A and B
+   */
+  public static float distance(int aX, int aY, int bX, int bY) {
+    double xDiff = aX - bX;
+    double yDiff = aY - bY;
+    return (float) Math.sqrt(xDiff * xDiff + yDiff * yDiff);
+  }
+
+  /**
+   * @param array values to sum
+   * @return sum of values in array
+   */
+  public static int sum(int[] array) {
+    int count = 0;
+    for (int a : array) {
+      count += a;
+    }
+    return count;
+  }
+
+}

src/common/detector/MonochromeRectangleDetector.java

@@ -0,0 +1,217 @@
+/*
+ * Copyright 2009 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common.detector;
+
+import com.google.zxing.NotFoundException;
+import com.google.zxing.ResultPoint;
+import com.google.zxing.common.BitMatrix;
+
+/**
+ * <p>A somewhat generic detector that looks for a barcode-like rectangular region within an image.
+ * It looks within a mostly white region of an image for a region of black and white, but mostly
+ * black. It returns the four corners of the region, as best it can determine.</p>
+ *
+ * @author Sean Owen
+ * @deprecated without replacement since 3.3.0
+ */
+@Deprecated
+public final class MonochromeRectangleDetector {
+
+  private static final int MAX_MODULES = 32;
+
+  private final BitMatrix image;
+
+  public MonochromeRectangleDetector(BitMatrix image) {
+    this.image = image;
+  }
+
+  /**
+   * <p>Detects a rectangular region of black and white -- mostly black -- with a region of mostly
+   * white, in an image.</p>
+   *
+   * @return {@link ResultPoint}[] describing the corners of the rectangular region. The first and
+   *  last points are opposed on the diagonal, as are the second and third. The first point will be
+   *  the topmost point and the last, the bottommost. The second point will be leftmost and the
+   *  third, the rightmost
+   * @throws NotFoundException if no Data Matrix Code can be found
+   */
+  public ResultPoint[] detect() throws NotFoundException {
+    int height = image.getHeight();
+    int width = image.getWidth();
+    int halfHeight = height / 2;
+    int halfWidth = width / 2;
+    int deltaY = Math.max(1, height / (MAX_MODULES * 8));
+    int deltaX = Math.max(1, width / (MAX_MODULES * 8));
+
+    int top = 0;
+    int bottom = height;
+    int left = 0;
+    int right = width;
+    ResultPoint pointA = findCornerFromCenter(halfWidth, 0, left, right,
+        halfHeight, -deltaY, top, bottom, halfWidth / 2);
+    top = (int) pointA.getY() - 1;
+    ResultPoint pointB = findCornerFromCenter(halfWidth, -deltaX, left, right,
+        halfHeight, 0, top, bottom, halfHeight / 2);
+    left = (int) pointB.getX() - 1;
+    ResultPoint pointC = findCornerFromCenter(halfWidth, deltaX, left, right,
+        halfHeight, 0, top, bottom, halfHeight / 2);
+    right = (int) pointC.getX() + 1;
+    ResultPoint pointD = findCornerFromCenter(halfWidth, 0, left, right,
+        halfHeight, deltaY, top, bottom, halfWidth / 2);
+    bottom = (int) pointD.getY() + 1;
+
+    // Go try to find point A again with better information -- might have been off at first.
+    pointA = findCornerFromCenter(halfWidth, 0, left, right,
+        halfHeight, -deltaY, top, bottom, halfWidth / 4);
+
+    return new ResultPoint[] { pointA, pointB, pointC, pointD };
+  }
+
+  /**
+   * Attempts to locate a corner of the barcode by scanning up, down, left or right from a center
+   * point which should be within the barcode.
+   *
+   * @param centerX center's x component (horizontal)
+   * @param deltaX same as deltaY but change in x per step instead
+   * @param left minimum value of x
+   * @param right maximum value of x
+   * @param centerY center's y component (vertical)
+   * @param deltaY change in y per step. If scanning up this is negative; down, positive;
+   *  left or right, 0
+   * @param top minimum value of y to search through (meaningless when di == 0)
+   * @param bottom maximum value of y
+   * @param maxWhiteRun maximum run of white pixels that can still be considered to be within
+   *  the barcode
+   * @return a {@link ResultPoint} encapsulating the corner that was found
+   * @throws NotFoundException if such a point cannot be found
+   */
+  private ResultPoint findCornerFromCenter(int centerX,
+                                           int deltaX,
+                                           int left,
+                                           int right,
+                                           int centerY,
+                                           int deltaY,
+                                           int top,
+                                           int bottom,
+                                           int maxWhiteRun) throws NotFoundException {
+    int[] lastRange = null;
+    for (int y = centerY, x = centerX;
+         y < bottom && y >= top && x < right && x >= left;
+         y += deltaY, x += deltaX) {
+      int[] range;
+      if (deltaX == 0) {
+        // horizontal slices, up and down
+        range = blackWhiteRange(y, maxWhiteRun, left, right, true);
+      } else {
+        // vertical slices, left and right
+        range = blackWhiteRange(x, maxWhiteRun, top, bottom, false);
+      }
+      if (range == null) {
+        if (lastRange == null) {
+          throw NotFoundException.getNotFoundInstance();
+        }
+        // lastRange was found
+        if (deltaX == 0) {
+          int lastY = y - deltaY;
+          if (lastRange[0] < centerX) {
+            if (lastRange[1] > centerX) {
+              // straddle, choose one or the other based on direction
+              return new ResultPoint(lastRange[deltaY > 0 ? 0 : 1], lastY);
+            }
+            return new ResultPoint(lastRange[0], lastY);
+          } else {
+            return new ResultPoint(lastRange[1], lastY);
+          }
+        } else {
+          int lastX = x - deltaX;
+          if (lastRange[0] < centerY) {
+            if (lastRange[1] > centerY) {
+              return new ResultPoint(lastX, lastRange[deltaX < 0 ? 0 : 1]);
+            }
+            return new ResultPoint(lastX, lastRange[0]);
+          } else {
+            return new ResultPoint(lastX, lastRange[1]);
+          }
+        }
+      }
+      lastRange = range;
+    }
+    throw NotFoundException.getNotFoundInstance();
+  }
+
+  /**
+   * Computes the start and end of a region of pixels, either horizontally or vertically, that could
+   * be part of a Data Matrix barcode.
+   *
+   * @param fixedDimension if scanning horizontally, this is the row (the fixed vertical location)
+   *  where we are scanning. If scanning vertically it's the column, the fixed horizontal location
+   * @param maxWhiteRun largest run of white pixels that can still be considered part of the
+   *  barcode region
+   * @param minDim minimum pixel location, horizontally or vertically, to consider
+   * @param maxDim maximum pixel location, horizontally or vertically, to consider
+   * @param horizontal if true, we're scanning left-right, instead of up-down
+   * @return int[] with start and end of found range, or null if no such range is found
+   *  (e.g. only white was found)
+   */
+  private int[] blackWhiteRange(int fixedDimension, int maxWhiteRun, int minDim, int maxDim, boolean horizontal) {
+
+    int center = (minDim + maxDim) / 2;
+
+    // Scan left/up first
+    int start = center;
+    while (start >= minDim) {
+      if (horizontal ? image.get(start, fixedDimension) : image.get(fixedDimension, start)) {
+        start--;
+      } else {
+        int whiteRunStart = start;
+        do {
+          start--;
+        } while (start >= minDim && !(horizontal ? image.get(start, fixedDimension) :
+            image.get(fixedDimension, start)));
+        int whiteRunSize = whiteRunStart - start;
+        if (start < minDim || whiteRunSize > maxWhiteRun) {
+          start = whiteRunStart;
+          break;
+        }
+      }
+    }
+    start++;
+
+    // Then try right/down
+    int end = center;
+    while (end < maxDim) {
+      if (horizontal ? image.get(end, fixedDimension) : image.get(fixedDimension, end)) {
+        end++;
+      } else {
+        int whiteRunStart = end;
+        do {
+          end++;
+        } while (end < maxDim && !(horizontal ? image.get(end, fixedDimension) :
+            image.get(fixedDimension, end)));
+        int whiteRunSize = end - whiteRunStart;
+        if (end >= maxDim || whiteRunSize > maxWhiteRun) {
+          end = whiteRunStart;
+          break;
+        }
+      }
+    }
+    end--;
+
+    return end > start ? new int[]{start, end} : null;
+  }
+
+}

src/common/detector/WhiteRectangleDetector.java

@@ -0,0 +1,325 @@
+/*
+ * Copyright 2010 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common.detector;
+
+import com.google.zxing.NotFoundException;
+import com.google.zxing.ResultPoint;
+import com.google.zxing.common.BitMatrix;
+
+/**
+ * <p>
+ * Detects a candidate barcode-like rectangular region within an image. It
+ * starts around the center of the image, increases the size of the candidate
+ * region until it finds a white rectangular region. By keeping track of the
+ * last black points it encountered, it determines the corners of the barcode.
+ * </p>
+ *
+ * @author David Olivier
+ */
+public final class WhiteRectangleDetector {
+
+  private static final int INIT_SIZE = 10;
+  private static final int CORR = 1;
+
+  private final BitMatrix image;
+  private final int height;
+  private final int width;
+  private final int leftInit;
+  private final int rightInit;
+  private final int downInit;
+  private final int upInit;
+
+  public WhiteRectangleDetector(BitMatrix image) throws NotFoundException {
+    this(image, INIT_SIZE, image.getWidth() / 2, image.getHeight() / 2);
+  }
+
+  /**
+   * @param image barcode image to find a rectangle in
+   * @param initSize initial size of search area around center
+   * @param x x position of search center
+   * @param y y position of search center
+   * @throws NotFoundException if image is too small to accommodate {@code initSize}
+   */
+  public WhiteRectangleDetector(BitMatrix image, int initSize, int x, int y) throws NotFoundException {
+    this.image = image;
+    height = image.getHeight();
+    width = image.getWidth();
+    int halfsize = initSize / 2;
+    leftInit = x - halfsize;
+    rightInit = x + halfsize;
+    upInit = y - halfsize;
+    downInit = y + halfsize;
+    if (upInit < 0 || leftInit < 0 || downInit >= height || rightInit >= width) {
+      throw NotFoundException.getNotFoundInstance();
+    }
+  }
+
+  /**
+   * <p>
+   * Detects a candidate barcode-like rectangular region within an image. It
+   * starts around the center of the image, increases the size of the candidate
+   * region until it finds a white rectangular region.
+   * </p>
+   *
+   * @return {@link ResultPoint}[] describing the corners of the rectangular
+   *         region. The first and last points are opposed on the diagonal, as
+   *         are the second and third. The first point will be the topmost
+   *         point and the last, the bottommost. The second point will be
+   *         leftmost and the third, the rightmost
+   * @throws NotFoundException if no Data Matrix Code can be found
+   */
+  public ResultPoint[] detect() throws NotFoundException {
+
+    int left = leftInit;
+    int right = rightInit;
+    int up = upInit;
+    int down = downInit;
+    boolean sizeExceeded = false;
+    boolean aBlackPointFoundOnBorder = true;
+
+    boolean atLeastOneBlackPointFoundOnRight = false;
+    boolean atLeastOneBlackPointFoundOnBottom = false;
+    boolean atLeastOneBlackPointFoundOnLeft = false;
+    boolean atLeastOneBlackPointFoundOnTop = false;
+
+    while (aBlackPointFoundOnBorder) {
+
+      aBlackPointFoundOnBorder = false;
+
+      // .....
+      // .   |
+      // .....
+      boolean rightBorderNotWhite = true;
+      while ((rightBorderNotWhite || !atLeastOneBlackPointFoundOnRight) && right < width) {
+        rightBorderNotWhite = containsBlackPoint(up, down, right, false);
+        if (rightBorderNotWhite) {
+          right++;
+          aBlackPointFoundOnBorder = true;
+          atLeastOneBlackPointFoundOnRight = true;
+        } else if (!atLeastOneBlackPointFoundOnRight) {
+          right++;
+        }
+      }
+
+      if (right >= width) {
+        sizeExceeded = true;
+        break;
+      }
+
+      // .....
+      // .   .
+      // .___.
+      boolean bottomBorderNotWhite = true;
+      while ((bottomBorderNotWhite || !atLeastOneBlackPointFoundOnBottom) && down < height) {
+        bottomBorderNotWhite = containsBlackPoint(left, right, down, true);
+        if (bottomBorderNotWhite) {
+          down++;
+          aBlackPointFoundOnBorder = true;
+          atLeastOneBlackPointFoundOnBottom = true;
+        } else if (!atLeastOneBlackPointFoundOnBottom) {
+          down++;
+        }
+      }
+
+      if (down >= height) {
+        sizeExceeded = true;
+        break;
+      }
+
+      // .....
+      // |   .
+      // .....
+      boolean leftBorderNotWhite = true;
+      while ((leftBorderNotWhite || !atLeastOneBlackPointFoundOnLeft) && left >= 0) {
+        leftBorderNotWhite = containsBlackPoint(up, down, left, false);
+        if (leftBorderNotWhite) {
+          left--;
+          aBlackPointFoundOnBorder = true;
+          atLeastOneBlackPointFoundOnLeft = true;
+        } else if (!atLeastOneBlackPointFoundOnLeft) {
+          left--;
+        }
+      }
+
+      if (left < 0) {
+        sizeExceeded = true;
+        break;
+      }
+
+      // .___.
+      // .   .
+      // .....
+      boolean topBorderNotWhite = true;
+      while ((topBorderNotWhite || !atLeastOneBlackPointFoundOnTop) && up >= 0) {
+        topBorderNotWhite = containsBlackPoint(left, right, up, true);
+        if (topBorderNotWhite) {
+          up--;
+          aBlackPointFoundOnBorder = true;
+          atLeastOneBlackPointFoundOnTop = true;
+        } else if (!atLeastOneBlackPointFoundOnTop) {
+          up--;
+        }
+      }
+
+      if (up < 0) {
+        sizeExceeded = true;
+        break;
+      }
+
+    }
+
+    if (!sizeExceeded) {
+
+      int maxSize = right - left;
+
+      ResultPoint z = null;
+      for (int i = 1; z == null && i < maxSize; i++) {
+        z = getBlackPointOnSegment(left, down - i, left + i, down);
+      }
+
+      if (z == null) {
+        throw NotFoundException.getNotFoundInstance();
+      }
+
+      ResultPoint t = null;
+      //go down right
+      for (int i = 1; t == null && i < maxSize; i++) {
+        t = getBlackPointOnSegment(left, up + i, left + i, up);
+      }
+
+      if (t == null) {
+        throw NotFoundException.getNotFoundInstance();
+      }
+
+      ResultPoint x = null;
+      //go down left
+      for (int i = 1; x == null && i < maxSize; i++) {
+        x = getBlackPointOnSegment(right, up + i, right - i, up);
+      }
+
+      if (x == null) {
+        throw NotFoundException.getNotFoundInstance();
+      }
+
+      ResultPoint y = null;
+      //go up left
+      for (int i = 1; y == null && i < maxSize; i++) {
+        y = getBlackPointOnSegment(right, down - i, right - i, down);
+      }
+
+      if (y == null) {
+        throw NotFoundException.getNotFoundInstance();
+      }
+
+      return centerEdges(y, z, x, t);
+
+    } else {
+      throw NotFoundException.getNotFoundInstance();
+    }
+  }
+
+  private ResultPoint getBlackPointOnSegment(float aX, float aY, float bX, float bY) {
+    int dist = MathUtils.round(MathUtils.distance(aX, aY, bX, bY));
+    float xStep = (bX - aX) / dist;
+    float yStep = (bY - aY) / dist;
+
+    for (int i = 0; i < dist; i++) {
+      int x = MathUtils.round(aX + i * xStep);
+      int y = MathUtils.round(aY + i * yStep);
+      if (image.get(x, y)) {
+        return new ResultPoint(x, y);
+      }
+    }
+    return null;
+  }
+
+  /**
+   * recenters the points of a constant distance towards the center
+   *
+   * @param y bottom most point
+   * @param z left most point
+   * @param x right most point
+   * @param t top most point
+   * @return {@link ResultPoint}[] describing the corners of the rectangular
+   *         region. The first and last points are opposed on the diagonal, as
+   *         are the second and third. The first point will be the topmost
+   *         point and the last, the bottommost. The second point will be
+   *         leftmost and the third, the rightmost
+   */
+  private ResultPoint[] centerEdges(ResultPoint y, ResultPoint z,
+                                    ResultPoint x, ResultPoint t) {
+
+    //
+    //       t            t
+    //  z                      x
+    //        x    OR    z
+    //   y                    y
+    //
+
+    float yi = y.getX();
+    float yj = y.getY();
+    float zi = z.getX();
+    float zj = z.getY();
+    float xi = x.getX();
+    float xj = x.getY();
+    float ti = t.getX();
+    float tj = t.getY();
+
+    if (yi < width / 2.0f) {
+      return new ResultPoint[]{
+          new ResultPoint(ti - CORR, tj + CORR),
+          new ResultPoint(zi + CORR, zj + CORR),
+          new ResultPoint(xi - CORR, xj - CORR),
+          new ResultPoint(yi + CORR, yj - CORR)};
+    } else {
+      return new ResultPoint[]{
+          new ResultPoint(ti + CORR, tj + CORR),
+          new ResultPoint(zi + CORR, zj - CORR),
+          new ResultPoint(xi - CORR, xj + CORR),
+          new ResultPoint(yi - CORR, yj - CORR)};
+    }
+  }
+
+  /**
+   * Determines whether a segment contains a black point
+   *
+   * @param a          min value of the scanned coordinate
+   * @param b          max value of the scanned coordinate
+   * @param fixed      value of fixed coordinate
+   * @param horizontal set to true if scan must be horizontal, false if vertical
+   * @return true if a black point has been found, else false.
+   */
+  private boolean containsBlackPoint(int a, int b, int fixed, boolean horizontal) {
+
+    if (horizontal) {
+      for (int x = a; x <= b; x++) {
+        if (image.get(x, fixed)) {
+          return true;
+        }
+      }
+    } else {
+      for (int y = a; y <= b; y++) {
+        if (image.get(fixed, y)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+}

src/common/reedsolomon/GenericGF.java

@@ -0,0 +1,166 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common.reedsolomon;
+
+/**
+ * <p>This class contains utility methods for performing mathematical operations over
+ * the Galois Fields. Operations use a given primitive polynomial in calculations.</p>
+ *
+ * <p>Throughout this package, elements of the GF are represented as an {@code int}
+ * for convenience and speed (but at the cost of memory).
+ * </p>
+ *
+ * @author Sean Owen
+ * @author David Olivier
+ */
+public final class GenericGF {
+
+  public static final GenericGF AZTEC_DATA_12 = new GenericGF(0x1069, 4096, 1); // x^12 + x^6 + x^5 + x^3 + 1
+  public static final GenericGF AZTEC_DATA_10 = new GenericGF(0x409, 1024, 1); // x^10 + x^3 + 1
+  public static final GenericGF AZTEC_DATA_6 = new GenericGF(0x43, 64, 1); // x^6 + x + 1
+  public static final GenericGF AZTEC_PARAM = new GenericGF(0x13, 16, 1); // x^4 + x + 1
+  public static final GenericGF QR_CODE_FIELD_256 = new GenericGF(0x011D, 256, 0); // x^8 + x^4 + x^3 + x^2 + 1
+  public static final GenericGF DATA_MATRIX_FIELD_256 = new GenericGF(0x012D, 256, 1); // x^8 + x^5 + x^3 + x^2 + 1
+  public static final GenericGF AZTEC_DATA_8 = DATA_MATRIX_FIELD_256;
+  public static final GenericGF MAXICODE_FIELD_64 = AZTEC_DATA_6;
+
+  private final int[] expTable;
+  private final int[] logTable;
+  private final GenericGFPoly zero;
+  private final GenericGFPoly one;
+  private final int size;
+  private final int primitive;
+  private final int generatorBase;
+
+  /**
+   * Create a representation of GF(size) using the given primitive polynomial.
+   *
+   * @param primitive irreducible polynomial whose coefficients are represented by
+   *  the bits of an int, where the least-significant bit represents the constant
+   *  coefficient
+   * @param size the size of the field
+   * @param b the factor b in the generator polynomial can be 0- or 1-based
+   *  (g(x) = (x+a^b)(x+a^(b+1))...(x+a^(b+2t-1))).
+   *  In most cases it should be 1, but for QR code it is 0.
+   */
+  public GenericGF(int primitive, int size, int b) {
+    this.primitive = primitive;
+    this.size = size;
+    this.generatorBase = b;
+
+    expTable = new int[size];
+    logTable = new int[size];
+    int x = 1;
+    for (int i = 0; i < size; i++) {
+      expTable[i] = x;
+      x *= 2; // we're assuming the generator alpha is 2
+      if (x >= size) {
+        x ^= primitive;
+        x &= size - 1;
+      }
+    }
+    for (int i = 0; i < size - 1; i++) {
+      logTable[expTable[i]] = i;
+    }
+    // logTable[0] == 0 but this should never be used
+    zero = new GenericGFPoly(this, new int[]{0});
+    one = new GenericGFPoly(this, new int[]{1});
+  }
+
+  GenericGFPoly getZero() {
+    return zero;
+  }
+
+  GenericGFPoly getOne() {
+    return one;
+  }
+
+  /**
+   * @return the monomial representing coefficient * x^degree
+   */
+  GenericGFPoly buildMonomial(int degree, int coefficient) {
+    if (degree < 0) {
+      throw new IllegalArgumentException();
+    }
+    if (coefficient == 0) {
+      return zero;
+    }
+    int[] coefficients = new int[degree + 1];
+    coefficients[0] = coefficient;
+    return new GenericGFPoly(this, coefficients);
+  }
+
+  /**
+   * Implements both addition and subtraction -- they are the same in GF(size).
+   *
+   * @return sum/difference of a and b
+   */
+  static int addOrSubtract(int a, int b) {
+    return a ^ b;
+  }
+
+  /**
+   * @return 2 to the power of a in GF(size)
+   */
+  int exp(int a) {
+    return expTable[a];
+  }
+
+  /**
+   * @return base 2 log of a in GF(size)
+   */
+  int log(int a) {
+    if (a == 0) {
+      throw new IllegalArgumentException();
+    }
+    return logTable[a];
+  }
+
+  /**
+   * @return multiplicative inverse of a
+   */
+  int inverse(int a) {
+    if (a == 0) {
+      throw new ArithmeticException();
+    }
+    return expTable[size - logTable[a] - 1];
+  }
+
+  /**
+   * @return product of a and b in GF(size)
+   */
+  int multiply(int a, int b) {
+    if (a == 0 || b == 0) {
+      return 0;
+    }
+    return expTable[(logTable[a] + logTable[b]) % (size - 1)];
+  }
+
+  public int getSize() {
+    return size;
+  }
+
+  public int getGeneratorBase() {
+    return generatorBase;
+  }
+
+  @Override
+  public String toString() {
+    return "GF(0x" + Integer.toHexString(primitive) + ',' + size + ')';
+  }
+
+}

src/common/reedsolomon/GenericGFPoly.java

@@ -0,0 +1,271 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common.reedsolomon;
+
+/**
+ * <p>Represents a polynomial whose coefficients are elements of a GF.
+ * Instances of this class are immutable.</p>
+ *
+ * <p>Much credit is due to William Rucklidge since portions of this code are an indirect
+ * port of his C++ Reed-Solomon implementation.</p>
+ *
+ * @author Sean Owen
+ */
+final class GenericGFPoly {
+
+  private final GenericGF field;
+  private final int[] coefficients;
+
+  /**
+   * @param field the {@link GenericGF} instance representing the field to use
+   * to perform computations
+   * @param coefficients coefficients as ints representing elements of GF(size), arranged
+   * from most significant (highest-power term) coefficient to least significant
+   * @throws IllegalArgumentException if argument is null or empty,
+   * or if leading coefficient is 0 and this is not a
+   * constant polynomial (that is, it is not the monomial "0")
+   */
+  GenericGFPoly(GenericGF field, int[] coefficients) {
+    if (coefficients.length == 0) {
+      throw new IllegalArgumentException();
+    }
+    this.field = field;
+    int coefficientsLength = coefficients.length;
+    if (coefficientsLength > 1 && coefficients[0] == 0) {
+      // Leading term must be non-zero for anything except the constant polynomial "0"
+      int firstNonZero = 1;
+      while (firstNonZero < coefficientsLength && coefficients[firstNonZero] == 0) {
+        firstNonZero++;
+      }
+      if (firstNonZero == coefficientsLength) {
+        this.coefficients = new int[]{0};
+      } else {
+        this.coefficients = new int[coefficientsLength - firstNonZero];
+        System.arraycopy(coefficients,
+            firstNonZero,
+            this.coefficients,
+            0,
+            this.coefficients.length);
+      }
+    } else {
+      this.coefficients = coefficients;
+    }
+  }
+
+  int[] getCoefficients() {
+    return coefficients;
+  }
+
+  /**
+   * @return degree of this polynomial
+   */
+  int getDegree() {
+    return coefficients.length - 1;
+  }
+
+  /**
+   * @return true iff this polynomial is the monomial "0"
+   */
+  boolean isZero() {
+    return coefficients[0] == 0;
+  }
+
+  /**
+   * @return coefficient of x^degree term in this polynomial
+   */
+  int getCoefficient(int degree) {
+    return coefficients[coefficients.length - 1 - degree];
+  }
+
+  /**
+   * @return evaluation of this polynomial at a given point
+   */
+  int evaluateAt(int a) {
+    if (a == 0) {
+      // Just return the x^0 coefficient
+      return getCoefficient(0);
+    }
+    if (a == 1) {
+      // Just the sum of the coefficients
+      int result = 0;
+      for (int coefficient : coefficients) {
+        result = GenericGF.addOrSubtract(result, coefficient);
+      }
+      return result;
+    }
+    int result = coefficients[0];
+    int size = coefficients.length;
+    for (int i = 1; i < size; i++) {
+      result = GenericGF.addOrSubtract(field.multiply(a, result), coefficients[i]);
+    }
+    return result;
+  }
+
+  GenericGFPoly addOrSubtract(GenericGFPoly other) {
+    if (!field.equals(other.field)) {
+      throw new IllegalArgumentException("GenericGFPolys do not have same GenericGF field");
+    }
+    if (isZero()) {
+      return other;
+    }
+    if (other.isZero()) {
+      return this;
+    }
+
+    int[] smallerCoefficients = this.coefficients;
+    int[] largerCoefficients = other.coefficients;
+    if (smallerCoefficients.length > largerCoefficients.length) {
+      int[] temp = smallerCoefficients;
+      smallerCoefficients = largerCoefficients;
+      largerCoefficients = temp;
+    }
+    int[] sumDiff = new int[largerCoefficients.length];
+    int lengthDiff = largerCoefficients.length - smallerCoefficients.length;
+    // Copy high-order terms only found in higher-degree polynomial's coefficients
+    System.arraycopy(largerCoefficients, 0, sumDiff, 0, lengthDiff);
+
+    for (int i = lengthDiff; i < largerCoefficients.length; i++) {
+      sumDiff[i] = GenericGF.addOrSubtract(smallerCoefficients[i - lengthDiff], largerCoefficients[i]);
+    }
+
+    return new GenericGFPoly(field, sumDiff);
+  }
+
+  GenericGFPoly multiply(GenericGFPoly other) {
+    if (!field.equals(other.field)) {
+      throw new IllegalArgumentException("GenericGFPolys do not have same GenericGF field");
+    }
+    if (isZero() || other.isZero()) {
+      return field.getZero();
+    }
+    int[] aCoefficients = this.coefficients;
+    int aLength = aCoefficients.length;
+    int[] bCoefficients = other.coefficients;
+    int bLength = bCoefficients.length;
+    int[] product = new int[aLength + bLength - 1];
+    for (int i = 0; i < aLength; i++) {
+      int aCoeff = aCoefficients[i];
+      for (int j = 0; j < bLength; j++) {
+        product[i + j] = GenericGF.addOrSubtract(product[i + j],
+            field.multiply(aCoeff, bCoefficients[j]));
+      }
+    }
+    return new GenericGFPoly(field, product);
+  }
+
+  GenericGFPoly multiply(int scalar) {
+    if (scalar == 0) {
+      return field.getZero();
+    }
+    if (scalar == 1) {
+      return this;
+    }
+    int size = coefficients.length;
+    int[] product = new int[size];
+    for (int i = 0; i < size; i++) {
+      product[i] = field.multiply(coefficients[i], scalar);
+    }
+    return new GenericGFPoly(field, product);
+  }
+
+  GenericGFPoly multiplyByMonomial(int degree, int coefficient) {
+    if (degree < 0) {
+      throw new IllegalArgumentException();
+    }
+    if (coefficient == 0) {
+      return field.getZero();
+    }
+    int size = coefficients.length;
+    int[] product = new int[size + degree];
+    for (int i = 0; i < size; i++) {
+      product[i] = field.multiply(coefficients[i], coefficient);
+    }
+    return new GenericGFPoly(field, product);
+  }
+
+  GenericGFPoly[] divide(GenericGFPoly other) {
+    if (!field.equals(other.field)) {
+      throw new IllegalArgumentException("GenericGFPolys do not have same GenericGF field");
+    }
+    if (other.isZero()) {
+      throw new IllegalArgumentException("Divide by 0");
+    }
+
+    GenericGFPoly quotient = field.getZero();
+    GenericGFPoly remainder = this;
+
+    int denominatorLeadingTerm = other.getCoefficient(other.getDegree());
+    int inverseDenominatorLeadingTerm = field.inverse(denominatorLeadingTerm);
+
+    while (remainder.getDegree() >= other.getDegree() && !remainder.isZero()) {
+      int degreeDifference = remainder.getDegree() - other.getDegree();
+      int scale = field.multiply(remainder.getCoefficient(remainder.getDegree()), inverseDenominatorLeadingTerm);
+      GenericGFPoly term = other.multiplyByMonomial(degreeDifference, scale);
+      GenericGFPoly iterationQuotient = field.buildMonomial(degreeDifference, scale);
+      quotient = quotient.addOrSubtract(iterationQuotient);
+      remainder = remainder.addOrSubtract(term);
+    }
+
+    return new GenericGFPoly[] { quotient, remainder };
+  }
+
+  @Override
+  public String toString() {
+    if (isZero()) {
+      return "0";
+    }
+    StringBuilder result = new StringBuilder(8 * getDegree());
+    for (int degree = getDegree(); degree >= 0; degree--) {
+      int coefficient = getCoefficient(degree);
+      if (coefficient != 0) {
+        if (coefficient < 0) {
+          if (degree == getDegree()) {
+            result.append("-");
+          } else {
+            result.append(" - ");
+          }
+          coefficient = -coefficient;
+        } else {
+          if (result.length() > 0) {
+            result.append(" + ");
+          }
+        }
+        if (degree == 0 || coefficient != 1) {
+          int alphaPower = field.log(coefficient);
+          if (alphaPower == 0) {
+            result.append('1');
+          } else if (alphaPower == 1) {
+            result.append('a');
+          } else {
+            result.append("a^");
+            result.append(alphaPower);
+          }
+        }
+        if (degree != 0) {
+          if (degree == 1) {
+            result.append('x');
+          } else {
+            result.append("x^");
+            result.append(degree);
+          }
+        }
+      }
+    }
+    return result.toString();
+  }
+
+}

src/common/reedsolomon/ReedSolomonDecoder.java

@@ -0,0 +1,191 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common.reedsolomon;
+
+/**
+ * <p>Implements Reed-Solomon decoding, as the name implies.</p>
+ *
+ * <p>The algorithm will not be explained here, but the following references were helpful
+ * in creating this implementation:</p>
+ *
+ * <ul>
+ * <li>Bruce Maggs.
+ * <a href="http://www.cs.cmu.edu/afs/cs.cmu.edu/project/pscico-guyb/realworld/www/rs_decode.ps">
+ * "Decoding Reed-Solomon Codes"</a> (see discussion of Forney's Formula)</li>
+ * <li>J.I. Hall. <a href="www.mth.msu.edu/~jhall/classes/codenotes/GRS.pdf">
+ * "Chapter 5. Generalized Reed-Solomon Codes"</a>
+ * (see discussion of Euclidean algorithm)</li>
+ * </ul>
+ *
+ * <p>Much credit is due to William Rucklidge since portions of this code are an indirect
+ * port of his C++ Reed-Solomon implementation.</p>
+ *
+ * @author Sean Owen
+ * @author William Rucklidge
+ * @author sanfordsquires
+ */
+public final class ReedSolomonDecoder {
+
+  private final GenericGF field;
+
+  public ReedSolomonDecoder(GenericGF field) {
+    this.field = field;
+  }
+
+  /**
+   * <p>Decodes given set of received codewords, which include both data and error-correction
+   * codewords. Really, this means it uses Reed-Solomon to detect and correct errors, in-place,
+   * in the input.</p>
+   *
+   * @param received data and error-correction codewords
+   * @param twoS number of error-correction codewords available
+   * @throws ReedSolomonException if decoding fails for any reason
+   */
+  public void decode(int[] received, int twoS) throws ReedSolomonException {
+    GenericGFPoly poly = new GenericGFPoly(field, received);
+    int[] syndromeCoefficients = new int[twoS];
+    boolean noError = true;
+    for (int i = 0; i < twoS; i++) {
+      int eval = poly.evaluateAt(field.exp(i + field.getGeneratorBase()));
+      syndromeCoefficients[syndromeCoefficients.length - 1 - i] = eval;
+      if (eval != 0) {
+        noError = false;
+      }
+    }
+    if (noError) {
+      return;
+    }
+    GenericGFPoly syndrome = new GenericGFPoly(field, syndromeCoefficients);
+    GenericGFPoly[] sigmaOmega =
+        runEuclideanAlgorithm(field.buildMonomial(twoS, 1), syndrome, twoS);
+    GenericGFPoly sigma = sigmaOmega[0];
+    GenericGFPoly omega = sigmaOmega[1];
+    int[] errorLocations = findErrorLocations(sigma);
+    int[] errorMagnitudes = findErrorMagnitudes(omega, errorLocations);
+    for (int i = 0; i < errorLocations.length; i++) {
+      int position = received.length - 1 - field.log(errorLocations[i]);
+      if (position < 0) {
+        throw new ReedSolomonException("Bad error location");
+      }
+      received[position] = GenericGF.addOrSubtract(received[position], errorMagnitudes[i]);
+    }
+  }
+
+  private GenericGFPoly[] runEuclideanAlgorithm(GenericGFPoly a, GenericGFPoly b, int R)
+      throws ReedSolomonException {
+    // Assume a's degree is >= b's
+    if (a.getDegree() < b.getDegree()) {
+      GenericGFPoly temp = a;
+      a = b;
+      b = temp;
+    }
+
+    GenericGFPoly rLast = a;
+    GenericGFPoly r = b;
+    GenericGFPoly tLast = field.getZero();
+    GenericGFPoly t = field.getOne();
+
+    // Run Euclidean algorithm until r's degree is less than R/2
+    while (2 * r.getDegree() >= R) {
+      GenericGFPoly rLastLast = rLast;
+      GenericGFPoly tLastLast = tLast;
+      rLast = r;
+      tLast = t;
+
+      // Divide rLastLast by rLast, with quotient in q and remainder in r
+      if (rLast.isZero()) {
+        // Oops, Euclidean algorithm already terminated?
+        throw new ReedSolomonException("r_{i-1} was zero");
+      }
+      r = rLastLast;
+      GenericGFPoly q = field.getZero();
+      int denominatorLeadingTerm = rLast.getCoefficient(rLast.getDegree());
+      int dltInverse = field.inverse(denominatorLeadingTerm);
+      while (r.getDegree() >= rLast.getDegree() && !r.isZero()) {
+        int degreeDiff = r.getDegree() - rLast.getDegree();
+        int scale = field.multiply(r.getCoefficient(r.getDegree()), dltInverse);
+        q = q.addOrSubtract(field.buildMonomial(degreeDiff, scale));
+        r = r.addOrSubtract(rLast.multiplyByMonomial(degreeDiff, scale));
+      }
+
+      t = q.multiply(tLast).addOrSubtract(tLastLast);
+
+      if (r.getDegree() >= rLast.getDegree()) {
+        throw new IllegalStateException("Division algorithm failed to reduce polynomial? " +
+          "r: " + r + ", rLast: " + rLast);
+      }
+    }
+
+    int sigmaTildeAtZero = t.getCoefficient(0);
+    if (sigmaTildeAtZero == 0) {
+      throw new ReedSolomonException("sigmaTilde(0) was zero");
+    }
+
+    int inverse = field.inverse(sigmaTildeAtZero);
+    GenericGFPoly sigma = t.multiply(inverse);
+    GenericGFPoly omega = r.multiply(inverse);
+    return new GenericGFPoly[]{sigma, omega};
+  }
+
+  private int[] findErrorLocations(GenericGFPoly errorLocator) throws ReedSolomonException {
+    // This is a direct application of Chien's search
+    int numErrors = errorLocator.getDegree();
+    if (numErrors == 1) { // shortcut
+      return new int[] { errorLocator.getCoefficient(1) };
+    }
+    int[] result = new int[numErrors];
+    int e = 0;
+    for (int i = 1; i < field.getSize() && e < numErrors; i++) {
+      if (errorLocator.evaluateAt(i) == 0) {
+        result[e] = field.inverse(i);
+        e++;
+      }
+    }
+    if (e != numErrors) {
+      throw new ReedSolomonException("Error locator degree does not match number of roots");
+    }
+    return result;
+  }
+
+  private int[] findErrorMagnitudes(GenericGFPoly errorEvaluator, int[] errorLocations) {
+    // This is directly applying Forney's Formula
+    int s = errorLocations.length;
+    int[] result = new int[s];
+    for (int i = 0; i < s; i++) {
+      int xiInverse = field.inverse(errorLocations[i]);
+      int denominator = 1;
+      for (int j = 0; j < s; j++) {
+        if (i != j) {
+          //denominator = field.multiply(denominator,
+          //    GenericGF.addOrSubtract(1, field.multiply(errorLocations[j], xiInverse)));
+          // Above should work but fails on some Apple and Linux JDKs due to a Hotspot bug.
+          // Below is a funny-looking workaround from Steven Parkes
+          int term = field.multiply(errorLocations[j], xiInverse);
+          int termPlus1 = (term & 0x1) == 0 ? term | 1 : term & ~1;
+          denominator = field.multiply(denominator, termPlus1);
+        }
+      }
+      result[i] = field.multiply(errorEvaluator.evaluateAt(xiInverse),
+          field.inverse(denominator));
+      if (field.getGeneratorBase() != 0) {
+        result[i] = field.multiply(result[i], xiInverse);
+      }
+    }
+    return result;
+  }
+
+}

src/common/reedsolomon/ReedSolomonEncoder.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common.reedsolomon;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * <p>Implements Reed-Solomon encoding, as the name implies.</p>
+ *
+ * @author Sean Owen
+ * @author William Rucklidge
+ */
+public final class ReedSolomonEncoder {
+
+  private final GenericGF field;
+  private final List<GenericGFPoly> cachedGenerators;
+
+  public ReedSolomonEncoder(GenericGF field) {
+    this.field = field;
+    this.cachedGenerators = new ArrayList<>();
+    cachedGenerators.add(new GenericGFPoly(field, new int[]{1}));
+  }
+
+  private GenericGFPoly buildGenerator(int degree) {
+    if (degree >= cachedGenerators.size()) {
+      GenericGFPoly lastGenerator = cachedGenerators.get(cachedGenerators.size() - 1);
+      for (int d = cachedGenerators.size(); d <= degree; d++) {
+        GenericGFPoly nextGenerator = lastGenerator.multiply(
+            new GenericGFPoly(field, new int[] { 1, field.exp(d - 1 + field.getGeneratorBase()) }));
+        cachedGenerators.add(nextGenerator);
+        lastGenerator = nextGenerator;
+      }
+    }
+    return cachedGenerators.get(degree);
+  }
+
+  public void encode(int[] toEncode, int ecBytes) {
+    if (ecBytes == 0) {
+      throw new IllegalArgumentException("No error correction bytes");
+    }
+    int dataBytes = toEncode.length - ecBytes;
+    if (dataBytes <= 0) {
+      throw new IllegalArgumentException("No data bytes provided");
+    }
+    GenericGFPoly generator = buildGenerator(ecBytes);
+    int[] infoCoefficients = new int[dataBytes];
+    System.arraycopy(toEncode, 0, infoCoefficients, 0, dataBytes);
+    GenericGFPoly info = new GenericGFPoly(field, infoCoefficients);
+    info = info.multiplyByMonomial(ecBytes, 1);
+    GenericGFPoly remainder = info.divide(generator)[1];
+    int[] coefficients = remainder.getCoefficients();
+    int numZeroCoefficients = ecBytes - coefficients.length;
+    for (int i = 0; i < numZeroCoefficients; i++) {
+      toEncode[dataBytes + i] = 0;
+    }
+    System.arraycopy(coefficients, 0, toEncode, dataBytes + numZeroCoefficients, coefficients.length);
+  }
+
+}

src/common/reedsolomon/ReedSolomonException.java

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.common.reedsolomon;
+
+/**
+ * <p>Thrown when an exception occurs during Reed-Solomon decoding, such as when
+ * there are too many errors to correct.</p>
+ *
+ * @author Sean Owen
+ */
+public final class ReedSolomonException extends Exception {
+
+  public ReedSolomonException(String message) {
+    super(message);
+  }
+
+}

src/datamatrix/DataMatrixReader.java

@@ -0,0 +1,160 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.datamatrix;
+
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.BinaryBitmap;
+import com.google.zxing.ChecksumException;
+import com.google.zxing.DecodeHintType;
+import com.google.zxing.FormatException;
+import com.google.zxing.NotFoundException;
+import com.google.zxing.Reader;
+import com.google.zxing.Result;
+import com.google.zxing.ResultMetadataType;
+import com.google.zxing.ResultPoint;
+import com.google.zxing.common.BitMatrix;
+import com.google.zxing.common.DecoderResult;
+import com.google.zxing.common.DetectorResult;
+import com.google.zxing.datamatrix.decoder.Decoder;
+import com.google.zxing.datamatrix.detector.Detector;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * This implementation can detect and decode Data Matrix codes in an image.
+ *
+ * @author bbrown@google.com (Brian Brown)
+ */
+public final class DataMatrixReader implements Reader {
+
+  private static final ResultPoint[] NO_POINTS = new ResultPoint[0];
+
+  private final Decoder decoder = new Decoder();
+
+  /**
+   * Locates and decodes a Data Matrix code in an image.
+   *
+   * @return a String representing the content encoded by the Data Matrix code
+   * @throws NotFoundException if a Data Matrix code cannot be found
+   * @throws FormatException if a Data Matrix code cannot be decoded
+   * @throws ChecksumException if error correction fails
+   */
+  @Override
+  public Result decode(BinaryBitmap image) throws NotFoundException, ChecksumException, FormatException {
+    return decode(image, null);
+  }
+
+  @Override
+  public Result decode(BinaryBitmap image, Map<DecodeHintType,?> hints)
+      throws NotFoundException, ChecksumException, FormatException {
+    DecoderResult decoderResult;
+    ResultPoint[] points;
+    if (hints != null && hints.containsKey(DecodeHintType.PURE_BARCODE)) {
+      BitMatrix bits = extractPureBits(image.getBlackMatrix());
+      decoderResult = decoder.decode(bits);
+      points = NO_POINTS;
+    } else {
+      DetectorResult detectorResult = new Detector(image.getBlackMatrix()).detect();
+      decoderResult = decoder.decode(detectorResult.getBits());
+      points = detectorResult.getPoints();
+    }
+    Result result = new Result(decoderResult.getText(), decoderResult.getRawBytes(), points,
+        BarcodeFormat.DATA_MATRIX);
+    List<byte[]> byteSegments = decoderResult.getByteSegments();
+    if (byteSegments != null) {
+      result.putMetadata(ResultMetadataType.BYTE_SEGMENTS, byteSegments);
+    }
+    String ecLevel = decoderResult.getECLevel();
+    if (ecLevel != null) {
+      result.putMetadata(ResultMetadataType.ERROR_CORRECTION_LEVEL, ecLevel);
+    }
+    result.putMetadata(ResultMetadataType.SYMBOLOGY_IDENTIFIER, "]d" + decoderResult.getSymbologyModifier());
+    return result;
+  }
+
+  @Override
+  public void reset() {
+    // do nothing
+  }
+
+  /**
+   * This method detects a code in a "pure" image -- that is, pure monochrome image
+   * which contains only an unrotated, unskewed, image of a code, with some white border
+   * around it. This is a specialized method that works exceptionally fast in this special
+   * case.
+   */
+  private static BitMatrix extractPureBits(BitMatrix image) throws NotFoundException {
+
+    int[] leftTopBlack = image.getTopLeftOnBit();
+    int[] rightBottomBlack = image.getBottomRightOnBit();
+    if (leftTopBlack == null || rightBottomBlack == null) {
+      throw NotFoundException.getNotFoundInstance();
+    }
+
+    int moduleSize = moduleSize(leftTopBlack, image);
+
+    int top = leftTopBlack[1];
+    int bottom = rightBottomBlack[1];
+    int left = leftTopBlack[0];
+    int right = rightBottomBlack[0];
+
+    int matrixWidth = (right - left + 1) / moduleSize;
+    int matrixHeight = (bottom - top + 1) / moduleSize;
+    if (matrixWidth <= 0 || matrixHeight <= 0) {
+      throw NotFoundException.getNotFoundInstance();
+    }
+
+    // Push in the "border" by half the module width so that we start
+    // sampling in the middle of the module. Just in case the image is a
+    // little off, this will help recover.
+    int nudge = moduleSize / 2;
+    top += nudge;
+    left += nudge;
+
+    // Now just read off the bits
+    BitMatrix bits = new BitMatrix(matrixWidth, matrixHeight);
+    for (int y = 0; y < matrixHeight; y++) {
+      int iOffset = top + y * moduleSize;
+      for (int x = 0; x < matrixWidth; x++) {
+        if (image.get(left + x * moduleSize, iOffset)) {
+          bits.set(x, y);
+        }
+      }
+    }
+    return bits;
+  }
+
+  private static int moduleSize(int[] leftTopBlack, BitMatrix image) throws NotFoundException {
+    int width = image.getWidth();
+    int x = leftTopBlack[0];
+    int y = leftTopBlack[1];
+    while (x < width && image.get(x, y)) {
+      x++;
+    }
+    if (x == width) {
+      throw NotFoundException.getNotFoundInstance();
+    }
+
+    int moduleSize = x - leftTopBlack[0];
+    if (moduleSize == 0) {
+      throw NotFoundException.getNotFoundInstance();
+    }
+    return moduleSize;
+  }
+
+}

src/datamatrix/DataMatrixWriter.java

@@ -0,0 +1,220 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.datamatrix;
+
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.EncodeHintType;
+import com.google.zxing.Writer;
+import com.google.zxing.common.BitMatrix;
+import com.google.zxing.datamatrix.encoder.DefaultPlacement;
+import com.google.zxing.Dimension;
+import com.google.zxing.datamatrix.encoder.ErrorCorrection;
+import com.google.zxing.datamatrix.encoder.HighLevelEncoder;
+import com.google.zxing.datamatrix.encoder.MinimalEncoder;
+import com.google.zxing.datamatrix.encoder.SymbolInfo;
+import com.google.zxing.datamatrix.encoder.SymbolShapeHint;
+import com.google.zxing.qrcode.encoder.ByteMatrix;
+
+import java.util.Map;
+import java.nio.charset.Charset;
+
+/**
+ * This object renders a Data Matrix code as a BitMatrix 2D array of greyscale values.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ * @author Guillaume Le Biller Added to zxing lib.
+ */
+public final class DataMatrixWriter implements Writer {
+
+  @Override
+  public BitMatrix encode(String contents, BarcodeFormat format, int width, int height) {
+    return encode(contents, format, width, height, null);
+  }
+
+  @Override
+  public BitMatrix encode(String contents, BarcodeFormat format, int width, int height, Map<EncodeHintType,?> hints) {
+
+    if (contents.isEmpty()) {
+      throw new IllegalArgumentException("Found empty contents");
+    }
+
+    if (format != BarcodeFormat.DATA_MATRIX) {
+      throw new IllegalArgumentException("Can only encode DATA_MATRIX, but got " + format);
+    }
+
+    if (width < 0 || height < 0) {
+      throw new IllegalArgumentException("Requested dimensions can't be negative: " + width + 'x' + height);
+    }
+
+    // Try to get force shape & min / max size
+    SymbolShapeHint shape = SymbolShapeHint.FORCE_NONE;
+    Dimension minSize = null;
+    Dimension maxSize = null;
+    if (hints != null) {
+      SymbolShapeHint requestedShape = (SymbolShapeHint) hints.get(EncodeHintType.DATA_MATRIX_SHAPE);
+      if (requestedShape != null) {
+        shape = requestedShape;
+      }
+      @SuppressWarnings("deprecation")
+      Dimension requestedMinSize = (Dimension) hints.get(EncodeHintType.MIN_SIZE);
+      if (requestedMinSize != null) {
+        minSize = requestedMinSize;
+      }
+      @SuppressWarnings("deprecation")
+      Dimension requestedMaxSize = (Dimension) hints.get(EncodeHintType.MAX_SIZE);
+      if (requestedMaxSize != null) {
+        maxSize = requestedMaxSize;
+      }
+    }
+
+
+    //1. step: Data encodation
+    String encoded;
+
+    boolean hasCompactionHint = hints != null && hints.containsKey(EncodeHintType.DATA_MATRIX_COMPACT) &&
+        Boolean.parseBoolean(hints.get(EncodeHintType.DATA_MATRIX_COMPACT).toString());
+    if (hasCompactionHint) {
+
+      boolean hasGS1FormatHint = hints.containsKey(EncodeHintType.GS1_FORMAT) &&
+          Boolean.parseBoolean(hints.get(EncodeHintType.GS1_FORMAT).toString());
+
+      Charset charset = null;
+      boolean hasEncodingHint = hints.containsKey(EncodeHintType.CHARACTER_SET);
+      if (hasEncodingHint) {
+        charset = Charset.forName(hints.get(EncodeHintType.CHARACTER_SET).toString());
+      }
+      encoded = MinimalEncoder.encodeHighLevel(contents, charset, hasGS1FormatHint ? 0x1D : -1, shape);
+    } else {
+      boolean hasForceC40Hint = hints != null && hints.containsKey(EncodeHintType.FORCE_C40) &&
+          Boolean.parseBoolean(hints.get(EncodeHintType.FORCE_C40).toString());
+      encoded = HighLevelEncoder.encodeHighLevel(contents, shape, minSize, maxSize, hasForceC40Hint);
+    }
+
+    SymbolInfo symbolInfo = SymbolInfo.lookup(encoded.length(), shape, minSize, maxSize, true);
+
+    //2. step: ECC generation
+    String codewords = ErrorCorrection.encodeECC200(encoded, symbolInfo);
+
+    //3. step: Module placement in Matrix
+    DefaultPlacement placement =
+        new DefaultPlacement(codewords, symbolInfo.getSymbolDataWidth(), symbolInfo.getSymbolDataHeight());
+    placement.place();
+
+    //4. step: low-level encoding
+    return encodeLowLevel(placement, symbolInfo, width, height);
+  }
+
+  /**
+   * Encode the given symbol info to a bit matrix.
+   *
+   * @param placement  The DataMatrix placement.
+   * @param symbolInfo The symbol info to encode.
+   * @return The bit matrix generated.
+   */
+  private static BitMatrix encodeLowLevel(DefaultPlacement placement, SymbolInfo symbolInfo, int width, int height) {
+    int symbolWidth = symbolInfo.getSymbolDataWidth();
+    int symbolHeight = symbolInfo.getSymbolDataHeight();
+
+    ByteMatrix matrix = new ByteMatrix(symbolInfo.getSymbolWidth(), symbolInfo.getSymbolHeight());
+
+    int matrixY = 0;
+
+    for (int y = 0; y < symbolHeight; y++) {
+      // Fill the top edge with alternate 0 / 1
+      int matrixX;
+      if ((y % symbolInfo.matrixHeight) == 0) {
+        matrixX = 0;
+        for (int x = 0; x < symbolInfo.getSymbolWidth(); x++) {
+          matrix.set(matrixX, matrixY, (x % 2) == 0);
+          matrixX++;
+        }
+        matrixY++;
+      }
+      matrixX = 0;
+      for (int x = 0; x < symbolWidth; x++) {
+        // Fill the right edge with full 1
+        if ((x % symbolInfo.matrixWidth) == 0) {
+          matrix.set(matrixX, matrixY, true);
+          matrixX++;
+        }
+        matrix.set(matrixX, matrixY, placement.getBit(x, y));
+        matrixX++;
+        // Fill the right edge with alternate 0 / 1
+        if ((x % symbolInfo.matrixWidth) == symbolInfo.matrixWidth - 1) {
+          matrix.set(matrixX, matrixY, (y % 2) == 0);
+          matrixX++;
+        }
+      }
+      matrixY++;
+      // Fill the bottom edge with full 1
+      if ((y % symbolInfo.matrixHeight) == symbolInfo.matrixHeight - 1) {
+        matrixX = 0;
+        for (int x = 0; x < symbolInfo.getSymbolWidth(); x++) {
+          matrix.set(matrixX, matrixY, true);
+          matrixX++;
+        }
+        matrixY++;
+      }
+    }
+
+    return convertByteMatrixToBitMatrix(matrix, width, height);
+  }
+
+  /**
+   * Convert the ByteMatrix to BitMatrix.
+   *
+   * @param reqHeight The requested height of the image (in pixels) with the Datamatrix code
+   * @param reqWidth The requested width of the image (in pixels) with the Datamatrix code
+   * @param matrix The input matrix.
+   * @return The output matrix.
+   */
+  private static BitMatrix convertByteMatrixToBitMatrix(ByteMatrix matrix, int reqWidth, int reqHeight) {
+    int matrixWidth = matrix.getWidth();
+    int matrixHeight = matrix.getHeight();
+    int outputWidth = Math.max(reqWidth, matrixWidth);
+    int outputHeight = Math.max(reqHeight, matrixHeight);
+
+    int multiple = Math.min(outputWidth / matrixWidth, outputHeight / matrixHeight);
+
+    int leftPadding = (outputWidth - (matrixWidth * multiple)) / 2 ;
+    int topPadding = (outputHeight - (matrixHeight * multiple)) / 2 ;
+
+    BitMatrix output;
+
+    // remove padding if requested width and height are too small
+    if (reqHeight < matrixHeight || reqWidth < matrixWidth) {
+      leftPadding = 0;
+      topPadding = 0;
+      output = new BitMatrix(matrixWidth, matrixHeight);
+    } else {
+      output = new BitMatrix(reqWidth, reqHeight);
+    }
+
+    output.clear();
+    for (int inputY = 0, outputY = topPadding; inputY < matrixHeight; inputY++, outputY += multiple) {
+      // Write the contents of this row of the bytematrix
+      for (int inputX = 0, outputX = leftPadding; inputX < matrixWidth; inputX++, outputX += multiple) {
+        if (matrix.get(inputX, inputY) == 1) {
+          output.setRegion(outputX, outputY, multiple, multiple);
+        }
+      }
+    }
+
+    return output;
+  }
+
+}

src/datamatrix/decoder/BitMatrixParser.java

@@ -0,0 +1,443 @@
+/*
+ * Copyright 2007 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.datamatrix.decoder;
+
+import com.google.zxing.FormatException;
+import com.google.zxing.common.BitMatrix;
+
+/**
+ * @author bbrown@google.com (Brian Brown)
+ */
+final class BitMatrixParser {
+
+  private final BitMatrix mappingBitMatrix;
+  private final BitMatrix readMappingMatrix;
+  private final Version version;
+
+  /**
+   * @param bitMatrix {@link BitMatrix} to parse
+   * @throws FormatException if dimension is < 8 or > 144 or not 0 mod 2
+   */
+  BitMatrixParser(BitMatrix bitMatrix) throws FormatException {
+    int dimension = bitMatrix.getHeight();
+    if (dimension < 8 || dimension > 144 || (dimension & 0x01) != 0) {
+      throw FormatException.getFormatInstance();
+    }
+
+    version = readVersion(bitMatrix);
+    this.mappingBitMatrix = extractDataRegion(bitMatrix);
+    this.readMappingMatrix = new BitMatrix(this.mappingBitMatrix.getWidth(), this.mappingBitMatrix.getHeight());
+  }
+
+  Version getVersion() {
+    return version;
+  }
+
+  /**
+   * <p>Creates the version object based on the dimension of the original bit matrix from
+   * the datamatrix code.</p>
+   *
+   * <p>See ISO 16022:2006 Table 7 - ECC 200 symbol attributes</p>
+   *
+   * @param bitMatrix Original {@link BitMatrix} including alignment patterns
+   * @return {@link Version} encapsulating the Data Matrix Code's "version"
+   * @throws FormatException if the dimensions of the mapping matrix are not valid
+   * Data Matrix dimensions.
+   */
+  private static Version readVersion(BitMatrix bitMatrix) throws FormatException {
+    int numRows = bitMatrix.getHeight();
+    int numColumns = bitMatrix.getWidth();
+    return Version.getVersionForDimensions(numRows, numColumns);
+  }
+
+  /**
+   * <p>Reads the bits in the {@link BitMatrix} representing the mapping matrix (No alignment patterns)
+   * in the correct order in order to reconstitute the codewords bytes contained within the
+   * Data Matrix Code.</p>
+   *
+   * @return bytes encoded within the Data Matrix Code
+   * @throws FormatException if the exact number of bytes expected is not read
+   */
+  byte[] readCodewords() throws FormatException {
+
+    byte[] result = new byte[version.getTotalCodewords()];
+    int resultOffset = 0;
+
+    int row = 4;
+    int column = 0;
+
+    int numRows = mappingBitMatrix.getHeight();
+    int numColumns = mappingBitMatrix.getWidth();
+
+    boolean corner1Read = false;
+    boolean corner2Read = false;
+    boolean corner3Read = false;
+    boolean corner4Read = false;
+
+    // Read all of the codewords
+    do {
+      // Check the four corner cases
+      if ((row == numRows) && (column == 0) && !corner1Read) {
+        result[resultOffset++] = (byte) readCorner1(numRows, numColumns);
+        row -= 2;
+        column += 2;
+        corner1Read = true;
+      } else if ((row == numRows - 2) && (column == 0) && ((numColumns & 0x03) != 0) && !corner2Read) {
+        result[resultOffset++] = (byte) readCorner2(numRows, numColumns);
+        row -= 2;
+        column += 2;
+        corner2Read = true;
+      } else if ((row == numRows + 4) && (column == 2) && ((numColumns & 0x07) == 0) && !corner3Read) {
+        result[resultOffset++] = (byte) readCorner3(numRows, numColumns);
+        row -= 2;
+        column += 2;
+        corner3Read = true;
+      } else if ((row == numRows - 2) && (column == 0) && ((numColumns & 0x07) == 4) && !corner4Read) {
+        result[resultOffset++] = (byte) readCorner4(numRows, numColumns);
+        row -= 2;
+        column += 2;
+        corner4Read = true;
+      } else {
+        // Sweep upward diagonally to the right
+        do {
+          if ((row < numRows) && (column >= 0) && !readMappingMatrix.get(column, row)) {
+            result[resultOffset++] = (byte) readUtah(row, column, numRows, numColumns);
+          }
+          row -= 2;
+          column += 2;
+        } while ((row >= 0) && (column < numColumns));
+        row += 1;
+        column += 3;
+
+        // Sweep downward diagonally to the left
+        do {
+          if ((row >= 0) && (column < numColumns) && !readMappingMatrix.get(column, row)) {
+            result[resultOffset++] = (byte) readUtah(row, column, numRows, numColumns);
+          }
+          row += 2;
+          column -= 2;
+        } while ((row < numRows) && (column >= 0));
+        row += 3;
+        column += 1;
+      }
+    } while ((row < numRows) || (column < numColumns));
+
+    if (resultOffset != version.getTotalCodewords()) {
+      throw FormatException.getFormatInstance();
+    }
+    return result;
+  }
+
+  /**
+   * <p>Reads a bit of the mapping matrix accounting for boundary wrapping.</p>
+   *
+   * @param row Row to read in the mapping matrix
+   * @param column Column to read in the mapping matrix
+   * @param numRows Number of rows in the mapping matrix
+   * @param numColumns Number of columns in the mapping matrix
+   * @return value of the given bit in the mapping matrix
+   */
+  private boolean readModule(int row, int column, int numRows, int numColumns) {
+    // Adjust the row and column indices based on boundary wrapping
+    if (row < 0) {
+      row += numRows;
+      column += 4 - ((numRows + 4) & 0x07);
+    }
+    if (column < 0) {
+      column += numColumns;
+      row += 4 - ((numColumns + 4) & 0x07);
+    }
+    if (row >= numRows) {
+      row -= numRows;
+    }
+    readMappingMatrix.set(column, row);
+    return mappingBitMatrix.get(column, row);
+  }
+
+  /**
+   * <p>Reads the 8 bits of the standard Utah-shaped pattern.</p>
+   *
+   * <p>See ISO 16022:2006, 5.8.1 Figure 6</p>
+   *
+   * @param row Current row in the mapping matrix, anchored at the 8th bit (LSB) of the pattern
+   * @param column Current column in the mapping matrix, anchored at the 8th bit (LSB) of the pattern
+   * @param numRows Number of rows in the mapping matrix
+   * @param numColumns Number of columns in the mapping matrix
+   * @return byte from the utah shape
+   */
+  private int readUtah(int row, int column, int numRows, int numColumns) {
+    int currentByte = 0;
+    if (readModule(row - 2, column - 2, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(row - 2, column - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(row - 1, column - 2, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(row - 1, column - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(row - 1, column, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(row, column - 2, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(row, column - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(row, column, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    return currentByte;
+  }
+
+  /**
+   * <p>Reads the 8 bits of the special corner condition 1.</p>
+   *
+   * <p>See ISO 16022:2006, Figure F.3</p>
+   *
+   * @param numRows Number of rows in the mapping matrix
+   * @param numColumns Number of columns in the mapping matrix
+   * @return byte from the Corner condition 1
+   */
+  private int readCorner1(int numRows, int numColumns) {
+    int currentByte = 0;
+    if (readModule(numRows - 1, 0, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(numRows - 1, 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(numRows - 1, 2, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(0, numColumns - 2, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(0, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(1, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(2, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(3, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    return currentByte;
+  }
+
+  /**
+   * <p>Reads the 8 bits of the special corner condition 2.</p>
+   *
+   * <p>See ISO 16022:2006, Figure F.4</p>
+   *
+   * @param numRows Number of rows in the mapping matrix
+   * @param numColumns Number of columns in the mapping matrix
+   * @return byte from the Corner condition 2
+   */
+  private int readCorner2(int numRows, int numColumns) {
+    int currentByte = 0;
+    if (readModule(numRows - 3, 0, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(numRows - 2, 0, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(numRows - 1, 0, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(0, numColumns - 4, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(0, numColumns - 3, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(0, numColumns - 2, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(0, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(1, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    return currentByte;
+  }
+
+  /**
+   * <p>Reads the 8 bits of the special corner condition 3.</p>
+   *
+   * <p>See ISO 16022:2006, Figure F.5</p>
+   *
+   * @param numRows Number of rows in the mapping matrix
+   * @param numColumns Number of columns in the mapping matrix
+   * @return byte from the Corner condition 3
+   */
+  private int readCorner3(int numRows, int numColumns) {
+    int currentByte = 0;
+    if (readModule(numRows - 1, 0, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(numRows - 1, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(0, numColumns - 3, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(0, numColumns - 2, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(0, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(1, numColumns - 3, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(1, numColumns - 2, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(1, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    return currentByte;
+  }
+
+  /**
+   * <p>Reads the 8 bits of the special corner condition 4.</p>
+   *
+   * <p>See ISO 16022:2006, Figure F.6</p>
+   *
+   * @param numRows Number of rows in the mapping matrix
+   * @param numColumns Number of columns in the mapping matrix
+   * @return byte from the Corner condition 4
+   */
+  private int readCorner4(int numRows, int numColumns) {
+    int currentByte = 0;
+    if (readModule(numRows - 3, 0, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(numRows - 2, 0, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(numRows - 1, 0, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(0, numColumns - 2, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(0, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(1, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(2, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(3, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    return currentByte;
+  }
+
+  /**
+   * <p>Extracts the data region from a {@link BitMatrix} that contains
+   * alignment patterns.</p>
+   *
+   * @param bitMatrix Original {@link BitMatrix} with alignment patterns
+   * @return BitMatrix that has the alignment patterns removed
+   */
+  private BitMatrix extractDataRegion(BitMatrix bitMatrix) {
+    int symbolSizeRows = version.getSymbolSizeRows();
+    int symbolSizeColumns = version.getSymbolSizeColumns();
+
+    if (bitMatrix.getHeight() != symbolSizeRows) {
+      throw new IllegalArgumentException("Dimension of bitMatrix must match the version size");
+    }
+
+    int dataRegionSizeRows = version.getDataRegionSizeRows();
+    int dataRegionSizeColumns = version.getDataRegionSizeColumns();
+
+    int numDataRegionsRow = symbolSizeRows / dataRegionSizeRows;
+    int numDataRegionsColumn = symbolSizeColumns / dataRegionSizeColumns;
+
+    int sizeDataRegionRow = numDataRegionsRow * dataRegionSizeRows;
+    int sizeDataRegionColumn = numDataRegionsColumn * dataRegionSizeColumns;
+
+    BitMatrix bitMatrixWithoutAlignment = new BitMatrix(sizeDataRegionColumn, sizeDataRegionRow);
+    for (int dataRegionRow = 0; dataRegionRow < numDataRegionsRow; ++dataRegionRow) {
+      int dataRegionRowOffset = dataRegionRow * dataRegionSizeRows;
+      for (int dataRegionColumn = 0; dataRegionColumn < numDataRegionsColumn; ++dataRegionColumn) {
+        int dataRegionColumnOffset = dataRegionColumn * dataRegionSizeColumns;
+        for (int i = 0; i < dataRegionSizeRows; ++i) {
+          int readRowOffset = dataRegionRow * (dataRegionSizeRows + 2) + 1 + i;
+          int writeRowOffset = dataRegionRowOffset + i;
+          for (int j = 0; j < dataRegionSizeColumns; ++j) {
+            int readColumnOffset = dataRegionColumn * (dataRegionSizeColumns + 2) + 1 + j;
+            if (bitMatrix.get(readColumnOffset, readRowOffset)) {
+              int writeColumnOffset = dataRegionColumnOffset + j;
+              bitMatrixWithoutAlignment.set(writeColumnOffset, writeRowOffset);
+            }
+          }
+        }
+      }
+    }
+    return bitMatrixWithoutAlignment;
+  }
+
+}

src/datamatrix/decoder/DataBlock.java

@@ -0,0 +1,118 @@
+/*
+ * Copyright 2008 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.zxing.datamatrix.decoder;
+
+/**
+ * <p>Encapsulates a block of data within a Data Matrix Code. Data Matrix Codes may split their data into
+ * multiple blocks, each of which is a unit of data and error-correction codewords. Each
+ * is represented by an instance of this class.</p>
+ *
+ * @author bbrown@google.com (Brian Brown)
+ */
+final class DataBlock {
+
+  private final int numDataCodewords;
+  private final byte[] codewords;
+
+  private DataBlock(int numDataCodewords, byte[] codewords) {
+    this.numDataCodewords = numDataCodewords;
+    this.codewords = codewords;
+  }
+
+  /**
+   * <p>When Data Matrix Codes use multiple data blocks, they actually interleave the bytes of each of them.
+   * That is, the first byte of data block 1 to n is written, then the second bytes, and so on. This
+   * method will separate the data into original blocks.</p>
+   *
+   * @param rawCodewords bytes as read directly from the Data Matrix Code
+   * @param version version of the Data Matrix Code
+   * @return DataBlocks containing original bytes, "de-interleaved" from representation in the
+   *         Data Matrix Code
+   */
+  static DataBlock[] getDataBlocks(byte[] rawCodewords,
+                                   Version version) {
+    // Figure out the number and size of data blocks used by this version
+    Version.ECBlocks ecBlocks = version.getECBlocks();
+
+    // First count the total number of data blocks
+    int totalBlocks = 0;
+    Version.ECB[] ecBlockArray = ecBlocks.getECBlocks();
+    for (Version.ECB ecBlock : ecBlockArray) {
+      totalBlocks += ecBlock.getCount();
+    }
+
+    // Now establish DataBlocks of the appropriate size and number of data codewords
+    DataBlock[] result = new DataBlock[totalBlocks];
+    int numResultBlocks = 0;
+    for (Version.ECB ecBlock : ecBlockArray) {
+      for (int i = 0; i < ecBlock.getCount(); i++) {
+        int numDataCodewords = ecBlock.getDataCodewords();
+        int numBlockCodewords = ecBlocks.getECCodewords() + numDataCodewords;
+        result[numResultBlocks++] = new DataBlock(numDataCodewords, new byte[numBlockCodewords]);
+      }
+    }
+
+    // All blocks have the same amount of data, except that the last n
+    // (where n may be 0) have 1 less byte. Figure out where these start.
+    // TODO(bbrown): There is only one case where there is a difference for Data Matrix for size 144
+    int longerBlocksTotalCodewords = result[0].codewords.length;
+    //int shorterBlocksTotalCodewords = longerBlocksTotalCodewords - 1;
+
+    int longerBlocksNumDataCodewords = longerBlocksTotalCodewords - ecBlocks.getECCodewords();
+    int shorterBlocksNumDataCodewords = longerBlocksNumDataCodewords - 1;
+    // The last elements of result may be 1 element shorter for 144 matrix
+    // first fill out as many elements as all of them have minus 1
+    int rawCodewordsOffset = 0;
+    for (int i = 0; i < shorterBlocksNumDataCodewords; i++) {
+      for (int j = 0; j < numResultBlocks; j++) {
+        result[j].codewords[i] = rawCodewords[rawCodewordsOffset++];
+      }
+    }
+
+    // Fill out the last data block in the longer ones
+    boolean specialVersion = version.getVersionNumber() == 24;
+    int numLongerBlocks = specialVersion ? 8 : numResultBlocks;
+    for (int j = 0; j < numLongerBlocks; j++) {
+      result[j].codewords[longerBlocksNumDataCodewords - 1] = rawCodewords[rawCodewordsOffset++];
+    }
+
+    // Now add in error correction blocks
+    int max = result[0].codewords.length;
+    for (int i = longerBlocksNumDataCodewords; i < max; i++) {
+      for (int j = 0; j < numResultBlocks; j++) {
+        int jOffset = specialVersion ? (j + 8) % numResultBlocks : j;
+        int iOffset = specialVersion && jOffset > 7 ? i - 1 : i;
+        result[jOffset].codewords[iOffset] = rawCodewords[rawCodewordsOffset++];
+      }
+    }
+
+    if (rawCodewordsOffset != rawCodewords.length) {
+      throw new IllegalArgumentException();
+    }
+
+    return result;
+  }
+
+  int getNumDataCodewords() {
+    return numDataCodewords;
+  }
+
+  byte[] getCodewords() {
+    return codewords;
+  }
+
+}