Preserve cached core frame across CMD_EVENT_REINIT (frontend + Metal)

command_event_reinit tears the video driver down via
video_driver_free, which nulls video_st->frame_cache_data (the
pointer was borrowed from the core's own framebuffer and isn't
guaranteed to stay live across the driver swap).  The new driver
then comes up with no cached frame to replay, so reinits triggered
from inside the menu (e.g. toggling video_hdr_mode between HDR10
and scRGB on Metal) leave the paused-core background missing until
the user F1-cycles back through the core.

Snapshot the cached frame into a static buffer before reinit,
restore the pointer into video_st->frame_cache_data afterwards, and
call video_driver_cached_frame() to push it through the new
driver's frame callback.  The static buffer is realloc'd on demand
and reused across reinits so there's no leak — the core's next real
frame will simply overwrite the frame_cache_data pointer at its
leisure.

In the Metal driver, additionally latch a _frameEverUploaded flag
so that on frame==NULL calls before the first real frame lands
(e.g. in the one-or-two-frame window before the cached replay
completes), we can also fall back to reading
video_st->frame_cache_data directly from inside renderFrame.  The
two paths overlap cleanly: the frontend snapshot keeps the cache
pointer valid across reinit, and the driver-side latch guards the
transient.

Fixes paused-core background disappearing after HDR mode toggle on
Metal; harmless elsewhere because other drivers either don't
rebuild their internal frame texture on reinit (keeping content
across the swap by accident) or already have equivalent workarounds.

Files

  command.c           : snapshot-and-replay around video_driver_reinit.
  gfx/drivers/metal.m : _frameEverUploaded latch + cached-frame
                        fallback in renderFrame.

Author: LibretroAdmin

command.c

@@ -2440,8 +2440,70 @@ void command_event_reinit(const int flags)
    const input_device_driver_t
       *sec_joypad                 = NULL;
 #endif
+   /* Snapshot the last cached core frame before tearing the video
+    * driver down.  video_driver_free() nulls frame_cache_data as part
+    * of the reinit cycle (the pointer was borrowed from the core's
+    * own framebuffer and isn't guaranteed to stay live across the
+    * driver swap), so without a snapshot the new driver would come
+    * up with no core image to replay.  Restored + replayed below so
+    * the paused-core background remains visible when reinit is
+    * triggered from inside the menu (e.g. HDR mode toggle).
+    *
+    * The snapshot buffer is static and reused across reinits — we
+    * need it to outlive command_event_reinit because we hand the
+    * pointer to video_st->frame_cache_data for the new driver to
+    * read via video_driver_cached_frame(), and the core's next real
+    * frame will replace the pointer at its leisure.  Resizing in
+    * place on each call keeps it bounded at one buffer's worth. */
+   static void  *cached_snapshot      = NULL;
+   static size_t cached_snapshot_cap  = 0;
+   size_t        want_size            = 0;
+   unsigned      cached_snapshot_w    = 0;
+   unsigned      cached_snapshot_h    = 0;
+   size_t        cached_snapshot_p    = 0;
+
+   if (     video_st
+         && video_st->frame_cache_data
+         && video_st->frame_cache_data != RETRO_HW_FRAME_BUFFER_VALID
+         && video_st->frame_cache_height
+         && video_st->frame_cache_pitch)
+      want_size = video_st->frame_cache_pitch
+                * video_st->frame_cache_height;
+   if (want_size > cached_snapshot_cap)
+   {
+      void *tmp = realloc(cached_snapshot, want_size);
+      if (tmp)
+      {
+         cached_snapshot     = tmp;
+         cached_snapshot_cap = want_size;
+      }
+      else
+         want_size           = 0;
+   }
+   if (want_size && cached_snapshot)
+   {
+      memcpy(cached_snapshot, video_st->frame_cache_data, want_size);
+      cached_snapshot_w = video_st->frame_cache_width;
+      cached_snapshot_h = video_st->frame_cache_height;
+      cached_snapshot_p = video_st->frame_cache_pitch;
+   }
 
    video_driver_reinit(flags);
+
+   /* Restore the snapshot and ask the new driver to replay it so the
+    * paused-core background appears in the first post-reinit frame.
+    * The buffer stays live across subsequent frame_cb calls from the
+    * core (which overwrite the pointer) and is either reused on the
+    * next reinit or freed at shutdown. */
+   if (cached_snapshot_p && cached_snapshot_h)
+   {
+      video_st->frame_cache_data   = cached_snapshot;
+      video_st->frame_cache_width  = cached_snapshot_w;
+      video_st->frame_cache_height = cached_snapshot_h;
+      video_st->frame_cache_pitch  = cached_snapshot_p;
+      video_driver_cached_frame();
+   }
+
    /* Poll input to avoid possibly stale data to corrupt things. */
    if (joypad && joypad->poll)
       joypad->poll();

gfx/drivers/metal.m

@@ -3235,6 +3235,18 @@ @implementation MetalDriver
     * Vulkan's behaviour: HDR is effectively an init-time choice that
     * takes effect on the next driver reinit. */
    unsigned _initial_hdr_mode;
+
+   /* Tracks whether _frameView has received any real frame since this
+    * driver instance came up.  When the HDR mode is toggled mid-session
+    * the frontend fires CMD_EVENT_REINIT, destroying and recreating the
+    * driver.  If the user was in the menu with a core paused in the
+    * background, the new driver's frame texture is empty and subsequent
+    * menu-loop frames arrive with frame==NULL, leaving hdrComposite
+    * nothing to sample — the paused core background disappears until
+    * the user F1-cycles.  On the first frame==NULL after reinit we fall
+    * back to the frontend's frame_cache_data to repopulate the texture
+    * ourselves. */
+   bool _frameEverUploaded;
 }
 
 - (instancetype)initWithVideo:(const video_info_t *)video
@@ -3540,8 +3552,33 @@ - (bool)renderFrame:(const void *)frame
       _frameView.frameCount = frameCount;
       if (frame && width && height)
       {
-         _frameView.size = CGSizeMake(width, height);
+         _frameView.size      = CGSizeMake(width, height);
          [_frameView updateFrame:frame pitch:pitch];
+         _frameEverUploaded   = true;
+      }
+      else if (!_frameEverUploaded)
+      {
+         /* Driver just came up (init or post-reinit).  The frontend
+          * hasn't delivered a real frame yet and — on CMD_EVENT_REINIT
+          * from inside the menu — likely won't until the user leaves
+          * the menu.  Pull the cached frame so the core image reappears
+          * under the menu immediately instead of waiting for an F1
+          * cycle.  Safe to do every frame while the flag is clear; we
+          * latch it after the first successful upload. */
+         video_driver_state_t *video_st = video_state_get_ptr();
+         if (     video_st
+               && video_st->frame_cache_data
+               && video_st->frame_cache_data != RETRO_HW_FRAME_BUFFER_VALID
+               && video_st->frame_cache_width
+               && video_st->frame_cache_height
+               && video_st->frame_cache_pitch)
+         {
+            _frameView.size    = CGSizeMake(video_st->frame_cache_width,
+                                            video_st->frame_cache_height);
+            [_frameView updateFrame:video_st->frame_cache_data
+                              pitch:video_st->frame_cache_pitch];
+            _frameEverUploaded = true;
+         }
       }
 
       /* Acquire the frame encoder.  In SDR mode this lazily opens a pass