Unified · Split
| @@ -3,68 +3,6 @@ · 2 unmodified lines | |||
| 3 | #include <flate.h> | 3 | #include <flate.h> |
| 4 | #include "pdf.h" | 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 | static int | 7 | static int |
| 70 | bw(void *aux, void *d, int n) | 8 | bw(void *aux, void *d, int n) |
| @@ -83,11 +21,7 @@ bget(void *aux) · 12 unmodified lines | |||
| 83 | static int | 21 | static int |
| 84 | flreadall(void *aux, Buffer *bi, Buffer *bo) | 22 | flreadall(void *aux, Buffer *bi, Buffer *bo) |
| 85 | { | 23 | { |
| 86 | int r, i, rows, n; | 24 | int r; |
| 87 | FlateParms *fp; | ||
| 88 | uchar *x, *y, *zero; | ||
| 89 | |||
| 90 | fp = aux; | ||
| 91 | 25 | ||
| 92 | do{ | 26 | do{ |
| 93 | r = inflatezlib(bo, bw, bi, bget); | 27 | r = inflatezlib(bo, bw, bi, bget); |
| @@ -97,66 +31,13 @@ flreadall(void *aux, Buffer *bi, Buffer *bo) · 3 unmodified lines | |||
| 97 | werrstr("%s", flateerr(r)); | 31 | werrstr("%s", flateerr(r)); |
| 98 | return -1; | 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) | 35 | return unpredict(aux, bo); |
| 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); | ||
| 155 | } | 36 | } |
| 156 | 37 | ||
| 157 | Filter filterFlate = { | 38 | Filter filterFlate = { |
| 158 | .name = "FlateDecode", | 39 | .name = "FlateDecode", |
| 159 | .readall = flreadall, | 40 | .readall = flreadall, |
| 160 | .open = flopen, | 41 | .open = flopenpredict, |
| 161 | .close = flclose, | 42 | .close = flclosepredict, |
| 162 | }; | 43 | }; |
| @@ -121,8 +121,6 @@ flreadall(void *aux, Buffer *bi, Buffer *bo) · 120 unmodified lines | |||
| 121 | uchar *in; | 121 | uchar *in; |
| 122 | Tb tb; | 122 | Tb tb; |
| 123 | 123 | ||
| 124 | USED(aux); | ||
| 125 | |||
| 126 | memset(&tb, 0, sizeof(tb)); | 124 | memset(&tb, 0, sizeof(tb)); |
| 127 | in = bufdata(bi, &insz); | 125 | in = bufdata(bi, &insz); |
| 128 | width = 9; | 126 | width = 9; |
| @@ -155,10 +153,12 @@ flreadall(void *aux, Buffer *bi, Buffer *bo) · 26 unmodified lines | |||
| 155 | tbfree(&tb); | 153 | tbfree(&tb); |
| 156 | bi->off = bi->sz; | 154 | bi->off = bi->sz; |
| 157 | 155 | ||
| 158 | return 0; | 156 | return unpredict(aux, bo); |
| 159 | } | 157 | } |
| 160 | 158 | ||
| 161 | Filter filterLZW = { | 159 | Filter filterLZW = { |
| 162 | .name = "LZWDecode", | 160 | .name = "LZWDecode", |
| 163 | .readall = flreadall, | 161 | .readall = flreadall, |
| 162 | .open = flopenpredict, | ||
| 163 | .close = flclosepredict, | ||
| 164 | }; | 164 | }; |
| @@ -7,12 +7,12 @@ OFILES=\ · 6 unmodified lines | |||
| 7 | buffer.$O\ | 7 | buffer.$O\ |
| 8 | dict.$O\ | 8 | dict.$O\ |
| 9 | eval.$O\ | 9 | eval.$O\ |
| 10 | f_dct.$O\ | ||
| 11 | f_ascii85.$O\ | 10 | f_ascii85.$O\ |
| 12 | f_asciihex.$O\ | 11 | f_asciihex.$O\ |
| 13 | f_ccittfax.$O\ | 12 | f_ccittfax.$O\ |
| 14 | f_crypt.$O\ | 13 | f_crypt.$O\ |
| 15 | f_dct.$O\ | 14 | f_dct.$O\ |
| 15 | f_dct.$O\ | ||
| 16 | f_flate.$O\ | 16 | f_flate.$O\ |
| 17 | f_jbig2.$O\ | 17 | f_jbig2.$O\ |
| 18 | f_jpx.$O\ | 18 | f_jpx.$O\ |
| @@ -25,6 +25,7 @@ OFILES=\ · 6 unmodified lines | |||
| 25 | object.$O\ | 25 | object.$O\ |
| 26 | pdf.$O\ | 26 | pdf.$O\ |
| 27 | pdffs.$O\ | 27 | pdffs.$O\ |
| 28 | predict.$O\ | ||
| 28 | stream.$O\ | 29 | stream.$O\ |
| 29 | string.$O\ | 30 | string.$O\ |
| 30 | xref.$O\ | 31 | xref.$O\ |
| @@ -15,6 +15,8 @@ typedef struct Filter Filter; · 14 unmodified lines | |||
| 15 | typedef struct KeyValue KeyValue; | 15 | typedef struct KeyValue KeyValue; |
| 16 | typedef struct Object Object; | 16 | typedef struct Object Object; |
| 17 | typedef struct Pdf Pdf; | 17 | typedef struct Pdf Pdf; |
| 18 | typedef struct PredictParms PredictParms; | ||
| 19 | #pragma incomplete PredictParms; | ||
| 18 | typedef struct Stream Stream; | 20 | typedef struct Stream Stream; |
| 19 | typedef struct Xref Xref; | 21 | typedef struct Xref Xref; |
| 20 | 22 | ||
| @@ -186,6 +188,11 @@ Filter *filteropen(char *name, Object *o); · 165 unmodified lines | |||
| 186 | int filterrun(Filter *f, Buffer *bi, Buffer *bo); | 188 | int filterrun(Filter *f, Buffer *bi, Buffer *bo); |
| 187 | void filterclose(Filter *f); | 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 | void bufinit(Buffer *b, uchar *d, int sz); | 196 | void bufinit(Buffer *b, uchar *d, int sz); |
| 190 | void buffree(Buffer *b); | 197 | void buffree(Buffer *b); |
| 191 | int bufeof(Buffer *b); | 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 | } | ||