388 lines
11 KiB
C
388 lines
11 KiB
C
/*------------------------------------------------------------------------
|
|
* Copyright 2010 (c) Jeff Brown <spadix@users.sourceforge.net>
|
|
*
|
|
* This file is part of the ZBar Bar Code Reader.
|
|
*
|
|
* The ZBar Bar Code Reader is free software; you can redistribute it
|
|
* and/or modify it under the terms of the GNU Lesser Public License as
|
|
* published by the Free Software Foundation; either version 2.1 of
|
|
* the License, or (at your option) any later version.
|
|
*
|
|
* The ZBar Bar Code Reader is distributed in the hope that it will be
|
|
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty
|
|
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser Public License
|
|
* along with the ZBar Bar Code Reader; if not, write to the Free
|
|
* Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
|
* Boston, MA 02110-1301 USA
|
|
*
|
|
* http://sourceforge.net/projects/zbar
|
|
*------------------------------------------------------------------------*/
|
|
|
|
#include "config.h"
|
|
#include <zbar.h>
|
|
|
|
#ifdef DEBUG_CODE93
|
|
#define DEBUG_LEVEL (DEBUG_CODE93)
|
|
#endif
|
|
#include "debug.h"
|
|
#include "decoder.h"
|
|
|
|
static const signed char code93_hash[0x40] = {
|
|
0x0f, 0x2b, 0x30, 0x38, 0x13, 0x1b, 0x11, 0x2a, 0x0a, -1, 0x2f,
|
|
0x0f, 0x38, 0x38, 0x2f, 0x37, 0x24, 0x3a, 0x1b, 0x36, 0x18, 0x26,
|
|
0x02, 0x2c, 0x2b, 0x05, 0x21, 0x3b, 0x04, 0x15, 0x12, 0x0c, 0x00,
|
|
0x26, 0x23, 0x00, -1, 0x2e, 0x3f, 0x13, 0x2e, 0x36, -1, 0x08,
|
|
0x09, -1, 0x15, 0x14, -1, 0x00, 0x21, 0x3b, -1, 0x33, 0x00,
|
|
-1, 0x2d, 0x0c, 0x1b, 0x0a, 0x3f, 0x3f, 0x29, 0x1c,
|
|
};
|
|
|
|
static inline int check_width(unsigned cur, unsigned prev)
|
|
{
|
|
unsigned dw;
|
|
if (prev > cur)
|
|
dw = prev - cur;
|
|
else
|
|
dw = cur - prev;
|
|
dw *= 4;
|
|
return (dw > prev);
|
|
}
|
|
|
|
static inline int encode6(zbar_decoder_t *dcode)
|
|
{
|
|
/* build edge signature of character */
|
|
unsigned s = dcode->s6;
|
|
int sig = 0, i;
|
|
|
|
dbprintf(2, " s=%d ", s);
|
|
if (s < 9)
|
|
return (-1);
|
|
|
|
for (i = 6; --i > 0;) {
|
|
unsigned c = decode_e(pair_width(dcode, i), s, 9);
|
|
if (c > 3)
|
|
return (-1);
|
|
sig = (sig << 2) | c;
|
|
dbprintf(2, "%d", c);
|
|
}
|
|
dbprintf(2, " sig=%03x", sig);
|
|
|
|
return (sig);
|
|
}
|
|
|
|
static inline int validate_sig(int sig)
|
|
{
|
|
int i, sum = 0, emin = 0, sig0 = 0, sig1 = 0;
|
|
dbprintf(3, " sum=0");
|
|
for (i = 3; --i >= 0;) {
|
|
int e = sig & 3;
|
|
sig >>= 2;
|
|
sum = e - sum;
|
|
sig1 <<= 4;
|
|
sig1 += sum;
|
|
dbprintf(3, "%d", sum);
|
|
if (!i)
|
|
break;
|
|
|
|
e = sig & 3;
|
|
sig >>= 2;
|
|
sum = e - sum;
|
|
sig0 <<= 4;
|
|
if (emin > sum)
|
|
emin = sum;
|
|
sig0 += sum;
|
|
dbprintf(3, "%d", sum);
|
|
}
|
|
|
|
dbprintf(3, " emin=%d sig=%03x/%03x", emin, sig1 & 0xfff, sig0 & 0xfff);
|
|
|
|
emin = emin + (emin << 4) + (emin << 8);
|
|
sig0 -= emin;
|
|
sig1 += emin;
|
|
|
|
dbprintf(3, "=%03x/%03x", sig1 & 0xfff, sig0 & 0xfff);
|
|
return ((sig0 | sig1) & 0x888);
|
|
}
|
|
|
|
static inline int decode6(zbar_decoder_t *dcode)
|
|
{
|
|
int sig = encode6(dcode);
|
|
int g0, g1, c;
|
|
if (sig < 0 || (sig & 0x3) + ((sig >> 4) & 0x3) + ((sig >> 8) & 0x3) != 3 ||
|
|
validate_sig(sig))
|
|
return (-1);
|
|
|
|
if (dcode->code93.direction) {
|
|
/* reverse signature */
|
|
unsigned tmp = sig & 0x030;
|
|
sig = ((sig & 0x3c0) >> 6) | ((sig & 0x00f) << 6);
|
|
sig = ((sig & 0x30c) >> 2) | ((sig & 0x0c3) << 2) | tmp;
|
|
}
|
|
|
|
g0 = code93_hash[(sig - (sig >> 4)) & 0x3f];
|
|
g1 = code93_hash[((sig >> 2) - (sig >> 7)) & 0x3f];
|
|
zassert(g0 >= 0 && g1 >= 0, -1, "dir=%x sig=%03x g0=%03x g1=%03x %s\n",
|
|
dcode->code93.direction, sig, g0, g1,
|
|
_zbar_decoder_buf_dump(dcode->buf, dcode->code93.character));
|
|
|
|
c = (g0 + g1) & 0x3f;
|
|
dbprintf(2, " g0=%x g1=%x c=%02x", g0, g1, c);
|
|
return (c);
|
|
}
|
|
|
|
static inline zbar_symbol_type_t decode_start(zbar_decoder_t *dcode)
|
|
{
|
|
code93_decoder_t *dcode93 = &dcode->code93;
|
|
unsigned dir, qz, s = dcode->s6;
|
|
int c;
|
|
|
|
dbprintf(2, " code93:");
|
|
c = encode6(dcode);
|
|
if (c < 0 || (c != 0x00f && c != 0x0f0))
|
|
return (ZBAR_NONE);
|
|
|
|
dir = (c >> 7);
|
|
|
|
if (dir) {
|
|
if (decode_e(pair_width(dcode, 0), s, 9))
|
|
return (ZBAR_NONE);
|
|
qz = get_width(dcode, 8);
|
|
}
|
|
|
|
qz = get_width(dcode, 7);
|
|
if (qz && qz < (s * 3) / 4) {
|
|
dbprintf(2, " [invalid qz %d]", qz);
|
|
return (ZBAR_NONE);
|
|
}
|
|
|
|
/* decoded valid start/stop - initialize state */
|
|
dcode93->direction = dir;
|
|
dcode93->element = (!dir) ? 0 : 7;
|
|
dcode93->character = 0;
|
|
dcode93->width = s;
|
|
|
|
dbprintf(2, " dir=%x [valid start]", dir);
|
|
return (ZBAR_PARTIAL);
|
|
}
|
|
|
|
static inline zbar_symbol_type_t decode_abort(zbar_decoder_t *dcode,
|
|
const char *reason)
|
|
{
|
|
code93_decoder_t *dcode93 = &dcode->code93;
|
|
if (dcode93->character > 1)
|
|
release_lock(dcode, ZBAR_CODE93);
|
|
dcode93->character = -1;
|
|
if (reason)
|
|
dbprintf(1, " [%s]\n", reason);
|
|
return (ZBAR_NONE);
|
|
}
|
|
|
|
static inline zbar_symbol_type_t check_stop(zbar_decoder_t *dcode)
|
|
{
|
|
code93_decoder_t *dcode93 = &dcode->code93;
|
|
unsigned n = dcode93->character, s = dcode->s6;
|
|
int max_len = CFG(*dcode93, ZBAR_CFG_MAX_LEN);
|
|
if (n < 2 || n < CFG(*dcode93, ZBAR_CFG_MIN_LEN) ||
|
|
(max_len && n > max_len))
|
|
return (decode_abort(dcode, "invalid len"));
|
|
|
|
if (dcode93->direction) {
|
|
unsigned qz = get_width(dcode, 0);
|
|
if (qz && qz < (s * 3) / 4)
|
|
return (decode_abort(dcode, "invalid qz"));
|
|
} else if (decode_e(pair_width(dcode, 0), s, 9))
|
|
/* FIXME forward-trailing QZ check */
|
|
return (decode_abort(dcode, "invalid stop"));
|
|
|
|
return (ZBAR_CODE93);
|
|
}
|
|
|
|
#define CHKMOD (47)
|
|
|
|
static inline int plusmod47(int acc, int add)
|
|
{
|
|
acc += add;
|
|
if (acc >= CHKMOD)
|
|
acc -= CHKMOD;
|
|
return (acc);
|
|
}
|
|
|
|
static inline int validate_checksums(zbar_decoder_t *dcode)
|
|
{
|
|
code93_decoder_t *dcode93 = &dcode->code93;
|
|
unsigned d, i, n = dcode93->character;
|
|
unsigned sum_c = 0, acc_c = 0, i_c = (n - 2) % 20;
|
|
unsigned sum_k = 0, acc_k = 0, i_k = (n - 1) % 15;
|
|
|
|
for (i = 0; i < n - 2; i++) {
|
|
d = dcode->buf[(dcode93->direction) ? n - 1 - i : i];
|
|
|
|
if (!i_c--) {
|
|
acc_c = 0;
|
|
i_c = 19;
|
|
}
|
|
acc_c = plusmod47(acc_c, d);
|
|
sum_c = plusmod47(sum_c, acc_c);
|
|
|
|
if (!i_k--) {
|
|
acc_k = 0;
|
|
i_k = 14;
|
|
}
|
|
acc_k = plusmod47(acc_k, d);
|
|
sum_k = plusmod47(sum_k, acc_k);
|
|
}
|
|
|
|
d = dcode->buf[(dcode93->direction) ? 1 : n - 2];
|
|
dbprintf(2, " C=%02x?=%02x", d, sum_c);
|
|
if (d != sum_c)
|
|
return (1);
|
|
|
|
acc_k = plusmod47(acc_k, sum_c);
|
|
sum_k = plusmod47(sum_k, acc_k);
|
|
d = dcode->buf[(dcode93->direction) ? 0 : n - 1];
|
|
dbprintf(2, " K=%02x?=%02x", d, sum_k);
|
|
if (d != sum_k)
|
|
return (1);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/* resolve scan direction and convert to ASCII */
|
|
static inline int postprocess(zbar_decoder_t *dcode)
|
|
{
|
|
code93_decoder_t *dcode93 = &dcode->code93;
|
|
unsigned i, j, n = dcode93->character;
|
|
static const unsigned char code93_graph[] = "-. $/+%";
|
|
static const unsigned char code93_s2[] =
|
|
"\x1b\x1c\x1d\x1e\x1f;<=>?[\\]^_{|}~\x7f\x00\x40`\x7f\x7f\x7f";
|
|
|
|
dbprintf(2, "\n postproc len=%d", n);
|
|
dcode->direction = 1 - 2 * dcode93->direction;
|
|
if (dcode93->direction) {
|
|
/* reverse buffer */
|
|
dbprintf(2, " (rev)");
|
|
for (i = 0; i < n / 2; i++) {
|
|
unsigned j = n - 1 - i;
|
|
unsigned char d = dcode->buf[i];
|
|
dcode->buf[i] = dcode->buf[j];
|
|
dcode->buf[j] = d;
|
|
}
|
|
}
|
|
|
|
n -= 2;
|
|
for (i = 0, j = 0; i < n;) {
|
|
unsigned char d = dcode->buf[i++];
|
|
if (d < 0xa)
|
|
d = '0' + d;
|
|
else if (d < 0x24)
|
|
d = 'A' + d - 0xa;
|
|
else if (d < 0x2b)
|
|
d = code93_graph[d - 0x24];
|
|
else {
|
|
unsigned shift = d;
|
|
zassert(shift < 0x2f, -1, "%s\n",
|
|
_zbar_decoder_buf_dump(dcode->buf, dcode93->character));
|
|
d = dcode->buf[i++];
|
|
if (d < 0xa || d >= 0x24)
|
|
return (1);
|
|
d -= 0xa;
|
|
switch (shift) {
|
|
case 0x2b:
|
|
d++;
|
|
break;
|
|
case 0x2c:
|
|
d = code93_s2[d];
|
|
break;
|
|
case 0x2d:
|
|
d += 0x21;
|
|
break;
|
|
case 0x2e:
|
|
d += 0x61;
|
|
break;
|
|
default:
|
|
return (1);
|
|
}
|
|
}
|
|
dcode->buf[j++] = d;
|
|
}
|
|
|
|
zassert(j < dcode->buf_alloc, 1, "j=%02x %s\n", j,
|
|
_zbar_decoder_buf_dump(dcode->buf, dcode->code93.character));
|
|
dcode->buflen = j;
|
|
dcode->buf[j] = '\0';
|
|
dcode->modifiers = 0;
|
|
return (0);
|
|
}
|
|
|
|
zbar_symbol_type_t _zbar_decode_code93(zbar_decoder_t *dcode)
|
|
{
|
|
code93_decoder_t *dcode93 = &dcode->code93;
|
|
int c;
|
|
|
|
if (dcode93->character < 0) {
|
|
zbar_symbol_type_t sym;
|
|
if (get_color(dcode) != ZBAR_BAR)
|
|
return (ZBAR_NONE);
|
|
sym = decode_start(dcode);
|
|
dbprintf(2, "\n");
|
|
return (sym);
|
|
}
|
|
|
|
if (/* process every 6th element of active symbol */
|
|
++dcode93->element != 6 ||
|
|
/* decode color based on direction */
|
|
get_color(dcode) == dcode93->direction)
|
|
return (ZBAR_NONE);
|
|
|
|
dcode93->element = 0;
|
|
|
|
dbprintf(2, " code93[%c%02d+%x]:", (dcode93->direction) ? '<' : '>',
|
|
dcode93->character, dcode93->element);
|
|
|
|
if (check_width(dcode->s6, dcode93->width))
|
|
return (decode_abort(dcode, "width var"));
|
|
|
|
c = decode6(dcode);
|
|
if (c < 0)
|
|
return (decode_abort(dcode, "aborted"));
|
|
|
|
if (c == 0x2f) {
|
|
if (!check_stop(dcode))
|
|
return (ZBAR_NONE);
|
|
if (validate_checksums(dcode))
|
|
return (decode_abort(dcode, "checksum error"));
|
|
if (postprocess(dcode))
|
|
return (decode_abort(dcode, "invalid encoding"));
|
|
|
|
dbprintf(2, " [valid end]\n");
|
|
dbprintf(3, " %s\n",
|
|
_zbar_decoder_buf_dump(dcode->buf, dcode93->character));
|
|
|
|
dcode93->character = -1;
|
|
return (ZBAR_CODE93);
|
|
}
|
|
|
|
if (size_buf(dcode, dcode93->character + 1))
|
|
return (decode_abort(dcode, "overflow"));
|
|
|
|
dcode93->width = dcode->s6;
|
|
|
|
if (dcode93->character == 1) {
|
|
/* lock shared resources */
|
|
if (acquire_lock(dcode, ZBAR_CODE93))
|
|
return (decode_abort(dcode, NULL));
|
|
dcode->buf[0] = dcode93->buf;
|
|
}
|
|
|
|
if (!dcode93->character)
|
|
dcode93->buf = c;
|
|
else
|
|
dcode->buf[dcode93->character] = c;
|
|
dcode93->character++;
|
|
|
|
dbprintf(2, "\n");
|
|
return (ZBAR_NONE);
|
|
}
|