110 lines
2.7 KiB
C
110 lines
2.7 KiB
C
#include "hufftree.h"
|
|
#include "error.h"
|
|
#include <stdlib.h>
|
|
|
|
/************************************/
|
|
/* Primitives des arbres de Huffman */
|
|
/************************************/
|
|
|
|
/* Création d'une feuille */
|
|
huffnode *create_huffleaf(int byte, int freq) {
|
|
huffnode *h = malloc(sizeof(huffnode));
|
|
h -> freq = 0;
|
|
h -> byte = 0;
|
|
h -> leftchild = NULL;
|
|
h -> rightchild = NULL;
|
|
return h;
|
|
}
|
|
|
|
/* Fusion de deux arbres avec un nouveau noeud racine */
|
|
huffnode *merge_hufftree(huffnode *pl, huffnode *pr) {
|
|
huffnode *h = create_huffleaf(0, pl->freq + pr->freq);
|
|
h->leftchild = pl;
|
|
h->rightchild = pr;
|
|
return h;
|
|
}
|
|
|
|
/* Teste si un noeud est une feuille */
|
|
bool isleaf_huffnode(huffnode *p) {
|
|
return p->leftchild == NULL && p->rightchild == NULL;
|
|
}
|
|
|
|
/* Retourne la valeur de l'octet correspondant à un noeud */
|
|
int getbyte_huffnode(huffnode *p) {
|
|
if (isleaf_huffnode(p)) {
|
|
ERROR("getbyte_huffnode: noeud feuille attendu\n");
|
|
exit(1);
|
|
}
|
|
return p->byte;
|
|
}
|
|
|
|
/* Retournent les fils d'un noeud */
|
|
|
|
huffnode *getleft_huffnode(huffnode *p) {
|
|
if (isleaf_huffnode(p)) {
|
|
ERROR("getleft_huffnode: noeud interne attendu\n");
|
|
exit(1);
|
|
}
|
|
return p->leftchild;
|
|
}
|
|
huffnode *getright_huffnode(huffnode *p) {
|
|
if (isleaf_huffnode(p)) {
|
|
ERROR("getright_huffnode: noeud interne attendu\n");
|
|
exit(1);
|
|
}
|
|
return p->rightchild;
|
|
}
|
|
|
|
/* Libération d'un arbre */
|
|
|
|
void free_hufftree(huffnode *p) {
|
|
if (p == NULL) return;
|
|
free_hufftree(p -> leftchild);
|
|
free_hufftree(p -> rightchild);
|
|
free(p);
|
|
}
|
|
|
|
/**********************************************/
|
|
/* Fonctions manipulant les arbres de Huffman */
|
|
/**********************************************/
|
|
|
|
/* Comparaison de deux arbres */
|
|
bool compare_hufftree(void *p1, void *p2) {
|
|
huffnode *v1 = (huffnode*)p1;
|
|
huffnode *v2 = (huffnode*)p2;
|
|
if (v1 == NULL || v2 == NULL) {
|
|
ERROR("compare_hufftree: NULL pointeur\n");
|
|
exit(1);
|
|
}
|
|
return v1->freq < v2->freq;
|
|
}
|
|
|
|
/* Création de l'arbre de Huffman à partir du fichier à compresser */
|
|
huffnode *datafile_to_hufftree(FILE *input) {
|
|
/* Phase 1: création du tableau de fréquences */
|
|
|
|
int *tab = malloc(256 * sizeof(int));
|
|
|
|
/* Phase 2: intialisation de la file de priorité à partir du tableau de
|
|
* fréquences */
|
|
|
|
// À écrire
|
|
|
|
/* Phase 3: création de l'arbre de Huffman à partir de la file de priorités */
|
|
|
|
// À écrire
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* Écriture de l'arbre de Huffman dans le futur fichier compressé */
|
|
void save_hufftree(huffnode *p, FILE *f) {
|
|
// À écrire
|
|
}
|
|
|
|
/* Lecture de l'arbre de Huffman dans le fichier compressé */
|
|
huffnode *read_hufftree(FILE *f) {
|
|
// À écrire
|
|
return NULL;
|
|
}
|