![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to CCITT.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / bcp|
Return to CCITT.c CVS log | Up to [Research Unix] / researchv10no / cmd / bcp |
1.1 ! root 1: /* Copyright (c) 1989, 1990 AT&T --- All Rights Reserved. */ ! 2: /* THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T. */ ! 3: /* The copyright notice does not imply actual or intended publication. */ ! 4: /* AUTHORS: */ ! 5: /* H. S. Baird - ATT-BL MH - first versions */ ! 6: ! 7: /* CCITT.c - functions for CCITT compression/decompression of binary images. ! 8: The following discussion is a summary of CCITT Recommendations T.4 and T.6 ! 9: on facsimile coding schemes and coding control functions for Group 3 and Group ! 10: 4 facsimile apparatus (drafted at Malaga-Torremolinos, 1984). They describe ! 11: algorithms for invertible (lossless) compression and decompression of bilevel ! 12: (black-and-white, not grey) 2D rectangular images of arbitrary height and ! 13: width. By convention the images are processed top-down, one horizontal scan ! 14: line at a time. It is not strictly necessary to know the height of an image ! 15: before starting compression or decompression. Width, however, must be known ! 16: in advance in some cases (discussed below), and must remain constant for the ! 17: whole image in all cases. There are three distinct but intimately related ! 18: standards: Group 3 1-dimensional, Group 3 2-dimensional, and Group 4. ! 19: VLSI hardware implementations always include all three. The Group 3 encodings ! 20: are used in the vast installed base of FAX machines. Group 4 is not used ! 21: in today's FAX machines, but seems to be the default standard in document image ! 22: archiving applications. ! 23: The CCITT Group 3 FAX standard permits either 1-D or 2-D encoding. ! 24: It is not easy to tell from an encoding which was used. Both 1-D and 2-D ! 25: assume fixed scanline length (in pixels), which must be known at encoding time. ! 26: Group 3 1-D (g31) code uses fixed ``modified Huffman'' codes for ! 27: run-lengths, with two different code tables for black and white runs. Each ! 28: line is assumed to begin with a (possibly 0-length) white run. Of course, ! 29: the colors strictly alternate. An empty (all-white) line is supposed to be ! 30: spelled out with a full pixel count, although some decoders won't complain ! 31: if just a 0-length count is used. There are provisions for fill bits at the ! 32: end of lines to allow slow receiving equipment to keep up. Each line ends with ! 33: an EOL code on which it may be possible to synchronize after transmission error. ! 34: Group 3 2-D (g32) encoding tries to exploit the slowly-changing nature ! 35: of artwork from line to line. It is a mixture of 1-D-coded lines and ! 36: ``2-D''-coded lines describing small local changes relative to the immediately ! 37: prior ``reference'' line. 1-D coding recurs every few (`k') lines, so that ! 38: resynchronization is frequently possible. K is usually 2 or 4, but the ! 39: standard permits any number, even infinity, since the coding method used on ! 40: a line is specified by which of two special EOLx codes is used to end the ! 41: prior line. ! 42: CCITT Group 4 (g4) is like Group 3 2-D, but optimized to take advantage ! 43: of a lossless communications channel or reliable storage medium (such as computer ! 44: memory), where resynchronization is unnecessary. Thus the first line is 2-D ! 45: encoded referenced to an imaginary initial blank line, k is always infinity, ! 46: and EOL's are not used at all. It essential that the line-length be known in ! 47: advance of both encoding and decoding, so that line-breaks can be triggered when ! 48: that length is exceeded. End of FAX buffer (end of page) is signaled by a ! 49: special EOFB code. ! 50: On images of printed text and sparse line-graphics, g4-compressed files ! 51: are often 15-40X smaller than bitmap (packed bits), 5X than bitfile(9.5), ! 52: 2X than g31, and 2X than rle | pack. ! 53: PERFORMANCE ! 54: On 10 printed A4 pages (business letters, technical reports, etc), ! 55: at a resolution of 400 dpi: ! 56: binary: 2020 Kbytes CPU secs (to compress binary) ! 57: pack: 200 - 380 17 ! 58: bitfile(9.5): 150 - 360 ? ! 59: rle: 100 - 230 7.5 ! 60: compress: 90 - 155 14 ! 61: g31: 85 - 190 13 ! 62: g32: 55 - 110 13 ! 63: g4: 30 - 70 13 ! 64: G4-compressed files are 15-40X smaller than binary, 5X than bitfile(9.5), ! 65: 3.5X than rle, 2X than g31, and 2X than rle | pack. ! 66: */ ! 67: ! 68: #include <stdio.h> ! 69: #include <string.h> ! 70: #include <ctype.h> ! 71: #include "CPU.h" ! 72: #include "stdocr.h" ! 73: #include "rle.h" ! 74: #include "bitio.h" ! 75: #include "CCITT.h" ! 76: ! 77: #define DEBUG 0 /* 0 disables compilation of all debugging code; ! 78: 1 compiles, but must enable particular parts below */ ! 79: #define NEW_TRAIL 1 /* enable new trailing-0 counts (has passed early tests) */ ! 80: #define dbg_trail 0 ! 81: ! 82: DST_table *ccitt_table() ! 83: { DST_context cx; ! 84: if((cx.t = (DST_table *)malloc(sizeof(DST_table)))==NULL) ! 85: abort("CCITT.c: build_tbl: can't alloc cx.t"); ! 86: /* All tables have e[DST_white], e[DST_black], & e[DST_2d] entries */ ! 87: cx.t->mny=3; ! 88: if((cx.t->e=(DST_entry *)malloc(cx.t->mny*sizeof(DST_entry)))==NULL) ! 89: abort("CCITT.c: build_tbl: can't alloc cx.t->e[%d]",cx.t->mny); ! 90: ! 91: cx.s = cx.c = DST_white; ! 92: cx.l = 0; ! 93: cx.t->e[cx.s].p[0] = '\0'; ! 94: cx.t->e[cx.s].l = 0; ! 95: cx.t->e[cx.s].z = 0; ! 96: build_transits(cx); ! 97: ! 98: cx.s = cx.c = DST_black; ! 99: cx.l = 0; ! 100: cx.t->e[cx.s].p[0] = '\0'; ! 101: cx.t->e[cx.s].l = 0; ! 102: cx.t->e[cx.s].z = 0; ! 103: build_transits(cx); ! 104: ! 105: cx.s = cx.c = DST_2d; ! 106: cx.l = 0; ! 107: cx.t->e[cx.s].p[0] = '\0'; ! 108: cx.t->e[cx.s].l = 0; ! 109: cx.t->e[cx.s].z = 0; ! 110: build_transits(cx); ! 111: ! 112: #if DEBUG ! 113: if(F) ccitt_err_tbl(cx.t); ! 114: #endif ! 115: return(cx.t); ! 116: } ! 117: ! 118: DST_state new_state(t) ! 119: DST_table *t; ! 120: { t->mny++; ! 121: if((t->e=(DST_entry *)realloc(t->e,t->mny*sizeof(DST_entry)))==NULL) ! 122: abort("can't realloc t->[%d]",t->mny); ! 123: return(t->mny-1); ! 124: } ! 125: ! 126: /* The entry described by `cx' exists in the table, and its prefix `p' is ! 127: setup; create its transitions, and their next entries, recursively. */ ! 128: build_transits(cx) ! 129: DST_context cx; ! 130: #define entry cx.t->e[cx.s] ! 131: #define transit entry.t[col] ! 132: { DST_color col; ! 133: DST_entry ne; /* next entry */ ! 134: DST_context ncx; /* next Context */ ! 135: char **s,**ss; /* for searching code */ ! 136: short *c,*cs; ! 137: int si,matching,longer; ! 138: char svch,col_str[2]; ! 139: switch(cx.c) { ! 140: case DST_white: ! 141: ss=codewht; ! 142: cs=bitcwht; ! 143: break; ! 144: case DST_black: ! 145: ss=codeblk; ! 146: cs=bitcblk; ! 147: break; ! 148: case DST_2d: ! 149: ss=code2d; ! 150: cs=bitc2d; ! 151: break; ! 152: }; ! 153: for(col=0;col<=1;col++) { ! 154: sprintf(col_str,"%1d",col); ! 155: ncx = cx; ncx.l++; ! 156: /* build a transition */ ! 157: strcpy(ne.p,entry.p); strcat(ne.p,col_str); ! 158: ne.l = ncx.l; ! 159: if(col==0) ne.z = entry.z+1; else ne.z = 0; ! 160: /* count those that match new prefix */ ! 161: longer=matching=0; ! 162: for(s=ss,c=cs,si=0; (*s)!=NULL; s++,c++,si++) { ! 163: if(*c==ncx.l) { ! 164: if(strcmp(*s,ne.p)==0) { ! 165: matching++; ! 166: switch(cx.c) { ! 167: case DST_white: ! 168: case DST_black: ! 169: transit.a = itor(si); ! 170: break; ! 171: case DST_2d: ! 172: transit.a = si; ! 173: break; ! 174: }; ! 175: }; ! 176: } ! 177: else if(*c>ncx.l) { ! 178: svch=(*s)[ncx.l]; (*s)[ncx.l] = '\0'; ! 179: if(strcmp(*s,ne.p)==0) { ! 180: longer++; ! 181: }; ! 182: (*s)[ncx.l]=svch; ! 183: }; ! 184: }; ! 185: /* analyze results */ ! 186: if(matching==0&&longer>0) { ! 187: /* no match yet; go deeper */ ! 188: transit.a = DST_action_NULL; ! 189: ncx.s = transit.s = new_state(cx.t); ! 190: strcpy(cx.t->e[ncx.s].p,ne.p); ! 191: cx.t->e[ncx.s].l = ne.l; ! 192: cx.t->e[ncx.s].z = ne.z; ! 193: build_transits(ncx); ! 194: } ! 195: else if(matching==1&&longer==0) { ! 196: /* unique leaf: good */ ! 197: /* picked up action earlier */ ! 198: switch(cx.c) { ! 199: case DST_white: ! 200: case DST_black: ! 201: if(transit.a<=63) /* termination code */ ! 202: transit.s = flip_color(cx.c); ! 203: else /* makeup code */ ! 204: transit.s = cx.c; ! 205: break; ! 206: case DST_2d: ! 207: /* legal end of code */ ! 208: transit.s = DST_state_NULL; ! 209: break; ! 210: }; ! 211: } ! 212: else { /* illegal transition */ ! 213: transit.a = DST_action_ERROR; ! 214: transit.s = DST_state_NULL; ! 215: }; ! 216: }; ! 217: } ! 218: ! 219: ccitt_err_tbl(t) ! 220: DST_table *t; ! 221: { int d; ! 222: ccitt_err_state(DST_white,t); ! 223: ccitt_err_state(DST_black,t); ! 224: ccitt_err_state(DST_2d,t); ! 225: } ! 226: ! 227: ccitt_err_state(s,t) ! 228: DST_state s; ! 229: DST_table *t; ! 230: { err("%03d %s %2d %2d%*s %d %03d,%-4d %d %03d,%-4d", ! 231: s,t->e[s].p,t->e[s].l,t->e[s].z,14-strlen(t->e[s].p)," ", ! 232: 0,t->e[s].t[0].s,t->e[s].t[0].a, ! 233: 1,t->e[s].t[1].s,t->e[s].t[1].a ! 234: ); ! 235: if(t->e[s].t[0].s>1) ccitt_err_state(t->e[s].t[0].s,t); ! 236: if(t->e[s].t[1].s>1) ccitt_err_state(t->e[s].t[1].s,t); ! 237: } ! 238: ! 239: /* Translate a stream of bits in CCITT FAX Group 3 (1-D) compression format ! 240: into a sequence of RLE_Lines. Returns one (RLE_Line *) on each call (or NULL ! 241: if EOF or error). The first pixel (black or white) in each g31 line is ! 242: assigned run index 0. */ ! 243: RLE_Line *g31_to_rlel(t,f,bof) ! 244: DST_table *t; ! 245: BITFILE *f; ! 246: boolean bof; /* beginning of file */ ! 247: #define dbg_g31r_r (0) /* trace each run/EOL/ERR_SYN */ ! 248: #define dbg_g31r_c (0) /* trace each Huffman code (or, fill+EOL)*/ ! 249: #define dbg_g31r_t (0) /* trace each state-transition */ ! 250: { static DST_context cx; ! 251: static RLE_Line rl; ! 252: static RLE_Run *r; /* prior, current runs */ ! 253: int run,biti,sync,si,bitv; ! 254: boolean fill; ! 255: /* color of 1st run in each line */ ! 256: #define g31_first_color DST_white ! 257: /* reverse Black/White in output image */ ! 258: #define g31_negative 0 ! 259: if(bof){if(T) { /* sync by skipping initial FILL & EOL code */ ! 260: sync=0; while((bitv=getb(f))==0) sync++; ! 261: if(bitv!=1||sync<11) { ! 262: #if DEBUG ! 263: if(dbg_g31r_c) { ! 264: fprintf(stderr,"BOF_ERR "); ! 265: for(si=0;si<sync;si++) fprintf(stderr,"0"); ! 266: if(bitv==1) fprintf(stderr,"1\n"); ! 267: else fprintf(stderr,"?\n"); ! 268: }; ! 269: #endif ! 270: return(NULL); ! 271: } ! 272: #if DEBUG ! 273: else if(dbg_g31r_c){ ! 274: fprintf(stderr,"BOF_EOL "); ! 275: for(si=0;si<sync;si++) fprintf(stderr,"0"); ! 276: fprintf(stderr,"1\n"); ! 277: }; ! 278: #endif ! 279: }; ! 280: /* start file expecting a run-code of a fixed color */ ! 281: cx.s = cx.c = g31_first_color; ! 282: rl.y = -1; /* assume first line is y==0 */ ! 283: }; ! 284: rl.y++; rl.runs=0; r = rl.r; biti=run=0; ! 285: while(T) switch(getb(f)) { ! 286: case 0 : /* next bit is 0 */ ! 287: switch(t->e[cx.s].t[0].a) { ! 288: case DST_action_ERROR: ! 289: /* bad code: try to resynchronize */ ! 290: #if DEBUG ! 291: if(dbg_g31r_t){ ! 292: fprintf(stderr,"%s %04d %s0?...\n", ! 293: (cx.c==DST_white)? "W": "B", ! 294: t->e[cx.s].t[0].s, ! 295: t->e[cx.s].p); ! 296: }; ! 297: #endif ! 298: /* count trailing 0's so far (should be in table) */ ! 299: #if !NEW_TRAIL ! 300: sync=1; ! 301: si=strlen(t->e[cx.s].p)-1; ! 302: while(si>=0&&t->e[cx.s].p[si]=='0') {sync++; si--;}; ! 303: fill = (si<0); /* all 0's: may be fill bits */ ! 304: #else ! 305: sync=t->e[cx.s].z+1; ! 306: fill = (sync>t->e[cx.s].l); /* all 0's: maybe fill bits */ ! 307: #endif ! 308: #if DEBUG ! 309: if(dbg_trail) err("sync %d fill %d",sync,fill); ! 310: if(dbg_g31r_c)fprintf(stderr,"ERR_SYN %s0?",t->e[cx.s].p); ! 311: #endif ! 312: while(sync<11) { ! 313: switch(bitv=getb(f)) { ! 314: case 0: sync++; ! 315: #if DEBUG ! 316: if(dbg_g31r_c) fprintf(stderr,"0"); ! 317: #endif ! 318: break; ! 319: case 1: sync=0; fill=F; ! 320: #if DEBUG ! 321: if(dbg_g31r_c) fprintf(stderr,"1"); ! 322: #endif ! 323: break; ! 324: case EOF: ! 325: #if DEBUG ! 326: if(dbg_g31r_c) fprintf(stderr,"<EOF>\n"); ! 327: #endif ! 328: return(NULL); break; ! 329: }; ! 330: }; ! 331: /* next `1' will synchronize */ ! 332: do { switch(bitv=getb(f)) { ! 333: case 0: ! 334: #if DEBUG ! 335: if(dbg_g31r_c) fprintf(stderr,"0"); ! 336: #endif ! 337: break; ! 338: case 1: ! 339: #if DEBUG ! 340: if(dbg_g31r_c) fprintf(stderr,"1"); ! 341: #endif ! 342: break; ! 343: case EOF: ! 344: #if DEBUG ! 345: if(dbg_g31r_c) fprintf(stderr,"<EOF>\n"); ! 346: #endif ! 347: return(NULL); break; ! 348: }; ! 349: } ! 350: while(bitv!=1); ! 351: #if DEBUG ! 352: if(dbg_g31r_c) fprintf(stderr,"\n"); ! 353: if(dbg_g31r_r) { ! 354: if(fill) fprintf(stderr,"FILL_EOL\n"); ! 355: else fprintf(stderr,"ERR_SYN_EOL\n"); ! 356: }; ! 357: #endif ! 358: /* start next line expecting a run-code of a fixed color */ ! 359: cx.s = cx.c = g31_first_color; ! 360: return(&rl); ! 361: break; ! 362: case DST_action_NULL: ! 363: #if DEBUG ! 364: if(dbg_g31r_t)fprintf(stderr,"%s %04d %s0\n", ! 365: (cx.c==DST_white)? "W": "B", ! 366: t->e[cx.s].t[0].s, ! 367: t->e[cx.s].p); ! 368: #endif ! 369: cx.s = t->e[cx.s].t[0].s; ! 370: break; ! 371: case DST_EOL: ! 372: #if DEBUG ! 373: if(dbg_g31r_c)fprintf(stderr,"EOL %s0\n", ! 374: t->e[cx.s].p); ! 375: if(dbg_g31r_r)fprintf(stderr,"EOL\n"); ! 376: #endif ! 377: /* start next line expecting a run-code of a fixed color */ ! 378: cx.s = cx.c = g31_first_color; ! 379: return(&rl); ! 380: break; ! 381: default: ! 382: #if DEBUG ! 383: if(dbg_g31r_c)fprintf(stderr,"%s%6d %s0\n", ! 384: (cx.c==DST_white)? "W": "B", ! 385: t->e[cx.s].t[0].a, ! 386: t->e[cx.s].p); ! 387: #endif ! 388: if(t->e[cx.s].t[0].a<=63) { ! 389: run += t->e[cx.s].t[0].a; ! 390: #if DEBUG ! 391: if(dbg_g31r_r)fprintf(stderr,"%s%6d\n", ! 392: (cx.c==DST_white)? "W": "B", ! 393: run); ! 394: #endif ! 395: biti += run; ! 396: if(cx.c==DST_black^g31_negative) { ! 397: /* end of black run */ ! 398: r->xe = biti-1; ! 399: r++; rl.runs++; ! 400: } ! 401: else { /* end of white run */ ! 402: r->xs = biti; ! 403: }; ! 404: cx.c = flip_color(cx.c); ! 405: run = 0; ! 406: } ! 407: else run += t->e[cx.s].t[0].a; ! 408: cx.s = t->e[cx.s].t[0].s; ! 409: break; ! 410: }; ! 411: break; ! 412: case 1: /* next bit is 1 */ ! 413: switch(t->e[cx.s].t[1].a) { ! 414: case DST_action_ERROR: ! 415: /* bad code: try to resynchronize */ ! 416: #if DEBUG ! 417: if(dbg_g31r_t){ ! 418: fprintf(stderr,"%s %04d %s1?...\n", ! 419: (cx.c==DST_white)? "W": "B", ! 420: t->e[cx.s].t[1].s, ! 421: t->e[cx.s].p); ! 422: }; ! 423: if(dbg_g31r_c)fprintf(stderr,"ERR_SYN %s1?",t->e[cx.s].p); ! 424: #endif ! 425: /* no trailing 0's; can't be fill bits */ ! 426: sync=0; ! 427: while(sync<11) { ! 428: switch(bitv=getb(f)) { ! 429: case 0: sync++; ! 430: #if DEBUG ! 431: if(dbg_g31r_c) fprintf(stderr,"0"); ! 432: #endif ! 433: break; ! 434: case 1: sync=0; ! 435: #if DEBUG ! 436: if(dbg_g31r_c) fprintf(stderr,"1"); ! 437: #endif ! 438: break; ! 439: case EOF: ! 440: #if DEBUG ! 441: if(dbg_g31r_c) ! 442: fprintf(stderr,"<EOF>\n"); ! 443: #endif ! 444: return(NULL); break; ! 445: }; ! 446: }; ! 447: /* next `1' will synchronize */ ! 448: do { switch(bitv=getb(f)) { ! 449: case 0: ! 450: #if DEBUG ! 451: if(dbg_g31r_c) fprintf(stderr,"0"); ! 452: #endif ! 453: break; ! 454: case 1: ! 455: #if DEBUG ! 456: if(dbg_g31r_c) fprintf(stderr,"1"); ! 457: #endif ! 458: break; ! 459: case EOF: ! 460: #if DEBUG ! 461: if(dbg_g31r_c) ! 462: fprintf(stderr,"<EOF>\n"); ! 463: #endif ! 464: return(NULL); break; ! 465: }; ! 466: } ! 467: while(bitv!=1); ! 468: #if DEBUG ! 469: if(dbg_g31r_c) fprintf(stderr,"\n"); ! 470: if(dbg_g31r_r) fprintf(stderr,"ERR_SYN_EOL\n"); ! 471: #endif ! 472: /* start next line expecting a run-code of a fixed color */ ! 473: cx.s = cx.c = g31_first_color; ! 474: return(&rl); ! 475: break; ! 476: case DST_action_NULL: ! 477: #if DEBUG ! 478: if(dbg_g31r_t)fprintf(stderr,"%s %04d %s1\n", ! 479: (cx.c==DST_white)? "W": "B", ! 480: t->e[cx.s].t[1].s, ! 481: t->e[cx.s].p); ! 482: #endif ! 483: cx.s = t->e[cx.s].t[1].s; ! 484: break; ! 485: case DST_EOL: ! 486: #if DEBUG ! 487: if(dbg_g31r_c)fprintf(stderr,"EOL %s1\n", ! 488: t->e[cx.s].p); ! 489: if(dbg_g31r_r)fprintf(stderr,"EOL\n"); ! 490: #endif ! 491: /* start next line expecting a run-code of a fixed color */ ! 492: cx.s = cx.c = g31_first_color; ! 493: return(&rl); ! 494: break; ! 495: default: ! 496: #if DEBUG ! 497: if(dbg_g31r_c)fprintf(stderr,"%s%6d %s1\n", ! 498: (cx.c==DST_white)? "W": "B", ! 499: t->e[cx.s].t[1].a, ! 500: t->e[cx.s].p); ! 501: #endif ! 502: if(t->e[cx.s].t[1].a<=63) { ! 503: run += t->e[cx.s].t[1].a; ! 504: #if DEBUG ! 505: if(dbg_g31r_r)fprintf(stderr,"%s%6d\n", ! 506: (cx.c==DST_white)? "W": "B", ! 507: run); ! 508: #endif ! 509: biti += run; ! 510: if(cx.c==DST_black^g31_negative) { ! 511: /* end of black run */ ! 512: r->xe = biti-1; ! 513: r++; rl.runs++; ! 514: } ! 515: else { /* end of white run */ ! 516: r->xs = biti; ! 517: }; ! 518: cx.c = flip_color(cx.c); ! 519: run = 0; ! 520: } ! 521: else run += t->e[cx.s].t[1].a; ! 522: cx.s = t->e[cx.s].t[1].s; ! 523: break; ! 524: }; ! 525: break; ! 526: case EOF: ! 527: return(NULL); ! 528: break; ! 529: default: ! 530: return(NULL); ! 531: break; ! 532: }; ! 533: /* never come here: return() variously from cases above */ ! 534: } ! 535: ! 536: /* Translate a sequence of RLE_Line's (describing a binary image) ! 537: into a file (a stream of bits) in CCITT FAX Group 3 (1-D) compression format. ! 538: BOF_to_g31() must be called first; then call rlel_to_g31() for each line ! 539: (including blank lines); finally, EOF_to_g31() must be called. Each line's ! 540: EOL and the RTC's first EOL are padded so they end on a byte boundary. ! 541: */ ! 542: /* debugging flags: trace to stderr */ ! 543: #define dbg_rg31_e (0) /* entry */ ! 544: #define dbg_rg31_r (0) /* runs */ ! 545: #define dbg_rg31_s (0) /* bitstrings */ ! 546: ! 547: #if DEBUG ! 548: #define bits_g31(bits) { \ ! 549: cs=(bits); while(*cs!='\0') {putb(*cs-'0',f); cs++;}; \ ! 550: if(dbg_rg31_s) fprintf(stderr,"%s",(bits)); \ ! 551: if(dbg_rg31_r) fprintf(stderr," "); \ ! 552: } ! 553: #define EOL_g31 { \ ! 554: if(dbg_rg31_r) fprintf(stderr,"EOL "); \ ! 555: bits_g31(EOLSTRING); \ ! 556: if(dbg_rg31_r) fprintf(stderr,"\n"); \ ! 557: } ! 558: #else ! 559: #define bits_g31(bits) { \ ! 560: cs=(bits); while(*cs!='\0') {putb(*cs-'0',f); cs++;}; \ ! 561: } ! 562: #define EOL_g31 { \ ! 563: bits_g31(EOLSTRING); \ ! 564: } ! 565: #endif ! 566: ! 567: BOF_to_g31(f) ! 568: BITFILE *f; /* state of output bitfile */ ! 569: { char *cs; ! 570: EOL_g31; ! 571: } ! 572: ! 573: rlel_to_g31(rl,wid,f) ! 574: RLE_Line *rl; /* line of runs: if NULL, then blank */ ! 575: int wid; /* width of an output line in pixels */ ! 576: BITFILE *f; /* state of output bitfile */ ! 577: { int pi; /* input pixel index on line */ ! 578: RLE_Run *rp,*pp,*sp; ! 579: int runl,codi; ! 580: char *cs,*p01; ! 581: #if DEBUG ! 582: #define Wrun_g31(rn) { \ ! 583: runl=(rn); \ ! 584: if(dbg_rg31_r) fprintf(stderr,"W %5d ",runl); \ ! 585: while(runl>2560) {p01=codewht[rtoi(2560)]; bits_g31(p01); runl-=2560;}; \ ! 586: p01=codewht[codi=rtoi(runl)]; bits_g31(p01); \ ! 587: if(codi>=64) {p01=codewht[runl%64]; bits_g31(p01);}; \ ! 588: if(dbg_rg31_r) fprintf(stderr,"\n"); \ ! 589: } ! 590: #else ! 591: #define Wrun_g31(rn) { \ ! 592: runl=(rn); \ ! 593: while(runl>2560) {p01=codewht[rtoi(2560)]; bits_g31(p01); runl-=2560;}; \ ! 594: p01=codewht[codi=rtoi(runl)]; bits_g31(p01); \ ! 595: if(codi>=64) {p01=codewht[runl%64]; bits_g31(p01);}; \ ! 596: } ! 597: #endif ! 598: #if DEBUG ! 599: #define Brun_g31(rn) { \ ! 600: runl=(rn); \ ! 601: if(dbg_rg31_r) fprintf(stderr,"B %5d ",runl); \ ! 602: while(runl>2560) {p01=codeblk[rtoi(2560)]; bits_g31(p01); runl-=2560;}; \ ! 603: p01=codeblk[codi=rtoi(runl)]; bits_g31(p01); \ ! 604: if(codi>=64) {p01=codeblk[runl%64]; bits_g31(p01);}; \ ! 605: if(dbg_rg31_r) fprintf(stderr,"\n"); \ ! 606: } ! 607: ! 608: #else ! 609: #define Brun_g31(rn) { \ ! 610: runl=(rn); \ ! 611: while(runl>2560) {p01=codeblk[rtoi(2560)]; bits_g31(p01); runl-=2560;}; \ ! 612: p01=codeblk[codi=rtoi(runl)]; bits_g31(p01); \ ! 613: if(codi>=64) {p01=codeblk[runl%64]; bits_g31(p01);}; \ ! 614: } ! 615: #endif ! 616: #if DEBUG ! 617: if(dbg_rg31_e) err("rlel_to_g31(rl[y%d,r%d])",rl->y,rl->runs); ! 618: #endif ! 619: if(rl!=NULL&&rl->runs>0) { ! 620: pi=0; /* bit to write next */ ! 621: #if DEBUG ! 622: if(dbg_rg31_e) err("rlel_to_g31(rl[y%d,r%d])",rl->y,rl->runs); ! 623: #endif ! 624: for(sp=(rp=rl->r)+rl->runs; rp<sp; rp++) { ! 625: Wrun_g31(rp->xs-pi); pi=rp->xs; ! 626: Brun_g31(rp->xe-pi+1); pi=rp->xe+1; ! 627: }; ! 628: if((--rp)->xe+1<wid) Wrun_g31(wid-rp->xe-1); ! 629: } ! 630: else { ! 631: #if DEBUG ! 632: if(dbg_rg31_e) err("rlel_to_g31(rl[y?,r0])"); ! 633: #endif ! 634: Wrun_g31(wid); /* blank (all-white) scanline */ ! 635: }; ! 636: /* fill so that EOL ends on byte boundary */ ! 637: padb(f,0,8,EOLLENGTH); ! 638: #if DEBUG ! 639: if(dbg_rg31_s) fprintf(stderr,"+0?"); ! 640: #endif ! 641: EOL_g31; ! 642: } ! 643: ! 644: EOF_to_g31(f) ! 645: BITFILE *f; ! 646: { char *cs; ! 647: /* fill so that EOL ends on byte boundary */ ! 648: padb(f,0,8,EOLLENGTH); ! 649: #if DEBUG ! 650: if(dbg_rg31_s) fprintf(stderr,"+0?"); ! 651: #endif ! 652: /* write RTC */ ! 653: EOL_g31; ! 654: EOL_g31; ! 655: EOL_g31; ! 656: EOL_g31; ! 657: EOL_g31; ! 658: EOL_g31; ! 659: } ! 660: ! 661: /* Macro for use within g32_to_rlel, to read one 1-D Modified Huffman coded ! 662: run-length of a given color, placing the result in a given variable. ! 663: Exceptionally, goto trap_eol, trap_eof, or trap_code_err. ! 664: */ ! 665: #if DEBUG ! 666: #define g32_1d_run(C,V) { \ ! 667: run = 0; \ ! 668: do { cx.tr.s = (C); \ ! 669: do { px = cx; \ ! 670: switch(bitv=getb(f)) { \ ! 671: case 0 : cx.tr=t->e[cx.tr.s].t[0]; break; \ ! 672: case 1 : cx.tr=t->e[cx.tr.s].t[1]; break; \ ! 673: case EOF : goto trap_eof; break; \ ! 674: }; \ ! 675: } \ ! 676: while(cx.tr.a==DST_action_NULL); \ ! 677: switch(cx.tr.a) { \ ! 678: case DST_EOL : \ ! 679: if(dbg_g32r_c)fprintf(stderr,"EOL %s\n",EOLSTRING); \ ! 680: goto trap_eol; \ ! 681: break; \ ! 682: case DST_action_ERROR : goto trap_code_err; break; \ ! 683: default : \ ! 684: if(dbg_g32r_c)fprintf(stderr,"%s%6d %s%d\n", \ ! 685: ((C)==DST_white)? "W": "B", \ ! 686: cx.tr.a, \ ! 687: t->e[px.tr.s].p, \ ! 688: bitv); \ ! 689: run += cx.tr.a; \ ! 690: break; \ ! 691: }; \ ! 692: } \ ! 693: while(cx.tr.a>63); \ ! 694: (V) = run; \ ! 695: } ! 696: #else ! 697: #define g32_1d_run(C,V) { \ ! 698: run = 0; \ ! 699: do { cx.tr.s = (C); \ ! 700: do { px = cx; \ ! 701: switch(bitv=getb(f)) { \ ! 702: case 0 : cx.tr=t->e[cx.tr.s].t[0]; break; \ ! 703: case 1 : cx.tr=t->e[cx.tr.s].t[1]; break; \ ! 704: case EOF : goto trap_eof; break; \ ! 705: }; \ ! 706: } \ ! 707: while(cx.tr.a==DST_action_NULL); \ ! 708: switch(cx.tr.a) { \ ! 709: case DST_EOL : \ ! 710: goto trap_eol; \ ! 711: break; \ ! 712: case DST_action_ERROR : goto trap_code_err; break; \ ! 713: default : \ ! 714: run += cx.tr.a; \ ! 715: break; \ ! 716: }; \ ! 717: } \ ! 718: while(cx.tr.a>63); \ ! 719: (V) = run; \ ! 720: } ! 721: #endif ! 722: ! 723: /* Translate a stream of bits in CCITT FAX Group 3 (2-D) compression format ! 724: into a sequence of RLE_Lines. Returns one (RLE_Line *) on each call (or NULL ! 725: if EOF or error). The first pixel (black or white) in each g32 line is ! 726: assigned run index 0. */ ! 727: RLE_Line *g32_to_rlel(t,f,bof) ! 728: DST_table *t; ! 729: BITFILE *f; ! 730: boolean bof; /* beginning of file */ ! 731: #define dbg_g32r_e (0) /* entry/exit */ ! 732: #define dbg_g32r_r (0) /* trace each run/EOL/ERR_SYN */ ! 733: #define dbg_g32r_c (0) /* trace each Huffman code (or, fill+EOL)*/ ! 734: #define dbg_g32r_t (0) /* trace each state-transition */ ! 735: #define g32r_strict (1) /* 1 is CORRECT: explicitly code the last black pel */ ! 736: { static RLE_Line rl0,rl1,*prl,*crl; /* prior, current run-lines */ ! 737: RLE_Line *swrl; ! 738: int bitv; /* the last-read bit value */ ! 739: DST_context cx,px; /* the current/prior decoding context */ ! 740: RLE_Run *cr,*pr,*pre; /* into current/prior rle lines */ ! 741: RLE_Run *pra0; /* rightmost in prior line with xe<=a0 (if none: prl->r) */ ! 742: int run,sync,si,rtc_eols; ! 743: boolean fill; ! 744: /* pixel indices (0,1,...): current-line a*; prior-line b*. ! 745: a0 is the index of the most recently completely encoded bit */ ! 746: int a0,a1,a2,b1,b2; ! 747: DST_color a0_color; /* a0's color: same as a2 & b2, opposite of a1 & b1 */ ! 748: int a01,a12; /* lengths of runs a0-a1 & a1-a2 */ ! 749: #define g32_first_color DST_white /* color of 1st run in each line */ ! 750: #define g32_negative (0) /* if 1, invert Black/White on output */ ! 751: #define swap_rl(f,b) {swrl=(f); (f)=(b); (b)=swrl;} ! 752: /* detect b1 & b2: sensitive to a0, a0_color, and prior runs *pr *(pr+1) */ ! 753: #define g32r_find_Bb1Wb2 { \ ! 754: /* find 1st black changing pel>a0 */ \ ! 755: /* advance pra0 as far as possible s.t. pra0->xe<=a0 */ \ ! 756: while((pra0+1)<pre && (pra0+1)->xe<=a0) pra0++; \ ! 757: /* look beyond pra0 */ \ ! 758: pr=pra0; while(pr<pre && (b1=pr->xs)<=a0) pr++; \ ! 759: /* move b2 to 1st changing white pel > b1 */ \ ! 760: if(pr<pre) b2=pr->xe+1; \ ! 761: else b1=b2=prl->len; \ ! 762: } ! 763: #define g32r_find_Wb1Bb2 { \ ! 764: /* find 1st white changing pel>a0 */ \ ! 765: /* advance pra0 as far as possible s.t. pra0->xe<=a0 */ \ ! 766: while((pra0+1)<pre && (pra0+1)->xe<=a0) pra0++; \ ! 767: /* look beyond pra0 */ \ ! 768: pr=pra0; while(pr<pre && (b1=pr->xe+1)<=a0) pr++; \ ! 769: /* move b2 to 1st changing black pel > b1 */ \ ! 770: if(pr<pre) { \ ! 771: if((pr+1)<pre) b2=(pr+1)->xs; \ ! 772: else b2=prl->len; \ ! 773: } \ ! 774: else b1=b2=prl->len; \ ! 775: } ! 776: #define g32r_find_b1b2 {if(a0_color==DST_white) g32r_find_Bb1Wb2 else g32r_find_Wb1Bb2;} ! 777: ! 778: #if DEBUG ! 779: if(dbg_g32r_e) fprintf(stderr,"g32_to_rlel(t,bf,bof%d)\n",bof); ! 780: #endif ! 781: if(bof){crl= &rl0; crl->y= -1; crl->len=0; crl->runs=0; ! 782: prl= &rl1; prl->y= -1; prl->len=0; prl->runs=0; ! 783: /* sync by skipping initial FILL & EOL code */ ! 784: sync=0; while((bitv=getb(f))==0) sync++; ! 785: if(bitv!=1||sync<11) { ! 786: #if DEBUG ! 787: if(dbg_g32r_c) { ! 788: fprintf(stderr,"BOF_ERR "); ! 789: for(si=0;si<sync;si++) fprintf(stderr,"0"); ! 790: if(bitv==1) fprintf(stderr,"1\n"); ! 791: else fprintf(stderr,"?\n"); ! 792: }; ! 793: #endif ! 794: return(NULL); ! 795: } ! 796: #if DEBUG ! 797: else if(dbg_g32r_c){ ! 798: fprintf(stderr,"BOF_EOL "); ! 799: for(si=0;si<sync;si++) fprintf(stderr,"0"); ! 800: fprintf(stderr,"1\n"); ! 801: }; ! 802: #else ! 803: ; ! 804: #endif ! 805: prl->y = -1; crl->y = 0; ! 806: } ! 807: else crl->y = prl->y + 1; ! 808: ! 809: pre = (pra0=pr=prl->r) + prl->runs; /* prior line */ ! 810: crl->runs=0; cr=crl->r-1; /* current line */ ! 811: /* start on an imaginary white pixel just to left of margin */ ! 812: a0= -1; a0_color = DST_white; ! 813: ! 814: /* check 1-D / 2-D bit immediately after prior EOL */ ! 815: switch(bitv=getb(f)) { ! 816: case 0 : /* 2-dimensionally encoded line */ ! 817: #if DEBUG ! 818: if(dbg_g32r_c) fprintf(stderr,"2D_LINE 0\n"); ! 819: #endif ! 820: /* start b1/b2 on prior line's first black pixel, etc; ! 821: if none, then place off end of line */ ! 822: if(pr<pre) {b1=pr->xs; b2=pr->xe+1;} else b1=b2=prl->len; ! 823: /* parse a sequence of 2D codes... */ ! 824: while(T/* exited only via goto trap_* and return */) { ! 825: cx.tr.s = DST_2d; cx.tr.a = DST_action_NULL; ! 826: #if DEBUG ! 827: if(dbg_g32r_t)fprintf(stderr,"(%d,%d)\n",cx.tr.s,cx.tr.a); ! 828: #endif ! 829: do { switch(bitv=getb(f)) { ! 830: case 0 : ! 831: case 1 : ! 832: cx.tr=t->e[cx.tr.s].t[bitv]; ! 833: break; ! 834: case EOF: goto trap_eof; break; ! 835: }; ! 836: #if DEBUG ! 837: if(dbg_g32r_t)fprintf(stderr,"%d->(%d,%d)\n", ! 838: bitv,cx.tr.s,cx.tr.a); ! 839: #endif ! 840: } ! 841: while(cx.tr.a==DST_action_NULL); ! 842: #if DEBUG ! 843: if(dbg_g32r_t)fprintf(stderr,"%s %04d %s0\n", ! 844: (cx.c==DST_white)? "W": "B", ! 845: cx.tr.s, ! 846: t->e[cx.tr.s].p); ! 847: #endif ! 848: switch(cx.tr.a) { ! 849: case i2D_V0: ! 850: #if DEBUG ! 851: if(dbg_g32r_c) ! 852: fprintf(stderr,"V0 %s\n",code2d[cx.tr.a]); ! 853: #endif ! 854: a1=b1; ! 855: /* encode a0 to a1-1 */ ! 856: if(a0_color==DST_black) cr->xe=a1-1; ! 857: /* move a0 to a1 */ ! 858: a0=a1; if(a0>=prl->len) goto trap_expecting_eol; ! 859: a0_color = flip_color(a0_color); ! 860: /* encode a0 */ ! 861: if(a0_color==DST_black) ! 862: { crl->runs++; (++cr)->xs = a0; cr->xe = a0; }; ! 863: #if g32r_strict ! 864: if(a0==prl->len-1) ! 865: { a0++; goto trap_expecting_eol; }; ! 866: #endif ! 867: g32r_find_b1b2; ! 868: break; ! 869: case i2D_VR1: ! 870: #if DEBUG ! 871: if(dbg_g32r_c) ! 872: fprintf(stderr,"VR1 %s\n",code2d[cx.tr.a]); ! 873: #endif ! 874: a1=b1+1; ! 875: /* encode a0 to a1-1 */ ! 876: if(a0_color==DST_black) cr->xe=a1-1; ! 877: /* move a0 to a1 */ ! 878: a0=a1; if(a0>=prl->len) goto trap_expecting_eol; ! 879: a0_color = flip_color(a0_color); ! 880: /* encode a0 */ ! 881: if(a0_color==DST_black) ! 882: { crl->runs++; (++cr)->xs = a0; cr->xe = a0; }; ! 883: #if !g32r_strict ! 884: if(a0==prl->len-1) ! 885: { a0++; goto trap_expecting_eol; }; ! 886: #endif ! 887: g32r_find_b1b2; ! 888: break; ! 889: case i2D_VR2: ! 890: #if DEBUG ! 891: if(dbg_g32r_c) ! 892: fprintf(stderr,"VR2 %s\n",code2d[cx.tr.a]); ! 893: #endif ! 894: a1=b1+2; ! 895: /* encode a0 to a1-1 */ ! 896: if(a0_color==DST_black) cr->xe=a1-1; ! 897: /* move a0 to a1 */ ! 898: a0=a1; if(a0>=prl->len) goto trap_expecting_eol; ! 899: a0_color = flip_color(a0_color); ! 900: /* encode a0 */ ! 901: if(a0_color==DST_black) ! 902: { crl->runs++; (++cr)->xs = a0; cr->xe = a0; }; ! 903: #if !g32r_strict ! 904: if(a0==prl->len-1) ! 905: { a0++; goto trap_expecting_eol; }; ! 906: #endif ! 907: g32r_find_b1b2; ! 908: break; ! 909: case i2D_VR3: ! 910: #if DEBUG ! 911: if(dbg_g32r_c) ! 912: fprintf(stderr,"VR3 %s\n",code2d[cx.tr.a]); ! 913: #endif ! 914: a1=b1+3; ! 915: /* encode a0 to a1-1 */ ! 916: if(a0_color==DST_black) cr->xe=a1-1; ! 917: /* move a0 to a1 */ ! 918: a0=a1; if(a0>=prl->len) goto trap_expecting_eol; ! 919: a0_color = flip_color(a0_color); ! 920: /* encode a0 */ ! 921: if(a0_color==DST_black) ! 922: { crl->runs++; (++cr)->xs = a0; cr->xe = a0; }; ! 923: #if !g32r_strict ! 924: if(a0==prl->len-1) ! 925: { a0++; goto trap_expecting_eol; }; ! 926: #endif ! 927: g32r_find_b1b2; ! 928: break; ! 929: case i2D_VL1: ! 930: #if DEBUG ! 931: if(dbg_g32r_c) ! 932: fprintf(stderr,"VL1 %s\n",code2d[cx.tr.a]); ! 933: #endif ! 934: if((a1=b1-1)<0) err("g32_to_rlel: VL1 backs up to %d",a1); ! 935: /* encode a0 to a1-1 */ ! 936: if(a0_color==DST_black) cr->xe=a1-1; ! 937: /* move a0 to a1 */ ! 938: a0=a1; if(a0>=prl->len) goto trap_expecting_eol; ! 939: a0_color = flip_color(a0_color); ! 940: /* encode a0 */ ! 941: if(a0_color==DST_black) ! 942: { crl->runs++; (++cr)->xs = a0; cr->xe = a0; }; ! 943: #if !g32_strict ! 944: if(a0==prl->len-1) ! 945: { a0++; goto trap_expecting_eol; }; ! 946: #endif ! 947: g32r_find_b1b2; ! 948: break; ! 949: case i2D_VL2: ! 950: #if DEBUG ! 951: if(dbg_g32r_c) ! 952: fprintf(stderr,"VL2 %s\n",code2d[cx.tr.a]); ! 953: #endif ! 954: if((a1=b1-2)<0) err("g32_to_rlel: VL2 backs up to %d",a1); ! 955: /* encode a0 to a1-1 */ ! 956: if(a0_color==DST_black) cr->xe=a1-1; ! 957: /* move a0 to a1 */ ! 958: a0=a1; if(a0>=prl->len) goto trap_expecting_eol; ! 959: a0_color = flip_color(a0_color); ! 960: /* encode a0 */ ! 961: if(a0_color==DST_black) ! 962: { crl->runs++; (++cr)->xs = a0; cr->xe = a0; }; ! 963: #if !g32r_strict ! 964: if(a0==prl->len-1) ! 965: { a0++; goto trap_expecting_eol; }; ! 966: #endif ! 967: g32r_find_b1b2; ! 968: break; ! 969: case i2D_VL3: ! 970: #if DEBUG ! 971: if(dbg_g32r_c) ! 972: fprintf(stderr,"VL3 %s\n",code2d[cx.tr.a]); ! 973: #endif ! 974: if((a1=b1-3)<0) err("g32_to_rlel: VL3 backs up to %d",a1); ! 975: /* encode a0 to a1-1 */ ! 976: if(a0_color==DST_black) cr->xe=a1-1; ! 977: /* move a0 to a1 */ ! 978: a0=a1; if(a0>=prl->len) goto trap_expecting_eol; ! 979: a0_color = flip_color(a0_color); ! 980: /* encode a0 */ ! 981: if(a0_color==DST_black) ! 982: { crl->runs++; (++cr)->xs = a0; cr->xe = a0; }; ! 983: #if !g32r_strict ! 984: if(a0==prl->len-1) ! 985: { a0++; goto trap_expecting_eol; }; ! 986: #endif ! 987: g32r_find_b1b2; ! 988: break; ! 989: case i2D_PASS: ! 990: #if DEBUG ! 991: if(dbg_g32r_c) ! 992: fprintf(stderr,"PASS %s\n",code2d[cx.tr.a]); ! 993: #endif ! 994: /* move a0 to b2; no change of color */ ! 995: a0=b2; if(a0>=prl->len) goto trap_expecting_eol; ! 996: if(a0_color==DST_black) cr->xe = a0; ! 997: #if !g32r_strict ! 998: if(a0==prl->len-1) ! 999: { a0++; goto trap_expecting_eol; }; ! 1000: #endif ! 1001: g32r_find_b1b2; ! 1002: break; ! 1003: case i2D_HORIZ: ! 1004: #if DEBUG ! 1005: if(dbg_g32r_c) ! 1006: fprintf(stderr,"HORIZ %s\n",code2d[cx.tr.a]); ! 1007: #endif ! 1008: if(a0_color==DST_white) { ! 1009: if(a0<0) a0=0; /* first run in line starts at 0 */ ! 1010: g32_1d_run(DST_white,a01); a1 = a0 + a01; ! 1011: g32_1d_run(DST_black,a12); a2 = a1 + a12; ! 1012: if(a12>0) /* Black run of >0 length */ { ! 1013: crl->runs++; ! 1014: (++cr)->xs = a1; ! 1015: cr->xe = a2-1; ! 1016: }; ! 1017: a0 = a2; /* still white */ ! 1018: if(a0>=prl->len) goto trap_expecting_eol; ! 1019: /* encode a0 */ ! 1020: #if !g32r_strict ! 1021: if(a0==prl->len-1) ! 1022: { a0++; goto trap_expecting_eol; }; ! 1023: #endif ! 1024: g32r_find_Bb1Wb2; ! 1025: } ! 1026: else { g32_1d_run(DST_black,a01); a1 = a0 + a01; ! 1027: g32_1d_run(DST_white,a12); a2 = a1 + a12; ! 1028: if(a01>0) /* Black run of >0 length */ { ! 1029: cr->xe = a1 - 1; ! 1030: } ! 1031: else { /* 0-length: very peculiar: ignore */ ! 1032: fprintf(stderr, ! 1033: "g32_to_rlel: HORIZ B%d! W%d - ignore\n", ! 1034: a01,a12); ! 1035: cr--; crl->runs--; ! 1036: }; ! 1037: a0 = a2; /* still black */ ! 1038: if(a0>=prl->len) goto trap_expecting_eol; ! 1039: /* encode a0 */ ! 1040: crl->runs++; (++cr)->xs = a0; ! 1041: #if !g32r_strict ! 1042: if(a0==prl->len-1) { ! 1043: cr->xe = a0; ! 1044: a0++; ! 1045: goto trap_expecting_eol; ! 1046: }; ! 1047: #endif ! 1048: g32r_find_Wb1Bb2; ! 1049: }; ! 1050: break; ! 1051: case i2D_EOL: ! 1052: #if DEBUG ! 1053: if(dbg_g32r_c) ! 1054: fprintf(stderr,"EOL %s\n",code2d[cx.tr.a]); ! 1055: #endif ! 1056: goto trap_eol; ! 1057: break; ! 1058: case DST_action_ERROR: goto trap_code_err; break; ! 1059: }; ! 1060: }; ! 1061: break; ! 1062: case 1 : /* 1-dimensionally encoded line */ ! 1063: #if DEBUG ! 1064: if(dbg_g32r_c) fprintf(stderr,"1D_LINE 1\n"); ! 1065: #endif ! 1066: /* read a sequence of 1-D runcodes... */ ! 1067: while(T/* exit only via goto trap_X */) { ! 1068: g32_1d_run(a0_color,a01); ! 1069: a1 = ((a0>=0)? a0 : 0) + a01; ! 1070: if(a01>0) { ! 1071: /* encode a0 through a1-1 */ ! 1072: if(a0_color==DST_black^g32_negative) { ! 1073: /* output-black run */ ! 1074: crl->runs++; ! 1075: (++cr)->xs=((a0>=0)? a0 : 0); ! 1076: cr->xe=a1-1; ! 1077: }; ! 1078: }; ! 1079: a0=a1; ! 1080: a0_color=flip_color(a0_color); ! 1081: if(prl->len>0 && a0>=prl->len) goto trap_expecting_eol; ! 1082: }; ! 1083: break; ! 1084: case EOF : goto trap_eof; break; ! 1085: }; ! 1086: ! 1087: /* come here via goto's: all these traps return() */ ! 1088: ! 1089: trap_expecting_eol: /* come here expecting to see EOL or FILL+EOL */ ! 1090: sync=0; while((bitv=getb(f))==0) sync++; ! 1091: switch(bitv) { ! 1092: case 1: ! 1093: if(sync==11) { ! 1094: #if DEBUG ! 1095: if(dbg_g32r_c){ ! 1096: fprintf(stderr,"EOL %s\n",EOLSTRING); ! 1097: }; ! 1098: #endif ! 1099: goto trap_eol; ! 1100: } ! 1101: else if(sync>11) { ! 1102: #if DEBUG ! 1103: if(dbg_g32r_c){ ! 1104: fprintf(stderr,"FILLEOL "); ! 1105: for(si=0;si<sync-11;si++) fprintf(stderr,"0"); ! 1106: fprintf(stderr,"+"); ! 1107: fprintf(stderr,"%s\n",EOLSTRING); ! 1108: }; ! 1109: #endif ! 1110: goto trap_eol; ! 1111: } ! 1112: else { ! 1113: #if DEBUG ! 1114: if(dbg_g32r_c){ ! 1115: fprintf(stderr,"NOT EOL "); ! 1116: for(si=0;si<sync;si++) fprintf(stderr,"0"); ! 1117: fprintf(stderr,"1?"); ! 1118: }; ! 1119: #endif ! 1120: sync=0; ! 1121: goto trap_eol_err; ! 1122: }; ! 1123: break; ! 1124: case EOF: goto trap_eof; break; ! 1125: }; ! 1126: goto trap_eol; ! 1127: ! 1128: trap_code_err: ! 1129: /* unexpected coding sequence: ! 1130: 'px' holds last decoding context & 'bitv' latest bit value; ! 1131: will attempt to resynchronize on next EOL */ ! 1132: #if DEBUG ! 1133: if(dbg_g32r_c)fprintf(stderr,"CODERR %s%d?", ! 1134: t->e[px.tr.s].p,bitv); ! 1135: #endif ! 1136: /* count trailing 0's so far (should be in table) */ ! 1137: #if !NEW_TRAIL ! 1138: if(bitv==0) sync=1; else sync=0; ! 1139: si=strlen(t->e[px.tr.s].p)-1; ! 1140: while(si>=0&&t->e[px.tr.s].p[si]=='0') {sync++; si--;}; ! 1141: fill = (si<0); /* all 0's: may be fill bits */ ! 1142: #else ! 1143: if(bitv==0) sync=t->e[px.tr.s].z+1; else sync=t->e[px.tr.s].z; ! 1144: fill = (sync>t->e[px.tr.s].l); /* all 0's: maybe fill bits */ ! 1145: #endif ! 1146: #if DEBUG ! 1147: if(dbg_trail)err("sync %d fill %d",sync,fill); ! 1148: #endif ! 1149: trap_eol_err: ! 1150: while(sync<11) { ! 1151: switch(bitv=getb(f)) { ! 1152: case 0: sync++; ! 1153: #if DEBUG ! 1154: if(dbg_g32r_c) fprintf(stderr,"0"); ! 1155: #endif ! 1156: break; ! 1157: case 1: sync=0; ! 1158: #if DEBUG ! 1159: if(dbg_g32r_c) fprintf(stderr,"1"); ! 1160: #endif ! 1161: break; ! 1162: case EOF: goto trap_eof; break; ! 1163: }; ! 1164: }; ! 1165: /* next `1' will synchronize */ ! 1166: do { switch(bitv=getb(f)) { ! 1167: case 0: ! 1168: #if DEBUG ! 1169: if(dbg_g32r_c) fprintf(stderr,"0"); ! 1170: #endif ! 1171: break; ! 1172: case 1: ! 1173: #if DEBUG ! 1174: if(dbg_g32r_c) fprintf(stderr,"1"); ! 1175: #endif ! 1176: break; ! 1177: case EOF: goto trap_eof; break; ! 1178: }; ! 1179: } ! 1180: while(bitv!=1); ! 1181: #if DEBUG ! 1182: if(dbg_g32r_c) fprintf(stderr," EOL\n"); ! 1183: #endif ! 1184: goto trap_eol; ! 1185: ! 1186: trap_eol: /* come here having seen (and reported) EOL */ ! 1187: /* learn/check line-length */ ! 1188: if(a0>=0) crl->len=a0; else crl->len=0; ! 1189: if(crl->len==0) { ! 1190: /* no pixels coded -- may be the 1st of 6 RTC EOLs */ ! 1191: /* check suffix 1 bit */ ! 1192: if((bitv=getb(f))!=1) goto trap_eol_err; ! 1193: rtc_eols=1; ! 1194: #if DEBUG ! 1195: if(dbg_g32r_c)fprintf(stderr,"RTC_EOL +1 (%d)\n",rtc_eols); ! 1196: #endif ! 1197: do { sync=0; while((bitv=getb(f))==0) sync++; ! 1198: switch(bitv) { ! 1199: case 1: ! 1200: if(sync<11) { ! 1201: #if DEBUG ! 1202: if(dbg_g32r_c){ ! 1203: fprintf(stderr,"NOT RTC "); ! 1204: for(si=0;si<sync;si++) ! 1205: fprintf(stderr,"0"); ! 1206: fprintf(stderr,"1?\n"); ! 1207: }; ! 1208: #endif ! 1209: sync=0; ! 1210: goto trap_eol_err; ! 1211: }; ! 1212: break; ! 1213: case EOF: goto trap_eof; break; ! 1214: }; ! 1215: /* check suffix 1 bit */ ! 1216: if((bitv=getb(f))!=1) goto trap_eol_err; ! 1217: rtc_eols++; ! 1218: #if DEBUG ! 1219: if(dbg_g32r_c) { ! 1220: fprintf(stderr,"RTC_EOL "); ! 1221: for(si=0;si<sync;si++) fprintf(stderr,"0"); ! 1222: fprintf(stderr,"1+1 (%d)\n",rtc_eols); ! 1223: }; ! 1224: #endif ! 1225: } ! 1226: while(rtc_eols<6); ! 1227: /* normal RTC */ ! 1228: #if DEBUG ! 1229: if(dbg_g32r_c)fprintf(stderr,"RTC\n"); ! 1230: #endif ! 1231: return(NULL); ! 1232: } ! 1233: else if(prl->len==0) { ! 1234: #if DEBUG ! 1235: if(dbg_g32r_c)fprintf(stderr,"LINELEN %d\n",crl->len); ! 1236: #endif ! 1237: } ! 1238: else if(crl->len!=prl->len) { ! 1239: err("g32_to_rlel: y%d: LINELEN changes c%d != p%d ? (force to %d)", ! 1240: crl->y,crl->len,prl->len,prl->len); ! 1241: crl->len = prl->len; ! 1242: }; ! 1243: swap_rl(crl,prl); ! 1244: return(prl); ! 1245: ! 1246: trap_eof: ! 1247: #if DEBUG ! 1248: if(dbg_g32r_c) fprintf(stderr,"<EOF>\n"); ! 1249: #endif ! 1250: return(NULL); ! 1251: ! 1252: } ! 1253: ! 1254: /* Translate a sequence of RLE_Line's (describing a binary image) ! 1255: into a file (a stream of bits) in CCITT FAX Group 3 (2-D) compression format. ! 1256: BOF_to_g32() must be called first; then call rlel_to_g32() for each line ! 1257: (including blank lines); finally, EOF_to_g32() must be called. Each line's ! 1258: EOL and the RTC's first EOL will be padded so they end on a byte boundary. ! 1259: */ ! 1260: /* debugging flags: trace to stderr */ ! 1261: #define dbg_rg32_e (0) /* entry */ ! 1262: #define dbg_rg32_r (0) /* runs */ ! 1263: #define dbg_rg32_s (0) /* bitstrings */ ! 1264: #define rg32_strict (1) /* 1 is CORRECT: explicitly code the last black pel */ ! 1265: ! 1266: #if DEBUG ! 1267: #define bits_g32(bits) { \ ! 1268: cs=(bits); while(*cs!='\0') {putb(*cs-'0',f); cs++;}; \ ! 1269: if(dbg_rg32_s) fprintf(stderr,"%s",(bits)); \ ! 1270: if(dbg_rg32_r) fprintf(stderr," "); \ ! 1271: } ! 1272: #else ! 1273: #define bits_g32(bits) { \ ! 1274: cs=(bits); while(*cs!='\0') {putb(*cs-'0',f); cs++;}; \ ! 1275: } ! 1276: #endif ! 1277: #if DEBUG ! 1278: #define EOL_g32 { \ ! 1279: if(dbg_rg32_r) fprintf(stderr,"EOL "); \ ! 1280: bits_g32(EOLSTRING); \ ! 1281: if(dbg_rg32_r) fprintf(stderr,"\n"); \ ! 1282: } ! 1283: #else ! 1284: #define EOL_g32 { \ ! 1285: bits_g32(EOLSTRING); \ ! 1286: } ! 1287: #endif ! 1288: ! 1289: BOF_to_g32(f) ! 1290: BITFILE *f; ! 1291: { char *cs; ! 1292: /* a NOP: no header for Group 3 (2-D) */ ! 1293: #if DEBUG ! 1294: if(dbg_rg32_e) fprintf(stderr,"BOF\n"); ! 1295: #endif ! 1296: }; ! 1297: ! 1298: rlel_to_g32(pl,cl,wid,f) ! 1299: RLE_Line *pl; /* prior "reference" line: if NULL, use 1-D coding on cl */ ! 1300: RLE_Line *cl; /* current "coding" line: if NULL, is blank (all white) */ ! 1301: int wid; /* width of an output line in pixels */ ! 1302: BITFILE *f; ! 1303: { int runl,codi; ! 1304: char *cs,*p01; ! 1305: #if DEBUG ! 1306: #define Wrun_g32(rn) { \ ! 1307: runl=(rn); \ ! 1308: if(dbg_rg32_r) fprintf(stderr,"W %5d ",runl); \ ! 1309: while(runl>2560) {p01=codewht[rtoi(2560)]; bits_g32(p01); runl-=2560;}; \ ! 1310: p01=codewht[codi=rtoi(runl)]; bits_g32(p01); \ ! 1311: if(codi>=64) {p01=codewht[runl%64]; bits_g32(p01);}; \ ! 1312: if(dbg_rg32_r) fprintf(stderr,"\n"); \ ! 1313: } ! 1314: #else ! 1315: #define Wrun_g32(rn) { \ ! 1316: runl=(rn); \ ! 1317: while(runl>2560) {p01=codewht[rtoi(2560)]; bits_g32(p01); runl-=2560;}; \ ! 1318: p01=codewht[codi=rtoi(runl)]; bits_g32(p01); \ ! 1319: if(codi>=64) {p01=codewht[runl%64]; bits_g32(p01);}; \ ! 1320: } ! 1321: #endif ! 1322: #if DEBUG ! 1323: #define Brun_g32(rn) { \ ! 1324: runl=(rn); \ ! 1325: if(dbg_rg32_r) fprintf(stderr,"B %5d ",runl); \ ! 1326: while(runl>2560) {p01=codeblk[rtoi(2560)]; bits_g32(p01); runl-=2560;}; \ ! 1327: p01=codeblk[codi=rtoi(runl)]; bits_g32(p01); \ ! 1328: if(codi>=64) {p01=codeblk[runl%64]; bits_g32(p01);}; \ ! 1329: if(dbg_rg32_r) fprintf(stderr,"\n"); \ ! 1330: } ! 1331: #else ! 1332: #define Brun_g32(rn) { \ ! 1333: runl=(rn); \ ! 1334: while(runl>2560) {p01=codeblk[rtoi(2560)]; bits_g32(p01); runl-=2560;}; \ ! 1335: p01=codeblk[codi=rtoi(runl)]; bits_g32(p01); \ ! 1336: if(codi>=64) {p01=codeblk[runl%64]; bits_g32(p01);}; \ ! 1337: } ! 1338: #endif ! 1339: #if DEBUG ! 1340: #define V0_g32 { \ ! 1341: if(dbg_rg32_r) fprintf(stderr,"V0 "); \ ! 1342: bits_g32(code2d[i2D_V0]); \ ! 1343: if(dbg_rg32_r) fprintf(stderr,"\n"); \ ! 1344: } ! 1345: #else ! 1346: #define V0_g32 { \ ! 1347: bits_g32(code2d[i2D_V0]); \ ! 1348: } ! 1349: #endif ! 1350: #if DEBUG ! 1351: #define VR1_g32 { \ ! 1352: if(dbg_rg32_r) fprintf(stderr,"VR1 "); \ ! 1353: bits_g32(code2d[i2D_VR1]); \ ! 1354: if(dbg_rg32_r) fprintf(stderr,"\n"); \ ! 1355: } ! 1356: #else ! 1357: #define VR1_g32 { \ ! 1358: bits_g32(code2d[i2D_VR1]); \ ! 1359: } ! 1360: #endif ! 1361: #if DEBUG ! 1362: #define VR2_g32 { \ ! 1363: if(dbg_rg32_r) fprintf(stderr,"VR2 "); \ ! 1364: bits_g32(code2d[i2D_VR2]); \ ! 1365: if(dbg_rg32_r) fprintf(stderr,"\n"); \ ! 1366: } ! 1367: #else ! 1368: #define VR2_g32 { \ ! 1369: bits_g32(code2d[i2D_VR2]); \ ! 1370: } ! 1371: #endif ! 1372: #if DEBUG ! 1373: #define VR3_g32 { \ ! 1374: if(dbg_rg32_r) fprintf(stderr,"VR3 "); \ ! 1375: bits_g32(code2d[i2D_VR3]); \ ! 1376: if(dbg_rg32_r) fprintf(stderr,"\n"); \ ! 1377: } ! 1378: #else ! 1379: #define VR3_g32 { \ ! 1380: bits_g32(code2d[i2D_VR3]); \ ! 1381: } ! 1382: #endif ! 1383: #if DEBUG ! 1384: #define VL1_g32 { \ ! 1385: if(dbg_rg32_r) fprintf(stderr,"VL1 "); \ ! 1386: bits_g32(code2d[i2D_VL1]); \ ! 1387: if(dbg_rg32_r) fprintf(stderr,"\n"); \ ! 1388: } ! 1389: #else ! 1390: #define VL1_g32 { \ ! 1391: bits_g32(code2d[i2D_VL1]); \ ! 1392: } ! 1393: #endif ! 1394: #if DEBUG ! 1395: #define VL2_g32 { \ ! 1396: if(dbg_rg32_r) fprintf(stderr,"VL2 "); \ ! 1397: bits_g32(code2d[i2D_VL2]); \ ! 1398: if(dbg_rg32_r) fprintf(stderr,"\n"); \ ! 1399: } ! 1400: #else ! 1401: #define VL2_g32 { \ ! 1402: bits_g32(code2d[i2D_VL2]); \ ! 1403: } ! 1404: #endif ! 1405: #if DEBUG ! 1406: #define VL3_g32 { \ ! 1407: if(dbg_rg32_r) fprintf(stderr,"VL3 "); \ ! 1408: bits_g32(code2d[i2D_VL3]); \ ! 1409: if(dbg_rg32_r) fprintf(stderr,"\n"); \ ! 1410: } ! 1411: #else ! 1412: #define VL3_g32 { \ ! 1413: bits_g32(code2d[i2D_VL3]); \ ! 1414: } ! 1415: #endif ! 1416: #if DEBUG ! 1417: #define PASS_g32 { \ ! 1418: if(dbg_rg32_r) fprintf(stderr,"PASS "); \ ! 1419: bits_g32(code2d[i2D_PASS]); \ ! 1420: if(dbg_rg32_r) fprintf(stderr,"\n"); \ ! 1421: } ! 1422: #else ! 1423: #define PASS_g32 { \ ! 1424: bits_g32(code2d[i2D_PASS]); \ ! 1425: } ! 1426: #endif ! 1427: #if DEBUG ! 1428: #define HORIZ_g32 { \ ! 1429: if(dbg_rg32_r) fprintf(stderr,"HORIZ "); \ ! 1430: bits_g32(code2d[i2D_HORIZ]); \ ! 1431: if(dbg_rg32_r) fprintf(stderr,"\n"); \ ! 1432: } ! 1433: #else ! 1434: #define HORIZ_g32 { \ ! 1435: bits_g32(code2d[i2D_HORIZ]); \ ! 1436: } ! 1437: #endif ! 1438: #define detect_a1a2_BW { \ ! 1439: /* find leftmost black changing pel > a0 */ \ ! 1440: /* advance cra as far as possible s.t. cra->xe<=a0 */ \ ! 1441: while((cra+1)<cre && (cra+1)->xe<=a0) cra++; \ ! 1442: /* look beyond cra, until cr->xs>a0 */ \ ! 1443: cr=cra; while(cr<cre && (a1=cr->xs)<=a0) cr++; \ ! 1444: if(cr<cre) a2=cr->xe+1; \ ! 1445: else a1=a2=wid; \ ! 1446: } ! 1447: #define detect_a1a2_WB { \ ! 1448: /* find leftmost white changing pel > a0 */ \ ! 1449: /* advance cra as far as possible s.t. cra->xe<=a0 */ \ ! 1450: while((cra+1)<cre && (cra+1)->xe<=a0) cra++; \ ! 1451: /* look beyond cra, until cr->xe+1>a0 */ \ ! 1452: cr=cra; while(cr<cre && (a1=cr->xe+1)<=a0) cr++; \ ! 1453: if(cr<cre) { \ ! 1454: if((cr+1)<cre) a2=(cr+1)->xs; \ ! 1455: else a2=wid; \ ! 1456: } \ ! 1457: else a1=a2=wid; \ ! 1458: } ! 1459: #define detect_a1a2 {if(a0_color==DST_white) detect_a1a2_BW else detect_a1a2_WB;} ! 1460: #define detect_b1b2_BW {\ ! 1461: /* find leftmost black changing pel > a0 */ \ ! 1462: /* advance pra as far as possible s.t. pra->xe<=a0 */ \ ! 1463: while((pra+1)<pre && (pra+1)->xe<=a0) pra++; \ ! 1464: /* look beyond pra */ \ ! 1465: pr=pra; while(pr<pre && (b1=pr->xs)<=a0) pr++; \ ! 1466: /* move b2 to 1st changing white pel > b1 */ \ ! 1467: if(pr<pre) b2=pr->xe+1; \ ! 1468: else b1=b2=wid; \ ! 1469: } ! 1470: #define detect_b1b2_WB {\ ! 1471: /* find leftmost white changing pel > a0 */ \ ! 1472: /* advance pra as far as possible s.t. pra->xe<=a0 */ \ ! 1473: while((pra+1)<pre && (pra+1)->xe<=a0) pra++; \ ! 1474: /* look beyond pra */ \ ! 1475: pr=pra; while(pr<pre && (b1=pr->xe+1)<=a0) pr++; \ ! 1476: /* move b2 to 1st changing black pel > b1 */ \ ! 1477: if(pr<pre) { \ ! 1478: if((pr+1)<pre) b2=(pr+1)->xs; \ ! 1479: else b2=wid; \ ! 1480: } \ ! 1481: else b1=b2=wid; \ ! 1482: } ! 1483: #define detect_b1b2 {if(a0_color==DST_white) detect_b1b2_BW else detect_b1b2_WB;} ! 1484: ! 1485: #if DEBUG ! 1486: if(dbg_rg32_e) err("rlel_to_g32(pl[%d],cl[%d],w%d)", ! 1487: (pl==NULL)? -1: pl->runs, ! 1488: (cl==NULL)? -1: cl->runs, ! 1489: wid); ! 1490: #endif ! 1491: /* fill so that EOL ends on byte boundary */ ! 1492: padb(f,0,8,EOLLENGTH); ! 1493: #if DEBUG ! 1494: if(dbg_rg32_s) fprintf(stderr,"FILL +0?"); ! 1495: #endif ! 1496: EOL_g32; /* begin with EOL (sic) */ ! 1497: if(pl==NULL) /* use 1-D coding for *cl */ { ! 1498: int pi; /* input pixel index on line */ ! 1499: RLE_Run *rp,*pp,*sp; ! 1500: putb(1,f); ! 1501: #if DEBUG ! 1502: if(dbg_rg32_r) fprintf(stderr,"1D_LINE 1\n"); ! 1503: #endif ! 1504: if(cl!=NULL&&cl->runs>0) { ! 1505: pi=0; /* bit to write next */ ! 1506: for(sp=(rp=cl->r)+cl->runs; rp<sp; rp++) { ! 1507: Wrun_g32(rp->xs-pi); pi=rp->xs; ! 1508: Brun_g32(rp->xe-pi+1); pi=rp->xe+1; ! 1509: }; ! 1510: if((--rp)->xe+1<wid) Wrun_g32(wid-rp->xe-1); ! 1511: } ! 1512: else Wrun_g32(wid); /* blank scanline */ ! 1513: } ! 1514: else /* use 2-D coding for *cl */ { ! 1515: RLE_Run *cr,*cre,*pr,*pre; /* into current/prior rle lines */ ! 1516: int a0,a1,a2,b1,b2; /* indices {0,1,...} of pixels */ ! 1517: DST_color a0_color; /* a0's color: same as a2 & b2, opp of a1 & b1 */ ! 1518: RLE_Run *cra; /* rightmost in current st xe<=a0 (none: ==cl->r) */ ! 1519: RLE_Run *pra; /* rightmost in prior st xe<=a0 (none: ==pl->r) */ ! 1520: int a01,a12,a1b1; /* lengths of runs a0-a1 a1-a2 a1-b1 */ ! 1521: putb(0,f); ! 1522: #if DEBUG ! 1523: if(dbg_rg32_r) fprintf(stderr,"2D_LINE 0\n"); ! 1524: #endif ! 1525: /* start on an imaginary white pixel just to left of margin */ ! 1526: a0= -1; a0_color = DST_white; ! 1527: pre = (pra=pl->r) + pl->runs; /* prior line's runs */ ! 1528: /* start b1/b2 on prior line's first black pixel, etc; ! 1529: if none, then place off end of line */ ! 1530: if(pra<pre) {b1=pra->xs; b2=pra->xe+1;} else b1=b2=wid; ! 1531: if(cl!=NULL&&cl->runs>0) { ! 1532: cre = (cra=cl->r) + cl->runs; ! 1533: a1=cra->xs; a2=cra->xe+1; ! 1534: #if rg32_strict ! 1535: while(a0 < wid) { ! 1536: #else ! 1537: while(a0 < wid-1) { ! 1538: #endif ! 1539: /* a0, a1, a2, b1, b2 are as in CCITT Rec T.4 */ ! 1540: #if DEBUG ! 1541: if(dbg_rg32_r) ! 1542: fprintf(stderr,"f%d(%d,%d,%d) b%d(%d,%d)\n", ! 1543: cra-(cl->r),a0,a1,a2,pra-(pl->r),b1,b2); ! 1544: #endif ! 1545: if(b2<a1) /* PASS mode */ { ! 1546: PASS_g32; ! 1547: a0=b2; ! 1548: /* a0-color, a1, & a2 are unchanged */ ! 1549: detect_b1b2; ! 1550: } ! 1551: else if((a1b1=(a1-b1))<=3 && a1b1>= -3) { ! 1552: /* VERTICAL mode */ ! 1553: switch(a1b1) { ! 1554: case -3: VL3_g32; break; ! 1555: case -2: VL2_g32; break; ! 1556: case -1: VL1_g32; break; ! 1557: case 0: V0_g32; break; ! 1558: case 1: VR1_g32; break; ! 1559: case 2: VR2_g32; break; ! 1560: case 3: VR3_g32; break; ! 1561: }; ! 1562: a0=a1; a0_color=flip_color(a0_color); ! 1563: detect_a1a2; ! 1564: detect_b1b2; ! 1565: } ! 1566: else { /* HORIZONTAL mode */ ! 1567: HORIZ_g32; ! 1568: a01=a1-a0; if(a0== -1) a01--; ! 1569: a12=a2-a1; ! 1570: if(a0_color==DST_white) { ! 1571: Wrun_g32(a01); ! 1572: Brun_g32(a12); ! 1573: } ! 1574: else { Brun_g32(a01); ! 1575: Wrun_g32(a12); ! 1576: }; ! 1577: a0=a2; ! 1578: /* a0_color is unchanged */ ! 1579: detect_a1a2; ! 1580: detect_b1b2; ! 1581: }; ! 1582: }; ! 1583: } ! 1584: else /* current line is blank */ { ! 1585: a1=a2=wid; ! 1586: #if rg32_strict ! 1587: while(a0 < wid) { ! 1588: #else ! 1589: while(a0 < wid-1) { ! 1590: #endif ! 1591: /* a0, a1, a2, b1, b2 are as in CCITT Rec. T.4 */ ! 1592: #if DEBUG ! 1593: if(dbg_rg32_r) ! 1594: fprintf(stderr,"f(%d,%d,%d) b%d(%d,%d)\n", ! 1595: a0,a1,a2,pra-(pl->r),b1,b2); ! 1596: #endif ! 1597: if(b2<a1) /* PASS mode */ { ! 1598: PASS_g32; ! 1599: a0=b2; ! 1600: /* a0-color, a1, & a2 are unchanged */ ! 1601: detect_b1b2; ! 1602: } ! 1603: else if((a1b1=a1-b1)<=3 && a1b1>= -3) { ! 1604: /* VERTICAL mode */ ! 1605: switch(a1b1) { ! 1606: case -3: VL3_g32; break; ! 1607: case -2: VL2_g32; break; ! 1608: case -1: VL1_g32; break; ! 1609: case 0: V0_g32; break; ! 1610: case 1: VR1_g32; break; ! 1611: case 2: VR2_g32; break; ! 1612: case 3: VR3_g32; break; ! 1613: }; ! 1614: a0=a1; a0_color=flip_color(a0_color); ! 1615: /* a1, & a2 are unchanged */ ! 1616: detect_b1b2; ! 1617: } ! 1618: else { /* HORIZONTAL mode */ ! 1619: HORIZ_g32; ! 1620: a01=a1-a0; if(a0== -1) a01--; ! 1621: a12=a2-a1; ! 1622: if(a0_color==DST_white) { ! 1623: Wrun_g32(a01); ! 1624: Brun_g32(a12); ! 1625: } ! 1626: else { Brun_g32(a01); ! 1627: Wrun_g32(a12); ! 1628: }; ! 1629: a0=a2; ! 1630: /* a0_color, a1, & a2 are unchanged */ ! 1631: detect_b1b2; ! 1632: }; ! 1633: }; ! 1634: }; ! 1635: }; ! 1636: } ! 1637: ! 1638: EOF_to_g32(f) ! 1639: BITFILE *f; ! 1640: { char *cs; ! 1641: padb(f,0,8,EOLLENGTH); /* fill so that EOL ends on byte boundary */ ! 1642: #if DEBUG ! 1643: if(dbg_rg32_s) fprintf(stderr,"FILL +0?"); ! 1644: #endif ! 1645: /* write RTC */ ! 1646: EOL_g32; ! 1647: EOL_g32; ! 1648: EOL_g32; ! 1649: EOL_g32; ! 1650: EOL_g32; ! 1651: EOL_g32; ! 1652: #if DEBUG ! 1653: if(dbg_rg32_e) fprintf(stderr,"EOF\n"); ! 1654: #endif ! 1655: } ! 1656: ! 1657: /* Macro for use within g4_to_rlel, to read one 1-D Modified Huffman coded ! 1658: run-length of color C, placing the result in variable V. ! 1659: Exceptionally, goto trap_eol, trap_eof, or trap_code_err. ! 1660: */ ! 1661: #if DEBUG ! 1662: #define g4_1d_run(C,V) { \ ! 1663: run = 0; \ ! 1664: do { cx.tr.s = (C); \ ! 1665: do { px = cx; \ ! 1666: switch(bitv=getb(f)) { \ ! 1667: case 0 : cx.tr=t->e[cx.tr.s].t[0]; break; \ ! 1668: case 1 : cx.tr=t->e[cx.tr.s].t[1]; break; \ ! 1669: case EOF : goto trap_eof; break; \ ! 1670: }; \ ! 1671: } \ ! 1672: while(cx.tr.a==DST_action_NULL); \ ! 1673: switch(cx.tr.a) { \ ! 1674: case DST_EOL : \ ! 1675: if(dbg_g4r_c)fprintf(stderr,"EOL %s\n",EOLSTRING); \ ! 1676: goto trap_eol; \ ! 1677: break; \ ! 1678: case DST_action_ERROR : goto trap_code_err; break; \ ! 1679: default : \ ! 1680: if(dbg_g4r_c)fprintf(stderr,"%s%6d %s%d\n", \ ! 1681: ((C)==DST_white)? "W": "B", \ ! 1682: cx.tr.a, \ ! 1683: t->e[px.tr.s].p, \ ! 1684: bitv); \ ! 1685: run += cx.tr.a; \ ! 1686: break; \ ! 1687: }; \ ! 1688: } \ ! 1689: while(cx.tr.a>63); \ ! 1690: (V) = run; \ ! 1691: } ! 1692: #else ! 1693: #define g4_1d_run(C,V) { \ ! 1694: run = 0; \ ! 1695: do { cx.tr.s = (C); \ ! 1696: do { px = cx; \ ! 1697: switch(bitv=getb(f)) { \ ! 1698: case 0 : cx.tr=t->e[cx.tr.s].t[0]; break; \ ! 1699: case 1 : cx.tr=t->e[cx.tr.s].t[1]; break; \ ! 1700: case EOF : goto trap_eof; break; \ ! 1701: }; \ ! 1702: } \ ! 1703: while(cx.tr.a==DST_action_NULL); \ ! 1704: switch(cx.tr.a) { \ ! 1705: case DST_EOL : \ ! 1706: goto trap_eol; \ ! 1707: break; \ ! 1708: case DST_action_ERROR : goto trap_code_err; break; \ ! 1709: default : \ ! 1710: run += cx.tr.a; \ ! 1711: break; \ ! 1712: }; \ ! 1713: } \ ! 1714: while(cx.tr.a>63); \ ! 1715: (V) = run; \ ! 1716: } ! 1717: #endif ! 1718: ! 1719: /* Translate a stream of bits in CCITT FAX Group 4 compression format, of known ! 1720: fixed line-length, into a sequence of RLE_Lines. Returns one (RLE_Line *) ! 1721: on each call (or NULL if EOF or error). The first pixel (black or white) ! 1722: in each g4 line is assigned run index 0. ! 1723: WARNING: the RLE_Line returned must NOT be modified by the caller, since ! 1724: it is used to decode the next line. */ ! 1725: RLE_Line *g4_to_rlel(t,f,bof,len) ! 1726: DST_table *t; ! 1727: BITFILE *f; ! 1728: boolean bof; /* beginning of file */ ! 1729: int len; /* line-length in pixels (used only on bof) */ ! 1730: #define dbg_g4r_e (0) /* trace entry-to / exit-from function */ ! 1731: #define dbg_g4r_r (0) /* trace each run/EOL/ERR_SYN */ ! 1732: #define dbg_g4r_c (0) /* trace each Huffman code (or, fill+EOL)*/ ! 1733: #define dbg_g4r_t (0) /* trace each state-transition */ ! 1734: #define g4r_strict (1) /* 1 is CORRECT: explicitly code the last black pel */ ! 1735: { static RLE_Line rl0,rl1,*prl,*crl; /* prior, current run-lines */ ! 1736: RLE_Line *swrl; ! 1737: int bitv; /* the last-read bit value */ ! 1738: DST_context cx,px; /* the current/prior decoding context */ ! 1739: RLE_Run *cr,*pr,*pre; /* into current/prior rle lines */ ! 1740: RLE_Run *pra0; /* rightmost in prior line with xe<=a0 ! 1741: (if none: prl->r) */ ! 1742: int run,sync,si,rtc_eols; ! 1743: /* pixel indices (0,1,...): current-line a*; prior-line b*. ! 1744: a0 is the index of the most recently completely encoded bit */ ! 1745: int a0,a1,a2,b1,b2; ! 1746: DST_color a0_color; /* a0's color: same as a2 & b2, opposite of a1 & b1 */ ! 1747: int a01,a12; /* lengths of runs a0-a1 & a1-a2 */ ! 1748: #define g4_first_color (DST_white) /* color of 1st run in each line */ ! 1749: #define g4_negative (0) /* if 1, invert Black/White on output */ ! 1750: #define swap_rl(f,b) {swrl=(f); (f)=(b); (b)=swrl;} ! 1751: /* detect b1 & b2: sensitive to a0, a0_color, and prior runs *pr *(pr+1) */ ! 1752: #define g4r_find_Bb1Wb2 { \ ! 1753: /* find 1st black changing pel>a0 */ \ ! 1754: /* advance pra0 as far as possible s.t. pra0->xe<=a0 */ \ ! 1755: while((pra0+1)<pre && (pra0+1)->xe<=a0) pra0++; \ ! 1756: /* look beyond pra0 */ \ ! 1757: pr=pra0; while(pr<pre && (b1=pr->xs)<=a0) pr++; \ ! 1758: /* move b2 to 1st changing white pel > b1 */ \ ! 1759: if(pr<pre) b2=pr->xe+1; \ ! 1760: else b1=b2=prl->len; \ ! 1761: } ! 1762: #define g4r_find_Wb1Bb2 { \ ! 1763: /* find 1st white changing pel>a0 */ \ ! 1764: /* advance pra0 as far as possible s.t. pra0->xe<=a0 */ \ ! 1765: while((pra0+1)<pre && (pra0+1)->xe<=a0) pra0++; \ ! 1766: /* look beyond pra0 */ \ ! 1767: pr=pra0; while(pr<pre && (b1=pr->xe+1)<=a0) pr++; \ ! 1768: /* move b2 to 1st changing black pel > b1 */ \ ! 1769: if(pr<pre) { \ ! 1770: if((pr+1)<pre) b2=(pr+1)->xs; \ ! 1771: else b2=prl->len; \ ! 1772: } \ ! 1773: else b1=b2=prl->len; \ ! 1774: } ! 1775: #define g4r_find_b1b2 { \ ! 1776: if(a0_color==DST_white) g4r_find_Bb1Wb2 else g4r_find_Wb1Bb2; \ ! 1777: if(b1<=a0) err("g4_to_rlel: y%d: b1 %d <= a0 %d ?",crl->y,a0,b1); \ ! 1778: } ! 1779: ! 1780: if(bof){/* initial reference line is all white, of known length */ ! 1781: prl= &rl0; prl->y= -1; prl->len=len; prl->runs=0; ! 1782: /* initial coding line has y-coordinate 0 */ ! 1783: crl= &rl1; crl->y=0; crl->len=0; crl->runs=0; ! 1784: } ! 1785: else crl->y = prl->y + 1; ! 1786: #if DEBUG ! 1787: if(dbg_g4r_e) ! 1788: fprintf(stderr, ! 1789: "g4_to_rlel(t,f,bof%d,len%d) y%d,l%d\n", ! 1790: bof,len,prl->y,prl->len); ! 1791: #endif ! 1792: ! 1793: pre = (pra0=pr=prl->r) + prl->runs; /* prior line */ ! 1794: crl->runs=0; cr=crl->r-1; /* current line */ ! 1795: /* start on an imaginary white pixel just to left of margin */ ! 1796: a0= -1; a0_color = DST_white; ! 1797: #if DEBUG ! 1798: a1=a2=b1=b2=0; /* immaterial; looks better when debugging */ ! 1799: #endif ! 1800: ! 1801: /* start b1/b2 on prior line's first black pixel, etc; ! 1802: if none, then place off end of line */ ! 1803: if(pr<pre) {b1=pr->xs; b2=pr->xe+1;} else b1=b2=prl->len; ! 1804: /* parse a sequence of 2D codes... */ ! 1805: while(T/* exit only via 'goto trap_X' */) { ! 1806: /* a0, a1, a2, b1, b2 are as defined in CCITT Rec. T.6 */ ! 1807: #if DEBUG ! 1808: if(dbg_g4r_r) ! 1809: fprintf(stderr,"a(%d,%d,%d) b(%d,%d)\n",a0,a1,a2,b1,b2); ! 1810: #endif ! 1811: cx.tr.s = DST_2d; cx.tr.a = DST_action_NULL; ! 1812: #if DEBUG ! 1813: if(dbg_g4r_t)fprintf(stderr,"(%d,%d)\n",cx.tr.s,cx.tr.a); ! 1814: #endif ! 1815: do { switch(bitv=getb(f)) { ! 1816: case 0 : ! 1817: case 1 : ! 1818: cx.tr=t->e[cx.tr.s].t[bitv]; ! 1819: break; ! 1820: case EOF: goto trap_eof; break; ! 1821: }; ! 1822: #if DEBUG ! 1823: if(dbg_g4r_t)fprintf(stderr,"%d->(%d,%d)\n", ! 1824: bitv,cx.tr.s,cx.tr.a); ! 1825: #endif ! 1826: } ! 1827: while(cx.tr.a==DST_action_NULL); ! 1828: #if DEBUG ! 1829: if(dbg_g4r_t)fprintf(stderr,"%s %04d %s0\n", ! 1830: (cx.c==DST_white)? "W": "B", ! 1831: cx.tr.s, ! 1832: t->e[cx.tr.s].p); ! 1833: #endif ! 1834: switch(cx.tr.a) { ! 1835: case i2D_V0: ! 1836: #if DEBUG ! 1837: if(dbg_g4r_c) ! 1838: fprintf(stderr,"V0 %s\n",code2d[cx.tr.a]); ! 1839: #endif ! 1840: a1=b1; ! 1841: /* interpret (a0,a1-1] */ ! 1842: if(a0_color==DST_black) cr->xe=a1-1; ! 1843: /* move a0 to a1 */ ! 1844: a0=a1; if(a0>=prl->len) goto trap_expecting_eol; ! 1845: a0_color = flip_color(a0_color); ! 1846: /* interpret a0 */ ! 1847: if(a0_color==DST_black) { ! 1848: if(cr->xs>cr->xe&&cr->xs<prl->len&&cr->xe>0) ! 1849: err("g4_to_rlel: y%d: r%d[%d,%d] not monotone ?", ! 1850: crl->y,crl->runs,cr->xs,cr->xe); ! 1851: crl->runs++; (++cr)->xs = a0; cr->xe = a0; ! 1852: }; ! 1853: #if !g4r_strict ! 1854: if(a0==prl->len-1) ! 1855: { a0++; goto trap_expecting_eol; }; ! 1856: #endif ! 1857: g4r_find_b1b2; ! 1858: break; ! 1859: case i2D_VR1: ! 1860: #if DEBUG ! 1861: if(dbg_g4r_c) ! 1862: fprintf(stderr,"VR1 %s\n",code2d[cx.tr.a]); ! 1863: #endif ! 1864: a1=b1+1; ! 1865: /* encode a0 to a1-1 */ ! 1866: if(a0_color==DST_black) cr->xe=a1-1; ! 1867: /* move a0 to a1 */ ! 1868: a0=a1; if(a0>=prl->len) goto trap_expecting_eol; ! 1869: a0_color = flip_color(a0_color); ! 1870: /* encode a0 */ ! 1871: if(a0_color==DST_black) { ! 1872: if(cr->xs>cr->xe&&cr->xs<prl->len&&cr->xe>0) ! 1873: err("g4_to_rlel: y%d: r%d[%d,%d] not monotone ?", ! 1874: crl->y,crl->runs,cr->xs,cr->xe); ! 1875: crl->runs++; (++cr)->xs = a0; cr->xe = a0; ! 1876: }; ! 1877: #if !g4r_strict ! 1878: if(a0==prl->len-1) ! 1879: { a0++; goto trap_expecting_eol; }; ! 1880: #endif ! 1881: g4r_find_b1b2; ! 1882: break; ! 1883: case i2D_VR2: ! 1884: #if DEBUG ! 1885: if(dbg_g4r_c) ! 1886: fprintf(stderr,"VR2 %s\n",code2d[cx.tr.a]); ! 1887: #endif ! 1888: a1=b1+2; ! 1889: /* encode a0 to a1-1 */ ! 1890: if(a0_color==DST_black) cr->xe=a1-1; ! 1891: /* move a0 to a1 */ ! 1892: a0=a1; if(a0>=prl->len) goto trap_expecting_eol; ! 1893: a0_color = flip_color(a0_color); ! 1894: /* encode a0 */ ! 1895: if(a0_color==DST_black) { ! 1896: if(cr->xs>cr->xe&&cr->xs<prl->len&&cr->xe>0) ! 1897: err("g4_to_rlel: y%d: r%d[%d,%d] not monotone ?", ! 1898: crl->y,crl->runs,cr->xs,cr->xe); ! 1899: crl->runs++; (++cr)->xs = a0; cr->xe = a0; ! 1900: }; ! 1901: #if !g4r_strict ! 1902: if(a0==prl->len-1) ! 1903: { a0++; goto trap_expecting_eol; }; ! 1904: #endif ! 1905: g4r_find_b1b2; ! 1906: break; ! 1907: case i2D_VR3: ! 1908: #if DEBUG ! 1909: if(dbg_g4r_c) ! 1910: fprintf(stderr,"VR3 %s\n",code2d[cx.tr.a]); ! 1911: #endif ! 1912: a1=b1+3; ! 1913: /* encode a0 to a1-1 */ ! 1914: if(a0_color==DST_black) cr->xe=a1-1; ! 1915: /* move a0 to a1 */ ! 1916: a0=a1; if(a0>=prl->len) goto trap_expecting_eol; ! 1917: a0_color = flip_color(a0_color); ! 1918: /* encode a0 */ ! 1919: if(a0_color==DST_black) { ! 1920: if(cr->xs>cr->xe&&cr->xs<prl->len&&cr->xe>0) ! 1921: err("g4_to_rlel: y%d: r%d[%d,%d] not monotone ?", ! 1922: crl->y,crl->runs,cr->xs,cr->xe); ! 1923: crl->runs++; (++cr)->xs = a0; cr->xe = a0; ! 1924: }; ! 1925: #if !g4r_strict ! 1926: if(a0==prl->len-1) ! 1927: { a0++; goto trap_expecting_eol; }; ! 1928: #endif ! 1929: g4r_find_b1b2; ! 1930: break; ! 1931: case i2D_VL1: ! 1932: #if DEBUG ! 1933: if(dbg_g4r_c) ! 1934: fprintf(stderr,"VL1 %s\n",code2d[cx.tr.a]); ! 1935: #endif ! 1936: if((a1=b1-1)<=a0) ! 1937: err("g4_to_rlel: y%d: VL1 a1 %d <= a0 %d ?", ! 1938: crl->y,a1,a0); ! 1939: /* encode a0 to a1-1 */ ! 1940: if(a0_color==DST_black) cr->xe=a1-1; ! 1941: /* move a0 to a1 */ ! 1942: a0=a1; if(a0>=prl->len) goto trap_expecting_eol; ! 1943: a0_color = flip_color(a0_color); ! 1944: /* encode a0 */ ! 1945: if(a0_color==DST_black) { ! 1946: if(cr->xs>cr->xe&&cr->xs<prl->len&&cr->xe>0) ! 1947: err("g4_to_rlel: y%d: r%d[%d,%d] not monotone ?", ! 1948: crl->y,crl->runs,cr->xs,cr->xe); ! 1949: crl->runs++; (++cr)->xs = a0; cr->xe = a0; ! 1950: }; ! 1951: #if !g4r_strict ! 1952: if(a0==prl->len-1) ! 1953: { a0++; goto trap_expecting_eol; }; ! 1954: #endif ! 1955: g4r_find_b1b2; ! 1956: break; ! 1957: case i2D_VL2: ! 1958: #if DEBUG ! 1959: if(dbg_g4r_c) ! 1960: fprintf(stderr,"VL2 %s\n",code2d[cx.tr.a]); ! 1961: #endif ! 1962: if((a1=b1-2)<=a0) ! 1963: err("g4_to_rlel: y%d: VL2 a1 %d <= a0 %d ?", ! 1964: crl->y,a1,a0); ! 1965: /* encode a0 to a1-1 */ ! 1966: if(a0_color==DST_black) cr->xe=a1-1; ! 1967: /* move a0 to a1 */ ! 1968: a0=a1; if(a0>=prl->len) goto trap_expecting_eol; ! 1969: a0_color = flip_color(a0_color); ! 1970: /* encode a0 */ ! 1971: if(a0_color==DST_black) { ! 1972: if(cr->xs>cr->xe&&cr->xs<prl->len&&cr->xe>0) ! 1973: err("g4_to_rlel: y%d: r%d[%d,%d] not monotone ?", ! 1974: crl->y,crl->runs,cr->xs,cr->xe); ! 1975: crl->runs++; (++cr)->xs = a0; cr->xe = a0; ! 1976: }; ! 1977: #if !g4r_strict ! 1978: if(a0==prl->len-1) ! 1979: { a0++; goto trap_expecting_eol; }; ! 1980: #endif ! 1981: g4r_find_b1b2; ! 1982: break; ! 1983: case i2D_VL3: ! 1984: #if DEBUG ! 1985: if(dbg_g4r_c) ! 1986: fprintf(stderr,"VL3 %s\n",code2d[cx.tr.a]); ! 1987: #endif ! 1988: if((a1=b1-3)<=a0) ! 1989: err("g4_to_rlel: y%d: VL3 a1 %d <= a0 %d ?", ! 1990: crl->y,a1,a0); ! 1991: /* encode a0 to a1-1 */ ! 1992: if(a0_color==DST_black) cr->xe=a1-1; ! 1993: /* move a0 to a1 */ ! 1994: a0=a1; if(a0>=prl->len) goto trap_expecting_eol; ! 1995: a0_color = flip_color(a0_color); ! 1996: /* encode a0 */ ! 1997: if(a0_color==DST_black) { ! 1998: if(cr->xs>cr->xe&&cr->xs<prl->len&&cr->xe>0) ! 1999: err("g4_to_rlel: y%d: r%d[%d,%d] not monotone ?", ! 2000: crl->y,crl->runs,cr->xs,cr->xe); ! 2001: crl->runs++; (++cr)->xs = a0; cr->xe = a0; ! 2002: }; ! 2003: #if !g4r_strict ! 2004: if(a0==prl->len-1) ! 2005: { a0++; goto trap_expecting_eol; }; ! 2006: #endif ! 2007: g4r_find_b1b2; ! 2008: break; ! 2009: case i2D_PASS: ! 2010: #if DEBUG ! 2011: if(dbg_g4r_c) ! 2012: fprintf(stderr,"PASS %s\n",code2d[cx.tr.a]); ! 2013: #endif ! 2014: /* move a0 to b2; no change of color */ ! 2015: a0=b2; if(a0>=prl->len) goto trap_expecting_eol; ! 2016: if(a0_color==DST_black) cr->xe = a0; ! 2017: #if !g4r_strict ! 2018: if(a0==prl->len-1) ! 2019: { a0++; goto trap_expecting_eol; }; ! 2020: #endif ! 2021: g4r_find_b1b2; ! 2022: break; ! 2023: case i2D_HORIZ: ! 2024: #if DEBUG ! 2025: if(dbg_g4r_c) ! 2026: fprintf(stderr,"HORIZ %s\n",code2d[cx.tr.a]); ! 2027: #endif ! 2028: if(a0_color==DST_white) { ! 2029: if(a0<0) a0=0; /* first run in line starts at 0 */ ! 2030: g4_1d_run(DST_white,a01); a1 = a0 + a01; ! 2031: g4_1d_run(DST_black,a12); a2 = a1 + a12; ! 2032: if(a12>0) /* Black run of >0 length */ { ! 2033: if(cr->xs>cr->xe&&cr->xs<prl->len&&cr->xe>0) ! 2034: err("g4_to_rlel: y%d: r%d[%d,%d] not monotone ?", ! 2035: crl->y,crl->runs,cr->xs,cr->xe); ! 2036: crl->runs++; (++cr)->xs = a1; cr->xe = a2-1; ! 2037: }; ! 2038: a0 = a2; /* still white */ ! 2039: if(a0>=prl->len) goto trap_expecting_eol; ! 2040: /* encode a0 */ ! 2041: #if !g4r_strict ! 2042: if(a0==prl->len-1) ! 2043: { a0++; goto trap_expecting_eol; }; ! 2044: #endif ! 2045: g4r_find_Bb1Wb2; ! 2046: } ! 2047: else { g4_1d_run(DST_black,a01); a1 = a0 + a01; ! 2048: g4_1d_run(DST_white,a12); a2 = a1 + a12; ! 2049: if(a01>0) /* Black run of >0 length */ { ! 2050: cr->xe = a1 - 1; ! 2051: } ! 2052: else { /* 0-length: very peculiar: ignore */ ! 2053: fprintf(stderr, ! 2054: "g4_to_rlel: HORIZ B%d! W%d - ignore\n", ! 2055: a01,a12); ! 2056: cr--; crl->runs--; ! 2057: }; ! 2058: a0 = a2; /* still black */ ! 2059: if(a0>=prl->len) goto trap_expecting_eol; ! 2060: /* encode a0 */ ! 2061: crl->runs++; (++cr)->xs = a0; ! 2062: #if !g4r_strict ! 2063: if(a0==prl->len-1) { ! 2064: cr->xe = a0; ! 2065: a0++; ! 2066: goto trap_expecting_eol; ! 2067: }; ! 2068: #endif ! 2069: g4r_find_Wb1Bb2; ! 2070: }; ! 2071: break; ! 2072: case i2D_EOL: ! 2073: #if DEBUG ! 2074: if(dbg_g4r_c) ! 2075: fprintf(stderr,"EOL %s\n",code2d[cx.tr.a]); ! 2076: #endif ! 2077: goto trap_eol; ! 2078: break; ! 2079: case DST_action_ERROR: goto trap_code_err; break; ! 2080: }; ! 2081: }; ! 2082: ! 2083: /* come here via goto's: all these traps return() */ ! 2084: ! 2085: trap_expecting_eol: /* come here having detected (computed) end-of-line */ ! 2086: /* learn/check/correct line-length */ ! 2087: crl->len = (a0>0)? a0 : 0; ! 2088: if(crl->len!=prl->len) { ! 2089: err("g4_to_rlel: y%d: LINELEN changes c%d != p%d ? (force to %d)", ! 2090: crl->y,crl->len,prl->len,prl->len); ! 2091: crl->len = prl->len; ! 2092: }; ! 2093: swap_rl(crl,prl); ! 2094: #if DEBUG ! 2095: if(dbg_g4r_e) ! 2096: fprintf(stderr, ! 2097: "exit g4_to_rlel: expg_eol y%d,l%d\n", ! 2098: prl->y,prl->len); ! 2099: #endif ! 2100: return(prl); ! 2101: ! 2102: trap_eol: /* come here having seen an EOL code (rare in Group 4) */ ! 2103: /* It must be the first of two EOL codes making up the EOB signal */ ! 2104: /* look for 2nd EOL */ ! 2105: sync=0; while((bitv=getb(f))==0) sync++; ! 2106: switch(bitv) { ! 2107: case 1: ! 2108: if(sync==11) { ! 2109: #if DEBUG ! 2110: if(dbg_g4r_c) { ! 2111: fprintf(stderr,"EOB_EOL %s\n",EOLSTRING); ! 2112: fprintf(stderr,"EOB\n"); ! 2113: }; ! 2114: #endif ! 2115: } ! 2116: else { ! 2117: #if DEBUG ! 2118: if(dbg_g4r_c){ ! 2119: fprintf(stderr,"NOT EOB "); ! 2120: for(si=0;si<sync;si++) ! 2121: fprintf(stderr,"0"); ! 2122: fprintf(stderr,"1?\n"); ! 2123: fprintf(stderr,"ABORT\n"); ! 2124: }; ! 2125: #endif ! 2126: }; ! 2127: break; ! 2128: case EOF: goto trap_eof; break; ! 2129: }; ! 2130: #if DEBUG ! 2131: if(dbg_g4r_e) fprintf(stderr,"exit g4_to_rlel: eol\n"); ! 2132: #endif ! 2133: return(NULL); ! 2134: ! 2135: trap_code_err: ! 2136: /* unexpected coding sequence: ! 2137: 'px' holds last decoding context & 'bitv' latest bit value; ! 2138: will attempt to resynchronize on next EOL */ ! 2139: #if DEBUG ! 2140: if(dbg_g4r_c)fprintf(stderr,"CODERR %s%d? (px.tr.s=%d)\n", ! 2141: t->e[px.tr.s].p,bitv,px.tr.s); ! 2142: #endif ! 2143: err("g4_to_rlel: code error"); ! 2144: #if DEBUG ! 2145: if(dbg_g4r_e) fprintf(stderr,"exit g4_to_rlel: code_err\n"); ! 2146: #endif ! 2147: return(NULL); ! 2148: ! 2149: trap_eof: ! 2150: #if DEBUG ! 2151: if(dbg_g4r_c) fprintf(stderr,"<EOF>\n"); ! 2152: if(dbg_g4r_e) fprintf(stderr,"exit g4_to_rlel: eof\n"); ! 2153: #endif ! 2154: return(NULL); ! 2155: ! 2156: } ! 2157: ! 2158: /* Translate a sequence of RLE_Line's (describing a binary image) ! 2159: into a file (a stream of bits) in CCITT FAX Group 4 compression format. ! 2160: BOF_to_g4() must be called first; then call rlel_to_g4() for each line ! 2161: (including blank lines); finally, EOF_to_g4() must be called. The EOFB ! 2162: is padded (suffixed) with 0's to a byte boundary if necessary; no other ! 2163: filling or padding is performed. ! 2164: */ ! 2165: /* debugging flags: trace to stderr */ ! 2166: #define dbg_rg4_e (0) /* entry */ ! 2167: #define dbg_rg4_r (0) /* runs */ ! 2168: #define dbg_rg4_c (0) /* codes (bitstrings) */ ! 2169: #define rg4_strict (1) /* 1 is CORRECT: explicitly code the last black pel */ ! 2170: ! 2171: #if DEBUG ! 2172: #define bits_g4(bits) { \ ! 2173: cs=(bits); while(*cs!='\0') {putb(*cs-'0',f); cs++;}; \ ! 2174: if(dbg_rg4_c) fprintf(stderr,"%s",(bits)); \ ! 2175: if(dbg_rg4_r) fprintf(stderr," "); \ ! 2176: } ! 2177: #else ! 2178: #define bits_g4(bits) { \ ! 2179: cs=(bits); while(*cs!='\0') {putb(*cs-'0',f); cs++;}; \ ! 2180: } ! 2181: #endif ! 2182: #if DEBUG ! 2183: #define EOFB_g4 { \ ! 2184: if(dbg_rg4_r) fprintf(stderr,"EOFB "); \ ! 2185: bits_g4(EOFB); \ ! 2186: if(dbg_rg4_r) fprintf(stderr,"\n"); \ ! 2187: } ! 2188: #else ! 2189: #define EOFB_g4 { \ ! 2190: bits_g4(EOFB); \ ! 2191: } ! 2192: #endif ! 2193: ! 2194: BOF_to_g4(f) ! 2195: BITFILE *f; ! 2196: { char *cs; ! 2197: /* a NOP: no header for Group 4 */ ! 2198: #if DEBUG ! 2199: if(dbg_rg4_e) fprintf(stderr,"BOF\n"); ! 2200: #endif ! 2201: }; ! 2202: ! 2203: rlel_to_g4(pl,cl,wid,f) ! 2204: RLE_Line *pl; /* prior "reference" line */ ! 2205: RLE_Line *cl; /* current "coding" line: if NULL, is blank (all white) */ ! 2206: int wid; /* width of an output line in pixels */ ! 2207: BITFILE *f; ! 2208: { int runl,codi; ! 2209: char *cs,*p01; ! 2210: #if DEBUG ! 2211: #define Wrun_g4(rn) { \ ! 2212: runl=(rn); \ ! 2213: if(dbg_rg4_r) fprintf(stderr,"W %5d ",runl); \ ! 2214: while(runl>2560) {p01=codewht[rtoi(2560)]; bits_g4(p01); runl-=2560;}; \ ! 2215: p01=codewht[codi=rtoi(runl)]; bits_g4(p01); \ ! 2216: if(codi>=64) {p01=codewht[runl%64]; bits_g4(p01);}; \ ! 2217: if(dbg_rg4_r) fprintf(stderr,"\n"); \ ! 2218: } ! 2219: #else ! 2220: #define Wrun_g4(rn) { \ ! 2221: runl=(rn); \ ! 2222: while(runl>2560) {p01=codewht[rtoi(2560)]; bits_g4(p01); runl-=2560;}; \ ! 2223: p01=codewht[codi=rtoi(runl)]; bits_g4(p01); \ ! 2224: if(codi>=64) {p01=codewht[runl%64]; bits_g4(p01);}; \ ! 2225: } ! 2226: #endif ! 2227: #if DEBUG ! 2228: #define Brun_g4(rn) { \ ! 2229: runl=(rn); \ ! 2230: if(dbg_rg4_r) fprintf(stderr,"B %5d ",runl); \ ! 2231: while(runl>2560) {p01=codeblk[rtoi(2560)]; bits_g4(p01); runl-=2560;}; \ ! 2232: p01=codeblk[codi=rtoi(runl)]; bits_g4(p01); \ ! 2233: if(codi>=64) {p01=codeblk[runl%64]; bits_g4(p01);}; \ ! 2234: if(dbg_rg4_r) fprintf(stderr,"\n"); \ ! 2235: } ! 2236: #else ! 2237: #define Brun_g4(rn) { \ ! 2238: runl=(rn); \ ! 2239: while(runl>2560) {p01=codeblk[rtoi(2560)]; bits_g4(p01); runl-=2560;}; \ ! 2240: p01=codeblk[codi=rtoi(runl)]; bits_g4(p01); \ ! 2241: if(codi>=64) {p01=codeblk[runl%64]; bits_g4(p01);}; \ ! 2242: } ! 2243: #endif ! 2244: #if DEBUG ! 2245: #define V0_g4 { \ ! 2246: if(dbg_rg4_r) fprintf(stderr,"V0 "); \ ! 2247: bits_g4(code2d[i2D_V0]); \ ! 2248: if(dbg_rg4_r) fprintf(stderr,"\n"); \ ! 2249: } ! 2250: #else ! 2251: #define V0_g4 { \ ! 2252: bits_g4(code2d[i2D_V0]); \ ! 2253: } ! 2254: #endif ! 2255: #if DEBUG ! 2256: #define VR1_g4 { \ ! 2257: if(dbg_rg4_r) fprintf(stderr,"VR1 "); \ ! 2258: bits_g4(code2d[i2D_VR1]); \ ! 2259: if(dbg_rg4_r) fprintf(stderr,"\n"); \ ! 2260: } ! 2261: #else ! 2262: #define VR1_g4 { \ ! 2263: bits_g4(code2d[i2D_VR1]); \ ! 2264: } ! 2265: #endif ! 2266: #if DEBUG ! 2267: #define VR2_g4 { \ ! 2268: if(dbg_rg4_r) fprintf(stderr,"VR2 "); \ ! 2269: bits_g4(code2d[i2D_VR2]); \ ! 2270: if(dbg_rg4_r) fprintf(stderr,"\n"); \ ! 2271: } ! 2272: #else ! 2273: #define VR2_g4 { \ ! 2274: bits_g4(code2d[i2D_VR2]); \ ! 2275: } ! 2276: #endif ! 2277: #if DEBUG ! 2278: #define VR3_g4 { \ ! 2279: if(dbg_rg4_r) fprintf(stderr,"VR3 "); \ ! 2280: bits_g4(code2d[i2D_VR3]); \ ! 2281: if(dbg_rg4_r) fprintf(stderr,"\n"); \ ! 2282: } ! 2283: #else ! 2284: #define VR3_g4 { \ ! 2285: bits_g4(code2d[i2D_VR3]); \ ! 2286: } ! 2287: #endif ! 2288: #if DEBUG ! 2289: #define VL1_g4 { \ ! 2290: if(dbg_rg4_r) fprintf(stderr,"VL1 "); \ ! 2291: bits_g4(code2d[i2D_VL1]); \ ! 2292: if(dbg_rg4_r) fprintf(stderr,"\n"); \ ! 2293: } ! 2294: #else ! 2295: #define VL1_g4 { \ ! 2296: bits_g4(code2d[i2D_VL1]); \ ! 2297: } ! 2298: #endif ! 2299: #if DEBUG ! 2300: #define VL2_g4 { \ ! 2301: if(dbg_rg4_r) fprintf(stderr,"VL2 "); \ ! 2302: bits_g4(code2d[i2D_VL2]); \ ! 2303: if(dbg_rg4_r) fprintf(stderr,"\n"); \ ! 2304: } ! 2305: #else ! 2306: #define VL2_g4 { \ ! 2307: bits_g4(code2d[i2D_VL2]); \ ! 2308: } ! 2309: #endif ! 2310: #if DEBUG ! 2311: #define VL3_g4 { \ ! 2312: if(dbg_rg4_r) fprintf(stderr,"VL3 "); \ ! 2313: bits_g4(code2d[i2D_VL3]); \ ! 2314: if(dbg_rg4_r) fprintf(stderr,"\n"); \ ! 2315: } ! 2316: #else ! 2317: #define VL3_g4 { \ ! 2318: bits_g4(code2d[i2D_VL3]); \ ! 2319: } ! 2320: #endif ! 2321: #if DEBUG ! 2322: #define PASS_g4 { \ ! 2323: if(dbg_rg4_r) fprintf(stderr,"PASS "); \ ! 2324: bits_g4(code2d[i2D_PASS]); \ ! 2325: if(dbg_rg4_r) fprintf(stderr,"\n"); \ ! 2326: } ! 2327: #else ! 2328: #define PASS_g4 { \ ! 2329: bits_g4(code2d[i2D_PASS]); \ ! 2330: } ! 2331: #endif ! 2332: #if DEBUG ! 2333: #define HORIZ_g4 { \ ! 2334: if(dbg_rg4_r) fprintf(stderr,"HORIZ "); \ ! 2335: bits_g4(code2d[i2D_HORIZ]); \ ! 2336: if(dbg_rg4_r) fprintf(stderr,"\n"); \ ! 2337: } ! 2338: #else ! 2339: #define HORIZ_g4 { \ ! 2340: bits_g4(code2d[i2D_HORIZ]); \ ! 2341: } ! 2342: #endif ! 2343: #define detect_a1a2_BW { \ ! 2344: /* find leftmost black changing pel > a0 */ \ ! 2345: /* advance cra as far as possible s.t. cra->xe<=a0 */ \ ! 2346: while((cra+1)<cre && (cra+1)->xe<=a0) cra++; \ ! 2347: /* look beyond cra, until cr->xs>a0 */ \ ! 2348: cr=cra; while(cr<cre && (a1=cr->xs)<=a0) cr++; \ ! 2349: if(cr<cre) a2=cr->xe+1; \ ! 2350: else a1=a2=wid; \ ! 2351: } ! 2352: #define detect_a1a2_WB { \ ! 2353: /* find leftmost white changing pel > a0 */ \ ! 2354: /* advance cra as far as possible s.t. cra->xe<=a0 */ \ ! 2355: while((cra+1)<cre && (cra+1)->xe<=a0) cra++; \ ! 2356: /* look beyond cra, until cr->xe+1>a0 */ \ ! 2357: cr=cra; while(cr<cre && (a1=cr->xe+1)<=a0) cr++; \ ! 2358: if(cr<cre) { \ ! 2359: if((cr+1)<cre) a2=(cr+1)->xs; \ ! 2360: else a2=wid; \ ! 2361: } \ ! 2362: else a1=a2=wid; \ ! 2363: } ! 2364: #define detect_a1a2 {if(a0_color==DST_white) detect_a1a2_BW else detect_a1a2_WB;} ! 2365: #define detect_b1b2_BW {\ ! 2366: /* find leftmost black changing pel > a0 */ \ ! 2367: /* advance pra as far as possible s.t. pra->xe<=a0 */ \ ! 2368: while((pra+1)<pre && (pra+1)->xe<=a0) pra++; \ ! 2369: /* look beyond pra */ \ ! 2370: pr=pra; while(pr<pre && (b1=pr->xs)<=a0) pr++; \ ! 2371: /* move b2 to 1st changing white pel > b1 */ \ ! 2372: if(pr<pre) b2=pr->xe+1; \ ! 2373: else b1=b2=wid; \ ! 2374: } ! 2375: #define detect_b1b2_WB {\ ! 2376: /* find leftmost white changing pel > a0 */ \ ! 2377: /* advance pra as far as possible s.t. pra->xe<=a0 */ \ ! 2378: while((pra+1)<pre && (pra+1)->xe<=a0) pra++; \ ! 2379: /* look beyond pra */ \ ! 2380: pr=pra; while(pr<pre && (b1=pr->xe+1)<=a0) pr++; \ ! 2381: /* move b2 to 1st changing black pel > b1 */ \ ! 2382: if(pr<pre) { \ ! 2383: if((pr+1)<pre) b2=(pr+1)->xs; \ ! 2384: else b2=wid; \ ! 2385: } \ ! 2386: else b1=b2=wid; \ ! 2387: } ! 2388: #define detect_b1b2 {if(a0_color==DST_white) detect_b1b2_BW else detect_b1b2_WB;} ! 2389: ! 2390: RLE_Run *cr,*cre,*pr,*pre; /* into current/prior rle lines */ ! 2391: int a0,a1,a2,b1,b2; /* indices {0,1,...} of pixels */ ! 2392: DST_color a0_color; /* a0's color: same as a2 & b2, opp of a1 & b1 */ ! 2393: RLE_Run *cra; /* rightmost in current st xe<=a0 (none: ==cl->r) */ ! 2394: RLE_Run *pra; /* rightmost in prior st xe<=a0 (none: ==pl->r) */ ! 2395: int a01,a12,a1b1; /* lengths of runs a0-a1 a1-a2 a1-b1 */ ! 2396: #if DEBUG ! 2397: if(dbg_rg4_e) err("rlel_to_g4(pl[%d],cl[%d],w%d)", ! 2398: (pl==NULL)? -1: pl->runs, ! 2399: (cl==NULL)? -1: cl->runs, ! 2400: wid); ! 2401: #endif ! 2402: /* start on an imaginary white pixel just to left of margin */ ! 2403: a0= -1; a0_color = DST_white; ! 2404: pre = (pra=pl->r) + pl->runs; /* prior line's runs */ ! 2405: /* start b1/b2 on prior line's first black pixel, etc; ! 2406: if none, then place off end of line */ ! 2407: if(pra<pre) {b1=pra->xs; b2=pra->xe+1;} else b1=b2=wid; ! 2408: if(cl!=NULL&&cl->runs>0) { ! 2409: cre = (cra=cl->r) + cl->runs; ! 2410: a1=cra->xs; a2=cra->xe+1; ! 2411: #if rg4_strict ! 2412: while( a0 < wid ) { ! 2413: #else ! 2414: while( a0 < wid-1 ) { ! 2415: #endif ! 2416: /* a0, a1, a2, b1, b2 are as defined in CCITT Rec. T.6 */ ! 2417: #if DEBUG ! 2418: if(dbg_rg4_r) ! 2419: fprintf(stderr,"f%d(%d,%d,%d) b%d(%d,%d)\n", ! 2420: cra-(cl->r),a0,a1,a2,pra-(pl->r),b1,b2); ! 2421: #endif ! 2422: if(b2<a1) /* PASS mode */ { ! 2423: PASS_g4; ! 2424: a0=b2; ! 2425: /* a0-color, a1, & a2 are unchanged */ ! 2426: detect_b1b2; ! 2427: } ! 2428: else if((a1b1=(a1-b1))<=3 && a1b1>= -3) { ! 2429: /* VERTICAL mode */ ! 2430: switch(a1b1) { ! 2431: case -3: VL3_g4; break; ! 2432: case -2: VL2_g4; break; ! 2433: case -1: VL1_g4; break; ! 2434: case 0: V0_g4; break; ! 2435: case 1: VR1_g4; break; ! 2436: case 2: VR2_g4; break; ! 2437: case 3: VR3_g4; break; ! 2438: }; ! 2439: a0=a1; a0_color=flip_color(a0_color); ! 2440: detect_a1a2; ! 2441: detect_b1b2; ! 2442: } ! 2443: else { /* HORIZONTAL mode */ ! 2444: HORIZ_g4; ! 2445: a01=a1-a0; if(a0== -1) a01--; ! 2446: a12=a2-a1; ! 2447: if(a0_color==DST_white) { ! 2448: Wrun_g4(a01); ! 2449: Brun_g4(a12); ! 2450: } ! 2451: else { Brun_g4(a01); ! 2452: Wrun_g4(a12); ! 2453: }; ! 2454: a0=a2; ! 2455: /* a0_color is unchanged */ ! 2456: detect_a1a2; ! 2457: detect_b1b2; ! 2458: }; ! 2459: }; ! 2460: } ! 2461: else /* current line is blank */ { ! 2462: a1=a2=wid; ! 2463: #if rg4_strict ! 2464: while( a0 < wid ) { ! 2465: #else ! 2466: while( a0 < wid-1 ) { ! 2467: #endif ! 2468: /* a0, a1, a2, b1, b2 are as defined in CCITT Rec. T.6 */ ! 2469: #if DEBUG ! 2470: if(dbg_rg4_r) ! 2471: fprintf(stderr,"f(%d,%d,%d) b%d(%d,%d)\n", ! 2472: a0,a1,a2,pra-(pl->r),b1,b2); ! 2473: #endif ! 2474: if(b2<a1) /* PASS mode */ { ! 2475: PASS_g4; ! 2476: a0=b2; ! 2477: /* a0-color, a1, & a2 are unchanged */ ! 2478: detect_b1b2; ! 2479: } ! 2480: else if((a1b1=a1-b1)<=3 && a1b1>= -3) { ! 2481: /* VERTICAL mode */ ! 2482: switch(a1b1) { ! 2483: case -3: VL3_g4; break; ! 2484: case -2: VL2_g4; break; ! 2485: case -1: VL1_g4; break; ! 2486: case 0: V0_g4; break; ! 2487: case 1: VR1_g4; break; ! 2488: case 2: VR2_g4; break; ! 2489: case 3: VR3_g4; break; ! 2490: }; ! 2491: a0=a1; a0_color=flip_color(a0_color); ! 2492: /* a1, & a2 are unchanged */ ! 2493: detect_b1b2; ! 2494: } ! 2495: else { /* HORIZONTAL mode */ ! 2496: HORIZ_g4; ! 2497: a01=a1-a0; if(a0== -1) a01--; ! 2498: a12=a2-a1; ! 2499: if(a0_color==DST_white) { ! 2500: Wrun_g4(a01); ! 2501: Brun_g4(a12); ! 2502: } ! 2503: else { Brun_g4(a01); ! 2504: Wrun_g4(a12); ! 2505: }; ! 2506: a0=a2; ! 2507: /* a0_color, a1, & a2 are unchanged */ ! 2508: detect_b1b2; ! 2509: }; ! 2510: }; ! 2511: }; ! 2512: } ! 2513: ! 2514: EOF_to_g4(f) ! 2515: BITFILE *f; ! 2516: { char *cs; ! 2517: /* write EOFB */ ! 2518: EOFB_g4; ! 2519: #if DEBUG ! 2520: if(dbg_rg4_e) fprintf(stderr,"EOF\n"); ! 2521: #endif ! 2522: } ! 2523:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.