Add OpenGL multi-open OCIO test and clear GL errors

Add a focused regression test for OpenGL + OCIO with multiple images: a new Python runner script (src/imiv/tools/imiv_opengl_multiopen_ocio_regression.py) that launches imiv with two copies of a source image, captures layout/state/screenshot, and scans the runtime log for known error patterns. Integrate the test into CTest (src/imiv/CMakeLists.txt) with labels and timeout, and document the test in docs/README (src/doc/imiv_tests.rst, src/imiv/README.md).

Also introduce clear_gl_error_queue() in the OpenGL renderer (src/imiv/imiv_renderer_opengl.cpp) and call it at several points before texture uploads and draw setup to flush stale GL errors and reduce spurious "OpenGL OCIO preview draw failed" runtime failures during startup.

Signed-off-by: Vlad (Kuzmin) Erium <libalias@gmail.com>
Signed-off-by: Vlad <shaamaan@gmail.com>

Author: ssh4net

src/doc/imiv_tests.rst

@@ -243,6 +243,9 @@ Recent focused GUI regressions in `src/imiv/tools/` include:
 * `imiv_view_recipe_regression.py`
   per-view recipe isolation for exposure, gamma, offset, interpolation, and
   OCIO state with multiple image views open.
+* `imiv_opengl_multiopen_ocio_regression.py`
+  OpenGL multi-image startup with OCIO enabled, with a hard failure if the
+  runtime log reports `OpenGL OCIO preview draw failed`.
 * `imiv_save_selection_regression.py`
   GUI-driven `Save Selection As...` crop export, including selected ROI and
   orientation-baked CPU output validation.

src/imiv/CMakeLists.txt

@@ -1289,6 +1289,22 @@ if (TARGET imiv
             imiv_opengl_smoke_regression PROPERTIES
                 LABELS "imiv;imiv_opengl;gui"
                 TIMEOUT 180)
+
+        add_test (
+            NAME imiv_opengl_multiopen_ocio_regression
+            COMMAND
+                "${Python3_EXECUTABLE}"
+                "${CMAKE_CURRENT_SOURCE_DIR}/tools/imiv_opengl_multiopen_ocio_regression.py"
+                --bin "$<TARGET_FILE:imiv>"
+                --cwd "$<TARGET_FILE_DIR:imiv>"
+                --backend opengl
+                --env-script "${CMAKE_BINARY_DIR}/imiv_env.sh"
+                --out-dir "${CMAKE_BINARY_DIR}/imiv_captures/opengl_multiopen_ocio_regression"
+                --open "${PROJECT_SOURCE_DIR}/ASWF/logos/openimageio-stacked-gradient.png")
+        set_tests_properties (
+            imiv_opengl_multiopen_ocio_regression PROPERTIES
+                LABELS "imiv;imiv_opengl;imiv_ocio;gui"
+                TIMEOUT 180)
     elseif (_imiv_renderer_is_metal)
         add_test (
             NAME imiv_metal_screenshot_regression

src/imiv/README.md

@@ -165,6 +165,17 @@ python3 src/imiv/tools/imiv_image_list_center_regression.py \
   --out-dir build/imiv_captures/image_list_center_regression
 ```
 
+Focused OpenGL multi-open OCIO regression:
+
+```bash
+python3 src/imiv/tools/imiv_opengl_multiopen_ocio_regression.py \
+  --bin build/bin/imiv \
+  --cwd build/bin \
+  --backend opengl \
+  --env-script build/imiv_env.sh \
+  --out-dir build/imiv_captures/opengl_multiopen_ocio_regression
+```
+
 Focused folder-open regression:
 
 ```bash

src/imiv/imiv_renderer_opengl.cpp

@@ -138,6 +138,13 @@ namespace Imiv {
 
 namespace {
 
+void
+clear_gl_error_queue()
+{
+    while (glGetError() != GL_NO_ERROR) {
+    }
+}
+
 struct RendererTextureBackendState {
     GLuint source_texture                         = 0;
     GLuint preview_linear_texture                 = 0;
@@ -535,6 +542,7 @@ struct RendererBackendState {
         glBindTexture(target, texture_id);
         set_ocio_texture_parameters(target, filter);
         glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+        clear_gl_error_queue();
         const float* values = blueprint.values.empty()
                                   ? nullptr
                                   : blueprint.values.data();
@@ -1142,6 +1150,7 @@ void main()
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
         glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+        clear_gl_error_queue();
         glTexImage2D(GL_TEXTURE_2D, 0, upload.internal_format, width, height, 0,
                      upload.format, upload.type, nullptr);
         GLenum err = glGetError();
@@ -1192,6 +1201,7 @@ void main()
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
+        clear_gl_error_queue();
         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, width, height, 0, GL_RGBA,
                      GL_FLOAT, nullptr);
         const GLenum err = glGetError();
@@ -1230,6 +1240,7 @@ void main()
         glViewport(0, 0, texture_state.width, texture_state.height);
         glDisable(GL_BLEND);
         glDisable(GL_DEPTH_TEST);
+        clear_gl_error_queue();
         glUseProgram(state.basic_preview.program);
         glBindVertexArray(state.basic_preview.fullscreen_triangle_vao);
         glActiveTexture(GL_TEXTURE0);
@@ -1304,6 +1315,7 @@ void main()
         glViewport(0, 0, texture_state.width, texture_state.height);
         glDisable(GL_BLEND);
         glDisable(GL_DEPTH_TEST);
+        clear_gl_error_queue();
         glUseProgram(state.ocio_preview.program);
         glBindVertexArray(state.basic_preview.fullscreen_triangle_vao);
 

src/imiv/tools/imiv_opengl_multiopen_ocio_regression.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""Regression check for OpenGL OCIO preview with multiple startup images."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+ERROR_PATTERNS = (
+    "error: imiv exited with code",
+    "OpenGL preview draw failed",
+    "OpenGL OCIO preview draw failed",
+)
+
+
+def _repo_root() -> Path:
+    return Path(__file__).resolve().parents[3]
+
+
+def _default_binary(repo_root: Path) -> Path:
+    candidates = [
+        repo_root / "build_u" / "bin" / "imiv",
+        repo_root / "build" / "bin" / "imiv",
+        repo_root / "build_u" / "src" / "imiv" / "imiv",
+        repo_root / "build" / "src" / "imiv" / "imiv",
+        repo_root / "build" / "Debug" / "imiv.exe",
+        repo_root / "build" / "Release" / "imiv.exe",
+    ]
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+    return candidates[0]
+
+
+def _load_env_from_script(script_path: Path) -> dict[str, str]:
+    env = dict(os.environ)
+    if not script_path.exists() or shutil.which("bash") is None:
+        return env
+
+    quoted = shlex.quote(str(script_path))
+    proc = subprocess.run(
+        ["bash", "-lc", f"source {quoted} >/dev/null 2>&1; env -0"],
+        check=True,
+        stdout=subprocess.PIPE,
+    )
+    for item in proc.stdout.split(b"\0"):
+        if not item:
+            continue
+        key, _, value = item.partition(b"=")
+        if not key:
+            continue
+        env[key.decode("utf-8", errors="ignore")] = value.decode(
+            "utf-8", errors="ignore"
+        )
+    return env
+
+
+def main() -> int:
+    repo_root = _repo_root()
+    runner = repo_root / "src" / "imiv" / "tools" / "imiv_gui_test_run.py"
+    default_env_script = repo_root / "build_u" / "imiv_env.sh"
+    default_out_dir = (
+        repo_root / "build_u" / "imiv_captures" / "opengl_multiopen_ocio_regression"
+    )
+    default_image = repo_root / "ASWF" / "logos" / "openimageio-stacked-gradient.png"
+
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--bin", default=str(_default_binary(repo_root)), help="imiv executable")
+    ap.add_argument("--cwd", default="", help="Working directory for imiv")
+    ap.add_argument("--backend", default="opengl", help="Runtime backend override")
+    ap.add_argument(
+        "--env-script", default=str(default_env_script), help="Optional shell env setup script"
+    )
+    ap.add_argument("--out-dir", default=str(default_out_dir), help="Output directory")
+    ap.add_argument("--open", default=str(default_image), help="Source image to duplicate")
+    ap.add_argument("--trace", action="store_true", help="Enable runner tracing")
+    args = ap.parse_args()
+
+    exe = Path(args.bin).resolve()
+    if not exe.exists():
+        print(f"error: binary not found: {exe}", file=sys.stderr)
+        return 2
+
+    cwd = Path(args.cwd).resolve() if args.cwd else exe.parent.resolve()
+    out_dir = Path(args.out_dir).resolve()
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    image_a = Path(args.open).resolve()
+    if not image_a.exists():
+        print(f"error: image not found: {image_a}", file=sys.stderr)
+        return 2
+    image_b = out_dir / f"{image_a.stem}_copy{image_a.suffix}"
+    shutil.copyfile(image_a, image_b)
+
+    env = _load_env_from_script(Path(args.env_script).resolve())
+    env["IMIV_CONFIG_HOME"] = str(out_dir / "cfg")
+
+    screenshot_path = out_dir / "opengl_multiopen_ocio.png"
+    layout_path = out_dir / "opengl_multiopen_ocio.layout.json"
+    state_path = out_dir / "opengl_multiopen_ocio.state.json"
+    log_path = out_dir / "opengl_multiopen_ocio.log"
+
+    cmd = [
+        sys.executable,
+        str(runner),
+        "--bin",
+        str(exe),
+        "--cwd",
+        str(cwd),
+        "--backend",
+        args.backend,
+        "--open",
+        str(image_a),
+        "--open",
+        str(image_b),
+        "--ocio-use",
+        "true",
+        "--screenshot-out",
+        str(screenshot_path),
+        "--layout-json-out",
+        str(layout_path),
+        "--layout-items",
+        "--state-json-out",
+        str(state_path),
+    ]
+    if args.trace:
+        cmd.append("--trace")
+
+    with log_path.open("w", encoding="utf-8") as log_handle:
+        proc = subprocess.run(
+            cmd,
+            cwd=str(repo_root),
+            env=env,
+            check=False,
+            stdout=log_handle,
+            stderr=subprocess.STDOUT,
+            timeout=90,
+        )
+    if proc.returncode != 0:
+        print(f"error: runner exited with code {proc.returncode}", file=sys.stderr)
+        return 1
+
+    for required in (screenshot_path, layout_path, state_path):
+        if not required.exists():
+            print(f"error: missing output: {required}", file=sys.stderr)
+            return 1
+
+    log_text = log_path.read_text(encoding="utf-8", errors="ignore")
+    for pattern in ERROR_PATTERNS:
+        if pattern in log_text:
+            print(f"error: found runtime error pattern: {pattern}", file=sys.stderr)
+            return 1
+
+    layout = json.loads(layout_path.read_text(encoding="utf-8"))
+    if not any(window.get("name") == "Image" for window in layout.get("windows", [])):
+        print("error: layout dump missing Image window", file=sys.stderr)
+        return 1
+
+    state = json.loads(state_path.read_text(encoding="utf-8"))
+    if not state.get("image_path"):
+        print("error: state dump missing image_path", file=sys.stderr)
+        return 1
+    if int(state.get("loaded_image_count", 0)) < 2:
+        print("error: expected at least 2 loaded images in session", file=sys.stderr)
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())