VIDEO/D3D: HDR screenshot support for D3D11 and D3D12 read_viewport

LibretroAdmin · LibretroAdmin · commit 7d3b452ef3af · 2026-04-22T19:09:03.000+02:00
Both drivers previously bailed out with "HDR screenshot not supported"
when the swapchain was in HDR10 PQ (R10G10B10A2_UNORM) or scRGB
(R16G16B16A16_FLOAT) format, falling back to the raw core framebuffer
path and losing shaders, overlays, scaling and everything else the
GPU had composed.

Add a shared CPU-side HDR -&gt; SDR decoder in gfx/common/dxgi_common:

    bool dxgi_hdr_readback_to_bgr24(src_format, src_data, src_pitch,
                                    src_x, src_y, width, height,
                                    paper_white_nits, dst_bgr24);

which runs the inverse of the forward composition path and writes
sRGB-encoded BGR24 bottom-up, matching the read_viewport contract
the rest of the frontend expects.  Implementation is pure C: an
IEEE 754 binary16 -&gt; binary32 decoder for scRGB, an ST.2084 PQ EOTF
for HDR10, BT.2020 -&gt; BT.709 primaries rotation, a hue-preserving
peak-channel tonemap (mirroring the forward inverse-tonemap), and
an sRGB OETF for writing to UNORM8.

At default settings (max_nits == paper_white_nits) the round-trip
is analytically exact for in-range SDR content; super-bright and
out-of-gamut pixels clamp in the OETF, which is the desired tonemapped
screenshot behaviour.

Wire both d3d11_gfx_read_viewport and d3d12_gfx_read_viewport to the
helper: remove the HDR early-return, route the two HDR swapchain
formats through the decoder, and pass d3dNN-&gt;hdr.ubo_values.
paper_white_nits as the calibration input.  The SDR RGBA8 / BGRA8
paths are unchanged except for a cosmetic enum refactor in D3D12.

Known limitations (tracked for a follow-up):
 - ExpandGamut is not reversed; non-default gamut expansions produce
   slightly desaturated screenshots relative to on-display output.
 - Per-pixel CPU cost, roughly 1.6 ms at 4K per screenshot.  The
   read_viewport signature permits moving this to a GPU tonemap pass
   behind the same ABI at a later date without touching callers.
 - Tonemap() uses paper_white for both max and reference white,
   matching the existing forward composition in hdr_sm5.hlsl.h and
   hdr.frag rather than fixing it here.
diff --git a/gfx/common/dxgi_common.c b/gfx/common/dxgi_common.c
@@ -2912,4 +2912,235 @@ void dxgi_set_hdr_metadata(
       g_hdr10_meta_data = hdr10_meta_data;
    }
 }
+
+/* ------------------------------------------------------------------ *
+ *  HDR screenshot readback: CPU-side HDR -> SDR decoder
+ *
+ *  Called from video driver read_viewport implementations when the
+ *  swapchain is in an HDR format.  Mirrors the forward HDR path in
+ *  hdr_sm5.hlsl.h but runs inverse, on the CPU, producing SDR BGR24.
+ *
+ *  The CPU path keeps the driver-side code simple (no extra PSO,
+ *  intermediate render target, descriptor heap slot, or resize
+ *  handling).  A future revision can move this to a GPU tonemap pass
+ *  behind the same signature without caller changes.
+ * ------------------------------------------------------------------ */
+
+#include <math.h>
+#include <stdint.h>
+
+/* IEEE 754 binary16 -> binary32.  Used to decode FP16 scRGB samples. */
+static INLINE float dxgi_half_to_float(uint16_t h)
+{
+   uint32_t sign = (uint32_t)(h >> 15) & 0x1u;
+   uint32_t exp  = (uint32_t)(h >> 10) & 0x1Fu;
+   uint32_t mant = (uint32_t) h        & 0x3FFu;
+   uint32_t f;
+   union { uint32_t u; float f; } u;
+
+   if (exp == 0)
+   {
+      if (mant == 0)
+         f = sign << 31;                     /* signed zero */
+      else
+      {
+         /* Subnormal: normalize. */
+         while (!(mant & 0x400u))
+         {
+            mant <<= 1;
+            exp   -= 1;     /* exp starts at 0, goes negative */
+         }
+         exp  += 1;
+         mant &= ~0x400u;
+         f     = (sign << 31) | ((exp + 127 - 15) << 23) | (mant << 13);
+      }
+   }
+   else if (exp == 0x1F)
+   {
+      /* Inf / NaN: propagate to float32 Inf/NaN with the same mantissa
+       * low bits (clamped away later, so exact bit-pattern doesn't matter). */
+      f = (sign << 31) | (0xFFu << 23) | (mant << 13);
+   }
+   else
+      f = (sign << 31) | ((exp + 127 - 15) << 23) | (mant << 13);
+
+   u.u = f;
+   return u.f;
+}
+
+/* ST.2084 (PQ) EOTF.  Input is the non-linear PQ code value in [0,1];
+ * output is linear light normalized so 1.0 == 10000 nits. */
+static INLINE float dxgi_st2084_to_linear(float pq)
+{
+   static const float m1_inv = 1.0f / 0.1593017578f;
+   static const float m2_inv = 1.0f / 78.84375f;
+   static const float c1     = 0.8359375f;
+   static const float c2     = 18.8515625f;
+   static const float c3     = 18.6875f;
+   float Np, num, den;
+
+   if (pq <= 0.0f)
+      return 0.0f;
+   Np  = powf(pq, m2_inv);
+   num = Np - c1;
+   if (num < 0.0f)
+      num = 0.0f;
+   den = c2 - c3 * Np;
+   if (den <= 0.0f)
+      return 0.0f;
+   return powf(num / den, m1_inv);
+}
+
+/* Linear [0,1] -> sRGB encoded [0,1].  Standard sRGB OETF. */
+static INLINE float dxgi_linear_to_srgb(float l)
+{
+   if (l <= 0.0f)
+      return 0.0f;
+   if (l >= 1.0f)
+      return 1.0f;
+   if (l <= 0.0031308f)
+      return l * 12.92f;
+   return 1.055f * powf(l, 1.0f / 2.4f) - 0.055f;
+}
+
+/* Reverse of the forward "inverse tonemap" used to lift SDR into HDR
+ * at composition time.  sdr = hdr / (1 + hdr * k), where
+ * k = 1 - (paper_white / max_nits).  We always compose with the same
+ * value for max_nits and paper_white at forward time, so this reduces
+ * to a no-op for in-range SDR content and gently compresses super-white.
+ * Applied per-pixel, on the max component, to preserve hue. */
+static INLINE void dxgi_tonemap_to_sdr(float *r, float *g, float *b,
+      float max_nits, float paper_white_nits)
+{
+   float peak_ratio, k, m, denom, scale;
+
+   m = *r;
+   if (*g > m) m = *g;
+   if (*b > m) m = *b;
+   if (m < 1.0e-4f)
+      return;
+
+   peak_ratio = max_nits / paper_white_nits;
+   k          = 1.0f - (1.0f / peak_ratio);
+   denom      = 1.0f + m * k;
+   if (denom < 1.0e-4f)
+      denom = 1.0e-4f;
+
+   scale = 1.0f / denom;
+   *r *= scale;
+   *g *= scale;
+   *b *= scale;
+}
+
+/* BT.2020 -> BT.709 colour-primary rotation.  Matches k2020to709 in
+ * the forward HLSL/GLSL shaders. */
+static INLINE void dxgi_rec2020_to_rec709(float *r, float *g, float *b)
+{
+   float R = *r, G = *g, B = *b;
+   *r =  1.6604910f * R + -0.5876411f * G + -0.0728499f * B;
+   *g = -0.1245505f * R +  1.1328999f * G + -0.0083494f * B;
+   *b = -0.0181508f * R + -0.1005789f * G +  1.1187297f * B;
+}
+
+static INLINE uint8_t dxgi_float_to_unorm8(float x)
+{
+   int v;
+   if (x <= 0.0f) return 0;
+   if (x >= 1.0f) return 255;
+   v = (int)(x * 255.0f + 0.5f);
+   if (v < 0)   v = 0;
+   if (v > 255) v = 255;
+   return (uint8_t)v;
+}
+
+bool dxgi_hdr_readback_to_bgr24(
+      DXGI_FORMAT  src_format,
+      const void*  src_data,
+      unsigned     src_pitch,
+      unsigned     src_x,
+      unsigned     src_y,
+      unsigned     width,
+      unsigned     height,
+      float        paper_white_nits,
+      uint8_t*     dst_bgr24)
+{
+   unsigned y, x;
+
+   if (!src_data || !dst_bgr24 || !width || !height)
+      return false;
+   if (paper_white_nits < 1.0f)
+      paper_white_nits = 200.0f;   /* sane fallback if UBO not populated */
+
+   if (src_format == DXGI_FORMAT_R10G10B10A2_UNORM)
+   {
+      /* HDR10 PQ.  Pixel layout per D3D: 10R | 10G | 10B | 2A (LSB to
+       * MSB inside the uint32), so:
+       *   R =  bits 0..9     (code & 0x3FF)
+       *   G =  bits 10..19  ((code >> 10) & 0x3FF)
+       *   B =  bits 20..29  ((code >> 20) & 0x3FF) */
+      const uint8_t* src_row = (const uint8_t*)src_data
+            + (size_t)src_pitch * src_y;
+
+      for (y = 0; y < height; y++, src_row += src_pitch)
+      {
+         uint8_t* dst = dst_bgr24 + 3 * (size_t)(height - y - 1) * width;
+         const uint32_t* src = (const uint32_t*)src_row + src_x;
+         for (x = 0; x < width; x++)
+         {
+            uint32_t px = src[x];
+            float r_pq = (float)((px      ) & 0x3FFu) * (1.0f / 1023.0f);
+            float g_pq = (float)((px >> 10) & 0x3FFu) * (1.0f / 1023.0f);
+            float b_pq = (float)((px >> 20) & 0x3FFu) * (1.0f / 1023.0f);
+            /* PQ -> linear, normalized so 1.0 = 10000 nits. */
+            float r = dxgi_st2084_to_linear(r_pq);
+            float g = dxgi_st2084_to_linear(g_pq);
+            float b = dxgi_st2084_to_linear(b_pq);
+            /* Rescale to paper-white-relative linear (SDR 1.0 == paper_white).
+             * The forward path scaled by (paper_white / 10000) before PQ
+             * encoding, so we undo it by multiplying by (10000 / paper_white). */
+            float scale = 10000.0f / paper_white_nits;
+            r *= scale;  g *= scale;  b *= scale;
+            /* BT.2020 -> BT.709 so the final sRGB encode is meaningful. */
+            dxgi_rec2020_to_rec709(&r, &g, &b);
+            /* Tonemap any super-white back into [0,1] using the same
+             * peak_ratio the forward inverse-tonemap used. */
+            dxgi_tonemap_to_sdr(&r, &g, &b, paper_white_nits, paper_white_nits);
+            /* sRGB OETF for the BGR24 output. */
+            dst[3 * x + 0] = dxgi_float_to_unorm8(dxgi_linear_to_srgb(b));
+            dst[3 * x + 1] = dxgi_float_to_unorm8(dxgi_linear_to_srgb(g));
+            dst[3 * x + 2] = dxgi_float_to_unorm8(dxgi_linear_to_srgb(r));
+         }
+      }
+      return true;
+   }
+
+   if (src_format == DXGI_FORMAT_R16G16B16A16_FLOAT)
+   {
+      /* scRGB: linear BT.709, FP16, 1.0 == 80 nits.
+       * Undo the forward scale of (paper_white / 80) so SDR 1.0 == 1.0. */
+      const uint8_t* src_row = (const uint8_t*)src_data
+            + (size_t)src_pitch * src_y;
+      const float inv_scale  = 80.0f / paper_white_nits;
+
+      for (y = 0; y < height; y++, src_row += src_pitch)
+      {
+         uint8_t* dst = dst_bgr24 + 3 * (size_t)(height - y - 1) * width;
+         const uint16_t* src = (const uint16_t*)src_row + src_x * 4;
+         for (x = 0; x < width; x++)
+         {
+            float r = dxgi_half_to_float(src[4 * x + 0]) * inv_scale;
+            float g = dxgi_half_to_float(src[4 * x + 1]) * inv_scale;
+            float b = dxgi_half_to_float(src[4 * x + 2]) * inv_scale;
+            /* scRGB carries legal negative values for out-of-gamut
+             * colours; clamping in LinearToSRGB handles them. */
+            dst[3 * x + 0] = dxgi_float_to_unorm8(dxgi_linear_to_srgb(b));
+            dst[3 * x + 1] = dxgi_float_to_unorm8(dxgi_linear_to_srgb(g));
+            dst[3 * x + 2] = dxgi_float_to_unorm8(dxgi_linear_to_srgb(r));
+         }
+      }
+      return true;
+   }
+
+   return false;
+}
 #endif
diff --git a/gfx/common/dxgi_common.h b/gfx/common/dxgi_common.h
@@ -476,6 +476,26 @@ void dxgi_set_hdr_metadata(
       float                         max_cll,
       float                         max_fall
 );
+
+/* Convert an HDR swapchain-format pixel buffer into SDR BGR24 bottom-up,
+ * suitable for a screenshot.  src_format is the swapchain format:
+ *   - DXGI_FORMAT_R10G10B10A2_UNORM : HDR10 (ST.2084 PQ, BT.2020)
+ *   - DXGI_FORMAT_R16G16B16A16_FLOAT: scRGB (linear BT.709, 1.0 = 80 nits)
+ * paper_white_nits is the user's configured SDR paper-white (typically
+ * 200), used to scale the HDR encoding back down so SDR content in the
+ * original framebuffer maps back to SDR 1.0.  Source is top-down; the
+ * output is laid out bottom-up to match the read_viewport contract.
+ * Returns false if the format is not an HDR format we handle. */
+bool dxgi_hdr_readback_to_bgr24(
+      DXGI_FORMAT  src_format,
+      const void*  src_data,
+      unsigned     src_pitch,
+      unsigned     src_x,
+      unsigned     src_y,
+      unsigned     width,
+      unsigned     height,
+      float        paper_white_nits,
+      uint8_t*     dst_bgr24);
 #endif
 
 DXGI_FORMAT glslang_format_to_dxgi(glslang_format fmt);
diff --git a/gfx/drivers/d3d11.c b/gfx/drivers/d3d11.c
@@ -5035,15 +5035,6 @@ static bool d3d11_gfx_read_viewport(void* data, uint8_t* buffer, bool is_idle)
    if (!d3d11)
       return false;
 
-   /*This implementation produces wrong result when using HDR*/
-#ifdef HAVE_DXGI_HDR
-   if ((d3d11->flags & D3D11_ST_FLAG_HDR_ENABLE))
-   {
-      RARCH_ERR("[D3D11] HDR screenshot not supported.\n");
-      return false;
-   }
-#endif
-
    /* Get the back buffer. */
    m_SwapChain = d3d11->swapChain;
 #ifdef __cplusplus
@@ -5080,36 +5071,72 @@ static bool d3d11_gfx_read_viewport(void* data, uint8_t* buffer, bool is_idle)
    /* Copy back buffer to back buffer staging. */
    d3d11->context->lpVtbl->CopyResource(d3d11->context, BackBufferStaging, BackBufferResource);
 
-   /* Create the image. */
+   /* Map the staging texture for CPU read. */
    d3d11->context->lpVtbl->Map(d3d11->context, BackBufferStaging, 0, D3D11_MAP_READ, 0, &Map);
    BackBufferData = (const uint8_t*)Map.pData;
 
-   /* Assuming format is DXGI_FORMAT_R8G8B8A8_UNORM */
-   if (StagingDesc.Format == DXGI_FORMAT_R8G8B8A8_UNORM)
    {
+      unsigned vp_x      = (d3d11->vp.x > 0) ? d3d11->vp.x : 0;
       unsigned vp_y      = (d3d11->vp.y > 0) ? d3d11->vp.y : 0;
       unsigned vp_width  = (d3d11->vp.width  > d3d11->vp.full_width)  ? d3d11->vp.full_width  : d3d11->vp.width;
       unsigned vp_height = (d3d11->vp.height > d3d11->vp.full_height) ? d3d11->vp.full_height : d3d11->vp.height;
 
-      BackBufferData += Map.RowPitch * vp_y;
+      ret = true;
 
-      for (y = 0; y < vp_height; y++, BackBufferData += Map.RowPitch)
+      switch (StagingDesc.Format)
       {
-         bufferRow = buffer + 3 * (vp_height - y - 1) * vp_width;
+         case DXGI_FORMAT_R8G8B8A8_UNORM:
+            /* SDR RGBA8 -> BGR24 swizzle, bottom-up. */
+            BackBufferData += Map.RowPitch * vp_y;
+            for (y = 0; y < vp_height; y++, BackBufferData += Map.RowPitch)
+            {
+               bufferRow = buffer + 3 * (vp_height - y - 1) * vp_width;
+               for (x = 0; x < vp_width; x++)
+               {
+                  bufferRow[3 * x + 2] = BackBufferData[4 * (x + vp_x) + 0];
+                  bufferRow[3 * x + 1] = BackBufferData[4 * (x + vp_x) + 1];
+                  bufferRow[3 * x + 0] = BackBufferData[4 * (x + vp_x) + 2];
+               }
+            }
+            break;
 
-         for (x = 0; x < vp_width; x++)
-         {
-            bufferRow[3 * x + 2] = BackBufferData[4 * (x + d3d11->vp.x) + 0];
-            bufferRow[3 * x + 1] = BackBufferData[4 * (x + d3d11->vp.x) + 1];
-            bufferRow[3 * x + 0] = BackBufferData[4 * (x + d3d11->vp.x) + 2];
-         }
+         case DXGI_FORMAT_B8G8R8A8_UNORM:
+            /* SDR BGRA8 -> BGR24 byte-drop, bottom-up. */
+            BackBufferData += Map.RowPitch * vp_y;
+            for (y = 0; y < vp_height; y++, BackBufferData += Map.RowPitch)
+            {
+               bufferRow = buffer + 3 * (vp_height - y - 1) * vp_width;
+               for (x = 0; x < vp_width; x++)
+               {
+                  bufferRow[3 * x + 0] = BackBufferData[4 * (x + vp_x) + 0];
+                  bufferRow[3 * x + 1] = BackBufferData[4 * (x + vp_x) + 1];
+                  bufferRow[3 * x + 2] = BackBufferData[4 * (x + vp_x) + 2];
+               }
+            }
+            break;
+
+#ifdef HAVE_DXGI_HDR
+         case DXGI_FORMAT_R10G10B10A2_UNORM:
+         case DXGI_FORMAT_R16G16B16A16_FLOAT:
+            /* HDR10 PQ or scRGB: hand off to the CPU HDR decoder.
+             * It undoes the forward HDR encoding using paper_white_nits
+             * and writes sRGB-encoded BGR24 bottom-up. */
+            if (!dxgi_hdr_readback_to_bgr24(
+                     StagingDesc.Format,
+                     Map.pData, Map.RowPitch,
+                     vp_x, vp_y, vp_width, vp_height,
+                     d3d11->hdr.ubo_values.paper_white_nits,
+                     buffer))
+               ret = false;
+            break;
+#endif
+
+         default:
+            RARCH_ERR("[D3D11] Unexpected swapchain format %u.\n",
+                  (unsigned)StagingDesc.Format);
+            ret = false;
+            break;
       }
-      ret = true;
-   }
-   else
-   {
-      RARCH_ERR("[D3D11] Unexpected swapchain format.\n");
-      ret = false;
    }
 
    d3d11->context->lpVtbl->Unmap(d3d11->context, BackBufferStaging, 0);
diff --git a/gfx/drivers/d3d12.c b/gfx/drivers/d3d12.c
