2018-04-05 16:47:07 +00:00
|
|
|
|
/**
|
|
|
|
|
* \file compress.cc
|
|
|
|
|
* \brief Implementation of compression
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include "compress.hh"
|
2018-04-10 08:39:41 +00:00
|
|
|
|
#include "utf8.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-04-26 09:54:02 +00:00
|
|
|
|
#include <iostream>
|
2018-04-26 11:56:43 +00:00
|
|
|
|
|
2018-04-26 11:49:39 +00:00
|
|
|
|
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<uint32_t>; // chaîne encodée
|
2018-04-10 08:39:41 +00:00
|
|
|
|
using std::printf;
|
2018-04-05 16:47:07 +00:00
|
|
|
|
|
2018-04-29 12:13:14 +00:00
|
|
|
|
/**
|
|
|
|
|
*
|
|
|
|
|
* Reçoit une liste de paires std::thread/vecteurs, le premier étant le
|
|
|
|
|
* processus dont sa sortie est stockée dans le second. La sortie, une liste
|
|
|
|
|
* de caractères uint32_t, est écrite dans le fichier de sortie \p out.
|
|
|
|
|
*
|
|
|
|
|
* \param[in] t_threads
|
|
|
|
|
* \param[out] t_out
|
|
|
|
|
*/
|
2018-04-26 11:49:39 +00:00
|
|
|
|
void join_and_write(
|
|
|
|
|
std::vector<std::pair<std::unique_ptr<std::thread>, uvec>> &t_threads,
|
|
|
|
|
FILE *t_out) {
|
|
|
|
|
for (auto &elem : t_threads) {
|
|
|
|
|
(*elem.first).join();
|
|
|
|
|
}
|
|
|
|
|
for (auto &elem : t_threads) {
|
|
|
|
|
for (const auto c : elem.second) {
|
|
|
|
|
write_utf8(t_out, c);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
t_threads.clear();
|
|
|
|
|
}
|
|
|
|
|
|
2018-04-05 16:47:07 +00:00
|
|
|
|
/**
|
2018-04-26 11:49:39 +00:00
|
|
|
|
* La chaîne de caractère \p t_text est lue caractère par caractère, et est et
|
2018-04-10 08:39:41 +00:00
|
|
|
|
* 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 fonction
|
2018-04-26 11:49:39 +00:00
|
|
|
|
* renvoie ledit vecteur de uint32_t via le paramètre \p t_res.
|
2018-04-05 16:47:07 +00:00
|
|
|
|
*
|
2018-04-29 12:13:14 +00:00
|
|
|
|
* \param[in] t_text Chaîne de caractères uint8_t représentant le fichier d'entrée
|
|
|
|
|
* \param[out] t_res Chaîne de caractères de sortie
|
2018-04-05 16:47:07 +00:00
|
|
|
|
*/
|
2018-04-26 09:54:02 +00:00
|
|
|
|
void lzw_compress(const std::vector<char> &t_text, uvec &t_res) {
|
|
|
|
|
dict_t dictionary{};
|
2018-04-05 16:47:07 +00:00
|
|
|
|
std::puts("Compressing...");
|
2018-04-26 11:49:39 +00:00
|
|
|
|
uint32_t w = 0xFFFF;
|
2018-04-10 08:39:41 +00:00
|
|
|
|
|
|
|
|
|
constexpr size_t DICT_MAX = 7936; /* 12 bits */
|
|
|
|
|
|
2018-04-05 16:47:07 +00:00
|
|
|
|
for (const auto &c : t_text) {
|
2018-04-26 11:49:39 +00:00
|
|
|
|
if (dictionary.size() >= DICT_MAX) {
|
|
|
|
|
t_res.push_back(static_cast<uint32_t>(w));
|
|
|
|
|
w = static_cast<uint32_t>(c);
|
2018-04-26 09:54:02 +00:00
|
|
|
|
} else if (const auto &[exists, pos] =
|
|
|
|
|
dico(dictionary, w, static_cast<std::uint8_t>(c));
|
|
|
|
|
exists) {
|
2018-04-05 16:47:07 +00:00
|
|
|
|
w = pos;
|
|
|
|
|
} else {
|
2018-04-26 11:49:39 +00:00
|
|
|
|
t_res.push_back(static_cast<uint32_t>(w));
|
2018-04-26 09:54:02 +00:00
|
|
|
|
w = static_cast<std::uint8_t>(c);
|
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) {
|
|
|
|
|
// Fichier d’entrée
|
|
|
|
|
std::ifstream input_file{t_in_file};
|
2018-04-26 11:49:39 +00:00
|
|
|
|
if (!input_file.is_open()) {
|
2018-04-26 09:54:02 +00:00
|
|
|
|
std::cerr << "Error at " << __FILE__ << ":" << __LINE__ - 2
|
2018-04-26 11:49:39 +00:00
|
|
|
|
<< ": could not open output file \"" << t_in_file
|
|
|
|
|
<< "\". Aborting...\n";
|
2018-04-26 09:54:02 +00:00
|
|
|
|
exit(1);
|
|
|
|
|
}
|
2018-04-10 08:39:41 +00:00
|
|
|
|
|
|
|
|
|
// Fichier de sortie
|
2018-04-29 12:13:14 +00:00
|
|
|
|
FILE *out =
|
|
|
|
|
(t_out_file) ? fopen(t_out_file, "wb") : fopen("output.lzw", "wb");
|
2018-04-26 11:49:39 +00:00
|
|
|
|
if (!out) {
|
2018-04-26 09:54:02 +00:00
|
|
|
|
std::cerr << "Error at " << __FILE__ << ":" << __LINE__ - 4
|
2018-04-29 12:13:14 +00:00
|
|
|
|
<< ": could not open output file. Aborting...\n";
|
2018-04-26 09:54:02 +00:00
|
|
|
|
input_file.close();
|
|
|
|
|
exit(1);
|
|
|
|
|
}
|
2018-04-10 08:39:41 +00:00
|
|
|
|
|
2018-04-26 09:54:02 +00:00
|
|
|
|
// thread pool
|
2018-04-26 09:59:09 +00:00
|
|
|
|
std::vector<std::pair<std::unique_ptr<std::thread>, uvec>> threads{};
|
2018-04-26 09:54:02 +00:00
|
|
|
|
|
|
|
|
|
// char chunk[32768];
|
2018-04-26 11:49:39 +00:00
|
|
|
|
std::vector<char> chunk(32768, 0);
|
|
|
|
|
while (input_file.read(chunk.data(),
|
|
|
|
|
static_cast<std::streamsize>(chunk.size()))) {
|
|
|
|
|
threads.emplace_back(nullptr, uvec{});
|
2018-04-29 12:13:14 +00:00
|
|
|
|
threads.back().first = std::make_unique<std::thread>(
|
|
|
|
|
std::thread{lzw_compress, chunk, ref(threads.back().second)});
|
2018-04-26 11:56:43 +00:00
|
|
|
|
assert(threads.back().first);
|
2018-04-26 09:54:02 +00:00
|
|
|
|
if (threads.size() >= 8) {
|
2018-04-26 11:49:39 +00:00
|
|
|
|
join_and_write(threads, out);
|
2018-04-26 09:54:02 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2018-04-10 08:39:41 +00:00
|
|
|
|
|
2018-04-26 11:49:39 +00:00
|
|
|
|
if (!threads.empty()) {
|
|
|
|
|
join_and_write(threads, out);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (input_file.tellg() != std::ios::end) {
|
|
|
|
|
std::puts("Leftovers, compressing...");
|
|
|
|
|
{
|
|
|
|
|
const auto prev_pos = input_file.tellg();
|
|
|
|
|
input_file.seekg(0, std::ios::end);
|
|
|
|
|
chunk.reserve(static_cast<size_t>(input_file.tellg() - prev_pos));
|
|
|
|
|
input_file.seekg(prev_pos, std::ios::beg);
|
|
|
|
|
std::istreambuf_iterator<char> itr(input_file);
|
|
|
|
|
for (std::streamoff i = 0; i < prev_pos; ++i, ++itr)
|
|
|
|
|
;
|
|
|
|
|
chunk.assign((itr), std::istreambuf_iterator<char>());
|
2018-04-26 09:59:09 +00:00
|
|
|
|
}
|
2018-04-26 11:49:39 +00:00
|
|
|
|
uvec ret{};
|
|
|
|
|
lzw_compress(chunk, ret);
|
|
|
|
|
for (const auto c : ret) {
|
|
|
|
|
write_utf8(out, c);
|
2018-04-26 09:59:09 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-04-10 08:39:41 +00:00
|
|
|
|
fclose(out);
|
|
|
|
|
input_file.close();
|
|
|
|
|
}
|