Merge pull request #461 from negativeExponent/libchdr

[pcsx_rearmed.git] / deps / lzma-16.04 / C / Xz.h

/* Xz.h - Xz interface\r
2015-05-01 : Igor Pavlov : Public domain */\r
\r
#ifndef __XZ_H\r
#define __XZ_H\r
\r
#include "Sha256.h"\r
\r
EXTERN_C_BEGIN\r
\r
#define XZ_ID_Subblock 1\r
#define XZ_ID_Delta 3\r
#define XZ_ID_X86 4\r
#define XZ_ID_PPC 5\r
#define XZ_ID_IA64 6\r
#define XZ_ID_ARM 7\r
#define XZ_ID_ARMT 8\r
#define XZ_ID_SPARC 9\r
#define XZ_ID_LZMA2 0x21\r
\r
unsigned Xz_ReadVarInt(const Byte *p, size_t maxSize, UInt64 *value);\r
unsigned Xz_WriteVarInt(Byte *buf, UInt64 v);\r
\r
/* ---------- xz block ---------- */\r
\r
#define XZ_BLOCK_HEADER_SIZE_MAX 1024\r
\r
#define XZ_NUM_FILTERS_MAX 4\r
#define XZ_BF_NUM_FILTERS_MASK 3\r
#define XZ_BF_PACK_SIZE (1 << 6)\r
#define XZ_BF_UNPACK_SIZE (1 << 7)\r
\r
#define XZ_FILTER_PROPS_SIZE_MAX 20\r
\r
typedef struct\r
{\r
  UInt64 id;\r
  UInt32 propsSize;\r
  Byte props[XZ_FILTER_PROPS_SIZE_MAX];\r
} CXzFilter;\r
\r
typedef struct\r
{\r
  UInt64 packSize;\r
  UInt64 unpackSize;\r
  Byte flags;\r
  CXzFilter filters[XZ_NUM_FILTERS_MAX];\r
} CXzBlock;\r
\r
#define XzBlock_GetNumFilters(p) (((p)->flags & XZ_BF_NUM_FILTERS_MASK) + 1)\r
#define XzBlock_HasPackSize(p)   (((p)->flags & XZ_BF_PACK_SIZE) != 0)\r
#define XzBlock_HasUnpackSize(p) (((p)->flags & XZ_BF_UNPACK_SIZE) != 0)\r
\r
SRes XzBlock_Parse(CXzBlock *p, const Byte *header);\r
SRes XzBlock_ReadHeader(CXzBlock *p, ISeqInStream *inStream, Bool *isIndex, UInt32 *headerSizeRes);\r
\r
/* ---------- xz stream ---------- */\r
\r
#define XZ_SIG_SIZE 6\r
#define XZ_FOOTER_SIG_SIZE 2\r
\r
extern const Byte XZ_SIG[XZ_SIG_SIZE];\r
extern const Byte XZ_FOOTER_SIG[XZ_FOOTER_SIG_SIZE];\r
\r
#define XZ_STREAM_FLAGS_SIZE 2\r
#define XZ_STREAM_CRC_SIZE 4\r
\r
#define XZ_STREAM_HEADER_SIZE (XZ_SIG_SIZE + XZ_STREAM_FLAGS_SIZE + XZ_STREAM_CRC_SIZE)\r
#define XZ_STREAM_FOOTER_SIZE (XZ_FOOTER_SIG_SIZE + XZ_STREAM_FLAGS_SIZE + XZ_STREAM_CRC_SIZE + 4)\r
\r
#define XZ_CHECK_MASK 0xF\r
#define XZ_CHECK_NO 0\r
#define XZ_CHECK_CRC32 1\r
#define XZ_CHECK_CRC64 4\r
#define XZ_CHECK_SHA256 10\r
\r
typedef struct\r
{\r
  unsigned mode;\r
  UInt32 crc;\r
  UInt64 crc64;\r
  CSha256 sha;\r
} CXzCheck;\r
\r
void XzCheck_Init(CXzCheck *p, unsigned mode);\r
void XzCheck_Update(CXzCheck *p, const void *data, size_t size);\r
int XzCheck_Final(CXzCheck *p, Byte *digest);\r
\r
typedef UInt16 CXzStreamFlags;\r
\r
#define XzFlags_IsSupported(f) ((f) <= XZ_CHECK_MASK)\r
#define XzFlags_GetCheckType(f) ((f) & XZ_CHECK_MASK)\r
#define XzFlags_HasDataCrc32(f) (Xz_GetCheckType(f) == XZ_CHECK_CRC32)\r
unsigned XzFlags_GetCheckSize(CXzStreamFlags f);\r
\r
SRes Xz_ParseHeader(CXzStreamFlags *p, const Byte *buf);\r
SRes Xz_ReadHeader(CXzStreamFlags *p, ISeqInStream *inStream);\r
\r
typedef struct\r
{\r
  UInt64 unpackSize;\r
  UInt64 totalSize;\r
} CXzBlockSizes;\r
\r
typedef struct\r
{\r
  CXzStreamFlags flags;\r
  size_t numBlocks;\r
  size_t numBlocksAllocated;\r
  CXzBlockSizes *blocks;\r
  UInt64 startOffset;\r
} CXzStream;\r
\r
void Xz_Construct(CXzStream *p);\r
void Xz_Free(CXzStream *p, ISzAlloc *alloc);\r
\r
#define XZ_SIZE_OVERFLOW ((UInt64)(Int64)-1)\r
\r
UInt64 Xz_GetUnpackSize(const CXzStream *p);\r
UInt64 Xz_GetPackSize(const CXzStream *p);\r
\r
typedef struct\r
{\r
  size_t num;\r
  size_t numAllocated;\r
  CXzStream *streams;\r
} CXzs;\r
\r
void Xzs_Construct(CXzs *p);\r
void Xzs_Free(CXzs *p, ISzAlloc *alloc);\r
SRes Xzs_ReadBackward(CXzs *p, ILookInStream *inStream, Int64 *startOffset, ICompressProgress *progress, ISzAlloc *alloc);\r
\r
UInt64 Xzs_GetNumBlocks(const CXzs *p);\r
UInt64 Xzs_GetUnpackSize(const CXzs *p);\r
\r
typedef enum\r
{\r
  CODER_STATUS_NOT_SPECIFIED,               /* use main error code instead */\r
  CODER_STATUS_FINISHED_WITH_MARK,          /* stream was finished with end mark. */\r
  CODER_STATUS_NOT_FINISHED,                /* stream was not finished */\r
  CODER_STATUS_NEEDS_MORE_INPUT             /* you must provide more input bytes */\r
} ECoderStatus;\r
\r
typedef enum\r
{\r
  CODER_FINISH_ANY,   /* finish at any point */\r
  CODER_FINISH_END    /* block must be finished at the end */\r
} ECoderFinishMode;\r
\r
typedef struct _IStateCoder\r
{\r
  void *p;\r
  void (*Free)(void *p, ISzAlloc *alloc);\r
  SRes (*SetProps)(void *p, const Byte *props, size_t propSize, ISzAlloc *alloc);\r
  void (*Init)(void *p);\r
  SRes (*Code)(void *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,\r
      int srcWasFinished, ECoderFinishMode finishMode, int *wasFinished);\r
} IStateCoder;\r
\r
#define MIXCODER_NUM_FILTERS_MAX 4\r
\r
typedef struct\r
{\r
  ISzAlloc *alloc;\r
  Byte *buf;\r
  unsigned numCoders;\r
  int finished[MIXCODER_NUM_FILTERS_MAX - 1];\r
  size_t pos[MIXCODER_NUM_FILTERS_MAX - 1];\r
  size_t size[MIXCODER_NUM_FILTERS_MAX - 1];\r
  UInt64 ids[MIXCODER_NUM_FILTERS_MAX];\r
  IStateCoder coders[MIXCODER_NUM_FILTERS_MAX];\r
} CMixCoder;\r
\r
void MixCoder_Construct(CMixCoder *p, ISzAlloc *alloc);\r
void MixCoder_Free(CMixCoder *p);\r
void MixCoder_Init(CMixCoder *p);\r
SRes MixCoder_SetFromMethod(CMixCoder *p, unsigned coderIndex, UInt64 methodId);\r
SRes MixCoder_Code(CMixCoder *p, Byte *dest, SizeT *destLen,\r
    const Byte *src, SizeT *srcLen, int srcWasFinished,\r
    ECoderFinishMode finishMode, ECoderStatus *status);\r
\r
typedef enum\r
{\r
  XZ_STATE_STREAM_HEADER,\r
  XZ_STATE_STREAM_INDEX,\r
  XZ_STATE_STREAM_INDEX_CRC,\r
  XZ_STATE_STREAM_FOOTER,\r
  XZ_STATE_STREAM_PADDING,\r
  XZ_STATE_BLOCK_HEADER,\r
  XZ_STATE_BLOCK,\r
  XZ_STATE_BLOCK_FOOTER\r
} EXzState;\r
\r
typedef struct\r
{\r
  EXzState state;\r
  UInt32 pos;\r
  unsigned alignPos;\r
  unsigned indexPreSize;\r
\r
  CXzStreamFlags streamFlags;\r
  \r
  UInt32 blockHeaderSize;\r
  UInt64 packSize;\r
  UInt64 unpackSize;\r
\r
  UInt64 numBlocks;\r
  UInt64 indexSize;\r
  UInt64 indexPos;\r
  UInt64 padSize;\r
\r
  UInt64 numStartedStreams;\r
  UInt64 numFinishedStreams;\r
  UInt64 numTotalBlocks;\r
\r
  UInt32 crc;\r
  CMixCoder decoder;\r
  CXzBlock block;\r
  CXzCheck check;\r
  CSha256 sha;\r
  Byte shaDigest[SHA256_DIGEST_SIZE];\r
  Byte buf[XZ_BLOCK_HEADER_SIZE_MAX];\r
} CXzUnpacker;\r
\r
void XzUnpacker_Construct(CXzUnpacker *p, ISzAlloc *alloc);\r
void XzUnpacker_Init(CXzUnpacker *p);\r
void XzUnpacker_Free(CXzUnpacker *p);\r
\r
/*\r
finishMode:\r
  It has meaning only if the decoding reaches output limit (*destLen).\r
  CODER_FINISH_ANY - use smallest number of input bytes\r
  CODER_FINISH_END - read EndOfStream marker after decoding\r
\r
Returns:\r
  SZ_OK\r
    status:\r
      CODER_STATUS_NOT_FINISHED,\r
      CODER_STATUS_NEEDS_MORE_INPUT - maybe there are more xz streams,\r
                                      call XzUnpacker_IsStreamWasFinished to check that current stream was finished\r
  SZ_ERROR_MEM  - Memory allocation error\r
  SZ_ERROR_DATA - Data error\r
  SZ_ERROR_UNSUPPORTED - Unsupported method or method properties\r
  SZ_ERROR_CRC  - CRC error\r
  // SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).\r
\r
  SZ_ERROR_NO_ARCHIVE - the error with xz Stream Header with one of the following reasons:\r
     - xz Stream Signature failure\r
     - CRC32 of xz Stream Header is failed\r
     - The size of Stream padding is not multiple of four bytes.\r
    It's possible to get that error, if xz stream was finished and the stream\r
    contains some another data. In that case you can call XzUnpacker_GetExtraSize()\r
    function to get real size of xz stream.\r
*/\r
\r
\r
SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,\r
    const Byte *src, SizeT *srcLen, ECoderFinishMode finishMode,\r
    ECoderStatus *status);\r
\r
Bool XzUnpacker_IsStreamWasFinished(CXzUnpacker *p);\r
\r
/*\r
Call XzUnpacker_GetExtraSize after XzUnpacker_Code function to detect real size of\r
xz stream in two cases:\r
XzUnpacker_Code() returns:\r
  res == SZ_OK && status == CODER_STATUS_NEEDS_MORE_INPUT\r
  res == SZ_ERROR_NO_ARCHIVE\r
*/\r
\r
UInt64 XzUnpacker_GetExtraSize(CXzUnpacker *p);\r
\r
EXTERN_C_END\r
\r
#endif\r