seven-zip 1.4.2 → 1.7.0.rc1

data/ext/p7zip/CPP/7zip/Compress/Lzham/lzhamdecomp/lzham_core.h

@@ -0,0 +1,303 @@
+// File: lzham_core.h
+// See Copyright Notice and license at the end of include/lzham.h
+#pragma once
+
+#if defined(_MSC_VER)
+   #pragma warning (disable: 4127) // conditional expression is constant
+#endif
+
+// If LZHAM_ERROR_LOGGING is 1, LZHAM will write a short internal error codes to stderr when something goes wrong. These codes can be very useful for postmortem debugging.
+#ifndef LZHAM_ERROR_LOGGING
+    #define LZHAM_ERROR_LOGGING 0
+#endif
+
+// If LZHAM_VERBOSE_ERROR_LOGGING, LZHAM will also write the function, file and line # along with the error code to stderr.
+#ifndef LZHAM_VERBOSE_ERROR_LOGGING
+    #define LZHAM_VERBOSE_ERROR_LOGGING 0
+#endif
+
+// Enable this when first porting to new platforms - disables all threading and atomic ops in compressor:
+//#define LZHAM_ANSI_CPLUSPLUS 1
+
+#if defined(__FreeBSD__) || defined(__NetBSD__)
+   // TODO: I compile and do minimal testing on FreeBSD v10.1 x86, but I haven't enabled threading there yet. (Should be easy because OSX is already supported with threading.)
+   #define LZHAM_ANSI_CPLUSPLUS 1
+#endif
+
+#if defined(__APPLE__) && defined(__MACH__)
+   // Apple OSX and iOS
+   #include <TargetConditionals.h>
+#endif
+
+#if defined(_XBOX) && !defined(LZHAM_ANSI_CPLUSPLUS)
+   // --- X360 - This hasn't been tested since early an alpha.
+   #include <xtl.h>
+   #define _HAS_EXCEPTIONS 0
+   #define NOMINMAX
+
+   #define LZHAM_PLATFORM_X360 1
+   #define LZHAM_USE_WIN32_API 1
+   #define LZHAM_USE_WIN32_ATOMIC_FUNCTIONS 1
+   #define LZHAM_64BIT_POINTERS 0
+   #define LZHAM_CPU_HAS_64BIT_REGISTERS 1
+   #define LZHAM_BIG_ENDIAN_CPU 1
+   #define LZHAM_USE_UNALIGNED_INT_LOADS 1
+   #define LZHAM_RESTRICT __restrict
+   #define LZHAM_FORCE_INLINE __forceinline
+   #define LZHAM_NOTE_UNUSED(x) (void)x
+
+   #define LZHAM_PRIi64 "I64i"
+   #define LZHAM_PRIu64 "I64u"
+
+#elif defined(WIN32) && !defined(LZHAM_ANSI_CPLUSPLUS)
+   // --- Windows: MSVC or MinGW, x86 or x64, Win32 API's for threading and Win32 Interlocked API's or GCC built-ins for atomic ops.
+   #ifdef NDEBUG
+      // Ensure checked iterators are disabled.
+      #define _SECURE_SCL 0
+      #define _HAS_ITERATOR_DEBUGGING 0
+   #endif
+   #ifndef _DLL
+      // If we're using the DLL form of the run-time libs, we're also going to be enabling exceptions because we'll be building CLR apps.
+      // Otherwise, we disable exceptions for a small speed boost.
+      #define _HAS_EXCEPTIONS 0
+   #endif
+   #define NOMINMAX
+
+    #ifndef _WIN32_WINNT
+      #define _WIN32_WINNT 0x500
+   #endif
+
+   #ifndef WIN32_LEAN_AND_MEAN
+      #define WIN32_LEAN_AND_MEAN
+   #endif
+
+   #include <windows.h>
+
+   #define LZHAM_USE_WIN32_API 1
+
+   #if defined(__MINGW32__) || defined(__MINGW64__)
+      #define LZHAM_USE_GCC_ATOMIC_BUILTINS 1
+   #else
+      #define LZHAM_USE_WIN32_ATOMIC_FUNCTIONS 1
+   #endif
+
+   #define LZHAM_PLATFORM_PC 1
+
+   #ifdef _WIN64
+      #define LZHAM_PLATFORM_PC_X64 1
+      #define LZHAM_64BIT_POINTERS 1
+      #define LZHAM_CPU_HAS_64BIT_REGISTERS 1
+      #define LZHAM_LITTLE_ENDIAN_CPU 1
+   #else
+      #define LZHAM_PLATFORM_PC_X86 1
+      #define LZHAM_64BIT_POINTERS 0
+      #define LZHAM_CPU_HAS_64BIT_REGISTERS 0
+      #define LZHAM_LITTLE_ENDIAN_CPU 1
+   #endif
+
+   #define LZHAM_USE_UNALIGNED_INT_LOADS 1
+   #define LZHAM_RESTRICT __restrict
+   #define LZHAM_FORCE_INLINE __forceinline
+
+   #if defined(_MSC_VER) || defined(__MINGW32__) || defined(__MINGW64__)
+      #define LZHAM_USE_MSVC_INTRINSICS 1
+   #endif
+
+   #define LZHAM_NOTE_UNUSED(x) (void)x
+
+   #define LZHAM_PRIi64 "I64i"
+   #define LZHAM_PRIu64 "I64u"
+
+#elif defined(__APPLE__) && !defined(LZHAM_ANSI_CPLUSPLUS)
+   // --- Apple: iOS or OSX
+   #if (TARGET_IPHONE_SIMULATOR == 1) || (TARGET_OS_IPHONE == 1)
+      #define LZHAM_PLATFORM_PC 0
+
+      #if defined(_WIN64) || defined(__MINGW64__) || defined(_LP64) || defined(__LP64__)
+         #define LZHAM_PLATFORM_PC_X64 0
+         #define LZHAM_64BIT_POINTERS 1
+         #define LZHAM_CPU_HAS_64BIT_REGISTERS 1
+      #else
+         #define LZHAM_PLATFORM_PC_X86 0
+         #define LZHAM_64BIT_POINTERS 0
+         #define LZHAM_CPU_HAS_64BIT_REGISTERS 0
+      #endif
+
+      #define LZHAM_USE_UNALIGNED_INT_LOADS 0
+
+      #if __BIG_ENDIAN__
+         #define LZHAM_BIG_ENDIAN_CPU 1
+      #else
+         #define LZHAM_LITTLE_ENDIAN_CPU 1
+      #endif
+
+      #define LZHAM_USE_PTHREADS_API 1
+      #define LZHAM_USE_GCC_ATOMIC_BUILTINS 1
+
+      #define LZHAM_RESTRICT
+
+      #if defined(__clang__)
+         #define LZHAM_FORCE_INLINE inline
+      #else
+         #define LZHAM_FORCE_INLINE inline __attribute__((__always_inline__,__gnu_inline__))
+      #endif
+
+      #define LZHAM_NOTE_UNUSED(x) (void)x
+
+      #define LZHAM_PRIi64 PRIi64
+      #define LZHAM_PRIu64 PRIu64
+
+   #elif (TARGET_OS_MAC == 1)
+      #define LZHAM_PLATFORM_PC 1
+
+      #if defined(_WIN64) || defined(__MINGW64__) || defined(_LP64) || defined(__LP64__)
+         #define LZHAM_PLATFORM_PC_X64 1
+         #define LZHAM_64BIT_POINTERS 1
+         #define LZHAM_CPU_HAS_64BIT_REGISTERS 1
+      #else
+         #define LZHAM_PLATFORM_PC_X86 1
+         #define LZHAM_64BIT_POINTERS 0
+         #define LZHAM_CPU_HAS_64BIT_REGISTERS 0
+      #endif
+
+      #define LZHAM_USE_UNALIGNED_INT_LOADS 1
+
+      #if __BIG_ENDIAN__
+         #define LZHAM_BIG_ENDIAN_CPU 1
+      #else
+         #define LZHAM_LITTLE_ENDIAN_CPU 1
+      #endif
+
+      #define LZHAM_USE_PTHREADS_API 1
+      #define LZHAM_USE_GCC_ATOMIC_BUILTINS 1
+
+      #define LZHAM_RESTRICT
+
+      #if defined(__clang__)
+         #define LZHAM_FORCE_INLINE inline
+      #else
+         #define LZHAM_FORCE_INLINE inline __attribute__((__always_inline__,__gnu_inline__))
+      #endif
+
+      #define LZHAM_NOTE_UNUSED(x) (void)x
+
+      #define LZHAM_PRIi64 PRIi64
+      #define LZHAM_PRIu64 PRIu64
+   #elif
+      #error TODO: Unknown Apple target
+   #endif
+
+#elif (defined(__linux__) || defined(__CYGWIN__) ) && (defined(__i386__) || defined(__x86_64__)) && !defined(LZHAM_ANSI_CPLUSPLUS)
+   // --- Generic GCC/clang path for x86/x64, clang or GCC, Linux, OSX, FreeBSD or NetBSD, pthreads for threading, GCC built-ins for atomic ops.
+   #define LZHAM_PLATFORM_PC 1
+
+   #if defined(_LP64) || defined(__LP64__) || defined(__x86_64__)
+      // 64-bit build assumes pointers are always 64-bit
+      #define LZHAM_PLATFORM_PC_X64 1
+      #define LZHAM_64BIT_POINTERS 1
+      #define LZHAM_CPU_HAS_64BIT_REGISTERS 1
+   #else
+      #define LZHAM_PLATFORM_PC_X86 1
+      #define LZHAM_64BIT_POINTERS 0
+      #define LZHAM_CPU_HAS_64BIT_REGISTERS 0
+   #endif
+
+   #define LZHAM_USE_UNALIGNED_INT_LOADS 1
+
+   #if __BIG_ENDIAN__
+      #define LZHAM_BIG_ENDIAN_CPU 1
+   #else
+      #define LZHAM_LITTLE_ENDIAN_CPU 1
+   #endif
+
+   #define LZHAM_USE_PTHREADS_API 1
+   #define LZHAM_USE_GCC_ATOMIC_BUILTINS 1
+
+   #define LZHAM_RESTRICT
+
+   #if defined(__clang__)
+      #define LZHAM_FORCE_INLINE inline
+   #else
+      #define LZHAM_FORCE_INLINE inline __attribute__((__always_inline__,__gnu_inline__))
+   #endif
+
+   #define LZHAM_NOTE_UNUSED(x) (void)x
+
+   #define LZHAM_PRIi64 PRIi64
+   #define LZHAM_PRIu64 PRIu64
+#else
+
+#ifndef _MSC_VER
+   #warning Building as vanilla ANSI-C/C++, multi-threaded compression is disabled! Please configure lzhamdecomp/lzham_core.h.
+#endif
+
+   // --- Vanilla ANSI-C/C++
+   // No threading support, unaligned loads are NOT okay, no atomic ops.
+   #if defined(_WIN64) || defined(__MINGW64__) || defined(_LP64) || defined(__LP64__)
+      #define LZHAM_64BIT_POINTERS 1
+      #define LZHAM_CPU_HAS_64BIT_REGISTERS 1
+   #else
+      #define LZHAM_64BIT_POINTERS 0
+      #define LZHAM_CPU_HAS_64BIT_REGISTERS 0
+   #endif
+
+   #define LZHAM_USE_UNALIGNED_INT_LOADS 0
+
+   #if __BIG_ENDIAN__
+      #define LZHAM_BIG_ENDIAN_CPU 1
+   #else
+      #define LZHAM_LITTLE_ENDIAN_CPU 1
+   #endif
+
+   #define LZHAM_USE_GCC_ATOMIC_BUILTINS 0
+   #define LZHAM_USE_WIN32_ATOMIC_FUNCTIONS 0
+
+   #define LZHAM_RESTRICT
+   #define LZHAM_FORCE_INLINE inline
+
+   #define LZHAM_NOTE_UNUSED(x) (void)x
+
+   #define LZHAM_PRIi64 PRIi64
+   #define LZHAM_PRIu64 PRIu64
+#endif
+
+#if LZHAM_LITTLE_ENDIAN_CPU
+   const bool c_lzham_little_endian_platform = true;
+#else
+   const bool c_lzham_little_endian_platform = false;
+#endif
+
+const bool c_lzham_big_endian_platform = !c_lzham_little_endian_platform;
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+#if !defined(__APPLE__) && !defined(__FreeBSD__)
+#include <malloc.h>
+#endif
+#include <stdarg.h>
+#include <memory.h>
+#include <limits.h>
+#include <algorithm>
+#include <errno.h>
+
+#ifndef _MSC_VER
+   #ifndef __STDC_FORMAT_MACROS
+      #define __STDC_FORMAT_MACROS
+   #endif
+   // Needed for PRIi64 and PRIu64
+   #include <inttypes.h>
+#endif
+
+#include "lzham.h"
+#include "lzham_config.h"
+#include "lzham_types.h"
+#include "lzham_assert.h"
+#include "lzham_platform.h"
+
+#include "lzham_helpers.h"
+#include "lzham_traits.h"
+#include "lzham_mem.h"
+#include "lzham_math.h"
+#include "lzham_utils.h"
+#include "lzham_vector.h"

data/ext/p7zip/CPP/7zip/Compress/Lzham/lzhamdecomp/lzham_decomp.h

@@ -0,0 +1,37 @@
+// File: lzham_decomp.h
+// See Copyright Notice and license at the end of include/lzham.h
+#pragma once
+#include "lzham.h"
+
+namespace lzham
+{
+   void LZHAM_CDECL lzham_lib_set_memory_callbacks(lzham_realloc_func pRealloc, lzham_msize_func pMSize, void* pUser_data);
+   
+   lzham_decompress_state_ptr LZHAM_CDECL lzham_lib_decompress_init(const lzham_decompress_params *pParams);
+
+   lzham_decompress_state_ptr LZHAM_CDECL lzham_lib_decompress_reinit(lzham_decompress_state_ptr pState, const lzham_decompress_params *pParams);
+
+   lzham_uint32 LZHAM_CDECL lzham_lib_decompress_deinit(lzham_decompress_state_ptr pState);
+
+   lzham_decompress_status_t LZHAM_CDECL lzham_lib_decompress(
+      lzham_decompress_state_ptr pState,
+      const lzham_uint8 *pIn_buf, size_t *pIn_buf_size, 
+      lzham_uint8 *pOut_buf, size_t *pOut_buf_size,
+      lzham_bool no_more_input_bytes_flag);
+      
+   lzham_decompress_status_t LZHAM_CDECL lzham_lib_decompress_memory(const lzham_decompress_params *pParams, 
+      lzham_uint8* pDst_buf, size_t *pDst_len, 
+      const lzham_uint8* pSrc_buf, size_t src_len, lzham_uint32 *pAdler32);
+
+   int LZHAM_CDECL lzham_lib_z_inflateInit2(lzham_z_streamp pStream, int window_bits);
+   int LZHAM_CDECL lzham_lib_z_inflateInit(lzham_z_streamp pStream);
+   int LZHAM_CDECL lzham_lib_z_inflateReset(lzham_z_streamp pStream);
+   int LZHAM_CDECL lzham_lib_z_inflate(lzham_z_streamp pStream, int flush);
+   int LZHAM_CDECL lzham_lib_z_inflateEnd(lzham_z_streamp pStream);
+   int LZHAM_CDECL lzham_lib_z_uncompress(unsigned char *pDest, lzham_z_ulong *pDest_len, const unsigned char *pSource, lzham_z_ulong source_len);
+
+   const char * LZHAM_CDECL lzham_lib_z_error(int err);
+   lzham_z_ulong lzham_lib_z_adler32(lzham_z_ulong adler, const unsigned char *ptr, size_t buf_len);
+   lzham_z_ulong LZHAM_CDECL lzham_lib_z_crc32(lzham_z_ulong crc, const lzham_uint8 *ptr, size_t buf_len);
+
+} // namespace lzham

data/ext/p7zip/CPP/7zip/Compress/Lzham/lzhamdecomp/lzham_helpers.h

@@ -0,0 +1,54 @@
+// File: lzham_helpers.h
+// See Copyright Notice and license at the end of include/lzham.h
+#pragma once
+
+#define LZHAM_NO_COPY_OR_ASSIGNMENT_OP(c) c(const c&); c& operator= (const c&);
+
+namespace lzham
+{
+   namespace helpers
+   {
+      template<typename T> struct rel_ops
+      {
+         friend inline bool operator!=(const T& x, const T& y) { return (!(x == y)); }
+         friend inline bool operator> (const T& x, const T& y) { return (y < x); }
+         friend inline bool operator<=(const T& x, const T& y) { return (!(y < x)); }
+         friend inline bool operator>=(const T& x, const T& y) { return (!(x < y)); }
+      };
+
+      template <typename T>
+      inline T* construct(T* p)
+      {
+         return new (static_cast<void*>(p)) T;
+      }
+
+      template <typename T, typename U>
+      inline T* construct(T* p, const U& init)
+      {
+         return new (static_cast<void*>(p)) T(init);
+      }
+
+      template <typename T> 
+      inline void construct_array(T* p, uint n);
+      
+      template <typename T, typename U>
+      inline void construct_array(T* p, uint n, const U& init)
+      {
+         T* q = p + n;
+         for ( ; p != q; ++p)
+            new (static_cast<void*>(p)) T(init);
+      }
+
+      template <typename T>
+      inline void destruct(T* p)
+      {
+         LZHAM_NOTE_UNUSED(p);
+         p->~T();
+      }
+
+      template <typename T> 
+      inline void destruct_array(T* p, uint n);
+
+   }  // namespace helpers
+
+}  // namespace lzham

data/ext/p7zip/CPP/7zip/Compress/Lzham/lzhamdecomp/lzham_huffman_codes.cpp

@@ -0,0 +1,286 @@
+// File: huffman_codes.cpp
+// See Copyright Notice and license at the end of include/lzham.h
+#include "lzham_core.h"
+#include "lzham_huffman_codes.h"
+
+namespace lzham
+{
+   void code_size_histogram::init(uint num_syms, const uint8* pCodesizes)
+   {
+      const uint8 *p = pCodesizes;
+
+      for (uint i = num_syms >> 2; i; --i)
+      {
+         uint a = p[0]; 
+         uint b = p[1];
+         uint c = p[2];
+         uint d = p[3];
+         m_num_codes[a]++;
+         m_num_codes[b]++;
+         m_num_codes[c]++;
+         m_num_codes[d]++;
+         p += 4;
+      }
+
+      for (uint i = num_syms & 3; i; --i)
+         m_num_codes[*p++]++;
+
+      LZHAM_ASSERT(static_cast<uint>(p - pCodesizes) == num_syms);
+   }
+
+   struct sym_freq
+   {
+      uint m_freq;
+      uint16 m_left;
+      uint16 m_right;
+
+      inline bool operator< (const sym_freq& other) const
+      {
+         return m_freq > other.m_freq;
+      }
+   };
+   
+   static inline sym_freq* radix_sort_syms(uint num_syms, sym_freq* syms0, sym_freq* syms1)
+   {  
+      const uint cMaxPasses = 2;
+      uint hist[256 * cMaxPasses];
+            
+      memset(hist, 0, sizeof(hist[0]) * 256 * cMaxPasses);
+
+      {
+         sym_freq* p = syms0;
+         sym_freq* q = syms0 + (num_syms >> 1) * 2;
+
+         for ( ; p != q; p += 2)
+         {
+            const uint freq0 = p[0].m_freq;
+            const uint freq1 = p[1].m_freq;
+
+            hist[        freq0         & 0xFF]++;
+            hist[256 + ((freq0 >>  8) & 0xFF)]++;
+
+            hist[        freq1        & 0xFF]++;
+            hist[256 + ((freq1 >>  8) & 0xFF)]++;
+         }
+      
+         if (num_syms & 1)
+         {
+            const uint freq = p->m_freq;
+
+            hist[        freq        & 0xFF]++;
+            hist[256 + ((freq >>  8) & 0xFF)]++;
+         }
+      }
+      
+      sym_freq* pCur_syms = syms0;
+      sym_freq* pNew_syms = syms1;
+      
+      const uint total_passes = (hist[256] == num_syms) ? 1 : cMaxPasses;
+
+      for (uint pass = 0; pass < total_passes; pass++)
+      {
+         const uint* pHist = &hist[pass << 8];
+
+         uint offsets[256];
+
+         uint cur_ofs = 0;
+         for (uint i = 0; i < 256; i += 2)
+         {
+            offsets[i] = cur_ofs;
+            cur_ofs += pHist[i];
+
+            offsets[i+1] = cur_ofs;
+            cur_ofs += pHist[i+1];
+         }
+
+         const uint pass_shift = pass << 3;
+
+         sym_freq* p = pCur_syms;
+         sym_freq* q = pCur_syms + (num_syms >> 1) * 2;
+
+         for ( ; p != q; p += 2)
+         {
+            uint c0 = p[0].m_freq;
+            uint c1 = p[1].m_freq;
+            
+            if (pass)
+            {
+               c0 >>= 8;
+               c1 >>= 8;
+            }
+            
+            c0 &= 0xFF;
+            c1 &= 0xFF;
+
+            if (c0 == c1)
+            {
+               uint dst_offset0 = offsets[c0];
+
+               offsets[c0] = dst_offset0 + 2;
+
+               pNew_syms[dst_offset0] = p[0];
+               pNew_syms[dst_offset0 + 1] = p[1];
+            }
+            else
+            {
+               uint dst_offset0 = offsets[c0]++;
+               uint dst_offset1 = offsets[c1]++;
+
+               pNew_syms[dst_offset0] = p[0];
+               pNew_syms[dst_offset1] = p[1];
+            }
+         }
+
+         if (num_syms & 1)
+         {
+            uint c = ((p->m_freq) >> pass_shift) & 0xFF;
+
+            uint dst_offset = offsets[c];
+            offsets[c] = dst_offset + 1;
+
+            pNew_syms[dst_offset] = *p;
+         }
+
+         sym_freq* t = pCur_syms;
+         pCur_syms = pNew_syms;
+         pNew_syms = t;
+      }            
+
+#if LZHAM_ASSERTS_ENABLED
+      uint prev_freq = 0;
+      for (uint i = 0; i < num_syms; i++)
+      {
+         LZHAM_ASSERT(!(pCur_syms[i].m_freq < prev_freq));
+         prev_freq = pCur_syms[i].m_freq;
+      }
+#endif
+      
+      return pCur_syms;
+   }
+   
+   struct huffman_work_tables
+   {
+      enum { cMaxInternalNodes = cHuffmanMaxSupportedSyms };
+      
+      sym_freq syms0[cHuffmanMaxSupportedSyms + 1 + cMaxInternalNodes];
+      sym_freq syms1[cHuffmanMaxSupportedSyms + 1 + cMaxInternalNodes];
+
+#if !USE_CALCULATE_MINIMUM_REDUNDANCY                  
+      uint16 queue[cMaxInternalNodes];
+#endif      
+   };
+   
+   uint get_generate_huffman_codes_table_size()
+   {
+      return sizeof(huffman_work_tables);
+   }
+
+   // calculate_minimum_redundancy() written by Alistair Moffat, alistair@cs.mu.oz.au, Jyrki Katajainen, jyrki@diku.dk November 1996.
+   static void calculate_minimum_redundancy(int A[], int n) 
+	{
+		int root;                  /* next root node to be used */
+		int leaf;                  /* next leaf to be used */
+		int next;                  /* next value to be assigned */
+		int avbl;                  /* number of available nodes */
+		int used;                  /* number of internal nodes */
+		int dpth;                  /* current depth of leaves */
+
+		/* check for pathological cases */
+		if (n==0) { return; }
+		if (n==1) { A[0] = 0; return; }
+
+		/* first pass, left to right, setting parent pointers */
+		A[0] += A[1]; root = 0; leaf = 2;
+		for (next=1; next < n-1; next++) {
+			/* select first item for a pairing */
+			if (leaf>=n || A[root]<A[leaf]) {
+				A[next] = A[root]; A[root++] = next;
+			} else
+				A[next] = A[leaf++];
+
+			/* add on the second item */
+			if (leaf>=n || (root<next && A[root]<A[leaf])) {
+				A[next] += A[root]; A[root++] = next;
+			} else
+				A[next] += A[leaf++];
+		}
+
+		/* second pass, right to left, setting internal depths */
+		A[n-2] = 0;
+		for (next=n-3; next>=0; next--)
+			A[next] = A[A[next]]+1;
+
+		/* third pass, right to left, setting leaf depths */
+		avbl = 1; used = dpth = 0; root = n-2; next = n-1;
+		while (avbl>0) {
+			while (root>=0 && A[root]==dpth) {
+				used++; root--;
+			}
+			while (avbl>used) {
+				A[next--] = dpth; avbl--;
+			}
+			avbl = 2*used; dpth++; used = 0;
+		}
+   }
+
+   bool generate_huffman_codes(void* pContext, uint num_syms, const uint16* pFreq, uint8* pCodesizes, uint& max_code_size, uint& total_freq_ret, code_size_histogram &code_size_hist)
+   {
+      if ((!num_syms) || (num_syms > cHuffmanMaxSupportedSyms))
+         return false;
+                  
+      huffman_work_tables& state = *static_cast<huffman_work_tables*>(pContext);;
+            
+      uint max_freq = 0;
+      uint total_freq = 0;
+      
+      uint num_used_syms = 0;
+      for (uint i = 0; i < num_syms; i++)
+      {
+         uint freq = pFreq[i];
+         
+         if (!freq)
+            pCodesizes[i] = 0;
+         else
+         {
+            total_freq += freq;
+            max_freq = math::maximum(max_freq, freq);
+            
+            sym_freq& sf = state.syms0[num_used_syms];
+            sf.m_left = (uint16)i;
+            sf.m_right = cUINT16_MAX;
+            sf.m_freq = freq;
+            num_used_syms++;
+         }            
+      }
+      
+      total_freq_ret = total_freq;
+
+      if (num_used_syms == 1)
+      {
+         pCodesizes[state.syms0[0].m_left] = 1;
+         return true;
+      }
+
+      sym_freq* syms = radix_sort_syms(num_used_syms, state.syms0, state.syms1);
+      
+      int x[cHuffmanMaxSupportedSyms];
+      for (uint i = 0; i < num_used_syms; i++)
+         x[i] = syms[i].m_freq;
+      
+      calculate_minimum_redundancy(x, num_used_syms);
+      
+      uint max_len = 0;
+      for (uint i = 0; i < num_used_syms; i++)
+      {
+         uint len = x[i];
+         max_len = math::maximum(len, max_len);
+         code_size_hist.m_num_codes[LZHAM_MIN(len, (uint)code_size_histogram::cMaxUnlimitedHuffCodeSize)]++;
+         pCodesizes[syms[i].m_left] = static_cast<uint8>(len);
+      }
+      max_code_size = max_len;
+                  
+      return true;
+   }
+
+} // namespace lzham
+

data/ext/p7zip/CPP/7zip/Compress/Lzham/lzhamdecomp/lzham_huffman_codes.h

@@ -0,0 +1,32 @@
+// File: lzham_huffman_codes.h
+// See Copyright Notice and license at the end of include/lzham.h
+#pragma once
+
+namespace lzham
+{
+   //const uint cHuffmanMaxSupportedSyms = 600;
+   const uint cHuffmanMaxSupportedSyms = 1024;
+
+   const uint cMaxExpectedHuffCodeSize = 16;
+
+   struct code_size_histogram
+   {
+      enum { cMaxUnlimitedHuffCodeSize = 32 };
+      uint m_num_codes[cMaxUnlimitedHuffCodeSize + 1];
+
+      void clear() { utils::zero_object(m_num_codes); }
+
+      void init(uint num_syms, const uint8* pCodesizes);
+
+      inline void init(uint code_size0, uint total_syms0, uint code_size1, uint total_syms1)
+      {
+         m_num_codes[code_size0] += total_syms0;
+         m_num_codes[code_size1] += total_syms1;
+      }
+   };
+   
+   uint get_generate_huffman_codes_table_size();
+   
+   bool generate_huffman_codes(void* pContext, uint num_syms, const uint16* pFreq, uint8* pCodesizes, uint& max_code_size, uint& total_freq_ret, code_size_histogram &code_size_hist);
+
+} // namespace lzham