koffi 2.3.10-beta.2 → 2.3.10

package/src/core/libcc/libcc.cc

@@ -20,14 +20,7 @@
 // OTHER DEALINGS IN THE SOFTWARE.
 
 #include "libcc.hh"
-#if !defined(LIBCC_NO_MINIZ) && __has_include("vendor/miniz/miniz.h")
-    #define MINIZ_NO_ZLIB_COMPATIBLE_NAMES
-    #include "vendor/miniz/miniz.h"
-#endif
-#if !defined(LIBCC_NO_BROTLI) && __has_include("vendor/brotli/c/include/brotli/decode.h")
-    #include "vendor/brotli/c/include/brotli/decode.h"
-    #include "vendor/brotli/c/include/brotli/encode.h"
-#endif
+
 #if __has_include("vendor/dragonbox/include/dragonbox/dragonbox.h") && __cplusplus >= 201703L
     #include "vendor/dragonbox/include/dragonbox/dragonbox.h"
 #endif
@@ -2142,6 +2135,8 @@ StatResult StatFile(const char *filename, unsigned int flags, FileInfo *out_info
     out_info->mtime = FileTimeToUnixTime(attr.ftLastWriteTime);
     out_info->btime = FileTimeToUnixTime(attr.ftCreationTime);
     out_info->mode = (out_info->type == FileType::Directory) ? 0755 : 0644;
+    out_info->uid = 0;
+    out_info->gid = 0;
 
     return StatResult::Success;
 }
@@ -2150,24 +2145,30 @@ bool RenameFile(const char *src_filename, const char *dest_filename, unsigned in
 {
     DWORD move_flags = (flags & (int)RenameFlag::Overwrite) ? MOVEFILE_REPLACE_EXISTING : 0;
 
-    if (win32_utf8) {
-        if (!MoveFileExA(src_filename, dest_filename, move_flags))
-            goto error;
-    } else {
-        wchar_t src_filename_w[4096];
-        wchar_t dest_filename_w[4096];
-        if (ConvertUtf8ToWin32Wide(src_filename, src_filename_w) < 0)
-            return false;
-        if (ConvertUtf8ToWin32Wide(dest_filename, dest_filename_w) < 0)
-            return false;
+    for (int i = 0; i < 10; i++) {
+        if (win32_utf8) {
+            if (MoveFileExA(src_filename, dest_filename, move_flags))
+                return true;
+        } else {
+            wchar_t src_filename_w[4096];
+            wchar_t dest_filename_w[4096];
+            if (ConvertUtf8ToWin32Wide(src_filename, src_filename_w) < 0)
+                return false;
+            if (ConvertUtf8ToWin32Wide(dest_filename, dest_filename_w) < 0)
+                return false;
 
-        if (!MoveFileExW(src_filename_w, dest_filename_w, move_flags))
-            goto error;
-    }
+            if (MoveFileExW(src_filename_w, dest_filename_w, move_flags))
+                return true;
+        }
 
-    return true;
+        if (GetLastError() != ERROR_ACCESS_DENIED)
+            break;
+
+        // If two threads are trying to rename to the same destination or the FS is
+        // very busy, we get spurious ERROR_ACCESS_DENIED errors. Wait a bit and retry :)
+        Sleep(1);
+    }
 
-error:
     LogError("Failed to rename file '%1' to '%2': %3", src_filename, dest_filename, GetWin32ErrorString());
     return false;
 }
@@ -2291,7 +2292,7 @@ static FileType FileModeToType(mode_t mode)
 
 StatResult StatFile(const char *filename, unsigned int flags, FileInfo *out_info)
 {
-#ifdef __linux__
+#if defined(__linux__) && !defined(LIBCC_NO_STATX)
     int stat_flags = (flags & (int)StatFlag::FollowSymlink) ? 0 : AT_SYMLINK_NOFOLLOW;
     int stat_mask = STATX_TYPE | STATX_MODE | STATX_MTIME | STATX_BTIME | STATX_SIZE;
 
@@ -2326,6 +2327,8 @@ StatResult StatFile(const char *filename, unsigned int flags, FileInfo *out_info
         out_info->btime = out_info->mtime;
     }
     out_info->mode = (unsigned int)sxb.stx_mode & ~S_IFMT;
+    out_info->uid = sxb.stx_uid;
+    out_info->gid = sxb.stx_gid;
 #else
     int stat_flags = (flags & (int)StatFlag::FollowSymlink) ? 0 : AT_SYMLINK_NOFOLLOW;
 
@@ -2351,7 +2354,12 @@ StatResult StatFile(const char *filename, unsigned int flags, FileInfo *out_info
 
     out_info->type = FileModeToType(sb.st_mode);
     out_info->size = (int64_t)sb.st_size;
-#if defined(__APPLE__)
+#if defined(__linux__)
+    out_info->mtime = (int64_t)sb.st_mtim.tv_sec * 1000 +
+                      (int64_t)sb.st_mtim.tv_nsec / 1000000;
+    out_info->btime = (int64_t)sb.st_ctim.tv_sec * 1000 +
+                      (int64_t)sb.st_ctim.tv_nsec / 1000000;
+#elif defined(__APPLE__)
     out_info->mtime = (int64_t)sb.st_mtimespec.tv_sec * 1000 +
                       (int64_t)sb.st_mtimespec.tv_nsec / 1000000;
     out_info->btime = (int64_t)sb.st_birthtimespec.tv_sec * 1000 +
@@ -2368,6 +2376,8 @@ StatResult StatFile(const char *filename, unsigned int flags, FileInfo *out_info
                       (int64_t)sb.st_birthtim.tv_nsec / 1000000;
 #endif
     out_info->mode = (unsigned int)sb.st_mode;
+    out_info->uid = (uint32_t)sb.st_uid;
+    out_info->gid = (uint32_t)sb.st_gid;
 #endif
 
     return StatResult::Success;
@@ -2997,9 +3007,13 @@ Span<const char> GetPathExtension(Span<const char> filename, CompressionType *ou
     };
 
     consume_next_extension();
+
     if (out_compression_type) {
-        if (TestStr(extension, ".gz")) {
-            *out_compression_type = CompressionType::Gzip;
+        const char *const *it = std::find_if(std::begin(CompressionTypeExtensions), std::end(CompressionTypeExtensions),
+                                             [&](const char *it) { return it && TestStr(it, extension); });
+
+        if (it != std::end(CompressionTypeExtensions)) {
+            *out_compression_type = (CompressionType)(it - CompressionTypeExtensions);
             consume_next_extension();
         } else {
             *out_compression_type = CompressionType::None;
@@ -5324,7 +5338,6 @@ class AsyncPool {
     HeapArray<bool> workers_state;
 
     HeapArray<TaskQueue> queues;
-    int next_queue_idx = 0;
     std::atomic_int pending_tasks { 0 };
 
 public:
@@ -5466,11 +5479,8 @@ void AsyncPool::AddTask(Async *async, const std::function<bool()> &func)
 {
     if (async_running_pool != async->pool) {
         for (;;) {
-            TaskQueue *queue = &queues[next_queue_idx];
-
-            if (--next_queue_idx < 0) {
-                next_queue_idx = (int)workers_state.len - 1;
-            }
+            int idx = GetRandomIntSafe(0, queues.len);
+            TaskQueue *queue = &queues[idx];
 
             std::unique_lock<std::mutex> lock_queue(queue->queue_mutex, std::try_to_lock);
             if (lock_queue.owns_lock()) {
@@ -5870,39 +5880,8 @@ StreamReader stdin_st(stdin, "<stdin>");
 StreamWriter stdout_st(stdout, "<stdout>");
 StreamWriter stderr_st(stderr, "<stderr>");
 
-#ifdef MZ_VERSION
-struct MinizInflateContext {
-    tinfl_decompressor inflator;
-    bool done;
-
-    uint8_t in[256 * 1024];
-    uint8_t *in_ptr;
-    Size in_len;
-
-    uint8_t out[256 * 1024];
-    uint8_t *out_ptr;
-    Size out_len;
-
-    // Gzip support
-    bool header_done;
-    uint32_t crc32;
-    Size uncompressed_size;
-};
-RG_STATIC_ASSERT(RG_SIZE(MinizInflateContext::out) >= TINFL_LZ_DICT_SIZE);
-#endif
-
-#ifdef BROTLI_DEFAULT_MODE
-struct BrotliDecompressContext {
-    BrotliDecoderState *state;
-    bool done;
-
-    uint8_t in[256 * 1024];
-    Size in_len;
-
-    uint8_t out[256 * 1024];
-    Size out_len;
-};
-#endif
+static CreateDecompressorFunc *DecompressorFunctions[RG_LEN(CompressionTypeNames)];
+static CreateCompressorFunc *CompressorFunctions[RG_LEN(CompressionTypeNames)];
 
 bool StreamReader::Open(Span<const uint8_t> buf, const char *filename,
                         CompressionType compression_type)
@@ -6000,35 +5979,9 @@ bool StreamReader::Close(bool implicit)
 {
     RG_ASSERT(implicit || this != &stdin_st);
 
-    switch (compression.type) {
-        case CompressionType::None: {} break;
-
-        case CompressionType::Gzip:
-        case CompressionType::Zlib: {
-#ifdef MZ_VERSION
-            ReleaseOne(nullptr, compression.u.miniz);
-            compression.u.miniz = nullptr;
-#else
-            RG_UNREACHABLE();
-#endif
-        } break;
-
-        case CompressionType::Brotli: {
-#ifdef BROTLI_DEFAULT_MODE
-            BrotliDecompressContext *ctx = compression.u.brotli;
-
-            if (ctx) {
-                if (ctx->state) {
-                    BrotliDecoderDestroyInstance(ctx->state);
-                }
-
-                ReleaseOne(nullptr, ctx);
-                compression.u.brotli = nullptr;
-            }
-#else
-            RG_UNREACHABLE();
-#endif
-        } break;
+    if (decompressor) {
+        RG_ASSERT(compression_type != CompressionType::None);
+        delete decompressor;
     }
 
     switch (source.type) {
@@ -6048,7 +6001,7 @@ bool StreamReader::Close(bool implicit)
 
     filename = nullptr;
     error = true;
-    compression.type = CompressionType::None;
+    compression_type = CompressionType::None;
     source.type = SourceType::Memory;
     source.eof = false;
     eof = false;
@@ -6079,31 +6032,12 @@ bool StreamReader::Rewind()
         } break;
     }
 
-    switch (compression.type) {
-        case CompressionType::None: {} break;
-
-        case CompressionType::Gzip:
-        case CompressionType::Zlib: {
-#ifdef MZ_VERSION
-            memset(compression.u.miniz, 0, sizeof(*compression.u.miniz));
-            tinfl_init(&compression.u.miniz->inflator);
-            compression.u.miniz->crc32 = MZ_CRC32_INIT;
-#else
-            RG_UNREACHABLE();
-#endif
-        } break;
+    if (decompressor) {
+        RG_ASSERT(compression_type != CompressionType::None);
+        delete decompressor;
 
-        case CompressionType::Brotli: {
-#ifdef BROTLI_DEFAULT_MODE
-            if (compression.u.brotli->state) {
-                BrotliDecoderDestroyInstance(compression.u.brotli->state);
-                compression.u.brotli->state = nullptr;
-            }
-            compression.u.brotli->state = BrotliDecoderCreateInstance(nullptr, nullptr, nullptr);
-#else
-            RG_UNREACHABLE();
-#endif
-        } break;
+        if (!InitDecompressor(compression_type))
+            return false;
     }
 
     source.eof = false;
@@ -6135,28 +6069,16 @@ Size StreamReader::Read(Span<uint8_t> out_buf)
         return -1;
 
     Size read_len = 0;
-    switch (compression.type) {
-        case CompressionType::None: {
-            read_len = ReadRaw(out_buf.len, out_buf.ptr);
-            eof = source.eof;
-        } break;
+    if (decompressor) {
+        RG_ASSERT(compression_type != CompressionType::None);
 
-        case CompressionType::Gzip:
-        case CompressionType::Zlib: {
-#ifdef MZ_VERSION
-            read_len = ReadInflate(out_buf.len, out_buf.ptr);
-#else
-            RG_UNREACHABLE();
-#endif
-        } break;
+        read_len = decompressor->Read(out_buf.len, out_buf.ptr);
+        error |= (read_len < 0);
+    } else {
+        RG_ASSERT(compression_type == CompressionType::None);
 
-        case CompressionType::Brotli: {
-#ifdef BROTLI_DEFAULT_MODE
-            read_len = ReadBrotli(out_buf.len, out_buf.ptr);
-#else
-            RG_UNREACHABLE();
-#endif
-        } break;
+        read_len = ReadRaw(out_buf.len, out_buf.ptr);
+        eof = source.eof;
     }
 
     return read_len;
@@ -6185,7 +6107,7 @@ Size StreamReader::ReadAll(Size max_len, HeapArray<uint8_t> *out_buf)
     // For some files (such as in /proc), the file size is reported as 0 even though there
     // is content inside, because these files are generated on demand. So we need to take
     // the slow path for apparently empty files.
-    if (compression.type == CompressionType::None && ComputeRawLen() > 0) {
+    if (compression_type == CompressionType::None && ComputeRawLen() > 0) {
         if (raw_len > max_len) {
             LogError("File '%1' is too large (limit = %2)", filename, FmtDiskSize(max_len));
             return -1;
@@ -6265,253 +6187,30 @@ int64_t StreamReader::ComputeRawLen()
 
 bool StreamReader::InitDecompressor(CompressionType type)
 {
-    switch (type) {
-        case CompressionType::None: {} break;
-
-        case CompressionType::Gzip:
-        case CompressionType::Zlib: {
-#ifdef MZ_VERSION
-            compression.u.miniz = AllocateOne<MinizInflateContext>(nullptr, (int)AllocFlag::Zero);
-            tinfl_init(&compression.u.miniz->inflator);
-            compression.u.miniz->crc32 = MZ_CRC32_INIT;
-#else
-            LogError("Deflate decompression not available for '%1'", filename);
-            error = true;
-            return false;
-#endif
-        } break;
+    if (type != CompressionType::None) {
+        CreateDecompressorFunc *func = DecompressorFunctions[(int)type];
 
-        case CompressionType::Brotli: {
-#ifdef BROTLI_DEFAULT_MODE
-            compression.u.brotli = AllocateOne<BrotliDecompressContext>(nullptr, (int)AllocFlag::Zero);
-            compression.u.brotli->state = BrotliDecoderCreateInstance(nullptr, nullptr, nullptr);
-#else
-            LogError("Brotli decompression not available for '%1'", filename);
+        if (!func) {
+            LogError("%1 decompression is not available for '%2'", CompressionTypeNames[(int)type], filename);
             error = true;
             return false;
-#endif
-        } break;
-    }
-    compression.type = type;
-
-    return true;
-}
-
-#ifdef MZ_VERSION
-Size StreamReader::ReadInflate(Size max_len, void *out_buf)
-{
-    MinizInflateContext *ctx = compression.u.miniz;
-
-    // Gzip header is not directly supported by miniz. Currently this
-    // will fail if the header is longer than 4096 bytes, which is
-    // probably quite rare.
-    if (compression.type == CompressionType::Gzip && !ctx->header_done) {
-        uint8_t header[4096];
-        Size header_len;
-
-        header_len = ReadRaw(RG_SIZE(header), header);
-        if (header_len < 0) {
-            return -1;
-        } else if (header_len < 10 || header[0] != 0x1F || header[1] != 0x8B) {
-            LogError("File '%1' does not look like a Gzip stream", filename);
-            error = true;
-            return -1;
-        }
-
-        Size header_offset = 10;
-        if (header[3] & 0x4) { // FEXTRA
-            if (header_len - header_offset < 2)
-                goto truncated_error;
-            uint16_t extra_len = (uint16_t)((header[11] << 8) | header[10]);
-            if (extra_len > header_len - header_offset)
-                goto truncated_error;
-            header_offset += extra_len;
-        }
-        if (header[3] & 0x8) { // FNAME
-            uint8_t *end_ptr = (uint8_t *)memchr(header + header_offset, '\0',
-                                                 (size_t)(header_len - header_offset));
-            if (!end_ptr)
-                goto truncated_error;
-            header_offset = end_ptr - header + 1;
-        }
-        if (header[3] & 0x10) { // FCOMMENT
-            uint8_t *end_ptr = (uint8_t *)memchr(header + header_offset, '\0',
-                                                 (size_t)(header_len - header_offset));
-            if (!end_ptr)
-                goto truncated_error;
-            header_offset = end_ptr - header + 1;
-        }
-        if (header[3] & 0x2) { // FHCRC
-            if (header_len - header_offset < 2)
-                goto truncated_error;
-            uint16_t crc16 = (uint16_t)(header[1] << 8 | header[0]);
-            if ((mz_crc32(MZ_CRC32_INIT, header, (size_t)header_offset) & 0xFFFF) == crc16) {
-                LogError("Failed header CRC16 check in '%s'", filename);
-                error = true;
-                return -1;
-            }
-            header_offset += 2;
-        }
-
-        // Put back remaining data in the buffer
-        memcpy_safe(ctx->in, header + header_offset, (size_t)(header_len - header_offset));
-        ctx->in_ptr = ctx->in;
-        ctx->in_len = header_len - header_offset;
-
-        ctx->header_done = true;
-    }
-
-    // Inflate (with miniz)
-    {
-        Size read_len = 0;
-        for (;;) {
-            if (max_len < ctx->out_len) {
-                memcpy_safe(out_buf, ctx->out_ptr, (size_t)max_len);
-                read_len += max_len;
-                ctx->out_ptr += max_len;
-                ctx->out_len -= max_len;
-
-                return read_len;
-            } else {
-                memcpy_safe(out_buf, ctx->out_ptr, (size_t)ctx->out_len);
-                read_len += ctx->out_len;
-                out_buf = (uint8_t *)out_buf + ctx->out_len;
-                max_len -= ctx->out_len;
-                ctx->out_ptr = ctx->out;
-                ctx->out_len = 0;
-
-                if (ctx->done) {
-                    eof = true;
-                    return read_len;
-                }
-            }
-
-            while (ctx->out_len < RG_SIZE(ctx->out)) {
-                if (!ctx->in_len) {
-                    ctx->in_ptr = ctx->in;
-                    ctx->in_len = ReadRaw(RG_SIZE(ctx->in), ctx->in);
-                    if (ctx->in_len < 0)
-                        return read_len ? read_len : ctx->in_len;
-                }
-
-                size_t in_arg = (size_t)ctx->in_len;
-                size_t out_arg = (size_t)(RG_SIZE(ctx->out) - ctx->out_len);
-                uint32_t flags = (uint32_t)
-                    ((compression.type == CompressionType::Zlib ? TINFL_FLAG_PARSE_ZLIB_HEADER : 0) |
-                     (source.eof ? 0 : TINFL_FLAG_HAS_MORE_INPUT));
-
-                tinfl_status status = tinfl_decompress(&ctx->inflator, ctx->in_ptr, &in_arg,
-                                                       ctx->out, ctx->out + ctx->out_len,
-                                                       &out_arg, flags);
-
-                if (compression.type == CompressionType::Gzip) {
-                    ctx->crc32 = (uint32_t)mz_crc32(ctx->crc32, ctx->out + ctx->out_len, out_arg);
-                    ctx->uncompressed_size += (Size)out_arg;
-                }
-
-                ctx->in_ptr += (Size)in_arg;
-                ctx->in_len -= (Size)in_arg;
-                ctx->out_len += (Size)out_arg;
-
-                if (status == TINFL_STATUS_DONE) {
-                    // Gzip footer (CRC and size check)
-                    if (compression.type == CompressionType::Gzip) {
-                        uint32_t footer[2];
-                        RG_STATIC_ASSERT(RG_SIZE(footer) == 8);
-
-                        if (ctx->in_len < RG_SIZE(footer)) {
-                            memcpy_safe(footer, ctx->in_ptr, (size_t)ctx->in_len);
-
-                            Size missing_len = RG_SIZE(footer) - ctx->in_len;
-                            if (ReadRaw(missing_len, footer + ctx->in_len) < missing_len) {
-                                if (error) {
-                                    return -1;
-                                } else {
-                                    goto truncated_error;
-                                }
-                            }
-                        } else {
-                            memcpy_safe(footer, ctx->in_ptr, RG_SIZE(footer));
-                        }
-                        footer[0] = LittleEndian(footer[0]);
-                        footer[1] = LittleEndian(footer[1]);
-
-                        if (ctx->crc32 != footer[0] ||
-                                (uint32_t)ctx->uncompressed_size != footer[1]) {
-                            LogError("Failed CRC32 or size check in GZip stream '%1'", filename);
-                            error = true;
-                            return -1;
-                        }
-                    }
-
-                    ctx->done = true;
-                    break;
-                } else if (status < TINFL_STATUS_DONE) {
-                    LogError("Failed to decompress '%1' (Deflate)", filename);
-                    error = true;
-                    return -1;
-                }
-            }
         }
-    }
 
-truncated_error:
-    LogError("Truncated Gzip header in '%1'", filename);
-    error = true;
-    return -1;
-}
-#endif
+        decompressor = func(this);
 
-#ifdef BROTLI_DEFAULT_MODE
-Size StreamReader::ReadBrotli(Size max_len, void *out_buf)
-{
-    BrotliDecompressContext *ctx = compression.u.brotli;
-
-    for (;;) {
-        if (ctx->out_len || ctx->done) {
-            Size copy_len = std::min(max_len, ctx->out_len);
-
-            ctx->out_len -= copy_len;
-            memcpy(out_buf, ctx->out, copy_len);
-            memmove(ctx->out, ctx->out + copy_len, ctx->out_len);
-
-            eof = !ctx->out_len && ctx->done;
-            return copy_len;
-        }
-
-        if (ctx->in_len < RG_SIZE(ctx->in)) {
-            Size raw_len = ReadRaw(RG_SIZE(ctx->in) - ctx->in_len, ctx->in + ctx->in_len);
-            if (raw_len < 0)
-                return -1;
-            ctx->in_len += raw_len;
-        }
-
-        const uint8_t *next_in = ctx->in;
-        uint8_t *next_out = ctx->out + ctx->out_len;
-        size_t avail_in = (size_t)ctx->in_len;
-        size_t avail_out = (size_t)(RG_SIZE(ctx->out) - ctx->out_len);
-
-        BrotliDecoderResult ret = BrotliDecoderDecompressStream(ctx->state, &avail_in, &next_in,
-                                                                &avail_out, &next_out, nullptr);
-
-        if (ret == BROTLI_DECODER_RESULT_SUCCESS) {
-            ctx->done = true;
-        } else if (ret == BROTLI_DECODER_RESULT_ERROR) {
-            LogError("Malformed Brotli stream in '%1'", filename);
+        if (!decompressor) {
             error = true;
-            return -1;
-        } else if (ret == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT) {
-            LogError("Truncated Brotli stream in '%1'", filename);
+            return false;
+        }
+        if (!decompressor->Init(type)) {
             error = true;
-            return -1;
+            return false;
         }
-
-        ctx->out_len = next_out - ctx->out - ctx->out_len;
     }
 
-    RG_UNREACHABLE();
+    compression_type = type;
+    return true;
 }
-#endif
 
 Size StreamReader::ReadRaw(Size max_len, void *out_buf)
 {
@@ -6559,6 +6258,11 @@ restart:
     return read_len;
 }
 
+StreamDecompressorHelper::StreamDecompressorHelper(CompressionType compression_type, CreateDecompressorFunc *func)
+{
+    DecompressorFunctions[(int)compression_type] = func;
+}
+
 // XXX: Maximum line length
 bool LineReader::Next(Span<char> *out_line)
 {
@@ -6612,16 +6316,12 @@ void LineReader::PushLogFilter()
     });
 }
 
-#ifdef MZ_VERSION
-struct MinizDeflateContext {
-    tdefl_compressor deflator;
-
-    // Gzip support
-    uint32_t crc32;
-    Size uncompressed_size;
+#ifdef LZ4_VERSION_MAJOR
+struct LZ4CompressContext {
+    LZ4F_cctx *encoder;
+    LZ4F_preferences_t prefs = {};
 
-    // Used to buffer small writes
-    LocalArray<uint8_t, 1024> buf;
+    HeapArray<uint8_t> buf;
 };
 #endif
 
@@ -6788,51 +6488,14 @@ bool StreamWriter::Write(Span<const uint8_t> buf)
     if (RG_UNLIKELY(error))
         return false;
 
-    switch (compression.type) {
-        case CompressionType::None: {
-            return WriteRaw(buf);
-        } break;
-
-        case CompressionType::Gzip:
-        case CompressionType::Zlib: {
-#ifdef MZ_VERSION
-            MinizDeflateContext *ctx = compression.u.miniz;
-
-            if (ctx->buf.len) {
-                Size copy_len = std::min(buf.len, ctx->buf.Available());
-
-                memcpy_safe(ctx->buf.end(), buf.ptr, copy_len);
-                ctx->buf.len += copy_len;
-                buf.ptr += copy_len;
-                buf.len -= copy_len;
-            }
-
-            if (buf.len) {
-                if (ctx->buf.len && !WriteDeflate(ctx->buf))
-                    return false;
-                ctx->buf.Clear();
-
-                if (buf.len >= RG_SIZE(ctx->buf.data) / 2) {
-                    if (!WriteDeflate(buf))
-                        return false;
-                } else {
-                    memcpy_safe(ctx->buf.data, buf.ptr, buf.len);
-                    ctx->buf.len = buf.len;
-                }
-            }
-
-            return true;
-#endif
-        } break;
+    if (compressor) {
+        RG_ASSERT(compression_type != CompressionType::None);
 
-        case CompressionType::Brotli: {
-#ifdef BROTLI_DEFAULT_MODE
-            return WriteBrotli(buf);
-#endif
-        } break;
+        error |= !compressor->Write(buf);
+        return !error;
+    } else {
+        return WriteRaw(buf);
     }
-
-    RG_UNREACHABLE();
 }
 
 bool StreamWriter::Close(bool implicit)
@@ -6840,82 +6503,11 @@ bool StreamWriter::Close(bool implicit)
     RG_ASSERT(implicit || this != &stdout_st);
     RG_ASSERT(implicit || this != &stderr_st);
 
-    switch (compression.type) {
-        case CompressionType::None: {} break;
-
-        case CompressionType::Gzip:
-        case CompressionType::Zlib: {
-#ifdef MZ_VERSION
-            MinizDeflateContext *ctx = compression.u.miniz;
-
-            RG_DEFER { 
-                ReleaseOne(nullptr, ctx);
-                compression.u.miniz = nullptr;
-            };
-
-            if (IsValid() && ctx) {
-                if (ctx->buf.len && !WriteDeflate(ctx->buf)) {
-                    error = true;
-                    break;
-                }
-
-                uint8_t dummy; // Avoid UB in miniz
-                tdefl_status status = tdefl_compress_buffer(&ctx->deflator, &dummy, 0, TDEFL_FINISH);
-                if (status != TDEFL_STATUS_DONE) {
-                    if (status != TDEFL_STATUS_PUT_BUF_FAILED) {
-                        LogError("Failed to end Deflate stream for '%1", filename);
-                    }
-
-                    error = true;
-                    break;
-                }
-
-                if (compression.type == CompressionType::Gzip) {
-                    uint32_t gzip_footer[] = {
-                        LittleEndian(ctx->crc32),
-                        LittleEndian((uint32_t)ctx->uncompressed_size)
-                    };
+    if (compressor && !error) {
+        RG_ASSERT(compression_type != CompressionType::None);
+        error |= !compressor->Finalize();
 
-                    if (!WriteRaw(MakeSpan((uint8_t *)gzip_footer, RG_SIZE(gzip_footer)))) {
-                        error = true;
-                        break;
-                    }
-                }
-            }
-#endif
-        } break;
-
-        case CompressionType::Brotli: {
-#ifdef BROTLI_DEFAULT_MODE
-            BrotliEncoderState *state = compression.u.brotli;
-            uint8_t output_buf[2048];
-
-            if (state) {
-                RG_DEFER {
-                    BrotliEncoderDestroyInstance(state);
-                    compression.u.brotli = nullptr;
-                };
-
-                do {
-                    const uint8_t *next_in = nullptr;
-                    uint8_t *next_out = output_buf;
-                    size_t avail_in = 0;
-                    size_t avail_out = RG_SIZE(output_buf);
-
-                    if (!BrotliEncoderCompressStream(state, BROTLI_OPERATION_FINISH,
-                                                     &avail_in, &next_in, &avail_out, &next_out, nullptr)) {
-                        LogError("Failed to compress '%1' with Brotli", filename);
-                        error = true;
-                        break;
-                    }
-                    if (!WriteRaw(MakeSpan(output_buf, next_out - output_buf))) {
-                        error = true;
-                        break;
-                    }
-                } while (BrotliEncoderHasMoreOutput(state));
-            }
-#endif
-        } break;
+        delete compressor;
     }
 
     switch (dest.type) {
@@ -6974,7 +6566,7 @@ bool StreamWriter::Close(bool implicit)
 
     filename = nullptr;
     error = true;
-    compression.type = CompressionType::None;
+    compression_type = CompressionType::None;
     dest.type = DestinationType::Memory;
     str_alloc.ReleaseAll();
 
@@ -6983,133 +6575,32 @@ bool StreamWriter::Close(bool implicit)
 
 bool StreamWriter::InitCompressor(CompressionType type, CompressionSpeed speed)
 {
-    switch (type) {
-        case CompressionType::None: {} break;
+    if (type != CompressionType::None) {
+        CreateCompressorFunc *func = CompressorFunctions[(int)type];
 
-        case CompressionType::Gzip:
-        case CompressionType::Zlib: {
-#ifdef MZ_VERSION
-            compression.u.miniz = AllocateOne<MinizDeflateContext>(nullptr, (int)AllocFlag::Zero);
-            compression.u.miniz->crc32 = MZ_CRC32_INIT;
-
-            int flags = 0;
-            switch (speed) {
-                case CompressionSpeed::Default: { flags = 32 | TDEFL_GREEDY_PARSING_FLAG; } break;
-                case CompressionSpeed::Slow: { flags = 512; } break;
-                case CompressionSpeed::Fast: { flags = 1 | TDEFL_GREEDY_PARSING_FLAG; } break;
-            }
-            flags |= (type == CompressionType::Zlib ? TDEFL_WRITE_ZLIB_HEADER : 0);
-
-            tdefl_status status = tdefl_init(&compression.u.miniz->deflator,
-                                             [](const void *buf, int len, void *udata) {
-                StreamWriter *st = (StreamWriter *)udata;
-                return (int)st->WriteRaw(MakeSpan((uint8_t *)buf, len));
-            }, this, flags);
-            if (status != TDEFL_STATUS_OKAY) {
-                LogError("Failed to initialize Deflate compression for '%1'", filename);
-                error = true;
-                return false;
-            }
-
-            if (type == CompressionType::Gzip) {
-                static uint8_t gzip_header[] = {
-                    0x1F, 0x8B, // Fixed bytes
-                    8,          // Deflate
-                    0,          // FLG
-                    0, 0, 0, 0, // MTIME
-                    0,          // XFL
-                    0           // OS
-                };
-
-                if (!WriteRaw(gzip_header))
-                    return false;
-            }
-#else
-            LogError("Deflate compression not available for '%1'", filename);
+        if (!func) {
+            LogError("%1 compression is not available for '%2'", CompressionTypeNames[(int)type], filename);
             error = true;
             return false;
-#endif
-        } break;
-
-        case CompressionType::Brotli: {
-#ifdef BROTLI_DEFAULT_MODE
-            BrotliEncoderState *state = BrotliEncoderCreateInstance(nullptr, nullptr, nullptr);
-            compression.u.brotli = state;
-
-            RG_STATIC_ASSERT(BROTLI_MIN_QUALITY == 0 && BROTLI_MAX_QUALITY == 11);
-
-            switch (speed) {
-                case CompressionSpeed::Default: { BrotliEncoderSetParameter(state, BROTLI_PARAM_QUALITY, 6); } break;
-                case CompressionSpeed::Slow: { BrotliEncoderSetParameter(state, BROTLI_PARAM_QUALITY, 11); } break;
-                case CompressionSpeed::Fast: { BrotliEncoderSetParameter(state, BROTLI_PARAM_QUALITY, 0); } break;
-            }
-#else
-            LogError("Brotli compression not available for '%1'", filename);
-            error = true;
-            return false;
-#endif
-        } break;
-    }
-
-    compression.type = type;
-    compression.speed = speed;
-
-    return true;
-}
-
-#ifdef MZ_VERSION
-bool StreamWriter::WriteDeflate(Span<const uint8_t> buf)
-{
-    MinizDeflateContext *ctx = compression.u.miniz;
-
-    if (compression.type == CompressionType::Gzip) {
-        ctx->crc32 = (uint32_t)mz_crc32(ctx->crc32, buf.ptr, (size_t)buf.len);
-        ctx->uncompressed_size += buf.len;
-    }
-
-    tdefl_status status = tdefl_compress_buffer(&ctx->deflator, buf.ptr, (size_t)buf.len, TDEFL_NO_FLUSH);
-    if (status < TDEFL_STATUS_OKAY) {
-        if (status != TDEFL_STATUS_PUT_BUF_FAILED) {
-            LogError("Failed to deflate stream to '%1'", filename);
         }
 
-        error = true;
-        return false;
-    }
-
-    return true;
-}
-#endif
-
-#ifdef BROTLI_DEFAULT_MODE
-bool StreamWriter::WriteBrotli(Span<const uint8_t> buf)
-{
-    BrotliEncoderState *state = compression.u.brotli;
-    uint8_t output_buf[2048];
+        compressor = func(this);
 
-    while (buf.len || BrotliEncoderHasMoreOutput(state)) {
-        const uint8_t *next_in = buf.ptr;
-        uint8_t *next_out = output_buf;
-        size_t avail_in = (size_t)buf.len;
-        size_t avail_out = RG_SIZE(output_buf);
-
-        if (!BrotliEncoderCompressStream(state, BROTLI_OPERATION_PROCESS,
-                                         &avail_in, &next_in, &avail_out, &next_out, nullptr)) {
+        if (!compressor) {
             error = true;
             return false;
         }
-        if (!WriteRaw(MakeSpan(output_buf, next_out - output_buf))) {
+        if (!compressor->Init(type, speed)) {
             error = true;
             return false;
         }
-
-        buf.len -= next_in - buf.ptr;
-        buf.ptr = next_in;
     }
 
+    compression_type = type;
+    compression_speed = speed;
+
     return true;
 }
-#endif
 
 bool StreamWriter::WriteRaw(Span<const uint8_t> buf)
 {
@@ -7161,6 +6652,11 @@ bool StreamWriter::WriteRaw(Span<const uint8_t> buf)
     return true;
 }
 
+StreamCompressorHelper::StreamCompressorHelper(CompressionType compression_type, CreateCompressorFunc *func)
+{
+    CompressorFunctions[(int)compression_type] = func;
+}
+
 bool SpliceStream(StreamReader *reader, int64_t max_len, StreamWriter *writer)
 {
     if (!reader->IsValid())