unpack zips in src to better compression

sources/z-tools/trunk/zview/zvdi/color.c

@@ -0,0 +1,190 @@
+#include "..//general.h"
+#include "..//pic_load.h"
+#include "vdi.h"
+
+typedef struct 
+{
+	uint8 satur;
+	uint8 red, green, blue;
+} SRGB;
+
+static SRGB screen_colortab[256];
+
+
+/* prototype */
+void save_colors(void);
+int16 remap_color (int32 value);
+uint32 color_lookup ( uint32 rgb, int16 *trans);
+void cnvpal_mono ( IMGINFO info, DECDATA data);
+void cnvpal_1_2 (IMGINFO info, DECDATA data);
+void cnvpal_4_8( IMGINFO info, DECDATA data);
+void cnvpal_15( IMGINFO info, DECDATA data);
+void cnvpal_high( IMGINFO info, DECDATA data);
+void cnvpal_true( IMGINFO info, DECDATA data);
+
+
+static uint8 saturation (uint8 * rgb)
+{
+	uint8 satr;
+
+	if (rgb[0] >= rgb[1]) 
+	{
+		if (rgb[1] >= rgb[2])   
+			satr = rgb[0]   - rgb[2];
+		else if (rgb[0] > rgb[2]) 
+			satr = rgb[0]   - rgb[1];
+		else
+			satr = rgb[2]  - rgb[1];
+	} 
+	else if (rgb[1] >= rgb[2]) 
+	{
+		if (rgb[0] >= rgb[2])
+	    	satr = rgb[1] - rgb[2];
+		else
+			satr = rgb[1] - rgb[0];
+	} 
+	else 
+		satr = rgb[2]  - rgb[0];
+
+	return satr;
+}
+
+
+void save_colors(void)
+{
+	register int16  i;
+
+	for( i = 0; i < app.color; i++)
+	{
+		screen_colortab[i].red   = ((((int32)app.palette[i][0] << 8 ) - app.palette[i][0]) + 500) / 1000;
+		screen_colortab[i].green = ((((int32)app.palette[i][1] << 8 ) - app.palette[i][1]) + 500) / 1000;
+		screen_colortab[i].blue  = ((((int32)app.palette[i][2] << 8 ) - app.palette[i][2]) + 500) / 1000;
+		screen_colortab[i].satur = saturation ( &screen_colortab[i].red);
+	}
+}
+
+int16 remap_color (int32 value)
+{
+	int16 red   = ((uint8*)&value)[1];
+	int16 green = ((uint8*)&value)[2];
+	int16 blue  = ((uint8*)&value)[3];
+	int16 satur = saturation (((uint8*)&value) +1);
+	
+	int16  best_fit  = 0;
+	uint16 best_err  = 0xFFFFu;
+	int16  max_color = 1 << app.nplanes;
+	
+	int16 i = 0;
+	
+	value = ( value & 0x00FFFFFFl) | (( int32)satur << 24);
+	
+	do 
+	{
+		if ( *( int32*)&screen_colortab[i] == value) 
+		{
+			/* gotcha! */
+			best_fit = i;
+			break;
+		} 
+		else 
+		{
+			uint16 err = 
+			( red > screen_colortab[i].red ? red - screen_colortab[i].red : screen_colortab[i].red - red)
+			+ (green > screen_colortab[i].green ? green - screen_colortab[i].green : screen_colortab[i].green - green)
+			+ (blue  > screen_colortab[i].blue  ? blue  - screen_colortab[i].blue  : screen_colortab[i].blue - blue)
+			+ (satur > screen_colortab[i].satur ? satur - screen_colortab[i].satur : screen_colortab[i].satur - satur);
+			
+			if (err <= best_err) 
+			{
+				best_err = err;
+				best_fit = i;
+			}
+		}
+	} while (++i < max_color);
+	
+	return best_fit;
+}
+
+
+uint32 color_lookup ( uint32 rgb, int16 *trans)
+{
+	uint8 idx = ((rgb & ~0xFFuL) == ~0xFFuL ? rgb : remap_color (rgb));
+	return ( (( int32)(trans ? trans[idx] : idx) << 24) | (*(int32*)&screen_colortab[idx] & 0x00FFFFFFuL));
+}
+
+
+void cnvpal_mono ( IMGINFO info, DECDATA data)
+{
+/*	if ( info->indexed_color) 
+	{
+		uint32  bgnd, fgnd;
+		
+		bgnd = (((( int32)info->palette[0].red <<8) | info->palette[0].green) <<8) | info->palette[0].blue;
+		fgnd = (((( int32)info->palette[1].red <<8) | info->palette[1].green) <<8) | info->palette[1].blue;
+
+		data->Pixel[0] = remap_color ( bgnd);
+		data->Pixel[1] = remap_color ( fgnd);
+		
+	}
+	else 
+*/	{
+		data->Pixel[0] = G_WHITE;
+		data->Pixel[1] = G_BLACK;
+	}
+}
+
+
+void cnvpal_1_2 (IMGINFO info, DECDATA data)
+{
+	register int32 i;
+
+	for( i = 0; i < info->colors; i++)
+	{
+		data->Pixel[i] = ( int16)info->palette[i].red * 5 + ( int16)info->palette[i].green * 9 + (( int16)info->palette[i].blue << 1);
+	}
+}
+
+
+void cnvpal_4_8( IMGINFO info, DECDATA data)
+{
+	register int32 i;
+
+	for( i = 0; i < info->colors; i++)
+	{
+	    uint32 rgb = (((( int32)info->palette[i].red << 8) | info->palette[i].green) << 8) | info->palette[i].blue;
+		data->Pixel[i] = rgb | (( int32)pixel_val[remap_color ( rgb)] << 24);
+	}
+}
+
+
+void cnvpal_15( IMGINFO info, DECDATA data)
+{
+	register int32 i;
+
+	for( i = 0; i < info->colors; i++)
+	{
+		data->Pixel[i] = (( int16)( info->palette[i].red & 0xF8) << 7) | (( int16)( info->palette[i].green & 0xF8) << 2) | ( info->palette[i].blue >> 3);
+	}
+}
+
+
+void cnvpal_high( IMGINFO info, DECDATA data)
+{
+	register int32 i;
+
+	for( i = 0; i < info->colors; i++)
+	{
+		data->Pixel[i] = (( int16)( info->palette[i].red & 0xF8) << 8) | (( int16)( info->palette[i].green & 0xFC) << 3) | ( info->palette[i].blue >> 3);
+	}
+}
+
+
+void cnvpal_true ( IMGINFO info, DECDATA data)
+{
+	register int32 i;
+	
+	for( i = 0; i < info->colors; i++)
+	{
+		data->Pixel[i] = (((( int32)info->palette[i].red << 8) | info->palette[i].green) << 8) | info->palette[i].blue;
+	}
+}

sources/z-tools/trunk/zview/zvdi/color.h

@@ -0,0 +1,14 @@
+extern void 	save_colors( void);
+extern int16 	remap_color( int32 value);
+
+extern uint32 	color_lookup( uint32 rgb, int16 *trans);
+
+extern void 	cnvpal_mono( IMGINFO info, DECDATA data);
+extern void 	cnvpal_1_2( IMGINFO info, DECDATA data);
+extern void 	cnvpal_4_8( IMGINFO info, DECDATA data);
+extern void 	cnvpal_15( IMGINFO info, DECDATA data);
+extern void 	cnvpal_high( IMGINFO info, DECDATA data);
+extern void 	cnvpal_true( IMGINFO info, DECDATA data);
+
+extern void 	( *cnvpal_color)( IMGINFO, DECDATA);
+

sources/z-tools/trunk/zview/zvdi/dither.c

@@ -0,0 +1,61 @@
+#include	"../general.h"
+
+extern uint32 	cube216[216];
+extern uint32   graymap[32];
+
+/* prototype */
+inline uint8 dither_true ( uint8 * rgb, int16 * err, int8 ** buf);
+inline uint8 dither_gray( uint8 *gray, int16 *err, int8 **buf);
+
+inline uint8 ditherize_32 ( uint8 * rgb, int16 * err, int8 ** buf)
+{
+	int8 	*dth = *buf;
+	unsigned short  r    = (( err[0] += ( int16)dth[0] + rgb[1]) <= 42 ? 0 : err[0] >= 213 ? 5 : ( err[0] * 3) >> 7);
+	unsigned short  g    = (( err[1] += ( int16)dth[1] + rgb[2]) <= 42 ? 0 : err[1] >= 213 ? 5 : ( err[1] * 3) >> 7);
+	unsigned short  b    = (( err[2] += ( int16)dth[2] + rgb[3]) <= 42 ? 0 : err[2] >= 213 ? 5 : ( err[2] * 3) >> 7);
+	uint8 * irgb = ( uint8*)&cube216[( r * 6 + g) * 6 + b];
+	
+	err[0] -= irgb[1];
+	dth[0] =  ( err[0] <= -254 ? ( err[0] =- 127) : err[0] >= +254 ? ( err[0] =+ 127) : ( err[0] >>= 1));
+	err[1] -= irgb[2];
+	dth[1] =  ( err[1] <= -254 ? ( err[1] =- 127) : err[1] >= +254 ? ( err[1] =+ 127) : ( err[1] >>= 1));
+	err[2] -= irgb[3];
+	dth[2] =  ( err[2] <= -254 ? ( err[2] = -127) : err[2] >= +254 ? ( err[2] = +127) : ( err[2] >>= 1));
+	( *buf) += 3;
+	
+	return irgb[0];
+}
+
+
+inline uint8 dither_true ( uint8 * rgb, int16 * err, int8 ** buf)
+{
+	int8 	*dth = *buf;
+	unsigned short  r    = (( err[0] += ( int16)dth[0] + rgb[0]) <= 42 ? 0 : err[0] >= 213 ? 5 : ( err[0] * 3) >> 7);
+	unsigned short  g    = (( err[1] += ( int16)dth[1] + rgb[1]) <= 42 ? 0 : err[1] >= 213 ? 5 : ( err[1] * 3) >> 7);
+	unsigned short  b    = (( err[2] += ( int16)dth[2] + rgb[2]) <= 42 ? 0 : err[2] >= 213 ? 5 : ( err[2] * 3) >> 7);
+	uint8 * irgb = ( uint8*)&cube216[( r * 6 + g) * 6 + b];
+	
+	err[0] -= irgb[1];
+	dth[0] =  ( err[0] <= -254 ? ( err[0] =- 127) : err[0] >= +254 ? ( err[0] =+ 127) : ( err[0] >>= 1));
+	err[1] -= irgb[2];
+	dth[1] =  ( err[1] <= -254 ? ( err[1] =- 127) : err[1] >= +254 ? ( err[1] =+ 127) : ( err[1] >>= 1));
+	err[2] -= irgb[3];
+	dth[2] =  ( err[2] <= -254 ? ( err[2] = -127) : err[2] >= +254 ? ( err[2] = +127) : ( err[2] >>= 1));
+	( *buf) += 3;
+	
+	return irgb[0];
+}
+
+
+inline uint8 dither_gray( uint8 *gray, int16 *err, int8 **buf)
+{
+	int8 	*dth  		= *buf;
+	unsigned short idx  = (( err[0] += ( int16)dth[0] + gray[0]) <= 0x07 ? 0 : err[0] >= 0xF8 ? 0x1F : err[0] >> 3);
+	uint8 	*irgb 		= ( uint8*)&graymap[idx];
+	
+	err[0] -= irgb[1];
+	dth[0] =  ( err[0] <= -254 ? ( err[0] = -127) : err[0] >= +254 ? ( err[0] =+ 127) : ( err[0] >>= 1));
+	(*buf) += 1;
+	
+	return irgb[0];
+}

sources/z-tools/trunk/zview/zvdi/dither.h

@@ -0,0 +1,3 @@
+extern inline uint8 ditherize_32 ( uint8 * rgb, int16 * err, int8 ** buf);
+extern inline uint8 dither_true ( uint8 * rgb, int16 * err, int8 ** buf);
+extern inline uint8 dither_gray( uint8 *gray, int16 *err, int8 **buf);

sources/z-tools/trunk/zview/zvdi/p2c.c

@@ -0,0 +1,82 @@
+#include "../general.h"
+
+void ( *planar_to_chunky)( uint8 *in, uint8 *out, int16 width);
+
+
+inline void planar8_to_chunky8( uint8 *in, uint8 *out, int16 width)
+{
+	uint8		*l;
+	uint16		x, c, p0, p1, p2, p3, p4, p5, p6, p7;
+
+	for( x = 0, l = in; x < width; l += 16)
+	{
+		p0 = ( l[0] << 8)  | l[1]; 
+		p1 = ( l[2] << 8)  | l[3];
+		p2 = ( l[4] << 8)  | l[5];
+		p3 = ( l[6] << 8)  | l[7];
+		p4 = ( l[8] << 8)  | l[9]; 
+		p5 = ( l[10] << 8) | l[11];
+		p6 = ( l[12] << 8) | l[13];
+		p7 = ( l[14] << 8) | l[15];
+
+        for ( c = 0; c < 16; c++)
+        {
+     	   out[x++] = ((p0 >> 15) & 1) | ((p1 >> 14) & 2) | ((p2 >> 13) & 4) | ((p3 >> 12) & 8) |
+					  ((p4 >> 11) & 16) | ((p5 >> 10) & 32)| ((p6 >> 9) & 64) | ((p7 >> 8)  & 128);
+           p0 <<= 1;
+           p1 <<= 1;
+           p2 <<= 1;
+           p3 <<= 1;
+           p4 <<= 1;
+           p5 <<= 1;
+           p6 <<= 1;
+           p7 <<= 1;
+        }
+	}
+}
+
+
+inline void planar4_to_chunky8( uint8 *in, uint8 *out, int16 width)
+{
+	uint8		*l;
+	uint16		x, c, p0, p1, p2, p3;
+
+	for( x = 0, l = in; x < width; l += 8)
+	{
+		p0 = ( l[0] << 8)  | l[1]; 
+		p1 = ( l[2] << 8)  | l[3];
+		p2 = ( l[4] << 8)  | l[5];
+		p3 = ( l[6] << 8)  | l[7];
+
+        for ( c = 0; c < 16; c++)
+        {
+     	   out[x++] = ((p0 >> 15) & 1) | ((p1 >> 14) & 2) | ((p2 >> 13) & 4) | ((p3 >> 12) & 8);
+
+           p0 <<= 1;
+           p1 <<= 1;
+           p2 <<= 1;
+           p3 <<= 1;
+        }
+	}
+}
+
+
+inline void planar2_to_chunky8( uint8 *in, uint8 *out, int16 width)
+{
+	uint8		*l;
+	uint16		x, c, p0, p1;
+
+	for ( x = 0, l = in; x < width; l += 4)
+    {
+    	p0 = (l[0] << 8) | l[1];
+    	p1 = (l[2] << 8) | l[3];
+
+    	for (c = 0; c < 16; c++)
+        {
+    	    out[x++] = ((p0 >> 15) & 1) | ((p1 >> 14) & 2);
+            p0 <<= 1;
+            p1 <<= 1;
+        }
+    }
+}
+

sources/z-tools/trunk/zview/zvdi/p2c.h

@@ -0,0 +1,5 @@
+extern void ( *planar_to_chunky)( uint8 *in, uint8 *out, int16 width);
+extern void planar8_to_chunky8( uint8 *in, uint8 *out, int16 width);
+extern void planar4_to_chunky8( uint8 *in, uint8 *out, int16 width);
+extern void planar2_to_chunky8( uint8 *in, uint8 *out, int16 width);
+

sources/z-tools/trunk/zview/zvdi/pixel.c

@@ -0,0 +1,137 @@
+#include "../general.h"
+
+void  ( *getPixel)( int, int, uint32, uint8*, uint8*, uint8*, uint8*);
+void  ( *setPixel)( int, int, uint32, uint8, uint8, uint8, uint8*);
+
+
+void getPixel_32( int x, int y, uint32 line_size, uint8 *red, uint8 *green, uint8 *blue, uint8 *src)
+{
+	register uint8 *line_source = src + ( y * line_size) + ( x << 2);
+	
+	*red   = line_source[1];
+	*green = line_source[2];
+	*blue  = line_source[3];
+}
+
+
+void setPixel_32( int x, int y, uint32 line_size, uint8 red, uint8 green, uint8 blue, uint8 *dst)
+{
+	register uint32 *line_dst = ( uint32*)( dst + ( y * line_size));
+	
+	line_dst[x] = ((((uint32)red << 8) | green) << 8) | blue;	
+}
+
+
+void getPixel_32r( int x, int y, uint32 line_size, uint8 *red, uint8 *green, uint8 *blue, uint8 *src)
+{
+	register uint8 *line_source = src + ( y * line_size) + ( x << 2);
+	
+	*red   = line_source[2];
+	*green = line_source[1];
+	*blue  = line_source[0];
+}
+
+
+void setPixel_32r( int x, int y, uint32 line_size, uint8 red, uint8 green, uint8 blue, uint8 *dst)
+{
+	register uint32 *line_dst = ( uint32*)( dst + ( y * line_size));
+
+	line_dst[x] = (((((uint32)blue << 8) | green) << 8) | red) << 8;
+}
+
+
+void getPixel_32z( int x, int y, uint32 line_size, uint8 *red, uint8 *green, uint8 *blue, uint8 *src)
+{
+	register uint8 *line_source = src + ( y * line_size) + ( x << 2);
+	
+	*red   = line_source[0];
+	*green = line_source[1];
+	*blue  = line_source[2];
+}
+
+
+void setPixel_32z( int x, int y, uint32 line_size, uint8 red, uint8 green, uint8 blue, uint8 *dst)
+{
+	register uint32 *line_dst = ( uint32*)( dst + ( y * line_size));
+
+	line_dst[x] = (((((uint32)red << 8) | green) << 8) | blue) << 8;
+}
+
+
+void getPixel_24( int x, int y, uint32 line_size, uint8 *red, uint8 *green, uint8 *blue, uint8 *src)
+{
+	register uint8 *line_source = src + ( y * line_size) + ( x * 3);
+	
+	*red   = line_source[0];
+	*green = line_source[1];
+	*blue  = line_source[2];
+}
+
+
+void setPixel_24( int x, int y, uint32 line_size, uint8 red, uint8 green, uint8 blue, uint8 *dst)
+{
+	register uint8 *line_dst = dst + ( y * line_size) + ( x * 3);
+	
+	line_dst[0] = red;
+	line_dst[1] = green;
+	line_dst[2] = blue;	
+}
+
+
+void getPixel_24r( int x, int y, uint32 line_size, uint8 *red, uint8 *green, uint8 *blue, uint8 *src)
+{
+	register uint8 *line_source = src + ( y * line_size) + ( x * 3);
+	
+	*red   = line_source[2];
+	*green = line_source[1];
+	*blue  = line_source[0];
+}
+
+
+void setPixel_24r( int x, int y, uint32 line_size, uint8 red, uint8 green, uint8 blue, uint8 *dst)
+{
+	register uint8 *line_dst = dst + ( y * line_size) + ( x * 3);
+	
+	line_dst[2] = red;
+	line_dst[1] = green;
+	line_dst[0] = blue;	
+}
+
+
+void getPixel_16( int x, int y, uint32 line_size, uint8 *red, uint8 *green, uint8 *blue, uint8 *src)
+{
+	register uint16 *line_source = ( uint16*)( src + ( y * line_size) + ( x << 1));
+	register uint16 src16 = line_source[0];
+
+	*red   = (( src16 >> 11) & 0x001F) << 3; 
+    *green = (( src16 >> 5)  & 0x003F) << 2;
+    *blue  = (( src16)       & 0x001F) << 3;
+}
+
+
+void setPixel_16( int x, int y, uint32 line_size, uint8 red, uint8 green, uint8 blue, uint8 *dst)
+{
+	register uint16 *line_dst = ( uint16*)( dst + ( y * line_size));
+	
+	line_dst[x] = (((uint16)red & 0xF8) << 8) | (((uint16)green & 0xFC) << 3) | ( blue >> 3);
+}
+
+
+void getPixel_16r( int x, int y, uint32 line_size, uint8 *red, uint8 *green, uint8 *blue, uint8 *src)
+{
+	register uint16 *line_source = ( uint16*)( src + ( y * line_size) + ( x << 1));
+	register uint16 src16 = (line_source[0] >> 8) | (line_source[0] << 8);
+
+	*red   = (( src16 >> 11) & 0x001F) << 3; 
+    *green = (( src16 >> 5)  & 0x003F) << 2;
+    *blue  = (( src16)       & 0x001F) << 3;
+}
+
+
+void setPixel_16r( int x, int y, uint32 line_size, uint8 red, uint8 green, uint8 blue, uint8 *dst)
+{
+	register uint16 *line_dst	= ( uint16*)( dst + ( y * line_size));
+	register uint16  pix 		= (((uint16)red & 0xF8) << 8) | (((uint16)green & 0xFC) << 3) | ( blue >> 3);
+
+	line_dst[x] = (pix >> 8) | (pix << 8);
+}

sources/z-tools/trunk/zview/zvdi/pixel.h

@@ -0,0 +1,19 @@
+extern void  ( *getPixel)( int, int, uint32, uint8*, uint8*, uint8*, uint8*);
+extern void  ( *setPixel)( int, int, uint32, uint8, uint8, uint8, uint8*);
+
+extern void getPixel_32( int x, int y, uint32 line_size, uint8 *red, uint8 *green, uint8 *blue, uint8 *src);
+extern void setPixel_32( int x, int y, uint32 line_size, uint8 red, uint8 green, uint8 blue, uint8 *dst);
+extern void getPixel_32r( int x, int y, uint32 line_size, uint8 *red, uint8 *green, uint8 *blue, uint8 *src);
+extern void setPixel_32r( int x, int y, uint32 line_size, uint8 red, uint8 green, uint8 blue, uint8 *dst);
+extern void getPixel_32z( int x, int y, uint32 line_size, uint8 *red, uint8 *green, uint8 *blue, uint8 *src);
+extern void setPixel_32z( int x, int y, uint32 line_size, uint8 red, uint8 green, uint8 blue, uint8 *dst);
+extern void getPixel_24( int x, int y, uint32 line_size, uint8 *red, uint8 *green, uint8 *blue, uint8 *src);
+extern void setPixel_24( int x, int y, uint32 line_size, uint8 red, uint8 green, uint8 blue, uint8 *dst);
+extern void getPixel_24r( int x, int y, uint32 line_size, uint8 *red, uint8 *green, uint8 *blue, uint8 *src);
+extern void setPixel_24r( int x, int y, uint32 line_size, uint8 red, uint8 green, uint8 blue, uint8 *dst);
+extern void getPixel_16( int x, int y, uint32 line_size, uint8 *red, uint8 *green, uint8 *blue, uint8 *src);
+extern void setPixel_16( int x, int y, uint32 line_size, uint8 red, uint8 green, uint8 blue, uint8 *dst);
+extern void getPixel_16r( int x, int y, uint32 line_size, uint8 *red, uint8 *green, uint8 *blue, uint8 *src);
+extern void setPixel_16r( int x, int y, uint32 line_size, uint8 red, uint8 green, uint8 blue, uint8 *dst);
+
+

sources/z-tools/trunk/zview/zvdi/raster.h

@@ -0,0 +1,67 @@
+extern void raster_chunks ( uint8 *src, uint16 *dst, uint16 num, uint16 depth);
+
+#ifdef USE_ASM
+extern void raster_chunk4 (uint8 *src, uint16* dst, size_t num);
+extern void raster_chunk8 (uint8 *src, uint16* dst, size_t num);
+#else
+#define raster_chunk4(s,d,n)   raster_chunks ( s, d, n, 4)
+#define raster_chunk8(s,d,n)   raster_chunks ( s, d, n, 8)
+#endif
+
+extern void raster_mono ( DECDATA info, void * _dst);
+extern void raster_D1 ( DECDATA info, void * _dst);
+extern void dither_D1 ( DECDATA info, void * _dst);
+extern void gscale_D1 ( DECDATA info, void * _dst);
+
+extern void raster_D2 ( DECDATA info, void * _dst);
+extern void dither_D2 ( DECDATA info, void * _dst);
+extern void gscale_D2 ( DECDATA info, void * _dst);
+
+extern void raster_I4 ( DECDATA info, void * _dst);
+extern void dither_I4 ( DECDATA info, void * _dst);
+extern void gscale_I4 ( DECDATA info, void * _dst);
+
+extern void raster_I8 ( DECDATA info, void * _dst);
+extern void dither_I8 ( DECDATA info, void * _dst);
+extern void gscale_I8 ( DECDATA info, void * _dst);
+
+extern void raster_P8 ( DECDATA info, void * _dst);
+extern void dither_P8 ( DECDATA info, void * _dst);
+extern void gscale_P8 ( DECDATA info, void * _dst);
+
+extern void raster_15 ( DECDATA info, void * _dst);
+extern void dither_15 ( DECDATA info, void * _dst);
+extern void gscale_15 ( DECDATA info, void * _dst);
+
+extern void raster_15r ( DECDATA info, void * _dst);
+extern void dither_15r ( DECDATA info, void * _dst);
+extern void gscale_15r ( DECDATA info, void * _dst);
+
+extern void raster_16 ( DECDATA info, void * _dst);
+extern void dither_16 ( DECDATA info, void * _dst);
+extern void gscale_16 ( DECDATA info, void * _dst);
+
+extern void raster_16r ( DECDATA info, void * _dst);
+extern void dither_16r ( DECDATA info, void * _dst);
+extern void gscale_16r ( DECDATA info, void * _dst);
+
+extern void raster_24 ( DECDATA info, void * _dst);
+extern void dither_24 ( DECDATA info, void * _dst);
+extern void gscale_24 ( DECDATA info, void * _dst);
+
+extern void raster_24r ( DECDATA info, void * _dst);
+extern void dither_24r ( DECDATA info, void * _dst);
+extern void gscale_24r ( DECDATA info, void * _dst);
+
+extern void raster_32 ( DECDATA info, void * _dst);
+extern void dither_32 ( DECDATA info, void * _dst);
+extern void gscale_32 ( DECDATA info, void * _dst);
+
+extern void raster_32r ( DECDATA info, void * _dst);
+extern void dither_32r ( DECDATA info, void * _dst);
+extern void gscale_32r ( DECDATA info, void * _dst);
+
+extern void raster_32z ( DECDATA info, void * _dst);
+extern void dither_32z ( DECDATA info, void * _dst);
+extern void gscale_32z ( DECDATA info, void * _dst);
+

sources/z-tools/trunk/zview/zvdi/raster_resize.c

@@ -0,0 +1,147 @@
+#include "..//general.h"
+#include "..//pic_load.h"
+#include "dither.h"
+#include "raster.h"
+
+inline void resize_mono ( DECDATA info, void * _dst)
+{
+	uint8	*dst   	= _dst;
+	int16   width 	= info->DthWidth;
+	uint32  x     	= (info->IncXfx + 1) >> 4;
+	uint16  pixel 	= 0x80, chunk = 0;
+
+	do 
+	{
+		chunk |= ( info->RowBuf[x >> 16] & 1);
+		chunk <<= 1;		
+
+		if ( !--width || !(pixel >>= 1)) 
+		{
+			*(dst++) = chunk;
+			chunk    = 0;
+			pixel    = 0x80;
+		}
+		
+		x += ( info->IncXfx >> 3);
+
+	} while ( width);		
+}
+
+
+inline void resize_I4 ( DECDATA info, void * _dst)
+{
+	uint16 	*dst   	= _dst;
+	int16   width 	= info->DthWidth;
+	uint32  x     	= (info->IncXfx +1) >> 1;
+	uint8   buf[16];
+	int16  	n   	= 16;
+	uint8 	*tmp 	= buf;
+
+	do 
+	{
+		*(tmp++) = *( uint8*)&info->DstBuf[x >> 16];
+		
+		if (!--width || !--n) 
+		{
+			raster_chunk4( buf, dst, tmp - buf);
+			dst += 4;
+			n    = 16;
+			tmp  = buf;
+		}
+		x += info->IncXfx;
+		
+	} while ( width);
+}
+
+
+inline void resize_I8 ( DECDATA info, void * _dst)
+{
+	uint16 	*dst   		= _dst;
+	int16   width 		= info->DthWidth;
+	uint32  x     		= (info->IncXfx +1) >> 1;
+	uint8   buf[16];
+	int16  	n   		= 16;
+	uint8 	*tmp 		= buf;
+	
+	do 
+	{
+		*(tmp++) = *( uint8*)&info->DstBuf[x >> 16];
+		
+		if (!--width || !--n) 
+		{
+			raster_chunk8 (buf, dst, tmp - buf);
+			dst += 8;
+			n    = 16;
+			tmp  = buf;
+		}
+		x += info->IncXfx;
+		
+	} while (width);
+}
+
+
+inline void resize_P8(DECDATA info, void * _dst)
+{
+	uint8 	*dst  		= _dst;
+	int16   width 		= info->DthWidth;
+	uint32  x     		= (info->IncXfx + 1) >> 1;
+	
+	do 
+	{
+		uint8 *rgb = &info->RowBuf[x >> 16];
+		*(dst++) = *(rgb);
+		x += info->IncXfx;
+	} while (--width);
+}
+
+
+inline void resize_16(DECDATA info, void * _dst)
+{
+	uint8 	*dst  		= _dst;
+	int16   width 		= info->DthWidth;
+	uint32  x     		= (info->IncXfx + 1) >> 1;
+	
+	do 
+	{
+		uint8 *rgb = &info->RowBuf[(x >> 16) << 1];
+		*(dst++) = *(rgb++);
+		*(dst++) = *(rgb);
+		x += info->IncXfx;
+	} while (--width);
+}
+
+
+inline void resize_24(DECDATA info, void * _dst)
+{
+	uint8 	*dst  = _dst;
+	int16   width = info->DthWidth;
+	uint32  x     = (info->IncXfx + 1) >> 1;
+	
+	do 
+	{
+		uint8 * rgb = &info->RowBuf[(x >>16) * 3];
+		*(dst++) = *(rgb++);
+		*(dst++) = *(rgb++);
+		*(dst++) = *(rgb);
+		x += info->IncXfx;
+	} while (--width);
+}
+
+
+inline void resize_32( DECDATA info, void * _dst)
+{
+	uint8  *dst   = _dst;
+	int16   width = info->DthWidth;
+	uint32  x     = (info->IncXfx + 1) >> 1;
+	
+	do 
+	{
+		uint8 * rgb = &info->RowBuf[(x >> 16) << 2];
+		*(dst++) = *(rgb++);
+		*(dst++) = *(rgb++);
+		*(dst++) = *(rgb++);
+		*(dst++) = *(rgb);
+
+		x += info->IncXfx;
+	} while (--width);
+}

sources/z-tools/trunk/zview/zvdi/raster_resize.h

@@ -0,0 +1,8 @@
+extern void resize_mono( DECDATA info, void * _dst);
+extern void resize_I4( DECDATA info, void * _dst);
+extern void resize_I8( DECDATA info, void * _dst);
+extern void resize_P8( DECDATA info, void * _dst);
+extern void resize_16( DECDATA info, void * _dst);
+extern void resize_24( DECDATA info, void * _dst);
+extern void resize_32( DECDATA info, void * _dst);
+

sources/z-tools/trunk/zview/zvdi/vdi.c

@@ -0,0 +1,222 @@
+#include "../general.h"
+#include "../pic_load.h"
+#include "../pic_resize.h"
+#include "raster.h"
+#include "raster_resize.h"
+#include "color.h"
+#include "p2c.h"
+#include "pixel.h"
+#include <mint/cookie.h>
+
+int16 	pixel_val[256];
+uint32 	cube216[216];
+uint32  graymap[32];
+int16	planar = 0;
+
+extern void 	save_colors( void);
+
+/* prototype */
+int16 vdi_init ( void);
+
+int16 vdi_init( void)
+{
+	int16 		out[273] = { -1, }; 
+	int16 		depth;
+	boolean	  	reverse, z_trail;
+	long		dum;
+
+	if( !get_cookie( C_EdDI, (long*)&dum))
+		return( 0);
+	
+	vq_scrninfo ( app.handle, out);
+
+ 	if ( app.nplanes <= 8)
+	{
+		save_colors();
+		memcpy ( pixel_val, out + 16, 512);
+	}
+
+	depth 	= (( uint16)out[4] == 0x8000u ? 15 : out[2]);	/* bits per pixel used */
+	reverse = (out[16] < out[48]);							/* intel crap...       */
+	z_trail = (out[48] > 0);								/* bits are shifted to the right side */
+
+	if ( depth == 1) 
+	{	/* monochrome */
+		cnvpal_color = cnvpal_1_2;
+		raster_cmap  = raster_D1;
+		raster_true  = dither_D1;
+		raster_gray  = gscale_D1;	
+		resize 		 = resize_mono;
+	}
+	else if ( out[0] == 0) /* Planar */
+	{
+		planar = 1;
+
+		switch ( depth)
+		{
+			case 2:
+				cnvpal_color = cnvpal_1_2;
+				raster_cmap  = raster_D2;
+				raster_true  = dither_D2;
+				raster_gray  = gscale_D2;
+				planar_to_chunky = planar2_to_chunky8;
+				break;
+			case 4:
+				cnvpal_color = cnvpal_4_8;
+				raster_cmap  = raster_I4;
+				raster_true  = dither_I4;
+				raster_gray  = gscale_I4;
+				resize 		 = resize_I4;
+				planar_to_chunky = planar4_to_chunky8;
+				break;
+			case 8:
+				cnvpal_color = cnvpal_4_8;
+				raster_cmap  = raster_I8;
+				raster_true  = dither_I8;
+				raster_gray  = gscale_I8;
+				resize 		 = resize_I8;
+				planar_to_chunky = planar8_to_chunky8;
+				break;
+		}
+	}
+	else if ( out[0] == 2) /* chunky */
+		switch ( depth)
+		{
+			case  8:
+				cnvpal_color = cnvpal_4_8;
+				raster_cmap  = raster_P8;
+				raster_true  = dither_P8;
+				raster_gray  = gscale_P8;
+				resize 		 = resize_P8;	
+				break;
+
+			case 15: 
+				if (!(out[14] & 0x02)) 
+				{
+					cnvpal_color = cnvpal_15;
+
+					if (reverse) 
+					{
+						raster_cmap = raster_15r;
+						raster_gray = gscale_15r;
+						raster_true = dither_15r;
+					} 
+					else 
+					{
+						raster_cmap = raster_15;
+						raster_gray = gscale_15;
+						raster_true = dither_15;
+					}
+
+					resize = resize_16;	
+
+					break;
+				}
+
+			case 16:
+				cnvpal_color = cnvpal_high;
+
+				if (reverse) 
+				{
+					raster_cmap = raster_16r;
+					raster_gray = gscale_16r;
+					raster_true = dither_16r;
+					getPixel	= getPixel_16r;
+					setPixel	= setPixel_16r;
+				} 
+				else 
+				{
+					raster_cmap = raster_16;
+					raster_gray = gscale_16;
+					raster_true = dither_16;
+					getPixel	= getPixel_16;
+					setPixel	= setPixel_16;					
+				}
+
+				resize = resize_16;	
+
+				break;
+
+			case 24:
+				cnvpal_color = cnvpal_true;
+
+				if (reverse) 
+				{
+					raster_cmap = raster_24r;
+					raster_gray = gscale_24r;
+					raster_true = dither_24r;
+					getPixel	= getPixel_24r;
+					setPixel	= setPixel_24r;					
+				} 
+				else 
+				{
+					raster_cmap = raster_24;
+					raster_gray = gscale_24;
+					raster_true = dither_24;
+					getPixel	= getPixel_24;
+					setPixel	= setPixel_24;					
+				}
+
+				resize = resize_24;	
+
+				break;
+
+			case 32:
+				cnvpal_color = cnvpal_true;
+
+				if (reverse) 
+				{
+					raster_cmap = raster_32r;
+					raster_gray = gscale_32r;
+					raster_true = dither_32r;
+					getPixel	= getPixel_32r;
+					setPixel	= setPixel_32r;					
+				} 
+				else if( z_trail) 
+				{
+					raster_cmap = raster_32z;
+					raster_gray = gscale_32z;
+					raster_true = dither_32z;
+					getPixel	= getPixel_32z;
+					setPixel	= setPixel_32z;					
+				} 
+				else 
+				{
+					raster_cmap = raster_32;
+					raster_gray = gscale_32;
+					raster_true = dither_32;
+					getPixel	= getPixel_32;
+					setPixel	= setPixel_32;					
+				}
+
+				resize = resize_32;				
+
+				break;	
+		}
+
+	if (depth == 4 || depth == 8) 
+	{
+		uint32 * dst;
+		uint32   r, g, b;
+		dst = cube216;
+
+		for (r = 0x000000uL; r <= 0xFF0000uL; r += 0x330000uL) 
+		{
+			for (g = 0x000000uL; g <= 0x00FF00uL; g += 0x003300uL) 
+			{
+				for (b = 0x000000uL; b <= 0x0000FFuL; b += 0x000033uL) 
+				{
+					*(dst++) = color_lookup ( r | g | b, pixel_val);
+				}
+			}
+		}
+
+		dst = graymap;
+
+		for ( g = 0x000000uL; g <= 0xF8F8F8uL; g += 0x080808uL) 
+			*( dst++) = color_lookup ( g | (( g >> 5) & 0x030303uL), pixel_val);
+	}
+
+	return( 1);
+}
+

sources/z-tools/trunk/zview/zvdi/vdi.h

@@ -0,0 +1,6 @@
+extern int16 	pixel_val[256];
+extern uint32 	cube216[216];
+extern uint32	graymap[32];
+extern int16	planar;
+
+extern int16 vdi_init( void);