mm/z64yaz0.c

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

//version 1.0 (20050707)
//by shevious
//Thanks to thakis for yaz0dec 1.0.

typedef unsigned char u8;
typedef unsigned int u32;

#define MAX_RUNLEN (0xFF + 0x12)

// simple and straight encoding scheme for Yaz0
static u32 simpleEnc(u8 *src, int size, int pos, u32 *pMatchPos)
{
	int startPos = pos - 0x1000;
	u32 numBytes = 1;
	u32 matchPos = 0;

	int end = size - pos;
	// maximum runlength for 3 byte encoding
	if (end > MAX_RUNLEN)
		end = MAX_RUNLEN;

	if (startPos < 0)
		startPos = 0;
	for (int i = startPos; i < pos; i++) {
		int j;
		for (j = 0; j < end; j++) {
			if (src[i + j] != src[j + pos])
				break;
		}
		if (j > numBytes) {
			numBytes = j;
			matchPos = i;
		}
	}

	*pMatchPos = matchPos;

	if (numBytes == 2)
		numBytes = 1;

	return numBytes;
}

// a lookahead encoding scheme for ngc Yaz0
static u32 nintendoEnc(u8 *src, int size, int pos, u32 *pMatchPos)
{
	u32 numBytes = 1;
	static u32 numBytes1;
	static u32 matchPos;
	static int prevFlag = 0;

	// if prevFlag is set, it means that the previous position
	// was determined by look-ahead try.
	// so just use it. this is not the best optimization,
	// but nintendo's choice for speed.
	if (prevFlag == 1) {
		*pMatchPos = matchPos;
		prevFlag = 0;
		return numBytes1;
	}

	prevFlag = 0;
	numBytes = simpleEnc(src, size, pos, &matchPos);
	*pMatchPos = matchPos;

	// if this position is RLE encoded, then compare to copying 1 byte and next position(pos+1) encoding
	if (numBytes >= 3) {
		numBytes1 = simpleEnc(src, size, pos + 1, &matchPos);
		// if the next position encoding is +2 longer than current position, choose it.
		// this does not guarantee the best optimization, but fairly good optimization with speed.
		if (numBytes1 >= numBytes + 2) {
			numBytes = 1;
			prevFlag = 1;
		}
	}
	return numBytes;
}

static int encodeYaz0(u8 *src, u8 *dst, int srcSize)
{
	int srcPos = 0;
	int dstPos = 0;
	int bufPos = 0;

	u8 buf[24]; // 8 codes * 3 bytes maximum

	u32 validBitCount = 0; // number of valid bits left in "code" byte
	u8 currCodeByte = 0; // a bitfield, set bits meaning copy, unset meaning RLE

	while (srcPos < srcSize) {
		u32 numBytes;
		u32 matchPos;

		numBytes = nintendoEnc(src, srcSize, srcPos, &matchPos);
		if (numBytes < 3) {
			// straight copy
			buf[bufPos] = src[srcPos];
			bufPos++;
			srcPos++;
			//set flag for straight copy
			currCodeByte |= (0x80 >> validBitCount);
		} else {
			//RLE part
			u32 dist = srcPos - matchPos - 1;
			u8 byte1, byte2, byte3;

			if (numBytes >= 0x12) { // 3 byte encoding
				byte1 = 0 | (dist >> 8);
				byte2 = dist & 0xFF;
				buf[bufPos++] = byte1;
				buf[bufPos++] = byte2;
				// maximum runlength for 3 byte encoding
				if (numBytes > MAX_RUNLEN)
					numBytes = MAX_RUNLEN;
				byte3 = numBytes - 0x12;
				buf[bufPos++] = byte3;
			} else { // 2 byte encoding
				byte1 = ((numBytes - 2) << 4) | (dist >> 8);
				byte2 = dist & 0xFF;
				buf[bufPos++] = byte1;
				buf[bufPos++] = byte2;
			}
			srcPos += numBytes;
		}

		validBitCount++;

		// write eight codes
		if (validBitCount == 8) {
			dst[dstPos++] = currCodeByte;
			for (int j = 0; j < bufPos; j++)
				dst[dstPos++] = buf[j];

			currCodeByte = 0;
			validBitCount = 0;
			bufPos = 0;
		}
	}

	if (validBitCount > 0) {
		dst[dstPos++] = currCodeByte;
		for (int j = 0; j < bufPos; j++)
			dst[dstPos++] = buf[j];

		currCodeByte = 0;
		validBitCount = 0;
		bufPos = 0;
	}

	return dstPos;
}

void decompress(u8 *src, u8 *dst, int uncompressedSize)
{
	int srcPlace = 0, dstPlace = 0; // current read/write positions

	u32 validBitCount = 0; // number of valid bits left in "code" byte
	u8 currCodeByte = 0;

	while (dstPlace < uncompressedSize) {
		// read new "code" byte if the current one is used up
		if (validBitCount == 0) {
			currCodeByte = src[srcPlace++];
			validBitCount = 8;
		}

		if ((currCodeByte & 0x80) != 0) {
			// straight copy
			dst[dstPlace++] = src[srcPlace++];
		} else {
			// RLE part
			u8 byte1 = src[srcPlace++];
			u8 byte2 = src[srcPlace++];

			u32 dist = ((byte1 & 0xF) << 8) | byte2;
			u32 copySource = dstPlace - (dist + 1);

			u32 numBytes = byte1 >> 4;
			if (numBytes == 0) {
				numBytes = src[srcPlace++] + 0x12;
			} else {
				numBytes += 2;
			}

			// copy run
			for(int i = 0; i < numBytes; ++i) {
				dst[dstPlace++] = dst[copySource++];
			}
		}

		// use next bit from "code" byte
		currCodeByte <<= 1;
		validBitCount--;
	}
}

int main(int argc, char *argv[])
{
	for (int i = 1; i < argc; i++) {
		FILE *f = fopen(argv[i], "rb");

		if (f == NULL) {
			perror(argv[1]);
			exit(1);
		}

		fseek(f, 0, SEEK_END);
		long size = ftell(f);
		fseek(f, 0, SEEK_SET);

		u8 *bufi = malloc(size);
		fread(bufi, 1, size, f);

		fclose(f);

		if (size > 0x10
			&& bufi[0] == 'Y'
			&& bufi[1] == 'a'
			&& bufi[2] == 'z'
			&& bufi[3] == '0') {
			long usize = (bufi[4] << 24)
				| (bufi[5] << 16)
				| (bufi[6] << 8)
				| bufi[7];
			u8 *bufo = malloc(usize);
			decompress(bufi + 16, bufo, usize);
			fwrite(bufo, usize, 1, stdout);
			free(bufo);
		} else {
			// we don't know how big the "compressed" file could get,
			// so over-allocate!
			// modern systems have more RAM than the largest Yaz0 file, so...
			u8 *bufo = malloc(size * 2);

			// write 4 bytes yaz0 header
			bufo[0] = 'Y';
			bufo[1] = 'a';
			bufo[2] = 'z';
			bufo[3] = '0';

			// write 4 bytes uncompressed size
			bufo[4] = (size >> 24) & 0xFF;
			bufo[5] = (size >> 16) & 0xFF;
			bufo[6] = (size >> 8) & 0xFF;
			bufo[7] = (size >> 0) & 0xFF;

			// write 8 bytes unused dummy
			bufo[8] = 0;
			bufo[9] = 0;
			bufo[10] = 0;
			bufo[11] = 0;
			bufo[12] = 0;
			bufo[13] = 0;
			bufo[14] = 0;
			bufo[15] = 0;

			long csize = encodeYaz0(bufi, bufo + 16, size) + 16;

			// pad compressed file to be a multiple of 16 bytes.
			long ceilsize = (csize + 15) & ~0xF;
			for (long i = csize; i < ceilsize; i++) {
				bufo[i] = 0;
			}

			fwrite(bufo, ceilsize, 1, stdout);
			free(bufo);
		}
		free(bufi);
	}
}