t82.h

/*
 *  Header file for the portable free JBIG compression library
 *
 *  Markus Kuhn -- http://www.cl.cam.ac.uk/~mgk25/
 *
 *  $Id: t82.h,v 1.5 2008/03/14 14:28:17 steveu Exp $
 */

#if !defined(_SPANDSP_T82_H_)
#define _SPANDSP_T82_H_

/*
 * JBIG-KIT version number
 */
#define T82_VERSION    "1.6"

/*
 * Buffer block for SDEs which are temporarily stored by encoder
 */

#define T82_BUFSIZE 4000

/*! T.82 buffer */
struct t82_buf
{
    uint8_t d[T82_BUFSIZE];         /* one block of a buffer list */
    int len;                        /* length of the data in this block */
    struct t82_buf *next;           /* pointer to next block */
    struct t82_buf *previous;       /* pointer to previous block *
                                     * (unused in freelist)      */
    struct t82_buf *last;           /* only used in list head: final block of list */
    struct t82_buf **free_list;     /* pointer to pointer to head of free list */
};

/*
 * Maximum number of ATMOVEs per stripe that decoder can handle
 */
#define T82_ATMOVES_MAX  64

/*
 * Option and order flags
 */
#define T82_HITOLO     0x08
#define T82_SEQ        0x04
#define T82_ILEAVE     0x02
#define T82_SMID       0x01

#define T82_LRLTWO     0x40
#define T82_VLENGTH    0x20
#define T82_TPDON      0x10
#define T82_TPBON      0x08
#define T82_DPON       0x04
#define T82_DPPRIV     0x02
#define T82_DPLAST     0x01

#define T82_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.*/

/*
 * Possible error code return values
 */
#define T82_EOK        0
#define T82_EOK_INTR   1
#define T82_EAGAIN     2
#define T82_ENOMEM     3
#define T82_EABORT     4
#define T82_EMARKER    5
#define T82_ENOCONT    6
#define T82_EINVAL     7
#define T82_EIMPL      8

/*
 * Language code for error message strings (based on ISO 639 2-letter
 * standard language name abbreviations).
 */
#define T82_EN         0        /* English */
#define T82_DE_8859_1  1        /* German in ISO Latin 1 character set */
#define T82_DE_UTF_8   2        /* German in Unicode UTF-8 encoding */

/*
 * Status description of an arithmetic encoder
 */
struct t82_arenc_state
{
    uint8_t st[4096];          /* probability status for contexts, MSB = MPS */
    uint32_t c;                     /* C register, base of coding intervall, *
                                     * layout as in Table 23                 */
    uint32_t a;           /* A register, normalized size of coding intervall */
    int32_t sc;     /* counter for buffered 0xff values which might 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 which receives all PSCD bytes */
    void *file;                              /* parameter passed to byte_out */
};

/*
 * Status description of an arithmetic decoder
 */
enum t82_ardec_result
{
    T82_OK,         /* symbol has been successfully decoded */
    T82_READY,      /* no more bytes of this PSCD required, marker  *
                     * encountered, probably more symbols available */
    T82_MORE,       /* more PSCD data bytes required to decode a symbol */
    T82_MARKER      /* more PSCD data bytes required, ignored final 0xff byte */
};

struct t82_ardec_state
{
    uint8_t st[4096];          /* probability status for contexts, MSB = MPS */
    uint32_t c;                     /* C register, base of coding interval,  *
                                     * layout as in Table 25                 */
    uint32_t a;            /* A register, normalized size of coding interval */
    int ct;     /* bit shift counter, determines when next byte will be read */
    const uint8_t *pscd_ptr;               /* pointer to next PSCD data byte */
    const uint8_t *pscd_end;                   /* pointer to byte after PSCD */
    enum t82_ardec_result result;          /* result of previous decode call */
    int startup;                            /* controls initial fill of s->c */
};

/*! State of a single instance of a T.82 JBIG encoder */
typedef struct
{
    int d;                            /* resolution layer of the input image */
    uint32_t xd;             /* size of the input image (resolution layer d) */
    uint32_t yd;
    uint32_t 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 */
    uint32_t l0;                     /* number of lines per stripe at lowest *
                                      * resolution layer 0                   */
    uint32_t stripes;         /* number of stripes required  (determ. by l0) */
    uint8_t **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;                               /* maximum ATMOVE window size */
    unsigned my;
    int *tx;       /* array [plane] with x-offset of adaptive template pixel */
    const uint8_t *dppriv;/* optional private deterministic prediction table */
    const char *res_tab;     /* table for the resolution reduction algorithm */
    struct t82_buf ****sde;      /* array [stripe][layer][plane] pointers to *
                                  * buffers for stored SDEs                  */
    struct t82_arenc_state *s;  /* array [planes] for arithm. encoder status */
    struct t82_buf *free_list; /* list of currently unused SDE block buffers */
    void (*data_out)(void *file, uint8_t *start, size_t len); /* data write callback */
    void *file;                            /* parameter passed to data_out() */
    char *tp;    /* buffer for temp. values used by diff. typical prediction */
} t82_tx_state_t;


/*! State of a single instance of a T.82 JBIG decoder */
typedef struct
{
    /* data from BIH */
    int d;                             /* resolution layer of the full image */
    int dl;                            /* first resolution layer in this BIE */
    uint32_t xd;              /* size of the full image (resolution layer d) */
    uint32_t yd;
    int planes;                         /* number of different bitmap planes */
    uint32_t l0;                     /* number of lines per stripe at lowest *
                                      * resolution layer 0                   */
    uint32_t stripes;         /* number of stripes required  (determ. by l0) */
    int order;                                    /* SDE ordering parameters */
    int options;                                      /* encoding parameters */
    int mx;                                    /* maximum ATMOVE window size */
    int my;
    const uint8_t *dppriv;/* optional private deterministic prediction table */

    /* loop variables */
    uint32_t 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.
     */
    uint8_t **lhp[2];

    /* status information */
    int **tx;         /* array [plane][layer-dl] with x,y-offset of AT pixel */
    int **ty;
    struct t82_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.           */
    uint32_t bie_len;                         /* number of bytes read so far */
    uint8_t buffer[20];       /* used to store BIH or marker segments fragm. */
    int buf_len;                                /* number of bytes in buffer */
    uint32_t comment_skip;           /* remaining bytes of a COMMENT segment */
    uint32_t x;                   /* x position of next pixel in current SDE */
    uint32_t i;      /* line in current SDE (first line of each stripe is 0) */
    int at_moves;                /* number of AT moves in the current stripe */
    uint32_t at_line[T82_ATMOVES_MAX];                /* lines at which an   *
                                                       * AT move will happen */
    int at_tx[T82_ATMOVES_MAX], at_ty[T82_ATMOVES_MAX]; /* ATMOVE offsets in *
                                                         * current stripe    */
    uint32_t line_h1;                            /* variables of decode_pscd */
    uint32_t line_h2;
    uint32_t line_h3;
    uint32_t line_l1;
    uint32_t line_l2;
    uint32_t 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 */

    uint32_t xmax;                    /* if possible abort before image gets */
    uint32_t ymax;                    /* larger than this size               */
    int dmax;                                      /* abort after this layer */
} t82_rx_state_t;

#if defined(__cplusplus)
extern "C" {
#endif

#ifdef TEST_CODEC
void arith_encode_init(struct t82_arenc_state *s, int reuse_st);
void arith_encode_flush(struct t82_arenc_state *s);
void arith_encode(struct t82_arenc_state *s, int cx, int pix);
void arith_decode_init(struct t82_ardec_state *s, int reuse_st);
int arith_decode(struct t82_ardec_state *s, int cx);
#endif

/* some macros (too trivial for a function) */
#define t82_dec_getplanes(s)     ((s)->planes)

void t82_enc_init(t82_tx_state_t *s,
                  uint32_t x,
                  uint32_t y,
                  int planes,
                  uint8_t **p,
                  void (*data_out)(void *file, uint8_t *start, size_t len),
                  void *file);
int t82_enc_lrlmax(t82_tx_state_t *s,
                   uint32_t mwidth,
                   uint32_t mheight);
void t82_enc_layers(t82_tx_state_t *s, int d);
int  t82_enc_lrange(t82_tx_state_t *s, int dl, int dh);
void t82_enc_options(t82_tx_state_t *s,
                     int order,
                     int options,
                     uint32_t l0,
                     int mx,
                     int my);
void t82_enc_out(t82_tx_state_t *s);
void t82_enc_free(t82_tx_state_t *s);

void t82_dec_init(t82_rx_state_t *s);
void t82_dec_maxsize(t82_rx_state_t *s,
                     uint32_t xmax,
                     uint32_t ymax);
int  t82_dec_in(t82_rx_state_t *s, uint8_t *data, size_t len,
                size_t *cnt);
long t82_dec_getwidth(const t82_rx_state_t *s);
long t82_dec_getheight(const t82_rx_state_t *s);
uint8_t *t82_dec_getimage(const t82_rx_state_t *s, int plane);
long t82_dec_getsize(const t82_rx_state_t *s);
void t82_dec_merge_planes(const t82_rx_state_t *s,
                          int use_graycode,
                          void (*data_out)(void *file, uint8_t *start, size_t len),
                          void *file);
long t82_dec_getsize_merged(const t82_rx_state_t *s);
void t82_dec_free(t82_rx_state_t *s);

const char *t82_strerror(int errnum, int language);
void t82_int2dppriv(uint8_t *dptable, const uint8_t *internal);
void t82_dppriv2int(uint8_t *internal, const uint8_t *dptable);
uint32_t t82_ceil_half(uint32_t x, int n);
void t82_split_planes(uint32_t x,
                      uint32_t y,
                      int has_planes,
                      int encode_planes,
                      const uint8_t *src,
                      const uint8_t **dest,
                      int use_graycode);
int t82_newlen(uint8_t bie[], size_t len);

#if defined(__cplusplus)
}
#endif

#endif
/*- End of file ------------------------------------------------------------*/