| // Copyright 2014 PDFium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com |
| // Original code is licensed as follows: |
| /* |
| * 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. |
| */ |
| |
| #include "xfa/fxbarcode/pdf417/BC_PDF417Common.h" |
| #include "xfa/fxbarcode/pdf417/BC_PDF417ECErrorCorrection.h" |
| #include "xfa/fxbarcode/pdf417/BC_PDF417ECModulusGF.h" |
| #include "xfa/fxbarcode/pdf417/BC_PDF417ECModulusPoly.h" |
| #include "xfa/fxbarcode/utils.h" |
| |
| CBC_PDF417ECModulusGF* CBC_PDF417ECErrorCorrection::m_field = nullptr; |
| |
| void CBC_PDF417ECErrorCorrection::Initialize(int32_t& e) { |
| m_field = |
| new CBC_PDF417ECModulusGF(CBC_PDF417Common::NUMBER_OF_CODEWORDS, 3, e); |
| } |
| void CBC_PDF417ECErrorCorrection::Finalize() { |
| delete m_field; |
| } |
| CBC_PDF417ECErrorCorrection::CBC_PDF417ECErrorCorrection() {} |
| CBC_PDF417ECErrorCorrection::~CBC_PDF417ECErrorCorrection() {} |
| int32_t CBC_PDF417ECErrorCorrection::decode(CFX_Int32Array& received, |
| int32_t numECCodewords, |
| CFX_Int32Array& erasures, |
| int32_t& e) { |
| CBC_PDF417ECModulusPoly poly(m_field, received, e); |
| BC_EXCEPTION_CHECK_ReturnValue(e, -1); |
| CFX_Int32Array S; |
| S.SetSize(numECCodewords); |
| FX_BOOL error = FALSE; |
| for (int32_t l = numECCodewords; l > 0; l--) { |
| int32_t eval = poly.evaluateAt(m_field->exp(l)); |
| S[numECCodewords - l] = eval; |
| if (eval != 0) { |
| error = TRUE; |
| } |
| } |
| if (!error) { |
| return 0; |
| } |
| CBC_PDF417ECModulusPoly* syndrome = |
| new CBC_PDF417ECModulusPoly(m_field, S, e); |
| BC_EXCEPTION_CHECK_ReturnValue(e, -1); |
| CBC_PDF417ECModulusPoly* buildmonomial = |
| m_field->buildMonomial(numECCodewords, 1, e); |
| if (e != BCExceptionNO) { |
| delete syndrome; |
| return -1; |
| } |
| CFX_ArrayTemplate<CBC_PDF417ECModulusPoly*>* sigmaOmega = |
| runEuclideanAlgorithm(buildmonomial, syndrome, numECCodewords, e); |
| delete buildmonomial; |
| delete syndrome; |
| BC_EXCEPTION_CHECK_ReturnValue(e, -1); |
| CBC_PDF417ECModulusPoly* sigma = sigmaOmega->GetAt(0); |
| CBC_PDF417ECModulusPoly* omega = sigmaOmega->GetAt(1); |
| CFX_Int32Array* errorLocations = findErrorLocations(sigma, e); |
| if (e != BCExceptionNO) { |
| for (int32_t i = 0; i < sigmaOmega->GetSize(); i++) { |
| delete sigmaOmega->GetAt(i); |
| } |
| sigmaOmega->RemoveAll(); |
| delete sigmaOmega; |
| return -1; |
| } |
| CFX_Int32Array* errorMagnitudes = |
| findErrorMagnitudes(omega, sigma, *errorLocations, e); |
| if (e != BCExceptionNO) { |
| delete errorLocations; |
| for (int32_t i = 0; i < sigmaOmega->GetSize(); i++) { |
| delete sigmaOmega->GetAt(i); |
| } |
| sigmaOmega->RemoveAll(); |
| delete sigmaOmega; |
| return -1; |
| } |
| for (int32_t i = 0; i < errorLocations->GetSize(); i++) { |
| int32_t log = m_field->log(errorLocations->GetAt(i), e); |
| |
| BC_EXCEPTION_CHECK_ReturnValue(e, -1); |
| int32_t position = received.GetSize() - 1 - log; |
| if (position < 0) { |
| e = BCExceptionChecksumException; |
| delete errorLocations; |
| delete errorMagnitudes; |
| for (int32_t j = 0; j < sigmaOmega->GetSize(); j++) { |
| delete sigmaOmega->GetAt(j); |
| } |
| sigmaOmega->RemoveAll(); |
| delete sigmaOmega; |
| return -1; |
| } |
| received[position] = |
| m_field->subtract(received[position], errorMagnitudes->GetAt(i)); |
| } |
| int32_t result = errorLocations->GetSize(); |
| delete errorLocations; |
| delete errorMagnitudes; |
| for (int32_t k = 0; k < sigmaOmega->GetSize(); k++) { |
| delete sigmaOmega->GetAt(k); |
| } |
| sigmaOmega->RemoveAll(); |
| delete sigmaOmega; |
| return result; |
| } |
| CFX_ArrayTemplate<CBC_PDF417ECModulusPoly*>* |
| CBC_PDF417ECErrorCorrection::runEuclideanAlgorithm(CBC_PDF417ECModulusPoly* a, |
| CBC_PDF417ECModulusPoly* b, |
| int32_t R, |
| int32_t& e) { |
| if (a->getDegree() < b->getDegree()) { |
| CBC_PDF417ECModulusPoly* temp = a; |
| a = b; |
| b = temp; |
| } |
| CBC_PDF417ECModulusPoly* rLast = a; |
| CBC_PDF417ECModulusPoly* r = b; |
| CBC_PDF417ECModulusPoly* tLast = m_field->getZero(); |
| CBC_PDF417ECModulusPoly* t = m_field->getOne(); |
| CBC_PDF417ECModulusPoly* qtemp = nullptr; |
| CBC_PDF417ECModulusPoly* rtemp = nullptr; |
| CBC_PDF417ECModulusPoly* ttemp = nullptr; |
| int32_t i = 0; |
| int32_t j = 0; |
| int32_t m = 0; |
| int32_t n = 0; |
| while (r->getDegree() >= R / 2) { |
| CBC_PDF417ECModulusPoly* rLastLast = rLast; |
| CBC_PDF417ECModulusPoly* tLastLast = tLast; |
| rLast = r; |
| tLast = t; |
| m = i; |
| n = j; |
| if (rLast->isZero()) { |
| e = BCExceptionChecksumException; |
| delete qtemp; |
| delete rtemp; |
| delete ttemp; |
| return nullptr; |
| } |
| r = rLastLast; |
| CBC_PDF417ECModulusPoly* q = m_field->getZero(); |
| int32_t denominatorLeadingTerm = rLast->getCoefficient(rLast->getDegree()); |
| int32_t dltInverse = m_field->inverse(denominatorLeadingTerm, e); |
| if (e != BCExceptionNO) { |
| delete qtemp; |
| delete rtemp; |
| delete ttemp; |
| return nullptr; |
| } |
| while (r->getDegree() >= rLast->getDegree() && !r->isZero()) { |
| int32_t degreeDiff = r->getDegree() - rLast->getDegree(); |
| int32_t scale = |
| m_field->multiply(r->getCoefficient(r->getDegree()), dltInverse); |
| CBC_PDF417ECModulusPoly* buildmonomial = |
| m_field->buildMonomial(degreeDiff, scale, e); |
| if (e != BCExceptionNO) { |
| delete qtemp; |
| delete rtemp; |
| delete ttemp; |
| return nullptr; |
| } |
| q = q->add(buildmonomial, e); |
| delete buildmonomial; |
| delete qtemp; |
| if (e != BCExceptionNO) { |
| delete rtemp; |
| delete ttemp; |
| return nullptr; |
| } |
| qtemp = q; |
| CBC_PDF417ECModulusPoly* multiply = |
| rLast->multiplyByMonomial(degreeDiff, scale, e); |
| if (e != BCExceptionNO) { |
| delete qtemp; |
| delete rtemp; |
| delete ttemp; |
| return nullptr; |
| } |
| CBC_PDF417ECModulusPoly* temp = r; |
| r = temp->subtract(multiply, e); |
| delete multiply; |
| if (m > 1 && i > m) { |
| delete temp; |
| temp = nullptr; |
| } |
| if (e != BCExceptionNO) { |
| delete qtemp; |
| delete rtemp; |
| delete ttemp; |
| return nullptr; |
| } |
| rtemp = r; |
| i = m + 1; |
| } |
| ttemp = q->multiply(tLast, e); |
| delete qtemp; |
| qtemp = nullptr; |
| if (e != BCExceptionNO) { |
| delete rtemp; |
| delete ttemp; |
| return nullptr; |
| } |
| t = ttemp->subtract(tLastLast, e); |
| if (n > 1 && j > n) { |
| delete tLastLast; |
| } |
| delete ttemp; |
| if (e != BCExceptionNO) { |
| delete rtemp; |
| return nullptr; |
| } |
| ttemp = t; |
| t = ttemp->negative(e); |
| delete ttemp; |
| if (e != BCExceptionNO) { |
| delete rtemp; |
| return nullptr; |
| } |
| ttemp = t; |
| j++; |
| } |
| int32_t sigmaTildeAtZero = t->getCoefficient(0); |
| if (sigmaTildeAtZero == 0) { |
| e = BCExceptionChecksumException; |
| delete rtemp; |
| delete ttemp; |
| return nullptr; |
| } |
| int32_t inverse = m_field->inverse(sigmaTildeAtZero, e); |
| if (e != BCExceptionNO) { |
| delete rtemp; |
| delete ttemp; |
| return nullptr; |
| } |
| CBC_PDF417ECModulusPoly* sigma = t->multiply(inverse, e); |
| delete ttemp; |
| if (e != BCExceptionNO) { |
| delete rtemp; |
| return nullptr; |
| } |
| CBC_PDF417ECModulusPoly* omega = r->multiply(inverse, e); |
| delete rtemp; |
| BC_EXCEPTION_CHECK_ReturnValue(e, nullptr); |
| CFX_ArrayTemplate<CBC_PDF417ECModulusPoly*>* modulusPoly = |
| new CFX_ArrayTemplate<CBC_PDF417ECModulusPoly*>(); |
| modulusPoly->Add(sigma); |
| modulusPoly->Add(omega); |
| return modulusPoly; |
| } |
| CFX_Int32Array* CBC_PDF417ECErrorCorrection::findErrorLocations( |
| CBC_PDF417ECModulusPoly* errorLocator, |
| int32_t& e) { |
| int32_t numErrors = errorLocator->getDegree(); |
| CFX_Int32Array* result = new CFX_Int32Array; |
| result->SetSize(numErrors); |
| int32_t ee = 0; |
| for (int32_t i = 1; i < m_field->getSize() && ee < numErrors; i++) { |
| if (errorLocator->evaluateAt(i) == 0) { |
| result->SetAt(ee, m_field->inverse(i, e)); |
| if (e != BCExceptionNO) { |
| delete result; |
| return nullptr; |
| } |
| ee++; |
| } |
| } |
| if (ee != numErrors) { |
| e = BCExceptionChecksumException; |
| delete result; |
| return nullptr; |
| } |
| return result; |
| } |
| CFX_Int32Array* CBC_PDF417ECErrorCorrection::findErrorMagnitudes( |
| CBC_PDF417ECModulusPoly* errorEvaluator, |
| CBC_PDF417ECModulusPoly* errorLocator, |
| CFX_Int32Array& errorLocations, |
| int32_t& e) { |
| int32_t errorLocatorDegree = errorLocator->getDegree(); |
| CFX_Int32Array formalDerivativeCoefficients; |
| formalDerivativeCoefficients.SetSize(errorLocatorDegree); |
| for (int32_t l = 1; l <= errorLocatorDegree; l++) { |
| formalDerivativeCoefficients[errorLocatorDegree - l] = |
| m_field->multiply(l, errorLocator->getCoefficient(l)); |
| } |
| CBC_PDF417ECModulusPoly formalDerivative(m_field, |
| formalDerivativeCoefficients, e); |
| BC_EXCEPTION_CHECK_ReturnValue(e, nullptr); |
| int32_t s = errorLocations.GetSize(); |
| CFX_Int32Array* result = new CFX_Int32Array; |
| result->SetSize(s); |
| for (int32_t i = 0; i < s; i++) { |
| int32_t xiInverse = m_field->inverse(errorLocations[i], e); |
| if (e != BCExceptionNO) { |
| delete result; |
| return nullptr; |
| } |
| int32_t numerator = |
| m_field->subtract(0, errorEvaluator->evaluateAt(xiInverse)); |
| int32_t denominator = |
| m_field->inverse(formalDerivative.evaluateAt(xiInverse), e); |
| if (e != BCExceptionNO) { |
| delete result; |
| return nullptr; |
| } |
| result->SetAt(i, m_field->multiply(numerator, denominator)); |
| } |
| return result; |
| } |
