Finished(?) decompression stuff

src/decomp/c/lz4.zig

@@ -0,0 +1,12 @@
+const std = @import("std");
+
+const c = @import("../../c_libs.zig").c;
+const Decompressor = @import("../../decomp.zig");
+
+interface: Decompressor = .{ .vtable = .{ .stateless = stateless } },
+
+pub fn stateless(_: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
+    const res = c.LZ4_decompress_safe(in.ptr, out.ptr, in.len, out.len);
+    if (res > 0) return @abs(res);
+    return Decompressor.Error.ReadFailed; // TOOD: Find out what errors can be returned.
+}

src/decomp/c/lzma.zig

@@ -0,0 +1,142 @@
+const std = @import("std");
+
+const c = @import("../../c_libs.zig").c;
+const Decompressor = @import("../../decomp.zig");
+
+const Lzma = @This();
+
+streams: std.AutoHashMap(std.Thread.Id, c.lzma_stream),
+
+interface: Decompressor,
+
+err: ?Error = null,
+
+pub fn init(alloc: std.mem.Allocator) !Lzma {
+    return .{
+        .streams = try .init(alloc),
+        .interface = &.{
+            .alloc = alloc,
+            .vtable = .{ .decompress = decompress, .stateless = stateless },
+        },
+    };
+}
+pub fn deinit(self: *Lzma) void {
+    var values = self.streams.valueIterator();
+    while (values.next()) |val| {
+        c.lzma_end(val);
+    }
+    self.streams.deinit();
+}
+
+fn getOrCreate(self: *Lzma) !*c.lzma_stream {
+    const res = try self.streams.getOrPut(std.Thread.getCurrentId());
+    if (res.found_existing) return res.value_ptr;
+    res.value_ptr.* = .{
+        .alloc = .{
+            .alloc = lzmaAlloc,
+            .free = lzmaFree,
+            .@"opaque" = &self.interface.alloc,
+        },
+    };
+    return res.value_ptr;
+}
+
+fn decompress(decomp: *const Decompressor, in: []u8, out: []u8) Decompressor.Error!usize {
+    var self: *Lzma = @fieldParentPtr("interface", decomp);
+
+    const stream = try self.getOrCreate();
+    stream.next_in = in.ptr;
+    stream.avail_in = in.len;
+    stream.next_out = out.ptr;
+    stream.avail_out = out.len;
+    var res = c.lzma_alone_decoder(stream, out.len, 0);
+    decodeResult(res) catch |err| {
+        self.err = err;
+        lzmaErrorToDecompError(err);
+    };
+    while (true) {
+        res = c.lzma_code(&stream, c.LZMA_RUN);
+        if (res == c.LZMA_OK) continue;
+        if (res == c.LZMA_STREAM_END) break;
+        decodeResult(res) catch |err| {
+            self.err = err;
+            lzmaErrorToDecompError(err);
+        };
+    }
+    return stream.total_out;
+}
+pub fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
+    var stream: c.lzma_stream = .{
+        .next_in = in.ptr,
+        .avail_in = in.len,
+        .next_out = out.ptr,
+        .avail_out = out.len,
+        .allocator = .{
+            .alloc = lzmaAlloc,
+            .free = lzmaFree,
+            .@"opaque" = &alloc,
+        },
+    };
+    var res = c.lzma_alone_decoder(&stream, out.len, 0);
+    decodeResult(res) catch |err| lzmaErrorToDecompError(err);
+    while (true) {
+        res = c.lzma_code(&stream, c.LZMA_RUN);
+        if (res == c.LZMA_OK) continue;
+        if (res == c.LZMA_STREAM_END) break;
+        decodeResult(res) catch |err| lzmaErrorToDecompError(err);
+    }
+    return stream.total_out;
+}
+
+inline fn decodeResult(res: c_uint) Error!void {
+    return switch (res) {
+        c.LZMA_OK => {},
+        c.LZMA_STREAM_END => {},
+        c.LZMA_NO_CHECK => {},
+        c.LZMA_UNSUPPORTED_CHECK => Error.UnsupportedCheck,
+        c.LZMA_MEM_ERROR => Error.OutOfMemory,
+        c.LZMA_MEMLIMIT_ERROR => Error.OutOfMemory,
+        c.LZMA_FORMAT_ERROR => Error.Format,
+        c.LZMA_OPTIONS_ERROR => Error.Options,
+        c.LZMA_DATA_ERROR => Error.Data,
+        c.LZMA_BUF_ERROR => Error.BufferExhausted,
+        c.LZMA_PROG_ERROR => Error.Programming,
+        c.LZMA_SEEK_NEEDED => Error.SeekNeeded,
+        else => Error.Unknown,
+    };
+}
+fn lzmaErrorToDecompError(err: Error) Decompressor.Error {
+    switch (err) {
+        Error.OutOfMemory => return err,
+        Error.UnsupportedCheck => return Decompressor.Error.ReadFailed,
+        Error.Format => return Decompressor.Error.ReadFailed,
+        Error.Options => return Decompressor.Error.ReadFailed,
+        Error.Data => return Decompressor.Error.ReadFailed,
+        Error.BufferExhausted => return Decompressor.Error.WriteFailed,
+        Error.Programming => return Decompressor.Error.ReadFailed,
+        Error.SeekNeeded => return Decompressor.Error.ReadFailed,
+        Error.Unknown => return Decompressor.Error.ReadFailed,
+    }
+}
+
+fn lzmaAlloc(ptr: ?*anyopaque, _: usize, size: usize) callconv(.c) ?*anyopaque {
+    var alloc: *std.mem.Allocator = @ptrCast(ptr);
+    return alloc.rawAlloc(size, .@"1", 0) catch return null;
+}
+fn lzmaFree(ptr: ?*anyopaque, alloc_ptr: ?*anyopaque) callconv(.c) void {
+    if (alloc_ptr == null) return;
+    var alloc: *std.mem.Allocator = @ptrCast(ptr);
+    alloc.rawFree(@ptrCast(alloc_ptr), .@"1", 0);
+}
+
+pub const Error = error{
+    OutOfMemory,
+    UnsupportedCheck,
+    Format,
+    Options,
+    Data,
+    BufferExhausted,
+    Programming,
+    SeekNeeded,
+    Unknown,
+};

src/decomp/c/lzo.zig

@@ -0,0 +1,28 @@
+const std = @import("std");
+
+const c = @import("../../c_libs.zig").c;
+const Decompressor = @import("../../decomp.zig");
+
+interface: Decompressor = .{ .vtable = .{ .stateless = stateless } },
+
+pub fn stateless(_: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
+    var out_len = out.len;
+    const res = c.lzo1x_decompress(in.ptr, in.len, out.ptr, &out_len, null);
+    return switch (res) {
+        c.LZO_E_OK => out_len,
+        c.LZO_E_ERROR => Decompressor.Error.ReadFailed,
+        c.LZO_E_OUT_OF_MEMORY => Decompressor.Error.OutOfMemory,
+        c.LZO_E_NOT_COMPRESSIBLE => Decompressor.Error.ReadFailed,
+        c.LZO_E_INPUT_OVERRUN => Decompressor.Error.ReadFailed,
+        c.LZO_E_OUTPUT_OVERRUN => Decompressor.Error.WriteFailed,
+        c.LZO_E_LOOKBEHIND_OVERRUN => Decompressor.Error.ReadFailed,
+        c.LZO_E_EOF_NOT_FOUND => Decompressor.Error.ReadFailed,
+        c.LZO_E_INPUT_NOT_CONSUMED => Decompressor.Error.ReadFailed,
+        c.LZO_E_NOT_YET_IMPLEMENTED => Decompressor.Error.ReadFailed,
+        c.LZO_E_INVALID_ARGUMENT => Decompressor.Error.ReadFailed,
+        c.LZO_E_INVALID_ALIGNMENT => Decompressor.Error.ReadFailed,
+        c.LZO_E_OUTPUT_NOT_CONSUMED => Decompressor.Error.WriteFailed,
+        c.LZO_E_INTERNAL_ERROR => Decompressor.Error.ReadFailed,
+        else => Decompressor.Error.ReadFailed,
+    };
+}

src/decomp/c/xz.zig

@@ -20,6 +20,13 @@ pub fn init(alloc: std.mem.Allocator) !Xz {
         },
     };
 }
+pub fn deinit(self: *Xz) void {
+    var values = self.streams.valueIterator();
+    while (values.next()) |val| {
+        c.lzma_end(val);
+    }
+    self.streams.deinit();
+}
 
 fn getOrCreate(self: *Xz) !*c.lzma_stream {
     const res = try self.streams.getOrPut(std.Thread.getCurrentId());
@@ -34,7 +41,7 @@ fn getOrCreate(self: *Xz) !*c.lzma_stream {
     return res.value_ptr;
 }
 
-fn decompress(decomp: *Decompressor, in: []u8, out: []u8) Decompressor.Error!usize {
+fn decompress(decomp: *const Decompressor, in: []u8, out: []u8) Decompressor.Error!usize {
     var self: *Xz = @fieldParentPtr("interface", decomp);
 
     const stream = try self.getOrCreate();
@@ -43,16 +50,22 @@ fn decompress(decomp: *Decompressor, in: []u8, out: []u8) Decompressor.Error!usi
     stream.next_out = out.ptr;
     stream.avail_out = out.len;
     var res = c.lzma_stream_decoder(stream, out.len, 0);
-    decodeResult(res) catch |err| xzErrorToDecompError(err);
+    decodeResult(res) catch |err| {
+        self.err = err;
+        xzErrorToDecompError(err);
+    };
     while (true) {
         res = c.lzma_code(&stream, c.LZMA_RUN);
         if (res == c.LZMA_OK) continue;
         if (res == c.LZMA_STREAM_END) break;
-        decodeResult(res) catch |err| xzErrorToDecompError(err);
+        decodeResult(res) catch |err| {
+            self.err = err;
+            xzErrorToDecompError(err);
+        };
     }
     return stream.total_out;
 }
-fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
+pub fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
     var stream: c.lzma_stream = .{
         .next_in = in.ptr,
         .avail_in = in.len,

src/decomp/c/zlib.zig

@@ -20,6 +20,13 @@ pub fn init(alloc: std.mem.Allocator) !Zlib {
         },
     };
 }
+pub fn deinit(self: *Zlib) void {
+    var values = self.streams.valueIterator();
+    while (values.next()) |val| {
+        _ = c.zng_deflateEnd(val);
+    }
+    self.streams.deinit();
+}
 
 fn getOrCreate(self: *Zlib) !*c.zng_stream {
     const res = try self.streams.getOrPut(std.Thread.getCurrentId());
@@ -32,7 +39,7 @@ fn getOrCreate(self: *Zlib) !*c.zng_stream {
     return res.value_ptr;
 }
 
-fn decompress(decomp: *Decompressor, in: []u8, out: []u8) Decompressor.Error!usize {
+fn decompress(decomp: *const Decompressor, in: []u8, out: []u8) Decompressor.Error!usize {
     var self: *Zlib = @fieldParentPtr("interface", decomp);
 
     var stream = try self.getOrCreate();
@@ -55,7 +62,7 @@ fn decompress(decomp: *Decompressor, in: []u8, out: []u8) Decompressor.Error!usi
     };
 }
 
-fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
+pub fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
     _ = alloc;
     var out_len = out.len;
     const res = c.zng_uncompress(out.ptr, &out_len, in.ptr, in.len);

src/decomp/c/zstd.zig

@@ -20,6 +20,13 @@ pub fn init(alloc: std.mem.Allocator) !Zstd {
         },
     };
 }
+pub fn deinit(self: *Zstd) void {
+    var values = self.context.valueIterator();
+    while (values.next()) |val| {
+        _ = c.ZSTD_freeDCtx(val.*);
+    }
+    self.context.deinit();
+}
 
 fn getOrCreate(self: *Zstd) !*c.ZSTD_DCtx {
     const res = try self.context.getOrPut(std.Thread.getCurrentId());
@@ -29,7 +36,7 @@ fn getOrCreate(self: *Zstd) !*c.ZSTD_DCtx {
     return res.value_ptr;
 }
 
-fn decompress(decomp: *Decompressor, in: []u8, out: []u8) Decompressor.Error!usize {
+fn decompress(decomp: *const Decompressor, in: []u8, out: []u8) Decompressor.Error!usize {
     var self: *Zstd = @fieldParentPtr("interface", decomp);
 
     const ctx = self.getOrCreate();
@@ -40,7 +47,7 @@ fn decompress(decomp: *Decompressor, in: []u8, out: []u8) Decompressor.Error!usi
     };
     return res;
 }
-fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
+pub fn stateless(alloc: std.mem.Allocator, in: []u8, out: []u8) Decompressor.Error!usize {
     _ = alloc;
     const res = c.ZSTD_decompress(out.ptr, out.len, in.ptr, in.len);
     decodeError(res) catch |err| return ZstdErrorToDecompError(err);