mirror of
https://github.com/despawnerer/freearc
synced 2026-08-23 02:23:04 -04:00
1092 lines
58 KiB
C++
1092 lines
58 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
|