Annotation of elwix/tools/oldlzma/SRC/7zip/Compress/LZMA_Alone/LzmaAlone.cpp, revision 1.1.1.1
1.1 misho 1: // LzmaAlone.cpp
2:
3: #include "StdAfx.h"
4:
5: #include "../../../Common/MyWindows.h"
6: #include "../../../Common/MyInitGuid.h"
7:
8: #include <stdio.h>
9:
10: #if defined(_WIN32) || defined(OS2) || defined(MSDOS)
11: #include <fcntl.h>
12: #include <io.h>
13: #define MY_SET_BINARY_MODE(file) setmode(fileno(file),O_BINARY)
14: #else
15: #define MY_SET_BINARY_MODE(file)
16: #endif
17:
18: #include "../../../Common/CommandLineParser.h"
19: #include "../../../Common/StringConvert.h"
20: #include "../../../Common/StringToInt.h"
21:
22: // #include "Windows/PropVariant.h"
23:
24: #include "../../Common/FileStreams.h"
25:
26: #include "../LZMA/LZMADecoder.h"
27: #include "../LZMA/LZMAEncoder.h"
28:
29: #include "LzmaBench.h"
30: #include "LzmaRam.h"
31:
32: extern "C"
33: {
34: #include "LzmaRamDecode.h"
35: }
36:
37: using namespace NCommandLineParser;
38:
39: namespace NKey {
40: enum Enum
41: {
42: kHelp1 = 0,
43: kHelp2,
44: kMode,
45: kDictionary,
46: kFastBytes,
47: kLitContext,
48: kLitPos,
49: kPosBits,
50: kMatchFinder,
51: kEOS,
52: kStdIn,
53: kStdOut,
54: kFilter86
55: };
56: }
57:
58: static const CSwitchForm kSwitchForms[] =
59: {
60: { L"?", NSwitchType::kSimple, false },
61: { L"H", NSwitchType::kSimple, false },
62: { L"A", NSwitchType::kUnLimitedPostString, false, 1 },
63: { L"D", NSwitchType::kUnLimitedPostString, false, 1 },
64: { L"FB", NSwitchType::kUnLimitedPostString, false, 1 },
65: { L"LC", NSwitchType::kUnLimitedPostString, false, 1 },
66: { L"LP", NSwitchType::kUnLimitedPostString, false, 1 },
67: { L"PB", NSwitchType::kUnLimitedPostString, false, 1 },
68: { L"MF", NSwitchType::kUnLimitedPostString, false, 1 },
69: { L"EOS", NSwitchType::kSimple, false },
70: { L"SI", NSwitchType::kSimple, false },
71: { L"SO", NSwitchType::kSimple, false },
72: { L"F86", NSwitchType::kSimple, false }
73: };
74:
75: static const int kNumSwitches = sizeof(kSwitchForms) / sizeof(kSwitchForms[0]);
76:
77: static void PrintHelp()
78: {
79: fprintf(stderr, "\nUsage: LZMA <e|d> inputFile outputFile [<switches>...]\n"
80: " e: encode file\n"
81: " d: decode file\n"
82: " b: Benchmark\n"
83: "<Switches>\n"
84: " -a{N}: set compression mode - [0, 2], default: 2 (max)\n"
85: " -d{N}: set dictionary - [0,28], default: 23 (8MB)\n"
86: " -fb{N}: set number of fast bytes - [5, 255], default: 128\n"
87: " -lc{N}: set number of literal context bits - [0, 8], default: 3\n"
88: " -lp{N}: set number of literal pos bits - [0, 4], default: 0\n"
89: " -pb{N}: set number of pos bits - [0, 4], default: 2\n"
90: " -mf{MF_ID}: set Match Finder: [bt2, bt3, bt4, bt4b, pat2r, pat2,\n"
91: " pat2h, pat3h, pat4h, hc3, hc4], default: bt4\n"
92: " -eos: write End Of Stream marker\n"
93: " -si: Read data from stdin\n"
94: " -so: Write data to stdout\n"
95: );
96: }
97:
98: static void PrintHelpAndExit(const char *s)
99: {
100: fprintf(stderr, "\nError: %s\n\n", s);
101: PrintHelp();
102: throw -1;
103: }
104:
105: static void IncorrectCommand()
106: {
107: PrintHelpAndExit("Incorrect command");
108: }
109:
110: static void WriteArgumentsToStringList(int numArguments, const char *arguments[],
111: UStringVector &strings)
112: {
113: for(int i = 1; i < numArguments; i++)
114: strings.Add(MultiByteToUnicodeString(arguments[i]));
115: }
116:
117: static bool GetNumber(const wchar_t *s, UInt32 &value)
118: {
119: value = 0;
120: if (MyStringLen(s) == 0)
121: return false;
122: const wchar_t *end;
123: UInt64 res = ConvertStringToUInt64(s, &end);
124: if (*end != L'\0')
125: return false;
126: if (res > 0xFFFFFFFF)
127: return false;
128: value = UInt32(res);
129: return true;
130: }
131:
132: int main2(int n, const char *args[])
133: {
134: fprintf(stderr, "\nLZMA 4.17 Copyright (c) 1999-2004 Igor Pavlov 2005-04-18\n");
135:
136: if (n == 1)
137: {
138: PrintHelp();
139: return 0;
140: }
141:
142: if (sizeof(Byte) != 1 || sizeof(UInt32) < 4 || sizeof(UInt64) < 4)
143: {
144: fprintf(stderr, "Unsupported base types. Edit Common/Types.h and recompile");
145: return 1;
146: }
147:
148: UStringVector commandStrings;
149: WriteArgumentsToStringList(n, args, commandStrings);
150: CParser parser(kNumSwitches);
151: try
152: {
153: parser.ParseStrings(kSwitchForms, commandStrings);
154: }
155: catch(...)
156: {
157: IncorrectCommand();
158: }
159:
160: if(parser[NKey::kHelp1].ThereIs || parser[NKey::kHelp2].ThereIs)
161: {
162: PrintHelp();
163: return 0;
164: }
165: const UStringVector &nonSwitchStrings = parser.NonSwitchStrings;
166:
167: int paramIndex = 0;
168: if (paramIndex >= nonSwitchStrings.Size())
169: IncorrectCommand();
170: const UString &command = nonSwitchStrings[paramIndex++];
171:
172: bool dictionaryIsDefined = false;
173: UInt32 dictionary = 1 << 21;
174: if(parser[NKey::kDictionary].ThereIs)
175: {
176: UInt32 dicLog;
177: if (!GetNumber(parser[NKey::kDictionary].PostStrings[0], dicLog))
178: IncorrectCommand();
179: dictionary = 1 << dicLog;
180: dictionaryIsDefined = true;
181: }
182: UString mf = L"BT4";
183: if (parser[NKey::kMatchFinder].ThereIs)
184: mf = parser[NKey::kMatchFinder].PostStrings[0];
185:
186: if (command.CompareNoCase(L"b") == 0)
187: {
188: const UInt32 kNumDefaultItereations = 10;
189: UInt32 numIterations = kNumDefaultItereations;
190: {
191: if (paramIndex < nonSwitchStrings.Size())
192: if (!GetNumber(nonSwitchStrings[paramIndex++], numIterations))
193: numIterations = kNumDefaultItereations;
194: }
195: return LzmaBenchmark(stderr, numIterations, dictionary,
196: mf.CompareNoCase(L"BT4") == 0);
197: }
198:
199: bool encodeMode = false;
200: if (command.CompareNoCase(L"e") == 0)
201: encodeMode = true;
202: else if (command.CompareNoCase(L"d") == 0)
203: encodeMode = false;
204: else
205: IncorrectCommand();
206:
207: bool stdInMode = parser[NKey::kStdIn].ThereIs;
208: bool stdOutMode = parser[NKey::kStdOut].ThereIs;
209:
210: CMyComPtr<ISequentialInStream> inStream;
211: CInFileStream *inStreamSpec = 0;
212: if (stdInMode)
213: {
214: inStream = new CStdInFileStream;
215: MY_SET_BINARY_MODE(stdin);
216: }
217: else
218: {
219: if (paramIndex >= nonSwitchStrings.Size())
220: IncorrectCommand();
221: const UString &inputName = nonSwitchStrings[paramIndex++];
222: inStreamSpec = new CInFileStream;
223: inStream = inStreamSpec;
224: if (!inStreamSpec->Open(GetSystemString(inputName)))
225: {
226: fprintf(stderr, "\nError: can not open input file %s\n",
227: (const char *)GetOemString(inputName));
228: return 1;
229: }
230: }
231:
232: CMyComPtr<ISequentialOutStream> outStream;
233: if (stdOutMode)
234: {
235: outStream = new CStdOutFileStream;
236: MY_SET_BINARY_MODE(stdout);
237: }
238: else
239: {
240: if (paramIndex >= nonSwitchStrings.Size())
241: IncorrectCommand();
242: const UString &outputName = nonSwitchStrings[paramIndex++];
243: COutFileStream *outStreamSpec = new COutFileStream;
244: outStream = outStreamSpec;
245: if (!outStreamSpec->Create(GetSystemString(outputName), true))
246: {
247: fprintf(stderr, "\nError: can not open output file %s\n",
248: (const char *)GetOemString(outputName));
249: return 1;
250: }
251: }
252:
253: if (parser[NKey::kFilter86].ThereIs)
254: {
255: // -f86 switch is for x86 filtered mode: BCJ + LZMA.
256: if (parser[NKey::kEOS].ThereIs || stdInMode)
257: throw "Can not use stdin in this mode";
258: UInt64 fileSize;
259: inStreamSpec->File.GetLength(fileSize);
260: if (fileSize > 0xF0000000)
261: throw "File is too big";
262: UInt32 inSize = (UInt32)fileSize;
263: Byte *inBuffer = (Byte *)MyAlloc((size_t)inSize);
264: if (inBuffer == 0)
265: throw "Can not allocate memory";
266:
267: UInt32 processedSize;
268: if (inStream->Read(inBuffer, (UInt32)inSize, &processedSize) != S_OK)
269: throw "Can not read";
270: if ((UInt32)inSize != processedSize)
271: throw "Read size error";
272:
273: Byte *outBuffer;
274: size_t outSizeProcessed;
275: if (encodeMode)
276: {
277: // we allocate 105% of original size for output buffer
278: size_t outSize = (size_t)fileSize / 20 * 21 + (1 << 16);
279: outBuffer = (Byte *)MyAlloc((size_t)outSize);
280: if (outBuffer == 0)
281: throw "Can not allocate memory";
282: if (!dictionaryIsDefined)
283: dictionary = 1 << 23;
284: int res = LzmaRamEncode(inBuffer, inSize, outBuffer, outSize, &outSizeProcessed,
285: dictionary, SZ_FILTER_AUTO);
286: if (res != 0)
287: {
288: fprintf(stderr, "\nEncoder error = %d\n", (int)res);
289: return 1;
290: }
291: }
292: else
293: {
294: size_t outSize;
295: if (LzmaRamGetUncompressedSize(inBuffer, inSize, &outSize) != 0)
296: throw "data error";
297: outBuffer = (Byte *)MyAlloc(outSize);
298: if (outBuffer == 0)
299: throw "Can not allocate memory";
300:
301: int res = LzmaRamDecompress(inBuffer, inSize, outBuffer, outSize, &outSizeProcessed, malloc, free);
302: if (res != 0)
303: throw "LzmaDecoder error";
304: }
305: if (outStream->Write(outBuffer, (UInt32)outSizeProcessed, &processedSize) != S_OK)
306: throw "Can not write";
307: MyFree(outBuffer);
308: MyFree(inBuffer);
309: return 0;
310: }
311:
312:
313: UInt64 fileSize;
314: if (encodeMode)
315: {
316: NCompress::NLZMA::CEncoder *encoderSpec =
317: new NCompress::NLZMA::CEncoder;
318: CMyComPtr<ICompressCoder> encoder = encoderSpec;
319:
320: if (!dictionaryIsDefined)
321: dictionary = 1 << 23;
322:
323: UInt32 posStateBits = 2;
324: UInt32 litContextBits = 3; // for normal files
325: // UInt32 litContextBits = 0; // for 32-bit data
326: UInt32 litPosBits = 0;
327: // UInt32 litPosBits = 2; // for 32-bit data
328: UInt32 algorithm = 2;
329: UInt32 numFastBytes = 128;
330:
331: bool eos = parser[NKey::kEOS].ThereIs || stdInMode;
332:
333: if(parser[NKey::kMode].ThereIs)
334: if (!GetNumber(parser[NKey::kMode].PostStrings[0], algorithm))
335: IncorrectCommand();
336:
337: if(parser[NKey::kFastBytes].ThereIs)
338: if (!GetNumber(parser[NKey::kFastBytes].PostStrings[0], numFastBytes))
339: IncorrectCommand();
340: if(parser[NKey::kLitContext].ThereIs)
341: if (!GetNumber(parser[NKey::kLitContext].PostStrings[0], litContextBits))
342: IncorrectCommand();
343: if(parser[NKey::kLitPos].ThereIs)
344: if (!GetNumber(parser[NKey::kLitPos].PostStrings[0], litPosBits))
345: IncorrectCommand();
346: if(parser[NKey::kPosBits].ThereIs)
347: if (!GetNumber(parser[NKey::kPosBits].PostStrings[0], posStateBits))
348: IncorrectCommand();
349:
350: PROPID propIDs[] =
351: {
352: NCoderPropID::kDictionarySize,
353: NCoderPropID::kPosStateBits,
354: NCoderPropID::kLitContextBits,
355: NCoderPropID::kLitPosBits,
356: NCoderPropID::kAlgorithm,
357: NCoderPropID::kNumFastBytes,
358: NCoderPropID::kMatchFinder,
359: NCoderPropID::kEndMarker
360: };
361: const int kNumProps = sizeof(propIDs) / sizeof(propIDs[0]);
362: /*
363: NWindows::NCOM::CPropVariant properties[kNumProps];
364: properties[0] = UInt32(dictionary);
365: properties[1] = UInt32(posStateBits);
366: properties[2] = UInt32(litContextBits);
367:
368: properties[3] = UInt32(litPosBits);
369: properties[4] = UInt32(algorithm);
370: properties[5] = UInt32(numFastBytes);
371: properties[6] = mf;
372: properties[7] = eos;
373: */
374: PROPVARIANT properties[kNumProps];
375: for (int p = 0; p < 6; p++)
376: properties[p].vt = VT_UI4;
377: properties[0].ulVal = UInt32(dictionary);
378: properties[1].ulVal = UInt32(posStateBits);
379: properties[2].ulVal = UInt32(litContextBits);
380: properties[3].ulVal = UInt32(litPosBits);
381: properties[4].ulVal = UInt32(algorithm);
382: properties[5].ulVal = UInt32(numFastBytes);
383:
384: properties[6].vt = VT_BSTR;
385: properties[6].bstrVal = (BSTR)(const wchar_t *)mf;
386:
387: properties[7].vt = VT_BOOL;
388: properties[7].boolVal = eos ? VARIANT_TRUE : VARIANT_FALSE;
389:
390: if (encoderSpec->SetCoderProperties(propIDs, properties, kNumProps) != S_OK)
391: IncorrectCommand();
392: encoderSpec->WriteCoderProperties(outStream);
393:
394: if (eos || stdInMode)
395: fileSize = (UInt64)(Int64)-1;
396: else
397: inStreamSpec->File.GetLength(fileSize);
398:
399: for (int i = 0; i < 8; i++)
400: {
401: Byte b = Byte(fileSize >> (8 * i));
402: if (outStream->Write(&b, sizeof(b), 0) != S_OK)
403: {
404: fprintf(stderr, "Write error");
405: return 1;
406: }
407: }
408: HRESULT result = encoder->Code(inStream, outStream, 0, 0, 0);
409: if (result == E_OUTOFMEMORY)
410: {
411: fprintf(stderr, "\nError: Can not allocate memory\n");
412: return 1;
413: }
414: else if (result != S_OK)
415: {
416: fprintf(stderr, "\nEncoder error = %X\n", (unsigned int)result);
417: return 1;
418: }
419: }
420: else
421: {
422: NCompress::NLZMA::CDecoder *decoderSpec =
423: new NCompress::NLZMA::CDecoder;
424: CMyComPtr<ICompressCoder> decoder = decoderSpec;
425: const UInt32 kPropertiesSize = 5;
426: Byte properties[kPropertiesSize];
427: UInt32 processedSize;
428: if (inStream->Read(properties, kPropertiesSize, &processedSize) != S_OK)
429: {
430: fprintf(stderr, "Read error");
431: return 1;
432: }
433: if (processedSize != kPropertiesSize)
434: {
435: fprintf(stderr, "Read error");
436: return 1;
437: }
438: if (decoderSpec->SetDecoderProperties2(properties, kPropertiesSize) != S_OK)
439: {
440: fprintf(stderr, "SetDecoderProperties error");
441: return 1;
442: }
443: fileSize = 0;
444: for (int i = 0; i < 8; i++)
445: {
446: Byte b;
447: if (inStream->Read(&b, sizeof(b), &processedSize) != S_OK)
448: {
449: fprintf(stderr, "Read error");
450: return 1;
451: }
452: if (processedSize != 1)
453: {
454: fprintf(stderr, "Read error");
455: return 1;
456: }
457: fileSize |= ((UInt64)b) << (8 * i);
458: }
459: if (decoder->Code(inStream, outStream, 0, &fileSize, 0) != S_OK)
460: {
461: fprintf(stderr, "Decoder error");
462: return 1;
463: }
464: }
465: return 0;
466: }
467:
468: int main(int n, const char *args[])
469: {
470: try { return main2(n, args); }
471: catch(const char *s)
472: {
473: fprintf(stderr, "\nError: %s\n", s);
474: return 1;
475: }
476: catch(...)
477: {
478: fprintf(stderr, "\nError\n");
479: return 1;
480: }
481: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to LzmaAlone.cpp CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / elwix / tools / oldlzma / SRC / 7zip / Compress / LZMA_Alone