hg/stx-libbasic: comparison ByteArray.st

equal deleted inserted replaced

-:17a819360ad5
+:0d75a92f1e56
 if ((__qClass(self) == @global(ByteArray))
 && (__qClass(aByteArray) == @global(ByteArray))
 && __isSmallInteger(nBitsPerPixel)
 && __bothSmallInteger(height, width)) {
-	if ((aMapByteArray != nil)
+if ((aMapByteArray != nil)
-	 && (__Class(aMapByteArray) == @global(ByteArray))) {
+&& (__Class(aMapByteArray) == @global(ByteArray))) {
-	    map = __ByteArrayInstPtr(aMapByteArray)->ba_element;
+map = __ByteArrayInstPtr(aMapByteArray)->ba_element;
-	} else {
+} else {
-	    map = (unsigned char *)0;
+map = (unsigned char *)0;
-	}
+}
-	bitsPerPixel = __intVal(nBitsPerPixel);
+bitsPerPixel = __intVal(nBitsPerPixel);
-	w = __intVal(width);
+w = __intVal(width);
-	h = __intVal(height);
+h = __intVal(height);
-	src = __ByteArrayInstPtr(self)->ba_element;
+src = __ByteArrayInstPtr(self)->ba_element;
-	dst = __ByteArrayInstPtr(aByteArray)->ba_element;
+dst = __ByteArrayInstPtr(aByteArray)->ba_element;
-	switch (bitsPerPixel) {
+switch (bitsPerPixel) {
-	    case 1:
+case 1:
-		mask = 0x01;
+mask = 0x01;
-		break;
+break;
-	    case 2:
+case 2:
-		mask = 0x03;
+mask = 0x03;
-		break;
+break;
-	    case 4:
+case 4:
-		mask = 0x0F;
+mask = 0x0F;
-		break;
+break;
-	    case 8:
+case 8:
-		mask = 0xFF;
+mask = 0xFF;
-		break;
+break;
-	    default:
+default:
-		printf("invalid depth in expandPixels\n");
+printf("invalid depth in expandPixels\n");
-		goto fail;
+goto fail;
-	}
+}
-	ncells = mask + 1;
+ncells = mask + 1;
-	if (map) {
+if (map) {
-	    /*
+/*
-	     * if a map is present, it must have the correct size
+* if a map is present, it must have the correct size
-	     * (i.e. 2 raisedTo:nBitsPerPixel)
+* (i.e. 2 raisedTo:nBitsPerPixel)
-	     */
+*/
-	    if ((__qSize(aMapByteArray) - OHDR_SIZE) < ncells) {
+if ((__qSize(aMapByteArray) - OHDR_SIZE) < ncells) {
-		printf("invalid map in expandPixels\n");
+printf("invalid map in expandPixels\n");
-		goto fail;
+goto fail;
-	    }
+}
-	}
+}
-	bytesPerRow = (w * bitsPerPixel + 7) / 8;
+bytesPerRow = (w * bitsPerPixel + 7) / 8;
-	shift0 = 8 - bitsPerPixel;
+shift0 = 8 - bitsPerPixel;
-	srcBytes = bytesPerRow * h;
+srcBytes = bytesPerRow * h;
-	dstBytes = w * h;
+dstBytes = w * h;
-	if ((__byteArraySize(self) >= srcBytes)
+if ((__byteArraySize(self) >= srcBytes)
-	 && (__byteArraySize(aByteArray) >= dstBytes)) {
+&& (__byteArraySize(aByteArray) >= dstBytes)) {
-	    for (hrun=h; hrun; hrun--) {
+for (hrun=h; hrun; hrun--) {
-		srcNext = src + bytesPerRow;
+srcNext = src + bytesPerRow;
-		shift = shift0;
+shift = shift0;
-		if (map) {
+if (map) {
-		    if (shift0 == 0) {
+if (shift0 == 0) {
-			/* translate only */
+/* translate only */
-			for (wrun=w; wrun; wrun--) {
+for (wrun=w; wrun; wrun--) {
-			    bits = *src++;
+bits = *src++;
-			    *dst++ = map[bits];
+*dst++ = map[bits];
-			}
+}
-		    } else {
+} else {
-			for (wrun=w; wrun; wrun--) {
+for (wrun=w; wrun; wrun--) {
-			    if (shift == shift0) {
+if (shift == shift0) {
-				bits = *src++;
+bits = *src++;
-			    }
+}
-			    *dst++ = map[(bits >> shift) & mask];
+*dst++ = map[(bits >> shift) & mask];
-			    shift -= bitsPerPixel;
+shift -= bitsPerPixel;
-			    if (shift < 0) {
+if (shift < 0) {
-				shift = shift0;
+shift = shift0;
-			    }
+}
-			}
+}
-		    }
+}
-		} else {
+} else {
-		    for (wrun=w; wrun; wrun--) {
+for (wrun=w; wrun; wrun--) {
-			if (shift == shift0) {
+if (shift == shift0) {
-			    bits = *src++;
+bits = *src++;
-			}
+}
-			*dst++ = (bits >> shift) & mask;
+*dst++ = (bits >> shift) & mask;
-			shift -= bitsPerPixel;
+shift -= bitsPerPixel;
-			if (shift < 0) {
+if (shift < 0) {
-			    shift = shift0;
+shift = shift0;
-			}
+}
-		    }
+}
-		}
+}
-		src = srcNext;
+src = srcNext;
-	    }
+}
-	    RETURN ( self );
+RETURN ( self );
-	}
+}
-	printf("buffer size: self:%d expect at least:%d\n",
+printf("buffer size: self:%d expect at least:%d\n",
-		__byteArraySize(self), srcBytes);
+__byteArraySize(self), srcBytes);
-	printf("buffer size: arg:%d expect at least:%d\n",
+printf("buffer size: arg:%d expect at least:%d\n",
-		__byteArraySize(aByteArray), dstBytes);
+__byteArraySize(aByteArray), dstBytes);
 }
 printf("invalid args\n");
 fail: ;
 %}.
 "
 "
 |inBits outBits|
 inBits := #[2r11110000
-		 2r11001100
+2r11001100
-		 2r01010101
+2r01010101
-		 2r00001111].
+2r00001111].
 outBits := ByteArray new:(8*4).
 inBits expandPixels:1 width:8 height:4
-		    into:outBits mapping:nil.
+into:outBits mapping:nil.
 outBits inspect
 "
 "Example2:
 expand bit-array into a byteArray, translating 0-bits to 99,
 |inBits outBits|
 inBits := #[2r11110000 2r11001100].
 outBits := ByteArray new:16.
 inBits expandPixels:1 width:16 height:1
-		    into:outBits mapping:#[99 176].
+into:outBits mapping:#[99 176].
 outBits inspect
 "
+"This Can also be used to extract nibbles ..."
+"
+|inBits outBits|
+inBits := #[ 16r12 16r34 16r56 16r78 16r9A 16rBC 16rDE 16rF0 ].
+outBits := ByteArray new:(inBits size * 2).
+inBits expandPixels:4 width:outBits size height:1 into:outBits mapping:nil.
+outBits inspect
+"
 !
 invert
 "invert all bytes - used with image manipulations
 written as a primitive for speed.
 ! !
 !ByteArray class methodsFor:'documentation'!
 version
-^ '$Header: /cvs/stx/stx/libbasic/ByteArray.st,v 1.132 1999-11-08 10:04:39 cg Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/ByteArray.st,v 1.133 1999-11-10 16:20:51 cg Exp $'
 ! !

changeset 4978	0d75a92f1e56
parent 4969	bd9f02a6a74f
child 4983	07e6aab900d9