VIDEO/VULKAN: Fix black GPU screenshots when HDR is enabled

When 'Screenshot: Use GPU' was enabled with the Vulkan driver and HDR
active, the resulting PNG was entirely black on both scRGB (FP16) and
HDR10 (RGB10A2 PQ) swapchains.

Two compounding issues in the HDR readback path:

1. gfx/drivers/vulkan.c hardcoded hdr_mode = 0 on the hdr_to_sdr
   pipeline call. In vulkan_run_hdr_pipeline() that falls into the
   legacy HDR10 branch (InverseTonemap = 1, HDR10 = 1). With an scRGB
   backbuffer the shader then ran HDR10ToLinear() — ST.2084 decode —
   on values that were never PQ-encoded, collapsing output to ~0.

   Pass the actual encoding instead: 2 for scRGB, 1 for HDR10. Also
   add an explicit COLOR_ATTACHMENT_WRITE -> TRANSFER_READ memory
   barrier between the tonemap render pass and vkCmdCopyImageToBuffer.
   The readback render pass has dependencyCount = 0, so its implicit
   finalLayout transition does not carry a memory-availability
   guarantee on its own.

2. gfx/drivers/vulkan_shaders/hdr_tonemap.frag called Tonemap(linear)
   with one argument while the helper in hdr_common.glsl takes three
   (hdr_linear, max_nits, paper_white_nits). The checked-in
   hdr_tonemap.frag.inc was therefore stale SPIR-V from an older
   single-argument signature, so the HDR10 readback path was also
   broken independently of the scRGB issue.

   Rewrite the shader to branch on HDRMode:
     - Mode 1 (HDR10 PQ): HDR10ToLinear -> Tonemap() back to SDR
       using paper_white_nits for both arguments (matching the
       forward pass).
     - Mode 2 (scRGB):    divide by (BrightnessNits / 80) to undo
       the scRGB nit scaling so SDR paper-white maps back to 1.0.

   Apply the sRGB OETF before writing in both cases — the readback
   target is B8G8R8A8_UNORM, not _SRGB, so without encoding the saved
   PNG would be too dark in any standard sRGB viewer.

Regenerate hdr_tonemap.frag.inc from the new source.

Fixes #14147

Author: LibretroAdmin

gfx/drivers/vulkan.c

@@ -6901,6 +6901,15 @@ static bool vulkan_frame(void *data, const void *frame,
          struct vk_image* readback_source = backbuffer;
          if((vk->context->flags & VK_CTX_FLAG_HDR_ENABLE))
          {
+            /* Select the inverse conversion the shader should apply.
+             * The backbuffer is in one of two HDR encodings:
+             *   - scRGB (FP16 linear, 1.0 = 80 nits)    -> pass mode 2
+             *   - HDR10 (RGB10A2 PQ, BT.2020)           -> pass mode 1
+             * The readback target is B8G8R8A8_UNORM, so the shader
+             * converts back to SDR and writes sRGB-encoded bytes.
+             * Modes here mirror the forward pipeline naming. */
+            unsigned readback_hdr_mode =
+                  (vk->context->flags & VK_CTX_FLAG_HDR_SCRGB) ? 2 : 1;
             {
                /* Prepare backbuffer for reading */
                backbuffer_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
@@ -6910,7 +6919,26 @@ static bool vulkan_frame(void *data, const void *frame,
                   VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
                   VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
             }
-            vulkan_run_hdr_pipeline(vk->pipelines.hdr_to_sdr, vk->readback_render_pass, readback_source, &vk->readback_image, vk, &vk->hdr.ubo, 0, false);
+            vulkan_run_hdr_pipeline(vk->pipelines.hdr_to_sdr, vk->readback_render_pass, readback_source, &vk->readback_image, vk, &vk->hdr.ubo, readback_hdr_mode, false);
+
+            /* The readback render pass declares its finalLayout as
+             * TRANSFER_SRC_OPTIMAL, but with no subpass dependency it
+             * does not provide a memory availability guarantee against
+             * the subsequent vkCmdCopyImageToBuffer in vulkan_readback().
+             * Insert an explicit barrier so color writes from the
+             * tonemap pass are visible to the transfer read. */
+            {
+               VkMemoryBarrier mem_barrier;
+               mem_barrier.sType         = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
+               mem_barrier.pNext         = NULL;
+               mem_barrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+               mem_barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+               vkCmdPipelineBarrier(vk->cmd,
+                     VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                     VK_PIPELINE_STAGE_TRANSFER_BIT, 0,
+                     1, &mem_barrier, 0, NULL, 0, NULL);
+            }
+
             readback_source = &vk->readback_image;
          }
 #endif /* VULKAN_HDR_SWAPCHAIN */

gfx/drivers/vulkan_shaders/hdr_tonemap.frag

@@ -7,21 +7,54 @@ layout(set = 0, binding = 2) uniform highp sampler2D Source;
 
 #include "hdr_common.glsl"
 
+/* sRGB electrical-optical transfer function (linear -> sRGB encoded bytes).
+ * Needed because the readback render target is B8G8R8A8_UNORM (linear),
+ * so we must apply the sRGB OETF ourselves for the saved PNG to look
+ * correct in any standard sRGB viewer. */
+vec3 LinearToSRGB(vec3 c)
+{
+   vec3 clamped = clamp(c, vec3(0.0), vec3(1.0));
+   vec3 lo = clamped * 12.92;
+   vec3 hi = 1.055 * pow(clamped, vec3(1.0 / 2.4)) - 0.055;
+   bvec3 cutoff = lessThanEqual(clamped, vec3(0.0031308));
+   return mix(hi, lo, vec3(cutoff));
+}
+
+/* Mode tag passed from vulkan_run_hdr_pipeline() for the readback pipeline:
+ *   1 = backbuffer is HDR10 PQ (RGB10A2, BT.2020, ST.2084 encoded)
+ *   2 = backbuffer is scRGB   (FP16, BT.709 linear, 1.0 == 80 nits)
+ * Any other value falls through to a passthrough path (e.g. if the
+ * backbuffer is already SDR). */
+
 void main()
 {
    vec4 source = texture(Source, vTexCoord);
-   vec3 hdr = source.rgb;
-   vec3 linear = hdr;
-   if (global.HDR10 > 0.0f)
+   vec3 sdr_linear;
+
+   if (global.HDRMode == 1u)
+   {
+      /* HDR10 PQ: decode PQ -> linear BT.709, then inverse-of-inverse-tonemap
+       * back down to SDR linear using the same paper_white the forward pass used. */
+      vec3 hdr_linear = HDR10ToLinear(source.rgb);
+      sdr_linear      = Tonemap(hdr_linear,
+                                global.BrightnessNits,
+                                global.BrightnessNits);
+   }
+   else if (global.HDRMode == 2u)
    {
-      /* Backbuffer is in HDR10, need to convert to linear */
-      linear = HDR10ToLinear(hdr);
+      /* scRGB: already linear BT.709, but scaled such that 1.0 = 80 nits
+       * and the SDR UI sits at paper_white_nits. Undo that scaling so SDR
+       * paper white maps back to 1.0. scRGB can carry negative / >1 values
+       * for out-of-gamut / super-white content; LinearToSRGB will clamp. */
+      sdr_linear = source.rgb * (kscRGBWhiteNits / global.BrightnessNits);
    }
-   vec3 sdr = hdr;
-   if (global.InverseTonemap > 0.0f)
+   else
    {
-      /* Backbuffer is inverse tonemapped, need to tonemap back */
-      sdr = Tonemap(linear);
+      /* Passthrough: backbuffer is already SDR linear (shouldn't happen on
+       * the HDR readback path, but keeps the shader well-defined). */
+      sdr_linear = source.rgb;
    }
-   FragColor = vec4(sdr, source.a);
+
+   /* B8G8R8A8_UNORM target — apply sRGB OETF so the PNG looks right. */
+   FragColor = vec4(LinearToSRGB(sdr_linear), 1.0);
 }