Merge pull request #179 from dschuermann/key-details

Key details

1 files changed, 0 insertions, 194 deletions

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