add huffman test

tools/huffman/huffman-decode.c

@@ -0,0 +1,224 @@
+/* huffman-decode.c */
+/*
+    This file is part of the AVR-Huffman.
+    Copyright (C) 2009  Daniel Otte (daniel.otte@rub.de)
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#define V_NODE (-2)
+#define V_EOF  (-1)
+
+#define PREFIX_SIZE_B 32 
+
+#define ALLOC_ERROR {fprintf(stderr,"failed to alloc memory in %s @ %d !\n",__FILE__, __LINE__); exit(-1);}
+
+#define DEBUG 0
+
+typedef struct {
+	int16_t value;
+	void*   left;
+	void*   right;
+} node_t;
+
+node_t* tree=NULL;
+uint16_t tree_index;
+
+void prefix_increment(uint8_t* prefix){
+	uint8_t i;
+	for(i=0; i<PREFIX_SIZE_B; ++i){
+		prefix[i] += 1;
+		if(prefix[i]!=0)
+			return;
+	}
+}
+
+void prefix_shiftleft(uint8_t* prefix){
+	uint8_t i;
+	uint8_t c[2]={0,0};
+	uint8_t ci=0;	
+	for(i=0; i<PREFIX_SIZE_B; ++i){
+		c[ci] = (prefix[i])>>7;				
+		prefix[i]<<=1;
+		ci ^= 1;
+		prefix[i]|=c[ci];
+	}
+}
+
+uint8_t append_tree(int16_t value, uint16_t depth){
+	static uint8_t prefix[PREFIX_SIZE_B];
+	static uint8_t cdepth=0;	
+	node_t* current=tree;
+	int8_t i,t;
+	for(;cdepth<depth;++cdepth){
+		prefix_shiftleft(prefix);
+	}
+	for(i=depth-1; i>=0; --i){
+		t=(prefix[i/8])&(1<<(i%8));
+		if(t==0){
+			if(current->left==NULL){
+			//	current->left=calloc(1, sizeof(node_t));
+				current->left=&(tree[tree_index++]);
+				((node_t*)(current->left))->value = V_NODE;
+			}
+			current = current->left;
+		} else {
+			if(current->right==NULL){
+			//	current->right=calloc(1, sizeof(node_t));
+				current->right=&(tree[tree_index++]);
+				((node_t*)(current->right))->value = V_NODE;
+			}
+			current = current->right;
+		}
+	}
+	if(current==NULL)
+		ALLOC_ERROR
+	current->value=value;
+	prefix_increment(prefix);
+	return prefix[depth/8]&(1<<(depth%8));
+}
+
+void set_last_to_eof(void){
+	node_t* current=tree;
+	while(current->value==V_NODE)
+		current=current->right;
+	current->value=V_EOF;
+}
+
+void build_tree(FILE* f){
+	uint16_t treesize;
+	uint16_t x1, x2;
+	x1 =fgetc(f);
+	x2 =fgetc(f);
+	if(x1!=0xc0 || (x2&0xFE)!=0xde){
+		fprintf(stderr,"No magic values found!\n");
+	}
+	treesize= fgetc(f);
+	if(treesize>0xff){
+		fprintf(stderr,"You are trying to uncompress an empty file!\n");
+		exit(-3);
+	}
+	treesize = 2*(((x2&1)<<8)+treesize)-1;
+	//printf("Using treesize=%i with size of %i\n", treesize, sizeof(node_t));
+	tree = calloc(treesize, sizeof(node_t));
+	if(tree==NULL)
+		ALLOC_ERROR
+	tree->value = V_NODE;
+	tree_index=1;
+	uint16_t depth=0;
+	uint16_t count=0;
+	uint8_t  v;
+	do{
+		while(count==0){
+			depth++;
+			count= fgetc(f);
+			if(count==255)
+				count += fgetc(f);
+		}
+		v = fgetc(f);
+		--count;
+	}while(!append_tree(v, depth));		
+	set_last_to_eof();
+}
+
+
+void free_tree(node_t* node){
+	free(node);
+}
+
+FILE* outfile;
+FILE* infile;
+
+void write_char(uint8_t v){
+	fputc(v, outfile);
+}
+
+uint8_t read_bit(void){
+	static uint8_t buffer;
+	static uint8_t index=0;
+	uint8_t t;
+	if(index==0){
+		buffer = fgetc(infile);
+		if(feof(infile))
+			return 0xFF;
+	}
+	t=buffer>>7;
+	buffer<<=1;
+	index = (index+1)%8;
+	return t;
+}
+
+uint16_t decompress_byte(void){
+	node_t* current=tree;
+	uint8_t t;
+	while(current->value==V_NODE){
+		t=read_bit();
+		if(t==0xFF)
+			return EOF;
+		if(t==0){
+			current=current->left;
+		} else {
+			current=current->right;
+		}
+		if(current==NULL){
+			fprintf(stderr, "Tree damaged!\n");
+			exit(-4);
+		}
+	}
+	return current->value;
+}
+
+void decompress(void){
+	uint16_t t;
+	for(;;){
+		t=decompress_byte();
+		if(t==(uint16_t)EOF)
+			return;
+		write_char(t);	
+	}
+}
+
+int main(int argc, char** argv){
+	int i;
+	FILE* fin;
+	FILE* fg;
+//	outfile=stdout;
+	for(i=1;i<argc;++i){
+		fin = fopen(argv[i], "r");
+		fg  = fopen("graphout.dot", "w");
+		outfile = fopen("decompress.out", "w");
+		puts("building tree ...");
+		build_tree(fin);
+		fclose(fg);
+		infile=fin;
+		puts("decompression ...");
+		decompress();
+		fclose(fin);
+		fclose(outfile);
+		free_tree(tree);
+	}
+	return 0;
+}
+
+
+
+
+
+
+