732 lines
18 KiB
C
732 lines
18 KiB
C
#include "fitz.h"
|
|
|
|
/* Fax G3/G4 decoder */
|
|
|
|
/* TODO: uncompressed */
|
|
|
|
/*
|
|
<raph> the first 2^(initialbits) entries map bit patterns to decodes
|
|
<raph> let's say initial_bits is 8 for the sake of example
|
|
<raph> and that the code is 1001
|
|
<raph> that means that entries 0x90 .. 0x9f have the entry { val, 4 }
|
|
<raph> because those are all the bytes that start with the code
|
|
<raph> and the 4 is the length of the code
|
|
... if (n_bits > initial_bits) ...
|
|
<raph> anyway, in that case, it basically points to a mini table
|
|
<raph> the n_bits is the maximum length of all codes beginning with that byte
|
|
<raph> so 2^(n_bits - initial_bits) is the size of the mini-table
|
|
<raph> peter came up with this, and it makes sense
|
|
*/
|
|
|
|
typedef struct cfd_node_s cfd_node;
|
|
|
|
struct cfd_node_s
|
|
{
|
|
short val;
|
|
short nbits;
|
|
};
|
|
|
|
enum
|
|
{
|
|
cfd_white_initial_bits = 8,
|
|
cfd_black_initial_bits = 7,
|
|
cfd_2d_initial_bits = 7,
|
|
cfd_uncompressed_initial_bits = 6 /* must be 6 */
|
|
};
|
|
|
|
/* non-run codes in tables */
|
|
enum
|
|
{
|
|
ERROR = -1,
|
|
ZEROS = -2, /* EOL follows, possibly with more padding first */
|
|
UNCOMPRESSED = -3
|
|
};
|
|
|
|
/* semantic codes for cf_2d_decode */
|
|
enum
|
|
{
|
|
P = -4,
|
|
H = -5,
|
|
VR3 = 0,
|
|
VR2 = 1,
|
|
VR1 = 2,
|
|
V0 = 3,
|
|
VL1 = 4,
|
|
VL2 = 5,
|
|
VL3 = 6
|
|
};
|
|
|
|
/* White decoding table. */
|
|
const cfd_node cf_white_decode[] = {
|
|
{256,12},{272,12},{29,8},{30,8},{45,8},{46,8},{22,7},{22,7},
|
|
{23,7},{23,7},{47,8},{48,8},{13,6},{13,6},{13,6},{13,6},{20,7},
|
|
{20,7},{33,8},{34,8},{35,8},{36,8},{37,8},{38,8},{19,7},{19,7},
|
|
{31,8},{32,8},{1,6},{1,6},{1,6},{1,6},{12,6},{12,6},{12,6},{12,6},
|
|
{53,8},{54,8},{26,7},{26,7},{39,8},{40,8},{41,8},{42,8},{43,8},
|
|
{44,8},{21,7},{21,7},{28,7},{28,7},{61,8},{62,8},{63,8},{0,8},
|
|
{320,8},{384,8},{10,5},{10,5},{10,5},{10,5},{10,5},{10,5},{10,5},
|
|
{10,5},{11,5},{11,5},{11,5},{11,5},{11,5},{11,5},{11,5},{11,5},
|
|
{27,7},{27,7},{59,8},{60,8},{288,9},{290,9},{18,7},{18,7},{24,7},
|
|
{24,7},{49,8},{50,8},{51,8},{52,8},{25,7},{25,7},{55,8},{56,8},
|
|
{57,8},{58,8},{192,6},{192,6},{192,6},{192,6},{1664,6},{1664,6},
|
|
{1664,6},{1664,6},{448,8},{512,8},{292,9},{640,8},{576,8},{294,9},
|
|
{296,9},{298,9},{300,9},{302,9},{256,7},{256,7},{2,4},{2,4},{2,4},
|
|
{2,4},{2,4},{2,4},{2,4},{2,4},{2,4},{2,4},{2,4},{2,4},{2,4},{2,4},
|
|
{2,4},{2,4},{3,4},{3,4},{3,4},{3,4},{3,4},{3,4},{3,4},{3,4},{3,4},
|
|
{3,4},{3,4},{3,4},{3,4},{3,4},{3,4},{3,4},{128,5},{128,5},{128,5},
|
|
{128,5},{128,5},{128,5},{128,5},{128,5},{8,5},{8,5},{8,5},{8,5},
|
|
{8,5},{8,5},{8,5},{8,5},{9,5},{9,5},{9,5},{9,5},{9,5},{9,5},{9,5},
|
|
{9,5},{16,6},{16,6},{16,6},{16,6},{17,6},{17,6},{17,6},{17,6},
|
|
{4,4},{4,4},{4,4},{4,4},{4,4},{4,4},{4,4},{4,4},{4,4},{4,4},{4,4},
|
|
{4,4},{4,4},{4,4},{4,4},{4,4},{5,4},{5,4},{5,4},{5,4},{5,4},{5,4},
|
|
{5,4},{5,4},{5,4},{5,4},{5,4},{5,4},{5,4},{5,4},{5,4},{5,4},
|
|
{14,6},{14,6},{14,6},{14,6},{15,6},{15,6},{15,6},{15,6},{64,5},
|
|
{64,5},{64,5},{64,5},{64,5},{64,5},{64,5},{64,5},{6,4},{6,4},
|
|
{6,4},{6,4},{6,4},{6,4},{6,4},{6,4},{6,4},{6,4},{6,4},{6,4},{6,4},
|
|
{6,4},{6,4},{6,4},{7,4},{7,4},{7,4},{7,4},{7,4},{7,4},{7,4},{7,4},
|
|
{7,4},{7,4},{7,4},{7,4},{7,4},{7,4},{7,4},{7,4},{-2,3},{-2,3},
|
|
{-1,0},{-1,0},{-1,0},{-1,0},{-1,0},{-1,0},{-1,0},{-1,0},{-1,0},
|
|
{-1,0},{-1,0},{-1,0},{-1,0},{-3,4},{1792,3},{1792,3},{1984,4},
|
|
{2048,4},{2112,4},{2176,4},{2240,4},{2304,4},{1856,3},{1856,3},
|
|
{1920,3},{1920,3},{2368,4},{2432,4},{2496,4},{2560,4},{1472,1},
|
|
{1536,1},{1600,1},{1728,1},{704,1},{768,1},{832,1},{896,1},
|
|
{960,1},{1024,1},{1088,1},{1152,1},{1216,1},{1280,1},{1344,1},
|
|
{1408,1}
|
|
};
|
|
|
|
/* Black decoding table. */
|
|
const cfd_node cf_black_decode[] = {
|
|
{128,12},{160,13},{224,12},{256,12},{10,7},{11,7},{288,12},{12,7},
|
|
{9,6},{9,6},{8,6},{8,6},{7,5},{7,5},{7,5},{7,5},{6,4},{6,4},{6,4},
|
|
{6,4},{6,4},{6,4},{6,4},{6,4},{5,4},{5,4},{5,4},{5,4},{5,4},{5,4},
|
|
{5,4},{5,4},{1,3},{1,3},{1,3},{1,3},{1,3},{1,3},{1,3},{1,3},{1,3},
|
|
{1,3},{1,3},{1,3},{1,3},{1,3},{1,3},{1,3},{4,3},{4,3},{4,3},{4,3},
|
|
{4,3},{4,3},{4,3},{4,3},{4,3},{4,3},{4,3},{4,3},{4,3},{4,3},{4,3},
|
|
{4,3},{3,2},{3,2},{3,2},{3,2},{3,2},{3,2},{3,2},{3,2},{3,2},{3,2},
|
|
{3,2},{3,2},{3,2},{3,2},{3,2},{3,2},{3,2},{3,2},{3,2},{3,2},{3,2},
|
|
{3,2},{3,2},{3,2},{3,2},{3,2},{3,2},{3,2},{3,2},{3,2},{3,2},{3,2},
|
|
{2,2},{2,2},{2,2},{2,2},{2,2},{2,2},{2,2},{2,2},{2,2},{2,2},{2,2},
|
|
{2,2},{2,2},{2,2},{2,2},{2,2},{2,2},{2,2},{2,2},{2,2},{2,2},{2,2},
|
|
{2,2},{2,2},{2,2},{2,2},{2,2},{2,2},{2,2},{2,2},{2,2},{2,2},
|
|
{-2,4},{-2,4},{-1,0},{-1,0},{-1,0},{-1,0},{-1,0},{-1,0},{-1,0},
|
|
{-1,0},{-1,0},{-1,0},{-1,0},{-1,0},{-1,0},{-3,5},{1792,4},
|
|
{1792,4},{1984,5},{2048,5},{2112,5},{2176,5},{2240,5},{2304,5},
|
|
{1856,4},{1856,4},{1920,4},{1920,4},{2368,5},{2432,5},{2496,5},
|
|
{2560,5},{18,3},{18,3},{18,3},{18,3},{18,3},{18,3},{18,3},{18,3},
|
|
{52,5},{52,5},{640,6},{704,6},{768,6},{832,6},{55,5},{55,5},
|
|
{56,5},{56,5},{1280,6},{1344,6},{1408,6},{1472,6},{59,5},{59,5},
|
|
{60,5},{60,5},{1536,6},{1600,6},{24,4},{24,4},{24,4},{24,4},
|
|
{25,4},{25,4},{25,4},{25,4},{1664,6},{1728,6},{320,5},{320,5},
|
|
{384,5},{384,5},{448,5},{448,5},{512,6},{576,6},{53,5},{53,5},
|
|
{54,5},{54,5},{896,6},{960,6},{1024,6},{1088,6},{1152,6},{1216,6},
|
|
{64,3},{64,3},{64,3},{64,3},{64,3},{64,3},{64,3},{64,3},{13,1},
|
|
{13,1},{13,1},{13,1},{13,1},{13,1},{13,1},{13,1},{13,1},{13,1},
|
|
{13,1},{13,1},{13,1},{13,1},{13,1},{13,1},{23,4},{23,4},{50,5},
|
|
{51,5},{44,5},{45,5},{46,5},{47,5},{57,5},{58,5},{61,5},{256,5},
|
|
{16,3},{16,3},{16,3},{16,3},{17,3},{17,3},{17,3},{17,3},{48,5},
|
|
{49,5},{62,5},{63,5},{30,5},{31,5},{32,5},{33,5},{40,5},{41,5},
|
|
{22,4},{22,4},{14,1},{14,1},{14,1},{14,1},{14,1},{14,1},{14,1},
|
|
{14,1},{14,1},{14,1},{14,1},{14,1},{14,1},{14,1},{14,1},{14,1},
|
|
{15,2},{15,2},{15,2},{15,2},{15,2},{15,2},{15,2},{15,2},{128,5},
|
|
{192,5},{26,5},{27,5},{28,5},{29,5},{19,4},{19,4},{20,4},{20,4},
|
|
{34,5},{35,5},{36,5},{37,5},{38,5},{39,5},{21,4},{21,4},{42,5},
|
|
{43,5},{0,3},{0,3},{0,3},{0,3}
|
|
};
|
|
|
|
/* 2-D decoding table. */
|
|
const cfd_node cf_2d_decode[] = {
|
|
{128,11},{144,10},{6,7},{0,7},{5,6},{5,6},{1,6},{1,6},{-4,4},
|
|
{-4,4},{-4,4},{-4,4},{-4,4},{-4,4},{-4,4},{-4,4},{-5,3},{-5,3},
|
|
{-5,3},{-5,3},{-5,3},{-5,3},{-5,3},{-5,3},{-5,3},{-5,3},{-5,3},
|
|
{-5,3},{-5,3},{-5,3},{-5,3},{-5,3},{4,3},{4,3},{4,3},{4,3},{4,3},
|
|
{4,3},{4,3},{4,3},{4,3},{4,3},{4,3},{4,3},{4,3},{4,3},{4,3},{4,3},
|
|
{2,3},{2,3},{2,3},{2,3},{2,3},{2,3},{2,3},{2,3},{2,3},{2,3},{2,3},
|
|
{2,3},{2,3},{2,3},{2,3},{2,3},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},
|
|
{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},
|
|
{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},
|
|
{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},
|
|
{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},
|
|
{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},{3,1},
|
|
{3,1},{3,1},{3,1},{-2,4},{-1,0},{-1,0},{-1,0},{-1,0},{-1,0},
|
|
{-1,0},{-1,0},{-1,0},{-1,0},{-1,0},{-1,0},{-1,0},{-1,0},{-1,0},
|
|
{-1,0},{-1,0},{-1,0},{-1,0},{-1,0},{-1,0},{-1,0},{-1,0},{-3,3}
|
|
};
|
|
|
|
/* Uncompresssed decoding table. */
|
|
const cfd_node cf_uncompressed_decode[] = {
|
|
{64,12},{5,6},{4,5},{4,5},{3,4},{3,4},{3,4},{3,4},{2,3},{2,3},
|
|
{2,3},{2,3},{2,3},{2,3},{2,3},{2,3},{1,2},{1,2},{1,2},{1,2},{1,2},
|
|
{1,2},{1,2},{1,2},{1,2},{1,2},{1,2},{1,2},{1,2},{1,2},{1,2},{1,2},
|
|
{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},
|
|
{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},
|
|
{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},{0,1},
|
|
{-1,0},{-1,0},{8,6},{9,6},{6,5},{6,5},{7,5},{7,5},{4,4},{4,4},
|
|
{4,4},{4,4},{5,4},{5,4},{5,4},{5,4},{2,3},{2,3},{2,3},{2,3},{2,3},
|
|
{2,3},{2,3},{2,3},{3,3},{3,3},{3,3},{3,3},{3,3},{3,3},{3,3},{3,3},
|
|
{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},
|
|
{0,2},{0,2},{0,2},{0,2},{0,2},{1,2},{1,2},{1,2},{1,2},{1,2},{1,2},
|
|
{1,2},{1,2},{1,2},{1,2},{1,2},{1,2},{1,2},{1,2},{1,2},{1,2}
|
|
};
|
|
|
|
/* bit magic */
|
|
|
|
static inline int getbit(const unsigned char *buf, int x)
|
|
{
|
|
return ( buf[x >> 3] >> ( 7 - (x & 7) ) ) & 1;
|
|
}
|
|
|
|
static int
|
|
find_changing(const unsigned char *line, int x, int w)
|
|
{
|
|
int a, b;
|
|
|
|
if (!line)
|
|
return w;
|
|
|
|
if (x == -1)
|
|
{
|
|
a = 0;
|
|
x = 0;
|
|
}
|
|
else
|
|
{
|
|
a = getbit(line, x);
|
|
x++;
|
|
}
|
|
|
|
while (x < w)
|
|
{
|
|
b = getbit(line, x);
|
|
if (a != b)
|
|
break;
|
|
x++;
|
|
}
|
|
|
|
return x;
|
|
}
|
|
|
|
static int
|
|
find_changing_color(const unsigned char *line, int x, int w, int color)
|
|
{
|
|
if (!line)
|
|
return w;
|
|
|
|
x = find_changing(line, x, w);
|
|
|
|
if (x < w && getbit(line, x) != color)
|
|
x = find_changing(line, x, w);
|
|
|
|
return x;
|
|
}
|
|
|
|
static const unsigned char lm[8] = {
|
|
0xFF, 0x7F, 0x3F, 0x1F, 0x0F, 0x07, 0x03, 0x01
|
|
};
|
|
|
|
static const unsigned char rm[8] = {
|
|
0x00, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFE
|
|
};
|
|
|
|
static inline void setbits(unsigned char *line, int x0, int x1)
|
|
{
|
|
int a0, a1, b0, b1, a;
|
|
|
|
a0 = x0 >> 3;
|
|
a1 = x1 >> 3;
|
|
|
|
b0 = x0 & 7;
|
|
b1 = x1 & 7;
|
|
|
|
if (a0 == a1)
|
|
{
|
|
if (b1)
|
|
line[a0] |= lm[b0] & rm[b1];
|
|
}
|
|
else
|
|
{
|
|
line[a0] |= lm[b0];
|
|
for (a = a0 + 1; a < a1; a++)
|
|
line[a] = 0xFF;
|
|
if (b1)
|
|
line[a1] |= rm[b1];
|
|
}
|
|
}
|
|
|
|
typedef struct fz_faxd_s fz_faxd;
|
|
|
|
enum
|
|
{
|
|
STATE_NORMAL, /* neutral state, waiting for any code */
|
|
STATE_MAKEUP, /* got a 1d makeup code, waiting for terminating code */
|
|
STATE_EOL, /* at eol, needs output buffer space */
|
|
STATE_H1, STATE_H2, /* in H part 1 and 2 (both makeup and terminating codes) */
|
|
STATE_DONE /* all done */
|
|
};
|
|
|
|
struct fz_faxd_s
|
|
{
|
|
fz_stream *chain;
|
|
|
|
int k;
|
|
int end_of_line;
|
|
int encoded_byte_align;
|
|
int columns;
|
|
int rows;
|
|
int end_of_block;
|
|
int black_is_1;
|
|
|
|
int stride;
|
|
int ridx;
|
|
|
|
int bidx;
|
|
unsigned int word;
|
|
|
|
int stage;
|
|
|
|
int a, c, dim, eolc;
|
|
unsigned char *ref;
|
|
unsigned char *dst;
|
|
unsigned char *rp, *wp;
|
|
};
|
|
|
|
static inline void eat_bits(fz_faxd *fax, int nbits)
|
|
{
|
|
fax->word <<= nbits;
|
|
fax->bidx += nbits;
|
|
}
|
|
|
|
static int
|
|
fill_bits(fz_faxd *fax)
|
|
{
|
|
while (fax->bidx >= 8)
|
|
{
|
|
int c = fz_read_byte(fax->chain);
|
|
if (c == EOF)
|
|
return EOF;
|
|
fax->bidx -= 8;
|
|
fax->word |= c << fax->bidx;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
get_code(fz_faxd *fax, const cfd_node *table, int initialbits)
|
|
{
|
|
unsigned int word = fax->word;
|
|
int tidx = word >> (32 - initialbits);
|
|
int val = table[tidx].val;
|
|
int nbits = table[tidx].nbits;
|
|
|
|
if (nbits > initialbits)
|
|
{
|
|
int mask = (1 << (32 - initialbits)) - 1;
|
|
tidx = val + ((word & mask) >> (32 - nbits));
|
|
val = table[tidx].val;
|
|
nbits = initialbits + table[tidx].nbits;
|
|
}
|
|
|
|
eat_bits(fax, nbits);
|
|
|
|
return val;
|
|
}
|
|
|
|
/* decode one 1d code */
|
|
static fz_error
|
|
dec1d(fz_faxd *fax)
|
|
{
|
|
int code;
|
|
|
|
if (fax->a == -1)
|
|
fax->a = 0;
|
|
|
|
if (fax->c)
|
|
code = get_code(fax, cf_black_decode, cfd_black_initial_bits);
|
|
else
|
|
code = get_code(fax, cf_white_decode, cfd_white_initial_bits);
|
|
|
|
if (code == UNCOMPRESSED)
|
|
return fz_throw("uncompressed data in faxd");
|
|
|
|
if (code < 0)
|
|
return fz_throw("negative code in 1d faxd");
|
|
|
|
if (fax->a + code > fax->columns)
|
|
return fz_throw("overflow in 1d faxd");
|
|
|
|
if (fax->c)
|
|
setbits(fax->dst, fax->a, fax->a + code);
|
|
|
|
fax->a += code;
|
|
|
|
if (code < 64)
|
|
{
|
|
fax->c = !fax->c;
|
|
fax->stage = STATE_NORMAL;
|
|
}
|
|
else
|
|
fax->stage = STATE_MAKEUP;
|
|
|
|
return fz_okay;
|
|
}
|
|
|
|
/* decode one 2d code */
|
|
static fz_error
|
|
dec2d(fz_faxd *fax)
|
|
{
|
|
int code, b1, b2;
|
|
|
|
if (fax->stage == STATE_H1 || fax->stage == STATE_H2)
|
|
{
|
|
if (fax->a == -1)
|
|
fax->a = 0;
|
|
|
|
if (fax->c)
|
|
code = get_code(fax, cf_black_decode, cfd_black_initial_bits);
|
|
else
|
|
code = get_code(fax, cf_white_decode, cfd_white_initial_bits);
|
|
|
|
if (code == UNCOMPRESSED)
|
|
return fz_throw("uncompressed data in faxd");
|
|
|
|
if (code < 0)
|
|
return fz_throw("negative code in 2d faxd");
|
|
|
|
if (fax->a + code > fax->columns)
|
|
return fz_throw("overflow in 2d faxd");
|
|
|
|
if (fax->c)
|
|
setbits(fax->dst, fax->a, fax->a + code);
|
|
|
|
fax->a += code;
|
|
|
|
if (code < 64)
|
|
{
|
|
fax->c = !fax->c;
|
|
if (fax->stage == STATE_H1)
|
|
fax->stage = STATE_H2;
|
|
else if (fax->stage == STATE_H2)
|
|
fax->stage = STATE_NORMAL;
|
|
}
|
|
|
|
return fz_okay;
|
|
}
|
|
|
|
code = get_code(fax, cf_2d_decode, cfd_2d_initial_bits);
|
|
|
|
switch (code)
|
|
{
|
|
case H:
|
|
fax->stage = STATE_H1;
|
|
break;
|
|
|
|
case P:
|
|
b1 = find_changing_color(fax->ref, fax->a, fax->columns, !fax->c);
|
|
if (b1 >= fax->columns)
|
|
b2 = fax->columns;
|
|
else
|
|
b2 = find_changing(fax->ref, b1, fax->columns);
|
|
if (fax->c) setbits(fax->dst, fax->a, b2);
|
|
fax->a = b2;
|
|
break;
|
|
|
|
case V0:
|
|
b1 = find_changing_color(fax->ref, fax->a, fax->columns, !fax->c);
|
|
if (fax->c) setbits(fax->dst, fax->a, b1);
|
|
fax->a = b1;
|
|
fax->c = !fax->c;
|
|
break;
|
|
|
|
case VR1:
|
|
b1 = 1 + find_changing_color(fax->ref, fax->a, fax->columns, !fax->c);
|
|
if (b1 >= fax->columns) b1 = fax->columns;
|
|
if (fax->c) setbits(fax->dst, fax->a, b1);
|
|
fax->a = b1;
|
|
fax->c = !fax->c;
|
|
break;
|
|
|
|
case VR2:
|
|
b1 = 2 + find_changing_color(fax->ref, fax->a, fax->columns, !fax->c);
|
|
if (b1 >= fax->columns) b1 = fax->columns;
|
|
if (fax->c) setbits(fax->dst, fax->a, b1);
|
|
fax->a = b1;
|
|
fax->c = !fax->c;
|
|
break;
|
|
|
|
case VR3:
|
|
b1 = 3 + find_changing_color(fax->ref, fax->a, fax->columns, !fax->c);
|
|
if (b1 >= fax->columns) b1 = fax->columns;
|
|
if (fax->c) setbits(fax->dst, fax->a, b1);
|
|
fax->a = b1;
|
|
fax->c = !fax->c;
|
|
break;
|
|
|
|
case VL1:
|
|
b1 = -1 + find_changing_color(fax->ref, fax->a, fax->columns, !fax->c);
|
|
if (b1 < 0) b1 = 0;
|
|
if (fax->c) setbits(fax->dst, fax->a, b1);
|
|
fax->a = b1;
|
|
fax->c = !fax->c;
|
|
break;
|
|
|
|
case VL2:
|
|
b1 = -2 + find_changing_color(fax->ref, fax->a, fax->columns, !fax->c);
|
|
if (b1 < 0) b1 = 0;
|
|
if (fax->c) setbits(fax->dst, fax->a, b1);
|
|
fax->a = b1;
|
|
fax->c = !fax->c;
|
|
break;
|
|
|
|
case VL3:
|
|
b1 = -3 + find_changing_color(fax->ref, fax->a, fax->columns, !fax->c);
|
|
if (b1 < 0) b1 = 0;
|
|
if (fax->c) setbits(fax->dst, fax->a, b1);
|
|
fax->a = b1;
|
|
fax->c = !fax->c;
|
|
break;
|
|
|
|
case UNCOMPRESSED:
|
|
return fz_throw("uncompressed data in faxd");
|
|
|
|
case ERROR:
|
|
return fz_throw("invalid code in 2d faxd");
|
|
|
|
default:
|
|
return fz_throw("invalid code in 2d faxd (%d)", code);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
read_faxd(fz_stream *stm, unsigned char *buf, int len)
|
|
{
|
|
fz_faxd *fax = stm->state;
|
|
unsigned char *p = buf;
|
|
unsigned char *ep = buf + len;
|
|
unsigned char *tmp;
|
|
fz_error error;
|
|
|
|
if (fax->stage == STATE_DONE)
|
|
return 0;
|
|
|
|
if (fax->stage == STATE_EOL)
|
|
goto eol;
|
|
|
|
loop:
|
|
|
|
if (fill_bits(fax))
|
|
{
|
|
if (fax->bidx > 31)
|
|
{
|
|
if (fax->a > 0)
|
|
goto eol;
|
|
goto rtc;
|
|
}
|
|
}
|
|
|
|
if ((fax->word >> (32 - 12)) == 0)
|
|
{
|
|
eat_bits(fax, 1);
|
|
goto loop;
|
|
}
|
|
|
|
if ((fax->word >> (32 - 12)) == 1)
|
|
{
|
|
eat_bits(fax, 12);
|
|
fax->eolc ++;
|
|
|
|
if (fax->k > 0)
|
|
{
|
|
if (fax->a == -1)
|
|
fax->a = 0;
|
|
if ((fax->word >> (32 - 1)) == 1)
|
|
fax->dim = 1;
|
|
else
|
|
fax->dim = 2;
|
|
eat_bits(fax, 1);
|
|
}
|
|
}
|
|
else if (fax->k > 0 && fax->a == -1)
|
|
{
|
|
fax->a = 0;
|
|
if ((fax->word >> (32 - 1)) == 1)
|
|
fax->dim = 1;
|
|
else
|
|
fax->dim = 2;
|
|
eat_bits(fax, 1);
|
|
}
|
|
else if (fax->dim == 1)
|
|
{
|
|
fax->eolc = 0;
|
|
error = dec1d(fax);
|
|
if (error)
|
|
return fz_rethrow(error, "cannot decode 1d code");
|
|
}
|
|
else if (fax->dim == 2)
|
|
{
|
|
fax->eolc = 0;
|
|
error = dec2d(fax);
|
|
if (error)
|
|
return fz_rethrow(error, "cannot decode 2d code");
|
|
}
|
|
|
|
/* no eol check after makeup codes nor in the middle of an H code */
|
|
if (fax->stage == STATE_MAKEUP || fax->stage == STATE_H1 || fax->stage == STATE_H2)
|
|
goto loop;
|
|
|
|
/* check for eol conditions */
|
|
if (fax->eolc || fax->a >= fax->columns)
|
|
{
|
|
if (fax->a > 0)
|
|
goto eol;
|
|
if (fax->eolc == (fax->k < 0 ? 2 : 6))
|
|
goto rtc;
|
|
}
|
|
|
|
goto loop;
|
|
|
|
eol:
|
|
fax->stage = STATE_EOL;
|
|
|
|
if (fax->black_is_1)
|
|
{
|
|
while (fax->rp < fax->wp && p < ep)
|
|
*p++ = *fax->rp++;
|
|
}
|
|
else
|
|
{
|
|
while (fax->rp < fax->wp && p < ep)
|
|
*p++ = *fax->rp++ ^ 0xff;
|
|
}
|
|
|
|
if (fax->rp < fax->wp)
|
|
return p - buf;
|
|
|
|
tmp = fax->ref;
|
|
fax->ref = fax->dst;
|
|
fax->dst = tmp;
|
|
memset(fax->dst, 0, fax->stride);
|
|
|
|
fax->rp = fax->dst;
|
|
fax->wp = fax->dst + fax->stride;
|
|
|
|
fax->stage = STATE_NORMAL;
|
|
fax->c = 0;
|
|
fax->a = -1;
|
|
fax->ridx ++;
|
|
|
|
if (!fax->end_of_block && fax->rows)
|
|
{
|
|
if (fax->ridx >= fax->rows)
|
|
goto rtc;
|
|
}
|
|
|
|
/* we have not read dim from eol, make a guess */
|
|
if (fax->k > 0 && !fax->eolc && fax->a == -1)
|
|
{
|
|
if (fax->ridx % fax->k == 0)
|
|
fax->dim = 1;
|
|
else
|
|
fax->dim = 2;
|
|
}
|
|
|
|
/* if end_of_line & encoded_byte_align, EOLs are *not* optional */
|
|
if (fax->encoded_byte_align)
|
|
{
|
|
if (fax->end_of_line)
|
|
eat_bits(fax, (12 - fax->bidx) & 7);
|
|
else
|
|
eat_bits(fax, (8 - fax->bidx) & 7);
|
|
}
|
|
|
|
/* no more space in output, don't decode the next row yet */
|
|
if (p == buf + len)
|
|
return p - buf;
|
|
|
|
goto loop;
|
|
|
|
rtc:
|
|
fax->stage = STATE_DONE;
|
|
return p - buf;
|
|
}
|
|
|
|
static void
|
|
close_faxd(fz_stream *stm)
|
|
{
|
|
fz_faxd *fax = stm->state;
|
|
int i;
|
|
|
|
/* if we read any extra bytes, try to put them back */
|
|
i = (32 - fax->bidx) / 8;
|
|
while (i--)
|
|
fz_unread_byte(fax->chain);
|
|
|
|
fz_close(fax->chain);
|
|
fz_free(fax->ref);
|
|
fz_free(fax->dst);
|
|
fz_free(fax);
|
|
}
|
|
|
|
fz_stream *
|
|
fz_open_faxd(fz_stream *chain, fz_obj *params)
|
|
{
|
|
fz_faxd *fax;
|
|
fz_obj *obj;
|
|
|
|
fax = fz_malloc(sizeof(fz_faxd));
|
|
fax->chain = chain;
|
|
|
|
fax->ref = NULL;
|
|
fax->dst = NULL;
|
|
|
|
fax->k = 0;
|
|
fax->end_of_line = 0;
|
|
fax->encoded_byte_align = 0;
|
|
fax->columns = 1728;
|
|
fax->rows = 0;
|
|
fax->end_of_block = 1;
|
|
fax->black_is_1 = 0;
|
|
|
|
obj = fz_dict_gets(params, "K");
|
|
if (obj) fax->k = fz_to_int(obj);
|
|
|
|
obj = fz_dict_gets(params, "EndOfLine");
|
|
if (obj) fax->end_of_line = fz_to_bool(obj);
|
|
|
|
obj = fz_dict_gets(params, "EncodedByteAlign");
|
|
if (obj) fax->encoded_byte_align = fz_to_bool(obj);
|
|
|
|
obj = fz_dict_gets(params, "Columns");
|
|
if (obj) fax->columns = fz_to_int(obj);
|
|
|
|
obj = fz_dict_gets(params, "Rows");
|
|
if (obj) fax->rows = fz_to_int(obj);
|
|
|
|
obj = fz_dict_gets(params, "EndOfBlock");
|
|
if (obj) fax->end_of_block = fz_to_bool(obj);
|
|
|
|
obj = fz_dict_gets(params, "BlackIs1");
|
|
if (obj) fax->black_is_1 = fz_to_bool(obj);
|
|
|
|
fax->stride = ((fax->columns - 1) >> 3) + 1;
|
|
fax->ridx = 0;
|
|
fax->bidx = 32;
|
|
fax->word = 0;
|
|
|
|
fax->stage = STATE_NORMAL;
|
|
fax->a = -1;
|
|
fax->c = 0;
|
|
fax->dim = fax->k < 0 ? 2 : 1;
|
|
fax->eolc = 0;
|
|
|
|
fax->ref = fz_malloc(fax->stride);
|
|
fax->dst = fz_malloc(fax->stride);
|
|
fax->rp = fax->dst;
|
|
fax->wp = fax->dst + fax->stride;
|
|
|
|
memset(fax->ref, 0, fax->stride);
|
|
memset(fax->dst, 0, fax->stride);
|
|
|
|
return fz_new_stream(fax, read_faxd, close_faxd);
|
|
}
|