home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 February / PCWK0296.iso / sharewar / dos / program / gs300sr1 / gs300sr1.exe / SCFD.C < prev    next >
C/C++ Source or Header  |  1994-07-27  |  19KB  |  664 lines
  1. /* Copyright (C) 1992, 1993 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* scfd.c */
  20. /* CCITTFax decoding filter */
  21. #include "stdio_.h"    /* includes std.h */
  22. #include "memory_.h"
  23. #include "gdebug.h"
  24. #include "strimpl.h"
  25. #include "scf.h"
  26. #include "scfx.h"
  27.  
  28. private_st_CFD_state();
  29.  
  30. #define ss ((stream_CFD_state *)st)
  31.  
  32. /* Initialize CCITTFaxDecode filter */
  33. private int
  34. s_CFD_init(stream_state *st)
  35. {    int raster = ss->raster = (ss->Columns + 7) >> 3;
  36.     byte white = (ss->BlackIs1 ? 0 : 0xff);
  37.     s_hcd_init_inline(ss);
  38.     ss->lprev = 0;            /* in case we bail out */
  39.     ss->lbuf = gs_alloc_bytes(st->memory, raster + 1, "CFD lbuf");
  40.     if ( ss->lbuf == 0 )
  41.         return ERRC;        /****** WRONG ******/
  42.     if ( ss->K != 0 )
  43.     {    ss->lprev = gs_alloc_bytes(st->memory, raster + 1, "CFD lprev");
  44.         if ( ss->lprev == 0 )
  45.             return ERRC;        /****** WRONG ******/
  46.         /* Clear the initial reference line for 2-D encoding. */
  47.         memset(ss->lbuf, white, raster);
  48.     }
  49.     ss->k_left = min(ss->K, 0);
  50.     ss->cbit = 0;
  51.     ss->uncomp_run = 0;
  52.     ss->rows_left = (ss->Rows <= 0 ? -1 : ss->Rows + 1);
  53.     ss->rpos = ss->wpos = raster - 1;
  54.     ss->eol_count = 0;
  55.     ss->invert = white;
  56.     return 0;
  57. }
  58.  
  59. /* Release the filter. */
  60. private void
  61. s_CFD_release(stream_state *st)
  62. {    gs_free_object(st->memory, ss->lprev, "CFD lprev(close)");
  63.     gs_free_object(st->memory, ss->lbuf, "CFD lbuf(close)");
  64. }
  65.  
  66. /* Declare the variables that hold the state. */
  67. #define cfd_declare_state\
  68.     hcd_declare_state;\
  69.     register byte *q;\
  70.     int qbit
  71. /* Load the state from the stream. */
  72. #define cfd_load_state()\
  73.     hcd_load_state(),\
  74.     q = ss->lbuf + ss->wpos, qbit = ss->cbit
  75. /* Store the state back in the stream. */
  76. #define cfd_store_state()\
  77.     hcd_store_state(),\
  78.     ss->wpos = q - ss->lbuf, ss->cbit = qbit
  79.  
  80. /* Macros to get blocks of bits from the input stream. */
  81. /* Invariants: 0 <= bits_left <= bits_size; */
  82. /* bits [bits_left-1..0] contain valid data. */
  83.  
  84. #define avail_bits(n) hcd_bits_available(n)
  85. #define ensure_bits(n, outl) hcd_ensure_bits(n, outl)
  86. #define peek_bits(n) hcd_peek_bits(n)
  87. #define peek_var_bits(n) hcd_peek_var_bits(n)
  88. #define skip_bits(n) hcd_skip_bits(n)
  89.  
  90. /* Get a run from the stream. */
  91. #define get_run(decode, initial_bits, runlen, str, outl)\
  92. {    const cfd_node *np;\
  93.     int clen;\
  94.     ensure_bits(initial_bits, outl);\
  95.     np = &decode[peek_bits(initial_bits)];\
  96.     if ( (clen = np->code_length) > initial_bits )\
  97.     {    do_debug(uint init_bits = peek_bits(initial_bits));\
  98.         if ( !avail_bits(clen) ) goto outl;\
  99.         clen -= initial_bits;\
  100.         skip_bits(initial_bits);\
  101.         ensure_bits(clen, outl);        /* can't goto outl */\
  102.         np = &decode[np->run_length + peek_var_bits(clen)];\
  103.         if_debug4('W', "%s clen=%d xcode=0x%x rlen=%d\n", str,\
  104.               initial_bits + np->code_length,\
  105.               (init_bits << np->code_length) +\
  106.                   peek_var_bits(np->code_length),\
  107.               np->run_length);\
  108.         skip_bits(np->code_length);\
  109.     }\
  110.     else\
  111.     {    if_debug4('W', "%s clen=%d code=0x%x rlen=%d\n", str,\
  112.               clen, peek_var_bits(clen), np->run_length);\
  113.         skip_bits(clen);\
  114.     }\
  115.     runlen = np->run_length;\
  116. }
  117.  
  118. /* Skip data bits for a white run. */
  119. /* rlen is either less than 64, or a multiple of 64. */
  120. #define skip_data(rlen, makeup_label)\
  121.     if ( (qbit -= rlen) < 0 )\
  122.     {    q -= qbit >> 3, qbit &= 7;\
  123.         if ( rlen >= 64 ) goto makeup_label;\
  124.     }
  125.  
  126. /* Invert data bits for a black run. */
  127. /* If rlen >= 64, execute makeup_action: this is to handle */
  128. /* makeup codes efficiently, since these are always a multiple of 64. */
  129. #define invert_data(rlen, black_byte, makeup_action, d)\
  130.     if ( rlen > qbit )\
  131.     {    *q++ ^= (1 << qbit) - 1;\
  132.         rlen -= qbit;\
  133.         switch ( rlen >> 3 )\
  134.         {\
  135.         default:    /* original rlen >= 64 */\
  136. d:            memset(q, black_byte, rlen >> 3);\
  137.             q += rlen >> 3;\
  138.             rlen &= 7;\
  139.             if ( !rlen ) qbit = 0, q--;\
  140.             else qbit = 8 - rlen, *q ^= 0xff << qbit;\
  141.             makeup_action;\
  142.             break;\
  143.         case 7:        /* original rlen possibly >= 64 */\
  144.             if ( rlen + qbit >= 64 ) goto d;\
  145.             *q++ = black_byte;\
  146.         case 6: *q++ = black_byte;\
  147.         case 5: *q++ = black_byte;\
  148.         case 4: *q++ = black_byte;\
  149.         case 3: *q++ = black_byte;\
  150.         case 2: *q++ = black_byte;\
  151.         case 1: *q = black_byte;\
  152.             rlen &= 7;\
  153.             if ( !rlen ) { qbit = 0; break; }\
  154.             q++;\
  155.         case 0:            /* know rlen != 0 */\
  156.             qbit = 8 - rlen;\
  157.             *q ^= 0xff << qbit;\
  158.         }\
  159.     }\
  160.     else\
  161.         qbit -= rlen,\
  162.         *q ^= ((1 << rlen) - 1) << qbit
  163.  
  164. /* Buffer refill for CCITTFaxDecode filter */
  165. private int cf_decode_eol(P2(stream_CFD_state *, stream_cursor_read *));
  166. private int cf_decode_1d(P2(stream_CFD_state *, stream_cursor_read *));
  167. private int cf_decode_2d(P2(stream_CFD_state *, stream_cursor_read *));
  168. private int cf_decode_uncompressed(P2(stream_CFD_state *, stream_cursor_read *));
  169. private int
  170. s_CFD_process(stream_state *st, stream_cursor_read *pr,
  171.   stream_cursor_write *pw, bool last)
  172. {    int wstop = ss->raster - 1;
  173.     int eol_count = ss->eol_count;
  174.     int k_left = ss->k_left;
  175.     int rows_left = ss->rows_left;
  176.     int status = 0;
  177. top:    /* Check for a completed scan line. */
  178.     if ( ss->wpos == wstop && ss->cbit <= (-ss->Columns & 7) )
  179.     {    /* Check for completed data to be copied to the client. */
  180.         /* (We could avoid the extra copy step for 1-D, but */
  181.         /* it's simpler not to, and it doesn't cost much.) */
  182.         if ( ss->rpos < ss->wpos )
  183.         {    stream_cursor_read cr;
  184.             cr.ptr = ss->lbuf + ss->rpos;
  185.             cr.limit = ss->lbuf + ss->wpos;
  186.             status = stream_move(&cr, pw);
  187.             ss->rpos = cr.ptr - ss->lbuf;
  188.             if ( status )
  189.                 goto out;
  190.         }
  191.         if ( rows_left > 0 && --rows_left == 0 )
  192.         {    status = EOFC;
  193.             goto out;
  194.         }
  195.         if ( ss->K != 0 )
  196.         {    byte *lprev = ss->lprev;
  197.             ss->lprev = ss->lbuf;
  198.             ss->lbuf = lprev;
  199.         }
  200.         ss->rpos = ss->wpos = -1;
  201.         ss->eol_count = eol_count = 0;
  202.         ss->cbit = 0;
  203.         ss->invert = (ss->BlackIs1 ? 0 : 0xff);
  204.         memset(ss->lbuf, ss->invert, wstop + 1);
  205.         ss->run_color = 0;
  206.         if ( ss->EncodedByteAlign )
  207.             ss->bits_left &= ~7;
  208.     }
  209.     /* If we're between scan lines, scan for EOLs. */
  210.     if ( ss->wpos < 0 )
  211.     {    while ( (status = cf_decode_eol(ss, pr)) > 0 )
  212.         {    if_debug0('w', "[w]EOL\n");
  213.             /* If we are in a Group 3 mixed regime, */
  214.             /* check the next bit for 1- vs. 2-D. */
  215.             if ( ss->K > 0 )
  216.             {    hcd_declare_state;
  217.                 hcd_load_state();
  218.                 ensure_bits(1, out);    /* can't fail */
  219.                 k_left = (peek_bits(1) ? 0 : 1);
  220.                 skip_bits(1);
  221.                 hcd_store_state();
  222.             }
  223.             ++eol_count;
  224.             if ( ss->EndOfBlock )
  225.             {    /* Check for end-of-data sequence. */
  226.                 if (eol_count == (ss->K < 0 ? 2 : 6))
  227.                 {    status = EOFC;
  228.                     goto out;
  229.                 }
  230.             }
  231.             else
  232.                 break;        /* >1 EOL is an error */
  233.         }
  234.         if ( status == 0 )    /* input empty while scanning EOLs */
  235.             goto out;
  236.         switch ( eol_count )
  237.         {
  238.         case 0:
  239.             if ( ss->EndOfLine )
  240.             {    /* EOL is required, but none is present. */
  241.                 status = ERRC;
  242.                 goto out;
  243.             }
  244.         case 1:
  245.             break;
  246.         default:
  247.             status = ERRC;
  248.             goto out;
  249.         }
  250.     }
  251.     /* Now decode actual data. */
  252.     if ( k_left < 0 )
  253.     {    if_debug0('w', "[w2]new row\n");
  254.         status = cf_decode_2d(ss, pr);
  255.     }
  256.     else if ( k_left == 0 )
  257.     {    if_debug0('w', "[w1]new row\n");
  258.         status = cf_decode_1d(ss, pr);
  259.         k_left = ss->K;
  260.     }
  261.     else
  262.     {    if_debug1('w', "[w1]new 2-D row, %d left\n", k_left);
  263.         status = cf_decode_2d(ss, pr);
  264.         k_left--;
  265.     }
  266.     if_debug3('w', "[w]CFD status = %d, wpos = %d, cbit = %d\n",
  267.           status, ss->wpos, ss->cbit);
  268.     if ( status == 1 )
  269.         goto top;
  270. out:    ss->k_left = k_left;
  271.     ss->rows_left = rows_left;
  272.     ss->eol_count = eol_count;
  273.     return status;
  274. }
  275.  
  276. #undef ss
  277.  
  278. /* Decode a leading EOL, if any. */
  279. /* If an EOL is present, skip over it and return 1; */
  280. /* if no EOL is present, return -1; if more input is needed, return 0. */
  281. private int
  282. cf_decode_eol(stream_CFD_state *ss, stream_cursor_read *pr)
  283. {    hcd_declare_state;
  284.     int zeros;
  285.     int look_ahead;
  286.     hcd_load_state();
  287.     for ( zeros = 0; zeros < run_eol_code_length - 1; zeros++ )
  288.     {    ensure_bits(1, out);
  289.         if ( peek_bits(1) )
  290.             return -1;
  291.         skip_bits(1);
  292.     }
  293.     /* We definitely have an EOL.  Skip further zero bits. */
  294.     look_ahead = (ss->K > 0 ? 2 : 1);
  295.     for ( ; ; )
  296.     {    ensure_bits(look_ahead, back);
  297.         if ( peek_bits(1) )
  298.             break;
  299.         skip_bits(1);
  300.     }
  301.     skip_bits(1);
  302.     hcd_store_state();
  303.     return 1;
  304. back:    /* We ran out of data while skipping zeros. */
  305.     /* We know we are at a byte boundary, and have just skipped */
  306.     /* at least run_eol_code_length - 1 zeros. */
  307.     bits = 0;
  308.     bits_left = run_eol_code_length - 1;
  309.     hcd_store_state();
  310. out:    return 0;
  311. }
  312.  
  313. /* Decode a 1-D scan line. */
  314. private int
  315. cf_decode_1d(stream_CFD_state *ss, stream_cursor_read *pr)
  316. {    cfd_declare_state;
  317.     byte black_byte = (ss->BlackIs1 ? 0xff : 0);
  318.     int end_bit = -ss->Columns & 7;
  319.     byte *stop = ss->lbuf - 1 + ss->raster;
  320.     int status;
  321.     int bcnt;
  322.     cfd_load_state();
  323.     if ( ss->run_color )
  324.         goto db;
  325.     else
  326.         goto dw;
  327. #define q_at_stop() (q >= stop && (qbit <= end_bit || q > stop))
  328. top:    if ( q_at_stop() )
  329.         goto done;
  330. dw:    /* Decode a white run. */
  331.     get_run(cf_white_decode, cfd_white_initial_bits, bcnt, "[w1]white", out0);
  332.     if ( bcnt < 0 )            /* exceptional situation */
  333.     {    switch ( bcnt )
  334.         {
  335.         case run_uncompressed:    /* Uncompressed data. */
  336.             cfd_store_state();
  337.             bcnt = cf_decode_uncompressed(ss, pr);
  338.             if ( bcnt < 0 )
  339.                 return bcnt;
  340.             cfd_load_state();
  341.             if ( bcnt ) goto db;
  342.             else goto dw;
  343.         /*case run_error:*/
  344.         /*case run_zeros:*/    /* Premature end-of-line. */
  345.         default:
  346.             status = ERRC;
  347.             goto out;
  348.         }
  349.     }
  350.     skip_data(bcnt, dw);
  351.     if ( q_at_stop() )
  352.         goto done;
  353. db:    /* Decode a black run. */
  354.     get_run(cf_black_decode, cfd_black_initial_bits, bcnt, "[w1]black", out1);
  355.     if ( bcnt < 0 )
  356.     {    /* All exceptional codes are invalid here. */
  357.         /****** WRONG, uncompressed IS ALLOWED ******/
  358.         status = ERRC;
  359.         goto out;
  360.     }
  361.     /* Invert bits designated by black run. */
  362.     invert_data(bcnt, black_byte, goto db, idb);
  363.     goto top;
  364. done:    if ( q > stop || qbit < end_bit )
  365.         status = ERRC;
  366.     else
  367.         status = 1;
  368. out:    cfd_store_state();
  369.     return status;
  370. out0:    ss->run_color = 0;
  371.     status = 0;
  372.     goto out;
  373. out1:    ss->run_color = 1;
  374.     status = 0;
  375.     goto out;
  376. }
  377.  
  378. /* Decode a 2-D scan line. */
  379. private int
  380. cf_decode_2d(stream_CFD_state *ss, stream_cursor_read *pr)
  381. {    cfd_declare_state;
  382.     byte invert_white = (ss->BlackIs1 ? 0 : 0xff);
  383.     byte black_byte = ~invert_white;
  384.     byte invert = ss->invert;
  385.     int end_count = -ss->Columns & 7;
  386.     uint raster = ss->raster;
  387.     byte *q0 = ss->lbuf;
  388.     byte *prev_q01 = ss->lprev + 1;
  389.     byte *endptr = q0 - 1 + raster;
  390.     int init_count = raster << 3;
  391.     register int count;
  392.     int rlen;
  393.     int status;
  394.     cfd_load_state();
  395.     count = ((endptr - q) << 3) + qbit;
  396.     endptr[1] = 0xa0;    /* a byte with some 0s and some 1s, */
  397.                 /* to ensure run scan will stop */
  398.     if_debug1('W', "[w2]raster=%d\n", raster);
  399.     switch ( ss->run_color )
  400.     {
  401.     case -1: goto hbw;
  402.     case 1: goto hwb;
  403.     /*case 0:*/
  404.     }
  405. top:    if ( count <= end_count )
  406.     {    status = (count < end_count ? ERRC : 1);
  407.         goto out;
  408.     }
  409.     /* If invert == invert_white, white and black have their */
  410.     /* correct meanings; if invert == ~invert_white, */
  411.     /* black and white are interchanged. */
  412.     if_debug1('W', "[w2]%4d:\n", count);
  413. #ifdef DEBUG
  414.     /* Check the invariant between q, qbit, and count. */
  415.     {    int pcount = (endptr - q) * 8 + qbit;
  416.         if ( pcount != count )
  417.             dprintf2("[w2]Error: count=%d pcount=%d\n",
  418.                  count, pcount);
  419.     }
  420. #endif
  421.     /* We could just use get_run here, but we can do better: */
  422.     ensure_bits(3, out0);
  423.     switch( peek_bits(3) )
  424.     {
  425.     default/*4..7*/:            /* vertical(0) */
  426.         skip_bits(1);
  427.         rlen = countof(cf2_run_vertical) / 2;
  428.         break;
  429.     case 2:                    /* vertical(+1) */
  430.         skip_bits(3);
  431.         rlen = countof(cf2_run_vertical) / 2 + 1;
  432.         break;
  433.     case 3:                    /* vertical(-1) */
  434.         skip_bits(3);
  435.         rlen = countof(cf2_run_vertical) / 2 - 1;
  436.         break;
  437.     case 1:                    /* horizontal */
  438.         skip_bits(3);
  439.         if ( invert == invert_white )
  440.         {    /* White, then black. */
  441. hww:            get_run(cf_white_decode, cfd_white_initial_bits,
  442.                 rlen, " white", hback);
  443.             if ( (count -= rlen) < end_count )
  444.             {    status = ERRC;
  445.                 goto out;
  446.             }
  447.             skip_data(rlen, hww);
  448.             goto hwb;
  449.         }
  450.         else
  451.         {    /* Black, then white. */
  452. hbb:            get_run(cf_black_decode, cfd_black_initial_bits,
  453.                 rlen, " black", hback);
  454.             if ( (count -= rlen) < end_count )
  455.             {    status = ERRC;
  456.                 goto out;
  457.             }
  458.             invert_data(rlen, black_byte, goto hbb, ihbb);
  459.             goto hbw;
  460.         }
  461.     case 0:                /* everything else */
  462.         get_run(cf_2d_decode, cfd_2d_initial_bits, rlen,
  463.             "[w2]", out0);
  464.         /* rlen may be run2_pass, run_uncompressed, or */
  465.         /* 0..countof(cf2_run_vertical)-1. */
  466.         if ( rlen < 0 )
  467.           switch ( rlen )
  468.         {
  469.         case run2_pass:
  470.             break;
  471.         case run_uncompressed:
  472.         {    int which;
  473.             cfd_store_state();
  474.             which = cf_decode_uncompressed(ss, pr);
  475.             if ( which < 0 )
  476.             {    status = which;
  477.                 goto out;
  478.             }
  479.             cfd_load_state();
  480.             /****** ADJUST count ******/
  481.             invert = (which ? ~invert_white : invert_white);
  482.         }    goto top;
  483.         default:    /* run_error, run_zeros */
  484.             status = ERRC;
  485.             goto out;
  486.         }
  487.     }
  488.     /* Interpreting the run requires scanning the */
  489.     /* previous ('reference') line. */
  490.     {    int prev_count = count;
  491.         byte prev_data;
  492.         int dlen;
  493.         static const byte count_bit[8] =
  494.             { 0x80, 1, 2, 4, 8, 0x10, 0x20, 0x40 };
  495.         byte *prev_q = prev_q01 + (q - q0);
  496.         if ( !(count & 7) )
  497.             prev_q++;    /* because of skip macros */
  498.         prev_data = prev_q[-1] ^ invert;
  499.         /* Find the b1 transition. */
  500.         if ( (prev_data & count_bit[prev_count & 7]) &&
  501.              (prev_count < init_count || invert != invert_white )
  502.            )
  503.         {    /* Look for changing white first. */
  504.             if_debug1('W', " data=0x%x", prev_data);
  505.             skip_black_pixels(prev_data, prev_q,
  506.                       prev_count, invert);
  507.             if ( prev_count < end_count ) /* overshot */
  508.                 prev_count = end_count;
  509.             if_debug1('W', " b1 other=%d", prev_count);
  510.         }
  511.         if ( prev_count != end_count )
  512.         {    if_debug1('W', " data=0x%x", prev_data);
  513.             skip_white_pixels(prev_data, prev_q,
  514.                       prev_count, invert);
  515.             if ( prev_count < end_count ) /* overshot */
  516.                 prev_count = end_count;
  517.             if_debug1('W', " b1 same=%d", prev_count);
  518.         }
  519.         /* b1 = prev_count; */
  520.         if ( rlen == run2_pass )
  521.         {    /* Pass mode.  Find b2. */
  522.             if ( prev_count != end_count )
  523.             {    if_debug1('W', " data=0x%x", prev_data);
  524.                 skip_black_pixels(prev_data, prev_q,
  525.                           prev_count, invert);
  526.                 if ( prev_count < end_count ) /* overshot */
  527.                     prev_count = end_count;
  528.             }
  529.             /* b2 = prev_count; */
  530.             if_debug2('W', " b2=%d, pass %d\n",
  531.                   prev_count, count - prev_count);
  532.         }
  533.         else
  534.         {    /* Vertical coding. */
  535.             /* Remember that count counts *down*. */
  536.             prev_count += rlen - 3;    /* a1 */
  537.             if_debug2('W', " vertical %d -> %d\n",
  538.                   3 - rlen, prev_count);
  539.         }
  540.         /* Now either invert or skip from count */
  541.         /* to prev_count, and reset count. */
  542.         if ( invert == invert_white )
  543.         {    /* Skip data bits. */
  544.             q = endptr - (prev_count >> 3);
  545.             qbit = prev_count & 7;
  546.         }
  547.         else
  548.         {    /* Invert data bits. */
  549.             dlen = count - prev_count;
  550.             invert_data(dlen, black_byte, DO_NOTHING, idd);
  551.         }
  552.         count = prev_count;
  553.         if ( rlen >= 0 )    /* vertical mode */
  554.             invert = ~invert;    /* polarity changes */
  555.     }
  556.     goto top;
  557. out:    cfd_store_state();
  558.     ss->invert = invert;
  559.     return status;
  560.         /* Handle input exhausted after recognizing a horizontal */
  561.         /* mode, but before parsing the black or white run. */
  562.         /* The mode flag is 3 bits; the longest black/white */
  563.         /* run code is 13 bits, so bits_left <= 12, and we can */
  564.         /* back up by just incrementing bits_left. */
  565.         /* To make this work even with makeup codes, */
  566.         /* we force the previous 3 bits to 001 (horizontal mode). */
  567. hback:    bits = (bits & ((1 << bits_left) - 1)) + (1 << bits_left);
  568.     bits_left += 3;
  569.     ss->run_color = 0;        /* start parsing from the top */
  570. out0:    status = 0;
  571.     goto out;
  572.         /* Handle input exhausted when parsing the second run */
  573.         /* of a horizontal sequence.  We have to resume parsing */
  574.         /* at hwb or hbw depending on the run color. */
  575. outbw:    ss->run_color = -1;
  576.     goto out0;
  577. outwb:    ss->run_color = 1;
  578.     goto out0;
  579.         /* Handle the second half of a white-black horizontal code. */
  580.         /* We put this here so we can branch to it when resuming. */
  581. hwb:    get_run(cf_black_decode, cfd_black_initial_bits, rlen,
  582.         " black", outwb);
  583.     if ( (count -= rlen) < end_count )
  584.     {    status = ERRC;
  585.         goto out;
  586.     }
  587.     invert_data(rlen, black_byte, goto hwb, ihwb);
  588.     goto top;
  589.         /* Handle the second half of a black-white horizontal code. */
  590.         /* We put this here so we can branch to it when resuming. */
  591. hbw:    get_run(cf_white_decode, cfd_white_initial_bits, rlen,
  592.         " white", outbw);
  593.     if ( (count -= rlen) < end_count )
  594.     {    status = ERRC;
  595.         goto out;
  596.     }
  597.     skip_data(rlen, hbw);
  598.     goto top;
  599. }
  600.  
  601. #if 1    /****************/
  602. private int
  603. cf_decode_uncompressed(stream_CFD_state *ss, stream_cursor_read *pr)
  604. {    return ERRC;
  605. }
  606. #else    /****************/
  607.  
  608. /* Decode uncompressed data. */
  609. /* (Not tested: no sample data available!) */
  610. /****** DOESN'T CHECK FOR OVERFLOWING SCAN LINE ******/
  611. private int
  612. cf_decode_uncompressed(stream *s)
  613. {    cfd_declare_state;
  614.     const cfd_node *np;
  615.     int clen, rlen;
  616.     cfd_load_state();
  617.     while ( 1 )
  618.     {    ensure_bits(cfd_uncompressed_initial_bits, NOOUT);
  619.         np = &cf_uncompressed_decode[peek_bits(cfd_uncompressed_initial_bits)];
  620.         clen = np->code_length;
  621.         rlen = np->run_length;
  622.         if ( clen > cfd_uncompressed_initial_bits )
  623.         {    /* Must be an exit code. */
  624.             break;
  625.         }
  626.         if ( rlen == cfd_uncompressed_initial_bits )
  627.         {    /* Longest representable white run */
  628.             if_debug1('W', "[wu]%d\n", rlen);
  629.             if ( (qbit -= cfd_uncompressed_initial_bits) < 0 )
  630.                 qbit += 8, q++;
  631.         }
  632.         else
  633.         {    if_debug1('W', "[wu]%d+1\n", rlen);
  634.             if ( qbit -= rlen < 0 )
  635.                 qbit += 8, q++;
  636.             *q ^= 1 << qbit;
  637.         }
  638.         skip_bits(clen);
  639.     }
  640.     clen -= cfd_uncompressed_initial_bits;
  641.     skip_bits(cfd_uncompressed_initial_bits);
  642.     ensure_bits(clen, NOOUT);
  643.     np = &cf_uncompressed_decode[rlen + peek_var_bits(clen)];
  644.     rlen = np->run_length;
  645.     skip_bits(np->code_length);
  646.     if_debug1('w', "[wu]exit %d\n", rlen);
  647.     if ( rlen >= 0 )
  648.     {    /* Valid exit code, rlen = 2 * run length + next polarity */
  649.         if ( (qbit -= rlen >> 1) < 0 )
  650.             qbit += 8, q++;
  651.         rlen &= 1;
  652.     }
  653. out:        /******* WRONG ******/
  654.     cfd_store_state();
  655.     return rlen;
  656. }
  657.  
  658. #endif    /****************/
  659.  
  660. /* Stream template */
  661. const stream_template s_CFD_template =
  662. {    &st_CFD_state, s_CFD_init, s_CFD_process, 1, 1, s_CFD_release
  663. };
  664.