Unified · Split
| @@ -3,68 +3,6 @@ · 2 unmodified lines | ||
| 3 | 3 | #include <flate.h> |
| 4 | 4 | #include "pdf.h" |
| 5 | 5 | |
| 6 | −typedef struct FlateParms FlateParms; | |
| 7 | − | |
| 8 | −struct FlateParms { | |
| 9 | − int predictor; | |
| 10 | − int columns; | |
| 11 | −}; | |
| 12 | − | |
| 13 | −static uchar | |
| 14 | −paeth(uchar a, uchar b, uchar c) | |
| 15 | −{ | |
| 16 | − int p, pa, pb, pc; | |
| 17 | − | |
| 18 | − p = a + b - c; | |
| 19 | − pa = abs(p - a); | |
| 20 | − pb = abs(p - b); | |
| 21 | − pc = abs(p - c); | |
| 22 | − | |
| 23 | − if(pa <= pb && pa <= pc) | |
| 24 | − return a; | |
| 25 | − return pb <= pc ? b : c; | |
| 26 | −} | |
| 27 | − | |
| 28 | −static int | |
| 29 | −pngunpredict(int pred, uchar *buf, uchar *up, int len) | |
| 30 | −{ | |
| 31 | − int i; | |
| 32 | − | |
| 33 | − switch(pred){ | |
| 34 | − case 0: /* None */ | |
| 35 | − break; | |
| 36 | − | |
| 37 | − case 1: /* Sub */ | |
| 38 | − for(i = 1; i < len; ++i) | |
| 39 | − buf[i] += buf[i-1]; | |
| 40 | − break; | |
| 41 | − | |
| 42 | − case 2: /* Up */ | |
| 43 | − for(i = 0; i < len; ++i) | |
| 44 | − buf[i] += up[i]; | |
| 45 | − break; | |
| 46 | − | |
| 47 | − case 3: /* Average */ | |
| 48 | − buf[0] += up[0]/2; | |
| 49 | − for(i = 1; i < len; ++i) | |
| 50 | − buf[i] += (buf[i-1]+up[i])/2; | |
| 51 | − break; | |
| 52 | − | |
| 53 | − case 4: /* Paeth */ | |
| 54 | − buf[0] += paeth(0, up[0], 0); | |
| 55 | − for(i = 0; i < len; ++i) | |
| 56 | − buf[i] += paeth(buf[i-1], up[i], up[i-1]); | |
| 57 | − break; | |
| 58 | − | |
| 59 | − /* FIXME 5 optimum??? */ | |
| 60 | − | |
| 61 | − default: | |
| 62 | − werrstr("unsupported predictor %d", pred); | |
| 63 | − return -1; | |
| 64 | − } | |
| 65 | − | |
| 66 | − return 0; | |
| 67 | −} | |
| 68 | 6 | |
| 69 | 7 | static int |
| 70 | 8 | bw(void *aux, void *d, int n) |
| @@ -83,11 +21,7 @@ bget(void *aux) · 12 unmodified lines | ||
| 83 | 21 | static int |
| 84 | 22 | flreadall(void *aux, Buffer *bi, Buffer *bo) |
| 85 | 23 | { |
| 86 | − int r, i, rows, n; | |
| 87 | − FlateParms *fp; | |
| 88 | − uchar *x, *y, *zero; | |
| 89 | − | |
| 90 | − fp = aux; | |
| 24 | + int r; | |
| 91 | 25 | |
| 92 | 26 | do{ |
| 93 | 27 | r = inflatezlib(bo, bw, bi, bget); |
| @@ -97,66 +31,13 @@ flreadall(void *aux, Buffer *bi, Buffer *bo) · 3 unmodified lines | ||
| 97 | 31 | werrstr("%s", flateerr(r)); |
| 98 | 32 | return -1; |
| 99 | 33 | } |
| 100 | − r = 0; | |
| 101 | − | |
| 102 | − /* 7.4.4.4 LZW and Flate predictor functions */ | |
| 103 | − if(fp->predictor >= 10 && fp->columns > 0){ | |
| 104 | − n = fp->columns + 1; | |
| 105 | − rows = bo->sz/n; | |
| 106 | − x = bo->b; | |
| 107 | − y = bo->b; | |
| 108 | − zero = mallocz(fp->columns, 1); | |
| 109 | − for(i = r = 0; i < rows && r == 0; i++, x += n, y += n) | |
| 110 | − r = pngunpredict(x[0], x+1, i < 1 ? zero : y+1-n, fp->columns); | |
| 111 | − free(zero); | |
| 112 | − | |
| 113 | − x = bo->b; | |
| 114 | − y = bo->b+1; | |
| 115 | − for(i = 0; i < rows; i++, x += fp->columns, y += n) | |
| 116 | − memmove(x, y, fp->columns); | |
| 117 | − bo->sz -= rows; | |
| 118 | − } | |
| 119 | − | |
| 120 | − return r; | |
| 121 | −} | |
| 122 | − | |
| 123 | −static int | |
| 124 | −flopen(Filter *f, Object *o) | |
| 125 | −{ | |
| 126 | − Object *parms; | |
| 127 | − FlateParms *fp; | |
| 128 | − int predictor, columns; | |
| 129 | − | |
| 130 | − parms = dictget(o, "DecodeParms"); | |
| 131 | − predictor = dictint(parms, "Predictor"); | |
| 132 | − columns = dictint(parms, "Columns"); | |
| 133 | − if((predictor >= 2 && predictor < 10) || predictor >= 15){ | |
| 134 | − werrstr("unsupported flate predictor %d", predictor); | |
| 135 | − return -1; | |
| 136 | − } | |
| 137 | − if(predictor >= 10 && predictor <= 15 && columns < 1){ | |
| 138 | − werrstr("invalid columns %d for predictor %d", columns, predictor); | |
| 139 | − return -1; | |
| 140 | − } | |
| 141 | 34 | |
| 142 | − if((fp = malloc(sizeof(FlateParms))) == nil) | |
| 143 | − return -1; | |
| 144 | − fp->predictor = predictor; | |
| 145 | − fp->columns = columns; | |
| 146 | − f->aux = fp; | |
| 147 | − | |
| 148 | − return 0; | |
| 149 | −} | |
| 150 | − | |
| 151 | −static void | |
| 152 | −flclose(Filter *f) | |
| 153 | −{ | |
| 154 | − free(f->aux); | |
| 35 | + return unpredict(aux, bo); | |
| 155 | 36 | } |
| 156 | 37 | |
| 157 | 38 | Filter filterFlate = { |
| 158 | 39 | .name = "FlateDecode", |
| 159 | 40 | .readall = flreadall, |
| 160 | − .open = flopen, | |
| 161 | − .close = flclose, | |
| 41 | + .open = flopenpredict, | |
| 42 | + .close = flclosepredict, | |
| 162 | 43 | }; |
| @@ -121,8 +121,6 @@ flreadall(void *aux, Buffer *bi, Buffer *bo) · 120 unmodified lines | ||
| 121 | 121 | uchar *in; |
| 122 | 122 | Tb tb; |
| 123 | 123 | |
| 124 | − USED(aux); | |
| 125 | − | |
| 126 | 124 | memset(&tb, 0, sizeof(tb)); |
| 127 | 125 | in = bufdata(bi, &insz); |
| 128 | 126 | width = 9; |
| @@ -155,10 +153,12 @@ flreadall(void *aux, Buffer *bi, Buffer *bo) · 26 unmodified lines | ||
| 155 | 153 | tbfree(&tb); |
| 156 | 154 | bi->off = bi->sz; |
| 157 | 155 | |
| 158 | − return 0; | |
| 156 | + return unpredict(aux, bo); | |
| 159 | 157 | } |
| 160 | 158 | |
| 161 | 159 | Filter filterLZW = { |
| 162 | 160 | .name = "LZWDecode", |
| 163 | 161 | .readall = flreadall, |
| 162 | + .open = flopenpredict, | |
| 163 | + .close = flclosepredict, | |
| 164 | 164 | }; |
| @@ -7,12 +7,12 @@ OFILES=\ · 6 unmodified lines | ||
| 7 | 7 | buffer.$O\ |
| 8 | 8 | dict.$O\ |
| 9 | 9 | eval.$O\ |
| 10 | − f_dct.$O\ | |
| 11 | 10 | f_ascii85.$O\ |
| 12 | 11 | f_asciihex.$O\ |
| 13 | 12 | f_ccittfax.$O\ |
| 14 | 13 | f_crypt.$O\ |
| 15 | 14 | f_dct.$O\ |
| 15 | + f_dct.$O\ | |
| 16 | 16 | f_flate.$O\ |
| 17 | 17 | f_jbig2.$O\ |
| 18 | 18 | f_jpx.$O\ |
| @@ -25,6 +25,7 @@ OFILES=\ · 6 unmodified lines | ||
| 25 | 25 | object.$O\ |
| 26 | 26 | pdf.$O\ |
| 27 | 27 | pdffs.$O\ |
| 28 | + predict.$O\ | |
| 28 | 29 | stream.$O\ |
| 29 | 30 | string.$O\ |
| 30 | 31 | xref.$O\ |
| @@ -15,6 +15,8 @@ typedef struct Filter Filter; · 14 unmodified lines | ||
| 15 | 15 | typedef struct KeyValue KeyValue; |
| 16 | 16 | typedef struct Object Object; |
| 17 | 17 | typedef struct Pdf Pdf; |
| 18 | +typedef struct PredictParms PredictParms; | |
| 19 | +#pragma incomplete PredictParms; | |
| 18 | 20 | typedef struct Stream Stream; |
| 19 | 21 | typedef struct Xref Xref; |
| 20 | 22 | |
| @@ -186,6 +188,11 @@ Filter *filteropen(char *name, Object *o); · 165 unmodified lines | ||
| 186 | 188 | int filterrun(Filter *f, Buffer *bi, Buffer *bo); |
| 187 | 189 | void filterclose(Filter *f); |
| 188 | 190 | |
| 191 | +/* 7.4.4.4 LZW and Flate predictor functions */ | |
| 192 | +int unpredict(PredictParms *pp, Buffer *bo); | |
| 193 | +int flopenpredict(Filter *f, Object *o); | |
| 194 | +void flclosepredict(Filter *f); | |
| 195 | + | |
| 189 | 196 | void bufinit(Buffer *b, uchar *d, int sz); |
| 190 | 197 | void buffree(Buffer *b); |
| 191 | 198 | int bufeof(Buffer *b); |
| @@ -0,0 +1,128 @@ | ||
| 1 | +#include <u.h> | |
| 2 | +#include <libc.h> | |
| 3 | +#include "pdf.h" | |
| 4 | + | |
| 5 | +struct PredictParms { | |
| 6 | + int predictor; | |
| 7 | + int columns; | |
| 8 | +}; | |
| 9 | + | |
| 10 | +static uchar | |
| 11 | +paeth(uchar a, uchar b, uchar c) | |
| 12 | +{ | |
| 13 | + int p, pa, pb, pc; | |
| 14 | + | |
| 15 | + p = a + b - c; | |
| 16 | + pa = abs(p - a); | |
| 17 | + pb = abs(p - b); | |
| 18 | + pc = abs(p - c); | |
| 19 | + | |
| 20 | + if(pa <= pb && pa <= pc) | |
| 21 | + return a; | |
| 22 | + return pb <= pc ? b : c; | |
| 23 | +} | |
| 24 | + | |
| 25 | +static int | |
| 26 | +pngunpredict(int pred, uchar *buf, uchar *up, int len) | |
| 27 | +{ | |
| 28 | + int i; | |
| 29 | + | |
| 30 | + switch(pred){ | |
| 31 | + case 0: /* None */ | |
| 32 | + break; | |
| 33 | + | |
| 34 | + case 1: /* Sub */ | |
| 35 | + for(i = 1; i < len; ++i) | |
| 36 | + buf[i] += buf[i-1]; | |
| 37 | + break; | |
| 38 | + | |
| 39 | + case 2: /* Up */ | |
| 40 | + for(i = 0; i < len; ++i) | |
| 41 | + buf[i] += up[i]; | |
| 42 | + break; | |
| 43 | + | |
| 44 | + case 3: /* Average */ | |
| 45 | + buf[0] += up[0]/2; | |
| 46 | + for(i = 1; i < len; ++i) | |
| 47 | + buf[i] += (buf[i-1]+up[i])/2; | |
| 48 | + break; | |
| 49 | + | |
| 50 | + case 4: /* Paeth */ | |
| 51 | + buf[0] += paeth(0, up[0], 0); | |
| 52 | + for(i = 0; i < len; ++i) | |
| 53 | + buf[i] += paeth(buf[i-1], up[i], up[i-1]); | |
| 54 | + break; | |
| 55 | + | |
| 56 | + /* FIXME 5 optimum??? */ | |
| 57 | + | |
| 58 | + default: | |
| 59 | + werrstr("unsupported predictor %d", pred); | |
| 60 | + return -1; | |
| 61 | + } | |
| 62 | + | |
| 63 | + return 0; | |
| 64 | +} | |
| 65 | + | |
| 66 | +int | |
| 67 | +unpredict(PredictParms *pp, Buffer *bo) | |
| 68 | +{ | |
| 69 | + uchar *x, *y, *zero; | |
| 70 | + int i, r, rows, n; | |
| 71 | + | |
| 72 | + if(pp->predictor < 10 || pp->columns < 1) | |
| 73 | + return 0; | |
| 74 | + | |
| 75 | + n = pp->columns + 1; | |
| 76 | + rows = bo->sz/n; | |
| 77 | + x = bo->b; | |
| 78 | + y = bo->b; | |
| 79 | + zero = mallocz(pp->columns, 1); | |
| 80 | + for(i = r = 0; i < rows && r == 0; i++, x += n, y += n) | |
| 81 | + r = pngunpredict(x[0], x+1, i < 1 ? zero : y+1-n, pp->columns); | |
| 82 | + free(zero); | |
| 83 | + | |
| 84 | + if(r != 0) | |
| 85 | + return r; | |
| 86 | + | |
| 87 | + x = bo->b; | |
| 88 | + y = bo->b+1; | |
| 89 | + for(i = 0; i < rows; i++, x += pp->columns, y += n) | |
| 90 | + memmove(x, y, pp->columns); | |
| 91 | + bo->sz -= rows; | |
| 92 | + | |
| 93 | + return r; | |
| 94 | +} | |
| 95 | + | |
| 96 | +int | |
| 97 | +flopenpredict(Filter *f, Object *o) | |
| 98 | +{ | |
| 99 | + Object *parms; | |
| 100 | + PredictParms *pp; | |
| 101 | + int predictor, columns; | |
| 102 | + | |
| 103 | + parms = dictget(o, "DecodeParms"); | |
| 104 | + predictor = dictint(parms, "Predictor"); | |
| 105 | + columns = dictint(parms, "Columns"); | |
| 106 | + if((predictor >= 2 && predictor < 10) || predictor >= 15){ | |
| 107 | + werrstr("unsupported flate predictor %d", predictor); | |
| 108 | + return -1; | |
| 109 | + } | |
| 110 | + if(predictor >= 10 && predictor <= 15 && columns < 1){ | |
| 111 | + werrstr("invalid columns %d for predictor %d", columns, predictor); | |
| 112 | + return -1; | |
| 113 | + } | |
| 114 | + | |
| 115 | + if((pp = malloc(sizeof(*pp))) == nil) | |
| 116 | + return -1; | |
| 117 | + pp->predictor = predictor; | |
| 118 | + pp->columns = columns; | |
| 119 | + f->aux = pp; | |
| 120 | + | |
| 121 | + return 0; | |
| 122 | +} | |
| 123 | + | |
| 124 | +void | |
| 125 | +flclosepredict(Filter *f) | |
| 126 | +{ | |
| 127 | + free(f->aux); | |
| 128 | +} | |