2018-04-05 16:47:07 +00:00
|
|
|
|
/**
|
|
|
|
|
* \file compress.cc
|
|
|
|
|
* \brief Implementation of compression
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include "compress.hh"
|
2018-06-05 09:38:27 +00:00
|
|
|
|
#include "io.hh"
|
2018-04-26 11:56:43 +00:00
|
|
|
|
#include <cassert>
|
2018-04-05 16:47:07 +00:00
|
|
|
|
#include <cstdlib>
|
2018-04-10 08:39:41 +00:00
|
|
|
|
#include <fstream>
|
2018-05-25 10:00:58 +00:00
|
|
|
|
using std::string;
|
2018-06-05 09:38:27 +00:00
|
|
|
|
using std::uint16_t;
|
|
|
|
|
using std::uint8_t;
|
|
|
|
|
using std::vector;
|
|
|
|
|
using vuint16 = vector<uint16_t>;
|
|
|
|
|
using vvuint16 = vector<vuint16>;
|
2018-05-25 10:00:58 +00:00
|
|
|
|
using std::string;
|
2018-04-26 11:56:43 +00:00
|
|
|
|
|
2018-06-05 09:38:27 +00:00
|
|
|
|
using dict_t = std::map<std::pair<uint16_t, uint8_t>, uint16_t>;
|
2018-04-10 08:39:41 +00:00
|
|
|
|
using std::printf;
|
2018-04-05 16:47:07 +00:00
|
|
|
|
|
2018-05-25 10:00:58 +00:00
|
|
|
|
constexpr int ipow(int base, int exp) {
|
|
|
|
|
int result = 1;
|
|
|
|
|
for (;;) {
|
|
|
|
|
if (exp & 1) {
|
|
|
|
|
result *= base;
|
|
|
|
|
}
|
|
|
|
|
exp >>= 1;
|
|
|
|
|
if (exp == 0) {
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
base *= base;
|
2018-04-26 11:49:39 +00:00
|
|
|
|
}
|
2018-05-25 10:00:58 +00:00
|
|
|
|
return result;
|
2018-04-26 11:49:39 +00:00
|
|
|
|
}
|
|
|
|
|
|
2018-05-25 10:13:12 +00:00
|
|
|
|
constexpr size_t DICT_MAX = ipow(2, 13) - 256; /* 12 bits */
|
|
|
|
|
|
2018-04-05 16:47:07 +00:00
|
|
|
|
/**
|
2018-06-05 09:38:27 +00:00
|
|
|
|
* 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é.
|
2018-04-05 16:47:07 +00:00
|
|
|
|
*
|
2018-05-25 11:28:37 +00:00
|
|
|
|
* \param t_text Chaîne de caractères uint8_t représentant le fichier d'entrée
|
2018-06-05 09:38:27 +00:00
|
|
|
|
* \return Vecteur de chunks (vecteurs de uint16_t)
|
2018-04-05 16:47:07 +00:00
|
|
|
|
*/
|
2018-06-05 09:38:27 +00:00
|
|
|
|
vvuint16 lzw_compress(string &&t_text) {
|
2018-04-05 16:47:07 +00:00
|
|
|
|
std::puts("Compressing...");
|
2018-06-05 09:38:27 +00:00
|
|
|
|
uint16_t w = 0xFFFF;
|
|
|
|
|
vuint16 chunk{};
|
|
|
|
|
vvuint16 res{};
|
2018-05-25 10:00:58 +00:00
|
|
|
|
dict_t dict{};
|
2018-06-05 09:38:27 +00:00
|
|
|
|
for (const auto c : t_text) {
|
|
|
|
|
if (dict.size() >= DICT_MAX) {
|
2018-05-25 10:00:58 +00:00
|
|
|
|
res.push_back(std::move(chunk));
|
2018-06-05 09:38:27 +00:00
|
|
|
|
chunk = vuint16{};
|
2018-05-25 10:00:58 +00:00
|
|
|
|
dict = dict_t{};
|
|
|
|
|
w = 0xFFFF;
|
|
|
|
|
}
|
|
|
|
|
if (const auto &[yes, pos] = dico(dict, w, static_cast<uint8_t>(c)); yes) {
|
2018-04-05 16:47:07 +00:00
|
|
|
|
w = pos;
|
|
|
|
|
} else {
|
2018-06-05 09:38:27 +00:00
|
|
|
|
chunk.push_back(static_cast<uint16_t>(w));
|
|
|
|
|
w = static_cast<uint16_t>(c);
|
2018-04-05 16:47:07 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2018-06-05 09:38:27 +00:00
|
|
|
|
if (w != 0xFFFF) {
|
2018-05-25 10:00:58 +00:00
|
|
|
|
chunk.push_back(w);
|
|
|
|
|
res.push_back(std::move(chunk));
|
|
|
|
|
}
|
|
|
|
|
return res;
|
2018-04-05 16:47:07 +00:00
|
|
|
|
}
|
2018-04-10 08:39:41 +00:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* 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`.
|
|
|
|
|
*
|
2018-04-29 12:13:14 +00:00
|
|
|
|
* \param[in] t_in_file Chemin vers le fichier d’entrée
|
|
|
|
|
* \param[in] t_out_file Chemin vers le fichier de sortie
|
2018-04-10 08:39:41 +00:00
|
|
|
|
*/
|
|
|
|
|
void compress(const std::string &t_in_file, const char *t_out_file) {
|
|
|
|
|
std::ifstream input_file{t_in_file};
|
2018-05-25 11:28:37 +00:00
|
|
|
|
assert(input_file.is_open());
|
2018-06-05 09:38:27 +00:00
|
|
|
|
FILE *const out = (t_out_file != nullptr) ? fopen(t_out_file, "wb")
|
|
|
|
|
: fopen("output.lzw", "wb");
|
2018-05-23 14:27:54 +00:00
|
|
|
|
if (out == nullptr) {
|
2018-06-05 09:38:27 +00:00
|
|
|
|
std::cerr << "Error at " << __FILE__ << ":" << __LINE__ - 4
|
|
|
|
|
<< ": could not open output file. Aborting...\n";
|
2018-04-26 09:54:02 +00:00
|
|
|
|
input_file.close();
|
|
|
|
|
exit(1);
|
|
|
|
|
}
|
2018-06-05 09:38:27 +00:00
|
|
|
|
const auto compressed_text{
|
|
|
|
|
lzw_compress(std::string{std::istreambuf_iterator<char>(input_file),
|
|
|
|
|
std::istreambuf_iterator<char>()})};
|
2018-05-03 11:28:17 +00:00
|
|
|
|
write_file(out, compressed_text);
|
2018-04-10 08:39:41 +00:00
|
|
|
|
fclose(out);
|
|
|
|
|
input_file.close();
|
|
|
|
|
}
|