decoding.c

//Huffman coding
//Adam Rachuba
//Decoding program
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>

#define MAX_CODE_BYTE 4

int symbols_number=0;
int bytes_number=0;

struct code_table 
{
    int symbol;
    unsigned char code[MAX_CODE_BYTE];
    unsigned char length;
};

struct node
{
    int value;
    int symbol;
    struct node *right;
    struct node *left;
};

char *new_extension(const char file[], const char new_extension[])
{
    int n = strlen(file);
    int i = n - 1;
    while (i >= 0 && file[i] != '.') i--;
    char *new_file = malloc((n + strlen(new_extension) + 2) * sizeof(char));
    if (new_file == NULL)
    {
        printf("Memory allocation failed\n");
        exit(EXIT_FAILURE);
    }
    if (i > 0) 
    {
        strncpy(new_file, file, i + 1);
        new_file[i + 1] = '\0';
    }
    else if(i==0) strcpy(new_file, file);
    strcat(new_file, new_extension);
    return new_file;
}

struct code_table* load_code_table(char name_file[]) 
{
    FILE* file = fopen(name_file, "rb");
    if (file == NULL) 
	{
        fprintf(stderr, "Unable to open file %s\n", name_file);
        exit(EXIT_FAILURE);
    }

    char ch;
    while ((ch = fgetc(file)) != EOF) 
	{
        if (ch == '\n') symbols_number++;
    }

    rewind(file);

    struct code_table* code_tab = malloc(symbols_number * sizeof(struct code_table));
    if (code_tab == NULL) 
	{
        fprintf(stderr, "Memory allocation failed\n");
        exit(EXIT_FAILURE);
    }

    int i;
    for (i = 0; i < symbols_number; i++) 
	{
        if (fscanf(file, "%d", &code_tab[i].symbol) != 1) 
		{
            fprintf(stderr, "Invalid file format\n");
            exit(EXIT_FAILURE);
        }
        int j=0;
        for (j = 0; j < MAX_CODE_BYTE; j++) 
		{
            if (fscanf(file, "%hhu", &code_tab[i].code[j]) != 1) 
			{
                fprintf(stderr, "Invalid file format\n");
                exit(EXIT_FAILURE);
            }
        }
        if (fscanf(file, "%hhu", &code_tab[i].length) != 1) 
		{
            fprintf(stderr, "Invalid file format\n");
            exit(EXIT_FAILURE);
        }
    }

    fclose(file);

    return code_tab;
}

int load_bytes_number(const char* name_file) 
{
    FILE* file = fopen(name_file, "r");
    if (file == NULL) 
    {
        fprintf(stderr, "Unable to open file %s\n", name_file);
        exit(EXIT_FAILURE);
    }

    int bytes;
    if (fscanf(file, "%d", &bytes) != 1) 
    {
        fprintf(stderr, "Invalid file format\n");
        exit(EXIT_FAILURE);
    }

    fclose(file);
    return bytes;
}

struct node* recreate_binary_tree(struct code_table code_tab[]) 
{
    if (symbols_number == 1) 
    {
        struct node* single_node = malloc(sizeof(struct node));
        if (single_node == NULL) 
        {
            fprintf(stderr, "Memory allocation failed for single node.\n");
            exit(EXIT_FAILURE);
        }
        single_node->symbol = code_tab[0].symbol;
        single_node->left = NULL;
        single_node->right = NULL;
        return single_node;
    }
	
	struct node *root = malloc(sizeof(struct node));
    if (root == NULL) 
    {
        fprintf(stderr, "Memory allocation failed for root node.\n");
        exit(EXIT_FAILURE);
    }
    root->value = -1;
    root->symbol = -1;
    root->left = NULL;
    root->right = NULL;

	int i=0;
    for (i = 0; i < symbols_number; i++) 
    {
        struct node *current = root; 
        int j=0;
		for (j = 0; j < code_tab[i].length; j++) 
        {
            if (((code_tab[i].code[j / 8]) >> (7 - (j % 8))) & 1) 
            {
                if (current->right == NULL) 
                {
                    current->right = malloc(sizeof(struct node));
                    if (current->right == NULL) 
                    {
                        fprintf(stderr, "Memory allocation failed for node.\n");
                        exit(EXIT_FAILURE);
                    }
                    current->right->value = -1;
                    current->right->symbol = -1;
                    current->right->left = NULL;
                    current->right->right = NULL;
                }
                current = current->right;
            } 
            else 
            {
                if (current->left == NULL) 
                {
                    current->left = malloc(sizeof(struct node));
                    if (current->left == NULL) 
                    {
                        fprintf(stderr, "Memory allocation failed for node.\n");
                        exit(EXIT_FAILURE);
                    }
                    current->left->value = -1;
                    current->left->symbol = -1;
                    current->left->left = NULL;
                    current->left->right = NULL;
                }
                current = current->left;
            }
        }
        if (current->left != NULL || current->right != NULL) 
        {
            fprintf(stderr, "Invalid code table. Tree structure is not correct.\n");
            exit(EXIT_FAILURE);
        }
        current->symbol = code_tab[i].symbol;
    }
    return root;
}

void decode_huffman(struct node* root, const char* encoded_file, const char* decoded_file) 
{
    FILE* input_file = fopen(encoded_file, "rb");
    if (input_file == NULL) 
    {
        fprintf(stderr, "Unable to open input file %s\n", encoded_file);
        exit(EXIT_FAILURE);
    }

    FILE* output_file = fopen(decoded_file, "wb");
    if (output_file == NULL) 
    {
        fprintf(stderr, "Unable to open output file %s\n", decoded_file);
        exit(EXIT_FAILURE);
    }

    struct node* current = root;
    int bit_index = 0;
    unsigned char byte;
    int bytes_decoded = 0;
    while (bytes_decoded < bytes_number && fread(&byte, sizeof(unsigned char), 1, input_file) > 0) 
    {
        int i;
        for (i = 7; i >= 0; --i) 
        {
            if (((byte >> i) & 1) == 1) 
            {
                current = current->right;
            } 
            else 
            {
                current = current->left;
            }
            if (current->left == NULL && current->right == NULL) 
            {
                fwrite(&(current->symbol), sizeof(unsigned char), 1, output_file);
                current = root;
                bytes_decoded++;
                if (bytes_decoded == bytes_number) break;
            }
        }
    }

    fclose(input_file);
    fclose(output_file);
}

void set_filenames(char* filenames[], char *argv[])
{
    filenames[0] = strdup(new_extension(argv[1], "codeTable"));
    filenames[1] = strdup(new_extension(argv[1], "bytes"));
	filenames[2] = strdup(new_extension(argv[1], "huffman"));
	filenames[3] = strdup(new_extension(argv[1], "decoded"));
}

int main(int argc, char *argv[]) 
{
    if (argc != 2)
    {
        printf("Give name of file as parameter!\n");
        exit(EXIT_FAILURE);
    }
    
    char *filenames[4];
    set_filenames(filenames, argv);

    struct code_table* code_tab = load_code_table(filenames[0]);
	
	bytes_number=load_bytes_number(filenames[1]);
	
	struct node* root=recreate_binary_tree(code_tab);
	
	decode_huffman(root, filenames[2], filenames[3]);
	    
    free(code_tab);

	int i;
    for (i = 0; i < 4; i++) free(filenames[i]);

    return 0;
}