// 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 2009 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 <stdlib.h>
#include "../barcode.h"
#include "../BC_DecoderResult.h"
#include "../common/BC_CommonDecoderResult.h"
#include "../../../../third_party/bigint/BigIntegerLibrary.hh"
#include "BC_PDF417ResultMetadata.h"
#include "BC_PDF417DecodedBitStreamParser.h"
#define TEXT_COMPACTION_MODE_LATCH 900
#define BYTE_COMPACTION_MODE_LATCH 901
#define NUMERIC_COMPACTION_MODE_LATCH 902
#define BYTE_COMPACTION_MODE_LATCH_6 924
#define BEGIN_MACRO_PDF417_CONTROL_BLOCK 928
#define BEGIN_MACRO_PDF417_OPTIONAL_FIELD 923
#define MACRO_PDF417_TERMINATOR 922
#define MODE_SHIFT_TO_BYTE_COMPACTION_MODE 913
int32_t CBC_DecodedBitStreamPaser::MAX_NUMERIC_CODEWORDS = 15;
int32_t CBC_DecodedBitStreamPaser::NUMBER_OF_SEQUENCE_CODEWORDS = 2;
int32_t CBC_DecodedBitStreamPaser::PL = 25;
int32_t CBC_DecodedBitStreamPaser::LL = 27;
int32_t CBC_DecodedBitStreamPaser::AS = 27;
int32_t CBC_DecodedBitStreamPaser::ML = 28;
int32_t CBC_DecodedBitStreamPaser::AL = 28;
int32_t CBC_DecodedBitStreamPaser::PS = 29;
int32_t CBC_DecodedBitStreamPaser::PAL = 29;
FX_CHAR CBC_DecodedBitStreamPaser::PUNCT_CHARS[29] = {
';', '<', '>', '@', '[', '\\', '}', '_', '`', '~', '!',
'\r', '\t', ',', ':', '\n', '-', '.', '$', '/', '"', '|', '*',
'(', ')', '?', '{', '}', '\''
};
FX_CHAR CBC_DecodedBitStreamPaser::MIXED_CHARS[30] = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '&',
'\r', '\t', ',', ':', '#', '-', '.', '$', '/', '+', '%', '*',
'=', '^'
};
void CBC_DecodedBitStreamPaser::Initialize()
{
}
void CBC_DecodedBitStreamPaser::Finalize()
{
}
CBC_DecodedBitStreamPaser::CBC_DecodedBitStreamPaser()
{
}
CBC_DecodedBitStreamPaser::~CBC_DecodedBitStreamPaser()
{
}
CBC_CommonDecoderResult* CBC_DecodedBitStreamPaser::decode(CFX_Int32Array &codewords, CFX_ByteString ecLevel, int32_t &e)
{
CFX_ByteString result;
int32_t codeIndex = 1;
int32_t code = codewords.GetAt(codeIndex);
codeIndex++;
CBC_PDF417ResultMetadata* resultMetadata = FX_NEW CBC_PDF417ResultMetadata;
while (codeIndex < codewords[0]) {
switch (code) {
case TEXT_COMPACTION_MODE_LATCH:
codeIndex = textCompaction(codewords, codeIndex, result);
break;
case BYTE_COMPACTION_MODE_LATCH:
codeIndex = byteCompaction(code, codewords, codeIndex, result);
break;
case NUMERIC_COMPACTION_MODE_LATCH:
codeIndex = numericCompaction(codewords, codeIndex, result, e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
break;
case MODE_SHIFT_TO_BYTE_COMPACTION_MODE:
codeIndex = byteCompaction(code, codewords, codeIndex, result);
break;
case BYTE_COMPACTION_MODE_LATCH_6:
codeIndex = byteCompaction(code, codewords, codeIndex, result);
break;
case BEGIN_MACRO_PDF417_CONTROL_BLOCK:
codeIndex = decodeMacroBlock(codewords, codeIndex, resultMetadata, e);
if (e != BCExceptionNO) {
delete resultMetadata;
return NULL;
}
break;
default:
codeIndex--;
codeIndex = textCompaction(codewords, codeIndex, result);
break;
}
if (codeIndex < codewords.GetSize()) {
code = codewords[codeIndex++];
} else {
e = BCExceptionFormatInstance;
delete resultMetadata;
return NULL;
}
}
if (result.GetLength() == 0) {
e = BCExceptionFormatInstance;
delete resultMetadata;
return NULL;
}
CFX_ByteArray rawBytes;
CFX_PtrArray byteSegments;
CBC_CommonDecoderResult *tempCd = FX_NEW CBC_CommonDecoderResult();
tempCd->Init(rawBytes, result, byteSegments, ecLevel, e);
if (e != BCExceptionNO) {
delete resultMetadata;
return NULL;
}
tempCd->setOther(resultMetadata);
return tempCd;
}
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;
}
int32_t CBC_DecodedBitStreamPaser::textCompaction(CFX_Int32Array &codewords, int32_t codeIndex, CFX_ByteString &result)
{
CFX_Int32Array textCompactionData;
textCompactionData.SetSize((codewords[0] - codeIndex) << 1);
CFX_Int32Array byteCompactionData;
byteCompactionData.SetSize((codewords[0] - codeIndex) << 1);
int32_t index = 0;
FX_BOOL end = FALSE;
while ((codeIndex < codewords[0]) && !end) {
int32_t code = codewords[codeIndex++];
if (code < TEXT_COMPACTION_MODE_LATCH) {
textCompactionData[index] = code / 30;
textCompactionData[index + 1] = code % 30;
index += 2;
} else {
switch (code) {
case TEXT_COMPACTION_MODE_LATCH:
textCompactionData[index++] = TEXT_COMPACTION_MODE_LATCH;
break;
case BYTE_COMPACTION_MODE_LATCH:
codeIndex--;
end = TRUE;
break;
case NUMERIC_COMPACTION_MODE_LATCH:
codeIndex--;
end = TRUE;
break;
case BEGIN_MACRO_PDF417_CONTROL_BLOCK:
codeIndex--;
end = TRUE;
break;
case BEGIN_MACRO_PDF417_OPTIONAL_FIELD:
codeIndex--;
end = TRUE;
break;
case MACRO_PDF417_TERMINATOR:
codeIndex--;
end = TRUE;
break;
case MODE_SHIFT_TO_BYTE_COMPACTION_MODE:
textCompactionData[index] = MODE_SHIFT_TO_BYTE_COMPACTION_MODE;
code = codewords[codeIndex++];
byteCompactionData[index] = code;
index++;
break;
case BYTE_COMPACTION_MODE_LATCH_6:
codeIndex--;
end = TRUE;
break;
}
}
}
decodeTextCompaction(textCompactionData, byteCompactionData, index, result);
return codeIndex;
}
void CBC_DecodedBitStreamPaser::decodeTextCompaction(CFX_Int32Array &textCompactionData, CFX_Int32Array &byteCompactionData, int32_t length, CFX_ByteString &result)
{
Mode subMode = ALPHA;
Mode priorToShiftMode = ALPHA;
int32_t i = 0;
while (i < length) {
int32_t subModeCh = textCompactionData[i];
FX_CHAR ch = 0;
switch (subMode) {
case ALPHA:
if (subModeCh < 26) {
ch = (FX_CHAR) ('A' + subModeCh);
} else {
if (subModeCh == 26) {
ch = ' ';
} else if (subModeCh == LL) {
subMode = LOWER;
} else if (subModeCh == ML) {
subMode = MIXED;
} else if (subModeCh == PS) {
priorToShiftMode = subMode;
subMode = PUNCT_SHIFT;
} else if (subModeCh == MODE_SHIFT_TO_BYTE_COMPACTION_MODE) {
result += (FX_CHAR) byteCompactionData[i];
} else if (subModeCh == TEXT_COMPACTION_MODE_LATCH) {
subMode = ALPHA;
}
}
break;
case LOWER:
if (subModeCh < 26) {
ch = (FX_CHAR) ('a' + subModeCh);
} else {
if (subModeCh == 26) {
ch = ' ';
} else if (subModeCh == AS) {
priorToShiftMode = subMode;
subMode = ALPHA_SHIFT;
} else if (subModeCh == ML) {
subMode = MIXED;
} else if (subModeCh == PS) {
priorToShiftMode = subMode;
subMode = PUNCT_SHIFT;
} else if (subModeCh == MODE_SHIFT_TO_BYTE_COMPACTION_MODE) {
result += (FX_CHAR) byteCompactionData[i];
} else if (subModeCh == TEXT_COMPACTION_MODE_LATCH) {
subMode = ALPHA;
}
}
break;
case MIXED:
if (subModeCh < PL) {
ch = MIXED_CHARS[subModeCh];
} else {
if (subModeCh == PL) {
subMode = PUNCT;
} else if (subModeCh == 26) {
ch = ' ';
} else if (subModeCh == LL) {
subMode = LOWER;
} else if (subModeCh == AL) {
subMode = ALPHA;
} else if (subModeCh == PS) {
priorToShiftMode = subMode;
subMode = PUNCT_SHIFT;
} else if (subModeCh == MODE_SHIFT_TO_BYTE_COMPACTION_MODE) {
result += (FX_CHAR) byteCompactionData[i];
} else if (subModeCh == TEXT_COMPACTION_MODE_LATCH) {
subMode = ALPHA;
}
}
break;
case PUNCT:
if (subModeCh < PAL) {
ch = PUNCT_CHARS[subModeCh];
} else {
if (subModeCh == PAL) {
subMode = ALPHA;
} else if (subModeCh == MODE_SHIFT_TO_BYTE_COMPACTION_MODE) {
result += (FX_CHAR) byteCompactionData[i];
} else if (subModeCh == TEXT_COMPACTION_MODE_LATCH) {
subMode = ALPHA;
}
}
break;
case ALPHA_SHIFT:
subMode = priorToShiftMode;
if (subModeCh < 26) {
ch = (FX_CHAR) ('A' + subModeCh);
} else {
if (subModeCh == 26) {
ch = ' ';
} else if (subModeCh == TEXT_COMPACTION_MODE_LATCH) {
subMode = ALPHA;
}
}
break;
case PUNCT_SHIFT:
subMode = priorToShiftMode;
if (subModeCh < PAL) {
ch = PUNCT_CHARS[subModeCh];
} else {
if (subModeCh == PAL) {
subMode = ALPHA;
} else if (subModeCh == MODE_SHIFT_TO_BYTE_COMPACTION_MODE) {
result += (FX_CHAR) byteCompactionData[i];
} else if (subModeCh == TEXT_COMPACTION_MODE_LATCH) {
subMode = ALPHA;
}
}
break;
}
if (ch != 0) {
result += ch;
}
i++;
}
}
int32_t CBC_DecodedBitStreamPaser::byteCompaction(int32_t mode, CFX_Int32Array &codewords, int32_t codeIndex, CFX_ByteString &result)
{
if (mode == BYTE_COMPACTION_MODE_LATCH) {
int32_t count = 0;
int64_t value = 0;
FX_WORD* decodedData = FX_Alloc(FX_WORD, 6 * sizeof(FX_WORD));
CFX_Int32Array byteCompactedCodewords;
byteCompactedCodewords.SetSize(6);
FX_BOOL end = FALSE;
int32_t nextCode = codewords[codeIndex++];
while ((codeIndex < codewords[0]) && !end) {
byteCompactedCodewords[count++] = nextCode;
value = 900 * value + nextCode;
nextCode = codewords[codeIndex++];
if (nextCode == TEXT_COMPACTION_MODE_LATCH ||
nextCode == BYTE_COMPACTION_MODE_LATCH ||
nextCode == NUMERIC_COMPACTION_MODE_LATCH ||
nextCode == BYTE_COMPACTION_MODE_LATCH_6 ||
nextCode == BEGIN_MACRO_PDF417_CONTROL_BLOCK ||
nextCode == BEGIN_MACRO_PDF417_OPTIONAL_FIELD ||
nextCode == MACRO_PDF417_TERMINATOR) {
codeIndex--;
end = TRUE;
} else {
if ((count % 5 == 0) && (count > 0)) {
int32_t j = 0;
for (; j < 6; ++j) {
decodedData[5 - j] = (FX_WORD) (value % 256);
value >>= 8;
}
for (j = 0; j < 6; ++j) {
result += (FX_CHAR)decodedData[j];
}
count = 0;
}
}
}
FX_Free(decodedData);
if (codeIndex == codewords[0] && nextCode < TEXT_COMPACTION_MODE_LATCH) {
byteCompactedCodewords[count++] = nextCode;
}
for (int32_t i = 0; i < count; i++) {
result += (FX_CHAR)(FX_WORD) byteCompactedCodewords[i];
}
} else if (mode == BYTE_COMPACTION_MODE_LATCH_6) {
int32_t count = 0;
int64_t value = 0;
FX_BOOL end = FALSE;
while (codeIndex < codewords[0] && !end) {
int32_t code = codewords[codeIndex++];
if (code < TEXT_COMPACTION_MODE_LATCH) {
count++;
value = 900 * value + code;
} else {
if (code == TEXT_COMPACTION_MODE_LATCH ||
code == BYTE_COMPACTION_MODE_LATCH ||
code == NUMERIC_COMPACTION_MODE_LATCH ||
code == BYTE_COMPACTION_MODE_LATCH_6 ||
code == BEGIN_MACRO_PDF417_CONTROL_BLOCK ||
code == BEGIN_MACRO_PDF417_OPTIONAL_FIELD ||
code == MACRO_PDF417_TERMINATOR) {
codeIndex--;
end = TRUE;
}
}
if ((count % 5 == 0) && (count > 0)) {
FX_WORD* decodedData = FX_Alloc(FX_WORD, 6 * sizeof(FX_WORD));
int32_t j = 0;
for (; j < 6; ++j) {
decodedData[5 - j] = (FX_WORD) (value & 0xFF);
value >>= 8;
}
for (j = 0; j < 6; ++j) {
result += (FX_CHAR)decodedData[j];
}
count = 0;
FX_Free(decodedData);
}
}
}
return codeIndex;
}
int32_t CBC_DecodedBitStreamPaser::numericCompaction(CFX_Int32Array &codewords, int32_t codeIndex, CFX_ByteString &result, int32_t &e)
{
int32_t count = 0;
FX_BOOL end = FALSE;
CFX_Int32Array numericCodewords;
numericCodewords.SetSize(MAX_NUMERIC_CODEWORDS);
while (codeIndex < codewords[0] && !end) {
int32_t code = codewords[codeIndex++];
if (codeIndex == codewords[0]) {
end = TRUE;
}
if (code < TEXT_COMPACTION_MODE_LATCH) {
numericCodewords[count] = code;
count++;
} else {
if (code == TEXT_COMPACTION_MODE_LATCH ||
code == BYTE_COMPACTION_MODE_LATCH ||
code == BYTE_COMPACTION_MODE_LATCH_6 ||
code == BEGIN_MACRO_PDF417_CONTROL_BLOCK ||
code == BEGIN_MACRO_PDF417_OPTIONAL_FIELD ||
code == MACRO_PDF417_TERMINATOR) {
codeIndex--;
end = TRUE;
}
}
if (count % MAX_NUMERIC_CODEWORDS == 0 ||
code == NUMERIC_COMPACTION_MODE_LATCH ||
end) {
CFX_ByteString s = decodeBase900toBase10(numericCodewords, count, e);
BC_EXCEPTION_CHECK_ReturnValue(e, -1);
result += s;
count = 0;
}
}
return codeIndex;
}
CFX_ByteString CBC_DecodedBitStreamPaser::decodeBase900toBase10(CFX_Int32Array &codewords, int32_t count, int32_t &e)
{
BigInteger result = 0;
BigInteger nineHundred(900);
for (int32_t i = 0; i < count; i++) {
result = result * nineHundred + BigInteger(codewords[i]);
}
CFX_ByteString resultString(bigIntegerToString(result).c_str());
if (resultString.GetAt(0) != '1') {
e = BCExceptionFormatInstance;
return ' ';
}
return resultString.Mid(1, resultString.GetLength() - 1);
}