zxing_cpp 0.1.0

data/ext/zxing/zxing-cpp/core/src/zxing/multi/qrcode/detector/MultiFinderPatternFinder.h

@@ -0,0 +1,47 @@
+#ifndef __MULTI_FINDER_PATTERN_FINDER_H__
+#define __MULTI_FINDER_PATTERN_FINDER_H__
+
+/*
+ *  Copyright 2011 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.
+ */
+
+#include <zxing/qrcode/detector/FinderPattern.h>
+#include <zxing/qrcode/detector/FinderPatternFinder.h>
+#include <zxing/qrcode/detector/FinderPatternInfo.h>
+
+namespace zxing {
+namespace multi {
+
+class MultiFinderPatternFinder : zxing::qrcode::FinderPatternFinder {
+  private:
+    std::vector<std::vector<Ref<zxing::qrcode::FinderPattern> > > selectBestPatterns();
+
+    static const float MAX_MODULE_COUNT_PER_EDGE;
+    static const float MIN_MODULE_COUNT_PER_EDGE;
+    static const float DIFF_MODSIZE_CUTOFF_PERCENT;
+    static const float DIFF_MODSIZE_CUTOFF;
+
+  public:
+    MultiFinderPatternFinder(Ref<BitMatrix> image, Ref<ResultPointCallback> resultPointCallback);
+    virtual ~MultiFinderPatternFinder();
+    virtual std::vector<Ref<zxing::qrcode::FinderPatternInfo> > findMulti(DecodeHints const& hints);
+
+
+};
+
+}
+}
+
+#endif // __MULTI_FINDER_PATTERN_FINDER_H__

data/ext/zxing/zxing-cpp/core/src/zxing/oned/CodaBarReader.cpp

@@ -0,0 +1,340 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * 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.
+ */
+
+#include <zxing/ZXing.h>
+#include <zxing/oned/CodaBarReader.h>
+#include <zxing/oned/OneDResultPoint.h>
+#include <zxing/common/Array.h>
+#include <zxing/ReaderException.h>
+#include <zxing/NotFoundException.h>
+#include <zxing/FormatException.h>
+#include <zxing/ChecksumException.h>
+#include <math.h>
+#include <sstream>
+
+using std::vector;
+using std::string;
+using zxing::NotFoundException;
+using zxing::FormatException;
+using zxing::ChecksumException;
+using zxing::Ref;
+using zxing::Result;
+using zxing::oned::CodaBarReader;
+
+// VC++
+using zxing::BitArray;
+
+namespace {
+  char const ALPHABET_STRING[] = "0123456789-$:/.+ABCD";
+  char const* const ALPHABET = ALPHABET_STRING;
+
+  /**
+   * These represent the encodings of characters, as patterns of wide and narrow bars. The 7 least-significant bits of
+   * each int correspond to the pattern of wide and narrow, with 1s representing "wide" and 0s representing narrow.
+   */
+  const int CHARACTER_ENCODINGS[] = {
+    0x003, 0x006, 0x009, 0x060, 0x012, 0x042, 0x021, 0x024, 0x030, 0x048, // 0-9
+    0x00c, 0x018, 0x045, 0x051, 0x054, 0x015, 0x01A, 0x029, 0x00B, 0x00E, // -$:/.+ABCD
+  };
+
+  // minimal number of characters that should be present (inclusing start and stop characters)
+  // under normal circumstances this should be set to 3, but can be set higher
+  // as a last-ditch attempt to reduce false positives.
+  const int MIN_CHARACTER_LENGTH = 3;
+
+  // official start and end patterns
+  const char STARTEND_ENCODING[] = {'A', 'B', 'C', 'D', 0};
+  // some codabar generator allow the codabar string to be closed by every
+  // character. This will cause lots of false positives!
+
+  // some industries use a checksum standard but this is not part of the original codabar standard
+  // for more information see : http://www.mecsw.com/specs/codabar.html
+}
+
+// These values are critical for determining how permissive the decoding
+// will be. All stripe sizes must be within the window these define, as
+// compared to the average stripe size.
+const int CodaBarReader::MAX_ACCEPTABLE =
+  (int) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 2.0f);
+const int CodaBarReader::PADDING = 
+  (int) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 1.5f);
+
+CodaBarReader::CodaBarReader() 
+  : counters(80, 0), counterLength(0) {}
+
+Ref<Result> CodaBarReader::decodeRow(int rowNumber, Ref<BitArray> row) {
+
+  { // Arrays.fill(counters, 0);
+    int size = counters.size();
+    counters.resize(0);
+    counters.resize(size); }
+
+  setCounters(row);
+  int startOffset = findStartPattern();
+  int nextStart = startOffset;
+
+  decodeRowResult.clear();
+  do {
+    int charOffset = toNarrowWidePattern(nextStart);
+    if (charOffset == -1) {
+      throw NotFoundException();
+    }
+    // Hack: We store the position in the alphabet table into a
+    // StringBuilder, so that we can access the decoded patterns in
+    // validatePattern. We'll translate to the actual characters later.
+    decodeRowResult.append(1, (char)charOffset);
+    nextStart += 8;
+    // Stop as soon as we see the end character.
+    if (decodeRowResult.length() > 1 &&
+        arrayContains(STARTEND_ENCODING, ALPHABET[charOffset])) {
+      break;
+    }
+  } while (nextStart < counterLength); // no fixed end pattern so keep on reading while data is available
+
+  // Look for whitespace after pattern:
+  int trailingWhitespace = counters[nextStart - 1];
+  int lastPatternSize = 0;
+  for (int i = -8; i < -1; i++) {
+    lastPatternSize += counters[nextStart + i];
+  }
+
+  // We need to see whitespace equal to 50% of the last pattern size,
+  // otherwise this is probably a false positive. The exception is if we are
+  // at the end of the row. (I.e. the barcode barely fits.)
+  if (nextStart < counterLength && trailingWhitespace < lastPatternSize / 2) {
+    throw NotFoundException();
+  }
+
+  validatePattern(startOffset);
+
+  // Translate character table offsets to actual characters.
+  for (int i = 0; i < (int)decodeRowResult.length(); i++) {
+    decodeRowResult[i] = ALPHABET[(int)decodeRowResult[i]];
+  }
+  // Ensure a valid start and end character
+  char startchar = decodeRowResult[0];
+  if (!arrayContains(STARTEND_ENCODING, startchar)) {
+    throw NotFoundException();
+  }
+  char endchar = decodeRowResult[decodeRowResult.length() - 1];
+  if (!arrayContains(STARTEND_ENCODING, endchar)) {
+    throw NotFoundException();
+  }
+
+  // remove stop/start characters character and check if a long enough string is contained
+  if ((int)decodeRowResult.length() <= MIN_CHARACTER_LENGTH) {
+    // Almost surely a false positive ( start + stop + at least 1 character)
+    throw NotFoundException();
+  }
+
+  decodeRowResult.erase(decodeRowResult.length() - 1, 1);
+  decodeRowResult.erase(0, 1);
+
+  int runningCount = 0;
+  for (int i = 0; i < startOffset; i++) {
+    runningCount += counters[i];
+  }
+  float left = (float) runningCount;
+  for (int i = startOffset; i < nextStart - 1; i++) {
+    runningCount += counters[i];
+  }
+  float right = (float) runningCount;
+
+  ArrayRef< Ref<ResultPoint> > resultPoints(2);
+  resultPoints[0] =
+    Ref<OneDResultPoint>(new OneDResultPoint(left, (float) rowNumber));
+  resultPoints[1] =
+    Ref<OneDResultPoint>(new OneDResultPoint(right, (float) rowNumber));
+
+  return Ref<Result>(new Result(Ref<String>(new String(decodeRowResult)),
+                                ArrayRef<char>(),
+                                resultPoints,
+                                BarcodeFormat::CODABAR));
+}
+
+void CodaBarReader::validatePattern(int start)  {
+  // First, sum up the total size of our four categories of stripe sizes;
+  vector<int> sizes (4, 0);
+  vector<int> counts (4, 0);
+  int end = decodeRowResult.length() - 1;
+
+  // We break out of this loop in the middle, in order to handle
+  // inter-character spaces properly.
+  int pos = start;
+  for (int i = 0; true; i++) {
+    int pattern = CHARACTER_ENCODINGS[(int)decodeRowResult[i]];
+    for (int j = 6; j >= 0; j--) {
+      // Even j = bars, while odd j = spaces. Categories 2 and 3 are for
+      // long stripes, while 0 and 1 are for short stripes.
+      int category = (j & 1) + (pattern & 1) * 2;
+      sizes[category] += counters[pos + j];
+      counts[category]++;
+      pattern >>= 1;
+    }
+    if (i >= end) {
+      break;
+    }
+    // We ignore the inter-character space - it could be of any size.
+    pos += 8;
+  }
+
+  // Calculate our allowable size thresholds using fixed-point math.
+  vector<int> maxes (4, 0);
+  vector<int> mins (4, 0);
+  // Define the threshold of acceptability to be the midpoint between the
+  // average small stripe and the average large stripe. No stripe lengths
+  // should be on the "wrong" side of that line.
+  for (int i = 0; i < 2; i++) {
+    mins[i] = 0;  // Accept arbitrarily small "short" stripes.
+    mins[i + 2] = ((sizes[i] << INTEGER_MATH_SHIFT) / counts[i] +
+                   (sizes[i + 2] << INTEGER_MATH_SHIFT) / counts[i + 2]) >> 1;
+    maxes[i] = mins[i + 2];
+    maxes[i + 2] = (sizes[i + 2] * MAX_ACCEPTABLE + PADDING) / counts[i + 2];
+  }
+
+  // Now verify that all of the stripes are within the thresholds.
+  pos = start;
+  for (int i = 0; true; i++) {
+    int pattern = CHARACTER_ENCODINGS[(int)decodeRowResult[i]];
+    for (int j = 6; j >= 0; j--) {
+      // Even j = bars, while odd j = spaces. Categories 2 and 3 are for
+      // long stripes, while 0 and 1 are for short stripes.
+      int category = (j & 1) + (pattern & 1) * 2;
+      int size = counters[pos + j] << INTEGER_MATH_SHIFT;
+      if (size < mins[category] || size > maxes[category]) {
+        throw NotFoundException();
+      }
+      pattern >>= 1;
+    }
+    if (i >= end) {
+      break;
+    }
+    pos += 8;
+  }
+}
+
+/**
+ * Records the size of all runs of white and black pixels, starting with white.
+ * This is just like recordPattern, except it records all the counters, and
+ * uses our builtin "counters" member for storage.
+ * @param row row to count from
+ */
+void CodaBarReader::setCounters(Ref<BitArray> row)  {
+  counterLength = 0;
+  // Start from the first white bit.
+  int i = row->getNextUnset(0);
+  int end = row->getSize();
+  if (i >= end) {
+    throw NotFoundException();
+  }
+  bool isWhite = true;
+  int count = 0;
+  for (; i < end; i++) {
+    if (row->get(i) ^ isWhite) { // that is, exactly one is true
+      count++;
+    } else {
+      counterAppend(count);
+      count = 1;
+      isWhite = !isWhite;
+    }
+  }
+  counterAppend(count);
+}
+
+void CodaBarReader::counterAppend(int e) {
+  if (counterLength < (int)counters.size()) {
+    counters[counterLength] = e;
+  } else {
+    counters.push_back(e);
+  }
+  counterLength++;
+}
+
+int CodaBarReader::findStartPattern() {
+  for (int i = 1; i < counterLength; i += 2) {
+    int charOffset = toNarrowWidePattern(i);
+    if (charOffset != -1 && arrayContains(STARTEND_ENCODING, ALPHABET[charOffset])) {
+      // Look for whitespace before start pattern, >= 50% of width of start pattern
+      // We make an exception if the whitespace is the first element.
+      int patternSize = 0;
+      for (int j = i; j < i + 7; j++) {
+        patternSize += counters[j];
+      }
+      if (i == 1 || counters[i-1] >= patternSize / 2) {
+        return i;
+      }
+    }
+  }
+  throw NotFoundException();
+}
+
+bool CodaBarReader::arrayContains(char const array[], char key) {
+  return strchr(array, key) != 0;
+}
+
+
+int CodaBarReader::toNarrowWidePattern(int position) {
+  int end = position + 7;
+  if (end >= counterLength) {
+    return -1;
+  }
+
+  vector<int>& theCounters = counters;
+
+  int maxBar = 0;
+  int minBar = std::numeric_limits<int>::max();
+  for (int j = position; j < end; j += 2) {
+    int currentCounter = theCounters[j];
+    if (currentCounter < minBar) {
+      minBar = currentCounter;
+    }
+    if (currentCounter > maxBar) {
+      maxBar = currentCounter;
+    }
+  }
+  int thresholdBar = (minBar + maxBar) / 2;
+
+  int maxSpace = 0;
+  int minSpace = std::numeric_limits<int>::max();
+  for (int j = position + 1; j < end; j += 2) {
+    int currentCounter = theCounters[j];
+    if (currentCounter < minSpace) {
+      minSpace = currentCounter;
+    }
+    if (currentCounter > maxSpace) {
+      maxSpace = currentCounter;
+    }
+  }
+  int thresholdSpace = (minSpace + maxSpace) / 2;
+
+  int bitmask = 1 << 7;
+  int pattern = 0;
+  for (int i = 0; i < 7; i++) {
+    int threshold = (i & 1) == 0 ? thresholdBar : thresholdSpace;
+    bitmask >>= 1;
+    if (theCounters[position + i] > threshold) {
+      pattern |= bitmask;
+    }
+  }
+
+  for (int i = 0; i < ZXING_ARRAY_LEN(CHARACTER_ENCODINGS); i++) {
+    if (CHARACTER_ENCODINGS[i] == pattern) {
+      return i;
+    }
+  }
+  return -1;
+}

data/ext/zxing/zxing-cpp/core/src/zxing/oned/CodaBarReader.h

@@ -0,0 +1,57 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __CODA_BAR_READER_H__
+#define __CODA_BAR_READER_H__
+/*
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * 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.
+ */
+
+#include <zxing/oned/OneDReader.h>
+#include <zxing/common/BitArray.h>
+#include <zxing/Result.h>
+
+namespace zxing {
+namespace oned {
+
+class CodaBarReader : public OneDReader {
+private:
+  static const int MAX_ACCEPTABLE;
+  static const int PADDING;
+
+  // Keep some instance variables to avoid reallocations
+  std::string decodeRowResult;
+  std::vector<int> counters;
+  int counterLength;
+
+public:
+  CodaBarReader();
+
+  Ref<Result> decodeRow(int rowNumber, Ref<BitArray> row);
+  
+  void validatePattern(int start);
+
+private:
+  void setCounters(Ref<BitArray> row);
+  void counterAppend(int e);
+  int findStartPattern();
+  
+  static bool arrayContains(char const array[], char key);
+
+  int toNarrowWidePattern(int position);
+};
+
+}
+}
+
+#endif

data/ext/zxing/zxing-cpp/core/src/zxing/oned/Code128Reader.cpp

@@ -0,0 +1,496 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * 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.
+ */
+
+#include <zxing/ZXing.h>
+#include <zxing/oned/Code128Reader.h>
+#include <zxing/oned/OneDResultPoint.h>
+#include <zxing/common/Array.h>
+#include <zxing/ReaderException.h>
+#include <zxing/NotFoundException.h>
+#include <zxing/FormatException.h>
+#include <zxing/ChecksumException.h>
+#include <math.h>
+#include <string.h>
+#include <sstream>
+
+using std::vector;
+using std::string;
+using zxing::NotFoundException;
+using zxing::FormatException;
+using zxing::ChecksumException;
+using zxing::Ref;
+using zxing::Result;
+using zxing::oned::Code128Reader;
+
+// VC++
+using zxing::BitArray;
+
+const int Code128Reader::MAX_AVG_VARIANCE = int(PATTERN_MATCH_RESULT_SCALE_FACTOR * 250/1000);
+const int Code128Reader::MAX_INDIVIDUAL_VARIANCE = int(PATTERN_MATCH_RESULT_SCALE_FACTOR * 700/1000);
+
+namespace {
+
+const int CODE_SHIFT = 98;
+	
+const int CODE_CODE_C = 99;
+const int CODE_CODE_B = 100;
+const int CODE_CODE_A = 101;
+	
+const int CODE_FNC_1 = 102;
+const int CODE_FNC_2 = 97;
+const int CODE_FNC_3 = 96;
+const int CODE_FNC_4_A = 101;
+const int CODE_FNC_4_B = 100;
+	
+const int CODE_START_A = 103;
+const int CODE_START_B = 104;
+const int CODE_START_C = 105;
+const int CODE_STOP = 106;
+			
+const int CODE_PATTERNS_LENGTH = 107;
+const int CODE_PATTERNS[CODE_PATTERNS_LENGTH][6] = {
+  {2, 1, 2, 2, 2, 2}, /* 0 */
+  {2, 2, 2, 1, 2, 2},
+  {2, 2, 2, 2, 2, 1},
+  {1, 2, 1, 2, 2, 3},
+  {1, 2, 1, 3, 2, 2},
+  {1, 3, 1, 2, 2, 2}, /* 5 */
+  {1, 2, 2, 2, 1, 3},
+  {1, 2, 2, 3, 1, 2},
+  {1, 3, 2, 2, 1, 2},
+  {2, 2, 1, 2, 1, 3},
+  {2, 2, 1, 3, 1, 2}, /* 10 */
+  {2, 3, 1, 2, 1, 2},
+  {1, 1, 2, 2, 3, 2},
+  {1, 2, 2, 1, 3, 2},
+  {1, 2, 2, 2, 3, 1},
+  {1, 1, 3, 2, 2, 2}, /* 15 */
+  {1, 2, 3, 1, 2, 2},
+  {1, 2, 3, 2, 2, 1},
+  {2, 2, 3, 2, 1, 1},
+  {2, 2, 1, 1, 3, 2},
+  {2, 2, 1, 2, 3, 1}, /* 20 */
+  {2, 1, 3, 2, 1, 2},
+  {2, 2, 3, 1, 1, 2},
+  {3, 1, 2, 1, 3, 1},
+  {3, 1, 1, 2, 2, 2},
+  {3, 2, 1, 1, 2, 2}, /* 25 */
+  {3, 2, 1, 2, 2, 1},
+  {3, 1, 2, 2, 1, 2},
+  {3, 2, 2, 1, 1, 2},
+  {3, 2, 2, 2, 1, 1},
+  {2, 1, 2, 1, 2, 3}, /* 30 */
+  {2, 1, 2, 3, 2, 1},
+  {2, 3, 2, 1, 2, 1},
+  {1, 1, 1, 3, 2, 3},
+  {1, 3, 1, 1, 2, 3},
+  {1, 3, 1, 3, 2, 1}, /* 35 */
+  {1, 1, 2, 3, 1, 3},
+  {1, 3, 2, 1, 1, 3},
+  {1, 3, 2, 3, 1, 1},
+  {2, 1, 1, 3, 1, 3},
+  {2, 3, 1, 1, 1, 3}, /* 40 */
+  {2, 3, 1, 3, 1, 1},
+  {1, 1, 2, 1, 3, 3},
+  {1, 1, 2, 3, 3, 1},
+  {1, 3, 2, 1, 3, 1},
+  {1, 1, 3, 1, 2, 3}, /* 45 */
+  {1, 1, 3, 3, 2, 1},
+  {1, 3, 3, 1, 2, 1},
+  {3, 1, 3, 1, 2, 1},
+  {2, 1, 1, 3, 3, 1},
+  {2, 3, 1, 1, 3, 1}, /* 50 */
+  {2, 1, 3, 1, 1, 3},
+  {2, 1, 3, 3, 1, 1},
+  {2, 1, 3, 1, 3, 1},
+  {3, 1, 1, 1, 2, 3},
+  {3, 1, 1, 3, 2, 1}, /* 55 */
+  {3, 3, 1, 1, 2, 1},
+  {3, 1, 2, 1, 1, 3},
+  {3, 1, 2, 3, 1, 1},
+  {3, 3, 2, 1, 1, 1},
+  {3, 1, 4, 1, 1, 1}, /* 60 */
+  {2, 2, 1, 4, 1, 1},
+  {4, 3, 1, 1, 1, 1},
+  {1, 1, 1, 2, 2, 4},
+  {1, 1, 1, 4, 2, 2},
+  {1, 2, 1, 1, 2, 4}, /* 65 */
+  {1, 2, 1, 4, 2, 1},
+  {1, 4, 1, 1, 2, 2},
+  {1, 4, 1, 2, 2, 1},
+  {1, 1, 2, 2, 1, 4},
+  {1, 1, 2, 4, 1, 2}, /* 70 */
+  {1, 2, 2, 1, 1, 4},
+  {1, 2, 2, 4, 1, 1},
+  {1, 4, 2, 1, 1, 2},
+  {1, 4, 2, 2, 1, 1},
+  {2, 4, 1, 2, 1, 1}, /* 75 */
+  {2, 2, 1, 1, 1, 4},
+  {4, 1, 3, 1, 1, 1},
+  {2, 4, 1, 1, 1, 2},
+  {1, 3, 4, 1, 1, 1},
+  {1, 1, 1, 2, 4, 2}, /* 80 */
+  {1, 2, 1, 1, 4, 2},
+  {1, 2, 1, 2, 4, 1},
+  {1, 1, 4, 2, 1, 2},
+  {1, 2, 4, 1, 1, 2},
+  {1, 2, 4, 2, 1, 1}, /* 85 */
+  {4, 1, 1, 2, 1, 2},
+  {4, 2, 1, 1, 1, 2},
+  {4, 2, 1, 2, 1, 1},
+  {2, 1, 2, 1, 4, 1},
+  {2, 1, 4, 1, 2, 1}, /* 90 */
+  {4, 1, 2, 1, 2, 1},
+  {1, 1, 1, 1, 4, 3},
+  {1, 1, 1, 3, 4, 1},
+  {1, 3, 1, 1, 4, 1},
+  {1, 1, 4, 1, 1, 3}, /* 95 */
+  {1, 1, 4, 3, 1, 1},
+  {4, 1, 1, 1, 1, 3},
+  {4, 1, 1, 3, 1, 1},
+  {1, 1, 3, 1, 4, 1},
+  {1, 1, 4, 1, 3, 1}, /* 100 */
+  {3, 1, 1, 1, 4, 1},
+  {4, 1, 1, 1, 3, 1},
+  {2, 1, 1, 4, 1, 2},
+  {2, 1, 1, 2, 1, 4},
+  {2, 1, 1, 2, 3, 2}, /* 105 */
+  {2, 3, 3, 1, 1, 1}
+};
+
+}
+
+Code128Reader::Code128Reader(){}
+
+vector<int> Code128Reader::findStartPattern(Ref<BitArray> row){
+  int width = row->getSize();
+  int rowOffset = row->getNextSet(0);
+
+  int counterPosition = 0;
+  vector<int> counters (6, 0);
+  int patternStart = rowOffset;
+  bool isWhite = false;
+  int patternLength =  counters.size();
+
+  for (int i = rowOffset; i < width; i++) {
+    if (row->get(i) ^ isWhite) {
+      counters[counterPosition]++;
+    } else {
+      if (counterPosition == patternLength - 1) {
+        int bestVariance = MAX_AVG_VARIANCE;
+        int bestMatch = -1;
+        for (int startCode = CODE_START_A; startCode <= CODE_START_C; startCode++) {
+          int variance = patternMatchVariance(counters, CODE_PATTERNS[startCode], MAX_INDIVIDUAL_VARIANCE);
+          if (variance < bestVariance) {
+            bestVariance = variance;
+            bestMatch = startCode;
+          }
+        }
+        // Look for whitespace before start pattern, >= 50% of width of start pattern
+        if (bestMatch >= 0 &&
+            row->isRange(std::max(0, patternStart - (i - patternStart) / 2), patternStart, false)) {
+          vector<int> resultValue (3, 0);
+          resultValue[0] = patternStart;
+          resultValue[1] = i;
+          resultValue[2] = bestMatch;
+          return resultValue;
+        }
+        patternStart += counters[0] + counters[1];
+        for (int y = 2; y < patternLength; y++) {
+          counters[y - 2] = counters[y];
+        }
+        counters[patternLength - 2] = 0;
+        counters[patternLength - 1] = 0;
+        counterPosition--;
+      } else {
+        counterPosition++;
+      }
+      counters[counterPosition] = 1;
+      isWhite = !isWhite;
+    }
+  }
+  throw NotFoundException();
+}
+
+int Code128Reader::decodeCode(Ref<BitArray> row, vector<int>& counters, int rowOffset) {
+  recordPattern(row, rowOffset, counters);
+  int bestVariance = MAX_AVG_VARIANCE; // worst variance we'll accept
+  int bestMatch = -1;
+  for (int d = 0; d < CODE_PATTERNS_LENGTH; d++) {
+    int const* const pattern = CODE_PATTERNS[d];
+    int variance = patternMatchVariance(counters, pattern, MAX_INDIVIDUAL_VARIANCE);
+    if (variance < bestVariance) {
+      bestVariance = variance;
+      bestMatch = d;
+    }
+  }
+  // TODO We're overlooking the fact that the STOP pattern has 7 values, not 6.
+  if (bestMatch >= 0) {
+    return bestMatch;
+  } else {
+    throw NotFoundException();
+  }
+}
+
+Ref<Result> Code128Reader::decodeRow(int rowNumber, Ref<BitArray> row) {
+  // boolean convertFNC1 = hints != null && hints.containsKey(DecodeHintType.ASSUME_GS1);
+  boolean convertFNC1 = false;
+  vector<int> startPatternInfo (findStartPattern(row));
+  int startCode = startPatternInfo[2];
+  int codeSet;
+  switch (startCode) {
+    case CODE_START_A:
+      codeSet = CODE_CODE_A;
+      break;
+    case CODE_START_B:
+      codeSet = CODE_CODE_B;
+      break;
+    case CODE_START_C:
+      codeSet = CODE_CODE_C;
+      break;
+    default:
+      throw FormatException();
+  }
+
+  bool done = false;
+  bool isNextShifted = false;
+
+  string result;
+  vector<char> rawCodes(20, 0);
+
+  int lastStart = startPatternInfo[0];
+  int nextStart = startPatternInfo[1];
+  vector<int> counters (6, 0);
+
+  int lastCode = 0;
+  int code = 0;
+  int checksumTotal = startCode;
+  int multiplier = 0;
+  bool lastCharacterWasPrintable = true;
+
+  std::ostringstream oss;
+
+  while (!done) {
+
+    bool unshift = isNextShifted;
+    isNextShifted = false;
+
+    // Save off last code
+    lastCode = code;
+
+    code = decodeCode(row, counters, nextStart);
+
+    // Remember whether the last code was printable or not (excluding CODE_STOP)
+    if (code != CODE_STOP) {
+      lastCharacterWasPrintable = true;
+    }
+
+    // Add to checksum computation (if not CODE_STOP of course)
+    if (code != CODE_STOP) {
+      multiplier++;
+      checksumTotal += multiplier * code;
+    }
+
+    // Advance to where the next code will to start
+    lastStart = nextStart;
+    for (int i = 0, e = counters.size(); i < e; i++) {
+      nextStart += counters[i];
+    }
+
+    // Take care of illegal start codes
+    switch (code) {
+      case CODE_START_A:
+      case CODE_START_B:
+      case CODE_START_C:
+        throw FormatException();
+    }
+
+    switch (codeSet) {
+
+      case CODE_CODE_A:
+        if (code < 64) {
+          result.append(1, (char) (' ' + code));
+        } else if (code < 96) {
+          result.append(1, (char) (code - 64));
+        } else {
+          // Don't let CODE_STOP, which always appears, affect whether whether we think the
+          // last code was printable or not.
+          if (code != CODE_STOP) {
+            lastCharacterWasPrintable = false;
+          }
+          switch (code) {
+            case CODE_FNC_1:
+              if (convertFNC1) {
+                if (result.length() == 0){
+                  // GS1 specification 5.4.3.7. and 5.4.6.4. If the first char after the start code
+                  // is FNC1 then this is GS1-128. We add the symbology identifier.
+                  result.append("]C1");
+                } else {
+                  // GS1 specification 5.4.7.5. Every subsequent FNC1 is returned as ASCII 29 (GS)
+                  result.append(1, (char) 29);
+                }
+              }
+              break;
+            case CODE_FNC_2:
+            case CODE_FNC_3:
+            case CODE_FNC_4_A:
+              // do nothing?
+              break;
+            case CODE_SHIFT:
+              isNextShifted = true;
+              codeSet = CODE_CODE_B;
+              break;
+            case CODE_CODE_B:
+              codeSet = CODE_CODE_B;
+              break;
+            case CODE_CODE_C:
+              codeSet = CODE_CODE_C;
+              break;
+            case CODE_STOP:
+              done = true;
+              break;
+          }
+        }
+        break;
+      case CODE_CODE_B:
+        if (code < 96) {
+          result.append(1, (char) (' ' + code));
+        } else {
+          if (code != CODE_STOP) {
+            lastCharacterWasPrintable = false;
+          }
+          switch (code) {
+            case CODE_FNC_1:
+            case CODE_FNC_2:
+            case CODE_FNC_3:
+            case CODE_FNC_4_B:
+              // do nothing?
+              break;
+            case CODE_SHIFT:
+              isNextShifted = true;
+              codeSet = CODE_CODE_A;
+              break;
+            case CODE_CODE_A:
+              codeSet = CODE_CODE_A;
+              break;
+            case CODE_CODE_C:
+              codeSet = CODE_CODE_C;
+              break;
+            case CODE_STOP:
+              done = true;
+              break;
+          }
+        }
+        break;
+      case CODE_CODE_C:
+        if (code < 100) {
+          if (code < 10) {
+            result.append(1, '0');
+          }
+          oss.clear();
+          oss.str("");
+          oss << code;
+          result.append(oss.str());
+        } else {
+          if (code != CODE_STOP) {
+            lastCharacterWasPrintable = false;
+          }
+          switch (code) {
+            case CODE_FNC_1:
+              // do nothing?
+              break;
+            case CODE_CODE_A:
+              codeSet = CODE_CODE_A;
+              break;
+            case CODE_CODE_B:
+              codeSet = CODE_CODE_B;
+              break;
+            case CODE_STOP:
+              done = true;
+              break;
+          }
+        }
+        break;
+    }
+
+    // Unshift back to another code set if we were shifted
+    if (unshift) {
+      codeSet = codeSet == CODE_CODE_A ? CODE_CODE_B : CODE_CODE_A;
+    }
+    
+  }
+
+  int lastPatternSize = nextStart - lastStart;
+
+  // Check for ample whitespace following pattern, but, to do this we first need to remember that
+  // we fudged decoding CODE_STOP since it actually has 7 bars, not 6. There is a black bar left
+  // to read off. Would be slightly better to properly read. Here we just skip it:
+  nextStart = row->getNextUnset(nextStart);
+  if (!row->isRange(nextStart,
+                    std::min(row->getSize(), nextStart + (nextStart - lastStart) / 2),
+                    false)) {
+    throw NotFoundException();
+  }
+
+  // Pull out from sum the value of the penultimate check code
+  checksumTotal -= multiplier * lastCode;
+  // lastCode is the checksum then:
+  if (checksumTotal % 103 != lastCode) {
+    throw ChecksumException();
+  }
+
+  // Need to pull out the check digits from string
+  int resultLength = result.length();
+  if (resultLength == 0) {
+    // false positive
+    throw NotFoundException();
+  }
+
+  // Only bother if the result had at least one character, and if the checksum digit happened to
+  // be a printable character. If it was just interpreted as a control code, nothing to remove.
+  if (resultLength > 0 && lastCharacterWasPrintable) {
+    if (codeSet == CODE_CODE_C) {
+      result.erase(resultLength - 2, resultLength);
+    } else {
+      result.erase(resultLength - 1, resultLength);
+    }
+  }
+
+  float left = (float) (startPatternInfo[1] + startPatternInfo[0]) / 2.0f;
+  float right = lastStart + lastPatternSize / 2.0f;
+
+  int rawCodesSize = rawCodes.size();
+  ArrayRef<char> rawBytes (rawCodesSize);
+  for (int i = 0; i < rawCodesSize; i++) {
+    rawBytes[i] = rawCodes[i];
+  }
+
+  ArrayRef< Ref<ResultPoint> > resultPoints(2);
+  resultPoints[0] =
+      Ref<OneDResultPoint>(new OneDResultPoint(left, (float) rowNumber));
+  resultPoints[1] =
+      Ref<OneDResultPoint>(new OneDResultPoint(right, (float) rowNumber));
+
+  return Ref<Result>(new Result(Ref<String>(new String(result)), rawBytes, resultPoints,
+                                BarcodeFormat::CODE_128));
+}
+
+Code128Reader::~Code128Reader(){}
+
+zxing::BarcodeFormat Code128Reader::getBarcodeFormat(){
+  return BarcodeFormat::CODE_128;
+}