// Generic PNG file loading code

// leave this as first line for PCH reasons...
//
#include "../game/q_shared.h"
#include "../qcommon/qcommon.h"

#include "../zlib32/zip.h"
#include "png.h"
//#include "../qcommon/memory.h"

// Error returns

#define PNG_ERROR_OK			0
#define PNG_ERROR_DECOMP		1
#define PNG_ERROR_COMP			2
#define PNG_ERROR_MEMORY		3
#define PNG_ERROR_NOSIG	   		4
#define PNG_ERROR_TOO_SMALL	   	5
#define PNG_ERROR_WNP2	   		6
#define PNG_ERROR_HNP2	   		7
#define PNG_ERROR_NOT_TC	   	8
#define PNG_ERROR_INV_FIL	   	9
#define PNG_ERROR_FAILED_CRC	10
#define PNG_ERROR_CREATE_FAIL	11
#define PNG_ERROR_WRITE			12
#define PNG_ERROR_NOT_PALETTE	13
#define PNG_ERROR_NOT8BIT		14
#define PNG_ERROR_TOO_LARGE		15

static int png_error = PNG_ERROR_OK;

static const byte png_signature[8] = { 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a };
static const char png_copyright[] = "Copyright\0Raven Software Inc. 2001";
static const char *png_errors[] = 
{
	"OK.",
	"Error decompressing image data.",
	"Error compressing image data.",
	"Error allocating memory.",
	"PNG signature not found.",
	"Image is too small to load.",
	"Width is not a power of two.",
	"Height is not a power of two.",
	"Image is not 24 or 32 bit.",
	"Invalid filter or compression type.",
	"Failed CRC check.",
	"Could not create file.",
	"Error writing to file.",
	"Image is not indexed colour.",
	"Image does not have 8 bits per sample.",
	"Image is too large",
};

// Gets the error string for a failed PNG operation

const char *PNG_GetError(void)
{
	return(png_errors[png_error]);
}

// Create a header chunk

void PNG_CreateHeader(png_ihdr_t *header, int width, int height, int bytedepth)
{
	header->width = BigLong(width);
	header->height = BigLong(height);
	header->bitdepth = 8;

	if(bytedepth == 3)
	{
		header->colortype = 2;
	}
	if(bytedepth == 4)
	{
		header->colortype = 6;
	}
	header->compression = 0;
	header->filter = 0;
	header->interlace = 0;
}

// Processes the header chunk and checks to see if all the data is valid

bool PNG_HandleIHDR(const byte *data, png_image_t *image)
{
	png_ihdr_t *ihdr = (png_ihdr_t *)data;

	image->width = BigLong(ihdr->width);
	image->height = BigLong(ihdr->height);

	// Make sure image is a reasonable size
	if((image->width < 2) || (image->height < 2))
	{
		png_error = PNG_ERROR_TOO_SMALL;
		return(false);
	}
	if(image->width > MAX_PNG_WIDTH)
	{
		png_error = PNG_ERROR_TOO_LARGE;
		return(false);
	}
	if(ihdr->bitdepth != 8)
	{
		png_error = PNG_ERROR_NOT8BIT;
		return(false);
	}
	// Check for non power of two size (but not for data files)
	if(image->isimage)
	{
		if(image->width & (image->width - 1))
		{
			png_error = PNG_ERROR_WNP2;
			return(false);
		}
		if(image->height & (image->height - 1))
		{
			png_error = PNG_ERROR_HNP2;
			return(false);
		}
	}
	// Make sure we have a 24 or 32 bit image (for images)
	if(image->isimage)
	{
		if((ihdr->colortype != 2) && (ihdr->colortype != 6))
		{
			png_error = PNG_ERROR_NOT_TC;
			return(false);
		}
	}
	// Make sure we have an 8 bit grayscale image for data files
	if(!image->isimage)
	{
		if(ihdr->colortype && (ihdr->colortype != 3))
		{
			png_error = PNG_ERROR_NOT_PALETTE;
			return(false);
		}
	}
	// Make sure we aren't using any wacky compression or filter algos
	if(ihdr->compression || ihdr->filter)
	{
		png_error = PNG_ERROR_INV_FIL;
		return(false);
	}
	// Extract the data we need
	if(!ihdr->colortype || (ihdr->colortype == 3))
	{
		image->bytedepth = 1;
	}
	if(ihdr->colortype == 2)
	{
		image->bytedepth = 3;
	}
	if(ihdr->colortype == 6)
	{
		image->bytedepth = 4;
	}
	return(true);
}

// Filter a row of data

void PNG_Filter(byte *out, byte filter, const byte *in, const byte *lastline, uint32_t rowbytes, uint32_t bpp)
{
	uint32_t		i;

	switch(filter)
	{
	case PNG_FILTER_VALUE_NONE:
		memcpy(out, in, rowbytes);
		break;
	case PNG_FILTER_VALUE_SUB:
		for(i = 0; i < bpp; i++)
		{
			*out++ = *in++;
		}
		for(i = bpp; i < rowbytes; i++)
		{
			*out++ = *in - *(in - bpp);
			in++;
		}
		break;
	case PNG_FILTER_VALUE_UP:
		for(i = 0; i < rowbytes; i++)
		{
			if(lastline)
			{
				*out++ = *in++ - *lastline++;
			}
			else
			{
				*out++ = *in++;
			}
		}
		break;
	case PNG_FILTER_VALUE_AVG:
		for(i = 0; i < bpp; i++)
		{
			if(lastline)
			{
				*out++ = *in++ - (*lastline++ >> 1);
			}
			else
			{
				*out++ = *in++;
			}
		}
		for(i = bpp; i < rowbytes; i++)
		{
			if(lastline)
			{
				*out++ = *in - ((*lastline++ + *(in - bpp)) >> 1);
			}
			else
			{
				*out++ = *in - (*(in - bpp) >> 1);
			}
			in++;
		}
		break;
	case PNG_FILTER_VALUE_PAETH:
		int			a, b, c;
		int			pa, pb, pc, p;

		for(i = 0; i < bpp; i++)
		{
			if(lastline)
			{
				*out++ = *in++ - *lastline++;
			}
			else
			{
				*out++ = *in++;
			}
		}
		for(i = bpp; i < rowbytes; i++)
		{
			a = *(in - bpp);
			c = 0;
			b = 0;
			if(lastline)
			{
				c = *(lastline - bpp);
				b = *lastline++;
			}

			p = b - c;
			pc = a - c;

			pa = p < 0 ? -p : p;
			pb = pc < 0 ? -pc : pc;
			pc = (p + pc) < 0 ? -(p + pc) : p + pc;

			p = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c;

			*out++ = *in++ - p;
		}
		break;
	}
}

// Unfilters a row of data

void PNG_Unfilter(byte *out, byte filter, const byte *lastline, uint32_t rowbytes, uint32_t bpp)
{
	uint32_t	i;

	switch(filter)
	{
	case PNG_FILTER_VALUE_NONE:
		break;
	case PNG_FILTER_VALUE_SUB:
		out += bpp;
		for(i = bpp; i < rowbytes; i++)
		{
			*out += *(out - bpp);
			out++;
		}
		break;
	case PNG_FILTER_VALUE_UP:   
		for(i = 0; i < rowbytes; i++)
		{
			if(lastline)
			{
				*out += *lastline++;
			}
			out++;
		}
		break;
	case PNG_FILTER_VALUE_AVG:  
		for(i = 0; i < bpp; i++)
		{
			if(lastline)
			{
				*out += *lastline++ >> 1;
			}
			out++;
		}
		for(i = bpp; i < rowbytes; i++)
		{
			if(lastline)
			{
				*out += (*lastline++ + *(out - bpp)) >> 1;
			}
			else
			{
				*out += *(out - bpp) >> 1;
			}
			out++;
		}
		break;
	case PNG_FILTER_VALUE_PAETH:
		int			a, b, c;
		int			pa, pb, pc, p;

		for(i = 0; i < bpp; i++)
		{
			if(lastline)
			{
				*out += *lastline++;
			}
			out++;
		}
		for(i = bpp; i < rowbytes; i++)
		{
			a = *(out - bpp);
			c = 0;
			b = 0;
			if(lastline)
			{
				c = *(lastline - bpp);
				b = *lastline++;
			}
			p = b - c;
			pc = a - c;

			pa = p < 0 ? -p : p;
			pb = pc < 0 ? -pc : pc;
			pc = (p + pc) < 0 ? -(p + pc) : p + pc;

			p = (pa <= pb && pa <= pc) ? a : (pb <= pc) ? b : c;

			*out++ += p;
		}
		break;
	default:
		break;
	}
}

// Pack up the image data line by line

bool PNG_Pack(byte *out, uint32_t *size, uint32_t maxsize, byte *data, int width, int height, int bytedepth)
{
	z_stream		zdata;
	uint32_t			rowbytes;
	uint32_t			y;
	const byte		*lastline, *source;
	// Storage for filter type and filtered row
	byte			workline[(MAX_PNG_WIDTH * MAX_PNG_DEPTH) + 1];

	// Number of bytes per row
	rowbytes = width * bytedepth;

	memset(&zdata, 0, sizeof(z_stream));
	if(deflateInit(&zdata, Z_FAST_COMPRESSION_HIGH) != Z_OK)
	{
		png_error = PNG_ERROR_COMP;
		return(false);
	}

	zdata.next_out = out;
	zdata.avail_out = maxsize;

	lastline = NULL;
	source = data + ((height - 1) * rowbytes);
	for(y = 0; y < height; y++)
	{
		// Refilter using the most compressable filter algo
		// Assume paeth to speed things up
		workline[0] = (byte)PNG_FILTER_VALUE_PAETH;
		PNG_Filter(workline + 1, (byte)PNG_FILTER_VALUE_PAETH, source, lastline, rowbytes, bytedepth);

		zdata.next_in = workline;
		zdata.avail_in = rowbytes + 1;
		if(deflate(&zdata, Z_SYNC_FLUSH) != Z_OK)
		{
			deflateEnd(&zdata);
			png_error = PNG_ERROR_COMP;
			return(false);
		}
		lastline = source;
		source -= rowbytes;
	}
	if(deflate(&zdata, Z_FINISH) != Z_STREAM_END)
	{
		png_error = PNG_ERROR_COMP;
		return(false);
	}
	*size = zdata.total_out;
	deflateEnd(&zdata);
	return(true);
}

// Unpack the image data, line by line

bool PNG_Unpack(const byte *data, const uint32_t datasize, png_image_t *image)
{
	uint32_t		rowbytes, zerror, y;
	byte		filter;
	z_stream	zdata;
	byte		*lastline, *out;

//	MD_PushTag(TAG_ZIP_TEMP);

	memset(&zdata, 0, sizeof(z_stream));
	if(inflateInit(&zdata, Z_SYNC_FLUSH) != Z_OK)
	{
		png_error = PNG_ERROR_DECOMP;
//		MD_PopTag();
		return(false);
	}
	zdata.next_in = (byte *)data;
	zdata.avail_in = datasize;

	rowbytes = image->width * image->bytedepth;

	lastline = NULL;
	out = image->data;
	for(y = 0; y < image->height; y++)
	{
		// Inflate a row of data
		zdata.next_out = &filter;
		zdata.avail_out = 1;
		if(inflate(&zdata) != Z_OK)
		{
			inflateEnd(&zdata);
			png_error = PNG_ERROR_DECOMP;
//			MD_PopTag();
			return(false);
		}
		zdata.next_out = out;
		zdata.avail_out = rowbytes;
		zerror = inflate(&zdata);
		if((zerror != Z_OK) && (zerror != Z_STREAM_END))
		{
			inflateEnd(&zdata);
			png_error = PNG_ERROR_DECOMP;
//			MD_PopTag();
			return(false);
		}

		// Unfilter a row of data
		PNG_Unfilter(out, filter, lastline, rowbytes, image->bytedepth);

		lastline = out;
		out += rowbytes;
	}
	inflateEnd(&zdata);
//	MD_PopTag();
	return(true);
}

// Scan through all chunks and process each one

bool PNG_Load(const byte *data, uint32_t datasize, png_image_t *image)
{
	bool			moredata;
	const byte		*next;
	byte			*workspace, *work;
	uint32_t			length, type, crc, totallength;

	png_error = PNG_ERROR_OK;

	if(memcmp(data, png_signature, sizeof(png_signature)))
	{
		png_error = PNG_ERROR_NOSIG;
		return(false);
	}
	data += sizeof(png_signature);

	workspace = (byte *)Z_Malloc(datasize, TAG_TEMP_PNG, qfalse);
	work = workspace;
	totallength = 0;

	moredata = true;
	while(moredata)
	{
		length = BigLong(*(uint32_t *)data);
		data += sizeof(uint32_t);

		type = BigLong(*(uint32_t *)data);
		const byte *crcbase = data;
		data += sizeof(uint32_t);

		// CRC checksum location
		next = data + length + sizeof(uint32_t);

		// CRC checksum includes header field
		crc = crc32(0, crcbase, length + sizeof(uint32_t));
		if(crc != (uint32_t)BigLong(*(uint32_t *)(next - 4)))
		{
			if(image->data)
			{
				Z_Free(image->data);
				image->data = NULL;
			}
			Z_Free(workspace);
			png_error = PNG_ERROR_FAILED_CRC;
			return(false);		
		}
		switch(type)
		{
		case PNG_IHDR:
			if(!PNG_HandleIHDR(data, image))
			{
				Z_Free(workspace);
				return(false);
			}
			image->data = (byte *)Z_Malloc(image->width * image->height * image->bytedepth, TAG_TEMP_PNG, qfalse);
			break;
		case PNG_IDAT:
			// Need to copy all the various IDAT chunks into one big one
			// Everything but 3dsmax has one IDAT chunk
			memcpy(work, data, length);
			work += length;
			totallength += length;
			break;
		case PNG_IEND:
			if(!PNG_Unpack(workspace, totallength, image))
			{
				Z_Free(workspace);
				Z_Free(image->data);
				image->data = NULL;
				return(false);
			}
			moredata = false;
			break;
		default:
			break;
		}
		data = next;
	}
	Z_Free(workspace);
	return(true);
}

// Outputs a crc'd chunk of PNG data

bool PNG_OutputChunk(fileHandle_t fp, uint32_t type, byte *data, uint32_t size)
{
	uint32_t	crc, little, outcount;

	// Output a standard PNG chunk - length, type, data, crc
	little = BigLong(size);
	outcount = FS_Write(&little, sizeof(little), fp);

	little = BigLong(type);
	crc = crc32(0, (byte *)&little, sizeof(little));
	outcount += FS_Write(&little, sizeof(little), fp);

	if(size)
	{
		crc = crc32(crc, data, size);
		outcount += FS_Write(data, size, fp);
	}

	little = BigLong(crc);
	outcount += FS_Write(&little, sizeof(little), fp);

	if(outcount != (size + 12))
	{
		png_error = PNG_ERROR_WRITE;
		return(false);
	}
	return(true);
}

// Saves a PNG format compressed image

bool PNG_Save(const char *name, byte *data, int width, int height, int bytedepth)
{
	byte			*work;
	fileHandle_t	fp;
	int				maxsize;
	uint32_t			size, outcount;
	png_ihdr_t		png_header;

	png_error = PNG_ERROR_OK;

	// Create the file
	fp = FS_FOpenFileWrite(name);
	if(!fp)
	{
		png_error = PNG_ERROR_CREATE_FAIL;
		return(false);
	}
	// Write out the PNG signature
	outcount = FS_Write(png_signature, sizeof(png_signature), fp);
	if(outcount != sizeof(png_signature))
	{
		FS_FCloseFile(fp);
		png_error = PNG_ERROR_WRITE;
		return(false);
	}
	// Create and output a valid header
	PNG_CreateHeader(&png_header, width, height, bytedepth);
	if(!PNG_OutputChunk(fp, PNG_IHDR, (byte *)&png_header, sizeof(png_header)))
	{
		FS_FCloseFile(fp);
		return(false);
	}
	// Create and output the copyright info
 	if(!PNG_OutputChunk(fp, PNG_tEXt, (byte *)png_copyright, sizeof(png_copyright)))
	{
		FS_FCloseFile(fp);
		return(false);
	}
	// Max size of compressed image (source size + 0.1% + 12)
	maxsize = (width * height * bytedepth) + 4096;
	work = (byte *)Z_Malloc(maxsize, TAG_TEMP_PNG, qtrue);	// fixme: optimise to qfalse sometime - ok?
  
	// Pack up the image data
	if(!PNG_Pack(work, &size, maxsize, data, width, height, bytedepth))
	{
		Z_Free(work);
		FS_FCloseFile(fp);
		return(false);
	}
	// Write out the compressed image data
	if(!PNG_OutputChunk(fp, PNG_IDAT, (byte *)work, size))
	{
		Z_Free(work);
		FS_FCloseFile(fp);
		return(false);
	}
	Z_Free(work);
	// Output terminating chunk
	if(!PNG_OutputChunk(fp, PNG_IEND, NULL, 0))
	{
		FS_FCloseFile(fp);
		return(false);
	}
	FS_FCloseFile(fp);
	return(true);
}

/*
=============
PNG_ConvertTo32
=============
*/

void PNG_ConvertTo32(png_image_t *image)
{
	byte	*temp;
	byte	*old, *old2;
	uint32_t	i;

	temp = (byte *)Z_Malloc(image->width * image->height * 4, TAG_TEMP_PNG, qtrue);
	old = image->data;
	old2 = old;
	image->data = temp;
	image->bytedepth = 4;

	for(i = 0; i < image->width * image->height; i++)
	{
		*temp++ = *old++;
		*temp++ = *old++;
		*temp++ = *old++;
		*temp++ = 0xff;
	}
	Z_Free(old2);
}

/*
=============
LoadPNG32
=============
*/
bool LoadPNG32 (char *name, byte **pixels, int *width, int *height, int *bytedepth)
{
	byte		*buffer;
	byte		**bufferptr = &buffer;
	int			nLen;
	png_image_t	png_image;

	if(!pixels)
	{
		bufferptr = NULL;
	}
	nLen = FS_ReadFile ( ( char * ) name, (void **)bufferptr);
	if (nLen == -1) 
	{
		if(pixels)
		{
			*pixels = NULL;
		}
		return(false);
	}
	if(!pixels)
	{
		return(true);
	}
	*pixels = NULL;
	png_image.isimage = true;
	if(!PNG_Load(buffer, nLen, &png_image))
	{
		Com_Printf ("Error parsing %s: %s\n", name, PNG_GetError());
		return(false);
	}
	if(png_image.bytedepth != 4)
	{
		PNG_ConvertTo32(&png_image);
	}
	*pixels = png_image.data;
	if(width)
	{
		*width = png_image.width;
	}
	if(height)
	{
		*height = png_image.height;
	}
	if(bytedepth)
	{
		*bytedepth = png_image.bytedepth;
	}
	FS_FreeFile(buffer);
	return(true);
}

/*
=============
LoadPNG8
=============
*/
bool LoadPNG8 (char *name, byte **pixels, int *width, int *height)
{
	byte		*buffer;
	byte		**bufferptr = &buffer;
	int			nLen;
	png_image_t	png_image;

	if(!pixels)
	{
		bufferptr = NULL;
	}
	nLen = FS_ReadFile ( ( char * ) name, (void **)bufferptr);
	if (nLen == -1) 
	{
		if(pixels)
		{
			*pixels = NULL;
		}
		return(false);
	}
	if(!pixels)
	{
		return(true);
	}
	*pixels = NULL;
	png_image.isimage = false;
	if(!PNG_Load(buffer, nLen, &png_image))
	{
		Com_Printf ("Error parsing %s: %s\n", name, PNG_GetError());
		return(false);
	}
	*pixels = png_image.data;
	if(width)
	{
		*width = png_image.width;
	}
	if(height)
	{
		*height = png_image.height;
	}
	FS_FreeFile(buffer);
	return(true);
}

// end