dlzma/package.d

   1 /* converted by Ketmar // Invisible Vector <ketmar@ketmar.no-ip.org>
   2  * Understanding is not required. Only obedience.
   3  *
   4  * This program is free software. It comes without any warranty, to
   5  * the extent permitted by applicable law. You can redistribute it
   6  * and/or modify it under the terms of the Do What The Fuck You Want
   7  * To Public License, Version 2, as published by Sam Hocevar. See
   8  * http://www.wtfpl.net/txt/copying/ for more details.
   9  */
  10 // conversion of LZMA SDK 2103 (lzma2103.7z)
  11 module iv.dlzma;
  12 public:
  13
  14
  15 // ////////////////////////////////////////////////////////////////////////// //
  16 static if (!is(typeof(usize))) public alias usize = size_t;
  17
  18
  19 // ////////////////////////////////////////////////////////////////////////// //
  20 /* LZMA_PROB32 can increase the speed on some CPUs,
  21    but memory usage for CLzmaDec::probs will be doubled in that case */
  22 //version = LZMA_PROB32;
  23
  24 version(LZMA_PROB32) {
  25   alias CLzmaProb = uint;
  26 } else {
  27   alias CLzmaProb = ushort;
  28 }
  29
  30
  31 // ////////////////////////////////////////////////////////////////////////// //
  32 enum {
  33   SZ_OK = 0,
  34
  35   SZ_ERROR_DATA = 1,
  36   SZ_ERROR_MEM = 2,
  37   // SZ_ERROR_CRC = 3,
  38   SZ_ERROR_UNSUPPORTED = 4,
  39   SZ_ERROR_PARAM = 5,
  40   SZ_ERROR_INPUT_EOF = 6,
  41   SZ_ERROR_OUTPUT_EOF = 7,
  42   SZ_ERROR_READ = 8,
  43   SZ_ERROR_WRITE = 9,
  44   SZ_ERROR_PROGRESS = 10,
  45   SZ_ERROR_FAIL = 11,
  46 }
  47
  48
  49 alias SRes = int;
  50 alias WRes = int;
  51
  52
  53 /* The following interfaces use first parameter as pointer to structure */
  54
  55 struct ISeqInStream {
  56   SRes delegate (/*const*/ISeqInStream* p, void* buf, usize* size) nothrow Read;
  57     /* if (input(*size) != 0 && output(*size) == 0) means end_of_stream.
  58        (output(*size) < input(*size)) is allowed */
  59 };
  60
  61
  62 struct ISeqOutStream {
  63   usize delegate (/*const*/ISeqOutStream* p, const(void)* buf, usize size) nothrow Write;
  64     /* Returns: result - the number of actually written bytes.
  65        (result < size) means error */
  66 };
  67
  68
  69 struct ICompressProgress {
  70   SRes delegate (/*const*/ICompressProgress* p, ulong inSize, ulong outSize) nothrow Progress;
  71     /* Returns: result. (result != SZ_OK) means break.
  72        Value (ulong)(long)-1 for size means unknown value. */
  73 };
  74
  75
  76 alias ISzAllocPtr = ISzAlloc*;
  77 struct ISzAlloc {
  78   void *delegate (ISzAllocPtr p, usize size) nothrow Alloc;
  79   void delegate (ISzAllocPtr p, void *address) nothrow Free; /* address can be 0 */
  80 };
  81
  82 public void *ISzAlloc_Alloc (ISzAllocPtr p, usize size) nothrow {
  83   pragma(inline, true);
  84   return p.Alloc(p, size);
  85 }
  86
  87 public void ISzAlloc_Free (ISzAllocPtr p, void *address) nothrow {
  88   pragma(inline, true);
  89   p.Free(p, address);
  90 }
  91
  92
  93 // ////////////////////////////////////////////////////////////////////////// //
  94 __gshared ISzAlloc lzmaDefAllocator = ISzAlloc(
  95   delegate void* (ISzAllocPtr p, usize size) nothrow {
  96     import core.stdc.stdlib : malloc;
  97     size += !size;
  98     return malloc(size);
  99   },
 100   delegate void (ISzAllocPtr p, void* address) nothrow {
 101     import core.stdc.stdlib : free;
 102     if (address !is null) free(address);
 103   }
 104 );
 105
 106
 107 // ////////////////////////////////////////////////////////////////////////// //
 108 enum LZMA_PROPS_SIZE = 5;
 109
 110
 111 //**************************************************************************
 112 //
 113 // encoder API
 114 //
 115 //**************************************************************************
 116
 117 struct CLzmaEncProps {
 118   int level;        /* 0 <= level <= 9 */
 119   uint dictSize;    /* (1 << 12) <= dictSize <= (1 << 27) for 32-bit version
 120                        (1 << 12) <= dictSize <= (3 << 29) for 64-bit version
 121                        default = (1 << 24) */
 122   int lc;           /* 0 <= lc <= 8, default = 3 */
 123   int lp;           /* 0 <= lp <= 4, default = 0 */
 124   int pb;           /* 0 <= pb <= 4, default = 2 */
 125   int algo;         /* 0 - fast, 1 - normal, default = 1 */
 126   int fb;           /* 5 <= fb <= 273, default = 32 */
 127   int btMode;       /* 0 - hashChain Mode, 1 - binTree mode - normal, default = 1 */
 128   int numHashBytes; /* 2, 3 or 4, default = 4 */
 129   uint mc;          /* 1 <= mc <= (1 << 30), default = 32 */
 130   uint writeEndMark;/* 0 - do not write EOPM, 1 - write EOPM, default = 0 */
 131
 132   ulong reduceSize; /* estimated size of data that will be compressed. default = (ulong)(long)-1.
 133                        Encoder uses this value to reduce dictionary size */
 134 }
 135
 136 alias CLzmaEncHandle = void*;
 137
 138 version(none) {
 139 public void LzmaEncProps_Init (CLzmaEncProps* p) @nogc;
 140 public void LzmaEncProps_Normalize (CLzmaEncProps* p) @nogc;
 141 public uint LzmaEncProps_GetDictSize (const(CLzmaEncProps)* props2) @nogc;
 142
 143 /* LzmaEnc* functions can return the following exit codes:
 144 SRes:
 145   SZ_OK           - OK
 146   SZ_ERROR_MEM    - Memory allocation error
 147   SZ_ERROR_PARAM  - Incorrect paramater in props
 148   SZ_ERROR_WRITE  - ISeqOutStream write callback error
 149   SZ_ERROR_OUTPUT_EOF - output buffer overflow - version with (ubyte *) output
 150   SZ_ERROR_PROGRESS - some break from progress callback
 151 */
 152
 153 public CLzmaEncHandle LzmaEnc_Create (ISzAllocPtr alloc);
 154 public void LzmaEnc_Destroy (CLzmaEncHandle p, ISzAllocPtr alloc, ISzAllocPtr allocBig);
 155
 156 public SRes LzmaEnc_SetProps (CLzmaEncHandle pp, const(CLzmaEncProps)* props2) @nogc;
 157 public void LzmaEnc_SetDataSize (CLzmaEncHandle pp, ulong expectedDataSiize) @nogc;
 158 public SRes LzmaEnc_WriteProperties (CLzmaEncHandle pp, ubyte* props, uint* size) @nogc;
 159 public uint LzmaEnc_IsWriteEndMark (CLzmaEncHandle pp) @nogc;
 160
 161 public SRes LzmaEnc_MemEncode (CLzmaEncHandle pp, ubyte* dest, usize* destLen, const(ubyte)* src, usize srcLen,
 162                                int writeEndMark, ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);
 163
 164 public SRes LzmaEnc_Encode (CLzmaEncHandle pp, ISeqOutStream *outStream, ISeqInStream *inStream,
 165                             ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);
 166
 167 /* ---------- One Call Interface ---------- */
 168 public SRes LzmaEncode (ubyte* dest, usize* destLen, const(ubyte)* src, usize srcLen,
 169                         const(CLzmaEncProps)* props, ubyte* propsEncoded, uint* propsSize,
 170                         int writeEndMark, ICompressProgress *progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);
 171
 172 }
 173
 174
 175 //**************************************************************************
 176 //
 177 // decoder API
 178 //
 179 //**************************************************************************
 180 struct CLzmaProps {
 181   ubyte lc;
 182   ubyte lp;
 183   ubyte pb;
 184   ubyte _pad_;
 185   uint dicSize;
 186 }
 187
 188 /* LzmaProps_Decode - decodes properties
 189 Returns:
 190   SZ_OK
 191   SZ_ERROR_UNSUPPORTED - Unsupported properties
 192 */
 193
 194 //SRes LzmaProps_Decode(CLzmaProps *p, const uint8_t *data, unsigned size);
 195
 196
 197 /* ---------- LZMA Decoder state ---------- */
 198
 199 /* LZMA_REQUIRED_INPUT_MAX = number of required input bytes for worst case.
 200    Num bits = log2((2^11 / 31) ^ 22) + 26 < 134 + 26 = 160; */
 201
 202 enum LZMA_REQUIRED_INPUT_MAX = 20;
 203
 204 struct CLzmaDec {
 205   CLzmaProps prop;
 206   CLzmaProb *probs;
 207   CLzmaProb *probs_1664;
 208   ubyte *dic;
 209   usize dicBufSize;
 210   usize dicPos;
 211   const(ubyte)* buf;
 212   uint range;
 213   uint code;
 214   uint processedPos;
 215   uint checkDicSize;
 216   uint[4] reps;
 217   uint state;
 218   uint remainLen;
 219
 220   uint numProbs;
 221   uint tempBufSize;
 222   ubyte[LZMA_REQUIRED_INPUT_MAX] tempBuf = void;
 223 }
 224
 225 //#define LzmaDec_Construct(p) { (p)->dic = NULL; (p)->probs = NULL; }
 226
 227 //public void LzmaDec_Construct (CLzmaDec *p) nothrow @nogc { p.dic = null; p.probs = null; }
 228
 229 /* There are two types of LZMA streams:
 230      - Stream with end mark. That end mark adds about 6 bytes to compressed size.
 231      - Stream without end mark. You must know exact uncompressed size to decompress such stream. */
 232
 233 alias ELzmaFinishMode = int;
 234 enum {
 235   LZMA_FINISH_ANY,   /* finish at any point */
 236   LZMA_FINISH_END    /* block must be finished at the end */
 237 }
 238
 239 /* ELzmaFinishMode has meaning only if the decoding reaches output limit !!!
 240
 241    You must use LZMA_FINISH_END, when you know that current output buffer
 242    covers last bytes of block. In other cases you must use LZMA_FINISH_ANY.
 243
 244    If LZMA decoder sees end marker before reaching output limit, it returns SZ_OK,
 245    and output value of destLen will be less than output buffer size limit.
 246    You can check status result also.
 247
 248    You can use multiple checks to test data integrity after full decompression:
 249      1) Check Result and "status" variable.
 250      2) Check that output(destLen) = uncompressedSize, if you know real uncompressedSize.
 251      3) Check that output(srcLen) = compressedSize, if you know real compressedSize.
 252         You must use correct finish mode in that case. */
 253
 254 alias ELzmaStatus = int;
 255 enum {
 256   LZMA_STATUS_NOT_SPECIFIED,               /* use main error code instead */
 257   LZMA_STATUS_FINISHED_WITH_MARK,          /* stream was finished with end mark. */
 258   LZMA_STATUS_NOT_FINISHED,                /* stream was not finished */
 259   LZMA_STATUS_NEEDS_MORE_INPUT,            /* you must provide more input bytes */
 260   LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK  /* there is probability that stream was finished without end mark */
 261 }
 262
 263 /* ELzmaStatus is used only as output value for function call */
 264
 265
 266 /* ---------- Interfaces ---------- */
 267
 268 /* There are 3 levels of interfaces:
 269      1) Dictionary Interface
 270      2) Buffer Interface
 271      3) One Call Interface
 272    You can select any of these interfaces, but don't mix functions from different
 273    groups for same object. */
 274
 275
 276 /* There are two variants to allocate state for Dictionary Interface:
 277      1) LzmaDec_Allocate / LzmaDec_Free
 278      2) LzmaDec_AllocateProbs / LzmaDec_FreeProbs
 279    You can use variant 2, if you set dictionary buffer manually.
 280    For Buffer Interface you must always use variant 1.
 281
 282 LzmaDec_Allocate* can return:
 283   SZ_OK
 284   SZ_ERROR_MEM         - Memory allocation error
 285   SZ_ERROR_UNSUPPORTED - Unsupported properties
 286 */
 287
 288 version(none) {
 289 // you can use this to check and decode properties
 290 public SRes LzmaProps_Decode (CLzmaProps* p, const(ubyte)* data, uint size) @nogc;
 291
 292 public void LzmaDec_Init (CLzmaDec* p) @nogc;
 293
 294 public SRes LzmaDec_Allocate (CLzmaDec* p, const(ubyte)* props, uint propsSize, ISzAllocPtr alloc);
 295 public void LzmaDec_Free (CLzmaDec* p, ISzAllocPtr alloc);
 296
 297 //k8: the following two functions are used for... something, i don't know.
 298 //k8: you don't need to call them, `LzmaDec_Allocate()` and `LzmaDec_Free()` will do it for you.
 299 public SRes LzmaDec_AllocateProbs (CLzmaDec* p, const(ubyte)* props, uint propsSize, ISzAllocPtr alloc);
 300 public void LzmaDec_FreeProbs (CLzmaDec *p, ISzAllocPtr alloc);
 301
 302 /* ---------- Dictionary Interface ---------- */
 303
 304 /* You can use it, if you want to eliminate the overhead for data copying from
 305    dictionary to some other external buffer.
 306    You must work with CLzmaDec variables directly in this interface.
 307
 308    STEPS:
 309      LzmaDec_Construct()
 310      LzmaDec_Allocate()
 311      for (each new stream)
 312      {
 313        LzmaDec_Init()
 314        while (it needs more decompression)
 315        {
 316          LzmaDec_DecodeToDic()
 317          use data from CLzmaDec::dic and update CLzmaDec::dicPos
 318        }
 319      }
 320      LzmaDec_Free()
 321 */
 322
 323 /* LzmaDec_DecodeToDic
 324
 325    The decoding to internal dictionary buffer (CLzmaDec::dic).
 326    You must manually update CLzmaDec::dicPos, if it reaches CLzmaDec::dicBufSize !!!
 327
 328 finishMode:
 329   It has meaning only if the decoding reaches output limit (dicLimit).
 330   LZMA_FINISH_ANY - Decode just dicLimit bytes.
 331   LZMA_FINISH_END - Stream must be finished after dicLimit.
 332
 333 Returns:
 334   SZ_OK
 335     status:
 336       LZMA_STATUS_FINISHED_WITH_MARK
 337       LZMA_STATUS_NOT_FINISHED
 338       LZMA_STATUS_NEEDS_MORE_INPUT
 339       LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK
 340   SZ_ERROR_DATA - Data error
 341   SZ_ERROR_FAIL - Some unexpected error: internal error of code, memory corruption or hardware failure
 342 */
 343
 344 public SRes LzmaDec_DecodeToDic (CLzmaDec* p, usize dicLimit, const(ubyte)* src, usize *srcLen,
 345                                  ELzmaFinishMode finishMode, ELzmaStatus *status) @nogc;
 346
 347
 348 /* ---------- Buffer Interface ---------- */
 349
 350 /* It's zlib-like interface.
 351    See LzmaDec_DecodeToDic description for information about STEPS and return results,
 352    but you must use LzmaDec_DecodeToBuf instead of LzmaDec_DecodeToDic and you don't need
 353    to work with CLzmaDec variables manually.
 354
 355 finishMode:
 356   It has meaning only if the decoding reaches output limit (*destLen).
 357   LZMA_FINISH_ANY - Decode just destLen bytes.
 358   LZMA_FINISH_END - Stream must be finished after (*destLen).
 359 */
 360
 361 public SRes LzmaDec_DecodeToBuf (CLzmaDec* p, ubyte* dest, usize* destLen, const(ubyte)* src, usize *srcLen,
 362                                  ELzmaFinishMode finishMode, ELzmaStatus *status) @nogc;
 363
 364
 365 /* ---------- One Call Interface ---------- */
 366
 367 /* LzmaDecode
 368
 369 finishMode:
 370   It has meaning only if the decoding reaches output limit (*destLen).
 371   LZMA_FINISH_ANY - Decode just destLen bytes.
 372   LZMA_FINISH_END - Stream must be finished after (*destLen).
 373
 374 Returns:
 375   SZ_OK
 376     status:
 377       LZMA_STATUS_FINISHED_WITH_MARK
 378       LZMA_STATUS_NOT_FINISHED
 379       LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK
 380   SZ_ERROR_DATA - Data error
 381   SZ_ERROR_MEM  - Memory allocation error
 382   SZ_ERROR_UNSUPPORTED - Unsupported properties
 383   SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).
 384   SZ_ERROR_FAIL - Some unexpected error: internal error of code, memory corruption or hardware failure
 385 */
 386
 387 public SRes LzmaDecode (ubyte* dest, usize* destLen, const(ubyte)* src, usize *srcLen,
 388                         const(ubyte)* propData, uint propSize, ELzmaFinishMode finishMode,
 389                         ELzmaStatus *status, ISzAllocPtr alloc);
 390 }
 391
 392
 393 public import iv.dlzma.dec;
 394 public import iv.dlzma.enc;