Coverage Report

Created: 2025-06-10 06:49

/src/ghostpdl/base/scfd.c
Line
Count
Source (jump to first uncovered line)
1
/* Copyright (C) 2001-2023 Artifex Software, Inc.
2
   All Rights Reserved.
3
4
   This software is provided AS-IS with no warranty, either express or
5
   implied.
6
7
   This software is distributed under license and may not be copied,
8
   modified or distributed except as expressly authorized under the terms
9
   of the license contained in the file LICENSE in this distribution.
10
11
   Refer to licensing information at http://www.artifex.com or contact
12
   Artifex Software, Inc.,  39 Mesa Street, Suite 108A, San Francisco,
13
   CA 94129, USA, for further information.
14
*/
15
16
17
/* CCITTFax decoding filter */
18
#include "stdio_.h"   /* includes std.h */
19
#include "memory_.h"
20
#include "gdebug.h"
21
#include "strimpl.h"
22
#include "scf.h"
23
#include "scfx.h"
24
25
/* ------ CCITTFaxDecode ------ */
26
27
private_st_CFD_state();
28
29
388k
#define CFD_BUFFER_SLOP 4
30
31
static inline int
32
get_run(stream_CFD_state *ss, stream_cursor_read *pr, const cfd_node decode[],
33
    int initial_bits, int min_bits, int *runlen, const char *str);
34
35
static inline int
36
invert_data(stream_CFD_state *ss, stream_cursor_read *pr, int *rlen, byte black_byte);
37
38
static inline int
39
skip_data(stream_CFD_state *ss, stream_cursor_read *pr, int rlen);
40
41
/* Set default parameter values. */
42
static void
43
s_CFD_set_defaults(register stream_state * st)
44
6.39k
{
45
6.39k
    stream_CFD_state *const ss = (stream_CFD_state *) st;
46
47
6.39k
    s_CFD_set_defaults_inline(ss);
48
6.39k
}
49
50
/* Initialize CCITTFaxDecode filter */
51
static int
52
s_CFD_init(stream_state * st)
53
6.40k
{
54
6.40k
    stream_CFD_state *const ss = (stream_CFD_state *) st;
55
6.40k
    int raster = ss->raster =
56
6.40k
        ROUND_UP((ss->Columns + 7) >> 3, ss->DecodedByteAlign);
57
6.40k
    byte white = (ss->BlackIs1 ? 0 : 0xff);
58
59
6.40k
    if (raster < 0)
60
0
        return ERRC;
61
62
6.40k
    if (ss->Columns <= 0)
63
0
        return ERRC;
64
65
6.40k
    s_hcd_init_inline(ss);
66
    /* Because skip_white_pixels can look as many as 4 bytes ahead, */
67
    /* we need to allow 4 extra bytes at the end of the row buffers. */
68
6.40k
    ss->lbufstart = gs_alloc_bytes(st->memory, raster + CFD_BUFFER_SLOP * 2, "CFD lbuf");
69
6.40k
    ss->lprev = 0;
70
6.40k
    if (ss->lbufstart == 0)
71
0
        return ERRC;   /****** WRONG ******/
72
6.40k
    ss->lbuf = ss->lbufstart + CFD_BUFFER_SLOP;
73
6.40k
    memset(ss->lbufstart, 0xaa, CFD_BUFFER_SLOP);
74
6.40k
    memset(ss->lbuf, white, raster);
75
6.40k
    memset(ss->lbuf + raster, 0xaa, CFD_BUFFER_SLOP);  /* for Valgrind */
76
6.40k
    if (ss->K != 0) {
77
6.40k
        ss->lprevstart = gs_alloc_bytes(st->memory, raster + CFD_BUFFER_SLOP * 2, "CFD lprev");
78
6.40k
        if (ss->lprevstart == 0)
79
0
            return ERRC; /****** WRONG ******/
80
6.40k
        ss->lprev = ss->lprevstart + CFD_BUFFER_SLOP;
81
        /* Clear the initial reference line for 2-D encoding. */
82
6.40k
        memset(ss->lprev, white, raster);
83
        /* Ensure that the scan of the reference line will stop. */
84
6.40k
        memset(ss->lprev + raster, 0xaa, CFD_BUFFER_SLOP);
85
6.40k
        memset(ss->lprevstart, 0xaa, CFD_BUFFER_SLOP);
86
6.40k
    }
87
6.40k
    ss->k_left = min(ss->K, 0);
88
6.40k
    ss->run_color = 0;
89
6.40k
    ss->damaged_rows = 0;
90
6.40k
    ss->skipping_damage = false;
91
6.40k
    ss->cbit = 0;
92
6.40k
    ss->uncomp_run = 0;
93
6.40k
    ss->rows_left = (ss->Rows <= 0 || ss->EndOfBlock ? -1 : ss->Rows);
94
6.40k
    ss->row = 0;
95
6.40k
    ss->rpos = ss->wpos = -1;
96
6.40k
    ss->eol_count = 0;
97
6.40k
    ss->invert = white;
98
6.40k
    ss->min_left = 1;
99
6.40k
    return 0;
100
6.40k
}
101
102
/* Release the filter. */
103
static void
104
s_CFD_release(stream_state * st)
105
6.40k
{
106
6.40k
    stream_CFD_state *const ss = (stream_CFD_state *) st;
107
108
6.40k
    gs_free_object(st->memory, ss->lprevstart, "CFD lprev(close)");
109
6.40k
    gs_free_object(st->memory, ss->lbufstart, "CFD lbuf(close)");
110
6.40k
}
111
112
/* Declare the variables that hold the state. */
113
#define cfd_declare_state\
114
659k
        hcd_declare_state;\
115
659k
        register byte *q;\
116
659k
        int qbit
117
/* Load the state from the stream. */
118
#define cfd_load_state()\
119
1.11M
        hcd_load_state(),\
120
0
        q = ss->lbuf + ss->wpos, qbit = ss->cbit
121
/* Store the state back in the stream. */
122
#define cfd_store_state()\
123
1.11M
        hcd_store_state(),\
124
403k
        ss->wpos = q - ss->lbuf, ss->cbit = qbit
125
126
/* Macros to get blocks of bits from the input stream. */
127
/* Invariants: 0 <= bits_left <= bits_size; */
128
/* bits [bits_left-1..0] contain valid data. */
129
130
4.59k
#define avail_bits(n) hcd_bits_available(n)
131
1.33M
#define ensure_bits(n, outl) hcd_ensure_bits(n, outl)
132
1.42M
#define peek_bits(n) hcd_peek_bits(n)
133
4.59k
#define peek_var_bits(n) hcd_peek_var_bits(n)
134
1.17M
#define skip_bits(n) hcd_skip_bits(n)
135
136
/* Get a run from the stream. */
137
#ifdef DEBUG
138
#  define IF_DEBUG(expr) expr
139
#else
140
4.59k
#  define IF_DEBUG(expr) DO_NOTHING
141
#endif
142
143
static inline int get_run(stream_CFD_state *ss, stream_cursor_read *pr, const cfd_node decode[],
144
           int initial_bits, int min_bits, int *runlen, const char *str)
145
92.0k
{
146
92.0k
    cfd_declare_state;
147
92.0k
    const cfd_node *np;
148
92.0k
    int clen;
149
92.0k
    cfd_load_state();
150
151
92.0k
    HCD_ENSURE_BITS_ELSE(initial_bits) {
152
        /* We might still have enough bits for the specific code. */
153
0
        if (bits_left < min_bits)
154
0
            goto outl;
155
0
        np = &decode[hcd_peek_bits_left() << (initial_bits - bits_left)];
156
0
        if ((clen = np->code_length) > bits_left)
157
0
            goto outl;
158
0
        goto locl;
159
0
    }
160
92.0k
    np = &decode[peek_bits(initial_bits)];
161
92.0k
    if ((clen = np->code_length) > initial_bits) {
162
4.59k
            IF_DEBUG(uint init_bits = peek_bits(initial_bits));
163
4.59k
            if (!avail_bits(clen)) goto outl;
164
4.59k
            clen -= initial_bits;
165
4.59k
            skip_bits(initial_bits);
166
4.59k
            ensure_bits(clen, outl);                /* can't goto outl */
167
4.59k
            np = &decode[np->run_length + peek_var_bits(clen)];
168
4.59k
            if_debug4('W', "%s xcode=0x%x,%d rlen=%d\n", str,
169
4.59k
                      (init_bits << np->code_length) +
170
4.59k
                        peek_var_bits(np->code_length),
171
4.59k
                      initial_bits + np->code_length,
172
4.59k
                      np->run_length);
173
4.59k
            skip_bits(np->code_length);
174
87.4k
    } else {
175
87.4k
locl:
176
87.4k
       if_debug4('W', "%s code=0x%x,%d rlen=%d\n", str,
177
87.4k
                      peek_var_bits(clen), clen, np->run_length);
178
87.4k
       skip_bits(clen);
179
87.4k
    }
180
92.0k
    *runlen = np->run_length;
181
182
92.0k
    cfd_store_state();
183
92.0k
    return(0);
184
0
outl:
185
0
    cfd_store_state();
186
0
    return(-1);
187
92.0k
}
188
189
190
/* Skip data bits for a white run. */
191
/* rlen is either less than 64, or a multiple of 64. */
192
static inline int skip_data(stream_CFD_state *ss, stream_cursor_read *pr, int rlen)
193
22.6k
{
194
22.6k
    cfd_declare_state;
195
22.6k
    cfd_load_state();
196
22.6k
    (void)rlimit;
197
198
22.6k
    if ( (qbit -= rlen) < 0 )
199
18.1k
    {
200
18.1k
        q -= qbit >> 3, qbit &= 7;
201
18.1k
        if ( rlen >= 64 ) {
202
93
            cfd_store_state();
203
93
            return(-1);
204
93
        }
205
18.1k
    }
206
22.6k
    cfd_store_state();
207
22.5k
    return(0);
208
22.6k
}
209
210
211
/* Invert data bits for a black run. */
212
/* If rlen >= 64, execute makeup_action: this is to handle */
213
/* makeup codes efficiently, since these are always a multiple of 64. */
214
215
static inline int invert_data(stream_CFD_state *ss, stream_cursor_read *pr, int *rlen, byte black_byte)
216
337k
{
217
337k
    byte *qlim = ss->lbuf + ss->raster + CFD_BUFFER_SLOP;
218
337k
    cfd_declare_state;
219
337k
    cfd_load_state();
220
337k
    (void)rlimit;
221
222
337k
    if (q >= qlim || q < ss->lbufstart) {
223
0
        return(-1);
224
0
    }
225
226
337k
    if ( (*rlen) > qbit )
227
242k
    {
228
242k
        if (q + ((*rlen - qbit) >> 3) > qlim) {
229
0
            return(-1);
230
0
        }
231
232
242k
        if (q >= ss->lbuf) {
233
229k
          *q++ ^= (1 << qbit) - 1;
234
229k
        }
235
13.2k
        else {
236
13.2k
            q++;
237
13.2k
        }
238
242k
        (*rlen) -= qbit;
239
240
242k
        if (q + ((*rlen) >> 3) >= qlim) {
241
0
            return(-1);
242
0
        }
243
244
242k
        switch ( (*rlen) >> 3 )
245
242k
        {
246
799
          case 7:         /* original rlen possibly >= 64 */
247
799
                  if ( (*rlen) + qbit >= 64 ) {
248
327
                    goto d;
249
327
                  }
250
472
                  *q++ = black_byte;
251
2.34k
          case 6: *q++ = black_byte;
252
4.17k
          case 5: *q++ = black_byte;
253
5.35k
          case 4: *q++ = black_byte;
254
10.6k
          case 3: *q++ = black_byte;
255
28.1k
          case 2: *q++ = black_byte;
256
62.1k
          case 1: *q = black_byte;
257
62.1k
              (*rlen) &= 7;
258
62.1k
              if ( !(*rlen) ) {
259
12.2k
                  qbit = 0;
260
12.2k
                  break;
261
12.2k
              }
262
49.8k
              q++;
263
228k
          case 0:                 /* know rlen != 0 */
264
228k
              qbit = 8 - (*rlen);
265
228k
              *q ^= 0xff << qbit;
266
228k
              break;
267
1.50k
          default:        /* original rlen >= 64 */
268
1.83k
d:            memset(q, black_byte, (*rlen) >> 3);
269
1.83k
              q += (*rlen) >> 3;
270
1.83k
              (*rlen) &= 7;
271
1.83k
              if ( !(*rlen) ) {
272
184
                qbit = 0;
273
184
                q--;
274
184
              }
275
1.65k
              else {
276
1.65k
                qbit = 8 - (*rlen);
277
1.65k
                *q ^= 0xff << qbit;
278
1.65k
              }
279
1.83k
              cfd_store_state();
280
1.83k
              return(-1);
281
242k
          }
282
242k
    }
283
94.6k
    else {
284
94.6k
            qbit -= (*rlen),
285
94.6k
            *q ^= ((1 << (*rlen)) - 1) << qbit;
286
287
94.6k
    }
288
337k
    cfd_store_state();
289
335k
    return(0);
290
337k
}
291
292
293
/* Buffer refill for CCITTFaxDecode filter */
294
static int cf_decode_eol(stream_CFD_state *, stream_cursor_read *);
295
static int cf_decode_1d(stream_CFD_state *, stream_cursor_read *);
296
static int cf_decode_2d(stream_CFD_state *, stream_cursor_read *);
297
static int cf_decode_uncompressed(stream_CFD_state *, stream_cursor_read *);
298
static int
299
s_CFD_process(stream_state * st, stream_cursor_read * pr,
300
              stream_cursor_write * pw, bool last)
301
6.41k
{
302
6.41k
    stream_CFD_state *const ss = (stream_CFD_state *) st;
303
6.41k
    int wstop = ss->raster - 1;
304
6.41k
    int eol_count = ss->eol_count;
305
6.41k
    int k_left = ss->k_left;
306
6.41k
    int rows_left = ss->rows_left;
307
6.41k
    int status = 0;
308
309
#ifdef DEBUG
310
    const byte *rstart = pr->ptr;
311
    const byte *wstart = pw->ptr;
312
313
#endif
314
315
    /* Update the pointers we actually use, in case GC moved the buffer */
316
6.41k
    ss->lbuf = ss->lbufstart + CFD_BUFFER_SLOP;
317
6.41k
    ss->lprev = ss->lprevstart + CFD_BUFFER_SLOP;
318
319
213k
top:
320
#ifdef DEBUG
321
    {
322
        hcd_declare_state;
323
        hcd_load_state();
324
        (void)rlimit;
325
        if_debug8m('w', ss->memory,
326
                   "[w]CFD_process top: eol_count=%d, k_left=%d, rows_left=%d\n"
327
                   "    bits="PRI_INTPTR", bits_left=%d, read %u, wrote %u%s\n",
328
                   eol_count, k_left, rows_left,
329
                   (intptr_t) bits, bits_left,
330
                   (uint) (p - rstart), (uint) (pw->ptr - wstart),
331
                   (ss->skipping_damage ? ", skipping damage" : ""));
332
    }
333
#endif
334
213k
    if (ss->skipping_damage) { /* Skip until we reach an EOL. */
335
0
        hcd_declare_state;
336
0
        int skip;
337
0
        (void)rlimit;
338
339
0
        status = 0;
340
0
        do {
341
0
            switch ((skip = cf_decode_eol(ss, pr))) {
342
0
                default:  /* not EOL */
343
0
                    hcd_load_state();
344
0
                    skip_bits(-skip);
345
0
                    hcd_store_state();
346
0
                    continue;
347
0
                case 0: /* need more input */
348
0
                    goto out;
349
0
                case 1: /* EOL */
350
0
                    {   /* Back up over the EOL. */
351
0
                        hcd_load_state();
352
0
                        bits_left += run_eol_code_length;
353
0
                        hcd_store_state();
354
0
                    }
355
0
                    ss->skipping_damage = false;
356
0
            }
357
0
        }
358
0
        while (ss->skipping_damage);
359
0
        ss->damaged_rows++;
360
0
    }
361
    /*
362
     * Check for a completed input scan line.  This isn't quite as
363
     * simple as it seems, because we could have run out of input data
364
     * between a makeup code and a 0-length termination code, or in a
365
     * 2-D line before a final horizontal code with a 0-length second
366
     * run.  There's probably a way to think about this situation that
367
     * doesn't require a special check, but I haven't found it yet.
368
     */
369
213k
    if (ss->wpos == wstop && ss->cbit <= (-ss->Columns & 7) &&
370
213k
        (k_left == 0 ? !(ss->run_color & ~1) : ss->run_color == 0)
371
213k
        ) {     /* Check for completed data to be copied to the client. */
372
        /* (We could avoid the extra copy step for 1-D, but */
373
        /* it's simpler not to, and it doesn't cost much.) */
374
207k
        if (ss->rpos < ss->wpos) {
375
207k
            stream_cursor_read cr;
376
377
207k
            cr.ptr = ss->lbuf + ss->rpos;
378
207k
            cr.limit = ss->lbuf + ss->wpos;
379
207k
            status = stream_move(&cr, pw);
380
207k
            ss->rpos = cr.ptr - ss->lbuf;
381
207k
            if (status)
382
0
                goto out;
383
207k
        }
384
207k
        ss->row++;
385
207k
        if (rows_left > 0 && --rows_left == 0)
386
1
            goto ck_eol;  /* handle EOD if it is present */
387
207k
        if (ss->K != 0) {
388
207k
            byte *prev_bits = ss->lprev;
389
207k
            byte *prev_start = ss->lprevstart;
390
391
207k
            ss->lprev = ss->lbuf;
392
207k
            ss->lprevstart = ss->lbufstart;
393
207k
            ss->lbuf = prev_bits;
394
207k
            ss->lbufstart = prev_start;
395
207k
            if (ss->K > 0)
396
0
                k_left = (k_left == 0 ? ss->K : k_left) - 1;
397
207k
        }
398
207k
        ss->rpos = ss->wpos = -1;
399
207k
        ss->eol_count = eol_count = 0;
400
207k
        ss->cbit = 0;
401
207k
        ss->invert = (ss->BlackIs1 ? 0 : 0xff);
402
207k
        memset(ss->lbuf, ss->invert, wstop + 1);
403
207k
        ss->run_color = 0;
404
        /*
405
         * If EndOfLine is true, we want to include the byte padding
406
         * in the string of initial zeros in the EOL.  If EndOfLine
407
         * is false, we aren't sure what we should do....
408
         */
409
207k
        if (ss->EncodedByteAlign && !ss->EndOfLine)
410
0
            ss->bits_left &= ~7;
411
207k
    }
412
    /* If we're between scan lines, scan for EOLs. */
413
213k
    if (ss->wpos < 0) {
414
            /*
415
             * According to Adobe, the decoder should always check for
416
             * the EOD sequence, regardless of EndOfBlock: the Red Book's
417
             * documentation of EndOfBlock is wrong.
418
             */
419
213k
ck_eol:
420
219k
        while ((status = cf_decode_eol(ss, pr)) > 0) {
421
12.7k
            if_debug0m('w', ss->memory, "[w]EOL\n");
422
            /* If we are in a Group 3 mixed regime, */
423
            /* check the next bit for 1- vs. 2-D. */
424
12.7k
            if (ss->K > 0) {
425
0
                hcd_declare_state;
426
0
                hcd_load_state();
427
0
                ensure_bits(1, out); /* can't fail */
428
0
                k_left = (peek_bits(1) ? 0 : 1);
429
0
                skip_bits(1);
430
0
                hcd_store_state();
431
0
            }
432
12.7k
            ++eol_count;
433
12.7k
            if (eol_count == (ss->K < 0 ? 2 : 6)) {
434
6.39k
                status = EOFC;
435
6.39k
                goto out;
436
6.39k
            }
437
12.7k
        }
438
207k
        if (rows_left == 0) {
439
1
            status = EOFC;
440
1
            goto out;
441
1
        }
442
207k
        if (status == 0)  /* input empty while scanning EOLs */
443
9
            goto out;
444
207k
        switch (eol_count) {
445
207k
            case 0:
446
207k
                if (ss->EndOfLine) { /* EOL is required, but none is present. */
447
0
                    status = ERRC;
448
0
                    goto check;
449
0
                }
450
207k
            case 1:
451
207k
                break;
452
0
            default:
453
0
                status = ERRC;
454
0
                goto check;
455
207k
        }
456
207k
    }
457
    /* Now decode actual data. */
458
207k
    if (k_left < 0) {
459
207k
        if_debug0m('w', ss->memory, "[w2]new row\n");
460
207k
        status = cf_decode_2d(ss, pr);
461
207k
    } else if (k_left == 0) {
462
0
        if_debug0m('w', ss->memory, "[w1]new row\n");
463
0
        status = cf_decode_1d(ss, pr);
464
0
    } else {
465
0
        if_debug1m('w', ss->memory, "[w1]new 2-D row, k_left=%d\n", k_left);
466
0
        status = cf_decode_2d(ss, pr);
467
0
    }
468
207k
    if_debug3m('w', ss->memory, "[w]CFD status = %d, wpos = %d, cbit = %d\n",
469
207k
               status, ss->wpos, ss->cbit);
470
207k
  check:switch (status) {
471
207k
        case 1:   /* output full */
472
207k
            goto top;
473
8
        case ERRC:
474
            /* Check for special handling of damaged rows. */
475
8
            if (ss->damaged_rows >= ss->DamagedRowsBeforeError ||
476
8
                !(ss->EndOfLine && ss->K >= 0)
477
8
                )
478
8
                break;
479
            /* Substitute undamaged data if appropriate. */
480
            /****** NOT IMPLEMENTED YET ******/
481
0
            {
482
0
                ss->wpos = wstop;
483
0
                ss->cbit = -ss->Columns & 7;
484
0
                ss->run_color = 0;
485
0
            }
486
0
            ss->skipping_damage = true;
487
0
            goto top;
488
0
        default:
489
0
            ss->damaged_rows = 0; /* finished a good row */
490
207k
    }
491
6.41k
  out:ss->k_left = k_left;
492
6.41k
    ss->rows_left = rows_left;
493
6.41k
    ss->eol_count = eol_count;
494
6.41k
    if (ss->ErrsAsEOD && status < 0)
495
0
        return EOFC;
496
6.41k
    return status;
497
6.41k
}
498
499
/*
500
 * Decode a leading EOL, if any.
501
 * If an EOL is present, skip over it and return 1;
502
 * if no EOL is present, read no input and return -N, where N is the
503
 * number of initial bits that can be skipped in the search for an EOL;
504
 * if more input is needed, return 0.
505
 * Note that if we detected an EOL, we know that we can back up over it;
506
 * if we detected an N-bit non-EOL, we know that at least N bits of data
507
 * are available in the buffer.
508
 */
509
static int
510
cf_decode_eol(stream_CFD_state * ss, stream_cursor_read * pr)
511
219k
{
512
219k
    hcd_declare_state;
513
219k
    int zeros;
514
219k
    int look_ahead;
515
516
219k
    hcd_load_state();
517
473k
    for (zeros = 0; zeros < run_eol_code_length - 1; zeros++) {
518
461k
        ensure_bits(1, out);
519
461k
        if (peek_bits(1))
520
207k
            return -(zeros + 1);
521
253k
        skip_bits(1);
522
253k
    }
523
    /* We definitely have an EOL.  Skip further zero bits. */
524
12.7k
    look_ahead = (ss->K > 0 ? 2 : 1);
525
12.7k
    for (;;) {
526
12.7k
        ensure_bits(look_ahead, back);
527
12.7k
        if (peek_bits(1))
528
12.7k
            break;
529
0
        skip_bits(1);
530
0
    }
531
12.7k
    skip_bits(1);
532
12.7k
    hcd_store_state();
533
12.7k
    return 1;
534
0
  back:     /*
535
                                 * We ran out of data while skipping zeros.
536
                                 * We know we are at a byte boundary, and have just skipped
537
                                 * at least run_eol_code_length - 1 zeros.  However,
538
                                 * bits_left may be 1 if look_ahead == 2.
539
                                 */
540
0
    bits &= (1 << bits_left) - 1;
541
0
    bits_left += run_eol_code_length - 1;
542
0
    hcd_store_state();
543
9
  out:return 0;
544
0
}
545
546
/* Decode a 1-D scan line. */
547
static int
548
cf_decode_1d(stream_CFD_state * ss, stream_cursor_read * pr)
549
0
{
550
0
    cfd_declare_state;
551
0
    byte black_byte = (ss->BlackIs1 ? 0xff : 0);
552
0
    int end_bit = -ss->Columns & 7;
553
0
    byte *stop = ss->lbuf - 1 + ss->raster;
554
0
    int run_color = ss->run_color;
555
0
    int status;
556
0
    int bcnt;
557
0
    (void)rlimit;
558
559
0
    cfd_load_state();
560
0
    if_debug1m('w', ss->memory, "[w1]entry run_color = %d\n", ss->run_color);
561
0
    if (run_color > 0)
562
0
        goto db;
563
0
    else
564
0
        goto dw;
565
0
#define q_at_stop() (q >= stop && (qbit <= end_bit || q > stop))
566
0
    while (1)
567
0
    {
568
0
        run_color = 0;
569
0
        if (q_at_stop())
570
0
            goto done;
571
572
0
  dw:   /* Decode a white run. */
573
0
        do {
574
0
            cfd_store_state();
575
0
            status = get_run(ss, pr, cf_white_decode, cfd_white_initial_bits,
576
0
                             cfd_white_min_bits, &bcnt, "[w1]white");
577
0
            cfd_load_state();
578
0
            if (status < 0) {
579
                /* We already set run_color to 0 or -1. */
580
0
                status = 0;
581
0
                goto out;
582
0
            }
583
584
0
            if (bcnt < 0) {   /* exceptional situation */
585
0
                switch (bcnt) {
586
0
                    case run_uncompressed: /* Uncompressed data. */
587
0
                        cfd_store_state();
588
0
                        bcnt = cf_decode_uncompressed(ss, pr);
589
0
                        if (bcnt < 0)
590
0
                            return bcnt;
591
0
                        cfd_load_state();
592
0
                        if (bcnt)
593
0
                            goto db;
594
0
                        else
595
0
                            continue; /* Restart decoding white */
596
                        /*case run_error: */
597
                        /*case run_zeros: *//* Premature end-of-line. */
598
0
                    default:
599
0
                        status = ERRC;
600
0
                        goto out;
601
0
                }
602
0
            }
603
604
0
            cfd_store_state();
605
0
            status = skip_data(ss, pr, bcnt);
606
0
            cfd_load_state();
607
0
            if (status < 0) {
608
                /* If we run out of data after a makeup code, */
609
                /* note that we are still processing a white run. */
610
0
                run_color = -1;
611
0
            }
612
0
        } while (status < 0);
613
614
0
        if (q_at_stop()) {
615
0
            run_color = 0;    /* not inside a run */
616
0
  done:
617
0
            if (q > stop || qbit < end_bit)
618
0
                status = ERRC;
619
0
            else
620
0
                status = 1;
621
0
            break;
622
0
        }
623
0
        run_color = 1;
624
625
0
  db:   /* Decode a black run. */
626
0
        do {
627
0
            cfd_store_state();
628
0
            status = get_run(ss, pr, cf_black_decode, cfd_black_initial_bits,
629
0
                             cfd_black_min_bits, &bcnt, "[w1]black");
630
0
            cfd_load_state();
631
0
            if (status < 0) {
632
                /* We already set run_color to 1 or 2. */
633
0
                status = 0;
634
0
                goto out;
635
0
            }
636
637
0
            if (bcnt < 0) {  /* All exceptional codes are invalid here. */
638
                /****** WRONG, uncompressed IS ALLOWED ******/
639
0
                status = ERRC;
640
0
                goto out;
641
0
            }
642
643
            /* Invert bits designated by black run. */
644
0
            cfd_store_state();
645
0
            status = invert_data(ss, pr, &bcnt, black_byte);
646
0
            cfd_load_state();
647
0
            if (status < 0) {
648
                /* If we run out of data after a makeup code, */
649
                /* note that we are still processing a black run. */
650
0
                run_color = 2;
651
0
            }
652
0
        } while (status < 0);
653
0
    }
654
655
0
out:
656
0
    cfd_store_state();
657
0
    ss->run_color = run_color;
658
0
    if_debug1m('w', ss->memory, "[w1]exit run_color = %d\n", run_color);
659
0
    return status;
660
0
}
661
662
/* Decode a 2-D scan line. */
663
static int
664
cf_decode_2d(stream_CFD_state * ss, stream_cursor_read * pr)
665
207k
{
666
207k
    cfd_declare_state;
667
207k
    byte invert_white = (ss->BlackIs1 ? 0 : 0xff);
668
207k
    byte black_byte = ~invert_white;
669
207k
    byte invert = ss->invert;
670
207k
    int end_count = -ss->Columns & 7;
671
207k
    uint raster = ss->raster;
672
207k
    byte *q0 = ss->lbuf;
673
207k
    byte *prev_q01 = ss->lprev + 1;
674
207k
    byte *endptr = q0 - 1 + raster;
675
207k
    int init_count = raster << 3;
676
207k
    register int count;
677
207k
    int rlen;
678
207k
    int status;
679
680
207k
    cfd_load_state();
681
207k
    count = ((endptr - q) << 3) + qbit;
682
207k
    endptr[1] = 0xa0;   /* a byte with some 0s and some 1s, */
683
    /* to ensure run scan will stop */
684
207k
    if_debug1m('W', ss->memory, "[w2]raster=%d\n", raster);
685
207k
    switch (ss->run_color) {
686
0
        case -2:
687
0
            ss->run_color = 0;
688
0
            goto hww;
689
0
        case -1:
690
0
            ss->run_color = 0;
691
0
            goto hbw;
692
0
        case 1:
693
0
            ss->run_color = 0;
694
0
            goto hwb;
695
0
        case 2:
696
0
            ss->run_color = 0;
697
0
            goto hbb;
698
            /*case 0: */
699
207k
    }
700
701
    /* top of decode loop */
702
1.06M
    while (1)
703
1.06M
    {
704
1.06M
        if (count <= end_count) {
705
207k
            status = (count < end_count ? ERRC : 1);
706
207k
            goto out;
707
207k
        }
708
        /* If invert == invert_white, white and black have their */
709
        /* correct meanings; if invert == ~invert_white, */
710
        /* black and white are interchanged. */
711
1.06M
        if_debug1m('W', ss->memory, "[w2]%4d:\n", count);
712
#ifdef DEBUG
713
        /* Check the invariant between q, qbit, and count. */
714
        {
715
            int pcount = (endptr - q) * 8 + qbit;
716
717
            if (pcount != count)
718
                dmlprintf2(ss->memory, "[w2]Error: count=%d pcount=%d\n",
719
                           count, pcount);
720
        }
721
#endif
722
        /*
723
         * We could just use get_run here, but we can do better.  However,
724
         * we must be careful to handle the case where the very last codes
725
         * in the input stream are 1-bit "vertical 0" codes: we can't just
726
         * use ensure_bits(3, ...) and go to get more data if it fails.
727
         */
728
854k
        ensure_bits(3, out3);
729
1.60M
#define vertical_0 (countof(cf2_run_vertical) / 2)
730
854k
        switch (peek_bits(3)) {
731
625k
        default /*4..7*/ :  /* vertical(0) */
732
625k
            if (0) {
733
0
 out3:
734
                /* Unless it's a 1-bit "vertical 0" code, exit. */
735
0
                if (!(bits_left > 0 && peek_bits(1)))
736
0
                    goto out0;
737
0
            }
738
625k
            skip_bits(1);
739
625k
            rlen = vertical_0;
740
625k
            break;
741
84.4k
        case 2:   /* vertical(+1) */
742
84.4k
            skip_bits(3);
743
84.4k
            rlen = vertical_0 + 1;
744
84.4k
            break;
745
75.4k
        case 3:   /* vertical(-1) */
746
75.4k
            skip_bits(3);
747
75.4k
            rlen = vertical_0 - 1;
748
75.4k
            break;
749
22.5k
        case 1:   /* horizontal */
750
22.5k
            skip_bits(3);
751
22.5k
            if (invert == invert_white) {
752
                /* We handle horizontal decoding here, so that we can
753
                 * branch back into it if we run out of input data. */
754
                /* White, then black. */
755
13.1k
  hww:
756
13.1k
                do {
757
13.1k
                    cfd_store_state();
758
13.1k
                    status = get_run(ss, pr, cf_white_decode,
759
13.1k
                                     cfd_white_initial_bits,
760
13.1k
                                     cfd_white_min_bits, &rlen, " white");
761
13.1k
                    cfd_load_state();
762
13.1k
                    if (status < 0) {
763
0
                        ss->run_color = -2;
764
0
                        goto out0;
765
0
                    }
766
767
13.1k
                    if ((count -= rlen) < end_count) {
768
0
                        status = ERRC;
769
0
                        goto out;
770
0
                    }
771
13.1k
                    if (rlen < 0) goto rlen_lt_zero;
772
773
13.1k
                    cfd_store_state();
774
13.1k
                    status = skip_data(ss, pr, rlen);
775
13.1k
                    cfd_load_state();
776
13.1k
                } while (status < 0);
777
778
                /* Handle the second half of a white-black horizontal code. */
779
13.1k
  hwb:
780
13.1k
                do {
781
13.1k
                    cfd_store_state();
782
13.1k
                    status = get_run(ss, pr, cf_black_decode,
783
13.1k
                                     cfd_black_initial_bits,
784
13.1k
                                     cfd_black_min_bits, &rlen, " black");
785
13.1k
                    cfd_load_state();
786
13.1k
                    if (status < 0){
787
0
                        ss->run_color = 1;
788
0
                        goto out0;
789
0
                    }
790
791
13.1k
                    if ((count -= rlen) < end_count) {
792
0
                        status = ERRC;
793
0
                        goto out;
794
0
                    }
795
13.1k
                    if (rlen < 0) goto rlen_lt_zero;
796
797
13.1k
                    cfd_store_state();
798
13.1k
                    status = invert_data(ss, pr, &rlen, black_byte);
799
13.1k
                    cfd_load_state();
800
13.1k
                } while (status < 0);
801
13.1k
            } else {
802
                /* Black, then white. */
803
9.41k
  hbb:
804
9.47k
                do {
805
9.47k
                    cfd_store_state();
806
9.47k
                    status = get_run(ss, pr, cf_black_decode,
807
9.47k
                                     cfd_black_initial_bits,
808
9.47k
                                     cfd_black_min_bits, &rlen, " black");
809
9.47k
                    cfd_load_state();
810
9.47k
                    if (status < 0) {
811
0
                        ss->run_color = 2;
812
0
                        goto out0;
813
0
                    }
814
815
9.47k
                    if ((count -= rlen) < end_count) {
816
0
                        status = ERRC;
817
0
                        goto out;
818
0
                    }
819
9.47k
                    if (rlen < 0) goto rlen_lt_zero;
820
821
9.47k
                    cfd_store_state();
822
9.47k
                    status = invert_data(ss, pr, &rlen, black_byte);
823
9.47k
                    cfd_load_state();
824
9.47k
                }
825
9.47k
                while (status < 0);
826
827
                /* Handle the second half of a black-white horizontal code. */
828
9.41k
  hbw:
829
9.49k
                do {
830
9.49k
                    cfd_store_state();
831
9.49k
                    status = get_run(ss, pr, cf_white_decode,
832
9.49k
                                     cfd_white_initial_bits,
833
9.49k
                                     cfd_white_min_bits, &rlen, " white");
834
9.49k
                    cfd_load_state();
835
9.49k
                    if (status < 0) {
836
0
                        ss->run_color = -1;
837
0
                        goto out0;
838
0
                    }
839
840
9.49k
                    if ((count -= rlen) < end_count) {
841
0
                        status = ERRC;
842
0
                        goto out;
843
0
                    }
844
9.49k
                    if (rlen < 0) goto rlen_lt_zero;
845
846
9.49k
                    cfd_store_state();
847
9.49k
                    status = skip_data(ss, pr, rlen);
848
9.49k
                    cfd_load_state();
849
9.49k
                } while (status < 0);
850
9.41k
            }
851
22.5k
            continue; /* jump back to top of decode loop */
852
46.7k
        case 0:   /* everything else */
853
46.7k
            cfd_store_state();
854
46.7k
            status = get_run(ss, pr, cf_2d_decode, cfd_2d_initial_bits,
855
46.7k
                             cfd_2d_min_bits, &rlen, "[w2]");
856
46.7k
            cfd_load_state();
857
46.7k
            if (status < 0) {
858
0
                goto out0;
859
0
            }
860
861
            /* rlen may be run2_pass, run_uncompressed, or */
862
            /* 0..countof(cf2_run_vertical)-1. */
863
46.7k
            if (rlen < 0) {
864
8.89k
rlen_lt_zero:
865
8.89k
                switch (rlen) {
866
8.89k
                case run2_pass:
867
8.89k
                    break;
868
0
                case run_uncompressed:
869
0
                {
870
0
                    int which;
871
872
0
                    cfd_store_state();
873
0
                    which = cf_decode_uncompressed(ss, pr);
874
0
                    if (which < 0) {
875
0
                        status = which;
876
0
                        goto out;
877
0
                    }
878
0
                    cfd_load_state();
879
/****** ADJUST count ******/
880
0
                    invert = (which ? ~invert_white : invert_white);
881
0
                    continue; /* jump back to top of decode loop */
882
0
                }
883
0
                default:  /* run_error, run_zeros */
884
0
                    status = ERRC;
885
0
                    goto out;
886
8.89k
                }
887
8.89k
            }
888
854k
        }
889
        /* Interpreting the run requires scanning the */
890
        /* previous ('reference') line. */
891
832k
        {
892
832k
            int prev_count = count;
893
832k
            byte prev_data;
894
832k
            int dlen;
895
832k
            static const byte count_bit[8] =
896
832k
                                   {0x80, 1, 2, 4, 8, 0x10, 0x20, 0x40};
897
832k
            byte *prev_q = prev_q01 + (q - q0);
898
832k
            int plen;
899
900
832k
            if (!(count & 7))
901
281k
                prev_q++;   /* because of skip macros */
902
832k
            prev_data = prev_q[-1] ^ invert;
903
            /* Find the b1 transition. */
904
832k
            if ((prev_data & count_bit[prev_count & 7]) &&
905
832k
                (prev_count < init_count || invert != invert_white)
906
832k
                ) {     /* Look for changing white first. */
907
101k
                if_debug1m('W', ss->memory, " data=0x%x", prev_data);
908
101k
                skip_black_pixels(prev_data, prev_q,
909
101k
                                  prev_count, invert, plen);
910
101k
                if (prev_count < end_count)    /* overshot */
911
1
                    prev_count = end_count;
912
101k
                if_debug1m('W', ss->memory, " b1 other=%d", prev_count);
913
101k
            }
914
832k
            if (prev_count != end_count) {
915
832k
                if_debug1m('W', ss->memory, " data=0x%x", prev_data);
916
832k
                skip_white_pixels(prev_data, prev_q,
917
832k
                                  prev_count, invert, plen);
918
832k
                if (prev_count < end_count)    /* overshot */
919
8
                    prev_count = end_count;
920
832k
                if_debug1m('W', ss->memory, " b1 same=%d", prev_count);
921
832k
            }
922
            /* b1 = prev_count; */
923
832k
            if (rlen == run2_pass) { /* Pass mode.  Find b2. */
924
8.89k
                if (prev_count != end_count) {
925
8.89k
                    if_debug1m('W', ss->memory, " data=0x%x", prev_data);
926
8.89k
                    skip_black_pixels(prev_data, prev_q,
927
8.89k
                                      prev_count, invert, plen);
928
8.89k
                    if (prev_count < end_count)  /* overshot */
929
0
                        prev_count = end_count;
930
8.89k
                }
931
                /* b2 = prev_count; */
932
8.89k
                if_debug2m('W', ss->memory, " b2=%d, pass %d\n",
933
8.89k
                           prev_count, count - prev_count);
934
823k
            } else {   /* Vertical coding. */
935
                /* Remember that count counts *down*. */
936
823k
                prev_count += rlen - vertical_0; /* a1 */
937
823k
                if_debug2m('W', ss->memory, " vertical %d -> %d\n",
938
823k
                           (int)(rlen - vertical_0), prev_count);
939
823k
            }
940
            /* Now either invert or skip from count */
941
            /* to prev_count, and reset count. */
942
832k
            if (invert == invert_white) { /* Skip data bits. */
943
517k
                q = endptr - (prev_count >> 3);
944
517k
                qbit = prev_count & 7;
945
517k
            } else {   /* Invert data bits. */
946
315k
                dlen = count - prev_count;
947
948
315k
                cfd_store_state();
949
315k
                (void)invert_data(ss, pr, &dlen, black_byte);
950
315k
                cfd_load_state();
951
315k
            }
952
832k
            count = prev_count;
953
832k
            if (rlen >= 0)    /* vertical mode */
954
823k
                invert = ~invert; /* polarity changes */
955
832k
        }
956
        /* jump back to top of decode loop */
957
832k
    }
958
959
0
  out0:status = 0;
960
    /* falls through */
961
207k
  out:cfd_store_state();
962
207k
    ss->invert = invert;
963
    /* Ignore an error (missing EOFB/RTC when EndOfBlock == true) */
964
    /* if we have finished all rows. */
965
207k
    if (status == ERRC && ss->Rows > 0 && ss->row > ss->Rows)
966
0
        status = EOFC;
967
207k
    return status;
968
0
}
969
970
#if 1       /*************** */
971
static int
972
cf_decode_uncompressed(stream_CFD_state * ss, stream_cursor_read * pr)
973
0
{
974
0
    return ERRC;
975
0
}
976
#else /*************** */
977
978
/* Decode uncompressed data. */
979
/* (Not tested: no sample data available!) */
980
/****** DOESN'T CHECK FOR OVERFLOWING SCAN LINE ******/
981
static int
982
cf_decode_uncompressed(stream * s)
983
{
984
    cfd_declare_state;
985
    const cfd_node *np;
986
    int clen, rlen;
987
988
    cfd_load_state();
989
    while (1) {
990
        ensure_bits(cfd_uncompressed_initial_bits, NOOUT);
991
        np = &cf_uncompressed_decode[peek_bits(cfd_uncompressed_initial_bits)];
992
        clen = np->code_length;
993
        rlen = np->run_length;
994
        if (clen > cfd_uncompressed_initial_bits) { /* Must be an exit code. */
995
            break;
996
        }
997
        if (rlen == cfd_uncompressed_initial_bits) {  /* Longest representable white run */
998
            if_debug1m('W', s->memory, "[wu]%d\n", rlen);
999
            if ((qbit -= cfd_uncompressed_initial_bits) < 0)
1000
                qbit += 8, q++;
1001
        } else {
1002
            if_debug1m('W', s->memory, "[wu]%d+1\n", rlen);
1003
            if (qbit -= rlen < 0)
1004
                qbit += 8, q++;
1005
            *q ^= 1 << qbit;
1006
        }
1007
        skip_bits(clen);
1008
    }
1009
    clen -= cfd_uncompressed_initial_bits;
1010
    skip_bits(cfd_uncompressed_initial_bits);
1011
    ensure_bits(clen, NOOUT);
1012
    np = &cf_uncompressed_decode[rlen + peek_var_bits(clen)];
1013
    rlen = np->run_length;
1014
    skip_bits(np->code_length);
1015
    if_debug1m('w', s->memory, "[wu]exit %d\n", rlen);
1016
    if (rlen >= 0) {    /* Valid exit code, rlen = 2 * run length + next polarity */
1017
        if ((qbit -= rlen >> 1) < 0)
1018
            qbit += 8, q++;
1019
        rlen &= 1;
1020
    }
1021
  out:        /******* WRONG ******/
1022
    cfd_store_state();
1023
    return rlen;
1024
}
1025
1026
#endif /*************** */
1027
1028
/* Stream template */
1029
const stream_template s_CFD_template =
1030
{&st_CFD_state, s_CFD_init, s_CFD_process, 1, 1, s_CFD_release,
1031
 s_CFD_set_defaults
1032
};