changed some types

2018-06-05 11:38:27 +02:00 · 2018-06-05 11:38:27 +02:00 · b807ee259e
commit b807ee259e
parent 816b5cf1a7
6 changed files with 77 additions and 69 deletions
--- 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<std::pair<uint32_t, uint8_t>, uint32_t>;
+using std::uint8_t;
+using std::uint16_t;
+using dic_comp_t = std::map<std::pair<uint16_t, uint8_t>, uint16_t>;
+using dic_un_t = std::map<std::uint16_t, std::unique_ptr<std::pair<uint16_t, uint8_t>>>;
+using ustring = std::basic_string<unsigned char>;

 /**
 *  Cette fonction a pour double usage la recherche d’une chaine de caractères
@ -18,18 +20,17 @@ using dic_t = std::map<std::pair<uint32_t, uint8_t>, 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<bool, uint32_t>
+ *  \return const std::pair<bool, uint16_t>
 */
-const std::pair<bool, uint32_t>
-dico(std::map<std::pair<uint32_t, uint8_t>, uint32_t> &t_dictionary,
-     uint32_t t_nr_chaine, uint8_t t_c) {
+std::pair<bool, uint16_t> 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);
  }
--- a/src/common.hh
+++ b/src/common.hh
@ -8,10 +8,11 @@

 #include <cstdint>
 #include <map>
+#include <memory>

 /// \brief Recherche ou ajout de chaine dans le dictionnaire
-const std::pair<bool, std::uint32_t>
-dico(std::map<std::pair<std::uint32_t, std::uint8_t>, std::uint32_t> &,
-     uint32_t, uint8_t);
+std::pair<bool, std::uint16_t>
+dico(std::map<std::pair<std::uint16_t, std::uint8_t>, std::uint16_t> &,
+     std::uint16_t, std::uint8_t);

 #endif /* LZW_SRC_COMMON_H_ */
--- a/src/compress.cc
+++ b/src/compress.cc
@ -4,21 +4,19 @@
 */

 #include "compress.hh"
+#include "io.hh"
 #include <cassert>
 #include <cstdlib>
 #include <fstream>
-#include "io.hh"
-using std::vector;
-using std::uint8_t;
-using std::uint32_t;
 using std::string;
-using vuint32 = vector<uint32_t>;
-using vvuint32 = vector<vuint32>;
+using std::uint16_t;
+using std::uint8_t;
+using std::vector;
+using vuint16 = vector<uint16_t>;
+using vvuint16 = vector<vuint16>;
 using std::string;

-using dict_t = std::map<std::pair<uint32_t, uint8_t>, uint32_t>;
-using ustring = std::basic_string<uint8_t>; // chaîne non encodée
-using uvec = std::vector<std::uint32_t>;         // chaîne encodée
+using dict_t = std::map<std::pair<uint16_t, uint8_t>, 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<uint8_t>(c)); yes) {
      w = pos;
    } else {
-      chunk.push_back(static_cast<uint32_t>(w));
-      w = static_cast<uint32_t>(c);
+      chunk.push_back(static_cast<uint16_t>(w));
+      w = static_cast<uint16_t>(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<char>(input_file), std::istreambuf_iterator<char>()})};
+  const auto compressed_text{
+      lzw_compress(std::string{std::istreambuf_iterator<char>(input_file),
+                               std::istreambuf_iterator<char>()})};
  write_file(out, compressed_text);
  fclose(out);
  input_file.close();
--- a/src/compress.hh
+++ b/src/compress.hh
@ -12,7 +12,7 @@
 #include <thread>

 /// \brief Compression d'une chaine de caractères
-std::vector<std::vector<std::uint32_t>> lzw_compress(std::string &&);
+std::vector<std::vector<std::uint16_t>> lzw_compress(std::string &&);

 /// \brief Wrapper de \ref lzw_compress
 void compress(const std::string &, const char *);
--- 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<uint32_t>;
-using vvuint32 = vector<vuint32>;
+using std::uint16_t;
+using vuint16 = vector<uint16_t>;
+using vvuint16 = vector<vuint16>;



@ -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<uint32_t>(t_text.size());
+void write_file(FILE *const t_out, const vvuint16 &t_text) {
+  const auto size = static_cast<uint16_t>(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<uint32_t>(t_chunk.size());
+void write_chunk(FILE *const t_out, const vuint16 &t_chunk) {
+  const auto chunk_size = static_cast<uint16_t>(t_chunk.size());
  fwrite(&chunk_size, sizeof(chunk_size), 1, t_out);
  std::array<unsigned char, 3> 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<unsigned char>(t_chunk[i] >> 8) & 0xC;
      data[2] = static_cast<unsigned char>(t_chunk[i]);
      fwrite(data.data(), sizeof(data[0]), 3, t_out);
+      data.fill(0);
    }
  }
  if (t_chunk.size() % 2 != 0) {
--- 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<std::vector<std::uint32_t>> &);
+void write_file(FILE *const, const std::vector<std::vector<std::uint16_t>> &);

 /// \brief Écrit un chunk dans le fichier de sortie
-void write_chunk(FILE *const, const std::vector<std::uint32_t> &);
+void write_chunk(FILE *const, const std::vector<std::uint16_t> &);

 #endif /* LZW_SRC_IO_H_ */