deps/lzma-16.04/C/Xz.h

   1 /* Xz.h - Xz interface\r
   2 2015-05-01 : Igor Pavlov : Public domain */\r
   3 \r
   4 #ifndef __XZ_H\r
   5 #define __XZ_H\r
   6 \r
   7 #include "Sha256.h"\r
   8 \r
   9 EXTERN_C_BEGIN\r
  10 \r
  11 #define XZ_ID_Subblock 1\r
  12 #define XZ_ID_Delta 3\r
  13 #define XZ_ID_X86 4\r
  14 #define XZ_ID_PPC 5\r
  15 #define XZ_ID_IA64 6\r
  16 #define XZ_ID_ARM 7\r
  17 #define XZ_ID_ARMT 8\r
  18 #define XZ_ID_SPARC 9\r
  19 #define XZ_ID_LZMA2 0x21\r
  20 \r
  21 unsigned Xz_ReadVarInt(const Byte *p, size_t maxSize, UInt64 *value);\r
  22 unsigned Xz_WriteVarInt(Byte *buf, UInt64 v);\r
  23 \r
  24 /* ---------- xz block ---------- */\r
  25 \r
  26 #define XZ_BLOCK_HEADER_SIZE_MAX 1024\r
  27 \r
  28 #define XZ_NUM_FILTERS_MAX 4\r
  29 #define XZ_BF_NUM_FILTERS_MASK 3\r
  30 #define XZ_BF_PACK_SIZE (1 << 6)\r
  31 #define XZ_BF_UNPACK_SIZE (1 << 7)\r
  32 \r
  33 #define XZ_FILTER_PROPS_SIZE_MAX 20\r
  34 \r
  35 typedef struct\r
  36 {\r
  37   UInt64 id;\r
  38   UInt32 propsSize;\r
  39   Byte props[XZ_FILTER_PROPS_SIZE_MAX];\r
  40 } CXzFilter;\r
  41 \r
  42 typedef struct\r
  43 {\r
  44   UInt64 packSize;\r
  45   UInt64 unpackSize;\r
  46   Byte flags;\r
  47   CXzFilter filters[XZ_NUM_FILTERS_MAX];\r
  48 } CXzBlock;\r
  49 \r
  50 #define XzBlock_GetNumFilters(p) (((p)->flags & XZ_BF_NUM_FILTERS_MASK) + 1)\r
  51 #define XzBlock_HasPackSize(p)   (((p)->flags & XZ_BF_PACK_SIZE) != 0)\r
  52 #define XzBlock_HasUnpackSize(p) (((p)->flags & XZ_BF_UNPACK_SIZE) != 0)\r
  53 \r
  54 SRes XzBlock_Parse(CXzBlock *p, const Byte *header);\r
  55 SRes XzBlock_ReadHeader(CXzBlock *p, ISeqInStream *inStream, Bool *isIndex, UInt32 *headerSizeRes);\r
  56 \r
  57 /* ---------- xz stream ---------- */\r
  58 \r
  59 #define XZ_SIG_SIZE 6\r
  60 #define XZ_FOOTER_SIG_SIZE 2\r
  61 \r
  62 extern const Byte XZ_SIG[XZ_SIG_SIZE];\r
  63 extern const Byte XZ_FOOTER_SIG[XZ_FOOTER_SIG_SIZE];\r
  64 \r
  65 #define XZ_STREAM_FLAGS_SIZE 2\r
  66 #define XZ_STREAM_CRC_SIZE 4\r
  67 \r
  68 #define XZ_STREAM_HEADER_SIZE (XZ_SIG_SIZE + XZ_STREAM_FLAGS_SIZE + XZ_STREAM_CRC_SIZE)\r
  69 #define XZ_STREAM_FOOTER_SIZE (XZ_FOOTER_SIG_SIZE + XZ_STREAM_FLAGS_SIZE + XZ_STREAM_CRC_SIZE + 4)\r
  70 \r
  71 #define XZ_CHECK_MASK 0xF\r
  72 #define XZ_CHECK_NO 0\r
  73 #define XZ_CHECK_CRC32 1\r
  74 #define XZ_CHECK_CRC64 4\r
  75 #define XZ_CHECK_SHA256 10\r
  76 \r
  77 typedef struct\r
  78 {\r
  79   unsigned mode;\r
  80   UInt32 crc;\r
  81   UInt64 crc64;\r
  82   CSha256 sha;\r
  83 } CXzCheck;\r
  84 \r
  85 void XzCheck_Init(CXzCheck *p, unsigned mode);\r
  86 void XzCheck_Update(CXzCheck *p, const void *data, size_t size);\r
  87 int XzCheck_Final(CXzCheck *p, Byte *digest);\r
  88 \r
  89 typedef UInt16 CXzStreamFlags;\r
  90 \r
  91 #define XzFlags_IsSupported(f) ((f) <= XZ_CHECK_MASK)\r
  92 #define XzFlags_GetCheckType(f) ((f) & XZ_CHECK_MASK)\r
  93 #define XzFlags_HasDataCrc32(f) (Xz_GetCheckType(f) == XZ_CHECK_CRC32)\r
  94 unsigned XzFlags_GetCheckSize(CXzStreamFlags f);\r
  95 \r
  96 SRes Xz_ParseHeader(CXzStreamFlags *p, const Byte *buf);\r
  97 SRes Xz_ReadHeader(CXzStreamFlags *p, ISeqInStream *inStream);\r
  98 \r
  99 typedef struct\r
 100 {\r
 101   UInt64 unpackSize;\r
 102   UInt64 totalSize;\r
 103 } CXzBlockSizes;\r
 104 \r
 105 typedef struct\r
 106 {\r
 107   CXzStreamFlags flags;\r
 108   size_t numBlocks;\r
 109   size_t numBlocksAllocated;\r
 110   CXzBlockSizes *blocks;\r
 111   UInt64 startOffset;\r
 112 } CXzStream;\r
 113 \r
 114 void Xz_Construct(CXzStream *p);\r
 115 void Xz_Free(CXzStream *p, ISzAlloc *alloc);\r
 116 \r
 117 #define XZ_SIZE_OVERFLOW ((UInt64)(Int64)-1)\r
 118 \r
 119 UInt64 Xz_GetUnpackSize(const CXzStream *p);\r
 120 UInt64 Xz_GetPackSize(const CXzStream *p);\r
 121 \r
 122 typedef struct\r
 123 {\r
 124   size_t num;\r
 125   size_t numAllocated;\r
 126   CXzStream *streams;\r
 127 } CXzs;\r
 128 \r
 129 void Xzs_Construct(CXzs *p);\r
 130 void Xzs_Free(CXzs *p, ISzAlloc *alloc);\r
 131 SRes Xzs_ReadBackward(CXzs *p, ILookInStream *inStream, Int64 *startOffset, ICompressProgress *progress, ISzAlloc *alloc);\r
 132 \r
 133 UInt64 Xzs_GetNumBlocks(const CXzs *p);\r
 134 UInt64 Xzs_GetUnpackSize(const CXzs *p);\r
 135 \r
 136 typedef enum\r
 137 {\r
 138   CODER_STATUS_NOT_SPECIFIED,               /* use main error code instead */\r
 139   CODER_STATUS_FINISHED_WITH_MARK,          /* stream was finished with end mark. */\r
 140   CODER_STATUS_NOT_FINISHED,                /* stream was not finished */\r
 141   CODER_STATUS_NEEDS_MORE_INPUT             /* you must provide more input bytes */\r
 142 } ECoderStatus;\r
 143 \r
 144 typedef enum\r
 145 {\r
 146   CODER_FINISH_ANY,   /* finish at any point */\r
 147   CODER_FINISH_END    /* block must be finished at the end */\r
 148 } ECoderFinishMode;\r
 149 \r
 150 typedef struct _IStateCoder\r
 151 {\r
 152   void *p;\r
 153   void (*Free)(void *p, ISzAlloc *alloc);\r
 154   SRes (*SetProps)(void *p, const Byte *props, size_t propSize, ISzAlloc *alloc);\r
 155   void (*Init)(void *p);\r
 156   SRes (*Code)(void *p, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,\r
 157       int srcWasFinished, ECoderFinishMode finishMode, int *wasFinished);\r
 158 } IStateCoder;\r
 159 \r
 160 #define MIXCODER_NUM_FILTERS_MAX 4\r
 161 \r
 162 typedef struct\r
 163 {\r
 164   ISzAlloc *alloc;\r
 165   Byte *buf;\r
 166   unsigned numCoders;\r
 167   int finished[MIXCODER_NUM_FILTERS_MAX - 1];\r
 168   size_t pos[MIXCODER_NUM_FILTERS_MAX - 1];\r
 169   size_t size[MIXCODER_NUM_FILTERS_MAX - 1];\r
 170   UInt64 ids[MIXCODER_NUM_FILTERS_MAX];\r
 171   IStateCoder coders[MIXCODER_NUM_FILTERS_MAX];\r
 172 } CMixCoder;\r
 173 \r
 174 void MixCoder_Construct(CMixCoder *p, ISzAlloc *alloc);\r
 175 void MixCoder_Free(CMixCoder *p);\r
 176 void MixCoder_Init(CMixCoder *p);\r
 177 SRes MixCoder_SetFromMethod(CMixCoder *p, unsigned coderIndex, UInt64 methodId);\r
 178 SRes MixCoder_Code(CMixCoder *p, Byte *dest, SizeT *destLen,\r
 179     const Byte *src, SizeT *srcLen, int srcWasFinished,\r
 180     ECoderFinishMode finishMode, ECoderStatus *status);\r
 181 \r
 182 typedef enum\r
 183 {\r
 184   XZ_STATE_STREAM_HEADER,\r
 185   XZ_STATE_STREAM_INDEX,\r
 186   XZ_STATE_STREAM_INDEX_CRC,\r
 187   XZ_STATE_STREAM_FOOTER,\r
 188   XZ_STATE_STREAM_PADDING,\r
 189   XZ_STATE_BLOCK_HEADER,\r
 190   XZ_STATE_BLOCK,\r
 191   XZ_STATE_BLOCK_FOOTER\r
 192 } EXzState;\r
 193 \r
 194 typedef struct\r
 195 {\r
 196   EXzState state;\r
 197   UInt32 pos;\r
 198   unsigned alignPos;\r
 199   unsigned indexPreSize;\r
 200 \r
 201   CXzStreamFlags streamFlags;\r
 202   \r
 203   UInt32 blockHeaderSize;\r
 204   UInt64 packSize;\r
 205   UInt64 unpackSize;\r
 206 \r
 207   UInt64 numBlocks;\r
 208   UInt64 indexSize;\r
 209   UInt64 indexPos;\r
 210   UInt64 padSize;\r
 211 \r
 212   UInt64 numStartedStreams;\r
 213   UInt64 numFinishedStreams;\r
 214   UInt64 numTotalBlocks;\r
 215 \r
 216   UInt32 crc;\r
 217   CMixCoder decoder;\r
 218   CXzBlock block;\r
 219   CXzCheck check;\r
 220   CSha256 sha;\r
 221   Byte shaDigest[SHA256_DIGEST_SIZE];\r
 222   Byte buf[XZ_BLOCK_HEADER_SIZE_MAX];\r
 223 } CXzUnpacker;\r
 224 \r
 225 void XzUnpacker_Construct(CXzUnpacker *p, ISzAlloc *alloc);\r
 226 void XzUnpacker_Init(CXzUnpacker *p);\r
 227 void XzUnpacker_Free(CXzUnpacker *p);\r
 228 \r
 229 /*\r
 230 finishMode:\r
 231   It has meaning only if the decoding reaches output limit (*destLen).\r
 232   CODER_FINISH_ANY - use smallest number of input bytes\r
 233   CODER_FINISH_END - read EndOfStream marker after decoding\r
 234 \r
 235 Returns:\r
 236   SZ_OK\r
 237     status:\r
 238       CODER_STATUS_NOT_FINISHED,\r
 239       CODER_STATUS_NEEDS_MORE_INPUT - maybe there are more xz streams,\r
 240                                       call XzUnpacker_IsStreamWasFinished to check that current stream was finished\r
 241   SZ_ERROR_MEM  - Memory allocation error\r
 242   SZ_ERROR_DATA - Data error\r
 243   SZ_ERROR_UNSUPPORTED - Unsupported method or method properties\r
 244   SZ_ERROR_CRC  - CRC error\r
 245   // SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).\r
 246 \r
 247   SZ_ERROR_NO_ARCHIVE - the error with xz Stream Header with one of the following reasons:\r
 248      - xz Stream Signature failure\r
 249      - CRC32 of xz Stream Header is failed\r
 250      - The size of Stream padding is not multiple of four bytes.\r
 251     It's possible to get that error, if xz stream was finished and the stream\r
 252     contains some another data. In that case you can call XzUnpacker_GetExtraSize()\r
 253     function to get real size of xz stream.\r
 254 */\r
 255 \r
 256 \r
 257 SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,\r
 258     const Byte *src, SizeT *srcLen, ECoderFinishMode finishMode,\r
 259     ECoderStatus *status);\r
 260 \r
 261 Bool XzUnpacker_IsStreamWasFinished(CXzUnpacker *p);\r
 262 \r
 263 /*\r
 264 Call XzUnpacker_GetExtraSize after XzUnpacker_Code function to detect real size of\r
 265 xz stream in two cases:\r
 266 XzUnpacker_Code() returns:\r
 267   res == SZ_OK && status == CODER_STATUS_NEEDS_MORE_INPUT\r
 268   res == SZ_ERROR_NO_ARCHIVE\r
 269 */\r
 270 \r
 271 UInt64 XzUnpacker_GetExtraSize(CXzUnpacker *p);\r
 272 \r
 273 EXTERN_C_END\r
 274 \r
 275 #endif\r