fix compress file

3 files changed, 57 insertions, 20 deletions

diff --git a/core/src/xmake/lz4/compress_file.c b/core/src/xmake/lz4/compress_file.c
index a4c1a7076..3d175dbc9 100644
--- a/core/src/xmake/lz4/compress_file.c
+++ b/core/src/xmake/lz4/compress_file.c
@@ -55,21 +55,27 @@ tb_int_t xm_lz4_compress_file(lua_State* lua)
     {
         tb_bool_t write_ok = tb_false;
         tb_byte_t idata[TB_STREAM_BLOCK_MAXN];
+        tb_byte_t odata[TB_STREAM_BLOCK_MAXN];
         while (!tb_stream_beof(istream))
         {
             write_ok = tb_false;
             tb_long_t ireal = (tb_long_t)tb_stream_read(istream, idata, sizeof(idata));
             if (ireal > 0)
             {
-                tb_byte_t* odata = tb_null;
-                tb_long_t oreal = xm_lz4_cstream_compress(stream_lz4, idata, ireal, &odata);
-                tb_assert_and_check_break(oreal >= 0);
-                if (oreal > 0)
+                tb_long_t r = xm_lz4_cstream_write(stream_lz4, idata, ireal, tb_stream_beof(istream));
+                tb_assert_and_check_break(r >= 0);
+                tb_check_continue(r > 0);
+
+                tb_long_t oreal;
+                while ((oreal = xm_lz4_cstream_read(stream_lz4, odata, sizeof(odata))) > 0)
                 {
-                    tb_assert_and_check_break(odata);
                     if (!tb_stream_bwrit(ostream, odata, oreal))
+                    {
+                        oreal = -1;
                         break;
+                    }
                 }
+                tb_assert_and_check_break(oreal >= 0);
             }
             else break;
             write_ok = tb_true;
diff --git a/core/src/xmake/lz4/decompress_file.c b/core/src/xmake/lz4/decompress_file.c
index 0aa58ccf3..1d12a16a0 100644
--- a/core/src/xmake/lz4/decompress_file.c
+++ b/core/src/xmake/lz4/decompress_file.c
@@ -62,7 +62,7 @@ tb_int_t xm_lz4_decompress_file(lua_State* lua)
             tb_long_t ireal = (tb_long_t)tb_stream_read(istream, idata, sizeof(idata));
             if (ireal > 0)
             {
-                tb_long_t r = xm_lz4_dstream_write(stream_lz4, idata, ireal);
+                tb_long_t r = xm_lz4_dstream_write(stream_lz4, idata, ireal, tb_stream_beof(istream));
                 tb_assert_and_check_break(r >= 0);
                 tb_check_continue(r > 0);
 
diff --git a/core/src/xmake/lz4/prefix.h b/core/src/xmake/lz4/prefix.h
index 6c429a249..23a52a856 100644
--- a/core/src/xmake/lz4/prefix.h
+++ b/core/src/xmake/lz4/prefix.h
@@ -38,6 +38,7 @@ typedef struct __xm_lz4_cstream_t
 {
     LZ4F_cctx*          cctx;
     LZ4_byte*           buffer;
+    tb_size_t           buffer_size;
     tb_size_t           buffer_maxn;
     tb_size_t           write_maxn;
     tb_bool_t           header_written;
@@ -113,25 +114,55 @@ static __tb_inline__ xm_lz4_cstream_t* xm_lz4_cstream_init()
     return stream;
 }
 
-static __tb_inline__ tb_long_t xm_lz4_cstream_compress(xm_lz4_cstream_t* stream, tb_byte_t const* idata, tb_size_t isize, tb_byte_t** podata)
+static __tb_inline__ tb_long_t xm_lz4_cstream_write(xm_lz4_cstream_t* stream, tb_byte_t const* idata, tb_size_t isize, tb_bool_t end)
 {
     // check
-    tb_assert_and_check_return_val(stream && stream->cctx && idata && isize && podata, -1);
+    tb_assert_and_check_return_val(stream && stream->cctx && idata && isize, -1);
     tb_assert_and_check_return_val(isize <= stream->write_maxn, -1);
+    tb_assert_and_check_return_val(stream->buffer_size + isize < stream->buffer_maxn, -1);
+
+    tb_size_t real = LZ4F_compressUpdate(stream->cctx, stream->buffer + stream->buffer_size,
+        stream->buffer_maxn - stream->buffer_size, idata, isize, tb_null);
+    if (LZ4F_isError(real))
+        return -1;
+    stream->buffer_size += real;
+
+    if (end)
+    {
+        tb_size_t ret = LZ4F_compressEnd(stream->cctx, stream->buffer + stream->buffer_size,
+            stream->buffer_maxn - stream->buffer_size, tb_null);
+        if (LZ4F_isError(ret))
+            return -1;
+
+        real += ret;
+        stream->buffer_size += ret;
+    }
 
+    return isize;
+}
+
+static __tb_inline__ tb_long_t xm_lz4_cstream_read(xm_lz4_cstream_t* stream, tb_byte_t* odata, tb_size_t osize)
+{
+    // check
+    tb_assert_and_check_return_val(stream && stream->cctx && odata && osize, -1);
+    tb_assert_and_check_return_val(osize >= sizeof(stream->header), -1);
+
+    tb_size_t read = 0;
     if (!stream->header_written)
     {
-        *podata = stream->header;
+        tb_memcpy(odata, stream->header, sizeof(stream->header));
         stream->header_written = tb_true;
-        return sizeof(stream->header);
+        read += sizeof(stream->header);
+        osize -= sizeof(stream->header);
     }
 
-    tb_size_t real = LZ4F_compressUpdate(stream->cctx, stream->buffer, stream->buffer_maxn, idata, isize, tb_null);
-    if (LZ4F_isError(real))
-        return -1;
-
-    *podata = stream->buffer;
-    return real;
+    tb_size_t need = tb_min(stream->buffer_size, osize);
+    tb_memcpy(odata + read, stream->buffer, need);
+    if (need < stream->buffer_size)
+        tb_memmov(stream->buffer, stream->buffer + need, stream->buffer_size - need);
+    stream->buffer_size -= need;
+    read += need;
+    return read;
 }
 
 static __tb_inline__ tb_void_t xm_lz4_dstream_exit(xm_lz4_dstream_t* stream)
@@ -178,7 +209,7 @@ static __tb_inline__ xm_lz4_dstream_t* xm_lz4_dstream_init()
     return stream;
 }
 
-static __tb_inline__ tb_long_t xm_lz4_dstream_write(xm_lz4_dstream_t* stream, tb_byte_t const* idata, tb_size_t isize)
+static __tb_inline__ tb_long_t xm_lz4_dstream_write(xm_lz4_dstream_t* stream, tb_byte_t const* idata, tb_size_t isize, tb_bool_t end)
 {
     // check
     tb_assert_and_check_return_val(stream && stream->dctx && idata && isize, -1);
@@ -237,15 +268,15 @@ static __tb_inline__ tb_long_t xm_lz4_dstream_write(xm_lz4_dstream_t* stream, tb
     return isize;
 }
 
-static __tb_inline__ tb_long_t xm_lz4_dstream_read(xm_lz4_dstream_t* stream, tb_byte_t* odata, tb_size_t omaxn)
+static __tb_inline__ tb_long_t xm_lz4_dstream_read(xm_lz4_dstream_t* stream, tb_byte_t* odata, tb_size_t osize)
 {
     // check
-    tb_assert_and_check_return_val(stream && stream->dctx && stream->buffer && odata && omaxn, -1);
+    tb_assert_and_check_return_val(stream && stream->dctx && stream->buffer && odata && osize, -1);
     tb_check_return_val(stream->buffer_size, 0);
 
     // do decompress
     size_t srcsize = stream->buffer_size;
-    size_t dstsize = omaxn;
+    size_t dstsize = osize;
     tb_size_t ret = LZ4F_decompress(stream->dctx, odata, &dstsize, stream->buffer, &srcsize, tb_null);
     if (LZ4F_isError(ret))
         return -1;