BUG FIXED, DOBBY IS FREEEEEE!!!

src/bitpack.cc

@@ -36,15 +36,6 @@ vuchar pack(const vuint16 &t_input) {
   return pack_n(t_input.begin(), t_input.end(), vec, 9);
 }
 
-/**
- *  Packs \p t_input into unsigned char, assuming  the max value of t_input
- * only takes \p t_n bits
- *
- *  \param t_input_begin pointer to the beginning of the vector of values to be
- * packed \param t_input_end pointer to the end of the input vector \param t_n
- * maximum size of an input value in bits \return Returns a vector of unsigned
- * char containing the packed values from t_input
- */
 vuchar pack_n(const vuint16::const_iterator t_input_begin,
               const vuint16::const_iterator t_input_end, vuchar &t_res,
               int t_n) {

src/bitpack.hh

@@ -1,8 +1,3 @@
-/**
- *   \file bitpack.hh
- *   \brief Header for bit-packing functions
- */
-
 #ifndef LZW_SRC_BITPACK_H_
 #define LZW_SRC_BITPACK_H_
 
@@ -10,15 +5,12 @@
 #include <string>
 #include <vector>
 
-/// \brief Bat-packs the input dynamically
 std::vector<unsigned char> pack(const std::vector<std::uint16_t> &);
 
-/// \brief Packs std::uint16_t of n bits into unsigned char
 std::vector<unsigned char> pack_n(std::vector<std::uint16_t>::const_iterator,
                                   std::vector<std::uint16_t>::const_iterator,
                                   std::vector<unsigned char> &, int);
 
-/// \brief Specialization of \ref pack_n for 16bits
 std::vector<unsigned char> pack_16(std::vector<std::uint16_t>::const_iterator,
                                    std::vector<std::uint16_t>::const_iterator,
                                    std::vector<unsigned char> &);

src/common.cc

@@ -1,8 +1,3 @@
-/**
- *   \file common.cc
- *   \brief Implementation for functions in common
- */
-
 #include "common.hh"
 
 using std::uint16_t;
@@ -26,24 +21,6 @@ int ipow(int base, int exp) {
   return result;
 }
 
-/**
- *  Cette fonction a pour double usage la recherche d’une chaine de caractères
- *  dans le dictionnaire, ou bien l’ajout d’une nouvelle chaîne si celle-ci
- * n’est pas déjà présente. Une chaine de caractères est représentée par un
- * couple numéro de chaine / caractère, le numéro de chaine renvoyant au
- * caractère précédent (soit son code ASCII, soit son indice dans le
- * dictionnaire) et le 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/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, uint16_t>
- */
 std::pair<bool, uint16_t> dico(dic_comp_t &t_dictionary,
                                const uint16_t t_nr_chaine, const uint8_t t_c) {
   if (t_nr_chaine == 0xFFFF) {
@@ -55,12 +32,6 @@ std::pair<bool, uint16_t> dico(dic_comp_t &t_dictionary,
                                                t_dictionary.size() + 255)));
 }
 
-/**
- *  Detailed description
- *
- *  \param t_dict Dictionnaire
- *  \return Retourne une chaîne de caractères non signés
- */
 ustring dico_uncompress(std::map<uint16_t, ustring> &t_dict,
                         const uint16_t t_code, const uint16_t t_old) {
   // le code existe dans le dictionnaire s’il est < 256

src/common.hh

@@ -1,8 +1,3 @@
-/**
- *   \file common.hh
- *   \brief Header for functions in common
- */
-
 #ifndef LZW_SRC_COMMON_H_
 #define LZW_SRC_COMMON_H_
 
@@ -12,7 +7,6 @@
 
 int ipow(int, int);
 
-/// \brief Recherche ou ajout de chaine dans le dictionnaire
 std::pair<bool, std::uint16_t>
 dico(std::map<std::pair<std::uint16_t, std::uint8_t>, std::uint16_t> &,
      const std::uint16_t, const std::uint8_t);

src/compress.cc

@@ -1,8 +1,3 @@
-/**
- *   \file compress.cc
- *   \brief Implementation of compression
- */
-
 #include "compress.hh"
 #include "common.hh"
 #include "io.hh"
@@ -41,10 +36,14 @@ vvuint16 lzw_compress(ustring &&t_text) {
   vvuint16 res{};
   const auto DICT_MAX = static_cast<size_t>(ipow(2, 14) - 256); /* 16 bits */
   uint16_t w = 0xFFFF;
+  bool pushed = false;
   vuint16 chunk{};
   dict_t dict{};
   for (const auto c : t_text) {
     if (dict.size() >= DICT_MAX) {
+      if (w != 0xFFFF) {
+        chunk.push_back(w);
+      }
       res.push_back(chunk);
       w = 0xFFFF;
       chunk.clear();
@@ -53,9 +52,11 @@ vvuint16 lzw_compress(ustring &&t_text) {
     if (const auto &[exists, pos] = dico(dict, w, static_cast<uint8_t>(c));
         exists) {
       w = pos;
+      pushed = false;
     } else {
       chunk.push_back(w);
       w = static_cast<uint16_t>(c);
+      pushed = true;
     }
   }
   if (w != 0xFFFF) {
@@ -65,15 +66,6 @@ vvuint16 lzw_compress(ustring &&t_text) {
   return res;
 }
 
-/**
- *  Wrapper de la fonction \ref lzw_compress gérant l'ouverture, la lecture,
- *  l'écriture et la fermeture des fichiers d’entrée et de sortie. Si \p
- *  t_out_file est nul (chemin non spécifié), il prendra alors la valeur de
- *  \p t_in_file à laquelle sera annexé l’extension `.lzw`.
- *
- *  \param[in] t_in_file Chemin vers le fichier d’entrée
- *  \param[in] t_out_file Chemin vers le fichier de sortie
- */
 void compress(const std::string &t_in_file, const char *t_out_file) {
   std::ofstream out{(t_out_file != nullptr) ? t_out_file : "output.lzw",
                     ios::out | ios::binary};

src/compress.hh

@@ -1,8 +1,3 @@
-/**
- *   \file compress.hh
- *   \brief Header for compression functions
- */
-
 #ifndef LZW_SRC_COMPRESS_H_
 #define LZW_SRC_COMPRESS_H_
 
@@ -11,11 +6,9 @@
 #include <thread>
 #include <vector>
 
-/// \brief Compression d'une chaine de caractères
 std::vector<std::vector<std::uint16_t>>
 lzw_compress(std::basic_string<unsigned char> &&);
 
-/// \brief Wrapper de \ref lzw_compress
 void compress(const std::string &, const char *);
 
 #endif /* LZW_SRC_COMPRESS_H_ */

src/io.cc

@@ -1,8 +1,3 @@
-/**
- *   \file io.cc
- *   \brief Body for file reading and writing
- */
-
 #include "io.hh"
 #include "bitpack.hh"
 #include <array>
@@ -12,23 +7,6 @@ using std::vector;
 using vuint16 = vector<uint16_t>;
 using vvuint16 = vector<vuint16>;
 
-/**
- *  É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 deux octets sont écrit un `uint16_t` (deux octets) déterminant le
- *    nombre de chunk composant le fichier\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 deux octets sont écrit un `uint32_t` (quatre octets) déterminant le
- *    nombre d’octets composant le chunk\n
- *  - Sur le nombre d’octets précisés par le header du chunk se trouvent les
- *    données compressées par l’algorithme lzw puis via bit-packing.\n
- *
- *  \param[out] t_out Fichier de sortie
- *  \param[in] t_chunks Collection ordonnée des chunks à écrire dans \p t_out
- */
 void write_file(std::ofstream &t_out, const vvuint16 &t_chunks) {
   const auto nr_chunks = static_cast<uint16_t>(t_chunks.size());
 #ifdef Debug
@@ -40,13 +18,6 @@ void write_file(std::ofstream &t_out, const vvuint16 &t_chunks) {
   }
 }
 
-/**
- *  É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(std::ofstream &t_out, const vuint16 &t_chunk) {
   const auto output = pack(t_chunk);
   const auto chunk_size = static_cast<uint32_t>(output.size());

src/io.hh

@@ -1,8 +1,3 @@
-/**
- *   \file io.hh
- *   \brief Header for file reading and writing
- */
-
 #ifndef LZW_SRC_IO_H_
 #define LZW_SRC_IO_H_
 
@@ -12,26 +7,9 @@
 #include <iostream>
 #include <vector>
 
-/*
- * Un fichier compressé se compose ainsi :
- * char_size : taille d'un caractère en bits (1B)
- * nb_chunk : nombre de chunks (4B)
- * chunks* : chunks
- *
- * Un chunk se compose ainsi :
- * nb_char_chunk : nombre de caractères du chunk (2B)
- * text* : caractères de taille char_size (ceil((char_size * nb_char_chunk) /
- * 8))
- *
- * Si le dernier caractère ne termine pas le dernier octet du chunk, les
- * derniers bits sont mit à zéro
- */
-
-/// \brief Écrit dans le fichier le texte compressé
 void write_file(std::ofstream &,
                 const std::vector<std::vector<std::uint16_t>> &);
 
-/// \brief Écrit un chunk dans le fichier de sortie
 void write_chunk(std::ofstream &, const std::vector<std::uint16_t> &);
 
 #endif /* LZW_SRC_IO_H_ */

src/main.cc

@@ -1,11 +1,3 @@
-/**
- *   \file main.cc
- *   \brief Main file
- *
- *
- *
- */
-
 #include "compress.hh"
 #include "uncompress.hh"
 #include <cassert>
@@ -19,23 +11,10 @@ using std::tuple;
 
 // custom types ///////////////////////////////////////////////////////////////
 
-/*
-  Dictionnaire :
-  <
-      <
-          numéro chaine précédente,
-          caractère ASCII
-      >
-      numéro chaine courante
-  >
- */
 using dic_t = std::map<std::pair<uint32_t, uint8_t>, uint32_t>;
 using ustring = std::basic_string<uint8_t>; // chaine non encodée
 using uvec = std::vector<uint32_t>;         // chaine encodée
 
-/**
- *  \brief Affichage d’aide
- */
 void help() {
   puts("Usage:");
   puts("lzw  [-options] [-i path] [-o path]\n");
@@ -101,7 +80,6 @@ std::tuple<string, string, bool> process_args(int t_argc, char *t_argv[]) {
   return ret;
 }
 
-/* TODO: compression multiple : nombre de compressions puis fichier compressé */
 int main(int argc, char *argv[]) {
   const auto [input_path, output_path, compressing] = process_args(argc, argv);
   assert(!input_path.empty());

src/uncompress.cc

@@ -55,9 +55,6 @@ void uncompress_chunk(FILE *const t_input, std::ofstream &t_output) {
   fread(chunk.get(), sizeof(unsigned char), size_chunk, t_input);
   auto unpacked = unpack(ustring{chunk.get(), chunk.get() + size_chunk});
   auto uncompressed_chunk = lzw_uncompress(std::move(unpacked));
-
-  // attention here for bug ///////////////////////////////////////////////////
-  uncompressed_chunk.push_back(0xFF);
   t_output.write(reinterpret_cast<const char *>(uncompressed_chunk.data()),
                  sizeof(uncompressed_chunk[0]) * uncompressed_chunk.size());
 }