summaryrefslogtreecommitdiff
path: root/source
diff options
context:
space:
mode:
Diffstat (limited to 'source')
-rw-r--r--source/codes/Codes.mc118
-rw-r--r--source/codes/DataMatrix.mc398
-rw-r--r--source/codes/Pdf417.mc428
-rw-r--r--source/codes/Qr.mc11
4 files changed, 935 insertions, 20 deletions
diff --git a/source/codes/Codes.mc b/source/codes/Codes.mc
index 2d307ef..bb1a4ed 100644
--- a/source/codes/Codes.mc
+++ b/source/codes/Codes.mc
@@ -53,12 +53,15 @@ module Codes {
}
}
- // A 2D code ready to draw: width x height modules, row-major, 1 = dark,
- // plus the quiet zone its symbology needs (QR 4, Data Matrix 1, ...).
+ // A 2D code ready to draw: width x height stored rows of modules,
+ // row-major, 1 = dark; each stored row is rowHeight modules high (PDF417
+ // rows are 3); plus the quiet zone its symbology needs (QR 4, Data
+ // Matrix 1, PDF417 2).
class Matrix {
var width as Number;
var height as Number;
var quiet as Number;
+ var rowHeight as Number = 1;
var modules as ByteArray;
function initialize(w as Number, h as Number, quietModules as Number, bits as ByteArray) {
@@ -68,35 +71,116 @@ module Codes {
modules = bits;
}
- // Compact form for the encrypted cache: width, height, quiet (one byte
- // each), then the modules packed 8 per byte.
+ // Height in modules as drawn.
+ function drawnHeight() as Number {
+ return height * rowHeight;
+ }
+
+ // Compact form for the encrypted cache: width, height, quiet zone,
+ // row height (one byte each), then the modules packed 8 per byte
+ // (eight per loop round: this runs in one event, under the watchdog).
function toBytes() as ByteArray {
- var out = [width, height, quiet]b;
- var packed = new [(modules.size() + 7) / 8]b;
- for (var i = 0; i < modules.size(); i++) {
- if (modules[i] == 1) {
- packed[i / 8] = packed[i / 8] | (0x80 >> (i % 8));
- }
+ var m = modules;
+ var n = m.size();
+ var full = n / 8;
+ var out = new [4 + (n + 7) / 8]b;
+ out[0] = width;
+ out[1] = height;
+ out[2] = quiet;
+ out[3] = rowHeight;
+ for (var i = 0; i < full; i++) {
+ var k = i * 8;
+ out[4 + i] = (m[k] << 7) | (m[k + 1] << 6) | (m[k + 2] << 5) | (m[k + 3] << 4)
+ | (m[k + 4] << 3) | (m[k + 5] << 2) | (m[k + 6] << 1) | m[k + 7];
+ }
+ for (var k = full * 8; k < n; k++) {
+ out[4 + full] = out[4 + full] | (m[k] << (7 - k % 8));
}
- out.addAll(packed);
return out;
}
static function fromBytes(data as ByteArray) as Matrix? {
- if (data.size() < 3) {
+ if (data.size() < 4) {
return null;
}
var w = data[0];
var h = data[1];
- if (w == 0 || h == 0 || data.size() != 3 + (w * h + 7) / 8) {
+ var n = w * h;
+ if (w == 0 || h == 0 || data[3] == 0 || data.size() != 4 + (n + 7) / 8) {
return null;
}
- var bits = new [w * h]b;
- for (var i = 0; i < w * h; i++) {
- bits[i] = (data[3 + i / 8] >> (7 - i % 8)) & 1;
+ var bits = new [(n + 7) / 8 * 8]b;
+ for (var i = 0; i < (n + 7) / 8; i++) {
+ var v = data[4 + i];
+ var k = i * 8;
+ bits[k] = (v >> 7) & 1;
+ bits[k + 1] = (v >> 6) & 1;
+ bits[k + 2] = (v >> 5) & 1;
+ bits[k + 3] = (v >> 4) & 1;
+ bits[k + 4] = (v >> 3) & 1;
+ bits[k + 5] = (v >> 2) & 1;
+ bits[k + 6] = (v >> 1) & 1;
+ bits[k + 7] = v & 1;
}
- return new Matrix(w, h, data[2], bits);
+ var matrix = new Matrix(w, h, data[2], bits.size() == n ? bits : bits.slice(0, n));
+ matrix.rowHeight = data[3];
+ return matrix;
+ }
+ }
+
+ // A 2D encoder run as a resumable job (watchdog): when step() returns
+ // true, either error is set or matrix() is the code.
+ class MatrixJob extends Jobs.Job {
+ var error as String? = null;
+
+ function initialize() {
+ Job.initialize();
+ }
+
+ // Progress 0-100 for the UI.
+ function percent() as Number {
+ return 0;
+ }
+
+ function matrix() as Matrix? {
+ return null;
+ }
+ }
+
+ // The job that encodes a 2D symbology, or null for linear ones. PDF417
+ // chooses its columns for the screen, so it gets the screen's size.
+ function matrixJob(symbology as Number, payload as String, options as Number, screenW as Number, screenH as Number,
+ round as Boolean) as MatrixJob? {
+ if (symbology == QR) {
+ return new Qr.QrJob(payload, ecLevel(options), 0, -1);
+ }
+ if (symbology == DATAMATRIX) {
+ return new DataMatrix.DataMatrixJob(payload);
+ }
+ if (symbology == PDF417) {
+ return new Pdf417.Pdf417Job(payload, ecLevel(options), screenW, screenH, round);
+ }
+ return null;
+ }
+
+ // Smallest module size allowed (README 12.2): 1 px for linear codes and
+ // PDF417 (a stacked linear code), 2 px for the square 2D codes.
+ function minModulePx(symbology as Number) as Number {
+ return isLinear(symbology) || symbology == PDF417 ? 1 : 2;
+ }
+
+ // True when a code of w x h modules (quiet zone included) at px pixels
+ // per module fits the screen: inside the circle (less a 4 px margin) on
+ // round screens; elsewhere the full width and the height less room for
+ // the name and ID lines.
+ function fits(w as Number, h as Number, px as Number, screenW as Number, screenH as Number, round as Boolean) as Boolean {
+ var width = w * px;
+ var height = h * px;
+ if (round) {
+ var r = screenW / 2 - 4;
+ return width.toLong() * width + height.toLong() * height <= 4l * r * r;
}
+ return width <= screenW - 4 && height <= screenH * 76 / 100;
}
function isMatrix(symbology as Number) as Boolean {
diff --git a/source/codes/DataMatrix.mc b/source/codes/DataMatrix.mc
new file mode 100644
index 0000000..45d5ff0
--- /dev/null
+++ b/source/codes/DataMatrix.mc
@@ -0,0 +1,398 @@
+// Author: cirakg & claude ai
+// Summary: Data Matrix ECC 200 encoder (ISO/IEC 16022): square sizes 10x10 to 144x144, ASCII and Base256, as a resumable job.
+//
+// Steps:
+// 1. Encode the UTF-8 bytes: ASCII (digit pairs as one codeword) when
+// every byte is below 128, otherwise the cheaper of ASCII with Upper
+// Shift per byte and one Base256 field (randomised, ISO 16022 annex B).
+// C40, Text, X12 and EDIFACT are deferred (README 12.1).
+// 2. Pick the smallest square size, pad (129, then randomised pads).
+// 3. Reed-Solomon over GF(256) (x^8+x^5+x^3+x^2+1, roots a^1..a^n),
+// per interleaved block, in chunks.
+// 4. Place the codewords with the standard "utah" placement, a few
+// diagonal sweeps per step, then add the finder and clock patterns of
+// every data region.
+// Verified against ppf.datamatrix (ASCII mode) and by decoding with zxing-cpp.
+
+import Toybox.Lang;
+
+module DataMatrix {
+
+ // Square sizes: [symbol size, data region size, regions per side,
+ // data codewords, EC codewords, interleaved blocks] (ISO 16022 table 7).
+ const SIZES = [
+ [10, 8, 1, 3, 5, 1], [12, 10, 1, 5, 7, 1], [14, 12, 1, 8, 10, 1], [16, 14, 1, 12, 12, 1],
+ [18, 16, 1, 18, 14, 1], [20, 18, 1, 22, 18, 1], [22, 20, 1, 30, 20, 1], [24, 22, 1, 36, 24, 1],
+ [26, 24, 1, 44, 28, 1], [32, 14, 2, 62, 36, 1], [36, 16, 2, 86, 42, 1], [40, 18, 2, 114, 48, 1],
+ [44, 20, 2, 144, 56, 1], [48, 22, 2, 174, 68, 1], [52, 24, 2, 204, 84, 2], [64, 14, 4, 280, 112, 2],
+ [72, 16, 4, 368, 144, 4], [80, 18, 4, 456, 192, 4], [88, 20, 4, 576, 224, 4], [96, 22, 4, 696, 272, 4],
+ [104, 24, 4, 816, 336, 6], [120, 18, 6, 1050, 408, 6], [132, 20, 6, 1304, 496, 8], [144, 22, 6, 1558, 620, 10]
+ ];
+ const QUIET = 1;
+ const PAD = 129;
+ const UPPER_SHIFT = 235;
+ const BASE256_LATCH = 231;
+ // Work per step, sized for the 120,000-bytecode watchdog.
+ const RS_SYMBOLS_PER_STEP = 40;
+ const SWEEPS_PER_STEP = 6;
+
+ var field as ReedSolomon.Field? = null;
+
+ function theField() as ReedSolomon.Field {
+ var f = field;
+ if (f == null) {
+ f = new ReedSolomon.Field(0x12D, 256, 1);
+ field = f;
+ }
+ return f;
+ }
+
+ // Codewords for data: ASCII, or Base256 when cheaper (non-ASCII text).
+ function codewords(data as ByteArray) as Array<Number> {
+ var ascii = [] as Array<Number>;
+ var highBytes = 0;
+ var i = 0;
+ while (i < data.size()) {
+ var b = data[i];
+ if (b >= 0x30 && b <= 0x39 && i + 1 < data.size() && data[i + 1] >= 0x30 && data[i + 1] <= 0x39) {
+ ascii.add(130 + (b - 0x30) * 10 + data[i + 1] - 0x30);
+ i += 2;
+ continue;
+ }
+ if (b >= 128) {
+ ascii.add(UPPER_SHIFT);
+ ascii.add(b - 128 + 1);
+ highBytes++;
+ } else {
+ ascii.add(b + 1);
+ }
+ i++;
+ }
+ var n = data.size();
+ var base256Cost = 1 + (n <= 249 ? 1 : 2) + n;
+ if (highBytes == 0 || ascii.size() <= base256Cost) {
+ return ascii;
+ }
+ var out = [BASE256_LATCH] as Array<Number>;
+ if (n <= 249) {
+ out.add(randomise255(n, 2));
+ } else {
+ out.add(randomise255(n / 250 + 249, 2));
+ out.add(randomise255(n % 250, 3));
+ }
+ for (var k = 0; k < n; k++) {
+ out.add(randomise255(data[k], out.size() + 1));
+ }
+ return out;
+ }
+
+ // The 255-state randomising of Base256 values at 1-based position pos.
+ function randomise255(value as Number, pos as Number) as Number {
+ var v = value + ((149 * pos) % 255) + 1;
+ return v <= 255 ? v : v - 256;
+ }
+
+ // The 253-state randomised pad at 1-based position pos.
+ function pad253(pos as Number) as Number {
+ var v = PAD + ((149 * pos) % 253) + 1;
+ return v <= 254 ? v : v - 254;
+ }
+
+ // Encode synchronously (tests); the app uses DataMatrixJob.
+ function encode(text as String) as Codes.Matrix or Codes.CodeError {
+ var job = new DataMatrixJob(text);
+ Jobs.runToCompletion(job, 1);
+ var err = job.error;
+ return err != null ? new Codes.CodeError(err) : job.matrix() as Codes.Matrix;
+ }
+
+ class DataMatrixJob extends Codes.MatrixJob {
+
+ private var _data as ByteArray;
+ private var _phase as Number = 0;
+ private var _size as Array<Number> = [] as Array<Number>;
+ private var _cw as Array<Number> = [] as Array<Number>;
+ private var _blocks as Array<Array<Number>> = [] as Array<Array<Number>>;
+ private var _rem as Array<Number> = [] as Array<Number>;
+ private var _block as Number = 0;
+ private var _at as Number = 0;
+ private var _ecTotal as Array<Number> = [] as Array<Number>;
+ // Placement state.
+ private var _nrow as Number = 0;
+ private var _ncol as Number = 0;
+ private var _place as Array<Number> = [] as Array<Number>; // 10 * codeword + bit, 0 = empty, -1 = fixed dark
+ private var _chr as Number = 1;
+ private var _row as Number = 4;
+ private var _col as Number = 0;
+ private var _result as Codes.Matrix? = null;
+
+ function initialize(text as String) {
+ MatrixJob.initialize();
+ _data = Bytes.fromUtf8(text);
+ }
+
+ function percent() as Number {
+ return _phase * 25;
+ }
+
+ function matrix() as Codes.Matrix? {
+ return _result;
+ }
+
+ function step(budget as Number) as Boolean {
+ if (_phase == 0) {
+ prepare();
+ } else if (_phase == 1) {
+ eccStep();
+ } else if (_phase == 2) {
+ placeStep();
+ } else if (_phase == 3) {
+ build();
+ }
+ return _phase >= 4 || error != null;
+ }
+
+ // Codewords, size, padding, blocks.
+ private function prepare() as Void {
+ if (_data.size() == 0) {
+ error = "Data Matrix needs some text";
+ return;
+ }
+ var cw = codewords(_data);
+ for (var i = 0; i < SIZES.size() && _size.size() == 0; i++) {
+ var s = SIZES[i] as Array<Number>;
+ if (cw.size() <= s[3]) {
+ _size = s;
+ }
+ }
+ if (_size.size() == 0) {
+ error = "too long for Data Matrix (" + cw.size() + " codewords, at most 1558)";
+ return;
+ }
+ var capacity = _size[3];
+ if (cw.size() < capacity) {
+ cw.add(PAD);
+ while (cw.size() < capacity) {
+ cw.add(pad253(cw.size() + 1));
+ }
+ }
+ _cw = cw;
+ var blocks = _size[5];
+ for (var b = 0; b < blocks; b++) {
+ var block = [] as Array<Number>;
+ for (var k = b; k < capacity; k += blocks) {
+ block.add(cw[k]);
+ }
+ _blocks.add(block);
+ }
+ _ecTotal = new [_size[4]] as Array<Number>;
+ startBlock();
+ _phase = 1;
+ }
+
+ private function startBlock() as Void {
+ var n = _size[4] / _size[5];
+ _rem = new [n] as Array<Number>;
+ for (var k = 0; k < n; k++) {
+ _rem[k] = 0;
+ }
+ _at = 0;
+ }
+
+ // Reed-Solomon, RS_SYMBOLS_PER_STEP data symbols per step.
+ private function eccStep() as Void {
+ var f = theField();
+ var data = _blocks[_block];
+ var n = _rem.size();
+ var g = f.generator(n);
+ var end = _at + RS_SYMBOLS_PER_STEP < data.size() ? _at + RS_SYMBOLS_PER_STEP : data.size();
+ for (var i = _at; i < end; i++) {
+ var factor = data[i] ^ _rem[0];
+ for (var k = 0; k < n - 1; k++) {
+ _rem[k] = _rem[k + 1] ^ f.multiply(g[k], factor);
+ }
+ _rem[n - 1] = f.multiply(g[n - 1], factor);
+ }
+ _at = end;
+ if (_at < data.size()) {
+ return;
+ }
+ // Interleave this block's EC codewords.
+ var blocks = _size[5];
+ for (var k = 0; k < n; k++) {
+ _ecTotal[_block + k * blocks] = _rem[k];
+ }
+ _block++;
+ if (_block < blocks) {
+ startBlock();
+ return;
+ }
+ _cw.addAll(_ecTotal);
+ _blocks = [] as Array<Array<Number>>;
+ _nrow = _size[1] * _size[2];
+ _ncol = _nrow;
+ _place = new [_nrow * _ncol] as Array<Number>;
+ for (var k = 0; k < _place.size(); k++) {
+ _place[k] = 0;
+ }
+ _phase = 2;
+ }
+
+ // ISO 16022 annex F placement, SWEEPS_PER_STEP diagonal sweeps per step.
+ private function placeStep() as Void {
+ var nrow = _nrow;
+ var ncol = _ncol;
+ for (var s = 0; s < SWEEPS_PER_STEP && (_row < nrow || _col < ncol); s++) {
+ if (_row == nrow && _col == 0) {
+ corner1();
+ }
+ if (_row == nrow - 2 && _col == 0 && ncol % 4 != 0) {
+ corner2();
+ }
+ if (_row == nrow - 2 && _col == 0 && ncol % 8 == 4) {
+ corner3();
+ }
+ if (_row == nrow + 4 && _col == 2 && ncol % 8 == 0) {
+ corner4();
+ }
+ do {
+ if (_row < nrow && _col >= 0 && _place[_row * ncol + _col] == 0) {
+ utah(_row, _col);
+ }
+ _row -= 2;
+ _col += 2;
+ } while (_row >= 0 && _col < ncol);
+ _row += 1;
+ _col += 3;
+ do {
+ if (_row >= 0 && _col < ncol && _place[_row * ncol + _col] == 0) {
+ utah(_row, _col);
+ }
+ _row += 2;
+ _col -= 2;
+ } while (_row < nrow && _col >= 0);
+ _row += 3;
+ _col += 1;
+ }
+ if (_row < nrow || _col < ncol) {
+ return;
+ }
+ if (_place[nrow * ncol - 1] == 0) {
+ _place[nrow * ncol - 1] = -1;
+ _place[nrow * ncol - ncol - 2] = -1;
+ }
+ _phase = 3;
+ }
+
+ private function setModule(row as Number, col as Number, bit as Number) as Void {
+ var r = row;
+ var c = col;
+ if (r < 0) {
+ r += _nrow;
+ c += 4 - ((_nrow + 4) % 8);
+ }
+ if (c < 0) {
+ c += _ncol;
+ r += 4 - ((_ncol + 4) % 8);
+ }
+ _place[r * _ncol + c] = 10 * _chr + bit;
+ }
+
+ private function utah(row as Number, col as Number) as Void {
+ setModule(row - 2, col - 2, 1);
+ setModule(row - 2, col - 1, 2);
+ setModule(row - 1, col - 2, 3);
+ setModule(row - 1, col - 1, 4);
+ setModule(row - 1, col, 5);
+ setModule(row, col - 2, 6);
+ setModule(row, col - 1, 7);
+ setModule(row, col, 8);
+ _chr++;
+ }
+
+ private function corner1() as Void {
+ setModule(_nrow - 1, 0, 1);
+ setModule(_nrow - 1, 1, 2);
+ setModule(_nrow - 1, 2, 3);
+ setModule(0, _ncol - 2, 4);
+ setModule(0, _ncol - 1, 5);
+ setModule(1, _ncol - 1, 6);
+ setModule(2, _ncol - 1, 7);
+ setModule(3, _ncol - 1, 8);
+ _chr++;
+ }
+
+ private function corner2() as Void {
+ setModule(_nrow - 3, 0, 1);
+ setModule(_nrow - 2, 0, 2);
+ setModule(_nrow - 1, 0, 3);
+ setModule(0, _ncol - 4, 4);
+ setModule(0, _ncol - 3, 5);
+ setModule(0, _ncol - 2, 6);
+ setModule(0, _ncol - 1, 7);
+ setModule(1, _ncol - 1, 8);
+ _chr++;
+ }
+
+ private function corner3() as Void {
+ setModule(_nrow - 3, 0, 1);
+ setModule(_nrow - 2, 0, 2);
+ setModule(_nrow - 1, 0, 3);
+ setModule(0, _ncol - 2, 4);
+ setModule(0, _ncol - 1, 5);
+ setModule(1, _ncol - 1, 6);
+ setModule(2, _ncol - 1, 7);
+ setModule(3, _ncol - 1, 8);
+ _chr++;
+ }
+
+ private function corner4() as Void {
+ setModule(_nrow - 1, 0, 1);
+ setModule(_nrow - 1, _ncol - 1, 2);
+ setModule(0, _ncol - 3, 3);
+ setModule(0, _ncol - 2, 4);
+ setModule(0, _ncol - 1, 5);
+ setModule(1, _ncol - 3, 6);
+ setModule(1, _ncol - 2, 7);
+ setModule(1, _ncol - 1, 8);
+ _chr++;
+ }
+
+ // The symbol: data modules mapped into the regions, plus each
+ // region's finder (solid left and bottom) and clock (top, right).
+ private function build() as Void {
+ var size = _size[0];
+ var region = _size[1];
+ var box = region + 2;
+ var m = new [size * size]b;
+ for (var y = 0; y < size; y++) {
+ var ry = y % box;
+ for (var x = 0; x < size; x++) {
+ var rx = x % box;
+ var dark = 0;
+ if (rx == 0 || ry == box - 1) {
+ dark = 1;
+ } else if (ry == 0) {
+ dark = rx % 2 == 0 ? 1 : 0;
+ } else if (rx == box - 1) {
+ dark = ry % 2 == 1 ? 1 : 0;
+ } else {
+ var mr = (y / box) * region + ry - 1;
+ var mc = (x / box) * region + rx - 1;
+ var v = _place[mr * _ncol + mc];
+ if (v == -1) {
+ dark = 1;
+ } else if (v > 0) {
+ var cw = _cw[v / 10 - 1];
+ dark = (cw >> (8 - v % 10)) & 1;
+ }
+ }
+ m[y * size + x] = dark;
+ }
+ }
+ _place = [] as Array<Number>;
+ _result = new Codes.Matrix(size, size, QUIET, m);
+ _phase = 4;
+ }
+ }
+}
diff --git a/source/codes/Pdf417.mc b/source/codes/Pdf417.mc
new file mode 100644
index 0000000..b17b5df
--- /dev/null
+++ b/source/codes/Pdf417.mc
@@ -0,0 +1,428 @@
+// Author: cirakg & claude ai
+// Summary: PDF417 encoder (ISO/IEC 15438): text, byte and numeric compaction as pdf417gen does it, columns fitted to the screen.
+//
+// Steps:
+// 1. Compaction, mirroring pdf417gen (the test reference): the bytes are
+// split into runs of digits, text-compactable characters and other
+// bytes; digit runs under 13 next to text become text; equal neighbours
+// merge. Text uses the four submodes (switch codes, pairs of values,
+// 29 as padding), numeric packs 44 digits per base-900 group, byte
+// packs 6 bytes into 5 codewords.
+// 2. Error-correction level: the option's fixed level, or automatic
+// (ISO 15438 annex E: 2 up to 40 data codewords, then 3, 4, 5).
+// 3. Columns and module size: the largest module size, then the fewest
+// columns, for which the symbol (with a 2-module quiet zone and rows 3
+// modules high) fits the screen (Codes.fits).
+// 4. Padding (900), length descriptor, Reed-Solomon mod 929 in steps.
+// 5. Rows: start, left row indicator, data, right row indicator, stop,
+// each codeword drawn from its cluster's 17-module pattern.
+// The 2,787 patterns, EC factors and text table are JSON resources
+// generated from pdf417gen (tools/gen_pdf417_tables.py), loaded only while
+// encoding.
+
+import Toybox.Lang;
+import Toybox.Math;
+import Toybox.WatchUi;
+
+module Pdf417 {
+
+ const START = 0x1fea8;
+ const STOP = 0x3fa29;
+ const PAD = 900;
+ const TEXT_LATCH = 900;
+ const BYTE_LATCH = 901;
+ const BYTE_LATCH_6 = 924;
+ const NUMERIC_LATCH = 902;
+ const ROW_HEIGHT = 3;
+ const QUIET = 2;
+ const MAX_CODEWORDS = 928;
+
+ const KIND_TEXT = 0;
+ const KIND_BYTE = 1;
+ const KIND_NUMERIC = 2;
+
+ // Text submodes and the switch codes between them [from][to].
+ const UPPER = 0;
+ const LOWER = 1;
+ const MIXED = 2;
+ const PUNCT = 3;
+ const SWITCHES = [
+ [[], [27], [28], [28, 25]],
+ [[28, 28], [], [28], [28, 25]],
+ [[28], [27], [], [25]],
+ [[29], [29, 27], [29, 28], []]
+ ];
+ const PREFERENCE = [1, 0, 2, 3]; // lower, upper, mixed, punctuation
+ const EC_STEP_WORDS = 20;
+
+ // One of the generated table resources ("v" holds the values).
+ function table(id as ResourceId) as Array {
+ return (WatchUi.loadResource(id) as Dictionary)["v"] as Array;
+ }
+
+ // Data codewords (without length descriptor and padding).
+ function dataCodewords(data as ByteArray, text as Array<Array<Number>>) as Array<Number> {
+ // Runs of one kind: [kind, start, end) triples.
+ var runs = [] as Array<Number>;
+ for (var i = 0; i < data.size(); i++) {
+ var kind = kindOf(data[i], text);
+ var n = runs.size();
+ if (n > 0 && runs[n - 3] == kind) {
+ runs[n - 1] = i + 1;
+ } else {
+ runs.add(kind);
+ runs.add(i);
+ runs.add(i + 1);
+ }
+ }
+ // Short digit runs next to text become text.
+ for (var r = 0; r < runs.size(); r += 3) {
+ if (runs[r] == KIND_NUMERIC && runs[r + 2] - runs[r + 1] < 13
+ && ((r > 0 && runs[r - 3] == KIND_TEXT) || (r + 3 < runs.size() && runs[r + 3] == KIND_TEXT))) {
+ runs[r] = -KIND_TEXT - 10; // marked; resolved below so later checks see the original kinds
+ }
+ }
+ for (var r = 0; r < runs.size(); r += 3) {
+ if (runs[r] == -KIND_TEXT - 10) {
+ runs[r] = KIND_TEXT;
+ }
+ }
+ // Merge equal neighbours.
+ var merged = [] as Array<Number>;
+ for (var r = 0; r < runs.size(); r += 3) {
+ var n = merged.size();
+ if (n > 0 && merged[n - 3] == runs[r]) {
+ merged[n - 1] = runs[r + 2];
+ } else {
+ merged.add(runs[r]);
+ merged.add(runs[r + 1]);
+ merged.add(runs[r + 2]);
+ }
+ }
+ var out = [] as Array<Number>;
+ for (var r = 0; r < merged.size(); r += 3) {
+ var kind = merged[r];
+ var start = merged[r + 1];
+ var end = merged[r + 2];
+ if (r > 0 || kind != KIND_TEXT) {
+ out.add(kind == KIND_TEXT ? TEXT_LATCH : (kind == KIND_NUMERIC ? NUMERIC_LATCH
+ : ((end - start) % 6 == 0 ? BYTE_LATCH_6 : BYTE_LATCH)));
+ }
+ if (kind == KIND_TEXT) {
+ compactText(data, start, end, text, out);
+ } else if (kind == KIND_NUMERIC) {
+ compactNumeric(data, start, end, out);
+ } else {
+ compactBytes(data, start, end, out);
+ }
+ }
+ return out;
+ }
+
+ function kindOf(b as Number, text as Array<Array<Number>>) as Number {
+ if (b >= 0x30 && b <= 0x39) {
+ return KIND_NUMERIC;
+ }
+ if (b < 127) {
+ for (var m = 0; m < 4; m++) {
+ if ((text[m][b] as Number) >= 0) {
+ return KIND_TEXT;
+ }
+ }
+ }
+ return KIND_BYTE;
+ }
+
+ function compactText(data as ByteArray, start as Number, end as Number, text as Array<Array<Number>>, out as Array<Number>) as Void {
+ var interim = [] as Array<Number>;
+ var submode = UPPER;
+ for (var i = start; i < end; i++) {
+ var c = data[i];
+ if ((text[submode][c] as Number) < 0) {
+ var next = submode;
+ for (var p = 0; p < 4; p++) {
+ var m = PREFERENCE[p] as Number;
+ if ((text[m][c] as Number) >= 0) {
+ next = m;
+ break;
+ }
+ }
+ interim.addAll((SWITCHES[submode] as Array)[next] as Array<Number>);
+ submode = next;
+ }
+ interim.add(text[submode][c] as Number);
+ }
+ for (var i = 0; i < interim.size(); i += 2) {
+ out.add(30 * interim[i] + (i + 1 < interim.size() ? interim[i + 1] : 29));
+ }
+ }
+
+ // 44 digits per group: the value of "1" followed by the digits, in base 900.
+ function compactNumeric(data as ByteArray, start as Number, end as Number, out as Array<Number>) as Void {
+ for (var g = start; g < end; g += 44) {
+ var stop = g + 44 < end ? g + 44 : end;
+ var decimal = [1] as Array<Number>;
+ for (var i = g; i < stop; i++) {
+ decimal.add(data[i] - 0x30);
+ }
+ var base900 = [] as Array<Number>;
+ while (decimal.size() > 0) {
+ // Divide the decimal number by 900, keeping the quotient.
+ var quotient = [] as Array<Number>;
+ var rem = 0;
+ for (var k = 0; k < decimal.size(); k++) {
+ var cur = rem * 10 + decimal[k];
+ var q = cur / 900;
+ rem = cur % 900;
+ if (quotient.size() > 0 || q > 0) {
+ quotient.add(q);
+ }
+ }
+ base900.add(rem);
+ decimal = quotient;
+ }
+ for (var k = base900.size() - 1; k >= 0; k--) {
+ out.add(base900[k]);
+ }
+ }
+ }
+
+ // 6 bytes per group as 5 base-900 codewords; a shorter last group as is.
+ function compactBytes(data as ByteArray, start as Number, end as Number, out as Array<Number>) as Void {
+ for (var g = start; g < end; g += 6) {
+ if (g + 6 > end) {
+ for (var i = g; i < end; i++) {
+ out.add(data[i]);
+ }
+ return;
+ }
+ var value = 0l;
+ for (var i = g; i < g + 6; i++) {
+ value = value * 256 + data[i];
+ }
+ var digits = new [5] as Array<Number>;
+ for (var k = 4; k >= 0; k--) {
+ digits[k] = (value % 900).toNumber();
+ value = value / 900;
+ }
+ out.addAll(digits);
+ }
+ }
+
+ // ISO 15438 annex E recommended level for the data codewords.
+ function autoLevel(dataCount as Number) as Number {
+ if (dataCount <= 40) {
+ return 2;
+ }
+ if (dataCount <= 160) {
+ return 3;
+ }
+ return dataCount <= 320 ? 4 : 5;
+ }
+
+ // The option's level: Low 2, Medium automatic, Quartile 5, High 6.
+ function levelFor(option as Number, dataCount as Number) as Number {
+ return [2, autoLevel(dataCount), 5, 6][option] as Number;
+ }
+
+ function leftIndicator(row as Number, rows as Number, cols as Number, level as Number) as Number {
+ var t = row % 3;
+ var x = t == 0 ? (rows - 1) / 3 : (t == 1 ? level * 3 + (rows - 1) % 3 : cols - 1);
+ return 30 * (row / 3) + x;
+ }
+
+ function rightIndicator(row as Number, rows as Number, cols as Number, level as Number) as Number {
+ var t = row % 3;
+ var x = t == 0 ? cols - 1 : (t == 1 ? (rows - 1) / 3 : level * 3 + (rows - 1) % 3);
+ return 30 * (row / 3) + x;
+ }
+
+ // Encode synchronously with given columns and level (tests).
+ function encode(text as String, cols as Number, level as Number) as Codes.Matrix or Codes.CodeError {
+ var job = new Pdf417Job(text, 0, 0, 0, false);
+ job.force(cols, level);
+ Jobs.runToCompletion(job, 1);
+ var err = job.error;
+ return err != null ? new Codes.CodeError(err) : job.matrix() as Codes.Matrix;
+ }
+
+ class Pdf417Job extends Codes.MatrixJob {
+
+ var columns as Number = 0;
+ var level as Number = -1;
+ var rows as Number = 0;
+
+ private var _data as ByteArray;
+ private var _option as Number;
+ private var _screenW as Number;
+ private var _screenH as Number;
+ private var _round as Boolean;
+ private var _phase as Number = 0;
+ private var _words as Array<Number> = [] as Array<Number>;
+ private var _ec as Array<Number> = [] as Array<Number>;
+ private var _factors as Array<Number> = [] as Array<Number>;
+ private var _codes as Array<Array<Number>> = [] as Array<Array<Number>>;
+ private var _at as Number = 0;
+ private var _modules as ByteArray = []b;
+ private var _result as Codes.Matrix? = null;
+
+ // option: the EC option (0-3). The screen size decides the columns.
+ function initialize(text as String, option as Number, screenW as Number, screenH as Number, round as Boolean) {
+ MatrixJob.initialize();
+ _data = Bytes.fromUtf8(text);
+ _option = option;
+ _screenW = screenW;
+ _screenH = screenH;
+ _round = round;
+ }
+
+ // Tests: fixed columns and level instead of the screen and option.
+ function force(cols as Number, ecLevel as Number) as Void {
+ columns = cols;
+ level = ecLevel;
+ }
+
+ function percent() as Number {
+ return _phase == 1 && _words.size() > 0 ? 20 + 60 * _at / _words.size() : _phase * 30;
+ }
+
+ function matrix() as Codes.Matrix? {
+ return _result;
+ }
+
+ function step(budget as Number) as Boolean {
+ if (_phase == 0) {
+ prepare();
+ } else if (_phase == 1) {
+ ecStep();
+ } else if (_phase == 2) {
+ rowsStep();
+ }
+ return _phase >= 3 || error != null;
+ }
+
+ private function prepare() as Void {
+ if (_data.size() == 0) {
+ error = "PDF417 needs some text";
+ return;
+ }
+ var data = dataCodewords(_data, table(Rez.JsonData.Pdf417Text) as Array<Array<Number>>);
+ if (level < 0) {
+ level = levelFor(_option, data.size());
+ }
+ var ecCount = 1 << (level + 1);
+ if (columns == 0 && !chooseLayout(data.size() + ecCount + 1)) {
+ error = "too large for this screen as PDF417 (" + data.size() + " codewords)";
+ return;
+ }
+ var total = data.size() + ecCount + 1;
+ var padding = total % columns == 0 ? 0 : columns - total % columns;
+ var length = data.size() + padding + 1;
+ rows = (total + padding) / columns;
+ if (length > MAX_CODEWORDS || rows > 90) {
+ error = "too long for PDF417 (" + data.size() + " codewords)";
+ return;
+ }
+ if (rows < 3) {
+ error = "PDF417 needs at least 3 rows; use fewer columns";
+ return;
+ }
+ _words = [length] as Array<Number>;
+ _words.addAll(data);
+ for (var i = 0; i < padding; i++) {
+ _words.add(PAD);
+ }
+ _factors = (table(Rez.JsonData.Pdf417Ec) as Array<Array<Number>>)[level];
+ _codes = [table(Rez.JsonData.Pdf417Codes0) as Array<Number>, table(Rez.JsonData.Pdf417Codes1) as Array<Number>,
+ table(Rez.JsonData.Pdf417Codes2) as Array<Number>];
+ _ec = new [ecCount] as Array<Number>;
+ for (var i = 0; i < ecCount; i++) {
+ _ec[i] = 0;
+ }
+ _at = 0;
+ _phase = 1;
+ }
+
+ // The largest module size, then the fewest columns, that fit.
+ private function chooseLayout(codewords as Number) as Boolean {
+ for (var px = 6; px >= 1; px--) {
+ for (var cols = 1; cols <= 30; cols++) {
+ var r = (codewords + cols - 1) / cols;
+ if (r < 3 || r > 90) {
+ continue;
+ }
+ var w = 17 * (cols + 4) + 1 + 2 * QUIET;
+ var h = r * ROW_HEIGHT + 2 * QUIET;
+ if (Codes.fits(w, h, px, _screenW, _screenH, _round)) {
+ columns = cols;
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ // Reed-Solomon mod 929 (pdf417gen's form), EC_STEP_WORDS words per step.
+ private function ecStep() as Void {
+ var n = _ec.size();
+ var f = _factors;
+ var end = _at + EC_STEP_WORDS < _words.size() ? _at + EC_STEP_WORDS : _words.size();
+ for (var i = _at; i < end; i++) {
+ var temp = (_words[i] + _ec[n - 1]) % 929;
+ for (var x = n - 1; x >= 0; x--) {
+ var word = x > 0 ? _ec[x - 1] : 0;
+ _ec[x] = (word + 929 - (temp * f[x]) % 929) % 929;
+ }
+ }
+ _at = end;
+ if (_at < _words.size()) {
+ return;
+ }
+ for (var x = n - 1; x >= 0; x--) {
+ var v = _ec[x];
+ _words.add(v > 0 ? 929 - v : 0);
+ }
+ _ec = [] as Array<Number>;
+ var width = 17 * (columns + 4) + 1;
+ _modules = new [width * rows]b;
+ _at = 0;
+ _phase = 2;
+ }
+
+ // A few rows per step: start, indicators, data, stop.
+ private function rowsStep() as Void {
+ var width = 17 * (columns + 4) + 1;
+ for (var k = 0; k < 4 && _at < rows; k++) {
+ var row = _at;
+ var cluster = _codes[row % 3];
+ var x = put(row, 0, START, 17, width);
+ x = put(row, x, cluster[leftIndicator(row, rows, columns, level)] as Number, 17, width);
+ for (var c = 0; c < columns; c++) {
+ x = put(row, x, cluster[_words[row * columns + c]] as Number, 17, width);
+ }
+ x = put(row, x, cluster[rightIndicator(row, rows, columns, level)] as Number, 17, width);
+ put(row, x, STOP, 18, width);
+ _at++;
+ }
+ if (_at < rows) {
+ return;
+ }
+ _codes = [] as Array<Array<Number>>;
+ _words = [] as Array<Number>;
+ var result = new Codes.Matrix(width, rows, QUIET, _modules);
+ result.rowHeight = ROW_HEIGHT;
+ _result = result;
+ _phase = 3;
+ }
+
+ // Draw count bits of pattern (most significant first) at column x of
+ // row `row`; returns the next column.
+ private function put(row as Number, x as Number, pattern as Number, count as Number, width as Number) as Number {
+ var at = row * width + x;
+ for (var i = 0; i < count; i++) {
+ _modules[at + i] = (pattern >> (count - 1 - i)) & 1;
+ }
+ return x + count;
+ }
+ }
+}
diff --git a/source/codes/Qr.mc b/source/codes/Qr.mc
index 8af0f5a..1fa69da 100644
--- a/source/codes/Qr.mc
+++ b/source/codes/Qr.mc
@@ -207,9 +207,8 @@ module Qr {
return err != null ? new Codes.CodeError(err) : job.result as MatrixCode;
}
- class QrJob extends Jobs.Job {
+ class QrJob extends Codes.MatrixJob {
- var error as String? = null;
var result as MatrixCode? = null;
private var _data as ByteArray;
@@ -237,7 +236,7 @@ module Qr {
// ec: 0 L, 1 M, 2 Q, 3 H. forceVersion 0 = smallest that fits;
// forceMask -1 = best by penalty.
function initialize(text as String, ec as Number, forceVersion as Number, forceMask as Number) {
- Job.initialize();
+ MatrixJob.initialize();
_data = Bytes.fromUtf8(text);
_ec = ec;
_forceMask = forceMask;
@@ -249,6 +248,12 @@ module Qr {
return _phase * 100 / 6;
}
+ // The code as a generic matrix with QR's 4-module quiet zone.
+ function matrix() as Codes.Matrix? {
+ var r = result;
+ return r != null ? new Codes.Matrix(r.size, r.size, 4, r.modules) : null;
+ }
+
function step(budget as Number) as Boolean {
if (_phase == 0) {
buildCodewords();
generated by cgit v1.2.3 (git 2.39.1) at 2026-10-29 18:57:32 +0000