huffcode.c

#include "huffman.h"
#ifdef USE_PARALLEL
#include "huffman_parallel.h"
#endif

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

#ifdef WIN32
#include <malloc.h>
extern int getopt(int, char**, char*);
extern char* optarg;
#else
#include <unistd.h>
#endif
#include <bits/getopt_core.h>

static int memory_encode_file(FILE* in, FILE* out, int parallel);
static int memory_decode_file(FILE* in, FILE* out, int parallel);

static void usage(FILE* out)
{
	fputs("Usage: huffcode [-i<input file>] [-o<output file>] [-d|-c] [-p]\n"
	      "-i - input file (default is standard input)\n"
	      "-o - output file (default is standard output)\n"
	      "-d - decompress\n"
	      "-c - compress (default)\n"
	      "-m - read file into memory, compress, then write to file (not default)\n"
#ifdef USE_PARALLEL
	      "-p - use parallel version\n"
#endif
	      ,
	      out);
}

int main(int argc, char** argv)
{
	char memory = 0;
	char compress = 1;
	int parallel = 0;
	int opt;
	const char *file_in = NULL, *file_out = NULL;
	FILE* in = stdin;
	FILE* out = stdout;
	int close_in = 0;
	int close_out = 0;
	int rc = 0;

	/* Get the command line arguments. */
	while ((opt = getopt(argc,
			     argv,
			     "i:o:cdhvm"
#ifdef USE_PARALLEL
			     "p"
#endif
			     )) != -1)
	{
		switch (opt)
		{
		case 'i':
			file_in = optarg;
			break;
		case 'o':
			file_out = optarg;
			break;
		case 'c':
			compress = 1;
			break;
		case 'd':
			compress = 0;
			break;
		case 'h':
			usage(stdout);
			return 0;
		case 'm':
			memory = 1;
			break;
#ifdef USE_PARALLEL
		case 'p':
			parallel = 1;
			break;
#endif
		default:
			usage(stderr);
			return 1;
		}
	}

	/* If an input file is given then open it. */
	if (file_in)
	{
		in = fopen(file_in, "rb");
		if (!in)
		{
			fprintf(
			    stderr, "Can't open input file '%s': %s\n", file_in, strerror(errno));
			return 1;
		}
		close_in = 1;
	}

	/* If an output file is given then create it. */
	if (file_out)
	{
		out = fopen(file_out, "wb");
		if (!out)
		{
			fprintf(
			    stderr, "Can't open output file '%s': %s\n", file_out, strerror(errno));
			return 1;
		}
		close_out = 1;
	}

	if (memory)
	{
		return compress ? memory_encode_file(in, out, parallel)
				: memory_decode_file(in, out, parallel);
	}

	if (compress)
	{
#ifdef USE_PARALLEL
		if (parallel)
			rc = huffman_encode_file_parallel(in, out);
		else
#endif
			rc = huffman_encode_file(in, out);
	}
	else
	{
#ifdef USE_PARALLEL
		if (parallel)
			rc = huffman_decode_file_parallel(in, out);
		else
#endif
			rc = huffman_decode_file(in, out);
	}

	/* Since exit is about to happen, the fclose calls aren't necessary, but they make valgrind
	 * happy. */
	if (close_in)
	{
		fclose(in);
	}

	if (close_out)
	{
		fclose(out);
	}

	return rc;
}

static int memory_encode_file(FILE* in, FILE* out, int parallel)
{
	(void)parallel; // Suppress unused parameter warning when not using parallel
	unsigned char *buf = NULL, *bufout = NULL;
	uint32_t len = 0, cur = 0, inc = 1024, bufoutlen = 0;

	assert(in && out);

	/* Read the file into memory. Use fread return value to detect EOF/errors. */
	while (1)
	{
		size_t got;
		unsigned char* tmp;
		if (cur + inc > len)
		{
			len += inc;
			tmp = (unsigned char*)realloc(buf, len);
			if (!tmp)
			{
				if (buf)
					free(buf);
				return 1;
			}
			buf = tmp;
		}

		got = fread(buf + cur, 1, inc, in);
		cur += (unsigned int)got;
		if (got < inc)
			break; /* EOF or short read */
	}

	if (!buf)
		return 1;

	/* Encode the memory. */
#ifdef USE_PARALLEL
	if (parallel)
	{
		if (huffman_encode_memory_parallel(buf, cur, &bufout, &bufoutlen))
		{
			free(buf);
			return 1;
		}
	}
	else
#endif
	{
		if (huffman_encode_memory(buf, cur, &bufout, &bufoutlen))
		{
			free(buf);
			return 1;
		}
	}

	free(buf);

	/* Write the memory to the file. */
	if (fwrite(bufout, 1, bufoutlen, out) != bufoutlen)
	{
		free(bufout);
		return 1;
	}

	free(bufout);

	return 0;
}

static int memory_decode_file(FILE* in, FILE* out, int parallel)
{
	(void)parallel; // Suppress unused parameter warning when not using parallel
	unsigned char *buf = NULL, *bufout = NULL;
	uint32_t len = 0, cur = 0, inc = 1024, bufoutlen = 0;
	assert(in && out);

	/* Read the file into memory. Use fread return value to detect EOF/errors. */
	while (1)
	{
		size_t got;
		unsigned char* tmp;
		if (cur + inc > len)
		{
			len += inc;
			tmp = (unsigned char*)realloc(buf, len);
			if (!tmp)
			{
				if (buf)
					free(buf);
				return 1;
			}
			buf = tmp;
		}

		got = fread(buf + cur, 1, inc, in);
		cur += (unsigned int)got;
		if (got < inc)
			break; /* EOF or short read */
	}

	if (!buf)
		return 1;

	/* Decode the memory. */
#ifdef USE_PARALLEL
	if (parallel)
	{
		if (huffman_decode_memory_parallel(buf, cur, &bufout, &bufoutlen))
		{
			free(buf);
			return 1;
		}
	}
	else
#endif
	{
		if (huffman_decode_memory(buf, cur, &bufout, &bufoutlen))
		{
			free(buf);
			return 1;
		}
	}

	free(buf);

	/* Write the memory to the file. */
	if (fwrite(bufout, 1, bufoutlen, out) != bufoutlen)
	{
		free(bufout);
		return 1;
	}

	free(bufout);

	return 0;
}