Track and show display presentation info

ssh4net · ssh4net · commit f52174e3614f · 2026-04-26T12:12:42.000+09:00
Add DisplayDynamicRange and DisplayPresentationInfo to track display color depth and dynamic range. Introduce display_dynamic_range_name and display_presentation_name helpers and compute/update display_presentation in Metal, OpenGL and Vulkan backends (color bits, range, and fallback status). Add platform_glfw_set_window_title and include the resolved presentation info in the main window title and verbose logging output. Minor refactors: update when windows/swapchains are configured and move framebuffer-bit logging to use the new presentation tracking.

Signed-off-by: Vlad &lt;shaamaan@gmail.com&gt;
diff --git a/src/imiv/imiv_app.cpp b/src/imiv/imiv_app.cpp
@@ -217,6 +217,14 @@ namespace {
         return sanitize_display_format_preference(static_cast<int>(requested));
     }
 
+    std::string main_window_title(BackendKind backend,
+                                  const DisplayPresentationInfo& presentation)
+    {
+        return Strutil::fmt::format("ImIv v.{} [{} / {}]", OIIO_VERSION_STRING,
+                                    backend_cli_name(backend),
+                                    display_presentation_name(presentation));
+    }
+
     void apply_glfw_topmost_state_to_platform_windows(GLFWwindow* main_window,
                                                       bool always_on_top)
     {
@@ -429,8 +437,7 @@ run(const AppConfig& config)
     }
 
     const std::string window_title
-        = Strutil::fmt::format("ImIv v.{} [{}]", OIIO_VERSION_STRING,
-                               backend_cli_name(active_backend));
+        = main_window_title(active_backend, DisplayPresentationInfo {});
     GLFWwindow* window
         = platform_glfw_create_main_window(active_backend,
                                            requested_display_format, 1600, 900,
@@ -503,6 +510,10 @@ run(const AppConfig& config)
                                framebuffer_height, startup_error)) {
         return fail_bootstrap(false, true, false);
     }
+    const std::string resolved_window_title
+        = main_window_title(active_backend,
+                            renderer_state.display_presentation);
+    platform_glfw_set_window_title(window, resolved_window_title.c_str());
 
     ImGuiIO& io = ImGui::GetIO();
     io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
@@ -568,6 +579,8 @@ run(const AppConfig& config)
               FileDialog::available() ? "enabled" : "disabled");
         print("imiv: requested display format: {}\n",
               display_format_cli_name(requested_display_format));
+        print("imiv: display presentation: {}\n",
+              display_presentation_name(renderer_state.display_presentation));
     }
 
 #if !defined(IMGUI_ENABLE_TEST_ENGINE)
diff --git a/src/imiv/imiv_platform_glfw.cpp b/src/imiv/imiv_platform_glfw.cpp
@@ -245,6 +245,13 @@ platform_glfw_destroy_window(GLFWwindow* window)
         glfwDestroyWindow(window);
 }
 
+void
+platform_glfw_set_window_title(GLFWwindow* window, const char* title)
+{
+    if (window != nullptr && title != nullptr)
+        glfwSetWindowTitle(window, title);
+}
+
 bool
 platform_glfw_supports_vulkan(std::string& error_message)
 {
diff --git a/src/imiv/imiv_platform_glfw.h b/src/imiv/imiv_platform_glfw.h
@@ -28,6 +28,8 @@ platform_glfw_create_main_window(BackendKind backend,
                                  std::string& error_message);
 void
 platform_glfw_destroy_window(GLFWwindow* window);
+void
+platform_glfw_set_window_title(GLFWwindow* window, const char* title);
 
 bool
 platform_glfw_supports_vulkan(std::string& error_message);
diff --git a/src/imiv/imiv_renderer.cpp b/src/imiv/imiv_renderer.cpp
@@ -759,4 +759,31 @@ renderer_screen_capture(ImGuiID viewport_id, int x, int y, int w, int h,
     return vtable->screen_capture(viewport_id, x, y, w, h, pixels, user_data);
 }
 
+const char*
+display_dynamic_range_name(DisplayDynamicRange range)
+{
+    switch (range) {
+    case DisplayDynamicRange::Sdr: return "SDR";
+    case DisplayDynamicRange::Edr: return "EDR";
+    case DisplayDynamicRange::Hdr: return "HDR";
+    case DisplayDynamicRange::Unknown: break;
+    }
+    return "unknown";
+}
+
+std::string
+display_presentation_name(const DisplayPresentationInfo& info)
+{
+    const std::string bits = info.color_bits > 0
+                                 ? OIIO::Strutil::fmt::format("{}-bit",
+                                                              info.color_bits)
+                                 : std::string("**-bit");
+    std::string label
+        = OIIO::Strutil::fmt::format("{} {}", bits,
+                                     display_dynamic_range_name(info.range));
+    if (info.format_request_fell_back)
+        label += " fallback";
+    return label;
+}
+
 }  // namespace Imiv
diff --git a/src/imiv/imiv_renderer.h b/src/imiv/imiv_renderer.h
@@ -22,12 +22,21 @@ struct RendererBackendVTable;
 struct RendererBackendState;
 struct RendererTextureBackendState;
 
+enum class DisplayDynamicRange : int { Unknown = 0, Sdr = 1, Edr = 2, Hdr = 3 };
+
+struct DisplayPresentationInfo {
+    int color_bits                = 8;
+    DisplayDynamicRange range     = DisplayDynamicRange::Sdr;
+    bool format_request_fell_back = false;
+};
+
 struct RendererState {
     const RendererBackendVTable* vtable = nullptr;
     RendererBackendState* backend       = nullptr;
     BackendKind active_backend          = BackendKind::Auto;
     DisplayFormatPreference requested_display_format
         = DisplayFormatPreference::Auto;
+    DisplayPresentationInfo display_presentation;
     bool verbose_logging           = false;
     bool verbose_validation_output = false;
     bool log_imgui_texture_updates = false;
@@ -239,5 +248,9 @@ renderer_frame_present(RendererState& renderer_state);
 bool
 renderer_screen_capture(ImGuiID viewport_id, int x, int y, int w, int h,
                         unsigned int* pixels, void* user_data);
+const char*
+display_dynamic_range_name(DisplayDynamicRange range);
+std::string
+display_presentation_name(const DisplayPresentationInfo& info);
 
 }  // namespace Imiv
diff --git a/src/imiv/imiv_renderer_metal.mm b/src/imiv/imiv_renderer_metal.mm
@@ -198,6 +198,44 @@ size_t metal_max_upload_chunk_bytes()
         return "unknown";
     }
 
+    int metal_display_color_bits(MTLPixelFormat pixel_format)
+    {
+        switch (pixel_format) {
+        case MTLPixelFormatBGRA8Unorm: return 8;
+        case MTLPixelFormatRGB10A2Unorm:
+        case MTLPixelFormatBGR10A2Unorm: return 10;
+        case MTLPixelFormatRGBA16Float: return 16;
+        default: break;
+        }
+        return 0;
+    }
+
+    DisplayDynamicRange metal_display_dynamic_range(MTLPixelFormat pixel_format)
+    {
+        switch (pixel_format) {
+        case MTLPixelFormatBGRA8Unorm:
+        case MTLPixelFormatRGB10A2Unorm:
+        case MTLPixelFormatBGR10A2Unorm: return DisplayDynamicRange::Sdr;
+        case MTLPixelFormatRGBA16Float: return DisplayDynamicRange::Hdr;
+        default: break;
+        }
+        return DisplayDynamicRange::Unknown;
+    }
+
+    void update_metal_display_presentation(RendererState& renderer_state,
+                                           MTLPixelFormat pixel_format)
+    {
+        DisplayPresentationInfo info;
+        info.color_bits = metal_display_color_bits(pixel_format);
+        info.range      = metal_display_dynamic_range(pixel_format);
+        info.format_request_fell_back = renderer_state.requested_display_format
+                                            == DisplayFormatPreference::Rgb10A2
+                                        && (info.color_bits < 10
+                                            || info.range
+                                                   != DisplayDynamicRange::Sdr);
+        renderer_state.display_presentation = info;
+    }
+
     void configure_metal_display_formats(MetalRendererBackendState& state,
                                          RendererState& renderer_state)
     {
@@ -2070,6 +2108,8 @@ bool metal_setup_window(RendererState& renderer_state, int width,
         state->render_pass               = [MTLRenderPassDescriptor new];
         renderer_set_framebuffer_size(renderer_state, width, height);
         update_drawable_size(renderer_state);
+        update_metal_display_presentation(renderer_state,
+                                          state->display_pixel_format);
         if (renderer_state.verbose_logging) {
             const bool fell_back = state->requested_display_format
                                        == DisplayFormatPreference::Rgb10A2
diff --git a/src/imiv/imiv_renderer_opengl.cpp b/src/imiv/imiv_renderer_opengl.cpp
@@ -1807,10 +1807,8 @@ void main()
         return true;
     }
 
-    void log_opengl_framebuffer_bits(RendererState& renderer_state)
+    void update_opengl_display_presentation(RendererState& renderer_state)
     {
-        if (!renderer_state.verbose_logging)
-            return;
         GLint red_bits   = 0;
         GLint green_bits = 0;
         GLint blue_bits  = 0;
@@ -1819,12 +1817,23 @@ void main()
         glGetIntegerv(GL_GREEN_BITS, &green_bits);
         glGetIntegerv(GL_BLUE_BITS, &blue_bits);
         glGetIntegerv(GL_ALPHA_BITS, &alpha_bits);
-        std::cout << "imiv: OpenGL display format requested="
-                  << display_format_cli_name(
-                         renderer_state.requested_display_format)
-                  << " actual framebuffer bits=" << red_bits << ','
-                  << green_bits << ',' << blue_bits << ',' << alpha_bits
-                  << "\n";
+        DisplayPresentationInfo info;
+        info.color_bits = std::min(red_bits, std::min(green_bits, blue_bits));
+        if (info.color_bits <= 0)
+            info.color_bits = 0;
+        info.range                    = DisplayDynamicRange::Sdr;
+        info.format_request_fell_back = renderer_state.requested_display_format
+                                            == DisplayFormatPreference::Rgb10A2
+                                        && info.color_bits < 10;
+        renderer_state.display_presentation = info;
+        if (renderer_state.verbose_logging) {
+            std::cout << "imiv: OpenGL display format requested="
+                      << display_format_cli_name(
+                             renderer_state.requested_display_format)
+                      << " actual framebuffer bits=" << red_bits << ','
+                      << green_bits << ',' << blue_bits << ',' << alpha_bits
+                      << "\n";
+        }
     }
 
     const RendererBackendVTable k_opengl_vtable = {
@@ -1871,7 +1880,7 @@ void main()
                 return false;
             state->window = window;
             platform_glfw_make_context_current(window);
-            log_opengl_framebuffer_bits(renderer_state);
+            update_opengl_display_presentation(renderer_state);
             error_message.clear();
             return true;
         },
diff --git a/src/imiv/imiv_renderer_vulkan.cpp b/src/imiv/imiv_renderer_vulkan.cpp
@@ -62,6 +62,49 @@ namespace {
         return backend_state<VulkanState>(renderer_state);
     }
 
+    int vulkan_display_color_bits(VkFormat format)
+    {
+        switch (format) {
+        case VK_FORMAT_B8G8R8A8_UNORM:
+        case VK_FORMAT_B8G8R8A8_SRGB:
+        case VK_FORMAT_R8G8B8A8_UNORM:
+        case VK_FORMAT_R8G8B8A8_SRGB:
+        case VK_FORMAT_B8G8R8_UNORM:
+        case VK_FORMAT_B8G8R8_SRGB:
+        case VK_FORMAT_R8G8B8_UNORM:
+        case VK_FORMAT_R8G8B8_SRGB: return 8;
+        case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
+        case VK_FORMAT_A2R10G10B10_UNORM_PACK32: return 10;
+        default: break;
+        }
+        return 0;
+    }
+
+    DisplayDynamicRange vulkan_display_dynamic_range(VkColorSpaceKHR color_space)
+    {
+        switch (color_space) {
+        case VK_COLORSPACE_SRGB_NONLINEAR_KHR: return DisplayDynamicRange::Sdr;
+        default: break;
+        }
+        return DisplayDynamicRange::Unknown;
+    }
+
+    void update_vulkan_display_presentation(RendererState& renderer_state,
+                                            const VulkanState& vk_state)
+    {
+        DisplayPresentationInfo info;
+        info.color_bits = vulkan_display_color_bits(
+            vk_state.window_data.SurfaceFormat.format);
+        info.range = vulkan_display_dynamic_range(
+            vk_state.window_data.SurfaceFormat.colorSpace);
+        info.format_request_fell_back = renderer_state.requested_display_format
+                                            == DisplayFormatPreference::Rgb10A2
+                                        && (info.color_bits < 10
+                                            || info.range
+                                                   != DisplayDynamicRange::Sdr);
+        renderer_state.display_presentation = info;
+    }
+
     bool vulkan_get_viewer_texture_refs(const ViewerState& viewer,
                                         const PlaceholderUiState& ui_state,
                                         ImTextureRef& main_texture_ref,
@@ -267,6 +310,7 @@ namespace {
             width, height, vk_state->min_image_count,
             vk_state->window_image_usage);
         name_window_frame_objects(*vk_state);
+        update_vulkan_display_presentation(renderer_state, *vk_state);
         vk_state->window_data.FrameIndex = 0;
         vk_state->swapchain_rebuild      = false;
     }
@@ -306,7 +350,10 @@ namespace {
             if (vk_state == nullptr)
                 return false;
             renderer_set_framebuffer_size(renderer_state, width, height);
-            return setup_vulkan_window(*vk_state, width, height, error_message);
+            if (!setup_vulkan_window(*vk_state, width, height, error_message))
+                return false;
+            update_vulkan_display_presentation(renderer_state, *vk_state);
+            return true;
         },
         [](RendererState& renderer_state, GLFWwindow* window,
            std::string& error_message) {

Original file line number	Diff line number	Diff line change
`@@ -245,6 +245,13 @@ platform_glfw_destroy_window(GLFWwindow* window)`
`245`	`245`	`glfwDestroyWindow(window);`
`246`	`246`	`}`
`247`	`247`
	`248`	`+void`
	`249`	`+platform_glfw_set_window_title(GLFWwindow* window, const char* title)`
	`250`	`+{`
	`251`	`+ if (window != nullptr && title != nullptr)`
	`252`	`+ glfwSetWindowTitle(window, title);`
	`253`	`+}`
	`254`	`+`
`248`	`255`	`bool`
`249`	`256`	`platform_glfw_supports_vulkan(std::string& error_message)`
`250`	`257`	`{`