/*********************************************/
// 	2003 (c) Hannibal Lecturer
//	RLE Compression tool
//	in stream:
//	0x1000000 - repeat sequence
//	0x0000000 - not repeat sequence
//	Max seqeunce length ~ 127
/*********************************************/


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

#define FALSE 0
#define TRUE 1


char* CompressRLE (char* strFile, int& intSize,  char* strOut)
{
	char* szResult = new char[intSize], szBuffer[128], szTemp[512];
	int i, intAdd;
	int blSequence = FALSE;
	int chRepeat = 1024, chNotRepeat = 1024;

	intSize = 0;
	strcpy (szBuffer,"");
	strcpy (szResult,"");

	ifstream fin (strFile, ios::in|ios::binary);
	ofstream fout (strOut, ios::out|ios::binary);

	while (!fin.eof())
	{
		if (!blSequence)
		{
			int intSeqLen = 1, ch1, ch2 = chNotRepeat;
			if (chNotRepeat!=1024) intSeqLen = 2;
			int intSeqLen0 = intSeqLen;
			szBuffer[0] = (char)chNotRepeat;
			ch1 = ch2;

			chNotRepeat = 1024;
			chRepeat = 1024;

			fin.get ((char)ch1);
			szBuffer [intSeqLen-1] = ch1;
			while ((ch2!=ch1) && (intSeqLen<128))
			{
				ch2 = ch1;
				fin.get ((char)ch1);
				szBuffer[intSeqLen] = (char)ch1;
				intSeqLen++;
			};

			if (intSeqLen-1==127)
			{
				intSeqLen0 = 1;
				chNotRepeat = szBuffer[intSeqLen-1];
				chRepeat = 1024;
			}
			else
			{
				intSeqLen0 = 2;
				chRepeat = szBuffer[intSeqLen-1];
				chNotRepeat = 1024;
			}

			if (intSeqLen>2)
			{
				fout.put (intSeqLen - intSeqLen0);
				for (i=0;i<intSeqLen-intSeqLen0;i++) fout.put (szBuffer[i]);
				szResult [intSize] = intSeqLen - intSeqLen0;
				intSize++;
				for (i=intSize;i<intSize+intSeqLen-intSeqLen0;i++) szResult[i] = szBuffer[i-intSize];
				szResult [intSize+intSeqLen-intSeqLen0] = 0;
				intSize += intSeqLen-intSeqLen0;
			}

			if (chRepeat!=1024) blSequence = TRUE;
			strcpy (szBuffer,"");
		}
		else
		{
			int intSeqLen = 2;
			char ch1 = chRepeat;

			while ( (ch1==chRepeat) && (intSeqLen<128))
			{
				intSeqLen++;
				fin.get (ch1);
			}

			chNotRepeat = ch1;
			szResult [intSize] = 128 | (intSeqLen-1);
			szResult [intSize+1] = chRepeat;
			fout.put (128|(intSeqLen-1));
			fout.put (chRepeat);

			intSize += 2;
			blSequence = FALSE;
			strcpy (szBuffer,"");
		}
	}
	fin.close();
	fout.close();
	return (szResult);
}

void DecompressRLE (char* strData,int& intSize,char* strOut)
{
	ofstream fout (strOut,ios::out|ios::binary);
	int i = 0, intMaxSize = intSize, j = 0, intIter = 0;
	char chSequence;
	int blSequence;
	intSize = 0;

	while (i<=intMaxSize)
	{
		for (j=0;j<intIter;j++)
		{
			intSize++;
			if (blSequence)
			{
				fout.put ((unsigned char)strData[i]);
				i++;
			}
			else fout.put ((unsigned char) chSequence);
		}
		if ((strData[i] & 128)==128)
		{
			blSequence = FALSE;
			intIter = 256+strData[i]^128;
			chSequence = strData[i+1];
			i+=2;
		}
		else
		{
			blSequence = TRUE;
			intIter = strData[i];
			i++;
		}
	};
	fout.close();
}

int PrintUsage (char* strApp)
{
	printf ("RLE Compression tool, 2003 (c) Hannibal Lecturer\n");
	printf ("Usage: %s [-c|-d] <in> <out>\n",strApp);
	printf ("Options: -c - pack file\n");
	printf ("         -d - unpack compressed file\n");
	printf ("Example: %s -c file1.bin file1.out\n\n",strApp);
	return (0);
}


int main(int argc,char** argv)
{
	if (argc!=4)
	{
		PrintUsage(argv[0]);
		return (0);
	}

	if (!strcmp(argv[1],"-c"))
	{
		int intSize;
		CompressRLE (argv[2],intSize,argv[3]);
		printf ("Size of compressed file: %d\n\n",intSize);
	}
	else if (!strcmp(argv[1],"-d"))
	{
		int intSize = 0;
		ifstream file1 (argv[1],ios::in|ios::binary);
		while (!file1.eof())
		{
			char chRead;
			file1.get (chRead);
			intSize++;
		}
		file1.close();

		char* strData = new char[intSize];
		strcpy (strData,"");
		ifstream file2 (argv[1],ios::in|ios::binary);
		for (int i=0;i<intSize;i++) file2.get(strData[i]);
		file2.close();
		DecompressRLE (strData,intSize,argv[2]);
	}
	else return (1);

	return (0);
};