1 /*
2 This is a Optical-Character-Recognition program
3 Copyright (C) GPLv2 2000-2018 Joerg Schulenburg
4
5 This program is free software; you can redistribute it and/or
6 modify it under the terms of the GNU General Public License
7 as published by the Free Software Foundation; either version 2
8 of the License, or (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18
19 see README for email address
20
21 ToDo:
22 - transform special xml bar code symbols (<>&) to xml symbols (<>&)
23
24 */
25
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <string.h>
29 /* #include <math.h> -- we do not want unnecessary dependencies */
30 #include "pgm2asc.h"
31 #include "gocr.h"
32 #include "pnm.h"
33 #include "unicode_defs.h" /* define UNKNOWN + PICTURE */
34
35 #ifndef DO_DEBUG /* can be defined outside (configure --with-debug) */
36 #define DO_DEBUG 0 /* 0 is the default */
37 #endif
38
39 #undef g_debug
40 #if DO_DEBUG
41 # define g_debug(a) if (OCR_JOB->cfg.verbose&1) { a }
42 #else
43 # define g_debug(a)
44 #endif
45
46 /*
47 detect barcode and add a XML-string to the box (obj-pointer, ToDo)
48 ToDo: barcode-output stderr->stdout
49 */
50
51 /* static functions are only visible to other functions in the same file */
sqr(double x)52 static double sqr(double x) { return(x*x); } /* static inline ? MACRO ? */
53
54 /* ----------------------------- code128 ---------------------------- *
55 * "BSBSBS", B=Bar, S=Space, better using 2*6=12bit-integer? */
56 #define Num128 107
57 const char *code128[Num128+1]={ /* can be generated by an algorithm? */
58 /* 00 */"212222","222122","222221","121223","121322","131222","122213","122312",
59 /* 08 */"132212","221213","221312","231212","112232","122132","122231","113222",
60 /* 16 */"123122","123221","223211","221132","221231","213212","223112","312131",
61 /* 24 */"311222","321122","321221","312212","322112","322211","212123","212321",
62 /* 32 */"232121","111323","131123","131321","112313","132113","132311","211313",
63 /* 40 */"231113","231311","112133","112331","132131","113123","113321","133121",
64 /* 48 */"313121","211331","231131","213113","213311","213131","311123","311321",
65 /* 56 */"331121","312113","312311","332111","314111","221411","431111","111224",
66 /* 64 */"111422","121124","121421","141122","141221","112214","112412","122114",
67 /* 72 */"122411","142112","142211","241211","221114","413111","241112","134111",
68 /* 80 */"111242","121142","121241","114212","124112","124211","411212","421112",
69 /* 88 */"421211","212141","214121","412121","111143","111341","131141","114113",
70 /* 96 */"114311","411113","411311","113141","114131","311141","411131","211412",
71 /*104 */"211214","211232","2331112","???"};
72
73 /*
74 code128: see code128.tex by Petr Olsak (108 codes)
75 quiet_zone: size=10 (before and after code128)
76 num_bars=3*(start+chars[N]+crc+stop)+1
77 B=bar S=space char=BSBSBS (size=11), stop=BSBSBSB (size=11+2)
78 Width: Bar,Space=1,[2,3,4] char=11 code=11*(N+3)+2 sumB=even,sumS=odd
79 startA="211412"=103 startB="211214"=104 startC="211232"=105(2dec_digits)
80 mode/code 0..95 96 97 98 99 100 101 102 103 104 105 106
81 1=A x20-x5f,0-x20 F3 F2 uB mC mB F4 F1 ^A ^B ^C $
82 2=B x20-x7f F3 F2 uA mC F4 mA F1 ^A ^B ^C $
83 3=C "00"-"95" "96" "97" "98" "99" mB mA F1 ^A ^B ^C $
84 uA,uB: switch mode for next char, mA,mB: switch mode permanently
85 crc=(start+1*char1+2*char2+3*char3+...+N*charN) mod 103
86 $=stop="2331112"=106 (4bars, with=13) => start/end==211
87 return num of chars or string
88 StartStopWidths: Bars=123 Spaces=123
89
90 size B+W even-variants odd-variants num_codes
91 11 = 8+3 = (1+3+4,2+2+4,2+3+3)+(1+1+1) => (6+3+3)*(1) = 12
92 = 6+5 = (1+1+4,1+2+3,2+2+2)+(1+1+3,1+2+2) => (3+6+1)*(3+3) = 60
93 = 4+7 = (1+1+2)+(1+2+4,1+3+3,2+2+3) => (3)*(6+3+3) = 36
94 sum = 108
95 */
96 /* example: barcode -E -e 128c -b 1434600120000884 >a.eps */
97 /* example: barcode -E -e 128b -b 14Test41 >a.eps */
98 /* example: barcode -E -e 128raw -b 105 17 14 30 >a.eps */
99
decode_code128(int * wb,int num_bars)100 char *decode_code128(int *wb, int num_bars){
101 int i, w, i1, i2, i3=0, i4, i5=0, crc, mode=1;
102 int minB, maxB, minS, maxS; /* min/max bars/spaces sample: 3-10 1-8 */
103 int wb6[6], addS, addB; /* normalized bars, normalization summand */
104 double dww, dw, err, min_err; char cc, *buf;
105 char *result=NULL; /* malloc and store the result */
106 #if DO_DEBUG
107 int i4old=0;
108 #endif
109
110 minB=maxB=wb[0];
111 minS=maxS=wb[1];
112 /* sample090916 showed maxS = minB so we normalize first */
113 for(i=0; i<2*num_bars-1; i++){
114 if (i&1) { if (minS>wb[i]) minS=wb[i]; if (maxS<wb[i]) maxS=wb[i]; }
115 else { if (minB>wb[i]) minB=wb[i]; if (maxB<wb[i]) maxB=wb[i]; }
116 }
117 /* sample: 05 02 03 ...
118 distortion: wb[0]=2*sb+db wb[1]=sb-db wb[2]=sb+db (scale+diff)
119 back: sb = wb[0]-wb[2] = 2
120 db = wb[2]-sb = 2wb[2]-wb[0] = 1
121 = (wb[2]-wb[1]+1)/2 = 1
122 */
123 addS=(minB-minS+1)/2; addB=-(minB-minS)/2;
124 for(w=i=0;i<2*num_bars-1;i++){
125 w+=wb[i]+((i&1)?addS:addB); /* summ all bars and spaces */
126 }
127
128 /* test code128 characteristics, ToDo: look for correct start/stop 211 seq. */
129 if ((num_bars-1)%3!=0 || num_bars<10 || w<11*(num_bars-1)/3+2)
130 return 0;
131 g_debug(fprintf(stderr," code128 BS= %d-%d %d-%d chars=%d 211... %02d %02d %02d\n",minB,maxB,minS,maxS,(num_bars-1)/3,wb[0],wb[1],wb[2]);)
132 if (3*(wb[0]+addB)<4* (wb[1]+addS)
133 || 3* wb[0] <4* wb[2]
134 || 4* wb[0] <3*(wb[1]+wb[2])
135 || 3* wb[0] >4*(wb[1]+wb[2])) return 0; /* start=211.. */
136 dw=3.0*w/((num_bars-1)*11+6);
137 /* get enough memory for all digits in longest mode C */
138 buf =(char *) malloc( (num_bars-7)/3*2+1); if (!buf) return result;
139 result=(char *) malloc(256+(num_bars-7)/3*2+1);
140
141 dww=crc=0;
142 for(i4=i1=0;i1<(num_bars-1)/3;i1++) {
143 for (i2=0;i2<6;i2++) wb6[i2]=wb[i1*6+i2]+((i2&1)?addS:addB);
144 for(min_err=1e8,i3=Num128,i5=0;i5<Num128;i5++){ /* get best fit */
145 for(err=i2=0;i2<6;i2++) err+=sqr(code128[i5][i2]-'0'-wb6[i2]/dw);
146 if (err<min_err) { min_err=err; i3=i5; }
147 } dww+=min_err;
148 g_debug(for(i2=0;i2<6;i2++)fprintf(stderr," %2d",wb[i1*6+i2]);
149 fprintf(stderr," %7s %3d err=%.3f",code128[i3],i3,min_err);)
150 g_debug(i4old=i4;)
151 if(i3<Num128){ /* valid symbol */
152 if(i1==0){ if (i3>102 && i3<106) mode=i3-103+1; crc=i3; } /* start */
153 if(i1>0 && i1<(num_bars-1)/3-2){
154 crc+=i3*(i1); cc=0; /* first * 1 + second * 2 + third * 3 ... */
155 i5=((mode>3)?mode>>2:mode&3); mode&=3; /* mode can be modified now */
156 switch (i5) { /* mode=1..3=modeA..modeC */
157 case 1: if (i3>=64 && i3<96) cc=i3-64; /* modeA: x20-x5f,0-x20 */
158 else cc=i3+32;
159 if (i3==101) mode=1; /* switch to mode A */
160 if (i3== 99) mode=3; /* switch to mode C */
161 if (i3== 98) mode|=2<<2; /* shift to mode B */
162 break;
163 case 2: cc=i3+32; /* modeB: x20-x7f */
164 if (i3==100) mode=2; /* switch to mode B */
165 if (i3== 99) mode=3; /* switch to mode C */
166 if (i3== 98) mode|=1<<2; /* shift to mode A */
167 break;
168 case 3:
169 if (i3==101) mode=1; /* switch to mode A */
170 if (i3==100) mode=2; /* switch to mode B */
171 }
172 if (i5==3 && i3<100) { buf[i4]='0'+i3/10; i4++;
173 buf[i4]='0'+i3%10; i4++; } /* modeC: 00-99 */
174 if (i5!=3) {
175 if (cc>=0x20 && i3<=0x7f) { buf[i4]=cc; i4++; } /* modeA+B: one digit */
176 if (cc>=0 && cc< 0x20) { buf[i4]='^'; i4++;
177 buf[i4]=cc+'@'; i4++; }
178 }
179 }
180 if(i1==(num_bars-1)/3-2){ crc=(crc+103-i3)%103; }
181 if(i1==(num_bars-1)/3-1){ if(i3!=106) i3=-1; } /* stop code */
182 mode &= 3; /* remove shift */
183 }
184 else fprintf(stderr," %s=%02d? ",buf,i5);
185 g_debug(fprintf(stderr," m%c %c%c\n",'A'-1+mode,
186 ((i4-i4old>1)?buf[i4-2]:' '), /* two digged modeC, Apr08 */
187 ((i4-i4old>0)?buf[i4-1]:' '));)
188 }
189 buf[i4]=0; /* end of string */
190 if (result)
191 sprintf(result,"<barcode type=\"128\" chars=\"%d\" code=\"%s\" "
192 "crc=\"%d\" error=\"%.3f\" />",
193 i4,buf,crc,dww/((num_bars-1)));
194 free(buf);
195 return result;
196 }
197
198 /* -------------------------------------------------------------------- UPC
199 EAN 13 (UPC,(1+6+1+6+1)*2bars,size=3+6*7+5+6*7+3=95)
200 EAN 8 (UPC,(1+4+1+4+1)*2bars,size=3+4*7+5+4*7+3=67)
201 UPC: (10 codes)
202 BSB SBSB^n SBSBS BSBS^n BSB
203 bsb ...... sbsbs ...... bsb
204 111 ...... 11111 ...... 111
205 num_bars=2*(2*6+3) middle=SBSBS=11111 right/left=BSB=111="101"
206 char: left=SBSB right=BSBS (size=7) only_dec_digits
207 SS+BB = (S+S) + (B+B) => BB:SS = 5:2 or 3:4
208 size ev+odd even + odd => variants
209 7 = 2 + 5 = (1+1) + (1+4,2+3) => (1)*(2+2) = 4 codes
210 = 4 + 3 = (1+3,2+2) + (1+3) => (2+1)*(2) = 6 codes += 10 codes
211 ToDo: make it more robust
212 - return error as mean deviation
213 * -------------------------------------------------------------------- */
214 /* example: barcode -E -e upc -b 12345678901 >a.eps # ok */
215 /* example: barcode -E -e ean -b 123456789012 >a.eps # ok */
216 #define NumUPC 20
217 const char *codeUPC[NumUPC+1]={ /* 0..9, first n = SBSB, last n = BSBS */
218 "3211","2221","2122","1411","1132", /* 0,1,2,3,4 normal (+0bit) */
219 "1231","1114","1312","1213","3112", /* 5,6,7,8,9 */
220 "1123","1222","2212","1141","2311", /* 0,1,2,3,4 mirrored (+1bit) */
221 "1321","4111","2131","3121","2113", /* 5,6,7,8,9 */
222 "????"}; /* not found */
223
decode_UPC(int * wb,int num_bars)224 char *decode_UPC(int *wb, int num_bars){ /* ToDo: char *dest, int len */
225 int i, w, i1, i2, i3, i5, crc, mirrored, ean;
226 double err, min_err, dw, dww=0.0; char digit;
227 char *result=NULL, *buf=NULL; /* malloc and store the result */
228 int minB, maxB, minS, maxS; /* min/max bars/spaces */
229 int addS, addB; /* corrections, JS1002 sample090916 */
230
231 minB=maxB=wb[0];
232 minS=maxS=wb[1];
233 /* sample090916 showed maxS = minB so we normalize first */
234 for(i=0; i<2*num_bars-1; i++){
235 if (i&1) { if (minS>wb[i]) minS=wb[i]; if (maxS<wb[i]) maxS=wb[i]; }
236 else { if (minB>wb[i]) minB=wb[i]; if (maxB<wb[i]) maxB=wb[i]; }
237 }
238 addS=(minB-minS)/2; addB=-(minB-minS)/2;
239 for(w=i=0;i<2*num_bars-1;i++) w+=wb[i]+((i&1)?addS:addB);
240
241 dw=2.0*w/((num_bars-6)*7+2*11); /* or min(wb[]) */
242 crc=0;
243 if ((num_bars)%2!=0 || num_bars<10 || w<7*(num_bars-6)/2+11
244 || ((num_bars-6)/2)%2!=0) return 0; /* should be balanced */
245 g_debug(fprintf(stderr," UPC/EAN BS= %d-%d %d-%d\n",minB,maxB,minS,maxS);)
246 /* check front BSB, middle SBSBS and end BSB */
247 dww=0;
248 for(i=0;i<3;i++){dww=sqr((wb[i ]+((i&1)?addS:addB))/dw-1);if(dww>0.4)return 0;}
249 for(i=0;i<5;i++){dww=sqr((wb[i+ num_bars-3]+((i&1)?addB:addS))/dw-1);if(dww>0.4)return 0;}
250 for(i=0;i<3;i++){dww=sqr((wb[i+2*num_bars-4]+((i&1)?addS:addB))/dw-1);if(dww>0.4)return 0;}
251 buf =(char *)malloc( (num_bars-6)/2+1); if (!buf) return result;
252 result=(char *)malloc(256+(num_bars-6)/2+1);
253
254 for(ean=i5=0,i1=3;i1<2*num_bars-4;i1+=4) { /* each digit (2bars+2spaces) */
255 if (i1==num_bars-3) { i1++; continue; } /* skip middle sync SBSBS */
256 for (mirrored=0,digit='?',min_err=16e8,i2=0;i2<NumUPC;i2++) {
257 for (err=0,i3=0;i3<4;i3++)
258 err+=sqr(codeUPC[i2][i3]-'0'-(wb[i1+i3]+(((i1+i3)&1)?addS:addB))/dw);
259 if (err<min_err) { min_err=err; digit='0'+i2%10; mirrored=i2/10; }
260 } dww+=min_err; crc+=(digit-'0')*((i5&1)?1:3); /* even*3+odd, last char is even */
261 buf[i5++]=digit; if (i5<7) ean=(ean<<1)|mirrored;
262 /* ToDo: error as deviation wb from ideal */
263 g_debug(fprintf(stderr,"\nDBG: UPC digit=%c mirrored=%d err=%.3f err_m=%.3f ",
264 digit,mirrored,min_err/4,dww/(i5*4));)
265 }
266 /* EAN has a 13th leading digit build by 3 of 6 mirorred digits */
267 if (ean & 0x20) ean^=0x3f; /* UPC-E mirrored 1xxxxx => 0yyyyy */
268 switch (ean) {
269 case 11: ean=1; break;
270 case 13: ean=2; break;
271 case 14: ean=3; break;
272 case 19: ean=4; break;
273 case 25: ean=5; break;
274 case 28: ean=6; break;
275 case 21: ean=7; break;
276 case 22: ean=8; break;
277 case 26: ean=9; break;
278 default: ean=0; /* no or invalid EAN digit or UPC-extension */
279 } crc+=ean*1;
280 /* ToDo: fix possible buffer OVL, complement crc */
281 buf[i5]=0;
282 if (result)
283 sprintf(result,"<barcode type=\"UPC\" chars=\"%d\" code=\"%d%s\" "
284 "crc=\"%d\" error=\"%.3f\" />",
285 i5+1,ean,buf,(10-crc%10)%10,dww/((num_bars-6)*2));
286 free(buf);
287 return result;
288 }
289
290 /* EAN/UPC add-on is either 2 or 5 digits. It always starts with a
291 * guard bar BSB, followed by ([digit + SB] * (N-1)) + digit. Digit is
292 * SBSB. Two digit add-on's have 7 bars, and 5 digit add ons have 16.
293 */
decode_UPC_addon(int * wb,int num_bars)294 char *decode_UPC_addon(int *wb, int num_bars){ /* ToDo: char *dest, int len */
295 int i, w, i1, i2, i3, i5, digits=num_bars/3;
296 double err, min_err, dw, dww=0.0; char digit;
297 char *result=NULL, *buf=NULL; /* malloc and store the result */
298 int minB, maxB, minS, maxS; /* min/max bars/spaces */
299 int addS, addB; /* corrections, JS1002 sample090916 */
300
301 minB=maxB=wb[0];
302 minS=maxS=wb[1];
303 /* sample090916 showed maxS = minB so we normalize first */
304 for(i=0; i<2*num_bars-1; i++){
305 if (i&1) { if (minS>wb[i]) minS=wb[i]; if (maxS<wb[i]) maxS=wb[i]; }
306 else { if (minB>wb[i]) minB=wb[i]; if (maxB<wb[i]) maxB=wb[i]; }
307 }
308 addS=(minB-minS)/2; addB=-(minB-minS)/2;
309 if (num_bars!=7 && num_bars!=16)
310 return 0;
311 for(w=i=0;i<2*num_bars-1;i++) w+=wb[i];
312 g_debug(fprintf(stderr," UPC_addon BS= %d-%d %d-%d\n",minB,maxB,minS,maxS);)
313
314 dw=1.0*w/(digits*7+4 + (digits-1)*2);
315 /* check front BSB, and delineators SB */
316 dww=0;
317 for (i=0;i<2;i++) {
318 dww=sqr((wb[i]+((i&1)?addS:addB))/dw-1); if (dww>0.4) return 0; }
319 dww=sqr((wb[i]+((i&1)?addS:addB))*0.5/dw-1); if (dww>0.4) return 0;
320 for (i=1;i<digits; i++) {
321 for (i1=0; i1<2; i1++) {
322 dww = sqr((wb[i*6 + 1 + i1]+((i1&1)?addB:addS))/dw-1);
323 if (dww > 0.4) return 0;
324 }
325 }
326 buf =(char *)malloc( digits+1); if (!buf) return result;
327 result=(char *)malloc(256+digits+1);
328
329 for(i5=0,i1=3;i1<2*num_bars-1;i1+=6) { /* each digit (2bars+2spaces) */
330 for (digit='?',min_err=16e8,i2=0;i2<NumUPC;i2++) {
331 for (err=0,i3=0;i3<4;i3++)
332 err+=sqr(codeUPC[i2][i3]-'0'-(wb[i1+i3]+(((i1+i3)&1)?addS:addB))/dw);
333 if (err<min_err) { min_err=err; digit='0'+i2%10; }
334 }
335 dww+=min_err;
336 buf[i5++]=digit;
337 /* ToDo: error as deviation wb from ideal */
338 g_debug(fprintf(stderr,"\nDBG: UPC digit=%c err=%.3f err_m=%.3f ",
339 digit, min_err/4, dww/(i5*4));)
340 }
341 buf[i5]=0;
342 if (result)
343 sprintf(result, "<barcode type=\"UPC_addon\" chars=\"%d\" code=\"%s\" "
344 "error=\"%.3f\" />",
345 i5, buf, dww/((num_bars-6)*2));
346 free(buf);
347 return result;
348 }
349
350
351 /* --------------------------------------------------------- *
352 * code 3 of 9, 3 thick of 9 bars
353 * BSBSBSBSB<S> size=7+3*aw aw=2(3), sumS/sumB=2/1?
354 * two widths: size=1 or size=2or3, digit_width=13(16)
355 * 5 bars and 4(+1) spaces per digit, last space is not used
356 * with 2 (or 0) wide bars, 1 (or 3) wide spaces per digit
357 * => 3 of 9 => max=9*8*7=504
358 * evenBB=(0of5)+(2of5) oddSS=(1of4)+(3of4) max=44
359 * ToDo: better code -...-.-.. as 046 or 083 (even,even,odd)
360 * sample 090916: width of wide space may be smaller than narrow bar
361 */
362 #define Num39 (40+4) /* (3of9)=(2of5)(1of4)+(0of5)(3of4), (2of5)(.-..)=0..9 */
363 const char *code39= /* rearranged to BBBBBSSSS<S> (bars,spaces) */
364 "0..--..-.."
365 "1-...-.-..""2.-..-.-..""3--....-..""4..-.-.-..""5-.-...-.."
366 "6.--...-..""7...--.-..""8-..-..-..""9.-.-..-.."
367 "A-...-..-.""B.-..-..-.""C--.....-.""D..-.-..-.""E-.-....-."
368 "F.--....-.""G...--..-.""H-..-...-.""I.-.-...-.""J..--...-."
369 "K-...-...-""L.-..-...-""M--......-""N..-.-...-""O-.-.....-"
370 "P.--.....-""Q...--...-""R-..-....-""S.-.-....-""T..--....-"
371 "U-...--...""V.-..--...""W--...-...""X..-.--...""Y-.-..-..."
372 "Z.--..-...""-...---..."".-..-.-..."" .-.-.-...""*..--.-..."
373 /* (0of5)(3of4)=(.....)(3of4) store only 3of4? */
374 "$.....---.""/.....--.-""+.....-.--""%......---"
375 "?xxxxxxxxx";
376
377 /* example: barcode -E -e 39 -b 123abc | gs -sDEVICE=pnggray -r100 */
378
379 /* return index[] according to sorted values[], big first */
sort(int * value,int * idx,int len)380 void sort(int *value, int *idx, int len){
381 int i,j;
382 for (j=0;j<len;j++) idx[j]=j; /* initialize */
383 for(i=1;i;) { /* bubble sort, len...len^2 steps */
384 for(i=j=0;j<len-1;j++) if(value[idx[j]]<value[idx[j+1]]) {
385 i=idx[j]; idx[j]=idx[j+1]; idx[j+1]=i; i=1;
386 }
387 }
388 }
389
decode_39(int * wb,int num_bars)390 char *decode_39(int *wb, int num_bars){ /* ToDo: char *dest, int len */
391 int i, w, i1, i3, i5, crc,
392 idx[9], /* indices sorted by length of wb9[idx] */
393 wb9[9], /* next 9 normalized bars and spaces BWBWBWBWB (JS1002) */
394 addS, addB, /* normalization diffs */
395 minB, maxB, minS, maxS; /* min/max bar/space (JS1002) */
396 double dw,dww,err; char *buf;
397 char *result=NULL; /* malloc and store the result */
398
399 /* check for multiple of 5 bars and minimum start+1char+stop=15 bars */
400 if ((num_bars)%5!=0 || num_bars<15) return 0;
401 minB=maxB=wb[0];
402 minS=maxS=wb[1];
403 /* sample090916 showed maxS = minB so we normalize first */
404 for(i=0; i<2*num_bars-1; i++){
405 if (i&1) { if (minS>wb[i]) minS=wb[i]; if (maxS<wb[i]) maxS=wb[i]; }
406 else { if (minB>wb[i]) minB=wb[i]; if (maxB<wb[i]) maxB=wb[i]; }
407 }
408 addS=(minB-minS)/2; addB=-(minB-minS)/2;
409 for(w=i=0; i<2*num_bars-1; i++){
410 #if 1
411 if (i&1) { w+=wb[i]+addS; }
412 else { w+=wb[i]+addB; }
413 #else
414 w+=wb[i]; /* summ width to w */
415 #endif
416 }
417 dw=w*1.0/(16*(num_bars/5)); /* threshold = 1.5..2 */
418 /* whats best and most rigorosely for dw=threshold_width?
419 * - (1.5..2)*mean_width of every 5th space
420 * - (1.5..2)*summ(5bars+5spaces)/(13..16)
421 * - 3/4*summ(three thickest)/3
422 */
423 dww=crc=0; /* error and checksum (not supported yet) */
424 #if 0 /* should we exclude any non-standard code39? */
425 /* check for correct start and end symbol * or NwNnWnWnN Narrow+Wide */
426 for (i=0;i<9;i++) wb9[i]=wb[i]+((i&1)?addS:addB); /* good for sample090916 */
427 if (wb9[0]>dw*2 || wb9[1]<=dw*2 || wb9[2]> dw*2) return 0; /* # # */
428 for (i=0;i<9;i++) wb9[i]=wb[2*num_bars-2-i]+((i&1)?addS:addB); /* good for sample090916 */
429 if (wb9[0]>dw*2 || wb9[1]> dw*2 || wb9[2]<=dw*2) return 0; /* ## # */
430 #endif
431 g_debug(fprintf(stderr," code39 base=%.3f B=%d-%d S=%d-%d chars=%2d\n ",dw,minB,maxB,minS,maxS,(num_bars)/5);)
432 buf =(char *)malloc( 1+(num_bars)/5); if (!buf) return result;
433 result=(char *)malloc(256+(num_bars)/5);
434
435 for(i5=i1=0;i1<2*num_bars-3;i1+=10) {
436 /* normalization, good for sample090916 */
437 for (i=0;i<9;i++) wb9[i]=wb[i1+i]+((i&1)?addS:addB);
438 /* ToDo: looking for three widest bars/gaps, 0 or 2 bars, 1 or 3 spaces */
439 sort(wb9,idx,9);
440 for(err=0,i3=3;i3<9;i3++) // estimate error ??
441 err+=sqr((wb9[idx[i3]])/dw-1.0); /* narrow=1, wide=2..3 */
442 dww+=err;
443 for(i3=0;i3<Num39;i3++)
444 if (code39[10*i3+1+(idx[0]%2)*5+idx[0]/2]=='-'
445 && code39[10*i3+1+(idx[1]%2)*5+idx[1]/2]=='-'
446 && code39[10*i3+1+(idx[2]%2)*5+idx[2]/2]=='-') break;
447 if (i5>0 && i5<num_bars/5-2) crc+=i3;
448 buf[i5++]=code39[10*i3];
449
450 /* ToDo: check if we have even number of black bars within 3 biggest */
451 g_debug(for(i3=0;i3<9;i3++)fprintf(stderr,"%02d ",wb[i1+i3]);
452 fprintf(stderr," posWide=%d,%d,%d %c err=%.3f\n ",
453 idx[0],idx[1],idx[2],buf[i5-1],err/6);)
454 { int num_ws=0; // Jul09 ~codabar
455 if (idx[0]&1) num_ws++;
456 if (idx[1]&1) num_ws++;
457 if (idx[2]&1) num_ws++;
458 if ((num_ws&1)==0) { // num wide spaces must be 1 or 3
459 free (buf); free(result);
460 g_debug(fprintf(stderr," num wide spaces = %d, abort code39\n", num_ws);)
461 return 0;
462 }
463 }
464 }
465 buf[i5]=0;
466 if (result)
467 sprintf(result,"<barcode type=\"39\" chars=\"%d\" code=\"%s\" "
468 "crc=\"%c\" error=\"%.3f\" />",
469 i5,buf,code39[(crc%44)*10],dww/((num_bars/5)*6));
470 free(buf);
471 return result;
472 }
473
474 /* code interleaved 2 of 5 numbers-only (10 bars+spaces = 2 decimal digits)
475 B B B B B <= digit1 bars=1,3,5,...
476 S S S S S <= digit2 spaces=2,4,6,...
477 1122447700 <= weight digit=sum(bit*weight)%11 (except 7+4=11 means 0)
478 N = narrow bar, W = wide bar, n = narrow space, w = wide space
479 "NnNn"+interleaved+"WnN" (odd num W, even num w)
480 18 digits/inch
481 see http://www.barcode-1.net/i25code.html (Jun 2009)
482 minN=0.19mm=0.0075inch
483 sizeN>0.02inch: sizeW=2..3*sizeN (but constant)
484 sizeN<0.02inch: sizeW=2.2..3*sizeN
485 quite zones 10*sizeN or 0.25inch
486 heigh=max(0.15*symbol_length,0.25inch)
487 Len = (numChars*(2*(sizeW/sizeN)+3) + 6 + (sizeW/sizeN)) * sizeN
488 */
489 #define Num25 10
490 const char *code25= /* is the code sorted randomly? */
491 "1-...-2.-..-3--...4..-.-5-.-..6.--..7...--8-..-.9.-.-.0..--.";
492
493 /* example: barcode -E -e i25 -b 123456 >a.eps */
494
495 /*
496 add i25, patch by: Chris Lee, 13 Jul 2009
497 ToDo: check correctness
498 */
decode_i25(int * wb,int num_bars)499 char *decode_i25(int *wb, int num_bars){ /* ToDo: char *dest, int len */
500 int i, w, i1, i3, i5, crc, idx[7], pos;
501 double dw, dww, err; char *buf;
502 char *result=NULL; /* malloc and store the result */
503
504 int *wb_temp;
505 int *wb_check;
506 int code_chars;
507
508 if ((num_bars)%5!=4) return 0; /* chars*5bars + 4 start/stop bars */
509 code_chars = ((num_bars - 4) / 5) * 2;
510 // dw=w*1.0/(9*(num_bars/3)); /* threshold = 1.5..2 */
511
512 wb_temp = (int *)malloc((code_chars * 5)*sizeof(int)); if (!wb_temp) { return NULL; }
513 wb_check = (int *)malloc( 7 *sizeof(int));
514 if (!wb_check) { free(wb_temp); return NULL; }
515 buf =(char *)malloc( code_chars);
516 if (!buf) { free(wb_temp); free(wb_check); return NULL; }
517
518 for (i=0; i<(code_chars * 5)+7; i++) {
519 if (i<4) { wb_check[i] = wb[i]; } /* start sequence NnNn... */
520 else if (i > ((code_chars*5)+3)) { /* end sequence ...WnN */
521 wb_check[i-(code_chars*5)] = wb[i]; }
522 else {
523 pos = i - 4;
524 /* reinterleave 0,5,1,6,2,7,3,8,4,9,... to 0,1,2,3,4,5,6,7,8,9,... */
525 // pos = (int)(10*(int)(pos/10) + 1.0*(pos%10)/2.0 + 4.5*(pos%2));
526 pos = 10*(pos/10) + (pos%10)/2 + 5*(pos&1);
527 wb_temp[pos] = wb[i];
528 }
529 }
530 wb = wb_temp;
531
532 /* check start / finish codes */
533 sort(wb_check,idx,7);
534 if (idx[0] != 4 /* widest bar W must be the 4th = 1st of end */
535 || wb_check[idx[0]]==wb_check[idx[1]]) { /* exact 1 widest */
536 free(wb_temp);
537 free(wb_check);
538 g_debug(fprintf(stderr," need exact 1 widest at start of end, abort\n");)
539 return 0;
540 }
541
542 for(w=i=0; i<5*code_chars;i++ ) w+=wb[i]; /* summ width */
543 dw=w*1.0/(16*(num_bars/5)); /* threshold = 1.5..2 */
544 /* whats best and most rigorosely for dw=threshold_width?
545 * - (1.5..2)*mean_width of every 5th space
546 * - (1.5..2)*summ(5bars+5spaces)/(13..16)
547 * - 3/4*summ(three thickest)/3
548 */
549 dww=crc=0; /* error and checksum (not supported yet) */
550 #if 0 /* should we exclude any non-standard code39? */
551 /* check for correct start and end symbol * or NwNnWnWnN Narrow+Wide */
552 i=2*num_bars-2;
553 if (wb[ 0]>dw*2 || wb[ 1]<=dw*2 || wb[ 2]> dw*2) return 0;
554 if (wb[i-0]>dw*2 || wb[i-1]> dw*2 || wb[i-2]<=dw*2) return 0;
555 #endif
556 g_debug(fprintf(stderr," code25 base=%.3f chars=%2d\n ",dw,code_chars);)
557
558 for(i5=i1=0;i1<5*code_chars;i1+=5) {
559 /* ToDo: looking for three widest bars/gaps */
560 sort(wb+i1,idx,5);
561 for(err=0,i3=2;i3<5;i3++)
562 err+=sqr(wb[i1+idx[i3]]/dw-1.0); /* narrow=1, wide=2..3 */
563 dww+=err;
564 for(i3=0;i3<Num25;i3++)
565 if (code25[6*i3+1+idx[0]]=='-'
566 && code25[6*i3+1+idx[1]]=='-') break;
567 //if (i5>0 && i5<num_bars/3-2) crc+=i3;
568 buf[i5++]=code25[6*i3];
569
570 /* ToDo: check if we have even number of black bars within 3 biggest */
571 g_debug(for(i3=0;i3<5;i3++)fprintf(stderr,"%02d ",wb[i1+i3]);
572 fprintf(stderr," posWide=%d,%d %c err=%.3f\n ",
573 idx[0], idx[1], buf[i5-1], err/6);)
574 {
575 /* check that we have exact 2 widest bars, 2nd widest > 3th widest */
576 if (wb[i1+idx[1]]==wb[i1+idx[2]]) {
577 free(buf);
578 free(wb_temp);
579 free(wb_check);
580 g_debug(fprintf(stderr," need exact 2 widest, abort\n");)
581 return 0;
582 }
583 }
584 }
585 buf[i5]=0;
586 result=(char *)malloc(256+code_chars);
587 if (result) // ToDo: fix CRC (not defined?)
588 sprintf(result,"<barcode type=\"i25\" chars=\"%d\" code=\"%s\" crc=\"%c\""
589 " error=\"%.3f\" />", i5,buf,code25[(crc%10)*10],dww/((num_bars/5)*6));
590
591 free(wb_temp);
592 free(wb_check);
593 free(buf);
594 return result;
595 }
596
597 /* code codabar, numbers only, 4 bars per char (1*wide bar, 1*wide space)
598 robust code (dot-matrix printer)
599 characters have same length (distance between 1st bar to 4th space)
600 ??? codeproject: 6*n+2*w=12 or 5*n+3*w=14
601 ??? suchymips.de:
602 variant 1: 18 different bar widths (Monarch code)
603 variant 2: 2 different bar widths (Codabar Matrix or ABC-Codabar)
604 9..11 digits/inch, N=narrow bar, W=wide bar, n=narrow space, w=wide space
605 see http://www.barcodeman.com/info/codabar.php (Jul 2009)
606 minN=0.17mm=0.0065inch, 11 digits/inch = 0.0909 = 14*minN
607 2of7 + extensions
608 extensions: 1 wide bar + 2 wide spaces (no narrow space between 2 wide)
609 4 start/stop sets = a/t, b/m, c/ *, d/e
610 - mean wide = thickest of 4 bars
611 - mean narrow = thinnest of 4 bars, thinnest of 3 (4) spaces or every 4th
612 wiki-sample: a31117013206375b (wide spaces between chars) schraeg!
613 barcode: t1234567t n=N=1 w=W=3 c=12,14 (not const.)
614 */
615 const char *code27= /* 4bars+3spaces, 12+12 chars */
616 // 0..11: 3 nbar + 1 wbar + 2 nspace + 1 wspace
617 "0.....--1....--.2...-..-3--.....4..-..-."
618 "5-....-.6.-....-7.-..-..8.--....9-..-...-...--..$..--..."
619 // 12..15: 1 nbar + 3 wbar + 3 nspace + 0 wspace
620 ":-...-.-/-.-...-.-.-.-..+..-.-.-"
621 // 16..23: 3 nbar + 1 wbar + 1 nspace + 2 wspace
622 "a..--.-.b.-.-..-c...-.--d...---.t..--.-.n.-.-..-*...-.--e...---."
623 // EOS
624 "????????";
625
626 /* example: barcode -E -e cbr -b 123456 >a.eps */
627
decode_27(int * wb,int num_bars)628 char *decode_27(int *wb, int num_bars){ /* ToDo: char *dest, int len */
629 int i, i1, i2, i3, i4, i5, b_idx[4], s_idx[3], b_w[4], s_w[3],
630 max_wdiff;
631 #if DO_DEBUG
632 int err=0;
633 #endif
634 // double dw, err;
635 char *buf, char27[8]="......";
636 char *result=NULL; /* malloc and store the result */
637
638 int code_chars;
639 #if 0 // ToDo: verifications nb_max < wb_min etc.
640 int nb_min=99999, nb_max=0, nb_sum=0, nb_num=0; // narrow bar
641 int ns_min=99999, ns_max=0, ns_sum=0, ns_num=0; // narrow space
642 int wb_min=99999, wb_max=0, wb_sum=0, wb_num=0; // wide bar
643 int ws_min=99999, ws_max=0, ws_sum=0, ws_num=0; // wide space
644 #endif
645
646 if ((num_bars)%4!=0) return 0; /* chars*4bars */
647 code_chars = num_bars / 4;
648 // dw=w*1.0/(9*(num_bars/3)); /* threshold = 1.5..2 */
649
650 g_debug(fprintf(stderr," codabar chars= %d\n ", code_chars);)
651 buf =(char *)malloc( code_chars); if (!buf) return result;
652 result=(char *)malloc(256+code_chars);
653 i5=0; // index output string
654 for (i=0; i< code_chars; i++) {
655 b_w[0]=wb[i*8+0]; // 1st bar
656 b_w[1]=wb[i*8+2]; // 2nd bar
657 b_w[2]=wb[i*8+4]; // 3th bar
658 b_w[3]=wb[i*8+6]; // 4th bar
659 s_w[0]=wb[i*8+1]; // 1st space
660 s_w[1]=wb[i*8+3]; // 2nd space
661 s_w[2]=wb[i*8+5]; // 3th space
662 sort(b_w,b_idx,4); /* idx[0] points to widest bar */
663 sort(s_w,s_idx,3); /* idx[0] points to widest space */
664 g_debug(for(i3=0;i3<7;i3++)fprintf(stderr,"%02d ",wb[8*i+i3]);)
665 if (b_w[b_idx[0]]==b_w[b_idx[3]]) { g_debug(err=__LINE__;) break; } // min. 1 wide + narrow
666 // search max. diff between sorted widths
667 i2=b_w[b_idx[0]]-b_w[b_idx[1]]; i1=1; max_wdiff=i2; // diff widest - 2nd wides
668 i2=b_w[b_idx[1]]-b_w[b_idx[2]]; if (i2>max_wdiff) { i1=2; max_wdiff=i2; }
669 i2=b_w[b_idx[2]]-b_w[b_idx[3]]; if (i2>max_wdiff) { i1=3; max_wdiff=i2; }
670 if (i1==2) { g_debug(err=__LINE__;) break; } // 2 wide + 2 narrow bars not allowed
671 for (i3=0;i3<7;i3++) char27[i3]='.'; // reset char
672 if (i1==1) { // 1 wide bar (1 or 2 wspaces)
673 if (s_w[s_idx[0]]-s_w[s_idx[1]]
674 >s_w[s_idx[1]]-s_w[s_idx[2]]) { // 1 wspace
675 char27[2*b_idx[0]+0]='-';
676 char27[2*s_idx[0]+1]='-';
677 } else { // assume 2 wspaces
678 if (s_w[s_idx[2]]==s_w[s_idx[1]]) { g_debug(err=__LINE__;) break; }
679 char27[2*b_idx[0]+0]='-';
680 char27[2*s_idx[0]+1]='-';
681 char27[2*s_idx[1]+1]='-';
682 }
683 } else { // assume 3 wbars + 0 wspaces
684 char27[2*s_idx[0]+0]='-';
685 char27[2*s_idx[1]+0]='-';
686 char27[2*s_idx[2]+0]='-';
687 }
688 for(i4=24,i3=0;i3<24;i3++) {
689 if (code27[8*i3+1]==char27[0]
690 && code27[8*i3+2]==char27[1]
691 && code27[8*i3+3]==char27[2]
692 && code27[8*i3+4]==char27[3]
693 && code27[8*i3+5]==char27[4]
694 && code27[8*i3+6]==char27[5]
695 && code27[8*i3+7]==char27[6]) {
696 i4=i3; buf[i5++]=code27[8*i3]; break; }
697 }
698 g_debug(fprintf(stderr," %s c27= %c\n ", char27, ((i5)?buf[i5-1]:'?'));)
699 if (i4==24) { g_debug(err=__LINE__;) break; }
700 } // each char
701 if (i>=code_chars) { // else: inconsistent char
702 g_debug(fprintf(stderr," code27 base=%.3f chars=%2d\n ",0.0,code_chars);)
703 } else {
704 g_debug(fprintf(stderr," error %d at char %d, abort\n", err, i);)
705 free(result); result=0;
706 }
707 buf[i5]=0;
708 if (result) // ToDo: fix CRC (not defined?)
709 sprintf(result,"<barcode type=\"codabar\" chars=\"%d\" code=\"%s\""
710 " crc=\"%c\" error=\"%.3f\" />", i5,buf,'?',0.0);
711
712 free(buf);
713 return result; // free at parent!
714 }
715
716
717 /*
718 decode barcode
719 - check main characteristics (num bars, min+max width, etc.)
720 - detect code type
721 - the current algorithm measures the width of bars and spaces
722 called by detect_barcode()
723 ToDo: - like storing sequence of widths for 1D code
724 store array of bits for 2D matrix code and decode later
725 */
decode_barcode(struct box * bb)726 char *decode_barcode(struct box *bb){ /* ToDo: char *dest, int len */
727 job_t *job=OCR_JOB; /* fixme */
728 int i, num_bars, yy, w, ww, dx, xx, cs=job->cfg.cs, *wb;
729 char *result=NULL; /* store the result */
730 yy=(bb->y0+bb->y1)/2;
731 w=ww=bb->x1-bb->x0+1;
732 num_bars = num_cross_fine(bb->x0,bb->x1,yy,yy,bb->p,job->cfg.cs);
733 if(job->cfg.verbose)
734 fprintf(stderr,"\n# ... detect bars=%3d w=%4d",num_bars,ww);
735
736 /* store width of bars and spaces to buffer wb */
737 wb=(int *)malloc(2*num_bars*sizeof(int)); if(!wb) return NULL;
738 xx=bb->x0;
739 xx-=loop(bb->p,xx,yy, 8,cs,1,LE);
740 xx+=loop(bb->p,xx,yy,ww,cs,0,RI); /* start with a bar! */
741 for (i=0;i<2*num_bars;i++) {
742 dx=loop(bb->p,xx,yy,w,cs,1^(i&1),RI);
743 xx+=dx;
744 w-=dx;
745 wb[i]=dx;
746 } wb[2*num_bars-1]=0;
747
748 /* ToDo: what about probability? if not unique
749 * - add argument char *result which can be modified or not,
750 * - or add box2? (would reuse of this code more difficult)
751 */
752 /* test code128 characteristics, ToDo: look for correct start/stop 211 seq. */
753 if ((num_bars-1)%3==0 && num_bars>=10 && ww>=11*(num_bars-1)/3+2){
754 if (!result) result=decode_code128(wb,num_bars);
755 }
756 /* test UPC/EAN characteristics */
757 if ((num_bars)%2==0 && num_bars>=8 && ww>=7*(num_bars-6)/2+11
758 && ((num_bars-6)/2)%2==0){ /* should be balanced */
759 if (!result) result=decode_UPC(wb,num_bars);
760 }
761 /* test UPC_addon by Michael van Rooyen, often on books */
762 if (num_bars==7 || num_bars==16)
763 if (!result) result=decode_UPC_addon(wb,num_bars);
764
765 /* test code39 characteristics */
766 if ((num_bars)%5==0 && num_bars>14){
767 if (!result) result=decode_39(wb,num_bars);
768 }
769 /* test i2of5 chartacteristics */
770 if ((num_bars)%5==4 && num_bars>3) {
771 if (!result) result=decode_i25(wb,num_bars);
772 }
773
774 /* test codabar chartacteristics */
775 if ((num_bars)%4==0 && num_bars>3) {
776 if (!result) result=decode_27(wb,num_bars);
777 }
778
779 free(wb);
780 return result;
781 }
782
783 // RS Reed Solomon Code
784 // Definition of Galois Field GF(2^m) (de: Zahlenraum, endl. Koerper)
785 // 1bit: m=1 dual GF2={0,1}
786 // 0+0=0 0+1=1 1+0=1 1+1=0 0*0=0*1=1*0=0 1*1=1 a^1=1?
787 // a^0=1 a^1=1
788 // 8bit: m=8 byte GF256= a=primitiv_element=2 a^255=1
789 // exp[0]=1; expa[i+1]=expa[i]*a;
790 // i: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 ... 254 255
791 // a^i: 1 2 4 8 16 32 64 128 29 58 116 232 205 135 19 ... 142 1
792 // generated by shift-register
793 // representation of GF(256) using the given primitive polynomial
794 // GF256_QR_CODE_FIELD = GF256(0x011D); // x^8 + x^4 + x^3 + x^2 + 1
795 // GF256_DATA_MATRIX_FIELD = GF256(0x012D); // x^8 + x^5 + x^3 + x^2 + 1
796 // based on LGPL code by Phil Karn, KA9Q 2004 + qrencode by Kentaro Fukuchi
797
798 typedef unsigned char uchar;
799 /**
800 * Reed-Solomon codec control block
801 */
802 struct _RS {
803 int mm; /* Bits per symbol, max=8 */
804 int nn; /* Symbols per block (= (1<<mm)-1) */
805 uchar alpha_exp[256]; /* log lookup table x=alpha^i, max_mm=8 */
806 uchar alpha_log[256]; /* Antilog lookup table i=loga(x), max_mm=8 */
807 uchar genpoly[256]; /* Generator polynomial, nroots_man=2^8-1 */
808 int nroots; /* Number of generator roots = number of parity symbols */
809 int fcr; /* First consecutive root, index form */
810 int prim; /* Primitive element, index form */
811 int iprim; /* prim-th root of 1, index form */
812 int pad; /* Padding bytes in shortened block */
813 int gfpoly;
814 };
815
816 static struct _RS rs;
817
818 #if 0
819 static int GF256_mult(int a, int b) { // a*b
820 int i, r=0, t=b; // result + temp var
821 int primitive = 0x011D;
822 for (i=0; i<8; i++) {
823 // <<= 1 is multiplication by a=2, ^= primitive_polynomial
824 r <<= 1; if (r & 0x100) r ^= primitive;
825 t <<= 1; if (t & 0x100) r ^= a;
826 }
827 return r;
828 }
829
830 static int GF256_invers_mult(int b) { // 1/b, (a/b)=a*(1/b)
831 int i, r = b;
832 for (i=1; i<7; i++) r = GF256_mult( GF256_mult(r,r), b);
833 return r;
834 }
835 #endif
836 /* Initialize a Reed-Solomon codec
837 * symsize = symbol size, bits (8 for GF256=GF(2^8))
838 * gfpoly = Field generator polynomial coefficients (0x011D for QR-Code)
839 * fcr = 1st root of RS code generator polynomial, index form (0..2^symsize-1)
840 * fcr = 0
841 * prim = primitive element to generate polynomial roots (1..2^symsize-1)
842 * prim = 1
843 * nroots = RS code generator polynomial degree (number of roots) (0..2^8-1)
844 nroots = num_ecc_bytes
845 * pad = padding bytes at front of shortened block (0..2^8-2-nroots)
846 * pad = 255 - num_ecc_bytes - num_data_bytes
847 * 2018-09 static inline, without inline because Visual Studio for Win. 2010
848 */
modnn(struct _RS * rs,int x)849 static int modnn(struct _RS *rs, int x){
850 while (x >= rs->nn) { // 255
851 x -= rs->nn; // 255
852 x = (x >> rs->mm) + (x & rs->nn); // 8 , 255
853 }
854 return x;
855 }
init_rs(int symsize,int gfpoly,int fcr,int prim,int nroots,int pad)856 static void init_rs(int symsize, int gfpoly, int fcr,
857 int prim, int nroots, int pad) {
858 int i,j,x,root,iprim;
859 rs.mm= symsize;
860 rs.nn= (1<<symsize)-1;
861 rs.pad= pad;
862 rs.nroots= nroots;
863
864 g_debug(fprintf(stderr,"\n# init_rs symsize= %d gfpoly=0x%04x necc= %4d\n# ",
865 symsize, gfpoly, nroots);)
866 /* Generate Galois field lookup tables using
867 * primitive field generator polynomial gfpoly */
868 rs.alpha_log[0]= rs.nn; // nn=255, log(0) = -inf
869 rs.alpha_exp[rs.nn]= 0; // alha^(-inf) = 0
870 x=1;
871 for (i=0; i<255; i++) {
872 rs.alpha_log[x] = i;
873 rs.alpha_exp[i] = x;
874 x <<= 1; if (x >= 0x100) { x ^= gfpoly; }
875 // g_debug(fprintf(stderr," %3d",x);)
876 }
877 if (x!=1) fprintf(stderr,"init_rs failed, bad primitive gfpoly x=%d\n# ",x);
878 // for (i=0; i<256; i++)
879 // printf(" i a^i loga(i) %3d %3d %3d\n", i, alpha_exp[i], alpha_log[i]);
880 /* Form RS code generator polynomial from its roots */
881 /* Find prim-th root of 1, used in decoding, prim=1, rs.nn=255, iprim=1 */
882 for(iprim=1; (iprim % prim) != 0; iprim += rs.nn);
883 rs.iprim = iprim / prim;
884 rs.genpoly[0]=1; // alpha0*x^nroot + ...
885 for (i = 0, root=fcr*prim; i < nroots; i++, root += prim) {
886 rs.genpoly[i+1] = 1;
887 /* Multiply rs.genpoly[] by alpha^(root + x) */
888 for (j = i; j > 0; j--){
889 if (rs.genpoly[j] != 0)
890 rs.genpoly[j] = rs.genpoly[j-1] ^ rs.alpha_exp[
891 modnn(&rs,rs.alpha_log[rs.genpoly[j]] + root)];
892 else
893 rs.genpoly[j] = rs.genpoly[j-1];
894 }
895 /* rs.genpoly[0] can never be zero */
896 rs.genpoly[0] = rs.alpha_exp[modnn(&rs,rs.alpha_log[rs.genpoly[0]] + root)];
897 }
898 #if DO_DEBUG
899 if (OCR_JOB->cfg.verbose&1) {
900 int i;
901 for (i=0; i <= nroots; i++)
902 fprintf(stderr,"%3d ", i);
903 fprintf(stderr,"\n# ");
904 for (i=0; i <= nroots; i++)
905 fprintf(stderr,"%3d ", rs.genpoly[i]); // coefficient * x^i
906 fprintf(stderr,"\n# ");
907 }
908 #endif
909 /* convert rs.genpoly[] to index form for quicker encoding */
910 for (i = 0; i <= nroots; i++)
911 rs.genpoly[i] = rs.alpha_log[rs.genpoly[i]];
912 #if DO_DEBUG
913 if (OCR_JOB->cfg.verbose&1) {
914 int i;
915 for (i=0; i <= nroots; i++)
916 fprintf(stderr,"%3d ", rs.genpoly[i]); // exponent i of alpha^i
917 fprintf(stderr,"\n# ");
918 }
919 #endif
920 }
encode_rs_char(struct _RS * rs,const uchar * data,uchar * parity)921 void encode_rs_char(struct _RS *rs, const uchar *data, uchar *parity) {
922 int i, j; uchar feedback;
923 memset(parity,0,rs->nroots*sizeof(uchar));
924
925 for(i=0;i<rs->nn - rs->nroots - rs->pad;i++){
926 feedback = rs->alpha_log[data[i] ^ parity[0]];
927 if(feedback != rs->nn){ /* feedback term is non-zero */
928 #ifdef UNNORMALIZED
929 // unnecessary when genpoly[nroots] = 1, as constructed by init_rs()
930 feedback = modnn(rs, rs->nn - rs->genpoly[rs->nroots] + feedback);
931 #endif
932 for(j=1;j<rs->nroots;j++)
933 parity[j] ^= rs->alpha_exp[modnn(rs, feedback + rs->genpoly[rs->nroots-j])];
934 }
935 /* Shift */
936 memmove(&parity[0],&parity[1],sizeof(uchar)*(rs->nroots-1));
937 if(feedback != rs->nn)
938 parity[rs->nroots-1] = rs->alpha_exp[modnn(rs, feedback + rs->genpoly[0])];
939 else
940 parity[rs->nroots-1] = 0;
941 }
942 #if DO_DEBUG
943 if (OCR_JOB->cfg.verbose&1) {
944 int i;
945 fprintf(stderr,"\n# ecc\n# ");
946 for (i=0; i <= rs->nroots; i++)
947 fprintf(stderr,"%3d ", parity[i]); // exponent i of alpha^i
948 fprintf(stderr,"\n# ");
949 for (i=0; i <= rs->nroots; i++)
950 fprintf(stderr," %02x ", parity[i]); // exponent i of alpha^i
951 fprintf(stderr,"\n# ");
952 }
953 #endif
954 }
955
956 /*
957 * taking the list of boxes and search for groups of bars (1D-barcodes)
958 */
detect_barcode(job_t * job)959 int detect_barcode(job_t *job)
960 {
961 int j=0, j2=0, bx0, by0, bx1, by1, bdx, bdy, bbx, bby, rm,
962 nbars, x0, y0, dx, dy, cs, x, y, yl0, yl1, yr0, yr1,
963 regx, regy; // regions for 2D barcode
964 struct box *box2, *box3;
965
966 if(job->cfg.verbose)
967 fprintf(stderr,"# barcode.c detect_barcode ");
968 x0=y0=0; rm=0; dx=job->src.p.x; dy=job->src.p.y; cs=job->cfg.cs;
969 bdx=0; bdy=0;
970 for_each_data(&(job->res.boxlist)) {
971 box2 = (struct box *)list_get_current(&(job->res.boxlist));
972 /* detect width (bdx) and height (bdy) of possible bar */
973 /* ToDo: better check for a line */
974 bdx=box2->x1-box2->x0+1 /* substract correction for skewed bars */
975 -loop(box2->p,box2->x1,(box2->y0+box2->y1)/2,box2->x1-box2->x0,cs,0,LE)
976 -loop(box2->p,box2->x0,(box2->y0+box2->y1)/2,box2->x1-box2->x0,cs,0,RI);
977 bdy=box2->y1-box2->y0+1;
978 if (box2->c == PICTURE || box2->c == UNKNOWN)
979 if (box2->y0 >= y0 && box2->y1 <= y0 + dy /* within frame? */
980 && box2->x0 >= x0 && box2->x1 <= x0 + dx
981 && box2->y1 - box2->y0 > 19 /* min. length */
982 && box2->y1 - box2->y0 > 8 * bdx
983 ) { /* a bar? */
984 j=1; /* number of bars */
985 bx0=box2->x0; bx1=box2->x1; /* initial values for barcode frame */
986 by0=box2->y0; by1=box2->y1;
987 bbx=bx1-bx0+2; /* width of bar */
988 /* this is for scans which are not exactly horizontal */
989 yl0=yr0=by0; /* left and right upper bound */
990 yl1=yr1=by1; /* left and right lower bound */
991 /* --- iteratively take into account next nearest bar ---
992 * this is important, because bar-boxes are not in right order */
993 for (j2=1;j2;) {
994 j2=0;
995 /* expand a frame around the potential barcode (bx0,by0,bx1,by1) */
996 for_each_data(&(job->res.boxlist)) {
997 box3 = (struct box *)list_get_current(&(job->res.boxlist));
998 /* bdy=box3->y1-box3->y0+1; */
999 if (box2!=box3)
1000 if (box3->c == PICTURE || box3->c == UNKNOWN)
1001 if (box3->y0 >= y0 && box3->y1 <= y0 + dy /* within image */
1002 && box3->x0 >= x0 && box3->x1 <= x0 + dx
1003 && box3->y1 - box3->y0 > 19 /* min. length */
1004 && box3->y1 - box3->y0 > 4 * (bdx) /* height > 4*width2 */
1005 && box3->x1 - box3->x0 < 4 * (bdy) /* width < height/4 = bar */
1006 && (( abs(box3->y0-by0)<bdy/16+4 /* within bar-box ? */
1007 && abs(box3->y1-by1)<bdy/2 ) /* lower ends of UPC could be longer */
1008 ||( abs(box3->y0-yl0)<bdy/16+4 /* left side of frame */
1009 && abs(box3->y1-yl1)<bdy/2
1010 && box3->x0 <= bx0 )
1011 ||( abs(box3->y0-yr0)<bdy/16+4 /* right side of frame */
1012 && abs(box3->y1-yr1)<bdy/2
1013 && box3->x0 >= bx1 ) )
1014 && box3->x0 > bx0 - 12*bbx /* startspace=5...10 */
1015 && box3->x1 < bx1 + 12*bbx
1016 && box3->x0 > bx0 - bdy/2 /* dont glue two barcodes together */
1017 && box3->x1 < bx1 + bdy/2 /* ex: ean13a.jpg */
1018 /* dont check bars which already within the frame twice ? */
1019 && ( box3->x1 > bx1 || box3->x0 < bx0 )
1020 ) { /* a bar? -> extend barcode frame only in x direction */
1021 /* take minimum of y to have valid barcode for all y */
1022 if (box3->x0<bx0) { bx0=box3->x0; yl0=box3->y0; yl1=box3->y1; }
1023 if (box3->x1>bx1) { bx1=box3->x1; yr0=box3->y0; yr1=box3->y1; }
1024 if (4*(box3->y1-box3->y0)>3*(by1-by0)) { /* carefull reduce */
1025 if (box3->y0>by0) by0=box3->y0; /* ToDo: fix for non-horizontal */
1026 if (box3->y1<by1) by1=box3->y1;
1027 }
1028 j++; /* found a near bar and count to num bars */
1029 j2=1; /* continue searching (endless loop?) */
1030 }
1031 } end_for_each(&(job->res.boxlist));
1032 }
1033 /* j is the num of bars found above, some inner bars are not counted */
1034 /* ToDo: better iterative add next nearest bars from sorted list near bars? */
1035 if (j>5) {
1036 char *code=0;
1037 box2->c=PICTURE; /* BARCODE */
1038 box2->x0=bx0; box2->y0=by0;
1039 box2->x1=bx1; box2->y1=by1;
1040 /* ToDo: add pointer to decoded text */
1041
1042 y=(box2->y0+box2->y1)/2;
1043 if (job->cfg.verbose){
1044 int nbars;
1045 nbars=num_cross_fine(box2->x0,box2->x1,y,y,box2->p,job->cfg.cs);
1046 fprintf(stderr,"\n# barcode at %3d %3d size %3d %3d nbars %d (%d)",
1047 bx0,by0,bx1-bx0+1,by1-by0+1,nbars,j);
1048 if (j!=nbars)
1049 fprintf(stderr,"\n# ... trouble: num_found_bars != num_cross");
1050 /* this is because some far bars are detected before near bars */
1051 }
1052 /* transport the info to the gocr-output (development) */
1053 /* ToDo: decode and print/store barcode bars=j */
1054 code=decode_barcode(box2); /* ToDo: char *dest, int len */
1055 if (!code) { /* failed */
1056 code=(char *)malloc(128);
1057 /* ToDo: analyze and output num_bars, width of bars etc. */
1058 if(code) strncpy(code,"<barcode type=\"unknown\" />",128);
1059 }
1060 if (job->cfg.verbose)
1061 fprintf(stderr,"\n# ... decoded as: %s", code);
1062 setas(box2,code,99); /* ToDo: set a better weight */
1063 free(code);
1064
1065 /* remove inner boxes, only if sure!? (ToDo: use cfg.certainty) */
1066 for_each_data(&(job->res.boxlist)) {
1067 box3 = (struct box *)list_get_current(&(job->res.boxlist));
1068 /* bdy=box3->y1-box3->y0+1; */
1069 if (box2!=box3)
1070 if (box3->c == PICTURE || box3->c == UNKNOWN)
1071 if ( abs(box3->y0-by0)<bdy/16+4 /* within bar-box ? */
1072 && abs(box3->y1-by1)<bdy/2 /* lower ends of UPC could be longer */
1073 && box3->x1 <= bx1
1074 && box3->x0 >= bx0
1075 ) {
1076 rm++; /* count removed boxes */
1077 list_del(&(job->res.boxlist),box3);
1078 free_box(box3);
1079 }
1080 } end_for_each(&(job->res.boxlist));
1081 if (job->cfg.verbose)
1082 fprintf(stderr,"\n# ... removed boxes: %d", rm);
1083 rm=0;
1084 }
1085 }
1086 } end_for_each(&(job->res.boxlist));
1087
1088 /* recalculate averages without bars */
1089 job->res.numC=job->res.sumX=job->res.sumY=j2=0;
1090 for_each_data(&(job->res.boxlist)) {
1091 j2++;
1092 box3 = (struct box *)list_get_current(&(job->res.boxlist));
1093 if (box3->c==PICTURE) continue;
1094 job->res.numC++; /* count remaining boxes */
1095 job->res.sumX+=box3->x1-box3->x0+1;
1096 job->res.sumY+=box3->y1-box3->y0+1;
1097 } end_for_each(&(job->res.boxlist));
1098 if(job->cfg.verbose)
1099 fprintf(stderr,"\n# ... boxes %d nC %d\n",
1100 j2, job->res.numC);
1101
1102
1103 /* ---------------------------------------------------------------
1104 * ToDo: detect DataMatrix = iec16022 (ecc200, 24 sizes)
1105 * search square of 2 lines and 2 dottet lines (first no rotation)
1106 * output characteristics pixel size, bytes, code type, etc.
1107 * symbolsize: 10^2...26^2, 32^2 ... 104^2, 120^2 ... 144^2
1108 * dataregion: 8^2...24^2, (4,16)*(14...24)^2, 36*(18,20,22)^2
1109 * codewords: 3...44, 62...816, 1050...1558
1110 * errorwords: 5...28, 36...336, 408...620
1111 * fill byte = 129, ASCIIdata = ASCII + 1
1112 *
1113 * ToDo: !!! no Reed Solomon Error Correction at the moment !!!
1114 * ToDo: !!! raw data output, no ASCII decoding !!!
1115 * see http://grandzebu.net/ ... datamatrix.htm
1116 * sample: iec16022 -f PNG 123456 > datamatrix_123456.png
1117 */
1118
1119 if(job->cfg.verbose)
1120 fprintf(stderr,"# barcode.c detect_barcode search datamatrix ");
1121 x0=y0=0; rm=0; dx=job->src.p.x; dy=job->src.p.y; cs=job->cfg.cs;
1122 for_each_data(&(job->res.boxlist)) {
1123 box2 = (struct box *)list_get_current(&(job->res.boxlist));
1124 /* detect width (bdx) and height (bdy) of possible matrix */
1125 /* ToDo: better check for a line */
1126 bdx=box2->x1-box2->x0+1; /* ToDo: correction for skewed matrix */
1127 bdy=box2->y1-box2->y0+1;
1128 if (bdx<10 || bdy<10) continue; // 2010-09-28 reduce output + computation
1129 // g_debug(fprintf(stderr,"\n# datamatrix box size %4d %4d", bdx, bdy);)
1130 by0=0; bx1=0; /* x of hor. max_num_crosses, max_num_crosses */
1131 bx0=0; by1=0; /* y of vert. max_num_crosses, max_num_crosses */
1132 x=num_cross_fine(box2->x0,box2->x1,box2->y1,box2->y1,box2->p,job->cfg.cs);
1133 y=num_cross_fine(box2->x0,box2->x0,box2->y0,box2->y1,box2->p,job->cfg.cs);
1134 for (j = box2->y0; j <= box2->y1; j++) {
1135 nbars=num_cross(box2->x0,box2->x1,j,j,box2->p,job->cfg.cs);
1136 for (j2=0; j2<nbars; j2++) {
1137 int t = box2->x0+j2*bdx/(nbars);
1138 // fprintf(stderr,"\n# %3d %3d %d %d",j,j2,((getpixel(box2->p,t+1*bdx/(4*nbars),j)<cs)?1:0),
1139 // ((getpixel(box2->p,t+3*bdx/(4*nbars),j)<cs)?1:0));
1140 if (((getpixel(box2->p,t+1*bdx/(4*nbars),j)<cs)?1:0)!=1) break;
1141 if (((getpixel(box2->p,t+3*bdx/(4*nbars),j)<cs)?1:0)!=0) break;
1142 } if (j2!=nbars) continue;
1143 if (nbars> bx1) { bx1=nbars; by0=j; } // search most upper
1144 }
1145 for (j = box2->x0; j <= box2->x1; j++) {
1146 nbars=num_cross_fine(j,j,box2->y0,box2->y1,box2->p,job->cfg.cs);
1147 for (j2=0; j2<nbars; j2++) {
1148 int t = box2->y0+j2*bdy/(nbars);
1149 // fprintf(stderr,"\n# %3d %3d %d %d",j,j2,((getpixel(box2->p,j,t+1*bdy/(4*nbars))<cs)?1:0),
1150 // ((getpixel(box2->p,j,t+3*bdy/(4*nbars))<cs)?1:0));
1151 if (((getpixel(box2->p,j,t+1*bdy/(4*nbars))<cs)?1:0)!=0) break;
1152 if (((getpixel(box2->p,j,t+3*bdy/(4*nbars))<cs)?1:0)!=1) break;
1153 } if (j2!=nbars) continue;
1154 if (nbars>=by1) { by1=nbars; bx0=j; } // search most right
1155 }
1156 bbx=(bx1)?bdx/(2*bx1):1; /* width of base square */
1157 bby=(by1)?bdy/(2*by1):1; /* height of base square*/
1158 // ToDo: check upper and left finder pattern
1159 if (box2->c != PICTURE && box2->c != UNKNOWN) continue;
1160 if (x!=1 || y!=1) continue;
1161 // 30 possible ECC 200 datamatrix size versions
1162 if (( ( ( (bx1>=5 && bx1<=13)
1163 || (bx1>=16 && bx1<=26 && bx1%2==0)
1164 || (bx1>=32 && bx1<=52 && bx1%4==0)
1165 || (bx1>=60 && bx1<=72 && bx1%6==0))
1166 && bx1==by1)
1167 || (by1==4 && bx1==9)
1168 || (by1==6 && bx1==13)
1169 || (by1==8 && bx1==36)
1170 || (by1==4 && bx1==16)
1171 || (by1==6 && bx1==18)
1172 || (by1==8 && bx1==24))
1173 && by0 < box2->y0 + bby // alternating b/w border
1174 && bx0 > box2->x1 - bbx // alternating b/w border
1175 ) { /* a bar? */
1176 g_debug(fprintf(stderr,"\n# datamatrix box size %4d %4d ncross %d %d %d %d bb %d %d", bdx, bdy, x, y, bx1, by1, bbx, bby);)
1177 regx=1; regy=1; // regx*regy regions (2x2,4x4,6x6,1x2)
1178 if (bx1>=16) { regx=2; } // 13 < x <= 16
1179 if (bx1>=32) { regx=4; } // 26 < x <= 32
1180 if (bx1>=60) { regx=6; } // 52 < x <= 60
1181 if (by1>=16) { regy=2; }
1182 if (by1>=32) { regy=4; }
1183 if (by1>=60) { regy=6; }
1184 g_debug(fprintf(stderr," mark%03d %dx%d reg %d %d bb %d %d bytes %d",
1185 __LINE__,2*bx1,2*by1,regx,regy,bbx,bby,(bx1-regx)*(by1-regy)/2);)
1186 /* j is the num of bars found above, some inner bars are not counted */
1187 /* ToDo: better iterative add next nearest bars from sorted list near bars? */
1188 {
1189 int row, col;
1190 char *dm_bitmap=NULL;
1191
1192 // store pattern without finder pattern into dm_bitmap
1193 dm_bitmap=(char *)malloc(4*(bx1-regx)*(by1-regy));
1194 if (!dm_bitmap) { fprintf(stderr," ERROR: mallocDM1 failed\n"); continue; }
1195 for (row=0;row<2*(by1-regy);row++) {
1196 for (col=0;col<2*(bx1-regx);col++) {
1197 x = box2->x0+bbx*(col+1+2*((col+2)/(2*bx1/regx)))+bbx/2;
1198 y = box2->y0+bby*(row+1+2*((row+2)/(2*by1/regy)))+bby/2;
1199 dm_bitmap[row*2*(bx1-regx)+col]=
1200 ((getpixel(box2->p,x,y)<cs)?1:0);
1201 }
1202 }
1203
1204 /* transport the info to the gocr-output (development) */
1205 if (job->cfg.verbose) {
1206 fprintf(stderr,"\n# ");
1207 for (col=0;col<2*bx1;col++)
1208 if (col<=8) fprintf(stderr," %1d",col); else
1209 if (col<=98 && col%2==0) fprintf(stderr," %3d",col); else
1210 if (col%4==0) fprintf(stderr," %7d",col);
1211 for (row=0;row<2*by1;row++) {
1212 fprintf(stderr,"\n# %3d: ", row);
1213 for (col=0;col<2*bx1;col++)
1214 fprintf(stderr," %c",
1215 ((getpixel(box2->p,box2->x0+bbx*col+bbx/2,
1216 box2->y0+bby*row+bby/2)<cs)?
1217 (( col%(2*bx1/regx)==0
1218 || col%(2*bx1/regx)==2*bx1/regx-1
1219 || row%(2*by1/regy)==0
1220 || row%(2*by1/regy)==2*by1/regy-1
1221 )?'x':'o'):' ')); // 'o' = data1, 'x' = finder1
1222 }
1223 // show pure data
1224 fprintf(stderr,"\n# now without finder pattern\n# ");
1225 for (col=0;col<2*(bx1-regx);col++)
1226 if (col<=8) fprintf(stderr," %1d",col); else
1227 if (col<=98 && col%2==0) fprintf(stderr," %3d",col); else
1228 if (col%4==0) fprintf(stderr," %7d",col);
1229 for (row=0;row<2*(by1-regy);row++) {
1230 fprintf(stderr,"\n# %3d: ", row);
1231 for (col=0;col<2*(bx1-regx);col++) {
1232 fprintf(stderr," %c",
1233 (dm_bitmap[row*2*(bx1-regx)+col])?'o':' ');
1234 }
1235 }
1236 }
1237
1238 char *code=0; int cpos=0;
1239 box2->c=PICTURE; /* BARCODE */
1240 code=NULL;
1241 code=(char *)malloc(6*4*bx1*by1/8+128); /* maxlen: &#%3d; = 6 */
1242 if (!code) { fprintf(stderr," ERROR: mallocDM2 failed\n"); continue; }
1243 code[0]=0;
1244 strncpy(code,"<barcode type=\"datamatrix ecc200\" rawcode=\"\" />",128);
1245 cpos=43; // insert chars at position 40
1246 /* pixel 32x32 = (2*2)*(2*7+2)^2 = 4*196/8bit - 12B (Reed Solomon),
1247 * = 98-12 B = 86B */
1248
1249 // code=decode_datamatrix(box2); /* ToDo: char *dest, int len */
1250 // for 8x8 (10x10) first CW is at 1: -2,+2, 2: +0,+0, 3: +2,-2,
1251 // 4: +5,-1, 5: +3,+1, 6: +1,+3, 7: -1,+5, 8: +4,+4
1252 // = diagonal zick/zack
1253 // --> x=c 7 6 (start: r=4, c=0) up/right=(r-=2, c+=2)
1254 // | 5 4 3 down/left=(r+=2, c-=2)
1255 // v y=r 2 1 0 turn=(r+=3, c+=1)
1256 // sample ascii=\x30='0' \x40='@' \x20=' '
1257 /* ToDo: decode and print/store barcode bars=j */
1258 x = +0; // col += 2
1259 y = +4; // row -= 2
1260 int nc=2*(bx1-regx), nr=2*(by1-regy),
1261 // dm_mode=0, // ECC200-mode: 0=ASCII+digitpair, 230=C40
1262 dm_d=+1; // direction right/down
1263 for (j=0;j<(bx1-regx)*(by1-regy)/2;j++) { // each byte
1264 int dm_byte=0;
1265 const int *pp; /* pointer to (const int) */
1266 const int // bitmatrix + 4 special cases for lower left corner
1267 pn[8*2]={ 0, 0, -1, 0, -2, 0, 0,-1, -1,-1, -2,-1, -1,-2, -2,-2},
1268 pa[8*2]={-1,+3, -1,+2, -1,+1, -1,+0, -2,+0, +2,-1, +1,-1, +0,-1},
1269 pb[8*2]={-1,+3, -1,+2, -2,+2, -3,+2, -4,+2, +0,+1, +0,+0, +0,-1},
1270 pc[8*2]={-1,+5, -1,+4, -1,+3, -1,+2, -2,+2, +0,+1, +0,+0, +0,-1},
1271 pd[8*2]={-3,-3, -4,-3, -5,-3, -3,-4, -4,-4, -5,-4, -3,-5, -2,-5};
1272 pp=pn;
1273 if (x==0 && y==nr) { pp=pa; }
1274 if (x==0 && y==nr-2 && (nc%4)) { pp=pb; }
1275 if (x==0 && y==nr-2 && (nc%8)==4) { pp=pc; }
1276 if (x==2 && y==nr+4 && (nc%8)==0) { pp=pd; }
1277 for (j2=0;j2<8;j2++) { // each bit
1278 col= (x + pp[2*j2+0]);
1279 row= (y + pp[2*j2+1]);
1280 if (pp!=pn) { col=(col+nc)%nc; row=(row+nr)%nr; }
1281 if (row<0) { row+=nr; col+=4-((nr+4)%8); }
1282 if (col<0) { col+=nc; row+=4-((nc+4)%8); }
1283 col=(col+nc)%nc; row=(row+nr)%nr;
1284 dm_byte += (dm_bitmap[row*nc+col])<<j2;
1285 // fprintf(stderr," @ %3d %3d",col,row);
1286 }
1287 if ((dm_d>0 && x>=0 && y<nr)
1288 ||(dm_d<0 && y>=0 && x<nc)) {
1289 fprintf(stderr,"\n# @ %3d %3d : %02x %3d d %2d pos %3d decode= ",
1290 x, y, dm_byte, dm_byte, dm_d, cpos);
1291 if (dm_byte>=' '+1 && dm_byte<=128)
1292 { code[cpos++]=(char)(dm_byte-1);
1293 fprintf(stderr,"%c", dm_byte-1); }
1294 else if (dm_byte>=130 && dm_byte<=229) // 130 + 00..99
1295 { code[cpos++]=(char)((dm_byte-130)/10)+'0';
1296 code[cpos++]=(char)((dm_byte-130)%10)+'0';
1297 fprintf(stderr,"%02d", dm_byte-130); }
1298 else {
1299 int nout=0;
1300 if (dm_byte==129) fprintf(stderr,"[Padding]");
1301 if (dm_byte==230) fprintf(stderr,"[C40]"); // 1.5 uppercase/B
1302 if (dm_byte==231) fprintf(stderr,"[Base256]"); // 1 byte/B
1303 if (dm_byte==232) fprintf(stderr,"[FNC1]");
1304 if (dm_byte==235) fprintf(stderr,"[ShiftASC]"); // next -127
1305 if (dm_byte==238) fprintf(stderr,"[AnsiX12]");
1306 if (dm_byte==239) fprintf(stderr,"[Text]"); // 1.5 lowercase/B
1307 if (dm_byte==240) fprintf(stderr,"[EDIFACT]"); // 1.33char/byte
1308 if (dm_byte==254) fprintf(stderr,"[EOTorRET2Text]");
1309 // ToDo: store bytes + interprete it later for output
1310 {
1311 nout = sprintf(code+cpos,"&#%d;",dm_byte);
1312 if (nout>0) cpos+=nout;
1313 }
1314 }
1315 } else j--; // missing reed-solomon chars from skipping!?
1316 if (cpos > 6*4*bx1*by1/8+128 - 10) break; // avoid buffer overflow
1317
1318 x += dm_d * 2;
1319 y -= dm_d * 2;
1320 if (dm_d>0 && (y<0 || x>=nc)) { y++; x+=3; dm_d*=-1; } else
1321 if (dm_d<0 && (x<0 || y>=nr)) { x++; y+=3; dm_d*=-1; }
1322 if (dm_d>0 && x>=nc && y>=nr) break;
1323 }
1324
1325 if (job->cfg.verbose){
1326 fprintf(stderr,"\n# datamatrix at %3d %3d size %3d %3d npix %d*%d unit %d*%d",
1327 box2->x0,box2->y0,bdx,bdy,2*bx1,2*by1,bbx,bby);
1328 }
1329 if (code && cpos<2*4*bx1*by1/8+128-6)
1330 strncpy(code+cpos,"\" />",6); // terminate xml string
1331 code[2*4*bx1*by1/8+127]=0;
1332 if (!code) { /* failed */
1333 code=(char *)malloc(128);
1334 /* ToDo: analyze and output num_bars, width of bars etc. */
1335 if (code) strncpy(code,"<barcode type=\"unknown datamatrix\" />",128);
1336 }
1337 if (job->cfg.verbose)
1338 fprintf(stderr,"\n# ... decoded as: %s", code);
1339 setas(box2,code,99); /* ToDo: set a better weight */
1340 free(code);
1341
1342 /* remove inner boxes, only if sure!? (ToDo: use cfg.certainty) */
1343 for_each_data(&(job->res.boxlist)) {
1344 box3 = (struct box *)list_get_current(&(job->res.boxlist));
1345 /* bdy=box3->y1-box3->y0+1; */
1346 if (box2!=box3)
1347 if (box3->c == PICTURE || box3->c == UNKNOWN)
1348 if ( box3->y0 >= box2->y0 /* within datamatrix ? */
1349 && box3->y1 <= box2->y1
1350 && box3->x1 <= box2->x1
1351 && box3->x0 >= box2->x0
1352 ) {
1353 rm++; /* count removed boxes */
1354 list_del(&(job->res.boxlist),box3);
1355 free_box(box3);
1356 }
1357 } end_for_each(&(job->res.boxlist));
1358 if (job->cfg.verbose)
1359 fprintf(stderr,"\n# ... removed boxes: %d", rm);
1360 rm=0;
1361 free(dm_bitmap);
1362 }
1363 }
1364 } end_for_each(&(job->res.boxlist));
1365
1366 /* ---------------------------------------------------------------
1367 * ToDo: QR-Code (Quick-Response)
1368 * Version 1..40: size= ((17+version*4) modules)^2 = 21,25,...,177 ^2
1369 * Data-Bits = size^2-3*64-2*version-2-formatbits
1370 * Data-Bits for ECC-Level=L: 152 ... 23648 (2953B)
1371 * (21,21): start(lower right corner=20,20)
1372 * - go up (width=2) +(-1,0) +(+1,-1) until upper border ??
1373 * - than go down (width=2) until lower border, etc. ??
1374 * - bits masked (8versions)
1375 * ...
1376 * two weeks of work to find out all the mysteries of QR-Code 2010-10-JS
1377 * (no access to the iso papers, which cost money)
1378 bit0
1379 v
1380 @@@@@@@.fxxxx.@@@@@@@ fff= format-bits (2*14bit)
1381 @.....@.fxxxx.@.....@ xxx= data-bits starting right bottom, going up
1382 @.@@@.@.fxxxx.@.@@@.@ @@.= finder pattern + timing pattern
1383 @.@@@.@.fxxxx.@.@@@.@
1384 @.@@@.@.fxxxx.@.@@@.@
1385 @.....@.fxxxx.@.....@
1386 @@@@@@@.@.@.@.@@@@@@@
1387 ........fxxxx........
1388 ffffff@ffxxxxffffffff<-bit0
1389 xxxxxx.xxxxxxxxxxxxxx
1390 xxxxxx@xxxxxxxxxxxxxx
1391 xxxxxx.xxxxxxxxxxxxxx
1392 xxxxxx@xxxxxxxxxxxxxx
1393 ........@xxxxxxxxxxxx
1394 @@@@@@@.fxxxxxxxxxxxx
1395 @.....@.fxxxxxxxxxxxx
1396 @.@@@.@.fxxxxxxxxxxxx
1397 @.@@@.@.fxxxxxxxxxxxx
1398 @.@@@.@.fxxxxxxxxxxxx
1399 @.....@.fxxxxxxxxxxxx
1400 @@@@@@@.fxxxxxxxxxxxx
1401 ^-bit14
1402 */
1403
1404 { // qrcode 2010-10-13
1405 // taken from qrencode-3.0.3/qrspec.c RS blocks
1406 // ToDo: rawbytes and bits can be computed, but what about ecc0..3 ???
1407 // rawbytes mod (b1+b2) == b2
1408 // ecc mod (b1+b2) == 0
1409 static int qrConst[40][6+8]= {
1410 // raw_bytes+bitrest, ecc_bytes, byte_interleaving
1411 // L M Q H L M Q H
1412 // rawB R ecc0 ecc1 ecc2 ecc3 b1 b2 b1 b2 b1 b2 b1 b2
1413 { 26, 0, 7, 10, 13, 17, 1, 0, 1, 0, 1, 0, 1, 0}, // 1
1414 { 44, 7, 10, 16, 22, 28, 1, 0, 1, 0, 1, 0, 1, 0},
1415 { 70, 7, 15, 26, 36, 44, 1, 0, 1, 0, 2, 0, 2, 0},
1416 { 100, 7, 20, 36, 52, 64, 1, 0, 2, 0, 2, 0, 4, 0},
1417 { 134, 7, 26, 48, 72, 88, 1, 0, 2, 0, 2, 2, 2, 2}, // 5
1418 { 172, 7, 36, 64, 96, 112, 2, 0, 4, 0, 4, 0, 4, 0},
1419 { 196, 0, 40, 72, 108, 130, 2, 0, 4, 0, 2, 4, 4, 1},
1420 { 242, 0, 48, 88, 132, 156, 2, 0, 2, 2, 4, 2, 4, 2},
1421 { 292, 0, 60, 110, 160, 192, 2, 0, 3, 2, 4, 4, 4, 4},
1422 { 346, 0, 72, 130, 192, 224, 2, 2, 4, 1, 6, 2, 6, 2}, //10
1423 { 404, 0, 80, 150, 224, 264, 4, 0, 1, 4, 4, 4, 3, 8},
1424 { 466, 0, 96, 176, 260, 308, 2, 2, 6, 2, 4, 6, 7, 4},
1425 { 532, 0, 104, 198, 288, 352, 4, 0, 8, 1, 8, 4, 12, 4},
1426 { 581, 3, 120, 216, 320, 384, 3, 1, 4, 5, 11, 5, 11, 5},
1427 { 655, 3, 132, 240, 360, 432, 5, 1, 5, 5, 5, 7, 11, 7}, //15
1428 { 733, 3, 144, 280, 408, 480, 5, 1, 7, 3, 15, 2, 3, 13},
1429 { 815, 3, 168, 308, 448, 532, 1, 5, 10, 1, 1, 15, 2, 17},
1430 { 901, 3, 180, 338, 504, 588, 5, 1, 9, 4, 17, 1, 2, 19},
1431 { 991, 3, 196, 364, 546, 650, 3, 4, 3, 11, 17, 4, 9, 16},
1432 { 1085, 3, 224, 416, 600, 700, 3, 5, 3, 13, 15, 5, 15, 10}, //20
1433 { 1156, 4, 224, 442, 644, 750, 4, 4, 17, 0, 17, 6, 19, 6},
1434 { 1258, 4, 252, 476, 690, 816, 2, 7, 17, 0, 7, 16, 34, 0},
1435 { 1364, 4, 270, 504, 750, 900, 4, 5, 4, 14, 11, 14, 16, 14},
1436 { 1474, 4, 300, 560, 810, 960, 6, 4, 6, 14, 11, 16, 30, 2},
1437 { 1588, 4, 312, 588, 870, 1050, 8, 4, 8, 13, 7, 22, 22, 13}, //25
1438 { 1706, 4, 336, 644, 952, 1110, 10, 2, 19, 4, 28, 6, 33, 4},
1439 { 1828, 4, 360, 700, 1020, 1200, 8, 4, 22, 3, 8, 26, 12, 28},
1440 { 1921, 3, 390, 728, 1050, 1260, 3, 10, 3, 23, 4, 31, 11, 31},
1441 { 2051, 3, 420, 784, 1140, 1350, 7, 7, 21, 7, 1, 37, 19, 26},
1442 { 2185, 3, 450, 812, 1200, 1440, 5, 10, 19, 10, 15, 25, 23, 25}, //30
1443 { 2323, 3, 480, 868, 1290, 1530, 13, 3, 2, 29, 42, 1, 23, 28},
1444 { 2465, 3, 510, 924, 1350, 1620, 17, 0, 10, 23, 10, 35, 19, 35},
1445 { 2611, 3, 540, 980, 1440, 1710, 17, 1, 14, 21, 29, 19, 11, 46},
1446 { 2761, 3, 570, 1036, 1530, 1800, 13, 6, 14, 23, 44, 7, 59, 1},
1447 { 2876, 0, 570, 1064, 1590, 1890, 12, 7, 12, 26, 39, 14, 22, 41}, //35
1448 { 3034, 0, 600, 1120, 1680, 1980, 6, 14, 6, 34, 46, 10, 2, 64},
1449 { 3196, 0, 630, 1204, 1770, 2100, 17, 4, 29, 14, 49, 10, 24, 46},
1450 { 3362, 0, 660, 1260, 1860, 2220, 4, 18, 13, 32, 48, 14, 42, 32},
1451 { 3532, 0, 720, 1316, 1950, 2310, 20, 4, 40, 7, 43, 22, 10, 67},
1452 { 3706, 0, 750, 1372, 2040, 2430, 19, 6, 18, 31, 34, 34, 20, 61}}; //40
1453 // rawbytes/blocks = 3706 / (19+6) = 148 Bytes per Block (30 ecc bytes)
1454 // rawbytes/blocks = 3706 / (20+61) = 45 Bytes per Block (30 ecc bytes)
1455 // 4 bits (mode) + 10,9,8,8 | 12,11,16,10 | 14,13,16,12 bits (size_of_len)
1456 // 012 AB byte kanji
1457 static int head_bits09[16]={0,14,13,0,12,0,0,0,12,0,0,0,0,0,0,0};
1458 static int head_bits26[16]={0,16,15,0,20,0,0,0,14,0,0,0,0,0,0,0};
1459 static int head_bits40[16]={0,18,17,0,20,0,0,0,16,0,0,0,0,0,0,0};
1460 static int word_bits[16]= {0,10,11,0, 8,0,0,0,13,0,0,0,0,0,0,0};
1461 static int word_nchr[16]= {0, 3, 2,0, 1,0,0,0, 2,0,0,0,0,0,0,0};
1462 int *head_bits=NULL;
1463 int x02,y02,dx2,dy2, x03,y03,dx3,dy3,
1464 interleave=1, // = qrConst[qr_version-1][6+2*qr_ecclevel+0];
1465 num_marker=0, /* number of detected big marker squares */
1466 qrcode=0; /* 1=detected, -1=detected_but_invalid_code */
1467 int qr_marker[3][4]; // x,y,dx,dy
1468 unsigned char *qrbytes=NULL, *qrtext=NULL; // for real data
1469 char *bits=NULL, *code=NULL;
1470 int fbits=0, // 15 formatbits (put in a 16..32bit word)
1471 bbits, wbits; // 8bits_per_byte, 11bits_per_word
1472 int i, j, num_bars, block_nbits=0, nbits=0, nwbits, ix, iy,
1473 nchars=0, // number chars encoded per block
1474 dchars=0, block_dchars=0, // number of decoded chars
1475 qr_mode=0, qr_mask=0, qr_version=0, qr_ecclevel=0;
1476 int an2, ad1, ad2, // allignment parts, rest distance, main distance
1477 num_rawbits;
1478
1479 if(job->cfg.verbose)
1480 fprintf(stderr,"#\n# barcode.c detect_barcode search qrcode ");
1481 #if 1
1482 for (j=0;j<4;j++) // LMQH: ecc % (b1+b2) == 0
1483 for (i=0;i<40;i++)
1484 if (qrConst[i][2+j]%(qrConst[i][6+2*j+0]+qrConst[i][6+2*j+1])!=0)
1485 fprintf(stderr,"ERROR qrcode L%04d i=%d j=%d\n", __LINE__,i,j);
1486 for (j=0;j<4;j++) // LMQH: rawbytes % (b1+b2) == b2
1487 for (i=0;i<40;i++)
1488 if (qrConst[i][0]%(qrConst[i][6+2*j+0]+qrConst[i][6+2*j+1])
1489 !=qrConst[i][6+2*j+1])
1490 fprintf(stderr,"ERROR qrcode L%04d i=%d j=%d\n", __LINE__,i,j);
1491 #endif
1492 // first searching biggest square objects = marker (min=3)
1493 x0=y0=0; rm=0; dx=job->src.p.x; dy=job->src.p.y; cs=job->cfg.cs;
1494 for_each_data(&(job->res.boxlist)) {
1495 box2 = (struct box *)list_get_current(&(job->res.boxlist));
1496 x02=box2->x0; dx2=box2->x1 - x02 + 1; /* ToDo: correction for skewed matrix */
1497 y02=box2->y0; dy2=box2->y1 - y02 + 1;
1498 /* detect width (bdx) and height (bdy) of possible matrix */
1499 /* ToDo: better check for a line */
1500 if (dx2<7 || dy2<7 || 8*abs(dx2-dy2)>dx2+dy2) continue;
1501 // ToDo: get center point c0, get max distance point from center = i1,
1502 // (in upper left region)
1503 // get max distance point from i1 = i2, get max dist from i0,i2 = i3
1504 // get max distance from i3 = i4 , check square
1505 #if 0
1506 int i1, i2, i3, i4, d;
1507 if (!box2->num_frames) continue;
1508 j=0; ix=x0+dx/2; iy=y0+dy/2;
1509 for (i=0;i<box2->num_frame_vectors[0];i++) {
1510 x=box2->frame_vector[i][0]; /* take a vector */
1511 y=box2->frame_vector[i][1];
1512 /* distance to upper left end, normalized to 128 */
1513 // d=sq((x-rx)*128/dx)+sq((y-ry)*128/dy); // old 2009-07
1514 d=abs(ix-x) + abs(iy-y);
1515 if (d>=j) { j=d; i1=i; }
1516 }
1517 #endif
1518 y= y02+dy2/2;
1519 x= loop(box2->p,x02 ,y,dx2,cs,0,RI); if ( x >dx2/16) continue;
1520 x+=loop(box2->p,x02+x,y,dx2,cs,1,RI); if (abs(x- dx2/7)>dx2/16) continue;
1521 x+=loop(box2->p,x02+x,y,dx2,cs,0,RI); if (abs(x-2*dx2/7)>dx2/16) continue;
1522 x+=loop(box2->p,x02+x,y,dx2,cs,1,RI); if (abs(x-5*dx2/7)>dx2/16) continue;
1523 x+=loop(box2->p,x02+x,y,dx2,cs,0,RI); if (abs(x-6*dx2/7)>dx2/16) continue;
1524 y= y02+dy2/14;
1525 x= loop(box2->p,x02 ,y,dx2,cs,0,RI); if (abs(x-0*dx2/7)>dx2/16) continue;
1526 x+=loop(box2->p,x02+x,y,dx2,cs,1,RI); if (abs(x-7*dx2/7)>dx2/16) continue;
1527 y= y02+13*dy2/14;
1528 x= loop(box2->p,x02 ,y,dx2,cs,0,RI); if (abs(x-0*dx2/7)>dx2/16) continue;
1529 x+=loop(box2->p,x02+x,y,dx2,cs,1,RI); if (abs(x-7*dx2/7)>dx2/16) continue;
1530 y= y02+3*dy2/14;
1531 x= loop(box2->p,x02 ,y,dx2,cs,0,RI); if (abs(x-0*dx2/7)>dx2/16) continue;
1532 x+=loop(box2->p,x02+x,y,dx2,cs,1,RI); if (abs(x-1*dx2/7)>dx2/16) continue;
1533 x+=loop(box2->p,x02+x,y,dx2,cs,0,RI); if (abs(x-6*dx2/7)>dx2/16) continue;
1534 y= y02+11*dy2/14;
1535 x= loop(box2->p,x02 ,y,dx2,cs,0,RI); if (abs(x-0*dx2/7)>dx2/16) continue;
1536 x+=loop(box2->p,x02+x,y,dx2,cs,1,RI); if (abs(x-1*dx2/7)>dx2/16) continue;
1537 x+=loop(box2->p,x02+x,y,dx2,cs,0,RI); if (abs(x-6*dx2/7)>dx2/16) continue;
1538 x= x02+dx2/2;
1539 y= loop(box2->p,x,y02 ,dy2,cs,0,DO); if ( y >dy2/16) continue;
1540 y+=loop(box2->p,x,y02+y,dy2,cs,1,DO); if (abs(y- dy2/7)>dy2/16) continue;
1541 y+=loop(box2->p,x,y02+y,dy2,cs,0,DO); if (abs(y-2*dy2/7)>dy2/16) continue;
1542 y+=loop(box2->p,x,y02+y,dy2,cs,1,DO); if (abs(y-5*dy2/7)>dy2/16) continue;
1543 y+=loop(box2->p,x,y02+y,dy2,cs,0,DO); if (abs(y-6*dy2/7)>dy2/16) continue;
1544 x= x02+dx2/14;
1545 y= loop(box2->p,x,y02 ,dy2,cs,0,DO); if (abs(y-0*dy2/7)>dy2/16) continue;
1546 y+=loop(box2->p,x,y02+y,dy2,cs,1,DO); if (abs(y-7*dy2/7)>dy2/16) continue;
1547 x= x02+13*dx2/14;
1548 y= loop(box2->p,x,y02 ,dy2,cs,0,DO); if (abs(y-0*dy2/7)>dy2/16) continue;
1549 y+=loop(box2->p,x,y02+y,dy2,cs,1,DO); if (abs(y-7*dy2/7)>dy2/16) continue;
1550 x= x02+3*dx2/14;
1551 y= loop(box2->p,x,y02 ,dy2,cs,0,DO); if (abs(y-0*dy2/7)>dy2/16) continue;
1552 y+=loop(box2->p,x,y02+y,dy2,cs,1,DO); if (abs(y-1*dy2/7)>dy2/16) continue;
1553 y+=loop(box2->p,x,y02+y,dy2,cs,0,DO); if (abs(y-6*dy2/7)>dy2/16) continue;
1554 x= x02+11*dx2/14;
1555 y= loop(box2->p,x,y02 ,dy2,cs,0,DO); if (abs(y-0*dy2/7)>dy2/16) continue;
1556 y+=loop(box2->p,x,y02+y,dy2,cs,1,DO); if (abs(y-1*dy2/7)>dy2/16) continue;
1557 y+=loop(box2->p,x,y02+y,dy2,cs,0,DO); if (abs(y-6*dy2/7)>dy2/16) continue;
1558 g_debug(fprintf(stderr,"\n# qrcode marker %d %4d %4d at %4d %4d",num_marker,dx2,dy2,x02,y02);)
1559 if (num_marker<3) {
1560 qr_marker[num_marker][0]=x02;
1561 qr_marker[num_marker][1]=y02;
1562 qr_marker[num_marker][2]=dx2;
1563 qr_marker[num_marker][3]=dy2;
1564 } else qrcode=-1;
1565 num_marker++;
1566 } end_for_each(&(job->res.boxlist));
1567 if (num_marker==3 && qr_marker[0][0]>qr_marker[1][0]) {
1568 // sort upper markers
1569 i=qr_marker[0][0]; qr_marker[0][0]=qr_marker[1][0]; qr_marker[1][0]=i;
1570 i=qr_marker[0][1]; qr_marker[0][1]=qr_marker[1][1]; qr_marker[1][1]=i;
1571 i=qr_marker[0][2]; qr_marker[0][2]=qr_marker[1][2]; qr_marker[1][2]=i;
1572 i=qr_marker[0][3]; qr_marker[0][3]=qr_marker[1][3]; qr_marker[1][3]=i;
1573 }
1574 if (num_marker==3 // check right order (ToDo: sort it)
1575 // a.x0 a.dx b.x0
1576 && qr_marker[0][0]+qr_marker[0][2]<qr_marker[1][0]
1577 // a.y0 a.dy c.y0
1578 && qr_marker[0][1]+qr_marker[0][3]<qr_marker[2][1]) { // qrcode detected
1579 x03=qr_marker[0][0];
1580 y03=qr_marker[0][1];
1581 dx3=qr_marker[1][0]+qr_marker[1][2]-qr_marker[0][0];
1582 dy3=qr_marker[2][1]+qr_marker[2][3]-qr_marker[0][1];
1583 i = num_cross_fine(x03,x03+dx3-1,y03+13*qr_marker[1][3]/14,
1584 y03+13*qr_marker[1][3]/14,box2->p,job->cfg.cs);
1585 i = 2*(i-2)+15; // num_pixel from timing pattern
1586 j = num_cross_fine(x03+13*qr_marker[1][2]/14,
1587 x03+13*qr_marker[1][2]/14,y03,y03+dy3-1,box2->p,job->cfg.cs);
1588 j = 2*(j-2)+15; // num_pixel from timing pattern
1589 x= 14 * dx3 / (qr_marker[0][2]+qr_marker[1][2]);
1590 y= 14 * dy3 / (qr_marker[0][3]+qr_marker[2][3]);
1591 num_bars= i;
1592 if ((i-17)%4!=0 && (j-17)%4==0) num_bars=j; // bad i, but good j ?
1593 qr_version= (num_bars-17) / 4; // size 21..177 to version 1..40
1594 // ToDo: check syncs and mark all boxes within qr_code as picture
1595 // num_cross = distance / base
1596 g_debug(fprintf(stderr,"\n# qrcode at %4d %4d %4d %4d px %d %d = %d %d %d v= %d ",
1597 x03,y03,dx3,dy3,x,y, i,j,num_bars, qr_version);)
1598 x=y=num_bars; // better?
1599 // num alignments/per_direction: 1-1 0, 2-11 1, 12-20++ 2
1600 // num alignments = (na+1)^2-3 , adist= (x-13)/(2*na)
1601 // distance from 6 to first and further alignment patterns (ad1,ad2,ad2,..)
1602 // v1: +8
1603 // v2-6: +12 +16 +20 +24 +28
1604 // v7-13: +16,16 +18,18 +20,20 +22,22 +24,24 +26,26 +28,28
1605 // v14-20: +20,20*2 +20,22*2 +20,24*2 +24,24*2 +24,26*2 +24,28*2 +28,28*2
1606 // v21-27: +22,22*3 +20,24*3 +24,24*3 +22,26*3 +26,26*3 +24,28*3 +28,28*3
1607 // v28-34: +20,24*4 +24,24*4 +20,26*4 +24,26*4 +28,26*4 +24,28*4 +28,28*4
1608 // v35-40: +24,24*5 +18,26*5 +22,26*5 +26,26*5 +20,28*5 +24,28*5
1609 // start: v=2
1610 // ad2 must be set, to avoid endeless loop later!?
1611 ad1=ad2=28; an2=0; // num alignments - 1 (after initial alignment)
1612 for (i=2;i<=qr_version;i++){
1613 if (an2) ad2=(4*i+17-13+an2-an2/4*2)/(an2+1); // main distance
1614 ad2=2*((ad2+1)/2); // round up
1615 ad1=(4*i+17-13)-an2*ad2; // rest distance for the leftmost pattern
1616 if (ad1+an2*ad2 >= 28+an2*28) an2++;
1617 // max distance alignments reached
1618 }
1619 num_rawbits= (4*qr_version+17)*(4*qr_version+17) // square area
1620 - 3 * 8*8 // - 8*8 finder pattern
1621 - ((an2>=0) ? 5*5 * (an2+1)*(an2+1) : 0) // alignment pattern
1622 - 2*((an2>=1) ? 4*5 * (an2 ) : 0) // alignment pattern
1623 - 2*(4*qr_version+17-16) // timing pattern
1624 - ((qr_version<=6)?0:2*3*6) // undocumented extra pattern?
1625 - 2*15 // - 2 * 15 bit format pattern (hor + vert)
1626 - 1; // black bit at (8,maxy-7)
1627 g_debug(fprintf(stderr,"\n# qrcode v= %2d dist= %2d %2d * %d rawbits= %5d bytes= %5d",
1628 qr_version, ad1, ad2, an2, num_rawbits, num_rawbits/8);)
1629 // additional alignment patterns (against skewness)
1630 // v1M= head=2Byte + data=16Byte=128bit + ecc=7B? = 25Byte=206bit?
1631 // v9 53 v9L=1856bits=230byte(8bit)
1632 // v40 177 v40L=2953 bytes (2^12) = 23624+24 Bit
1633 if (x==y && (x-17)%4==0 && x>=21 && x<=177) { // if square and v=1..40
1634 bits= (char *)malloc(x*y);
1635 if (bits) {
1636 for (i=0;i<x*y;i++) {
1637 bits[i]=((getpixel(box2->p,
1638 x03 + ((i%x)*dx3 + dx3/2) / x,
1639 y03 + ((i/x)*dy3 + dy3/2) / y) < job->cfg.cs) ? 1 : 0);
1640 //g_debug(if (i%x==0) fprintf(stderr,"\n# qrcode ");)
1641 //g_debug(fprintf(stderr,"%c",((bits[i])?'@':'.'));)
1642 }
1643 qrcode=1;
1644 // ToDo: check finder pattern
1645 for (i=0;i<x-14;i++) {
1646 if ((bits[6*x+(7+i)]&1)!=(i&1)){
1647 qrcode=-1;
1648 g_debug(fprintf(stderr,"\n# qrcode bad finder bit at %d %d",7+i,6);)
1649 }
1650 if ((bits[6+(7+i)*x]&1)!=(i&1)){
1651 qrcode=-2;
1652 g_debug(fprintf(stderr,"\n# qrcode bad finder bit at %d %d",6,7+i);)
1653 }
1654 bits[6*x+(7+i)]|=2; // mark as finder
1655 bits[6+(7+i)*x]|=2;
1656 }
1657 if ((bits[8+(x-7-1)*x]&1)==0){ qrcode=-3;
1658 g_debug(fprintf(stderr,"\n# qrcode bad bit at %d %d",8,x-7);)
1659 }
1660 bits[8+(x-7-1)*x]|=2;
1661 if (ad1) { // mark alignment pattern
1662 for (i=6;i<y;i+=(i==6 || ad2==0)?ad1:ad2)
1663 for (j=6;j<x;j+=(j==6 || ad2==0)?ad1:ad2)
1664 if ((i<8 && j>6 && j<x-8)
1665 || (j<8 && i>6 && i<y-8)
1666 || (i>6 && j>6)) {
1667 int ti, tj;
1668 for (ti=-2;ti<3;ti++)
1669 for (tj=-2;tj<3;tj++) bits[(i+ti)*x+(j+tj)]|=2;
1670 }
1671 }
1672 for (i=0;i<8*8;i++) { // qr-marker pixel
1673 bits[ (i%8)+x*( i/8)]|=2;
1674 bits[x-8+(i%8)+x*( i/8)]|=2;
1675 bits[ (i%8)+x*(x-8+i/8)]|=2;
1676 }
1677 if (qr_version>6)
1678 for (i=0;i<3*6;i++) { // qr-marker pixel
1679 bits[x-11+(i%3)+x*( i/3)]|=2;
1680 bits[ (i%6)+x*(x-11+i/6)]|=2;
1681 }
1682 // ToDo: check format bits (30 for v<=6, 66 for v>6) ???
1683 // from right to left
1684 g_debug(fprintf(stderr,"\n# qrcode h-format bits 0..14: ");)
1685 for (i=0;i<15;i++) {
1686 fbits|= (bits[8*x+((i<8)?x-i-1:((i<9)?7:5+9-i))]&1)<<i;
1687 g_debug(fprintf(stderr,"%d",(fbits>>i)&1);) // bit0 first
1688 bits[8*x+((i<8)?x-i-1:((i<9)?7:5+9-i))]|=2;
1689 }
1690 // from top to bottom
1691 g_debug(fprintf(stderr,"\n# qrcode v-format bits 0..14: ");)
1692 for (i=0;i<15;i++) {
1693 j= (bits[8+x*((i<6)?i:((i<8)?i+1:i+x-7-8))]&1);
1694 if (((fbits>>i)&1)!=j) qrcode=-4;
1695 g_debug(fprintf(stderr,"%d",j);) // bit0 first
1696 bits[8+x*((i<6)?i:((i<8)?i+1:i+x-7-8))]|=2;
1697 }
1698 g_debug(if(qrcode<0)fprintf(stderr,"\n# qrcode error %d ",qrcode);)
1699 // err mask ecc
1700 fbits ^= 0x5412; // 10 101 0000010010 = 0x5412
1701 g_debug(fprintf(stderr,"\n# qrcode format bits 0..14: ");)
1702 // ToDo: check ECC
1703 for (i=0;i<15;i++) {
1704 g_debug(fprintf(stderr,"%d",(fbits>>i)&1);) // bit0 first
1705 }
1706 // errorlevel: 0..3 = 00=M(15%) 01=L(7%) 10=H(30%) 11=Q(25%) maxlost
1707 // 21x21 = level1 H: 9 bytes + 17 bytes RedSolomon
1708 // mask pattern: 0..7: invers pixel rules
1709 // mask needed to avoid finder and timing pattern in data
1710 qr_mask= 7 & (fbits>>10); // 0..7
1711 { // BCH_15_5 (3*5bit) Reed-Solomon-encode
1712 int data, wk=0;
1713 data= 31 & (fbits>>10);
1714 data <<= 5;
1715 for (i=0; i<5; i++) {
1716 wk <<= 1; data <<= 1;
1717 if ((wk^data) & 0x400) wk ^= 0x137;
1718 } data = (data & 0x7c00) | (wk & 0x3ff);
1719 g_debug(fprintf(stderr,"\n# qrcode ECC check: 0x%04x == 0x%04x",fbits,data);)
1720 // ToDo: if not equal try to encode all 5-bit-BCH-words and compute
1721 // number of different bits, if num_diff_bits<=3 we found it
1722 }
1723 qr_ecclevel= 1 ^ (3 & (fbits>>13));
1724 g_debug(fprintf(stderr,"\n# qrcode errorlevel^1 = %d (2bit)",qr_ecclevel);)
1725 g_debug(fprintf(stderr,"\n# qrcode mask pattern = %d (3bit)",qr_mask);)
1726 g_debug(fprintf(stderr,"\n# qrcode 10bit-ECC = 0x%04x",1023&(fbits>>0));)
1727 #if DO_DEBUG
1728 for (i=0;i<x*y;i++) {
1729 const char xx[5]=".o_@"; // 2018-09 was [4], no gcc but vc warning
1730 g_debug(if (i%x==0) fprintf(stderr,"\n# qrcode ");)
1731 g_debug(fprintf(stderr,"%c",xx[bits[i]&3]);)
1732 }
1733 #endif
1734 // ToDo: check ECC Bose-Chaudhuri-Hocquenghem(BCH)(15,5) 15bit,5data
1735 // G(x)=x^10+x^8+x^5+x^4+x^2+x+1 = 10100110111 = 0x0A37 ???
1736 // F(x)=x^14+x^11+x^10 = 10011.......... = 0x4C00 (data=10011)
1737 // R(x)=x^8+x^7+x^6+x = 0111000010 = 0x01C2 (ecc)
1738 // http://de.wikipedia.org/wiki/BCH-Code
1739 // http://www.swetake.com/qr/qr6_en.html
1740 // first 4+8..10 bit data
1741 // data: 1:3*[0-9]=10bit + 7bit_for_rest2*[0-9] + 3bit_for_rest1*[0..9]
1742 // 2:2*[0-9A-Z $%*+-./:]=11bit + 6bit_rest1 (45*char1+char2)
1743 // 4:8byte, 8:Kanji=13bit
1744 // 4bit-mode={1=numeric,2=alpha,4=byte,8=kanji}
1745 // 8..10bit-len: 8bit for byte+kanjy, 9bit for alpha, 10bit for numeric
1746 // fillbits=0, fillbytes=0xEC,0x11 (see below)
1747 // get data, start at x,y
1748 // ToDo: mark non_data_pixel using 2nd+3th bit?
1749 i=0; // count data bits = valid bits
1750 for (iy=0;iy<x;iy++)
1751 for (ix=0;ix<x;ix++) {
1752 int i2 = iy*x + ix;
1753 if ((bits[i2]&6)==0) // valid pixel?
1754 if ( (qr_mask==0 && (iy+ix)%2==0)
1755 || (qr_mask==1 && (iy )%2==0)
1756 || (qr_mask==2 && ( ix)%3==0)
1757 || (qr_mask==3 && (iy+ix)%3==0) // OK
1758 || (qr_mask==4 && (iy/2+ix/3)%2==0) // OK
1759 || (qr_mask==5 && (iy*ix)%2 + (iy*ix)%3 ==0) // OK
1760 || (qr_mask==6 && ((iy*ix)%2 + (iy*ix)%3) %2 ==0)
1761 || (qr_mask==7 && ((iy*ix)%3 + (iy+ix)%2) %2 ==0) ) bits[i2]^=1;
1762 if ((bits[i2]&6)==0) i++;
1763 }
1764 num_rawbits= i; // overwrite bad computed num_rawbits
1765 g_debug(fprintf(stderr,"\n# qrcode rawbits= %5d bytes= %5d", i, i/8);)
1766 #if DO_DEBUG
1767 g_debug(fprintf(stderr,"\n# qrcode unmasked: ");)
1768 for (i=0;i<x*y;i++) {
1769 const char xx[5]=".x _";
1770 g_debug(if (i%x==0) fprintf(stderr,"\n# qrcode ");)
1771 g_debug(fprintf(stderr,"%c",xx[bits[i]&3]);)
1772 }
1773 #endif
1774 // testing deinterleave 2+2 for v5 = 46 data + 88 ecc, head=12bit nchars=44
1775 // bit-data fitting to mod 8: no way (best fit is 4bit-shift)
1776 // interleave-sequence data 11 11 12 12 (!!) ecc 22 22 22 22 (??)
1777 // qrencode -8 -lH -v5 -oa.png '333333333D3333333333U33333333333f3333333333w'
1778 // # 3=0x33 D=0x44 U=0x55 f=0x66 w=0x77 as byte position marker!
1779 // # nbytes=2+100=5*12+3 interleave=2+2
1780 // testing b1+b2=3+2 data=292raw-110ecc=182 182/(3+2)=36
1781 // interleave sequence: 36 36 36 37 37
1782 // qrencode -8 -lM -v9 -oa.png '(34*3)D(34*3)4U(34*3)3f(34*3)33w(34*3)3"'
1783 // (34*3)=3333333333333333333333333333333333
1784 qrbytes=(unsigned char *)malloc(x*x/8); // enough space for data bits + ecc
1785 nbits=0; // num valid data bits 0..x*x-- of all data blocks
1786 bbits=0; // 8 bits
1787 int num_data_bytes, num_ecc_bytes; // data bytes include header bits
1788 interleave= qrConst[qr_version-1][6+2*qr_ecclevel+0] // 1-40 0123=LMQH
1789 + qrConst[qr_version-1][6+2*qr_ecclevel+1];
1790 // raw_bytes, raw_bits_mod, ecc0 .. ecc3
1791 num_ecc_bytes= qrConst[qr_version-1][2+qr_ecclevel];
1792 num_data_bytes= qrConst[qr_version-1][0]-num_ecc_bytes;
1793 g_debug(fprintf(stderr,"\n# qrcode v%d numbytes= %4d == %4d = %4d data + %4d ecc",
1794 qr_version, num_rawbits/8, num_data_bytes+num_ecc_bytes,
1795 num_data_bytes, num_ecc_bytes);)
1796 g_debug(fprintf(stderr,"\n# qrcode v%d interleave= %d = %d + %d\n# ",
1797 qr_version,interleave,qrConst[qr_version-1][6+2*qr_ecclevel+0],
1798 qrConst[qr_version-1][6+2*qr_ecclevel+1]);)
1799 j=-1; // -x means upwards, +x means downwards
1800 iy=ix=x-1; // start pixel
1801 if (qrbytes)
1802 while (ix>=0 && iy>=0) { // de-interleave bytes
1803 int i2 = iy*x+ix, idx; // help pixel index, old+new byte index
1804 int b1, b2;
1805 b1 = qrConst[qr_version-1][6+2*qr_ecclevel+0];
1806 b2 = qrConst[qr_version-1][6+2*qr_ecclevel+1];
1807 if ((bits[i2]&6)==0) { // valid pixel?
1808 // g_debug(fprintf(stderr,"\n %2d %2d %2d %d",i2%x,i2/x,j,bits[i2]);)
1809 g_debug(fprintf(stderr,"%d",bits[i2]);)
1810 bbits = (bbits << 1) | (bits[i2]&1); // byte
1811 nbits++; // all valid data bits
1812 // store all bits in 8bit words
1813 // no warranty that this impirical code works
1814 // ToDo: replace by better readable code, or create
1815 // better 2D-coding standart replacing QR-Code
1816 if ((nbits&7)==0) {
1817 if (nbits/8-1 < num_data_bytes) {
1818 idx= (nbits/8-1)/interleave
1819 +((nbits/8-1)%interleave)*(num_data_bytes/interleave);
1820 if (idx >= b1*(num_data_bytes/interleave)) // interleaveblock
1821 idx= (nbits/8-1-b1)/interleave
1822 +((nbits/8-1-b1)%interleave)*(num_data_bytes/interleave+1)
1823 + b1*(num_data_bytes/interleave);
1824 if (nbits/8-1 >= num_data_bytes-b2)
1825 idx= (nbits/8-1)/interleave
1826 +((nbits/8-1)%interleave)*(num_data_bytes/interleave+1)
1827 + b1*(num_data_bytes/interleave);
1828 }
1829 else { // ToDo: ecc de-interleave is not proved
1830 idx= (nbits/8-num_data_bytes-1)/interleave
1831 +((nbits/8-num_data_bytes-1)%interleave)*(num_ecc_bytes/interleave)
1832 +num_data_bytes;
1833 if ((nbits/8-1)/interleave >= num_rawbits/8-b2) // interleaveblock
1834 idx+= num_rawbits/8-b2 + ((nbits/8-1)%interleave);
1835 }
1836 qrbytes[idx]= bbits;
1837 g_debug(fprintf(stderr," %3d %02x ",idx,bbits);)
1838 g_debug(if (nbits/8==num_data_bytes) fprintf(stderr,"\n# end_data\n#");)
1839 g_debug(fprintf(stderr,(((nbits/8)%interleave==0)?"\n# ":" "));)
1840 if (nbits/8==num_data_bytes - b2)
1841 for (i=0;i<b1;i++) {
1842 g_debug(fprintf(stderr,"%17s"," ");)
1843 }
1844 bbits=0;
1845 } // used for head+data+ECC
1846 } // valid bit
1847 // (x,maxy) x=max,..,20,18,16,14,12,10,8,(skip6)5,3,1
1848 // next step (up, down or 2 left)
1849 // g_debug(fprintf(stderr,"\n# qr1 xy= %3d %3d %+2d ", ix, iy, j);)
1850 if (ix%2==((ix<6)?1:0) || ix==6) ix--; // go left
1851 else if (iy+j>=0 && iy+j<x) { iy+=j; ix++; } // go right up/down
1852 else { ix--; j*=-1; } // go 2*left + change direction
1853 // g_debug(fprintf(stderr,"\n# qr2 xy= %3d %3d %+2d ", ix, iy, j);)
1854 } // i=max(x*x-x-1)..0
1855 // RS-check/decoding
1856 // needed to define addition and multiplication and finaly a^i
1857 // now wen need the RS generator polynom g(x) depending from size
1858 // ToDo: ECC check and correction, test=tmp10/qrcode_21c4m4e2.png
1859 // qrencode 3.1.1 Kentaro Fukuchi 2010 0123=LMQH
1860 // -l H -v 10 -o a.png '000000000000000000000000000'
1861 // v1 H m1=17= 3*5+2= 57bit 57..59 bit+18 raw= 9+17ecc
1862 // Q raw=13+13ecc
1863 // L m1=41=3*13+2=137bit 137..139 bit+18 raw=19 +7ecc
1864 // v2 H m1=34=3*11+1=114bit
1865 // L m1=77=3*25+2=257bit
1866 // v3 e2=Q m1= raw=34+36ecc=70(ok)rest7
1867 int b1, b2;
1868 int dl=0, el=0, i_ecc=num_data_bytes, i_data=0; // data and ecc length
1869 unsigned char qr_ecc[256]; // buffer for generated ecc data
1870 b1 = qrConst[qr_version-1][6+2*qr_ecclevel+0];
1871 b2 = qrConst[qr_version-1][6+2*qr_ecclevel+1];
1872 // for b1 and b2 we have different datasize ???
1873 for (i=0; i<b1+b2; i++) { // (interleaved) block nr.
1874 if (i==0 || i==b1) {
1875 dl = num_data_bytes/(b1+b2); // divided in blocks to reduce RS size
1876 if (i==b1) dl++;
1877 el = num_ecc_bytes/(b1+b2);
1878 init_rs(8,0x11D,0,1,el,255-dl-el);
1879 }
1880 // gfpoly = 0x11D is the primitive polynom for QR-Code
1881 // max. data+ecc=255
1882 encode_rs_char(&rs, qrbytes + i_data, qr_ecc);
1883 g_debug(for(j=0;j<el;j++)fprintf(stderr," %02x ",qr_ecc[j]);fprintf(stderr,"\n# ");)
1884 g_debug(for(j=0;j<el;j++)fprintf(stderr," %02x ",qrbytes[i_ecc+j]);fprintf(stderr,"\n# ");)
1885 for (j=0;j<el;j++) if (qr_ecc[j]!=qrbytes[i_ecc+j])
1886 {qrcode=-3;g_debug(fprintf(stderr," ECC-Error ");)break;}
1887 i_data += dl;
1888 i_ecc += el;
1889 }
1890
1891 // get 1..2 bits from bits[i] and bits[i-1]
1892 // 1st bit + 2nd bit stored in i2, i2-1
1893 if (qr_version<=40) head_bits=head_bits40;
1894 if (qr_version<=26) head_bits=head_bits26;
1895 if (qr_version<= 9) head_bits=head_bits09;
1896 block_nbits=0; // num valid data bits per block
1897 nwbits=0; // num bits per local word 0..14
1898 nchars=0; // num chars (nwords*cpw+rest) expected
1899 dchars=0; // num chars decoded
1900 wbits=0; // data bits of local word
1901 int next_wbits=1023; // bits of the next dataword
1902 #if DO_DEBUG
1903 unsigned char *ptext=NULL; // pointer to char tuple of next word
1904 #endif
1905 // get bits and words from deinterleaved byte stream
1906 g_debug(fprintf(stderr,"\n# qrcode bytes: %02x %02x %02x ...\n# qr new_block ",
1907 255&(int)qrbytes[0], 255&(int)qrbytes[1], 255&(int)qrbytes[2]);)
1908 // read all blocks
1909 // qrencode -l H -v 5 -o a.png '0123456789abcdefghijklmnopqrstuvwxyz'
1910 // # 10c1=0123456789=34bit + 26c4=abcdefghijklmnopqrstuvwxyz=26byte
1911 if (!qrtext) qrtext= (unsigned char *)malloc(3*num_rawbits/10+1); // 70%
1912 if (qrtext)
1913 // for (nbits=0; nbits<num_rawbits; nbits++)
1914 for (nbits=0; nbits<num_data_bytes*8; nbits++)
1915 {
1916 // g_debug(fprintf(stderr,"\n %2d %2d %2d %d",i2%x,i2/x,j,bits[i2]);)
1917 g_debug(fprintf(stderr,"%d",1&(qrbytes[nbits/8]>>(7-nbits%8)));)
1918 wbits = (wbits << 1) | (1&(qrbytes[nbits/8]>>(7-nbits%8))); // word
1919 block_nbits++;
1920 nwbits++; // local word
1921
1922 if (qr_mode==0 && block_nbits==4) {
1923 qr_mode= wbits & 15;
1924 wbits=0; nwbits=0; // word bits and valid number of bits
1925 // if (qr_mode==3) qr_mode=1; // auto correction ???
1926 g_debug(fprintf(stderr," mode=%d numbits=%d wordbits=%d wchr=%d\n"
1927 "# qr data ", qr_mode, head_bits[qr_mode]-4,
1928 word_bits[qr_mode],
1929 word_nchr[qr_mode]);)
1930 nchars=0; // flag new block
1931 }
1932 // set extra nchars flag!?
1933 // ToDo: what about bad qr_mode? (not 1,2,4,8)
1934 if (nchars==0 && head_bits[qr_mode]!=0
1935 && head_bits[qr_mode]==block_nbits) {
1936 nchars= wbits; // 8..14 bits
1937 wbits=0; nwbits= 0; // sync to data words
1938 next_wbits= word_bits[qr_mode];
1939 if (nchars==0) { qr_mode=0; block_nbits=0; } // reset, new block?
1940 g_debug(fprintf(stderr," nchars=%d\n# qr data ", nchars);)
1941 }
1942 if (dchars==0) qrtext[0]=0;
1943 if (qr_mode==0 || !nchars) continue; // we dont have chars to read
1944 if (block_dchars>=nchars) continue; // all block chars read
1945 if (nwbits < next_wbits) continue; // not enough bits read
1946 g_debug(ptext = &(qrtext[dchars]);) // for debugging word
1947 // reading chars
1948 if (dchars + word_nchr[qr_mode] >= 3*num_rawbits/10) // safety
1949 { fprintf(stderr,"qrcode.unexpected_overflow\n");break; }
1950 // decode
1951 if (qr_mode==8) { // 13bit??? UTF ??? JIS ?
1952 int c1 = (wbits/192) + wbits % 192;
1953 if (c1+0x8140 <= 0x9FFC) c1+=0x8140;
1954 else c1+=0xC140;
1955 qrtext[dchars ]= c1>>8; // ToDo ??
1956 qrtext[dchars+1]= c1&255; // ToDo
1957 dchars += 2;
1958 block_dchars += 2;
1959 if (nchars-block_dchars==1) next_wbits=8;
1960 }
1961 if (qr_mode==4){ // 8bit
1962 qrtext[dchars]= wbits; // ToDo: what about ""<>&?
1963 dchars += 1;
1964 block_dchars += 1;
1965 }
1966 if (qr_mode==2) { // 45*45=2025=11bit ToDo: error if 2025++
1967 int c1 = (wbits/45)%45, c2 = wbits%45;
1968 char crest[9+1]=" $%*+-./:";
1969 if (next_wbits==11) {
1970 qrtext[dchars ]= c1+'0';
1971 qrtext[dchars+1]= c2+'0';
1972 if (c1> 9) qrtext[dchars ]= c1-10+'A';
1973 if (c2> 9) qrtext[dchars+1]= c2-10+'A';
1974 if (c1>35) qrtext[dchars ]= crest[c1-36];
1975 if (c2>35) qrtext[dchars+1]= crest[c2-36];
1976 dchars += 2;
1977 block_dchars += 2;
1978 if (nchars-block_dchars==1) next_wbits=6;
1979 } else if (next_wbits==6) {
1980 qrtext[dchars ]= c2+'0';
1981 if (c2> 9) qrtext[dchars ]= c2-10+'A';
1982 if (c2>35) qrtext[dchars ]= crest[c2-36];
1983 dchars += 1;
1984 block_dchars += 1;
1985 next_wbits=0;
1986 }
1987 // ToDo: odd numchars?
1988 }
1989 if (qr_mode==1) { // 10*10*10=1000=10bit ToDo: error 1001++
1990 if (next_wbits==10) {
1991 qrtext[dchars ]= '0'+ (wbits)/100;
1992 qrtext[dchars+1]= '0'+((wbits)/10)%10;
1993 qrtext[dchars+2]= '0'+ (wbits)%10;
1994 dchars += 3;
1995 block_dchars += 3;
1996 }
1997 if (next_wbits==7) {
1998 qrtext[dchars ]= '0'+ (wbits)/10;
1999 qrtext[dchars+1]= '0'+ (wbits)%10;
2000 dchars += 2;
2001 block_dchars += 2;
2002 next_wbits=0;
2003 }
2004 if (next_wbits==4) {
2005 qrtext[dchars ]= '0'+ (wbits)%10;
2006 dchars += 1;
2007 block_dchars += 1;
2008 next_wbits=0;
2009 }
2010 if (nchars-block_dchars==1) next_wbits=4;
2011 if (nchars-block_dchars==2) next_wbits=7;
2012 // ToDo: %3!=0 rest nchars?
2013 }
2014 if (dchars<=3*num_rawbits/10) qrtext[dchars]=0; // end of string
2015 #if DO_DEBUG
2016 if ((job->cfg.verbose&1) && block_dchars < nchars+word_nchr[qr_mode])
2017 fprintf(stderr," %4s next_wbits= %2d byte= %3d", ptext, next_wbits, nbits/8);
2018 if ((job->cfg.verbose&1) && block_dchars < nchars)
2019 fprintf(stderr,"\n# qr data ");
2020 #endif
2021 wbits=0; nwbits=0;
2022 if (block_dchars >= nchars) { // reset block
2023 block_dchars=0; nchars=0; qr_mode=0; block_nbits=0;
2024 g_debug(fprintf(stderr,"\n# qr new_block ");)
2025 }
2026 // end reading data word = char tuple
2027 } // i=0..num_rawbits
2028 } else fprintf(stderr,"qrcode.malloc failed\n");
2029 } // if square and v=1..40
2030
2031 g_debug(fprintf(stderr,"\n# qr dchars=%d nbits=%d ", dchars, nbits);)
2032 // Reed-Solomon
2033 // size+errlevel = headbits+databits+fillbits + ecbits + ?
2034 // 21H 9*8 17*8 215 RS: 1block (26,9,8) = (allbytes,databytes,errbytes)
2035 // sample 21H 9data+17ecc=26byte+
2036 // f(x)=byte0*x^25+byte1*x^24+...+byte8*x^17 (9byte data)
2037 // byte0=32=a^5 byte1=7=a^198 ... (table4)
2038 // n=17 g(x)=sum(i=0..n)a^ai*x^i where a^255=1
2039 // ai=136,163,243,39,150,99,24,147,214,206,123,239,43,78,206,139,43,17,0
2040 // a^ai=79,99,125,53,85,134,143,41,249,83,197,22,119,120,83,66,119,152,1
2041 // rest of g(x)/f(x) is r(x)=byte16*x^16+byte15*x^15+...bye1*x+byte0
2042 // 21L 19*8 7*8 ... RS: 1block (26,19,2)
2043 // n=7 g(x)=sum(i=0..n)a^ai*x^i
2044 // ai=21,102,238,149,146,229,87,0
2045 // check? f/g=x+R?
2046 // gpg --export -a 0x26D124F8 | qrencode -oa.png # v31 nc=1723
2047 // gpg --export -a --export-options export-minimal 0x26D124F8
2048 // | qrencode -8 -oa.png # v30 137*137 nc=1723
2049 // 300dpi(12dot/mm) 3dot=0.25mm 4dot=0.33mm 5dot=0.42mm 6dot=0.5mm
2050 // 177x177 = 45x45mm^2
2051 if (qrcode>0) {
2052 code= (char *)malloc(4000);
2053 if (code && qrtext) {
2054 code[0]='_'; code[1]=0;
2055 // if (dchars<512) // ToDo: limited output buffer? or stdout?
2056 sprintf(code,"<barcode type=\"qrcode%d\" chars=\"%d\""
2057 " ecclevel=\"%d\" >\n%s\n</barcode>",
2058 qr_version, dchars, qr_ecclevel, qrtext);
2059 // else printf("<barcode type=\"qrcode%d\" chars=\"%d\""
2060 // " ecclevel=\"%d\" >\n%s\n</barcode>",
2061 // qr_version, dchars, qr_ecclevel, qrtext);
2062 // ToDo: error=...
2063 }
2064 }
2065 if (qrcode<0) {
2066 code= (char *)malloc(128);
2067 if (code) {
2068 strncpy(code,"<barcode type=\"unknown qrcode\" />",128);
2069 }
2070 }
2071 if (qrtext) free(qrtext);
2072 if (qrbytes) free(qrbytes);
2073 box3=NULL;
2074 for_each_data(&(job->res.boxlist)) {
2075 box2 = (struct box *)list_get_current(&(job->res.boxlist));
2076 x02=box2->x0; dx2=box2->x1-x02+1; /* ToDo: correction for skewed matrix */
2077 y02=box2->y0; dy2=box2->y1-y02+1;
2078 if (x02>=x03-qr_marker[0][2]/14
2079 && y02>=y03-qr_marker[0][3]/14
2080 && x02+dx2<=x03+dx3+qr_marker[0][2]/14
2081 && y02+dy2<=y03+dy3+qr_marker[0][3]/14 ) { // object inside QR area
2082 box2->c=PICTURE; /* BARCODE */
2083 box2->x0=x03;
2084 box2->y0=y03;
2085 box2->x1=x03+dx3-1;
2086 box2->y1=y03+dy3-1;
2087 if (!box3) {
2088 box3=box2;
2089 if (code) setas(box3,code,99); /* ToDo: set a better weight */
2090 } else {
2091 // ToDo: list_del except one
2092 rm++; /* count removed boxes */
2093 list_del(&(job->res.boxlist),box2);
2094 free_box(box2);
2095 }
2096 }
2097 } end_for_each(&(job->res.boxlist));
2098 if (code) free(code);
2099 if (job->cfg.verbose)
2100 fprintf(stderr,"\n# ... removed boxes: %d", rm);
2101 rm=0;
2102 } // qrcode detected
2103 } // qrcode
2104
2105 /* recalculate averages without bars */
2106 job->res.numC=job->res.sumX=job->res.sumY=j2=0;
2107 for_each_data(&(job->res.boxlist)) {
2108 j2++;
2109 box3 = (struct box *)list_get_current(&(job->res.boxlist));
2110 if (box3->c==PICTURE) continue;
2111 job->res.numC++; /* count remaining boxes */
2112 job->res.sumX+=box3->x1-box3->x0+1;
2113 job->res.sumY+=box3->y1-box3->y0+1;
2114 } end_for_each(&(job->res.boxlist));
2115 if(job->cfg.verbose)
2116 fprintf(stderr,"\n# ... boxes %d nC %d\n",
2117 j2, job->res.numC);
2118
2119 return 0;
2120 }
2121
2122
