diff options
| author | Bo Xu <bo_xu@foxitsoftware.com> | 2015-01-09 17:27:21 -0800 |
|---|---|---|
| committer | Bo Xu <bo_xu@foxitsoftware.com> | 2015-01-09 17:27:21 -0800 |
| commit | a902979f7c6a39fbdd8e9fc1b2ce00553b655eeb (patch) | |
| tree | 854a51dbf1577ee8493db769ba7c8ab07cc72140 /xfa/src/fxbarcode/pdf417 | |
| parent | 5f21e9ddd181fc344f8d6070351858f98a25547e (diff) | |
| download | pdfium-a902979f7c6a39fbdd8e9fc1b2ce00553b655eeb.tar.xz | |
Organize barcode codes into modules.
Previously all the files in barcode are lumped together.
The naming of some files are inconsistent,
leading to difficult understanding of the structure.
Now files are grouped based on different barcode type like in zxing.
This also matches what it looks like in other xfa folders.
The file names in each folder could be further modified to be consistent.
R=tsepez@chromium.org
Review URL: https://codereview.chromium.org/842043002
Diffstat (limited to 'xfa/src/fxbarcode/pdf417')
53 files changed, 6794 insertions, 0 deletions
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417.cpp new file mode 100644 index 0000000000..96d3a3b655 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417.cpp @@ -0,0 +1,692 @@ +// 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 "../barcode.h"
+#include "BC_PDF417Compaction.h"
+#include "BC_PDF417BarcodeRow.h"
+#include "BC_PDF417BarcodeMatrix.h"
+#include "BC_PDF417ErrorCorrection.h"
+#include "BC_PDF417HighLevelEncoder.h"
+#include "BC_PDF417.h"
+FX_INT32 CBC_PDF417::START_PATTERN = 0x1fea8;
+FX_INT32 CBC_PDF417::STOP_PATTERN = 0x3fa29;
+FX_INT32 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, FX_INT32 errorCorrectionLevel, FX_INT32 &e)
+{
+ FX_INT32 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);
+ FX_INT32 sourceCodeWords = highLevel.GetLength();
+ CFX_Int32Array* dimension = determineDimensions(sourceCodeWords, errorCorrectionCodeWords, e);
+ BC_EXCEPTION_CHECK_ReturnVoid(e);
+ FX_INT32 cols = dimension->GetAt(0);
+ FX_INT32 rows = dimension->GetAt(1);
+ delete dimension;
+ FX_INT32 pad = getNumberOfPadCodewords(sourceCodeWords, errorCorrectionCodeWords, cols, rows);
+ if (sourceCodeWords + errorCorrectionCodeWords + 1 > 929) {
+ e = BCExceptionEncodedMessageContainsTooManyCodeWords;
+ return;
+ }
+ FX_INT32 n = sourceCodeWords + pad + 1;
+ CFX_WideString sb;
+ sb += (FX_WCHAR) n;
+ sb += highLevel;
+ for (FX_INT32 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 = FX_NEW CBC_BarcodeMatrix(rows, cols);
+ encodeLowLevel(fullCodewords, cols, rows, errorCorrectionLevel, m_barcodeMatrix);
+}
+void CBC_PDF417::setDimensions(FX_INT32 maxCols, FX_INT32 minCols, FX_INT32 maxRows, FX_INT32 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;
+}
+FX_INT32 CBC_PDF417::calculateNumberOfRows(FX_INT32 m, FX_INT32 k, FX_INT32 c)
+{
+ FX_INT32 r = ((m + 1 + k) / c) + 1;
+ if (c * r >= (m + 1 + k + c)) {
+ r--;
+ }
+ return r;
+}
+FX_INT32 CBC_PDF417::getNumberOfPadCodewords(FX_INT32 m, FX_INT32 k, FX_INT32 c, FX_INT32 r)
+{
+ FX_INT32 n = c * r - k;
+ return n > m + 1 ? n - m - 1 : 0;
+}
+void CBC_PDF417::encodeChar(FX_INT32 pattern, FX_INT32 len, CBC_BarcodeRow* logic)
+{
+ FX_INT32 map = 1 << (len - 1);
+ FX_BOOL last = ((pattern & map) != 0);
+ FX_INT32 width = 0;
+ for (FX_INT32 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, FX_INT32 c, FX_INT32 r, FX_INT32 errorCorrectionLevel, CBC_BarcodeMatrix* logic)
+{
+ FX_INT32 idx = 0;
+ for (FX_INT32 y = 0; y < r; y++) {
+ FX_INT32 cluster = y % 3;
+ logic->startRow();
+ FX_INT32 a = START_PATTERN;
+ encodeChar(START_PATTERN, 17, logic->getCurrentRow());
+ FX_INT32 left;
+ FX_INT32 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);
+ }
+ FX_INT32 pattern = CODEWORD_TABLE[cluster][left];
+ encodeChar(pattern, 17, logic->getCurrentRow());
+ for (FX_INT32 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(FX_INT32 sourceCodeWords, FX_INT32 errorCorrectionCodeWords, FX_INT32 &e)
+{
+ FX_FLOAT ratio = 0.0f;
+ CFX_Int32Array* dimension = NULL;
+ for (FX_INT32 cols = m_minCols; cols <= m_maxCols; cols++) {
+ FX_INT32 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 != NULL && fabsf(newRatio - PREFERRED_RATIO) > fabsf(ratio - PREFERRED_RATIO)) {
+ continue;
+ }
+ ratio = newRatio;
+ if (dimension) {
+ delete dimension;
+ }
+ dimension = FX_NEW CFX_Int32Array;
+ dimension->Add(cols);
+ dimension->Add(rows);
+ }
+ if (dimension == NULL) {
+ FX_INT32 rows = calculateNumberOfRows(sourceCodeWords, errorCorrectionCodeWords, m_minCols);
+ if (rows < m_minRows) {
+ dimension = FX_NEW CFX_Int32Array;
+ dimension->Add(m_minCols);
+ dimension->Add(m_minRows);
+ } else if (rows >= 3 && rows <= 90) {
+ dimension = FX_NEW CFX_Int32Array;
+ dimension->Add(m_minCols);
+ dimension->Add(rows);
+ }
+ }
+ if (dimension == NULL) {
+ e = BCExceptionUnableToFitMessageInColumns;
+ return NULL;
+ }
+ return dimension;
+}
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417.h b/xfa/src/fxbarcode/pdf417/BC_PDF417.h new file mode 100644 index 0000000000..ab31244add --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417.h @@ -0,0 +1,45 @@ +// 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 _BC_PDF417_H_
+#define _BC_PDF417_H_
+class CBC_Compaction;
+class CBC_BarcodeRow;
+class CBC_BarcodeMatrix;
+class CBC_PDF417;
+class CBC_PDF417 : public CFX_Object
+{
+public:
+ CBC_PDF417();
+ CBC_PDF417(FX_BOOL compact);
+ virtual ~CBC_PDF417();
+ CBC_BarcodeMatrix* getBarcodeMatrix();
+ void generateBarcodeLogic(CFX_WideString msg, FX_INT32 errorCorrectionLevel, FX_INT32 &e);
+ void setDimensions(FX_INT32 maxCols, FX_INT32 minCols, FX_INT32 maxRows, FX_INT32 minRows);
+ void setCompaction(Compaction compaction);
+ void setCompact(FX_BOOL compact);
+private:
+ static FX_INT32 START_PATTERN;
+ static FX_INT32 STOP_PATTERN;
+ static FX_INT32 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;
+ FX_INT32 m_minCols;
+ FX_INT32 m_maxCols;
+ FX_INT32 m_maxRows;
+ FX_INT32 m_minRows;
+private:
+ static FX_INT32 calculateNumberOfRows(FX_INT32 m, FX_INT32 k, FX_INT32 c);
+ static FX_INT32 getNumberOfPadCodewords(FX_INT32 m, FX_INT32 k, FX_INT32 c, FX_INT32 r);
+ static void encodeChar(FX_INT32 pattern, FX_INT32 len, CBC_BarcodeRow* logic);
+ void encodeLowLevel(CFX_WideString fullCodewords, FX_INT32 c, FX_INT32 r, FX_INT32 errorCorrectionLevel, CBC_BarcodeMatrix* logic);
+ CFX_Int32Array* determineDimensions(FX_INT32 sourceCodeWords, FX_INT32 errorCorrectionCodeWords, FX_INT32 &e);
+};
+#endif
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.cpp new file mode 100644 index 0000000000..e45562ba79 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.cpp @@ -0,0 +1,98 @@ +// 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 "../barcode.h"
+#include "BC_PDF417BarcodeRow.h"
+#include "BC_PDF417BarcodeMatrix.h"
+CBC_BarcodeMatrix::CBC_BarcodeMatrix(FX_INT32 height, FX_INT32 width)
+{
+ m_matrix.SetSize(height + 2);
+ for (FX_INT32 i = 0, matrixLength = m_matrix.GetSize(); i < matrixLength; i++) {
+ m_matrix[i] = FX_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 (FX_INT32 i = 0; i < m_matrix.GetSize(); i++) {
+ delete (CBC_BarcodeRow*)m_matrix.GetAt(i);
+ }
+ m_matrix.RemoveAll();
+ m_matrixOut.RemoveAll();
+}
+void CBC_BarcodeMatrix::set(FX_INT32 x, FX_INT32 y, FX_BYTE value)
+{
+ ((CBC_BarcodeRow*)m_matrix[y])->set(x, value);
+}
+void CBC_BarcodeMatrix::setMatrix(FX_INT32 x, FX_INT32 y, FX_BOOL black)
+{
+ set(x, y, (FX_BYTE) (black ? 1 : 0));
+}
+void CBC_BarcodeMatrix::startRow()
+{
+ ++m_currentRow;
+}
+CBC_BarcodeRow* CBC_BarcodeMatrix::getCurrentRow()
+{
+ return (CBC_BarcodeRow*)m_matrix[m_currentRow];
+}
+FX_INT32 CBC_BarcodeMatrix::getWidth()
+{
+ return m_outWidth;
+}
+FX_INT32 CBC_BarcodeMatrix::getHeight()
+{
+ return m_outHeight;
+}
+CFX_ByteArray& CBC_BarcodeMatrix::getMatrix()
+{
+ return getScaledMatrix(1, 1);
+}
+CFX_ByteArray& CBC_BarcodeMatrix::getScaledMatrix(FX_INT32 scale)
+{
+ return getScaledMatrix(scale, scale);
+}
+CFX_ByteArray& CBC_BarcodeMatrix::getScaledMatrix(FX_INT32 xScale, FX_INT32 yScale)
+{
+ FX_INT32 yMax = m_height * yScale;
+ CFX_ByteArray bytearray;
+ bytearray.Copy(((CBC_BarcodeRow*)m_matrix[0])->getScaledRow(xScale));
+ FX_INT32 xMax = bytearray.GetSize();
+ m_matrixOut.SetSize(xMax * yMax);
+ m_outWidth = xMax;
+ m_outHeight = yMax;
+ FX_INT32 k = 0;
+ for (FX_INT32 i = 0; i < yMax; i++) {
+ if (i != 0) {
+ bytearray.Copy(((CBC_BarcodeRow*)m_matrix[i / yScale])->getScaledRow(xScale));
+ }
+ k = i * xMax;
+ for (FX_INT32 l = 0; l < xMax; l++) {
+ m_matrixOut[k + l] = bytearray.GetAt(l);
+ }
+ }
+ return m_matrixOut;
+}
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.h b/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.h new file mode 100644 index 0000000000..d8a0c5d0ae --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeMatrix.h @@ -0,0 +1,35 @@ +// 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 _BC_BARCODEMATRIX_H_
+#define _BC_BARCODEMATRIX_H_
+class CBC_BarcodeRow;
+class CBC_BarcodeMatrix;
+class CBC_BarcodeMatrix : public CFX_Object
+{
+public:
+ CBC_BarcodeMatrix();
+ CBC_BarcodeMatrix(FX_INT32 height, FX_INT32 width);
+ virtual ~CBC_BarcodeMatrix();
+ void set(FX_INT32 x, FX_INT32 y, FX_BYTE value);
+ void setMatrix(FX_INT32 x, FX_INT32 y, FX_BOOL black);
+ void startRow();
+ CBC_BarcodeRow* getCurrentRow();
+ CFX_ByteArray& getMatrix();
+ CFX_ByteArray& getScaledMatrix(FX_INT32 scale);
+ CFX_ByteArray& getScaledMatrix(FX_INT32 xScale, FX_INT32 yScale);
+ FX_INT32 getWidth();
+ FX_INT32 getHeight();
+private:
+ CFX_PtrArray m_matrix;
+ CFX_ByteArray m_matrixOut;
+ FX_INT32 m_currentRow;
+ FX_INT32 m_height;
+ FX_INT32 m_width;
+ FX_INT32 m_outWidth;
+ FX_INT32 m_outHeight;
+};
+#endif
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeMetadata.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeMetadata.cpp new file mode 100644 index 0000000000..456c0e6f2e --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeMetadata.cpp @@ -0,0 +1,55 @@ +// 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 "../barcode.h"
+#include "BC_PDF417BarcodeMetadata.h"
+CBC_BarcodeMetadata::CBC_BarcodeMetadata(FX_INT32 columnCount, FX_INT32 rowCountUpperPart, FX_INT32 rowCountLowerPart, FX_INT32 errorCorrectionLevel)
+{
+ m_columnCount = columnCount;
+ m_rowCountUpperPart = rowCountUpperPart;
+ m_rowCountLowerPart = rowCountLowerPart;
+ m_errorCorrectionLevel = errorCorrectionLevel;
+ m_rowCount = m_rowCountUpperPart + m_rowCountLowerPart;
+}
+CBC_BarcodeMetadata::~CBC_BarcodeMetadata()
+{
+}
+FX_INT32 CBC_BarcodeMetadata::getColumnCount()
+{
+ return m_columnCount;
+}
+FX_INT32 CBC_BarcodeMetadata::getErrorCorrectionLevel()
+{
+ return m_errorCorrectionLevel;
+}
+FX_INT32 CBC_BarcodeMetadata::getRowCount()
+{
+ return m_rowCount;
+}
+FX_INT32 CBC_BarcodeMetadata::getRowCountUpperPart()
+{
+ return m_rowCountUpperPart;
+}
+FX_INT32 CBC_BarcodeMetadata::getRowCountLowerPart()
+{
+ return m_rowCountLowerPart;
+}
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeMetadata.h b/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeMetadata.h new file mode 100644 index 0000000000..62b1282827 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeMetadata.h @@ -0,0 +1,27 @@ +// 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 _BC_BARCODEMETADATA_H_
+#define _BC_BARCODEMETADATA_H_
+class CBC_BarcodeMetadata;
+class CBC_BarcodeMetadata : public CFX_Object
+{
+public:
+ CBC_BarcodeMetadata(FX_INT32 columnCount, FX_INT32 rowCountUpperPart, FX_INT32 rowCountLowerPart, FX_INT32 errorCorrectionLevel);
+ virtual ~CBC_BarcodeMetadata();
+ FX_INT32 getColumnCount();
+ FX_INT32 getErrorCorrectionLevel();
+ FX_INT32 getRowCount();
+ FX_INT32 getRowCountUpperPart();
+ FX_INT32 getRowCountLowerPart();
+private:
+ FX_INT32 m_columnCount;
+ FX_INT32 m_errorCorrectionLevel;
+ FX_INT32 m_rowCountUpperPart;
+ FX_INT32 m_rowCountLowerPart;
+ FX_INT32 m_rowCount;
+};
+#endif
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeRow.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeRow.cpp new file mode 100644 index 0000000000..02bc0f5574 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeRow.cpp @@ -0,0 +1,60 @@ +// 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 "../barcode.h"
+#include "BC_PDF417BarcodeRow.h"
+CBC_BarcodeRow::CBC_BarcodeRow(FX_INT32 width)
+{
+ m_row.SetSize(width);
+ m_currentLocation = 0;
+}
+CBC_BarcodeRow::~CBC_BarcodeRow()
+{
+ m_output.RemoveAll();
+ m_row.RemoveAll();
+}
+void CBC_BarcodeRow::set(FX_INT32 x, FX_BYTE value)
+{
+ m_row.SetAt(x, value);
+}
+void CBC_BarcodeRow::set(FX_INT32 x, FX_BOOL black)
+{
+ m_row.SetAt(x, (FX_BYTE) (black ? 1 : 0));
+}
+void CBC_BarcodeRow::addBar(FX_BOOL black, FX_INT32 width)
+{
+ for (FX_INT32 ii = 0; ii < width; ii++) {
+ set(m_currentLocation++, black);
+ }
+}
+CFX_ByteArray& CBC_BarcodeRow::getRow()
+{
+ return m_row;
+}
+CFX_ByteArray& CBC_BarcodeRow::getScaledRow(FX_INT32 scale)
+{
+ m_output.SetSize(m_row.GetSize() * scale);
+ for (FX_INT32 i = 0; i < m_output.GetSize(); i++) {
+ m_output[i] = (m_row[i / scale]);
+ }
+ return m_output;
+}
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeRow.h b/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeRow.h new file mode 100644 index 0000000000..75fd15b653 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeRow.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 _BC_BARCODEROW_H_
+#define _BC_BARCODEROW_H_
+class CBC_BarcodeRow;
+class CBC_BarcodeRow : public CFX_Object
+{
+public:
+ CBC_BarcodeRow(FX_INT32 width);
+ virtual ~CBC_BarcodeRow();
+ void set(FX_INT32 x, FX_BYTE value);
+ void set(FX_INT32 x, FX_BOOL black);
+ void addBar(FX_BOOL black, FX_INT32 width);
+ CFX_ByteArray& getRow();
+ CFX_ByteArray& getScaledRow(FX_INT32 scale);
+private:
+ CFX_ByteArray m_row;
+ CFX_ByteArray m_output;
+ FX_INT32 m_currentLocation;
+};
+#endif
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeValue.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeValue.cpp new file mode 100644 index 0000000000..446ef58a48 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeValue.cpp @@ -0,0 +1,68 @@ +// 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 "../barcode.h"
+#include "BC_PDF417Common.h"
+#include "BC_PDF417BarcodeValue.h"
+CBC_BarcodeValue::CBC_BarcodeValue()
+{
+}
+CBC_BarcodeValue::~CBC_BarcodeValue()
+{
+}
+void CBC_BarcodeValue::setValue(FX_INT32 value)
+{
+ FX_INT32 confidence = 0;
+ for (FX_INT32 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()
+{
+ FX_INT32 maxConfidence = -1;
+ CFX_Int32Array* result = FX_NEW CFX_Int32Array;
+ for (FX_INT32 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;
+}
+FX_INT32 CBC_BarcodeValue::getConfidence(FX_INT32 value)
+{
+ for (FX_INT32 i = 0; i < m_keys.GetSize(); i++)
+ if (m_keys.GetAt(i) == value) {
+ return m_values.GetAt(i);
+ }
+ return -1;
+}
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeValue.h b/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeValue.h new file mode 100644 index 0000000000..1695c8ac5a --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417BarcodeValue.h @@ -0,0 +1,22 @@ +// 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 _BC_BARCODEVALUE_H_
+#define _BC_BARCODEVALUE_H_
+class CBC_BarcodeValue;
+class CBC_BarcodeValue : public CFX_Object
+{
+public:
+ CBC_BarcodeValue();
+ virtual ~CBC_BarcodeValue();
+ void setValue(FX_INT32 value);
+ CFX_Int32Array* getValue();
+ FX_INT32 getConfidence(FX_INT32 value);
+private:
+ CFX_Int32Array m_keys;
+ CFX_Int32Array m_values;
+};
+#endif
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417BoundingBox.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417BoundingBox.cpp new file mode 100644 index 0000000000..55f4cb4510 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417BoundingBox.cpp @@ -0,0 +1,194 @@ +// 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 "../barcode.h"
+#include "../BC_ResultPoint.h"
+#include "../common/BC_CommonBitMatrix.h"
+#include "BC_PDF417BoundingBox.h"
+CBC_BoundingBox::CBC_BoundingBox(CBC_CommonBitMatrix* image, CBC_ResultPoint* topLeft, CBC_ResultPoint* bottomLeft, CBC_ResultPoint* topRight, CBC_ResultPoint* bottomRight, FX_INT32 &e)
+{
+ if ((topLeft == NULL && topRight == NULL) ||
+ (bottomLeft == NULL && bottomRight == NULL) ||
+ (topLeft != NULL && bottomLeft == NULL) ||
+ (topRight != NULL && 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, FX_INT32 &e)
+{
+ CBC_BoundingBox* boundingBox = NULL;
+ if (leftBox == NULL) {
+ boundingBox = FX_NEW CBC_BoundingBox(rightBox);
+ return boundingBox;
+ }
+ if (rightBox == NULL) {
+ boundingBox = FX_NEW CBC_BoundingBox(leftBox);
+ return boundingBox;
+ }
+ boundingBox = FX_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(FX_INT32 missingStartRows, FX_INT32 missingEndRows, FX_BOOL isLeft, FX_INT32 &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;
+ FX_INT32 newMinY = (FX_INT32) top->GetY() - missingStartRows;
+ if (newMinY < 0) {
+ newMinY = 0;
+ }
+ newTop = FX_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;
+ FX_INT32 newMaxY = (FX_INT32) bottom->GetY() + missingEndRows;
+ if (newMaxY >= m_image->GetHeight()) {
+ newMaxY = m_image->GetHeight() - 1;
+ }
+ newBottom = FX_NEW CBC_ResultPoint((FX_FLOAT)bottom->GetX(), (FX_FLOAT)newMaxY);
+ if (isLeft) {
+ newBottomLeft = newBottom;
+ } else {
+ newBottomRight = newBottom;
+ }
+ }
+ calculateMinMaxValues();
+ CBC_BoundingBox* boundingBox = FX_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 = FX_NEW CBC_ResultPoint(topRight.GetX(), topRight.GetY());
+ calculateMinMaxValues();
+}
+void CBC_BoundingBox::setBottomRight(CBC_ResultPoint bottomRight)
+{
+ if (m_bottomRight) {
+ delete m_bottomRight;
+ }
+ m_bottomRight = FX_NEW CBC_ResultPoint(bottomRight.GetX(), bottomRight.GetY());
+ calculateMinMaxValues();
+}
+FX_INT32 CBC_BoundingBox::getMinX()
+{
+ return m_minX;
+}
+FX_INT32 CBC_BoundingBox::getMaxX()
+{
+ return m_maxX;
+}
+FX_INT32 CBC_BoundingBox::getMinY()
+{
+ return m_minY;
+}
+FX_INT32 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 = FX_NEW CBC_ResultPoint(topLeft->GetX(), topLeft->GetY());
+ }
+ if (bottomLeft) {
+ m_bottomLeft = FX_NEW CBC_ResultPoint(bottomLeft->GetX(), bottomLeft->GetY());
+ }
+ if (topRight) {
+ m_topRight = FX_NEW CBC_ResultPoint(topRight->GetX(), topRight->GetY());
+ }
+ if (bottomRight) {
+ m_bottomRight = FX_NEW CBC_ResultPoint(bottomRight->GetX(), bottomRight->GetY());
+ }
+ calculateMinMaxValues();
+}
+void CBC_BoundingBox::calculateMinMaxValues()
+{
+ if (m_topLeft == NULL) {
+ m_topLeft = FX_NEW CBC_ResultPoint(0, m_topRight->GetY());
+ m_bottomLeft = FX_NEW CBC_ResultPoint(0, m_bottomRight->GetY());
+ } else if (m_topRight == NULL) {
+ m_topRight = FX_NEW CBC_ResultPoint((FX_FLOAT)m_image->GetWidth() - 1, (FX_FLOAT)m_topLeft->GetY());
+ m_bottomRight = FX_NEW CBC_ResultPoint((FX_FLOAT)m_image->GetWidth() - 1, (FX_FLOAT)m_bottomLeft->GetY());
+ }
+ m_minX = (FX_INT32) (m_topLeft->GetX() < m_bottomLeft->GetX() ? m_topLeft->GetX() : m_bottomLeft->GetX());
+ m_maxX = (FX_INT32) (m_topRight->GetX() > m_bottomRight->GetX() ? m_topRight->GetX() : m_bottomRight->GetX());
+ m_minY = (FX_INT32) (m_topLeft->GetY() < m_topRight->GetY() ? m_topLeft->GetY() : m_topRight->GetY());
+ m_maxY = (FX_INT32) (m_bottomLeft->GetY() > m_bottomRight->GetY() ? m_bottomLeft->GetY() : m_bottomRight->GetY());
+}
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417BoundingBox.h b/xfa/src/fxbarcode/pdf417/BC_PDF417BoundingBox.h new file mode 100644 index 0000000000..efae2b706f --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417BoundingBox.h @@ -0,0 +1,43 @@ +// 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 _BC_BOUNDINGBOX_H_
+#define _BC_BOUNDINGBOX_H_
+class CBC_CommonBitMatrix;
+class CBC_ResultPoint;
+class CBC_BoundingBox;
+class CBC_BoundingBox : public CFX_Object
+{
+public:
+ CBC_BoundingBox(CBC_CommonBitMatrix* image, CBC_ResultPoint* topLeft, CBC_ResultPoint* bottomLeft, CBC_ResultPoint* topRight, CBC_ResultPoint* bottomRight, FX_INT32 &e);
+ CBC_BoundingBox(CBC_BoundingBox* boundingBox);
+ virtual ~CBC_BoundingBox();
+ static CBC_BoundingBox* merge(CBC_BoundingBox* leftBox, CBC_BoundingBox* rightBox, FX_INT32 &e);
+ CBC_BoundingBox* addMissingRows(FX_INT32 missingStartRows, FX_INT32 missingEndRows, FX_BOOL isLeft, FX_INT32 &e);
+ void setTopRight(CBC_ResultPoint topRight);
+ void setBottomRight(CBC_ResultPoint bottomRight);
+ FX_INT32 getMinX();
+ FX_INT32 getMaxX();
+ FX_INT32 getMinY();
+ FX_INT32 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;
+ FX_INT32 m_minX;
+ FX_INT32 m_maxX;
+ FX_INT32 m_minY;
+ FX_INT32 m_maxY;
+ void init(CBC_CommonBitMatrix* image, CBC_ResultPoint* topLeft, CBC_ResultPoint* bottomLeft, CBC_ResultPoint* topRight, CBC_ResultPoint* bottomRight);
+ void calculateMinMaxValues();
+};
+#endif
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417Codeword.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417Codeword.cpp new file mode 100644 index 0000000000..9ac65ab7bc --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417Codeword.cpp @@ -0,0 +1,80 @@ +// 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 "../barcode.h"
+#include "BC_PDF417Codeword.h"
+FX_INT32 CBC_Codeword::BARCODE_ROW_UNKNOWN = -1;
+CBC_Codeword::CBC_Codeword(FX_INT32 startX, FX_INT32 endX, FX_INT32 bucket, FX_INT32 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(FX_INT32 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;
+}
+FX_INT32 CBC_Codeword::getWidth()
+{
+ return m_endX - m_startX;
+}
+FX_INT32 CBC_Codeword::getStartX()
+{
+ return m_startX;
+}
+FX_INT32 CBC_Codeword::getEndX()
+{
+ return m_endX;
+}
+FX_INT32 CBC_Codeword::getBucket()
+{
+ return m_bucket;
+}
+FX_INT32 CBC_Codeword::getValue()
+{
+ return m_value;
+}
+FX_INT32 CBC_Codeword::getRowNumber()
+{
+ return m_rowNumber;
+}
+void CBC_Codeword::setRowNumber(FX_INT32 rowNumber)
+{
+ m_rowNumber = rowNumber;
+}
+CFX_ByteString CBC_Codeword::toString()
+{
+ return m_rowNumber + (FX_CHAR)'|' + m_value;
+}
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417Codeword.h b/xfa/src/fxbarcode/pdf417/BC_PDF417Codeword.h new file mode 100644 index 0000000000..93b3cf6bb3 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417Codeword.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 _BC_CODEWORD_H_
+#define _BC_CODEWORD_H_
+class CBC_Codeword;
+class CBC_Codeword : public CFX_Object
+{
+public:
+ CBC_Codeword(FX_INT32 startX, FX_INT32 endX, FX_INT32 bucket, FX_INT32 value);
+ virtual ~CBC_Codeword();
+ FX_BOOL hasValidRowNumber() ;
+ FX_BOOL isValidRowNumber(FX_INT32 rowNumber);
+ void setRowNumberAsRowIndicatorColumn();
+ FX_INT32 getWidth();
+ FX_INT32 getStartX();
+ FX_INT32 getEndX();
+ FX_INT32 getBucket();
+ FX_INT32 getValue();
+ FX_INT32 getRowNumber();
+ void setRowNumber(FX_INT32 rowNumber);
+ CFX_ByteString toString();
+private:
+ static FX_INT32 BARCODE_ROW_UNKNOWN;
+ FX_INT32 m_startX;
+ FX_INT32 m_endX;
+ FX_INT32 m_bucket;
+ FX_INT32 m_value;
+ FX_INT32 m_rowNumber;
+};
+#endif
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417CodewordDecoder.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417CodewordDecoder.cpp new file mode 100644 index 0000000000..bf16bc25e0 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417CodewordDecoder.cpp @@ -0,0 +1,118 @@ +// 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 "../barcode.h"
+#include "BC_PDF417Common.h"
+#include "BC_PDF417CodewordDecoder.h"
+#define SYMBOL_TABLE_Length 2787
+#define Float_MAX_VALUE 2147483647
+FX_FLOAT CBC_PDF417CodewordDecoder::RATIOS_TABLE[2787][8] = {0};
+CBC_PDF417CodewordDecoder::CBC_PDF417CodewordDecoder()
+{
+}
+CBC_PDF417CodewordDecoder::~CBC_PDF417CodewordDecoder()
+{
+}
+void CBC_PDF417CodewordDecoder::Initialize()
+{
+ for (FX_INT32 i = 0; i < SYMBOL_TABLE_Length; i++) {
+ FX_INT32 currentSymbol = CBC_PDF417Common::SYMBOL_TABLE[i];
+ FX_INT32 currentBit = currentSymbol & 0x1;
+ for (FX_INT32 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()
+{
+}
+FX_INT32 CBC_PDF417CodewordDecoder::getDecodedValue(CFX_Int32Array& moduleBitCount)
+{
+ CFX_Int32Array* array = sampleBitCounts(moduleBitCount);
+ FX_INT32 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 = FX_NEW CFX_Int32Array();
+ bitCount->SetSize(CBC_PDF417Common::BARS_IN_MODULE);
+ FX_INT32 bitCountIndex = 0;
+ FX_INT32 sumPreviousBits = 0;
+ for (FX_INT32 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;
+}
+FX_INT32 CBC_PDF417CodewordDecoder::getDecodedCodewordValue(CFX_Int32Array& moduleBitCount)
+{
+ FX_INT32 decodedValue = getBitValue(moduleBitCount);
+ return CBC_PDF417Common::getCodeword(decodedValue) == -1 ? -1 : decodedValue;
+}
+FX_INT32 CBC_PDF417CodewordDecoder::getBitValue(CFX_Int32Array& moduleBitCount)
+{
+ FX_INT64 result = 0;
+ for (FX_INT32 i = 0; i < moduleBitCount.GetSize(); i++) {
+ for (FX_INT32 bit = 0; bit < moduleBitCount.GetAt(i); bit++) {
+ result = (result << 1) | (i % 2 == 0 ? 1 : 0);
+ }
+ }
+ return (FX_INT32) result;
+}
+FX_INT32 CBC_PDF417CodewordDecoder::getClosestDecodedValue(CFX_Int32Array& moduleBitCount)
+{
+ FX_INT32 bitCountSum = CBC_PDF417Common::getBitCountSum(moduleBitCount);
+ CFX_FloatArray bitCountRatios;
+ bitCountRatios.SetSize(CBC_PDF417Common::BARS_IN_MODULE);
+ for (FX_INT32 i = 0; i < bitCountRatios.GetSize(); i++) {
+ bitCountRatios[i] = moduleBitCount.GetAt(i) / (FX_FLOAT) bitCountSum;
+ }
+ FX_FLOAT bestMatchError = (FX_FLOAT)Float_MAX_VALUE;
+ FX_INT32 bestMatch = -1;
+ for (FX_INT32 j = 0; j < SYMBOL_TABLE_Length; j++) {
+ FX_FLOAT error = 0.0f;
+ for (FX_INT32 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/src/fxbarcode/pdf417/BC_PDF417CodewordDecoder.h b/xfa/src/fxbarcode/pdf417/BC_PDF417CodewordDecoder.h new file mode 100644 index 0000000000..da22683bfa --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417CodewordDecoder.h @@ -0,0 +1,27 @@ +// 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 _BC_PDF417CODEWORDDECODER_H_
+#define _BC_PDF417CODEWORDDECODER_H_
+class CBC_PDF417Common;
+class CBC_PDF417CodewordDecoder;
+#define column 8
+class CBC_PDF417CodewordDecoder : public CFX_Object
+{
+public:
+ CBC_PDF417CodewordDecoder();
+ virtual ~CBC_PDF417CodewordDecoder();
+ static void Initialize();
+ static void Finalize();
+ static FX_INT32 getDecodedValue(CFX_Int32Array& moduleBitCount);
+private:
+ static FX_FLOAT RATIOS_TABLE[][8];
+ static CFX_Int32Array* sampleBitCounts(CFX_Int32Array& moduleBitCount);
+ static FX_INT32 getDecodedCodewordValue(CFX_Int32Array& moduleBitCount);
+ static FX_INT32 getBitValue(CFX_Int32Array& moduleBitCount);
+ static FX_INT32 getClosestDecodedValue(CFX_Int32Array& moduleBitCount);
+};
+#endif
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417Common.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417Common.cpp new file mode 100644 index 0000000000..1f192e63a7 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417Common.cpp @@ -0,0 +1,450 @@ +// 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 "../barcode.h"
+#include "BC_PDF417Common.h"
+FX_INT32 CBC_PDF417Common::NUMBER_OF_CODEWORDS = 929;
+FX_INT32 CBC_PDF417Common::MAX_CODEWORDS_IN_BARCODE = NUMBER_OF_CODEWORDS - 1;
+FX_INT32 CBC_PDF417Common::MIN_ROWS_IN_BARCODE = 3;
+FX_INT32 CBC_PDF417Common::MAX_ROWS_IN_BARCODE = 90;
+FX_INT32 CBC_PDF417Common::MAX_CODEWORDS_IN_ROW = 32;
+FX_INT32 CBC_PDF417Common::MODULES_IN_CODEWORD = 17;
+FX_INT32 CBC_PDF417Common::MODULES_IN_STOP_PATTERN = 18;
+FX_INT32 CBC_PDF417Common::BARS_IN_MODULE = 8;
+CFX_Int32Array* CBC_PDF417Common::EMPTY_INT_ARRAY = NULL;
+FX_INT32 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
+};
+FX_INT32 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()
+{
+}
+FX_INT32 CBC_PDF417Common::getBitCountSum(CFX_Int32Array& moduleBitCount)
+{
+ FX_INT32 bitCountSum = 0;
+ for (FX_INT32 i = 0; i < moduleBitCount.GetSize(); i++) {
+ FX_INT32 count = moduleBitCount.GetAt(i);
+ bitCountSum += count;
+ }
+ return bitCountSum;
+}
+FX_INT32 CBC_PDF417Common::getCodeword(FX_DWORD symbol)
+{
+ FX_DWORD sym = symbol & 0x3FFFF;
+ FX_INT32 i = findCodewordIndex(sym);
+ if (i == -1) {
+ return -1;
+ }
+ return (CODEWORD_TABLE[i] - 1) % NUMBER_OF_CODEWORDS;
+}
+FX_INT32 CBC_PDF417Common::findCodewordIndex(FX_DWORD symbol)
+{
+ FX_INT32 first = 0;
+ FX_INT32 upto = sizeof(SYMBOL_TABLE) / sizeof(SYMBOL_TABLE[0]);
+ while (first < upto) {
+ FX_INT32 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/src/fxbarcode/pdf417/BC_PDF417Common.h b/xfa/src/fxbarcode/pdf417/BC_PDF417Common.h new file mode 100644 index 0000000000..19e3fe57da --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417Common.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 _BC_PDF417COMMON_H_
+#define _BC_PDF417COMMON_H_
+class CBC_PDF417Common;
+class CBC_PDF417Common : public CFX_Object
+{
+public:
+ CBC_PDF417Common();
+ virtual ~CBC_PDF417Common();
+ static FX_INT32 getBitCountSum(CFX_Int32Array& moduleBitCount);
+ static FX_INT32 getCodeword(FX_DWORD symbol);
+ static FX_INT32 NUMBER_OF_CODEWORDS;
+ static FX_INT32 MAX_CODEWORDS_IN_BARCODE;
+ static FX_INT32 MIN_ROWS_IN_BARCODE;
+ static FX_INT32 MAX_ROWS_IN_BARCODE;
+ static FX_INT32 MAX_CODEWORDS_IN_ROW;
+ static FX_INT32 MODULES_IN_CODEWORD;
+ static FX_INT32 MODULES_IN_STOP_PATTERN;
+ static FX_INT32 BARS_IN_MODULE;
+ static FX_INT32 SYMBOL_TABLE[];
+ static FX_INT32 CODEWORD_TABLE[];
+private:
+ static CFX_Int32Array* EMPTY_INT_ARRAY;
+ static FX_INT32 findCodewordIndex(FX_DWORD symbol);
+};
+#endif
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417Compaction.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417Compaction.cpp new file mode 100644 index 0000000000..6ad8c1321f --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417Compaction.cpp @@ -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
+// 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 "../barcode.h"
+#include "BC_PDF417Compaction.h"
+CBC_Compaction::CBC_Compaction()
+{
+}
+CBC_Compaction::~CBC_Compaction()
+{
+}
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417Compaction.h b/xfa/src/fxbarcode/pdf417/BC_PDF417Compaction.h new file mode 100644 index 0000000000..774a23fbdf --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417Compaction.h @@ -0,0 +1,22 @@ +// 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 _BC_COMPACTION_H_
+#define _BC_COMPACTION_H_
+class CBC_Compaction;
+enum Compaction {
+ AUTO,
+ TEXT,
+ BYTES,
+ NUMERIC
+};
+class CBC_Compaction : public CFX_Object
+{
+public:
+ CBC_Compaction();
+ virtual ~CBC_Compaction();
+};
+#endif
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.cpp new file mode 100644 index 0000000000..ae26057c3e --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.cpp @@ -0,0 +1,485 @@ +// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+// Original code is licensed as follows:
+/*
+ * Copyright 2009 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdlib.h>
+#include "../barcode.h"
+#include "../BC_DecoderResult.h"
+#include "../common/BC_CommonDecoderResult.h"
+#include "../../../../third_party/bigint/BigIntegerLibrary.hh"
+#include "BC_PDF417ResultMetadata.h"
+#include "BC_PDF417DecodedBitStreamParser.h"
+#define TEXT_COMPACTION_MODE_LATCH 900
+#define BYTE_COMPACTION_MODE_LATCH 901
+#define NUMERIC_COMPACTION_MODE_LATCH 902
+#define BYTE_COMPACTION_MODE_LATCH_6 924
+#define BEGIN_MACRO_PDF417_CONTROL_BLOCK 928
+#define BEGIN_MACRO_PDF417_OPTIONAL_FIELD 923
+#define MACRO_PDF417_TERMINATOR 922
+#define MODE_SHIFT_TO_BYTE_COMPACTION_MODE 913
+
+FX_INT32 CBC_DecodedBitStreamPaser::MAX_NUMERIC_CODEWORDS = 15;
+FX_INT32 CBC_DecodedBitStreamPaser::NUMBER_OF_SEQUENCE_CODEWORDS = 2;
+FX_INT32 CBC_DecodedBitStreamPaser::PL = 25;
+FX_INT32 CBC_DecodedBitStreamPaser::LL = 27;
+FX_INT32 CBC_DecodedBitStreamPaser::AS = 27;
+FX_INT32 CBC_DecodedBitStreamPaser::ML = 28;
+FX_INT32 CBC_DecodedBitStreamPaser::AL = 28;
+FX_INT32 CBC_DecodedBitStreamPaser::PS = 29;
+FX_INT32 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, FX_INT32 &e)
+{
+ CFX_ByteString result;
+ FX_INT32 codeIndex = 1;
+ FX_INT32 code = codewords.GetAt(codeIndex);
+ codeIndex++;
+ CBC_PDF417ResultMetadata* resultMetadata = FX_NEW CBC_PDF417ResultMetadata;
+ while (codeIndex < codewords[0]) {
+ switch (code) {
+ case TEXT_COMPACTION_MODE_LATCH:
+ codeIndex = textCompaction(codewords, codeIndex, result);
+ break;
+ case BYTE_COMPACTION_MODE_LATCH:
+ codeIndex = byteCompaction(code, codewords, codeIndex, result);
+ break;
+ case NUMERIC_COMPACTION_MODE_LATCH:
+ codeIndex = numericCompaction(codewords, codeIndex, result, e);
+ BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
+ break;
+ case MODE_SHIFT_TO_BYTE_COMPACTION_MODE:
+ codeIndex = byteCompaction(code, codewords, codeIndex, result);
+ break;
+ case BYTE_COMPACTION_MODE_LATCH_6:
+ codeIndex = byteCompaction(code, codewords, codeIndex, result);
+ break;
+ case BEGIN_MACRO_PDF417_CONTROL_BLOCK:
+ codeIndex = decodeMacroBlock(codewords, codeIndex, resultMetadata, e);
+ if (e != BCExceptionNO) {
+ delete resultMetadata;
+ return NULL;
+ }
+ break;
+ default:
+ codeIndex--;
+ codeIndex = textCompaction(codewords, codeIndex, result);
+ break;
+ }
+ if (codeIndex < codewords.GetSize()) {
+ code = codewords[codeIndex++];
+ } else {
+ e = BCExceptionFormatInstance;
+ delete resultMetadata;
+ return NULL;
+ }
+ }
+ if (result.GetLength() == 0) {
+ e = BCExceptionFormatInstance;
+ delete resultMetadata;
+ return NULL;
+ }
+ CFX_ByteArray rawBytes;
+ CFX_PtrArray byteSegments;
+ CBC_CommonDecoderResult *tempCd = FX_NEW CBC_CommonDecoderResult();
+ tempCd->Init(rawBytes, result, byteSegments, ecLevel, e);
+ if (e != BCExceptionNO) {
+ delete resultMetadata;
+ return NULL;
+ }
+ tempCd->setOther(resultMetadata);
+ return tempCd;
+}
+FX_INT32 CBC_DecodedBitStreamPaser::decodeMacroBlock(CFX_Int32Array &codewords, FX_INT32 codeIndex, CBC_PDF417ResultMetadata* resultMetadata, FX_INT32 &e)
+{
+ if (codeIndex + NUMBER_OF_SEQUENCE_CODEWORDS > codewords[0]) {
+ e = BCExceptionFormatInstance;
+ return -1;
+ }
+ CFX_Int32Array segmentIndexArray;
+ segmentIndexArray.SetSize(NUMBER_OF_SEQUENCE_CODEWORDS);
+ for (FX_INT32 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);
+ FX_INT32 additionalOptionCodeWordsIndex = 0;
+ FX_BOOL end = FALSE;
+ while ((codeIndex < codewords[0]) && !end) {
+ FX_INT32 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;
+}
+FX_INT32 CBC_DecodedBitStreamPaser::textCompaction(CFX_Int32Array &codewords, FX_INT32 codeIndex, CFX_ByteString &result)
+{
+ CFX_Int32Array textCompactionData;
+ textCompactionData.SetSize((codewords[0] - codeIndex) << 1);
+ CFX_Int32Array byteCompactionData;
+ byteCompactionData.SetSize((codewords[0] - codeIndex) << 1);
+ FX_INT32 index = 0;
+ FX_BOOL end = FALSE;
+ while ((codeIndex < codewords[0]) && !end) {
+ FX_INT32 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, FX_INT32 length, CFX_ByteString &result)
+{
+ Mode subMode = ALPHA;
+ Mode priorToShiftMode = ALPHA;
+ FX_INT32 i = 0;
+ while (i < length) {
+ FX_INT32 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++;
+ }
+}
+FX_INT32 CBC_DecodedBitStreamPaser::byteCompaction(FX_INT32 mode, CFX_Int32Array &codewords, FX_INT32 codeIndex, CFX_ByteString &result)
+{
+ if (mode == BYTE_COMPACTION_MODE_LATCH) {
+ FX_INT32 count = 0;
+ FX_INT64 value = 0;
+ FX_WORD* decodedData = FX_Alloc(FX_WORD, 6 * sizeof(FX_WORD));
+ CFX_Int32Array byteCompactedCodewords;
+ byteCompactedCodewords.SetSize(6);
+ FX_BOOL end = FALSE;
+ FX_INT32 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)) {
+ FX_INT32 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 (FX_INT32 i = 0; i < count; i++) {
+ result += (FX_CHAR)(FX_WORD) byteCompactedCodewords[i];
+ }
+ } else if (mode == BYTE_COMPACTION_MODE_LATCH_6) {
+ FX_INT32 count = 0;
+ FX_INT64 value = 0;
+ FX_BOOL end = FALSE;
+ while (codeIndex < codewords[0] && !end) {
+ FX_INT32 code = codewords[codeIndex++];
+ if (code < TEXT_COMPACTION_MODE_LATCH) {
+ count++;
+ value = 900 * value + code;
+ } else {
+ if (code == TEXT_COMPACTION_MODE_LATCH ||
+ code == BYTE_COMPACTION_MODE_LATCH ||
+ code == NUMERIC_COMPACTION_MODE_LATCH ||
+ code == BYTE_COMPACTION_MODE_LATCH_6 ||
+ code == BEGIN_MACRO_PDF417_CONTROL_BLOCK ||
+ code == BEGIN_MACRO_PDF417_OPTIONAL_FIELD ||
+ code == MACRO_PDF417_TERMINATOR) {
+ codeIndex--;
+ end = TRUE;
+ }
+ }
+ if ((count % 5 == 0) && (count > 0)) {
+ FX_WORD* decodedData = FX_Alloc(FX_WORD, 6 * sizeof(FX_WORD));
+ FX_INT32 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;
+}
+FX_INT32 CBC_DecodedBitStreamPaser::numericCompaction(CFX_Int32Array &codewords, FX_INT32 codeIndex, CFX_ByteString &result, FX_INT32 &e)
+{
+ FX_INT32 count = 0;
+ FX_BOOL end = FALSE;
+ CFX_Int32Array numericCodewords;
+ numericCodewords.SetSize(MAX_NUMERIC_CODEWORDS);
+ while (codeIndex < codewords[0] && !end) {
+ FX_INT32 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, FX_INT32 count, FX_INT32 &e)
+{
+ BigInteger result = 0;
+ BigInteger nineHundred(900);
+ for (FX_INT32 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/src/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.h b/xfa/src/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.h new file mode 100644 index 0000000000..64ae2aee53 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417DecodedBitStreamParser.h @@ -0,0 +1,48 @@ +// 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 _BC_DECODEDBITSTREAMPARSER_H_
+#define _BC_DECODEDBITSTREAMPARSER_H_
+class CBC_CommonDecoderResult;
+class CBC_PDF417ResultMetadata;
+class CBC_DecodedBitStreamPaser;
+class CBC_DecodedBitStreamPaser : public CFX_Object
+{
+public:
+ CBC_DecodedBitStreamPaser();
+ virtual ~CBC_DecodedBitStreamPaser();
+ static void Initialize();
+ static void Finalize();
+ static CBC_CommonDecoderResult* decode(CFX_Int32Array &codewords, CFX_ByteString ecLevel, FX_INT32 &e);
+
+private:
+ enum Mode {
+ ALPHA,
+ LOWER,
+ MIXED,
+ PUNCT,
+ ALPHA_SHIFT,
+ PUNCT_SHIFT
+ };
+ static FX_INT32 MAX_NUMERIC_CODEWORDS;
+ static FX_INT32 PL;
+ static FX_INT32 LL;
+ static FX_INT32 AS;
+ static FX_INT32 ML;
+ static FX_INT32 AL;
+ static FX_INT32 PS;
+ static FX_INT32 PAL;
+ static FX_CHAR PUNCT_CHARS[29];
+ static FX_CHAR MIXED_CHARS[30];
+ static FX_INT32 NUMBER_OF_SEQUENCE_CODEWORDS;
+ static FX_INT32 decodeMacroBlock(CFX_Int32Array &codewords, FX_INT32 codeIndex, CBC_PDF417ResultMetadata* resultMetadata, FX_INT32 &e);
+ static FX_INT32 textCompaction(CFX_Int32Array &codewords, FX_INT32 codeIndex, CFX_ByteString &result);
+ static void decodeTextCompaction(CFX_Int32Array &textCompactionData, CFX_Int32Array &byteCompactionData, FX_INT32 length, CFX_ByteString &result);
+ static FX_INT32 byteCompaction(FX_INT32 mode, CFX_Int32Array &codewords, FX_INT32 codeIndex, CFX_ByteString &result);
+ static FX_INT32 numericCompaction(CFX_Int32Array &codewords, FX_INT32 codeIndex, CFX_ByteString &result, FX_INT32 &e);
+ static CFX_ByteString decodeBase900toBase10(CFX_Int32Array &codewords, FX_INT32 count, FX_INT32 &e);
+};
+#endif
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417DetectionResult.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417DetectionResult.cpp new file mode 100644 index 0000000000..af316f7660 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417DetectionResult.cpp @@ -0,0 +1,283 @@ +// 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 "../barcode.h"
+#include "BC_PDF417Codeword.h"
+#include "BC_PDF417BarcodeMetadata.h"
+#include "BC_PDF417BoundingBox.h"
+#include "BC_PDF417DetectionResultColumn.h"
+#include "BC_PDF417Common.h"
+#include "BC_PDF417DetectionResultRowIndicatorColumn.h"
+#include "BC_PDF417DetectionResult.h"
+FX_INT32 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 (FX_INT32 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));
+ FX_INT32 unadjustedCodewordCount = CBC_PDF417Common::MAX_CODEWORDS_IN_BARCODE;
+ FX_INT32 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(FX_INT32 barcodeColumn, CBC_DetectionResultColumn* detectionResultColumn)
+{
+ m_detectionResultColumns[barcodeColumn] = detectionResultColumn;
+}
+CBC_DetectionResultColumn* CBC_DetectionResult::getDetectionResultColumn(FX_INT32 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 (FX_INT32 codewordsRow = 0; codewordsRow < rowIndicatorColumn->getCodewords()->GetSize(); codewordsRow++) {
+ result += (FX_CHAR) codewordsRow;
+ for (FX_INT32 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 != NULL) {
+ ((CBC_DetectionResultRowIndicatorColumn*)detectionResultColumn)->adjustCompleteIndicatorColumnRowNumbers(*m_barcodeMetadata);
+ }
+}
+FX_INT32 CBC_DetectionResult::adjustRowNumbers()
+{
+ FX_INT32 unadjustedCount = adjustRowNumbersByRow();
+ if (unadjustedCount == 0) {
+ return 0;
+ }
+ for (FX_INT32 barcodeColumn = 1; barcodeColumn < m_barcodeColumnCount + 1; barcodeColumn++) {
+ CFX_PtrArray* codewords = ((CBC_DetectionResultColumn*)m_detectionResultColumns[barcodeColumn])->getCodewords();
+ for (FX_INT32 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;
+}
+FX_INT32 CBC_DetectionResult::adjustRowNumbersByRow()
+{
+ adjustRowNumbersFromBothRI();
+ FX_INT32 unadjustedCount = adjustRowNumbersFromLRI();
+ return unadjustedCount + adjustRowNumbersFromRRI();
+}
+FX_INT32 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 (FX_INT32 codewordsRow = 0; codewordsRow < LRIcodewords->GetSize(); codewordsRow++) {
+ if (LRIcodewords->GetAt(codewordsRow) != NULL &&
+ RRIcodewords->GetAt(codewordsRow) != NULL &&
+ ((CBC_Codeword*)LRIcodewords->GetAt(codewordsRow))->getRowNumber() == ((CBC_Codeword*)RRIcodewords->GetAt(codewordsRow))->getRowNumber()) {
+ for (FX_INT32 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;
+}
+FX_INT32 CBC_DetectionResult::adjustRowNumbersFromRRI()
+{
+ if (m_detectionResultColumns[m_barcodeColumnCount + 1] == NULL) {
+ return 0;
+ }
+ FX_INT32 unadjustedCount = 0;
+ CFX_PtrArray* codewords = ((CBC_DetectionResultColumn*) m_detectionResultColumns.GetAt(m_barcodeColumnCount + 1))->getCodewords();
+ for (FX_INT32 codewordsRow = 0; codewordsRow < codewords->GetSize(); codewordsRow++) {
+ if (codewords->GetAt(codewordsRow) == NULL) {
+ continue;
+ }
+ FX_INT32 rowIndicatorRowNumber = ((CBC_Codeword*)codewords->GetAt(codewordsRow))->getRowNumber();
+ FX_INT32 invalidRowCounts = 0;
+ for (FX_INT32 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 != NULL) {
+ invalidRowCounts = adjustRowNumberIfValid(rowIndicatorRowNumber, invalidRowCounts, codeword);
+ if (!codeword->hasValidRowNumber()) {
+ unadjustedCount++;
+ }
+ }
+ }
+ }
+ return unadjustedCount;
+}
+FX_INT32 CBC_DetectionResult::adjustRowNumbersFromLRI()
+{
+ if (m_detectionResultColumns[0] == NULL) {
+ return 0;
+ }
+ FX_INT32 unadjustedCount = 0;
+ CFX_PtrArray* codewords = ((CBC_DetectionResultColumn*)m_detectionResultColumns.GetAt(0))->getCodewords();
+ for (FX_INT32 codewordsRow = 0; codewordsRow < codewords->GetSize(); codewordsRow++) {
+ if (codewords->GetAt(codewordsRow) == NULL) {
+ continue;
+ }
+ FX_INT32 rowIndicatorRowNumber = ((CBC_Codeword*)codewords->GetAt(codewordsRow))->getRowNumber();
+ FX_INT32 invalidRowCounts = 0;
+ for (FX_INT32 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 != NULL) {
+ invalidRowCounts = adjustRowNumberIfValid(rowIndicatorRowNumber, invalidRowCounts, codeword);
+ if (!codeword->hasValidRowNumber()) {
+ unadjustedCount++;
+ }
+ }
+ }
+ }
+ return unadjustedCount;
+}
+FX_INT32 CBC_DetectionResult::adjustRowNumberIfValid(FX_INT32 rowIndicatorRowNumber, FX_INT32 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(FX_INT32 barcodeColumn, FX_INT32 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] != NULL) {
+ 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 (FX_INT32 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;
+}
+FX_INT32 CBC_DetectionResult::getBarcodeColumnCount()
+{
+ return m_barcodeColumnCount;
+}
+FX_INT32 CBC_DetectionResult::getBarcodeRowCount()
+{
+ return m_barcodeMetadata->getRowCount();
+}
+FX_INT32 CBC_DetectionResult::getBarcodeECLevel()
+{
+ return m_barcodeMetadata->getErrorCorrectionLevel();
+}
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417DetectionResult.h b/xfa/src/fxbarcode/pdf417/BC_PDF417DetectionResult.h new file mode 100644 index 0000000000..9c3401459b --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417DetectionResult.h @@ -0,0 +1,48 @@ +// 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 _BC_EDTECTIONRESULT_H_
+#define _BC_EDTECTIONRESULT_H_
+class CBC_BarcodeMetadata;
+class CBC_BoundingBox;
+class CBC_Codeword;
+class CBC_DetectionResultColumn;
+class CBC_DetectionResult;
+class CBC_DetectionResult : public CFX_Object
+{
+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(FX_INT32 barcodeColumn, CBC_DetectionResultColumn* detectionResultColumn);
+ CBC_DetectionResultColumn* getDetectionResultColumn(FX_INT32 barcodeColumn);
+ CFX_ByteString toString();
+
+ FX_INT32 getBarcodeColumnCount();
+ FX_INT32 getBarcodeRowCount();
+ FX_INT32 getBarcodeECLevel();
+private:
+ static FX_INT32 ADJUST_ROW_NUMBER_SKIP;
+ CBC_BarcodeMetadata* m_barcodeMetadata;
+ CFX_PtrArray m_detectionResultColumns;
+ CBC_BoundingBox* m_boundingBox;
+ FX_INT32 m_barcodeColumnCount;
+private:
+ void adjustIndicatorColumnRowNumbers(CBC_DetectionResultColumn* detectionResultColumn);
+ FX_INT32 adjustRowNumbers();
+ FX_INT32 adjustRowNumbersByRow();
+ FX_INT32 adjustRowNumbersFromBothRI();
+ FX_INT32 adjustRowNumbersFromRRI();
+ FX_INT32 adjustRowNumbersFromLRI();
+ static FX_INT32 adjustRowNumberIfValid(FX_INT32 rowIndicatorRowNumber, FX_INT32 invalidRowCounts, CBC_Codeword* codeword);
+ void adjustRowNumbers(FX_INT32 barcodeColumn, FX_INT32 codewordsRow, CFX_PtrArray* codewords);
+ static FX_BOOL adjustRowNumber(CBC_Codeword* codeword, CBC_Codeword* otherCodeword);
+
+
+};
+#endif
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417DetectionResultColumn.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417DetectionResultColumn.cpp new file mode 100644 index 0000000000..6d949b7640 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417DetectionResultColumn.cpp @@ -0,0 +1,107 @@ +// 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 "../barcode.h"
+#include "BC_PDF417Codeword.h"
+#include "BC_PDF417BoundingBox.h"
+#include "BC_PDF417DetectionResultColumn.h"
+FX_INT32 CBC_DetectionResultColumn::MAX_NEARBY_DISTANCE = 5;
+CBC_DetectionResultColumn::CBC_DetectionResultColumn(CBC_BoundingBox* boundingBox)
+{
+ m_boundingBox = boundingBox;
+ m_codewords = FX_NEW CFX_PtrArray;
+ m_codewords->SetSize(boundingBox->getMaxY() - boundingBox->getMinY() + 1);
+}
+CBC_DetectionResultColumn::~CBC_DetectionResultColumn()
+{
+ for (FX_INT32 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(FX_INT32 imageRow)
+{
+ CBC_Codeword* codeword = getCodeword(imageRow);
+ if (codeword != NULL) {
+ return codeword;
+ }
+ for (FX_INT32 i = 1; i < MAX_NEARBY_DISTANCE; i++) {
+ FX_INT32 nearImageRow = imageRowToCodewordIndex(imageRow) - i;
+ if (nearImageRow >= 0) {
+ codeword = (CBC_Codeword*)m_codewords->GetAt(nearImageRow);
+ if (codeword != NULL) {
+ return codeword;
+ }
+ }
+ nearImageRow = imageRowToCodewordIndex(imageRow) + i;
+ if (nearImageRow < m_codewords->GetSize()) {
+ codeword = (CBC_Codeword*)m_codewords->GetAt(nearImageRow);
+ if (codeword != NULL) {
+ return codeword;
+ }
+ }
+ }
+ return NULL;
+}
+FX_INT32 CBC_DetectionResultColumn::imageRowToCodewordIndex(FX_INT32 imageRow)
+{
+ return imageRow - m_boundingBox->getMinY();
+}
+FX_INT32 CBC_DetectionResultColumn::codewordIndexToImageRow(FX_INT32 codewordIndex)
+{
+ return m_boundingBox->getMinY() + codewordIndex;
+}
+void CBC_DetectionResultColumn::setCodeword(FX_INT32 imageRow, CBC_Codeword* codeword)
+{
+ m_codewords->SetAt(imageRowToCodewordIndex(imageRow), codeword);
+}
+CBC_Codeword* CBC_DetectionResultColumn::getCodeword(FX_INT32 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;
+ FX_INT32 row = 0;
+ for (FX_INT32 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/src/fxbarcode/pdf417/BC_PDF417DetectionResultColumn.h b/xfa/src/fxbarcode/pdf417/BC_PDF417DetectionResultColumn.h new file mode 100644 index 0000000000..eddc3bce6d --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417DetectionResultColumn.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 _BC_DETECTIONRESULTCOLUMN_H_
+#define _BC_DETECTIONRESULTCOLUMN_H_
+class CBC_Codeword;
+class CBC_BoundingBox;
+class CBC_DetectionResultColumn;
+class CBC_DetectionResultColumn : public CFX_Object
+{
+public:
+ CBC_DetectionResultColumn(CBC_BoundingBox* boundingBox);
+ virtual ~CBC_DetectionResultColumn();
+ CBC_Codeword* getCodewordNearby(FX_INT32 imageRow);
+ FX_INT32 imageRowToCodewordIndex(FX_INT32 imageRow);
+ FX_INT32 codewordIndexToImageRow(FX_INT32 codewordIndex);
+ void setCodeword(FX_INT32 imageRow, CBC_Codeword* codeword);
+ CBC_Codeword* getCodeword(FX_INT32 imageRow);
+ CBC_BoundingBox* getBoundingBox();
+ CFX_PtrArray* getCodewords();
+ CFX_ByteString toString();
+public:
+ CBC_BoundingBox* m_boundingBox;
+ CFX_PtrArray* m_codewords;
+private:
+ static FX_INT32 MAX_NEARBY_DISTANCE;
+};
+#endif
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417DetectionResultRowIndicatorColumn.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417DetectionResultRowIndicatorColumn.cpp new file mode 100644 index 0000000000..89e46a74cd --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417DetectionResultRowIndicatorColumn.cpp @@ -0,0 +1,241 @@ +// 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 "../barcode.h"
+#include "../BC_ResultPoint.h"
+#include "BC_PDF417BarcodeMetadata.h"
+#include "BC_PDF417BoundingBox.h"
+#include "BC_PDF417Codeword.h"
+#include "BC_PDF417BarcodeValue.h"
+#include "BC_PDF417Common.h"
+#include "BC_PDF417DetectionResultColumn.h"
+#include "BC_PDF417DetectionResultRowIndicatorColumn.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 (FX_INT32 i = 0; i < m_codewords->GetSize(); i++) {
+ CBC_Codeword * codeword = (CBC_Codeword*)m_codewords->GetAt(i);
+ if (codeword != NULL) {
+ codeword->setRowNumberAsRowIndicatorColumn();
+ }
+ }
+}
+FX_INT32 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();
+ FX_INT32 firstRow = imageRowToCodewordIndex((FX_INT32) top->GetY());
+ FX_INT32 lastRow = imageRowToCodewordIndex((FX_INT32) bottom->GetY());
+ FX_FLOAT averageRowHeight = (lastRow - firstRow) / (FX_FLOAT) barcodeMetadata.getRowCount();
+ FX_INT32 barcodeRow = -1;
+ FX_INT32 maxRowHeight = 1;
+ FX_INT32 currentRowHeight = 0;
+ for (FX_INT32 codewordsRow = firstRow; codewordsRow < lastRow; codewordsRow++) {
+ if (codewords->GetAt(codewordsRow) == NULL) {
+ continue;
+ }
+ CBC_Codeword* codeword = (CBC_Codeword*)codewords->GetAt(codewordsRow);
+ FX_INT32 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 {
+ FX_INT32 checkedRows;
+ if (maxRowHeight > 2) {
+ checkedRows = (maxRowHeight - 2) * rowDifference;
+ } else {
+ checkedRows = rowDifference;
+ }
+ FX_BOOL closePreviousCodewordFound = checkedRows >= codewordsRow;
+ for (FX_INT32 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 (FX_INT32) (averageRowHeight + 0.5);
+}
+CFX_Int32Array* CBC_DetectionResultRowIndicatorColumn::getRowHeights(FX_INT32 &e)
+{
+ CBC_BarcodeMetadata* barcodeMetadata = getBarcodeMetadata();
+ if (barcodeMetadata == NULL) {
+ e = BCExceptionCannotMetadata;
+ return NULL;
+ }
+ adjustIncompleteIndicatorColumnRowNumbers(*barcodeMetadata);
+ CFX_Int32Array* result = FX_NEW CFX_Int32Array;
+ result->SetSize(barcodeMetadata->getRowCount());
+ for (FX_INT32 i = 0; i < getCodewords()->GetSize(); i++) {
+ CBC_Codeword* codeword = (CBC_Codeword*)getCodewords()->GetAt(i);
+ if (codeword != NULL) {
+ result->SetAt(codeword->getRowNumber(), result->GetAt(codeword->getRowNumber()) + 1);
+ }
+ }
+ return result;
+}
+FX_INT32 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();
+ FX_INT32 firstRow = imageRowToCodewordIndex((FX_INT32) top->GetY());
+ FX_INT32 lastRow = imageRowToCodewordIndex((FX_INT32) bottom->GetY());
+ FX_FLOAT averageRowHeight = (lastRow - firstRow) / (FX_FLOAT) barcodeMetadata.getRowCount();
+ CFX_PtrArray* codewords = getCodewords();
+ FX_INT32 barcodeRow = -1;
+ FX_INT32 maxRowHeight = 1;
+ FX_INT32 currentRowHeight = 0;
+ for (FX_INT32 codewordsRow = firstRow; codewordsRow < lastRow; codewordsRow++) {
+ if (codewords->GetAt(codewordsRow) == NULL) {
+ continue;
+ }
+ CBC_Codeword* codeword = (CBC_Codeword*)codewords->GetAt(codewordsRow);
+ codeword->setRowNumberAsRowIndicatorColumn();
+ FX_INT32 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 (FX_INT32) (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 (FX_INT32 i = 0; i < codewords->GetSize(); i++) {
+ CBC_Codeword* codeword = (CBC_Codeword*)codewords->GetAt(i);
+ if (codeword == NULL) {
+ continue;
+ }
+ codeword->setRowNumberAsRowIndicatorColumn();
+ FX_INT32 rowIndicatorValue = codeword->getValue() % 30;
+ FX_INT32 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 = FX_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 (FX_INT32 codewordRow = 0; codewordRow < codewords->GetSize(); codewordRow++) {
+ CBC_Codeword* codeword = (CBC_Codeword*)codewords->GetAt(codewordRow);
+ if (codeword == NULL) {
+ continue;
+ }
+ FX_INT32 rowIndicatorValue = codeword->getValue() % 30;
+ FX_INT32 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/src/fxbarcode/pdf417/BC_PDF417DetectionResultRowIndicatorColumn.h b/xfa/src/fxbarcode/pdf417/BC_PDF417DetectionResultRowIndicatorColumn.h new file mode 100644 index 0000000000..fbdd0f0ec4 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417DetectionResultRowIndicatorColumn.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 _BC_DETECTIONRESULTROWINDICATORCOLUMN_H_
+#define _BC_DETECTIONRESULTROWINDICATORCOLUMN_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();
+ FX_INT32 adjustCompleteIndicatorColumnRowNumbers(CBC_BarcodeMetadata barcodeMetadata);
+ CFX_Int32Array* getRowHeights(FX_INT32 &e);
+ FX_INT32 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
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417Detector.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417Detector.cpp new file mode 100644 index 0000000000..8d1a86ec92 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417Detector.cpp @@ -0,0 +1,311 @@ +// 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 "../barcode.h"
+#include "../BC_ResultPoint.h"
+#include "../BC_BinaryBitmap.h"
+#include "../common/BC_CommonBitMatrix.h"
+#include "../common/BC_CommonBitArray.h"
+#include "BC_PDF417DetectorResult.h"
+#include "BC_PDF417Detector.h"
+#define INTERGER_MAX 2147483647
+FX_INT32 CBC_Detector::INDEXES_START_PATTERN[] = {0, 4, 1, 5};
+FX_INT32 CBC_Detector::INDEXES_STOP_PATTERN[] = {6, 2, 7, 3};
+FX_INT32 CBC_Detector::INTEGER_MATH_SHIFT = 8;
+FX_INT32 CBC_Detector::PATTERN_MATCH_RESULT_SCALE_FACTOR = 1 << INTEGER_MATH_SHIFT;
+FX_INT32 CBC_Detector::MAX_AVG_VARIANCE = (FX_INT32) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.42f);
+FX_INT32 CBC_Detector::MAX_INDIVIDUAL_VARIANCE = (FX_INT32) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.8f);
+FX_INT32 CBC_Detector::START_PATTERN[] = {8, 1, 1, 1, 1, 1, 1, 3};
+FX_INT32 CBC_Detector::STOP_PATTERN[] = {7, 1, 1, 3, 1, 1, 1, 2, 1};
+FX_INT32 CBC_Detector::MAX_PIXEL_DRIFT = 3;
+FX_INT32 CBC_Detector::MAX_PATTERN_DRIFT = 5;
+FX_INT32 CBC_Detector::SKIPPED_ROW_COUNT_MAX = 25;
+FX_INT32 CBC_Detector::ROW_STEP = 5;
+FX_INT32 CBC_Detector::BARCODE_MIN_HEIGHT = 10;
+CBC_Detector::CBC_Detector()
+{
+}
+CBC_Detector::~CBC_Detector()
+{
+}
+CBC_PDF417DetectorResult* CBC_Detector::detect(CBC_BinaryBitmap* image, FX_INT32 hints, FX_BOOL multiple, FX_INT32 &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 = FX_NEW CBC_PDF417DetectorResult(bitMatrix, barcodeCoordinates);
+ return detectorResult;
+}
+void CBC_Detector::rotate180(CBC_CommonBitMatrix* bitMatrix)
+{
+ FX_INT32 width = bitMatrix->GetWidth();
+ FX_INT32 height = bitMatrix->GetHeight();
+ CBC_CommonBitArray* firstRowBitArray = FX_NEW CBC_CommonBitArray(width);
+ CBC_CommonBitArray* secondRowBitArray = FX_NEW CBC_CommonBitArray(width);
+ CBC_CommonBitArray* tmpBitArray = FX_NEW CBC_CommonBitArray(width);
+ for (FX_INT32 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 = FX_NEW CBC_CommonBitArray(result->GetSize());
+ array->Clear();
+ FX_INT32 size = input->GetSize();
+ for (FX_INT32 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 = FX_NEW CFX_PtrArray;
+ FX_INT32 row = 0;
+ FX_INT32 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 (FX_INT32 i = 0; i < barcodeCoordinates->GetSize(); i++) {
+ CFX_PtrArray* barcodeCoordinate = (CFX_PtrArray*)barcodeCoordinates->GetAt(i);
+ if (barcodeCoordinate->GetAt(1) != NULL) {
+ row = row > ((CBC_ResultPoint*)barcodeCoordinate->GetAt(1))->GetY();
+ }
+ if (barcodeCoordinate->GetAt(3) != NULL) {
+ 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) != NULL) {
+ column = (FX_INT32) ((CBC_ResultPoint*)vertices->GetAt(2))->GetX();
+ row = (FX_INT32) ((CBC_ResultPoint*)vertices->GetAt(2))->GetY();
+ } else {
+ column = (FX_INT32) ((CBC_ResultPoint*)vertices->GetAt(4))->GetX();
+ row = (FX_INT32) ((CBC_ResultPoint*)vertices->GetAt(4))->GetY();
+ }
+ }
+ return barcodeCoordinates;
+}
+CFX_PtrArray* CBC_Detector::findVertices(CBC_CommonBitMatrix* matrix, FX_INT32 startRow, FX_INT32 startColumn)
+{
+ FX_INT32 height = matrix->GetHeight();
+ FX_INT32 width = matrix->GetWidth();
+ CFX_PtrArray* result = FX_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) != NULL) {
+ startColumn = (FX_INT32) ((CBC_ResultPoint*)result->GetAt(4))->GetX();
+ startRow = (FX_INT32) ((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, FX_INT32* destinationIndexes, FX_INT32 destinationLength)
+{
+ for (FX_INT32 i = 0; i < destinationLength; i++) {
+ result->SetAt(destinationIndexes[i], tmpResult->GetAt(i));
+ }
+}
+CFX_PtrArray* CBC_Detector::findRowsWithPattern(CBC_CommonBitMatrix* matrix, FX_INT32 height, FX_INT32 width, FX_INT32 startRow, FX_INT32 startColumn, FX_INT32* pattern, FX_INT32 patternLength)
+{
+ CFX_PtrArray* result = FX_NEW CFX_PtrArray;
+ result->SetSize(4);
+ FX_BOOL found = FALSE;
+ CFX_Int32Array counters;
+ counters.SetSize(patternLength);
+ for (; startRow < height; startRow += ROW_STEP) {
+ CFX_Int32Array* loc = findGuardPattern(matrix, startColumn, startRow, width, FALSE, pattern, patternLength, counters);
+ if (loc != NULL) {
+ while (startRow > 0) {
+ CFX_Int32Array* previousRowLoc = findGuardPattern(matrix, startColumn, --startRow, width, FALSE, pattern, patternLength, counters);
+ if (previousRowLoc != NULL) {
+ delete loc;
+ loc = previousRowLoc;
+ } else {
+ startRow++;
+ break;
+ }
+ }
+ result->SetAt(0, FX_NEW CBC_ResultPoint((FX_FLOAT)loc->GetAt(0), (FX_FLOAT)startRow));
+ result->SetAt(1, FX_NEW CBC_ResultPoint((FX_FLOAT)loc->GetAt(1), (FX_FLOAT)startRow));
+ found = TRUE;
+ delete loc;
+ break;
+ }
+ }
+ FX_INT32 stopRow = startRow + 1;
+ if (found) {
+ FX_INT32 skippedRowCount = 0;
+ CFX_Int32Array previousRowLoc;
+ previousRowLoc.Add((FX_INT32)((CBC_ResultPoint*)result->GetAt(0))->GetX());
+ previousRowLoc.Add((FX_INT32)((CBC_ResultPoint*)result->GetAt(1))->GetX());
+ for (; stopRow < height; stopRow++) {
+ CFX_Int32Array* loc = findGuardPattern(matrix, previousRowLoc[0], stopRow, width, FALSE, pattern, patternLength, counters);
+ if (loc != NULL &&
+ abs(previousRowLoc[0] - loc->GetAt(0)) < MAX_PATTERN_DRIFT &&
+ abs(previousRowLoc[1] - loc->GetAt(1)) < MAX_PATTERN_DRIFT) {
+ previousRowLoc.Copy(*loc);
+ skippedRowCount = 0;
+ } else {
+ if (skippedRowCount > SKIPPED_ROW_COUNT_MAX) {
+ delete loc;
+ break;
+ } else {
+ skippedRowCount++;
+ }
+ }
+ delete loc;
+ }
+ stopRow -= skippedRowCount + 1;
+ result->SetAt(2, FX_NEW CBC_ResultPoint((FX_FLOAT)previousRowLoc.GetAt(0), (FX_FLOAT)stopRow));
+ result->SetAt(3, FX_NEW CBC_ResultPoint((FX_FLOAT)previousRowLoc.GetAt(1), (FX_FLOAT)stopRow));
+ }
+ if (stopRow - startRow < BARCODE_MIN_HEIGHT) {
+ for (FX_INT32 i = 0; i < result->GetSize(); i++) {
+ result->SetAt(i, NULL);
+ }
+ }
+ return result;
+}
+CFX_Int32Array* CBC_Detector::findGuardPattern(CBC_CommonBitMatrix* matrix, FX_INT32 column, FX_INT32 row, FX_INT32 width, FX_BOOL whiteFirst, FX_INT32* pattern, FX_INT32 patternLength, CFX_Int32Array &counters)
+{
+ for (FX_INT32 i = 0; i < counters.GetSize(); i++) {
+ counters.SetAt(i, 0);
+ }
+ FX_BOOL isWhite = whiteFirst;
+ FX_INT32 patternStart = column;
+ FX_INT32 pixelDrift = 0;
+ CFX_Int32Array* intarray = FX_NEW CFX_Int32Array;
+ while (matrix->Get(patternStart, row) && patternStart > 0 && pixelDrift++ < MAX_PIXEL_DRIFT) {
+ patternStart--;
+ }
+ FX_INT32 x = patternStart;
+ FX_INT32 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 (FX_INT32 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;
+}
+FX_INT32 CBC_Detector::patternMatchVariance(CFX_Int32Array &counters, FX_INT32* pattern, FX_INT32 maxIndividualVariance)
+{
+ FX_INT32 numCounters = counters.GetSize();
+ FX_INT32 total = 0;
+ FX_INT32 patternLength = 0;
+ for (FX_INT32 i = 0; i < numCounters; i++) {
+ total += counters[i];
+ patternLength += pattern[i];
+ }
+ if (total < patternLength) {
+ return INTERGER_MAX;
+ }
+ FX_INT32 unitBarWidth = (total << INTEGER_MATH_SHIFT) / patternLength;
+ maxIndividualVariance = (maxIndividualVariance * unitBarWidth) >> INTEGER_MATH_SHIFT;
+ FX_INT32 totalVariance = 0;
+ for (FX_INT32 x = 0; x < numCounters; x++) {
+ FX_INT32 counter = counters[x] << INTEGER_MATH_SHIFT;
+ FX_INT32 scaledPattern = pattern[x] * unitBarWidth;
+ FX_INT32 variance = counter > scaledPattern ? counter - scaledPattern : scaledPattern - counter;
+ if (variance > maxIndividualVariance) {
+ return INTERGER_MAX;
+ }
+ totalVariance += variance;
+ }
+ return totalVariance / total;
+}
+
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417Detector.h b/xfa/src/fxbarcode/pdf417/BC_PDF417Detector.h new file mode 100644 index 0000000000..557559e1f7 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417Detector.h @@ -0,0 +1,43 @@ +// 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 _BC_DETECTOR_H_
+#define _BC_DETECTOR_H_
+class CBC_PDF417DetectorResult;
+class CBC_BinaryBitmap;
+class CBC_CommonBitMatrix;
+class CBC_CommonBitArray;
+class CBC_Detector;
+class CBC_Detector : public CFX_Object
+{
+public:
+ CBC_Detector();
+ virtual ~CBC_Detector();
+ static CBC_PDF417DetectorResult* detect(CBC_BinaryBitmap* image, FX_INT32 hints, FX_BOOL multiple, FX_INT32 &e);
+ static void rotate180(CBC_CommonBitMatrix* bitMatrix);
+ static CBC_CommonBitArray* mirror(CBC_CommonBitArray* input, CBC_CommonBitArray* result);
+private:
+ static FX_INT32 INDEXES_START_PATTERN[];
+ static FX_INT32 INDEXES_STOP_PATTERN[];
+ static FX_INT32 INTEGER_MATH_SHIFT;
+ static FX_INT32 PATTERN_MATCH_RESULT_SCALE_FACTOR;
+ static FX_INT32 MAX_AVG_VARIANCE;
+ static FX_INT32 MAX_INDIVIDUAL_VARIANCE;
+ static FX_INT32 START_PATTERN[];
+ static FX_INT32 STOP_PATTERN[];
+ static FX_INT32 MAX_PIXEL_DRIFT;
+ static FX_INT32 MAX_PATTERN_DRIFT;
+ static FX_INT32 SKIPPED_ROW_COUNT_MAX;
+ static FX_INT32 ROW_STEP;
+ static FX_INT32 BARCODE_MIN_HEIGHT;
+ static CFX_PtrArray* detect(FX_BOOL multiple, CBC_CommonBitMatrix* bitMatrix);
+ static CFX_PtrArray* findVertices(CBC_CommonBitMatrix* matrix, FX_INT32 startRow, FX_INT32 startColumn);
+ static void copyToResult(CFX_PtrArray* result, CFX_PtrArray* tmpResult, FX_INT32* destinationIndexes, FX_INT32 destinationLength);
+ static CFX_PtrArray* findRowsWithPattern(CBC_CommonBitMatrix* matrix, FX_INT32 height, FX_INT32 width, FX_INT32 startRow, FX_INT32 startColumn, FX_INT32* pattern, FX_INT32 patternLength);
+ static CFX_Int32Array* findGuardPattern(CBC_CommonBitMatrix* matrix, FX_INT32 column, FX_INT32 row, FX_INT32 width, FX_BOOL whiteFirst, FX_INT32* pattern, FX_INT32 patternLength, CFX_Int32Array &counters);
+ static FX_INT32 patternMatchVariance(CFX_Int32Array &counters, FX_INT32* pattern, FX_INT32 maxIndividualVariance);
+};
+#endif
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417DetectorResult.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417DetectorResult.cpp new file mode 100644 index 0000000000..e082290011 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417DetectorResult.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 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 "../barcode.h"
+#include "../common/BC_CommonBitMatrix.h"
+#include "../BC_ResultPoint.h"
+#include "BC_PDF417DetectorResult.h"
+CBC_PDF417DetectorResult::CBC_PDF417DetectorResult(CBC_CommonBitMatrix* bits, CFX_PtrArray* points)
+{
+ m_bits = bits;
+ m_points = points;
+}
+CBC_PDF417DetectorResult::~CBC_PDF417DetectorResult()
+{
+ for (FX_INT32 i = 0; i < m_points->GetSize(); i++) {
+ CFX_PtrArray* temp = (CFX_PtrArray*)m_points->GetAt(i);
+ for (FX_INT32 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/src/fxbarcode/pdf417/BC_PDF417DetectorResult.h b/xfa/src/fxbarcode/pdf417/BC_PDF417DetectorResult.h new file mode 100644 index 0000000000..ba557f1541 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417DetectorResult.h @@ -0,0 +1,22 @@ +// 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 _BC_PDF417DETECTORRESULT_H_
+#define _BC_PDF417DETECTORRESULT_H_
+class CBC_CommonBitMatrix;
+class CBC_PDF417DetectorResult;
+class CBC_PDF417DetectorResult : public CFX_Object
+{
+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
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417Dimensions.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417Dimensions.cpp new file mode 100644 index 0000000000..76d2e7bf88 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417Dimensions.cpp @@ -0,0 +1,51 @@ +// 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 "../barcode.h"
+#include "BC_PDF417Dimensions.h"
+CBC_Dimensions::CBC_Dimensions(FX_INT32 minCols, FX_INT32 maxCols, FX_INT32 minRows, FX_INT32 maxRows)
+{
+ m_minCols = minCols;
+ m_maxCols = maxCols;
+ m_minRows = minRows;
+ m_maxRows = maxRows;
+}
+CBC_Dimensions::~CBC_Dimensions()
+{
+}
+FX_INT32 CBC_Dimensions::getMinCols()
+{
+ return m_minCols;
+}
+FX_INT32 CBC_Dimensions::getMaxCols()
+{
+ return m_maxCols;
+}
+FX_INT32 CBC_Dimensions::getMinRows()
+{
+ return m_minRows;
+}
+FX_INT32 CBC_Dimensions::getMaxRows()
+{
+ return m_maxRows;
+}
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417Dimensions.h b/xfa/src/fxbarcode/pdf417/BC_PDF417Dimensions.h new file mode 100644 index 0000000000..6f8eaffed7 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417Dimensions.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 _BC_DIMENSIONS_H_
+#define _BC_DIMENSIONS_H_
+class CBC_Dimensions;
+class CBC_Dimensions : public CFX_Object
+{
+public:
+ CBC_Dimensions(FX_INT32 minCols, FX_INT32 maxCols, FX_INT32 minRows, FX_INT32 maxRows);
+ virtual ~CBC_Dimensions();
+ FX_INT32 getMinCols();
+ FX_INT32 getMaxCols();
+ FX_INT32 getMinRows();
+ FX_INT32 getMaxRows();
+private:
+ FX_INT32 m_minCols;
+ FX_INT32 m_maxCols;
+ FX_INT32 m_minRows;
+ FX_INT32 m_maxRows;
+};
+#endif
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417ECErrorCorrection.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417ECErrorCorrection.cpp new file mode 100644 index 0000000000..23207ef959 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417ECErrorCorrection.cpp @@ -0,0 +1,369 @@ +// 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 "../barcode.h"
+#include "BC_PDF417Common.h"
+#include "BC_PDF417ECModulusPoly.h"
+#include "BC_PDF417ECModulusGF.h"
+#include "BC_PDF417ECErrorCorrection.h"
+CBC_PDF417ECModulusGF* CBC_PDF417ECErrorCorrection::m_field = NULL;
+void CBC_PDF417ECErrorCorrection::Initialize(FX_INT32 &e)
+{
+ m_field = FX_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()
+{
+}
+FX_INT32 CBC_PDF417ECErrorCorrection::decode(CFX_Int32Array &received, FX_INT32 numECCodewords, CFX_Int32Array &erasures, FX_INT32 &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 (FX_INT32 l = numECCodewords; l > 0; l--) {
+ FX_INT32 eval = poly.evaluateAt(m_field->exp(l));
+ S[numECCodewords - l] = eval;
+ if (eval != 0) {
+ error = TRUE;
+ }
+ }
+ if (!error) {
+ return 0;
+ }
+ CBC_PDF417ECModulusPoly* syndrome = FX_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 (FX_INT32 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 (FX_INT32 i = 0; i < sigmaOmega->GetSize(); i++) {
+ delete (CBC_PDF417ECModulusPoly*)sigmaOmega->GetAt(i);
+ }
+ sigmaOmega->RemoveAll();
+ delete sigmaOmega;
+ return -1;
+ }
+ for (FX_INT32 i = 0; i < errorLocations->GetSize(); i++) {
+ FX_INT32 log = m_field->log(errorLocations->GetAt(i), e);;
+ BC_EXCEPTION_CHECK_ReturnValue(e, -1);
+ FX_INT32 position = received.GetSize() - 1 - log;
+ if (position < 0) {
+ e = BCExceptionChecksumException;
+ delete errorLocations;
+ delete errorMagnitudes;
+ for (FX_INT32 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));
+ }
+ FX_INT32 result = errorLocations->GetSize();
+ delete errorLocations;
+ delete errorMagnitudes;
+ for (FX_INT32 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, FX_INT32 R, FX_INT32 &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;
+ FX_INT32 i = 0;
+ FX_INT32 j = 0;
+ FX_INT32 m = 0;
+ FX_INT32 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();
+ FX_INT32 denominatorLeadingTerm = rLast->getCoefficient(rLast->getDegree());
+ FX_INT32 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()) {
+ FX_INT32 degreeDiff = r->getDegree() - rLast->getDegree();
+ FX_INT32 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++;
+ }
+ FX_INT32 aa = t->getCoefficient(1);
+ FX_INT32 sigmaTildeAtZero = t->getCoefficient(0);
+ if (sigmaTildeAtZero == 0) {
+ e = BCExceptionChecksumException;
+ if (rtemp) {
+ delete rtemp;
+ }
+ if (ttemp) {
+ delete ttemp;
+ }
+ return NULL;
+ }
+ FX_INT32 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 = FX_NEW CFX_PtrArray;
+ modulusPoly->Add(sigma);
+ modulusPoly->Add(omega);
+ return modulusPoly;
+}
+CFX_Int32Array* CBC_PDF417ECErrorCorrection::findErrorLocations(CBC_PDF417ECModulusPoly* errorLocator, FX_INT32 &e)
+{
+ FX_INT32 numErrors = errorLocator->getDegree();
+ CFX_Int32Array* result = FX_NEW CFX_Int32Array;
+ result->SetSize(numErrors);
+ FX_INT32 ee = 0;
+ for (FX_INT32 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, FX_INT32 &e)
+{
+ FX_INT32 errorLocatorDegree = errorLocator->getDegree();
+ CFX_Int32Array formalDerivativeCoefficients;
+ formalDerivativeCoefficients.SetSize(errorLocatorDegree);
+ for (FX_INT32 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);
+ FX_INT32 s = errorLocations.GetSize();
+ CFX_Int32Array* result = FX_NEW CFX_Int32Array;
+ result->SetSize(s);
+ for (FX_INT32 i = 0; i < s; i++) {
+ FX_INT32 xiInverse = m_field->inverse(errorLocations[i], e);
+ if (e != BCExceptionNO) {
+ delete result;
+ return NULL;
+ }
+ FX_INT32 numerator = m_field->subtract(0, errorEvaluator->evaluateAt(xiInverse));
+ FX_INT32 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/src/fxbarcode/pdf417/BC_PDF417ECErrorCorrection.h b/xfa/src/fxbarcode/pdf417/BC_PDF417ECErrorCorrection.h new file mode 100644 index 0000000000..4ce8eda7d6 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417ECErrorCorrection.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 _BC_PDF417ECERRORCORRECTION_H_
+#define _BC_PDF417ECERRORCORRECTION_H_
+class CBC_PDF417ECModulusGF;
+class CBC_PDF417ECModulusPoly;
+class CBC_PDF417ECErrorCorrection;
+class CBC_PDF417ECErrorCorrection : public CFX_Object
+{
+public:
+ CBC_PDF417ECErrorCorrection();
+ virtual ~CBC_PDF417ECErrorCorrection();
+ static void Initialize(FX_INT32 &e);
+ static void Finalize();
+ static FX_INT32 decode(CFX_Int32Array &received, FX_INT32 numECCodewords, CFX_Int32Array &erasures, FX_INT32 &e);
+private:
+ static CBC_PDF417ECModulusGF* m_field;
+ static CFX_PtrArray* runEuclideanAlgorithm(CBC_PDF417ECModulusPoly* a, CBC_PDF417ECModulusPoly* b, FX_INT32 R, FX_INT32 &e);
+ static CFX_Int32Array* findErrorLocations(CBC_PDF417ECModulusPoly* errorLocator, FX_INT32 &e);
+ static CFX_Int32Array* findErrorMagnitudes(CBC_PDF417ECModulusPoly* errorEvaluator, CBC_PDF417ECModulusPoly* errorLocator, CFX_Int32Array &errorLocations, FX_INT32 &e);
+};
+#endif
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417ECModulusGF.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417ECModulusGF.cpp new file mode 100644 index 0000000000..7619854bcb --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417ECModulusGF.cpp @@ -0,0 +1,126 @@ +// 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 "../barcode.h"
+#include "BC_PDF417Common.h"
+#include "BC_PDF417ECModulusPoly.h"
+#include "BC_PDF417ECModulusGF.h"
+CBC_PDF417ECModulusGF* CBC_PDF417ECModulusGF::PDF417_GF = NULL;
+void CBC_PDF417ECModulusGF::Initialize(FX_INT32 &e)
+{
+ PDF417_GF = FX_NEW CBC_PDF417ECModulusGF(CBC_PDF417Common::NUMBER_OF_CODEWORDS, 3, e);
+}
+void CBC_PDF417ECModulusGF::Finalize()
+{
+ delete PDF417_GF;
+}
+CBC_PDF417ECModulusGF::CBC_PDF417ECModulusGF(FX_INT32 modulus, FX_INT32 generator, FX_INT32 &e)
+{
+ m_modulus = modulus;
+ m_expTable.SetSize(modulus);
+ m_logTable.SetSize(modulus);
+ FX_INT32 x = 1;
+ for (FX_INT32 i = 0; i < modulus; i++) {
+ m_expTable[i] = x;
+ x = (x * generator) % modulus;
+ }
+ for (FX_INT32 j = 0; j < modulus - 1; j++) {
+ m_logTable[m_expTable[j]] = j;
+ }
+ CFX_Int32Array zero;
+ zero.Add(0);
+ m_zero = FX_NEW CBC_PDF417ECModulusPoly(this, zero, e);
+ CFX_Int32Array one;
+ one.Add(1);
+ m_one = FX_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(FX_INT32 degree, FX_INT32 coefficient, FX_INT32 &e)
+{
+ if (degree < 0) {
+ e = BCExceptionIllegalArgument;
+ return NULL;
+ }
+ CBC_PDF417ECModulusPoly* modulusPoly = NULL;
+ if (coefficient == 0) {
+ modulusPoly = FX_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 = FX_NEW CBC_PDF417ECModulusPoly(this, coefficients, e);
+ BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
+ return modulusPoly;
+}
+FX_INT32 CBC_PDF417ECModulusGF::add(FX_INT32 a, FX_INT32 b)
+{
+ return (a + b) % m_modulus;
+}
+FX_INT32 CBC_PDF417ECModulusGF::subtract(FX_INT32 a, FX_INT32 b)
+{
+ return (m_modulus + a - b) % m_modulus;
+}
+FX_INT32 CBC_PDF417ECModulusGF::exp(FX_INT32 a)
+{
+ return m_expTable[a];
+}
+FX_INT32 CBC_PDF417ECModulusGF::log(FX_INT32 a, FX_INT32 &e)
+{
+ if (a == 0) {
+ e = BCExceptionIllegalArgument;
+ return -1;
+ }
+ return m_logTable[a];
+}
+FX_INT32 CBC_PDF417ECModulusGF::inverse(FX_INT32 a, FX_INT32 &e)
+{
+ if (a == 0) {
+ e = BCExceptionIllegalArgument;
+ return -1;
+ }
+ return m_expTable[m_modulus - m_logTable[a] - 1];
+}
+FX_INT32 CBC_PDF417ECModulusGF::multiply(FX_INT32 a, FX_INT32 b)
+{
+ if (a == 0 || b == 0) {
+ return 0;
+ }
+ return m_expTable[(m_logTable[a] + m_logTable[b]) % (m_modulus - 1)];
+}
+FX_INT32 CBC_PDF417ECModulusGF::getSize()
+{
+ return m_modulus;
+}
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417ECModulusGF.h b/xfa/src/fxbarcode/pdf417/BC_PDF417ECModulusGF.h new file mode 100644 index 0000000000..7ebe33ecfd --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417ECModulusGF.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 _BC_PDF417ECMODULUSGF_H_
+#define _BC_PDF417ECMODULUSGF_H_
+class CBC_PDF417ECModulusPoly;
+class CBC_PDF417Common;
+class CBC_PDF417ECModulusGF;
+class CBC_PDF417ECModulusGF : public CFX_Object
+{
+public:
+ CBC_PDF417ECModulusGF(FX_INT32 modulus, FX_INT32 generator, FX_INT32 &e);
+ virtual ~CBC_PDF417ECModulusGF();
+ static void Initialize(FX_INT32 &e);
+ static void Finalize();
+ CBC_PDF417ECModulusPoly* getZero();
+ CBC_PDF417ECModulusPoly* getOne();
+ CBC_PDF417ECModulusPoly* buildMonomial(FX_INT32 degree, FX_INT32 coefficient, FX_INT32 &e);
+ FX_INT32 add(FX_INT32 a, FX_INT32 b);
+ FX_INT32 subtract(FX_INT32 a, FX_INT32 b);
+ FX_INT32 exp(FX_INT32 a);
+ FX_INT32 log(FX_INT32 a, FX_INT32 &e);
+ FX_INT32 inverse(FX_INT32 a, FX_INT32 &e);
+ FX_INT32 multiply(FX_INT32 a, FX_INT32 b);
+ FX_INT32 getSize();
+ static CBC_PDF417ECModulusGF* PDF417_GF;
+private:
+ CFX_Int32Array m_expTable;
+ CFX_Int32Array m_logTable;
+ CBC_PDF417ECModulusPoly* m_zero;
+ CBC_PDF417ECModulusPoly* m_one;
+ FX_INT32 m_modulus;
+};
+#endif
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417ECModulusPoly.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417ECModulusPoly.cpp new file mode 100644 index 0000000000..39d3fd8056 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417ECModulusPoly.cpp @@ -0,0 +1,316 @@ +// 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 "../barcode.h"
+#include "BC_PDF417Common.h"
+#include "BC_PDF417ECModulusGF.h"
+#include "BC_PDF417ECModulusPoly.h"
+CBC_PDF417ECModulusPoly::CBC_PDF417ECModulusPoly(CBC_PDF417ECModulusGF* field, CFX_Int32Array &coefficients, FX_INT32 &e)
+{
+ if (coefficients.GetSize() == 0) {
+ e = BCExceptionIllegalArgument;
+ }
+ m_field = field;
+ FX_INT32 coefficientsLength = coefficients.GetSize();
+ if (coefficientsLength > 1 && coefficients[0] == 0) {
+ FX_INT32 firstNonZero = 1;
+ while (firstNonZero < coefficientsLength && coefficients[firstNonZero] == 0) {
+ firstNonZero++;
+ }
+ if (firstNonZero == coefficientsLength) {
+ m_coefficients = field->getZero()->m_coefficients;
+ } else {
+ m_coefficients.SetSize(coefficientsLength - firstNonZero);
+ FX_INT32 l = 0;
+ for (FX_INT32 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;
+}
+FX_INT32 CBC_PDF417ECModulusPoly::getDegree()
+{
+ return m_coefficients.GetSize() - 1;
+}
+FX_BOOL CBC_PDF417ECModulusPoly::isZero()
+{
+ return m_coefficients[0] == 0;
+}
+FX_INT32 CBC_PDF417ECModulusPoly::getCoefficient(FX_INT32 degree)
+{
+ return m_coefficients[m_coefficients.GetSize() - 1 - degree];
+}
+FX_INT32 CBC_PDF417ECModulusPoly::evaluateAt(FX_INT32 a)
+{
+ if (a == 0) {
+ return getCoefficient(0);
+ }
+ FX_INT32 size = m_coefficients.GetSize();
+ if (a == 1) {
+ FX_INT32 result = 0;
+ for (FX_INT32 l = 0; l < m_coefficients.GetSize(); l++) {
+ FX_INT32 coefficient = m_coefficients.GetAt(l);
+ result = m_field->add(result, coefficient);
+ }
+ return result;
+ }
+ FX_INT32 result = m_coefficients[0];
+ for (FX_INT32 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, FX_INT32 &e)
+{
+ CBC_PDF417ECModulusPoly* modulusPoly = NULL;
+ if (isZero()) {
+ modulusPoly = FX_NEW CBC_PDF417ECModulusPoly(other->getField(), other->getCoefficients(), e);
+ BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
+ return modulusPoly;
+ }
+ if (other->isZero()) {
+ modulusPoly = FX_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());
+ FX_INT32 lengthDiff = largerCoefficients.GetSize() - smallerCoefficients.GetSize();
+ for (FX_INT32 l = 0; l < lengthDiff; l++) {
+ sumDiff.SetAt(l, largerCoefficients.GetAt(l));
+ }
+ for (FX_INT32 i = lengthDiff; i < largerCoefficients.GetSize(); i++) {
+ sumDiff[i] = m_field->add(smallerCoefficients[i - lengthDiff], largerCoefficients[i]);
+ }
+ modulusPoly = FX_NEW CBC_PDF417ECModulusPoly(m_field, sumDiff, e);
+ BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
+ return modulusPoly;
+}
+CBC_PDF417ECModulusPoly* CBC_PDF417ECModulusPoly::subtract(CBC_PDF417ECModulusPoly* other, FX_INT32 &e)
+{
+ CBC_PDF417ECModulusPoly* modulusPoly = NULL;
+ if (other->isZero()) {
+ modulusPoly = FX_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, FX_INT32 &e)
+{
+ CBC_PDF417ECModulusPoly* modulusPoly = NULL;
+ if (isZero() || other->isZero()) {
+ modulusPoly = FX_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);
+ FX_INT32 aLength = aCoefficients.GetSize();
+ CFX_Int32Array bCoefficients;
+ bCoefficients.Copy(other->m_coefficients);
+ FX_INT32 bLength = bCoefficients.GetSize();
+ CFX_Int32Array product;
+ product.SetSize(aLength + bLength - 1);
+ for (FX_INT32 i = 0; i < aLength; i++) {
+ FX_INT32 aCoeff = aCoefficients[i];
+ for (FX_INT32 j = 0; j < bLength; j++) {
+ product[i + j] = m_field->add(product[i + j], m_field->multiply(aCoeff, bCoefficients[j]));
+ }
+ }
+ modulusPoly = FX_NEW CBC_PDF417ECModulusPoly(m_field, product, e);
+ BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
+ return modulusPoly;
+}
+CBC_PDF417ECModulusPoly* CBC_PDF417ECModulusPoly::negative(FX_INT32 &e)
+{
+ FX_INT32 size = m_coefficients.GetSize();
+ CFX_Int32Array negativeCoefficients;
+ negativeCoefficients.SetSize(size);
+ for (FX_INT32 i = 0; i < size; i++) {
+ negativeCoefficients[i] = m_field->subtract(0, m_coefficients[i]);
+ }
+ CBC_PDF417ECModulusPoly* modulusPoly = FX_NEW CBC_PDF417ECModulusPoly(m_field, negativeCoefficients, e);
+ BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
+ return modulusPoly;
+}
+CBC_PDF417ECModulusPoly* CBC_PDF417ECModulusPoly::multiply(FX_INT32 scalar, FX_INT32 &e)
+{
+ CBC_PDF417ECModulusPoly* modulusPoly = NULL;
+ if (scalar == 0) {
+ modulusPoly = FX_NEW CBC_PDF417ECModulusPoly(m_field->getZero()->getField(), m_field->getZero()->getCoefficients(), e);
+ BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
+ return modulusPoly;
+ }
+ if (scalar == 1) {
+ modulusPoly = FX_NEW CBC_PDF417ECModulusPoly(m_field, m_coefficients, e);
+ BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
+ return modulusPoly;
+ }
+ FX_INT32 size = m_coefficients.GetSize();
+ CFX_Int32Array product;
+ product.SetSize(size);
+ for (FX_INT32 i = 0; i < size; i++) {
+ product[i] = m_field->multiply(m_coefficients[i], scalar);
+ }
+ modulusPoly = FX_NEW CBC_PDF417ECModulusPoly(m_field, product, e);
+ BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
+ return modulusPoly;
+}
+CBC_PDF417ECModulusPoly* CBC_PDF417ECModulusPoly::multiplyByMonomial(FX_INT32 degree, FX_INT32 coefficient, FX_INT32 &e)
+{
+ if (degree < 0) {
+ e = BCExceptionIllegalArgument;
+ return NULL;
+ }
+ CBC_PDF417ECModulusPoly* modulusPoly = NULL;
+ if (coefficient == 0) {
+ modulusPoly = FX_NEW CBC_PDF417ECModulusPoly(m_field->getZero()->m_field, m_field->getZero()->m_coefficients, e);
+ BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
+ return modulusPoly;
+ }
+ FX_INT32 size = m_coefficients.GetSize();
+ CFX_Int32Array product;
+ product.SetSize(size + degree);
+ for (FX_INT32 i = 0; i < size; i++) {
+ product[i] = m_field->multiply(m_coefficients[i], coefficient);
+ }
+ modulusPoly = FX_NEW CBC_PDF417ECModulusPoly(m_field, product, e);
+ BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
+ return modulusPoly;
+}
+CFX_PtrArray* CBC_PDF417ECModulusPoly::divide(CBC_PDF417ECModulusPoly* other, FX_INT32 &e)
+{
+ if (other->isZero()) {
+ e = BCExceptionDivideByZero;
+ return NULL;
+ }
+ CBC_PDF417ECModulusPoly* quotient = FX_NEW CBC_PDF417ECModulusPoly(m_field->getZero()->m_field, m_field->getZero()->m_coefficients, e);
+ BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
+ CBC_PDF417ECModulusPoly* remainder = FX_NEW CBC_PDF417ECModulusPoly(m_field, m_coefficients, e);
+ if (e != BCExceptionNO) {
+ delete quotient;
+ return NULL;
+ }
+ FX_INT32 denominatorLeadingTerm = other->getCoefficient(other->getDegree());
+ FX_INT32 inverseDenominatorLeadingTerm = m_field->inverse(denominatorLeadingTerm, e);
+ if (e != BCExceptionNO) {
+ delete quotient;
+ delete remainder;
+ return NULL;
+ }
+ while (remainder->getDegree() >= other->getDegree() && !remainder->isZero()) {
+ FX_INT32 degreeDifference = remainder->getDegree() - other->getDegree();
+ FX_INT32 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 = FX_NEW CFX_PtrArray;
+ modulusPoly->Add(quotient);
+ modulusPoly->Add(remainder);
+ return modulusPoly;
+}
+CFX_ByteString CBC_PDF417ECModulusPoly::toString()
+{
+ CFX_ByteString result;
+ for (FX_INT32 degree = getDegree(); degree >= 0; degree--) {
+ FX_INT32 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/src/fxbarcode/pdf417/BC_PDF417ECModulusPoly.h b/xfa/src/fxbarcode/pdf417/BC_PDF417ECModulusPoly.h new file mode 100644 index 0000000000..9a9d6c16f2 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417ECModulusPoly.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 _BC_PDF417ECMODULUSPOLY_H_
+#define _BC_PDF417ECMODULUSPOLY_H_
+class CBC_PDF417ECModulusGF;
+class CBC_PDF417ECModulusPoly;
+class CBC_PDF417ECModulusPoly : public CFX_Object
+{
+public:
+ CBC_PDF417ECModulusPoly(CBC_PDF417ECModulusGF* field, CFX_Int32Array &coefficients, FX_INT32 &e);
+ virtual ~CBC_PDF417ECModulusPoly();
+ CFX_Int32Array& getCoefficients();
+ CBC_PDF417ECModulusGF* getField();
+ FX_INT32 getDegree();
+ FX_BOOL isZero();
+ FX_INT32 getCoefficient(FX_INT32 degree);
+ FX_INT32 evaluateAt(FX_INT32 a);
+ CBC_PDF417ECModulusPoly* add(CBC_PDF417ECModulusPoly* other, FX_INT32 &e);
+ CBC_PDF417ECModulusPoly* subtract(CBC_PDF417ECModulusPoly* other, FX_INT32 &e);
+ CBC_PDF417ECModulusPoly* multiply(CBC_PDF417ECModulusPoly* other, FX_INT32 &e);
+ CBC_PDF417ECModulusPoly* negative(FX_INT32 &e);
+ CBC_PDF417ECModulusPoly* multiply(FX_INT32 scalar, FX_INT32 &e);
+ CBC_PDF417ECModulusPoly* multiplyByMonomial(FX_INT32 degree, FX_INT32 coefficient, FX_INT32 &e);
+ CFX_PtrArray* divide(CBC_PDF417ECModulusPoly* other, FX_INT32 &e);
+ CFX_ByteString toString();
+private:
+ CBC_PDF417ECModulusGF* m_field;
+ CFX_Int32Array m_coefficients;
+};
+#endif
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417ErrorCorrection.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417ErrorCorrection.cpp new file mode 100644 index 0000000000..cd1ea88046 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417ErrorCorrection.cpp @@ -0,0 +1,193 @@ +// 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 "../barcode.h"
+#include "BC_PDF417ErrorCorrection.h"
+FX_INT32 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()
+{
+}
+FX_INT32 CBC_PDF417ErrorCorrection::getErrorCorrectionCodewordCount(FX_INT32 errorCorrectionLevel, FX_INT32 &e)
+{
+ if (errorCorrectionLevel < 0 || errorCorrectionLevel > 8) {
+ e = BCExceptionErrorCorrectionLevelMustBeBetween0And8;
+ return -1;
+ }
+ return 1 << (errorCorrectionLevel + 1);
+}
+FX_INT32 CBC_PDF417ErrorCorrection::getRecommendedMinimumErrorCorrectionLevel(FX_INT32 n, FX_INT32 &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, FX_INT32 errorCorrectionLevel, FX_INT32 &e)
+{
+ FX_INT32 k = getErrorCorrectionCodewordCount(errorCorrectionLevel, e);
+ BC_EXCEPTION_CHECK_ReturnValue(e, (FX_WCHAR)' ');
+ FX_WCHAR* ech = FX_Alloc(FX_WCHAR, k * sizeof(FX_WCHAR));
+ FXSYS_memset32(ech, 0, k * sizeof(FX_WCHAR));
+ FX_INT32 sld = dataCodewords.GetLength();
+ for (FX_INT32 i = 0; i < sld; i++) {
+ FX_INT32 t1 = (dataCodewords.GetAt(i) + ech[k - 1]) % 929;
+ FX_INT32 t2;
+ FX_INT32 t3;
+ for (FX_INT32 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 (FX_INT32 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/src/fxbarcode/pdf417/BC_PDF417ErrorCorrection.h b/xfa/src/fxbarcode/pdf417/BC_PDF417ErrorCorrection.h new file mode 100644 index 0000000000..4e3aee8d26 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417ErrorCorrection.h @@ -0,0 +1,21 @@ +// 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 _BC_PDF417ERRORCORRECTION_H_
+#define _BC_PDF417ERRORCORRECTION_H_
+class CBC_PDF417ErrorCorrection;
+class CBC_PDF417ErrorCorrection : public CFX_Object
+{
+public:
+ CBC_PDF417ErrorCorrection();
+ virtual ~CBC_PDF417ErrorCorrection();
+ static FX_INT32 getErrorCorrectionCodewordCount(FX_INT32 errorCorrectionLevel, FX_INT32 &e);
+ static FX_INT32 getRecommendedMinimumErrorCorrectionLevel(FX_INT32 n, FX_INT32 &e);
+ static CFX_WideString generateErrorCorrection(CFX_WideString dataCodewords, FX_INT32 errorCorrectionLevel, FX_INT32 &e);
+private:
+ static FX_INT32 EC_COEFFICIENTS[][2500];
+};
+#endif
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417HighLevelEncoder.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417HighLevelEncoder.cpp new file mode 100644 index 0000000000..8ee21ea97e --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417HighLevelEncoder.cpp @@ -0,0 +1,420 @@ +// 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 "../barcode.h"
+#include "../BC_UtilCodingConvert.h"
+#include "../../../../third_party/bigint/BigIntegerLibrary.hh"
+#include "BC_PDF417Compaction.h"
+#include "BC_PDF417HighLevelEncoder.h"
+#define SUBMODE_ALPHA 0
+#define SUBMODE_LOWER 1
+#define SUBMODE_MIXED 2
+FX_INT32 CBC_PDF417HighLevelEncoder::TEXT_COMPACTION = 0;
+FX_INT32 CBC_PDF417HighLevelEncoder::BYTE_COMPACTION = 1;
+FX_INT32 CBC_PDF417HighLevelEncoder::NUMERIC_COMPACTION = 2;
+FX_INT32 CBC_PDF417HighLevelEncoder::SUBMODE_PUNCTUATION = 3;
+FX_INT32 CBC_PDF417HighLevelEncoder::LATCH_TO_TEXT = 900;
+FX_INT32 CBC_PDF417HighLevelEncoder::LATCH_TO_BYTE_PADDED = 901;
+FX_INT32 CBC_PDF417HighLevelEncoder::LATCH_TO_NUMERIC = 902;
+FX_INT32 CBC_PDF417HighLevelEncoder::SHIFT_TO_BYTE = 913;
+FX_INT32 CBC_PDF417HighLevelEncoder::LATCH_TO_BYTE = 924;
+FX_BYTE 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
+ };
+FX_BYTE 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
+ };
+FX_INT32 CBC_PDF417HighLevelEncoder::MIXED[128] = {0};
+FX_INT32 CBC_PDF417HighLevelEncoder::PUNCTUATION[128] = {0};
+void CBC_PDF417HighLevelEncoder::Initialize()
+{
+ Inverse();
+}
+void CBC_PDF417HighLevelEncoder::Finalize()
+{
+}
+CFX_WideString CBC_PDF417HighLevelEncoder::encodeHighLevel(CFX_WideString wideMsg, Compaction compaction, FX_INT32 &e)
+{
+ CFX_ByteString bytes;
+ CBC_UtilCodingConvert::UnicodeToUTF8(wideMsg, bytes);
+ CFX_WideString msg;
+ FX_INT32 len = bytes.GetLength();
+ for (FX_INT32 i = 0; i < len; i++) {
+ FX_WCHAR ch = (FX_WCHAR)(bytes.GetAt(i) & 0xff);
+ if (ch == '?' && bytes.GetAt(i) != '?') {
+ e = BCExceptionCharactersOutsideISO88591Encoding;
+ return (FX_LPWSTR)"";
+ }
+ msg += ch;
+ }
+ CFX_ByteArray byteArr;
+ for (FX_INT32 k = 0; k < bytes.GetLength(); k++) {
+ byteArr.Add(bytes.GetAt(k));
+ }
+ CFX_WideString sb;
+ len = msg.GetLength();
+ FX_INT32 p = 0;
+ FX_INT32 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 {
+ FX_INT32 encodingMode = LATCH_TO_TEXT;
+ while (p < len) {
+ FX_INT32 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 {
+ FX_INT32 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 {
+ FX_INT32 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()
+{
+ FX_BYTE i = 0;
+ FX_INT32 l = 0;
+ for (l = 0; l < sizeof(MIXED) / sizeof(MIXED[0]); l++) {
+ MIXED[l] = -1;
+ }
+ for (i = 0; i < sizeof(TEXT_MIXED_RAW) / sizeof(TEXT_MIXED_RAW[0]); i++) {
+ FX_BYTE b = TEXT_MIXED_RAW[i];
+ if (b > 0) {
+ MIXED[b] = i;
+ }
+ }
+ for (l = 0; l < sizeof(PUNCTUATION) / sizeof(PUNCTUATION[0]); l++) {
+ PUNCTUATION[l] = -1;
+ }
+ for (i = 0; i < sizeof(TEXT_PUNCTUATION_RAW) / sizeof(TEXT_PUNCTUATION_RAW[0]); i++) {
+ FX_BYTE b = TEXT_PUNCTUATION_RAW[i];
+ if (b > 0) {
+ PUNCTUATION[b] = i;
+ }
+ }
+}
+FX_INT32 CBC_PDF417HighLevelEncoder::encodeText(CFX_WideString msg, FX_INT32 startpos, FX_INT32 count, CFX_WideString &sb, FX_INT32 initialSubmode)
+{
+ CFX_WideString tmp;
+ FX_INT32 submode = initialSubmode;
+ FX_INT32 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)) {
+ FX_WCHAR a = MIXED[ch];
+ FX_INT32 b = (FX_INT32)a;
+ 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;
+ FX_INT32 len = tmp.GetLength();
+ for (FX_INT32 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, FX_INT32 startpos, FX_INT32 count, FX_INT32 startmode, CFX_WideString &sb)
+{
+ if (count == 1 && startmode == TEXT_COMPACTION) {
+ sb += (FX_WCHAR) SHIFT_TO_BYTE;
+ }
+ FX_INT32 idx = startpos;
+ FX_INT32 i = 0;
+ if (count >= 6) {
+ sb += (FX_WCHAR) LATCH_TO_BYTE;
+ FX_WCHAR chars[5];
+ while ((startpos + count - idx) >= 6) {
+ FX_INT64 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++) {
+ FX_INT32 ch = bytes->GetAt(i) & 0xff;
+ sb += (FX_WCHAR) ch;
+ }
+}
+void CBC_PDF417HighLevelEncoder::encodeNumeric(CFX_WideString msg, FX_INT32 startpos, FX_INT32 count, CFX_WideString &sb)
+{
+ FX_INT32 idx = 0;
+ BigInteger num900 = 900;
+ while (idx < count - 1) {
+ CFX_WideString tmp;
+ FX_INT32 len = 44 < count - idx ? 44 : count - idx;
+ CFX_ByteString part = ((FX_WCHAR)'1' + msg.Mid(startpos + idx, len)).UTF8Encode();
+ BigInteger bigint = stringToBigInteger(FX_LPCSTR(part));
+ do {
+ FX_INT32 c = (bigint % num900).toInt();
+ tmp += (FX_WCHAR)(c);
+ bigint = bigint / num900;
+ } while (!bigint.isZero());
+ for (FX_INT32 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);
+}
+FX_INT32 CBC_PDF417HighLevelEncoder::determineConsecutiveDigitCount(CFX_WideString msg, FX_INT32 startpos)
+{
+ FX_INT32 count = 0;
+ FX_INT32 len = msg.GetLength();
+ FX_INT32 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;
+}
+FX_INT32 CBC_PDF417HighLevelEncoder::determineConsecutiveTextCount(CFX_WideString msg, FX_INT32 startpos)
+{
+ FX_INT32 len = msg.GetLength();
+ FX_INT32 idx = startpos;
+ while (idx < len) {
+ FX_WCHAR ch = msg.GetAt(idx);
+ FX_INT32 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;
+}
+FX_INT32 CBC_PDF417HighLevelEncoder::determineConsecutiveBinaryCount(CFX_WideString msg, CFX_ByteArray* bytes, FX_INT32 startpos, FX_INT32 &e)
+{
+ FX_INT32 len = msg.GetLength();
+ FX_INT32 idx = startpos;
+ while (idx < len) {
+ FX_WCHAR ch = msg.GetAt(idx);
+ FX_INT32 numericCount = 0;
+ while (numericCount < 13 && isDigit(ch)) {
+ numericCount++;
+ FX_INT32 i = idx + numericCount;
+ if (i >= len) {
+ break;
+ }
+ ch = msg.GetAt(i);
+ }
+ if (numericCount >= 13) {
+ return idx - startpos;
+ }
+ FX_INT32 textCount = 0;
+ while (textCount < 5 && isText(ch)) {
+ textCount++;
+ FX_INT32 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/src/fxbarcode/pdf417/BC_PDF417HighLevelEncoder.h b/xfa/src/fxbarcode/pdf417/BC_PDF417HighLevelEncoder.h new file mode 100644 index 0000000000..ed962030ac --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417HighLevelEncoder.h @@ -0,0 +1,54 @@ +// 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 _BC_PDF417HIGHLEVELENCODER_H_
+#define _BC_PDF417HIGHLEVELENCODER_H_
+
+#include "BC_PDF417Compaction.h"
+
+class CBC_PDF417HighLevelEncoder : public CFX_Object
+{
+public:
+ static CFX_WideString encodeHighLevel(CFX_WideString msg, Compaction compaction, FX_INT32 &e);
+ static void Inverse();
+ static void Initialize();
+ static void Finalize();
+private:
+ static FX_INT32 TEXT_COMPACTION;
+ static FX_INT32 BYTE_COMPACTION;
+ static FX_INT32 NUMERIC_COMPACTION;
+ static FX_INT32 SUBMODE_PUNCTUATION;
+ static FX_INT32 LATCH_TO_TEXT;
+ static FX_INT32 LATCH_TO_BYTE_PADDED;
+ static FX_INT32 LATCH_TO_NUMERIC;
+ static FX_INT32 SHIFT_TO_BYTE;
+ static FX_INT32 LATCH_TO_BYTE;
+ static FX_BYTE TEXT_MIXED_RAW[];
+ static FX_BYTE TEXT_PUNCTUATION_RAW[];
+ static FX_INT32 MIXED[128];
+ static FX_INT32 PUNCTUATION[128];
+ static FX_INT32 encodeText(CFX_WideString msg, FX_INT32 startpos, FX_INT32 count, CFX_WideString &sb, FX_INT32 initialSubmode);
+ static void encodeBinary(CFX_ByteArray* bytes, FX_INT32 startpos, FX_INT32 count, FX_INT32 startmode, CFX_WideString &sb);
+ static void encodeNumeric(CFX_WideString msg, FX_INT32 startpos, FX_INT32 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 FX_INT32 determineConsecutiveDigitCount(CFX_WideString msg, FX_INT32 startpos);
+ static FX_INT32 determineConsecutiveTextCount(CFX_WideString msg, FX_INT32 startpos);
+ static FX_INT32 determineConsecutiveBinaryCount(CFX_WideString msg, CFX_ByteArray* bytes, FX_INT32 startpos, FX_INT32 &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
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417HighLevelEncoder_unittest.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417HighLevelEncoder_unittest.cpp new file mode 100644 index 0000000000..33c875366c --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417HighLevelEncoder_unittest.cpp @@ -0,0 +1,221 @@ +// 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 "BC_PDF417HighLevelEncoder.h" +#include "testing/gtest/include/gtest/gtest.h" +#include "testing/fx_string_testhelpers.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 }, + + // Blank string encodes as empty string. + { L" ", 0, 1, L"", 0 }, + + // Single 0 should encode as 10 base-900 == 10. + { L"0", 0, 1, L"", 0 }, // wrong - should be \u000a? + + // 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\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\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\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\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/src/fxbarcode/pdf417/BC_PDF417Reader.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417Reader.cpp new file mode 100644 index 0000000000..ed751cc4ba --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417Reader.cpp @@ -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
+// 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 "../barcode.h"
+#include "../BC_Reader.h"
+#include "../BC_BinaryBitmap.h"
+#include "../BC_ResultPoint.h"
+#include "../BC_BinaryBitmap.h"
+#include "../BC_DecoderResult.h"
+#include "../common/BC_CommonBitMatrix.h"
+#include "../common/BC_CommonBitArray.h"
+#include "../common/BC_CommonDecoderResult.h"
+#include "../common/BC_CommonBitMatrix.h"
+#include "BC_PDF417DetectorResult.h"
+#include "BC_PDF417Detector.h"
+#include "BC_PDF417DetectorResult.h"
+#include "BC_PDF417Codeword.h"
+#include "BC_PDF417Common.h"
+#include "BC_PDF417BarcodeValue.h"
+#include "BC_PDF417BarcodeMetadata.h"
+#include "BC_PDF417BoundingBox.h"
+#include "BC_PDF417DetectionResultColumn.h"
+#include "BC_PDF417DetectionResultRowIndicatorColumn.h"
+#include "BC_PDF417DetectionResult.h"
+#include "BC_PDF417DecodedBitStreamParser.h"
+#include "BC_PDF417CodewordDecoder.h"
+#include "BC_PDF417DecodedBitStreamParser.h"
+#include "BC_PDF417ECModulusPoly.h"
+#include "BC_PDF417ECModulusGF.h"
+#include "BC_PDF417ECErrorCorrection.h"
+#include "BC_PDF417DecodedBitStreamParser.h"
+#include "BC_PDF417ScanningDecoder.h"
+#include "BC_PDF417Reader.h"
+#define Integer_MAX_VALUE 2147483647
+CBC_PDF417Reader::CBC_PDF417Reader()
+{
+}
+CBC_PDF417Reader::~CBC_PDF417Reader()
+{
+}
+CFX_ByteString CBC_PDF417Reader::Decode(CBC_BinaryBitmap *image, FX_INT32 &e)
+{
+ return Decode(image, 0, e);
+}
+CFX_ByteString CBC_PDF417Reader::Decode(CBC_BinaryBitmap *image, FX_BOOL multiple, FX_INT32 hints, FX_INT32 &e)
+{
+ CFX_ByteString results;
+ CBC_PDF417DetectorResult* detectorResult = CBC_Detector::detect(image, hints, multiple, e);
+ BC_EXCEPTION_CHECK_ReturnValue(e, "");
+ for (FX_INT32 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, FX_INT32 hints, FX_INT32 &e)
+{
+ CFX_ByteString bs = Decode(image, FALSE, 0, e);
+ BC_EXCEPTION_CHECK_ReturnValue(e, "");
+ return bs;
+}
+FX_INT32 CBC_PDF417Reader::getMaxWidth(CBC_ResultPoint* p1, CBC_ResultPoint* p2)
+{
+ if (p1 == NULL || p2 == NULL) {
+ return 0;
+ }
+ return (FX_INT32) FXSYS_fabs(p1->GetX() - p2->GetX());
+}
+FX_INT32 CBC_PDF417Reader::getMinWidth(CBC_ResultPoint* p1, CBC_ResultPoint* p2)
+{
+ if (p1 == NULL || p2 == NULL) {
+ return Integer_MAX_VALUE;
+ }
+ return (FX_INT32) FXSYS_fabs(p1->GetX() - p2->GetX());
+}
+FX_INT32 CBC_PDF417Reader::getMaxCodewordWidth(CFX_PtrArray& p)
+{
+ FX_INT32 a = getMaxWidth((CBC_ResultPoint*)p.GetAt(6), (CBC_ResultPoint*)p.GetAt(2)) * CBC_PDF417Common::MODULES_IN_CODEWORD / CBC_PDF417Common::MODULES_IN_STOP_PATTERN;
+ FX_INT32 b = getMaxWidth((CBC_ResultPoint*)p.GetAt(7), (CBC_ResultPoint*)p.GetAt(3)) * CBC_PDF417Common::MODULES_IN_CODEWORD / CBC_PDF417Common::MODULES_IN_STOP_PATTERN;
+ FX_INT32 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;
+ FX_INT32 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;
+}
+FX_INT32 CBC_PDF417Reader::getMinCodewordWidth(CFX_PtrArray& p)
+{
+ FX_INT32 a = getMinWidth((CBC_ResultPoint*)p.GetAt(6), (CBC_ResultPoint*)p.GetAt(2)) * CBC_PDF417Common::MODULES_IN_CODEWORD / CBC_PDF417Common::MODULES_IN_STOP_PATTERN;
+ FX_INT32 b = getMinWidth((CBC_ResultPoint*)p.GetAt(7), (CBC_ResultPoint*)p.GetAt(3)) * CBC_PDF417Common::MODULES_IN_CODEWORD / CBC_PDF417Common::MODULES_IN_STOP_PATTERN;
+ FX_INT32 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;
+ FX_INT32 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/src/fxbarcode/pdf417/BC_PDF417Reader.h b/xfa/src/fxbarcode/pdf417/BC_PDF417Reader.h new file mode 100644 index 0000000000..e6c0236cf7 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417Reader.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 _BC_PDF417READER_H_
+#define _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, FX_INT32 &e);
+ CFX_ByteString Decode(CBC_BinaryBitmap *image, FX_BOOL multiple, FX_INT32 hints, FX_INT32 &e);
+ CFX_ByteString Decode(CBC_BinaryBitmap *image, FX_INT32 hints, FX_INT32 &e);
+private:
+ static FX_INT32 getMaxWidth(CBC_ResultPoint* p1, CBC_ResultPoint* p2);
+ static FX_INT32 getMinWidth(CBC_ResultPoint* p1, CBC_ResultPoint* p2);
+ static FX_INT32 getMaxCodewordWidth(CFX_PtrArray& p);
+ static FX_INT32 getMinCodewordWidth(CFX_PtrArray& p);
+};
+#endif
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417ResultMetadata.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417ResultMetadata.cpp new file mode 100644 index 0000000000..393ee2e75d --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417ResultMetadata.cpp @@ -0,0 +1,62 @@ +// 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 "../barcode.h"
+#include "BC_PDF417ResultMetadata.h"
+CBC_PDF417ResultMetadata::CBC_PDF417ResultMetadata()
+{
+}
+CBC_PDF417ResultMetadata::~CBC_PDF417ResultMetadata()
+{
+}
+FX_INT32 CBC_PDF417ResultMetadata::getSegmentIndex()
+{
+ return m_segmentIndex;
+}
+void CBC_PDF417ResultMetadata::setSegmentIndex(FX_INT32 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/src/fxbarcode/pdf417/BC_PDF417ResultMetadata.h b/xfa/src/fxbarcode/pdf417/BC_PDF417ResultMetadata.h new file mode 100644 index 0000000000..e6c7780304 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417ResultMetadata.h @@ -0,0 +1,29 @@ +// 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 _BC_PDF417READER_H_
+#define _BC_PDF417READER_H_
+class CBC_PDF417ResultMetadata;
+class CBC_PDF417ResultMetadata : public CFX_Object
+{
+public:
+ CBC_PDF417ResultMetadata();
+ virtual ~CBC_PDF417ResultMetadata();
+ FX_INT32 getSegmentIndex();
+ void setSegmentIndex(FX_INT32 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:
+ FX_INT32 m_segmentIndex;
+ CFX_ByteString m_fileId;
+ CFX_Int32Array m_optionalData;
+ FX_BOOL m_lastSegment;
+};
+#endif
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417ScanningDecoder.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417ScanningDecoder.cpp new file mode 100644 index 0000000000..2b127ceb07 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417ScanningDecoder.cpp @@ -0,0 +1,596 @@ +// 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 "../barcode.h"
+#include "../BC_DecoderResult.h"
+#include "../BC_ResultPoint.h"
+#include "../common/BC_CommonBitMatrix.h"
+#include "BC_PDF417Codeword.h"
+#include "BC_PDF417Common.h"
+#include "BC_PDF417BarcodeValue.h"
+#include "BC_PDF417BarcodeMetadata.h"
+#include "BC_PDF417BoundingBox.h"
+#include "BC_PDF417DetectionResultColumn.h"
+#include "BC_PDF417DetectionResultRowIndicatorColumn.h"
+#include "BC_PDF417DetectionResult.h"
+#include "BC_PDF417DecodedBitStreamParser.h"
+#include "BC_PDF417CodewordDecoder.h"
+#include "BC_PDF417DecodedBitStreamParser.h"
+#include "BC_PDF417ECModulusPoly.h"
+#include "BC_PDF417ECModulusGF.h"
+#include "BC_PDF417ECErrorCorrection.h"
+#include "BC_PDF417DecodedBitStreamParser.h"
+#include "BC_PDF417ScanningDecoder.h"
+FX_INT32 CBC_PDF417ScanningDecoder::CODEWORD_SKEW_SIZE = 2;
+FX_INT32 CBC_PDF417ScanningDecoder::MAX_ERRORS = 3;
+FX_INT32 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 = FX_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, FX_INT32 minCodewordWidth, FX_INT32 maxCodewordWidth, FX_INT32 &e)
+{
+ CBC_BoundingBox* boundingBox = FX_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 (FX_INT32 i = 0; i < 2; i++) {
+ if (imageTopLeft != NULL) {
+ leftRowIndicatorColumn = getRowIndicatorColumn(image, boundingBox, *imageTopLeft, TRUE, minCodewordWidth, maxCodewordWidth);
+ }
+ if (imageTopRight != NULL) {
+ 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;
+ }
+ }
+ FX_INT32 maxBarcodeColumn = detectionResult->getBarcodeColumnCount() + 1;
+ detectionResult->setDetectionResultColumn(0, leftRowIndicatorColumn);
+ detectionResult->setDetectionResultColumn(maxBarcodeColumn, rightRowIndicatorColumn);
+ FX_BOOL leftToRight = leftRowIndicatorColumn != NULL;
+ for (FX_INT32 barcodeColumnCount = 1; barcodeColumnCount <= maxBarcodeColumn; barcodeColumnCount++) {
+ FX_INT32 barcodeColumn = leftToRight ? barcodeColumnCount : maxBarcodeColumn - barcodeColumnCount;
+ if (detectionResult->getDetectionResultColumn(barcodeColumn) != NULL) {
+ continue;
+ }
+ CBC_DetectionResultColumn* detectionResultColumn = NULL;
+ if (barcodeColumn == 0 || barcodeColumn == maxBarcodeColumn) {
+ detectionResultColumn = FX_NEW CBC_DetectionResultRowIndicatorColumn(boundingBox, barcodeColumn == 0);
+ } else {
+ detectionResultColumn = FX_NEW CBC_DetectionResultColumn(boundingBox);
+ }
+ detectionResult->setDetectionResultColumn(barcodeColumn, detectionResultColumn);
+ FX_INT32 startColumn = -1;
+ FX_INT32 previousStartColumn = startColumn;
+ for (FX_INT32 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 != NULL) {
+ 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 (FX_INT32 row = 0; row < barcodeMatrix->GetSize(); row++) {
+ result += row;
+ FX_INT32 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, FX_INT32 &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 = FX_NEW CBC_DetectionResult(barcodeMetadata, boundingBox);
+ return detectionresult;
+}
+CBC_BoundingBox* CBC_PDF417ScanningDecoder::adjustBoundingBox(CBC_DetectionResultRowIndicatorColumn* rowIndicatorColumn, FX_INT32 &e)
+{
+ if (rowIndicatorColumn == NULL) {
+ return NULL;
+ }
+ CFX_Int32Array* rowHeights = rowIndicatorColumn->getRowHeights(e);
+ BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
+ FX_INT32 maxRowHeight = getMax(*rowHeights);
+ FX_INT32 missingStartRows = 0;
+ for (FX_INT32 i = 0; i < rowHeights->GetSize(); i++) {
+ FX_INT32 rowHeight = rowHeights->GetAt(i);
+ missingStartRows += maxRowHeight - rowHeight;
+ if (rowHeight > 0) {
+ break;
+ }
+ }
+ CFX_PtrArray* codewords = rowIndicatorColumn->getCodewords();
+ for (FX_INT32 row = 0; missingStartRows > 0 && codewords->GetAt(row) == NULL; row++) {
+ missingStartRows--;
+ }
+ FX_INT32 missingEndRows = 0;
+ for (FX_INT32 row1 = rowHeights->GetSize() - 1; row1 >= 0; row1--) {
+ missingEndRows += maxRowHeight - rowHeights->GetAt(row1);
+ if (rowHeights->GetAt(row1) > 0) {
+ break;
+ }
+ }
+ for (FX_INT32 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;
+}
+FX_INT32 CBC_PDF417ScanningDecoder::getMax(CFX_Int32Array& values)
+{
+ FX_INT32 maxValue = -1;
+ for (FX_INT32 i = 0; i < values.GetSize(); i++) {
+ FX_INT32 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, FX_INT32 minCodewordWidth, FX_INT32 maxCodewordWidth)
+{
+ CBC_DetectionResultRowIndicatorColumn* rowIndicatorColumn = FX_NEW CBC_DetectionResultRowIndicatorColumn(boundingBox, leftToRight);
+ for (FX_INT32 i = 0; i < 2; i++) {
+ FX_INT32 increment = i == 0 ? 1 : -1;
+ FX_INT32 startColumn = (FX_INT32) startPoint.GetX();
+ for (FX_INT32 imageRow = (FX_INT32) 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 != NULL) {
+ 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, FX_INT32 &e)
+{
+ CFX_Int32Array* numberOfCodewords = ((CBC_BarcodeValue*)((CFX_PtrArray*)barcodeMatrix->GetAt(0))->GetAt(1))->getValue();
+ FX_INT32 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, FX_INT32 &e)
+{
+ CFX_PtrArray* barcodeMatrix = createBarcodeMatrix(detectionResult);
+ adjustCodewordCount(detectionResult, barcodeMatrix, e);
+ if (e != BCExceptionNO) {
+ for (FX_INT32 i = 0; i < barcodeMatrix->GetSize(); i++) {
+ CFX_PtrArray* temp = (CFX_PtrArray*)barcodeMatrix->GetAt(i);
+ for (FX_INT32 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 (FX_INT32 row = 0; row < detectionResult->getBarcodeRowCount(); row++) {
+ for (FX_INT32 l = 0; l < detectionResult->getBarcodeColumnCount(); l++) {
+ CFX_Int32Array* values = ((CBC_BarcodeValue*)((CFX_PtrArray*)barcodeMatrix->GetAt(row))->GetAt(l + 1))->getValue();
+ FX_INT32 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 (FX_INT32 i = 0; i < ambiguousIndexValues.GetSize(); i++) {
+ ambiguousIndexValues.SetAt(i, ambiguousIndexValuesList.GetAt(i));
+ }
+ for (FX_INT32 l = 0; l < barcodeMatrix->GetSize(); l++) {
+ CFX_PtrArray* temp = (CFX_PtrArray*)barcodeMatrix->GetAt(l);
+ for (FX_INT32 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(FX_INT32 ecLevel, CFX_Int32Array &codewords, CFX_Int32Array &erasureArray, CFX_Int32Array &ambiguousIndexes,
+ CFX_PtrArray& ambiguousIndexValues, FX_INT32 &e)
+{
+ CFX_Int32Array ambiguousIndexCount;
+ ambiguousIndexCount.SetSize(ambiguousIndexes.GetSize());
+ FX_INT32 tries = 100;
+ while (tries-- > 0) {
+ for (FX_INT32 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 (FX_INT32 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 = FX_NEW CFX_PtrArray;
+ barcodeMatrix->SetSize(detectionResult->getBarcodeRowCount());
+ CFX_PtrArray* temp = NULL;
+ FX_INT32 colume = 0;
+ for (FX_INT32 row = 0; row < barcodeMatrix->GetSize(); row++) {
+ temp = FX_NEW CFX_PtrArray;
+ temp->SetSize(detectionResult->getBarcodeColumnCount() + 2);
+ for (colume = 0; colume < detectionResult->getBarcodeColumnCount() + 2; colume++) {
+ temp->SetAt(colume, FX_NEW CBC_BarcodeValue());
+ }
+ barcodeMatrix->SetAt(row, temp);
+ }
+ colume = -1;
+ for (FX_INT32 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 (FX_INT32 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, FX_INT32 barcodeColumn)
+{
+ return barcodeColumn >= 0 && barcodeColumn <= detectionResult->getBarcodeColumnCount() + 1;
+}
+FX_INT32 CBC_PDF417ScanningDecoder::getStartColumn(CBC_DetectionResult* detectionResult, FX_INT32 barcodeColumn, FX_INT32 imageRow, FX_BOOL leftToRight)
+{
+ FX_INT32 offset = leftToRight ? 1 : -1;
+ CBC_Codeword* codeword = NULL;
+ if (isValidBarcodeColumn(detectionResult, barcodeColumn - offset)) {
+ codeword = detectionResult->getDetectionResultColumn(barcodeColumn - offset)->getCodeword(imageRow);
+ }
+ if (codeword != NULL) {
+ return leftToRight ? codeword->getEndX() : codeword->getStartX();
+ }
+ codeword = detectionResult->getDetectionResultColumn(barcodeColumn)->getCodewordNearby(imageRow);
+ if (codeword != NULL) {
+ return leftToRight ? codeword->getStartX() : codeword->getEndX();
+ }
+ if (isValidBarcodeColumn(detectionResult, barcodeColumn - offset)) {
+ codeword = detectionResult->getDetectionResultColumn(barcodeColumn - offset)->getCodewordNearby(imageRow);
+ }
+ if (codeword != NULL) {
+ return leftToRight ? codeword->getEndX() : codeword->getStartX();
+ }
+ FX_INT32 skippedColumns = 0;
+ while (isValidBarcodeColumn(detectionResult, barcodeColumn - offset)) {
+ barcodeColumn -= offset;
+ for (FX_INT32 i = 0; i < detectionResult->getDetectionResultColumn(barcodeColumn)->getCodewords()->GetSize(); i++) {
+ CBC_Codeword* previousRowCodeword = (CBC_Codeword*) detectionResult->getDetectionResultColumn(barcodeColumn)->getCodewords()->GetAt(i);
+ if (previousRowCodeword != NULL) {
+ 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, FX_INT32 minColumn, FX_INT32 maxColumn, FX_BOOL leftToRight, FX_INT32 startColumn,
+ FX_INT32 imageRow, FX_INT32 minCodewordWidth, FX_INT32 maxCodewordWidth)
+{
+ startColumn = adjustCodewordStartColumn(image, minColumn, maxColumn, leftToRight, startColumn, imageRow);
+ CFX_Int32Array* moduleBitCount = getModuleBitCount(image, minColumn, maxColumn, leftToRight, startColumn, imageRow);
+ if (moduleBitCount == NULL) {
+ return NULL;
+ }
+ FX_INT32 endColumn;
+ FX_INT32 codewordBitCount = CBC_PDF417Common::getBitCountSum(*moduleBitCount);
+ if (leftToRight) {
+ endColumn = startColumn + codewordBitCount;
+ } else {
+ for (FX_INT32 i = 0; i < moduleBitCount->GetSize() >> 1; i++) {
+ FX_INT32 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;
+ }
+ FX_INT32 decodedValue = CBC_PDF417CodewordDecoder::getDecodedValue(*moduleBitCount);
+ FX_INT32 codeword = CBC_PDF417Common::getCodeword(decodedValue);
+ delete moduleBitCount;
+ if (codeword == -1) {
+ return NULL;
+ }
+ return FX_NEW CBC_Codeword(startColumn, endColumn, getCodewordBucketNumber(decodedValue), codeword);
+}
+CFX_Int32Array* CBC_PDF417ScanningDecoder::getModuleBitCount(CBC_CommonBitMatrix* image, FX_INT32 minColumn, FX_INT32 maxColumn, FX_BOOL leftToRight, FX_INT32 startColumn, FX_INT32 imageRow)
+{
+ FX_INT32 imageColumn = startColumn;
+ CFX_Int32Array* moduleBitCount = FX_NEW CFX_Int32Array;
+ moduleBitCount->SetSize(8);
+ FX_INT32 moduleNumber = 0;
+ FX_INT32 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;
+}
+FX_INT32 CBC_PDF417ScanningDecoder::getNumberOfECCodeWords(FX_INT32 barcodeECLevel)
+{
+ return 2 << barcodeECLevel;
+}
+FX_INT32 CBC_PDF417ScanningDecoder::adjustCodewordStartColumn(CBC_CommonBitMatrix* image, FX_INT32 minColumn, FX_INT32 maxColumn, FX_BOOL leftToRight, FX_INT32 codewordStartColumn, FX_INT32 imageRow)
+{
+ FX_INT32 correctedStartColumn = codewordStartColumn;
+ FX_INT32 increment = leftToRight ? -1 : 1;
+ for (FX_INT32 i = 0; i < 2; i++) {
+ FX_BOOL l = image->Get(correctedStartColumn, imageRow);
+ 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(FX_INT32 codewordSize, FX_INT32 minCodewordWidth, FX_INT32 maxCodewordWidth)
+{
+ return minCodewordWidth - CODEWORD_SKEW_SIZE <= codewordSize && codewordSize <= maxCodewordWidth + CODEWORD_SKEW_SIZE;
+}
+CBC_CommonDecoderResult* CBC_PDF417ScanningDecoder::decodeCodewords(CFX_Int32Array &codewords, FX_INT32 ecLevel, CFX_Int32Array &erasures, FX_INT32 &e)
+{
+ if (codewords.GetSize() == 0) {
+ e = BCExceptionFormatInstance;
+ return NULL;
+ }
+ FX_INT32 numECCodewords = 1 << (ecLevel + 1);
+ FX_INT32 correctedErrorsCount = 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;
+}
+FX_INT32 CBC_PDF417ScanningDecoder::correctErrors(CFX_Int32Array &codewords, CFX_Int32Array &erasures, FX_INT32 numECCodewords, FX_INT32 &e)
+{
+ if ((erasures.GetSize() != 0 && erasures.GetSize() > (numECCodewords / 2 + MAX_ERRORS)) || numECCodewords < 0 || numECCodewords > MAX_EC_CODEWORDS) {
+ e = BCExceptionChecksumInstance;
+ return -1;
+ }
+ FX_INT32 result = CBC_PDF417ECErrorCorrection::decode(codewords, numECCodewords, erasures, e);
+ BC_EXCEPTION_CHECK_ReturnValue(e, -1);
+ return result;
+}
+void CBC_PDF417ScanningDecoder::verifyCodewordCount(CFX_Int32Array &codewords, FX_INT32 numECCodewords, FX_INT32 &e)
+{
+ if (codewords.GetSize() < 4) {
+ e = BCExceptionFormatInstance;
+ return;
+ }
+ FX_INT32 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(FX_INT32 codeword)
+{
+ CFX_Int32Array* result = FX_NEW CFX_Int32Array;
+ result->SetSize(8);
+ FX_INT32 previousValue = 0;
+ FX_INT32 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;
+}
+FX_INT32 CBC_PDF417ScanningDecoder::getCodewordBucketNumber(FX_INT32 codeword)
+{
+ CFX_Int32Array* array = getBitCountForCodeword(codeword);
+ FX_INT32 result = getCodewordBucketNumber(*array);
+ delete array;
+ return result;
+}
+FX_INT32 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/src/fxbarcode/pdf417/BC_PDF417ScanningDecoder.h b/xfa/src/fxbarcode/pdf417/BC_PDF417ScanningDecoder.h new file mode 100644 index 0000000000..924e5f798a --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417ScanningDecoder.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 _BC_PDF417SCANNINGDECODER_H_
+#define _BC_PDF417SCANNINGDECODER_H_
+class CBC_CommonDecoderResult;
+class CBC_CommonBitMatrix;
+class CBC_ErrorCorrection;
+class CBC_Codeword;
+class CBC_BoundingBox;
+class CBC_ResultPoint;
+class CBC_BarcodeMetadata;
+class CBC_BarcodeValue;
+class CBC_DetectionResult;
+class CBC_DetectionResultRowIndicatorColumn;
+class CBC_PDF417ScanningDecoder;
+class CBC_PDF417ScanningDecoder : public CFX_Object
+{
+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, FX_INT32 minCodewordWidth, FX_INT32 maxCodewordWidth, FX_INT32 &e);
+ static CFX_ByteString toString(CFX_PtrArray* barcodeMatrix);
+private:
+ static FX_INT32 CODEWORD_SKEW_SIZE;
+ static FX_INT32 MAX_ERRORS;
+ static FX_INT32 MAX_EC_CODEWORDS;
+ static CBC_PDF417ECErrorCorrection* errorCorrection;
+ static CBC_DetectionResult* merge(CBC_DetectionResultRowIndicatorColumn* leftRowIndicatorColumn, CBC_DetectionResultRowIndicatorColumn* rightRowIndicatorColumn, FX_INT32 &e);
+ static CBC_BoundingBox* adjustBoundingBox(CBC_DetectionResultRowIndicatorColumn* rowIndicatorColumn, FX_INT32 &e);
+ static FX_INT32 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, FX_INT32 minCodewordWidth, FX_INT32 maxCodewordWidth);
+ static void adjustCodewordCount(CBC_DetectionResult* detectionResult, CFX_PtrArray* barcodeMatrix, FX_INT32 &e);
+ static CBC_CommonDecoderResult* createDecoderResult(CBC_DetectionResult* detectionResult, FX_INT32 &e);
+ static CBC_CommonDecoderResult* createDecoderResultFromAmbiguousValues(FX_INT32 ecLevel, CFX_Int32Array &codewords, CFX_Int32Array &erasureArray, CFX_Int32Array &ambiguousIndexes,
+ CFX_PtrArray& ambiguousIndexValues, FX_INT32 &e);
+ static CFX_PtrArray* createBarcodeMatrix(CBC_DetectionResult* detectionResult);
+ static FX_BOOL isValidBarcodeColumn(CBC_DetectionResult* detectionResult, FX_INT32 barcodeColumn);
+ static FX_INT32 getStartColumn(CBC_DetectionResult* detectionResult, FX_INT32 barcodeColumn, FX_INT32 imageRow, FX_BOOL leftToRight);
+ static CBC_Codeword* detectCodeword(CBC_CommonBitMatrix* image, FX_INT32 minColumn, FX_INT32 maxColumn, FX_BOOL leftToRight, FX_INT32 startColumn,
+ FX_INT32 imageRow, FX_INT32 minCodewordWidth, FX_INT32 maxCodewordWidth);
+ static CFX_Int32Array* getModuleBitCount(CBC_CommonBitMatrix* image, FX_INT32 minColumn, FX_INT32 maxColumn, FX_BOOL leftToRight, FX_INT32 startColumn, FX_INT32 imageRow);
+ static FX_INT32 getNumberOfECCodeWords(FX_INT32 barcodeECLevel);
+ static FX_INT32 adjustCodewordStartColumn(CBC_CommonBitMatrix* image, FX_INT32 minColumn, FX_INT32 maxColumn, FX_BOOL leftToRight, FX_INT32 codewordStartColumn, FX_INT32 imageRow);
+ static FX_BOOL checkCodewordSkew(FX_INT32 codewordSize, FX_INT32 minCodewordWidth, FX_INT32 maxCodewordWidth);
+ static CBC_CommonDecoderResult* decodeCodewords(CFX_Int32Array &codewords, FX_INT32 ecLevel, CFX_Int32Array &erasures, FX_INT32 &e);
+ static FX_INT32 correctErrors(CFX_Int32Array &codewords, CFX_Int32Array &erasures, FX_INT32 numECCodewords, FX_INT32 &e);
+ static void verifyCodewordCount(CFX_Int32Array &codewords, FX_INT32 numECCodewords, FX_INT32 &e);
+ static CFX_Int32Array* getBitCountForCodeword(FX_INT32 codeword);
+ static FX_INT32 getCodewordBucketNumber(FX_INT32 codeword);
+ static FX_INT32 getCodewordBucketNumber(CFX_Int32Array& moduleBitCount);
+};
+#endif
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417Writer.cpp b/xfa/src/fxbarcode/pdf417/BC_PDF417Writer.cpp new file mode 100644 index 0000000000..86951c91e9 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417Writer.cpp @@ -0,0 +1,126 @@ +// 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 "../barcode.h"
+#include "../BC_TwoDimWriter.h"
+#include "../common/BC_CommonBitArray.h"
+#include "../common/BC_CommonBitMatrix.h"
+#include "BC_PDF417Compaction.h"
+#include "BC_PDF417.h"
+#include "BC_PDF417BarcodeMatrix.h"
+#include "BC_PDF417Writer.h"
+CBC_PDF417Writer::CBC_PDF417Writer()
+{
+ m_bFixedSize = FALSE;
+}
+CBC_PDF417Writer::~CBC_PDF417Writer()
+{
+ m_bTruncated = TRUE;
+}
+FX_BOOL CBC_PDF417Writer:: SetErrorCorrectionLevel(FX_INT32 level)
+{
+ if (level < 0 || level > 8) {
+ return FALSE;
+ }
+ m_iCorrectLevel = level;
+ return TRUE;
+}
+void CBC_PDF417Writer::SetTruncated(FX_BOOL truncated)
+{
+ m_bTruncated = truncated;
+}
+FX_BYTE* CBC_PDF417Writer::Encode(const CFX_ByteString &contents, BCFORMAT format, FX_INT32 &outWidth, FX_INT32 &outHeight, FX_INT32 &e)
+{
+ if ( format != BCFORMAT_PDF_417) {
+ return NULL;
+ }
+ CFX_WideString encodeContents = contents.UTF8Decode();
+ return Encode(encodeContents, outWidth, outHeight, e );
+}
+FX_BYTE* CBC_PDF417Writer::Encode(const CFX_ByteString &contents, BCFORMAT format, FX_INT32 &outWidth, FX_INT32 &outHeight, FX_INT32 hints, FX_INT32 &e)
+{
+ return NULL;
+}
+FX_BYTE* CBC_PDF417Writer::Encode(const CFX_WideString &contents, FX_INT32 &outWidth, FX_INT32 &outHeight, FX_INT32 &e)
+{
+ CBC_PDF417 encoder;
+ FX_INT32 col = (m_Width / m_ModuleWidth - 69) / 17;
+ FX_INT32 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);
+ FX_INT32 lineThickness = 2;
+ FX_INT32 aspectRatio = 4;
+ CBC_BarcodeMatrix* barcodeMatrix = encoder.getBarcodeMatrix();
+ CFX_ByteArray originalScale;
+ originalScale.Copy(barcodeMatrix->getScaledMatrix(lineThickness, aspectRatio * lineThickness));
+ FX_INT32 width = outWidth;
+ FX_INT32 height = outHeight;
+ outWidth = barcodeMatrix->getWidth();
+ outHeight = barcodeMatrix->getHeight();
+ FX_BOOL rotated = FALSE;
+ if ((height > width) ^ (outWidth < outHeight)) {
+ rotateArray(originalScale, outHeight, outWidth);
+ rotated = TRUE;
+ FX_INT32 temp = outHeight;
+ outHeight = outWidth;
+ outWidth = temp;
+ }
+ FX_INT32 scaleX = width / outWidth;
+ FX_INT32 scaleY = height / outHeight;
+ FX_INT32 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);
+ FX_INT32 temp = outHeight;
+ outHeight = outWidth;
+ outWidth = temp;
+ }
+ }
+ FX_BYTE* result = (FX_BYTE*)FX_Alloc(FX_BYTE, outHeight * outWidth);
+ FXSYS_memcpy32(result, originalScale.GetData(), outHeight * outWidth);
+ return result;
+}
+void CBC_PDF417Writer::rotateArray(CFX_ByteArray& bitarray, FX_INT32 height, FX_INT32 width)
+{
+ CFX_ByteArray temp;
+ temp.Copy(bitarray);
+ for (FX_INT32 ii = 0; ii < height; ii++) {
+ FX_INT32 inverseii = height - ii - 1;
+ for (FX_INT32 jj = 0; jj < width; jj++) {
+ bitarray[jj * height + inverseii] = temp[ii * width + jj];
+ }
+ }
+}
diff --git a/xfa/src/fxbarcode/pdf417/BC_PDF417Writer.h b/xfa/src/fxbarcode/pdf417/BC_PDF417Writer.h new file mode 100644 index 0000000000..5d974f9377 --- /dev/null +++ b/xfa/src/fxbarcode/pdf417/BC_PDF417Writer.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 _BC_PDF417WRITER_H_
+#define _BC_PDF417WRITER_H_
+class CBC_TwoDimWriter;
+class CBC_PDF417Writer;
+class CBC_PDF417Writer : public CBC_TwoDimWriter
+{
+public:
+ CBC_PDF417Writer();
+ virtual ~CBC_PDF417Writer();
+ FX_BYTE * Encode(const CFX_WideString &contents, FX_INT32 &outWidth, FX_INT32 &outHeight, FX_INT32 &e);
+
+ FX_BYTE * Encode(const CFX_ByteString &contents, BCFORMAT format, FX_INT32 &outWidth, FX_INT32 &outHeight, FX_INT32 &e);
+ FX_BYTE * Encode(const CFX_ByteString &contents, BCFORMAT format, FX_INT32 &outWidth, FX_INT32 &outHeight, FX_INT32 hints, FX_INT32 &e);
+ FX_BOOL SetErrorCorrectionLevel(FX_INT32 level);
+ void SetTruncated(FX_BOOL truncated);
+private:
+ void rotateArray(CFX_ByteArray& bitarray, FX_INT32 width, FX_INT32 height);
+ FX_BOOL m_bTruncated;
+};
+#endif
|