mirror of
https://github.com/despawnerer/freearc
synced 2026-08-23 02:23:04 -04:00
5bd67eebc4
These are: - GUIs - Shell extensions - FAR plugin (lol) - Everything that has to do with supporting Windows - Installers et al. - Lua support Things still don't compile though, at least not with a modern toolchain, but the problems seem smaller than if I had tried to do the lot.
1092 lines
51 KiB
C++
Executable file
1092 lines
51 KiB
C++
Executable file
#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
|