Fixed empty chunk issue, still unexpected errors

This commit is contained in:
Phuntsok Drak-pa 2018-04-26 13:49:39 +02:00
parent d7ea7c8866
commit b7f96f0557
5 changed files with 76 additions and 93 deletions

View File

@ -6,8 +6,8 @@
#include "common.hh" #include "common.hh"
using uint8_t = std::uint8_t; using uint8_t = std::uint8_t;
using uint16_t = std::uint16_t; using uint32_t = std::uint32_t;
using dic_t = std::map<std::pair<uint16_t, uint8_t>, uint16_t>; using dic_t = std::map<std::pair<uint32_t, uint8_t>, uint32_t>;
/** /**
* Cette fonction a pour double usage la recherche dune chaine de caractères * Cette fonction a pour double usage la recherche dune chaine de caractères
@ -18,18 +18,18 @@ using dic_t = std::map<std::pair<uint16_t, uint8_t>, uint16_t>;
* caractère se référant au dernier caractère de la chaine courante. Si 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 sagit du premier caractère de la chaine, * numéro de chaine est -1, alors il sagit du premier caractère de la chaine,
* et la valeur renvoyée sera la valeur ASCII du caractère. La fonction renvoie * 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 * une paire bool/uint32_t, la valeur booléene indiquant si une nouvelle fut
* ajoutée dans le dictionnaire ou non, et le uint16_t indiquant la valeur * ajoutée dans le dictionnaire ou non, et le uint32_t indiquant la valeur
* numérique de la chaîne dans le dictionnaire. * numérique de la chaîne dans le dictionnaire.
* *
* \param dictionary Dictionnaire * \param dictionary Dictionnaire
* \param nr_chaine Numéro de la chaine précédant le caractères \p c dans \p dictionary * \param nr_chaine Numéro de la chaine précédant le caractères \p c dans \p dictionary
* \param c Caractère suivant la chaine de caractères \p nr_chaine * \param c Caractère suivant la chaine de caractères \p nr_chaine
* \return std::pair<bool, uint16_t> * \return std::pair<bool, uint32_t>
*/ */
const std::pair<bool, uint16_t> const std::pair<bool, uint32_t>
dico(std::map<std::pair<uint16_t, uint8_t>, uint16_t> &t_dictionary, dico(std::map<std::pair<uint32_t, uint8_t>, uint32_t> &t_dictionary,
uint16_t t_nr_chaine, uint8_t t_c) { uint32_t t_nr_chaine, uint8_t t_c) {
if (t_nr_chaine == 0xFFFF) if (t_nr_chaine == 0xFFFF)
return std::make_pair(true, t_c); return std::make_pair(true, t_c);
auto &e = t_dictionary[std::make_pair(t_nr_chaine, t_c)]; auto &e = t_dictionary[std::make_pair(t_nr_chaine, t_c)];

View File

@ -10,8 +10,8 @@
#include <map> #include <map>
/// \brief Recherche ou ajout de chaine dans le dictionnaire /// \brief Recherche ou ajout de chaine dans le dictionnaire
const std::pair<bool, std::uint16_t> const std::pair<bool, std::uint32_t>
dico(std::map<std::pair<std::uint16_t, std::uint8_t>, std::uint16_t> &, dico(std::map<std::pair<std::uint32_t, std::uint8_t>, std::uint32_t> &,
uint16_t, uint8_t); uint32_t, uint8_t);
#endif /* LZW_SRC_COMMON_H_ */ #endif /* LZW_SRC_COMMON_H_ */

View File

@ -16,56 +16,55 @@ constexpr bool debug_mode = false;
#include <iostream> #include <iostream>
#include <thread> #include <thread>
using dict_t = std::map<std::pair<uint16_t, uint8_t>, uint16_t>; using dict_t = std::map<std::pair<uint32_t, uint8_t>, uint32_t>;
using ustring = std::basic_string<uint8_t>; // chaine non encodée using ustring = std::basic_string<uint8_t>; // chaîne non encodée
using uvec = std::vector<uint16_t>; // chaine encodée using uvec = std::vector<uint32_t>; // chaîne encodée
using std::printf; using std::printf;
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();
}
/** /**
* La chaine de caractère \p text est lue caractère par caractère, et est et * 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 * 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 * 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 * de caractères UTF-8 représentant des mots de chars compressés. La fonction
* renvoie ledit vecteur de uint32_t. * renvoie ledit vecteur de uint32_t via le paramètre \p t_res.
* *
* \param t_text Chaine de caractères uint8_t représentant le fichier d'entrée * \param[in] t_text Chaîne de caractères uint8_t représentant le fichier
* \param t_dictionary Dictionnaire de compression * d'entrée \param[out] t_res Chaîne de caractères de sortie
* \return std::vector<uint16_t>
*/ */
void lzw_compress(const std::vector<char> &t_text, uvec &t_res) { void lzw_compress(const std::vector<char> &t_text, uvec &t_res) {
dict_t dictionary{}; dict_t dictionary{};
std::puts("Compressing..."); std::puts("Compressing...");
// uvec res{}; uint32_t w = 0xFFFF;
uint16_t w = 0xFFFF;
uint16_t len = 0;
constexpr size_t DICT_MAX = 7936; /* 12 bits */ constexpr size_t DICT_MAX = 7936; /* 12 bits */
size_t progress = 0;
for (const auto &c : t_text) { for (const auto &c : t_text) {
++len; if (dictionary.size() >= DICT_MAX) {
t_res.push_back(static_cast<uint32_t>(w));
if constexpr (debug_mode) { w = static_cast<uint32_t>(c);
printf("\rprogress: %zu / %zu", ++progress, t_text.size());
}
if (/* len > LENGTH_MAX || */ dictionary.size() >= DICT_MAX) {
t_res.push_back(static_cast<uint16_t>(w));
w = static_cast<uint16_t>(c);
len = 0;
} else if (const auto &[exists, pos] = } else if (const auto &[exists, pos] =
dico(dictionary, w, static_cast<std::uint8_t>(c)); dico(dictionary, w, static_cast<std::uint8_t>(c));
exists) { exists) {
w = pos; w = pos;
} else { } else {
t_res.push_back(static_cast<uint16_t>(w)); t_res.push_back(static_cast<uint32_t>(w));
w = static_cast<std::uint8_t>(c); w = static_cast<std::uint8_t>(c);
len = 0;
} }
} }
printf("\n");
// return res;
} }
/** /**
@ -84,78 +83,63 @@ void compress(const std::string &t_in_file, const char *t_out_file) {
std::ifstream input_file{t_in_file}; std::ifstream input_file{t_in_file};
if (!input_file.is_open()) { if (!input_file.is_open()) {
std::cerr << "Error at " << __FILE__ << ":" << __LINE__ - 2 std::cerr << "Error at " << __FILE__ << ":" << __LINE__ - 2
<< ": could not open output file \"" << t_in_file << "\". Aborting...\n"; << ": could not open output file \"" << t_in_file
<< "\". Aborting...\n";
exit(1); exit(1);
} }
// Fichier de sortie // Fichier de sortie
const char *filename = const char *filename = (t_out_file) ? t_out_file : "output.lzw";
(t_out_file) ? t_out_file : "output.lzw";
FILE *out = fopen(filename, "wb"); FILE *out = fopen(filename, "wb");
if (!out) { if (!out) {
std::cerr << "Error at " << __FILE__ << ":" << __LINE__ - 4 std::cerr << "Error at " << __FILE__ << ":" << __LINE__ - 4
<< ": could not open output file \"" << filename << "\". Aborting...\n"; << ": could not open output file \"" << filename
<< "\". Aborting...\n";
input_file.close(); input_file.close();
exit(1); exit(1);
} }
// input_file.seekg(0, std::ios::end);
// // string contenant le fichier dentrée
// ustring str(static_cast<unsigned long>(input_file.tellg()),
// static_cast<unsigned char>(0));
// input_file.seekg(0, std::ios::beg);
// // assignation du contenu du fichier à str
// str.assign((std::istreambuf_iterator<char>(input_file)),
// std::istreambuf_iterator<char>());
// printf("Size of input file: %zu\n", str.size());
// dict_t dictionary{};
// const auto comp_str{lzw_compress(str, dictionary)};
// thread pool // thread pool
std::vector<std::pair<std::unique_ptr<std::thread>, uvec>> threads{}; std::vector<std::pair<std::unique_ptr<std::thread>, uvec>> threads{};
// char chunk[32768]; // char chunk[32768];
std::vector<char> chunk{}; std::vector<char> chunk(32768, 0);
chunk.reserve(32768); while (input_file.read(chunk.data(),
while (input_file.read(chunk.data(), 32768)) { static_cast<std::streamsize>(chunk.size()))) {
threads.push_back(std::make_pair(nullptr, uvec{})); printf("\n");
threads.emplace_back(nullptr, uvec{});
threads.back().first = std::make_unique<std::thread>( threads.back().first = std::make_unique<std::thread>(
std::thread{lzw_compress, chunk, ref(threads.back().second)}); std::thread{lzw_compress, chunk, ref(threads.back().second)});
if (threads.size() >= 8) { if (threads.size() >= 8) {
for (auto &elem : threads) { join_and_write(threads, out);
(*elem.first).join();
}
for (auto &elem : threads) {
for (const auto c : elem.second) {
write_utf8(out, c);
}
}
threads.clear();
} }
} }
if(threads.size() != 0) { if (!threads.empty()) {
for (auto &elem : threads) { join_and_write(threads, out);
(*elem.first).join();
}
for (auto &elem : threads) {
for (const auto c : elem.second) {
write_utf8(out, c);
}
}
threads.clear();
} }
if (input_file.tellg() != std::ios::end) { if (input_file.tellg() != std::ios::end) {
std::puts("Leftovers..."); 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>());
}
uvec ret{};
lzw_compress(chunk, ret);
for (const auto c : ret) {
if constexpr (debug_mode) {
printf("%c\t", c);
}
write_utf8(out, c);
}
} }
// for (const auto c : comp_str)
// write_utf8(out, c);
fclose(out); fclose(out);
input_file.close(); input_file.close();

View File

@ -11,10 +11,9 @@
#include <iostream> #include <iostream>
/// \brief Compression d'une chaine de caractères /// \brief Compression d'une chaine de caractères
void lzw_compress(const std::vector<char> &t_text, void lzw_compress(const std::vector<char> &, std::vector<std::uint32_t> &);
std::vector<std::uint16_t> &t_rec);
/// \brief Wrapper de \ref lzw_compress /// \brief Wrapper de \ref lzw_compress
void compress(const std::string &t_in_file, const char *t_out_file); void compress(const std::string &, const char *);
#endif /* LZW_SRC_COMPRESS_H_ */ #endif /* LZW_SRC_COMPRESS_H_ */

View File

@ -64,7 +64,7 @@ int main(int argc, char *argv[]) {
std::string output_path{}; std::string output_path{};
bool compressing = true; bool compressing = true;
while (1) { while (true) {
int option_index = 0; int option_index = 0;
static struct option long_options[] = { static struct option long_options[] = {
{"help", no_argument, nullptr, 'h'}, {"help", no_argument, nullptr, 'h'},
@ -72,7 +72,7 @@ int main(int argc, char *argv[]) {
{"output", required_argument, nullptr, 'o'}, {"output", required_argument, nullptr, 'o'},
{"compress", no_argument, nullptr, 'c'}, {"compress", no_argument, nullptr, 'c'},
{"uncompress", no_argument, nullptr, 'u'}, {"uncompress", no_argument, nullptr, 'u'},
{0, 0, 0, 0}}; {nullptr, 0, nullptr, 0}};
int c = getopt_long(argc, argv, "hi:o:cu", long_options, &option_index); int c = getopt_long(argc, argv, "hi:o:cu", long_options, &option_index);
if (c == -1) if (c == -1)
break; break;
@ -133,7 +133,7 @@ int main(int argc, char *argv[]) {
} }
} }
if (input_path == "") { if (input_path.empty()) {
puts("Error: no input file specified"); puts("Error: no input file specified");
return 2; return 2;
} }