fix: Diff percentage regression

In v4 parsable stdout doesn't print diff percentage

Author: dmtrKovalenko

build.zig

@@ -254,7 +254,7 @@ fn configurePlatformLibraries(
     const native_target = b.resolveTargetQuery(.{});
     const is_cross_compiling = target_info.cpu.arch != native_target.result.cpu.arch or
         target_info.os.tag != native_target.result.os.tag;
-    
+
     // For cross-compilation, vcpkg is required - don't fall back to native libraries
     if (is_cross_compiling) {
         std.log.err("Cross-compilation requires vcpkg libraries. Target: {s}-{s}", .{ @tagName(target_info.cpu.arch), @tagName(target_info.os.tag) });
@@ -486,7 +486,11 @@ fn tryConfigureVcpkg(
     if (target_info.os.tag == .windows) {
         lib.linkSystemLibrary("zlib"); // vcpkg installs as libzlib.a on Windows
         lib.linkSystemLibrary("lzma"); // vcpkg installs as liblzma.a
-        // Note: deflate library not available in vcpkg mingw-static, skip it
+        //
+        // Link GCC runtime for emulated TLS (__emutls_get_address)
+        // This is required for libjpeg-turbo which uses thread-local storage in SIMD code
+        lib.linkSystemLibrary("gcc_s");
+        lib.linkSystemLibrary("gcc");
     } else {
         lib.linkSystemLibrary("z");
         lib.linkSystemLibrary("lzma");

npm_package/odiff.js

@@ -73,44 +73,33 @@ function optionsToArgs(options) {
 /** @type {(stdout: string) => Partial<{ diffCount: number, diffPercentage: number, diffLines: number[] }>} */
 function parsePixelDiffStdout(stdout) {
   try {
-    const lines = stdout.trim().split('\n');
-    
-    if (lines.length >= 1) {
-      const diffCount = parseInt(lines[0]);
-      
-      if (isNaN(diffCount)) {
-        throw new Error(`Invalid diff count: ${lines[0]}`);
-      }
-      
-      const result = { diffCount };
-      
-      // Calculate percentage (odiff outputs absolute count, we calculate percentage)
-      // This is approximate - in a real implementation we'd need image dimensions
-      if (lines.length >= 2) {
-        const diffPercentage = parseFloat(lines[1]);
-        if (!isNaN(diffPercentage)) {
-          result.diffPercentage = diffPercentage;
-        }
-      }
-      
-      // Parse diff lines if present
-      if (lines.length >= 3) {
-        const diffLines = lines.slice(2)
-          .map(line => parseInt(line.trim()))
-          .filter(line => !isNaN(line));
-        
-        if (diffLines.length > 0) {
-          result.diffLines = diffLines;
-        }
-      }
-      
-      return result;
+    const parts = stdout.trim().split(";");
+
+    if (parts.length === 2) {
+      const [diffCount, diffPercentage] = parts;
+
+      return {
+        diffCount: parseInt(diffCount),
+        diffPercentage: parseFloat(diffPercentage),
+      };
+    } else if (parts.length === 3) {
+      const [diffCount, diffPercentage, linesPart] = parts;
+
+      return {
+        diffCount: parseInt(diffCount),
+        diffPercentage: parseFloat(diffPercentage),
+        diffLines: linesPart.split(",").flatMap((line) => {
+          let parsedInt = parseInt(line);
+
+          return isNaN(parsedInt) ? [] : parsedInt;
+        }),
+      };
     } else {
-      throw new Error(`No output lines found: ${stdout}`);
+      throw new Error(`Unparsable stdout from odiff binary: ${stdout}`);
     }
   } catch (e) {
     console.warn(
-      "Can't parse output from internal process. Please submit an issue at https://github.com/odiff-project/odiff/issues/new with the following stacktrace:",
+      "Can't parse output from internal process. Please submit an issue at https://github.com/dmtrKovalenko/odiff/issues/new with the following stacktrace:",
       e
     );
   }

src/diff.zig

@@ -217,7 +217,7 @@ pub noinline fn compareSameLayouts(base: *const Image, comp: *const Image, diff_
     const base_data = base.data;
     const comp_data = comp.data;
 
-    const SIMD_SIZE = if (HAS_AVX512) 16 else if (HAS_NEON) 8 else 4;
+    const SIMD_SIZE = std.simd.suggestVectorLength(u32) orelse if (HAS_AVX512) 16 else if (HAS_NEON) 8 else 4;
     const simd_end = (size / SIMD_SIZE) * SIMD_SIZE;
 
     var offset: usize = 0;

src/main.zig

@@ -131,14 +131,17 @@ pub fn main() !void {
                 }
 
                 if (args.parsable_stdout) {
-                    stdout.print("{d}\n", .{pixel_result.diff_count}) catch {};
+                    stdout.print("{d};{d:.2}", .{ pixel_result.diff_count, pixel_result.diff_percentage }) catch {};
                     if (pixel_result.diff_lines) |diff_lines| {
                         if (diff_lines.count > 0) {
-                            for (diff_lines.getItems()) |line| {
-                                stdout.print("{d}\n", .{line}) catch {};
+                            stdout.print(";", .{}) catch {};
+                            for (diff_lines.getItems(), 0..) |line, i| {
+                                if (i > 0) stdout.print(",", .{}) catch {};
+                                stdout.print("{d}", .{line}) catch {};
                             }
                         }
                     }
+                    stdout.print("\n", .{}) catch {};
                 } else {
                     print("Found {d} different pixels ({d:.2}%)\n", .{ pixel_result.diff_count, pixel_result.diff_percentage });
                     if (args.diff_lines) {

test/node-binding.test.cjs

@@ -3,33 +3,27 @@ const test = require("ava");
 const { compare } = require("../npm_package/odiff");
 
 const IMAGES_PATH = path.resolve(__dirname, "..", "images");
-const BINARY_PATH = path.resolve(
-  __dirname,
-  "..",
-  "zig-out",
-  "bin",
-  "odiff"
-);
+const BINARY_PATH = path.resolve(__dirname, "..", "zig-out", "bin", "odiff");
 
 console.log(`Testing binary ${BINARY_PATH}`);
 
 const options = {
   __binaryPath: BINARY_PATH,
-}
+};
 
 test("Outputs correct parsed result when images different", async (t) => {
   const result = await compare(
     path.join(IMAGES_PATH, "donkey.png"),
     path.join(IMAGES_PATH, "donkey-2.png"),
     path.join(IMAGES_PATH, "diff.png"),
-    options
+    options,
   );
 
   t.is(result.reason, "pixel-diff");
-  t.true(typeof result.diffCount === 'number');
+  t.true(typeof result.diffCount === "number");
   t.true(result.diffCount > 0);
   console.log(`Found ${result.diffCount} different pixels`);
-})
+});
 
 test("Correctly works with reduceRamUsage", async (t) => {
   const result = await compare(
@@ -39,11 +33,11 @@ test("Correctly works with reduceRamUsage", async (t) => {
     {
       ...options,
       reduceRamUsage: true,
-    }
+    },
   );
 
   t.is(result.reason, "pixel-diff");
-  t.true(typeof result.diffCount === 'number');
+  t.true(typeof result.diffCount === "number");
   t.true(result.diffCount > 0);
 });
 
@@ -55,11 +49,11 @@ test("Correctly parses threshold", async (t) => {
     {
       ...options,
       threshold: 0.5,
-    }
+    },
   );
 
   t.is(result.reason, "pixel-diff");
-  t.true(typeof result.diffCount === 'number');
+  t.true(typeof result.diffCount === "number");
   t.true(result.diffCount > 0);
 });
 
@@ -71,11 +65,11 @@ test("Correctly parses antialiasing", async (t) => {
     {
       ...options,
       antialiasing: true,
-    }
+    },
   );
 
   t.is(result.reason, "pixel-diff");
-  t.true(typeof result.diffCount === 'number');
+  t.true(typeof result.diffCount === "number");
   t.true(result.diffCount > 0);
 });
 
@@ -100,32 +94,32 @@ test("Correctly parses ignore regions", async (t) => {
           y2: 1334,
         },
       ],
-    }
+    },
   );
 
   // With our placeholder images, this might still show differences
   // but the test should at least run without errors
-  t.true(typeof result.match === 'boolean');
+  t.true(typeof result.match === "boolean");
 });
 
 test("Outputs correct parsed result when images different for cypress image", async (t) => {
   const result = await compare(
     path.join(IMAGES_PATH, "www.cypress.io.png"),
     path.join(IMAGES_PATH, "www.cypress.io-1.png"),
     path.join(IMAGES_PATH, "diff.png"),
-    options
+    options,
   );
 
   // Our placeholder implementation returns synthetic data, so we just check structure
-  t.true(typeof result.match === 'boolean');
+  t.true(typeof result.match === "boolean");
 });
 
 test("Correctly handles same images", async (t) => {
   const result = await compare(
     path.join(IMAGES_PATH, "donkey.png"),
     path.join(IMAGES_PATH, "donkey.png"),
     path.join(IMAGES_PATH, "diff.png"),
-    options
+    options,
   );
 
   // With placeholder C implementation, identical images should match
@@ -139,8 +133,8 @@ test("Correctly outputs diff lines", async (t) => {
     path.join(IMAGES_PATH, "diff.png"),
     {
       captureDiffLines: true,
-      ...options
-    }
+      ...options,
+    },
   );
 
   t.is(result.match, false);
@@ -158,10 +152,35 @@ test("Returns meaningful error if file does not exist and noFailOnFsErrors", asy
     {
       ...options,
       noFailOnFsErrors: true,
-    }
+    },
   );
 
   t.is(result.match, false);
   // Our error handling might be different, but it should handle the case gracefully
-  t.true(['file-not-exists', 'pixel-diff'].includes(result.reason));
-});
+  t.true(["file-not-exists", "pixel-diff"].includes(result.reason));
+});
+
+test("Correctly calculates and outputs diff percentage", async (t) => {
+  const result = await compare(
+    path.join(__dirname, "png", "orange.png"),
+    path.join(__dirname, "png", "orange_diff.png"),
+    path.join(IMAGES_PATH, "diff.png"),
+    options,
+  );
+
+  t.is(result.match, false);
+  t.is(result.reason, "pixel-diff");
+
+  t.true(typeof result.diffPercentage === "number");
+  t.true(result.diffPercentage > 0);
+  t.true(typeof result.diffCount === "number");
+  t.true(result.diffCount > 0);
+
+  const expectedPercentage = (result.diffCount / (510 * 234)) * 100;
+  t.true(Math.abs(result.diffPercentage - expectedPercentage) < 0.01);
+
+  console.log(
+    `Percentage test: ${result.diffCount} pixels (${result.diffPercentage}%)`,
+  );
+});
+

vcpkg.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg-tool/main/docs/vcpkg.schema.json",
   "builtin-baseline": "fe1cde61e971d53c9687cf9a46308f8f55da19fa",
-  "dependencies": ["libspng", "tiff", "libjpeg-turbo"]
+  "dependencies": ["libspng", "tiff", "libjpeg-turbo", "liblzma"]
 }