release/src-rt-6.x.4708/tools/misc/lzma_src/C/LzmaUtil/LzmaUtil.c

   1 /* LzmaUtil.c -- Test application for LZMA compression
   2 2008-11-23 : Igor Pavlov : Public domain */
   3
   4 #define _CRT_SECURE_NO_WARNINGS
   5
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9
  10 #include "../Alloc.h"
  11 #include "../7zFile.h"
  12 #include "../7zVersion.h"
  13 #include "../LzmaDec.h"
  14 #include "../LzmaEnc.h"
  15
  16 const char *kCantReadMessage = "Can not read input file";
  17 const char *kCantWriteMessage = "Can not write output file";
  18 const char *kCantAllocateMessage = "Can not allocate memory";
  19 const char *kDataErrorMessage = "Data error";
  20
  21 static void *SzAlloc(void *p, size_t size) { p = p; return MyAlloc(size); }
  22 static void SzFree(void *p, void *address) { p = p; MyFree(address); }
  23 static ISzAlloc g_Alloc = { SzAlloc, SzFree };
  24
  25 void PrintHelp(char *buffer)
  26 {
  27   strcat(buffer, "\nLZMA Utility " MY_VERSION_COPYRIGHT_DATE "\n"
  28       "\nUsage:  lzma <e|d> inputFile outputFile\n"
  29              "  e: encode file\n"
  30              "  d: decode file\n");
  31 }
  32
  33 int PrintError(char *buffer, const char *message)
  34 {
  35   strcat(buffer, "\nError: ");
  36   strcat(buffer, message);
  37   strcat(buffer, "\n");
  38   return 1;
  39 }
  40
  41 int PrintErrorNumber(char *buffer, SRes val)
  42 {
  43   sprintf(buffer + strlen(buffer), "\nError code: %x\n", (unsigned)val);
  44   return 1;
  45 }
  46
  47 int PrintUserError(char *buffer)
  48 {
  49   return PrintError(buffer, "Incorrect command");
  50 }
  51
  52 #define IN_BUF_SIZE (1 << 16)
  53 #define OUT_BUF_SIZE (1 << 16)
  54
  55 static SRes Decode2(CLzmaDec *state, ISeqOutStream *outStream, ISeqInStream *inStream,
  56     UInt64 unpackSize)
  57 {
  58   int thereIsSize = (unpackSize != (UInt64)(Int64)-1);
  59   Byte inBuf[IN_BUF_SIZE];
  60   Byte outBuf[OUT_BUF_SIZE];
  61   size_t inPos = 0, inSize = 0, outPos = 0;
  62   LzmaDec_Init(state);
  63   for (;;)
  64   {
  65     if (inPos == inSize)
  66     {
  67       inSize = IN_BUF_SIZE;
  68       RINOK(inStream->Read(inStream, inBuf, &inSize));
  69       inPos = 0;
  70     }
  71     {
  72       SRes res;
  73       SizeT inProcessed = inSize - inPos;
  74       SizeT outProcessed = OUT_BUF_SIZE - outPos;
  75       ELzmaFinishMode finishMode = LZMA_FINISH_ANY;
  76       ELzmaStatus status;
  77       if (thereIsSize && outProcessed > unpackSize)
  78       {
  79         outProcessed = (SizeT)unpackSize;
  80         finishMode = LZMA_FINISH_END;
  81       }
  82
  83       res = LzmaDec_DecodeToBuf(state, outBuf + outPos, &outProcessed,
  84         inBuf + inPos, &inProcessed, finishMode, &status);
  85       inPos += inProcessed;
  86       outPos += outProcessed;
  87       unpackSize -= outProcessed;
  88
  89       if (outStream)
  90         if (outStream->Write(outStream, outBuf, outPos) != outPos)
  91           return SZ_ERROR_WRITE;
  92
  93       outPos = 0;
  94
  95       if (res != SZ_OK || thereIsSize && unpackSize == 0)
  96         return res;
  97
  98       if (inProcessed == 0 && outProcessed == 0)
  99       {
 100         if (thereIsSize || status != LZMA_STATUS_FINISHED_WITH_MARK)
 101           return SZ_ERROR_DATA;
 102         return res;
 103       }
 104     }
 105   }
 106 }
 107
 108 static SRes Decode(ISeqOutStream *outStream, ISeqInStream *inStream)
 109 {
 110   UInt64 unpackSize;
 111   int i;
 112   SRes res = 0;
 113
 114   CLzmaDec state;
 115
 116   /* header: 5 bytes of LZMA properties and 8 bytes of uncompressed size */
 117   unsigned char header[LZMA_PROPS_SIZE + 8];
 118
 119   /* Read and parse header */
 120
 121   RINOK(SeqInStream_Read(inStream, header, sizeof(header)));
 122
 123   unpackSize = 0;
 124   for (i = 0; i < 8; i++)
 125     unpackSize += (UInt64)header[LZMA_PROPS_SIZE + i] << (i * 8);
 126
 127   LzmaDec_Construct(&state);
 128   RINOK(LzmaDec_Allocate(&state, header, LZMA_PROPS_SIZE, &g_Alloc));
 129   res = Decode2(&state, outStream, inStream, unpackSize);
 130   LzmaDec_Free(&state, &g_Alloc);
 131   return res;
 132 }
 133
 134 static SRes Encode(ISeqOutStream *outStream, ISeqInStream *inStream, UInt64 fileSize, char *rs)
 135 {
 136   CLzmaEncHandle enc;
 137   SRes res;
 138   CLzmaEncProps props;
 139
 140   rs = rs;
 141
 142   enc = LzmaEnc_Create(&g_Alloc);
 143   if (enc == 0)
 144     return SZ_ERROR_MEM;
 145
 146   LzmaEncProps_Init(&props);
 147   res = LzmaEnc_SetProps(enc, &props);
 148
 149   if (res == SZ_OK)
 150   {
 151     Byte header[LZMA_PROPS_SIZE + 8];
 152     size_t headerSize = LZMA_PROPS_SIZE;
 153     int i;
 154
 155     res = LzmaEnc_WriteProperties(enc, header, &headerSize);
 156     for (i = 0; i < 8; i++)
 157       header[headerSize++] = (Byte)(fileSize >> (8 * i));
 158     if (outStream->Write(outStream, header, headerSize) != headerSize)
 159       res = SZ_ERROR_WRITE;
 160     else
 161     {
 162       if (res == SZ_OK)
 163         res = LzmaEnc_Encode(enc, outStream, inStream, NULL, &g_Alloc, &g_Alloc);
 164     }
 165   }
 166   LzmaEnc_Destroy(enc, &g_Alloc, &g_Alloc);
 167   return res;
 168 }
 169
 170 int main2(int numArgs, const char *args[], char *rs)
 171 {
 172   CFileSeqInStream inStream;
 173   CFileOutStream outStream;
 174   char c;
 175   int res;
 176   int encodeMode;
 177   Bool useOutFile = False;
 178
 179   FileSeqInStream_CreateVTable(&inStream);
 180   File_Construct(&inStream.file);
 181
 182   FileOutStream_CreateVTable(&outStream);
 183   File_Construct(&outStream.file);
 184
 185   if (numArgs == 1)
 186   {
 187     PrintHelp(rs);
 188     return 0;
 189   }
 190
 191   if (numArgs < 3 || numArgs > 4 || strlen(args[1]) != 1)
 192     return PrintUserError(rs);
 193
 194   c = args[1][0];
 195   encodeMode = (c == 'e' || c == 'E');
 196   if (!encodeMode && c != 'd' && c != 'D')
 197     return PrintUserError(rs);
 198
 199   {
 200     size_t t4 = sizeof(UInt32);
 201     size_t t8 = sizeof(UInt64);
 202     if (t4 != 4 || t8 != 8)
 203       return PrintError(rs, "Incorrect UInt32 or UInt64");
 204   }
 205
 206   if (InFile_Open(&inStream.file, args[2]) != 0)
 207     return PrintError(rs, "Can not open input file");
 208
 209   if (numArgs > 3)
 210   {
 211     useOutFile = True;
 212     if (OutFile_Open(&outStream.file, args[3]) != 0)
 213       return PrintError(rs, "Can not open output file");
 214   }
 215   else if (encodeMode)
 216     PrintUserError(rs);
 217
 218   if (encodeMode)
 219   {
 220     UInt64 fileSize;
 221     File_GetLength(&inStream.file, &fileSize);
 222     res = Encode(&outStream.s, &inStream.s, fileSize, rs);
 223   }
 224   else
 225   {
 226     res = Decode(&outStream.s, useOutFile ? &inStream.s : NULL);
 227   }
 228
 229   if (useOutFile)
 230     File_Close(&outStream.file);
 231   File_Close(&inStream.file);
 232
 233   if (res != SZ_OK)
 234   {
 235     if (res == SZ_ERROR_MEM)
 236       return PrintError(rs, kCantAllocateMessage);
 237     else if (res == SZ_ERROR_DATA)
 238       return PrintError(rs, kDataErrorMessage);
 239     else if (res == SZ_ERROR_WRITE)
 240       return PrintError(rs, kCantWriteMessage);
 241     else if (res == SZ_ERROR_READ)
 242       return PrintError(rs, kCantReadMessage);
 243     return PrintErrorNumber(rs, res);
 244   }
 245   return 0;
 246 }
 247
 248 int MY_CDECL main(int numArgs, const char *args[])
 249 {
 250   char rs[800] = { 0 };
 251   int res = main2(numArgs, args, rs);
 252   printf(rs);
 253   return res;
 254 }