Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
home:maciek_borzecki
foo2zjs
foo2zjs-dynamic-jbig.patch
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File foo2zjs-dynamic-jbig.patch of Package foo2zjs
diff -rupN foo2zjs.orig/jbig_ar.c foo2zjs/jbig_ar.c --- foo2zjs.orig/jbig_ar.c 2014-04-08 10:13:35.000000000 -0400 +++ foo2zjs/jbig_ar.c 1969-12-31 19:00:00.000000000 -0500 @@ -1,417 +0,0 @@ -/* - * Arithmetic encoder and decoder of the portable JBIG - * compression library - * - * Markus Kuhn -- http://www.cl.cam.ac.uk/~mgk25/jbigkit/ - * - * This module implements a portable standard C arithmetic encoder - * and decoder used by the JBIG lossless bi-level image compression - * algorithm as specified in International Standard ISO 11544:1993 - * and ITU-T Recommendation T.82. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - * - * If you want to use this program under different license conditions, - * then contact the author for an arrangement. - */ - -#include <assert.h> -#include "jbig_ar.h" - -/* - * Probability estimation tables for the arithmetic encoder/decoder - * given by ITU T.82 Table 24. - */ - -static short lsztab[113] = { - 0x5a1d, 0x2586, 0x1114, 0x080b, 0x03d8, 0x01da, 0x00e5, 0x006f, - 0x0036, 0x001a, 0x000d, 0x0006, 0x0003, 0x0001, 0x5a7f, 0x3f25, - 0x2cf2, 0x207c, 0x17b9, 0x1182, 0x0cef, 0x09a1, 0x072f, 0x055c, - 0x0406, 0x0303, 0x0240, 0x01b1, 0x0144, 0x00f5, 0x00b7, 0x008a, - 0x0068, 0x004e, 0x003b, 0x002c, 0x5ae1, 0x484c, 0x3a0d, 0x2ef1, - 0x261f, 0x1f33, 0x19a8, 0x1518, 0x1177, 0x0e74, 0x0bfb, 0x09f8, - 0x0861, 0x0706, 0x05cd, 0x04de, 0x040f, 0x0363, 0x02d4, 0x025c, - 0x01f8, 0x01a4, 0x0160, 0x0125, 0x00f6, 0x00cb, 0x00ab, 0x008f, - 0x5b12, 0x4d04, 0x412c, 0x37d8, 0x2fe8, 0x293c, 0x2379, 0x1edf, - 0x1aa9, 0x174e, 0x1424, 0x119c, 0x0f6b, 0x0d51, 0x0bb6, 0x0a40, - 0x5832, 0x4d1c, 0x438e, 0x3bdd, 0x34ee, 0x2eae, 0x299a, 0x2516, - 0x5570, 0x4ca9, 0x44d9, 0x3e22, 0x3824, 0x32b4, 0x2e17, 0x56a8, - 0x4f46, 0x47e5, 0x41cf, 0x3c3d, 0x375e, 0x5231, 0x4c0f, 0x4639, - 0x415e, 0x5627, 0x50e7, 0x4b85, 0x5597, 0x504f, 0x5a10, 0x5522, - 0x59eb -}; - -static unsigned char nmpstab[113] = { - 1, 2, 3, 4, 5, 6, 7, 8, - 9, 10, 11, 12, 13, 13, 15, 16, - 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32, - 33, 34, 35, 9, 37, 38, 39, 40, - 41, 42, 43, 44, 45, 46, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, 61, 62, 63, 32, - 65, 66, 67, 68, 69, 70, 71, 72, - 73, 74, 75, 76, 77, 78, 79, 48, - 81, 82, 83, 84, 85, 86, 87, 71, - 89, 90, 91, 92, 93, 94, 86, 96, - 97, 98, 99, 100, 93, 102, 103, 104, - 99, 106, 107, 103, 109, 107, 111, 109, - 111 -}; - -/* - * least significant 7 bits (mask 0x7f) of nlpstab[] contain NLPS value, - * most significant bit (mask 0x80) contains SWTCH bit - */ -static unsigned char nlpstab[113] = { - 129, 14, 16, 18, 20, 23, 25, 28, - 30, 33, 35, 9, 10, 12, 143, 36, - 38, 39, 40, 42, 43, 45, 46, 48, - 49, 51, 52, 54, 56, 57, 59, 60, - 62, 63, 32, 33, 165, 64, 65, 67, - 68, 69, 70, 72, 73, 74, 75, 77, - 78, 79, 48, 50, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 61, 61, - 193, 80, 81, 82, 83, 84, 86, 87, - 87, 72, 72, 74, 74, 75, 77, 77, - 208, 88, 89, 90, 91, 92, 93, 86, - 216, 95, 96, 97, 99, 99, 93, 223, - 101, 102, 103, 104, 99, 105, 106, 107, - 103, 233, 108, 109, 110, 111, 238, 112, - 240 -}; - -/* - * The next functions implement the arithmedic encoder and decoder - * required for JBIG. The same algorithm is also used in the arithmetic - * variant of JPEG. - */ - -/* marker codes */ -#define MARKER_STUFF 0x00 -#define MARKER_ESC 0xff - -void arith_encode_init(struct jbg_arenc_state *s, int reuse_st) -{ - int i; - - if (!reuse_st) - for (i = 0; i < 4096; s->st[i++] = 0) ; - s->c = 0; - s->a = 0x10000L; - s->sc = 0; - s->ct = 11; - s->buffer = -1; /* empty */ - - return; -} - - -void arith_encode_flush(struct jbg_arenc_state *s) -{ - unsigned long temp; - - /* find the s->c in the coding interval with the largest - * number of trailing zero bits */ - if ((temp = (s->a - 1 + s->c) & 0xffff0000L) < s->c) - s->c = temp + 0x8000; - else - s->c = temp; - /* send remaining bytes to output */ - s->c <<= s->ct; - if (s->c & 0xf8000000L) { - /* one final overflow has to be handled */ - if (s->buffer >= 0) { - s->byte_out(s->buffer + 1, s->file); - if (s->buffer + 1 == MARKER_ESC) - s->byte_out(MARKER_STUFF, s->file); - } - /* output 0x00 bytes only when more non-0x00 will follow */ - if (s->c & 0x7fff800L) - for (; s->sc; --s->sc) - s->byte_out(0x00, s->file); - } else { - if (s->buffer >= 0) - s->byte_out(s->buffer, s->file); - /* T.82 figure 30 says buffer+1 for the above line! Typo? */ - for (; s->sc; --s->sc) { - s->byte_out(0xff, s->file); - s->byte_out(MARKER_STUFF, s->file); - } - } - /* output final bytes only if they are not 0x00 */ - if (s->c & 0x7fff800L) { - s->byte_out((s->c >> 19) & 0xff, s->file); - if (((s->c >> 19) & 0xff) == MARKER_ESC) - s->byte_out(MARKER_STUFF, s->file); - if (s->c & 0x7f800L) { - s->byte_out((s->c >> 11) & 0xff, s->file); - if (((s->c >> 11) & 0xff) == MARKER_ESC) - s->byte_out(MARKER_STUFF, s->file); - } - } - - return; -} - - -void arith_encode(struct jbg_arenc_state *s, int cx, int pix) -{ - register unsigned lsz, ss; - register unsigned char *st; - long temp; - - assert(cx >= 0 && cx < 4096); - st = s->st + cx; - ss = *st & 0x7f; - assert(ss < 113); - lsz = lsztab[ss]; - -#if 0 - fprintf(stderr, "pix = %d, cx = %d, mps = %d, st = %3d, lsz = 0x%04x, " - "a = 0x%05lx, c = 0x%08lx, ct = %2d, buf = 0x%02x\n", - pix, cx, !!(s->st[cx] & 0x80), ss, lsz, s->a, s->c, s->ct, - s->buffer); -#endif - - if (((pix << 7) ^ s->st[cx]) & 0x80) { - /* encode the less probable symbol */ - if ((s->a -= lsz) >= lsz) { - /* If the interval size (lsz) for the less probable symbol (LPS) - * is larger than the interval size for the MPS, then exchange - * the two symbols for coding efficiency, otherwise code the LPS - * as usual: */ - s->c += s->a; - s->a = lsz; - } - /* Check whether MPS/LPS exchange is necessary - * and chose next probability estimator status */ - *st &= 0x80; - *st ^= nlpstab[ss]; - } else { - /* encode the more probable symbol */ - if ((s->a -= lsz) & 0xffff8000L) - return; /* A >= 0x8000 -> ready, no renormalization required */ - if (s->a < lsz) { - /* If the interval size (lsz) for the less probable symbol (LPS) - * is larger than the interval size for the MPS, then exchange - * the two symbols for coding efficiency: */ - s->c += s->a; - s->a = lsz; - } - /* chose next probability estimator status */ - *st &= 0x80; - *st |= nmpstab[ss]; - } - - /* renormalization of coding interval */ - do { - s->a <<= 1; - s->c <<= 1; - --s->ct; - if (s->ct == 0) { - /* another byte is ready for output */ - temp = s->c >> 19; - if (temp & 0xffffff00L) { - /* handle overflow over all buffered 0xff bytes */ - if (s->buffer >= 0) { - ++s->buffer; - s->byte_out(s->buffer, s->file); - if (s->buffer == MARKER_ESC) - s->byte_out(MARKER_STUFF, s->file); - } - for (; s->sc; --s->sc) - s->byte_out(0x00, s->file); - s->buffer = temp & 0xff; /* new output byte, might overflow later */ - assert(s->buffer != 0xff); - /* can s->buffer really never become 0xff here? */ - } else if (temp == 0xff) { - /* buffer 0xff byte (which might overflow later) */ - ++s->sc; - } else { - /* output all buffered 0xff bytes, they will not overflow any more */ - if (s->buffer >= 0) - s->byte_out(s->buffer, s->file); - for (; s->sc; --s->sc) { - s->byte_out(0xff, s->file); - s->byte_out(MARKER_STUFF, s->file); - } - s->buffer = temp; /* buffer new output byte (can still overflow) */ - } - s->c &= 0x7ffffL; - s->ct = 8; - } - } while (s->a < 0x8000); - - return; -} - - -void arith_decode_init(struct jbg_ardec_state *s, int reuse_st) -{ - int i; - - if (!reuse_st) - for (i = 0; i < 4096; s->st[i++] = 0) ; - s->c = 0; - s->a = 1; - s->ct = 0; - s->startup = 1; - s->nopadding = 0; - return; -} - -/* - * Decode and return one symbol from the provided PSCD byte stream - * that starts in s->pscd_ptr and ends in the byte before s->pscd_end. - * The context cx is a 12-bit integer in the range 0..4095. This - * function will advance s->pscd_ptr each time it has consumed all - * information from that PSCD byte. - * - * If a symbol has been decoded successfully, the return value will be - * 0 or 1 (depending on the symbol). - * - * If the decoder was not able to decode a symbol from the provided - * PSCD, then the return value will be -1, and two cases can be - * distinguished: - * - * s->pscd_ptr == s->pscd_end: - * - * The decoder has used up all information in the provided PSCD - * bytes. Further PSCD bytes have to be provided (via new values of - * s->pscd_ptr and/or s->pscd_end) before another symbol can be - * decoded. - * - * s->pscd_ptr == s->pscd_end - 1: - * - * The decoder has used up all provided PSCD bytes except for the - * very last byte, because that has the value 0xff. The decoder can - * at this point not yet tell whether this 0xff belongs to a - * MARKER_STUFF sequence or marks the end of the PSCD. Further PSCD - * bytes have to be provided (via new values of s->pscd_ptr and/or - * s->pscd_end), including the not yet processed 0xff byte, before - * another symbol can be decoded successfully. - * - * If s->nopadding != 0, the decoder will return -2 when it reaches - * the first two bytes of the marker segment that follows (and - * terminates) the PSCD, but before decoding the first symbol that - * depends on a bit in the input data that could have been the result - * of zero padding, and might, therefore, never have been encoded. - * This gives the caller the opportunity to lookahead early enough - * beyond a terminating SDNORM/SDRST for a trailing NEWLEN (as - * required by T.85) before decoding remaining symbols. Call the - * decoder again afterwards as often as necessary (leaving s->pscd_ptr - * pointing to the start of the marker segment) to retrieve any - * required remaining symbols that might depend on padding. - * - * [Note that each PSCD can be decoded into an infinitely long - * sequence of symbols, because the encoder might have truncated away - * an arbitrarily long sequence of trailing 0x00 bytes, which the - * decoder will append automatically as needed when it reaches the end - * of the PSCD. Therefore, the decoder cannot report any end of the - * symbol sequence and other means (external to the PSCD and - * arithmetic decoding process) are needed to determine that.] - */ - -int arith_decode(struct jbg_ardec_state *s, int cx) -{ - register unsigned lsz, ss; - register unsigned char *st; - int pix; - - /* renormalization */ - while (s->a < 0x8000 || s->startup) { - while (s->ct <= 8 && s->ct >= 0) { - /* first we can move a new byte into s->c */ - if (s->pscd_ptr >= s->pscd_end) { - return -1; /* more bytes needed */ - } - if (*s->pscd_ptr == 0xff) - if (s->pscd_ptr + 1 >= s->pscd_end) { - return -1; /* final 0xff byte not processed */ - } else { - if (*(s->pscd_ptr + 1) == MARKER_STUFF) { - s->c |= 0xffL << (8 - s->ct); - s->ct += 8; - s->pscd_ptr += 2; - } else { - s->ct = -1; /* start padding with zero bytes */ - if (s->nopadding) { - s->nopadding = 0; - return -2; /* subsequent symbols might depend on zero padding */ - } - } - } - else { - s->c |= (long)*(s->pscd_ptr++) << (8 - s->ct); - s->ct += 8; - } - } - s->c <<= 1; - s->a <<= 1; - if (s->ct >= 0) s->ct--; - if (s->a == 0x10000L) - s->startup = 0; - } - - st = s->st + cx; - ss = *st & 0x7f; - assert(ss < 113); - lsz = lsztab[ss]; - -#if 0 - fprintf(stderr, "cx = %d, mps = %d, st = %3d, lsz = 0x%04x, a = 0x%05lx, " - "c = 0x%08lx, ct = %2d\n", - cx, !!(s->st[cx] & 0x80), ss, lsz, s->a, s->c, s->ct); -#endif - - if ((s->c >> 16) < (s->a -= lsz)) - if (s->a & 0xffff8000L) - return *st >> 7; - else { - /* MPS_EXCHANGE */ - if (s->a < lsz) { - pix = 1 - (*st >> 7); - /* Check whether MPS/LPS exchange is necessary - * and chose next probability estimator status */ - *st &= 0x80; - *st ^= nlpstab[ss]; - } else { - pix = *st >> 7; - *st &= 0x80; - *st |= nmpstab[ss]; - } - } - else { - /* LPS_EXCHANGE */ - if (s->a < lsz) { - s->c -= s->a << 16; - s->a = lsz; - pix = *st >> 7; - *st &= 0x80; - *st |= nmpstab[ss]; - } else { - s->c -= s->a << 16; - s->a = lsz; - pix = 1 - (*st >> 7); - /* Check whether MPS/LPS exchange is necessary - * and chose next probability estimator status */ - *st &= 0x80; - *st ^= nlpstab[ss]; - } - } - - return pix; -} diff -rupN foo2zjs.orig/jbig_ar.h foo2zjs/jbig_ar.h --- foo2zjs.orig/jbig_ar.h 2014-04-08 10:17:39.000000000 -0400 +++ foo2zjs/jbig_ar.h 1969-12-31 19:00:00.000000000 -0500 @@ -1,55 +0,0 @@ -/* - * Header file for the arithmetic encoder and decoder of - * the portable JBIG compression library - * - * Markus Kuhn -- http://www.cl.cam.ac.uk/~mgk25/jbigkit/ - * - * $Id: jbig_ar.h,v 1.1 2008/09/05 15:05:54 rick Exp $ - */ - -#ifndef JBG_AR_H -#define JBG_AR_H - -/* - * Status of arithmetic encoder - */ - -struct jbg_arenc_state { - unsigned char st[4096]; /* probability status for contexts, MSB = MPS */ - unsigned long c; /* register C: base of coding intervall, * - * layout as in Table 23 */ - unsigned long a; /* register A: normalized size of coding interval */ - long sc; /* number of buffered 0xff values that might still overflow */ - int ct; /* bit shift counter, determines when next byte will be written */ - int buffer; /* buffer for most recent output byte != 0xff */ - void (*byte_out)(int, void *); /* function that receives all PSCD bytes */ - void *file; /* parameter passed to byte_out */ -}; - -/* - * Status of arithmetic decoder - */ - -struct jbg_ardec_state { - unsigned char st[4096]; /* probability status for contexts, MSB = MPS */ - unsigned long c; /* register C: base of coding intervall, * - * layout as in Table 25 */ - unsigned long a; /* register A: normalized size of coding interval */ - unsigned char *pscd_ptr; /* pointer to next PSCD data byte */ - unsigned char *pscd_end; /* pointer to byte after PSCD */ - int ct; /* bit-shift counter, determines when next byte will be read; - * special value -1 signals that zero-padding has started */ - int startup; /* boolean flag that controls initial fill of s->c */ - int nopadding; /* boolean flag that triggers return -2 between - * reaching PSCD end and decoding the first symbol - * that might never have been encoded in the first - * place */ -}; - -void arith_encode_init(struct jbg_arenc_state *s, int reuse_st); -void arith_encode_flush(struct jbg_arenc_state *s); -void arith_encode(struct jbg_arenc_state *s, int cx, int pix); -void arith_decode_init(struct jbg_ardec_state *s, int reuse_st); -int arith_decode(struct jbg_ardec_state *s, int cx); - -#endif /* JBG_AR_H */ diff -rupN foo2zjs.orig/jbig.c foo2zjs/jbig.c --- foo2zjs.orig/jbig.c 2014-04-08 10:22:54.000000000 -0400 +++ foo2zjs/jbig.c 1969-12-31 19:00:00.000000000 -0500 @@ -1,3288 +0,0 @@ -/* - * Portable JBIG image compression library - * - * Copyright 1995-2014 -- Markus Kuhn -- http://www.cl.cam.ac.uk/~mgk25/ - * - * $Id: jbig.c,v 1.7 2014/04/08 14:22:54 rick Exp $ - * - * This module implements a portable standard C encoder and decoder - * using the JBIG1 lossless bi-level image compression algorithm - * specified in International Standard ISO 11544:1993 and - * ITU-T Recommendation T.82. See the file jbig.txt for usage - * instructions and application examples. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - * - * If you want to use this program under different license conditions, - * then contact the author for an arrangement. - */ - -#ifdef DEBUG -#include <stdio.h> -#else -#define NDEBUG -#endif - -#include <stdlib.h> -#include <string.h> -#include <assert.h> - -#include "jbig.h" - -#define MX_MAX 127 /* maximal supported mx offset for - * adaptive template in the encoder */ - -#define TPB2CX 0x195 /* contexts for TP special pixels */ -#define TPB3CX 0x0e5 -#define TPDCX 0xc3f - -/* marker codes */ -#define MARKER_STUFF 0x00 -#define MARKER_RESERVE 0x01 -#define MARKER_SDNORM 0x02 -#define MARKER_SDRST 0x03 -#define MARKER_ABORT 0x04 -#define MARKER_NEWLEN 0x05 -#define MARKER_ATMOVE 0x06 -#define MARKER_COMMENT 0x07 -#define MARKER_ESC 0xff - -/* loop array indices */ -#define STRIPE 0 -#define LAYER 1 -#define PLANE 2 - -/* special jbg_buf pointers (instead of NULL) */ -#define SDE_DONE ((struct jbg_buf *) -1) -#define SDE_TODO ((struct jbg_buf *) 0) - -/* object code version id */ - -const char jbg_version[] = - "JBIG-KIT " JBG_VERSION " -- (c) 1995-2014 Markus Kuhn -- " - "Licence: " JBG_LICENCE "\n" - "$Id: jbig.c,v 1.7 2014/04/08 14:22:54 rick Exp $ "; - -/* - * The following array specifies for each combination of the 3 - * ordering bits, which ii[] variable represents which dimension - * of s->sde. - */ -static const int iindex[8][3] = { - { 2, 1, 0 }, /* no ordering bit set */ - { -1, -1, -1}, /* SMID -> illegal combination */ - { 2, 0, 1 }, /* ILEAVE */ - { 1, 0, 2 }, /* SMID + ILEAVE */ - { 0, 2, 1 }, /* SEQ */ - { 1, 2, 0 }, /* SEQ + SMID */ - { 0, 1, 2 }, /* SEQ + ILEAVE */ - { -1, -1, -1 } /* SEQ + SMID + ILEAVE -> illegal combination */ -}; - -#define _(String) String /* to mark translatable string for GNU gettext */ - -/* - * Array with English ASCII error messages that correspond - * to return values from public functions in this library. - */ -static const char *errmsg[] = { - _("All OK"), /* JBG_EOK */ - _("Reached specified image size"), /* JBG_EOK_INTR */ - _("Unexpected end of input data stream"), /* JBG_EAGAIN */ - _("Not enough memory available"), /* JBG_ENOMEM */ - _("ABORT marker segment encountered"), /* JBG_EABORT */ - _("Unknown marker segment encountered"), /* JBG_EMARKER */ - _("Input data stream contains invalid data"), /* JBG_EINVAL */ - _("Input data stream uses unimplemented JBIG features"), /* JBG_EIMPL */ - _("Incremental BIE does not continue previous one") /* JBG_ENOCONT */ -}; - - -/* - * The following three functions are the only places in this code, were - * C library memory management functions are called. The whole JBIG - * library has been designed in order to allow multi-threaded - * execution. No static or global variables are used, so all fuctions - * are fully reentrant. However if you want to use this multi-thread - * capability and your malloc, realloc and free are not reentrant, - * then simply add the necessary semaphores or mutex primitives below. - * In contrast to C's malloc() and realloc(), but like C's calloc(), - * these functions take two parameters nmemb and size that are multiplied - * before being passed on to the corresponding C function. - * This we can catch all overflows during a size_t multiplication a - * a single place. - */ - -#ifndef SIZE_MAX -#define SIZE_MAX ((size_t) -1) /* largest value of size_t */ -#endif - -static void *checked_malloc(size_t nmemb, size_t size) -{ - void *p; - - /* Full manual exception handling is ugly here for performance - * reasons. If an adequate handling of lack of memory is required, - * then use C++ and throw a C++ exception instead of abort(). */ - - /* assert that nmemb * size <= SIZE_MAX */ - if (size > SIZE_MAX / nmemb) - abort(); - - p = malloc(nmemb * size); - - if (!p) - abort(); - -#if 0 - fprintf(stderr, "%p = malloc(%lu * %lu)\n", p, - (unsigned long) nmemb, (unsigned long) size); -#endif - - return p; -} - - -static void *checked_realloc(void *ptr, size_t nmemb, size_t size) -{ - void *p; - - /* Full manual exception handling is ugly here for performance - * reasons. If an adequate handling of lack of memory is required, - * then use C++ and throw a C++ exception here instead of abort(). */ - - /* assert that nmemb * size <= SIZE_MAX */ - if (size > SIZE_MAX / nmemb) - abort(); - - p = realloc(ptr, nmemb * size); - - if (!p) - abort(); - -#if 0 - fprintf(stderr, "%p = realloc(%p, %lu * %lu)\n", p, ptr, - (unsigned long) nmemb, (unsigned long) size); -#endif - - return p; -} - - -static void checked_free(void *ptr) -{ - free(ptr); - -#if 0 - fprintf(stderr, "free(%p)\n", ptr); -#endif - -} - - - - -/* - * Memory management for buffers which are used for temporarily - * storing SDEs by the encoder. - * - * The following functions manage a set of struct jbg_buf storage - * containers were each can keep JBG_BUFSIZE bytes. The jbg_buf - * containers can be linked to form linear double-chained lists for - * which a number of operations are provided. Blocks which are - * tempoarily not used any more are returned to a freelist which each - * encoder keeps. Only the destructor of the encoder actually returns - * the block via checked_free() to the stdlib memory management. - */ - - -/* - * Allocate a new buffer block and initialize it. Try to get it from - * the free_list, and if it is empty, call checked_malloc(). - */ -static struct jbg_buf *jbg_buf_init(struct jbg_buf **free_list) -{ - struct jbg_buf *new_block; - - /* Test whether a block from the free list is available */ - if (*free_list) { - new_block = *free_list; - *free_list = new_block->next; - } else { - /* request a new memory block */ - new_block = (struct jbg_buf *) checked_malloc(1, sizeof(struct jbg_buf)); - } - new_block->len = 0; - new_block->next = NULL; - new_block->previous = NULL; - new_block->last = new_block; - new_block->free_list = free_list; - - return new_block; -} - - -/* - * Return an entire free_list to the memory management of stdlib. - * This is only done by jbg_enc_free(). - */ -static void jbg_buf_free(struct jbg_buf **free_list) -{ - struct jbg_buf *tmp; - - while (*free_list) { - tmp = (*free_list)->next; - checked_free(*free_list); - *free_list = tmp; - } - - return; -} - - -/* - * Append a single byte to a single list that starts with the block - * *(struct jbg_buf *) head. The type of *head is void here in order to - * keep the interface of the arithmetic encoder gereric, which uses this - * function as a call-back function in order to deliver single bytes - * for a PSCD. - */ -static void jbg_buf_write(int b, void *head) -{ - struct jbg_buf *now; - - now = ((struct jbg_buf *) head)->last; - if (now->len < JBG_BUFSIZE - 1) { - now->d[now->len++] = b; - return; - } - now->next = jbg_buf_init(((struct jbg_buf *) head)->free_list); - now->next->previous = now; - now->next->d[now->next->len++] = b; - ((struct jbg_buf *) head)->last = now->next; - - return; -} - - -/* - * Remove any trailing zero bytes from the end of a linked jbg_buf list, - * however make sure that no zero byte is removed which directly - * follows a 0xff byte (i.e., keep MARKER_ESC MARKER_STUFF sequences - * intact). This function is used to remove any redundant final zero - * bytes from a PSCD. - */ -static void jbg_buf_remove_zeros(struct jbg_buf *head) -{ - struct jbg_buf *last; - - while (1) { - /* remove trailing 0x00 in last block of list until this block is empty */ - last = head->last; - while (last->len && last->d[last->len - 1] == 0) - last->len--; - /* if block became really empty, remove it in case it is not the - * only remaining block and then loop to next block */ - if (last->previous && !last->len) { - head->last->next = *head->free_list; - *head->free_list = head->last; - head->last = last->previous; - head->last->next = NULL; - } else - break; - } - - /* - * If the final non-zero byte is 0xff (MARKER_ESC), then we just have - * removed a MARKER_STUFF and we will append it again now in order - * to preserve PSCD status of byte stream. - */ - if (head->last->len && head->last->d[head->last->len - 1] == MARKER_ESC) - jbg_buf_write(MARKER_STUFF, head); - - return; -} - - -/* - * The jbg_buf list which starts with block *new_prefix is concatenated - * with the list which starts with block **start and *start will then point - * to the first block of the new list. - */ -static void jbg_buf_prefix(struct jbg_buf *new_prefix, struct jbg_buf **start) -{ - new_prefix->last->next = *start; - new_prefix->last->next->previous = new_prefix->last; - new_prefix->last = new_prefix->last->next->last; - *start = new_prefix; - - return; -} - - -/* - * Send the contents of a jbg_buf list that starts with block **head to - * the call back function data_out and return the blocks of the jbg_buf - * list to the freelist from which these jbg_buf blocks have been taken. - * After the call, *head == NULL. - */ -static void jbg_buf_output(struct jbg_buf **head, - void (*data_out)(unsigned char *start, - size_t len, void *file), - void *file) -{ - struct jbg_buf *tmp; - - while (*head) { - data_out((*head)->d, (*head)->len, file); - tmp = (*head)->next; - (*head)->next = *(*head)->free_list; - *(*head)->free_list = *head; - *head = tmp; - } - - return; -} - - -/* - * Calculate y = ceil(x/2) applied n times, which is equivalent to - * y = ceil(x/(2^n)). This function is used to - * determine the number of pixels per row or column after n resolution - * reductions. E.g. X[d-1] = jbg_ceil_half(X[d], 1) and X[0] = - * jbg_ceil_half(X[d], d) as defined in clause 6.2.3 of T.82. - */ -unsigned long jbg_ceil_half(unsigned long x, int n) -{ - unsigned long mask; - - assert(n >= 0 && n < 32); - mask = (1UL << n) - 1; /* the lowest n bits are 1 here */ - return (x >> n) + ((mask & x) != 0); -} - - -/* - * Set L0 (the number of lines in a stripe at lowest resolution) - * to a default value, such that there are about 35 stripes, as - * suggested in Annex C of ITU-T T.82, without exceeding the - * limit 128/2^D suggested in Annex A. - */ -static void jbg_set_default_l0(struct jbg_enc_state *s) -{ - s->l0 = jbg_ceil_half(s->yd, s->d) / 35; /* 35 stripes/image */ - while ((s->l0 << s->d) > 128) /* but <= 128 lines/stripe */ - --s->l0; - if (s->l0 < 2) s->l0 = 2; -} - - -/* - * Calculate the number of stripes, as defined in clause 6.2.3 of T.82. - */ -unsigned long jbg_stripes(unsigned long l0, unsigned long yd, - unsigned long d) -{ - unsigned long y0 = jbg_ceil_half(yd, d); - - return y0 / l0 + (y0 % l0 != 0); -} - - -/* - * Resolution reduction table given by ITU-T T.82 Table 17 - */ - -static char jbg_resred[4096] = { - 0,0,0,1,0,0,0,1,0,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 1,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,0,1,1,0,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1, - 0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,1,1,0,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1, - 0,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,1,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1, - 1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,1,0,0,0,0,0,1,0,1,0,0,1,1,1,0,1,1, - 0,0,0,1,0,0,0,1,0,0,1,0,0,0,1,1,0,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,1,1,1,0,1,0,1,0,0,1,1,1,0,1,1,0,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,1,0,0,1,1,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1, - 1,0,0,1,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1, - 0,0,1,1,0,0,0,1,0,0,0,1,0,0,1,1,0,1,1,1,0,1,0,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,1,0,1,1,0,1,1,1,1,1,1,0,1,1,1,0, - 0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,1,0,1,1,1,0,1,0,1,1,1,1,1,1,1,1,1, - 0,0,0,1,0,0,0,1,0,1,1,0,1,0,1,1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1,1, - 1,1,1,0,1,0,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1, - 1,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,1,1,1,1,1,1, - 0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,1,1,1,0,1,0,1,0,1,1,0,1,0,1,1,0,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,1,0,1,0,0,1,0,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,0,1,1,1,0,0,1,1,0,0,1,1,1,1,1,1,0,1,1,1,1,0,1,1, - 1,0,0,1,0,0,1,0,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,1,0,1,1,1,1,1,1,1,1,1,0, - 0,0,1,0,1,1,1,1,0,0,0,1,1,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,1,0,1,1,1,1,1,1,1,1,1,1,0, - 0,0,0,0,1,0,0,1,0,0,1,1,0,1,1,1,0,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,1,1,0,1,0,0,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,1,1,0,1,1,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,0,1,1,1,0,1,0,1,0,1,1,1,1,1,1,1,0,1,1,1,0,1,1,1, - 0,0,1,0,0,1,1,1,0,1,1,1,1,1,1,1,0,1,1,1,1,0,1,1,0,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1, - 0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,1,0,0,1,0,0,1,1, - 0,0,0,0,0,0,0,1,0,1,1,1,0,1,0,1,0,0,1,0,0,0,0,1,0,1,0,1,0,1,0,1, - 0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,1,0,1,1,1, - 0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,1,0,1,0,1,1,0,0,0,1,0,0,1,1, - 0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,1,1,1,0,0,1,1, - 0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,1,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,0,0,0,0,0,0,1, - 0,0,1,0,0,1,1,1,0,0,0,0,1,0,0,1,0,0,0,1,1,1,1,0,1,0,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,1,1,0, - 0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,1,1,0,1,1,1, - 0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,1,1,0,1,0,0,0,1,1,0,1,0,0,0,0,1,1,1,1,0,0,1,1,1,0,1,1,0,0,1,1, - 0,0,0,0,0,0,0,0,1,1,0,1,0,0,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1, - 0,0,1,1,0,0,1,1,0,0,1,1,0,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,1,1,1,0,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,1,0,0,0,1,0,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1, - 0,0,0,1,0,0,1,0,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1, - 0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,0,1,1,0,0,0,1,0,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1, - 0,0,1,1,1,1,1,1,0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1, - 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,0,1,1,0,1,1, - 0,0,0,1,0,0,0,1,0,0,1,0,0,0,1,1,0,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,1,1,1,0,1,0,1,0,0,1,0,1,0,1,1,0,1,1,1,0,1,1,1, - 0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,1,0,1,0,1,1,0,1,1,0,1,1,1,1,1,1,1, - 0,0,0,0,1,0,0,1,0,0,1,1,0,0,1,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,1,1,0,1,1,1,1,1,1,1,1,0,1,1, - 1,0,1,0,1,0,0,1,1,0,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,1,1,0,1,1,0,1,1,1, - 0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,1,0,1,1,1,0,1,0,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,1,0,1,1,0,1,1,1,1, - 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,0,1,1,1,0,1,0,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,1,0,1,0,1,0,1,1,0,1,0,1,0,0,0,1,1,1,1,1,1,1,1,1, - 1,1,1,0,1,0,0,0,1,1,0,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1, - 1,0,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,0,1,1,0,1,1, - 0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,1,0,0,1,1,0,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,1,1,1,0,1,0,1,0,0,1,0,1,0,0,1,0,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,1,0,1,1,0,1,1,0,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,1,0,1,0,0,0,1,1,1,0,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1, - 1,0,0,0,1,0,0,0,0,1,1,1,0,1,0,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,1,1,1,0,1,1,0, - 0,0,1,1,1,1,1,1,0,0,0,0,1,0,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,1,1,0,1,1,1,1,1,1,1, - 0,0,0,0,1,0,0,0,0,0,0,1,0,0,1,1,0,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1, - 0,0,1,0,1,0,1,1,0,0,1,0,1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,1,0,1,1,1,1,1,1,1,0,1,1,1,0,1,1,1, - 0,0,1,0,1,0,1,1,0,1,1,1,1,1,1,1,0,0,1,1,1,0,1,1,0,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,1, - 0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1, - 0,0,0,0,0,0,0,1,0,1,1,1,0,1,0,1,0,0,1,0,0,0,0,1,0,1,0,1,0,1,0,1, - 0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1, - 0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,1, - 0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,1, - 0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,1,1, - 1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0,1,1,0,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,0,0,0,0,0,0,0, - 0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,1, - 0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,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,1,0,0,1,1, - 0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,1, - 0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,1,0,0,0,1,0,1,1,1,1,1,1,1, - 0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,1,1, - 0,0,0,0,0,0,0,1,0,1,0,1,0,1,0,0,0,0,1,1,0,0,0,1,0,1,1,1,0,1,1,1 -}; - -/* - * Deterministic prediction tables given by ITU-T T.82 tables - * 19 to 22. The table below is organized differently, the - * index bits are permutated for higher efficiency. - */ - -static char jbg_dptable[256 + 512 + 2048 + 4096] = { - /* phase 0: offset=0 */ - 0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, - 0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2, - 0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,0,2,2,2,2,2,2,0,2,2,2,2,2,2,2, - 0,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2,0,0,2,2,2,2,2,2,0,2,0,2,2,2,2,2, - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,0,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,1, - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,0,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, - /* phase 1: offset=256 */ - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2, - 0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,0,2,2,2,2,2,0,2,0,2,2,2,2,2, - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2, - 0,2,2,2,2,1,2,1,2,2,2,2,1,1,1,1,2,0,2,0,2,2,2,2,0,2,0,2,2,2,2,2, - 0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,0,0,2,2,2,2,0,2,2,2,2,2,2,2, - 0,2,0,2,2,2,2,2,2,2,2,2,2,0,2,0,2,2,0,0,2,2,2,2,2,0,0,2,2,2,2,2, - 0,2,2,2,2,1,2,1,2,2,2,2,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1, - 1,2,1,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,1,1,2,2,2,2,2,0,2,2,2,2,2,2, - 2,2,2,2,2,0,2,0,2,2,2,2,0,0,0,0,0,2,0,2,2,2,2,2,0,2,2,2,2,2,2,2, - 0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,0,2,2,2,2,0,2,0,2,2,2,2,2, - 2,2,2,2,2,1,1,1,2,2,2,2,1,1,1,1,1,2,1,2,2,2,2,2,2,2,2,2,2,2,2,1, - 2,2,2,2,2,2,2,2,2,2,2,2,2,0,1,2,0,2,0,2,2,2,2,2,0,2,0,2,2,2,2,1, - 0,2,0,2,2,1,2,1,2,2,2,2,1,1,1,1,0,0,0,0,2,2,2,2,0,2,0,2,2,2,2,1, - 2,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,2,2,0,0,0,2,2,2,2,2, - 2,2,2,2,2,1,2,1,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,1,2,1,2,2,2,2,1, - 2,2,2,2,2,2,2,2,0,2,0,2,2,1,2,2,2,2,2,2,2,2,2,2,0,0,0,2,2,2,2,2, - /* phase 2: offset=768 */ - 2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,2,2,2,2,1,1,1,1, - 0,2,2,2,2,1,2,1,2,2,2,2,1,2,1,2,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1, - 2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,0,2,2,1,2,1,2,2,2,2,2,1,1,1, - 2,0,2,2,2,1,2,1,0,2,2,2,1,2,1,2,2,2,2,0,2,2,2,2,0,2,0,2,2,2,2,2, - 0,2,0,0,1,1,1,1,2,2,2,2,1,1,1,1,0,2,0,2,1,1,1,1,2,2,2,2,1,1,1,1, - 2,2,0,2,2,2,1,2,2,2,2,2,1,2,1,2,2,2,0,2,2,1,2,1,0,2,0,2,1,1,1,1, - 2,0,0,2,2,2,2,2,0,2,0,2,2,0,2,0,2,0,2,0,2,2,2,1,2,2,0,2,1,1,2,1, - 2,2,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,1, - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,2,2,2,2,1,1,1,1, - 0,0,0,0,2,2,2,2,0,0,0,0,2,2,2,2,0,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2, - 2,2,0,2,2,2,2,1,0,2,2,2,1,1,1,1,2,0,2,2,2,2,2,2,0,2,0,2,2,1,2,1, - 2,0,2,0,2,2,2,2,0,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,2,2, - 0,2,2,2,1,2,1,2,2,2,2,2,2,2,2,2,0,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2, - 2,2,0,2,2,2,2,2,2,2,2,2,2,2,0,2,2,0,0,2,2,1,2,1,0,2,2,2,1,1,1,1, - 2,2,2,0,2,2,2,2,2,2,0,2,2,0,2,0,2,1,2,2,2,2,2,2,1,2,1,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,0,2,0,2,2,2,1, - 0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,2,1,1,1,2,2,2,2,1,1,1,1, - 2,2,2,1,2,2,2,2,2,2,1,2,0,0,0,0,2,2,0,2,2,1,2,2,2,2,2,2,1,1,1,1, - 2,0,0,0,2,2,2,2,0,2,2,2,2,2,2,0,2,2,2,0,2,2,2,2,2,0,0,2,2,2,2,2, - 2,2,2,2,2,2,2,2,2,2,0,2,2,1,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,1, - 0,2,0,2,2,1,1,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2, - 2,0,2,0,2,1,2,1,0,2,0,2,2,2,1,2,2,0,2,0,2,2,2,2,0,2,0,2,2,2,1,2, - 2,2,2,0,2,2,2,2,2,2,0,2,2,2,2,2,2,2,1,2,2,2,2,2,2,0,1,2,2,2,2,1, - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1, - 0,2,2,2,1,2,1,2,2,2,2,2,2,2,2,2,0,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2, - 2,0,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2,0,0,2,2,1,2,1,0,2,2,2,1,1,1,1, - 2,0,2,0,2,1,2,2,0,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,0,2,2,1,2,2, - 2,0,2,2,2,2,2,2,2,0,2,2,2,2,2,2,2,0,2,0,2,2,2,2,0,0,0,0,2,1,2,1, - 2,2,2,2,2,2,2,0,2,2,2,2,2,2,2,0,2,2,2,2,2,1,2,0,0,2,2,2,1,2,2,2, - 0,0,2,0,2,2,2,2,0,2,0,2,2,0,2,0,1,1,1,2,2,2,2,2,2,2,2,2,2,1,1,1, - 2,2,2,2,2,2,2,2,2,0,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,0,2,0,2,2,2,1, - 2,2,0,0,2,2,2,2,2,2,2,0,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,1,1,1,1,2,2,2,2,1,1,1,1, - 0,2,2,2,1,2,1,2,2,2,2,2,2,2,2,2,0,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2, - 2,0,0,2,2,2,2,2,0,2,0,2,2,2,2,2,1,0,1,2,2,2,2,1,0,2,2,2,1,1,1,1, - 2,2,2,2,2,2,2,2,2,2,0,2,2,0,2,0,2,1,2,2,2,2,2,2,2,2,0,2,2,1,2,2, - 0,2,0,0,1,1,1,1,0,2,2,2,1,1,1,1,2,2,2,2,2,2,2,2,2,0,2,2,1,2,1,1, - 2,2,0,2,2,1,2,2,2,2,2,2,1,2,2,2,2,0,2,2,2,2,2,2,0,2,0,2,1,2,1,1, - 2,0,2,0,2,2,2,2,0,2,0,2,2,1,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,2,2,1, - 2,2,2,2,2,2,2,2,2,0,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1, - 0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, - 0,2,2,2,2,0,2,0,2,2,2,2,0,0,0,0,2,2,2,2,2,1,1,2,2,2,2,2,1,2,2,2, - 2,0,2,2,2,1,2,1,0,2,2,2,2,2,1,2,2,0,2,0,2,2,2,2,0,2,0,2,2,1,2,2, - 0,2,0,0,2,2,2,2,1,2,2,2,2,2,2,0,2,1,2,2,2,2,2,2,1,2,2,2,2,2,2,2, - 0,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,2,1,0,2,2, - 0,0,0,2,2,1,1,1,2,2,2,2,1,2,2,2,2,0,2,0,2,2,2,1,2,2,2,2,1,2,1,2, - 0,0,0,0,2,2,2,2,2,2,0,2,2,1,2,2,2,1,2,1,2,2,2,2,1,2,1,2,0,2,2,2, - 2,0,2,0,2,2,2,2,2,0,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1, - 0,2,2,2,1,2,1,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,1,2,2,2,2,2,0,2,2,1,2,2,0,0,0,2,2,2,2,2,1,2,2,0,2,2,2,1,2,1,2, - 2,0,2,0,2,2,2,2,0,2,0,2,2,1,2,2,0,2,0,0,2,2,2,2,2,2,2,2,2,1,2,2, - 2,2,2,2,2,2,2,2,2,0,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,0,2,0,2,2,2,1, - 1,2,0,2,2,1,2,1,2,2,2,2,1,2,2,2,2,0,2,0,2,2,2,2,2,0,2,2,1,1,1,1, - 0,2,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,0,2,2,1,2,1, - 2,2,0,0,2,2,2,2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1, - 2,2,2,0,2,2,2,2,2,2,2,0,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,1,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,0,2, - 2,0,2,0,2,2,2,2,2,1,1,2,2,2,2,2,2,2,2,2,2,2,2,1,0,2,0,2,2,2,1,2, - 2,0,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,2, - 2,0,2,0,2,2,2,2,2,0,2,0,2,2,2,2,2,0,2,0,2,2,2,2,0,0,0,0,2,1,2,1, - 2,2,2,2,2,1,2,1,0,2,0,2,2,2,2,2,2,0,2,0,2,2,2,2,0,2,0,2,2,2,2,1, - 2,0,2,0,2,2,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,0, - 2,0,2,0,2,2,2,1,2,2,2,0,2,2,2,1,2,0,2,0,2,2,2,2,0,0,0,2,2,2,2,1, - 2,0,2,0,2,2,2,2,2,2,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,2, - /* phase 3: offset=2816 */ - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,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,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1, - 0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,1,2,1,2,0,2,0,1,2,1,2,0,2,0,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,2,0,2,2,2,1,2,0,2,2,2,1,2,2,2,2,0,2,0,2,1,2,1,0,0,0,0,1,1,1,1, - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,2,0,2,2,2,1,2, - 2,2,2,1,2,2,2,0,1,1,1,1,0,0,0,0,2,2,2,2,2,2,2,2,2,0,2,0,2,1,2,1, - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,2,0,0,0,0,1,1,1,1, - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,0,2,1,2,1,0,0,0,0,1,1,1,1, - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,1,2,0,2,0,2, - 2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,0,2,0,2,1,2,1,2,0,2,0,2,1,2,1, - 2,0,0,0,2,1,1,1,0,0,0,0,1,1,1,1,2,2,2,0,2,2,2,1,2,2,2,2,2,2,2,2, - 2,0,2,2,2,1,2,2,2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,0,0,2,0,1,1,2,1, - 2,2,2,0,2,2,2,1,2,1,2,2,2,0,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,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,0,2,2,2,1, - 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,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1, - 0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, - 0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,2,0,2,0,2,1,2,1,0,0,0,0,1,1,1,1, - 2,0,0,2,2,1,1,2,2,2,2,2,2,2,2,2,2,1,2,1,2,0,2,0,2,1,1,1,2,0,0,0, - 2,1,2,1,2,0,2,0,1,2,1,2,0,2,0,2,2,2,2,0,2,2,2,1,2,0,2,0,2,1,2,1, - 2,0,2,0,2,1,2,1,0,0,0,0,1,1,1,1,2,2,2,2,2,2,2,2,2,0,2,0,2,1,2,1, - 2,2,2,2,2,2,2,2,2,0,0,0,2,1,1,1,2,2,2,2,2,2,2,2,2,0,2,0,2,1,2,1, - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2, - 0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2, - 2,0,0,0,2,1,1,1,0,0,0,0,1,1,1,1,2,0,2,0,2,1,2,1,0,0,2,0,1,1,2,1, - 2,2,1,2,2,2,0,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,0,0,0,2,1,1,1, - 2,2,2,1,2,2,2,0,2,1,1,1,2,0,0,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, - 2,2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,1,2,1,2,0,2,0,1,2,1,2,0,2,0,2, - 2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1, - 2,2,2,2,2,2,2,2,2,0,2,2,2,1,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, - 0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,0,0,0,2,1,1,1,0,0,0,0,1,1,1,1, - 2,0,2,2,2,1,2,2,0,0,2,0,1,1,2,1,2,1,2,1,2,0,2,0,2,2,2,2,2,2,2,2, - 2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,2,0,0,0,0,1,1,1,1, - 2,0,0,0,2,1,1,1,0,0,0,0,1,1,1,1,2,2,2,2,2,2,2,2,2,1,0,2,2,0,1,2, - 2,2,2,1,2,2,2,0,2,1,1,1,2,0,0,0,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1, - 2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,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,0,2,2,2,1, - 0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,0,2,2,2,2,2,2,2,2,2,2, - 2,1,2,1,2,0,2,0,1,2,1,1,0,2,0,0,0,0,2,1,1,1,2,0,0,0,0,0,1,1,1,1, - 2,2,2,2,2,2,2,2,1,2,2,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, - 2,0,2,1,2,1,2,0,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, - 2,2,2,0,2,2,2,1,2,2,0,2,2,2,1,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,1,2,2,2,0,2,2,2,2,0,2,2,2,1,2,2,2,0,0,2,2,1,1, - 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,0,2,2,2,1, - 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,0,2,2,2,1,2,2,2,2,2,2,2,2,2, - 0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,0,2,2,2,2,2,2,2,2,2, - 2,0,2,0,2,1,2,1,0,0,0,0,1,1,1,1,2,2,2,2,2,2,2,2,0,0,0,0,1,1,1,1, - 2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,0,0,0,2,1,1,1, - 2,2,2,0,2,2,2,1,0,2,2,2,1,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,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,2, - 2,0,2,2,2,1,2,2,2,0,2,0,2,1,2,1,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1, - 2,1,2,1,2,0,2,0,1,2,1,2,0,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, - 2,1,2,1,2,0,2,0,1,2,1,1,0,2,0,0,2,0,2,2,2,1,2,2,0,2,1,2,1,2,0,2, - 2,2,2,1,2,2,2,0,2,2,1,2,2,2,0,2,2,1,2,2,2,0,2,2,2,2,0,2,2,2,1,2, - 0,0,2,0,1,1,2,1,0,0,1,0,1,1,0,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, - 2,2,2,0,2,2,2,1,1,2,2,2,0,2,2,2,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1, - 2,2,2,2,2,2,2,2,2,1,2,2,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1, - 2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, - 2,2,0,0,2,2,1,1,2,2,2,0,2,2,2,1,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,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,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1, - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2, - 0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,0,2,2,2,2,2,2,2,2,2, - 2,0,0,0,2,1,1,1,0,0,0,0,1,1,1,1,2,2,2,1,2,2,2,0,2,1,2,1,2,0,2,0, - 2,1,2,2,2,0,2,2,2,2,2,2,2,2,2,2,0,2,0,0,1,2,1,1,2,0,0,0,2,1,1,1, - 2,2,2,2,2,2,2,2,2,1,1,1,2,0,0,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, - 2,2,2,0,2,2,2,1,2,2,0,2,2,2,1,2,2,1,2,1,2,0,2,0,2,0,2,2,2,1,2,2, - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,0,2,2,2,1,1,1,2,0,0,0, - 2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,0,2,0,0,1,2,1,1, - 2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,2,0,2,2,2,1,2,2,2, - 2,1,2,1,2,0,2,0,2,1,2,2,2,0,2,2,2,2,2,0,2,2,2,1,2,0,2,0,2,1,2,1, - 2,0,2,0,2,1,2,1,0,2,0,2,1,2,1,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,2, - 2,2,2,2,2,2,2,2,0,2,0,2,1,2,1,2,2,2,2,2,2,2,2,2,0,1,0,0,1,0,1,1, - 2,2,2,2,2,2,2,2,2,1,2,2,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1, - 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, - 0,2,2,2,1,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, - 0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,2,2,1,2,2,2,0,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,0,1,2,2,1,0,2,0,2,2,2,1,2,2,2, - 2,2,2,2,2,2,2,2,1,2,2,2,0,2,2,2,2,2,2,0,2,2,2,1,2,2,0,2,2,2,1,2, - 2,0,2,0,2,1,2,1,0,2,0,2,1,2,1,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,2, - 0,2,0,0,1,2,1,1,2,0,0,0,2,1,1,1,2,2,2,2,2,2,2,2,1,0,1,2,0,1,0,2, - 2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,2,2,1,2,2,2,0,2,2,1,1,2,2,0,0,2,2, - 0,2,2,2,1,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,1,2,1,2,0,2,0,2,1,2,2,2,0,2,2,2,0,2,2,2,1,2,2,0,2,2,2,1,2,2,2, - 0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,1,2,2,2,0,2,2,2, - 2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,0,2,1,2,1,2, - 0,0,0,0,1,1,1,1,2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,2, - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,1,2,0,2,0,2,2,0,2,2,2,1,2, - 2,0,2,0,2,1,2,1,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1, - 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,0,2,2,2,1,2,2,2,2,2,2,2,2,2, - 0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2, - 2,2,2,1,2,2,2,0,1,1,2,1,0,0,2,0,2,0,2,2,2,1,2,2,0,2,2,2,1,2,2,2, - 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,2,2,2,0,2,2,2,2,0,2,2,2,1,2, - 2,0,2,0,2,1,2,1,0,2,0,2,1,2,1,2,2,2,2,2,2,2,2,2,2,1,2,2,2,0,2,2, - 0,2,0,0,1,2,1,1,0,2,0,2,1,2,1,2,2,2,2,2,2,2,2,2,0,0,0,2,1,1,1,2, - 2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1, - 2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, - 2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,0,0,2,1,1,1,2,0,0,2,2,2,1,2,2,2, - 2,1,2,1,2,0,2,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,0,0,1,2,1,1, - 0,0,2,2,1,1,2,2,0,2,1,2,1,2,0,2,2,1,2,1,2,0,2,0,1,2,1,2,0,2,0,2, - 2,2,2,2,2,2,2,2,1,2,1,2,0,2,0,2,2,2,2,2,2,2,2,2,2,0,2,0,2,1,2,1, - 2,2,0,0,2,2,1,1,2,2,0,0,2,2,1,1,2,2,2,2,2,2,2,2,2,2,0,0,2,2,1,1, - 2,2,2,2,2,2,2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,0,2,0,0,1,2,1,1, - 2,2,2,0,2,2,2,1,2,2,2,0,2,2,2,1,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,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,1,1,1,2,0,0,0,2, - 2,2,2,2,2,2,2,2,1,1,1,2,0,0,0,2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,2,2, - 2,0,2,0,2,1,2,1,2,2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,0,0,0,2,1,1,1, - 2,0,2,2,2,1,2,2,0,2,2,2,1,2,2,2,2,0,2,0,2,1,2,1,2,2,2,2,2,2,2,2, - 2,0,2,0,2,1,2,1,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,0,2,0,2,1,2,1,2,1,2,0,2,0,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, - 2,0,2,0,2,1,2,1,1,2,1,2,0,2,0,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,1,2,1,2,0,2,0,2,2,1,2,1,2,0,2,0,2,2,2,2,2,2,2,2, - 2,0,2,1,2,1,2,0,0,2,1,2,1,2,0,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1, - 2,0,2,0,2,1,2,1,2,2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,0,2,0,2,1,2,1, - 2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, - 2,0,2,2,2,1,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,1,2,1,2,0,2,0,1,1,1,2,0,0,0,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,1, - 2,0,2,0,2,1,2,1,2,2,2,0,2,2,2,1,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,0,2,2,2,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, -}; - - -/* - * Initialize the status struct for the encoder. - */ -void jbg_enc_init(struct jbg_enc_state *s, unsigned long x, unsigned long y, - int planes, unsigned char **p, - void (*data_out)(unsigned char *start, size_t len, - void *file), - void *file) -{ - unsigned long l, lx; - int i; - - assert(x > 0 && y > 0 && planes > 0 && planes < 256); - s->xd = x; - s->yd = y; - s->yd1 = y; /* This is the hight initially announced in BIH. To provoke - generation of NEWLEN for T.85 compatibility tests, - overwrite with new value s->yd1 > s->yd */ - s->planes = planes; - s->data_out = data_out; - s->file = file; - - s->d = 0; - s->dl = 0; - s->dh = s->d; - jbg_set_default_l0(s); - s->mx = 8; - s->my = 0; - s->order = JBG_ILEAVE | JBG_SMID; - s->options = JBG_TPBON | JBG_TPDON | JBG_DPON; - s->comment = NULL; - s->dppriv = jbg_dptable; - s->res_tab = jbg_resred; - - s->highres = (int *) checked_malloc(planes, sizeof(int)); - s->lhp[0] = p; - s->lhp[1] = (unsigned char **) - checked_malloc(planes, sizeof(unsigned char *)); - for (i = 0; i < planes; i++) { - s->highres[i] = 0; - s->lhp[1][i] = (unsigned char *) - checked_malloc(jbg_ceil_half(y, 1), jbg_ceil_half(x, 1+3)); - } - - s->free_list = NULL; - s->s = (struct jbg_arenc_state *) - checked_malloc(s->planes, sizeof(struct jbg_arenc_state)); - s->tx = (int *) checked_malloc(s->planes, sizeof(int)); - lx = jbg_ceil_half(x, 1); - s->tp = (char *) checked_malloc(lx, sizeof(char)); - for (l = 0; l < lx; s->tp[l++] = 2) ; - s->sde = NULL; - - return; -} - - -/* - * This function selects the number of differential layers based on - * the maximum size requested for the lowest resolution layer. If - * possible, a number of differential layers is selected, which will - * keep the size of the lowest resolution layer below or equal to the - * given width x and height y. However not more than 6 differential - * resolution layers will be used. In addition, a reasonable value for - * l0 (height of one stripe in the lowest resolution layer) is - * selected, which obeys the recommended limitations for l0 in annex A - * and C of the JBIG standard. The selected number of resolution layers - * is returned. - */ -int jbg_enc_lrlmax(struct jbg_enc_state *s, unsigned long x, - unsigned long y) -{ - for (s->d = 0; s->d < 6; s->d++) - if (jbg_ceil_half(s->xd, s->d) <= x && jbg_ceil_half(s->yd, s->d) <= y) - break; - s->dl = 0; - s->dh = s->d; - jbg_set_default_l0(s); - return s->d; -} - - -/* - * As an alternative to jbg_enc_lrlmax(), the following function allows - * to specify the number of layers directly. The stripe height and layer - * range is also adjusted automatically here. - */ -void jbg_enc_layers(struct jbg_enc_state *s, int d) -{ - if (d < 0 || d > 31) - return; - s->d = d; - s->dl = 0; - s->dh = s->d; - jbg_set_default_l0(s); - return; -} - - -/* - * Specify the highest and lowest resolution layers which will be - * written to the output file. Call this function not before - * jbg_enc_layers() or jbg_enc_lrlmax(), because these two functions - * reset the lowest and highest resolution layer to default values. - * Negative values are ignored. The total number of layers is returned. - */ -int jbg_enc_lrange(struct jbg_enc_state *s, int dl, int dh) -{ - if (dl >= 0 && dl <= s->d) s->dl = dl; - if (dh >= s->dl && dh <= s->d) s->dh = dh; - - return s->d; -} - - -/* - * The following function allows to specify the bits describing the - * options of the format as well as the maximum AT movement window and - * the number of layer 0 lines per stripes. - */ -void jbg_enc_options(struct jbg_enc_state *s, int order, int options, - unsigned long l0, int mx, int my) -{ - if (order >= 0 && order <= 0x0f) s->order = order; - if (options >= 0) s->options = options; - if (l0 > 0) s->l0 = l0; - if (mx >= 0 && my < 128) s->mx = mx; - if (my >= 0 && my < 256) s->my = my; - - return; -} - - -/* - * This function actually does all the tricky work involved in producing - * a SDE, which is stored in the appropriate s->sde[][][] element - * for later output in the correct order. - */ -static void encode_sde(struct jbg_enc_state *s, - long stripe, int layer, int plane) -{ - unsigned char *hp, *lp1, *lp2, *p0, *p1, *q1, *q2; - unsigned long hl, ll, hx, hy, lx, ly, hbpl, lbpl; - unsigned long line_h0 = 0, line_h1 = 0; - unsigned long line_h2, line_h3, line_l1, line_l2, line_l3; - struct jbg_arenc_state *se; - unsigned long y; /* current line number in highres image */ - unsigned long i; /* current line number within highres stripe */ - unsigned long j; /* current column number in highres image */ - long o; - unsigned a, p, t; - int ltp, ltp_old, cx; - unsigned long c_all, c[MX_MAX + 1], cmin, cmax, clmin, clmax; - int tmax, at_determined; - int new_tx; - long new_tx_line = -1; - int reset; - struct jbg_buf *new_jbg_buf; - -#ifdef DEBUG - static long tp_lines, tp_exceptions, tp_pixels, dp_pixels; - static long encoded_pixels; -#endif - - /* return immediately if this stripe has already been encoded */ - if (s->sde[stripe][layer][plane] != SDE_TODO) - return; - -#ifdef DEBUG - if (stripe == 0) - tp_lines = tp_exceptions = tp_pixels = dp_pixels = encoded_pixels = 0; - fprintf(stderr, "encode_sde: s/d/p = %2ld/%2d/%2d\n", - stripe, layer, plane); -#endif - - /* number of lines per stripe in highres image */ - hl = s->l0 << layer; - /* number of lines per stripe in lowres image */ - ll = hl >> 1; - /* current line number in highres image */ - y = stripe * hl; - /* number of pixels in highres image */ - hx = jbg_ceil_half(s->xd, s->d - layer); - hy = jbg_ceil_half(s->yd, s->d - layer); - /* number of pixels in lowres image */ - lx = jbg_ceil_half(hx, 1); - ly = jbg_ceil_half(hy, 1); - /* bytes per line in highres and lowres image */ - hbpl = jbg_ceil_half(hx, 3); - lbpl = jbg_ceil_half(lx, 3); - /* pointer to first image byte of highres stripe */ - hp = s->lhp[s->highres[plane]][plane] + stripe * hl * hbpl; - lp2 = s->lhp[1 - s->highres[plane]][plane] + stripe * ll * lbpl; - lp1 = lp2 + lbpl; - - /* check whether we can refer to any state of a previous stripe */ - reset = (stripe == 0) || (s->options & JBG_SDRST); - - /* initialize arithmetic encoder */ - se = s->s + plane; - arith_encode_init(se, !reset); - s->sde[stripe][layer][plane] = jbg_buf_init(&s->free_list); - se->byte_out = jbg_buf_write; - se->file = s->sde[stripe][layer][plane]; - - /* initialize adaptive template movement algorithm */ - c_all = 0; - for (t = 0; t <= s->mx; t++) - c[t] = 0; - if (stripe == 0) /* the SDRST case is handled at the end */ - s->tx[plane] = 0; - new_tx = -1; - at_determined = 0; /* we haven't yet decided the template move */ - if (s->mx == 0) - at_determined = 1; - - /* initialize typical prediction */ - ltp = 0; - if (reset) - ltp_old = 0; - else { - ltp_old = 1; - p1 = hp - hbpl; - if (y > 1) { - q1 = p1 - hbpl; - while (p1 < hp && (ltp_old = (*p1++ == *q1++)) != 0) ; - } else - while (p1 < hp && (ltp_old = (*p1++ == 0)) != 0) ; - } - - if (layer == 0) { - - /* - * Encode lowest resolution layer - */ - - for (i = 0; i < hl && y < hy; i++, y++) { - - /* check whether it is worth to perform an ATMOVE */ - if (!at_determined && c_all > 2048) { - cmin = clmin = 0xffffffffL; - cmax = clmax = 0; - tmax = 0; - for (t = (s->options & JBG_LRLTWO) ? 5 : 3; t <= s->mx; t++) { - if (c[t] > cmax) cmax = c[t]; - if (c[t] < cmin) cmin = c[t]; - if (c[t] > c[tmax]) tmax = t; - } - clmin = (c[0] < cmin) ? c[0] : cmin; - clmax = (c[0] > cmax) ? c[0] : cmax; - if (c_all - cmax < (c_all >> 3) && - cmax - c[s->tx[plane]] > c_all - cmax && - cmax - c[s->tx[plane]] > (c_all >> 4) && - /* ^ T.82 said < here, fixed in Cor.1/25 */ - cmax - (c_all - c[s->tx[plane]]) > c_all - cmax && - cmax - (c_all - c[s->tx[plane]]) > (c_all >> 4) && - cmax - cmin > (c_all >> 2) && - (s->tx[plane] || clmax - clmin > (c_all >> 3))) { - /* we have decided to perform an ATMOVE */ - new_tx = tmax; - if (!(s->options & JBG_DELAY_AT)) { - new_tx_line = i; - s->tx[plane] = new_tx; - } -#ifdef DEBUG - fprintf(stderr, "ATMOVE: line=%ld, tx=%d, c_all=%ld\n", - i, new_tx, c_all); -#endif - } - at_determined = 1; - } - assert(s->tx[plane] >= 0); /* i.e., tx can safely be cast to unsigned */ - - /* typical prediction */ - if (s->options & JBG_TPBON) { - ltp = 1; - p1 = hp; - if (i > 0 || !reset) { - q1 = hp - hbpl; - while (q1 < hp && (ltp = (*p1++ == *q1++)) != 0) ; - } else - while (p1 < hp + hbpl && (ltp = (*p1++ == 0)) != 0) ; - arith_encode(se, (s->options & JBG_LRLTWO) ? TPB2CX : TPB3CX, - ltp == ltp_old); -#ifdef DEBUG - tp_lines += ltp; -#endif - ltp_old = ltp; - if (ltp) { - /* skip next line */ - hp += hbpl; - continue; - } - } - - /* - * Layout of the variables line_h1, line_h2, line_h3, which contain - * as bits the neighbour pixels of the currently coded pixel X: - * - * 76543210765432107654321076543210 line_h3 - * 76543210765432107654321076543210 line_h2 - * 76543210765432107654321X76543210 line_h1 - */ - - line_h1 = line_h2 = line_h3 = 0; - if (i > 0 || !reset) line_h2 = (long)*(hp - hbpl) << 8; - if (i > 1 || !reset) line_h3 = (long)*(hp - hbpl - hbpl) << 8; - - /* encode line */ - for (j = 0; j < hx; hp++) { - line_h1 |= *hp; - if (j < hbpl * 8 - 8 && (i > 0 || !reset)) { - line_h2 |= *(hp - hbpl + 1); - if (i > 1 || !reset) - line_h3 |= *(hp - hbpl - hbpl + 1); - } - if (s->options & JBG_LRLTWO) { - /* two line template */ - do { - line_h1 <<= 1; line_h2 <<= 1; line_h3 <<= 1; - if (s->tx[plane]) { - if ((unsigned) s->tx[plane] > j) - a = 0; - else { - o = (j - s->tx[plane]) - (j & ~7L); - a = (hp[o >> 3] >> (7 - (o & 7))) & 1; - a <<= 4; - } - assert(s->tx[plane] > 23 || - a == ((line_h1 >> (4 + s->tx[plane])) & 0x010)); - arith_encode(se, (((line_h2 >> 10) & 0x3e0) | a | - ((line_h1 >> 9) & 0x00f)), - (line_h1 >> 8) & 1); - } - else - arith_encode(se, (((line_h2 >> 10) & 0x3f0) | - ((line_h1 >> 9) & 0x00f)), - (line_h1 >> 8) & 1); -#ifdef DEBUG - encoded_pixels++; -#endif - /* statistics for adaptive template changes */ - if (!at_determined && j >= s->mx && j < hx-2) { - p = (line_h1 & 0x100) != 0; /* current pixel value */ - c[0] += ((line_h2 & 0x4000) != 0) == p; /* default position */ - assert(!(((line_h2 >> 6) ^ line_h1) & 0x100) == - (((line_h2 & 0x4000) != 0) == p)); - for (t = 5; t <= s->mx && t <= j; t++) { - o = (j - t) - (j & ~7L); - a = (hp[o >> 3] >> (7 - (o & 7))) & 1; - assert(t > 23 || - (a == p) == !(((line_h1 >> t) ^ line_h1) & 0x100)); - c[t] += a == p; - } - for (; t <= s->mx; t++) { - c[t] += 0 == p; - } - ++c_all; - } - } while (++j & 7 && j < hx); - } else { - /* three line template */ - do { - line_h1 <<= 1; line_h2 <<= 1; line_h3 <<= 1; - if (s->tx[plane]) { - if ((unsigned) s->tx[plane] > j) - a = 0; - else { - o = (j - s->tx[plane]) - (j & ~7L); - a = (hp[o >> 3] >> (7 - (o & 7))) & 1; - a <<= 2; - } - assert(s->tx[plane] > 23 || - a == ((line_h1 >> (6 + s->tx[plane])) & 0x004)); - arith_encode(se, (((line_h3 >> 8) & 0x380) | - ((line_h2 >> 12) & 0x078) | a | - ((line_h1 >> 9) & 0x003)), - (line_h1 >> 8) & 1); - } else - arith_encode(se, (((line_h3 >> 8) & 0x380) | - ((line_h2 >> 12) & 0x07c) | - ((line_h1 >> 9) & 0x003)), - (line_h1 >> 8) & 1); -#ifdef DEBUG - encoded_pixels++; -#endif - /* statistics for adaptive template changes */ - if (!at_determined && j >= s->mx && j < hx-2) { - p = (line_h1 & 0x100) != 0; /* current pixel value */ - c[0] += ((line_h2 & 0x4000) != 0) == p; /* default position */ - assert(!(((line_h2 >> 6) ^ line_h1) & 0x100) == - (((line_h2 & 0x4000) != 0) == p)); - for (t = 3; t <= s->mx && t <= j; t++) { - o = (j - t) - (j & ~7L); - a = (hp[o >> 3] >> (7 - (o & 7))) & 1; - assert(t > 23 || - (a == p) == !(((line_h1 >> t) ^ line_h1) & 0x100)); - c[t] += a == p; - } - for (; t <= s->mx; t++) { - c[t] += 0 == p; - } - ++c_all; - } - } while (++j & 7 && j < hx); - } /* if (s->options & JBG_LRLTWO) */ - } /* for (j = ...) */ - } /* for (i = ...) */ - - } else { - - /* - * Encode differential layer - */ - - for (i = 0; i < hl && y < hy; i++, y++) { - - /* check whether it is worth to perform an ATMOVE */ - if (!at_determined && c_all > 2048) { - cmin = clmin = 0xffffffffL; - cmax = clmax = 0; - tmax = 0; - for (t = 3; t <= s->mx; t++) { - if (c[t] > cmax) cmax = c[t]; - if (c[t] < cmin) cmin = c[t]; - if (c[t] > c[tmax]) tmax = t; - } - clmin = (c[0] < cmin) ? c[0] : cmin; - clmax = (c[0] > cmax) ? c[0] : cmax; - if (c_all - cmax < (c_all >> 3) && - cmax - c[s->tx[plane]] > c_all - cmax && - cmax - c[s->tx[plane]] > (c_all >> 4) && - /* ^ T.82 said < here, fixed in Cor.1/25 */ - cmax - (c_all - c[s->tx[plane]]) > c_all - cmax && - cmax - (c_all - c[s->tx[plane]]) > (c_all >> 4) && - cmax - cmin > (c_all >> 2) && - (s->tx[plane] || clmax - clmin > (c_all >> 3))) { - /* we have decided to perform an ATMOVE */ - new_tx = tmax; - if (!(s->options & JBG_DELAY_AT)) { - new_tx_line = i; - s->tx[plane] = new_tx; - } -#ifdef DEBUG - fprintf(stderr, "ATMOVE: line=%ld, tx=%d, c_all=%ld\n", - i, new_tx, c_all); -#endif - } - at_determined = 1; - } - - if ((i >> 1) >= ll - 1 || (y >> 1) >= ly - 1) - lp1 = lp2; - - /* typical prediction */ - if (s->options & JBG_TPDON && (i & 1) == 0) { - q1 = lp1; q2 = lp2; - p0 = p1 = hp; - if (i < hl - 1 && y < hy - 1) - p0 = hp + hbpl; - if (i > 1 || !reset) - line_l3 = (long)*(q2 - lbpl) << 8; - else - line_l3 = 0; - line_l2 = (long)*q2 << 8; - line_l1 = (long)*q1 << 8; - ltp = 1; - for (j = 0; j < lx && ltp; q1++, q2++) { - if (j < lbpl * 8 - 8) { - if (i > 1 || !reset) - line_l3 |= *(q2 - lbpl + 1); - line_l2 |= *(q2 + 1); - line_l1 |= *(q1 + 1); - } - do { - if ((j >> 2) < hbpl) { - line_h1 = *(p1++); - line_h0 = *(p0++); - } - do { - line_l3 <<= 1; - line_l2 <<= 1; - line_l1 <<= 1; - line_h1 <<= 2; - line_h0 <<= 2; - cx = (((line_l3 >> 15) & 0x007) | - ((line_l2 >> 12) & 0x038) | - ((line_l1 >> 9) & 0x1c0)); - if (cx == 0x000) - if ((line_h1 & 0x300) == 0 && (line_h0 & 0x300) == 0) - s->tp[j] = 0; - else { - ltp = 0; -#ifdef DEBUG - tp_exceptions++; -#endif - } - else if (cx == 0x1ff) - if ((line_h1 & 0x300) == 0x300 && (line_h0 & 0x300) == 0x300) - s->tp[j] = 1; - else { - ltp = 0; -#ifdef DEBUG - tp_exceptions++; -#endif - } - else - s->tp[j] = 2; - } while (++j & 3 && j < lx); - } while (j & 7 && j < lx); - } /* for (j = ...) */ - arith_encode(se, TPDCX, !ltp); -#ifdef DEBUG - tp_lines += ltp; -#endif - } - - - /* - * Layout of the variables line_h1, line_h2, line_h3, which contain - * as bits the high resolution neighbour pixels of the currently coded - * highres pixel X: - * - * 76543210 76543210 76543210 76543210 line_h3 - * 76543210 76543210 76543210 76543210 line_h2 - * 76543210 76543210 7654321X 76543210 line_h1 - * - * Layout of the variables line_l1, line_l2, line_l3, which contain - * the low resolution pixels near the currently coded pixel as bits. - * The lowres pixel in which the currently coded highres pixel is - * located is marked as Y: - * - * 76543210 76543210 76543210 76543210 line_l3 - * 76543210 7654321Y 76543210 76543210 line_l2 - * 76543210 76543210 76543210 76543210 line_l1 - */ - - - line_h1 = line_h2 = line_h3 = line_l1 = line_l2 = line_l3 = 0; - if (i > 0 || !reset) line_h2 = (long)*(hp - hbpl) << 8; - if (i > 1 || !reset) { - line_h3 = (long)*(hp - hbpl - hbpl) << 8; - line_l3 = (long)*(lp2 - lbpl) << 8; - } - line_l2 = (long)*lp2 << 8; - line_l1 = (long)*lp1 << 8; - - /* encode line */ - for (j = 0; j < hx; lp1++, lp2++) { - if ((j >> 1) < lbpl * 8 - 8) { - if (i > 1 || !reset) - line_l3 |= *(lp2 - lbpl + 1); - line_l2 |= *(lp2 + 1); - line_l1 |= *(lp1 + 1); - } - do { /* ... while (j & 15 && j < hx) */ - - assert(hp - (s->lhp[s->highres[plane]][plane] + - (stripe * hl + i) * hbpl) - == (ptrdiff_t) j >> 3); - - assert(lp2 - (s->lhp[1-s->highres[plane]][plane] + - (stripe * ll + (i>>1)) * lbpl) - == (ptrdiff_t) j >> 4); - - line_h1 |= *hp; - if (j < hbpl * 8 - 8) { - if (i > 0 || !reset) { - line_h2 |= *(hp - hbpl + 1); - if (i > 1 || !reset) - line_h3 |= *(hp - hbpl - hbpl + 1); - } - } - do { /* ... while (j & 7 && j < hx) */ - line_l1 <<= 1; line_l2 <<= 1; line_l3 <<= 1; - if (ltp && s->tp[j >> 1] < 2) { - /* pixel are typical and have not to be encoded */ - line_h1 <<= 2; line_h2 <<= 2; line_h3 <<= 2; -#ifdef DEBUG - do { - ++tp_pixels; - } while (++j & 1 && j < hx); -#else - j += 2; -#endif - } else - do { /* ... while (++j & 1 && j < hx) */ - line_h1 <<= 1; line_h2 <<= 1; line_h3 <<= 1; - - /* deterministic prediction */ - if (s->options & JBG_DPON) { - if ((y & 1) == 0) { - if ((j & 1) == 0) { - /* phase 0 */ - if (s->dppriv[((line_l3 >> 16) & 0x003) | - ((line_l2 >> 14) & 0x00c) | - ((line_h1 >> 5) & 0x010) | - ((line_h2 >> 10) & 0x0e0)] < 2) { -#ifdef DEBUG - ++dp_pixels; -#endif - continue; - } - } else { - /* phase 1 */ - if (s->dppriv[(((line_l3 >> 16) & 0x003) | - ((line_l2 >> 14) & 0x00c) | - ((line_h1 >> 5) & 0x030) | - ((line_h2 >> 10) & 0x1c0)) + 256] < 2) { -#ifdef DEBUG - ++dp_pixels; -#endif - continue; - } - } - } else { - if ((j & 1) == 0) { - /* phase 2 */ - if (s->dppriv[(((line_l3 >> 16) & 0x003) | - ((line_l2 >> 14) & 0x00c) | - ((line_h1 >> 5) & 0x010) | - ((line_h2 >> 10) & 0x0e0) | - ((line_h3 >> 7) & 0x700)) + 768] < 2) { -#ifdef DEBUG - ++dp_pixels; -#endif - continue; - } - } else { - /* phase 3 */ - if (s->dppriv[(((line_l3 >> 16) & 0x003) | - ((line_l2 >> 14) & 0x00c) | - ((line_h1 >> 5) & 0x030) | - ((line_h2 >> 10) & 0x1c0) | - ((line_h3 >> 7) & 0xe00)) + 2816] < 2) { -#ifdef DEBUG - ++dp_pixels; -#endif - continue; - } - } - } - } - - /* determine context */ - if (s->tx[plane]) { - if ((unsigned) s->tx[plane] > j) - a = 0; - else { - o = (j - s->tx[plane]) - (j & ~7L); - a = (hp[o >> 3] >> (7 - (o & 7))) & 1; - a <<= 4; - } - assert(s->tx[plane] > 23 || - a == ((line_h1 >> (4 + s->tx[plane])) & 0x010)); - cx = (((line_h1 >> 9) & 0x003) | a | - ((line_h2 >> 13) & 0x00c) | - ((line_h3 >> 11) & 0x020)); - } else - cx = (((line_h1 >> 9) & 0x003) | - ((line_h2 >> 13) & 0x01c) | - ((line_h3 >> 11) & 0x020)); - if (j & 1) - cx |= (((line_l2 >> 9) & 0x0c0) | - ((line_l1 >> 7) & 0x300)) | (1UL << 10); - else - cx |= (((line_l2 >> 10) & 0x0c0) | - ((line_l1 >> 8) & 0x300)); - cx |= (y & 1) << 11; - - arith_encode(se, cx, (line_h1 >> 8) & 1); -#ifdef DEBUG - encoded_pixels++; -#endif - - /* statistics for adaptive template changes */ - if (!at_determined && j >= s->mx) { - c[0] += !(((line_h2 >> 6) ^ line_h1) & 0x100); - for (t = 3; t <= s->mx; t++) - c[t] += !(((line_h1 >> t) ^ line_h1) & 0x100); - ++c_all; - } - - } while (++j & 1 && j < hx); - } while (j & 7 && j < hx); - hp++; - } while (j & 15 && j < hx); - } /* for (j = ...) */ - - /* low resolution pixels are used twice */ - if ((i & 1) == 0) { - lp1 -= lbpl; - lp2 -= lbpl; - } - - } /* for (i = ...) */ - } - - arith_encode_flush(se); - jbg_buf_remove_zeros(s->sde[stripe][layer][plane]); - jbg_buf_write(MARKER_ESC, s->sde[stripe][layer][plane]); - jbg_buf_write((s->options & JBG_SDRST) ? MARKER_SDRST : MARKER_SDNORM, - s->sde[stripe][layer][plane]); - if (s->options & JBG_SDRST) - s->tx[plane] = 0; - - /* add ATMOVE */ - if (new_tx != -1) { - if (s->options & JBG_DELAY_AT) { - /* ATMOVE will become active at the first line of the next stripe */ - s->tx[plane] = new_tx; - jbg_buf_write(MARKER_ESC, s->sde[stripe][layer][plane]); - jbg_buf_write(MARKER_ATMOVE, s->sde[stripe][layer][plane]); - jbg_buf_write(0, s->sde[stripe][layer][plane]); - jbg_buf_write(0, s->sde[stripe][layer][plane]); - jbg_buf_write(0, s->sde[stripe][layer][plane]); - jbg_buf_write(0, s->sde[stripe][layer][plane]); - jbg_buf_write(s->tx[plane], s->sde[stripe][layer][plane]); - jbg_buf_write(0, s->sde[stripe][layer][plane]); - } else { - /* ATMOVE has already become active during this stripe - * => we have to prefix the SDE data with an ATMOVE marker */ - new_jbg_buf = jbg_buf_init(&s->free_list); - jbg_buf_write(MARKER_ESC, new_jbg_buf); - jbg_buf_write(MARKER_ATMOVE, new_jbg_buf); - jbg_buf_write((new_tx_line >> 24) & 0xff, new_jbg_buf); - jbg_buf_write((new_tx_line >> 16) & 0xff, new_jbg_buf); - jbg_buf_write((new_tx_line >> 8) & 0xff, new_jbg_buf); - jbg_buf_write(new_tx_line & 0xff, new_jbg_buf); - jbg_buf_write(new_tx, new_jbg_buf); - jbg_buf_write(0, new_jbg_buf); - jbg_buf_prefix(new_jbg_buf, &s->sde[stripe][layer][plane]); - } - } - -#if 0 - if (stripe == s->stripes - 1) - fprintf(stderr, "tp_lines = %ld, tp_exceptions = %ld, tp_pixels = %ld, " - "dp_pixels = %ld, encoded_pixels = %ld\n", - tp_lines, tp_exceptions, tp_pixels, dp_pixels, encoded_pixels); -#endif - - return; -} - - -/* - * Create the next lower resolution version of an image - */ -static void resolution_reduction(struct jbg_enc_state *s, int plane, - int higher_layer) -{ - unsigned long hl, ll, hx, hy, lx, ly, hbpl, lbpl; - unsigned char *hp1, *hp2, *hp3, *lp; - unsigned long line_h1, line_h2, line_h3, line_l2; - unsigned long y; /* current line number in lowres image */ - unsigned long i; /* current line number within lowres stripe */ - unsigned long j; /* current column number in lowres image */ - int pix, k, l; - - /* number of lines per stripe in highres image */ - hl = s->l0 << higher_layer; - /* number of lines per stripe in lowres image */ - ll = hl >> 1; - /* number of pixels in highres image */ - hx = jbg_ceil_half(s->xd, s->d - higher_layer); - hy = jbg_ceil_half(s->yd, s->d - higher_layer); - /* number of pixels in lowres image */ - lx = jbg_ceil_half(hx, 1); - ly = jbg_ceil_half(hy, 1); - /* bytes per line in highres and lowres image */ - hbpl = jbg_ceil_half(hx, 3); - lbpl = jbg_ceil_half(lx, 3); - /* pointers to first image bytes */ - hp2 = s->lhp[s->highres[plane]][plane]; - hp1 = hp2 + hbpl; - hp3 = hp2 - hbpl; - lp = s->lhp[1 - s->highres[plane]][plane]; - -#ifdef DEBUG - fprintf(stderr, "resolution_reduction: plane = %d, higher_layer = %d\n", - plane, higher_layer); -#endif - - /* - * Layout of the variables line_h1, line_h2, line_h3, which contain - * as bits the high resolution neighbour pixels of the currently coded - * lowres pixel /\: - * \/ - * - * 76543210 76543210 76543210 76543210 line_h3 - * 76543210 76543210 765432/\ 76543210 line_h2 - * 76543210 76543210 765432\/ 76543210 line_h1 - * - * Layout of the variable line_l2, which contains the low resolution - * pixels near the currently coded pixel as bits. The lowres pixel - * which is currently coded is marked as X: - * - * 76543210 76543210 76543210 76543210 line_l2 - * X - */ - - for (y = 0; y < ly;) { - for (i = 0; i < ll && y < ly; i++, y++) { - if (2*y + 1 >= hy) - hp1 = hp2; - pix = 0; - line_h1 = line_h2 = line_h3 = line_l2 = 0; - for (j = 0; j < lbpl * 8; j += 8) { - *lp = 0; - if (i > 0 || (y > 0 && !(s->options & JBG_SDRST))) - line_l2 |= *(lp-lbpl); - for (k = 0; k < 8 && j + k < lx; k += 4) { - if (((j + k) >> 2) < hbpl) { - if (i > 0 || (y > 0 && !(s->options & JBG_SDRST))) - line_h3 |= *hp3; - ++hp3; - line_h2 |= *(hp2++); - line_h1 |= *(hp1++); - } - for (l = 0; l < 4 && j + k + l < lx; l++) { - line_h3 <<= 2; - line_h2 <<= 2; - line_h1 <<= 2; - line_l2 <<= 1; - pix = s->res_tab[((line_h1 >> 8) & 0x007) | - ((line_h2 >> 5) & 0x038) | - ((line_h3 >> 2) & 0x1c0) | - (pix << 9) | ((line_l2 << 2) & 0xc00)]; - *lp = (*lp << 1) | pix; - } - } - ++lp; - } - *(lp - 1) <<= lbpl * 8 - lx; - hp1 += hbpl; - hp2 += hbpl; - hp3 += hbpl; - } - } - -#ifdef DEBUG - { - FILE *f; - char fn[50]; - - sprintf(fn, "dbg_d=%02d.pbm", higher_layer - 1); - f = fopen(fn, "wb"); - fprintf(f, "P4\n%lu %lu\n", lx, ly); - fwrite(s->lhp[1 - s->highres[plane]][plane], 1, lbpl * ly, f); - fclose(f); - } -#endif - - return; -} - - -/* - * This function is called inside the three loops of jbg_enc_out() in - * order to write the next SDE. It has first to generate the required - * SDE and all SDEs which have to be encoded before this SDE can be - * created. The problem here is that if we want to output a lower - * resolution layer, we have to apply the resolution reduction - * algorithm first to get it. As we try to safe as much memory as - * possible, the resolution reduction will overwrite previous higher - * resolution bitmaps. Consequently, we have to encode and buffer SDEs - * which depend on higher resolution layers before we can start the - * resolution reduction. All the logic about which SDE has to be - * encoded before resolution reduction is allowed is handled - * here. This approach may be a bit more complex than alternative ways - * of doing it, but it minimizes the amount of temporary memory used. - */ -static void output_sde(struct jbg_enc_state *s, - unsigned long stripe, int layer, int plane) -{ - int lfcl; /* lowest fully coded layer */ - long i; - unsigned long u; - - assert(s->sde[stripe][layer][plane] != SDE_DONE); - - if (s->sde[stripe][layer][plane] != SDE_TODO) { -#ifdef DEBUG - fprintf(stderr, "writing SDE: s/d/p = %2lu/%2d/%2d\n", - stripe, layer, plane); -#endif - jbg_buf_output(&s->sde[stripe][layer][plane], s->data_out, s->file); - s->sde[stripe][layer][plane] = SDE_DONE; - return; - } - - /* Determine the smallest resolution layer in this plane for which - * not yet all stripes have been encoded into SDEs. This layer will - * have to be completely coded, before we can apply the next - * resolution reduction step. */ - lfcl = 0; - for (i = s->d; i >= 0; i--) - if (s->sde[s->stripes - 1][i][plane] == SDE_TODO) { - lfcl = i + 1; - break; - } - if (lfcl > s->d && s->d > 0 && stripe == 0) { - /* perform the first resolution reduction */ - resolution_reduction(s, plane, s->d); - } - /* In case HITOLO is not used, we have to encode and store the higher - * resolution layers first, although we do not need them right now. */ - while (lfcl - 1 > layer) { - for (u = 0; u < s->stripes; u++) - encode_sde(s, u, lfcl - 1, plane); - --lfcl; - s->highres[plane] ^= 1; - if (lfcl > 1) - resolution_reduction(s, plane, lfcl - 1); - } - - encode_sde(s, stripe, layer, plane); - -#ifdef DEBUG - fprintf(stderr, "writing SDE: s/d/p = %2lu/%2d/%2d\n", stripe, layer, plane); -#endif - jbg_buf_output(&s->sde[stripe][layer][plane], s->data_out, s->file); - s->sde[stripe][layer][plane] = SDE_DONE; - - if (stripe == s->stripes - 1 && layer > 0 && - s->sde[0][layer-1][plane] == SDE_TODO) { - s->highres[plane] ^= 1; - if (layer > 1) - resolution_reduction(s, plane, layer - 1); - } - - return; -} - - -/* - * Convert the table which controls the deterministic prediction - * process from the internal format into the representation required - * for the 1728 byte long DPTABLE element of a BIH. - * - * The bit order of the DPTABLE format (see also ITU-T T.82 figure 13) is - * - * high res: 4 5 6 low res: 0 1 - * 7 8 9 2 3 - * 10 11 12 - * - * were 4 table entries are packed into one byte, while we here use - * internally an unpacked 6912 byte long table indexed by the following - * bit order: - * - * high res: 7 6 5 high res: 8 7 6 low res: 1 0 - * (phase 0) 4 . . (phase 1) 5 4 . 3 2 - * . . . . . . - * - * high res: 10 9 8 high res: 11 10 9 - * (phase 2) 7 6 5 (phase 3) 8 7 6 - * 4 . . 5 4 . - */ -void jbg_int2dppriv(unsigned char *dptable, const char *internal) -{ - int i, j, k; - int trans0[ 8] = { 1, 0, 3, 2, 7, 6, 5, 4 }; - int trans1[ 9] = { 1, 0, 3, 2, 8, 7, 6, 5, 4 }; - int trans2[11] = { 1, 0, 3, 2, 10, 9, 8, 7, 6, 5, 4 }; - int trans3[12] = { 1, 0, 3, 2, 11, 10, 9, 8, 7, 6, 5, 4 }; - - for (i = 0; i < 1728; dptable[i++] = 0) ; - -#define FILL_TABLE1(offset, len, trans) \ - for (i = 0; i < len; i++) { \ - k = 0; \ - for (j = 0; i >> j; j++) \ - k |= ((i >> j) & 1) << trans[j]; \ - dptable[(i + offset) >> 2] |= \ - (internal[k + offset] & 3) << ((3 - (i&3)) << 1); \ - } - - FILL_TABLE1( 0, 256, trans0); - FILL_TABLE1( 256, 512, trans1); - FILL_TABLE1( 768, 2048, trans2); - FILL_TABLE1(2816, 4096, trans3); - - return; -} - - -/* - * Convert the table which controls the deterministic prediction - * process from the 1728 byte long DPTABLE format into the 6912 byte long - * internal format. - */ -void jbg_dppriv2int(char *internal, const unsigned char *dptable) -{ - int i, j, k; - int trans0[ 8] = { 1, 0, 3, 2, 7, 6, 5, 4 }; - int trans1[ 9] = { 1, 0, 3, 2, 8, 7, 6, 5, 4 }; - int trans2[11] = { 1, 0, 3, 2, 10, 9, 8, 7, 6, 5, 4 }; - int trans3[12] = { 1, 0, 3, 2, 11, 10, 9, 8, 7, 6, 5, 4 }; - -#define FILL_TABLE2(offset, len, trans) \ - for (i = 0; i < len; i++) { \ - k = 0; \ - for (j = 0; i >> j; j++) \ - k |= ((i >> j) & 1) << trans[j]; \ - internal[k + offset] = \ - (dptable[(i + offset) >> 2] >> ((3 - (i & 3)) << 1)) & 3; \ - } - - FILL_TABLE2( 0, 256, trans0); - FILL_TABLE2( 256, 512, trans1); - FILL_TABLE2( 768, 2048, trans2); - FILL_TABLE2(2816, 4096, trans3); - - return; -} - - -/* - * Encode one full BIE and pass the generated data to the specified - * call-back function - */ -void jbg_enc_out(struct jbg_enc_state *s) -{ - unsigned long bpl; - unsigned char buf[20]; - unsigned long xd, yd, y; - long ii[3], is[3], ie[3]; /* generic variables for the 3 nested loops */ - unsigned long stripe; - int layer, plane; - int order; - unsigned char dpbuf[1728]; - - /* some sanity checks */ - s->order &= JBG_HITOLO | JBG_SEQ | JBG_ILEAVE | JBG_SMID; - order = s->order & (JBG_SEQ | JBG_ILEAVE | JBG_SMID); - if (iindex[order][0] < 0) - s->order = order = JBG_SMID | JBG_ILEAVE; - if (s->options & JBG_DPON && s->dppriv != jbg_dptable) - s->options |= JBG_DPPRIV; - if (s->mx > MX_MAX) - s->mx = MX_MAX; - s->my = 0; - if (s->mx && s->mx < ((s->options & JBG_LRLTWO) ? 5U : 3U)) - s->mx = 0; - if (s->d > 255 || s->d < 0 || s->dh > s->d || s->dh < 0 || - s->dl < 0 || s->dl > s->dh || s->planes < 0 || s->planes > 255) - return; - /* prevent uint32 overflow: s->l0 * 2 ^ s->d < 2 ^ 32 */ - if (s->d > 31 || (s->d != 0 && s->l0 >= (1UL << (32 - s->d)))) - return; - if (s->yd1 < s->yd) - s->yd1 = s->yd; - if (s->yd1 > s->yd) - s->options |= JBG_VLENGTH; - - /* ensure correct zero padding of bitmap at the final byte of each line */ - if (s->xd & 7) { - bpl = jbg_ceil_half(s->xd, 3); /* bytes per line */ - for (plane = 0; plane < s->planes; plane++) - for (y = 0; y < s->yd; y++) - s->lhp[0][plane][y * bpl + bpl - 1] &= ~((1 << (8 - (s->xd & 7))) - 1); - } - - /* prepare BIH */ - buf[0] = s->dl; - buf[1] = s->dh; - buf[2] = s->planes; - buf[3] = 0; - xd = jbg_ceil_half(s->xd, s->d - s->dh); - yd = jbg_ceil_half(s->yd1, s->d - s->dh); - buf[4] = xd >> 24; - buf[5] = (xd >> 16) & 0xff; - buf[6] = (xd >> 8) & 0xff; - buf[7] = xd & 0xff; - buf[8] = yd >> 24; - buf[9] = (yd >> 16) & 0xff; - buf[10] = (yd >> 8) & 0xff; - buf[11] = yd & 0xff; - buf[12] = s->l0 >> 24; - buf[13] = (s->l0 >> 16) & 0xff; - buf[14] = (s->l0 >> 8) & 0xff; - buf[15] = s->l0 & 0xff; - buf[16] = s->mx; - buf[17] = s->my; - buf[18] = s->order; - buf[19] = s->options & 0x7f; - -#if 0 - /* sanitize L0 (if it was set to 0xffffffff for T.85-style NEWLEN tests) */ - if (s->l0 > (s->yd >> s->d)) - s->l0 = s->yd >> s->d; -#endif - - /* calculate number of stripes that will be required */ - s->stripes = jbg_stripes(s->l0, s->yd, s->d); - - /* allocate buffers for SDE pointers */ - if (s->sde == NULL) { - s->sde = (struct jbg_buf ****) - checked_malloc(s->stripes, sizeof(struct jbg_buf ***)); - for (stripe = 0; stripe < s->stripes; stripe++) { - s->sde[stripe] = (struct jbg_buf ***) - checked_malloc(s->d + 1, sizeof(struct jbg_buf **)); - for (layer = 0; layer < s->d + 1; layer++) { - s->sde[stripe][layer] = (struct jbg_buf **) - checked_malloc(s->planes, sizeof(struct jbg_buf *)); - for (plane = 0; plane < s->planes; plane++) - s->sde[stripe][layer][plane] = SDE_TODO; - } - } - } - - /* output BIH */ - s->data_out(buf, 20, s->file); - if ((s->options & (JBG_DPON | JBG_DPPRIV | JBG_DPLAST)) == - (JBG_DPON | JBG_DPPRIV)) { - /* write private table */ - jbg_int2dppriv(dpbuf, s->dppriv); - s->data_out(dpbuf, 1728, s->file); - } - -#if 0 - /* - * Encode everything first. This is a simple-minded alternative to - * all the tricky on-demand encoding logic in output_sde() for - * debugging purposes. - */ - for (layer = s->dh; layer >= s->dl; layer--) { - for (plane = 0; plane < s->planes; plane++) { - if (layer > 0) - resolution_reduction(s, plane, layer); - for (stripe = 0; stripe < s->stripes; stripe++) - encode_sde(s, stripe, layer, plane); - s->highres[plane] ^= 1; - } - } -#endif - - /* - * Generic loops over all SDEs. Which loop represents layer, plane and - * stripe depends on the option flags. - */ - - /* start and end value for each loop */ - is[iindex[order][STRIPE]] = 0; - ie[iindex[order][STRIPE]] = s->stripes - 1; - is[iindex[order][LAYER]] = s->dl; - ie[iindex[order][LAYER]] = s->dh; - is[iindex[order][PLANE]] = 0; - ie[iindex[order][PLANE]] = s->planes - 1; - - for (ii[0] = is[0]; ii[0] <= ie[0]; ii[0]++) - for (ii[1] = is[1]; ii[1] <= ie[1]; ii[1]++) - for (ii[2] = is[2]; ii[2] <= ie[2]; ii[2]++) { - - stripe = ii[iindex[order][STRIPE]]; - if (s->order & JBG_HITOLO) - layer = s->dh - (ii[iindex[order][LAYER]] - s->dl); - else - layer = ii[iindex[order][LAYER]]; - plane = ii[iindex[order][PLANE]]; - - /* output comment marker segment if there is any pending */ - if (s->comment) { - buf[0] = MARKER_ESC; - buf[1] = MARKER_COMMENT; - buf[2] = s->comment_len >> 24; - buf[3] = (s->comment_len >> 16) & 0xff; - buf[4] = (s->comment_len >> 8) & 0xff; - buf[5] = s->comment_len & 0xff; - s->data_out(buf, 6, s->file); - s->data_out(s->comment, s->comment_len, s->file); - s->comment = NULL; - } - - output_sde(s, stripe, layer, plane); - - /* - * When we generate a NEWLEN test case (s->yd1 > s->yd), output - * NEWLEN after last stripe if we have only a single - * resolution layer or plane (see ITU-T T.85 profile), otherwise - * output NEWLEN before last stripe. - */ - if (s->yd1 > s->yd && - (stripe == s->stripes - 1 || - (stripe == s->stripes - 2 && - (s->dl != s->dh || s->planes > 1)))) { - s->yd1 = s->yd; - yd = jbg_ceil_half(s->yd, s->d - s->dh); - buf[0] = MARKER_ESC; - buf[1] = MARKER_NEWLEN; - buf[2] = yd >> 24; - buf[3] = (yd >> 16) & 0xff; - buf[4] = (yd >> 8) & 0xff; - buf[5] = yd & 0xff; - s->data_out(buf, 6, s->file); -#ifdef DEBUG - fprintf(stderr, "NEWLEN: yd=%lu\n", yd); -#endif - if (stripe == s->stripes - 1) { - buf[1] = MARKER_SDNORM; - s->data_out(buf, 2, s->file); - } - } - - } - - return; -} - - -void jbg_enc_free(struct jbg_enc_state *s) -{ - unsigned long stripe; - int layer, plane; - -#ifdef DEBUG - fprintf(stderr, "jbg_enc_free(%p)\n", (void *) s); -#endif - - /* clear buffers for SDEs */ - if (s->sde) { - for (stripe = 0; stripe < s->stripes; stripe++) { - for (layer = 0; layer < s->d + 1; layer++) { - for (plane = 0; plane < s->planes; plane++) - if (s->sde[stripe][layer][plane] != SDE_DONE && - s->sde[stripe][layer][plane] != SDE_TODO) - jbg_buf_free(&s->sde[stripe][layer][plane]); - checked_free(s->sde[stripe][layer]); - } - checked_free(s->sde[stripe]); - } - checked_free(s->sde); - } - - /* clear free_list */ - jbg_buf_free(&s->free_list); - - /* clear memory for arithmetic encoder states */ - checked_free(s->s); - - /* clear memory for differential-layer typical prediction buffer */ - checked_free(s->tp); - - /* clear memory for adaptive template pixel offsets */ - checked_free(s->tx); - - /* clear lowres image buffers */ - if (s->lhp[1]) { - for (plane = 0; plane < s->planes; plane++) - checked_free(s->lhp[1][plane]); - checked_free(s->lhp[1]); - } - - /* clear buffer for index of highres image in lhp */ - checked_free(s->highres); - - return; -} - - -/* - * Convert the error codes used by jbg_dec_in() into an English ASCII string - */ -const char *jbg_strerror(int errnum) -{ - errnum >>= 4; - if (errnum < 0 || (unsigned) errnum >= sizeof(errmsg)/sizeof(errmsg[0])) - return "Unknown error code passed to jbg_strerror()"; - - return errmsg[errnum]; -} - - -/* - * The constructor for a decoder - */ -void jbg_dec_init(struct jbg_dec_state *s) -{ - s->order = 0; - s->d = -1; - s->bie_len = 0; - s->buf_len = 0; - s->dppriv = NULL; - s->xmax = 4294967295UL; - s->ymax = 4294967295UL; - s->dmax = 256; - s->s = NULL; - - return; -} - - -/* - * Specify a maximum image size for the decoder. If the JBIG file has - * the order bit ILEAVE, but not the bit SEQ set, then the decoder - * will abort to decode after the image has reached the maximal - * resolution layer which is still not wider than xmax or higher than - * ymax. - */ -void jbg_dec_maxsize(struct jbg_dec_state *s, unsigned long xmax, - unsigned long ymax) -{ - if (xmax > 0) s->xmax = xmax; - if (ymax > 0) s->ymax = ymax; - - return; -} - - -/* - * Decode the new len PSDC bytes to which data points and add them to - * the current stripe. Return the number of bytes which have actually - * been read (this will be less than len if a marker segment was - * part of the data or if the final byte was 0xff, in which case - * this code cannot determine whether we have a marker segment). - */ -static size_t decode_pscd(struct jbg_dec_state *s, unsigned char *data, - size_t len) -{ - unsigned long stripe; - unsigned int layer, plane; - unsigned long hl, ll, y, hx, hy, lx, ly, hbpl, lbpl; - unsigned char *hp, *lp1, *lp2, *p1, *q1; - register unsigned long line_h1, line_h2, line_h3; - register unsigned long line_l1, line_l2, line_l3; - struct jbg_ardec_state *se; - unsigned long x; - long o; - unsigned a; - int n; - int pix, cx = 0, slntp, tx; - - /* SDE loop variables */ - stripe = s->ii[iindex[s->order & 7][STRIPE]]; - layer = s->ii[iindex[s->order & 7][LAYER]]; - plane = s->ii[iindex[s->order & 7][PLANE]]; - - /* forward data to arithmetic decoder */ - se = s->s[plane] + layer - s->dl; - se->pscd_ptr = data; - se->pscd_end = data + len; - - /* number of lines per stripe in highres image */ - hl = s->l0 << layer; - /* number of lines per stripe in lowres image */ - ll = hl >> 1; - /* current line number in highres image */ - y = stripe * hl + s->i; - /* number of pixels in highres image */ - hx = jbg_ceil_half(s->xd, s->d - layer); - hy = jbg_ceil_half(s->yd, s->d - layer); - /* number of pixels in lowres image */ - lx = jbg_ceil_half(hx, 1); - ly = jbg_ceil_half(hy, 1); - /* bytes per line in highres and lowres image */ - hbpl = jbg_ceil_half(hx, 3); - lbpl = jbg_ceil_half(lx, 3); - /* pointer to highres and lowres image bytes */ - hp = s->lhp[ layer & 1][plane] + (stripe * hl + s->i) * hbpl + - (s->x >> 3); - lp2 = s->lhp[(layer-1) & 1][plane] + (stripe * ll + (s->i >> 1)) * lbpl + - (s->x >> 4); - lp1 = lp2 + lbpl; - - /* restore a few local variables */ - line_h1 = s->line_h1; - line_h2 = s->line_h2; - line_h3 = s->line_h3; - line_l1 = s->line_l1; - line_l2 = s->line_l2; - line_l3 = s->line_l3; - x = s->x; - -#ifdef DEBUG - if (s->x == 0 && s->i == 0 && s->pseudo) - fprintf(stderr, "decode_pscd(%p, %p, %ld): s/d/p = %2lu/%2u/%2u\n", - (void *) s, (void *) data, (long) len, stripe, layer, plane); -#endif - - if (s->x == 0 && s->i == 0 && - (stripe == 0 || s->reset[plane][layer - s->dl]) && s->pseudo) { - s->tx[plane][layer - s->dl] = s->ty[plane][layer - s->dl] = 0; - s->lntp[plane][layer - s->dl] = 1; - } - - if (layer == 0) { - - /* - * Decode lowest resolution layer - */ - - for (; s->i < hl && y < hy; s->i++, y++) { - - /* adaptive template changes */ - if (x == 0 && s->pseudo) - for (n = 0; n < s->at_moves; n++) - if (s->at_line[n] == s->i) { - s->tx[plane][layer - s->dl] = s->at_tx[n]; - s->ty[plane][layer - s->dl] = s->at_ty[n]; -#ifdef DEBUG - fprintf(stderr, "ATMOVE: line=%lu, tx=%d, ty=%d.\n", s->i, - s->tx[plane][layer - s->dl], s->ty[plane][layer - s->dl]); -#endif - } - tx = s->tx[plane][layer - s->dl]; - assert(tx >= 0); /* i.e., tx can safely be cast to unsigned */ - - /* typical prediction */ - if (s->options & JBG_TPBON && s->pseudo) { - slntp = arith_decode(se, (s->options & JBG_LRLTWO) ? TPB2CX : TPB3CX); - if (slntp < 0) - goto leave; - s->lntp[plane][layer - s->dl] = - !(slntp ^ s->lntp[plane][layer - s->dl]); - if (!s->lntp[plane][layer - s->dl]) { - /* this line is 'typical' (i.e. identical to the previous one) */ - p1 = hp; - if (s->i == 0 && (stripe == 0 || s->reset[plane][layer - s->dl])) - while (p1 < hp + hbpl) *p1++ = 0; - else { - q1 = hp - hbpl; - while (q1 < hp) *p1++ = *q1++; - } - hp += hbpl; - continue; - } - /* this line is 'not typical' and has to be coded completely */ - } - s->pseudo = 0; - - /* - * Layout of the variables line_h1, line_h2, line_h3, which contain - * as bits the neighbour pixels of the currently decoded pixel X: - * - * 76543210 76543210 76543210 76543210 line_h3 - * 76543210 76543210 76543210 76543210 line_h2 - * 76543210 76543210 76543210 76543210 X line_h1 - */ - - if (x == 0) { - line_h1 = line_h2 = line_h3 = 0; - if (s->i > 0 || (y > 0 && !s->reset[plane][layer - s->dl])) - line_h2 = (long)*(hp - hbpl) << 8; - if (s->i > 1 || (y > 1 && !s->reset[plane][layer - s->dl])) - line_h3 = (long)*(hp - hbpl - hbpl) << 8; - } - - /* - * Another tiny JBIG standard bug: - * - * While implementing the line_h3 handling here, I discovered - * another problem with the ITU-T T.82(1993 E) specification. - * This might be a somewhat pathological case, however. The - * standard is unclear about how a decoder should behave in the - * following situation: - * - * Assume we are in layer 0 and all stripes are single lines - * (L0=1 allowed by table 9). We are now decoding the first (and - * only) line of the third stripe. Assume, the first stripe was - * terminated by SDRST and the second stripe was terminated by - * SDNORM. While decoding the only line of the third stripe with - * the three-line template, we need access to pixels from the - * previous two stripes. We know that the previous stripe - * terminated with SDNROM, so we access the pixel from the - * second stripe. But do we have to replace the pixels from the - * first stripe by background pixels, because this stripe ended - * with SDRST? The standard, especially clause 6.2.5 does never - * mention this case, so the behaviour is undefined here. My - * current implementation remembers only the marker used to - * terminate the previous stripe. In the above example, the - * pixels of the first stripe are accessed despite the fact that - * this stripe ended with SDRST. An alternative (only slightly - * more complicated) implementation would be to remember the end - * marker (SDNORM or SDRST) of the previous two stripes in a - * plane/layer and to act accordingly when accessing the two - * previous lines. What am I supposed to do here? - * - * As the standard is unclear about the correct behaviour in the - * situation of the above example, I strongly suggest to avoid - * the following situation while encoding data with JBIG: - * - * LRLTWO = 0, L0=1 and both SDNORM and SDRST appear in layer 0. - * - * I guess that only a very few if any encoders will switch - * between SDNORM and SDRST, so let us hope that this ambiguity - * in the standard will never cause any interoperability - * problems. - * - * Markus Kuhn -- 1995-04-30 - */ - - /* decode line */ - while (x < hx) { - if ((x & 7) == 0) { - if (x < hbpl * 8 - 8 && - (s->i > 0 || (y > 0 && !s->reset[plane][layer - s->dl]))) { - line_h2 |= *(hp - hbpl + 1); - if (s->i > 1 || (y > 1 && !s->reset[plane][layer - s->dl])) - line_h3 |= *(hp - hbpl - hbpl + 1); - } - } - if (s->options & JBG_LRLTWO) { - /* two line template */ - do { - if (tx) { - if ((unsigned) tx > x) - a = 0; - else if (tx < 8) - a = ((line_h1 >> (tx - 5)) & 0x010); - else { - o = (x - tx) - (x & ~7L); - a = (hp[o >> 3] >> (7 - (o & 7))) & 1; - a <<= 4; - } - assert(tx > 31 || - a == ((line_h1 >> (tx - 5)) & 0x010)); - pix = arith_decode(se, (((line_h2 >> 9) & 0x3e0) | a | - (line_h1 & 0x00f))); - } else - pix = arith_decode(se, (((line_h2 >> 9) & 0x3f0) | - (line_h1 & 0x00f))); - if (pix < 0) - goto leave; - line_h1 = (line_h1 << 1) | pix; - line_h2 <<= 1; - } while ((++x & 7) && x < hx); - } else { - /* three line template */ - do { - if (tx) { - if ((unsigned) tx > x) - a = 0; - else if (tx < 8) - a = ((line_h1 >> (tx - 3)) & 0x004); - else { - o = (x - tx) - (x & ~7L); - a = (hp[o >> 3] >> (7 - (o & 7))) & 1; - a <<= 2; - } - assert(tx > 31 || - a == ((line_h1 >> (tx - 3)) & 0x004)); - pix = arith_decode(se, (((line_h3 >> 7) & 0x380) | - ((line_h2 >> 11) & 0x078) | a | - (line_h1 & 0x003))); - } else - pix = arith_decode(se, (((line_h3 >> 7) & 0x380) | - ((line_h2 >> 11) & 0x07c) | - (line_h1 & 0x003))); - if (pix < 0) - goto leave; - - line_h1 = (line_h1 << 1) | pix; - line_h2 <<= 1; - line_h3 <<= 1; - } while ((++x & 7) && x < hx); - } /* if (s->options & JBG_LRLTWO) */ - *hp++ = line_h1; - } /* while */ - *(hp - 1) <<= hbpl * 8 - hx; - x = 0; - s->pseudo = 1; - } /* for (i = ...) */ - - } else { - - /* - * Decode differential layer - */ - - for (; s->i < hl && y < hy; s->i++, y++) { - - /* adaptive template changes */ - if (x == 0) - for (n = 0; n < s->at_moves; n++) - if (s->at_line[n] == s->i) { - s->tx[plane][layer - s->dl] = s->at_tx[n]; - s->ty[plane][layer - s->dl] = s->at_ty[n]; -#ifdef DEBUG - fprintf(stderr, "ATMOVE: line=%lu, tx=%d, ty=%d.\n", s->i, - s->tx[plane][layer - s->dl], s->ty[plane][layer - s->dl]); -#endif - } - tx = s->tx[plane][layer - s->dl]; - - /* handle lower border of low-resolution image */ - if ((s->i >> 1) >= ll - 1 || (y >> 1) >= ly - 1) - lp1 = lp2; - - /* typical prediction */ - if ((s->options & JBG_TPDON) && s->pseudo) { - if ((s->lntp[plane][layer - s->dl] = arith_decode(se, TPDCX)) < 0) - goto leave; - } - s->pseudo = 0; - - /* - * Layout of the variables line_h1, line_h2, line_h3, which contain - * as bits the high resolution neighbour pixels of the currently - * decoded highres pixel X: - * - * 76543210 76543210 76543210 76543210 line_h3 - * 76543210 76543210 76543210 76543210 line_h2 - * 76543210 76543210 76543210 76543210 X line_h1 - * - * Layout of the variables line_l1, line_l2, line_l3, which contain - * the low resolution pixels near the currently decoded pixel as bits. - * The lowres pixel in which the currently coded highres pixel is - * located is marked as Y: - * - * 76543210 76543210 76543210 76543210 line_l3 - * 76543210 76543210 Y6543210 76543210 line_l2 - * 76543210 76543210 76543210 76543210 line_l1 - */ - - - if (x == 0) { - line_h1 = line_h2 = line_h3 = line_l1 = line_l2 = line_l3 = 0; - if (s->i > 0 || (y > 0 && !s->reset[plane][layer - s->dl])) { - line_h2 = (long)*(hp - hbpl) << 8; - if (s->i > 1 || (y > 1 && !s->reset[plane][layer - s->dl])) - line_h3 = (long)*(hp - hbpl - hbpl) << 8; - } - if (s->i > 1 || (y > 1 && !s->reset[plane][layer-s->dl])) - line_l3 = (long)*(lp2 - lbpl) << 8; - line_l2 = (long)*lp2 << 8; - line_l1 = (long)*lp1 << 8; - } - - /* decode line */ - while (x < hx) { - if ((x & 15) == 0) - if ((x >> 1) < lbpl * 8 - 8) { - line_l1 |= *(lp1 + 1); - line_l2 |= *(lp2 + 1); - if (s->i > 1 || - (y > 1 && !s->reset[plane][layer - s->dl])) - line_l3 |= *(lp2 - lbpl + 1); - } - do { - - assert(hp - (s->lhp[ layer &1][plane] + (stripe * hl + s->i) - * hbpl) == (ptrdiff_t) x >> 3); - assert(lp2 - (s->lhp[(layer-1) &1][plane] + (stripe * ll + (s->i>>1)) - * lbpl) == (ptrdiff_t) x >> 4); - - if ((x & 7) == 0) - if (x < hbpl * 8 - 8) { - if (s->i > 0 || (y > 0 && !s->reset[plane][layer - s->dl])) { - line_h2 |= *(hp + 1 - hbpl); - if (s->i > 1 || (y > 1 && !s->reset[plane][layer - s->dl])) - line_h3 |= *(hp + 1 - hbpl - hbpl); - } - } - do { - if (!s->lntp[plane][layer - s->dl]) - cx = (((line_l3 >> 14) & 0x007) | - ((line_l2 >> 11) & 0x038) | - ((line_l1 >> 8) & 0x1c0)); - if (!s->lntp[plane][layer - s->dl] && - (cx == 0x000 || cx == 0x1ff)) { - /* pixels are typical and have not to be decoded */ - do { - line_h1 = (line_h1 << 1) | (cx & 1); - } while ((++x & 1) && x < hx); - line_h2 <<= 2; line_h3 <<= 2; - } else - do { - - /* deterministic prediction */ - if (s->options & JBG_DPON) - if ((y & 1) == 0) - if ((x & 1) == 0) - /* phase 0 */ - pix = s->dppriv[((line_l3 >> 15) & 0x003) | - ((line_l2 >> 13) & 0x00c) | - ((line_h1 << 4) & 0x010) | - ((line_h2 >> 9) & 0x0e0)]; - else - /* phase 1 */ - pix = s->dppriv[(((line_l3 >> 15) & 0x003) | - ((line_l2 >> 13) & 0x00c) | - ((line_h1 << 4) & 0x030) | - ((line_h2 >> 9) & 0x1c0)) + 256]; - else - if ((x & 1) == 0) - /* phase 2 */ - pix = s->dppriv[(((line_l3 >> 15) & 0x003) | - ((line_l2 >> 13) & 0x00c) | - ((line_h1 << 4) & 0x010) | - ((line_h2 >> 9) & 0x0e0) | - ((line_h3 >> 6) & 0x700)) + 768]; - else - /* phase 3 */ - pix = s->dppriv[(((line_l3 >> 15) & 0x003) | - ((line_l2 >> 13) & 0x00c) | - ((line_h1 << 4) & 0x030) | - ((line_h2 >> 9) & 0x1c0) | - ((line_h3 >> 6) & 0xe00)) + 2816]; - else - pix = 2; - - if (pix & 2) { - if (tx) - cx = ((line_h1 & 0x003) | - (((line_h1 << 2) >> (tx - 3)) & 0x010) | - ((line_h2 >> 12) & 0x00c) | - ((line_h3 >> 10) & 0x020)); - else - cx = ((line_h1 & 0x003) | - ((line_h2 >> 12) & 0x01c) | - ((line_h3 >> 10) & 0x020)); - if (x & 1) - cx |= (((line_l2 >> 8) & 0x0c0) | - ((line_l1 >> 6) & 0x300)) | (1UL << 10); - else - cx |= (((line_l2 >> 9) & 0x0c0) | - ((line_l1 >> 7) & 0x300)); - cx |= (y & 1) << 11; - - pix = arith_decode(se, cx); - if (pix < 0) - goto leave; - } - - line_h1 = (line_h1 << 1) | pix; - line_h2 <<= 1; - line_h3 <<= 1; - - } while ((++x & 1) && x < hx); - line_l1 <<= 1; line_l2 <<= 1; line_l3 <<= 1; - } while ((x & 7) && x < hx); - *hp++ = line_h1; - } while ((x & 15) && x < hx); - ++lp1; - ++lp2; - } /* while */ - x = 0; - - *(hp - 1) <<= hbpl * 8 - hx; - if ((s->i & 1) == 0) { - /* low resolution pixels are used twice */ - lp1 -= lbpl; - lp2 -= lbpl; - } else - s->pseudo = 1; - - } /* for (i = ...) */ - - } - - leave: - - /* save a few local variables */ - s->line_h1 = line_h1; - s->line_h2 = line_h2; - s->line_h3 = line_h3; - s->line_l1 = line_l1; - s->line_l2 = line_l2; - s->line_l3 = line_l3; - s->x = x; - - return se->pscd_ptr - data; -} - - -/* - * Provide to the decoder a new BIE fragment of len bytes starting at data. - * - * Unless cnt is NULL, *cnt will contain the number of actually read bytes - * on return. - * - * Normal return values: - * - * JBG_EAGAIN All data bytes provided so far have been processed - * (*cnt == len) but the end of the data stream has - * not yet been recognized. Call the function again - * with additional BIE bytes. - * JBG_EOK The function has reached the end of a and - * a full image has been decoded. The function can - * be called again with data from the next BIE, if - * there exists one, in order to get to a higher - * resolution layer. The remaining len - *cnt bytes - * of the previous data block will then have to passed - * to this function again if len > *cnt. - * JBG_EOK_INTR Parsing the BIE has been interrupted as had been - * requested by a jbg_dec_maxsize() specification. - * This function can be called again with the - * rest of the BIE to continue the decoding process. - * The remaining len - *cnt bytes of the previous - * data block will then have to be passed to this - * function again if len > *cnt. - * - * Any other return value indicates that the decoding process was - * aborted by a serious problem and the only function you can then - * still call is jbg_dec_free() in order to remove the mess, and - * jbg85_strerror() to find out what to tell the user. (Looking at the - * least significant bits of the return value will provide additional - * information by identifying which test exactly has failed.) - */ -int jbg_dec_in(struct jbg_dec_state *s, unsigned char *data, size_t len, - size_t *cnt) -{ - int i, j, required_length; - unsigned long x, y; - unsigned long is[3], ie[3]; - size_t dummy_cnt; - unsigned char *dppriv; - - if (!cnt) cnt = &dummy_cnt; - *cnt = 0; - if (len < 1) return JBG_EAGAIN; - - /* read in 20-byte BIH */ - if (s->bie_len < 20) { - while (s->bie_len < 20 && *cnt < len) - s->buffer[s->bie_len++] = data[(*cnt)++]; - if (s->bie_len < 20) - return JBG_EAGAIN; - /* test whether this looks like a valid JBIG header at all */ - if (s->buffer[1] < s->buffer[0]) - return JBG_EINVAL | 1; - if (s->buffer[3] != 0) return JBG_EINVAL | 2; /* padding != 0 */ - if ((s->buffer[18] & 0xf0) != 0) return JBG_EINVAL | 3; /* padding != 0 */ - if ((s->buffer[19] & 0x80) != 0) return JBG_EINVAL | 4; /* padding != 0 */ - if (s->buffer[0] != s->d + 1) - return JBG_ENOCONT | 1; - s->dl = s->buffer[0]; - s->d = s->buffer[1]; - if (s->dl == 0) - s->planes = s->buffer[2]; - else - if (s->planes != s->buffer[2]) - return JBG_ENOCONT | 2; - x = (((long) s->buffer[ 4] << 24) | ((long) s->buffer[ 5] << 16) | - ((long) s->buffer[ 6] << 8) | (long) s->buffer[ 7]); - y = (((long) s->buffer[ 8] << 24) | ((long) s->buffer[ 9] << 16) | - ((long) s->buffer[10] << 8) | (long) s->buffer[11]); - if (s->dl != 0 && ((s->xd << (s->d - s->dl + 1)) != x && - (s->yd << (s->d - s->dl + 1)) != y)) - return JBG_ENOCONT | 3; - s->xd = x; - s->yd = y; - s->l0 = (((long) s->buffer[12] << 24) | ((long) s->buffer[13] << 16) | - ((long) s->buffer[14] << 8) | (long) s->buffer[15]); - /* ITU-T T.85 trick not directly supported by decoder; for full - * T.85 compatibility with respect to all NEWLEN marker scenarios, - * preprocess BIE with jbg_newlen() before passing it to the decoder, - * or consider using the decoder found in jbig85.c instead. */ - if (s->yd == 0xffffffff) - return JBG_EIMPL | 1; - if (!s->planes) return JBG_EINVAL | 5; - if (!s->xd) return JBG_EINVAL | 6; - if (!s->yd) return JBG_EINVAL | 7; - if (!s->l0) return JBG_EINVAL | 8; - /* prevent uint32 overflow: s->l0 * 2 ^ s->d < 2 ^ 32 */ - if (s->d > 31) - return JBG_EIMPL | 2; - if ((s->d != 0 && s->l0 >= (1UL << (32 - s->d)))) - return JBG_EIMPL | 3; - s->mx = s->buffer[16]; - if (s->mx > 127) - return JBG_EINVAL | 9; - s->my = s->buffer[17]; -#if 0 - if (s->my > 0) - return JBG_EIMPL | 4; -#endif - s->order = s->buffer[18]; - if (iindex[s->order & 7][0] < 0) - return JBG_EINVAL | 10; - /* HITOLO and SEQ currently not yet implemented */ - if (s->dl != s->d && (s->order & JBG_HITOLO || s->order & JBG_SEQ)) - return JBG_EIMPL | 5; - s->options = s->buffer[19]; - - /* calculate number of stripes that will be required */ - s->stripes = jbg_stripes(s->l0, s->yd, s->d); - - /* some initialization */ - s->ii[iindex[s->order & 7][STRIPE]] = 0; - s->ii[iindex[s->order & 7][LAYER]] = s->dl; - s->ii[iindex[s->order & 7][PLANE]] = 0; - if (s->dl == 0) { - s->s = (struct jbg_ardec_state **) - checked_malloc(s->planes, sizeof(struct jbg_ardec_state *)); - s->tx = (int **) checked_malloc(s->planes, sizeof(int *)); - s->ty = (int **) checked_malloc(s->planes, sizeof(int *)); - s->reset = (int **) checked_malloc(s->planes, sizeof(int *)); - s->lntp = (int **) checked_malloc(s->planes, sizeof(int *)); - s->lhp[0] = (unsigned char **) - checked_malloc(s->planes, sizeof(unsigned char *)); - s->lhp[1] = (unsigned char **) - checked_malloc(s->planes, sizeof(unsigned char *)); - for (i = 0; i < s->planes; i++) { - s->s[i] = (struct jbg_ardec_state *) - checked_malloc(s->d - s->dl + 1, sizeof(struct jbg_ardec_state)); - s->tx[i] = (int *) checked_malloc(s->d - s->dl + 1, sizeof(int)); - s->ty[i] = (int *) checked_malloc(s->d - s->dl + 1, sizeof(int)); - s->reset[i] = (int *) checked_malloc(s->d - s->dl + 1, sizeof(int)); - s->lntp[i] = (int *) checked_malloc(s->d - s->dl + 1, sizeof(int)); - s->lhp[ s->d & 1][i] = (unsigned char *) - checked_malloc(s->yd, jbg_ceil_half(s->xd, 3)); - s->lhp[(s->d-1) & 1][i] = (unsigned char *) - checked_malloc(jbg_ceil_half(s->yd, 1), jbg_ceil_half(s->xd, 1+3)); - } - } else { - for (i = 0; i < s->planes; i++) { - s->s[i] = (struct jbg_ardec_state *) - checked_realloc(s->s[i], s->d - s->dl + 1, - sizeof(struct jbg_ardec_state)); - s->tx[i] = (int *) checked_realloc(s->tx[i], - s->d - s->dl + 1, sizeof(int)); - s->ty[i] = (int *) checked_realloc(s->ty[i], - s->d - s->dl + 1, sizeof(int)); - s->reset[i] = (int *) checked_realloc(s->reset[i], - s->d - s->dl + 1, sizeof(int)); - s->lntp[i] = (int *) checked_realloc(s->lntp[i], - s->d - s->dl + 1, sizeof(int)); - s->lhp[ s->d & 1][i] = (unsigned char *) - checked_realloc(s->lhp[ s->d & 1][i], - s->yd, jbg_ceil_half(s->xd, 3)); - s->lhp[(s->d-1) & 1][i] = (unsigned char *) - checked_realloc(s->lhp[(s->d-1) & 1][i], - jbg_ceil_half(s->yd, 1), jbg_ceil_half(s->xd, 1+3)); - } - } - for (i = 0; i < s->planes; i++) - for (j = 0; j <= s->d - s->dl; j++) - arith_decode_init(s->s[i] + j, 0); - if (s->dl == 0 || (s->options & JBG_DPON && !(s->options & JBG_DPPRIV))) - s->dppriv = jbg_dptable; - s->comment_skip = 0; - s->buf_len = 0; - s->x = 0; - s->i = 0; - s->pseudo = 1; - s->at_moves = 0; - } - - /* read in DPTABLE */ - if (s->bie_len < 20 + 1728 && - (s->options & (JBG_DPON | JBG_DPPRIV | JBG_DPLAST)) == - (JBG_DPON | JBG_DPPRIV)) { - assert(s->bie_len >= 20); - if (!s->dppriv || s->dppriv == jbg_dptable) - s->dppriv = (char *) checked_malloc(1728, sizeof(char)); - while (s->bie_len < 20 + 1728 && *cnt < len) - s->dppriv[s->bie_len++ - 20] = data[(*cnt)++]; - if (s->bie_len < 20 + 1728) - return JBG_EAGAIN; - dppriv = (unsigned char *) s->dppriv; - s->dppriv = (char *) checked_malloc(6912, sizeof(char)); - jbg_dppriv2int(s->dppriv, dppriv); - checked_free(dppriv); - } - - /* - * BID processing loop - */ - - while (*cnt < len) { - - /* process floating marker segments */ - - /* skip COMMENT contents */ - if (s->comment_skip) { - if (s->comment_skip <= len - *cnt) { - *cnt += s->comment_skip; - s->comment_skip = 0; - } else { - s->comment_skip -= len - *cnt; - *cnt = len; - } - continue; - } - - /* load complete marker segments into s->buffer for processing */ - if (s->buf_len > 0) { - assert(s->buffer[0] == MARKER_ESC); - while (s->buf_len < 2 && *cnt < len) - s->buffer[s->buf_len++] = data[(*cnt)++]; - if (s->buf_len < 2) continue; - switch (s->buffer[1]) { - case MARKER_COMMENT: required_length = 6; break; - case MARKER_ATMOVE: required_length = 8; break; - case MARKER_NEWLEN: required_length = 6; break; - case MARKER_ABORT: - case MARKER_SDNORM: - case MARKER_SDRST: required_length = 2; break; - case MARKER_STUFF: - /* forward stuffed 0xff to arithmetic decoder */ - s->buf_len = 0; - decode_pscd(s, s->buffer, 2); - continue; - default: - return JBG_EMARKER; - } - while (s->buf_len < required_length && *cnt < len) - s->buffer[s->buf_len++] = data[(*cnt)++]; - if (s->buf_len < required_length) continue; - /* now the buffer is filled with exactly one marker segment */ - switch (s->buffer[1]) { - case MARKER_COMMENT: - s->comment_skip = - (((long) s->buffer[2] << 24) | ((long) s->buffer[3] << 16) | - ((long) s->buffer[4] << 8) | (long) s->buffer[5]); - break; - case MARKER_ATMOVE: - if (s->at_moves < JBG_ATMOVES_MAX) { - s->at_line[s->at_moves] = - (((long) s->buffer[2] << 24) | ((long) s->buffer[3] << 16) | - ((long) s->buffer[4] << 8) | (long) s->buffer[5]); - s->at_tx[s->at_moves] = (signed char) s->buffer[6]; - s->at_ty[s->at_moves] = s->buffer[7]; - if (s->at_tx[s->at_moves] < - (int) s->mx || - s->at_tx[s->at_moves] > (int) s->mx || - s->at_ty[s->at_moves] > (int) s->my || - (s->at_ty[s->at_moves] == 0 && s->at_tx[s->at_moves] < 0)) - return JBG_EINVAL | 11; - if (s->at_ty[s->at_moves] != 0) - return JBG_EIMPL | 6; - s->at_moves++; - } else - return JBG_EIMPL | 7; /* more than JBG_ATMOVES_MAX ATMOVES */ - break; - case MARKER_NEWLEN: - y = (((long) s->buffer[2] << 24) | ((long) s->buffer[3] << 16) | - ((long) s->buffer[4] << 8) | (long) s->buffer[5]); - if (y > s->yd) return JBG_EINVAL | 12; - if (!(s->options & JBG_VLENGTH)) return JBG_EINVAL | 13; - s->yd = y; - /* calculate again number of stripes that will be required */ - s->stripes = jbg_stripes(s->l0, s->yd, s->d); - break; - case MARKER_ABORT: - return JBG_EABORT; - - case MARKER_SDNORM: - case MARKER_SDRST: - /* decode final pixels based on trailing zero bytes */ - decode_pscd(s, s->buffer, 2); - - arith_decode_init(s->s[s->ii[iindex[s->order & 7][PLANE]]] + - s->ii[iindex[s->order & 7][LAYER]] - s->dl, - s->ii[iindex[s->order & 7][STRIPE]] != s->stripes - 1 - && s->buffer[1] != MARKER_SDRST); - - s->reset[s->ii[iindex[s->order & 7][PLANE]]] - [s->ii[iindex[s->order & 7][LAYER]] - s->dl] = - (s->buffer[1] == MARKER_SDRST); - - /* prepare for next SDE */ - s->x = 0; - s->i = 0; - s->pseudo = 1; - s->at_moves = 0; - - /* increment layer/stripe/plane loop variables */ - /* start and end value for each loop: */ - is[iindex[s->order & 7][STRIPE]] = 0; - ie[iindex[s->order & 7][STRIPE]] = s->stripes - 1; - is[iindex[s->order & 7][LAYER]] = s->dl; - ie[iindex[s->order & 7][LAYER]] = s->d; - is[iindex[s->order & 7][PLANE]] = 0; - ie[iindex[s->order & 7][PLANE]] = s->planes - 1; - i = 2; /* index to innermost loop */ - do { - j = 0; /* carry flag */ - if (++s->ii[i] > ie[i]) { - /* handling overflow of loop variable */ - j = 1; - if (i > 0) - s->ii[i] = is[i]; - } - } while (--i >= 0 && j); - - s->buf_len = 0; - - /* check whether this have been all SDEs */ - if (j) { -#ifdef DEBUG - fprintf(stderr, "This was the final SDE in this BIE, " - "%ld bytes left.\n", (long) (len - *cnt)); -#endif - s->bie_len = 0; - return JBG_EOK; - } - - /* check whether we have to abort because of xmax/ymax */ - if (iindex[s->order & 7][LAYER] == 0 && i < 0) { - /* LAYER is the outermost loop and we have just gone to next layer */ - if (jbg_ceil_half(s->xd, s->d - s->ii[0]) > s->xmax || - jbg_ceil_half(s->yd, s->d - s->ii[0]) > s->ymax) { - s->xmax = 4294967295UL; - s->ymax = 4294967295UL; - return JBG_EOK_INTR; - } - if (s->ii[0] > (unsigned long) s->dmax) { - s->dmax = 256; - return JBG_EOK_INTR; - } - } - - break; - } - s->buf_len = 0; - - } else if (data[*cnt] == MARKER_ESC) - s->buffer[s->buf_len++] = data[(*cnt)++]; - - else { - - /* we have found PSCD bytes */ - *cnt += decode_pscd(s, data + *cnt, len - *cnt); - if (*cnt < len && data[*cnt] != 0xff) { -#ifdef DEBUG - fprintf(stderr, "PSCD was longer than expected, unread bytes " - "%02x %02x %02x %02x ...\n", data[*cnt], data[*cnt+1], - data[*cnt+2], data[*cnt+3]); -#endif - return JBG_EINVAL | 14; - } - - } - } /* of BID processing loop 'while (*cnt < len) ...' */ - - return JBG_EAGAIN; -} - - -/* - * After jbg_dec_in() returned JBG_EOK or JBG_EOK_INTR, you can call this - * function in order to find out the width of the image. Returns 0 if - * there is no image available yet. - */ -unsigned long jbg_dec_getwidth(const struct jbg_dec_state *s) -{ - if (s->d < 0) - return 0; - if (iindex[s->order & 7][LAYER] == 0) { - if (s->ii[0] < 1) - return 0; - else - return jbg_ceil_half(s->xd, s->d - (s->ii[0] - 1)); - } - - return s->xd; -} - - -/* - * After jbg_dec_in() returned JBG_EOK or JBG_EOK_INTR, you can call this - * function in order to find out the height of the image. Returns 0 if - * there is no image available yet. - */ -unsigned long jbg_dec_getheight(const struct jbg_dec_state *s) -{ - if (s->d < 0) - return 0; - if (iindex[s->order & 7][LAYER] == 0) { - if (s->ii[0] < 1) - return 0; - else - return jbg_ceil_half(s->yd, s->d - (s->ii[0] - 1)); - } - - return s->yd; -} - - -/* - * After jbg_dec_in() returned JBG_EOK or JBG_EOK_INTR, you can call this - * function in order to get a pointer to the image. Returns NULL if - * there is no image available yet. - */ -unsigned char *jbg_dec_getimage(const struct jbg_dec_state *s, int plane) -{ - if (s->d < 0) - return NULL; - if (iindex[s->order & 7][LAYER] == 0) { - if (s->ii[0] < 1) - return NULL; - else - return s->lhp[(s->ii[0] - 1) & 1][plane]; - } - - return s->lhp[s->d & 1][plane]; -} - - -/* - * After jbg_dec_in() returned JBG_EOK or JBG_EOK_INTR, you can call - * this function in order to find out the size in bytes of one - * bitplane of the image. - */ -unsigned long jbg_dec_getsize(const struct jbg_dec_state *s) -{ - if (s->d < 0) - return 0; - if (iindex[s->order & 7][LAYER] == 0) { - if (s->ii[0] < 1) - return 0; - else - return - jbg_ceil_half(s->xd, s->d - (s->ii[0] - 1) + 3) * /* overflow risk? */ - jbg_ceil_half(s->yd, s->d - (s->ii[0] - 1)); - } - - return jbg_ceil_half(s->xd, 3) * s->yd; -} - - -/* - * After jbg_dec_in() returned JBG_EOK or JBG_EOK_INTR, you can call - * this function in order to find out the size of the image that you - * can retrieve with jbg_merge_planes(). - */ -unsigned long jbg_dec_getsize_merged(const struct jbg_dec_state *s) -{ - if (s->d < 0) - return 0; - if (iindex[s->order & 7][LAYER] == 0) { - if (s->ii[0] < 1) - return 0; - else - return - jbg_ceil_half(s->xd, s->d - (s->ii[0] - 1)) * /* overflow risk? */ - jbg_ceil_half(s->yd, s->d - (s->ii[0] - 1)) * - ((s->planes + 7) / 8); - } - - return s->xd * s->yd * ((s->planes + 7) / 8); -} - - -/* - * The destructor function which releases any resources obtained by the - * other decoder functions. - */ -void jbg_dec_free(struct jbg_dec_state *s) -{ - int i; - - if (s->d < 0 || s->s == NULL) - return; - s->d = -2; - - for (i = 0; i < s->planes; i++) { - checked_free(s->s[i]); - checked_free(s->tx[i]); - checked_free(s->ty[i]); - checked_free(s->reset[i]); - checked_free(s->lntp[i]); - checked_free(s->lhp[0][i]); - checked_free(s->lhp[1][i]); - } - - checked_free(s->s); - checked_free(s->tx); - checked_free(s->ty); - checked_free(s->reset); - checked_free(s->lntp); - checked_free(s->lhp[0]); - checked_free(s->lhp[1]); - if (s->dppriv && s->dppriv != jbg_dptable) - checked_free(s->dppriv); - - s->s = NULL; - - return; -} - - -/* - * Split bigendian integer pixel field into separate bit planes. In the - * src array, every pixel is represented by a ((has_planes + 7) / 8) byte - * long word, most significant byte first. While has_planes describes - * the number of used bits per pixel in the source image, encode_plane - * is the number of most significant bits among those that we - * actually transfer to dest. - */ -void jbg_split_planes(unsigned long x, unsigned long y, int has_planes, - int encode_planes, - const unsigned char *src, unsigned char **dest, - int use_graycode) -{ - unsigned long bpl = jbg_ceil_half(x, 3); /* bytes per line in dest plane */ - unsigned long line, i; - unsigned k = 8; - int p; - unsigned prev; /* previous *src byte shifted by 8 bit to the left */ - register int bits, msb = has_planes - 1; - int bitno; - - /* sanity checks */ - if (encode_planes > has_planes) - encode_planes = has_planes; - use_graycode = use_graycode != 0 && encode_planes > 1; - - for (p = 0; p < encode_planes; p++) - memset(dest[p], 0, bpl * y); - - for (line = 0; line < y; line++) { /* lines loop */ - for (i = 0; i * 8 < x; i++) { /* dest bytes loop */ - for (k = 0; k < 8 && i * 8 + k < x; k++) { /* pixel loop */ - prev = 0; - for (p = 0; p < encode_planes; p++) { /* bit planes loop */ - /* calculate which bit in *src do we want */ - bitno = (msb - p) & 7; - /* put this bit with its left neighbor right adjusted into bits */ - bits = (prev | *src) >> bitno; - /* go to next *src byte, but keep old */ - if (bitno == 0) - prev = *src++ << 8; - /* make space for inserting new bit */ - dest[p][bpl * line + i] <<= 1; - /* insert bit, if requested apply Gray encoding */ - dest[p][bpl * line + i] |= (bits ^ (use_graycode & (bits>>1))) & 1; - /* - * Theorem: Let b(n),...,b(1),b(0) be the digits of a - * binary word and let g(n),...,g(1),g(0) be the digits of the - * corresponding Gray code word, then g(i) = b(i) xor b(i+1). - */ - } - /* skip unused *src bytes */ - for (;p < has_planes; p++) - if (((msb - p) & 7) == 0) - src++; - } - } - for (p = 0; p < encode_planes; p++) /* right padding loop */ - dest[p][bpl * (line + 1) - 1] <<= 8 - k; - } - - return; -} - -/* - * Merge the separate bit planes decoded by the JBIG decoder into an - * integer pixel field. This is essentially the counterpart to - * jbg_split_planes(). - */ -void jbg_dec_merge_planes(const struct jbg_dec_state *s, int use_graycode, - void (*data_out)(unsigned char *start, size_t len, - void *file), void *file) -{ -#define BUFLEN 4096 - unsigned long bpl, line, i; - unsigned k = 8; - int p; - unsigned char buf[BUFLEN]; - unsigned char *bp = buf; - unsigned char **src; - unsigned long x, y; - unsigned v; - - /* sanity check */ - use_graycode = use_graycode != 0; - - x = jbg_dec_getwidth(s); - y = jbg_dec_getheight(s); - if (x == 0 || y == 0) - return; - bpl = jbg_ceil_half(x, 3); /* bytes per line in src plane */ - - if (iindex[s->order & 7][LAYER] == 0) - if (s->ii[0] < 1) - return; - else - src = s->lhp[(s->ii[0] - 1) & 1]; - else - src = s->lhp[s->d & 1]; - - for (line = 0; line < y; line++) { /* lines loop */ - for (i = 0; i * 8 < x; i++) { /* src bytes loop */ - for (k = 0; k < 8 && i * 8 + k < x; k++) { /* pixel loop */ - v = 0; - for (p = 0; p < s->planes;) { /* dest bytes loop */ - do { - v = (v << 1) | - (((src[p][bpl * line + i] >> (7 - k)) & 1) ^ - (use_graycode & v)); - } while ((s->planes - ++p) & 7); - *bp++ = v; - if (bp - buf == BUFLEN) { - data_out(buf, BUFLEN, file); - bp = buf; - } - } - } - } - } - - if (bp - buf > 0) - data_out(buf, bp - buf, file); - - return; -} - - -/* - * Given a pointer p to the first byte of either a marker segment or a - * PSCD, as well as the length len of the remaining data, return - * either the pointer to the first byte of the next marker segment or - * PSCD, or p+len if this was the last one, or NULL if some error was - * encountered. Possible errors are: - * - * - not enough bytes left for complete marker segment - * - no marker segment terminates the PSCD - * - unknown marker code encountered - * - */ -unsigned char *jbg_next_pscdms(unsigned char *p, size_t len) -{ - unsigned char *pp; - unsigned long l; - - if (len < 2) - return NULL; /* not enough bytes left for complete marker segment */ - - if (p[0] != MARKER_ESC || p[1] == MARKER_STUFF) { - do { - while (p[0] == MARKER_ESC && p[1] == MARKER_STUFF) { - p += 2; - len -= 2; - if (len < 2) - return NULL; /* not enough bytes left for complete marker segment */ - } - assert(len >= 2); - pp = (unsigned char *) memchr(p, MARKER_ESC, len - 1); - if (!pp) - return NULL; /* no marker segment terminates the PSCD */ - l = pp - p; - assert(l < len); - p += l; - len -= l; - } while (p[1] == MARKER_STUFF); - } else { - switch (p[1]) { - case MARKER_SDNORM: - case MARKER_SDRST: - case MARKER_ABORT: - return p + 2; - case MARKER_NEWLEN: - if (len < 6) - return NULL; /* not enough bytes left for complete marker segment */ - return p + 6; - case MARKER_ATMOVE: - if (len < 8) - return NULL; /* not enough bytes left for complete marker segment */ - return p + 8; - case MARKER_COMMENT: - if (len < 6) - return NULL; /* not enough bytes left for complete marker segment */ - l = (((long) p[2] << 24) | ((long) p[3] << 16) | - ((long) p[4] << 8) | (long) p[5]); - if (len - 6 < l) - return NULL; /* not enough bytes left for complete marker segment */ - return p + 6 + l; - default: - /* unknown marker sequence encountered */ - return NULL; - } - } - - return p; -} - - -/* - * Scan a complete BIE for a NEWLEN marker segment, then read the new - * YD value found in it and use it to overwrite the one in the BIE - * header. Use this procedure if a BIE initially declares an - * unreasonably high provisional YD value (e.g., 0xffffffff) or - * depends on the fact that section 6.2.6.2 of ITU-T T.82 says that a - * NEWLEN marker segment "could refer to a line in the immediately - * preceding stripe due to an unexpected termination of the image or - * the use of only such stripe". ITU-T.85 explicitely suggests the - * use of this for fax machines that start transmission before having - * encountered the end of the page. None of this is necessary for - * BIEs produced by JBIG-KIT, which normally does not use NEWLEN. - */ -int jbg_newlen(unsigned char *bie, size_t len) -{ - unsigned char *p = bie + 20; - int i; - unsigned long y, yn; - - if (len < 20) - return JBG_EAGAIN; - if ((bie[19] & (JBG_DPON | JBG_DPPRIV | JBG_DPLAST)) - == (JBG_DPON | JBG_DPPRIV)) - p += 1728; /* skip DPTABLE */ - if (p >= bie + len) - return JBG_EAGAIN; - - while ((p = jbg_next_pscdms(p, len - (p - bie)))) { - if (p == bie + len) - return JBG_EOK; - else if (p[0] == MARKER_ESC) - switch (p[1]) { - case MARKER_NEWLEN: - y = (((long) bie[ 8] << 24) | ((long) bie[ 9] << 16) | - ((long) bie[10] << 8) | (long) bie[11]); - yn = (((long) p[2] << 24) | ((long) p[3] << 16) | - ((long) p[4] << 8) | (long) p[5]); - if (yn > y) return JBG_EINVAL | 12; - /* overwrite YD in BIH with YD from NEWLEN */ - for (i = 0; i < 4; i++) { - bie[8+i] = p[2+i]; - } - return JBG_EOK; - case MARKER_ABORT: - return JBG_EABORT; - } - } - return JBG_EINVAL | 0; -} diff -rupN foo2zjs.orig/jbig.h foo2zjs/jbig.h --- foo2zjs.orig/jbig.h 2014-04-08 10:22:54.000000000 -0400 +++ foo2zjs/jbig.h 1969-12-31 19:00:00.000000000 -0500 @@ -1,235 +0,0 @@ -/* - * Header file for the portable JBIG compression library - * - * Copyright 1995-2014 -- Markus Kuhn -- http://www.cl.cam.ac.uk/~mgk25/ - * - * $Id: jbig.h,v 1.5 2014/04/08 14:22:54 rick Exp $ - */ - -#ifndef JBG_H -#define JBG_H - -#include <stddef.h> -#include "jbig_ar.h" - -/* - * JBIG-KIT version number - */ - -#define JBG_VERSION "2.1" -#define JBG_VERSION_MAJOR 2 -#define JBG_VERSION_MINOR 1 - -/* - * JBIG-KIT licence agreement reference code: - * If you use JBIG-KIT under a commercial licence, please replace - * below the letters GPL with the reference code that you received - * with your licence agreement. (This code is typically a letter "A" - * followed by four decimal digits, e.g. "A1234".) - */ - -#define JBG_LICENCE "GPL" - -/* - * Buffer block for SDEs which are temporarily stored by encoder - */ - -#define JBG_BUFSIZE 4000 - -struct jbg_buf { - unsigned char d[JBG_BUFSIZE]; /* one block of a buffer list */ - int len; /* length of the data in this block */ - struct jbg_buf *next; /* pointer to next block */ - struct jbg_buf *previous; /* pointer to previous block * - * (unused in freelist) */ - struct jbg_buf *last; /* only used in list head: final block of list */ - struct jbg_buf **free_list; /* pointer to pointer to head of free list */ -}; - -/* - * Maximum number of ATMOVEs per stripe that decoder can handle - */ - -#define JBG_ATMOVES_MAX 64 - -/* - * Option and order flags - */ - -#define JBG_HITOLO 0x08 -#define JBG_SEQ 0x04 -#define JBG_ILEAVE 0x02 -#define JBG_SMID 0x01 - -#define JBG_LRLTWO 0x40 -#define JBG_VLENGTH 0x20 -#define JBG_TPDON 0x10 -#define JBG_TPBON 0x08 -#define JBG_DPON 0x04 -#define JBG_DPPRIV 0x02 -#define JBG_DPLAST 0x01 - -/* encoding options that will not be indicated in the header */ - -#define JBG_DELAY_AT 0x100 /* Delay ATMOVE until the first line of the next - * stripe. Option available for compatibility - * with conformance test example in clause 7.2. */ - -#define JBG_SDRST 0x200 /* Use SDRST instead of SDNORM. This option is - * there for anyone who needs to generate - * test data that covers the SDRST cases. */ - -/* - * Possible error code return values - */ - -#define JBG_EOK (0 << 4) -#define JBG_EOK_INTR (1 << 4) -#define JBG_EAGAIN (2 << 4) -#define JBG_ENOMEM (3 << 4) -#define JBG_EABORT (4 << 4) -#define JBG_EMARKER (5 << 4) -#define JBG_EINVAL (6 << 4) -#define JBG_EIMPL (7 << 4) -#define JBG_ENOCONT (8 << 4) - -/* - * Status of a JBIG encoder - */ - -struct jbg_enc_state { - int d; /* resolution layer of the input image */ - unsigned long xd, yd; /* size of the input image (resolution layer d) */ - unsigned long yd1; /* BIH announced height of image, use yd1 != yd to - emulate T.85-style NEWLEN height updates for tests */ - int planes; /* number of different bitmap planes */ - int dl; /* lowest resolution layer in the next BIE */ - int dh; /* highest resolution layer in the next BIE */ - unsigned long l0; /* number of lines per stripe at lowest * - * resolution layer 0 */ - unsigned long stripes; /* number of stripes required (determ. by l0) */ - unsigned char **lhp[2]; /* pointers to lower/higher resolution images */ - int *highres; /* index [plane] of highres image in lhp[] */ - int order; /* SDE ordering parameters */ - int options; /* encoding parameters */ - unsigned mx, my; /* maximum ATMOVE window size */ - int *tx; /* array [plane] with x-offset of adaptive template pixel */ - char *dppriv; /* optional private deterministic prediction table */ - char *res_tab; /* table for the resolution reduction algorithm */ - struct jbg_buf ****sde; /* array [stripe][layer][plane] pointers to * - * buffers for stored SDEs */ - struct jbg_arenc_state *s; /* array [planes] for arithm. encoder status */ - struct jbg_buf *free_list; /* list of currently unused SDE block buffers */ - void (*data_out)(unsigned char *start, size_t len, void *file); - /* data write callback */ - void *file; /* parameter passed to data_out() */ - char *tp; /* buffer for temp. values used by diff. typical prediction */ - unsigned char *comment; /* content of comment marker segment to be added - at next opportunity (will be reset to NULL - as soon as comment has been written) */ - unsigned long comment_len; /* length of data pointed to by comment */ -}; - - -/* - * Status of a JBIG decoder - */ - -struct jbg_dec_state { - /* data from BIH */ - int d; /* resolution layer of the full image */ - int dl; /* first resolution layer in this BIE */ - unsigned long xd, yd; /* size of the full image (resolution layer d) */ - int planes; /* number of different bitmap planes */ - unsigned long l0; /* number of lines per stripe at lowest * - * resolution layer 0 */ - unsigned long stripes; /* number of stripes required (determ. by l0) */ - int order; /* SDE ordering parameters */ - int options; /* encoding parameters */ - int mx, my; /* maximum ATMOVE window size */ - char *dppriv; /* optional private deterministic prediction table */ - - /* loop variables */ - unsigned long ii[3]; /* current stripe, layer, plane (outer loop first) */ - - /* - * Pointers to array [planes] of lower/higher resolution images. - * lhp[d & 1] contains image of layer d. - */ - unsigned char **lhp[2]; - - /* status information */ - int **tx, **ty; /* array [plane][layer-dl] with x,y-offset of AT pixel */ - struct jbg_ardec_state **s; /* array [plane][layer-dl] for arithmetic * - * decoder status */ - int **reset; /* array [plane][layer-dl] remembers if previous stripe * - * in that plane/resolution ended with SDRST. */ - unsigned long bie_len; /* number of bytes read so far */ - unsigned char buffer[20]; /* used to store BIH or marker segments fragm. */ - int buf_len; /* number of bytes in buffer */ - unsigned long comment_skip; /* remaining bytes of a COMMENT segment */ - unsigned long x; /* x position of next pixel in current SDE */ - unsigned long i; /* line in current SDE (first line of each stripe is 0) */ - int at_moves; /* number of AT moves in the current stripe */ - unsigned long at_line[JBG_ATMOVES_MAX]; /* lines at which an * - * AT move will happen */ - int at_tx[JBG_ATMOVES_MAX], at_ty[JBG_ATMOVES_MAX]; /* ATMOVE offsets in * - * current stripe */ - unsigned long line_h1, line_h2, line_h3; /* variables of decode_pscd */ - unsigned long line_l1, line_l2, line_l3; - int pseudo; /* flag for TPBON/TPDON: next pixel is pseudo pixel */ - int **lntp; /* flag [plane][layer-dl] for TP: line is not typical */ - - unsigned long xmax, ymax; /* if possible abort before image gets * - * larger than this size */ - int dmax; /* abort after this layer */ -}; - - -/* some macros (too trivial for a function) */ - -#define jbg_dec_getplanes(s) ((s)->planes) - - -/* function prototypes */ - -void jbg_enc_init(struct jbg_enc_state *s, unsigned long x, unsigned long y, - int planes, unsigned char **p, - void (*data_out)(unsigned char *start, size_t len, - void *file), - void *file); -int jbg_enc_lrlmax(struct jbg_enc_state *s, unsigned long mwidth, - unsigned long mheight); -void jbg_enc_layers(struct jbg_enc_state *s, int d); -int jbg_enc_lrange(struct jbg_enc_state *s, int dl, int dh); -void jbg_enc_options(struct jbg_enc_state *s, int order, int options, - unsigned long l0, int mx, int my); -void jbg_enc_out(struct jbg_enc_state *s); -void jbg_enc_free(struct jbg_enc_state *s); - -void jbg_dec_init(struct jbg_dec_state *s); -void jbg_dec_maxsize(struct jbg_dec_state *s, unsigned long xmax, - unsigned long ymax); -int jbg_dec_in(struct jbg_dec_state *s, unsigned char *data, size_t len, - size_t *cnt); -unsigned long jbg_dec_getwidth(const struct jbg_dec_state *s); -unsigned long jbg_dec_getheight(const struct jbg_dec_state *s); -unsigned char *jbg_dec_getimage(const struct jbg_dec_state *s, int plane); -unsigned long jbg_dec_getsize(const struct jbg_dec_state *s); -void jbg_dec_merge_planes(const struct jbg_dec_state *s, int use_graycode, - void (*data_out)(unsigned char *start, size_t len, - void *file), void *file); -unsigned long jbg_dec_getsize_merged(const struct jbg_dec_state *s); -void jbg_dec_free(struct jbg_dec_state *s); - -const char *jbg_strerror(int errnum); -void jbg_int2dppriv(unsigned char *dptable, const char *internal); -void jbg_dppriv2int(char *internal, const unsigned char *dptable); -unsigned long jbg_ceil_half(unsigned long x, int n); -void jbg_split_planes(unsigned long x, unsigned long y, int has_planes, - int encode_planes, - const unsigned char *src, unsigned char **dest, - int use_graycode); -int jbg_newlen(unsigned char *bie, size_t len); - -#endif /* JBG_H */ diff -rupN foo2zjs.orig/Makefile foo2zjs/Makefile --- foo2zjs.orig/Makefile 2017-04-07 16:16:42.000000000 -0400 +++ foo2zjs/Makefile 2017-04-14 08:38:02.621021173 -0400 @@ -128,10 +128,6 @@ FILES = \ Makefile \ foo2zjs.c \ foo2zjs.1in \ - jbig.c \ - jbig.h \ - jbig_ar.c \ - jbig_ar.h \ zjsdecode.c \ zjsdecode.1in \ zjs.h \ @@ -295,7 +291,7 @@ MANPAGES+= foo2ddst-wrapper.1 foo2ddst.1 MANPAGES+= gipddecode.1 MANPAGES+= foo2zjs-pstops.1 arm2hpdl.1 usb_printerid.1 MANPAGES+= printer-profile.1 -LIBJBG = jbig.o jbig_ar.o +LIBJBG = -ljbig BINPROGS= ifeq ($(UNAME),Linux) @@ -467,34 +463,34 @@ all-done: @echo "yourself." -foo2ddst: foo2ddst.o $(LIBJBG) +foo2ddst: foo2ddst.o $(CC) $(CFLAGS) -o $@ foo2ddst.o $(LIBJBG) -foo2hbpl2: foo2hbpl2.o $(LIBJBG) +foo2hbpl2: foo2hbpl2.o $(CC) $(CFLAGS) -o $@ foo2hbpl2.o $(LIBJBG) -foo2hp: foo2hp.o $(LIBJBG) +foo2hp: foo2hp.o $(CC) $(CFLAGS) -o $@ foo2hp.o $(LIBJBG) -foo2hiperc: foo2hiperc.o $(LIBJBG) +foo2hiperc: foo2hiperc.o $(CC) $(CFLAGS) -o $@ foo2hiperc.o $(LIBJBG) -foo2lava: foo2lava.o $(LIBJBG) +foo2lava: foo2lava.o $(CC) $(CFLAGS) -o $@ foo2lava.o $(LIBJBG) -foo2oak: foo2oak.o $(LIBJBG) +foo2oak: foo2oak.o $(CC) $(CFLAGS) -o $@ foo2oak.o $(LIBJBG) -foo2qpdl: foo2qpdl.o $(LIBJBG) +foo2qpdl: foo2qpdl.o $(CC) $(CFLAGS) -o $@ foo2qpdl.o $(LIBJBG) -foo2slx: foo2slx.o $(LIBJBG) +foo2slx: foo2slx.o $(CC) $(CFLAGS) -o $@ foo2slx.o $(LIBJBG) -foo2xqx: foo2xqx.o $(LIBJBG) +foo2xqx: foo2xqx.o $(CC) $(CFLAGS) -o $@ foo2xqx.o $(LIBJBG) -foo2zjs: foo2zjs.o $(LIBJBG) +foo2zjs: foo2zjs.o $(CC) $(CFLAGS) -o $@ foo2zjs.o $(LIBJBG) @@ -580,43 +576,43 @@ ifeq ($(UNAME),Darwin) cd osx-hotplug; $(MAKE) all endif -ok: ok.o $(LIBJBG) +ok: ok.o $(CC) $(CFLAGS) ok.o $(LIBJBG) -o $@ -ddstdecode: ddstdecode.o $(LIBJBG) +ddstdecode: ddstdecode.o $(CC) $(CFLAGS) ddstdecode.o $(LIBJBG) -o $@ -gipddecode: gipddecode.o $(LIBJBG) +gipddecode: gipddecode.o $(CC) $(CFLAGS) gipddecode.o $(LIBJBG) -o $@ -hbpldecode: hbpldecode.o $(LIBJBG) +hbpldecode: hbpldecode.o $(CC) $(CFLAGS) hbpldecode.o $(LIBJBG) -o $@ -hipercdecode: hipercdecode.o $(LIBJBG) +hipercdecode: hipercdecode.o $(CC) $(CFLAGS) hipercdecode.o $(LIBJBG) -o $@ -lavadecode: lavadecode.o $(LIBJBG) +lavadecode: lavadecode.o $(CC) $(CFLAGS) lavadecode.o $(LIBJBG) -o $@ -oakdecode: oakdecode.o $(LIBJBG) +oakdecode: oakdecode.o $(CC) $(CFLAGS) -g oakdecode.o $(LIBJBG) -o $@ -opldecode: opldecode.o $(LIBJBG) +opldecode: opldecode.o $(CC) $(CFLAGS) -g opldecode.o $(LIBJBG) -o $@ -qpdldecode: qpdldecode.o $(LIBJBG) +qpdldecode: qpdldecode.o $(CC) $(CFLAGS) qpdldecode.o $(LIBJBG) -o $@ -splcdecode: splcdecode.o $(LIBJBG) +splcdecode: splcdecode.o $(CC) $(CFLAGS) splcdecode.o $(LIBJBG) -lz -o $@ -slxdecode: slxdecode.o $(LIBJBG) +slxdecode: slxdecode.o $(CC) $(CFLAGS) slxdecode.o $(LIBJBG) -o $@ -xqxdecode: xqxdecode.o $(LIBJBG) +xqxdecode: xqxdecode.o $(CC) $(CFLAGS) xqxdecode.o $(LIBJBG) -o $@ -zjsdecode: zjsdecode.o $(LIBJBG) +zjsdecode: zjsdecode.o $(CC) $(CFLAGS) zjsdecode.o $(LIBJBG) -o $@ command2foo2lava-pjl: command2foo2lava-pjl.o @@ -1227,7 +1223,7 @@ clean: -rm -f $(PROGS) $(BINPROGS) $(SHELLS) -rm -f *.zc *.zm -rm -f xxx.* xxxomatic - -rm -f foo2zjs.o jbig.o jbig_ar.o zjsdecode.o foo2hp.o + -rm -f foo2zjs.o zjsdecode.o foo2hp.o -rm -f foo2oak.o oakdecode.o -rm -f foo2xqx.o xqxdecode.o -rm -f foo2lava.o lavadecode.o @@ -1257,29 +1253,27 @@ clean: # # Header dependencies # -jbig.o: jbig.h - -foo2ddst.o: jbig.h ddst.h -foo2hiperc.o: jbig.h hiperc.h -foo2hp.o: jbig.h zjs.h cups.h -foo2hbpl2.o: jbig.h hbpl.h -foo2lava.o: jbig.h -foo2oak.o: jbig.h oak.h -foo2qpdl.o: jbig.h qpdl.h -foo2slx.o: jbig.h slx.h -foo2xqx.o: jbig.h xqx.h -foo2zjs.o: jbig.h zjs.h - -ddstdecode.o: ddst.h jbig.h -gipddecode.o: slx.h jbig.h -hbpldecode.o: jbig.h -hipercdecode.o: hiperc.h jbig.h -lavadecode.o: jbig.h -opldecode.o: jbig.h -qpdldecode.o: jbig.h -slxdecode.o: slx.h jbig.h -xqxdecode.o: xqx.h jbig.h -zjsdecode.o: jbig.h zjs.h +foo2ddst.o: ddst.h +foo2hiperc.o: hiperc.h +foo2hp.o: zjs.h cups.h +foo2hbpl2.o: hbpl.h +foo2lava.o: +foo2oak.o: oak.h +foo2qpdl.o: qpdl.h +foo2slx.o: slx.h +foo2xqx.o: xqx.h +foo2zjs.o: zjs.h + +ddstdecode.o: ddst.h +gipddecode.o: slx.h +hbpldecode.o: +hipercdecode.o: hiperc.h +lavadecode.o: +opldecode.o: +qpdldecode.o: +slxdecode.o: slx.h +xqxdecode.o: xqx.h +zjsdecode.o: zjs.h # # foo2* Regression tests Binary files foo2zjs.orig/.Makefile.swp and foo2zjs/.Makefile.swp differ
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
