CBC_ReedSolomonGF256Poly* CBC_ReedSolomonGF256Poly::Multiply(
CBC_ReedSolomonGF256Poly* other,
int32_t& e) {
if (IsZero() || other->IsZero()) {
CBC_ReedSolomonGF256Poly* temp = m_field->GetZero()->Clone(e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
return temp;
}
CFX_Int32Array aCoefficients;
aCoefficients.Copy(m_coefficients);
int32_t aLength = m_coefficients.GetSize();
CFX_Int32Array bCoefficients;
bCoefficients.Copy(*(other->GetCoefficients()));
int32_t bLength = other->GetCoefficients()->GetSize();
CFX_Int32Array product;
product.SetSize(aLength + bLength - 1);
for (int32_t i = 0; i < aLength; i++) {
int32_t aCoeff = m_coefficients[i];
for (int32_t j = 0; j < bLength; j++) {
product[i + j] = CBC_ReedSolomonGF256::AddOrSubtract(
product[i + j],
m_field->Multiply(aCoeff, other->GetCoefficients()->operator[](j)));
}
}
CBC_ReedSolomonGF256Poly* temp = new CBC_ReedSolomonGF256Poly();
temp->Init(m_field, &product, e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
return temp;
}
CBC_ReedSolomonGF256Poly* CBC_ReedSolomonGF256Poly::AddOrSubtract(
CBC_ReedSolomonGF256Poly* other,
int32_t& e) {
if (IsZero())
return other->Clone(e);
if (other->IsZero())
return Clone(e);
CFX_Int32Array smallerCoefficients;
smallerCoefficients.Copy(m_coefficients);
CFX_Int32Array largerCoefficients;
largerCoefficients.Copy(*(other->GetCoefficients()));
if (smallerCoefficients.GetSize() > largerCoefficients.GetSize()) {
CFX_Int32Array temp;
temp.Copy(smallerCoefficients);
smallerCoefficients.Copy(largerCoefficients);
largerCoefficients.Copy(temp);
}
CFX_Int32Array sumDiff;
sumDiff.SetSize(largerCoefficients.GetSize());
int32_t lengthDiff =
largerCoefficients.GetSize() - smallerCoefficients.GetSize();
for (int32_t i = 0; i < lengthDiff; i++) {
sumDiff[i] = largerCoefficients[i];
}
for (int32_t j = lengthDiff; j < largerCoefficients.GetSize(); j++) {
sumDiff[j] = (CBC_ReedSolomonGF256::AddOrSubtract(
smallerCoefficients[j - lengthDiff], largerCoefficients[j]));
}
CBC_ReedSolomonGF256Poly* temp = new CBC_ReedSolomonGF256Poly();
temp->Init(m_field, &sumDiff, e);
BC_EXCEPTION_CHECK_ReturnValue(e, nullptr);
return temp;
}
int32_t CBC_DecodedBitStreamPaser::decodeMacroBlock(
CFX_Int32Array& codewords,
int32_t codeIndex,
CBC_PDF417ResultMetadata* resultMetadata,
int32_t& e) {
if (codeIndex + NUMBER_OF_SEQUENCE_CODEWORDS > codewords[0]) {
e = BCExceptionFormatInstance;
return -1;
}
CFX_Int32Array segmentIndexArray;
segmentIndexArray.SetSize(NUMBER_OF_SEQUENCE_CODEWORDS);
for (int32_t i = 0; i < NUMBER_OF_SEQUENCE_CODEWORDS; i++, codeIndex++) {
segmentIndexArray.SetAt(i, codewords[codeIndex]);
}
CFX_ByteString str =
decodeBase900toBase10(segmentIndexArray, NUMBER_OF_SEQUENCE_CODEWORDS, e);
BC_EXCEPTION_CHECK_ReturnValue(e, -1);
resultMetadata->setSegmentIndex(atoi(str.GetBuffer(str.GetLength())));
CFX_ByteString fileId;
codeIndex = textCompaction(codewords, codeIndex, fileId);
resultMetadata->setFileId(fileId);
if (codewords[codeIndex] == BEGIN_MACRO_PDF417_OPTIONAL_FIELD) {
codeIndex++;
CFX_Int32Array additionalOptionCodeWords;
additionalOptionCodeWords.SetSize(codewords[0] - codeIndex);
int32_t additionalOptionCodeWordsIndex = 0;
FX_BOOL end = FALSE;
while ((codeIndex < codewords[0]) && !end) {
int32_t code = codewords[codeIndex++];
if (code < TEXT_COMPACTION_MODE_LATCH) {
additionalOptionCodeWords[additionalOptionCodeWordsIndex++] = code;
} else {
switch (code) {
case MACRO_PDF417_TERMINATOR:
resultMetadata->setLastSegment(TRUE);
codeIndex++;
end = TRUE;
break;
default:
e = BCExceptionFormatInstance;
return -1;
}
}
}
CFX_Int32Array array;
array.SetSize(additionalOptionCodeWordsIndex);
array.Copy(additionalOptionCodeWords);
resultMetadata->setOptionalData(array);
} else if (codewords[codeIndex] == MACRO_PDF417_TERMINATOR) {
resultMetadata->setLastSegment(TRUE);
codeIndex++;
}
return codeIndex;
}
CFX_PtrArray* CBC_Detector::findRowsWithPattern(CBC_CommonBitMatrix* matrix,
int32_t height,
int32_t width,
int32_t startRow,
int32_t startColumn,
int32_t* pattern,
int32_t patternLength) {
CFX_PtrArray* result = new CFX_PtrArray;
result->SetSize(4);
FX_BOOL found = FALSE;
CFX_Int32Array counters;
counters.SetSize(patternLength);
for (; startRow < height; startRow += ROW_STEP) {
CFX_Int32Array* loc =
findGuardPattern(matrix, startColumn, startRow, width, FALSE, pattern,
patternLength, counters);
if (loc != NULL) {
while (startRow > 0) {
CFX_Int32Array* previousRowLoc =
findGuardPattern(matrix, startColumn, --startRow, width, FALSE,
pattern, patternLength, counters);
if (previousRowLoc != NULL) {
delete loc;
loc = previousRowLoc;
} else {
startRow++;
break;
}
}
result->SetAt(
0, new CBC_ResultPoint((FX_FLOAT)loc->GetAt(0), (FX_FLOAT)startRow));
result->SetAt(
1, new CBC_ResultPoint((FX_FLOAT)loc->GetAt(1), (FX_FLOAT)startRow));
found = TRUE;
delete loc;
break;
}
}
int32_t stopRow = startRow + 1;
if (found) {
int32_t skippedRowCount = 0;
CFX_Int32Array previousRowLoc;
previousRowLoc.Add((int32_t)((CBC_ResultPoint*)result->GetAt(0))->GetX());
previousRowLoc.Add((int32_t)((CBC_ResultPoint*)result->GetAt(1))->GetX());
for (; stopRow < height; stopRow++) {
CFX_Int32Array* loc =
findGuardPattern(matrix, previousRowLoc[0], stopRow, width, FALSE,
pattern, patternLength, counters);
if (loc != NULL &&
abs(previousRowLoc[0] - loc->GetAt(0)) < MAX_PATTERN_DRIFT &&
abs(previousRowLoc[1] - loc->GetAt(1)) < MAX_PATTERN_DRIFT) {
previousRowLoc.Copy(*loc);
skippedRowCount = 0;
} else {
if (skippedRowCount > SKIPPED_ROW_COUNT_MAX) {
delete loc;
break;
} else {
skippedRowCount++;
}
}
delete loc;
}
stopRow -= skippedRowCount + 1;
result->SetAt(2, new CBC_ResultPoint((FX_FLOAT)previousRowLoc.GetAt(0),
(FX_FLOAT)stopRow));
result->SetAt(3, new CBC_ResultPoint((FX_FLOAT)previousRowLoc.GetAt(1),
(FX_FLOAT)stopRow));
}
if (stopRow - startRow < BARCODE_MIN_HEIGHT) {
for (int32_t i = 0; i < result->GetSize(); i++) {
result->SetAt(i, NULL);
}
}
return result;
}
