BaseTools LzmaCompress: Update LZMA to new 19.00 version

[mirror_edk2.git] / BaseTools / Source / C / LzmaCompress / LzmaCompress.c

/** @file\r
  LZMA Compress/Decompress tool (LzmaCompress)\r
\r
  Based on LZMA SDK 19.00:\r
    LzmaUtil.c -- Test application for LZMA compression\r
    2019-02-21 : Igor Pavlov : Public domain\r
\r
  Copyright (c) 2006 - 2019, Intel Corporation. All rights reserved.<BR>\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#define _CRT_SECURE_NO_WARNINGS\r
\r
#include <stdio.h>\r
#include <stdlib.h>\r
#include <string.h>\r
\r
#include "Sdk/C/Alloc.h"\r
#include "Sdk/C/7zFile.h"\r
#include "Sdk/C/7zVersion.h"\r
#include "Sdk/C/LzmaDec.h"\r
#include "Sdk/C/LzmaEnc.h"\r
#include "Sdk/C/Bra.h"\r
#include "CommonLib.h"\r
#include "ParseInf.h"\r
\r
#define LZMA_HEADER_SIZE (LZMA_PROPS_SIZE + 8)\r
\r
typedef enum {\r
  NoConverter,\r
  X86Converter,\r
  MaxConverter\r
} CONVERTER_TYPE;\r
\r
const char *kCantReadMessage = "Can not read input file";\r
const char *kCantWriteMessage = "Can not write output file";\r
const char *kCantAllocateMessage = "Can not allocate memory";\r
const char *kDataErrorMessage = "Data error";\r
const char *kInvalidParamValMessage = "Invalid parameter value";\r
\r
static BoolInt mQuietMode = False;\r
static CONVERTER_TYPE mConType = NoConverter;\r
\r
UINT64 mDictionarySize = 28;\r
UINT64 mCompressionMode = 2;\r
\r
#define UTILITY_NAME "LzmaCompress"\r
#define UTILITY_MAJOR_VERSION 0\r
#define UTILITY_MINOR_VERSION 2\r
#define INTEL_COPYRIGHT \\r
  "Copyright (c) 2009-2018, Intel Corporation. All rights reserved."\r
void PrintHelp(char *buffer)\r
{\r
  strcat(buffer,\r
      "\n" UTILITY_NAME " - " INTEL_COPYRIGHT "\n"\r
      "Based on LZMA Utility " MY_VERSION_COPYRIGHT_DATE "\n"\r
      "\nUsage:  LzmaCompress -e|-d [options] <inputFile>\n"\r
             "  -e: encode file\n"\r
             "  -d: decode file\n"\r
             "  -o FileName, --output FileName: specify the output filename\n"\r
             "  --f86: enable converter for x86 code\n"\r
             "  -v, --verbose: increase output messages\n"\r
             "  -q, --quiet: reduce output messages\n"\r
             "  --debug [0-9]: set debug level\n"\r
             "  -a: set compression mode 0 = fast, 1 = normal, default: 1 (normal)\n"\r
             "  d: sets Dictionary size - [0, 27], default: 24 (16MB)\n"\r
             "  --version: display the program version and exit\n"\r
             "  -h, --help: display this help text\n"\r
             );\r
}\r
\r
int PrintError(char *buffer, const char *message)\r
{\r
  strcat(buffer, "\nError: ");\r
  strcat(buffer, message);\r
  strcat(buffer, "\n");\r
  return 1;\r
}\r
\r
int PrintErrorNumber(char *buffer, SRes val)\r
{\r
  sprintf(buffer + strlen(buffer), "\nError code: %x\n", (unsigned)val);\r
  return 1;\r
}\r
\r
int PrintUserError(char *buffer)\r
{\r
  return PrintError(buffer, "Incorrect command");\r
}\r
\r
void PrintVersion(char *buffer)\r
{\r
  sprintf (buffer, "%s Version %d.%d %s ", UTILITY_NAME, UTILITY_MAJOR_VERSION, UTILITY_MINOR_VERSION, __BUILD_VERSION);\r
}\r
\r
static SRes Encode(ISeqOutStream *outStream, ISeqInStream *inStream, UInt64 fileSize, CLzmaEncProps *props)\r
{\r
  SRes res;\r
  size_t inSize = (size_t)fileSize;\r
  Byte *inBuffer = 0;\r
  Byte *outBuffer = 0;\r
  Byte *filteredStream = 0;\r
  size_t outSize;\r
\r
  if (inSize != 0) {\r
    inBuffer = (Byte *)MyAlloc(inSize);\r
    if (inBuffer == 0)\r
      return SZ_ERROR_MEM;\r
  } else {\r
    return SZ_ERROR_INPUT_EOF;\r
  }\r
\r
  if (SeqInStream_Read(inStream, inBuffer, inSize) != SZ_OK) {\r
    res = SZ_ERROR_READ;\r
    goto Done;\r
  }\r
\r
  // we allocate 105% of original size + 64KB for output buffer\r
  outSize = (size_t)fileSize / 20 * 21 + (1 << 16);\r
  outBuffer = (Byte *)MyAlloc(outSize);\r
  if (outBuffer == 0) {\r
    res = SZ_ERROR_MEM;\r
    goto Done;\r
  }\r
\r
  {\r
    int i;\r
    for (i = 0; i < 8; i++)\r
      outBuffer[i + LZMA_PROPS_SIZE] = (Byte)(fileSize >> (8 * i));\r
  }\r
\r
  if (mConType != NoConverter)\r
  {\r
    filteredStream = (Byte *)MyAlloc(inSize);\r
    if (filteredStream == 0) {\r
      res = SZ_ERROR_MEM;\r
      goto Done;\r
    }\r
    memcpy(filteredStream, inBuffer, inSize);\r
\r
    if (mConType == X86Converter) {\r
      {\r
        UInt32 x86State;\r
        x86_Convert_Init(x86State);\r
        x86_Convert(filteredStream, (SizeT) inSize, 0, &x86State, 1);\r
      }\r
    }\r
  }\r
\r
  {\r
    size_t outSizeProcessed = outSize - LZMA_HEADER_SIZE;\r
    size_t outPropsSize = LZMA_PROPS_SIZE;\r
\r
    res = LzmaEncode(outBuffer + LZMA_HEADER_SIZE, &outSizeProcessed,\r
        mConType != NoConverter ? filteredStream : inBuffer, inSize,\r
        props, outBuffer, &outPropsSize, 0,\r
        NULL, &g_Alloc, &g_Alloc);\r
\r
    if (res != SZ_OK)\r
      goto Done;\r
\r
    outSize = LZMA_HEADER_SIZE + outSizeProcessed;\r
  }\r
\r
  if (outStream->Write(outStream, outBuffer, outSize) != outSize)\r
    res = SZ_ERROR_WRITE;\r
\r
Done:\r
  MyFree(outBuffer);\r
  MyFree(inBuffer);\r
  MyFree(filteredStream);\r
\r
  return res;\r
}\r
\r
static SRes Decode(ISeqOutStream *outStream, ISeqInStream *inStream, UInt64 fileSize)\r
{\r
  SRes res;\r
  size_t inSize = (size_t)fileSize;\r
  Byte *inBuffer = 0;\r
  Byte *outBuffer = 0;\r
  size_t outSize = 0;\r
  size_t inSizePure;\r
  ELzmaStatus status;\r
  UInt64 outSize64 = 0;\r
\r
  int i;\r
\r
  if (inSize < LZMA_HEADER_SIZE)\r
    return SZ_ERROR_INPUT_EOF;\r
\r
  inBuffer = (Byte *)MyAlloc(inSize);\r
  if (inBuffer == 0)\r
    return SZ_ERROR_MEM;\r
\r
  if (SeqInStream_Read(inStream, inBuffer, inSize) != SZ_OK) {\r
    res = SZ_ERROR_READ;\r
    goto Done;\r
  }\r
\r
  for (i = 0; i < 8; i++)\r
    outSize64 += ((UInt64)inBuffer[LZMA_PROPS_SIZE + i]) << (i * 8);\r
\r
  outSize = (size_t)outSize64;\r
  if (outSize != 0) {\r
    outBuffer = (Byte *)MyAlloc(outSize);\r
    if (outBuffer == 0) {\r
      res = SZ_ERROR_MEM;\r
      goto Done;\r
    }\r
  } else {\r
    res = SZ_OK;\r
    goto Done;\r
  }\r
\r
  inSizePure = inSize - LZMA_HEADER_SIZE;\r
  res = LzmaDecode(outBuffer, &outSize, inBuffer + LZMA_HEADER_SIZE, &inSizePure,\r
      inBuffer, LZMA_PROPS_SIZE, LZMA_FINISH_END, &status, &g_Alloc);\r
\r
  if (res != SZ_OK)\r
    goto Done;\r
\r
  if (mConType == X86Converter)\r
  {\r
    UInt32 x86State;\r
    x86_Convert_Init(x86State);\r
    x86_Convert(outBuffer, (SizeT) outSize, 0, &x86State, 0);\r
  }\r
\r
  if (outStream->Write(outStream, outBuffer, outSize) != outSize)\r
    res = SZ_ERROR_WRITE;\r
\r
Done:\r
  MyFree(outBuffer);\r
  MyFree(inBuffer);\r
\r
  return res;\r
}\r
\r
int main2(int numArgs, const char *args[], char *rs)\r
{\r
  CFileSeqInStream inStream;\r
  CFileOutStream outStream;\r
  int res;\r
  int encodeMode = 0;\r
  BoolInt modeWasSet = False;\r
  const char *inputFile = NULL;\r
  const char *outputFile = "file.tmp";\r
  int param;\r
  UInt64 fileSize;\r
  CLzmaEncProps props;\r
\r
  LzmaEncProps_Init(&props);\r
  LzmaEncProps_Normalize(&props);\r
\r
  FileSeqInStream_CreateVTable(&inStream);\r
  File_Construct(&inStream.file);\r
\r
  FileOutStream_CreateVTable(&outStream);\r
  File_Construct(&outStream.file);\r
\r
  if (numArgs == 1)\r
  {\r
    PrintHelp(rs);\r
    return 0;\r
  }\r
\r
  for (param = 1; param < numArgs; param++) {\r
    if (strcmp(args[param], "-e") == 0 || strcmp(args[param], "-d") == 0) {\r
      encodeMode = (args[param][1] == 'e');\r
      modeWasSet = True;\r
    } else if (strcmp(args[param], "--f86") == 0) {\r
      mConType = X86Converter;\r
    } else if (strcmp(args[param], "-o") == 0 ||\r
               strcmp(args[param], "--output") == 0) {\r
      if (numArgs < (param + 2)) {\r
        return PrintUserError(rs);\r
      }\r
      outputFile = args[++param];\r
    } else if (strcmp(args[param], "--debug") == 0) {\r
      if (numArgs < (param + 2)) {\r
        return PrintUserError(rs);\r
      }\r
      //\r
      // For now we silently ignore this parameter to achieve command line\r
      // parameter compatibility with other build tools.\r
      //\r
      param++;\r
    } else if (strcmp(args[param], "-a") == 0) {\r
      AsciiStringToUint64(args[param + 1],FALSE,&mCompressionMode);\r
      if ((mCompressionMode == 0)||(mCompressionMode == 1)){\r
        props.algo = (int)mCompressionMode;\r
        param++;\r
        continue;\r
      } else {\r
        return PrintError(rs, kInvalidParamValMessage);\r
      }\r
    } else if (strcmp(args[param], "d") == 0) {\r
      AsciiStringToUint64(args[param + 1],FALSE,&mDictionarySize);\r
      if (mDictionarySize <= 27) {\r
        if (mDictionarySize == 0) {\r
          props.dictSize = 0;\r
        } else {\r
          props.dictSize = (1 << mDictionarySize);\r
        }\r
        param++;\r
        continue;\r
      } else {\r
        return PrintError(rs, kInvalidParamValMessage);\r
      }\r
    } else if (\r
                strcmp(args[param], "-h") == 0 ||\r
                strcmp(args[param], "--help") == 0\r
              ) {\r
      PrintHelp(rs);\r
      return 0;\r
    } else if (\r
                strcmp(args[param], "-v") == 0 ||\r
                strcmp(args[param], "--verbose") == 0\r
              ) {\r
      //\r
      // For now we silently ignore this parameter to achieve command line\r
      // parameter compatibility with other build tools.\r
      //\r
    } else if (\r
                strcmp(args[param], "-q") == 0 ||\r
                strcmp(args[param], "--quiet") == 0\r
              ) {\r
      mQuietMode = True;\r
    } else if (strcmp(args[param], "--version") == 0) {\r
      PrintVersion(rs);\r
      return 0;\r
    } else if (inputFile == NULL) {\r
      inputFile = args[param];\r
    } else {\r
      return PrintUserError(rs);\r
    }\r
  }\r
\r
  if ((inputFile == NULL) || !modeWasSet) {\r
    return PrintUserError(rs);\r
  }\r
\r
  {\r
    size_t t4 = sizeof(UInt32);\r
    size_t t8 = sizeof(UInt64);\r
    if (t4 != 4 || t8 != 8)\r
      return PrintError(rs, "Incorrect UInt32 or UInt64");\r
  }\r
\r
  if (InFile_Open(&inStream.file, inputFile) != 0)\r
    return PrintError(rs, "Can not open input file");\r
\r
  if (OutFile_Open(&outStream.file, outputFile) != 0) {\r
    File_Close(&inStream.file);\r
    return PrintError(rs, "Can not open output file");\r
  }\r
\r
  File_GetLength(&inStream.file, &fileSize);\r
\r
  if (encodeMode)\r
  {\r
    if (!mQuietMode) {\r
      printf("Encoding\n");\r
    }\r
    res = Encode(&outStream.vt, &inStream.vt, fileSize, &props);\r
  }\r
  else\r
  {\r
    if (!mQuietMode) {\r
      printf("Decoding\n");\r
    }\r
    res = Decode(&outStream.vt, &inStream.vt, fileSize);\r
  }\r
\r
  File_Close(&outStream.file);\r
  File_Close(&inStream.file);\r
\r
  if (res != SZ_OK)\r
  {\r
    if (res == SZ_ERROR_MEM)\r
      return PrintError(rs, kCantAllocateMessage);\r
    else if (res == SZ_ERROR_DATA)\r
      return PrintError(rs, kDataErrorMessage);\r
    else if (res == SZ_ERROR_WRITE)\r
      return PrintError(rs, kCantWriteMessage);\r
    else if (res == SZ_ERROR_READ)\r
      return PrintError(rs, kCantReadMessage);\r
    return PrintErrorNumber(rs, res);\r
  }\r
  return 0;\r
}\r
\r
int MY_CDECL main(int numArgs, const char *args[])\r
{\r
  char rs[2000] = { 0 };\r
  int res = main2(numArgs, args, rs);\r
  if (strlen(rs) > 0) {\r
    puts(rs);\r
  }\r
  return res;\r
}\r