Debian Codegraph @

utils/lzma/SRC/7zip/Compress/LZMA_Alone/LzmaRam.cpp

raw
1 // LzmaRam.cpp
2
3 #include "StdAfx.h"
4 #include "../../../Common/Types.h"
5 #include "../LZMA/LZMADecoder.h"
6 #include "../LZMA/LZMAEncoder.h"
7 #include "LzmaRam.h"
8
9 extern "C"
10 {
11 #include "../Branch/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 STDMETHOD(ReadPart)(void *data, UInt32 size, UInt32 *processedSize);
31 };
32
33 STDMETHODIMP CInStreamRam::Read(void *data, UInt32 size, UInt32 *processedSize)
34 {
35 UInt32 remain = Size - Pos;
36 if (size > remain)
37 size = remain;
38 for (UInt32 i = 0; i < size; i++)
39 {
40 ((Byte *)data)[i] = Data[Pos + i];
41 }
42 Pos += size;
43 if(processedSize != NULL)
44 *processedSize = size;
45 return S_OK;
46 }
47
48 STDMETHODIMP CInStreamRam::ReadPart(void *data, UInt32 size, UInt32 *processedSize)
49 {
50 return Read(data, size, processedSize);
51 }
52
53 class COutStreamRam:
54 public ISequentialOutStream,
55 public CMyUnknownImp
56 {
57 size_t Size;
58 public:
59 Byte *Data;
60 size_t Pos;
61 bool Overflow;
62 void Init(Byte *data, size_t size)
63 {
64 Data = data;
65 Size = size;
66 Pos = 0;
67 Overflow = false;
68 }
69 void SetPos(size_t pos)
70 {
71 Overflow = false;
72 Pos = pos;
73 }
74 MY_UNKNOWN_IMP
75 HRESULT WriteByte(Byte b)
76 {
77 if (Pos >= Size)
78 {
79 Overflow = true;
80 return E_FAIL;
81 }
82 Data[Pos++] = b;
83 return S_OK;
84 }
85 STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
86 STDMETHOD(WritePart)(const void *data, UInt32 size, UInt32 *processedSize);
87 };
88
89 STDMETHODIMP COutStreamRam::Write(const void *data, UInt32 size, UInt32 *processedSize)
90 {
91 UInt32 i;
92 for (i = 0; i < size && Pos < Size; i++)
93 Data[Pos++] = ((const Byte *)data)[i];
94 if(processedSize != NULL)
95 *processedSize = i;
96 if (i != size)
97 {
98 Overflow = true;
99 return E_FAIL;
100 }
101 return S_OK;
102 }
103
104 STDMETHODIMP COutStreamRam::WritePart(const void *data, UInt32 size, UInt32 *processedSize)
105 {
106 return Write(data, size, processedSize);
107 }
108
109 #define SZE_FAIL (1)
110 #define SZE_OUTOFMEMORY (2)
111 #define SZE_OUT_OVERFLOW (3)
112
113 int LzmaRamEncode(
114 const Byte *inBuffer, size_t inSize,
115 Byte *outBuffer, size_t outSize, size_t *outSizeProcessed,
116 UInt32 dictionarySize, ESzFilterMode filterMode)
117 {
118 #ifndef _NO_EXCEPTIONS
119 try {
120 #endif
121
122 *outSizeProcessed = 0;
123 const size_t kIdSize = 1;
124 const size_t kLzmaPropsSize = 5;
125 const size_t kMinDestSize = kIdSize + kLzmaPropsSize + 8;
126 if (outSize < kMinDestSize)
127 return SZE_OUT_OVERFLOW;
128 NCompress::NLZMA::CEncoder *encoderSpec = new NCompress::NLZMA::CEncoder;
129 CMyComPtr<ICompressCoder> encoder = encoderSpec;
130
131 PROPID propIDs[] =
132 {
133 NCoderPropID::kAlgorithm,
134 NCoderPropID::kDictionarySize,
135 NCoderPropID::kNumFastBytes,
136 };
137 const int kNumProps = sizeof(propIDs) / sizeof(propIDs[0]);
138 PROPVARIANT properties[kNumProps];
139 properties[0].vt = VT_UI4;
140 properties[1].vt = VT_UI4;
141 properties[2].vt = VT_UI4;
142 properties[0].ulVal = (UInt32)2;
143 properties[1].ulVal = (UInt32)dictionarySize;
144 properties[2].ulVal = (UInt32)64;
145
146 if (encoderSpec->SetCoderProperties(propIDs, properties, kNumProps) != S_OK)
147 return 1;
148
149 COutStreamRam *outStreamSpec = new COutStreamRam;
150 if (outStreamSpec == 0)
151 return SZE_OUTOFMEMORY;
152 CMyComPtr<ISequentialOutStream> outStream = outStreamSpec;
153 CInStreamRam *inStreamSpec = new CInStreamRam;
154 if (inStreamSpec == 0)
155 return SZE_OUTOFMEMORY;
156 CMyComPtr<ISequentialInStream> inStream = inStreamSpec;
157
158 outStreamSpec->Init(outBuffer, outSize);
159 if (outStreamSpec->WriteByte(0) != S_OK)
160 return SZE_OUT_OVERFLOW;
161
162 if (encoderSpec->WriteCoderProperties(outStream) != S_OK)
163 return SZE_OUT_OVERFLOW;
164 if (outStreamSpec->Pos != kIdSize + kLzmaPropsSize)
165 return 1;
166
167 int i;
168 for (i = 0; i < 8; i++)
169 {
170 UInt64 t = (UInt64)(inSize);
171 if (outStreamSpec->WriteByte((Byte)((t) >> (8 * i))) != S_OK)
172 return SZE_OUT_OVERFLOW;
173 }
174
175 Byte *filteredStream = 0;
176
177 bool useFilter = (filterMode != SZ_FILTER_NO);
178 if (useFilter)
179 {
180 if (inSize != 0)
181 {
182 filteredStream = (Byte *)MyAlloc(inSize);
183 if (filteredStream == 0)
184 return SZE_OUTOFMEMORY;
185 memmove(filteredStream, inBuffer, inSize);
186 }
187 UInt32 _prevMask;
188 UInt32 _prevPos;
189 x86_Convert_Init(_prevMask, _prevPos);
190 x86_Convert(filteredStream, (UInt32)inSize, 0, &_prevMask, &_prevPos, 1);
191 }
192
193 UInt32 minSize = 0;
194 int numPasses = (filterMode == SZ_FILTER_AUTO) ? 3 : 1;
195 bool bestIsFiltered = false;
196 int mainResult = 0;
197 size_t startPos = outStreamSpec->Pos;
198 for (i = 0; i < numPasses; i++)
199 {
200 if (numPasses > 1 && i == numPasses - 1 && !bestIsFiltered)
201 break;
202 outStreamSpec->SetPos(startPos);
203 bool curModeIsFiltered = false;
204 if (useFilter && i == 0)
205 curModeIsFiltered = true;
206 if (numPasses > 1 && i == numPasses - 1)
207 curModeIsFiltered = true;
208
209 inStreamSpec->Init(curModeIsFiltered ? filteredStream : inBuffer, inSize);
210
211 HRESULT lzmaResult = encoder->Code(inStream, outStream, 0, 0, 0);
212
213 mainResult = 0;
214 if (lzmaResult == E_OUTOFMEMORY)
215 {
216 mainResult = SZE_OUTOFMEMORY;
217 break;
218 }
219 if (i == 0 || outStreamSpec->Pos <= minSize)
220 {
221 minSize = outStreamSpec->Pos;
222 bestIsFiltered = curModeIsFiltered;
223 }
224 if (outStreamSpec->Overflow)
225 mainResult = SZE_OUT_OVERFLOW;
226 else if (lzmaResult != S_OK)
227 {
228 mainResult = SZE_FAIL;
229 break;
230 }
231 }
232 *outSizeProcessed = outStreamSpec->Pos;
233 if (bestIsFiltered)
234 outBuffer[0] = 1;
235 if (useFilter)
236 MyFree(filteredStream);
237 return mainResult;
238
239 #ifndef _NO_EXCEPTIONS
240 } catch(...) { return SZE_OUTOFMEMORY; }
241 #endif
242 }