git.sur5r.net Git - iec16022/blob - iec16022ecc200.c

   1 /**
   2  *
   3  * IEC16022 bar code generation
   4  * Adrian Kennard, Andrews & Arnold Ltd
   5  * with help from Cliff Hones on the RS coding
   6  *
   7  * (c) 2004 Adrian Kennard, Andrews & Arnold Ltd
   8  * (c) 2006-2007 Stefan Schmidt <stefan@datenfreihafen.org>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  23  *
  24  */
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <ctype.h>
  29 #include <string.h>
  30 #include <time.h>
  31 #include <popt.h>
  32 #include <malloc.h>
  33 #include "reedsol.h"
  34 #include "iec16022ecc200.h"
  35
  36 static struct ecc200matrix_s {
  37         int H, W;
  38         int FH, FW;
  39         int bytes;
  40         int datablock, rsblock;
  41 } ecc200matrix[] = {
  42         10, 10, 10, 10, 3, 3, 5,        //
  43             12, 12, 12, 12, 5, 5, 7,    //
  44             8, 18, 8, 18, 5, 5, 7,      //
  45             14, 14, 14, 14, 8, 8, 10,   //
  46             8, 32, 8, 16, 10, 10, 11,   //
  47             16, 16, 16, 16, 12, 12, 12, //
  48             12, 26, 12, 26, 16, 16, 14, //
  49             18, 18, 18, 18, 18, 18, 14, //
  50             20, 20, 20, 20, 22, 22, 18, //
  51             12, 36, 12, 18, 22, 22, 18, //
  52             22, 22, 22, 22, 30, 30, 20, //
  53             16, 36, 16, 18, 32, 32, 24, //
  54             24, 24, 24, 24, 36, 36, 24, //
  55             26, 26, 26, 26, 44, 44, 28, //
  56             16, 48, 16, 24, 49, 49, 28, //
  57             32, 32, 16, 16, 62, 62, 36, //
  58             36, 36, 18, 18, 86, 86, 42, //
  59             40, 40, 20, 20, 114, 114, 48,       //
  60             44, 44, 22, 22, 144, 144, 56,       //
  61             48, 48, 24, 24, 174, 174, 68,       //
  62             52, 52, 26, 26, 204, 102, 42,       //
  63             64, 64, 16, 16, 280, 140, 56,       //
  64             72, 72, 18, 18, 368, 92, 36,        //
  65             80, 80, 20, 20, 456, 114, 48,       //
  66             88, 88, 22, 22, 576, 144, 56,       //
  67             96, 96, 24, 24, 696, 174, 68,       //
  68             104, 104, 26, 26, 816, 136, 56,     //
  69             120, 120, 20, 20, 1050, 175, 68,    //
  70             132, 132, 22, 22, 1304, 163, 62,    //
  71             144, 144, 24, 24, 1558, 156, 62,    // 156*4+155*2
  72             0                   // terminate
  73 };
  74
  75  // simple checked response malloc
  76 static void *safemalloc(int n)
  77 {
  78         void *p = malloc(n);
  79         if (!p) {
  80                 fprintf(stderr, "Malloc(%d) failed\n", n);
  81                 exit(1);
  82         }
  83         return p;
  84 }
  85
  86 // Annex M placement alorithm low level
  87 static void ecc200placementbit(int *array, int NR, int NC, int r, int c,
  88                                int p, char b)
  89 {
  90         if (r < 0) {
  91                 r += NR;
  92                 c += 4 - ((NR + 4) % 8);
  93         }
  94         if (c < 0) {
  95                 c += NC;
  96                 r += 4 - ((NC + 4) % 8);
  97         }
  98         array[r * NC + c] = (p << 3) + b;
  99 }
 100
 101 static void ecc200placementblock(int *array, int NR, int NC, int r,
 102                                  int c, int p)
 103 {
 104         ecc200placementbit(array, NR, NC, r - 2, c - 2, p, 7);
 105         ecc200placementbit(array, NR, NC, r - 2, c - 1, p, 6);
 106         ecc200placementbit(array, NR, NC, r - 1, c - 2, p, 5);
 107         ecc200placementbit(array, NR, NC, r - 1, c - 1, p, 4);
 108         ecc200placementbit(array, NR, NC, r - 1, c - 0, p, 3);
 109         ecc200placementbit(array, NR, NC, r - 0, c - 2, p, 2);
 110         ecc200placementbit(array, NR, NC, r - 0, c - 1, p, 1);
 111         ecc200placementbit(array, NR, NC, r - 0, c - 0, p, 0);
 112 }
 113
 114 static void ecc200placementcornerA(int *array, int NR, int NC, int p)
 115 {
 116         ecc200placementbit(array, NR, NC, NR - 1, 0, p, 7);
 117         ecc200placementbit(array, NR, NC, NR - 1, 1, p, 6);
 118         ecc200placementbit(array, NR, NC, NR - 1, 2, p, 5);
 119         ecc200placementbit(array, NR, NC, 0, NC - 2, p, 4);
 120         ecc200placementbit(array, NR, NC, 0, NC - 1, p, 3);
 121         ecc200placementbit(array, NR, NC, 1, NC - 1, p, 2);
 122         ecc200placementbit(array, NR, NC, 2, NC - 1, p, 1);
 123         ecc200placementbit(array, NR, NC, 3, NC - 1, p, 0);
 124 }
 125
 126 static void ecc200placementcornerB(int *array, int NR, int NC, int p)
 127 {
 128         ecc200placementbit(array, NR, NC, NR - 3, 0, p, 7);
 129         ecc200placementbit(array, NR, NC, NR - 2, 0, p, 6);
 130         ecc200placementbit(array, NR, NC, NR - 1, 0, p, 5);
 131         ecc200placementbit(array, NR, NC, 0, NC - 4, p, 4);
 132         ecc200placementbit(array, NR, NC, 0, NC - 3, p, 3);
 133         ecc200placementbit(array, NR, NC, 0, NC - 2, p, 2);
 134         ecc200placementbit(array, NR, NC, 0, NC - 1, p, 1);
 135         ecc200placementbit(array, NR, NC, 1, NC - 1, p, 0);
 136 }
 137
 138 static void ecc200placementcornerC(int *array, int NR, int NC, int p)
 139 {
 140         ecc200placementbit(array, NR, NC, NR - 3, 0, p, 7);
 141         ecc200placementbit(array, NR, NC, NR - 2, 0, p, 6);
 142         ecc200placementbit(array, NR, NC, NR - 1, 0, p, 5);
 143         ecc200placementbit(array, NR, NC, 0, NC - 2, p, 4);
 144         ecc200placementbit(array, NR, NC, 0, NC - 1, p, 3);
 145         ecc200placementbit(array, NR, NC, 1, NC - 1, p, 2);
 146         ecc200placementbit(array, NR, NC, 2, NC - 1, p, 1);
 147         ecc200placementbit(array, NR, NC, 3, NC - 1, p, 0);
 148 }
 149
 150 static void ecc200placementcornerD(int *array, int NR, int NC, int p)
 151 {
 152         ecc200placementbit(array, NR, NC, NR - 1, 0, p, 7);
 153         ecc200placementbit(array, NR, NC, NR - 1, NC - 1, p, 6);
 154         ecc200placementbit(array, NR, NC, 0, NC - 3, p, 5);
 155         ecc200placementbit(array, NR, NC, 0, NC - 2, p, 4);
 156         ecc200placementbit(array, NR, NC, 0, NC - 1, p, 3);
 157         ecc200placementbit(array, NR, NC, 1, NC - 3, p, 2);
 158         ecc200placementbit(array, NR, NC, 1, NC - 2, p, 1);
 159         ecc200placementbit(array, NR, NC, 1, NC - 1, p, 0);
 160 }
 161
 162 // Annex M placement alorithm main function
 163 static void ecc200placement(int *array, int NR, int NC)
 164 {
 165         int r, c, p;
 166         // invalidate
 167         for (r = 0; r < NR; r++)
 168                 for (c = 0; c < NC; c++)
 169                         array[r * NC + c] = 0;
 170         // start
 171         p = 1;
 172         r = 4;
 173         c = 0;
 174         do {
 175                 // check corner
 176                 if (r == NR && !c)
 177                         ecc200placementcornerA(array, NR, NC, p++);
 178                 if (r == NR - 2 && !c && NC % 4)
 179                         ecc200placementcornerB(array, NR, NC, p++);
 180                 if (r == NR - 2 && !c && (NC % 8) == 4)
 181                         ecc200placementcornerC(array, NR, NC, p++);
 182                 if (r == NR + 4 && c == 2 && !(NC % 8))
 183                         ecc200placementcornerD(array, NR, NC, p++);
 184                 // up/right
 185                 do {
 186                         if (r < NR && c >= 0 && !array[r * NC + c])
 187                                 ecc200placementblock(array, NR, NC, r, c, p++);
 188                         r -= 2;
 189                         c += 2;
 190                 }
 191                 while (r >= 0 && c < NC);
 192                 r++;
 193                 c += 3;
 194                 // down/left
 195                 do {
 196                         if (r >= 0 && c < NC && !array[r * NC + c])
 197                                 ecc200placementblock(array, NR, NC, r, c, p++);
 198                         r += 2;
 199                         c -= 2;
 200                 }
 201                 while (r < NR && c >= 0);
 202                 r += 3;
 203                 c++;
 204         }
 205         while (r < NR || c < NC);
 206         // unfilled corner
 207         if (!array[NR * NC - 1])
 208                 array[NR * NC - 1] = array[NR * NC - NC - 2] = 1;
 209 }
 210
 211 // calculate and append ecc code, and if necessary interleave
 212 static void ecc200(unsigned char *binary, int bytes, int datablock, int rsblock)
 213 {
 214         int blocks = (bytes + 2) / datablock, b;
 215         rs_init_gf(0x12d);
 216         rs_init_code(rsblock, 1);
 217         for (b = 0; b < blocks; b++) {
 218                 unsigned char buf[256], ecc[256];
 219                 int n, p = 0;
 220                 for (n = b; n < bytes; n += blocks)
 221                         buf[p++] = binary[n];
 222                 rs_encode(p, buf, ecc);
 223                 p = rsblock - 1;        // comes back reversed
 224                 for (n = b; n < rsblock * blocks; n += blocks)
 225                         binary[bytes + n] = ecc[p--];
 226         }
 227 }
 228
 229 /*
 230  * perform encoding for ecc200, source s len sl, to target t len tl, using
 231  * optional encoding control string e return 1 if OK, 0 if failed. Does all
 232  * necessary padding to tl
 233  */
 234
 235 char ecc200encode(unsigned char *t, int tl, unsigned char *s, int sl,
 236                   char *encoding, int *lenp)
 237 {
 238         char enc = 'a';         // start in ASCII encoding mode
 239         int tp = 0, sp = 0;
 240         if (strlen(encoding) < sl) {
 241                 fprintf(stderr, "Encoding string too short\n");
 242                 return 0;
 243         }
 244         // do the encoding
 245         while (sp < sl && tp < tl) {
 246                 char newenc = enc;      // suggest new encoding
 247                 if (tl - tp <= 1 && (enc == 'c' || enc == 't') || tl - tp <= 2
 248                     && enc == 'x')
 249                         enc = 'a';      // auto revert to ASCII
 250                 newenc = tolower(encoding[sp]);
 251                 switch (newenc) {       // encode character
 252                 case 'c':       // C40
 253                 case 't':       // Text
 254                 case 'x':       // X12
 255                         {
 256                                 char out[6], p = 0;
 257                                 const char *e,
 258                                     *s2 = "!\"#$%&'()*+,-./:;<=>?@[\\]^_",
 259                                     *s3 = 0;
 260                                 if (newenc == 'c') {
 261                                         e = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 262                                         s3 = "`abcdefghijklmnopqrstuvwxyz{|}~\177";
 263                                 }
 264                                 if (newenc == 't') {
 265                                         e = " 0123456789abcdefghijklmnopqrstuvwxyz";
 266                                         s3 = "`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~\177";
 267                                 }
 268                                 if (newenc == 'x')
 269                                         e = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ\r*>";
 270                                 do {
 271                                         unsigned char c = s[sp++];
 272                                         char *w;
 273                                         if (c & 0x80) {
 274                                                 if (newenc == 'x') {
 275                                                         fprintf(stderr,
 276                                                                 "Cannot encode char 0x%02X in X12\n",
 277                                                                 c);
 278                                                         return 0;
 279                                                 }
 280                                                 c &= 0x7f;
 281                                                 out[p++] = 1;
 282                                                 out[p++] = 30;
 283                                         }
 284                                         w = strchr(e, c);
 285                                         if (w)
 286                                                 out[p++] = ((w - e) + 3) % 40;
 287                                         else {
 288                                                 if (newenc == 'x') {
 289                                                         fprintf(stderr,
 290                                                                 "Cannot encode char 0x%02X in X12\n",
 291                                                                 c);
 292                                                         return 0;
 293                                                 }
 294                                                 if (c < 32) {   // shift 1
 295                                                         out[p++] = 0;
 296                                                         out[p++] = c;
 297                                                 } else {
 298                                                         w = strchr(s2, c);
 299                                                         if (w) {        // shift 2
 300                                                                 out[p++] = 1;
 301                                                                 out[p++] =
 302                                                                     (w - s2);
 303                                                         } else {
 304                                                                 w = strchr(s3,
 305                                                                            c);
 306                                                                 if (w) {
 307                                                                         out[p++]
 308                                                                             = 2;
 309                                                                         out[p++]
 310                                                                             =
 311                                                                             (w -
 312                                                                              s3);
 313                                                                 } else {
 314                                                                         fprintf
 315                                                                             (stderr,
 316                                                                              "Could not encode 0x%02X, should \
 317                                                                         not happen\n", c);
 318                                                                         return
 319                                                                             0;
 320                                                                 }
 321                                                         }
 322                                                 }
 323                                         }
 324                                         while (p >= 3 || (p && sp == sl)) {
 325                                                 int v;
 326                                                 while (p < 3) out[p++] = 0; // pad at end
 327                                                 if (tp + 2 >= tl) return 0; // not enough space
 328                                                 v = out[0] * 1600 +
 329                                                     out[1] * 40 + out[2] + 1;
 330                                                 if (enc != newenc) {
 331                                                         if (enc == 'c'
 332                                                             || enc == 't'
 333                                                             || enc == 'x')
 334                                                                 t[tp++] = 254;  // escape C40/text/X12
 335                                                         else if (enc == 'x')
 336                                                                 t[tp++] = 0x7C; // escape EDIFACT
 337                                                         if (newenc == 'c')
 338                                                                 t[tp++] = 230;
 339                                                         if (newenc == 't')
 340                                                                 t[tp++] = 239;
 341                                                         if (newenc == 'x')
 342                                                                 t[tp++] = 238;
 343                                                         enc = newenc;
 344                                                 }
 345                                                 t[tp++] = (v >> 8);
 346                                                 t[tp++] = (v & 0xFF);
 347                                                 p -= 3;
 348                                                 out[0] = out[3];
 349                                                 out[1] = out[4];
 350                                                 out[2] = out[5];
 351                                         }
 352                                 }
 353                                 while (p && sp < sl);
 354                         }
 355                         break;
 356                 case 'e':       // EDIFACT
 357                         {
 358                                 unsigned char out[4], p = 0;
 359                                 if (enc != 'a' && enc != newenc) {      // can only be from C40/Text/X12
 360                                         t[tp++] = 254;
 361                                         enc = 'a';
 362                                 }
 363                                 if (enc == 'a')
 364                                 {
 365                                         t[tp++] = 240;
 366                                         enc = 'e';
 367                                 }
 368                                 while (sp < sl && tolower(encoding[sp]) == 'e'
 369                                        && p < 4) {
 370                                         if (s[sp] < 32 || s[sp] > 94) {
 371                                                 fprintf(stderr, "Cannot encode 0x%02X in EDIFACT\n", s[sp]);
 372                                                 return 0;
 373                                         }
 374                                         out[p++] = s[sp++];
 375                                 }
 376                                 if (p < 4) {
 377                                         out[p++] = 0x1F;
 378                                         enc = 'a';
 379                                 }       // termination
 380                                 t[tp] = ((out[0] & 0x3F) << 2);
 381                                 t[tp++] |= ((out[1] & 0x30) >> 4);
 382                                 t[tp] = ((out[1] & 0x0F) << 4);
 383                                 if (p == 2)
 384                                         tp++;
 385                                 else {
 386                                         t[tp++] |= ((out[2] & 0x3C) >> 2);
 387                                         t[tp] = ((out[2] & 0x03) << 6);
 388                                         t[tp++] |= (out[3] & 0x3F);
 389                                 }
 390                         }
 391                         break;
 392                 case 'a':       // ASCII
 393                         if (enc != newenc) {
 394                                 if (enc == 'c' || enc == 't' || enc == 'x')
 395                                         t[tp++] = 254;  // escape C40/text/X12
 396                                 else
 397                                         t[tp++] = 0x7C; // escape EDIFACT
 398                         }
 399                         enc = 'a';
 400                         if (sl - sp >= 2 && isdigit(s[sp])
 401                             && isdigit(s[sp + 1])) {
 402                                 t[tp++] =
 403                                     (s[sp] - '0') * 10 + s[sp + 1] - '0' + 130;
 404                                 sp += 2;
 405                         } else if (s[sp] > 127) {
 406                                 t[tp++] = 235;
 407                                 t[tp++] = s[sp++] - 127;
 408                         } else
 409                                 t[tp++] = s[sp++] + 1;
 410                         break;
 411                 case 'b':       // Binary
 412                         {
 413                                 int l = 0;      // how much to encode
 414                                 if (encoding) {
 415                                         int p;
 416                                         for (p = sp;
 417                                              p < sl
 418                                              && tolower(encoding[p]) == 'b';
 419                                              p++)
 420                                                 l++;
 421                                 }
 422                                 t[tp++] = 231;  // base256
 423                                 if (l < 250)
 424                                         t[tp++] = l;
 425                                 else {
 426                                         t[tp++] = 249 + (l / 250);
 427                                         t[tp++] = (l % 250);
 428                                 }
 429                                 while (l-- && tp < tl) {
 430                                         t[tp] = s[sp++] + (((tp + 1) * 149) % 255) + 1; // see annex H
 431                                         tp++;
 432                                 }
 433                                 if (l) return 0; // not enough space
 434                                 enc = 'a';      // reverse to ASCII at end
 435                         }
 436                         break;
 437                 default:
 438                         fprintf(stderr, "Unknown encoding %c\n", newenc);
 439                         return 0;       // failed
 440                 }
 441         }
 442         if (lenp)
 443                 *lenp = tp;
 444         if (tp < tl && enc != 'a') {
 445                 if (enc == 'c' || enc == 'x' || enc == 't')
 446                         t[tp++] = 254;  // escape X12/C40/Text
 447                 else
 448                         t[tp++] = 0x7C; // escape EDIFACT
 449         }
 450         if (tp < tl)
 451                 t[tp++] = 129;  // pad
 452         while (tp < tl) {       // more padding
 453                 int v = 129 + (((tp + 1) * 149) % 253) + 1;     // see Annex H
 454                 if (v > 254)
 455                         v -= 254;
 456                 t[tp++] = v;
 457         }
 458         if (tp > tl || sp < sl)
 459                 return 0;       // did not fit
 460         /*
 461          * for (tp = 0; tp < tl; tp++) fprintf (stderr, "%02X ", t[tp]); \
 462          * fprintf (stderr, "\n");
 463          */
 464         return 1;               // OK
 465 }
 466
 467 // Auto encoding format functions
 468 static char encchr[] = "ACTXEB";
 469
 470 enum {
 471         E_ASCII,
 472         E_C40,
 473         E_TEXT,
 474         E_X12,
 475         E_EDIFACT,
 476         E_BINARY,
 477         E_MAX
 478 };
 479
 480 unsigned char switchcost[E_MAX][E_MAX] = {
 481         0, 1, 1, 1, 1, 2,       // From E_ASCII
 482         1, 0, 2, 2, 2, 3,       // From E_C40
 483         1, 2, 0, 2, 2, 3,       // From E_TEXT
 484         1, 2, 2, 0, 2, 3,       // From E_X12
 485         1, 2, 2, 2, 0, 3,       // From E_EDIFACT
 486         0, 1, 1, 1, 1, 0,       // From E_BINARY
 487 };
 488
 489 /*
 490  * Creates a encoding list (malloc)
 491  * returns encoding string
 492  * if lenp not null, target len stored
 493  * if error, null returned
 494  * if exact specified, then assumes shortcuts applicable for exact fit
 495  * in target
 496  * 1. No unlatch to return to ASCII for last encoded byte after C40 or
 497  * Text or X12
 498  * 2. No unlatch to return to ASCII for last 1 or 2 encoded bytes after
 499  * EDIFACT
 500  * 3. Final C40 or text encoding exactly in last 2 bytes can have a shift
 501  * 0 to pad to make a tripple
 502  * Only use the encoding from an exact request if the len matches the target,
 503  * otherwise free the result and try again with exact=0
 504  */
 505
 506 static char *encmake(int l, unsigned char *s, int *lenp, char exact)
 507 {
 508         char *encoding = 0;
 509         int p = l;
 510         char e;
 511         struct {
 512                 // number of bytes of source that can be encoded in a row at this point
 513                 // using this encoding mode
 514                 short s;
 515                 // number of bytes of target generated encoding from this point to end if
 516                 // already in this encoding mode
 517                 short t;
 518         } enc[MAXBARCODE][E_MAX];
 519         memset(&enc, 0, sizeof(enc));
 520         if (!l)
 521                 return "";      // no length
 522         if (l > MAXBARCODE)
 523                 return 0;       // not valid
 524         while (p--) {
 525                 char b = 0, sub;
 526                 int sl, tl, bl, t;
 527                 // consider each encoding from this point
 528                 // ASCII
 529                 sl = tl = 1;
 530                 if (isdigit(s[p]) && p + 1 < l && isdigit(s[p + 1]))
 531                         sl = 2; // double digit
 532                 else if (s[p] & 0x80)
 533                         tl = 2; // high shifted
 534                 bl = 0;
 535                 if (p + sl < l)
 536                         for (e = 0; e < E_MAX; e++)
 537                                 if (enc[p + sl][e].t && ((t = enc[p + sl][e].t +
 538                                                           switchcost[E_ASCII]
 539                                                           [e]) < bl || !bl)) {
 540                                         bl = t;
 541                                         b = e;
 542                                 }
 543                 enc[p][E_ASCII].t = tl + bl;
 544                 enc[p][E_ASCII].s = sl;
 545                 if (bl && b == E_ASCII)
 546                         enc[p][b].s += enc[p + sl][b].s;
 547                 // C40
 548                 sub = tl = sl = 0;
 549                 do {
 550                         unsigned char c = s[p + sl++];
 551                         if (c & 0x80) { // shift + upper
 552                                 sub += 2;
 553                                 c &= 0x7F;
 554                         }
 555                         if (c != ' ' && !isdigit(c) && !isupper(c))
 556                                 sub++;  // shift
 557                         sub++;
 558                         while (sub >= 3) {
 559                                 sub -= 3;
 560                                 tl += 2;
 561                         }
 562                 } while (sub && p + sl < l);
 563                 if (exact && sub == 2 && p + sl == l) {
 564                         // special case, can encode last block with shift 0 at end (Is this
 565                         // valid when not end of target buffer?)
 566                         sub = 0;
 567                         tl += 2;
 568                 }
 569                 if (!sub) {     // can encode C40
 570                         bl = 0;
 571                         if (p + sl < l)
 572                                 for (e = 0; e < E_MAX; e++)
 573                                         if (enc[p + sl][e].t
 574                                             &&
 575                                             ((t =
 576                                               enc[p + sl][e].t +
 577                                               switchcost[E_C40][e]) < bl
 578                                              || !bl)) {
 579                                                 bl = t;
 580                                                 b = e;
 581                                         }
 582                         if (exact && enc[p + sl][E_ASCII].t == 1 && 1 < bl) {
 583                                 // special case, switch to ASCII for last bytes
 584                                 bl = 1;
 585                                 b = E_ASCII;
 586                         }
 587                         enc[p][E_C40].t = tl + bl;
 588                         enc[p][E_C40].s = sl;
 589                         if (bl && b == E_C40)
 590                                 enc[p][b].s += enc[p + sl][b].s;
 591                 }
 592                 // Text
 593                 sub = tl = sl = 0;
 594                 do {
 595                         unsigned char c = s[p + sl++];
 596                         if (c & 0x80) { // shift + upper
 597                                 sub += 2;
 598                                 c &= 0x7F;
 599                         }
 600                         if (c != ' ' && !isdigit(c) && !islower(c))
 601                                 sub++;  // shift
 602                         sub++;
 603                         while (sub >= 3) {
 604                                 sub -= 3;
 605                                 tl += 2;
 606                         }
 607                 } while (sub && p + sl < l);
 608                 if (exact && sub == 2 && p + sl == l) {
 609                         // special case, can encode last block with shift 0 at end (Is this
 610                         // valid when not end of target buffer?)
 611                         sub = 0;
 612                         tl += 2;
 613                 }
 614                 if (!sub && sl) {       // can encode Text
 615                         bl = 0;
 616                         if (p + sl < l)
 617                                 for (e = 0; e < E_MAX; e++)
 618                                         if (enc[p + sl][e].t
 619                                             &&
 620                                             ((t =
 621                                               enc[p + sl][e].t +
 622                                               switchcost[E_TEXT][e]) < bl
 623                                              || !bl)) {
 624                                                 bl = t;
 625                                                 b = e;
 626                                         }
 627                         if (exact && enc[p + sl][E_ASCII].t == 1 && 1 < bl) {   // special case, switch to ASCII for last bytes
 628                                 bl = 1;
 629                                 b = E_ASCII;
 630                         }
 631                         enc[p][E_TEXT].t = tl + bl;
 632                         enc[p][E_TEXT].s = sl;
 633                         if (bl && b == E_TEXT)
 634                                 enc[p][b].s += enc[p + sl][b].s;
 635                 }
 636                 // X12
 637                 sub = tl = sl = 0;
 638                 do {
 639                         unsigned char c = s[p + sl++];
 640                         if (c != 13 && c != '*' && c != '>' && c != ' '
 641                             && !isdigit(c) && !isupper(c)) {
 642                                 sl = 0;
 643                                 break;
 644                         }
 645                         sub++;
 646                         while (sub >= 3) {
 647                                 sub -= 3;
 648                                 tl += 2;
 649                         }
 650                 } while (sub && p + sl < l);
 651                 if (!sub && sl) {       // can encode X12
 652                         bl = 0;
 653                         if (p + sl < l)
 654                                 for (e = 0; e < E_MAX; e++)
 655                                         if (enc[p + sl][e].t
 656                                             &&
 657                                             ((t =
 658                                               enc[p + sl][e].t +
 659                                               switchcost[E_X12][e]) < bl
 660                                              || !bl)) {
 661                                                 bl = t;
 662                                                 b = e;
 663                                         }
 664                         if (exact && enc[p + sl][E_ASCII].t == 1 && 1 < bl) {
 665                                 // special case, switch to ASCII for last bytes
 666                                 bl = 1;
 667                                 b = E_ASCII;
 668                         }
 669                         enc[p][E_X12].t = tl + bl;
 670                         enc[p][E_X12].s = sl;
 671                         if (bl && b == E_X12)
 672                                 enc[p][b].s += enc[p + sl][b].s;
 673                 }
 674                 // EDIFACT
 675                 sl = bl = 0;
 676                 if (s[p + 0] >= 32 && s[p + 0] <= 94) { // can encode 1
 677                         char bs = 0;
 678                         if (p + 1 == l && (!bl || bl < 2)) {
 679                                 bl = 2;
 680                                 bs = 1;
 681                         } else
 682                                 for (e = 0; e < E_MAX; e++)
 683                                         if (e != E_EDIFACT && enc[p + 1][e].t
 684                                             &&
 685                                             ((t =
 686                                               2 + enc[p + 1][e].t +
 687                                               switchcost[E_ASCII][e])
 688                                              < bl || !bl))      // E_ASCII as allowed for unlatch
 689                                         {
 690                                                 bs = 1;
 691                                                 bl = t;
 692                                                 b = e;
 693                                         }
 694                         if (p + 1 < l && s[p + 1] >= 32 && s[p + 1] <= 94) {    // can encode 2
 695                                 if (p + 2 == l && (!bl || bl < 2)) {
 696                                         bl = 3;
 697                                         bs = 2;
 698                                 } else
 699                                         for (e = 0; e < E_MAX; e++)
 700                                                 if (e != E_EDIFACT
 701                                                     && enc[p + 2][e].t
 702                                                     &&
 703                                                     ((t =
 704                                                       3 + enc[p + 2][e].t +
 705                                                       switchcost[E_ASCII][e])
 706                                                      < bl || !bl))      // E_ASCII as allowed for unlatch
 707                                                 {
 708                                                         bs = 2;
 709                                                         bl = t;
 710                                                         b = e;
 711                                                 }
 712                                 if (p + 2 < l && s[p + 2] >= 32 && s[p + 2] <= 94) {    // can encode 3
 713                                         if (p + 3 == l && (!bl || bl < 3)) {
 714                                                 bl = 3;
 715                                                 bs = 3;
 716                                         } else
 717                                                 for (e = 0; e < E_MAX; e++)
 718                                                         if (e != E_EDIFACT
 719                                                             && enc[p + 3][e].t
 720                                                             &&
 721                                                             ((t =
 722                                                               3 + enc[p +
 723                                                                       3][e].t +
 724                                                               switchcost
 725                                                               [E_ASCII][e])
 726                                                              < bl || !bl))      // E_ASCII as allowed for unlatch
 727                                                         {
 728                                                                 bs = 3;
 729                                                                 bl = t;
 730                                                                 b = e;
 731                                                         }
 732                                         if (p + 4 < l && s[p + 3] >= 32 && s[p + 3] <= 94) {    // can encode 4
 733                                                 if (p + 4 == l
 734                                                     && (!bl || bl < 3)) {
 735                                                         bl = 3;
 736                                                         bs = 4;
 737                                                 } else {
 738                                                         for (e = 0; e < E_MAX;
 739                                                              e++)
 740                                                                 if (enc[p + 4]
 741                                                                     [e].t
 742                                                                     &&
 743                                                                     ((t =
 744                                                                       3 +
 745                                                                       enc[p +
 746                                                                           4][e].
 747                                                                       t +
 748                                                                       switchcost
 749                                                                       [E_EDIFACT]
 750                                                                       [e]) < bl
 751                                                                      || !bl)) {
 752                                                                         bs = 4;
 753                                                                         bl = t;
 754                                                                         b = e;
 755                                                                 }
 756                                                         if (exact
 757                                                             && enc[p +
 758                                                                    4][E_ASCII].t
 759                                                             && enc[p +
 760                                                                    4][E_ASCII].
 761                                                             t <= 2
 762                                                             && (t =
 763                                                                 3 + enc[p +
 764                                                                         4]
 765                                                                 [E_ASCII].t) <
 766                                                             bl) {
 767                                                                 // special case, switch to ASCII for last 1 ot two bytes
 768                                                                 bs = 4;
 769                                                                 bl = t;
 770                                                                 b = E_ASCII;
 771                                                         }
 772                                                 }
 773                                         }
 774                                 }
 775                         }
 776                         enc[p][E_EDIFACT].t = bl;
 777                         enc[p][E_EDIFACT].s = bs;
 778                         if (bl && b == E_EDIFACT)
 779                                 enc[p][b].s += enc[p + bs][b].s;
 780                 }
 781                 // Binary
 782                 bl = 0;
 783                 for (e = 0; e < E_MAX; e++)
 784                         if (enc[p + 1][e].t
 785                             &&
 786                             ((t =
 787                               enc[p + 1][e].t + switchcost[E_BINARY][e] +
 788                               ((e == E_BINARY
 789                                 && enc[p + 1][e].t == 249) ? 1 : 0))
 790                              < bl || !bl)) {
 791                                 bl = t;
 792                                 b = e;
 793                         }
 794                 enc[p][E_BINARY].t = 1 + bl;
 795                 enc[p][E_BINARY].s = 1;
 796                 if (bl && b == E_BINARY)
 797                         enc[p][b].s += enc[p + 1][b].s;
 798                 /*
 799                  * fprintf (stderr, "%d:", p); for (e = 0; e < E_MAX; e++) fprintf \
 800                  * (stderr, " %c*%d/%d", encchr[e], enc[p][e].s, enc[p][e].t); \
 801                  * fprintf (stderr, "\n");
 802                  */
 803         }
 804         encoding = safemalloc(l + 1);
 805         p = 0;
 806         {
 807                 char cur = E_ASCII;     // starts ASCII
 808                 while (p < l) {
 809                         int t, m = 0;
 810                         char b = 0;
 811                         for (e = 0; e < E_MAX; e++)
 812                                 if (enc[p][e].t
 813                                     && ((t = enc[p][e].t + switchcost[cur][e]) <
 814                                         m || t == m && e == cur || !m)) {
 815                                         b = e;
 816                                         m = t;
 817                                 }
 818                         cur = b;
 819                         m = enc[p][b].s;
 820                         if (!p && lenp)
 821                                 *lenp = enc[p][b].t;
 822                         while (p < l && m--)
 823                                 encoding[p++] = encchr[b];
 824                 }
 825         }
 826         encoding[p] = 0;
 827         return encoding;
 828 }
 829
 830 /*
 831  * Main encoding function
 832  * Returns the grid (malloced) containing the matrix. L corner at 0,0.
 833  * Takes suggested size in *Wptr, *Hptr, or 0,0. Fills in actual size.
 834  * Takes barcodelen and barcode to be encoded
 835  * Note, if *encodingptr is null, then fills with auto picked (malloced)
 836  * encoding
 837  * If lenp not null, then the length of encoded data before any final
 838  * unlatch or pad is stored
 839  * If maxp not null, then the max storage of this size code is stored
 840  * If eccp not null, then the number of ecc bytes used in this size is
 841  * stored
 842  * Returns 0 on error (writes to stderr with details).
 843  */
 844
 845 unsigned char *iec16022ecc200(int *Wptr, int *Hptr, char **encodingptr,
 846                               int barcodelen, unsigned char *barcode,
 847                               int *lenp, int *maxp, int *eccp)
 848 {
 849         unsigned char binary[3000];     // encoded raw data and ecc to place in barcode
 850         int W = 0, H = 0;
 851         char *encoding = 0;
 852         unsigned char *grid = 0;
 853         struct ecc200matrix_s *matrix;
 854         memset(binary, 0, sizeof(binary));
 855         if (encodingptr)
 856                 encoding = *encodingptr;
 857         if (Wptr)
 858                 W = *Wptr;
 859         if (Hptr)
 860                 H = *Hptr;
 861
 862         // encoding
 863         if (W) {                // known size
 864                 for (matrix = ecc200matrix; matrix->W && (matrix->W != W ||
 865                                                           matrix->H != H);
 866                      matrix++) ;
 867                 if (!matrix->W) {
 868                         fprintf(stderr, "Invalid size %dx%d\n", W, H);
 869                         return 0;
 870                 }
 871                 if (!encoding) {
 872                         int len;
 873                         char *e = encmake(barcodelen, barcode, &len, 1);
 874                         if (e && len != matrix->bytes) {        // try not an exact fit
 875                                 free(e);
 876                                 e = encmake(barcodelen, barcode, &len, 0);
 877                                 if (len > matrix->bytes) {
 878                                         fprintf(stderr,
 879                                                 "Cannot make barcode fit %dx%d\n",
 880                                                 W, H);
 881                                         return 0;
 882                                 }
 883                         }
 884                         encoding = e;
 885                 }
 886         } else {
 887                 // find a suitable encoding
 888                 if (encoding == NULL)
 889                         encoding = encmake(barcodelen, barcode, NULL, 1);
 890
 891                 if (encoding) { // find one that fits chosen encoding
 892                         for (matrix = ecc200matrix; matrix->W; matrix++)
 893                                 if (ecc200encode
 894                                     (binary, matrix->bytes, barcode, barcodelen,
 895                                      encoding, 0))
 896                                         break;
 897                 } else {
 898                         int len;
 899                         char *e;
 900                         e = encmake(barcodelen, barcode, &len, 1);
 901                         for (matrix = ecc200matrix;
 902                              matrix->W && matrix->bytes != len; matrix++) ;
 903                         if (e && !matrix->W) {  // try for non exact fit
 904                                 free(e);
 905                                 e = encmake(barcodelen, barcode, &len, 0);
 906                                 for (matrix = ecc200matrix;
 907                                      matrix->W && matrix->bytes < len;
 908                                      matrix++) ;
 909                         }
 910                         encoding = e;
 911                 }
 912                 if (!matrix->W) {
 913                         fprintf(stderr,
 914                                 "Cannot find suitable size, barcode too long\n");
 915                         return 0;
 916                 }
 917                 W = matrix->W;
 918                 H = matrix->H;
 919         }
 920         if (!ecc200encode(binary, matrix->bytes, barcode, barcodelen,
 921                           encoding, lenp)) {
 922                 fprintf(stderr, "Barcode too long for %dx%d\n", W, H);
 923                 return 0;
 924         }
 925         // ecc code
 926         ecc200(binary, matrix->bytes, matrix->datablock, matrix->rsblock);
 927         {                       // placement
 928                 int x, y, NC, NR, *places;
 929                 NC = W - 2 * (W / matrix->FW);
 930                 NR = H - 2 * (H / matrix->FH);
 931                 places = safemalloc(NC * NR * sizeof(int));
 932                 ecc200placement(places, NR, NC);
 933                 grid = safemalloc(W * H);
 934                 memset(grid, 0, W * H);
 935                 for (y = 0; y < H; y += matrix->FH) {
 936                         for (x = 0; x < W; x++)
 937                                 grid[y * W + x] = 1;
 938                         for (x = 0; x < W; x += 2)
 939                                 grid[(y + matrix->FH - 1) * W + x] = 1;
 940                 }
 941                 for (x = 0; x < W; x += matrix->FW) {
 942                         for (y = 0; y < H; y++)
 943                                 grid[y * W + x] = 1;
 944                         for (y = 0; y < H; y += 2)
 945                                 grid[y * W + x + matrix->FW - 1] = 1;
 946                 }
 947                 for (y = 0; y < NR; y++) {
 948                         for (x = 0; x < NC; x++) {
 949                                 int v = places[(NR - y - 1) * NC + x];
 950                                 //fprintf (stderr, "%4d", v);
 951                                 if (v == 1 || v > 7
 952                                     && (binary[(v >> 3) - 1] & (1 << (v & 7))))
 953                                         grid[(1 + y +
 954                                               2 * (y / (matrix->FH - 2))) * W +
 955                                              1 + x +
 956                                              2 * (x / (matrix->FW - 2))] = 1;
 957                         }
 958                         //fprintf (stderr, "\n");
 959                 }
 960                 free(places);
 961         }
 962         if (Wptr)
 963                 *Wptr = W;
 964         if (Hptr)
 965                 *Hptr = H;
 966         if (encodingptr)
 967                 *encodingptr = encoding;
 968         if (maxp)
 969                 *maxp = matrix->bytes;
 970         if (eccp)
 971                 *eccp =
 972                     (matrix->bytes + 2) / matrix->datablock * matrix->rsblock;
 973         return grid;
 974 }