"

 COPYRIGHT (c) 1991 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libview' }"

"{ NameSpace: Smalltalk }"

Object subclass:#ImageReader

	instanceVariableNames:'width height data byteOrder inStream outStream photometric depth

		samplesPerPixel bitsPerSample colorMap mask maskPixel

		dimensionCallBack dimensionHolder progressHolder imageSequence

		metaData'

	classVariableNames:'BlackCountTable BlackShiftTable LeftBits ReverseBits

		WhiteCountTable WhiteShiftTable'

	poolDictionaries:''

	category:'Graphics-Images-Readers'

!

Query subclass:#EnforcedImageTypeQuery

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	privateIn:ImageReader

!

!ImageReader primitiveDefinitions!

%{

# define STDC_HEADERS

#ifndef _STDIO_H_INCLUDED_

# include <stdio.h>

# define _STDIO_H_INCLUDED_

#endif

#if defined(__osx__)

# include <stdlib.h>

# define _MALLOC_H_INCLUDED_

#endif

#ifndef _MALLOC_H_INCLUDED_

# if !defined(FREEBSD)

#  include <malloc.h>

#  define _MALLOC_H_INCLUDED_

# endif

#endif

%}

! !

!ImageReader primitiveFunctions!

%{

/*

 * ccitt decompression

 */

static short *whiteCountTable;

static char  *whiteShiftTable;

static short *blackCountTable;

static char  *blackShiftTable;

struct ccitt_def {

    unsigned short bits;

    short nBits;

};

static struct ccitt_def

whiteDef[] = {

    { 0x3500, 8 }, /* 0 */

    { 0x1c00, 6 },

    { 0x7000, 4 },

    { 0x8000, 4 },

    { 0xb000, 4 },

    { 0xc000, 4 },

    { 0xe000, 4 },

    { 0xf000, 4 },

    { 0x9800, 5 },

    { 0xA000, 5 },

    { 0x3800, 5 }, /* 10 */

    { 0x4000, 5 },

    { 0x2000, 6 },

    { 0x0c00, 6 },

    { 0xd000, 6 },

    { 0xd400, 6 },

    { 0xa800, 6 },

    { 0xac00, 6 },

    { 0x4e00, 7 },

    { 0x1800, 7 },

    { 0x1000, 7 }, /* 20 */

    { 0x2e00, 7 },

    { 0x0600, 7 },

    { 0x0800, 7 },

    { 0x5000, 7 },

    { 0x5600, 7 },

    { 0x2600, 7 },

    { 0x4800, 7 },

    { 0x3000, 7 },

    { 0x0200, 8 },

    { 0x0300, 8 }, /* 30 */

    { 0x1a00, 8 },

    { 0x1b00, 8 },

    { 0x1200, 8 },

    { 0x1300, 8 },

    { 0x1400, 8 },

    { 0x1500, 8 },

    { 0x1600, 8 },

    { 0x1700, 8 },

    { 0x2800, 8 },

    { 0x2900, 8 }, /* 40 */

    { 0x2a00, 8 },

    { 0x2b00, 8 },

    { 0x2c00, 8 },

    { 0x2d00, 8 },

    { 0x0400, 8 },

    { 0x0500, 8 },

    { 0x0a00, 8 },

    { 0x0b00, 8 },

    { 0x5200, 8 },

    { 0x5300, 8 }, /* 50 */

    { 0x5400, 8 },

    { 0x5500, 8 },

    { 0x2400, 8 },

    { 0x2500, 8 },

    { 0x5800, 8 },

    { 0x5900, 8 },

    { 0x5a00, 8 },

    { 0x5b00, 8 },

    { 0x4a00, 8 },

    { 0x4b00, 8 }, /* 60 */

    { 0x3200, 8 },

    { 0x3300, 8 },

    { 0x3400, 8 },

/* ---------------- */

    { 0xd800, 5 }, /* 64 */

    { 0x9000, 5 }, /* 128 */

    { 0x5c00, 6 }, /* 192 */

    { 0x6e00, 7 }, /* 256 */

    { 0x3600, 8 }, /* 320 */

    { 0x3700, 8 },

    { 0x6400, 8 },

    { 0x6500, 8 },

    { 0x6800, 8 },

    { 0x6700, 8 }, /* 640 */

    { 0x6600, 9 }, /* 704 */

    { 0x6680, 9 },

    { 0x6900, 9 },

    { 0x6980, 9 },

    { 0x6a00, 9 },

    { 0x6a80, 9 },

    { 0x6b00, 9 },

    { 0x6b80, 9 },

    { 0x6c00, 9 },

    { 0x6c80, 9 },

    { 0x6d00, 9 },

    { 0x6d80, 9 },

    { 0x4c00, 9 },

    { 0x4c80, 9 },

    { 0x4d00, 9 }, /* 1600 */

    { 0x6000, 6 }, /* 1664 */

    { 0x4d80, 9 }, /* 1728 */

/* -------------------------------- */

    { 0x0100, 11 }, /* 1792 */

    { 0x0180, 11 },

    { 0x01a0, 11 }, /* 1920 */

    { 0x0120, 12 }, /* 1984 */

    { 0x0130, 12 },

    { 0x0140, 12 },

    { 0x0150, 12 },

    { 0x0160, 12 },

    { 0x0170, 12 },

    { 0x01c0, 12 },

    { 0x01d0, 12 },

    { 0x01e0, 12 },

    { 0x01f0, 12 }, /* 2560 */

/* -------------------------------- */

    { 0x0010, 12 }, /* EOL */

};

static struct ccitt_def

blackDef[] = {

    { 0x0dc0, 10 }, /* 0 */

    { 0x4000, 3 },

    { 0xc000, 2 },

    { 0x8000, 2 },

    { 0x6000, 3 },

    { 0x3000, 4 },

    { 0x2000, 4 },

    { 0x1800, 5 },

    { 0x1400, 6 },

    { 0x1000, 6 },

    { 0x0800, 7 }, /* 10 */

    { 0x0a00, 7 },

    { 0x0e00, 7 },

    { 0x0400, 8 },

    { 0x0700, 8 },

    { 0x0c00, 9 },

    { 0x05c0, 10 },

    { 0x0600, 10 },

    { 0x0200, 10 },

    { 0x0ce0, 11 },

    { 0x0d00, 11 }, /* 20 */

    { 0x0d80, 11 },

    { 0x06e0, 11 },

    { 0x0500, 11 },

    { 0x02e0, 11 },

    { 0x0300, 11 },

    { 0x0ca0, 12 },

    { 0x0cb0, 12 },

    { 0x0cc0, 12 },

    { 0x0cd0, 12 },

    { 0x0680, 12 }, /* 30 */

    { 0x0690, 12 },

    { 0x06a0, 12 },

    { 0x06b0, 12 },

    { 0x0d20, 12 },

    { 0x0d30, 12 },

    { 0x0d40, 12 },

    { 0x0d50, 12 },

    { 0x0d60, 12 },

    { 0x0d70, 12 },

    { 0x06c0, 12 }, /* 40 */

    { 0x06d0, 12 },

    { 0x0da0, 12 },

    { 0x0db0, 12 },

    { 0x0540, 12 },

    { 0x0550, 12 },

    { 0x0560, 12 },

    { 0x0570, 12 },

    { 0x0640, 12 },

    { 0x0650, 12 },

    { 0x0520, 12 }, /* 50 */

    { 0x0530, 12 },

    { 0x0240, 12 },

    { 0x0370, 12 },

    { 0x0380, 12 },

    { 0x0270, 12 },

    { 0x0280, 12 },

    { 0x0580, 12 },

    { 0x0590, 12 },

    { 0x02b0, 12 },

    { 0x02c0, 12 }, /* 60 */

    { 0x05a0, 12 },

    { 0x0660, 12 },

    { 0x0670, 12 },

/* ---------------- */

    { 0x03c0, 10 }, /* 64 */

    { 0x0c80, 12 }, /* 128 */

    { 0x0c90, 12 }, /* 192 */

    { 0x05b0, 12 }, /* 256 */

    { 0x0330, 12 }, /* 320 */

    { 0x0340, 12 },

    { 0x0350, 12 }, /* 448 */

    { 0x0360, 13 }, /* 512 */

    { 0x0368, 13 },

    { 0x0250, 13 }, /* 640 */

    { 0x0258, 13 }, /* 704 */

    { 0x0260, 13 },

    { 0x0268, 13 },

    { 0x0390, 13 },

    { 0x0398, 13 },

    { 0x03a0, 13 },

    { 0x03a8, 13 },

    { 0x03b0, 13 },

    { 0x03b8, 13 },

    { 0x0290, 13 },

    { 0x0298, 13 },

    { 0x02a0, 13 },

    { 0x02a8, 13 },

    { 0x02d0, 13 },

    { 0x02d8, 13 }, /* 1600 */

    { 0x0320, 13 }, /* 1664 */

    { 0x0328, 13 }, /* 1728 */

/* -------------------------------- */

};

static void

initCCITTTables() {

    register int cnt, bits, value;

    int nBits, index;

    if (whiteCountTable != (short *)0) return;

    whiteCountTable = (short *) malloc(sizeof(short) * 8192);

    if (! whiteCountTable) return;

    whiteShiftTable = (char *) malloc(sizeof(char) * 8192);

    if (! whiteShiftTable) {

	goto fail1;

    }

    blackCountTable = (short *) malloc(sizeof(short) * 8192);

    if (! blackCountTable) {

	goto fail2;

    }

    blackShiftTable = (char *) malloc(sizeof(char) * 8192);

    if (! blackShiftTable) {

	free(blackCountTable); blackCountTable = (short *)0;

fail2:

	free(whiteShiftTable); whiteShiftTable = (char *)0;

fail1:

	free(whiteCountTable); whiteCountTable = (short *)0;

	return;

    }

    for (index = 0; index < 8192; index++) {

	whiteCountTable[index] = -1;

	blackCountTable[index] = -1;

    }

    for (value = 0; value <= 63; value++) {

	nBits = whiteDef[value].nBits;

	bits = whiteDef[value].bits >> 3;

	for (cnt = 1 << (13 - nBits); cnt; cnt--, bits++) {

	    whiteCountTable[bits] = value;

	    whiteShiftTable[bits] = nBits;

	}

	nBits = blackDef[value].nBits;

	bits = blackDef[value].bits >> 3;

	for (cnt = 1 << (13 - nBits); cnt; cnt--, bits++) {

	    blackCountTable[bits] = value;

	    blackShiftTable[bits] = nBits;

	}

    }

    index = value;

    for (; value <= 1728; value += 64) {

	nBits = whiteDef[index].nBits;

	bits = whiteDef[index].bits >> 3;

	for (cnt = 1 << (13 - nBits); cnt; cnt--, bits++) {

	    whiteCountTable[bits] = value;

	    whiteShiftTable[bits] = nBits;

	}

	nBits = blackDef[index].nBits;

	bits = blackDef[index].bits >> 3;

	for (cnt = 1 << (13 - nBits); cnt; cnt--, bits++) {

	    blackCountTable[bits] = value;

	    blackShiftTable[bits] = nBits;

	}

	index++;

    }

    for (; value <= 2560; value += 64) {

	nBits = whiteDef[index].nBits;

	bits = whiteDef[index].bits >> 3;

	for (cnt = 1 << (13 - nBits); cnt; cnt--, bits++) {

	    whiteCountTable[bits] = value;

	    whiteShiftTable[bits] = nBits;

	    blackCountTable[bits] = value;

	    blackShiftTable[bits] = nBits;

	}

	index++;

    }

}

static short

leftBits[] = {

     0, 0x80, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC, 0xFE, 0xFF

};

static int

__decodeCCITTgroup3__(unsigned char *from, unsigned char *to, int len)

{

    register int cnt;

    register short *countPtr;

    register char *shiftPtr;

    unsigned int bits, bits13;

    int shift, outCount, nBitsLess13;

    int outBitOffset;

    int nLeft, t;

    if (! whiteCountTable) {

	initCCITTTables();

	if (! whiteCountTable) return 0; /* malloc failed */

    }

    countPtr = whiteCountTable;

    shiftPtr = whiteShiftTable;

    outCount = 0;

    outBitOffset = 0;

    bits = *from++;

    bits = (bits << 8) | *from++;

    nBitsLess13 = 3;

    for (;;) {

	bits13 = (bits >> nBitsLess13) & 0x1FFF;

	cnt = countPtr[bits13];

	if (cnt < 0) return 1;

	shift = shiftPtr[bits13];

	outCount += cnt;

	if (outCount > len) {

	    fprintf(stderr, "CCITT buffer overrun\n");

	    return 0;

	}

	if (countPtr == blackCountTable) {

	    /* toggle if it was a terminating code */

	    if (cnt < 64) {

		countPtr = whiteCountTable;

		shiftPtr = whiteShiftTable;

	    }

	    /* draw cnt black bits */

	    if (cnt) {

		if (outBitOffset) {

		    nLeft = 8 - outBitOffset;

		    if (cnt < nLeft) nLeft = cnt;

		    t = leftBits[nLeft] >> outBitOffset;

		    *to |= t;

		    cnt -= nLeft;

		    outBitOffset += nLeft;

		    if (outBitOffset >= 8) {

			to++;

			outBitOffset -= 8;

		    }

		}

		if (cnt > 256) {

		    while ((INT)to & 3) {

			*to++ = 0xFF;

			cnt -= 8;

		    }

#if __POINTER_SIZE__ == 8

		    while ((INT)to & 7) {

			*to++ = 0xFF;

			cnt -= 8;

		    }

		    while (cnt >= 64) {

			(*(INT *)to) = 0xFFFFFFFFFFFFFFFF;

			to += 8;

			cnt -= 64;

		    }

		    if (cnt >= 32) {

			(*(long *)to) = 0xFFFFFFFF;

			to += 4;

			cnt -= 32;

		    }

#else

		    while ((INT)to & 3) {

			*to++ = 0xFF;

			cnt -= 8;

		    }

		    while (cnt >= 32) {

			(*(long *)to) = 0xFFFFFFFF;

			to += 4;

			cnt -= 32;

		    }

#endif

		}

		while (cnt >= 8) {

		    *to++ = 0xFF;

		    cnt -= 8;

		}

		*to |= leftBits[cnt];

		outBitOffset += cnt;

	    }

	} else {

	    /* toggle if it was a terminating code */

	    if (cnt < 64) {

		countPtr = blackCountTable;

		shiftPtr = blackShiftTable;

	    }

	    /* skip cnt bits */

	    to += cnt >> 3;

	    outBitOffset += cnt & 7;

	    if (outBitOffset >= 8) {

		to++;

		outBitOffset -= 8;

	    }

	}

	if (outCount >= len) return 1;

	nBitsLess13 -= shift;

	while (nBitsLess13 < 0) {

	    bits = (bits << 8) | *from++;

	    nBitsLess13 += 8;

	}

    }

}

/*

 * LZW decompression

 */

struct buffer {

	struct buffer *prev;

	unsigned char chars[8192 - 4];

};

static int

__decodeLZW__(unsigned char *from, unsigned char *to, int inCount, int fromSize, int toSize)

{

    register unsigned code;

    unsigned char **strings;

    short *stringLen;

    struct buffer *scratchBuffer;

    struct buffer *newBuffer;

    unsigned char *scratchPtr;

    int nScratch;