kastet/zint
1
0
Fork 0
mirror of https://github.com/woo-j/zint.git synced 2024-12-23 01:33:55 +03:00
Code Issues Projects Releases Wiki Activity

QROCDE/UPNQR: add FAST_MODE (try 4 not 8 masks automatically)

Browse Source
This commit is contained in:
gitlost 2022-12-05 10:11:36 +00:00
parent 5499e9d71f
commit ad1b091ed1
18 changed files with 356 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
backend/qr.c
View File

@ -1281,7 +1281,7 @@ static void qr_add_format_info(unsigned char *grid, const int size, const int ec
} }
static int qr_apply_bitmask(unsigned char *grid, const int size, const int ecc_level, const int user_mask, static int qr_apply_bitmask(unsigned char *grid, const int size, const int ecc_level, const int user_mask,
const int debug_print) { const int fast_encode, const int debug_print) {
int x, y; int x, y;
int r, k; int r, k;
int bit; int bit;
@ -1302,24 +1302,30 @@ static int qr_apply_bitmask(unsigned char *grid, const int size, const int ecc_l
if (((y + x) & 1) == 0) { if (((y + x) & 1) == 0) {
mask[r + x] |= 0x01; mask[r + x] |= 0x01;
} }
if (!fast_encode) {
if ((y & 1) == 0) { if ((y & 1) == 0) {
mask[r + x] |= 0x02; mask[r + x] |= 0x02;
} }
}
if ((x % 3) == 0) { if ((x % 3) == 0) {
mask[r + x] |= 0x04; mask[r + x] |= 0x04;
} }
if (!fast_encode) {
if (((y + x) % 3) == 0) { if (((y + x) % 3) == 0) {
mask[r + x] |= 0x08; mask[r + x] |= 0x08;
} }
}
if ((((y / 2) + (x / 3)) & 1) == 0) { if ((((y / 2) + (x / 3)) & 1) == 0) {
mask[r + x] |= 0x10; mask[r + x] |= 0x10;
} }
if (!fast_encode) {
if ((y * x) % 6 == 0) { /* Equivalent to (y * x) % 2 + (y * x) % 3 == 0 */ if ((y * x) % 6 == 0) { /* Equivalent to (y * x) % 2 + (y * x) % 3 == 0 */
mask[r + x] |= 0x20; mask[r + x] |= 0x20;
} }
if (((((y * x) & 1) + ((y * x) % 3)) & 1) == 0) { if (((((y * x) & 1) + ((y * x) % 3)) & 1) == 0) {
mask[r + x] |= 0x40; mask[r + x] |= 0x40;
} }
}
if (((((y + x) & 1) + ((y * x) % 3)) & 1) == 0) { if (((((y + x) & 1) + ((y * x) % 3)) & 1) == 0) {
mask[r + x] |= 0x80; mask[r + x] |= 0x80;
} }
@ -1335,7 +1341,9 @@ static int qr_apply_bitmask(unsigned char *grid, const int size, const int ecc_l
* desired pattern.*/ * desired pattern.*/
best_pattern = 0; best_pattern = 0;
for (pattern = 0; pattern < 8; pattern++) { for (pattern = 0; pattern < 8; pattern++) {
if (fast_encode && pattern != 0 && pattern != 2 && pattern != 4 && pattern != 7) {
continue;
}
bit = 1 << pattern; bit = 1 << pattern;
for (k = 0; k < size_squared; k++) { for (k = 0; k < size_squared; k++) {
if (mask[k] & bit) { if (mask[k] & bit) {
@ -1355,17 +1363,21 @@ static int qr_apply_bitmask(unsigned char *grid, const int size, const int ecc_l
} }
if (debug_print) { if (debug_print) {
printf("Mask: %d (%s)", best_pattern, user_mask ? "specified" : "automatic"); printf("Mask: %d (%s)", best_pattern, user_mask ? "specified" : fast_encode ? "fast automatic": "automatic");
if (!user_mask) { if (!user_mask) {
if (fast_encode) {
printf(" 0:%d 2:%d 4:%d 7:%d", penalty[0], penalty[2], penalty[4], penalty[7]);
} else {
for (pattern = 0; pattern < 8; pattern++) printf(" %d:%d", pattern, penalty[pattern]); for (pattern = 0; pattern < 8; pattern++) printf(" %d:%d", pattern, penalty[pattern]);
} }
}
printf("\n"); printf("\n");
} }
#ifdef ZINTLOG #ifdef ZINTLOG
char str[15]; char str[15];
sprintf(str, "%d", best_val); sprintf(str, "%d", best_val);
write_log("choosed pattern:"); write_log("chose pattern:");
write_log(str); write_log(str);
#endif #endif
@ -1586,6 +1598,7 @@ INTERNAL int qrcode(struct zint_symbol *symbol, struct zint_seg segs[], const in
int size_squared; int size_squared;
const struct zint_structapp *p_structapp = NULL; const struct zint_structapp *p_structapp = NULL;
const int gs1 = ((symbol->input_mode & 0x07) == GS1_MODE); const int gs1 = ((symbol->input_mode & 0x07) == GS1_MODE);
const int fast_encode = symbol->input_mode & FAST_MODE;
const int debug_print = symbol->debug & ZINT_DEBUG_PRINT; const int debug_print = symbol->debug & ZINT_DEBUG_PRINT;
const int eci_length_segs = get_eci_length_segs(segs, seg_count); const int eci_length_segs = get_eci_length_segs(segs, seg_count);
struct zint_seg *local_segs = (struct zint_seg *) z_alloca(sizeof(struct zint_seg) * seg_count); struct zint_seg *local_segs = (struct zint_seg *) z_alloca(sizeof(struct zint_seg) * seg_count);
@ -1835,7 +1848,7 @@ INTERNAL int qrcode(struct zint_symbol *symbol, struct zint_seg segs[], const in
qr_add_version_info(grid, size, version); qr_add_version_info(grid, size, version);
} }
bitmask = qr_apply_bitmask(grid, size, ecc_level, user_mask, debug_print); bitmask = qr_apply_bitmask(grid, size, ecc_level, user_mask, fast_encode, debug_print);
qr_add_format_info(grid, size, ecc_level, bitmask); qr_add_format_info(grid, size, ecc_level, bitmask);
@ -2767,6 +2780,7 @@ INTERNAL int upnqr(struct zint_symbol *symbol, unsigned char source[], int lengt
int size_squared; int size_squared;
struct zint_seg segs[1]; struct zint_seg segs[1];
const int seg_count = 1; const int seg_count = 1;
const int fast_encode = symbol->input_mode & FAST_MODE;
const int debug_print = symbol->debug & ZINT_DEBUG_PRINT; const int debug_print = symbol->debug & ZINT_DEBUG_PRINT;
unsigned char *datastream; unsigned char *datastream;
unsigned char *fullstream; unsigned char *fullstream;
@ -2811,8 +2825,8 @@ INTERNAL int upnqr(struct zint_symbol *symbol, unsigned char source[], int lengt
segs[0].length = length; segs[0].length = length;
segs[0].eci = 4; segs[0].eci = 4;
est_binlen = qr_calc_binlen_segs(15, mode, ddata, segs, seg_count, NULL /*p_structapp*/, 1 /*mode_preset*/, 0, est_binlen = qr_calc_binlen_segs(15, mode, ddata, segs, seg_count, NULL /*p_structapp*/, 1 /*mode_preset*/,
debug_print); 0 /*gs1*/, debug_print);
ecc_level = QR_LEVEL_M; ecc_level = QR_LEVEL_M;
@ -2847,7 +2861,7 @@ INTERNAL int upnqr(struct zint_symbol *symbol, unsigned char source[], int lengt
qr_add_version_info(grid, size, version); qr_add_version_info(grid, size, version);
bitmask = qr_apply_bitmask(grid, size, ecc_level, user_mask, debug_print); bitmask = qr_apply_bitmask(grid, size, ecc_level, user_mask, fast_encode, debug_print);
qr_add_format_info(grid, size, ecc_level, bitmask); qr_add_format_info(grid, size, ecc_level, bitmask);

5
backend/tests/test_big5.c
View File

@ -32,7 +32,9 @@
#include "testcommon.h" #include "testcommon.h"
#include "test_big5_tab.h" #include "test_big5_tab.h"
/* For local "private" testing using previous libiconv adaptation, not included for licensing reasons */ /* For local "private" testing using previous libiconv adaptation, not included for licensing reasons */
/* #define TEST_JUST_SAY_GNO */ #if 0
#define TEST_JUST_SAY_GNO
#endif
#ifdef TEST_JUST_SAY_GNO #ifdef TEST_JUST_SAY_GNO
#include "../just_say_gno/big5_gnu.h" #include "../just_say_gno/big5_gnu.h"
#endif #endif
@ -105,6 +107,7 @@ static void test_u_big5_int(const testCtx *const p_ctx) {
if (i >= 0xD800 && i < 0xE000) { /* UTF-16 surrogates */ if (i >= 0xD800 && i < 0xE000) { /* UTF-16 surrogates */
continue; continue;
} }
if (testContinue(p_ctx, i)) continue;
val = val2 = 0; val = val2 = 0;
ret = u_big5_int(i, &val); ret = u_big5_int(i, &val);
ret2 = u_big5_int2(i, &val2); ret2 = u_big5_int2(i, &val2);

7
backend/tests/test_gb18030.c
View File

@ -34,7 +34,9 @@
#include "test_gbk_tab.h" #include "test_gbk_tab.h"
#include "../eci.h" #include "../eci.h"
/* For local "private" testing using previous libiconv adaptation, not included for licensing reasons */ /* For local "private" testing using previous libiconv adaptation, not included for licensing reasons */
/* #define TEST_JUST_SAY_GNO */ #if 0
#define TEST_JUST_SAY_GNO */
#endif
#ifdef TEST_JUST_SAY_GNO #ifdef TEST_JUST_SAY_GNO
#include "../just_say_gno/gb18030_gnu.c" #include "../just_say_gno/gb18030_gnu.c"
#include "../just_say_gno/gb2312_gnu.c" #include "../just_say_gno/gb2312_gnu.c"
@ -183,6 +185,7 @@ static void test_u_gb18030_int(const testCtx *const p_ctx) {
if (i >= 0xD800 && i <= 0xDFFF) { /* UTF-16 surrogates */ if (i >= 0xD800 && i <= 0xDFFF) { /* UTF-16 surrogates */
continue; continue;
} }
if (testContinue(p_ctx, i)) continue;
val1_1 = val1_2 = val2_1 = val2_2 = 0; val1_1 = val1_2 = val2_1 = val2_2 = 0;
ret = u_gb18030_int_test(i, &val1_1, &val1_2); ret = u_gb18030_int_test(i, &val1_1, &val1_2);
ret2 = u_gb18030_int2(i, &val2_1, &val2_2); ret2 = u_gb18030_int2(i, &val2_1, &val2_2);
@ -525,7 +528,7 @@ static void test_u_gbk_int(const testCtx *const p_ctx) {
testFinish(); testFinish();
} }
#define TEST_PERF_ITER_MILLES 50 #define TEST_PERF_ITER_MILLES 100
#define TEST_PERF_ITERATIONS (TEST_PERF_ITER_MILLES * 1000) #define TEST_PERF_ITERATIONS (TEST_PERF_ITER_MILLES * 1000)
/* Not a real test, just performance indicator */ /* Not a real test, just performance indicator */

5
backend/tests/test_gb2312.c
View File

@ -33,7 +33,9 @@
#include "test_gb2312_tab.h" #include "test_gb2312_tab.h"
#include "../eci.h" #include "../eci.h"
/* For local "private" testing using previous libiconv adaptation, not included for licensing reasons */ /* For local "private" testing using previous libiconv adaptation, not included for licensing reasons */
/* #define TEST_JUST_SAY_GNO */ #if 0
#define TEST_JUST_SAY_GNO
#endif
#ifdef TEST_JUST_SAY_GNO #ifdef TEST_JUST_SAY_GNO
#include "../just_say_gno/gb2312_gnu.c" #include "../just_say_gno/gb2312_gnu.c"
#endif #endif
@ -102,6 +104,7 @@ static void test_u_gb2312_int(const testCtx *const p_ctx) {
if (i >= 0xD800 && i <= 0xDFFF) { /* UTF-16 surrogates */ if (i >= 0xD800 && i <= 0xDFFF) { /* UTF-16 surrogates */
continue; continue;
} }
if (testContinue(p_ctx, i)) continue;
val = val2 = 0; val = val2 = 0;
ret = u_gb2312_int_test(i, &val); ret = u_gb2312_int_test(i, &val);
ret2 = u_gb2312_int2(i, &val2); ret2 = u_gb2312_int2(i, &val2);

6
backend/tests/test_hanxin.c
View File

@ -3644,7 +3644,7 @@ static void test_perf(const testCtx *const p_ctx) {
struct item data[] = { struct item data[] = {
/* 0*/ { BARCODE_HANXIN, UNICODE_MODE, -1, -1, /* 0*/ { BARCODE_HANXIN, UNICODE_MODE, -1, -1,
"汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。", "汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。",
0, 43, 43, "98 chars, Region One and Text" }, ZINT_WARN_NONCOMPLIANT, 43, 43, "98 chars, Region One and Text" },
/* 1*/ { BARCODE_HANXIN, UNICODE_MODE, -1, -1, /* 1*/ { BARCODE_HANXIN, UNICODE_MODE, -1, -1,
"汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。" "汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。"
"汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。" "汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。"
@ -3656,7 +3656,7 @@ static void test_perf(const testCtx *const p_ctx) {
"汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。" "汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。"
"汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。" "汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。"
"汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。", "汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。",
0, 121, 121, "980 chars, Region One and Text" }, ZINT_WARN_NONCOMPLIANT, 121, 121, "980 chars, Region One and Text" },
/* 2*/ { BARCODE_HANXIN, UNICODE_MODE, -1, -1, /* 2*/ { BARCODE_HANXIN, UNICODE_MODE, -1, -1,
"汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。" "汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。"
"汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。" "汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。"
@ -3673,7 +3673,7 @@ static void test_perf(const testCtx *const p_ctx) {
"汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。" "汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。"
"汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。" "汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。"
"汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。", "汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。汉信码(Chinese-Sensible Code)是一种能够有效表示汉字、图像等信息的二维条码。",
0, 147, 147, "1470 chars, Region One and Text" }, ZINT_WARN_NONCOMPLIANT, 147, 147, "1470 chars, Region One and Text" },
}; };
int data_size = ARRAY_SIZE(data); int data_size = ARRAY_SIZE(data);
int i, length, ret; int i, length, ret;

4
backend/tests/test_imail.c
View File

@ -41,7 +41,9 @@
#define TEST_CSV_PERF_ITERATIONS 100 #define TEST_CSV_PERF_ITERATIONS 100
/* #define TEST_IMAIL_CSV_MAX 300 */ #if 0
#define TEST_IMAIL_CSV_MAX 300
#endif
static void test_csv(const testCtx *const p_ctx) { static void test_csv(const testCtx *const p_ctx) {
int debug = p_ctx->debug; int debug = p_ctx->debug;

5
backend/tests/test_ksx1001.c
View File

@ -33,7 +33,9 @@
#include "test_ksx1001_tab.h" #include "test_ksx1001_tab.h"
#include "../ksx1001.h" #include "../ksx1001.h"
/* For local "private" testing using previous libiconv adaptation, not included for licensing reasons */ /* For local "private" testing using previous libiconv adaptation, not included for licensing reasons */
/* #define TEST_JUST_SAY_GNO */ #if 0
#define TEST_JUST_SAY_GNO
#endif
#ifdef TEST_JUST_SAY_GNO #ifdef TEST_JUST_SAY_GNO
#include "../just_say_gno/ksx1001_gnu.h" #include "../just_say_gno/ksx1001_gnu.h"
#endif #endif
@ -121,6 +123,7 @@ static void test_u_ksx1001_int(const testCtx *const p_ctx) {
if (i >= 0xD800 && i <= 0xDFFF) { /* UTF-16 surrogates */ if (i >= 0xD800 && i <= 0xDFFF) { /* UTF-16 surrogates */
continue; continue;
} }
if (testContinue(p_ctx, i)) continue;
val = val2 = 0; val = val2 = 0;
ret = u_ksx1001_int(i, &val); ret = u_ksx1001_int(i, &val);
ret2 = u_ksx1001_int2(i, &val2); ret2 = u_ksx1001_int2(i, &val2);

233
backend/tests/test_qr.c
View File

@ -3974,6 +3974,52 @@ static void test_qr_encode(const testCtx *const p_ctx) {
"100000101111111000011" "100000101111111000011"
"111111101000010110101" "111111101000010110101"
}, },
/*126*/ { BARCODE_QRCODE, UNICODE_MODE, -1, -1, -1, -1, { 0, 0, "" }, "ABCDEFGHI", 9, 0, 21, 21, 1, "Automatic mask 3",
"111111100000001111111"
"100000100111101000001"
"101110100000001011101"
"101110100110001011101"
"101110101100101011101"
"100000100011001000001"
"111111101010101111111"
"000000001101100000000"
"001100111101111010000"
"100111011101100101110"
"010011111000101001010"
"110100001001011011010"
"011101110001100101111"
"000000001011110001011"
"111111101100111110111"
"100000100100101110000"
"101110100111101011111"
"101110101111110010010"
"101110101000100101100"
"100000100001111110000"
"111111100101000111010"
},
/*127*/ { BARCODE_QRCODE, UNICODE_MODE | FAST_MODE, -1, -1, -1, -1, { 0, 0, "" }, "ABCDEFGHI", 9, 0, 21, 21, 1, "Fast automatic mask 2",
"111111101000001111111"
"100000101010001000001"
"101110101110101011101"
"101110100110001011101"
"101110100001001011101"
"100000101101101000001"
"111111101010101111111"
"000000001000000000000"
"001110101011011100111"
"100111011101100101110"
"111110110101000100111"
"000010011111101101100"
"011101110001100101111"
"000000001110011100110"
"111111100010001000001"
"100000100100101110000"
"101110101010000110010"
"101110101001000100100"
"101110101000100101100"
"100000100100010011101"
"111111100011110001100"
},
}; };
int data_size = ARRAY_SIZE(data); int data_size = ARRAY_SIZE(data);
int i, length, ret; int i, length, ret;
@ -4398,7 +4444,9 @@ static void test_qr_encode_segs(const testCtx *const p_ctx) {
#include <time.h> #include <time.h>
#define TEST_PERF_ITERATIONS 1000 #define TEST_PERF_ITER_MILLES 5
#define TEST_PERF_ITERATIONS (TEST_PERF_ITER_MILLES * 1000)
#define TEST_PERF_TIME(arg) (((arg) * 1000.0) / CLOCKS_PER_SEC)
/* Not a real test, just performance indicator */ /* Not a real test, just performance indicator */
static void test_qr_perf(const testCtx *const p_ctx) { static void test_qr_perf(const testCtx *const p_ctx) {
@ -4417,10 +4465,23 @@ static void test_qr_perf(const testCtx *const p_ctx) {
char *comment; char *comment;
}; };
struct item data[] = { struct item data[] = {
/* 0*/ { BARCODE_QRCODE, UNICODE_MODE, -1, -1, /* 0*/ { BARCODE_QRCODE, UNICODE_MODE, -1, -1, "12345678901234", 0, 21, 21, "14 chars, Numeric mode" },
/* 1*/ { BARCODE_QRCODE, UNICODE_MODE, -1, -1, "ABC 123 ABC 123 ABCD", 0, 21, 21, "20 chars, Alphanumeric" },
/* 2*/ { BARCODE_QRCODE, UNICODE_MODE, -1, -1, "ABCde fG H 123456 IJKlmn, 1234567890 opQ Rst uvwxyz. 1234", 0, 29, 29, "57 chars, Alphanumeric" },
/* 3*/ { BARCODE_QRCODE, UNICODE_MODE, -1, -1,
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点", "ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点",
ZINT_WARN_NONCOMPLIANT, 37, 37, "107 chars, Mixed modes" }, ZINT_WARN_NONCOMPLIANT, 37, 37, "107 chars, Mixed modes" },
/* 1*/ { BARCODE_QRCODE, UNICODE_MODE, -1, -1, /* 4*/ { BARCODE_QRCODE, UNICODE_MODE, -1, -1,
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点",
ZINT_WARN_NONCOMPLIANT, 53, 53, "214 chars, Mixed modes" },
/* 5*/ { BARCODE_QRCODE, UNICODE_MODE, -1, -1,
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点",
ZINT_WARN_NONCOMPLIANT, 73, 73, "428 chars, Mixed modes" },
/* 6*/ { BARCODE_QRCODE, UNICODE_MODE, -1, -1,
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点" "ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点" "ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点" "ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点"
@ -4431,25 +4492,99 @@ static void test_qr_perf(const testCtx *const p_ctx) {
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点" "ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点", "ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点",
ZINT_WARN_NONCOMPLIANT, 105, 105, "963 chars, Mixed modes" }, ZINT_WARN_NONCOMPLIANT, 105, 105, "963 chars, Mixed modes" },
/* 7*/ { BARCODE_QRCODE, UNICODE_MODE, -1, -1,
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 12345678901234567890123456 点点点点点点点点点点点点点点点点点点点点点点点点点点",
ZINT_WARN_NONCOMPLIANT, 133, 133, "1498 chars, Mixed modes" },
}; };
int data_size = ARRAY_SIZE(data); int data_size = ARRAY_SIZE(data);
int i, length, ret; int i, length, ret;
struct zint_symbol *symbol;
clock_t start, total_encode = 0, total_buffer = 0, diff_encode, diff_buffer; clock_t start;
clock_t total_create = 0, total_encode = 0, total_buffer = 0;
clock_t diff_create, diff_encode, diff_buffer;
int comment_max = 0;
if (!(debug & ZINT_DEBUG_TEST_PERFORMANCE)) { /* -d 256 */ if (!(debug & ZINT_DEBUG_TEST_PERFORMANCE)) { /* -d 256 */
return; return;
} }
for (i = 0; i < data_size; i++) if ((int) strlen(data[i].comment) > comment_max) comment_max = (int) strlen(data[i].comment);
printf("Iterations %d\n", TEST_PERF_ITERATIONS);
printf("FAST_MODE\n");
for (i = 0; i < data_size; i++) { for (i = 0; i < data_size; i++) {
int j; int j;
if (testContinue(p_ctx, i)) continue; if (testContinue(p_ctx, i)) continue;
diff_encode = diff_buffer = 0; diff_create = diff_encode = diff_buffer = 0;
for (j = 0; j < TEST_PERF_ITERATIONS; j++) { for (j = 0; j < TEST_PERF_ITERATIONS; j++) {
struct zint_symbol *symbol = ZBarcode_Create(); int input_mode = data[i].input_mode == -1 ? FAST_MODE : (data[i].input_mode | FAST_MODE);
start = clock();
symbol = ZBarcode_Create();
diff_create += clock() - start;
assert_nonnull(symbol, "Symbol not created\n");
length = testUtilSetSymbol(symbol, data[i].symbology, input_mode, -1 /*eci*/, data[i].option_1, data[i].option_2, -1, -1 /*output_options*/, data[i].data, -1, debug);
start = clock();
ret = ZBarcode_Encode(symbol, (unsigned char *) data[i].data, length);
diff_encode += clock() - start;
assert_equal(ret, data[i].ret, "i:%d ZBarcode_Encode ret %d != %d (%s)\n", i, ret, data[i].ret, symbol->errtxt);
#if 0
assert_equal(symbol->rows, data[i].expected_rows, "i:%d symbol->rows %d != %d (%s)\n", i, symbol->rows, data[i].expected_rows, data[i].data);
assert_equal(symbol->width, data[i].expected_width, "i:%d symbol->width %d != %d (%s)\n", i, symbol->width, data[i].expected_width, data[i].data);
#endif
start = clock();
ret = ZBarcode_Buffer(symbol, 0 /*rotate_angle*/);
diff_buffer += clock() - start;
assert_zero(ret, "i:%d ZBarcode_Buffer ret %d != 0 (%s)\n", i, ret, symbol->errtxt);
ZBarcode_Delete(symbol);
}
printf("%*s: encode % 8gms, buffer % 8gms, create % 8gms\n", comment_max, data[i].comment,
TEST_PERF_TIME(diff_encode), TEST_PERF_TIME(diff_buffer), TEST_PERF_TIME(diff_create));
total_create += diff_create;
total_encode += diff_encode;
total_buffer += diff_buffer;
}
if (p_ctx->index != -1) {
printf("%*s: encode % 8gms, buffer % 8gms, create % 8gms\n", comment_max, "totals",
TEST_PERF_TIME(total_encode), TEST_PERF_TIME(total_buffer), TEST_PERF_TIME(total_create));
}
printf("OPTIMIZED\n");
for (i = 0; i < data_size; i++) {
int j;
if (testContinue(p_ctx, i)) continue;
diff_create = diff_encode = diff_buffer = 0;
for (j = 0; j < TEST_PERF_ITERATIONS; j++) {
start = clock();
symbol = ZBarcode_Create();
diff_create += clock() - start;
assert_nonnull(symbol, "Symbol not created\n"); assert_nonnull(symbol, "Symbol not created\n");
length = testUtilSetSymbol(symbol, data[i].symbology, data[i].input_mode, -1 /*eci*/, data[i].option_1, data[i].option_2, -1, -1 /*output_options*/, data[i].data, -1, debug); length = testUtilSetSymbol(symbol, data[i].symbology, data[i].input_mode, -1 /*eci*/, data[i].option_1, data[i].option_2, -1, -1 /*output_options*/, data[i].data, -1, debug);
@ -4470,13 +4605,16 @@ static void test_qr_perf(const testCtx *const p_ctx) {
ZBarcode_Delete(symbol); ZBarcode_Delete(symbol);
} }
printf("%s: diff_encode %gms, diff_buffer %gms\n", data[i].comment, diff_encode * 1000.0 / CLOCKS_PER_SEC, diff_buffer * 1000.0 / CLOCKS_PER_SEC); printf("%*s: encode % 8gms, buffer % 8gms, create % 8gms\n", comment_max, data[i].comment,
TEST_PERF_TIME(diff_encode), TEST_PERF_TIME(diff_buffer), TEST_PERF_TIME(diff_create));
total_create += diff_create;
total_encode += diff_encode; total_encode += diff_encode;
total_buffer += diff_buffer; total_buffer += diff_buffer;
} }
if (p_ctx->index != -1) { if (p_ctx->index != -1) {
printf("totals: encode %gms, buffer %gms\n", total_encode * 1000.0 / CLOCKS_PER_SEC, total_buffer * 1000.0 / CLOCKS_PER_SEC); printf("%*s: encode % 8gms, buffer % 8gms, create % 8gms\n", comment_max, "totals",
TEST_PERF_TIME(total_encode), TEST_PERF_TIME(total_buffer), TEST_PERF_TIME(total_create));
} }
} }
@ -6539,6 +6677,85 @@ static void test_upnqr_encode(const testCtx *const p_ctx) {
"10000010011100010001111111000000001011100000001000111111100001011101111000001" "10000010011100010001111111000000001011100000001000111111100001011101111000001"
"11111110110101111101111001011101111100101101111101100101000101100100011101000" "11111110110101111101111001011101111100101101111101100101000101100100011101000"
}, },
/* 5*/ { UNICODE_MODE, -1, -1, -1, "UPNQR\012\012\012\012\012Janez Novak\012Dunajska 1\0121000 Ljubljana\01200000008105\012\012\012COST\012Plačilo obveznosti 10/2016\012\012SI56051008010486080\012SI0598765432100\012Novo podjetje d.o.o.\012Lepa cesta 15\0123698 Loški Potok\012183\012 ", 0, 77, 77, "Example A fast automatic mask 0 (not 3)",
"11111110111111111100010011100010110001111000010010000011011111010000001111111"
"10000010100011011111111001110100100100111110110100100100100111100010101000001"
"10111010001000100000110111010001001000001000001101001001001001011000101011101"
"10111010101000111111100101110000011010110100010001010110010010111000101011101"
"10111010001000001001001011111100000110101100001111110101110011110111101011101"
"10000010001111111001010010001001001000001000001000101001011001101010001000001"
"11111110101010101010101010101010101010101010101010101010101010101010101111111"
"00000000110100001001111110001101011101000100101000100100100100100100100000000"
"10110111001011100111111111111011000001101011011111101101010000000101001001011"
"11001001101111111100011011010011101000111100110110000001000110000010011010010"
"10010011010011001101011011110101100100100110100110100100111100100101100100000"
"10100000010000010100110110001000001001001001001101011011000001011001001001000"
"11000110111001011001100000101001001011110000000011000110001011000111110000010"
"01100000001000001010001010000101000110101100000100100111110000100100001100100"
"11011010001110100011010100011001011001001001001001001011001001001000001001101"
"01100101000011101111001001011100110111010010010110011000011010010010010010011"
"01011011110011001110010110000111101100100110110101001010110101100001100110100"
"00000101101101100110100111101110101010100001101001010000001101011001100001011"
"00000011000011011001011001010011010110010010010000011000110010010011010110110"
"11100101110001011000111101110100110110100100100000001101000100100100100000101"
"00011010011000100011111101110011011011101011000011000110011000001011011111011"
"11101000111110111101100000101011110010011010110111000001110110000000000010010"
"10001011110111101111111001111100111100100100101101100110000100100001100000101"
"00100000001000110101001110010000001111000001001011011000101001001001101101010"
"11111111110101101000100011111000011100111000001111100111000011010100111111010"
"11101000100100011011011010001101100110100100001000100101000000110000100011101"
"00111010110010001010010010101001001101001001001010101001101011001111101011100"
"01101000100011111100011110001010010000011010001000101010010110010010100010101"
"10001111100101011010000111111110101110010110111111101001110000100001111110010"
"00011000010101110110101111110001101001010001110000010001101110011010011110001"
"01101010101101011001000100111010010010010010010110110010010011010011011010101"
"01100101110001010010111010111100100000110101011000100100100010100110111011000"
"10111010001110111000010101110011000001101010100001101100111010001100001001111"
"01001001001010111000000101001010110110011010110011100011010100100001000100010"
"00000110111010100100111010001100100100110101110101100100100100100100111001010"
"01011001111110011000100111110001001001010100000000001000001111001011011010001"
"00111011010010000010110111001110011010111000000110010111101001010110110011100"
"01111100011111110001111011111100000110101111000101110101010000010010100110100"
"01001010110110000011110111100101001001011011001001101001010001001001010101101"
"00100000000111011011011101101110010010010110010010010010010010010000000110011"
"10001110000101001100110001011100101101100001101000000000110110001000000000100"
"00110001010111011000100111010011101011001000000000011000000100011001001101001"
"01010010001111001110110101011100010011010011010010010010010011111010010110110"
"11010101111000010110001010111000100100100100001100100100100000111100101100101"
"10100010001001000010001100110101000001101110101101001011001100111101100001001"
"01101001011100010101001101101110110000011110110011000111000001000010010000010"
"11101111111001110000001011111010100100100101101111100010110101000100111110000"
"00111000110101111110000010001100001000001101001000101001001001111001100011000"
"01111010100010111010110010101011000010110000001010110110000011000110101010010"
"11011000101011001011011010001100000110001010001000110111100000100100100010100"
"10001111111100100100000111111010011000001111001111100001001001001001111111101"
"11100001001110110011111000111010010010010010010010000010010010000011011010011"
"11000111010101101011000010000110111101000110100100110000110101110000100100100"
"10110001010110000001010000001010101011100001111101010010001101001001001001001"
"01010011111110111110111010111100010010010010010011011100010010010010010000110"
"01111101011001100100101010011110010101100100100100101100100100100101101100101"
"10010010101001000111101010111011000001101011001001001111011000001101101001001"
"01011101011000111010101001000010101101011010100110001111010110000011010010010"
"11110111111011001000011101001001111001100100100101100000100100100100000110010"
"00101101100110101001001100001011011001001001001001001001001001001000000001010"
"01001110101000011100110000011010010010110000010100011100100011010010110010000"
"01011001110011001100010011101001001010101100010000110000000000110001100100010"
"11011110101100100101101111110111011001001001001010000111001001001101101010000"
"10110000001001111010001001110000000010011010010000011000010010010011011010001"
"00011011010000111010011010100101001010011110100100101000010101100010000100100"
"01100101010110100001100110001101101011000001110111011000101101011001001000011"
"01001111100111100110111110110101101110010010011011111010110000010011010001100"
"00001001111101000000101011011110100000100100101101111101100100100111001101101"
"01111010101101000011101111111001000001100011011111111101111111001101111110011"
"00000000101101101110101110001110110100001010111000101010110111000000100011010"
"11111110110001001100010110101010100100100100111010100100100011100101101010000"
"10000010110110110101000110001011001001001001101000101001001111001001100010100"
"10111010010110001000101011111010011100101001101111110110100111010111111111110"
"10111010111111011111010010100000000110101100000111110101100010010110000000100"
"10111010111000101010000010001111001111011001010101101001101011001000001000101"
"10000010001101100100010110101010010010001110010010010010110010010010100101001"
"11111110100011011001111101001100101100000010111001100000111111111001000100010"
},
}; };
int data_size = ARRAY_SIZE(data); int data_size = ARRAY_SIZE(data);
int i, length, ret; int i, length, ret;

5
backend/tests/test_sjis.c
View File

@ -33,7 +33,9 @@
#include "test_sjis_tab.h" #include "test_sjis_tab.h"
#include "../eci.h" #include "../eci.h"
/* For local "private" testing using previous libiconv adaptation, not included for licensing reasons */ /* For local "private" testing using previous libiconv adaptation, not included for licensing reasons */
/* #define TEST_JUST_SAY_GNO */ #if 0
#define TEST_JUST_SAY_GNO
#endif
#ifdef TEST_JUST_SAY_GNO #ifdef TEST_JUST_SAY_GNO
#include "../just_say_gno/sjis_gnu.c" #include "../just_say_gno/sjis_gnu.c"
#endif #endif
@ -127,7 +129,6 @@ static void test_u_sjis_int(const testCtx *const p_ctx) {
continue; continue;
} }
if (testContinue(p_ctx, i)) continue; if (testContinue(p_ctx, i)) continue;
val = val2 = 0; val = val2 = 0;
ret = u_sjis_int_test(i, &val); ret = u_sjis_int_test(i, &val);
ret2 = u_sjis_int2(i, &val2); ret2 = u_sjis_int2(i, &val2);

4
backend/zint.h
View File

@ -295,8 +295,8 @@ extern "C" {
#define GS1PARENS_MODE 0x0010 /* Process parentheses as GS1 AI delimiters (instead of square brackets) */ #define GS1PARENS_MODE 0x0010 /* Process parentheses as GS1 AI delimiters (instead of square brackets) */
#define GS1NOCHECK_MODE 0x0020 /* Do not check validity of GS1 data (except that printable ASCII only) */ #define GS1NOCHECK_MODE 0x0020 /* Do not check validity of GS1 data (except that printable ASCII only) */
#define HEIGHTPERROW_MODE 0x0040 /* Interpret `height` as per-row rather than as overall height */ #define HEIGHTPERROW_MODE 0x0040 /* Interpret `height` as per-row rather than as overall height */
#define FAST_MODE 0x0080 /* Use faster if less optimal encodation for symbologies that support it */ #define FAST_MODE 0x0080 /* Use faster if less optimal encodation or other shortcuts if available */
/* Note: only DATAMATRIX, MICROPDF417 & PDF417 currently */ /* Note: affects DATAMATRIX, MICROPDF417, PDF417, QRCODE & UPNQR only */
/* Data Matrix specific options (`symbol->option_3`) */ /* Data Matrix specific options (`symbol->option_3`) */
#define DM_SQUARE 100 /* Only consider square versions on automatic symbol size selection */ #define DM_SQUARE 100 /* Only consider square versions on automatic symbol size selection */

12
docs/manual.pmd
View File

@ -2097,9 +2097,9 @@ Value Effect
`HEIGHTPERROW_MODE` Interpret the `height` variable as per-row rather than as `HEIGHTPERROW_MODE` Interpret the `height` variable as per-row rather than as
overall height. overall height.
`FAST_MODE` Use faster if less optimal encodation for symbologies that `FAST_MODE` Use faster if less optimal encodation or other shortcuts if
support it (currently `DATAMATRIX`, `MICROPDF417` and available (affects `DATAMATRIX`, `MICROPDF417`, `PDF417`,
`PDF417` only). `QRCODE` and `UPNQR` only).
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
Table: API `input_mode` Values {#tbl:api_input_mode tag="$ $"} Table: API `input_mode` Values {#tbl:api_input_mode tag="$ $"}
@ -3608,6 +3608,10 @@ by using the `--mask` switch with values 0-7, or in the API by setting
option_3 = ZINT_FULL_MULTIBYTE | (N + 1) << 8 option_3 = ZINT_FULL_MULTIBYTE | (N + 1) << 8
``` ```
The `--fast` option (API `input_mode |= FAST_MODE`) may be used when leaving
Zint to automatically select a mask to reduce the number of masks to try to four
(0, 2, 4, 7).
QR Code supports Structured Append of up to 16 symbols and a numeric ID QR Code supports Structured Append of up to 16 symbols and a numeric ID
(parity), which can be set by using the `--structapp` option (see [4.16 (parity), which can be set by using the `--structapp` option (see [4.16
Structured Append]) (API `structapp`). The parity ID ranges from 0 (default) to Structured Append]) (API `structapp`). The parity ID ranges from 0 (default) to
@ -3738,6 +3742,8 @@ The following example creates a symbol from data saved as a Latin-2 file:
zint -o upnqr.png -b 143 --scale=3 --binary -i upn.txt zint -o upnqr.png -b 143 --scale=3 --binary -i upn.txt
``` ```
A mask may be manually specified or the `--fast` option used as with QRCODE.
### 6.6.6 MaxiCode (ISO 16023) ### 6.6.6 MaxiCode (ISO 16023)
![`zint -b MAXICODE -d "1Z00004951\GUPSN\G06X610\G159\G1234567\G1/1\G\GY\G1 MAIN ![`zint -b MAXICODE -d "1Z00004951\GUPSN\G06X610\G159\G1234567\G1/1\G\GY\G1 MAIN

16
docs/manual.txt
View File

@ -2101,9 +2101,9 @@ property. Valid values are shown in the table below.
HEIGHTPERROW_MODE Interpret the height variable as per-row rather than as HEIGHTPERROW_MODE Interpret the height variable as per-row rather than as
overall height. overall height.
FAST_MODE Use faster if less optimal encodation for symbologies that FAST_MODE Use faster if less optimal encodation or other shortcuts if
support it (currently DATAMATRIX, MICROPDF417 and PDF417 available (affects DATAMATRIX, MICROPDF417, PDF417, QRCODE
only). and UPNQR only).
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
: Table  : API input_mode Values : Table  : API input_mode Values
@ -3501,6 +3501,10 @@ option_3 = (N + 1) << 8 where N is 0-7. To use with ZINT_FULL_MULTIBYTE set
option_3 = ZINT_FULL_MULTIBYTE | (N + 1) << 8 option_3 = ZINT_FULL_MULTIBYTE | (N + 1) << 8
The --fast option (API input_mode |= FAST_MODE) may be used when leaving Zint to
automatically select a mask to reduce the number of masks to try to four (0, 2,
4, 7).
QR Code supports Structured Append of up to 16 symbols and a numeric ID QR Code supports Structured Append of up to 16 symbols and a numeric ID
(parity), which can be set by using the --structapp option (see 4.16 Structured (parity), which can be set by using the --structapp option (see 4.16 Structured
Append) (API structapp). The parity ID ranges from 0 (default) to 255, and for Append) (API structapp). The parity ID ranges from 0 (default) to 255, and for
@ -3627,6 +3631,8 @@ The following example creates a symbol from data saved as a Latin-2 file:
zint -o upnqr.png -b 143 --scale=3 --binary -i upn.txt zint -o upnqr.png -b 143 --scale=3 --binary -i upn.txt
A mask may be manually specified or the --fast option used as with QRCODE.
6.6.6 MaxiCode (ISO 16023) 6.6.6 MaxiCode (ISO 16023)
[zint -b MAXICODE -d "1Z00004951\GUPSN\G06X610\G159\G1234567\G1/1\G\GY\G1 MAIN ST\GNY\GNY\R\E" --esc --primary="152382802000000" --scmvv=96] [zint -b MAXICODE -d "1Z00004951\GUPSN\G06X610\G159\G1234567\G1/1\G\GY\G1 MAIN ST\GNY\GNY\R\E" --esc --primary="152382802000000" --scmvv=96]
@ -4421,8 +4427,8 @@ OPTIONS
--fast --fast
Use faster if less optimal encodation (currently affects Data Matrix, Use faster if less optimal encodation or other shortcuts (affects Data
MicroPDF417 & PDF417 only). Matrix, MicroPDF417, PDF417, QRCODE & UPNQR only).
--fg=COLOUR --fg=COLOUR

4
docs/zint.1
View File

@ -198,8 +198,8 @@ The escape sequences are:
.RE .RE
.TP .TP
\f[V]--fast\f[R] \f[V]--fast\f[R]
Use faster if less optimal encodation (currently affects Data Matrix, Use faster if less optimal encodation or other shortcuts (affects Data
MicroPDF417 & PDF417 only). Matrix, MicroPDF417, PDF417, QRCODE & UPNQR only).
.TP .TP
\f[V]--fg=COLOUR\f[R] \f[V]--fg=COLOUR\f[R]
Specify a foreground (ink) colour where \f[I]COLOUR\f[R] is in hex Specify a foreground (ink) colour where \f[I]COLOUR\f[R] is in hex

3
docs/zint.1.pmd
View File

@ -148,7 +148,8 @@ Paintbrush (`PCX`), Portable Network Format (`PNG`), Scalable Vector Graphic (`S
`--fast` `--fast`
: Use faster if less optimal encodation (currently affects Data Matrix, MicroPDF417 & PDF417 only). : Use faster if less optimal encodation or other shortcuts (affects Data Matrix, MicroPDF417, PDF417, QRCODE & UPNQR
only).
`--fg=COLOUR` `--fg=COLOUR`

2
frontend/main.c
View File

@ -164,7 +164,7 @@ static void usage(int no_png) {
" -e, --ecinos Display ECI (Extended Channel Interpretation) table\n", stdout); " -e, --ecinos Display ECI (Extended Channel Interpretation) table\n", stdout);
fputs( " --eci=NUMBER Set the ECI code for the data (segment 0)\n" fputs( " --eci=NUMBER Set the ECI code for the data (segment 0)\n"
" --esc Process escape characters in input data\n" " --esc Process escape characters in input data\n"
" --fast Use faster encodation (Data Matrix)\n" " --fast Use faster encodation or other shortcuts if available\n"
" --fg=COLOUR Specify a foreground colour (in hex RGB/RGBA)\n", stdout); " --fg=COLOUR Specify a foreground colour (in hex RGB/RGBA)\n", stdout);
printf(" --filetype=TYPE Set output file type BMP/EMF/EPS/GIF/PCX%s/SVG/TIF/TXT\n", no_png_type); printf(" --filetype=TYPE Set output file type BMP/EMF/EPS/GIF/PCX%s/SVG/TIF/TXT\n", no_png_type);
fputs( " --fullmultibyte Use multibyte for binary/Latin (QR/Han Xin/Grid Matrix)\n" fputs( " --fullmultibyte Use multibyte for binary/Latin (QR/Han Xin/Grid Matrix)\n"

14
frontend_qt/grpQR.ui
View File

@ -430,6 +430,20 @@ and Latin data</string>
</property> </property>
</widget> </widget>
</item> </item>
<item>
<widget class="QCheckBox" name="chkQRFast">
<property name="text">
<string>&amp;Fast mode</string>
</property>
<property name="toolTip">
<string>Only try four masks (0, 2, 4, 7) not eight
when automatically selecting a mask</string>
</property>
<property name="checked">
<bool>false</bool>
</property>
</widget>
</item>
<item> <item>
<widget class="QGroupBox" name="groupBoxQRStructApp"> <widget class="QGroupBox" name="groupBoxQRStructApp">
<property name="title"> <property name="title">

14
frontend_qt/grpUPNQR.ui
View File

@ -89,6 +89,20 @@
</item> </item>
</layout> </layout>
</item> </item>
<item>
<widget class="QCheckBox" name="chkUPNQRFast">
<property name="text">
<string>&amp;Fast mode</string>
</property>
<property name="toolTip">
<string>Only try four masks (0, 2, 4, 7) not eight
when automatically selecting a mask</string>
</property>
<property name="checked">
<bool>false</bool>
</property>
</widget>
</item>
<item> <item>
<spacer name="verticalSpacerQR"> <spacer name="verticalSpacerQR">
<property name="orientation"> <property name="orientation">

12
frontend_qt/mainwindow.cpp
View File

@ -1858,6 +1858,7 @@ void MainWindow::change_options()
connect(get_widget(QSL("radQRGS1")), SIGNAL(toggled( bool )), SLOT(update_preview())); connect(get_widget(QSL("radQRGS1")), SIGNAL(toggled( bool )), SLOT(update_preview()));
connect(get_widget(QSL("radQRHIBC")), SIGNAL(toggled( bool )), SLOT(update_preview())); connect(get_widget(QSL("radQRHIBC")), SIGNAL(toggled( bool )), SLOT(update_preview()));
connect(get_widget(QSL("chkQRFullMultibyte")), SIGNAL(toggled( bool )), SLOT(update_preview())); connect(get_widget(QSL("chkQRFullMultibyte")), SIGNAL(toggled( bool )), SLOT(update_preview()));
connect(get_widget(QSL("chkQRFast")), SIGNAL(toggled( bool )), SLOT(update_preview()));
connect(get_widget(QSL("cmbQRStructAppCount")), SIGNAL(currentIndexChanged( int )), SLOT(update_preview())); connect(get_widget(QSL("cmbQRStructAppCount")), SIGNAL(currentIndexChanged( int )), SLOT(update_preview()));
connect(get_widget(QSL("cmbQRStructAppCount")), SIGNAL(currentIndexChanged( int )), SLOT(structapp_ui_set())); connect(get_widget(QSL("cmbQRStructAppCount")), SIGNAL(currentIndexChanged( int )), SLOT(structapp_ui_set()));
connect(get_widget(QSL("cmbQRStructAppIndex")), SIGNAL(currentIndexChanged( int )), SLOT(update_preview())); connect(get_widget(QSL("cmbQRStructAppIndex")), SIGNAL(currentIndexChanged( int )), SLOT(update_preview()));
@ -1871,6 +1872,7 @@ void MainWindow::change_options()
load_sub_settings(settings, symbology); load_sub_settings(settings, symbology);
tabMain->insertTab(1, m_optionWidget, tr("UP&NQR")); tabMain->insertTab(1, m_optionWidget, tr("UP&NQR"));
connect(get_widget(QSL("cmbUPNQRMask")), SIGNAL(currentIndexChanged( int )), SLOT(update_preview())); connect(get_widget(QSL("cmbUPNQRMask")), SIGNAL(currentIndexChanged( int )), SLOT(update_preview()));
connect(get_widget(QSL("chkUPNQRFast")), SIGNAL(toggled( bool )), SLOT(update_preview()));
} }
} else if (symbology == BARCODE_RMQR) { } else if (symbology == BARCODE_RMQR) {
@ -2843,6 +2845,9 @@ void MainWindow::update_preview()
if (get_chk_val(QSL("chkQRFullMultibyte"))) { if (get_chk_val(QSL("chkQRFullMultibyte"))) {
m_bc.bc.setOption3(ZINT_FULL_MULTIBYTE | m_bc.bc.option3()); m_bc.bc.setOption3(ZINT_FULL_MULTIBYTE | m_bc.bc.option3());
} }
if (get_chk_val(QSL("chkQRFast"))) {
m_bc.bc.setInputMode(FAST_MODE | m_bc.bc.inputMode());
}
if ((item_val = get_cmb_index(QSL("cmbQRStructAppCount"))) != 0) { if ((item_val = get_cmb_index(QSL("cmbQRStructAppCount"))) != 0) {
QString id; QString id;
int id_val = get_spn_val(QSL("spnQRStructAppID")); int id_val = get_spn_val(QSL("spnQRStructAppID"));
@ -2872,6 +2877,9 @@ void MainWindow::update_preview()
if ((item_val = get_cmb_index(QSL("cmbUPNQRMask"))) != 0) { if ((item_val = get_cmb_index(QSL("cmbUPNQRMask"))) != 0) {
m_bc.bc.setOption3((item_val << 8) | m_bc.bc.option3()); m_bc.bc.setOption3((item_val << 8) | m_bc.bc.option3());
} }
if (get_chk_val(QSL("chkUPNQRFast"))) {
m_bc.bc.setInputMode(FAST_MODE | m_bc.bc.inputMode());
}
break; break;
case BARCODE_RMQR: case BARCODE_RMQR:
@ -4010,6 +4018,7 @@ void MainWindow::save_sub_settings(QSettings &settings, int symbology)
settings.setValue(QSL("studio/bc/qrcode/encoding_mode"), get_rad_grp_index( settings.setValue(QSL("studio/bc/qrcode/encoding_mode"), get_rad_grp_index(
QStringList() << QSL("radDM200Stand") << QSL("radQRGS1") << QSL("radQRHIBC"))); QStringList() << QSL("radDM200Stand") << QSL("radQRGS1") << QSL("radQRHIBC")));
settings.setValue(QSL("studio/bc/qrcode/chk_full_multibyte"), get_chk_val(QSL("chkQRFullMultibyte"))); settings.setValue(QSL("studio/bc/qrcode/chk_full_multibyte"), get_chk_val(QSL("chkQRFullMultibyte")));
settings.setValue(QSL("studio/bc/qrcode/chk_fast_mode"), get_chk_val(QSL("chkQRFast")));
settings.setValue(QSL("studio/bc/qrcode/structapp_count"), get_cmb_index(QSL("cmbQRStructAppCount"))); settings.setValue(QSL("studio/bc/qrcode/structapp_count"), get_cmb_index(QSL("cmbQRStructAppCount")));
settings.setValue(QSL("studio/bc/qrcode/structapp_index"), get_cmb_index(QSL("cmbQRStructAppIndex"))); settings.setValue(QSL("studio/bc/qrcode/structapp_index"), get_cmb_index(QSL("cmbQRStructAppIndex")));
settings.setValue(QSL("studio/bc/qrcode/structapp_id"), get_spn_val(QSL("spnQRStructAppID"))); settings.setValue(QSL("studio/bc/qrcode/structapp_id"), get_spn_val(QSL("spnQRStructAppID")));
@ -4017,6 +4026,7 @@ void MainWindow::save_sub_settings(QSettings &settings, int symbology)
case BARCODE_UPNQR: case BARCODE_UPNQR:
settings.setValue(QSL("studio/bc/upnqr/mask"), get_cmb_index(QSL("cmbUPNQRMask"))); settings.setValue(QSL("studio/bc/upnqr/mask"), get_cmb_index(QSL("cmbUPNQRMask")));
settings.setValue(QSL("studio/bc/upnqr/chk_fast_mode"), get_chk_val(QSL("chkUPNQRFast")));
break; break;
case BARCODE_RMQR: case BARCODE_RMQR:
@ -4411,6 +4421,7 @@ void MainWindow::load_sub_settings(QSettings &settings, int symbology)
set_rad_from_setting(settings, QSL("studio/bc/qrcode/encoding_mode"), set_rad_from_setting(settings, QSL("studio/bc/qrcode/encoding_mode"),
QStringList() << QSL("radDM200Stand") << QSL("radQRGS1") << QSL("radQRHIBC")); QStringList() << QSL("radDM200Stand") << QSL("radQRGS1") << QSL("radQRHIBC"));
set_chk_from_setting(settings, QSL("studio/bc/qrcode/chk_full_multibyte"), QSL("chkQRFullMultibyte")); set_chk_from_setting(settings, QSL("studio/bc/qrcode/chk_full_multibyte"), QSL("chkQRFullMultibyte"));
set_chk_from_setting(settings, QSL("studio/bc/qrcode/chk_fast_mode"), QSL("chkQRFast"));
set_cmb_from_setting(settings, QSL("studio/bc/qrcode/structapp_count"), QSL("cmbQRStructAppCount")); set_cmb_from_setting(settings, QSL("studio/bc/qrcode/structapp_count"), QSL("cmbQRStructAppCount"));
set_cmb_from_setting(settings, QSL("studio/bc/qrcode/structapp_index"), QSL("cmbQRStructAppIndex")); set_cmb_from_setting(settings, QSL("studio/bc/qrcode/structapp_index"), QSL("cmbQRStructAppIndex"));
set_spn_from_setting(settings, QSL("studio/bc/qrcode/structapp_id"), QSL("spnQRStructAppID"), 0); set_spn_from_setting(settings, QSL("studio/bc/qrcode/structapp_id"), QSL("spnQRStructAppID"), 0);
@ -4418,6 +4429,7 @@ void MainWindow::load_sub_settings(QSettings &settings, int symbology)
case BARCODE_UPNQR: case BARCODE_UPNQR:
set_cmb_from_setting(settings, QSL("studio/bc/upnqr/mask"), QSL("cmbUPNQRMask")); set_cmb_from_setting(settings, QSL("studio/bc/upnqr/mask"), QSL("cmbUPNQRMask"));
set_chk_from_setting(settings, QSL("studio/bc/upnqr/chk_fast_mode"), QSL("chkUPNQRFast"));
break; break;
case BARCODE_RMQR: case BARCODE_RMQR: