[proxmark3-svn] / client / fpga_compress.c

//-----------------------------------------------------------------------------
// This code is licensed to you under the terms of the GNU GPL, version 2 or,
// at your option, any later version. See the LICENSE.txt file for the text of
// the license.
//-----------------------------------------------------------------------------
// Compression tool for FPGA config files. Compress several *.bit files at
// compile time. Decompression is done at run time (see fpgaloader.c).
// This uses the zlib library tuned to this specific case. The small file sizes
// allow to use "insane" parameters for optimum compression ratio.
//-----------------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <stdbool.h>
#include "zlib.h"

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

// zlib configuration
#define COMPRESS_LEVEL			9		// use best possible compression
#define COMPRESS_WINDOW_BITS	15		// default = max = 15 for a window of 2^15 = 32KBytes
#define COMPRESS_MEM_LEVEL		9		// determines the amount of memory allocated during compression. Default = 8.
/* COMPRESS_STRATEGY can be 
	Z_DEFAULT_STRATEGY (the default), 
	Z_FILTERED (more huffmann, less string matching),
	Z_HUFFMAN_ONLY (huffman only, no string matching)
	Z_RLE (distances limited to one)
	Z_FIXED (prevents the use of dynamic Huffman codes)
*/	
#define	COMPRESS_STRATEGY		Z_DEFAULT_STRATEGY
// zlib tuning parameters:
#define COMPRESS_GOOD_LENGTH		258
#define	COMPRESS_MAX_LAZY			258	
#define	COMPRESS_MAX_NICE_LENGTH	258
#define	COMPRESS_MAX_CHAIN			8192

#define FPGA_INTERLEAVE_SIZE	288 	// (the FPGA's internal config frame size is 288 bits. Interleaving with 288 bytes should give best compression)
#define FPGA_CONFIG_SIZE		42336	// our current fpga_[lh]f.bit files are 42175 bytes. Rounded up to next multiple of FPGA_INTERLEAVE_SIZE

static void usage(void)
{
	fprintf(stderr, "Usage: fpga_compress <infile1> <infile2> ... <infile_n> <outfile>\n");
	fprintf(stderr, "          Combine n FPGA bitstream files and compress them into one.\n\n");
	fprintf(stderr, "       fpga_compress -d <infile> <outfile>");
	fprintf(stderr, "          Decompress <infile>. Write result to <outfile>");
}


static voidpf fpga_deflate_malloc(voidpf opaque, uInt items, uInt size)
{
	return malloc(items*size);
}


static void fpga_deflate_free(voidpf opaque, voidpf address)
{
	return free(address);
}


static bool all_feof(FILE *infile[], uint8_t num_infiles)
{
	for (uint16_t i = 0; i < num_infiles; i++) {
		if (!feof(infile[i])) {
			return false;
		}
	}
	
	return true;
}


int zlib_compress(FILE *infile[], uint8_t num_infiles, FILE *outfile)
{
	uint8_t *fpga_config;
	uint32_t i;
	int ret;
	int c;		
	z_stream compressed_fpga_stream;

	fpga_config = malloc(num_infiles * FPGA_CONFIG_SIZE);
	
	// read the input files. Interleave them into fpga_config[]
	i = 0;
	do {

		if (i >= num_infiles * FPGA_CONFIG_SIZE) {
			fprintf(stderr, "Input files too big (total > %d bytes). These are probably not PM3 FPGA config files.\n", num_infiles*FPGA_CONFIG_SIZE);
			for(uint16_t j = 0; j < num_infiles; j++) {
				fclose(infile[j]);
			}
			free(fpga_config);
			return(EXIT_FAILURE);
		}

		for(uint16_t j = 0; j < num_infiles; j++) {
			for(uint16_t k = 0; k < FPGA_INTERLEAVE_SIZE; k++) {
				c = fgetc(infile[j]);
				if (!feof(infile[j])) {
					fpga_config[i++] = c &0xFF;
				} else if (num_infiles > 1) {
					fpga_config[i++] = '\0';
				}
			}
		}

	} while (!all_feof(infile, num_infiles));

	// initialize zlib structures
	compressed_fpga_stream.next_in = fpga_config;
	compressed_fpga_stream.avail_in = i;
	compressed_fpga_stream.zalloc = fpga_deflate_malloc;
	compressed_fpga_stream.zfree = fpga_deflate_free;
	compressed_fpga_stream.opaque = Z_NULL;
	
	ret = deflateInit2(&compressed_fpga_stream, 
						COMPRESS_LEVEL,
						Z_DEFLATED,
						COMPRESS_WINDOW_BITS,
						COMPRESS_MEM_LEVEL,
						COMPRESS_STRATEGY);

	// estimate the size of the compressed output
	unsigned int outsize_max = deflateBound(&compressed_fpga_stream, compressed_fpga_stream.avail_in);
	uint8_t *outbuf = malloc(outsize_max);
	compressed_fpga_stream.next_out = outbuf;
	compressed_fpga_stream.avail_out = outsize_max;
					
	if (ret == Z_OK) {
		ret = deflateTune(&compressed_fpga_stream,
							COMPRESS_GOOD_LENGTH,
							COMPRESS_MAX_LAZY,
							COMPRESS_MAX_NICE_LENGTH,
							COMPRESS_MAX_CHAIN);
	}
	
	if (ret == Z_OK) {
		ret = deflate(&compressed_fpga_stream, Z_FINISH);
	}
	
	fprintf(stderr, "compressed %u input bytes to %lu output bytes\n", i, compressed_fpga_stream.total_out);

	if (ret != Z_STREAM_END) {
		fprintf(stderr, "Error in deflate(): %d %s\n", ret, compressed_fpga_stream.msg);
		free(outbuf);
		deflateEnd(&compressed_fpga_stream);
		for(uint16_t j = 0; j < num_infiles; j++) {
			fclose(infile[j]);
		}
		fclose(outfile);
		free(infile);
		free(fpga_config);
		return(EXIT_FAILURE);
		}
		
	for (i = 0; i < compressed_fpga_stream.total_out; i++) {
		fputc(outbuf[i], outfile);
	}	

	free(outbuf);
	deflateEnd(&compressed_fpga_stream);
	for(uint16_t j = 0; j < num_infiles; j++) {
		fclose(infile[j]);
	}
	fclose(outfile);
	free(infile);
	free(fpga_config);
	
	return(EXIT_SUCCESS);
	
}


int zlib_decompress(FILE *infile, FILE *outfile)
{
	#define DECOMPRESS_BUF_SIZE 1024
	uint8_t outbuf[DECOMPRESS_BUF_SIZE];
	uint8_t inbuf[DECOMPRESS_BUF_SIZE];
	int ret;
	
	z_stream compressed_fpga_stream;

	// initialize zlib structures
	compressed_fpga_stream.next_in = inbuf;
	compressed_fpga_stream.avail_in = 0;
	compressed_fpga_stream.next_out = outbuf;
	compressed_fpga_stream.avail_out = DECOMPRESS_BUF_SIZE;
	compressed_fpga_stream.zalloc = fpga_deflate_malloc;
	compressed_fpga_stream.zfree = fpga_deflate_free;
	compressed_fpga_stream.opaque = Z_NULL;
	
	ret = inflateInit2(&compressed_fpga_stream, 0);
	
	do {
		if (compressed_fpga_stream.avail_in == 0) {
			compressed_fpga_stream.next_in = inbuf;
			uint16_t i = 0;
			do {
				int c = fgetc(infile);
				if (!feof(infile)) {
					inbuf[i++] = c;
					compressed_fpga_stream.avail_in++;
				} else {
					break;
				}
			} while (i < DECOMPRESS_BUF_SIZE);
		}

		ret = inflate(&compressed_fpga_stream, Z_SYNC_FLUSH);

		if (ret != Z_OK && ret != Z_STREAM_END) {
			break;
		}

		if (compressed_fpga_stream.avail_out == 0) {
			for (uint16_t i = 0; i < DECOMPRESS_BUF_SIZE; i++) {
				fputc(outbuf[i], outfile);
			}
			compressed_fpga_stream.avail_out = DECOMPRESS_BUF_SIZE;
			compressed_fpga_stream.next_out = outbuf;
		}
	} while (ret == Z_OK);

	if (ret == Z_STREAM_END) {  // reached end of input
		uint16_t i = 0;
		while (compressed_fpga_stream.avail_out < DECOMPRESS_BUF_SIZE) {
			fputc(outbuf[i++], outfile);
			compressed_fpga_stream.avail_out++;
		}
		fclose(outfile);
		fclose(infile);
		return(EXIT_SUCCESS);
	} else {
		fprintf(stderr, "Error. Inflate() returned error %d, %s", ret, compressed_fpga_stream.msg);
		fclose(outfile);
		fclose(infile);
		return(EXIT_FAILURE);
	}
	
}


int main(int argc, char **argv)
{
	FILE **infiles;
	FILE *outfile;
	
	if (argc == 1 || argc == 2) {
		usage();
		return(EXIT_FAILURE);
	}
	
	if (!strcmp(argv[1], "-d")) {			// Decompress
		infiles = calloc(1, sizeof(FILE*));
		if (argc != 4) {
			usage();
			return(EXIT_FAILURE);
		} 
		infiles[0] = fopen(argv[2], "rb");
		if (infiles[0] == NULL) {
			fprintf(stderr, "Error. Cannot open input file %s", argv[2]);
			return(EXIT_FAILURE);
		}
		outfile = fopen(argv[3], "wb");
		if (outfile == NULL) {
			fprintf(stderr, "Error. Cannot open output file %s", argv[3]);
			return(EXIT_FAILURE);
		}
		return zlib_decompress(infiles[0], outfile);

	} else {								// Compress

		infiles = calloc(argc-2, sizeof(FILE*));
		for (uint16_t i = 0; i < argc-2; i++) { 
			infiles[i] = fopen(argv[i+1], "rb");
			if (infiles[i] == NULL) {
				fprintf(stderr, "Error. Cannot open input file %s", argv[i+1]);
				return(EXIT_FAILURE);
			}
		}
		outfile = fopen(argv[argc-1], "wb");
		if (outfile == NULL) {
			fprintf(stderr, "Error. Cannot open output file %s", argv[argc-1]);
			return(EXIT_FAILURE);
		}
		return zlib_compress(infiles, argc-2, outfile);
	}
}
Commit	Line	Data
5ce7e22a	1	//-----------------------------------------------------------------------------
	2	// This code is licensed to you under the terms of the GNU GPL, version 2 or,
	3	// at your option, any later version. See the LICENSE.txt file for the text of
	4	// the license.
	5	//-----------------------------------------------------------------------------
	6	// Compression tool for FPGA config files. Compress several *.bit files at
	7	// compile time. Decompression is done at run time (see fpgaloader.c).
	8	// This uses the zlib library tuned to this specific case. The small file sizes
	9	// allow to use "insane" parameters for optimum compression ratio.
	10	//-----------------------------------------------------------------------------
	11
	12	#include <stdio.h>
	13	#include <stdlib.h>
	14	#include <string.h>
	15	#include <stdint.h>
	16	#include <stdbool.h>
	17	#include "zlib.h"
	18
	19	#define MAX(a,b) ((a)>(b)?(a):(b))
	20
	21	// zlib configuration
	22	#define COMPRESS_LEVEL 9 // use best possible compression
	23	#define COMPRESS_WINDOW_BITS 15 // default = max = 15 for a window of 2^15 = 32KBytes
	24	#define COMPRESS_MEM_LEVEL 9 // determines the amount of memory allocated during compression. Default = 8.
	25	/* COMPRESS_STRATEGY can be
	26	Z_DEFAULT_STRATEGY (the default),
	27	Z_FILTERED (more huffmann, less string matching),
	28	Z_HUFFMAN_ONLY (huffman only, no string matching)
	29	Z_RLE (distances limited to one)
	30	Z_FIXED (prevents the use of dynamic Huffman codes)
	31	*/
	32	#define COMPRESS_STRATEGY Z_DEFAULT_STRATEGY
	33	// zlib tuning parameters:
	34	#define COMPRESS_GOOD_LENGTH 258
	35	#define COMPRESS_MAX_LAZY 258
	36	#define COMPRESS_MAX_NICE_LENGTH 258
	37	#define COMPRESS_MAX_CHAIN 8192
	38
	39	#define FPGA_INTERLEAVE_SIZE 288 // (the FPGA's internal config frame size is 288 bits. Interleaving with 288 bytes should give best compression)
	40	#define FPGA_CONFIG_SIZE 42336 // our current fpga_[lh]f.bit files are 42175 bytes. Rounded up to next multiple of FPGA_INTERLEAVE_SIZE
	41
	42	static void usage(void)
	43	{
	44	fprintf(stderr, "Usage: fpga_compress <infile1> <infile2> ... <infile_n> <outfile>\n");
	45	fprintf(stderr, " Combine n FPGA bitstream files and compress them into one.\n\n");
	46	fprintf(stderr, " fpga_compress -d <infile> <outfile>");
	47	fprintf(stderr, " Decompress <infile>. Write result to <outfile>");
	48	}
	49
	50
	51	static voidpf fpga_deflate_malloc(voidpf opaque, uInt items, uInt size)
	52	{
	53	return malloc(items*size);
	54	}
	55
	56
	57	static void fpga_deflate_free(voidpf opaque, voidpf address)
	58	{
	59	return free(address);
	60	}
	61
	62
	63	static bool all_feof(FILE *infile[], uint8_t num_infiles)
	64	{
65	for (uint16_t i = 0; i < num_infiles; i++) {
66	if (!feof(infile[i])) {
67	return false;
68	}
69	}
70
71	return true;
72	}
73
74
75	int zlib_compress(FILE infile[], uint8_t num_infiles, FILE outfile)
76	{
77	uint8_t *fpga_config;
78	uint32_t i;
79	int ret;
5f5aa82b	80	int c;
5ce7e22a	81	z_stream compressed_fpga_stream;
	82
	83	fpga_config = malloc(num_infiles * FPGA_CONFIG_SIZE);
	84
	85	// read the input files. Interleave them into fpga_config[]
	86	i = 0;
	87	do {
	88
	89	if (i >= num_infiles * FPGA_CONFIG_SIZE) {
43d3f769	90	fprintf(stderr, "Input files too big (total > %d bytes). These are probably not PM3 FPGA config files.\n", num_infiles*FPGA_CONFIG_SIZE);
43d3f769	91	for(uint16_t j = 0; j < num_infiles; j++) {
5ce7e22a	92	fclose(infile[j]);
5ce7e22a	93	}
639a5718	94	free(fpga_config);
5ce7e22a	95	return(EXIT_FAILURE);
	96	}
	97
	98	for(uint16_t j = 0; j < num_infiles; j++) {
	99	for(uint16_t k = 0; k < FPGA_INTERLEAVE_SIZE; k++) {
	100	c = fgetc(infile[j]);
	101	if (!feof(infile[j])) {
5f5aa82b	102	fpga_config[i++] = c &0xFF;
5ce7e22a	103	} else if (num_infiles > 1) {
	104	fpga_config[i++] = '\0';
	105	}
	106	}
	107	}
	108
	109	} while (!all_feof(infile, num_infiles));
	110
	111	// initialize zlib structures
	112	compressed_fpga_stream.next_in = fpga_config;
	113	compressed_fpga_stream.avail_in = i;
	114	compressed_fpga_stream.zalloc = fpga_deflate_malloc;
	115	compressed_fpga_stream.zfree = fpga_deflate_free;
88696833	116	compressed_fpga_stream.opaque = Z_NULL;
5ce7e22a	117
	118	ret = deflateInit2(&compressed_fpga_stream,
	119	COMPRESS_LEVEL,
	120	Z_DEFLATED,
	121	COMPRESS_WINDOW_BITS,
	122	COMPRESS_MEM_LEVEL,
	123	COMPRESS_STRATEGY);
	124
	125	// estimate the size of the compressed output
	126	unsigned int outsize_max = deflateBound(&compressed_fpga_stream, compressed_fpga_stream.avail_in);
	127	uint8_t *outbuf = malloc(outsize_max);
	128	compressed_fpga_stream.next_out = outbuf;
	129	compressed_fpga_stream.avail_out = outsize_max;
	130
	131	if (ret == Z_OK) {
	132	ret = deflateTune(&compressed_fpga_stream,
	133	COMPRESS_GOOD_LENGTH,
	134	COMPRESS_MAX_LAZY,
	135	COMPRESS_MAX_NICE_LENGTH,
	136	COMPRESS_MAX_CHAIN);
	137	}
	138
	139	if (ret == Z_OK) {
	140	ret = deflate(&compressed_fpga_stream, Z_FINISH);
	141	}
	142
7f975d7e	143	fprintf(stderr, "compressed %u input bytes to %lu output bytes\n", i, compressed_fpga_stream.total_out);
5ce7e22a	144
	145	if (ret != Z_STREAM_END) {
	146	fprintf(stderr, "Error in deflate(): %d %s\n", ret, compressed_fpga_stream.msg);
	147	free(outbuf);
	148	deflateEnd(&compressed_fpga_stream);
	149	for(uint16_t j = 0; j < num_infiles; j++) {
	150	fclose(infile[j]);
	151	}
	152	fclose(outfile);
	153	free(infile);
	154	free(fpga_config);
	155	return(EXIT_FAILURE);
	156	}
	157
	158	for (i = 0; i < compressed_fpga_stream.total_out; i++) {
	159	fputc(outbuf[i], outfile);
	160	}
	161
	162	free(outbuf);
	163	deflateEnd(&compressed_fpga_stream);
	164	for(uint16_t j = 0; j < num_infiles; j++) {
	165	fclose(infile[j]);
	166	}
	167	fclose(outfile);
	168	free(infile);
	169	free(fpga_config);
	170
	171	return(EXIT_SUCCESS);
	172
	173	}
	174
	175
	176	int zlib_decompress(FILE infile, FILE outfile)
	177	{
	178	#define DECOMPRESS_BUF_SIZE 1024
	179	uint8_t outbuf[DECOMPRESS_BUF_SIZE];
	180	uint8_t inbuf[DECOMPRESS_BUF_SIZE];
	181	int ret;
	182
	183	z_stream compressed_fpga_stream;
	184
	185	// initialize zlib structures
	186	compressed_fpga_stream.next_in = inbuf;
	187	compressed_fpga_stream.avail_in = 0;
	188	compressed_fpga_stream.next_out = outbuf;
	189	compressed_fpga_stream.avail_out = DECOMPRESS_BUF_SIZE;
	190	compressed_fpga_stream.zalloc = fpga_deflate_malloc;
	191	compressed_fpga_stream.zfree = fpga_deflate_free;
704d552a	192	compressed_fpga_stream.opaque = Z_NULL;
5ce7e22a	193
	194	ret = inflateInit2(&compressed_fpga_stream, 0);
	195
	196	do {
	197	if (compressed_fpga_stream.avail_in == 0) {
	198	compressed_fpga_stream.next_in = inbuf;
	199	uint16_t i = 0;
	200	do {
639a5718	201	int c = fgetc(infile);
5ce7e22a	202	if (!feof(infile)) {
	203	inbuf[i++] = c;
	204	compressed_fpga_stream.avail_in++;
	205	} else {
	206	break;
	207	}
	208	} while (i < DECOMPRESS_BUF_SIZE);
	209	}
	210
	211	ret = inflate(&compressed_fpga_stream, Z_SYNC_FLUSH);
	212
	213	if (ret != Z_OK && ret != Z_STREAM_END) {
	214	break;
	215	}
	216
	217	if (compressed_fpga_stream.avail_out == 0) {
	218	for (uint16_t i = 0; i < DECOMPRESS_BUF_SIZE; i++) {
	219	fputc(outbuf[i], outfile);
	220	}
	221	compressed_fpga_stream.avail_out = DECOMPRESS_BUF_SIZE;
	222	compressed_fpga_stream.next_out = outbuf;
	223	}
	224	} while (ret == Z_OK);
	225
	226	if (ret == Z_STREAM_END) { // reached end of input
	227	uint16_t i = 0;
	228	while (compressed_fpga_stream.avail_out < DECOMPRESS_BUF_SIZE) {
	229	fputc(outbuf[i++], outfile);
	230	compressed_fpga_stream.avail_out++;
	231	}
	232	fclose(outfile);
	233	fclose(infile);
	234	return(EXIT_SUCCESS);
	235	} else {
	236	fprintf(stderr, "Error. Inflate() returned error %d, %s", ret, compressed_fpga_stream.msg);
	237	fclose(outfile);
	238	fclose(infile);
	239	return(EXIT_FAILURE);
	240	}
	241
	242	}
	243
	244
	245	int main(int argc, char **argv)
	246	{
	247	FILE **infiles;
	248	FILE *outfile;
	249
	250	if (argc == 1 \|\| argc == 2) {
	251	usage();
	252	return(EXIT_FAILURE);
	253	}
	254
	255	if (!strcmp(argv[1], "-d")) { // Decompress
	256	infiles = calloc(1, sizeof(FILE*));
	257	if (argc != 4) {
	258	usage();
	259	return(EXIT_FAILURE);
	260	}
	261	infiles[0] = fopen(argv[2], "rb");
	262	if (infiles[0] == NULL) {
	263	fprintf(stderr, "Error. Cannot open input file %s", argv[2]);
	264	return(EXIT_FAILURE);
	265	}
266	outfile = fopen(argv[3], "wb");
267	if (outfile == NULL) {
268	fprintf(stderr, "Error. Cannot open output file %s", argv[3]);
269	return(EXIT_FAILURE);
270	}
271	return zlib_decompress(infiles[0], outfile);
272
273	} else { // Compress
274
275	infiles = calloc(argc-2, sizeof(FILE*));
276	for (uint16_t i = 0; i < argc-2; i++) {
277	infiles[i] = fopen(argv[i+1], "rb");
278	if (infiles[i] == NULL) {
279	fprintf(stderr, "Error. Cannot open input file %s", argv[i+1]);
280	return(EXIT_FAILURE);
281	}
282	}
283	outfile = fopen(argv[argc-1], "wb");
284	if (outfile == NULL) {
285	fprintf(stderr, "Error. Cannot open output file %s", argv[argc-1]);
286	return(EXIT_FAILURE);
287	}
288	return zlib_compress(infiles, argc-2, outfile);
289	}
290	}