UI: XMU Settings

config_spec.yml

@@ -25,6 +25,27 @@ input:
     port2: string
     port3: string
     port4: string
+  peripherals:
+    port1:
+      peripheral_type_0: integer
+      peripheral_param_0: string
+      peripheral_type_1: integer
+      peripheral_param_1: string
+    port2:
+      peripheral_type_0: integer
+      peripheral_param_0: string
+      peripheral_type_1: integer
+      peripheral_param_1: string
+    port3:
+      peripheral_type_0: integer
+      peripheral_param_0: string
+      peripheral_type_1: integer
+      peripheral_param_1: string
+    port4:
+      peripheral_type_0: integer
+      peripheral_param_0: string
+      peripheral_type_1: integer
+      peripheral_param_1: string
   gamecontrollerdb_path: string
   auto_bind:
     type: bool

data/meson.build

@@ -1,5 +1,6 @@
 pfiles = [
   'controller_mask.png',
+  'xmu_mask.png',
   'logo_sdf.png',
   'xemu_64x64.png',
   'abxy.ttf',

ui/meson.build

@@ -45,7 +45,7 @@ xemu_ss.add(when: 'CONFIG_LINUX', if_true: [xemu_gtk, files('xemu-os-utils-linux
 xemu_ss.add(when: 'CONFIG_WIN32', if_true: files('xemu-os-utils-windows.c'))
 xemu_ss.add(when: 'CONFIG_DARWIN', if_true: files('xemu-os-utils-macos.m'))
 xemu_ss.add(when: 'CONFIG_RENDERDOC', if_true: [libdl])
-xemu_ss.add(imgui, implot, stb_image, noc, sdl, opengl, openssl, fa, fpng, json, httplib)
+xemu_ss.add(imgui, implot, stb_image, noc, sdl, opengl, openssl, fa, fpng, json, httplib, fatx)
 
 softmmu_ss.add_all(xemu_ss)
 

ui/thirdparty/fatx/fatx.c

@@ -0,0 +1,51 @@
+#include "fatx.h"
+#include "qemu/bswap.h"
+
+#define FATX_SIGNATURE 0x58544146
+
+// This is from libfatx
+#pragma pack(1)
+struct fatx_superblock {
+    uint32_t signature;
+    uint32_t volume_id;
+    uint32_t sectors_per_cluster;
+    uint32_t root_cluster;
+    uint16_t unknown1;
+    uint8_t  padding[4078];
+};
+#pragma pack()
+
+bool create_fatx_image(const char* filename, unsigned int size)
+{
+    unsigned int empty_fat = cpu_to_le32(0xfffffff8);
+    unsigned char zero = 0;
+
+    FILE *fp = qemu_fopen(filename, "wb");
+    if (fp != NULL)
+    {
+        struct fatx_superblock superblock;
+        memset(&superblock, 0xff, sizeof(struct fatx_superblock));
+
+        superblock.signature = cpu_to_le32(FATX_SIGNATURE);
+        superblock.sectors_per_cluster = cpu_to_le32(4);
+        superblock.volume_id = (uint32_t)rand();
+        superblock.root_cluster = cpu_to_le32(1);
+        superblock.unknown1 = 0;
+
+        // Write the fatx superblock.
+        fwrite(&superblock, sizeof(superblock), 1, fp);
+
+        // Write the FAT
+        fwrite(&empty_fat, sizeof(empty_fat), 1, fp);
+
+        fseek(fp, size-sizeof(unsigned char), SEEK_SET);
+        fwrite(&zero, sizeof(unsigned char), 1, fp);
+
+        fflush(fp);
+        fclose(fp);
+
+        return true;
+    }
+
+    return false;
+}

ui/thirdparty/fatx/fatx.h

@@ -0,0 +1,16 @@
+#ifndef FATX_H
+#define FATX_H
+
+#include "qemu/osdep.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+bool create_fatx_image(const char* filename, unsigned int size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

ui/thirdparty/meson.build

@@ -62,3 +62,6 @@ fpng = declare_dependency(include_directories: 'fpng', link_with: libfpng)
 
 json = declare_dependency(include_directories: 'json')
 httplib = declare_dependency(include_directories: 'httplib')
+
+libfatx = static_library('fatx', sources: 'fatx/fatx.c')
+fatx = declare_dependency(include_directories: 'fatx', link_with: libfatx)

ui/xemu-input.c

@@ -33,6 +33,8 @@
 #include "xemu-notifications.h"
 #include "xemu-settings.h"
 
+#include "sysemu/blockdev.h"
+
 // #define DEBUG_INPUT
 
 #ifdef DEBUG_INPUT
@@ -94,8 +96,24 @@ static const char **port_index_to_settings_key_map[] = {
     &g_config.input.bindings.port4,
 };
 
+static int* peripheral_types_settings_map[4][2] = {
+    { &g_config.input.peripherals.port1.peripheral_type_0, &g_config.input.peripherals.port1.peripheral_type_1 },
+    { &g_config.input.peripherals.port2.peripheral_type_0, &g_config.input.peripherals.port2.peripheral_type_1 },
+    { &g_config.input.peripherals.port3.peripheral_type_0, &g_config.input.peripherals.port3.peripheral_type_1 },
+    { &g_config.input.peripherals.port4.peripheral_type_0, &g_config.input.peripherals.port4.peripheral_type_1 }
+};
+
+static const char **peripheral_params_settings_map[4][2] = {
+    { &g_config.input.peripherals.port1.peripheral_param_0, &g_config.input.peripherals.port1.peripheral_param_1 },
+    { &g_config.input.peripherals.port2.peripheral_param_0, &g_config.input.peripherals.port2.peripheral_param_1 },
+    { &g_config.input.peripherals.port3.peripheral_param_0, &g_config.input.peripherals.port3.peripheral_param_1 },
+    { &g_config.input.peripherals.port4.peripheral_param_0, &g_config.input.peripherals.port4.peripheral_param_1 }
+};
+
 static int sdl_kbd_scancode_map[25];
 
+static const int port_map[4] = {3, 4, 1, 2};
+
 void xemu_input_init(void)
 {
     if (g_config.input.background_input_capture) {
@@ -113,6 +131,10 @@ void xemu_input_init(void)
     new_con->type = INPUT_DEVICE_SDL_KEYBOARD;
     new_con->name = "Keyboard";
     new_con->bound = -1;
+    new_con->peripheral_types[0] = PERIPHERAL_NONE;
+    new_con->peripheral_types[1] = PERIPHERAL_NONE;
+    new_con->peripherals[0] = NULL;
+    new_con->peripherals[1] = NULL;
 
     sdl_kbd_scancode_map[0] = g_config.input.keyboard_controller_scancode_map.a;
     sdl_kbd_scancode_map[1] = g_config.input.keyboard_controller_scancode_map.b;
@@ -178,6 +200,18 @@ int xemu_input_get_controller_default_bind_port(ControllerState *state, int star
     return -1;
 }
 
+void xemu_save_peripheral_settings(int player_index, int peripheral_index, int peripheral_type, const char *peripheral_parameter)
+{
+    int *peripheral_type_ptr = peripheral_types_settings_map[player_index][peripheral_index];
+    const char **peripheral_param_ptr = peripheral_params_settings_map[player_index][peripheral_index];
+
+    assert(peripheral_type_ptr);
+    assert(peripheral_param_ptr);
+
+    *peripheral_type_ptr = peripheral_type;
+    xemu_settings_set_string(peripheral_param_ptr, peripheral_parameter == NULL ? "" : peripheral_parameter);
+}
+
 void xemu_input_process_sdl_events(const SDL_Event *event)
 {
     if (event->type == SDL_CONTROLLERDEVICEADDED) {
@@ -202,6 +236,10 @@ void xemu_input_process_sdl_events(const SDL_Event *event)
         new_con->sdl_joystick_id      = SDL_JoystickInstanceID(new_con->sdl_joystick);
         new_con->sdl_joystick_guid    = SDL_JoystickGetGUID(new_con->sdl_joystick);
         new_con->bound                = -1;
+        new_con->peripheral_types[0]  = PERIPHERAL_NONE;
+        new_con->peripheral_types[1]  = PERIPHERAL_NONE;
+        new_con->peripherals[0]       = NULL;
+        new_con->peripherals[1]       = NULL;
 
         char guid_buf[35] = { 0 };
         SDL_JoystickGetGUIDString(new_con->sdl_joystick_guid, guid_buf, sizeof(guid_buf));
@@ -255,6 +293,39 @@ void xemu_input_process_sdl_events(const SDL_Event *event)
             char buf[128];
             snprintf(buf, sizeof(buf), "Connected '%s' to port %d", new_con->name, port+1);
             xemu_queue_notification(buf);
+
+            // Try to bind peripherals back to controller
+            for(int i = 0; i < 2; i++) {
+                enum peripheral_type peripheralType = (enum peripheral_type)(*peripheral_types_settings_map[port][i]);
+
+                // If peripheralType is out of range, change the settings for this controller and peripheral port to default
+                if(peripheralType < PERIPHERAL_NONE || peripheralType >= PERIPHERAL_TYPE_COUNT) {
+                    xemu_save_peripheral_settings(port, i, PERIPHERAL_NONE, NULL);
+                    peripheralType = PERIPHERAL_NONE;
+                }
+
+                const char *param = *peripheral_params_settings_map[port][i];
+
+                if(peripheralType == PERIPHERAL_XMU) {
+                    if(param != NULL && strlen(param) > 0) {
+                        // This is an XMU and needs to be bound to this controller
+                        if(qemu_access(param, F_OK) == 0) {
+                            bound_controllers[port]->peripheral_types[i] = (enum peripheral_type)peripheralType;
+                            bound_controllers[port]->peripherals[i] = malloc(sizeof(XmuState));
+                            memset(bound_controllers[port]->peripherals[i], 0, sizeof(XmuState));
+                            xemu_input_bind_xmu(port, i, param);
+
+                            char *buf = g_strdup_printf("Connected XMU %s to port %d%c", param, port + 1, 'A' + i);
+                            xemu_queue_notification(buf);
+                            g_free(buf);
+                        } else {
+                            char *buf = g_strdup_printf("Unable to bind XMU at %s to port %d%c", param, port + 1, 'A' + i);
+                            xemu_queue_error_message(buf);
+                            g_free(buf);
+                        }
+                    }
+                }
+            }
         }
     } else if (event->type == SDL_CONTROLLERDEVICEREMOVED) {
         DPRINTF("Controller Removed: %d\n", event->cdevice.which);
@@ -430,6 +501,11 @@ void xemu_input_bind(int index, ControllerState *state, int save)
     if (bound_controllers[index]) {
         assert(bound_controllers[index]->device != NULL);
         Error *err = NULL;
+
+        // Unbind any XMUs
+        for(int i = 0; i < 2; i++)
+            xemu_input_unbind_xmu(index, i);
+
         qdev_unplug((DeviceState *)bound_controllers[index]->device, &err);
         assert(err == NULL);
 
@@ -461,7 +537,6 @@ void xemu_input_bind(int index, ControllerState *state, int save)
         bound_controllers[index] = state;
         bound_controllers[index]->bound = index;
 
-        const int port_map[4] = {3, 4, 1, 2};
         char *tmp;
 
         // Create controller's internal USB hub.
@@ -507,6 +582,118 @@ void xemu_input_bind(int index, ControllerState *state, int save)
     }
 }
 
+void xemu_input_bind_xmu(int player_index, int peripheral_port_index, const char *filename)
+{
+    assert(player_index >= 0 && player_index < 4);
+    assert(peripheral_port_index >= 0 && peripheral_port_index < 2);
+
+    ControllerState *player = bound_controllers[player_index];
+    enum peripheral_type peripheralType = player->peripheral_types[peripheral_port_index];
+    if(peripheralType != PERIPHERAL_XMU)
+        return;
+
+    XmuState *xmu = (XmuState*)player->peripherals[peripheral_port_index];
+
+    // Unbind existing XMU
+    if(xmu->dev != NULL) {
+        xemu_input_unbind_xmu(player_index, peripheral_port_index);
+    }
+
+    if(filename == NULL)
+        return;
+
+    // Look for any other XMUs that are using this file, and unbind them
+    for(int player_i = 0; player_i < 4; player_i++) {
+        ControllerState *state = bound_controllers[player_i];
+        if(state != NULL) {
+            for(int peripheral_i = 0; peripheral_i < 2; peripheral_i++) {
+                if(state->peripheral_types[peripheral_i] == PERIPHERAL_XMU) {
+                    XmuState *xmu_i = (XmuState*)state->peripherals[peripheral_i];
+                    assert(xmu_i);
+
+                    if(xmu_i->filename != NULL && strcmp(xmu_i->filename, filename) == 0) {
+                        char *buf = g_strdup_printf("This XMU is already mounted on player %d slot %c\r\n", player_i+1, 'A' + peripheral_i);
+                        xemu_queue_notification(buf);
+                        g_free(buf);
+                        return;
+                    }
+                }
+            }
+        }
+    }
+
+    xmu->filename = strdup(filename);
+
+    const int xmu_map[2] = {2, 3};
+    char *tmp;
+
+    static int id_counter = 0;
+    tmp = g_strdup_printf("xmu_%d", id_counter++);
+
+    // Add the file as a drive
+    QDict *qdict1 = qdict_new();
+    qdict_put_str(qdict1, "id", tmp);
+    qdict_put_str(qdict1, "format", "raw");
+    qdict_put_str(qdict1, "file", filename);
+
+    QemuOpts *drvopts = qemu_opts_from_qdict(qemu_find_opts("drive"), qdict1, &error_abort);
+
+    DriveInfo *dinfo = drive_new(drvopts, 0, &error_abort);
+    assert(dinfo);
+
+    // Create the usb-storage device
+    QDict *qdict2 = qdict_new();
+
+    // Specify device driver
+    qdict_put_str(qdict2, "driver", "usb-storage");
+
+    // Specify device identifier
+    qdict_put_str(qdict2, "drive", tmp);
+    g_free(tmp);
+
+    // Specify index/port
+    tmp = g_strdup_printf("1.%d.%d", port_map[player_index], xmu_map[peripheral_port_index]);
+    qdict_put_str(qdict2, "port", tmp);
+    g_free(tmp);
+
+    // Create the device
+    QemuOpts *opts = qemu_opts_from_qdict(qemu_find_opts("device"), qdict2, &error_abort);
+
+    DeviceState *dev = qdev_device_add(opts, &error_abort);
+    assert(dev);
+
+    xmu->dev = (void*)dev;
+
+    // Unref for eventual cleanup
+    qobject_unref(qdict1);
+    qobject_unref(qdict2);
+
+    xemu_save_peripheral_settings(player_index, peripheral_port_index, player->peripheral_types[peripheral_port_index], xmu->filename);
+}
+
+void xemu_input_unbind_xmu(int player_index, int peripheral_port_index)
+{
+    assert(player_index >= 0 && player_index < 4);
+    assert(peripheral_port_index >= 0 && peripheral_port_index < 2);
+
+    ControllerState *state = bound_controllers[player_index];
+    if(state->peripheral_types[peripheral_port_index] != PERIPHERAL_XMU)
+        return;
+
+    XmuState *xmu = (XmuState*)state->peripherals[peripheral_port_index];
+    if(xmu != NULL)
+    {
+        if(xmu->dev != NULL) {
+            qdev_unplug((DeviceState*)xmu->dev, &error_abort);
+            object_unref(OBJECT(xmu->dev));
+            xmu->dev = NULL;
+        }
+
+        g_free((void*)xmu->filename);
+        xmu->filename = NULL;
+    }
+}
+
 void xemu_input_set_test_mode(int enabled)
 {
     test_mode = enabled;
@@ -515,4 +702,4 @@ void xemu_input_set_test_mode(int enabled)
 int xemu_input_get_test_mode(void)
 {
     return test_mode;
-}
+}