ruby-lzma 0.4.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/.gitignore +6 -0
- data/README.markdown +15 -0
- data/Rakefile +53 -0
- data/VERSION +1 -0
- data/ext/Alloc.cpp +118 -0
- data/ext/Alloc.h +29 -0
- data/ext/BinTree.h +55 -0
- data/ext/BinTree2.h +12 -0
- data/ext/BinTree3.h +16 -0
- data/ext/BinTree3Z.h +16 -0
- data/ext/BinTree4.h +18 -0
- data/ext/BinTree4b.h +20 -0
- data/ext/BinTreeMain.h +444 -0
- data/ext/BranchX86.c +101 -0
- data/ext/BranchX86.h +19 -0
- data/ext/CRC.cpp +61 -0
- data/ext/CRC.h +36 -0
- data/ext/C_FileIO.h +45 -0
- data/ext/CommandLineParser.h +82 -0
- data/ext/Defs.h +20 -0
- data/ext/FileStreams.h +98 -0
- data/ext/HC.h +55 -0
- data/ext/HC2.h +13 -0
- data/ext/HC3.h +17 -0
- data/ext/HC4.h +19 -0
- data/ext/HC4b.h +21 -0
- data/ext/HCMain.h +350 -0
- data/ext/ICoder.h +156 -0
- data/ext/IMatchFinder.h +63 -0
- data/ext/IStream.h +62 -0
- data/ext/InBuffer.cpp +80 -0
- data/ext/InBuffer.h +76 -0
- data/ext/LZInWindow.cpp +102 -0
- data/ext/LZInWindow.h +84 -0
- data/ext/LZMA.h +82 -0
- data/ext/LZMADecoder.h +248 -0
- data/ext/LZMAEncoder.cpp +1504 -0
- data/ext/LZMAEncoder.h +416 -0
- data/ext/LZOutWindow.cpp +17 -0
- data/ext/LZOutWindow.h +66 -0
- data/ext/LzmaBench.h +11 -0
- data/ext/LzmaDecode.c +588 -0
- data/ext/LzmaDecode.h +131 -0
- data/ext/LzmaRam.cpp +228 -0
- data/ext/LzmaRam.h +46 -0
- data/ext/LzmaRamDecode.c +79 -0
- data/ext/LzmaRamDecode.h +55 -0
- data/ext/MyCom.h +203 -0
- data/ext/MyGuidDef.h +54 -0
- data/ext/MyInitGuid.h +13 -0
- data/ext/MyString.h +631 -0
- data/ext/MyUnknown.h +24 -0
- data/ext/MyWindows.h +183 -0
- data/ext/OutBuffer.cpp +117 -0
- data/ext/OutBuffer.h +64 -0
- data/ext/Pat.h +318 -0
- data/ext/Pat2.h +22 -0
- data/ext/Pat2H.h +24 -0
- data/ext/Pat2R.h +20 -0
- data/ext/Pat3H.h +24 -0
- data/ext/Pat4H.h +24 -0
- data/ext/PatMain.h +989 -0
- data/ext/RangeCoder.h +205 -0
- data/ext/RangeCoderBit.cpp +80 -0
- data/ext/RangeCoderBit.h +120 -0
- data/ext/RangeCoderBitTree.h +161 -0
- data/ext/RangeCoderOpt.h +31 -0
- data/ext/StdAfx.h +8 -0
- data/ext/StreamUtils.cpp +44 -0
- data/ext/StreamUtils.h +11 -0
- data/ext/StringConvert.h +71 -0
- data/ext/StringToInt.h +17 -0
- data/ext/Types.h +19 -0
- data/ext/Vector.h +211 -0
- data/ext/extconf.rb +7 -0
- data/ext/lzma_ruby.cpp +51 -0
- data/ext/lzmalib.h +64 -0
- data/ext/mylib.cpp +81 -0
- data/java/SevenZip/CRC.java +52 -0
- data/java/SevenZip/Compression/LZ/BinTree.java +382 -0
- data/java/SevenZip/Compression/LZ/InWindow.java +131 -0
- data/java/SevenZip/Compression/LZ/OutWindow.java +85 -0
- data/java/SevenZip/Compression/LZMA/Base.java +88 -0
- data/java/SevenZip/Compression/LZMA/Decoder.java +329 -0
- data/java/SevenZip/Compression/LZMA/Encoder.java +1415 -0
- data/java/SevenZip/Compression/RangeCoder/BitTreeDecoder.java +55 -0
- data/java/SevenZip/Compression/RangeCoder/BitTreeEncoder.java +99 -0
- data/java/SevenZip/Compression/RangeCoder/Decoder.java +88 -0
- data/java/SevenZip/Compression/RangeCoder/Encoder.java +151 -0
- data/java/SevenZip/ICodeProgress.java +6 -0
- data/java/SevenZip/LzmaAlone.java +253 -0
- data/java/SevenZip/LzmaBench.java +391 -0
- data/java/com/ephemeronindustries/lzma/LZMA.java +104 -0
- data/lib/lzma.rb +32 -0
- data/ruby-lzma.gemspec +136 -0
- data/test/test_lzma.rb +42 -0
- metadata +157 -0
data/ext/LzmaDecode.h
ADDED
@@ -0,0 +1,131 @@
|
|
1
|
+
/*
|
2
|
+
LzmaDecode.h
|
3
|
+
LZMA Decoder interface
|
4
|
+
|
5
|
+
LZMA SDK 4.21 Copyright (c) 1999-2005 Igor Pavlov (2005-06-08)
|
6
|
+
http://www.7-zip.org/
|
7
|
+
|
8
|
+
LZMA SDK is licensed under two licenses:
|
9
|
+
1) GNU Lesser General Public License (GNU LGPL)
|
10
|
+
2) Common Public License (CPL)
|
11
|
+
It means that you can select one of these two licenses and
|
12
|
+
follow rules of that license.
|
13
|
+
|
14
|
+
SPECIAL EXCEPTION:
|
15
|
+
Igor Pavlov, as the author of this code, expressly permits you to
|
16
|
+
statically or dynamically link your code (or bind by name) to the
|
17
|
+
interfaces of this file without subjecting your linked code to the
|
18
|
+
terms of the CPL or GNU LGPL. Any modifications or additions
|
19
|
+
to this file, however, are subject to the LGPL or CPL terms.
|
20
|
+
*/
|
21
|
+
|
22
|
+
#ifndef __LZMADECODE_H
|
23
|
+
#define __LZMADECODE_H
|
24
|
+
|
25
|
+
/* #define _LZMA_IN_CB */
|
26
|
+
/* Use callback for input data */
|
27
|
+
|
28
|
+
/* #define _LZMA_OUT_READ */
|
29
|
+
/* Use read function for output data */
|
30
|
+
|
31
|
+
/* #define _LZMA_PROB32 */
|
32
|
+
/* It can increase speed on some 32-bit CPUs,
|
33
|
+
but memory usage will be doubled in that case */
|
34
|
+
|
35
|
+
/* #define _LZMA_LOC_OPT */
|
36
|
+
/* Enable local speed optimizations inside code */
|
37
|
+
|
38
|
+
/* #define _LZMA_SYSTEM_SIZE_T */
|
39
|
+
/* Use system's size_t. You can use it to enable 64-bit sizes supporting*/
|
40
|
+
|
41
|
+
#ifndef UInt32
|
42
|
+
#ifdef _LZMA_UINT32_IS_ULONG
|
43
|
+
#define UInt32 unsigned long
|
44
|
+
#else
|
45
|
+
#define UInt32 unsigned int
|
46
|
+
#endif
|
47
|
+
#endif
|
48
|
+
|
49
|
+
#ifndef SizeT
|
50
|
+
#ifdef _LZMA_SYSTEM_SIZE_T
|
51
|
+
#include <stddef.h>
|
52
|
+
#define SizeT size_t
|
53
|
+
#else
|
54
|
+
#define SizeT UInt32
|
55
|
+
#endif
|
56
|
+
#endif
|
57
|
+
|
58
|
+
#ifdef _LZMA_PROB32
|
59
|
+
#define CProb UInt32
|
60
|
+
#else
|
61
|
+
#define CProb unsigned short
|
62
|
+
#endif
|
63
|
+
|
64
|
+
#define LZMA_RESULT_OK 0
|
65
|
+
#define LZMA_RESULT_DATA_ERROR 1
|
66
|
+
|
67
|
+
#ifdef _LZMA_IN_CB
|
68
|
+
typedef struct _ILzmaInCallback
|
69
|
+
{
|
70
|
+
int (*Read)(void *object, const unsigned char **buffer, SizeT *bufferSize);
|
71
|
+
} ILzmaInCallback;
|
72
|
+
#endif
|
73
|
+
|
74
|
+
#define LZMA_BASE_SIZE 1846
|
75
|
+
#define LZMA_LIT_SIZE 768
|
76
|
+
|
77
|
+
#define LZMA_PROPERTIES_SIZE 5
|
78
|
+
|
79
|
+
typedef struct _CLzmaProperties
|
80
|
+
{
|
81
|
+
int lc;
|
82
|
+
int lp;
|
83
|
+
int pb;
|
84
|
+
#ifdef _LZMA_OUT_READ
|
85
|
+
UInt32 DictionarySize;
|
86
|
+
#endif
|
87
|
+
}CLzmaProperties;
|
88
|
+
|
89
|
+
int LzmaDecodeProperties(CLzmaProperties *propsRes, const unsigned char *propsData, int size);
|
90
|
+
|
91
|
+
#define LzmaGetNumProbs(Properties) (LZMA_BASE_SIZE + (LZMA_LIT_SIZE << ((Properties)->lc + (Properties)->lp)))
|
92
|
+
|
93
|
+
#define kLzmaNeedInitId (-2)
|
94
|
+
|
95
|
+
typedef struct _CLzmaDecoderState
|
96
|
+
{
|
97
|
+
CLzmaProperties Properties;
|
98
|
+
CProb *Probs;
|
99
|
+
|
100
|
+
#ifdef _LZMA_IN_CB
|
101
|
+
const unsigned char *Buffer;
|
102
|
+
const unsigned char *BufferLim;
|
103
|
+
#endif
|
104
|
+
|
105
|
+
#ifdef _LZMA_OUT_READ
|
106
|
+
unsigned char *Dictionary;
|
107
|
+
UInt32 Range;
|
108
|
+
UInt32 Code;
|
109
|
+
UInt32 DictionaryPos;
|
110
|
+
UInt32 GlobalPos;
|
111
|
+
UInt32 DistanceLimit;
|
112
|
+
UInt32 Reps[4];
|
113
|
+
int State;
|
114
|
+
int RemainLen;
|
115
|
+
unsigned char TempDictionary[4];
|
116
|
+
#endif
|
117
|
+
} CLzmaDecoderState;
|
118
|
+
|
119
|
+
#ifdef _LZMA_OUT_READ
|
120
|
+
#define LzmaDecoderInit(vs) { (vs)->RemainLen = kLzmaNeedInitId; }
|
121
|
+
#endif
|
122
|
+
|
123
|
+
int LzmaDecode(CLzmaDecoderState *vs,
|
124
|
+
#ifdef _LZMA_IN_CB
|
125
|
+
ILzmaInCallback *inCallback,
|
126
|
+
#else
|
127
|
+
const unsigned char *inStream, SizeT inSize, SizeT *inSizeProcessed,
|
128
|
+
#endif
|
129
|
+
unsigned char *outStream, SizeT outSize, SizeT *outSizeProcessed);
|
130
|
+
|
131
|
+
#endif
|
data/ext/LzmaRam.cpp
ADDED
@@ -0,0 +1,228 @@
|
|
1
|
+
// LzmaRam.cpp
|
2
|
+
|
3
|
+
#include "StdAfx.h"
|
4
|
+
#include "Types.h"
|
5
|
+
#include "LZMADecoder.h"
|
6
|
+
#include "LZMAEncoder.h"
|
7
|
+
#include "LzmaRam.h"
|
8
|
+
|
9
|
+
extern "C"
|
10
|
+
{
|
11
|
+
#include "BranchX86.h"
|
12
|
+
}
|
13
|
+
|
14
|
+
class CInStreamRam:
|
15
|
+
public ISequentialInStream,
|
16
|
+
public CMyUnknownImp
|
17
|
+
{
|
18
|
+
const Byte *Data;
|
19
|
+
size_t Size;
|
20
|
+
size_t Pos;
|
21
|
+
public:
|
22
|
+
MY_UNKNOWN_IMP
|
23
|
+
void Init(const Byte *data, size_t size)
|
24
|
+
{
|
25
|
+
Data = data;
|
26
|
+
Size = size;
|
27
|
+
Pos = 0;
|
28
|
+
}
|
29
|
+
STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
|
30
|
+
};
|
31
|
+
|
32
|
+
STDMETHODIMP CInStreamRam::Read(void *data, UInt32 size, UInt32 *processedSize)
|
33
|
+
{
|
34
|
+
UInt32 remain = Size - Pos;
|
35
|
+
if (size > remain)
|
36
|
+
size = remain;
|
37
|
+
for (UInt32 i = 0; i < size; i++)
|
38
|
+
((Byte *)data)[i] = Data[Pos + i];
|
39
|
+
Pos += size;
|
40
|
+
if(processedSize != NULL)
|
41
|
+
*processedSize = size;
|
42
|
+
return S_OK;
|
43
|
+
}
|
44
|
+
|
45
|
+
class COutStreamRam:
|
46
|
+
public ISequentialOutStream,
|
47
|
+
public CMyUnknownImp
|
48
|
+
{
|
49
|
+
size_t Size;
|
50
|
+
public:
|
51
|
+
Byte *Data;
|
52
|
+
size_t Pos;
|
53
|
+
bool Overflow;
|
54
|
+
void Init(Byte *data, size_t size)
|
55
|
+
{
|
56
|
+
Data = data;
|
57
|
+
Size = size;
|
58
|
+
Pos = 0;
|
59
|
+
Overflow = false;
|
60
|
+
}
|
61
|
+
void SetPos(size_t pos)
|
62
|
+
{
|
63
|
+
Overflow = false;
|
64
|
+
Pos = pos;
|
65
|
+
}
|
66
|
+
MY_UNKNOWN_IMP
|
67
|
+
HRESULT WriteByte(Byte b)
|
68
|
+
{
|
69
|
+
if (Pos >= Size)
|
70
|
+
{
|
71
|
+
Overflow = true;
|
72
|
+
return E_FAIL;
|
73
|
+
}
|
74
|
+
Data[Pos++] = b;
|
75
|
+
return S_OK;
|
76
|
+
}
|
77
|
+
STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
|
78
|
+
};
|
79
|
+
|
80
|
+
STDMETHODIMP COutStreamRam::Write(const void *data, UInt32 size, UInt32 *processedSize)
|
81
|
+
{
|
82
|
+
UInt32 i;
|
83
|
+
for (i = 0; i < size && Pos < Size; i++)
|
84
|
+
Data[Pos++] = ((const Byte *)data)[i];
|
85
|
+
if(processedSize != NULL)
|
86
|
+
*processedSize = i;
|
87
|
+
if (i != size)
|
88
|
+
{
|
89
|
+
Overflow = true;
|
90
|
+
return E_FAIL;
|
91
|
+
}
|
92
|
+
return S_OK;
|
93
|
+
}
|
94
|
+
|
95
|
+
#define SZE_FAIL (1)
|
96
|
+
#define SZE_OUTOFMEMORY (2)
|
97
|
+
#define SZE_OUT_OVERFLOW (3)
|
98
|
+
|
99
|
+
int LzmaRamEncode(
|
100
|
+
const Byte *inBuffer, size_t inSize,
|
101
|
+
Byte *outBuffer, size_t outSize, size_t *outSizeProcessed,
|
102
|
+
UInt32 dictionarySize, ESzFilterMode filterMode)
|
103
|
+
{
|
104
|
+
#ifndef _NO_EXCEPTIONS
|
105
|
+
try {
|
106
|
+
#endif
|
107
|
+
|
108
|
+
*outSizeProcessed = 0;
|
109
|
+
const size_t kIdSize = 0;
|
110
|
+
const size_t kLzmaPropsSize = 5;
|
111
|
+
const size_t kMinDestSize = kIdSize + kLzmaPropsSize + 8;
|
112
|
+
if (outSize < kMinDestSize)
|
113
|
+
return SZE_OUT_OVERFLOW;
|
114
|
+
NCompress::NLZMA::CEncoder *encoderSpec = new NCompress::NLZMA::CEncoder;
|
115
|
+
CMyComPtr<ICompressCoder> encoder = encoderSpec;
|
116
|
+
|
117
|
+
PROPID propIDs[] =
|
118
|
+
{
|
119
|
+
NCoderPropID::kAlgorithm,
|
120
|
+
NCoderPropID::kDictionarySize,
|
121
|
+
NCoderPropID::kNumFastBytes,
|
122
|
+
};
|
123
|
+
const int kNumProps = sizeof(propIDs) / sizeof(propIDs[0]);
|
124
|
+
PROPVARIANT properties[kNumProps];
|
125
|
+
properties[0].vt = VT_UI4;
|
126
|
+
properties[1].vt = VT_UI4;
|
127
|
+
properties[2].vt = VT_UI4;
|
128
|
+
properties[0].ulVal = (UInt32)2;
|
129
|
+
properties[1].ulVal = (UInt32)dictionarySize;
|
130
|
+
properties[2].ulVal = (UInt32)64;
|
131
|
+
|
132
|
+
if (encoderSpec->SetCoderProperties(propIDs, properties, kNumProps) != S_OK)
|
133
|
+
return 1;
|
134
|
+
|
135
|
+
COutStreamRam *outStreamSpec = new COutStreamRam;
|
136
|
+
if (outStreamSpec == 0)
|
137
|
+
return SZE_OUTOFMEMORY;
|
138
|
+
CMyComPtr<ISequentialOutStream> outStream = outStreamSpec;
|
139
|
+
CInStreamRam *inStreamSpec = new CInStreamRam;
|
140
|
+
if (inStreamSpec == 0)
|
141
|
+
return SZE_OUTOFMEMORY;
|
142
|
+
CMyComPtr<ISequentialInStream> inStream = inStreamSpec;
|
143
|
+
|
144
|
+
outStreamSpec->Init(outBuffer, outSize);
|
145
|
+
// if (outStreamSpec->WriteByte(0) != S_OK)
|
146
|
+
// return SZE_OUT_OVERFLOW;
|
147
|
+
|
148
|
+
if (encoderSpec->WriteCoderProperties(outStream) != S_OK)
|
149
|
+
return SZE_OUT_OVERFLOW;
|
150
|
+
if (outStreamSpec->Pos != kIdSize + kLzmaPropsSize)
|
151
|
+
return 1;
|
152
|
+
|
153
|
+
int i;
|
154
|
+
for (i = 0; i < 8; i++)
|
155
|
+
{
|
156
|
+
UInt64 t = (UInt64)(inSize);
|
157
|
+
if (outStreamSpec->WriteByte((Byte)((t) >> (8 * i))) != S_OK)
|
158
|
+
return SZE_OUT_OVERFLOW;
|
159
|
+
}
|
160
|
+
|
161
|
+
Byte *filteredStream = 0;
|
162
|
+
|
163
|
+
bool useFilter = (filterMode != SZ_FILTER_NO);
|
164
|
+
if (useFilter)
|
165
|
+
{
|
166
|
+
if (inSize != 0)
|
167
|
+
{
|
168
|
+
filteredStream = (Byte *)MyAlloc(inSize);
|
169
|
+
if (filteredStream == 0)
|
170
|
+
return SZE_OUTOFMEMORY;
|
171
|
+
memmove(filteredStream, inBuffer, inSize);
|
172
|
+
}
|
173
|
+
UInt32 _prevMask;
|
174
|
+
UInt32 _prevPos;
|
175
|
+
x86_Convert_Init(_prevMask, _prevPos);
|
176
|
+
x86_Convert(filteredStream, (UInt32)inSize, 0, &_prevMask, &_prevPos, 1);
|
177
|
+
}
|
178
|
+
|
179
|
+
UInt32 minSize = 0;
|
180
|
+
int numPasses = (filterMode == SZ_FILTER_AUTO) ? 3 : 1;
|
181
|
+
bool bestIsFiltered = false;
|
182
|
+
int mainResult = 0;
|
183
|
+
size_t startPos = outStreamSpec->Pos;
|
184
|
+
for (i = 0; i < numPasses; i++)
|
185
|
+
{
|
186
|
+
if (numPasses > 1 && i == numPasses - 1 && !bestIsFiltered)
|
187
|
+
break;
|
188
|
+
outStreamSpec->SetPos(startPos);
|
189
|
+
bool curModeIsFiltered = false;
|
190
|
+
if (useFilter && i == 0)
|
191
|
+
curModeIsFiltered = true;
|
192
|
+
if (numPasses > 1 && i == numPasses - 1)
|
193
|
+
curModeIsFiltered = true;
|
194
|
+
|
195
|
+
inStreamSpec->Init(curModeIsFiltered ? filteredStream : inBuffer, inSize);
|
196
|
+
|
197
|
+
HRESULT lzmaResult = encoder->Code(inStream, outStream, 0, 0, 0);
|
198
|
+
|
199
|
+
mainResult = 0;
|
200
|
+
if (lzmaResult == E_OUTOFMEMORY)
|
201
|
+
{
|
202
|
+
mainResult = SZE_OUTOFMEMORY;
|
203
|
+
break;
|
204
|
+
}
|
205
|
+
if (i == 0 || outStreamSpec->Pos <= minSize)
|
206
|
+
{
|
207
|
+
minSize = outStreamSpec->Pos;
|
208
|
+
bestIsFiltered = curModeIsFiltered;
|
209
|
+
}
|
210
|
+
if (outStreamSpec->Overflow)
|
211
|
+
mainResult = SZE_OUT_OVERFLOW;
|
212
|
+
else if (lzmaResult != S_OK)
|
213
|
+
{
|
214
|
+
mainResult = SZE_FAIL;
|
215
|
+
break;
|
216
|
+
}
|
217
|
+
}
|
218
|
+
*outSizeProcessed = outStreamSpec->Pos;
|
219
|
+
// if (bestIsFiltered)
|
220
|
+
// outBuffer[0] = 1;
|
221
|
+
if (useFilter)
|
222
|
+
MyFree(filteredStream);
|
223
|
+
return mainResult;
|
224
|
+
|
225
|
+
#ifndef _NO_EXCEPTIONS
|
226
|
+
} catch(...) { return SZE_OUTOFMEMORY; }
|
227
|
+
#endif
|
228
|
+
}
|
data/ext/LzmaRam.h
ADDED
@@ -0,0 +1,46 @@
|
|
1
|
+
// LzmaRam.h
|
2
|
+
|
3
|
+
#ifndef __LzmaRam_h
|
4
|
+
#define __LzmaRam_h
|
5
|
+
|
6
|
+
#include <stdlib.h>
|
7
|
+
#include "Types.h"
|
8
|
+
|
9
|
+
/*
|
10
|
+
LzmaRamEncode: BCJ + LZMA RAM->RAM compressing.
|
11
|
+
It uses .lzma format, but it writes one additional byte to .lzma file:
|
12
|
+
0: - no filter
|
13
|
+
1: - x86(BCJ) filter.
|
14
|
+
|
15
|
+
To provide best compression ratio dictionarySize mustbe >= inSize
|
16
|
+
|
17
|
+
LzmaRamEncode allocates Data with MyAlloc/BigAlloc functions.
|
18
|
+
RAM Requirements:
|
19
|
+
RamSize = dictionarySize * 9.5 + 6MB + FilterBlockSize
|
20
|
+
FilterBlockSize = 0, if useFilter == false
|
21
|
+
FilterBlockSize = inSize, if useFilter == true
|
22
|
+
|
23
|
+
Return code:
|
24
|
+
0 - OK
|
25
|
+
1 - Unspecified Error
|
26
|
+
2 - Memory allocating error
|
27
|
+
3 - Output buffer OVERFLOW
|
28
|
+
|
29
|
+
If you use SZ_FILTER_AUTO mode, then encoder will use 2 or 3 passes:
|
30
|
+
2 passes when FILTER_NO provides better compression.
|
31
|
+
3 passes when FILTER_YES provides better compression.
|
32
|
+
*/
|
33
|
+
|
34
|
+
enum ESzFilterMode
|
35
|
+
{
|
36
|
+
SZ_FILTER_NO,
|
37
|
+
SZ_FILTER_YES,
|
38
|
+
SZ_FILTER_AUTO
|
39
|
+
};
|
40
|
+
|
41
|
+
int LzmaRamEncode(
|
42
|
+
const Byte *inBuffer, size_t inSize,
|
43
|
+
Byte *outBuffer, size_t outSize, size_t *outSizeProcessed,
|
44
|
+
UInt32 dictionarySize, ESzFilterMode filterMode);
|
45
|
+
|
46
|
+
#endif
|
data/ext/LzmaRamDecode.c
ADDED
@@ -0,0 +1,79 @@
|
|
1
|
+
/* LzmaRamDecode.c */
|
2
|
+
|
3
|
+
#include "LzmaRamDecode.h"
|
4
|
+
#ifdef _SZ_ONE_DIRECTORY
|
5
|
+
#include "LzmaDecode.h"
|
6
|
+
#include "BranchX86.h"
|
7
|
+
#else
|
8
|
+
#include "LzmaDecode.h"
|
9
|
+
#include "BranchX86.h"
|
10
|
+
#endif
|
11
|
+
|
12
|
+
#define LZMA_PROPS_SIZE 13
|
13
|
+
#define LZMA_SIZE_OFFSET 5
|
14
|
+
|
15
|
+
int LzmaRamGetUncompressedSize(
|
16
|
+
const unsigned char *inBuffer,
|
17
|
+
size_t inSize,
|
18
|
+
size_t *outSize)
|
19
|
+
{
|
20
|
+
unsigned int i;
|
21
|
+
if (inSize < LZMA_PROPS_SIZE)
|
22
|
+
return 1;
|
23
|
+
*outSize = 0;
|
24
|
+
for(i = 0; i < sizeof(size_t); i++)
|
25
|
+
*outSize += ((size_t)inBuffer[LZMA_SIZE_OFFSET + i]) << (8 * i);
|
26
|
+
for(; i < 8; i++)
|
27
|
+
if (inBuffer[LZMA_SIZE_OFFSET + i] != 0)
|
28
|
+
return 1;
|
29
|
+
return 0;
|
30
|
+
}
|
31
|
+
|
32
|
+
#define SZE_DATA_ERROR (1)
|
33
|
+
#define SZE_OUTOFMEMORY (2)
|
34
|
+
|
35
|
+
int LzmaRamDecompress(
|
36
|
+
const unsigned char *inBuffer,
|
37
|
+
size_t inSize,
|
38
|
+
unsigned char *outBuffer,
|
39
|
+
size_t outSize,
|
40
|
+
size_t *outSizeProcessed,
|
41
|
+
void * (*allocFunc)(size_t size),
|
42
|
+
void (*freeFunc)(void *))
|
43
|
+
{
|
44
|
+
CLzmaDecoderState state; /* it's about 24 bytes structure, if int is 32-bit */
|
45
|
+
int result;
|
46
|
+
SizeT outSizeProcessedLoc;
|
47
|
+
SizeT inProcessed;
|
48
|
+
int useFilter = 0;
|
49
|
+
|
50
|
+
if (inSize < LZMA_PROPS_SIZE)
|
51
|
+
return 1;
|
52
|
+
// useFilter = inBuffer[0];
|
53
|
+
|
54
|
+
*outSizeProcessed = 0;
|
55
|
+
if (useFilter > 1)
|
56
|
+
return 1;
|
57
|
+
|
58
|
+
if (LzmaDecodeProperties(&state.Properties, inBuffer, LZMA_PROPERTIES_SIZE) != LZMA_RESULT_OK)
|
59
|
+
return 1;
|
60
|
+
state.Probs = (CProb *)allocFunc(LzmaGetNumProbs(&state.Properties) * sizeof(CProb));
|
61
|
+
if (state.Probs == 0)
|
62
|
+
return SZE_OUTOFMEMORY;
|
63
|
+
|
64
|
+
result = LzmaDecode(&state,
|
65
|
+
inBuffer + LZMA_PROPS_SIZE, (SizeT)inSize - LZMA_PROPS_SIZE, &inProcessed,
|
66
|
+
outBuffer, (SizeT)outSize, &outSizeProcessedLoc);
|
67
|
+
freeFunc(state.Probs);
|
68
|
+
if (result != LZMA_RESULT_OK)
|
69
|
+
return 1;
|
70
|
+
*outSizeProcessed = (size_t)outSizeProcessedLoc;
|
71
|
+
if (useFilter == 1)
|
72
|
+
{
|
73
|
+
UInt32 _prevMask;
|
74
|
+
UInt32 _prevPos;
|
75
|
+
x86_Convert_Init(_prevMask, _prevPos);
|
76
|
+
x86_Convert(outBuffer, (UInt32)outSizeProcessedLoc, 0, &_prevMask, &_prevPos, 0);
|
77
|
+
}
|
78
|
+
return 0;
|
79
|
+
}
|