[foo2zjs] Update to lastest revision
Leigh Scott
leigh123linux at rpmfusion.org
Wed Aug 10 15:29:17 CEST 2016
commit 639ce0c6e6b192d9a1ba9345fe482bf7e8d64a82
Author: leigh123linux <leigh123linux at googlemail.com>
Date: Wed Aug 10 14:29:12 2016 +0100
Update to lastest revision
.gitignore | 1 +
foo2zjs-dynamic-jbig.patch | 4019 --------------------------------------------
foo2zjs.spec | 34 +-
sources | 2 +-
4 files changed, 33 insertions(+), 4023 deletions(-)
---
diff --git a/.gitignore b/.gitignore
index ff92501..c9167e9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,2 @@
foo2zjs-20130618.tar.gz
+/foo2zjs-20160810.tar.gz
diff --git a/foo2zjs-dynamic-jbig.patch b/foo2zjs-dynamic-jbig.patch
index 9b4a2f3..744f5fe 100644
--- a/foo2zjs-dynamic-jbig.patch
+++ b/foo2zjs-dynamic-jbig.patch
@@ -1,4022 +1,3 @@
-diff -uNr foo2zjs-patch1/jbig_ar.c foo2zjs/jbig_ar.c
---- foo2zjs-patch1/jbig_ar.c 2008-09-05 17:05:54.000000000 +0200
-+++ foo2zjs/jbig_ar.c 1970-01-01 01:00:00.000000000 +0100
-@@ -1,426 +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.
-- *
-- * It is possible that certain products which can be built using this
-- * software module might form inventions protected by patent rights in
-- * some countries (e.g., by patents about arithmetic coding algorithms
-- * owned by IBM and AT&T in the USA). Provision of this software by the
-- * author does NOT include any licences for any patents. In those
-- * countries where a patent licence is required for certain applications
-- * of this software module, you will have to obtain such a licence
-- * yourself.
-- */
--
--#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 -uNr foo2zjs-patch1/jbig_ar.h foo2zjs/jbig_ar.h
---- foo2zjs-patch1/jbig_ar.h 2008-09-05 17:05:54.000000000 +0200
-+++ foo2zjs/jbig_ar.h 1970-01-01 01:00:00.000000000 +0100
-@@ -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 -uNr foo2zjs-patch1/jbig.c foo2zjs/jbig.c
---- foo2zjs-patch1/jbig.c 2011-06-09 13:54:12.000000000 +0200
-+++ foo2zjs/jbig.c 1970-01-01 01:00:00.000000000 +0100
-@@ -1,3289 +0,0 @@
--/*
-- * Portable JBIG image compression library
-- *
-- * Copyright 1995-2007 -- Markus Kuhn -- http://www.cl.cam.ac.uk/~mgk25/
-- *
-- * $Id: jbig.c,v 1.6 2011/06/09 11:54:12 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.
-- *
-- * It is possible that certain products which can be built using this
-- * software module might form inventions protected by patent rights in
-- * some countries (e.g., by patents about arithmetic coding algorithms
-- * owned by IBM and AT&T in the USA). Provision of this software by the
-- * author does NOT include any licences for any patents. In those
-- * countries where a patent licence is required for certain applications
-- * of this software module, you will have to obtain such a licence
-- * yourself.
-- */
--
--#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-2008 Markus Kuhn -- "
-- "Licence: " JBG_LICENCE "\n"
-- "$Id: jbig.c,v 1.6 2011/06/09 11:54:12 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; j < 8; 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; j < 8; 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 were this code
-- * can not 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;
--
-- 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);
-- while (s->bie_len < 20 + 1728 && *cnt < len)
-- s->buffer[s->bie_len++ - 20] = data[(*cnt)++];
-- if (s->bie_len < 20 + 1728)
-- return JBG_EAGAIN;
-- if (!s->dppriv || s->dppriv == jbg_dptable)
-- s->dppriv = (char *) checked_malloc(1728, sizeof(char));
-- jbg_dppriv2int(s->dppriv, s->buffer);
-- }
--
-- /*
-- * 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, "
-- "%d bytes left.\n", 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
-- // int bpp;
-- 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;
-- // bpp = (s->planes + 7) / 8; /* bytes per pixel in dest image */
-- 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;
--
-- 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:
-- /* 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 -uNr foo2zjs-patch1/jbig.h foo2zjs/jbig.h
---- foo2zjs-patch1/jbig.h 2008-09-05 17:06:03.000000000 +0200
-+++ foo2zjs/jbig.h 1970-01-01 01:00:00.000000000 +0100
-@@ -1,233 +0,0 @@
--/*
-- * Header file for the portable JBIG compression library
-- *
-- * Copyright 1995-2008 -- Markus Kuhn -- http://www.cl.cam.ac.uk/~mgk25/
-- *
-- * $Id: jbig.h,v 1.4 2008/09/05 15:05:54 rick Exp $
-- */
--
--#ifndef JBG_H
--#define JBG_H
--
--#include <stddef.h>
--#include "jbig_ar.h"
--
--/*
-- * JBIG-KIT version number
-- */
--
--#define JBG_VERSION "2.0"
--
--/*
-- * 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 -uNr foo2zjs-patch1/Makefile foo2zjs/Makefile
--- foo2zjs-patch1/Makefile 2013-03-02 17:46:05.000000000 +0100
+++ foo2zjs/Makefile 2013-03-03 08:36:20.139826214 +0100
diff --git a/foo2zjs.spec b/foo2zjs.spec
index 79b9b70..a2028e5 100644
--- a/foo2zjs.spec
+++ b/foo2zjs.spec
@@ -1,8 +1,8 @@
-%define foo2zjs_ver 20130618
+%define foo2zjs_ver 20160810
Name: foo2zjs
Version: 0.%{foo2zjs_ver}
-Release: 2%{?dist}
+Release: 1%{?dist}
Summary: Linux printer driver for ZjStream protocol
Group: System Environment/Libraries
@@ -211,7 +211,7 @@ http://foo2oak.rkkda.com/ and consider contributing.
%patch1 -p1
# Remove jbig source code, jbigkit-devel package is used in BuildRequires
-#rm -f jbig*
+rm -f jbig*
sed -i -e s/foo2zjs-icc2ps/icc2ps/g *wrapper*
sed -i -e s/775/755/ Makefile
@@ -302,11 +302,25 @@ rm -rf $RPM_BUILD_ROOT
%{_datadir}/foomatic/db/source/driver/foo2hbpl2.xml
%{_datadir}/foomatic/db/source/opt/foo2hbpl2*.xml
%{_datadir}/foomatic/db/source/printer/Dell-1355.xml
+%{_datadir}/foomatic/db/source/printer/Dell-C1765.xml
+%{_datadir}/foomatic/db/source/printer/Epson-AcuLaser_CX17NF.xml
+%{_datadir}/foomatic/db/source/printer/Epson-AcuLaser_M1400.xml
+%{_datadir}/foomatic/db/source/printer/Xerox-WorkCentre_3045.xml
%{_datadir}/foomatic/db/source/printer/Xerox-WorkCentre_6015.xml
%{_datadir}/foomatic/db/source/printer/Fuji_Xerox-DocuPrint_CM205.xml
+%{_datadir}/foomatic/db/source/printer/Fuji_Xerox-DocuPrint_CM215.xml
+%{_datadir}/foomatic/db/source/printer/Fuji_Xerox-DocuPrint_M215.xml
+%{_datadir}/foomatic/db/source/printer/Fuji_Xerox-DocuPrint_P205.xml
%{_datadir}/cups/model/Dell-1355.ppd.gz
+%{_datadir}/cups/model/Dell-C1765.ppd.gz
+%{_datadir}/cups/model/Epson-AcuLaser_CX17NF.ppd.gz
+%{_datadir}/cups/model/Epson-AcuLaser_M1400.ppd.gz
+%{_datadir}/cups/model/Xerox-WorkCentre_3045.ppd.gz
%{_datadir}/cups/model/Xerox-WorkCentre_6015.ppd.gz
%{_datadir}/cups/model/Fuji_Xerox-DocuPrint_CM205.ppd.gz
+%{_datadir}/cups/model/Fuji_Xerox-DocuPrint_CM215.ppd.gz
+%{_datadir}/cups/model/Fuji_Xerox-DocuPrint_M215.ppd.gz
+%{_datadir}/cups/model/Fuji_Xerox-DocuPrint_P205.ppd.gz
%files -n foo2xqx
%defattr(-,root,root,-)
@@ -375,6 +389,7 @@ rm -rf $RPM_BUILD_ROOT
%{_bindir}/*hiperc*
%{_mandir}/man1/*hiperc*
%{_datadir}/foomatic/db/source/driver/foo2hiperc.xml
+%{_datadir}/foomatic/db/source/driver/foo2hiperc-z1.xml
%{_datadir}/foomatic/db/source/opt/foo2hiperc*.xml
%{_datadir}/foomatic/db/source/printer/Oki-C*.xml
%{_datadir}/cups/model/Oki-C*.ppd.gz
@@ -422,6 +437,19 @@ rm -rf $RPM_BUILD_ROOT
/bin/rm -f /var/cache/foomatic/*
%changelog
+* Wed Aug 10 2016 Leigh Scott <leigh123linux at googlemail.com> - 0.20160810-1
+- Update to lastest revision
+- Add New printer support : Dell-C1765
+- Add New printer support : Epson-AcuLaser_CX17NF
+- Add New printer support : Epson-AcuLaser_M1400
+- Add New printer support : HP-LaserJet_Pro_M1212nf
+- Add New printer support : Xerox-WorkCentre_3045
+- Add New printer support : Fuji_Xerox-DocuPrint_CM215
+- Add New printer support : Fuji_Xerox-DocuPrint_M215
+- Add New printer support : Fuji_Xerox-DocuPrint_P205
+- Add New printer support : Oki-C511dn
+- Add New printer support : Oki-C810
+
* Sun Aug 31 2014 Sérgio Basto <sergio at serjux.com> - 0.20130618-2
- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_22_Mass_Rebuild
diff --git a/sources b/sources
index 80f789c..ce2b64b 100644
--- a/sources
+++ b/sources
@@ -1 +1 @@
-be3cd1bbcd6cb967c91d362f7a493460 foo2zjs-20130618.tar.gz
+d88e300068ba24cc13d0c0721ec94812 foo2zjs-20160810.tar.gz
More information about the rpmfusion-commits
mailing list