From 1770c021cf998ff1b33855b1397f6ea8ff9f7cd7 Mon Sep 17 00:00:00 2001 From: Dan Sinclair Date: Mon, 14 Mar 2016 14:14:16 -0400 Subject: Move xfa/src up to xfa/. This CL moves the xfa/src files up to the xfa/ directory and fixes the includes, include guards, and build files. R=tsepez@chromium.org Review URL: https://codereview.chromium.org/1803723002 . --- xfa/fxbarcode/pdf417/BC_PDF417.cpp | 586 ++++++++++++++++ xfa/fxbarcode/pdf417/BC_PDF417.h | 64 ++ xfa/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.cpp | 90 +++ xfa/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.h | 38 ++ xfa/fxbarcode/pdf417/BC_PDF417BarcodeMetadata.cpp | 50 ++ xfa/fxbarcode/pdf417/BC_PDF417BarcodeMetadata.h | 33 + xfa/fxbarcode/pdf417/BC_PDF417BarcodeRow.cpp | 53 ++ xfa/fxbarcode/pdf417/BC_PDF417BarcodeRow.h | 28 + xfa/fxbarcode/pdf417/BC_PDF417BarcodeValue.cpp | 61 ++ xfa/fxbarcode/pdf417/BC_PDF417BarcodeValue.h | 25 + xfa/fxbarcode/pdf417/BC_PDF417BoundingBox.cpp | 207 ++++++ xfa/fxbarcode/pdf417/BC_PDF417BoundingBox.h | 61 ++ xfa/fxbarcode/pdf417/BC_PDF417Codeword.cpp | 70 ++ xfa/fxbarcode/pdf417/BC_PDF417Codeword.h | 37 + xfa/fxbarcode/pdf417/BC_PDF417CodewordDecoder.cpp | 117 ++++ xfa/fxbarcode/pdf417/BC_PDF417CodewordDecoder.h | 28 + xfa/fxbarcode/pdf417/BC_PDF417Common.cpp | 651 ++++++++++++++++++ xfa/fxbarcode/pdf417/BC_PDF417Common.h | 34 + xfa/fxbarcode/pdf417/BC_PDF417Compaction.cpp | 26 + xfa/fxbarcode/pdf417/BC_PDF417Compaction.h | 18 + .../pdf417/BC_PDF417DecodedBitStreamParser.cpp | 493 ++++++++++++++ .../pdf417/BC_PDF417DecodedBitStreamParser.h | 63 ++ xfa/fxbarcode/pdf417/BC_PDF417DetectionResult.cpp | 339 ++++++++++ xfa/fxbarcode/pdf417/BC_PDF417DetectionResult.h | 57 ++ .../pdf417/BC_PDF417DetectionResultColumn.cpp | 101 +++ .../pdf417/BC_PDF417DetectionResultColumn.h | 33 + .../BC_PDF417DetectionResultRowIndicatorColumn.cpp | 267 ++++++++ .../BC_PDF417DetectionResultRowIndicatorColumn.h | 34 + xfa/fxbarcode/pdf417/BC_PDF417Detector.cpp | 352 ++++++++++ xfa/fxbarcode/pdf417/BC_PDF417Detector.h | 69 ++ xfa/fxbarcode/pdf417/BC_PDF417DetectorResult.cpp | 50 ++ xfa/fxbarcode/pdf417/BC_PDF417DetectorResult.h | 26 + xfa/fxbarcode/pdf417/BC_PDF417Dimensions.cpp | 46 ++ xfa/fxbarcode/pdf417/BC_PDF417Dimensions.h | 31 + .../pdf417/BC_PDF417ECErrorCorrection.cpp | 389 +++++++++++ xfa/fxbarcode/pdf417/BC_PDF417ECErrorCorrection.h | 39 ++ xfa/fxbarcode/pdf417/BC_PDF417ECModulusGF.cpp | 120 ++++ xfa/fxbarcode/pdf417/BC_PDF417ECModulusGF.h | 39 ++ xfa/fxbarcode/pdf417/BC_PDF417ECModulusPoly.cpp | 332 +++++++++ xfa/fxbarcode/pdf417/BC_PDF417ECModulusPoly.h | 39 ++ xfa/fxbarcode/pdf417/BC_PDF417ErrorCorrection.cpp | 165 +++++ xfa/fxbarcode/pdf417/BC_PDF417ErrorCorrection.h | 30 + xfa/fxbarcode/pdf417/BC_PDF417HighLevelEncoder.cpp | 427 ++++++++++++ xfa/fxbarcode/pdf417/BC_PDF417HighLevelEncoder.h | 74 ++ .../pdf417/BC_PDF417HighLevelEncoder_unittest.cpp | 231 +++++++ xfa/fxbarcode/pdf417/BC_PDF417Reader.cpp | 149 ++++ xfa/fxbarcode/pdf417/BC_PDF417Reader.h | 31 + xfa/fxbarcode/pdf417/BC_PDF417ResultMetadata.cpp | 50 ++ xfa/fxbarcode/pdf417/BC_PDF417ResultMetadata.h | 32 + xfa/fxbarcode/pdf417/BC_PDF417ScanningDecoder.cpp | 752 +++++++++++++++++++++ xfa/fxbarcode/pdf417/BC_PDF417ScanningDecoder.h | 119 ++++ xfa/fxbarcode/pdf417/BC_PDF417Writer.cpp | 115 ++++ xfa/fxbarcode/pdf417/BC_PDF417Writer.h | 28 + 53 files changed, 7399 insertions(+) create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417BarcodeMetadata.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417BarcodeMetadata.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417BarcodeRow.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417BarcodeRow.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417BarcodeValue.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417BarcodeValue.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417BoundingBox.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417BoundingBox.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417Codeword.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417Codeword.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417CodewordDecoder.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417CodewordDecoder.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417Common.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417Common.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417Compaction.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417Compaction.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417DetectionResult.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417DetectionResult.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417DetectionResultColumn.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417DetectionResultColumn.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417DetectionResultRowIndicatorColumn.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417DetectionResultRowIndicatorColumn.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417Detector.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417Detector.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417DetectorResult.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417DetectorResult.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417Dimensions.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417Dimensions.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417ECErrorCorrection.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417ECErrorCorrection.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417ECModulusGF.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417ECModulusGF.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417ECModulusPoly.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417ECModulusPoly.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417ErrorCorrection.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417ErrorCorrection.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417HighLevelEncoder.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417HighLevelEncoder.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417HighLevelEncoder_unittest.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417Reader.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417Reader.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417ResultMetadata.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417ResultMetadata.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417ScanningDecoder.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417ScanningDecoder.h create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417Writer.cpp create mode 100644 xfa/fxbarcode/pdf417/BC_PDF417Writer.h (limited to 'xfa/fxbarcode/pdf417') diff --git a/xfa/fxbarcode/pdf417/BC_PDF417.cpp b/xfa/fxbarcode/pdf417/BC_PDF417.cpp new file mode 100644 index 0000000000..e57a79e17e --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417.cpp @@ -0,0 +1,586 @@ +// 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 2006 Jeremias Maerki in part, and ZXing Authors in part + * + * 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_PDF417.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417BarcodeRow.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417Compaction.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417ErrorCorrection.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417HighLevelEncoder.h" +#include "xfa/fxbarcode/utils.h" + +int32_t CBC_PDF417::START_PATTERN = 0x1fea8; +int32_t CBC_PDF417::STOP_PATTERN = 0x3fa29; +int32_t CBC_PDF417::CODEWORD_TABLE[][1000] = { + {0x1d5c0, 0x1eaf0, 0x1f57c, 0x1d4e0, 0x1ea78, 0x1f53e, 0x1a8c0, 0x1d470, + 0x1a860, 0x15040, 0x1a830, 0x15020, 0x1adc0, 0x1d6f0, 0x1eb7c, 0x1ace0, + 0x1d678, 0x1eb3e, 0x158c0, 0x1ac70, 0x15860, 0x15dc0, 0x1aef0, 0x1d77c, + 0x15ce0, 0x1ae78, 0x1d73e, 0x15c70, 0x1ae3c, 0x15ef0, 0x1af7c, 0x15e78, + 0x1af3e, 0x15f7c, 0x1f5fa, 0x1d2e0, 0x1e978, 0x1f4be, 0x1a4c0, 0x1d270, + 0x1e93c, 0x1a460, 0x1d238, 0x14840, 0x1a430, 0x1d21c, 0x14820, 0x1a418, + 0x14810, 0x1a6e0, 0x1d378, 0x1e9be, 0x14cc0, 0x1a670, 0x1d33c, 0x14c60, + 0x1a638, 0x1d31e, 0x14c30, 0x1a61c, 0x14ee0, 0x1a778, 0x1d3be, 0x14e70, + 0x1a73c, 0x14e38, 0x1a71e, 0x14f78, 0x1a7be, 0x14f3c, 0x14f1e, 0x1a2c0, + 0x1d170, 0x1e8bc, 0x1a260, 0x1d138, 0x1e89e, 0x14440, 0x1a230, 0x1d11c, + 0x14420, 0x1a218, 0x14410, 0x14408, 0x146c0, 0x1a370, 0x1d1bc, 0x14660, + 0x1a338, 0x1d19e, 0x14630, 0x1a31c, 0x14618, 0x1460c, 0x14770, 0x1a3bc, + 0x14738, 0x1a39e, 0x1471c, 0x147bc, 0x1a160, 0x1d0b8, 0x1e85e, 0x14240, + 0x1a130, 0x1d09c, 0x14220, 0x1a118, 0x1d08e, 0x14210, 0x1a10c, 0x14208, + 0x1a106, 0x14360, 0x1a1b8, 0x1d0de, 0x14330, 0x1a19c, 0x14318, 0x1a18e, + 0x1430c, 0x14306, 0x1a1de, 0x1438e, 0x14140, 0x1a0b0, 0x1d05c, 0x14120, + 0x1a098, 0x1d04e, 0x14110, 0x1a08c, 0x14108, 0x1a086, 0x14104, 0x141b0, + 0x14198, 0x1418c, 0x140a0, 0x1d02e, 0x1a04c, 0x1a046, 0x14082, 0x1cae0, + 0x1e578, 0x1f2be, 0x194c0, 0x1ca70, 0x1e53c, 0x19460, 0x1ca38, 0x1e51e, + 0x12840, 0x19430, 0x12820, 0x196e0, 0x1cb78, 0x1e5be, 0x12cc0, 0x19670, + 0x1cb3c, 0x12c60, 0x19638, 0x12c30, 0x12c18, 0x12ee0, 0x19778, 0x1cbbe, + 0x12e70, 0x1973c, 0x12e38, 0x12e1c, 0x12f78, 0x197be, 0x12f3c, 0x12fbe, + 0x1dac0, 0x1ed70, 0x1f6bc, 0x1da60, 0x1ed38, 0x1f69e, 0x1b440, 0x1da30, + 0x1ed1c, 0x1b420, 0x1da18, 0x1ed0e, 0x1b410, 0x1da0c, 0x192c0, 0x1c970, + 0x1e4bc, 0x1b6c0, 0x19260, 0x1c938, 0x1e49e, 0x1b660, 0x1db38, 0x1ed9e, + 0x16c40, 0x12420, 0x19218, 0x1c90e, 0x16c20, 0x1b618, 0x16c10, 0x126c0, + 0x19370, 0x1c9bc, 0x16ec0, 0x12660, 0x19338, 0x1c99e, 0x16e60, 0x1b738, + 0x1db9e, 0x16e30, 0x12618, 0x16e18, 0x12770, 0x193bc, 0x16f70, 0x12738, + 0x1939e, 0x16f38, 0x1b79e, 0x16f1c, 0x127bc, 0x16fbc, 0x1279e, 0x16f9e, + 0x1d960, 0x1ecb8, 0x1f65e, 0x1b240, 0x1d930, 0x1ec9c, 0x1b220, 0x1d918, + 0x1ec8e, 0x1b210, 0x1d90c, 0x1b208, 0x1b204, 0x19160, 0x1c8b8, 0x1e45e, + 0x1b360, 0x19130, 0x1c89c, 0x16640, 0x12220, 0x1d99c, 0x1c88e, 0x16620, + 0x12210, 0x1910c, 0x16610, 0x1b30c, 0x19106, 0x12204, 0x12360, 0x191b8, + 0x1c8de, 0x16760, 0x12330, 0x1919c, 0x16730, 0x1b39c, 0x1918e, 0x16718, + 0x1230c, 0x12306, 0x123b8, 0x191de, 0x167b8, 0x1239c, 0x1679c, 0x1238e, + 0x1678e, 0x167de, 0x1b140, 0x1d8b0, 0x1ec5c, 0x1b120, 0x1d898, 0x1ec4e, + 0x1b110, 0x1d88c, 0x1b108, 0x1d886, 0x1b104, 0x1b102, 0x12140, 0x190b0, + 0x1c85c, 0x16340, 0x12120, 0x19098, 0x1c84e, 0x16320, 0x1b198, 0x1d8ce, + 0x16310, 0x12108, 0x19086, 0x16308, 0x1b186, 0x16304, 0x121b0, 0x190dc, + 0x163b0, 0x12198, 0x190ce, 0x16398, 0x1b1ce, 0x1638c, 0x12186, 0x16386, + 0x163dc, 0x163ce, 0x1b0a0, 0x1d858, 0x1ec2e, 0x1b090, 0x1d84c, 0x1b088, + 0x1d846, 0x1b084, 0x1b082, 0x120a0, 0x19058, 0x1c82e, 0x161a0, 0x12090, + 0x1904c, 0x16190, 0x1b0cc, 0x19046, 0x16188, 0x12084, 0x16184, 0x12082, + 0x120d8, 0x161d8, 0x161cc, 0x161c6, 0x1d82c, 0x1d826, 0x1b042, 0x1902c, + 0x12048, 0x160c8, 0x160c4, 0x160c2, 0x18ac0, 0x1c570, 0x1e2bc, 0x18a60, + 0x1c538, 0x11440, 0x18a30, 0x1c51c, 0x11420, 0x18a18, 0x11410, 0x11408, + 0x116c0, 0x18b70, 0x1c5bc, 0x11660, 0x18b38, 0x1c59e, 0x11630, 0x18b1c, + 0x11618, 0x1160c, 0x11770, 0x18bbc, 0x11738, 0x18b9e, 0x1171c, 0x117bc, + 0x1179e, 0x1cd60, 0x1e6b8, 0x1f35e, 0x19a40, 0x1cd30, 0x1e69c, 0x19a20, + 0x1cd18, 0x1e68e, 0x19a10, 0x1cd0c, 0x19a08, 0x1cd06, 0x18960, 0x1c4b8, + 0x1e25e, 0x19b60, 0x18930, 0x1c49c, 0x13640, 0x11220, 0x1cd9c, 0x1c48e, + 0x13620, 0x19b18, 0x1890c, 0x13610, 0x11208, 0x13608, 0x11360, 0x189b8, + 0x1c4de, 0x13760, 0x11330, 0x1cdde, 0x13730, 0x19b9c, 0x1898e, 0x13718, + 0x1130c, 0x1370c, 0x113b8, 0x189de, 0x137b8, 0x1139c, 0x1379c, 0x1138e, + 0x113de, 0x137de, 0x1dd40, 0x1eeb0, 0x1f75c, 0x1dd20, 0x1ee98, 0x1f74e, + 0x1dd10, 0x1ee8c, 0x1dd08, 0x1ee86, 0x1dd04, 0x19940, 0x1ccb0, 0x1e65c, + 0x1bb40, 0x19920, 0x1eedc, 0x1e64e, 0x1bb20, 0x1dd98, 0x1eece, 0x1bb10, + 0x19908, 0x1cc86, 0x1bb08, 0x1dd86, 0x19902, 0x11140, 0x188b0, 0x1c45c, + 0x13340, 0x11120, 0x18898, 0x1c44e, 0x17740, 0x13320, 0x19998, 0x1ccce, + 0x17720, 0x1bb98, 0x1ddce, 0x18886, 0x17710, 0x13308, 0x19986, 0x17708, + 0x11102, 0x111b0, 0x188dc, 0x133b0, 0x11198, 0x188ce, 0x177b0, 0x13398, + 0x199ce, 0x17798, 0x1bbce, 0x11186, 0x13386, 0x111dc, 0x133dc, 0x111ce, + 0x177dc, 0x133ce, 0x1dca0, 0x1ee58, 0x1f72e, 0x1dc90, 0x1ee4c, 0x1dc88, + 0x1ee46, 0x1dc84, 0x1dc82, 0x198a0, 0x1cc58, 0x1e62e, 0x1b9a0, 0x19890, + 0x1ee6e, 0x1b990, 0x1dccc, 0x1cc46, 0x1b988, 0x19884, 0x1b984, 0x19882, + 0x1b982, 0x110a0, 0x18858, 0x1c42e, 0x131a0, 0x11090, 0x1884c, 0x173a0, + 0x13190, 0x198cc, 0x18846, 0x17390, 0x1b9cc, 0x11084, 0x17388, 0x13184, + 0x11082, 0x13182, 0x110d8, 0x1886e, 0x131d8, 0x110cc, 0x173d8, 0x131cc, + 0x110c6, 0x173cc, 0x131c6, 0x110ee, 0x173ee, 0x1dc50, 0x1ee2c, 0x1dc48, + 0x1ee26, 0x1dc44, 0x1dc42, 0x19850, 0x1cc2c, 0x1b8d0, 0x19848, 0x1cc26, + 0x1b8c8, 0x1dc66, 0x1b8c4, 0x19842, 0x1b8c2, 0x11050, 0x1882c, 0x130d0, + 0x11048, 0x18826, 0x171d0, 0x130c8, 0x19866, 0x171c8, 0x1b8e6, 0x11042, + 0x171c4, 0x130c2, 0x171c2, 0x130ec, 0x171ec, 0x171e6, 0x1ee16, 0x1dc22, + 0x1cc16, 0x19824, 0x19822, 0x11028, 0x13068, 0x170e8, 0x11022, 0x13062, + 0x18560, 0x10a40, 0x18530, 0x10a20, 0x18518, 0x1c28e, 0x10a10, 0x1850c, + 0x10a08, 0x18506, 0x10b60, 0x185b8, 0x1c2de, 0x10b30, 0x1859c, 0x10b18, + 0x1858e, 0x10b0c, 0x10b06, 0x10bb8, 0x185de, 0x10b9c, 0x10b8e, 0x10bde, + 0x18d40, 0x1c6b0, 0x1e35c, 0x18d20, 0x1c698, 0x18d10, 0x1c68c, 0x18d08, + 0x1c686, 0x18d04, 0x10940, 0x184b0, 0x1c25c, 0x11b40, 0x10920, 0x1c6dc, + 0x1c24e, 0x11b20, 0x18d98, 0x1c6ce, 0x11b10, 0x10908, 0x18486, 0x11b08, + 0x18d86, 0x10902, 0x109b0, 0x184dc, 0x11bb0, 0x10998, 0x184ce, 0x11b98, + 0x18dce, 0x11b8c, 0x10986, 0x109dc, 0x11bdc, 0x109ce, 0x11bce, 0x1cea0, + 0x1e758, 0x1f3ae, 0x1ce90, 0x1e74c, 0x1ce88, 0x1e746, 0x1ce84, 0x1ce82, + 0x18ca0, 0x1c658, 0x19da0, 0x18c90, 0x1c64c, 0x19d90, 0x1cecc, 0x1c646, + 0x19d88, 0x18c84, 0x19d84, 0x18c82, 0x19d82, 0x108a0, 0x18458, 0x119a0, + 0x10890, 0x1c66e, 0x13ba0, 0x11990, 0x18ccc, 0x18446, 0x13b90, 0x19dcc, + 0x10884, 0x13b88, 0x11984, 0x10882, 0x11982, 0x108d8, 0x1846e, 0x119d8, + 0x108cc, 0x13bd8, 0x119cc, 0x108c6, 0x13bcc, 0x119c6, 0x108ee, 0x119ee, + 0x13bee, 0x1ef50, 0x1f7ac, 0x1ef48, 0x1f7a6, 0x1ef44, 0x1ef42, 0x1ce50, + 0x1e72c, 0x1ded0, 0x1ef6c, 0x1e726, 0x1dec8, 0x1ef66, 0x1dec4, 0x1ce42, + 0x1dec2, 0x18c50, 0x1c62c, 0x19cd0, 0x18c48, 0x1c626, 0x1bdd0, 0x19cc8, + 0x1ce66, 0x1bdc8, 0x1dee6, 0x18c42, 0x1bdc4, 0x19cc2, 0x1bdc2, 0x10850, + 0x1842c, 0x118d0, 0x10848, 0x18426, 0x139d0, 0x118c8, 0x18c66, 0x17bd0, + 0x139c8, 0x19ce6, 0x10842, 0x17bc8, 0x1bde6, 0x118c2, 0x17bc4, 0x1086c, + 0x118ec, 0x10866, 0x139ec, 0x118e6, 0x17bec, 0x139e6, 0x17be6, 0x1ef28, + 0x1f796, 0x1ef24, 0x1ef22, 0x1ce28, 0x1e716, 0x1de68, 0x1ef36, 0x1de64, + 0x1ce22, 0x1de62, 0x18c28, 0x1c616, 0x19c68, 0x18c24, 0x1bce8, 0x19c64, + 0x18c22, 0x1bce4, 0x19c62, 0x1bce2, 0x10828, 0x18416, 0x11868, 0x18c36, + 0x138e8, 0x11864, 0x10822, 0x179e8, 0x138e4, 0x11862, 0x179e4, 0x138e2, + 0x179e2, 0x11876, 0x179f6, 0x1ef12, 0x1de34, 0x1de32, 0x19c34, 0x1bc74, + 0x1bc72, 0x11834, 0x13874, 0x178f4, 0x178f2, 0x10540, 0x10520, 0x18298, + 0x10510, 0x10508, 0x10504, 0x105b0, 0x10598, 0x1058c, 0x10586, 0x105dc, + 0x105ce, 0x186a0, 0x18690, 0x1c34c, 0x18688, 0x1c346, 0x18684, 0x18682, + 0x104a0, 0x18258, 0x10da0, 0x186d8, 0x1824c, 0x10d90, 0x186cc, 0x10d88, + 0x186c6, 0x10d84, 0x10482, 0x10d82, 0x104d8, 0x1826e, 0x10dd8, 0x186ee, + 0x10dcc, 0x104c6, 0x10dc6, 0x104ee, 0x10dee, 0x1c750, 0x1c748, 0x1c744, + 0x1c742, 0x18650, 0x18ed0, 0x1c76c, 0x1c326, 0x18ec8, 0x1c766, 0x18ec4, + 0x18642, 0x18ec2, 0x10450, 0x10cd0, 0x10448, 0x18226, 0x11dd0, 0x10cc8, + 0x10444, 0x11dc8, 0x10cc4, 0x10442, 0x11dc4, 0x10cc2, 0x1046c, 0x10cec, + 0x10466, 0x11dec, 0x10ce6, 0x11de6, 0x1e7a8, 0x1e7a4, 0x1e7a2, 0x1c728, + 0x1cf68, 0x1e7b6, 0x1cf64, 0x1c722, 0x1cf62, 0x18628, 0x1c316, 0x18e68, + 0x1c736, 0x19ee8, 0x18e64, 0x18622, 0x19ee4, 0x18e62, 0x19ee2, 0x10428, + 0x18216, 0x10c68, 0x18636, 0x11ce8, 0x10c64, 0x10422, 0x13de8, 0x11ce4, + 0x10c62, 0x13de4, 0x11ce2, 0x10436, 0x10c76, 0x11cf6, 0x13df6, 0x1f7d4, + 0x1f7d2, 0x1e794, 0x1efb4, 0x1e792, 0x1efb2, 0x1c714, 0x1cf34, 0x1c712, + 0x1df74, 0x1cf32, 0x1df72, 0x18614, 0x18e34, 0x18612, 0x19e74, 0x18e32, + 0x1bef4}, + {0x1f560, 0x1fab8, 0x1ea40, 0x1f530, 0x1fa9c, 0x1ea20, 0x1f518, 0x1fa8e, + 0x1ea10, 0x1f50c, 0x1ea08, 0x1f506, 0x1ea04, 0x1eb60, 0x1f5b8, 0x1fade, + 0x1d640, 0x1eb30, 0x1f59c, 0x1d620, 0x1eb18, 0x1f58e, 0x1d610, 0x1eb0c, + 0x1d608, 0x1eb06, 0x1d604, 0x1d760, 0x1ebb8, 0x1f5de, 0x1ae40, 0x1d730, + 0x1eb9c, 0x1ae20, 0x1d718, 0x1eb8e, 0x1ae10, 0x1d70c, 0x1ae08, 0x1d706, + 0x1ae04, 0x1af60, 0x1d7b8, 0x1ebde, 0x15e40, 0x1af30, 0x1d79c, 0x15e20, + 0x1af18, 0x1d78e, 0x15e10, 0x1af0c, 0x15e08, 0x1af06, 0x15f60, 0x1afb8, + 0x1d7de, 0x15f30, 0x1af9c, 0x15f18, 0x1af8e, 0x15f0c, 0x15fb8, 0x1afde, + 0x15f9c, 0x15f8e, 0x1e940, 0x1f4b0, 0x1fa5c, 0x1e920, 0x1f498, 0x1fa4e, + 0x1e910, 0x1f48c, 0x1e908, 0x1f486, 0x1e904, 0x1e902, 0x1d340, 0x1e9b0, + 0x1f4dc, 0x1d320, 0x1e998, 0x1f4ce, 0x1d310, 0x1e98c, 0x1d308, 0x1e986, + 0x1d304, 0x1d302, 0x1a740, 0x1d3b0, 0x1e9dc, 0x1a720, 0x1d398, 0x1e9ce, + 0x1a710, 0x1d38c, 0x1a708, 0x1d386, 0x1a704, 0x1a702, 0x14f40, 0x1a7b0, + 0x1d3dc, 0x14f20, 0x1a798, 0x1d3ce, 0x14f10, 0x1a78c, 0x14f08, 0x1a786, + 0x14f04, 0x14fb0, 0x1a7dc, 0x14f98, 0x1a7ce, 0x14f8c, 0x14f86, 0x14fdc, + 0x14fce, 0x1e8a0, 0x1f458, 0x1fa2e, 0x1e890, 0x1f44c, 0x1e888, 0x1f446, + 0x1e884, 0x1e882, 0x1d1a0, 0x1e8d8, 0x1f46e, 0x1d190, 0x1e8cc, 0x1d188, + 0x1e8c6, 0x1d184, 0x1d182, 0x1a3a0, 0x1d1d8, 0x1e8ee, 0x1a390, 0x1d1cc, + 0x1a388, 0x1d1c6, 0x1a384, 0x1a382, 0x147a0, 0x1a3d8, 0x1d1ee, 0x14790, + 0x1a3cc, 0x14788, 0x1a3c6, 0x14784, 0x14782, 0x147d8, 0x1a3ee, 0x147cc, + 0x147c6, 0x147ee, 0x1e850, 0x1f42c, 0x1e848, 0x1f426, 0x1e844, 0x1e842, + 0x1d0d0, 0x1e86c, 0x1d0c8, 0x1e866, 0x1d0c4, 0x1d0c2, 0x1a1d0, 0x1d0ec, + 0x1a1c8, 0x1d0e6, 0x1a1c4, 0x1a1c2, 0x143d0, 0x1a1ec, 0x143c8, 0x1a1e6, + 0x143c4, 0x143c2, 0x143ec, 0x143e6, 0x1e828, 0x1f416, 0x1e824, 0x1e822, + 0x1d068, 0x1e836, 0x1d064, 0x1d062, 0x1a0e8, 0x1d076, 0x1a0e4, 0x1a0e2, + 0x141e8, 0x1a0f6, 0x141e4, 0x141e2, 0x1e814, 0x1e812, 0x1d034, 0x1d032, + 0x1a074, 0x1a072, 0x1e540, 0x1f2b0, 0x1f95c, 0x1e520, 0x1f298, 0x1f94e, + 0x1e510, 0x1f28c, 0x1e508, 0x1f286, 0x1e504, 0x1e502, 0x1cb40, 0x1e5b0, + 0x1f2dc, 0x1cb20, 0x1e598, 0x1f2ce, 0x1cb10, 0x1e58c, 0x1cb08, 0x1e586, + 0x1cb04, 0x1cb02, 0x19740, 0x1cbb0, 0x1e5dc, 0x19720, 0x1cb98, 0x1e5ce, + 0x19710, 0x1cb8c, 0x19708, 0x1cb86, 0x19704, 0x19702, 0x12f40, 0x197b0, + 0x1cbdc, 0x12f20, 0x19798, 0x1cbce, 0x12f10, 0x1978c, 0x12f08, 0x19786, + 0x12f04, 0x12fb0, 0x197dc, 0x12f98, 0x197ce, 0x12f8c, 0x12f86, 0x12fdc, + 0x12fce, 0x1f6a0, 0x1fb58, 0x16bf0, 0x1f690, 0x1fb4c, 0x169f8, 0x1f688, + 0x1fb46, 0x168fc, 0x1f684, 0x1f682, 0x1e4a0, 0x1f258, 0x1f92e, 0x1eda0, + 0x1e490, 0x1fb6e, 0x1ed90, 0x1f6cc, 0x1f246, 0x1ed88, 0x1e484, 0x1ed84, + 0x1e482, 0x1ed82, 0x1c9a0, 0x1e4d8, 0x1f26e, 0x1dba0, 0x1c990, 0x1e4cc, + 0x1db90, 0x1edcc, 0x1e4c6, 0x1db88, 0x1c984, 0x1db84, 0x1c982, 0x1db82, + 0x193a0, 0x1c9d8, 0x1e4ee, 0x1b7a0, 0x19390, 0x1c9cc, 0x1b790, 0x1dbcc, + 0x1c9c6, 0x1b788, 0x19384, 0x1b784, 0x19382, 0x1b782, 0x127a0, 0x193d8, + 0x1c9ee, 0x16fa0, 0x12790, 0x193cc, 0x16f90, 0x1b7cc, 0x193c6, 0x16f88, + 0x12784, 0x16f84, 0x12782, 0x127d8, 0x193ee, 0x16fd8, 0x127cc, 0x16fcc, + 0x127c6, 0x16fc6, 0x127ee, 0x1f650, 0x1fb2c, 0x165f8, 0x1f648, 0x1fb26, + 0x164fc, 0x1f644, 0x1647e, 0x1f642, 0x1e450, 0x1f22c, 0x1ecd0, 0x1e448, + 0x1f226, 0x1ecc8, 0x1f666, 0x1ecc4, 0x1e442, 0x1ecc2, 0x1c8d0, 0x1e46c, + 0x1d9d0, 0x1c8c8, 0x1e466, 0x1d9c8, 0x1ece6, 0x1d9c4, 0x1c8c2, 0x1d9c2, + 0x191d0, 0x1c8ec, 0x1b3d0, 0x191c8, 0x1c8e6, 0x1b3c8, 0x1d9e6, 0x1b3c4, + 0x191c2, 0x1b3c2, 0x123d0, 0x191ec, 0x167d0, 0x123c8, 0x191e6, 0x167c8, + 0x1b3e6, 0x167c4, 0x123c2, 0x167c2, 0x123ec, 0x167ec, 0x123e6, 0x167e6, + 0x1f628, 0x1fb16, 0x162fc, 0x1f624, 0x1627e, 0x1f622, 0x1e428, 0x1f216, + 0x1ec68, 0x1f636, 0x1ec64, 0x1e422, 0x1ec62, 0x1c868, 0x1e436, 0x1d8e8, + 0x1c864, 0x1d8e4, 0x1c862, 0x1d8e2, 0x190e8, 0x1c876, 0x1b1e8, 0x1d8f6, + 0x1b1e4, 0x190e2, 0x1b1e2, 0x121e8, 0x190f6, 0x163e8, 0x121e4, 0x163e4, + 0x121e2, 0x163e2, 0x121f6, 0x163f6, 0x1f614, 0x1617e, 0x1f612, 0x1e414, + 0x1ec34, 0x1e412, 0x1ec32, 0x1c834, 0x1d874, 0x1c832, 0x1d872, 0x19074, + 0x1b0f4, 0x19072, 0x1b0f2, 0x120f4, 0x161f4, 0x120f2, 0x161f2, 0x1f60a, + 0x1e40a, 0x1ec1a, 0x1c81a, 0x1d83a, 0x1903a, 0x1b07a, 0x1e2a0, 0x1f158, + 0x1f8ae, 0x1e290, 0x1f14c, 0x1e288, 0x1f146, 0x1e284, 0x1e282, 0x1c5a0, + 0x1e2d8, 0x1f16e, 0x1c590, 0x1e2cc, 0x1c588, 0x1e2c6, 0x1c584, 0x1c582, + 0x18ba0, 0x1c5d8, 0x1e2ee, 0x18b90, 0x1c5cc, 0x18b88, 0x1c5c6, 0x18b84, + 0x18b82, 0x117a0, 0x18bd8, 0x1c5ee, 0x11790, 0x18bcc, 0x11788, 0x18bc6, + 0x11784, 0x11782, 0x117d8, 0x18bee, 0x117cc, 0x117c6, 0x117ee, 0x1f350, + 0x1f9ac, 0x135f8, 0x1f348, 0x1f9a6, 0x134fc, 0x1f344, 0x1347e, 0x1f342, + 0x1e250, 0x1f12c, 0x1e6d0, 0x1e248, 0x1f126, 0x1e6c8, 0x1f366, 0x1e6c4, + 0x1e242, 0x1e6c2, 0x1c4d0, 0x1e26c, 0x1cdd0, 0x1c4c8, 0x1e266, 0x1cdc8, + 0x1e6e6, 0x1cdc4, 0x1c4c2, 0x1cdc2, 0x189d0, 0x1c4ec, 0x19bd0, 0x189c8, + 0x1c4e6, 0x19bc8, 0x1cde6, 0x19bc4, 0x189c2, 0x19bc2, 0x113d0, 0x189ec, + 0x137d0, 0x113c8, 0x189e6, 0x137c8, 0x19be6, 0x137c4, 0x113c2, 0x137c2, + 0x113ec, 0x137ec, 0x113e6, 0x137e6, 0x1fba8, 0x175f0, 0x1bafc, 0x1fba4, + 0x174f8, 0x1ba7e, 0x1fba2, 0x1747c, 0x1743e, 0x1f328, 0x1f996, 0x132fc, + 0x1f768, 0x1fbb6, 0x176fc, 0x1327e, 0x1f764, 0x1f322, 0x1767e, 0x1f762, + 0x1e228, 0x1f116, 0x1e668, 0x1e224, 0x1eee8, 0x1f776, 0x1e222, 0x1eee4, + 0x1e662, 0x1eee2, 0x1c468, 0x1e236, 0x1cce8, 0x1c464, 0x1dde8, 0x1cce4, + 0x1c462, 0x1dde4, 0x1cce2, 0x1dde2, 0x188e8, 0x1c476, 0x199e8, 0x188e4, + 0x1bbe8, 0x199e4, 0x188e2, 0x1bbe4, 0x199e2, 0x1bbe2, 0x111e8, 0x188f6, + 0x133e8, 0x111e4, 0x177e8, 0x133e4, 0x111e2, 0x177e4, 0x133e2, 0x177e2, + 0x111f6, 0x133f6, 0x1fb94, 0x172f8, 0x1b97e, 0x1fb92, 0x1727c, 0x1723e, + 0x1f314, 0x1317e, 0x1f734, 0x1f312, 0x1737e, 0x1f732, 0x1e214, 0x1e634, + 0x1e212, 0x1ee74, 0x1e632, 0x1ee72, 0x1c434, 0x1cc74, 0x1c432, 0x1dcf4, + 0x1cc72, 0x1dcf2, 0x18874, 0x198f4, 0x18872, 0x1b9f4, 0x198f2, 0x1b9f2, + 0x110f4, 0x131f4, 0x110f2, 0x173f4, 0x131f2, 0x173f2, 0x1fb8a, 0x1717c, + 0x1713e, 0x1f30a, 0x1f71a, 0x1e20a, 0x1e61a, 0x1ee3a, 0x1c41a, 0x1cc3a, + 0x1dc7a, 0x1883a, 0x1987a, 0x1b8fa, 0x1107a, 0x130fa, 0x171fa, 0x170be, + 0x1e150, 0x1f0ac, 0x1e148, 0x1f0a6, 0x1e144, 0x1e142, 0x1c2d0, 0x1e16c, + 0x1c2c8, 0x1e166, 0x1c2c4, 0x1c2c2, 0x185d0, 0x1c2ec, 0x185c8, 0x1c2e6, + 0x185c4, 0x185c2, 0x10bd0, 0x185ec, 0x10bc8, 0x185e6, 0x10bc4, 0x10bc2, + 0x10bec, 0x10be6, 0x1f1a8, 0x1f8d6, 0x11afc, 0x1f1a4, 0x11a7e, 0x1f1a2, + 0x1e128, 0x1f096, 0x1e368, 0x1e124, 0x1e364, 0x1e122, 0x1e362, 0x1c268, + 0x1e136, 0x1c6e8, 0x1c264, 0x1c6e4, 0x1c262, 0x1c6e2, 0x184e8, 0x1c276, + 0x18de8, 0x184e4, 0x18de4, 0x184e2, 0x18de2, 0x109e8, 0x184f6, 0x11be8, + 0x109e4, 0x11be4, 0x109e2, 0x11be2, 0x109f6, 0x11bf6, 0x1f9d4, 0x13af8, + 0x19d7e, 0x1f9d2, 0x13a7c, 0x13a3e, 0x1f194, 0x1197e, 0x1f3b4, 0x1f192, + 0x13b7e, 0x1f3b2, 0x1e114, 0x1e334, 0x1e112, 0x1e774, 0x1e332, 0x1e772, + 0x1c234, 0x1c674, 0x1c232, 0x1cef4, 0x1c672, 0x1cef2, 0x18474, 0x18cf4, + 0x18472, 0x19df4, 0x18cf2, 0x19df2, 0x108f4, 0x119f4, 0x108f2, 0x13bf4, + 0x119f2, 0x13bf2, 0x17af0, 0x1bd7c, 0x17a78, 0x1bd3e, 0x17a3c, 0x17a1e, + 0x1f9ca, 0x1397c, 0x1fbda, 0x17b7c, 0x1393e, 0x17b3e, 0x1f18a, 0x1f39a, + 0x1f7ba, 0x1e10a, 0x1e31a, 0x1e73a, 0x1ef7a, 0x1c21a, 0x1c63a, 0x1ce7a, + 0x1defa, 0x1843a, 0x18c7a, 0x19cfa, 0x1bdfa, 0x1087a, 0x118fa, 0x139fa, + 0x17978, 0x1bcbe, 0x1793c, 0x1791e, 0x138be, 0x179be, 0x178bc, 0x1789e, + 0x1785e, 0x1e0a8, 0x1e0a4, 0x1e0a2, 0x1c168, 0x1e0b6, 0x1c164, 0x1c162, + 0x182e8, 0x1c176, 0x182e4, 0x182e2, 0x105e8, 0x182f6, 0x105e4, 0x105e2, + 0x105f6, 0x1f0d4, 0x10d7e, 0x1f0d2, 0x1e094, 0x1e1b4, 0x1e092, 0x1e1b2, + 0x1c134, 0x1c374, 0x1c132, 0x1c372, 0x18274, 0x186f4, 0x18272, 0x186f2, + 0x104f4, 0x10df4, 0x104f2, 0x10df2, 0x1f8ea, 0x11d7c, 0x11d3e, 0x1f0ca, + 0x1f1da, 0x1e08a, 0x1e19a, 0x1e3ba, 0x1c11a, 0x1c33a, 0x1c77a, 0x1823a, + 0x1867a, 0x18efa, 0x1047a, 0x10cfa, 0x11dfa, 0x13d78, 0x19ebe, 0x13d3c, + 0x13d1e, 0x11cbe, 0x13dbe, 0x17d70, 0x1bebc, 0x17d38, 0x1be9e, 0x17d1c, + 0x17d0e, 0x13cbc, 0x17dbc, 0x13c9e, 0x17d9e, 0x17cb8, 0x1be5e, 0x17c9c, + 0x17c8e, 0x13c5e, 0x17cde, 0x17c5c, 0x17c4e, 0x17c2e, 0x1c0b4, 0x1c0b2, + 0x18174, 0x18172, 0x102f4, 0x102f2, 0x1e0da, 0x1c09a, 0x1c1ba, 0x1813a, + 0x1837a, 0x1027a, 0x106fa, 0x10ebe, 0x11ebc, 0x11e9e, 0x13eb8, 0x19f5e, + 0x13e9c, 0x13e8e, 0x11e5e, 0x13ede, 0x17eb0, 0x1bf5c, 0x17e98, 0x1bf4e, + 0x17e8c, 0x17e86, 0x13e5c, 0x17edc, 0x13e4e, 0x17ece, 0x17e58, 0x1bf2e, + 0x17e4c, 0x17e46, 0x13e2e, 0x17e6e, 0x17e2c, 0x17e26, 0x10f5e, 0x11f5c, + 0x11f4e, 0x13f58, 0x19fae, 0x13f4c, 0x13f46, 0x11f2e, 0x13f6e, 0x13f2c, + 0x13f26}, + {0x1abe0, 0x1d5f8, 0x153c0, 0x1a9f0, 0x1d4fc, 0x151e0, 0x1a8f8, 0x1d47e, + 0x150f0, 0x1a87c, 0x15078, 0x1fad0, 0x15be0, 0x1adf8, 0x1fac8, 0x159f0, + 0x1acfc, 0x1fac4, 0x158f8, 0x1ac7e, 0x1fac2, 0x1587c, 0x1f5d0, 0x1faec, + 0x15df8, 0x1f5c8, 0x1fae6, 0x15cfc, 0x1f5c4, 0x15c7e, 0x1f5c2, 0x1ebd0, + 0x1f5ec, 0x1ebc8, 0x1f5e6, 0x1ebc4, 0x1ebc2, 0x1d7d0, 0x1ebec, 0x1d7c8, + 0x1ebe6, 0x1d7c4, 0x1d7c2, 0x1afd0, 0x1d7ec, 0x1afc8, 0x1d7e6, 0x1afc4, + 0x14bc0, 0x1a5f0, 0x1d2fc, 0x149e0, 0x1a4f8, 0x1d27e, 0x148f0, 0x1a47c, + 0x14878, 0x1a43e, 0x1483c, 0x1fa68, 0x14df0, 0x1a6fc, 0x1fa64, 0x14cf8, + 0x1a67e, 0x1fa62, 0x14c7c, 0x14c3e, 0x1f4e8, 0x1fa76, 0x14efc, 0x1f4e4, + 0x14e7e, 0x1f4e2, 0x1e9e8, 0x1f4f6, 0x1e9e4, 0x1e9e2, 0x1d3e8, 0x1e9f6, + 0x1d3e4, 0x1d3e2, 0x1a7e8, 0x1d3f6, 0x1a7e4, 0x1a7e2, 0x145e0, 0x1a2f8, + 0x1d17e, 0x144f0, 0x1a27c, 0x14478, 0x1a23e, 0x1443c, 0x1441e, 0x1fa34, + 0x146f8, 0x1a37e, 0x1fa32, 0x1467c, 0x1463e, 0x1f474, 0x1477e, 0x1f472, + 0x1e8f4, 0x1e8f2, 0x1d1f4, 0x1d1f2, 0x1a3f4, 0x1a3f2, 0x142f0, 0x1a17c, + 0x14278, 0x1a13e, 0x1423c, 0x1421e, 0x1fa1a, 0x1437c, 0x1433e, 0x1f43a, + 0x1e87a, 0x1d0fa, 0x14178, 0x1a0be, 0x1413c, 0x1411e, 0x141be, 0x140bc, + 0x1409e, 0x12bc0, 0x195f0, 0x1cafc, 0x129e0, 0x194f8, 0x1ca7e, 0x128f0, + 0x1947c, 0x12878, 0x1943e, 0x1283c, 0x1f968, 0x12df0, 0x196fc, 0x1f964, + 0x12cf8, 0x1967e, 0x1f962, 0x12c7c, 0x12c3e, 0x1f2e8, 0x1f976, 0x12efc, + 0x1f2e4, 0x12e7e, 0x1f2e2, 0x1e5e8, 0x1f2f6, 0x1e5e4, 0x1e5e2, 0x1cbe8, + 0x1e5f6, 0x1cbe4, 0x1cbe2, 0x197e8, 0x1cbf6, 0x197e4, 0x197e2, 0x1b5e0, + 0x1daf8, 0x1ed7e, 0x169c0, 0x1b4f0, 0x1da7c, 0x168e0, 0x1b478, 0x1da3e, + 0x16870, 0x1b43c, 0x16838, 0x1b41e, 0x1681c, 0x125e0, 0x192f8, 0x1c97e, + 0x16de0, 0x124f0, 0x1927c, 0x16cf0, 0x1b67c, 0x1923e, 0x16c78, 0x1243c, + 0x16c3c, 0x1241e, 0x16c1e, 0x1f934, 0x126f8, 0x1937e, 0x1fb74, 0x1f932, + 0x16ef8, 0x1267c, 0x1fb72, 0x16e7c, 0x1263e, 0x16e3e, 0x1f274, 0x1277e, + 0x1f6f4, 0x1f272, 0x16f7e, 0x1f6f2, 0x1e4f4, 0x1edf4, 0x1e4f2, 0x1edf2, + 0x1c9f4, 0x1dbf4, 0x1c9f2, 0x1dbf2, 0x193f4, 0x193f2, 0x165c0, 0x1b2f0, + 0x1d97c, 0x164e0, 0x1b278, 0x1d93e, 0x16470, 0x1b23c, 0x16438, 0x1b21e, + 0x1641c, 0x1640e, 0x122f0, 0x1917c, 0x166f0, 0x12278, 0x1913e, 0x16678, + 0x1b33e, 0x1663c, 0x1221e, 0x1661e, 0x1f91a, 0x1237c, 0x1fb3a, 0x1677c, + 0x1233e, 0x1673e, 0x1f23a, 0x1f67a, 0x1e47a, 0x1ecfa, 0x1c8fa, 0x1d9fa, + 0x191fa, 0x162e0, 0x1b178, 0x1d8be, 0x16270, 0x1b13c, 0x16238, 0x1b11e, + 0x1621c, 0x1620e, 0x12178, 0x190be, 0x16378, 0x1213c, 0x1633c, 0x1211e, + 0x1631e, 0x121be, 0x163be, 0x16170, 0x1b0bc, 0x16138, 0x1b09e, 0x1611c, + 0x1610e, 0x120bc, 0x161bc, 0x1209e, 0x1619e, 0x160b8, 0x1b05e, 0x1609c, + 0x1608e, 0x1205e, 0x160de, 0x1605c, 0x1604e, 0x115e0, 0x18af8, 0x1c57e, + 0x114f0, 0x18a7c, 0x11478, 0x18a3e, 0x1143c, 0x1141e, 0x1f8b4, 0x116f8, + 0x18b7e, 0x1f8b2, 0x1167c, 0x1163e, 0x1f174, 0x1177e, 0x1f172, 0x1e2f4, + 0x1e2f2, 0x1c5f4, 0x1c5f2, 0x18bf4, 0x18bf2, 0x135c0, 0x19af0, 0x1cd7c, + 0x134e0, 0x19a78, 0x1cd3e, 0x13470, 0x19a3c, 0x13438, 0x19a1e, 0x1341c, + 0x1340e, 0x112f0, 0x1897c, 0x136f0, 0x11278, 0x1893e, 0x13678, 0x19b3e, + 0x1363c, 0x1121e, 0x1361e, 0x1f89a, 0x1137c, 0x1f9ba, 0x1377c, 0x1133e, + 0x1373e, 0x1f13a, 0x1f37a, 0x1e27a, 0x1e6fa, 0x1c4fa, 0x1cdfa, 0x189fa, + 0x1bae0, 0x1dd78, 0x1eebe, 0x174c0, 0x1ba70, 0x1dd3c, 0x17460, 0x1ba38, + 0x1dd1e, 0x17430, 0x1ba1c, 0x17418, 0x1ba0e, 0x1740c, 0x132e0, 0x19978, + 0x1ccbe, 0x176e0, 0x13270, 0x1993c, 0x17670, 0x1bb3c, 0x1991e, 0x17638, + 0x1321c, 0x1761c, 0x1320e, 0x1760e, 0x11178, 0x188be, 0x13378, 0x1113c, + 0x17778, 0x1333c, 0x1111e, 0x1773c, 0x1331e, 0x1771e, 0x111be, 0x133be, + 0x177be, 0x172c0, 0x1b970, 0x1dcbc, 0x17260, 0x1b938, 0x1dc9e, 0x17230, + 0x1b91c, 0x17218, 0x1b90e, 0x1720c, 0x17206, 0x13170, 0x198bc, 0x17370, + 0x13138, 0x1989e, 0x17338, 0x1b99e, 0x1731c, 0x1310e, 0x1730e, 0x110bc, + 0x131bc, 0x1109e, 0x173bc, 0x1319e, 0x1739e, 0x17160, 0x1b8b8, 0x1dc5e, + 0x17130, 0x1b89c, 0x17118, 0x1b88e, 0x1710c, 0x17106, 0x130b8, 0x1985e, + 0x171b8, 0x1309c, 0x1719c, 0x1308e, 0x1718e, 0x1105e, 0x130de, 0x171de, + 0x170b0, 0x1b85c, 0x17098, 0x1b84e, 0x1708c, 0x17086, 0x1305c, 0x170dc, + 0x1304e, 0x170ce, 0x17058, 0x1b82e, 0x1704c, 0x17046, 0x1302e, 0x1706e, + 0x1702c, 0x17026, 0x10af0, 0x1857c, 0x10a78, 0x1853e, 0x10a3c, 0x10a1e, + 0x10b7c, 0x10b3e, 0x1f0ba, 0x1e17a, 0x1c2fa, 0x185fa, 0x11ae0, 0x18d78, + 0x1c6be, 0x11a70, 0x18d3c, 0x11a38, 0x18d1e, 0x11a1c, 0x11a0e, 0x10978, + 0x184be, 0x11b78, 0x1093c, 0x11b3c, 0x1091e, 0x11b1e, 0x109be, 0x11bbe, + 0x13ac0, 0x19d70, 0x1cebc, 0x13a60, 0x19d38, 0x1ce9e, 0x13a30, 0x19d1c, + 0x13a18, 0x19d0e, 0x13a0c, 0x13a06, 0x11970, 0x18cbc, 0x13b70, 0x11938, + 0x18c9e, 0x13b38, 0x1191c, 0x13b1c, 0x1190e, 0x13b0e, 0x108bc, 0x119bc, + 0x1089e, 0x13bbc, 0x1199e, 0x13b9e, 0x1bd60, 0x1deb8, 0x1ef5e, 0x17a40, + 0x1bd30, 0x1de9c, 0x17a20, 0x1bd18, 0x1de8e, 0x17a10, 0x1bd0c, 0x17a08, + 0x1bd06, 0x17a04, 0x13960, 0x19cb8, 0x1ce5e, 0x17b60, 0x13930, 0x19c9c, + 0x17b30, 0x1bd9c, 0x19c8e, 0x17b18, 0x1390c, 0x17b0c, 0x13906, 0x17b06, + 0x118b8, 0x18c5e, 0x139b8, 0x1189c, 0x17bb8, 0x1399c, 0x1188e, 0x17b9c, + 0x1398e, 0x17b8e, 0x1085e, 0x118de, 0x139de, 0x17bde, 0x17940, 0x1bcb0, + 0x1de5c, 0x17920, 0x1bc98, 0x1de4e, 0x17910, 0x1bc8c, 0x17908, 0x1bc86, + 0x17904, 0x17902, 0x138b0, 0x19c5c, 0x179b0, 0x13898, 0x19c4e, 0x17998, + 0x1bcce, 0x1798c, 0x13886, 0x17986, 0x1185c, 0x138dc, 0x1184e, 0x179dc, + 0x138ce, 0x179ce, 0x178a0, 0x1bc58, 0x1de2e, 0x17890, 0x1bc4c, 0x17888, + 0x1bc46, 0x17884, 0x17882, 0x13858, 0x19c2e, 0x178d8, 0x1384c, 0x178cc, + 0x13846, 0x178c6, 0x1182e, 0x1386e, 0x178ee, 0x17850, 0x1bc2c, 0x17848, + 0x1bc26, 0x17844, 0x17842, 0x1382c, 0x1786c, 0x13826, 0x17866, 0x17828, + 0x1bc16, 0x17824, 0x17822, 0x13816, 0x17836, 0x10578, 0x182be, 0x1053c, + 0x1051e, 0x105be, 0x10d70, 0x186bc, 0x10d38, 0x1869e, 0x10d1c, 0x10d0e, + 0x104bc, 0x10dbc, 0x1049e, 0x10d9e, 0x11d60, 0x18eb8, 0x1c75e, 0x11d30, + 0x18e9c, 0x11d18, 0x18e8e, 0x11d0c, 0x11d06, 0x10cb8, 0x1865e, 0x11db8, + 0x10c9c, 0x11d9c, 0x10c8e, 0x11d8e, 0x1045e, 0x10cde, 0x11dde, 0x13d40, + 0x19eb0, 0x1cf5c, 0x13d20, 0x19e98, 0x1cf4e, 0x13d10, 0x19e8c, 0x13d08, + 0x19e86, 0x13d04, 0x13d02, 0x11cb0, 0x18e5c, 0x13db0, 0x11c98, 0x18e4e, + 0x13d98, 0x19ece, 0x13d8c, 0x11c86, 0x13d86, 0x10c5c, 0x11cdc, 0x10c4e, + 0x13ddc, 0x11cce, 0x13dce, 0x1bea0, 0x1df58, 0x1efae, 0x1be90, 0x1df4c, + 0x1be88, 0x1df46, 0x1be84, 0x1be82, 0x13ca0, 0x19e58, 0x1cf2e, 0x17da0, + 0x13c90, 0x19e4c, 0x17d90, 0x1becc, 0x19e46, 0x17d88, 0x13c84, 0x17d84, + 0x13c82, 0x17d82, 0x11c58, 0x18e2e, 0x13cd8, 0x11c4c, 0x17dd8, 0x13ccc, + 0x11c46, 0x17dcc, 0x13cc6, 0x17dc6, 0x10c2e, 0x11c6e, 0x13cee, 0x17dee, + 0x1be50, 0x1df2c, 0x1be48, 0x1df26, 0x1be44, 0x1be42, 0x13c50, 0x19e2c, + 0x17cd0, 0x13c48, 0x19e26, 0x17cc8, 0x1be66, 0x17cc4, 0x13c42, 0x17cc2, + 0x11c2c, 0x13c6c, 0x11c26, 0x17cec, 0x13c66, 0x17ce6, 0x1be28, 0x1df16, + 0x1be24, 0x1be22, 0x13c28, 0x19e16, 0x17c68, 0x13c24, 0x17c64, 0x13c22, + 0x17c62, 0x11c16, 0x13c36, 0x17c76, 0x1be14, 0x1be12, 0x13c14, 0x17c34, + 0x13c12, 0x17c32, 0x102bc, 0x1029e, 0x106b8, 0x1835e, 0x1069c, 0x1068e, + 0x1025e, 0x106de, 0x10eb0, 0x1875c, 0x10e98, 0x1874e, 0x10e8c, 0x10e86, + 0x1065c, 0x10edc, 0x1064e, 0x10ece, 0x11ea0, 0x18f58, 0x1c7ae, 0x11e90, + 0x18f4c, 0x11e88, 0x18f46, 0x11e84, 0x11e82, 0x10e58, 0x1872e, 0x11ed8, + 0x18f6e, 0x11ecc, 0x10e46, 0x11ec6, 0x1062e, 0x10e6e, 0x11eee, 0x19f50, + 0x1cfac, 0x19f48, 0x1cfa6, 0x19f44, 0x19f42, 0x11e50, 0x18f2c, 0x13ed0, + 0x19f6c, 0x18f26, 0x13ec8, 0x11e44, 0x13ec4, 0x11e42, 0x13ec2, 0x10e2c, + 0x11e6c, 0x10e26, 0x13eec, 0x11e66, 0x13ee6, 0x1dfa8, 0x1efd6, 0x1dfa4, + 0x1dfa2, 0x19f28, 0x1cf96, 0x1bf68, 0x19f24, 0x1bf64, 0x19f22, 0x1bf62, + 0x11e28, 0x18f16, 0x13e68, 0x11e24, 0x17ee8, 0x13e64, 0x11e22, 0x17ee4, + 0x13e62, 0x17ee2, 0x10e16, 0x11e36, 0x13e76, 0x17ef6, 0x1df94, 0x1df92, + 0x19f14, 0x1bf34, 0x19f12, 0x1bf32, 0x11e14, 0x13e34, 0x11e12, 0x17e74, + 0x13e32, 0x17e72, 0x1df8a, 0x19f0a, 0x1bf1a, 0x11e0a, 0x13e1a, 0x17e3a, + 0x1035c, 0x1034e, 0x10758, 0x183ae, 0x1074c, 0x10746, 0x1032e, 0x1076e, + 0x10f50, 0x187ac, 0x10f48, 0x187a6, 0x10f44, 0x10f42, 0x1072c, 0x10f6c, + 0x10726, 0x10f66, 0x18fa8, 0x1c7d6, 0x18fa4, 0x18fa2, 0x10f28, 0x18796, + 0x11f68, 0x18fb6, 0x11f64, 0x10f22, 0x11f62, 0x10716, 0x10f36, 0x11f76, + 0x1cfd4, 0x1cfd2, 0x18f94, 0x19fb4, 0x18f92, 0x19fb2, 0x10f14, 0x11f34, + 0x10f12, 0x13f74, 0x11f32, 0x13f72, 0x1cfca, 0x18f8a, 0x19f9a, 0x10f0a, + 0x11f1a, 0x13f3a, 0x103ac, 0x103a6, 0x107a8, 0x183d6, 0x107a4, 0x107a2, + 0x10396, 0x107b6, 0x187d4, 0x187d2, 0x10794, 0x10fb4, 0x10792, 0x10fb2, + 0x1c7ea}}; +FX_FLOAT CBC_PDF417::PREFERRED_RATIO = 3.0f; +FX_FLOAT CBC_PDF417::DEFAULT_MODULE_WIDTH = 0.357f; +FX_FLOAT CBC_PDF417::HEIGHT = 2.0f; +CBC_PDF417::CBC_PDF417() { + m_compact = FALSE; + m_compaction = AUTO; + m_minCols = 1; + m_maxCols = 30; + m_maxRows = 90; + m_minRows = 3; + m_barcodeMatrix = NULL; +} +CBC_PDF417::CBC_PDF417(FX_BOOL compact) { + m_compact = compact; + m_compaction = AUTO; + m_minCols = 1; + m_maxCols = 30; + m_maxRows = 90; + m_minRows = 3; + m_barcodeMatrix = NULL; +} +CBC_PDF417::~CBC_PDF417() { + if (m_barcodeMatrix) { + delete m_barcodeMatrix; + } +} +CBC_BarcodeMatrix* CBC_PDF417::getBarcodeMatrix() { + return m_barcodeMatrix; +} +void CBC_PDF417::generateBarcodeLogic(CFX_WideString msg, + int32_t errorCorrectionLevel, + int32_t& e) { + int32_t errorCorrectionCodeWords = + CBC_PDF417ErrorCorrection::getErrorCorrectionCodewordCount( + errorCorrectionLevel, e); + BC_EXCEPTION_CHECK_ReturnVoid(e); + CFX_WideString highLevel = + CBC_PDF417HighLevelEncoder::encodeHighLevel(msg, m_compaction, e); + BC_EXCEPTION_CHECK_ReturnVoid(e); + int32_t sourceCodeWords = highLevel.GetLength(); + CFX_Int32Array* dimension = + determineDimensions(sourceCodeWords, errorCorrectionCodeWords, e); + BC_EXCEPTION_CHECK_ReturnVoid(e); + int32_t cols = dimension->GetAt(0); + int32_t rows = dimension->GetAt(1); + delete dimension; + int32_t pad = getNumberOfPadCodewords(sourceCodeWords, + errorCorrectionCodeWords, cols, rows); + if (sourceCodeWords + errorCorrectionCodeWords + 1 > 929) { + e = BCExceptionEncodedMessageContainsTooManyCodeWords; + return; + } + int32_t n = sourceCodeWords + pad + 1; + CFX_WideString sb; + sb += (FX_WCHAR)n; + sb += highLevel; + for (int32_t i = 0; i < pad; i++) { + sb += (FX_WCHAR)900; + } + CFX_WideString dataCodewords(sb); + CFX_WideString ec = CBC_PDF417ErrorCorrection::generateErrorCorrection( + dataCodewords, errorCorrectionLevel, e); + BC_EXCEPTION_CHECK_ReturnVoid(e); + CFX_WideString fullCodewords = dataCodewords + ec; + m_barcodeMatrix = new CBC_BarcodeMatrix(rows, cols); + encodeLowLevel(fullCodewords, cols, rows, errorCorrectionLevel, + m_barcodeMatrix); +} +void CBC_PDF417::setDimensions(int32_t maxCols, + int32_t minCols, + int32_t maxRows, + int32_t minRows) { + m_maxCols = maxCols; + m_minCols = minCols; + m_maxRows = maxRows; + m_minRows = minRows; +} +void CBC_PDF417::setCompaction(Compaction compaction) { + m_compaction = compaction; +} +void CBC_PDF417::setCompact(FX_BOOL compact) { + m_compact = compact; +} +int32_t CBC_PDF417::calculateNumberOfRows(int32_t m, int32_t k, int32_t c) { + int32_t r = ((m + 1 + k) / c) + 1; + if (c * r >= (m + 1 + k + c)) { + r--; + } + return r; +} +int32_t CBC_PDF417::getNumberOfPadCodewords(int32_t m, + int32_t k, + int32_t c, + int32_t r) { + int32_t n = c * r - k; + return n > m + 1 ? n - m - 1 : 0; +} +void CBC_PDF417::encodeChar(int32_t pattern, + int32_t len, + CBC_BarcodeRow* logic) { + int32_t map = 1 << (len - 1); + FX_BOOL last = ((pattern & map) != 0); + int32_t width = 0; + for (int32_t i = 0; i < len; i++) { + FX_BOOL black = ((pattern & map) != 0); + if (last == black) { + width++; + } else { + logic->addBar(last, width); + last = black; + width = 1; + } + map >>= 1; + } + logic->addBar(last, width); +} +void CBC_PDF417::encodeLowLevel(CFX_WideString fullCodewords, + int32_t c, + int32_t r, + int32_t errorCorrectionLevel, + CBC_BarcodeMatrix* logic) { + int32_t idx = 0; + for (int32_t y = 0; y < r; y++) { + int32_t cluster = y % 3; + logic->startRow(); + encodeChar(START_PATTERN, 17, logic->getCurrentRow()); + int32_t left; + int32_t right; + if (cluster == 0) { + left = (30 * (y / 3)) + ((r - 1) / 3); + right = (30 * (y / 3)) + (c - 1); + } else if (cluster == 1) { + left = (30 * (y / 3)) + (errorCorrectionLevel * 3) + ((r - 1) % 3); + right = (30 * (y / 3)) + ((r - 1) / 3); + } else { + left = (30 * (y / 3)) + (c - 1); + right = (30 * (y / 3)) + (errorCorrectionLevel * 3) + ((r - 1) % 3); + } + int32_t pattern = CODEWORD_TABLE[cluster][left]; + encodeChar(pattern, 17, logic->getCurrentRow()); + for (int32_t x = 0; x < c; x++) { + pattern = CODEWORD_TABLE[cluster][fullCodewords.GetAt(idx)]; + encodeChar(pattern, 17, logic->getCurrentRow()); + idx++; + } + if (m_compact) { + encodeChar(STOP_PATTERN, 1, logic->getCurrentRow()); + } else { + pattern = CODEWORD_TABLE[cluster][right]; + encodeChar(pattern, 17, logic->getCurrentRow()); + encodeChar(STOP_PATTERN, 18, logic->getCurrentRow()); + } + } +} +CFX_Int32Array* CBC_PDF417::determineDimensions( + int32_t sourceCodeWords, + int32_t errorCorrectionCodeWords, + int32_t& e) { + FX_FLOAT ratio = 0.0f; + CFX_Int32Array* dimension = NULL; + for (int32_t cols = m_minCols; cols <= m_maxCols; cols++) { + int32_t rows = + calculateNumberOfRows(sourceCodeWords, errorCorrectionCodeWords, cols); + if (rows < m_minRows) { + break; + } + if (rows > m_maxRows) { + continue; + } + FX_FLOAT newRatio = + ((17 * cols + 69) * DEFAULT_MODULE_WIDTH) / (rows * HEIGHT); + if (dimension && + fabsf(newRatio - PREFERRED_RATIO) > fabsf(ratio - PREFERRED_RATIO)) { + continue; + } + ratio = newRatio; + if (dimension) { + delete dimension; + } + dimension = new CFX_Int32Array; + dimension->Add(cols); + dimension->Add(rows); + } + if (dimension == NULL) { + int32_t rows = calculateNumberOfRows(sourceCodeWords, + errorCorrectionCodeWords, m_minCols); + if (rows < m_minRows) { + dimension = new CFX_Int32Array; + dimension->Add(m_minCols); + dimension->Add(m_minRows); + } else if (rows >= 3 && rows <= 90) { + dimension = new CFX_Int32Array; + dimension->Add(m_minCols); + dimension->Add(rows); + } + } + if (dimension == NULL) { + e = BCExceptionUnableToFitMessageInColumns; + return NULL; + } + return dimension; +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417.h b/xfa/fxbarcode/pdf417/BC_PDF417.h new file mode 100644 index 0000000000..fe279db21b --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417.h @@ -0,0 +1,64 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417_H_ + +#include "core/include/fxcrt/fx_basic.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417Compaction.h" + +class CBC_BarcodeRow; +class CBC_BarcodeMatrix; + +class CBC_PDF417 { + public: + CBC_PDF417(); + CBC_PDF417(FX_BOOL compact); + virtual ~CBC_PDF417(); + CBC_BarcodeMatrix* getBarcodeMatrix(); + void generateBarcodeLogic(CFX_WideString msg, + int32_t errorCorrectionLevel, + int32_t& e); + void setDimensions(int32_t maxCols, + int32_t minCols, + int32_t maxRows, + int32_t minRows); + void setCompaction(Compaction compaction); + void setCompact(FX_BOOL compact); + + private: + static int32_t START_PATTERN; + static int32_t STOP_PATTERN; + static int32_t CODEWORD_TABLE[][1000]; + static FX_FLOAT PREFERRED_RATIO; + static FX_FLOAT DEFAULT_MODULE_WIDTH; + static FX_FLOAT HEIGHT; + CBC_BarcodeMatrix* m_barcodeMatrix; + FX_BOOL m_compact; + Compaction m_compaction; + int32_t m_minCols; + int32_t m_maxCols; + int32_t m_maxRows; + int32_t m_minRows; + + private: + static int32_t calculateNumberOfRows(int32_t m, int32_t k, int32_t c); + static int32_t getNumberOfPadCodewords(int32_t m, + int32_t k, + int32_t c, + int32_t r); + static void encodeChar(int32_t pattern, int32_t len, CBC_BarcodeRow* logic); + void encodeLowLevel(CFX_WideString fullCodewords, + int32_t c, + int32_t r, + int32_t errorCorrectionLevel, + CBC_BarcodeMatrix* logic); + CFX_Int32Array* determineDimensions(int32_t sourceCodeWords, + int32_t errorCorrectionCodeWords, + int32_t& e); +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.cpp b/xfa/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.cpp new file mode 100644 index 0000000000..47255fac71 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.cpp @@ -0,0 +1,90 @@ +// 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 2011 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_PDF417BarcodeMatrix.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417BarcodeRow.h" + +CBC_BarcodeMatrix::CBC_BarcodeMatrix(int32_t height, int32_t width) { + m_matrix.SetSize(height + 2); + for (int32_t i = 0, matrixLength = m_matrix.GetSize(); i < matrixLength; + i++) { + m_matrix[i] = new CBC_BarcodeRow((width + 4) * 17 + 1); + } + m_width = width * 17; + m_height = height + 2; + m_currentRow = 0; + m_outHeight = 0; + m_outWidth = 0; +} +CBC_BarcodeMatrix::~CBC_BarcodeMatrix() { + for (int32_t i = 0; i < m_matrix.GetSize(); i++) { + delete (CBC_BarcodeRow*)m_matrix.GetAt(i); + } + m_matrix.RemoveAll(); + m_matrixOut.RemoveAll(); +} +void CBC_BarcodeMatrix::set(int32_t x, int32_t y, uint8_t value) { + ((CBC_BarcodeRow*)m_matrix[y])->set(x, value); +} +void CBC_BarcodeMatrix::setMatrix(int32_t x, int32_t y, FX_BOOL black) { + set(x, y, (uint8_t)(black ? 1 : 0)); +} +void CBC_BarcodeMatrix::startRow() { + ++m_currentRow; +} +CBC_BarcodeRow* CBC_BarcodeMatrix::getCurrentRow() { + return (CBC_BarcodeRow*)m_matrix[m_currentRow]; +} +int32_t CBC_BarcodeMatrix::getWidth() { + return m_outWidth; +} +int32_t CBC_BarcodeMatrix::getHeight() { + return m_outHeight; +} +CFX_ByteArray& CBC_BarcodeMatrix::getMatrix() { + return getScaledMatrix(1, 1); +} +CFX_ByteArray& CBC_BarcodeMatrix::getScaledMatrix(int32_t scale) { + return getScaledMatrix(scale, scale); +} +CFX_ByteArray& CBC_BarcodeMatrix::getScaledMatrix(int32_t xScale, + int32_t yScale) { + int32_t yMax = m_height * yScale; + CFX_ByteArray bytearray; + bytearray.Copy(((CBC_BarcodeRow*)m_matrix[0])->getScaledRow(xScale)); + int32_t xMax = bytearray.GetSize(); + m_matrixOut.SetSize(xMax * yMax); + m_outWidth = xMax; + m_outHeight = yMax; + int32_t k = 0; + for (int32_t i = 0; i < yMax; i++) { + if (i != 0) { + bytearray.Copy( + ((CBC_BarcodeRow*)m_matrix[i / yScale])->getScaledRow(xScale)); + } + k = i * xMax; + for (int32_t l = 0; l < xMax; l++) { + m_matrixOut[k + l] = bytearray.GetAt(l); + } + } + return m_matrixOut; +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.h b/xfa/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.h new file mode 100644 index 0000000000..21ee44b65f --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.h @@ -0,0 +1,38 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417BARCODEMATRIX_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417BARCODEMATRIX_H_ + +#include "core/include/fxcrt/fx_basic.h" + +class CBC_BarcodeRow; +class CBC_BarcodeMatrix { + public: + CBC_BarcodeMatrix(); + CBC_BarcodeMatrix(int32_t height, int32_t width); + virtual ~CBC_BarcodeMatrix(); + void set(int32_t x, int32_t y, uint8_t value); + void setMatrix(int32_t x, int32_t y, FX_BOOL black); + void startRow(); + CBC_BarcodeRow* getCurrentRow(); + CFX_ByteArray& getMatrix(); + CFX_ByteArray& getScaledMatrix(int32_t scale); + CFX_ByteArray& getScaledMatrix(int32_t xScale, int32_t yScale); + int32_t getWidth(); + int32_t getHeight(); + + private: + CFX_PtrArray m_matrix; + CFX_ByteArray m_matrixOut; + int32_t m_currentRow; + int32_t m_height; + int32_t m_width; + int32_t m_outWidth; + int32_t m_outHeight; +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417BARCODEMATRIX_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417BarcodeMetadata.cpp b/xfa/fxbarcode/pdf417/BC_PDF417BarcodeMetadata.cpp new file mode 100644 index 0000000000..ac59c6ef94 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417BarcodeMetadata.cpp @@ -0,0 +1,50 @@ +// 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 2013 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_PDF417BarcodeMetadata.h" + +CBC_BarcodeMetadata::CBC_BarcodeMetadata(int32_t columnCount, + int32_t rowCountUpperPart, + int32_t rowCountLowerPart, + int32_t errorCorrectionLevel) { + m_columnCount = columnCount; + m_rowCountUpperPart = rowCountUpperPart; + m_rowCountLowerPart = rowCountLowerPart; + m_errorCorrectionLevel = errorCorrectionLevel; + m_rowCount = m_rowCountUpperPart + m_rowCountLowerPart; +} +CBC_BarcodeMetadata::~CBC_BarcodeMetadata() {} +int32_t CBC_BarcodeMetadata::getColumnCount() { + return m_columnCount; +} +int32_t CBC_BarcodeMetadata::getErrorCorrectionLevel() { + return m_errorCorrectionLevel; +} +int32_t CBC_BarcodeMetadata::getRowCount() { + return m_rowCount; +} +int32_t CBC_BarcodeMetadata::getRowCountUpperPart() { + return m_rowCountUpperPart; +} +int32_t CBC_BarcodeMetadata::getRowCountLowerPart() { + return m_rowCountLowerPart; +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417BarcodeMetadata.h b/xfa/fxbarcode/pdf417/BC_PDF417BarcodeMetadata.h new file mode 100644 index 0000000000..2b398f13f6 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417BarcodeMetadata.h @@ -0,0 +1,33 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417BARCODEMETADATA_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417BARCODEMETADATA_H_ + +#include + +class CBC_BarcodeMetadata { + public: + CBC_BarcodeMetadata(int32_t columnCount, + int32_t rowCountUpperPart, + int32_t rowCountLowerPart, + int32_t errorCorrectionLevel); + virtual ~CBC_BarcodeMetadata(); + int32_t getColumnCount(); + int32_t getErrorCorrectionLevel(); + int32_t getRowCount(); + int32_t getRowCountUpperPart(); + int32_t getRowCountLowerPart(); + + private: + int32_t m_columnCount; + int32_t m_errorCorrectionLevel; + int32_t m_rowCountUpperPart; + int32_t m_rowCountLowerPart; + int32_t m_rowCount; +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417BARCODEMETADATA_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417BarcodeRow.cpp b/xfa/fxbarcode/pdf417/BC_PDF417BarcodeRow.cpp new file mode 100644 index 0000000000..6f88b33877 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417BarcodeRow.cpp @@ -0,0 +1,53 @@ +// 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 2011 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_PDF417BarcodeRow.h" + +CBC_BarcodeRow::CBC_BarcodeRow(int32_t width) { + m_row.SetSize(width); + m_currentLocation = 0; +} +CBC_BarcodeRow::~CBC_BarcodeRow() { + m_output.RemoveAll(); + m_row.RemoveAll(); +} +void CBC_BarcodeRow::set(int32_t x, uint8_t value) { + m_row.SetAt(x, value); +} +void CBC_BarcodeRow::set(int32_t x, FX_BOOL black) { + m_row.SetAt(x, (uint8_t)(black ? 1 : 0)); +} +void CBC_BarcodeRow::addBar(FX_BOOL black, int32_t width) { + for (int32_t ii = 0; ii < width; ii++) { + set(m_currentLocation++, black); + } +} +CFX_ByteArray& CBC_BarcodeRow::getRow() { + return m_row; +} +CFX_ByteArray& CBC_BarcodeRow::getScaledRow(int32_t scale) { + m_output.SetSize(m_row.GetSize() * scale); + for (int32_t i = 0; i < m_output.GetSize(); i++) { + m_output[i] = (m_row[i / scale]); + } + return m_output; +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417BarcodeRow.h b/xfa/fxbarcode/pdf417/BC_PDF417BarcodeRow.h new file mode 100644 index 0000000000..007876a93c --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417BarcodeRow.h @@ -0,0 +1,28 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417BARCODEROW_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417BARCODEROW_H_ + +#include "core/include/fxcrt/fx_basic.h" + +class CBC_BarcodeRow { + public: + CBC_BarcodeRow(int32_t width); + virtual ~CBC_BarcodeRow(); + void set(int32_t x, uint8_t value); + void set(int32_t x, FX_BOOL black); + void addBar(FX_BOOL black, int32_t width); + CFX_ByteArray& getRow(); + CFX_ByteArray& getScaledRow(int32_t scale); + + private: + CFX_ByteArray m_row; + CFX_ByteArray m_output; + int32_t m_currentLocation; +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417BARCODEROW_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417BarcodeValue.cpp b/xfa/fxbarcode/pdf417/BC_PDF417BarcodeValue.cpp new file mode 100644 index 0000000000..eb89546b5c --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417BarcodeValue.cpp @@ -0,0 +1,61 @@ +// 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 2013 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_PDF417BarcodeValue.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417Common.h" + +CBC_BarcodeValue::CBC_BarcodeValue() {} +CBC_BarcodeValue::~CBC_BarcodeValue() {} +void CBC_BarcodeValue::setValue(int32_t value) { + int32_t confidence = 0; + for (int32_t i = 0; i < m_keys.GetSize(); i++) { + if (m_keys.GetAt(i) == value) { + confidence = m_values.GetAt(i); + m_values.SetAt(i, confidence + 1); + return; + } + } + confidence = 1; + m_keys.Add(value); + m_values.Add(confidence); +} +CFX_Int32Array* CBC_BarcodeValue::getValue() { + int32_t maxConfidence = -1; + CFX_Int32Array* result = new CFX_Int32Array; + for (int32_t i = 0; i < m_keys.GetSize(); i++) { + if (m_values.GetAt(i) > maxConfidence) { + maxConfidence = m_values.GetAt(i); + result->RemoveAll(); + result->Add(m_keys.GetAt(i)); + } else if (m_values.GetAt(i) == maxConfidence) { + result->Add(m_keys.GetAt(i)); + } + } + return result; +} +int32_t CBC_BarcodeValue::getConfidence(int32_t value) { + for (int32_t i = 0; i < m_keys.GetSize(); i++) + if (m_keys.GetAt(i) == value) { + return m_values.GetAt(i); + } + return -1; +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417BarcodeValue.h b/xfa/fxbarcode/pdf417/BC_PDF417BarcodeValue.h new file mode 100644 index 0000000000..e99fb84cba --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417BarcodeValue.h @@ -0,0 +1,25 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417BARCODEVALUE_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417BARCODEVALUE_H_ + +#include "core/include/fxcrt/fx_basic.h" + +class CBC_BarcodeValue { + public: + CBC_BarcodeValue(); + virtual ~CBC_BarcodeValue(); + void setValue(int32_t value); + CFX_Int32Array* getValue(); + int32_t getConfidence(int32_t value); + + private: + CFX_Int32Array m_keys; + CFX_Int32Array m_values; +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417BARCODEVALUE_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417BoundingBox.cpp b/xfa/fxbarcode/pdf417/BC_PDF417BoundingBox.cpp new file mode 100644 index 0000000000..c8328ab1c6 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417BoundingBox.cpp @@ -0,0 +1,207 @@ +// 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 2013 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/BC_ResultPoint.h" +#include "xfa/fxbarcode/common/BC_CommonBitMatrix.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417BoundingBox.h" +#include "xfa/fxbarcode/utils.h" + +CBC_BoundingBox::CBC_BoundingBox(CBC_CommonBitMatrix* image, + CBC_ResultPoint* topLeft, + CBC_ResultPoint* bottomLeft, + CBC_ResultPoint* topRight, + CBC_ResultPoint* bottomRight, + int32_t& e) { + if ((topLeft == NULL && topRight == NULL) || + (bottomLeft == NULL && bottomRight == NULL) || + (topLeft && bottomLeft == NULL) || (topRight && bottomRight == NULL)) { + e = BCExceptionNotFoundInstance; + } + init(image, topLeft, bottomLeft, topRight, bottomRight); +} +CBC_BoundingBox::CBC_BoundingBox(CBC_BoundingBox* boundingBox) { + init(boundingBox->m_image, boundingBox->m_topLeft, boundingBox->m_bottomLeft, + boundingBox->m_topRight, boundingBox->m_bottomRight); +} +CBC_BoundingBox::~CBC_BoundingBox() { + if (m_topLeft) { + delete m_topLeft; + } + if (m_bottomLeft) { + delete m_bottomLeft; + } + if (m_topRight) { + delete m_topRight; + } + if (m_bottomRight) { + delete m_bottomRight; + } +} +CBC_BoundingBox* CBC_BoundingBox::merge(CBC_BoundingBox* leftBox, + CBC_BoundingBox* rightBox, + int32_t& e) { + CBC_BoundingBox* boundingBox = NULL; + if (leftBox == NULL) { + boundingBox = new CBC_BoundingBox(rightBox); + return boundingBox; + } + if (rightBox == NULL) { + boundingBox = new CBC_BoundingBox(leftBox); + return boundingBox; + } + boundingBox = new CBC_BoundingBox(leftBox->m_image, leftBox->m_topLeft, + leftBox->m_bottomLeft, rightBox->m_topRight, + rightBox->m_bottomRight, e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + return boundingBox; +} +CBC_BoundingBox* CBC_BoundingBox::addMissingRows(int32_t missingStartRows, + int32_t missingEndRows, + FX_BOOL isLeft, + int32_t& e) { + CBC_ResultPoint* newTopLeft = m_topLeft; + CBC_ResultPoint* newBottomLeft = m_bottomLeft; + CBC_ResultPoint* newTopRight = m_topRight; + CBC_ResultPoint* newBottomRight = m_bottomRight; + CBC_ResultPoint* newTop = NULL; + CBC_ResultPoint* newBottom = NULL; + if (missingStartRows > 0) { + CBC_ResultPoint* top = isLeft ? m_topLeft : m_topRight; + int32_t newMinY = (int32_t)top->GetY() - missingStartRows; + if (newMinY < 0) { + newMinY = 0; + } + newTop = new CBC_ResultPoint((FX_FLOAT)top->GetX(), (FX_FLOAT)newMinY); + if (isLeft) { + newTopLeft = newTop; + } else { + newTopRight = newTop; + } + } + if (missingEndRows > 0) { + CBC_ResultPoint* bottom = isLeft ? m_bottomLeft : m_bottomRight; + int32_t newMaxY = (int32_t)bottom->GetY() + missingEndRows; + if (newMaxY >= m_image->GetHeight()) { + newMaxY = m_image->GetHeight() - 1; + } + newBottom = + new CBC_ResultPoint((FX_FLOAT)bottom->GetX(), (FX_FLOAT)newMaxY); + if (isLeft) { + newBottomLeft = newBottom; + } else { + newBottomRight = newBottom; + } + } + calculateMinMaxValues(); + CBC_BoundingBox* boundingBox = new CBC_BoundingBox( + m_image, newTopLeft, newBottomLeft, newTopRight, newBottomRight, e); + delete newTop; + delete newBottom; + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + return boundingBox; +} +void CBC_BoundingBox::setTopRight(CBC_ResultPoint topRight) { + if (m_topRight) { + delete m_topRight; + } + m_topRight = new CBC_ResultPoint(topRight.GetX(), topRight.GetY()); + calculateMinMaxValues(); +} +void CBC_BoundingBox::setBottomRight(CBC_ResultPoint bottomRight) { + if (m_bottomRight) { + delete m_bottomRight; + } + m_bottomRight = new CBC_ResultPoint(bottomRight.GetX(), bottomRight.GetY()); + calculateMinMaxValues(); +} +int32_t CBC_BoundingBox::getMinX() { + return m_minX; +} +int32_t CBC_BoundingBox::getMaxX() { + return m_maxX; +} +int32_t CBC_BoundingBox::getMinY() { + return m_minY; +} +int32_t CBC_BoundingBox::getMaxY() { + return m_maxY; +} +CBC_ResultPoint* CBC_BoundingBox::getTopLeft() { + return m_topLeft; +} +CBC_ResultPoint* CBC_BoundingBox::getTopRight() { + return m_topRight; +} +CBC_ResultPoint* CBC_BoundingBox::getBottomLeft() { + return m_bottomLeft; +} +CBC_ResultPoint* CBC_BoundingBox::getBottomRight() { + return m_bottomRight; +} +void CBC_BoundingBox::init(CBC_CommonBitMatrix* image, + CBC_ResultPoint* topLeft, + CBC_ResultPoint* bottomLeft, + CBC_ResultPoint* topRight, + CBC_ResultPoint* bottomRight) { + m_topLeft = NULL; + m_bottomLeft = NULL; + m_topRight = NULL; + m_bottomRight = NULL; + m_image = image; + if (topLeft) { + m_topLeft = new CBC_ResultPoint(topLeft->GetX(), topLeft->GetY()); + } + if (bottomLeft) { + m_bottomLeft = new CBC_ResultPoint(bottomLeft->GetX(), bottomLeft->GetY()); + } + if (topRight) { + m_topRight = new CBC_ResultPoint(topRight->GetX(), topRight->GetY()); + } + if (bottomRight) { + m_bottomRight = + new CBC_ResultPoint(bottomRight->GetX(), bottomRight->GetY()); + } + calculateMinMaxValues(); +} +void CBC_BoundingBox::calculateMinMaxValues() { + if (m_topLeft == NULL) { + m_topLeft = new CBC_ResultPoint(0, m_topRight->GetY()); + m_bottomLeft = new CBC_ResultPoint(0, m_bottomRight->GetY()); + } else if (m_topRight == NULL) { + m_topRight = new CBC_ResultPoint((FX_FLOAT)m_image->GetWidth() - 1, + (FX_FLOAT)m_topLeft->GetY()); + m_bottomRight = new CBC_ResultPoint((FX_FLOAT)m_image->GetWidth() - 1, + (FX_FLOAT)m_bottomLeft->GetY()); + } + m_minX = (int32_t)(m_topLeft->GetX() < m_bottomLeft->GetX() + ? m_topLeft->GetX() + : m_bottomLeft->GetX()); + m_maxX = (int32_t)(m_topRight->GetX() > m_bottomRight->GetX() + ? m_topRight->GetX() + : m_bottomRight->GetX()); + m_minY = + (int32_t)(m_topLeft->GetY() < m_topRight->GetY() ? m_topLeft->GetY() + : m_topRight->GetY()); + m_maxY = (int32_t)(m_bottomLeft->GetY() > m_bottomRight->GetY() + ? m_bottomLeft->GetY() + : m_bottomRight->GetY()); +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417BoundingBox.h b/xfa/fxbarcode/pdf417/BC_PDF417BoundingBox.h new file mode 100644 index 0000000000..8b9563587d --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417BoundingBox.h @@ -0,0 +1,61 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417BOUNDINGBOX_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417BOUNDINGBOX_H_ + +#include "core/include/fxcrt/fx_system.h" + +class CBC_CommonBitMatrix; +class CBC_ResultPoint; + +class CBC_BoundingBox { + public: + CBC_BoundingBox(CBC_CommonBitMatrix* image, + CBC_ResultPoint* topLeft, + CBC_ResultPoint* bottomLeft, + CBC_ResultPoint* topRight, + CBC_ResultPoint* bottomRight, + int32_t& e); + CBC_BoundingBox(CBC_BoundingBox* boundingBox); + virtual ~CBC_BoundingBox(); + static CBC_BoundingBox* merge(CBC_BoundingBox* leftBox, + CBC_BoundingBox* rightBox, + int32_t& e); + CBC_BoundingBox* addMissingRows(int32_t missingStartRows, + int32_t missingEndRows, + FX_BOOL isLeft, + int32_t& e); + void setTopRight(CBC_ResultPoint topRight); + void setBottomRight(CBC_ResultPoint bottomRight); + int32_t getMinX(); + int32_t getMaxX(); + int32_t getMinY(); + int32_t getMaxY(); + CBC_ResultPoint* getTopLeft(); + CBC_ResultPoint* getTopRight(); + CBC_ResultPoint* getBottomLeft(); + CBC_ResultPoint* getBottomRight(); + + private: + CBC_CommonBitMatrix* m_image; + CBC_ResultPoint* m_topLeft; + CBC_ResultPoint* m_bottomLeft; + CBC_ResultPoint* m_topRight; + CBC_ResultPoint* m_bottomRight; + int32_t m_minX; + int32_t m_maxX; + int32_t m_minY; + int32_t m_maxY; + void init(CBC_CommonBitMatrix* image, + CBC_ResultPoint* topLeft, + CBC_ResultPoint* bottomLeft, + CBC_ResultPoint* topRight, + CBC_ResultPoint* bottomRight); + void calculateMinMaxValues(); +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417BOUNDINGBOX_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417Codeword.cpp b/xfa/fxbarcode/pdf417/BC_PDF417Codeword.cpp new file mode 100644 index 0000000000..0280ea0953 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417Codeword.cpp @@ -0,0 +1,70 @@ +// 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 2013 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_PDF417Codeword.h" + +int32_t CBC_Codeword::BARCODE_ROW_UNKNOWN = -1; +CBC_Codeword::CBC_Codeword(int32_t startX, + int32_t endX, + int32_t bucket, + int32_t cvalue) { + m_startX = startX; + m_endX = endX; + m_bucket = bucket; + m_value = cvalue; + m_rowNumber = BARCODE_ROW_UNKNOWN; +} +CBC_Codeword::~CBC_Codeword() {} +FX_BOOL CBC_Codeword::hasValidRowNumber() { + return isValidRowNumber(m_rowNumber); +} +FX_BOOL CBC_Codeword::isValidRowNumber(int32_t rowNumber) { + return m_rowNumber != BARCODE_ROW_UNKNOWN && + m_bucket == (m_rowNumber % 3) * 3; +} +void CBC_Codeword::setRowNumberAsRowIndicatorColumn() { + m_rowNumber = (m_value / 30) * 3 + m_bucket / 3; +} +int32_t CBC_Codeword::getWidth() { + return m_endX - m_startX; +} +int32_t CBC_Codeword::getStartX() { + return m_startX; +} +int32_t CBC_Codeword::getEndX() { + return m_endX; +} +int32_t CBC_Codeword::getBucket() { + return m_bucket; +} +int32_t CBC_Codeword::getValue() { + return m_value; +} +int32_t CBC_Codeword::getRowNumber() { + return m_rowNumber; +} +void CBC_Codeword::setRowNumber(int32_t rowNumber) { + m_rowNumber = rowNumber; +} +CFX_ByteString CBC_Codeword::toString() { + return m_rowNumber + (FX_CHAR)'|' + m_value; +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417Codeword.h b/xfa/fxbarcode/pdf417/BC_PDF417Codeword.h new file mode 100644 index 0000000000..e1ca60f229 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417Codeword.h @@ -0,0 +1,37 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417CODEWORD_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417CODEWORD_H_ + +#include "core/include/fxcrt/fx_basic.h" + +class CBC_Codeword { + public: + CBC_Codeword(int32_t startX, int32_t endX, int32_t bucket, int32_t value); + virtual ~CBC_Codeword(); + FX_BOOL hasValidRowNumber(); + FX_BOOL isValidRowNumber(int32_t rowNumber); + void setRowNumberAsRowIndicatorColumn(); + int32_t getWidth(); + int32_t getStartX(); + int32_t getEndX(); + int32_t getBucket(); + int32_t getValue(); + int32_t getRowNumber(); + void setRowNumber(int32_t rowNumber); + CFX_ByteString toString(); + + private: + static int32_t BARCODE_ROW_UNKNOWN; + int32_t m_startX; + int32_t m_endX; + int32_t m_bucket; + int32_t m_value; + int32_t m_rowNumber; +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417CODEWORD_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417CodewordDecoder.cpp b/xfa/fxbarcode/pdf417/BC_PDF417CodewordDecoder.cpp new file mode 100644 index 0000000000..dfbbc70264 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417CodewordDecoder.cpp @@ -0,0 +1,117 @@ +// 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 2013 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 + +#include "xfa/fxbarcode/pdf417/BC_PDF417CodewordDecoder.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417Common.h" + +#define SYMBOL_TABLE_Length 2787 + +FX_FLOAT CBC_PDF417CodewordDecoder::RATIOS_TABLE[2787][8] = {{0}}; + +CBC_PDF417CodewordDecoder::CBC_PDF417CodewordDecoder() {} +CBC_PDF417CodewordDecoder::~CBC_PDF417CodewordDecoder() {} +void CBC_PDF417CodewordDecoder::Initialize() { + for (int32_t i = 0; i < SYMBOL_TABLE_Length; i++) { + int32_t currentSymbol = CBC_PDF417Common::SYMBOL_TABLE[i]; + int32_t currentBit = currentSymbol & 0x1; + for (int32_t j = 0; j < CBC_PDF417Common::BARS_IN_MODULE; j++) { + FX_FLOAT size = 0.0f; + while ((currentSymbol & 0x1) == currentBit) { + size += 1.0f; + currentSymbol >>= 1; + } + currentBit = currentSymbol & 0x1; + RATIOS_TABLE[i][CBC_PDF417Common::BARS_IN_MODULE - j - 1] = + size / CBC_PDF417Common::MODULES_IN_CODEWORD; + } + } +} +void CBC_PDF417CodewordDecoder::Finalize() {} +int32_t CBC_PDF417CodewordDecoder::getDecodedValue( + CFX_Int32Array& moduleBitCount) { + CFX_Int32Array* array = sampleBitCounts(moduleBitCount); + int32_t decodedValue = getDecodedCodewordValue(*array); + delete array; + if (decodedValue != -1) { + return decodedValue; + } + return getClosestDecodedValue(moduleBitCount); +} +CFX_Int32Array* CBC_PDF417CodewordDecoder::sampleBitCounts( + CFX_Int32Array& moduleBitCount) { + FX_FLOAT bitCountSum = + (FX_FLOAT)CBC_PDF417Common::getBitCountSum(moduleBitCount); + CFX_Int32Array* bitCount = new CFX_Int32Array(); + bitCount->SetSize(CBC_PDF417Common::BARS_IN_MODULE); + int32_t bitCountIndex = 0; + int32_t sumPreviousBits = 0; + for (int32_t i = 0; i < CBC_PDF417Common::MODULES_IN_CODEWORD; i++) { + FX_FLOAT sampleIndex = + bitCountSum / (2 * CBC_PDF417Common::MODULES_IN_CODEWORD) + + (i * bitCountSum) / CBC_PDF417Common::MODULES_IN_CODEWORD; + if (sumPreviousBits + moduleBitCount.GetAt(bitCountIndex) <= sampleIndex) { + sumPreviousBits += moduleBitCount.GetAt(bitCountIndex); + bitCountIndex++; + } + bitCount->SetAt(bitCountIndex, bitCount->GetAt(bitCountIndex) + 1); + } + return bitCount; +} +int32_t CBC_PDF417CodewordDecoder::getDecodedCodewordValue( + CFX_Int32Array& moduleBitCount) { + int32_t decodedValue = getBitValue(moduleBitCount); + return CBC_PDF417Common::getCodeword(decodedValue) == -1 ? -1 : decodedValue; +} +int32_t CBC_PDF417CodewordDecoder::getBitValue(CFX_Int32Array& moduleBitCount) { + int64_t result = 0; + for (int32_t i = 0; i < moduleBitCount.GetSize(); i++) { + for (int32_t bit = 0; bit < moduleBitCount.GetAt(i); bit++) { + result = (result << 1) | (i % 2 == 0 ? 1 : 0); + } + } + return (int32_t)result; +} +int32_t CBC_PDF417CodewordDecoder::getClosestDecodedValue( + CFX_Int32Array& moduleBitCount) { + int32_t bitCountSum = CBC_PDF417Common::getBitCountSum(moduleBitCount); + CFX_FloatArray bitCountRatios; + bitCountRatios.SetSize(CBC_PDF417Common::BARS_IN_MODULE); + for (int32_t i = 0; i < bitCountRatios.GetSize(); i++) { + bitCountRatios[i] = moduleBitCount.GetAt(i) / (FX_FLOAT)bitCountSum; + } + FX_FLOAT bestMatchError = std::numeric_limits::max(); + int32_t bestMatch = -1; + for (int32_t j = 0; j < SYMBOL_TABLE_Length; j++) { + FX_FLOAT error = 0.0f; + for (int32_t k = 0; k < CBC_PDF417Common::BARS_IN_MODULE; k++) { + FX_FLOAT diff = RATIOS_TABLE[j][k] - bitCountRatios[k]; + error += diff * diff; + } + if (error < bestMatchError) { + bestMatchError = error; + bestMatch = CBC_PDF417Common::SYMBOL_TABLE[j]; + } + } + return bestMatch; +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417CodewordDecoder.h b/xfa/fxbarcode/pdf417/BC_PDF417CodewordDecoder.h new file mode 100644 index 0000000000..920409df84 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417CodewordDecoder.h @@ -0,0 +1,28 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417CODEWORDDECODER_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417CODEWORDDECODER_H_ + +#include "core/include/fxcrt/fx_basic.h" + +class CBC_PDF417CodewordDecoder { + public: + CBC_PDF417CodewordDecoder(); + virtual ~CBC_PDF417CodewordDecoder(); + static void Initialize(); + static void Finalize(); + static int32_t getDecodedValue(CFX_Int32Array& moduleBitCount); + + private: + static FX_FLOAT RATIOS_TABLE[][8]; + static CFX_Int32Array* sampleBitCounts(CFX_Int32Array& moduleBitCount); + static int32_t getDecodedCodewordValue(CFX_Int32Array& moduleBitCount); + static int32_t getBitValue(CFX_Int32Array& moduleBitCount); + static int32_t getClosestDecodedValue(CFX_Int32Array& moduleBitCount); +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417CODEWORDDECODER_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417Common.cpp b/xfa/fxbarcode/pdf417/BC_PDF417Common.cpp new file mode 100644 index 0000000000..fa4647db84 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417Common.cpp @@ -0,0 +1,651 @@ +// 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 "xfa/fxbarcode/pdf417/BC_PDF417Common.h" + +int32_t CBC_PDF417Common::NUMBER_OF_CODEWORDS = 929; +int32_t CBC_PDF417Common::MAX_CODEWORDS_IN_BARCODE = NUMBER_OF_CODEWORDS - 1; +int32_t CBC_PDF417Common::MIN_ROWS_IN_BARCODE = 3; +int32_t CBC_PDF417Common::MAX_ROWS_IN_BARCODE = 90; +int32_t CBC_PDF417Common::MAX_CODEWORDS_IN_ROW = 32; +int32_t CBC_PDF417Common::MODULES_IN_CODEWORD = 17; +int32_t CBC_PDF417Common::MODULES_IN_STOP_PATTERN = 18; +int32_t CBC_PDF417Common::BARS_IN_MODULE = 8; +CFX_Int32Array* CBC_PDF417Common::EMPTY_INT_ARRAY = NULL; +int32_t CBC_PDF417Common::SYMBOL_TABLE[] = { + 0x1025e, 0x1027a, 0x1029e, 0x102bc, 0x102f2, 0x102f4, 0x1032e, 0x1034e, + 0x1035c, 0x10396, 0x103a6, 0x103ac, 0x10422, 0x10428, 0x10436, 0x10442, + 0x10444, 0x10448, 0x10450, 0x1045e, 0x10466, 0x1046c, 0x1047a, 0x10482, + 0x1049e, 0x104a0, 0x104bc, 0x104c6, 0x104d8, 0x104ee, 0x104f2, 0x104f4, + 0x10504, 0x10508, 0x10510, 0x1051e, 0x10520, 0x1053c, 0x10540, 0x10578, + 0x10586, 0x1058c, 0x10598, 0x105b0, 0x105be, 0x105ce, 0x105dc, 0x105e2, + 0x105e4, 0x105e8, 0x105f6, 0x1062e, 0x1064e, 0x1065c, 0x1068e, 0x1069c, + 0x106b8, 0x106de, 0x106fa, 0x10716, 0x10726, 0x1072c, 0x10746, 0x1074c, + 0x10758, 0x1076e, 0x10792, 0x10794, 0x107a2, 0x107a4, 0x107a8, 0x107b6, + 0x10822, 0x10828, 0x10842, 0x10848, 0x10850, 0x1085e, 0x10866, 0x1086c, + 0x1087a, 0x10882, 0x10884, 0x10890, 0x1089e, 0x108a0, 0x108bc, 0x108c6, + 0x108cc, 0x108d8, 0x108ee, 0x108f2, 0x108f4, 0x10902, 0x10908, 0x1091e, + 0x10920, 0x1093c, 0x10940, 0x10978, 0x10986, 0x10998, 0x109b0, 0x109be, + 0x109ce, 0x109dc, 0x109e2, 0x109e4, 0x109e8, 0x109f6, 0x10a08, 0x10a10, + 0x10a1e, 0x10a20, 0x10a3c, 0x10a40, 0x10a78, 0x10af0, 0x10b06, 0x10b0c, + 0x10b18, 0x10b30, 0x10b3e, 0x10b60, 0x10b7c, 0x10b8e, 0x10b9c, 0x10bb8, + 0x10bc2, 0x10bc4, 0x10bc8, 0x10bd0, 0x10bde, 0x10be6, 0x10bec, 0x10c2e, + 0x10c4e, 0x10c5c, 0x10c62, 0x10c64, 0x10c68, 0x10c76, 0x10c8e, 0x10c9c, + 0x10cb8, 0x10cc2, 0x10cc4, 0x10cc8, 0x10cd0, 0x10cde, 0x10ce6, 0x10cec, + 0x10cfa, 0x10d0e, 0x10d1c, 0x10d38, 0x10d70, 0x10d7e, 0x10d82, 0x10d84, + 0x10d88, 0x10d90, 0x10d9e, 0x10da0, 0x10dbc, 0x10dc6, 0x10dcc, 0x10dd8, + 0x10dee, 0x10df2, 0x10df4, 0x10e16, 0x10e26, 0x10e2c, 0x10e46, 0x10e58, + 0x10e6e, 0x10e86, 0x10e8c, 0x10e98, 0x10eb0, 0x10ebe, 0x10ece, 0x10edc, + 0x10f0a, 0x10f12, 0x10f14, 0x10f22, 0x10f28, 0x10f36, 0x10f42, 0x10f44, + 0x10f48, 0x10f50, 0x10f5e, 0x10f66, 0x10f6c, 0x10fb2, 0x10fb4, 0x11022, + 0x11028, 0x11042, 0x11048, 0x11050, 0x1105e, 0x1107a, 0x11082, 0x11084, + 0x11090, 0x1109e, 0x110a0, 0x110bc, 0x110c6, 0x110cc, 0x110d8, 0x110ee, + 0x110f2, 0x110f4, 0x11102, 0x1111e, 0x11120, 0x1113c, 0x11140, 0x11178, + 0x11186, 0x11198, 0x111b0, 0x111be, 0x111ce, 0x111dc, 0x111e2, 0x111e4, + 0x111e8, 0x111f6, 0x11208, 0x1121e, 0x11220, 0x11278, 0x112f0, 0x1130c, + 0x11330, 0x1133e, 0x11360, 0x1137c, 0x1138e, 0x1139c, 0x113b8, 0x113c2, + 0x113c8, 0x113d0, 0x113de, 0x113e6, 0x113ec, 0x11408, 0x11410, 0x1141e, + 0x11420, 0x1143c, 0x11440, 0x11478, 0x114f0, 0x115e0, 0x1160c, 0x11618, + 0x11630, 0x1163e, 0x11660, 0x1167c, 0x116c0, 0x116f8, 0x1171c, 0x11738, + 0x11770, 0x1177e, 0x11782, 0x11784, 0x11788, 0x11790, 0x1179e, 0x117a0, + 0x117bc, 0x117c6, 0x117cc, 0x117d8, 0x117ee, 0x1182e, 0x11834, 0x1184e, + 0x1185c, 0x11862, 0x11864, 0x11868, 0x11876, 0x1188e, 0x1189c, 0x118b8, + 0x118c2, 0x118c8, 0x118d0, 0x118de, 0x118e6, 0x118ec, 0x118fa, 0x1190e, + 0x1191c, 0x11938, 0x11970, 0x1197e, 0x11982, 0x11984, 0x11990, 0x1199e, + 0x119a0, 0x119bc, 0x119c6, 0x119cc, 0x119d8, 0x119ee, 0x119f2, 0x119f4, + 0x11a0e, 0x11a1c, 0x11a38, 0x11a70, 0x11a7e, 0x11ae0, 0x11afc, 0x11b08, + 0x11b10, 0x11b1e, 0x11b20, 0x11b3c, 0x11b40, 0x11b78, 0x11b8c, 0x11b98, + 0x11bb0, 0x11bbe, 0x11bce, 0x11bdc, 0x11be2, 0x11be4, 0x11be8, 0x11bf6, + 0x11c16, 0x11c26, 0x11c2c, 0x11c46, 0x11c4c, 0x11c58, 0x11c6e, 0x11c86, + 0x11c98, 0x11cb0, 0x11cbe, 0x11cce, 0x11cdc, 0x11ce2, 0x11ce4, 0x11ce8, + 0x11cf6, 0x11d06, 0x11d0c, 0x11d18, 0x11d30, 0x11d3e, 0x11d60, 0x11d7c, + 0x11d8e, 0x11d9c, 0x11db8, 0x11dc4, 0x11dc8, 0x11dd0, 0x11dde, 0x11de6, + 0x11dec, 0x11dfa, 0x11e0a, 0x11e12, 0x11e14, 0x11e22, 0x11e24, 0x11e28, + 0x11e36, 0x11e42, 0x11e44, 0x11e50, 0x11e5e, 0x11e66, 0x11e6c, 0x11e82, + 0x11e84, 0x11e88, 0x11e90, 0x11e9e, 0x11ea0, 0x11ebc, 0x11ec6, 0x11ecc, + 0x11ed8, 0x11eee, 0x11f1a, 0x11f2e, 0x11f32, 0x11f34, 0x11f4e, 0x11f5c, + 0x11f62, 0x11f64, 0x11f68, 0x11f76, 0x12048, 0x1205e, 0x12082, 0x12084, + 0x12090, 0x1209e, 0x120a0, 0x120bc, 0x120d8, 0x120f2, 0x120f4, 0x12108, + 0x1211e, 0x12120, 0x1213c, 0x12140, 0x12178, 0x12186, 0x12198, 0x121b0, + 0x121be, 0x121e2, 0x121e4, 0x121e8, 0x121f6, 0x12204, 0x12210, 0x1221e, + 0x12220, 0x12278, 0x122f0, 0x12306, 0x1230c, 0x12330, 0x1233e, 0x12360, + 0x1237c, 0x1238e, 0x1239c, 0x123b8, 0x123c2, 0x123c8, 0x123d0, 0x123e6, + 0x123ec, 0x1241e, 0x12420, 0x1243c, 0x124f0, 0x125e0, 0x12618, 0x1263e, + 0x12660, 0x1267c, 0x126c0, 0x126f8, 0x12738, 0x12770, 0x1277e, 0x12782, + 0x12784, 0x12790, 0x1279e, 0x127a0, 0x127bc, 0x127c6, 0x127cc, 0x127d8, + 0x127ee, 0x12820, 0x1283c, 0x12840, 0x12878, 0x128f0, 0x129e0, 0x12bc0, + 0x12c18, 0x12c30, 0x12c3e, 0x12c60, 0x12c7c, 0x12cc0, 0x12cf8, 0x12df0, + 0x12e1c, 0x12e38, 0x12e70, 0x12e7e, 0x12ee0, 0x12efc, 0x12f04, 0x12f08, + 0x12f10, 0x12f20, 0x12f3c, 0x12f40, 0x12f78, 0x12f86, 0x12f8c, 0x12f98, + 0x12fb0, 0x12fbe, 0x12fce, 0x12fdc, 0x1302e, 0x1304e, 0x1305c, 0x13062, + 0x13068, 0x1308e, 0x1309c, 0x130b8, 0x130c2, 0x130c8, 0x130d0, 0x130de, + 0x130ec, 0x130fa, 0x1310e, 0x13138, 0x13170, 0x1317e, 0x13182, 0x13184, + 0x13190, 0x1319e, 0x131a0, 0x131bc, 0x131c6, 0x131cc, 0x131d8, 0x131f2, + 0x131f4, 0x1320e, 0x1321c, 0x13270, 0x1327e, 0x132e0, 0x132fc, 0x13308, + 0x1331e, 0x13320, 0x1333c, 0x13340, 0x13378, 0x13386, 0x13398, 0x133b0, + 0x133be, 0x133ce, 0x133dc, 0x133e2, 0x133e4, 0x133e8, 0x133f6, 0x1340e, + 0x1341c, 0x13438, 0x13470, 0x1347e, 0x134e0, 0x134fc, 0x135c0, 0x135f8, + 0x13608, 0x13610, 0x1361e, 0x13620, 0x1363c, 0x13640, 0x13678, 0x136f0, + 0x1370c, 0x13718, 0x13730, 0x1373e, 0x13760, 0x1377c, 0x1379c, 0x137b8, + 0x137c2, 0x137c4, 0x137c8, 0x137d0, 0x137de, 0x137e6, 0x137ec, 0x13816, + 0x13826, 0x1382c, 0x13846, 0x1384c, 0x13858, 0x1386e, 0x13874, 0x13886, + 0x13898, 0x138b0, 0x138be, 0x138ce, 0x138dc, 0x138e2, 0x138e4, 0x138e8, + 0x13906, 0x1390c, 0x13930, 0x1393e, 0x13960, 0x1397c, 0x1398e, 0x1399c, + 0x139b8, 0x139c8, 0x139d0, 0x139de, 0x139e6, 0x139ec, 0x139fa, 0x13a06, + 0x13a0c, 0x13a18, 0x13a30, 0x13a3e, 0x13a60, 0x13a7c, 0x13ac0, 0x13af8, + 0x13b0e, 0x13b1c, 0x13b38, 0x13b70, 0x13b7e, 0x13b88, 0x13b90, 0x13b9e, + 0x13ba0, 0x13bbc, 0x13bcc, 0x13bd8, 0x13bee, 0x13bf2, 0x13bf4, 0x13c12, + 0x13c14, 0x13c22, 0x13c24, 0x13c28, 0x13c36, 0x13c42, 0x13c48, 0x13c50, + 0x13c5e, 0x13c66, 0x13c6c, 0x13c82, 0x13c84, 0x13c90, 0x13c9e, 0x13ca0, + 0x13cbc, 0x13cc6, 0x13ccc, 0x13cd8, 0x13cee, 0x13d02, 0x13d04, 0x13d08, + 0x13d10, 0x13d1e, 0x13d20, 0x13d3c, 0x13d40, 0x13d78, 0x13d86, 0x13d8c, + 0x13d98, 0x13db0, 0x13dbe, 0x13dce, 0x13ddc, 0x13de4, 0x13de8, 0x13df6, + 0x13e1a, 0x13e2e, 0x13e32, 0x13e34, 0x13e4e, 0x13e5c, 0x13e62, 0x13e64, + 0x13e68, 0x13e76, 0x13e8e, 0x13e9c, 0x13eb8, 0x13ec2, 0x13ec4, 0x13ec8, + 0x13ed0, 0x13ede, 0x13ee6, 0x13eec, 0x13f26, 0x13f2c, 0x13f3a, 0x13f46, + 0x13f4c, 0x13f58, 0x13f6e, 0x13f72, 0x13f74, 0x14082, 0x1409e, 0x140a0, + 0x140bc, 0x14104, 0x14108, 0x14110, 0x1411e, 0x14120, 0x1413c, 0x14140, + 0x14178, 0x1418c, 0x14198, 0x141b0, 0x141be, 0x141e2, 0x141e4, 0x141e8, + 0x14208, 0x14210, 0x1421e, 0x14220, 0x1423c, 0x14240, 0x14278, 0x142f0, + 0x14306, 0x1430c, 0x14318, 0x14330, 0x1433e, 0x14360, 0x1437c, 0x1438e, + 0x143c2, 0x143c4, 0x143c8, 0x143d0, 0x143e6, 0x143ec, 0x14408, 0x14410, + 0x1441e, 0x14420, 0x1443c, 0x14440, 0x14478, 0x144f0, 0x145e0, 0x1460c, + 0x14618, 0x14630, 0x1463e, 0x14660, 0x1467c, 0x146c0, 0x146f8, 0x1471c, + 0x14738, 0x14770, 0x1477e, 0x14782, 0x14784, 0x14788, 0x14790, 0x147a0, + 0x147bc, 0x147c6, 0x147cc, 0x147d8, 0x147ee, 0x14810, 0x14820, 0x1483c, + 0x14840, 0x14878, 0x148f0, 0x149e0, 0x14bc0, 0x14c30, 0x14c3e, 0x14c60, + 0x14c7c, 0x14cc0, 0x14cf8, 0x14df0, 0x14e38, 0x14e70, 0x14e7e, 0x14ee0, + 0x14efc, 0x14f04, 0x14f08, 0x14f10, 0x14f1e, 0x14f20, 0x14f3c, 0x14f40, + 0x14f78, 0x14f86, 0x14f8c, 0x14f98, 0x14fb0, 0x14fce, 0x14fdc, 0x15020, + 0x15040, 0x15078, 0x150f0, 0x151e0, 0x153c0, 0x15860, 0x1587c, 0x158c0, + 0x158f8, 0x159f0, 0x15be0, 0x15c70, 0x15c7e, 0x15ce0, 0x15cfc, 0x15dc0, + 0x15df8, 0x15e08, 0x15e10, 0x15e20, 0x15e40, 0x15e78, 0x15ef0, 0x15f0c, + 0x15f18, 0x15f30, 0x15f60, 0x15f7c, 0x15f8e, 0x15f9c, 0x15fb8, 0x1604e, + 0x1605c, 0x1608e, 0x1609c, 0x160b8, 0x160c2, 0x160c4, 0x160c8, 0x160de, + 0x1610e, 0x1611c, 0x16138, 0x16170, 0x1617e, 0x16184, 0x16188, 0x16190, + 0x1619e, 0x161a0, 0x161bc, 0x161c6, 0x161cc, 0x161d8, 0x161f2, 0x161f4, + 0x1620e, 0x1621c, 0x16238, 0x16270, 0x1627e, 0x162e0, 0x162fc, 0x16304, + 0x16308, 0x16310, 0x1631e, 0x16320, 0x1633c, 0x16340, 0x16378, 0x16386, + 0x1638c, 0x16398, 0x163b0, 0x163be, 0x163ce, 0x163dc, 0x163e2, 0x163e4, + 0x163e8, 0x163f6, 0x1640e, 0x1641c, 0x16438, 0x16470, 0x1647e, 0x164e0, + 0x164fc, 0x165c0, 0x165f8, 0x16610, 0x1661e, 0x16620, 0x1663c, 0x16640, + 0x16678, 0x166f0, 0x16718, 0x16730, 0x1673e, 0x16760, 0x1677c, 0x1678e, + 0x1679c, 0x167b8, 0x167c2, 0x167c4, 0x167c8, 0x167d0, 0x167de, 0x167e6, + 0x167ec, 0x1681c, 0x16838, 0x16870, 0x168e0, 0x168fc, 0x169c0, 0x169f8, + 0x16bf0, 0x16c10, 0x16c1e, 0x16c20, 0x16c3c, 0x16c40, 0x16c78, 0x16cf0, + 0x16de0, 0x16e18, 0x16e30, 0x16e3e, 0x16e60, 0x16e7c, 0x16ec0, 0x16ef8, + 0x16f1c, 0x16f38, 0x16f70, 0x16f7e, 0x16f84, 0x16f88, 0x16f90, 0x16f9e, + 0x16fa0, 0x16fbc, 0x16fc6, 0x16fcc, 0x16fd8, 0x17026, 0x1702c, 0x17046, + 0x1704c, 0x17058, 0x1706e, 0x17086, 0x1708c, 0x17098, 0x170b0, 0x170be, + 0x170ce, 0x170dc, 0x170e8, 0x17106, 0x1710c, 0x17118, 0x17130, 0x1713e, + 0x17160, 0x1717c, 0x1718e, 0x1719c, 0x171b8, 0x171c2, 0x171c4, 0x171c8, + 0x171d0, 0x171de, 0x171e6, 0x171ec, 0x171fa, 0x17206, 0x1720c, 0x17218, + 0x17230, 0x1723e, 0x17260, 0x1727c, 0x172c0, 0x172f8, 0x1730e, 0x1731c, + 0x17338, 0x17370, 0x1737e, 0x17388, 0x17390, 0x1739e, 0x173a0, 0x173bc, + 0x173cc, 0x173d8, 0x173ee, 0x173f2, 0x173f4, 0x1740c, 0x17418, 0x17430, + 0x1743e, 0x17460, 0x1747c, 0x174c0, 0x174f8, 0x175f0, 0x1760e, 0x1761c, + 0x17638, 0x17670, 0x1767e, 0x176e0, 0x176fc, 0x17708, 0x17710, 0x1771e, + 0x17720, 0x1773c, 0x17740, 0x17778, 0x17798, 0x177b0, 0x177be, 0x177dc, + 0x177e2, 0x177e4, 0x177e8, 0x17822, 0x17824, 0x17828, 0x17836, 0x17842, + 0x17844, 0x17848, 0x17850, 0x1785e, 0x17866, 0x1786c, 0x17882, 0x17884, + 0x17888, 0x17890, 0x1789e, 0x178a0, 0x178bc, 0x178c6, 0x178cc, 0x178d8, + 0x178ee, 0x178f2, 0x178f4, 0x17902, 0x17904, 0x17908, 0x17910, 0x1791e, + 0x17920, 0x1793c, 0x17940, 0x17978, 0x17986, 0x1798c, 0x17998, 0x179b0, + 0x179be, 0x179ce, 0x179dc, 0x179e2, 0x179e4, 0x179e8, 0x179f6, 0x17a04, + 0x17a08, 0x17a10, 0x17a1e, 0x17a20, 0x17a3c, 0x17a40, 0x17a78, 0x17af0, + 0x17b06, 0x17b0c, 0x17b18, 0x17b30, 0x17b3e, 0x17b60, 0x17b7c, 0x17b8e, + 0x17b9c, 0x17bb8, 0x17bc4, 0x17bc8, 0x17bd0, 0x17bde, 0x17be6, 0x17bec, + 0x17c2e, 0x17c32, 0x17c34, 0x17c4e, 0x17c5c, 0x17c62, 0x17c64, 0x17c68, + 0x17c76, 0x17c8e, 0x17c9c, 0x17cb8, 0x17cc2, 0x17cc4, 0x17cc8, 0x17cd0, + 0x17cde, 0x17ce6, 0x17cec, 0x17d0e, 0x17d1c, 0x17d38, 0x17d70, 0x17d82, + 0x17d84, 0x17d88, 0x17d90, 0x17d9e, 0x17da0, 0x17dbc, 0x17dc6, 0x17dcc, + 0x17dd8, 0x17dee, 0x17e26, 0x17e2c, 0x17e3a, 0x17e46, 0x17e4c, 0x17e58, + 0x17e6e, 0x17e72, 0x17e74, 0x17e86, 0x17e8c, 0x17e98, 0x17eb0, 0x17ece, + 0x17edc, 0x17ee2, 0x17ee4, 0x17ee8, 0x17ef6, 0x1813a, 0x18172, 0x18174, + 0x18216, 0x18226, 0x1823a, 0x1824c, 0x18258, 0x1826e, 0x18272, 0x18274, + 0x18298, 0x182be, 0x182e2, 0x182e4, 0x182e8, 0x182f6, 0x1835e, 0x1837a, + 0x183ae, 0x183d6, 0x18416, 0x18426, 0x1842c, 0x1843a, 0x18446, 0x18458, + 0x1846e, 0x18472, 0x18474, 0x18486, 0x184b0, 0x184be, 0x184ce, 0x184dc, + 0x184e2, 0x184e4, 0x184e8, 0x184f6, 0x18506, 0x1850c, 0x18518, 0x18530, + 0x1853e, 0x18560, 0x1857c, 0x1858e, 0x1859c, 0x185b8, 0x185c2, 0x185c4, + 0x185c8, 0x185d0, 0x185de, 0x185e6, 0x185ec, 0x185fa, 0x18612, 0x18614, + 0x18622, 0x18628, 0x18636, 0x18642, 0x18650, 0x1865e, 0x1867a, 0x18682, + 0x18684, 0x18688, 0x18690, 0x1869e, 0x186a0, 0x186bc, 0x186c6, 0x186cc, + 0x186d8, 0x186ee, 0x186f2, 0x186f4, 0x1872e, 0x1874e, 0x1875c, 0x18796, + 0x187a6, 0x187ac, 0x187d2, 0x187d4, 0x18826, 0x1882c, 0x1883a, 0x18846, + 0x1884c, 0x18858, 0x1886e, 0x18872, 0x18874, 0x18886, 0x18898, 0x188b0, + 0x188be, 0x188ce, 0x188dc, 0x188e2, 0x188e4, 0x188e8, 0x188f6, 0x1890c, + 0x18930, 0x1893e, 0x18960, 0x1897c, 0x1898e, 0x189b8, 0x189c2, 0x189c8, + 0x189d0, 0x189de, 0x189e6, 0x189ec, 0x189fa, 0x18a18, 0x18a30, 0x18a3e, + 0x18a60, 0x18a7c, 0x18ac0, 0x18af8, 0x18b1c, 0x18b38, 0x18b70, 0x18b7e, + 0x18b82, 0x18b84, 0x18b88, 0x18b90, 0x18b9e, 0x18ba0, 0x18bbc, 0x18bc6, + 0x18bcc, 0x18bd8, 0x18bee, 0x18bf2, 0x18bf4, 0x18c22, 0x18c24, 0x18c28, + 0x18c36, 0x18c42, 0x18c48, 0x18c50, 0x18c5e, 0x18c66, 0x18c7a, 0x18c82, + 0x18c84, 0x18c90, 0x18c9e, 0x18ca0, 0x18cbc, 0x18ccc, 0x18cf2, 0x18cf4, + 0x18d04, 0x18d08, 0x18d10, 0x18d1e, 0x18d20, 0x18d3c, 0x18d40, 0x18d78, + 0x18d86, 0x18d98, 0x18dce, 0x18de2, 0x18de4, 0x18de8, 0x18e2e, 0x18e32, + 0x18e34, 0x18e4e, 0x18e5c, 0x18e62, 0x18e64, 0x18e68, 0x18e8e, 0x18e9c, + 0x18eb8, 0x18ec2, 0x18ec4, 0x18ec8, 0x18ed0, 0x18efa, 0x18f16, 0x18f26, + 0x18f2c, 0x18f46, 0x18f4c, 0x18f58, 0x18f6e, 0x18f8a, 0x18f92, 0x18f94, + 0x18fa2, 0x18fa4, 0x18fa8, 0x18fb6, 0x1902c, 0x1903a, 0x19046, 0x1904c, + 0x19058, 0x19072, 0x19074, 0x19086, 0x19098, 0x190b0, 0x190be, 0x190ce, + 0x190dc, 0x190e2, 0x190e8, 0x190f6, 0x19106, 0x1910c, 0x19130, 0x1913e, + 0x19160, 0x1917c, 0x1918e, 0x1919c, 0x191b8, 0x191c2, 0x191c8, 0x191d0, + 0x191de, 0x191e6, 0x191ec, 0x191fa, 0x19218, 0x1923e, 0x19260, 0x1927c, + 0x192c0, 0x192f8, 0x19338, 0x19370, 0x1937e, 0x19382, 0x19384, 0x19390, + 0x1939e, 0x193a0, 0x193bc, 0x193c6, 0x193cc, 0x193d8, 0x193ee, 0x193f2, + 0x193f4, 0x19430, 0x1943e, 0x19460, 0x1947c, 0x194c0, 0x194f8, 0x195f0, + 0x19638, 0x19670, 0x1967e, 0x196e0, 0x196fc, 0x19702, 0x19704, 0x19708, + 0x19710, 0x19720, 0x1973c, 0x19740, 0x19778, 0x19786, 0x1978c, 0x19798, + 0x197b0, 0x197be, 0x197ce, 0x197dc, 0x197e2, 0x197e4, 0x197e8, 0x19822, + 0x19824, 0x19842, 0x19848, 0x19850, 0x1985e, 0x19866, 0x1987a, 0x19882, + 0x19884, 0x19890, 0x1989e, 0x198a0, 0x198bc, 0x198cc, 0x198f2, 0x198f4, + 0x19902, 0x19908, 0x1991e, 0x19920, 0x1993c, 0x19940, 0x19978, 0x19986, + 0x19998, 0x199ce, 0x199e2, 0x199e4, 0x199e8, 0x19a08, 0x19a10, 0x19a1e, + 0x19a20, 0x19a3c, 0x19a40, 0x19a78, 0x19af0, 0x19b18, 0x19b3e, 0x19b60, + 0x19b9c, 0x19bc2, 0x19bc4, 0x19bc8, 0x19bd0, 0x19be6, 0x19c2e, 0x19c34, + 0x19c4e, 0x19c5c, 0x19c62, 0x19c64, 0x19c68, 0x19c8e, 0x19c9c, 0x19cb8, + 0x19cc2, 0x19cc8, 0x19cd0, 0x19ce6, 0x19cfa, 0x19d0e, 0x19d1c, 0x19d38, + 0x19d70, 0x19d7e, 0x19d82, 0x19d84, 0x19d88, 0x19d90, 0x19da0, 0x19dcc, + 0x19df2, 0x19df4, 0x19e16, 0x19e26, 0x19e2c, 0x19e46, 0x19e4c, 0x19e58, + 0x19e74, 0x19e86, 0x19e8c, 0x19e98, 0x19eb0, 0x19ebe, 0x19ece, 0x19ee2, + 0x19ee4, 0x19ee8, 0x19f0a, 0x19f12, 0x19f14, 0x19f22, 0x19f24, 0x19f28, + 0x19f42, 0x19f44, 0x19f48, 0x19f50, 0x19f5e, 0x19f6c, 0x19f9a, 0x19fae, + 0x19fb2, 0x19fb4, 0x1a046, 0x1a04c, 0x1a072, 0x1a074, 0x1a086, 0x1a08c, + 0x1a098, 0x1a0b0, 0x1a0be, 0x1a0e2, 0x1a0e4, 0x1a0e8, 0x1a0f6, 0x1a106, + 0x1a10c, 0x1a118, 0x1a130, 0x1a13e, 0x1a160, 0x1a17c, 0x1a18e, 0x1a19c, + 0x1a1b8, 0x1a1c2, 0x1a1c4, 0x1a1c8, 0x1a1d0, 0x1a1de, 0x1a1e6, 0x1a1ec, + 0x1a218, 0x1a230, 0x1a23e, 0x1a260, 0x1a27c, 0x1a2c0, 0x1a2f8, 0x1a31c, + 0x1a338, 0x1a370, 0x1a37e, 0x1a382, 0x1a384, 0x1a388, 0x1a390, 0x1a39e, + 0x1a3a0, 0x1a3bc, 0x1a3c6, 0x1a3cc, 0x1a3d8, 0x1a3ee, 0x1a3f2, 0x1a3f4, + 0x1a418, 0x1a430, 0x1a43e, 0x1a460, 0x1a47c, 0x1a4c0, 0x1a4f8, 0x1a5f0, + 0x1a61c, 0x1a638, 0x1a670, 0x1a67e, 0x1a6e0, 0x1a6fc, 0x1a702, 0x1a704, + 0x1a708, 0x1a710, 0x1a71e, 0x1a720, 0x1a73c, 0x1a740, 0x1a778, 0x1a786, + 0x1a78c, 0x1a798, 0x1a7b0, 0x1a7be, 0x1a7ce, 0x1a7dc, 0x1a7e2, 0x1a7e4, + 0x1a7e8, 0x1a830, 0x1a860, 0x1a87c, 0x1a8c0, 0x1a8f8, 0x1a9f0, 0x1abe0, + 0x1ac70, 0x1ac7e, 0x1ace0, 0x1acfc, 0x1adc0, 0x1adf8, 0x1ae04, 0x1ae08, + 0x1ae10, 0x1ae20, 0x1ae3c, 0x1ae40, 0x1ae78, 0x1aef0, 0x1af06, 0x1af0c, + 0x1af18, 0x1af30, 0x1af3e, 0x1af60, 0x1af7c, 0x1af8e, 0x1af9c, 0x1afb8, + 0x1afc4, 0x1afc8, 0x1afd0, 0x1afde, 0x1b042, 0x1b05e, 0x1b07a, 0x1b082, + 0x1b084, 0x1b088, 0x1b090, 0x1b09e, 0x1b0a0, 0x1b0bc, 0x1b0cc, 0x1b0f2, + 0x1b0f4, 0x1b102, 0x1b104, 0x1b108, 0x1b110, 0x1b11e, 0x1b120, 0x1b13c, + 0x1b140, 0x1b178, 0x1b186, 0x1b198, 0x1b1ce, 0x1b1e2, 0x1b1e4, 0x1b1e8, + 0x1b204, 0x1b208, 0x1b210, 0x1b21e, 0x1b220, 0x1b23c, 0x1b240, 0x1b278, + 0x1b2f0, 0x1b30c, 0x1b33e, 0x1b360, 0x1b39c, 0x1b3c2, 0x1b3c4, 0x1b3c8, + 0x1b3d0, 0x1b3e6, 0x1b410, 0x1b41e, 0x1b420, 0x1b43c, 0x1b440, 0x1b478, + 0x1b4f0, 0x1b5e0, 0x1b618, 0x1b660, 0x1b67c, 0x1b6c0, 0x1b738, 0x1b782, + 0x1b784, 0x1b788, 0x1b790, 0x1b79e, 0x1b7a0, 0x1b7cc, 0x1b82e, 0x1b84e, + 0x1b85c, 0x1b88e, 0x1b89c, 0x1b8b8, 0x1b8c2, 0x1b8c4, 0x1b8c8, 0x1b8d0, + 0x1b8e6, 0x1b8fa, 0x1b90e, 0x1b91c, 0x1b938, 0x1b970, 0x1b97e, 0x1b982, + 0x1b984, 0x1b988, 0x1b990, 0x1b99e, 0x1b9a0, 0x1b9cc, 0x1b9f2, 0x1b9f4, + 0x1ba0e, 0x1ba1c, 0x1ba38, 0x1ba70, 0x1ba7e, 0x1bae0, 0x1bafc, 0x1bb08, + 0x1bb10, 0x1bb20, 0x1bb3c, 0x1bb40, 0x1bb98, 0x1bbce, 0x1bbe2, 0x1bbe4, + 0x1bbe8, 0x1bc16, 0x1bc26, 0x1bc2c, 0x1bc46, 0x1bc4c, 0x1bc58, 0x1bc72, + 0x1bc74, 0x1bc86, 0x1bc8c, 0x1bc98, 0x1bcb0, 0x1bcbe, 0x1bcce, 0x1bce2, + 0x1bce4, 0x1bce8, 0x1bd06, 0x1bd0c, 0x1bd18, 0x1bd30, 0x1bd3e, 0x1bd60, + 0x1bd7c, 0x1bd9c, 0x1bdc2, 0x1bdc4, 0x1bdc8, 0x1bdd0, 0x1bde6, 0x1bdfa, + 0x1be12, 0x1be14, 0x1be22, 0x1be24, 0x1be28, 0x1be42, 0x1be44, 0x1be48, + 0x1be50, 0x1be5e, 0x1be66, 0x1be82, 0x1be84, 0x1be88, 0x1be90, 0x1be9e, + 0x1bea0, 0x1bebc, 0x1becc, 0x1bef4, 0x1bf1a, 0x1bf2e, 0x1bf32, 0x1bf34, + 0x1bf4e, 0x1bf5c, 0x1bf62, 0x1bf64, 0x1bf68, 0x1c09a, 0x1c0b2, 0x1c0b4, + 0x1c11a, 0x1c132, 0x1c134, 0x1c162, 0x1c164, 0x1c168, 0x1c176, 0x1c1ba, + 0x1c21a, 0x1c232, 0x1c234, 0x1c24e, 0x1c25c, 0x1c262, 0x1c264, 0x1c268, + 0x1c276, 0x1c28e, 0x1c2c2, 0x1c2c4, 0x1c2c8, 0x1c2d0, 0x1c2de, 0x1c2e6, + 0x1c2ec, 0x1c2fa, 0x1c316, 0x1c326, 0x1c33a, 0x1c346, 0x1c34c, 0x1c372, + 0x1c374, 0x1c41a, 0x1c42e, 0x1c432, 0x1c434, 0x1c44e, 0x1c45c, 0x1c462, + 0x1c464, 0x1c468, 0x1c476, 0x1c48e, 0x1c49c, 0x1c4b8, 0x1c4c2, 0x1c4c8, + 0x1c4d0, 0x1c4de, 0x1c4e6, 0x1c4ec, 0x1c4fa, 0x1c51c, 0x1c538, 0x1c570, + 0x1c57e, 0x1c582, 0x1c584, 0x1c588, 0x1c590, 0x1c59e, 0x1c5a0, 0x1c5bc, + 0x1c5c6, 0x1c5cc, 0x1c5d8, 0x1c5ee, 0x1c5f2, 0x1c5f4, 0x1c616, 0x1c626, + 0x1c62c, 0x1c63a, 0x1c646, 0x1c64c, 0x1c658, 0x1c66e, 0x1c672, 0x1c674, + 0x1c686, 0x1c68c, 0x1c698, 0x1c6b0, 0x1c6be, 0x1c6ce, 0x1c6dc, 0x1c6e2, + 0x1c6e4, 0x1c6e8, 0x1c712, 0x1c714, 0x1c722, 0x1c728, 0x1c736, 0x1c742, + 0x1c744, 0x1c748, 0x1c750, 0x1c75e, 0x1c766, 0x1c76c, 0x1c77a, 0x1c7ae, + 0x1c7d6, 0x1c7ea, 0x1c81a, 0x1c82e, 0x1c832, 0x1c834, 0x1c84e, 0x1c85c, + 0x1c862, 0x1c864, 0x1c868, 0x1c876, 0x1c88e, 0x1c89c, 0x1c8b8, 0x1c8c2, + 0x1c8c8, 0x1c8d0, 0x1c8de, 0x1c8e6, 0x1c8ec, 0x1c8fa, 0x1c90e, 0x1c938, + 0x1c970, 0x1c97e, 0x1c982, 0x1c984, 0x1c990, 0x1c99e, 0x1c9a0, 0x1c9bc, + 0x1c9c6, 0x1c9cc, 0x1c9d8, 0x1c9ee, 0x1c9f2, 0x1c9f4, 0x1ca38, 0x1ca70, + 0x1ca7e, 0x1cae0, 0x1cafc, 0x1cb02, 0x1cb04, 0x1cb08, 0x1cb10, 0x1cb20, + 0x1cb3c, 0x1cb40, 0x1cb78, 0x1cb86, 0x1cb8c, 0x1cb98, 0x1cbb0, 0x1cbbe, + 0x1cbce, 0x1cbdc, 0x1cbe2, 0x1cbe4, 0x1cbe8, 0x1cbf6, 0x1cc16, 0x1cc26, + 0x1cc2c, 0x1cc3a, 0x1cc46, 0x1cc58, 0x1cc72, 0x1cc74, 0x1cc86, 0x1ccb0, + 0x1ccbe, 0x1ccce, 0x1cce2, 0x1cce4, 0x1cce8, 0x1cd06, 0x1cd0c, 0x1cd18, + 0x1cd30, 0x1cd3e, 0x1cd60, 0x1cd7c, 0x1cd9c, 0x1cdc2, 0x1cdc4, 0x1cdc8, + 0x1cdd0, 0x1cdde, 0x1cde6, 0x1cdfa, 0x1ce22, 0x1ce28, 0x1ce42, 0x1ce50, + 0x1ce5e, 0x1ce66, 0x1ce7a, 0x1ce82, 0x1ce84, 0x1ce88, 0x1ce90, 0x1ce9e, + 0x1cea0, 0x1cebc, 0x1cecc, 0x1cef2, 0x1cef4, 0x1cf2e, 0x1cf32, 0x1cf34, + 0x1cf4e, 0x1cf5c, 0x1cf62, 0x1cf64, 0x1cf68, 0x1cf96, 0x1cfa6, 0x1cfac, + 0x1cfca, 0x1cfd2, 0x1cfd4, 0x1d02e, 0x1d032, 0x1d034, 0x1d04e, 0x1d05c, + 0x1d062, 0x1d064, 0x1d068, 0x1d076, 0x1d08e, 0x1d09c, 0x1d0b8, 0x1d0c2, + 0x1d0c4, 0x1d0c8, 0x1d0d0, 0x1d0de, 0x1d0e6, 0x1d0ec, 0x1d0fa, 0x1d11c, + 0x1d138, 0x1d170, 0x1d17e, 0x1d182, 0x1d184, 0x1d188, 0x1d190, 0x1d19e, + 0x1d1a0, 0x1d1bc, 0x1d1c6, 0x1d1cc, 0x1d1d8, 0x1d1ee, 0x1d1f2, 0x1d1f4, + 0x1d21c, 0x1d238, 0x1d270, 0x1d27e, 0x1d2e0, 0x1d2fc, 0x1d302, 0x1d304, + 0x1d308, 0x1d310, 0x1d31e, 0x1d320, 0x1d33c, 0x1d340, 0x1d378, 0x1d386, + 0x1d38c, 0x1d398, 0x1d3b0, 0x1d3be, 0x1d3ce, 0x1d3dc, 0x1d3e2, 0x1d3e4, + 0x1d3e8, 0x1d3f6, 0x1d470, 0x1d47e, 0x1d4e0, 0x1d4fc, 0x1d5c0, 0x1d5f8, + 0x1d604, 0x1d608, 0x1d610, 0x1d620, 0x1d640, 0x1d678, 0x1d6f0, 0x1d706, + 0x1d70c, 0x1d718, 0x1d730, 0x1d73e, 0x1d760, 0x1d77c, 0x1d78e, 0x1d79c, + 0x1d7b8, 0x1d7c2, 0x1d7c4, 0x1d7c8, 0x1d7d0, 0x1d7de, 0x1d7e6, 0x1d7ec, + 0x1d826, 0x1d82c, 0x1d83a, 0x1d846, 0x1d84c, 0x1d858, 0x1d872, 0x1d874, + 0x1d886, 0x1d88c, 0x1d898, 0x1d8b0, 0x1d8be, 0x1d8ce, 0x1d8e2, 0x1d8e4, + 0x1d8e8, 0x1d8f6, 0x1d90c, 0x1d918, 0x1d930, 0x1d93e, 0x1d960, 0x1d97c, + 0x1d99c, 0x1d9c2, 0x1d9c4, 0x1d9c8, 0x1d9d0, 0x1d9e6, 0x1d9fa, 0x1da0c, + 0x1da18, 0x1da30, 0x1da3e, 0x1da60, 0x1da7c, 0x1dac0, 0x1daf8, 0x1db38, + 0x1db82, 0x1db84, 0x1db88, 0x1db90, 0x1db9e, 0x1dba0, 0x1dbcc, 0x1dbf2, + 0x1dbf4, 0x1dc22, 0x1dc42, 0x1dc44, 0x1dc48, 0x1dc50, 0x1dc5e, 0x1dc66, + 0x1dc7a, 0x1dc82, 0x1dc84, 0x1dc88, 0x1dc90, 0x1dc9e, 0x1dca0, 0x1dcbc, + 0x1dccc, 0x1dcf2, 0x1dcf4, 0x1dd04, 0x1dd08, 0x1dd10, 0x1dd1e, 0x1dd20, + 0x1dd3c, 0x1dd40, 0x1dd78, 0x1dd86, 0x1dd98, 0x1ddce, 0x1dde2, 0x1dde4, + 0x1dde8, 0x1de2e, 0x1de32, 0x1de34, 0x1de4e, 0x1de5c, 0x1de62, 0x1de64, + 0x1de68, 0x1de8e, 0x1de9c, 0x1deb8, 0x1dec2, 0x1dec4, 0x1dec8, 0x1ded0, + 0x1dee6, 0x1defa, 0x1df16, 0x1df26, 0x1df2c, 0x1df46, 0x1df4c, 0x1df58, + 0x1df72, 0x1df74, 0x1df8a, 0x1df92, 0x1df94, 0x1dfa2, 0x1dfa4, 0x1dfa8, + 0x1e08a, 0x1e092, 0x1e094, 0x1e0a2, 0x1e0a4, 0x1e0a8, 0x1e0b6, 0x1e0da, + 0x1e10a, 0x1e112, 0x1e114, 0x1e122, 0x1e124, 0x1e128, 0x1e136, 0x1e142, + 0x1e144, 0x1e148, 0x1e150, 0x1e166, 0x1e16c, 0x1e17a, 0x1e19a, 0x1e1b2, + 0x1e1b4, 0x1e20a, 0x1e212, 0x1e214, 0x1e222, 0x1e224, 0x1e228, 0x1e236, + 0x1e242, 0x1e248, 0x1e250, 0x1e25e, 0x1e266, 0x1e26c, 0x1e27a, 0x1e282, + 0x1e284, 0x1e288, 0x1e290, 0x1e2a0, 0x1e2bc, 0x1e2c6, 0x1e2cc, 0x1e2d8, + 0x1e2ee, 0x1e2f2, 0x1e2f4, 0x1e31a, 0x1e332, 0x1e334, 0x1e35c, 0x1e362, + 0x1e364, 0x1e368, 0x1e3ba, 0x1e40a, 0x1e412, 0x1e414, 0x1e422, 0x1e428, + 0x1e436, 0x1e442, 0x1e448, 0x1e450, 0x1e45e, 0x1e466, 0x1e46c, 0x1e47a, + 0x1e482, 0x1e484, 0x1e490, 0x1e49e, 0x1e4a0, 0x1e4bc, 0x1e4c6, 0x1e4cc, + 0x1e4d8, 0x1e4ee, 0x1e4f2, 0x1e4f4, 0x1e502, 0x1e504, 0x1e508, 0x1e510, + 0x1e51e, 0x1e520, 0x1e53c, 0x1e540, 0x1e578, 0x1e586, 0x1e58c, 0x1e598, + 0x1e5b0, 0x1e5be, 0x1e5ce, 0x1e5dc, 0x1e5e2, 0x1e5e4, 0x1e5e8, 0x1e5f6, + 0x1e61a, 0x1e62e, 0x1e632, 0x1e634, 0x1e64e, 0x1e65c, 0x1e662, 0x1e668, + 0x1e68e, 0x1e69c, 0x1e6b8, 0x1e6c2, 0x1e6c4, 0x1e6c8, 0x1e6d0, 0x1e6e6, + 0x1e6fa, 0x1e716, 0x1e726, 0x1e72c, 0x1e73a, 0x1e746, 0x1e74c, 0x1e758, + 0x1e772, 0x1e774, 0x1e792, 0x1e794, 0x1e7a2, 0x1e7a4, 0x1e7a8, 0x1e7b6, + 0x1e812, 0x1e814, 0x1e822, 0x1e824, 0x1e828, 0x1e836, 0x1e842, 0x1e844, + 0x1e848, 0x1e850, 0x1e85e, 0x1e866, 0x1e86c, 0x1e87a, 0x1e882, 0x1e884, + 0x1e888, 0x1e890, 0x1e89e, 0x1e8a0, 0x1e8bc, 0x1e8c6, 0x1e8cc, 0x1e8d8, + 0x1e8ee, 0x1e8f2, 0x1e8f4, 0x1e902, 0x1e904, 0x1e908, 0x1e910, 0x1e920, + 0x1e93c, 0x1e940, 0x1e978, 0x1e986, 0x1e98c, 0x1e998, 0x1e9b0, 0x1e9be, + 0x1e9ce, 0x1e9dc, 0x1e9e2, 0x1e9e4, 0x1e9e8, 0x1e9f6, 0x1ea04, 0x1ea08, + 0x1ea10, 0x1ea20, 0x1ea40, 0x1ea78, 0x1eaf0, 0x1eb06, 0x1eb0c, 0x1eb18, + 0x1eb30, 0x1eb3e, 0x1eb60, 0x1eb7c, 0x1eb8e, 0x1eb9c, 0x1ebb8, 0x1ebc2, + 0x1ebc4, 0x1ebc8, 0x1ebd0, 0x1ebde, 0x1ebe6, 0x1ebec, 0x1ec1a, 0x1ec2e, + 0x1ec32, 0x1ec34, 0x1ec4e, 0x1ec5c, 0x1ec62, 0x1ec64, 0x1ec68, 0x1ec8e, + 0x1ec9c, 0x1ecb8, 0x1ecc2, 0x1ecc4, 0x1ecc8, 0x1ecd0, 0x1ece6, 0x1ecfa, + 0x1ed0e, 0x1ed1c, 0x1ed38, 0x1ed70, 0x1ed7e, 0x1ed82, 0x1ed84, 0x1ed88, + 0x1ed90, 0x1ed9e, 0x1eda0, 0x1edcc, 0x1edf2, 0x1edf4, 0x1ee16, 0x1ee26, + 0x1ee2c, 0x1ee3a, 0x1ee46, 0x1ee4c, 0x1ee58, 0x1ee6e, 0x1ee72, 0x1ee74, + 0x1ee86, 0x1ee8c, 0x1ee98, 0x1eeb0, 0x1eebe, 0x1eece, 0x1eedc, 0x1eee2, + 0x1eee4, 0x1eee8, 0x1ef12, 0x1ef22, 0x1ef24, 0x1ef28, 0x1ef36, 0x1ef42, + 0x1ef44, 0x1ef48, 0x1ef50, 0x1ef5e, 0x1ef66, 0x1ef6c, 0x1ef7a, 0x1efae, + 0x1efb2, 0x1efb4, 0x1efd6, 0x1f096, 0x1f0a6, 0x1f0ac, 0x1f0ba, 0x1f0ca, + 0x1f0d2, 0x1f0d4, 0x1f116, 0x1f126, 0x1f12c, 0x1f13a, 0x1f146, 0x1f14c, + 0x1f158, 0x1f16e, 0x1f172, 0x1f174, 0x1f18a, 0x1f192, 0x1f194, 0x1f1a2, + 0x1f1a4, 0x1f1a8, 0x1f1da, 0x1f216, 0x1f226, 0x1f22c, 0x1f23a, 0x1f246, + 0x1f258, 0x1f26e, 0x1f272, 0x1f274, 0x1f286, 0x1f28c, 0x1f298, 0x1f2b0, + 0x1f2be, 0x1f2ce, 0x1f2dc, 0x1f2e2, 0x1f2e4, 0x1f2e8, 0x1f2f6, 0x1f30a, + 0x1f312, 0x1f314, 0x1f322, 0x1f328, 0x1f342, 0x1f344, 0x1f348, 0x1f350, + 0x1f35e, 0x1f366, 0x1f37a, 0x1f39a, 0x1f3ae, 0x1f3b2, 0x1f3b4, 0x1f416, + 0x1f426, 0x1f42c, 0x1f43a, 0x1f446, 0x1f44c, 0x1f458, 0x1f46e, 0x1f472, + 0x1f474, 0x1f486, 0x1f48c, 0x1f498, 0x1f4b0, 0x1f4be, 0x1f4ce, 0x1f4dc, + 0x1f4e2, 0x1f4e4, 0x1f4e8, 0x1f4f6, 0x1f506, 0x1f50c, 0x1f518, 0x1f530, + 0x1f53e, 0x1f560, 0x1f57c, 0x1f58e, 0x1f59c, 0x1f5b8, 0x1f5c2, 0x1f5c4, + 0x1f5c8, 0x1f5d0, 0x1f5de, 0x1f5e6, 0x1f5ec, 0x1f5fa, 0x1f60a, 0x1f612, + 0x1f614, 0x1f622, 0x1f624, 0x1f628, 0x1f636, 0x1f642, 0x1f644, 0x1f648, + 0x1f650, 0x1f65e, 0x1f666, 0x1f67a, 0x1f682, 0x1f684, 0x1f688, 0x1f690, + 0x1f69e, 0x1f6a0, 0x1f6bc, 0x1f6cc, 0x1f6f2, 0x1f6f4, 0x1f71a, 0x1f72e, + 0x1f732, 0x1f734, 0x1f74e, 0x1f75c, 0x1f762, 0x1f764, 0x1f768, 0x1f776, + 0x1f796, 0x1f7a6, 0x1f7ac, 0x1f7ba, 0x1f7d2, 0x1f7d4, 0x1f89a, 0x1f8ae, + 0x1f8b2, 0x1f8b4, 0x1f8d6, 0x1f8ea, 0x1f91a, 0x1f92e, 0x1f932, 0x1f934, + 0x1f94e, 0x1f95c, 0x1f962, 0x1f964, 0x1f968, 0x1f976, 0x1f996, 0x1f9a6, + 0x1f9ac, 0x1f9ba, 0x1f9ca, 0x1f9d2, 0x1f9d4, 0x1fa1a, 0x1fa2e, 0x1fa32, + 0x1fa34, 0x1fa4e, 0x1fa5c, 0x1fa62, 0x1fa64, 0x1fa68, 0x1fa76, 0x1fa8e, + 0x1fa9c, 0x1fab8, 0x1fac2, 0x1fac4, 0x1fac8, 0x1fad0, 0x1fade, 0x1fae6, + 0x1faec, 0x1fb16, 0x1fb26, 0x1fb2c, 0x1fb3a, 0x1fb46, 0x1fb4c, 0x1fb58, + 0x1fb6e, 0x1fb72, 0x1fb74, 0x1fb8a, 0x1fb92, 0x1fb94, 0x1fba2, 0x1fba4, + 0x1fba8, 0x1fbb6, 0x1fbda}; +int32_t CBC_PDF417Common::CODEWORD_TABLE[] = { + 2627, 1819, 2622, 2621, 1813, 1812, 2729, 2724, 2723, 2779, 2774, 2773, + 902, 896, 908, 868, 865, 861, 859, 2511, 873, 871, 1780, 835, + 2493, 825, 2491, 842, 837, 844, 1764, 1762, 811, 810, 809, 2483, + 807, 2482, 806, 2480, 815, 814, 813, 812, 2484, 817, 816, 1745, + 1744, 1742, 1746, 2655, 2637, 2635, 2626, 2625, 2623, 2628, 1820, 2752, + 2739, 2737, 2728, 2727, 2725, 2730, 2785, 2783, 2778, 2777, 2775, 2780, + 787, 781, 747, 739, 736, 2413, 754, 752, 1719, 692, 689, 681, + 2371, 678, 2369, 700, 697, 694, 703, 1688, 1686, 642, 638, 2343, + 631, 2341, 627, 2338, 651, 646, 643, 2345, 654, 652, 1652, 1650, + 1647, 1654, 601, 599, 2322, 596, 2321, 594, 2319, 2317, 611, 610, + 608, 606, 2324, 603, 2323, 615, 614, 612, 1617, 1616, 1614, 1612, + 616, 1619, 1618, 2575, 2538, 2536, 905, 901, 898, 909, 2509, 2507, + 2504, 870, 867, 864, 860, 2512, 875, 872, 1781, 2490, 2489, 2487, + 2485, 1748, 836, 834, 832, 830, 2494, 827, 2492, 843, 841, 839, + 845, 1765, 1763, 2701, 2676, 2674, 2653, 2648, 2656, 2634, 2633, 2631, + 2629, 1821, 2638, 2636, 2770, 2763, 2761, 2750, 2745, 2753, 2736, 2735, + 2733, 2731, 1848, 2740, 2738, 2786, 2784, 591, 588, 576, 569, 566, + 2296, 1590, 537, 534, 526, 2276, 522, 2274, 545, 542, 539, 548, + 1572, 1570, 481, 2245, 466, 2242, 462, 2239, 492, 485, 482, 2249, + 496, 494, 1534, 1531, 1528, 1538, 413, 2196, 406, 2191, 2188, 425, + 419, 2202, 415, 2199, 432, 430, 427, 1472, 1467, 1464, 433, 1476, + 1474, 368, 367, 2160, 365, 2159, 362, 2157, 2155, 2152, 378, 377, + 375, 2166, 372, 2165, 369, 2162, 383, 381, 379, 2168, 1419, 1418, + 1416, 1414, 385, 1411, 384, 1423, 1422, 1420, 1424, 2461, 802, 2441, + 2439, 790, 786, 783, 794, 2409, 2406, 2403, 750, 742, 738, 2414, + 756, 753, 1720, 2367, 2365, 2362, 2359, 1663, 693, 691, 684, 2373, + 680, 2370, 702, 699, 696, 704, 1690, 1687, 2337, 2336, 2334, 2332, + 1624, 2329, 1622, 640, 637, 2344, 634, 2342, 630, 2340, 650, 648, + 645, 2346, 655, 653, 1653, 1651, 1649, 1655, 2612, 2597, 2595, 2571, + 2568, 2565, 2576, 2534, 2529, 2526, 1787, 2540, 2537, 907, 904, 900, + 910, 2503, 2502, 2500, 2498, 1768, 2495, 1767, 2510, 2508, 2506, 869, + 866, 863, 2513, 876, 874, 1782, 2720, 2713, 2711, 2697, 2694, 2691, + 2702, 2672, 2670, 2664, 1828, 2678, 2675, 2647, 2646, 2644, 2642, 1823, + 2639, 1822, 2654, 2652, 2650, 2657, 2771, 1855, 2765, 2762, 1850, 1849, + 2751, 2749, 2747, 2754, 353, 2148, 344, 342, 336, 2142, 332, 2140, + 345, 1375, 1373, 306, 2130, 299, 2128, 295, 2125, 319, 314, 311, + 2132, 1354, 1352, 1349, 1356, 262, 257, 2101, 253, 2096, 2093, 274, + 273, 267, 2107, 263, 2104, 280, 278, 275, 1316, 1311, 1308, 1320, + 1318, 2052, 202, 2050, 2044, 2040, 219, 2063, 212, 2060, 208, 2055, + 224, 221, 2066, 1260, 1258, 1252, 231, 1248, 229, 1266, 1264, 1261, + 1268, 155, 1998, 153, 1996, 1994, 1991, 1988, 165, 164, 2007, 162, + 2006, 159, 2003, 2000, 172, 171, 169, 2012, 166, 2010, 1186, 1184, + 1182, 1179, 175, 1176, 173, 1192, 1191, 1189, 1187, 176, 1194, 1193, + 2313, 2307, 2305, 592, 589, 2294, 2292, 2289, 578, 572, 568, 2297, + 580, 1591, 2272, 2267, 2264, 1547, 538, 536, 529, 2278, 525, 2275, + 547, 544, 541, 1574, 1571, 2237, 2235, 2229, 1493, 2225, 1489, 478, + 2247, 470, 2244, 465, 2241, 493, 488, 484, 2250, 498, 495, 1536, + 1533, 1530, 1539, 2187, 2186, 2184, 2182, 1432, 2179, 1430, 2176, 1427, + 414, 412, 2197, 409, 2195, 405, 2193, 2190, 426, 424, 421, 2203, + 418, 2201, 431, 429, 1473, 1471, 1469, 1466, 434, 1477, 1475, 2478, + 2472, 2470, 2459, 2457, 2454, 2462, 803, 2437, 2432, 2429, 1726, 2443, + 2440, 792, 789, 785, 2401, 2399, 2393, 1702, 2389, 1699, 2411, 2408, + 2405, 745, 741, 2415, 758, 755, 1721, 2358, 2357, 2355, 2353, 1661, + 2350, 1660, 2347, 1657, 2368, 2366, 2364, 2361, 1666, 690, 687, 2374, + 683, 2372, 701, 698, 705, 1691, 1689, 2619, 2617, 2610, 2608, 2605, + 2613, 2593, 2588, 2585, 1803, 2599, 2596, 2563, 2561, 2555, 1797, 2551, + 1795, 2573, 2570, 2567, 2577, 2525, 2524, 2522, 2520, 1786, 2517, 1785, + 2514, 1783, 2535, 2533, 2531, 2528, 1788, 2541, 2539, 906, 903, 911, + 2721, 1844, 2715, 2712, 1838, 1836, 2699, 2696, 2693, 2703, 1827, 1826, + 1824, 2673, 2671, 2669, 2666, 1829, 2679, 2677, 1858, 1857, 2772, 1854, + 1853, 1851, 1856, 2766, 2764, 143, 1987, 139, 1986, 135, 133, 131, + 1984, 128, 1983, 125, 1981, 138, 137, 136, 1985, 1133, 1132, 1130, + 112, 110, 1974, 107, 1973, 104, 1971, 1969, 122, 121, 119, 117, + 1977, 114, 1976, 124, 1115, 1114, 1112, 1110, 1117, 1116, 84, 83, + 1953, 81, 1952, 78, 1950, 1948, 1945, 94, 93, 91, 1959, 88, + 1958, 85, 1955, 99, 97, 95, 1961, 1086, 1085, 1083, 1081, 1078, + 100, 1090, 1089, 1087, 1091, 49, 47, 1917, 44, 1915, 1913, 1910, + 1907, 59, 1926, 56, 1925, 53, 1922, 1919, 66, 64, 1931, 61, + 1929, 1042, 1040, 1038, 71, 1035, 70, 1032, 68, 1048, 1047, 1045, + 1043, 1050, 1049, 12, 10, 1869, 1867, 1864, 1861, 21, 1880, 19, + 1877, 1874, 1871, 28, 1888, 25, 1886, 22, 1883, 982, 980, 977, + 974, 32, 30, 991, 989, 987, 984, 34, 995, 994, 992, 2151, + 2150, 2147, 2146, 2144, 356, 355, 354, 2149, 2139, 2138, 2136, 2134, + 1359, 343, 341, 338, 2143, 335, 2141, 348, 347, 346, 1376, 1374, + 2124, 2123, 2121, 2119, 1326, 2116, 1324, 310, 308, 305, 2131, 302, + 2129, 298, 2127, 320, 318, 316, 313, 2133, 322, 321, 1355, 1353, + 1351, 1357, 2092, 2091, 2089, 2087, 1276, 2084, 1274, 2081, 1271, 259, + 2102, 256, 2100, 252, 2098, 2095, 272, 269, 2108, 266, 2106, 281, + 279, 277, 1317, 1315, 1313, 1310, 282, 1321, 1319, 2039, 2037, 2035, + 2032, 1203, 2029, 1200, 1197, 207, 2053, 205, 2051, 201, 2049, 2046, + 2043, 220, 218, 2064, 215, 2062, 211, 2059, 228, 226, 223, 2069, + 1259, 1257, 1254, 232, 1251, 230, 1267, 1265, 1263, 2316, 2315, 2312, + 2311, 2309, 2314, 2304, 2303, 2301, 2299, 1593, 2308, 2306, 590, 2288, + 2287, 2285, 2283, 1578, 2280, 1577, 2295, 2293, 2291, 579, 577, 574, + 571, 2298, 582, 581, 1592, 2263, 2262, 2260, 2258, 1545, 2255, 1544, + 2252, 1541, 2273, 2271, 2269, 2266, 1550, 535, 532, 2279, 528, 2277, + 546, 543, 549, 1575, 1573, 2224, 2222, 2220, 1486, 2217, 1485, 2214, + 1482, 1479, 2238, 2236, 2234, 2231, 1496, 2228, 1492, 480, 477, 2248, + 473, 2246, 469, 2243, 490, 487, 2251, 497, 1537, 1535, 1532, 2477, + 2476, 2474, 2479, 2469, 2468, 2466, 2464, 1730, 2473, 2471, 2453, 2452, + 2450, 2448, 1729, 2445, 1728, 2460, 2458, 2456, 2463, 805, 804, 2428, + 2427, 2425, 2423, 1725, 2420, 1724, 2417, 1722, 2438, 2436, 2434, 2431, + 1727, 2444, 2442, 793, 791, 788, 795, 2388, 2386, 2384, 1697, 2381, + 1696, 2378, 1694, 1692, 2402, 2400, 2398, 2395, 1703, 2392, 1701, 2412, + 2410, 2407, 751, 748, 744, 2416, 759, 757, 1807, 2620, 2618, 1806, + 1805, 2611, 2609, 2607, 2614, 1802, 1801, 1799, 2594, 2592, 2590, 2587, + 1804, 2600, 2598, 1794, 1793, 1791, 1789, 2564, 2562, 2560, 2557, 1798, + 2554, 1796, 2574, 2572, 2569, 2578, 1847, 1846, 2722, 1843, 1842, 1840, + 1845, 2716, 2714, 1835, 1834, 1832, 1830, 1839, 1837, 2700, 2698, 2695, + 2704, 1817, 1811, 1810, 897, 862, 1777, 829, 826, 838, 1760, 1758, + 808, 2481, 1741, 1740, 1738, 1743, 2624, 1818, 2726, 2776, 782, 740, + 737, 1715, 686, 679, 695, 1682, 1680, 639, 628, 2339, 647, 644, + 1645, 1643, 1640, 1648, 602, 600, 597, 595, 2320, 593, 2318, 609, + 607, 604, 1611, 1610, 1608, 1606, 613, 1615, 1613, 2328, 926, 924, + 892, 886, 899, 857, 850, 2505, 1778, 824, 823, 821, 819, 2488, + 818, 2486, 833, 831, 828, 840, 1761, 1759, 2649, 2632, 2630, 2746, + 2734, 2732, 2782, 2781, 570, 567, 1587, 531, 527, 523, 540, 1566, + 1564, 476, 467, 463, 2240, 486, 483, 1524, 1521, 1518, 1529, 411, + 403, 2192, 399, 2189, 423, 416, 1462, 1457, 1454, 428, 1468, 1465, + 2210, 366, 363, 2158, 360, 2156, 357, 2153, 376, 373, 370, 2163, + 1410, 1409, 1407, 1405, 382, 1402, 380, 1417, 1415, 1412, 1421, 2175, + 2174, 777, 774, 771, 784, 732, 725, 722, 2404, 743, 1716, 676, + 674, 668, 2363, 665, 2360, 685, 1684, 1681, 626, 624, 622, 2335, + 620, 2333, 617, 2330, 641, 635, 649, 1646, 1644, 1642, 2566, 928, + 925, 2530, 2527, 894, 891, 888, 2501, 2499, 2496, 858, 856, 854, + 851, 1779, 2692, 2668, 2665, 2645, 2643, 2640, 2651, 2768, 2759, 2757, + 2744, 2743, 2741, 2748, 352, 1382, 340, 337, 333, 1371, 1369, 307, + 300, 296, 2126, 315, 312, 1347, 1342, 1350, 261, 258, 250, 2097, + 246, 2094, 271, 268, 264, 1306, 1301, 1298, 276, 1312, 1309, 2115, + 203, 2048, 195, 2045, 191, 2041, 213, 209, 2056, 1246, 1244, 1238, + 225, 1234, 222, 1256, 1253, 1249, 1262, 2080, 2079, 154, 1997, 150, + 1995, 147, 1992, 1989, 163, 160, 2004, 156, 2001, 1175, 1174, 1172, + 1170, 1167, 170, 1164, 167, 1185, 1183, 1180, 1177, 174, 1190, 1188, + 2025, 2024, 2022, 587, 586, 564, 559, 556, 2290, 573, 1588, 520, + 518, 512, 2268, 508, 2265, 530, 1568, 1565, 461, 457, 2233, 450, + 2230, 446, 2226, 479, 471, 489, 1526, 1523, 1520, 397, 395, 2185, + 392, 2183, 389, 2180, 2177, 410, 2194, 402, 422, 1463, 1461, 1459, + 1456, 1470, 2455, 799, 2433, 2430, 779, 776, 773, 2397, 2394, 2390, + 734, 728, 724, 746, 1717, 2356, 2354, 2351, 2348, 1658, 677, 675, + 673, 670, 667, 688, 1685, 1683, 2606, 2589, 2586, 2559, 2556, 2552, + 927, 2523, 2521, 2518, 2515, 1784, 2532, 895, 893, 890, 2718, 2709, + 2707, 2689, 2687, 2684, 2663, 2662, 2660, 2658, 1825, 2667, 2769, 1852, + 2760, 2758, 142, 141, 1139, 1138, 134, 132, 129, 126, 1982, 1129, + 1128, 1126, 1131, 113, 111, 108, 105, 1972, 101, 1970, 120, 118, + 115, 1109, 1108, 1106, 1104, 123, 1113, 1111, 82, 79, 1951, 75, + 1949, 72, 1946, 92, 89, 86, 1956, 1077, 1076, 1074, 1072, 98, + 1069, 96, 1084, 1082, 1079, 1088, 1968, 1967, 48, 45, 1916, 42, + 1914, 39, 1911, 1908, 60, 57, 54, 1923, 50, 1920, 1031, 1030, + 1028, 1026, 67, 1023, 65, 1020, 62, 1041, 1039, 1036, 1033, 69, + 1046, 1044, 1944, 1943, 1941, 11, 9, 1868, 7, 1865, 1862, 1859, + 20, 1878, 16, 1875, 13, 1872, 970, 968, 966, 963, 29, 960, + 26, 23, 983, 981, 978, 975, 33, 971, 31, 990, 988, 985, + 1906, 1904, 1902, 993, 351, 2145, 1383, 331, 330, 328, 326, 2137, + 323, 2135, 339, 1372, 1370, 294, 293, 291, 289, 2122, 286, 2120, + 283, 2117, 309, 303, 317, 1348, 1346, 1344, 245, 244, 242, 2090, + 239, 2088, 236, 2085, 2082, 260, 2099, 249, 270, 1307, 1305, 1303, + 1300, 1314, 189, 2038, 186, 2036, 183, 2033, 2030, 2026, 206, 198, + 2047, 194, 216, 1247, 1245, 1243, 1240, 227, 1237, 1255, 2310, 2302, + 2300, 2286, 2284, 2281, 565, 563, 561, 558, 575, 1589, 2261, 2259, + 2256, 2253, 1542, 521, 519, 517, 514, 2270, 511, 533, 1569, 1567, + 2223, 2221, 2218, 2215, 1483, 2211, 1480, 459, 456, 453, 2232, 449, + 474, 491, 1527, 1525, 1522, 2475, 2467, 2465, 2451, 2449, 2446, 801, + 800, 2426, 2424, 2421, 2418, 1723, 2435, 780, 778, 775, 2387, 2385, + 2382, 2379, 1695, 2375, 1693, 2396, 735, 733, 730, 727, 749, 1718, + 2616, 2615, 2604, 2603, 2601, 2584, 2583, 2581, 2579, 1800, 2591, 2550, + 2549, 2547, 2545, 1792, 2542, 1790, 2558, 929, 2719, 1841, 2710, 2708, + 1833, 1831, 2690, 2688, 2686, 1815, 1809, 1808, 1774, 1756, 1754, 1737, + 1736, 1734, 1739, 1816, 1711, 1676, 1674, 633, 629, 1638, 1636, 1633, + 1641, 598, 1605, 1604, 1602, 1600, 605, 1609, 1607, 2327, 887, 853, + 1775, 822, 820, 1757, 1755, 1584, 524, 1560, 1558, 468, 464, 1514, + 1511, 1508, 1519, 408, 404, 400, 1452, 1447, 1444, 417, 1458, 1455, + 2208, 364, 361, 358, 2154, 1401, 1400, 1398, 1396, 374, 1393, 371, + 1408, 1406, 1403, 1413, 2173, 2172, 772, 726, 723, 1712, 672, 669, + 666, 682, 1678, 1675, 625, 623, 621, 618, 2331, 636, 632, 1639, + 1637, 1635, 920, 918, 884, 880, 889, 849, 848, 847, 846, 2497, + 855, 852, 1776, 2641, 2742, 2787, 1380, 334, 1367, 1365, 301, 297, + 1340, 1338, 1335, 1343, 255, 251, 247, 1296, 1291, 1288, 265, 1302, + 1299, 2113, 204, 196, 192, 2042, 1232, 1230, 1224, 214, 1220, 210, + 1242, 1239, 1235, 1250, 2077, 2075, 151, 148, 1993, 144, 1990, 1163, + 1162, 1160, 1158, 1155, 161, 1152, 157, 1173, 1171, 1168, 1165, 168, + 1181, 1178, 2021, 2020, 2018, 2023, 585, 560, 557, 1585, 516, 509, + 1562, 1559, 458, 447, 2227, 472, 1516, 1513, 1510, 398, 396, 393, + 390, 2181, 386, 2178, 407, 1453, 1451, 1449, 1446, 420, 1460, 2209, + 769, 764, 720, 712, 2391, 729, 1713, 664, 663, 661, 659, 2352, + 656, 2349, 671, 1679, 1677, 2553, 922, 919, 2519, 2516, 885, 883, + 881, 2685, 2661, 2659, 2767, 2756, 2755, 140, 1137, 1136, 130, 127, + 1125, 1124, 1122, 1127, 109, 106, 102, 1103, 1102, 1100, 1098, 116, + 1107, 1105, 1980, 80, 76, 73, 1947, 1068, 1067, 1065, 1063, 90, + 1060, 87, 1075, 1073, 1070, 1080, 1966, 1965, 46, 43, 40, 1912, + 36, 1909, 1019, 1018, 1016, 1014, 58, 1011, 55, 1008, 51, 1029, + 1027, 1024, 1021, 63, 1037, 1034, 1940, 1939, 1937, 1942, 8, 1866, + 4, 1863, 1, 1860, 956, 954, 952, 949, 946, 17, 14, 969, + 967, 964, 961, 27, 957, 24, 979, 976, 972, 1901, 1900, 1898, + 1896, 986, 1905, 1903, 350, 349, 1381, 329, 327, 324, 1368, 1366, + 292, 290, 287, 284, 2118, 304, 1341, 1339, 1337, 1345, 243, 240, + 237, 2086, 233, 2083, 254, 1297, 1295, 1293, 1290, 1304, 2114, 190, + 187, 184, 2034, 180, 2031, 177, 2027, 199, 1233, 1231, 1229, 1226, + 217, 1223, 1241, 2078, 2076, 584, 555, 554, 552, 550, 2282, 562, + 1586, 507, 506, 504, 502, 2257, 499, 2254, 515, 1563, 1561, 445, + 443, 441, 2219, 438, 2216, 435, 2212, 460, 454, 475, 1517, 1515, + 1512, 2447, 798, 797, 2422, 2419, 770, 768, 766, 2383, 2380, 2376, + 721, 719, 717, 714, 731, 1714, 2602, 2582, 2580, 2548, 2546, 2543, + 923, 921, 2717, 2706, 2705, 2683, 2682, 2680, 1771, 1752, 1750, 1733, + 1732, 1731, 1735, 1814, 1707, 1670, 1668, 1631, 1629, 1626, 1634, 1599, + 1598, 1596, 1594, 1603, 1601, 2326, 1772, 1753, 1751, 1581, 1554, 1552, + 1504, 1501, 1498, 1509, 1442, 1437, 1434, 401, 1448, 1445, 2206, 1392, + 1391, 1389, 1387, 1384, 359, 1399, 1397, 1394, 1404, 2171, 2170, 1708, + 1672, 1669, 619, 1632, 1630, 1628, 1773, 1378, 1363, 1361, 1333, 1328, + 1336, 1286, 1281, 1278, 248, 1292, 1289, 2111, 1218, 1216, 1210, 197, + 1206, 193, 1228, 1225, 1221, 1236, 2073, 2071, 1151, 1150, 1148, 1146, + 152, 1143, 149, 1140, 145, 1161, 1159, 1156, 1153, 158, 1169, 1166, + 2017, 2016, 2014, 2019, 1582, 510, 1556, 1553, 452, 448, 1506, 1500, + 394, 391, 387, 1443, 1441, 1439, 1436, 1450, 2207, 765, 716, 713, + 1709, 662, 660, 657, 1673, 1671, 916, 914, 879, 878, 877, 882, + 1135, 1134, 1121, 1120, 1118, 1123, 1097, 1096, 1094, 1092, 103, 1101, + 1099, 1979, 1059, 1058, 1056, 1054, 77, 1051, 74, 1066, 1064, 1061, + 1071, 1964, 1963, 1007, 1006, 1004, 1002, 999, 41, 996, 37, 1017, + 1015, 1012, 1009, 52, 1025, 1022, 1936, 1935, 1933, 1938, 942, 940, + 938, 935, 932, 5, 2, 955, 953, 950, 947, 18, 943, 15, + 965, 962, 958, 1895, 1894, 1892, 1890, 973, 1899, 1897, 1379, 325, + 1364, 1362, 288, 285, 1334, 1332, 1330, 241, 238, 234, 1287, 1285, + 1283, 1280, 1294, 2112, 188, 185, 181, 178, 2028, 1219, 1217, 1215, + 1212, 200, 1209, 1227, 2074, 2072, 583, 553, 551, 1583, 505, 503, + 500, 513, 1557, 1555, 444, 442, 439, 436, 2213, 455, 451, 1507, + 1505, 1502, 796, 763, 762, 760, 767, 711, 710, 708, 706, 2377, + 718, 715, 1710, 2544, 917, 915, 2681, 1627, 1597, 1595, 2325, 1769, + 1749, 1747, 1499, 1438, 1435, 2204, 1390, 1388, 1385, 1395, 2169, 2167, + 1704, 1665, 1662, 1625, 1623, 1620, 1770, 1329, 1282, 1279, 2109, 1214, + 1207, 1222, 2068, 2065, 1149, 1147, 1144, 1141, 146, 1157, 1154, 2013, + 2011, 2008, 2015, 1579, 1549, 1546, 1495, 1487, 1433, 1431, 1428, 1425, + 388, 1440, 2205, 1705, 658, 1667, 1664, 1119, 1095, 1093, 1978, 1057, + 1055, 1052, 1062, 1962, 1960, 1005, 1003, 1000, 997, 38, 1013, 1010, + 1932, 1930, 1927, 1934, 941, 939, 936, 933, 6, 930, 3, 951, + 948, 944, 1889, 1887, 1884, 1881, 959, 1893, 1891, 35, 1377, 1360, + 1358, 1327, 1325, 1322, 1331, 1277, 1275, 1272, 1269, 235, 1284, 2110, + 1205, 1204, 1201, 1198, 182, 1195, 179, 1213, 2070, 2067, 1580, 501, + 1551, 1548, 440, 437, 1497, 1494, 1490, 1503, 761, 709, 707, 1706, + 913, 912, 2198, 1386, 2164, 2161, 1621, 1766, 2103, 1208, 2058, 2054, + 1145, 1142, 2005, 2002, 1999, 2009, 1488, 1429, 1426, 2200, 1698, 1659, + 1656, 1975, 1053, 1957, 1954, 1001, 998, 1924, 1921, 1918, 1928, 937, + 934, 931, 1879, 1876, 1873, 1870, 945, 1885, 1882, 1323, 1273, 1270, + 2105, 1202, 1199, 1196, 1211, 2061, 2057, 1576, 1543, 1540, 1484, 1481, + 1478, 1491, 1700}; + +CBC_PDF417Common::CBC_PDF417Common() {} +CBC_PDF417Common::~CBC_PDF417Common() {} +int32_t CBC_PDF417Common::getBitCountSum(CFX_Int32Array& moduleBitCount) { + int32_t bitCountSum = 0; + for (int32_t i = 0; i < moduleBitCount.GetSize(); i++) { + int32_t count = moduleBitCount.GetAt(i); + bitCountSum += count; + } + return bitCountSum; +} +int32_t CBC_PDF417Common::getCodeword(FX_DWORD symbol) { + FX_DWORD sym = symbol & 0x3FFFF; + int32_t i = findCodewordIndex(sym); + if (i == -1) { + return -1; + } + return (CODEWORD_TABLE[i] - 1) % NUMBER_OF_CODEWORDS; +} +int32_t CBC_PDF417Common::findCodewordIndex(FX_DWORD symbol) { + int32_t first = 0; + int32_t upto = sizeof(SYMBOL_TABLE) / sizeof(SYMBOL_TABLE[0]); + while (first < upto) { + int32_t mid = ((FX_DWORD)(first + upto)) >> 1; + if (symbol < (FX_DWORD)SYMBOL_TABLE[mid]) { + upto = mid; + } else if (symbol > (FX_DWORD)SYMBOL_TABLE[mid]) { + first = mid + 1; + } else { + return mid; + } + } + return -1; +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417Common.h b/xfa/fxbarcode/pdf417/BC_PDF417Common.h new file mode 100644 index 0000000000..61e93ab759 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417Common.h @@ -0,0 +1,34 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417COMMON_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417COMMON_H_ + +#include "core/include/fxcrt/fx_basic.h" + +class CBC_PDF417Common { + public: + CBC_PDF417Common(); + virtual ~CBC_PDF417Common(); + static int32_t getBitCountSum(CFX_Int32Array& moduleBitCount); + static int32_t getCodeword(FX_DWORD symbol); + static int32_t NUMBER_OF_CODEWORDS; + static int32_t MAX_CODEWORDS_IN_BARCODE; + static int32_t MIN_ROWS_IN_BARCODE; + static int32_t MAX_ROWS_IN_BARCODE; + static int32_t MAX_CODEWORDS_IN_ROW; + static int32_t MODULES_IN_CODEWORD; + static int32_t MODULES_IN_STOP_PATTERN; + static int32_t BARS_IN_MODULE; + static int32_t SYMBOL_TABLE[]; + static int32_t CODEWORD_TABLE[]; + + private: + static CFX_Int32Array* EMPTY_INT_ARRAY; + static int32_t findCodewordIndex(FX_DWORD symbol); +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417COMMON_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417Compaction.cpp b/xfa/fxbarcode/pdf417/BC_PDF417Compaction.cpp new file mode 100644 index 0000000000..d3a1663eb6 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417Compaction.cpp @@ -0,0 +1,26 @@ +// 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 2011 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_PDF417Compaction.h" + +CBC_Compaction::CBC_Compaction() {} +CBC_Compaction::~CBC_Compaction() {} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417Compaction.h b/xfa/fxbarcode/pdf417/BC_PDF417Compaction.h new file mode 100644 index 0000000000..2df0fce303 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417Compaction.h @@ -0,0 +1,18 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417COMPACTION_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417COMPACTION_H_ + +class CBC_Compaction; +enum Compaction { AUTO, TEXT, BYTES, NUMERIC }; +class CBC_Compaction { + public: + CBC_Compaction(); + virtual ~CBC_Compaction(); +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417COMPACTION_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.cpp b/xfa/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.cpp new file mode 100644 index 0000000000..d52648c683 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.cpp @@ -0,0 +1,493 @@ +// 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 "xfa/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.h" + +#include + +#include "third_party/bigint/BigIntegerLibrary.hh" +#include "xfa/fxbarcode/BC_DecoderResult.h" +#include "xfa/fxbarcode/common/BC_CommonDecoderResult.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417ResultMetadata.h" +#include "xfa/fxbarcode/utils.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 = 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 = 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); + 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); + 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); +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.h b/xfa/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.h new file mode 100644 index 0000000000..747a4ceb5d --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.h @@ -0,0 +1,63 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417DECODEDBITSTREAMPARSER_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417DECODEDBITSTREAMPARSER_H_ + +#include "core/include/fxcrt/fx_basic.h" +#include "core/include/fxcrt/fx_string.h" + +class CBC_CommonDecoderResult; +class CBC_PDF417ResultMetadata; + +class CBC_DecodedBitStreamPaser { + public: + CBC_DecodedBitStreamPaser(); + virtual ~CBC_DecodedBitStreamPaser(); + static void Initialize(); + static void Finalize(); + static CBC_CommonDecoderResult* decode(CFX_Int32Array& codewords, + CFX_ByteString ecLevel, + int32_t& e); + + private: + enum Mode { ALPHA, LOWER, MIXED, PUNCT, ALPHA_SHIFT, PUNCT_SHIFT }; + static int32_t MAX_NUMERIC_CODEWORDS; + static int32_t PL; + static int32_t LL; + static int32_t AS; + static int32_t ML; + static int32_t AL; + static int32_t PS; + static int32_t PAL; + static FX_CHAR PUNCT_CHARS[29]; + static FX_CHAR MIXED_CHARS[30]; + static int32_t NUMBER_OF_SEQUENCE_CODEWORDS; + static int32_t decodeMacroBlock(CFX_Int32Array& codewords, + int32_t codeIndex, + CBC_PDF417ResultMetadata* resultMetadata, + int32_t& e); + static int32_t textCompaction(CFX_Int32Array& codewords, + int32_t codeIndex, + CFX_ByteString& result); + static void decodeTextCompaction(CFX_Int32Array& textCompactionData, + CFX_Int32Array& byteCompactionData, + int32_t length, + CFX_ByteString& result); + static int32_t byteCompaction(int32_t mode, + CFX_Int32Array& codewords, + int32_t codeIndex, + CFX_ByteString& result); + static int32_t numericCompaction(CFX_Int32Array& codewords, + int32_t codeIndex, + CFX_ByteString& result, + int32_t& e); + static CFX_ByteString decodeBase900toBase10(CFX_Int32Array& codewords, + int32_t count, + int32_t& e); +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417DECODEDBITSTREAMPARSER_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417DetectionResult.cpp b/xfa/fxbarcode/pdf417/BC_PDF417DetectionResult.cpp new file mode 100644 index 0000000000..fa278bdea9 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417DetectionResult.cpp @@ -0,0 +1,339 @@ +// 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 2013 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_PDF417BarcodeMetadata.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417BoundingBox.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417Codeword.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417Common.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417DetectionResult.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417DetectionResultColumn.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417DetectionResultRowIndicatorColumn.h" + +int32_t CBC_DetectionResult::ADJUST_ROW_NUMBER_SKIP = 2; + +CBC_DetectionResult::CBC_DetectionResult(CBC_BarcodeMetadata* barcodeMetadata, + CBC_BoundingBox* boundingBox) { + m_barcodeMetadata = barcodeMetadata; + m_barcodeColumnCount = barcodeMetadata->getColumnCount(); + m_boundingBox = boundingBox; + m_detectionResultColumns.SetSize(m_barcodeColumnCount + 2); + for (int32_t i = 0; i < m_barcodeColumnCount + 2; i++) { + m_detectionResultColumns[i] = NULL; + } +} +CBC_DetectionResult::~CBC_DetectionResult() { + delete m_boundingBox; + delete m_barcodeMetadata; + m_detectionResultColumns.RemoveAll(); +} +CFX_PtrArray& CBC_DetectionResult::getDetectionResultColumns() { + adjustIndicatorColumnRowNumbers( + (CBC_DetectionResultColumn*)m_detectionResultColumns.GetAt(0)); + adjustIndicatorColumnRowNumbers( + (CBC_DetectionResultColumn*)m_detectionResultColumns.GetAt( + m_barcodeColumnCount + 1)); + int32_t unadjustedCodewordCount = CBC_PDF417Common::MAX_CODEWORDS_IN_BARCODE; + int32_t previousUnadjustedCount; + do { + previousUnadjustedCount = unadjustedCodewordCount; + unadjustedCodewordCount = adjustRowNumbers(); + } while (unadjustedCodewordCount > 0 && + unadjustedCodewordCount < previousUnadjustedCount); + return m_detectionResultColumns; +} +void CBC_DetectionResult::setBoundingBox(CBC_BoundingBox* boundingBox) { + m_boundingBox = boundingBox; +} +CBC_BoundingBox* CBC_DetectionResult::getBoundingBox() { + return m_boundingBox; +} +void CBC_DetectionResult::setDetectionResultColumn( + int32_t barcodeColumn, + CBC_DetectionResultColumn* detectionResultColumn) { + m_detectionResultColumns[barcodeColumn] = detectionResultColumn; +} +CBC_DetectionResultColumn* CBC_DetectionResult::getDetectionResultColumn( + int32_t barcodeColumn) { + return (CBC_DetectionResultColumn*)m_detectionResultColumns[barcodeColumn]; +} +CFX_ByteString CBC_DetectionResult::toString() { + CBC_DetectionResultColumn* rowIndicatorColumn = + (CBC_DetectionResultColumn*)m_detectionResultColumns[0]; + if (rowIndicatorColumn == NULL) { + rowIndicatorColumn = (CBC_DetectionResultColumn*) + m_detectionResultColumns[m_barcodeColumnCount + 1]; + } + CFX_ByteString result; + for (int32_t codewordsRow = 0; + codewordsRow < rowIndicatorColumn->getCodewords()->GetSize(); + codewordsRow++) { + result += (FX_CHAR)codewordsRow; + for (int32_t barcodeColumn = 0; barcodeColumn < m_barcodeColumnCount + 2; + barcodeColumn++) { + if (m_detectionResultColumns[barcodeColumn] == NULL) { + result += " | "; + continue; + } + CBC_Codeword* codeword = + (CBC_Codeword*)((CBC_DetectionResultColumn*) + m_detectionResultColumns[barcodeColumn]) + ->getCodewords() + ->GetAt(codewordsRow); + if (codeword == NULL) { + result += " | "; + continue; + } + result += codeword->getRowNumber(); + result += codeword->getValue(); + } + } + return result; +} +void CBC_DetectionResult::adjustIndicatorColumnRowNumbers( + CBC_DetectionResultColumn* detectionResultColumn) { + if (detectionResultColumn) { + ((CBC_DetectionResultRowIndicatorColumn*)detectionResultColumn) + ->adjustCompleteIndicatorColumnRowNumbers(*m_barcodeMetadata); + } +} +int32_t CBC_DetectionResult::adjustRowNumbers() { + int32_t unadjustedCount = adjustRowNumbersByRow(); + if (unadjustedCount == 0) { + return 0; + } + for (int32_t barcodeColumn = 1; barcodeColumn < m_barcodeColumnCount + 1; + barcodeColumn++) { + CFX_PtrArray* codewords = + ((CBC_DetectionResultColumn*)m_detectionResultColumns[barcodeColumn]) + ->getCodewords(); + for (int32_t codewordsRow = 0; codewordsRow < codewords->GetSize(); + codewordsRow++) { + if (codewords->GetAt(codewordsRow) == NULL) { + continue; + } + if (!((CBC_Codeword*)codewords->GetAt(codewordsRow)) + ->hasValidRowNumber()) { + adjustRowNumbers(barcodeColumn, codewordsRow, codewords); + } + } + } + return unadjustedCount; +} +int32_t CBC_DetectionResult::adjustRowNumbersByRow() { + adjustRowNumbersFromBothRI(); + int32_t unadjustedCount = adjustRowNumbersFromLRI(); + return unadjustedCount + adjustRowNumbersFromRRI(); +} +int32_t CBC_DetectionResult::adjustRowNumbersFromBothRI() { + if (m_detectionResultColumns[0] == NULL || + m_detectionResultColumns[m_barcodeColumnCount + 1] == NULL) { + return 0; + } + CFX_PtrArray* LRIcodewords = + ((CBC_DetectionResultColumn*)m_detectionResultColumns[0])->getCodewords(); + CFX_PtrArray* RRIcodewords = + ((CBC_DetectionResultColumn*) + m_detectionResultColumns[m_barcodeColumnCount + 1]) + ->getCodewords(); + for (int32_t codewordsRow = 0; codewordsRow < LRIcodewords->GetSize(); + codewordsRow++) { + if (LRIcodewords->GetAt(codewordsRow) && + RRIcodewords->GetAt(codewordsRow) && + ((CBC_Codeword*)LRIcodewords->GetAt(codewordsRow))->getRowNumber() == + ((CBC_Codeword*)RRIcodewords->GetAt(codewordsRow)) + ->getRowNumber()) { + for (int32_t barcodeColumn = 1; barcodeColumn <= m_barcodeColumnCount; + barcodeColumn++) { + CBC_Codeword* codeword = + (CBC_Codeword*)((CBC_DetectionResultColumn*) + m_detectionResultColumns[barcodeColumn]) + ->getCodewords() + ->GetAt(codewordsRow); + if (codeword == NULL) { + continue; + } + codeword->setRowNumber( + ((CBC_Codeword*)LRIcodewords->GetAt(codewordsRow))->getRowNumber()); + if (!codeword->hasValidRowNumber()) { + ((CBC_DetectionResultColumn*)m_detectionResultColumns[barcodeColumn]) + ->getCodewords() + ->SetAt(codewordsRow, NULL); + } + } + } + } + return 0; +} +int32_t CBC_DetectionResult::adjustRowNumbersFromRRI() { + if (m_detectionResultColumns[m_barcodeColumnCount + 1] == NULL) { + return 0; + } + int32_t unadjustedCount = 0; + CFX_PtrArray* codewords = + ((CBC_DetectionResultColumn*)m_detectionResultColumns.GetAt( + m_barcodeColumnCount + 1)) + ->getCodewords(); + for (int32_t codewordsRow = 0; codewordsRow < codewords->GetSize(); + codewordsRow++) { + if (codewords->GetAt(codewordsRow) == NULL) { + continue; + } + int32_t rowIndicatorRowNumber = + ((CBC_Codeword*)codewords->GetAt(codewordsRow))->getRowNumber(); + int32_t invalidRowCounts = 0; + for (int32_t barcodeColumn = m_barcodeColumnCount + 1; + barcodeColumn > 0 && invalidRowCounts < ADJUST_ROW_NUMBER_SKIP; + barcodeColumn--) { + CBC_Codeword* codeword = + (CBC_Codeword*)((CBC_DetectionResultColumn*) + m_detectionResultColumns.GetAt(barcodeColumn)) + ->getCodewords() + ->GetAt(codewordsRow); + if (codeword) { + invalidRowCounts = adjustRowNumberIfValid(rowIndicatorRowNumber, + invalidRowCounts, codeword); + if (!codeword->hasValidRowNumber()) { + unadjustedCount++; + } + } + } + } + return unadjustedCount; +} +int32_t CBC_DetectionResult::adjustRowNumbersFromLRI() { + if (m_detectionResultColumns[0] == NULL) { + return 0; + } + int32_t unadjustedCount = 0; + CFX_PtrArray* codewords = + ((CBC_DetectionResultColumn*)m_detectionResultColumns.GetAt(0)) + ->getCodewords(); + for (int32_t codewordsRow = 0; codewordsRow < codewords->GetSize(); + codewordsRow++) { + if (codewords->GetAt(codewordsRow) == NULL) { + continue; + } + int32_t rowIndicatorRowNumber = + ((CBC_Codeword*)codewords->GetAt(codewordsRow))->getRowNumber(); + int32_t invalidRowCounts = 0; + for (int32_t barcodeColumn = 1; barcodeColumn < m_barcodeColumnCount + 1 && + invalidRowCounts < ADJUST_ROW_NUMBER_SKIP; + barcodeColumn++) { + CBC_Codeword* codeword = + (CBC_Codeword*)((CBC_DetectionResultColumn*) + m_detectionResultColumns[barcodeColumn]) + ->getCodewords() + ->GetAt(codewordsRow); + if (codeword) { + invalidRowCounts = adjustRowNumberIfValid(rowIndicatorRowNumber, + invalidRowCounts, codeword); + if (!codeword->hasValidRowNumber()) { + unadjustedCount++; + } + } + } + } + return unadjustedCount; +} +int32_t CBC_DetectionResult::adjustRowNumberIfValid( + int32_t rowIndicatorRowNumber, + int32_t invalidRowCounts, + CBC_Codeword* codeword) { + if (codeword == NULL) { + return invalidRowCounts; + } + if (!codeword->hasValidRowNumber()) { + if (codeword->isValidRowNumber(rowIndicatorRowNumber)) { + codeword->setRowNumber(rowIndicatorRowNumber); + invalidRowCounts = 0; + } else { + ++invalidRowCounts; + } + } + return invalidRowCounts; +} +void CBC_DetectionResult::adjustRowNumbers(int32_t barcodeColumn, + int32_t codewordsRow, + CFX_PtrArray* codewords) { + CBC_Codeword* codeword = (CBC_Codeword*)codewords->GetAt(codewordsRow); + CFX_PtrArray* previousColumnCodewords = + ((CBC_DetectionResultColumn*)m_detectionResultColumns.GetAt( + barcodeColumn - 1)) + ->getCodewords(); + CFX_PtrArray* nextColumnCodewords = previousColumnCodewords; + if (m_detectionResultColumns[barcodeColumn + 1]) { + nextColumnCodewords = ((CBC_DetectionResultColumn*) + m_detectionResultColumns[barcodeColumn + 1]) + ->getCodewords(); + } + CFX_PtrArray otherCodewords; + otherCodewords.SetSize(14); + otherCodewords[2] = previousColumnCodewords->GetAt(codewordsRow); + otherCodewords[3] = nextColumnCodewords->GetAt(codewordsRow); + if (codewordsRow > 0) { + otherCodewords[0] = codewords->GetAt(codewordsRow - 1); + otherCodewords[4] = previousColumnCodewords->GetAt(codewordsRow - 1); + otherCodewords[5] = nextColumnCodewords->GetAt(codewordsRow - 1); + } + if (codewordsRow > 1) { + otherCodewords[8] = codewords->GetAt(codewordsRow - 2); + otherCodewords[10] = previousColumnCodewords->GetAt(codewordsRow - 2); + otherCodewords[11] = nextColumnCodewords->GetAt(codewordsRow - 2); + } + if (codewordsRow < codewords->GetSize() - 1) { + otherCodewords[1] = codewords->GetAt(codewordsRow + 1); + otherCodewords[6] = previousColumnCodewords->GetAt(codewordsRow + 1); + otherCodewords[7] = nextColumnCodewords->GetAt(codewordsRow + 1); + } + if (codewordsRow < codewords->GetSize() - 2) { + otherCodewords[9] = codewords->GetAt(codewordsRow + 2); + otherCodewords[12] = previousColumnCodewords->GetAt(codewordsRow + 2); + otherCodewords[13] = nextColumnCodewords->GetAt(codewordsRow + 2); + } + for (int32_t i = 0; i < otherCodewords.GetSize(); i++) { + CBC_Codeword* otherCodeword = (CBC_Codeword*)otherCodewords.GetAt(i); + if (adjustRowNumber(codeword, otherCodeword)) { + return; + } + } +} +FX_BOOL CBC_DetectionResult::adjustRowNumber(CBC_Codeword* codeword, + CBC_Codeword* otherCodeword) { + if (otherCodeword == NULL) { + return FALSE; + } + if (otherCodeword->hasValidRowNumber() && + otherCodeword->getBucket() == codeword->getBucket()) { + codeword->setRowNumber(otherCodeword->getRowNumber()); + return TRUE; + } + return FALSE; +} +int32_t CBC_DetectionResult::getBarcodeColumnCount() { + return m_barcodeColumnCount; +} +int32_t CBC_DetectionResult::getBarcodeRowCount() { + return m_barcodeMetadata->getRowCount(); +} +int32_t CBC_DetectionResult::getBarcodeECLevel() { + return m_barcodeMetadata->getErrorCorrectionLevel(); +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417DetectionResult.h b/xfa/fxbarcode/pdf417/BC_PDF417DetectionResult.h new file mode 100644 index 0000000000..8b7f91bfcd --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417DetectionResult.h @@ -0,0 +1,57 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417DETECTIONRESULT_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417DETECTIONRESULT_H_ + +class CBC_BarcodeMetadata; +class CBC_BoundingBox; +class CBC_Codeword; +class CBC_DetectionResultColumn; +class CBC_DetectionResult { + public: + CBC_DetectionResult(CBC_BarcodeMetadata* barcodeMetadata, + CBC_BoundingBox* boundingBox); + virtual ~CBC_DetectionResult(); + CFX_PtrArray& getDetectionResultColumns(); + void setBoundingBox(CBC_BoundingBox* boundingBox); + CBC_BoundingBox* getBoundingBox(); + void setDetectionResultColumn( + int32_t barcodeColumn, + CBC_DetectionResultColumn* detectionResultColumn); + CBC_DetectionResultColumn* getDetectionResultColumn(int32_t barcodeColumn); + CFX_ByteString toString(); + + int32_t getBarcodeColumnCount(); + int32_t getBarcodeRowCount(); + int32_t getBarcodeECLevel(); + + private: + static int32_t ADJUST_ROW_NUMBER_SKIP; + CBC_BarcodeMetadata* m_barcodeMetadata; + CFX_PtrArray m_detectionResultColumns; + CBC_BoundingBox* m_boundingBox; + int32_t m_barcodeColumnCount; + + private: + void adjustIndicatorColumnRowNumbers( + CBC_DetectionResultColumn* detectionResultColumn); + int32_t adjustRowNumbers(); + int32_t adjustRowNumbersByRow(); + int32_t adjustRowNumbersFromBothRI(); + int32_t adjustRowNumbersFromRRI(); + int32_t adjustRowNumbersFromLRI(); + static int32_t adjustRowNumberIfValid(int32_t rowIndicatorRowNumber, + int32_t invalidRowCounts, + CBC_Codeword* codeword); + void adjustRowNumbers(int32_t barcodeColumn, + int32_t codewordsRow, + CFX_PtrArray* codewords); + static FX_BOOL adjustRowNumber(CBC_Codeword* codeword, + CBC_Codeword* otherCodeword); +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417DETECTIONRESULT_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417DetectionResultColumn.cpp b/xfa/fxbarcode/pdf417/BC_PDF417DetectionResultColumn.cpp new file mode 100644 index 0000000000..24d81070f3 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417DetectionResultColumn.cpp @@ -0,0 +1,101 @@ +// 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 2013 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_PDF417BoundingBox.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417Codeword.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417DetectionResultColumn.h" + +int32_t CBC_DetectionResultColumn::MAX_NEARBY_DISTANCE = 5; + +CBC_DetectionResultColumn::CBC_DetectionResultColumn( + CBC_BoundingBox* boundingBox) { + m_boundingBox = boundingBox; + m_codewords = new CFX_PtrArray; + m_codewords->SetSize(boundingBox->getMaxY() - boundingBox->getMinY() + 1); +} +CBC_DetectionResultColumn::~CBC_DetectionResultColumn() { + for (int32_t i = 0; i < m_codewords->GetSize(); i++) { + delete (CBC_Codeword*)m_codewords->GetAt(i); + } + m_codewords->RemoveAll(); + delete m_codewords; +} +CBC_Codeword* CBC_DetectionResultColumn::getCodewordNearby(int32_t imageRow) { + CBC_Codeword* codeword = getCodeword(imageRow); + if (codeword) { + return codeword; + } + for (int32_t i = 1; i < MAX_NEARBY_DISTANCE; i++) { + int32_t nearImageRow = imageRowToCodewordIndex(imageRow) - i; + if (nearImageRow >= 0) { + codeword = (CBC_Codeword*)m_codewords->GetAt(nearImageRow); + if (codeword) { + return codeword; + } + } + nearImageRow = imageRowToCodewordIndex(imageRow) + i; + if (nearImageRow < m_codewords->GetSize()) { + codeword = (CBC_Codeword*)m_codewords->GetAt(nearImageRow); + if (codeword) { + return codeword; + } + } + } + return NULL; +} +int32_t CBC_DetectionResultColumn::imageRowToCodewordIndex(int32_t imageRow) { + return imageRow - m_boundingBox->getMinY(); +} +int32_t CBC_DetectionResultColumn::codewordIndexToImageRow( + int32_t codewordIndex) { + return m_boundingBox->getMinY() + codewordIndex; +} +void CBC_DetectionResultColumn::setCodeword(int32_t imageRow, + CBC_Codeword* codeword) { + m_codewords->SetAt(imageRowToCodewordIndex(imageRow), codeword); +} +CBC_Codeword* CBC_DetectionResultColumn::getCodeword(int32_t imageRow) { + return (CBC_Codeword*)m_codewords->GetAt(imageRowToCodewordIndex(imageRow)); +} +CBC_BoundingBox* CBC_DetectionResultColumn::getBoundingBox() { + return m_boundingBox; +} +CFX_PtrArray* CBC_DetectionResultColumn::getCodewords() { + return m_codewords; +} +CFX_ByteString CBC_DetectionResultColumn::toString() { + CFX_ByteString result; + int32_t row = 0; + for (int32_t i = 0; i < m_codewords->GetSize(); i++) { + CBC_Codeword* codeword = (CBC_Codeword*)m_codewords->GetAt(i); + if (codeword == NULL) { + result += (FX_CHAR)row; + row++; + continue; + } + result += (FX_CHAR)row; + result += codeword->getRowNumber(); + result += codeword->getValue(); + row++; + } + return result; +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417DetectionResultColumn.h b/xfa/fxbarcode/pdf417/BC_PDF417DetectionResultColumn.h new file mode 100644 index 0000000000..ebe01a2a0c --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417DetectionResultColumn.h @@ -0,0 +1,33 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417DETECTIONRESULTCOLUMN_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417DETECTIONRESULTCOLUMN_H_ + +class CBC_Codeword; +class CBC_BoundingBox; +class CBC_DetectionResultColumn { + public: + CBC_DetectionResultColumn(CBC_BoundingBox* boundingBox); + virtual ~CBC_DetectionResultColumn(); + CBC_Codeword* getCodewordNearby(int32_t imageRow); + int32_t imageRowToCodewordIndex(int32_t imageRow); + int32_t codewordIndexToImageRow(int32_t codewordIndex); + void setCodeword(int32_t imageRow, CBC_Codeword* codeword); + CBC_Codeword* getCodeword(int32_t imageRow); + CBC_BoundingBox* getBoundingBox(); + CFX_PtrArray* getCodewords(); + CFX_ByteString toString(); + + public: + CBC_BoundingBox* m_boundingBox; + CFX_PtrArray* m_codewords; + + private: + static int32_t MAX_NEARBY_DISTANCE; +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417DETECTIONRESULTCOLUMN_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417DetectionResultRowIndicatorColumn.cpp b/xfa/fxbarcode/pdf417/BC_PDF417DetectionResultRowIndicatorColumn.cpp new file mode 100644 index 0000000000..22fd25df8b --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417DetectionResultRowIndicatorColumn.cpp @@ -0,0 +1,267 @@ +// 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 2013 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 "core/include/fxcrt/fx_basic.h" +#include "xfa/fxbarcode/BC_ResultPoint.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417BarcodeMetadata.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417BarcodeValue.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417BoundingBox.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417Codeword.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417Common.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417DetectionResultColumn.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417DetectionResultRowIndicatorColumn.h" +#include "xfa/fxbarcode/utils.h" + +CBC_DetectionResultRowIndicatorColumn::CBC_DetectionResultRowIndicatorColumn( + CBC_BoundingBox* boundingBox, + FX_BOOL isLeft) + : CBC_DetectionResultColumn(boundingBox) { + m_isLeft = isLeft; +} +CBC_DetectionResultRowIndicatorColumn:: + ~CBC_DetectionResultRowIndicatorColumn() {} +void CBC_DetectionResultRowIndicatorColumn::setRowNumbers() { + for (int32_t i = 0; i < m_codewords->GetSize(); i++) { + CBC_Codeword* codeword = (CBC_Codeword*)m_codewords->GetAt(i); + if (codeword) { + codeword->setRowNumberAsRowIndicatorColumn(); + } + } +} +int32_t +CBC_DetectionResultRowIndicatorColumn::adjustCompleteIndicatorColumnRowNumbers( + CBC_BarcodeMetadata barcodeMetadata) { + CFX_PtrArray* codewords = getCodewords(); + setRowNumbers(); + removeIncorrectCodewords(codewords, barcodeMetadata); + CBC_BoundingBox* boundingBox = getBoundingBox(); + CBC_ResultPoint* top = + m_isLeft ? boundingBox->getTopLeft() : boundingBox->getTopRight(); + CBC_ResultPoint* bottom = + m_isLeft ? boundingBox->getBottomLeft() : boundingBox->getBottomRight(); + int32_t firstRow = imageRowToCodewordIndex((int32_t)top->GetY()); + int32_t lastRow = imageRowToCodewordIndex((int32_t)bottom->GetY()); + FX_FLOAT averageRowHeight = + (lastRow - firstRow) / (FX_FLOAT)barcodeMetadata.getRowCount(); + int32_t barcodeRow = -1; + int32_t maxRowHeight = 1; + int32_t currentRowHeight = 0; + for (int32_t codewordsRow = firstRow; codewordsRow < lastRow; + codewordsRow++) { + if (codewords->GetAt(codewordsRow) == NULL) { + continue; + } + CBC_Codeword* codeword = (CBC_Codeword*)codewords->GetAt(codewordsRow); + int32_t rowDifference = codeword->getRowNumber() - barcodeRow; + if (rowDifference == 0) { + currentRowHeight++; + } else if (rowDifference == 1) { + maxRowHeight = + maxRowHeight > currentRowHeight ? maxRowHeight : currentRowHeight; + currentRowHeight = 1; + barcodeRow = codeword->getRowNumber(); + } else if (rowDifference < 0) { + codewords->SetAt(codewordsRow, NULL); + } else if (codeword->getRowNumber() >= barcodeMetadata.getRowCount()) { + codewords->SetAt(codewordsRow, NULL); + } else if (rowDifference > codewordsRow) { + codewords->SetAt(codewordsRow, NULL); + } else { + int32_t checkedRows; + if (maxRowHeight > 2) { + checkedRows = (maxRowHeight - 2) * rowDifference; + } else { + checkedRows = rowDifference; + } + FX_BOOL closePreviousCodewordFound = checkedRows >= codewordsRow; + for (int32_t i = 1; i <= checkedRows && !closePreviousCodewordFound; + i++) { + closePreviousCodewordFound = codewords->GetAt(codewordsRow - i) != NULL; + } + if (closePreviousCodewordFound) { + codewords->SetAt(codewordsRow, NULL); + } else { + barcodeRow = codeword->getRowNumber(); + currentRowHeight = 1; + } + } + } + return (int32_t)(averageRowHeight + 0.5); +} +CFX_Int32Array* CBC_DetectionResultRowIndicatorColumn::getRowHeights( + int32_t& e) { + CBC_BarcodeMetadata* barcodeMetadata = getBarcodeMetadata(); + if (barcodeMetadata == NULL) { + e = BCExceptionCannotMetadata; + return NULL; + } + adjustIncompleteIndicatorColumnRowNumbers(*barcodeMetadata); + CFX_Int32Array* result = new CFX_Int32Array; + result->SetSize(barcodeMetadata->getRowCount()); + for (int32_t i = 0; i < getCodewords()->GetSize(); i++) { + CBC_Codeword* codeword = (CBC_Codeword*)getCodewords()->GetAt(i); + if (codeword) { + result->SetAt(codeword->getRowNumber(), + result->GetAt(codeword->getRowNumber()) + 1); + } + } + return result; +} +int32_t CBC_DetectionResultRowIndicatorColumn:: + adjustIncompleteIndicatorColumnRowNumbers( + CBC_BarcodeMetadata barcodeMetadata) { + CBC_BoundingBox* boundingBox = getBoundingBox(); + CBC_ResultPoint* top = + m_isLeft ? boundingBox->getTopLeft() : boundingBox->getTopRight(); + CBC_ResultPoint* bottom = + m_isLeft ? boundingBox->getBottomLeft() : boundingBox->getBottomRight(); + int32_t firstRow = imageRowToCodewordIndex((int32_t)top->GetY()); + int32_t lastRow = imageRowToCodewordIndex((int32_t)bottom->GetY()); + FX_FLOAT averageRowHeight = + (lastRow - firstRow) / (FX_FLOAT)barcodeMetadata.getRowCount(); + CFX_PtrArray* codewords = getCodewords(); + int32_t barcodeRow = -1; + int32_t maxRowHeight = 1; + int32_t currentRowHeight = 0; + for (int32_t codewordsRow = firstRow; codewordsRow < lastRow; + codewordsRow++) { + if (codewords->GetAt(codewordsRow) == NULL) { + continue; + } + CBC_Codeword* codeword = (CBC_Codeword*)codewords->GetAt(codewordsRow); + codeword->setRowNumberAsRowIndicatorColumn(); + int32_t rowDifference = codeword->getRowNumber() - barcodeRow; + if (rowDifference == 0) { + currentRowHeight++; + } else if (rowDifference == 1) { + maxRowHeight = + maxRowHeight > currentRowHeight ? maxRowHeight : currentRowHeight; + currentRowHeight = 1; + barcodeRow = codeword->getRowNumber(); + } else if (codeword->getRowNumber() >= barcodeMetadata.getRowCount()) { + codewords->SetAt(codewordsRow, NULL); + } else { + barcodeRow = codeword->getRowNumber(); + currentRowHeight = 1; + } + } + return (int32_t)(averageRowHeight + 0.5); +} +CBC_BarcodeMetadata* +CBC_DetectionResultRowIndicatorColumn::getBarcodeMetadata() { + CFX_PtrArray* codewords = getCodewords(); + CBC_BarcodeValue barcodeColumnCount; + CBC_BarcodeValue barcodeRowCountUpperPart; + CBC_BarcodeValue barcodeRowCountLowerPart; + CBC_BarcodeValue barcodeECLevel; + for (int32_t i = 0; i < codewords->GetSize(); i++) { + CBC_Codeword* codeword = (CBC_Codeword*)codewords->GetAt(i); + if (codeword == NULL) { + continue; + } + codeword->setRowNumberAsRowIndicatorColumn(); + int32_t rowIndicatorValue = codeword->getValue() % 30; + int32_t codewordRowNumber = codeword->getRowNumber(); + if (!m_isLeft) { + codewordRowNumber += 2; + } + switch (codewordRowNumber % 3) { + case 0: + barcodeRowCountUpperPart.setValue(rowIndicatorValue * 3 + 1); + break; + case 1: + barcodeECLevel.setValue(rowIndicatorValue / 3); + barcodeRowCountLowerPart.setValue(rowIndicatorValue % 3); + break; + case 2: + barcodeColumnCount.setValue(rowIndicatorValue + 1); + break; + } + } + if ((barcodeColumnCount.getValue()->GetSize() == 0) || + (barcodeRowCountUpperPart.getValue()->GetSize() == 0) || + (barcodeRowCountLowerPart.getValue()->GetSize() == 0) || + (barcodeECLevel.getValue()->GetSize() == 0) || + barcodeColumnCount.getValue()->GetAt(0) < 1 || + barcodeRowCountUpperPart.getValue()->GetAt(0) + + barcodeRowCountLowerPart.getValue()->GetAt(0) < + CBC_PDF417Common::MIN_ROWS_IN_BARCODE || + barcodeRowCountUpperPart.getValue()->GetAt(0) + + barcodeRowCountLowerPart.getValue()->GetAt(0) > + CBC_PDF417Common::MAX_ROWS_IN_BARCODE) { + return NULL; + } + CBC_BarcodeMetadata* barcodeMetadata = + new CBC_BarcodeMetadata(barcodeColumnCount.getValue()->GetAt(0), + barcodeRowCountUpperPart.getValue()->GetAt(0), + barcodeRowCountLowerPart.getValue()->GetAt(0), + barcodeECLevel.getValue()->GetAt(0)); + removeIncorrectCodewords(codewords, *barcodeMetadata); + return barcodeMetadata; +} +FX_BOOL CBC_DetectionResultRowIndicatorColumn::isLeft() { + return m_isLeft; +} +CFX_ByteString CBC_DetectionResultRowIndicatorColumn::toString() { + return (CFX_ByteString) "IsLeft: " + (CFX_ByteString)m_isLeft + '\n' + + CBC_DetectionResultColumn::toString(); +} +void CBC_DetectionResultRowIndicatorColumn::removeIncorrectCodewords( + CFX_PtrArray* codewords, + CBC_BarcodeMetadata barcodeMetadata) { + for (int32_t codewordRow = 0; codewordRow < codewords->GetSize(); + codewordRow++) { + CBC_Codeword* codeword = (CBC_Codeword*)codewords->GetAt(codewordRow); + if (codeword == NULL) { + continue; + } + int32_t rowIndicatorValue = codeword->getValue() % 30; + int32_t codewordRowNumber = codeword->getRowNumber(); + if (codewordRowNumber > barcodeMetadata.getRowCount()) { + codewords->SetAt(codewordRow, NULL); + continue; + } + if (!m_isLeft) { + codewordRowNumber += 2; + } + switch (codewordRowNumber % 3) { + case 0: + if (rowIndicatorValue * 3 + 1 != + barcodeMetadata.getRowCountUpperPart()) { + codewords->SetAt(codewordRow, NULL); + } + break; + case 1: + if (rowIndicatorValue / 3 != + barcodeMetadata.getErrorCorrectionLevel() || + rowIndicatorValue % 3 != barcodeMetadata.getRowCountLowerPart()) { + codewords->SetAt(codewordRow, NULL); + } + break; + case 2: + if (rowIndicatorValue + 1 != barcodeMetadata.getColumnCount()) { + codewords->SetAt(codewordRow, NULL); + } + break; + } + } +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417DetectionResultRowIndicatorColumn.h b/xfa/fxbarcode/pdf417/BC_PDF417DetectionResultRowIndicatorColumn.h new file mode 100644 index 0000000000..dfe6a069d6 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417DetectionResultRowIndicatorColumn.h @@ -0,0 +1,34 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417DETECTIONRESULTROWINDICATORCOLUMN_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417DETECTIONRESULTROWINDICATORCOLUMN_H_ + +class CBC_BarcodeMetadata; +class CBC_BoundingBox; +class CBC_DetectionResultRowIndicatorColumn; +class CBC_DetectionResultRowIndicatorColumn : public CBC_DetectionResultColumn { + public: + CBC_DetectionResultRowIndicatorColumn(CBC_BoundingBox* boundingBox, + FX_BOOL isLeft); + virtual ~CBC_DetectionResultRowIndicatorColumn(); + void setRowNumbers(); + int32_t adjustCompleteIndicatorColumnRowNumbers( + CBC_BarcodeMetadata barcodeMetadata); + CFX_Int32Array* getRowHeights(int32_t& e); + int32_t adjustIncompleteIndicatorColumnRowNumbers( + CBC_BarcodeMetadata barcodeMetadata); + CBC_BarcodeMetadata* getBarcodeMetadata(); + FX_BOOL isLeft(); + CFX_ByteString toString(); + + private: + FX_BOOL m_isLeft; + void removeIncorrectCodewords(CFX_PtrArray* codewords, + CBC_BarcodeMetadata barcodeMetadata); +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417DETECTIONRESULTROWINDICATORCOLUMN_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417Detector.cpp b/xfa/fxbarcode/pdf417/BC_PDF417Detector.cpp new file mode 100644 index 0000000000..cfd52e56dc --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417Detector.cpp @@ -0,0 +1,352 @@ +// 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 "xfa/fxbarcode/BC_BinaryBitmap.h" +#include "xfa/fxbarcode/BC_ResultPoint.h" +#include "xfa/fxbarcode/common/BC_CommonBitArray.h" +#include "xfa/fxbarcode/common/BC_CommonBitMatrix.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417Detector.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417DetectorResult.h" +#include "xfa/fxbarcode/utils.h" + +#define INTEGER_MAX 2147483647 + +int32_t CBC_Detector::INDEXES_START_PATTERN[] = {0, 4, 1, 5}; +int32_t CBC_Detector::INDEXES_STOP_PATTERN[] = {6, 2, 7, 3}; +int32_t CBC_Detector::INTEGER_MATH_SHIFT = 8; +int32_t CBC_Detector::PATTERN_MATCH_RESULT_SCALE_FACTOR = 1 + << INTEGER_MATH_SHIFT; +int32_t CBC_Detector::MAX_AVG_VARIANCE = + (int32_t)(PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.42f); +int32_t CBC_Detector::MAX_INDIVIDUAL_VARIANCE = + (int32_t)(PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.8f); +int32_t CBC_Detector::START_PATTERN[] = {8, 1, 1, 1, 1, 1, 1, 3}; +int32_t CBC_Detector::STOP_PATTERN[] = {7, 1, 1, 3, 1, 1, 1, 2, 1}; +int32_t CBC_Detector::MAX_PIXEL_DRIFT = 3; +int32_t CBC_Detector::MAX_PATTERN_DRIFT = 5; +int32_t CBC_Detector::SKIPPED_ROW_COUNT_MAX = 25; +int32_t CBC_Detector::ROW_STEP = 5; +int32_t CBC_Detector::BARCODE_MIN_HEIGHT = 10; + +CBC_Detector::CBC_Detector() {} +CBC_Detector::~CBC_Detector() {} +CBC_PDF417DetectorResult* CBC_Detector::detect(CBC_BinaryBitmap* image, + int32_t hints, + FX_BOOL multiple, + int32_t& e) { + CBC_CommonBitMatrix* bitMatrix = image->GetBlackMatrix(e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + CFX_PtrArray* barcodeCoordinates = detect(multiple, bitMatrix); + if (barcodeCoordinates->GetSize() == 0) { + rotate180(bitMatrix); + barcodeCoordinates = detect(multiple, bitMatrix); + } + if (barcodeCoordinates->GetSize() == 0) { + e = BCExceptionUnSupportedBarcode; + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + } + CBC_PDF417DetectorResult* detectorResult = + new CBC_PDF417DetectorResult(bitMatrix, barcodeCoordinates); + return detectorResult; +} +void CBC_Detector::rotate180(CBC_CommonBitMatrix* bitMatrix) { + int32_t width = bitMatrix->GetWidth(); + int32_t height = bitMatrix->GetHeight(); + CBC_CommonBitArray* firstRowBitArray = new CBC_CommonBitArray(width); + CBC_CommonBitArray* secondRowBitArray = new CBC_CommonBitArray(width); + CBC_CommonBitArray* tmpBitArray = new CBC_CommonBitArray(width); + for (int32_t y = 0; y<(height + 1)>> 1; y++) { + CBC_CommonBitArray* temp = + bitMatrix->GetRow(height - 1 - y, secondRowBitArray); + CBC_CommonBitArray* tempfirstRow = firstRowBitArray; + firstRowBitArray = bitMatrix->GetRow(y, tempfirstRow); + delete tempfirstRow; + CBC_CommonBitArray* row = mirror(temp, tmpBitArray); + delete temp; + bitMatrix->SetRow(y, row); + delete row; + CBC_CommonBitArray* rowfirstRow = mirror(firstRowBitArray, tmpBitArray); + bitMatrix->SetRow(height - 1 - y, rowfirstRow); + delete rowfirstRow; + } + delete tmpBitArray; + delete firstRowBitArray; + delete secondRowBitArray; +} +CBC_CommonBitArray* CBC_Detector::mirror(CBC_CommonBitArray* input, + CBC_CommonBitArray* result) { + CBC_CommonBitArray* array = new CBC_CommonBitArray(result->GetSize()); + array->Clear(); + int32_t size = input->GetSize(); + for (int32_t i = 0; i < size; i++) { + if (input->Get(i)) { + array->Set(size - 1 - i); + } + } + return array; +} +CFX_PtrArray* CBC_Detector::detect(FX_BOOL multiple, + CBC_CommonBitMatrix* bitMatrix) { + CFX_PtrArray* barcodeCoordinates = new CFX_PtrArray; + int32_t row = 0; + int32_t column = 0; + FX_BOOL foundBarcodeInRow = FALSE; + while (row < bitMatrix->GetHeight()) { + CFX_PtrArray* vertices = findVertices(bitMatrix, row, column); + if (vertices->GetAt(0) == NULL && vertices->GetAt(3) == NULL) { + if (!foundBarcodeInRow) { + if (vertices) { + delete (vertices); + } + break; + } + foundBarcodeInRow = FALSE; + column = 0; + for (int32_t i = 0; i < barcodeCoordinates->GetSize(); i++) { + CFX_PtrArray* barcodeCoordinate = + (CFX_PtrArray*)barcodeCoordinates->GetAt(i); + if (barcodeCoordinate->GetAt(1)) { + row = row > ((CBC_ResultPoint*)barcodeCoordinate->GetAt(1))->GetY(); + } + if (barcodeCoordinate->GetAt(3)) { + row = row > ((CBC_ResultPoint*)barcodeCoordinate->GetAt(3))->GetY(); + } + } + row += ROW_STEP; + if (vertices) { + delete (vertices); + } + continue; + } + foundBarcodeInRow = TRUE; + barcodeCoordinates->Add(vertices); + if (!multiple) { + break; + } + if (vertices->GetAt(2)) { + column = (int32_t)((CBC_ResultPoint*)vertices->GetAt(2))->GetX(); + row = (int32_t)((CBC_ResultPoint*)vertices->GetAt(2))->GetY(); + } else { + column = (int32_t)((CBC_ResultPoint*)vertices->GetAt(4))->GetX(); + row = (int32_t)((CBC_ResultPoint*)vertices->GetAt(4))->GetY(); + } + } + return barcodeCoordinates; +} +CFX_PtrArray* CBC_Detector::findVertices(CBC_CommonBitMatrix* matrix, + int32_t startRow, + int32_t startColumn) { + int32_t height = matrix->GetHeight(); + int32_t width = matrix->GetWidth(); + CFX_PtrArray* result = new CFX_PtrArray; + result->SetSize(8); + CFX_PtrArray* startptr = findRowsWithPattern( + matrix, height, width, startRow, startColumn, START_PATTERN, + sizeof(START_PATTERN) / sizeof(START_PATTERN[0])); + copyToResult( + result, startptr, INDEXES_START_PATTERN, + sizeof(INDEXES_START_PATTERN) / sizeof(INDEXES_START_PATTERN[0])); + startptr->RemoveAll(); + delete startptr; + if (result->GetAt(4)) { + startColumn = (int32_t)((CBC_ResultPoint*)result->GetAt(4))->GetX(); + startRow = (int32_t)((CBC_ResultPoint*)result->GetAt(4))->GetY(); + } + CFX_PtrArray* stopptr = findRowsWithPattern( + matrix, height, width, startRow, startColumn, STOP_PATTERN, + sizeof(STOP_PATTERN) / sizeof(STOP_PATTERN[0])); + copyToResult(result, stopptr, INDEXES_STOP_PATTERN, + sizeof(INDEXES_STOP_PATTERN) / sizeof(INDEXES_STOP_PATTERN[0])); + stopptr->RemoveAll(); + delete stopptr; + return result; +} +void CBC_Detector::copyToResult(CFX_PtrArray* result, + CFX_PtrArray* tmpResult, + int32_t* destinationIndexes, + int32_t destinationLength) { + for (int32_t i = 0; i < destinationLength; i++) { + result->SetAt(destinationIndexes[i], tmpResult->GetAt(i)); + } +} +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) { + while (startRow > 0) { + CFX_Int32Array* previousRowLoc = + findGuardPattern(matrix, startColumn, --startRow, width, FALSE, + pattern, patternLength, counters); + if (previousRowLoc) { + 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 && 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; +} +CFX_Int32Array* CBC_Detector::findGuardPattern(CBC_CommonBitMatrix* matrix, + int32_t column, + int32_t row, + int32_t width, + FX_BOOL whiteFirst, + int32_t* pattern, + int32_t patternLength, + CFX_Int32Array& counters) { + for (int32_t i = 0; i < counters.GetSize(); i++) { + counters.SetAt(i, 0); + } + FX_BOOL isWhite = whiteFirst; + int32_t patternStart = column; + int32_t pixelDrift = 0; + CFX_Int32Array* intarray = new CFX_Int32Array; + while (matrix->Get(patternStart, row) && patternStart > 0 && + pixelDrift++ < MAX_PIXEL_DRIFT) { + patternStart--; + } + int32_t x = patternStart; + int32_t counterPosition = 0; + for (; x < width; x++) { + FX_BOOL pixel = matrix->Get(x, row); + if (pixel ^ isWhite) { + counters[counterPosition]++; + } else { + if (counterPosition == patternLength - 1) { + if (patternMatchVariance(counters, pattern, MAX_INDIVIDUAL_VARIANCE) < + MAX_AVG_VARIANCE) { + intarray->Add(patternStart); + intarray->Add(x); + return intarray; + } + patternStart += counters[0] + counters[1]; + for (int32_t l = 2, k = 0; l < patternLength; l++, k++) { + counters.SetAt(k, counters.GetAt(l)); + } + counters.SetAt(patternLength - 2, 0); + counters.SetAt(patternLength - 1, 0); + counterPosition--; + } else { + counterPosition++; + } + counters[counterPosition] = 1; + isWhite = !isWhite; + } + } + if (counterPosition == patternLength - 1) { + if (patternMatchVariance(counters, pattern, MAX_INDIVIDUAL_VARIANCE) < + MAX_AVG_VARIANCE) { + intarray->Add(patternStart); + intarray->Add(x - 1); + return intarray; + } + } + delete intarray; + return NULL; +} +int32_t CBC_Detector::patternMatchVariance(CFX_Int32Array& counters, + int32_t* pattern, + int32_t maxIndividualVariance) { + int32_t numCounters = counters.GetSize(); + int32_t total = 0; + int32_t patternLength = 0; + for (int32_t i = 0; i < numCounters; i++) { + total += counters[i]; + patternLength += pattern[i]; + } + if (total < patternLength) { + return INTEGER_MAX; + } + int32_t unitBarWidth = (total << INTEGER_MATH_SHIFT) / patternLength; + maxIndividualVariance = + (maxIndividualVariance * unitBarWidth) >> INTEGER_MATH_SHIFT; + int32_t totalVariance = 0; + for (int32_t x = 0; x < numCounters; x++) { + int32_t counter = counters[x] << INTEGER_MATH_SHIFT; + int32_t scaledPattern = pattern[x] * unitBarWidth; + int32_t variance = counter > scaledPattern ? counter - scaledPattern + : scaledPattern - counter; + if (variance > maxIndividualVariance) { + return INTEGER_MAX; + } + totalVariance += variance; + } + return totalVariance / total; +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417Detector.h b/xfa/fxbarcode/pdf417/BC_PDF417Detector.h new file mode 100644 index 0000000000..dda039d6d5 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417Detector.h @@ -0,0 +1,69 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417DETECTOR_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417DETECTOR_H_ + +class CBC_PDF417DetectorResult; +class CBC_BinaryBitmap; +class CBC_CommonBitMatrix; +class CBC_CommonBitArray; + +class CBC_Detector { + public: + CBC_Detector(); + virtual ~CBC_Detector(); + static CBC_PDF417DetectorResult* detect(CBC_BinaryBitmap* image, + int32_t hints, + FX_BOOL multiple, + int32_t& e); + static void rotate180(CBC_CommonBitMatrix* bitMatrix); + static CBC_CommonBitArray* mirror(CBC_CommonBitArray* input, + CBC_CommonBitArray* result); + + private: + static int32_t INDEXES_START_PATTERN[]; + static int32_t INDEXES_STOP_PATTERN[]; + static int32_t INTEGER_MATH_SHIFT; + static int32_t PATTERN_MATCH_RESULT_SCALE_FACTOR; + static int32_t MAX_AVG_VARIANCE; + static int32_t MAX_INDIVIDUAL_VARIANCE; + static int32_t START_PATTERN[]; + static int32_t STOP_PATTERN[]; + static int32_t MAX_PIXEL_DRIFT; + static int32_t MAX_PATTERN_DRIFT; + static int32_t SKIPPED_ROW_COUNT_MAX; + static int32_t ROW_STEP; + static int32_t BARCODE_MIN_HEIGHT; + static CFX_PtrArray* detect(FX_BOOL multiple, CBC_CommonBitMatrix* bitMatrix); + static CFX_PtrArray* findVertices(CBC_CommonBitMatrix* matrix, + int32_t startRow, + int32_t startColumn); + static void copyToResult(CFX_PtrArray* result, + CFX_PtrArray* tmpResult, + int32_t* destinationIndexes, + int32_t destinationLength); + static CFX_PtrArray* findRowsWithPattern(CBC_CommonBitMatrix* matrix, + int32_t height, + int32_t width, + int32_t startRow, + int32_t startColumn, + int32_t* pattern, + int32_t patternLength); + static CFX_Int32Array* findGuardPattern(CBC_CommonBitMatrix* matrix, + int32_t column, + int32_t row, + int32_t width, + FX_BOOL whiteFirst, + int32_t* pattern, + int32_t patternLength, + CFX_Int32Array& counters); + static int32_t patternMatchVariance(CFX_Int32Array& counters, + int32_t* pattern, + int32_t maxIndividualVariance); +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417DETECTOR_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417DetectorResult.cpp b/xfa/fxbarcode/pdf417/BC_PDF417DetectorResult.cpp new file mode 100644 index 0000000000..557d50d951 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417DetectorResult.cpp @@ -0,0 +1,50 @@ +// 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 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. + */ + +#include "xfa/fxbarcode/BC_ResultPoint.h" +#include "xfa/fxbarcode/common/BC_CommonBitMatrix.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417DetectorResult.h" + +CBC_PDF417DetectorResult::CBC_PDF417DetectorResult(CBC_CommonBitMatrix* bits, + CFX_PtrArray* points) { + m_bits = bits; + m_points = points; +} +CBC_PDF417DetectorResult::~CBC_PDF417DetectorResult() { + for (int32_t i = 0; i < m_points->GetSize(); i++) { + CFX_PtrArray* temp = (CFX_PtrArray*)m_points->GetAt(i); + for (int32_t j = 0; j < temp->GetSize(); j++) { + delete (CBC_ResultPoint*)temp->GetAt(j); + } + temp->RemoveAll(); + delete temp; + } + m_points->RemoveAll(); + delete m_points; +} +CBC_CommonBitMatrix* CBC_PDF417DetectorResult::getBits() { + return m_bits; +} + +CFX_PtrArray* CBC_PDF417DetectorResult::getPoints() { + return m_points; +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417DetectorResult.h b/xfa/fxbarcode/pdf417/BC_PDF417DetectorResult.h new file mode 100644 index 0000000000..0eea685fbc --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417DetectorResult.h @@ -0,0 +1,26 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417DETECTORRESULT_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417DETECTORRESULT_H_ + +#include "core/include/fxcrt/fx_basic.h" + +class CBC_CommonBitMatrix; + +class CBC_PDF417DetectorResult { + public: + CBC_PDF417DetectorResult(CBC_CommonBitMatrix* bits, CFX_PtrArray* points); + virtual ~CBC_PDF417DetectorResult(); + CBC_CommonBitMatrix* getBits(); + CFX_PtrArray* getPoints(); + + private: + CBC_CommonBitMatrix* m_bits; + CFX_PtrArray* m_points; +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417DETECTORRESULT_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417Dimensions.cpp b/xfa/fxbarcode/pdf417/BC_PDF417Dimensions.cpp new file mode 100644 index 0000000000..3f0b3145b0 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417Dimensions.cpp @@ -0,0 +1,46 @@ +// 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_PDF417Dimensions.h" + +CBC_Dimensions::CBC_Dimensions(int32_t minCols, + int32_t maxCols, + int32_t minRows, + int32_t maxRows) { + m_minCols = minCols; + m_maxCols = maxCols; + m_minRows = minRows; + m_maxRows = maxRows; +} +CBC_Dimensions::~CBC_Dimensions() {} +int32_t CBC_Dimensions::getMinCols() { + return m_minCols; +} +int32_t CBC_Dimensions::getMaxCols() { + return m_maxCols; +} +int32_t CBC_Dimensions::getMinRows() { + return m_minRows; +} +int32_t CBC_Dimensions::getMaxRows() { + return m_maxRows; +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417Dimensions.h b/xfa/fxbarcode/pdf417/BC_PDF417Dimensions.h new file mode 100644 index 0000000000..622ad236bc --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417Dimensions.h @@ -0,0 +1,31 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417DIMENSIONS_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417DIMENSIONS_H_ + +#include + +class CBC_Dimensions { + public: + CBC_Dimensions(int32_t minCols, + int32_t maxCols, + int32_t minRows, + int32_t maxRows); + virtual ~CBC_Dimensions(); + int32_t getMinCols(); + int32_t getMaxCols(); + int32_t getMinRows(); + int32_t getMaxRows(); + + private: + int32_t m_minCols; + int32_t m_maxCols; + int32_t m_minRows; + int32_t m_maxRows; +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417DIMENSIONS_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417ECErrorCorrection.cpp b/xfa/fxbarcode/pdf417/BC_PDF417ECErrorCorrection.cpp new file mode 100644 index 0000000000..830b65e199 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417ECErrorCorrection.cpp @@ -0,0 +1,389 @@ +// 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 = NULL; + +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_PtrArray* sigmaOmega = + runEuclideanAlgorithm(buildmonomial, syndrome, numECCodewords, e); + delete buildmonomial; + delete syndrome; + BC_EXCEPTION_CHECK_ReturnValue(e, -1); + CBC_PDF417ECModulusPoly* sigma = + (CBC_PDF417ECModulusPoly*)sigmaOmega->GetAt(0); + CBC_PDF417ECModulusPoly* omega = + (CBC_PDF417ECModulusPoly*)sigmaOmega->GetAt(1); + CFX_Int32Array* errorLocations = findErrorLocations(sigma, e); + if (e != BCExceptionNO) { + for (int32_t i = 0; i < sigmaOmega->GetSize(); i++) { + delete (CBC_PDF417ECModulusPoly*)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 (CBC_PDF417ECModulusPoly*)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 (CBC_PDF417ECModulusPoly*)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 (CBC_PDF417ECModulusPoly*)sigmaOmega->GetAt(k); + } + sigmaOmega->RemoveAll(); + delete sigmaOmega; + return result; +} +CFX_PtrArray* 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 = NULL; + CBC_PDF417ECModulusPoly* rtemp = NULL; + CBC_PDF417ECModulusPoly* ttemp = NULL; + 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; + if (qtemp) { + delete qtemp; + } + if (rtemp) { + delete rtemp; + } + if (ttemp) { + delete ttemp; + } + return NULL; + } + 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) { + if (qtemp) { + delete qtemp; + } + if (rtemp) { + delete rtemp; + } + if (ttemp) { + delete ttemp; + } + return NULL; + } + 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) { + if (qtemp) { + delete qtemp; + } + if (rtemp) { + delete rtemp; + } + if (ttemp) { + delete ttemp; + } + return NULL; + } + q = q->add(buildmonomial, e); + delete buildmonomial; + if (qtemp) { + delete qtemp; + } + if (e != BCExceptionNO) { + if (rtemp) { + delete rtemp; + } + if (ttemp) { + delete ttemp; + } + return NULL; + } + qtemp = q; + CBC_PDF417ECModulusPoly* multiply = + rLast->multiplyByMonomial(degreeDiff, scale, e); + if (e != BCExceptionNO) { + if (qtemp) { + delete qtemp; + } + if (rtemp) { + delete rtemp; + } + if (ttemp) { + delete ttemp; + } + return NULL; + } + CBC_PDF417ECModulusPoly* temp = r; + r = temp->subtract(multiply, e); + delete multiply; + if (m > 1 && i > m) { + delete temp; + temp = NULL; + } + if (e != BCExceptionNO) { + if (qtemp) { + delete qtemp; + } + if (rtemp) { + delete rtemp; + } + if (ttemp) { + delete ttemp; + } + return NULL; + } + rtemp = r; + i = m + 1; + } + ttemp = q->multiply(tLast, e); + if (qtemp) { + delete qtemp; + qtemp = NULL; + } + if (e != BCExceptionNO) { + if (rtemp) { + delete rtemp; + } + if (ttemp) { + delete ttemp; + } + return NULL; + } + t = ttemp->subtract(tLastLast, e); + if (n > 1 && j > n) { + delete tLastLast; + } + delete ttemp; + if (e != BCExceptionNO) { + if (rtemp) { + delete rtemp; + } + return NULL; + } + ttemp = t; + t = ttemp->negative(e); + delete ttemp; + if (e != BCExceptionNO) { + if (rtemp) { + delete rtemp; + } + return NULL; + } + ttemp = t; + j++; + } + int32_t sigmaTildeAtZero = t->getCoefficient(0); + if (sigmaTildeAtZero == 0) { + e = BCExceptionChecksumException; + if (rtemp) { + delete rtemp; + } + if (ttemp) { + delete ttemp; + } + return NULL; + } + int32_t inverse = m_field->inverse(sigmaTildeAtZero, e); + if (e != BCExceptionNO) { + if (rtemp) { + delete rtemp; + } + if (ttemp) { + delete ttemp; + } + return NULL; + } + CBC_PDF417ECModulusPoly* sigma = t->multiply(inverse, e); + if (ttemp) { + delete ttemp; + } + if (e != BCExceptionNO) { + if (rtemp) { + delete rtemp; + } + return NULL; + } + CBC_PDF417ECModulusPoly* omega = r->multiply(inverse, e); + if (rtemp) { + delete rtemp; + } + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + CFX_PtrArray* modulusPoly = new CFX_PtrArray; + 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 NULL; + } + ee++; + } + } + if (ee != numErrors) { + e = BCExceptionChecksumException; + delete result; + return NULL; + } + 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, NULL); + 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 NULL; + } + 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 NULL; + } + result->SetAt(i, m_field->multiply(numerator, denominator)); + } + return result; +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417ECErrorCorrection.h b/xfa/fxbarcode/pdf417/BC_PDF417ECErrorCorrection.h new file mode 100644 index 0000000000..d7b56defe9 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417ECErrorCorrection.h @@ -0,0 +1,39 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417ECERRORCORRECTION_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417ECERRORCORRECTION_H_ + +class CBC_PDF417ECModulusGF; +class CBC_PDF417ECModulusPoly; +class CBC_PDF417ECErrorCorrection { + public: + CBC_PDF417ECErrorCorrection(); + virtual ~CBC_PDF417ECErrorCorrection(); + static void Initialize(int32_t& e); + static void Finalize(); + static int32_t decode(CFX_Int32Array& received, + int32_t numECCodewords, + CFX_Int32Array& erasures, + int32_t& e); + + private: + static CBC_PDF417ECModulusGF* m_field; + static CFX_PtrArray* runEuclideanAlgorithm(CBC_PDF417ECModulusPoly* a, + CBC_PDF417ECModulusPoly* b, + int32_t R, + int32_t& e); + static CFX_Int32Array* findErrorLocations( + CBC_PDF417ECModulusPoly* errorLocator, + int32_t& e); + static CFX_Int32Array* findErrorMagnitudes( + CBC_PDF417ECModulusPoly* errorEvaluator, + CBC_PDF417ECModulusPoly* errorLocator, + CFX_Int32Array& errorLocations, + int32_t& e); +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417ECERRORCORRECTION_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417ECModulusGF.cpp b/xfa/fxbarcode/pdf417/BC_PDF417ECModulusGF.cpp new file mode 100644 index 0000000000..4779d80157 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417ECModulusGF.cpp @@ -0,0 +1,120 @@ +// 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_PDF417ECModulusGF.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417ECModulusPoly.h" +#include "xfa/fxbarcode/utils.h" + +CBC_PDF417ECModulusGF* CBC_PDF417ECModulusGF::PDF417_GF = NULL; +void CBC_PDF417ECModulusGF::Initialize(int32_t& e) { + PDF417_GF = + new CBC_PDF417ECModulusGF(CBC_PDF417Common::NUMBER_OF_CODEWORDS, 3, e); +} +void CBC_PDF417ECModulusGF::Finalize() { + delete PDF417_GF; +} +CBC_PDF417ECModulusGF::CBC_PDF417ECModulusGF(int32_t modulus, + int32_t generator, + int32_t& e) { + m_modulus = modulus; + m_expTable.SetSize(modulus); + m_logTable.SetSize(modulus); + int32_t x = 1; + for (int32_t i = 0; i < modulus; i++) { + m_expTable[i] = x; + x = (x * generator) % modulus; + } + for (int32_t j = 0; j < modulus - 1; j++) { + m_logTable[m_expTable[j]] = j; + } + CFX_Int32Array zero; + zero.Add(0); + m_zero = new CBC_PDF417ECModulusPoly(this, zero, e); + CFX_Int32Array one; + one.Add(1); + m_one = new CBC_PDF417ECModulusPoly(this, one, e); +} +CBC_PDF417ECModulusGF::~CBC_PDF417ECModulusGF() { + delete m_zero; + delete m_one; +} +CBC_PDF417ECModulusPoly* CBC_PDF417ECModulusGF::getZero() { + return m_zero; +} +CBC_PDF417ECModulusPoly* CBC_PDF417ECModulusGF::getOne() { + return m_one; +} +CBC_PDF417ECModulusPoly* CBC_PDF417ECModulusGF::buildMonomial( + int32_t degree, + int32_t coefficient, + int32_t& e) { + if (degree < 0) { + e = BCExceptionIllegalArgument; + return NULL; + } + CBC_PDF417ECModulusPoly* modulusPoly = NULL; + if (coefficient == 0) { + modulusPoly = new CBC_PDF417ECModulusPoly(m_zero->getField(), + m_zero->getCoefficients(), e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + return modulusPoly; + } + CFX_Int32Array coefficients; + coefficients.SetSize(degree + 1); + coefficients[0] = coefficient; + modulusPoly = new CBC_PDF417ECModulusPoly(this, coefficients, e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + return modulusPoly; +} +int32_t CBC_PDF417ECModulusGF::add(int32_t a, int32_t b) { + return (a + b) % m_modulus; +} +int32_t CBC_PDF417ECModulusGF::subtract(int32_t a, int32_t b) { + return (m_modulus + a - b) % m_modulus; +} +int32_t CBC_PDF417ECModulusGF::exp(int32_t a) { + return m_expTable[a]; +} +int32_t CBC_PDF417ECModulusGF::log(int32_t a, int32_t& e) { + if (a == 0) { + e = BCExceptionIllegalArgument; + return -1; + } + return m_logTable[a]; +} +int32_t CBC_PDF417ECModulusGF::inverse(int32_t a, int32_t& e) { + if (a == 0) { + e = BCExceptionIllegalArgument; + return -1; + } + return m_expTable[m_modulus - m_logTable[a] - 1]; +} +int32_t CBC_PDF417ECModulusGF::multiply(int32_t a, int32_t b) { + if (a == 0 || b == 0) { + return 0; + } + return m_expTable[(m_logTable[a] + m_logTable[b]) % (m_modulus - 1)]; +} +int32_t CBC_PDF417ECModulusGF::getSize() { + return m_modulus; +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417ECModulusGF.h b/xfa/fxbarcode/pdf417/BC_PDF417ECModulusGF.h new file mode 100644 index 0000000000..094e00164d --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417ECModulusGF.h @@ -0,0 +1,39 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417ECMODULUSGF_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417ECMODULUSGF_H_ + +class CBC_PDF417ECModulusPoly; +class CBC_PDF417ECModulusGF { + public: + CBC_PDF417ECModulusGF(int32_t modulus, int32_t generator, int32_t& e); + virtual ~CBC_PDF417ECModulusGF(); + static void Initialize(int32_t& e); + static void Finalize(); + CBC_PDF417ECModulusPoly* getZero(); + CBC_PDF417ECModulusPoly* getOne(); + CBC_PDF417ECModulusPoly* buildMonomial(int32_t degree, + int32_t coefficient, + int32_t& e); + int32_t add(int32_t a, int32_t b); + int32_t subtract(int32_t a, int32_t b); + int32_t exp(int32_t a); + int32_t log(int32_t a, int32_t& e); + int32_t inverse(int32_t a, int32_t& e); + int32_t multiply(int32_t a, int32_t b); + int32_t getSize(); + static CBC_PDF417ECModulusGF* PDF417_GF; + + private: + CFX_Int32Array m_expTable; + CFX_Int32Array m_logTable; + CBC_PDF417ECModulusPoly* m_zero; + CBC_PDF417ECModulusPoly* m_one; + int32_t m_modulus; +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417ECMODULUSGF_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417ECModulusPoly.cpp b/xfa/fxbarcode/pdf417/BC_PDF417ECModulusPoly.cpp new file mode 100644 index 0000000000..d0bbe5ab0a --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417ECModulusPoly.cpp @@ -0,0 +1,332 @@ +// 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_PDF417ECModulusGF.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417ECModulusPoly.h" +#include "xfa/fxbarcode/utils.h" + +CBC_PDF417ECModulusPoly::CBC_PDF417ECModulusPoly(CBC_PDF417ECModulusGF* field, + CFX_Int32Array& coefficients, + int32_t& e) { + if (coefficients.GetSize() == 0) { + e = BCExceptionIllegalArgument; + } + m_field = field; + int32_t coefficientsLength = coefficients.GetSize(); + if (coefficientsLength > 1 && coefficients[0] == 0) { + int32_t firstNonZero = 1; + while (firstNonZero < coefficientsLength && + coefficients[firstNonZero] == 0) { + firstNonZero++; + } + if (firstNonZero == coefficientsLength) { + m_coefficients = field->getZero()->m_coefficients; + } else { + m_coefficients.SetSize(coefficientsLength - firstNonZero); + int32_t l = 0; + for (int32_t i = firstNonZero; + i < firstNonZero + m_coefficients.GetSize(); i++) { + m_coefficients.SetAt(l, coefficients.GetAt(i)); + l++; + } + } + } else { + m_coefficients.Copy(coefficients); + } +} +CBC_PDF417ECModulusPoly::~CBC_PDF417ECModulusPoly() {} +CFX_Int32Array& CBC_PDF417ECModulusPoly::getCoefficients() { + return m_coefficients; +} +CBC_PDF417ECModulusGF* CBC_PDF417ECModulusPoly::getField() { + return m_field; +} +int32_t CBC_PDF417ECModulusPoly::getDegree() { + return m_coefficients.GetSize() - 1; +} +FX_BOOL CBC_PDF417ECModulusPoly::isZero() { + return m_coefficients[0] == 0; +} +int32_t CBC_PDF417ECModulusPoly::getCoefficient(int32_t degree) { + return m_coefficients[m_coefficients.GetSize() - 1 - degree]; +} +int32_t CBC_PDF417ECModulusPoly::evaluateAt(int32_t a) { + if (a == 0) { + return getCoefficient(0); + } + int32_t size = m_coefficients.GetSize(); + if (a == 1) { + int32_t result = 0; + for (int32_t l = 0; l < m_coefficients.GetSize(); l++) { + int32_t coefficient = m_coefficients.GetAt(l); + result = m_field->add(result, coefficient); + } + return result; + } + int32_t result = m_coefficients[0]; + for (int32_t i = 1; i < size; i++) { + result = m_field->add(m_field->multiply(a, result), m_coefficients[i]); + } + return result; +} +CBC_PDF417ECModulusPoly* CBC_PDF417ECModulusPoly::add( + CBC_PDF417ECModulusPoly* other, + int32_t& e) { + CBC_PDF417ECModulusPoly* modulusPoly = NULL; + if (isZero()) { + modulusPoly = new CBC_PDF417ECModulusPoly(other->getField(), + other->getCoefficients(), e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + return modulusPoly; + } + if (other->isZero()) { + modulusPoly = new CBC_PDF417ECModulusPoly(m_field, m_coefficients, e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + return modulusPoly; + } + CFX_Int32Array smallerCoefficients; + smallerCoefficients.Copy(m_coefficients); + CFX_Int32Array largerCoefficients; + largerCoefficients.Copy(other->m_coefficients); + 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 l = 0; l < lengthDiff; l++) { + sumDiff.SetAt(l, largerCoefficients.GetAt(l)); + } + for (int32_t i = lengthDiff; i < largerCoefficients.GetSize(); i++) { + sumDiff[i] = m_field->add(smallerCoefficients[i - lengthDiff], + largerCoefficients[i]); + } + modulusPoly = new CBC_PDF417ECModulusPoly(m_field, sumDiff, e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + return modulusPoly; +} +CBC_PDF417ECModulusPoly* CBC_PDF417ECModulusPoly::subtract( + CBC_PDF417ECModulusPoly* other, + int32_t& e) { + CBC_PDF417ECModulusPoly* modulusPoly = NULL; + if (other->isZero()) { + modulusPoly = new CBC_PDF417ECModulusPoly(m_field, m_coefficients, e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + return modulusPoly; + } + CBC_PDF417ECModulusPoly* poly = other->negative(e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + modulusPoly = add(poly, e); + delete poly; + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + return modulusPoly; +} +CBC_PDF417ECModulusPoly* CBC_PDF417ECModulusPoly::multiply( + CBC_PDF417ECModulusPoly* other, + int32_t& e) { + CBC_PDF417ECModulusPoly* modulusPoly = NULL; + if (isZero() || other->isZero()) { + modulusPoly = + new CBC_PDF417ECModulusPoly(m_field->getZero()->getField(), + m_field->getZero()->getCoefficients(), e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + return modulusPoly; + } + CFX_Int32Array aCoefficients; + aCoefficients.Copy(m_coefficients); + int32_t aLength = aCoefficients.GetSize(); + CFX_Int32Array bCoefficients; + bCoefficients.Copy(other->m_coefficients); + int32_t bLength = bCoefficients.GetSize(); + CFX_Int32Array product; + product.SetSize(aLength + bLength - 1); + for (int32_t i = 0; i < aLength; i++) { + int32_t aCoeff = aCoefficients[i]; + for (int32_t j = 0; j < bLength; j++) { + product[i + j] = m_field->add( + product[i + j], m_field->multiply(aCoeff, bCoefficients[j])); + } + } + modulusPoly = new CBC_PDF417ECModulusPoly(m_field, product, e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + return modulusPoly; +} +CBC_PDF417ECModulusPoly* CBC_PDF417ECModulusPoly::negative(int32_t& e) { + int32_t size = m_coefficients.GetSize(); + CFX_Int32Array negativeCoefficients; + negativeCoefficients.SetSize(size); + for (int32_t i = 0; i < size; i++) { + negativeCoefficients[i] = m_field->subtract(0, m_coefficients[i]); + } + CBC_PDF417ECModulusPoly* modulusPoly = + new CBC_PDF417ECModulusPoly(m_field, negativeCoefficients, e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + return modulusPoly; +} +CBC_PDF417ECModulusPoly* CBC_PDF417ECModulusPoly::multiply(int32_t scalar, + int32_t& e) { + CBC_PDF417ECModulusPoly* modulusPoly = NULL; + if (scalar == 0) { + modulusPoly = + new CBC_PDF417ECModulusPoly(m_field->getZero()->getField(), + m_field->getZero()->getCoefficients(), e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + return modulusPoly; + } + if (scalar == 1) { + modulusPoly = new CBC_PDF417ECModulusPoly(m_field, m_coefficients, e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + return modulusPoly; + } + int32_t size = m_coefficients.GetSize(); + CFX_Int32Array product; + product.SetSize(size); + for (int32_t i = 0; i < size; i++) { + product[i] = m_field->multiply(m_coefficients[i], scalar); + } + modulusPoly = new CBC_PDF417ECModulusPoly(m_field, product, e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + return modulusPoly; +} +CBC_PDF417ECModulusPoly* CBC_PDF417ECModulusPoly::multiplyByMonomial( + int32_t degree, + int32_t coefficient, + int32_t& e) { + if (degree < 0) { + e = BCExceptionIllegalArgument; + return NULL; + } + CBC_PDF417ECModulusPoly* modulusPoly = NULL; + if (coefficient == 0) { + modulusPoly = new CBC_PDF417ECModulusPoly( + m_field->getZero()->m_field, m_field->getZero()->m_coefficients, e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + return modulusPoly; + } + int32_t size = m_coefficients.GetSize(); + CFX_Int32Array product; + product.SetSize(size + degree); + for (int32_t i = 0; i < size; i++) { + product[i] = m_field->multiply(m_coefficients[i], coefficient); + } + modulusPoly = new CBC_PDF417ECModulusPoly(m_field, product, e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + return modulusPoly; +} +CFX_PtrArray* CBC_PDF417ECModulusPoly::divide(CBC_PDF417ECModulusPoly* other, + int32_t& e) { + if (other->isZero()) { + e = BCExceptionDivideByZero; + return NULL; + } + CBC_PDF417ECModulusPoly* quotient = new CBC_PDF417ECModulusPoly( + m_field->getZero()->m_field, m_field->getZero()->m_coefficients, e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + CBC_PDF417ECModulusPoly* remainder = + new CBC_PDF417ECModulusPoly(m_field, m_coefficients, e); + if (e != BCExceptionNO) { + delete quotient; + return NULL; + } + int32_t denominatorLeadingTerm = other->getCoefficient(other->getDegree()); + int32_t inverseDenominatorLeadingTerm = + m_field->inverse(denominatorLeadingTerm, e); + if (e != BCExceptionNO) { + delete quotient; + delete remainder; + return NULL; + } + while (remainder->getDegree() >= other->getDegree() && !remainder->isZero()) { + int32_t degreeDifference = remainder->getDegree() - other->getDegree(); + int32_t scale = + m_field->multiply(remainder->getCoefficient(remainder->getDegree()), + inverseDenominatorLeadingTerm); + CBC_PDF417ECModulusPoly* term = + other->multiplyByMonomial(degreeDifference, scale, e); + if (e != BCExceptionNO) { + delete quotient; + delete remainder; + return NULL; + } + CBC_PDF417ECModulusPoly* iterationQuotient = + m_field->buildMonomial(degreeDifference, scale, e); + if (e != BCExceptionNO) { + delete quotient; + delete remainder; + delete term; + return NULL; + } + CBC_PDF417ECModulusPoly* temp = quotient; + quotient = temp->add(iterationQuotient, e); + delete iterationQuotient; + delete temp; + if (e != BCExceptionNO) { + delete remainder; + return NULL; + } + temp = remainder; + remainder = temp->subtract(term, e); + delete term; + delete temp; + if (e != BCExceptionNO) { + delete quotient; + return NULL; + } + } + CFX_PtrArray* modulusPoly = new CFX_PtrArray; + modulusPoly->Add(quotient); + modulusPoly->Add(remainder); + return modulusPoly; +} +CFX_ByteString CBC_PDF417ECModulusPoly::toString() { + CFX_ByteString result; + for (int32_t degree = getDegree(); degree >= 0; degree--) { + int32_t coefficient = getCoefficient(degree); + if (coefficient != 0) { + if (coefficient < 0) { + result += " - "; + coefficient = -coefficient; + } else { + if (result.GetLength() > 0) { + result += " + "; + } + } + if (degree == 0 || coefficient != 1) { + result += coefficient; + } + if (degree != 0) { + if (degree == 1) { + result += 'x'; + } else { + result += "x^"; + result += degree; + } + } + } + } + return result; +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417ECModulusPoly.h b/xfa/fxbarcode/pdf417/BC_PDF417ECModulusPoly.h new file mode 100644 index 0000000000..2eff3ef1ce --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417ECModulusPoly.h @@ -0,0 +1,39 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417ECMODULUSPOLY_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417ECMODULUSPOLY_H_ + +class CBC_PDF417ECModulusGF; +class CBC_PDF417ECModulusPoly { + public: + CBC_PDF417ECModulusPoly(CBC_PDF417ECModulusGF* field, + CFX_Int32Array& coefficients, + int32_t& e); + virtual ~CBC_PDF417ECModulusPoly(); + CFX_Int32Array& getCoefficients(); + CBC_PDF417ECModulusGF* getField(); + int32_t getDegree(); + FX_BOOL isZero(); + int32_t getCoefficient(int32_t degree); + int32_t evaluateAt(int32_t a); + CBC_PDF417ECModulusPoly* add(CBC_PDF417ECModulusPoly* other, int32_t& e); + CBC_PDF417ECModulusPoly* subtract(CBC_PDF417ECModulusPoly* other, int32_t& e); + CBC_PDF417ECModulusPoly* multiply(CBC_PDF417ECModulusPoly* other, int32_t& e); + CBC_PDF417ECModulusPoly* negative(int32_t& e); + CBC_PDF417ECModulusPoly* multiply(int32_t scalar, int32_t& e); + CBC_PDF417ECModulusPoly* multiplyByMonomial(int32_t degree, + int32_t coefficient, + int32_t& e); + CFX_PtrArray* divide(CBC_PDF417ECModulusPoly* other, int32_t& e); + CFX_ByteString toString(); + + private: + CBC_PDF417ECModulusGF* m_field; + CFX_Int32Array m_coefficients; +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417ECMODULUSPOLY_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417ErrorCorrection.cpp b/xfa/fxbarcode/pdf417/BC_PDF417ErrorCorrection.cpp new file mode 100644 index 0000000000..0d4f2ffdb3 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417ErrorCorrection.cpp @@ -0,0 +1,165 @@ +// 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 2006 Jeremias Maerki in part, and ZXing Authors in part + * + * 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_PDF417ErrorCorrection.h" +#include "xfa/fxbarcode/utils.h" + +int32_t CBC_PDF417ErrorCorrection::EC_COEFFICIENTS[][2500] = { + {27, 917}, + {522, 568, 723, 809}, + {237, 308, 436, 284, 646, 653, 428, 379}, + {274, 562, 232, 755, 599, 524, 801, 132, 295, 116, 442, 428, 295, 42, 176, + 65}, + {361, 575, 922, 525, 176, 586, 640, 321, 536, 742, 677, 742, 687, 284, 193, + 517, 273, 494, 263, 147, 593, 800, 571, 320, 803, 133, 231, 390, 685, 330, + 63, 410}, + {539, 422, 6, 93, 862, 771, 453, 106, 610, 287, 107, 505, 733, 877, 381, + 612, 723, 476, 462, 172, 430, 609, 858, 822, 543, 376, 511, 400, 672, 762, + 283, 184, 440, 35, 519, 31, 460, 594, 225, 535, 517, 352, 605, 158, 651, + 201, 488, 502, 648, 733, 717, 83, 404, 97, 280, 771, 840, 629, 4, 381, 843, + 623, 264, 543}, + {521, 310, 864, 547, 858, 580, 296, 379, 53, 779, 897, 444, 400, 925, 749, + 415, 822, 93, 217, 208, 928, 244, 583, 620, 246, 148, 447, 631, 292, 908, + 490, 704, 516, 258, 457, 907, 594, 723, 674, 292, 272, 96, 684, 432, 686, + 606, 860, 569, 193, 219, 129, 186, 236, 287, 192, 775, 278, 173, 40, 379, + 712, 463, 646, 776, 171, 491, 297, 763, 156, 732, 95, 270, 447, 90, 507, + 48, 228, 821, 808, 898, 784, 663, 627, 378, 382, 262, 380, 602, 754, 336, + 89, 614, 87, 432, 670, 616, 157, 374, 242, 726, 600, 269, 375, 898, 845, + 454, 354, 130, 814, 587, 804, 34, 211, 330, 539, 297, 827, 865, 37, 517, + 834, 315, 550, 86, 801, 4, 108, 539}, + {524, 894, 75, 766, 882, 857, 74, 204, 82, 586, 708, 250, 905, 786, 138, + 720, 858, 194, 311, 913, 275, 190, 375, 850, 438, 733, 194, 280, 201, 280, + 828, 757, 710, 814, 919, 89, 68, 569, 11, 204, 796, 605, 540, 913, 801, + 700, 799, 137, 439, 418, 592, 668, 353, 859, 370, 694, 325, 240, 216, 257, + 284, 549, 209, 884, 315, 70, 329, 793, 490, 274, 877, 162, 749, 812, 684, + 461, 334, 376, 849, 521, 307, 291, 803, 712, 19, 358, 399, 908, 103, 511, + 51, 8, 517, 225, 289, 470, 637, 731, 66, 255, 917, 269, 463, 830, 730, 433, + 848, 585, 136, 538, 906, 90, 2, 290, 743, 199, 655, 903, 329, 49, 802, 580, + 355, 588, 188, 462, 10, 134, 628, 320, 479, 130, 739, 71, 263, 318, 374, + 601, 192, 605, 142, 673, 687, 234, 722, 384, 177, 752, 607, 640, 455, 193, + 689, 707, 805, 641, 48, 60, 732, 621, 895, 544, 261, 852, 655, 309, 697, + 755, 756, 60, 231, 773, 434, 421, 726, 528, 503, 118, 49, 795, 32, 144, + 500, 238, 836, 394, 280, 566, 319, 9, 647, 550, 73, 914, 342, 126, 32, 681, + 331, 792, 620, 60, 609, 441, 180, 791, 893, 754, 605, 383, 228, 749, 760, + 213, 54, 297, 134, 54, 834, 299, 922, 191, 910, 532, 609, 829, 189, 20, + 167, 29, 872, 449, 83, 402, 41, 656, 505, 579, 481, 173, 404, 251, 688, 95, + 497, 555, 642, 543, 307, 159, 924, 558, 648, 55, 497, 10}, + {352, 77, 373, 504, 35, 599, 428, 207, 409, 574, 118, 498, 285, 380, 350, + 492, 197, 265, 920, 155, 914, 299, 229, 643, 294, 871, 306, 88, 87, 193, + 352, 781, 846, 75, 327, 520, 435, 543, 203, 666, 249, 346, 781, 621, 640, + 268, 794, 534, 539, 781, 408, 390, 644, 102, 476, 499, 290, 632, 545, 37, + 858, 916, 552, 41, 542, 289, 122, 272, 383, 800, 485, 98, 752, 472, 761, + 107, 784, 860, 658, 741, 290, 204, 681, 407, 855, 85, 99, 62, 482, 180, 20, + 297, 451, 593, 913, 142, 808, 684, 287, 536, 561, 76, 653, 899, 729, 567, + 744, 390, 513, 192, 516, 258, 240, 518, 794, 395, 768, 848, 51, 610, 384, + 168, 190, 826, 328, 596, 786, 303, 570, 381, 415, 641, 156, 237, 151, 429, + 531, 207, 676, 710, 89, 168, 304, 402, 40, 708, 575, 162, 864, 229, 65, + 861, 841, 512, 164, 477, 221, 92, 358, 785, 288, 357, 850, 836, 827, 736, + 707, 94, 8, 494, 114, 521, 2, 499, 851, 543, 152, 729, 771, 95, 248, 361, + 578, 323, 856, 797, 289, 51, 684, 466, 533, 820, 669, 45, 902, 452, 167, + 342, 244, 173, 35, 463, 651, 51, 699, 591, 452, 578, 37, 124, 298, 332, + 552, 43, 427, 119, 662, 777, 475, 850, 764, 364, 578, 911, 283, 711, 472, + 420, 245, 288, 594, 394, 511, 327, 589, 777, 699, 688, 43, 408, 842, 383, + 721, 521, 560, 644, 714, 559, 62, 145, 873, 663, 713, 159, 672, 729, 624, + 59, 193, 417, 158, 209, 563, 564, 343, 693, 109, 608, 563, 365, 181, 772, + 677, 310, 248, 353, 708, 410, 579, 870, 617, 841, 632, 860, 289, 536, 35, + 777, 618, 586, 424, 833, 77, 597, 346, 269, 757, 632, 695, 751, 331, 247, + 184, 45, 787, 680, 18, 66, 407, 369, 54, 492, 228, 613, 830, 922, 437, 519, + 644, 905, 789, 420, 305, 441, 207, 300, 892, 827, 141, 537, 381, 662, 513, + 56, 252, 341, 242, 797, 838, 837, 720, 224, 307, 631, 61, 87, 560, 310, + 756, 665, 397, 808, 851, 309, 473, 795, 378, 31, 647, 915, 459, 806, 590, + 731, 425, 216, 548, 249, 321, 881, 699, 535, 673, 782, 210, 815, 905, 303, + 843, 922, 281, 73, 469, 791, 660, 162, 498, 308, 155, 422, 907, 817, 187, + 62, 16, 425, 535, 336, 286, 437, 375, 273, 610, 296, 183, 923, 116, 667, + 751, 353, 62, 366, 691, 379, 687, 842, 37, 357, 720, 742, 330, 5, 39, 923, + 311, 424, 242, 749, 321, 54, 669, 316, 342, 299, 534, 105, 667, 488, 640, + 672, 576, 540, 316, 486, 721, 610, 46, 656, 447, 171, 616, 464, 190, 531, + 297, 321, 762, 752, 533, 175, 134, 14, 381, 433, 717, 45, 111, 20, 596, + 284, 736, 138, 646, 411, 877, 669, 141, 919, 45, 780, 407, 164, 332, 899, + 165, 726, 600, 325, 498, 655, 357, 752, 768, 223, 849, 647, 63, 310, 863, + 251, 366, 304, 282, 738, 675, 410, 389, 244, 31, 121, 303, 263}}; + +CBC_PDF417ErrorCorrection::CBC_PDF417ErrorCorrection() {} +CBC_PDF417ErrorCorrection::~CBC_PDF417ErrorCorrection() {} +int32_t CBC_PDF417ErrorCorrection::getErrorCorrectionCodewordCount( + int32_t errorCorrectionLevel, + int32_t& e) { + if (errorCorrectionLevel < 0 || errorCorrectionLevel > 8) { + e = BCExceptionErrorCorrectionLevelMustBeBetween0And8; + return -1; + } + return 1 << (errorCorrectionLevel + 1); +} +int32_t CBC_PDF417ErrorCorrection::getRecommendedMinimumErrorCorrectionLevel( + int32_t n, + int32_t& e) { + if (n <= 0) { + e = BCExceptionIllegalArgumentnMustBeAbove0; + return -1; + } + if (n <= 40) { + return 2; + } + if (n <= 160) { + return 3; + } + if (n <= 320) { + return 4; + } + if (n <= 863) { + return 5; + } + e = BCExceptionNoRecommendationPossible; + return -1; +} +CFX_WideString CBC_PDF417ErrorCorrection::generateErrorCorrection( + CFX_WideString dataCodewords, + int32_t errorCorrectionLevel, + int32_t& e) { + int32_t k = getErrorCorrectionCodewordCount(errorCorrectionLevel, e); + BC_EXCEPTION_CHECK_ReturnValue(e, (FX_WCHAR)' '); + FX_WCHAR* ech = FX_Alloc(FX_WCHAR, k); + FXSYS_memset(ech, 0, k * sizeof(FX_WCHAR)); + int32_t sld = dataCodewords.GetLength(); + for (int32_t i = 0; i < sld; i++) { + int32_t t1 = (dataCodewords.GetAt(i) + ech[k - 1]) % 929; + int32_t t2; + int32_t t3; + for (int32_t j = k - 1; j >= 1; j--) { + t2 = (t1 * EC_COEFFICIENTS[errorCorrectionLevel][j]) % 929; + t3 = 929 - t2; + ech[j] = (FX_WCHAR)((ech[j - 1] + t3) % 929); + } + t2 = (t1 * EC_COEFFICIENTS[errorCorrectionLevel][0]) % 929; + t3 = 929 - t2; + ech[0] = (FX_WCHAR)(t3 % 929); + } + CFX_WideString sb; + for (int32_t j = k - 1; j >= 0; j--) { + if (ech[j] != 0) { + ech[j] = (FX_WCHAR)(929 - ech[j]); + } + sb += (FX_WCHAR)ech[j]; + } + FX_Free(ech); + return sb; +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417ErrorCorrection.h b/xfa/fxbarcode/pdf417/BC_PDF417ErrorCorrection.h new file mode 100644 index 0000000000..9a2a0c63ef --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417ErrorCorrection.h @@ -0,0 +1,30 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417ERRORCORRECTION_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417ERRORCORRECTION_H_ + +#include + +#include "core/include/fxcrt/fx_string.h" + +class CBC_PDF417ErrorCorrection { + public: + CBC_PDF417ErrorCorrection(); + virtual ~CBC_PDF417ErrorCorrection(); + static int32_t getErrorCorrectionCodewordCount(int32_t errorCorrectionLevel, + int32_t& e); + static int32_t getRecommendedMinimumErrorCorrectionLevel(int32_t n, + int32_t& e); + static CFX_WideString generateErrorCorrection(CFX_WideString dataCodewords, + int32_t errorCorrectionLevel, + int32_t& e); + + private: + static int32_t EC_COEFFICIENTS[][2500]; +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417ERRORCORRECTION_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417HighLevelEncoder.cpp b/xfa/fxbarcode/pdf417/BC_PDF417HighLevelEncoder.cpp new file mode 100644 index 0000000000..27c6651542 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417HighLevelEncoder.cpp @@ -0,0 +1,427 @@ +// 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 2006 Jeremias Maerki in part, and ZXing Authors in part + * + * 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_PDF417HighLevelEncoder.h" + +#include "third_party/bigint/BigIntegerLibrary.hh" +#include "xfa/fxbarcode/BC_UtilCodingConvert.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417Compaction.h" +#include "xfa/fxbarcode/utils.h" + +#define SUBMODE_ALPHA 0 +#define SUBMODE_LOWER 1 +#define SUBMODE_MIXED 2 + +int32_t CBC_PDF417HighLevelEncoder::TEXT_COMPACTION = 0; +int32_t CBC_PDF417HighLevelEncoder::BYTE_COMPACTION = 1; +int32_t CBC_PDF417HighLevelEncoder::NUMERIC_COMPACTION = 2; +int32_t CBC_PDF417HighLevelEncoder::SUBMODE_PUNCTUATION = 3; +int32_t CBC_PDF417HighLevelEncoder::LATCH_TO_TEXT = 900; +int32_t CBC_PDF417HighLevelEncoder::LATCH_TO_BYTE_PADDED = 901; +int32_t CBC_PDF417HighLevelEncoder::LATCH_TO_NUMERIC = 902; +int32_t CBC_PDF417HighLevelEncoder::SHIFT_TO_BYTE = 913; +int32_t CBC_PDF417HighLevelEncoder::LATCH_TO_BYTE = 924; +uint8_t CBC_PDF417HighLevelEncoder::TEXT_MIXED_RAW[] = { + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 38, 13, 9, 44, 58, + 35, 45, 46, 36, 47, 43, 37, 42, 61, 94, 0, 32, 0, 0, 0}; +uint8_t CBC_PDF417HighLevelEncoder::TEXT_PUNCTUATION_RAW[] = { + 59, 60, 62, 64, 91, 92, 93, 95, 96, 126, 33, 13, 9, 44, 58, + 10, 45, 46, 36, 47, 34, 124, 42, 40, 41, 63, 123, 125, 39, 0}; +int32_t CBC_PDF417HighLevelEncoder::MIXED[128] = {0}; +int32_t CBC_PDF417HighLevelEncoder::PUNCTUATION[128] = {0}; + +void CBC_PDF417HighLevelEncoder::Initialize() { + Inverse(); +} +void CBC_PDF417HighLevelEncoder::Finalize() {} +CFX_WideString CBC_PDF417HighLevelEncoder::encodeHighLevel( + CFX_WideString wideMsg, + Compaction compaction, + int32_t& e) { + CFX_ByteString bytes; + CBC_UtilCodingConvert::UnicodeToUTF8(wideMsg, bytes); + CFX_WideString msg; + int32_t len = bytes.GetLength(); + for (int32_t i = 0; i < len; i++) { + FX_WCHAR ch = (FX_WCHAR)(bytes.GetAt(i) & 0xff); + if (ch == '?' && bytes.GetAt(i) != '?') { + e = BCExceptionCharactersOutsideISO88591Encoding; + return (FX_WCHAR*)""; + } + msg += ch; + } + CFX_ByteArray byteArr; + for (int32_t k = 0; k < bytes.GetLength(); k++) { + byteArr.Add(bytes.GetAt(k)); + } + CFX_WideString sb; + len = msg.GetLength(); + int32_t p = 0; + int32_t textSubMode = SUBMODE_ALPHA; + if (compaction == TEXT) { + encodeText(msg, p, len, sb, textSubMode); + } else if (compaction == BYTES) { + encodeBinary(&byteArr, p, byteArr.GetSize(), BYTE_COMPACTION, sb); + } else if (compaction == NUMERIC) { + sb += (FX_WCHAR)LATCH_TO_NUMERIC; + encodeNumeric(msg, p, len, sb); + } else { + int32_t encodingMode = LATCH_TO_TEXT; + while (p < len) { + int32_t n = determineConsecutiveDigitCount(msg, p); + if (n >= 13) { + sb += (FX_WCHAR)LATCH_TO_NUMERIC; + encodingMode = NUMERIC_COMPACTION; + textSubMode = SUBMODE_ALPHA; + encodeNumeric(msg, p, n, sb); + p += n; + } else { + int32_t t = determineConsecutiveTextCount(msg, p); + if (t >= 5 || n == len) { + if (encodingMode != TEXT_COMPACTION) { + sb += (FX_WCHAR)LATCH_TO_TEXT; + encodingMode = TEXT_COMPACTION; + textSubMode = SUBMODE_ALPHA; + } + textSubMode = encodeText(msg, p, t, sb, textSubMode); + p += t; + } else { + int32_t b = determineConsecutiveBinaryCount(msg, &byteArr, p, e); + BC_EXCEPTION_CHECK_ReturnValue(e, (FX_WCHAR)' '); + if (b == 0) { + b = 1; + } + if (b == 1 && encodingMode == TEXT_COMPACTION) { + encodeBinary(&byteArr, p, 1, TEXT_COMPACTION, sb); + } else { + encodeBinary(&byteArr, p, b, encodingMode, sb); + encodingMode = BYTE_COMPACTION; + textSubMode = SUBMODE_ALPHA; + } + p += b; + } + } + } + } + return sb; +} + +void CBC_PDF417HighLevelEncoder::Inverse() { + for (size_t l = 0; l < FX_ArraySize(MIXED); ++l) + MIXED[l] = -1; + + for (uint8_t i = 0; i < FX_ArraySize(TEXT_MIXED_RAW); ++i) { + uint8_t b = TEXT_MIXED_RAW[i]; + if (b != 0) + MIXED[b] = i; + } + + for (size_t l = 0; l < FX_ArraySize(PUNCTUATION); ++l) + PUNCTUATION[l] = -1; + + for (uint8_t i = 0; i < FX_ArraySize(TEXT_PUNCTUATION_RAW); ++i) { + uint8_t b = TEXT_PUNCTUATION_RAW[i]; + if (b != 0) + PUNCTUATION[b] = i; + } +} + +int32_t CBC_PDF417HighLevelEncoder::encodeText(CFX_WideString msg, + int32_t startpos, + int32_t count, + CFX_WideString& sb, + int32_t initialSubmode) { + CFX_WideString tmp; + int32_t submode = initialSubmode; + int32_t idx = 0; + while (TRUE) { + FX_WCHAR ch = msg.GetAt(startpos + idx); + switch (submode) { + case SUBMODE_ALPHA: + if (isAlphaUpper(ch)) { + if (ch == ' ') { + tmp += (FX_WCHAR)26; + } else { + tmp += (FX_WCHAR)(ch - 65); + } + } else { + if (isAlphaLower(ch)) { + submode = SUBMODE_LOWER; + tmp += (FX_WCHAR)27; + continue; + } else if (isMixed(ch)) { + submode = SUBMODE_MIXED; + tmp += (FX_WCHAR)28; + continue; + } else { + tmp += (FX_WCHAR)29; + tmp += PUNCTUATION[ch]; + break; + } + } + break; + case SUBMODE_LOWER: + if (isAlphaLower(ch)) { + if (ch == ' ') { + tmp += (FX_WCHAR)26; + } else { + tmp += (FX_WCHAR)(ch - 97); + } + } else { + if (isAlphaUpper(ch)) { + tmp += (FX_WCHAR)27; + tmp += (FX_WCHAR)(ch - 65); + break; + } else if (isMixed(ch)) { + submode = SUBMODE_MIXED; + tmp += (FX_WCHAR)28; + continue; + } else { + tmp += (FX_WCHAR)29; + tmp += PUNCTUATION[ch]; + break; + } + } + break; + case SUBMODE_MIXED: + if (isMixed(ch)) { + tmp += MIXED[ch]; + } else { + if (isAlphaUpper(ch)) { + submode = SUBMODE_ALPHA; + tmp += (FX_WCHAR)28; + continue; + } else if (isAlphaLower(ch)) { + submode = SUBMODE_LOWER; + tmp += (FX_WCHAR)27; + continue; + } else { + if (startpos + idx + 1 < count) { + FX_WCHAR next = msg.GetAt(startpos + idx + 1); + if (isPunctuation(next)) { + submode = SUBMODE_PUNCTUATION; + tmp += (FX_WCHAR)25; + continue; + } + } + tmp += (FX_WCHAR)29; + tmp += PUNCTUATION[ch]; + } + } + break; + default: + if (isPunctuation(ch)) { + tmp += PUNCTUATION[ch]; + } else { + submode = SUBMODE_ALPHA; + tmp += (FX_WCHAR)29; + continue; + } + } + idx++; + if (idx >= count) { + break; + } + } + FX_WCHAR h = 0; + int32_t len = tmp.GetLength(); + for (int32_t i = 0; i < len; i++) { + FX_BOOL odd = (i % 2) != 0; + if (odd) { + h = (FX_WCHAR)((h * 30) + tmp.GetAt(i)); + sb += h; + } else { + h = tmp.GetAt(i); + } + } + if ((len % 2) != 0) { + sb += (FX_WCHAR)((h * 30) + 29); + } + return submode; +} +void CBC_PDF417HighLevelEncoder::encodeBinary(CFX_ByteArray* bytes, + int32_t startpos, + int32_t count, + int32_t startmode, + CFX_WideString& sb) { + if (count == 1 && startmode == TEXT_COMPACTION) { + sb += (FX_WCHAR)SHIFT_TO_BYTE; + } + int32_t idx = startpos; + int32_t i = 0; + if (count >= 6) { + sb += (FX_WCHAR)LATCH_TO_BYTE; + FX_WCHAR chars[5]; + while ((startpos + count - idx) >= 6) { + int64_t t = 0; + for (i = 0; i < 6; i++) { + t <<= 8; + t += bytes->GetAt(idx + i) & 0xff; + } + for (i = 0; i < 5; i++) { + chars[i] = (FX_WCHAR)(t % 900); + t /= 900; + } + for (i = 4; i >= 0; i--) { + sb += (chars[i]); + } + idx += 6; + } + } + if (idx < startpos + count) { + sb += (FX_WCHAR)LATCH_TO_BYTE_PADDED; + } + for (i = idx; i < startpos + count; i++) { + int32_t ch = bytes->GetAt(i) & 0xff; + sb += (FX_WCHAR)ch; + } +} +void CBC_PDF417HighLevelEncoder::encodeNumeric(CFX_WideString msg, + int32_t startpos, + int32_t count, + CFX_WideString& sb) { + int32_t idx = 0; + BigInteger num900 = 900; + while (idx < count) { + CFX_WideString tmp; + int32_t len = 44 < count - idx ? 44 : count - idx; + CFX_ByteString part = + ((FX_WCHAR)'1' + msg.Mid(startpos + idx, len)).UTF8Encode(); + BigInteger bigint = stringToBigInteger(part.c_str()); + do { + int32_t c = (bigint % num900).toInt(); + tmp += (FX_WCHAR)(c); + bigint = bigint / num900; + } while (!bigint.isZero()); + for (int32_t i = tmp.GetLength() - 1; i >= 0; i--) { + sb += tmp.GetAt(i); + } + idx += len; + } +} +FX_BOOL CBC_PDF417HighLevelEncoder::isDigit(FX_WCHAR ch) { + return ch >= '0' && ch <= '9'; +} +FX_BOOL CBC_PDF417HighLevelEncoder::isAlphaUpper(FX_WCHAR ch) { + return ch == ' ' || (ch >= 'A' && ch <= 'Z'); +} +FX_BOOL CBC_PDF417HighLevelEncoder::isAlphaLower(FX_WCHAR ch) { + return ch == ' ' || (ch >= 'a' && ch <= 'z'); +} +FX_BOOL CBC_PDF417HighLevelEncoder::isMixed(FX_WCHAR ch) { + return MIXED[ch] != -1; +} +FX_BOOL CBC_PDF417HighLevelEncoder::isPunctuation(FX_WCHAR ch) { + return PUNCTUATION[ch] != -1; +} +FX_BOOL CBC_PDF417HighLevelEncoder::isText(FX_WCHAR ch) { + return ch == '\t' || ch == '\n' || ch == '\r' || (ch >= 32 && ch <= 126); +} +int32_t CBC_PDF417HighLevelEncoder::determineConsecutiveDigitCount( + CFX_WideString msg, + int32_t startpos) { + int32_t count = 0; + int32_t len = msg.GetLength(); + int32_t idx = startpos; + if (idx < len) { + FX_WCHAR ch = msg.GetAt(idx); + while (isDigit(ch) && idx < len) { + count++; + idx++; + if (idx < len) { + ch = msg.GetAt(idx); + } + } + } + return count; +} +int32_t CBC_PDF417HighLevelEncoder::determineConsecutiveTextCount( + CFX_WideString msg, + int32_t startpos) { + int32_t len = msg.GetLength(); + int32_t idx = startpos; + while (idx < len) { + FX_WCHAR ch = msg.GetAt(idx); + int32_t numericCount = 0; + while (numericCount < 13 && isDigit(ch) && idx < len) { + numericCount++; + idx++; + if (idx < len) { + ch = msg.GetAt(idx); + } + } + if (numericCount >= 13) { + return idx - startpos - numericCount; + } + if (numericCount > 0) { + continue; + } + ch = msg.GetAt(idx); + if (!isText(ch)) { + break; + } + idx++; + } + return idx - startpos; +} +int32_t CBC_PDF417HighLevelEncoder::determineConsecutiveBinaryCount( + CFX_WideString msg, + CFX_ByteArray* bytes, + int32_t startpos, + int32_t& e) { + int32_t len = msg.GetLength(); + int32_t idx = startpos; + while (idx < len) { + FX_WCHAR ch = msg.GetAt(idx); + int32_t numericCount = 0; + while (numericCount < 13 && isDigit(ch)) { + numericCount++; + int32_t i = idx + numericCount; + if (i >= len) { + break; + } + ch = msg.GetAt(i); + } + if (numericCount >= 13) { + return idx - startpos; + } + int32_t textCount = 0; + while (textCount < 5 && isText(ch)) { + textCount++; + int32_t i = idx + textCount; + if (i >= len) { + break; + } + ch = msg.GetAt(i); + } + if (textCount >= 5) { + return idx - startpos; + } + ch = msg.GetAt(idx); + if (bytes->GetAt(idx) == 63 && ch != '?') { + e = BCExceptionNonEncodableCharacterDetected; + return -1; + } + idx++; + } + return idx - startpos; +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417HighLevelEncoder.h b/xfa/fxbarcode/pdf417/BC_PDF417HighLevelEncoder.h new file mode 100644 index 0000000000..0ba01265f9 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417HighLevelEncoder.h @@ -0,0 +1,74 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417HIGHLEVELENCODER_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417HIGHLEVELENCODER_H_ + +#include "core/include/fxcrt/fx_basic.h" +#include "core/include/fxcrt/fx_string.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417Compaction.h" + +class CBC_PDF417HighLevelEncoder { + public: + static CFX_WideString encodeHighLevel(CFX_WideString msg, + Compaction compaction, + int32_t& e); + static void Inverse(); + static void Initialize(); + static void Finalize(); + + private: + static int32_t TEXT_COMPACTION; + static int32_t BYTE_COMPACTION; + static int32_t NUMERIC_COMPACTION; + static int32_t SUBMODE_PUNCTUATION; + static int32_t LATCH_TO_TEXT; + static int32_t LATCH_TO_BYTE_PADDED; + static int32_t LATCH_TO_NUMERIC; + static int32_t SHIFT_TO_BYTE; + static int32_t LATCH_TO_BYTE; + static uint8_t TEXT_MIXED_RAW[]; + static uint8_t TEXT_PUNCTUATION_RAW[]; + static int32_t MIXED[128]; + static int32_t PUNCTUATION[128]; + static int32_t encodeText(CFX_WideString msg, + int32_t startpos, + int32_t count, + CFX_WideString& sb, + int32_t initialSubmode); + static void encodeBinary(CFX_ByteArray* bytes, + int32_t startpos, + int32_t count, + int32_t startmode, + CFX_WideString& sb); + static void encodeNumeric(CFX_WideString msg, + int32_t startpos, + int32_t count, + CFX_WideString& sb); + static FX_BOOL isDigit(FX_WCHAR ch); + static FX_BOOL isAlphaUpper(FX_WCHAR ch); + static FX_BOOL isAlphaLower(FX_WCHAR ch); + static FX_BOOL isMixed(FX_WCHAR ch); + static FX_BOOL isPunctuation(FX_WCHAR ch); + static FX_BOOL isText(FX_WCHAR ch); + static int32_t determineConsecutiveDigitCount(CFX_WideString msg, + int32_t startpos); + static int32_t determineConsecutiveTextCount(CFX_WideString msg, + int32_t startpos); + static int32_t determineConsecutiveBinaryCount(CFX_WideString msg, + CFX_ByteArray* bytes, + int32_t startpos, + int32_t& e); + + friend class PDF417HighLevelEncoder_EncodeNumeric_Test; + friend class PDF417HighLevelEncoder_EncodeBinary_Test; + friend class PDF417HighLevelEncoder_EncodeText_Test; + friend class PDF417HighLevelEncoder_ConsecutiveDigitCount_Test; + friend class PDF417HighLevelEncoder_ConsecutiveTextCount_Test; + friend class PDF417HighLevelEncoder_ConsecutiveBinaryCount_Test; +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417HIGHLEVELENCODER_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417HighLevelEncoder_unittest.cpp b/xfa/fxbarcode/pdf417/BC_PDF417HighLevelEncoder_unittest.cpp new file mode 100644 index 0000000000..8e1837071d --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417HighLevelEncoder_unittest.cpp @@ -0,0 +1,231 @@ +// 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. + +#include "core/include/fxcrt/fx_basic.h" +#include "testing/fx_string_testhelpers.h" +#include "testing/gtest/include/gtest/gtest.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417HighLevelEncoder.h" + +TEST(PDF417HighLevelEncoder, EncodeHighLevel) { + // TODO(tsepez): implement test cases. +} + +TEST(PDF417HighLevelEncoder, EncodeText) { + // TODO(tsepez): implement test cases. +} + +TEST(PDF417HighLevelEncoder, EncodeBinary) { + struct EncodeBinaryCase { + const char* input; + int offset; + int count; + int startmode; + const wchar_t* expected; + int expected_length; + } encode_binary_cases[] = { + // Empty string encodes as empty string. + {"", 0, 0, CBC_PDF417HighLevelEncoder::TEXT_COMPACTION, L"", 0}, + + // Fewer than 6 characters encodes as prefix without compaction. + {"xxxxx", 0, 5, CBC_PDF417HighLevelEncoder::TEXT_COMPACTION, + L"\x0385xxxxx", 6}, + + // 6 charcters triggerst text encoding compaction. + {"xxxxxx", 0, 6, CBC_PDF417HighLevelEncoder::TEXT_COMPACTION, + L"\u039c\u00c9\u031f\u012a\u00d2\u02d0", 6}, + + // Same result if initially in numeric compaction mode. + {"xxxxxx", 0, 6, CBC_PDF417HighLevelEncoder::NUMERIC_COMPACTION, + L"\u039c\u00c9\u031f\u012a\u00d2\u02d0", 6}, + }; + + CBC_PDF417HighLevelEncoder::Initialize(); + for (size_t i = 0; i < FX_ArraySize(encode_binary_cases); ++i) { + EncodeBinaryCase* ptr = &encode_binary_cases[i]; + CFX_ByteArray input_array; + size_t input_length = strlen(ptr->input); + input_array.SetSize(input_length); + for (size_t j = 0; j < input_length; ++j) { + input_array.SetAt(j, ptr->input[j]); + } + CFX_WideString expected(ptr->expected, ptr->expected_length); + CFX_WideString result; + CBC_PDF417HighLevelEncoder::encodeBinary( + &input_array, ptr->offset, ptr->count, ptr->startmode, result); + EXPECT_EQ(expected, result) << " for case number " << i; + } + CBC_PDF417HighLevelEncoder::Finalize(); +} + +TEST(PDF417HighLevelEncoder, EncodeNumeric) { + struct EncodeNumericCase { + const wchar_t* input; + int offset; + int count; + const wchar_t* expected; + int expected_length; + } encode_numeric_cases[] = { + // Empty string encodes as empty string. + {L"", 0, 0, L"", 0}, + + // Single 0 should encode as 10 base-900 == a. + {L"0", 0, 1, L"\x000a", 1}, + + // 800 should encode as 1800 base-900 == 2,0. + {L"800", 0, 3, L"\x0002\x0000", 2}, + + // Test longer strings and sub-strings. + {L"123456", 0, 6, L"\x0001\x015c\x0100", 3}, + {L"123456", 0, 5, L"\x007c\x02e9", 2}, + {L"123456", 1, 5, L"\x0089\x009c", 2}, + {L"123456", 2, 2, L"\x0086", 1}, + + // Up to 44 characters encodes as 15 base-900 words. + {L"00000000000000000000000000000000000000000000", 0, 44, + L"\x01b5\x006f\x02cc\x0084\x01bc\x0076\x00b3\x005c\x01f0\x034f\x01e6" + L"\x0090\x020b\x019b\x0064", + 15}, + + // 45 characters should encode as same 15 words followed by one additional + // word. + {L"000000000000000000000000000000000000000000000", 0, 45, + L"\x01b5\x006f\x02cc\x0084\x01bc\x0076\x00b3\x005c\x01f0\x034f\x01e6" + L"\x0090\x020b\x019b\x0064\x000a", + 16}, + + // 44 characters followed by 800 should encode as 15 words followed by + // 1800 base-900 == 2,0. + {L"00000000000000000000000000000000000000000000800", 0, 47, + L"\x01b5\x006f\x02cc\x0084\x01bc\x0076\x00b3\x005c\x01f0\x034f\x01e6" + L"\x0090\x020b\x019b\x0064\x0002\x0000", + 17}, + + // Even longer input. + {L"10000000000000000000000000000000000000000000000000", 0, 50, + L"\x01e0\x02f0\x036d\x02ad\x029c\x01ea\x0011\x000b\x02d6\x023c\x0108" + L"\x02bb\x0023\x02d2\x00c8\x0001\x00d3\x0064", + 18}, + }; + + CBC_PDF417HighLevelEncoder::Initialize(); + for (size_t i = 0; i < FX_ArraySize(encode_numeric_cases); ++i) { + EncodeNumericCase* ptr = &encode_numeric_cases[i]; + CFX_WideString input(ptr->input); + CFX_WideString expected(ptr->expected, ptr->expected_length); + CFX_WideString result; + CBC_PDF417HighLevelEncoder::encodeNumeric(input, ptr->offset, ptr->count, + result); + EXPECT_EQ(expected, result) << " for case number " << i; + } + CBC_PDF417HighLevelEncoder::Finalize(); +} + +TEST(PDF417HighLevelEncoder, ConsecutiveDigitCount) { + struct ConsecutiveDigitCase { + const wchar_t* input; + int offset; + int expected_count; + } consecutive_digit_cases[] = { + // Empty string contains 0 consecuitve digits. + {L"", 0, 0}, + + // Single non-digit character contains 0 consecutive digits. + {L"X", 0, 0}, + + // Leading non-digit followed by digits contains 0 consecutive. + {L"X123", 0, 0}, + + // Single digit contains 1 consecutive digit. + {L"1", 0, 1}, + + // Single digit followe by non-digit contains 1 consecutive digit. + {L"1Z", 0, 1}, + + // Test longer strings. + {L"123FOO45678", 0, 3}, + + // Test subtring starting in digits field. + {L"123FOO45678", 3, 0}, + + // Test subtring starting in non-digits field. + {L"123FOO45678", 3, 0}, + + // Test substring starting in digits field following non-digit field. + {L"123FOO45678", 6, 5}, + }; + + CBC_PDF417HighLevelEncoder::Initialize(); + for (size_t i = 0; i < FX_ArraySize(consecutive_digit_cases); ++i) { + ConsecutiveDigitCase* ptr = &consecutive_digit_cases[i]; + CFX_WideString input(ptr->input); + int actual_count = + CBC_PDF417HighLevelEncoder::determineConsecutiveDigitCount(input, + ptr->offset); + EXPECT_EQ(ptr->expected_count, actual_count) << " for case number " << i; + } + CBC_PDF417HighLevelEncoder::Finalize(); +} + +TEST(PDF417HighLevelEncoder, ConsecutiveTextCount) { + struct ConsecutiveTextCase { + const wchar_t* input; + int offset; + int expected_count; + } consecutive_text_cases[] = { + // Empty string contains 0 consecutive text characters. + {L"", 0, 0}, + + // Single text character is 1 consecutive text characters. + {L"X", 0, 1}, + + // Trailing numbers count as text characters. + {L"X123", 0, 4}, + + // Leading numbers count as text characters. + {L"123X", 0, 4}, + + // Embedded lo-value binary characters terminate text runs. + {L"ABC\x0001XXXX", 0, 3}, + + // Embedded hi-value binary characters terminate text runs. + {L"ABC\x0100XXXX", 0, 3}, + + // Text run still found after indexing past lo-value character. + {L"ABC\x0001XXXX", 4, 4}, + + // Text run still found after indexing past hi-value character. + {L"ABC\x0100XXXX", 4, 4}, + + // Leading hi-value character results in 0 consecutive characters. + {L"\x0100XXX", 0, 0}, + + // Up to 12 numbers count as text. + {L"123456789012", 0, 12}, + + // 13 or more numbers are compresssed using numeric compression, not text. + {L"1234567890123", 0, 0}, + + // Leading Text character doesn't affect the 12 character case. + {L"X123456789012", 0, 13}, + + // Leading Text character doesn't affect the 13 character case. + {L"X1234567890123", 0, 1}, + + // Jumping between numbers and letters works properly. + {L"XXX121XXX12345678901234", 0, 9}, + }; + + CBC_PDF417HighLevelEncoder::Initialize(); + for (size_t i = 0; i < FX_ArraySize(consecutive_text_cases); ++i) { + ConsecutiveTextCase* ptr = &consecutive_text_cases[i]; + CFX_WideString input(ptr->input); + int actual_count = + CBC_PDF417HighLevelEncoder::determineConsecutiveTextCount(input, + ptr->offset); + EXPECT_EQ(ptr->expected_count, actual_count) << " for case number " << i; + } + CBC_PDF417HighLevelEncoder::Finalize(); +} + +TEST(PDF417HighLevelEncoder, ConsecutiveBinaryCount) {} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417Reader.cpp b/xfa/fxbarcode/pdf417/BC_PDF417Reader.cpp new file mode 100644 index 0000000000..4d953e006a --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417Reader.cpp @@ -0,0 +1,149 @@ +// 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 + +#include "xfa/fxbarcode/BC_BinaryBitmap.h" +#include "xfa/fxbarcode/BC_BinaryBitmap.h" +#include "xfa/fxbarcode/BC_DecoderResult.h" +#include "xfa/fxbarcode/BC_Reader.h" +#include "xfa/fxbarcode/BC_ResultPoint.h" +#include "xfa/fxbarcode/common/BC_CommonBitArray.h" +#include "xfa/fxbarcode/common/BC_CommonBitMatrix.h" +#include "xfa/fxbarcode/common/BC_CommonBitMatrix.h" +#include "xfa/fxbarcode/common/BC_CommonDecoderResult.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417BarcodeMetadata.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417BarcodeValue.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417BoundingBox.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417Codeword.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417CodewordDecoder.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417Common.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417DetectionResult.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417DetectionResultColumn.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417DetectionResultRowIndicatorColumn.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417Detector.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417DetectorResult.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417DetectorResult.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/pdf417/BC_PDF417Reader.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417ScanningDecoder.h" +#include "xfa/fxbarcode/utils.h" + +CBC_PDF417Reader::CBC_PDF417Reader() {} +CBC_PDF417Reader::~CBC_PDF417Reader() {} + +CFX_ByteString CBC_PDF417Reader::Decode(CBC_BinaryBitmap* image, int32_t& e) { + return Decode(image, 0, e); +} +CFX_ByteString CBC_PDF417Reader::Decode(CBC_BinaryBitmap* image, + FX_BOOL multiple, + int32_t hints, + int32_t& e) { + CFX_ByteString results; + CBC_PDF417DetectorResult* detectorResult = + CBC_Detector::detect(image, hints, multiple, e); + BC_EXCEPTION_CHECK_ReturnValue(e, ""); + for (int32_t i = 0; i < detectorResult->getPoints()->GetSize(); i++) { + CFX_PtrArray* points = (CFX_PtrArray*)detectorResult->getPoints()->GetAt(i); + CBC_CommonDecoderResult* ResultTemp = CBC_PDF417ScanningDecoder::decode( + detectorResult->getBits(), (CBC_ResultPoint*)points->GetAt(4), + (CBC_ResultPoint*)points->GetAt(5), (CBC_ResultPoint*)points->GetAt(6), + (CBC_ResultPoint*)points->GetAt(7), getMinCodewordWidth(*points), + getMaxCodewordWidth(*points), e); + if (ResultTemp == NULL) { + delete detectorResult; + e = BCExceptiontNotFoundInstance; + return ""; + } + results += ResultTemp->GetText(); + delete ResultTemp; + } + delete detectorResult; + return results; +} +CFX_ByteString CBC_PDF417Reader::Decode(CBC_BinaryBitmap* image, + int32_t hints, + int32_t& e) { + CFX_ByteString bs = Decode(image, FALSE, 0, e); + BC_EXCEPTION_CHECK_ReturnValue(e, ""); + return bs; +} +int32_t CBC_PDF417Reader::getMaxWidth(CBC_ResultPoint* p1, + CBC_ResultPoint* p2) { + if (p1 == NULL || p2 == NULL) { + return 0; + } + return (int32_t)FXSYS_fabs(p1->GetX() - p2->GetX()); +} +int32_t CBC_PDF417Reader::getMinWidth(CBC_ResultPoint* p1, + CBC_ResultPoint* p2) { + if (!p1 || !p2) + return std::numeric_limits::max(); + return (int32_t)FXSYS_fabs(p1->GetX() - p2->GetX()); +} +int32_t CBC_PDF417Reader::getMaxCodewordWidth(CFX_PtrArray& p) { + int32_t a = + getMaxWidth((CBC_ResultPoint*)p.GetAt(6), (CBC_ResultPoint*)p.GetAt(2)) * + CBC_PDF417Common::MODULES_IN_CODEWORD / + CBC_PDF417Common::MODULES_IN_STOP_PATTERN; + int32_t b = + getMaxWidth((CBC_ResultPoint*)p.GetAt(7), (CBC_ResultPoint*)p.GetAt(3)) * + CBC_PDF417Common::MODULES_IN_CODEWORD / + CBC_PDF417Common::MODULES_IN_STOP_PATTERN; + int32_t c = getMaxWidth((CBC_ResultPoint*)p.GetAt(0), + (CBC_ResultPoint*)p.GetAt(4)) < a + ? getMaxWidth((CBC_ResultPoint*)p.GetAt(0), + (CBC_ResultPoint*)p.GetAt(4)) + : a; + int32_t d = getMaxWidth((CBC_ResultPoint*)p.GetAt(1), + (CBC_ResultPoint*)p.GetAt(5)) < b + ? getMaxWidth((CBC_ResultPoint*)p.GetAt(1), + (CBC_ResultPoint*)p.GetAt(5)) + : b; + return c < d ? c : d; +} +int32_t CBC_PDF417Reader::getMinCodewordWidth(CFX_PtrArray& p) { + int32_t a = + getMinWidth((CBC_ResultPoint*)p.GetAt(6), (CBC_ResultPoint*)p.GetAt(2)) * + CBC_PDF417Common::MODULES_IN_CODEWORD / + CBC_PDF417Common::MODULES_IN_STOP_PATTERN; + int32_t b = + getMinWidth((CBC_ResultPoint*)p.GetAt(7), (CBC_ResultPoint*)p.GetAt(3)) * + CBC_PDF417Common::MODULES_IN_CODEWORD / + CBC_PDF417Common::MODULES_IN_STOP_PATTERN; + int32_t c = getMinWidth((CBC_ResultPoint*)p.GetAt(0), + (CBC_ResultPoint*)p.GetAt(4)) < a + ? getMinWidth((CBC_ResultPoint*)p.GetAt(0), + (CBC_ResultPoint*)p.GetAt(4)) + : a; + int32_t d = getMinWidth((CBC_ResultPoint*)p.GetAt(1), + (CBC_ResultPoint*)p.GetAt(5)) < b + ? getMinWidth((CBC_ResultPoint*)p.GetAt(1), + (CBC_ResultPoint*)p.GetAt(5)) + : b; + return c < d ? c : d; +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417Reader.h b/xfa/fxbarcode/pdf417/BC_PDF417Reader.h new file mode 100644 index 0000000000..2a5c39bae2 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417Reader.h @@ -0,0 +1,31 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417READER_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417READER_H_ + +class CBC_BinaryBitmap; +class CBC_ResultPoint; +class CBC_PDF417Reader; +class CBC_PDF417Reader : public CBC_Reader { + public: + CBC_PDF417Reader(); + virtual ~CBC_PDF417Reader(); + CFX_ByteString Decode(CBC_BinaryBitmap* image, int32_t& e); + CFX_ByteString Decode(CBC_BinaryBitmap* image, + FX_BOOL multiple, + int32_t hints, + int32_t& e); + CFX_ByteString Decode(CBC_BinaryBitmap* image, int32_t hints, int32_t& e); + + private: + static int32_t getMaxWidth(CBC_ResultPoint* p1, CBC_ResultPoint* p2); + static int32_t getMinWidth(CBC_ResultPoint* p1, CBC_ResultPoint* p2); + static int32_t getMaxCodewordWidth(CFX_PtrArray& p); + static int32_t getMinCodewordWidth(CFX_PtrArray& p); +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417READER_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417ResultMetadata.cpp b/xfa/fxbarcode/pdf417/BC_PDF417ResultMetadata.cpp new file mode 100644 index 0000000000..083d63e2d2 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417ResultMetadata.cpp @@ -0,0 +1,50 @@ +// 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 2013 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_PDF417ResultMetadata.h" + +CBC_PDF417ResultMetadata::CBC_PDF417ResultMetadata() {} +CBC_PDF417ResultMetadata::~CBC_PDF417ResultMetadata() {} +int32_t CBC_PDF417ResultMetadata::getSegmentIndex() { + return m_segmentIndex; +} +void CBC_PDF417ResultMetadata::setSegmentIndex(int32_t segmentIndex) { + m_segmentIndex = segmentIndex; +} +CFX_ByteString CBC_PDF417ResultMetadata::getFileId() { + return m_fileId; +} +void CBC_PDF417ResultMetadata::setFileId(CFX_ByteString fileId) { + m_fileId = fileId; +} +CFX_Int32Array& CBC_PDF417ResultMetadata::getOptionalData() { + return m_optionalData; +} +void CBC_PDF417ResultMetadata::setOptionalData(CFX_Int32Array& optionalData) { + m_optionalData.Copy(optionalData); +} +FX_BOOL CBC_PDF417ResultMetadata::isLastSegment() { + return m_lastSegment; +} +void CBC_PDF417ResultMetadata::setLastSegment(FX_BOOL lastSegment) { + m_lastSegment = lastSegment; +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417ResultMetadata.h b/xfa/fxbarcode/pdf417/BC_PDF417ResultMetadata.h new file mode 100644 index 0000000000..8e25bdbf43 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417ResultMetadata.h @@ -0,0 +1,32 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417RESULTMETADATA_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417RESULTMETADATA_H_ + +#include "core/include/fxcrt/fx_basic.h" + +class CBC_PDF417ResultMetadata { + public: + CBC_PDF417ResultMetadata(); + virtual ~CBC_PDF417ResultMetadata(); + int32_t getSegmentIndex(); + void setSegmentIndex(int32_t segmentIndex); + CFX_ByteString getFileId(); + void setFileId(CFX_ByteString fileId); + CFX_Int32Array& getOptionalData(); + void setOptionalData(CFX_Int32Array& optionalData); + FX_BOOL isLastSegment(); + void setLastSegment(FX_BOOL lastSegment); + + private: + int32_t m_segmentIndex; + CFX_ByteString m_fileId; + CFX_Int32Array m_optionalData; + FX_BOOL m_lastSegment; +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417RESULTMETADATA_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417ScanningDecoder.cpp b/xfa/fxbarcode/pdf417/BC_PDF417ScanningDecoder.cpp new file mode 100644 index 0000000000..6ae68d72f3 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417ScanningDecoder.cpp @@ -0,0 +1,752 @@ +// 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 2013 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/BC_DecoderResult.h" +#include "xfa/fxbarcode/BC_ResultPoint.h" +#include "xfa/fxbarcode/common/BC_CommonBitMatrix.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417BarcodeMetadata.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417BarcodeValue.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417BoundingBox.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417Codeword.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417CodewordDecoder.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417Common.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417DetectionResult.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417DetectionResultColumn.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417DetectionResultRowIndicatorColumn.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/pdf417/BC_PDF417ScanningDecoder.h" +#include "xfa/fxbarcode/utils.h" + +int32_t CBC_PDF417ScanningDecoder::CODEWORD_SKEW_SIZE = 2; +int32_t CBC_PDF417ScanningDecoder::MAX_ERRORS = 3; +int32_t CBC_PDF417ScanningDecoder::MAX_EC_CODEWORDS = 512; +CBC_PDF417ECErrorCorrection* CBC_PDF417ScanningDecoder::errorCorrection = NULL; + +CBC_PDF417ScanningDecoder::CBC_PDF417ScanningDecoder() {} +CBC_PDF417ScanningDecoder::~CBC_PDF417ScanningDecoder() {} +void CBC_PDF417ScanningDecoder::Initialize() { + errorCorrection = new CBC_PDF417ECErrorCorrection; +} +void CBC_PDF417ScanningDecoder::Finalize() { + delete errorCorrection; +} +CBC_CommonDecoderResult* CBC_PDF417ScanningDecoder::decode( + CBC_CommonBitMatrix* image, + CBC_ResultPoint* imageTopLeft, + CBC_ResultPoint* imageBottomLeft, + CBC_ResultPoint* imageTopRight, + CBC_ResultPoint* imageBottomRight, + int32_t minCodewordWidth, + int32_t maxCodewordWidth, + int32_t& e) { + CBC_BoundingBox* boundingBox = new CBC_BoundingBox( + image, imageTopLeft, imageBottomLeft, imageTopRight, imageBottomRight, e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + CBC_DetectionResultRowIndicatorColumn* leftRowIndicatorColumn = NULL; + CBC_DetectionResultRowIndicatorColumn* rightRowIndicatorColumn = NULL; + CBC_DetectionResult* detectionResult = NULL; + for (int32_t i = 0; i < 2; i++) { + if (imageTopLeft) { + leftRowIndicatorColumn = + getRowIndicatorColumn(image, boundingBox, *imageTopLeft, TRUE, + minCodewordWidth, maxCodewordWidth); + } + if (imageTopRight) { + rightRowIndicatorColumn = + getRowIndicatorColumn(image, boundingBox, *imageTopRight, FALSE, + minCodewordWidth, maxCodewordWidth); + } + detectionResult = merge(leftRowIndicatorColumn, rightRowIndicatorColumn, e); + if (e != BCExceptionNO) { + e = BCExceptiontNotFoundInstance; + delete leftRowIndicatorColumn; + delete rightRowIndicatorColumn; + delete boundingBox; + return NULL; + } + if (i == 0 && (detectionResult->getBoundingBox()->getMinY() < + boundingBox->getMinY() || + detectionResult->getBoundingBox()->getMaxY() > + boundingBox->getMaxY())) { + delete boundingBox; + boundingBox = detectionResult->getBoundingBox(); + } else { + detectionResult->setBoundingBox(boundingBox); + break; + } + } + int32_t maxBarcodeColumn = detectionResult->getBarcodeColumnCount() + 1; + detectionResult->setDetectionResultColumn(0, leftRowIndicatorColumn); + detectionResult->setDetectionResultColumn(maxBarcodeColumn, + rightRowIndicatorColumn); + FX_BOOL leftToRight = leftRowIndicatorColumn != NULL; + for (int32_t barcodeColumnCount = 1; barcodeColumnCount <= maxBarcodeColumn; + barcodeColumnCount++) { + int32_t barcodeColumn = leftToRight ? barcodeColumnCount + : maxBarcodeColumn - barcodeColumnCount; + if (detectionResult->getDetectionResultColumn(barcodeColumn)) { + continue; + } + CBC_DetectionResultColumn* detectionResultColumn = NULL; + if (barcodeColumn == 0 || barcodeColumn == maxBarcodeColumn) { + detectionResultColumn = new CBC_DetectionResultRowIndicatorColumn( + boundingBox, barcodeColumn == 0); + } else { + detectionResultColumn = new CBC_DetectionResultColumn(boundingBox); + } + detectionResult->setDetectionResultColumn(barcodeColumn, + detectionResultColumn); + int32_t startColumn = -1; + int32_t previousStartColumn = startColumn; + for (int32_t imageRow = boundingBox->getMinY(); + imageRow <= boundingBox->getMaxY(); imageRow++) { + startColumn = + getStartColumn(detectionResult, barcodeColumn, imageRow, leftToRight); + if (startColumn < 0 || startColumn > boundingBox->getMaxX()) { + if (previousStartColumn == -1) { + continue; + } + startColumn = previousStartColumn; + } + CBC_Codeword* codeword = detectCodeword( + image, boundingBox->getMinX(), boundingBox->getMaxX(), leftToRight, + startColumn, imageRow, minCodewordWidth, maxCodewordWidth); + if (codeword) { + detectionResultColumn->setCodeword(imageRow, codeword); + previousStartColumn = startColumn; + minCodewordWidth = minCodewordWidth < codeword->getWidth() + ? minCodewordWidth + : codeword->getWidth(); + maxCodewordWidth = maxCodewordWidth > codeword->getWidth() + ? maxCodewordWidth + : codeword->getWidth(); + } + } + } + CBC_CommonDecoderResult* decoderresult = + createDecoderResult(detectionResult, e); + if (e != BCExceptionNO) { + delete detectionResult; + return NULL; + } + return decoderresult; +} +CFX_ByteString CBC_PDF417ScanningDecoder::toString( + CFX_PtrArray* barcodeMatrix) { + CFX_ByteString result; + for (int32_t row = 0; row < barcodeMatrix->GetSize(); row++) { + result += row; + int32_t l = 0; + for (; l < ((CFX_PtrArray*)barcodeMatrix->GetAt(row))->GetSize(); l++) { + CBC_BarcodeValue* barcodeValue = + (CBC_BarcodeValue*)((CFX_PtrArray*)barcodeMatrix->GetAt(row)) + ->GetAt(l); + if (barcodeValue->getValue()->GetSize() == 0) { + result += ""; + } else { + result += barcodeValue->getValue()->GetAt(0); + result += + barcodeValue->getConfidence(barcodeValue->getValue()->GetAt(0)); + } + } + } + return result; +} +CBC_DetectionResult* CBC_PDF417ScanningDecoder::merge( + CBC_DetectionResultRowIndicatorColumn* leftRowIndicatorColumn, + CBC_DetectionResultRowIndicatorColumn* rightRowIndicatorColumn, + int32_t& e) { + if (leftRowIndicatorColumn == NULL && rightRowIndicatorColumn == NULL) { + e = BCExceptionIllegalArgument; + return NULL; + } + CBC_BarcodeMetadata* barcodeMetadata = + getBarcodeMetadata(leftRowIndicatorColumn, rightRowIndicatorColumn); + if (barcodeMetadata == NULL) { + e = BCExceptionCannotMetadata; + return NULL; + } + CBC_BoundingBox* leftboundingBox = + adjustBoundingBox(leftRowIndicatorColumn, e); + if (e != BCExceptionNO) { + delete barcodeMetadata; + return NULL; + } + CBC_BoundingBox* rightboundingBox = + adjustBoundingBox(rightRowIndicatorColumn, e); + if (e != BCExceptionNO) { + delete barcodeMetadata; + return NULL; + } + CBC_BoundingBox* boundingBox = + CBC_BoundingBox::merge(leftboundingBox, rightboundingBox, e); + if (e != BCExceptionNO) { + delete barcodeMetadata; + return NULL; + } + CBC_DetectionResult* detectionresult = + new CBC_DetectionResult(barcodeMetadata, boundingBox); + return detectionresult; +} +CBC_BoundingBox* CBC_PDF417ScanningDecoder::adjustBoundingBox( + CBC_DetectionResultRowIndicatorColumn* rowIndicatorColumn, + int32_t& e) { + if (rowIndicatorColumn == NULL) { + return NULL; + } + CFX_Int32Array* rowHeights = rowIndicatorColumn->getRowHeights(e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + int32_t maxRowHeight = getMax(*rowHeights); + int32_t missingStartRows = 0; + for (int32_t i = 0; i < rowHeights->GetSize(); i++) { + int32_t rowHeight = rowHeights->GetAt(i); + missingStartRows += maxRowHeight - rowHeight; + if (rowHeight > 0) { + break; + } + } + CFX_PtrArray* codewords = rowIndicatorColumn->getCodewords(); + for (int32_t row = 0; missingStartRows > 0 && codewords->GetAt(row) == NULL; + row++) { + missingStartRows--; + } + int32_t missingEndRows = 0; + for (int32_t row1 = rowHeights->GetSize() - 1; row1 >= 0; row1--) { + missingEndRows += maxRowHeight - rowHeights->GetAt(row1); + if (rowHeights->GetAt(row1) > 0) { + break; + } + } + for (int32_t row2 = codewords->GetSize() - 1; + missingEndRows > 0 && codewords->GetAt(row2) == NULL; row2--) { + missingEndRows--; + } + CBC_BoundingBox* boundingBox = + rowIndicatorColumn->getBoundingBox()->addMissingRows( + missingStartRows, missingEndRows, rowIndicatorColumn->isLeft(), e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + return boundingBox; +} +int32_t CBC_PDF417ScanningDecoder::getMax(CFX_Int32Array& values) { + int32_t maxValue = -1; + for (int32_t i = 0; i < values.GetSize(); i++) { + int32_t value = values.GetAt(i); + maxValue = maxValue > value ? maxValue : value; + } + return maxValue; +} +CBC_BarcodeMetadata* CBC_PDF417ScanningDecoder::getBarcodeMetadata( + CBC_DetectionResultRowIndicatorColumn* leftRowIndicatorColumn, + CBC_DetectionResultRowIndicatorColumn* rightRowIndicatorColumn) { + CBC_BarcodeMetadata* leftBarcodeMetadata = NULL; + CBC_BarcodeMetadata* rightBarcodeMetadata = NULL; + if (leftRowIndicatorColumn == NULL || + (leftBarcodeMetadata = leftRowIndicatorColumn->getBarcodeMetadata()) == + NULL) { + return rightRowIndicatorColumn == NULL + ? NULL + : rightRowIndicatorColumn->getBarcodeMetadata(); + } + if (rightRowIndicatorColumn == NULL || + (rightBarcodeMetadata = rightRowIndicatorColumn->getBarcodeMetadata()) == + NULL) { + return leftRowIndicatorColumn == NULL + ? NULL + : leftRowIndicatorColumn->getBarcodeMetadata(); + } + if (leftBarcodeMetadata->getColumnCount() != + rightBarcodeMetadata->getColumnCount() && + leftBarcodeMetadata->getErrorCorrectionLevel() != + rightBarcodeMetadata->getErrorCorrectionLevel() && + leftBarcodeMetadata->getRowCount() != + rightBarcodeMetadata->getRowCount()) { + delete leftBarcodeMetadata; + delete rightBarcodeMetadata; + return NULL; + } + delete rightBarcodeMetadata; + return leftBarcodeMetadata; +} +CBC_DetectionResultRowIndicatorColumn* +CBC_PDF417ScanningDecoder::getRowIndicatorColumn(CBC_CommonBitMatrix* image, + CBC_BoundingBox* boundingBox, + CBC_ResultPoint startPoint, + FX_BOOL leftToRight, + int32_t minCodewordWidth, + int32_t maxCodewordWidth) { + CBC_DetectionResultRowIndicatorColumn* rowIndicatorColumn = + new CBC_DetectionResultRowIndicatorColumn(boundingBox, leftToRight); + for (int32_t i = 0; i < 2; i++) { + int32_t increment = i == 0 ? 1 : -1; + int32_t startColumn = (int32_t)startPoint.GetX(); + for (int32_t imageRow = (int32_t)startPoint.GetY(); + imageRow <= boundingBox->getMaxY() && + imageRow >= boundingBox->getMinY(); + imageRow += increment) { + CBC_Codeword* codeword = + detectCodeword(image, 0, image->GetWidth(), leftToRight, startColumn, + imageRow, minCodewordWidth, maxCodewordWidth); + if (codeword) { + rowIndicatorColumn->setCodeword(imageRow, codeword); + if (leftToRight) { + startColumn = codeword->getStartX(); + } else { + startColumn = codeword->getEndX(); + } + } + } + } + return rowIndicatorColumn; +} +void CBC_PDF417ScanningDecoder::adjustCodewordCount( + CBC_DetectionResult* detectionResult, + CFX_PtrArray* barcodeMatrix, + int32_t& e) { + CFX_Int32Array* numberOfCodewords = + ((CBC_BarcodeValue*)((CFX_PtrArray*)barcodeMatrix->GetAt(0))->GetAt(1)) + ->getValue(); + int32_t calculatedNumberOfCodewords = + detectionResult->getBarcodeColumnCount() * + detectionResult->getBarcodeRowCount() - + getNumberOfECCodeWords(detectionResult->getBarcodeECLevel()); + if (numberOfCodewords->GetSize() == 0) { + if (calculatedNumberOfCodewords < 1 || + calculatedNumberOfCodewords > + CBC_PDF417Common::MAX_CODEWORDS_IN_BARCODE) { + e = BCExceptiontNotFoundInstance; + delete numberOfCodewords; + BC_EXCEPTION_CHECK_ReturnVoid(e); + } + ((CBC_BarcodeValue*)((CFX_PtrArray*)barcodeMatrix->GetAt(0))->GetAt(1)) + ->setValue(calculatedNumberOfCodewords); + } else if (numberOfCodewords->GetAt(0) != calculatedNumberOfCodewords) { + ((CBC_BarcodeValue*)((CFX_PtrArray*)barcodeMatrix->GetAt(0))->GetAt(1)) + ->setValue(calculatedNumberOfCodewords); + } + delete numberOfCodewords; +} +CBC_CommonDecoderResult* CBC_PDF417ScanningDecoder::createDecoderResult( + CBC_DetectionResult* detectionResult, + int32_t& e) { + CFX_PtrArray* barcodeMatrix = createBarcodeMatrix(detectionResult); + adjustCodewordCount(detectionResult, barcodeMatrix, e); + if (e != BCExceptionNO) { + for (int32_t i = 0; i < barcodeMatrix->GetSize(); i++) { + CFX_PtrArray* temp = (CFX_PtrArray*)barcodeMatrix->GetAt(i); + for (int32_t j = 0; j < temp->GetSize(); j++) { + delete (CBC_BarcodeValue*)temp->GetAt(j); + } + temp->RemoveAll(); + delete temp; + } + barcodeMatrix->RemoveAll(); + delete barcodeMatrix; + return NULL; + } + CFX_Int32Array erasures; + CFX_Int32Array codewords; + codewords.SetSize(detectionResult->getBarcodeRowCount() * + detectionResult->getBarcodeColumnCount()); + CFX_PtrArray ambiguousIndexValuesList; + CFX_Int32Array ambiguousIndexesList; + for (int32_t row = 0; row < detectionResult->getBarcodeRowCount(); row++) { + for (int32_t l = 0; l < detectionResult->getBarcodeColumnCount(); l++) { + CFX_Int32Array* values = + ((CBC_BarcodeValue*)((CFX_PtrArray*)barcodeMatrix->GetAt(row)) + ->GetAt(l + 1)) + ->getValue(); + int32_t codewordIndex = + row * detectionResult->getBarcodeColumnCount() + l; + if (values->GetSize() == 0) { + erasures.Add(codewordIndex); + } else if (values->GetSize() == 1) { + codewords[codewordIndex] = values->GetAt(0); + } else { + ambiguousIndexesList.Add(codewordIndex); + ambiguousIndexValuesList.Add(values); + } + } + } + CFX_PtrArray ambiguousIndexValues; + ambiguousIndexValues.SetSize(ambiguousIndexValuesList.GetSize()); + for (int32_t i = 0; i < ambiguousIndexValues.GetSize(); i++) { + ambiguousIndexValues.SetAt(i, ambiguousIndexValuesList.GetAt(i)); + } + for (int32_t l = 0; l < barcodeMatrix->GetSize(); l++) { + CFX_PtrArray* temp = (CFX_PtrArray*)barcodeMatrix->GetAt(l); + for (int32_t j = 0; j < temp->GetSize(); j++) { + delete (CBC_BarcodeValue*)temp->GetAt(j); + } + temp->RemoveAll(); + delete temp; + } + barcodeMatrix->RemoveAll(); + delete barcodeMatrix; + CBC_CommonDecoderResult* decoderResult = + createDecoderResultFromAmbiguousValues( + detectionResult->getBarcodeECLevel(), codewords, erasures, + ambiguousIndexesList, ambiguousIndexValues, e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + return decoderResult; +} +CBC_CommonDecoderResult* +CBC_PDF417ScanningDecoder::createDecoderResultFromAmbiguousValues( + int32_t ecLevel, + CFX_Int32Array& codewords, + CFX_Int32Array& erasureArray, + CFX_Int32Array& ambiguousIndexes, + CFX_PtrArray& ambiguousIndexValues, + int32_t& e) { + CFX_Int32Array ambiguousIndexCount; + ambiguousIndexCount.SetSize(ambiguousIndexes.GetSize()); + int32_t tries = 100; + while (tries-- > 0) { + for (int32_t l = 0; l < ambiguousIndexCount.GetSize(); l++) { + codewords[ambiguousIndexes[l]] = + ((CFX_Int32Array*)ambiguousIndexValues.GetAt(l)) + ->GetAt(ambiguousIndexCount[l]); + } + CBC_CommonDecoderResult* decoderResult = + decodeCodewords(codewords, ecLevel, erasureArray, e); + if (e != BCExceptionNO) { + e = BCExceptionNO; + continue; + } else { + return decoderResult; + } + if (ambiguousIndexCount.GetSize() == 0) { + e = BCExceptionChecksumInstance; + return NULL; + } + for (int32_t i = 0; i < ambiguousIndexCount.GetSize(); i++) { + if (ambiguousIndexCount[i] < + ((CFX_Int32Array*)(ambiguousIndexValues.GetAt(i)))->GetSize() - 1) { + ambiguousIndexCount[i]++; + break; + } else { + ambiguousIndexCount[i] = 0; + if (i == ambiguousIndexCount.GetSize() - 1) { + e = BCExceptionChecksumInstance; + return NULL; + } + } + } + } + e = BCExceptionChecksumInstance; + return NULL; +} +CFX_PtrArray* CBC_PDF417ScanningDecoder::createBarcodeMatrix( + CBC_DetectionResult* detectionResult) { + CFX_PtrArray* barcodeMatrix = new CFX_PtrArray; + barcodeMatrix->SetSize(detectionResult->getBarcodeRowCount()); + CFX_PtrArray* temp = NULL; + int32_t colume = 0; + for (int32_t row = 0; row < barcodeMatrix->GetSize(); row++) { + temp = new CFX_PtrArray; + temp->SetSize(detectionResult->getBarcodeColumnCount() + 2); + for (colume = 0; colume < detectionResult->getBarcodeColumnCount() + 2; + colume++) { + temp->SetAt(colume, new CBC_BarcodeValue()); + } + barcodeMatrix->SetAt(row, temp); + } + colume = -1; + for (int32_t i = 0; + i < detectionResult->getDetectionResultColumns().GetSize(); i++) { + CBC_DetectionResultColumn* detectionResultColumn = + (CBC_DetectionResultColumn*)detectionResult->getDetectionResultColumns() + .GetAt(i); + colume++; + if (detectionResultColumn == NULL) { + continue; + } + CFX_PtrArray* temp = detectionResultColumn->getCodewords(); + for (int32_t l = 0; l < temp->GetSize(); l++) { + CBC_Codeword* codeword = (CBC_Codeword*)temp->GetAt(l); + if (codeword == NULL || codeword->getRowNumber() == -1) { + continue; + } + ((CBC_BarcodeValue*)((CFX_PtrArray*)barcodeMatrix->GetAt( + codeword->getRowNumber())) + ->GetAt(colume)) + ->setValue(codeword->getValue()); + } + } + return barcodeMatrix; +} +FX_BOOL CBC_PDF417ScanningDecoder::isValidBarcodeColumn( + CBC_DetectionResult* detectionResult, + int32_t barcodeColumn) { + return barcodeColumn >= 0 && + barcodeColumn <= detectionResult->getBarcodeColumnCount() + 1; +} +int32_t CBC_PDF417ScanningDecoder::getStartColumn( + CBC_DetectionResult* detectionResult, + int32_t barcodeColumn, + int32_t imageRow, + FX_BOOL leftToRight) { + int32_t offset = leftToRight ? 1 : -1; + CBC_Codeword* codeword = NULL; + if (isValidBarcodeColumn(detectionResult, barcodeColumn - offset)) { + codeword = detectionResult->getDetectionResultColumn(barcodeColumn - offset) + ->getCodeword(imageRow); + } + if (codeword) { + return leftToRight ? codeword->getEndX() : codeword->getStartX(); + } + codeword = detectionResult->getDetectionResultColumn(barcodeColumn) + ->getCodewordNearby(imageRow); + if (codeword) { + return leftToRight ? codeword->getStartX() : codeword->getEndX(); + } + if (isValidBarcodeColumn(detectionResult, barcodeColumn - offset)) { + codeword = detectionResult->getDetectionResultColumn(barcodeColumn - offset) + ->getCodewordNearby(imageRow); + } + if (codeword) { + return leftToRight ? codeword->getEndX() : codeword->getStartX(); + } + int32_t skippedColumns = 0; + while (isValidBarcodeColumn(detectionResult, barcodeColumn - offset)) { + barcodeColumn -= offset; + for (int32_t i = 0; + i < detectionResult->getDetectionResultColumn(barcodeColumn) + ->getCodewords() + ->GetSize(); + i++) { + CBC_Codeword* previousRowCodeword = + (CBC_Codeword*)detectionResult->getDetectionResultColumn( + barcodeColumn) + ->getCodewords() + ->GetAt(i); + if (previousRowCodeword) { + return (leftToRight ? previousRowCodeword->getEndX() + : previousRowCodeword->getStartX()) + + offset * skippedColumns * (previousRowCodeword->getEndX() - + previousRowCodeword->getStartX()); + } + } + skippedColumns++; + } + return leftToRight ? detectionResult->getBoundingBox()->getMinX() + : detectionResult->getBoundingBox()->getMaxX(); +} +CBC_Codeword* CBC_PDF417ScanningDecoder::detectCodeword( + CBC_CommonBitMatrix* image, + int32_t minColumn, + int32_t maxColumn, + FX_BOOL leftToRight, + int32_t startColumn, + int32_t imageRow, + int32_t minCodewordWidth, + int32_t maxCodewordWidth) { + startColumn = adjustCodewordStartColumn(image, minColumn, maxColumn, + leftToRight, startColumn, imageRow); + CFX_Int32Array* moduleBitCount = getModuleBitCount( + image, minColumn, maxColumn, leftToRight, startColumn, imageRow); + if (moduleBitCount == NULL) { + return NULL; + } + int32_t endColumn; + int32_t codewordBitCount = CBC_PDF417Common::getBitCountSum(*moduleBitCount); + if (leftToRight) { + endColumn = startColumn + codewordBitCount; + } else { + for (int32_t i = 0; iGetSize()>> 1; i++) { + int32_t tmpCount = moduleBitCount->GetAt(i); + moduleBitCount->SetAt( + i, moduleBitCount->GetAt(moduleBitCount->GetSize() - 1 - i)); + moduleBitCount->SetAt(moduleBitCount->GetSize() - 1 - i, tmpCount); + } + endColumn = startColumn; + startColumn = endColumn - codewordBitCount; + } + int32_t decodedValue = + CBC_PDF417CodewordDecoder::getDecodedValue(*moduleBitCount); + int32_t codeword = CBC_PDF417Common::getCodeword(decodedValue); + delete moduleBitCount; + if (codeword == -1) { + return NULL; + } + return new CBC_Codeword(startColumn, endColumn, + getCodewordBucketNumber(decodedValue), codeword); +} +CFX_Int32Array* CBC_PDF417ScanningDecoder::getModuleBitCount( + CBC_CommonBitMatrix* image, + int32_t minColumn, + int32_t maxColumn, + FX_BOOL leftToRight, + int32_t startColumn, + int32_t imageRow) { + int32_t imageColumn = startColumn; + CFX_Int32Array* moduleBitCount = new CFX_Int32Array; + moduleBitCount->SetSize(8); + int32_t moduleNumber = 0; + int32_t increment = leftToRight ? 1 : -1; + FX_BOOL previousPixelValue = leftToRight; + while (((leftToRight && imageColumn < maxColumn) || + (!leftToRight && imageColumn >= minColumn)) && + moduleNumber < moduleBitCount->GetSize()) { + if (image->Get(imageColumn, imageRow) == previousPixelValue) { + moduleBitCount->SetAt(moduleNumber, + moduleBitCount->GetAt(moduleNumber) + 1); + imageColumn += increment; + } else { + moduleNumber++; + previousPixelValue = !previousPixelValue; + } + } + if (moduleNumber == moduleBitCount->GetSize() || + (((leftToRight && imageColumn == maxColumn) || + (!leftToRight && imageColumn == minColumn)) && + moduleNumber == moduleBitCount->GetSize() - 1)) { + return moduleBitCount; + } + delete moduleBitCount; + return NULL; +} +int32_t CBC_PDF417ScanningDecoder::getNumberOfECCodeWords( + int32_t barcodeECLevel) { + return 2 << barcodeECLevel; +} +int32_t CBC_PDF417ScanningDecoder::adjustCodewordStartColumn( + CBC_CommonBitMatrix* image, + int32_t minColumn, + int32_t maxColumn, + FX_BOOL leftToRight, + int32_t codewordStartColumn, + int32_t imageRow) { + int32_t correctedStartColumn = codewordStartColumn; + int32_t increment = leftToRight ? -1 : 1; + for (int32_t i = 0; i < 2; i++) { + while (((leftToRight && correctedStartColumn >= minColumn) || + (!leftToRight && correctedStartColumn < maxColumn)) && + leftToRight == image->Get(correctedStartColumn, imageRow)) { + if (abs(codewordStartColumn - correctedStartColumn) > + CODEWORD_SKEW_SIZE) { + return codewordStartColumn; + } + correctedStartColumn += increment; + } + increment = -increment; + leftToRight = !leftToRight; + } + return correctedStartColumn; +} +FX_BOOL CBC_PDF417ScanningDecoder::checkCodewordSkew(int32_t codewordSize, + int32_t minCodewordWidth, + int32_t maxCodewordWidth) { + return minCodewordWidth - CODEWORD_SKEW_SIZE <= codewordSize && + codewordSize <= maxCodewordWidth + CODEWORD_SKEW_SIZE; +} +CBC_CommonDecoderResult* CBC_PDF417ScanningDecoder::decodeCodewords( + CFX_Int32Array& codewords, + int32_t ecLevel, + CFX_Int32Array& erasures, + int32_t& e) { + if (codewords.GetSize() == 0) { + e = BCExceptionFormatInstance; + return NULL; + } + int32_t numECCodewords = 1 << (ecLevel + 1); + correctErrors(codewords, erasures, numECCodewords, e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + verifyCodewordCount(codewords, numECCodewords, e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + CFX_ByteString bytestring; + CBC_CommonDecoderResult* decoderResult = CBC_DecodedBitStreamPaser::decode( + codewords, bytestring.FormatInteger(ecLevel), e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + return decoderResult; +} +int32_t CBC_PDF417ScanningDecoder::correctErrors(CFX_Int32Array& codewords, + CFX_Int32Array& erasures, + int32_t numECCodewords, + int32_t& e) { + if ((erasures.GetSize() != 0 && + erasures.GetSize() > (numECCodewords / 2 + MAX_ERRORS)) || + numECCodewords < 0 || numECCodewords > MAX_EC_CODEWORDS) { + e = BCExceptionChecksumInstance; + return -1; + } + int32_t result = CBC_PDF417ECErrorCorrection::decode( + codewords, numECCodewords, erasures, e); + BC_EXCEPTION_CHECK_ReturnValue(e, -1); + return result; +} +void CBC_PDF417ScanningDecoder::verifyCodewordCount(CFX_Int32Array& codewords, + int32_t numECCodewords, + int32_t& e) { + if (codewords.GetSize() < 4) { + e = BCExceptionFormatInstance; + return; + } + int32_t numberOfCodewords = codewords.GetAt(0); + if (numberOfCodewords > codewords.GetSize()) { + e = BCExceptionFormatInstance; + return; + } + if (numberOfCodewords == 0) { + if (numECCodewords < codewords.GetSize()) { + codewords[0] = codewords.GetSize() - numECCodewords; + } else { + e = BCExceptionFormatInstance; + return; + } + } +} +CFX_Int32Array* CBC_PDF417ScanningDecoder::getBitCountForCodeword( + int32_t codeword) { + CFX_Int32Array* result = new CFX_Int32Array; + result->SetSize(8); + int32_t previousValue = 0; + int32_t i = result->GetSize() - 1; + while (TRUE) { + if ((codeword & 0x1) != previousValue) { + previousValue = codeword & 0x1; + i--; + if (i < 0) { + break; + } + } + result->SetAt(i, result->GetAt(i) + 1); + codeword >>= 1; + } + return result; +} +int32_t CBC_PDF417ScanningDecoder::getCodewordBucketNumber(int32_t codeword) { + CFX_Int32Array* array = getBitCountForCodeword(codeword); + int32_t result = getCodewordBucketNumber(*array); + delete array; + return result; +} +int32_t CBC_PDF417ScanningDecoder::getCodewordBucketNumber( + CFX_Int32Array& moduleBitCount) { + return (moduleBitCount.GetAt(0) - moduleBitCount.GetAt(2) + + moduleBitCount.GetAt(4) - moduleBitCount.GetAt(6) + 9) % + 9; +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417ScanningDecoder.h b/xfa/fxbarcode/pdf417/BC_PDF417ScanningDecoder.h new file mode 100644 index 0000000000..6dbc125c31 --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417ScanningDecoder.h @@ -0,0 +1,119 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417SCANNINGDECODER_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417SCANNINGDECODER_H_ + +class CBC_CommonDecoderResult; +class CBC_CommonBitMatrix; +class CBC_Codeword; +class CBC_BoundingBox; +class CBC_ResultPoint; +class CBC_BarcodeMetadata; +class CBC_DetectionResult; +class CBC_DetectionResultRowIndicatorColumn; + +class CBC_PDF417ScanningDecoder { + public: + CBC_PDF417ScanningDecoder(); + virtual ~CBC_PDF417ScanningDecoder(); + static void Initialize(); + static void Finalize(); + static CBC_CommonDecoderResult* decode(CBC_CommonBitMatrix* image, + CBC_ResultPoint* imageTopLeft, + CBC_ResultPoint* imageBottomLeft, + CBC_ResultPoint* imageTopRight, + CBC_ResultPoint* imageBottomRight, + int32_t minCodewordWidth, + int32_t maxCodewordWidth, + int32_t& e); + static CFX_ByteString toString(CFX_PtrArray* barcodeMatrix); + + private: + static int32_t CODEWORD_SKEW_SIZE; + static int32_t MAX_ERRORS; + static int32_t MAX_EC_CODEWORDS; + static CBC_PDF417ECErrorCorrection* errorCorrection; + static CBC_DetectionResult* merge( + CBC_DetectionResultRowIndicatorColumn* leftRowIndicatorColumn, + CBC_DetectionResultRowIndicatorColumn* rightRowIndicatorColumn, + int32_t& e); + static CBC_BoundingBox* adjustBoundingBox( + CBC_DetectionResultRowIndicatorColumn* rowIndicatorColumn, + int32_t& e); + static int32_t getMax(CFX_Int32Array& values); + static CBC_BarcodeMetadata* getBarcodeMetadata( + CBC_DetectionResultRowIndicatorColumn* leftRowIndicatorColumn, + CBC_DetectionResultRowIndicatorColumn* rightRowIndicatorColumn); + static CBC_DetectionResultRowIndicatorColumn* getRowIndicatorColumn( + CBC_CommonBitMatrix* image, + CBC_BoundingBox* boundingBox, + CBC_ResultPoint startPoint, + FX_BOOL leftToRight, + int32_t minCodewordWidth, + int32_t maxCodewordWidth); + static void adjustCodewordCount(CBC_DetectionResult* detectionResult, + CFX_PtrArray* barcodeMatrix, + int32_t& e); + static CBC_CommonDecoderResult* createDecoderResult( + CBC_DetectionResult* detectionResult, + int32_t& e); + static CBC_CommonDecoderResult* createDecoderResultFromAmbiguousValues( + int32_t ecLevel, + CFX_Int32Array& codewords, + CFX_Int32Array& erasureArray, + CFX_Int32Array& ambiguousIndexes, + CFX_PtrArray& ambiguousIndexValues, + int32_t& e); + static CFX_PtrArray* createBarcodeMatrix( + CBC_DetectionResult* detectionResult); + static FX_BOOL isValidBarcodeColumn(CBC_DetectionResult* detectionResult, + int32_t barcodeColumn); + static int32_t getStartColumn(CBC_DetectionResult* detectionResult, + int32_t barcodeColumn, + int32_t imageRow, + FX_BOOL leftToRight); + static CBC_Codeword* detectCodeword(CBC_CommonBitMatrix* image, + int32_t minColumn, + int32_t maxColumn, + FX_BOOL leftToRight, + int32_t startColumn, + int32_t imageRow, + int32_t minCodewordWidth, + int32_t maxCodewordWidth); + static CFX_Int32Array* getModuleBitCount(CBC_CommonBitMatrix* image, + int32_t minColumn, + int32_t maxColumn, + FX_BOOL leftToRight, + int32_t startColumn, + int32_t imageRow); + static int32_t getNumberOfECCodeWords(int32_t barcodeECLevel); + static int32_t adjustCodewordStartColumn(CBC_CommonBitMatrix* image, + int32_t minColumn, + int32_t maxColumn, + FX_BOOL leftToRight, + int32_t codewordStartColumn, + int32_t imageRow); + static FX_BOOL checkCodewordSkew(int32_t codewordSize, + int32_t minCodewordWidth, + int32_t maxCodewordWidth); + static CBC_CommonDecoderResult* decodeCodewords(CFX_Int32Array& codewords, + int32_t ecLevel, + CFX_Int32Array& erasures, + int32_t& e); + static int32_t correctErrors(CFX_Int32Array& codewords, + CFX_Int32Array& erasures, + int32_t numECCodewords, + int32_t& e); + static void verifyCodewordCount(CFX_Int32Array& codewords, + int32_t numECCodewords, + int32_t& e); + static CFX_Int32Array* getBitCountForCodeword(int32_t codeword); + static int32_t getCodewordBucketNumber(int32_t codeword); + static int32_t getCodewordBucketNumber(CFX_Int32Array& moduleBitCount); +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417SCANNINGDECODER_H_ diff --git a/xfa/fxbarcode/pdf417/BC_PDF417Writer.cpp b/xfa/fxbarcode/pdf417/BC_PDF417Writer.cpp new file mode 100644 index 0000000000..765c1d613c --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417Writer.cpp @@ -0,0 +1,115 @@ +// 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/BC_TwoDimWriter.h" +#include "xfa/fxbarcode/common/BC_CommonBitArray.h" +#include "xfa/fxbarcode/common/BC_CommonBitMatrix.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417Compaction.h" +#include "xfa/fxbarcode/pdf417/BC_PDF417Writer.h" + +CBC_PDF417Writer::CBC_PDF417Writer() { + m_bFixedSize = FALSE; +} +CBC_PDF417Writer::~CBC_PDF417Writer() { + m_bTruncated = TRUE; +} +FX_BOOL CBC_PDF417Writer::SetErrorCorrectionLevel(int32_t level) { + if (level < 0 || level > 8) { + return FALSE; + } + m_iCorrectLevel = level; + return TRUE; +} +void CBC_PDF417Writer::SetTruncated(FX_BOOL truncated) { + m_bTruncated = truncated; +} +uint8_t* CBC_PDF417Writer::Encode(const CFX_WideString& contents, + int32_t& outWidth, + int32_t& outHeight, + int32_t& e) { + CBC_PDF417 encoder; + int32_t col = (m_Width / m_ModuleWidth - 69) / 17; + int32_t row = m_Height / (m_ModuleWidth * 20); + if (row >= 3 && row <= 90 && col >= 1 && col <= 30) { + encoder.setDimensions(col, col, row, row); + } else if (col >= 1 && col <= 30) { + encoder.setDimensions(col, col, 90, 3); + } else if (row >= 3 && row <= 90) { + encoder.setDimensions(30, 1, row, row); + } + encoder.generateBarcodeLogic(contents, m_iCorrectLevel, e); + BC_EXCEPTION_CHECK_ReturnValue(e, NULL); + int32_t lineThickness = 2; + int32_t aspectRatio = 4; + CBC_BarcodeMatrix* barcodeMatrix = encoder.getBarcodeMatrix(); + CFX_ByteArray originalScale; + originalScale.Copy(barcodeMatrix->getScaledMatrix( + lineThickness, aspectRatio * lineThickness)); + int32_t width = outWidth; + int32_t height = outHeight; + outWidth = barcodeMatrix->getWidth(); + outHeight = barcodeMatrix->getHeight(); + FX_BOOL rotated = FALSE; + if ((height > width) ^ (outWidth < outHeight)) { + rotateArray(originalScale, outHeight, outWidth); + rotated = TRUE; + int32_t temp = outHeight; + outHeight = outWidth; + outWidth = temp; + } + int32_t scaleX = width / outWidth; + int32_t scaleY = height / outHeight; + int32_t scale; + if (scaleX < scaleY) { + scale = scaleX; + } else { + scale = scaleY; + } + if (scale > 1) { + originalScale.RemoveAll(); + originalScale.Copy(barcodeMatrix->getScaledMatrix( + scale * lineThickness, scale * aspectRatio * lineThickness)); + if (rotated) { + rotateArray(originalScale, outHeight, outWidth); + int32_t temp = outHeight; + outHeight = outWidth; + outWidth = temp; + } + } + uint8_t* result = FX_Alloc2D(uint8_t, outHeight, outWidth); + FXSYS_memcpy(result, originalScale.GetData(), outHeight * outWidth); + return result; +} +void CBC_PDF417Writer::rotateArray(CFX_ByteArray& bitarray, + int32_t height, + int32_t width) { + CFX_ByteArray temp; + temp.Copy(bitarray); + for (int32_t ii = 0; ii < height; ii++) { + int32_t inverseii = height - ii - 1; + for (int32_t jj = 0; jj < width; jj++) { + bitarray[jj * height + inverseii] = temp[ii * width + jj]; + } + } +} diff --git a/xfa/fxbarcode/pdf417/BC_PDF417Writer.h b/xfa/fxbarcode/pdf417/BC_PDF417Writer.h new file mode 100644 index 0000000000..f92f57b82c --- /dev/null +++ b/xfa/fxbarcode/pdf417/BC_PDF417Writer.h @@ -0,0 +1,28 @@ +// 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 + +#ifndef XFA_FXBARCODE_PDF417_BC_PDF417WRITER_H_ +#define XFA_FXBARCODE_PDF417_BC_PDF417WRITER_H_ + +class CBC_TwoDimWriter; +class CBC_PDF417Writer; +class CBC_PDF417Writer : public CBC_TwoDimWriter { + public: + CBC_PDF417Writer(); + virtual ~CBC_PDF417Writer(); + uint8_t* Encode(const CFX_WideString& contents, + int32_t& outWidth, + int32_t& outHeight, + int32_t& e); + FX_BOOL SetErrorCorrectionLevel(int32_t level); + void SetTruncated(FX_BOOL truncated); + + private: + void rotateArray(CFX_ByteArray& bitarray, int32_t width, int32_t height); + FX_BOOL m_bTruncated; +}; + +#endif // XFA_FXBARCODE_PDF417_BC_PDF417WRITER_H_ -- cgit v1.2.3