/****************************************************************************
* Function : WriteHeader
* Description: This function writes the each symbol contained in a tree
* as well as its number of occurrences in the original file
* to the specified output file. If the same algorithm that
* produced the original tree is used with these counts, an
* exact copy of the tree will be produced.
* Parameters : ht - pointer to root of huffman tree
* bfp - pointer to open binary file to write to.
* Effects : Symbol values and symbol counts are written to a file.
* Returned : None
****************************************************************************/
static void WriteHeader(huffman_node_t *ht, bit_file_t *bfp)
{
unsigned int i;
for(;;)
{
/* follow this branch all the way left */
while (ht->left != NULL)
{
ht = ht->left;
}
if ((ht->value != COMPOSITE_NODE) &&
(ht->value != EOF_CHAR))
{
/* write symbol and count to header */
BitFilePutChar(ht->value, bfp);
BitFilePutBits(bfp, (void *)&(ht->count), 8 * sizeof(count_t));
}
while (ht->parent != NULL)
{
if (ht != ht->parent->right)
{
ht = ht->parent->right;
break;
}
else
{
/* parent's right tried, go up one level yet */
ht = ht->parent;
}
}
if (ht->parent == NULL)
{
/* we're at the top with nowhere to go */
break;
}
}
/* now write end of table char 0 count 0 */
BitFilePutChar(0, bfp);
for(i = 0; i < sizeof(count_t); i++)
{
BitFilePutChar(0, bfp);
}
}
void extract_fextract(bit_file_t *compressed, bit_file_t *extracted, tree_node* root, unsigned int bytecount) {
unsigned int bytesread = 0;
tree_node *current = root;
while (bytesread < bytecount) {
current = BitFileGetBit(compressed) ? current->right : current->left;
if (tree_is_leaf(current)) {
BitFilePutChar(current->content, extracted);
current = root;
bytesread++;
}
}
}
void DecodeFile(FILE *infile,FILE *outfile){
int ch;
huffman_node_t *huffmanLeaves[CHARCOUNT], *htree, *currentnode;
huffman_code_t *huffmanCodes[CHARCOUNT];
buffered_bit_file_t *bufferedInFile;
buffered_bit_file_t *bufferedOutFile=CreateBitOutFile(outfile);
for(ch=0;ch<CHARCOUNT;ch++){
huffmanLeaves[ch]=CreateNode(ch);
}
huffmanLeaves[EOF_CHAR]->value=EOF_CHAR;
huffmanLeaves[EOF_CHAR]->count=1;
ReadFrequencyArray(infile, huffmanLeaves);
htree=BuildTree(huffmanLeaves, CHARCOUNT);
bufferedInFile=CreateBitInFile(infile);
if(htree != huffmanLeaves[EOF_CHAR]){
for(int i=0;i<CHARCOUNT;i++){
huffmanCodes[i]=CreateCode();
}
GenerateCodeList(huffmanCodes, htree);
currentnode=htree;
for(;;){
int bit=BitFileGetBit(bufferedInFile);
if(bit != 0)
currentnode=currentnode->left;
else
currentnode=currentnode->right;
if(currentnode->value != COMBINE_NODE){
if(currentnode->value == EOF_CHAR){
BitFileFlush(bufferedOutFile);
break;
}
BitFilePutChar(bufferedOutFile, currentnode->value);
currentnode=htree;
}
}
for(int i=0;i<CHARCOUNT;i++)
free(huffmanCodes[i]);
}
FreeHuffmanTree(htree);
free(bufferedInFile);
free(bufferedOutFile);
}
/****************************************************************************
* Function : EncodeLZSSByFile
* Description: This function will read an input file and write an output
* file encoded according to the traditional LZSS algorithm.
* This algorithm encodes strings as 16 bits (a 12 bit offset
* + a 4 bit length).
* Parameters : fpIn - pointer to the open binary file to encode
* fpOut - pointer to the open binary file to write encoded
* output
* Effects : fpIn is encoded and written to fpOut. Neither file is
* closed after exit.
* Returned : EXIT_SUCCESS or EXIT_FAILURE
****************************************************************************/
int EncodeLZSSByFile(FILE *fpIn, FILE *fpOut)
{
bit_file_t *bfpOut;
encoded_string_t matchData;
unsigned int i, c;
unsigned int len; /* length of string */
/* head of sliding window and lookahead */
unsigned int windowHead, uncodedHead;
/* use stdin if no input file */
if (fpIn == NULL)
{
fpIn = stdin;
}
if (fpOut == NULL)
{
/* use stdout if no output file */
bfpOut = MakeBitFile(stdout, BF_WRITE);
}
else
{
/* convert output file to bitfile */
bfpOut = MakeBitFile(fpOut, BF_WRITE);
}
windowHead = 0;
uncodedHead = 0;
/* Window Size : 2^12 same as offset */
/************************************************************************
* Fill the sliding window buffer with some known vales. DecodeLZSS must
* use the same values. If common characters are used, there's an
* increased chance of matching to the earlier strings.
************************************************************************/
memset(slidingWindow, ' ', WINDOW_SIZE * sizeof(unsigned char));
/* MAX_CODED : 2 to 17 because we cant have 0 to 1 */
/************************************************************************
* Copy MAX_CODED bytes from the input file into the uncoded lookahead
* buffer.
************************************************************************/
for (len = 0; len < MAX_CODED && (c = getc(fpIn)) != EOF; len++)
{
uncodedLookahead[len] = c;
}
if (len == 0)
{
return (EXIT_SUCCESS); /* inFile was empty */
}
/* Look for matching string in sliding window */
InitializeSearchStructures();
matchData = FindMatch(windowHead, uncodedHead);
/* now encoded the rest of the file until an EOF is read */
while (len > 0)
{
if (matchData.length > len)
{
/* garbage beyond last data happened to extend match length */
matchData.length = len;
}
if (matchData.length <= MAX_UNCODED)
{
/* not long enough match. write uncoded flag and character */
BitFilePutBit(UNCODED, bfpOut);
BitFilePutChar(uncodedLookahead[uncodedHead], bfpOut);
matchData.length = 1; /* set to 1 for 1 byte uncoded */
}
else
{
unsigned int adjustedLen;
/* adjust the length of the match so minimun encoded len is 0*/
adjustedLen = matchData.length - (MAX_UNCODED + 1);
/* match length > MAX_UNCODED. Encode as offset and length. */
BitFilePutBit(ENCODED, bfpOut);
BitFilePutBitsInt(bfpOut, &matchData.offset, OFFSET_BITS,
sizeof(unsigned int));
BitFilePutBitsInt(bfpOut, &adjustedLen, LENGTH_BITS,
sizeof(unsigned int));
}
/********************************************************************
* Replace the matchData.length worth of bytes we've matched in the
* sliding window with new bytes from the input file.
********************************************************************/
i = 0;
while ((i < matchData.length) && ((c = getc(fpIn)) != EOF))
{
/* add old byte into sliding window and new into lookahead */
ReplaceChar(windowHead, uncodedLookahead[uncodedHead]);
uncodedLookahead[uncodedHead] = c;
windowHead = Wrap((windowHead + 1), WINDOW_SIZE);
uncodedHead = Wrap((uncodedHead + 1), MAX_CODED);
i++;
}
/* handle case where we hit EOF before filling lookahead */
while (i < matchData.length)
{
ReplaceChar(windowHead, uncodedLookahead[uncodedHead]);
/* nothing to add to lookahead here */
windowHead = Wrap((windowHead + 1), WINDOW_SIZE);
uncodedHead = Wrap((uncodedHead + 1), MAX_CODED);
len--;
i++;
}
/* find match for the remaining characters */
matchData = FindMatch(windowHead, uncodedHead);
}
/* we've decoded everything, free bitfile structure */
BitFileToFILE(bfpOut);
return (EXIT_SUCCESS);
}
/*
* aazip - compress files using a transform based compression system
*/
int main(int argc, char** argv)
{
FILE* f;
bit_file_t* of;
char* infile,*outfile;
uint8_t* input,*lupdate,*bwt,lumode;
int32_t I,osize,opt;
uint32_t size;
mode_t lupdate_alg;
float ient,oent;
uint64_t cost,tstart,tstop,elapsed;
/* parse command line parameter */
opt = GETOPT_FINISHED;
if (argc <= 1) {
print_usage(argv[0]);
exit(EXIT_FAILURE);
}
while ((opt = getopt(argc, argv, "m:h")) != GETOPT_FINISHED) {
switch (opt) {
case 'm':
if (strcmp(optarg, "simple") == 0) lupdate_alg = SIMPLE;
else if (strcmp(optarg, "mtf") == 0) lupdate_alg = MTF;
else if (strcmp(optarg, "fc") == 0) lupdate_alg = FC;
else if (strcmp(optarg, "wfc") == 0) lupdate_alg = WFC;
else if (strcmp(optarg, "timestamp") == 0) lupdate_alg = TS;
else fatal("ERROR: mode <%s> unknown!\n", optarg);
break;
case 'h':
default:
print_usage(argv[0]);
exit(EXIT_FAILURE);
}
}
/* read input file name */
if (optind < argc) infile = argv[optind];
else {
print_usage(argv[0]);
exit(EXIT_FAILURE);
}
/* read input file */
f = safe_fopen(infile,"r");
size = safe_filesize(f);
input = (uint8_t*) safe_malloc(size+1);
if (fread(input,1,size,f)!=(size_t)size) {
fatal("read input file.");
}
safe_fclose(f);
input[size] = 0;
/* TODO calculate input entropy */
ient = 0.0f;
/* perform bwt */
bwt = (uint8_t*) safe_malloc(size);
tstart = gettime();
bwt = transform_bwt(input,size,bwt,&I);
/* peform list update */
switch (lupdate_alg) {
case SIMPLE:
fprintf(stdout,"ALGORITHM: simple\n");
lupdate = lupdate_simple(bwt,size,input,&cost);
break;
case MTF:
fprintf(stdout,"ALGORITHM: move to front\n");
lupdate = lupdate_movetofront(bwt,size,input,&cost);
break;
case FC:
fprintf(stdout,"ALGORITHM: frequency count\n");
lupdate = lupdate_freqcount(bwt,size,input,&cost);
break;
case WFC:
fprintf(stdout,"ALGORITHM: weighted frequency count\n");
lupdate = lupdate_wfc(bwt,size,input,&cost);
break;
case TS:
fprintf(stdout,"ALGORITHM: timestamp\n");
lupdate = lupdate_timestamp(bwt,size,input,&cost);
break;
default:
fatal("unkown list update algorithm.");
}
fprintf(stdout,"INPUT: %s (%d bytes)\n",infile,size);
fprintf(stdout,"COST: %lu\n",cost);
/* TODO calculate entropy after list update*/
oent = 0.0f;
/* write output */
outfile = safe_strcat(infile,".aazip");
/* create bit file for writing */
of = BitFileOpen(outfile, BF_WRITE);
/* write aa zip header */
BitFilePutChar('A', of);
BitFilePutChar('A', of);
/* write I */
BitFilePutBitsInt(of,&I,32,sizeof(uint32_t));
/* write lupdate mode */
lumode = lupdate_alg;
BitFilePutBitsInt(of,&lumode,8,sizeof(uint8_t));
fprintf(stderr,"I %d lumode %d\n",I,lumode);
/* perform huffman coding */
encode_huffman(lupdate,size,of);
tstop = gettime();
elapsed = tstop - tstart;
fprintf(stdout,"TIME: %.3f s\n",(float)elapsed/1000000);
/* flush and get file stats */
BitFileFlushOutput(of,0);
f = BitFileToFILE(of);
osize = ftell(f);
fprintf(stdout,"OUTPUT: %s\n",outfile);
fprintf(stdout,"ENTROPY: %.2f bps / %.2f bps\n",ient,oent);
fprintf(stdout,"COMPRESSION: %.2f\n",((float)osize/(float)size)*100);
/* clean up*/
safe_fclose(f);
free(input);
free(bwt);
return (EXIT_SUCCESS);
}
/***************************************************************************
* Function : main
* Description: This function demonstrates the usage of each of the bit
* bit file functions.
* Parameters : argc - the number command line arguments (not used)
* Parameters : argv - array of command line arguments (not used)
* Effects : Writes bit file, reads back results, printing them to
* stdout.
* Returned : EXIT_SUCCESS
***************************************************************************/
int main(int argc, char *argv[])
{
bit_file_t *bfp;
FILE *fp;
int i, numCalls, value;
if (argc < 2)
{
numCalls = NUM_CALLS;
}
else
{
numCalls = atoi(argv[1]);
}
/* create bit file for writing */
bfp = BitFileOpen("testfile", BF_WRITE);
if (bfp == NULL)
{
perror("opening file");
return (EXIT_FAILURE);
}
/* write chars */
value = (int)'A';
for (i = 0; i < numCalls; i++)
{
printf("writing char %c\n", value);
if(BitFilePutChar(value, bfp) == EOF)
{
perror("writing char");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
value++;
}
/* write single bits */
value = 0;
for (i = 0; i < numCalls; i++)
{
printf("writing bit %d\n", value);
if(BitFilePutBit(value, bfp) == EOF)
{
perror("writing bit");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
value = 1 - value;
}
/* write ints as bits */
value = 0x11111111;
for (i = 0; i < numCalls; i++)
{
printf("writing bits %0X\n", (unsigned int)value);
if(BitFilePutBits(bfp, &value,
(unsigned int)(8 * sizeof(int))) == EOF)
{
perror("writing bits");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
value += 0x11111111;
}
/* close bit file */
if (BitFileClose(bfp) != 0)
{
perror("closing file");
return (EXIT_FAILURE);
}
else
{
printf("closed file\n");
}
/* reopen file for appending */
bfp = BitFileOpen("testfile", BF_APPEND);
if (bfp == NULL)
{
perror("opening file");
return (EXIT_FAILURE);
}
/* append some chars */
value = (int)'A';
for (i = 0; i < numCalls; i++)
{
printf("appending char %c\n", value);
if(BitFilePutChar(value, bfp) == EOF)
{
perror("appending char");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
value++;
}
/* write some bits from an integer */
value = 0x111;
for (i = 0; i < numCalls; i++)
{
printf("writing 12 bits from an integer %03X\n", (unsigned int)value);
if(BitFilePutBitsInt(bfp, &value, 12, sizeof(value)) == EOF)
{
perror("writing bits from an integer");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
value += 0x111;
}
/* convert to normal file */
fp = BitFileToFILE(bfp);
if (fp == NULL)
{
perror("converting to stdio FILE");
return (EXIT_FAILURE);
}
else
{
printf("converted to stdio FILE\n");
}
/* append some chars */
value = (int)'a';
for (i = 0; i < numCalls; i++)
{
printf("appending char %c\n", value);
if(fputc(value, fp) == EOF)
{
perror("appending char to FILE");
if (fclose(fp) == EOF)
{
perror("closing stdio FILE");
}
return (EXIT_FAILURE);
}
value++;
}
/* close file */
if (fclose(fp) == EOF)
{
perror("closing stdio FILE");
return (EXIT_FAILURE);
}
/* now read back writes */
/* open bit file */
bfp = BitFileOpen("testfile", BF_READ);
if (bfp == NULL)
{
perror("reopening file");
return (EXIT_FAILURE);
}
/* read chars */
for (i = 0; i < numCalls; i++)
{
value = BitFileGetChar(bfp);
if(value == EOF)
{
perror("reading char");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
else
{
printf("read %c\n", value);
}
}
/* read single bits */
for (i = 0; i < numCalls; i++)
{
value = BitFileGetBit(bfp);
if(value == EOF)
{
perror("reading bit");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
else
{
printf("read bit %d\n", value);
}
}
/* read ints as bits */
for (i = 0; i < numCalls; i++)
{
if(BitFileGetBits(bfp, &value, (unsigned int)(8 * sizeof(int))) == EOF)
{
perror("reading bits");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
else
{
printf("read bits %0X\n", (unsigned int)value);
}
}
if (BitFileByteAlign(bfp) == EOF)
{
fprintf(stderr, "failed to align file\n");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
else
{
printf("byte aligning file\n");
}
/* read appended characters */
for (i = 0; i < numCalls; i++)
{
value = BitFileGetChar(bfp);
if(value == EOF)
{
perror("reading char");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
else
{
printf("read %c\n", value);
}
}
/* read some bits into an integer */
for (i = 0; i < numCalls; i++)
{
value = 0;
if(BitFileGetBitsInt(bfp, &value, 12, sizeof(value)) == EOF)
{
perror("reading bits from an integer");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
else
{
printf("read 12 bits into an integer %03X\n", (unsigned int)value);
}
}
/* convert to stdio FILE */
fp = BitFileToFILE(bfp);
if (fp == NULL)
{
perror("converting to stdio FILE");
return (EXIT_FAILURE);
}
else
{
printf("converted to stdio FILE\n");
}
/* read append some chars */
value = (int)'a';
for (i = 0; i < numCalls; i++)
{
value = fgetc(fp);
if(value == EOF)
{
perror("stdio reading char");
if (0 != BitFileClose(bfp))
{
perror("closing bitfile");
}
return (EXIT_FAILURE);
}
else
{
printf("stdio read %c\n", value);
}
}
/* close file */
if (fclose(fp) == EOF)
{
perror("closing stdio FILE");
return (EXIT_FAILURE);
}
return(EXIT_SUCCESS);
}
