398 lines
12 KiB
C
398 lines
12 KiB
C
/*------------------------------------------------------------------------
|
|
* Copyright 2011 (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 <string.h> /* memmove */
|
|
|
|
#include <zbar.h>
|
|
|
|
#ifdef DEBUG_CODABAR
|
|
#define DEBUG_LEVEL (DEBUG_CODABAR)
|
|
#endif
|
|
#include "debug.h"
|
|
#include "decoder.h"
|
|
|
|
#define NIBUF 6 /* initial scan buffer size */
|
|
|
|
static const signed char codabar_lo[12] = { 0x0, 0x1, 0x4, 0x5, 0x2, 0xa,
|
|
0xb, 0x9, 0x6, 0x7, 0x8, 0x3 };
|
|
|
|
static const unsigned char codabar_hi[8] = { 0x1, 0x4, 0x7, 0x6,
|
|
0x2, 0x3, 0x0, 0x5 };
|
|
|
|
static const unsigned char codabar_characters[20] = "0123456789-$:/.+ABCD";
|
|
|
|
static inline int check_width(unsigned ref, unsigned w)
|
|
{
|
|
unsigned dref = ref;
|
|
ref *= 4;
|
|
w *= 4;
|
|
return (ref - dref <= w && w <= ref + dref);
|
|
}
|
|
|
|
static inline signed char codabar_decode7(zbar_decoder_t *dcode)
|
|
{
|
|
unsigned ibar, wbmax, wbmin, wb1, wb2;
|
|
unsigned long b0b3, b1b2;
|
|
unsigned ispc, wsmax, wsmid, wsmin;
|
|
unsigned long s0s2, s1s1;
|
|
codabar_decoder_t *codabar = &dcode->codabar;
|
|
unsigned s = codabar->s7;
|
|
dbprintf(2, " s=%d", s);
|
|
if (s < 7)
|
|
return (-1);
|
|
|
|
/* check width */
|
|
if (!check_width(codabar->width, s)) {
|
|
dbprintf(2, " [width]");
|
|
return (-1);
|
|
}
|
|
|
|
/* extract min/max bar */
|
|
ibar = decode_sortn(dcode, 4, 1);
|
|
dbprintf(2, " bar=%04x", ibar);
|
|
|
|
wbmax = get_width(dcode, ibar & 0xf);
|
|
wbmin = get_width(dcode, ibar >> 12);
|
|
if (8 * wbmin < wbmax || 3 * wbmin > 2 * wbmax) {
|
|
dbprintf(2, " [bar outer ratio]");
|
|
return (-1);
|
|
}
|
|
|
|
wb1 = get_width(dcode, (ibar >> 8) & 0xf);
|
|
wb2 = get_width(dcode, (ibar >> 4) & 0xf);
|
|
b0b3 = wbmin * wbmax;
|
|
b1b2 = wb1 * wb2;
|
|
if (b1b2 + b1b2 / 8 < b0b3) {
|
|
/* single wide bar combinations */
|
|
if (8 * wbmin < 5 * wb1 || 8 * wb1 < 5 * wb2 || 4 * wb2 > 3 * wbmax ||
|
|
wb2 * wb2 >= wb1 * wbmax) {
|
|
dbprintf(2, " [1bar inner ratios]");
|
|
return (-1);
|
|
}
|
|
ibar = (ibar >> 1) & 0x3;
|
|
} else if (b1b2 > b0b3 + b0b3 / 8) {
|
|
/* three wide bars, no wide spaces */
|
|
if (4 * wbmin > 3 * wb1 || 8 * wb1 < 5 * wb2 || 8 * wb2 < 5 * wbmax ||
|
|
wbmin * wb2 >= wb1 * wb1) {
|
|
dbprintf(2, " [3bar inner ratios]");
|
|
return (-1);
|
|
}
|
|
ibar = (ibar >> 13) + 4;
|
|
} else {
|
|
dbprintf(2, " [bar inner ratios]");
|
|
return (-1);
|
|
}
|
|
|
|
ispc = decode_sort3(dcode, 2);
|
|
dbprintf(2, "(%x) spc=%03x", ibar, ispc);
|
|
|
|
wsmax = get_width(dcode, ispc & 0xf);
|
|
wsmid = get_width(dcode, (ispc >> 4) & 0xf);
|
|
wsmin = get_width(dcode, (ispc >> 8) & 0xf);
|
|
if (ibar >> 2) {
|
|
int c;
|
|
/* verify no wide spaces */
|
|
if (8 * wsmin < wsmax || 8 * wsmin < 5 * wsmid ||
|
|
8 * wsmid < 5 * wsmax) {
|
|
dbprintf(2, " [0space inner ratios]");
|
|
return (-1);
|
|
}
|
|
ibar &= 0x3;
|
|
if (codabar->direction)
|
|
ibar = 3 - ibar;
|
|
c = (0xfcde >> (ibar << 2)) & 0xf;
|
|
dbprintf(2, " ex[%d]=%x", ibar, c);
|
|
return (c);
|
|
} else if (8 * wsmin < wsmax || 3 * wsmin > 2 * wsmax) {
|
|
dbprintf(2, " [space outer ratio]");
|
|
return (-1);
|
|
}
|
|
|
|
s0s2 = wsmin * wsmax;
|
|
s1s1 = wsmid * wsmid;
|
|
if (s1s1 + s1s1 / 8 < s0s2) {
|
|
unsigned ic;
|
|
int c;
|
|
/* single wide space */
|
|
if (8 * wsmin < 5 * wsmid || 4 * wsmid > 3 * wsmax) {
|
|
dbprintf(2, " [1space inner ratios]");
|
|
return (-1);
|
|
}
|
|
ispc = ((ispc & 0xf) >> 1) - 1;
|
|
ic = (ispc << 2) | ibar;
|
|
if (codabar->direction)
|
|
ic = 11 - ic;
|
|
c = codabar_lo[ic];
|
|
dbprintf(2, "(%d) lo[%d]=%x", ispc, ic, c);
|
|
return (c);
|
|
} else if (s1s1 > s0s2 + s0s2 / 8) {
|
|
unsigned ic;
|
|
unsigned char c;
|
|
/* two wide spaces, check start/stop */
|
|
if (4 * wsmin > 3 * wsmid || 8 * wsmid < 5 * wsmax) {
|
|
dbprintf(2, " [2space inner ratios]");
|
|
return (-1);
|
|
}
|
|
if ((ispc >> 8) == 4) {
|
|
dbprintf(2, " [space comb]");
|
|
return (-1);
|
|
}
|
|
ispc >>= 10;
|
|
dbprintf(2, "(%d)", ispc);
|
|
ic = ispc * 4 + ibar;
|
|
zassert(ic < 8, -1, "ic=%d ispc=%d ibar=%d", ic, ispc, ibar);
|
|
c = codabar_hi[ic];
|
|
if (c >> 2 != codabar->direction) {
|
|
dbprintf(2, " [invalid stop]");
|
|
return (-1);
|
|
}
|
|
c = (c & 0x3) | 0x10;
|
|
dbprintf(2, " hi[%d]=%x", ic, c);
|
|
return (c);
|
|
} else {
|
|
dbprintf(2, " [space inner ratios]");
|
|
return (-1);
|
|
}
|
|
}
|
|
|
|
static inline signed char codabar_decode_start(zbar_decoder_t *dcode)
|
|
{
|
|
unsigned qz, ispc, wsmax, wsmin, wsmid, ibar, wbmax, wbmin, wb1, wb2;
|
|
int ic, c;
|
|
codabar_decoder_t *codabar = &dcode->codabar;
|
|
unsigned s = codabar->s7;
|
|
if (s < 8)
|
|
return (ZBAR_NONE);
|
|
dbprintf(2, " codabar: s=%d", s);
|
|
|
|
/* check leading quiet zone - spec is 10x */
|
|
qz = get_width(dcode, 8);
|
|
if ((qz && qz * 2 < s) || 4 * get_width(dcode, 0) > 3 * s) {
|
|
dbprintf(2, " [invalid qz/ics]\n");
|
|
return (ZBAR_NONE);
|
|
}
|
|
|
|
/* check space ratios first */
|
|
ispc = decode_sort3(dcode, 2);
|
|
dbprintf(2, " spc=%03x", ispc);
|
|
if ((ispc >> 8) == 4) {
|
|
dbprintf(2, " [space comb]\n");
|
|
return (ZBAR_NONE);
|
|
}
|
|
|
|
/* require 2 wide and 1 narrow spaces */
|
|
wsmax = get_width(dcode, ispc & 0xf);
|
|
wsmin = get_width(dcode, ispc >> 8);
|
|
wsmid = get_width(dcode, (ispc >> 4) & 0xf);
|
|
if (8 * wsmin < wsmax || 3 * wsmin > 2 * wsmax || 4 * wsmin > 3 * wsmid ||
|
|
8 * wsmid < 5 * wsmax || wsmid * wsmid <= wsmax * wsmin) {
|
|
dbprintf(2, " [space ratio]\n");
|
|
return (ZBAR_NONE);
|
|
}
|
|
ispc >>= 10;
|
|
dbprintf(2, "(%d)", ispc);
|
|
|
|
/* check bar ratios */
|
|
ibar = decode_sortn(dcode, 4, 1);
|
|
dbprintf(2, " bar=%04x", ibar);
|
|
|
|
wbmax = get_width(dcode, ibar & 0xf);
|
|
wbmin = get_width(dcode, ibar >> 12);
|
|
if (8 * wbmin < wbmax || 3 * wbmin > 2 * wbmax) {
|
|
dbprintf(2, " [bar outer ratio]\n");
|
|
return (ZBAR_NONE);
|
|
}
|
|
|
|
/* require 1 wide & 3 narrow bars */
|
|
wb1 = get_width(dcode, (ibar >> 8) & 0xf);
|
|
wb2 = get_width(dcode, (ibar >> 4) & 0xf);
|
|
if (8 * wbmin < 5 * wb1 || 8 * wb1 < 5 * wb2 || 4 * wb2 > 3 * wbmax ||
|
|
wb1 * wb2 >= wbmin * wbmax || wb2 * wb2 >= wb1 * wbmax) {
|
|
dbprintf(2, " [bar inner ratios]\n");
|
|
return (ZBAR_NONE);
|
|
}
|
|
ibar = ((ibar & 0xf) - 1) >> 1;
|
|
dbprintf(2, "(%d)", ibar);
|
|
|
|
/* decode combination */
|
|
ic = ispc * 4 + ibar;
|
|
zassert(ic < 8, ZBAR_NONE, "ic=%d ispc=%d ibar=%d", ic, ispc, ibar);
|
|
c = codabar_hi[ic];
|
|
codabar->buf[0] = (c & 0x3) | 0x10;
|
|
|
|
/* set character direction */
|
|
codabar->direction = c >> 2;
|
|
|
|
codabar->element = 4;
|
|
codabar->character = 1;
|
|
codabar->width = codabar->s7;
|
|
dbprintf(1, " start=%c dir=%x [valid start]\n", codabar->buf[0] + 0x31,
|
|
codabar->direction);
|
|
return (ZBAR_PARTIAL);
|
|
}
|
|
|
|
static inline int codabar_checksum(zbar_decoder_t *dcode, unsigned n)
|
|
{
|
|
unsigned chk = 0;
|
|
unsigned char *buf = dcode->buf;
|
|
while (n--)
|
|
chk += *(buf++);
|
|
return (!!(chk & 0xf));
|
|
}
|
|
|
|
static inline zbar_symbol_type_t codabar_postprocess(zbar_decoder_t *dcode)
|
|
{
|
|
int dir, i, n;
|
|
codabar_decoder_t *codabar = &dcode->codabar;
|
|
dir = codabar->direction;
|
|
dcode->direction = 1 - 2 * dir;
|
|
n = codabar->character;
|
|
for (i = 0; i < NIBUF; i++)
|
|
dcode->buf[i] = codabar->buf[i];
|
|
if (dir)
|
|
/* reverse buffer */
|
|
for (i = 0; i < n / 2; i++) {
|
|
unsigned j = n - 1 - i;
|
|
char code = dcode->buf[i];
|
|
dcode->buf[i] = dcode->buf[j];
|
|
dcode->buf[j] = code;
|
|
}
|
|
|
|
if (TEST_CFG(codabar->config, ZBAR_CFG_ADD_CHECK)) {
|
|
/* validate checksum */
|
|
if (codabar_checksum(dcode, n))
|
|
return (ZBAR_NONE);
|
|
if (!TEST_CFG(codabar->config, ZBAR_CFG_EMIT_CHECK)) {
|
|
dcode->buf[n - 2] = dcode->buf[n - 1];
|
|
n--;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < n; i++) {
|
|
unsigned c = dcode->buf[i];
|
|
dcode->buf[i] = ((c < 0x14) ? codabar_characters[c] : '?');
|
|
}
|
|
dcode->buflen = i;
|
|
dcode->buf[i] = '\0';
|
|
dcode->modifiers = 0;
|
|
|
|
codabar->character = -1;
|
|
return (ZBAR_CODABAR);
|
|
}
|
|
|
|
zbar_symbol_type_t _zbar_decode_codabar(zbar_decoder_t *dcode)
|
|
{
|
|
signed char c;
|
|
unsigned char *buf;
|
|
unsigned s;
|
|
codabar_decoder_t *codabar = &dcode->codabar;
|
|
|
|
/* update latest character width */
|
|
codabar->s7 -= get_width(dcode, 8);
|
|
codabar->s7 += get_width(dcode, 1);
|
|
|
|
if (get_color(dcode) != ZBAR_SPACE)
|
|
return (ZBAR_NONE);
|
|
if (codabar->character < 0)
|
|
return (codabar_decode_start(dcode));
|
|
if (codabar->character < 2 && codabar_decode_start(dcode))
|
|
return (ZBAR_PARTIAL);
|
|
if (--codabar->element)
|
|
return (ZBAR_NONE);
|
|
codabar->element = 4;
|
|
|
|
dbprintf(1, " codabar[%c%02d+%x]", (codabar->direction) ? '<' : '>',
|
|
codabar->character, codabar->element);
|
|
|
|
c = codabar_decode7(dcode);
|
|
dbprintf(1, " %d", c);
|
|
if (c < 0) {
|
|
dbprintf(1, " [aborted]\n");
|
|
goto reset;
|
|
}
|
|
|
|
if (codabar->character < NIBUF)
|
|
buf = codabar->buf;
|
|
else {
|
|
if (codabar->character >= BUFFER_MIN &&
|
|
size_buf(dcode, codabar->character + 1)) {
|
|
dbprintf(1, " [overflow]\n");
|
|
goto reset;
|
|
}
|
|
buf = dcode->buf;
|
|
}
|
|
buf[codabar->character++] = c;
|
|
|
|
/* lock shared resources */
|
|
if (codabar->character == NIBUF && acquire_lock(dcode, ZBAR_CODABAR)) {
|
|
codabar->character = -1;
|
|
return (ZBAR_PARTIAL);
|
|
}
|
|
|
|
s = codabar->s7;
|
|
if (c & 0x10) {
|
|
zbar_symbol_type_t sym;
|
|
unsigned n;
|
|
unsigned qz = get_width(dcode, 0);
|
|
if (qz && qz * 2 < s) {
|
|
dbprintf(2, " [invalid qz]\n");
|
|
goto reset;
|
|
}
|
|
n = codabar->character;
|
|
if (n < CFG(*codabar, ZBAR_CFG_MIN_LEN) ||
|
|
(CFG(*codabar, ZBAR_CFG_MAX_LEN) > 0 &&
|
|
n > CFG(*codabar, ZBAR_CFG_MAX_LEN))) {
|
|
dbprintf(2, " [invalid len]\n");
|
|
goto reset;
|
|
}
|
|
if (codabar->character < NIBUF && acquire_lock(dcode, ZBAR_CODABAR)) {
|
|
codabar->character = -1;
|
|
return (ZBAR_PARTIAL);
|
|
}
|
|
dbprintf(2, " stop=%c", c + 0x31);
|
|
|
|
sym = codabar_postprocess(dcode);
|
|
if (sym > ZBAR_PARTIAL)
|
|
dbprintf(2, " [valid stop]");
|
|
else {
|
|
release_lock(dcode, ZBAR_CODABAR);
|
|
codabar->character = -1;
|
|
}
|
|
dbprintf(2, "\n");
|
|
return (sym);
|
|
} else if (4 * get_width(dcode, 0) > 3 * s) {
|
|
dbprintf(2, " [ics]\n");
|
|
goto reset;
|
|
}
|
|
|
|
dbprintf(2, "\n");
|
|
return (ZBAR_NONE);
|
|
|
|
reset:
|
|
if (codabar->character >= NIBUF)
|
|
release_lock(dcode, ZBAR_CODABAR);
|
|
codabar->character = -1;
|
|
return (ZBAR_NONE);
|
|
}
|