From b807ee259e2a635306931785652b62b05e5c94b9 Mon Sep 17 00:00:00 2001 From: Phuntsok Drak-pa Date: Tue, 5 Jun 2018 11:38:27 +0200 Subject: [PATCH] changed some types --- src/common.cc | 19 +++++++-------- src/common.hh | 7 +++--- src/compress.cc | 61 +++++++++++++++++++++++++------------------------ src/compress.hh | 2 +- src/io.cc | 53 +++++++++++++++++++++++------------------- src/io.hh | 4 ++-- 6 files changed, 77 insertions(+), 69 deletions(-) diff --git a/src/common.cc b/src/common.cc index 8c7a98d..430d8ea 100644 --- a/src/common.cc +++ b/src/common.cc @@ -5,9 +5,11 @@ #include "common.hh" -using uint8_t = std::uint8_t; -using uint32_t = std::uint32_t; -using dic_t = std::map, uint32_t>; +using std::uint8_t; +using std::uint16_t; +using dic_comp_t = std::map, uint16_t>; +using dic_un_t = std::map>>; +using ustring = std::basic_string; /** * Cette fonction a pour double usage la recherche d’une chaine de caractères @@ -18,18 +20,17 @@ using dic_t = std::map, uint32_t>; * caractère se référant au dernier caractère de la chaine courante. Si le * numéro de chaine est -1, alors il s’agit du premier caractère de la chaine, * et la valeur renvoyée sera la valeur ASCII du caractère. La fonction renvoie - * une paire bool/uint32_t, la valeur booléene indiquant si une nouvelle fut - * ajoutée dans le dictionnaire ou non, et le uint32_t indiquant la valeur + * une paire bool/uint16_t, la valeur booléene indiquant si une nouvelle fut + * ajoutée dans le dictionnaire ou non, et le uint16_t indiquant la valeur * numérique de la chaîne dans le dictionnaire. * * \param t_dictionary Dictionnaire * \param t_nr_chaine Numéro de la chaine précédant le caractères \p t_c dans \p t_dictionary * \param t_c Caractère suivant la chaine de caractères \p t_nr_chaine - * \return const std::pair + * \return const std::pair */ -const std::pair -dico(std::map, uint32_t> &t_dictionary, - uint32_t t_nr_chaine, uint8_t t_c) { +std::pair dico(dic_comp_t &t_dictionary, uint16_t t_nr_chaine, + uint8_t t_c) { if (t_nr_chaine == 0xFFFF) { return std::make_pair(true, t_c); } diff --git a/src/common.hh b/src/common.hh index 1406ab8..0d592c9 100644 --- a/src/common.hh +++ b/src/common.hh @@ -8,10 +8,11 @@ #include #include +#include /// \brief Recherche ou ajout de chaine dans le dictionnaire -const std::pair -dico(std::map, std::uint32_t> &, - uint32_t, uint8_t); +std::pair +dico(std::map, std::uint16_t> &, + std::uint16_t, std::uint8_t); #endif /* LZW_SRC_COMMON_H_ */ diff --git a/src/compress.cc b/src/compress.cc index db3b0bf..26bef85 100644 --- a/src/compress.cc +++ b/src/compress.cc @@ -4,21 +4,19 @@ */ #include "compress.hh" +#include "io.hh" #include #include #include -#include "io.hh" -using std::vector; -using std::uint8_t; -using std::uint32_t; using std::string; -using vuint32 = vector; -using vvuint32 = vector; +using std::uint16_t; +using std::uint8_t; +using std::vector; +using vuint16 = vector; +using vvuint16 = vector; using std::string; -using dict_t = std::map, uint32_t>; -using ustring = std::basic_string; // chaîne non encodée -using uvec = std::vector; // chaîne encodée +using dict_t = std::map, uint16_t>; using std::printf; constexpr int ipow(int base, int exp) { @@ -39,41 +37,40 @@ constexpr int ipow(int base, int exp) { constexpr size_t DICT_MAX = ipow(2, 13) - 256; /* 12 bits */ /** - * La chaîne de caractère \p t_text est lue caractère par caractère, et est et - * selon la valeur de retour de la fonction \ref dico (permettant dans le même - * temps la création du dictionnaire), on rajoute un mot ou pas dans le vecteur - * de caractères UTF-8 représentant des mots de chars compressés. + * La chaîne de caractères \p t_text est lue caractère par caractère, et est + * selon la valeur de retour de la fonction \ref dico (permettant dans le même + * temps la création du dictionnaire), on rajoute ou non un nouveau caractère + * encodé sur 12bits dans le chunk courant. Dès que le dictionnaire est plein + * (2^12 caractères), le chunk est sauvegardé et vidé, et le dictionnaire est + * réinitialisé. * * \param t_text Chaîne de caractères uint8_t représentant le fichier d'entrée - * \return Vecteur de chunks (vecteurs de uint32_t) + * \return Vecteur de chunks (vecteurs de uint16_t) */ -vvuint32 lzw_compress(string &&t_text) { +vvuint16 lzw_compress(string &&t_text) { std::puts("Compressing..."); - uint32_t w = 0xFFFF; - vuint32 chunk{}; - vvuint32 res{}; + uint16_t w = 0xFFFF; + vuint16 chunk{}; + vvuint16 res{}; dict_t dict{}; - - for(const auto c : t_text) { - if(dict.size() >= DICT_MAX) { - // Dictionary full -> chunk pushed, dict emptied + for (const auto c : t_text) { + if (dict.size() >= DICT_MAX) { res.push_back(std::move(chunk)); - chunk = vuint32{}; + chunk = vuint16{}; dict = dict_t{}; w = 0xFFFF; } if (const auto &[yes, pos] = dico(dict, w, static_cast(c)); yes) { w = pos; } else { - chunk.push_back(static_cast(w)); - w = static_cast(c); + chunk.push_back(static_cast(w)); + w = static_cast(c); } } - if(w != 0xFFFF) { + if (w != 0xFFFF) { chunk.push_back(w); res.push_back(std::move(chunk)); } - return res; } @@ -89,13 +86,17 @@ vvuint32 lzw_compress(string &&t_text) { void compress(const std::string &t_in_file, const char *t_out_file) { std::ifstream input_file{t_in_file}; assert(input_file.is_open()); - FILE *const out = (t_out_file != nullptr) ? fopen(t_out_file, "wb") : fopen("output.lzw", "wb"); + FILE *const out = (t_out_file != nullptr) ? fopen(t_out_file, "wb") + : fopen("output.lzw", "wb"); if (out == nullptr) { - std::cerr << "Error at " << __FILE__ << ":" << __LINE__ - 4 << ": could not open output file. Aborting...\n"; + std::cerr << "Error at " << __FILE__ << ":" << __LINE__ - 4 + << ": could not open output file. Aborting...\n"; input_file.close(); exit(1); } - const auto compressed_text{lzw_compress(std::string{std::istreambuf_iterator(input_file), std::istreambuf_iterator()})}; + const auto compressed_text{ + lzw_compress(std::string{std::istreambuf_iterator(input_file), + std::istreambuf_iterator()})}; write_file(out, compressed_text); fclose(out); input_file.close(); diff --git a/src/compress.hh b/src/compress.hh index 58bce87..7e0089d 100644 --- a/src/compress.hh +++ b/src/compress.hh @@ -12,7 +12,7 @@ #include /// \brief Compression d'une chaine de caractères -std::vector> lzw_compress(std::string &&); +std::vector> lzw_compress(std::string &&); /// \brief Wrapper de \ref lzw_compress void compress(const std::string &, const char *); diff --git a/src/io.cc b/src/io.cc index 967c6ec..dce2531 100644 --- a/src/io.cc +++ b/src/io.cc @@ -14,9 +14,9 @@ constexpr bool debug_mode = false; #endif using std::vector; -using std::uint32_t; -using vuint32 = vector; -using vvuint32 = vector; +using std::uint16_t; +using vuint16 = vector; +using vvuint16 = vector; @@ -25,49 +25,53 @@ constexpr unsigned char char_size = 12; /** * Écrit dans le fichier \p t_out les chunks passés en paramètre. Le fichier de * sortie est composé des éléments suivants :\n - * - Sur quatre octets sont écrit un `uint32_t` déterminant la taille d'un + * - Sur deux octets sont écrit un `uint16_t` déterminant la taille d'un * caractère\n - * - Sur quatre octets sont écrit un `uint32_t` déterminant le nombre de chunk + * - Sur deux octets sont écrit un `uint16_t` déterminant le nombre de chunk * composant le fichier\n - * - Sont ensuite écrits les chunks sur des nombres d’octets variable suivant - * la taille d’un caractère et le nombre de caractères\n + * - Sont ensuite écrits les chunks sur un nombre variable d’octets suivant la + * taille des chunks\n * \n * Un chunk est composé de la manière qui suit :\n - * - Sur quatre octets sont écrit un `uint32_t` déterminant le nombre de - * caractères composant le chunk\n - * - Les caractères composant le chunk, accolés les uns au autres. Si le - * dernier caractère ne remplis pas le dernier octet du chunk, alors ces - * derniers bits seront initialisés à 0.\n - * La taille d’un chunk est donc la taille d’un caractère multiplié par le - * nombre de caractères du chunk, le tout divisé par 8. Si le résultat n’est - * pas un entier, alors il est nivelé vers le haut pour avoir un nombre entier - * d’octets (e.g. si le résultat est 103.4, alors 104 octets seront utilisés). + * - Sur deux octets sont écrit un `uint16_t` déterminant le nombre de + * caractères (uint16_t) composant le chunk\n + * - Sur n*2 octets la chaîne de caractères compressés (n représentant le + * nombre de caractères dans le chunk).\n + * Les caractères uint16_t sont à nouveau compressés en 12bits via du + * bit-packing, intégrant dont en trois unsigned char deux uint16_t. Le premier + * char contient les huit bits de poids fort des douze bits significatifs. Les + * quatre bits de poids fort du second char contient les quatre bits de poids + * faible du premier uint16_t. Les quatre bits de poids faible du second char + * contiennent les quatre bits de poids fort du second uint16_t, et le + * troisième char contient les huit bits de poids faible du second uint16_t.\n + * Si le nombre de charactères dans le chunk est impair, alors les trois + * derniers chars seront remplis comme si le chunk disposait d’un caractère nul + * supplémentaire. * * \param[out] t_out Fichier de sortie * \param[in] t_text Collection ordonnée des chunks à écrire dans \p t_out */ -void write_file(FILE *const t_out, const vvuint32 &t_text) { - const auto size = static_cast(t_text.size()); +void write_file(FILE *const t_out, const vvuint16 &t_text) { + const auto size = static_cast(t_text.size()); if constexpr (debug_mode) { - std::printf("Char size: %u\n", char_size); std::printf("Number of chunks: %u\n", size); } fwrite(&char_size, sizeof(char_size), 1, t_out); fwrite(&size, sizeof(size), 1, t_out); for (const auto &chunk : t_text) { - if constexpr (debug_mode) { - std::printf("Size of chunk: %zu\n", chunk.size()); - } write_chunk(t_out, chunk); } } /** + * Écrit dans le fichier \p t_out le chunk unique \p t_chunk. Se référer à la + * documentation de \ref write_file pour plus de détails. + * * \param t_out Output file * \param t_chunk Chunk to be written to \p t_out */ -void write_chunk(FILE *const t_out, const vuint32 &t_chunk) { - const auto chunk_size = static_cast(t_chunk.size()); +void write_chunk(FILE *const t_out, const vuint16 &t_chunk) { + const auto chunk_size = static_cast(t_chunk.size()); fwrite(&chunk_size, sizeof(chunk_size), 1, t_out); std::array data = {0, 0, 0}; for (size_t i = 0; i < t_chunk.size(); ++i) { @@ -78,6 +82,7 @@ void write_chunk(FILE *const t_out, const vuint32 &t_chunk) { data[1] |= static_cast(t_chunk[i] >> 8) & 0xC; data[2] = static_cast(t_chunk[i]); fwrite(data.data(), sizeof(data[0]), 3, t_out); + data.fill(0); } } if (t_chunk.size() % 2 != 0) { diff --git a/src/io.hh b/src/io.hh index 0eb3f7d..9979add 100644 --- a/src/io.hh +++ b/src/io.hh @@ -27,9 +27,9 @@ /// \brief Écrit dans le fichier le texte compressé -void write_file(FILE *const, const std::vector> &); +void write_file(FILE *const, const std::vector> &); /// \brief Écrit un chunk dans le fichier de sortie -void write_chunk(FILE *const, const std::vector &); +void write_chunk(FILE *const, const std::vector &); #endif /* LZW_SRC_IO_H_ */