hg/stx-libview: comparison ImageReader.st

equal deleted inserted replaced

-:ad20df4aec7a
+:6357c181c178
 whiteCountTable = (short *) malloc(sizeof(short) * 8192);
 if (! whiteCountTable) return;
 whiteShiftTable = (char *) malloc(sizeof(char) * 8192);
 if (! whiteShiftTable) {
-goto fail1;
+	goto fail1;
 }
 blackCountTable = (short *) malloc(sizeof(short) * 8192);
 if (! blackCountTable) {
-goto fail2;
+	goto fail2;
 }
 blackShiftTable = (char *) malloc(sizeof(char) * 8192);
 if (! blackShiftTable) {
-free(blackCountTable); blackCountTable = (short *)0;
+	free(blackCountTable); blackCountTable = (short *)0;
 fail2:
-free(whiteShiftTable); whiteShiftTable = (char *)0;
+	free(whiteShiftTable); whiteShiftTable = (char *)0;
 fail1:
-free(whiteCountTable); whiteCountTable = (short *)0;
+	free(whiteCountTable); whiteCountTable = (short *)0;
-return;
+	return;
 }
 for (index = 0; index < 8192; index++) {
-whiteCountTable[index] = -1;
+	whiteCountTable[index] = -1;
-blackCountTable[index] = -1;
+	blackCountTable[index] = -1;
 }
 for (value = 0; value <= 63; value++) {
-nBits = whiteDef[value].nBits;
+	nBits = whiteDef[value].nBits;
-bits = whiteDef[value].bits >> 3;
+	bits = whiteDef[value].bits >> 3;
-for (cnt = 1 << (13 - nBits); cnt; cnt--, bits++) {
+	for (cnt = 1 << (13 - nBits); cnt; cnt--, bits++) {
-whiteCountTable[bits] = value;
+	    whiteCountTable[bits] = value;
-whiteShiftTable[bits] = nBits;
+	    whiteShiftTable[bits] = nBits;
-}
+	}
-nBits = blackDef[value].nBits;
+	nBits = blackDef[value].nBits;
-bits = blackDef[value].bits >> 3;
+	bits = blackDef[value].bits >> 3;
-for (cnt = 1 << (13 - nBits); cnt; cnt--, bits++) {
+	for (cnt = 1 << (13 - nBits); cnt; cnt--, bits++) {
-blackCountTable[bits] = value;
+	    blackCountTable[bits] = value;
-blackShiftTable[bits] = nBits;
+	    blackShiftTable[bits] = nBits;
-}
+	}
 }
 index = value;
 for (; value <= 1728; value += 64) {
-nBits = whiteDef[index].nBits;
+	nBits = whiteDef[index].nBits;
-bits = whiteDef[index].bits >> 3;
+	bits = whiteDef[index].bits >> 3;
-for (cnt = 1 << (13 - nBits); cnt; cnt--, bits++) {
+	for (cnt = 1 << (13 - nBits); cnt; cnt--, bits++) {
-whiteCountTable[bits] = value;
+	    whiteCountTable[bits] = value;
-whiteShiftTable[bits] = nBits;
+	    whiteShiftTable[bits] = nBits;
-}
+	}
-nBits = blackDef[index].nBits;
+	nBits = blackDef[index].nBits;
-bits = blackDef[index].bits >> 3;
+	bits = blackDef[index].bits >> 3;
-for (cnt = 1 << (13 - nBits); cnt; cnt--, bits++) {
+	for (cnt = 1 << (13 - nBits); cnt; cnt--, bits++) {
-blackCountTable[bits] = value;
+	    blackCountTable[bits] = value;
-blackShiftTable[bits] = nBits;
+	    blackShiftTable[bits] = nBits;
-}
+	}
-index++;
+	index++;
 }
 for (; value <= 2560; value += 64) {
-nBits = whiteDef[index].nBits;
+	nBits = whiteDef[index].nBits;
-bits = whiteDef[index].bits >> 3;
+	bits = whiteDef[index].bits >> 3;
-for (cnt = 1 << (13 - nBits); cnt; cnt--, bits++) {
+	for (cnt = 1 << (13 - nBits); cnt; cnt--, bits++) {
-whiteCountTable[bits] = value;
+	    whiteCountTable[bits] = value;
-whiteShiftTable[bits] = nBits;
+	    whiteShiftTable[bits] = nBits;
-blackCountTable[bits] = value;
+	    blackCountTable[bits] = value;
-blackShiftTable[bits] = nBits;
+	    blackShiftTable[bits] = nBits;
-}
+	}
-index++;
+	index++;
 }
 }
 static short
 leftBits[] = {
 outBitOffset = 0;
 bits = *from++;
 bits = (bits << 8) | *from++;
 nBitsLess13 = 3;
 for (;;) {
-bits13 = (bits >> nBitsLess13) & 0x1FFF;
+	bits13 = (bits >> nBitsLess13) & 0x1FFF;
-cnt = countPtr[bits13];
+	cnt = countPtr[bits13];
-if (cnt < 0) return 1;
+	if (cnt < 0) return 1;
-shift = shiftPtr[bits13];
+	shift = shiftPtr[bits13];
-outCount += cnt;
+	outCount += cnt;
-if (countPtr == blackCountTable) {
+	if (countPtr == blackCountTable) {
-/* toggle if it was a terminating code */
+	    /* toggle if it was a terminating code */
-if (cnt < 64) {
+	    if (cnt < 64) {
-countPtr = whiteCountTable;
+		countPtr = whiteCountTable;
-shiftPtr = whiteShiftTable;
+		shiftPtr = whiteShiftTable;
-}
+	    }
-/* draw cnt black bits */
+	    /* draw cnt black bits */
-if (cnt) {
+	    if (cnt) {
-if (outBitOffset) {
+		if (outBitOffset) {
-nLeft = 8 - outBitOffset;
+		    nLeft = 8 - outBitOffset;
-if (cnt < nLeft) nLeft = cnt;
+		    if (cnt < nLeft) nLeft = cnt;
-t = leftBits[nLeft] >> outBitOffset;
+		    t = leftBits[nLeft] >> outBitOffset;
-*to |= t;
+		    *to |= t;
-cnt -= nLeft;
+		    cnt -= nLeft;
-outBitOffset += nLeft;
+		    outBitOffset += nLeft;
-if (outBitOffset >= 8) {
+		    if (outBitOffset >= 8) {
-to++;
+			to++;
-outBitOffset -= 8;
+			outBitOffset -= 8;
-}
+		    }
-}
+		}
-if (cnt > 256) {
+		if (cnt > 256) {
-while ((INT)to & 3) {
+		    while ((INT)to & 3) {
-*to++ = 0xFF;
+			*to++ = 0xFF;
-cnt -= 8;
+			cnt -= 8;
-}
+		    }
 #if __POINTER_SIZE__ == 8
-while ((INT)to & 7) {
+		    while ((INT)to & 7) {
-*to++ = 0xFF;
+			*to++ = 0xFF;
-cnt -= 8;
+			cnt -= 8;
-}
+		    }
-while (cnt >= 64) {
+		    while (cnt >= 64) {
-(*(INT *)to) = 0xFFFFFFFFFFFFFFFF;
+			(*(INT *)to) = 0xFFFFFFFFFFFFFFFF;
-to += 8;
+			to += 8;
-cnt -= 64;
+			cnt -= 64;
-}
+		    }
-if (cnt >= 32) {
+		    if (cnt >= 32) {
-(*(long *)to) = 0xFFFFFFFF;
+			(*(long *)to) = 0xFFFFFFFF;
-to += 4;
+			to += 4;
-cnt -= 32;
+			cnt -= 32;
-}
+		    }
 #else
-while ((INT)to & 3) {
+		    while ((INT)to & 3) {
-*to++ = 0xFF;
+			*to++ = 0xFF;
-cnt -= 8;
+			cnt -= 8;
-}
+		    }
-while (cnt >= 32) {
+		    while (cnt >= 32) {
-(*(long *)to) = 0xFFFFFFFF;
+			(*(long *)to) = 0xFFFFFFFF;
-to += 4;
+			to += 4;
-cnt -= 32;
+			cnt -= 32;
-}
+		    }
 #endif
-}
+		}
-while (cnt >= 8) {
+		while (cnt >= 8) {
-*to++ = 0xFF;
+		    *to++ = 0xFF;
-cnt -= 8;
+		    cnt -= 8;
-}
+		}
-*to |= leftBits[cnt];
+		*to |= leftBits[cnt];
-outBitOffset += cnt;
+		outBitOffset += cnt;
-}
+	    }
-} else {
+	} else {
-/* toggle if it was a terminating code */
+	    /* toggle if it was a terminating code */
-if (cnt < 64) {
+	    if (cnt < 64) {
-countPtr = blackCountTable;
+		countPtr = blackCountTable;
-shiftPtr = blackShiftTable;
+		shiftPtr = blackShiftTable;
-}
+	    }
-/* skip cnt bits */
+	    /* skip cnt bits */
-to += cnt >> 3;
+	    to += cnt >> 3;
-outBitOffset += cnt & 7;
+	    outBitOffset += cnt & 7;
-if (outBitOffset >= 8) {
+	    if (outBitOffset >= 8) {
-to++;
+		to++;
-outBitOffset -= 8;
+		outBitOffset -= 8;
-}
+	    }
-}
+	}
-if (outCount >= len) return 1;
+	if (outCount >= len) return 1;
-nBitsLess13 -= shift;
+	nBitsLess13 -= shift;
-while (nBitsLess13 < 0) {
+	while (nBitsLess13 < 0) {
-bits = (bits << 8) | *from++;
+	    bits = (bits << 8) | *from++;
-nBitsLess13 += 8;
+	    nBitsLess13 += 8;
-}
+	}
 }
 }
 /*
 * LZW decompression
 */
 struct buffer {
-struct buffer *prev;
+	struct buffer *prev;
-unsigned char chars[8192 - 4];
+	unsigned char chars[8192 - 4];
 };
 static int
 __decodeLZW__(from, to, inCount, fromSize, toSize)
 unsigned char *from;
 scratchBuffer = (struct buffer *)malloc(sizeof(struct buffer));
 if (! scratchBuffer) return 0;
 strings = (unsigned char **)malloc(sizeof(unsigned char *) * 4096);
 if (! strings) {
-free(scratchBuffer);
+	free(scratchBuffer);
-return 0;
+	return 0;
 }
 stringLen = (short *)malloc(sizeof(short) * 4096);
 if (! stringLen) {
-free(strings);
+	free(strings);
-free(scratchBuffer);
+	free(scratchBuffer);
-return 0;
+	return 0;
 }
 scratchBuffer->prev = (struct buffer *)0;
 scratchPtr = scratchBuffer->chars;
 nScratch = sizeof(scratchBuffer->chars);
 for (i = 0; i < 256; i++) {
-*scratchPtr = i;
+	*scratchPtr = i;
-strings[i] = scratchPtr++;
+	strings[i] = scratchPtr++;
-stringLen[i] = 1;
+	stringLen[i] = 1;
 }
 nextCode = 258;
 nScratch -= 256;
 mask = 0x1FF;
 nBits = 0;
 bits = 0;
 while (inCount) {
-/* fetch code */
+	/* fetch code */
-while (nBits < codeLen) {
+	while (nBits < codeLen) {
-bits = (bits<<8) | *from++;
+	    bits = (bits<<8) | *from++;
-inCount--;
+	    inCount--;
-nBits += 8;
+	    nBits += 8;
-}
+	}
-shift = nBits - codeLen;
+	shift = nBits - codeLen;
-code = (bits >> shift) & mask;
+	code = (bits >> shift) & mask;
-bits &= ~(mask << shift);
+	bits &= ~(mask << shift);
-nBits -= codeLen;
+	nBits -= codeLen;
-if (code == 257) break;
+	if (code == 257) break;
-if (code == 256) {
+	if (code == 256) {
-if (! inCount)
+	    if (! inCount)
-break;
+		break;
-/* free stuff */
+	    /* free stuff */
-while (scratchBuffer->prev) {
+	    while (scratchBuffer->prev) {
-newBuffer = scratchBuffer;
+		newBuffer = scratchBuffer;
-scratchBuffer = scratchBuffer->prev;
+		scratchBuffer = scratchBuffer->prev;
-free(newBuffer);
+		free(newBuffer);
-}
+	    }
-/* reset everything */
+	    /* reset everything */
-scratchPtr = scratchBuffer->chars + 256;
+	    scratchPtr = scratchBuffer->chars + 256;
-nScratch = sizeof(scratchBuffer->chars) - 256;
+	    nScratch = sizeof(scratchBuffer->chars) - 256;
-codeLen = 9;
+	    codeLen = 9;
-nextCode = 258;
+	    nextCode = 258;
-mask = 0x1FF;
+	    mask = 0x1FF;
-/* fetch code */
+	    /* fetch code */
-while (nBits < codeLen) {
+	    while (nBits < codeLen) {
-bits = (bits<<8) | *from++;
+		bits = (bits<<8) | *from++;
-inCount--;
+		inCount--;
-nBits += 8;
+		nBits += 8;
-}
+	    }
-shift = nBits - codeLen;
+	    shift = nBits - codeLen;
-code = (bits >> shift) & mask;
+	    code = (bits >> shift) & mask;
-bits &= ~(mask << shift);
+	    bits &= ~(mask << shift);
-nBits -= codeLen;
+	    nBits -= codeLen;
-if (code == 257) break;
+	    if (code == 257) break;
-/* add to output */
+	    /* add to output */
-if (to >= toEnd) {
+	    if (to >= toEnd) {
-if (@global(InfoPrinting) == true) {
+		if (@global(InfoPrinting) == true) {
-console_fprintf(stderr, "ImageReader [warning]: LZW outBuffer overrun\n");
+		    console_fprintf(stderr, "ImageReader [warning]: LZW outBuffer overrun\n");
-}
+		}
-ret = 0;
+		ret = 0;
-break;
+		break;
-}
+	    }
-*to++ = code;
+	    *to++ = code;
-oldCode = code;
+	    oldCode = code;
-} else {
+	} else {
-if (code < nextCode) {
+	    if (code < nextCode) {
-/* writeString(string[code]) */
+		/* writeString(string[code]) */
-len = stringLen[code];
+		len = stringLen[code];
-bcopy(strings[code], to, len);
+		bcopy(strings[code], to, len);
-to += len;
+		to += len;
-if (oldCode != -1) {
+		if (oldCode != -1) {
-/* add( string[oldcode] + first(string[code]) ) */
+		    /* add( string[oldcode] + first(string[code]) ) */
-len = stringLen[oldCode] + 1;
+		    len = stringLen[oldCode] + 1;
-if (nScratch < len) {
+		    if (nScratch < len) {
-newBuffer = (struct buffer *)malloc(sizeof(struct buffer));
+			newBuffer = (struct buffer *)malloc(sizeof(struct buffer));
-if (! newBuffer) goto out;
+			if (! newBuffer) goto out;
-newBuffer->prev = scratchBuffer;
+			newBuffer->prev = scratchBuffer;
-scratchBuffer = newBuffer;
+			scratchBuffer = newBuffer;
-scratchPtr = scratchBuffer->chars;
+			scratchPtr = scratchBuffer->chars;
-nScratch = sizeof(scratchBuffer->chars);
+			nScratch = sizeof(scratchBuffer->chars);
-}
+		    }
-stringLen[nextCode] = len;
+		    stringLen[nextCode] = len;
-strings[nextCode] = scratchPtr;
+		    strings[nextCode] = scratchPtr;
-bcopy(strings[oldCode], scratchPtr, len-1);
+		    bcopy(strings[oldCode], scratchPtr, len-1);
-scratchPtr += len-1;
+		    scratchPtr += len-1;
-*scratchPtr++ = strings[code][0];
+		    *scratchPtr++ = strings[code][0];
-nScratch -= len;
+		    nScratch -= len;
-nextCode++;
+		    nextCode++;
-}
+		}
-} else {
+	    } else {
-if (oldCode == -1) {
+		if (oldCode == -1) {
-/* bad input */
+		    /* bad input */
-ret = 0;
+		    ret = 0;
-goto out;
+		    goto out;
-}
+		}
-/* writeString(string[oldCode] + first(string[oldCode]) ) */
+		/* writeString(string[oldCode] + first(string[oldCode]) ) */
-len = stringLen[oldCode];
+		len = stringLen[oldCode];
-if ((to+len) >= toEnd) {
+		if ((to+len) >= toEnd) {
-if (@global(InfoPrinting) == true) {
+		    if (@global(InfoPrinting) == true) {
-console_fprintf(stderr, "ImageReader [warning]: LZW outBuffer overrun\n");
+			console_fprintf(stderr, "ImageReader [warning]: LZW outBuffer overrun\n");
-}
+		    }
-ret = 0;
+		    ret = 0;
-goto out;
+		    goto out;
-}
+		}
-bcopy(strings[oldCode], to, len);
+		bcopy(strings[oldCode], to, len);
-to += len;
+		to += len;
-*to++ = strings[oldCode][0];
+		*to++ = strings[oldCode][0];
-/* add( string[oldcode] + first(string[oldCode]) ) */
+		/* add( string[oldcode] + first(string[oldCode]) ) */
-len++;
+		len++;
-if (nScratch < len) {
+		if (nScratch < len) {
-newBuffer = (struct buffer *)malloc(sizeof(struct buffer));
+		    newBuffer = (struct buffer *)malloc(sizeof(struct buffer));
-if (! newBuffer) goto out;
+		    if (! newBuffer) goto out;
-newBuffer->prev = scratchBuffer;
+		    newBuffer->prev = scratchBuffer;
-scratchBuffer = newBuffer;
+		    scratchBuffer = newBuffer;
-scratchPtr = scratchBuffer->chars;
+		    scratchPtr = scratchBuffer->chars;
-nScratch = sizeof(scratchBuffer->chars);
+		    nScratch = sizeof(scratchBuffer->chars);
-}
+		}
-stringLen[nextCode] = len;
+		stringLen[nextCode] = len;
-strings[nextCode] = scratchPtr;
+		strings[nextCode] = scratchPtr;
-bcopy(strings[oldCode], scratchPtr, len-1);
+		bcopy(strings[oldCode], scratchPtr, len-1);
-scratchPtr += len-1;
+		scratchPtr += len-1;
-*scratchPtr++ = strings[oldCode][0];
+		*scratchPtr++ = strings[oldCode][0];
-nScratch -= len;
+		nScratch -= len;
-nextCode++;
+		nextCode++;
-}
+	    }
-oldCode = code;
+	    oldCode = code;
-if (nextCode >= 511)
+	    if (nextCode >= 511) {
-if (nextCode == 511) {
+		if (nextCode == 511) {
-codeLen = 10;
+		    codeLen = 10;
-mask = 0x3FF;
+		    mask = 0x3FF;
-} else if (nextCode >= 1023)
+		} else if (nextCode >= 1023) {
-if (nextCode == 1023) {
+		    if (nextCode == 1023) {
-codeLen = 11;
+			codeLen = 11;
-mask = 0x7FF;
+			mask = 0x7FF;
-} else
+		    } else {
-if (nextCode == 2047) {
+			if (nextCode == 2047) {
-codeLen = 12;
+			    codeLen = 12;
-mask = 0xFFF;
+			    mask = 0xFFF;
-}
+			}
-}
+		    }
+		}
+	    }
+	}
 }
 out: ;
 /* free stuff */
 while (scratchBuffer) {
-newBuffer = scratchBuffer;
+	newBuffer = scratchBuffer;
-scratchBuffer = scratchBuffer->prev;
+	scratchBuffer = scratchBuffer->prev;
-free(newBuffer);
+	free(newBuffer);
 }
 free(strings);
 free(stringLen);
 if (from > fromEnd) {
-if (@global(InfoPrinting) == true) {
+	if (@global(InfoPrinting) == true) {
-console_fprintf(stderr, "ImageReader [warning]: LZW inBuffer overrun\n");
+	    console_fprintf(stderr, "ImageReader [warning]: LZW inBuffer overrun\n");
-}
+	}
-ret = 0;
+	ret = 0;
 }
 return ret;
 }
 /*
 * delta decoding (TIFF predictor = 2)
 */
-static
+static void
 __decodeDelta__(bytes, width, height)
 register unsigned char *bytes;
 {
-register w;
+	register w;
-unsigned char r, g, b;
+	unsigned char r, g, b;
-while (height--) {
+	while (height--) {
-r = g = b = 0;
+	    r = g = b = 0;
-for (w = width; w; w--) {
+	    for (w = width; w; w--) {
-r += *bytes;
+		r += *bytes;
-*bytes++ = r;
+		*bytes++ = r;
-g += *bytes;
+		g += *bytes;
-*bytes++ = g;
+		*bytes++ = g;
-b += *bytes;
+		b += *bytes;
-*bytes++ = b;
+		*bytes++ = b;
-}
+	    }
-}
+	}
 }
 /*
 * GIF decompression
 */
 int len;
 int endCode, clearCode, freeCode;
 int codeLen = initialCodeLen;
 unsigned char *fromEnd, *toEnd;
 static int ranges[] = {0, 1, 2, 4, 8, 16, 32, 64,
-128, 256, 512, 1024, 2048 };
+			   128, 256, 512, 1024, 2048 };
 fromEnd = from + fromSize;
 toEnd = to + toSize;
 if ((unsigned)codeLen > 12) {
-if (@global(InfoPrinting) == true) {
+	if (@global(InfoPrinting) == true) {
-console_fprintf(stderr, "ImageReader [warning]: GIF bad codelen (>12)\n");
+	    console_fprintf(stderr, "ImageReader [warning]: GIF bad codelen (>12)\n");
-}
+	}
-return 0;
+	return 0;
 }
 prefix = (unsigned short *)malloc(sizeof(short) * 4096);
 if (! prefix) return 0;
 suffix  = (unsigned short *)malloc(sizeof(short) * 4096);
 if (! suffix) {
-free(prefix);
+	free(prefix);
-return 0;
+	return 0;
 }
 outCode = (unsigned short *)malloc(sizeof(short) * 4096);
 if (! outCode) {
-free(prefix);
+	free(prefix);
-free(suffix);
+	free(suffix);
-return 0;
+	return 0;
 }
 clearCode = ranges[codeLen]; /* 256 */
 endCode = clearCode + 1;     /* 257 */
 freeCode = clearCode + 2;    /* 258 */
 maxCode = clearCode << 1;    /* 512 */
 mask = maxCode - 1;          /* 1FF */
 nBits = 0;
 bits = 0;
 while (inCount) {
-/* fetch code */
+	/* fetch code */
-while (nBits < codeLen) {
+	while (nBits < codeLen) {
-bits = bits | (*from++ << nBits);
+	    bits = bits | (*from++ << nBits);
-inCount--;
+	    inCount--;
-nBits += 8;
+	    nBits += 8;
-}
+	}
-if (inCount <= 0)
+	if (inCount <= 0)
-break;
+	    break;
-code = bits & mask;
+	code = bits & mask;
-bits >>= codeLen;
+	bits >>= codeLen;
-nBits -= codeLen;
+	nBits -= codeLen;
-if (code == endCode) break;
+	if (code == endCode) break;
-if (code == clearCode) {
+	if (code == clearCode) {
-if (inCount <= 0)
+	    if (inCount <= 0)
-break;
+		break;
-codeLen = initialCodeLen;
+	    codeLen = initialCodeLen;
-maxCode = clearCode<<1;
+	    maxCode = clearCode<<1;
-mask = maxCode - 1;
+	    mask = maxCode - 1;
-freeCode = clearCode + 2;
+	    freeCode = clearCode + 2;
-/* fetch code */
+	    /* fetch code */
-while (nBits < codeLen) {
+	    while (nBits < codeLen) {
-bits = bits | (*from++ << nBits);
+		bits = bits | (*from++ << nBits);
-inCount--;
+		inCount--;
-nBits += 8;
+		nBits += 8;
-}
+	    }
-if (inCount <= 0)
+	    if (inCount <= 0)
-break;
+		break;
-code = bits & mask;
+	    code = bits & mask;
-bits >>= codeLen;
+	    bits >>= codeLen;
-nBits -= codeLen;
+	    nBits -= codeLen;
-if (code == endCode) break;
+	    if (code == endCode) break;
-/* add to output */
+	    /* add to output */
-if (to >= toEnd) {
+	    if (to >= toEnd) {
-if (@global(InfoPrinting) == true) {
+		if (@global(InfoPrinting) == true) {
-console_fprintf(stderr, "ImageReader [warning]: GIF outBuffer overrun\n");
+		    console_fprintf(stderr, "ImageReader [warning]: GIF outBuffer overrun\n");
-}
+		}
-ret = 0;
+		ret = 0;
-break;
+		break;
-}
+	    }
-*to++ = code;
+	    *to++ = code;
-oldCode = fin = curCode = code;
+	    oldCode = fin = curCode = code;
-} else {
+	} else {
-curCode = inCode = code;
+	    curCode = inCode = code;
-if (curCode >= freeCode) {
+	    if (curCode >= freeCode) {
-curCode = oldCode;
+		curCode = oldCode;
-outCode[outCount++] = fin;
+		outCode[outCount++] = fin;
-}
+	    }
-while (curCode >= clearCode) {
+	    while (curCode >= clearCode) {
-if (outCount > 1024) {
+		if (outCount > 1024) {
-goto out;
+		    goto out;
-}
+		}
-/* debugging and protecting myself from overwrites */
+		/* debugging and protecting myself from overwrites */
-if (curCode >= 4096) {
+		if (curCode >= 4096) {
-if (@global(InfoPrinting) == true) {
+		    if (@global(InfoPrinting) == true) {
-console_fprintf(stderr, "ImageReader [warning]: GIF corrupted input (code > 4095)\n");
+			console_fprintf(stderr, "ImageReader [warning]: GIF corrupted input (code > 4095)\n");
-}
+		    }
-ret = 0;
+		    ret = 0;
-break;
+		    break;
-}
+		}
-outCode[outCount++] = suffix[curCode];
+		outCode[outCount++] = suffix[curCode];
-curCode = prefix[curCode];
+		curCode = prefix[curCode];
-}
+	    }
-fin = curCode;
+	    fin = curCode;
-outCode[outCount++] = fin;
+	    outCode[outCount++] = fin;
 #if 0
-if ((to+outCount) >= toEnd) {
+	    if ((to+outCount) >= toEnd) {
-if (@global(InfoPrinting) == true) {
+		if (@global(InfoPrinting) == true) {
-console_fprintf(stderr, "ImageReader [warning]: GIF outBuffer overrun\n");
+		    console_fprintf(stderr, "ImageReader [warning]: GIF outBuffer overrun\n");
-}
+		}
-ret = 0;
+		ret = 0;
-break;
+		break;
-}
+	    }
 #endif
-for (i = outCount - 1; i >= 0; i--) {
+	    for (i = outCount - 1; i >= 0; i--) {
-if (to >= toEnd) {
+		if (to >= toEnd) {
-if (@global(InfoPrinting) == true) {
+		    if (@global(InfoPrinting) == true) {
-console_fprintf(stderr, "ImageReader [warning]: GIF outBuffer overrun\n");
+			console_fprintf(stderr, "ImageReader [warning]: GIF outBuffer overrun\n");
-}
+		    }
-ret = 0;
+		    ret = 0;
-break;
+		    break;
-}
+		}
-*to++ = outCode[i];
+		*to++ = outCode[i];
-}
+	    }
-outCount = 0;
+	    outCount = 0;
-/* debugging and protecting myself from overwrites */
+	    /* debugging and protecting myself from overwrites */
-if (freeCode >= 4096) {
+	    if (freeCode >= 4096) {
-if (@global(InfoPrinting) == true) {
+		if (@global(InfoPrinting) == true) {
-console_fprintf(stderr, "ImageReader [warning]: GIF corrupted input (freeCode > 4095)\n");
+		    console_fprintf(stderr, "ImageReader [warning]: GIF corrupted input (freeCode > 4095)\n");
-}
+		}
-ret = 0;
+		ret = 0;
-break;
+		break;
-}
+	    }
-prefix[freeCode] = oldCode;
+	    prefix[freeCode] = oldCode;
-suffix[freeCode] = fin;
+	    suffix[freeCode] = fin;
-oldCode = inCode;
+	    oldCode = inCode;
-freeCode++;
+	    freeCode++;
-if (freeCode >= maxCode) {
+	    if (freeCode >= maxCode) {
-if (codeLen < 12) {
+		if (codeLen < 12) {
-codeLen++;
+		    codeLen++;
-maxCode *= 2;
+		    maxCode *= 2;
-mask = (1 << codeLen) - 1;
+		    mask = (1 << codeLen) - 1;
-}
+		}
-}
+	    }
-}
+	}
 }
 out: ;
 free(prefix);
 free(suffix);
 free(outCode);
 if (from > fromEnd) {
-if (@global(InfoPrinting) == true) {
+	if (@global(InfoPrinting) == true) {
-console_fprintf(stderr, "ImageReader [warning]: GIF inBuffer overrun\n");
+	    console_fprintf(stderr, "ImageReader [warning]: GIF inBuffer overrun\n");
-}
+	}
-ret = 0;
+	ret = 0;
 }
 return ret;
 }
 %}
 ImageReaderWriter classes.
 ImageReaders are created temporary to read an image from a stream.
 Normally, they are not directly used - instead, the image class is
 asked to read some file, and return an instance for it:
-Image fromFile:<someFileName>
+	Image fromFile:<someFileName>
 The Image class will guess the images format and forward the task to
 some concrete ImageReaderClass.
 If that class thinks, that the file's format is incorrect,
 other readers are tried until some reader class finds the file's format acceptable.
 Image readers read the stream and collect all relevant information internally.
 Once done with reading, the actual image object is created and
 data filled in from the imageReaders collected info.
 See the implementation of #fromStream: in concrete subclasses.
 The public interfaces are:
-<ConcreteReaderClass> fromFile:aFilename
+	 <ConcreteReaderClass> fromFile:aFilename
 or:
-<ConcreteReaderClass> fromStream:aStream
+	 <ConcreteReaderClass> fromStream:aStream
 If you add a new reader, don't forget to add the method #isValidImageFile:
 which should return true, if this reader supports reading a given file.
 If your new reader class supports writing files, don't forget to add
 #canRepresent:anImage and return true from this method.
 [See also:]
-Image Icon Form
+	Image Icon Form
 [author:]
-Claus Gittinger
+	Claus Gittinger
 "
 ! !
 !ImageReader class methodsFor:'instance creation'!
 Calls primitive c function for speed"
 %{
 if (__isByteArrayLike(srcBytes)
 && __isByteArray(dstBytes)
 && __bothSmallInteger(offset, count)) {
-if (__decodeCCITTgroup3__(__ByteArrayInstPtr(srcBytes)->ba_element,
+	if (__decodeCCITTgroup3__(__ByteArrayInstPtr(srcBytes)->ba_element,
-__ByteArrayInstPtr(dstBytes)->ba_element
+				  __ByteArrayInstPtr(dstBytes)->ba_element
-+ __intVal(offset) - 1,
+				  + __intVal(offset) - 1,
-__intVal(count))) {
+				  __intVal(count))) {
-RETURN ( self );
+	    RETURN ( self );
-}
+	}
 }
 %}
 .
 self primitiveFailed
 !
 %{
 if (__isByteArrayLike(srcBytes)
 && __isByteArray(dstBytes)
 && __bothSmallInteger(codeLen, offset)
 && __isSmallInteger(count)) {
-if (__decodeGIF__(__ByteArrayInstPtr(srcBytes)->ba_element,
+	if (__decodeGIF__(__ByteArrayInstPtr(srcBytes)->ba_element,
-__ByteArrayInstPtr(dstBytes)->ba_element
+			  __ByteArrayInstPtr(dstBytes)->ba_element
-+__intVal(offset) - 1,
+						+__intVal(offset) - 1,
-__intVal(count),
+			  __intVal(count),
-__intVal(codeLen),
+			  __intVal(codeLen),
-__byteArraySize(srcBytes),
+			  __byteArraySize(srcBytes),
-__byteArraySize(dstBytes)
+			  __byteArraySize(dstBytes)
-)) {
+			 )) {
-RETURN ( self );
+	    RETURN ( self );
-}
+	}
 }
 %}
 .
 self primitiveFailed
 !
 Calls primitive c function for speed"
 %{
 if (__isByteArrayLike(srcBytes)
 && __isByteArray(dstBytes)
 && __bothSmallInteger(offset, count)) {
-if (__decodeLZW__(__ByteArrayInstPtr(srcBytes)->ba_element,
+	if (__decodeLZW__(__ByteArrayInstPtr(srcBytes)->ba_element,
-__ByteArrayInstPtr(dstBytes)->ba_element
+			  __ByteArrayInstPtr(dstBytes)->ba_element
-+ __intVal(offset) - 1,
+					      + __intVal(offset) - 1,
-__intVal(count),
+			  __intVal(count),
-__byteArraySize(srcBytes),
+			  __byteArraySize(srcBytes),
-__byteArraySize(dstBytes)
+			  __byteArraySize(dstBytes)
-)) {
+			)) {
-RETURN ( self );
+	    RETURN ( self );
-}
+	}
 }
 %}
 .
 self primitiveFailed
 !
 dstOffs := dstOffset.
 i := 1.
 [i <= nIn] whileTrue:[
-b := srcBytes at:i.
+	b := srcBytes at:i.
-i := i + 1.
+	i := i + 1.
-b ~~ 16rFF ifTrue:[   "/ not a NOP
+	b ~~ 16rFF ifTrue:[   "/ not a NOP
-b <= 127 ifTrue:[
+	    b <= 127 ifTrue:[
-"/ 0..127 literal bytes
+		"/ 0..127 literal bytes
-n := b + 1.
+		n := b + 1.
-dstBytes replaceFrom:dstOffs to:dstOffs+n-1 with:srcBytes startingAt:i.
+		dstBytes replaceFrom:dstOffs to:dstOffs+n-1 with:srcBytes startingAt:i.
-i := i + n.
+		i := i + n.
-] ifFalse:[
+	    ] ifFalse:[
-"/ 128..254 a run
+		"/ 128..254 a run
-n := b - 125.
+		n := b - 125.
-v := srcBytes at:i.
+		v := srcBytes at:i.
-i := i + 1.
+		i := i + 1.
-dstBytes from:dstOffs to:dstOffs+n put:v.
+		dstBytes from:dstOffs to:dstOffs+n put:v.
-].
+	    ].
-dstOffs := dstOffs + n.
+	    dstOffs := dstOffs + n.
-]
+	]
 ].
 ^ dstOffs - dstOffset
 "Created: / 1.12.1997 / 18:39:23 / cg"
 "Modified: / 1.12.1997 / 18:49:58 / cg"
 dstOffs := dstStart.
 i := srcStart.
 nRemaining := outCount.
 [nRemaining > 0] whileTrue:[
-b := srcBytes at:i.
+	b := srcBytes at:i.
-i := i + 1.
+	i := i + 1.
-b ~~ 16rFF ifTrue:[   "/ not a NOP
+	b ~~ 16rFF ifTrue:[   "/ not a NOP
-b <= 127 ifTrue:[
+	    b <= 127 ifTrue:[
-"/ 0..127 literal bytes
+		"/ 0..127 literal bytes
-n := b + 1.
+		n := b + 1.
-dstBytes replaceFrom:dstOffs to:dstOffs+n-1 with:srcBytes startingAt:i.
+		dstBytes replaceFrom:dstOffs to:dstOffs+n-1 with:srcBytes startingAt:i.
-nRemaining := nRemaining - n.
+		nRemaining := nRemaining - n.
-i := i + n.
+		i := i + n.
-] ifFalse:[
+	    ] ifFalse:[
-"/ 128..254 a run
+		"/ 128..254 a run
-n := b - 125.
+		n := b - 125.
-v := srcBytes at:i.
+		v := srcBytes at:i.
-i := i + 1.
+		i := i + 1.
-dstBytes from:dstOffs to:dstOffs+n-1 put:v.
+		dstBytes from:dstOffs to:dstOffs+n-1 put:v.
-nRemaining := nRemaining - n.
+		nRemaining := nRemaining - n.
-].
+	    ].
-dstOffs := dstOffs + n.
+	    dstOffs := dstOffs + n.
-]
+	]
 ].
 ^ i-srcStart
 !
 decompressRLEFrom:srcBytes at:srcStartIndex into:dstBytes at:dstStartIndex increment:dstIncrement
 |bytes|
 bytes := ByteArray new:1000000.
 bytes replaceFrom:1 with:#[ 0 1 2 3 4 5 6 7 8 9 10 11 12].
 Time millisecondsToRun:[
-self swap:1000000 bytesFromRGB_to_BGR_in:bytes.
+	self swap:1000000 bytesFromRGB_to_BGR_in:bytes.
 ].
 bytes copyTo:10.
 "
 !
 The argument is a pixel data buffer (byteArray)"
 |t|
 %{  /* OPTIONAL */
 if (__isByteArray(data)
 && __isSmallInteger(nBytes)
 && __isSmallInteger(startIndex)) {
-int __nBytes = __intVal(nBytes);
+	int __nBytes = __intVal(nBytes);
-int __startOffset = __intVal(startIndex) - 1;
+	int __startOffset = __intVal(startIndex) - 1;
-int __dataSize = __byteArraySize(data);
+	int __dataSize = __byteArraySize(data);
-if ((__startOffset + __nBytes) <= __dataSize) {
+	if ((__startOffset + __nBytes) <= __dataSize) {
-int __lastIndex = __startOffset + __nBytes - 2;
+	    int __lastIndex = __startOffset + __nBytes - 2;
-unsigned char *__cp = __ByteArrayInstPtr(data)->ba_element + __startOffset;
+	    unsigned char *__cp = __ByteArrayInstPtr(data)->ba_element + __startOffset;
-int __i;
+	    int __i;
-unsigned char __t;
+	    unsigned char __t;
-for (__i=__startOffset; __i<__lastIndex; __i+=3, __cp+=3) {
+	    for (__i=__startOffset; __i<__lastIndex; __i+=3, __cp+=3) {
-__t = __cp[0];
+		__t = __cp[0];
-__cp[0] = __cp[2];
+		__cp[0] = __cp[2];
-__cp[2] = __t;
+		__cp[2] = __t;
-}
+	    }
-RETURN (true);
+	    RETURN (true);
-}
+	}
 }
 %}.
 1 to:(nBytes - 2) by:3 do:[:i |
-|ii|
+	|ii|
-ii := i + startIndex - 1.
+	ii := i + startIndex - 1.
-t := data at:ii.
+	t := data at:ii.
-data at:i put:(data at:ii+2).
+	data at:i put:(data at:ii+2).
-data at:ii+2 put:t
+	data at:ii+2 put:t
 ].
 "
 |bytes|
 |bytes|
 bytes := ByteArray new:1000000.
 bytes replaceFrom:1 with:#[ 0 1 2 3 4 5 6 7 8 9 10 11 12].
 Time millisecondsToRun:[
-self swap:1000000 bytesFromRGB_to_BGR_in:bytes.
+	self swap:1000000 bytesFromRGB_to_BGR_in:bytes.
 ].
 bytes copyTo:10.
 "
 ! !
 Return the image or nil (if unrecognized format or error)"
 |readerClass response|
 self == ImageReader ifTrue:[
-"select a reader supporting this file format"
+	"select a reader supporting this file format"
-readerClass := self readerClassForFilename:url asURL path.
+	readerClass := self readerClassForFilename:url asURL path.
-readerClass ~~ self ifTrue:[
+	readerClass ~~ self ifTrue:[
-^ readerClass fromURL:url.
+	    ^ readerClass fromURL:url.
-].
+	].
 ].
 response := HTTPInterface get:url.
 response isErrorResponse ifTrue:[
-self error:'failed to read url' mayProceed:true.
+	self error:'failed to read url' mayProceed:true.
-^ nil
+	^ nil
 ].
 ^ self fromBytes:(response data).
 "
 self fromURL:'http://www.lutece.paris.fr/tech/images/helloworld.png'
 so it can be asked with 'reader image')."
 |readerClass reader inStream|
 self == ImageReader ifTrue:[
-"select a reader supporting this file format"
+	"select a reader supporting this file format"
-readerClass := self readerClassForFilename:aFilename.
+	readerClass := self readerClassForFilename:aFilename.
-readerClass ~~ self ifTrue:[
+	readerClass ~~ self ifTrue:[
-^ readerClass readFile:aFilename.
+	    ^ readerClass readFile:aFilename.
-].
+	].
 ].
 inStream := self streamReadingFile:aFilename.
 inStream isNil ifTrue:[
-'ImageReader [warning]: file open error' errorPrintCR.
+	'ImageReader [warning]: file open error' errorPrintCR.
-^ nil
+	^ nil
 ].
 reader := self new.
 reader inStream:inStream.
 [
-reader fromStream:inStream.
+	reader fromStream:inStream.
 ] ensure:[
-inStream close.
+	inStream close.
 ].
 ^ reader
 "
 XPMReader readFile:'../../goodies/bitmaps/xpmBitmaps/misc_icons/BOOK.xpm'
 |mime reader|
 mime := aStringOrFilename asFilename mimeTypeFromName.
 mime isNil ifTrue:[
-mime := aStringOrFilename asFilename mimeTypeOfContents.
+	mime := aStringOrFilename asFilename mimeTypeOfContents.
 ].
 mime notNil ifTrue:[
-reader := MIMETypes imageReaderForType:mime.
+	reader := MIMETypes imageReaderForType:mime.
 ].
 reader isNil ifTrue:[
-"answer the reader when proceeding form this error"
+	"answer the reader when proceeding form this error"
-reader := ConversionError raiseRequestErrorString:(' - unsupported image type: ''%1''' bindWith:(mime ? aStringOrFilename asFilename suffix)).
+	reader := ConversionError raiseRequestErrorString:(' - unsupported image type: ''%1''' bindWith:(mime ? aStringOrFilename asFilename suffix)).
 ].
 ^ reader
 "
 self readerClassForFilename:('http://www.foo.bar/helloworld.png' asURL path)
 /*
 printf("outP: %x outEnd: %x sz: %d\n", __outP, outEnd, __byteArraySize(maskArray));
 */
 for (__y=__h; __y>0; __y--) {
-__outBits = 0;
+	__outBits = 0;
-__nOut = 8;
+	__nOut = 8;
-__nextOutRow = __outP + __bpr;
+	__nextOutRow = __outP + __bpr;
-for (__x=__w; __x>=8; __x-=8) {
+	for (__x=__w; __x>=8; __x-=8) {
-if (__inP[0] != __maskPixel) { __outBits |= 0x80; };
+	    if (__inP[0] != __maskPixel) { __outBits |= 0x80; };
-if (__inP[1] != __maskPixel) { __outBits |= 0x40; };
+	    if (__inP[1] != __maskPixel) { __outBits |= 0x40; };
-if (__inP[2] != __maskPixel) { __outBits |= 0x20; };
+	    if (__inP[2] != __maskPixel) { __outBits |= 0x20; };
-if (__inP[3] != __maskPixel) { __outBits |= 0x10; };
+	    if (__inP[3] != __maskPixel) { __outBits |= 0x10; };
-if (__inP[4] != __maskPixel) { __outBits |= 0x08; };
+	    if (__inP[4] != __maskPixel) { __outBits |= 0x08; };
-if (__inP[5] != __maskPixel) { __outBits |= 0x04; };
+	    if (__inP[5] != __maskPixel) { __outBits |= 0x04; };
-if (__inP[6] != __maskPixel) { __outBits |= 0x02; };
+	    if (__inP[6] != __maskPixel) { __outBits |= 0x02; };
-if (__inP[7] != __maskPixel) { __outBits |= 0x01; };
+	    if (__inP[7] != __maskPixel) { __outBits |= 0x01; };
-__inP += 8;
+	    __inP += 8;
-*__outP++ = __outBits;
+	    *__outP++ = __outBits;
-__outBits = 0;
+	    __outBits = 0;
-}
+	}
-for (; __x>0; __x--) {
+	for (; __x>0; __x--) {
-__outBits <<= 1;
+	    __outBits <<= 1;
-if (*__inP != __maskPixel) {
+	    if (*__inP != __maskPixel) {
-__outBits |= 1;
+		__outBits |= 1;
-}
+	    }
-__inP++;
+	    __inP++;
 /*
 printf("x: %d  bits: %x\n", __x, __outBits);
 */
-if (--__nOut == 0) {
+	    if (--__nOut == 0) {
 #ifdef DEBUG
-if (__outP >= outEnd) {
+		if (__outP >= outEnd) {
-if (@global(InfoPrinting) == true) {
+		    if (@global(InfoPrinting) == true) {
-console_fprintf(stderr, "oops %d\n", __LINE__);
+			console_fprintf(stderr, "oops %d\n", __LINE__);
-}
+		    }
-goto fail;
+		    goto fail;
-}
+		}
 #endif
-*__outP = __outBits;
+		*__outP = __outBits;
-__outP++;
+		__outP++;
-__nOut = 8;
+		__nOut = 8;
-__outBits = 0;
+		__outBits = 0;
-}
+	    }
-}
+	}
-if (__nOut != 8) {
+	if (__nOut != 8) {
-__outBits <<= __nOut;
+	    __outBits <<= __nOut;
 #ifdef DEBUG
-if (__outP >= outEnd) {
+	    if (__outP >= outEnd) {
-if (@global(InfoPrinting) == true) {
+		if (@global(InfoPrinting) == true) {
-console_fprintf(stderr, "oops2 %d\n", __LINE__);
+		    console_fprintf(stderr, "oops2 %d\n", __LINE__);
-}
+		}
-goto fail;
+		goto fail;
-}
+	    }
 #endif
-*__outP = __outBits;
+	    *__outP = __outBits;
-}
+	}
-__outP = __nextOutRow;
+	__outP = __nextOutRow;
 }
 fail: ;
 %}.
 mask := ImageMask width:width height:height fromArray:maskArray.
 ^ mask
 photometric
 "return the photometric interpretation of the image data.
 This may be a somewhat old leftover from times, when tiff was the first image file type to be read.
 Much better would be to always have some (possibly fake and virtual) colormap around, and ask that one.
 However, in the meantime, many other classes depend on that, so that it should be kept as an API
 - even when the internal representation will be replaced by something better in the future."
 ^ photometric
 "Modified: 22.4.1996 / 19:15:57 / cg"
 |errorString|
 errorString := self class name , ' [info]: ' , aMessage.
 inStream isFileStream ifTrue:[
-errorString := errorString , ' [in ' , inStream pathName , ']'
+	errorString := errorString , ' [in ' , inStream pathName , ']'
 ].
 Image badImageFormatQuerySignal raiseRequestErrorString:errorString.
 ^ nil
 save:image onFile:aFileName
 "save image in my format on aFile"
 self writingFile:aFileName for:image do:[:stream |
-self save:image onStream:stream.
+	self save:image onStream:stream.
 ].
 "Modified: / 01-06-2010 / 19:02:17 / cg"
 !
 save:image onStream:aStream
 "save image in my format on a Stream"
 ^ Image cannotRepresentImageSignal
-raiseWith:image
+	raiseWith:image
-errorString:('image save not implemented/supported for this format').
+	errorString:('image save not implemented/supported for this format').
 !
 saveAll:aCollectionOfImages onFile:aFileName
 "save a collection of images in my format on aFile.
 Not all file formats support multiple images, so be prepared
 for an exception to be raised."
 self writingFile:aFileName for:aCollectionOfImages do:[:stream |
-self saveAll:aCollectionOfImages onStream:stream.
+	self saveAll:aCollectionOfImages onStream:stream.
 ].
 "Modified: / 01-06-2010 / 19:02:17 / cg"
 !
 "save an image collection in my format on a Stream.
 Not all file formats support multiple images, so be prepared
 for an exception to be raised."
 ^ Image cannotRepresentImageSignal
-raiseWith:aCollectionOfImages
+	raiseWith:aCollectionOfImages
-errorString:('save of imageSequence not implemented/supported for this format').
+	errorString:('save of imageSequence not implemented/supported for this format').
 !
 writingFile:aFileName for:something do:aBlock
 "helper for save image"
 |stream|
 [
-stream := aFileName asFilename newReadWriteStream.
+	stream := aFileName asFilename newReadWriteStream.
 ] on:FileStream openErrorSignal do:[:ex|
-^ Image fileCreationErrorSignal
+	^ Image fileCreationErrorSignal
-raiseWith:something
+	    raiseWith:something
-errorString:('file creation error: ' , aFileName asString).
+	    errorString:('file creation error: ' , aFileName asString).
 ].
 [
-[
+	[
-aBlock value: stream
+	    aBlock value: stream
-] ensure:[
+	] ensure:[
-stream close.
+	    stream close.
-].
+	].
 ] ifCurtailed:[
-OperatingSystem accessDeniedErrorSignal
+	OperatingSystem accessDeniedErrorSignal
-handle:[:ex |]
+	    handle:[:ex |]
-do:[
+	    do:[
-aFileName asFilename delete.
+		aFileName asFilename delete.
-]
+	    ]
 ].
 ! !
 !ImageReader methodsFor:'initialization'!
 ! !
 !ImageReader class methodsFor:'documentation'!
 version
-^ '$Header: /cvs/stx/stx/libview/ImageReader.st,v 1.114 2015-02-09 16:58:13 cg Exp $'
+^ '$Header$'
 !
 version_CVS
-^ '$Header: /cvs/stx/stx/libview/ImageReader.st,v 1.114 2015-02-09 16:58:13 cg Exp $'
+^ '$Header$'
 ! !

changeset 6902	6357c181c178
parent 6761	7307a75477f4
child 7142	439177d49d77