gfx/gdi,vga: reuse menu frame buffer across set_texture_frame calls

Both drivers unconditionally free'd menu_frame and set it to NULL
before a subsequent size-comparison check, making the "only reallocate
if size changed" branch dead. Every menu frame triggered a full
free+malloc+memcpy round-trip on a buffer whose size rarely or never
changes.

gdi: replace with a cached-capacity realloc pattern matching the
earlier caca/fpga/sixel/network fix — allocate or grow only when the
required size exceeds the current capacity; otherwise reuse. The
menu_frame_cap field is added to gdi_t in gdi_defines.h. Since gdi_t
is heap-allocated via calloc and freed entire, no explicit cap-reset
is needed in the free path (re-init gets fresh zeros).

vga: the menu buffer is *always* VGA_WIDTH*VGA_HEIGHT (64000 bytes)
regardless of the source frame dimensions — the incoming frame is
downscaled into this fixed-size buffer. No capacity tracking is
needed; allocate once on first call and reuse forever. The original
size-comparison check was doubly meaningless (against a buffer of
constant size).

Note on vga: an unrelated pre-existing bug — the rgb32 branch of the
downscaling loop does not populate vga_menu_frame at all, leaving
stale/uninitialized content — is flagged with a FIXME comment but not
fixed here. It deserves its own commit with testing on a real DOS
target.

Thread-safety for both: set_texture_frame and the frame read-site both
run on the video thread (threaded video) or main thread (non-threaded),
sequentially within the same loop iteration. No synchronization
required, none added. The Win32 WM_PAINT handler reads other fields
of gdi_t from the UI thread; menu_frame is not among them and this
patch does not alter the pre-existing concurrency surface. The
realloc/once-alloc patterns additionally close a transient NULL window
that existed between free and malloc in the original code.

Author: LibretroAdmin

gfx/common/gdi_defines.h

@@ -35,6 +35,7 @@ typedef struct gdi
    HBITMAP bmp_old;
    uint16_t *temp_buf;
    uint8_t *menu_frame;
+   size_t menu_frame_cap;
 
    unsigned video_width;
    unsigned video_height;

gfx/drivers/gdi_gfx.c

@@ -872,38 +872,29 @@ static void gdi_set_texture_frame(void *data,
       const void *frame, bool rgb32, unsigned width, unsigned height,
       float alpha)
 {
-   gdi_t *gdi     = (gdi_t*)data;
-   unsigned pitch = width * 2;
+   gdi_t   *gdi     = (gdi_t*)data;
+   unsigned pitch   = width * (rgb32 ? 4 : 2);
+   size_t   required;
 
-   if (rgb32)
-      pitch = width * 4;
+   if (!frame || !width || !height || !pitch)
+      return;
 
-   if (gdi->menu_frame)
-      free(gdi->menu_frame);
-   gdi->menu_frame = NULL;
+   required = (size_t)pitch * (size_t)height;
 
-   if (     !gdi->menu_frame
-         || (gdi->menu_width  != width)
-         || (gdi->menu_height != height)
-         || (gdi->menu_pitch  != pitch))
+   if (required > gdi->menu_frame_cap)
    {
-      if (pitch && height)
-      {
-         unsigned char *tmp = (unsigned char*)malloc(pitch * height);
-
-         if (tmp)
-            gdi->menu_frame = tmp;
-      }
+      uint8_t *tmp = (uint8_t*)realloc(gdi->menu_frame, required);
+      if (!tmp)
+         return;                        /* keep previous frame intact */
+      gdi->menu_frame     = tmp;
+      gdi->menu_frame_cap = required;
    }
 
-   if (gdi->menu_frame && frame && pitch && height)
-   {
-      memcpy(gdi->menu_frame, frame, pitch * height);
-      gdi->menu_width  = width;
-      gdi->menu_height = height;
-      gdi->menu_pitch  = pitch;
-      gdi->menu_bits   = rgb32 ? 32 : 16;
-   }
+   memcpy(gdi->menu_frame, frame, required);
+   gdi->menu_width  = width;
+   gdi->menu_height = height;
+   gdi->menu_pitch  = pitch;
+   gdi->menu_bits   = rgb32 ? 32 : 16;
 }
 
 static void gdi_set_video_mode(void *data, unsigned width, unsigned height,

gfx/drivers/vga_gfx.c

@@ -405,23 +405,24 @@ static void vga_set_texture_frame(void *data,
       float alpha)
 {
    vga_t     *vga = (vga_t*)data;
-   unsigned pitch = width * 2;
+   unsigned pitch = width * (rgb32 ? 4 : 2);
 
-   if (rgb32)
-      pitch = width * 4;
-
-   if (vga->vga_menu_frame)
-      free(vga->vga_menu_frame);
-   vga->vga_menu_frame = NULL;
+   if (!frame || !width || !height || !pitch)
+      return;
 
-   if ( !vga->vga_menu_frame ||
-         vga->vga_menu_width  != width  ||
-         vga->vga_menu_height != height ||
-         vga->vga_menu_pitch  != pitch)
-      if (pitch && height)
-         vga->vga_menu_frame = (unsigned char*)malloc(VGA_WIDTH * VGA_HEIGHT);
+   /* vga_menu_frame is always VGA_WIDTH*VGA_HEIGHT regardless of the
+    * incoming source frame size — the source is downscaled into this
+    * fixed-size buffer below.  Allocate once on first call and reuse
+    * thereafter; the original free+malloc per call was pure churn on
+    * a buffer whose size never changes. */
+   if (!vga->vga_menu_frame)
+   {
+      unsigned char *tmp = (unsigned char*)malloc(VGA_WIDTH * VGA_HEIGHT);
+      if (!tmp)
+         return;                        /* keep previous frame intact (NULL) */
+      vga->vga_menu_frame = tmp;
+   }
 
-   if (vga->vga_menu_frame && frame && pitch && height)
    {
       unsigned x, y;
 
@@ -444,6 +445,9 @@ static void vga_set_texture_frame(void *data,
             }
          }
       }
+      /* FIXME: rgb32 path does not populate vga_menu_frame - leaves
+       * stale/uninitialized content for the renderer.  Separate pre-
+       * existing bug, not fixed here. */
 
       vga->vga_menu_width  = width;
       vga->vga_menu_height = height;