Refactor renderer bootstrap and test utilities

Introduce centralized cleanup lambdas in imiv_app.cpp to simplify failure paths and unify renderer window/device cleanup. Factor OCIO texture blueprint construction in imiv_ocio.cpp into a reusable append_texture_blueprint helper. In Metal renderer (imiv_renderer_metal.mm) add a render_preview lambda to consolidate OCIO vs non-OCIO preview rendering and reduce duplicated calls.

Refactor multiple test/utility Python scripts to reuse a new imiv_test_utils module: move many common helpers (path discovery, env loading, command builders, timing/logging, program resolution, defaults) into imiv_test_utils and update imiv_backend_verify.py, imiv_ocio_config_source_regression.py, imiv_ocio_missing_fallback_regression.py, imiv_ux_actions_regression.py, and others to import and use those utilities. Replace ad-hoc subprocess/run helpers with shared run_timed_logged_process, run_capture_output, script_command, generic_smoke_runner_command, and standardized error handling via fail().

Overall this cleans up error/cleanup handling in C++ code and consolidates Python test tooling to reduce duplication and improve maintainability.

Signed-off-by: Vlad <shaamaan@gmail.com>

Author: ssh4net

src/imiv/imiv_app.cpp

@@ -429,37 +429,36 @@ run(const AppConfig& config)
     renderer_state.verbose_logging           = verbose_logging;
     renderer_state.verbose_validation_output = verbose_validation_output;
     renderer_state.log_imgui_texture_updates = log_imgui_texture_updates;
-    ImVector<const char*> instance_extensions;
-    if (active_backend == BackendKind::Vulkan)
-        platform_glfw_collect_vulkan_instance_extensions(instance_extensions);
-
-    if (!renderer_setup_instance(renderer_state, instance_extensions,
-                                 startup_error)) {
+    const auto fail_bootstrap = [&](bool destroy_surface, bool cleanup_window,
+                                    bool shutdown_platform_imgui) {
         print(stderr, "imiv: {}\n", startup_error);
+        if (shutdown_platform_imgui)
+            platform_glfw_imgui_shutdown();
+        if (cleanup_window)
+            renderer_cleanup_window(renderer_state);
+        if (destroy_surface)
+            renderer_destroy_surface(renderer_state);
         renderer_cleanup(renderer_state);
         ImGui::DestroyContext();
         platform_glfw_destroy_window(window);
         platform_glfw_terminate();
         return EXIT_FAILURE;
+    };
+    ImVector<const char*> instance_extensions;
+    if (active_backend == BackendKind::Vulkan)
+        platform_glfw_collect_vulkan_instance_extensions(instance_extensions);
+
+    if (!renderer_setup_instance(renderer_state, instance_extensions,
+                                 startup_error)) {
+        return fail_bootstrap(false, false, false);
     }
 
     if (!renderer_create_surface(renderer_state, window, startup_error)) {
-        print(stderr, "imiv: {}\n", startup_error);
-        renderer_cleanup(renderer_state);
-        ImGui::DestroyContext();
-        platform_glfw_destroy_window(window);
-        platform_glfw_terminate();
-        return EXIT_FAILURE;
+        return fail_bootstrap(false, false, false);
     }
 
     if (!renderer_setup_device(renderer_state, startup_error)) {
-        print(stderr, "imiv: {}\n", startup_error);
-        renderer_destroy_surface(renderer_state);
-        renderer_cleanup(renderer_state);
-        ImGui::DestroyContext();
-        platform_glfw_destroy_window(window);
-        platform_glfw_terminate();
-        return EXIT_FAILURE;
+        return fail_bootstrap(true, false, false);
     }
 
     int framebuffer_width  = 0;
@@ -468,13 +467,7 @@ run(const AppConfig& config)
                                        framebuffer_height);
     if (!renderer_setup_window(renderer_state, framebuffer_width,
                                framebuffer_height, startup_error)) {
-        print(stderr, "imiv: {}\n", startup_error);
-        renderer_cleanup_window(renderer_state);
-        renderer_cleanup(renderer_state);
-        ImGui::DestroyContext();
-        platform_glfw_destroy_window(window);
-        platform_glfw_terminate();
-        return EXIT_FAILURE;
+        return fail_bootstrap(false, true, false);
     }
 
     ImGuiIO& io = ImGui::GetIO();
@@ -494,14 +487,7 @@ run(const AppConfig& config)
     }
     platform_glfw_imgui_init(window, active_backend);
     if (!renderer_imgui_init(renderer_state, startup_error)) {
-        print(stderr, "imiv: {}\n", startup_error);
-        platform_glfw_imgui_shutdown();
-        renderer_cleanup_window(renderer_state);
-        renderer_cleanup(renderer_state);
-        ImGui::DestroyContext();
-        platform_glfw_destroy_window(window);
-        platform_glfw_terminate();
-        return EXIT_FAILURE;
+        return fail_bootstrap(false, true, true);
     }
 
     const bool platform_has_viewports
@@ -822,21 +808,21 @@ run(const AppConfig& config)
 #endif
     FileDialog::set_native_dialog_scope_hook(nullptr, nullptr);
     uninstall_drag_drop(window);
-    if (active_backend == BackendKind::OpenGL) {
+    const auto cleanup_renderer_backend = [&] {
         renderer_cleanup_window(renderer_state);
         renderer_cleanup(renderer_state);
-    }
+    };
+    if (active_backend == BackendKind::OpenGL)
+        cleanup_renderer_backend();
     renderer_imgui_shutdown(renderer_state);
     platform_glfw_imgui_shutdown();
     ImGui::DestroyContext();
 #if defined(IMGUI_ENABLE_TEST_ENGINE)
     test_engine_destroy(test_engine_runtime);
 #endif
 
-    if (active_backend != BackendKind::OpenGL) {
-        renderer_cleanup_window(renderer_state);
-        renderer_cleanup(renderer_state);
-    }
+    if (active_backend != BackendKind::OpenGL)
+        cleanup_renderer_backend();
     platform_glfw_destroy_window(window);
     platform_glfw_terminate();
     return EXIT_SUCCESS;

src/imiv/imiv_ocio.cpp

@@ -328,6 +328,27 @@ namespace {
         blueprint.textures.clear();
         blueprint.textures.reserve(num_textures
                                    + shader_desc->getNum3DTextures());
+        const auto append_texture_blueprint =
+            [&](const char* texture_name, const char* sampler_name,
+                uint32_t shader_binding, uint32_t width, uint32_t height,
+                uint32_t depth, OcioTextureChannel channel,
+                OcioTextureDimensions dimensions,
+                OcioInterpolation interpolation, const float* values,
+                size_t texel_count) {
+                OcioTextureBlueprint texture;
+                texture.texture_name   = texture_name ? texture_name : "";
+                texture.sampler_name   = sampler_name ? sampler_name : "";
+                texture.shader_binding = shader_binding;
+                texture.width          = width;
+                texture.height         = height;
+                texture.depth          = depth;
+                texture.channel        = channel;
+                texture.dimensions     = dimensions;
+                texture.interpolation  = interpolation;
+                if (values && texel_count != 0)
+                    texture.values.assign(values, values + texel_count);
+                blueprint.textures.push_back(std::move(texture));
+            };
         for (unsigned idx = 0; idx < num_textures; ++idx) {
             const char* texture_name = nullptr;
             const char* sampler_name = nullptr;
@@ -342,31 +363,17 @@ namespace {
                                     height, channel, dimensions, interpolation);
             const float* values = nullptr;
             shader_desc->getTextureValues(idx, values);
-
-            OcioTextureBlueprint texture;
-            if (texture_name)
-                texture.texture_name = texture_name;
-            if (sampler_name)
-                texture.sampler_name = sampler_name;
-            texture.shader_binding = shader_desc->getTextureShaderBindingIndex(
-                idx);
-            texture.width         = width;
-            texture.height        = height;
-            texture.depth         = 1;
-            texture.channel       = map_ocio_texture_channel(channel);
-            texture.dimensions    = map_ocio_texture_dimensions(dimensions,
-                                                                height);
-            texture.interpolation = map_ocio_interpolation(interpolation);
-            if (values) {
-                const size_t texel_count
-                    = static_cast<size_t>(width) * static_cast<size_t>(height)
-                      * static_cast<size_t>(
-                          channel == OCIO::GpuShaderDesc::TEXTURE_RED_CHANNEL
-                              ? 1
-                              : 3);
-                texture.values.assign(values, values + texel_count);
-            }
-            blueprint.textures.push_back(std::move(texture));
+            const size_t texel_count
+                = static_cast<size_t>(width) * static_cast<size_t>(height)
+                  * static_cast<size_t>(
+                      channel == OCIO::GpuShaderDesc::TEXTURE_RED_CHANNEL ? 1
+                                                                          : 3);
+            append_texture_blueprint(
+                texture_name, sampler_name,
+                shader_desc->getTextureShaderBindingIndex(idx), width, height,
+                1, map_ocio_texture_channel(channel),
+                map_ocio_texture_dimensions(dimensions, height),
+                map_ocio_interpolation(interpolation), values, texel_count);
         }
 
         const unsigned num_textures_3d = shader_desc->getNum3DTextures();
@@ -379,27 +386,15 @@ namespace {
                                       interpolation);
             const float* values = nullptr;
             shader_desc->get3DTextureValues(idx, values);
-
-            OcioTextureBlueprint texture;
-            if (texture_name)
-                texture.texture_name = texture_name;
-            if (sampler_name)
-                texture.sampler_name = sampler_name;
-            texture.shader_binding
-                = shader_desc->get3DTextureShaderBindingIndex(idx);
-            texture.width         = edge_len;
-            texture.height        = edge_len;
-            texture.depth         = edge_len;
-            texture.channel       = OcioTextureChannel::RGB;
-            texture.dimensions    = OcioTextureDimensions::Tex3D;
-            texture.interpolation = map_ocio_interpolation(interpolation);
-            if (values) {
-                const size_t texel_count = static_cast<size_t>(edge_len)
-                                           * static_cast<size_t>(edge_len)
-                                           * static_cast<size_t>(edge_len) * 3u;
-                texture.values.assign(values, values + texel_count);
-            }
-            blueprint.textures.push_back(std::move(texture));
+            const size_t texel_count = static_cast<size_t>(edge_len)
+                                       * static_cast<size_t>(edge_len)
+                                       * static_cast<size_t>(edge_len) * 3u;
+            append_texture_blueprint(
+                texture_name, sampler_name,
+                shader_desc->get3DTextureShaderBindingIndex(idx), edge_len,
+                edge_len, edge_len, OcioTextureChannel::RGB,
+                OcioTextureDimensions::Tex3D,
+                map_ocio_interpolation(interpolation), values, texel_count);
         }
 
         if (blueprint.display.empty() || blueprint.view.empty()) {

src/imiv/imiv_renderer_metal.mm

@@ -1863,41 +1863,44 @@ bool metal_update_preview_texture(RendererState& renderer_state,
             return true;
         }
 
-        bool used_ocio = false;
+        bool used_ocio            = false;
+        const auto render_preview = [&](id<MTLTexture> target_texture,
+                                        id<MTLSamplerState> sampler_state,
+                                        std::string& render_error) {
+            return effective_controls.use_ocio != 0
+                       ? render_ocio_preview_texture(
+                             *renderer_backend, *texture_state, target_texture,
+                             sampler_state, effective_controls, render_error)
+                       : render_preview_texture(*renderer_backend,
+                                                *texture_state, target_texture,
+                                                sampler_state,
+                                                effective_controls,
+                                                render_error);
+        };
         if (effective_controls.use_ocio != 0) {
             std::string ocio_error;
             if (ensure_ocio_preview_program(*renderer_backend, ui_state, image,
                                             ocio_error)
-                && render_ocio_preview_texture(
-                    *renderer_backend, *texture_state,
-                    texture_state->preview_linear_texture,
-                    renderer_backend->linear_sampler, effective_controls,
-                    ocio_error)
-                && render_ocio_preview_texture(
-                    *renderer_backend, *texture_state,
-                    texture_state->preview_nearest_texture,
-                    renderer_backend->nearest_sampler, effective_controls,
-                    ocio_error)) {
+                && render_preview(texture_state->preview_linear_texture,
+                                  renderer_backend->linear_sampler, ocio_error)
+                && render_preview(texture_state->preview_nearest_texture,
+                                  renderer_backend->nearest_sampler,
+                                  ocio_error)) {
                 used_ocio = true;
             } else {
-                if (!ocio_error.empty()) {
+                if (!ocio_error.empty())
                     std::cerr << "imiv: Metal OCIO fallback: " << ocio_error
                               << "\n";
-                }
                 effective_controls.use_ocio = 0;
             }
         }
 
         if (!used_ocio
-            && (!render_preview_texture(*renderer_backend, *texture_state,
-                                        texture_state->preview_linear_texture,
-                                        renderer_backend->linear_sampler,
-                                        effective_controls, error_message)
-                || !render_preview_texture(
-                    *renderer_backend, *texture_state,
-                    texture_state->preview_nearest_texture,
-                    renderer_backend->nearest_sampler, effective_controls,
-                    error_message))) {
+            && (!render_preview(texture_state->preview_linear_texture,
+                                renderer_backend->linear_sampler, error_message)
+                || !render_preview(texture_state->preview_nearest_texture,
+                                   renderer_backend->nearest_sampler,
+                                   error_message))) {
             texture.preview_initialized = false;
             return false;
         }