[idd/client] correct HDR luminance when PQ conversion is in use

`linear` is a HLSL keyword

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,3 +1,9 @@
+---
+name: Bug report
+about: Report bugs in Looking Glass (only confirmed bugs and feature requests please)
+
+---
+
 ### Issues are for Bug Reports and Feature Requests Only!
 
 If you are looking for help or support please use one of the following methods
@@ -64,3 +70,4 @@ https://www.youtube.com/watch?v=EqxxJK9Yo64
 ```
 PASTE FULL BACKTRACE HERE
 ```
+

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,9 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Looking Glass on Level1Tech's Forum
+    url: https://forum.level1techs.com/c/software/lookingGlass/142
+    about: Ask for help by creating a New Topic on the Level1Tech's forum
+  - name: Looking Glass Discord Server
+    url: https://discord.gg/52SMupxkvt
+    about: Ask for help in the Looking Glass discord server
+

.github/workflows/build.yml

@@ -120,11 +120,33 @@ jobs:
         makensis -DIVSHMEM platform/Windows/installer.nsi
 
   host-windows-native:
-    runs-on: windows-latest
+    runs-on: windows-2025
     steps:
     - uses: actions/checkout@v2
       with:
         submodules: recursive
+    - name: Install NSIS
+      shell: powershell
+      run: |
+        winget install -e --id NSIS.NSIS --silent --accept-source-agreements --accept-package-agreements
+        $paths = @(
+          (Join-Path ${env:ProgramFiles}      'NSIS\Bin'),
+          (Join-Path ${env:ProgramFiles(x86)} 'NSIS\Bin')
+        ) | Where-Object { Test-Path $_ }
+
+        if ($paths.Count -eq 0) {
+          Write-Error "NSIS 'Bin' folder not found after install."
+          exit 1
+        }
+
+        $paths | ForEach-Object {
+          Add-Content -Path $env:GITHUB_PATH -Value $_
+        }
+
+        Write-Host "makensis location(s): $($paths -join ', ')"
+    - name: Test NSIS
+      run: |
+        makensis /VERSION
     - name: Configure Windows host for native MinGW-w64
       run: |
         mkdir host\build
@@ -139,6 +161,36 @@ jobs:
         cd host\build
         makensis -DBUILD_32BIT platform\Windows\installer.nsi
 
+  idd:
+    runs-on: windows-2022
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        submodules: recursive
+    - name: Add msbuild to PATH
+      uses: microsoft/setup-msbuild@v2
+      with:
+        msbuild-architecture: x64
+    - name: Install NuGet packages
+      run: |
+        cd idd
+        nuget restore LGIdd.sln
+    - name: Build IDD
+      run: |
+        cd idd
+        msbuild.exe LGIdd.sln /t:Build /p:Configuration=Release /p:Platform=x64
+    - name: Build NSIS Installer
+      run: |
+        cd idd\x64\Release\LGIdd
+        makensis -DBUILD_32BIT installer.nsi
+    - name: Build NSIS installer with IVSHMEM drivers
+      run: |
+        cd idd\x64\Release
+        Invoke-WebRequest https://dl.quantum2.xyz/ivshmem.tar.gz -OutFile ivshmem.tar.gz
+        tar -xzvf ivshmem.tar.gz
+        cd LGIdd
+        makensis -DBUILD_32BIT -DIVSHMEM installer.nsi
+
   obs:
     runs-on: ubuntu-latest
     strategy:

.gitignore

@@ -11,7 +11,11 @@ module/modules.order
 __pycache__
 *.py[co]
 */.vs
+*.user
 idd/Debug
 idd/x64
-idd/LGIdd/x64
+idd/*/x64
-idd/LGIdd/Debug
+idd/*/Debug
+idd/*/VersionInfo.h
+idd/*/VERSION
+idd/packages

.gitmodules

@@ -9,7 +9,7 @@
 	url = https://github.com/cimgui/cimgui.git
 [submodule "repos/wayland-protocols"]
 	path = repos/wayland-protocols
-	url = https://gitlab.freedesktop.org/wayland/wayland-protocols.git
+	url = https://github.com/quantum5/wayland-protocols.git
 [submodule "repos/nanosvg"]
 	path = repos/nanosvg
 	url = https://github.com/memononen/nanosvg.git

.woodpecker/idd.yaml

@@ -0,0 +1,34 @@
+---
+labels:
+  platform: windows/amd64
+
+matrix:
+  BUILD_TYPE:
+    - Debug
+    - Release
+
+when:
+  - event: push
+    branch: master
+    repo: gnif/LookingGlass
+
+clone:
+  - name: clone
+    image: woodpeckerci/plugin-git
+    pull: false
+    settings:
+      tags: true
+
+steps:
+  - name: idd
+    image: lg-vs2022:latest
+    pull: true
+    environment:
+      VS_PATH: "\"C:\\\\Program Files (x86)\\\\Microsoft Visual Studio\\\\2022\\\\\""
+    entrypoint:
+      - cmd
+      - /C
+      - >
+        %VS_PATH%\BuildTools\Common7\Tools\VsDevCmd.bat -arch=amd64 &&
+        msbuild /restore idd\LGIdd.sln /p:Configuration=${BUILD_TYPE} /p:RestorePackagesConfig=true /p:Platform=x64 /p:SignMode=Off /m &&
+        IF EXIST C:\artifacts\build.cmd (cmd /C C:\artifacts\build.cmd)

AUTHORS

@@ -72,3 +72,6 @@ Jacob McNamee <jacob@jacobmcnamee.com> (jacobmcnamee)
 Marco Antonio J. Costa <marco.antonio.costa@gmail.com> (majcosta)
 rs189 <35667100+rs189@users.noreply.github.com> (rs189)
 Jérôme Poulin <jeromepoulin@gmail.com> (ticpu)
+Marco Rodolfi <marco.rodolfi@tuta.io> (RodoMa92)
+Stewart Borle <stewi1014@gmail.com> (stewi1014)
+Jannis Lübke <business.janrupf@gmail.com> (Janrupf)

client/CMakeLists.txt

@@ -113,6 +113,7 @@ set(SOURCES
   src/main.c
   src/core.c
   src/app.c
+  src/message.c
   src/audio.c
   src/config.c
   src/keybind.c
@@ -124,6 +125,7 @@ set(SOURCES
   src/eglutil.c
   src/overlay_utils.c
   src/render_queue.c
+  src/evdev.c
 
   src/overlay/splash.c
   src/overlay/alert.c

client/audiodevs/PipeWire/pipewire.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -168,6 +168,12 @@ static bool pipewire_init(void)
   pw_init(NULL, NULL);
 
   pw.loop = pw_loop_new(NULL);
+#if PW_CHECK_VERSION(1, 3, 81)
+  pw.context = pw_context_new(
+    pw.loop,
+    NULL,
+    0);
+#else
   pw.context = pw_context_new(
     pw.loop,
     pw_properties_new(
@@ -176,6 +182,7 @@ static bool pipewire_init(void)
       NULL
     ),
     0);
+#endif
   if (!pw.context)
   {
     DEBUG_ERROR("Failed to create a context");

client/audiodevs/PulseAudio/pulseaudio.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/displayservers/Wayland/CMakeLists.txt

@@ -13,6 +13,7 @@ find_program(WAYLAND_SCANNER_EXECUTABLE NAMES wayland-scanner)
 add_library(displayserver_Wayland STATIC
   activation.c
   clipboard.c
+  colormgmt.c
   cursor.c
   gl.c
   idle.c

client/displayservers/Wayland/activation.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/displayservers/Wayland/clipboard.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/displayservers/Wayland/colormgmt.c

@@ -0,0 +1,110 @@
+/**
+ * Looking Glass
+ * Copyright (C) 2017-2026 The Looking Glass Authors
+ * https://looking-glass.io
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc., 59
+ * Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include "wayland.h"
+
+#include <stdbool.h>
+
+#include <wayland-client.h>
+
+#include "common/debug.h"
+
+static void cmIntent(void * data, struct wp_color_manager_v1 * cm, uint32_t intent)
+{
+  if (intent == WP_COLOR_MANAGER_V1_RENDER_INTENT_PERCEPTUAL)
+    wlWm.cmHasPerceptualIntent = true;
+}
+
+static void cmFeature(void * data, struct wp_color_manager_v1 * cm, uint32_t feature)
+{
+  switch (feature)
+  {
+    case WP_COLOR_MANAGER_V1_FEATURE_PARAMETRIC:
+      wlWm.cmHasParametric = true;
+      break;
+    case WP_COLOR_MANAGER_V1_FEATURE_SET_LUMINANCES:
+      wlWm.cmHasLuminances = true;
+      break;
+    case WP_COLOR_MANAGER_V1_FEATURE_SET_MASTERING_DISPLAY_PRIMARIES:
+      wlWm.cmHasMasteringPrimaries = true;
+      break;
+    default:
+      break;
+  }
+}
+
+static void cmTFNamed(void * data, struct wp_color_manager_v1 * cm, uint32_t tf)
+{
+  if (tf == WP_COLOR_MANAGER_V1_TRANSFER_FUNCTION_ST2084_PQ)
+    wlWm.cmHasTFSt2084PQ = true;
+  else if (tf == WP_COLOR_MANAGER_V1_TRANSFER_FUNCTION_EXT_LINEAR)
+    wlWm.cmHasTFExtLinear = true;
+}
+
+static void cmPrimariesNamed(void * data, struct wp_color_manager_v1 * cm,
+    uint32_t primaries)
+{
+  if (primaries == WP_COLOR_MANAGER_V1_PRIMARIES_BT2020)
+    wlWm.cmHasPrimariesBT2020 = true;
+  else if (primaries == WP_COLOR_MANAGER_V1_PRIMARIES_SRGB)
+    wlWm.cmHasPrimariesSRGB = true;
+}
+
+static void cmDone(void * data, struct wp_color_manager_v1 * cm)
+{
+  wlWm.cmFeaturesDone = true;
+  wlWm.cmCanDoHDR = wlWm.cmHasParametric &&
+    ((wlWm.cmHasTFSt2084PQ && wlWm.cmHasPrimariesBT2020) ||
+     (wlWm.cmHasTFExtLinear && wlWm.cmHasPrimariesSRGB));
+  DEBUG_INFO("Color management features: parametric:%d luminances:%d "
+      "mastering_primaries:%d st2084_pq:%d ext_linear:%d bt2020:%d srgb:%d "
+      "can_do_hdr:%d",
+      wlWm.cmHasParametric, wlWm.cmHasLuminances,
+      wlWm.cmHasMasteringPrimaries,
+      wlWm.cmHasTFSt2084PQ, wlWm.cmHasTFExtLinear,
+      wlWm.cmHasPrimariesBT2020, wlWm.cmHasPrimariesSRGB,
+      wlWm.cmCanDoHDR);
+}
+
+static const struct wp_color_manager_v1_listener cmListener = {
+  .supported_intent          = cmIntent,
+  .supported_feature         = cmFeature,
+  .supported_tf_named        = cmTFNamed,
+  .supported_primaries_named = cmPrimariesNamed,
+  .done                      = cmDone,
+};
+
+bool waylandColorMgmtInit(void)
+{
+  if (!wlWm.colorManager)
+    return true;
+
+  wp_color_manager_v1_add_listener(wlWm.colorManager, &cmListener, NULL);
+  return true;
+}
+
+void waylandColorMgmtFree(void)
+{
+  if (!wlWm.colorManager)
+    return;
+
+  wp_color_manager_v1_destroy(wlWm.colorManager);
+  wlWm.colorManager = NULL;
+}

client/displayservers/Wayland/cursor.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -183,7 +183,7 @@ void waylandCursorFree(void)
 
 void waylandCursorScaleChange(void)
 {
-  int newScale = ceil(wl_fixed_to_double(wlWm.scale));
+  int newScale = waylandScaleCeil(wlWm.scale);
   if (newScale == wlWm.cursorScale)
     return;
 

client/displayservers/Wayland/desktops/libdecor/libdecor.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -46,6 +46,7 @@ typedef struct LibDecorState
   int32_t width, height;
   bool     needsResize;
   bool     fullscreen;
+  bool     borderless;
   uint32_t resizeSerial;
 }
 LibDecorState;
@@ -147,6 +148,10 @@ static bool libdecor_shellInit(
   if (maximize)
     libdecor_frame_set_maximized(state.libdecorFrame);
 
+  if (borderless)
+    libdecor_frame_set_visibility(state.libdecorFrame, false);
+  state.borderless = borderless;
+
   if (resizable)
     libdecor_frame_set_capabilities(state.libdecorFrame,
         LIBDECOR_ACTION_RESIZE);
@@ -183,6 +188,7 @@ static void libdecor_setFullscreen(bool fs)
   else
     libdecor_frame_unset_fullscreen(state.libdecorFrame);
 
+  if (!state.borderless)
     libdecor_frame_set_visibility(state.libdecorFrame, !fs);
 }
 
@@ -257,6 +263,11 @@ void libdecor_pollWait(struct wl_display * display, int epollFd,
   }
 }
 
+bool libdecor_configured(void)
+{
+  return state.configured;
+}
+
 WL_DesktopOps WLD_libdecor =
 {
   .name                      = "libdecor",
@@ -271,5 +282,6 @@ WL_DesktopOps WLD_libdecor =
   .getSize                   = libdecor_getSize,
   .registryGlobalHandler     = libdecor_registryGlobalHandler,
   .pollInit                  = libdecor_pollInit,
-  .pollWait                  = libdecor_pollWait
+  .pollWait                  = libdecor_pollWait,
+  .configured                = libdecor_configured
 };

client/displayservers/Wayland/desktops/xdg/xdg.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -49,6 +49,7 @@ typedef struct XDGState
   uint32_t resizeSerial;
   bool fullscreen;
   bool floating;
+  bool resizable;
   int displayFd;
 }
 XDGState;
@@ -155,6 +156,13 @@ bool xdg_shellInit(struct wl_display * display, struct wl_surface * surface,
   if (maximize)
     xdg_toplevel_set_maximized(state.toplevel);
 
+  if (!resizable)
+  {
+    xdg_toplevel_set_min_size(state.toplevel, state.width, state.height);
+    xdg_toplevel_set_max_size(state.toplevel, state.width, state.height);
+  }
+  state.resizable = resizable;
+
   if (state.decorationManager)
   {
     state.toplevelDecoration = zxdg_decoration_manager_v1_get_toplevel_decoration(
@@ -200,7 +208,7 @@ static void xdg_minimize(void)
 
 static void xdg_shellResize(int w, int h)
 {
-  if (!state.floating)
+  if (!state.floating || !state.resizable)
     return;
 
   state.width  = w;
@@ -296,6 +304,11 @@ void xdg_pollWait(struct wl_display * display, int epollFd,
     wl_display_cancel_read(display);
 }
 
+bool xdg_configured(void)
+{
+  return state.configured;
+}
+
 WL_DesktopOps WLD_xdg =
 {
   .name                      = "xdg",
@@ -310,5 +323,6 @@ WL_DesktopOps WLD_xdg =
   .getSize                   = xdg_getSize,
   .registryGlobalHandler     = xdg_registryGlobalHandler,
   .pollInit                  = xdg_pollInit,
-  .pollWait                  = xdg_pollWait
+  .pollWait                  = xdg_pollWait,
+  .configured                = xdg_configured
 };

client/displayservers/Wayland/gl.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -70,6 +70,52 @@ EGLDisplay waylandGetEGLDisplay(void)
   return eglGetDisplay(native);
 }
 
+static void applyHDRPending(void)
+{
+  if (wlWm.pendingHDRApply)
+  {
+    wlWm.pendingHDRApply = false;
+    atomic_thread_fence(memory_order_acquire);
+    waylandSetHDRImageDescription(
+        wlWm.pendingHDRDisplayPrimary, wlWm.pendingHDRWhitePoint,
+        wlWm.pendingHDRMaxDisplayLuminance,
+        wlWm.pendingHDRMinDisplayLuminance,
+        wlWm.pendingHDRMaxCLL,
+        wlWm.pendingHDRMaxFALL,
+        wlWm.pendingHDRPQ);
+  }
+  else if (wlWm.pendingHDRClear)
+  {
+    wlWm.pendingHDRClear = false;
+    waylandClearHDRImageDescription();
+  }
+}
+
+void waylandClearHDRImageDescription(void)
+{
+  if (!wlWm.hdrActive)
+    return;
+
+  if (wlWm.hdrImageCreator)
+  {
+    wp_image_description_creator_params_v1_destroy(wlWm.hdrImageCreator);
+    wlWm.hdrImageCreator = NULL;
+  }
+  if (wlWm.hdrImageDesc)
+  {
+    wp_image_description_v1_destroy(wlWm.hdrImageDesc);
+    wlWm.hdrImageDesc = NULL;
+  }
+  if (wlWm.colorSurface)
+  {
+    wp_color_management_surface_v1_destroy(wlWm.colorSurface);
+    wlWm.colorSurface = NULL;
+  }
+
+  wlWm.hdrActive = false;
+  DEBUG_INFO("HDR image description cleared");
+}
+
 void waylandEGLSwapBuffers(EGLDisplay display, EGLSurface surface, const struct Rect * damage, int count)
 {
   if (!wlWm.swapWithDamage.init)
@@ -84,6 +130,7 @@ void waylandEGLSwapBuffers(EGLDisplay display, EGLSurface surface, const struct
   }
 
   waylandPresentationFrame();
+  applyHDRPending();
   swapWithDamage(&wlWm.swapWithDamage, display, surface, damage, count);
 
   if (wlWm.needsResize)
@@ -92,8 +139,8 @@ void waylandEGLSwapBuffers(EGLDisplay display, EGLSurface surface, const struct
 
     int width, height;
     wlWm.desktop->getSize(&width, &height);
-    wl_egl_window_resize(wlWm.eglWindow, wl_fixed_to_int(width * wlWm.scale),
+    wl_egl_window_resize(wlWm.eglWindow, waylandScaleMulInt(wlWm.scale, width),
-        wl_fixed_to_int(height * wlWm.scale), 0, 0);
+        waylandScaleMulInt(wlWm.scale, height), 0, 0);
 
     if (width == 0 || height == 0)
       skipResize = true;
@@ -123,7 +170,7 @@ void waylandEGLSwapBuffers(EGLDisplay display, EGLSurface surface, const struct
         wp_viewport_destroy(wlWm.viewport);
         wlWm.viewport = NULL;
       }
-      wl_surface_set_buffer_scale(wlWm.surface, wl_fixed_to_int(wlWm.scale));
+      wl_surface_set_buffer_scale(wlWm.surface, waylandScaleFloor(wlWm.scale));
     }
 
     struct wl_region * region = wl_compositor_create_region(wlWm.compositor);
@@ -131,7 +178,7 @@ void waylandEGLSwapBuffers(EGLDisplay display, EGLSurface surface, const struct
     wl_surface_set_opaque_region(wlWm.surface, region);
     wl_region_destroy(region);
 
-    app_handleResizeEvent(width, height, wl_fixed_to_double(wlWm.scale),
+    app_handleResizeEvent(width, height, waylandScaleToDouble(wlWm.scale),
         (struct Border) {0, 0, 0, 0});
     app_invalidateWindow(true);
     waylandStopWaitFrame();
@@ -149,23 +196,239 @@ EGLNativeWindowType waylandGetEGLNativeWindow(void)
 }
 #endif
 
+// HDR color management support
+void waylandSetHDRImageDescription(const uint16_t displayPrimary[3][2],
+    const uint16_t whitePoint[2], uint32_t maxDisplayLuminance,
+    uint32_t minDisplayLuminance, uint32_t maxCLL, uint32_t maxFALL,
+    bool hdrPQ)
+{
+  if (!wlWm.colorManager)
+    return;
+
+  if (!wlWm.cmFeaturesDone)
+  {
+    DEBUG_WARN("Color management features not yet advertised, deferring HDR");
+    return;
+  }
+
+  if (!wlWm.cmHasParametric)
+  {
+    DEBUG_WARN("Compositor does not support parametric image descriptions");
+    return;
+  }
+
+  // Verify the compositor supports the transfer function we need
+  if (hdrPQ && !wlWm.cmHasTFSt2084PQ)
+  {
+    DEBUG_WARN("Compositor does not support ST2084_PQ transfer function");
+    return;
+  }
+  if (!hdrPQ && !wlWm.cmHasTFExtLinear)
+  {
+    DEBUG_WARN("Compositor does not support EXT_LINEAR transfer function");
+    return;
+  }
+
+  // Verify primaries support for the target color space
+  if (hdrPQ && !wlWm.cmHasPrimariesBT2020)
+  {
+    DEBUG_WARN("Compositor does not support BT.2020 primaries");
+    return;
+  }
+  if (!hdrPQ && !wlWm.cmHasPrimariesSRGB)
+  {
+    DEBUG_WARN("Compositor does not support sRGB primaries");
+    return;
+  }
+
+  // Clean up any previous description (allows re-application with updated metadata)
+  if (wlWm.hdrImageCreator)
+  {
+    wp_image_description_creator_params_v1_destroy(wlWm.hdrImageCreator);
+    wlWm.hdrImageCreator = NULL;
+  }
+  if (wlWm.hdrImageDesc)
+  {
+    wp_image_description_v1_destroy(wlWm.hdrImageDesc);
+    wlWm.hdrImageDesc = NULL;
+  }
+  if (wlWm.colorSurface)
+  {
+    wp_color_management_surface_v1_destroy(wlWm.colorSurface);
+    wlWm.colorSurface = NULL;
+  }
+
+  wlWm.hdrActive = false;
+
+  wlWm.hdrImageCreator =
+    wp_color_manager_v1_create_parametric_creator(wlWm.colorManager);
+  if (!wlWm.hdrImageCreator)
+  {
+    DEBUG_WARN("Failed to create parametric image description creator");
+    return;
+  }
+
+  // Set primaries: BT.2020 for PQ HDR10, sRGB for scRGB/FP16
+  wp_image_description_creator_params_v1_set_primaries_named(
+      wlWm.hdrImageCreator,
+      hdrPQ ? WP_COLOR_MANAGER_V1_PRIMARIES_BT2020
+            : WP_COLOR_MANAGER_V1_PRIMARIES_SRGB);
+
+  // Select transfer function: PQ for PQ-encoded content, linear for scRGB/FP16
+  wp_image_description_creator_params_v1_set_tf_named(
+      wlWm.hdrImageCreator,
+      hdrPQ ? WP_COLOR_MANAGER_V1_TRANSFER_FUNCTION_ST2084_PQ
+            : WP_COLOR_MANAGER_V1_TRANSFER_FUNCTION_EXT_LINEAR);
+
+  // Set luminance range from metadata.
+  // min_lum is in 0.0001 cd/m² units (multiplied by 10000 as per protocol).
+  // max_lum and reference_lum are in unscaled cd/m² units.
+  if (wlWm.cmHasLuminances)
+    wp_image_description_creator_params_v1_set_luminances(
+        wlWm.hdrImageCreator,
+        minDisplayLuminance > 0 ? minDisplayLuminance : 50,
+        maxDisplayLuminance > 0 ? maxDisplayLuminance / 10000 : 1000,
+        hdrPQ                   ? 203                         : 80);
+
+  // Set mastering display primaries from frame HDR metadata.
+  // Always set when the compositor supports it, falling back to the
+  // primaries from the metadata (even if zero, in which case the
+  // compositor uses its own defaults).
+  if (wlWm.cmHasMasteringPrimaries)
+  {
+    wp_image_description_creator_params_v1_set_mastering_display_primaries(
+        wlWm.hdrImageCreator,
+        displayPrimary[0][0], displayPrimary[0][1],
+        displayPrimary[1][0], displayPrimary[1][1],
+        displayPrimary[2][0], displayPrimary[2][1],
+        whitePoint[0], whitePoint[1]);
+
+    // Set mastering luminance range so the compositor knows the target
+    // color volume for tone mapping.  min_lum is in ×10000 units (0.0001 cd/m²),
+    // max_lum is in unscaled cd/m².
+    wp_image_description_creator_params_v1_set_mastering_luminance(
+        wlWm.hdrImageCreator,
+        minDisplayLuminance > 0 ? minDisplayLuminance : 50,
+        maxDisplayLuminance > 0 ? maxDisplayLuminance / 10000 : 1000);
+  }
+
+  if (maxCLL > 0)
+    wp_image_description_creator_params_v1_set_max_cll(wlWm.hdrImageCreator, maxCLL);
+  if (maxFALL > 0)
+    wp_image_description_creator_params_v1_set_max_fall(wlWm.hdrImageCreator, maxFALL);
+
+  wlWm.hdrImageDesc =
+    wp_image_description_creator_params_v1_create(wlWm.hdrImageCreator);
+  wlWm.hdrImageCreator = NULL; // consumed by create
+
+  if (!wlWm.hdrImageDesc)
+  {
+    DEBUG_WARN("Failed to create HDR image description");
+    return;
+  }
+
+  wlWm.colorSurface =
+    wp_color_manager_v1_get_surface(wlWm.colorManager, wlWm.surface);
+  if (!wlWm.colorSurface)
+  {
+    DEBUG_WARN("Failed to get color management surface");
+    wp_image_description_v1_destroy(wlWm.hdrImageDesc);
+    wlWm.hdrImageDesc = NULL;
+    return;
+  }
+
+  wp_color_management_surface_v1_set_image_description(
+      wlWm.colorSurface, wlWm.hdrImageDesc,
+      WP_COLOR_MANAGER_V1_RENDER_INTENT_PERCEPTUAL);
+
+  wlWm.hdrActive = true;
+  DEBUG_INFO("HDR image description set on surface (%s, %s, %u nits)",
+      hdrPQ ? "PQ" : "scRGB", hdrPQ ? "BT.2020" : "sRGB", maxDisplayLuminance);
+}
+
+bool waylandRequestHDR(const uint16_t displayPrimary[3][2],
+    const uint16_t whitePoint[2], uint32_t maxDisplayLuminance,
+    uint32_t minDisplayLuminance, uint32_t maxCLL, uint32_t maxFALL,
+    bool hdrPQ)
+{
+  if (!wlWm.cmFeaturesDone || !wlWm.cmHasParametric)
+    return false;
+  if (hdrPQ && !wlWm.cmHasTFSt2084PQ)
+    return false;
+  if (!hdrPQ && !wlWm.cmHasTFExtLinear)
+    return false;
+  if (hdrPQ && !wlWm.cmHasPrimariesBT2020)
+    return false;
+  if (!hdrPQ && !wlWm.cmHasPrimariesSRGB)
+    return false;
+
+  wlWm.pendingHDRPQ = hdrPQ;
+
+  // Write all metadata before setting the apply flag to ensure the
+  // render thread sees the complete HDR metadata when it observes
+  // pendingHDRApply == true.
+  memcpy(wlWm.pendingHDRDisplayPrimary, displayPrimary,
+      sizeof(wlWm.pendingHDRDisplayPrimary));
+  memcpy(wlWm.pendingHDRWhitePoint, whitePoint,
+      sizeof(wlWm.pendingHDRWhitePoint));
+  wlWm.pendingHDRMaxDisplayLuminance = maxDisplayLuminance;
+  wlWm.pendingHDRMinDisplayLuminance = minDisplayLuminance;
+  wlWm.pendingHDRMaxCLL              = maxCLL;
+  wlWm.pendingHDRMaxFALL             = maxFALL;
+
+  wlWm.pendingHDRClear = false;
+  atomic_thread_fence(memory_order_release);
+  wlWm.pendingHDRApply = true;
+  return true;
+}
+
+void waylandRequestClearHDR(void)
+{
+  wlWm.pendingHDRClear = true;
+  wlWm.pendingHDRApply = false;
+}
+
 #ifdef ENABLE_OPENGL
-bool waylandOpenGLInit(void)
+
+static const EGLint eglBaseAttrs[] =
 {
-  EGLint attr[] =
-  {
-    EGL_BUFFER_SIZE      , 24,
   EGL_CONFORMANT       , EGL_OPENGL_BIT,
   EGL_RENDERABLE_TYPE  , EGL_OPENGL_BIT,
   EGL_COLOR_BUFFER_TYPE, EGL_RGB_BUFFER,
-    EGL_RED_SIZE         , 8,
-    EGL_GREEN_SIZE       , 8,
-    EGL_BLUE_SIZE        , 8,
   EGL_SAMPLE_BUFFERS   , 0,
   EGL_SAMPLES          , 0,
   EGL_NONE
 };
 
+static bool eglChooseConfigWithDepth(EGLDisplay display, EGLint red,
+    EGLint green, EGLint blue, EGLint alpha, EGLint depth,
+    EGLConfig * config, const char ** desc)
+{
+  // Build attr array with the base attrs plus color depth
+  EGLint attr[32];
+  int   ai = 0;
+  attr[ai++] = EGL_RED_SIZE  ; attr[ai++] = red;
+  attr[ai++] = EGL_GREEN_SIZE; attr[ai++] = green;
+  attr[ai++] = EGL_BLUE_SIZE ; attr[ai++] = blue;
+  attr[ai++] = EGL_ALPHA_SIZE; attr[ai++] = alpha;
+  attr[ai++] = EGL_BUFFER_SIZE; attr[ai++] = depth;
+  for (int i = 0; eglBaseAttrs[i] != EGL_NONE; ++i)
+    attr[ai++] = eglBaseAttrs[i];
+  attr[ai] = EGL_NONE;
+
+  EGLint num_config;
+  if (eglChooseConfig(display, attr, config, 1, &num_config) && num_config > 0)
+  {
+    if (desc)
+      *desc = red >= 16 ? "FP16 (RGBA16F)" :
+              red >= 10 ? "10-bit (RGBA10)" : "8-bit (RGBA8)";
+    return true;
+  }
+  return false;
+}
+
+bool waylandOpenGLInit(void)
+{
   wlWm.glDisplay = waylandGetEGLDisplay();
 
   int maj, min;
@@ -181,13 +444,31 @@ bool waylandOpenGLInit(void)
     return false;
   }
 
-  EGLint num_config;
+  EGLConfig config;
-  if (!eglChooseConfig(wlWm.glDisplay, attr, &wlWm.glConfig, 1, &num_config))
+  const char * configDesc = NULL;
+
+  // Probe for best available color depth: FP16 → 10-bit → 8-bit
+  if (!eglChooseConfigWithDepth(wlWm.glDisplay,
+        16, 16, 16, 0, 48, &config, &configDesc) &&
+      !eglChooseConfigWithDepth(wlWm.glDisplay,
+        10, 10, 10, 2, 32, &config, &configDesc) &&
+      !eglChooseConfigWithDepth(wlWm.glDisplay,
+        8, 8, 8, 0, 24, &config, &configDesc))
   {
-    DEBUG_ERROR("Failed to choose config (eglError: 0x%x)", eglGetError());
+    DEBUG_ERROR("Failed to choose any EGL config");
     return false;
   }
 
+  wlWm.glConfig = config;
+  DEBUG_INFO("EGL config: %s", configDesc);
+
+  // Also store the 8-bit fallback for SDR contexts
+  if (configDesc && strcmp(configDesc, "8-bit (RGBA8)") != 0)
+    eglChooseConfigWithDepth(wlWm.glDisplay,
+        8, 8, 8, 0, 24, &wlWm.glConfigSDR, NULL);
+  else
+    wlWm.glConfigSDR = wlWm.glConfig;
+
   wlWm.glSurface = eglCreateWindowSurface(wlWm.glDisplay, wlWm.glConfig, wlWm.eglWindow, NULL);
   if (wlWm.glSurface == EGL_NO_SURFACE)
   {

client/displayservers/Wayland/idle.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/displayservers/Wayland/input.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -32,6 +32,9 @@
 #include "app.h"
 #include "common/debug.h"
 
+const double WL_SCROLL_STEP = 15.0;
+const double WL_HALF_SCROLL_STEP = WL_SCROLL_STEP / 2.0;
+
 // Mouse-handling listeners.
 
 static void pointerMotionHandler(void * data, struct wl_pointer * pointer,
@@ -91,12 +94,25 @@ static void pointerAxisHandler(void * data, struct wl_pointer * pointer,
   if (axis != WL_POINTER_AXIS_VERTICAL_SCROLL)
     return;
 
-  int button = value > 0 ?
+  double delta = wl_fixed_to_double(value);
-    5 /* SPICE_MOUSE_BUTTON_DOWN */ :
+
-    4 /* SPICE_MOUSE_BUTTON_UP */;
+  wlWm.scrollState += delta;
-  app_handleButtonPress(button);
+
-  app_handleButtonRelease(button);
+  while (wlWm.scrollState > WL_HALF_SCROLL_STEP)
-  app_handleWheelMotion(wl_fixed_to_double(value) / 15.0);
+  {
+    app_handleButtonPress(5 /* SPICE_MOUSE_BUTTON_DOWN */);
+    app_handleButtonRelease(5 /* SPICE_MOUSE_BUTTON_DOWN */);
+    wlWm.scrollState -= WL_SCROLL_STEP;
+  }
+
+  while (wlWm.scrollState < -WL_HALF_SCROLL_STEP)
+  {
+    app_handleButtonPress(4 /* SPICE_MOUSE_BUTTON_UP */);
+    app_handleButtonRelease(4 /* SPICE_MOUSE_BUTTON_UP */);
+    wlWm.scrollState += WL_SCROLL_STEP;
+  }
+
+  app_handleWheelMotion(delta / WL_SCROLL_STEP);
 }
 
 static int mapWaylandToSpiceButton(uint32_t button)
@@ -209,7 +225,7 @@ done:
   close(fd);
 }
 
-static int getCharcode(uint32_t key)
+int waylandGetCharCode(int key)
 {
   key += 8; // xkb scancode is evdev scancode + 8
   xkb_keysym_t sym = xkb_state_key_get_one_sym(wlWm.xkbState, key);
@@ -232,7 +248,7 @@ static void keyboardEnterHandler(void * data, struct wl_keyboard * keyboard,
 
   uint32_t * key;
   wl_array_for_each(key, keys)
-    app_handleKeyPress(*key, getCharcode(*key));
+    app_handleKeyPress(*key);
 }
 
 static void keyboardLeaveHandler(void * data, struct wl_keyboard * keyboard,
@@ -253,9 +269,9 @@ static void keyboardKeyHandler(void * data, struct wl_keyboard * keyboard,
     return;
 
   if (state == WL_KEYBOARD_KEY_STATE_PRESSED)
-    app_handleKeyPress(key, getCharcode(key));
+    app_handleKeyPress(key);
   else
-    app_handleKeyRelease(key, getCharcode(key));
+    app_handleKeyRelease(key);
 
   if (!wlWm.xkbState || !app_isOverlayMode() || state != WL_KEYBOARD_KEY_STATE_PRESSED)
     return;

client/displayservers/Wayland/interface/desktop.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -58,6 +58,8 @@ typedef struct WL_DesktopOps
   bool (*pollInit)(struct wl_display * display);
 
   void (*pollWait)(struct wl_display * display, int epollFd, unsigned int time);
+
+  bool (*configured)(void);
 }
 WL_DesktopOps;
 

client/displayservers/Wayland/output.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -29,17 +29,17 @@
 
 static void outputUpdateScale(struct WaylandOutput * node)
 {
-  wl_fixed_t original = node->scale;
+  struct WaylandScale original = node->scale;
 
   if (!wlWm.useFractionalScale || !wlWm.viewporter || !node->logicalWidth)
-    node->scale = wl_fixed_from_int(node->scaleInt);
+    node->scale = waylandScaleFromInt(node->scaleInt);
   else
   {
     int32_t modeWidth = node->modeRotate ? node->modeHeight : node->modeWidth;
-    node->scale = wl_fixed_from_double(1.0 * modeWidth / node->logicalWidth);
+    node->scale = waylandScaleFromRatio(modeWidth, node->logicalWidth);
   }
 
-  if (original != node->scale)
+  if (!waylandScaleEqual(original, node->scale))
     waylandWindowUpdateScale();
 }
 
@@ -167,7 +167,7 @@ void waylandOutputBind(uint32_t name, uint32_t version)
   }
 
   node->name    = name;
-  node->scale   = 0;
+  node->scale   = waylandScaleFromInt(0);
   node->version = version;
   node->output  = wl_registry_bind(wlWm.registry, name,
       &wl_output_interface, version >= 3 ? 3 : 2);
@@ -209,12 +209,12 @@ void waylandOutputTryUnbind(uint32_t name)
   }
 }
 
-wl_fixed_t waylandOutputGetScale(struct wl_output * output)
+struct WaylandScale waylandOutputGetScale(struct wl_output * output)
 {
   struct WaylandOutput * node;
 
   wl_list_for_each(node, &wlWm.outputs, link)
     if (node->output == output)
       return node->scale;
-  return 0;
+  return waylandScaleFromInt(0);
 }

client/displayservers/Wayland/poll.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/displayservers/Wayland/presentation.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/displayservers/Wayland/protocol/CMakeLists.txt

@@ -60,6 +60,15 @@ wayland_generate(
 wayland_generate(
   "${WAYLAND_PROTOCOLS_BASE}/staging/xdg-activation/xdg-activation-v1.xml"
   "${CMAKE_BINARY_DIR}/wayland/wayland-xdg-activation-v1-client-protocol")
+wayland_generate(
+  "${WAYLAND_PROTOCOLS_BASE}/staging/fractional-scale/fractional-scale-v1.xml"
+  "${CMAKE_BINARY_DIR}/wayland/wayland-fractional-scale-v1-client-protocol")
+wayland_generate(
+  "${WAYLAND_PROTOCOLS_BASE}/staging/content-type/content-type-v1.xml"
+  "${CMAKE_BINARY_DIR}/wayland/wayland-content-type-v1-client-protocol")
+wayland_generate(
+  "${WAYLAND_PROTOCOLS_BASE}/staging/color-management/color-management-v1.xml"
+  "${CMAKE_BINARY_DIR}/wayland/wayland-color-management-v1-client-protocol")
 
 target_link_libraries(wayland_protocol
   PkgConfig::WAYLAND

client/displayservers/Wayland/registry.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -46,6 +46,9 @@ static void registryGlobalHandler(void * data, struct wl_registry * registry,
   else if (!strcmp(interface, wp_viewporter_interface.name))
     wlWm.viewporter = wl_registry_bind(wlWm.registry, name,
         &wp_viewporter_interface, 1);
+  else if (!strcmp(interface, wp_fractional_scale_manager_v1_interface.name))
+    wlWm.fractionalScaleManager = wl_registry_bind(wlWm.registry, name,
+        &wp_fractional_scale_manager_v1_interface, 1);
   else if (!strcmp(interface, zwp_relative_pointer_manager_v1_interface.name))
     wlWm.relativePointerManager = wl_registry_bind(wlWm.registry, name,
         &zwp_relative_pointer_manager_v1_interface, 1);
@@ -68,6 +71,12 @@ static void registryGlobalHandler(void * data, struct wl_registry * registry,
   else if (!strcmp(interface, xdg_activation_v1_interface.name))
     wlWm.xdgActivation = wl_registry_bind(wlWm.registry, name,
         &xdg_activation_v1_interface, 1);
+  else if (!strcmp(interface, wp_content_type_manager_v1_interface.name))
+    wlWm.contentTypeManager = wl_registry_bind(wlWm.registry, name,
+        &wp_content_type_manager_v1_interface, 1);
+  else if (!strcmp(interface, wp_color_manager_v1_interface.name))
+    wlWm.colorManager = wl_registry_bind(wlWm.registry, name,
+        &wp_color_manager_v1_interface, 1);
   else if (wlWm.desktop->registryGlobalHandler(
         data, registry, name, interface, version))
     return;

client/displayservers/Wayland/scale.h

@@ -0,0 +1,80 @@
+/**
+ * Looking Glass
+ * Copyright © 2017-2026 The Looking Glass Authors
+ * https://looking-glass.io
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc., 59
+ * Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <stdint.h>
+
+struct WaylandScale
+{
+  int32_t num;
+  int32_t den;
+};
+
+static inline struct WaylandScale waylandScaleFromInt(int32_t scale)
+{
+  return (struct WaylandScale) { scale, 1 };
+}
+
+static inline struct WaylandScale waylandScaleFromRatio(int32_t num, int32_t den)
+{
+  return (struct WaylandScale) { num, den };
+}
+
+static inline bool waylandScaleValid(struct WaylandScale scale)
+{
+  return scale.num > 0 && scale.den > 0;
+}
+
+static inline bool waylandScaleEqual(struct WaylandScale a, struct WaylandScale b)
+{
+  return (int64_t)a.num * b.den == (int64_t)b.num * a.den;
+}
+
+static inline int waylandScaleCmp(struct WaylandScale a, struct WaylandScale b)
+{
+  int64_t lhs = (int64_t)a.num * b.den;
+  int64_t rhs = (int64_t)b.num * a.den;
+
+  return (lhs > rhs) - (lhs < rhs);
+}
+
+static inline bool waylandScaleIsFractional(struct WaylandScale scale)
+{
+  return waylandScaleValid(scale) && scale.num % scale.den != 0;
+}
+
+static inline int waylandScaleFloor(struct WaylandScale scale)
+{
+  return scale.num / scale.den;
+}
+
+static inline int waylandScaleCeil(struct WaylandScale scale)
+{
+  return (scale.num + scale.den - 1) / scale.den;
+}
+
+static inline int waylandScaleMulInt(struct WaylandScale scale, int value)
+{
+  return (int)(((int64_t)value * scale.num + scale.den / 2) / scale.den);
+}
+
+static inline double waylandScaleToDouble(struct WaylandScale scale)
+{
+  return (double)scale.num / (double)scale.den;
+}

client/displayservers/Wayland/state.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/displayservers/Wayland/wayland.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -28,6 +28,7 @@
 
 #include "common/debug.h"
 #include "common/option.h"
+#include "interface/renderer.h"
 
 #include "dynamic/wayland_desktops.h"
 
@@ -143,6 +144,9 @@ static bool waylandInit(const LG_DSInitParams params)
   if (!waylandRegistryInit())
     return false;
 
+  if (!waylandColorMgmtInit())
+    return false;
+
   if (!waylandActivationInit())
     return false;
 
@@ -189,6 +193,7 @@ static void waylandFree(void)
   waylandPresentationFree();
   waylandInputFree();
   waylandOutputFree();
+  waylandColorMgmtFree();
   waylandRegistryFree();
   waylandCursorFree();
   wl_display_disconnect(wlWm.display);
@@ -202,6 +207,12 @@ static bool waylandGetProp(LG_DSProperty prop, void * ret)
     return true;
   }
 
+  if (prop == LG_DS_NATIVE_HDR)
+  {
+    *(bool *)ret = wlWm.cmCanDoHDR;
+    return true;
+  }
+
   return false;
 }
 
@@ -227,6 +238,22 @@ static void waylandMinimize(void)
   wlWm.desktop->minimize();
 }
 
+static bool waylandHDRCallback(const void * rendererFormat)
+{
+  if (!wlWm.colorManager)
+    return false;
+
+  const LG_RendererFormat * format = (const LG_RendererFormat *)rendererFormat;
+  if (format->hdr)
+    return waylandRequestHDR(format->hdrDisplayPrimary, format->hdrWhitePoint,
+        format->hdrMaxDisplayLuminance, format->hdrMinDisplayLuminance,
+        format->hdrMaxContentLightLevel, format->hdrMaxFrameAverageLightLevel,
+        format->hdrPQ);
+  else
+    waylandRequestClearHDR();
+  return true;
+}
+
 struct LG_DisplayServerOps LGDS_Wayland =
 {
   .name                = "Wayland",
@@ -263,6 +290,7 @@ struct LG_DisplayServerOps LGDS_Wayland =
   .uncapturePointer    = waylandUncapturePointer,
   .grabKeyboard        = waylandGrabKeyboard,
   .ungrabKeyboard      = waylandUngrabKeyboard,
+  .getCharCode         = waylandGetCharCode,
   .warpPointer         = waylandWarpPointer,
   .realignPointer      = waylandRealignPointer,
   .isValidPointerPos   = waylandIsValidPointerPos,
@@ -275,6 +303,8 @@ struct LG_DisplayServerOps LGDS_Wayland =
   .getFullscreen       = waylandGetFullscreen,
   .minimize            = waylandMinimize,
 
+  .setHDRImageDescription = waylandHDRCallback,
+
   .cbInit    = waylandCBInit,
   .cbNotice  = waylandCBNotice,
   .cbRelease = waylandCBRelease,

client/displayservers/Wayland/wayland.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -47,6 +47,11 @@
 #include "wayland-idle-inhibit-unstable-v1-client-protocol.h"
 #include "wayland-xdg-output-unstable-v1-client-protocol.h"
 #include "wayland-xdg-activation-v1-client-protocol.h"
+#include "wayland-fractional-scale-v1-client-protocol.h"
+#include "wayland-content-type-v1-client-protocol.h"
+#include "wayland-color-management-v1-client-protocol.h"
+
+#include "scale.h"
 
 typedef void (*WaylandPollCallback)(uint32_t events, void * opaque);
 
@@ -62,7 +67,7 @@ struct WaylandPoll
 struct WaylandOutput
 {
   uint32_t name;
-  wl_fixed_t scale;
+  struct WaylandScale scale;
   int32_t scaleInt;
   int32_t logicalWidth;
   int32_t logicalHeight;
@@ -81,13 +86,6 @@ struct SurfaceOutput
   struct wl_list link;
 };
 
-enum EGLSwapWithDamageState {
-  SWAP_WITH_DAMAGE_UNKNOWN,
-  SWAP_WITH_DAMAGE_UNSUPPORTED,
-  SWAP_WITH_DAMAGE_KHR,
-  SWAP_WITH_DAMAGE_EXT,
-};
-
 struct xkb_context;
 struct xkb_keymap;
 struct xkb_state;
@@ -108,12 +106,13 @@ struct WaylandDSState
   struct wl_shm * shm;
   struct wl_compositor * compositor;
 
-  wl_fixed_t scale;
+  struct WaylandScale scale;
   bool fractionalScale;
   bool needsResize;
   bool configured;
   bool warpSupport;
   double cursorX, cursorY;
+  double scrollState;
 
 #if defined(ENABLE_EGL) || defined(ENABLE_OPENGL)
   struct wl_egl_window * eglWindow;
@@ -122,7 +121,8 @@ struct WaylandDSState
 
 #ifdef ENABLE_OPENGL
   EGLDisplay glDisplay;
-  EGLConfig glConfig;
+  EGLConfig  glConfig;    // primary config (best bit depth probed)
+  EGLConfig  glConfigSDR; // fallback 8-bit SDR config
   EGLSurface glSurface;
 #endif
 
@@ -172,11 +172,52 @@ struct WaylandDSState
 
   struct wp_viewporter * viewporter;
   struct wp_viewport * viewport;
+  struct wp_fractional_scale_manager_v1 * fractionalScaleManager;
+  struct wp_fractional_scale_v1 * fractionalScaleInterface;
   struct zxdg_output_manager_v1 * xdgOutputManager;
   struct wl_list outputs; // WaylandOutput::link
   struct wl_list surfaceOutputs; // SurfaceOutput::link
   bool useFractionalScale;
 
+  struct wp_content_type_manager_v1 * contentTypeManager;
+  struct wp_content_type_v1 * contentType;
+
+  // Color management (HDR)
+  struct wp_color_manager_v1                    * colorManager;
+  struct wp_color_management_surface_v1         * colorSurface;
+  struct wp_image_description_v1                * hdrImageDesc;
+  struct wp_image_description_creator_params_v1 * hdrImageCreator;
+
+  // Set to true when an HDR image description is active on the surface
+  bool hdrActive;
+
+  // wp_color_manager_v1 feature advertisement tracking.
+  // Set to true after the done event for the color-manager has been received
+  // and all compositor capabilities have been recorded.
+  bool cmFeaturesDone;
+  bool cmHasParametric;
+  bool cmHasLuminances;
+  bool cmHasMasteringPrimaries;
+  bool cmHasTFSt2084PQ;
+  bool cmHasTFExtLinear;
+  bool cmHasPrimariesBT2020;
+  bool cmHasPrimariesSRGB;
+  bool cmHasPerceptualIntent;
+  bool cmCanDoHDR;       // true if compositor supports features needed for HDR
+
+  // Pending HDR format to apply (set by frame thread, applied in swap buffers).
+  // pendingHDRApply and pendingHDRClear are accessed from multiple threads
+  // without a lock, so they must be atomic.
+  _Atomic(bool) pendingHDRApply;
+  _Atomic(bool) pendingHDRClear;
+  bool          pendingHDRPQ;
+  uint16_t      pendingHDRDisplayPrimary[3][2];
+  uint16_t      pendingHDRWhitePoint[2];
+  uint32_t      pendingHDRMaxDisplayLuminance;
+  uint32_t      pendingHDRMinDisplayLuminance;
+  uint32_t      pendingHDRMaxCLL;
+  uint32_t      pendingHDRMaxFALL;
+
   LGEvent * frameEvent;
 
   struct wl_list poll; // WaylandPoll::link
@@ -259,6 +300,24 @@ void waylandGLSetSwapInterval(int interval);
 void waylandGLSwapBuffers(void);
 #endif
 
+// HDR color management (Wayland color-management-v1)
+bool waylandColorMgmtInit(void);
+void waylandColorMgmtFree(void);
+void waylandSetHDRImageDescription(const uint16_t displayPrimary[3][2],
+    const uint16_t whitePoint[2], uint32_t maxDisplayLuminance,
+    uint32_t minDisplayLuminance, uint32_t maxCLL, uint32_t maxFALL,
+    bool hdrPQ);
+void waylandClearHDRImageDescription(void);
+
+// Queue HDR change from any thread (applied in waylandEGLSwapBuffers).
+// Returns true if the request was queued, false if HDR is not available
+// (no color manager, missing features, or unsupported TF/primaries).
+bool waylandRequestHDR(const uint16_t displayPrimary[3][2],
+    const uint16_t whitePoint[2], uint32_t maxDisplayLuminance,
+    uint32_t minDisplayLuminance, uint32_t maxCLL, uint32_t maxFALL,
+    bool hdrPQ);
+void waylandRequestClearHDR(void);
+
 // idle module
 bool waylandIdleInit(void);
 void waylandIdleFree(void);
@@ -277,13 +336,14 @@ void waylandUncapturePointer(void);
 void waylandRealignPointer(void);
 void waylandWarpPointer(int x, int y, bool exiting);
 void waylandGuestPointerUpdated(double x, double y, double localX, double localY);
+int waylandGetCharCode(int key);
 
 // output module
 bool waylandOutputInit(void);
 void waylandOutputFree(void);
 void waylandOutputBind(uint32_t name, uint32_t version);
 void waylandOutputTryUnbind(uint32_t name);
-wl_fixed_t waylandOutputGetScale(struct wl_output * output);
+struct WaylandScale waylandOutputGetScale(struct wl_output * output);
 
 // poll module
 bool waylandPollInit(void);

client/displayservers/Wayland/window.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -31,29 +31,39 @@
 
 // Surface-handling listeners.
 
-void waylandWindowUpdateScale(void)
+static void setScale(struct WaylandScale newScale)
 {
-  wl_fixed_t maxScale = 0;
+  wlWm.scale = newScale;
-  struct SurfaceOutput * node;
+  wlWm.fractionalScale = waylandScaleIsFractional(newScale);
-
-  wl_list_for_each(node, &wlWm.surfaceOutputs, link)
-  {
-    wl_fixed_t scale = waylandOutputGetScale(node->output);
-    if (scale > maxScale)
-      maxScale = scale;
-  }
-
-  if (maxScale)
-  {
-    wlWm.scale = maxScale;
-    wlWm.fractionalScale = wl_fixed_from_int(wl_fixed_to_int(maxScale)) != maxScale;
   wlWm.needsResize = true;
+
+  if (wlWm.desktop->configured())
+  {
     waylandCursorScaleChange();
     app_invalidateWindow(true);
     waylandStopWaitFrame();
   }
 }
 
+void waylandWindowUpdateScale(void)
+{
+  if (wlWm.fractionalScaleInterface)
+    return;
+
+  struct WaylandScale maxScale = waylandScaleFromInt(0);
+  struct SurfaceOutput * node;
+
+  wl_list_for_each(node, &wlWm.surfaceOutputs, link)
+  {
+    struct WaylandScale scale = waylandOutputGetScale(node->output);
+    if (waylandScaleCmp(scale, maxScale) > 0)
+      maxScale = scale;
+  }
+
+  if (waylandScaleValid(maxScale))
+    setScale(maxScale);
+}
+
 static void wlSurfaceEnterHandler(void * data, struct wl_surface * surface, struct wl_output * output)
 {
   struct SurfaceOutput * node = malloc(sizeof(*node));
@@ -85,9 +95,19 @@ static const struct wl_surface_listener wlSurfaceListener = {
   .leave = wlSurfaceLeaveHandler,
 };
 
+static void fractionalScalePreferredScale(void * data,
+    struct wp_fractional_scale_v1 * fractionalScale, uint32_t scale)
+{
+  setScale(waylandScaleFromRatio(scale, 120));
+}
+
+static const struct wp_fractional_scale_v1_listener fractionalScaleListener = {
+  .preferred_scale = fractionalScalePreferredScale,
+};
+
 bool waylandWindowInit(const char * title, const char * appId, bool fullscreen, bool maximize, bool borderless, bool resizable)
 {
-  wlWm.scale = wl_fixed_from_int(1);
+  wlWm.scale = waylandScaleFromInt(1);
 
   wlWm.frameEvent = lgCreateEvent(true, 0);
   if (!wlWm.frameEvent)
@@ -110,8 +130,23 @@ bool waylandWindowInit(const char * title, const char * appId, bool fullscreen,
     return false;
   }
 
+  if (wlWm.fractionalScaleManager)
+  {
+    wlWm.fractionalScaleInterface = wp_fractional_scale_manager_v1_get_fractional_scale(
+        wlWm.fractionalScaleManager, wlWm.surface);
+    wp_fractional_scale_v1_add_listener(wlWm.fractionalScaleInterface,
+        &fractionalScaleListener, NULL);
+  }
+  else
     wl_surface_add_listener(wlWm.surface, &wlSurfaceListener, NULL);
 
+  if (wlWm.contentTypeManager)
+  {
+    wlWm.contentType = wp_content_type_manager_v1_get_surface_content_type(
+        wlWm.contentTypeManager, wlWm.surface);
+    wp_content_type_v1_set_content_type(wlWm.contentType, WP_CONTENT_TYPE_V1_TYPE_GAME);
+  }
+
   if (!wlWm.desktop->shellInit(wlWm.display, wlWm.surface,
         title, appId, fullscreen, maximize, borderless, resizable))
     return false;
@@ -122,6 +157,10 @@ bool waylandWindowInit(const char * title, const char * appId, bool fullscreen,
 
 void waylandWindowFree(void)
 {
+  if (wlWm.fractionalScaleInterface)
+    wp_fractional_scale_v1_destroy(wlWm.fractionalScaleInterface);
+  if (wlWm.contentType)
+    wp_content_type_v1_destroy(wlWm.contentType);
   wl_surface_destroy(wlWm.surface);
   lgFreeEvent(wlWm.frameEvent);
 }

client/displayservers/X11/atoms.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/displayservers/X11/atoms.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/displayservers/X11/clipboard.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/displayservers/X11/clipboard.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/displayservers/X11/cursor.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/displayservers/X11/cursor.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/displayservers/X11/wm.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/displayservers/X11/wm/default.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/displayservers/X11/wm/i3.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/displayservers/X11/x11.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -1087,8 +1087,9 @@ static void setFocus(bool focused, double x, double y)
   app_handleFocusEvent(focused);
 }
 
-static int getCharcode(int detail)
+static int x11GetCharCode(int detail)
 {
+  detail += x11.minKeycode;
   if (detail < x11.minKeycode || detail > x11.maxKeycode)
     return 0;
 
@@ -1229,8 +1230,7 @@ static void x11XInputEvent(XGenericEventCookie *cookie)
         return;
 
       XIDeviceEvent *device = cookie->data;
-      app_handleKeyPress(device->detail - x11.minKeycode,
+      app_handleKeyPress(device->detail - x11.minKeycode);
-          getCharcode(device->detail));
 
       if (!x11.xic || !app_isOverlayMode())
         return;
@@ -1280,8 +1280,7 @@ static void x11XInputEvent(XGenericEventCookie *cookie)
         return;
 
       XIDeviceEvent *device = cookie->data;
-      app_handleKeyRelease(device->detail - x11.minKeycode,
+      app_handleKeyRelease(device->detail - x11.minKeycode);
-          getCharcode(device->detail));
 
       if (!x11.xic || !app_isOverlayMode())
         return;
@@ -1310,8 +1309,7 @@ static void x11XInputEvent(XGenericEventCookie *cookie)
         return;
 
       XIRawEvent *raw = cookie->data;
-      app_handleKeyPress(raw->detail - x11.minKeycode,
+      app_handleKeyPress(raw->detail - x11.minKeycode);
-          getCharcode(raw->detail));
       return;
     }
 
@@ -1321,8 +1319,7 @@ static void x11XInputEvent(XGenericEventCookie *cookie)
         return;
 
       XIRawEvent *raw = cookie->data;
-      app_handleKeyRelease(raw->detail - x11.minKeycode,
+      app_handleKeyRelease(raw->detail - x11.minKeycode);
-          getCharcode(raw->detail));
       return;
     }
 
@@ -2017,6 +2014,7 @@ struct LG_DisplayServerOps LGDS_X11 =
   .ungrabPointer       = x11UngrabPointer,
   .capturePointer      = x11CapturePointer,
   .uncapturePointer    = x11UncapturePointer,
+  .getCharCode         = x11GetCharCode,
   .grabKeyboard        = x11GrabKeyboard,
   .ungrabKeyboard      = x11UngrabKeyboard,
   .warpPointer         = x11WarpPointer,

client/displayservers/X11/x11.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/include/app.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -59,8 +59,8 @@ void app_handleButtonPress(int button);
 void app_handleButtonRelease(int button);
 void app_handleWheelMotion(double motion);
 void app_handleKeyboardTyped(const char * typed);
-void app_handleKeyPress(int scancode, int charcode);
+void app_handleKeyPress(int scancode);
-void app_handleKeyRelease(int scancode, int charcode);
+void app_handleKeyRelease(int scancode);
 void app_handleKeyboardModifiers(bool ctrl, bool shift, bool alt, bool super);
 void app_handleKeyboardLEDs(bool numLock, bool capsLock, bool scrollLock);
 void app_handleEnterEvent(bool entered);
@@ -72,6 +72,13 @@ void app_setFullscreen(bool fs);
 bool app_getFullscreen(void);
 bool app_getProp(LG_DSProperty prop, void * ret);
 
+/**
+ * Returns true if the last call to setHDRImageDescription() failed.
+ * When this returns true, the renderer should fall back to software
+ * tone-mapping even on a compositor that reports LG_DS_NATIVE_HDR.
+ */
+bool app_getHDRDescFailed(void);
+
 #ifdef ENABLE_EGL
 EGLDisplay app_getEGLDisplay(void);
 EGLNativeWindowType app_getEGLNativeWindow(void);

client/include/egl_dynprocs.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/include/eglutil.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/include/evdev.h

@@ -0,0 +1,51 @@
+/**
+ * Looking Glass
+ * Copyright © 2017-2026 The Looking Glass Authors
+ * https://looking-glass.io
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc., 59
+ * Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <stdbool.h>
+
+/**
+ * initialize configuration options
+ */
+void evdev_earlyInit(void);
+
+/**
+ * start the evdev layer
+ */
+bool evdev_start(void);
+
+/**
+ * stop the evdev layer
+ */
+void evdev_stop(void);
+
+/**
+ * grab the keyboard for exclusive access
+ */
+void evdev_grabKeyboard(void);
+
+/**
+ * ungrab the keyboard
+ */
+void evdev_ungrabKeyboard(void);
+
+/**
+ * returns true if input should only be processed by evdev
+ */
+bool evdev_isExclusive(void);

client/include/gl_dynprocs.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/include/interface/audiodev.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/include/interface/displayserver.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -53,6 +53,14 @@ typedef enum LG_DSProperty
    * return data type: bool
    */
   LG_DS_WARP_SUPPORT,
+
+  /**
+   * returns true if the display server supports native HDR via
+   * setHDRImageDescription (i.e., the compositor actually has the
+   * required color-management features to process HDR content).
+   * return data type: bool
+   */
+  LG_DS_NATIVE_HDR,
 }
 LG_DSProperty;
 
@@ -183,6 +191,9 @@ struct LG_DisplayServerOps
   void (*capturePointer)(void);
   void (*uncapturePointer)(void);
 
+  /* get the character code for the provided scancode */
+  int (*getCharCode)(int sc);
+
   /* exiting = true if the warp is to leave the window */
   void (*warpPointer)(int x, int y, bool exiting);
 
@@ -210,6 +221,13 @@ struct LG_DisplayServerOps
   void (*setFullscreen)(bool fs);
   void (*minimize)(void);
 
+  /* HDR color management - set display image description.
+   * Optional, if not supported set to NULL.
+   * Returns true on success, false if the description could not be applied
+   * (e.g., compositor doesn't support the required transfer function or
+   * primaries, or the image description creation failed). */
+  bool (*setHDRImageDescription)(const void * rendererFormat);
+
   /* clipboard support, optional, if not supported set to NULL */
   bool (*cbInit)(void);
   void (*cbNotice)(LG_ClipboardData type);
@@ -253,6 +271,7 @@ struct LG_DisplayServerOps
   DEBUG_ASSERT((x)->ungrabPointer      ); \
   DEBUG_ASSERT((x)->capturePointer     ); \
   DEBUG_ASSERT((x)->uncapturePointer   ); \
+  DEBUG_ASSERT((x)->getCharCode        ); \
   DEBUG_ASSERT((x)->warpPointer        ); \
   DEBUG_ASSERT((x)->realignPointer     ); \
   DEBUG_ASSERT((x)->isValidPointerPos  ); \

client/include/interface/font.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/include/interface/overlay.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/include/interface/renderer.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -84,6 +84,14 @@ typedef struct LG_RendererFormat
   unsigned int      pitch;   // scanline bytes (or compressed size)
   unsigned int      bpp;     // bits per pixel (zero if compressed)
   LG_RendererRotate rotate;  // guest rotation
+
+  // HDR static metadata (from KVMFRFrame, valid when hdr is true)
+  uint16_t hdrDisplayPrimary[3][2];
+  uint16_t hdrWhitePoint[2];
+  uint32_t hdrMaxDisplayLuminance;
+  uint32_t hdrMinDisplayLuminance;
+  uint32_t hdrMaxContentLightLevel;
+  uint32_t hdrMaxFrameAverageLightLevel;
 }
 LG_RendererFormat;
 

client/include/overlay_utils.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/include/util.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/cursor.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/cursor.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/damage.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/damage.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/desktop.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -91,6 +91,7 @@ struct EGL_Desktop
 
   // map HDR content to SDR
   bool  mapHDRtoSDR;
+  bool  nativeHDR;
   int   peakLuminance;
   int   maxCLL;
 
@@ -479,6 +480,13 @@ bool egl_desktopRender(EGL_Desktop * desktop, unsigned int outputWidth,
   EGL_Texture * texture = egl_postProcessGetOutput(desktop->pp,
       &finalSizeX, &finalSizeY);
 
+  if (unlikely(!texture))
+  {
+    texture    = tex;
+    finalSizeX = width;
+    finalSizeY = height;
+  }
+
   glBindFramebuffer(GL_FRAMEBUFFER, 0);
   egl_resetViewport(desktop->egl);
 
@@ -541,7 +549,7 @@ bool egl_desktopRender(EGL_Desktop * desktop, unsigned int outputWidth,
     {
       .type        = EGL_UNIFORM_TYPE_1I,
       .location    = shader->uCBMode,
-      .f           = { desktop->cbMode }
+      .i           = { desktop->cbMode }
     },
     {
       .type        = EGL_UNIFORM_TYPE_1I,
@@ -551,7 +559,7 @@ bool egl_desktopRender(EGL_Desktop * desktop, unsigned int outputWidth,
     {
       .type        = EGL_UNIFORM_TYPE_1I,
       .location    = shader->uMapHDRtoSDR,
-      .i           = { desktop->mapHDRtoSDR }
+      .i           = { desktop->mapHDRtoSDR && !desktop->nativeHDR }
     },
     {
       .type        = EGL_UNIFORM_TYPE_1F,
@@ -561,7 +569,7 @@ bool egl_desktopRender(EGL_Desktop * desktop, unsigned int outputWidth,
     {
       .type        = EGL_UNIFORM_TYPE_1I,
       .location    = shader->uMapHDRPQ,
-      .f           = { desktop->hdrPQ }
+      .i           = { desktop->hdrPQ }
     }
   };
 
@@ -572,6 +580,11 @@ bool egl_desktopRender(EGL_Desktop * desktop, unsigned int outputWidth,
   return true;
 }
 
+void egl_desktopSetNativeHDR(EGL_Desktop * desktop, bool nativeHDR)
+{
+  desktop->nativeHDR = nativeHDR;
+}
+
 void egl_desktopSpiceConfigure(EGL_Desktop * desktop, int width, int height)
 {
   if (!desktop->spiceTexture)

client/renderers/EGL/desktop.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -42,6 +42,7 @@ bool egl_desktopInit(EGL * egl, EGL_Desktop ** desktop, EGLDisplay * display,
 void egl_desktopFree(EGL_Desktop ** desktop);
 
 void egl_desktopConfigUI(EGL_Desktop * desktop);
+void egl_desktopSetNativeHDR(EGL_Desktop * desktop, bool nativeHDR);
 bool egl_desktopSetup (EGL_Desktop * desktop, const LG_RendererFormat format);
 bool egl_desktopUpdate(EGL_Desktop * desktop, const FrameBuffer * frame, int dmaFd,
     const FrameDamageRect * damageRects, int damageRectsCount);

client/renderers/EGL/desktop_rects.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/desktop_rects.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/egl.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -121,6 +121,9 @@ struct Inst
 
   bool showSpice;
   int  spiceWidth, spiceHeight;
+
+  bool configSupportsHDR; // true if we probed FP16 or 10-bit EGL config
+  bool hdr;               // true if current frame format is HDR
 };
 
 static struct Option egl_options[] =
@@ -607,6 +610,26 @@ static bool egl_onFrameFormat(LG_Renderer * renderer, const LG_RendererFormat fo
     egl_cursorSetScale(this->cursor, scale);
   }
 
+  // Track HDR state and warn if HDR frames arrive without any HDR path
+  this->hdr = format.hdr;
+  if (format.hdr)
+  {
+    bool nativeHDR = false;
+    app_getProp(LG_DS_NATIVE_HDR, &nativeHDR);
+    if (!this->configSupportsHDR && !nativeHDR)
+      DEBUG_WARN("HDR frames being displayed on an 8-bit EGL surface "
+          "without a color-managed compositor; tones may be incorrect");
+  }
+
+  // If the display server supports native HDR (via setHDRImageDescription),
+  // disable software tone-mapping to avoid double tone-mapping.
+  // However, if the last call to setHDRImageDescription actually failed
+  // (e.g., compositor missing required primaries), keep tone-mapping on.
+  bool nativeHDR = false;
+  app_getProp(LG_DS_NATIVE_HDR, &nativeHDR);
+  egl_desktopSetNativeHDR(this->desktop,
+      format.hdr && nativeHDR && !app_getHDRDescFailed());
+
   egl_update_scale_type(this);
   egl_damageSetup(this->damage, format.frameWidth, format.frameHeight);
 
@@ -774,22 +797,51 @@ static bool egl_renderStartup(LG_Renderer * renderer, bool useDMA)
     }
   }
 
+  // Probe for best available color depth: FP16 → 10-bit → 8-bit
+  static const struct { EGLint r, g, b, a, depth; const char * desc; } configs[] =
+  {
+    { 16, 16, 16,  0, 48, "FP16 (RGBA16F)"  },
+    { 10, 10, 10,  2, 32, "10-bit (RGBA10)" },
+    {  8,  8,  8,  0, 24, "8-bit (RGBA8)"   },
+  };
+  EGLint       num_config;
+  const char * configDesc = NULL;
+  int          chosen     = -1;
+
+  for (int i = 0; i < (int)(sizeof(configs) / sizeof(configs[0])); ++i)
+  {
     EGLint attr[] =
     {
-    EGL_BUFFER_SIZE    , 30,
+      EGL_RED_SIZE        , configs[i].r,
+      EGL_GREEN_SIZE      , configs[i].g,
+      EGL_BLUE_SIZE       , configs[i].b,
+      EGL_ALPHA_SIZE      , configs[i].a,
+      EGL_BUFFER_SIZE     , configs[i].depth,
       EGL_RENDERABLE_TYPE , EGL_OPENGL_ES2_BIT,
       EGL_SAMPLE_BUFFERS  , maxSamples > 0 ? 1 : 0,
       EGL_SAMPLES         , maxSamples,
       EGL_NONE
     };
 
-  EGLint num_config;
+    if (eglChooseConfig(this->display, attr, &this->configs, 1, &num_config) &&
-  if (!eglChooseConfig(this->display, attr, &this->configs, 1, &num_config))
+        num_config > 0)
     {
-    DEBUG_ERROR("Failed to choose config (eglError: 0x%x)", eglGetError());
+      configDesc = configs[i].desc;
+      chosen     = i;
+      break;
+    }
+  }
+
+  if (chosen < 0)
+  {
+    DEBUG_ERROR("Failed to choose any EGL config");
     return false;
   }
 
+  this->configSupportsHDR = chosen <= 1; // FP16 or 10-bit
+  DEBUG_INFO("EGL config: %s%s", configDesc,
+      this->configSupportsHDR ? " (HDR capable)" : "");
+
   const EGLint surfattr[] =
   {
     EGL_RENDER_BUFFER, this->opt.doubleBuffer ? EGL_BACK_BUFFER : EGL_SINGLE_BUFFER,

client/renderers/EGL/egl.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/egldebug.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/egldebug.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/egltypes.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/ffx.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/ffx.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/filter.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/filter.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/filter_24bit.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/filter_downscale.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/filter_ffx_cas.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/filter_ffx_fsr1.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/filters.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/framebuffer.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/framebuffer.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/model.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/model.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/postprocess.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/postprocess.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/shader.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/shader.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/shader/convert_24bit.frag

@@ -2,6 +2,7 @@
 #extension GL_OES_EGL_image_external_essl3 : enable
 
 precision highp float;
+precision highp int;
 
 in  vec2  fragCoord;
 out vec4  fragColor;

client/renderers/EGL/shader/cursor_mono.frag

@@ -1,5 +1,6 @@
 #version 300 es
 precision highp float;
+precision highp int;
 
 in  vec2 uv;
 out vec4 color;

client/renderers/EGL/shader/cursor_rgb.frag

@@ -1,5 +1,6 @@
 #version 300 es
 precision highp float;
+precision highp int;
 
 #include "color_blind.h"
 

client/renderers/EGL/shader/damage.frag

@@ -1,5 +1,6 @@
 #version 300 es
 precision highp float;
+precision highp int;
 
 out vec4 color;
 

client/renderers/EGL/shader/desktop_rgb.frag

@@ -2,6 +2,7 @@
 #extension GL_OES_EGL_image_external_essl3 : enable
 
 precision highp float;
+precision highp int;
 
 #define EGL_SCALE_AUTO    0
 #define EGL_SCALE_NEAREST 1

client/renderers/EGL/shader/downscale.frag

@@ -2,6 +2,7 @@
 #extension GL_OES_EGL_image_external_essl3 : enable
 
 precision highp float;
+precision highp int;
 
 in  vec2  fragCoord;
 out vec4  fragColor;

client/renderers/EGL/shader/downscale_lanczos2.frag

@@ -2,6 +2,7 @@
 #extension GL_OES_EGL_image_external_essl3 : enable
 
 precision highp float;
+precision highp int;
 
 #define PI 3.141592653589793
 

client/renderers/EGL/shader/downscale_linear.frag

@@ -2,6 +2,7 @@
 #extension GL_OES_EGL_image_external_essl3 : enable
 
 precision highp float;
+precision highp int;
 
 in  vec2  fragCoord;
 out vec4  fragColor;

client/renderers/EGL/shader/ffx_cas.frag

@@ -2,6 +2,7 @@
 #extension GL_OES_EGL_image_external_essl3 : enable
 
 precision highp float;
+precision highp int;
 
 #include "compat.h"
 

client/renderers/EGL/shader/ffx_fsr1_easu.frag

@@ -2,6 +2,7 @@
 #extension GL_OES_EGL_image_external_essl3 : enable
 
 precision highp float;
+precision highp int;
 
 #include "compat.h"
 

client/renderers/EGL/shader/ffx_fsr1_rcas.frag

@@ -1,5 +1,6 @@
 #version 300 es
 precision highp float;
+precision highp int;
 
 #include "compat.h"
 

client/renderers/EGL/texture.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/texture.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/texture_buffer.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -255,7 +255,6 @@ EGL_TexStatus egl_texBufferStreamProcess(EGL_Texture * texture)
     glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
 
     this->sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
-    glFlush();
   }
 
   return EGL_TEX_STATUS_OK;
@@ -271,7 +270,8 @@ EGL_TexStatus egl_texBufferStreamGet(EGL_Texture * texture, GLuint * tex,
 
   if (this->sync)
   {
-    switch(glClientWaitSync(this->sync, 0, 40000000)) // 40ms
+    switch(glClientWaitSync(
+          this->sync, GL_SYNC_FLUSH_COMMANDS_BIT, 40000000)) //40ms
     {
       case GL_ALREADY_SIGNALED:
       case GL_CONDITION_SATISFIED:

client/renderers/EGL/texture_buffer.h

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it

client/renderers/EGL/texture_dmabuf.c

@@ -1,6 +1,6 @@
 /**
  * Looking Glass
- * Copyright © 2017-2025 The Looking Glass Authors
+ * Copyright © 2017-2026 The Looking Glass Authors
  * https://looking-glass.io
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -22,7 +22,7 @@
 #include "texture_buffer.h"
 #include "util.h"
 
-#include "common/vector.h"
+#include "common/array.h"
 #include "egl_dynprocs.h"
 #include "egldebug.h"
 
@@ -30,6 +30,8 @@ struct FdImage
 {
   int fd;
   EGLImage image;
+  GLsync   sync;
+  int      texIndex;
 };
 
 typedef struct TexDMABUF
@@ -37,7 +39,9 @@ typedef struct TexDMABUF
   TextureBuffer base;
 
   EGLDisplay display;
-  Vector images;
+
+  struct FdImage images[2];
+  int            lastIndex;
 
   EGL_PixelFormat pixFmt;
   unsigned        fourcc;
@@ -59,21 +63,26 @@ static void egl_texDMABUFCleanup(EGL_Texture * texture)
   TextureBuffer * parent = UPCAST(TextureBuffer, texture);
   TexDMABUF     * this   = UPCAST(TexDMABUF    , parent);
 
-  struct FdImage * image;
+  for(int i = 0; i < ARRAY_LENGTH(this->images); ++i)
-  vector_forEachRef(image, &this->images)
+  {
-    g_egl_dynProcs.eglDestroyImage(this->display, image->image);
+    if (this->images[i].image != EGL_NO_IMAGE)
-  vector_clear(&this->images);
+    {
+      g_egl_dynProcs.eglDestroyImage(this->display, this->images[i].image);
+      this->images[i].image = EGL_NO_IMAGE;
+    }
+    if (this->images[i].sync)
+    {
+      glDeleteSync(this->images[i].sync);
+      this->images[i].sync = 0;
+    }
+    this->images[i].fd       = -1;
+    this->images[i].texIndex = -1;
+  }
 
   egl_texUtilFreeBuffers(parent->buf, parent->texCount);
 
   if (parent->tex[0])
     glDeleteTextures(parent->texCount, parent->tex);
-
-  if (parent->sync)
-  {
-    glDeleteSync(parent->sync);
-    parent->sync = 0;
-  }
 }
 
 // dmabuf functions
@@ -84,17 +93,18 @@ static bool egl_texDMABUFInit(EGL_Texture ** texture, EGL_TexType type,
   TexDMABUF * this = calloc(1, sizeof(*this));
   *texture = &this->base.base;
 
-  if (!vector_create(&this->images, sizeof(struct FdImage), 2))
+  for(int i = 0; i < ARRAY_LENGTH(this->images); ++i)
   {
-    free(this);
+    this->images[i].fd       = -1;
-    *texture = NULL;
+    this->images[i].image    = EGL_NO_IMAGE;
-    return false;
+    this->images[i].sync     = 0;
+    this->images[i].texIndex = -1;
   }
+  this->lastIndex = -1;
 
   EGL_Texture * parent = &this->base.base;
   if (!egl_texBufferStreamInit(&parent, type, display))
   {
-    vector_destroy(&this->images);
     free(this);
     *texture = NULL;
     return false;
@@ -119,8 +129,6 @@ static void egl_texDMABUFFree(EGL_Texture * texture)
   TexDMABUF     * this   = UPCAST(TexDMABUF    , parent);
 
   egl_texDMABUFCleanup(texture);
-  vector_destroy(&this->images);
-
   egl_texBufferFree(&parent->base);
   free(this);
 }
@@ -141,22 +149,8 @@ static bool texDMABUFSetup(EGL_Texture * texture)
   egl_texDMABUFCleanup(texture);
 
   glGenTextures(parent->texCount, parent->tex);
-  for(int i = 0; i < parent->texCount; ++i)
-  {
-    glBindTexture(GL_TEXTURE_EXTERNAL_OES, parent->tex[i]);
-    glTexImage2D(GL_TEXTURE_EXTERNAL_OES,
-        0,
-        texture->format.intFormat,
-        this->width,
-        texture->format.height,
-        0,
-        this->format,
-        texture->format.dataType,
-        NULL);
-  }
-
-  glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
   parent->rIndex = -1;
+
   return true;
 }
 
@@ -212,16 +206,12 @@ static bool egl_texDMABUFUpdate(EGL_Texture * texture,
 
   DEBUG_ASSERT(update->type == EGL_TEXTYPE_DMABUF);
 
-  EGLImage image = EGL_NO_IMAGE;
+  struct FdImage *fdImage =
-
+    (this->images[0].fd == update->dmaFD) ? &this->images[0] :
-  struct FdImage * fdImage;
+    (this->images[1].fd == update->dmaFD) ? &this->images[1] :
-  vector_forEachRef(fdImage, &this->images)
+    (this->images[0].fd == -1)            ? &this->images[0] :
-    if (fdImage->fd == update->dmaFD)
+                                            &this->images[1];
-    {
+  EGLImage image = fdImage->image;
-      image = fdImage->image;
-      break;
-    }
-
   if (unlikely(image == EGL_NO_IMAGE))
   {
     bool setup = false;
@@ -248,28 +238,31 @@ static bool egl_texDMABUFUpdate(EGL_Texture * texture,
       return false;
     }
 
-    if (unlikely(!vector_push(&this->images, &(struct FdImage) {
+    fdImage->fd    = update->dmaFD;
-      .fd    = update->dmaFD,
+    fdImage->image = image;
-      .image = image,
-    })))
-    {
-      DEBUG_ERROR("Failed to store EGLImage");
-      g_egl_dynProcs.eglDestroyImage(this->display, image);
-      return false;
-    }
-  }
 
+    int slot = (fdImage == &this->images[0]) ? 0 : 1;
+    fdImage->texIndex = slot;
     INTERLOCKED_SECTION(parent->copyLock,
     {
-    glBindTexture(GL_TEXTURE_EXTERNAL_OES, parent->tex[parent->bufIndex]);
+      glBindTexture(GL_TEXTURE_EXTERNAL_OES, parent->tex[slot]);
-    g_egl_dynProcs.glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, image);
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    if (likely(parent->sync))
+      glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-      glDeleteSync(parent->sync);
+      glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-
+      g_egl_dynProcs.glEGLImageTargetTexture2DOES(
-    parent->sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
+          GL_TEXTURE_EXTERNAL_OES, image);
     });
-  glFlush();
+  }
+
+  this->lastIndex = (fdImage == &this->images[0]) ? 0 : 1;
+  INTERLOCKED_SECTION(parent->copyLock,
+  {
+    if (fdImage->sync)
+      glDeleteSync(fdImage->sync);
+    fdImage->sync = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
+  });
+
   return true;
 }
 
@@ -284,23 +277,22 @@ static EGL_TexStatus egl_texDMABUFGet(EGL_Texture * texture, GLuint * tex,
   TextureBuffer * parent = UPCAST(TextureBuffer, texture);
   TexDMABUF     * this   = UPCAST(TexDMABUF    , parent);
 
+  if (unlikely(this->lastIndex < 0))
+    return EGL_TEX_STATUS_NOTREADY;
+
+  struct FdImage *cur = &this->images[this->lastIndex];
   GLsync sync = 0;
 
-  INTERLOCKED_SECTION(parent->copyLock,
+  INTERLOCKED_SECTION(parent->copyLock, {
-  {
+    if (cur->sync) {
-    if (parent->sync)
+      sync = cur->sync;
-    {
+      cur->sync = 0;
-      sync           = parent->sync;
-      parent->sync   = 0;
-      parent->rIndex = parent->bufIndex;
-      if (++parent->bufIndex == parent->texCount)
-        parent->bufIndex = 0;
     }
   });
 
   if (sync)
   {
-    switch(glClientWaitSync(sync, 0, 20000000)) // 20ms
+    switch (glClientWaitSync(sync, GL_SYNC_FLUSH_COMMANDS_BIT, 20000000)) //20ms
     {
       case GL_ALREADY_SIGNALED:
       case GL_CONDITION_SATISFIED:
@@ -308,10 +300,11 @@ static EGL_TexStatus egl_texDMABUFGet(EGL_Texture * texture, GLuint * tex,
         break;
 
       case GL_TIMEOUT_EXPIRED:
+        // Put it back for next try
         INTERLOCKED_SECTION(parent->copyLock,
         {
-          if (!parent->sync)
+          if (!cur->sync)
-            parent->sync = sync;
+            cur->sync = sync;
           else
             glDeleteSync(sync);
         });
@@ -325,7 +318,7 @@ static EGL_TexStatus egl_texDMABUFGet(EGL_Texture * texture, GLuint * tex,
     }
   }
 
-  *tex = parent->tex[parent->rIndex];
+  *tex = parent->tex[cur->texIndex];
 
   if (fmt)
     *fmt = this->pixFmt;