7zip-native 0.0.0-stage → 0.0.1

package/vendor/7zip/C/LzmaEnc.h

@@ -0,0 +1,85 @@
+/*  LzmaEnc.h -- LZMA Encoder
+: Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_LZMA_ENC_H
+#define ZIP7_INC_LZMA_ENC_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+#define LZMA_PROPS_SIZE 5
+
+typedef struct
+{
+  int level;       /* 0 <= level <= 9 */
+  UInt32 dictSize; /* (1 << 12) <= dictSize <= (1 << 27) for 32-bit version
+                      (1 << 12) <= dictSize <= (3 << 29) for 64-bit version
+                      default = (1 << 24) */
+  int lc;          /* 0 <= lc <= 8, default = 3 */
+  int lp;          /* 0 <= lp <= 4, default = 0 */
+  int pb;          /* 0 <= pb <= 4, default = 2 */
+  int algo;        /* 0 - fast, 1 - normal, default = 1 */
+  int fb;          /* 5 <= fb <= 273, default = 32 */
+  int btMode;      /* 0 - hashChain Mode, 1 - binTree mode - normal, default = 1 */
+  int numHashBytes; /* 2, 3 or 4, default = 4 */
+  unsigned numHashOutBits;  /* default = ? */
+  UInt32 mc;       /* 1 <= mc <= (1 << 30), default = 32 */
+  unsigned writeEndMark;  /* 0 - do not write EOPM, 1 - write EOPM, default = 0 */
+  int numThreads;  /* 1 or 2, default = 2 */
+
+  // int _pad;
+  Int32 affinityGroup;
+
+  UInt64 reduceSize; /* estimated size of data that will be compressed. default = (UInt64)(Int64)-1.
+                        Encoder uses this value to reduce dictionary size */
+
+  UInt64 affinity;
+  UInt64 affinityInGroup;
+} CLzmaEncProps;
+
+void LzmaEncProps_Init(CLzmaEncProps *p);
+void LzmaEncProps_Normalize(CLzmaEncProps *p);
+UInt32 LzmaEncProps_GetDictSize(const CLzmaEncProps *props2);
+
+
+/* ---------- CLzmaEncHandle Interface ---------- */
+
+/* LzmaEnc* functions can return the following exit codes:
+SRes:
+  SZ_OK           - OK
+  SZ_ERROR_MEM    - Memory allocation error
+  SZ_ERROR_PARAM  - Incorrect paramater in props
+  SZ_ERROR_WRITE  - ISeqOutStream write callback error
+  SZ_ERROR_OUTPUT_EOF - output buffer overflow - version with (Byte *) output
+  SZ_ERROR_PROGRESS - some break from progress callback
+  SZ_ERROR_THREAD - error in multithreading functions (only for Mt version)
+*/
+
+typedef struct CLzmaEnc CLzmaEnc;
+typedef CLzmaEnc * CLzmaEncHandle;
+// Z7_DECLARE_HANDLE(CLzmaEncHandle)
+
+CLzmaEncHandle LzmaEnc_Create(ISzAllocPtr alloc);
+void LzmaEnc_Destroy(CLzmaEncHandle p, ISzAllocPtr alloc, ISzAllocPtr allocBig);
+
+SRes LzmaEnc_SetProps(CLzmaEncHandle p, const CLzmaEncProps *props);
+void LzmaEnc_SetDataSize(CLzmaEncHandle p, UInt64 expectedDataSiize);
+SRes LzmaEnc_WriteProperties(CLzmaEncHandle p, Byte *properties, SizeT *size);
+unsigned LzmaEnc_IsWriteEndMark(CLzmaEncHandle p);
+
+SRes LzmaEnc_Encode(CLzmaEncHandle p, ISeqOutStreamPtr outStream, ISeqInStreamPtr inStream,
+    ICompressProgressPtr progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);
+SRes LzmaEnc_MemEncode(CLzmaEncHandle p, Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
+    int writeEndMark, ICompressProgressPtr progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);
+
+
+/* ---------- One Call Interface ---------- */
+
+SRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
+    const CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark,
+    ICompressProgressPtr progress, ISzAllocPtr alloc, ISzAllocPtr allocBig);
+
+EXTERN_C_END
+
+#endif

package/vendor/7zip/C/LzmaLib.c

@@ -0,0 +1,42 @@
+/* LzmaLib.c -- LZMA library wrapper
+2023-04-02 : Igor Pavlov : Public domain */
+
+#include "Precomp.h"
+
+#include "Alloc.h"
+#include "LzmaDec.h"
+#include "LzmaEnc.h"
+#include "LzmaLib.h"
+
+Z7_STDAPI LzmaCompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t srcLen,
+  unsigned char *outProps, size_t *outPropsSize,
+  int level, /* 0 <= level <= 9, default = 5 */
+  unsigned dictSize, /* use (1 << N) or (3 << N). 4 KB < dictSize <= 128 MB */
+  int lc, /* 0 <= lc <= 8, default = 3  */
+  int lp, /* 0 <= lp <= 4, default = 0  */
+  int pb, /* 0 <= pb <= 4, default = 2  */
+  int fb,  /* 5 <= fb <= 273, default = 32 */
+  int numThreads /* 1 or 2, default = 2 */
+)
+{
+  CLzmaEncProps props;
+  LzmaEncProps_Init(&props);
+  props.level = level;
+  props.dictSize = dictSize;
+  props.lc = lc;
+  props.lp = lp;
+  props.pb = pb;
+  props.fb = fb;
+  props.numThreads = numThreads;
+
+  return LzmaEncode(dest, destLen, src, srcLen, &props, outProps, outPropsSize, 0,
+      NULL, &g_Alloc, &g_Alloc);
+}
+
+
+Z7_STDAPI LzmaUncompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t *srcLen,
+  const unsigned char *props, size_t propsSize)
+{
+  ELzmaStatus status;
+  return LzmaDecode(dest, destLen, src, srcLen, props, (unsigned)propsSize, LZMA_FINISH_ANY, &status, &g_Alloc);
+}

package/vendor/7zip/C/LzmaLib.h

@@ -0,0 +1,138 @@
+/* LzmaLib.h -- LZMA library interface
+2023-04-02 : Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_LZMA_LIB_H
+#define ZIP7_INC_LZMA_LIB_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+#define Z7_STDAPI int Z7_STDCALL
+
+#define LZMA_PROPS_SIZE 5
+
+/*
+RAM requirements for LZMA:
+  for compression:   (dictSize * 11.5 + 6 MB) + state_size
+  for decompression: dictSize + state_size
+    state_size = (4 + (1.5 << (lc + lp))) KB
+    by default (lc=3, lp=0), state_size = 16 KB.
+
+LZMA properties (5 bytes) format
+    Offset Size  Description
+      0     1    lc, lp and pb in encoded form.
+      1     4    dictSize (little endian).
+*/
+
+/*
+LzmaCompress
+------------
+
+outPropsSize -
+     In:  the pointer to the size of outProps buffer; *outPropsSize = LZMA_PROPS_SIZE = 5.
+     Out: the pointer to the size of written properties in outProps buffer; *outPropsSize = LZMA_PROPS_SIZE = 5.
+
+  LZMA Encoder will use defult values for any parameter, if it is
+  -1  for any from: level, loc, lp, pb, fb, numThreads
+   0  for dictSize
+  
+level - compression level: 0 <= level <= 9;
+
+  level dictSize algo  fb
+    0:    64 KB   0    32
+    1:   256 KB   0    32
+    2:     1 MB   0    32
+    3:     4 MB   0    32
+    4:    16 MB   0    32
+    5:    16 MB   1    32
+    6:    32 MB   1    32
+    7:    32 MB   1    64
+    8:    64 MB   1    64
+    9:    64 MB   1    64
+ 
+  The default value for "level" is 5.
+
+  algo = 0 means fast method
+  algo = 1 means normal method
+
+dictSize - The dictionary size in bytes. The maximum value is
+        128 MB = (1 << 27) bytes for 32-bit version
+          1 GB = (1 << 30) bytes for 64-bit version
+     The default value is 16 MB = (1 << 24) bytes.
+     It's recommended to use the dictionary that is larger than 4 KB and
+     that can be calculated as (1 << N) or (3 << N) sizes.
+
+lc - The number of literal context bits (high bits of previous literal).
+     It can be in the range from 0 to 8. The default value is 3.
+     Sometimes lc=4 gives the gain for big files.
+
+lp - The number of literal pos bits (low bits of current position for literals).
+     It can be in the range from 0 to 4. The default value is 0.
+     The lp switch is intended for periodical data when the period is equal to 2^lp.
+     For example, for 32-bit (4 bytes) periodical data you can use lp=2. Often it's
+     better to set lc=0, if you change lp switch.
+
+pb - The number of pos bits (low bits of current position).
+     It can be in the range from 0 to 4. The default value is 2.
+     The pb switch is intended for periodical data when the period is equal 2^pb.
+
+fb - Word size (the number of fast bytes).
+     It can be in the range from 5 to 273. The default value is 32.
+     Usually, a big number gives a little bit better compression ratio and
+     slower compression process.
+
+numThreads - The number of thereads. 1 or 2. The default value is 2.
+     Fast mode (algo = 0) can use only 1 thread.
+
+In:
+  dest     - output data buffer
+  destLen  - output data buffer size
+  src      - input data
+  srcLen   - input data size
+Out:
+  destLen  - processed output size
+Returns:
+  SZ_OK               - OK
+  SZ_ERROR_MEM        - Memory allocation error
+  SZ_ERROR_PARAM      - Incorrect paramater
+  SZ_ERROR_OUTPUT_EOF - output buffer overflow
+  SZ_ERROR_THREAD     - errors in multithreading functions (only for Mt version)
+*/
+
+Z7_STDAPI LzmaCompress(unsigned char *dest, size_t *destLen, const unsigned char *src, size_t srcLen,
+  unsigned char *outProps, size_t *outPropsSize, /* *outPropsSize must be = 5 */
+  int level,      /* 0 <= level <= 9, default = 5 */
+  unsigned dictSize,  /* default = (1 << 24) */
+  int lc,        /* 0 <= lc <= 8, default = 3  */
+  int lp,        /* 0 <= lp <= 4, default = 0  */
+  int pb,        /* 0 <= pb <= 4, default = 2  */
+  int fb,        /* 5 <= fb <= 273, default = 32 */
+  int numThreads /* 1 or 2, default = 2 */
+  );
+
+/*
+LzmaUncompress
+--------------
+In:
+  dest     - output data buffer
+  destLen  - output data buffer size
+  src      - input data
+  srcLen   - input data size
+Out:
+  destLen  - processed output size
+  srcLen   - processed input size
+Returns:
+  SZ_OK                - OK
+  SZ_ERROR_DATA        - Data error
+  SZ_ERROR_MEM         - Memory allocation arror
+  SZ_ERROR_UNSUPPORTED - Unsupported properties
+  SZ_ERROR_INPUT_EOF   - it needs more bytes in input buffer (src)
+*/
+
+Z7_STDAPI LzmaUncompress(unsigned char *dest, size_t *destLen, const unsigned char *src, SizeT *srcLen,
+  const unsigned char *props, size_t propsSize);
+
+EXTERN_C_END
+
+#endif

package/vendor/7zip/C/Md5.c

@@ -0,0 +1,206 @@
+/* Md5.c -- MD5 Hash
+: Igor Pavlov : Public domain
+This code is based on Colin Plumb's public domain md5.c code */
+
+#include "Precomp.h"
+
+#include <string.h>
+
+#include "Md5.h"
+#include "RotateDefs.h"
+#include "CpuArch.h"
+
+#define MD5_UPDATE_BLOCKS(p) Md5_UpdateBlocks
+
+Z7_NO_INLINE
+void Md5_Init(CMd5 *p)
+{
+  p->count = 0;
+  p->state[0] = 0x67452301;
+  p->state[1] = 0xefcdab89;
+  p->state[2] = 0x98badcfe;
+  p->state[3] = 0x10325476;
+}
+
+#if 0 && !defined(MY_CPU_LE_UNALIGN)
+// optional optimization for Big-endian processors or processors without unaligned access:
+// it is intended to reduce the number of complex LE32 memory reading from 64 to 16.
+// But some compilers (sparc, armt) are better without this optimization.
+#define Z7_MD5_USE_DATA32_ARRAY
+#endif
+
+#define LOAD_DATA(i)  GetUi32((const UInt32 *)(const void *)data + (i))
+
+#ifdef Z7_MD5_USE_DATA32_ARRAY
+#define D(i)  data32[i]
+#else
+#define D(i)  LOAD_DATA(i)
+#endif
+
+#define F1(x, y, z)   (z ^ (x & (y ^ z)))
+#define F2(x, y, z)   F1(z, x, y)
+#define F3(x, y, z)   (x ^ y ^ z)
+#define F4(x, y, z)   (y ^ (x | ~z))
+
+#define R1(i, f, start, step, w, x, y, z, s, k) \
+    w += D((start + step * (i)) % 16) + k; \
+    w += f(x, y, z); \
+    w = rotlFixed(w, s) + x; \
+
+#define R4(i4,  f, start, step, s0,s1,s2,s3, k0,k1,k2,k3) \
+    R1 (i4*4+0, f, start, step, a,b,c,d, s0, k0) \
+    R1 (i4*4+1, f, start, step, d,a,b,c, s1, k1) \
+    R1 (i4*4+2, f, start, step, c,d,a,b, s2, k2) \
+    R1 (i4*4+3, f, start, step, b,c,d,a, s3, k3) \
+
+#define R16(f, start, step, s0,s1,s2,s3, k00,k01,k02,k03, k10,k11,k12,k13, k20,k21,k22,k23, k30,k31,k32,k33)  \
+    R4 (0,  f, start, step, s0,s1,s2,s3, k00,k01,k02,k03) \
+    R4 (1,  f, start, step, s0,s1,s2,s3, k10,k11,k12,k13) \
+    R4 (2,  f, start, step, s0,s1,s2,s3, k20,k21,k22,k23) \
+    R4 (3,  f, start, step, s0,s1,s2,s3, k30,k31,k32,k33) \
+
+static
+Z7_NO_INLINE
+void Z7_FASTCALL Md5_UpdateBlocks(UInt32 state[4], const Byte *data, size_t numBlocks)
+{
+  UInt32 a, b, c, d;
+  // if (numBlocks == 0) return;
+  a = state[0];
+  b = state[1];
+  c = state[2];
+  d = state[3];
+  do
+  {
+#ifdef Z7_MD5_USE_DATA32_ARRAY
+    UInt32 data32[MD5_NUM_BLOCK_WORDS];
+    {
+#define LOAD_data32_x4(i) { \
+      data32[i    ] = LOAD_DATA(i    ); \
+      data32[i + 1] = LOAD_DATA(i + 1); \
+      data32[i + 2] = LOAD_DATA(i + 2); \
+      data32[i + 3] = LOAD_DATA(i + 3); }
+#if 1
+      LOAD_data32_x4 (0 * 4)
+      LOAD_data32_x4 (1 * 4)
+      LOAD_data32_x4 (2 * 4)
+      LOAD_data32_x4 (3 * 4)
+#else
+      unsigned i;
+      for (i = 0; i < MD5_NUM_BLOCK_WORDS; i += 4)
+      {
+        LOAD_data32_x4(i)
+      }
+#endif
+    }
+#endif
+
+    R16 (F1, 0, 1,  7,12,17,22, 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
+                                0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
+                                0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
+                                0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821)
+    R16 (F2, 1, 5,  5, 9,14,20, 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
+                                0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
+                                0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
+                                0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a)
+    R16 (F3, 5, 3,  4,11,16,23, 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
+                                0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
+                                0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
+                                0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665)
+    R16 (F4, 0, 7,  6,10,15,21, 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
+                                0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
+                                0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
+                                0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391)
+
+    a += state[0];
+    b += state[1];
+    c += state[2];
+    d += state[3];
+    
+    state[0] = a;
+    state[1] = b;
+    state[2] = c;
+    state[3] = d;
+    
+    data += MD5_BLOCK_SIZE;
+  }
+  while (--numBlocks);
+}
+
+
+#define Md5_UpdateBlock(p) MD5_UPDATE_BLOCKS(p)(p->state, p->buffer, 1)
+
+void Md5_Update(CMd5 *p, const Byte *data, size_t size)
+{
+  if (size == 0)
+    return;
+  {
+    const unsigned pos = (unsigned)p->count & (MD5_BLOCK_SIZE - 1);
+    const unsigned num = MD5_BLOCK_SIZE - pos;
+    p->count += size;
+    if (num > size)
+    {
+      memcpy(p->buffer + pos, data, size);
+      return;
+    }
+    if (pos != 0)
+    {
+      size -= num;
+      memcpy(p->buffer + pos, data, num);
+      data += num;
+      Md5_UpdateBlock(p);
+    }
+  }
+  {
+    const size_t numBlocks = size >> 6;
+    if (numBlocks)
+    MD5_UPDATE_BLOCKS(p)(p->state, data, numBlocks);
+    size &= MD5_BLOCK_SIZE - 1;
+    if (size == 0)
+      return;
+    data += (numBlocks << 6);
+    memcpy(p->buffer, data, size);
+  }
+}
+
+
+void Md5_Final(CMd5 *p, Byte *digest)
+{
+  unsigned pos = (unsigned)p->count & (MD5_BLOCK_SIZE - 1);
+  p->buffer[pos++] = 0x80;
+  if (pos > (MD5_BLOCK_SIZE - 4 * 2))
+  {
+    while (pos != MD5_BLOCK_SIZE) { p->buffer[pos++] = 0; }
+    // memset(&p->buf.buffer[pos], 0, MD5_BLOCK_SIZE - pos);
+    Md5_UpdateBlock(p);
+    pos = 0;
+  }
+  memset(&p->buffer[pos], 0, (MD5_BLOCK_SIZE - 4 * 2) - pos);
+  {
+    const UInt64 numBits = p->count << 3;
+#if defined(MY_CPU_LE_UNALIGN)
+    SetUi64 (p->buffer + MD5_BLOCK_SIZE - 4 * 2, numBits)
+#else
+    SetUi32a(p->buffer + MD5_BLOCK_SIZE - 4 * 2, (UInt32)(numBits))
+    SetUi32a(p->buffer + MD5_BLOCK_SIZE - 4 * 1, (UInt32)(numBits >> 32))
+#endif
+  }
+  Md5_UpdateBlock(p);
+
+  SetUi32(digest,      p->state[0])
+  SetUi32(digest + 4,  p->state[1])
+  SetUi32(digest + 8,  p->state[2])
+  SetUi32(digest + 12, p->state[3])
+  
+  Md5_Init(p);
+}
+
+#undef R1
+#undef R4
+#undef R16
+#undef D
+#undef LOAD_DATA
+#undef LOAD_data32_x4
+#undef F1
+#undef F2
+#undef F3
+#undef F4

package/vendor/7zip/C/Md5.h

@@ -0,0 +1,34 @@
+/* Md5.h -- MD5 Hash
+: Igor Pavlov : Public domain */
+
+#ifndef ZIP7_INC_MD5_H
+#define ZIP7_INC_MD5_H
+
+#include "7zTypes.h"
+
+EXTERN_C_BEGIN
+
+#define MD5_NUM_BLOCK_WORDS  16
+#define MD5_NUM_DIGEST_WORDS  4
+
+#define MD5_BLOCK_SIZE   (MD5_NUM_BLOCK_WORDS * 4)
+#define MD5_DIGEST_SIZE  (MD5_NUM_DIGEST_WORDS * 4)
+
+typedef struct
+{
+  UInt64 count;
+  UInt64 _pad_1;
+  // we want 16-bytes alignment here
+  UInt32 state[MD5_NUM_DIGEST_WORDS];
+  UInt64 _pad_2[4];
+  // we want 64-bytes alignment here
+  Byte buffer[MD5_BLOCK_SIZE];
+} CMd5;
+
+void Md5_Init(CMd5 *p);
+void Md5_Update(CMd5 *p, const Byte *data, size_t size);
+void Md5_Final(CMd5 *p, Byte *digest);
+
+EXTERN_C_END
+
+#endif