X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=image.c;h=529d7472e1e3425d489d33b993c82df77175ecef;hb=f2faeae42c59c7cd882f90a9617e7d6c5959ee76;hp=21e809ed8360ddd11a0c24f05261e578ef09c106;hpb=d7dc58ac2811c032a59852625bc2ca5edc245919;p=xonotic%2Fdarkplaces.git

diff --git a/image.c b/image.c
index 21e809ed..529d7472 100644
--- a/image.c
+++ b/image.c
@@ -300,7 +300,7 @@ LoadTGA
 */
 unsigned char *LoadTGA (const unsigned char *f, int filesize, int matchwidth, int matchheight)
 {
-	int x, y, row_inc, compressed, readpixelcount, red, green, blue, alpha, runlen, pindex, alphabits;
+	int x, y, pix_inc, row_inc, red, green, blue, alpha, runlen, alphabits;
 	unsigned char *pixbuf, *image_rgba;
 	const unsigned char *fin, *enddata;
 	unsigned char *p;
@@ -386,35 +386,35 @@ unsigned char *LoadTGA (const unsigned char *f, int filesize, int matchwidth, in
 	}
 
 	// check our pixel_size restrictions according to image_type
-	if (targa_header.image_type == 2 || targa_header.image_type == 10)
+	switch (targa_header.image_type & ~8)
 	{
+	case 2:
 		if (targa_header.pixel_size != 24 && targa_header.pixel_size != 32)
 		{
 			Con_Print("LoadTGA: only 24bit and 32bit pixel sizes supported for type 2 and type 10 images\n");
 			PrintTargaHeader(&targa_header);
 			return NULL;
 		}
-	}
-	else if (targa_header.image_type == 1 || targa_header.image_type == 9)
-	{
-		if (targa_header.pixel_size != 8)
+		break;
+	case 3:
+		// set up a palette to make the loader easier
+		for (x = 0;x < 256;x++)
 		{
-			Con_Print("LoadTGA: only 8bit pixel size for type 1, 3, 9, and 11 images supported\n");
-			PrintTargaHeader(&targa_header);
-			return NULL;
+			palette[x*4+2] = x;
+			palette[x*4+1] = x;
+			palette[x*4+0] = x;
+			palette[x*4+3] = 255;
 		}
-	}
-	else if (targa_header.image_type == 3 || targa_header.image_type == 11)
-	{
+		// fall through to colormap case
+	case 1:
 		if (targa_header.pixel_size != 8)
 		{
 			Con_Print("LoadTGA: only 8bit pixel size for type 1, 3, 9, and 11 images supported\n");
 			PrintTargaHeader(&targa_header);
 			return NULL;
 		}
-	}
-	else
-	{
+		break;
+	default:
 		Con_Printf("LoadTGA: Only type 1, 2, 3, 9, 10, and 11 targa RGB images supported, image_type = %i\n", targa_header.image_type);
 		PrintTargaHeader(&targa_header);
 		return NULL;
@@ -453,80 +453,215 @@ unsigned char *LoadTGA (const unsigned char *f, int filesize, int matchwidth, in
 		row_inc = 0;
 	}
 
-	compressed = targa_header.image_type == 9 || targa_header.image_type == 10 || targa_header.image_type == 11;
 	x = 0;
 	y = 0;
 	red = green = blue = alpha = 255;
-	while (y < image_height)
+	pix_inc = 1;
+	if ((targa_header.image_type & ~8) == 2)
+		pix_inc = targa_header.pixel_size / 8;
+	switch (targa_header.image_type)
 	{
-		// decoder is mostly the same whether it's compressed or not
-		readpixelcount = 1000000;
-		runlen = 1000000;
-		if (compressed && fin < enddata)
+	case 1: // colormapped, uncompressed
+	case 3: // greyscale, uncompressed
+		if (fin + image_width * image_height * pix_inc > enddata)
+			break;
+		for (y = 0;y < image_height;y++, pixbuf += row_inc)
 		{
-			runlen = *fin++;
-			// high bit indicates this is an RLE compressed run
-			if (runlen & 0x80)
-				readpixelcount = 1;
-			runlen = 1 + (runlen & 0x7f);
+			for (x = 0;x < image_width;x++)
+			{
+				p = palette + *fin++ * 4;
+				*pixbuf++ = p[0];
+				*pixbuf++ = p[1];
+				*pixbuf++ = p[2];
+				*pixbuf++ = p[3];
+			}
 		}
-
-		while((runlen--) && y < image_height)
+		break;
+	case 2:
+		// BGR or BGRA, uncompressed
+		if (fin + image_width * image_height * pix_inc > enddata)
+			break;
+		if (targa_header.pixel_size == 32 && alphabits)
 		{
-			if (readpixelcount > 0)
+			for (y = 0;y < image_height;y++, pixbuf += row_inc)
 			{
-				readpixelcount--;
-				red = green = blue = alpha = 255;
-				if (fin < enddata)
+				for (x = 0;x < image_width;x++, fin += pix_inc)
 				{
-					switch(targa_header.image_type)
+					*pixbuf++ = fin[2];
+					*pixbuf++ = fin[1];
+					*pixbuf++ = fin[0];
+					*pixbuf++ = fin[3];
+				}
+			}
+		}
+		else
+		{
+			for (y = 0;y < image_height;y++, pixbuf += row_inc)
+			{
+				for (x = 0;x < image_width;x++, fin += pix_inc)
+				{
+					*pixbuf++ = fin[2];
+					*pixbuf++ = fin[1];
+					*pixbuf++ = fin[0];
+					*pixbuf++ = 255;
+				}
+			}
+		}
+		break;
+	case 9: // colormapped, RLE
+	case 11: // greyscale, RLE
+		for (y = 0;y < image_height;y++, pixbuf += row_inc)
+		{
+			for (x = 0;x < image_width;)
+			{
+				if (fin >= enddata)
+					break; // error - truncated file
+				runlen = *fin++;
+				if (runlen & 0x80)
+				{
+					// RLE - all pixels the same color
+					runlen += 1 - 0x80;
+					if (fin + pix_inc > enddata)
+						break; // error - truncated file
+					if (x + runlen > image_width)
+						break; // error - line exceeds width
+					p = palette + *fin++ * 4;
+					red = p[0];
+					green = p[1];
+					blue = p[2];
+					alpha = p[3];
+					for (;runlen--;x++)
 					{
-					case 1:
-					case 9:
-						// colormapped
-						pindex = *fin++;
-						if (pindex >= targa_header.colormap_length)
-							pindex = 0; // error
-						p = palette + pindex * 4;
-						red = p[0];
-						green = p[1];
-						blue = p[2];
-						alpha = p[3];
-						break;
-					case 2:
-					case 10:
-						// BGR or BGRA
-						blue = *fin++;
-						if (fin < enddata)
-							green = *fin++;
-						if (fin < enddata)
-							red = *fin++;
-						if (targa_header.pixel_size == 32 && fin < enddata)
-							alpha = *fin++;
-						break;
-					case 3:
-					case 11:
-						// greyscale
-						red = green = blue = *fin++;
-						break;
+						*pixbuf++ = red;
+						*pixbuf++ = green;
+						*pixbuf++ = blue;
+						*pixbuf++ = alpha;
+					}
+				}
+				else
+				{
+					// uncompressed - all pixels different color
+					runlen++;
+					if (fin + pix_inc * runlen > enddata)
+						break; // error - truncated file
+					if (x + runlen > image_width)
+						break; // error - line exceeds width
+					for (;runlen--;x++)
+					{
+						p = palette + *fin++ * 4;
+						*pixbuf++ = p[0];
+						*pixbuf++ = p[1];
+						*pixbuf++ = p[2];
+						*pixbuf++ = p[3];
+					}
+				}
+			}
+		}
+		break;
+	case 10:
+		// BGR or BGRA, RLE
+		if (targa_header.pixel_size == 32 && alphabits)
+		{
+			for (y = 0;y < image_height;y++, pixbuf += row_inc)
+			{
+				for (x = 0;x < image_width;)
+				{
+					if (fin >= enddata)
+						break; // error - truncated file
+					runlen = *fin++;
+					if (runlen & 0x80)
+					{
+						// RLE - all pixels the same color
+						runlen += 1 - 0x80;
+						if (fin + pix_inc > enddata)
+							break; // error - truncated file
+						if (x + runlen > image_width)
+							break; // error - line exceeds width
+						red = fin[2];
+						green = fin[1];
+						blue = fin[0];
+						alpha = fin[3];
+						fin += pix_inc;
+						for (;runlen--;x++)
+						{
+							*pixbuf++ = red;
+							*pixbuf++ = green;
+							*pixbuf++ = blue;
+							*pixbuf++ = alpha;
+						}
+					}
+					else
+					{
+						// uncompressed - all pixels different color
+						runlen++;
+						if (fin + pix_inc * runlen > enddata)
+							break; // error - truncated file
+						if (x + runlen > image_width)
+							break; // error - line exceeds width
+						for (;runlen--;x++, fin += pix_inc)
+						{
+							*pixbuf++ = fin[2];
+							*pixbuf++ = fin[1];
+							*pixbuf++ = fin[0];
+							*pixbuf++ = fin[3];
+						}
 					}
-					if (!alphabits)
-						alpha = 255;
 				}
 			}
-			*pixbuf++ = red;
-			*pixbuf++ = green;
-			*pixbuf++ = blue;
-			*pixbuf++ = alpha;
-			x++;
-			if (x == image_width)
+		}
+		else
+		{
+			for (y = 0;y < image_height;y++, pixbuf += row_inc)
 			{
-				// end of line, advance to next
-				x = 0;
-				y++;
-				pixbuf += row_inc;
+				for (x = 0;x < image_width;)
+				{
+					if (fin >= enddata)
+						break; // error - truncated file
+					runlen = *fin++;
+					if (runlen & 0x80)
+					{
+						// RLE - all pixels the same color
+						runlen += 1 - 0x80;
+						if (fin + pix_inc > enddata)
+							break; // error - truncated file
+						if (x + runlen > image_width)
+							break; // error - line exceeds width
+						red = fin[2];
+						green = fin[1];
+						blue = fin[0];
+						alpha = 255;
+						fin += pix_inc;
+						for (;runlen--;x++)
+						{
+							*pixbuf++ = red;
+							*pixbuf++ = green;
+							*pixbuf++ = blue;
+							*pixbuf++ = alpha;
+						}
+					}
+					else
+					{
+						// uncompressed - all pixels different color
+						runlen++;
+						if (fin + pix_inc * runlen > enddata)
+							break; // error - truncated file
+						if (x + runlen > image_width)
+							break; // error - line exceeds width
+						for (;runlen--;x++, fin += pix_inc)
+						{
+							*pixbuf++ = fin[2];
+							*pixbuf++ = fin[1];
+							*pixbuf++ = fin[0];
+							*pixbuf++ = 255;
+						}
+					}
+				}
 			}
 		}
+		break;
+	default:
+		// unknown image_type
+		break;
 	}
 
 	return image_rgba;
@@ -666,17 +801,22 @@ imageformat_t imageformats_tenebrae[] =
 	{"override/%s.tga", LoadTGA},
 	{"override/%s.png", PNG_LoadImage},
 	{"override/%s.jpg", JPEG_LoadImage},
+	{"override/%s.pcx", LoadPCX},
 	{NULL, NULL}
 };
 
 imageformat_t imageformats_nopath[] =
 {
+	{"override/%s.tga", LoadTGA},
+	{"override/%s.png", PNG_LoadImage},
+	{"override/%s.jpg", JPEG_LoadImage},
 	{"textures/%s.tga", LoadTGA},
 	{"textures/%s.png", PNG_LoadImage},
 	{"textures/%s.jpg", JPEG_LoadImage},
 	{"%s.tga", LoadTGA},
 	{"%s.png", PNG_LoadImage},
 	{"%s.jpg", JPEG_LoadImage},
+	{"%s.pcx", LoadPCX},
 	{NULL, NULL}
 };
 
@@ -754,7 +894,8 @@ unsigned char *loadimagepixels (const char *filename, qboolean complain, int mat
 			Mem_Free(f);
 			if (data)
 			{
-				Con_DPrintf("loaded image %s (%dx%d)\n", name, image_width, image_height);
+				if (developer.integer >= 10)
+					Con_Printf("loaded image %s (%dx%d)\n", name, image_width, image_height);
 				if (developer_memorydebug.integer)
 					Mem_CheckSentinelsGlobal();
 				return data;
@@ -1221,6 +1362,12 @@ void Image_MipReduce(const unsigned char *in, unsigned char *out, int *width, in
 	if (*depth != 1 || destdepth != 1)
 	{
 		Con_Printf ("Image_Resample: 3D resampling not supported\n");
+		if (*width > destwidth)
+			*width >>= 1;
+		if (*height > destheight)
+			*height >>= 1;
+		if (*depth > destdepth)
+			*depth >>= 1;
 		return;
 	}
 	nextrow = *width * bytesperpixel;
@@ -1402,9 +1549,9 @@ void Image_HeightmapToNormalmap(const unsigned char *inpixels, unsigned char *ou
 			n[2] = ibumpscale;
 			VectorNormalize(n);
 			*/
-			out[0] = 128.0f + n[0] * 127.0f;
-			out[1] = 128.0f + n[1] * 127.0f;
-			out[2] = 128.0f + n[2] * 127.0f;
+			out[0] = (int)(128.0f + n[0] * 127.0f);
+			out[1] = (int)(128.0f + n[1] * 127.0f);
+			out[2] = (int)(128.0f + n[2] * 127.0f);
 			out[3] = (p0[0] + p0[1] + p0[2]) / 3;
 			out += 4;
 		}