qrscanner 0.1

data/ext/qrscanner/zxing/core/src/zxing/common/reedsolomon/GF256.h

@@ -0,0 +1,68 @@
+#ifndef __GF256_H__
+#define __GF256_H__
+
+/*
+ *  GF256.h
+ *  zxing
+ *
+ *  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 <memory>
+#include <vector>
+#include <zxing/common/Counted.h>
+
+namespace zxing {
+class GF256Poly;
+
+class GF256 {
+  /**
+   * <p>This class contains utility methods for performing mathematical
+   * operations over the Galois Field GF(256). Operations use a given
+   * primitive polynomial in calculations.</p>
+   *
+   * <p>Throughout this package, elements of GF(256) are represented as an
+   * <code>int</code> for convenience and speed (but at the cost of memory).
+   * Only the bottom 8 bits are really used.</p>
+   *
+   * @author srowen@google.com (Sean Owen)
+   * @author christian.brunschen@gmail.com (Christian Brunschen)
+   */
+private:
+  std::vector<int> exp_;
+  std::vector<int> log_;
+  Ref<GF256Poly> zero_;
+  Ref<GF256Poly> one_;
+
+  GF256(int primitive);
+
+public:
+  Ref<GF256Poly> getZero();
+  Ref<GF256Poly> getOne();
+  Ref<GF256Poly> buildMonomial(int degree, int coefficient);
+  static int addOrSubtract(int a, int b);
+  int exp(int a);
+  int log(int a);
+  int inverse(int a);
+  int multiply(int a, int b);
+
+  static GF256 QR_CODE_FIELD;
+  static GF256 DATA_MATRIX_FIELD;
+
+  friend std::ostream& operator<<(std::ostream& out, const GF256& field);
+};
+}
+
+#endif // __GF256_H__

data/ext/qrscanner/zxing/core/src/zxing/common/reedsolomon/GF256Poly.cpp

@@ -0,0 +1,198 @@
+/*
+ *  GF256Poly.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 05/05/2008.
+ *  Copyright 2008 Google UK. 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 <iostream>
+#include <sstream>
+#include <zxing/common/reedsolomon/GF256Poly.h>
+#include <zxing/common/reedsolomon/GF256.h>
+#include <zxing/common/IllegalArgumentException.h>
+
+namespace zxing {
+using namespace std;
+
+void GF256Poly::fixCoefficients() {
+  int coefficientsLength = coefficients.size();
+  if (coefficientsLength > 1 && coefficients[0] == 0) {
+    // Leading term must be non-zero for anything except
+    // the constant polynomial "0"
+    int firstNonZero = 1;
+    while (firstNonZero < coefficientsLength && coefficients[firstNonZero] == 0) {
+      firstNonZero++;
+    }
+    if (firstNonZero == coefficientsLength) {
+      coefficientsLength = field.getZero()->coefficients.size();
+      coefficients.reset(new Array<int> (coefficientsLength));
+      *coefficients = *(field.getZero()->coefficients);
+    } else {
+      ArrayRef<int> c(coefficients);
+      coefficientsLength -= firstNonZero;
+      coefficients.reset(new Array<int> (coefficientsLength));
+      for (int i = 0; i < coefficientsLength; i++) {
+        coefficients[i] = c[i + firstNonZero];
+      }
+    }
+  }
+}
+
+GF256Poly::GF256Poly(GF256 &f, ArrayRef<int> c) :
+    Counted(), field(f), coefficients(c) {
+  fixCoefficients();
+}
+
+GF256Poly::~GF256Poly() {
+
+}
+
+int GF256Poly::getDegree() {
+  return coefficients.size() - 1;
+}
+
+bool GF256Poly::isZero() {
+  return coefficients[0] == 0;
+}
+
+int GF256Poly::getCoefficient(int degree) {
+  return coefficients[coefficients.size() - 1 - degree];
+}
+
+int GF256Poly::evaluateAt(int a) {
+  if (a == 0) {
+    return getCoefficient(0);
+  }
+  int size = coefficients.size();
+  if (a == 1) {
+    // Just the sum of the coefficients
+    int result = 0;
+    for (int i = 0; i < size; i++) {
+      result = GF256::addOrSubtract(result, coefficients[i]);
+    }
+    return result;
+  }
+  int result = coefficients[0];
+  for (int i = 1; i < size; i++) {
+    result = GF256::addOrSubtract(field.multiply(a, result), coefficients[i]);
+  }
+  return result;
+}
+
+Ref<GF256Poly> GF256Poly::addOrSubtract(Ref<GF256Poly> b) {
+  if (&field != &b->field) {
+    throw IllegalArgumentException("Fields must be the same");
+  }
+  if (isZero()) {
+    return b;
+  }
+  if (b->isZero()) {
+    return Ref<GF256Poly>(this);
+  }
+
+  ArrayRef<int> largerCoefficients = coefficients;
+  ArrayRef<int> smallerCoefficients = b->coefficients;
+  if (smallerCoefficients.size() > largerCoefficients.size()) {
+    ArrayRef<int> tmp(smallerCoefficients);
+    smallerCoefficients = largerCoefficients;
+    largerCoefficients = tmp;
+  }
+
+  ArrayRef<int> sumDiff(new Array<int> (largerCoefficients.size()));
+
+  unsigned lengthDiff = largerCoefficients.size() - smallerCoefficients.size();
+  for (unsigned i = 0; i < lengthDiff; i++) {
+    sumDiff[i] = largerCoefficients[i];
+  }
+  for (unsigned i = lengthDiff; i < largerCoefficients.size(); i++) {
+    sumDiff[i] = GF256::addOrSubtract(smallerCoefficients[i - lengthDiff], largerCoefficients[i]);
+  }
+  return Ref<GF256Poly>(new GF256Poly(field, sumDiff));
+}
+
+Ref<GF256Poly> GF256Poly::multiply(Ref<GF256Poly> b) {
+  if (&field != &b->field) {
+    throw IllegalArgumentException("Fields must be the same");
+  }
+  if (isZero() || b->isZero()) {
+    return field.getZero();
+  }
+  ArrayRef<int> aCoefficients = coefficients;
+  int aLength = aCoefficients.size();
+  ArrayRef<int> bCoefficients = b->coefficients;
+  int bLength = bCoefficients.size();
+  int productLength = aLength + bLength - 1;
+  ArrayRef<int> product(new Array<int> (productLength));
+  for (int i = 0; i < aLength; i++) {
+    int aCoeff = aCoefficients[i];
+    for (int j = 0; j < bLength; j++) {
+      product[i + j] = GF256::addOrSubtract(product[i + j], field.multiply(aCoeff, bCoefficients[j]));
+    }
+  }
+
+  return Ref<GF256Poly>(new GF256Poly(field, product));
+}
+
+Ref<GF256Poly> GF256Poly::multiply(int scalar) {
+  if (scalar == 0) {
+    return field.getZero();
+  }
+  if (scalar == 1) {
+    return Ref<GF256Poly>(this);
+  }
+  int size = coefficients.size();
+  ArrayRef<int> product(new Array<int> (size));
+  for (int i = 0; i < size; i++) {
+    product[i] = field.multiply(coefficients[i], scalar);
+  }
+  return Ref<GF256Poly>(new GF256Poly(field, product));
+}
+
+Ref<GF256Poly> GF256Poly::multiplyByMonomial(int degree, int coefficient) {
+  if (degree < 0) {
+    throw IllegalArgumentException("Degree must be non-negative");
+  }
+  if (coefficient == 0) {
+    return field.getZero();
+  }
+  int size = coefficients.size();
+  ArrayRef<int> product(new Array<int> (size + degree));
+  for (int i = 0; i < size; i++) {
+    product[i] = field.multiply(coefficients[i], coefficient);
+  }
+  return Ref<GF256Poly>(new GF256Poly(field, product));
+}
+
+const char *GF256Poly::description() const {
+  ostringstream result;
+  result << *this;
+  return result.str().c_str();
+}
+
+ostream& operator<<(ostream& out, const GF256Poly& p) {
+  GF256Poly &poly = const_cast<GF256Poly&>(p);
+  out << "Poly[" << poly.coefficients.size() << "]";
+  if (poly.coefficients.size() > 0) {
+    out << "(" << poly.coefficients[0];
+    for (unsigned i = 1; i < poly.coefficients.size(); i++) {
+      out << "," << poly.coefficients[i];
+    }
+    out << ")";
+  }
+  return out;
+}
+
+}

data/ext/qrscanner/zxing/core/src/zxing/common/reedsolomon/GF256Poly.h

@@ -0,0 +1,53 @@
+#ifndef __GF256_POLY_H__
+#define __GF256_POLY_H__
+
+/*
+ *  GF256Poly.h
+ *  zxing
+ *
+ *  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 <memory>
+#include <zxing/common/Counted.h>
+#include <zxing/common/Array.h>
+
+namespace zxing {
+class GF256;
+
+class GF256Poly : public Counted {
+private:
+  GF256 &field;
+  ArrayRef<int> coefficients;
+  void fixCoefficients();
+public:
+  GF256Poly(GF256 &field, ArrayRef<int> c);
+  ~GF256Poly();
+
+  int getDegree();
+  bool isZero();
+  int getCoefficient(int degree);
+  int evaluateAt(int a);
+  Ref<GF256Poly> addOrSubtract(Ref<GF256Poly> other);
+  Ref<GF256Poly> multiply(Ref<GF256Poly> other);
+  Ref<GF256Poly> multiply(int scalar);
+  Ref<GF256Poly> multiplyByMonomial(int degree, int coefficient);
+  const char *description() const;
+  friend std::ostream& operator<<(std::ostream& out, const GF256Poly& poly);
+
+};
+}
+
+#endif // __GF256_POLY_H__

data/ext/qrscanner/zxing/core/src/zxing/common/reedsolomon/ReedSolomonDecoder.cpp

@@ -0,0 +1,193 @@
+/*
+ *  ReedSolomonDecoder.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 05/05/2008.
+ *  Copyright 2008 Google UK. 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 <iostream>
+
+#include <memory>
+#include <zxing/common/reedsolomon/ReedSolomonDecoder.h>
+#include <zxing/common/reedsolomon/GF256.h>
+#include <zxing/common/reedsolomon/GF256Poly.h>
+#include <zxing/common/reedsolomon/ReedSolomonException.h>
+#include <zxing/common/IllegalArgumentException.h>
+
+using namespace std;
+
+namespace zxing {
+
+ReedSolomonDecoder::ReedSolomonDecoder(GF256 &fld) :
+    field(fld) {
+}
+
+ReedSolomonDecoder::~ReedSolomonDecoder() {
+}
+
+void ReedSolomonDecoder::decode(ArrayRef<int> received, int twoS) {
+
+  Ref<GF256Poly> poly(new GF256Poly(field, received));
+
+
+#ifdef DEBUG
+  cout << "decoding with poly " << *poly << "\n";
+#endif
+
+  ArrayRef<int> syndromeCoefficients(new Array<int> (twoS));
+
+
+#ifdef DEBUG
+  cout << "syndromeCoefficients array = " <<
+       syndromeCoefficients.array_ << "\n";
+#endif
+
+  bool noError = true;
+  for (int i = 0; i < twoS; i++) {
+    int eval = poly->evaluateAt(field.exp(i));
+    syndromeCoefficients[syndromeCoefficients->size() - 1 - i] = eval;
+    if (eval != 0) {
+      noError = false;
+    }
+  }
+  if (noError) {
+    return;
+  }
+
+  Ref<GF256Poly> syndrome(new GF256Poly(field, syndromeCoefficients));
+  Ref<GF256Poly> monomial(field.buildMonomial(twoS, 1));
+  vector<Ref<GF256Poly> > sigmaOmega(runEuclideanAlgorithm(monomial, syndrome, twoS));
+  ArrayRef<int> errorLocations = findErrorLocations(sigmaOmega[0]);
+  ArrayRef<int> errorMagitudes = findErrorMagnitudes(sigmaOmega[1], errorLocations);
+  for (unsigned i = 0; i < errorLocations->size(); i++) {
+    int position = received->size() - 1 - field.log(errorLocations[i]);
+    //TODO: check why the position would be invalid
+    if (position < 0 || (size_t)position >= received.size())
+      throw IllegalArgumentException("Invalid position (ReedSolomonDecoder)");
+    received[position] = GF256::addOrSubtract(received[position], errorMagitudes[i]);
+  }
+}
+
+vector<Ref<GF256Poly> > ReedSolomonDecoder::runEuclideanAlgorithm(Ref<GF256Poly> a, Ref<GF256Poly> b, int R) {
+  // Assume a's degree is >= b's
+  if (a->getDegree() < b->getDegree()) {
+    Ref<GF256Poly> tmp = a;
+    a = b;
+    b = tmp;
+  }
+
+  Ref<GF256Poly> rLast(a);
+  Ref<GF256Poly> r(b);
+  Ref<GF256Poly> sLast(field.getOne());
+  Ref<GF256Poly> s(field.getZero());
+  Ref<GF256Poly> tLast(field.getZero());
+  Ref<GF256Poly> t(field.getOne());
+
+
+  // Run Euclidean algorithm until r's degree is less than R/2
+  while (r->getDegree() >= R / 2) {
+    Ref<GF256Poly> rLastLast(rLast);
+    Ref<GF256Poly> sLastLast(sLast);
+    Ref<GF256Poly> tLastLast(tLast);
+    rLast = r;
+    sLast = s;
+    tLast = t;
+
+
+    // Divide rLastLast by rLast, with quotient q and remainder r
+    if (rLast->isZero()) {
+      // Oops, Euclidean algorithm already terminated?
+      throw ReedSolomonException("r_{i-1} was zero");
+    }
+    r = rLastLast;
+    Ref<GF256Poly> q(field.getZero());
+    int denominatorLeadingTerm = rLast->getCoefficient(rLast->getDegree());
+    int dltInverse = field.inverse(denominatorLeadingTerm);
+    while (r->getDegree() >= rLast->getDegree() && !r->isZero()) {
+      int degreeDiff = r->getDegree() - rLast->getDegree();
+      int scale = field.multiply(r->getCoefficient(r->getDegree()), dltInverse);
+      q = q->addOrSubtract(field.buildMonomial(degreeDiff, scale));
+      r = r->addOrSubtract(rLast->multiplyByMonomial(degreeDiff, scale));
+    }
+
+    s = q->multiply(sLast)->addOrSubtract(sLastLast);
+    t = q->multiply(tLast)->addOrSubtract(tLastLast);
+  }
+
+  int sigmaTildeAtZero = t->getCoefficient(0);
+  if (sigmaTildeAtZero == 0) {
+    throw ReedSolomonException("sigmaTilde(0) was zero");
+  }
+
+  int inverse = field.inverse(sigmaTildeAtZero);
+  Ref<GF256Poly> sigma(t->multiply(inverse));
+  Ref<GF256Poly> omega(r->multiply(inverse));
+
+
+#ifdef DEBUG
+  cout << "t = " << *t << "\n";
+  cout << "r = " << *r << "\n";
+  cout << "sigma = " << *sigma << "\n";
+  cout << "omega = " << *omega << "\n";
+#endif
+
+  vector<Ref<GF256Poly> > result(2);
+  result[0] = sigma;
+  result[1] = omega;
+  return result;
+}
+
+ArrayRef<int> ReedSolomonDecoder::findErrorLocations(Ref<GF256Poly> errorLocator) {
+  // This is a direct application of Chien's search
+  int numErrors = errorLocator->getDegree();
+  if (numErrors == 1) { // shortcut
+    ArrayRef<int> result(1);
+    result[0] = errorLocator->getCoefficient(1);
+    return result;
+  }
+  ArrayRef<int> result(numErrors);
+  int e = 0;
+  for (int i = 1; i < 256 && e < numErrors; i++) {
+    // cout << "errorLocator(" << i << ") == " << errorLocator->evaluateAt(i) << "\n";
+    if (errorLocator->evaluateAt(i) == 0) {
+      result[e] = field.inverse(i);
+      e++;
+    }
+  }
+  if (e != numErrors) {
+    throw ReedSolomonException("Error locator degree does not match number of roots");
+  }
+  return result;
+}
+
+ArrayRef<int> ReedSolomonDecoder::findErrorMagnitudes(Ref<GF256Poly> errorEvaluator, ArrayRef<int> errorLocations) {
+  // This is directly applying Forney's Formula
+  int s = errorLocations.size();
+  ArrayRef<int> result(s);
+  for (int i = 0; i < s; i++) {
+    int xiInverse = field.inverse(errorLocations[i]);
+    int denominator = 1;
+    for (int j = 0; j < s; j++) {
+      if (i != j) {
+        denominator = field.multiply(denominator, GF256::addOrSubtract(1, field.multiply(errorLocations[j],
+                                     xiInverse)));
+      }
+    }
+    result[i] = field.multiply(errorEvaluator->evaluateAt(xiInverse), field.inverse(denominator));
+  }
+  return result;
+}
+}