Add Google ZXing Core as Built-in

rubylib/src/main/java/com/google/zxing/BarcodeFormat.java

+/*
+ * 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
+
+}

rubylib/src/main/java/com/google/zxing/Binarizer.java

+/*
+ * 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();
+  }
+
+}

rubylib/src/main/java/com/google/zxing/BinaryBitmap.java

+/*
+ * 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 "";
+    }
+  }
+
+}

rubylib/src/main/java/com/google/zxing/ChecksumException.java

+/*
+ * 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;
+  }
+}
\ No newline at end of file

rubylib/src/main/java/com/google/zxing/DecodeHintType.java

+/*
+ * 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),
+
+  // 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;
+  }
+
+}

rubylib/src/main/java/com/google/zxing/Dimension.java

+/*
+ * 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;
+  }
+
+}

rubylib/src/main/java/com/google/zxing/EncodeHintType.java

+/*
+ * 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 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 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,
+}

rubylib/src/main/java/com/google/zxing/FormatException.java

+/*
+ * 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;
+  }
+}

rubylib/src/main/java/com/google/zxing/InvertedLuminanceSource.java

+/*
+ * 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());
+  }
+
+}

rubylib/src/main/java/com/google/zxing/LuminanceSource.java

+/*
+ * 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();
+  }
+
+}

rubylib/src/main/java/com/google/zxing/MultiFormatReader.java

+/*
+ * 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 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(new Reader[readers.size()]);
+  }
+
+  @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) {
+        try {
+          return reader.decode(image, hints);
+        } catch (ReaderException re) {
+          // continue
+        }
+      }
+    }
+    throw NotFoundException.getNotFoundInstance();
+  }
+
+}

rubylib/src/main/java/com/google/zxing/MultiFormatWriter.java

+/*
+ * 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);
+  }
+
+}

rubylib/src/main/java/com/google/zxing/NotFoundException.java

+/*
+ * 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 INSTANCE;
+  }
+
+}
\ No newline at end of file

rubylib/src/main/java/com/google/zxing/PlanarYUVLuminanceSource.java

+/*
+ * 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;
+      }
+    }
+  }
+
+}

rubylib/src/main/java/com/google/zxing/RGBLuminanceSource.java

+/*
+ * 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);
+  }
+
+}

rubylib/src/main/java/com/google/zxing/Reader.java

+/*
+ * 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();
+
+}

rubylib/src/main/java/com/google/zxing/ReaderException.java

+/*
+ * 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 final 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;
+  }
+
+}

rubylib/src/main/java/com/google/zxing/Result.java

+/*
+ * 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;
+  }
+
+}

rubylib/src/main/java/com/google/zxing/ResultMetadataType.java

+/*
+ * 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,
+
+}

rubylib/src/main/java/com/google/zxing/ResultPoint.java

+/*
+ * 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));
+  }
+
+}

rubylib/src/main/java/com/google/zxing/ResultPointCallback.java

+/*
+ * 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);
+
+}

rubylib/src/main/java/com/google/zxing/Writer.java

+/*
+ * 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;
+
+}

rubylib/src/main/java/com/google/zxing/WriterException.java

+/*
+ * 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);
+  }
+
+}

rubylib/src/main/java/com/google/zxing/aztec/AztecDetectorResult.java

+/*
+ * 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;
+  }
+
+}

rubylib/src/main/java/com/google/zxing/aztec/AztecReader.java

+/*
+ * 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);
+    }
+
+    return result;
+  }
+
+  @Override
+  public void reset() {
+    // do nothing
+  }
+
+}

rubylib/src/main/java/com/google/zxing/aztec/AztecWriter.java

+/*
+ * 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 {
+
+  private static final Charset DEFAULT_CHARSET = Charset.forName("ISO-8859-1");
+
+  @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 = DEFAULT_CHARSET;
+    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.getBytes(charset), eccPercent, layers);
+    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;
+  }
+}

rubylib/src/main/java/com/google/zxing/aztec/decoder/Decoder.java

+/*
+ * 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.DecoderResult;
+import com.google.zxing.common.reedsolomon.GenericGF;
+import com.google.zxing.common.reedsolomon.ReedSolomonDecoder;
+import com.google.zxing.common.reedsolomon.ReedSolomonException;
+
+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 = {
+      "", "\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 AztecDetectorResult ddata;
+
+  public DecoderResult decode(AztecDetectorResult detectorResult) throws FormatException {
+    ddata = detectorResult;
+    BitMatrix matrix = detectorResult.getBits();
+    boolean[] rawbits = extractBits(matrix);
+    boolean[] correctedBits = correctBits(rawbits);
+    byte[] rawBytes = convertBoolArrayToByteArray(correctedBits);
+    String result = getEncodedData(correctedBits);
+    DecoderResult decoderResult = new DecoderResult(rawBytes, result, null, null);
+    decoderResult.setNumBits(correctedBits.length);
+    return decoderResult;
+  }
+
+  // This method is used for testing the high-level encoder
+  public static String highLevelDecode(boolean[] correctedBits) {
+    return getEncodedData(correctedBits);
+  }
+
+  /**
+   * Gets the string encoded in the aztec code bits
+   *
+   * @return the decoded string
+   */
+  private static String getEncodedData(boolean[] correctedBits) {
+    int endIndex = correctedBits.length;
+    Table latchTable = Table.UPPER; // table most recently latched to
+    Table shiftTable = Table.UPPER; // table to use for the next read
+    StringBuilder result = new StringBuilder(20);
+    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);
+          result.append((char) 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 (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 {
+          result.append(str);
+          // Go back to whatever mode we had been in
+          shiftTable = latchTable;
+        }
+      }
+    }
+    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");
+    }
+  }
+
+  /**
+   * <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 boolean[] 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 correctedBits;
+  }
+
+  /**
+   * 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;
+  }
+}

rubylib/src/main/java/com/google/zxing/aztec/encoder/AztecCode.java

+/*
+ * 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;
+  }
+
+}

rubylib/src/main/java/com/google/zxing/aztec/encoder/BinaryShiftToken.java

+/*
+ * 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 short binaryShiftStart;
+  private final short binaryShiftByteCount;
+
+  BinaryShiftToken(Token previous,
+                   int binaryShiftStart,
+                   int binaryShiftByteCount) {
+    super(previous);
+    this.binaryShiftStart = (short) binaryShiftStart;
+    this.binaryShiftByteCount = (short) binaryShiftByteCount;
+  }
+
+  @Override
+  public void appendTo(BitArray bitArray, byte[] text) {
+    for (int i = 0; i < binaryShiftByteCount; i++) {
+      if (i == 0 || (i == 31 && binaryShiftByteCount <= 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 (binaryShiftByteCount > 62) {
+          bitArray.appendBits(binaryShiftByteCount - 31, 16);
+        } else if (i == 0) {
+          // 1 <= binaryShiftByteCode <= 62
+          bitArray.appendBits(Math.min(binaryShiftByteCount, 31), 5);
+        } else {
+          // 32 <= binaryShiftCount <= 62 and i == 31
+          bitArray.appendBits(binaryShiftByteCount - 31, 5);
+        }
+      }
+      bitArray.appendBits(text[binaryShiftStart + i], 8);
+    }
+  }
+
+  @Override
+  public String toString() {
+    return "<" + binaryShiftStart + "::" + (binaryShiftStart + binaryShiftByteCount - 1) + '>';
+  }
+
+}

rubylib/src/main/java/com/google/zxing/aztec/encoder/Encoder.java

+/*
+ * 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;
+
+/**
+ * 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 binary content as an Aztec symbol
+   *
+   * @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);
+  }
+
+  /**
+   * 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
+   * @return Aztec symbol matrix with metadata
+   */
+  public static AztecCode encode(byte[] data, int minECCPercent, int userSpecifiedLayers) {
+    // High-level encode
+    BitArray bits = new HighLevelEncoder(data).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 (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;
+  }
+}

rubylib/src/main/java/com/google/zxing/aztec/encoder/HighLevelEncoder.java

+/*
+ * 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 java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * 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;
+
+  public HighLevelEncoder(byte[] text) {
+    this.text = text;
+  }
+
+  /**
+   * @return text represented by this encoder encoded as a {@link BitArray}
+   */
+  public BitArray encode() {
+    Collection<State> states = Collections.singletonList(State.INITIAL_STATE);
+    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) {
+    List<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.add(newState);
+      }
+    }
+    return result;
+  }
+
+}

rubylib/src/main/java/com/google/zxing/aztec/encoder/SimpleToken.java

+/*
+ * 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) + '>';
+  }
+
+}

rubylib/src/main/java/com/google/zxing/aztec/encoder/State.java

+/*
+ * 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.util.Deque;
+import java.util.LinkedList;
+
+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 State(Token token, int mode, int binaryBytes, int bitCount) {
+    this.token = token;
+    this.mode = mode;
+    this.binaryShiftByteCount = binaryBytes;
+    this.bitCount = bitCount;
+    // Make sure we match the token
+    //int binaryShiftBitCount = (binaryShiftByteCount * 8) +
+    //    (binaryShiftByteCount == 0 ? 0 :
+    //     binaryShiftByteCount <= 31 ? 10 :
+    //     binaryShiftByteCount <= 62 ? 20 : 21);
+    //assert this.bitCount == token.getTotalBitCount() + binaryShiftBitCount;
+  }
+
+  int getMode() {
+    return mode;
+  }
+
+  Token getToken() {
+    return token;
+  }
+
+  int getBinaryShiftByteCount() {
+    return binaryShiftByteCount;
+  }
+
+  int getBitCount() {
+    return bitCount;
+  }
+
+  // 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) {
+    //assert binaryShiftByteCount == 0;
+    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) {
+    //assert binaryShiftByteCount == 0 && this.mode != mode;
+    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) {
+      //assert binaryShiftByteCount == 0;
+      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);
+    //assert token.getTotalBitCount() == this.bitCount;
+    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 mySize = this.bitCount + (HighLevelEncoder.LATCH_TABLE[this.mode][other.mode] >> 16);
+    if (other.binaryShiftByteCount > 0 &&
+        (this.binaryShiftByteCount == 0 || this.binaryShiftByteCount > other.binaryShiftByteCount)) {
+      mySize += 10;     // Cost of entering Binary Shift mode.
+    }
+    return mySize <= other.bitCount;
+  }
+
+  BitArray toBitArray(byte[] text) {
+    // Reverse the tokens, so that they are in the order that they should
+    // be output
+    Deque<Token> symbols = new LinkedList<>();
+    for (Token token = endBinaryShift(text.length).token; token != null; token = token.getPrevious()) {
+      symbols.addFirst(token);
+    }
+    BitArray bitArray = new BitArray();
+    // Add each token to the result.
+    for (Token symbol : symbols) {
+      symbol.appendTo(bitArray, text);
+    }
+    //assert bitArray.getSize() == this.bitCount;
+    return bitArray;
+  }
+
+  @Override
+  public String toString() {
+    return String.format("%s bits=%d bytes=%d", HighLevelEncoder.MODE_NAMES[mode], bitCount, binaryShiftByteCount);
+  }
+
+}

rubylib/src/main/java/com/google/zxing/aztec/encoder/Token.java

+/*
+ * 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);
+
+}

rubylib/src/main/java/com/google/zxing/client/result/AbstractDoCoMoResultParser.java

+/*
+ * 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, boolean trim) {
+    return matchPrefixedField(prefix, rawText, ';', trim);
+  }
+
+  static String matchSingleDoCoMoPrefixedField(String prefix, String rawText, boolean trim) {
+    return matchSinglePrefixedField(prefix, rawText, ';', trim);
+  }
+
+}

rubylib/src/main/java/com/google/zxing/client/result/AddressBookAUResultParser.java

+/*
+ * 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", 3, rawText, true);
+    String[] emails = matchMultipleValuePrefix("MAIL", 3, rawText, true);
+    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,
+                                                   int max,
+                                                   String rawText,
+                                                   boolean trim) {
+    List<String> values = null;
+    for (int i = 1; i <= max; i++) {
+      String value = matchSinglePrefixedField(prefix + i + ':', rawText, '\r', trim);
+      if (value == null) {
+        break;
+      }
+      if (values == null) {
+        values = new ArrayList<>(max); // lazy init
+      }
+      values.add(value);
+    }
+    if (values == null) {
+      return null;
+    }
+    return values.toArray(new String[values.size()]);
+  }
+
+}

rubylib/src/main/java/com/google/zxing/client/result/AddressBookDoCoMoResultParser.java

+/*
+ * 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, true);
+    if (rawName == null) {
+      return null;
+    }
+    String name = parseName(rawName[0]);
+    String pronunciation = matchSingleDoCoMoPrefixedField("SOUND:", rawText, true);
+    String[] phoneNumbers = matchDoCoMoPrefixedField("TEL:", rawText, true);
+    String[] emails = matchDoCoMoPrefixedField("EMAIL:", rawText, true);
+    String note = matchSingleDoCoMoPrefixedField("NOTE:", rawText, false);
+    String[] addresses = matchDoCoMoPrefixedField("ADR:", rawText, true);
+    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, true);
+
+    // 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;
+  }
+
+}

rubylib/src/main/java/com/google/zxing/client/result/AddressBookParsedResult.java

+/*
+ * 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();
+  }
+
+}

rubylib/src/main/java/com/google/zxing/client/result/BookmarkDoCoMoResultParser.java

+/*
+ * 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, true);
+    if (rawUri == null) {
+      return null;
+    }
+    String uri = rawUri[0];
+    return URIResultParser.isBasicallyValidURI(uri) ? new URIParsedResult(uri, title) : null;
+  }
+
+}
\ No newline at end of file