Leptonica  1.77.0
Image processing and image analysis suite
bardecode.c
Go to the documentation of this file.
1 /*====================================================================*
2  - Copyright (C) 2001 Leptonica. All rights reserved.
3  -
4  - Redistribution and use in source and binary forms, with or without
5  - modification, are permitted provided that the following conditions
6  - are met:
7  - 1. Redistributions of source code must retain the above copyright
8  - notice, this list of conditions and the following disclaimer.
9  - 2. Redistributions in binary form must reproduce the above
10  - copyright notice, this list of conditions and the following
11  - disclaimer in the documentation and/or other materials
12  - provided with the distribution.
13  -
14  - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
15  - ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
16  - LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
17  - A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ANY
18  - CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  - EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  - PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  - OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
23  - NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
24  - SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  *====================================================================*/
26 
62 #include <string.h>
63 #include "allheaders.h"
64 #include "readbarcode.h"
65 
66 
67 static l_int32 barcodeFindFormat(char *barstr);
68 static l_int32 barcodeVerifyFormat(char *barstr, l_int32 format,
69  l_int32 *pvalid, l_int32 *preverse);
70 static char *barcodeDecode2of5(char *barstr, l_int32 debugflag);
71 static char *barcodeDecodeI2of5(char *barstr, l_int32 debugflag);
72 static char *barcodeDecode93(char *barstr, l_int32 debugflag);
73 static char *barcodeDecode39(char *barstr, l_int32 debugflag);
74 static char *barcodeDecodeCodabar(char *barstr, l_int32 debugflag);
75 static char *barcodeDecodeUpca(char *barstr, l_int32 debugflag);
76 static char *barcodeDecodeEan13(char *barstr, l_int32 first, l_int32 debugflag);
77 
78 
79 #ifndef NO_CONSOLE_IO
80 #define DEBUG_CODES 0
81 #endif /* ~NO_CONSOLE_IO */
82 
83 
84 /*------------------------------------------------------------------------*
85  * Decoding dispatcher *
86  *------------------------------------------------------------------------*/
95 char *
96 barcodeDispatchDecoder(char *barstr,
97  l_int32 format,
98  l_int32 debugflag)
99 {
100 char *data = NULL;
101 
102  PROCNAME("barcodeDispatchDecoder");
103 
104  if (!barstr)
105  return (char *)ERROR_PTR("barstr not defined", procName, NULL);
106 
107  debugflag = FALSE; /* not used yet */
108 
109  if (format == L_BF_ANY)
110  format = barcodeFindFormat(barstr);
111 
112  if (format == L_BF_CODE2OF5)
113  data = barcodeDecode2of5(barstr, debugflag);
114  else if (format == L_BF_CODEI2OF5)
115  data = barcodeDecodeI2of5(barstr, debugflag);
116  else if (format == L_BF_CODE93)
117  data = barcodeDecode93(barstr, debugflag);
118  else if (format == L_BF_CODE39)
119  data = barcodeDecode39(barstr, debugflag);
120  else if (format == L_BF_CODABAR)
121  data = barcodeDecodeCodabar(barstr, debugflag);
122  else if (format == L_BF_UPCA)
123  data = barcodeDecodeUpca(barstr, debugflag);
124  else if (format == L_BF_EAN13)
125  data = barcodeDecodeEan13(barstr, 0, debugflag);
126  else
127  return (char *)ERROR_PTR("format not implemented", procName, NULL);
128 
129  return data;
130 }
131 
132 
133 /*------------------------------------------------------------------------*
134  * Barcode format determination *
135  *------------------------------------------------------------------------*/
142 static l_int32
143 barcodeFindFormat(char *barstr)
144 {
145 l_int32 i, format, valid;
146 
147  PROCNAME("barcodeFindFormat");
148 
149  if (!barstr)
150  return ERROR_INT("barstr not defined", procName, L_BF_UNKNOWN);
151 
152  for (i = 0; i < NumSupportedBarcodeFormats; i++) {
153  format = SupportedBarcodeFormat[i];
154  barcodeVerifyFormat(barstr, format, &valid, NULL);
155  if (valid) {
156  L_INFO("Barcode format: %s\n", procName,
157  SupportedBarcodeFormatName[i]);
158  return format;
159  }
160  }
161  return L_BF_UNKNOWN;
162 }
163 
164 
172 l_int32
173 barcodeFormatIsSupported(l_int32 format)
174 {
175 l_int32 i;
176 
177  for (i = 0; i < NumSupportedBarcodeFormats; i++) {
178  if (format == SupportedBarcodeFormat[i])
179  return 1;
180  }
181  return 0;
182 }
183 
184 
203 static l_int32
204 barcodeVerifyFormat(char *barstr,
205  l_int32 format,
206  l_int32 *pvalid,
207  l_int32 *preverse)
208 {
209 char *revbarstr;
210 l_int32 i, start, len, stop, mid;
211 
212  PROCNAME("barcodeVerifyFormat");
213 
214  if (!pvalid)
215  return ERROR_INT("barstr not defined", procName, 1);
216  *pvalid = 0;
217  if (preverse) *preverse = 0;
218  if (!barstr)
219  return ERROR_INT("barstr not defined", procName, 1);
220 
221  switch (format)
222  {
223  case L_BF_CODE2OF5:
224  start = !strncmp(barstr, Code2of5[C25_START], 3);
225  len = strlen(barstr);
226  stop = !strncmp(&barstr[len - 5], Code2of5[C25_STOP], 5);
227  if (start && stop) {
228  *pvalid = 1;
229  } else {
230  revbarstr = stringReverse(barstr);
231  start = !strncmp(revbarstr, Code2of5[C25_START], 3);
232  stop = !strncmp(&revbarstr[len - 5], Code2of5[C25_STOP], 5);
233  LEPT_FREE(revbarstr);
234  if (start && stop) {
235  *pvalid = 1;
236  if (preverse) *preverse = 1;
237  }
238  }
239  break;
240  case L_BF_CODEI2OF5:
241  start = !strncmp(barstr, CodeI2of5[CI25_START], 4);
242  len = strlen(barstr);
243  stop = !strncmp(&barstr[len - 3], CodeI2of5[CI25_STOP], 3);
244  if (start && stop) {
245  *pvalid = 1;
246  } else {
247  revbarstr = stringReverse(barstr);
248  start = !strncmp(revbarstr, CodeI2of5[CI25_START], 4);
249  stop = !strncmp(&revbarstr[len - 3], CodeI2of5[CI25_STOP], 3);
250  LEPT_FREE(revbarstr);
251  if (start && stop) {
252  *pvalid = 1;
253  if (preverse) *preverse = 1;
254  }
255  }
256  break;
257  case L_BF_CODE93:
258  start = !strncmp(barstr, Code93[C93_START], 6);
259  len = strlen(barstr);
260  stop = !strncmp(&barstr[len - 7], Code93[C93_STOP], 6);
261  if (start && stop) {
262  *pvalid = 1;
263  } else {
264  revbarstr = stringReverse(barstr);
265  start = !strncmp(revbarstr, Code93[C93_START], 6);
266  stop = !strncmp(&revbarstr[len - 7], Code93[C93_STOP], 6);
267  LEPT_FREE(revbarstr);
268  if (start && stop) {
269  *pvalid = 1;
270  if (preverse) *preverse = 1;
271  }
272  }
273  break;
274  case L_BF_CODE39:
275  start = !strncmp(barstr, Code39[C39_START], 9);
276  len = strlen(barstr);
277  stop = !strncmp(&barstr[len - 9], Code39[C39_STOP], 9);
278  if (start && stop) {
279  *pvalid = 1;
280  } else {
281  revbarstr = stringReverse(barstr);
282  start = !strncmp(revbarstr, Code39[C39_START], 9);
283  stop = !strncmp(&revbarstr[len - 9], Code39[C39_STOP], 9);
284  LEPT_FREE(revbarstr);
285  if (start && stop) {
286  *pvalid = 1;
287  if (preverse) *preverse = 1;
288  }
289  }
290  break;
291  case L_BF_CODABAR:
292  start = stop = 0;
293  len = strlen(barstr);
294  for (i = 16; i <= 19; i++) /* any of these will do */
295  start += !strncmp(barstr, Codabar[i], 7);
296  for (i = 16; i <= 19; i++) /* ditto */
297  stop += !strncmp(&barstr[len - 7], Codabar[i], 7);
298  if (start && stop) {
299  *pvalid = 1;
300  } else {
301  start = stop = 0;
302  revbarstr = stringReverse(barstr);
303  for (i = 16; i <= 19; i++)
304  start += !strncmp(revbarstr, Codabar[i], 7);
305  for (i = 16; i <= 19; i++)
306  stop += !strncmp(&revbarstr[len - 7], Codabar[i], 7);
307  LEPT_FREE(revbarstr);
308  if (start && stop) {
309  *pvalid = 1;
310  if (preverse) *preverse = 1;
311  }
312  }
313  break;
314  case L_BF_UPCA:
315  case L_BF_EAN13:
316  len = strlen(barstr);
317  if (len == 59) {
318  start = !strncmp(barstr, Upca[UPCA_START], 3);
319  mid = !strncmp(&barstr[27], Upca[UPCA_MID], 5);
320  stop = !strncmp(&barstr[len - 3], Upca[UPCA_STOP], 3);
321  if (start && mid && stop)
322  *pvalid = 1;
323  }
324  break;
325  default:
326  return ERROR_INT("format not supported", procName, 1);
327  }
328 
329  return 0;
330 }
331 
332 
333 /*------------------------------------------------------------------------*
334  * Code 2 of 5 *
335  *------------------------------------------------------------------------*/
363 static char *
364 barcodeDecode2of5(char *barstr,
365  l_int32 debugflag)
366 {
367 char *data, *vbarstr;
368 char code[10];
369 l_int32 valid, reverse, i, j, len, error, ndigits, start, found;
370 
371  PROCNAME("barcodeDecodeI2of5");
372 
373  if (!barstr)
374  return (char *)ERROR_PTR("barstr not defined", procName, NULL);
375 
376  /* Verify format; reverse if necessary */
377  barcodeVerifyFormat(barstr, L_BF_CODE2OF5, &valid, &reverse);
378  if (!valid)
379  return (char *)ERROR_PTR("barstr not in 2of5 format", procName, NULL);
380  if (reverse)
381  vbarstr = stringReverse(barstr);
382  else
383  vbarstr = stringNew(barstr);
384 
385  /* Verify size */
386  len = strlen(vbarstr);
387  if ((len - 11) % 10 != 0) {
388  LEPT_FREE(vbarstr);
389  return (char *)ERROR_PTR("size not divisible by 10: invalid 2of5 code",
390  procName, NULL);
391  }
392 
393  error = FALSE;
394  ndigits = (len - 11) / 10;
395  data = (char *)LEPT_CALLOC(ndigits + 1, sizeof(char));
396  memset(code, 0, 10);
397  for (i = 0; i < ndigits; i++) {
398  start = 6 + 10 * i;
399  for (j = 0; j < 9; j++)
400  code[j] = vbarstr[start + j];
401 
402  if (debugflag)
403  fprintf(stderr, "code: %s\n", code);
404 
405  found = FALSE;
406  for (j = 0; j < 10; j++) {
407  if (!strcmp(code, Code2of5[j])) {
408  data[i] = 0x30 + j;
409  found = TRUE;
410  break;
411  }
412  }
413  if (!found) error = TRUE;
414  }
415  LEPT_FREE(vbarstr);
416 
417  if (error) {
418  LEPT_FREE(data);
419  return (char *)ERROR_PTR("error in decoding", procName, NULL);
420  }
421 
422  return data;
423 }
424 
425 
426 /*------------------------------------------------------------------------*
427  * Interleaved Code 2 of 5 *
428  *------------------------------------------------------------------------*/
443 static char *
444 barcodeDecodeI2of5(char *barstr,
445  l_int32 debugflag)
446 {
447 char *data, *vbarstr;
448 char code1[6], code2[6];
449 l_int32 valid, reverse, i, j, len, error, npairs, start, found;
450 
451  PROCNAME("barcodeDecodeI2of5");
452 
453  if (!barstr)
454  return (char *)ERROR_PTR("barstr not defined", procName, NULL);
455 
456  /* Verify format; reverse if necessary */
457  barcodeVerifyFormat(barstr, L_BF_CODEI2OF5, &valid, &reverse);
458  if (!valid)
459  return (char *)ERROR_PTR("barstr not in i2of5 format", procName, NULL);
460  if (reverse)
461  vbarstr = stringReverse(barstr);
462  else
463  vbarstr = stringNew(barstr);
464 
465  /* Verify size */
466  len = strlen(vbarstr);
467  if ((len - 7) % 10 != 0) {
468  LEPT_FREE(vbarstr);
469  return (char *)ERROR_PTR("size not divisible by 10: invalid I2of5 code",
470  procName, NULL);
471  }
472 
473  error = FALSE;
474  npairs = (len - 7) / 10;
475  data = (char *)LEPT_CALLOC(2 * npairs + 1, sizeof(char));
476  memset(code1, 0, 6);
477  memset(code2, 0, 6);
478  for (i = 0; i < npairs; i++) {
479  start = 4 + 10 * i;
480  for (j = 0; j < 5; j++) {
481  code1[j] = vbarstr[start + 2 * j];
482  code2[j] = vbarstr[start + 2 * j + 1];
483  }
484 
485  if (debugflag)
486  fprintf(stderr, "code1: %s, code2: %s\n", code1, code2);
487 
488  found = FALSE;
489  for (j = 0; j < 10; j++) {
490  if (!strcmp(code1, CodeI2of5[j])) {
491  data[2 * i] = 0x30 + j;
492  found = TRUE;
493  break;
494  }
495  }
496  if (!found) error = TRUE;
497  found = FALSE;
498  for (j = 0; j < 10; j++) {
499  if (!strcmp(code2, CodeI2of5[j])) {
500  data[2 * i + 1] = 0x30 + j;
501  found = TRUE;
502  break;
503  }
504  }
505  if (!found) error = TRUE;
506  }
507  LEPT_FREE(vbarstr);
508 
509  if (error) {
510  LEPT_FREE(data);
511  return (char *)ERROR_PTR("error in decoding", procName, NULL);
512  }
513 
514  return data;
515 }
516 
517 
518 /*------------------------------------------------------------------------*
519  * Code 93 *
520  *------------------------------------------------------------------------*/
540 static char *
541 barcodeDecode93(char *barstr,
542  l_int32 debugflag)
543 {
544 const char *checkc, *checkk;
545 char *data, *vbarstr;
546 char code[7];
547 l_int32 valid, reverse, i, j, len, error, nsymb, start, found, sum;
548 l_int32 *index;
549 
550  PROCNAME("barcodeDecode93");
551 
552  if (!barstr)
553  return (char *)ERROR_PTR("barstr not defined", procName, NULL);
554 
555  /* Verify format; reverse if necessary */
556  barcodeVerifyFormat(barstr, L_BF_CODE93, &valid, &reverse);
557  if (!valid)
558  return (char *)ERROR_PTR("barstr not in code93 format", procName, NULL);
559  if (reverse)
560  vbarstr = stringReverse(barstr);
561  else
562  vbarstr = stringNew(barstr);
563 
564  /* Verify size; skip the first 6 and last 7 bars. */
565  len = strlen(vbarstr);
566  if ((len - 13) % 6 != 0) {
567  LEPT_FREE(vbarstr);
568  return (char *)ERROR_PTR("size not divisible by 6: invalid code 93",
569  procName, NULL);
570  }
571 
572  /* Decode the symbols */
573  nsymb = (len - 13) / 6;
574  data = (char *)LEPT_CALLOC(nsymb + 1, sizeof(char));
575  index = (l_int32 *)LEPT_CALLOC(nsymb, sizeof(l_int32));
576  memset(code, 0, 7);
577  error = FALSE;
578  for (i = 0; i < nsymb; i++) {
579  start = 6 + 6 * i;
580  for (j = 0; j < 6; j++)
581  code[j] = vbarstr[start + j];
582 
583  if (debugflag)
584  fprintf(stderr, "code: %s\n", code);
585 
586  found = FALSE;
587  for (j = 0; j < C93_START; j++) {
588  if (!strcmp(code, Code93[j])) {
589  data[i] = Code93Val[j];
590  index[i] = j;
591  found = TRUE;
592  break;
593  }
594  }
595  if (!found) error = TRUE;
596  }
597  LEPT_FREE(vbarstr);
598 
599  if (error) {
600  LEPT_FREE(index);
601  LEPT_FREE(data);
602  return (char *)ERROR_PTR("error in decoding", procName, NULL);
603  }
604 
605  /* Do check sums. For character "C", use only the
606  * actual data in computing the sum. For character "K",
607  * use the actual data plus the check character "C". */
608  sum = 0;
609  for (i = 0; i < nsymb - 2; i++) /* skip the "C" and "K" */
610  sum += ((i % 20) + 1) * index[nsymb - 3 - i];
611  if (data[nsymb - 2] != Code93Val[sum % 47])
612  L_WARNING("Error for check C\n", procName);
613 
614  if (debugflag) {
615  checkc = Code93[sum % 47];
616  fprintf(stderr, "checkc = %s\n", checkc);
617  }
618 
619  sum = 0;
620  for (i = 0; i < nsymb - 1; i++) /* skip the "K" */
621  sum += ((i % 15) + 1) * index[nsymb - 2 - i];
622  if (data[nsymb - 1] != Code93Val[sum % 47])
623  L_WARNING("Error for check K\n", procName);
624 
625  if (debugflag) {
626  checkk = Code93[sum % 47];
627  fprintf(stderr, "checkk = %s\n", checkk);
628  }
629 
630  /* Remove the two check codes from the output */
631  data[nsymb - 2] = '\0';
632 
633  LEPT_FREE(index);
634  return data;
635 }
636 
637 
638 /*------------------------------------------------------------------------*
639  * Code 39 *
640  *------------------------------------------------------------------------*/
657 static char *
658 barcodeDecode39(char *barstr,
659  l_int32 debugflag)
660 {
661 char *data, *vbarstr;
662 char code[10];
663 l_int32 valid, reverse, i, j, len, error, nsymb, start, found;
664 
665  PROCNAME("barcodeDecode39");
666 
667  if (!barstr)
668  return (char *)ERROR_PTR("barstr not defined", procName, NULL);
669 
670  /* Verify format; reverse if necessary */
671  barcodeVerifyFormat(barstr, L_BF_CODE39, &valid, &reverse);
672  if (!valid)
673  return (char *)ERROR_PTR("barstr not in code39 format", procName, NULL);
674  if (reverse)
675  vbarstr = stringReverse(barstr);
676  else
677  vbarstr = stringNew(barstr);
678 
679  /* Verify size */
680  len = strlen(vbarstr);
681  if ((len + 1) % 10 != 0) {
682  LEPT_FREE(vbarstr);
683  return (char *)ERROR_PTR("size+1 not divisible by 10: invalid code 39",
684  procName, NULL);
685  }
686 
687  /* Decode the symbols */
688  nsymb = (len - 19) / 10;
689  data = (char *)LEPT_CALLOC(nsymb + 1, sizeof(char));
690  memset(code, 0, 10);
691  error = FALSE;
692  for (i = 0; i < nsymb; i++) {
693  start = 10 + 10 * i;
694  for (j = 0; j < 9; j++)
695  code[j] = vbarstr[start + j];
696 
697  if (debugflag)
698  fprintf(stderr, "code: %s\n", code);
699 
700  found = FALSE;
701  for (j = 0; j < C39_START; j++) {
702  if (!strcmp(code, Code39[j])) {
703  data[i] = Code39Val[j];
704  found = TRUE;
705  break;
706  }
707  }
708  if (!found) error = TRUE;
709  }
710  LEPT_FREE(vbarstr);
711 
712  if (error) {
713  LEPT_FREE(data);
714  return (char *)ERROR_PTR("error in decoding", procName, NULL);
715  }
716 
717  return data;
718 }
719 
720 
721 /*------------------------------------------------------------------------*
722  * Codabar *
723  *------------------------------------------------------------------------*/
740 static char *
741 barcodeDecodeCodabar(char *barstr,
742  l_int32 debugflag)
743 {
744 char *data, *vbarstr;
745 char code[8];
746 l_int32 valid, reverse, i, j, len, error, nsymb, start, found;
747 
748  PROCNAME("barcodeDecodeCodabar");
749 
750  if (!barstr)
751  return (char *)ERROR_PTR("barstr not defined", procName, NULL);
752 
753  /* Verify format; reverse if necessary */
754  barcodeVerifyFormat(barstr, L_BF_CODABAR, &valid, &reverse);
755  if (!valid)
756  return (char *)ERROR_PTR("barstr not in codabar format",
757  procName, NULL);
758  if (reverse)
759  vbarstr = stringReverse(barstr);
760  else
761  vbarstr = stringNew(barstr);
762 
763  /* Verify size */
764  len = strlen(vbarstr);
765  if ((len + 1) % 8 != 0) {
766  LEPT_FREE(vbarstr);
767  return (char *)ERROR_PTR("size+1 not divisible by 8: invalid codabar",
768  procName, NULL);
769  }
770 
771  /* Decode the symbols */
772  nsymb = (len - 15) / 8;
773  data = (char *)LEPT_CALLOC(nsymb + 1, sizeof(char));
774  memset(code, 0, 8);
775  error = FALSE;
776  for (i = 0; i < nsymb; i++) {
777  start = 8 + 8 * i;
778  for (j = 0; j < 7; j++)
779  code[j] = vbarstr[start + j];
780 
781  if (debugflag)
782  fprintf(stderr, "code: %s\n", code);
783 
784  found = FALSE;
785  for (j = 0; j < 16; j++) {
786  if (!strcmp(code, Codabar[j])) {
787  data[i] = CodabarVal[j];
788  found = TRUE;
789  break;
790  }
791  }
792  if (!found) error = TRUE;
793  }
794  LEPT_FREE(vbarstr);
795 
796  if (error) {
797  LEPT_FREE(data);
798  return (char *)ERROR_PTR("error in decoding", procName, NULL);
799  }
800 
801  return data;
802 }
803 
804 
805 /*------------------------------------------------------------------------*
806  * Code UPC-A *
807  *------------------------------------------------------------------------*/
828 static char *
829 barcodeDecodeUpca(char *barstr,
830  l_int32 debugflag)
831 {
832 char *data, *vbarstr;
833 char code[5];
834 l_int32 valid, i, j, len, error, start, found, sum, checkdigit;
835 
836  PROCNAME("barcodeDecodeUpca");
837 
838  if (!barstr)
839  return (char *)ERROR_PTR("barstr not defined", procName, NULL);
840 
841  /* Verify format; reverse has no meaning here -- we must test both */
842  barcodeVerifyFormat(barstr, L_BF_UPCA, &valid, NULL);
843  if (!valid)
844  return (char *)ERROR_PTR("barstr not in UPC-A format", procName, NULL);
845 
846  /* Verify size */
847  len = strlen(barstr);
848  if (len != 59)
849  return (char *)ERROR_PTR("size not 59; invalid UPC-A barcode",
850  procName, NULL);
851 
852  /* Check the first digit. If invalid, reverse the string. */
853  memset(code, 0, 5);
854  for (i = 0; i < 4; i++)
855  code[i] = barstr[i + 3];
856  found = FALSE;
857  for (i = 0; i < 10; i++) {
858  if (!strcmp(code, Upca[i])) {
859  found = TRUE;
860  break;
861  }
862  }
863  if (found == FALSE)
864  vbarstr = stringReverse(barstr);
865  else
866  vbarstr = stringNew(barstr);
867 
868  /* Decode the 12 symbols */
869  data = (char *)LEPT_CALLOC(13, sizeof(char));
870  memset(code, 0, 5);
871  error = FALSE;
872  for (i = 0; i < 12; i++) {
873  if (i < 6)
874  start = 3 + 4 * i;
875  else
876  start = 32 + 4 * (i - 6);
877  for (j = 0; j < 4; j++)
878  code[j] = vbarstr[start + j];
879 
880  if (debugflag)
881  fprintf(stderr, "code: %s\n", code);
882 
883  found = FALSE;
884  for (j = 0; j < 10; j++) {
885  if (!strcmp(code, Upca[j])) {
886  data[i] = 0x30 + j;
887  found = TRUE;
888  break;
889  }
890  }
891  if (!found) error = TRUE;
892  }
893  LEPT_FREE(vbarstr);
894 
895  if (error) {
896  LEPT_FREE(data);
897  return (char *)ERROR_PTR("error in decoding", procName, NULL);
898  }
899 
900  /* Calculate the check digit (data[11]). */
901  sum = 0;
902  for (i = 0; i < 12; i += 2) /* "even" digits */
903  sum += 3 * (data[i] - 0x30);
904  for (i = 1; i < 11; i += 2) /* "odd" digits */
905  sum += (data[i] - 0x30);
906  checkdigit = sum % 10;
907  if (checkdigit) /* not 0 */
908  checkdigit = 10 - checkdigit;
909  if (checkdigit + 0x30 != data[11])
910  L_WARNING("Error for UPC-A check character\n", procName);
911 
912  return data;
913 }
914 
915 
916 /*------------------------------------------------------------------------*
917  * Code EAN-13 *
918  *------------------------------------------------------------------------*/
945 static char *
946 barcodeDecodeEan13(char *barstr,
947  l_int32 first,
948  l_int32 debugflag)
949 {
950 char *data, *vbarstr;
951 char code[5];
952 l_int32 valid, i, j, len, error, start, found, sum, checkdigit;
953 
954  PROCNAME("barcodeDecodeEan13");
955 
956  if (!barstr)
957  return (char *)ERROR_PTR("barstr not defined", procName, NULL);
958 
959  /* Verify format. You can't tell the orientation by the start
960  * and stop codes, but you can by the location of the digits.
961  * Use the UPCA verifier for EAN 13 -- it is identical. */
962  barcodeVerifyFormat(barstr, L_BF_UPCA, &valid, NULL);
963  if (!valid)
964  return (char *)ERROR_PTR("barstr not in EAN 13 format", procName, NULL);
965 
966  /* Verify size */
967  len = strlen(barstr);
968  if (len != 59)
969  return (char *)ERROR_PTR("size not 59; invalid EAN 13 barcode",
970  procName, NULL);
971 
972  /* Check the first digit. If invalid, reverse the string. */
973  memset(code, 0, 5);
974  for (i = 0; i < 4; i++)
975  code[i] = barstr[i + 3];
976  found = FALSE;
977  for (i = 0; i < 10; i++) {
978  if (!strcmp(code, Upca[i])) {
979  found = TRUE;
980  break;
981  }
982  }
983  if (found == FALSE)
984  vbarstr = stringReverse(barstr);
985  else
986  vbarstr = stringNew(barstr);
987 
988  /* Decode the 12 symbols */
989  data = (char *)LEPT_CALLOC(13, sizeof(char));
990  memset(code, 0, 5);
991  error = FALSE;
992  for (i = 0; i < 12; i++) {
993  if (i < 6)
994  start = 3 + 4 * i;
995  else
996  start = 32 + 4 * (i - 6);
997  for (j = 0; j < 4; j++)
998  code[j] = vbarstr[start + j];
999 
1000  if (debugflag)
1001  fprintf(stderr, "code: %s\n", code);
1002 
1003  found = FALSE;
1004  for (j = 0; j < 10; j++) {
1005  if (!strcmp(code, Upca[j])) {
1006  data[i] = 0x30 + j;
1007  found = TRUE;
1008  break;
1009  }
1010  }
1011  if (!found) error = TRUE;
1012  }
1013  LEPT_FREE(vbarstr);
1014 
1015  if (error) {
1016  LEPT_FREE(data);
1017  return (char *)ERROR_PTR("error in decoding", procName, NULL);
1018  }
1019 
1020  /* Calculate the check digit (data[11]). */
1021  sum = 0;
1022  for (i = 0; i < 12; i += 2) /* "even" digits */
1023  sum += 3 * (data[i] - 0x30);
1024  for (i = 1; i < 12; i += 2) /* "odd" digits */
1025  sum += (data[i] - 0x30);
1026  checkdigit = sum % 10;
1027  if (checkdigit) /* not 0 */
1028  checkdigit = 10 - checkdigit;
1029  if (checkdigit + 0x30 != data[11])
1030  L_WARNING("Error for EAN-13 check character\n", procName);
1031 
1032  return data;
1033 }
barcodeDecodeI2of5
static char * barcodeDecodeI2of5(char *barstr, l_int32 debugflag)
barcodeDecodeI2of5()
Definition: bardecode.c:444
barcodeVerifyFormat
static l_int32 barcodeVerifyFormat(char *barstr, l_int32 format, l_int32 *pvalid, l_int32 *preverse)
barcodeVerifyFormat()
Definition: bardecode.c:204
barcodeDecode2of5
static char * barcodeDecode2of5(char *barstr, l_int32 debugflag)
barcodeDecode2of5()
Definition: bardecode.c:364
stringNew
char * stringNew(const char *src)
stringNew()
Definition: utils2.c:215
barcodeDecodeCodabar
static char * barcodeDecodeCodabar(char *barstr, l_int32 debugflag)
barcodeDecodeCodabar()
Definition: bardecode.c:741
barcodeDecodeUpca
static char * barcodeDecodeUpca(char *barstr, l_int32 debugflag)
barcodeDecodeUpca()
Definition: bardecode.c:829
barcodeDispatchDecoder
char * barcodeDispatchDecoder(char *barstr, l_int32 format, l_int32 debugflag)
barcodeDispatchDecoder()
Definition: bardecode.c:96
barcodeFindFormat
static l_int32 barcodeFindFormat(char *barstr)
barcodeFindFormat()
Definition: bardecode.c:143
barcodeFormatIsSupported
l_int32 barcodeFormatIsSupported(l_int32 format)
barcodeFormatIsSupported()
Definition: bardecode.c:173
L_Bytea::data
l_uint8 * data
Definition: array.h:131
barcodeDecode93
static char * barcodeDecode93(char *barstr, l_int32 debugflag)
barcodeDecode93()
Definition: bardecode.c:541
barcodeDecodeEan13
static char * barcodeDecodeEan13(char *barstr, l_int32 first, l_int32 debugflag)
barcodeDecodeEan13()
Definition: bardecode.c:946
stringReverse
char * stringReverse(const char *src)
stringReverse()
Definition: utils2.c:588
barcodeDecode39
static char * barcodeDecode39(char *barstr, l_int32 debugflag)
barcodeDecode39()
Definition: bardecode.c:658