C/Xz.h

   1 /* Xz.h - Xz interface\r
   2 2010-09-17 : 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 Byte XZ_SIG[XZ_SIG_SIZE];\r
  63 extern 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   int 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, int 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   int 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, int 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 numStreams;\r
 213 \r
 214   UInt32 crc;\r
 215   CMixCoder decoder;\r
 216   CXzBlock block;\r
 217   CXzCheck check;\r
 218   CSha256 sha;\r
 219   Byte shaDigest[SHA256_DIGEST_SIZE];\r
 220   Byte buf[XZ_BLOCK_HEADER_SIZE_MAX];\r
 221 } CXzUnpacker;\r
 222 \r
 223 SRes XzUnpacker_Create(CXzUnpacker *p, ISzAlloc *alloc);\r
 224 void XzUnpacker_Free(CXzUnpacker *p);\r
 225 \r
 226 /*\r
 227 finishMode:\r
 228   It has meaning only if the decoding reaches output limit (*destLen).\r
 229   LZMA_FINISH_ANY - use smallest number of input bytes\r
 230   LZMA_FINISH_END - read EndOfStream marker after decoding\r
 231 \r
 232 Returns:\r
 233   SZ_OK\r
 234     status:\r
 235       LZMA_STATUS_FINISHED_WITH_MARK\r
 236       LZMA_STATUS_NOT_FINISHED\r
 237   SZ_ERROR_DATA - Data error\r
 238   SZ_ERROR_MEM  - Memory allocation error\r
 239   SZ_ERROR_UNSUPPORTED - Unsupported properties\r
 240   SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).\r
 241 */\r
 242 \r
 243 \r
 244 SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,\r
 245     const Byte *src, SizeT *srcLen, /* int srcWasFinished, */ int finishMode,\r
 246     ECoderStatus *status);\r
 247 \r
 248 Bool XzUnpacker_IsStreamWasFinished(CXzUnpacker *p);\r
 249 \r
 250 EXTERN_C_END\r
 251 \r
 252 #endif\r