7zip-native 0.0.0-stage → 0.0.5

package/vendor/7zip/CPP/7zip/Compress/XpressDecoder.cpp

@@ -0,0 +1,399 @@
+// XpressDecoder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+#include "../../../C/RotateDefs.h"
+
+#include "HuffmanDecoder.h"
+#include "XpressDecoder.h"
+
+#ifdef MY_CPU_LE_UNALIGN
+  #define Z7_XPRESS_DEC_USE_UNALIGNED_COPY
+#endif
+
+#ifdef Z7_XPRESS_DEC_USE_UNALIGNED_COPY
+
+  #define COPY_CHUNK_SIZE 16
+
+    #define COPY_CHUNK_4_2(dest, src) \
+    { \
+      ((UInt32 *)(void *)dest)[0] = ((const UInt32 *)(const void *)src)[0]; \
+      ((UInt32 *)(void *)dest)[1] = ((const UInt32 *)(const void *)src)[1]; \
+      src += 4 * 2; \
+      dest += 4 * 2; \
+    }
+
+  /* sse2 doesn't help here in GCC and CLANG.
+     so we disabled sse2 here */
+#if 0
+  #if defined(MY_CPU_AMD64)
+    #define Z7_XPRESS_DEC_USE_SSE2
+  #elif defined(MY_CPU_X86)
+    #if defined(_MSC_VER) && _MSC_VER >= 1300 && defined(_M_IX86_FP) && (_M_IX86_FP >= 2) \
+      || defined(__SSE2__) \
+      // || 1 == 1  // for debug only
+      #define Z7_XPRESS_DEC_USE_SSE2
+    #endif
+  #endif
+#endif
+
+  #if defined(MY_CPU_ARM64)
+  #include <arm_neon.h>
+    #define COPY_OFFSET_MIN  16
+    #define COPY_CHUNK1(dest, src) \
+    { \
+      vst1q_u8((uint8_t *)(void *)dest, \
+      vld1q_u8((const uint8_t *)(const void *)src)); \
+      src += 16; \
+      dest += 16; \
+    }
+    
+    #define COPY_CHUNK(dest, src) \
+    { \
+      COPY_CHUNK1(dest, src) \
+      if (dest >= dest_lim) break; \
+      COPY_CHUNK1(dest, src) \
+    }
+
+  #elif defined(Z7_XPRESS_DEC_USE_SSE2)
+    #include <emmintrin.h> // sse2
+    #define COPY_OFFSET_MIN  16
+
+    #define COPY_CHUNK1(dest, src) \
+    { \
+      _mm_storeu_si128((__m128i *)(void *)dest, \
+      _mm_loadu_si128((const __m128i *)(const void *)src)); \
+      src += 16; \
+      dest += 16; \
+    }
+
+    #define COPY_CHUNK(dest, src) \
+    { \
+      COPY_CHUNK1(dest, src) \
+      if (dest >= dest_lim) break; \
+      COPY_CHUNK1(dest, src) \
+    }
+
+  #elif defined(MY_CPU_64BIT)
+    #define COPY_OFFSET_MIN  8
+
+    #define COPY_CHUNK(dest, src) \
+    { \
+      ((UInt64 *)(void *)dest)[0] = ((const UInt64 *)(const void *)src)[0]; \
+      ((UInt64 *)(void *)dest)[1] = ((const UInt64 *)(const void *)src)[1]; \
+      src += 8 * 2; \
+      dest += 8 * 2; \
+    }
+
+  #else
+    #define COPY_OFFSET_MIN  4
+
+    #define COPY_CHUNK(dest, src) \
+    { \
+      COPY_CHUNK_4_2(dest, src); \
+      COPY_CHUNK_4_2(dest, src); \
+    }
+
+  #endif
+#endif
+
+
+#ifndef COPY_CHUNK_SIZE
+    #define COPY_OFFSET_MIN  4
+    #define COPY_CHUNK_SIZE  8
+    #define COPY_CHUNK_2(dest, src) \
+    { \
+      const Byte a0 = src[0]; \
+      const Byte a1 = src[1]; \
+      dest[0] = a0; \
+      dest[1] = a1; \
+      src += 2; \
+      dest += 2; \
+    }
+    #define COPY_CHUNK(dest, src) \
+    { \
+      COPY_CHUNK_2(dest, src) \
+      COPY_CHUNK_2(dest, src) \
+      COPY_CHUNK_2(dest, src) \
+      COPY_CHUNK_2(dest, src) \
+    }
+#endif
+
+
+#define COPY_CHUNKS \
+{ \
+  Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE \
+  do { COPY_CHUNK(dest, src) } \
+  while (dest < dest_lim); \
+}
+
+
+static
+Z7_FORCE_INLINE
+// Z7_ATTRIB_NO_VECTOR
+void CopyMatch_1(Byte *dest, const Byte *dest_lim)
+{
+      const unsigned b0 = dest[-1];
+      {
+#if defined(Z7_XPRESS_DEC_USE_UNALIGNED_COPY) && (COPY_CHUNK_SIZE == 16)
+        #if defined(MY_CPU_64BIT)
+        {
+          const UInt64 v64 = (UInt64)b0 * 0x0101010101010101;
+          Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
+          do
+          {
+            ((UInt64 *)(void *)dest)[0] = v64;
+            ((UInt64 *)(void *)dest)[1] = v64;
+            dest += 16;
+          }
+          while (dest < dest_lim);
+        }
+        #else
+        {
+          UInt32 v = b0;
+          v |= v << 8;
+          v |= v << 16;
+          do
+          {
+            ((UInt32 *)(void *)dest)[0] = v;
+            ((UInt32 *)(void *)dest)[1] = v;
+            dest += 8;
+            ((UInt32 *)(void *)dest)[0] = v;
+            ((UInt32 *)(void *)dest)[1] = v;
+            dest += 8;
+          }
+          while (dest < dest_lim);
+        }
+        #endif
+#else
+        do
+        {
+          dest[0] = (Byte)b0;
+          dest[1] = (Byte)b0;
+          dest += 2;
+          dest[0] = (Byte)b0;
+          dest[1] = (Byte)b0;
+          dest += 2;
+        }
+        while (dest < dest_lim);
+#endif
+      }
+}
+
+
+// (offset != 1)
+static
+Z7_FORCE_INLINE
+// Z7_ATTRIB_NO_VECTOR
+void CopyMatch_Non1(Byte *dest, size_t offset, const Byte *dest_lim)
+{
+  const Byte *src = dest - offset;
+  {
+    // (COPY_OFFSET_MIN >= 4)
+    if (offset >= COPY_OFFSET_MIN)
+    {
+      COPY_CHUNKS
+      // return;
+    }
+    else
+#if (COPY_OFFSET_MIN > 4)
+    #if COPY_CHUNK_SIZE < 8
+      #error Stop_Compiling_Bad_COPY_CHUNK_SIZE
+    #endif
+    if (offset >= 4)
+    {
+      Z7_PRAGMA_OPT_DISABLE_LOOP_UNROLL_VECTORIZE
+      do
+      {
+        COPY_CHUNK_4_2(dest, src)
+        #if COPY_CHUNK_SIZE != 16
+          if (dest >= dest_lim) break;
+        #endif
+        COPY_CHUNK_4_2(dest, src)
+      }
+      while (dest < dest_lim);
+      // return;
+    }
+    else
+#endif
+    {
+      // (offset < 4)
+      if (offset == 2)
+      {
+#if defined(Z7_XPRESS_DEC_USE_UNALIGNED_COPY)
+        UInt32 w0 = GetUi16(src);
+        w0 += w0 << 16;
+        do
+        {
+          SetUi32(dest, w0)
+          dest += 4;
+        }
+        while (dest < dest_lim);
+#else
+        const unsigned b0 = src[0];
+        const Byte b1 = src[1];
+        do
+        {
+          dest[0] = (Byte)b0;
+          dest[1] = b1;
+          dest += 2;
+        }
+        while (dest < dest_lim);
+#endif
+      }
+      else // (offset == 3)
+      {
+        const unsigned b0 = src[0];
+#if defined(Z7_XPRESS_DEC_USE_UNALIGNED_COPY)
+        const unsigned w1 = GetUi16(src + 1);
+        do
+        {
+          dest[0] = (Byte)b0;
+          SetUi16(dest + 1, (UInt16)w1)
+          dest += 3;
+        }
+        while (dest < dest_lim);
+#else
+        const Byte b1 = src[1];
+        const Byte b2 = src[2];
+        do
+        {
+          dest[0] = (Byte)b0;
+          dest[1] = b1;
+          dest[2] = b2;
+          dest += 3;
+        }
+        while (dest < dest_lim);
+#endif
+      }
+    }
+  }
+}
+
+
+namespace NCompress {
+namespace NXpress {
+
+#define BIT_STREAM_NORMALIZE \
+    if (BitPos > 16) { \
+      if (in >= lim) return S_FALSE; \
+      BitPos -= 16; \
+      Value |= (UInt32)GetUi16(in) << BitPos; \
+      in += 2; }
+
+#define MOVE_POS(bs, numBits) \
+    BitPos += (unsigned)numBits; \
+    Value <<= numBits; \
+
+
+static const unsigned kNumHuffBits = 15;
+static const unsigned kNumTableBits = 10;
+static const unsigned kNumLenBits = 4;
+static const unsigned kLenMask = (1 << kNumLenBits) - 1;
+static const unsigned kNumPosSlots = 16;
+static const unsigned kNumSyms = 256 + (kNumPosSlots << kNumLenBits);
+
+HRESULT Decode_WithExceedWrite(const Byte *in, size_t inSize, Byte *out, size_t outSize)
+{
+  NCompress::NHuffman::CDecoder<kNumHuffBits, kNumSyms, kNumTableBits> huff;
+  
+  if (inSize < kNumSyms / 2 + 4)
+    return S_FALSE;
+  {
+    Byte levels[kNumSyms];
+    for (unsigned i = 0; i < kNumSyms / 2; i++)
+    {
+      const unsigned b = in[i];
+      levels[(size_t)i * 2    ] = (Byte)(b & 0xf);
+      levels[(size_t)i * 2 + 1] = (Byte)(b >> 4);
+    }
+    if (!huff.Build(levels, NHuffman::k_BuildMode_Full))
+      return S_FALSE;
+  }
+
+  UInt32 Value;
+  unsigned BitPos;  // how many bits in (Value) were processed
+
+  const Byte *lim = in + inSize - 1;  // points to last byte
+  in += kNumSyms / 2;
+#ifdef MY_CPU_LE_UNALIGN
+  Value = GetUi32(in);
+  Value = rotlFixed(Value, 16);
+#else
+  Value = ((UInt32)GetUi16(in) << 16) | GetUi16(in + 2);
+#endif
+    
+  in += 4;
+  BitPos = 0;
+  Byte *dest = out;
+  const Byte *outLim = out + outSize;
+
+  for (;;)
+  {
+    unsigned sym;
+    Z7_HUFF_DECODE_VAL_IN_HIGH32(sym, &huff, kNumHuffBits, kNumTableBits,
+        Value, Z7_HUFF_DECODE_ERROR_SYM_CHECK_NO, {}, MOVE_POS, {}, bs)
+    // 0 < BitPos <= 31
+    BIT_STREAM_NORMALIZE
+    // 0 < BitPos <= 16
+
+    if (dest >= outLim)
+      return (sym == 256 && Value == 0 && in == lim + 1) ? S_OK : S_FALSE;
+
+    if (sym < 256)
+      *dest++ = (Byte)sym;
+    else
+    {
+      const unsigned distBits = (unsigned)(Byte)sym >> kNumLenBits; // (sym - 256) >> kNumLenBits;
+      UInt32 len = (UInt32)(sym & kLenMask);
+      
+      if (len == kLenMask)
+      {
+        if (in > lim)
+          return S_FALSE;
+        // here we read input bytes in out-of-order related to main input stream (bits in Value):
+        len = *in++;
+        if (len == 0xff)
+        {
+          if (in >= lim)
+            return S_FALSE;
+          len = GetUi16(in);
+          in += 2;
+        }
+        else
+          len += kLenMask;
+      }
+
+      len += 3;
+      if (len > (size_t)(outLim - dest))
+        return S_FALSE;
+
+      if (distBits == 0)
+      {
+        // d == 1
+        if (dest == out)
+          return S_FALSE;
+        Byte *destTemp = dest;
+        dest += len;
+        CopyMatch_1(destTemp, dest);
+      }
+      else
+      {
+        unsigned d = (unsigned)(Value >> (32 - distBits));
+        MOVE_POS(bs, distBits)
+        d += 1u << distBits;
+        // 0 < BitPos <= 31
+        BIT_STREAM_NORMALIZE
+        // 0 < BitPos <= 16
+        if (d > (size_t)(dest - out))
+          return S_FALSE;
+        Byte *destTemp = dest;
+        dest += len;
+        CopyMatch_Non1(destTemp, d, dest);
+      }
+    }
+  }
+}
+
+}}

package/vendor/7zip/CPP/7zip/Compress/XpressDecoder.h

@@ -0,0 +1,18 @@
+// XpressDecoder.h
+
+#ifndef ZIP7_INC_XPRESS_DECODER_H
+#define ZIP7_INC_XPRESS_DECODER_H
+
+#include "../../Common/MyTypes.h"
+
+namespace NCompress {
+namespace NXpress {
+
+// (out) buffer size must be larger than (outSize) for the following value:
+const unsigned kAdditionalOutputBufSize = 32;
+
+HRESULT Decode_WithExceedWrite(const Byte *in, size_t inSize, Byte *out, size_t outSize);
+
+}}
+
+#endif

package/vendor/7zip/CPP/7zip/Compress/XzDecoder.cpp

@@ -0,0 +1,151 @@
+// XzDecoder.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/Alloc.h"
+
+#include "../Common/CWrappers.h"
+
+#include "XzDecoder.h"
+
+namespace NCompress {
+namespace NXz {
+
+#define RET_IF_WRAP_ERROR_CONFIRMED(wrapRes, sRes, sResErrorCode) \
+  if (wrapRes != S_OK && sRes == sResErrorCode) return wrapRes;
+
+#define RET_IF_WRAP_ERROR(wrapRes, sRes, sResErrorCode) \
+  if (wrapRes != S_OK /* && (sRes == SZ_OK || sRes == sResErrorCode) */) return wrapRes;
+
+static HRESULT SResToHRESULT_Code(SRes res) throw()
+{
+  if (res < 0)
+    return res;
+  switch (res)
+  {
+    case SZ_OK: return S_OK;
+    case SZ_ERROR_MEM: return E_OUTOFMEMORY;
+    case SZ_ERROR_UNSUPPORTED: return E_NOTIMPL;
+    default: break;
+  }
+  return S_FALSE;
+}
+
+
+HRESULT CDecoder::Decode(ISequentialInStream *seqInStream, ISequentialOutStream *outStream,
+    const UInt64 *outSizeLimit, bool finishStream, ICompressProgressInfo *progress)
+{
+  MainDecodeSRes = SZ_OK;
+  MainDecodeSRes_wasUsed = false;
+  XzStatInfo_Clear(&Stat);
+
+  if (!xz)
+  {
+    xz = XzDecMt_Create(&g_Alloc, &g_MidAlloc);
+    if (!xz)
+      return E_OUTOFMEMORY;
+  }
+
+  CXzDecMtProps props;
+  XzDecMtProps_Init(&props);
+
+  int isMT = False;
+
+  #ifndef Z7_ST
+  {
+    props.numThreads = 1;
+    const UInt32 numThreads = _numThreads;
+
+    if (_tryMt && numThreads > 1)
+    {
+      size_t memUsage = (size_t)_memUsage;
+      if (memUsage != _memUsage)
+        memUsage = (size_t)0 - 1;
+      props.memUseMax = memUsage;
+      isMT = (numThreads > 1);
+    }
+
+    props.numThreads = numThreads;
+  }
+  #endif
+
+  CSeqInStreamWrap inWrap;
+  CSeqOutStreamWrap outWrap;
+  CCompressProgressWrap progressWrap;
+
+  inWrap.Init(seqInStream);
+  outWrap.Init(outStream);
+  progressWrap.Init(progress);
+
+  SRes res = XzDecMt_Decode(xz,
+      &props,
+      outSizeLimit, finishStream,
+      &outWrap.vt,
+      &inWrap.vt,
+      &Stat,
+      &isMT,
+      progress ? &progressWrap.vt : NULL);
+
+  MainDecodeSRes = res;
+
+  #ifndef Z7_ST
+  // _tryMt = isMT;
+  #endif
+
+  RET_IF_WRAP_ERROR(outWrap.Res, res, SZ_ERROR_WRITE)
+  RET_IF_WRAP_ERROR(progressWrap.Res, res, SZ_ERROR_PROGRESS)
+  RET_IF_WRAP_ERROR_CONFIRMED(inWrap.Res, res, SZ_ERROR_READ)
+
+  // return E_OUTOFMEMORY; // for debug check
+
+  MainDecodeSRes_wasUsed = true;
+
+  if (res == SZ_OK && finishStream)
+  {
+    /*
+    if (inSize && *inSize != Stat.PhySize)
+      res = SZ_ERROR_DATA;
+    */
+    if (outSizeLimit && *outSizeLimit != outWrap.Processed)
+      res = SZ_ERROR_DATA;
+  }
+
+  return SResToHRESULT_Code(res);
+}
+
+
+Z7_COM7F_IMF(CComDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
+    const UInt64 * /* inSize */, const UInt64 *outSize, ICompressProgressInfo *progress))
+{
+  return Decode(inStream, outStream, outSize, _finishStream, progress);
+}
+
+Z7_COM7F_IMF(CComDecoder::SetFinishMode(UInt32 finishMode))
+{
+  _finishStream = (finishMode != 0);
+  return S_OK;
+}
+
+Z7_COM7F_IMF(CComDecoder::GetInStreamProcessedSize(UInt64 *value))
+{
+  *value = Stat.InSize;
+  return S_OK;
+}
+
+#ifndef Z7_ST
+
+Z7_COM7F_IMF(CComDecoder::SetNumberOfThreads(UInt32 numThreads))
+{
+  _numThreads = numThreads;
+  return S_OK;
+}
+
+Z7_COM7F_IMF(CComDecoder::SetMemLimit(UInt64 memUsage))
+{
+  _memUsage = memUsage;
+  return S_OK;
+}
+
+#endif
+
+}}

package/vendor/7zip/CPP/7zip/Compress/XzDecoder.h

@@ -0,0 +1,86 @@
+// XzDecoder.h
+
+#ifndef ZIP7_INC_XZ_DECODER_H
+#define ZIP7_INC_XZ_DECODER_H
+
+#include "../../../C/Xz.h"
+
+#include "../../Common/MyCom.h"
+
+#include "../ICoder.h"
+
+namespace NCompress {
+namespace NXz {
+
+struct CDecoder
+{
+  CXzDecMtHandle xz;
+  int _tryMt;
+  UInt32 _numThreads;
+  UInt64 _memUsage;
+
+  SRes MainDecodeSRes; // it's not HRESULT
+  bool MainDecodeSRes_wasUsed;
+  CXzStatInfo Stat;
+
+  CDecoder():
+      xz(NULL),
+      _tryMt(True),
+      _numThreads(1),
+      _memUsage((UInt64)(sizeof(size_t)) << 28),
+      MainDecodeSRes(SZ_OK),
+      MainDecodeSRes_wasUsed(false)
+    {}
+  
+  ~CDecoder()
+  {
+    if (xz)
+      XzDecMt_Destroy(xz);
+  }
+
+  /* Decode() can return S_OK, if there is data after good xz streams, and that data is not new xz stream.
+     check also (Stat.DataAfterEnd) flag */
+
+  HRESULT Decode(ISequentialInStream *seqInStream, ISequentialOutStream *outStream,
+      const UInt64 *outSizeLimit, bool finishStream, ICompressProgressInfo *compressProgress);
+};
+
+
+class CComDecoder Z7_final:
+  public ICompressCoder,
+  public ICompressSetFinishMode,
+  public ICompressGetInStreamProcessedSize,
+ #ifndef Z7_ST
+  public ICompressSetCoderMt,
+  public ICompressSetMemLimit,
+ #endif
+  public CMyUnknownImp,
+  public CDecoder
+{
+  Z7_COM_QI_BEGIN2(ICompressCoder)
+  Z7_COM_QI_ENTRY(ICompressSetFinishMode)
+  Z7_COM_QI_ENTRY(ICompressGetInStreamProcessedSize)
+ #ifndef Z7_ST
+  Z7_COM_QI_ENTRY(ICompressSetCoderMt)
+  Z7_COM_QI_ENTRY(ICompressSetMemLimit)
+ #endif
+  Z7_COM_QI_END
+  Z7_COM_ADDREF_RELEASE
+
+  Z7_IFACE_COM7_IMP(ICompressCoder)
+  Z7_IFACE_COM7_IMP(ICompressSetFinishMode)
+  Z7_IFACE_COM7_IMP(ICompressGetInStreamProcessedSize)
+ #ifndef Z7_ST
+  Z7_IFACE_COM7_IMP(ICompressSetCoderMt)
+  Z7_IFACE_COM7_IMP(ICompressSetMemLimit)
+ #endif
+
+  bool _finishStream;
+
+public:
+  CComDecoder(): _finishStream(false) {}
+};
+
+}}
+
+#endif