/* 

LzmaTest.c

Test application for LZMA Decoder

This file written and distributed to public domain by Igor Pavlov.

This file is part of LZMA SDK 4.26 (2005-08-05)

*/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "LzmaDecode.h"

const char *kCantReadMessage = "Can not read input file";

const char *kCantWriteMessage = "Can not write output file";

const char *kCantAllocateMessage = "Can not allocate memory";

size_t MyReadFile(FILE *file, void *data, size_t size)

{ 

  if (size == 0)

    return 0;

  return fread(data, 1, size, file); 

}

int MyReadFileAndCheck(FILE *file, void *data, size_t size)

  { return (MyReadFile(file, data, size) == size);} 

size_t MyWriteFile(FILE *file, const void *data, size_t size)

{ 

  if (size == 0)

    return 0;

  return fwrite(data, 1, size, file); 

}

int MyWriteFileAndCheck(FILE *file, const void *data, size_t size)

  { return (MyWriteFile(file, data, size) == size); }

#ifdef _LZMA_IN_CB

#define kInBufferSize (1 << 15)

typedef struct _CBuffer

{

  ILzmaInCallback InCallback;

  FILE *File;

  unsigned char Buffer[kInBufferSize];

} CBuffer;

int LzmaReadCompressed(void *object, const unsigned char **buffer, SizeT *size)

{

  CBuffer *b = (CBuffer *)object;

  *buffer = b->Buffer;

  *size = (SizeT)MyReadFile(b->File, b->Buffer, kInBufferSize);

  return LZMA_RESULT_OK;

}

CBuffer g_InBuffer;

#endif

#ifdef _LZMA_OUT_READ

#define kOutBufferSize (1 << 15)

unsigned char g_OutBuffer[kOutBufferSize];

#endif

int PrintError(char *buffer, const char *message)

{

  sprintf(buffer + strlen(buffer), "\nError: ");

  sprintf(buffer + strlen(buffer), message);

  return 1;

}

int main3(FILE *inFile, FILE *outFile, char *rs)

{

  /* We use two 32-bit integers to construct 64-bit integer for file size.

     You can remove outSizeHigh, if you don't need >= 4GB supporting,

     or you can use UInt64 outSize, if your compiler supports 64-bit integers*/

  UInt32 outSize = 0;

  UInt32 outSizeHigh = 0;

  #ifndef _LZMA_OUT_READ

  SizeT outSizeFull;

  unsigned char *outStream;

  #endif

  int waitEOS = 1; 

  /* waitEOS = 1, if there is no uncompressed size in headers, 

   so decoder will wait EOS (End of Stream Marker) in compressed stream */

  #ifndef _LZMA_IN_CB

  SizeT compressedSize;

  unsigned char *inStream;

  #endif

  CLzmaDecoderState state;  /* it's about 24-80 bytes structure, if int is 32-bit */

  unsigned char properties[LZMA_PROPERTIES_SIZE];

  int res;

  #ifdef _LZMA_IN_CB

  g_InBuffer.File = inFile;

  #endif

  if (sizeof(UInt32) < 4)

    return PrintError(rs, "LZMA decoder needs correct UInt32");

  #ifndef _LZMA_IN_CB

  {

    long length;

    fseek(inFile, 0, SEEK_END);

    length = ftell(inFile);

    fseek(inFile, 0, SEEK_SET);

    if ((long)(SizeT)length != length)

      return PrintError(rs, "Too big compressed stream");

    compressedSize = (SizeT)(length - (LZMA_PROPERTIES_SIZE + 8));

  }

  #endif

  /* Read LZMA properties for compressed stream */

  if (!MyReadFileAndCheck(inFile, properties, sizeof(properties)))

    return PrintError(rs, kCantReadMessage);

  /* Read uncompressed size */

  {

    int i;

    for (i = 0; i < 8; i++)

    {

      unsigned char b;

      if (!MyReadFileAndCheck(inFile, &b, 1))

        return PrintError(rs, kCantReadMessage);

      if (b != 0xFF)

        waitEOS = 0;

      if (i < 4)

        outSize += (UInt32)(b) << (i * 8);

      else

        outSizeHigh += (UInt32)(b) << ((i - 4) * 8);

    }

    #ifndef _LZMA_OUT_READ

    if (waitEOS)

      return PrintError(rs, "Stream with EOS marker is not supported");

    outSizeFull = (SizeT)outSize;

    if (sizeof(SizeT) >= 8)

      outSizeFull |= (((SizeT)outSizeHigh << 16) << 16);

    else if (outSizeHigh != 0 || (UInt32)(SizeT)outSize != outSize)

      return PrintError(rs, "Too big uncompressed stream");

    #endif

  }

  /* Decode LZMA properties and allocate memory */

  if (LzmaDecodeProperties(&state.Properties, properties, LZMA_PROPERTIES_SIZE) != LZMA_RESULT_OK)

    return PrintError(rs, "Incorrect stream properties");

  state.Probs = (CProb *)malloc(LzmaGetNumProbs(&state.Properties) * sizeof(CProb));

  #ifdef _LZMA_OUT_READ

  if (state.Properties.DictionarySize == 0)

    state.Dictionary = 0;

  else

    state.Dictionary = (unsigned char *)malloc(state.Properties.DictionarySize);

  #else

  if (outSizeFull == 0)

    outStream = 0;

  else

    outStream = (unsigned char *)malloc(outSizeFull);

  #endif

  #ifndef _LZMA_IN_CB

  if (compressedSize == 0)

    inStream = 0;

  else

    inStream = (unsigned char *)malloc(compressedSize);

  #endif

  if (state.Probs == 0 

    #ifdef _LZMA_OUT_READ

    || (state.Dictionary == 0 && state.Properties.DictionarySize != 0)

    #else

    || (outStream == 0 && outSizeFull != 0)

    #endif

    #ifndef _LZMA_IN_CB

    || (inStream == 0 && compressedSize != 0)

    #endif

    )

  {

    free(state.Probs);

    #ifdef _LZMA_OUT_READ

    free(state.Dictionary);

    #else

    free(outStream);

    #endif

    #ifndef _LZMA_IN_CB

    free(inStream);

    #endif

    return PrintError(rs, kCantAllocateMessage);

  }

  /* Decompress */

  #ifdef _LZMA_IN_CB

  g_InBuffer.InCallback.Read = LzmaReadCompressed;

  #else

  if (!MyReadFileAndCheck(inFile, inStream, compressedSize))

    return PrintError(rs, kCantReadMessage);

  #endif

  #ifdef _LZMA_OUT_READ

  {

    #ifndef _LZMA_IN_CB

    SizeT inAvail = compressedSize;

    const unsigned char *inBuffer = inStream;

    #endif

    LzmaDecoderInit(&state);

    do

    {

      #ifndef _LZMA_IN_CB

      SizeT inProcessed;

      #endif

      SizeT outProcessed;

      SizeT outAvail = kOutBufferSize;

      if (!waitEOS && outSizeHigh == 0 && outAvail > outSize)

        outAvail = (SizeT)outSize;

      res = LzmaDecode(&state,

        #ifdef _LZMA_IN_CB

        &g_InBuffer.InCallback,

        #else

        inBuffer, inAvail, &inProcessed,

        #endif

        g_OutBuffer, outAvail, &outProcessed);

      if (res != 0)

      {

        sprintf(rs + strlen(rs), "\nDecoding error = %d\n", res);

        res = 1;

        break;

      }

      #ifndef _LZMA_IN_CB

      inAvail -= inProcessed;

      inBuffer += inProcessed;

      #endif

      if (outFile != 0)  

        if (!MyWriteFileAndCheck(outFile, g_OutBuffer, (size_t)outProcessed))

        {

          PrintError(rs, kCantWriteMessage);

          res = 1;

          break;

        }

      if (outSize < outProcessed)

        outSizeHigh--;

      outSize -= (UInt32)outProcessed;

      outSize &= 0xFFFFFFFF;

      if (outProcessed == 0)

      {

        if (!waitEOS && (outSize != 0 || outSizeHigh != 0))

          res = 1;

        break;

      }

    }

    while ((outSize != 0 && outSizeHigh == 0) || outSizeHigh != 0  || waitEOS);

  }

  #else

  {

    #ifndef _LZMA_IN_CB

    SizeT inProcessed;

    #endif

    SizeT outProcessed;

    res = LzmaDecode(&state,

      #ifdef _LZMA_IN_CB

      &g_InBuffer.InCallback,

      #else

      inStream, compressedSize, &inProcessed,

      #endif

      outStream, outSizeFull, &outProcessed);

    if (res != 0)

    {

      sprintf(rs + strlen(rs), "\nDecoding error = %d\n", res);

      res = 1;

    }

    else if (outFile != 0)

    {

      if (!MyWriteFileAndCheck(outFile, outStream, (size_t)outProcessed))

      {

        PrintError(rs, kCantWriteMessage);

        res = 1;

      }

    }

  }

  #endif

  free(state.Probs);

  #ifdef _LZMA_OUT_READ

  free(state.Dictionary);

  #else

  free(outStream);

  #endif

  #ifndef _LZMA_IN_CB

  free(inStream);

  #endif

  return res;

}

int main2(int numArgs, const char *args[], char *rs)

{

  FILE *inFile = 0;

  FILE *outFile = 0;

  int res;

  sprintf(rs + strlen(rs), "\nLZMA Decoder 4.26 Copyright (c) 1999-2005 Igor Pavlov  2005-08-05\n");

  if (numArgs < 2 || numArgs > 3)

  {

    sprintf(rs + strlen(rs), "\nUsage:  lzmadec file.lzma [outFile]\n");

    return 1;

  }

  inFile = fopen(args[1], "rb");

  if (inFile == 0)

    return PrintError(rs, "Can not open input file");

  if (numArgs > 2)

  {

    outFile = fopen(args[2], "wb+");

    if (outFile == 0)

      return PrintError(rs, "Can not open output file");

  }

  res = main3(inFile, outFile, rs);

  if (outFile != 0)

    fclose(outFile);

  fclose(inFile);

  return res;

}

int main(int numArgs, const char *args[])

{

  char rs[800] = { 0 };

  int res = main2(numArgs, args, rs);

  printf(rs);

  return res;

}