gfx/vita2d: fix broken size-change check and replace per-pixel copy with per-row memcpy

vita2d_set_texture_frame had two separate bugs in its menu-texture
update path:

1. Broken size-change check. The recreate condition was

      if ((width != vita->menu.width)
          && (height != vita->menu.height)
          && vita->menu.texture)

   with && between the dimension comparisons. That only recreates the
   texture when BOTH dimensions change. If a resize flips only one
   dimension (e.g. 480x272 -> 480x544 on a portrait-mode menu toggle,
   or a width-only change on menu-size setting updates), the old
   texture stays in place but the per-pixel writes below run with the
   new dimensions - indexing past the old allocation when the new
   size is larger, or leaving stale border pixels when it is smaller.
   Change the operator to || so either dimension change triggers a
   recreate. Also hoist the 'vita->menu.texture' truthiness check to
   the front of the expression so the short-circuit is: 'no texture
   to free anyway -> skip the whole branch', which reads more
   naturally than the old ordering.

2. Per-pixel copy. Both the rgb32 and rgb16 branches wrote the frame
   into the texture one pixel at a time inside a double loop:

      for (i = 0; i < height; i++)
         for (j = 0; j < width; j++)
            tex32[j + i*stride] = frame32[j + i*width];

   The destination texture's stride can legitimately differ from the
   source pitch (width * bpp) for alignment reasons, so a single
   memcpy of the whole buffer is not correct, but a per-row memcpy
   handles that case and is straightforwardly faster than the
   per-pixel nested-loop form the compiler has to try hard to
   vectorise. Replace with

      for (i = 0; i < height; i++)
         memcpy(tex + i * stride, frame + i * width, rowlen);

   in both branches.

Also clean up the loop-counter type: the original declared 'int i, j'
but compared against 'unsigned height' / 'unsigned width'. Now just
'unsigned i'; j is no longer needed.

Pre-existing not-addressed-here: if rgb32 flips between calls while
the texture dimensions happen to stay the same, the new check (same
as the old one in this respect) does not recreate the texture, so
the texture format and the caller's data format diverge. In current
practice the menu drivers that drive set_texture_frame always pass a
consistent rgb32 for the duration of a session (rgui always passes
false), so this is latent rather than live, and fixing it cleanly
needs a stored 'was_rgb32' flag on vita_menu_t. Deferred.

Thread-safety: unchanged. set_texture_frame and vita2d_frame both
run on the video thread (threaded video) or main thread (non-threaded),
sequentially within the same loop iteration. No synchronisation
introduced or needed. The transient 'NULL texture between free and
recreate' window is present in both the old and new code and is
correctly guarded by the 'if (vita->menu.texture)' check at the
reader in vita2d_frame.

Author: LibretroAdmin

gfx/drivers/vita2d_gfx.c

@@ -1041,14 +1041,22 @@ static void vita2d_apply_state_changes(void *data)
 static void vita2d_set_texture_frame(void *data, const void *frame, bool rgb32,
    unsigned width, unsigned height, float alpha)
 {
-   int i, j;
+   unsigned i;
    void *tex_p;
    unsigned int stride;
    vita_video_t *vita = (vita_video_t*)data;
 
-   if (     (width  != vita->menu.width)
-         && (height != vita->menu.height)
-         && vita->menu.texture)
+   /* Recreate when either dimension changes, not both.  The original
+    * condition used && between the width/height comparisons, so a
+    * resize that only changed one dimension (e.g. 480x272 -> 480x544
+    * when the menu toggles portrait mode, or a width-only change on
+    * menu-size setting updates) would skip the destroy-recreate step;
+    * the subsequent per-pixel write below would then index past the
+    * old texture's allocation (new size > old) or leave stale border
+    * pixels (new size < old). */
+   if (     vita->menu.texture
+         && (   width  != (unsigned)vita->menu.width
+             || height != (unsigned)vita->menu.height))
    {
       vita2d_wait_rendering_done();
       vita2d_free_texture(vita->menu.texture);
@@ -1073,27 +1081,31 @@ static void vita2d_set_texture_frame(void *data, const void *frame, bool rgb32,
    tex_p  = vita2d_texture_get_datap(vita->menu.texture);
    stride = vita2d_texture_get_stride(vita->menu.texture);
 
+   /* Copy row-by-row via memcpy rather than pixel-by-pixel.  The
+    * texture stride (destination) can differ from the source pitch
+    * (width * bpp) for alignment reasons, so a single memcpy of the
+    * whole buffer isn't safe when stride != width*bpp, but a per-row
+    * memcpy handles both cases and is materially faster than the
+    * previous nested loop with per-pixel indexing. */
    if (rgb32)
    {
-      uint32_t         *tex32 = tex_p;
-      const uint32_t *frame32 = frame;
-
-      stride                 /= 4;
+      uint32_t       *tex32   = (uint32_t*)tex_p;
+      const uint32_t *frame32 = (const uint32_t*)frame;
+      size_t          rowlen  = (size_t)width * 4;
 
+      stride /= 4;
       for (i = 0; i < height; i++)
-         for (j = 0; j < width; j++)
-            tex32[j + i*stride] = frame32[j + i*width];
+         memcpy(tex32 + i * stride, frame32 + i * width, rowlen);
    }
    else
    {
-      uint16_t               *tex16 = tex_p;
-      const uint16_t       *frame16 = frame;
-
-      stride                       /= 2;
+      uint16_t       *tex16   = (uint16_t*)tex_p;
+      const uint16_t *frame16 = (const uint16_t*)frame;
+      size_t          rowlen  = (size_t)width * 2;
 
+      stride /= 2;
       for (i = 0; i < height; i++)
-         for (j = 0; j < width; j++)
-            tex16[j + i*stride] = frame16[j + i*width];
+         memcpy(tex16 + i * stride, frame16 + i * width, rowlen);
    }
 }