Add display-format preference and RGB10A2 support

Introduce a launch-time display-format preference (auto/rgba8/rgb10a2/hdr) with precedence: --display-format, IMIV_DISPLAY_FORMAT, saved imiv.inf preference, then auto. Add --display-format CLI parsing and IMIV_DISPLAY_FORMAT environment support; preference is persisted in imiv.inf and changes are next-launch only. HDR is reserved and currently falls back to auto.

UI: expose display-format selector in Preferences and save/load display_format state. Validate/sanitize values and surface helpful UI messages when rgb10a2 or hdr are requested.

Renderer/platform: thread requested display format through app/renderer state. GLFW: add framebuffer bit hints for OpenGL when requesting RGB10A2. OpenGL: probe window with requested format and log actual framebuffer bits. Vulkan: request 10-bit surface formats when requested, select surface format and present mode, record whether swapchain supports transfer-src (screenshots), and expose verbose logging and fallback reporting. Metal: choose display and preview pixel formats per preference, create pipelines/textures accordingly, and fall back to BGRA8 when 10-bit formats are unavailable; verbose logging reports selection and fallbacks.

Capture: implement conversion utilities for Vulkan and Metal to convert various framebuffer formats (including A2R10/A2B10 packed formats) into RGBA8 for screenshots/previews; fail gracefully when format unsupported.

Misc: update persistence read/write, types/headers, and several renderer/backends to carry the new DisplayFormatPreference. Add helper functions for parsing/printing display-format names and some Vulkan/Metal format name helpers for logging.

Author: ssh4net

src/doc/imiv_dev.rst

@@ -1082,6 +1082,18 @@ Backend preference changes made in the Preferences window are persistent but
 take effect on the next launch. This is intentional and should remain true for
 all backends.
 
+The launch-time display-format request resolves in this order:
+
+1. the `--display-format` command-line option, if supplied;
+2. the `IMIV_DISPLAY_FORMAT` environment variable, if set;
+3. the saved `display_format` preference from `imiv.inf`;
+4. `auto`, which keeps the backend default presentation format.
+
+Display-format preference changes are also persistent and next-launch only.
+The current implemented non-default request is `rgb10a2` for 10-bit SDR
+presentation. `hdr` is parsed as a reserved value but falls back to `auto`
+until the backends have an explicit HDR/EDR color-space path.
+
 For isolated local repros and tests, set `IMIV_CONFIG_HOME` so preference
 changes do not bleed into your normal user config.
 

src/doc/imiv_user.rst

@@ -49,6 +49,8 @@ image list. For example::
 
     imiv --backend vulkan frame.exr
 
+    imiv --display-format rgb10a2 frame.exr
+
     imiv --display "sRGB - Display" \
          --view "ACES 2.0 - SDR 100 nits (Rec.709)" \
          --image-color-space ACEScg image.exr
@@ -85,6 +87,20 @@ Use :program:`imiv --help` to print the option summary for the current build.
     :program:`imiv` falls back to the resolved default backend and prints a
     message.
 
+.. option:: --display-format FORMAT
+
+    Request a display presentation format at launch time. Valid values are
+    `auto`, `rgba8`, `rgb10a2`, and `hdr`.
+
+    `rgba8` keeps the default 8-bit SDR path. `rgb10a2` requests 10-bit SDR
+    presentation from the renderer backend and falls back to the backend's
+    default format if unsupported. `hdr` is accepted for forward compatibility
+    but currently falls back to `auto`; HDR/EDR output still needs a dedicated
+    color-space and presentation path.
+
+    The command-line request takes precedence over the saved display-format
+    preference and the ``IMIV_DISPLAY_FORMAT`` environment variable.
+
 .. option:: --list-backends
 
     Print the backend support compiled into the current :program:`imiv`
@@ -370,6 +386,7 @@ Saved state currently includes:
 * Dear ImGui docking/window layout;
 * viewer and preview defaults for the primary view;
 * backend preference (`renderer_backend`);
+* display format preference (`display_format`);
 * whether the main window is `Always on Top`;
 * OCIO settings;
 * recent images and sort mode.
@@ -378,6 +395,7 @@ Example::
 
     [ImivApp][State]
     renderer_backend=vulkan
+    display_format=rgb10a2
     fit_image_to_window=1
     window_always_on_top=0
     use_ocio=1
@@ -390,6 +408,9 @@ the compiled backends, plus ``Auto``. Changing the backend preference updates
 the next-launch backend and shows a restart-required note. The active backend
 for the current process does not change until the next launch.
 
+The same Preferences section exposes the display-format request. Changing it is
+persistent and also applies on the next launch.
+
 Developer mode may also be controlled by the ``OIIO_DEVMODE`` environment
 variable. Acceptable values include ``1``, ``0``, ``true``, ``false``, ``on``,
 ``off``, ``yes``, and ``no``. The command-line ``--devmode`` flag takes

src/imiv/imiv_app.cpp

@@ -193,6 +193,30 @@ namespace {
         return sanitize_backend_kind(ui_state.renderer_backend);
     }
 
+    DisplayFormatPreference
+    requested_display_format_for_launch(const AppConfig& config,
+                                        const PlaceholderUiState& ui_state,
+                                        bool verbose_logging)
+    {
+        DisplayFormatPreference requested = sanitize_display_format_preference(
+            ui_state.display_format);
+        std::string env_value;
+        if (read_env_value("IMIV_DISPLAY_FORMAT", env_value)) {
+            DisplayFormatPreference env_format = DisplayFormatPreference::Auto;
+            if (parse_display_format_preference(env_value, env_format)) {
+                requested = env_format;
+            } else if (verbose_logging) {
+                print(stderr,
+                      "imiv: ignoring invalid IMIV_DISPLAY_FORMAT value '{}'; "
+                      "expected auto/rgba8/rgb10a2/hdr\n",
+                      env_value);
+            }
+        }
+        if (config.display_format_explicit)
+            requested = config.requested_display_format;
+        return sanitize_display_format_preference(static_cast<int>(requested));
+    }
+
     void apply_glfw_topmost_state_to_platform_windows(GLFWwindow* main_window,
                                                       bool always_on_top)
     {
@@ -325,6 +349,14 @@ run(const AppConfig& config)
                                      library.sort_mode, library.sort_reverse);
     const BackendKind requested_backend
         = requested_backend_for_launch(run_config, ui_state);
+    DisplayFormatPreference requested_display_format
+        = requested_display_format_for_launch(run_config, ui_state,
+                                              run_config.verbose);
+    if (requested_display_format == DisplayFormatPreference::Hdr) {
+        print(
+            "imiv: display format 'hdr' is not implemented yet; using auto\n");
+        requested_display_format = DisplayFormatPreference::Auto;
+    }
 
     const bool verbose_logging = run_config.verbose;
     const bool verbose_validation_output
@@ -400,7 +432,8 @@ run(const AppConfig& config)
         = Strutil::fmt::format("ImIv v.{} [{}]", OIIO_VERSION_STRING,
                                backend_cli_name(active_backend));
     GLFWwindow* window
-        = platform_glfw_create_main_window(active_backend, 1600, 900,
+        = platform_glfw_create_main_window(active_backend,
+                                           requested_display_format, 1600, 900,
                                            window_title.c_str(), startup_error);
     if (window == nullptr) {
         print(stderr, "imiv: {}\n", startup_error);
@@ -426,6 +459,7 @@ run(const AppConfig& config)
 
     RendererState renderer_state;
     renderer_select_backend(renderer_state, active_backend);
+    renderer_state.requested_display_format  = requested_display_format;
     renderer_state.verbose_logging           = verbose_logging;
     renderer_state.verbose_validation_output = verbose_validation_output;
     renderer_state.log_imgui_texture_updates = log_imgui_texture_updates;
@@ -532,6 +566,8 @@ run(const AppConfig& config)
               run_config.input_paths.size());
         print("imiv: native file dialogs: {}\n",
               FileDialog::available() ? "enabled" : "disabled");
+        print("imiv: requested display format: {}\n",
+              display_format_cli_name(requested_display_format));
     }
 
 #if !defined(IMGUI_ENABLE_TEST_ENGINE)

src/imiv/imiv_app.h

@@ -23,6 +23,9 @@ struct AppConfig {
     bool developer_mode_explicit = false;
 
     BackendKind requested_backend = BackendKind::Auto;
+    DisplayFormatPreference requested_display_format
+        = DisplayFormatPreference::Auto;
+    bool display_format_explicit = false;
 
     std::string ocio_display;
     std::string ocio_image_color_space;

src/imiv/imiv_aux_windows.cpp

@@ -600,6 +600,51 @@ namespace {
         }
     }
 
+    void draw_display_format_selector_row(PlaceholderUiState& ui, float spacing)
+    {
+        DisplayFormatPreference requested_format
+            = sanitize_display_format_preference(ui.display_format);
+        const float row_width    = std::max(1.0f,
+                                            ImGui::GetContentRegionAvail().x);
+        const float button_width = std::max(1.0f, (row_width - spacing * 2.0f)
+                                                      / 3.0f);
+
+        if (draw_preferences_segment_button("pref_display_auto", "Auto",
+                                            requested_format
+                                                == DisplayFormatPreference::Auto,
+                                            true, button_width)) {
+            ui.display_format = static_cast<int>(DisplayFormatPreference::Auto);
+        }
+        register_test_engine_item_label("pref-display-format:auto");
+        register_layout_dump_synthetic_item("button", "Display format Auto");
+
+        ImGui::SameLine(0.0f, spacing);
+        requested_format = sanitize_display_format_preference(
+            ui.display_format);
+        if (draw_preferences_segment_button(
+                "pref_display_rgba8", "RGBA8",
+                requested_format == DisplayFormatPreference::Rgba8, true,
+                button_width)) {
+            ui.display_format = static_cast<int>(
+                DisplayFormatPreference::Rgba8);
+        }
+        register_test_engine_item_label("pref-display-format:rgba8");
+        register_layout_dump_synthetic_item("button", "Display format RGBA8");
+
+        ImGui::SameLine(0.0f, spacing);
+        requested_format = sanitize_display_format_preference(
+            ui.display_format);
+        if (draw_preferences_segment_button(
+                "pref_display_rgb10a2", "RGB10A2",
+                requested_format == DisplayFormatPreference::Rgb10A2, true,
+                button_width)) {
+            ui.display_format = static_cast<int>(
+                DisplayFormatPreference::Rgb10A2);
+        }
+        register_test_engine_item_label("pref-display-format:rgb10a2");
+        register_layout_dump_synthetic_item("button", "Display format RGB10A2");
+    }
+
     void draw_backend_preference_info(PlaceholderUiState& ui,
                                       BackendKind active_backend)
     {
@@ -627,6 +672,10 @@ namespace {
         table_labeled_row("Next launch backend");
         draw_right_aligned_text(backend_display_name(next_launch_backend));
 
+        table_labeled_row("Display format");
+        draw_right_aligned_text(display_format_display_name(
+            sanitize_display_format_preference(ui.display_format)));
+
         table_labeled_row("Generate mipmaps");
         draw_right_aligned_checkbox("##pref_auto_mipmap", ui.auto_mipmap);
         ImGui::EndTable();
@@ -674,6 +723,15 @@ namespace {
         if (requested_backend == BackendKind::Auto)
             draw_disabled_wrapped_text(
                 "Auto selects the first available backend.");
+        const DisplayFormatPreference requested_format
+            = sanitize_display_format_preference(ui.display_format);
+        if (requested_format == DisplayFormatPreference::Rgb10A2) {
+            draw_disabled_wrapped_text(
+                "RGB10A2 requests 10-bit SDR presentation and falls back when unsupported.");
+        } else if (requested_format == DisplayFormatPreference::Hdr) {
+            draw_disabled_wrapped_text(
+                "HDR/EDR presentation is reserved for a future backend path.");
+        }
         for (const BackendRuntimeInfo& info : runtime_backend_info()) {
             if (!info.build_info.compiled || info.available)
                 continue;
@@ -709,6 +767,8 @@ namespace {
                                                 backend_row_min,
                                                 backend_row_max);
         }
+        ImGui::Spacing();
+        draw_display_format_selector_row(ui, spacing);
         draw_backend_preference_info(ui, active_backend);
         draw_backend_status_messages(ui, active_backend);
     }

src/imiv/imiv_backend.h

@@ -12,6 +12,13 @@ namespace Imiv {
 
 enum class BackendKind : int { Auto = -1, Vulkan = 0, Metal = 1, OpenGL = 2 };
 
+enum class DisplayFormatPreference : int {
+    Auto    = -1,
+    Rgba8   = 0,
+    Rgb10A2 = 1,
+    Hdr     = 2
+};
+
 struct BackendInfo {
     BackendKind kind         = BackendKind::Auto;
     const char* cli_name     = "auto";
@@ -38,6 +45,15 @@ const char*
 backend_display_name(BackendKind kind);
 const char*
 backend_runtime_name(BackendKind kind);
+DisplayFormatPreference
+sanitize_display_format_preference(int value);
+bool
+parse_display_format_preference(std::string_view value,
+                                DisplayFormatPreference& out_format);
+const char*
+display_format_cli_name(DisplayFormatPreference format);
+const char*
+display_format_display_name(DisplayFormatPreference format);
 BackendKind
 active_build_backend_kind();
 BackendKind