tests: add VISP_BACKEND_TEST macro

Acly · Acly · commit 7a2986795daa · 2025-07-23T11:13:15.000+02:00
- simplify running tests for all backends
- allow to skip gpu tests from command line
diff --git a/include/visp/util.hpp b/include/visp/util.hpp
@@ -146,9 +146,17 @@ struct flags {
         return (lhs.value & uint32_t(rhs)) != 0;
     }
 
+    friend constexpr bool operator&(flags<E> lhs, flags<E> rhs) {
+        return (lhs.value & rhs.value) != 0;
+    }
+
     friend constexpr flags<E> operator|(flags<E> lhs, E rhs) {
         return flags<E>(lhs.value | uint32_t(rhs));
     }
+
+    friend constexpr flags<E> operator|(flags<E> lhs, flags<E> rhs) {
+        return flags<E>(lhs.value | rhs.value);
+    }
 };
 
 } // namespace visp
diff --git a/src/cli/cli.cpp b/src/cli/cli.cpp
@@ -35,7 +35,7 @@ char const* next_arg(int argc, char** argv, int& i) {
     if (++i < argc) {
         return argv[i];
     } else {
-        throw error("Missing argument after {}", argv[i - 1]);
+        throw except("Missing argument after {}", argv[i - 1]);
     }
 }
 
@@ -45,7 +45,7 @@ std::vector<char const*> collect_args(int argc, char** argv, int& i, char delim
         r.push_back(next_arg(argc, argv, i));
     } while (i + 1 < argc && argv[i + 1][0] != delim);
     if (r.empty()) {
-        throw error("Missing argument after {}", argv[i - 1]);
+        throw except("Missing argument after {}", argv[i - 1]);
     }
     return r;
 }
@@ -54,21 +54,21 @@ int parse_int(std::string_view arg) {
     int value = 0;
     auto [ptr, ec] = std::from_chars(arg.data(), arg.data() + arg.size(), value);
     if (ec != std::errc()) {
-        throw error("Invalid integer argument: {}", arg);
+        throw except("Invalid integer argument: {}", arg);
     }
     return value;
 }
 
 char const* validate_path(char const* arg) {
     if (!exists(path(arg))) {
-        throw error("File not found: {}", arg);
+        throw except("File not found: {}", arg);
     }
     return arg;
 }
 
 void require_inputs(std::span<char const* const> inputs, int n_required, char const* names) {
     if (inputs.size() != size_t(n_required)) {
-        throw error(
+        throw except(
             "Expected -i to be followed by {} inputs: {} - but found {}.", n_required, names,
             inputs.size());
     }
@@ -77,7 +77,7 @@ void require_inputs(std::span<char const* const> inputs, int n_required, char co
 cli_args cli_parse(int argc, char** argv) {
     cli_args r;
     if (argc < 2) {
-        throw error("Missing command.\nUsage: {} <command> [options]", argv[0]);
+        throw except("Missing command.\nUsage: {} <command> [options]", argv[0]);
     }
 
     std::string_view arg1 = argv[1];
@@ -90,7 +90,7 @@ cli_args cli_parse(int argc, char** argv) {
     } else if (arg1 == "esrgan") {
         r.command = cli_command::esrgan;
     } else {
-        throw error("Unknown command: {}", arg1);
+        throw except("Unknown command: {}", arg1);
     }
 
     for (int i = 2; i < argc; ++i) {
@@ -111,14 +111,14 @@ cli_args cli_parse(int argc, char** argv) {
             } else if (backend_arg == "gpu") {
                 r.bknd_type = backend_type::gpu;
             } else {
-                throw error("Unknown backend type '{}', must be one of: cpu, gpu", backend_arg);
+                throw except("Unknown backend type '{}', must be one of: cpu, gpu", backend_arg);
             }
         } else if (arg == "--composite") {
             r.composite = next_arg(argc, argv, i);
         } else if (arg == "--tile") {
             r.tile_size = parse_int(next_arg(argc, argv, i));
         } else if (arg.starts_with("-")) {
-            throw error("Unknown argument: {}", arg);
+            throw except("Unknown argument: {}", arg);
         }
     }
     return r;
@@ -255,12 +255,12 @@ struct sam_prompt {
 
 sam_prompt sam_parse_prompt(std::span<char const* const> args, i32x2 extent) {
     if (args.empty()) {
-        throw error(
+        throw except(
             "SAM requires a prompt with coordinates for a point or box"
             "eg. '--prompt 100 200' to pick the point at pixel (x=100, y=200)");
     }
     if (args.size() < 2 || args.size() > 4) {
-        throw error(
+        throw except(
             "Invalid number of arguments for SAM prompt. Expected 2 (point) or 4 (box) numbers, "
             "got {}",
             args.size());
@@ -269,17 +269,17 @@ sam_prompt sam_parse_prompt(std::span<char const* const> args, i32x2 extent) {
     if (args.size() >= 2) {
         a = {parse_int(args[0]), parse_int(args[1])};
         if (a[0] < 0 || a[1] < 0 || a[0] >= extent[0] || a[1] >= extent[1]) {
-            throw error("Invalid image coordinates: ({}, {})", a[0], a[1]);
+            throw except("Invalid image coordinates: ({}, {})", a[0], a[1]);
         }
     }
     i32x2 b{-1, -1};
     if (args.size() == 4) {
         b = {parse_int(args[2]), parse_int(args[3])};
         if (b[0] < 0 || b[1] < 0 || b[0] >= extent[0] || b[1] >= extent[1]) {
-            throw error("Invalid image coordinates: ({}, {})", b[0], b[1]);
+            throw except("Invalid image coordinates: ({}, {})", b[0], b[1]);
         }
         if (a[0] >= b[0] || a[1] >= b[1]) {
-            throw error("Invalid box coordinates: ({}, {}) to ({}, {})", a[0], a[1], b[0], b[1]);
+            throw except("Invalid box coordinates: ({}, {}) to ({}, {})", a[0], a[1], b[0], b[1]);
         }
     }
     return sam_prompt{a, b};
diff --git a/src/util/string.hpp b/src/util/string.hpp
@@ -66,8 +66,8 @@ template <size_t N, typename... Args>
 char const* format(fixed_string<N>& dst, char const* fmt, Args&&... args) {
     auto it = truncating_iterator(dst.data, N);
     auto out = fmt::vformat_to(it, fmt, fmt::make_format_args(args...));
-    dst.data[N - 1] = 0;
     dst.length = std::min(size_t(out - it), N - 1);
+    dst.data[dst.length] = 0;
     return dst.c_str();
 }
 
@@ -79,7 +79,7 @@ String format(char const* fmt, Args&&... args) {
 }
 
 template <typename... Args>
-exception error(char const* fmt, Args&&... args) {
+exception except(char const* fmt, Args&&... args) {
     return exception(format<fixed_string<128>>(fmt, std::forward<Args>(args)...));
 }
 
diff --git a/src/visp/birefnet.cpp b/src/visp/birefnet.cpp
@@ -588,14 +588,14 @@ const swin_params swin_l_params = {
 swin_params swin_detect_params(model_ref m) {
     tensor t = m.find("bb.layers.0.blocks.0.attn.proj.bias");
     if (t == nullptr) {
-        throw error("Failed to detect model parameters");
+        throw except("Failed to detect model parameters");
     }
     if (t->ne[0] == 96) {
         return swin_t_params;
     } else if (t->ne[0] == 192) {
         return swin_l_params;
     } else {
-        throw error("Unsupported Swin Transformer embed dim: {}", t->ne[0]);
+        throw except("Unsupported Swin Transformer embed dim: {}", t->ne[0]);
     }
 }
 
diff --git a/src/visp/esrgan.cpp b/src/visp/esrgan.cpp
@@ -102,10 +102,10 @@ esrgan_params esrgan_detect_params(model_ref m) {
     // 3 layers per upscale block, each upscales x2, 5 blocks for the rest of the model
     p.scale = 1 << ((model_len - 5) / 3);
     if (p.scale < 2 || p.scale > 4) {
-        throw error("Unsupported scale: {}", p.scale);
+        throw except("Unsupported scale: {}", p.scale);
     }
     if (p.n_blocks < 1 || p.n_blocks > 23) {
-        throw error("Invalid number of blocks: {}", p.n_blocks);
+        throw except("Invalid number of blocks: {}", p.n_blocks);
     }
     return p;
 }
diff --git a/src/visp/image.cpp b/src/visp/image.cpp
@@ -184,7 +184,7 @@ image_data image_load(char const* filepath) {
     int channels = 0;
     uint8_t* pixels = stbi_load(filepath, &extent[0], &extent[1], &channels, 0);
     if (!pixels) {
-        throw error("Failed to load image {}: {}", filepath, stbi_failure_reason());
+        throw except("Failed to load image {}: {}", filepath, stbi_failure_reason());
     }
     image_format format = image_format_from_channels(channels);
     return image_data(extent, format, std::unique_ptr<uint8_t[]>(pixels));
@@ -195,12 +195,12 @@ void image_save(image_view const& img, char const* filepath) {
     
     if (!(img.format == image_format::alpha_u8 || img.format == image_format::rgb_u8 ||
           img.format == image_format::rgba_u8)) {
-        throw error("Unsupported image format [{}]", int(img.format));
+        throw except("Unsupported image format [{}]", int(img.format));
     }
     int comp = n_channels(img.format);
     if (!stbi_write_png(
             filepath, img.extent[0], img.extent[1], comp, img.data, img.extent[0] * comp)) {
-        throw error("Failed to save image {}", filepath);
+        throw except("Failed to save image {}", filepath);
     }
 }
 
@@ -338,7 +338,7 @@ void image_scale(image_view const& img, i32x2 target, image_span const& dst) {
             STBIR_COLORSPACE_SRGB, nullptr);
     }
     if (result == 0) {
-        throw error(
+        throw except(
             "Failed to resize image {}x{} to {}x{}", img.extent[0], img.extent[1], target[0],
             target[1]);
     }
diff --git a/src/visp/ml.cpp b/src/visp/ml.cpp
@@ -52,7 +52,7 @@ backend_device backend_init(backend_type type) {
     backend_device b;
     b.handle.reset(ggml_backend_init_by_type(convert(type), nullptr));
     if (!b.handle) {
-        throw error("Failed to initialize backend, no suitable device available");
+        throw except("Failed to initialize backend, no suitable device available");
     }
     b.device = ggml_backend_get_device(b.handle.get());
 
@@ -305,7 +305,7 @@ tensor model_ref::weights(char const* name) const {
     if (tensor result = find(name)) {
         return result;
     }
-    throw error("tensor not found: {}.{}", prefix.view(), name);
+    throw except("tensor not found: {}.{}", prefix.view(), name);
 }
 
 model_ref model_ref::with_prefix(tensor_name new_prefix) const {
@@ -360,13 +360,13 @@ tensor_data tensor_alloc(tensor x) {
 tensor_data tensor_load(tensor x, char const* filepath) {
     FILE* file = fopen(filepath, "rb");
     if (!file) {
-        throw error("Failed to open file: {}", filepath);
+        throw except("Failed to open file: {}", filepath);
     }
     tensor_data result = tensor_alloc(x);
     size_t read = fread(result.data.get(), 1, ggml_nbytes(x), file);
     fclose(file);
     if (read != ggml_nbytes(x)) {
-        throw error("Failed to read data from file: {}", filepath);
+        throw except("Failed to read data from file: {}", filepath);
     }
     return result;
 }
diff --git a/tests/test-image.cpp b/tests/test-image.cpp
@@ -8,7 +8,7 @@
 
 namespace visp {
 
-TEST_CASE(image_formats) {
+VISP_TEST(image_formats) {
     auto formats = std::array{image_format::rgba_u8, image_format::bgra_u8,  image_format::argb_u8,
                               image_format::rgb_u8,  image_format::alpha_u8, image_format::rgba_f32,
                               image_format::rgb_f32, image_format::alpha_f32};
@@ -36,14 +36,14 @@ TEST_CASE(image_formats) {
     }
 }
 
-TEST_CASE(image_load) {
+VISP_TEST(image_load) {
     image_data img = image_load((test_dir().input / "cat-and-hat.jpg").string().c_str());
     CHECK(img.extent == i32x2{512, 512});
     CHECK(img.format == image_format::rgb_u8);
     CHECK(n_bytes(img) == 512 * 512 * 3);
 }
 
-TEST_CASE(image_save) {
+VISP_TEST(image_save) {
     image_data img = image_alloc(i32x2{16, 16}, image_format::rgba_u8);
     for (int i = 0; i < 16 * 16; ++i) {
         img.data.get()[i * 4 + 0] = 255;
@@ -74,20 +74,20 @@ void test_image_u8_to_f32(
     CHECK_IMAGES_EQUAL(output, expected);
 }
 
-TEST_CASE(image_alpha_u8_to_alpha_f32) {
+VISP_TEST(image_alpha_u8_to_alpha_f32) {
     test_image_u8_to_f32(
         image_format::alpha_u8, image_format::alpha_f32, //
         std::array<uint8_t, 4>{0, 128, 190, 255},        //
         std::array<float, 4>{0.05f, 0.3f, 0.4225f, 0.55f});
 }
-TEST_CASE(image_rgb_u8_to_rgb_f32) {
+VISP_TEST(image_rgb_u8_to_rgb_f32) {
     test_image_u8_to_f32(
         image_format::rgb_u8, image_format::rgb_f32,                                  //
         std::array<uint8_t, 12>{0, 128, 192, 255, 0, 128, 128, 255, 0, 128, 64, 255}, //
         std::array<float, 12>{
             0.05f, 0.7f, -1.05f, 0.55f, 0.2f, -0.8f, 0.3f, 1.2f, -0.3f, 0.3f, 0.45f, -1.3f});
 }
-TEST_CASE(image_rgba_u8_to_rgb_f32) {
+VISP_TEST(image_rgba_u8_to_rgb_f32) {
     test_image_u8_to_f32(
         image_format::rgba_u8, image_format::rgb_f32, //
         std::array<uint8_t, 16>{
@@ -101,7 +101,7 @@ TEST_CASE(image_rgba_u8_to_rgb_f32) {
             0.3f, 1.2f, -0.3f,   //
             0.3f, 0.45f, -1.3f});
 }
-TEST_CASE(image_rgba_u8_to_rgba_f32) {
+VISP_TEST(image_rgba_u8_to_rgba_f32) {
     test_image_u8_to_f32(
         image_format::rgba_u8, image_format::rgba_f32, //
         std::array<uint8_t, 16>{
@@ -115,7 +115,7 @@ TEST_CASE(image_rgba_u8_to_rgba_f32) {
             0.3f, 1.2f, -0.3f, 0.9f, 0.3f, //
             0.45f, -1.3f, 1.4f});
 }
-TEST_CASE(image_bgra_u8_to_rgb_f32) {
+VISP_TEST(image_bgra_u8_to_rgb_f32) {
     test_image_u8_to_f32(
         image_format::bgra_u8, image_format::rgb_f32, //
         std::array<uint8_t, 16>{
@@ -129,7 +129,7 @@ TEST_CASE(image_bgra_u8_to_rgb_f32) {
             0.3f, 1.2f, -0.3f,   //
             0.3f, 0.45f, -1.3f});
 }
-TEST_CASE(image_argb_u8_to_rgb_f32) {
+VISP_TEST(image_argb_u8_to_rgb_f32) {
     test_image_u8_to_f32(
         image_format::argb_u8, image_format::rgb_f32, //
         std::array<uint8_t, 16>{
@@ -144,7 +144,7 @@ TEST_CASE(image_argb_u8_to_rgb_f32) {
             0.3f, 0.45f, -1.3f});
 }
 
-TEST_CASE(image_u8_to_f32_tiled_pad) {
+VISP_TEST(image_u8_to_f32_tiled_pad) {
     std::array<uint8_t, 9> input_data = {0, 0, 102, 0, 0, 255, 0, 0, 102};
     std::array<float, 4> expected_data = {1.0f, 1.0f, 0.4f, 0.4f};
     image_view input(i32x2{3, 3}, image_format::alpha_u8, input_data);
@@ -159,7 +159,7 @@ TEST_CASE(image_u8_to_f32_tiled_pad) {
     CHECK_IMAGES_EQUAL(output, expected);
 }
 
-TEST_CASE(image_alpha_f32_to_alpha_u8) {
+VISP_TEST(image_alpha_f32_to_alpha_u8) {
     std::array<float, 4> input_data{0.0f, 0.3f, 0.4225f, 1.1f};
     std::array<uint8_t, 4> expected_data = {0, 76, 107, 255};
     image_view input(i32x2{2, 2}, image_format::alpha_f32, input_data.data());
@@ -171,7 +171,7 @@ TEST_CASE(image_alpha_f32_to_alpha_u8) {
     CHECK_IMAGES_EQUAL(output, expected);
 }
 
-TEST_CASE(image_rgb_f32_to_rgba_u8) {
+VISP_TEST(image_rgb_f32_to_rgba_u8) {
     std::array<float, 6> input_data{0.0f, 0.31f, -0.51f, 1.0f, 0.2f, 1.8f};
     std::array<uint8_t, 8> expected_data = {0, 79, 0, 255, 255, 51, 255, 255};
     image_view input(i32x2{2, 1}, image_format::rgb_f32, input_data.data());
@@ -183,7 +183,7 @@ TEST_CASE(image_rgb_f32_to_rgba_u8) {
     CHECK_IMAGES_EQUAL(output, expected);
 }
 
-TEST_CASE(image_scale) {
+VISP_TEST(image_scale) {
     image_data img = image_alloc(i32x2{8, 8}, image_format::rgba_u8);
     for (int i = 0; i < 8 * 8; ++i) {
         img.data[i * 4 + 0] = uint8_t(255);
@@ -202,7 +202,7 @@ TEST_CASE(image_scale) {
     }
 }
 
-TEST_CASE(image_alpha_composite) {
+VISP_TEST(image_alpha_composite) {
     std::array<uint8_t, 2 * 2 * 4> fg_data = {255, 0, 0,   255, 0,   255, 0, 255, //
                                               0,   0, 255, 255, 255, 255, 0, 255};
     image_view fg{i32x2{2, 2}, image_format::rgba_u8, fg_data};
@@ -222,7 +222,7 @@ TEST_CASE(image_alpha_composite) {
     CHECK_IMAGES_EQUAL(output, expected);
 }
 
-TEST_CASE(image_blur) {
+VISP_TEST(image_blur) {
     constexpr i32x2 extent{6, 6};
     // clang-format off
     std::array<float, extent[0] * extent[1]> input_data = {
@@ -252,7 +252,7 @@ TEST_CASE(image_blur) {
     CHECK_IMAGES_EQUAL(output, expected);
 }
 
-TEST_CASE(tile_merge) {
+VISP_TEST(tile_merge) {
     std::array<std::array<f32x3, 5 * 5>, 4> tiles;
     for (int t = 0; t < 4; ++t) {
         float v = float(t);
@@ -290,7 +290,7 @@ TEST_CASE(tile_merge) {
     CHECK_IMAGES_EQUAL(dst_span, expected);
 }
 
-TEST_CASE(tile_merge_blending) {
+VISP_TEST(tile_merge_blending) {
     std::array<f32x3, 22 * 19> dst{};
     auto dst_span = image_span({22, 19}, dst);
 
diff --git a/tests/test-models.cpp b/tests/test-models.cpp
diff --git a/tests/testing.cpp b/tests/testing.cpp
diff --git a/tests/testing.hpp b/tests/testing.hpp
diff --git a/tests/workbench.cpp b/tests/workbench.cpp

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ char const* next_arg(int argc, char** argv, int& i) {`
`35`	`35`	`if (++i < argc) {`
`36`	`36`	`return argv[i];`
`37`	`37`	`} else {`
`38`		`- throw error("Missing argument after {}", argv[i - 1]);`
	`38`	`+ throw except("Missing argument after {}", argv[i - 1]);`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
`@@ -45,7 +45,7 @@ std::vector<char const> collect_args(int argc, char* argv, int& i, char delim`
`45`	`45`	`r.push_back(next_arg(argc, argv, i));`
`46`	`46`	`} while (i + 1 < argc && argv[i + 1][0] != delim);`
`47`	`47`	`if (r.empty()) {`
`48`		`- throw error("Missing argument after {}", argv[i - 1]);`
	`48`	`+ throw except("Missing argument after {}", argv[i - 1]);`
`49`	`49`	`}`
`50`	`50`	`return r;`
`51`	`51`	`}`
`@@ -54,21 +54,21 @@ int parse_int(std::string_view arg) {`
`54`	`54`	`int value = 0;`
`55`	`55`	`auto [ptr, ec] = std::from_chars(arg.data(), arg.data() + arg.size(), value);`
`56`	`56`	`if (ec != std::errc()) {`
`57`		`- throw error("Invalid integer argument: {}", arg);`
	`57`	`+ throw except("Invalid integer argument: {}", arg);`
`58`	`58`	`}`
`59`	`59`	`return value;`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`char const* validate_path(char const* arg) {`
`63`	`63`	`if (!exists(path(arg))) {`
`64`		`- throw error("File not found: {}", arg);`
	`64`	`+ throw except("File not found: {}", arg);`
`65`	`65`	`}`
`66`	`66`	`return arg;`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`void require_inputs(std::span<char const* const> inputs, int n_required, char const* names) {`
`70`	`70`	`if (inputs.size() != size_t(n_required)) {`
`71`		`- throw error(`
	`71`	`+ throw except(`
`72`	`72`	`"Expected -i to be followed by {} inputs: {} - but found {}.", n_required, names,`
`73`	`73`	`inputs.size());`
`74`	`74`	`}`
`@@ -77,7 +77,7 @@ void require_inputs(std::span<char const* const> inputs, int n_required, char co`
`77`	`77`	`cli_args cli_parse(int argc, char** argv) {`
`78`	`78`	`cli_args r;`
`79`	`79`	`if (argc < 2) {`
`80`		`- throw error("Missing command.\nUsage: {} <command> [options]", argv[0]);`
	`80`	`+ throw except("Missing command.\nUsage: {} <command> [options]", argv[0]);`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`std::string_view arg1 = argv[1];`
`@@ -90,7 +90,7 @@ cli_args cli_parse(int argc, char** argv) {`
`90`	`90`	`} else if (arg1 == "esrgan") {`
`91`	`91`	`r.command = cli_command::esrgan;`
`92`	`92`	`} else {`
`93`		`- throw error("Unknown command: {}", arg1);`
	`93`	`+ throw except("Unknown command: {}", arg1);`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`for (int i = 2; i < argc; ++i) {`
`@@ -111,14 +111,14 @@ cli_args cli_parse(int argc, char** argv) {`
`111`	`111`	`} else if (backend_arg == "gpu") {`
`112`	`112`	`r.bknd_type = backend_type::gpu;`
`113`	`113`	`} else {`
`114`		`- throw error("Unknown backend type '{}', must be one of: cpu, gpu", backend_arg);`
	`114`	`+ throw except("Unknown backend type '{}', must be one of: cpu, gpu", backend_arg);`
`115`	`115`	`}`
`116`	`116`	`} else if (arg == "--composite") {`
`117`	`117`	`r.composite = next_arg(argc, argv, i);`
`118`	`118`	`} else if (arg == "--tile") {`
`119`	`119`	`r.tile_size = parse_int(next_arg(argc, argv, i));`
`120`	`120`	`} else if (arg.starts_with("-")) {`
`121`		`- throw error("Unknown argument: {}", arg);`
	`121`	`+ throw except("Unknown argument: {}", arg);`
`122`	`122`	`}`
`123`	`123`	`}`
`124`	`124`	`return r;`
`@@ -255,12 +255,12 @@ struct sam_prompt {`
`255`	`255`
`256`	`256`	`sam_prompt sam_parse_prompt(std::span<char const* const> args, i32x2 extent) {`
`257`	`257`	`if (args.empty()) {`
`258`		`- throw error(`
	`258`	`+ throw except(`
`259`	`259`	`"SAM requires a prompt with coordinates for a point or box"`
`260`	`260`	`"eg. '--prompt 100 200' to pick the point at pixel (x=100, y=200)");`
`261`	`261`	`}`
`262`	`262`	`if (args.size() < 2 \|\| args.size() > 4) {`
`263`		`- throw error(`
	`263`	`+ throw except(`
`264`	`264`	`"Invalid number of arguments for SAM prompt. Expected 2 (point) or 4 (box) numbers, "`
`265`	`265`	`"got {}",`
`266`	`266`	`args.size());`
`@@ -269,17 +269,17 @@ sam_prompt sam_parse_prompt(std::span<char const* const> args, i32x2 extent) {`
`269`	`269`	`if (args.size() >= 2) {`
`270`	`270`	`a = {parse_int(args[0]), parse_int(args[1])};`
`271`	`271`	`if (a[0] < 0 \|\| a[1] < 0 \|\| a[0] >= extent[0] \|\| a[1] >= extent[1]) {`
`272`		`- throw error("Invalid image coordinates: ({}, {})", a[0], a[1]);`
	`272`	`+ throw except("Invalid image coordinates: ({}, {})", a[0], a[1]);`
`273`	`273`	`}`
`274`	`274`	`}`
`275`	`275`	`i32x2 b{-1, -1};`
`276`	`276`	`if (args.size() == 4) {`
`277`	`277`	`b = {parse_int(args[2]), parse_int(args[3])};`
`278`	`278`	`if (b[0] < 0 \|\| b[1] < 0 \|\| b[0] >= extent[0] \|\| b[1] >= extent[1]) {`
`279`		`- throw error("Invalid image coordinates: ({}, {})", b[0], b[1]);`
	`279`	`+ throw except("Invalid image coordinates: ({}, {})", b[0], b[1]);`
`280`	`280`	`}`
`281`	`281`	`if (a[0] >= b[0] \|\| a[1] >= b[1]) {`
`282`		`- throw error("Invalid box coordinates: ({}, {}) to ({}, {})", a[0], a[1], b[0], b[1]);`
	`282`	`+ throw except("Invalid box coordinates: ({}, {}) to ({}, {})", a[0], a[1], b[0], b[1]);`
`283`	`283`	`}`
`284`	`284`	`}`
`285`	`285`	`return sam_prompt{a, b};`
Original file line number	Diff line number	Diff line change
`@@ -66,8 +66,8 @@ template <size_t N, typename... Args>`
`66`	`66`	`char const* format(fixed_string<N>& dst, char const* fmt, Args&&... args) {`
`67`	`67`	`auto it = truncating_iterator(dst.data, N);`
`68`	`68`	`auto out = fmt::vformat_to(it, fmt, fmt::make_format_args(args...));`
`69`		`- dst.data[N - 1] = 0;`
`70`	`69`	`dst.length = std::min(size_t(out - it), N - 1);`
	`70`	`+ dst.data[dst.length] = 0;`
`71`	`71`	`return dst.c_str();`
`72`	`72`	`}`
`73`	`73`
`@@ -79,7 +79,7 @@ String format(char const* fmt, Args&&... args) {`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`template <typename... Args>`
`82`		`-exception error(char const* fmt, Args&&... args) {`
	`82`	`+exception except(char const* fmt, Args&&... args) {`
`83`	`83`	`return exception(format<fixed_string<128>>(fmt, std::forward<Args>(args)...));`
`84`	`84`	`}`
`85`	`85`
Original file line number	Diff line number	Diff line change
`@@ -588,14 +588,14 @@ const swin_params swin_l_params = {`
`588`	`588`	`swin_params swin_detect_params(model_ref m) {`
`589`	`589`	`tensor t = m.find("bb.layers.0.blocks.0.attn.proj.bias");`
`590`	`590`	`if (t == nullptr) {`
`591`		`- throw error("Failed to detect model parameters");`
	`591`	`+ throw except("Failed to detect model parameters");`
`592`	`592`	`}`
`593`	`593`	`if (t->ne[0] == 96) {`
`594`	`594`	`return swin_t_params;`
`595`	`595`	`} else if (t->ne[0] == 192) {`
`596`	`596`	`return swin_l_params;`
`597`	`597`	`} else {`
`598`		`- throw error("Unsupported Swin Transformer embed dim: {}", t->ne[0]);`
	`598`	`+ throw except("Unsupported Swin Transformer embed dim: {}", t->ne[0]);`
`599`	`599`	`}`
`600`	`600`	`}`
`601`	`601`
Original file line number	Diff line number	Diff line change
`@@ -102,10 +102,10 @@ esrgan_params esrgan_detect_params(model_ref m) {`
`102`	`102`	`// 3 layers per upscale block, each upscales x2, 5 blocks for the rest of the model`
`103`	`103`	`p.scale = 1 << ((model_len - 5) / 3);`
`104`	`104`	`if (p.scale < 2 \|\| p.scale > 4) {`
`105`		`- throw error("Unsupported scale: {}", p.scale);`
	`105`	`+ throw except("Unsupported scale: {}", p.scale);`
`106`	`106`	`}`
`107`	`107`	`if (p.n_blocks < 1 \|\| p.n_blocks > 23) {`
`108`		`- throw error("Invalid number of blocks: {}", p.n_blocks);`
	`108`	`+ throw except("Invalid number of blocks: {}", p.n_blocks);`
`109`	`109`	`}`
`110`	`110`	`return p;`
`111`	`111`	`}`
Original file line number	Diff line number	Diff line change
`@@ -184,7 +184,7 @@ image_data image_load(char const* filepath) {`
`184`	`184`	`int channels = 0;`
`185`	`185`	`uint8_t* pixels = stbi_load(filepath, &extent[0], &extent[1], &channels, 0);`
`186`	`186`	`if (!pixels) {`
`187`		`- throw error("Failed to load image {}: {}", filepath, stbi_failure_reason());`
	`187`	`+ throw except("Failed to load image {}: {}", filepath, stbi_failure_reason());`
`188`	`188`	`}`
`189`	`189`	`image_format format = image_format_from_channels(channels);`
`190`	`190`	`return image_data(extent, format, std::unique_ptr<uint8_t[]>(pixels));`
`@@ -195,12 +195,12 @@ void image_save(image_view const& img, char const* filepath) {`
`195`	`195`
`196`	`196`	`if (!(img.format == image_format::alpha_u8 \|\| img.format == image_format::rgb_u8 \|\|`
`197`	`197`	`img.format == image_format::rgba_u8)) {`
`198`		`- throw error("Unsupported image format [{}]", int(img.format));`
	`198`	`+ throw except("Unsupported image format [{}]", int(img.format));`
`199`	`199`	`}`
`200`	`200`	`int comp = n_channels(img.format);`
`201`	`201`	`if (!stbi_write_png(`
`202`	`202`	`filepath, img.extent[0], img.extent[1], comp, img.data, img.extent[0] * comp)) {`
`203`		`- throw error("Failed to save image {}", filepath);`
	`203`	`+ throw except("Failed to save image {}", filepath);`
`204`	`204`	`}`
`205`	`205`	`}`
`206`	`206`
`@@ -338,7 +338,7 @@ void image_scale(image_view const& img, i32x2 target, image_span const& dst) {`
`338`	`338`	`STBIR_COLORSPACE_SRGB, nullptr);`
`339`	`339`	`}`
`340`	`340`	`if (result == 0) {`
`341`		`- throw error(`
	`341`	`+ throw except(`
`342`	`342`	`"Failed to resize image {}x{} to {}x{}", img.extent[0], img.extent[1], target[0],`
`343`	`343`	`target[1]);`
`344`	`344`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ backend_device backend_init(backend_type type) {`
`52`	`52`	`backend_device b;`
`53`	`53`	`b.handle.reset(ggml_backend_init_by_type(convert(type), nullptr));`
`54`	`54`	`if (!b.handle) {`
`55`		`- throw error("Failed to initialize backend, no suitable device available");`
	`55`	`+ throw except("Failed to initialize backend, no suitable device available");`
`56`	`56`	`}`
`57`	`57`	`b.device = ggml_backend_get_device(b.handle.get());`
`58`	`58`
`@@ -305,7 +305,7 @@ tensor model_ref::weights(char const* name) const {`
`305`	`305`	`if (tensor result = find(name)) {`
`306`	`306`	`return result;`
`307`	`307`	`}`
`308`		`- throw error("tensor not found: {}.{}", prefix.view(), name);`
	`308`	`+ throw except("tensor not found: {}.{}", prefix.view(), name);`
`309`	`309`	`}`
`310`	`310`
`311`	`311`	`model_ref model_ref::with_prefix(tensor_name new_prefix) const {`
`@@ -360,13 +360,13 @@ tensor_data tensor_alloc(tensor x) {`
`360`	`360`	`tensor_data tensor_load(tensor x, char const* filepath) {`
`361`	`361`	`FILE* file = fopen(filepath, "rb");`
`362`	`362`	`if (!file) {`
`363`		`- throw error("Failed to open file: {}", filepath);`
	`363`	`+ throw except("Failed to open file: {}", filepath);`
`364`	`364`	`}`
`365`	`365`	`tensor_data result = tensor_alloc(x);`
`366`	`366`	`size_t read = fread(result.data.get(), 1, ggml_nbytes(x), file);`
`367`	`367`	`fclose(file);`
`368`	`368`	`if (read != ggml_nbytes(x)) {`
`369`		`- throw error("Failed to read data from file: {}", filepath);`
	`369`	`+ throw except("Failed to read data from file: {}", filepath);`
`370`	`370`	`}`
`371`	`371`	`return result;`
`372`	`372`	`}`