1 /* Xz.h - Xz interface
\r
2 2015-05-01 : Igor Pavlov : Public domain */
\r
11 #define XZ_ID_Subblock 1
\r
12 #define XZ_ID_Delta 3
\r
15 #define XZ_ID_IA64 6
\r
17 #define XZ_ID_ARMT 8
\r
18 #define XZ_ID_SPARC 9
\r
19 #define XZ_ID_LZMA2 0x21
\r
21 unsigned Xz_ReadVarInt(const Byte *p, size_t maxSize, UInt64 *value);
\r
22 unsigned Xz_WriteVarInt(Byte *buf, UInt64 v);
\r
24 /* ---------- xz block ---------- */
\r
26 #define XZ_BLOCK_HEADER_SIZE_MAX 1024
\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
33 #define XZ_FILTER_PROPS_SIZE_MAX 20
\r
39 Byte props[XZ_FILTER_PROPS_SIZE_MAX];
\r
47 CXzFilter filters[XZ_NUM_FILTERS_MAX];
\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
54 SRes XzBlock_Parse(CXzBlock *p, const Byte *header);
\r
55 SRes XzBlock_ReadHeader(CXzBlock *p, ISeqInStream *inStream, Bool *isIndex, UInt32 *headerSizeRes);
\r
57 /* ---------- xz stream ---------- */
\r
59 #define XZ_SIG_SIZE 6
\r
60 #define XZ_FOOTER_SIG_SIZE 2
\r
62 extern const Byte XZ_SIG[XZ_SIG_SIZE];
\r
63 extern const Byte XZ_FOOTER_SIG[XZ_FOOTER_SIG_SIZE];
\r
65 #define XZ_STREAM_FLAGS_SIZE 2
\r
66 #define XZ_STREAM_CRC_SIZE 4
\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
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
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
89 typedef UInt16 CXzStreamFlags;
\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
96 SRes Xz_ParseHeader(CXzStreamFlags *p, const Byte *buf);
\r
97 SRes Xz_ReadHeader(CXzStreamFlags *p, ISeqInStream *inStream);
\r
107 CXzStreamFlags flags;
\r
109 size_t numBlocksAllocated;
\r
110 CXzBlockSizes *blocks;
\r
111 UInt64 startOffset;
\r
114 void Xz_Construct(CXzStream *p);
\r
115 void Xz_Free(CXzStream *p, ISzAlloc *alloc);
\r
117 #define XZ_SIZE_OVERFLOW ((UInt64)(Int64)-1)
\r
119 UInt64 Xz_GetUnpackSize(const CXzStream *p);
\r
120 UInt64 Xz_GetPackSize(const CXzStream *p);
\r
125 size_t numAllocated;
\r
126 CXzStream *streams;
\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
133 UInt64 Xzs_GetNumBlocks(const CXzs *p);
\r
134 UInt64 Xzs_GetUnpackSize(const CXzs *p);
\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
146 CODER_FINISH_ANY, /* finish at any point */
\r
147 CODER_FINISH_END /* block must be finished at the end */
\r
148 } ECoderFinishMode;
\r
150 typedef struct _IStateCoder
\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
160 #define MIXCODER_NUM_FILTERS_MAX 4
\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
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
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
191 XZ_STATE_BLOCK_FOOTER
\r
199 unsigned indexPreSize;
\r
201 CXzStreamFlags streamFlags;
\r
203 UInt32 blockHeaderSize;
\r
212 UInt64 numStartedStreams;
\r
213 UInt64 numFinishedStreams;
\r
214 UInt64 numTotalBlocks;
\r
221 Byte shaDigest[SHA256_DIGEST_SIZE];
\r
222 Byte buf[XZ_BLOCK_HEADER_SIZE_MAX];
\r
225 void XzUnpacker_Construct(CXzUnpacker *p, ISzAlloc *alloc);
\r
226 void XzUnpacker_Init(CXzUnpacker *p);
\r
227 void XzUnpacker_Free(CXzUnpacker *p);
\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
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
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
257 SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
\r
258 const Byte *src, SizeT *srcLen, ECoderFinishMode finishMode,
\r
259 ECoderStatus *status);
\r
261 Bool XzUnpacker_IsStreamWasFinished(CXzUnpacker *p);
\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
271 UInt64 XzUnpacker_GetExtraSize(CXzUnpacker *p);
\r