|
#ifndef PHOTOCOMPRESSARCHIVER_H
|
|
#define PHOTOCOMPRESSARCHIVER_H
|
|
|
|
#include <condition_variable>
|
|
#include <cstdint>
|
|
#include <deque>
|
|
#include <mutex>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <thread>
|
|
#include <vector>
|
|
|
|
#include <boost/filesystem.hpp>
|
|
#include <boost/regex.hpp>
|
|
|
|
#include "ProtectedAndSynchronizedQueue.h"
|
|
|
|
// Alias the boost fs namespace to keep the code readable
|
|
namespace bfs = boost::filesystem;
|
|
|
|
const std::string BOLD("\033[1m");
|
|
const std::string ENDC("\033[0m");
|
|
const std::string RED("\033[31m");
|
|
const std::string YELLOW("\033[33m");
|
|
const std::string PURPLE("\033[35m");
|
|
const std::string UP_ONE = "\033[1A";
|
|
const std::string DOWN_ONE = "\033[1B";
|
|
|
|
const std::string version("v0.3.5");
|
|
|
|
const boost::regex JPEG_REGEX("^.+\\.(jpg)|(jpeg)$", boost::regex::icase);
|
|
const boost::regex PJG_REGEX("^.+\\.pjg$", boost::regex::icase);
|
|
|
|
const std::string JPG_EXTENSION(".jpg");
|
|
const std::string PJG_EXTENSION(".pjg");
|
|
|
|
const uint32_t PROGRESS_BAR_WIDTH = 80;
|
|
|
|
class WorkUnit
|
|
{
|
|
public:
|
|
bfs::path m_path;
|
|
uint32_t m_file_size;
|
|
|
|
WorkUnit(const bfs::path& path)
|
|
: m_path(path),
|
|
m_file_size(0)
|
|
{
|
|
// Automagically determine the file size
|
|
m_file_size = bfs::file_size(path);
|
|
};
|
|
};
|
|
|
|
class PhotoCompressArchiver
|
|
{
|
|
public:
|
|
|
|
PhotoCompressArchiver(
|
|
const std::string& path,
|
|
uint32_t num_threads,
|
|
bool decompress,
|
|
bool delete_orig,
|
|
bool verbose,
|
|
boost::regex& filter_regex);
|
|
|
|
~PhotoCompressArchiver();
|
|
|
|
/**
|
|
* Start processing
|
|
*/
|
|
int execute();
|
|
|
|
/**
|
|
* Recursively find input files based on passed regex
|
|
*/
|
|
void find_files(
|
|
const bfs::path& dir_path,
|
|
const boost::regex& file_regex);
|
|
|
|
/**
|
|
* Compress/decompress worker thread body
|
|
*/
|
|
void worker_thread_body(uint32_t tid);
|
|
|
|
/**
|
|
* Calculate the return the "global" percent done as determined by the
|
|
* m_files_processed and m_num_input_files instance variables.
|
|
*/
|
|
double get_global_percent_done();
|
|
|
|
/**
|
|
* Asynchronously terminate processing.
|
|
*/
|
|
void terminate();
|
|
|
|
private:
|
|
|
|
const bfs::path m_path; // top level path where to look for input files
|
|
uint32_t m_num_threads; // number of processing threads to use
|
|
bool m_decompress; // decompress files instead of compress them
|
|
bool m_delete_orig; // delete original files after de/compression
|
|
bool m_verbose ; // verbose processing output
|
|
|
|
std::mutex m_output_mutex; // output mutex
|
|
|
|
bool m_terminate_flag; // terminate flag
|
|
|
|
std::atomic<uint32_t> m_files_processed; // number of input files processed
|
|
uint32_t m_num_input_files; // total number of input files found
|
|
uint64_t m_total_uncompressed_size; // total uncompressed size of all images
|
|
uint64_t m_total_compressed_size; // total compressed size of all images
|
|
uint64_t m_running_compressed_size; // running compressed size (for status)
|
|
|
|
// input file list (either images or compressed images)
|
|
ProtectedAndSynchronizedQueue<WorkUnit*> m_file_list;
|
|
|
|
// list of any errors
|
|
ProtectedAndSynchronizedQueue<WorkUnit*> m_errors;
|
|
|
|
std::thread* p_finder_thread; // file finder thread
|
|
std::vector<std::thread*> m_worker_threads; // worker threads
|
|
|
|
bool m_filter_empty; // is the filter regex empty
|
|
boost::regex& m_filter_regex; // filter regular expression
|
|
};
|
|
|
|
#endif // PHOTOCOMPRESSARCHIVER_H
|