From ee154f16bd09a43359967f7e7b86c3677c09461d Mon Sep 17 00:00:00 2001 From: Tor Andersson Date: Wed, 30 Mar 2005 08:30:22 +0200 Subject: rename part 1 -- files --- TODO | 9 + base/arc4.c | 95 ----- base/base_cpudep.c | 221 ++++++++++++ base/base_error.c | 78 +++++ base/base_hash.c | 274 +++++++++++++++ base/base_matrix.c | 151 ++++++++ base/base_memory.c | 81 +++++ base/base_rect.c | 75 ++++ base/base_rune.c | 168 +++++++++ base/cpudep.c | 221 ------------ base/error.c | 78 ----- base/hash.c | 274 --------------- base/matrix.c | 151 -------- base/md5.c | 269 -------------- base/memory.c | 81 ----- base/node_debug.c | 191 ++++++++++ base/node_misc1.c | 167 +++++++++ base/node_misc2.c | 338 ++++++++++++++++++ base/node_optimize.c | 310 ++++++++++++++++ base/node_path.c | 305 ++++++++++++++++ base/node_text.c | 141 ++++++++ base/node_tree.c | 107 ++++++ base/rect.c | 75 ---- base/res_cmap.c | 466 +++++++++++++++++++++++++ base/res_colorspace.c | 89 +++++ base/res_font.c | 269 ++++++++++++++ base/res_image.c | 22 ++ base/res_shade.c | 28 ++ base/rune.c | 168 --------- base/util_getopt.c | 116 ++++++ base/util_strlcat.c | 35 ++ base/util_strlcpy.c | 32 ++ base/util_strsep.c | 11 + filter/TODO | 8 - filter/a85d.c | 128 ------- filter/a85e.c | 127 ------- filter/ahxd.c | 112 ------ filter/ahxe.c | 64 ---- filter/arc4filter.c | 46 --- filter/buffer.c | 93 ----- filter/dctc.h | 39 --- filter/dctd.c | 219 ------------ filter/dcte.c | 252 ------------- filter/faxc.h | 125 ------- filter/faxd.c | 441 ----------------------- filter/faxd.h | 61 ---- filter/faxdtab.c | 931 ------------------------------------------------- filter/faxe.c | 398 --------------------- filter/faxe.h | 37 -- filter/faxetab.c | 131 ------- filter/filec.c | 349 ------------------ filter/filer.c | 252 ------------- filter/filew.c | 260 -------------- filter/filter.c | 51 --- filter/flate.c | 176 ---------- filter/jbig2d.c | 115 ------ filter/jpxd.c | 143 -------- filter/lzwd.c | 253 -------------- filter/lzwe.c | 261 -------------- filter/null.c | 50 --- filter/pipeline.c | 128 ------- filter/predict.c | 238 ------------- filter/rld.c | 66 ---- filter/rle.c | 237 ------------- object/array.c | 184 ---------- object/dict.c | 355 ------------------- object/parse.c | 401 --------------------- object/print.c | 302 ---------------- object/simple.c | 297 ---------------- stream/crypt_arc4.c | 95 +++++ stream/crypt_md5.c | 269 ++++++++++++++ stream/filt_a85d.c | 128 +++++++ stream/filt_a85e.c | 127 +++++++ stream/filt_ahxd.c | 112 ++++++ stream/filt_ahxe.c | 64 ++++ stream/filt_arc4.c | 46 +++ stream/filt_buffer.c | 93 +++++ stream/filt_dctc.h | 39 +++ stream/filt_dctd.c | 219 ++++++++++++ stream/filt_dcte.c | 252 +++++++++++++ stream/filt_faxc.h | 125 +++++++ stream/filt_faxd.c | 441 +++++++++++++++++++++++ stream/filt_faxd.h | 61 ++++ stream/filt_faxdtab.c | 931 +++++++++++++++++++++++++++++++++++++++++++++++++ stream/filt_faxe.c | 398 +++++++++++++++++++++ stream/filt_faxe.h | 37 ++ stream/filt_faxetab.c | 131 +++++++ stream/filt_filec.c | 349 ++++++++++++++++++ stream/filt_filer.c | 252 +++++++++++++ stream/filt_filew.c | 260 ++++++++++++++ stream/filt_flate.c | 176 ++++++++++ stream/filt_jbig2d.c | 115 ++++++ stream/filt_jpxd.c | 143 ++++++++ stream/filt_lzwd.c | 253 ++++++++++++++ stream/filt_lzwe.c | 261 ++++++++++++++ stream/filt_null.c | 50 +++ stream/filt_pipeline.c | 128 +++++++ stream/filt_predict.c | 238 +++++++++++++ stream/filt_process.c | 51 +++ stream/filt_rld.c | 66 ++++ stream/filt_rle.c | 237 +++++++++++++ stream/obj_array.c | 184 ++++++++++ stream/obj_dict.c | 355 +++++++++++++++++++ stream/obj_parse.c | 401 +++++++++++++++++++++ stream/obj_print.c | 302 ++++++++++++++++ stream/obj_simple.c | 297 ++++++++++++++++ tree/cmap.c | 466 ------------------------- tree/colorspace.c | 89 ----- tree/debug.c | 191 ---------- tree/font.c | 269 -------------- tree/image.c | 22 -- tree/node1.c | 167 --------- tree/node2.c | 338 ------------------ tree/optimize.c | 310 ---------------- tree/path.c | 305 ---------------- tree/shade.c | 28 -- tree/text.c | 141 -------- tree/tree.c | 107 ------ util/cleanname.c | 63 ---- util/getopt.c | 116 ------ util/strlcat.c | 35 -- util/strlcpy.c | 32 -- util/strsep.c | 11 - 123 files changed, 11370 insertions(+), 11432 deletions(-) delete mode 100644 base/arc4.c create mode 100644 base/base_cpudep.c create mode 100644 base/base_error.c create mode 100644 base/base_hash.c create mode 100644 base/base_matrix.c create mode 100644 base/base_memory.c create mode 100644 base/base_rect.c create mode 100644 base/base_rune.c delete mode 100644 base/cpudep.c delete mode 100644 base/error.c delete mode 100644 base/hash.c delete mode 100644 base/matrix.c delete mode 100644 base/md5.c delete mode 100644 base/memory.c create mode 100644 base/node_debug.c create mode 100644 base/node_misc1.c create mode 100644 base/node_misc2.c create mode 100644 base/node_optimize.c create mode 100644 base/node_path.c create mode 100644 base/node_text.c create mode 100644 base/node_tree.c delete mode 100644 base/rect.c create mode 100644 base/res_cmap.c create mode 100644 base/res_colorspace.c create mode 100644 base/res_font.c create mode 100644 base/res_image.c create mode 100644 base/res_shade.c delete mode 100644 base/rune.c create mode 100644 base/util_getopt.c create mode 100644 base/util_strlcat.c create mode 100644 base/util_strlcpy.c create mode 100644 base/util_strsep.c delete mode 100644 filter/TODO delete mode 100644 filter/a85d.c delete mode 100644 filter/a85e.c delete mode 100644 filter/ahxd.c delete mode 100644 filter/ahxe.c delete mode 100644 filter/arc4filter.c delete mode 100644 filter/buffer.c delete mode 100644 filter/dctc.h delete mode 100644 filter/dctd.c delete mode 100644 filter/dcte.c delete mode 100644 filter/faxc.h delete mode 100644 filter/faxd.c delete mode 100644 filter/faxd.h delete mode 100644 filter/faxdtab.c delete mode 100644 filter/faxe.c delete mode 100644 filter/faxe.h delete mode 100644 filter/faxetab.c delete mode 100644 filter/filec.c delete mode 100644 filter/filer.c delete mode 100644 filter/filew.c delete mode 100644 filter/filter.c delete mode 100644 filter/flate.c delete mode 100644 filter/jbig2d.c delete mode 100644 filter/jpxd.c delete mode 100644 filter/lzwd.c delete mode 100644 filter/lzwe.c delete mode 100644 filter/null.c delete mode 100644 filter/pipeline.c delete mode 100644 filter/predict.c delete mode 100644 filter/rld.c delete mode 100644 filter/rle.c delete mode 100644 object/array.c delete mode 100644 object/dict.c delete mode 100644 object/parse.c delete mode 100644 object/print.c delete mode 100644 object/simple.c create mode 100644 stream/crypt_arc4.c create mode 100644 stream/crypt_md5.c create mode 100644 stream/filt_a85d.c create mode 100644 stream/filt_a85e.c create mode 100644 stream/filt_ahxd.c create mode 100644 stream/filt_ahxe.c create mode 100644 stream/filt_arc4.c create mode 100644 stream/filt_buffer.c create mode 100644 stream/filt_dctc.h create mode 100644 stream/filt_dctd.c create mode 100644 stream/filt_dcte.c create mode 100644 stream/filt_faxc.h create mode 100644 stream/filt_faxd.c create mode 100644 stream/filt_faxd.h create mode 100644 stream/filt_faxdtab.c create mode 100644 stream/filt_faxe.c create mode 100644 stream/filt_faxe.h create mode 100644 stream/filt_faxetab.c create mode 100644 stream/filt_filec.c create mode 100644 stream/filt_filer.c create mode 100644 stream/filt_filew.c create mode 100644 stream/filt_flate.c create mode 100644 stream/filt_jbig2d.c create mode 100644 stream/filt_jpxd.c create mode 100644 stream/filt_lzwd.c create mode 100644 stream/filt_lzwe.c create mode 100644 stream/filt_null.c create mode 100644 stream/filt_pipeline.c create mode 100644 stream/filt_predict.c create mode 100644 stream/filt_process.c create mode 100644 stream/filt_rld.c create mode 100644 stream/filt_rle.c create mode 100644 stream/obj_array.c create mode 100644 stream/obj_dict.c create mode 100644 stream/obj_parse.c create mode 100644 stream/obj_print.c create mode 100644 stream/obj_simple.c delete mode 100644 tree/cmap.c delete mode 100644 tree/colorspace.c delete mode 100644 tree/debug.c delete mode 100644 tree/font.c delete mode 100644 tree/image.c delete mode 100644 tree/node1.c delete mode 100644 tree/node2.c delete mode 100644 tree/optimize.c delete mode 100644 tree/path.c delete mode 100644 tree/shade.c delete mode 100644 tree/text.c delete mode 100644 tree/tree.c delete mode 100644 util/cleanname.c delete mode 100644 util/getopt.c delete mode 100644 util/strlcat.c delete mode 100644 util/strlcpy.c delete mode 100644 util/strsep.c diff --git a/TODO b/TODO index 5b52caaf..b1653719 100644 --- a/TODO +++ b/TODO @@ -57,3 +57,12 @@ fz_optimizetree() - concatenate chained transforms - remove identity transforms +validate ahxd pushback +go through eof responsibility +be more defensive of api user errors +flate needin/needout + +jbig2 rewrite +dctencode params +dctdecode app marker + diff --git a/base/arc4.c b/base/arc4.c deleted file mode 100644 index 86c9afd8..00000000 --- a/base/arc4.c +++ /dev/null @@ -1,95 +0,0 @@ -/* This code illustrates a sample implementation - * of the Arcfour algorithm - * Copyright (c) April 29, 1997 Kalle Kaukonen. - * All Rights Reserved. - * - * Redistribution and use in source and binary forms, with or - * without modification, are permitted provided that this copyright - * notice and disclaimer are retained. - * - * THIS SOFTWARE IS PROVIDED BY KALLE KAUKONEN AND CONTRIBUTORS ``AS - * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL KALLE - * KAUKONEN OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS - * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include - -void -fz_arc4init(fz_arc4 *arc4, unsigned char *key, unsigned keylen) -{ - unsigned int t, u; - unsigned int keyindex; - unsigned int stateindex; - unsigned char *state; - unsigned int counter; - - state = arc4->state; - - arc4->x = 0; - arc4->y = 0; - - for (counter = 0; counter < 256; counter++) { - state[counter] = counter; - } - - keyindex = 0; - stateindex = 0; - - for (counter = 0; counter < 256; counter++) { - t = state[counter]; - stateindex = (stateindex + key[keyindex] + t) & 0xff; - u = state[stateindex]; - - state[stateindex] = t; - state[counter] = u; - - if (++keyindex >= keylen) { - keyindex = 0; - } - } -} - -unsigned char -fz_arc4next(fz_arc4 *arc4) -{ - unsigned int x; - unsigned int y; - unsigned int sx, sy; - unsigned char *state; - - state = arc4->state; - - x = (arc4->x + 1) & 0xff; - sx = state[x]; - y = (sx + arc4->y) & 0xff; - sy = state[y]; - - arc4->x = x; - arc4->y = y; - - state[y] = sx; - state[x] = sy; - - return state[(sx + sy) & 0xff]; -} - -void -fz_arc4encrypt(fz_arc4 *arc4, unsigned char *dest, unsigned char *src, unsigned len) -{ - unsigned int i; - for (i = 0; i < len; i++) { - unsigned char x; - x = fz_arc4next(arc4); - dest[i] = src[i] ^ x; - } -} - diff --git a/base/base_cpudep.c b/base/base_cpudep.c new file mode 100644 index 00000000..0db2e331 --- /dev/null +++ b/base/base_cpudep.c @@ -0,0 +1,221 @@ +/* +run-time cpu feature detection code +mm, alphabet soup... + +Glenn Kennard +*/ + +#include + +/* global run-time constant */ +unsigned fz_cpuflags = 0; + +#ifndef HAVE_CPUDEP + +void fz_accelerate(void) +{ +} + +void fz_cpudetect(void) +{ +} + +#else + +#include /* signal/sigaction */ +#include /* sigsetjmp/siglongjmp */ + +#ifdef WIN32 +#define sigjmp_buf jmp_buf +#define sigsetjmp(a,b) setjmp(a) +#define siglongjmp longjmp +#endif + +typedef struct { + void (*test)(void); + const unsigned flag; + const char *name; +} featuretest; + + +#if defined(ARCH_X86) || defined(ARCH_X86_64) + +/* need emms?? */ +static void mmx(void) +{ __asm__ ("pand %mm0, %mm0\n\t"); } + +static void m3dnow(void) +{ __asm__ ("pavgusb %mm0, %mm0\n\t"); } + +static void mmxext(void) /* aka Extended 3DNow! */ +{ __asm__ ("pmaxsw %mm0, %mm0\n\t"); } + +static void sse(void) +{ __asm__ ("andps %xmm0, %xmm0\n\t"); } + +static void sse2(void) +{ __asm__ ("andpd %xmm0, %xmm0\n\t"); } + +/* static void sse3(void) */ +/* { __asm__ ("haddps %%xmm0, %%xmm0\n\t" : : : "%xmm0"); } */ + +#ifdef ARCH_X86_64 +static void amd64(void) +{ __asm__ ("and %rax, %rax\n\t"); } +#endif + + +static const featuretest features[] = { + { mmx, HAVE_MMX, "mmx" }, + { m3dnow, HAVE_3DNOW, "3dnow" }, + { mmxext, HAVE_MMXEXT, "mmxext" }, + { sse, HAVE_SSE, "sse" }, + { sse2, HAVE_SSE2, "sse2" }, +/* { sse3, HAVE_SSE3, "sse3" }, */ +#ifdef ARCH_X86_64 + { amd64, HAVE_AMD64, "amd64" } +#endif +}; + +#endif + + +#if defined(ARCH_SPARC) +/* assembler must have -xarch=v8plusa passed to it (v9a for 64 bit binaries) */ +static void vis(void) +{ __asm__ ("fand %f8, %f8, %f8\n\t"); } + +static const featuretest features[] = { + { vis, HAVE_VIS, "vis" } +}; + +#endif + + +#if defined(ARCH_PPC) + +static void altivec(void) +{ __asm__ ("vand v0, v0, v0\n\t"); } + + +static const featuretest features[] = { + { altivec, HAVE_ALTIVEC, "altivec" }, +}; + +#endif + +static sigjmp_buf jmpbuf; +static volatile sig_atomic_t canjump; + +static void +sigillhandler(int sig) +{ + if (!canjump) { + signal(sig, SIG_DFL); + raise(sig); + } + + canjump = 0; + siglongjmp(jmpbuf, 1); +} + +static int +enabled(char *env, const char *ext) +{ + int len; + char *s; + if (!env) + return 1; + len = strlen(ext); + while ((s = strstr(env, ext))) + { + s += len; + if (*s == ' ' || *s == ',' || *s == '\0') + return 1; + } + return 0; +} + +static void +dumpflags(void) +{ + unsigned f = fz_cpuflags; + int i, n; + + fputs("detected cpu features:", stdout); + n = 0; + for (i = 0; i < sizeof(features) / sizeof(featuretest); i++) + { + if (f & features[i].flag) + { + fputc(' ', stdout); + fputs(features[i].name, stdout); + n ++; + } + } + if (!n) + fputs(" none", stdout); + fputc('\n', stdout); +} + +void fz_cpudetect(void) +{ + static int hasrun = 0; + + unsigned flags = 0; + int i; + void (*oldhandler)(int) = NULL; + void (*tmphandler)(int); + char *env; + + if (hasrun) + return; + hasrun = 1; + + env = getenv("CPUACCEL"); + + for (i = 0; i < sizeof(features) / sizeof(featuretest); i++) + { + canjump = 0; + + tmphandler = signal(SIGILL, sigillhandler); + if (!oldhandler) + oldhandler = tmphandler; + + if (sigsetjmp(jmpbuf, 1)) + { + /* test failed - disable feature */ + flags &= ~features[i].flag; + continue; + } + + canjump = 1; + + features[i].test(); + + /* if we got here the test succeeded */ + if (enabled(env, features[i].name)) + flags |= features[i].flag; + else + flags &= ~features[i].flag; + } + + /* restore previous signal handler */ + signal(SIGILL, oldhandler); + + fz_cpuflags = flags; + +#if defined(ARCH_X86) || defined(ARCH_X86_64) + __asm__ __volatile__ ("emms\n\t"); +#endif + + dumpflags(); +} + +static __attribute__((constructor, used)) void fzcpudetect(void) +{ + fz_cpudetect(); +} + +#endif + diff --git a/base/base_error.c b/base/base_error.c new file mode 100644 index 00000000..926c48dc --- /dev/null +++ b/base/base_error.c @@ -0,0 +1,78 @@ +#include + +void +fz_warn(char *fmt, ...) +{ + va_list ap; + fprintf(stderr, "warning: "); + va_start(ap, fmt); + vfprintf(stderr, fmt, ap); + va_end(ap); + fprintf(stderr, "\n"); +} + +fz_error * +fz_throw1(char *fmt, ...) +{ + va_list ap; + fz_error *eo; + + eo = fz_malloc(sizeof(fz_error)); + if (!eo) return fz_outofmem; + + eo->refs = 1; + strlcpy(eo->func, "unknown", sizeof eo->func); + strlcpy(eo->file, "unknown", sizeof eo->file); + eo->line = 0; + + va_start(ap, fmt); + vsnprintf(eo->msg, sizeof eo->msg, fmt, ap); + eo->msg[sizeof(eo->msg) - 1] = '\0'; + va_end(ap); + + return eo; +} + +fz_error * +fz_throw0(const char *func, const char *file, int line, char *fmt, ...) +{ + va_list ap; + fz_error *eo; + + eo = fz_malloc(sizeof(fz_error)); + if (!eo) return fz_outofmem; + + eo->refs = 1; + strlcpy(eo->func, func, sizeof eo->func); + strlcpy(eo->file, file, sizeof eo->file); + eo->line = line; + + va_start(ap, fmt); + vsnprintf(eo->msg, sizeof eo->msg, fmt, ap); + eo->msg[sizeof(eo->msg) - 1] = '\0'; + va_end(ap); + + if (getenv("BOMB")) + fz_abort(eo); + + return eo; +} + +void +fz_droperror(fz_error *eo) +{ + if (eo->refs > 0) + eo->refs--; + if (eo->refs == 0) + fz_free(eo); +} + +void +fz_abort(fz_error *eo) +{ + fflush(stdout); + fprintf(stderr, "%s:%d: %s(): %s\n", eo->file, eo->line, eo->func, eo->msg); + fflush(stderr); + abort(); +} + diff --git a/base/base_hash.c b/base/base_hash.c new file mode 100644 index 00000000..65bc7130 --- /dev/null +++ b/base/base_hash.c @@ -0,0 +1,274 @@ +/* Linear probe hash table. + * 2004 (C) Tor Andersson. + * BSD license. + * + * Simple hashtable with open adressing linear probe. + * Unlike text book examples, removing entries works + * correctly in this implementation so it wont start + * exhibiting bad behaviour if entries are inserted + * and removed frequently. + */ + +#include + +enum { MAXKEYLEN = 16 }; + +typedef struct fz_hashentry_s fz_hashentry; + +struct fz_hashentry_s +{ + unsigned char key[MAXKEYLEN]; + void *val; +}; + +struct fz_hashtable_s +{ + int keylen; + int size; + int load; + fz_hashentry *ents; +}; + +static unsigned hash(unsigned char *s, int len) +{ + unsigned hash = 0; + int i; + for (i = 0; i < len; i++) + { + hash += s[i]; + hash += (hash << 10); + hash ^= (hash >> 6); + } + hash += (hash << 3); + hash ^= (hash >> 11); + hash += (hash << 15); + return hash; +} + +fz_error * +fz_newhash(fz_hashtable **tablep, int initialsize, int keylen) +{ + fz_hashtable *table; + + assert(keylen <= MAXKEYLEN); + + table = *tablep = fz_malloc(sizeof(fz_hashtable)); + if (!table) + return fz_outofmem; + + table->keylen = keylen; + table->size = initialsize; + table->load = 0; + + table->ents = fz_malloc(sizeof(fz_hashentry) * table->size); + if (!table->ents) + { + fz_free(table); + *tablep = nil; + return fz_outofmem; + } + + memset(table->ents, 0, sizeof(fz_hashentry) * table->size); + + return nil; +} + +void +fz_emptyhash(fz_hashtable *table) +{ + table->load = 0; + memset(table->ents, 0, sizeof(fz_hashentry) * table->size); +} + +int +fz_hashlen(fz_hashtable *table) +{ + return table->size; +} + +void * +fz_hashgetkey(fz_hashtable *table, int idx) +{ + return table->ents[idx].key; +} + +void * +fz_hashgetval(fz_hashtable *table, int idx) +{ + return table->ents[idx].val; +} + +void +fz_drophash(fz_hashtable *table) +{ + fz_free(table->ents); + fz_free(table); +} + +fz_error * +fz_resizehash(fz_hashtable *table, int newsize) +{ + fz_error *error; + fz_hashentry *newents; + fz_hashentry *oldents; + int oldload; + int oldsize; + int i; + + oldsize = table->size; + oldload = table->load; + oldents = table->ents; + + if (newsize < oldload * 8 / 10) + return fz_throw("rangecheck: resize hash too small"); + + newents = fz_malloc(sizeof(fz_hashentry) * newsize); + if (!newents) + return fz_outofmem; + + table->size = newsize; + table->load = 0; + table->ents = newents; + memset(table->ents, 0, sizeof(fz_hashentry) * table->size); + + for (i = 0; i < oldsize; i++) + { + if (oldents[i].val) + { + error = fz_hashinsert(table, oldents[i].key, oldents[i].val); + if (error) + { + table->size = oldsize; + table->load = oldload; + table->ents = oldents; + fz_free(newents); + return error; + } + } + } + + fz_free(oldents); + return nil; +} + +void * +fz_hashfind(fz_hashtable *table, void *key) +{ + fz_hashentry *ents = table->ents; + unsigned size = table->size; + unsigned pos = hash(key, table->keylen) % size; + + while (1) + { + if (!ents[pos].val) + return nil; + + if (memcmp(key, &ents[pos].key, table->keylen) == 0) + return ents[pos].val; + + pos = (pos + 1) % size; + } +} + +fz_error * +fz_hashinsert(fz_hashtable *table, void *key, void *val) +{ + fz_error *error; + fz_hashentry *ents; + unsigned size; + unsigned pos; + + if (table->load > table->size * 8 / 10) + { + error = fz_resizehash(table, table->size * 2); + if (error) + return error; + } + + ents = table->ents; + size = table->size; + pos = hash(key, table->keylen) % size; + + while (1) + { + if (!ents[pos].val) + { + memcpy(ents[pos].key, key, table->keylen); + ents[pos].val = val; + table->load ++; + return nil; + } + + if (memcmp(key, &ents[pos].key, table->keylen) == 0) + return fz_throw("rangecheck: overwrite hash slot"); + + pos = (pos + 1) % size; + } + + return nil; +} + +fz_error * +fz_hashremove(fz_hashtable *table, void *key) +{ + fz_hashentry *ents = table->ents; + unsigned size = table->size; + unsigned pos = hash(key, table->keylen) % size; + unsigned hole, look, code; + + while (1) + { + if (!ents[pos].val) + return fz_throw("rangecheck: remove inexistant hash entry"); + + if (memcmp(key, &ents[pos].key, table->keylen) == 0) + { + ents[pos].val = nil; + + hole = pos; + look = (hole + 1) % size; + + while (ents[look].val) + { + code = hash(ents[look].key, table->keylen) % size; + if ((code <= hole && hole < look) || + (look < code && code <= hole) || + (hole < look && look < code)) + { + ents[hole] = ents[look]; + ents[look].val = nil; + hole = look; + } + + look = (look + 1) % size; + } + + table->load --; + return nil; + } + + pos = (pos + 1) % size; + } +} + +void +fz_debughash(fz_hashtable *table) +{ + int i, k; + + printf("cache load %d / %d\n", table->load, table->size); + + for (i = 0; i < table->size; i++) + { + if (!table->ents[i].val) + printf("table % 4d: empty\n", i); + else + { + printf("table % 4d: key=", i); + for (k = 0; k < MAXKEYLEN; k++) + printf("%02x", ((char*)table->ents[i].key)[k]); + printf(" val=$%p\n", table->ents[i].val); + } + } +} + diff --git a/base/base_matrix.c b/base/base_matrix.c new file mode 100644 index 00000000..7d7097c4 --- /dev/null +++ b/base/base_matrix.c @@ -0,0 +1,151 @@ +#include + +void fz_invert3x3(float *dst, float *m) +{ + float det; + int i; + +#define M3(m,i,j) (m)[3*i+j] +#define D2(a,b,c,d) (a * d - b * c) +#define D3(a1,a2,a3,b1,b2,b3,c1,c2,c3) \ + (a1 * D2(b2,b3,c2,c3)) - \ + (b1 * D2(a2,a3,c2,c3)) + \ + (c1 * D2(a2,a3,b2,b3)) + + det = D3(M3(m,0,0), M3(m,1,0), M3(m,2,0), + M3(m,0,1), M3(m,1,1), M3(m,2,1), + M3(m,0,2), M3(m,1,2), M3(m,2,2)); + if (det == 0) + det = 1.0; + det = 1.0 / det; + + M3(dst,0,0) = M3(m,1,1) * M3(m,2,2) - M3(m,1,2) * M3(m,2,1); + M3(dst,0,1) = -M3(m,0,1) * M3(m,2,2) + M3(m,0,2) * M3(m,2,1); + M3(dst,0,2) = M3(m,0,1) * M3(m,1,2) - M3(m,0,2) * M3(m,1,1); + + M3(dst,1,0) = -M3(m,1,0) * M3(m,2,2) + M3(m,1,2) * M3(m,2,0); + M3(dst,1,1) = M3(m,0,0) * M3(m,2,2) - M3(m,0,2) * M3(m,2,0); + M3(dst,1,2) = -M3(m,0,0) * M3(m,1,2) + M3(m,0,2) * M3(m,1,0); + + M3(dst,2,0) = M3(m,1,0) * M3(m,2,1) - M3(m,1,1) * M3(m,2,0); + M3(dst,2,1) = -M3(m,0,0) * M3(m,2,1) + M3(m,0,1) * M3(m,2,0); + M3(dst,2,2) = M3(m,0,0) * M3(m,1,1) - M3(m,0,1) * M3(m,1,0); + + for (i = 0; i < 9; i++) + dst[i] *= det; +} + +fz_matrix +fz_concat(fz_matrix one, fz_matrix two) +{ + fz_matrix dst; + dst.a = one.a * two.a + one.b * two.c; + dst.b = one.a * two.b + one.b * two.d; + dst.c = one.c * two.a + one.d * two.c; + dst.d = one.c * two.b + one.d * two.d; + dst.e = one.e * two.a + one.f * two.c + two.e; + dst.f = one.e * two.b + one.f * two.d + two.f; + return dst; +} + +fz_matrix +fz_identity(void) +{ + fz_matrix m; + m.a = 1; m.b = 0; + m.c = 0; m.d = 1; + m.e = 0; m.f = 0; + return m; +} + +fz_matrix +fz_scale(float sx, float sy) +{ + fz_matrix m; + m.a = sx; m.b = 0; + m.c = 0; m.d = sy; + m.e = 0; m.f = 0; + return m; +} + +fz_matrix +fz_rotate(float theta) +{ + fz_matrix m; + float s = sin(theta * M_PI / 180.0); + float c = cos(theta * M_PI / 180.0); + m.a = c; m.b = s; + m.c = -s; m.d = c; + m.e = 0; m.f = 0; + return m; +} + +fz_matrix +fz_translate(float tx, float ty) +{ + fz_matrix m; + m.a = 1; m.b = 0; + m.c = 0; m.d = 1; + m.e = tx; m.f = ty; + return m; +} + +fz_matrix +fz_invertmatrix(fz_matrix src) +{ + fz_matrix dst; + float rdet = 1.0 / (src.a * src.d - src.b * src.c); + dst.a = src.d * rdet; + dst.b = -src.b * rdet; + dst.c = -src.c * rdet; + dst.d = src.a * rdet; + dst.e = -src.e * dst.a - src.f * dst.c; + dst.f = -src.e * dst.b - src.f * dst.d; + return dst; +} + +int +fz_isrectilinear(fz_matrix m) +{ + return (fabs(m.b) < FLT_EPSILON && fabs(m.c) < FLT_EPSILON) || + (fabs(m.a) < FLT_EPSILON && fabs(m.d) < FLT_EPSILON); +} + +float +fz_matrixexpansion(fz_matrix m) +{ + return sqrt(fabs(m.a * m.d - m.b * m.c)); +} + +fz_point +fz_transformpoint(fz_matrix m, fz_point p) +{ + fz_point t; + t.x = p.x * m.a + p.y * m.c + m.e; + t.y = p.x * m.b + p.y * m.d + m.f; + return t; +} + +fz_rect +fz_transformaabb(fz_matrix m, fz_rect r) +{ + fz_point s, t, u, v; + + if (fz_isinfiniterect(r)) + return r; + + s.x = r.min.x; s.y = r.min.y; + t.x = r.min.x; t.y = r.max.y; + u.x = r.max.x; u.y = r.max.y; + v.x = r.max.x; v.y = r.min.y; + s = fz_transformpoint(m, s); + t = fz_transformpoint(m, t); + u = fz_transformpoint(m, u); + v = fz_transformpoint(m, v); + r.min.x = MIN4(s.x, t.x, u.x, v.x); + r.min.y = MIN4(s.y, t.y, u.y, v.y); + r.max.x = MAX4(s.x, t.x, u.x, v.x); + r.max.y = MAX4(s.y, t.y, u.y, v.y); + return r; +} + diff --git a/base/base_memory.c b/base/base_memory.c new file mode 100644 index 00000000..2c2f8e0d --- /dev/null +++ b/base/base_memory.c @@ -0,0 +1,81 @@ +#include + +/* Make this thread local storage if you wish. */ + +static void *stdmalloc(fz_memorycontext *mem, int n) +{ +#if 0 + void *p = malloc(n); + if (!p) + fprintf(stderr, "failed to malloc %d bytes\n", n); + return p; +#else + return malloc(n); +#endif +} + +static void *stdrealloc(fz_memorycontext *mem, void *p, int n) +{ +#if 0 + void *np = realloc(p, n); + if (np == nil) + fprintf(stderr, "realloc failed %d nytes", n); + else if (np == p) + fprintf(stderr, "realloc kept %d\n", n); + else + fprintf(stderr, "realloc moved %d\n", n); + return np; +#else + return realloc(p, n); +#endif +} + +static void stdfree(fz_memorycontext *mem, void *p) +{ + free(p); +} + +static fz_memorycontext defmem = { stdmalloc, stdrealloc, stdfree }; +static fz_memorycontext *curmem = &defmem; + +fz_error fz_koutofmem = { + -1, + {"out of memory"}, + {""}, + {"memory.c"}, + 0 +}; + +fz_memorycontext * +fz_currentmemorycontext() +{ + return curmem; +} + +void +fz_setmemorycontext(fz_memorycontext *mem) +{ + curmem = mem; +} + +void * +fz_malloc(int n) +{ + fz_memorycontext *mem = fz_currentmemorycontext(); + return mem->malloc(mem, n); +} + +void * +fz_realloc(void *p, int n) +{ + fz_memorycontext *mem = fz_currentmemorycontext(); + return mem->realloc(mem, p, n); +} + +void +fz_free(void *p) +{ + fz_memorycontext *mem = fz_currentmemorycontext(); + mem->free(mem, p); +} + diff --git a/base/base_rect.c b/base/base_rect.c new file mode 100644 index 00000000..2efb11f7 --- /dev/null +++ b/base/base_rect.c @@ -0,0 +1,75 @@ +#include + +fz_rect fz_infiniterect = { { 1, 1}, {-1, -1} }; +fz_rect fz_emptyrect = { { 0, 0}, {0, 0} }; + +static fz_irect infinite = { { 1, 1}, {-1, -1} }; +static fz_irect empty = { { 0, 0}, {0, 0} }; + +fz_irect +fz_roundrect(fz_rect f) +{ + fz_irect i; + i.min.x = fz_floor(f.min.x); + i.min.y = fz_floor(f.min.y); + i.max.x = fz_ceil(f.max.x); + i.max.y = fz_ceil(f.max.y); + return i; +} + +fz_rect +fz_intersectrects(fz_rect a, fz_rect b) +{ + fz_rect r; + if (fz_isinfiniterect(a)) return b; + if (fz_isinfiniterect(b)) return a; + r.min.x = MAX(a.min.x, b.min.x); + r.min.y = MAX(a.min.y, b.min.y); + r.max.x = MIN(a.max.x, b.max.x); + r.max.y = MIN(a.max.y, b.max.y); + return (r.max.x < r.min.x || r.max.y < r.min.y) ? fz_emptyrect : r; +} + +fz_rect +fz_mergerects(fz_rect a, fz_rect b) +{ + fz_rect r; + if (fz_isinfiniterect(a) || fz_isinfiniterect(b)) + return fz_infiniterect; + if (fz_isemptyrect(a)) return b; + if (fz_isemptyrect(b)) return a; + r.min.x = MIN(a.min.x, b.min.x); + r.min.y = MIN(a.min.y, b.min.y); + r.max.x = MAX(a.max.x, b.max.x); + r.max.y = MAX(a.max.y, b.max.y); + return r; +} + +fz_irect +fz_intersectirects(fz_irect a, fz_irect b) +{ + fz_irect r; + if (fz_isinfiniterect(a)) return b; + if (fz_isinfiniterect(b)) return a; + r.min.x = MAX(a.min.x, b.min.x); + r.min.y = MAX(a.min.y, b.min.y); + r.max.x = MIN(a.max.x, b.max.x); + r.max.y = MIN(a.max.y, b.max.y); + return (r.max.x < r.min.x || r.max.y < r.min.y) ? empty : r; +} + +fz_irect +fz_mergeirects(fz_irect a, fz_irect b) +{ + fz_irect r; + if (fz_isinfiniterect(a) || fz_isinfiniterect(b)) + return infinite; + if (fz_isemptyrect(a)) return b; + if (fz_isemptyrect(b)) return a; + r.min.x = MIN(a.min.x, b.min.x); + r.min.y = MIN(a.min.y, b.min.y); + r.max.x = MAX(a.max.x, b.max.x); + r.max.y = MAX(a.max.y, b.max.y); + return r; +} + diff --git a/base/base_rune.c b/base/base_rune.c new file mode 100644 index 00000000..4aa81df3 --- /dev/null +++ b/base/base_rune.c @@ -0,0 +1,168 @@ +enum +{ + UTFmax = 3, /* maximum bytes per rune */ + Runesync = 0x80, /* cannot represent part of a UTF sequence (<) */ + Runeself = 0x80, /* rune and UTF sequences are the same (<) */ + Runeerror = 0x80 /* decoding error in UTF */ +}; + +enum +{ + Bit1 = 7, + Bitx = 6, + Bit2 = 5, + Bit3 = 4, + Bit4 = 3, + + T1 = ((1<<(Bit1+1))-1) ^ 0xFF, /* 0000 0000 */ + Tx = ((1<<(Bitx+1))-1) ^ 0xFF, /* 1000 0000 */ + T2 = ((1<<(Bit2+1))-1) ^ 0xFF, /* 1100 0000 */ + T3 = ((1<<(Bit3+1))-1) ^ 0xFF, /* 1110 0000 */ + T4 = ((1<<(Bit4+1))-1) ^ 0xFF, /* 1111 0000 */ + + Rune1 = (1<<(Bit1+0*Bitx))-1, /* 0000 0000 0111 1111 */ + Rune2 = (1<<(Bit2+1*Bitx))-1, /* 0000 0111 1111 1111 */ + Rune3 = (1<<(Bit3+2*Bitx))-1, /* 1111 1111 1111 1111 */ + + Maskx = (1< T1 + */ + c = *(unsigned char*)str; + if(c < Tx) { + *rune = c; + return 1; + } + + /* + * two character sequence + * 0080-07FF => T2 Tx + */ + c1 = *(unsigned char*)(str+1) ^ Tx; + if(c1 & Testx) + goto bad; + if(c < T3) { + if(c < T2) + goto bad; + l = ((c << Bitx) | c1) & Rune2; + if(l <= Rune1) + goto bad; + *rune = l; + return 2; + } + + /* + * three character sequence + * 0800-FFFF => T3 Tx Tx + */ + c2 = *(unsigned char*)(str+2) ^ Tx; + if(c2 & Testx) + goto bad; + if(c < T4) { + l = ((((c << Bitx) | c1) << Bitx) | c2) & Rune3; + if(l <= Rune2) + goto bad; + *rune = l; + return 3; + } + + /* + * bad decoding + */ +bad: + *rune = Bad; + return 1; +} + +int +runetochar(char *str, int *rune) +{ + int c; + + /* + * one character sequence + * 00000-0007F => 00-7F + */ + c = *rune; + if(c <= Rune1) { + str[0] = c; + return 1; + } + + /* + * two character sequence + * 0080-07FF => T2 Tx + */ + if(c <= Rune2) { + str[0] = T2 | (c >> 1*Bitx); + str[1] = Tx | (c & Maskx); + return 2; + } + + /* + * three character sequence + * 0800-FFFF => T3 Tx Tx + */ + str[0] = T3 | (c >> 2*Bitx); + str[1] = Tx | ((c >> 1*Bitx) & Maskx); + str[2] = Tx | (c & Maskx); + return 3; +} + +int +runelen(int c) +{ + int rune; + char str[10]; + + rune = c; + return runetochar(str, &rune); +} + +int +runenlen(int *r, int nrune) +{ + int nb, c; + + nb = 0; + while(nrune--) { + c = *r++; + if(c <= Rune1) + nb++; + else + if(c <= Rune2) + nb += 2; + else + nb += 3; + } + return nb; +} + +int +fullrune(char *str, int n) +{ + int c; + + if(n > 0) { + c = *(unsigned char*)str; + if(c < Tx) + return 1; + if(n > 1) + if(c < T3 || n > 2) + return 1; + } + return 0; +} + diff --git a/base/cpudep.c b/base/cpudep.c deleted file mode 100644 index 0db2e331..00000000 --- a/base/cpudep.c +++ /dev/null @@ -1,221 +0,0 @@ -/* -run-time cpu feature detection code -mm, alphabet soup... - -Glenn Kennard -*/ - -#include - -/* global run-time constant */ -unsigned fz_cpuflags = 0; - -#ifndef HAVE_CPUDEP - -void fz_accelerate(void) -{ -} - -void fz_cpudetect(void) -{ -} - -#else - -#include /* signal/sigaction */ -#include /* sigsetjmp/siglongjmp */ - -#ifdef WIN32 -#define sigjmp_buf jmp_buf -#define sigsetjmp(a,b) setjmp(a) -#define siglongjmp longjmp -#endif - -typedef struct { - void (*test)(void); - const unsigned flag; - const char *name; -} featuretest; - - -#if defined(ARCH_X86) || defined(ARCH_X86_64) - -/* need emms?? */ -static void mmx(void) -{ __asm__ ("pand %mm0, %mm0\n\t"); } - -static void m3dnow(void) -{ __asm__ ("pavgusb %mm0, %mm0\n\t"); } - -static void mmxext(void) /* aka Extended 3DNow! */ -{ __asm__ ("pmaxsw %mm0, %mm0\n\t"); } - -static void sse(void) -{ __asm__ ("andps %xmm0, %xmm0\n\t"); } - -static void sse2(void) -{ __asm__ ("andpd %xmm0, %xmm0\n\t"); } - -/* static void sse3(void) */ -/* { __asm__ ("haddps %%xmm0, %%xmm0\n\t" : : : "%xmm0"); } */ - -#ifdef ARCH_X86_64 -static void amd64(void) -{ __asm__ ("and %rax, %rax\n\t"); } -#endif - - -static const featuretest features[] = { - { mmx, HAVE_MMX, "mmx" }, - { m3dnow, HAVE_3DNOW, "3dnow" }, - { mmxext, HAVE_MMXEXT, "mmxext" }, - { sse, HAVE_SSE, "sse" }, - { sse2, HAVE_SSE2, "sse2" }, -/* { sse3, HAVE_SSE3, "sse3" }, */ -#ifdef ARCH_X86_64 - { amd64, HAVE_AMD64, "amd64" } -#endif -}; - -#endif - - -#if defined(ARCH_SPARC) -/* assembler must have -xarch=v8plusa passed to it (v9a for 64 bit binaries) */ -static void vis(void) -{ __asm__ ("fand %f8, %f8, %f8\n\t"); } - -static const featuretest features[] = { - { vis, HAVE_VIS, "vis" } -}; - -#endif - - -#if defined(ARCH_PPC) - -static void altivec(void) -{ __asm__ ("vand v0, v0, v0\n\t"); } - - -static const featuretest features[] = { - { altivec, HAVE_ALTIVEC, "altivec" }, -}; - -#endif - -static sigjmp_buf jmpbuf; -static volatile sig_atomic_t canjump; - -static void -sigillhandler(int sig) -{ - if (!canjump) { - signal(sig, SIG_DFL); - raise(sig); - } - - canjump = 0; - siglongjmp(jmpbuf, 1); -} - -static int -enabled(char *env, const char *ext) -{ - int len; - char *s; - if (!env) - return 1; - len = strlen(ext); - while ((s = strstr(env, ext))) - { - s += len; - if (*s == ' ' || *s == ',' || *s == '\0') - return 1; - } - return 0; -} - -static void -dumpflags(void) -{ - unsigned f = fz_cpuflags; - int i, n; - - fputs("detected cpu features:", stdout); - n = 0; - for (i = 0; i < sizeof(features) / sizeof(featuretest); i++) - { - if (f & features[i].flag) - { - fputc(' ', stdout); - fputs(features[i].name, stdout); - n ++; - } - } - if (!n) - fputs(" none", stdout); - fputc('\n', stdout); -} - -void fz_cpudetect(void) -{ - static int hasrun = 0; - - unsigned flags = 0; - int i; - void (*oldhandler)(int) = NULL; - void (*tmphandler)(int); - char *env; - - if (hasrun) - return; - hasrun = 1; - - env = getenv("CPUACCEL"); - - for (i = 0; i < sizeof(features) / sizeof(featuretest); i++) - { - canjump = 0; - - tmphandler = signal(SIGILL, sigillhandler); - if (!oldhandler) - oldhandler = tmphandler; - - if (sigsetjmp(jmpbuf, 1)) - { - /* test failed - disable feature */ - flags &= ~features[i].flag; - continue; - } - - canjump = 1; - - features[i].test(); - - /* if we got here the test succeeded */ - if (enabled(env, features[i].name)) - flags |= features[i].flag; - else - flags &= ~features[i].flag; - } - - /* restore previous signal handler */ - signal(SIGILL, oldhandler); - - fz_cpuflags = flags; - -#if defined(ARCH_X86) || defined(ARCH_X86_64) - __asm__ __volatile__ ("emms\n\t"); -#endif - - dumpflags(); -} - -static __attribute__((constructor, used)) void fzcpudetect(void) -{ - fz_cpudetect(); -} - -#endif - diff --git a/base/error.c b/base/error.c deleted file mode 100644 index 926c48dc..00000000 --- a/base/error.c +++ /dev/null @@ -1,78 +0,0 @@ -#include - -void -fz_warn(char *fmt, ...) -{ - va_list ap; - fprintf(stderr, "warning: "); - va_start(ap, fmt); - vfprintf(stderr, fmt, ap); - va_end(ap); - fprintf(stderr, "\n"); -} - -fz_error * -fz_throw1(char *fmt, ...) -{ - va_list ap; - fz_error *eo; - - eo = fz_malloc(sizeof(fz_error)); - if (!eo) return fz_outofmem; - - eo->refs = 1; - strlcpy(eo->func, "unknown", sizeof eo->func); - strlcpy(eo->file, "unknown", sizeof eo->file); - eo->line = 0; - - va_start(ap, fmt); - vsnprintf(eo->msg, sizeof eo->msg, fmt, ap); - eo->msg[sizeof(eo->msg) - 1] = '\0'; - va_end(ap); - - return eo; -} - -fz_error * -fz_throw0(const char *func, const char *file, int line, char *fmt, ...) -{ - va_list ap; - fz_error *eo; - - eo = fz_malloc(sizeof(fz_error)); - if (!eo) return fz_outofmem; - - eo->refs = 1; - strlcpy(eo->func, func, sizeof eo->func); - strlcpy(eo->file, file, sizeof eo->file); - eo->line = line; - - va_start(ap, fmt); - vsnprintf(eo->msg, sizeof eo->msg, fmt, ap); - eo->msg[sizeof(eo->msg) - 1] = '\0'; - va_end(ap); - - if (getenv("BOMB")) - fz_abort(eo); - - return eo; -} - -void -fz_droperror(fz_error *eo) -{ - if (eo->refs > 0) - eo->refs--; - if (eo->refs == 0) - fz_free(eo); -} - -void -fz_abort(fz_error *eo) -{ - fflush(stdout); - fprintf(stderr, "%s:%d: %s(): %s\n", eo->file, eo->line, eo->func, eo->msg); - fflush(stderr); - abort(); -} - diff --git a/base/hash.c b/base/hash.c deleted file mode 100644 index 65bc7130..00000000 --- a/base/hash.c +++ /dev/null @@ -1,274 +0,0 @@ -/* Linear probe hash table. - * 2004 (C) Tor Andersson. - * BSD license. - * - * Simple hashtable with open adressing linear probe. - * Unlike text book examples, removing entries works - * correctly in this implementation so it wont start - * exhibiting bad behaviour if entries are inserted - * and removed frequently. - */ - -#include - -enum { MAXKEYLEN = 16 }; - -typedef struct fz_hashentry_s fz_hashentry; - -struct fz_hashentry_s -{ - unsigned char key[MAXKEYLEN]; - void *val; -}; - -struct fz_hashtable_s -{ - int keylen; - int size; - int load; - fz_hashentry *ents; -}; - -static unsigned hash(unsigned char *s, int len) -{ - unsigned hash = 0; - int i; - for (i = 0; i < len; i++) - { - hash += s[i]; - hash += (hash << 10); - hash ^= (hash >> 6); - } - hash += (hash << 3); - hash ^= (hash >> 11); - hash += (hash << 15); - return hash; -} - -fz_error * -fz_newhash(fz_hashtable **tablep, int initialsize, int keylen) -{ - fz_hashtable *table; - - assert(keylen <= MAXKEYLEN); - - table = *tablep = fz_malloc(sizeof(fz_hashtable)); - if (!table) - return fz_outofmem; - - table->keylen = keylen; - table->size = initialsize; - table->load = 0; - - table->ents = fz_malloc(sizeof(fz_hashentry) * table->size); - if (!table->ents) - { - fz_free(table); - *tablep = nil; - return fz_outofmem; - } - - memset(table->ents, 0, sizeof(fz_hashentry) * table->size); - - return nil; -} - -void -fz_emptyhash(fz_hashtable *table) -{ - table->load = 0; - memset(table->ents, 0, sizeof(fz_hashentry) * table->size); -} - -int -fz_hashlen(fz_hashtable *table) -{ - return table->size; -} - -void * -fz_hashgetkey(fz_hashtable *table, int idx) -{ - return table->ents[idx].key; -} - -void * -fz_hashgetval(fz_hashtable *table, int idx) -{ - return table->ents[idx].val; -} - -void -fz_drophash(fz_hashtable *table) -{ - fz_free(table->ents); - fz_free(table); -} - -fz_error * -fz_resizehash(fz_hashtable *table, int newsize) -{ - fz_error *error; - fz_hashentry *newents; - fz_hashentry *oldents; - int oldload; - int oldsize; - int i; - - oldsize = table->size; - oldload = table->load; - oldents = table->ents; - - if (newsize < oldload * 8 / 10) - return fz_throw("rangecheck: resize hash too small"); - - newents = fz_malloc(sizeof(fz_hashentry) * newsize); - if (!newents) - return fz_outofmem; - - table->size = newsize; - table->load = 0; - table->ents = newents; - memset(table->ents, 0, sizeof(fz_hashentry) * table->size); - - for (i = 0; i < oldsize; i++) - { - if (oldents[i].val) - { - error = fz_hashinsert(table, oldents[i].key, oldents[i].val); - if (error) - { - table->size = oldsize; - table->load = oldload; - table->ents = oldents; - fz_free(newents); - return error; - } - } - } - - fz_free(oldents); - return nil; -} - -void * -fz_hashfind(fz_hashtable *table, void *key) -{ - fz_hashentry *ents = table->ents; - unsigned size = table->size; - unsigned pos = hash(key, table->keylen) % size; - - while (1) - { - if (!ents[pos].val) - return nil; - - if (memcmp(key, &ents[pos].key, table->keylen) == 0) - return ents[pos].val; - - pos = (pos + 1) % size; - } -} - -fz_error * -fz_hashinsert(fz_hashtable *table, void *key, void *val) -{ - fz_error *error; - fz_hashentry *ents; - unsigned size; - unsigned pos; - - if (table->load > table->size * 8 / 10) - { - error = fz_resizehash(table, table->size * 2); - if (error) - return error; - } - - ents = table->ents; - size = table->size; - pos = hash(key, table->keylen) % size; - - while (1) - { - if (!ents[pos].val) - { - memcpy(ents[pos].key, key, table->keylen); - ents[pos].val = val; - table->load ++; - return nil; - } - - if (memcmp(key, &ents[pos].key, table->keylen) == 0) - return fz_throw("rangecheck: overwrite hash slot"); - - pos = (pos + 1) % size; - } - - return nil; -} - -fz_error * -fz_hashremove(fz_hashtable *table, void *key) -{ - fz_hashentry *ents = table->ents; - unsigned size = table->size; - unsigned pos = hash(key, table->keylen) % size; - unsigned hole, look, code; - - while (1) - { - if (!ents[pos].val) - return fz_throw("rangecheck: remove inexistant hash entry"); - - if (memcmp(key, &ents[pos].key, table->keylen) == 0) - { - ents[pos].val = nil; - - hole = pos; - look = (hole + 1) % size; - - while (ents[look].val) - { - code = hash(ents[look].key, table->keylen) % size; - if ((code <= hole && hole < look) || - (look < code && code <= hole) || - (hole < look && look < code)) - { - ents[hole] = ents[look]; - ents[look].val = nil; - hole = look; - } - - look = (look + 1) % size; - } - - table->load --; - return nil; - } - - pos = (pos + 1) % size; - } -} - -void -fz_debughash(fz_hashtable *table) -{ - int i, k; - - printf("cache load %d / %d\n", table->load, table->size); - - for (i = 0; i < table->size; i++) - { - if (!table->ents[i].val) - printf("table % 4d: empty\n", i); - else - { - printf("table % 4d: key=", i); - for (k = 0; k < MAXKEYLEN; k++) - printf("%02x", ((char*)table->ents[i].key)[k]); - printf(" val=$%p\n", table->ents[i].val); - } - } -} - diff --git a/base/matrix.c b/base/matrix.c deleted file mode 100644 index 7d7097c4..00000000 --- a/base/matrix.c +++ /dev/null @@ -1,151 +0,0 @@ -#include - -void fz_invert3x3(float *dst, float *m) -{ - float det; - int i; - -#define M3(m,i,j) (m)[3*i+j] -#define D2(a,b,c,d) (a * d - b * c) -#define D3(a1,a2,a3,b1,b2,b3,c1,c2,c3) \ - (a1 * D2(b2,b3,c2,c3)) - \ - (b1 * D2(a2,a3,c2,c3)) + \ - (c1 * D2(a2,a3,b2,b3)) - - det = D3(M3(m,0,0), M3(m,1,0), M3(m,2,0), - M3(m,0,1), M3(m,1,1), M3(m,2,1), - M3(m,0,2), M3(m,1,2), M3(m,2,2)); - if (det == 0) - det = 1.0; - det = 1.0 / det; - - M3(dst,0,0) = M3(m,1,1) * M3(m,2,2) - M3(m,1,2) * M3(m,2,1); - M3(dst,0,1) = -M3(m,0,1) * M3(m,2,2) + M3(m,0,2) * M3(m,2,1); - M3(dst,0,2) = M3(m,0,1) * M3(m,1,2) - M3(m,0,2) * M3(m,1,1); - - M3(dst,1,0) = -M3(m,1,0) * M3(m,2,2) + M3(m,1,2) * M3(m,2,0); - M3(dst,1,1) = M3(m,0,0) * M3(m,2,2) - M3(m,0,2) * M3(m,2,0); - M3(dst,1,2) = -M3(m,0,0) * M3(m,1,2) + M3(m,0,2) * M3(m,1,0); - - M3(dst,2,0) = M3(m,1,0) * M3(m,2,1) - M3(m,1,1) * M3(m,2,0); - M3(dst,2,1) = -M3(m,0,0) * M3(m,2,1) + M3(m,0,1) * M3(m,2,0); - M3(dst,2,2) = M3(m,0,0) * M3(m,1,1) - M3(m,0,1) * M3(m,1,0); - - for (i = 0; i < 9; i++) - dst[i] *= det; -} - -fz_matrix -fz_concat(fz_matrix one, fz_matrix two) -{ - fz_matrix dst; - dst.a = one.a * two.a + one.b * two.c; - dst.b = one.a * two.b + one.b * two.d; - dst.c = one.c * two.a + one.d * two.c; - dst.d = one.c * two.b + one.d * two.d; - dst.e = one.e * two.a + one.f * two.c + two.e; - dst.f = one.e * two.b + one.f * two.d + two.f; - return dst; -} - -fz_matrix -fz_identity(void) -{ - fz_matrix m; - m.a = 1; m.b = 0; - m.c = 0; m.d = 1; - m.e = 0; m.f = 0; - return m; -} - -fz_matrix -fz_scale(float sx, float sy) -{ - fz_matrix m; - m.a = sx; m.b = 0; - m.c = 0; m.d = sy; - m.e = 0; m.f = 0; - return m; -} - -fz_matrix -fz_rotate(float theta) -{ - fz_matrix m; - float s = sin(theta * M_PI / 180.0); - float c = cos(theta * M_PI / 180.0); - m.a = c; m.b = s; - m.c = -s; m.d = c; - m.e = 0; m.f = 0; - return m; -} - -fz_matrix -fz_translate(float tx, float ty) -{ - fz_matrix m; - m.a = 1; m.b = 0; - m.c = 0; m.d = 1; - m.e = tx; m.f = ty; - return m; -} - -fz_matrix -fz_invertmatrix(fz_matrix src) -{ - fz_matrix dst; - float rdet = 1.0 / (src.a * src.d - src.b * src.c); - dst.a = src.d * rdet; - dst.b = -src.b * rdet; - dst.c = -src.c * rdet; - dst.d = src.a * rdet; - dst.e = -src.e * dst.a - src.f * dst.c; - dst.f = -src.e * dst.b - src.f * dst.d; - return dst; -} - -int -fz_isrectilinear(fz_matrix m) -{ - return (fabs(m.b) < FLT_EPSILON && fabs(m.c) < FLT_EPSILON) || - (fabs(m.a) < FLT_EPSILON && fabs(m.d) < FLT_EPSILON); -} - -float -fz_matrixexpansion(fz_matrix m) -{ - return sqrt(fabs(m.a * m.d - m.b * m.c)); -} - -fz_point -fz_transformpoint(fz_matrix m, fz_point p) -{ - fz_point t; - t.x = p.x * m.a + p.y * m.c + m.e; - t.y = p.x * m.b + p.y * m.d + m.f; - return t; -} - -fz_rect -fz_transformaabb(fz_matrix m, fz_rect r) -{ - fz_point s, t, u, v; - - if (fz_isinfiniterect(r)) - return r; - - s.x = r.min.x; s.y = r.min.y; - t.x = r.min.x; t.y = r.max.y; - u.x = r.max.x; u.y = r.max.y; - v.x = r.max.x; v.y = r.min.y; - s = fz_transformpoint(m, s); - t = fz_transformpoint(m, t); - u = fz_transformpoint(m, u); - v = fz_transformpoint(m, v); - r.min.x = MIN4(s.x, t.x, u.x, v.x); - r.min.y = MIN4(s.y, t.y, u.y, v.y); - r.max.x = MAX4(s.x, t.x, u.x, v.x); - r.max.y = MAX4(s.y, t.y, u.y, v.y); - return r; -} - diff --git a/base/md5.c b/base/md5.c deleted file mode 100644 index 03601e5b..00000000 --- a/base/md5.c +++ /dev/null @@ -1,269 +0,0 @@ -/* -MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm - -Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. -All rights reserved. - -License to copy and use this software is granted provided that it -is identified as the "RSA Data Security, Inc. MD5 Message-Digest -Algorithm" in all material mentioning or referencing this software -or this function. - -License is also granted to make and use derivative works provided -that such works are identified as "derived from the RSA Data -Security, Inc. MD5 Message-Digest Algorithm" in all material -mentioning or referencing the derived work. - -RSA Data Security, Inc. makes no representations concerning either -the merchantability of this software or the suitability of this -software for any particular purpose. It is provided "as is" -without express or implied warranty of any kind. - -These notices must be retained in any copies of any part of this -documentation and/or software. -*/ - -#include - -/* Constants for MD5Transform routine */ -enum -{ - S11 = 7, S12 = 12, S13 = 17, S14 = 22, - S21 = 5, S22 = 9, S23 = 14, S24 = 20, - S31 = 4, S32 = 11, S33 = 16, S34 = 23, - S41 = 6, S42 = 10, S43 = 15, S44 = 21 -}; - -static void encode(unsigned char *, unsigned long *, unsigned); -static void decode(unsigned long *, unsigned char *, unsigned); -static void transform(unsigned long state[4], unsigned char block[64]); - -static unsigned char padding[64] = -{ - 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 -}; - -/* F, G, H and I are basic MD5 functions */ -#define F(x, y, z) (((x) & (y)) | ((~x) & (z))) -#define G(x, y, z) (((x) & (z)) | ((y) & (~z))) -#define H(x, y, z) ((x) ^ (y) ^ (z)) -#define I(x, y, z) ((y) ^ ((x) | (~z))) - -/* ROTATE rotates x left n bits */ -#define ROTATE(x, n) (((x) << (n)) | ((x) >> (32-(n)))) - -/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4. - * Rotation is separate from addition to prevent recomputation. - */ -#define FF(a, b, c, d, x, s, ac) { \ - (a) += F ((b), (c), (d)) + (x) + (unsigned long)(ac); \ - (a) = ROTATE ((a), (s)); \ - (a) += (b); \ - } -#define GG(a, b, c, d, x, s, ac) { \ - (a) += G ((b), (c), (d)) + (x) + (unsigned long)(ac); \ - (a) = ROTATE ((a), (s)); \ - (a) += (b); \ - } -#define HH(a, b, c, d, x, s, ac) { \ - (a) += H ((b), (c), (d)) + (x) + (unsigned long)(ac); \ - (a) = ROTATE ((a), (s)); \ - (a) += (b); \ - } -#define II(a, b, c, d, x, s, ac) { \ - (a) += I ((b), (c), (d)) + (x) + (unsigned long)(ac); \ - (a) = ROTATE ((a), (s)); \ - (a) += (b); \ - } - -static void encode(unsigned char *output, unsigned long *input, unsigned len) -{ - unsigned i, j; - - for (i = 0, j = 0; j < len; i++, j += 4) { - output[j] = (unsigned char)(input[i] & 0xff); - output[j+1] = (unsigned char)((input[i] >> 8) & 0xff); - output[j+2] = (unsigned char)((input[i] >> 16) & 0xff); - output[j+3] = (unsigned char)((input[i] >> 24) & 0xff); - } -} - -static void decode(unsigned long *output, unsigned char *input, unsigned len) -{ - unsigned i, j; - - for (i = 0, j = 0; j < len; i++, j += 4) { - output[i] = ((unsigned long)input[j]) | - (((unsigned long)input[j+1]) << 8) | - (((unsigned long)input[j+2]) << 16) | - (((unsigned long)input[j+3]) << 24); - } -} - -static void transform(unsigned long state[4], unsigned char block[64]) -{ - unsigned long a = state[0]; - unsigned long b = state[1]; - unsigned long c = state[2]; - unsigned long d = state[3]; - unsigned long x[16]; - - decode(x, block, 64); - - /* Round 1 */ - FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */ - FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */ - FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */ - FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */ - FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */ - FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */ - FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */ - FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */ - FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */ - FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */ - FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */ - FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */ - FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */ - FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */ - FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */ - FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */ - - /* Round 2 */ - GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */ - GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */ - GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */ - GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */ - GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */ - GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */ - GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */ - GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */ - GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */ - GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */ - GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */ - GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */ - GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */ - GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */ - GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */ - GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */ - - /* Round 3 */ - HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */ - HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */ - HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */ - HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */ - HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */ - HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */ - HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */ - HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */ - HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */ - HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */ - HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */ - HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */ - HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */ - HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */ - HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */ - HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */ - - /* Round 4 */ - II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */ - II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */ - II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */ - II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */ - II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */ - II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */ - II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */ - II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */ - II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */ - II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */ - II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */ - II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */ - II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */ - II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */ - II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */ - II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */ - - state[0] += a; - state[1] += b; - state[2] += c; - state[3] += d; - - /* Zeroize sensitive information */ - memset(x, 0, sizeof (x)); -} - -/* MD5 initialization. Begins an MD5 operation, writing a new context. */ -void fz_md5init(fz_md5 *context) -{ - context->count[0] = context->count[1] = 0; - - /* Load magic initialization constants */ - context->state[0] = 0x67452301; - context->state[1] = 0xefcdab89; - context->state[2] = 0x98badcfe; - context->state[3] = 0x10325476; -} - -/* MD5 block update operation. Continues an MD5 message-digest operation, - * processing another message block, and updating the context. - */ -void fz_md5update(fz_md5 *context, unsigned char *input, unsigned inlen) -{ - unsigned i, index, partlen; - - /* Compute number of bytes mod 64 */ - index = (unsigned)((context->count[0] >> 3) & 0x3F); - - /* Update number of bits */ - context->count[0] += (unsigned long) inlen << 3; - if (context->count[0] < (unsigned long) inlen << 3) - context->count[1] ++; - context->count[1] += (unsigned long) inlen >> 29; - - partlen = 64 - index; - - /* Transform as many times as possible. */ - if (inlen >= partlen) { - memcpy(context->buffer + index, input, partlen); - transform(context->state, context->buffer); - - for (i = partlen; i + 63 < inlen; i += 64) - transform(context->state, input + i); - - index = 0; - } - else { - i = 0; - } - - /* Buffer remaining input */ - memcpy(context->buffer + index, input + i, inlen - i); -} - -/* MD5 finalization. Ends an MD5 message-digest operation, writing the - * the message digest and zeroizing the context. - */ -void fz_md5final(fz_md5 *context, unsigned char digest[16]) -{ - unsigned char bits[8]; - unsigned index, padlen; - - /* Save number of bits */ - encode(bits, context->count, 8); - - /* Pad out to 56 mod 64 */ - index = (unsigned)((context->count[0] >> 3) & 0x3f); - padlen = index < 56 ? 56 - index : 120 - index; - fz_md5update(context, padding, padlen); - - /* Append length (before padding) */ - fz_md5update(context, bits, 8); - - /* Store state in digest */ - encode(digest, context->state, 16); - - /* Zeroize sensitive information */ - memset(context, 0, sizeof(fz_md5)); -} - diff --git a/base/memory.c b/base/memory.c deleted file mode 100644 index 2c2f8e0d..00000000 --- a/base/memory.c +++ /dev/null @@ -1,81 +0,0 @@ -#include - -/* Make this thread local storage if you wish. */ - -static void *stdmalloc(fz_memorycontext *mem, int n) -{ -#if 0 - void *p = malloc(n); - if (!p) - fprintf(stderr, "failed to malloc %d bytes\n", n); - return p; -#else - return malloc(n); -#endif -} - -static void *stdrealloc(fz_memorycontext *mem, void *p, int n) -{ -#if 0 - void *np = realloc(p, n); - if (np == nil) - fprintf(stderr, "realloc failed %d nytes", n); - else if (np == p) - fprintf(stderr, "realloc kept %d\n", n); - else - fprintf(stderr, "realloc moved %d\n", n); - return np; -#else - return realloc(p, n); -#endif -} - -static void stdfree(fz_memorycontext *mem, void *p) -{ - free(p); -} - -static fz_memorycontext defmem = { stdmalloc, stdrealloc, stdfree }; -static fz_memorycontext *curmem = &defmem; - -fz_error fz_koutofmem = { - -1, - {"out of memory"}, - {""}, - {"memory.c"}, - 0 -}; - -fz_memorycontext * -fz_currentmemorycontext() -{ - return curmem; -} - -void -fz_setmemorycontext(fz_memorycontext *mem) -{ - curmem = mem; -} - -void * -fz_malloc(int n) -{ - fz_memorycontext *mem = fz_currentmemorycontext(); - return mem->malloc(mem, n); -} - -void * -fz_realloc(void *p, int n) -{ - fz_memorycontext *mem = fz_currentmemorycontext(); - return mem->realloc(mem, p, n); -} - -void -fz_free(void *p) -{ - fz_memorycontext *mem = fz_currentmemorycontext(); - mem->free(mem, p); -} - diff --git a/base/node_debug.c b/base/node_debug.c new file mode 100644 index 00000000..b03d4e28 --- /dev/null +++ b/base/node_debug.c @@ -0,0 +1,191 @@ +#include + +static void indent(int level) +{ + while (level--) + putchar(' '); +} + +static void lispnode(fz_node *node, int level); + +static void lispmeta(fz_metanode *node, int level) +{ + fz_node *child; + indent(level); + printf("(meta "); + if (node->name) { fz_debugobj(node->name); } + if (node->dict) { printf("\n"); fz_debugobj(node->dict); } + printf("\n"); + for (child = node->super.first; child; child = child->next) + lispnode(child, level + 1); + indent(level); + printf(")\n"); +} + +static void lispover(fz_overnode *node, int level) +{ + fz_node *child; + indent(level); + printf("(over\n"); + for (child = node->super.first; child; child = child->next) + lispnode(child, level + 1); + indent(level); + printf(")\n"); +} + +static void lispmask(fz_masknode *node, int level) +{ + fz_node *child; + indent(level); + printf("(mask\n"); + for (child = node->super.first; child; child = child->next) + lispnode(child, level + 1); + indent(level); + printf(")\n"); +} + +static void lispblend(fz_blendnode *node, int level) +{ + fz_node *child; + indent(level); + printf("(blend-%d\n", node->mode); + for (child = node->super.first; child; child = child->next) + lispnode(child, level + 1); + indent(level); + printf(")\n"); +} + +static void lisptransform(fz_transformnode *node, int level) +{ + indent(level); + printf("(transform %g %g %g %g %g %g\n", + node->m.a, node->m.b, + node->m.c, node->m.d, + node->m.e, node->m.f); + lispnode(node->super.first, level + 1); + indent(level); + printf(")\n"); +} + +static void lispcolor(fz_colornode *node, int level) +{ + int i; + indent(level); + printf("(color %s ", node->cs->name); + for (i = 0; i < node->n; i++) + printf("%g ", node->samples[i]); + printf(")\n"); +} + +static void lisplink(fz_linknode *node, int level) +{ + indent(level); + printf("(link %p)\n", node->tree); +} + +static void lisppath(fz_pathnode *node, int level) +{ + int i; + + indent(level); + + if (node->paint == FZ_STROKE) + { + printf("(path 'stroke %d %d %g %g ", + node->linecap, + node->linejoin, + node->linewidth, + node->miterlimit); + if (node->dash) + { + printf("%g '( ", node->dash->phase); + for (i = 0; i < node->dash->len; i++) + printf("%g ", node->dash->array[i]); + printf(")"); + } + else + printf("0 '()"); + } + else + { + printf("(path '%s", node->paint == FZ_FILL ? "fill" : "eofill"); + } + + printf("\n"); + fz_debugpathnode(node); + + indent(level); + printf(")\n"); +} + +static void lisptext(fz_textnode *node, int level) +{ + int i; + + indent(level); + printf("(text %s [%g %g %g %g]\n", node->font->name, + node->trm.a, node->trm.b, node->trm.c, node->trm.d); + + for (i = 0; i < node->len; i++) + { + indent(level + 1); + if (node->els[i].cid >= 32 && node->els[i].cid < 128) + printf("(cid '%c' %g %g)\n", node->els[i].cid, node->els[i].x, node->els[i].y); + else + printf("(cid <%04x> %g %g)\n", node->els[i].cid, node->els[i].x, node->els[i].y); + } + + indent(level); + printf(")\n"); +} + +static void lispimage(fz_imagenode *node, int level) +{ + fz_image *image = node->image; + indent(level); + printf("(image %dx%d %d+%d)\n", image->w, image->h, image->n, image->a); +} + +static void lispshade(fz_shadenode *node, int level) +{ + indent(level); + printf("(shade)\n"); +} + +static void lispnode(fz_node *node, int level) +{ + if (!node) + { + indent(level); + printf("(nil)\n"); + return; + } + + switch (node->kind) + { + case FZ_NMETA: lispmeta((fz_metanode*)node, level); break; + case FZ_NOVER: lispover((fz_overnode*)node, level); break; + case FZ_NMASK: lispmask((fz_masknode*)node, level); break; + case FZ_NBLEND: lispblend((fz_blendnode*)node, level); break; + case FZ_NTRANSFORM: lisptransform((fz_transformnode*)node, level); break; + case FZ_NCOLOR: lispcolor((fz_colornode*)node, level); break; + case FZ_NPATH: lisppath((fz_pathnode*)node, level); break; + case FZ_NTEXT: lisptext((fz_textnode*)node, level); break; + case FZ_NIMAGE: lispimage((fz_imagenode*)node, level); break; + case FZ_NSHADE: lispshade((fz_shadenode*)node, level); break; + case FZ_NLINK: lisplink((fz_linknode*)node, level); break; + } +} + +void +fz_debugnode(fz_node *node) +{ + lispnode(node, 0); +} + +void +fz_debugtree(fz_tree *tree) +{ + lispnode(tree->root, 0); +} + diff --git a/base/node_misc1.c b/base/node_misc1.c new file mode 100644 index 00000000..c2d6e876 --- /dev/null +++ b/base/node_misc1.c @@ -0,0 +1,167 @@ +#include + +void fz_dropmetanode(fz_metanode* node); +void fz_droplinknode(fz_linknode* node); +void fz_droppathnode(fz_pathnode* node); +void fz_droptextnode(fz_textnode* node); +void fz_dropimagenode(fz_imagenode* node); +void fz_dropshadenode(fz_shadenode* node); + +fz_rect fz_boundtransformnode(fz_transformnode* node, fz_matrix ctm); +fz_rect fz_boundovernode(fz_overnode* node, fz_matrix ctm); +fz_rect fz_boundmasknode(fz_masknode* node, fz_matrix ctm); +fz_rect fz_boundblendnode(fz_blendnode* node, fz_matrix ctm); +fz_rect fz_boundcolornode(fz_colornode* node, fz_matrix ctm); +fz_rect fz_boundpathnode(fz_pathnode* node, fz_matrix ctm); +fz_rect fz_boundtextnode(fz_textnode* node, fz_matrix ctm); +fz_rect fz_boundimagenode(fz_imagenode* node, fz_matrix ctm); +fz_rect fz_boundshadenode(fz_shadenode* node, fz_matrix ctm); +fz_rect fz_boundlinknode(fz_linknode* node, fz_matrix ctm); +fz_rect fz_boundmetanode(fz_metanode* node, fz_matrix ctm); + +void +fz_initnode(fz_node *node, fz_nodekind kind) +{ + node->kind = kind; + node->parent = nil; + node->first = nil; + node->last = nil; + node->next = nil; +} + +void +fz_dropnode(fz_node *node) +{ + if (node->first) + fz_dropnode(node->first); + if (node->next) + fz_dropnode(node->next); + + switch (node->kind) + { + case FZ_NTRANSFORM: + case FZ_NOVER: + case FZ_NMASK: + case FZ_NBLEND: + case FZ_NCOLOR: + break; + case FZ_NPATH: + fz_droppathnode((fz_pathnode *) node); + break; + case FZ_NTEXT: + fz_droptextnode((fz_textnode *) node); + break; + case FZ_NIMAGE: + fz_dropimagenode((fz_imagenode *) node); + break; + case FZ_NSHADE: + fz_dropshadenode((fz_shadenode *) node); + break; + case FZ_NLINK: + fz_droplinknode((fz_linknode *) node); + break; + case FZ_NMETA: + fz_dropmetanode((fz_metanode *) node); + break; + } + + fz_free(node); +} + +fz_rect +fz_boundnode(fz_node *node, fz_matrix ctm) +{ + switch (node->kind) + { + case FZ_NTRANSFORM: + return fz_boundtransformnode((fz_transformnode *) node, ctm); + case FZ_NOVER: + return fz_boundovernode((fz_overnode *) node, ctm); + case FZ_NMASK: + return fz_boundmasknode((fz_masknode *) node, ctm); + case FZ_NBLEND: + return fz_boundblendnode((fz_blendnode *) node, ctm); + case FZ_NCOLOR: + return fz_boundcolornode((fz_colornode *) node, ctm); + case FZ_NPATH: + return fz_boundpathnode((fz_pathnode *) node, ctm); + case FZ_NTEXT: + return fz_boundtextnode((fz_textnode *) node, ctm); + case FZ_NIMAGE: + return fz_boundimagenode((fz_imagenode *) node, ctm); + case FZ_NSHADE: + return fz_boundshadenode((fz_shadenode *) node, ctm); + case FZ_NLINK: + return fz_boundlinknode((fz_linknode *) node, ctm); + case FZ_NMETA: + return fz_boundmetanode((fz_metanode *) node, ctm); + } + return fz_emptyrect; +} + +int +fz_istransformnode(fz_node *node) +{ + return node ? node->kind == FZ_NTRANSFORM : 0; +} + +int +fz_isovernode(fz_node *node) +{ + return node ? node->kind == FZ_NOVER : 0; +} + +int +fz_ismasknode(fz_node *node) +{ + return node ? node->kind == FZ_NMASK : 0; +} + +int +fz_isblendnode(fz_node *node) +{ + return node ? node->kind == FZ_NBLEND : 0; +} + +int +fz_iscolornode(fz_node *node) +{ + return node ? node->kind == FZ_NCOLOR : 0; +} + +int +fz_ispathnode(fz_node *node) +{ + return node ? node->kind == FZ_NPATH : 0; +} + +int +fz_istextnode(fz_node *node) +{ + return node ? node->kind == FZ_NTEXT : 0; +} + +int +fz_isimagenode(fz_node *node) +{ + return node ? node->kind == FZ_NIMAGE : 0; +} + +int +fz_isshadenode(fz_node *node) +{ + return node ? node->kind == FZ_NSHADE : 0; +} + +int +fz_islinknode(fz_node *node) +{ + return node ? node->kind == FZ_NLINK : 0; +} + +int +fz_ismetanode(fz_node *node) +{ + return node ? node->kind == FZ_NMETA : 0; +} + diff --git a/base/node_misc2.c b/base/node_misc2.c new file mode 100644 index 00000000..f21ebf36 --- /dev/null +++ b/base/node_misc2.c @@ -0,0 +1,338 @@ +#include + +/* + * Over + */ + +fz_error * +fz_newovernode(fz_node **nodep) +{ + fz_node *node; + + node = *nodep = fz_malloc(sizeof (fz_overnode)); + if (!node) + return fz_outofmem; + + fz_initnode(node, FZ_NOVER); + + return nil; +} + +fz_rect +fz_boundovernode(fz_overnode *node, fz_matrix ctm) +{ + fz_node *child; + fz_rect bbox; + fz_rect temp; + + child = node->super.first; + if (!child) + return fz_emptyrect; + + bbox = fz_boundnode(child, ctm); + + child = child->next; + while (child) + { + temp = fz_boundnode(child, ctm); + bbox = fz_mergerects(temp, bbox); + child = child->next; + } + + return bbox; +} + +/* + * Mask + */ + +fz_error * +fz_newmasknode(fz_node **nodep) +{ + fz_node *node; + + node = *nodep = fz_malloc(sizeof (fz_masknode)); + if (!node) + return fz_outofmem; + + fz_initnode(node, FZ_NMASK); + + return nil; +} + +fz_rect +fz_boundmasknode(fz_masknode *node, fz_matrix ctm) +{ + fz_node *shape; + fz_node *color; + fz_rect one, two; + + shape = node->super.first; + color = shape->next; + + one = fz_boundnode(shape, ctm); + two = fz_boundnode(color, ctm); + return fz_intersectrects(one, two); +} + +/* + * Blend + */ + +fz_error * +fz_newblendnode(fz_node **nodep, fz_colorspace *cs, fz_blendkind b, int k, int i) +{ + fz_blendnode *node; + + node = fz_malloc(sizeof (fz_blendnode)); + if (!node) + return fz_outofmem; + *nodep = (fz_node*)node; + + fz_initnode((fz_node*)node, FZ_NBLEND); + node->cs = fz_keepcolorspace(cs); + node->mode = b; + node->knockout = k; + node->isolated = i; + + return nil; +} + +fz_rect +fz_boundblendnode(fz_blendnode *node, fz_matrix ctm) +{ + fz_node *child; + fz_rect bbox; + fz_rect temp; + + child = node->super.first; + if (!child) + return fz_emptyrect; + + bbox = fz_boundnode(child, ctm); + + child = child->next; + while (child) + { + temp = fz_boundnode(child, ctm); + bbox = fz_mergerects(temp, bbox); + child = child->next; + } + + return bbox; +} + +void +fz_dropblendnode(fz_blendnode *node) +{ + fz_dropcolorspace(node->cs); +} + +/* + * Transform + */ + +fz_error * +fz_newtransformnode(fz_node **nodep, fz_matrix m) +{ + fz_transformnode *node; + + node = fz_malloc(sizeof (fz_transformnode)); + if (!node) + return fz_outofmem; + *nodep = (fz_node*)node; + + fz_initnode((fz_node*)node, FZ_NTRANSFORM); + node->m = m; + + return nil; +} + +fz_rect +fz_boundtransformnode(fz_transformnode *node, fz_matrix ctm) +{ + if (!node->super.first) + return fz_emptyrect; + return fz_boundnode(node->super.first, fz_concat(node->m, ctm)); +} + +/* + * Meta info + */ + +fz_error * +fz_newmetanode(fz_node **nodep, fz_obj *name, fz_obj *dict) +{ + fz_metanode *node; + + node = fz_malloc(sizeof (fz_metanode)); + if (!node) + return fz_outofmem; + *nodep = (fz_node*)node; + + fz_initnode((fz_node*)node, FZ_NMETA); + node->name = nil; + node->dict = nil; + + if (name) + node->name = fz_keepobj(name); + if (dict) + node->dict = fz_keepobj(dict); + + return nil; +} + +void +fz_dropmetanode(fz_metanode *node) +{ + if (node->name) + fz_dropobj(node->name); + if (node->dict) + fz_dropobj(node->dict); +} + +fz_rect +fz_boundmetanode(fz_metanode *node, fz_matrix ctm) +{ + if (!node->super.first) + return fz_emptyrect; + return fz_boundnode(node->super.first, ctm); +} + +/* + * Link to tree + */ + +fz_error * +fz_newlinknode(fz_node **nodep, fz_tree *subtree) +{ + fz_linknode *node; + + node = fz_malloc(sizeof (fz_linknode)); + if (!node) + return fz_outofmem; + *nodep = (fz_node*)node; + + fz_initnode((fz_node*)node, FZ_NLINK); + node->tree = fz_keeptree(subtree); + + return nil; +} + +void +fz_droplinknode(fz_linknode *node) +{ + fz_droptree(node->tree); +} + +fz_rect +fz_boundlinknode(fz_linknode *node, fz_matrix ctm) +{ + return fz_boundtree(node->tree, ctm); +} + +/* + * Solid color + */ + +fz_error * +fz_newcolornode(fz_node **nodep, fz_colorspace *cs, int n, float *v) +{ + fz_colornode *node; + int i; + + node = fz_malloc(sizeof(fz_colornode) + sizeof(float) * n); + if (!node) + return fz_outofmem; + *nodep = (fz_node*)node; + + fz_initnode((fz_node*)node, FZ_NCOLOR); + node->cs = fz_keepcolorspace(cs); + node->n = n; + for (i = 0; i < n; i++) + node->samples[i] = v[i]; + + return nil; +} + +fz_rect +fz_boundcolornode(fz_colornode *node, fz_matrix ctm) +{ + return fz_infiniterect; +} + +void +fz_dropcolornode(fz_colornode *node) +{ + fz_dropcolorspace(node->cs); +} + +/* + * Image node + */ + +fz_error * +fz_newimagenode(fz_node **nodep, fz_image *image) +{ + fz_imagenode *node; + + node = fz_malloc(sizeof (fz_imagenode)); + if (!node) + return fz_outofmem; + *nodep = (fz_node*)node; + + fz_initnode((fz_node*)node, FZ_NIMAGE); + node->image = fz_keepimage(image); + + return nil; +} + +void +fz_dropimagenode(fz_imagenode *node) +{ + fz_dropimage(node->image); +} + +fz_rect +fz_boundimagenode(fz_imagenode *node, fz_matrix ctm) +{ + fz_rect bbox; + bbox.min.x = 0; + bbox.min.y = 0; + bbox.max.x = 1; + bbox.max.y = 1; + return fz_transformaabb(ctm, bbox); +} + +/* + * Shade node + */ + +fz_error * +fz_newshadenode(fz_node **nodep, fz_shade *shade) +{ + fz_shadenode *node; + + node = fz_malloc(sizeof (fz_shadenode)); + if (!node) + return fz_outofmem; + *nodep = (fz_node*)node; + + fz_initnode((fz_node*)node, FZ_NSHADE); + node->shade = fz_keepshade(shade); + + return nil; +} + +void +fz_dropshadenode(fz_shadenode *node) +{ + fz_dropshade(node->shade); +} + +fz_rect +fz_boundshadenode(fz_shadenode *node, fz_matrix ctm) +{ + return fz_boundshade(node->shade, ctm); +} + diff --git a/base/node_optimize.c b/base/node_optimize.c new file mode 100644 index 00000000..d92aa812 --- /dev/null +++ b/base/node_optimize.c @@ -0,0 +1,310 @@ +#include + +/* + * Remove (mask ... white) until we get something not white + */ + +static int iswhitenode(fz_colornode *node) +{ + if (!strcmp(node->cs->name, "DeviceGray")) + return fabs(node->samples[0] - 1.0) < FLT_EPSILON; + if (!strcmp(node->cs->name, "DeviceRGB")) + return fabs(node->samples[0] - 1.0) < FLT_EPSILON && + fabs(node->samples[1] - 1.0) < FLT_EPSILON && + fabs(node->samples[2] - 1.0) < FLT_EPSILON; + if (!strcmp(node->cs->name, "DeviceCMYK")) + return fabs(node->samples[0]) < FLT_EPSILON && + fabs(node->samples[1]) < FLT_EPSILON && + fabs(node->samples[2]) < FLT_EPSILON && + fabs(node->samples[3]) < FLT_EPSILON; + return 0; +} + +static int cleanwhite(fz_node *node) +{ + fz_node *current; + fz_node *next; + fz_node *shape; + fz_node *color; + + for (current = node->first; current; current = next) + { + next = current->next; + + if (fz_islinknode(current)) + return 1; + else if (fz_isimagenode(current)) + return 1; + else if (fz_isshadenode(current)) + return 1; + else if (fz_iscolornode(current)) + { + if (!iswhitenode((fz_colornode*)current)) + return 1; + } + + else if (fz_ismasknode(current)) + { + shape = current->first; + color = shape->next; + if (fz_iscolornode(color)) + { + if (iswhitenode((fz_colornode*)color)) + fz_removenode(current); + else + return 1; + } + else + { + if (cleanwhite(current)) + return 1; + } + } + + else + { + if (cleanwhite(current)) + return 1; + } + } + + return 0; +} + +/* + * Remove useless overs that only have one child. + */ + +static void cleanovers(fz_node *node) +{ + fz_node *prev; + fz_node *next; + fz_node *current; + fz_node *child; + + prev = nil; + for (current = node->first; current; current = next) + { + next = current->next; + + if (fz_isovernode(current)) + { + if (current->first == current->last) + { + child = current->first; + fz_removenode(current); + if (child) + { + if (prev) + fz_insertnodeafter(prev, child); + else + fz_insertnodefirst(node, child); + } + current = child; + } + } + + if (current) + prev = current; + } + + for (current = node->first; current; current = current->next) + cleanovers(current); +} + +/* + * Remove rectangular clip-masks whose contents fit... + */ + +static int getrect(fz_pathnode *path, fz_rect *bboxp) +{ + float x, y, w, h; + + /* move x y, line x+w y, line x+w y+h, line x y+h, close */ + + if (path->len != 13) + return 0; + + if (path->els[0].k != FZ_MOVETO) return 0; + x = path->els[1].v; + y = path->els[2].v; + + if (path->els[3].k != FZ_LINETO) return 0; + w = path->els[4].v - x; + if (path->els[5].v != y) return 0; + + if (path->els[6].k != FZ_LINETO) return 0; + if (path->els[7].v != x + w) return 0; + h = path->els[8].v - y; + + if (path->els[9].k != FZ_LINETO) return 0; + if (path->els[10].v != x) return 0; + if (path->els[11].v != y + h) return 0; + + if (path->els[12].k != FZ_CLOSEPATH) return 0; + + bboxp->min.x = MIN(x, x + w); + bboxp->min.y = MIN(y, y + h); + bboxp->max.x = MAX(x, x + w); + bboxp->max.y = MAX(y, y + h); + + return 1; +} + +static int fitsinside(fz_node *node, fz_rect clip) +{ + fz_rect bbox; + bbox = fz_boundnode(node, fz_identity()); + if (fz_isinfiniterect(bbox)) return 0; + if (fz_isemptyrect(bbox)) return 1; + if (bbox.min.x < clip.min.x) return 0; + if (bbox.max.x > clip.max.x) return 0; + if (bbox.min.y < clip.min.y) return 0; + if (bbox.max.y > clip.max.y) return 0; + return 1; +} + +static void cleanmasks(fz_node *node) +{ + fz_node *prev; + fz_node *current; + fz_node *shape; + fz_node *color; + fz_rect bbox; + + for (current = node->first; current; current = current->next) + cleanmasks(current); + + prev = nil; + for (current = node->first; current; current = current->next) + { +retry: + if (fz_ismasknode(current)) + { + shape = current->first; + color = shape->next; + + if (color == nil) + { + fz_removenode(current); + prev = nil; + current = node->first; + goto retry; + } + + if (fz_ispathnode(shape)) + { + if (getrect((fz_pathnode*)shape, &bbox)) + { + if (fitsinside(color, bbox)) + { + fz_removenode(current); + if (prev) + fz_insertnodeafter(prev, color); + else + fz_insertnodefirst(node, color); + current = color; + goto retry; + } + } + } + } + + prev = current; + } +} + +/* + * Turn 1x1 images into rectangle fills + */ + +static fz_error *clean1x1(fz_node *node) +{ + fz_error *error; + fz_node *current; + fz_node *color; + fz_pathnode *rect; + fz_node *mask; + fz_image *image; + fz_pixmap *pix; + float v[FZ_MAXCOLORS]; + int i; + + for (current = node->first; current; current = current->next) + { + if (fz_isimagenode(current)) + { + image = ((fz_imagenode*)current)->image; + if (image->w == 1 && image->h == 1) + { + error = fz_newpathnode(&rect); + fz_moveto(rect, 0, 0); + fz_lineto(rect, 1, 0); + fz_lineto(rect, 1, 1); + fz_lineto(rect, 0, 1); + fz_closepath(rect); + fz_endpath(rect, FZ_FILL, nil, nil); + + if (image->cs) + { + error = fz_newpixmap(&pix, 0, 0, 1, 1, image->n + 1); + if (error) + return error; + + error = image->loadtile(image, pix); + if (error) + return error; + + for (i = 0; i < image->n; i++) + v[i] = pix->samples[i + 1] / 255.0; + + fz_droppixmap(pix); + + error = fz_newcolornode(&color, image->cs, image->n, v); + if (error) + return error; + error = fz_newmasknode(&mask); + if (error) + return error; + + fz_insertnodeafter(current, mask); + fz_insertnodelast(mask, (fz_node*)rect); + fz_insertnodelast(mask, color); + fz_removenode(current); + current = mask; + } + + else + { + /* pray that the 1x1 image mask is all opaque */ + fz_insertnodeafter(current, (fz_node*)rect); + fz_removenode(current); + current = (fz_node*)rect; + } + } + } + + error = clean1x1(current); + if (error) + return error; + } + + return nil; +} + +/* + * + */ + +fz_error * +fz_optimizetree(fz_tree *tree) +{ + if (getenv("DONTOPT")) + return nil; + cleanwhite(tree->root); + cleanovers(tree->root); + cleanmasks(tree->root); + clean1x1(tree->root); + return nil; +} + diff --git a/base/node_path.c b/base/node_path.c new file mode 100644 index 00000000..24b4dfc8 --- /dev/null +++ b/base/node_path.c @@ -0,0 +1,305 @@ +#include + +fz_error * +fz_newpathnode(fz_pathnode **pathp) +{ + fz_pathnode *path; + + path = *pathp = fz_malloc(sizeof(fz_pathnode)); + if (!path) + return fz_outofmem; + + fz_initnode((fz_node*)path, FZ_NPATH); + + path->paint = FZ_FILL; + path->linecap = 0; + path->linejoin = 0; + path->linewidth = 1.0; + path->miterlimit = 10.0; + path->dash = nil; + path->len = 0; + path->cap = 0; + path->els = nil; + + return nil; +} + +fz_error * +fz_clonepathnode(fz_pathnode **pathp, fz_pathnode *oldpath) +{ + fz_pathnode *path; + + path = *pathp = fz_malloc(sizeof(fz_pathnode)); + if (!path) + return fz_outofmem; + + fz_initnode((fz_node*)path, FZ_NPATH); + + path->paint = FZ_FILL; + path->linecap = 0; + path->linejoin = 0; + path->linewidth = 1.0; + path->miterlimit = 10.0; + path->dash = nil; + path->len = oldpath->len; + path->cap = oldpath->len; + + path->els = fz_malloc(sizeof (fz_pathel) * path->len); + if (!path->els) { + fz_free(path); + return fz_outofmem; + } + memcpy(path->els, oldpath->els, sizeof(fz_pathel) * path->len); + + return nil; +} + +void +fz_droppathnode(fz_pathnode *node) +{ + fz_free(node->dash); + fz_free(node->els); +} + +static fz_error * +growpath(fz_pathnode *path, int n) +{ + int newcap; + fz_pathel *newels; + + while (path->len + n > path->cap) + { + newcap = path->cap + 36; + newels = fz_realloc(path->els, sizeof (fz_pathel) * newcap); + if (!newels) + return fz_outofmem; + path->cap = newcap; + path->els = newels; + } + + return nil; +} + +fz_error * +fz_moveto(fz_pathnode *path, float x, float y) +{ + if (growpath(path, 3) != nil) + return fz_outofmem; + path->els[path->len++].k = FZ_MOVETO; + path->els[path->len++].v = x; + path->els[path->len++].v = y; + return nil; +} + +fz_error * +fz_lineto(fz_pathnode *path, float x, float y) +{ + if (growpath(path, 3) != nil) + return fz_outofmem; + path->els[path->len++].k = FZ_LINETO; + path->els[path->len++].v = x; + path->els[path->len++].v = y; + return nil; +} + +fz_error * +fz_curveto(fz_pathnode *path, + float x1, float y1, + float x2, float y2, + float x3, float y3) +{ + if (growpath(path, 7) != nil) + return fz_outofmem; + path->els[path->len++].k = FZ_CURVETO; + path->els[path->len++].v = x1; + path->els[path->len++].v = y1; + path->els[path->len++].v = x2; + path->els[path->len++].v = y2; + path->els[path->len++].v = x3; + path->els[path->len++].v = y3; + return nil; +} + +fz_error * +fz_curvetov(fz_pathnode *path, float x2, float y2, float x3, float y3) +{ + float x1 = path->els[path->len-2].v; + float y1 = path->els[path->len-1].v; + return fz_curveto(path, x1, y1, x2, y2, x3, y3); +} + +fz_error * +fz_curvetoy(fz_pathnode *path, float x1, float y1, float x3, float y3) +{ + return fz_curveto(path, x1, y1, x3, y3, x3, y3); +} + +fz_error * +fz_closepath(fz_pathnode *path) +{ + if (growpath(path, 1) != nil) + return fz_outofmem; + path->els[path->len++].k = FZ_CLOSEPATH; + return nil; +} + +fz_error * +fz_endpath(fz_pathnode *path, fz_pathkind paint, fz_stroke *stroke, fz_dash *dash) +{ + fz_pathel *newels; + + newels = fz_realloc(path->els, path->len * sizeof(fz_pathel)); + if (!newels) + return fz_outofmem; + path->els = newels; + + path->paint = paint; + path->dash = dash; + if (stroke) + { + path->linecap = stroke->linecap; + path->linejoin = stroke->linejoin; + path->linewidth = stroke->linewidth; + path->miterlimit = stroke->miterlimit; + } + + if (path->linewidth < 0.01) + path->linewidth = 0.01; + + return nil; +} + +static inline fz_rect boundexpand(fz_rect r, fz_point p) +{ + if (p.x < r.min.x) r.min.x = p.x; + if (p.y < r.min.y) r.min.y = p.y; + if (p.x > r.max.x) r.max.x = p.x; + if (p.y > r.max.y) r.max.y = p.y; + return r; +} + +fz_rect +fz_boundpathnode(fz_pathnode *path, fz_matrix ctm) +{ + fz_point p; + fz_rect r = fz_emptyrect; + int i = 0; + + if (path->len) + { + p.x = path->els[1].v; + p.y = path->els[2].v; + p = fz_transformpoint(ctm, p); + r.min.x = r.max.x = p.x; + r.min.y = r.max.y = p.y; + } + + while (i < path->len) + { + switch (path->els[i++].k) + { + case FZ_CURVETO: + p.x = path->els[i++].v; + p.y = path->els[i++].v; + r = boundexpand(r, fz_transformpoint(ctm, p)); + p.x = path->els[i++].v; + p.y = path->els[i++].v; + r = boundexpand(r, fz_transformpoint(ctm, p)); + case FZ_MOVETO: + case FZ_LINETO: + p.x = path->els[i++].v; + p.y = path->els[i++].v; + r = boundexpand(r, fz_transformpoint(ctm, p)); + break; + case FZ_CLOSEPATH: + break; + } + } + + if (path->paint == FZ_STROKE) + { + float miterlength = sin(path->miterlimit / 2.0); + float linewidth = path->linewidth; + float expand = MAX(miterlength, linewidth) / 2.0; + r.min.x -= expand; + r.min.y -= expand; + r.max.x += expand; + r.max.y += expand; + } + + return r; +} + +void +fz_debugpathnode(fz_pathnode *path) +{ + float x, y; + int i = 0; + while (i < path->len) + { + switch (path->els[i++].k) + { + case FZ_MOVETO: + x = path->els[i++].v; + y = path->els[i++].v; + printf("%g %g m\n", x, y); + break; + case FZ_LINETO: + x = path->els[i++].v; + y = path->els[i++].v; + printf("%g %g l\n", x, y); + break; + case FZ_CURVETO: + x = path->els[i++].v; + y = path->els[i++].v; + printf("%g %g ", x, y); + x = path->els[i++].v; + y = path->els[i++].v; + printf("%g %g ", x, y); + x = path->els[i++].v; + y = path->els[i++].v; + printf("%g %g c\n", x, y); + break; + case FZ_CLOSEPATH: + printf("h\n"); + } + } + + switch (path->paint) + { + case FZ_STROKE: + printf("S\n"); + break; + case FZ_FILL: + printf("f\n"); + break; + case FZ_EOFILL: + printf("f*\n"); + break; + } +} + +fz_error * +fz_newdash(fz_dash **dashp, float phase, int len, float *array) +{ + fz_dash *dash; + int i; + + dash = *dashp = fz_malloc(sizeof(fz_dash) + sizeof(float) * len); + if (!dash) + return fz_outofmem; + + dash->len = len; + dash->phase = phase; + for (i = 0; i < len; i++) + dash->array[i] = array[i]; + + return nil; +} + +void +fz_dropdash(fz_dash *dash) +{ + fz_free(dash); +} + diff --git a/base/node_text.c b/base/node_text.c new file mode 100644 index 00000000..d88e04ec --- /dev/null +++ b/base/node_text.c @@ -0,0 +1,141 @@ +#include + +fz_error * +fz_newtextnode(fz_textnode **textp, fz_font *font) +{ + fz_textnode *text; + + text = fz_malloc(sizeof(fz_textnode)); + if (!text) + return fz_outofmem; + + fz_initnode((fz_node*)text, FZ_NTEXT); + + text->font = fz_keepfont(font); + text->trm = fz_identity(); + text->len = 0; + text->cap = 0; + text->els = nil; + + *textp = text; + return nil; +} + +fz_error * +fz_clonetextnode(fz_textnode **textp, fz_textnode *oldtext) +{ + fz_textnode *text; + + text = *textp = fz_malloc(sizeof(fz_textnode)); + if (!text) + return fz_outofmem; + + fz_initnode((fz_node*)text, FZ_NTEXT); + + text->font = fz_keepfont(oldtext->font); + text->trm = oldtext->trm; + text->len = oldtext->len; + text->cap = oldtext->len; + text->els = nil; + + text->els = fz_malloc(sizeof(fz_textel) * text->len); + if (!text->els) + { + fz_dropfont(text->font); + fz_free(text); + return fz_outofmem; + } + + memcpy(text->els, oldtext->els, sizeof(fz_textel) * text->len); + + *textp = text; + return nil; +} + +void +fz_droptextnode(fz_textnode *text) +{ + fz_dropfont(text->font); + fz_free(text->els); +} + +fz_rect +fz_boundtextnode(fz_textnode *text, fz_matrix ctm) +{ + fz_matrix trm; + fz_rect bbox; + fz_rect fbox; + int i; + + if (text->len == 0) + return fz_emptyrect; + + /* find bbox of glyph origins in ctm space */ + + bbox.min.x = bbox.max.x = text->els[0].x; + bbox.min.y = bbox.max.y = text->els[0].y; + + for (i = 1; i < text->len; i++) + { + bbox.min.x = MIN(bbox.min.x, text->els[i].x); + bbox.min.y = MIN(bbox.min.y, text->els[i].y); + bbox.max.x = MAX(bbox.max.x, text->els[i].x); + bbox.max.y = MAX(bbox.max.y, text->els[i].y); + } + + bbox = fz_transformaabb(ctm, bbox); + + /* find bbox of font in trm * ctm space */ + + trm = fz_concat(text->trm, ctm); + trm.e = 0; + trm.f = 0; + + fbox.min.x = text->font->bbox.min.x * 0.001; + fbox.min.y = text->font->bbox.min.y * 0.001; + fbox.max.x = text->font->bbox.max.x * 0.001; + fbox.max.y = text->font->bbox.max.y * 0.001; + + fbox = fz_transformaabb(trm, fbox); + + /* expand glyph origin bbox by font bbox */ + + bbox.min.x += fbox.min.x; + bbox.min.y += fbox.min.y; + bbox.max.x += fbox.max.x; + bbox.max.y += fbox.max.y; + + return bbox; +} + +static fz_error * +growtext(fz_textnode *text, int n) +{ + int newcap; + fz_textel *newels; + + while (text->len + n > text->cap) + { + newcap = text->cap + 36; + newels = fz_realloc(text->els, sizeof (fz_textel) * newcap); + if (!newels) + return fz_outofmem; + text->cap = newcap; + text->els = newels; + } + + return nil; +} + +fz_error * +fz_addtext(fz_textnode *text, int cid, float x, float y) +{ + if (growtext(text, 1) != nil) + return fz_outofmem; + text->els[text->len].cid = cid; + text->els[text->len].x = x; + text->els[text->len].y = y; + text->len++; + return nil; +} + diff --git a/base/node_tree.c b/base/node_tree.c new file mode 100644 index 00000000..f6874711 --- /dev/null +++ b/base/node_tree.c @@ -0,0 +1,107 @@ +#include + +fz_error * +fz_newtree(fz_tree **treep) +{ + fz_tree *tree; + + tree = *treep = fz_malloc(sizeof (fz_tree)); + if (!tree) + return fz_outofmem; + + tree->refs = 1; + tree->root = nil; + tree->head = nil; + + return nil; +} + +fz_tree * +fz_keeptree(fz_tree *tree) +{ + tree->refs ++; + return tree; +} + +void +fz_droptree(fz_tree *tree) +{ + if (--tree->refs == 0) + { + if (tree->root) + fz_dropnode(tree->root); + fz_free(tree); + } +} + +fz_rect +fz_boundtree(fz_tree *tree, fz_matrix ctm) +{ + if (tree->root) + return fz_boundnode(tree->root, ctm); + return fz_emptyrect; +} + +void +fz_insertnodefirst(fz_node *parent, fz_node *child) +{ + child->parent = parent; + child->next = parent->first; + parent->first = child; + if (!parent->last) + parent->last = child; +} + +void +fz_insertnodelast(fz_node *parent, fz_node *child) +{ + child->parent = parent; + if (!parent->first) + parent->first = child; + else + parent->last->next = child; + parent->last = child; +} + +void +fz_insertnodeafter(fz_node *prev, fz_node *child) +{ + fz_node *parent = prev->parent; + child->parent = parent; + if (parent->last == prev) + parent->last = child; + child->next = prev->next; + prev->next = child; +} + +void +fz_removenode(fz_node *child) +{ + fz_node *parent = child->parent; + fz_node *prev; + fz_node *node; + + if (parent->first == child) + { + parent->first = child->next; + if (parent->last == child) + parent->last = nil; + return; + } + + prev = parent->first; + node = prev->next; + + while (node) + { + if (node == child) + { + prev->next = child->next; + } + prev = node; + node = node->next; + } + + parent->last = prev; +} + diff --git a/base/rect.c b/base/rect.c deleted file mode 100644 index 2efb11f7..00000000 --- a/base/rect.c +++ /dev/null @@ -1,75 +0,0 @@ -#include - -fz_rect fz_infiniterect = { { 1, 1}, {-1, -1} }; -fz_rect fz_emptyrect = { { 0, 0}, {0, 0} }; - -static fz_irect infinite = { { 1, 1}, {-1, -1} }; -static fz_irect empty = { { 0, 0}, {0, 0} }; - -fz_irect -fz_roundrect(fz_rect f) -{ - fz_irect i; - i.min.x = fz_floor(f.min.x); - i.min.y = fz_floor(f.min.y); - i.max.x = fz_ceil(f.max.x); - i.max.y = fz_ceil(f.max.y); - return i; -} - -fz_rect -fz_intersectrects(fz_rect a, fz_rect b) -{ - fz_rect r; - if (fz_isinfiniterect(a)) return b; - if (fz_isinfiniterect(b)) return a; - r.min.x = MAX(a.min.x, b.min.x); - r.min.y = MAX(a.min.y, b.min.y); - r.max.x = MIN(a.max.x, b.max.x); - r.max.y = MIN(a.max.y, b.max.y); - return (r.max.x < r.min.x || r.max.y < r.min.y) ? fz_emptyrect : r; -} - -fz_rect -fz_mergerects(fz_rect a, fz_rect b) -{ - fz_rect r; - if (fz_isinfiniterect(a) || fz_isinfiniterect(b)) - return fz_infiniterect; - if (fz_isemptyrect(a)) return b; - if (fz_isemptyrect(b)) return a; - r.min.x = MIN(a.min.x, b.min.x); - r.min.y = MIN(a.min.y, b.min.y); - r.max.x = MAX(a.max.x, b.max.x); - r.max.y = MAX(a.max.y, b.max.y); - return r; -} - -fz_irect -fz_intersectirects(fz_irect a, fz_irect b) -{ - fz_irect r; - if (fz_isinfiniterect(a)) return b; - if (fz_isinfiniterect(b)) return a; - r.min.x = MAX(a.min.x, b.min.x); - r.min.y = MAX(a.min.y, b.min.y); - r.max.x = MIN(a.max.x, b.max.x); - r.max.y = MIN(a.max.y, b.max.y); - return (r.max.x < r.min.x || r.max.y < r.min.y) ? empty : r; -} - -fz_irect -fz_mergeirects(fz_irect a, fz_irect b) -{ - fz_irect r; - if (fz_isinfiniterect(a) || fz_isinfiniterect(b)) - return infinite; - if (fz_isemptyrect(a)) return b; - if (fz_isemptyrect(b)) return a; - r.min.x = MIN(a.min.x, b.min.x); - r.min.y = MIN(a.min.y, b.min.y); - r.max.x = MAX(a.max.x, b.max.x); - r.max.y = MAX(a.max.y, b.max.y); - return r; -} - diff --git a/base/res_cmap.c b/base/res_cmap.c new file mode 100644 index 00000000..577ba7c0 --- /dev/null +++ b/base/res_cmap.c @@ -0,0 +1,466 @@ +#include + +typedef struct fz_range_s fz_range; + +enum { MAXCODESPACE = 10 }; +enum { SINGLE, RANGE, LOOKUP }; + +struct fz_range_s +{ + int low; + int high; + int flag; + int offset; +}; + +struct fz_cmap_s +{ + int refs; + char cmapname[32]; + + char usecmapname[32]; + fz_cmap *usecmap; + + int wmode; + + int ncspace; + struct { + int n; + unsigned char lo[4]; + unsigned char hi[4]; + } cspace[MAXCODESPACE]; + + int rlen, rcap; + fz_range *ranges; + + int tlen, tcap; + int *lookup; +}; + +fz_error * +fz_newcmap(fz_cmap **cmapp) +{ + fz_cmap *cmap; + + cmap = *cmapp = fz_malloc(sizeof(fz_cmap)); + if (!cmap) + return fz_outofmem; + + cmap->refs = 1; + strcpy(cmap->cmapname, ""); + + strcpy(cmap->usecmapname, ""); + cmap->usecmap = nil; + + cmap->wmode = 0; + + cmap->ncspace = 0; + + cmap->rlen = 0; + cmap->rcap = 0; + cmap->ranges = nil; + + cmap->tlen = 0; + cmap->tcap = 0; + cmap->lookup = nil; + + return nil; +} + +fz_cmap * +fz_keepcmap(fz_cmap *cmap) +{ + cmap->refs ++; + return cmap; +} + +void +fz_dropcmap(fz_cmap *cmap) +{ + if (--cmap->refs == 0) + { + if (cmap->usecmap) + fz_dropcmap(cmap->usecmap); + fz_free(cmap->ranges); + fz_free(cmap->lookup); + fz_free(cmap); + } +} + +char * +fz_getcmapname(fz_cmap *cmap) +{ + if (cmap->cmapname[0]) + return cmap->cmapname; + return nil; +} + +void +fz_setcmapname(fz_cmap *cmap, char *cmapname) +{ + strlcpy(cmap->cmapname, cmapname, sizeof cmap->cmapname); +} + +char * +fz_getusecmapname(fz_cmap *cmap) +{ + if (cmap->usecmapname[0]) + return cmap->usecmapname; + return nil; +} + +void +fz_setusecmapname(fz_cmap *cmap, char *usecmap) +{ + strlcpy(cmap->usecmapname, usecmap, sizeof cmap->usecmapname); +} + +fz_cmap * +fz_getusecmap(fz_cmap *cmap) +{ + return cmap->usecmap; +} + +void +fz_setusecmap(fz_cmap *cmap, fz_cmap *usecmap) +{ + int i; + + if (cmap->usecmap) + fz_dropcmap(cmap->usecmap); + cmap->usecmap = fz_keepcmap(usecmap); + + if (cmap->ncspace == 0) + { + cmap->ncspace = usecmap->ncspace; + for (i = 0; i < usecmap->ncspace; i++) + cmap->cspace[i] = usecmap->cspace[i]; + } +} + +void +fz_setwmode(fz_cmap *cmap, int wmode) +{ + cmap->wmode = wmode; +} + +int +fz_getwmode(fz_cmap *cmap) +{ + return cmap->wmode; +} + +fz_error * +fz_addcodespacerange(fz_cmap *cmap, unsigned lo, unsigned hi, int n) +{ + int i; + + if (cmap->ncspace + 1 == MAXCODESPACE) + return fz_throw("rangelimit: too many code space ranges"); + + cmap->cspace[cmap->ncspace].n = n; + + for (i = 0; i < n; i++) + { + int o = (n - i - 1) * 8; + cmap->cspace[cmap->ncspace].lo[i] = (lo >> o) & 0xFF; + cmap->cspace[cmap->ncspace].hi[i] = (hi >> o) & 0xFF; + } + + cmap->ncspace ++; + + return nil; +} + +fz_error * +fz_addcidrange(fz_cmap *cmap, int low, int high, int offset) +{ + if (cmap->rlen + 1 > cmap->rcap) + { + fz_range *newranges; + int newcap = cmap->rcap == 0 ? 256 : cmap->rcap * 2; + newranges = fz_realloc(cmap->ranges, newcap * sizeof(fz_range)); + if (!newranges) + return fz_outofmem; + cmap->rcap = newcap; + cmap->ranges = newranges; + } + + cmap->ranges[cmap->rlen].low = low; + cmap->ranges[cmap->rlen].high = high; + cmap->ranges[cmap->rlen].flag = high - low == 0 ? SINGLE : RANGE; + cmap->ranges[cmap->rlen].offset = offset; + cmap->rlen ++; + + return nil; +} + +static fz_error * +addlookup(fz_cmap *cmap, int value) +{ + if (cmap->tlen + 1 > cmap->tcap) + { + int newcap = cmap->tcap == 0 ? 256 : cmap->tcap * 2; + int *newlookup = fz_realloc(cmap->lookup, newcap * sizeof(int)); + if (!newlookup) + return fz_outofmem; + cmap->tcap = newcap; + cmap->lookup = newlookup; + } + + cmap->lookup[cmap->tlen++] = value; + + return nil; +} + +static int compare(const void *va, const void *vb) +{ + return ((const fz_range*)va)->low - ((const fz_range*)vb)->low; +} + +fz_error * +fz_endcidrange(fz_cmap *cmap) +{ + fz_error *error; + fz_range *newranges; + int *newlookup; + fz_range *a; /* last written range on output */ + fz_range *b; /* current range examined on input */ + + qsort(cmap->ranges, cmap->rlen, sizeof(fz_range), compare); + + a = cmap->ranges; + b = cmap->ranges + 1; + + while (b < cmap->ranges + cmap->rlen) + { + /* input contiguous */ + if (a->high + 1 == b->low) + { + /* output contiguous */ + if (a->high - a->low + a->offset + 1 == b->offset) + { + /* SR -> R and SS -> R and RR -> R and RS -> R */ + if (a->flag == SINGLE || a->flag == RANGE) + { + a->flag = RANGE; + a->high = b->high; + } + + /* LS -> L */ + else if (a->flag == LOOKUP && b->flag == SINGLE) + { + a->high = b->high; + error = addlookup(cmap, b->offset); + if (error) + return error; + } + + /* LR -> LR */ + else if (a->flag == LOOKUP && b->flag == RANGE) + { + *(++a) = *b; + } + } + + /* output separated */ + else + { + /* SS -> L */ + if (a->flag == SINGLE && b->flag == SINGLE) + { + a->flag = LOOKUP; + a->high = b->high; + + error = addlookup(cmap, a->offset); + if (error) + return error; + + error = addlookup(cmap, b->offset); + if (error) + return error; + + a->offset = cmap->tlen - 2; + } + + /* LS -> L */ + else if (a->flag == LOOKUP && b->flag == SINGLE) + { + a->high = b->high; + error = addlookup(cmap, b->offset); + if (error) + return error; + } + + /* XX -> XX */ + else + { + *(++a) = *b; + } + } + } + + /* input separated: XX -> XX */ + else + { + *(++a) = *b; + } + + b ++; + } + + cmap->rlen = a - cmap->ranges + 1; + + assert(cmap->rlen > 0); + + newranges = fz_realloc(cmap->ranges, cmap->rlen * sizeof(fz_range)); + if (!newranges) + return fz_outofmem; + cmap->rcap = cmap->rlen; + cmap->ranges = newranges; + + if (cmap->tlen) + { + newlookup = fz_realloc(cmap->lookup, cmap->tlen * sizeof(int)); + if (!newlookup) + return fz_outofmem; + cmap->tcap = cmap->tlen; + cmap->lookup = newlookup; + } + + return nil; +} + +fz_error * +fz_setcidlookup(fz_cmap *cmap, int map[256]) +{ + int i; + + cmap->rlen = cmap->rcap = 1; + cmap->ranges = fz_malloc(sizeof (fz_range)); + if (!cmap->ranges) { + return fz_outofmem; + } + + cmap->tlen = cmap->tcap = 256; + cmap->lookup = fz_malloc(sizeof (int) * 256); + if (!cmap->lookup) { + fz_free(cmap->ranges); + return fz_outofmem; + } + + cmap->ranges[0].low = 0; + cmap->ranges[0].high = 255; + cmap->ranges[0].flag = LOOKUP; + cmap->ranges[0].offset = 0; + + for (i = 0; i < 256; i++) + cmap->lookup[i] = map[i]; + + return nil; +} + +int +fz_lookupcid(fz_cmap *cmap, int cpt) +{ + int l = 0; + int r = cmap->rlen - 1; + int m; + + while (l <= r) + { + m = (l + r) >> 1; + if (cpt < cmap->ranges[m].low) + r = m - 1; + else if (cpt > cmap->ranges[m].high) + l = m + 1; + else + { + int i = cpt - cmap->ranges[m].low + cmap->ranges[m].offset; + if (cmap->ranges[m].flag == LOOKUP) + return cmap->lookup[i]; + return i; + } + } + + if (cmap->usecmap) + return fz_lookupcid(cmap->usecmap, cpt); + + return -1; +} + +unsigned char * +fz_decodecpt(fz_cmap *cmap, unsigned char *buf, int *cpt) +{ + int i, k; + + for (k = 0; k < cmap->ncspace; k++) + { + unsigned char *lo = cmap->cspace[k].lo; + unsigned char *hi = cmap->cspace[k].hi; + int n = cmap->cspace[k].n; + int c = 0; + + for (i = 0; i < n; i++) + { + if (lo[i] <= buf[i] && buf[i] <= hi[i]) + c = (c << 8) | buf[i]; + else + break; + } + + if (i == n) { + *cpt = c; + return buf + n; + } + } + + *cpt = 0; + return buf + 1; +} + +void +fz_debugcmap(fz_cmap *cmap) +{ + int i, k; + + printf("cmap $%p /%s {\n", cmap, cmap->cmapname); + + if (cmap->usecmapname[0]) + printf(" usecmap /%s\n", cmap->usecmapname); + if (cmap->usecmap) + printf(" usecmap $%p\n", cmap->usecmap); + + printf(" wmode %d\n", cmap->wmode); + + printf(" codespaces {\n"); + for (i = 0; i < cmap->ncspace; i++) + { + printf(" <"); + for (k = 0; k < cmap->cspace[i].n; k++) + printf("%02x", cmap->cspace[i].lo[k]); + printf("> <"); + for (k = 0; k < cmap->cspace[i].n; k++) + printf("%02x", cmap->cspace[i].hi[k]); + printf(">\n"); + } + printf(" }\n"); + + printf(" ranges (%d,%d) {\n", cmap->rlen, cmap->tlen); + for (i = 0; i < cmap->rlen; i++) + { + fz_range *r = &cmap->ranges[i]; + printf(" <%04x> <%04x> ", r->low, r->high); + if (r->flag == LOOKUP) + { + printf("[ "); + for (k = 0; k < r->high - r->low + 1; k++) + printf("%d ", cmap->lookup[r->offset + k]); + printf("]\n"); + } + else + printf("%d\n", r->offset); + } + printf(" }\n}\n"); +} + diff --git a/base/res_colorspace.c b/base/res_colorspace.c new file mode 100644 index 00000000..65909bfe --- /dev/null +++ b/base/res_colorspace.c @@ -0,0 +1,89 @@ +#include + +void +fz_convertpixmap(fz_colorspace *srcs, fz_pixmap *src, fz_colorspace *dsts, fz_pixmap *dst) +{ + srcs->convpixmap(srcs, src, dsts, dst); +} + +void +fz_convertcolor(fz_colorspace *srcs, float *srcv, fz_colorspace *dsts, float *dstv) +{ + srcs->convcolor(srcs, srcv, dsts, dstv); +} + +fz_colorspace * +fz_keepcolorspace(fz_colorspace *cs) +{ + if (cs->refs < 0) + return cs; + cs->refs ++; + return cs; +} + +void +fz_dropcolorspace(fz_colorspace *cs) +{ + if (cs->refs < 0) + return; + if (--cs->refs == 0) + { + if (cs->drop) + cs->drop(cs); + fz_free(cs); + } +} + +void +fz_stdconvcolor(fz_colorspace *srcs, float *srcv, fz_colorspace *dsts, float *dstv) +{ + float xyz[3]; + int i; + + if (srcs != dsts) + { + srcs->toxyz(srcs, srcv, xyz); + dsts->fromxyz(dsts, xyz, dstv); + for (i = 0; i < dsts->n; i++) + dstv[i] = CLAMP(dstv[i], 0.0, 1.0); + } + else + { + for (i = 0; i < srcs->n; i++) + dstv[i] = srcv[i]; + } +} + +void +fz_stdconvpixmap(fz_colorspace *srcs, fz_pixmap *src, fz_colorspace *dsts, fz_pixmap *dst) +{ + float srcv[FZ_MAXCOLORS]; + float dstv[FZ_MAXCOLORS]; + int y, x, k; + + unsigned char *s = src->samples; + unsigned char *d = dst->samples; + + printf("convert pixmap from %s to %s\n", srcs->name, dsts->name); + + assert(src->w == dst->w && src->h == dst->h); + assert(src->n == srcs->n + 1); + assert(dst->n == dsts->n + 1); + + for (y = 0; y < src->h; y++) + { + for (x = 0; x < src->w; x++) + { + *d++ = *s++; + + for (k = 0; k < src->n - 1; k++) + srcv[k] = *s++ / 255.0; + + fz_convertcolor(srcs, srcv, dsts, dstv); + + for (k = 0; k < dst->n - 1; k++) + *d++ = dstv[k] * 255; + } + } +} + diff --git a/base/res_font.c b/base/res_font.c new file mode 100644 index 00000000..b7367ce1 --- /dev/null +++ b/base/res_font.c @@ -0,0 +1,269 @@ +#include + +void +fz_initfont(fz_font *font, char *name) +{ + font->refs = 1; + strlcpy(font->name, name, sizeof font->name); + + font->wmode = 0; + + font->bbox.min.x = 0; + font->bbox.min.y = 0; + font->bbox.max.x = 1000; + font->bbox.max.y = 1000; + + font->hmtxcap = 0; + font->vmtxcap = 0; + font->nhmtx = 0; + font->nvmtx = 0; + font->hmtx = nil; + font->vmtx = nil; + + font->dhmtx.lo = 0x0000; + font->dhmtx.hi = 0xFFFF; + font->dhmtx.w = 0; + + font->dvmtx.lo = 0x0000; + font->dvmtx.hi = 0xFFFF; + font->dvmtx.x = 0; + font->dvmtx.y = 880; + font->dvmtx.w = -1000; +} + +fz_font * +fz_keepfont(fz_font *font) +{ + font->refs ++; + return font; +} + +void +fz_dropfont(fz_font *font) +{ + if (--font->refs == 0) + { + if (font->drop) + font->drop(font); + fz_free(font->hmtx); + fz_free(font->vmtx); + fz_free(font); + } +} + +void +fz_setfontwmode(fz_font *font, int wmode) +{ + font->wmode = wmode; +} + +void +fz_setfontbbox(fz_font *font, int xmin, int ymin, int xmax, int ymax) +{ + font->bbox.min.x = xmin; + font->bbox.min.y = ymin; + font->bbox.max.x = xmax; + font->bbox.max.y = ymax; +} + +void +fz_setdefaulthmtx(fz_font *font, int w) +{ + font->dhmtx.w = w; +} + +void +fz_setdefaultvmtx(fz_font *font, int y, int w) +{ + font->dvmtx.y = y; + font->dvmtx.w = w; +} + +fz_error * +fz_addhmtx(fz_font *font, int lo, int hi, int w) +{ + int newcap; + fz_hmtx *newmtx; + + if (font->nhmtx + 1 >= font->hmtxcap) + { + newcap = font->hmtxcap + 16; + newmtx = fz_realloc(font->hmtx, sizeof(fz_hmtx) * newcap); + if (!newmtx) + return fz_outofmem; + font->hmtxcap = newcap; + font->hmtx = newmtx; + } + + font->hmtx[font->nhmtx].lo = lo; + font->hmtx[font->nhmtx].hi = hi; + font->hmtx[font->nhmtx].w = w; + font->nhmtx++; + + return nil; +} + +fz_error * +fz_addvmtx(fz_font *font, int lo, int hi, int x, int y, int w) +{ + int newcap; + fz_vmtx *newmtx; + + if (font->nvmtx + 1 >= font->vmtxcap) + { + newcap = font->vmtxcap + 16; + newmtx = fz_realloc(font->vmtx, sizeof(fz_vmtx) * newcap); + if (!newmtx) + return fz_outofmem; + font->vmtxcap = newcap; + font->vmtx = newmtx; + } + + font->vmtx[font->nvmtx].lo = lo; + font->vmtx[font->nvmtx].hi = hi; + font->vmtx[font->nvmtx].x = x; + font->vmtx[font->nvmtx].y = y; + font->vmtx[font->nvmtx].w = w; + font->nvmtx++; + + return nil; +} + +static int cmph(const void *a0, const void *b0) +{ + fz_hmtx *a = (fz_hmtx*)a0; + fz_hmtx *b = (fz_hmtx*)b0; + return a->lo - b->lo; +} + +static int cmpv(const void *a0, const void *b0) +{ + fz_vmtx *a = (fz_vmtx*)a0; + fz_vmtx *b = (fz_vmtx*)b0; + return a->lo - b->lo; +} + +fz_error * +fz_endhmtx(fz_font *font) +{ + fz_hmtx *newmtx; + + if (!font->hmtx) + return nil; + + qsort(font->hmtx, font->nhmtx, sizeof(fz_hmtx), cmph); + + newmtx = fz_realloc(font->hmtx, sizeof(fz_hmtx) * font->nhmtx); + if (!newmtx) + return fz_outofmem; + font->hmtxcap = font->nhmtx; + font->hmtx = newmtx; + + return nil; +} + +fz_error * +fz_endvmtx(fz_font *font) +{ + fz_vmtx *newmtx; + + if (!font->vmtx) + return nil; + + qsort(font->vmtx, font->nvmtx, sizeof(fz_vmtx), cmpv); + + newmtx = fz_realloc(font->vmtx, sizeof(fz_vmtx) * font->nvmtx); + if (!newmtx) + return fz_outofmem; + font->vmtxcap = font->nvmtx; + font->vmtx = newmtx; + + return nil; +} + +fz_hmtx +fz_gethmtx(fz_font *font, int cid) +{ + int l = 0; + int r = font->nhmtx - 1; + int m; + + if (!font->hmtx) + goto notfound; + + while (l <= r) + { + m = (l + r) >> 1; + if (cid < font->hmtx[m].lo) + r = m - 1; + else if (cid > font->hmtx[m].hi) + l = m + 1; + else + return font->hmtx[m]; + } + +notfound: + return font->dhmtx; +} + +fz_vmtx +fz_getvmtx(fz_font *font, int cid) +{ + fz_hmtx h; + fz_vmtx v; + int l = 0; + int r = font->nvmtx - 1; + int m; + + if (!font->vmtx) + goto notfound; + + while (l <= r) + { + m = (l + r) >> 1; + if (cid < font->vmtx[m].lo) + r = m - 1; + else if (cid > font->vmtx[m].hi) + l = m + 1; + else + return font->vmtx[m]; + } + +notfound: + h = fz_gethmtx(font, cid); + v = font->dvmtx; + v.x = h.w / 2; + return v; +} + +void +fz_debugfont(fz_font *font) +{ + int i; + + printf("font '%s' {\n", font->name); + printf(" wmode %d\n", font->wmode); + printf(" bbox [%d %d %d %d]\n", + font->bbox.min.x, font->bbox.min.y, + font->bbox.max.x, font->bbox.max.y); + printf(" DW %d\n", font->dhmtx.w); + + printf(" W {\n"); + for (i = 0; i < font->nhmtx; i++) + printf(" <%04x> <%04x> %d\n", + font->hmtx[i].lo, font->hmtx[i].hi, font->hmtx[i].w); + printf(" }\n"); + + if (font->wmode) + { + printf(" DW2 [%d %d]\n", font->dvmtx.y, font->dvmtx.w); + printf(" W2 {\n"); + for (i = 0; i < font->nvmtx; i++) + printf(" <%04x> <%04x> %d %d %d\n", font->vmtx[i].lo, font->vmtx[i].hi, + font->vmtx[i].x, font->vmtx[i].y, font->vmtx[i].w); + printf(" }\n"); + } + + printf("}\n"); +} + diff --git a/base/res_image.c b/base/res_image.c new file mode 100644 index 00000000..dbeb1fd8 --- /dev/null +++ b/base/res_image.c @@ -0,0 +1,22 @@ +#include + +fz_image * +fz_keepimage(fz_image *image) +{ + image->refs ++; + return image; +} + +void +fz_dropimage(fz_image *image) +{ + if (--image->refs == 0) + { + if (image->drop) + image->drop(image); + if (image->cs) + fz_dropcolorspace(image->cs); + fz_free(image); + } +} + diff --git a/base/res_shade.c b/base/res_shade.c new file mode 100644 index 00000000..67a64e4e --- /dev/null +++ b/base/res_shade.c @@ -0,0 +1,28 @@ +#include + +fz_shade * +fz_keepshade(fz_shade *shade) +{ + shade->refs ++; + return shade; +} + +void +fz_dropshade(fz_shade *shade) +{ + if (--shade->refs == 0) + { + if (shade->cs) + fz_dropcolorspace(shade->cs); + fz_free(shade->mesh); + fz_free(shade); + } +} + +fz_rect +fz_boundshade(fz_shade *shade, fz_matrix ctm) +{ + ctm = fz_concat(shade->matrix, ctm); + return fz_transformaabb(ctm, shade->bbox); +} + diff --git a/base/rune.c b/base/rune.c deleted file mode 100644 index 4aa81df3..00000000 --- a/base/rune.c +++ /dev/null @@ -1,168 +0,0 @@ -enum -{ - UTFmax = 3, /* maximum bytes per rune */ - Runesync = 0x80, /* cannot represent part of a UTF sequence (<) */ - Runeself = 0x80, /* rune and UTF sequences are the same (<) */ - Runeerror = 0x80 /* decoding error in UTF */ -}; - -enum -{ - Bit1 = 7, - Bitx = 6, - Bit2 = 5, - Bit3 = 4, - Bit4 = 3, - - T1 = ((1<<(Bit1+1))-1) ^ 0xFF, /* 0000 0000 */ - Tx = ((1<<(Bitx+1))-1) ^ 0xFF, /* 1000 0000 */ - T2 = ((1<<(Bit2+1))-1) ^ 0xFF, /* 1100 0000 */ - T3 = ((1<<(Bit3+1))-1) ^ 0xFF, /* 1110 0000 */ - T4 = ((1<<(Bit4+1))-1) ^ 0xFF, /* 1111 0000 */ - - Rune1 = (1<<(Bit1+0*Bitx))-1, /* 0000 0000 0111 1111 */ - Rune2 = (1<<(Bit2+1*Bitx))-1, /* 0000 0111 1111 1111 */ - Rune3 = (1<<(Bit3+2*Bitx))-1, /* 1111 1111 1111 1111 */ - - Maskx = (1< T1 - */ - c = *(unsigned char*)str; - if(c < Tx) { - *rune = c; - return 1; - } - - /* - * two character sequence - * 0080-07FF => T2 Tx - */ - c1 = *(unsigned char*)(str+1) ^ Tx; - if(c1 & Testx) - goto bad; - if(c < T3) { - if(c < T2) - goto bad; - l = ((c << Bitx) | c1) & Rune2; - if(l <= Rune1) - goto bad; - *rune = l; - return 2; - } - - /* - * three character sequence - * 0800-FFFF => T3 Tx Tx - */ - c2 = *(unsigned char*)(str+2) ^ Tx; - if(c2 & Testx) - goto bad; - if(c < T4) { - l = ((((c << Bitx) | c1) << Bitx) | c2) & Rune3; - if(l <= Rune2) - goto bad; - *rune = l; - return 3; - } - - /* - * bad decoding - */ -bad: - *rune = Bad; - return 1; -} - -int -runetochar(char *str, int *rune) -{ - int c; - - /* - * one character sequence - * 00000-0007F => 00-7F - */ - c = *rune; - if(c <= Rune1) { - str[0] = c; - return 1; - } - - /* - * two character sequence - * 0080-07FF => T2 Tx - */ - if(c <= Rune2) { - str[0] = T2 | (c >> 1*Bitx); - str[1] = Tx | (c & Maskx); - return 2; - } - - /* - * three character sequence - * 0800-FFFF => T3 Tx Tx - */ - str[0] = T3 | (c >> 2*Bitx); - str[1] = Tx | ((c >> 1*Bitx) & Maskx); - str[2] = Tx | (c & Maskx); - return 3; -} - -int -runelen(int c) -{ - int rune; - char str[10]; - - rune = c; - return runetochar(str, &rune); -} - -int -runenlen(int *r, int nrune) -{ - int nb, c; - - nb = 0; - while(nrune--) { - c = *r++; - if(c <= Rune1) - nb++; - else - if(c <= Rune2) - nb += 2; - else - nb += 3; - } - return nb; -} - -int -fullrune(char *str, int n) -{ - int c; - - if(n > 0) { - c = *(unsigned char*)str; - if(c < Tx) - return 1; - if(n > 1) - if(c < T3 || n > 2) - return 1; - } - return 0; -} - diff --git a/base/util_getopt.c b/base/util_getopt.c new file mode 100644 index 00000000..c870e206 --- /dev/null +++ b/base/util_getopt.c @@ -0,0 +1,116 @@ +/* + * Copyright (c) 1987 Regents of the University of California. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#if defined(LIBC_SCCS) && !defined(lint) +static char sccsid[] = "@(#)getopt.c 4.13 (Berkeley) 2/23/91"; +#endif /* LIBC_SCCS and not lint */ + +#include +#include +#include + +/* + * get option letter from argument vector + */ +int opterr = 1, /* if error message should be printed */ + optind = 1, /* index into parent argv vector */ + optopt; /* character checked for validity */ +char *optarg; /* argument associated with option */ + +#define BADCH (int)'?' +#define EMSG "" + +int getopt(int nargc, char * const * nargv, const char *ostr) +{ + static char *place = EMSG; /* option letter processing */ + register char *oli; /* option letter list index */ + char *p; + + if (!*place) { /* update scanning pointer */ + if (optind >= nargc || *(place = nargv[optind]) != '-') { + place = EMSG; + return(EOF); + } + if (place[1] && *++place == '-') { /* found "--" */ + ++optind; + place = EMSG; + return(EOF); + } + } /* option letter okay? */ + if ((optopt = (int)*place++) == (int)':' || + !(oli = strchr(ostr, optopt))) { + /* + * if the user didn't specify '-' as an option, + * assume it means EOF. + */ + if (optopt == (int)'-') + return(EOF); + if (!*place) + ++optind; + if (opterr) { + if (!(p = strrchr(*nargv, '/'))) + p = *nargv; + else + ++p; + (void)fprintf(stderr, "%s: illegal option -- %c\n", + p, optopt); + } + return(BADCH); + } + if (*++oli != ':') { /* don't need argument */ + optarg = NULL; + if (!*place) + ++optind; + } + else { /* need an argument */ + if (*place) /* no white space */ + optarg = place; + else if (nargc <= ++optind) { /* no arg */ + place = EMSG; + if (!(p = strrchr(*nargv, '/'))) + p = *nargv; + else + ++p; + if (opterr) + (void)fprintf(stderr, + "%s: option requires an argument -- %c\n", + p, optopt); + return(BADCH); + } + else /* white space */ + optarg = nargv[optind]; + place = EMSG; + ++optind; + } + return(optopt); /* dump back option letter */ +} diff --git a/base/util_strlcat.c b/base/util_strlcat.c new file mode 100644 index 00000000..c659b73a --- /dev/null +++ b/base/util_strlcat.c @@ -0,0 +1,35 @@ +/* Appends src to string dst of size siz (unlike strncat, siz is the + * full size of dst, not space left). At most siz-1 characters + * will be copied. Always NUL terminates (unless siz == 0). + * Returns strlen(src); if retval >= siz, truncation occurred. + */ + +#include + +int strlcat(char *dst, const char *src, int siz) +{ + register char *d = dst; + register const char *s = src; + register int n = siz; + int dlen; + + /* Find the end of dst and adjust bytes left but don't go past end */ + while (*d != '\0' && n-- != 0) + d++; + dlen = d - dst; + n = siz - dlen; + + if (n == 0) + return dlen + strlen(s); + while (*s != '\0') { + if (n != 1) { + *d++ = *s; + n--; + } + s++; + } + *d = '\0'; + + return dlen + (s - src); /* count does not include NUL */ +} + diff --git a/base/util_strlcpy.c b/base/util_strlcpy.c new file mode 100644 index 00000000..73416ae1 --- /dev/null +++ b/base/util_strlcpy.c @@ -0,0 +1,32 @@ +/* Copy src to string dst of size siz. At most siz-1 characters + * will be copied. Always NUL terminates (unless siz == 0). + * Returns strlen(src); if retval >= siz, truncation occurred. + */ + +#include + +int strlcpy(char *dst, const char *src, int siz) +{ + register char *d = dst; + register const char *s = src; + register int n = siz; + + /* Copy as many bytes as will fit */ + if (n != 0 && --n != 0) { + do { + if ((*d++ = *s++) == 0) + break; + } while (--n != 0); + } + + /* Not enough room in dst, add NUL and traverse rest of src */ + if (n == 0) { + if (siz != 0) + *d = '\0'; /* NUL-terminate dst */ + while (*s++) + ; + } + + return(s - src - 1); /* count does not include NUL */ +} + diff --git a/base/util_strsep.c b/base/util_strsep.c new file mode 100644 index 00000000..e54903ce --- /dev/null +++ b/base/util_strsep.c @@ -0,0 +1,11 @@ +#include + +char *strsep(char **stringp, const char *delim) +{ + char *ret = *stringp; + if (ret == NULL) return NULL; + if ((*stringp = strpbrk(*stringp, delim)) != NULL) + *((*stringp)++) = '\0'; + return ret; +} + diff --git a/filter/TODO b/filter/TODO deleted file mode 100644 index 404d76c2..00000000 --- a/filter/TODO +++ /dev/null @@ -1,8 +0,0 @@ -validate ahxd pushback -go through eof responsibility -be more defensive of api user errors -flate needin/needout - -jbig2 rewrite -dctencode params - diff --git a/filter/a85d.c b/filter/a85d.c deleted file mode 100644 index 5b2e105e..00000000 --- a/filter/a85d.c +++ /dev/null @@ -1,128 +0,0 @@ -#include - -typedef struct fz_a85d_s fz_a85d; - -struct fz_a85d_s -{ - fz_filter super; - unsigned long word; - int count; -}; - -static inline int iswhite(int a) -{ - switch (a) { - case '\n': case '\r': case '\t': case ' ': - case '\0': case '\f': case '\b': case 0177: - return 1; - } - return 0; -} - -fz_error * -fz_newa85d(fz_filter **fp, fz_obj *params) -{ - FZ_NEWFILTER(fz_a85d, f, a85d); - f->word = 0; - f->count = 0; - return nil; -} - -void -fz_dropa85d(fz_filter *f) -{ -} - -fz_error * -fz_processa85d(fz_filter *filter, fz_buffer *in, fz_buffer *out) -{ - fz_a85d *f = (fz_a85d*)filter; - int c; - - while (1) - { - if (in->rp == in->wp) - return fz_ioneedin; - - c = *in->rp++; - - if (c >= '!' && c <= 'u') { - if (f->count == 4) { - if (out->wp + 4 > out->ep) { - in->rp --; - return fz_ioneedout; - } - - f->word = f->word * 85 + (c - '!'); - - *out->wp++ = (f->word >> 24) & 0xff; - *out->wp++ = (f->word >> 16) & 0xff; - *out->wp++ = (f->word >> 8) & 0xff; - *out->wp++ = (f->word) & 0xff; - - f->word = 0; - f->count = 0; - } - else { - f->word = f->word * 85 + (c - '!'); - f->count ++; - } - } - - else if (c == 'z' && f->count == 0) { - if (out->wp + 4 > out->ep) { - in->rp --; - return fz_ioneedout; - } - *out->wp++ = 0; - *out->wp++ = 0; - *out->wp++ = 0; - *out->wp++ = 0; - } - - else if (c == '~') { - if (in->rp == in->wp) { - in->rp --; - return fz_ioneedin; - } - - c = *in->rp++; - - if (c != '>') { - return fz_throw("ioerror: bad eod marker in a85d"); - } - - if (out->wp + f->count - 1 > out->ep) { - in->rp -= 2; - return fz_ioneedout; - } - - switch (f->count) { - case 0: - break; - case 1: - return fz_throw("ioerror: partial final byte in a85d"); - case 2: - f->word = f->word * (85L * 85 * 85) + 0xffffffL; - goto o1; - case 3: - f->word = f->word * (85L * 85) + 0xffffL; - goto o2; - case 4: - f->word = f->word * 85 + 0xffL; - *(out->wp+2) = f->word >> 8; -o2: *(out->wp+1) = f->word >> 16; -o1: *(out->wp+0) = f->word >> 24; - out->wp += f->count - 1; - break; - } - out->eof = 1; - return fz_iodone; - } - - else if (!iswhite(c)) { - return fz_throw("ioerror: bad data in a85d: '%c'", c); - } - } -} - diff --git a/filter/a85e.c b/filter/a85e.c deleted file mode 100644 index d9cd22c6..00000000 --- a/filter/a85e.c +++ /dev/null @@ -1,127 +0,0 @@ -#include - -typedef struct fz_a85e_s fz_a85e; - -struct fz_a85e_s -{ - fz_filter super; - int c; -}; - -fz_error * -fz_newa85e(fz_filter **fp, fz_obj *params) -{ - FZ_NEWFILTER(fz_a85e, f, a85e); - f->c = 0; - return nil; -} - -void -fz_dropa85e(fz_filter *f) -{ -} - -fz_error * -fz_processa85e(fz_filter *filter, fz_buffer *in, fz_buffer *out) -{ - fz_a85e *f = (fz_a85e*)filter; - unsigned long word; - int count; - int n; - - n = 0; - - while (1) - { - if (f->c >= 70) { - if (out->wp + 1 > out->ep) - return fz_ioneedout; - *out->wp++ = '\n'; - f->c = 0; - n ++; - } - - if (in->rp + 4 <= in->wp) - { - word = (in->rp[0] << 24) | - (in->rp[1] << 16) | - (in->rp[2] << 8) | - (in->rp[3]); - if (word == 0) { - if (out->wp + 1 > out->ep) - return fz_ioneedout; - *out->wp++ = 'z'; - f->c ++; - n ++; - } - else { - unsigned long v1, v2, v3, v4; - - if (out->wp + 5 > out->ep) - return fz_ioneedout; - - v4 = word / 85; - v3 = v4 / 85; - v2 = v3 / 85; - v1 = v2 / 85; - - *out->wp++ = (v1 % 85) + '!'; - *out->wp++ = (v2 % 85) + '!'; - *out->wp++ = (v3 % 85) + '!'; - *out->wp++ = (v4 % 85) + '!'; - *out->wp++ = (word % 85) + '!'; - f->c += 5; - n += 5; - } - in->rp += 4; - } - - else if (in->eof) - { - unsigned long divisor; - - if (in->rp == in->wp) - goto needinput; /* handle clean eof here */ - - count = in->wp - in->rp; - - if (out->wp + count + 3 > out->ep) - return fz_ioneedout; - - word = 0; - switch (count) { - case 3: word |= in->rp[2] << 8; - case 2: word |= in->rp[1] << 16; - case 1: word |= in->rp[0] << 24; - } - in->rp += count; - - divisor = 85L * 85 * 85 * 85; - while (count-- >= 0) { - *out->wp++ = ((word / divisor) % 85) + '!'; - divisor /= 85; - } - - *out->wp++ = '~'; - *out->wp++ = '>'; - out->eof = 1; - return fz_iodone; - } - - else { - goto needinput; - } - } - -needinput: - if (in->eof) { - if (out->wp + 2 > out->ep) - return fz_ioneedout; - *out->wp++ = '~'; - *out->wp++ = '>'; - out->eof = 1; - return fz_iodone; - } - return fz_ioneedin; -} - diff --git a/filter/ahxd.c b/filter/ahxd.c deleted file mode 100644 index d0e6d7f5..00000000 --- a/filter/ahxd.c +++ /dev/null @@ -1,112 +0,0 @@ -#include - -typedef struct fz_ahxd_s fz_ahxd; - -struct fz_ahxd_s -{ - fz_filter super; - int odd; - int a; -}; - -static inline int iswhite(int a) -{ - switch (a) { - case '\n': case '\r': case '\t': case ' ': - case '\0': case '\f': case '\b': case 0177: - return 1; - } - return 0; -} - -static inline int ishex(int a) -{ - return (a >= 'A' && a <= 'F') || - (a >= 'a' && a <= 'f') || - (a >= '0' && a <= '9'); -} - -static inline int fromhex(int a) -{ - if (a >= 'A' && a <= 'F') - return a - 'A' + 0xA; - if (a >= 'a' && a <= 'f') - return a - 'a' + 0xA; - if (a >= '0' && a <= '9') - return a - '0'; - return 0; -} - -fz_error * -fz_newahxd(fz_filter **fp, fz_obj *params) -{ - FZ_NEWFILTER(fz_ahxd, f, ahxd); - f->odd = 0; - f->a = 0; - return nil; -} - -void -fz_dropahxd(fz_filter *f) -{ -} - -fz_error * -fz_processahxd(fz_filter *filter, fz_buffer *in, fz_buffer *out) -{ - fz_ahxd *f = (fz_ahxd*)filter; - int b, c; - - while (1) - { - if (in->rp == in->wp) - return fz_ioneedin; - - if (out->wp == out->ep) - return fz_ioneedout; - - c = *in->rp++; - - if (ishex(c)) { - if (!f->odd) { - f->a = fromhex(c); - f->odd = 1; - } - else { - b = fromhex(c); - *out->wp++ = (f->a << 4) | b; - f->odd = 0; - } - } - - else if (c == '>') { - if (f->odd) - *out->wp++ = (f->a << 4); - out->eof = 1; - return fz_iodone; - } - - else if (!iswhite(c)) { - return fz_throw("ioerror: bad data in ahxd: '%c'", c); - } - } -} - -void -fz_pushbackahxd(fz_filter *filter, fz_buffer *in, fz_buffer *out, int n) -{ - int k; - - assert(filter->process == fz_processahxd); - assert(out->wp - n >= out->rp); - - k = 0; - while (k < n * 2) { - in->rp --; - if (ishex(*in->rp)) - k ++; - } - - out->wp -= n; -} - diff --git a/filter/ahxe.c b/filter/ahxe.c deleted file mode 100644 index c2b882a6..00000000 --- a/filter/ahxe.c +++ /dev/null @@ -1,64 +0,0 @@ -#include - -typedef struct fz_ahxe_s fz_ahxe; - -struct fz_ahxe_s -{ - fz_filter super; - int c; -}; - -static const char tohex[16] = "0123456789ABCDEF"; - -fz_error * -fz_newahxe(fz_filter **fp, fz_obj *params) -{ - FZ_NEWFILTER(fz_ahxe, f, ahxe); - f->c = 0; - return nil; -} - -void -fz_dropahxe(fz_filter *f) -{ -} - -fz_error * -fz_processahxe(fz_filter *filter, fz_buffer *in, fz_buffer *out) -{ - fz_ahxe *f = (fz_ahxe*)filter; - int a, b, c; - - while (1) - { - if (in->rp == in->wp) - goto needinput; - - if (out->wp + 2 >= out->ep) /* can write 3 bytes from 1 */ - return fz_ioneedout; - - c = *in->rp++; - a = tohex[(c >> 4) & 0x0f]; - b = tohex[c & 0x0f]; - - *out->wp++ = a; - *out->wp++ = b; - - f->c += 2; - if (f->c == 60) { - *out->wp++ = '\n'; - f->c = 0; - } - } - -needinput: - if (in->eof) { - if (out->wp == out->ep) - return fz_ioneedout; - *out->wp++ = '>'; - out->eof = 1; - return fz_iodone; - } - return fz_ioneedin; -} - diff --git a/filter/arc4filter.c b/filter/arc4filter.c deleted file mode 100644 index b025368c..00000000 --- a/filter/arc4filter.c +++ /dev/null @@ -1,46 +0,0 @@ -#include - -typedef struct fz_arc4c_s fz_arc4c; - -struct fz_arc4c_s -{ - fz_filter super; - fz_arc4 arc4; -}; - -fz_error * -fz_newarc4filter(fz_filter **fp, unsigned char *key, unsigned keylen) -{ - FZ_NEWFILTER(fz_arc4c, f, arc4filter); - fz_arc4init(&f->arc4, key, keylen); - return nil; -} - -void -fz_droparc4filter(fz_filter *f) -{ -} - -fz_error * -fz_processarc4filter(fz_filter *filter, fz_buffer *in, fz_buffer *out) -{ - fz_arc4c *f = (fz_arc4c*)filter; - int n; - - while (1) - { - if (in->rp + 1 > in->wp) { - if (in->eof) - return fz_iodone; - return fz_ioneedin; - } - if (out->wp + 1 > out->ep) - return fz_ioneedout; - - n = MIN(in->wp - in->rp, out->ep - out->wp); - fz_arc4encrypt(&f->arc4, out->wp, in->rp, n); - in->rp += n; - out->wp += n; - } -} - diff --git a/filter/buffer.c b/filter/buffer.c deleted file mode 100644 index 206137a6..00000000 --- a/filter/buffer.c +++ /dev/null @@ -1,93 +0,0 @@ -#include - -fz_error * -fz_newbuffer(fz_buffer **bp, int size) -{ - fz_buffer *b; - - b = *bp = fz_malloc(sizeof(fz_buffer)); - if (!b) return fz_outofmem; - - b->refs = 1; - b->ownsdata = 1; - b->bp = fz_malloc(size); - if (!b->bp) { fz_free(b); return fz_outofmem; } - - b->rp = b->bp; - b->wp = b->bp; - b->ep = b->bp + size; - b->eof = 0; - - return nil; -} - -fz_error * -fz_newbufferwithdata(fz_buffer **bp, unsigned char *data, int size) -{ - fz_buffer *b; - - b = *bp = fz_malloc(sizeof(fz_buffer)); - if (!b) return fz_outofmem; - - b->refs = 1; - b->ownsdata = 0; - b->bp = data; - - b->rp = b->bp; - b->wp = b->bp + size; - b->ep = b->bp + size; - b->eof = 0; - - return nil; -} - -fz_buffer * -fz_keepbuffer(fz_buffer *buf) -{ - buf->refs ++; - return buf; -} - -void -fz_dropbuffer(fz_buffer *buf) -{ - if (--buf->refs == 0) - { - if (buf->ownsdata) - fz_free(buf->bp); - fz_free(buf); - } -} - -fz_error * -fz_growbuffer(fz_buffer *buf) -{ - unsigned char *newbp; - - int rp = buf->rp - buf->bp; - int wp = buf->wp - buf->bp; - int ep = buf->ep - buf->bp; - - assert(buf->ownsdata); - - newbp = fz_realloc(buf->bp, ep * 2); - if (!newbp) return fz_outofmem; - - buf->bp = newbp; - buf->rp = buf->bp + rp; - buf->wp = buf->bp + wp; - buf->ep = buf->bp + ep * 2; - - return nil; -} - -fz_error * -fz_rewindbuffer(fz_buffer *buf) -{ - assert(buf->ownsdata); - memmove(buf->bp, buf->rp, buf->wp - buf->rp); - buf->wp = buf->bp + (buf->wp - buf->rp); - buf->rp = buf->bp; - return nil; -} - diff --git a/filter/dctc.h b/filter/dctc.h deleted file mode 100644 index 8aa6aeb7..00000000 --- a/filter/dctc.h +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Extend libjpegs error handler to use setjmp/longjmp - */ - -#include - -#include - -struct myerrmgr -{ - struct jpeg_error_mgr super; - jmp_buf jb; - char msg[JMSG_LENGTH_MAX]; -}; - -static void myerrexit(j_common_ptr cinfo) -{ - struct myerrmgr *err = (struct myerrmgr *)cinfo->err; - char msgbuf[JMSG_LENGTH_MAX]; - err->super.format_message(cinfo, msgbuf); - strlcpy(err->msg, msgbuf, sizeof err->msg); - longjmp(err->jb, 1); -} - -static void myoutmess(j_common_ptr cinfo) -{ - struct myerrmgr *err = (struct myerrmgr *)cinfo->err; - char msgbuf[JMSG_LENGTH_MAX]; - err->super.format_message(cinfo, msgbuf); - fprintf(stderr, "ioerror: dct: %s", msgbuf); -} - -static void myiniterr(struct myerrmgr *err) -{ - jpeg_std_error(&err->super); - err->super.error_exit = myerrexit; - err->super.output_message = myoutmess; -} - diff --git a/filter/dctd.c b/filter/dctd.c deleted file mode 100644 index 750f7893..00000000 --- a/filter/dctd.c +++ /dev/null @@ -1,219 +0,0 @@ -#include - -#include "dctc.h" - -typedef struct fz_dctd_s fz_dctd; - -struct mysrcmgr -{ - struct jpeg_source_mgr super; - fz_buffer *buf; - int skip; -}; - -struct fz_dctd_s -{ - fz_filter super; - struct jpeg_decompress_struct cinfo; - struct mysrcmgr src; - struct myerrmgr err; - int colortransform; - int stage; -}; - -static void myinitsource(j_decompress_ptr cinfo) { /* empty */ } -static boolean myfillinput(j_decompress_ptr cinfo) { return FALSE; } -static void mytermsource(j_decompress_ptr cinfo) { /* empty */ } - -static void myskipinput(j_decompress_ptr cinfo, long n) -{ - struct mysrcmgr *src = (struct mysrcmgr *)cinfo->src; - fz_buffer *in = src->buf; - - assert(src->skip == 0); - - in->rp = in->wp - src->super.bytes_in_buffer; - - if (in->rp + n > in->wp) { - src->skip = (in->rp + n) - in->wp; - in->rp = in->wp; - } - else { - src->skip = 0; - in->rp += n; - } - - src->super.bytes_in_buffer = in->wp - in->rp; - src->super.next_input_byte = in->rp; -} - -fz_error * -fz_newdctd(fz_filter **fp, fz_obj *params) -{ - fz_error *err; - fz_obj *obj; - int colortransform; - - FZ_NEWFILTER(fz_dctd, d, dctd); - - colortransform = 1; - - if (params) { - obj = fz_dictgets(params, "ColorTransform"); - if (obj) colortransform = fz_toint(obj); - } - - d->colortransform = colortransform; - d->stage = 0; - - /* setup error callback first thing */ - myiniterr(&d->err); - d->cinfo.err = (struct jpeg_error_mgr*) &d->err; - - if (setjmp(d->err.jb)) { - err = fz_throw("ioerror in dctd: %s", d->err.msg); - fz_free(d); - return err; - } - - /* create decompression object. this zeroes cinfo except for err. */ - jpeg_create_decompress(&d->cinfo); - - /* prepare source manager */ - d->cinfo.src = (struct jpeg_source_mgr *)&d->src; - d->src.super.init_source = myinitsource; - d->src.super.fill_input_buffer = myfillinput; - d->src.super.skip_input_data = myskipinput; - d->src.super.resync_to_restart = jpeg_resync_to_restart; - d->src.super.term_source = mytermsource; - - d->src.super.bytes_in_buffer = 0; - d->src.super.next_input_byte = nil; - d->src.skip = 0; - - /* speed up jpeg decoding a bit */ - d->cinfo.dct_method = JDCT_FASTEST; - d->cinfo.do_fancy_upsampling = FALSE; - - return nil; -} - -void -fz_dropdctd(fz_filter *filter) -{ - fz_dctd *d = (fz_dctd*)filter; - if (setjmp(d->err.jb)) { - fprintf(stderr, "ioerror in dct: jpeg_destroy_decompress: %s", d->err.msg); - return; - } - jpeg_destroy_decompress(&d->cinfo); -} - -fz_error * -fz_processdctd(fz_filter *filter, fz_buffer *in, fz_buffer *out) -{ - fz_dctd *d = (fz_dctd*)filter; - boolean b; - int i; - int stride; - JSAMPROW scanlines[1]; - - d->src.buf = in; - - /* skip any bytes left over from myskipinput() */ - if (d->src.skip > 0) { - if (in->rp + d->src.skip > in->wp) { - d->src.skip = (in->rp + d->src.skip) - in->wp; - in->rp = in->wp; - goto needinput; - } - else { - in->rp += d->src.skip; - d->src.skip = 0; - } - } - - d->src.super.bytes_in_buffer = in->wp - in->rp; - d->src.super.next_input_byte = in->rp; - - if (setjmp(d->err.jb)) { - return fz_throw("ioerror in dctd: %s", d->err.msg); - } - - switch (d->stage) - { - case 0: - i = jpeg_read_header(&d->cinfo, TRUE); - if (i == JPEG_SUSPENDED) - goto needinput; - - /* FIXME: default value if ColorTransform is not set */ - - if (!d->cinfo.saw_Adobe_marker) { - switch (d->cinfo.num_components) { - case 3: - if (d->colortransform) - d->cinfo.jpeg_color_space = JCS_YCbCr; - else - d->cinfo.jpeg_color_space = JCS_RGB; - break; - case 4: - if (d->colortransform) - d->cinfo.jpeg_color_space = JCS_YCCK; - else - d->cinfo.jpeg_color_space = JCS_CMYK; - break; - } - } - - /* fall through */ - d->stage = 1; - - case 1: - b = jpeg_start_decompress(&d->cinfo); - if (b == FALSE) - goto needinput; - - /* fall through */ - d->stage = 2; - - case 2: - stride = d->cinfo.output_width * d->cinfo.output_components; - - while (d->cinfo.output_scanline < d->cinfo.output_height) - { - if (out->wp + stride > out->ep) - goto needoutput; - - scanlines[0] = out->wp; - - i = jpeg_read_scanlines(&d->cinfo, scanlines, 1); - - if (i == 0) - goto needinput; - - out->wp += stride; - } - - /* fall through */ - d->stage = 3; - - case 3: - b = jpeg_finish_decompress(&d->cinfo); - if (b == FALSE) - goto needinput; - d->stage = 4; - out->eof = 1; - in->rp = in->wp - d->src.super.bytes_in_buffer; - return fz_iodone; - } - -needinput: - in->rp = in->wp - d->src.super.bytes_in_buffer; - return fz_ioneedin; - -needoutput: - in->rp = in->wp - d->src.super.bytes_in_buffer; - return fz_ioneedout; -} - diff --git a/filter/dcte.c b/filter/dcte.c deleted file mode 100644 index 547721b4..00000000 --- a/filter/dcte.c +++ /dev/null @@ -1,252 +0,0 @@ -#include - -#include "dctc.h" - -typedef struct fz_dcte_s fz_dcte; - -struct mydstmgr -{ - struct jpeg_destination_mgr super; - fz_buffer *buf; -}; - -struct fz_dcte_s -{ - fz_filter super; - - struct jpeg_compress_struct cinfo; - struct mydstmgr dst; - struct myerrmgr err; - int stage; - - int columns; - int rows; - int colors; -}; - -static void myinitdest(j_compress_ptr cinfo) { /* empty */ } -static boolean myemptybuf(j_compress_ptr cinfo) { return FALSE; } -static void mytermdest(j_compress_ptr cinfo) { /* empty */ } - -fz_error * -fz_newdcte(fz_filter **fp, fz_obj *params) -{ - fz_error *err; - fz_obj *obj; - int i; - - FZ_NEWFILTER(fz_dcte, e, dcte); - - e->stage = 0; - - obj = fz_dictgets(params, "Columns"); - if (!obj) { fz_free(e); return fz_throw("ioerror in dcte: missing Columns parameter"); } - e->columns = fz_toint(obj); - - obj = fz_dictgets(params, "Rows"); - if (!obj) { fz_free(e); return fz_throw("ioerror in dcte: missing Rows parameter"); } - e->rows = fz_toint(obj); - - obj = fz_dictgets(params, "Colors"); - if (!obj) { fz_free(e); return fz_throw("ioerror in dcte: missing Colors parameter"); } - e->colors = fz_toint(obj); - - /* setup error callback first thing */ - myiniterr(&e->err); - e->cinfo.err = (struct jpeg_error_mgr*) &e->err; - - if (setjmp(e->err.jb)) { - err = fz_throw("ioerror in dcte: %s", e->err.msg); - fz_free(e); - return err; - } - - jpeg_create_compress(&e->cinfo); - - /* prepare destination manager */ - e->cinfo.dest = (struct jpeg_destination_mgr *) &e->dst; - e->dst.super.init_destination = myinitdest; - e->dst.super.empty_output_buffer = myemptybuf; - e->dst.super.term_destination = mytermdest; - - e->dst.super.next_output_byte = nil; - e->dst.super.free_in_buffer = 0; - - /* prepare required encoding options */ - e->cinfo.image_width = e->columns; - e->cinfo.image_height = e->rows; - e->cinfo.input_components = e->colors; - - switch (e->colors) { - case 1: e->cinfo.in_color_space = JCS_GRAYSCALE; break; - case 3: e->cinfo.in_color_space = JCS_RGB; break; - case 4: e->cinfo.in_color_space = JCS_CMYK; break; - default: e->cinfo.in_color_space = JCS_UNKNOWN; break; - } - - jpeg_set_defaults(&e->cinfo); - - /* FIXME check this */ - obj = fz_dictgets(params, "ColorTransform"); - if (obj) { - int colortransform = fz_toint(obj); - if (e->colors == 3 && !colortransform) - jpeg_set_colorspace(&e->cinfo, JCS_RGB); - if (e->colors == 4 && colortransform) - jpeg_set_colorspace(&e->cinfo, JCS_YCCK); - if (e->colors == 4 && !colortransform) - jpeg_set_colorspace(&e->cinfo, JCS_CMYK); - } - - obj = fz_dictgets(params, "HSamples"); - if (obj && fz_isarray(obj)) { - fz_obj *o; - for (i = 0; i < e->colors; i++) { - o = fz_arrayget(obj, i); - e->cinfo.comp_info[i].h_samp_factor = fz_toint(o); - } - } - - obj = fz_dictgets(params, "VSamples"); - if (obj && fz_isarray(obj)) { - fz_obj *o; - for (i = 0; i < e->colors; i++) { - o = fz_arrayget(obj, i); - e->cinfo.comp_info[i].v_samp_factor = fz_toint(o); - } - } - - /* TODO: quant-tables and huffman-tables */ - - return nil; -} - -void -fz_dropdcte(fz_filter *filter) -{ - fz_dcte *e = (fz_dcte*)filter; - - if (setjmp(e->err.jb)) { - fprintf(stderr, "ioerror in dcte: jpeg_destroy_compress: %s", e->err.msg); - return; - } - - jpeg_destroy_compress(&e->cinfo); -} - -/* Adobe says zigzag order. IJG > v6a says natural order. */ -#if JPEG_LIB_VERSION >= 61 -#define unzigzag(x) unzigzagorder[x] -/* zigzag array position of n'th element of natural array order */ -static const unsigned char unzigzagorder[] = -{ - 0, 1, 5, 6, 14, 15, 27, 28, - 2, 4, 7, 13, 16, 26, 29, 42, - 3, 8, 12, 17, 25, 30, 41, 43, - 9, 11, 18, 24, 31, 40, 44, 53, - 10, 19, 23, 32, 39, 45, 52, 54, - 20, 22, 33, 38, 46, 51, 55, 60, - 21, 34, 37, 47, 50, 56, 59, 61, - 35, 36, 48, 49, 57, 58, 62, 63 -}; -#else -#define unzigzag(x) (x) -#endif - -fz_error * -fz_setquanttables(fz_dcte *e, unsigned int **qtables, int qfactor) -{ - int i, j; - unsigned int table[64]; - - if (setjmp(e->err.jb)) { - return fz_throw("ioerror in dcte: %s", e->err.msg); - } - - /* TODO: check for duplicate tables */ - - for (i = 0; i < e->colors; i++) { - for (j = 0; j < 64; j++) { - table[j] = unzigzag(qtables[i][j]); - } - jpeg_add_quant_table(&e->cinfo, i, table, qfactor, TRUE); - e->cinfo.comp_info[i].quant_tbl_no = i; - } - - return nil; -} - -fz_error * -fz_processdcte(fz_filter *filter, fz_buffer *in, fz_buffer *out) -{ - fz_dcte *e = (fz_dcte*)filter; - JSAMPROW scanline[1]; - int stride; - int i; - - e->dst.buf = out; - e->dst.super.free_in_buffer = out->ep - out->wp; - e->dst.super.next_output_byte = out->wp; - - if (setjmp(e->err.jb)) { - return fz_throw("ioerror in dcte: %s", e->err.msg); - } - - switch (e->stage) - { - case 0: - /* must have enough space for markers, typically 600 bytes or so */ - if (out->wp + 1024 > out->ep) - goto needoutput; - - jpeg_start_compress(&e->cinfo, TRUE); - - /* TODO: write Adobe ColorTransform marker */ - - /* fall through */ - e->stage = 1; - - case 1: - stride = e->columns * e->colors; - - while (e->cinfo.next_scanline < e->cinfo.image_height) - { - if (in->rp + stride > in->wp) - goto needinput; - - scanline[0] = in->rp; - - i = jpeg_write_scanlines(&e->cinfo, scanline, 1); - - if (i == 0) - goto needoutput; - - in->rp += stride; - } - - /* fall through */ - e->stage = 2; - - case 2: - /* must have enough space for end markers */ - if (out->wp + 100 > out->ep) - goto needoutput; - - /* finish compress cannot suspend! */ - jpeg_finish_compress(&e->cinfo); - - e->stage = 3; - out->eof = 1; - out->wp = out->ep - e->dst.super.free_in_buffer; - return fz_iodone; - } - -needinput: - out->wp = out->ep - e->dst.super.free_in_buffer; - return fz_ioneedin; - -needoutput: - out->wp = out->ep - e->dst.super.free_in_buffer; - return fz_ioneedout; -} - diff --git a/filter/faxc.h b/filter/faxc.h deleted file mode 100644 index 14cae13f..00000000 --- a/filter/faxc.h +++ /dev/null @@ -1,125 +0,0 @@ -/* common bit magic */ - -static inline void -printbits(FILE *f, int code, int nbits) -{ - int n, b; - for (n = nbits - 1; n >= 0; n--) - { - b = (code >> n) & 1; - fprintf(f, "%c", b ? '1' : '0'); - } -} - -static inline int -getbit(const unsigned char *buf, int x) -{ - return ( buf[x >> 3] >> ( 7 - (x & 7) ) ) & 1; -} - -static inline void -printline(FILE *f, unsigned char *line, int w) -{ - int i; - for (i = 0; i < w; i++) - fprintf(f, "%c", getbit(line, i) ? '#' : '.'); - fprintf(f, "\n"); -} - -static inline int -getrun(const unsigned char *line, int x, int w, int c) -{ - int z; - int b; - - if (x < 0) - x = 0; - - z = x; - while (z < w) - { - b = getbit(line, z); - if (c != b) - break; - z ++; - } - - return z - x; -} - -static inline int -findchanging(const unsigned char *line, int x, int w) -{ - int a, b; - - if (line == 0) - 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 inline int -findchangingcolor(const unsigned char *line, int x, int w, int color) -{ - if (line == 0) - return w; - - x = findchanging(line, x, w); - - if (x < w && getbit(line, x) != color) - x = findchanging(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]; - } -} - diff --git a/filter/faxd.c b/filter/faxd.c deleted file mode 100644 index d8686a08..00000000 --- a/filter/faxd.c +++ /dev/null @@ -1,441 +0,0 @@ -#include - -#include "faxd.h" -#include "faxc.h" - -enum -{ - SNORMAL, /* neutral state, waiting for any code */ - SMAKEUP, /* got a 1d makeup code, waiting for terminating code */ - SEOL, /* at eol, needs output buffer space */ - SH1, SH2 /* in H part 1 and 2 (both makeup and terminating codes) */ -}; - -/* TODO: uncompressed */ - -typedef struct fz_faxd_s fz_faxd; - -struct fz_faxd_s -{ - fz_filter super; - - int k; - int endofline; - int encodedbytealign; - int columns; - int rows; - int endofblock; - int blackis1; - - int stride; - int ridx; - - int bidx; - unsigned int word; - - int stage, a, c, dim, eolc; - unsigned char *ref; - unsigned char *dst; -}; - -fz_error * -fz_newfaxd(fz_filter **fp, fz_obj *params) -{ - fz_obj *obj; - - FZ_NEWFILTER(fz_faxd, fax, faxd); - - fax->ref = nil; - fax->dst = nil; - - fax->k = 0; - fax->endofline = 0; - fax->encodedbytealign = 0; - fax->columns = 1728; - fax->rows = 0; - fax->endofblock = 1; - fax->blackis1 = 0; - - obj = fz_dictgets(params, "K"); - if (obj) fax->k = fz_toint(obj); - - obj = fz_dictgets(params, "EndOfLine"); - if (obj) fax->endofline = fz_tobool(obj); - - obj = fz_dictgets(params, "EncodedByteAlign"); - if (obj) fax->encodedbytealign = fz_tobool(obj); - - obj = fz_dictgets(params, "Columns"); - if (obj) fax->columns = fz_toint(obj); - - obj = fz_dictgets(params, "Rows"); - if (obj) fax->rows = fz_toint(obj); - - obj = fz_dictgets(params, "EndOfBlock"); - if (obj) fax->endofblock = fz_tobool(obj); - - obj = fz_dictgets(params, "BlackIs1"); - if (obj) fax->blackis1 = fz_tobool(obj); - - fax->stride = ((fax->columns - 1) >> 3) + 1; - fax->ridx = 0; - fax->bidx = 32; - fax->word = 0; - - fax->stage = SNORMAL; - fax->a = -1; - fax->c = 0; - fax->dim = fax->k < 0 ? 2 : 1; - fax->eolc = 0; - - fax->ref = fz_malloc(fax->stride); - if (!fax->ref) { fz_free(fax); return fz_outofmem; } - - fax->dst = fz_malloc(fax->stride); - if (!fax->dst) { fz_free(fax); fz_free(fax->ref); return fz_outofmem; } - - memset(fax->ref, 0, fax->stride); - memset(fax->dst, 0, fax->stride); - - return nil; -} - -void -fz_dropfaxd(fz_filter *p) -{ - fz_faxd *fax = (fz_faxd*) p; - fz_free(fax->ref); - fz_free(fax->dst); -} - -static inline void eatbits(fz_faxd *fax, int nbits) -{ - fax->word <<= nbits; - fax->bidx += nbits; -} - -static inline fz_error * fillbits(fz_faxd *fax, fz_buffer *in) -{ - while (fax->bidx >= 8) - { - if (in->rp + 1 > in->wp) - return fz_ioneedin; - fax->bidx -= 8; - fax->word |= *in->rp << fax->bidx; - in->rp ++; - } - return nil; -} - -static int -getcode(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; - } - - eatbits(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 = getcode(fax, cf_black_decode, cfd_black_initial_bits); - else - code = getcode(fax, cf_white_decode, cfd_white_initial_bits); - - if (code == UNCOMPRESSED) - return fz_throw("ioerror: uncompressed data in faxd"); - - if (code < 0) - return fz_throw("ioerror: invalid 1d code in faxd"); - - if (fax->a + code > fax->columns) - return fz_throw("ioerror: invalid 1d data in faxd"); - - if (fax->c) - setbits(fax->dst, fax->a, fax->a + code); - - fax->a += code; - - if (code < 64) - { - fax->c = !fax->c; - fax->stage = SNORMAL; - } - else - fax->stage = SMAKEUP; - - return nil; -} - -/* decode one 2d code */ -static fz_error * -dec2d(fz_faxd *fax) -{ - int code, b1, b2; - - if (fax->stage == SH1 || fax->stage == SH2) - { - if (fax->a == -1) - fax->a = 0; - - if (fax->c) - code = getcode(fax, cf_black_decode, cfd_black_initial_bits); - else - code = getcode(fax, cf_white_decode, cfd_white_initial_bits); - - if (code == UNCOMPRESSED) - return fz_throw("ioerror: uncompressed data in faxd"); - - if (code < 0) - return fz_throw("ioerror: invalid 2d code in faxd"); - - if (fax->a + code > fax->columns) - return fz_throw("ioerror: invalid 2d data in 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 == SH1) - fax->stage = SH2; - else if (fax->stage == SH2) - fax->stage = SNORMAL; - } - - return nil; - } - - code = getcode(fax, cf_2d_decode, cfd_2d_initial_bits); - - switch (code) - { - case H: - fax->stage = SH1; - break; - - case P: - b1 = findchangingcolor(fax->ref, fax->a, fax->columns, !fax->c); - b2 = findchanging(fax->ref, b1, fax->columns); - if (fax->c) setbits(fax->dst, fax->a, b2); - fax->a = b2; - break; - - case V0: - b1 = findchangingcolor(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 = findchangingcolor(fax->ref, fax->a, fax->columns, !fax->c); - if (fax->c) setbits(fax->dst, fax->a, b1 + 1); - fax->a = b1 + 1; - fax->c = !fax->c; - break; - - case VR2: - b1 = findchangingcolor(fax->ref, fax->a, fax->columns, !fax->c); - if (fax->c) setbits(fax->dst, fax->a, b1 + 2); - fax->a = b1 + 2; - fax->c = !fax->c; - break; - - case VR3: - b1 = findchangingcolor(fax->ref, fax->a, fax->columns, !fax->c); - if (fax->c) setbits(fax->dst, fax->a, b1 + 3); - fax->a = b1 + 3; - fax->c = !fax->c; - break; - - case VL1: - b1 = findchangingcolor(fax->ref, fax->a, fax->columns, !fax->c); - if (fax->c) setbits(fax->dst, fax->a, b1 - 1); - fax->a = b1 - 1; - fax->c = !fax->c; - break; - - case VL2: - b1 = findchangingcolor(fax->ref, fax->a, fax->columns, !fax->c); - if (fax->c) setbits(fax->dst, fax->a, b1 - 2); - fax->a = b1 - 2; - fax->c = !fax->c; - break; - - case VL3: - b1 = findchangingcolor(fax->ref, fax->a, fax->columns, !fax->c); - if (fax->c) setbits(fax->dst, fax->a, b1 - 3); - fax->a = b1 - 3; - fax->c = !fax->c; - break; - - case UNCOMPRESSED: - return fz_throw("ioerror: uncompressed data in faxd"); - - case ERROR: - return fz_throw("ioerror: invalid 2d code in faxd"); - - default: - return fz_throw("ioerror: invalid 2d code in faxd (%d)", code); - } - - return 0; -} - -fz_error * -fz_processfaxd(fz_filter *f, fz_buffer *in, fz_buffer *out) -{ - fz_faxd *fax = (fz_faxd*)f; - fz_error *error; - int i; - - if (fax->stage == SEOL) - goto eol; - -loop: - - if (fillbits(fax, in)) - { - if (in->eof) - { - if (fax->bidx > 31) - { - if (fax->a > 0) - goto eol; - goto rtc; - } - } - else - { - return fz_ioneedin; - } - } - - if ((fax->word >> (32 - 12)) == 0) - { - eatbits(fax, 1); - goto loop; - } - - if ((fax->word >> (32 - 12)) == 1) - { - eatbits(fax, 12); - fax->eolc ++; - - if (fax->k > 0) - { - if ((fax->word >> (32 - 1)) == 1) - fax->dim = 1; - else - fax->dim = 2; - eatbits(fax, 1); - } - } - else if (fax->dim == 1) - { - fax->eolc = 0; - error = dec1d(fax); - if (error) return error; - - } - else if (fax->dim == 2) - { - fax->eolc = 0; - error = dec2d(fax); - if (error) return error; - } - - /* no eol check after makeup codes nor in the middle of an H code */ - if (fax->stage == SMAKEUP || fax->stage == SH1 || fax->stage == SH2) - 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 = SEOL; - if (out->wp + fax->stride > out->ep) - return fz_ioneedout; - - if (fax->blackis1) - memcpy(out->wp, fax->dst, fax->stride); - else - for (i = 0; i < fax->stride; i++) - out->wp[i] = ~fax->dst[i]; - - memcpy(fax->ref, fax->dst, fax->stride); - memset(fax->dst, 0, fax->stride); - out->wp += fax->stride; - - fax->stage = SNORMAL; - fax->c = 0; - fax->a = -1; - fax->ridx ++; - - if (!fax->endofblock && 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) - { - if (fax->ridx % fax->k == 0) - fax->dim = 1; - else - fax->dim = 2; - } - - /* if endofline & encodedbytealign, EOLs are *not* optional */ - if (fax->encodedbytealign) - { - if (fax->endofline) - eatbits(fax, (12 - fax->bidx) & 7); - else - eatbits(fax, (8 - fax->bidx) & 7); - } - - goto loop; - -rtc: - i = (32 - fax->bidx) / 8; - while (i-- && in->rp > in->bp) - in->rp --; - - out->eof = 1; - return fz_iodone; -} - diff --git a/filter/faxd.h b/filter/faxd.h deleted file mode 100644 index 9f3fb470..00000000 --- a/filter/faxd.h +++ /dev/null @@ -1,61 +0,0 @@ -/* Fax G3/G4 tables */ - -/* - the first 2^(initialbits) entries map bit patterns to decodes - let's say initial_bits is 8 for the sake of example - and that the code is 1001 - that means that entries 0x90 .. 0x9f have the entry { val, 4 } - because those are all the bytes that start with the code - and the 4 is the length of the code -... if (n_bits > initial_bits) ... - anyway, in that case, it basically points to a mini table - the n_bits is the maximum length of all codes beginning with that byte - so 2^(n_bits - initial_bits) is the size of the mini-table - 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 -}; - -/* Decoding tables */ - -extern const cfd_node cf_white_decode[]; -extern const cfd_node cf_black_decode[]; -extern const cfd_node cf_2d_decode[]; -extern const cfd_node cf_uncompressed_decode[]; - diff --git a/filter/faxdtab.c b/filter/faxdtab.c deleted file mode 100644 index 8e387d03..00000000 --- a/filter/faxdtab.c +++ /dev/null @@ -1,931 +0,0 @@ -/* Tables for CCITTFaxDecode filter. */ - -/* This file was generated automatically. It is governed by the same terms */ -/* as the files scfetab.c and scfdgen.c from which it was derived. */ -/* Consult those files for the licensing terms and conditions. */ - -#include "faxd.h" - -/* 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 } -}; - -/* Dummy executable code to pacify compilers. */ -void scfdtab_dummy(void) { } - diff --git a/filter/faxe.c b/filter/faxe.c deleted file mode 100644 index e96c5ace..00000000 --- a/filter/faxe.c +++ /dev/null @@ -1,398 +0,0 @@ -#include - -#include "faxe.h" -#include "faxc.h" - -/* TODO: honor Rows param */ - -typedef struct fz_faxe_s fz_faxe; - -struct fz_faxe_s -{ - fz_filter super; - - int k; - int endofline; - int encodedbytealign; - int columns; - int endofblock; - int blackis1; - - int stride; - int ridx; /* how many rows in total */ - int bidx; /* how many bits are already used in out->wp */ - unsigned char bsave; /* partial byte saved between process() calls */ - - int stage; - int a0, c; /* mid-line coding state */ - - unsigned char *ref; - unsigned char *src; -}; - -fz_error * -fz_newfaxe(fz_filter **fp, fz_obj *params) -{ - fz_obj *obj; - - FZ_NEWFILTER(fz_faxe, fax, faxe); - - fax->ref = nil; - fax->src = nil; - - fax->k = 0; - fax->endofline = 0; - fax->encodedbytealign = 0; - fax->columns = 1728; - fax->endofblock = 1; - fax->blackis1 = 0; - - obj = fz_dictgets(params, "K"); - if (obj) fax->k = fz_toint(obj); - - obj = fz_dictgets(params, "EndOfLine"); - if (obj) fax->endofline = fz_tobool(obj); - - obj = fz_dictgets(params, "EncodedByteAlign"); - if (obj) fax->encodedbytealign = fz_tobool(obj); - - obj = fz_dictgets(params, "Columns"); - if (obj) fax->columns = fz_toint(obj); - - obj = fz_dictgets(params, "EndOfBlock"); - if (obj) fax->endofblock = fz_tobool(obj); - - obj = fz_dictgets(params, "BlackIs1"); - if (obj) fax->blackis1 = fz_tobool(obj); - - fax->stride = ((fax->columns - 1) >> 3) + 1; - fax->bidx = 0; - fax->ridx = 0; - - fax->stage = 0; - fax->a0 = -1; - fax->c = 0; - - fax->ref = fz_malloc(fax->stride); - if (!fax->ref) { fz_free(fax); return fz_outofmem; } - - fax->src = fz_malloc(fax->stride); - if (!fax->src) { fz_free(fax); fz_free(fax->ref); return fz_outofmem; } - - memset(fax->ref, 0, fax->stride); - memset(fax->src, 0, fax->stride); - - return nil; -} - -void -fz_dropfaxe(fz_filter *p) -{ - fz_faxe *fax = (fz_faxe*) p; - fz_free(fax->src); - fz_free(fax->ref); -} - -enum { codebytes = 2 }; - -static inline int runbytes(int run) -{ - int m = (run / 64) / 40 + 1; /* number of makeup codes */ - return codebytes * (m + 1); /* bytes for makeup + term codes */ -} - -static void -putbits(fz_faxe *fax, fz_buffer *out, int code, int nbits) -{ - while (nbits > 0) - { - if (fax->bidx == 0) - *out->wp = 0; - - /* code does not fit: shift right */ - if (nbits > (8 - fax->bidx)) - { - *out->wp |= code >> (nbits - (8 - fax->bidx)); - nbits = nbits - (8 - fax->bidx); - fax->bidx = 0; - out->wp ++; - } - - /* shift left */ - else - { - *out->wp |= code << ((8 - fax->bidx) - nbits); - fax->bidx += nbits; - if (fax->bidx == 8) - { - fax->bidx = 0; - out->wp ++; - } - nbits = 0; - } - } -} - -static inline void -putcode(fz_faxe *fax, fz_buffer *out, const cfe_code *run) -{ - putbits(fax, out, run->code, run->nbits); -} - -static void -putrun(fz_faxe *fax, fz_buffer *out, int run, int c) -{ - int m; - - const cf_runs *codetable = c ? &cf_black_runs : &cf_white_runs; - - if (run > 63) - { - m = run / 64; - while (m > 40) - { - putcode(fax, out, &codetable->makeup[40]); - m -= 40; - } - if (m > 0) - { - putcode(fax, out, &codetable->makeup[m]); - } - putcode(fax, out, &codetable->termination[run % 64]); - } - else - { - putcode(fax, out, &codetable->termination[run]); - } -} - -static fz_error * -enc1d(fz_faxe *fax, unsigned char *line, fz_buffer *out) -{ - int run; - - if (fax->a0 < 0) - fax->a0 = 0; - - while (fax->a0 < fax->columns) - { - run = getrun(line, fax->a0, fax->columns, fax->c); - - if (out->wp + 1 + runbytes(run) > out->ep) - return fz_ioneedout; - - putrun(fax, out, run, fax->c); - - fax->a0 += run; - fax->c = !fax->c; - } - - return 0; -} - -static fz_error * -enc2d(fz_faxe *fax, unsigned char *ref, unsigned char *src, fz_buffer *out) -{ - int a1, a2, b1, b2; - int run1, run2, n; - - while (fax->a0 < fax->columns) - { - a1 = findchanging(src, fax->a0, fax->columns); - b1 = findchangingcolor(ref, fax->a0, fax->columns, !fax->c); - b2 = findchanging(ref, b1, fax->columns); - - /* pass */ - if (b2 < a1) - { - if (out->wp + 1 + codebytes > out->ep) - return fz_ioneedout; - - putcode(fax, out, &cf2_run_pass); - - fax->a0 = b2; - } - - /* vertical */ - else if (ABS(b1 - a1) <= 3) - { - if (out->wp + 1 + codebytes > out->ep) - return fz_ioneedout; - - putcode(fax, out, &cf2_run_vertical[b1 - a1 + 3]); - - fax->a0 = a1; - fax->c = !fax->c; - } - - /* horizontal */ - else - { - a2 = findchanging(src, a1, fax->columns); - run1 = a1 - fax->a0; - run2 = a2 - a1; - n = codebytes + runbytes(run1) + runbytes(run2); - - if (out->wp + 1 + n > out->ep) - return fz_ioneedout; - - putcode(fax, out, &cf2_run_horizontal); - putrun(fax, out, run1, fax->c); - putrun(fax, out, run2, !fax->c); - - fax->a0 = a2; - } - } - - return 0; -} - -static fz_error * -process(fz_faxe *fax, fz_buffer *in, fz_buffer *out) -{ - fz_error *error; - int i, n; - - while (1) - { - if (in->rp == in->wp && in->eof) - goto rtc; - - switch (fax->stage) - { - case 0: - if (fax->encodedbytealign) - { - if (fax->endofline) - { - if (out->wp + 1 + 1 > out->ep) - return fz_ioneedout; - - /* make sure that EOL ends on a byte border */ - putbits(fax, out, 0, (12 - fax->bidx) & 7); - } - else - { - if (fax->bidx) - { - if (out->wp + 1 > out->ep) - return fz_ioneedout; - fax->bidx = 0; - out->wp ++; - } - } - } - - fax->stage ++; - - case 1: - if (fax->endofline) - { - if (out->wp + 1 + codebytes + 1 > out->ep) - return fz_ioneedout; - - if (fax->k > 0) - { - if (fax->ridx % fax->k == 0) - putcode(fax, out, &cf2_run_eol_1d); - else - putcode(fax, out, &cf2_run_eol_2d); - } - else - { - putcode(fax, out, &cf_run_eol); - } - } - - fax->stage ++; - - case 2: - if (in->rp + fax->stride > in->wp) - { - if (in->eof) /* XXX barf here? */ - goto rtc; - return fz_ioneedin; - } - - memcpy(fax->ref, fax->src, fax->stride); - memcpy(fax->src, in->rp, fax->stride); - - if (!fax->blackis1) - { - for (i = 0; i < fax->stride; i++) - fax->src[i] = ~fax->src[i]; - } - - in->rp += fax->stride; - - fax->c = 0; - fax->a0 = -1; - - fax->stage ++; - - case 3: - error = 0; /* to silence compiler */ - - if (fax->k < 0) - error = enc2d(fax, fax->ref, fax->src, out); - - else if (fax->k == 0) - error = enc1d(fax, fax->src, out); - - else if (fax->k > 0) - { - if (fax->ridx % fax->k == 0) - error = enc1d(fax, fax->src, out); - else - error = enc2d(fax, fax->ref, fax->src, out); - } - - if (error) - return error; - - fax->ridx ++; - - fax->stage = 0; - } - } - -rtc: - if (fax->endofblock) - { - n = fax->k < 0 ? 2 : 6; - - if (out->wp + 1 + codebytes * n > out->ep) - return fz_ioneedout; - - for (i = 0; i < n; i++) - { - putcode(fax, out, &cf_run_eol); - if (fax->k > 0) - putbits(fax, out, 1, 1); - } - } - - if (fax->bidx) - out->wp ++; - out->eof = 1; - - return fz_iodone; -} - -fz_error * -fz_processfaxe(fz_filter *p, fz_buffer *in, fz_buffer *out) -{ - fz_faxe *fax = (fz_faxe*) p; - fz_error *error; - - /* restore partial bits */ - *out->wp = fax->bsave; - - error = process(fax, in, out); - - /* save partial bits */ - fax->bsave = *out->wp; - - return error; -} - diff --git a/filter/faxe.h b/filter/faxe.h deleted file mode 100644 index dd3fc121..00000000 --- a/filter/faxe.h +++ /dev/null @@ -1,37 +0,0 @@ -/* Fax G3/G4 tables */ - -typedef struct cfe_code_s cfe_code; - -struct cfe_code_s -{ - unsigned short code; - unsigned short nbits; -}; - -typedef struct cf_runs_s { - cfe_code termination[64]; - cfe_code makeup[41]; -} cf_runs; - -/* Encoding tables */ - -/* Codes common to 1-D and 2-D encoding. */ -extern const cfe_code cf_run_eol; -extern const cf_runs cf_white_runs, cf_black_runs; -extern const cfe_code cf_uncompressed[6]; -extern const cfe_code cf_uncompressed_exit[10]; /* indexed by 2 x length of */ - -/* 1-D encoding. */ -extern const cfe_code cf1_run_uncompressed; - -/* 2-D encoding. */ -enum { cf2_run_vertical_offset = 3 }; -extern const cfe_code cf2_run_pass; -extern const cfe_code cf2_run_vertical[7]; /* indexed by b1 - a1 + offset */ -extern const cfe_code cf2_run_horizontal; -extern const cfe_code cf2_run_uncompressed; - -/* 2-D Group 3 encoding. */ -extern const cfe_code cf2_run_eol_1d; -extern const cfe_code cf2_run_eol_2d; - diff --git a/filter/faxetab.c b/filter/faxetab.c deleted file mode 100644 index 409039f4..00000000 --- a/filter/faxetab.c +++ /dev/null @@ -1,131 +0,0 @@ -/* Tables for CCITTFaxEncode filter */ - -#include "faxe.h" - -/* Define the end-of-line code. */ -const cfe_code cf_run_eol = {1, 12}; - -/* Define the 1-D code that signals uncompressed data. */ -const cfe_code cf1_run_uncompressed = {0xf, 12}; - -/* Define the 2-D run codes. */ -const cfe_code cf2_run_pass = {0x1, 4}; -const cfe_code cf2_run_vertical[7] = -{ - {0x3, 7}, - {0x3, 6}, - {0x3, 3}, - {0x1, 1}, - {0x2, 3}, - {0x2, 6}, - {0x2, 7} -}; -const cfe_code cf2_run_horizontal = {1, 3}; -const cfe_code cf2_run_uncompressed = {0xf, 10}; - -/* EOL codes for Group 3 2-D. */ -const cfe_code cf2_run_eol_1d = { (1 << 1) + 1, 12 + 1}; -const cfe_code cf2_run_eol_2d = { (1 << 1) + 0, 12 + 1}; - -/* White run codes. */ -const cf_runs cf_white_runs = -{ - /* Termination codes */ - { - {0x35, 8}, {0x7, 6}, {0x7, 4}, {0x8, 4}, - {0xb, 4}, {0xc, 4}, {0xe, 4}, {0xf, 4}, - {0x13, 5}, {0x14, 5}, {0x7, 5}, {0x8, 5}, - {0x8, 6}, {0x3, 6}, {0x34, 6}, {0x35, 6}, - {0x2a, 6}, {0x2b, 6}, {0x27, 7}, {0xc, 7}, - {0x8, 7}, {0x17, 7}, {0x3, 7}, {0x4, 7}, - {0x28, 7}, {0x2b, 7}, {0x13, 7}, {0x24, 7}, - {0x18, 7}, {0x2, 8}, {0x3, 8}, {0x1a, 8}, - {0x1b, 8}, {0x12, 8}, {0x13, 8}, {0x14, 8}, - {0x15, 8}, {0x16, 8}, {0x17, 8}, {0x28, 8}, - {0x29, 8}, {0x2a, 8}, {0x2b, 8}, {0x2c, 8}, - {0x2d, 8}, {0x4, 8}, {0x5, 8}, {0xa, 8}, - {0xb, 8}, {0x52, 8}, {0x53, 8}, {0x54, 8}, - {0x55, 8}, {0x24, 8}, {0x25, 8}, {0x58, 8}, - {0x59, 8}, {0x5a, 8}, {0x5b, 8}, {0x4a, 8}, - {0x4b, 8}, {0x32, 8}, {0x33, 8}, {0x34, 8} - }, - - /* Make-up codes */ - { - {0, 0} /* dummy */ , {0x1b, 5}, {0x12, 5}, {0x17, 6}, - {0x37, 7}, {0x36, 8}, {0x37, 8}, {0x64, 8}, - {0x65, 8}, {0x68, 8}, {0x67, 8}, {0xcc, 9}, - {0xcd, 9}, {0xd2, 9}, {0xd3, 9}, {0xd4, 9}, - {0xd5, 9}, {0xd6, 9}, {0xd7, 9}, {0xd8, 9}, - {0xd9, 9}, {0xda, 9}, {0xdb, 9}, {0x98, 9}, - {0x99, 9}, {0x9a, 9}, {0x18, 6}, {0x9b, 9}, - {0x8, 11}, {0xc, 11}, {0xd, 11}, {0x12, 12}, - {0x13, 12}, {0x14, 12}, {0x15, 12}, {0x16, 12}, - {0x17, 12}, {0x1c, 12}, {0x1d, 12}, {0x1e, 12}, - {0x1f, 12} - } -}; - -/* Black run codes. */ -const cf_runs cf_black_runs = -{ - /* Termination codes */ - { - {0x37, 10}, {0x2, 3}, {0x3, 2}, {0x2, 2}, - {0x3, 3}, {0x3, 4}, {0x2, 4}, {0x3, 5}, - {0x5, 6}, {0x4, 6}, {0x4, 7}, {0x5, 7}, - {0x7, 7}, {0x4, 8}, {0x7, 8}, {0x18, 9}, - {0x17, 10}, {0x18, 10}, {0x8, 10}, {0x67, 11}, - {0x68, 11}, {0x6c, 11}, {0x37, 11}, {0x28, 11}, - {0x17, 11}, {0x18, 11}, {0xca, 12}, {0xcb, 12}, - {0xcc, 12}, {0xcd, 12}, {0x68, 12}, {0x69, 12}, - {0x6a, 12}, {0x6b, 12}, {0xd2, 12}, {0xd3, 12}, - {0xd4, 12}, {0xd5, 12}, {0xd6, 12}, {0xd7, 12}, - {0x6c, 12}, {0x6d, 12}, {0xda, 12}, {0xdb, 12}, - {0x54, 12}, {0x55, 12}, {0x56, 12}, {0x57, 12}, - {0x64, 12}, {0x65, 12}, {0x52, 12}, {0x53, 12}, - {0x24, 12}, {0x37, 12}, {0x38, 12}, {0x27, 12}, - {0x28, 12}, {0x58, 12}, {0x59, 12}, {0x2b, 12}, - {0x2c, 12}, {0x5a, 12}, {0x66, 12}, {0x67, 12} - }, - - /* Make-up codes. */ - { - {0, 0} /* dummy */ , {0xf, 10}, {0xc8, 12}, {0xc9, 12}, - {0x5b, 12}, {0x33, 12}, {0x34, 12}, {0x35, 12}, - {0x6c, 13}, {0x6d, 13}, {0x4a, 13}, {0x4b, 13}, - {0x4c, 13}, {0x4d, 13}, {0x72, 13}, {0x73, 13}, - {0x74, 13}, {0x75, 13}, {0x76, 13}, {0x77, 13}, - {0x52, 13}, {0x53, 13}, {0x54, 13}, {0x55, 13}, - {0x5a, 13}, {0x5b, 13}, {0x64, 13}, {0x65, 13}, - {0x8, 11}, {0xc, 11}, {0xd, 11}, {0x12, 12}, - {0x13, 12}, {0x14, 12}, {0x15, 12}, {0x16, 12}, - {0x17, 12}, {0x1c, 12}, {0x1d, 12}, {0x1e, 12}, - {0x1f, 12} - } -}; - -/* Uncompressed codes. */ -const cfe_code cf_uncompressed[6] = -{ - {1, 1}, - {1, 2}, - {1, 3}, - {1, 4}, - {1, 5}, - {1, 6} -}; - -/* Uncompressed exit codes. */ -const cfe_code cf_uncompressed_exit[10] = -{ - {2, 8}, {3, 8}, - {2, 9}, {3, 9}, - {2, 10}, {3, 10}, - {2, 11}, {3, 11}, - {2, 12}, {3, 12} -}; - -/* Some C compilers insist on having executable code in every file.... */ -void scfetab_dummy(void) { } - diff --git a/filter/filec.c b/filter/filec.c deleted file mode 100644 index 05813185..00000000 --- a/filter/filec.c +++ /dev/null @@ -1,349 +0,0 @@ -#include - -fz_error * -fz_ferror(fz_file *f) -{ - fz_error *e = f->error; - f->error = nil; - return e; -} - -fz_error * -fz_openfile(fz_file **filep, char *path, int mode) -{ - fz_error *error; - fz_file *file; - int realmode; - int fd; - int n; - - assert(mode == FZ_READ || mode == FZ_WRITE || mode == FZ_APPEND); - - realmode = 0; - if (mode == FZ_READ) - realmode = O_BINARY | O_RDONLY; - if (mode == FZ_WRITE) - realmode = O_BINARY | O_WRONLY | O_CREAT | O_TRUNC; - if (mode == FZ_APPEND) - realmode = O_BINARY | O_WRONLY; - - fd = open(path, realmode, 0644); - if (fd == -1) - return fz_throw("ioerror: open '%s': %s", path, strerror(errno)); - - if (mode == FZ_APPEND) - { - mode = FZ_WRITE; - n = lseek(fd, 0, 2); - if (n == -1) { - error = fz_throw("ioerror: lseek: %s", strerror(errno)); - close(fd); - return error; - } - } - - file = *filep = fz_malloc(sizeof(fz_file)); - if (!file) - return fz_outofmem; - - file->mode = mode; - file->fd = fd; - file->depth = 0; - file->error = nil; - file->filter = nil; - file->in = nil; - file->out = nil; - - error = fz_newbuffer(&file->in, FZ_BUFSIZE); - if (error) - goto cleanup; - - error = fz_newbuffer(&file->out, FZ_BUFSIZE); - if (error) - goto cleanup; - - return nil; - -cleanup: - *filep = nil; - close(fd); - fz_dropbuffer(file->out); - fz_dropbuffer(file->in); - fz_free(file); - return error; -} - -fz_error * -fz_openbuffer(fz_file **filep, fz_buffer *buf, int mode) -{ - fz_error *error; - fz_file *file; - - assert(mode == FZ_READ || mode == FZ_WRITE); - - file = *filep = fz_malloc(sizeof(fz_file)); - if (!file) - return fz_outofmem; - - file->mode = mode; - file->fd = -1; - file->depth = 0; - file->error = nil; - file->filter = nil; - - if (mode == FZ_READ) - { - file->out = fz_keepbuffer(buf); - error = fz_newbuffer(&file->in, FZ_BUFSIZE); - if (error) - goto cleanup; - } - - else - { - error = fz_newbuffer(&file->out, FZ_BUFSIZE); - if (error) - goto cleanup; - file->in = fz_keepbuffer(buf); - } - - return nil; - -cleanup: - *filep = nil; - fz_free(file); - return error; -} - -void -fz_closefile(fz_file *file) -{ - assert(file->depth == 0); - - if (file->mode == FZ_WRITE) - fz_flush(file); - - if (file->error) - { - fz_warn("%s", file->error->msg); - fz_droperror(file->error); - file->error = nil; - } - - if (file->fd != -1) /* open to real file */ - close(file->fd); - - fz_dropbuffer(file->in); - fz_dropbuffer(file->out); - - if (file->filter) - fz_dropfilter(file->filter); - - fz_free(file); -} - -fz_error * -fz_pushfilter(fz_file *file, fz_filter *filter) -{ - fz_error *error; - - /* without a filter, one buffer is ignored: unignore. */ - if (file->depth == 0) - { - fz_buffer *buf; - - buf = file->out; - file->out = file->in; - file->in = buf; - - if (file->mode == FZ_READ) - { - file->out->rp = file->out->bp; - file->out->wp = file->out->bp; - file->out->eof = 0; - } - else - { - file->out->eof = 0; - file->in->rp = file->in->bp; - file->in->wp = file->in->bp; - file->in->eof = 0; - } - - file->filter = fz_keepfilter(filter); - } - - else - { - if (file->mode == FZ_READ) - { - error = fz_chainpipeline(&file->filter, file->filter, filter, file->out); - if (error) - return error; - - error = fz_newbuffer(&file->out, FZ_BUFSIZE); - if (error) - { - fz_unchainpipeline(file->filter, &file->filter, &file->out); - return error; - } - } - - else - { - error = fz_chainpipeline(&file->filter, filter, file->filter, file->in); - if (error) - return error; - - error = fz_newbuffer(&file->in, FZ_BUFSIZE); - if (error) - { - fz_unchainpipeline(file->filter, &file->filter, &file->in); - return error; - } - } - } - - file->depth ++; - - return nil; -} - -void -fz_popfilter(fz_file *file) -{ - fz_buffer *buf; - - assert(file->depth > 0); - - if (file->mode == FZ_WRITE) - fz_flush(file); - - if (file->error) - { - fz_warn("%s", file->error->msg); - fz_droperror(file->error); - file->error = nil; - } - - if (file->depth == 1) - { - fz_dropfilter(file->filter); - file->filter = nil; - - buf = file->out; - file->out = file->in; - file->in = buf; - } - else - { - if (file->mode == FZ_READ) - { - fz_dropbuffer(file->out); - fz_unchainpipeline(file->filter, &file->filter, &file->out); - } - else - { - fz_dropbuffer(file->in); - fz_unchainpipeline(file->filter, &file->filter, &file->in); - } - } - - file->depth --; -} - -int -fz_seek(fz_file *f, int ofs, int whence) -{ - int t; - int c; - - if (f->filter) - { - assert(f->mode == FZ_READ && whence == 0); - - if (ofs < fz_tell(f)) - { - f->error = fz_throw("ioerror: cannot seek backwards in filter"); - return -1; - } - while (fz_tell(f) < ofs) - { - c = fz_readbyte(f); - if (c == EOF) - return -1; - } - return ofs; - } - - if (whence == 1) - { - ofs = fz_tell(f) + ofs; - whence = 0; - } - - if (f->fd == -1) - { - if (whence == 0) - { - if (f->mode == FZ_READ) - f->out->rp = CLAMP(f->out->bp + ofs, f->out->bp, f->in->ep); - else - f->in->wp = CLAMP(f->in->bp + ofs, f->in->bp, f->in->ep); - } - else - { - if (f->mode == FZ_READ) - f->out->rp = CLAMP(f->out->ep + ofs, f->out->bp, f->in->ep); - else - f->in->wp = CLAMP(f->in->ep + ofs, f->in->bp, f->in->ep); - } - return fz_tell(f); - } - - t = lseek(f->fd, ofs, whence); - if (t == -1) - { - f->error = fz_throw("ioerror: lseek: %s", strerror(errno)); - return -1; - } - - f->out->rp = f->out->bp; - f->out->wp = f->out->bp; - f->out->eof = 0; - - return t; -} - -int -fz_tell(fz_file *f) -{ - int t; - - if (f->filter) - { - assert(f->mode == FZ_READ); - return f->filter->count - (f->out->wp - f->out->rp); - } - - if (f->fd == -1) - { - if (f->mode == FZ_READ) - return f->out->rp - f->out->bp; - else - return f->in->wp - f->in->bp; - } - - t = lseek(f->fd, 0, 1); - if (t == -1) - { - f->error = fz_throw("ioerror: lseek: %s", strerror(errno)); - return -1; - } - - if (f->mode == FZ_READ) - return t - (f->out->wp - f->out->rp); - else - return t + (f->in->wp - f->in->rp); -} - diff --git a/filter/filer.c b/filter/filer.c deleted file mode 100644 index a63a7dd2..00000000 --- a/filter/filer.c +++ /dev/null @@ -1,252 +0,0 @@ -#include - -static int doread(fz_buffer *b, int fd) -{ - int n = read(fd, b->wp, b->ep - b->wp); - if (n == -1) - return -1; - if (n == 0) - b->eof = 1; - b->wp += n; - return n; -} - -int fz_producedata(fz_file *f) -{ - fz_error *reason; - int produced; - int n; - - assert(f->mode == FZ_READ); - assert(f->error == nil); - - if (!f->filter) - { - fz_rewindbuffer(f->out); - n = doread(f->out, f->fd); - if (n < 0) { - f->error = fz_throw("ioerror in read: %s", strerror(errno)); - return -1; - } - return 0; - } - - produced = 0; - - while (1) - { - reason = fz_process(f->filter, f->in, f->out); - - if (f->filter->produced) - produced = 1; - - if (reason == fz_ioneedin) - { - if (f->in->eof) { - f->error = fz_throw("ioerror: premature eof in filter"); - return -1; - } - - /* no space to produce, rewind or grow */ - if (f->in->wp == f->in->ep) - { - if (f->in->rp > f->in->bp) - f->error = fz_rewindbuffer(f->in); - else - f->error = fz_growbuffer(f->in); - if (f->error) - return -1; - } - - /* then fill with more input */ - n = doread(f->in, f->fd); - if (n < 0) { - f->error = fz_throw("ioerror in read: %s", strerror(errno)); - return -1; - } - - if (produced) - return 0; - } - - else if (reason == fz_ioneedout) - { - if (produced) - return 0; - - /* need more outspace, and produced no data */ - if (f->out->rp > f->out->bp) - f->error = fz_rewindbuffer(f->out); - else - f->error = fz_growbuffer(f->out); - if (f->error) - return -1; - } - - else if (reason == fz_iodone) - return 0; - - else { - f->error = reason; - return -1; - } - } -} - -int -fz_peekbyte(fz_file *f) -{ - if (f->out->rp == f->out->wp) - { - if (f->out->eof) return EOF; - if (fz_producedata(f)) return EOF; - } - - if (f->out->rp < f->out->wp) - return *f->out->rp; - - return EOF; -} - -int -fz_readbyte(fz_file *f) -{ - if (f->out->rp == f->out->wp) - { - if (f->out->eof) return EOF; - if (fz_producedata(f)) return EOF; - } - - if (f->out->rp < f->out->wp) - return *f->out->rp++; - - return EOF; -} - -int -fz_read(fz_file *f, unsigned char *buf, int n) -{ - int i = 0; - - while (i < n) - { - while (f->out->rp < f->out->wp && i < n) - buf[i++] = *f->out->rp ++; - - if (f->out->rp == f->out->wp) - { - if (f->out->eof) return i; - if (fz_producedata(f) < 0) return -1; - } - } - - return i; -} - -int -fz_readline(fz_file *f, char *buf, int n) -{ - int c = EOF; - char *s = buf; - - while (n > 1) - { - c = fz_readbyte(f); - if (c == EOF) - break; - if (c == '\r') { - c = fz_peekbyte(f); - if (c == '\n') - c = fz_readbyte(f); - break; - } - if (c == '\n') - break; - *s++ = c; - n--; - } - if (n) - *s = '\0'; - return s - buf; -} - -/* - * Utility function to consume contents of file stream into - * a freshly allocated buffer; realloced and trimmed to size. - */ - -enum { CHUNKSIZE = 1024 * 32 }; - -fz_error * -fz_readfile(fz_buffer **bufp, fz_file *file) -{ - fz_buffer *real; - unsigned char *newbuf; - unsigned char *buf; - int len; - int pos; - int n; - - *bufp = nil; - - len = 0; - pos = 0; - buf = nil; - - while (1) - { - if (len - pos == 0) - { - len += CHUNKSIZE; - newbuf = fz_realloc(buf, len); - if (!newbuf) - { - fz_free(buf); - return fz_outofmem; - } - buf = newbuf; - } - - n = fz_read(file, buf + pos, len - pos); - - if (n < 0) - { - fz_free(buf); - return fz_ferror(file); - } - - pos += n; - - if (n < CHUNKSIZE) - { - if (pos > 0) - { - newbuf = fz_realloc(buf, pos); - if (!newbuf) - { - fz_free(buf); - return fz_outofmem; - } - } - else newbuf = buf; - - real = *bufp = fz_malloc(sizeof(fz_buffer)); - if (!real) - { - fz_free(newbuf); - return fz_outofmem; - } - - real->refs = 1; - real->ownsdata = 1; - real->bp = buf; - real->rp = buf; - real->wp = buf + pos; - real->ep = buf + pos; - real->eof = 1; - - return nil; - } - } -} - diff --git a/filter/filew.c b/filter/filew.c deleted file mode 100644 index f83399a2..00000000 --- a/filter/filew.c +++ /dev/null @@ -1,260 +0,0 @@ -#include - -int -fz_printstring(fz_file *f, char *s) -{ - return fz_write(f, s, strlen(s)); -} - -int -fz_printobj(fz_file *file, fz_obj *obj, int tight) -{ - char buf[1024]; - char *ptr; - int n; - - n = fz_sprintobj(nil, 0, obj, tight); - if (n < sizeof buf) - { - fz_sprintobj(buf, sizeof buf, obj, tight); - return fz_write(file, buf, n); - } - else - { - ptr = fz_malloc(n); - if (!ptr) { - file->error = fz_outofmem; - return -1; - } - fz_sprintobj(ptr, n, obj, tight); - n = fz_write(file, ptr, n); - fz_free(ptr); - return n; - } -} - -int -fz_print(fz_file *f, char *fmt, ...) -{ - va_list ap; - char buf[1024]; - char *p; - int n; - - va_start(ap, fmt); - n = vsnprintf(buf, sizeof buf, fmt, ap); - va_end(ap); - - if (n < sizeof buf) - return fz_write(f, buf, n); - - p = fz_malloc(n); - if (!p) { - f->error = fz_outofmem; - return -1; - } - - va_start(ap, fmt); - vsnprintf(p, n, fmt, ap); - va_end(ap); - - n = fz_write(f, p, n); - - fz_free(p); - - return n; -} - -static int dowrite(fz_buffer *b, int fd) -{ - int n = write(fd, b->rp, b->wp - b->rp); - if (n == -1) - return -1; - b->rp += n; - return n; -} - -int -fz_write(fz_file *f, unsigned char *buf, int n) -{ - fz_error *reason; - int i = 0; - int x; - - assert(f->mode == FZ_WRITE); - assert(f->error == nil); - - if (!f->filter) - { - while (i < n) - { - while (f->in->wp < f->in->ep && i < n) - *f->in->wp++ = buf[i++]; - - if (f->in->wp == f->in->ep) - { - if (f->fd != -1) - { - x = dowrite(f->in, f->fd); - if (x < 0) { - f->error = fz_throw("ioerror in write: %s", strerror(errno)); - return -1; - } - } - - if (f->in->rp > f->in->bp) - f->error = fz_rewindbuffer(f->in); - else - f->error = fz_growbuffer(f->in); - if (f->error) - return -1; - } - } - - return 0; - } - - while (i < n) - { - while (f->in->wp < f->in->ep && i < n) - *f->in->wp++ = buf[i++]; - - if (f->in->wp == f->in->ep) - { - reason = fz_process(f->filter, f->in, f->out); - - if (reason == fz_ioneedin) - { - if (f->in->wp == f->in->ep) { - if (f->in->rp > f->in->bp) - f->error = fz_rewindbuffer(f->in); - else - f->error = fz_growbuffer(f->in); - if (f->error) - return -1; - } - } - - else if (reason == fz_ioneedout) - { - if (f->fd != -1) - { - x = dowrite(f->out, f->fd); - if (x < 0) { - f->error = fz_throw("ioerror in write: %s", strerror(errno)); - return -1; - } - } - - if (f->out->rp > f->out->bp) - f->error = fz_rewindbuffer(f->out); - else - f->error = fz_growbuffer(f->out); - if (f->error) - return -1; - } - - else if (reason == fz_iodone) - { - if (f->fd != -1) - { - while (f->out->rp < f->out->wp) - { - x = dowrite(f->out, f->fd); - if (x < 0) { - f->error = fz_throw("ioerror in write: %s", strerror(errno)); - return -1; - } - } - } - break; - } - - else { - f->error = reason; - return -1; - } - } - } - - return i; -} - -int -fz_flush(fz_file *f) -{ - fz_error *reason; - int n; - - assert(f->mode == FZ_WRITE); - assert(f->error == nil); - - f->in->eof = 1; - - if (!f->filter) - { - if (f->fd != -1) - { - while (f->in->rp < f->in->wp) - { - n = dowrite(f->in, f->fd); - if (n < 0) { - f->error = fz_throw("ioerror in write: %s", strerror(errno)); - return -1; - } - } - } - return 0; - } - - while (!f->out->eof) - { - reason = fz_process(f->filter, f->in, f->out); - - if (reason == fz_ioneedin) { - f->error = fz_throw("ioerror: premature eof in filter"); - return -1; - } - - else if (reason == fz_ioneedout) - { - if (f->fd != -1) - { - n = dowrite(f->out, f->fd); - if (n < 0) { - f->error = fz_throw("ioerror in write: %s", strerror(errno)); - return -1; - } - } - - if (f->out->rp > f->out->bp) - f->error = fz_rewindbuffer(f->out); - else - f->error = fz_growbuffer(f->out); - if (f->error) - return -1; - } - - else if (reason == fz_iodone) - { - if (f->fd != -1) - { - n = dowrite(f->out, f->fd); - if (n < 0) { - f->error = fz_throw("ioerror in write: %s", strerror(errno)); - return -1; - } - } - break; - } - - else - { - f->error = reason; - return -1; - } - } - - return 0; -} - diff --git a/filter/filter.c b/filter/filter.c deleted file mode 100644 index afe4feed..00000000 --- a/filter/filter.c +++ /dev/null @@ -1,51 +0,0 @@ -#include - -fz_error fz_kioneedin = { -1, "", "", "filter.c", 0 }; -fz_error fz_kioneedout = { -1, "", "", "filter.c", 0 }; -fz_error fz_kiodone = { -1, "", "", "filter.c", 0 }; - -fz_error * -fz_process(fz_filter *f, fz_buffer *in, fz_buffer *out) -{ - fz_error *reason; - unsigned char *oldrp; - unsigned char *oldwp; - - assert(!out->eof); - - oldrp = in->rp; - oldwp = out->wp; - - reason = f->process(f, in, out); - - assert(in->rp <= in->wp); - assert(out->wp <= out->ep); - - f->consumed = in->rp > oldrp; - f->produced = out->wp > oldwp; - f->count += out->wp - oldwp; - - if (reason != fz_ioneedin && reason != fz_ioneedout) - out->eof = 1; - - return reason; -} - -fz_filter * -fz_keepfilter(fz_filter *f) -{ - f->refs ++; - return f; -} - -void -fz_dropfilter(fz_filter *f) -{ - if (--f->refs == 0) - { - if (f->drop) - f->drop(f); - fz_free(f); - } -} - diff --git a/filter/flate.c b/filter/flate.c deleted file mode 100644 index c34a49b7..00000000 --- a/filter/flate.c +++ /dev/null @@ -1,176 +0,0 @@ -#include - -#include - -typedef struct fz_flate_s fz_flate; - -struct fz_flate_s -{ - fz_filter super; - z_stream z; -}; - -static void * -zmalloc(void *opaque, unsigned int items, unsigned int size) -{ - fz_memorycontext *mctx = (fz_memorycontext*)opaque; - return mctx->malloc(mctx, items * size); -} - -fz_error * -fz_newflated(fz_filter **fp, fz_obj *params) -{ - fz_error *eo; - int ei; - - FZ_NEWFILTER(fz_flate, f, flated); - - f->z.zalloc = zmalloc; - f->z.zfree = (void(*)(void*,void*))fz_currentmemorycontext()->free; - f->z.opaque = fz_currentmemorycontext(); - f->z.next_in = nil; - f->z.avail_in = 0; - - ei = inflateInit(&f->z); - if (ei != Z_OK) { - eo = fz_throw("ioerror: inflateInit: %s", f->z.msg); - fz_free(f); - return eo; - } - - return nil; -} - -void -fz_dropflated(fz_filter *f) -{ - z_streamp zp = &((fz_flate*)f)->z; - int err; - - err = inflateEnd(zp); - if (err != Z_OK) - fprintf(stderr, "inflateEnd: %s", zp->msg); -} - -fz_error * -fz_processflated(fz_filter *f, fz_buffer *in, fz_buffer *out) -{ - z_streamp zp = &((fz_flate*)f)->z; - int err; - - if (in->rp == in->wp && !in->eof) - return fz_ioneedin; - if (out->wp == out->ep) - return fz_ioneedout; - - zp->next_in = in->rp; - zp->avail_in = in->wp - in->rp; - - zp->next_out = out->wp; - zp->avail_out = out->ep - out->wp; - - err = inflate(zp, Z_NO_FLUSH); - - in->rp = in->wp - zp->avail_in; - out->wp = out->ep - zp->avail_out; - - if (err == Z_STREAM_END) { - out->eof = 1; - return fz_iodone; - } - else if (err == Z_OK) { - if (in->rp == in->wp && !in->eof) - return fz_ioneedin; - if (out->wp == out->ep) - return fz_ioneedout; - return fz_ioneedin; /* hmm, what's going on here? */ - } - else { - return fz_throw("ioerror: inflate: %s", zp->msg); - } -} - -fz_error * -fz_newflatee(fz_filter **fp, fz_obj *params) -{ - fz_obj *obj; - fz_error *eo; - int effort; - int ei; - - FZ_NEWFILTER(fz_flate, f, flatee); - - effort = -1; - - if (params) { - obj = fz_dictgets(params, "Effort"); - if (obj) effort = fz_toint(obj); - } - - f->z.zalloc = zmalloc; - f->z.zfree = (void(*)(void*,void*))fz_currentmemorycontext()->free; - f->z.opaque = fz_currentmemorycontext(); - f->z.next_in = nil; - f->z.avail_in = 0; - - ei = deflateInit(&f->z, effort); - if (ei != Z_OK) { - eo = fz_throw("ioerror: deflateInit: %s", f->z.msg); - fz_free(f); - return eo; - } - - return nil; -} - -void -fz_dropflatee(fz_filter *f) -{ - z_streamp zp = &((fz_flate*)f)->z; - int err; - - err = deflateEnd(zp); - if (err != Z_OK) - fprintf(stderr, "deflateEnd: %s", zp->msg); - - fz_free(f); -} - -fz_error * -fz_processflatee(fz_filter *f, fz_buffer *in, fz_buffer *out) -{ - z_streamp zp = &((fz_flate*)f)->z; - int err; - - if (in->rp == in->wp && !in->eof) - return fz_ioneedin; - if (out->wp == out->ep) - return fz_ioneedout; - - zp->next_in = in->rp; - zp->avail_in = in->wp - in->rp; - - zp->next_out = out->wp; - zp->avail_out = out->ep - out->wp; - - err = deflate(zp, in->eof ? Z_FINISH : Z_NO_FLUSH); - - in->rp = in->wp - zp->avail_in; - out->wp = out->ep - zp->avail_out; - - if (err == Z_STREAM_END) { - out->eof = 1; - return fz_iodone; - } - else if (err == Z_OK) { - if (in->rp == in->wp && !in->eof) - return fz_ioneedin; - if (out->wp == out->ep) - return fz_ioneedout; - return fz_ioneedin; /* hmm? */ - } - else { - return fz_throw("ioerror: deflate: %s", zp->msg); - } -} - diff --git a/filter/jbig2d.c b/filter/jbig2d.c deleted file mode 100644 index ed54eed3..00000000 --- a/filter/jbig2d.c +++ /dev/null @@ -1,115 +0,0 @@ -#include - -/* TODO: complete rewrite with error checking and use fitz memctx */ - -/* - so to use a global_ctx, you run your global data through a normal ctx - then call jbig2_make_global_ctx with the normal context - that does the (currently null) conversion - make_global_ctx after i fed it all the global stream data? - maskros: yes - and you pass the new global ctx object to jbig2_ctx_new() when you -+create the per-page ctx -*/ - -#ifdef WIN32 /* Microsoft Visual C++ */ - -typedef signed char int8_t; -typedef short int int16_t; -typedef int int32_t; -typedef __int64 int64_t; - -typedef unsigned char uint8_t; -typedef unsigned short int uint16_t; -typedef unsigned int uint32_t; - -#else -#include -#endif - -#include - -typedef struct fz_jbig2d_s fz_jbig2d; - -struct fz_jbig2d_s -{ - fz_filter super; - Jbig2Ctx *ctx; - Jbig2GlobalCtx *gctx; - Jbig2Image *page; - int idx; -}; - -fz_error * -fz_newjbig2d(fz_filter **fp, fz_obj *params) -{ - FZ_NEWFILTER(fz_jbig2d, d, jbig2d); - d->ctx = jbig2_ctx_new(nil, JBIG2_OPTIONS_EMBEDDED, nil, nil, nil); - d->page = nil; - d->idx = 0; - return nil; -} - -void -fz_dropjbig2d(fz_filter *filter) -{ - fz_jbig2d *d = (fz_jbig2d*)filter; - jbig2_ctx_free(d->ctx); -} - -fz_error * -fz_setjbig2dglobalstream(fz_filter *filter, unsigned char *buf, int len) -{ - fz_jbig2d *d = (fz_jbig2d*)filter; - jbig2_data_in(d->ctx, buf, len); - d->gctx = jbig2_make_global_ctx(d->ctx); - d->ctx = jbig2_ctx_new(nil, JBIG2_OPTIONS_EMBEDDED, d->gctx, nil, nil); - return nil; -} - -fz_error * -fz_processjbig2d(fz_filter *filter, fz_buffer *in, fz_buffer *out) -{ - fz_jbig2d *d = (fz_jbig2d*)filter; - int len; - int i; - - while (1) - { - if (in->rp == in->wp) { - if (!in->eof) - return fz_ioneedin; - - if (!d->page) { - jbig2_complete_page(d->ctx); - d->page = jbig2_page_out(d->ctx); - } - - if (out->wp == out->ep) - return fz_ioneedout; - - len = out->ep - out->wp; - if (d->idx + len > d->page->height * d->page->stride) - len = d->page->height * d->page->stride - d->idx; - - /* XXX memcpy(out->wp, d->page->data + d->idx, len); */ - for (i = 0; i < len; i++) - out->wp[i] = ~ d->page->data[d->idx + i]; - - out->wp += len; - d->idx += len; - - if (d->idx == d->page->height * d->page->stride) { - jbig2_release_page(d->ctx, d->page); - out->eof = 1; - return fz_iodone; - } - } - else { - len = in->wp - in->rp; - jbig2_data_in(d->ctx, in->rp, len); - in->rp += len; - } - } -} - diff --git a/filter/jpxd.c b/filter/jpxd.c deleted file mode 100644 index 2aa93448..00000000 --- a/filter/jpxd.c +++ /dev/null @@ -1,143 +0,0 @@ -#include - -/* TODO: bpc */ - -/* - * We use the Jasper JPEG2000 coder for now. - */ - -#include - -static char *colorspacename(jas_clrspc_t clrspc) -{ - switch (jas_clrspc_fam(clrspc)) - { - case JAS_CLRSPC_FAM_UNKNOWN: return "Unknown"; - case JAS_CLRSPC_FAM_XYZ: return "XYZ"; - case JAS_CLRSPC_FAM_LAB: return "Lab"; - case JAS_CLRSPC_FAM_GRAY: return "Gray"; - case JAS_CLRSPC_FAM_RGB: return "RGB"; - case JAS_CLRSPC_FAM_YCBCR: return "YCbCr"; - } - return "Unknown"; -} - -typedef struct fz_jpxd_s fz_jpxd; - -struct fz_jpxd_s -{ - fz_filter super; - jas_stream_t *stream; - jas_image_t *image; - int offset; - int stage; -}; - -fz_error * -fz_newjpxd(fz_filter **fp, fz_obj *params) -{ - int err; - - FZ_NEWFILTER(fz_jpxd, d, jpxd); - - err = jas_init(); - if (err) { - fz_free(d); - return fz_throw("ioerror in jpxd: jas_init()"); - } - - d->stream = jas_stream_memopen(nil, 0); - if (!d->stream) { - fz_free(d); - return fz_throw("ioerror in jpxd: jas_stream_memopen()"); - } - - d->image = nil; - d->offset = 0; - d->stage = 0; - - return nil; -} - -void -fz_dropjpxd(fz_filter *filter) -{ - fz_jpxd *d = (fz_jpxd*)filter; - if (d->stream) jas_stream_close(d->stream); - if (d->image) jas_image_destroy(d->image); -} - -fz_error * -fz_processjpxd(fz_filter *filter, fz_buffer *in, fz_buffer *out) -{ - fz_jpxd *d = (fz_jpxd*)filter; - int n, bpc, w, h; - int i, x, y; - - switch (d->stage) - { - case 0: goto input; - case 1: goto decode; - case 2: goto output; - } - -input: - while (in->rp < in->wp) { - n = jas_stream_write(d->stream, in->rp, in->wp - in->rp); - in->rp += n; - } - - if (!in->eof) - return fz_ioneedin; - - d->stage = 1; - -decode: - jas_stream_seek(d->stream, 0, 0); - - d->image = jas_image_decode(d->stream, -1, 0); - if (!d->image) - return fz_throw("ioerror in jpxd: unable to decode image data"); - - fprintf(stderr, "P%c\n# JPX %d x %d n=%d bpc=%d colorspace=%04x %s\n%d %d\n%d\n", - jas_image_numcmpts(d->image) == 1 ? '5' : '6', - - jas_image_width(d->image), - jas_image_height(d->image), - jas_image_numcmpts(d->image), - jas_image_cmptprec(d->image, 0), - jas_image_clrspc(d->image), - colorspacename(jas_image_clrspc(d->image)), - - jas_image_width(d->image), - jas_image_height(d->image), - (1 << jas_image_cmptprec(d->image, 0)) - 1); - - d->stage = 2; - -output: - w = jas_image_width(d->image); - h = jas_image_height(d->image); - n = jas_image_numcmpts(d->image); - bpc = jas_image_cmptprec(d->image, 0); /* use precision of first component for all... */ - - while (d->offset < w * h) - { - y = d->offset / w; - x = d->offset - y * w; - - /* FIXME bpc != 8 */ - - if (out->wp + n >= out->ep) - return fz_ioneedout; - - for (i = 0; i < n; i++) - *out->wp++ = jas_image_readcmptsample(d->image, i, x, y); - - d->offset ++; - } - - out->eof = 1; - return fz_iodone; -} - diff --git a/filter/lzwd.c b/filter/lzwd.c deleted file mode 100644 index 95fc462a..00000000 --- a/filter/lzwd.c +++ /dev/null @@ -1,253 +0,0 @@ -#include - -/* TODO: error checking */ - -enum -{ - MINBITS = 9, - MAXBITS = 12, - NUMCODES = (1 << MAXBITS), - LZW_CLEAR = 256, - LZW_EOD = 257, - LZW_FIRST = 258 -}; - -typedef struct lzw_code_s lzw_code; - -struct lzw_code_s -{ - int prev; /* prev code (in string) */ - unsigned short length; /* string len, including this token */ - unsigned char value; /* data value */ - unsigned char firstchar; /* first token of string */ -}; - -typedef struct fz_lzwd_s fz_lzwd; - -struct fz_lzwd_s -{ - fz_filter super; - - int earlychange; - - unsigned int word; /* bits loaded from data */ - int bidx; - - int resume; /* resume output of code from needout */ - int codebits; /* num bits/code */ - int code; /* current code */ - int oldcode; /* previously recognized code */ - int nextcode; /* next free entry */ - lzw_code table[NUMCODES]; -}; - -fz_error * -fz_newlzwd(fz_filter **fp, fz_obj *params) -{ - int i; - - FZ_NEWFILTER(fz_lzwd, lzw, lzwd); - - lzw->earlychange = 0; - - if (params) - { - fz_obj *obj; - obj = fz_dictgets(params, "EarlyChange"); - if (obj) lzw->earlychange = fz_toint(obj) != 0; - } - - lzw->bidx = 32; - lzw->word = 0; - - for (i = 0; i < 256; i++) - { - lzw->table[i].value = i; - lzw->table[i].firstchar = i; - lzw->table[i].length = 1; - lzw->table[i].prev = -1; - } - - for (i = LZW_FIRST; i < NUMCODES; i++) - { - lzw->table[i].value = 0; - lzw->table[i].firstchar = 0; - lzw->table[i].length = 0; - lzw->table[i].prev = -1; - } - - lzw->codebits = MINBITS; - lzw->code = -1; - lzw->nextcode = LZW_FIRST; - lzw->oldcode = -1; - lzw->resume = 0; - - return nil; -} - -void -fz_droplzwd(fz_filter *filter) -{ -} - -static inline void eatbits(fz_lzwd *lzw, int nbits) -{ - lzw->word <<= nbits; - lzw->bidx += nbits; -} - -static inline fz_error * fillbits(fz_lzwd *lzw, fz_buffer *in) -{ - while (lzw->bidx >= 8) - { - if (in->rp + 1 > in->wp) - return fz_ioneedin; - lzw->bidx -= 8; - lzw->word |= *in->rp << lzw->bidx; - in->rp ++; - } - return nil; -} - -static inline void unstuff(fz_lzwd *lzw, fz_buffer *in) -{ - int i = (32 - lzw->bidx) / 8; - while (i-- && in->rp > in->bp) - in->rp --; -} - -fz_error * -fz_processlzwd(fz_filter *filter, fz_buffer *in, fz_buffer *out) -{ - fz_lzwd *lzw = (fz_lzwd*)filter; - unsigned char *s; - int len; - - if (lzw->resume) - { - lzw->resume = 0; - goto output; - } - - while (1) - { - if (fillbits(lzw, in)) - { - if (in->eof) - { - if (lzw->bidx > 32 - lzw->codebits) - { - out->eof = 1; - unstuff(lzw, in); - return fz_iodone; - } - } - else - { - return fz_ioneedin; - } - } - - lzw->code = lzw->word >> (32 - lzw->codebits); - - if (lzw->code == LZW_EOD) - { - eatbits(lzw, lzw->codebits); - out->eof = 1; - unstuff(lzw, in); - return fz_iodone; - } - - if (lzw->code == LZW_CLEAR) - { - int oldcodebits = lzw->codebits; - - lzw->codebits = MINBITS; - lzw->nextcode = LZW_FIRST; - - lzw->code = lzw->word >> (32 - oldcodebits - MINBITS) & ((1 << MINBITS) - 1); - - if (lzw->code == LZW_EOD) - { - eatbits(lzw, oldcodebits + MINBITS); - out->eof = 1; - unstuff(lzw, in); - return fz_iodone; - } - - if (out->wp + 1 > out->ep) - return fz_ioneedout; - - *out->wp++ = lzw->code; - - lzw->oldcode = lzw->code; - - eatbits(lzw, oldcodebits + MINBITS); - - continue; - } - - eatbits(lzw, lzw->codebits); - - /* if stream starts without a clear code, oldcode is undefined... */ - if (lzw->oldcode == -1) - { - lzw->oldcode = lzw->code; - goto output; - } - - /* add new entry to the code table */ - lzw->table[lzw->nextcode].prev = lzw->oldcode; - lzw->table[lzw->nextcode].firstchar = lzw->table[lzw->oldcode].firstchar; - lzw->table[lzw->nextcode].length = lzw->table[lzw->oldcode].length + 1; - if (lzw->code < lzw->nextcode) - lzw->table[lzw->nextcode].value = lzw->table[lzw->code].firstchar; - else - lzw->table[lzw->nextcode].value = lzw->table[lzw->nextcode].firstchar; - - lzw->nextcode ++; - - if (lzw->nextcode >= (1 << lzw->codebits) - lzw->earlychange - 1) - { - lzw->codebits ++; - if (lzw->codebits > MAXBITS) - lzw->codebits = MAXBITS; /* FIXME */ - } - - lzw->oldcode = lzw->code; - -output: - /* code maps to a string, copy to output (in reverse...) */ - if (lzw->code > 255) - { - if (out->wp + lzw->table[lzw->code].length > out->ep) - { - lzw->resume = 1; - return fz_ioneedout; - } - - len = lzw->table[lzw->code].length; - s = out->wp + len; - - do - { - *(--s) = lzw->table[lzw->code].value; - lzw->code = lzw->table[lzw->code].prev; - } while (lzw->code >= 0 && s > out->wp); - out->wp += len; - } - - /* ... or just a single character */ - else - { - if (out->wp + 1 > out->ep) - { - lzw->resume = 1; - return fz_ioneedout; - } - - *out->wp++ = lzw->code; - } - } -} - diff --git a/filter/lzwe.c b/filter/lzwe.c deleted file mode 100644 index f2c3c7a4..00000000 --- a/filter/lzwe.c +++ /dev/null @@ -1,261 +0,0 @@ -#include - -#define noDEBUG 1 - -enum -{ - MINBITS = 9, - MAXBITS = 12, - MAXBYTES = 2, - NUMCODES = (1 << MAXBITS), - LZW_CLEAR = 256, - LZW_EOD = 257, - LZW_FIRST = 258, - HSIZE = 9001, /* 91% occupancy (???) */ - HSHIFT = (13 - 8) -}; - -typedef struct lzw_hash_s lzw_hash; - -struct lzw_hash_s -{ - int hash; - int code; -}; - -typedef struct fz_lzwe_s fz_lzwe; - -struct fz_lzwe_s -{ - fz_filter super; - - int earlychange; - - int bidx; /* partial bits used in out->wp */ - unsigned char bsave; /* partial byte saved between process() calls */ - - int resume; - int code; - int fcode; - int hcode; - - int codebits; - int oldcode; - int nextcode; - - lzw_hash table[HSIZE]; -}; - -static void -clearhash(fz_lzwe *lzw) -{ - int i; - for (i = 0; i < HSIZE; i++) - lzw->table[i].hash = -1; -} - -fz_error * -fz_newlzwe(fz_filter **fp, fz_obj *params) -{ - FZ_NEWFILTER(fz_lzwe, lzw, lzwe); - - lzw->earlychange = 0; - - if (params) - { - fz_obj *obj; - obj = fz_dictgets(params, "EarlyChange"); - if (obj) lzw->earlychange = fz_toint(obj) != 0; - } - - lzw->bidx = 0; - lzw->bsave = 0; - - lzw->resume = 0; - lzw->code = -1; - lzw->hcode = -1; - lzw->fcode = -1; - - lzw->codebits = MINBITS; - lzw->nextcode = LZW_FIRST; - lzw->oldcode = -1; /* generates LZW_CLEAR */ - - clearhash(lzw); - - return nil; -} - -void -fz_droplzwe(fz_filter *filter) -{ -} - -static void -putcode(fz_lzwe *lzw, fz_buffer *out, int code) -{ - int nbits = lzw->codebits; - - while (nbits > 0) - { - if (lzw->bidx == 0) - { - *out->wp = 0; - } - - /* code does not fit: shift right */ - if (nbits > (8 - lzw->bidx)) - { - *out->wp |= code >> (nbits - (8 - lzw->bidx)); - nbits = nbits - (8 - lzw->bidx); - lzw->bidx = 0; - out->wp ++; - } - - /* shift left */ - else - { - *out->wp |= code << ((8 - lzw->bidx) - nbits); - lzw->bidx += nbits; - if (lzw->bidx == 8) - { - lzw->bidx = 0; - out->wp ++; - } - nbits = 0; - } - } -} - - -static fz_error * -compress(fz_lzwe *lzw, fz_buffer *in, fz_buffer *out) -{ - if (lzw->resume) - { - lzw->resume = 0; - goto resume; - } - - /* at start of data, output a clear code */ - if (lzw->oldcode == -1) - { - if (out->wp + 3 > out->ep) - return fz_ioneedout; - - if (in->rp + 1 > in->wp) - { - if (in->eof) - goto eof; - return fz_ioneedin; - } - - putcode(lzw, out, LZW_CLEAR); - - lzw->oldcode = *in->rp++; - } - -begin: - while (1) - { - if (in->rp + 1 > in->wp) - { - if (in->eof) - goto eof; - return fz_ioneedin; - } - - /* read character */ - lzw->code = *in->rp++; - - /* hash string + character */ - lzw->fcode = (lzw->code << MAXBITS) + lzw->oldcode; - lzw->hcode = (lzw->code << HSHIFT) ^ lzw->oldcode; - - /* primary hash */ - if (lzw->table[lzw->hcode].hash == lzw->fcode) - { - lzw->oldcode = lzw->table[lzw->hcode].code; - continue; - } - - /* secondary hash */ - if (lzw->table[lzw->hcode].hash != -1) - { - int disp = HSIZE - lzw->hcode; - if (lzw->hcode == 0) - disp = 1; - do - { - lzw->hcode = lzw->hcode - disp; - if (lzw->hcode < 0) - lzw->hcode += HSIZE; - if (lzw->table[lzw->hcode].hash == lzw->fcode) - { - lzw->oldcode = lzw->table[lzw->hcode].code; - goto begin; - } - } while (lzw->table[lzw->hcode].hash != -1); - } - -resume: - /* new entry: emit code and add to table */ - - /* reserve space for this code and an eventual CLEAR code */ - if (out->wp + 5 > out->ep) - { - lzw->resume = 1; - return fz_ioneedout; - } - - putcode(lzw, out, lzw->oldcode); - - lzw->oldcode = lzw->code; - lzw->table[lzw->hcode].code = lzw->nextcode; - lzw->table[lzw->hcode].hash = lzw->fcode; - - lzw->nextcode ++; - - /* table is full: emit clear code and reset */ - if (lzw->nextcode == NUMCODES - 1) - { - putcode(lzw, out, LZW_CLEAR); - clearhash(lzw); - lzw->nextcode = LZW_FIRST; - lzw->codebits = MINBITS; - } - - /* check if next entry will be too big for the code size */ - else if (lzw->nextcode >= (1 << lzw->codebits) - lzw->earlychange) - { - lzw->codebits ++; - } - } - -eof: - if (out->wp + 5 > out->ep) - return fz_ioneedout; - - putcode(lzw, out, lzw->oldcode); - putcode(lzw, out, LZW_EOD); - - out->eof = 1; - return fz_iodone; -} - -fz_error * -fz_processlzwe(fz_filter *filter, fz_buffer *in, fz_buffer *out) -{ - fz_lzwe *lzw = (fz_lzwe*)filter; - fz_error *error; - - /* restore partial bits */ - *out->wp = lzw->bsave; - - error = compress(lzw, in, out); - - /* save partial bits */ - lzw->bsave = *out->wp; - - return error; -} - diff --git a/filter/null.c b/filter/null.c deleted file mode 100644 index e83b6d5a..00000000 --- a/filter/null.c +++ /dev/null @@ -1,50 +0,0 @@ -#include - -typedef struct fz_nullfilter_s fz_nullfilter; - -struct fz_nullfilter_s -{ - fz_filter super; - int len; - int cur; -}; - -fz_error * -fz_newnullfilter(fz_filter **fp, int len) -{ - FZ_NEWFILTER(fz_nullfilter, f, nullfilter); - f->len = len; - f->cur = 0; - return nil; -} - -void -fz_dropnullfilter(fz_filter *f) -{ -} - -fz_error * -fz_processnullfilter(fz_filter *filter, fz_buffer *in, fz_buffer *out) -{ - fz_nullfilter *f = (fz_nullfilter*)filter; - int n; - - n = MIN(MIN(in->wp - in->rp, out->ep - out->wp), f->len - f->cur); - - if (n) { - memcpy(out->wp, in->rp, n); - in->rp += n; - out->wp += n; - f->cur += n; - } - - if (f->cur == f->len) - return fz_iodone; - if (in->rp == in->wp) - return fz_ioneedin; - if (out->wp == out->ep) - return fz_ioneedout; - - return fz_throw("braindead programmer in nullfilter"); -} - diff --git a/filter/pipeline.c b/filter/pipeline.c deleted file mode 100644 index 7b7f4252..00000000 --- a/filter/pipeline.c +++ /dev/null @@ -1,128 +0,0 @@ -#include - -#define noDEBUG 1 - -typedef struct fz_pipeline_s fz_pipeline; - -fz_error * fz_processpipeline(fz_filter *filter, fz_buffer *in, fz_buffer *out); - -struct fz_pipeline_s -{ - fz_filter super; - fz_filter *head; - fz_buffer *buffer; - fz_filter *tail; - int tailneedsin; -}; - -fz_error * -fz_chainpipeline(fz_filter **fp, fz_filter *head, fz_filter *tail, fz_buffer *buf) -{ - FZ_NEWFILTER(fz_pipeline, p, pipeline); - p->head = fz_keepfilter(head); - p->tail = fz_keepfilter(tail); - p->tailneedsin = 1; - p->buffer = fz_keepbuffer(buf); - return nil; -} - -void -fz_unchainpipeline(fz_filter *filter, fz_filter **oldfp, fz_buffer **oldbp) -{ - fz_pipeline *p = (fz_pipeline*)filter; - - *oldfp = fz_keepfilter(p->head); - *oldbp = fz_keepbuffer(p->buffer); - - fz_dropfilter(filter); -} - -fz_error * -fz_newpipeline(fz_filter **fp, fz_filter *head, fz_filter *tail) -{ - fz_error *error; - - FZ_NEWFILTER(fz_pipeline, p, pipeline); - p->head = fz_keepfilter(head); - p->tail = fz_keepfilter(tail); - p->tailneedsin = 1; - - error = fz_newbuffer(&p->buffer, FZ_BUFSIZE); - if (error) { fz_free(p); return error; } - - return nil; -} - -void -fz_droppipeline(fz_filter *filter) -{ - fz_pipeline *p = (fz_pipeline*)filter; - fz_dropfilter(p->head); - fz_dropfilter(p->tail); - fz_dropbuffer(p->buffer); -} - -fz_error * -fz_processpipeline(fz_filter *filter, fz_buffer *in, fz_buffer *out) -{ - fz_pipeline *p = (fz_pipeline*)filter; - fz_error *e; - - if (p->buffer->eof) - goto tail; - - if (p->tailneedsin && p->head->produced) - goto tail; - -head: - e = fz_process(p->head, in, p->buffer); - - if (e == fz_ioneedin) - return fz_ioneedin; - - else if (e == fz_ioneedout) - { - if (p->tailneedsin && !p->head->produced) - { - fz_error *be = nil; - if (p->buffer->rp > p->buffer->bp) - be = fz_rewindbuffer(p->buffer); - else - be = fz_growbuffer(p->buffer); - if (be) - return be; - goto head; - } - goto tail; - } - - else if (e == fz_iodone) - goto tail; - - else - return e; - -tail: - e = fz_process(p->tail, p->buffer, out); - - if (e == fz_ioneedin) - { - if (p->buffer->eof) - return fz_throw("ioerror: premature eof in pipeline"); - p->tailneedsin = 1; - goto head; - } - - else if (e == fz_ioneedout) - { - p->tailneedsin = 0; - return fz_ioneedout; - } - - else if (e == fz_iodone) - return fz_iodone; - - else - return e; -} - diff --git a/filter/predict.c b/filter/predict.c deleted file mode 100644 index d7b594ac..00000000 --- a/filter/predict.c +++ /dev/null @@ -1,238 +0,0 @@ -#include - -/* TODO: check if this works with 16bpp images */ - -enum { MAXC = 16 }; - -typedef struct fz_predict_s fz_predict; - -struct fz_predict_s -{ - fz_filter super; - - int predictor; - int columns; - int colors; - int bpc; - - int stride; - int bpp; - unsigned char *ref; - - int encode; -}; - -fz_error * -fz_newpredict(fz_filter **fp, fz_obj *params, int encode) -{ - fz_obj *obj; - - FZ_NEWFILTER(fz_predict, p, predict); - - p->encode = encode; - - p->predictor = 1; - p->columns = 1; - p->colors = 1; - p->bpc = 8; - - obj = fz_dictgets(params, "Predictor"); - if (obj) p->predictor = fz_toint(obj); - - obj = fz_dictgets(params, "Columns"); - if (obj) p->columns = fz_toint(obj); - - obj = fz_dictgets(params, "Colors"); - if (obj) p->colors = fz_toint(obj); - - obj = fz_dictgets(params, "BitsPerComponent"); - if (obj) p->bpc = fz_toint(obj); - - p->stride = (p->bpc * p->colors * p->columns + 7) / 8; - p->bpp = (p->bpc * p->colors + 7) / 8; - - if (p->predictor >= 10) { - p->ref = fz_malloc(p->stride); - if (!p->ref) { fz_free(p); return fz_outofmem; } - memset(p->ref, 0, p->stride); - } - else { - p->ref = nil; - } - - return nil; -} - -void -fz_droppredict(fz_filter *filter) -{ - fz_predict *p = (fz_predict*)filter; - fz_free(p->ref); -} - -static inline int -getcomponent(unsigned char *buf, int x, int bpc) -{ - switch (bpc) - { - case 1: return buf[x / 8] >> (7 - (x % 8)) & 0x01; - case 2: return buf[x / 4] >> ((3 - (x % 4)) * 2) & 0x03; - case 4: return buf[x / 2] >> ((1 - (x % 2)) * 4) & 0x0f; - case 8: return buf[x]; - } - return 0; -} - -static inline void -putcomponent(unsigned char *buf, int x, int bpc, int value) -{ - switch (bpc) - { - case 1: buf[x / 8] |= value << (7 - (x % 8)); break; - case 2: buf[x / 4] |= value << ((3 - (x % 4)) * 2); break; - case 4: buf[x / 2] |= value << ((1 - (x % 2)) * 4); break; - case 8: buf[x] = value; break; - } -} - -static inline int -paeth(int a, int b, int c) -{ - /* The definitions of ac and bc are correct, not a typo. */ - int ac = b - c, bc = a - c, abcc = ac + bc; - int pa = (ac < 0 ? -ac : ac); - int pb = (bc < 0 ? -bc : bc); - int pc = (abcc < 0 ? -abcc : abcc); - return pa <= pb && pa <= pc ? a : pb <= pc ? b : c; -} - -static inline void -none(fz_predict *p, unsigned char *in, unsigned char *out) -{ - memcpy(out, in, p->stride); -} - -static void -tiff(fz_predict *p, unsigned char *in, unsigned char *out) -{ - int left[MAXC]; - int i, k; - - for (k = 0; k < p->colors; k++) - left[k] = 0; - - for (i = 0; i < p->columns; i++) { - for (k = 0; k < p->colors; k++) { - int a = getcomponent(in, i * p->colors + k, p->bpc); - int b = p->encode ? a - left[k] : a + left[k]; - int c = b % (1 << p->bpc); - putcomponent(out, i * p->colors + k, p->bpc, c); - left[k] = p->encode ? a : c; - } - } -} - -static void -png(fz_predict *p, unsigned char *in, unsigned char *out, int predictor) -{ - int upleft[MAXC], left[MAXC], i, k; - - for (k = 0; k < p->bpp; k++) { - left[k] = 0; - upleft[k] = 0; - } - - if (p->encode) - { - for (k = 0, i = 0; i < p->stride; k = (k + 1) % p->bpp, i ++) - { - switch (predictor) - { - case 0: out[i] = in[i]; break; - case 1: out[i] = in[i] - left[k]; break; - case 2: out[i] = in[i] - p->ref[i]; break; - case 3: out[i] = in[i] - (left[k] + p->ref[i]) / 2; break; - case 4: out[i] = in[i] - paeth(left[k], p->ref[i], upleft[k]); break; - } - left[k] = in[i]; - upleft[k] = p->ref[i]; - } - } - - else - { - for (k = 0, i = 0; i < p->stride; k = (k + 1) % p->bpp, i ++) - { - switch (predictor) - { - case 0: out[i] = in[i]; break; - case 1: out[i] = in[i] + left[k]; break; - case 2: out[i] = in[i] + p->ref[i]; break; - case 3: out[i] = in[i] + (left[k] + p->ref[i]) / 2; break; - case 4: out[i] = in[i] + paeth(left[k], p->ref[i], upleft[k]); break; - } - left[k] = out[i]; - upleft[k] = p->ref[i]; - } - } -} - -fz_error * -fz_processpredict(fz_filter *filter, fz_buffer *in, fz_buffer *out) -{ - fz_predict *dec = (fz_predict*)filter; - int ispng = dec->predictor >= 10; - int predictor; - - while (1) - { - if (in->rp + dec->stride + (!dec->encode && ispng) > in->wp) { - if (in->eof) - return fz_iodone; - return fz_ioneedin; - } - - if (out->wp + dec->stride + (dec->encode && ispng) > out->ep) - return fz_ioneedout; - - if (dec->predictor == 1) { - none(dec, in->rp, out->wp); - } - else if (dec->predictor == 2) { - if (dec->bpc != 8) - memset(out->wp, 0, dec->stride); - tiff(dec, in->rp, out->wp); - } - else { - if (dec->encode) { - predictor = dec->predictor - 10; - if (predictor < 0 || predictor > 4) - predictor = 1; - *out->wp ++ = predictor; - } - else { - predictor = *in->rp++; - } - png(dec, in->rp, out->wp, predictor); - } - - if (dec->ref) - memcpy(dec->ref, out->wp, dec->stride); - - in->rp += dec->stride; - out->wp += dec->stride; - } -} - -fz_error * -fz_newpredictd(fz_filter **fp, fz_obj *params) -{ - return fz_newpredict(fp, params, 0); -} - -fz_error * -fz_newpredicte(fz_filter **fp, fz_obj *params) -{ - return fz_newpredict(fp, params, 1); -} - diff --git a/filter/rld.c b/filter/rld.c deleted file mode 100644 index bcad4323..00000000 --- a/filter/rld.c +++ /dev/null @@ -1,66 +0,0 @@ -#include - -fz_error * -fz_newrld(fz_filter **fp, fz_obj *params) -{ - FZ_NEWFILTER(fz_filter, f, rld); - return nil; -} - -void -fz_droprld(fz_filter *rld) -{ -} - -fz_error * -fz_processrld(fz_filter *filter, fz_buffer *in, fz_buffer *out) -{ - int run, i; - unsigned char c; - - while (1) - { - if (in->rp == in->wp) - return fz_ioneedin; - - if (out->wp == out->ep) - return fz_ioneedout; - - run = *in->rp++; - - if (run == 128) { - out->eof = 1; - return fz_iodone; - } - - else if (run < 128) { - run = run + 1; - if (in->rp + run > in->wp) { - in->rp --; - return fz_ioneedin; - } - if (out->wp + run > out->ep) { - in->rp --; - return fz_ioneedout; - } - for (i = 0; i < run; i++) - *out->wp++ = *in->rp++; - } - - else if (run > 128) { - run = 257 - run; - if (in->rp + 1 > in->wp) { - in->rp --; - return fz_ioneedin; - } - if (out->wp + run > out->ep) { - in->rp --; - return fz_ioneedout; - } - c = *in->rp++; - for (i = 0; i < run; i++) - *out->wp++ = c; - } - } -} - diff --git a/filter/rle.c b/filter/rle.c deleted file mode 100644 index 921e470a..00000000 --- a/filter/rle.c +++ /dev/null @@ -1,237 +0,0 @@ -#include - -/* TODO: rewrite! - * make it non-optimal or something, - * just not this horrid mess... - */ - -#define noDEBUG - -typedef struct fz_rle_s fz_rle; - -struct fz_rle_s -{ - fz_filter super; - int reclen; - int curlen; - int state; - int run; - unsigned char buf[128]; -}; - -enum { - ZERO, - ONE, - DIFF, - SAME, - END -}; - -fz_error * -fz_newrle(fz_filter **fp, fz_obj *params) -{ - FZ_NEWFILTER(fz_rle, enc, rle); - - if (params) - enc->reclen = fz_toint(params); - else - enc->reclen = 0; - - enc->curlen = 0; - enc->state = ZERO; - enc->run = 0; - - return nil; -} - -void -fz_droprle(fz_filter *enc) -{ -} - -static fz_error * -putone(fz_rle *enc, fz_buffer *in, fz_buffer *out) -{ - if (out->wp + 2 >= out->ep) - return fz_ioneedout; - -#ifdef DEBUG -fprintf(stderr, "one '%c'\n", enc->buf[0]); -#endif - - *out->wp++ = 0; - *out->wp++ = enc->buf[0]; - - return nil; -} - -static fz_error * -putsame(fz_rle *enc, fz_buffer *in, fz_buffer *out) -{ - if (out->wp + enc->run >= out->ep) - return fz_ioneedout; - -#ifdef DEBUG -fprintf(stderr, "same %d x '%c'\n", enc->run, enc->buf[0]); -#endif - - *out->wp++ = 257 - enc->run; - *out->wp++ = enc->buf[0]; - return nil; -} - -static fz_error * -putdiff(fz_rle *enc, fz_buffer *in, fz_buffer *out) -{ - int i; - if (out->wp + enc->run >= out->ep) - return fz_ioneedout; - -#ifdef DEBUG -fprintf(stderr, "diff %d\n", enc->run); -#endif - - *out->wp++ = enc->run - 1; - for (i = 0; i < enc->run; i++) - *out->wp++ = enc->buf[i]; - return nil; -} - -static fz_error * -puteod(fz_rle *enc, fz_buffer *in, fz_buffer *out) -{ - if (out->wp + 1 >= out->ep) - return fz_ioneedout; - -#ifdef DEBUG -fprintf(stderr, "eod\n"); -#endif - - *out->wp++ = 128; - return nil; -} - -static fz_error * -savebuf(fz_rle *enc, fz_buffer *in, fz_buffer *out) -{ - switch (enc->state) - { - case ZERO: return nil; - case ONE: return putone(enc, in, out); - case SAME: return putsame(enc, in, out); - case DIFF: return putdiff(enc, in, out); - case END: return puteod(enc, in, out); - default: assert(!"invalid state in rle"); return nil; - } -} - -fz_error * -fz_processrle(fz_filter *filter, fz_buffer *in, fz_buffer *out) -{ - fz_rle *enc = (fz_rle*)filter; - fz_error *error; - unsigned char c; - - while (1) - { - - if (enc->reclen && enc->curlen == enc->reclen) { - error = savebuf(enc, in, out); - if (error) return error; -#ifdef DEBUG -fprintf(stderr, "--record--\n"); -#endif - enc->state = ZERO; - enc->curlen = 0; - } - - if (in->rp == in->wp) { - if (in->eof) { - if (enc->state != END) { - error = savebuf(enc, in, out); - if (error) return error; - } - enc->state = END; - } - else - return fz_ioneedin; - } - - c = *in->rp; - - switch (enc->state) - { - case ZERO: - enc->state = ONE; - enc->run = 1; - enc->buf[0] = c; - break; - - case ONE: - enc->state = DIFF; - enc->run = 2; - enc->buf[1] = c; - break; - - case DIFF: - /* out of space */ - if (enc->run == 128) { - error = putdiff(enc, in, out); - if (error) return error; - - enc->state = ONE; - enc->run = 1; - enc->buf[0] = c; - } - - /* run of three that are the same */ - else if ((enc->run > 1) && - (c == enc->buf[enc->run - 1]) && - (c == enc->buf[enc->run - 2])) - { - if (enc->run >= 3) { - enc->run -= 2; /* skip prev two for diff run */ - error = putdiff(enc, in, out); - if (error) return error; - } - - enc->state = SAME; - enc->run = 3; - enc->buf[0] = c; - } - - /* keep on collecting */ - else { - enc->buf[enc->run++] = c; - } - break; - - case SAME: - if (enc->run == 128 || c != enc->buf[0]) { - error = putsame(enc, in, out); - if (error) return error; - - enc->state = ONE; - enc->run = 1; - enc->buf[0] = c; - } - else { - enc->run ++; - } - break; - - case END: - error = puteod(enc, in, out); - if (error) return error; - - out->eof = 1; - return fz_iodone; - } - - in->rp ++; - - enc->curlen ++; - - } -} - diff --git a/object/array.c b/object/array.c deleted file mode 100644 index c493bdaa..00000000 --- a/object/array.c +++ /dev/null @@ -1,184 +0,0 @@ -#include - -void fz_droparray(fz_obj *obj); - -fz_error * -fz_newarray(fz_obj **op, int initialcap) -{ - fz_obj *obj; - int i; - - obj = *op = fz_malloc(sizeof (fz_obj)); - if (!obj) return fz_outofmem; - - obj->refs = 1; - obj->kind = FZ_ARRAY; - - obj->u.a.len = 0; - obj->u.a.cap = initialcap > 0 ? initialcap : 6; - - obj->u.a.items = fz_malloc(sizeof (fz_obj*) * obj->u.a.cap); - if (!obj->u.a.items) { fz_free(obj); return fz_outofmem; } - - for (i = 0; i < obj->u.a.cap; i++) - obj->u.a.items[i] = nil; - - return nil; -} - -fz_error * -fz_copyarray(fz_obj **op, fz_obj *obj) -{ - fz_error *error; - fz_obj *new; - int i; - - if (!fz_isarray(obj)) - return fz_throw("typecheck in copyarray"); - - error = fz_newarray(&new, fz_arraylen(obj)); - if (error) return error; - *op = new; - - for (i = 0; i < fz_arraylen(obj); i++) { - error = fz_arraypush(new, fz_arrayget(obj, i)); - if (error) { fz_droparray(new); return error; } - } - - return nil; -} - -fz_error * -fz_deepcopyarray(fz_obj **op, fz_obj *obj) -{ - fz_error *error; - fz_obj *new; - fz_obj *val; - int i; - - if (!fz_isarray(obj)) - return fz_throw("typecheck in deepcopyarray"); - - error = fz_newarray(&new, fz_arraylen(obj)); - if (error) return error; - *op = new; - - for (i = 0; i < fz_arraylen(obj); i++) - { - val = fz_arrayget(obj, i); - - if (fz_isarray(val)) { - error = fz_deepcopyarray(&val, val); - if (error) { fz_droparray(new); return error; } - error = fz_arraypush(new, val); - if (error) { fz_dropobj(val); fz_droparray(new); return error; } - fz_dropobj(val); - } - - else if (fz_isdict(val)) { - error = fz_deepcopydict(&val, val); - if (error) { fz_droparray(new); return error; } - error = fz_arraypush(new, val); - if (error) { fz_dropobj(val); fz_droparray(new); return error; } - fz_dropobj(val); - } - - else { - error = fz_arraypush(new, val); - if (error) { fz_droparray(new); return error; } - } - } - - return nil; -} - -int -fz_arraylen(fz_obj *obj) -{ - if (!fz_isarray(obj)) - return 0; - return obj->u.a.len; -} - -fz_obj * -fz_arrayget(fz_obj *obj, int i) -{ - if (!fz_isarray(obj)) - return nil; - - if (i < 0 || i >= obj->u.a.len) - return nil; - - return obj->u.a.items[i]; -} - -fz_error * -fz_arrayput(fz_obj *obj, int i, fz_obj *item) -{ - if (!fz_isarray(obj)) - return fz_throw("typecheck in arrayput"); - if (i < 0) - return fz_throw("rangecheck in arrayput: %d < 0", i); - if (i >= obj->u.a.len) - return fz_throw("rangecheck in arrayput: %d > %d", i, obj->u.a.len); - - if (obj->u.a.items[i]) - fz_dropobj(obj->u.a.items[i]); - obj->u.a.items[i] = fz_keepobj(item); - - return nil; -} - -static fz_error * -growarray(fz_obj *obj) -{ - fz_obj **newitems; - int newcap; - int i; - - newcap = obj->u.a.cap * 2; - newitems = fz_realloc(obj->u.a.items, sizeof (fz_obj*) * newcap); - if (!newitems) return fz_outofmem; - - obj->u.a.items = newitems; - for (i = obj->u.a.cap ; i < newcap; i++) - obj->u.a.items[i] = nil; - obj->u.a.cap = newcap; - - return nil; -} - -fz_error * -fz_arraypush(fz_obj *obj, fz_obj *item) -{ - fz_error *error; - - if (!fz_isarray(obj)) - return fz_throw("typecheck in arraypush"); - - if (obj->u.a.len + 1 > obj->u.a.cap) { - error = growarray(obj); - if (error) return error; - } - - obj->u.a.items[obj->u.a.len] = fz_keepobj(item); - obj->u.a.len++; - - return nil; -} - -void -fz_droparray(fz_obj *obj) -{ - int i; - - assert(obj->kind == FZ_ARRAY); - - for (i = 0; i < obj->u.a.len; i++) - if (obj->u.a.items[i]) - fz_dropobj(obj->u.a.items[i]); - - fz_free(obj->u.a.items); - fz_free(obj); -} - diff --git a/object/dict.c b/object/dict.c deleted file mode 100644 index a0fb6d25..00000000 --- a/object/dict.c +++ /dev/null @@ -1,355 +0,0 @@ -#include - -/* keep either names or strings in the dict. don't mix & match. */ - -static int keyvalcmp(const void *ap, const void *bp) -{ - const fz_keyval *a = ap; - const fz_keyval *b = bp; - if (fz_isname(a->k)) - return strcmp(fz_toname(a->k), fz_toname(b->k)); - if (fz_isstring(a->k)) - return strcmp(fz_tostrbuf(a->k), fz_tostrbuf(b->k)); - return -1; -} - -static inline int keystrcmp(fz_obj *key, char *s) -{ - if (fz_isname(key)) - return strcmp(fz_toname(key), s); - if (fz_isstring(key)) - return strcmp(fz_tostrbuf(key), s); - return -1; -} - -fz_error * -fz_newdict(fz_obj **op, int initialcap) -{ - fz_obj *obj; - int i; - - obj = *op = fz_malloc(sizeof (fz_obj)); - if (!obj) return fz_outofmem; - - obj->refs = 1; - obj->kind = FZ_DICT; - - obj->u.d.sorted = 1; - obj->u.d.len = 0; - obj->u.d.cap = initialcap > 0 ? initialcap : 10; - - obj->u.d.items = fz_malloc(sizeof(fz_keyval) * obj->u.d.cap); - if (!obj->u.d.items) { fz_free(obj); return fz_outofmem; } - - for (i = 0; i < obj->u.d.cap; i++) { - obj->u.d.items[i].k = nil; - obj->u.d.items[i].v = nil; - } - - return nil; -} - -fz_error * -fz_copydict(fz_obj **op, fz_obj *obj) -{ - fz_error *error; - fz_obj *new; - int i; - - if (!fz_isdict(obj)) - return fz_throw("typecheck in copydict"); - - error = fz_newdict(&new, obj->u.d.cap); - if (error) return error; - *op = new; - - for (i = 0; i < fz_dictlen(obj); i++) { - error = fz_dictput(new, fz_dictgetkey(obj, i), fz_dictgetval(obj, i)); - if (error) { fz_dropobj(new); return error; } - } - - return nil; -} - -fz_error * -fz_deepcopydict(fz_obj **op, fz_obj *obj) -{ - fz_error *error; - fz_obj *new; - fz_obj *val; - int i; - - if (!fz_isdict(obj)) - return fz_throw("typecheck in deepcopydict"); - - error = fz_newdict(&new, obj->u.d.cap); - if (error) return error; - *op = new; - - for (i = 0; i < fz_dictlen(obj); i++) - { - val = fz_dictgetval(obj, i); - - if (fz_isarray(val)) { - error = fz_deepcopyarray(&val, val); - if (error) { fz_dropobj(new); return error; } - error = fz_dictput(new, fz_dictgetkey(obj, i), val); - if (error) { fz_dropobj(val); fz_dropobj(new); return error; } - fz_dropobj(val); - } - - else if (fz_isdict(val)) { - error = fz_deepcopydict(&val, val); - if (error) { fz_dropobj(new); return error; } - error = fz_dictput(new, fz_dictgetkey(obj, i), val); - if (error) { fz_dropobj(val); fz_dropobj(new); return error; } - fz_dropobj(val); - } - - else { - error = fz_dictput(new, fz_dictgetkey(obj, i), val); - if (error) { fz_dropobj(new); return error; } - } - } - - return nil; -} - -static fz_error * -growdict(fz_obj *obj) -{ - fz_keyval *newitems; - int newcap; - int i; - - newcap = obj->u.d.cap * 2; - - newitems = fz_realloc(obj->u.d.items, sizeof(fz_keyval) * newcap); - if (!newitems) return fz_outofmem; - - obj->u.d.items = newitems; - for (i = obj->u.d.cap; i < newcap; i++) { - obj->u.d.items[i].k = nil; - obj->u.d.items[i].v = nil; - } - obj->u.d.cap = newcap; - - return nil; -} - -int -fz_dictlen(fz_obj *obj) -{ - if (!fz_isdict(obj)) - return 0; - return obj->u.d.len; -} - -fz_obj * -fz_dictgetkey(fz_obj *obj, int i) -{ - if (!fz_isdict(obj)) - return nil; - - if (i < 0 || i >= obj->u.d.len) - return nil; - - return obj->u.d.items[i].k; -} - -fz_obj * -fz_dictgetval(fz_obj *obj, int i) -{ - if (!fz_isdict(obj)) - return nil; - - if (i < 0 || i >= obj->u.d.len) - return nil; - - return obj->u.d.items[i].v; -} - -static inline int dictfinds(fz_obj *obj, char *key) -{ - if (obj->u.d.sorted) - { - int l = 0; - int r = obj->u.d.len - 1; - while (l <= r) - { - int m = (l + r) >> 1; - int c = -keystrcmp(obj->u.d.items[m].k, key); - if (c < 0) - r = m - 1; - else if (c > 0) - l = m + 1; - else - return m; - } - } - - else - { - int i; - for (i = 0; i < obj->u.d.len; i++) - if (keystrcmp(obj->u.d.items[i].k, key) == 0) - return i; - } - - return -1; -} - -fz_obj * -fz_dictgets(fz_obj *obj, char *key) -{ - int i; - - if (!fz_isdict(obj)) - return nil; - - i = dictfinds(obj, key); - if (i >= 0) - return obj->u.d.items[i].v; - - return nil; -} - -fz_obj * -fz_dictget(fz_obj *obj, fz_obj *key) -{ - if (fz_isname(key)) - return fz_dictgets(obj, fz_toname(key)); - if (fz_isstring(key)) - return fz_dictgets(obj, fz_tostrbuf(key)); - return nil; -} - -fz_obj * -fz_dictgetsa(fz_obj *obj, char *key, char *abbrev) -{ - fz_obj *v; - v = fz_dictgets(obj, key); - if (v) - return v; - return fz_dictgets(obj, abbrev); -} - -fz_error * -fz_dictput(fz_obj *obj, fz_obj *key, fz_obj *val) -{ - fz_error *error; - char *s; - int i; - - if (!fz_isdict(obj)) - return fz_throw("typecheck in dictput"); - - if (fz_isname(key)) - s = fz_toname(key); - else if (fz_isstring(key)) - s = fz_tostrbuf(key); - else - return fz_throw("typecheck in dictput"); - - i = dictfinds(obj, s); - if (i >= 0) - { - fz_dropobj(obj->u.d.items[i].v); - obj->u.d.items[i].v = fz_keepobj(val); - return nil; - } - - if (obj->u.d.len + 1 > obj->u.d.cap) - { - error = growdict(obj); - if (error) - return error; - } - - /* borked! */ - if (obj->u.d.len) - if (keystrcmp(obj->u.d.items[obj->u.d.len - 1].k, s) > 0) - obj->u.d.sorted = 0; - - obj->u.d.items[obj->u.d.len].k = fz_keepobj(key); - obj->u.d.items[obj->u.d.len].v = fz_keepobj(val); - obj->u.d.len ++; - - return nil; -} - -fz_error * -fz_dictputs(fz_obj *obj, char *key, fz_obj *val) -{ - fz_error *error; - fz_obj *keyobj; - error = fz_newname(&keyobj, key); - if (error) return error; - error = fz_dictput(obj, keyobj, val); - fz_dropobj(keyobj); - return error; -} - -fz_error * -fz_dictdels(fz_obj *obj, char *key) -{ - int i; - - if (!fz_isdict(obj)) - return fz_throw("typecheck in dictdel"); - - i = dictfinds(obj, key); - if (i >= 0) - { - fz_dropobj(obj->u.d.items[i].k); - fz_dropobj(obj->u.d.items[i].v); - obj->u.d.sorted = 0; - obj->u.d.items[i] = obj->u.d.items[obj->u.d.len-1]; - obj->u.d.len --; - } - - return nil; -} - -fz_error * -fz_dictdel(fz_obj *obj, fz_obj *key) -{ - if (fz_isname(key)) - return fz_dictdels(obj, fz_toname(key)); - else if (fz_isstring(key)) - return fz_dictdels(obj, fz_tostrbuf(key)); - else - return fz_throw("typecheck in dictdel"); -} - -void -fz_dropdict(fz_obj *obj) -{ - int i; - - if (!fz_isdict(obj)) - return; - - for (i = 0; i < obj->u.d.len; i++) { - if (obj->u.d.items[i].k) - fz_dropobj(obj->u.d.items[i].k); - if (obj->u.d.items[i].v) - fz_dropobj(obj->u.d.items[i].v); - } - - fz_free(obj->u.d.items); - fz_free(obj); -} - -void -fz_sortdict(fz_obj *obj) -{ - if (!fz_isdict(obj)) - return; - if (!obj->u.d.sorted) - { - qsort(obj->u.d.items, obj->u.d.len, sizeof(fz_keyval), keyvalcmp); - obj->u.d.sorted = 1; - } -} - diff --git a/object/parse.c b/object/parse.c deleted file mode 100644 index c3f3d3dc..00000000 --- a/object/parse.c +++ /dev/null @@ -1,401 +0,0 @@ -#include - -struct vap { va_list ap; }; - -static inline int iswhite(int ch) -{ - return - ch == '\000' || - ch == '\011' || - ch == '\012' || - ch == '\014' || - ch == '\015' || - ch == '\040'; -} - -static inline int isdelim(int ch) -{ - return - ch == '(' || ch == ')' || - ch == '<' || ch == '>' || - ch == '[' || ch == ']' || - ch == '{' || ch == '}' || - ch == '/' || - ch == '%'; -} - -static inline int isregular(int ch) -{ - return !isdelim(ch) && !iswhite(ch) && ch != EOF; -} - -static fz_error *parseobj(fz_obj **obj, char **sp, struct vap *v); - -static inline int fromhex(char ch) -{ - if (ch >= '0' && ch <= '9') - return ch - '0'; - else if (ch >= 'A' && ch <= 'F') - return ch - 'A' + 0xA; - else if (ch >= 'a' && ch <= 'f') - return ch - 'a' + 0xA; - return 0; -} - -static inline void skipwhite(char **sp) -{ - char *s = *sp; - while (iswhite(*s)) - s ++; - *sp = s; -} - -static void parsekeyword(char **sp, char *b, char *eb) -{ - char *s = *sp; - while (b < eb && isregular(*s)) - *b++ = *s++; - *b++ = 0; - *sp = s; -} - -static fz_error *parsename(fz_obj **obj, char **sp) -{ - char buf[64]; - char *s = *sp; - char *p = buf; - - s ++; /* skip '/' */ - while (p < buf + sizeof buf - 1 && isregular(*s)) - *p++ = *s++; - *p++ = 0; - *sp = s; - - return fz_newname(obj, buf); -} - -static fz_error *parsenumber(fz_obj **obj, char **sp) -{ - char buf[32]; - char *s = *sp; - char *p = buf; - - while (p < buf + sizeof buf - 1) - { - if (s[0] == '-' || s[0] == '.' || (s[0] >= '0' && s[0] <= '9')) - *p++ = *s++; - else - break; - } - *p++ = 0; - *sp = s; - - if (strchr(buf, '.')) - return fz_newreal(obj, atof(buf)); - return fz_newint(obj, atoi(buf)); -} - -static fz_error *parsedict(fz_obj **obj, char **sp, struct vap *v) -{ - fz_error *error = nil; - fz_obj *dict = nil; - fz_obj *key = nil; - fz_obj *val = nil; - char *s = *sp; - - error = fz_newdict(&dict, 8); - if (error) return error; - *obj = dict; - - s += 2; /* skip "<<" */ - - while (*s) - { - skipwhite(&s); - - /* end-of-dict marker >> */ - if (*s == '>') { - s ++; - if (*s == '>') { - s ++; - break; - } - error = fz_throw("syntaxerror in parsedict"); - goto cleanup; - } - - /* non-name as key, bail */ - if (*s != '/') { - error = fz_throw("syntaxerror in parsedict"); - goto cleanup; - } - - error = parsename(&key, &s); - if (error) goto cleanup; - - skipwhite(&s); - - error = parseobj(&val, &s, v); - if (error) goto cleanup; - - error = fz_dictput(dict, key, val); - if (error) goto cleanup; - - fz_dropobj(val); val = nil; - fz_dropobj(key); key = nil; - } - - *sp = s; - return nil; - -cleanup: - if (val) fz_dropobj(val); - if (key) fz_dropobj(key); - if (dict) fz_dropobj(dict); - *obj = nil; - *sp = s; - return error; -} - -static fz_error *parsearray(fz_obj **obj, char **sp, struct vap *v) -{ - fz_error *error; - fz_obj *a; - fz_obj *o; - char *s = *sp; - - error = fz_newarray(&a, 8); - if (error) return error; - *obj = a; - - s ++; /* skip '[' */ - - while (*s) - { - skipwhite(&s); - - if (*s == ']') { - s ++; - break; - } - - error = parseobj(&o, &s, v); - if (error) { *obj = nil; fz_dropobj(a); return error; } - - error = fz_arraypush(a, o); - if (error) { fz_dropobj(o); *obj = nil; fz_dropobj(a); return error; } - - fz_dropobj(o); - } - - *sp = s; - return nil; -} - -static fz_error *parsestring(fz_obj **obj, char **sp) -{ - char buf[512]; - char *s = *sp; - char *p = buf; - int balance = 1; - int oct; - - s ++; /* skip '(' */ - - while (*s && p < buf + sizeof buf) - { - if (*s == '(') - { - balance ++; - *p++ = *s++; - } - else if (*s == ')') - { - balance --; - *p++ = *s++; - } - else if (*s == '\\') - { - s ++; - if (*s >= '0' && *s <= '9') - { - oct = *s - '0'; - s ++; - if (*s >= '0' && *s <= '9') - { - oct = oct * 8 + (*s - '0'); - s ++; - if (*s >= '0' && *s <= '9') - { - oct = oct * 8 + (*s - '0'); - s ++; - } - } - *p++ = oct; - } - else switch (*s) - { - case 'n': *p++ = '\n'; s++; break; - case 'r': *p++ = '\r'; s++; break; - case 't': *p++ = '\t'; s++; break; - case 'b': *p++ = '\b'; s++; break; - case 'f': *p++ = '\f'; s++; break; - default: *p++ = *s++; break; - } - } - else - *p++ = *s++; - - if (balance == 0) - break; - } - - *sp = s; - return fz_newstring(obj, buf, p - buf - 1); -} - -static fz_error *parsehexstring(fz_obj **obj, char **sp) -{ - char buf[512]; - char *s = *sp; - char *p = buf; - int a, b; - - s ++; /* skip '<' */ - - while (*s && p < buf + sizeof buf) - { - skipwhite(&s); - if (*s == '>') { - s ++; - break; - } - a = *s++; - - if (*s == '\0') - break; - - skipwhite(&s); - if (*s == '>') { - s ++; - break; - } - b = *s++; - - *p++ = fromhex(a) * 16 + fromhex(b); - } - - *sp = s; - return fz_newstring(obj, buf, p - buf); -} - -static fz_error *parseobj(fz_obj **obj, char **sp, struct vap *v) -{ - fz_error *error; - char buf[32]; - int oid, gid, len; - char *tmp; - char *s = *sp; - - if (*s == '\0') - return fz_throw("syntaxerror in parseobj: end-of-string"); - - skipwhite(&s); - - error = nil; - - if (v != nil && *s == '%') - { - s ++; - switch (*s) - { - case 'p': error = fz_newpointer(obj, va_arg(v->ap, void*)); break; - case 'o': *obj = fz_keepobj(va_arg(v->ap, fz_obj*)); break; - case 'b': error = fz_newbool(obj, va_arg(v->ap, int)); break; - case 'i': error = fz_newint(obj, va_arg(v->ap, int)); break; - case 'f': error = fz_newreal(obj, (float)va_arg(v->ap, double)); break; - case 'n': error = fz_newname(obj, va_arg(v->ap, char*)); break; - case 'r': - oid = va_arg(v->ap, int); - gid = va_arg(v->ap, int); - error = fz_newindirect(obj, oid, gid); - break; - case 's': - tmp = va_arg(v->ap, char*); - error = fz_newstring(obj, tmp, strlen(tmp)); - break; - case '#': - tmp = va_arg(v->ap, char*); - len = va_arg(v->ap, int); - error = fz_newstring(obj, tmp, len); - break; - default: - error = fz_throw("unknown format specifier in packobj: '%c'", *s); - break; - } - s ++; - } - - else if (*s == '/') - error = parsename(obj, &s); - - else if (*s == '(') - error = parsestring(obj, &s); - - else if (*s == '<') { - if (s[1] == '<') - error = parsedict(obj, &s, v); - else - error = parsehexstring(obj, &s); - } - - else if (*s == '[') - error = parsearray(obj, &s, v); - - else if (*s == '-' || *s == '.' || (*s >= '0' && *s <= '9')) - error = parsenumber(obj, &s); - - else if (isregular(*s)) - { - parsekeyword(&s, buf, buf + sizeof buf); - - if (strcmp("true", buf) == 0) - error = fz_newbool(obj, 1); - else if (strcmp("false", buf) == 0) - error = fz_newbool(obj, 0); - else if (strcmp("null", buf) == 0) - error = fz_newnull(obj); - else - error = fz_throw("syntaxerror in parseobj: undefined keyword %s", buf); - } - - else - error = fz_throw("syntaxerror in parseobj"); - - *sp = s; - return error; -} - -fz_error * -fz_packobj(fz_obj **op, char *fmt, ...) -{ - fz_error *error; - struct vap v; - va_list ap; - - va_start(ap, fmt); - va_copy(v.ap, ap); - - error = parseobj(op, &fmt, &v); - - va_end(ap); - - return error; -} - -fz_error * -fz_parseobj(fz_obj **op, char *str) -{ - return parseobj(op, &str, nil); -} - diff --git a/object/print.c b/object/print.c deleted file mode 100644 index 7ada9845..00000000 --- a/object/print.c +++ /dev/null @@ -1,302 +0,0 @@ -#include - -struct fmt -{ - char *buf; - int cap; - int len; - int indent; - int tight; - int col; - int sep; - int last; -}; - -static void fmtobj(struct fmt *fmt, fz_obj *obj); - -static inline int isdelim(int ch) -{ - return ch == '(' || ch == ')' || - ch == '<' || ch == '>' || - ch == '[' || ch == ']' || - ch == '{' || ch == '}' || - ch == '/' || - ch == '%'; -} - -static inline void fmtputc(struct fmt *fmt, int c) -{ - if (fmt->sep && !isdelim(fmt->last) && !isdelim(c)) { - fmt->sep = 0; - fmtputc(fmt, ' '); - } - fmt->sep = 0; - - if (fmt->buf && fmt->len < fmt->cap) - fmt->buf[fmt->len] = c; - - if (c == '\n') - fmt->col = 0; - else - fmt->col ++; - - fmt->len ++; - - fmt->last = c; -} - -static void fmtindent(struct fmt *fmt) -{ - int i = fmt->indent; - while (i--) { - fmtputc(fmt, ' '); - fmtputc(fmt, ' '); - } -} - -static inline void fmtputs(struct fmt *fmt, char *s) -{ - while (*s) - fmtputc(fmt, *s++); -} - -static inline void fmtsep(struct fmt *fmt) -{ - fmt->sep = 1; -} - -static void fmtstr(struct fmt *fmt, fz_obj *obj) -{ - int i; - int c; - - fmtputc(fmt, '('); - for (i = 0; i < obj->u.s.len; i++) - { - c = (unsigned char) obj->u.s.buf[i]; - if (c == '\n') - fmtputs(fmt, "\\n"); - else if (c == '\r') - fmtputs(fmt, "\\r"); - else if (c == '\t') - fmtputs(fmt, "\\t"); - else if (c == '\b') - fmtputs(fmt, "\\b"); - else if (c == '\f') - fmtputs(fmt, "\\f"); - else if (c == '(') - fmtputs(fmt, "\\("); - else if (c == ')') - fmtputs(fmt, "\\)"); - else if (c < 32 || c > 126) { - char buf[16]; - fmtputc(fmt, '\\'); - sprintf(buf, "%o", c); - fmtputs(fmt, buf); - } - else - fmtputc(fmt, c); - } - fmtputc(fmt, ')'); -} - -static void fmthex(struct fmt *fmt, fz_obj *obj) -{ - int i; - int b; - int c; - - fmtputc(fmt, '<'); - for (i = 0; i < obj->u.s.len; i++) { - b = (unsigned char) obj->u.s.buf[i]; - c = (b >> 4) & 0x0f; - fmtputc(fmt, c < 0xA ? c + '0' : c + 'A' - 0xA); - c = (b) & 0x0f; - fmtputc(fmt, c < 0xA ? c + '0' : c + 'A' - 0xA); - } - fmtputc(fmt, '>'); -} - -static void fmtarray(struct fmt *fmt, fz_obj *obj) -{ - int i; - - if (fmt->tight) { - fmtputc(fmt, '['); - for (i = 0; i < fz_arraylen(obj); i++) { - fmtobj(fmt, fz_arrayget(obj, i)); - fmtsep(fmt); - } - fmtputc(fmt, ']'); - } - else { - fmtputs(fmt, "[ "); - for (i = 0; i < fz_arraylen(obj); i++) { - if (fmt->col > 60) { - fmtputc(fmt, '\n'); - fmtindent(fmt); - } - fmtobj(fmt, fz_arrayget(obj, i)); - fmtputc(fmt, ' '); - } - fmtputc(fmt, ']'); - fmtsep(fmt); - } -} - -static void fmtdict(struct fmt *fmt, fz_obj *obj) -{ - int i; - fz_obj *key, *val; - - if (fmt->tight) { - fmtputs(fmt, "<<"); - for (i = 0; i < fz_dictlen(obj); i++) { - fmtobj(fmt, fz_dictgetkey(obj, i)); - fmtsep(fmt); - fmtobj(fmt, fz_dictgetval(obj, i)); - fmtsep(fmt); - } - fmtputs(fmt, ">>"); - } - else { - fmtputs(fmt, "<<\n"); - fmt->indent ++; - for (i = 0; i < fz_dictlen(obj); i++) { - key = fz_dictgetkey(obj, i); - val = fz_dictgetval(obj, i); - fmtindent(fmt); - fmtobj(fmt, key); - fmtputc(fmt, ' '); - if (fz_isarray(val)) - fmt->indent ++; - fmtobj(fmt, val); - fmtputc(fmt, '\n'); - if (fz_isarray(val)) - fmt->indent --; - } - fmt->indent --; - fmtindent(fmt); - fmtputs(fmt, ">>"); - } -} - -static void fmtobj(struct fmt *fmt, fz_obj *obj) -{ - char buf[256]; - - if (!obj) { - fmtputs(fmt, ""); - return; - } - - switch (obj->kind) - { - case FZ_NULL: - fmtputs(fmt, "null"); - break; - case FZ_BOOL: - fmtputs(fmt, fz_tobool(obj) ? "true" : "false"); - break; - case FZ_INT: - sprintf(buf, "%d", fz_toint(obj)); - fmtputs(fmt, buf); - break; - case FZ_REAL: - sprintf(buf, "%g", fz_toreal(obj)); - if (strchr(buf, 'e')) /* bad news! */ - sprintf(buf, fabs(fz_toreal(obj)) > 1 ? "%1.1f" : "%1.8f", fz_toreal(obj)); - fmtputs(fmt, buf); - break; - case FZ_STRING: - { - int added = 0; - int i, c; - for (i = 0; i < obj->u.s.len; i++) { - c = (unsigned char)obj->u.s.buf[i]; - if (strchr("()\\\n\r\t\b\f", c) != 0) - added ++; - else if (c < 8) - added ++; - else if (c < 32) - added += 2; - else if (c >= 127) - added += 3; - } - if (added < obj->u.s.len) - fmtstr(fmt, obj); - else - fmthex(fmt, obj); - } - break; - case FZ_NAME: - sprintf(buf, "/%s", fz_toname(obj)); - fmtputs(fmt, buf); - break; - case FZ_ARRAY: - fmtarray(fmt, obj); - break; - case FZ_DICT: - fmtdict(fmt, obj); - break; - case FZ_INDIRECT: - sprintf(buf, "%d %d R", obj->u.r.oid, obj->u.r.gid); - fmtputs(fmt, buf); - break; - case FZ_POINTER: - sprintf(buf, "$%p", obj->u.p); - fmtputs(fmt, buf); - break; - default: - sprintf(buf, "", obj->kind); - fmtputs(fmt, buf); - break; - } -} - -int -fz_sprintobj(char *s, int n, fz_obj *obj, int tight) -{ - struct fmt fmt; - - fmt.indent = 0; - fmt.col = 0; - fmt.sep = 0; - fmt.last = 0; - - fmt.tight = tight; - fmt.buf = s; - fmt.cap = n; - fmt.len = 0; - fmtobj(&fmt, obj); - - if (fmt.buf && fmt.len < fmt.cap) - fmt.buf[fmt.len] = '\0'; - - return fmt.len; -} - -void -fz_debugobj(fz_obj *obj) -{ - char buf[1024]; - char *ptr; - int n; - - n = fz_sprintobj(nil, 0, obj, 0); - if (n < sizeof buf) - { - fz_sprintobj(buf, sizeof buf, obj, 0); - fwrite(buf, 1, n, stdout); - } - else - { - ptr = fz_malloc(n); - if (!ptr) - return; - fz_sprintobj(ptr, n, obj, 0); - fwrite(ptr, 1, n, stdout); - fz_free(ptr); - } -} - diff --git a/object/simple.c b/object/simple.c deleted file mode 100644 index 131e11b4..00000000 --- a/object/simple.c +++ /dev/null @@ -1,297 +0,0 @@ -#include - -extern void fz_droparray(fz_obj *array); -extern void fz_dropdict(fz_obj *dict); - -#define NEWOBJ(KIND,SIZE) \ - fz_obj *o; \ - o = *op = fz_malloc(SIZE); \ - if (!o) return fz_outofmem; \ - o->refs = 1; \ - o->kind = KIND; \ - -fz_error * -fz_newnull(fz_obj **op) -{ - NEWOBJ(FZ_NULL, sizeof (fz_obj)); - return nil; -} - -fz_error * -fz_newbool(fz_obj **op, int b) -{ - NEWOBJ(FZ_BOOL, sizeof (fz_obj)); - o->u.b = b; - return nil; -} - -fz_error * -fz_newint(fz_obj **op, int i) -{ - NEWOBJ(FZ_INT, sizeof (fz_obj)); - o->u.i = i; - return nil; -} - -fz_error * -fz_newreal(fz_obj **op, float f) -{ - NEWOBJ(FZ_REAL, sizeof (fz_obj)); - o->u.f = f; - return nil; -} - -fz_error * -fz_newstring(fz_obj **op, char *str, int len) -{ - NEWOBJ(FZ_STRING, offsetof(fz_obj, u.s.buf) + len + 1); - o->u.s.len = len; - memcpy(o->u.s.buf, str, len); - o->u.s.buf[len] = '\0'; - return nil; -} - -fz_error * -fz_newname(fz_obj **op, char *str) -{ - NEWOBJ(FZ_NAME, offsetof(fz_obj, u.n) + strlen(str) + 1); - strcpy(o->u.n, str); - return nil; -} - -fz_error * -fz_newindirect(fz_obj **op, int objid, int genid) -{ - NEWOBJ(FZ_INDIRECT, sizeof (fz_obj)); - o->u.r.oid = objid; - o->u.r.gid = genid; - return nil; -} - -fz_error * -fz_newpointer(fz_obj **op, void *p) -{ - NEWOBJ(FZ_POINTER, sizeof (fz_obj)); - o->u.p = p; - return nil; -} - -fz_obj * -fz_keepobj(fz_obj *o) -{ - assert(o != nil); - o->refs ++; - return o; -} - -void -fz_dropobj(fz_obj *o) -{ - assert(o != nil); - if (--o->refs == 0) - { - if (o->kind == FZ_ARRAY) - fz_droparray(o); - else if (o->kind == FZ_DICT) - fz_dropdict(o); - else - fz_free(o); - } -} - -int -fz_isnull(fz_obj *obj) -{ - return obj ? obj->kind == FZ_NULL : 0; -} - -int -fz_isbool(fz_obj *obj) -{ - return obj ? obj->kind == FZ_BOOL : 0; -} - -int -fz_isint(fz_obj *obj) -{ - return obj ? obj->kind == FZ_INT : 0; -} - -int -fz_isreal(fz_obj *obj) -{ - return obj ? obj->kind == FZ_REAL : 0; -} - -int -fz_isstring(fz_obj *obj) -{ - return obj ? obj->kind == FZ_STRING : 0; -} - -int -fz_isname(fz_obj *obj) -{ - return obj ? obj->kind == FZ_NAME : 0; -} - -int -fz_isarray(fz_obj *obj) -{ - return obj ? obj->kind == FZ_ARRAY : 0; -} - -int -fz_isdict(fz_obj *obj) -{ - return obj ? obj->kind == FZ_DICT : 0; -} - -int -fz_isindirect(fz_obj *obj) -{ - return obj ? obj->kind == FZ_INDIRECT : 0; -} - -int -fz_ispointer(fz_obj *obj) -{ - return obj ? obj->kind == FZ_POINTER : 0; -} - -int -fz_tobool(fz_obj *obj) -{ - if (fz_isbool(obj)) - return obj->u.b; - return 0; -} - -int -fz_toint(fz_obj *obj) -{ - if (fz_isint(obj)) - return obj->u.i; - if (fz_isreal(obj)) - return obj->u.f; - return 0; -} - -float -fz_toreal(fz_obj *obj) -{ - if (fz_isreal(obj)) - return obj->u.f; - if (fz_isint(obj)) - return obj->u.i; - return 0; -} - -char * -fz_toname(fz_obj *obj) -{ - if (fz_isname(obj)) - return obj->u.n; - return ""; -} - -char * -fz_tostrbuf(fz_obj *obj) -{ - if (fz_isstring(obj)) - return obj->u.s.buf; - return ""; -} - -int -fz_tostrlen(fz_obj *obj) -{ - if (fz_isstring(obj)) - return obj->u.s.len; - return 0; -} - -int -fz_tonum(fz_obj *obj) -{ - if (fz_isindirect(obj)) - return obj->u.r.oid; - return 0; -} - -int -fz_togen(fz_obj *obj) -{ - if (fz_isindirect(obj)) - return obj->u.r.gid; - return 0; -} - -void * -fz_topointer(fz_obj *obj) -{ - if (fz_ispointer(obj)) - return obj->u.p; - return nil; -} - -fz_error * -fz_newnamefromstring(fz_obj **op, fz_obj *str) -{ - NEWOBJ(FZ_NAME, offsetof(fz_obj, u.n) + fz_tostrlen(str) + 1); - memcpy(o->u.n, fz_tostrbuf(str), fz_tostrlen(str)); - o->u.n[fz_tostrlen(str)] = '\0'; - return nil; -} - -int -fz_objcmp(fz_obj *a, fz_obj *b) -{ - int i; - - if (a == b) - return 0; - if (a->kind != b->kind) - return 1; - - switch (a->kind) - { - case FZ_NULL: return 0; - case FZ_BOOL: return a->u.b - b->u.b; - case FZ_INT: return a->u.i - b->u.i; - case FZ_REAL: return a->u.f - b->u.f; - case FZ_STRING: - if (a->u.s.len != b->u.s.len) - return a->u.s.len - b->u.s.len; - return memcmp(a->u.s.buf, b->u.s.buf, a->u.s.len); - case FZ_NAME: - return strcmp(a->u.n, b->u.n); - - case FZ_INDIRECT: - if (a->u.r.oid == b->u.r.oid) - return a->u.r.gid - b->u.r.gid; - return a->u.r.oid - b->u.r.oid; - - case FZ_ARRAY: - if (a->u.a.len != b->u.a.len) - return a->u.a.len - b->u.a.len; - for (i = 0; i < a->u.a.len; i++) - if (fz_objcmp(a->u.a.items[i], b->u.a.items[i])) - return 1; - return 0; - - case FZ_DICT: - if (a->u.d.len != b->u.d.len) - return a->u.d.len - b->u.d.len; - for (i = 0; i < a->u.d.len; i++) - { - if (fz_objcmp(a->u.d.items[i].k, b->u.d.items[i].k)) - return 1; - if (fz_objcmp(a->u.d.items[i].v, b->u.d.items[i].v)) - return 1; - } - return 0; - } - return 1; -} - diff --git a/stream/crypt_arc4.c b/stream/crypt_arc4.c new file mode 100644 index 00000000..86c9afd8 --- /dev/null +++ b/stream/crypt_arc4.c @@ -0,0 +1,95 @@ +/* This code illustrates a sample implementation + * of the Arcfour algorithm + * Copyright (c) April 29, 1997 Kalle Kaukonen. + * All Rights Reserved. + * + * Redistribution and use in source and binary forms, with or + * without modification, are permitted provided that this copyright + * notice and disclaimer are retained. + * + * THIS SOFTWARE IS PROVIDED BY KALLE KAUKONEN AND CONTRIBUTORS ``AS + * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL KALLE + * KAUKONEN OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include + +void +fz_arc4init(fz_arc4 *arc4, unsigned char *key, unsigned keylen) +{ + unsigned int t, u; + unsigned int keyindex; + unsigned int stateindex; + unsigned char *state; + unsigned int counter; + + state = arc4->state; + + arc4->x = 0; + arc4->y = 0; + + for (counter = 0; counter < 256; counter++) { + state[counter] = counter; + } + + keyindex = 0; + stateindex = 0; + + for (counter = 0; counter < 256; counter++) { + t = state[counter]; + stateindex = (stateindex + key[keyindex] + t) & 0xff; + u = state[stateindex]; + + state[stateindex] = t; + state[counter] = u; + + if (++keyindex >= keylen) { + keyindex = 0; + } + } +} + +unsigned char +fz_arc4next(fz_arc4 *arc4) +{ + unsigned int x; + unsigned int y; + unsigned int sx, sy; + unsigned char *state; + + state = arc4->state; + + x = (arc4->x + 1) & 0xff; + sx = state[x]; + y = (sx + arc4->y) & 0xff; + sy = state[y]; + + arc4->x = x; + arc4->y = y; + + state[y] = sx; + state[x] = sy; + + return state[(sx + sy) & 0xff]; +} + +void +fz_arc4encrypt(fz_arc4 *arc4, unsigned char *dest, unsigned char *src, unsigned len) +{ + unsigned int i; + for (i = 0; i < len; i++) { + unsigned char x; + x = fz_arc4next(arc4); + dest[i] = src[i] ^ x; + } +} + diff --git a/stream/crypt_md5.c b/stream/crypt_md5.c new file mode 100644 index 00000000..03601e5b --- /dev/null +++ b/stream/crypt_md5.c @@ -0,0 +1,269 @@ +/* +MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm + +Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. +All rights reserved. + +License to copy and use this software is granted provided that it +is identified as the "RSA Data Security, Inc. MD5 Message-Digest +Algorithm" in all material mentioning or referencing this software +or this function. + +License is also granted to make and use derivative works provided +that such works are identified as "derived from the RSA Data +Security, Inc. MD5 Message-Digest Algorithm" in all material +mentioning or referencing the derived work. + +RSA Data Security, Inc. makes no representations concerning either +the merchantability of this software or the suitability of this +software for any particular purpose. It is provided "as is" +without express or implied warranty of any kind. + +These notices must be retained in any copies of any part of this +documentation and/or software. +*/ + +#include + +/* Constants for MD5Transform routine */ +enum +{ + S11 = 7, S12 = 12, S13 = 17, S14 = 22, + S21 = 5, S22 = 9, S23 = 14, S24 = 20, + S31 = 4, S32 = 11, S33 = 16, S34 = 23, + S41 = 6, S42 = 10, S43 = 15, S44 = 21 +}; + +static void encode(unsigned char *, unsigned long *, unsigned); +static void decode(unsigned long *, unsigned char *, unsigned); +static void transform(unsigned long state[4], unsigned char block[64]); + +static unsigned char padding[64] = +{ + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +/* F, G, H and I are basic MD5 functions */ +#define F(x, y, z) (((x) & (y)) | ((~x) & (z))) +#define G(x, y, z) (((x) & (z)) | ((y) & (~z))) +#define H(x, y, z) ((x) ^ (y) ^ (z)) +#define I(x, y, z) ((y) ^ ((x) | (~z))) + +/* ROTATE rotates x left n bits */ +#define ROTATE(x, n) (((x) << (n)) | ((x) >> (32-(n)))) + +/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4. + * Rotation is separate from addition to prevent recomputation. + */ +#define FF(a, b, c, d, x, s, ac) { \ + (a) += F ((b), (c), (d)) + (x) + (unsigned long)(ac); \ + (a) = ROTATE ((a), (s)); \ + (a) += (b); \ + } +#define GG(a, b, c, d, x, s, ac) { \ + (a) += G ((b), (c), (d)) + (x) + (unsigned long)(ac); \ + (a) = ROTATE ((a), (s)); \ + (a) += (b); \ + } +#define HH(a, b, c, d, x, s, ac) { \ + (a) += H ((b), (c), (d)) + (x) + (unsigned long)(ac); \ + (a) = ROTATE ((a), (s)); \ + (a) += (b); \ + } +#define II(a, b, c, d, x, s, ac) { \ + (a) += I ((b), (c), (d)) + (x) + (unsigned long)(ac); \ + (a) = ROTATE ((a), (s)); \ + (a) += (b); \ + } + +static void encode(unsigned char *output, unsigned long *input, unsigned len) +{ + unsigned i, j; + + for (i = 0, j = 0; j < len; i++, j += 4) { + output[j] = (unsigned char)(input[i] & 0xff); + output[j+1] = (unsigned char)((input[i] >> 8) & 0xff); + output[j+2] = (unsigned char)((input[i] >> 16) & 0xff); + output[j+3] = (unsigned char)((input[i] >> 24) & 0xff); + } +} + +static void decode(unsigned long *output, unsigned char *input, unsigned len) +{ + unsigned i, j; + + for (i = 0, j = 0; j < len; i++, j += 4) { + output[i] = ((unsigned long)input[j]) | + (((unsigned long)input[j+1]) << 8) | + (((unsigned long)input[j+2]) << 16) | + (((unsigned long)input[j+3]) << 24); + } +} + +static void transform(unsigned long state[4], unsigned char block[64]) +{ + unsigned long a = state[0]; + unsigned long b = state[1]; + unsigned long c = state[2]; + unsigned long d = state[3]; + unsigned long x[16]; + + decode(x, block, 64); + + /* Round 1 */ + FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */ + FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */ + FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */ + FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */ + FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */ + FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */ + FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */ + FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */ + FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */ + FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */ + FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */ + FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */ + FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */ + FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */ + FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */ + FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */ + + /* Round 2 */ + GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */ + GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */ + GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */ + GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */ + GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */ + GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */ + GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */ + GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */ + GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */ + GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */ + GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */ + GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */ + GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */ + GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */ + GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */ + GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */ + + /* Round 3 */ + HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */ + HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */ + HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */ + HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */ + HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */ + HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */ + HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */ + HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */ + HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */ + HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */ + HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */ + HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */ + HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */ + HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */ + HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */ + HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */ + + /* Round 4 */ + II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */ + II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */ + II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */ + II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */ + II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */ + II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */ + II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */ + II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */ + II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */ + II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */ + II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */ + II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */ + II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */ + II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */ + II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */ + II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */ + + state[0] += a; + state[1] += b; + state[2] += c; + state[3] += d; + + /* Zeroize sensitive information */ + memset(x, 0, sizeof (x)); +} + +/* MD5 initialization. Begins an MD5 operation, writing a new context. */ +void fz_md5init(fz_md5 *context) +{ + context->count[0] = context->count[1] = 0; + + /* Load magic initialization constants */ + context->state[0] = 0x67452301; + context->state[1] = 0xefcdab89; + context->state[2] = 0x98badcfe; + context->state[3] = 0x10325476; +} + +/* MD5 block update operation. Continues an MD5 message-digest operation, + * processing another message block, and updating the context. + */ +void fz_md5update(fz_md5 *context, unsigned char *input, unsigned inlen) +{ + unsigned i, index, partlen; + + /* Compute number of bytes mod 64 */ + index = (unsigned)((context->count[0] >> 3) & 0x3F); + + /* Update number of bits */ + context->count[0] += (unsigned long) inlen << 3; + if (context->count[0] < (unsigned long) inlen << 3) + context->count[1] ++; + context->count[1] += (unsigned long) inlen >> 29; + + partlen = 64 - index; + + /* Transform as many times as possible. */ + if (inlen >= partlen) { + memcpy(context->buffer + index, input, partlen); + transform(context->state, context->buffer); + + for (i = partlen; i + 63 < inlen; i += 64) + transform(context->state, input + i); + + index = 0; + } + else { + i = 0; + } + + /* Buffer remaining input */ + memcpy(context->buffer + index, input + i, inlen - i); +} + +/* MD5 finalization. Ends an MD5 message-digest operation, writing the + * the message digest and zeroizing the context. + */ +void fz_md5final(fz_md5 *context, unsigned char digest[16]) +{ + unsigned char bits[8]; + unsigned index, padlen; + + /* Save number of bits */ + encode(bits, context->count, 8); + + /* Pad out to 56 mod 64 */ + index = (unsigned)((context->count[0] >> 3) & 0x3f); + padlen = index < 56 ? 56 - index : 120 - index; + fz_md5update(context, padding, padlen); + + /* Append length (before padding) */ + fz_md5update(context, bits, 8); + + /* Store state in digest */ + encode(digest, context->state, 16); + + /* Zeroize sensitive information */ + memset(context, 0, sizeof(fz_md5)); +} + diff --git a/stream/filt_a85d.c b/stream/filt_a85d.c new file mode 100644 index 00000000..5b2e105e --- /dev/null +++ b/stream/filt_a85d.c @@ -0,0 +1,128 @@ +#include + +typedef struct fz_a85d_s fz_a85d; + +struct fz_a85d_s +{ + fz_filter super; + unsigned long word; + int count; +}; + +static inline int iswhite(int a) +{ + switch (a) { + case '\n': case '\r': case '\t': case ' ': + case '\0': case '\f': case '\b': case 0177: + return 1; + } + return 0; +} + +fz_error * +fz_newa85d(fz_filter **fp, fz_obj *params) +{ + FZ_NEWFILTER(fz_a85d, f, a85d); + f->word = 0; + f->count = 0; + return nil; +} + +void +fz_dropa85d(fz_filter *f) +{ +} + +fz_error * +fz_processa85d(fz_filter *filter, fz_buffer *in, fz_buffer *out) +{ + fz_a85d *f = (fz_a85d*)filter; + int c; + + while (1) + { + if (in->rp == in->wp) + return fz_ioneedin; + + c = *in->rp++; + + if (c >= '!' && c <= 'u') { + if (f->count == 4) { + if (out->wp + 4 > out->ep) { + in->rp --; + return fz_ioneedout; + } + + f->word = f->word * 85 + (c - '!'); + + *out->wp++ = (f->word >> 24) & 0xff; + *out->wp++ = (f->word >> 16) & 0xff; + *out->wp++ = (f->word >> 8) & 0xff; + *out->wp++ = (f->word) & 0xff; + + f->word = 0; + f->count = 0; + } + else { + f->word = f->word * 85 + (c - '!'); + f->count ++; + } + } + + else if (c == 'z' && f->count == 0) { + if (out->wp + 4 > out->ep) { + in->rp --; + return fz_ioneedout; + } + *out->wp++ = 0; + *out->wp++ = 0; + *out->wp++ = 0; + *out->wp++ = 0; + } + + else if (c == '~') { + if (in->rp == in->wp) { + in->rp --; + return fz_ioneedin; + } + + c = *in->rp++; + + if (c != '>') { + return fz_throw("ioerror: bad eod marker in a85d"); + } + + if (out->wp + f->count - 1 > out->ep) { + in->rp -= 2; + return fz_ioneedout; + } + + switch (f->count) { + case 0: + break; + case 1: + return fz_throw("ioerror: partial final byte in a85d"); + case 2: + f->word = f->word * (85L * 85 * 85) + 0xffffffL; + goto o1; + case 3: + f->word = f->word * (85L * 85) + 0xffffL; + goto o2; + case 4: + f->word = f->word * 85 + 0xffL; + *(out->wp+2) = f->word >> 8; +o2: *(out->wp+1) = f->word >> 16; +o1: *(out->wp+0) = f->word >> 24; + out->wp += f->count - 1; + break; + } + out->eof = 1; + return fz_iodone; + } + + else if (!iswhite(c)) { + return fz_throw("ioerror: bad data in a85d: '%c'", c); + } + } +} + diff --git a/stream/filt_a85e.c b/stream/filt_a85e.c new file mode 100644 index 00000000..d9cd22c6 --- /dev/null +++ b/stream/filt_a85e.c @@ -0,0 +1,127 @@ +#include + +typedef struct fz_a85e_s fz_a85e; + +struct fz_a85e_s +{ + fz_filter super; + int c; +}; + +fz_error * +fz_newa85e(fz_filter **fp, fz_obj *params) +{ + FZ_NEWFILTER(fz_a85e, f, a85e); + f->c = 0; + return nil; +} + +void +fz_dropa85e(fz_filter *f) +{ +} + +fz_error * +fz_processa85e(fz_filter *filter, fz_buffer *in, fz_buffer *out) +{ + fz_a85e *f = (fz_a85e*)filter; + unsigned long word; + int count; + int n; + + n = 0; + + while (1) + { + if (f->c >= 70) { + if (out->wp + 1 > out->ep) + return fz_ioneedout; + *out->wp++ = '\n'; + f->c = 0; + n ++; + } + + if (in->rp + 4 <= in->wp) + { + word = (in->rp[0] << 24) | + (in->rp[1] << 16) | + (in->rp[2] << 8) | + (in->rp[3]); + if (word == 0) { + if (out->wp + 1 > out->ep) + return fz_ioneedout; + *out->wp++ = 'z'; + f->c ++; + n ++; + } + else { + unsigned long v1, v2, v3, v4; + + if (out->wp + 5 > out->ep) + return fz_ioneedout; + + v4 = word / 85; + v3 = v4 / 85; + v2 = v3 / 85; + v1 = v2 / 85; + + *out->wp++ = (v1 % 85) + '!'; + *out->wp++ = (v2 % 85) + '!'; + *out->wp++ = (v3 % 85) + '!'; + *out->wp++ = (v4 % 85) + '!'; + *out->wp++ = (word % 85) + '!'; + f->c += 5; + n += 5; + } + in->rp += 4; + } + + else if (in->eof) + { + unsigned long divisor; + + if (in->rp == in->wp) + goto needinput; /* handle clean eof here */ + + count = in->wp - in->rp; + + if (out->wp + count + 3 > out->ep) + return fz_ioneedout; + + word = 0; + switch (count) { + case 3: word |= in->rp[2] << 8; + case 2: word |= in->rp[1] << 16; + case 1: word |= in->rp[0] << 24; + } + in->rp += count; + + divisor = 85L * 85 * 85 * 85; + while (count-- >= 0) { + *out->wp++ = ((word / divisor) % 85) + '!'; + divisor /= 85; + } + + *out->wp++ = '~'; + *out->wp++ = '>'; + out->eof = 1; + return fz_iodone; + } + + else { + goto needinput; + } + } + +needinput: + if (in->eof) { + if (out->wp + 2 > out->ep) + return fz_ioneedout; + *out->wp++ = '~'; + *out->wp++ = '>'; + out->eof = 1; + return fz_iodone; + } + return fz_ioneedin; +} + diff --git a/stream/filt_ahxd.c b/stream/filt_ahxd.c new file mode 100644 index 00000000..d0e6d7f5 --- /dev/null +++ b/stream/filt_ahxd.c @@ -0,0 +1,112 @@ +#include + +typedef struct fz_ahxd_s fz_ahxd; + +struct fz_ahxd_s +{ + fz_filter super; + int odd; + int a; +}; + +static inline int iswhite(int a) +{ + switch (a) { + case '\n': case '\r': case '\t': case ' ': + case '\0': case '\f': case '\b': case 0177: + return 1; + } + return 0; +} + +static inline int ishex(int a) +{ + return (a >= 'A' && a <= 'F') || + (a >= 'a' && a <= 'f') || + (a >= '0' && a <= '9'); +} + +static inline int fromhex(int a) +{ + if (a >= 'A' && a <= 'F') + return a - 'A' + 0xA; + if (a >= 'a' && a <= 'f') + return a - 'a' + 0xA; + if (a >= '0' && a <= '9') + return a - '0'; + return 0; +} + +fz_error * +fz_newahxd(fz_filter **fp, fz_obj *params) +{ + FZ_NEWFILTER(fz_ahxd, f, ahxd); + f->odd = 0; + f->a = 0; + return nil; +} + +void +fz_dropahxd(fz_filter *f) +{ +} + +fz_error * +fz_processahxd(fz_filter *filter, fz_buffer *in, fz_buffer *out) +{ + fz_ahxd *f = (fz_ahxd*)filter; + int b, c; + + while (1) + { + if (in->rp == in->wp) + return fz_ioneedin; + + if (out->wp == out->ep) + return fz_ioneedout; + + c = *in->rp++; + + if (ishex(c)) { + if (!f->odd) { + f->a = fromhex(c); + f->odd = 1; + } + else { + b = fromhex(c); + *out->wp++ = (f->a << 4) | b; + f->odd = 0; + } + } + + else if (c == '>') { + if (f->odd) + *out->wp++ = (f->a << 4); + out->eof = 1; + return fz_iodone; + } + + else if (!iswhite(c)) { + return fz_throw("ioerror: bad data in ahxd: '%c'", c); + } + } +} + +void +fz_pushbackahxd(fz_filter *filter, fz_buffer *in, fz_buffer *out, int n) +{ + int k; + + assert(filter->process == fz_processahxd); + assert(out->wp - n >= out->rp); + + k = 0; + while (k < n * 2) { + in->rp --; + if (ishex(*in->rp)) + k ++; + } + + out->wp -= n; +} + diff --git a/stream/filt_ahxe.c b/stream/filt_ahxe.c new file mode 100644 index 00000000..c2b882a6 --- /dev/null +++ b/stream/filt_ahxe.c @@ -0,0 +1,64 @@ +#include + +typedef struct fz_ahxe_s fz_ahxe; + +struct fz_ahxe_s +{ + fz_filter super; + int c; +}; + +static const char tohex[16] = "0123456789ABCDEF"; + +fz_error * +fz_newahxe(fz_filter **fp, fz_obj *params) +{ + FZ_NEWFILTER(fz_ahxe, f, ahxe); + f->c = 0; + return nil; +} + +void +fz_dropahxe(fz_filter *f) +{ +} + +fz_error * +fz_processahxe(fz_filter *filter, fz_buffer *in, fz_buffer *out) +{ + fz_ahxe *f = (fz_ahxe*)filter; + int a, b, c; + + while (1) + { + if (in->rp == in->wp) + goto needinput; + + if (out->wp + 2 >= out->ep) /* can write 3 bytes from 1 */ + return fz_ioneedout; + + c = *in->rp++; + a = tohex[(c >> 4) & 0x0f]; + b = tohex[c & 0x0f]; + + *out->wp++ = a; + *out->wp++ = b; + + f->c += 2; + if (f->c == 60) { + *out->wp++ = '\n'; + f->c = 0; + } + } + +needinput: + if (in->eof) { + if (out->wp == out->ep) + return fz_ioneedout; + *out->wp++ = '>'; + out->eof = 1; + return fz_iodone; + } + return fz_ioneedin; +} + diff --git a/stream/filt_arc4.c b/stream/filt_arc4.c new file mode 100644 index 00000000..b025368c --- /dev/null +++ b/stream/filt_arc4.c @@ -0,0 +1,46 @@ +#include + +typedef struct fz_arc4c_s fz_arc4c; + +struct fz_arc4c_s +{ + fz_filter super; + fz_arc4 arc4; +}; + +fz_error * +fz_newarc4filter(fz_filter **fp, unsigned char *key, unsigned keylen) +{ + FZ_NEWFILTER(fz_arc4c, f, arc4filter); + fz_arc4init(&f->arc4, key, keylen); + return nil; +} + +void +fz_droparc4filter(fz_filter *f) +{ +} + +fz_error * +fz_processarc4filter(fz_filter *filter, fz_buffer *in, fz_buffer *out) +{ + fz_arc4c *f = (fz_arc4c*)filter; + int n; + + while (1) + { + if (in->rp + 1 > in->wp) { + if (in->eof) + return fz_iodone; + return fz_ioneedin; + } + if (out->wp + 1 > out->ep) + return fz_ioneedout; + + n = MIN(in->wp - in->rp, out->ep - out->wp); + fz_arc4encrypt(&f->arc4, out->wp, in->rp, n); + in->rp += n; + out->wp += n; + } +} + diff --git a/stream/filt_buffer.c b/stream/filt_buffer.c new file mode 100644 index 00000000..206137a6 --- /dev/null +++ b/stream/filt_buffer.c @@ -0,0 +1,93 @@ +#include + +fz_error * +fz_newbuffer(fz_buffer **bp, int size) +{ + fz_buffer *b; + + b = *bp = fz_malloc(sizeof(fz_buffer)); + if (!b) return fz_outofmem; + + b->refs = 1; + b->ownsdata = 1; + b->bp = fz_malloc(size); + if (!b->bp) { fz_free(b); return fz_outofmem; } + + b->rp = b->bp; + b->wp = b->bp; + b->ep = b->bp + size; + b->eof = 0; + + return nil; +} + +fz_error * +fz_newbufferwithdata(fz_buffer **bp, unsigned char *data, int size) +{ + fz_buffer *b; + + b = *bp = fz_malloc(sizeof(fz_buffer)); + if (!b) return fz_outofmem; + + b->refs = 1; + b->ownsdata = 0; + b->bp = data; + + b->rp = b->bp; + b->wp = b->bp + size; + b->ep = b->bp + size; + b->eof = 0; + + return nil; +} + +fz_buffer * +fz_keepbuffer(fz_buffer *buf) +{ + buf->refs ++; + return buf; +} + +void +fz_dropbuffer(fz_buffer *buf) +{ + if (--buf->refs == 0) + { + if (buf->ownsdata) + fz_free(buf->bp); + fz_free(buf); + } +} + +fz_error * +fz_growbuffer(fz_buffer *buf) +{ + unsigned char *newbp; + + int rp = buf->rp - buf->bp; + int wp = buf->wp - buf->bp; + int ep = buf->ep - buf->bp; + + assert(buf->ownsdata); + + newbp = fz_realloc(buf->bp, ep * 2); + if (!newbp) return fz_outofmem; + + buf->bp = newbp; + buf->rp = buf->bp + rp; + buf->wp = buf->bp + wp; + buf->ep = buf->bp + ep * 2; + + return nil; +} + +fz_error * +fz_rewindbuffer(fz_buffer *buf) +{ + assert(buf->ownsdata); + memmove(buf->bp, buf->rp, buf->wp - buf->rp); + buf->wp = buf->bp + (buf->wp - buf->rp); + buf->rp = buf->bp; + return nil; +} + diff --git a/stream/filt_dctc.h b/stream/filt_dctc.h new file mode 100644 index 00000000..8aa6aeb7 --- /dev/null +++ b/stream/filt_dctc.h @@ -0,0 +1,39 @@ +/* + * Extend libjpegs error handler to use setjmp/longjmp + */ + +#include + +#include + +struct myerrmgr +{ + struct jpeg_error_mgr super; + jmp_buf jb; + char msg[JMSG_LENGTH_MAX]; +}; + +static void myerrexit(j_common_ptr cinfo) +{ + struct myerrmgr *err = (struct myerrmgr *)cinfo->err; + char msgbuf[JMSG_LENGTH_MAX]; + err->super.format_message(cinfo, msgbuf); + strlcpy(err->msg, msgbuf, sizeof err->msg); + longjmp(err->jb, 1); +} + +static void myoutmess(j_common_ptr cinfo) +{ + struct myerrmgr *err = (struct myerrmgr *)cinfo->err; + char msgbuf[JMSG_LENGTH_MAX]; + err->super.format_message(cinfo, msgbuf); + fprintf(stderr, "ioerror: dct: %s", msgbuf); +} + +static void myiniterr(struct myerrmgr *err) +{ + jpeg_std_error(&err->super); + err->super.error_exit = myerrexit; + err->super.output_message = myoutmess; +} + diff --git a/stream/filt_dctd.c b/stream/filt_dctd.c new file mode 100644 index 00000000..750f7893 --- /dev/null +++ b/stream/filt_dctd.c @@ -0,0 +1,219 @@ +#include + +#include "dctc.h" + +typedef struct fz_dctd_s fz_dctd; + +struct mysrcmgr +{ + struct jpeg_source_mgr super; + fz_buffer *buf; + int skip; +}; + +struct fz_dctd_s +{ + fz_filter super; + struct jpeg_decompress_struct cinfo; + struct mysrcmgr src; + struct myerrmgr err; + int colortransform; + int stage; +}; + +static void myinitsource(j_decompress_ptr cinfo) { /* empty */ } +static boolean myfillinput(j_decompress_ptr cinfo) { return FALSE; } +static void mytermsource(j_decompress_ptr cinfo) { /* empty */ } + +static void myskipinput(j_decompress_ptr cinfo, long n) +{ + struct mysrcmgr *src = (struct mysrcmgr *)cinfo->src; + fz_buffer *in = src->buf; + + assert(src->skip == 0); + + in->rp = in->wp - src->super.bytes_in_buffer; + + if (in->rp + n > in->wp) { + src->skip = (in->rp + n) - in->wp; + in->rp = in->wp; + } + else { + src->skip = 0; + in->rp += n; + } + + src->super.bytes_in_buffer = in->wp - in->rp; + src->super.next_input_byte = in->rp; +} + +fz_error * +fz_newdctd(fz_filter **fp, fz_obj *params) +{ + fz_error *err; + fz_obj *obj; + int colortransform; + + FZ_NEWFILTER(fz_dctd, d, dctd); + + colortransform = 1; + + if (params) { + obj = fz_dictgets(params, "ColorTransform"); + if (obj) colortransform = fz_toint(obj); + } + + d->colortransform = colortransform; + d->stage = 0; + + /* setup error callback first thing */ + myiniterr(&d->err); + d->cinfo.err = (struct jpeg_error_mgr*) &d->err; + + if (setjmp(d->err.jb)) { + err = fz_throw("ioerror in dctd: %s", d->err.msg); + fz_free(d); + return err; + } + + /* create decompression object. this zeroes cinfo except for err. */ + jpeg_create_decompress(&d->cinfo); + + /* prepare source manager */ + d->cinfo.src = (struct jpeg_source_mgr *)&d->src; + d->src.super.init_source = myinitsource; + d->src.super.fill_input_buffer = myfillinput; + d->src.super.skip_input_data = myskipinput; + d->src.super.resync_to_restart = jpeg_resync_to_restart; + d->src.super.term_source = mytermsource; + + d->src.super.bytes_in_buffer = 0; + d->src.super.next_input_byte = nil; + d->src.skip = 0; + + /* speed up jpeg decoding a bit */ + d->cinfo.dct_method = JDCT_FASTEST; + d->cinfo.do_fancy_upsampling = FALSE; + + return nil; +} + +void +fz_dropdctd(fz_filter *filter) +{ + fz_dctd *d = (fz_dctd*)filter; + if (setjmp(d->err.jb)) { + fprintf(stderr, "ioerror in dct: jpeg_destroy_decompress: %s", d->err.msg); + return; + } + jpeg_destroy_decompress(&d->cinfo); +} + +fz_error * +fz_processdctd(fz_filter *filter, fz_buffer *in, fz_buffer *out) +{ + fz_dctd *d = (fz_dctd*)filter; + boolean b; + int i; + int stride; + JSAMPROW scanlines[1]; + + d->src.buf = in; + + /* skip any bytes left over from myskipinput() */ + if (d->src.skip > 0) { + if (in->rp + d->src.skip > in->wp) { + d->src.skip = (in->rp + d->src.skip) - in->wp; + in->rp = in->wp; + goto needinput; + } + else { + in->rp += d->src.skip; + d->src.skip = 0; + } + } + + d->src.super.bytes_in_buffer = in->wp - in->rp; + d->src.super.next_input_byte = in->rp; + + if (setjmp(d->err.jb)) { + return fz_throw("ioerror in dctd: %s", d->err.msg); + } + + switch (d->stage) + { + case 0: + i = jpeg_read_header(&d->cinfo, TRUE); + if (i == JPEG_SUSPENDED) + goto needinput; + + /* FIXME: default value if ColorTransform is not set */ + + if (!d->cinfo.saw_Adobe_marker) { + switch (d->cinfo.num_components) { + case 3: + if (d->colortransform) + d->cinfo.jpeg_color_space = JCS_YCbCr; + else + d->cinfo.jpeg_color_space = JCS_RGB; + break; + case 4: + if (d->colortransform) + d->cinfo.jpeg_color_space = JCS_YCCK; + else + d->cinfo.jpeg_color_space = JCS_CMYK; + break; + } + } + + /* fall through */ + d->stage = 1; + + case 1: + b = jpeg_start_decompress(&d->cinfo); + if (b == FALSE) + goto needinput; + + /* fall through */ + d->stage = 2; + + case 2: + stride = d->cinfo.output_width * d->cinfo.output_components; + + while (d->cinfo.output_scanline < d->cinfo.output_height) + { + if (out->wp + stride > out->ep) + goto needoutput; + + scanlines[0] = out->wp; + + i = jpeg_read_scanlines(&d->cinfo, scanlines, 1); + + if (i == 0) + goto needinput; + + out->wp += stride; + } + + /* fall through */ + d->stage = 3; + + case 3: + b = jpeg_finish_decompress(&d->cinfo); + if (b == FALSE) + goto needinput; + d->stage = 4; + out->eof = 1; + in->rp = in->wp - d->src.super.bytes_in_buffer; + return fz_iodone; + } + +needinput: + in->rp = in->wp - d->src.super.bytes_in_buffer; + return fz_ioneedin; + +needoutput: + in->rp = in->wp - d->src.super.bytes_in_buffer; + return fz_ioneedout; +} + diff --git a/stream/filt_dcte.c b/stream/filt_dcte.c new file mode 100644 index 00000000..547721b4 --- /dev/null +++ b/stream/filt_dcte.c @@ -0,0 +1,252 @@ +#include + +#include "dctc.h" + +typedef struct fz_dcte_s fz_dcte; + +struct mydstmgr +{ + struct jpeg_destination_mgr super; + fz_buffer *buf; +}; + +struct fz_dcte_s +{ + fz_filter super; + + struct jpeg_compress_struct cinfo; + struct mydstmgr dst; + struct myerrmgr err; + int stage; + + int columns; + int rows; + int colors; +}; + +static void myinitdest(j_compress_ptr cinfo) { /* empty */ } +static boolean myemptybuf(j_compress_ptr cinfo) { return FALSE; } +static void mytermdest(j_compress_ptr cinfo) { /* empty */ } + +fz_error * +fz_newdcte(fz_filter **fp, fz_obj *params) +{ + fz_error *err; + fz_obj *obj; + int i; + + FZ_NEWFILTER(fz_dcte, e, dcte); + + e->stage = 0; + + obj = fz_dictgets(params, "Columns"); + if (!obj) { fz_free(e); return fz_throw("ioerror in dcte: missing Columns parameter"); } + e->columns = fz_toint(obj); + + obj = fz_dictgets(params, "Rows"); + if (!obj) { fz_free(e); return fz_throw("ioerror in dcte: missing Rows parameter"); } + e->rows = fz_toint(obj); + + obj = fz_dictgets(params, "Colors"); + if (!obj) { fz_free(e); return fz_throw("ioerror in dcte: missing Colors parameter"); } + e->colors = fz_toint(obj); + + /* setup error callback first thing */ + myiniterr(&e->err); + e->cinfo.err = (struct jpeg_error_mgr*) &e->err; + + if (setjmp(e->err.jb)) { + err = fz_throw("ioerror in dcte: %s", e->err.msg); + fz_free(e); + return err; + } + + jpeg_create_compress(&e->cinfo); + + /* prepare destination manager */ + e->cinfo.dest = (struct jpeg_destination_mgr *) &e->dst; + e->dst.super.init_destination = myinitdest; + e->dst.super.empty_output_buffer = myemptybuf; + e->dst.super.term_destination = mytermdest; + + e->dst.super.next_output_byte = nil; + e->dst.super.free_in_buffer = 0; + + /* prepare required encoding options */ + e->cinfo.image_width = e->columns; + e->cinfo.image_height = e->rows; + e->cinfo.input_components = e->colors; + + switch (e->colors) { + case 1: e->cinfo.in_color_space = JCS_GRAYSCALE; break; + case 3: e->cinfo.in_color_space = JCS_RGB; break; + case 4: e->cinfo.in_color_space = JCS_CMYK; break; + default: e->cinfo.in_color_space = JCS_UNKNOWN; break; + } + + jpeg_set_defaults(&e->cinfo); + + /* FIXME check this */ + obj = fz_dictgets(params, "ColorTransform"); + if (obj) { + int colortransform = fz_toint(obj); + if (e->colors == 3 && !colortransform) + jpeg_set_colorspace(&e->cinfo, JCS_RGB); + if (e->colors == 4 && colortransform) + jpeg_set_colorspace(&e->cinfo, JCS_YCCK); + if (e->colors == 4 && !colortransform) + jpeg_set_colorspace(&e->cinfo, JCS_CMYK); + } + + obj = fz_dictgets(params, "HSamples"); + if (obj && fz_isarray(obj)) { + fz_obj *o; + for (i = 0; i < e->colors; i++) { + o = fz_arrayget(obj, i); + e->cinfo.comp_info[i].h_samp_factor = fz_toint(o); + } + } + + obj = fz_dictgets(params, "VSamples"); + if (obj && fz_isarray(obj)) { + fz_obj *o; + for (i = 0; i < e->colors; i++) { + o = fz_arrayget(obj, i); + e->cinfo.comp_info[i].v_samp_factor = fz_toint(o); + } + } + + /* TODO: quant-tables and huffman-tables */ + + return nil; +} + +void +fz_dropdcte(fz_filter *filter) +{ + fz_dcte *e = (fz_dcte*)filter; + + if (setjmp(e->err.jb)) { + fprintf(stderr, "ioerror in dcte: jpeg_destroy_compress: %s", e->err.msg); + return; + } + + jpeg_destroy_compress(&e->cinfo); +} + +/* Adobe says zigzag order. IJG > v6a says natural order. */ +#if JPEG_LIB_VERSION >= 61 +#define unzigzag(x) unzigzagorder[x] +/* zigzag array position of n'th element of natural array order */ +static const unsigned char unzigzagorder[] = +{ + 0, 1, 5, 6, 14, 15, 27, 28, + 2, 4, 7, 13, 16, 26, 29, 42, + 3, 8, 12, 17, 25, 30, 41, 43, + 9, 11, 18, 24, 31, 40, 44, 53, + 10, 19, 23, 32, 39, 45, 52, 54, + 20, 22, 33, 38, 46, 51, 55, 60, + 21, 34, 37, 47, 50, 56, 59, 61, + 35, 36, 48, 49, 57, 58, 62, 63 +}; +#else +#define unzigzag(x) (x) +#endif + +fz_error * +fz_setquanttables(fz_dcte *e, unsigned int **qtables, int qfactor) +{ + int i, j; + unsigned int table[64]; + + if (setjmp(e->err.jb)) { + return fz_throw("ioerror in dcte: %s", e->err.msg); + } + + /* TODO: check for duplicate tables */ + + for (i = 0; i < e->colors; i++) { + for (j = 0; j < 64; j++) { + table[j] = unzigzag(qtables[i][j]); + } + jpeg_add_quant_table(&e->cinfo, i, table, qfactor, TRUE); + e->cinfo.comp_info[i].quant_tbl_no = i; + } + + return nil; +} + +fz_error * +fz_processdcte(fz_filter *filter, fz_buffer *in, fz_buffer *out) +{ + fz_dcte *e = (fz_dcte*)filter; + JSAMPROW scanline[1]; + int stride; + int i; + + e->dst.buf = out; + e->dst.super.free_in_buffer = out->ep - out->wp; + e->dst.super.next_output_byte = out->wp; + + if (setjmp(e->err.jb)) { + return fz_throw("ioerror in dcte: %s", e->err.msg); + } + + switch (e->stage) + { + case 0: + /* must have enough space for markers, typically 600 bytes or so */ + if (out->wp + 1024 > out->ep) + goto needoutput; + + jpeg_start_compress(&e->cinfo, TRUE); + + /* TODO: write Adobe ColorTransform marker */ + + /* fall through */ + e->stage = 1; + + case 1: + stride = e->columns * e->colors; + + while (e->cinfo.next_scanline < e->cinfo.image_height) + { + if (in->rp + stride > in->wp) + goto needinput; + + scanline[0] = in->rp; + + i = jpeg_write_scanlines(&e->cinfo, scanline, 1); + + if (i == 0) + goto needoutput; + + in->rp += stride; + } + + /* fall through */ + e->stage = 2; + + case 2: + /* must have enough space for end markers */ + if (out->wp + 100 > out->ep) + goto needoutput; + + /* finish compress cannot suspend! */ + jpeg_finish_compress(&e->cinfo); + + e->stage = 3; + out->eof = 1; + out->wp = out->ep - e->dst.super.free_in_buffer; + return fz_iodone; + } + +needinput: + out->wp = out->ep - e->dst.super.free_in_buffer; + return fz_ioneedin; + +needoutput: + out->wp = out->ep - e->dst.super.free_in_buffer; + return fz_ioneedout; +} + diff --git a/stream/filt_faxc.h b/stream/filt_faxc.h new file mode 100644 index 00000000..14cae13f --- /dev/null +++ b/stream/filt_faxc.h @@ -0,0 +1,125 @@ +/* common bit magic */ + +static inline void +printbits(FILE *f, int code, int nbits) +{ + int n, b; + for (n = nbits - 1; n >= 0; n--) + { + b = (code >> n) & 1; + fprintf(f, "%c", b ? '1' : '0'); + } +} + +static inline int +getbit(const unsigned char *buf, int x) +{ + return ( buf[x >> 3] >> ( 7 - (x & 7) ) ) & 1; +} + +static inline void +printline(FILE *f, unsigned char *line, int w) +{ + int i; + for (i = 0; i < w; i++) + fprintf(f, "%c", getbit(line, i) ? '#' : '.'); + fprintf(f, "\n"); +} + +static inline int +getrun(const unsigned char *line, int x, int w, int c) +{ + int z; + int b; + + if (x < 0) + x = 0; + + z = x; + while (z < w) + { + b = getbit(line, z); + if (c != b) + break; + z ++; + } + + return z - x; +} + +static inline int +findchanging(const unsigned char *line, int x, int w) +{ + int a, b; + + if (line == 0) + 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 inline int +findchangingcolor(const unsigned char *line, int x, int w, int color) +{ + if (line == 0) + return w; + + x = findchanging(line, x, w); + + if (x < w && getbit(line, x) != color) + x = findchanging(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]; + } +} + diff --git a/stream/filt_faxd.c b/stream/filt_faxd.c new file mode 100644 index 00000000..d8686a08 --- /dev/null +++ b/stream/filt_faxd.c @@ -0,0 +1,441 @@ +#include + +#include "faxd.h" +#include "faxc.h" + +enum +{ + SNORMAL, /* neutral state, waiting for any code */ + SMAKEUP, /* got a 1d makeup code, waiting for terminating code */ + SEOL, /* at eol, needs output buffer space */ + SH1, SH2 /* in H part 1 and 2 (both makeup and terminating codes) */ +}; + +/* TODO: uncompressed */ + +typedef struct fz_faxd_s fz_faxd; + +struct fz_faxd_s +{ + fz_filter super; + + int k; + int endofline; + int encodedbytealign; + int columns; + int rows; + int endofblock; + int blackis1; + + int stride; + int ridx; + + int bidx; + unsigned int word; + + int stage, a, c, dim, eolc; + unsigned char *ref; + unsigned char *dst; +}; + +fz_error * +fz_newfaxd(fz_filter **fp, fz_obj *params) +{ + fz_obj *obj; + + FZ_NEWFILTER(fz_faxd, fax, faxd); + + fax->ref = nil; + fax->dst = nil; + + fax->k = 0; + fax->endofline = 0; + fax->encodedbytealign = 0; + fax->columns = 1728; + fax->rows = 0; + fax->endofblock = 1; + fax->blackis1 = 0; + + obj = fz_dictgets(params, "K"); + if (obj) fax->k = fz_toint(obj); + + obj = fz_dictgets(params, "EndOfLine"); + if (obj) fax->endofline = fz_tobool(obj); + + obj = fz_dictgets(params, "EncodedByteAlign"); + if (obj) fax->encodedbytealign = fz_tobool(obj); + + obj = fz_dictgets(params, "Columns"); + if (obj) fax->columns = fz_toint(obj); + + obj = fz_dictgets(params, "Rows"); + if (obj) fax->rows = fz_toint(obj); + + obj = fz_dictgets(params, "EndOfBlock"); + if (obj) fax->endofblock = fz_tobool(obj); + + obj = fz_dictgets(params, "BlackIs1"); + if (obj) fax->blackis1 = fz_tobool(obj); + + fax->stride = ((fax->columns - 1) >> 3) + 1; + fax->ridx = 0; + fax->bidx = 32; + fax->word = 0; + + fax->stage = SNORMAL; + fax->a = -1; + fax->c = 0; + fax->dim = fax->k < 0 ? 2 : 1; + fax->eolc = 0; + + fax->ref = fz_malloc(fax->stride); + if (!fax->ref) { fz_free(fax); return fz_outofmem; } + + fax->dst = fz_malloc(fax->stride); + if (!fax->dst) { fz_free(fax); fz_free(fax->ref); return fz_outofmem; } + + memset(fax->ref, 0, fax->stride); + memset(fax->dst, 0, fax->stride); + + return nil; +} + +void +fz_dropfaxd(fz_filter *p) +{ + fz_faxd *fax = (fz_faxd*) p; + fz_free(fax->ref); + fz_free(fax->dst); +} + +static inline void eatbits(fz_faxd *fax, int nbits) +{ + fax->word <<= nbits; + fax->bidx += nbits; +} + +static inline fz_error * fillbits(fz_faxd *fax, fz_buffer *in) +{ + while (fax->bidx >= 8) + { + if (in->rp + 1 > in->wp) + return fz_ioneedin; + fax->bidx -= 8; + fax->word |= *in->rp << fax->bidx; + in->rp ++; + } + return nil; +} + +static int +getcode(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; + } + + eatbits(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 = getcode(fax, cf_black_decode, cfd_black_initial_bits); + else + code = getcode(fax, cf_white_decode, cfd_white_initial_bits); + + if (code == UNCOMPRESSED) + return fz_throw("ioerror: uncompressed data in faxd"); + + if (code < 0) + return fz_throw("ioerror: invalid 1d code in faxd"); + + if (fax->a + code > fax->columns) + return fz_throw("ioerror: invalid 1d data in faxd"); + + if (fax->c) + setbits(fax->dst, fax->a, fax->a + code); + + fax->a += code; + + if (code < 64) + { + fax->c = !fax->c; + fax->stage = SNORMAL; + } + else + fax->stage = SMAKEUP; + + return nil; +} + +/* decode one 2d code */ +static fz_error * +dec2d(fz_faxd *fax) +{ + int code, b1, b2; + + if (fax->stage == SH1 || fax->stage == SH2) + { + if (fax->a == -1) + fax->a = 0; + + if (fax->c) + code = getcode(fax, cf_black_decode, cfd_black_initial_bits); + else + code = getcode(fax, cf_white_decode, cfd_white_initial_bits); + + if (code == UNCOMPRESSED) + return fz_throw("ioerror: uncompressed data in faxd"); + + if (code < 0) + return fz_throw("ioerror: invalid 2d code in faxd"); + + if (fax->a + code > fax->columns) + return fz_throw("ioerror: invalid 2d data in 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 == SH1) + fax->stage = SH2; + else if (fax->stage == SH2) + fax->stage = SNORMAL; + } + + return nil; + } + + code = getcode(fax, cf_2d_decode, cfd_2d_initial_bits); + + switch (code) + { + case H: + fax->stage = SH1; + break; + + case P: + b1 = findchangingcolor(fax->ref, fax->a, fax->columns, !fax->c); + b2 = findchanging(fax->ref, b1, fax->columns); + if (fax->c) setbits(fax->dst, fax->a, b2); + fax->a = b2; + break; + + case V0: + b1 = findchangingcolor(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 = findchangingcolor(fax->ref, fax->a, fax->columns, !fax->c); + if (fax->c) setbits(fax->dst, fax->a, b1 + 1); + fax->a = b1 + 1; + fax->c = !fax->c; + break; + + case VR2: + b1 = findchangingcolor(fax->ref, fax->a, fax->columns, !fax->c); + if (fax->c) setbits(fax->dst, fax->a, b1 + 2); + fax->a = b1 + 2; + fax->c = !fax->c; + break; + + case VR3: + b1 = findchangingcolor(fax->ref, fax->a, fax->columns, !fax->c); + if (fax->c) setbits(fax->dst, fax->a, b1 + 3); + fax->a = b1 + 3; + fax->c = !fax->c; + break; + + case VL1: + b1 = findchangingcolor(fax->ref, fax->a, fax->columns, !fax->c); + if (fax->c) setbits(fax->dst, fax->a, b1 - 1); + fax->a = b1 - 1; + fax->c = !fax->c; + break; + + case VL2: + b1 = findchangingcolor(fax->ref, fax->a, fax->columns, !fax->c); + if (fax->c) setbits(fax->dst, fax->a, b1 - 2); + fax->a = b1 - 2; + fax->c = !fax->c; + break; + + case VL3: + b1 = findchangingcolor(fax->ref, fax->a, fax->columns, !fax->c); + if (fax->c) setbits(fax->dst, fax->a, b1 - 3); + fax->a = b1 - 3; + fax->c = !fax->c; + break; + + case UNCOMPRESSED: + return fz_throw("ioerror: uncompressed data in faxd"); + + case ERROR: + return fz_throw("ioerror: invalid 2d code in faxd"); + + default: + return fz_throw("ioerror: invalid 2d code in faxd (%d)", code); + } + + return 0; +} + +fz_error * +fz_processfaxd(fz_filter *f, fz_buffer *in, fz_buffer *out) +{ + fz_faxd *fax = (fz_faxd*)f; + fz_error *error; + int i; + + if (fax->stage == SEOL) + goto eol; + +loop: + + if (fillbits(fax, in)) + { + if (in->eof) + { + if (fax->bidx > 31) + { + if (fax->a > 0) + goto eol; + goto rtc; + } + } + else + { + return fz_ioneedin; + } + } + + if ((fax->word >> (32 - 12)) == 0) + { + eatbits(fax, 1); + goto loop; + } + + if ((fax->word >> (32 - 12)) == 1) + { + eatbits(fax, 12); + fax->eolc ++; + + if (fax->k > 0) + { + if ((fax->word >> (32 - 1)) == 1) + fax->dim = 1; + else + fax->dim = 2; + eatbits(fax, 1); + } + } + else if (fax->dim == 1) + { + fax->eolc = 0; + error = dec1d(fax); + if (error) return error; + + } + else if (fax->dim == 2) + { + fax->eolc = 0; + error = dec2d(fax); + if (error) return error; + } + + /* no eol check after makeup codes nor in the middle of an H code */ + if (fax->stage == SMAKEUP || fax->stage == SH1 || fax->stage == SH2) + 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 = SEOL; + if (out->wp + fax->stride > out->ep) + return fz_ioneedout; + + if (fax->blackis1) + memcpy(out->wp, fax->dst, fax->stride); + else + for (i = 0; i < fax->stride; i++) + out->wp[i] = ~fax->dst[i]; + + memcpy(fax->ref, fax->dst, fax->stride); + memset(fax->dst, 0, fax->stride); + out->wp += fax->stride; + + fax->stage = SNORMAL; + fax->c = 0; + fax->a = -1; + fax->ridx ++; + + if (!fax->endofblock && 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) + { + if (fax->ridx % fax->k == 0) + fax->dim = 1; + else + fax->dim = 2; + } + + /* if endofline & encodedbytealign, EOLs are *not* optional */ + if (fax->encodedbytealign) + { + if (fax->endofline) + eatbits(fax, (12 - fax->bidx) & 7); + else + eatbits(fax, (8 - fax->bidx) & 7); + } + + goto loop; + +rtc: + i = (32 - fax->bidx) / 8; + while (i-- && in->rp > in->bp) + in->rp --; + + out->eof = 1; + return fz_iodone; +} + diff --git a/stream/filt_faxd.h b/stream/filt_faxd.h new file mode 100644 index 00000000..9f3fb470 --- /dev/null +++ b/stream/filt_faxd.h @@ -0,0 +1,61 @@ +/* Fax G3/G4 tables */ + +/* + the first 2^(initialbits) entries map bit patterns to decodes + let's say initial_bits is 8 for the sake of example + and that the code is 1001 + that means that entries 0x90 .. 0x9f have the entry { val, 4 } + because those are all the bytes that start with the code + and the 4 is the length of the code +... if (n_bits > initial_bits) ... + anyway, in that case, it basically points to a mini table + the n_bits is the maximum length of all codes beginning with that byte + so 2^(n_bits - initial_bits) is the size of the mini-table + 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 +}; + +/* Decoding tables */ + +extern const cfd_node cf_white_decode[]; +extern const cfd_node cf_black_decode[]; +extern const cfd_node cf_2d_decode[]; +extern const cfd_node cf_uncompressed_decode[]; + diff --git a/stream/filt_faxdtab.c b/stream/filt_faxdtab.c new file mode 100644 index 00000000..8e387d03 --- /dev/null +++ b/stream/filt_faxdtab.c @@ -0,0 +1,931 @@ +/* Tables for CCITTFaxDecode filter. */ + +/* This file was generated automatically. It is governed by the same terms */ +/* as the files scfetab.c and scfdgen.c from which it was derived. */ +/* Consult those files for the licensing terms and conditions. */ + +#include "faxd.h" + +/* 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 } +}; + +/* Dummy executable code to pacify compilers. */ +void scfdtab_dummy(void) { } + diff --git a/stream/filt_faxe.c b/stream/filt_faxe.c new file mode 100644 index 00000000..e96c5ace --- /dev/null +++ b/stream/filt_faxe.c @@ -0,0 +1,398 @@ +#include + +#include "faxe.h" +#include "faxc.h" + +/* TODO: honor Rows param */ + +typedef struct fz_faxe_s fz_faxe; + +struct fz_faxe_s +{ + fz_filter super; + + int k; + int endofline; + int encodedbytealign; + int columns; + int endofblock; + int blackis1; + + int stride; + int ridx; /* how many rows in total */ + int bidx; /* how many bits are already used in out->wp */ + unsigned char bsave; /* partial byte saved between process() calls */ + + int stage; + int a0, c; /* mid-line coding state */ + + unsigned char *ref; + unsigned char *src; +}; + +fz_error * +fz_newfaxe(fz_filter **fp, fz_obj *params) +{ + fz_obj *obj; + + FZ_NEWFILTER(fz_faxe, fax, faxe); + + fax->ref = nil; + fax->src = nil; + + fax->k = 0; + fax->endofline = 0; + fax->encodedbytealign = 0; + fax->columns = 1728; + fax->endofblock = 1; + fax->blackis1 = 0; + + obj = fz_dictgets(params, "K"); + if (obj) fax->k = fz_toint(obj); + + obj = fz_dictgets(params, "EndOfLine"); + if (obj) fax->endofline = fz_tobool(obj); + + obj = fz_dictgets(params, "EncodedByteAlign"); + if (obj) fax->encodedbytealign = fz_tobool(obj); + + obj = fz_dictgets(params, "Columns"); + if (obj) fax->columns = fz_toint(obj); + + obj = fz_dictgets(params, "EndOfBlock"); + if (obj) fax->endofblock = fz_tobool(obj); + + obj = fz_dictgets(params, "BlackIs1"); + if (obj) fax->blackis1 = fz_tobool(obj); + + fax->stride = ((fax->columns - 1) >> 3) + 1; + fax->bidx = 0; + fax->ridx = 0; + + fax->stage = 0; + fax->a0 = -1; + fax->c = 0; + + fax->ref = fz_malloc(fax->stride); + if (!fax->ref) { fz_free(fax); return fz_outofmem; } + + fax->src = fz_malloc(fax->stride); + if (!fax->src) { fz_free(fax); fz_free(fax->ref); return fz_outofmem; } + + memset(fax->ref, 0, fax->stride); + memset(fax->src, 0, fax->stride); + + return nil; +} + +void +fz_dropfaxe(fz_filter *p) +{ + fz_faxe *fax = (fz_faxe*) p; + fz_free(fax->src); + fz_free(fax->ref); +} + +enum { codebytes = 2 }; + +static inline int runbytes(int run) +{ + int m = (run / 64) / 40 + 1; /* number of makeup codes */ + return codebytes * (m + 1); /* bytes for makeup + term codes */ +} + +static void +putbits(fz_faxe *fax, fz_buffer *out, int code, int nbits) +{ + while (nbits > 0) + { + if (fax->bidx == 0) + *out->wp = 0; + + /* code does not fit: shift right */ + if (nbits > (8 - fax->bidx)) + { + *out->wp |= code >> (nbits - (8 - fax->bidx)); + nbits = nbits - (8 - fax->bidx); + fax->bidx = 0; + out->wp ++; + } + + /* shift left */ + else + { + *out->wp |= code << ((8 - fax->bidx) - nbits); + fax->bidx += nbits; + if (fax->bidx == 8) + { + fax->bidx = 0; + out->wp ++; + } + nbits = 0; + } + } +} + +static inline void +putcode(fz_faxe *fax, fz_buffer *out, const cfe_code *run) +{ + putbits(fax, out, run->code, run->nbits); +} + +static void +putrun(fz_faxe *fax, fz_buffer *out, int run, int c) +{ + int m; + + const cf_runs *codetable = c ? &cf_black_runs : &cf_white_runs; + + if (run > 63) + { + m = run / 64; + while (m > 40) + { + putcode(fax, out, &codetable->makeup[40]); + m -= 40; + } + if (m > 0) + { + putcode(fax, out, &codetable->makeup[m]); + } + putcode(fax, out, &codetable->termination[run % 64]); + } + else + { + putcode(fax, out, &codetable->termination[run]); + } +} + +static fz_error * +enc1d(fz_faxe *fax, unsigned char *line, fz_buffer *out) +{ + int run; + + if (fax->a0 < 0) + fax->a0 = 0; + + while (fax->a0 < fax->columns) + { + run = getrun(line, fax->a0, fax->columns, fax->c); + + if (out->wp + 1 + runbytes(run) > out->ep) + return fz_ioneedout; + + putrun(fax, out, run, fax->c); + + fax->a0 += run; + fax->c = !fax->c; + } + + return 0; +} + +static fz_error * +enc2d(fz_faxe *fax, unsigned char *ref, unsigned char *src, fz_buffer *out) +{ + int a1, a2, b1, b2; + int run1, run2, n; + + while (fax->a0 < fax->columns) + { + a1 = findchanging(src, fax->a0, fax->columns); + b1 = findchangingcolor(ref, fax->a0, fax->columns, !fax->c); + b2 = findchanging(ref, b1, fax->columns); + + /* pass */ + if (b2 < a1) + { + if (out->wp + 1 + codebytes > out->ep) + return fz_ioneedout; + + putcode(fax, out, &cf2_run_pass); + + fax->a0 = b2; + } + + /* vertical */ + else if (ABS(b1 - a1) <= 3) + { + if (out->wp + 1 + codebytes > out->ep) + return fz_ioneedout; + + putcode(fax, out, &cf2_run_vertical[b1 - a1 + 3]); + + fax->a0 = a1; + fax->c = !fax->c; + } + + /* horizontal */ + else + { + a2 = findchanging(src, a1, fax->columns); + run1 = a1 - fax->a0; + run2 = a2 - a1; + n = codebytes + runbytes(run1) + runbytes(run2); + + if (out->wp + 1 + n > out->ep) + return fz_ioneedout; + + putcode(fax, out, &cf2_run_horizontal); + putrun(fax, out, run1, fax->c); + putrun(fax, out, run2, !fax->c); + + fax->a0 = a2; + } + } + + return 0; +} + +static fz_error * +process(fz_faxe *fax, fz_buffer *in, fz_buffer *out) +{ + fz_error *error; + int i, n; + + while (1) + { + if (in->rp == in->wp && in->eof) + goto rtc; + + switch (fax->stage) + { + case 0: + if (fax->encodedbytealign) + { + if (fax->endofline) + { + if (out->wp + 1 + 1 > out->ep) + return fz_ioneedout; + + /* make sure that EOL ends on a byte border */ + putbits(fax, out, 0, (12 - fax->bidx) & 7); + } + else + { + if (fax->bidx) + { + if (out->wp + 1 > out->ep) + return fz_ioneedout; + fax->bidx = 0; + out->wp ++; + } + } + } + + fax->stage ++; + + case 1: + if (fax->endofline) + { + if (out->wp + 1 + codebytes + 1 > out->ep) + return fz_ioneedout; + + if (fax->k > 0) + { + if (fax->ridx % fax->k == 0) + putcode(fax, out, &cf2_run_eol_1d); + else + putcode(fax, out, &cf2_run_eol_2d); + } + else + { + putcode(fax, out, &cf_run_eol); + } + } + + fax->stage ++; + + case 2: + if (in->rp + fax->stride > in->wp) + { + if (in->eof) /* XXX barf here? */ + goto rtc; + return fz_ioneedin; + } + + memcpy(fax->ref, fax->src, fax->stride); + memcpy(fax->src, in->rp, fax->stride); + + if (!fax->blackis1) + { + for (i = 0; i < fax->stride; i++) + fax->src[i] = ~fax->src[i]; + } + + in->rp += fax->stride; + + fax->c = 0; + fax->a0 = -1; + + fax->stage ++; + + case 3: + error = 0; /* to silence compiler */ + + if (fax->k < 0) + error = enc2d(fax, fax->ref, fax->src, out); + + else if (fax->k == 0) + error = enc1d(fax, fax->src, out); + + else if (fax->k > 0) + { + if (fax->ridx % fax->k == 0) + error = enc1d(fax, fax->src, out); + else + error = enc2d(fax, fax->ref, fax->src, out); + } + + if (error) + return error; + + fax->ridx ++; + + fax->stage = 0; + } + } + +rtc: + if (fax->endofblock) + { + n = fax->k < 0 ? 2 : 6; + + if (out->wp + 1 + codebytes * n > out->ep) + return fz_ioneedout; + + for (i = 0; i < n; i++) + { + putcode(fax, out, &cf_run_eol); + if (fax->k > 0) + putbits(fax, out, 1, 1); + } + } + + if (fax->bidx) + out->wp ++; + out->eof = 1; + + return fz_iodone; +} + +fz_error * +fz_processfaxe(fz_filter *p, fz_buffer *in, fz_buffer *out) +{ + fz_faxe *fax = (fz_faxe*) p; + fz_error *error; + + /* restore partial bits */ + *out->wp = fax->bsave; + + error = process(fax, in, out); + + /* save partial bits */ + fax->bsave = *out->wp; + + return error; +} + diff --git a/stream/filt_faxe.h b/stream/filt_faxe.h new file mode 100644 index 00000000..dd3fc121 --- /dev/null +++ b/stream/filt_faxe.h @@ -0,0 +1,37 @@ +/* Fax G3/G4 tables */ + +typedef struct cfe_code_s cfe_code; + +struct cfe_code_s +{ + unsigned short code; + unsigned short nbits; +}; + +typedef struct cf_runs_s { + cfe_code termination[64]; + cfe_code makeup[41]; +} cf_runs; + +/* Encoding tables */ + +/* Codes common to 1-D and 2-D encoding. */ +extern const cfe_code cf_run_eol; +extern const cf_runs cf_white_runs, cf_black_runs; +extern const cfe_code cf_uncompressed[6]; +extern const cfe_code cf_uncompressed_exit[10]; /* indexed by 2 x length of */ + +/* 1-D encoding. */ +extern const cfe_code cf1_run_uncompressed; + +/* 2-D encoding. */ +enum { cf2_run_vertical_offset = 3 }; +extern const cfe_code cf2_run_pass; +extern const cfe_code cf2_run_vertical[7]; /* indexed by b1 - a1 + offset */ +extern const cfe_code cf2_run_horizontal; +extern const cfe_code cf2_run_uncompressed; + +/* 2-D Group 3 encoding. */ +extern const cfe_code cf2_run_eol_1d; +extern const cfe_code cf2_run_eol_2d; + diff --git a/stream/filt_faxetab.c b/stream/filt_faxetab.c new file mode 100644 index 00000000..409039f4 --- /dev/null +++ b/stream/filt_faxetab.c @@ -0,0 +1,131 @@ +/* Tables for CCITTFaxEncode filter */ + +#include "faxe.h" + +/* Define the end-of-line code. */ +const cfe_code cf_run_eol = {1, 12}; + +/* Define the 1-D code that signals uncompressed data. */ +const cfe_code cf1_run_uncompressed = {0xf, 12}; + +/* Define the 2-D run codes. */ +const cfe_code cf2_run_pass = {0x1, 4}; +const cfe_code cf2_run_vertical[7] = +{ + {0x3, 7}, + {0x3, 6}, + {0x3, 3}, + {0x1, 1}, + {0x2, 3}, + {0x2, 6}, + {0x2, 7} +}; +const cfe_code cf2_run_horizontal = {1, 3}; +const cfe_code cf2_run_uncompressed = {0xf, 10}; + +/* EOL codes for Group 3 2-D. */ +const cfe_code cf2_run_eol_1d = { (1 << 1) + 1, 12 + 1}; +const cfe_code cf2_run_eol_2d = { (1 << 1) + 0, 12 + 1}; + +/* White run codes. */ +const cf_runs cf_white_runs = +{ + /* Termination codes */ + { + {0x35, 8}, {0x7, 6}, {0x7, 4}, {0x8, 4}, + {0xb, 4}, {0xc, 4}, {0xe, 4}, {0xf, 4}, + {0x13, 5}, {0x14, 5}, {0x7, 5}, {0x8, 5}, + {0x8, 6}, {0x3, 6}, {0x34, 6}, {0x35, 6}, + {0x2a, 6}, {0x2b, 6}, {0x27, 7}, {0xc, 7}, + {0x8, 7}, {0x17, 7}, {0x3, 7}, {0x4, 7}, + {0x28, 7}, {0x2b, 7}, {0x13, 7}, {0x24, 7}, + {0x18, 7}, {0x2, 8}, {0x3, 8}, {0x1a, 8}, + {0x1b, 8}, {0x12, 8}, {0x13, 8}, {0x14, 8}, + {0x15, 8}, {0x16, 8}, {0x17, 8}, {0x28, 8}, + {0x29, 8}, {0x2a, 8}, {0x2b, 8}, {0x2c, 8}, + {0x2d, 8}, {0x4, 8}, {0x5, 8}, {0xa, 8}, + {0xb, 8}, {0x52, 8}, {0x53, 8}, {0x54, 8}, + {0x55, 8}, {0x24, 8}, {0x25, 8}, {0x58, 8}, + {0x59, 8}, {0x5a, 8}, {0x5b, 8}, {0x4a, 8}, + {0x4b, 8}, {0x32, 8}, {0x33, 8}, {0x34, 8} + }, + + /* Make-up codes */ + { + {0, 0} /* dummy */ , {0x1b, 5}, {0x12, 5}, {0x17, 6}, + {0x37, 7}, {0x36, 8}, {0x37, 8}, {0x64, 8}, + {0x65, 8}, {0x68, 8}, {0x67, 8}, {0xcc, 9}, + {0xcd, 9}, {0xd2, 9}, {0xd3, 9}, {0xd4, 9}, + {0xd5, 9}, {0xd6, 9}, {0xd7, 9}, {0xd8, 9}, + {0xd9, 9}, {0xda, 9}, {0xdb, 9}, {0x98, 9}, + {0x99, 9}, {0x9a, 9}, {0x18, 6}, {0x9b, 9}, + {0x8, 11}, {0xc, 11}, {0xd, 11}, {0x12, 12}, + {0x13, 12}, {0x14, 12}, {0x15, 12}, {0x16, 12}, + {0x17, 12}, {0x1c, 12}, {0x1d, 12}, {0x1e, 12}, + {0x1f, 12} + } +}; + +/* Black run codes. */ +const cf_runs cf_black_runs = +{ + /* Termination codes */ + { + {0x37, 10}, {0x2, 3}, {0x3, 2}, {0x2, 2}, + {0x3, 3}, {0x3, 4}, {0x2, 4}, {0x3, 5}, + {0x5, 6}, {0x4, 6}, {0x4, 7}, {0x5, 7}, + {0x7, 7}, {0x4, 8}, {0x7, 8}, {0x18, 9}, + {0x17, 10}, {0x18, 10}, {0x8, 10}, {0x67, 11}, + {0x68, 11}, {0x6c, 11}, {0x37, 11}, {0x28, 11}, + {0x17, 11}, {0x18, 11}, {0xca, 12}, {0xcb, 12}, + {0xcc, 12}, {0xcd, 12}, {0x68, 12}, {0x69, 12}, + {0x6a, 12}, {0x6b, 12}, {0xd2, 12}, {0xd3, 12}, + {0xd4, 12}, {0xd5, 12}, {0xd6, 12}, {0xd7, 12}, + {0x6c, 12}, {0x6d, 12}, {0xda, 12}, {0xdb, 12}, + {0x54, 12}, {0x55, 12}, {0x56, 12}, {0x57, 12}, + {0x64, 12}, {0x65, 12}, {0x52, 12}, {0x53, 12}, + {0x24, 12}, {0x37, 12}, {0x38, 12}, {0x27, 12}, + {0x28, 12}, {0x58, 12}, {0x59, 12}, {0x2b, 12}, + {0x2c, 12}, {0x5a, 12}, {0x66, 12}, {0x67, 12} + }, + + /* Make-up codes. */ + { + {0, 0} /* dummy */ , {0xf, 10}, {0xc8, 12}, {0xc9, 12}, + {0x5b, 12}, {0x33, 12}, {0x34, 12}, {0x35, 12}, + {0x6c, 13}, {0x6d, 13}, {0x4a, 13}, {0x4b, 13}, + {0x4c, 13}, {0x4d, 13}, {0x72, 13}, {0x73, 13}, + {0x74, 13}, {0x75, 13}, {0x76, 13}, {0x77, 13}, + {0x52, 13}, {0x53, 13}, {0x54, 13}, {0x55, 13}, + {0x5a, 13}, {0x5b, 13}, {0x64, 13}, {0x65, 13}, + {0x8, 11}, {0xc, 11}, {0xd, 11}, {0x12, 12}, + {0x13, 12}, {0x14, 12}, {0x15, 12}, {0x16, 12}, + {0x17, 12}, {0x1c, 12}, {0x1d, 12}, {0x1e, 12}, + {0x1f, 12} + } +}; + +/* Uncompressed codes. */ +const cfe_code cf_uncompressed[6] = +{ + {1, 1}, + {1, 2}, + {1, 3}, + {1, 4}, + {1, 5}, + {1, 6} +}; + +/* Uncompressed exit codes. */ +const cfe_code cf_uncompressed_exit[10] = +{ + {2, 8}, {3, 8}, + {2, 9}, {3, 9}, + {2, 10}, {3, 10}, + {2, 11}, {3, 11}, + {2, 12}, {3, 12} +}; + +/* Some C compilers insist on having executable code in every file.... */ +void scfetab_dummy(void) { } + diff --git a/stream/filt_filec.c b/stream/filt_filec.c new file mode 100644 index 00000000..05813185 --- /dev/null +++ b/stream/filt_filec.c @@ -0,0 +1,349 @@ +#include + +fz_error * +fz_ferror(fz_file *f) +{ + fz_error *e = f->error; + f->error = nil; + return e; +} + +fz_error * +fz_openfile(fz_file **filep, char *path, int mode) +{ + fz_error *error; + fz_file *file; + int realmode; + int fd; + int n; + + assert(mode == FZ_READ || mode == FZ_WRITE || mode == FZ_APPEND); + + realmode = 0; + if (mode == FZ_READ) + realmode = O_BINARY | O_RDONLY; + if (mode == FZ_WRITE) + realmode = O_BINARY | O_WRONLY | O_CREAT | O_TRUNC; + if (mode == FZ_APPEND) + realmode = O_BINARY | O_WRONLY; + + fd = open(path, realmode, 0644); + if (fd == -1) + return fz_throw("ioerror: open '%s': %s", path, strerror(errno)); + + if (mode == FZ_APPEND) + { + mode = FZ_WRITE; + n = lseek(fd, 0, 2); + if (n == -1) { + error = fz_throw("ioerror: lseek: %s", strerror(errno)); + close(fd); + return error; + } + } + + file = *filep = fz_malloc(sizeof(fz_file)); + if (!file) + return fz_outofmem; + + file->mode = mode; + file->fd = fd; + file->depth = 0; + file->error = nil; + file->filter = nil; + file->in = nil; + file->out = nil; + + error = fz_newbuffer(&file->in, FZ_BUFSIZE); + if (error) + goto cleanup; + + error = fz_newbuffer(&file->out, FZ_BUFSIZE); + if (error) + goto cleanup; + + return nil; + +cleanup: + *filep = nil; + close(fd); + fz_dropbuffer(file->out); + fz_dropbuffer(file->in); + fz_free(file); + return error; +} + +fz_error * +fz_openbuffer(fz_file **filep, fz_buffer *buf, int mode) +{ + fz_error *error; + fz_file *file; + + assert(mode == FZ_READ || mode == FZ_WRITE); + + file = *filep = fz_malloc(sizeof(fz_file)); + if (!file) + return fz_outofmem; + + file->mode = mode; + file->fd = -1; + file->depth = 0; + file->error = nil; + file->filter = nil; + + if (mode == FZ_READ) + { + file->out = fz_keepbuffer(buf); + error = fz_newbuffer(&file->in, FZ_BUFSIZE); + if (error) + goto cleanup; + } + + else + { + error = fz_newbuffer(&file->out, FZ_BUFSIZE); + if (error) + goto cleanup; + file->in = fz_keepbuffer(buf); + } + + return nil; + +cleanup: + *filep = nil; + fz_free(file); + return error; +} + +void +fz_closefile(fz_file *file) +{ + assert(file->depth == 0); + + if (file->mode == FZ_WRITE) + fz_flush(file); + + if (file->error) + { + fz_warn("%s", file->error->msg); + fz_droperror(file->error); + file->error = nil; + } + + if (file->fd != -1) /* open to real file */ + close(file->fd); + + fz_dropbuffer(file->in); + fz_dropbuffer(file->out); + + if (file->filter) + fz_dropfilter(file->filter); + + fz_free(file); +} + +fz_error * +fz_pushfilter(fz_file *file, fz_filter *filter) +{ + fz_error *error; + + /* without a filter, one buffer is ignored: unignore. */ + if (file->depth == 0) + { + fz_buffer *buf; + + buf = file->out; + file->out = file->in; + file->in = buf; + + if (file->mode == FZ_READ) + { + file->out->rp = file->out->bp; + file->out->wp = file->out->bp; + file->out->eof = 0; + } + else + { + file->out->eof = 0; + file->in->rp = file->in->bp; + file->in->wp = file->in->bp; + file->in->eof = 0; + } + + file->filter = fz_keepfilter(filter); + } + + else + { + if (file->mode == FZ_READ) + { + error = fz_chainpipeline(&file->filter, file->filter, filter, file->out); + if (error) + return error; + + error = fz_newbuffer(&file->out, FZ_BUFSIZE); + if (error) + { + fz_unchainpipeline(file->filter, &file->filter, &file->out); + return error; + } + } + + else + { + error = fz_chainpipeline(&file->filter, filter, file->filter, file->in); + if (error) + return error; + + error = fz_newbuffer(&file->in, FZ_BUFSIZE); + if (error) + { + fz_unchainpipeline(file->filter, &file->filter, &file->in); + return error; + } + } + } + + file->depth ++; + + return nil; +} + +void +fz_popfilter(fz_file *file) +{ + fz_buffer *buf; + + assert(file->depth > 0); + + if (file->mode == FZ_WRITE) + fz_flush(file); + + if (file->error) + { + fz_warn("%s", file->error->msg); + fz_droperror(file->error); + file->error = nil; + } + + if (file->depth == 1) + { + fz_dropfilter(file->filter); + file->filter = nil; + + buf = file->out; + file->out = file->in; + file->in = buf; + } + else + { + if (file->mode == FZ_READ) + { + fz_dropbuffer(file->out); + fz_unchainpipeline(file->filter, &file->filter, &file->out); + } + else + { + fz_dropbuffer(file->in); + fz_unchainpipeline(file->filter, &file->filter, &file->in); + } + } + + file->depth --; +} + +int +fz_seek(fz_file *f, int ofs, int whence) +{ + int t; + int c; + + if (f->filter) + { + assert(f->mode == FZ_READ && whence == 0); + + if (ofs < fz_tell(f)) + { + f->error = fz_throw("ioerror: cannot seek backwards in filter"); + return -1; + } + while (fz_tell(f) < ofs) + { + c = fz_readbyte(f); + if (c == EOF) + return -1; + } + return ofs; + } + + if (whence == 1) + { + ofs = fz_tell(f) + ofs; + whence = 0; + } + + if (f->fd == -1) + { + if (whence == 0) + { + if (f->mode == FZ_READ) + f->out->rp = CLAMP(f->out->bp + ofs, f->out->bp, f->in->ep); + else + f->in->wp = CLAMP(f->in->bp + ofs, f->in->bp, f->in->ep); + } + else + { + if (f->mode == FZ_READ) + f->out->rp = CLAMP(f->out->ep + ofs, f->out->bp, f->in->ep); + else + f->in->wp = CLAMP(f->in->ep + ofs, f->in->bp, f->in->ep); + } + return fz_tell(f); + } + + t = lseek(f->fd, ofs, whence); + if (t == -1) + { + f->error = fz_throw("ioerror: lseek: %s", strerror(errno)); + return -1; + } + + f->out->rp = f->out->bp; + f->out->wp = f->out->bp; + f->out->eof = 0; + + return t; +} + +int +fz_tell(fz_file *f) +{ + int t; + + if (f->filter) + { + assert(f->mode == FZ_READ); + return f->filter->count - (f->out->wp - f->out->rp); + } + + if (f->fd == -1) + { + if (f->mode == FZ_READ) + return f->out->rp - f->out->bp; + else + return f->in->wp - f->in->bp; + } + + t = lseek(f->fd, 0, 1); + if (t == -1) + { + f->error = fz_throw("ioerror: lseek: %s", strerror(errno)); + return -1; + } + + if (f->mode == FZ_READ) + return t - (f->out->wp - f->out->rp); + else + return t + (f->in->wp - f->in->rp); +} + diff --git a/stream/filt_filer.c b/stream/filt_filer.c new file mode 100644 index 00000000..a63a7dd2 --- /dev/null +++ b/stream/filt_filer.c @@ -0,0 +1,252 @@ +#include + +static int doread(fz_buffer *b, int fd) +{ + int n = read(fd, b->wp, b->ep - b->wp); + if (n == -1) + return -1; + if (n == 0) + b->eof = 1; + b->wp += n; + return n; +} + +int fz_producedata(fz_file *f) +{ + fz_error *reason; + int produced; + int n; + + assert(f->mode == FZ_READ); + assert(f->error == nil); + + if (!f->filter) + { + fz_rewindbuffer(f->out); + n = doread(f->out, f->fd); + if (n < 0) { + f->error = fz_throw("ioerror in read: %s", strerror(errno)); + return -1; + } + return 0; + } + + produced = 0; + + while (1) + { + reason = fz_process(f->filter, f->in, f->out); + + if (f->filter->produced) + produced = 1; + + if (reason == fz_ioneedin) + { + if (f->in->eof) { + f->error = fz_throw("ioerror: premature eof in filter"); + return -1; + } + + /* no space to produce, rewind or grow */ + if (f->in->wp == f->in->ep) + { + if (f->in->rp > f->in->bp) + f->error = fz_rewindbuffer(f->in); + else + f->error = fz_growbuffer(f->in); + if (f->error) + return -1; + } + + /* then fill with more input */ + n = doread(f->in, f->fd); + if (n < 0) { + f->error = fz_throw("ioerror in read: %s", strerror(errno)); + return -1; + } + + if (produced) + return 0; + } + + else if (reason == fz_ioneedout) + { + if (produced) + return 0; + + /* need more outspace, and produced no data */ + if (f->out->rp > f->out->bp) + f->error = fz_rewindbuffer(f->out); + else + f->error = fz_growbuffer(f->out); + if (f->error) + return -1; + } + + else if (reason == fz_iodone) + return 0; + + else { + f->error = reason; + return -1; + } + } +} + +int +fz_peekbyte(fz_file *f) +{ + if (f->out->rp == f->out->wp) + { + if (f->out->eof) return EOF; + if (fz_producedata(f)) return EOF; + } + + if (f->out->rp < f->out->wp) + return *f->out->rp; + + return EOF; +} + +int +fz_readbyte(fz_file *f) +{ + if (f->out->rp == f->out->wp) + { + if (f->out->eof) return EOF; + if (fz_producedata(f)) return EOF; + } + + if (f->out->rp < f->out->wp) + return *f->out->rp++; + + return EOF; +} + +int +fz_read(fz_file *f, unsigned char *buf, int n) +{ + int i = 0; + + while (i < n) + { + while (f->out->rp < f->out->wp && i < n) + buf[i++] = *f->out->rp ++; + + if (f->out->rp == f->out->wp) + { + if (f->out->eof) return i; + if (fz_producedata(f) < 0) return -1; + } + } + + return i; +} + +int +fz_readline(fz_file *f, char *buf, int n) +{ + int c = EOF; + char *s = buf; + + while (n > 1) + { + c = fz_readbyte(f); + if (c == EOF) + break; + if (c == '\r') { + c = fz_peekbyte(f); + if (c == '\n') + c = fz_readbyte(f); + break; + } + if (c == '\n') + break; + *s++ = c; + n--; + } + if (n) + *s = '\0'; + return s - buf; +} + +/* + * Utility function to consume contents of file stream into + * a freshly allocated buffer; realloced and trimmed to size. + */ + +enum { CHUNKSIZE = 1024 * 32 }; + +fz_error * +fz_readfile(fz_buffer **bufp, fz_file *file) +{ + fz_buffer *real; + unsigned char *newbuf; + unsigned char *buf; + int len; + int pos; + int n; + + *bufp = nil; + + len = 0; + pos = 0; + buf = nil; + + while (1) + { + if (len - pos == 0) + { + len += CHUNKSIZE; + newbuf = fz_realloc(buf, len); + if (!newbuf) + { + fz_free(buf); + return fz_outofmem; + } + buf = newbuf; + } + + n = fz_read(file, buf + pos, len - pos); + + if (n < 0) + { + fz_free(buf); + return fz_ferror(file); + } + + pos += n; + + if (n < CHUNKSIZE) + { + if (pos > 0) + { + newbuf = fz_realloc(buf, pos); + if (!newbuf) + { + fz_free(buf); + return fz_outofmem; + } + } + else newbuf = buf; + + real = *bufp = fz_malloc(sizeof(fz_buffer)); + if (!real) + { + fz_free(newbuf); + return fz_outofmem; + } + + real->refs = 1; + real->ownsdata = 1; + real->bp = buf; + real->rp = buf; + real->wp = buf + pos; + real->ep = buf + pos; + real->eof = 1; + + return nil; + } + } +} + diff --git a/stream/filt_filew.c b/stream/filt_filew.c new file mode 100644 index 00000000..f83399a2 --- /dev/null +++ b/stream/filt_filew.c @@ -0,0 +1,260 @@ +#include + +int +fz_printstring(fz_file *f, char *s) +{ + return fz_write(f, s, strlen(s)); +} + +int +fz_printobj(fz_file *file, fz_obj *obj, int tight) +{ + char buf[1024]; + char *ptr; + int n; + + n = fz_sprintobj(nil, 0, obj, tight); + if (n < sizeof buf) + { + fz_sprintobj(buf, sizeof buf, obj, tight); + return fz_write(file, buf, n); + } + else + { + ptr = fz_malloc(n); + if (!ptr) { + file->error = fz_outofmem; + return -1; + } + fz_sprintobj(ptr, n, obj, tight); + n = fz_write(file, ptr, n); + fz_free(ptr); + return n; + } +} + +int +fz_print(fz_file *f, char *fmt, ...) +{ + va_list ap; + char buf[1024]; + char *p; + int n; + + va_start(ap, fmt); + n = vsnprintf(buf, sizeof buf, fmt, ap); + va_end(ap); + + if (n < sizeof buf) + return fz_write(f, buf, n); + + p = fz_malloc(n); + if (!p) { + f->error = fz_outofmem; + return -1; + } + + va_start(ap, fmt); + vsnprintf(p, n, fmt, ap); + va_end(ap); + + n = fz_write(f, p, n); + + fz_free(p); + + return n; +} + +static int dowrite(fz_buffer *b, int fd) +{ + int n = write(fd, b->rp, b->wp - b->rp); + if (n == -1) + return -1; + b->rp += n; + return n; +} + +int +fz_write(fz_file *f, unsigned char *buf, int n) +{ + fz_error *reason; + int i = 0; + int x; + + assert(f->mode == FZ_WRITE); + assert(f->error == nil); + + if (!f->filter) + { + while (i < n) + { + while (f->in->wp < f->in->ep && i < n) + *f->in->wp++ = buf[i++]; + + if (f->in->wp == f->in->ep) + { + if (f->fd != -1) + { + x = dowrite(f->in, f->fd); + if (x < 0) { + f->error = fz_throw("ioerror in write: %s", strerror(errno)); + return -1; + } + } + + if (f->in->rp > f->in->bp) + f->error = fz_rewindbuffer(f->in); + else + f->error = fz_growbuffer(f->in); + if (f->error) + return -1; + } + } + + return 0; + } + + while (i < n) + { + while (f->in->wp < f->in->ep && i < n) + *f->in->wp++ = buf[i++]; + + if (f->in->wp == f->in->ep) + { + reason = fz_process(f->filter, f->in, f->out); + + if (reason == fz_ioneedin) + { + if (f->in->wp == f->in->ep) { + if (f->in->rp > f->in->bp) + f->error = fz_rewindbuffer(f->in); + else + f->error = fz_growbuffer(f->in); + if (f->error) + return -1; + } + } + + else if (reason == fz_ioneedout) + { + if (f->fd != -1) + { + x = dowrite(f->out, f->fd); + if (x < 0) { + f->error = fz_throw("ioerror in write: %s", strerror(errno)); + return -1; + } + } + + if (f->out->rp > f->out->bp) + f->error = fz_rewindbuffer(f->out); + else + f->error = fz_growbuffer(f->out); + if (f->error) + return -1; + } + + else if (reason == fz_iodone) + { + if (f->fd != -1) + { + while (f->out->rp < f->out->wp) + { + x = dowrite(f->out, f->fd); + if (x < 0) { + f->error = fz_throw("ioerror in write: %s", strerror(errno)); + return -1; + } + } + } + break; + } + + else { + f->error = reason; + return -1; + } + } + } + + return i; +} + +int +fz_flush(fz_file *f) +{ + fz_error *reason; + int n; + + assert(f->mode == FZ_WRITE); + assert(f->error == nil); + + f->in->eof = 1; + + if (!f->filter) + { + if (f->fd != -1) + { + while (f->in->rp < f->in->wp) + { + n = dowrite(f->in, f->fd); + if (n < 0) { + f->error = fz_throw("ioerror in write: %s", strerror(errno)); + return -1; + } + } + } + return 0; + } + + while (!f->out->eof) + { + reason = fz_process(f->filter, f->in, f->out); + + if (reason == fz_ioneedin) { + f->error = fz_throw("ioerror: premature eof in filter"); + return -1; + } + + else if (reason == fz_ioneedout) + { + if (f->fd != -1) + { + n = dowrite(f->out, f->fd); + if (n < 0) { + f->error = fz_throw("ioerror in write: %s", strerror(errno)); + return -1; + } + } + + if (f->out->rp > f->out->bp) + f->error = fz_rewindbuffer(f->out); + else + f->error = fz_growbuffer(f->out); + if (f->error) + return -1; + } + + else if (reason == fz_iodone) + { + if (f->fd != -1) + { + n = dowrite(f->out, f->fd); + if (n < 0) { + f->error = fz_throw("ioerror in write: %s", strerror(errno)); + return -1; + } + } + break; + } + + else + { + f->error = reason; + return -1; + } + } + + return 0; +} + diff --git a/stream/filt_flate.c b/stream/filt_flate.c new file mode 100644 index 00000000..c34a49b7 --- /dev/null +++ b/stream/filt_flate.c @@ -0,0 +1,176 @@ +#include + +#include + +typedef struct fz_flate_s fz_flate; + +struct fz_flate_s +{ + fz_filter super; + z_stream z; +}; + +static void * +zmalloc(void *opaque, unsigned int items, unsigned int size) +{ + fz_memorycontext *mctx = (fz_memorycontext*)opaque; + return mctx->malloc(mctx, items * size); +} + +fz_error * +fz_newflated(fz_filter **fp, fz_obj *params) +{ + fz_error *eo; + int ei; + + FZ_NEWFILTER(fz_flate, f, flated); + + f->z.zalloc = zmalloc; + f->z.zfree = (void(*)(void*,void*))fz_currentmemorycontext()->free; + f->z.opaque = fz_currentmemorycontext(); + f->z.next_in = nil; + f->z.avail_in = 0; + + ei = inflateInit(&f->z); + if (ei != Z_OK) { + eo = fz_throw("ioerror: inflateInit: %s", f->z.msg); + fz_free(f); + return eo; + } + + return nil; +} + +void +fz_dropflated(fz_filter *f) +{ + z_streamp zp = &((fz_flate*)f)->z; + int err; + + err = inflateEnd(zp); + if (err != Z_OK) + fprintf(stderr, "inflateEnd: %s", zp->msg); +} + +fz_error * +fz_processflated(fz_filter *f, fz_buffer *in, fz_buffer *out) +{ + z_streamp zp = &((fz_flate*)f)->z; + int err; + + if (in->rp == in->wp && !in->eof) + return fz_ioneedin; + if (out->wp == out->ep) + return fz_ioneedout; + + zp->next_in = in->rp; + zp->avail_in = in->wp - in->rp; + + zp->next_out = out->wp; + zp->avail_out = out->ep - out->wp; + + err = inflate(zp, Z_NO_FLUSH); + + in->rp = in->wp - zp->avail_in; + out->wp = out->ep - zp->avail_out; + + if (err == Z_STREAM_END) { + out->eof = 1; + return fz_iodone; + } + else if (err == Z_OK) { + if (in->rp == in->wp && !in->eof) + return fz_ioneedin; + if (out->wp == out->ep) + return fz_ioneedout; + return fz_ioneedin; /* hmm, what's going on here? */ + } + else { + return fz_throw("ioerror: inflate: %s", zp->msg); + } +} + +fz_error * +fz_newflatee(fz_filter **fp, fz_obj *params) +{ + fz_obj *obj; + fz_error *eo; + int effort; + int ei; + + FZ_NEWFILTER(fz_flate, f, flatee); + + effort = -1; + + if (params) { + obj = fz_dictgets(params, "Effort"); + if (obj) effort = fz_toint(obj); + } + + f->z.zalloc = zmalloc; + f->z.zfree = (void(*)(void*,void*))fz_currentmemorycontext()->free; + f->z.opaque = fz_currentmemorycontext(); + f->z.next_in = nil; + f->z.avail_in = 0; + + ei = deflateInit(&f->z, effort); + if (ei != Z_OK) { + eo = fz_throw("ioerror: deflateInit: %s", f->z.msg); + fz_free(f); + return eo; + } + + return nil; +} + +void +fz_dropflatee(fz_filter *f) +{ + z_streamp zp = &((fz_flate*)f)->z; + int err; + + err = deflateEnd(zp); + if (err != Z_OK) + fprintf(stderr, "deflateEnd: %s", zp->msg); + + fz_free(f); +} + +fz_error * +fz_processflatee(fz_filter *f, fz_buffer *in, fz_buffer *out) +{ + z_streamp zp = &((fz_flate*)f)->z; + int err; + + if (in->rp == in->wp && !in->eof) + return fz_ioneedin; + if (out->wp == out->ep) + return fz_ioneedout; + + zp->next_in = in->rp; + zp->avail_in = in->wp - in->rp; + + zp->next_out = out->wp; + zp->avail_out = out->ep - out->wp; + + err = deflate(zp, in->eof ? Z_FINISH : Z_NO_FLUSH); + + in->rp = in->wp - zp->avail_in; + out->wp = out->ep - zp->avail_out; + + if (err == Z_STREAM_END) { + out->eof = 1; + return fz_iodone; + } + else if (err == Z_OK) { + if (in->rp == in->wp && !in->eof) + return fz_ioneedin; + if (out->wp == out->ep) + return fz_ioneedout; + return fz_ioneedin; /* hmm? */ + } + else { + return fz_throw("ioerror: deflate: %s", zp->msg); + } +} + diff --git a/stream/filt_jbig2d.c b/stream/filt_jbig2d.c new file mode 100644 index 00000000..ed54eed3 --- /dev/null +++ b/stream/filt_jbig2d.c @@ -0,0 +1,115 @@ +#include + +/* TODO: complete rewrite with error checking and use fitz memctx */ + +/* + so to use a global_ctx, you run your global data through a normal ctx + then call jbig2_make_global_ctx with the normal context + that does the (currently null) conversion + make_global_ctx after i fed it all the global stream data? + maskros: yes + and you pass the new global ctx object to jbig2_ctx_new() when you ++create the per-page ctx +*/ + +#ifdef WIN32 /* Microsoft Visual C++ */ + +typedef signed char int8_t; +typedef short int int16_t; +typedef int int32_t; +typedef __int64 int64_t; + +typedef unsigned char uint8_t; +typedef unsigned short int uint16_t; +typedef unsigned int uint32_t; + +#else +#include +#endif + +#include + +typedef struct fz_jbig2d_s fz_jbig2d; + +struct fz_jbig2d_s +{ + fz_filter super; + Jbig2Ctx *ctx; + Jbig2GlobalCtx *gctx; + Jbig2Image *page; + int idx; +}; + +fz_error * +fz_newjbig2d(fz_filter **fp, fz_obj *params) +{ + FZ_NEWFILTER(fz_jbig2d, d, jbig2d); + d->ctx = jbig2_ctx_new(nil, JBIG2_OPTIONS_EMBEDDED, nil, nil, nil); + d->page = nil; + d->idx = 0; + return nil; +} + +void +fz_dropjbig2d(fz_filter *filter) +{ + fz_jbig2d *d = (fz_jbig2d*)filter; + jbig2_ctx_free(d->ctx); +} + +fz_error * +fz_setjbig2dglobalstream(fz_filter *filter, unsigned char *buf, int len) +{ + fz_jbig2d *d = (fz_jbig2d*)filter; + jbig2_data_in(d->ctx, buf, len); + d->gctx = jbig2_make_global_ctx(d->ctx); + d->ctx = jbig2_ctx_new(nil, JBIG2_OPTIONS_EMBEDDED, d->gctx, nil, nil); + return nil; +} + +fz_error * +fz_processjbig2d(fz_filter *filter, fz_buffer *in, fz_buffer *out) +{ + fz_jbig2d *d = (fz_jbig2d*)filter; + int len; + int i; + + while (1) + { + if (in->rp == in->wp) { + if (!in->eof) + return fz_ioneedin; + + if (!d->page) { + jbig2_complete_page(d->ctx); + d->page = jbig2_page_out(d->ctx); + } + + if (out->wp == out->ep) + return fz_ioneedout; + + len = out->ep - out->wp; + if (d->idx + len > d->page->height * d->page->stride) + len = d->page->height * d->page->stride - d->idx; + + /* XXX memcpy(out->wp, d->page->data + d->idx, len); */ + for (i = 0; i < len; i++) + out->wp[i] = ~ d->page->data[d->idx + i]; + + out->wp += len; + d->idx += len; + + if (d->idx == d->page->height * d->page->stride) { + jbig2_release_page(d->ctx, d->page); + out->eof = 1; + return fz_iodone; + } + } + else { + len = in->wp - in->rp; + jbig2_data_in(d->ctx, in->rp, len); + in->rp += len; + } + } +} + diff --git a/stream/filt_jpxd.c b/stream/filt_jpxd.c new file mode 100644 index 00000000..2aa93448 --- /dev/null +++ b/stream/filt_jpxd.c @@ -0,0 +1,143 @@ +#include + +/* TODO: bpc */ + +/* + * We use the Jasper JPEG2000 coder for now. + */ + +#include + +static char *colorspacename(jas_clrspc_t clrspc) +{ + switch (jas_clrspc_fam(clrspc)) + { + case JAS_CLRSPC_FAM_UNKNOWN: return "Unknown"; + case JAS_CLRSPC_FAM_XYZ: return "XYZ"; + case JAS_CLRSPC_FAM_LAB: return "Lab"; + case JAS_CLRSPC_FAM_GRAY: return "Gray"; + case JAS_CLRSPC_FAM_RGB: return "RGB"; + case JAS_CLRSPC_FAM_YCBCR: return "YCbCr"; + } + return "Unknown"; +} + +typedef struct fz_jpxd_s fz_jpxd; + +struct fz_jpxd_s +{ + fz_filter super; + jas_stream_t *stream; + jas_image_t *image; + int offset; + int stage; +}; + +fz_error * +fz_newjpxd(fz_filter **fp, fz_obj *params) +{ + int err; + + FZ_NEWFILTER(fz_jpxd, d, jpxd); + + err = jas_init(); + if (err) { + fz_free(d); + return fz_throw("ioerror in jpxd: jas_init()"); + } + + d->stream = jas_stream_memopen(nil, 0); + if (!d->stream) { + fz_free(d); + return fz_throw("ioerror in jpxd: jas_stream_memopen()"); + } + + d->image = nil; + d->offset = 0; + d->stage = 0; + + return nil; +} + +void +fz_dropjpxd(fz_filter *filter) +{ + fz_jpxd *d = (fz_jpxd*)filter; + if (d->stream) jas_stream_close(d->stream); + if (d->image) jas_image_destroy(d->image); +} + +fz_error * +fz_processjpxd(fz_filter *filter, fz_buffer *in, fz_buffer *out) +{ + fz_jpxd *d = (fz_jpxd*)filter; + int n, bpc, w, h; + int i, x, y; + + switch (d->stage) + { + case 0: goto input; + case 1: goto decode; + case 2: goto output; + } + +input: + while (in->rp < in->wp) { + n = jas_stream_write(d->stream, in->rp, in->wp - in->rp); + in->rp += n; + } + + if (!in->eof) + return fz_ioneedin; + + d->stage = 1; + +decode: + jas_stream_seek(d->stream, 0, 0); + + d->image = jas_image_decode(d->stream, -1, 0); + if (!d->image) + return fz_throw("ioerror in jpxd: unable to decode image data"); + + fprintf(stderr, "P%c\n# JPX %d x %d n=%d bpc=%d colorspace=%04x %s\n%d %d\n%d\n", + jas_image_numcmpts(d->image) == 1 ? '5' : '6', + + jas_image_width(d->image), + jas_image_height(d->image), + jas_image_numcmpts(d->image), + jas_image_cmptprec(d->image, 0), + jas_image_clrspc(d->image), + colorspacename(jas_image_clrspc(d->image)), + + jas_image_width(d->image), + jas_image_height(d->image), + (1 << jas_image_cmptprec(d->image, 0)) - 1); + + d->stage = 2; + +output: + w = jas_image_width(d->image); + h = jas_image_height(d->image); + n = jas_image_numcmpts(d->image); + bpc = jas_image_cmptprec(d->image, 0); /* use precision of first component for all... */ + + while (d->offset < w * h) + { + y = d->offset / w; + x = d->offset - y * w; + + /* FIXME bpc != 8 */ + + if (out->wp + n >= out->ep) + return fz_ioneedout; + + for (i = 0; i < n; i++) + *out->wp++ = jas_image_readcmptsample(d->image, i, x, y); + + d->offset ++; + } + + out->eof = 1; + return fz_iodone; +} + diff --git a/stream/filt_lzwd.c b/stream/filt_lzwd.c new file mode 100644 index 00000000..95fc462a --- /dev/null +++ b/stream/filt_lzwd.c @@ -0,0 +1,253 @@ +#include + +/* TODO: error checking */ + +enum +{ + MINBITS = 9, + MAXBITS = 12, + NUMCODES = (1 << MAXBITS), + LZW_CLEAR = 256, + LZW_EOD = 257, + LZW_FIRST = 258 +}; + +typedef struct lzw_code_s lzw_code; + +struct lzw_code_s +{ + int prev; /* prev code (in string) */ + unsigned short length; /* string len, including this token */ + unsigned char value; /* data value */ + unsigned char firstchar; /* first token of string */ +}; + +typedef struct fz_lzwd_s fz_lzwd; + +struct fz_lzwd_s +{ + fz_filter super; + + int earlychange; + + unsigned int word; /* bits loaded from data */ + int bidx; + + int resume; /* resume output of code from needout */ + int codebits; /* num bits/code */ + int code; /* current code */ + int oldcode; /* previously recognized code */ + int nextcode; /* next free entry */ + lzw_code table[NUMCODES]; +}; + +fz_error * +fz_newlzwd(fz_filter **fp, fz_obj *params) +{ + int i; + + FZ_NEWFILTER(fz_lzwd, lzw, lzwd); + + lzw->earlychange = 0; + + if (params) + { + fz_obj *obj; + obj = fz_dictgets(params, "EarlyChange"); + if (obj) lzw->earlychange = fz_toint(obj) != 0; + } + + lzw->bidx = 32; + lzw->word = 0; + + for (i = 0; i < 256; i++) + { + lzw->table[i].value = i; + lzw->table[i].firstchar = i; + lzw->table[i].length = 1; + lzw->table[i].prev = -1; + } + + for (i = LZW_FIRST; i < NUMCODES; i++) + { + lzw->table[i].value = 0; + lzw->table[i].firstchar = 0; + lzw->table[i].length = 0; + lzw->table[i].prev = -1; + } + + lzw->codebits = MINBITS; + lzw->code = -1; + lzw->nextcode = LZW_FIRST; + lzw->oldcode = -1; + lzw->resume = 0; + + return nil; +} + +void +fz_droplzwd(fz_filter *filter) +{ +} + +static inline void eatbits(fz_lzwd *lzw, int nbits) +{ + lzw->word <<= nbits; + lzw->bidx += nbits; +} + +static inline fz_error * fillbits(fz_lzwd *lzw, fz_buffer *in) +{ + while (lzw->bidx >= 8) + { + if (in->rp + 1 > in->wp) + return fz_ioneedin; + lzw->bidx -= 8; + lzw->word |= *in->rp << lzw->bidx; + in->rp ++; + } + return nil; +} + +static inline void unstuff(fz_lzwd *lzw, fz_buffer *in) +{ + int i = (32 - lzw->bidx) / 8; + while (i-- && in->rp > in->bp) + in->rp --; +} + +fz_error * +fz_processlzwd(fz_filter *filter, fz_buffer *in, fz_buffer *out) +{ + fz_lzwd *lzw = (fz_lzwd*)filter; + unsigned char *s; + int len; + + if (lzw->resume) + { + lzw->resume = 0; + goto output; + } + + while (1) + { + if (fillbits(lzw, in)) + { + if (in->eof) + { + if (lzw->bidx > 32 - lzw->codebits) + { + out->eof = 1; + unstuff(lzw, in); + return fz_iodone; + } + } + else + { + return fz_ioneedin; + } + } + + lzw->code = lzw->word >> (32 - lzw->codebits); + + if (lzw->code == LZW_EOD) + { + eatbits(lzw, lzw->codebits); + out->eof = 1; + unstuff(lzw, in); + return fz_iodone; + } + + if (lzw->code == LZW_CLEAR) + { + int oldcodebits = lzw->codebits; + + lzw->codebits = MINBITS; + lzw->nextcode = LZW_FIRST; + + lzw->code = lzw->word >> (32 - oldcodebits - MINBITS) & ((1 << MINBITS) - 1); + + if (lzw->code == LZW_EOD) + { + eatbits(lzw, oldcodebits + MINBITS); + out->eof = 1; + unstuff(lzw, in); + return fz_iodone; + } + + if (out->wp + 1 > out->ep) + return fz_ioneedout; + + *out->wp++ = lzw->code; + + lzw->oldcode = lzw->code; + + eatbits(lzw, oldcodebits + MINBITS); + + continue; + } + + eatbits(lzw, lzw->codebits); + + /* if stream starts without a clear code, oldcode is undefined... */ + if (lzw->oldcode == -1) + { + lzw->oldcode = lzw->code; + goto output; + } + + /* add new entry to the code table */ + lzw->table[lzw->nextcode].prev = lzw->oldcode; + lzw->table[lzw->nextcode].firstchar = lzw->table[lzw->oldcode].firstchar; + lzw->table[lzw->nextcode].length = lzw->table[lzw->oldcode].length + 1; + if (lzw->code < lzw->nextcode) + lzw->table[lzw->nextcode].value = lzw->table[lzw->code].firstchar; + else + lzw->table[lzw->nextcode].value = lzw->table[lzw->nextcode].firstchar; + + lzw->nextcode ++; + + if (lzw->nextcode >= (1 << lzw->codebits) - lzw->earlychange - 1) + { + lzw->codebits ++; + if (lzw->codebits > MAXBITS) + lzw->codebits = MAXBITS; /* FIXME */ + } + + lzw->oldcode = lzw->code; + +output: + /* code maps to a string, copy to output (in reverse...) */ + if (lzw->code > 255) + { + if (out->wp + lzw->table[lzw->code].length > out->ep) + { + lzw->resume = 1; + return fz_ioneedout; + } + + len = lzw->table[lzw->code].length; + s = out->wp + len; + + do + { + *(--s) = lzw->table[lzw->code].value; + lzw->code = lzw->table[lzw->code].prev; + } while (lzw->code >= 0 && s > out->wp); + out->wp += len; + } + + /* ... or just a single character */ + else + { + if (out->wp + 1 > out->ep) + { + lzw->resume = 1; + return fz_ioneedout; + } + + *out->wp++ = lzw->code; + } + } +} + diff --git a/stream/filt_lzwe.c b/stream/filt_lzwe.c new file mode 100644 index 00000000..f2c3c7a4 --- /dev/null +++ b/stream/filt_lzwe.c @@ -0,0 +1,261 @@ +#include + +#define noDEBUG 1 + +enum +{ + MINBITS = 9, + MAXBITS = 12, + MAXBYTES = 2, + NUMCODES = (1 << MAXBITS), + LZW_CLEAR = 256, + LZW_EOD = 257, + LZW_FIRST = 258, + HSIZE = 9001, /* 91% occupancy (???) */ + HSHIFT = (13 - 8) +}; + +typedef struct lzw_hash_s lzw_hash; + +struct lzw_hash_s +{ + int hash; + int code; +}; + +typedef struct fz_lzwe_s fz_lzwe; + +struct fz_lzwe_s +{ + fz_filter super; + + int earlychange; + + int bidx; /* partial bits used in out->wp */ + unsigned char bsave; /* partial byte saved between process() calls */ + + int resume; + int code; + int fcode; + int hcode; + + int codebits; + int oldcode; + int nextcode; + + lzw_hash table[HSIZE]; +}; + +static void +clearhash(fz_lzwe *lzw) +{ + int i; + for (i = 0; i < HSIZE; i++) + lzw->table[i].hash = -1; +} + +fz_error * +fz_newlzwe(fz_filter **fp, fz_obj *params) +{ + FZ_NEWFILTER(fz_lzwe, lzw, lzwe); + + lzw->earlychange = 0; + + if (params) + { + fz_obj *obj; + obj = fz_dictgets(params, "EarlyChange"); + if (obj) lzw->earlychange = fz_toint(obj) != 0; + } + + lzw->bidx = 0; + lzw->bsave = 0; + + lzw->resume = 0; + lzw->code = -1; + lzw->hcode = -1; + lzw->fcode = -1; + + lzw->codebits = MINBITS; + lzw->nextcode = LZW_FIRST; + lzw->oldcode = -1; /* generates LZW_CLEAR */ + + clearhash(lzw); + + return nil; +} + +void +fz_droplzwe(fz_filter *filter) +{ +} + +static void +putcode(fz_lzwe *lzw, fz_buffer *out, int code) +{ + int nbits = lzw->codebits; + + while (nbits > 0) + { + if (lzw->bidx == 0) + { + *out->wp = 0; + } + + /* code does not fit: shift right */ + if (nbits > (8 - lzw->bidx)) + { + *out->wp |= code >> (nbits - (8 - lzw->bidx)); + nbits = nbits - (8 - lzw->bidx); + lzw->bidx = 0; + out->wp ++; + } + + /* shift left */ + else + { + *out->wp |= code << ((8 - lzw->bidx) - nbits); + lzw->bidx += nbits; + if (lzw->bidx == 8) + { + lzw->bidx = 0; + out->wp ++; + } + nbits = 0; + } + } +} + + +static fz_error * +compress(fz_lzwe *lzw, fz_buffer *in, fz_buffer *out) +{ + if (lzw->resume) + { + lzw->resume = 0; + goto resume; + } + + /* at start of data, output a clear code */ + if (lzw->oldcode == -1) + { + if (out->wp + 3 > out->ep) + return fz_ioneedout; + + if (in->rp + 1 > in->wp) + { + if (in->eof) + goto eof; + return fz_ioneedin; + } + + putcode(lzw, out, LZW_CLEAR); + + lzw->oldcode = *in->rp++; + } + +begin: + while (1) + { + if (in->rp + 1 > in->wp) + { + if (in->eof) + goto eof; + return fz_ioneedin; + } + + /* read character */ + lzw->code = *in->rp++; + + /* hash string + character */ + lzw->fcode = (lzw->code << MAXBITS) + lzw->oldcode; + lzw->hcode = (lzw->code << HSHIFT) ^ lzw->oldcode; + + /* primary hash */ + if (lzw->table[lzw->hcode].hash == lzw->fcode) + { + lzw->oldcode = lzw->table[lzw->hcode].code; + continue; + } + + /* secondary hash */ + if (lzw->table[lzw->hcode].hash != -1) + { + int disp = HSIZE - lzw->hcode; + if (lzw->hcode == 0) + disp = 1; + do + { + lzw->hcode = lzw->hcode - disp; + if (lzw->hcode < 0) + lzw->hcode += HSIZE; + if (lzw->table[lzw->hcode].hash == lzw->fcode) + { + lzw->oldcode = lzw->table[lzw->hcode].code; + goto begin; + } + } while (lzw->table[lzw->hcode].hash != -1); + } + +resume: + /* new entry: emit code and add to table */ + + /* reserve space for this code and an eventual CLEAR code */ + if (out->wp + 5 > out->ep) + { + lzw->resume = 1; + return fz_ioneedout; + } + + putcode(lzw, out, lzw->oldcode); + + lzw->oldcode = lzw->code; + lzw->table[lzw->hcode].code = lzw->nextcode; + lzw->table[lzw->hcode].hash = lzw->fcode; + + lzw->nextcode ++; + + /* table is full: emit clear code and reset */ + if (lzw->nextcode == NUMCODES - 1) + { + putcode(lzw, out, LZW_CLEAR); + clearhash(lzw); + lzw->nextcode = LZW_FIRST; + lzw->codebits = MINBITS; + } + + /* check if next entry will be too big for the code size */ + else if (lzw->nextcode >= (1 << lzw->codebits) - lzw->earlychange) + { + lzw->codebits ++; + } + } + +eof: + if (out->wp + 5 > out->ep) + return fz_ioneedout; + + putcode(lzw, out, lzw->oldcode); + putcode(lzw, out, LZW_EOD); + + out->eof = 1; + return fz_iodone; +} + +fz_error * +fz_processlzwe(fz_filter *filter, fz_buffer *in, fz_buffer *out) +{ + fz_lzwe *lzw = (fz_lzwe*)filter; + fz_error *error; + + /* restore partial bits */ + *out->wp = lzw->bsave; + + error = compress(lzw, in, out); + + /* save partial bits */ + lzw->bsave = *out->wp; + + return error; +} + diff --git a/stream/filt_null.c b/stream/filt_null.c new file mode 100644 index 00000000..e83b6d5a --- /dev/null +++ b/stream/filt_null.c @@ -0,0 +1,50 @@ +#include + +typedef struct fz_nullfilter_s fz_nullfilter; + +struct fz_nullfilter_s +{ + fz_filter super; + int len; + int cur; +}; + +fz_error * +fz_newnullfilter(fz_filter **fp, int len) +{ + FZ_NEWFILTER(fz_nullfilter, f, nullfilter); + f->len = len; + f->cur = 0; + return nil; +} + +void +fz_dropnullfilter(fz_filter *f) +{ +} + +fz_error * +fz_processnullfilter(fz_filter *filter, fz_buffer *in, fz_buffer *out) +{ + fz_nullfilter *f = (fz_nullfilter*)filter; + int n; + + n = MIN(MIN(in->wp - in->rp, out->ep - out->wp), f->len - f->cur); + + if (n) { + memcpy(out->wp, in->rp, n); + in->rp += n; + out->wp += n; + f->cur += n; + } + + if (f->cur == f->len) + return fz_iodone; + if (in->rp == in->wp) + return fz_ioneedin; + if (out->wp == out->ep) + return fz_ioneedout; + + return fz_throw("braindead programmer in nullfilter"); +} + diff --git a/stream/filt_pipeline.c b/stream/filt_pipeline.c new file mode 100644 index 00000000..7b7f4252 --- /dev/null +++ b/stream/filt_pipeline.c @@ -0,0 +1,128 @@ +#include + +#define noDEBUG 1 + +typedef struct fz_pipeline_s fz_pipeline; + +fz_error * fz_processpipeline(fz_filter *filter, fz_buffer *in, fz_buffer *out); + +struct fz_pipeline_s +{ + fz_filter super; + fz_filter *head; + fz_buffer *buffer; + fz_filter *tail; + int tailneedsin; +}; + +fz_error * +fz_chainpipeline(fz_filter **fp, fz_filter *head, fz_filter *tail, fz_buffer *buf) +{ + FZ_NEWFILTER(fz_pipeline, p, pipeline); + p->head = fz_keepfilter(head); + p->tail = fz_keepfilter(tail); + p->tailneedsin = 1; + p->buffer = fz_keepbuffer(buf); + return nil; +} + +void +fz_unchainpipeline(fz_filter *filter, fz_filter **oldfp, fz_buffer **oldbp) +{ + fz_pipeline *p = (fz_pipeline*)filter; + + *oldfp = fz_keepfilter(p->head); + *oldbp = fz_keepbuffer(p->buffer); + + fz_dropfilter(filter); +} + +fz_error * +fz_newpipeline(fz_filter **fp, fz_filter *head, fz_filter *tail) +{ + fz_error *error; + + FZ_NEWFILTER(fz_pipeline, p, pipeline); + p->head = fz_keepfilter(head); + p->tail = fz_keepfilter(tail); + p->tailneedsin = 1; + + error = fz_newbuffer(&p->buffer, FZ_BUFSIZE); + if (error) { fz_free(p); return error; } + + return nil; +} + +void +fz_droppipeline(fz_filter *filter) +{ + fz_pipeline *p = (fz_pipeline*)filter; + fz_dropfilter(p->head); + fz_dropfilter(p->tail); + fz_dropbuffer(p->buffer); +} + +fz_error * +fz_processpipeline(fz_filter *filter, fz_buffer *in, fz_buffer *out) +{ + fz_pipeline *p = (fz_pipeline*)filter; + fz_error *e; + + if (p->buffer->eof) + goto tail; + + if (p->tailneedsin && p->head->produced) + goto tail; + +head: + e = fz_process(p->head, in, p->buffer); + + if (e == fz_ioneedin) + return fz_ioneedin; + + else if (e == fz_ioneedout) + { + if (p->tailneedsin && !p->head->produced) + { + fz_error *be = nil; + if (p->buffer->rp > p->buffer->bp) + be = fz_rewindbuffer(p->buffer); + else + be = fz_growbuffer(p->buffer); + if (be) + return be; + goto head; + } + goto tail; + } + + else if (e == fz_iodone) + goto tail; + + else + return e; + +tail: + e = fz_process(p->tail, p->buffer, out); + + if (e == fz_ioneedin) + { + if (p->buffer->eof) + return fz_throw("ioerror: premature eof in pipeline"); + p->tailneedsin = 1; + goto head; + } + + else if (e == fz_ioneedout) + { + p->tailneedsin = 0; + return fz_ioneedout; + } + + else if (e == fz_iodone) + return fz_iodone; + + else + return e; +} + diff --git a/stream/filt_predict.c b/stream/filt_predict.c new file mode 100644 index 00000000..d7b594ac --- /dev/null +++ b/stream/filt_predict.c @@ -0,0 +1,238 @@ +#include + +/* TODO: check if this works with 16bpp images */ + +enum { MAXC = 16 }; + +typedef struct fz_predict_s fz_predict; + +struct fz_predict_s +{ + fz_filter super; + + int predictor; + int columns; + int colors; + int bpc; + + int stride; + int bpp; + unsigned char *ref; + + int encode; +}; + +fz_error * +fz_newpredict(fz_filter **fp, fz_obj *params, int encode) +{ + fz_obj *obj; + + FZ_NEWFILTER(fz_predict, p, predict); + + p->encode = encode; + + p->predictor = 1; + p->columns = 1; + p->colors = 1; + p->bpc = 8; + + obj = fz_dictgets(params, "Predictor"); + if (obj) p->predictor = fz_toint(obj); + + obj = fz_dictgets(params, "Columns"); + if (obj) p->columns = fz_toint(obj); + + obj = fz_dictgets(params, "Colors"); + if (obj) p->colors = fz_toint(obj); + + obj = fz_dictgets(params, "BitsPerComponent"); + if (obj) p->bpc = fz_toint(obj); + + p->stride = (p->bpc * p->colors * p->columns + 7) / 8; + p->bpp = (p->bpc * p->colors + 7) / 8; + + if (p->predictor >= 10) { + p->ref = fz_malloc(p->stride); + if (!p->ref) { fz_free(p); return fz_outofmem; } + memset(p->ref, 0, p->stride); + } + else { + p->ref = nil; + } + + return nil; +} + +void +fz_droppredict(fz_filter *filter) +{ + fz_predict *p = (fz_predict*)filter; + fz_free(p->ref); +} + +static inline int +getcomponent(unsigned char *buf, int x, int bpc) +{ + switch (bpc) + { + case 1: return buf[x / 8] >> (7 - (x % 8)) & 0x01; + case 2: return buf[x / 4] >> ((3 - (x % 4)) * 2) & 0x03; + case 4: return buf[x / 2] >> ((1 - (x % 2)) * 4) & 0x0f; + case 8: return buf[x]; + } + return 0; +} + +static inline void +putcomponent(unsigned char *buf, int x, int bpc, int value) +{ + switch (bpc) + { + case 1: buf[x / 8] |= value << (7 - (x % 8)); break; + case 2: buf[x / 4] |= value << ((3 - (x % 4)) * 2); break; + case 4: buf[x / 2] |= value << ((1 - (x % 2)) * 4); break; + case 8: buf[x] = value; break; + } +} + +static inline int +paeth(int a, int b, int c) +{ + /* The definitions of ac and bc are correct, not a typo. */ + int ac = b - c, bc = a - c, abcc = ac + bc; + int pa = (ac < 0 ? -ac : ac); + int pb = (bc < 0 ? -bc : bc); + int pc = (abcc < 0 ? -abcc : abcc); + return pa <= pb && pa <= pc ? a : pb <= pc ? b : c; +} + +static inline void +none(fz_predict *p, unsigned char *in, unsigned char *out) +{ + memcpy(out, in, p->stride); +} + +static void +tiff(fz_predict *p, unsigned char *in, unsigned char *out) +{ + int left[MAXC]; + int i, k; + + for (k = 0; k < p->colors; k++) + left[k] = 0; + + for (i = 0; i < p->columns; i++) { + for (k = 0; k < p->colors; k++) { + int a = getcomponent(in, i * p->colors + k, p->bpc); + int b = p->encode ? a - left[k] : a + left[k]; + int c = b % (1 << p->bpc); + putcomponent(out, i * p->colors + k, p->bpc, c); + left[k] = p->encode ? a : c; + } + } +} + +static void +png(fz_predict *p, unsigned char *in, unsigned char *out, int predictor) +{ + int upleft[MAXC], left[MAXC], i, k; + + for (k = 0; k < p->bpp; k++) { + left[k] = 0; + upleft[k] = 0; + } + + if (p->encode) + { + for (k = 0, i = 0; i < p->stride; k = (k + 1) % p->bpp, i ++) + { + switch (predictor) + { + case 0: out[i] = in[i]; break; + case 1: out[i] = in[i] - left[k]; break; + case 2: out[i] = in[i] - p->ref[i]; break; + case 3: out[i] = in[i] - (left[k] + p->ref[i]) / 2; break; + case 4: out[i] = in[i] - paeth(left[k], p->ref[i], upleft[k]); break; + } + left[k] = in[i]; + upleft[k] = p->ref[i]; + } + } + + else + { + for (k = 0, i = 0; i < p->stride; k = (k + 1) % p->bpp, i ++) + { + switch (predictor) + { + case 0: out[i] = in[i]; break; + case 1: out[i] = in[i] + left[k]; break; + case 2: out[i] = in[i] + p->ref[i]; break; + case 3: out[i] = in[i] + (left[k] + p->ref[i]) / 2; break; + case 4: out[i] = in[i] + paeth(left[k], p->ref[i], upleft[k]); break; + } + left[k] = out[i]; + upleft[k] = p->ref[i]; + } + } +} + +fz_error * +fz_processpredict(fz_filter *filter, fz_buffer *in, fz_buffer *out) +{ + fz_predict *dec = (fz_predict*)filter; + int ispng = dec->predictor >= 10; + int predictor; + + while (1) + { + if (in->rp + dec->stride + (!dec->encode && ispng) > in->wp) { + if (in->eof) + return fz_iodone; + return fz_ioneedin; + } + + if (out->wp + dec->stride + (dec->encode && ispng) > out->ep) + return fz_ioneedout; + + if (dec->predictor == 1) { + none(dec, in->rp, out->wp); + } + else if (dec->predictor == 2) { + if (dec->bpc != 8) + memset(out->wp, 0, dec->stride); + tiff(dec, in->rp, out->wp); + } + else { + if (dec->encode) { + predictor = dec->predictor - 10; + if (predictor < 0 || predictor > 4) + predictor = 1; + *out->wp ++ = predictor; + } + else { + predictor = *in->rp++; + } + png(dec, in->rp, out->wp, predictor); + } + + if (dec->ref) + memcpy(dec->ref, out->wp, dec->stride); + + in->rp += dec->stride; + out->wp += dec->stride; + } +} + +fz_error * +fz_newpredictd(fz_filter **fp, fz_obj *params) +{ + return fz_newpredict(fp, params, 0); +} + +fz_error * +fz_newpredicte(fz_filter **fp, fz_obj *params) +{ + return fz_newpredict(fp, params, 1); +} + diff --git a/stream/filt_process.c b/stream/filt_process.c new file mode 100644 index 00000000..afe4feed --- /dev/null +++ b/stream/filt_process.c @@ -0,0 +1,51 @@ +#include + +fz_error fz_kioneedin = { -1, "", "", "filter.c", 0 }; +fz_error fz_kioneedout = { -1, "", "", "filter.c", 0 }; +fz_error fz_kiodone = { -1, "", "", "filter.c", 0 }; + +fz_error * +fz_process(fz_filter *f, fz_buffer *in, fz_buffer *out) +{ + fz_error *reason; + unsigned char *oldrp; + unsigned char *oldwp; + + assert(!out->eof); + + oldrp = in->rp; + oldwp = out->wp; + + reason = f->process(f, in, out); + + assert(in->rp <= in->wp); + assert(out->wp <= out->ep); + + f->consumed = in->rp > oldrp; + f->produced = out->wp > oldwp; + f->count += out->wp - oldwp; + + if (reason != fz_ioneedin && reason != fz_ioneedout) + out->eof = 1; + + return reason; +} + +fz_filter * +fz_keepfilter(fz_filter *f) +{ + f->refs ++; + return f; +} + +void +fz_dropfilter(fz_filter *f) +{ + if (--f->refs == 0) + { + if (f->drop) + f->drop(f); + fz_free(f); + } +} + diff --git a/stream/filt_rld.c b/stream/filt_rld.c new file mode 100644 index 00000000..bcad4323 --- /dev/null +++ b/stream/filt_rld.c @@ -0,0 +1,66 @@ +#include + +fz_error * +fz_newrld(fz_filter **fp, fz_obj *params) +{ + FZ_NEWFILTER(fz_filter, f, rld); + return nil; +} + +void +fz_droprld(fz_filter *rld) +{ +} + +fz_error * +fz_processrld(fz_filter *filter, fz_buffer *in, fz_buffer *out) +{ + int run, i; + unsigned char c; + + while (1) + { + if (in->rp == in->wp) + return fz_ioneedin; + + if (out->wp == out->ep) + return fz_ioneedout; + + run = *in->rp++; + + if (run == 128) { + out->eof = 1; + return fz_iodone; + } + + else if (run < 128) { + run = run + 1; + if (in->rp + run > in->wp) { + in->rp --; + return fz_ioneedin; + } + if (out->wp + run > out->ep) { + in->rp --; + return fz_ioneedout; + } + for (i = 0; i < run; i++) + *out->wp++ = *in->rp++; + } + + else if (run > 128) { + run = 257 - run; + if (in->rp + 1 > in->wp) { + in->rp --; + return fz_ioneedin; + } + if (out->wp + run > out->ep) { + in->rp --; + return fz_ioneedout; + } + c = *in->rp++; + for (i = 0; i < run; i++) + *out->wp++ = c; + } + } +} + diff --git a/stream/filt_rle.c b/stream/filt_rle.c new file mode 100644 index 00000000..921e470a --- /dev/null +++ b/stream/filt_rle.c @@ -0,0 +1,237 @@ +#include + +/* TODO: rewrite! + * make it non-optimal or something, + * just not this horrid mess... + */ + +#define noDEBUG + +typedef struct fz_rle_s fz_rle; + +struct fz_rle_s +{ + fz_filter super; + int reclen; + int curlen; + int state; + int run; + unsigned char buf[128]; +}; + +enum { + ZERO, + ONE, + DIFF, + SAME, + END +}; + +fz_error * +fz_newrle(fz_filter **fp, fz_obj *params) +{ + FZ_NEWFILTER(fz_rle, enc, rle); + + if (params) + enc->reclen = fz_toint(params); + else + enc->reclen = 0; + + enc->curlen = 0; + enc->state = ZERO; + enc->run = 0; + + return nil; +} + +void +fz_droprle(fz_filter *enc) +{ +} + +static fz_error * +putone(fz_rle *enc, fz_buffer *in, fz_buffer *out) +{ + if (out->wp + 2 >= out->ep) + return fz_ioneedout; + +#ifdef DEBUG +fprintf(stderr, "one '%c'\n", enc->buf[0]); +#endif + + *out->wp++ = 0; + *out->wp++ = enc->buf[0]; + + return nil; +} + +static fz_error * +putsame(fz_rle *enc, fz_buffer *in, fz_buffer *out) +{ + if (out->wp + enc->run >= out->ep) + return fz_ioneedout; + +#ifdef DEBUG +fprintf(stderr, "same %d x '%c'\n", enc->run, enc->buf[0]); +#endif + + *out->wp++ = 257 - enc->run; + *out->wp++ = enc->buf[0]; + return nil; +} + +static fz_error * +putdiff(fz_rle *enc, fz_buffer *in, fz_buffer *out) +{ + int i; + if (out->wp + enc->run >= out->ep) + return fz_ioneedout; + +#ifdef DEBUG +fprintf(stderr, "diff %d\n", enc->run); +#endif + + *out->wp++ = enc->run - 1; + for (i = 0; i < enc->run; i++) + *out->wp++ = enc->buf[i]; + return nil; +} + +static fz_error * +puteod(fz_rle *enc, fz_buffer *in, fz_buffer *out) +{ + if (out->wp + 1 >= out->ep) + return fz_ioneedout; + +#ifdef DEBUG +fprintf(stderr, "eod\n"); +#endif + + *out->wp++ = 128; + return nil; +} + +static fz_error * +savebuf(fz_rle *enc, fz_buffer *in, fz_buffer *out) +{ + switch (enc->state) + { + case ZERO: return nil; + case ONE: return putone(enc, in, out); + case SAME: return putsame(enc, in, out); + case DIFF: return putdiff(enc, in, out); + case END: return puteod(enc, in, out); + default: assert(!"invalid state in rle"); return nil; + } +} + +fz_error * +fz_processrle(fz_filter *filter, fz_buffer *in, fz_buffer *out) +{ + fz_rle *enc = (fz_rle*)filter; + fz_error *error; + unsigned char c; + + while (1) + { + + if (enc->reclen && enc->curlen == enc->reclen) { + error = savebuf(enc, in, out); + if (error) return error; +#ifdef DEBUG +fprintf(stderr, "--record--\n"); +#endif + enc->state = ZERO; + enc->curlen = 0; + } + + if (in->rp == in->wp) { + if (in->eof) { + if (enc->state != END) { + error = savebuf(enc, in, out); + if (error) return error; + } + enc->state = END; + } + else + return fz_ioneedin; + } + + c = *in->rp; + + switch (enc->state) + { + case ZERO: + enc->state = ONE; + enc->run = 1; + enc->buf[0] = c; + break; + + case ONE: + enc->state = DIFF; + enc->run = 2; + enc->buf[1] = c; + break; + + case DIFF: + /* out of space */ + if (enc->run == 128) { + error = putdiff(enc, in, out); + if (error) return error; + + enc->state = ONE; + enc->run = 1; + enc->buf[0] = c; + } + + /* run of three that are the same */ + else if ((enc->run > 1) && + (c == enc->buf[enc->run - 1]) && + (c == enc->buf[enc->run - 2])) + { + if (enc->run >= 3) { + enc->run -= 2; /* skip prev two for diff run */ + error = putdiff(enc, in, out); + if (error) return error; + } + + enc->state = SAME; + enc->run = 3; + enc->buf[0] = c; + } + + /* keep on collecting */ + else { + enc->buf[enc->run++] = c; + } + break; + + case SAME: + if (enc->run == 128 || c != enc->buf[0]) { + error = putsame(enc, in, out); + if (error) return error; + + enc->state = ONE; + enc->run = 1; + enc->buf[0] = c; + } + else { + enc->run ++; + } + break; + + case END: + error = puteod(enc, in, out); + if (error) return error; + + out->eof = 1; + return fz_iodone; + } + + in->rp ++; + + enc->curlen ++; + + } +} + diff --git a/stream/obj_array.c b/stream/obj_array.c new file mode 100644 index 00000000..c493bdaa --- /dev/null +++ b/stream/obj_array.c @@ -0,0 +1,184 @@ +#include + +void fz_droparray(fz_obj *obj); + +fz_error * +fz_newarray(fz_obj **op, int initialcap) +{ + fz_obj *obj; + int i; + + obj = *op = fz_malloc(sizeof (fz_obj)); + if (!obj) return fz_outofmem; + + obj->refs = 1; + obj->kind = FZ_ARRAY; + + obj->u.a.len = 0; + obj->u.a.cap = initialcap > 0 ? initialcap : 6; + + obj->u.a.items = fz_malloc(sizeof (fz_obj*) * obj->u.a.cap); + if (!obj->u.a.items) { fz_free(obj); return fz_outofmem; } + + for (i = 0; i < obj->u.a.cap; i++) + obj->u.a.items[i] = nil; + + return nil; +} + +fz_error * +fz_copyarray(fz_obj **op, fz_obj *obj) +{ + fz_error *error; + fz_obj *new; + int i; + + if (!fz_isarray(obj)) + return fz_throw("typecheck in copyarray"); + + error = fz_newarray(&new, fz_arraylen(obj)); + if (error) return error; + *op = new; + + for (i = 0; i < fz_arraylen(obj); i++) { + error = fz_arraypush(new, fz_arrayget(obj, i)); + if (error) { fz_droparray(new); return error; } + } + + return nil; +} + +fz_error * +fz_deepcopyarray(fz_obj **op, fz_obj *obj) +{ + fz_error *error; + fz_obj *new; + fz_obj *val; + int i; + + if (!fz_isarray(obj)) + return fz_throw("typecheck in deepcopyarray"); + + error = fz_newarray(&new, fz_arraylen(obj)); + if (error) return error; + *op = new; + + for (i = 0; i < fz_arraylen(obj); i++) + { + val = fz_arrayget(obj, i); + + if (fz_isarray(val)) { + error = fz_deepcopyarray(&val, val); + if (error) { fz_droparray(new); return error; } + error = fz_arraypush(new, val); + if (error) { fz_dropobj(val); fz_droparray(new); return error; } + fz_dropobj(val); + } + + else if (fz_isdict(val)) { + error = fz_deepcopydict(&val, val); + if (error) { fz_droparray(new); return error; } + error = fz_arraypush(new, val); + if (error) { fz_dropobj(val); fz_droparray(new); return error; } + fz_dropobj(val); + } + + else { + error = fz_arraypush(new, val); + if (error) { fz_droparray(new); return error; } + } + } + + return nil; +} + +int +fz_arraylen(fz_obj *obj) +{ + if (!fz_isarray(obj)) + return 0; + return obj->u.a.len; +} + +fz_obj * +fz_arrayget(fz_obj *obj, int i) +{ + if (!fz_isarray(obj)) + return nil; + + if (i < 0 || i >= obj->u.a.len) + return nil; + + return obj->u.a.items[i]; +} + +fz_error * +fz_arrayput(fz_obj *obj, int i, fz_obj *item) +{ + if (!fz_isarray(obj)) + return fz_throw("typecheck in arrayput"); + if (i < 0) + return fz_throw("rangecheck in arrayput: %d < 0", i); + if (i >= obj->u.a.len) + return fz_throw("rangecheck in arrayput: %d > %d", i, obj->u.a.len); + + if (obj->u.a.items[i]) + fz_dropobj(obj->u.a.items[i]); + obj->u.a.items[i] = fz_keepobj(item); + + return nil; +} + +static fz_error * +growarray(fz_obj *obj) +{ + fz_obj **newitems; + int newcap; + int i; + + newcap = obj->u.a.cap * 2; + newitems = fz_realloc(obj->u.a.items, sizeof (fz_obj*) * newcap); + if (!newitems) return fz_outofmem; + + obj->u.a.items = newitems; + for (i = obj->u.a.cap ; i < newcap; i++) + obj->u.a.items[i] = nil; + obj->u.a.cap = newcap; + + return nil; +} + +fz_error * +fz_arraypush(fz_obj *obj, fz_obj *item) +{ + fz_error *error; + + if (!fz_isarray(obj)) + return fz_throw("typecheck in arraypush"); + + if (obj->u.a.len + 1 > obj->u.a.cap) { + error = growarray(obj); + if (error) return error; + } + + obj->u.a.items[obj->u.a.len] = fz_keepobj(item); + obj->u.a.len++; + + return nil; +} + +void +fz_droparray(fz_obj *obj) +{ + int i; + + assert(obj->kind == FZ_ARRAY); + + for (i = 0; i < obj->u.a.len; i++) + if (obj->u.a.items[i]) + fz_dropobj(obj->u.a.items[i]); + + fz_free(obj->u.a.items); + fz_free(obj); +} + diff --git a/stream/obj_dict.c b/stream/obj_dict.c new file mode 100644 index 00000000..a0fb6d25 --- /dev/null +++ b/stream/obj_dict.c @@ -0,0 +1,355 @@ +#include + +/* keep either names or strings in the dict. don't mix & match. */ + +static int keyvalcmp(const void *ap, const void *bp) +{ + const fz_keyval *a = ap; + const fz_keyval *b = bp; + if (fz_isname(a->k)) + return strcmp(fz_toname(a->k), fz_toname(b->k)); + if (fz_isstring(a->k)) + return strcmp(fz_tostrbuf(a->k), fz_tostrbuf(b->k)); + return -1; +} + +static inline int keystrcmp(fz_obj *key, char *s) +{ + if (fz_isname(key)) + return strcmp(fz_toname(key), s); + if (fz_isstring(key)) + return strcmp(fz_tostrbuf(key), s); + return -1; +} + +fz_error * +fz_newdict(fz_obj **op, int initialcap) +{ + fz_obj *obj; + int i; + + obj = *op = fz_malloc(sizeof (fz_obj)); + if (!obj) return fz_outofmem; + + obj->refs = 1; + obj->kind = FZ_DICT; + + obj->u.d.sorted = 1; + obj->u.d.len = 0; + obj->u.d.cap = initialcap > 0 ? initialcap : 10; + + obj->u.d.items = fz_malloc(sizeof(fz_keyval) * obj->u.d.cap); + if (!obj->u.d.items) { fz_free(obj); return fz_outofmem; } + + for (i = 0; i < obj->u.d.cap; i++) { + obj->u.d.items[i].k = nil; + obj->u.d.items[i].v = nil; + } + + return nil; +} + +fz_error * +fz_copydict(fz_obj **op, fz_obj *obj) +{ + fz_error *error; + fz_obj *new; + int i; + + if (!fz_isdict(obj)) + return fz_throw("typecheck in copydict"); + + error = fz_newdict(&new, obj->u.d.cap); + if (error) return error; + *op = new; + + for (i = 0; i < fz_dictlen(obj); i++) { + error = fz_dictput(new, fz_dictgetkey(obj, i), fz_dictgetval(obj, i)); + if (error) { fz_dropobj(new); return error; } + } + + return nil; +} + +fz_error * +fz_deepcopydict(fz_obj **op, fz_obj *obj) +{ + fz_error *error; + fz_obj *new; + fz_obj *val; + int i; + + if (!fz_isdict(obj)) + return fz_throw("typecheck in deepcopydict"); + + error = fz_newdict(&new, obj->u.d.cap); + if (error) return error; + *op = new; + + for (i = 0; i < fz_dictlen(obj); i++) + { + val = fz_dictgetval(obj, i); + + if (fz_isarray(val)) { + error = fz_deepcopyarray(&val, val); + if (error) { fz_dropobj(new); return error; } + error = fz_dictput(new, fz_dictgetkey(obj, i), val); + if (error) { fz_dropobj(val); fz_dropobj(new); return error; } + fz_dropobj(val); + } + + else if (fz_isdict(val)) { + error = fz_deepcopydict(&val, val); + if (error) { fz_dropobj(new); return error; } + error = fz_dictput(new, fz_dictgetkey(obj, i), val); + if (error) { fz_dropobj(val); fz_dropobj(new); return error; } + fz_dropobj(val); + } + + else { + error = fz_dictput(new, fz_dictgetkey(obj, i), val); + if (error) { fz_dropobj(new); return error; } + } + } + + return nil; +} + +static fz_error * +growdict(fz_obj *obj) +{ + fz_keyval *newitems; + int newcap; + int i; + + newcap = obj->u.d.cap * 2; + + newitems = fz_realloc(obj->u.d.items, sizeof(fz_keyval) * newcap); + if (!newitems) return fz_outofmem; + + obj->u.d.items = newitems; + for (i = obj->u.d.cap; i < newcap; i++) { + obj->u.d.items[i].k = nil; + obj->u.d.items[i].v = nil; + } + obj->u.d.cap = newcap; + + return nil; +} + +int +fz_dictlen(fz_obj *obj) +{ + if (!fz_isdict(obj)) + return 0; + return obj->u.d.len; +} + +fz_obj * +fz_dictgetkey(fz_obj *obj, int i) +{ + if (!fz_isdict(obj)) + return nil; + + if (i < 0 || i >= obj->u.d.len) + return nil; + + return obj->u.d.items[i].k; +} + +fz_obj * +fz_dictgetval(fz_obj *obj, int i) +{ + if (!fz_isdict(obj)) + return nil; + + if (i < 0 || i >= obj->u.d.len) + return nil; + + return obj->u.d.items[i].v; +} + +static inline int dictfinds(fz_obj *obj, char *key) +{ + if (obj->u.d.sorted) + { + int l = 0; + int r = obj->u.d.len - 1; + while (l <= r) + { + int m = (l + r) >> 1; + int c = -keystrcmp(obj->u.d.items[m].k, key); + if (c < 0) + r = m - 1; + else if (c > 0) + l = m + 1; + else + return m; + } + } + + else + { + int i; + for (i = 0; i < obj->u.d.len; i++) + if (keystrcmp(obj->u.d.items[i].k, key) == 0) + return i; + } + + return -1; +} + +fz_obj * +fz_dictgets(fz_obj *obj, char *key) +{ + int i; + + if (!fz_isdict(obj)) + return nil; + + i = dictfinds(obj, key); + if (i >= 0) + return obj->u.d.items[i].v; + + return nil; +} + +fz_obj * +fz_dictget(fz_obj *obj, fz_obj *key) +{ + if (fz_isname(key)) + return fz_dictgets(obj, fz_toname(key)); + if (fz_isstring(key)) + return fz_dictgets(obj, fz_tostrbuf(key)); + return nil; +} + +fz_obj * +fz_dictgetsa(fz_obj *obj, char *key, char *abbrev) +{ + fz_obj *v; + v = fz_dictgets(obj, key); + if (v) + return v; + return fz_dictgets(obj, abbrev); +} + +fz_error * +fz_dictput(fz_obj *obj, fz_obj *key, fz_obj *val) +{ + fz_error *error; + char *s; + int i; + + if (!fz_isdict(obj)) + return fz_throw("typecheck in dictput"); + + if (fz_isname(key)) + s = fz_toname(key); + else if (fz_isstring(key)) + s = fz_tostrbuf(key); + else + return fz_throw("typecheck in dictput"); + + i = dictfinds(obj, s); + if (i >= 0) + { + fz_dropobj(obj->u.d.items[i].v); + obj->u.d.items[i].v = fz_keepobj(val); + return nil; + } + + if (obj->u.d.len + 1 > obj->u.d.cap) + { + error = growdict(obj); + if (error) + return error; + } + + /* borked! */ + if (obj->u.d.len) + if (keystrcmp(obj->u.d.items[obj->u.d.len - 1].k, s) > 0) + obj->u.d.sorted = 0; + + obj->u.d.items[obj->u.d.len].k = fz_keepobj(key); + obj->u.d.items[obj->u.d.len].v = fz_keepobj(val); + obj->u.d.len ++; + + return nil; +} + +fz_error * +fz_dictputs(fz_obj *obj, char *key, fz_obj *val) +{ + fz_error *error; + fz_obj *keyobj; + error = fz_newname(&keyobj, key); + if (error) return error; + error = fz_dictput(obj, keyobj, val); + fz_dropobj(keyobj); + return error; +} + +fz_error * +fz_dictdels(fz_obj *obj, char *key) +{ + int i; + + if (!fz_isdict(obj)) + return fz_throw("typecheck in dictdel"); + + i = dictfinds(obj, key); + if (i >= 0) + { + fz_dropobj(obj->u.d.items[i].k); + fz_dropobj(obj->u.d.items[i].v); + obj->u.d.sorted = 0; + obj->u.d.items[i] = obj->u.d.items[obj->u.d.len-1]; + obj->u.d.len --; + } + + return nil; +} + +fz_error * +fz_dictdel(fz_obj *obj, fz_obj *key) +{ + if (fz_isname(key)) + return fz_dictdels(obj, fz_toname(key)); + else if (fz_isstring(key)) + return fz_dictdels(obj, fz_tostrbuf(key)); + else + return fz_throw("typecheck in dictdel"); +} + +void +fz_dropdict(fz_obj *obj) +{ + int i; + + if (!fz_isdict(obj)) + return; + + for (i = 0; i < obj->u.d.len; i++) { + if (obj->u.d.items[i].k) + fz_dropobj(obj->u.d.items[i].k); + if (obj->u.d.items[i].v) + fz_dropobj(obj->u.d.items[i].v); + } + + fz_free(obj->u.d.items); + fz_free(obj); +} + +void +fz_sortdict(fz_obj *obj) +{ + if (!fz_isdict(obj)) + return; + if (!obj->u.d.sorted) + { + qsort(obj->u.d.items, obj->u.d.len, sizeof(fz_keyval), keyvalcmp); + obj->u.d.sorted = 1; + } +} + diff --git a/stream/obj_parse.c b/stream/obj_parse.c new file mode 100644 index 00000000..c3f3d3dc --- /dev/null +++ b/stream/obj_parse.c @@ -0,0 +1,401 @@ +#include + +struct vap { va_list ap; }; + +static inline int iswhite(int ch) +{ + return + ch == '\000' || + ch == '\011' || + ch == '\012' || + ch == '\014' || + ch == '\015' || + ch == '\040'; +} + +static inline int isdelim(int ch) +{ + return + ch == '(' || ch == ')' || + ch == '<' || ch == '>' || + ch == '[' || ch == ']' || + ch == '{' || ch == '}' || + ch == '/' || + ch == '%'; +} + +static inline int isregular(int ch) +{ + return !isdelim(ch) && !iswhite(ch) && ch != EOF; +} + +static fz_error *parseobj(fz_obj **obj, char **sp, struct vap *v); + +static inline int fromhex(char ch) +{ + if (ch >= '0' && ch <= '9') + return ch - '0'; + else if (ch >= 'A' && ch <= 'F') + return ch - 'A' + 0xA; + else if (ch >= 'a' && ch <= 'f') + return ch - 'a' + 0xA; + return 0; +} + +static inline void skipwhite(char **sp) +{ + char *s = *sp; + while (iswhite(*s)) + s ++; + *sp = s; +} + +static void parsekeyword(char **sp, char *b, char *eb) +{ + char *s = *sp; + while (b < eb && isregular(*s)) + *b++ = *s++; + *b++ = 0; + *sp = s; +} + +static fz_error *parsename(fz_obj **obj, char **sp) +{ + char buf[64]; + char *s = *sp; + char *p = buf; + + s ++; /* skip '/' */ + while (p < buf + sizeof buf - 1 && isregular(*s)) + *p++ = *s++; + *p++ = 0; + *sp = s; + + return fz_newname(obj, buf); +} + +static fz_error *parsenumber(fz_obj **obj, char **sp) +{ + char buf[32]; + char *s = *sp; + char *p = buf; + + while (p < buf + sizeof buf - 1) + { + if (s[0] == '-' || s[0] == '.' || (s[0] >= '0' && s[0] <= '9')) + *p++ = *s++; + else + break; + } + *p++ = 0; + *sp = s; + + if (strchr(buf, '.')) + return fz_newreal(obj, atof(buf)); + return fz_newint(obj, atoi(buf)); +} + +static fz_error *parsedict(fz_obj **obj, char **sp, struct vap *v) +{ + fz_error *error = nil; + fz_obj *dict = nil; + fz_obj *key = nil; + fz_obj *val = nil; + char *s = *sp; + + error = fz_newdict(&dict, 8); + if (error) return error; + *obj = dict; + + s += 2; /* skip "<<" */ + + while (*s) + { + skipwhite(&s); + + /* end-of-dict marker >> */ + if (*s == '>') { + s ++; + if (*s == '>') { + s ++; + break; + } + error = fz_throw("syntaxerror in parsedict"); + goto cleanup; + } + + /* non-name as key, bail */ + if (*s != '/') { + error = fz_throw("syntaxerror in parsedict"); + goto cleanup; + } + + error = parsename(&key, &s); + if (error) goto cleanup; + + skipwhite(&s); + + error = parseobj(&val, &s, v); + if (error) goto cleanup; + + error = fz_dictput(dict, key, val); + if (error) goto cleanup; + + fz_dropobj(val); val = nil; + fz_dropobj(key); key = nil; + } + + *sp = s; + return nil; + +cleanup: + if (val) fz_dropobj(val); + if (key) fz_dropobj(key); + if (dict) fz_dropobj(dict); + *obj = nil; + *sp = s; + return error; +} + +static fz_error *parsearray(fz_obj **obj, char **sp, struct vap *v) +{ + fz_error *error; + fz_obj *a; + fz_obj *o; + char *s = *sp; + + error = fz_newarray(&a, 8); + if (error) return error; + *obj = a; + + s ++; /* skip '[' */ + + while (*s) + { + skipwhite(&s); + + if (*s == ']') { + s ++; + break; + } + + error = parseobj(&o, &s, v); + if (error) { *obj = nil; fz_dropobj(a); return error; } + + error = fz_arraypush(a, o); + if (error) { fz_dropobj(o); *obj = nil; fz_dropobj(a); return error; } + + fz_dropobj(o); + } + + *sp = s; + return nil; +} + +static fz_error *parsestring(fz_obj **obj, char **sp) +{ + char buf[512]; + char *s = *sp; + char *p = buf; + int balance = 1; + int oct; + + s ++; /* skip '(' */ + + while (*s && p < buf + sizeof buf) + { + if (*s == '(') + { + balance ++; + *p++ = *s++; + } + else if (*s == ')') + { + balance --; + *p++ = *s++; + } + else if (*s == '\\') + { + s ++; + if (*s >= '0' && *s <= '9') + { + oct = *s - '0'; + s ++; + if (*s >= '0' && *s <= '9') + { + oct = oct * 8 + (*s - '0'); + s ++; + if (*s >= '0' && *s <= '9') + { + oct = oct * 8 + (*s - '0'); + s ++; + } + } + *p++ = oct; + } + else switch (*s) + { + case 'n': *p++ = '\n'; s++; break; + case 'r': *p++ = '\r'; s++; break; + case 't': *p++ = '\t'; s++; break; + case 'b': *p++ = '\b'; s++; break; + case 'f': *p++ = '\f'; s++; break; + default: *p++ = *s++; break; + } + } + else + *p++ = *s++; + + if (balance == 0) + break; + } + + *sp = s; + return fz_newstring(obj, buf, p - buf - 1); +} + +static fz_error *parsehexstring(fz_obj **obj, char **sp) +{ + char buf[512]; + char *s = *sp; + char *p = buf; + int a, b; + + s ++; /* skip '<' */ + + while (*s && p < buf + sizeof buf) + { + skipwhite(&s); + if (*s == '>') { + s ++; + break; + } + a = *s++; + + if (*s == '\0') + break; + + skipwhite(&s); + if (*s == '>') { + s ++; + break; + } + b = *s++; + + *p++ = fromhex(a) * 16 + fromhex(b); + } + + *sp = s; + return fz_newstring(obj, buf, p - buf); +} + +static fz_error *parseobj(fz_obj **obj, char **sp, struct vap *v) +{ + fz_error *error; + char buf[32]; + int oid, gid, len; + char *tmp; + char *s = *sp; + + if (*s == '\0') + return fz_throw("syntaxerror in parseobj: end-of-string"); + + skipwhite(&s); + + error = nil; + + if (v != nil && *s == '%') + { + s ++; + switch (*s) + { + case 'p': error = fz_newpointer(obj, va_arg(v->ap, void*)); break; + case 'o': *obj = fz_keepobj(va_arg(v->ap, fz_obj*)); break; + case 'b': error = fz_newbool(obj, va_arg(v->ap, int)); break; + case 'i': error = fz_newint(obj, va_arg(v->ap, int)); break; + case 'f': error = fz_newreal(obj, (float)va_arg(v->ap, double)); break; + case 'n': error = fz_newname(obj, va_arg(v->ap, char*)); break; + case 'r': + oid = va_arg(v->ap, int); + gid = va_arg(v->ap, int); + error = fz_newindirect(obj, oid, gid); + break; + case 's': + tmp = va_arg(v->ap, char*); + error = fz_newstring(obj, tmp, strlen(tmp)); + break; + case '#': + tmp = va_arg(v->ap, char*); + len = va_arg(v->ap, int); + error = fz_newstring(obj, tmp, len); + break; + default: + error = fz_throw("unknown format specifier in packobj: '%c'", *s); + break; + } + s ++; + } + + else if (*s == '/') + error = parsename(obj, &s); + + else if (*s == '(') + error = parsestring(obj, &s); + + else if (*s == '<') { + if (s[1] == '<') + error = parsedict(obj, &s, v); + else + error = parsehexstring(obj, &s); + } + + else if (*s == '[') + error = parsearray(obj, &s, v); + + else if (*s == '-' || *s == '.' || (*s >= '0' && *s <= '9')) + error = parsenumber(obj, &s); + + else if (isregular(*s)) + { + parsekeyword(&s, buf, buf + sizeof buf); + + if (strcmp("true", buf) == 0) + error = fz_newbool(obj, 1); + else if (strcmp("false", buf) == 0) + error = fz_newbool(obj, 0); + else if (strcmp("null", buf) == 0) + error = fz_newnull(obj); + else + error = fz_throw("syntaxerror in parseobj: undefined keyword %s", buf); + } + + else + error = fz_throw("syntaxerror in parseobj"); + + *sp = s; + return error; +} + +fz_error * +fz_packobj(fz_obj **op, char *fmt, ...) +{ + fz_error *error; + struct vap v; + va_list ap; + + va_start(ap, fmt); + va_copy(v.ap, ap); + + error = parseobj(op, &fmt, &v); + + va_end(ap); + + return error; +} + +fz_error * +fz_parseobj(fz_obj **op, char *str) +{ + return parseobj(op, &str, nil); +} + diff --git a/stream/obj_print.c b/stream/obj_print.c new file mode 100644 index 00000000..7ada9845 --- /dev/null +++ b/stream/obj_print.c @@ -0,0 +1,302 @@ +#include + +struct fmt +{ + char *buf; + int cap; + int len; + int indent; + int tight; + int col; + int sep; + int last; +}; + +static void fmtobj(struct fmt *fmt, fz_obj *obj); + +static inline int isdelim(int ch) +{ + return ch == '(' || ch == ')' || + ch == '<' || ch == '>' || + ch == '[' || ch == ']' || + ch == '{' || ch == '}' || + ch == '/' || + ch == '%'; +} + +static inline void fmtputc(struct fmt *fmt, int c) +{ + if (fmt->sep && !isdelim(fmt->last) && !isdelim(c)) { + fmt->sep = 0; + fmtputc(fmt, ' '); + } + fmt->sep = 0; + + if (fmt->buf && fmt->len < fmt->cap) + fmt->buf[fmt->len] = c; + + if (c == '\n') + fmt->col = 0; + else + fmt->col ++; + + fmt->len ++; + + fmt->last = c; +} + +static void fmtindent(struct fmt *fmt) +{ + int i = fmt->indent; + while (i--) { + fmtputc(fmt, ' '); + fmtputc(fmt, ' '); + } +} + +static inline void fmtputs(struct fmt *fmt, char *s) +{ + while (*s) + fmtputc(fmt, *s++); +} + +static inline void fmtsep(struct fmt *fmt) +{ + fmt->sep = 1; +} + +static void fmtstr(struct fmt *fmt, fz_obj *obj) +{ + int i; + int c; + + fmtputc(fmt, '('); + for (i = 0; i < obj->u.s.len; i++) + { + c = (unsigned char) obj->u.s.buf[i]; + if (c == '\n') + fmtputs(fmt, "\\n"); + else if (c == '\r') + fmtputs(fmt, "\\r"); + else if (c == '\t') + fmtputs(fmt, "\\t"); + else if (c == '\b') + fmtputs(fmt, "\\b"); + else if (c == '\f') + fmtputs(fmt, "\\f"); + else if (c == '(') + fmtputs(fmt, "\\("); + else if (c == ')') + fmtputs(fmt, "\\)"); + else if (c < 32 || c > 126) { + char buf[16]; + fmtputc(fmt, '\\'); + sprintf(buf, "%o", c); + fmtputs(fmt, buf); + } + else + fmtputc(fmt, c); + } + fmtputc(fmt, ')'); +} + +static void fmthex(struct fmt *fmt, fz_obj *obj) +{ + int i; + int b; + int c; + + fmtputc(fmt, '<'); + for (i = 0; i < obj->u.s.len; i++) { + b = (unsigned char) obj->u.s.buf[i]; + c = (b >> 4) & 0x0f; + fmtputc(fmt, c < 0xA ? c + '0' : c + 'A' - 0xA); + c = (b) & 0x0f; + fmtputc(fmt, c < 0xA ? c + '0' : c + 'A' - 0xA); + } + fmtputc(fmt, '>'); +} + +static void fmtarray(struct fmt *fmt, fz_obj *obj) +{ + int i; + + if (fmt->tight) { + fmtputc(fmt, '['); + for (i = 0; i < fz_arraylen(obj); i++) { + fmtobj(fmt, fz_arrayget(obj, i)); + fmtsep(fmt); + } + fmtputc(fmt, ']'); + } + else { + fmtputs(fmt, "[ "); + for (i = 0; i < fz_arraylen(obj); i++) { + if (fmt->col > 60) { + fmtputc(fmt, '\n'); + fmtindent(fmt); + } + fmtobj(fmt, fz_arrayget(obj, i)); + fmtputc(fmt, ' '); + } + fmtputc(fmt, ']'); + fmtsep(fmt); + } +} + +static void fmtdict(struct fmt *fmt, fz_obj *obj) +{ + int i; + fz_obj *key, *val; + + if (fmt->tight) { + fmtputs(fmt, "<<"); + for (i = 0; i < fz_dictlen(obj); i++) { + fmtobj(fmt, fz_dictgetkey(obj, i)); + fmtsep(fmt); + fmtobj(fmt, fz_dictgetval(obj, i)); + fmtsep(fmt); + } + fmtputs(fmt, ">>"); + } + else { + fmtputs(fmt, "<<\n"); + fmt->indent ++; + for (i = 0; i < fz_dictlen(obj); i++) { + key = fz_dictgetkey(obj, i); + val = fz_dictgetval(obj, i); + fmtindent(fmt); + fmtobj(fmt, key); + fmtputc(fmt, ' '); + if (fz_isarray(val)) + fmt->indent ++; + fmtobj(fmt, val); + fmtputc(fmt, '\n'); + if (fz_isarray(val)) + fmt->indent --; + } + fmt->indent --; + fmtindent(fmt); + fmtputs(fmt, ">>"); + } +} + +static void fmtobj(struct fmt *fmt, fz_obj *obj) +{ + char buf[256]; + + if (!obj) { + fmtputs(fmt, ""); + return; + } + + switch (obj->kind) + { + case FZ_NULL: + fmtputs(fmt, "null"); + break; + case FZ_BOOL: + fmtputs(fmt, fz_tobool(obj) ? "true" : "false"); + break; + case FZ_INT: + sprintf(buf, "%d", fz_toint(obj)); + fmtputs(fmt, buf); + break; + case FZ_REAL: + sprintf(buf, "%g", fz_toreal(obj)); + if (strchr(buf, 'e')) /* bad news! */ + sprintf(buf, fabs(fz_toreal(obj)) > 1 ? "%1.1f" : "%1.8f", fz_toreal(obj)); + fmtputs(fmt, buf); + break; + case FZ_STRING: + { + int added = 0; + int i, c; + for (i = 0; i < obj->u.s.len; i++) { + c = (unsigned char)obj->u.s.buf[i]; + if (strchr("()\\\n\r\t\b\f", c) != 0) + added ++; + else if (c < 8) + added ++; + else if (c < 32) + added += 2; + else if (c >= 127) + added += 3; + } + if (added < obj->u.s.len) + fmtstr(fmt, obj); + else + fmthex(fmt, obj); + } + break; + case FZ_NAME: + sprintf(buf, "/%s", fz_toname(obj)); + fmtputs(fmt, buf); + break; + case FZ_ARRAY: + fmtarray(fmt, obj); + break; + case FZ_DICT: + fmtdict(fmt, obj); + break; + case FZ_INDIRECT: + sprintf(buf, "%d %d R", obj->u.r.oid, obj->u.r.gid); + fmtputs(fmt, buf); + break; + case FZ_POINTER: + sprintf(buf, "$%p", obj->u.p); + fmtputs(fmt, buf); + break; + default: + sprintf(buf, "", obj->kind); + fmtputs(fmt, buf); + break; + } +} + +int +fz_sprintobj(char *s, int n, fz_obj *obj, int tight) +{ + struct fmt fmt; + + fmt.indent = 0; + fmt.col = 0; + fmt.sep = 0; + fmt.last = 0; + + fmt.tight = tight; + fmt.buf = s; + fmt.cap = n; + fmt.len = 0; + fmtobj(&fmt, obj); + + if (fmt.buf && fmt.len < fmt.cap) + fmt.buf[fmt.len] = '\0'; + + return fmt.len; +} + +void +fz_debugobj(fz_obj *obj) +{ + char buf[1024]; + char *ptr; + int n; + + n = fz_sprintobj(nil, 0, obj, 0); + if (n < sizeof buf) + { + fz_sprintobj(buf, sizeof buf, obj, 0); + fwrite(buf, 1, n, stdout); + } + else + { + ptr = fz_malloc(n); + if (!ptr) + return; + fz_sprintobj(ptr, n, obj, 0); + fwrite(ptr, 1, n, stdout); + fz_free(ptr); + } +} + diff --git a/stream/obj_simple.c b/stream/obj_simple.c new file mode 100644 index 00000000..131e11b4 --- /dev/null +++ b/stream/obj_simple.c @@ -0,0 +1,297 @@ +#include + +extern void fz_droparray(fz_obj *array); +extern void fz_dropdict(fz_obj *dict); + +#define NEWOBJ(KIND,SIZE) \ + fz_obj *o; \ + o = *op = fz_malloc(SIZE); \ + if (!o) return fz_outofmem; \ + o->refs = 1; \ + o->kind = KIND; \ + +fz_error * +fz_newnull(fz_obj **op) +{ + NEWOBJ(FZ_NULL, sizeof (fz_obj)); + return nil; +} + +fz_error * +fz_newbool(fz_obj **op, int b) +{ + NEWOBJ(FZ_BOOL, sizeof (fz_obj)); + o->u.b = b; + return nil; +} + +fz_error * +fz_newint(fz_obj **op, int i) +{ + NEWOBJ(FZ_INT, sizeof (fz_obj)); + o->u.i = i; + return nil; +} + +fz_error * +fz_newreal(fz_obj **op, float f) +{ + NEWOBJ(FZ_REAL, sizeof (fz_obj)); + o->u.f = f; + return nil; +} + +fz_error * +fz_newstring(fz_obj **op, char *str, int len) +{ + NEWOBJ(FZ_STRING, offsetof(fz_obj, u.s.buf) + len + 1); + o->u.s.len = len; + memcpy(o->u.s.buf, str, len); + o->u.s.buf[len] = '\0'; + return nil; +} + +fz_error * +fz_newname(fz_obj **op, char *str) +{ + NEWOBJ(FZ_NAME, offsetof(fz_obj, u.n) + strlen(str) + 1); + strcpy(o->u.n, str); + return nil; +} + +fz_error * +fz_newindirect(fz_obj **op, int objid, int genid) +{ + NEWOBJ(FZ_INDIRECT, sizeof (fz_obj)); + o->u.r.oid = objid; + o->u.r.gid = genid; + return nil; +} + +fz_error * +fz_newpointer(fz_obj **op, void *p) +{ + NEWOBJ(FZ_POINTER, sizeof (fz_obj)); + o->u.p = p; + return nil; +} + +fz_obj * +fz_keepobj(fz_obj *o) +{ + assert(o != nil); + o->refs ++; + return o; +} + +void +fz_dropobj(fz_obj *o) +{ + assert(o != nil); + if (--o->refs == 0) + { + if (o->kind == FZ_ARRAY) + fz_droparray(o); + else if (o->kind == FZ_DICT) + fz_dropdict(o); + else + fz_free(o); + } +} + +int +fz_isnull(fz_obj *obj) +{ + return obj ? obj->kind == FZ_NULL : 0; +} + +int +fz_isbool(fz_obj *obj) +{ + return obj ? obj->kind == FZ_BOOL : 0; +} + +int +fz_isint(fz_obj *obj) +{ + return obj ? obj->kind == FZ_INT : 0; +} + +int +fz_isreal(fz_obj *obj) +{ + return obj ? obj->kind == FZ_REAL : 0; +} + +int +fz_isstring(fz_obj *obj) +{ + return obj ? obj->kind == FZ_STRING : 0; +} + +int +fz_isname(fz_obj *obj) +{ + return obj ? obj->kind == FZ_NAME : 0; +} + +int +fz_isarray(fz_obj *obj) +{ + return obj ? obj->kind == FZ_ARRAY : 0; +} + +int +fz_isdict(fz_obj *obj) +{ + return obj ? obj->kind == FZ_DICT : 0; +} + +int +fz_isindirect(fz_obj *obj) +{ + return obj ? obj->kind == FZ_INDIRECT : 0; +} + +int +fz_ispointer(fz_obj *obj) +{ + return obj ? obj->kind == FZ_POINTER : 0; +} + +int +fz_tobool(fz_obj *obj) +{ + if (fz_isbool(obj)) + return obj->u.b; + return 0; +} + +int +fz_toint(fz_obj *obj) +{ + if (fz_isint(obj)) + return obj->u.i; + if (fz_isreal(obj)) + return obj->u.f; + return 0; +} + +float +fz_toreal(fz_obj *obj) +{ + if (fz_isreal(obj)) + return obj->u.f; + if (fz_isint(obj)) + return obj->u.i; + return 0; +} + +char * +fz_toname(fz_obj *obj) +{ + if (fz_isname(obj)) + return obj->u.n; + return ""; +} + +char * +fz_tostrbuf(fz_obj *obj) +{ + if (fz_isstring(obj)) + return obj->u.s.buf; + return ""; +} + +int +fz_tostrlen(fz_obj *obj) +{ + if (fz_isstring(obj)) + return obj->u.s.len; + return 0; +} + +int +fz_tonum(fz_obj *obj) +{ + if (fz_isindirect(obj)) + return obj->u.r.oid; + return 0; +} + +int +fz_togen(fz_obj *obj) +{ + if (fz_isindirect(obj)) + return obj->u.r.gid; + return 0; +} + +void * +fz_topointer(fz_obj *obj) +{ + if (fz_ispointer(obj)) + return obj->u.p; + return nil; +} + +fz_error * +fz_newnamefromstring(fz_obj **op, fz_obj *str) +{ + NEWOBJ(FZ_NAME, offsetof(fz_obj, u.n) + fz_tostrlen(str) + 1); + memcpy(o->u.n, fz_tostrbuf(str), fz_tostrlen(str)); + o->u.n[fz_tostrlen(str)] = '\0'; + return nil; +} + +int +fz_objcmp(fz_obj *a, fz_obj *b) +{ + int i; + + if (a == b) + return 0; + if (a->kind != b->kind) + return 1; + + switch (a->kind) + { + case FZ_NULL: return 0; + case FZ_BOOL: return a->u.b - b->u.b; + case FZ_INT: return a->u.i - b->u.i; + case FZ_REAL: return a->u.f - b->u.f; + case FZ_STRING: + if (a->u.s.len != b->u.s.len) + return a->u.s.len - b->u.s.len; + return memcmp(a->u.s.buf, b->u.s.buf, a->u.s.len); + case FZ_NAME: + return strcmp(a->u.n, b->u.n); + + case FZ_INDIRECT: + if (a->u.r.oid == b->u.r.oid) + return a->u.r.gid - b->u.r.gid; + return a->u.r.oid - b->u.r.oid; + + case FZ_ARRAY: + if (a->u.a.len != b->u.a.len) + return a->u.a.len - b->u.a.len; + for (i = 0; i < a->u.a.len; i++) + if (fz_objcmp(a->u.a.items[i], b->u.a.items[i])) + return 1; + return 0; + + case FZ_DICT: + if (a->u.d.len != b->u.d.len) + return a->u.d.len - b->u.d.len; + for (i = 0; i < a->u.d.len; i++) + { + if (fz_objcmp(a->u.d.items[i].k, b->u.d.items[i].k)) + return 1; + if (fz_objcmp(a->u.d.items[i].v, b->u.d.items[i].v)) + return 1; + } + return 0; + } + return 1; +} + diff --git a/tree/cmap.c b/tree/cmap.c deleted file mode 100644 index 577ba7c0..00000000 --- a/tree/cmap.c +++ /dev/null @@ -1,466 +0,0 @@ -#include - -typedef struct fz_range_s fz_range; - -enum { MAXCODESPACE = 10 }; -enum { SINGLE, RANGE, LOOKUP }; - -struct fz_range_s -{ - int low; - int high; - int flag; - int offset; -}; - -struct fz_cmap_s -{ - int refs; - char cmapname[32]; - - char usecmapname[32]; - fz_cmap *usecmap; - - int wmode; - - int ncspace; - struct { - int n; - unsigned char lo[4]; - unsigned char hi[4]; - } cspace[MAXCODESPACE]; - - int rlen, rcap; - fz_range *ranges; - - int tlen, tcap; - int *lookup; -}; - -fz_error * -fz_newcmap(fz_cmap **cmapp) -{ - fz_cmap *cmap; - - cmap = *cmapp = fz_malloc(sizeof(fz_cmap)); - if (!cmap) - return fz_outofmem; - - cmap->refs = 1; - strcpy(cmap->cmapname, ""); - - strcpy(cmap->usecmapname, ""); - cmap->usecmap = nil; - - cmap->wmode = 0; - - cmap->ncspace = 0; - - cmap->rlen = 0; - cmap->rcap = 0; - cmap->ranges = nil; - - cmap->tlen = 0; - cmap->tcap = 0; - cmap->lookup = nil; - - return nil; -} - -fz_cmap * -fz_keepcmap(fz_cmap *cmap) -{ - cmap->refs ++; - return cmap; -} - -void -fz_dropcmap(fz_cmap *cmap) -{ - if (--cmap->refs == 0) - { - if (cmap->usecmap) - fz_dropcmap(cmap->usecmap); - fz_free(cmap->ranges); - fz_free(cmap->lookup); - fz_free(cmap); - } -} - -char * -fz_getcmapname(fz_cmap *cmap) -{ - if (cmap->cmapname[0]) - return cmap->cmapname; - return nil; -} - -void -fz_setcmapname(fz_cmap *cmap, char *cmapname) -{ - strlcpy(cmap->cmapname, cmapname, sizeof cmap->cmapname); -} - -char * -fz_getusecmapname(fz_cmap *cmap) -{ - if (cmap->usecmapname[0]) - return cmap->usecmapname; - return nil; -} - -void -fz_setusecmapname(fz_cmap *cmap, char *usecmap) -{ - strlcpy(cmap->usecmapname, usecmap, sizeof cmap->usecmapname); -} - -fz_cmap * -fz_getusecmap(fz_cmap *cmap) -{ - return cmap->usecmap; -} - -void -fz_setusecmap(fz_cmap *cmap, fz_cmap *usecmap) -{ - int i; - - if (cmap->usecmap) - fz_dropcmap(cmap->usecmap); - cmap->usecmap = fz_keepcmap(usecmap); - - if (cmap->ncspace == 0) - { - cmap->ncspace = usecmap->ncspace; - for (i = 0; i < usecmap->ncspace; i++) - cmap->cspace[i] = usecmap->cspace[i]; - } -} - -void -fz_setwmode(fz_cmap *cmap, int wmode) -{ - cmap->wmode = wmode; -} - -int -fz_getwmode(fz_cmap *cmap) -{ - return cmap->wmode; -} - -fz_error * -fz_addcodespacerange(fz_cmap *cmap, unsigned lo, unsigned hi, int n) -{ - int i; - - if (cmap->ncspace + 1 == MAXCODESPACE) - return fz_throw("rangelimit: too many code space ranges"); - - cmap->cspace[cmap->ncspace].n = n; - - for (i = 0; i < n; i++) - { - int o = (n - i - 1) * 8; - cmap->cspace[cmap->ncspace].lo[i] = (lo >> o) & 0xFF; - cmap->cspace[cmap->ncspace].hi[i] = (hi >> o) & 0xFF; - } - - cmap->ncspace ++; - - return nil; -} - -fz_error * -fz_addcidrange(fz_cmap *cmap, int low, int high, int offset) -{ - if (cmap->rlen + 1 > cmap->rcap) - { - fz_range *newranges; - int newcap = cmap->rcap == 0 ? 256 : cmap->rcap * 2; - newranges = fz_realloc(cmap->ranges, newcap * sizeof(fz_range)); - if (!newranges) - return fz_outofmem; - cmap->rcap = newcap; - cmap->ranges = newranges; - } - - cmap->ranges[cmap->rlen].low = low; - cmap->ranges[cmap->rlen].high = high; - cmap->ranges[cmap->rlen].flag = high - low == 0 ? SINGLE : RANGE; - cmap->ranges[cmap->rlen].offset = offset; - cmap->rlen ++; - - return nil; -} - -static fz_error * -addlookup(fz_cmap *cmap, int value) -{ - if (cmap->tlen + 1 > cmap->tcap) - { - int newcap = cmap->tcap == 0 ? 256 : cmap->tcap * 2; - int *newlookup = fz_realloc(cmap->lookup, newcap * sizeof(int)); - if (!newlookup) - return fz_outofmem; - cmap->tcap = newcap; - cmap->lookup = newlookup; - } - - cmap->lookup[cmap->tlen++] = value; - - return nil; -} - -static int compare(const void *va, const void *vb) -{ - return ((const fz_range*)va)->low - ((const fz_range*)vb)->low; -} - -fz_error * -fz_endcidrange(fz_cmap *cmap) -{ - fz_error *error; - fz_range *newranges; - int *newlookup; - fz_range *a; /* last written range on output */ - fz_range *b; /* current range examined on input */ - - qsort(cmap->ranges, cmap->rlen, sizeof(fz_range), compare); - - a = cmap->ranges; - b = cmap->ranges + 1; - - while (b < cmap->ranges + cmap->rlen) - { - /* input contiguous */ - if (a->high + 1 == b->low) - { - /* output contiguous */ - if (a->high - a->low + a->offset + 1 == b->offset) - { - /* SR -> R and SS -> R and RR -> R and RS -> R */ - if (a->flag == SINGLE || a->flag == RANGE) - { - a->flag = RANGE; - a->high = b->high; - } - - /* LS -> L */ - else if (a->flag == LOOKUP && b->flag == SINGLE) - { - a->high = b->high; - error = addlookup(cmap, b->offset); - if (error) - return error; - } - - /* LR -> LR */ - else if (a->flag == LOOKUP && b->flag == RANGE) - { - *(++a) = *b; - } - } - - /* output separated */ - else - { - /* SS -> L */ - if (a->flag == SINGLE && b->flag == SINGLE) - { - a->flag = LOOKUP; - a->high = b->high; - - error = addlookup(cmap, a->offset); - if (error) - return error; - - error = addlookup(cmap, b->offset); - if (error) - return error; - - a->offset = cmap->tlen - 2; - } - - /* LS -> L */ - else if (a->flag == LOOKUP && b->flag == SINGLE) - { - a->high = b->high; - error = addlookup(cmap, b->offset); - if (error) - return error; - } - - /* XX -> XX */ - else - { - *(++a) = *b; - } - } - } - - /* input separated: XX -> XX */ - else - { - *(++a) = *b; - } - - b ++; - } - - cmap->rlen = a - cmap->ranges + 1; - - assert(cmap->rlen > 0); - - newranges = fz_realloc(cmap->ranges, cmap->rlen * sizeof(fz_range)); - if (!newranges) - return fz_outofmem; - cmap->rcap = cmap->rlen; - cmap->ranges = newranges; - - if (cmap->tlen) - { - newlookup = fz_realloc(cmap->lookup, cmap->tlen * sizeof(int)); - if (!newlookup) - return fz_outofmem; - cmap->tcap = cmap->tlen; - cmap->lookup = newlookup; - } - - return nil; -} - -fz_error * -fz_setcidlookup(fz_cmap *cmap, int map[256]) -{ - int i; - - cmap->rlen = cmap->rcap = 1; - cmap->ranges = fz_malloc(sizeof (fz_range)); - if (!cmap->ranges) { - return fz_outofmem; - } - - cmap->tlen = cmap->tcap = 256; - cmap->lookup = fz_malloc(sizeof (int) * 256); - if (!cmap->lookup) { - fz_free(cmap->ranges); - return fz_outofmem; - } - - cmap->ranges[0].low = 0; - cmap->ranges[0].high = 255; - cmap->ranges[0].flag = LOOKUP; - cmap->ranges[0].offset = 0; - - for (i = 0; i < 256; i++) - cmap->lookup[i] = map[i]; - - return nil; -} - -int -fz_lookupcid(fz_cmap *cmap, int cpt) -{ - int l = 0; - int r = cmap->rlen - 1; - int m; - - while (l <= r) - { - m = (l + r) >> 1; - if (cpt < cmap->ranges[m].low) - r = m - 1; - else if (cpt > cmap->ranges[m].high) - l = m + 1; - else - { - int i = cpt - cmap->ranges[m].low + cmap->ranges[m].offset; - if (cmap->ranges[m].flag == LOOKUP) - return cmap->lookup[i]; - return i; - } - } - - if (cmap->usecmap) - return fz_lookupcid(cmap->usecmap, cpt); - - return -1; -} - -unsigned char * -fz_decodecpt(fz_cmap *cmap, unsigned char *buf, int *cpt) -{ - int i, k; - - for (k = 0; k < cmap->ncspace; k++) - { - unsigned char *lo = cmap->cspace[k].lo; - unsigned char *hi = cmap->cspace[k].hi; - int n = cmap->cspace[k].n; - int c = 0; - - for (i = 0; i < n; i++) - { - if (lo[i] <= buf[i] && buf[i] <= hi[i]) - c = (c << 8) | buf[i]; - else - break; - } - - if (i == n) { - *cpt = c; - return buf + n; - } - } - - *cpt = 0; - return buf + 1; -} - -void -fz_debugcmap(fz_cmap *cmap) -{ - int i, k; - - printf("cmap $%p /%s {\n", cmap, cmap->cmapname); - - if (cmap->usecmapname[0]) - printf(" usecmap /%s\n", cmap->usecmapname); - if (cmap->usecmap) - printf(" usecmap $%p\n", cmap->usecmap); - - printf(" wmode %d\n", cmap->wmode); - - printf(" codespaces {\n"); - for (i = 0; i < cmap->ncspace; i++) - { - printf(" <"); - for (k = 0; k < cmap->cspace[i].n; k++) - printf("%02x", cmap->cspace[i].lo[k]); - printf("> <"); - for (k = 0; k < cmap->cspace[i].n; k++) - printf("%02x", cmap->cspace[i].hi[k]); - printf(">\n"); - } - printf(" }\n"); - - printf(" ranges (%d,%d) {\n", cmap->rlen, cmap->tlen); - for (i = 0; i < cmap->rlen; i++) - { - fz_range *r = &cmap->ranges[i]; - printf(" <%04x> <%04x> ", r->low, r->high); - if (r->flag == LOOKUP) - { - printf("[ "); - for (k = 0; k < r->high - r->low + 1; k++) - printf("%d ", cmap->lookup[r->offset + k]); - printf("]\n"); - } - else - printf("%d\n", r->offset); - } - printf(" }\n}\n"); -} - diff --git a/tree/colorspace.c b/tree/colorspace.c deleted file mode 100644 index 65909bfe..00000000 --- a/tree/colorspace.c +++ /dev/null @@ -1,89 +0,0 @@ -#include - -void -fz_convertpixmap(fz_colorspace *srcs, fz_pixmap *src, fz_colorspace *dsts, fz_pixmap *dst) -{ - srcs->convpixmap(srcs, src, dsts, dst); -} - -void -fz_convertcolor(fz_colorspace *srcs, float *srcv, fz_colorspace *dsts, float *dstv) -{ - srcs->convcolor(srcs, srcv, dsts, dstv); -} - -fz_colorspace * -fz_keepcolorspace(fz_colorspace *cs) -{ - if (cs->refs < 0) - return cs; - cs->refs ++; - return cs; -} - -void -fz_dropcolorspace(fz_colorspace *cs) -{ - if (cs->refs < 0) - return; - if (--cs->refs == 0) - { - if (cs->drop) - cs->drop(cs); - fz_free(cs); - } -} - -void -fz_stdconvcolor(fz_colorspace *srcs, float *srcv, fz_colorspace *dsts, float *dstv) -{ - float xyz[3]; - int i; - - if (srcs != dsts) - { - srcs->toxyz(srcs, srcv, xyz); - dsts->fromxyz(dsts, xyz, dstv); - for (i = 0; i < dsts->n; i++) - dstv[i] = CLAMP(dstv[i], 0.0, 1.0); - } - else - { - for (i = 0; i < srcs->n; i++) - dstv[i] = srcv[i]; - } -} - -void -fz_stdconvpixmap(fz_colorspace *srcs, fz_pixmap *src, fz_colorspace *dsts, fz_pixmap *dst) -{ - float srcv[FZ_MAXCOLORS]; - float dstv[FZ_MAXCOLORS]; - int y, x, k; - - unsigned char *s = src->samples; - unsigned char *d = dst->samples; - - printf("convert pixmap from %s to %s\n", srcs->name, dsts->name); - - assert(src->w == dst->w && src->h == dst->h); - assert(src->n == srcs->n + 1); - assert(dst->n == dsts->n + 1); - - for (y = 0; y < src->h; y++) - { - for (x = 0; x < src->w; x++) - { - *d++ = *s++; - - for (k = 0; k < src->n - 1; k++) - srcv[k] = *s++ / 255.0; - - fz_convertcolor(srcs, srcv, dsts, dstv); - - for (k = 0; k < dst->n - 1; k++) - *d++ = dstv[k] * 255; - } - } -} - diff --git a/tree/debug.c b/tree/debug.c deleted file mode 100644 index b03d4e28..00000000 --- a/tree/debug.c +++ /dev/null @@ -1,191 +0,0 @@ -#include - -static void indent(int level) -{ - while (level--) - putchar(' '); -} - -static void lispnode(fz_node *node, int level); - -static void lispmeta(fz_metanode *node, int level) -{ - fz_node *child; - indent(level); - printf("(meta "); - if (node->name) { fz_debugobj(node->name); } - if (node->dict) { printf("\n"); fz_debugobj(node->dict); } - printf("\n"); - for (child = node->super.first; child; child = child->next) - lispnode(child, level + 1); - indent(level); - printf(")\n"); -} - -static void lispover(fz_overnode *node, int level) -{ - fz_node *child; - indent(level); - printf("(over\n"); - for (child = node->super.first; child; child = child->next) - lispnode(child, level + 1); - indent(level); - printf(")\n"); -} - -static void lispmask(fz_masknode *node, int level) -{ - fz_node *child; - indent(level); - printf("(mask\n"); - for (child = node->super.first; child; child = child->next) - lispnode(child, level + 1); - indent(level); - printf(")\n"); -} - -static void lispblend(fz_blendnode *node, int level) -{ - fz_node *child; - indent(level); - printf("(blend-%d\n", node->mode); - for (child = node->super.first; child; child = child->next) - lispnode(child, level + 1); - indent(level); - printf(")\n"); -} - -static void lisptransform(fz_transformnode *node, int level) -{ - indent(level); - printf("(transform %g %g %g %g %g %g\n", - node->m.a, node->m.b, - node->m.c, node->m.d, - node->m.e, node->m.f); - lispnode(node->super.first, level + 1); - indent(level); - printf(")\n"); -} - -static void lispcolor(fz_colornode *node, int level) -{ - int i; - indent(level); - printf("(color %s ", node->cs->name); - for (i = 0; i < node->n; i++) - printf("%g ", node->samples[i]); - printf(")\n"); -} - -static void lisplink(fz_linknode *node, int level) -{ - indent(level); - printf("(link %p)\n", node->tree); -} - -static void lisppath(fz_pathnode *node, int level) -{ - int i; - - indent(level); - - if (node->paint == FZ_STROKE) - { - printf("(path 'stroke %d %d %g %g ", - node->linecap, - node->linejoin, - node->linewidth, - node->miterlimit); - if (node->dash) - { - printf("%g '( ", node->dash->phase); - for (i = 0; i < node->dash->len; i++) - printf("%g ", node->dash->array[i]); - printf(")"); - } - else - printf("0 '()"); - } - else - { - printf("(path '%s", node->paint == FZ_FILL ? "fill" : "eofill"); - } - - printf("\n"); - fz_debugpathnode(node); - - indent(level); - printf(")\n"); -} - -static void lisptext(fz_textnode *node, int level) -{ - int i; - - indent(level); - printf("(text %s [%g %g %g %g]\n", node->font->name, - node->trm.a, node->trm.b, node->trm.c, node->trm.d); - - for (i = 0; i < node->len; i++) - { - indent(level + 1); - if (node->els[i].cid >= 32 && node->els[i].cid < 128) - printf("(cid '%c' %g %g)\n", node->els[i].cid, node->els[i].x, node->els[i].y); - else - printf("(cid <%04x> %g %g)\n", node->els[i].cid, node->els[i].x, node->els[i].y); - } - - indent(level); - printf(")\n"); -} - -static void lispimage(fz_imagenode *node, int level) -{ - fz_image *image = node->image; - indent(level); - printf("(image %dx%d %d+%d)\n", image->w, image->h, image->n, image->a); -} - -static void lispshade(fz_shadenode *node, int level) -{ - indent(level); - printf("(shade)\n"); -} - -static void lispnode(fz_node *node, int level) -{ - if (!node) - { - indent(level); - printf("(nil)\n"); - return; - } - - switch (node->kind) - { - case FZ_NMETA: lispmeta((fz_metanode*)node, level); break; - case FZ_NOVER: lispover((fz_overnode*)node, level); break; - case FZ_NMASK: lispmask((fz_masknode*)node, level); break; - case FZ_NBLEND: lispblend((fz_blendnode*)node, level); break; - case FZ_NTRANSFORM: lisptransform((fz_transformnode*)node, level); break; - case FZ_NCOLOR: lispcolor((fz_colornode*)node, level); break; - case FZ_NPATH: lisppath((fz_pathnode*)node, level); break; - case FZ_NTEXT: lisptext((fz_textnode*)node, level); break; - case FZ_NIMAGE: lispimage((fz_imagenode*)node, level); break; - case FZ_NSHADE: lispshade((fz_shadenode*)node, level); break; - case FZ_NLINK: lisplink((fz_linknode*)node, level); break; - } -} - -void -fz_debugnode(fz_node *node) -{ - lispnode(node, 0); -} - -void -fz_debugtree(fz_tree *tree) -{ - lispnode(tree->root, 0); -} - diff --git a/tree/font.c b/tree/font.c deleted file mode 100644 index b7367ce1..00000000 --- a/tree/font.c +++ /dev/null @@ -1,269 +0,0 @@ -#include - -void -fz_initfont(fz_font *font, char *name) -{ - font->refs = 1; - strlcpy(font->name, name, sizeof font->name); - - font->wmode = 0; - - font->bbox.min.x = 0; - font->bbox.min.y = 0; - font->bbox.max.x = 1000; - font->bbox.max.y = 1000; - - font->hmtxcap = 0; - font->vmtxcap = 0; - font->nhmtx = 0; - font->nvmtx = 0; - font->hmtx = nil; - font->vmtx = nil; - - font->dhmtx.lo = 0x0000; - font->dhmtx.hi = 0xFFFF; - font->dhmtx.w = 0; - - font->dvmtx.lo = 0x0000; - font->dvmtx.hi = 0xFFFF; - font->dvmtx.x = 0; - font->dvmtx.y = 880; - font->dvmtx.w = -1000; -} - -fz_font * -fz_keepfont(fz_font *font) -{ - font->refs ++; - return font; -} - -void -fz_dropfont(fz_font *font) -{ - if (--font->refs == 0) - { - if (font->drop) - font->drop(font); - fz_free(font->hmtx); - fz_free(font->vmtx); - fz_free(font); - } -} - -void -fz_setfontwmode(fz_font *font, int wmode) -{ - font->wmode = wmode; -} - -void -fz_setfontbbox(fz_font *font, int xmin, int ymin, int xmax, int ymax) -{ - font->bbox.min.x = xmin; - font->bbox.min.y = ymin; - font->bbox.max.x = xmax; - font->bbox.max.y = ymax; -} - -void -fz_setdefaulthmtx(fz_font *font, int w) -{ - font->dhmtx.w = w; -} - -void -fz_setdefaultvmtx(fz_font *font, int y, int w) -{ - font->dvmtx.y = y; - font->dvmtx.w = w; -} - -fz_error * -fz_addhmtx(fz_font *font, int lo, int hi, int w) -{ - int newcap; - fz_hmtx *newmtx; - - if (font->nhmtx + 1 >= font->hmtxcap) - { - newcap = font->hmtxcap + 16; - newmtx = fz_realloc(font->hmtx, sizeof(fz_hmtx) * newcap); - if (!newmtx) - return fz_outofmem; - font->hmtxcap = newcap; - font->hmtx = newmtx; - } - - font->hmtx[font->nhmtx].lo = lo; - font->hmtx[font->nhmtx].hi = hi; - font->hmtx[font->nhmtx].w = w; - font->nhmtx++; - - return nil; -} - -fz_error * -fz_addvmtx(fz_font *font, int lo, int hi, int x, int y, int w) -{ - int newcap; - fz_vmtx *newmtx; - - if (font->nvmtx + 1 >= font->vmtxcap) - { - newcap = font->vmtxcap + 16; - newmtx = fz_realloc(font->vmtx, sizeof(fz_vmtx) * newcap); - if (!newmtx) - return fz_outofmem; - font->vmtxcap = newcap; - font->vmtx = newmtx; - } - - font->vmtx[font->nvmtx].lo = lo; - font->vmtx[font->nvmtx].hi = hi; - font->vmtx[font->nvmtx].x = x; - font->vmtx[font->nvmtx].y = y; - font->vmtx[font->nvmtx].w = w; - font->nvmtx++; - - return nil; -} - -static int cmph(const void *a0, const void *b0) -{ - fz_hmtx *a = (fz_hmtx*)a0; - fz_hmtx *b = (fz_hmtx*)b0; - return a->lo - b->lo; -} - -static int cmpv(const void *a0, const void *b0) -{ - fz_vmtx *a = (fz_vmtx*)a0; - fz_vmtx *b = (fz_vmtx*)b0; - return a->lo - b->lo; -} - -fz_error * -fz_endhmtx(fz_font *font) -{ - fz_hmtx *newmtx; - - if (!font->hmtx) - return nil; - - qsort(font->hmtx, font->nhmtx, sizeof(fz_hmtx), cmph); - - newmtx = fz_realloc(font->hmtx, sizeof(fz_hmtx) * font->nhmtx); - if (!newmtx) - return fz_outofmem; - font->hmtxcap = font->nhmtx; - font->hmtx = newmtx; - - return nil; -} - -fz_error * -fz_endvmtx(fz_font *font) -{ - fz_vmtx *newmtx; - - if (!font->vmtx) - return nil; - - qsort(font->vmtx, font->nvmtx, sizeof(fz_vmtx), cmpv); - - newmtx = fz_realloc(font->vmtx, sizeof(fz_vmtx) * font->nvmtx); - if (!newmtx) - return fz_outofmem; - font->vmtxcap = font->nvmtx; - font->vmtx = newmtx; - - return nil; -} - -fz_hmtx -fz_gethmtx(fz_font *font, int cid) -{ - int l = 0; - int r = font->nhmtx - 1; - int m; - - if (!font->hmtx) - goto notfound; - - while (l <= r) - { - m = (l + r) >> 1; - if (cid < font->hmtx[m].lo) - r = m - 1; - else if (cid > font->hmtx[m].hi) - l = m + 1; - else - return font->hmtx[m]; - } - -notfound: - return font->dhmtx; -} - -fz_vmtx -fz_getvmtx(fz_font *font, int cid) -{ - fz_hmtx h; - fz_vmtx v; - int l = 0; - int r = font->nvmtx - 1; - int m; - - if (!font->vmtx) - goto notfound; - - while (l <= r) - { - m = (l + r) >> 1; - if (cid < font->vmtx[m].lo) - r = m - 1; - else if (cid > font->vmtx[m].hi) - l = m + 1; - else - return font->vmtx[m]; - } - -notfound: - h = fz_gethmtx(font, cid); - v = font->dvmtx; - v.x = h.w / 2; - return v; -} - -void -fz_debugfont(fz_font *font) -{ - int i; - - printf("font '%s' {\n", font->name); - printf(" wmode %d\n", font->wmode); - printf(" bbox [%d %d %d %d]\n", - font->bbox.min.x, font->bbox.min.y, - font->bbox.max.x, font->bbox.max.y); - printf(" DW %d\n", font->dhmtx.w); - - printf(" W {\n"); - for (i = 0; i < font->nhmtx; i++) - printf(" <%04x> <%04x> %d\n", - font->hmtx[i].lo, font->hmtx[i].hi, font->hmtx[i].w); - printf(" }\n"); - - if (font->wmode) - { - printf(" DW2 [%d %d]\n", font->dvmtx.y, font->dvmtx.w); - printf(" W2 {\n"); - for (i = 0; i < font->nvmtx; i++) - printf(" <%04x> <%04x> %d %d %d\n", font->vmtx[i].lo, font->vmtx[i].hi, - font->vmtx[i].x, font->vmtx[i].y, font->vmtx[i].w); - printf(" }\n"); - } - - printf("}\n"); -} - diff --git a/tree/image.c b/tree/image.c deleted file mode 100644 index dbeb1fd8..00000000 --- a/tree/image.c +++ /dev/null @@ -1,22 +0,0 @@ -#include - -fz_image * -fz_keepimage(fz_image *image) -{ - image->refs ++; - return image; -} - -void -fz_dropimage(fz_image *image) -{ - if (--image->refs == 0) - { - if (image->drop) - image->drop(image); - if (image->cs) - fz_dropcolorspace(image->cs); - fz_free(image); - } -} - diff --git a/tree/node1.c b/tree/node1.c deleted file mode 100644 index c2d6e876..00000000 --- a/tree/node1.c +++ /dev/null @@ -1,167 +0,0 @@ -#include - -void fz_dropmetanode(fz_metanode* node); -void fz_droplinknode(fz_linknode* node); -void fz_droppathnode(fz_pathnode* node); -void fz_droptextnode(fz_textnode* node); -void fz_dropimagenode(fz_imagenode* node); -void fz_dropshadenode(fz_shadenode* node); - -fz_rect fz_boundtransformnode(fz_transformnode* node, fz_matrix ctm); -fz_rect fz_boundovernode(fz_overnode* node, fz_matrix ctm); -fz_rect fz_boundmasknode(fz_masknode* node, fz_matrix ctm); -fz_rect fz_boundblendnode(fz_blendnode* node, fz_matrix ctm); -fz_rect fz_boundcolornode(fz_colornode* node, fz_matrix ctm); -fz_rect fz_boundpathnode(fz_pathnode* node, fz_matrix ctm); -fz_rect fz_boundtextnode(fz_textnode* node, fz_matrix ctm); -fz_rect fz_boundimagenode(fz_imagenode* node, fz_matrix ctm); -fz_rect fz_boundshadenode(fz_shadenode* node, fz_matrix ctm); -fz_rect fz_boundlinknode(fz_linknode* node, fz_matrix ctm); -fz_rect fz_boundmetanode(fz_metanode* node, fz_matrix ctm); - -void -fz_initnode(fz_node *node, fz_nodekind kind) -{ - node->kind = kind; - node->parent = nil; - node->first = nil; - node->last = nil; - node->next = nil; -} - -void -fz_dropnode(fz_node *node) -{ - if (node->first) - fz_dropnode(node->first); - if (node->next) - fz_dropnode(node->next); - - switch (node->kind) - { - case FZ_NTRANSFORM: - case FZ_NOVER: - case FZ_NMASK: - case FZ_NBLEND: - case FZ_NCOLOR: - break; - case FZ_NPATH: - fz_droppathnode((fz_pathnode *) node); - break; - case FZ_NTEXT: - fz_droptextnode((fz_textnode *) node); - break; - case FZ_NIMAGE: - fz_dropimagenode((fz_imagenode *) node); - break; - case FZ_NSHADE: - fz_dropshadenode((fz_shadenode *) node); - break; - case FZ_NLINK: - fz_droplinknode((fz_linknode *) node); - break; - case FZ_NMETA: - fz_dropmetanode((fz_metanode *) node); - break; - } - - fz_free(node); -} - -fz_rect -fz_boundnode(fz_node *node, fz_matrix ctm) -{ - switch (node->kind) - { - case FZ_NTRANSFORM: - return fz_boundtransformnode((fz_transformnode *) node, ctm); - case FZ_NOVER: - return fz_boundovernode((fz_overnode *) node, ctm); - case FZ_NMASK: - return fz_boundmasknode((fz_masknode *) node, ctm); - case FZ_NBLEND: - return fz_boundblendnode((fz_blendnode *) node, ctm); - case FZ_NCOLOR: - return fz_boundcolornode((fz_colornode *) node, ctm); - case FZ_NPATH: - return fz_boundpathnode((fz_pathnode *) node, ctm); - case FZ_NTEXT: - return fz_boundtextnode((fz_textnode *) node, ctm); - case FZ_NIMAGE: - return fz_boundimagenode((fz_imagenode *) node, ctm); - case FZ_NSHADE: - return fz_boundshadenode((fz_shadenode *) node, ctm); - case FZ_NLINK: - return fz_boundlinknode((fz_linknode *) node, ctm); - case FZ_NMETA: - return fz_boundmetanode((fz_metanode *) node, ctm); - } - return fz_emptyrect; -} - -int -fz_istransformnode(fz_node *node) -{ - return node ? node->kind == FZ_NTRANSFORM : 0; -} - -int -fz_isovernode(fz_node *node) -{ - return node ? node->kind == FZ_NOVER : 0; -} - -int -fz_ismasknode(fz_node *node) -{ - return node ? node->kind == FZ_NMASK : 0; -} - -int -fz_isblendnode(fz_node *node) -{ - return node ? node->kind == FZ_NBLEND : 0; -} - -int -fz_iscolornode(fz_node *node) -{ - return node ? node->kind == FZ_NCOLOR : 0; -} - -int -fz_ispathnode(fz_node *node) -{ - return node ? node->kind == FZ_NPATH : 0; -} - -int -fz_istextnode(fz_node *node) -{ - return node ? node->kind == FZ_NTEXT : 0; -} - -int -fz_isimagenode(fz_node *node) -{ - return node ? node->kind == FZ_NIMAGE : 0; -} - -int -fz_isshadenode(fz_node *node) -{ - return node ? node->kind == FZ_NSHADE : 0; -} - -int -fz_islinknode(fz_node *node) -{ - return node ? node->kind == FZ_NLINK : 0; -} - -int -fz_ismetanode(fz_node *node) -{ - return node ? node->kind == FZ_NMETA : 0; -} - diff --git a/tree/node2.c b/tree/node2.c deleted file mode 100644 index f21ebf36..00000000 --- a/tree/node2.c +++ /dev/null @@ -1,338 +0,0 @@ -#include - -/* - * Over - */ - -fz_error * -fz_newovernode(fz_node **nodep) -{ - fz_node *node; - - node = *nodep = fz_malloc(sizeof (fz_overnode)); - if (!node) - return fz_outofmem; - - fz_initnode(node, FZ_NOVER); - - return nil; -} - -fz_rect -fz_boundovernode(fz_overnode *node, fz_matrix ctm) -{ - fz_node *child; - fz_rect bbox; - fz_rect temp; - - child = node->super.first; - if (!child) - return fz_emptyrect; - - bbox = fz_boundnode(child, ctm); - - child = child->next; - while (child) - { - temp = fz_boundnode(child, ctm); - bbox = fz_mergerects(temp, bbox); - child = child->next; - } - - return bbox; -} - -/* - * Mask - */ - -fz_error * -fz_newmasknode(fz_node **nodep) -{ - fz_node *node; - - node = *nodep = fz_malloc(sizeof (fz_masknode)); - if (!node) - return fz_outofmem; - - fz_initnode(node, FZ_NMASK); - - return nil; -} - -fz_rect -fz_boundmasknode(fz_masknode *node, fz_matrix ctm) -{ - fz_node *shape; - fz_node *color; - fz_rect one, two; - - shape = node->super.first; - color = shape->next; - - one = fz_boundnode(shape, ctm); - two = fz_boundnode(color, ctm); - return fz_intersectrects(one, two); -} - -/* - * Blend - */ - -fz_error * -fz_newblendnode(fz_node **nodep, fz_colorspace *cs, fz_blendkind b, int k, int i) -{ - fz_blendnode *node; - - node = fz_malloc(sizeof (fz_blendnode)); - if (!node) - return fz_outofmem; - *nodep = (fz_node*)node; - - fz_initnode((fz_node*)node, FZ_NBLEND); - node->cs = fz_keepcolorspace(cs); - node->mode = b; - node->knockout = k; - node->isolated = i; - - return nil; -} - -fz_rect -fz_boundblendnode(fz_blendnode *node, fz_matrix ctm) -{ - fz_node *child; - fz_rect bbox; - fz_rect temp; - - child = node->super.first; - if (!child) - return fz_emptyrect; - - bbox = fz_boundnode(child, ctm); - - child = child->next; - while (child) - { - temp = fz_boundnode(child, ctm); - bbox = fz_mergerects(temp, bbox); - child = child->next; - } - - return bbox; -} - -void -fz_dropblendnode(fz_blendnode *node) -{ - fz_dropcolorspace(node->cs); -} - -/* - * Transform - */ - -fz_error * -fz_newtransformnode(fz_node **nodep, fz_matrix m) -{ - fz_transformnode *node; - - node = fz_malloc(sizeof (fz_transformnode)); - if (!node) - return fz_outofmem; - *nodep = (fz_node*)node; - - fz_initnode((fz_node*)node, FZ_NTRANSFORM); - node->m = m; - - return nil; -} - -fz_rect -fz_boundtransformnode(fz_transformnode *node, fz_matrix ctm) -{ - if (!node->super.first) - return fz_emptyrect; - return fz_boundnode(node->super.first, fz_concat(node->m, ctm)); -} - -/* - * Meta info - */ - -fz_error * -fz_newmetanode(fz_node **nodep, fz_obj *name, fz_obj *dict) -{ - fz_metanode *node; - - node = fz_malloc(sizeof (fz_metanode)); - if (!node) - return fz_outofmem; - *nodep = (fz_node*)node; - - fz_initnode((fz_node*)node, FZ_NMETA); - node->name = nil; - node->dict = nil; - - if (name) - node->name = fz_keepobj(name); - if (dict) - node->dict = fz_keepobj(dict); - - return nil; -} - -void -fz_dropmetanode(fz_metanode *node) -{ - if (node->name) - fz_dropobj(node->name); - if (node->dict) - fz_dropobj(node->dict); -} - -fz_rect -fz_boundmetanode(fz_metanode *node, fz_matrix ctm) -{ - if (!node->super.first) - return fz_emptyrect; - return fz_boundnode(node->super.first, ctm); -} - -/* - * Link to tree - */ - -fz_error * -fz_newlinknode(fz_node **nodep, fz_tree *subtree) -{ - fz_linknode *node; - - node = fz_malloc(sizeof (fz_linknode)); - if (!node) - return fz_outofmem; - *nodep = (fz_node*)node; - - fz_initnode((fz_node*)node, FZ_NLINK); - node->tree = fz_keeptree(subtree); - - return nil; -} - -void -fz_droplinknode(fz_linknode *node) -{ - fz_droptree(node->tree); -} - -fz_rect -fz_boundlinknode(fz_linknode *node, fz_matrix ctm) -{ - return fz_boundtree(node->tree, ctm); -} - -/* - * Solid color - */ - -fz_error * -fz_newcolornode(fz_node **nodep, fz_colorspace *cs, int n, float *v) -{ - fz_colornode *node; - int i; - - node = fz_malloc(sizeof(fz_colornode) + sizeof(float) * n); - if (!node) - return fz_outofmem; - *nodep = (fz_node*)node; - - fz_initnode((fz_node*)node, FZ_NCOLOR); - node->cs = fz_keepcolorspace(cs); - node->n = n; - for (i = 0; i < n; i++) - node->samples[i] = v[i]; - - return nil; -} - -fz_rect -fz_boundcolornode(fz_colornode *node, fz_matrix ctm) -{ - return fz_infiniterect; -} - -void -fz_dropcolornode(fz_colornode *node) -{ - fz_dropcolorspace(node->cs); -} - -/* - * Image node - */ - -fz_error * -fz_newimagenode(fz_node **nodep, fz_image *image) -{ - fz_imagenode *node; - - node = fz_malloc(sizeof (fz_imagenode)); - if (!node) - return fz_outofmem; - *nodep = (fz_node*)node; - - fz_initnode((fz_node*)node, FZ_NIMAGE); - node->image = fz_keepimage(image); - - return nil; -} - -void -fz_dropimagenode(fz_imagenode *node) -{ - fz_dropimage(node->image); -} - -fz_rect -fz_boundimagenode(fz_imagenode *node, fz_matrix ctm) -{ - fz_rect bbox; - bbox.min.x = 0; - bbox.min.y = 0; - bbox.max.x = 1; - bbox.max.y = 1; - return fz_transformaabb(ctm, bbox); -} - -/* - * Shade node - */ - -fz_error * -fz_newshadenode(fz_node **nodep, fz_shade *shade) -{ - fz_shadenode *node; - - node = fz_malloc(sizeof (fz_shadenode)); - if (!node) - return fz_outofmem; - *nodep = (fz_node*)node; - - fz_initnode((fz_node*)node, FZ_NSHADE); - node->shade = fz_keepshade(shade); - - return nil; -} - -void -fz_dropshadenode(fz_shadenode *node) -{ - fz_dropshade(node->shade); -} - -fz_rect -fz_boundshadenode(fz_shadenode *node, fz_matrix ctm) -{ - return fz_boundshade(node->shade, ctm); -} - diff --git a/tree/optimize.c b/tree/optimize.c deleted file mode 100644 index d92aa812..00000000 --- a/tree/optimize.c +++ /dev/null @@ -1,310 +0,0 @@ -#include - -/* - * Remove (mask ... white) until we get something not white - */ - -static int iswhitenode(fz_colornode *node) -{ - if (!strcmp(node->cs->name, "DeviceGray")) - return fabs(node->samples[0] - 1.0) < FLT_EPSILON; - if (!strcmp(node->cs->name, "DeviceRGB")) - return fabs(node->samples[0] - 1.0) < FLT_EPSILON && - fabs(node->samples[1] - 1.0) < FLT_EPSILON && - fabs(node->samples[2] - 1.0) < FLT_EPSILON; - if (!strcmp(node->cs->name, "DeviceCMYK")) - return fabs(node->samples[0]) < FLT_EPSILON && - fabs(node->samples[1]) < FLT_EPSILON && - fabs(node->samples[2]) < FLT_EPSILON && - fabs(node->samples[3]) < FLT_EPSILON; - return 0; -} - -static int cleanwhite(fz_node *node) -{ - fz_node *current; - fz_node *next; - fz_node *shape; - fz_node *color; - - for (current = node->first; current; current = next) - { - next = current->next; - - if (fz_islinknode(current)) - return 1; - else if (fz_isimagenode(current)) - return 1; - else if (fz_isshadenode(current)) - return 1; - else if (fz_iscolornode(current)) - { - if (!iswhitenode((fz_colornode*)current)) - return 1; - } - - else if (fz_ismasknode(current)) - { - shape = current->first; - color = shape->next; - if (fz_iscolornode(color)) - { - if (iswhitenode((fz_colornode*)color)) - fz_removenode(current); - else - return 1; - } - else - { - if (cleanwhite(current)) - return 1; - } - } - - else - { - if (cleanwhite(current)) - return 1; - } - } - - return 0; -} - -/* - * Remove useless overs that only have one child. - */ - -static void cleanovers(fz_node *node) -{ - fz_node *prev; - fz_node *next; - fz_node *current; - fz_node *child; - - prev = nil; - for (current = node->first; current; current = next) - { - next = current->next; - - if (fz_isovernode(current)) - { - if (current->first == current->last) - { - child = current->first; - fz_removenode(current); - if (child) - { - if (prev) - fz_insertnodeafter(prev, child); - else - fz_insertnodefirst(node, child); - } - current = child; - } - } - - if (current) - prev = current; - } - - for (current = node->first; current; current = current->next) - cleanovers(current); -} - -/* - * Remove rectangular clip-masks whose contents fit... - */ - -static int getrect(fz_pathnode *path, fz_rect *bboxp) -{ - float x, y, w, h; - - /* move x y, line x+w y, line x+w y+h, line x y+h, close */ - - if (path->len != 13) - return 0; - - if (path->els[0].k != FZ_MOVETO) return 0; - x = path->els[1].v; - y = path->els[2].v; - - if (path->els[3].k != FZ_LINETO) return 0; - w = path->els[4].v - x; - if (path->els[5].v != y) return 0; - - if (path->els[6].k != FZ_LINETO) return 0; - if (path->els[7].v != x + w) return 0; - h = path->els[8].v - y; - - if (path->els[9].k != FZ_LINETO) return 0; - if (path->els[10].v != x) return 0; - if (path->els[11].v != y + h) return 0; - - if (path->els[12].k != FZ_CLOSEPATH) return 0; - - bboxp->min.x = MIN(x, x + w); - bboxp->min.y = MIN(y, y + h); - bboxp->max.x = MAX(x, x + w); - bboxp->max.y = MAX(y, y + h); - - return 1; -} - -static int fitsinside(fz_node *node, fz_rect clip) -{ - fz_rect bbox; - bbox = fz_boundnode(node, fz_identity()); - if (fz_isinfiniterect(bbox)) return 0; - if (fz_isemptyrect(bbox)) return 1; - if (bbox.min.x < clip.min.x) return 0; - if (bbox.max.x > clip.max.x) return 0; - if (bbox.min.y < clip.min.y) return 0; - if (bbox.max.y > clip.max.y) return 0; - return 1; -} - -static void cleanmasks(fz_node *node) -{ - fz_node *prev; - fz_node *current; - fz_node *shape; - fz_node *color; - fz_rect bbox; - - for (current = node->first; current; current = current->next) - cleanmasks(current); - - prev = nil; - for (current = node->first; current; current = current->next) - { -retry: - if (fz_ismasknode(current)) - { - shape = current->first; - color = shape->next; - - if (color == nil) - { - fz_removenode(current); - prev = nil; - current = node->first; - goto retry; - } - - if (fz_ispathnode(shape)) - { - if (getrect((fz_pathnode*)shape, &bbox)) - { - if (fitsinside(color, bbox)) - { - fz_removenode(current); - if (prev) - fz_insertnodeafter(prev, color); - else - fz_insertnodefirst(node, color); - current = color; - goto retry; - } - } - } - } - - prev = current; - } -} - -/* - * Turn 1x1 images into rectangle fills - */ - -static fz_error *clean1x1(fz_node *node) -{ - fz_error *error; - fz_node *current; - fz_node *color; - fz_pathnode *rect; - fz_node *mask; - fz_image *image; - fz_pixmap *pix; - float v[FZ_MAXCOLORS]; - int i; - - for (current = node->first; current; current = current->next) - { - if (fz_isimagenode(current)) - { - image = ((fz_imagenode*)current)->image; - if (image->w == 1 && image->h == 1) - { - error = fz_newpathnode(&rect); - fz_moveto(rect, 0, 0); - fz_lineto(rect, 1, 0); - fz_lineto(rect, 1, 1); - fz_lineto(rect, 0, 1); - fz_closepath(rect); - fz_endpath(rect, FZ_FILL, nil, nil); - - if (image->cs) - { - error = fz_newpixmap(&pix, 0, 0, 1, 1, image->n + 1); - if (error) - return error; - - error = image->loadtile(image, pix); - if (error) - return error; - - for (i = 0; i < image->n; i++) - v[i] = pix->samples[i + 1] / 255.0; - - fz_droppixmap(pix); - - error = fz_newcolornode(&color, image->cs, image->n, v); - if (error) - return error; - error = fz_newmasknode(&mask); - if (error) - return error; - - fz_insertnodeafter(current, mask); - fz_insertnodelast(mask, (fz_node*)rect); - fz_insertnodelast(mask, color); - fz_removenode(current); - current = mask; - } - - else - { - /* pray that the 1x1 image mask is all opaque */ - fz_insertnodeafter(current, (fz_node*)rect); - fz_removenode(current); - current = (fz_node*)rect; - } - } - } - - error = clean1x1(current); - if (error) - return error; - } - - return nil; -} - -/* - * - */ - -fz_error * -fz_optimizetree(fz_tree *tree) -{ - if (getenv("DONTOPT")) - return nil; - cleanwhite(tree->root); - cleanovers(tree->root); - cleanmasks(tree->root); - clean1x1(tree->root); - return nil; -} - diff --git a/tree/path.c b/tree/path.c deleted file mode 100644 index 24b4dfc8..00000000 --- a/tree/path.c +++ /dev/null @@ -1,305 +0,0 @@ -#include - -fz_error * -fz_newpathnode(fz_pathnode **pathp) -{ - fz_pathnode *path; - - path = *pathp = fz_malloc(sizeof(fz_pathnode)); - if (!path) - return fz_outofmem; - - fz_initnode((fz_node*)path, FZ_NPATH); - - path->paint = FZ_FILL; - path->linecap = 0; - path->linejoin = 0; - path->linewidth = 1.0; - path->miterlimit = 10.0; - path->dash = nil; - path->len = 0; - path->cap = 0; - path->els = nil; - - return nil; -} - -fz_error * -fz_clonepathnode(fz_pathnode **pathp, fz_pathnode *oldpath) -{ - fz_pathnode *path; - - path = *pathp = fz_malloc(sizeof(fz_pathnode)); - if (!path) - return fz_outofmem; - - fz_initnode((fz_node*)path, FZ_NPATH); - - path->paint = FZ_FILL; - path->linecap = 0; - path->linejoin = 0; - path->linewidth = 1.0; - path->miterlimit = 10.0; - path->dash = nil; - path->len = oldpath->len; - path->cap = oldpath->len; - - path->els = fz_malloc(sizeof (fz_pathel) * path->len); - if (!path->els) { - fz_free(path); - return fz_outofmem; - } - memcpy(path->els, oldpath->els, sizeof(fz_pathel) * path->len); - - return nil; -} - -void -fz_droppathnode(fz_pathnode *node) -{ - fz_free(node->dash); - fz_free(node->els); -} - -static fz_error * -growpath(fz_pathnode *path, int n) -{ - int newcap; - fz_pathel *newels; - - while (path->len + n > path->cap) - { - newcap = path->cap + 36; - newels = fz_realloc(path->els, sizeof (fz_pathel) * newcap); - if (!newels) - return fz_outofmem; - path->cap = newcap; - path->els = newels; - } - - return nil; -} - -fz_error * -fz_moveto(fz_pathnode *path, float x, float y) -{ - if (growpath(path, 3) != nil) - return fz_outofmem; - path->els[path->len++].k = FZ_MOVETO; - path->els[path->len++].v = x; - path->els[path->len++].v = y; - return nil; -} - -fz_error * -fz_lineto(fz_pathnode *path, float x, float y) -{ - if (growpath(path, 3) != nil) - return fz_outofmem; - path->els[path->len++].k = FZ_LINETO; - path->els[path->len++].v = x; - path->els[path->len++].v = y; - return nil; -} - -fz_error * -fz_curveto(fz_pathnode *path, - float x1, float y1, - float x2, float y2, - float x3, float y3) -{ - if (growpath(path, 7) != nil) - return fz_outofmem; - path->els[path->len++].k = FZ_CURVETO; - path->els[path->len++].v = x1; - path->els[path->len++].v = y1; - path->els[path->len++].v = x2; - path->els[path->len++].v = y2; - path->els[path->len++].v = x3; - path->els[path->len++].v = y3; - return nil; -} - -fz_error * -fz_curvetov(fz_pathnode *path, float x2, float y2, float x3, float y3) -{ - float x1 = path->els[path->len-2].v; - float y1 = path->els[path->len-1].v; - return fz_curveto(path, x1, y1, x2, y2, x3, y3); -} - -fz_error * -fz_curvetoy(fz_pathnode *path, float x1, float y1, float x3, float y3) -{ - return fz_curveto(path, x1, y1, x3, y3, x3, y3); -} - -fz_error * -fz_closepath(fz_pathnode *path) -{ - if (growpath(path, 1) != nil) - return fz_outofmem; - path->els[path->len++].k = FZ_CLOSEPATH; - return nil; -} - -fz_error * -fz_endpath(fz_pathnode *path, fz_pathkind paint, fz_stroke *stroke, fz_dash *dash) -{ - fz_pathel *newels; - - newels = fz_realloc(path->els, path->len * sizeof(fz_pathel)); - if (!newels) - return fz_outofmem; - path->els = newels; - - path->paint = paint; - path->dash = dash; - if (stroke) - { - path->linecap = stroke->linecap; - path->linejoin = stroke->linejoin; - path->linewidth = stroke->linewidth; - path->miterlimit = stroke->miterlimit; - } - - if (path->linewidth < 0.01) - path->linewidth = 0.01; - - return nil; -} - -static inline fz_rect boundexpand(fz_rect r, fz_point p) -{ - if (p.x < r.min.x) r.min.x = p.x; - if (p.y < r.min.y) r.min.y = p.y; - if (p.x > r.max.x) r.max.x = p.x; - if (p.y > r.max.y) r.max.y = p.y; - return r; -} - -fz_rect -fz_boundpathnode(fz_pathnode *path, fz_matrix ctm) -{ - fz_point p; - fz_rect r = fz_emptyrect; - int i = 0; - - if (path->len) - { - p.x = path->els[1].v; - p.y = path->els[2].v; - p = fz_transformpoint(ctm, p); - r.min.x = r.max.x = p.x; - r.min.y = r.max.y = p.y; - } - - while (i < path->len) - { - switch (path->els[i++].k) - { - case FZ_CURVETO: - p.x = path->els[i++].v; - p.y = path->els[i++].v; - r = boundexpand(r, fz_transformpoint(ctm, p)); - p.x = path->els[i++].v; - p.y = path->els[i++].v; - r = boundexpand(r, fz_transformpoint(ctm, p)); - case FZ_MOVETO: - case FZ_LINETO: - p.x = path->els[i++].v; - p.y = path->els[i++].v; - r = boundexpand(r, fz_transformpoint(ctm, p)); - break; - case FZ_CLOSEPATH: - break; - } - } - - if (path->paint == FZ_STROKE) - { - float miterlength = sin(path->miterlimit / 2.0); - float linewidth = path->linewidth; - float expand = MAX(miterlength, linewidth) / 2.0; - r.min.x -= expand; - r.min.y -= expand; - r.max.x += expand; - r.max.y += expand; - } - - return r; -} - -void -fz_debugpathnode(fz_pathnode *path) -{ - float x, y; - int i = 0; - while (i < path->len) - { - switch (path->els[i++].k) - { - case FZ_MOVETO: - x = path->els[i++].v; - y = path->els[i++].v; - printf("%g %g m\n", x, y); - break; - case FZ_LINETO: - x = path->els[i++].v; - y = path->els[i++].v; - printf("%g %g l\n", x, y); - break; - case FZ_CURVETO: - x = path->els[i++].v; - y = path->els[i++].v; - printf("%g %g ", x, y); - x = path->els[i++].v; - y = path->els[i++].v; - printf("%g %g ", x, y); - x = path->els[i++].v; - y = path->els[i++].v; - printf("%g %g c\n", x, y); - break; - case FZ_CLOSEPATH: - printf("h\n"); - } - } - - switch (path->paint) - { - case FZ_STROKE: - printf("S\n"); - break; - case FZ_FILL: - printf("f\n"); - break; - case FZ_EOFILL: - printf("f*\n"); - break; - } -} - -fz_error * -fz_newdash(fz_dash **dashp, float phase, int len, float *array) -{ - fz_dash *dash; - int i; - - dash = *dashp = fz_malloc(sizeof(fz_dash) + sizeof(float) * len); - if (!dash) - return fz_outofmem; - - dash->len = len; - dash->phase = phase; - for (i = 0; i < len; i++) - dash->array[i] = array[i]; - - return nil; -} - -void -fz_dropdash(fz_dash *dash) -{ - fz_free(dash); -} - diff --git a/tree/shade.c b/tree/shade.c deleted file mode 100644 index 67a64e4e..00000000 --- a/tree/shade.c +++ /dev/null @@ -1,28 +0,0 @@ -#include - -fz_shade * -fz_keepshade(fz_shade *shade) -{ - shade->refs ++; - return shade; -} - -void -fz_dropshade(fz_shade *shade) -{ - if (--shade->refs == 0) - { - if (shade->cs) - fz_dropcolorspace(shade->cs); - fz_free(shade->mesh); - fz_free(shade); - } -} - -fz_rect -fz_boundshade(fz_shade *shade, fz_matrix ctm) -{ - ctm = fz_concat(shade->matrix, ctm); - return fz_transformaabb(ctm, shade->bbox); -} - diff --git a/tree/text.c b/tree/text.c deleted file mode 100644 index d88e04ec..00000000 --- a/tree/text.c +++ /dev/null @@ -1,141 +0,0 @@ -#include - -fz_error * -fz_newtextnode(fz_textnode **textp, fz_font *font) -{ - fz_textnode *text; - - text = fz_malloc(sizeof(fz_textnode)); - if (!text) - return fz_outofmem; - - fz_initnode((fz_node*)text, FZ_NTEXT); - - text->font = fz_keepfont(font); - text->trm = fz_identity(); - text->len = 0; - text->cap = 0; - text->els = nil; - - *textp = text; - return nil; -} - -fz_error * -fz_clonetextnode(fz_textnode **textp, fz_textnode *oldtext) -{ - fz_textnode *text; - - text = *textp = fz_malloc(sizeof(fz_textnode)); - if (!text) - return fz_outofmem; - - fz_initnode((fz_node*)text, FZ_NTEXT); - - text->font = fz_keepfont(oldtext->font); - text->trm = oldtext->trm; - text->len = oldtext->len; - text->cap = oldtext->len; - text->els = nil; - - text->els = fz_malloc(sizeof(fz_textel) * text->len); - if (!text->els) - { - fz_dropfont(text->font); - fz_free(text); - return fz_outofmem; - } - - memcpy(text->els, oldtext->els, sizeof(fz_textel) * text->len); - - *textp = text; - return nil; -} - -void -fz_droptextnode(fz_textnode *text) -{ - fz_dropfont(text->font); - fz_free(text->els); -} - -fz_rect -fz_boundtextnode(fz_textnode *text, fz_matrix ctm) -{ - fz_matrix trm; - fz_rect bbox; - fz_rect fbox; - int i; - - if (text->len == 0) - return fz_emptyrect; - - /* find bbox of glyph origins in ctm space */ - - bbox.min.x = bbox.max.x = text->els[0].x; - bbox.min.y = bbox.max.y = text->els[0].y; - - for (i = 1; i < text->len; i++) - { - bbox.min.x = MIN(bbox.min.x, text->els[i].x); - bbox.min.y = MIN(bbox.min.y, text->els[i].y); - bbox.max.x = MAX(bbox.max.x, text->els[i].x); - bbox.max.y = MAX(bbox.max.y, text->els[i].y); - } - - bbox = fz_transformaabb(ctm, bbox); - - /* find bbox of font in trm * ctm space */ - - trm = fz_concat(text->trm, ctm); - trm.e = 0; - trm.f = 0; - - fbox.min.x = text->font->bbox.min.x * 0.001; - fbox.min.y = text->font->bbox.min.y * 0.001; - fbox.max.x = text->font->bbox.max.x * 0.001; - fbox.max.y = text->font->bbox.max.y * 0.001; - - fbox = fz_transformaabb(trm, fbox); - - /* expand glyph origin bbox by font bbox */ - - bbox.min.x += fbox.min.x; - bbox.min.y += fbox.min.y; - bbox.max.x += fbox.max.x; - bbox.max.y += fbox.max.y; - - return bbox; -} - -static fz_error * -growtext(fz_textnode *text, int n) -{ - int newcap; - fz_textel *newels; - - while (text->len + n > text->cap) - { - newcap = text->cap + 36; - newels = fz_realloc(text->els, sizeof (fz_textel) * newcap); - if (!newels) - return fz_outofmem; - text->cap = newcap; - text->els = newels; - } - - return nil; -} - -fz_error * -fz_addtext(fz_textnode *text, int cid, float x, float y) -{ - if (growtext(text, 1) != nil) - return fz_outofmem; - text->els[text->len].cid = cid; - text->els[text->len].x = x; - text->els[text->len].y = y; - text->len++; - return nil; -} - diff --git a/tree/tree.c b/tree/tree.c deleted file mode 100644 index f6874711..00000000 --- a/tree/tree.c +++ /dev/null @@ -1,107 +0,0 @@ -#include - -fz_error * -fz_newtree(fz_tree **treep) -{ - fz_tree *tree; - - tree = *treep = fz_malloc(sizeof (fz_tree)); - if (!tree) - return fz_outofmem; - - tree->refs = 1; - tree->root = nil; - tree->head = nil; - - return nil; -} - -fz_tree * -fz_keeptree(fz_tree *tree) -{ - tree->refs ++; - return tree; -} - -void -fz_droptree(fz_tree *tree) -{ - if (--tree->refs == 0) - { - if (tree->root) - fz_dropnode(tree->root); - fz_free(tree); - } -} - -fz_rect -fz_boundtree(fz_tree *tree, fz_matrix ctm) -{ - if (tree->root) - return fz_boundnode(tree->root, ctm); - return fz_emptyrect; -} - -void -fz_insertnodefirst(fz_node *parent, fz_node *child) -{ - child->parent = parent; - child->next = parent->first; - parent->first = child; - if (!parent->last) - parent->last = child; -} - -void -fz_insertnodelast(fz_node *parent, fz_node *child) -{ - child->parent = parent; - if (!parent->first) - parent->first = child; - else - parent->last->next = child; - parent->last = child; -} - -void -fz_insertnodeafter(fz_node *prev, fz_node *child) -{ - fz_node *parent = prev->parent; - child->parent = parent; - if (parent->last == prev) - parent->last = child; - child->next = prev->next; - prev->next = child; -} - -void -fz_removenode(fz_node *child) -{ - fz_node *parent = child->parent; - fz_node *prev; - fz_node *node; - - if (parent->first == child) - { - parent->first = child->next; - if (parent->last == child) - parent->last = nil; - return; - } - - prev = parent->first; - node = prev->next; - - while (node) - { - if (node == child) - { - prev->next = child->next; - } - prev = node; - node = node->next; - } - - parent->last = prev; -} - diff --git a/util/cleanname.c b/util/cleanname.c deleted file mode 100644 index e8a8ed86..00000000 --- a/util/cleanname.c +++ /dev/null @@ -1,63 +0,0 @@ -/* - * In place, rewrite name to compress multiple /, eliminate ., and process .. - */ - -#define SEP(x) ((x)=='/' || (x) == 0) - -char * -cleanname(char *name) -{ - char *p, *q, *dotdot; - int rooted; - - rooted = name[0] == '/'; - - /* - * invariants: - * p points at beginning of path element we're considering. - * q points just past the last path element we wrote (no slash). - * dotdot points just past the point where .. cannot backtrack - * any further (no slash). - */ - - p = q = dotdot = name + rooted; - - while (*p) - { - if (p[0] == '/') /* null element */ - p++; - - else if (p[0] == '.' && SEP(p[1])) - p += 1; /* don't count the separator in case it is nul */ - - else if (p[0] == '.' && p[1] == '.' && SEP(p[2])) - { - p += 2; - if (q > dotdot) { /* can backtrack */ - while (--q > dotdot && *q != '/') - ; - } else if (!rooted) { /* /.. is / but ./../ is .. */ - if (q != name) - *q++ = '/'; - *q++ = '.'; - *q++ = '.'; - dotdot = q; - } - } - - else { /* real path element */ - if (q != name + rooted) - *q++ = '/'; - while ((*q = *p) != '/' && *q != 0) - p++, q++; - } - } - - if (q == name) /* empty string is really ``.'' */ - *q++ = '.'; - - *q = '\0'; - - return name; -} - diff --git a/util/getopt.c b/util/getopt.c deleted file mode 100644 index c870e206..00000000 --- a/util/getopt.c +++ /dev/null @@ -1,116 +0,0 @@ -/* - * Copyright (c) 1987 Regents of the University of California. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the University of - * California, Berkeley and its contributors. - * 4. Neither the name of the University nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE - * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS - * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY - * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF - * SUCH DAMAGE. - */ - -#if defined(LIBC_SCCS) && !defined(lint) -static char sccsid[] = "@(#)getopt.c 4.13 (Berkeley) 2/23/91"; -#endif /* LIBC_SCCS and not lint */ - -#include -#include -#include - -/* - * get option letter from argument vector - */ -int opterr = 1, /* if error message should be printed */ - optind = 1, /* index into parent argv vector */ - optopt; /* character checked for validity */ -char *optarg; /* argument associated with option */ - -#define BADCH (int)'?' -#define EMSG "" - -int getopt(int nargc, char * const * nargv, const char *ostr) -{ - static char *place = EMSG; /* option letter processing */ - register char *oli; /* option letter list index */ - char *p; - - if (!*place) { /* update scanning pointer */ - if (optind >= nargc || *(place = nargv[optind]) != '-') { - place = EMSG; - return(EOF); - } - if (place[1] && *++place == '-') { /* found "--" */ - ++optind; - place = EMSG; - return(EOF); - } - } /* option letter okay? */ - if ((optopt = (int)*place++) == (int)':' || - !(oli = strchr(ostr, optopt))) { - /* - * if the user didn't specify '-' as an option, - * assume it means EOF. - */ - if (optopt == (int)'-') - return(EOF); - if (!*place) - ++optind; - if (opterr) { - if (!(p = strrchr(*nargv, '/'))) - p = *nargv; - else - ++p; - (void)fprintf(stderr, "%s: illegal option -- %c\n", - p, optopt); - } - return(BADCH); - } - if (*++oli != ':') { /* don't need argument */ - optarg = NULL; - if (!*place) - ++optind; - } - else { /* need an argument */ - if (*place) /* no white space */ - optarg = place; - else if (nargc <= ++optind) { /* no arg */ - place = EMSG; - if (!(p = strrchr(*nargv, '/'))) - p = *nargv; - else - ++p; - if (opterr) - (void)fprintf(stderr, - "%s: option requires an argument -- %c\n", - p, optopt); - return(BADCH); - } - else /* white space */ - optarg = nargv[optind]; - place = EMSG; - ++optind; - } - return(optopt); /* dump back option letter */ -} diff --git a/util/strlcat.c b/util/strlcat.c deleted file mode 100644 index c659b73a..00000000 --- a/util/strlcat.c +++ /dev/null @@ -1,35 +0,0 @@ -/* Appends src to string dst of size siz (unlike strncat, siz is the - * full size of dst, not space left). At most siz-1 characters - * will be copied. Always NUL terminates (unless siz == 0). - * Returns strlen(src); if retval >= siz, truncation occurred. - */ - -#include - -int strlcat(char *dst, const char *src, int siz) -{ - register char *d = dst; - register const char *s = src; - register int n = siz; - int dlen; - - /* Find the end of dst and adjust bytes left but don't go past end */ - while (*d != '\0' && n-- != 0) - d++; - dlen = d - dst; - n = siz - dlen; - - if (n == 0) - return dlen + strlen(s); - while (*s != '\0') { - if (n != 1) { - *d++ = *s; - n--; - } - s++; - } - *d = '\0'; - - return dlen + (s - src); /* count does not include NUL */ -} - diff --git a/util/strlcpy.c b/util/strlcpy.c deleted file mode 100644 index 73416ae1..00000000 --- a/util/strlcpy.c +++ /dev/null @@ -1,32 +0,0 @@ -/* Copy src to string dst of size siz. At most siz-1 characters - * will be copied. Always NUL terminates (unless siz == 0). - * Returns strlen(src); if retval >= siz, truncation occurred. - */ - -#include - -int strlcpy(char *dst, const char *src, int siz) -{ - register char *d = dst; - register const char *s = src; - register int n = siz; - - /* Copy as many bytes as will fit */ - if (n != 0 && --n != 0) { - do { - if ((*d++ = *s++) == 0) - break; - } while (--n != 0); - } - - /* Not enough room in dst, add NUL and traverse rest of src */ - if (n == 0) { - if (siz != 0) - *d = '\0'; /* NUL-terminate dst */ - while (*s++) - ; - } - - return(s - src - 1); /* count does not include NUL */ -} - diff --git a/util/strsep.c b/util/strsep.c deleted file mode 100644 index e54903ce..00000000 --- a/util/strsep.c +++ /dev/null @@ -1,11 +0,0 @@ -#include - -char *strsep(char **stringp, const char *delim) -{ - char *ret = *stringp; - if (ret == NULL) return NULL; - if ((*stringp = strpbrk(*stringp, delim)) != NULL) - *((*stringp)++) = '\0'; - return ret; -} - -- cgit v1.2.3