/*
	ClutAdd V0.2
	A TIM file CLUT table appender.
	
	Copyright 1998, Dominic F. A. Collins.
	
	 Permission is granted to freely copy and use this software, subject
	to the restrictions outlined in the help text.
*/

#define MAXCLUTS 50
#define BUFFER_SIZE 65536
#define NAMELENGTH 64
#define LINES 22

#include <stdio.h>
#include <malloc.h>
#include <string.h>

char clutbsel=0;
char debugf=0;
const char headerid[]={0x10, 0x00, 0x00, 0x00}; // Header file ID, with file version.
const char ext[4][5]={"\0",".tim",".clt",".pal"};
void MakeCLUTSpace(size_t csize);
char TestTIM(char *data);

char *cluts[2]={NULL, NULL}; // Pointer to raw tile data.
char *oldclut=NULL;
void * buf=NULL;
int i,j;
unsigned int k;
char inp[NAMELENGTH];	/*	Input parameter.	*/
char timinfilename[NAMELENGTH]; // TIM Input filename.
char clutinfilename[MAXCLUTS][NAMELENGTH]; // CLUT Input filename.
char clutintype[MAXCLUTS];
char timoutfilename[NAMELENGTH]="A.TIM"; // TIM Output filename.
char cnum=0;
char ctype=1;
char datatype=1;
size_t totlength;
size_t clutlength[2]={0, 0};
size_t tempsize;
int clutcols=256;
unsigned int black=0x8000;
unsigned int transbit=0;
char clutflag=1;
FILE * iostream; // Used for all file I/O.
FILE * iotwo;	// Used to filter TIM file

main(int paramlength, char *param[])
{

timinfilename[0]=0;
memset( &clutintype, 0, (size_t)MAXCLUTS );

for (i=1; i<paramlength; i++)
	{
	strcpy( &inp[0], param[i]);

	if ((inp[0]=='-') || (inp[0]=='/'))
		{
		inp[1]=toupper(inp[1]);
		switch (inp[1])
			{
			case 'H':
			case '?':
				ShowHelp(0xfff);
				exit(0);

			case 'D':
				debugf=1;
				break;

			case 'T':
				ctype=1;
				break;

			case 'C':
				ctype=2;
				break;

			case 'P':
				ctype=3;
				break;

			case 'O':
				datatype=2;
				break;

			case 'I':
				datatype=1;
				break;

			case '4':
				clutcols=16;
				break;

			case 'B':
				black^=0x8000;
				break;

			case 'S':
				transbit^=0x8000;
				break;

			default:
				printf("Unknown option '%s'.\n", inp);
				ShowHelp(1<<4);
				exit(1);
			}
		}
	else
		{
		switch (datatype)
			{
			case 1:
				strcpy(timinfilename, inp);
				datatype=0;
				break;
			
			case 2:
				strcpy(timoutfilename, inp);
				datatype=0;
				break;

			default:
				strcpy(clutinfilename[cnum], inp);
				clutintype[cnum]=ctype;
				cnum++;
				if (cnum==MAXCLUTS) cnum--;
			}
		}
	}

for (i=0; i<cnum; i++)
	{
	strcpy(inp, clutinfilename[i]);
	printf("Using file '%s'\nLoading...\n", inp );
	if ((iostream=fopen(&inp[0], "rb"))==NULL)
		{
		// This 'if' statement prevents a silly string overflow bug with strcat().
		if (strlen(clutinfilename[i])<(NAMELENGTH-4))
			{
			strcat(inp, ext[clutintype[i]]);
			}
		if ((iostream=fopen(&inp[0], "rb"))==NULL)
			{
			printf("File not found\n");
			clutintype[i]=0;
			}
		}
	
	if (clutintype[i])
		{
		fseek(iostream, 0, SEEK_END);
		totlength=ftell(iostream);
		if (debugf)
			printf("Length: %ld...\n", totlength);
		fseek(iostream, 0, SEEK_SET);
		switch (clutintype[i])
			{
			case 1:
				if ((fread(&inp[0], 1, 20, iostream))!=20)
					{
					printf("File read error!\n");
					break;
					}
				if (TestTIM(&inp[0]))
					{
					printf("Bad TIM header\n");
					break;
					}
				if (!(inp[4]&(1<<3)))
					{
					printf("TIM has no CLUT!\n");
					break;
					}
				tempsize=inp[8]+(inp[9]<<8)+(inp[10]<<16)+(inp[11]<<24)-12;
				if (tempsize&(0xf))
					{
					printf("Invalid CLUT size!\n");
					break;
					}
				clutlength[clutbsel]+=tempsize;
				MakeCLUTSpace(clutlength[clutbsel]);
				if (fread((cluts[clutbsel]+clutlength[clutbsel]-tempsize), 1, tempsize, iostream)!=tempsize)
					{
					printf("Fatal read error!\nCLUTS destroyed!\n");
					MakeCLUTSpace(0);
					exit(1);
					}
				break;
			
			case 2:
				tempsize=clutlength[clutbsel];
				clutlength[clutbsel]+=totlength;
				MakeCLUTSpace(clutlength[clutbsel]);
				if (fread((cluts[clutbsel]+tempsize), 1, totlength, iostream)!=totlength)
					{
					printf("Fatal read error!\nCLUTS destroyed!\n");
					MakeCLUTSpace(0);
					exit(1);
					}
				break;
			
			case 3:
				if ((totlength!=768)&&(totlength!=48))
					{
					printf("Invalid palette file size!\n");
					break;
					}
				j=totlength/3;
				buf=malloc(totlength);
				if (buf==NULL)
					{
						printf("Memory allocation error!\nNot enough memory for palette file '%s'!\n", inp);
					break;
					}

				if ((fread(buf, 1, totlength, iostream))<totlength)
					{
					printf("File read error while reading pallette file '%s'!\n", inp);
					}
				tempsize=clutlength[clutbsel];
				clutlength[clutbsel]+=j;
				MakeCLUTSpace(clutlength[clutbsel]);
				
				for (i=0; i<j; i++)
					{
					k=((*(char*)(buf+(i*3)+2)&0xf8)<<10);
					k|=((*(char*)(buf+(i*3)+1)&0xf8)<<5);
					k|=(*(char*)(buf+(i*3))>>3);
					if (k==0)
						{
						k=black;
						}
					else
						{
						k^=transbit;
						}
						
					*(char*)(cluts[clutbsel]+tempsize+i+i)=k;
					*(char*)(cluts[clutbsel]+tempsize+i+i+1)=(k>>8);
					}
				
				free(buf);
				break;
				
			default:
				puts("Unknown error!\n");
				break;
			}
		fclose(iostream);
		}
	}

if (clutlength[clutbsel]==0)
	{
	printf("\nNo CLUTS found!\nType CLUTADD -? for help\n");
	exit(1);
	}

printf("\nAdding CLUTs to TIM file '%s'\nLoading...", timinfilename);
if ((iostream=fopen(timinfilename, "rb"))==NULL)
	{
	strcpy(inp, timinfilename);
	// This 'if' statement prevents a silly string overflow bug with strcat().
	if (strlen(timinfilename)<(NAMELENGTH-4))
		{
		strcat(inp, ".tim");
		}
	if ((iostream=fopen(&inp[0], "rb"))==NULL)
		{
		printf("File not found\nUnable to add CLUTs\n");
		exit(1);
		}
	}

fseek(iostream, 0, SEEK_END);
totlength=ftell(iostream);
if (debugf)
	{
	printf("Length: %ld...", totlength);
	}
fseek(iostream, 0, SEEK_SET);

if ((fread(&inp[0], 1, 20, iostream))!=20)
	{
	printf("File read error!\n");
	exit(1);
	}

if (TestTIM(&inp[0]))
	{
	printf("Bad TIM header\n");
	exit(2);
	}

printf("Creating output file '%s'\n", timoutfilename);
iotwo=fopen(timoutfilename, "wb");
if (iotwo==NULL)
	{
	printf("Failed to create output file!\n");
	exit(1);
	}

if (!(inp[4]&(1<<3)))
	{
	printf("TIM has no CLUT!\n");
	clutflag=0;
	inp[4]=((inp[4])&(0xf0))|((1<<3)|4);
	fseek(iostream, 8, SEEK_SET);

	tempsize=clutlength[clutbsel]+12;
	inp[16]=clutcols&0xff;
	inp[17]=clutcols>>8;

	inp[12]=0;
	inp[13]=0;
	inp[14]=0xe0;
	inp[15]=0x01;
	}
else
	{
	tempsize=inp[8]+(inp[9]<<8)+(inp[10]<<16)+(inp[11]<<24)+clutlength[clutbsel];
	clutcols=inp[16]+(inp[17]<<8);
	}

inp[8]=(tempsize)&(0xff);
inp[9]=(tempsize>>8)&(0xff);
inp[10]=(tempsize>>16)&(0xff);
inp[11]=(tempsize>>24)&(0xff);

tempsize-=12;

i=tempsize/clutcols;
i=i/2;
inp[18]=i&(0xff);
inp[19]=(i>>8)&(0xff);

tempsize-=clutlength[clutbsel];

if ((fwrite(&inp[0], 1, 20, iotwo))!=20)
	{
	printf("Error writing file!\n");
	exit(1);
	}

if (clutflag)
	{
	oldclut=malloc(tempsize);
	if (oldclut==NULL)
		{
		printf("Not enough memory to copy old CLUTs!\n");
		exit(1);
		}
	if ((fread( oldclut, 1, tempsize, iostream))<tempsize)
		{
		printf("Error reading old CLUTs!\n");
		exit(1);
		}
	if ((fwrite( oldclut, 1, tempsize, iotwo))<tempsize)
		{
		printf("Error writing old CLUTs!\n");
		exit(1);
		}
	free(oldclut);
	}

clutlength[clutbsel]-=clutlength[clutbsel]%clutcols;

if ((fwrite( cluts[clutbsel], 1, clutlength[clutbsel], iotwo))<clutlength[clutbsel])
	{
	printf("Error writing new CLUTs!\n");
	exit(1);
	}

free(cluts[0]);
free(cluts[1]);

buf=malloc(BUFFER_SIZE);
tempsize=BUFFER_SIZE;

while (tempsize==BUFFER_SIZE)
	{
	tempsize=fread(buf, 1, BUFFER_SIZE, iostream);

	if ((fwrite(buf, 1,tempsize, iotwo))<tempsize)
		{
		printf("Write error while copying pixel data!\n");
		exit(1);
		}
	}

printf("Closing files...\n");

fclose(iostream);
fclose(iotwo);

printf("Done!");


}


char TestTIM(char *data)
{

if (strncmp(data, headerid, 4)!=0)
	{
	return 1;
	}

return 0;
}

void MakeCLUTSpace(size_t csize)
{
char *tmp;
tmp=realloc(cluts[clutbsel], csize);
if (tmp!=NULL)
	{
	cluts[clutbsel]=tmp;
	}
else
	{
	printf("\nMemory allocation error!\nNot enough memory for CLUTs!\n");
	exit(1);
	}
}

char help[][80]={
	" ",
	"ClutAdd V0.2    TIM File CLUT Table Appender.",
    "------- ----    --- ---- ---- ----- ---------",
	"	",
	"Copyright 1998 Dominic F. A. Collins.",
	"	",
	" This program is freeware, and may be copied freely, but not for",
	"commercial gain. This program cannot be altered in any way."
	"	",
	" I have tried to make this program as bug-free as possible, but if",
	"you decide to use this program, I give you no express or implied",
	"warranty of any kind; by using this program, you are agreeing not",
	"to hold me responsible for anything this program does. Okay?",
	"	",
	"Syntax: CLUTADD filename.tim [[-][/]options] [filename.ext]",
	" filename.tim     TIM file to add CLUTs to.",
	" filename.ext     TIM/CLT/PAL file to take CLUT from",
	"	",
	"Options:",
	" -help, /Help, -?   Prints the help screen",
	" -d, -DEBUG         Extra debug output.",
	" -c, -CLUT          Import files as raw CLUT data",
	" -p, -PAL           Import files as raw 24-bit RGB palette",
	" -t, -TIM           Import files as TIM CLUTs",
	" -o, -OUTPUT        Sets name for output file",
	" -4, -4BITCLUT      Adds new 4-bit clut to TIM with no clut",
	" -b, -BLACKTRANSPARENT",
	"                    Makes black (from raw palette) transparent",
	" -s, -SEETHROUGH    Makes non-black colours (from raw palette) semitransparent",
	"	",
	" This program will load the CLUTs, then add them to the TIM file specified,",
	"then output the data to a new file (defaults to 'A.TIM')",
	"	",
	"."
	};

ShowHelp(int c)
{
int i=0;
int j=LINES;

for (i=0; help[i][0]!='.'; i++ )
	{
	if (help[i][0]=='	') (c=c>>1);
	if (c&1)
		{
		puts(help[i]);
		j--;

		}
	if (j==0)
		{
		puts("Press return to continue...");
		getchar();
		j=LINES;
		}
	}
}