mirror of
https://github.com/despawnerer/freearc
synced 2026-08-23 02:23:04 -04:00
1273 lines
59 KiB
C++
1273 lines
59 KiB
C++
#include "Compression.h"
|
||
#include "MultiThreading.h"
|
||
|
||
// ****************************************************************************************************************************
|
||
// Internal basic (de)compression routines *
|
||
// ****************************************************************************************************************************
|
||
|
||
// (De)compress data with supplied method and report operation time via "time"
|
||
// callback
|
||
static int timed_de_compress(COMPRESSION direction,
|
||
COMPRESSION_METHOD *compressor,
|
||
CALLBACK_FUNC *callback, void *auxdata) {
|
||
// SET_JMP_POINT( FREEARC_ERRCODE_GENERAL);
|
||
double time0 = GetThreadCPUTime();
|
||
#ifndef FREEARC_DECOMPRESS_ONLY
|
||
int result =
|
||
(direction == COMPRESS ? compressor->compress(callback, auxdata)
|
||
: compressor->decompress(callback, auxdata));
|
||
#else
|
||
int result =
|
||
(direction == COMPRESS ? FREEARC_ERRCODE_ONLY_DECOMPRESS
|
||
: compressor->decompress(callback, auxdata));
|
||
#endif
|
||
double time1 = GetThreadCPUTime(), t;
|
||
if (time0 >= 0 && time1 >= 0 && compressor->addtime >= 0)
|
||
t = compressor->addtime + time1 - time0;
|
||
else
|
||
t = -1;
|
||
callback("time", &t, 0, auxdata);
|
||
return result;
|
||
}
|
||
|
||
// (De)compress data with method encoded as string
|
||
static int single_de_compress(COMPRESSION direction, char *method,
|
||
CALLBACK_FUNC *callback, void *auxdata) {
|
||
COMPRESSION_METHOD *compressor = ParseCompressionMethod(method);
|
||
if (compressor) {
|
||
int result = timed_de_compress(direction, compressor, callback, auxdata);
|
||
delete compressor;
|
||
return result;
|
||
} else
|
||
return FREEARC_ERRCODE_INVALID_COMPRESSOR;
|
||
}
|
||
|
||
// ****************************************************************************************************************************
|
||
// Механизм передачи данных от одного алгоритма (рас)паковки другому *
|
||
// ****************************************************************************************************************************
|
||
|
||
struct AsOutput {
|
||
virtual int Write(BYTE *buf, int size) = 0;
|
||
virtual void NoMoreWrites() {}
|
||
};
|
||
struct AsInput {
|
||
virtual int Read(BYTE *buf, int size) = 0;
|
||
virtual void NoMoreReads() {}
|
||
};
|
||
|
||
struct Channels : AsOutput, AsInput {
|
||
BYTE *buf; // Buffer pointing to the data sent between methods
|
||
int size; // Amount of data in the buf
|
||
Semaphore read; // Semaphores for inter-thread communication
|
||
Semaphore write;
|
||
bool NoMoreData;
|
||
|
||
Channels() {
|
||
NoMoreData = false;
|
||
read.Create(0, 1);
|
||
write.Create(0, 1);
|
||
}
|
||
void NoMoreReads() {
|
||
NoMoreData = true;
|
||
write.Release();
|
||
} // Tell the output thread that no more data required
|
||
void NoMoreWrites() {
|
||
NoMoreData = true;
|
||
read.Release();
|
||
} // Tell the input thread that no more data will be supplied to it
|
||
|
||
// Послать _size байт из _buf
|
||
int Write(BYTE *_buf, int _size) {
|
||
buf = _buf;
|
||
size = _size;
|
||
read.Release(); // даём разрешение на чтение (в буфере появились данные)
|
||
if (!NoMoreData)
|
||
write.Wait(); // ожидаем разрешения на выход (после того, как все данные
|
||
// будут прочитаны)
|
||
return NoMoreData ? FREEARC_ERRCODE_NO_MORE_DATA_REQUIRED : _size;
|
||
}
|
||
|
||
// Получить _size байт в _buf. _size==0 используется для проверки готовности к
|
||
// чтению
|
||
int Read(BYTE *_buf, int _size) {
|
||
int prev = 0;
|
||
loop:
|
||
// if (_size==0) return prev;
|
||
read.Wait(); // ожидаем разрешения на чтение (появления данных в буфере)
|
||
if (NoMoreData) // данных больше не будет - предыдущий тред завершён
|
||
{
|
||
read.Release(); // возвращаем разрешение на чтение
|
||
return prev;
|
||
} else if (_size <=
|
||
size) // данных в буфере достаточно для выполнения чтения
|
||
{
|
||
memcpy(_buf, buf, _size);
|
||
buf += _size;
|
||
size -= _size;
|
||
read.Release(); // возвращаем разрешение на чтение
|
||
return prev + _size;
|
||
} else // size < _size // данных в буфере недостаточно для выполнения
|
||
// чтения
|
||
{
|
||
memcpy(_buf, buf, size);
|
||
_buf += size;
|
||
_size -= size;
|
||
prev += size;
|
||
write.Release(); // даём разрешение на выход из записи (буфер пуст)
|
||
goto loop;
|
||
}
|
||
}
|
||
};
|
||
|
||
// ****************************************************************************************************************************
|
||
// Multi-stream input/output classes
|
||
// ******************************************************************************************
|
||
// ****************************************************************************************************************************
|
||
|
||
// Формат многопоточного файла: [Заголовок] [Данные]
|
||
// Заголовок ::= [Смещение к началу потока 1]..[Смещение к началу потока N-1]
|
||
// Данные ::= [Кусочек потока 0] [Кусочек потока i] [Кусочек потока j]...
|
||
// Кусочек потока k ::= [Длина кусочка] [Данные кусочка] [Смещение к
|
||
// следующему кусочку того же потока]
|
||
// Длины/смещения записываются 4-байтными числами в Intel-формате. 0
|
||
// используется как спецфлаг, реальные значения перед записью увеличиваются
|
||
// на 10. Спецфлаг в поле смещения озгначает, что кусочков этого потока больше
|
||
// нет. Спецфлаг в поле длины означает, что этот кусочек длится до конца файла.
|
||
|
||
// Перейти на заданную позицию во входном/выходном файле
|
||
#define SEEK_OUTPUT(pos) SEEK("seek_output", pos)
|
||
#define SEEK_INPUT(pos) \
|
||
{ \
|
||
if (!(pos).empty && (pos).n != curpos) { \
|
||
SEEK("seek_input", (pos).n); \
|
||
curpos = (pos).n; \
|
||
} \
|
||
}
|
||
#define SEEK(request, pos) \
|
||
{ \
|
||
int64 localPos = (pos); \
|
||
int localErrCode; \
|
||
if ((localErrCode = callback(request, &localPos, (pos), auxdata)) < 0) { \
|
||
errcode = localErrCode; \
|
||
goto finished; \
|
||
} \
|
||
}
|
||
|
||
// Пара RESERVE/OVERWRITE резервирует в выходном потоке место под запись числа и
|
||
// затем заполняет его. Пока под запись любого числа используются ровно 4
|
||
// байта. LOAD загружает из входного потока записанное таким способом значение.
|
||
// Зарезервированное, но не заполненное значение считывается как
|
||
// place.empty==true.
|
||
#define RESERVE(place) \
|
||
{ \
|
||
(place).pos = curpos; \
|
||
WRITE4(SPECIAL_VALUE_EMPTY); \
|
||
curpos += (place).len = 4; \
|
||
}
|
||
#define OVERWRITE(place, base) \
|
||
{ \
|
||
if ((place).pos != INVALID_FILESIZE) { \
|
||
SEEK_OUTPUT((place).pos); \
|
||
WRITE4(SPECIAL_VALUES + (base) - (place).pos - (place).len); \
|
||
} \
|
||
}
|
||
#define LOAD(place) \
|
||
{ \
|
||
READ4((place).n); \
|
||
curpos += 4; \
|
||
if (0 < (place).n && (place).n < SPECIAL_VALUES) { \
|
||
errcode = FREEARC_ERRCODE_READ; \
|
||
goto finished; \
|
||
} \
|
||
(place).empty = ((place).n == SPECIAL_VALUE_EMPTY); \
|
||
(place).n -= SPECIAL_VALUES; \
|
||
}
|
||
#define SPECIAL_VALUES 10
|
||
#define SPECIAL_VALUE_EMPTY 0
|
||
#define INVALID_FILESIZE (-1)
|
||
|
||
// Число, записанное в выходной файл - его позиция и кол-во использованных байт
|
||
struct PLACE {
|
||
FILESIZE pos;
|
||
int len;
|
||
};
|
||
|
||
// FILESIZE or empty value
|
||
struct MAYBE_FILESIZE {
|
||
FILESIZE n;
|
||
bool empty;
|
||
};
|
||
|
||
// Реализация многопоточной записи в один файл путём интерливинга данных от
|
||
// отдельных потоков
|
||
struct MultiWriter {
|
||
bool first_time; // TRUE - structure wasn't yet initialized
|
||
Mutex exclusive_access; // Ensure single-threaded access to the structure and
|
||
// underlying output file
|
||
int nStreams; // Number of output streams going to be interleaved
|
||
CALLBACK_FUNC *callback; // Original callback (function that provides access
|
||
// to the underlying files)
|
||
void *auxdata; // Original callback parameter
|
||
FILESIZE curpos; // Current position in the output file
|
||
int last_n; // Номер текущего записываемого в файл потока (при переключении на
|
||
// другой поток мы должны завершить кусочек старого)
|
||
PLACE *ofs; // ofs[N] - позиция в файле, куда надо записать смещение к
|
||
// следующему кусочку потока N, как только мы его начнём
|
||
PLACE *len; // len[N] - позиция в файле, куда надо записать длину кусочка
|
||
// потока N, как только мы его завершим
|
||
|
||
MultiWriter(int _nStreams, CALLBACK_FUNC *_callback, void *_auxdata) {
|
||
nStreams = _nStreams;
|
||
callback = _callback;
|
||
auxdata = _auxdata;
|
||
first_time = TRUE;
|
||
ofs = new PLACE[nStreams];
|
||
len = new PLACE[nStreams];
|
||
}
|
||
int Write(int n, BYTE *buf, int size);
|
||
~MultiWriter() {
|
||
delete[] len;
|
||
delete[] ofs;
|
||
}
|
||
};
|
||
|
||
// Реализация многопоточного чтения из одного файла путём деинтерливинга данных
|
||
// отдельных потоков
|
||
struct MultiReader {
|
||
bool first_time; // TRUE - structure wasn't yet initialized
|
||
Mutex exclusive_access; // Ensure single-threaded access to the structure and
|
||
// underlying input file
|
||
int nStreams; // Number of input streams going to be deinterleaved
|
||
CALLBACK_FUNC *callback; // Original callback (function that provides access
|
||
// to the underlying files)
|
||
void *auxdata; // Original callback parameter
|
||
FILESIZE curpos; // Current position in the input file
|
||
int last_n; // Номер текущего читаемого из файла потока (при переключении на
|
||
// другой поток мы должны сделать seek на его текущий кусочек)
|
||
MAYBE_FILESIZE *pos; // pos[N] - позиция во входном файле, откуда будут
|
||
// читаться следующие данные потока N
|
||
MAYBE_FILESIZE
|
||
*len; // len[N] - кол-во байт, оставшихся в текущем кусочке потока N
|
||
|
||
MultiReader(int _nStreams, CALLBACK_FUNC *_callback, void *_auxdata) {
|
||
nStreams = _nStreams;
|
||
callback = _callback;
|
||
auxdata = _auxdata;
|
||
first_time = TRUE;
|
||
pos = new MAYBE_FILESIZE[nStreams];
|
||
len = new MAYBE_FILESIZE[nStreams];
|
||
}
|
||
int Read(int n, BYTE *buf, int size);
|
||
~MultiReader() {
|
||
delete[] len;
|
||
delete[] pos;
|
||
}
|
||
};
|
||
|
||
// Записать содержимое буфера в поток n
|
||
int MultiWriter::Write(int n, BYTE *buf, int size) {
|
||
// Writing to sole output don't require the interleaving
|
||
if (n == 0 && nStreams == 1)
|
||
return callback("write", buf, size, auxdata);
|
||
|
||
Lock _(exclusive_access); // Prohibit simultaneous writing from multiple OS
|
||
// threads
|
||
int errcode = FREEARC_OK;
|
||
if (n < 0 || n >= nStreams || nStreams <= 1)
|
||
return FREEARC_ERRCODE_GENERAL;
|
||
|
||
if (first_time) { // Initialization of multi-stream writing
|
||
first_time = FALSE;
|
||
curpos = 0;
|
||
for (int i = 1; i < nStreams; i++) {
|
||
RESERVE(ofs[i]); // Зарезервируем в выходном файле место для записи
|
||
// смещения к первому кусочку потока i
|
||
len[i].pos = INVALID_FILESIZE;
|
||
}
|
||
last_n = 0; // Начнём запись в поток 0
|
||
ofs[0].pos = INVALID_FILESIZE;
|
||
RESERVE(len[0]); // Зарезервируем в выходном файле место для записи длины
|
||
// начинающегося здесь кусочка потока 0
|
||
}
|
||
|
||
if (n != last_n) { // Switching from writing to stream last_n into writing to
|
||
// stream n
|
||
FILESIZE data_end = curpos;
|
||
RESERVE(ofs[last_n]); // Зарезервируем в выходном файле место для записи
|
||
// смещения к след. кусочку потока last_n
|
||
FILESIZE between_blocks = curpos;
|
||
RESERVE(len[n]); // Зарезервируем в выходном файле место для записи длины
|
||
// начинающегося здесь кусочка потока n
|
||
|
||
OVERWRITE(ofs[n],
|
||
between_blocks); // Вернёмся назад и запишем смещение из пред.
|
||
// кусочка потока n к вновь начинающемуся
|
||
OVERWRITE(len[last_n],
|
||
data_end); // Вернёмся назад и запишем длину только что
|
||
// закончившегося кусочка потока last_n
|
||
|
||
SEEK_OUTPUT(curpos);
|
||
last_n = n;
|
||
}
|
||
|
||
WRITE(buf, size);
|
||
curpos += size;
|
||
return FREEARC_OK;
|
||
|
||
finished:
|
||
return errcode;
|
||
}
|
||
|
||
// Fill buf with data read from stream n
|
||
int MultiReader::Read(int n, BYTE *buf, int size) {
|
||
// Reading from sole input don't need the deinterleaving
|
||
if (n == 0 && nStreams == 1)
|
||
return callback("read", buf, size, auxdata);
|
||
|
||
Lock _(exclusive_access); // Prohibit simultaneous reading from multiple OS
|
||
// threads
|
||
int errcode = FREEARC_OK, orig_size = size;
|
||
if (n < 0 || n >= nStreams || nStreams <= 1)
|
||
return FREEARC_ERRCODE_GENERAL;
|
||
|
||
if (first_time) { // Initialization of multi-stream reading
|
||
first_time = FALSE;
|
||
curpos = 0;
|
||
for (int i = 1; i < nStreams; i++) { // Starting positions of streams 1..N-1
|
||
// were saved at the file beginning
|
||
LOAD(pos[i]);
|
||
pos[i].n += curpos; // Decode position of the first chunk of the stream i
|
||
len[i].n = 0;
|
||
len[i].empty = false;
|
||
}
|
||
last_n = 0; // Начнём чтение из потока 0
|
||
pos[0].n = curpos;
|
||
pos[0].empty = false; // Stream 0 starts right after the saved positions of
|
||
// other streams
|
||
len[0].n = 0;
|
||
len[0].empty = false; // Length of first chunk of stream 0 isn't yet loaded
|
||
}
|
||
|
||
if (n !=
|
||
last_n) { // Switching from reading stream last_n to reading of stream n
|
||
SEEK_INPUT(pos[n]);
|
||
last_n = n;
|
||
}
|
||
|
||
while (size) { // While we need to read more data to the buf
|
||
if (!len[n].empty &&
|
||
len[n].n == 0) { // We should jump to the next chunk of stream n
|
||
if (pos[n].empty)
|
||
break; // End-Of-Stream: there are no more chunks in stream n
|
||
SEEK_INPUT(pos[n]);
|
||
LOAD(len[n]); // Read length of being started chunk of stream n
|
||
pos[n].n =
|
||
curpos; // Advance pos[n] to the first byte after the length encoding
|
||
}
|
||
int b, bytes = len[n].empty
|
||
? size
|
||
: mymin(size, len[n].n); // How much bytes we can read
|
||
if (bytes) {
|
||
READ_LEN(b, buf, bytes);
|
||
if (b == 0)
|
||
break;
|
||
curpos += b;
|
||
pos[n].n += b;
|
||
len[n].n -= b;
|
||
buf += b;
|
||
size -= b;
|
||
}
|
||
if (!len[n].empty && len[n].n == 0) { // At the end of chunk
|
||
LOAD(pos[n]);
|
||
pos[n].n +=
|
||
curpos; // Decode position of the next chunk of the same stream
|
||
}
|
||
}
|
||
return orig_size - size;
|
||
|
||
finished:
|
||
return errcode;
|
||
}
|
||
|
||
struct MultiReaderAsInput : AsInput {
|
||
int n;
|
||
MultiReader *multi_reader;
|
||
void Bind(int _n, MultiReader *_multi_reader) {
|
||
n = _n;
|
||
multi_reader = _multi_reader;
|
||
}
|
||
int Read(BYTE *buf, int size) { return multi_reader->Read(n, buf, size); }
|
||
};
|
||
|
||
struct MultiWriterAsOutput : AsOutput {
|
||
int n;
|
||
MultiWriter *multi_writer;
|
||
void Bind(int _n, MultiWriter *_multi_writer) {
|
||
n = _n;
|
||
multi_writer = _multi_writer;
|
||
}
|
||
int Write(BYTE *buf, int size) { return multi_writer->Write(n, buf, size); }
|
||
};
|
||
|
||
// ****************************************************************************************************************************
|
||
// Упаковка и распаковка данных деревом методов *
|
||
// ****************************************************************************************************************************
|
||
|
||
// Глобальные данные процесса (рас)паковки
|
||
struct Globals {
|
||
COMPRESSION direction; // COMPRESS or DECOMPRESS - that's the question!
|
||
CALLBACK_FUNC *callback; // Original callback (function that reads data in the
|
||
// first method and writes data in the last one)
|
||
void *auxdata; // Original callback parameter
|
||
int retcode; // multi_de_compress() return code
|
||
Mutex retcode_cs; // Ensure single-threaded access to retcode
|
||
|
||
Globals(COMPRESSION _direction, CALLBACK_FUNC *_callback, void *_auxdata) {
|
||
direction = _direction;
|
||
callback = _callback;
|
||
auxdata = _auxdata;
|
||
retcode = 0;
|
||
}
|
||
|
||
// Set overall multi_de_compress() exit code
|
||
void SetExitCode(int code) {
|
||
Lock _(retcode_cs);
|
||
// Save into retcode first error code signalled (subsequent error codes may
|
||
// be sequels of the first one)
|
||
if (retcode == 0 && code != FREEARC_ERRCODE_NO_MORE_DATA_REQUIRED)
|
||
retcode = code;
|
||
}
|
||
};
|
||
|
||
// Локальные данные одного метода
|
||
struct Locals {
|
||
Globals *Global;
|
||
Thread thread; // OS thread executing this (de)compression algorithm
|
||
CMETHOD method; // String denoting (de)compression method with its parameters
|
||
int NumInputs;
|
||
int NumOutputs;
|
||
AsInput **Input;
|
||
AsOutput **Output;
|
||
};
|
||
|
||
static THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE
|
||
multi_de_compress_thread(void *paramPtr);
|
||
static int multi_de_compress_callback(const char *what, void *buf, int size,
|
||
void *paramPtr);
|
||
|
||
// Упаковать/распаковать данные деревом методов
|
||
static int multi_de_compress(COMPRESSION direction, char *compressor,
|
||
CALLBACK_FUNC *callback, void *auxdata) {
|
||
// Мы будем работать с копией строки, потому что split() модифицирует её
|
||
char new_compressor[MAX_COMPRESSOR_STRLEN],
|
||
output_compressors_buf[MAX_COMPRESSOR_STRLEN * 2],
|
||
*out_ptr = output_compressors_buf;
|
||
strncopy(new_compressor, compressor, MAX_COMPRESSOR_STRLEN);
|
||
|
||
// Разобьём компрессор на отдельные алгоритмы и запустим для каждого из них
|
||
// отдельный тред
|
||
CMETHOD cm[MAX_METHODS_IN_COMPRESSOR];
|
||
int N = split(new_compressor, COMPRESSION_METHODS_DELIMITER, cm,
|
||
MAX_METHODS_IN_COMPRESSOR);
|
||
|
||
// Теперь мы знаем, что дерево включает N методов сжатия, создадим локальные
|
||
// структуры для них
|
||
Globals Global(direction, callback, auxdata);
|
||
Locals Local[MAX_METHODS_IN_COMPRESSOR];
|
||
Channels Channel[MAX_METHODS_IN_COMPRESSOR];
|
||
MultiReaderAsInput Reader[MAX_METHODS_IN_COMPRESSOR];
|
||
MultiWriterAsOutput Writer[MAX_METHODS_IN_COMPRESSOR];
|
||
int InChan = 1, OutChan = 1;
|
||
|
||
// Arrays storing inputs/ouputs for all methods
|
||
AsInput *LocalInputsArray[MAX_METHODS_IN_COMPRESSOR],
|
||
**LocalInputs = LocalInputsArray;
|
||
AsOutput *LocalOutputsArray[MAX_METHODS_IN_COMPRESSOR],
|
||
**LocalOutputs = LocalOutputsArray;
|
||
#define AllocInputs(Loc, n) \
|
||
{ \
|
||
Loc.Input = LocalInputs; \
|
||
Loc.NumInputs = n; \
|
||
LocalInputs += n; \
|
||
}
|
||
#define AllocOutputs(Loc, n) \
|
||
{ \
|
||
Loc.Output = LocalOutputs; \
|
||
Loc.NumOutputs = n; \
|
||
LocalOutputs += n; \
|
||
}
|
||
|
||
// Сформируем взаимосвязи входов и выходов алгоритмов в соответствии с деревом
|
||
// методов
|
||
for (int i = N - 1; i >= 0; i--) {
|
||
int nStreams = CompressionService(cm[i], "NumOutStreams");
|
||
if (nStreams <= 0)
|
||
return FREEARC_ERRCODE_INVALID_COMPRESSOR;
|
||
|
||
if (direction ==
|
||
COMPRESS) // СОЗДАДИМ ДЕРЕВО ВЫХОДОВ ДЛЯ УПАКОВКИ
|
||
// ============================================================
|
||
{
|
||
AllocInputs(Local[i], 1);
|
||
Local[i].Input[0] = i > 0 ? (AsInput *)&Channel[i - 1] : &Reader[0];
|
||
AllocOutputs(Local[i], nStreams);
|
||
Local[i].Output[0] = i < N - 1 ? (AsOutput *)&Channel[i] : &Writer[0];
|
||
for (int j = 1; j < nStreams; j++) {
|
||
*out_ptr =
|
||
'\0'; // буфер для запроса метода упаковки j-го выхода алгоритма
|
||
if (CompressionService(cm[i], "GetOutStreamCompressor", j, out_ptr) < 0)
|
||
return FREEARC_ERRCODE_INVALID_COMPRESSOR;
|
||
if (*out_ptr) { // ============================================ На
|
||
// выходе стоит метод сжатия ==========================
|
||
Local[i].Output[j] = &Channel[N]; // Используем канал N для передачи
|
||
// данных между этими методами
|
||
AllocInputs(Local[N], 1);
|
||
Local[N].Input[0] = &Channel[N];
|
||
AllocOutputs(Local[N], 1);
|
||
Local[N].Output[0] =
|
||
&Writer[OutChan++]; // Выход нового метода пойдёт в новый поток в
|
||
// выходном файле
|
||
cm[N++] = out_ptr;
|
||
out_ptr += strlen(out_ptr) + 1; // Добавим новый метод сжатия в дерево
|
||
} else { // ============================================ Выход напрямую
|
||
// записывается в выходной файл ===========
|
||
Local[i].Output[j] =
|
||
&Writer[OutChan++]; // Этот выход метода пойдёт в новый поток в
|
||
// выходном файле
|
||
}
|
||
}
|
||
} else // СОЗДАДИМ ДЕРЕВО ВХОДОВ ДЛЯ РАСПАКОВКИ
|
||
// ===============================================================================
|
||
{
|
||
AllocOutputs(Local[i], 1);
|
||
Local[i].Output[0] = i > 0 ? (AsOutput *)&Channel[i - 1] : &Writer[0];
|
||
AllocInputs(Local[i], nStreams);
|
||
Local[i].Input[0] = i < N - 1 ? (AsInput *)&Channel[i] : &Reader[0];
|
||
for (int j = 1; j < nStreams; j++) {
|
||
*out_ptr = '\0'; // буфер для запроса упаковщика j-го выхода алгоритма
|
||
if (CompressionService(cm[i], "GetOutStreamCompressor", j, out_ptr) < 0)
|
||
return FREEARC_ERRCODE_INVALID_COMPRESSOR;
|
||
if (*out_ptr) { // ============================================ На входе
|
||
// стоит метод сжатия ===========================
|
||
Local[i].Input[j] = &Channel[N]; // Используем канал N для передачи
|
||
// данных между этими методами
|
||
AllocOutputs(Local[N], 1);
|
||
Local[N].Output[0] = &Channel[N];
|
||
AllocInputs(Local[N], 1);
|
||
Local[N].Input[0] = &Reader[InChan++]; // Выход нового метода пойдёт в
|
||
// новый поток в выходном файле
|
||
cm[N++] = out_ptr;
|
||
out_ptr += strlen(out_ptr) + 1; // Добавим новый метод сжатия в дерево
|
||
} else { // ============================================ Вход напрямую
|
||
// читается из выходного файла =============
|
||
Local[i].Input[j] = &Reader[InChan++]; // Этот выход метода пойдёт в
|
||
// новый поток в выходном файле
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (N == 1 && InChan == 1 && OutChan == 1)
|
||
return single_de_compress(direction, new_compressor, callback,
|
||
auxdata); // multi-threading isn't required
|
||
|
||
// Объекты ввода/вывода для входных и выходных потоков
|
||
MultiReader multi_reader(InChan, callback,
|
||
auxdata); // Worker object implementing multi-stream
|
||
// reading for decompression
|
||
MultiWriter multi_writer(OutChan, callback,
|
||
auxdata); // Worker object implementing multi-stream
|
||
// writing for compression
|
||
|
||
iterate(InChan, Reader[i].Bind(i, &multi_reader));
|
||
iterate(OutChan, Writer[i].Bind(i, &multi_writer));
|
||
|
||
// Start N threads
|
||
for (int i = 0; i < N; i++) {
|
||
Local[i].Global = &Global;
|
||
Local[i].method = cm[i];
|
||
Local[i].thread.Create(multi_de_compress_thread, &Local[i]);
|
||
}
|
||
|
||
// Wait until all threads will be finished and return errcode or 0 at success
|
||
for (int i = 0; i < N; i++)
|
||
Local[i].thread.Wait();
|
||
return Global.retcode;
|
||
}
|
||
|
||
// Один тред распаковки в multi_de_compress
|
||
static THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE
|
||
multi_de_compress_thread(void *paramPtr) {
|
||
Locals *Local = (Locals *)paramPtr;
|
||
Globals *Global = Local->Global;
|
||
// Не запускать этот thread, пока не начался вывод из предыдущего (для
|
||
// экономии памяти)
|
||
Local->Input[0]->Read(NULL, 0); // ожидаем появления данных в буфере
|
||
SetCompressionThreadPriority(); // понизить приоритет треда
|
||
int ret = single_de_compress(Global->direction, Local->method,
|
||
multi_de_compress_callback, paramPtr);
|
||
if (ret < 0)
|
||
Global->SetExitCode(ret); // Set global error code if single_de_compress()
|
||
// returned with error
|
||
for (int i = 0; i < Local->NumInputs; i++)
|
||
Local->Input[i]->NoMoreReads(); // Tell the input threads that no more data
|
||
// are required
|
||
for (int i = 0; i < Local->NumOutputs; i++)
|
||
Local->Output[i]->NoMoreWrites(); // Tell the output threads that no more
|
||
// data will be supplied to them
|
||
return 0;
|
||
}
|
||
|
||
// Callback-функция для multi_de_compress_thread(), перехватывающая операции
|
||
// чтения и записи
|
||
static int multi_de_compress_callback(const char *what, void *_buf, int size,
|
||
void *paramPtr) {
|
||
Locals *Local = (Locals *)paramPtr;
|
||
Globals *Global = Local->Global;
|
||
BYTE *buf = (BYTE *)_buf;
|
||
|
||
// readXXX: прочитать данные для обработки из входного потока номер XXX, 0 по
|
||
// умолчанию
|
||
if (start_with(what, "read")) {
|
||
int xxx = what[4] ? atoi(what + 4) : 0;
|
||
if (xxx >= Local->NumInputs)
|
||
return FREEARC_ERRCODE_READ;
|
||
return Local->Input[xxx]->Read(buf, size);
|
||
}
|
||
|
||
// writeXXX: записать результат обработки в выходной поток номер XXX, 0 по
|
||
// умолчанию
|
||
else if (start_with(what, "write")) {
|
||
int xxx = what[5] ? atoi(what + 5) : 0;
|
||
if (xxx >= Local->NumOutputs)
|
||
return FREEARC_ERRCODE_WRITE;
|
||
return Local->Output[xxx]->Write(buf, size);
|
||
}
|
||
|
||
// progress: пропустить поскольку мы пока не умеем комбинировать "progress" от
|
||
// цепочки упаковщиков
|
||
else if (strequ(what, "progress")) {
|
||
return FREEARC_ERRCODE_NOT_IMPLEMENTED;
|
||
}
|
||
|
||
// Все остальные запросы передаются на выполнение в оригинальный callback
|
||
else
|
||
return Global->callback(what, buf, size, Global->auxdata);
|
||
}
|
||
|
||
// ****************************************************************************************************************************
|
||
// Compression *
|
||
// ****************************************************************************************************************************
|
||
|
||
#ifndef FREEARC_DECOMPRESS_ONLY
|
||
// Compress data with given compressor (compression method or chain of
|
||
// compression methods)
|
||
int Compress(char *compressor, CALLBACK_FUNC *callback, void *auxdata) {
|
||
return multi_de_compress(COMPRESS, compressor, callback, auxdata);
|
||
}
|
||
|
||
// Put to the output stream string describing the compressor and then the
|
||
// compressed data
|
||
int CompressWithHeader(char *orig_compressor, CALLBACK_FUNC *callback,
|
||
void *auxdata) {
|
||
// Split compressor into methods
|
||
char new_compressor[MAX_COMPRESSOR_STRLEN],
|
||
canonical_methods[MAX_COMPRESSOR_STRLEN], *p = canonical_methods;
|
||
CMETHOD method[MAX_METHODS_IN_COMPRESSOR];
|
||
strncopy(new_compressor, orig_compressor, MAX_COMPRESSOR_STRLEN);
|
||
int N = split(new_compressor, COMPRESSION_METHODS_DELIMITER, method,
|
||
MAX_METHODS_IN_COMPRESSOR);
|
||
|
||
// Generate canonical, pure representation of each compression method (in
|
||
// order to improve compatibility with future decompressors and omit
|
||
// compression-stage specific hints
|
||
for (int i = 0; i < N; i++) {
|
||
CanonizeCompressionMethod(method[i], p, TRUE);
|
||
method[i] = p;
|
||
p += strlen(p) + 1;
|
||
}
|
||
method[N] = NULL;
|
||
|
||
// Join canonized method strings back together and write canonicalized
|
||
// compressor string to output stream
|
||
join(method, COMPRESSION_METHODS_DELIMITER, new_compressor,
|
||
MAX_COMPRESSOR_STRLEN);
|
||
int result =
|
||
callback("write", new_compressor, strlen(new_compressor) + 1, auxdata);
|
||
|
||
if (result >= 0)
|
||
result = Compress(
|
||
orig_compressor, callback,
|
||
auxdata); // Use original compressor string since it may include hints
|
||
// omitted by CanonizeCompressionMethod(purify=TRUE)
|
||
return result;
|
||
}
|
||
#endif // !defined (FREEARC_DECOMPRESS_ONLY)
|
||
|
||
// ****************************************************************************************************************************
|
||
// Decompression *
|
||
// ****************************************************************************************************************************
|
||
|
||
// Decompress data with given compressor (compression method or chain of
|
||
// compression methods)
|
||
int Decompress(char *compressor, CALLBACK_FUNC *callback, void *auxdata) {
|
||
return multi_de_compress(DECOMPRESS, compressor, callback, auxdata);
|
||
}
|
||
|
||
// Read string, describing the compressor, from input stream and decompress rest
|
||
// of stream with this compressor
|
||
int DecompressWithHeader(CALLBACK_FUNC *callback, void *auxdata) {
|
||
char compressor[MAX_COMPRESSOR_STRLEN];
|
||
for (int i = 0; i < MAX_COMPRESSOR_STRLEN; i++) {
|
||
// Посимвольно читаем входные данные, пока не прочтём символ конца строки
|
||
callback("read", &compressor[i], 1, auxdata);
|
||
if (compressor[i] == '\0')
|
||
return Decompress(compressor, callback, auxdata);
|
||
}
|
||
return FREEARC_ERRCODE_INVALID_COMPRESSOR; // Сюда мы попадаем, если в первых
|
||
// MAX_COMPRESSOR_STRLEN символах
|
||
// входных данных не нашлось
|
||
// символа '\0'
|
||
}
|
||
|
||
// ****************************************************************************************************************************
|
||
// Getters and Setters: query or set memory usage, dictionary, block size for
|
||
// compresssion method *
|
||
// ****************************************************************************************************************************
|
||
|
||
#define Generate_Getter(GETTER) \
|
||
MemSize GETTER(char *method) { \
|
||
COMPRESSION_METHOD *compressor = ParseCompressionMethod(method); \
|
||
if (compressor) { \
|
||
MemSize bytes = compressor->GETTER(); \
|
||
delete compressor; \
|
||
return bytes; \
|
||
} else \
|
||
return (MemSize)FREEARC_ERRCODE_INVALID_COMPRESSOR; \
|
||
}
|
||
|
||
#define Generate_Setter(SETTER) \
|
||
int SETTER(char *in_method, MemSize bytes, char *out_method) { \
|
||
COMPRESSION_METHOD *compressor = ParseCompressionMethod(in_method); \
|
||
if (compressor) { \
|
||
compressor->SETTER(bytes); \
|
||
compressor->ShowCompressionMethod(out_method, FALSE); \
|
||
delete compressor; \
|
||
return FREEARC_OK; \
|
||
} else \
|
||
return FREEARC_ERRCODE_INVALID_COMPRESSOR; \
|
||
}
|
||
|
||
// Информация о памяти, необходимой для упаковки/распаковки, размере словаря и
|
||
// размере блока
|
||
Generate_Getter(GetDictionary) Generate_Getter(GetBlockSize)
|
||
Generate_Getter(GetDecompressionMem) Generate_Setter(SetDecompressionMem)
|
||
Generate_Setter(LimitDecompressionMem)
|
||
|
||
#ifndef FREEARC_DECOMPRESS_ONLY
|
||
// Информация о памяти, необходимой для упаковки/распаковки
|
||
Generate_Getter(GetCompressionMem) Generate_Getter(GetMinCompressionMem)
|
||
Generate_Getter(GetMinDecompressionMem)
|
||
|
||
// Возвратить в out_method новый метод сжатия, настроенный на использование
|
||
// соответствующего количества памяти при упаковке/распаковке или
|
||
// словаря/размера блока
|
||
Generate_Setter(SetDictionary) Generate_Setter(SetBlockSize)
|
||
Generate_Setter(SetCompressionMem)
|
||
Generate_Setter(SetMinDecompressionMem)
|
||
|
||
// Возвратить в out_method новый метод сжатия, уменьшив, если необходимо,
|
||
// используемую алгоритмом память / его словарь / размер блока
|
||
Generate_Setter(LimitDictionary) Generate_Setter(LimitBlockSize)
|
||
Generate_Setter(LimitCompressionMem)
|
||
Generate_Setter(LimitMinDecompressionMem)
|
||
#endif // !defined (FREEARC_DECOMPRESS_ONLY)
|
||
|
||
// Объём памяти, характеризующий алгоритм
|
||
MemSize COMPRESSION_METHOD::GetAlgoMem() {
|
||
MemSize dict = GetDictionary();
|
||
if (dict)
|
||
return dict;
|
||
MemSize BlockSize = GetBlockSize();
|
||
if (BlockSize)
|
||
return BlockSize;
|
||
return 0;
|
||
}
|
||
|
||
// Универсальный метод. Параметры:
|
||
// what: "compress", "decompress", "setCompressionMem", "limitDictionary"...
|
||
// data: данные для операции в формате, зависящем от конкретной выполняемой
|
||
// операции param&result: простой числовой параметр, что достаточно для многих
|
||
// информационных операций
|
||
// Неиспользуемые параметры устанавливайте в NULL/0. result<0 - код ошибки
|
||
int COMPRESSION_METHOD::doit(char *what, int param, void *data,
|
||
CALLBACK_FUNC *callback) {
|
||
if (strequ(what, "encryption?"))
|
||
return 0; // Это алгоритм шифрования?
|
||
#ifndef FREEARC_DECOMPRESS_ONLY
|
||
else if (strequ(what, "GetCompressionMem"))
|
||
return GetCompressionMem(); // Объём памяти, необходимый для упаковки
|
||
#endif // !defined (FREEARC_DECOMPRESS_ONLY)
|
||
else if (strequ(what, "GetDecompressionMem"))
|
||
return GetDecompressionMem(); // Объём памяти, необходимый для распаковки
|
||
else if (strequ(what, "NumOutStreams"))
|
||
return 1; // Кол-во выходных потоков упаковщика
|
||
else if (strequ(what, "GetAlgoMem"))
|
||
return GetAlgoMem(); // Объём памяти, характеризующий алгоритм
|
||
else
|
||
return FREEARC_ERRCODE_NOT_IMPLEMENTED;
|
||
}
|
||
|
||
// Вывести в canonical_method каноническое представление метода сжатия in_method
|
||
int CanonizeCompressionMethod(char *method, char *canonical_method,
|
||
int purify) {
|
||
COMPRESSION_METHOD *compressor = ParseCompressionMethod(method);
|
||
if (compressor) {
|
||
compressor->ShowCompressionMethod(canonical_method, purify != 0);
|
||
delete compressor;
|
||
return FREEARC_OK;
|
||
} else
|
||
return FREEARC_ERRCODE_INVALID_COMPRESSOR;
|
||
}
|
||
|
||
// ****************************************************************************************************************************
|
||
// (De)compress data from memory buffer (input) to another memory buffer
|
||
// (output) *
|
||
// ****************************************************************************************************************************
|
||
|
||
// Callback-функция чтения/записи для (рас)паковки в памяти
|
||
int ReadWriteMem(const char *what, void *buf, int size, void *_membuf) {
|
||
MemBuf *membuf = (MemBuf *)_membuf;
|
||
if (strequ(what, "read") && membuf->readPtr) {
|
||
// Скопировать данные из readPtr в buf и продвинуть указатель чтения
|
||
int read_bytes = membuf->readLeft < size ? membuf->readLeft : size;
|
||
memcpy(buf, membuf->readPtr, read_bytes);
|
||
membuf->readPtr += read_bytes;
|
||
membuf->readLeft -= read_bytes;
|
||
return read_bytes;
|
||
} else if (strequ(what, "write") && membuf->writePtr) {
|
||
// Скопировать данные из buf в writePtr и продвинуть указатель записи
|
||
if (size > membuf->writeLeft)
|
||
return FREEARC_ERRCODE_OUTBLOCK_TOO_SMALL;
|
||
memcpy(membuf->writePtr, buf, size);
|
||
membuf->writePtr += size;
|
||
membuf->writeLeft -= size;
|
||
return size;
|
||
} else {
|
||
// Остальные операции отдаём "наверх"
|
||
return (membuf->callback
|
||
? membuf->callback(what, buf, size, membuf->auxdata)
|
||
: FREEARC_ERRCODE_NOT_IMPLEMENTED);
|
||
}
|
||
}
|
||
|
||
// Реализация DeCompressMem по умолчанию: через compress/decompress и MemBuf.
|
||
// Затратный, но универсальный вариант
|
||
int COMPRESSION_METHOD::DeCompressMem(COMPRESSION direction, void *input,
|
||
int inputSize, void *output,
|
||
int *outputSize, CALLBACK_FUNC *callback,
|
||
void *auxdata, void **CodecState) {
|
||
MemBuf membuf(input, inputSize, output, *outputSize, callback, auxdata);
|
||
int result = (direction == COMPRESS ?
|
||
#ifndef FREEARC_DECOMPRESS_ONLY
|
||
compress(ReadWriteMem, &membuf)
|
||
#else
|
||
FREEARC_ERRCODE_ONLY_DECOMPRESS
|
||
#endif
|
||
: decompress(ReadWriteMem, &membuf));
|
||
*outputSize = membuf.written();
|
||
return result;
|
||
}
|
||
|
||
// Распаковать данные в памяти, записав в выходной буфер не более outputSize
|
||
// байт. Возвращает код ошибки или количество байт, записанных в выходной буфер
|
||
int DecompressMem(char *compressor, void *input, int inputSize, void *output,
|
||
int outputSize) {
|
||
MemBuf membuf(input, inputSize, output, outputSize);
|
||
int result = Decompress(compressor, ReadWriteMem, &membuf);
|
||
return result < 0 ? result : membuf.written();
|
||
}
|
||
|
||
// Аналог DecompressMem с чтением алгоритма сжатия из самого входного буфера
|
||
int DecompressMemWithHeader(void *input, int inputSize, void *output,
|
||
int outputSize) {
|
||
MemBuf membuf(input, inputSize, output, outputSize);
|
||
int result = DecompressWithHeader(ReadWriteMem, &membuf);
|
||
return result < 0 ? result : membuf.written();
|
||
}
|
||
|
||
#ifndef FREEARC_DECOMPRESS_ONLY
|
||
// Упаковать данные в памяти, записав в выходной буфер не более outputSize байт.
|
||
// Возвращает код ошибки или количество байт, записанных в выходной буфер
|
||
int CompressMem(char *compressor, void *input, int inputSize, void *output,
|
||
int outputSize) {
|
||
MemBuf membuf(input, inputSize, output, outputSize);
|
||
int result = Compress(compressor, ReadWriteMem, &membuf);
|
||
return result < 0 ? result : membuf.written();
|
||
}
|
||
|
||
// Упаковать данные в памяти, записав в выходной буфер не более outputSize байт.
|
||
// Возвращает код ошибки или количество байт, записанных в выходной буфер
|
||
int CompressMemWithHeader(char *compressor, void *input, int inputSize,
|
||
void *output, int outputSize) {
|
||
MemBuf membuf(input, inputSize, output, outputSize);
|
||
int result = CompressWithHeader(compressor, ReadWriteMem, &membuf);
|
||
return result < 0 ? result : membuf.written();
|
||
}
|
||
#endif // !defined (FREEARC_DECOMPRESS_ONLY)
|
||
|
||
// ****************************************************************************************************************************
|
||
// УТИЛИТЫ *
|
||
// ****************************************************************************************************************************
|
||
|
||
// Разбить COMPRESSOR на отдельные алгоритмы сжатия/шифрования
|
||
// void splitCompressor (COMPRESSOR c, ARRAY<CMETHOD> &cm)
|
||
|
||
// Запросить сервис what метода сжатия method
|
||
int CompressionService(char *method, char *what, int param, void *data,
|
||
CALLBACK_FUNC *callback) {
|
||
COMPRESSION_METHOD *compressor = ParseCompressionMethod(method);
|
||
if (compressor) {
|
||
int result = compressor->doit(what, param, data, callback);
|
||
delete compressor;
|
||
return result;
|
||
} else
|
||
return FREEARC_ERRCODE_INVALID_COMPRESSOR;
|
||
}
|
||
|
||
// Проверить, что данный компрессор включает алгоритм шифрования
|
||
int compressorIsEncrypted(COMPRESSOR c) {
|
||
char compressor[MAX_COMPRESSOR_STRLEN];
|
||
strcpy(compressor, c);
|
||
|
||
// Разобьём компрессор на отдельные алгоритмы и поищем среди них алгоритм
|
||
// шифрования
|
||
CMETHOD arr[MAX_METHODS_IN_COMPRESSOR];
|
||
split(compressor, COMPRESSION_METHODS_DELIMITER, arr,
|
||
MAX_METHODS_IN_COMPRESSOR);
|
||
for (CMETHOD *cm = arr; *cm; cm++)
|
||
if (CompressionService(*cm, "encryption?") == 1)
|
||
return TRUE;
|
||
return FALSE;
|
||
}
|
||
|
||
// Вычислить, сколько памяти нужно для распаковки данных, сжатых этим
|
||
// компрессором (портит c)
|
||
MemSize compressorGetDecompressionMem(COMPRESSOR c) {
|
||
// Разобьём компрессор на отдельные алгоритмы и просуммируем их требования к
|
||
// памяти
|
||
CMETHOD arr[MAX_METHODS_IN_COMPRESSOR];
|
||
split(c, COMPRESSION_METHODS_DELIMITER, arr, MAX_METHODS_IN_COMPRESSOR);
|
||
MemSize sum = 0;
|
||
for (CMETHOD *cm = arr; *cm; cm++)
|
||
sum += CompressionService(*cm, "GetDecompressionMem");
|
||
return sum;
|
||
}
|
||
|
||
// ****************************************************************************************************************************
|
||
// ПОДДЕРЖКА ТАБЛИЦЫ ЗАРЕГИСТРИРОВАННЫХ РАЗБОРЩИКОВ МЕТОДОВ СЖАТИЯ И ПОИСК В
|
||
// ЭТОЙ ТАБЛИЦЕ РЕАЛИЗАЦИИ ЧИСТО КОНКРЕТНОГО МЕТОДА *
|
||
// ****************************************************************************************************************************
|
||
|
||
template <class PARSER> struct Parser {
|
||
PARSER parser;
|
||
void *data;
|
||
};
|
||
|
||
int cmCount = 0; // Кол-во зарегистрированных методов сжатия
|
||
Parser<CM_PARSER>
|
||
cmTable[MAX_COMPRESSION_METHODS]; // Таблица, в которую записываются все
|
||
// зарегистрированные парсеры методов
|
||
// сжатия
|
||
|
||
// Добавить новый метод в список поддерживаемых методов сжатия
|
||
int AddCompressionMethod(CM_PARSER parser) {
|
||
CHECK(FREEARC_ERRCODE_INTERNAL, cmCount < elements(cmTable),
|
||
(s, "INTERNAL ERROR: Overflow of compression methods table"));
|
||
cmTable[cmCount++].parser = parser;
|
||
return 0;
|
||
}
|
||
|
||
int cmExternalCount = 0; // Кол-во зарегистрированных внешних методов сжатия
|
||
Parser<CM_PARSER2>
|
||
cmExternalTable[MAX_COMPRESSION_METHODS]; // Таблица, в которую записываются
|
||
// все зарегистрированные парсеры
|
||
// внешних методов сжатия
|
||
|
||
// Очистить таблицу внешних упаковщиков
|
||
void ClearExternalCompressorsTable(void) {
|
||
static int builtins = -1;
|
||
if (builtins < 0)
|
||
builtins = cmExternalCount;
|
||
cmExternalCount =
|
||
builtins; // Оставим только встроенные описания внешних упаковщиков
|
||
}
|
||
|
||
// Добавить парсер метода с дополнительным параметром, который должен быть
|
||
// передан этому парсеру
|
||
int AddExternalCompressionMethod(CM_PARSER2 parser, void *data) {
|
||
CHECK(FREEARC_ERRCODE_GENERAL, cmExternalCount < elements(cmExternalTable),
|
||
(s, "Too much external compression methods defined"));
|
||
cmExternalTable[cmExternalCount].parser = parser;
|
||
cmExternalTable[cmExternalCount].data = data;
|
||
cmExternalCount++;
|
||
return 0;
|
||
}
|
||
|
||
// Сконструировать объект класса COMPRESSION_METHOD, реализующий метод, заданный
|
||
// в виде строки `method`
|
||
COMPRESSION_METHOD *ParseCompressionMethod(char *method) {
|
||
// Превратим строку метода сжатия в массив строк `parameters`, хранящий его
|
||
// название и параметры
|
||
char *parameters[MAX_PARAMETERS];
|
||
char local_method[MAX_METHOD_STRLEN];
|
||
strncopy(local_method, method, sizeof(local_method));
|
||
split(local_method, COMPRESSION_METHOD_PARAMETERS_DELIMITER, parameters,
|
||
MAX_PARAMETERS);
|
||
|
||
// Переберём все зарегистрированные парсеры методов сжатия и найдём тот,
|
||
// который сможет опознать `parameters`
|
||
iterate_var(i, cmExternalCount) {
|
||
COMPRESSION_METHOD *m =
|
||
(*cmExternalTable[i].parser)(parameters, cmExternalTable[i].data);
|
||
if (m)
|
||
return m;
|
||
}
|
||
iterate_var(i, cmCount) {
|
||
COMPRESSION_METHOD *m = (*cmTable[i].parser)(parameters);
|
||
if (m)
|
||
return m;
|
||
}
|
||
return NULL; // Полученный метод сжатия не опознан ни одним из парсеров
|
||
}
|
||
|
||
// ****************************************************************************************************************************
|
||
// Loading compression methods from external DLLs *
|
||
// ****************************************************************************************************************************
|
||
|
||
// Load accelerated function either from facompress.dll or facompress_mt.dll
|
||
FARPROC LoadFromDLL(char *funcname, int only_facompress_mt) { return NULL; }
|
||
|
||
// Other compression methods may chain-redefine this callback in order to
|
||
// perform their own cleanup procedures
|
||
static void NOP() {}
|
||
void (*BeforeUnloadDLL)() = &NOP;
|
||
|
||
// This function unloads DLLs containing accelerated compression functions
|
||
void UnloadDLL(void) { (*BeforeUnloadDLL)(); }
|
||
|
||
// This function cleans up the Compression Library
|
||
void compressionLib_cleanup(void) { removeTemporaryFiles(); }
|
||
|
||
// ****************************************************************************************************************************
|
||
// Compression Library global settings *
|
||
// ****************************************************************************************************************************
|
||
|
||
// Get/set number of threads used for (de)compression. 0 means "autodetect"
|
||
static int CompressionThreads = 1;
|
||
int __cdecl GetCompressionThreads(void) { return CompressionThreads; }
|
||
void __cdecl SetCompressionThreads(int threads) {
|
||
CompressionThreads = threads == 0 ? 1 : threads;
|
||
#ifndef FREEARC_COMPRESSION_DLL
|
||
static FARPROC f = LoadFromDLL("SetCompressionThreads");
|
||
static FARPROC f2 = LoadFromDLL("SetCompressionThreads", TRUE);
|
||
if (f)
|
||
((void(__cdecl *)(int))f)(threads);
|
||
if (f2)
|
||
((void(__cdecl *)(int))f2)(threads);
|
||
#endif
|
||
}
|
||
|
||
// Used in 4x4 only: read entire input buffer before compression begins,
|
||
// allocate output buffer large enough to hold entire compressed output
|
||
int compress_all_at_once = 0;
|
||
void __cdecl Set_compress_all_at_once(int n) {
|
||
compress_all_at_once = n;
|
||
#ifndef FREEARC_COMPRESSION_DLL
|
||
static FARPROC f = LoadFromDLL("Set_compress_all_at_once");
|
||
static FARPROC f2 = LoadFromDLL("Set_compress_all_at_once", TRUE);
|
||
if (f)
|
||
((void(__cdecl *)(int))f)(n);
|
||
if (f2)
|
||
((void(__cdecl *)(int))f2)(n);
|
||
#endif
|
||
}
|
||
|
||
// Enable debugging output
|
||
int debug_mode = 0;
|
||
void __cdecl Set_debug_mode(int n) {
|
||
debug_mode = n;
|
||
#ifndef FREEARC_COMPRESSION_DLL
|
||
static FARPROC f = LoadFromDLL("Set_debug_mode");
|
||
static FARPROC f2 = LoadFromDLL("Set_debug_mode", TRUE);
|
||
if (f)
|
||
((void(__cdecl *)(int))f)(n);
|
||
if (f2)
|
||
((void(__cdecl *)(int))f2)(n);
|
||
#endif
|
||
}
|
||
|
||
// ***********************************************************************************************************************
|
||
// Реализация класса STORING_METHOD *
|
||
// ***********************************************************************************************************************
|
||
|
||
// Функция "(рас)паковки", копирующая данные один в один
|
||
int copy_data(CALLBACK_FUNC *callback, void *auxdata) {
|
||
char buf[BUFFER_SIZE];
|
||
int len;
|
||
while ((len = callback("read", buf, BUFFER_SIZE, auxdata)) > 0) {
|
||
if ((len = callback("write", buf, len, auxdata)) < 0)
|
||
break;
|
||
}
|
||
return len;
|
||
}
|
||
|
||
// Функция распаковки
|
||
int STORING_METHOD::decompress(CALLBACK_FUNC *callback, void *auxdata) {
|
||
return copy_data(callback, auxdata);
|
||
}
|
||
|
||
#ifndef FREEARC_DECOMPRESS_ONLY
|
||
|
||
// Функция упаковки
|
||
int STORING_METHOD::compress(CALLBACK_FUNC *callback, void *auxdata) {
|
||
return copy_data(callback, auxdata);
|
||
}
|
||
|
||
#endif // !defined (FREEARC_DECOMPRESS_ONLY)
|
||
|
||
// Конструирует объект типа STORING_METHOD или возвращает NULL, если это другой
|
||
// метод сжатия
|
||
COMPRESSION_METHOD *parse_STORING(char **parameters) {
|
||
if (strcmp(parameters[0], "storing") == 0 && parameters[1] == NULL)
|
||
// Если название метода - "storing" и параметров у него нет, то это наш
|
||
// метод
|
||
return new STORING_METHOD;
|
||
else
|
||
return NULL; // Это не метод storing
|
||
}
|
||
|
||
static int STORING_x = AddCompressionMethod(
|
||
parse_STORING); // Зарегистрируем парсер метода STORING_METHOD
|
||
|
||
// ***********************************************************************************************************************
|
||
// Реализация класса CRC_METHOD *
|
||
// ***********************************************************************************************************************
|
||
|
||
#ifndef FREEARC_DECOMPRESS_ONLY
|
||
// Функция упаковки, просто "съедающая" входные жанные
|
||
int CRC_METHOD::compress(CALLBACK_FUNC *callback, void *auxdata) {
|
||
char buf[BUFFER_SIZE];
|
||
int len;
|
||
while ((len = callback("read", buf, BUFFER_SIZE, auxdata)) > 0)
|
||
;
|
||
return len;
|
||
}
|
||
#endif // !defined (FREEARC_DECOMPRESS_ONLY)
|
||
|
||
// Конструирует объект типа CRC_METHOD или возвращает NULL, если это другой
|
||
// метод сжатия
|
||
COMPRESSION_METHOD *parse_CRC(char **parameters) {
|
||
if (strcmp(parameters[0], "crc") == 0 && parameters[1] == NULL)
|
||
// Если название метода - "crc" и параметров у него нет, то это наш метод
|
||
return new CRC_METHOD;
|
||
else
|
||
return NULL; // Это не метод crc
|
||
}
|
||
|
||
static int CRC_x =
|
||
AddCompressionMethod(parse_CRC); // Зарегистрируем парсер метода CRC_METHOD
|
||
|
||
// ***********************************************************************************************************************
|
||
// Реализация класса FAKE_METHOD *
|
||
// ***********************************************************************************************************************
|
||
|
||
// Конструирует объект типа FAKE_METHOD или возвращает NULL, если это другой
|
||
// метод сжатия
|
||
COMPRESSION_METHOD *parse_FAKE(char **parameters) {
|
||
if (strcmp(parameters[0], "fake") == 0 && parameters[1] == NULL)
|
||
// Если название метода - "fake" и параметров у него нет, то это наш метод
|
||
return new FAKE_METHOD;
|
||
else
|
||
return NULL; // Это не метод fake
|
||
}
|
||
|
||
static int FAKE_x = AddCompressionMethod(
|
||
parse_FAKE); // Зарегистрируем парсер метода FAKE_METHOD
|
||
|
||
// ****************************************************************************************************************************
|
||
// ВЫЧИСЛЕНИЕ CRC-32 *
|
||
// ****************************************************************************************************************************
|
||
|
||
#ifdef FREEARC_COMPRESSION_DLL
|
||
|
||
// cdecl shells around 7-zip's fastcall assembler routines
|
||
extern "C" uint32 __fastcall CrcUpdateT8(uint32 StartCRC, void *data,
|
||
size_t size, const uint32 *table);
|
||
uint32 CrcUpdate(uint32 StartCRC, void *data, size_t size,
|
||
const uint32 *table) {
|
||
return CrcUpdateT8(StartCRC, data, size, table);
|
||
}
|
||
|
||
extern "C" void(__fastcall AesCtr_Code_Intel)(UInt32 *ivAes, Byte *data,
|
||
size_t numBlocks);
|
||
void Fast_AesCtr_Code(UInt32 *ivAes, Byte *data, size_t numBlocks) {
|
||
AesCtr_Code_Intel(ivAes, data, numBlocks);
|
||
}
|
||
|
||
#else
|
||
|
||
#define kCrcPoly 0xEDB88320
|
||
#define CRC_NUM_TABLES 8
|
||
uint32 g_CrcTable[256 * CRC_NUM_TABLES];
|
||
|
||
void CrcGenerateTable() {
|
||
uint32 i;
|
||
for (i = 0; i < 256; i++) {
|
||
uint32 r = i;
|
||
int j;
|
||
for (j = 0; j < 8; j++)
|
||
r = (r >> 1) ^ (kCrcPoly & ~((r & 1) - 1));
|
||
g_CrcTable[i] = r;
|
||
}
|
||
#if CRC_NUM_TABLES > 1
|
||
for (; i < 256 * CRC_NUM_TABLES; i++) {
|
||
uint32 r = g_CrcTable[i - 256];
|
||
g_CrcTable[i] = g_CrcTable[r & 0xFF] ^ (r >> 8);
|
||
}
|
||
#endif
|
||
}
|
||
|
||
#define CRC_UPDATE_BYTE_2(crc, b) \
|
||
(g_CrcTable[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
|
||
|
||
uint32 UpdateCRC(const void *data, size_t size, UInt32 v) {
|
||
if (g_CrcTable[elements(g_CrcTable) - 1] == 0)
|
||
CrcGenerateTable();
|
||
|
||
static FARPROC f = LoadFromDLL("CrcUpdate");
|
||
if (f)
|
||
return ((uint32(__cdecl *)(uint32, const void *, uint, const uint32 *))f)(
|
||
v, data, size, g_CrcTable);
|
||
|
||
const Byte *p = (const Byte *)data;
|
||
#if defined(FREEARC_INTEL_BYTE_ORDER)
|
||
for (; size > 0 && ((unsigned)(ptrdiff_t)p & 3) != 0; size--, p++)
|
||
v = CRC_UPDATE_BYTE_2(v, *p);
|
||
for (; size >= 4; size -= 4, p += 4) {
|
||
v ^= *(const UInt32 *)p;
|
||
v = g_CrcTable[0x300 + (v & 0xFF)] ^ g_CrcTable[0x200 + ((v >> 8) & 0xFF)] ^
|
||
g_CrcTable[0x100 + ((v >> 16) & 0xFF)] ^
|
||
g_CrcTable[0x000 + ((v >> 24))];
|
||
}
|
||
#endif
|
||
for (; size > 0; size--, p++)
|
||
v = CRC_UPDATE_BYTE_2(v, *p);
|
||
return v;
|
||
}
|
||
|
||
// Вычислить CRC блока данных
|
||
uint32 CalcCRC(const void *Addr, size_t Size) {
|
||
return UpdateCRC(Addr, Size, INIT_CRC) ^ INIT_CRC;
|
||
}
|
||
|
||
#endif
|