add: 添加fastlz压缩库

components/fastlz/LICENSE.MIT

@@ -0,0 +1,21 @@
+FastLZ - Byte-aligned LZ77 compression library
+Copyright (C) 2005-2020 Ariya Hidayat <ariya.hidayat@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

components/fastlz/fastlz.c

@@ -0,0 +1,503 @@
+/*
+  FastLZ - Byte-aligned LZ77 compression library
+  Copyright (C) 2005-2020 Ariya Hidayat <ariya.hidayat@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#include "fastlz.h"
+
+#include <stdint.h>
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
+
+/*
+ * Give hints to the compiler for branch prediction optimization.
+ */
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 2))
+#define FASTLZ_LIKELY(c) (__builtin_expect(!!(c), 1))
+#define FASTLZ_UNLIKELY(c) (__builtin_expect(!!(c), 0))
+#else
+#define FASTLZ_LIKELY(c) (c)
+#define FASTLZ_UNLIKELY(c) (c)
+#endif
+
+/*
+ * Specialize custom 64-bit implementation for speed improvements.
+ */
+#if defined(__x86_64__) || defined(_M_X64) || defined(__aarch64__)
+#define FLZ_ARCH64
+#endif
+
+/*
+ * Workaround for DJGPP to find uint8_t, uint16_t, etc.
+ */
+#if defined(__MSDOS__) && defined(__GNUC__)
+#include <stdint-gcc.h>
+#endif
+
+#if defined(FASTLZ_USE_MEMMOVE) && (FASTLZ_USE_MEMMOVE == 0)
+
+static void fastlz_memmove(uint8_t* dest, const uint8_t* src, uint32_t count) {
+  do {
+    *dest++ = *src++;
+  } while (--count);
+}
+
+static void fastlz_memcpy(uint8_t* dest, const uint8_t* src, uint32_t count) {
+  return fastlz_memmove(dest, src, count);
+}
+
+#else
+
+#include <string.h>
+
+static void fastlz_memmove(uint8_t* dest, const uint8_t* src, uint32_t count) {
+  if ((count > 4) && (dest >= src + count)) {
+    memmove(dest, src, count);
+  } else {
+    switch (count) {
+      default:
+        do {
+          *dest++ = *src++;
+        } while (--count);
+        break;
+      case 3:
+        *dest++ = *src++;
+      case 2:
+        *dest++ = *src++;
+      case 1:
+        *dest++ = *src++;
+      case 0:
+        break;
+    }
+  }
+}
+
+static void fastlz_memcpy(uint8_t* dest, const uint8_t* src, uint32_t count) { memcpy(dest, src, count); }
+
+#endif
+
+#if defined(FLZ_ARCH64)
+
+static uint32_t flz_readu32(const void* ptr) { return *(const uint32_t*)ptr; }
+
+static uint32_t flz_cmp(const uint8_t* p, const uint8_t* q, const uint8_t* r) {
+  const uint8_t* start = p;
+
+  if (flz_readu32(p) == flz_readu32(q)) {
+    p += 4;
+    q += 4;
+  }
+  while (q < r)
+    if (*p++ != *q++) break;
+  return p - start;
+}
+
+#endif /* FLZ_ARCH64 */
+
+#if !defined(FLZ_ARCH64)
+
+static uint32_t flz_readu32(const void* ptr) {
+  const uint8_t* p = (const uint8_t*)ptr;
+  return (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
+}
+
+static uint32_t flz_cmp(const uint8_t* p, const uint8_t* q, const uint8_t* r) {
+  const uint8_t* start = p;
+  while (q < r)
+    if (*p++ != *q++) break;
+  return p - start;
+}
+
+#endif /* !FLZ_ARCH64 */
+
+#define MAX_COPY 32
+#define MAX_LEN 264 /* 256 + 8 */
+#define MAX_L1_DISTANCE 8192
+#define MAX_L2_DISTANCE 8191
+#define MAX_FARDISTANCE (65535 + MAX_L2_DISTANCE - 1)
+
+#define HASH_LOG 13
+#define HASH_SIZE (1 << HASH_LOG)
+#define HASH_MASK (HASH_SIZE - 1)
+
+static uint16_t flz_hash(uint32_t v) {
+  uint32_t h = (v * 2654435769LL) >> (32 - HASH_LOG);
+  return h & HASH_MASK;
+}
+
+/* special case of memcpy: at most MAX_COPY bytes */
+static void flz_smallcopy(uint8_t* dest, const uint8_t* src, uint32_t count) {
+#if defined(FLZ_ARCH64)
+  if (count >= 4) {
+    const uint32_t* p = (const uint32_t*)src;
+    uint32_t* q = (uint32_t*)dest;
+    while (count > 4) {
+      *q++ = *p++;
+      count -= 4;
+      dest += 4;
+      src += 4;
+    }
+  }
+#endif
+  fastlz_memcpy(dest, src, count);
+}
+
+/* special case of memcpy: exactly MAX_COPY bytes */
+static void flz_maxcopy(void* dest, const void* src) {
+#if defined(FLZ_ARCH64)
+  const uint32_t* p = (const uint32_t*)src;
+  uint32_t* q = (uint32_t*)dest;
+  *q++ = *p++;
+  *q++ = *p++;
+  *q++ = *p++;
+  *q++ = *p++;
+  *q++ = *p++;
+  *q++ = *p++;
+  *q++ = *p++;
+  *q++ = *p++;
+#else
+  fastlz_memcpy(dest, src, MAX_COPY);
+#endif
+}
+
+static uint8_t* flz_literals(uint32_t runs, const uint8_t* src, uint8_t* dest) {
+  while (runs >= MAX_COPY) {
+    *dest++ = MAX_COPY - 1;
+    flz_maxcopy(dest, src);
+    src += MAX_COPY;
+    dest += MAX_COPY;
+    runs -= MAX_COPY;
+  }
+  if (runs > 0) {
+    *dest++ = runs - 1;
+    flz_smallcopy(dest, src, runs);
+    dest += runs;
+  }
+  return dest;
+}
+
+static uint8_t* flz1_match(uint32_t len, uint32_t distance, uint8_t* op) {
+  --distance;
+  if (FASTLZ_UNLIKELY(len > MAX_LEN - 2))
+    while (len > MAX_LEN - 2) {
+      *op++ = (7 << 5) + (distance >> 8);
+      *op++ = MAX_LEN - 2 - 7 - 2;
+      *op++ = (distance & 255);
+      len -= MAX_LEN - 2;
+    }
+  if (len < 7) {
+    *op++ = (len << 5) + (distance >> 8);
+    *op++ = (distance & 255);
+  } else {
+    *op++ = (7 << 5) + (distance >> 8);
+    *op++ = len - 7;
+    *op++ = (distance & 255);
+  }
+  return op;
+}
+
+#define FASTLZ_BOUND_CHECK(cond) \
+  if (FASTLZ_UNLIKELY(!(cond))) return 0;
+
+int fastlz1_compress(const void* input, int length, void* output, uint32_t *htab) {
+  const uint8_t* ip = (const uint8_t*)input;
+  const uint8_t* ip_start = ip;
+  const uint8_t* ip_bound = ip + length - 4; /* because readU32 */
+  const uint8_t* ip_limit = ip + length - 12 - 1;
+  uint8_t* op = (uint8_t*)output;
+
+  // uint32_t htab[HASH_SIZE];
+  uint32_t seq, hash;
+
+  /* initializes hash table */
+  for (hash = 0; hash < HASH_SIZE; ++hash) htab[hash] = 0;
+
+  /* we start with literal copy */
+  const uint8_t* anchor = ip;
+  ip += 2;
+
+  /* main loop */
+  while (FASTLZ_LIKELY(ip < ip_limit)) {
+    const uint8_t* ref;
+    uint32_t distance, cmp;
+
+    /* find potential match */
+    do {
+      seq = flz_readu32(ip) & 0xffffff;
+      hash = flz_hash(seq);
+      ref = ip_start + htab[hash];
+      htab[hash] = ip - ip_start;
+      distance = ip - ref;
+      cmp = FASTLZ_LIKELY(distance < MAX_L1_DISTANCE) ? flz_readu32(ref) & 0xffffff : 0x1000000;
+      if (FASTLZ_UNLIKELY(ip >= ip_limit)) break;
+      ++ip;
+    } while (seq != cmp);
+
+    if (FASTLZ_UNLIKELY(ip >= ip_limit)) break;
+    --ip;
+
+    if (FASTLZ_LIKELY(ip > anchor)) {
+      op = flz_literals(ip - anchor, anchor, op);
+    }
+
+    uint32_t len = flz_cmp(ref + 3, ip + 3, ip_bound);
+    op = flz1_match(len, distance, op);
+
+    /* update the hash at match boundary */
+    ip += len;
+    seq = flz_readu32(ip);
+    hash = flz_hash(seq & 0xffffff);
+    htab[hash] = ip++ - ip_start;
+    seq >>= 8;
+    hash = flz_hash(seq);
+    htab[hash] = ip++ - ip_start;
+
+    anchor = ip;
+  }
+
+  uint32_t copy = (uint8_t*)input + length - anchor;
+  op = flz_literals(copy, anchor, op);
+
+  return op - (uint8_t*)output;
+}
+
+
+int fastlz1_decompress(const void* input, int length, void* output, int maxout) {
+  const uint8_t* ip = (const uint8_t*)input;
+  const uint8_t* ip_limit = ip + length;
+  const uint8_t* ip_bound = ip_limit - 2;
+  uint8_t* op = (uint8_t*)output;
+  uint8_t* op_limit = op + maxout;
+  uint32_t ctrl = (*ip++) & 31;
+
+  while (1) {
+    if (ctrl >= 32) {
+      uint32_t len = (ctrl >> 5) - 1;
+      uint32_t ofs = (ctrl & 31) << 8;
+      const uint8_t* ref = op - ofs - 1;
+      if (len == 7 - 1) {
+        FASTLZ_BOUND_CHECK(ip <= ip_bound);
+        len += *ip++;
+      }
+      ref -= *ip++;
+      len += 3;
+      FASTLZ_BOUND_CHECK(op + len <= op_limit);
+      FASTLZ_BOUND_CHECK(ref >= (uint8_t*)output);
+      fastlz_memmove(op, ref, len);
+      op += len;
+    } else {
+      ctrl++;
+      FASTLZ_BOUND_CHECK(op + ctrl <= op_limit);
+      FASTLZ_BOUND_CHECK(ip + ctrl <= ip_limit);
+      fastlz_memcpy(op, ip, ctrl);
+      ip += ctrl;
+      op += ctrl;
+    }
+
+    if (FASTLZ_UNLIKELY(ip > ip_bound)) break;
+    ctrl = *ip++;
+  }
+
+  return op - (uint8_t*)output;
+}
+
+
+
+static uint8_t* flz2_match(uint32_t len, uint32_t distance, uint8_t* op) {
+  --distance;
+  if (distance < MAX_L2_DISTANCE) {
+    if (len < 7) {
+      *op++ = (len << 5) + (distance >> 8);
+      *op++ = (distance & 255);
+    } else {
+      *op++ = (7 << 5) + (distance >> 8);
+      for (len -= 7; len >= 255; len -= 255) *op++ = 255;
+      *op++ = len;
+      *op++ = (distance & 255);
+    }
+  } else {
+    /* far away, but not yet in the another galaxy... */
+    if (len < 7) {
+      distance -= MAX_L2_DISTANCE;
+      *op++ = (len << 5) + 31;
+      *op++ = 255;
+      *op++ = distance >> 8;
+      *op++ = distance & 255;
+    } else {
+      distance -= MAX_L2_DISTANCE;
+      *op++ = (7 << 5) + 31;
+      for (len -= 7; len >= 255; len -= 255) *op++ = 255;
+      *op++ = len;
+      *op++ = 255;
+      *op++ = distance >> 8;
+      *op++ = distance & 255;
+    }
+  }
+  return op;
+}
+
+int fastlz2_compress(const void* input, int length, void* output, uint32_t *htab) {
+  const uint8_t* ip = (const uint8_t*)input;
+  const uint8_t* ip_start = ip;
+  const uint8_t* ip_bound = ip + length - 4; /* because readU32 */
+  const uint8_t* ip_limit = ip + length - 12 - 1;
+  uint8_t* op = (uint8_t*)output;
+
+  // uint32_t htab[HASH_SIZE];
+  uint32_t seq, hash;
+
+  /* initializes hash table */
+  for (hash = 0; hash < HASH_SIZE; ++hash) htab[hash] = 0;
+
+  /* we start with literal copy */
+  const uint8_t* anchor = ip;
+  ip += 2;
+
+  /* main loop */
+  while (FASTLZ_LIKELY(ip < ip_limit)) {
+    const uint8_t* ref;
+    uint32_t distance, cmp;
+
+    /* find potential match */
+    do {
+      seq = flz_readu32(ip) & 0xffffff;
+      hash = flz_hash(seq);
+      ref = ip_start + htab[hash];
+      htab[hash] = ip - ip_start;
+      distance = ip - ref;
+      cmp = FASTLZ_LIKELY(distance < MAX_FARDISTANCE) ? flz_readu32(ref) & 0xffffff : 0x1000000;
+      if (FASTLZ_UNLIKELY(ip >= ip_limit)) break;
+      ++ip;
+    } while (seq != cmp);
+
+    if (FASTLZ_UNLIKELY(ip >= ip_limit)) break;
+
+    --ip;
+
+    /* far, needs at least 5-byte match */
+    if (distance >= MAX_L2_DISTANCE) {
+      if (ref[3] != ip[3] || ref[4] != ip[4]) {
+        ++ip;
+        continue;
+      }
+    }
+
+    if (FASTLZ_LIKELY(ip > anchor)) {
+      op = flz_literals(ip - anchor, anchor, op);
+    }
+
+    uint32_t len = flz_cmp(ref + 3, ip + 3, ip_bound);
+    op = flz2_match(len, distance, op);
+
+    /* update the hash at match boundary */
+    ip += len;
+    seq = flz_readu32(ip);
+    hash = flz_hash(seq & 0xffffff);
+    htab[hash] = ip++ - ip_start;
+    seq >>= 8;
+    hash = flz_hash(seq);
+    htab[hash] = ip++ - ip_start;
+
+    anchor = ip;
+  }
+
+  uint32_t copy = (uint8_t*)input + length - anchor;
+  op = flz_literals(copy, anchor, op);
+
+  /* marker for fastlz2 */
+  *(uint8_t*)output |= (1 << 5);
+
+  return op - (uint8_t*)output;
+}
+
+int fastlz2_decompress(const void* input, int length, void* output, int maxout) {
+  const uint8_t* ip = (const uint8_t*)input;
+  const uint8_t* ip_limit = ip + length;
+  const uint8_t* ip_bound = ip_limit - 2;
+  uint8_t* op = (uint8_t*)output;
+  uint8_t* op_limit = op + maxout;
+  uint32_t ctrl = (*ip++) & 31;
+
+  while (1) {
+    if (ctrl >= 32) {
+      uint32_t len = (ctrl >> 5) - 1;
+      uint32_t ofs = (ctrl & 31) << 8;
+      const uint8_t* ref = op - ofs - 1;
+
+      uint8_t code;
+      if (len == 7 - 1) do {
+          FASTLZ_BOUND_CHECK(ip <= ip_bound);
+          code = *ip++;
+          len += code;
+        } while (code == 255);
+      code = *ip++;
+      ref -= code;
+      len += 3;
+
+      /* match from 16-bit distance */
+      if (FASTLZ_UNLIKELY(code == 255))
+        if (FASTLZ_LIKELY(ofs == (31 << 8))) {
+          FASTLZ_BOUND_CHECK(ip < ip_bound);
+          ofs = (*ip++) << 8;
+          ofs += *ip++;
+          ref = op - ofs - MAX_L2_DISTANCE - 1;
+        }
+
+      FASTLZ_BOUND_CHECK(op + len <= op_limit);
+      FASTLZ_BOUND_CHECK(ref >= (uint8_t*)output);
+      fastlz_memmove(op, ref, len);
+      op += len;
+    } else {
+      ctrl++;
+      FASTLZ_BOUND_CHECK(op + ctrl <= op_limit);
+      FASTLZ_BOUND_CHECK(ip + ctrl <= ip_limit);
+      fastlz_memcpy(op, ip, ctrl);
+      ip += ctrl;
+      op += ctrl;
+    }
+
+    if (FASTLZ_UNLIKELY(ip >= ip_limit)) break;
+    ctrl = *ip++;
+  }
+
+  return op - (uint8_t*)output;
+}
+
+int fastlz_decompress(const void* input, int length, void* output, int maxout) {
+  /* magic identifier for compression level */
+  int level = ((*(const uint8_t*)input) >> 5) + 1;
+
+  if (level == 1) return fastlz1_decompress(input, length, output, maxout);
+  if (level == 2) return fastlz2_decompress(input, length, output, maxout);
+
+  /* unknown level, trigger error */
+  return 0;
+}
+
+int fastlz_compress_level(int level, const void* input, int length, void* output, uint32_t *htab) {
+  if (level == 1) return fastlz1_compress(input, length, output, htab);
+  if (level == 2) return fastlz2_compress(input, length, output, htab);
+
+  return 0;
+}
+
+#pragma GCC diagnostic pop

components/fastlz/fastlz.h

@@ -0,0 +1,100 @@
+/*
+  FastLZ - Byte-aligned LZ77 compression library
+  Copyright (C) 2005-2020 Ariya Hidayat <ariya.hidayat@gmail.com>
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#ifndef FASTLZ_H
+#define FASTLZ_H
+
+#include <stdint.h>
+#include <string.h>
+
+#define FASTLZ_VERSION 0x000500
+
+#define FASTLZ_VERSION_MAJOR 0
+#define FASTLZ_VERSION_MINOR 5
+#define FASTLZ_VERSION_REVISION 0
+
+#define FASTLZ_VERSION_STRING "0.5.0"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/**
+  Compress a block of data in the input buffer and returns the size of
+  compressed block. The size of input buffer is specified by length. The
+  minimum input buffer size is 16.
+
+  The output buffer must be at least 5% larger than the input buffer
+  and can not be smaller than 66 bytes.
+
+  If the input is not compressible, the return value might be larger than
+  length (input buffer size).
+
+  The input buffer and the output buffer can not overlap.
+
+  Compression level can be specified in parameter level. At the moment,
+  only level 1 and level 2 are supported.
+  Level 1 is the fastest compression and generally useful for short data.
+  Level 2 is slightly slower but it gives better compression ratio.
+
+  Note that the compressed data, regardless of the level, can always be
+  decompressed using the function fastlz_decompress below.
+*/
+
+int fastlz_compress_level(int level, const void* input, int length, void* output, uint32_t *htab);
+
+/**
+  Decompress a block of compressed data and returns the size of the
+  decompressed block. If error occurs, e.g. the compressed data is
+  corrupted or the output buffer is not large enough, then 0 (zero)
+  will be returned instead.
+
+  The input buffer and the output buffer can not overlap.
+
+  Decompression is memory safe and guaranteed not to write the output buffer
+  more than what is specified in maxout.
+
+  Note that the decompression will always work, regardless of the
+  compression level specified in fastlz_compress_level above (when
+  producing the compressed block).
+ */
+
+int fastlz_decompress(const void* input, int length, void* output, int maxout);
+
+/**
+  DEPRECATED.
+
+  This is similar to fastlz_compress_level above, but with the level
+  automatically chosen.
+
+  This function is deprecated and it will be completely removed in some future
+  version.
+*/
+
+// int fastlz_compress(const void* input, int length, void* output, uint32_t *htab);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif /* FASTLZ_H */

components/fastlz/luat_lib_fastlz.c

@@ -0,0 +1,104 @@
+/*
+@module  fastlz
+@summary FastLZ压缩
+@version 1.0
+@date    2023.7.38
+@tag LUAT_USE_FASTLZ
+@usage
+-- 与miniz库的差异
+-- 内存需求量小很多, miniz库接近200k, fastlz只需要32k+原始数据大小
+-- 压缩比, miniz的压缩比要好于fastlz
+
+-- 准备好数据
+local bigdata = "123jfoiq4hlkfjbnasdilfhuqwo;hfashfp9qw38hrfaios;hfiuoaghfluaeisw"
+-- 压缩之
+local cdata = fastlz.compress(bigdata) 
+-- lua 的 字符串相当于有长度的char[],可存放包括0x00的一切数据
+if cdata then
+    -- 检查压缩前后的数据大小
+    log.info("fastlz", "before", #bigdata, "after", #cdata)
+    log.info("fastlz", "cdata as hex", cdata:toHex())
+
+    -- 解压, 得到原文
+    local udata = fastlz.uncompress(cdata)
+    log.info("fastlz", "udata", udata)
+end
+*/
+#include "luat_base.h"
+#include "luat_malloc.h"
+
+#define LUAT_LOG_TAG "fastlz"
+#include "luat_log.h"
+
+#include "fastlz.h"
+
+#define HASH_LOG 13
+#define HASH_SIZE (1 << HASH_LOG)
+#define HASH_MASK (HASH_SIZE - 1)
+
+/*
+快速压缩
+@api fastlz.compress(data, level)
+@string 待压缩的数据, 少于400字节的数据不建议压缩, 且压缩后的数据不能大于32k
+@int 压缩级别,默认1, 可选1或者2, 2的压缩比更高(有时候)
+@return string 若压缩成功,返回数据字符串, 否则返回nil
+@usage
+-- 注意, 压缩过程的内存消耗如下
+-- 系统内存, 固定32k
+-- lua内存, 原始数据的大小的1.05倍,最小占用1024字节.
+*/
+static int l_fastlz_compress(lua_State* L) {
+    size_t len = 0;
+    const char* data = luaL_checklstring(L, 1, &len);
+    int level = luaL_optinteger(L, 2, 1);
+    luaL_Buffer buff;
+    luaL_buffinitsize(L, &buff, len > 512 ? (int)(len * 1.05) : (1024));
+    uint32_t *htab = luat_heap_malloc( sizeof(uint32_t) * HASH_SIZE);
+    if (htab) {
+        int ret = fastlz_compress_level(level, data, len, buff.b, htab);
+        luat_heap_free(htab);
+        if (ret > 0) {
+            luaL_pushresultsize(&buff, ret);
+            return 1;
+        }
+    }
+    return 0;
+}
+
+/*
+快速解压
+@api fastlz.uncompress(data, maxout)
+@string 待解压的数据
+@int 解压后的最大大小, 默认是4k, 可按需调整
+@return string 若解压成功,返回数据字符串, 否则返回nil
+*/
+static int l_fastlz_uncompress(lua_State* L) {
+    size_t len = 0;
+    const char* data = luaL_checklstring(L, 1, &len);
+    size_t maxout = luaL_optinteger(L, 2, 4096);
+    luaL_Buffer buff;
+    luaL_buffinitsize(L, &buff, maxout);
+    uint32_t *htab = luat_heap_malloc( sizeof(uint32_t) * HASH_SIZE);
+    if (htab) {
+        int ret = fastlz_decompress(data, len, buff.b, maxout);
+        luat_heap_free(htab);
+        if (ret > 0) {
+            luaL_pushresultsize(&buff, ret);
+            return 1;
+        }
+    }
+    return 0;
+}
+
+#include "rotable2.h"
+static const rotable_Reg_t reg_fastlz[] = {
+    {"compress", ROREG_FUNC(l_fastlz_compress)},
+    {"uncompress", ROREG_FUNC(l_fastlz_uncompress)},
+    {NULL, ROREG_INT(0)}
+};
+
+
+LUAMOD_API int luaopen_fastlz( lua_State *L ) {
+    luat_newlib2(L, reg_fastlz);
+    return 1;
+}

luat/include/luat_libs.h

@@ -150,4 +150,8 @@ LUAMOD_API int luaopen_max30102( lua_State *L );
 LUAMOD_API int luaopen_bit64( lua_State *L );
 
 LUAMOD_API int luaopen_repl( lua_State *L );
+
+
+LUAMOD_API int luaopen_fastlz( lua_State *L );
+
 #endif