Metal: add GPU Index menu option

The Settings -> Video -> Output "GPU Index" entry was missing when
running under the Metal video driver, despite being present for
Vulkan and D3D10/11/12.  The menu displaylist unconditionally tries
to parse VIDEO_GPU_INDEX, but the CONFIG_INT was only registered for
Vulkan/D3D, so the entry silently dropped out on Metal.

Wire Metal into the existing GPU-index plumbing:

- configuration.{h,c}, config.def.h: add metal_gpu_index settings
  int, DEFAULT_METAL_GPU_INDEX, and SETTING_INT binding for config
  persistence.  All gated on HAVE_METAL.
- gfx/video_driver.c: add GFX_CTX_METAL_API slot to gpu_map so
  video_driver_{set,get}_gpu_api_devices() can store/retrieve the
  Metal device list.
- menu/menu_setting.c: register CONFIG_INT for metal_gpu_index when
  the active driver is "metal", mirroring the vulkan/d3dN pattern.
- menu/cbs/menu_cbs_{left,right}.c: add GFX_CTX_METAL_API wraparound
  branches so left/right cycles the selected device.
- gfx/drivers/metal.m: enumerate adapters and publish the device
  list to the frontend.

Platform split inside metal.m:

- macOS: use MTLCopyAllDevices() to enumerate every adapter, honour
  settings->ints.metal_gpu_index when in range, and fall back to
  MTLCreateSystemDefaultDevice() with a RARCH_WARN otherwise (same
  bounds-check + fallback pattern as d3d10.c).
- iOS/tvOS: MTLCopyAllDevices() is explicitly API_UNAVAILABLE(ios)
  and these platforms only ever expose one GPU.  Gated behind
  !defined(HAVE_COCOATOUCH); the CocoaTouch path keeps the existing
  MTLCreateSystemDefaultDevice() call and publishes a one-element
  list so the menu entry still renders sensibly.

Nothing added raises the minimum deployment target (iOS 6.0 Cocoa
TUs don't include metal.m at all; MTLDevice.name and the two device
APIs used have been available since the Metal floor of each
platform).

The GPU list is stored as a plain C struct string_list on a new
_gpu_list ivar, so it crosses the ARC/MRC TU boundary safely.
MTLCopyAllDevices() and MTLCreateSystemDefaultDevice() are both
NS_RETURNS_RETAINED and handled correctly by ARC in metal.m (which
is always compiled -fobjc-arc per the per-file Makefile override);
string_list_append() strdup's its input so the autoreleased NSString
backing -[MTLDevice name].UTF8String is not captured past its
lifetime.  dealloc frees the list and clears the frontend slot with
video_driver_set_gpu_api_devices(GFX_CTX_METAL_API, NULL) before
freeing, so a driver reinit can't chase a dangling pointer.

Existing retroarch.cfg files without a metal_gpu_index key default
to 0 (system default device) and keep their previous behaviour.

Author: LibretroAdmin

config.def.h

@@ -1791,6 +1791,10 @@
 #define DEFAULT_D3D12_GPU_INDEX 0
 #endif
 
+#ifdef HAVE_METAL
+#define DEFAULT_METAL_GPU_INDEX 0
+#endif
+
 #if defined(HAKCHI)
 #define DEFAULT_BUILDBOT_SERVER_URL "http://hakchicloud.com/Libretro_Cores/"
 #elif defined(WEBOS)

configuration.c

@@ -2794,6 +2794,9 @@ static struct config_int_setting *populate_settings_int(
 #ifdef HAVE_VULKAN
    SETTING_INT("vulkan_gpu_index",               &settings->ints.vulkan_gpu_index, true, DEFAULT_VULKAN_GPU_INDEX, false);
 #endif
+#ifdef HAVE_METAL
+   SETTING_INT("metal_gpu_index",                &settings->ints.metal_gpu_index, true, DEFAULT_METAL_GPU_INDEX, false);
+#endif
 
 #ifdef HAVE_NETWORKING
    SETTING_INT("netplay_check_frames",           &settings->ints.netplay_check_frames, true, DEFAULT_NETPLAY_CHECK_FRAMES, false);

configuration.h

@@ -136,6 +136,9 @@ typedef struct settings
 #ifdef HAVE_D3D12
       int d3d12_gpu_index;
 #endif
+#ifdef HAVE_METAL
+      int metal_gpu_index;
+#endif
 #ifdef HAVE_WINDOW_OFFSET
       int video_window_offset_x;
       int video_window_offset_y;

gfx/drivers/metal.m

@@ -28,6 +28,7 @@
 
 #include <encodings/utf.h>
 #include <compat/strl.h>
+#include <lists/string_list.h>
 #include <gfx/scaler/scaler.h>
 #include <gfx/video_frame.h>
 #include <formats/image.h>
@@ -3253,6 +3254,15 @@ @implementation MetalDriver
     * back to the frontend's frame_cache_data to repopulate the texture
     * ourselves. */
    bool _frameEverUploaded;
+
+   /* List of selectable Metal devices reported to the frontend so the
+    * "GPU Index" menu entry can enumerate them.  Owned by this driver
+    * instance: created in init, published via
+    * video_driver_set_gpu_api_devices(), freed in dealloc (where we
+    * also clear the frontend pointer).  On iOS/tvOS this is always a
+    * 1-element list containing the system default device, since
+    * MTLCopyAllDevices() is macOS-only. */
+   struct string_list *_gpu_list;
 }
 
 - (instancetype)initWithVideo:(const video_info_t *)video
@@ -3261,7 +3271,81 @@ - (instancetype)initWithVideo:(const video_info_t *)video
 {
    if (self = [super init])
    {
-      _device                       = MTLCreateSystemDefaultDevice();
+      /* Build the list of selectable Metal devices and pick one per the
+       * user-configured metal_gpu_index.
+       *
+       * iOS/tvOS: MTLCopyAllDevices() is macOS-only (explicitly marked
+       * API_UNAVAILABLE(ios) in <Metal/MTLDevice.h>), and these platforms
+       * only ever expose a single integrated GPU.  We publish a
+       * one-element list containing the system default device so the
+       * frontend's GPU-index menu entry shows something sensible, and
+       * the setting is effectively a no-op.
+       *
+       * macOS: enumerate every adapter via MTLCopyAllDevices(), honour
+       * settings->ints.metal_gpu_index if it's in range, and fall back
+       * to MTLCreateSystemDefaultDevice() otherwise (matches the
+       * behaviour of every other RetroArch driver that exposes this
+       * setting — see d3d10.c:2725 for the reference pattern).
+       *
+       * The list is stored as a plain C struct string_list, so it's
+       * safe to cross the ARC/MRC TU boundary; ownership is tracked
+       * explicitly and cleared in dealloc. */
+      {
+         union string_list_elem_attr attr = {0};
+         _gpu_list                        = string_list_new();
+
+#if defined(HAVE_COCOATOUCH)
+         _device                          = MTLCreateSystemDefaultDevice();
+
+         if (_gpu_list && _device)
+         {
+            const char *name              = [[_device name] UTF8String];
+            string_list_append(_gpu_list, name ? name : "Default", attr);
+         }
+#else
+         {
+            settings_t               *settings_ptr = config_get_ptr();
+            int                       gpu_index    = settings_ptr
+               ? settings_ptr->ints.metal_gpu_index : 0;
+            NSArray<id<MTLDevice>> *devices        = MTLCopyAllDevices();
+            NSUInteger                count        = devices ? [devices count] : 0;
+            NSUInteger                i;
+
+            if (_gpu_list)
+            {
+               for (i = 0; i < count; i++)
+               {
+                  id<MTLDevice> d            = [devices objectAtIndex:i];
+                  const char   *name         = [[d name] UTF8String];
+                  RARCH_LOG("[Metal] Found GPU #%u: \"%s\".\n",
+                        (unsigned)i, name ? name : "Unknown");
+                  string_list_append(_gpu_list,
+                        name ? name : "Unknown", attr);
+               }
+            }
+
+            if (count > 0 && gpu_index >= 0 && gpu_index < (int)count)
+            {
+               const char *picked_name;
+               _device     = [devices objectAtIndex:gpu_index];
+               picked_name = [[_device name] UTF8String];
+               RARCH_LOG("[Metal] Using GPU #%d: \"%s\".\n",
+                     gpu_index, picked_name ? picked_name : "Unknown");
+            }
+            else
+            {
+               if (gpu_index != 0)
+                  RARCH_WARN("[Metal] metal_gpu_index %d out of range (%u device(s) found), "
+                        "falling back to system default device.\n",
+                        gpu_index, (unsigned)count);
+               _device = MTLCreateSystemDefaultDevice();
+            }
+         }
+#endif
+
+         video_driver_set_gpu_api_devices(GFX_CTX_METAL_API, _gpu_list);
+      }
+
       MetalView *view               = (MetalView *)apple_platform.renderView;
       view.device                   = _device;
       view.delegate                 = self;
@@ -3422,6 +3506,18 @@ - (void)dealloc
    }
    font_driver_free_osd();
 
+   /* Tear down the GPU list we published to the frontend.  We clear
+    * the slot first so any later code paths (e.g. the menu cbs) that
+    * look up the list for GFX_CTX_METAL_API see NULL instead of a
+    * pointer to freed memory before the next driver instance comes
+    * up and repopulates it. */
+   if (_gpu_list)
+   {
+      video_driver_set_gpu_api_devices(GFX_CTX_METAL_API, NULL);
+      string_list_free(_gpu_list);
+      _gpu_list = NULL;
+   }
+
 #if METAL_HDR_AVAILABLE
    /* Withdraw the HDR-capability flags so a subsequent driver init (e.g.
     * after the user switches to Vulkan and back) doesn't see stale bits. */

gfx/video_driver.c

@@ -83,7 +83,10 @@ static gfx_api_gpu_map gpu_map[] = {
    { NULL,                   GFX_CTX_VULKAN_API     },
    { NULL,                   GFX_CTX_DIRECT3D10_API },
    { NULL,                   GFX_CTX_DIRECT3D11_API },
-   { NULL,                   GFX_CTX_DIRECT3D12_API }
+   { NULL,                   GFX_CTX_DIRECT3D12_API },
+#ifdef HAVE_METAL
+   { NULL,                   GFX_CTX_METAL_API      },
+#endif
 };
 
 static const video_display_server_t dispserv_null = {

menu/cbs/menu_cbs_left.c

@@ -1080,6 +1080,32 @@ static int action_left_video_gpu_index(unsigned type, const char *label,
          break;
       }
 #endif
+#ifdef HAVE_METAL
+      case GFX_CTX_METAL_API:
+      {
+         struct string_list *list = video_driver_get_gpu_api_devices(api);
+
+         if (list)
+         {
+            settings_t *settings = config_get_ptr();
+            int metal_gpu_index  = settings->ints.metal_gpu_index;
+            if (metal_gpu_index > 0)
+            {
+               configuration_set_int(settings,
+                     settings->ints.metal_gpu_index,
+                     metal_gpu_index - 1);
+            }
+            else
+            {
+               configuration_set_int(settings,
+                     settings->ints.metal_gpu_index,
+                     (int)list->size - 1);
+            }
+         }
+
+         break;
+      }
+#endif
       default:
          break;
    }

menu/cbs/menu_cbs_right.c

@@ -471,6 +471,23 @@ static int action_right_video_gpu_index(unsigned type, const char *label,
          break;
       }
 #endif
+#ifdef HAVE_METAL
+      case GFX_CTX_METAL_API:
+      {
+         struct string_list *list = video_driver_get_gpu_api_devices(api);
+
+         if (list)
+         {
+            settings_t *settings = config_get_ptr();
+            if (settings->ints.metal_gpu_index < (int)(list->size - 1))
+               settings->ints.metal_gpu_index++;
+            else if (settings->ints.metal_gpu_index == (int)(list->size - 1))
+               settings->ints.metal_gpu_index = 0;
+         }
+
+         break;
+      }
+#endif
       default:
          break;
    }

menu/menu_setting.c

@@ -13243,6 +13243,27 @@ static bool setting_append_list(
             }
 #endif
 
+#ifdef HAVE_METAL
+            if (string_is_equal(video_driver_get_ident(), "metal"))
+            {
+               CONFIG_INT(
+                     list, list_info,
+                     &settings->ints.metal_gpu_index,
+                     MENU_ENUM_LABEL_VIDEO_GPU_INDEX,
+                     MENU_ENUM_LABEL_VALUE_VIDEO_GPU_INDEX,
+                     0,
+                     &group_info,
+                     &subgroup_info,
+                     parent_group,
+                     general_write_handler,
+                     general_read_handler);
+               menu_settings_list_current_add_range(list, list_info, 0, 15, 1, true, true);
+               (*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
+               (*list)[list_info->index - 1].get_string_representation =
+                  &setting_get_string_representation_int_gpu_index;
+            }
+#endif
+
 #ifdef WIIU
             CONFIG_BOOL(
                   list, list_info,