Update vapoursynth-zig

dnjulek · Jan 20, 2025 · 7ab9a9b · 7ab9a9b
1 parent 98979cc
commit 7ab9a9b
Show file tree

Hide file tree

Showing 18 changed files with 242 additions and 267 deletions.
diff --git a/build.zig.zon b/build.zig.zon
@@ -1,11 +1,11 @@
 .{
     .name = "vszip",
-    .version = "3.0.0",
+    .version = "4.0.0",
     .paths = .{""},
     .dependencies = .{
         .vapoursynth = .{
-            .url = "git+https://github.com/dnjulek/vapoursynth-zig.git#8ec6f7927f57054105a1cda885ca8dfad2ed1101",
-            .hash = "1220169bc1ed7049fedcc83cf7494c902f325bcd53d3785a07a849ca785989269087",
+            .url = "git+https://github.com/dnjulek/vapoursynth-zig.git#94da91b6229a20c1b8d49825773becead339c1e9",
+            .hash = "12200b2cb28aa0c1e7eb62f23c05c40da6a8c1b4a80f81a187159c9a65cf7e2e7580",
         },
     },
 }
diff --git a/src/filters/bilateral.zig b/src/filters/bilateral.zig
@@ -6,12 +6,7 @@ const math = std.math;
 
 const allocator = std.heap.c_allocator;
 
-pub fn bilateral(comptime T: type, src: []const u8, ref: []const u8, dst: []u8, _stride: u32, w: u32, h: u32, plane: u32, comptime join: bool, d: *Data) void {
-    const srcp: []const T = @as([*]const T, @ptrCast(@alignCast(src)))[0..src.len];
-    const refp: []const T = @as([*]const T, @ptrCast(@alignCast(ref)))[0..ref.len];
-    const dstp: []T = @as([*]T, @ptrCast(@alignCast(dst)))[0..dst.len];
-    const stride: u32 = _stride >> (@sizeOf(T) >> 1);
-
+pub fn bilateral(comptime T: type, srcp: []const T, refp: []const T, dstp: []T, stride: u32, w: u32, h: u32, plane: u32, comptime join: bool, d: *Data) void {
     if (@typeInfo(T) == .int) {
         if (d.algorithm[plane] == 1) {
             bilateralAlg1(T, srcp, refp, dstp, stride, w, h, plane, d);

diff --git a/src/filters/boxblur_comptime.zig b/src/filters/boxblur_comptime.zig
@@ -7,7 +7,7 @@ const math = std.math;
 
 const allocator = std.heap.c_allocator;
 
-pub fn hvBlur(comptime T: type, src: []const u8, dst: []u8, stride: u32, w: u32, h: u32, radius: u32) void {
+pub fn hvBlur(comptime T: type, src: []const T, dst: []T, stride: u32, w: u32, h: u32, radius: u32) void {
     switch (radius) {
         1 => hvBlurCT(T, 1, src, dst, stride, w, h),
         2 => hvBlurCT(T, 2, src, dst, stride, w, h),
@@ -35,10 +35,7 @@ pub fn hvBlur(comptime T: type, src: []const u8, dst: []u8, stride: u32, w: u32,
     }
 }
 
-fn hvBlurCT(comptime T: type, comptime radius: u32, _src: []const u8, _dst: []u8, _stride: u32, w: u32, h: u32) void {
-    const src: []const T = @as([*]const T, @ptrCast(@alignCast(_src)))[0.._src.len];
-    const dst: []T = @as([*]T, @ptrCast(@alignCast(_dst)))[0.._dst.len];
-    const stride: u32 = _stride >> (@sizeOf(T) >> 1);
+fn hvBlurCT(comptime T: type, comptime radius: u32, src: []const T, dst: []T, stride: u32, w: u32, h: u32) void {
     const ksize: u32 = (radius << 1) + 1;
     const iradius: i32 = @bitCast(radius);
     const ih: i32 = @bitCast(h);

diff --git a/src/filters/boxblur_runtime.zig b/src/filters/boxblur_runtime.zig
@@ -8,7 +8,7 @@ const math = std.math;
 
 const allocator = std.heap.c_allocator;
 
-pub fn hvBlur(comptime T: type, src: zapi.Frame, dst: zapi.Frame, d: *Data) void {
+pub fn hvBlur(comptime T: type, src: zapi.ZFrameRO, dst: zapi.ZFrameRW, d: *Data) void {
     const temp1 = allocator.alloc(T, d.tmp_size) catch unreachable;
     const temp2 = allocator.alloc(T, d.tmp_size) catch unreachable;
     defer allocator.free(temp1);
@@ -20,25 +20,22 @@ pub fn hvBlur(comptime T: type, src: zapi.Frame, dst: zapi.Frame, d: *Data) void
             continue;
         }
 
-        const src8 = src.getReadSlice(plane);
-        const dst8 = dst.getWriteSlice(plane);
-        const srcp: []const T = @as([*]const T, @ptrCast(@alignCast(src8)))[0..src8.len];
-        const dstp: []T = @as([*]T, @ptrCast(@alignCast(dst8)))[0..dst8.len];
-        const w, const h, var stride = src.getDimensions(plane);
-        stride >>= (@sizeOf(T) >> 1);
+        const srcp = src.getReadSlice2(T, plane);
+        const dstp = dst.getWriteSlice2(T, plane);
+        const w, const h, const stride = src.getDimensions2(T, plane);
 
         hblur(T, srcp, dstp, stride, w, h, d.hradius, d.hpasses, temp1, temp2);
         vblur(T, dstp, dstp, stride, w, h, d.vradius, d.vpasses, temp1, temp2);
     }
 }
 
-inline fn blurInt(comptime T: type, srcp: []const T, src_step: usize, dstp: []T, dst_step: usize, len: u32, radius: u32) void {
+inline fn blurInt(comptime T: type, srcp: []const T, src_step: u32, dstp: []T, dst_step: u32, len: u32, radius: u32) void {
     const ksize: u32 = (radius << 1) + 1;
     const inv: u64 = @divTrunc(((1 << 32) + @as(u64, radius)), ksize);
     var sum: u64 = srcp[radius * src_step];
     const inv2 = inv >> 16;
 
-    var x: usize = 0;
+    var x: u32 = 0;
     while (x < radius) : (x += 1) {
         sum += @as(u32, srcp[x * src_step]) << 1;
     }
@@ -65,12 +62,12 @@ inline fn blurInt(comptime T: type, srcp: []const T, src_step: usize, dstp: []T,
     }
 }
 
-inline fn blurFloat(comptime T: type, srcp: []const T, src_step: usize, dstp: []T, dst_step: usize, len: u32, radius: u32) void {
+inline fn blurFloat(comptime T: type, srcp: []const T, src_step: u32, dstp: []T, dst_step: u32, len: u32, radius: u32) void {
     const ksize: T = @floatFromInt(radius * 2 + 1);
     const div: T = 1.0 / ksize;
     var sum: T = srcp[radius * src_step];
 
-    var x: usize = 0;
+    var x: u32 = 0;
     while (x < radius) : (x += 1) {
         const srcv: T = srcp[x * src_step];
         sum += srcv * 2;
@@ -101,7 +98,7 @@ inline fn blurFloat(comptime T: type, srcp: []const T, src_step: usize, dstp: []
     }
 }
 
-inline fn blur_passes(comptime T: type, srcp: []const T, dstp: []T, step: usize, len: u32, radius: u32, passes: i32, _tmp1: []T, _tmp2: []T) void {
+inline fn blur_passes(comptime T: type, srcp: []const T, dstp: []T, step: u32, len: u32, radius: u32, passes: i32, _tmp1: []T, _tmp2: []T) void {
     var tmp1 = _tmp1;
     var tmp2 = _tmp2;
     var p: i32 = passes;
@@ -118,7 +115,7 @@ inline fn blur_passes(comptime T: type, srcp: []const T, dstp: []T, step: usize,
         if (p > 1) {
             blurInt(T, tmp1, 1, dstp, step, len, radius);
         } else {
-            var x: usize = 0;
+            var x: u32 = 0;
             while (x < len) : (x += 1) {
                 dstp[x * step] = tmp1[x];
             }
@@ -135,17 +132,17 @@ inline fn blur_passes(comptime T: type, srcp: []const T, dstp: []T, step: usize,
         if (p > 1) {
             blurFloat(T, tmp1, 1, dstp, step, len, radius);
         } else {
-            var x: usize = 0;
+            var x: u32 = 0;
             while (x < len) : (x += 1) {
                 dstp[x * step] = tmp1[x];
             }
         }
     }
 }
 
-fn hblur(comptime T: type, srcp: []const T, dstp: []T, stride: usize, w: u32, h: u32, radius: u32, passes: i32, temp1: []T, temp2: []T) void {
+fn hblur(comptime T: type, srcp: []const T, dstp: []T, stride: u32, w: u32, h: u32, radius: u32, passes: i32, temp1: []T, temp2: []T) void {
     if ((passes > 0) and (radius > 0)) {
-        var y: usize = 0;
+        var y: u32 = 0;
         while (y < h) : (y += 1) {
             blur_passes(
                 T,
@@ -160,7 +157,7 @@ fn hblur(comptime T: type, srcp: []const T, dstp: []T, stride: usize, w: u32, h:
             );
         }
     } else {
-        var y: usize = 0;
+        var y: u32 = 0;
         while (y < h) : (y += 1) {
             const srcp2 = srcp[(y * stride)..];
             const dstp2 = dstp[(y * stride)..];
@@ -169,9 +166,9 @@ fn hblur(comptime T: type, srcp: []const T, dstp: []T, stride: usize, w: u32, h:
     }
 }
 
-fn vblur(comptime T: type, srcp: []const T, dstp: []T, stride: usize, w: u32, h: u32, radius: u32, passes: i32, temp1: []T, temp2: []T) void {
+fn vblur(comptime T: type, srcp: []const T, dstp: []T, stride: u32, w: u32, h: u32, radius: u32, passes: i32, temp1: []T, temp2: []T) void {
     if ((passes > 0) and (radius > 0)) {
-        var x: usize = 0;
+        var x: u32 = 0;
         while (x < w) : (x += 1) {
             blur_passes(
                 T,

diff --git a/src/filters/clahe.zig b/src/filters/clahe.zig
@@ -32,11 +32,11 @@ fn calcLut(
     comptime T: type,
     srcp: []const T,
     stride: u32,
-    width: usize,
-    height: usize,
+    width: u32,
+    height: u32,
     lut: []T,
-    tile_width: usize,
-    tile_height: usize,
+    tile_width: u32,
+    tile_height: u32,
     tiles: []u32,
     clip_limit: i32,
     lut_scale: f32,
@@ -47,15 +47,15 @@ fn calcLut(
     const tiles_x = tiles[0];
     const tiles_y = tiles[1];
 
-    var ty: usize = 0;
+    var ty: u32 = 0;
     while (ty < tiles_y) : (ty += 1) {
-        var tx: usize = 0;
+        var tx: u32 = 0;
         while (tx < tiles_x) : (tx += 1) {
             @memset(&tile_hist, 0);
 
-            var y: usize = ty * tile_height;
+            var y: u32 = ty * tile_height;
             while (y < @min((ty + 1) * tile_height, height)) : (y += 1) {
-                var x: usize = tx * tile_width;
+                var x: u32 = tx * tile_width;
                 while (x < @min((tx + 1) * tile_width, width)) : (x += 1) {
                     tile_hist[srcp[y * stride + x]] += 1;
                 }
@@ -79,7 +79,7 @@ fn calcLut(
 
                 if (residual != 0) {
                     const residual_step = @max(@divTrunc(hist_sizei, residual), 1);
-                    var i: usize = 0;
+                    var i: u32 = 0;
                     while ((i < hist_size) and (residual > 0)) : (i += residual_step) {
                         tile_hist[i] += 1;
                         residual -= 1;
@@ -88,7 +88,7 @@ fn calcLut(
             }
 
             var sum: i32 = 0;
-            var i: usize = 0;
+            var i: u32 = 0;
             while (i < hist_size) : (i += 1) {
                 sum += tile_hist[i];
                 lut[(ty * tiles_x + tx) * hist_size + i] = @intFromFloat(@as(f32, @floatFromInt(sum)) * lut_scale + 0.5);
@@ -102,11 +102,11 @@ fn interpolate(
     srcp: []const T,
     dstp: []T,
     stride: u32,
-    width: usize,
-    height: usize,
+    width: u32,
+    height: u32,
     lut: []const T,
-    tile_width: usize,
-    tile_height: usize,
+    tile_width: u32,
+    tile_height: u32,
     tiles: []u32,
 ) void {
     const hist_size: u32 = @as(u32, 1) << @as(u32, @typeInfo(T).int.bits);
@@ -116,7 +116,7 @@ fn interpolate(
     const inv_tw: f32 = 1.0 / @as(f32, @floatFromInt(tile_width));
     const inv_th: f32 = 1.0 / @as(f32, @floatFromInt(tile_height));
 
-    var y: usize = 0;
+    var y: u32 = 0;
     while (y < height) : (y += 1) {
         const tyf: f32 = @as(f32, @floatFromInt(y)) * inv_th - 0.5;
         var ty1: i32 = @intFromFloat(@floor(tyf));
@@ -128,7 +128,7 @@ fn interpolate(
         const lut_p1 = ty1 * tiles_x;
         const lut_p2 = ty2 * tiles_x;
 
-        var x: usize = 0;
+        var x: u32 = 0;
         while (x < width) : (x += 1) {
             const txf: f32 = @as(f32, @floatFromInt(x)) * inv_tw - 0.5;
             const _tx1: i32 = @intFromFloat(@floor(txf));

diff --git a/src/filters/planeaverage.zig b/src/filters/planeaverage.zig
@@ -23,9 +23,8 @@ fn result(comptime T: type, acc: anytype, total: f64, peak: f32) f64 {
     }
 }
 
-pub fn average(comptime T: type, src: []const u8, _stride: usize, w: usize, h: usize, exclude_union: Exclude, peak: f32) f64 {
-    var srcp: []const T = @as([*]const T, @ptrCast(@alignCast(src)))[0..src.len];
-    const stride: usize = @divTrunc(_stride, @sizeOf(T));
+pub fn average(comptime T: type, src: []const T, stride: u32, w: u32, h: u32, exclude_union: Exclude, peak: f32) f64 {
+    var srcp: []const T = src;
     const exclude = if (@typeInfo(T) == .float) exclude_union.f else exclude_union.i;
     var total: i64 = @intCast(w * h);
     var acc: if (@typeInfo(T) == .float) f64 else u64 = 0;
@@ -48,10 +47,10 @@ pub fn average(comptime T: type, src: []const u8, _stride: usize, w: usize, h: u
     return result(T, acc, @floatFromInt(total), peak);
 }
 
-pub fn averageRef(comptime T: type, src: []const u8, ref: []const u8, _stride: usize, w: usize, h: usize, exclude_union: Exclude, peak: f32) Stats {
-    var srcp: []const T = @as([*]const T, @ptrCast(@alignCast(src)))[0..src.len];
-    var refp: []const T = @as([*]const T, @ptrCast(@alignCast(ref)))[0..ref.len];
-    const stride: usize = @divTrunc(_stride, @sizeOf(T));
+pub fn averageRef(comptime T: type, src: []const T, ref: []const T, stride: u32, w: u32, h: u32, exclude_union: Exclude, peak: f32) Stats {
+    var srcp: []const T = src;
+    var refp: []const T = ref;
+
     const exclude = if (@typeInfo(T) == .float) exclude_union.f else exclude_union.i;
     const _total: i64 = @intCast(w * h);
     var total = _total;

diff --git a/src/filters/planeminmax.zig b/src/filters/planeminmax.zig
@@ -23,9 +23,8 @@ pub const Stats = union(enum) {
     i: StatsInt,
 };
 
-pub fn minMaxInt(comptime T: type, src: []const u8, _stride: usize, w: usize, h: usize, d: *Data) Stats {
-    var srcp: []const T = @as([*]const T, @ptrCast(@alignCast(src)))[0..src.len];
-    const stride: usize = @divTrunc(_stride, @sizeOf(T));
+pub fn minMaxInt(comptime T: type, src: []const T, stride: u32, w: u32, h: u32, d: *Data) Stats {
+    var srcp: []const T = src;
     const total: f64 = @floatFromInt(w * h);
 
     const accum_buf = allocator.alignedAlloc(u32, 32, 65536) catch unreachable;
@@ -63,9 +62,8 @@ pub fn minMaxInt(comptime T: type, src: []const u8, _stride: usize, w: usize, h:
     return .{ .i = .{ .max = retvalmax, .min = retvalmin, .diff = undefined } };
 }
 
-pub fn minMaxFloat(comptime T: type, src: []const u8, _stride: usize, w: usize, h: usize, d: *Data) Stats {
-    var srcp: []const T = @as([*]const T, @ptrCast(@alignCast(src)))[0..src.len];
-    const stride: usize = @divTrunc(_stride, @sizeOf(T));
+pub fn minMaxFloat(comptime T: type, src: []const T, stride: u32, w: u32, h: u32, d: *Data) Stats {
+    var srcp: []const T = src;
     const total: f64 = @floatFromInt(w * h);
 
     const accum_buf = allocator.alignedAlloc(u32, 32, 65536) catch unreachable;
@@ -105,10 +103,9 @@ pub fn minMaxFloat(comptime T: type, src: []const u8, _stride: usize, w: usize,
     return .{ .f = .{ .max = retvalmaxf, .min = retvalminf, .diff = undefined } };
 }
 
-pub fn minMaxIntRef(comptime T: type, src: []const u8, ref: []const u8, _stride: usize, w: usize, h: usize, d: *Data) Stats {
-    var srcp: []const T = @as([*]const T, @ptrCast(@alignCast(src)))[0..src.len];
-    var refp: []const T = @as([*]const T, @ptrCast(@alignCast(ref)))[0..ref.len];
-    const stride: usize = @divTrunc(_stride, @sizeOf(T));
+pub fn minMaxIntRef(comptime T: type, src: []const T, ref: []const T, stride: u32, w: u32, h: u32, d: *Data) Stats {
+    var srcp: []const T = src;
+    var refp: []const T = ref;
     const total: f64 = @floatFromInt(w * h);
     var diffacc: u64 = 0;
 
@@ -150,10 +147,9 @@ pub fn minMaxIntRef(comptime T: type, src: []const u8, ref: []const u8, _stride:
     return .{ .i = .{ .max = retvalmax, .min = retvalmin, .diff = diff } };
 }
 
-pub fn minMaxFloatRef(comptime T: type, src: []const u8, ref: []const u8, _stride: usize, w: usize, h: usize, d: *Data) Stats {
-    var srcp: []const T = @as([*]const T, @ptrCast(@alignCast(src)))[0..src.len];
-    var refp: []const T = @as([*]const T, @ptrCast(@alignCast(ref)))[0..ref.len];
-    const stride: usize = @divTrunc(_stride, @sizeOf(T));
+pub fn minMaxFloatRef(comptime T: type, src: []const T, ref: []const T, stride: u32, w: u32, h: u32, d: *Data) Stats {
+    var srcp: []const T = src;
+    var refp: []const T = ref;
     const total: f64 = @floatFromInt(w * h);
     var diffacc: f64 = 0;
 

diff --git a/src/helper.zig b/src/helper.zig
@@ -11,10 +11,10 @@ pub const DataType = enum {
     F16,
     F32,
 
-    pub fn select(map: zapi.Map, node: ?*vs.Node, vi: *const vs.VideoInfo, comptime name: []const u8) !DataType {
-        var err_msg: ?[*]const u8 = null;
+    pub fn select(map: zapi.ZMapRW, node: ?*vs.Node, vi: *const vs.VideoInfo, comptime name: []const u8) !DataType {
+        var err_msg: ?[]const u8 = null;
         errdefer {
-            map.vsapi.?.mapSetError.?(map.out, err_msg.?);
+            map.setError(err_msg.?);
             map.vsapi.?.freeNode.?(node);
         }
 
@@ -44,23 +44,19 @@ pub fn absDiff(x: anytype, y: anytype) @TypeOf(x) {
     return if (x > y) (x - y) else (y - x);
 }
 
-pub fn mapGetPlanes(in: ?*const vs.Map, out: ?*vs.Map, nodes: []?*vs.Node, process: []bool, num_planes: c_int, comptime name: []const u8, vsapi: ?*const vs.API) !void {
-    const num_e = vsapi.?.mapNumElements.?(in, "planes");
-    if (num_e < 1) {
-        return;
-    }
-
+pub fn mapGetPlanes(in: zapi.ZMapRO, out: zapi.ZMapRW, nodes: []?*vs.Node, process: []bool, num_planes: c_int, comptime name: []const u8, vsapi: ?*const vs.API) !void {
+    const num_e = in.numElements("planes") orelse return;
     @memset(process, false);
 
-    var err_msg: ?[*]const u8 = null;
+    var err_msg: ?[]const u8 = null;
     errdefer {
-        vsapi.?.mapSetError.?(out, err_msg.?);
+        out.setError(err_msg.?);
         for (nodes) |node| vsapi.?.freeNode.?(node);
     }
 
     var i: u32 = 0;
     while (i < num_e) : (i += 1) {
-        const e: i32 = vsh.mapGetN(i32, in, "planes", i, vsapi).?;
+        const e = in.getInt2(i32, "planes", i).?;
         if ((e < 0) or (e >= num_planes)) {
             err_msg = name ++ ": plane index out of range";
             return error.ValidationError;
@@ -76,14 +72,14 @@ pub fn mapGetPlanes(in: ?*const vs.Map, out: ?*vs.Map, nodes: []?*vs.Node, proce
     }
 }
 
-pub fn compareNodes(out: ?*vs.Map, node1: ?*vs.Node, node2: ?*vs.Node, vi1: *const vs.VideoInfo, vi2: *const vs.VideoInfo, comptime name: []const u8, vsapi: ?*const vs.API) !void {
+pub fn compareNodes(out: zapi.ZMapRW, node1: ?*vs.Node, node2: ?*vs.Node, vi1: *const vs.VideoInfo, vi2: *const vs.VideoInfo, comptime name: []const u8, vsapi: ?*const vs.API) !void {
     if (node2 == null) {
         return;
     }
 
-    var err_msg: ?[*]const u8 = null;
+    var err_msg: ?[]const u8 = null;
     errdefer {
-        vsapi.?.mapSetError.?(out, err_msg.?);
+        out.setError(err_msg.?);
         vsapi.?.freeNode.?(node1);
         vsapi.?.freeNode.?(node2);
     }