You can now set when building to use c or zig libraries.

src/decomp.zig

@@ -1,6 +1,15 @@
+//! Implementations for decompression.
+//! TODO: change to vtable interface to allow for shared decompressors for better performance/resource usage.
+
 const std = @import("std");
 const Reader = std.Io.Reader;
 
+const config = @import("config");
+
+const c = @cImport({
+    @cInclude("zstd.h");
+});
+
 pub const CompressionType = enum(u16) {
     gzip = 1,
     lzma,
@@ -12,32 +21,53 @@ pub const CompressionType = enum(u16) {
 
 pub const DecompFn = *const fn (alloc: std.mem.Allocator, in: []u8, out: []u8) anyerror!usize; // TODO: replace anyerror to definitive error types.
 
-// pub const DecompressError = error{
-//     ReadFailed,
-//     anyerror,
-// };
+pub const gzipDecompress = if (config.use_c_libs) cGzip else zigGzip;
 
-pub fn gzipDecompress(alloc: std.mem.Allocator, in: []u8, out: []u8) anyerror!usize {
+fn zigGzip(alloc: std.mem.Allocator, in: []u8, out: []u8) anyerror!usize {
     var rdr: Reader = .fixed(in);
     const buf = try alloc.alloc(u8, out.len);
     defer alloc.free(buf);
     var decomp = std.compress.flate.Decompress.init(&rdr, .zlib, buf);
     return decomp.reader.readSliceShort(out);
 }
+fn cGzip(alloc: std.mem.Allocator, in: []u8, out: []u8) anyerror!usize {
+    _ = alloc;
+    _ = in;
+    _ = out;
+    return error.TODO;
+}
 
-pub fn lzmaDecompress(alloc: std.mem.Allocator, in: []u8, out: []u8) anyerror!usize {
+pub const lzmaDecompress = if (config.use_c_libs) cLzma else zigLzma;
+
+fn zigLzma(alloc: std.mem.Allocator, in: []u8, out: []u8) anyerror!usize {
     var rdr: Reader = .fixed(in);
     var decomp = try std.compress.lzma.decompress(alloc, rdr.adaptToOldInterface());
     return decomp.read(out);
 }
+fn cLzma(alloc: std.mem.Allocator, in: []u8, out: []u8) anyerror!usize {
+    _ = alloc;
+    _ = in;
+    _ = out;
+    return error.TODO;
+}
 
-pub fn xzDecompress(alloc: std.mem.Allocator, in: []u8, out: []u8) anyerror!usize {
+pub const xzDecompress = if (config.use_c_libs) cXz else zigXz;
+
+fn zigXz(alloc: std.mem.Allocator, in: []u8, out: []u8) anyerror!usize {
     var rdr: Reader = .fixed(in);
     var decomp = try std.compress.xz.decompress(alloc, rdr.adaptToOldInterface());
     return decomp.read(out);
 }
+fn cXz(alloc: std.mem.Allocator, in: []u8, out: []u8) anyerror!usize {
+    _ = alloc;
+    _ = in;
+    _ = out;
+    return error.TODO;
+}
 
-pub fn zstdDecompress(alloc: std.mem.Allocator, in: []u8, out: []u8) anyerror!usize {
+pub const zstdDecompress = if (config.use_c_libs) cZstd else zigZstd;
+
+pub fn zigZstd(alloc: std.mem.Allocator, in: []u8, out: []u8) anyerror!usize {
     var rdr: Reader = .fixed(in);
     const buf = try alloc.alloc(u8, std.compress.zstd.default_window_len + std.compress.zstd.block_size_max);
     defer alloc.free(buf);
@@ -46,3 +76,83 @@ pub fn zstdDecompress(alloc: std.mem.Allocator, in: []u8, out: []u8) anyerror!us
         return decomp.err orelse err;
     };
 }
+fn cZstd(alloc: std.mem.Allocator, in: []u8, out: []u8) anyerror!usize {
+    _ = alloc;
+    const res = c.ZSTD_decompress(out.ptr, out.len, in.ptr, in.len);
+    if (c.ZSTD_isError(res) == 0) return res;
+    return switch (c.ZSTD_getErrorCode(res)) {
+        c.ZSTD_error_prefix_unknown => cZstdError.PrefixUnknown,
+        c.ZSTD_error_version_unsupported => cZstdError.VersionUnsupported,
+        c.ZSTD_error_frameParameter_unsupported => cZstdError.FrameParameterUnsupported,
+        c.ZSTD_error_frameParameter_windowTooLarge => cZstdError.FrameParameterWindowTooLarge,
+        c.ZSTD_error_corruption_detected => cZstdError.CorruptionDetected,
+        c.ZSTD_error_checksum_wrong => cZstdError.ChecksumWrong,
+        c.ZSTD_error_literals_headerWrong => cZstdError.LiteralsHeaderWrong,
+        c.ZSTD_error_dictionary_corrupted => cZstdError.DictionaryCorrupted,
+        c.ZSTD_error_dictionary_wrong => cZstdError.DictionaryWrong,
+        c.ZSTD_error_dictionaryCreation_failed => cZstdError.DictionaryCreationFailed,
+        c.ZSTD_error_parameter_unsupported => cZstdError.ParameterUnsupported,
+        c.ZSTD_error_parameter_combination_unsupported => cZstdError.ParameterCombinationUnsupported,
+        c.ZSTD_error_parameter_outOfBound => cZstdError.ParameterOutOfBound,
+        c.ZSTD_error_tableLog_tooLarge => cZstdError.TableLogTooLarge,
+        c.ZSTD_error_maxSymbolValue_tooLarge => cZstdError.MaxSymbolValueTooLarge,
+        c.ZSTD_error_maxSymbolValue_tooSmall => cZstdError.MaxSymbolValueTooSmall,
+        c.ZSTD_error_cannotProduce_uncompressedBlock => cZstdError.CannotProduceUncompressedBlock,
+        c.ZSTD_error_stabilityCondition_notRespected => cZstdError.StabilityConditionNotRespected,
+        c.ZSTD_error_stage_wrong => cZstdError.StageWrong,
+        c.ZSTD_error_init_missing => cZstdError.InitMissing,
+        c.ZSTD_error_memory_allocation => cZstdError.MemoryAllocation,
+        c.ZSTD_error_workSpace_tooSmall => cZstdError.WorkSpaceTooSmall,
+        c.ZSTD_error_dstSize_tooSmall => cZstdError.DstSizeTooSmall,
+        c.ZSTD_error_srcSize_wrong => cZstdError.SrcSizeWrong,
+        c.ZSTD_error_dstBuffer_null => cZstdError.DstBufferNull,
+        c.ZSTD_error_noForwardProgress_destFull => cZstdError.NoForwardProgressDestFull,
+        c.ZSTD_error_noForwardProgress_inputEmpty => cZstdError.NoForwardProgressInputEmpty,
+        c.ZSTD_error_frameIndex_tooLarge => cZstdError.FrameIndexTooLarge,
+        c.ZSTD_error_seekableIO => cZstdError.SeekableIo,
+        c.ZSTD_error_dstBuffer_wrong => cZstdError.DstBufferWrong,
+        c.ZSTD_error_srcBuffer_wrong => cZstdError.SrcBufferWrong,
+        c.ZSTD_error_sequenceProducer_failed => cZstdError.SequenceProducerFailed,
+        c.ZSTD_error_externalSequences_invalid => cZstdError.ExternalSequencesInvalid,
+        c.ZSTD_error_maxCode => cZstdError.MaxCode,
+        else => cZstdError.Generic,
+    };
+}
+
+pub const cZstdError = error{
+    Generic,
+    PrefixUnknown,
+    VersionUnsupported,
+    FrameParameterUnsupported,
+    FrameParameterWindowTooLarge,
+    CorruptionDetected,
+    ChecksumWrong,
+    LiteralsHeaderWrong,
+    DictionaryCorrupted,
+    DictionaryWrong,
+    DictionaryCreationFailed,
+    ParameterUnsupported,
+    ParameterCombinationUnsupported,
+    ParameterOutOfBound,
+    TableLogTooLarge,
+    MaxSymbolValueTooLarge,
+    MaxSymbolValueTooSmall,
+    CannotProduceUncompressedBlock,
+    StabilityConditionNotRespected,
+    StageWrong,
+    InitMissing,
+    MemoryAllocation,
+    WorkSpaceTooSmall,
+    DstSizeTooSmall,
+    SrcSizeWrong,
+    DstBufferNull,
+    NoForwardProgressDestFull,
+    NoForwardProgressInputEmpty,
+    FrameIndexTooLarge,
+    SeekableIo,
+    DstBufferWrong,
+    SrcBufferWrong,
+    SequenceProducerFailed,
+    ExternalSequencesInvalid,
+    MaxCode,
+};