armorpaint/base/sources/libs/lz4x.h

/*

LZ4X - An optimized LZ4 compressor

Written and placed in the public domain by Ilya Muravyov

*/

#ifndef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#endif
#define _CRT_DISABLE_PERFCRIT_LOCKS

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

typedef unsigned char U8;
typedef unsigned short U16;
typedef unsigned int U32;

#define LZ4_MAGIC 0x184C2102
#define BLOCK_SIZE (8<<20) // 8 MB
#define PADDING_LITERALS 5

#define WINDOW_BITS 16
#define WINDOW_SIZE (1<<WINDOW_BITS)
#define WINDOW_MASK (WINDOW_SIZE-1)

#define MIN_MATCH 4

#define EXCESS (16+(BLOCK_SIZE/255))

static U8 g_buf[BLOCK_SIZE+BLOCK_SIZE+EXCESS];

#define MIN(a, b) (((a)<(b))?(a):(b))
#define MAX(a, b) (((a)>(b))?(a):(b))

#define LOAD_16(p) (*(const U16*)(&g_buf[p]))
#define LOAD_32(p) (*(const U32*)(&g_buf[p]))
#define STORE_16(p, x) (*(U16*)(&g_buf[p])=(x))
#define COPY_32(d, s) (*(U32*)(&g_buf[d])=LOAD_32(s))

#define HASH_BITS 18
#define HASH_SIZE (1<<HASH_BITS)
#define NIL (-1)

#define HASH_32(p) ((LOAD_32(p)*0x9E3779B9)>>(32-HASH_BITS))

static size_t kread(void* dst, size_t size, const char* src, size_t* offset, size_t compressedSize) {
	size_t realSize = MIN(size, compressedSize - *offset);
	memcpy(dst, &src[*offset], realSize);
	*offset += realSize;
	return realSize;
}

static size_t kwrite(void* src, size_t size, char* dst, size_t* offset, int maxOutputSize) {
	size_t realSize = MIN(size, maxOutputSize - *offset);
	memcpy(&dst[*offset], src, size);
	*offset += realSize;
	return realSize;
}

static inline void wild_copy(int d, int s, int n) {
	COPY_32(d, s);
	COPY_32(d+4, s+4);

	for (int i=8; i<n; i+=8)
	{
		COPY_32(d+i, s+i);
		COPY_32(d+4+i, s+4+i);
	}
}

size_t LZ4_compress(const char *source, int sourceSize, char *dest, const int max_chain, int maxDestSize) {
	static int head[HASH_SIZE];
	static int tail[WINDOW_SIZE];

	size_t read_offset = 0;
	size_t write_offset = 0;
	int n;

	while ((n = kread(g_buf, BLOCK_SIZE, source, &read_offset, sourceSize)) > 0) {
		for (int i=0; i<HASH_SIZE; ++i)
			head[i]=NIL;

		int op=BLOCK_SIZE;
		int pp=0;

		int p=0;
		while (p<n)
		{
			int best_len=0;
			int dist=0;

			const int max_match=(n-PADDING_LITERALS)-p;
			if (max_match>=MAX(12-PADDING_LITERALS, MIN_MATCH))
			{
				const int limit=MAX(p-WINDOW_SIZE, NIL);
				int chain_len=max_chain;

				int s=head[HASH_32(p)];
				while (s>limit)
				{
					if (g_buf[s+best_len]==g_buf[p+best_len] && LOAD_32(s)==LOAD_32(p))
					{
						int len=MIN_MATCH;
						while (len<max_match && g_buf[s+len]==g_buf[p+len])
							++len;

						if (len>best_len)
						{
							best_len=len;
							dist=p-s;

							if (len==max_match)
								break;
						}
					}

					if (--chain_len==0)
						break;

					s=tail[s&WINDOW_MASK];
				}
			}

			if (best_len>=MIN_MATCH)
			{
				int len=best_len-MIN_MATCH;
				const int nib=MIN(len, 15);

				if (pp!=p)
				{
					const int run=p-pp;
					if (run>=15)
					{
						g_buf[op++]=(15<<4)+nib;

						int j=run-15;
						for (; j>=255; j-=255)
							g_buf[op++]=255;
						g_buf[op++]=j;
					}
					else
						g_buf[op++]=(run<<4)+nib;

					wild_copy(op, pp, run);
					op+=run;
				}
				else
					g_buf[op++]=nib;

				STORE_16(op, dist);
				op+=2;

				if (len>=15)
				{
					len-=15;
					for (; len>=255; len-=255)
						g_buf[op++]=255;
					g_buf[op++]=len;
				}

				pp=p+best_len;

				while (p<pp)
				{
					const U32 h=HASH_32(p);
					tail[p&WINDOW_MASK]=head[h];size_t read_offset = 0;
					size_t write_offset = 0;
					head[h]=p++;
				}
			}
			else
			{
				const U32 h=HASH_32(p);
				tail[p&WINDOW_MASK]=head[h];
				head[h]=p++;
			}
		}

		if (pp!=p)
		{
			const int run=p-pp;
			if (run>=15)
			{
				g_buf[op++]=15<<4;

				int j=run-15;
				for (; j>=255; j-=255)
					g_buf[op++]=255;
				g_buf[op++]=j;
			}
			else
				g_buf[op++]=run<<4;

			wild_copy(op, pp, run);
			op+=run;
		}

		int comp_len=op-BLOCK_SIZE;

		kwrite(&comp_len, sizeof(comp_len), dest, &write_offset, maxDestSize);
		kwrite(&g_buf[BLOCK_SIZE], comp_len, dest, &write_offset, maxDestSize);
	}

	return write_offset;
}

int LZ4_compress_bound(int inputSize) {
	return inputSize + (inputSize / 255) + 16;
}

size_t LZ4_compress_default(const char *source, char *dest, int sourceSize, int maxDestSize) {
	return LZ4_compress(source, sourceSize, dest, WINDOW_SIZE, maxDestSize);
}

int LZ4_decompress_safe(const char *source, char *buf, int compressedSize, int maxOutputSize) {
	size_t read_offset = 0;
	size_t write_offset = 0;
	int comp_len;
	while (kread(&comp_len, sizeof(comp_len), source, &read_offset, compressedSize)>0)
	{
		if (comp_len<2 || comp_len>(BLOCK_SIZE+EXCESS)
				|| kread(&g_buf[BLOCK_SIZE], comp_len, source, &read_offset, compressedSize)!=comp_len)
			return -1;

		int p=0;

		int ip=BLOCK_SIZE;
		const int ip_end=ip+comp_len;

		for (;;)
		{
			const int token=g_buf[ip++];
			if (token>=16)
			{
				int run=token>>4;
				if (run==15)
				{
					for (;;)
					{
						const int c=g_buf[ip++];
						run+=c;
						if (c!=255)
							break;
					}
				}
				if ((p+run)>BLOCK_SIZE)
					return -1;

				wild_copy(p, ip, run);
				p+=run;
				ip+=run;
				if (ip>=ip_end)
					break;
			}

			int s=p-LOAD_16(ip);
			ip+=2;
			if (s<0)
				return -1;

			int len=(token&15)+MIN_MATCH;
			if (len==(15+MIN_MATCH))
			{
				for (;;)
				{
					const int c=g_buf[ip++];
					len+=c;
					if (c!=255)
						break;
				}
			}
			if ((p+len)>BLOCK_SIZE)
				return -1;

			if ((p-s)>=4)
			{
				wild_copy(p, s, len);
				p+=len;
			}
			else
			{
				while (len--!=0)
					g_buf[p++]=g_buf[s++];
			}
		}

		if (kwrite(g_buf, p, buf, &write_offset, maxOutputSize)!=p)
		{
			return -1;
		}
	}

	return 0;
}