1/* 2 efaxlib.c - utility routines for efax 3 Copyright 1995 Ed Casas 4*/ 5 6#include <ctype.h> 7#include <stdio.h> 8#include <string.h> 9 10#include "efaxmsg.h" 11#include "efaxlib.h" 12 13#ifndef SEEK_SET 14#define SEEK_SET 0 15#endif 16 17#define DEFXRES 204.145 /* fax x and y resolution in dpi */ 18#define DEFYRES 195.58 19 20#define DEFWIDTH 1728 /* 215x297 mm image at fax resolution */ 21#define DEFHEIGHT 2287 22 23extern t4tab wtab [ ( 64 + 27 + 13 ) + 1 ] ; /* T.4 coding tables */ 24extern t4tab btab [ ( 64 + 27 + 13 ) + 1 ] ; 25 26short short256 = 256 ; /* for endian-ness detection */ 27 28/* Bit reversal lookup tables (note that the `normalbits' array 29 is the one actually used for the bit reversal. */ 30 31uchar reversebits [ 256 ], normalbits [ 256 ] ; 32 33/* Make sure printf strings have only %d escapes and n or fewer 34 of them. Returns 0 if OK, 1 on error. */ 35 36int ckfmt ( char *p, int n ) 37{ 38 for ( ; *p ; p++ ) { 39 if ( p[0] == '%' ) { 40 if ( p[1] == 'd' ) n-- ; 41 else if ( p[1] == '%' ) p++ ; 42 else n=-1 ; 43 } 44 } 45 46 return n < 0 ; 47} 48 49 50/* Initialize state of variable-length code word encoder. */ 51 52void newENCODER ( ENCODER *e ) 53{ 54 e->x = 0 ; 55 e->shift = -8 ; 56} 57 58 59/* Store a code word `code' of length `bits' (<=24) in buffer pointed to by 60 `buf'. Bits that don't fit in complete bytes are saved between calls. 61 To flush the remaining bits call the function with code=0 and bits=0. 62 Returns pointer to next free element in output buffer. Calling function 63 must ensure at least bits/8 bytes are available in buffer. */ 64 65uchar *putcode ( ENCODER *e, short code, short bits, uchar *buf ) 66{ 67 e->x = ( e->x << bits ) | code ; 68 e->shift += bits ? bits : -e->shift ; 69 70 while ( e->shift >= 0 ) { 71 *buf++ = e->x >> e->shift ; 72 e->shift -= 8 ; 73 } 74 75 return buf ; 76} 77 78 79/* Convert run lengths to 1-D T.4-codes. First run is white. Silently 80 truncates run lengths that are too long. After using this function EOLs 81 may need to be added and/or the putcode() buffer flushed. Returns 82 pointer to next free element in output buffer. */ 83 84uchar *runtocode ( ENCODER *e, short *runs, int nr, uchar *codes ) 85{ 86 uchar col = 0, *maxcodes = codes + MAXCODES ; 87 t4tab *ctab = wtab, *p ; 88 short rlen ; 89 long x ; 90 short shift ; 91 92#define PUTCODE(p) { x = ( x << p->bits ) | p->code ; shift += p->bits ; \ 93 while ( shift >= 0 ) { *codes++ = x >> shift ; shift -= 8 ; } } 94 95 x = e->x ; shift = e->shift ; 96 97 while ( nr-- > 0 ) { 98 rlen = *runs++ ; 99 if ( rlen > 63 ) { /* make-up code */ 100 if ( rlen > MAXRUNLEN ) rlen = MAXRUNLEN ; 101 p = ctab + 63 + ( rlen >> 6 ) ; 102 if ( codes < maxcodes ) PUTCODE(p) ; 103 } 104 p = ctab + ( rlen & 0x3f ) ; /* terminating code */ 105 if ( codes < maxcodes ) PUTCODE(p) ; 106 ctab = ( col ^= 1 ) ? btab : wtab ; 107 } 108 109 e->x = x ; e->shift = shift ; 110 111 return codes ; 112} 113 114 115/* Pad/truncate run-length coded scan line 'runs' of 'nr' runs by 'pad' 116 pixels (truncate if negative). Returns the new number of runs. */ 117 118int xpad ( short *runs, int nr, int pad ) 119{ 120 if ( pad < 0 ) { /* truncate */ 121 while ( pad < 0 ) pad += ( nr <= 0 ? -pad : runs [ --nr ] ) ; 122 runs [ nr++ ] = pad ; 123 } else { /* pad with white */ 124 if ( nr & 1 ) runs [ nr - 1 ] += pad ; 125 else runs [ nr++ ] = pad ; 126 } 127 return nr ; 128} 129 130 131/* Shift a run-length coded scan line right by s pixels (left if negative). 132 If necessary, zero-length runs are created to avoid copying. Returns 133 the pixel width change (+/-). */ 134 135int xshift ( short *runs, int nr, int s ) 136{ 137 int i=0, n=0 ; 138 if ( s < 0 ) { 139 for ( i = 0 ; s < 0 && i < nr ; i++ ) { 140 s += runs [ i ] ; 141 n -= runs [ i ] ; 142 runs [ i ] = 0 ; 143 } 144 i-- ; 145 } 146 if ( i < nr ) { 147 runs [ i ] += s ; 148 n += s ; 149 } 150 return n ; 151} 152 153 154/* Scale nr run lengths in buffer pointed to by p to scale image 155 horizontally. The scaling factor is xs/256. Returns new line width in 156 pixels. */ 157 158int xscale ( short *p, int nr, int xs ) 159{ 160 int inlen=0, outlen=0 ; 161 for ( ; nr-- > 0 ; p++ ) { 162 inlen += *p ; 163 *p = ( ( inlen * xs + 128 ) >> 8 ) - outlen ; 164 outlen += *p ; 165 } 166 return outlen ; 167} 168 169/* Invert a run-length buffer by prepending or removing a 170 zero-length initial run. */ 171 172int xinvert ( short *p, int nr ) 173{ 174 int i ; 175 if ( ! *p ) { 176 for ( i=0 ; i<nr-1 ; i++ ) { /* remove */ 177 p[i] = p[i+1] ; 178 } 179 nr-- ; 180 } else { 181 for ( i=nr ; i>0 ; i-- ) { /* insert */ 182 p[i] = p[i-1] ; 183 } 184 p[0] = 0 ; 185 nr++ ; 186 } 187 return nr ; 188} 189 190 191/* Zero-terminated lists of run lengths for each byte. */ 192 193uchar byteruns [ 1408 + 1 ] = 194 "8071061106205120511105210530413041210411110411204220421104310440" 195 "3140313103121103122031112031111103112103113032303221032111032120" 196 "3320331103410350215021410213110213202121202121110212210212302111" 197 "3021112102111111021111202112202112110211310211402240223102221102" 198 "2220221120221111022121022130233023210231110231202420241102510260" 199 "1160115101141101142011312011311101132101133011213011212101121111" 200 "0112112011222011221101123101124011114011113101111211011112201111" 201 "1120111111110111112101111130111230111221011121110111212011132011" 202 "1311011141011150125012410123110123201221201221110122210122301211" 203 "3012112101211111012111201212201212110121310121401340133101321101" 204 "3220131120131111013121013130143014210141110141201520151101610170" 205 "1701610151101520141201411101421014301313013121013111101311201322" 206 "0132110133101340121401213101212110121220121112012111110121121012" 207 "1130122301222101221110122120123201231101241012501115011141011131" 208 "1011132011121201112111011122101112301111130111112101111111101111" 209 "1120111122011112110111131011114011240112310112211011222011211201" 210 "1211110112121011213011330113210113111011312011420114110115101160" 211 "2602510241102420231202311102321023302213022121022111102211202222" 212 "0222110223102240211402113102112110211220211112021111110211121021" 213 "1130212302122102121110212120213202131102141021503503410331103320" 214 "3212032111032210323031130311210311111031112031220312110313103140" 215 "4404310421104220411204111104121041305305210511105120620611071080" ; 216 217/* Convert byte-aligned bit-mapped n-byte scan line into array of run 218 lengths. Run length array must have *more* than 8*n elements. First 219 run is white. Returns number of runs coded. */ 220 221int bittorun ( uchar *bits, int n, short *runs ) 222{ 223 static uchar init=0, *rltab [ 256 ] ; 224 register uchar *p, c, lastc = 0x00 ; 225 short *runs0 = runs ; 226 227 if ( ! init ) { /* initialize pointer and run tables */ 228 int i = 0 ; 229 for ( rltab[ 0 ] = p = byteruns ; *p ; p++ ) 230 if ( ! ( *p -= '0' ) && i < 255 ) 231 rltab [ ++i ] = p+1 ; 232 init = 1 ; 233 } 234 235 *runs = 0 ; 236 for ( ; n > 0 ; n-- ) { 237 p = rltab [ c = *bits++ ] ; 238 if ( ( lastc & 0x01 ) ? ! ( c & 0x80 ) : ( c & 0x80 ) ) 239 *(++runs) = *p++ ; /* new run */ 240 else 241 *runs += *p++ ; /* continue run */ 242 while ( *p ) 243 *(++runs) = *p++ ; 244 lastc = c ; 245 } 246 247 return runs - runs0 + 1 ; 248} 249 250 251/* Bitwise-OR two run-length coded scan lines. The run length 252 vectors a and b are OR-ed into c. If c is null, the result is 253 placed in a. The new image width is stored in pels if it is 254 not null. Returns the number of runs in the result. */ 255 256int runor ( short *a, int na, short *b, int nb, short *c, int *pels ) 257{ 258 register short la, lb ; 259 int ia, ib, ic, np=0 ; 260 short tmp [ MAXRUNS ] ; 261 262 if ( ! c ) c = tmp ; 263 264 la = a [ ia = 0 ] ; 265 lb = b [ ib = 0 ] ; 266 c [ ic = 0 ] = 0 ; 267 268 while ( 1 ) { 269 if ( la <= lb ) { /* select shorter sub-run */ 270 if ( ( ( ia | ib ) ^ ic ) & 1 ) /* OR of subruns same colour as c? */ 271 c [ ++ic ] = la ; /* no, new output run */ 272 else 273 c [ ic ] += la ; /* yes, add it */ 274 lb -= la ; /* align subruns */ 275 if ( ++ia >= na ) break ; /* done */ 276 la = a [ ia ] ; /* get new subrun */ 277 } else { /* same for line b ... */ 278 if ( ( ( ia | ib ) ^ ic ) & 1 ) 279 c [ ++ic ] = lb ; 280 else 281 c [ ic ] += lb ; 282 la -= lb ; 283 if ( ++ib >= nb ) break ; 284 lb = b [ ib ] ; 285 } 286 } 287 288 if ( ia < na ) 289 while ( 1 ) { 290 if ( ( ia ^ ic ) & 1 ) 291 c [ ++ic ] = la ; 292 else 293 c [ ic ] += la ; 294 if ( ++ia >= na ) break ; 295 la = a [ ia ] ; 296 } 297 else 298 while ( 1 ) { 299 if ( ( ib ^ ic ) & 1 ) 300 c [ ++ic ] = lb ; 301 else 302 c [ ic ] += lb ; 303 if ( ++ib >= nb ) break ; 304 lb = b [ ib ] ; 305 } 306 307 if ( c == tmp ) for ( ia=0 ; ia <= ic ; ia++ ) np += a[ia] = c[ia] ; 308 309 if ( pels ) *pels = np ; 310 311 return ic + 1 ; 312} 313 314 315/* Get a number from a PBM file header while skipping whitespace 316 and comments. Returns the number or 0 on EOF. Reads one more 317 byte than used by the number. */ 318 319int pbmdim ( IFILE *f ) 320{ 321 int c, n=0 ; 322 323 /* scan for first digit and skip comments */ 324 while ( ! isdigit ( c = fgetc ( f->f ) ) && c >= 0 ) 325 if ( c == '#' ) 326 while ( ( c = fgetc ( f->f ) ) != '\n' && c >= 0 ) ; 327 328 /* get the number */ 329 if ( c >= 0 && isdigit( c ) ) { 330 n = c - '0' ; 331 while ( isdigit ( c = fgetc ( f->f ) ) && c >= 0 ) 332 n = n * 10 + c - '0' ; 333 } 334 335 return n ; 336} 337 338 339/* Append nb bits from in[from] to bit-mapped scan line buffer 340 where `from' is a bit (not byte) index. Bits in bytes are 341 ordered from MS to LS bit. Initialize before each scan line by 342 calling with nb=0 and in pointing to output buffer. Flush 343 after each scan line by calling with nb=0 and in=NULL. */ 344 345#define putbits( c, b ) { x = ( x << (b) ) | (c) ; shift += (b) ; \ 346 if ( shift >= 0 ) { *out++ = x >> shift ; shift -= 8 ; } } 347 348void copybits ( uchar *in, int from, short nb ) 349{ 350 uchar *f ; 351 short bits ; 352 static uchar *out ; 353 static short x, shift ; 354 static unsigned char right [ 9 ] = { 355 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff } ; 356 357 if ( ! nb ) { /* reset for new scan line */ 358 if ( in ) out = in ; 359 else putbits ( 0, -shift ) ; /* or flush bit buffer */ 360 x = 0 ; 361 shift = -8 ; 362 } else { 363 f = in + ( from >> 3 ) ; 364 bits = 8 - ( from & 7 ) ; 365 366 if ( nb >= bits ) { 367 putbits ( *f++ & right [ bits ], bits ) ; 368 nb -= bits ; 369 } else { 370 putbits ( ( *f >> ( bits - nb ) ) & right [ bits ], nb ) ; 371 nb = 0 ; 372 } 373 374 while ( nb >= 8 ) { putbits ( *f++, 8 ) ; nb -= 8 ; } 375 376 if ( nb > 0 ) putbits ( *f >> ( 8 - nb ), nb ); 377 } 378} 379 380 381/* Generate scan line 'line' of string 'txt' using font `font' 382 and store the runs in 'runs'. The font is scaled so it 383 appears to have cells of width w and height h. lmargin pixels 384 of white space are added at the left margin. Sets 'pels' to 385 line width if not null. Returns number of runs coded. */ 386 387int texttorun ( uchar *txt, faxfont *font, short line, 388 int w, int h, int lmargin, 389 short *runs, int *ppels ) 390{ 391 uchar *in, out [ MAXLINELEN * MAXFONTW / 8 + 1 ] ; 392 int i, nc = 0, cw, nr, pels ; 393 394 line = ( line * font->h + h/2 ) / h ; 395 396 cw = font->w ; 397 if ( line >= font->h ) line = font->h - 1 ; 398 in = font->buf + 256/8 * cw * line ; 399 400 copybits ( out, 0, 0 ) ; 401 for ( i=0 ; txt[i] && i < MAXLINELEN ; i++ ) { 402 copybits ( in, font->offset [ txt[i] ], cw ) ; 403 nc++ ; 404 while ( ( txt[i] == HT ) && ( nc & 7 ) ) { /* tab */ 405 copybits ( in, font->offset [ ' ' ], cw ) ; 406 nc++ ; 407 } 408 } 409 copybits ( 0, 0, 0 ) ; 410 411 nr = bittorun ( out, ( nc*cw + 7 )/8, runs ) ; 412 413 if ( font->w == w ) 414 pels = nc*cw ; 415 else 416 pels = xscale ( runs, nr, ( w * 256 ) / font->w ) ; 417 418 pels += xshift ( runs, nr, lmargin ) ; 419 420 if ( ppels ) *ppels = pels ; 421 422 return nr ; 423} 424 425 /* Image File Input Functions */ 426 427 428/* Names of file formats */ 429 430char *iformatname [ NIFORMATS ] = IFORMATS ; 431char *oformatname [ NOFORMATS ] = OFORMATS ; 432char *pformatname [ NPFORMATS ] = PFORMATS ; 433 434/* Log the names of files still to be sent using the "msg()" 435 format string s. */ 436 437void logifnames ( IFILE *f, char *s ) 438{ 439 PAGE *p ; 440 char *fn ; 441 442 if ( f && f->page ) 443 for ( p = f->page ; p <= f->lastpage ; p++ ) { 444 fn = p->fname ; 445 if ( fn ) msg ( s, fn ) ; 446 } 447} 448 449 450/* Read run lengths for one scan line from T.4-coded IFILE f into buffer 451 runs. If pointer pels is not null it is used to save pixel count. 452 Returns number of runs stored, EOF on RTC, or -2 on EOF or other 453 error. */ 454 455int readruns ( IFILE *f, short *runs, int *pels ) 456{ 457 int err=0, c=EOF, n ; 458 register int x ; 459 dtab *tab, *t ; 460 short shift ; 461 short *p, *maxp, *q, len=0, npad=0 ; 462 DECODER *d ; 463 uchar reverse=f->page->revbits ; 464 465 maxp = ( p = runs ) + MAXRUNS ; 466 d = &f->d ; 467 468 x = d->x ; shift = d->shift ; tab = d->tab ; /* restore decoder state */ 469 470 do { 471 do { 472 while ( shift < 0 ) { 473 if ( ( c = fgetc ( f->f ) ) == EOF ) { 474 x = ( x << 15 ) | 1 ; shift += 15 ; /* EOL pad at EOF */ 475 npad++ ; 476 } else { 477 if ( reverse ) c = normalbits [ c & 0xff ] ; 478 x = ( x << 8 ) | c ; shift += 8 ; 479 } 480 } 481 t = tab + ( ( x >> shift ) & 0x1ff ) ; 482 tab = t->next ; 483 shift -= t->bits ; 484 } while ( ! t->code ) ; 485 if ( p < maxp ) *p++ = t->code ; 486 } while ( t->code != -1 ) ; 487 488 d->x = x ; d->shift = shift ; d->tab = tab ; /* save state */ 489 490 if ( npad > 1 ) msg ("W EOF before RTC" ) ; 491 492 if ( p >= maxp ) msg ( "W run length buffer overflow" ) ; 493 494 /* combine make-up and terminating codes and remove +1 offset 495 in run lengths */ 496 497 n = p - runs - 1 ; 498 for ( p = q = runs ; n-- > 0 ; ) 499 if ( *p > 64 && n-- > 0 ) { 500 len += *q++ = p[0] + p[1] - 2 ; 501 p+=2 ; 502 } else { 503 len += *q++ = *p++ - 1 ; 504 } 505 n = q - runs ; 506 507 /* check for RTC and errors */ 508 509 if ( len ) 510 d->eolcnt = 0 ; 511 else 512 if ( ++(d->eolcnt) >= RTCEOL ) err = EOF ; 513 514 if ( c == EOF ) { 515 if ( ferror ( f->f ) ) { 516 err = -msg ("ES2error reading fax file:") ; 517 } else { 518 err = -2 ; 519 } 520 } 521 522 if ( pels ) *pels = len ; 523 524 return err ? err : n ; 525} 526 527 528/* Read a PCX compressed bit-map */ 529 530int readpcx ( char *p, int len, IFILE *f ) 531{ 532 int err=0, n, c ; 533 534 while ( !err && len > 0 ) { 535 if ( ( c = fgetc ( f->f ) ) < 0 ) { 536 err = msg ( "ES2 PCX read failed" ) ; 537 } else { 538 if ( ( c & 0xc0 ) == 0xc0 ) { /* a run count */ 539 n = c & 0x3f ; 540 c = fgetc ( f->f ) ; 541 if ( ( c = fgetc ( f->f ) ) < 0 ) { 542 err = msg ( "ES2 PCX read failed" ) ; 543 } else { 544 memset ( p, c, n <= len ? n : len ) ; 545 p += n ; 546 len -= n ; 547 } 548 } else { /* bits 0 to 7 are image data */ 549 *p++ = c ; 550 len-- ; 551 } 552 } 553 } 554 555 if ( len != 0 ) 556 msg ( "W PCX run-length coding error" ) ; 557 558 return err ; 559} 560 561/* Read a scan line from the current page of IFILE f. Stores 562 number of runs in runs and line width in pels if not null. 563 Pages ends at EOF. Text pages also end if a complete text line 564 would not fit or if the line contains a formfeed character. 565 PBM pages also end when all lines in the bitmap have been 566 read. Fax pages also end at RTC. Returns number of runs stored 567 or EOF at end of page. */ 568 569int readline ( IFILE *f, short *runs, int *pels ) 570{ 571 int nr = 0, nb ; 572 uchar bits [ MAXBITS ] ; 573 574 if ( f->lines != 0 ) { /* -1 allowed as well */ 575 576 577 switch ( f->page->format ) { 578 579 case P_TEXT : 580 if ( f->txtlines <= 0 ) { /* need another text line */ 581 if ( fgets ( f->text, MAXLINELEN, f->f ) ) { 582 f->txtlines = f->charh ; 583 if ( strchr ( f->text, FF ) ) { 584 f->lines = 0 ; /* no more lines in this page */ 585 nr = EOF ; /* don't return any */ 586 } 587 } else { 588 nr = EOF ; 589 } 590 } 591 if ( nr != EOF ) { 592 nr = texttorun ( (uchar*) f->text, f->font, f->charh - f->txtlines, 593 f->charw, f->charh, f->lmargin, 594 runs, pels ) ; 595 f->txtlines-- ; 596 } 597 break ; 598 599 case P_RAW: 600 case P_PBM: 601 if ( fread ( bits, 1, f->page->w/8, f->f ) != f->page->w/8 ) { 602 nr = EOF ; 603 } else { 604 nr = bittorun ( bits, f->page->w/8, runs ) ; 605 if ( pels ) *pels = f->page->w ; 606 } 607 break ; 608 609 case P_FAX: 610 nr = readruns ( f, runs, pels ) ; 611 break ; 612 613 case P_PCX: 614 nb = ( ( f->page->w + 15 ) / 16 ) * 2 ; /* round up */ 615 if ( readpcx ( (char*)bits, nb, f ) != 0 ) { 616 nr = EOF ; 617 } else { 618 nr = bittorun ( bits, nb, runs ) ; 619 if ( pels ) *pels = f->page->w ; 620 } 621 break ; 622 623 } 624 } else { 625 nr = EOF ; 626 } 627 628 if ( nr >= 0 && f->page->black_is_zero ) { /* invert */ 629 nr = xinvert ( runs, nr ) ; 630 } 631 632 if ( nr >= 0 && f->lines > 0 ) f->lines-- ; 633 634 635 return nr ; 636} 637 638 639/* Deduce the file type by scanning buffer p of n bytes. */ 640 641int getformat ( uchar *p, int n ) 642{ 643 int format = 0 ; 644 645 /* figure out file type if not already set */ 646 647 if ( ! format && n && n < 2 ) { 648 format = I_TEXT ; 649 msg ( "W only read %d byte(s) from input file, assuming text", n ) ; 650 } 651 652 if ( ! format && n >= 2 && ! p[0] && ! ( p[1] & 0xe0 ) ) { 653 format = I_FAX ; 654 } 655 656 if ( ! format && n >= 2 && ! strncmp ( (char*)p, "P4", 2 ) ) { 657 format = I_PBM ; 658 } 659 660 if ( ! format && n >= 128 && p[0] == 0x0a && 661 strchr ("\02\03\05", p[1] ) && p[2] <= 1 ) { 662 if ( p[65] != 1 ) { 663 msg ( "E can't read colour PCX" ) ; 664 } else { 665 format = p[2] ? I_PCX : I_PCX ; 666 } 667 } 668 669 if ( ! format && n >= 2 && ! strncmp ( (char*)p, "%!", 2 ) ) { 670 msg ( "W Postscript input file will be treated as text" ) ; 671 } 672 673 if ( ! format && n >= 2 && ( p[0] == 'M' || p[1] == 'I' ) && ( p[1] == p[0] ) ) { 674 format = I_TIFF ; 675 } 676 677 if ( ! format && n >= 4 && 678 ( p[0] == 0x3a && p[1] == 0xde && 679 p[2] == 0x68 && p[3] == 0xb1) ) { 680 format = I_DCX ; 681 } 682 683 if ( ! format && n ) { /* "90% printable" heuristic */ 684 int i, nprint = 0 ; 685 for ( i=0 ; i<n ; i++ ) { 686 if ( isspace ( p[i] ) || isprint ( p[i] ) ) { 687 nprint++ ; 688 } 689 } 690 if ( ( nprint / (float) n ) > 0.90 ) { 691 format = I_TEXT ; 692 } 693 } 694 695 return format ; 696} 697 698 699/* initialize page descriptor */ 700 701void page_init ( PAGE *p, char *fn ) 702{ 703 p->fname = fn ; 704 p->offset = 0 ; 705 p->w = DEFWIDTH ; 706 p->h = DEFHEIGHT ; 707 p->xres = DEFXRES ; 708 p->yres = DEFYRES ; 709 p->format = P_FAX ; 710 p->revbits = 0 ; 711 p->black_is_zero = 0 ; 712} 713 714void page_report ( PAGE *p, int fmt, int n ) 715{ 716 msg ( "F page %d : %s + %ld : %dx%d @ %.fx%.f dpi %s/%s", 717 n, 718 p->fname, p->offset, p->w, p->h, 719 p->xres, p->yres, 720 iformatname [fmt], pformatname [p->format] ) ; 721} 722 723/* File handling for undefined file types */ 724 725#define auto_first 0 726#define auto_next 0 727 728/* File handling for TIFF files */ 729 730#define tiff_reset 0 731 732/* Name of TIFF tag 'tag'. */ 733 734char *tagname ( int tag ) 735{ 736 static struct tagnamestruct { int code ; char *name ; } 737 tagnames [] = { 738 { 256, "width" }, 739 { 257, "length" }, 740 { 258, "bits/sample" }, 741 { 259, "compresssion(g3=3)" }, 742 { 262, "photometric(0-min=white)" }, 743 { 266, "fill order(msb2lsb=1)" }, 744 { 273, "strip offsets" }, 745 { 274, "orientation(1=normal)" }, 746 { 277, "samples/pixel" }, 747 { 278, "rows/strip" }, 748 { 279, "strip byte counts" }, 749 { 282, "xresolution" }, 750 { 283, "yresolution" }, 751 { 284, "storage(1=single plane)" }, 752 { 292, "g3options" }, 753 { 296, "resolution units(2=in,3=cm)" }, 754 { 297, "page number" }, 755 { 327, "clean fax(0=clean/1=regen/2=errors)" }, 756 {0,0} }, 757 *p ; 758 759 for ( p=tagnames ; p->code ; p++ ) 760 if ( tag == p->code ) break ; 761 return p->code ? p->name : "unknown tag" ; 762} 763 764/* Read 2- or 4-byte integers from a file and correct for file 765 endianness. Returns 0 if OK, 1 on error. */ 766 767int fread2 ( unsigned short *p, IFILE *f ) 768{ 769 int err=0 ; 770 uchar c[2] ; 771 772 err = fread ( c, 1, 2, f->f ) == 2 ? 0 : 1 ; 773 774 *p = f->bigend ? 775 c[0] << 8 | c[1] << 0 : 776 c[1] << 8 | c[0] << 0 ; 777 778 return err ; 779} 780 781int fread4 ( unsigned long *p, IFILE *f ) 782{ 783 int err=0 ; 784 uchar c[4] ; 785 786 err = fread ( c, 1, 4, f->f ) == 4 ? 0 : 1 ; 787 788 *p = f->bigend ? 789 c[0] << 24 | c[1] << 16 | c[2] << 8 | c[3] << 0 : 790 c[3] << 24 | c[2] << 16 | c[1] << 8 | c[0] << 0 ; 791 792 return err ; 793} 794 795 796/* Read a TIFF directory at current file offset, save image 797 format information and seek to next directory if any. Returns 798 0 if OK, 2 on errors. */ 799 800int tiff_next ( IFILE *f ) 801{ 802 int err=0 ; 803 unsigned short ntag, tag, type ; 804 unsigned long count, tv ; 805 double ftv ; 806 807 msg ( "F+ TIFF directory at %ld", ftell ( f->f ) ) ; 808 809 if ( fread2 ( &ntag, f ) ) { 810 err = msg ( "E2can't read TIFF tag count" ) ; 811 } else { 812 msg ( "F+ with %d tags", (int) ntag ) ; 813 } 814 815 for ( ; ! err && ntag > 0 ; ntag-- ) { 816 817 err = err || fread2 ( &tag, f ) ; 818 err = err || fread2 ( &type, f ) ; 819 err = err || fread4 ( &count, f ) ; 820 821 if ( type == 3 ) { /* left-aligned short */ 822 unsigned short a, b ; 823 err = err || fread2 ( &a, f ) ; 824 err = err || fread2 ( &b, f ) ; 825 tv = a ; 826 } else { /* long or offset to data */ 827 err = err || fread4 ( &tv, f ) ; 828 } 829 830 if ( type == 5 ) { /* float as ratio in directory data */ 831 long a, b, where=0 ; 832 err = err || ( ( where = ftell ( f->f ) ) < 0 ) ; 833 err = err || fseek ( f->f, tv, SEEK_SET ) ; 834 err = err || fread4 ( (unsigned long*)&a, f ) ; 835 err = err || fread4 ( (unsigned long*)&b, f ) ; 836 err = err || fseek ( f->f, where, SEEK_SET ) ; 837 ftv = (float) a / ( b ? b : 1 ) ; 838 } else { 839 ftv = 0.0 ; 840 } 841 842 if ( err ) { 843 err = msg ( "ES2can't read TIFF tag" ) ; 844 continue ; 845 } 846 847#ifdef TIFF_DEBUG 848 { 849 char *tagtype[] = { "none", "byte", "ascii", "short", "long", "ratio" } ; 850 msg ( "F %3d %-5s tag %s %5ld (%3d:%s)", 851 count, 852 type <= 5 ? tagtype[type] : "other", 853 count > 1 ? "@" : "=", 854 type == 5 ? (long) ftv : tv, tag, tagname(tag) ) ; 855 } 856#endif 857 858 switch ( tag ) { 859 case 256 : /* width */ 860 f->page->w = tv ; 861 break ; 862 case 257 : /* height */ 863 f->page->h = tv ; 864 break ; 865 case 259 : /* compression: 1=none, 3=G3 */ 866 if ( tv == 1 ) { 867 f->page->format = P_RAW ; 868 } else if ( tv == 3 ) { 869 f->page->format = P_FAX ; 870 } else { 871 err = msg ( "E2can only read TIFF/G3 or TIFF/uncompressed" ) ; 872 } 873 break ; 874 case 262 : /* photometric interpretation */ 875 f->page->black_is_zero = tv ; 876 break ; 877 case 266 : /* fill order */ 878 f->page->revbits = ( tv == 2 ? 1 : 0 ) ; 879 break ; 880 case 273 : /* data offset */ 881 if ( count != 1 ) 882 err = msg ( "E2can't read multi-strip TIFF files" ) ; 883 else 884 f->page->offset = tv ; 885 break ; 886 case 282 : /* x resolution */ 887 f->page->xres = ftv ; 888 break ; 889 case 283 : /* y resolution */ 890 f->page->yres = ftv ; 891 break ; 892 case 292 : /* T4 options: 1=2D, 2=uncompressed */ 893 if ( tv & 0x1 ) 894 err = msg ( "E2can't read 2D compressed TIFF-F file" ) ; 895 if ( tv & 0x2 ) 896 err = msg ( "E2can't read uncompressed TIFF-F file" ) ; 897 break ; 898 case 296 : /* units: 2=in, 3=cm */ 899 if ( tv == 3 ) { 900 f->page->xres *= 2.54 ; 901 f->page->yres *= 2.54 ; 902 } 903 break ; 904 } 905 906 } /* end of tag reading loop */ 907 908 909 if ( f->page->format == I_AUTO ) { 910 msg ( "W missing TIFF compression format, set to raw" ) ; 911 f->page->format = P_RAW ; 912 } 913 914 if ( ! err ) { 915 916 if ( fread4 ( (unsigned long*)&(f->next), f ) ) { 917 err = msg ( "E2can't read offset to next TIFF directory" ) ; 918 } else { 919 if ( f->next ) { 920 msg ( "F , next directory at %ld.", f->next ) ; 921 if ( fseek ( f->f, f->next, SEEK_SET ) ) 922 err = msg ( "ES2 seek to next TIFF directory failed" ) ; 923 } else { 924 msg ( "F , last image." ) ; 925 } 926 } 927 928 } 929 930 if ( ! f->page->offset ) 931 err = msg ( "E2 missing offset to TIFF data" ) ; 932 933 return err ; 934} 935 936 937int tiff_first ( IFILE *f ) 938{ 939 short magic, version ; 940 941 fread ( (uchar*) &magic, 1, 2, f->f ) ; 942 f->bigend = ( *(uchar*) &magic == 'M' ) ? 1 : 0 ; 943 fread2 ( (unsigned short*)&version, f ) ; 944 fread4 ( (unsigned long*)&(f->next), f ) ; 945 946 msg ( "F TIFF version %d.%d file (%s-endian)", 947 version/10, version%10, f->bigend ? "big" : "little" ) ; 948 949 fseek ( f->f, f->next, SEEK_SET ) ; 950 951 return tiff_next ( f ) ; 952} 953 954 955/* File handling for text files. */ 956 957int text_next ( IFILE *f ) 958{ 959 int err = 0, i, nc ; 960 char buf [ MAXLINELEN ] ; 961 962 f->page->offset = ftell ( f->f ) ; 963 f->page->format = P_TEXT ; 964 965 nc = ( f->page->w - f->lmargin ) / f->charw ; 966 967 if ( nc > MAXLINELEN ) 968 nc = MAXLINELEN ; 969 970 for ( i = 0 ; i < f->pglines && fgets ( buf, nc, f->f ) ; i++ ) ; 971 972 f->next = ! feof(f->f) ? ftell ( f->f ) : 0 ; 973 974 err = ferror(f->f) ? 2 : 0 ; 975 976 return err ; 977} 978 979 980int text_first ( IFILE *f ) 981{ 982 static faxfont defaultfont ; 983 984 if ( ! f->font ) { 985 /* use default font scaled 2X, 1 inch margin, 66 lines/page */ 986 f->font = &defaultfont ; 987 readfont ( 0, f->font ) ; 988 if ( ! f->charw ) f->charw = 2 * f->font->w ; 989 if ( ! f->charh ) f->charh = 2 * f->font->h ; 990 if ( ! f->lmargin ) f->lmargin = 204 ; 991 if ( ! f->pglines ) f->pglines = DEFPGLINES ; 992 } 993 /* if not set, take default values from font */ 994 if ( ! f->charw ) f->charw = f->font->w ; 995 if ( ! f->charh ) f->charh = f->font->h ; 996 if ( ! f->lmargin ) f->lmargin = 0 ; 997 if ( ! f->pglines ) f->pglines = f->page->h / f->charh - 6 ; 998 999 return text_next ( f ) ; 1000} 1001 1002 1003/* File handling for PBM files */ 1004 1005int pbm_first ( IFILE *f ) 1006{ 1007 int err=0 ; 1008 1009 fseek ( f->f, 2, SEEK_SET ) ; 1010 1011 if ( ! ( f->page->w = pbmdim ( f ) ) || ! ( f->page->h = pbmdim ( f ) ) ) { 1012 err = msg ( "E2 EOF or 0 dimension in PBM header" ) ; 1013 } else if ( f->page->w % 8 ) { 1014 err = msg ( "E2 PBM width must be multiple of 8" ) ; 1015 } else { 1016 msg ( "F read %dx%d PBM header", f->page->w, f->page->h ) ; 1017 } 1018 1019 f->page->offset = ftell ( f->f ) ; 1020 f->page->format = P_PBM ; 1021 f->next = 0 ; 1022 1023 return err ; 1024} 1025 1026#define pbm_next 0 1027 1028 1029/* File handling for FAX files */ 1030 1031#define fax_first 0 1032 1033#define fax_next 0 1034 1035/* File handling for PCX files */ 1036 1037/* get a 16-bit word in Intel byte order. */ 1038 1039int fgeti ( IFILE *f ) 1040{ 1041 return fgetc ( f->f ) + fgetc ( f->f ) * 256 ; 1042} 1043 1044int pcx_first ( IFILE *f ) 1045{ 1046 int err=0, xmin, xmax, ymin, ymax, nc, nb ; 1047 long start ; 1048 1049 start = ftell ( f->f ) ; 1050 1051 fseek ( f->f, start+4, SEEK_SET ) ; 1052 xmin = fgeti ( f ) ; 1053 ymin = fgeti ( f ) ; 1054 xmax = fgeti ( f ) ; 1055 ymax = fgeti ( f ) ; 1056 1057 f->page->w = xmax - xmin + 1 ; 1058 f->page->h = ymax - ymin + 1 ; 1059 1060 f->page->xres = fgeti ( f ) ; 1061 f->page->yres = fgeti ( f ) ; 1062 1063 fseek ( f->f, start+0x41, SEEK_SET ) ; 1064 nc = fgetc ( f->f ) ; 1065 nb = fgeti ( f ) ; 1066 1067 if ( nc != 1 ) 1068 msg ( "W mono PCX file has %d colour planes", nc ) ; 1069 1070 if ( nb != ( f->page->w + 15 ) / 16 * 2 ) 1071 msg ( "W PCX file has %d bytes per scan line for %d pels", 1072 nb, f->page->w ) ; 1073 1074 f->page->offset = start + 128 ; 1075 f->page->format = P_PCX ; 1076 1077 return err ; 1078} 1079 1080#define pcx_next 0 1081 1082/* File handling for DCX files */ 1083 1084int dcx_next ( IFILE *f ) 1085{ 1086 int err=0 ; 1087 long thisp, nextp ; 1088 1089 /* get this and next pages' offsets */ 1090 1091 fseek ( f->f, f->next, SEEK_SET ) ; 1092 fread4 ( (unsigned long*)&thisp, f ) ; 1093 fread4 ( (unsigned long*)&nextp, f ) ; 1094 1095 /* save address of next directory entry, if any */ 1096 1097 f->next = nextp ? f->next + 4 : 0 ; 1098 1099 if ( ! thisp ) 1100 err = msg ( "E2 can't happen (dcx_next)" ) ; 1101 else 1102 fseek ( f->f, thisp, SEEK_SET ) ; 1103 1104 return err ? err : pcx_first ( f ) ; 1105} 1106 1107int dcx_first ( IFILE *f ) 1108{ 1109 f->bigend = 0 ; 1110 f->next = 4 ; 1111 return dcx_next ( f ) ; 1112} 1113 1114 1115#define raw_reset 0 1116#define raw_first 0 1117#define raw_next 0 1118 1119 1120/* input file state reset for different compression methods */ 1121 1122#define pcx_reset 0 1123#define pbm_reset 0 1124 1125int text_reset ( IFILE *f ) 1126{ 1127 int err=0 ; 1128 1129 f->lines = ( ( f->pglines * f->charh ) / f->charh ) * f->charh ; 1130 f->txtlines = 0 ; 1131 f->page->yres = f->lines > 1078 ? 196 : 98 ; /* BOGUS */ 1132 1133 return err ; 1134} 1135 1136int fax_reset ( IFILE *f ) 1137{ 1138 int pels ; 1139 short runs [ MAXRUNS ] ; 1140 1141 newDECODER ( &f->d ) ; 1142 if ( readruns ( f, runs, &pels ) < 0 || pels ) /* skip first EOL */ 1143 msg ( "W first line has %d pixels: probably not fax data", pels ) ; 1144 1145 switch ( f->fileformat ) { 1146 1147 /* A TIFF file knows how many lines there are in the data. A proper TIFF-F 1148 * file should not have an RTC. Therefore don't reset the number of lines 1149 * counter since readline will use this rather than the non-existent RTC 1150 * to terminate the page. 1151 */ 1152 case I_TIFF: 1153 break ; 1154 1155 case I_FAX: 1156 default: 1157 f->lines = -1 ; 1158 } 1159 1160 return 0 ; 1161} 1162 1163 1164/* Skip to start of same (dp=0) or next (dp=1) page image. 1165 Returns 0 if OK, 1 if no more pages, 2 on errors. */ 1166 1167int nextipage ( IFILE *f, int dp ) 1168{ 1169 int err=0 ; 1170 1171 int ( *reset [NPFORMATS] ) ( IFILE * ) = { 1172 raw_reset, fax_reset, pbm_reset, text_reset, pcx_reset 1173 }, (*pf)(IFILE*) ; 1174 1175 /* close current file if any and set to NULL */ 1176 1177 if ( f->f ) { 1178 fclose ( f->f ) ; 1179 f->f = 0 ; 1180 } 1181 1182 /* if requested, point to next page and check if done */ 1183 1184 if ( dp ) { 1185 f->page++ ; 1186 } 1187 1188 if ( f->page > f->lastpage ) { 1189 err = 1 ; 1190 } 1191 1192 /* open the file and seek to start of image data */ 1193 1194 if ( ! err ) { 1195 f->f = fopen ( f->page->fname, (f->page->format == P_TEXT) ? "r" : "rb" ) ; 1196 if ( ! f->f ) 1197 err = msg ( "ES2can't open %s:", f->page->fname ) ; 1198 } 1199 1200 if ( ! err && fseek ( f->f, f->page->offset, SEEK_SET ) ) 1201 err = msg ( "ES2 seek failed" ) ; 1202 1203 /* default initializations */ 1204 1205 f->lines = f->page->h ; 1206 1207 /* coding-specific initializations for this page */ 1208 1209 if ( ! err ) { 1210 pf = reset[f->page->format] ; 1211 if ( pf ) 1212 err = (*pf)(f) ; 1213 } 1214 1215 return err ; 1216} 1217 1218 1219/* Returns true if on last file. */ 1220 1221int lastpage ( IFILE *f ) 1222{ 1223 return f->page >= f->lastpage ; 1224} 1225 1226#define dfax_first 0 1227#define dfax_next 0 1228 1229/* Initialize an input (IFILE) structure. This structure 1230 collects the data about images to be processed to allow a 1231 simple interface for functions that need to read image files. 1232 1233 The IFILE is initialized by building an array of information 1234 for each page (image) in all of the files. 1235 1236 The page pointer index is initialized so that the first call 1237 to nextipage with dp=1 actually opens the first file. 1238 1239*/ 1240 1241 1242int newIFILE ( IFILE *f, char **fnames ) 1243{ 1244 int err=0, i, n; 1245 char **p ; 1246 uchar buf[128] ; 1247 int ( *fun ) ( IFILE * ) ; 1248 1249 int ( *first [NIFORMATS] ) ( IFILE * ) = { 1250 auto_first, pbm_first, fax_first, text_first, tiff_first, 1251 dfax_first, pcx_first, raw_first, dcx_first 1252 } ; 1253 1254 int ( *next [NIFORMATS] ) ( IFILE * ) = { 1255 auto_next, pbm_next, fax_next, text_next, tiff_next, 1256 dfax_next, pcx_next, raw_next, dcx_next 1257 } ; 1258 1259 f->fileformat = 0; 1260 f->totalpages = 0; 1261 f->page = f->pages ; 1262 1263 /* get info for all pages in all files */ 1264 1265 for ( p=fnames ; ! err && *p ; p++ ) { 1266 1267 if ( ! ( f->f = fopen ( *p, "rb" ) ) ) 1268 err = msg ( "ES2 can't open %s:", *p ) ; 1269 1270 if ( ! err ) { 1271 n = fread ( buf, 1, 128, f->f ) ; 1272 if ( ferror ( f->f ) ) 1273 err = msg ( "ES2 can't open %s:", *p ) ; 1274 } 1275 1276 if ( ! err ) { 1277 f->fileformat = getformat ( buf, n ) ; 1278 if ( ! f->fileformat ) 1279 err = msg ( "E2 can't get format of %s", *p ) ; 1280 } 1281 1282 if ( ! err && fseek ( f->f, 0, SEEK_SET ) ) 1283 err = msg ( "ES2 can't rewind %s:", *p ) ; 1284 1285 /* get format information for all pages in this file */ 1286 1287 for ( i=0 ; ! err ; i++ ) { 1288 1289 page_init ( f->page, *p ) ; 1290 1291 if ( ( fun = i ? next[f->fileformat] : first[f->fileformat] ) ) 1292 err = (*fun)(f) ; 1293 1294 if ( ! err ) { 1295 1296 page_report ( f->page, f->fileformat, f->page - f->pages + 1 ) ; 1297 1298 f->page++ ; 1299 f->totalpages++; 1300 1301 if ( f->page >= f->pages + MAXPAGE ) 1302 err = msg ( "E2 too many pages (max is %d)", MAXPAGE ) ; 1303 } 1304 1305 if ( ! f->next ) break ; 1306 } 1307 1308 if ( f->f ) { 1309 fclose ( f->f ) ; 1310 f->f = 0 ; 1311 } 1312 1313 } 1314 1315 f->lastpage = f->page - 1 ; 1316 1317 f->page = f->pages ; 1318 1319 if ( ! normalbits[1] ) initbittab() ; /* bit-reverse table initialization */ 1320 1321 return err ; 1322} 1323 1324 /* Image File Output Functions */ 1325 1326/* Strings and function to write a bit map in HP-PCL format. The only 1327 compression is removal of trailing zeroes. Margins and resolution are 1328 set before first write. */ 1329 1330char *PCLBEGIN = 1331 "\033E" /* Printer reset. */ 1332 "\033&l0E" /* top margin = 0 */ 1333 "\033&a0L" /* left margin = 0 */ 1334 "\033*t%dR" /* Set raster graphics resolution */ 1335 "\033*r1A" ; /* Start raster graphics, rel. adressing */ 1336 1337char *PCLEND = 1338 "\033*rB" /* end raster graphics */ 1339 "\014" /* form feed */ 1340 "\033E" ; /* Printer reset. */ 1341 1342void pclwrite ( OFILE *f, unsigned char *buf, int n ) 1343{ 1344 while ( n > 0 && buf [ n-1 ] == 0 ) n-- ; 1345 fprintf( f->f, "\033*b%dW", n ) ; 1346 fwrite ( buf, n, 1, f->f ) ; 1347} 1348 1349 1350/* Write a bit map as (raw) Portable Gray Map (PGM) format after 1351 decimating by a factor of 4. Sums bits in each 4x4-pel square 1352 to compute sample value. This function reduces each dimension 1353 of a bit map by 4 (it writes n*8/4 pixels per scan line and 1354 one scan line for every 4 in). The 17 possible sample values 1355 are spread linearly over the range 0-255. */ 1356 1357void pgmwrite ( OFILE *f, uchar *buf, int n ) 1358{ 1359 static uchar gval [ MAXBITS * 8 / 4 ] ; 1360 static int init=0, lines=0 ; 1361 static uchar hbits [ 256 ], lbits [ 256 ] ; 1362 static int nybblecnt [ 16 ] = { 0,1,1,2, 1,2,2,3, 1,2,2,3, 2,3,3,4 } ; 1363 static uchar corr [ 17 ] = { 255, 239, 223, 207, 191, 175, 159, 143, 127, 1364 111, 95, 79, 63, 47, 31, 15, 0 } ; 1365 int m ; 1366 uchar *p, *q ; 1367 1368 if ( ! init ) { /* build table of bit counts in each nybble */ 1369 short i ; 1370 for ( i=0 ; i<256 ; i++ ) { 1371 hbits [ i ] = nybblecnt [ i >> 4 & 0x0f ] ; 1372 lbits [ i ] = nybblecnt [ i & 0x0f ] ; 1373 } 1374 init = 1 ; 1375 } 1376 1377 for ( m=n, p=gval, q=buf ; m-- > 0 ; q++ ) { 1378 *p++ += hbits [ *q ] ; 1379 *p++ += lbits [ *q ] ; 1380 } 1381 1382 if ( ( lines++ & 0x03 ) == 0x03 ) { 1383 for ( p=gval, m=2*n ; m-- > 0 ; p++ ) *p = corr [ *p ] ; 1384 fwrite ( gval, 1, 2*n, f->f ) ; 1385 memset ( gval, 0, 2*n ) ; 1386 } 1387} 1388 1389 1390/* Postscript image data is differentially coded vertically and 1391 run-length coded horizontally. A leading byte (n) defines the type 1392 of coding for subsequent data: 1393 1394 0 repeat previous line 1395 1-127 n data bytes follow 1396 128-254 copy n-127 bytes from previous line 1397 255 n repeat the next character 'n' times 1398 1399 The overhead for coding a copy is 2 bytes (copy count, data count), 1400 so copies > 2 bytes should be so coded. The overhead for coding a 1401 run is 4 bytes (255, count, byte, data count), so runs > 4 bytes 1402 should be so coded. Copies decode/execute faster and code more 1403 compactly so are preferred over runs. 1404 1405*/ 1406 1407const char PSBEGIN [] = /* start of file */ 1408 "%%!PS-Adobe-2.0 EPSF-2.0 \n" 1409 "%%%%Creator: efax (Copyright 1995 Ed Casas) \n" 1410 "%%%%Title: efix output\n" 1411 "%%%%Pages: (atend) \n" 1412 "%%%%BoundingBox: 0 0 %d %d \n" 1413 "%%%%BeginComments \n" 1414 "%%%%EndComments \n" 1415 "/val 1 string def \n" 1416 "/buf %d string def \n" 1417 "/getval { \n" 1418 " currentfile val readhexstring pop 0 get \n" 1419 "} bind def \n" 1420 "/readbuf { \n" 1421 " 0 %% => index \n" 1422 " { \n" 1423 " dup buf length ge { exit } if \n" 1424 " getval %% => index run_length \n" 1425 " dup 127 le { \n" 1426 " dup 0 eq { \n" 1427 " pop buf length \n" 1428 " } { \n" 1429 " currentfile buf 3 index 3 index getinterval readhexstring pop pop\n" 1430 " } ifelse \n" 1431 " } { \n" 1432 " dup 255 eq { \n" 1433 " pop getval getval %% => index run_length value \n" 1434 " 2 index 1 3 index 2 index add 1 sub %% => ... start 1 end \n" 1435 " { buf exch 2 index put } for \n" 1436 " pop \n" 1437 " } { \n" 1438 " 127 sub \n" 1439 " } ifelse \n" 1440 " } ifelse \n" 1441 " add %% => index \n" 1442 " } loop \n" 1443 " pop \n" 1444 " buf \n" 1445 "} bind def \n" 1446 "%%%%EndProlog \n" ; 1447 1448const char PSPAGE [] = /* start of page */ 1449 "%%%%Page: %d %d \n" 1450 "gsave \n" 1451 "%f %f translate \n" 1452 "%f %f scale \n" 1453 "%d %d %d [ %d %d %d %d %d %d ] { readbuf } image \n" ; 1454 1455const char PSPAGEEND [] = /* end of page */ 1456 "\n" 1457 "grestore \n" 1458 "showpage \n" ; 1459 1460const char PSEND [] = /* end of file */ 1461 "%%Trailer \n" 1462 "%%%%Pages: %d \n" ; 1463 1464 1465void psinit ( OFILE *f, int newfile, int page, int w, int h, int n ) 1466{ 1467 float ptw, pth ; 1468 1469 if ( ! f ) { 1470 msg ( "E2 can't happen (psinit)" ) ; 1471 return ; 1472 } 1473 1474 ptw = w/f->xres * 72.0 ; /* convert to points */ 1475 pth = h/f->yres * 72.0 ; 1476 1477 if ( newfile ) 1478 fprintf ( f->f, PSBEGIN, 1479 (int) ptw, (int) pth, /* Bounding Box */ 1480 n ) ; /* buffer string length */ 1481 1482 fprintf ( f->f, PSPAGE, 1483 page, page, /* page number */ 1484 0.0, 0.0, /* shift */ 1485 ptw, pth, /* scaling */ 1486 w, h, 1, /* image size */ 1487 w, 0, 0, -h, 0, h ) ; /* CTM */ 1488 f->pslines = 0 ; 1489 f->lastpageno = page ; 1490} 1491 1492 1493char nhexout = 0, hexchars [ 16 ] = "0123456789abcdef" ; 1494 1495#define hexputc( f, c ) ( \ 1496 putc ( hexchars [ (c) >> 4 ], f ), \ 1497 putc ( hexchars [ (c) & 0x0f ], f ), \ 1498 ( ( ( nhexout++ & 31 ) == 31 ) ? putc ( '\n', f ) : 0 ) ) 1499 1500void hexputs ( FILE *f, uchar *p, int n ) 1501{ 1502 uchar c ; 1503 if ( n > 0 ) { 1504 hexputc ( f, n ) ; 1505 while ( n-- ) { c = *p++ ^ 0xff ; hexputc ( f, c ) ; } 1506 } 1507} 1508 1509/* Encode into postscript. If not a repeated line, test (using 1510 index j) from current position (i) for possible encodings as: 1511 copy of > 2 bytes, runs of > 4 or data >=127. Otherwise the 1512 byte is skipped. Uncoded bytes are output from the last 1513 uncoded byte (l) before output of runs/copies. */ 1514 1515void pswrite ( OFILE *f, unsigned char *buf, int n ) 1516{ 1517 int i, j, l ; 1518 static unsigned char last [ MAXBITS ] ; 1519 1520 l=i=0 ; 1521 1522 if ( ! f || ! buf || n<0 ) { 1523 msg ( "E2 can't happen (pswrite)" ) ; 1524 return ; 1525 } 1526 1527 for ( j=0 ; j<n && buf[j]==last[j] && f->pslines ; j++ ) ; 1528 if ( j == n ) { /* repeat line */ 1529 hexputc ( f->f, 0 ) ; 1530 l=i=n ; 1531 } 1532 1533 while ( i<n ) { 1534 1535 for ( j=i ; j<n && buf[j]==last[j] && j-i<127 && f->pslines ; j++ ) ; 1536 if ( j-i > 2 ) { /* skip */ 1537 hexputs ( f->f, buf+l, i-l ) ; 1538 hexputc ( f->f, j-i + 127 ) ; 1539 l=i=j ; 1540 } else { 1541 for ( j=i ; j<n && buf[j]==buf[i] && j-i<255 ; j++ ) ; 1542 if ( j-i > 4 ) { /* run */ 1543 hexputs ( f->f, buf+l, i-l ) ; 1544 hexputc ( f->f, 255 ) ; 1545 hexputc ( f->f, j-i ) ; 1546 hexputc ( f->f, buf[i] ^ 0xff ) ; 1547 l=i=j ; 1548 } else { 1549 if ( i-l >= 127 ) { /* maximum data length */ 1550 hexputs ( f->f, buf+l, i-l ) ; 1551 l=i ; 1552 } else { /* data */ 1553 i++ ; 1554 } 1555 } 1556 } 1557 1558 } 1559 hexputs ( f->f, buf+l, i-l ) ; 1560 1561 if ( n >= 0 ) 1562 memcpy ( last, buf, n ) ; 1563 1564 f->pslines++ ; 1565} 1566 1567 1568/* Write 2- and 4-byte integers to an image output file. Return 1569 as for fwrite. */ 1570 1571int fwrite2 ( short s, OFILE *f ) 1572{ 1573 uchar *p = (void*) &s ; 1574 return fwrite ( bigendian ? p + sizeof(short) - 2 : p, 2, 1, f->f ) ; 1575} 1576 1577int fwrite4 ( long l, OFILE *f ) 1578{ 1579 uchar *p = (void*) &l ; 1580 return fwrite ( bigendian ? p + sizeof(long ) - 4 : p, 4, 1, f->f ) ; 1581} 1582 1583 1584/* Write a TIFF directory tag. Returns 0 if OK, 1 on errors. */ 1585 1586int wtag ( OFILE *f, int lng, short tag, short type, long count, long offset ) 1587{ 1588 int err=0 ; 1589 1590 err = err || ! fwrite2 ( tag, f ) ; 1591 err = err || ! fwrite2 ( type, f ) ; 1592 err = err || ! fwrite4 ( count, f ) ; 1593 if ( lng ) { 1594 err = err || ! fwrite4 ( offset, f ) ; 1595 } else { 1596 err = err || ! fwrite2 ( offset, f ) ; 1597 err = err || ! fwrite2 ( 0, f ) ; 1598 } 1599 1600 if ( err ) msg ( "ES2 can't write TIFF tag" ) ; 1601 return err ; 1602} 1603 1604 1605/* Write TIFF header and directory. File format based on Sam 1606 Leffler's tiff.h. Can only be used for single-image TIFFs 1607 because always seeks to start of file to re-write the 1608 header. */ 1609 1610#define NTAGS 17 /* number of tags in directory */ 1611#define NRATIO 2 /* number of floats (as ratios) */ 1612 1613int tiffinit ( OFILE *f ) 1614{ 1615 int err=0, compr=1 ; 1616 long tdoff, doff ; 1617 1618 fseek ( f->f, 0, SEEK_SET ) ; 1619 1620 /* 0 ==> (start of TIFF file) */ 1621 1622 /* write magic, TIFF version and offset to directory */ 1623 1624 fwrite2 ( bigendian ? 0x4d4d : 0x4949, f ) ; 1625 fwrite2 ( 42, f ) ; 1626 fwrite4 ( 8, f ) ; 1627 1628 /* 8 ==> directory */ 1629 1630 fwrite2 ( NTAGS, f ) ; 1631 1632 /* figure out offsets within file and compression code */ 1633 1634 tdoff = 8 + 2 + NTAGS*12 + 4 ; /* offset to directory data */ 1635 doff = tdoff + NRATIO*8 ; /* offset to image data */ 1636 1637 switch ( f->format ) { 1638 case O_TIFF_RAW: compr = 1 ; break ; 1639 case O_TIFF_FAX: compr = 3 ; break ; 1640 default: err = msg ( "E2can't happen(tiffinit)" ) ; break ; 1641 } 1642 1643 /* write directory tags, 12 bytes each */ 1644 1645 wtag( f, 1, 256, 4, 1, f->w ) ; /* width long */ 1646 wtag( f, 1, 257, 4, 1, f->h ) ; /* length long */ 1647 wtag( f, 0, 258, 3, 1, 1 ) ; /* bits/sample short */ 1648 1649 wtag( f, 0, 259, 3, 1, compr ) ; /* compresssion(g3=3) short */ 1650 wtag( f, 0, 262, 3, 1, 0 ) ; /* photometric(0-min=white) short */ 1651 wtag( f, 0, 266, 3, 1, 1 ) ; /* fill order(msb2lsb=1) short */ 1652 wtag( f, 1, 273, 4, 1, doff ) ; /* strip offsets long */ 1653 1654 wtag( f, 0, 274, 3, 1, 1 ) ; /* orientation(1=normal) short */ 1655 wtag( f, 0, 277, 3, 1, 1 ) ; /* samples/pixel short */ 1656 wtag( f, 1, 278, 4, 1, f->h ) ; /* rows/strip long */ 1657 wtag( f, 1, 279, 4, 1, f->bytes ) ; /* strip byte counts long */ 1658 1659 wtag( f, 1, 282, 5, 1, tdoff+0 ) ; /* xresolution ratio */ 1660 wtag( f, 1, 283, 5, 1, tdoff+8 ) ; /* yresolution ratio */ 1661 wtag( f, 0, 284, 3, 1, 1 ) ; /* storage(1=single plane) short */ 1662 wtag( f, 1, 292, 4, 1, 0 ) ; /* g3options long */ 1663 1664 wtag( f, 0, 296, 3, 1, 2 ) ; /* resolution units(2=in,3=cm) short */ 1665 wtag( f, 0, 327, 3, 1, 0 ) ; /* clean fax(0=clean) short */ 1666 1667 fwrite4 ( 0, f ) ; /* offset to next dir (no more) */ 1668 1669 /* ==> tdoff (tag data offset), write ratios for floats here */ 1670 1671 fwrite4 ( f->xres+0.5, f ) ; 1672 fwrite4 ( 1, f ) ; 1673 fwrite4 ( f->yres+0.5, f ) ; 1674 fwrite4 ( 1, f ) ; 1675 1676 /* ==> doff (strip data offset), image data goes here */ 1677 1678 return err ; 1679} 1680 1681 1682/* Convert array 'runs' of 'nr' run lengths into a bit map 'buf'. Returns 1683 the number of bytes filled. */ 1684 1685int runtobit ( short *runs, int nr, uchar *buf ) 1686{ 1687 static uchar zerofill [ 9 ] = { 1688 0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00 } ; 1689 static uchar onefill [ 9 ] = { 1690 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff } ; 1691 1692 uchar col=0, *buf0 = buf ; 1693 register short len, b=8, bytes ; 1694 1695 while ( nr-- > 0 ) { 1696 len = *runs++ ; 1697 if ( col ) *buf |= onefill [ b ] ; /* right bits of cur. byte */ 1698 else *buf &= zerofill [ b ] ; 1699 if ( b > len ) { /* done fill */ 1700 b -= len ; 1701 } else { /* continue to next byte */ 1702 len -= b ; 1703 buf++ ; 1704 b = 8 ; 1705 if ( ( bytes = len>>3 ) > 0 ) { /* fill >1 byte */ 1706 memset ( buf, col, bytes ) ; 1707 len -= bytes*8; 1708 buf += bytes ; 1709 } 1710 *buf = col ; /* flood the rest */ 1711 b -= len ; 1712 } 1713 col ^= 0xff ; 1714 } 1715 1716 return buf - buf0 + ( b < 8 ) ; 1717} 1718 1719 1720/* Write a PCX file header. */ 1721 1722int fputi ( int i, OFILE *f ) 1723{ 1724 putc ( i & 0xff, f->f ) ; 1725 putc ( ( i >> 8 ) & 0xff, f->f ) ; 1726 return 0 ; 1727} 1728 1729void pcxinit ( OFILE *f ) 1730{ 1731 uchar buf [ 60 ] = { 0x0a, 3, 1, 1 } ; /* magic, version, compr, BPP */ 1732 1733 fwrite ( buf, 1, 4, f->f ) ; /* 4 */ 1734 fputi ( 0, f ) ; /* 8 xmin, ymin, xmax, ymax */ 1735 fputi ( 0, f ) ; 1736 fputi ( f->w-1, f ) ; 1737 fputi ( f->h-1, f ) ; 1738 fputi ( f->xres, f ) ; /* 4 x and y dpi */ 1739 fputi ( f->yres, f ) ; 1740 memset ( buf, 0, 48 ) ; /* 48 palette */ 1741 fwrite ( buf, 1, 48, f->f ) ; 1742 putc ( 0, f->f ) ; /* 1 reserved */ 1743 putc ( 1, f->f ) ; /* 1 planes per pixel */ 1744 fputi ( (f->w+15)/16*2, f ) ; /* 2 bytes per line */ 1745 memset ( buf, 0, 60 ) ; /* 60 zero */ 1746 fwrite ( buf, 1, 60, f->f ) ; 1747} 1748 1749/* Write a PCX-compressed scan line. */ 1750 1751void pcxwrite ( OFILE *of, uchar *p, int nb ) 1752{ 1753 int c, n, runc ; 1754 FILE *f = of->f ; 1755 1756 runc = *p++ ; 1757 n = 1 ; 1758 1759 for ( nb-- ; nb > 0 ; nb-- ) { 1760 c = *p++ ; 1761 if ( c == runc && n < 63 ) { /* continue run */ 1762 n++ ; 1763 } else { /* terminate run */ 1764 if ( n > 1 || ( ( runc & 0xc0 ) == 0xc0 ) ) /* output as run */ 1765 putc ( n | 0xc0, f ) ; 1766 putc ( runc, f ) ; 1767 runc = c ; /* start new run */ 1768 n = 1 ; 1769 } 1770 } 1771 1772 /* last run */ 1773 1774 if ( n > 1 || ( ( runc & 0xc0 ) == 0xc0 ) ) /* output as run */ 1775 putc ( n | 0xc0, f ) ; 1776 putc ( runc, f ) ; 1777 1778} 1779 1780 1781/* Begin/end output pages. If not starting first page (0), terminate 1782 previous page. If output filename pattern is defined, [re-]opens that 1783 file. If not terminating last page (page==EOF), writes file header. 1784 Returns 0 or 2 on errors. */ 1785 1786int nextopage ( OFILE *f, int page ) 1787{ 1788 int err = 0 ; 1789 int i, nb=0 ; 1790 uchar *p, codes [ ( RTCEOL * EOLBITS ) / 8 + 3 ] ; 1791 1792 if ( f->f ) { /* terminate previous page */ 1793 1794 switch ( f->format ) { 1795 case O_PBM: 1796 break ; 1797 case O_PGM: 1798 break ; 1799 case O_FAX: 1800 case O_TIFF_FAX: 1801 for ( p = codes, i=0 ; i<RTCEOL ; i++ ) 1802 p = putcode ( &f->e, EOLCODE, EOLBITS, p ) ; 1803 nb = putcode ( &f->e, 0, 0, p ) - codes ; 1804 fwrite ( codes, 1, nb, f->f ) ; 1805 f->bytes += nb ; 1806 if ( f->format == O_TIFF_FAX ) tiffinit ( f ) ; 1807 break ; 1808 case O_TIFF_RAW: 1809 tiffinit(f) ; /* rewind & update TIFF header */ 1810 break ; 1811 case O_PCL: 1812 fprintf ( f->f, PCLEND ) ; 1813 break ; 1814 case O_PS: 1815 fprintf ( f->f, PSPAGEEND ) ; 1816 if ( f->fname || page<0 ) fprintf ( f->f, PSEND, f->lastpageno ) ; 1817 break ; 1818 case O_PCX: 1819 case O_PCX_RAW: 1820 fseek ( f->f, 0, SEEK_SET ) ; 1821 pcxinit ( f ) ; 1822 break ; 1823 } 1824 1825 if ( ferror ( f->f ) ) { 1826 err = msg ("ES2output error:" ) ; 1827 } else { 1828 msg ( "F+ wrote %s as %dx%d pixel %.fx%.f dpi %s page", 1829 f->cfname, f->w, f->h, f->xres, f->yres, 1830 oformatname [f->format] ) ; 1831 1832 switch ( f->format ) { 1833 case O_PS: 1834 msg ( "F (%d lines)", f->pslines ) ; 1835 break ; 1836 case O_TIFF_RAW: 1837 case O_TIFF_FAX: 1838 msg ( "F (%d bytes)", f->bytes ) ; 1839 break ; 1840 default: 1841 msg ( "F " ) ; 1842 break ; 1843 } 1844 1845 } 1846 1847 } 1848 1849 if ( ! err && page >= 0 ) { /* open new file */ 1850 if ( f->fname ) { 1851 snprintf ( f->cfname, sizeof(f->cfname), f->fname, page+1, page+1, page+1 ) ; 1852 1853 if ( ! f->f ) 1854 f->f = fopen ( f->cfname, ( f->format == O_PS ) ? "w" : "wb+" ) ; 1855 else 1856 f->f = freopen ( f->cfname, ( f->format == O_PS ) ? "w" : "wb+", f->f ) ; 1857 1858 if ( ! f->f ) { 1859 err = msg ("ES2can't open output file %s:", f->cfname ) ; 1860 } 1861 } else { 1862 f->f = stdout ; 1863 strcpy ( f->cfname, "standard output" ) ; 1864 } 1865 } 1866 1867 /* start new page */ 1868 1869 if ( ! err && page >= 0 ) { 1870 switch ( f->format ) { 1871 case O_PBM: 1872 fprintf ( f->f, "P4 %d %d\n", f->w, f->h ) ; 1873 break ; 1874 case O_PGM: 1875 fprintf ( f->f, "P5 %d %d %d\n", f->w/4, f->h/4, 255 ) ; 1876 break ; 1877 case O_FAX: 1878 case O_TIFF_FAX: 1879 if ( f->format == O_TIFF_FAX ) tiffinit ( f ) ; 1880 p = putcode ( &f->e, EOLCODE, EOLBITS, codes ) ; 1881 nb = p - codes ; 1882 fwrite ( codes, 1, nb, f->f ) ; 1883 break ; 1884 case O_TIFF_RAW: 1885 tiffinit ( f ) ; 1886 break ; 1887 case O_PCL: 1888 fprintf ( f->f, PCLBEGIN, (int) f->xres ) ; 1889 break ; 1890 case O_PS: 1891 psinit ( f, ( f->fname || page==0 ), page+1, f->w, f->h, f->w/8 ) ; 1892 break ; 1893 case O_PCX: 1894 case O_PCX_RAW: 1895 fseek ( f->f, 0, SEEK_SET ) ; 1896 pcxinit ( f ) ; 1897 break ; 1898 } 1899 1900 if ( ferror ( f->f ) ) err = msg ("ES2output error:" ) ; 1901 } 1902 1903 /* only count lines/bytes for those formats that don't have 1904 headers or where we will update the headers on closing */ 1905 1906 switch ( f->format ) { 1907 case O_FAX: 1908 case O_TIFF_FAX: 1909 case O_PCX: 1910 case O_PCX_RAW: 1911 f->h = 0 ; 1912 f->bytes = nb ; 1913 break ; 1914 } 1915 1916 return err ; 1917} 1918 1919 1920/* Output scan line of nr runs no times to output file f. */ 1921 1922void writeline ( OFILE *f, short *runs, int nr, int no ) 1923{ 1924 int nb = 0 ; 1925 uchar *p, buf [ MAXCODES ] ; 1926 1927 /* if line to be output, convert to right format */ 1928 1929 if ( no > 0 ) 1930 switch ( f->format ) { 1931 case O_PBM: 1932 case O_PGM: 1933 case O_PCL: 1934 case O_PS: 1935 case O_TIFF_RAW: 1936 case O_PCX: 1937 case O_PCX_RAW: 1938 nb = runtobit ( runs, nr, buf ) ; 1939 break ; 1940 case O_FAX: 1941 case O_TIFF_FAX: 1942 break ; 1943 } 1944 1945 /* output `no' times. */ 1946 1947 while ( no-- > 0 ) { 1948 switch ( f->format ) { 1949 case O_PCX_RAW: 1950 case O_TIFF_RAW: 1951 case O_PBM: 1952 fwrite ( buf, 1, nb, f->f ) ; 1953 break ; 1954 case O_PGM: 1955 pgmwrite ( f, buf, nb ) ; 1956 break ; 1957 case O_TIFF_FAX: 1958 case O_FAX: 1959 p = runtocode ( &f->e, runs, nr, buf ) ; 1960 p = putcode ( &f->e, EOLCODE, EOLBITS, p ) ; 1961 nb = p - buf ; 1962 fwrite ( buf, 1, nb, f->f ) ; 1963 break ; 1964 case O_PCL: 1965 pclwrite ( f, buf, nb ) ; 1966 break ; 1967 case O_PS: 1968 pswrite ( f, buf, nb ) ; 1969 break ; 1970 case O_PCX: 1971 pcxwrite ( f, buf, nb ) ; 1972 break ; 1973 } 1974 1975 /* only count lines/bytes for those formats that don't have 1976 headers or where we will update the headers on closing */ 1977 1978 switch ( f->format ) { 1979 case O_FAX: 1980 case O_TIFF_FAX: 1981 case O_TIFF_RAW: 1982 case O_PCX: 1983 case O_PCX_RAW: 1984 f->h++ ; 1985 f->bytes += nb ; 1986 break ; 1987 } 1988 1989 } 1990} 1991 1992 1993/* Initialize new output file. If fname is NULL, stdout will be used for 1994 all images. */ 1995 1996void newOFILE ( OFILE *f, int format, char *fname, 1997 float xres, float yres, int w, int h ) 1998{ 1999 f->f = 0 ; 2000 f->format = format ; 2001 f->fname = fname ; 2002 f->xres = xres ; 2003 f->yres = yres ; 2004 f->w = w ; 2005 f->h = h ; 2006 f->bytes = 0 ; 2007 newENCODER ( &f->e ) ; 2008} 2009 2010/* Read a bitmap to use as a font and fill in the font data. If 2011 the file name is null, empty, or there are errors, the font is 2012 initialized to the built-in font. Returns 0 if OK, 2 on 2013 errors. */ 2014 2015int readfont ( char *fname, faxfont *font ) 2016{ 2017 int err=0, i, j, n=0, nr, nb, fontok=0, pels ; 2018 char *fnames [2] = { 0, 0 } ; 2019 short runs [ MAXRUNS ] ; 2020 IFILE f; 2021 2022 if ( fname && *fname ) { 2023 2024 fnames[0] = fname ; 2025 2026 newIFILE ( &f, fnames ) ; 2027 2028 if ( nextipage ( &f, 0 ) ) { 2029 err = msg ( "E2 can't open font file %s", fnames[0] ) ; 2030 } 2031 2032 nb = 0 ; 2033 while ( ! err && ( nr = readline ( &f, runs, &pels ) ) >= 0 ) { 2034 if ( nb+pels/8 < MAXFONTBUF ) { 2035 nb += runtobit ( runs, nr, font->buf+nb ) ; 2036 } else { 2037 err = msg ("E2font file %s too large (max %d bytes)", 2038 fnames[0], MAXFONTBUF ) ; 2039 } 2040 } 2041 2042 if ( ! err && nb != f.page->w * f.page->h / 8 ) 2043 err = msg ( "E2 read %d bytes of font data for %dx%d bitmap", 2044 nb, f.page->w, f.page->h ) ; 2045 2046 if ( ! err && ( f.page->w / 256 > MAXFONTW || f.page->h > MAXFONTH ) ) { 2047 err = msg ( "E2font size (%dx%d) too large", f.page->w, f.page->h ) ; 2048 } 2049 2050 if ( err ) { 2051 font->w = font->h = 0 ; 2052 } else { 2053 font->w = f.page->w / 256 ; 2054 font->h = f.page->h ; 2055 for ( i=0 ; i<256 ; i++ ) font->offset[i] = i*font->w ; 2056 msg ("Iread %dx%d font %s (%d bytes)", font->w, font->h, fname, nb ) ; 2057 fontok = 1 ; 2058 } 2059 2060 if ( f.f ) { 2061 fclose ( f.f ) ; 2062 f.f = 0 ; 2063 } 2064 } 2065 2066 if ( ! fontok ) { /* use built-in font */ 2067 2068 font->w = STDFONTW ; 2069 font->h = STDFONTH ; 2070 2071 for ( i=j=0 ; j<STDFONTBUF ; i++ ) /* expand bit map */ 2072 if ( stdfont [ i ] == 0 ) 2073 for ( n = stdfont [ ++i ] ; n > 0 ; n-- ) 2074 font->buf [ j++ ] = 0 ; 2075 else 2076 font->buf [ j++ ] = stdfont [ i ] ; 2077 2078 if ( i != 1980 ) err = msg ( "E2can't happen(readfont)" ) ; 2079 2080 for ( i=0 ; i<256 ; i++ ) font->offset[i] = i*font->w ; 2081 } 2082 2083 return err ; 2084} 2085 2086 2087/* Initialize bit reversal lookup tables (note that the 2088 `normalbits' array is the one actually used for the bit 2089 reversal. */ 2090 2091void initbittab ( void ) 2092{ 2093 int i ; 2094 for ( i=0 ; i<256 ; i++ ) 2095 normalbits [ reversebits [ i ] = i ] = 2096 ( i& 1 ? 128:0 ) | ( i& 2 ? 64:0 ) | ( i& 4 ? 32:0 ) | ( i& 8 ? 16:0 ) | 2097 ( i&16 ? 8:0 ) | ( i&32 ? 4:0 ) | ( i&64 ? 2:0 ) | ( i&128 ? 1:0 ) ; 2098} 2099 2100 2101 /* T.4 Encoding/Decoding */ 2102 2103/* Table-lookup decoder for variable-bit-length codewords. The table index 2104 is the N most recently undecoded bits with the first (oldest) undecoded 2105 bit as the MS bit. If the N bits uniquely identify a codeword then the 2106 indexed 'code' member identifies the code, otherwise it is zero. The 2107 'bits' member gives the number of bits to be considered decoded (to be 2108 removed from the bit stream) and the 'next' element is a pointer to the 2109 table to use for decoding the next part of the bit sequence. 2110 2111 For T.4 decoding the longest T.4 codeword is 13 bits. The implementation 2112 below uses two tables of 512 elements (N=9 bits) for each colour. 2113 Codewords longer than 9 bits require a second lookup. Since all 2114 codewords longer than than 9 bits have a 4-bit zero prefix it is 2115 possible to use only one secondary 9-bit lookup table by dropping only 2116 the first 4 bits after the first lookup. The code indentifier is the run 2117 length + 1. A separate table is used for decoding the variable-length 2118 FILL patterns. 2119 2120 For undefined codewords, one bit is skipped and decoding continues at 2121 the white code table. */ 2122 2123/* the lookup tables for each colour and the fill lookup table */ 2124 2125dtab tw1 [ 512 ], tw2 [ 512 ], tb1 [ 512 ], tb2 [ 512 ], fill [ 512 ] ; 2126char tabinit=0 ; 2127 2128/* Add code cword shifted left by shift to decoding table tab. */ 2129 2130void addcode ( dtab *tab, int cword, int shift, 2131 short code, short bits, dtab *next ) 2132{ 2133 int i, n = 1 << shift ; 2134 2135 for ( i = cword << shift ; n-- > 0 ; i++ ) { 2136 tab[i].code = code ; 2137 tab[i].bits = bits ; 2138 tab[i].next = next ; 2139 } 2140} 2141 2142/* Initialize the decoding table for one colour using the codes in the T.4 2143 table p0. t1 and t2 are the two decoding tables and ot is the first 2144 table of the other colour. */ 2145 2146void init1dtab ( t4tab *p0, dtab *t1, dtab *t2, dtab *ot ) 2147{ 2148 t4tab *p ; 2149 for ( p = p0 ; p->code ; p++ ) 2150 if ( p->bits <= 9 ) { 2151 addcode ( t1, p->code, 9 - p->bits, p->rlen + 1, p->bits, 2152 ( p - p0 ) > 63 ? t1 : ot ) ; 2153 } else { 2154 addcode ( t1, p->code >> ( p->bits - 9 ), 0, 0, 4, t2 ) ; 2155 addcode ( t2, p->code, 13 - p->bits, p->rlen + 1, p->bits - 4, 2156 ( p - p0 ) > 63 ? t1 : ot ) ; 2157 } 2158} 2159 2160 2161/* Initialize a T.4 decoder. */ 2162 2163void newDECODER ( DECODER *d ) 2164{ 2165 int i ; 2166 2167 if ( ! tabinit ) { 2168 2169 /* undefined codes */ 2170 2171 addcode ( tw1, 0, 9, 0, 1, tw1 ) ; 2172 addcode ( tw2, 0, 9, 0, 1, tw1 ) ; 2173 addcode ( tb1, 0, 9, 0, 1, tw1 ) ; 2174 addcode ( tb2, 0, 9, 0, 1, tw1 ) ; 2175 addcode ( fill, 0, 9, 0, 1, tw1 ) ; 2176 2177 /* fill and EOL */ 2178 2179 addcode ( tw1, 0, 0, 0, 4, tw2 ) ; 2180 addcode ( tw2, 0, 2, 0, 7, fill ) ; 2181 addcode ( tb1, 0, 0, 0, 4, tb2 ) ; 2182 addcode ( tb2, 0, 2, 0, 7, fill ) ; 2183 2184 addcode ( fill, 0, 0, 0, 9, fill ) ; 2185 for ( i=0 ; i<=8 ; i++ ) 2186 addcode ( fill, 1, i, -1, 9-i, tw1 ) ; 2187 2188 /* white and black runs */ 2189 2190 init1dtab ( wtab, tw1, tw2, tb1 ) ; 2191 init1dtab ( btab, tb1, tb2, tw1 ) ; 2192 2193 tabinit=1 ; 2194 } 2195 2196 /* initialize decoder to starting state */ 2197 2198 d->x = 0 ; 2199 d->shift = -9 ; 2200 d->tab = tw1 ; 2201 d->eolcnt = 0 ; 2202} 2203 2204 /* T.4 coding table and default font for efax/efix */ 2205 2206/* T.4 1-D run-length coding tables. codes must be in run length 2207 order for runtocode(). */ 2208 2209t4tab wtab [ ( 64 + 27 + 13 ) + 1 ] = { /* runs of white */ 2210 2211/* Terminating White Codes */ 2212 2213{53,8,0}, {7,6,1}, {7,4,2}, {8,4,3}, {11,4,4}, {12,4,5}, 2214{14,4,6}, {15,4,7}, {19,5,8}, {20,5,9}, {7,5,10}, {8,5,11}, 2215{8,6,12}, {3,6,13}, {52,6,14}, {53,6,15}, {42,6,16}, {43,6,17}, 2216{39,7,18}, {12,7,19}, {8,7,20}, {23,7,21}, {3,7,22}, {4,7,23}, 2217{40,7,24}, {43,7,25}, {19,7,26}, {36,7,27}, {24,7,28}, {2,8,29}, 2218{3,8,30}, {26,8,31}, {27,8,32}, {18,8,33}, {19,8,34}, {20,8,35}, 2219{21,8,36}, {22,8,37}, {23,8,38}, {40,8,39}, {41,8,40}, {42,8,41}, 2220{43,8,42}, {44,8,43}, {45,8,44}, {4,8,45}, {5,8,46}, {10,8,47}, 2221{11,8,48}, {82,8,49}, {83,8,50}, {84,8,51}, {85,8,52}, {36,8,53}, 2222{37,8,54}, {88,8,55}, {89,8,56}, {90,8,57}, {91,8,58}, {74,8,59}, 2223{75,8,60}, {50,8,61}, {51,8,62}, {52,8,63}, 2224 2225/* Make Up White Codes */ 2226 2227{27,5,64}, {18,5,128}, {23,6,192}, {55,7,256}, {54,8,320}, {55,8,384}, 2228{100,8,448}, {101,8,512}, {104,8,576}, {103,8,640}, {204,9,704}, {205,9,768}, 2229{210,9,832}, {211,9,896}, {212,9,960}, {213,9,1024},{214,9,1088},{215,9,1152}, 2230{216,9,1216},{217,9,1280},{218,9,1344},{219,9,1408},{152,9,1472},{153,9,1536}, 2231{154,9,1600},{24,6,1664}, {155,9,1728}, 2232 2233/* Extended Make Up Codes (Black and White) */ 2234 2235{8,11,1792}, {12,11,1856},{13,11,1920},{18,12,1984},{19,12,2048},{20,12,2112}, 2236{21,12,2176},{22,12,2240},{23,12,2304},{28,12,2368},{29,12,2432},{30,12,2496}, 2237{31,12,2560}, 2238 2239{0,0,0} } ; 2240 2241t4tab btab [ ( 64 + 27 + 13 ) + 1 ] = { /* runs of black */ 2242 2243/* Terminating Black Codes */ 2244 2245{55,10,0}, {2,3,1}, {3,2,2}, {2,2,3}, {3,3,4}, {3,4,5}, 2246{2,4,6}, {3,5,7}, {5,6,8}, {4,6,9}, {4,7,10}, {5,7,11}, 2247{7,7,12}, {4,8,13}, {7,8,14}, {24,9,15}, {23,10,16}, {24,10,17}, 2248{8,10,18}, {103,11,19}, {104,11,20}, {108,11,21}, {55,11,22}, {40,11,23}, 2249{23,11,24}, {24,11,25}, {202,12,26}, {203,12,27}, {204,12,28}, {205,12,29}, 2250{104,12,30}, {105,12,31}, {106,12,32}, {107,12,33}, {210,12,34}, {211,12,35}, 2251{212,12,36}, {213,12,37}, {214,12,38}, {215,12,39}, {108,12,40}, {109,12,41}, 2252{218,12,42}, {219,12,43}, {84,12,44}, {85,12,45}, {86,12,46}, {87,12,47}, 2253{100,12,48}, {101,12,49}, {82,12,50}, {83,12,51}, {36,12,52}, {55,12,53}, 2254{56,12,54}, {39,12,55}, {40,12,56}, {88,12,57}, {89,12,58}, {43,12,59}, 2255{44,12,60}, {90,12,61}, {102,12,62}, {103,12,63}, 2256 2257/* Make Up Black Codes */ 2258 2259{15,10,64}, {200,12,128},{201,12,192},{91,12,256}, {51,12,320}, {52,12,384}, 2260{53,12,448}, {108,13,512},{109,13,576},{74,13,640}, {75,13,704}, {76,13,768}, 2261{77,13,832}, {114,13,896},{115,13,960},{116,13,1024},{117,13,1088}, 2262{118,13,1152}, 2263{119,13,1216},{82,13,1280},{83,13,1344},{84,13,1408},{85,13,1472},{90,13,1536}, 2264{91,13,1600},{100,13,1664},{101,13,1728}, 2265 2266/* Extended Make Up Codes (Black and White) */ 2267 2268{8,11,1792}, {12,11,1856},{13,11,1920},{18,12,1984},{19,12,2048},{20,12,2112}, 2269{21,12,2176},{22,12,2240},{23,12,2304},{28,12,2368},{29,12,2432},{30,12,2496}, 2270{31,12,2560}, 2271 2272{0,0,0} } ; 2273 2274 2275/* The built-in 8x16 font. Runs of zeroes are coded as 0 2276 followed by the repetition count. */ 2277 2278uchar stdfont [ 1980 ] = { 22790,255,0,255,0,194,8,4,12,10,18,0,3,16,4,8,20,8,4,8,20,0,1,10,8,4, 22804,10,18,0,2,16,4,8,20,4,0,68,20,0,1,8,0,2,12,6,48,0,5,2,0,43,14,32, 228156,0,2,12,0,1,32,0,1,2,0,1,14,0,1,32,8,4,32,56,0,14,6,8,48,0,40,8, 22820,1,18,0,6,30,0,4,4,0,11,4,8,18,20,18,12,0,2,8,8,20,20,4,8,20,20, 22830,1,20,4,8,10,20,18,0,2,8,8,20,20,8,0,1,24,8,4,8,10,20,12,0,2,8,4, 22848,20,16,8,8,20,54,10,8,4,8,10,20,0,2,16,4,8,20,4,0,1,20,0,33,12,20, 228518,28,48,12,12,8,8,8,0,4,2,28,8,28,28,4,62,28,62,28,28,0,5,60,28, 228612,60,14,56,62,30,14,34,62,62,33,16,33,34,12,60,12,60,30,127,34,33, 228765,34,34,62,8,32,8,8,0,1,24,0,1,32,0,1,2,0,1,16,0,1,32,8,4,32,8,0, 22887,16,0,6,8,8,8,0,36,4,14,0,1,34,8,12,18,28,24,0,3,28,0,1,24,0,1,28, 228928,8,0,1,30,0,2,8,28,0,1,100,100,98,0,6,18,31,14,0,8,56,0,7,13,0, 22905,32,36,4,8,20,20,20,18,0,2,4,8,20,20,8,16,20,20,8,20,4,8,20,20,20, 22910,2,8,8,20,20,8,32,20,0,33,12,20,18,42,73,18,24,8,8,42,8,0,3,4,34, 229224,34,34,12,32,34,2,34,34,0,2,2,0,1,16,2,34,12,34,18,36,32,16,18, 229334,8,8,34,16,51,50,18,34,18,34,32,8,34,33,73,34,34,2,8,16,8,8,0,1, 229424,0,1,32,0,1,2,0,1,16,0,1,32,0,2,32,8,0,7,16,0,6,8,8,8,0,36,15,16, 229565,34,8,18,0,1,34,4,0,3,34,0,1,36,8,2,2,0,2,58,0,2,56,34,0,1,36,36, 229618,0,1,12,12,12,12,12,12,24,18,62,62,62,62,62,62,62,62,36,34,12,12, 229712,12,12,0,1,18,34,34,34,34,34,32,36,0,5,12,0,10,52,0,6,8,0,6,32, 22980,34,12,0,1,63,40,74,18,0,1,16,4,20,8,0,3,4,34,40,2,2,20,32,32,2, 229934,34,24,24,4,0,1,8,2,78,18,34,32,34,32,16,32,34,8,8,36,16,51,50, 230033,34,33,34,32,8,34,33,73,20,34,4,8,16,8,20,0,2,28,44,14,30,28,62, 230130,44,56,60,34,8,82,44,28,44,30,22,30,62,34,34,65,34,34,62,8,8,8, 23020,35,12,20,16,62,34,8,16,0,1,77,4,0,3,93,0,1,24,8,2,12,0,1,34,58, 23030,2,8,34,0,1,40,40,100,4,12,12,12,12,12,12,40,32,32,32,32,32,8,8, 23048,8,34,50,18,18,18,18,18,34,35,34,34,34,34,34,60,40,28,28,28,28,28, 230528,54,14,28,28,28,28,56,56,56,56,2,44,28,28,28,28,28,8,29,34,34,34, 230634,34,44,34,0,33,12,0,1,18,24,52,12,0,1,16,4,42,8,0,3,8,34,8,2,2, 230736,60,32,4,34,34,24,24,8,127,4,2,82,18,34,32,34,32,16,32,34,8,8,40, 230816,45,42,33,34,33,34,48,8,34,33,73,20,20,4,8,8,8,20,0,2,34,50,16, 230934,34,16,34,50,8,4,36,8,109,50,34,50,34,24,32,16,34,34,73,34,34,2, 23104,8,16,57,0,34,12,36,16,34,20,0,1,40,0,1,81,28,18,127,0,1,89,0,2, 2311127,12,2,0,1,34,58,28,0,1,8,34,36,40,40,24,4,18,18,18,18,18,18,40, 231232,32,32,32,32,8,8,8,8,34,50,33,33,33,33,33,20,37,34,34,34,34,20, 231334,40,34,34,34,34,34,34,9,16,34,34,34,34,8,8,8,8,30,50,34,34,34,34, 231434,0,1,34,34,34,34,34,34,50,34,0,33,12,0,1,18,12,8,25,0,1,16,4,8, 2315127,0,1,127,0,1,8,34,8,4,12,68,2,60,8,28,30,0,2,16,0,1,2,28,82,18, 231660,32,34,60,30,32,62,8,8,56,16,45,42,33,34,33,60,28,8,34,18,85,8, 231720,8,8,8,8,34,0,2,2,34,32,34,34,16,34,34,8,4,40,8,73,34,34,34,34, 231816,32,16,34,34,73,20,34,4,24,8,12,78,0,35,36,60,34,62,0,1,36,0,1, 231981,36,36,1,28,85,0,2,8,16,2,0,1,34,26,28,0,1,8,34,18,18,22,106,0, 23201,18,18,18,18,18,18,47,32,60,60,60,60,8,8,8,8,122,42,33,33,33,33, 232133,8,45,34,34,34,34,20,34,36,2,2,2,2,2,2,9,32,34,34,34,34,8,8,8,8, 232234,34,34,34,34,34,34,127,38,34,34,34,34,34,34,34,0,33,8,0,1,63,10, 232322,37,0,1,16,4,0,1,8,0,3,8,34,8,8,2,126,2,34,8,34,2,0,2,8,127,4,16, 232486,63,34,32,34,32,16,34,34,8,8,36,16,45,38,33,60,33,36,6,8,34,18, 232554,20,8,16,8,8,8,34,0,2,30,34,32,34,62,16,34,34,8,4,56,8,73,34,34, 232634,34,16,28,16,34,20,85,8,20,8,4,8,16,0,35,8,36,16,34,8,8,18,0,1, 232781,26,72,1,0,1,34,0,2,8,30,28,0,1,34,10,28,0,1,8,28,9,22,17,22,4, 232863,63,63,63,63,63,120,32,32,32,32,32,8,8,8,8,34,42,33,33,33,33,33, 232920,41,34,34,34,34,8,34,34,30,30,30,30,30,30,63,32,62,62,62,62,8,8, 23308,8,34,34,34,34,34,34,34,0,1,42,34,34,34,34,20,34,20,0,35,18,10,41, 233134,0,1,16,4,0,1,8,0,3,16,34,8,16,2,4,2,34,16,34,2,0,2,4,0,1,8,0,1, 233273,33,34,32,34,32,16,34,34,8,8,34,16,33,38,33,32,33,34,2,8,34,18, 233334,20,8,16,8,4,8,0,3,34,34,32,34,32,16,38,34,8,4,36,8,73,34,34,34, 233434,16,2,16,34,20,34,20,20,16,8,8,8,0,35,12,20,16,62,62,8,10,0,1,77, 23350,1,36,1,0,1,28,0,6,34,10,0,4,18,42,34,42,28,33,33,33,33,33,33,72, 233632,32,32,32,32,8,8,8,8,34,38,33,33,33,33,33,34,49,34,34,34,34,8,60, 233734,34,34,34,34,34,34,72,32,32,32,32,32,8,8,8,8,34,34,34,34,34,34, 233834,8,50,34,34,34,34,20,34,20,0,33,12,0,1,18,42,73,34,0,1,8,8,0,1, 23398,12,0,1,24,16,34,8,32,34,4,34,34,16,34,34,24,24,2,0,1,16,16,32,33, 234034,16,36,32,16,18,34,8,8,33,16,33,34,18,32,18,34,2,8,34,12,34,34, 23418,32,8,4,8,0,3,34,34,16,38,34,16,26,34,8,4,34,8,73,34,34,34,38,16, 23422,16,38,8,34,34,8,32,8,8,8,0,35,12,15,16,65,8,8,4,0,1,34,0,1,18,0, 23435,127,0,3,54,10,0,4,36,79,68,79,32,33,33,33,33,33,33,72,16,32,32, 234432,32,8,8,8,8,36,38,18,18,18,18,18,0,1,18,34,34,34,34,8,32,34,34, 234534,34,34,34,34,72,16,34,34,34,34,8,8,8,8,34,34,34,34,34,34,34,8,34, 234638,38,38,38,8,34,8,0,33,12,0,1,18,28,6,29,0,1,8,8,0,2,12,0,1,24,32, 234728,8,62,28,4,28,28,16,28,28,24,24,0,3,16,28,33,60,14,56,62,16,14, 234834,62,112,33,30,33,34,12,32,12,34,60,8,28,12,34,34,8,62,8,2,8,0,3, 234929,60,14,26,28,16,2,34,8,4,33,8,73,34,28,60,26,16,60,14,26,8,34,34, 23508,62,8,8,8,0,35,12,4,62,0,1,8,8,36,0,1,28,0,11,42,10,0,5,66,71,66, 235132,33,33,33,33,33,33,79,14,62,62,62,62,62,62,62,62,56,34,12,12,12, 235212,12,0,1,44,28,28,28,28,8,32,36,29,29,29,29,29,29,55,14,28,28,28, 235328,8,8,8,8,28,34,28,28,28,28,28,0,1,92,26,26,26,26,8,60,8,0,36,8, 23540,3,6,48,0,2,24,0,2,32,0,11,48,0,21,6,0,9,14,2,56,0,1,127,0,7,2,0, 23552,4,0,5,32,2,0,7,16,0,1,6,8,48,0,35,12,0,4,8,24,0,13,32,10,0,1,4, 23560,6,32,0,7,4,0,31,4,0,21,16,32,16,0,81,3,0,21,28,0,2,56,0,5,32,2, 23570,7,48,0,39,12,0,19,32,0,2,24,0,6,30,0,7,24,0,31,24,0,21,48,32,48, 23580,255,0,1 2359} ; 2360