X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=frontend%2Flibretro.c;h=0be62b94393de58797181fd751ec11274d5d6c84;hb=5bbe183f3aa15f21613fcf58ead2016c9283a842;hp=93bfc2829ca33108146f8b26acc3f1020aca979e;hpb=44e8d7afc4a20812c0d6be3112c864d4b1af37c1;p=pcsx_rearmed.git

diff --git a/frontend/libretro.c b/frontend/libretro.c
index 93bfc282..0be62b94 100644
--- a/frontend/libretro.c
+++ b/frontend/libretro.c
@@ -41,6 +41,10 @@
 #include <libretro.h>
 #include "libretro_core_options.h"
 
+#ifdef USE_LIBRETRO_VFS
+#include <streams/file_stream_transforms.h>
+#endif
+
 #ifdef _3DS
 #include "3ds/3ds_utils.h"
 #endif
@@ -76,22 +80,43 @@ static unsigned msg_interface_version = 0;
 static void *vout_buf;
 static void *vout_buf_ptr;
 static int vout_width, vout_height;
-static int vout_doffs_old, vout_fb_dirty;
+static int vout_fb_dirty;
 static bool vout_can_dupe;
 static bool duping_enable;
 static bool found_bios;
 static bool display_internal_fps = false;
 static unsigned frame_count = 0;
 static bool libretro_supports_bitmasks = false;
+static bool libretro_supports_option_categories = false;
+static bool show_input_settings = true;
 #ifdef GPU_PEOPS
-static int show_advanced_gpu_peops_settings = -1;
+static bool show_advanced_gpu_peops_settings = true;
 #endif
 #ifdef GPU_UNAI
-static int show_advanced_gpu_unai_settings = -1;
+static bool show_advanced_gpu_unai_settings = true;
 #endif
-static int show_other_input_settings = -1;
 static float mouse_sensitivity = 1.0f;
 
+typedef enum
+{
+   FRAMESKIP_NONE = 0,
+   FRAMESKIP_AUTO,
+   FRAMESKIP_AUTO_THRESHOLD,
+   FRAMESKIP_FIXED_INTERVAL
+} frameskip_type_t;
+
+static unsigned frameskip_type                  = FRAMESKIP_NONE;
+static unsigned frameskip_threshold             = 0;
+static unsigned frameskip_interval              = 0;
+static unsigned frameskip_counter               = 0;
+
+static int retro_audio_buff_active              = false;
+static unsigned retro_audio_buff_occupancy      = 0;
+static int retro_audio_buff_underrun            = false;
+
+static unsigned retro_audio_latency             = 0;
+static int update_audio_latency                 = false;
+
 static unsigned previous_width = 0;
 static unsigned previous_height = 0;
 
@@ -242,29 +267,22 @@ static void convert(void *buf, size_t bytes)
 }
 #endif
 
-static void vout_flip(const void *vram, int stride, int bgr24, int w, int h)
+static void vout_flip(const void *vram, int stride, int bgr24,
+      int x, int y, int w, int h, int dims_changed)
 {
    unsigned short *dest = vout_buf_ptr;
    const unsigned short *src = vram;
    int dstride = vout_width, h1 = h;
-   int doffs;
 
-   if (vram == NULL)
+   if (vram == NULL || dims_changed)
    {
+      memset(vout_buf_ptr, 0, dstride * vout_height * 2);
       // blanking
-      memset(vout_buf_ptr, 0, dstride * h * 2);
-      goto out;
+      if (vram == NULL)
+         goto out;
    }
 
-   doffs = (vout_height - h) * dstride;
-   doffs += (dstride - w) / 2 & ~1;
-   if (doffs != vout_doffs_old)
-   {
-      // clear borders
-      memset(vout_buf_ptr, 0, dstride * h * 2);
-      vout_doffs_old = doffs;
-   }
-   dest += doffs;
+   dest += x + y * dstride;
 
    if (bgr24)
    {
@@ -476,7 +494,7 @@ struct rearmed_cbs pl_rearmed_cbs = {
 void pl_frame_limit(void)
 {
    /* called once per frame, make psxCpu->Execute() above return */
-   stop = 1;
+   stop++;
 }
 
 void pl_timing_prepare(int is_pal)
@@ -516,15 +534,256 @@ void out_register_libretro(struct out_driver *drv)
    drv->feed   = snd_feed;
 }
 
+#define RETRO_DEVICE_PSE_STANDARD   RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_JOYPAD,   0)
+#define RETRO_DEVICE_PSE_ANALOG     RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_ANALOG,   0)
+#define RETRO_DEVICE_PSE_DUALSHOCK  RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_ANALOG,   1)
+#define RETRO_DEVICE_PSE_NEGCON     RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_ANALOG,   2)
+#define RETRO_DEVICE_PSE_GUNCON     RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_LIGHTGUN, 0)
+#define RETRO_DEVICE_PSE_MOUSE      RETRO_DEVICE_SUBCLASS(RETRO_DEVICE_MOUSE,    0)
+
+static char *get_pse_pad_label[] = {
+   "none", "mouse", "negcon", "konami gun", "standard", "analog", "guncon", "dualshock"
+};
+
+static const struct retro_controller_description pads[7] =
+{
+   { "standard",  RETRO_DEVICE_JOYPAD },
+   { "analog",    RETRO_DEVICE_PSE_ANALOG },
+   { "dualshock", RETRO_DEVICE_PSE_DUALSHOCK },
+   { "negcon",    RETRO_DEVICE_PSE_NEGCON },
+   { "guncon",    RETRO_DEVICE_PSE_GUNCON },
+   { "mouse",     RETRO_DEVICE_PSE_MOUSE },
+   { NULL, 0 },
+};
+
+static const struct retro_controller_info ports[9] =
+{
+   { pads, 7 },
+   { pads, 7 },
+   { pads, 7 },
+   { pads, 7 },
+   { pads, 7 },
+   { pads, 7 },
+   { pads, 7 },
+   { pads, 7 },
+   { NULL, 0 },
+};
+
 /* libretro */
+
+static bool update_option_visibility(void)
+{
+   struct retro_variable var                       = {0};
+   struct retro_core_option_display option_display = {0};
+   bool updated                                    = false;
+   unsigned i;
+
+   /* If frontend supports core option categories
+    * then show/hide core option entries are ignored
+    * and no options should be hidden */
+   if (libretro_supports_option_categories)
+      return false;
+
+   var.key = "pcsx_rearmed_show_input_settings";
+   var.value = NULL;
+
+   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+   {
+      bool show_input_settings_prev =
+            show_input_settings;
+
+      show_input_settings = true;
+      if (strcmp(var.value, "disabled") == 0)
+         show_input_settings = false;
+
+      if (show_input_settings !=
+            show_input_settings_prev)
+      {
+         char input_option[][50] = {
+            "pcsx_rearmed_analog_axis_modifier",
+            "pcsx_rearmed_vibration",
+            "pcsx_rearmed_multitap",
+            "pcsx_rearmed_negcon_deadzone",
+            "pcsx_rearmed_negcon_response",
+            "pcsx_rearmed_input_sensitivity",
+            "pcsx_rearmed_gunconadjustx",
+            "pcsx_rearmed_gunconadjusty",
+            "pcsx_rearmed_gunconadjustratiox",
+            "pcsx_rearmed_gunconadjustratioy"
+         };
+
+         option_display.visible = show_input_settings;
+
+         for (i = 0;
+              i < (sizeof(input_option) /
+                     sizeof(input_option[0]));
+              i++)
+         {
+            option_display.key = input_option[i];
+            environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_DISPLAY,
+                  &option_display);
+         }
+
+         updated = true;
+      }
+   }
+#ifdef GPU_PEOPS
+   var.key = "pcsx_rearmed_show_gpu_peops_settings";
+   var.value = NULL;
+
+   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+   {
+      bool show_advanced_gpu_peops_settings_prev =
+            show_advanced_gpu_peops_settings;
+
+      show_advanced_gpu_peops_settings = true;
+      if (strcmp(var.value, "disabled") == 0)
+         show_advanced_gpu_peops_settings = false;
+
+      if (show_advanced_gpu_peops_settings !=
+            show_advanced_gpu_peops_settings_prev)
+      {
+         unsigned i;
+         struct retro_core_option_display option_display;
+         char gpu_peops_option[][45] = {
+            "pcsx_rearmed_gpu_peops_odd_even_bit",
+            "pcsx_rearmed_gpu_peops_expand_screen_width",
+            "pcsx_rearmed_gpu_peops_ignore_brightness",
+            "pcsx_rearmed_gpu_peops_disable_coord_check",
+            "pcsx_rearmed_gpu_peops_lazy_screen_update",
+            "pcsx_rearmed_gpu_peops_repeated_triangles",
+            "pcsx_rearmed_gpu_peops_quads_with_triangles",
+            "pcsx_rearmed_gpu_peops_fake_busy_state"
+         };
+
+         option_display.visible = show_advanced_gpu_peops_settings;
+
+         for (i = 0;
+              i < (sizeof(gpu_peops_option) /
+                     sizeof(gpu_peops_option[0]));
+              i++)
+         {
+            option_display.key = gpu_peops_option[i];
+            environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_DISPLAY,
+                  &option_display);
+         }
+
+         updated = true;
+      }
+   }
+#endif
+#ifdef GPU_UNAI
+   var.key = "pcsx_rearmed_show_gpu_unai_settings";
+   var.value = NULL;
+
+   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+   {
+      bool show_advanced_gpu_unai_settings_prev =
+            show_advanced_gpu_unai_settings;
+
+      show_advanced_gpu_unai_settings = true;
+      if (strcmp(var.value, "disabled") == 0)
+         show_advanced_gpu_unai_settings = false;
+
+      if (show_advanced_gpu_unai_settings !=
+            show_advanced_gpu_unai_settings_prev)
+      {
+         unsigned i;
+         struct retro_core_option_display option_display;
+         char gpu_unai_option[][40] = {
+            "pcsx_rearmed_gpu_unai_blending",
+            "pcsx_rearmed_gpu_unai_lighting",
+            "pcsx_rearmed_gpu_unai_fast_lighting",
+            "pcsx_rearmed_gpu_unai_scale_hires",
+         };
+
+         option_display.visible = show_advanced_gpu_unai_settings;
+
+         for (i = 0;
+              i < (sizeof(gpu_unai_option) /
+                     sizeof(gpu_unai_option[0]));
+              i++)
+         {
+            option_display.key = gpu_unai_option[i];
+            environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_DISPLAY,
+                  &option_display);
+         }
+
+         updated = true;
+      }
+   }
+#endif
+   return updated;
+}
+
 void retro_set_environment(retro_environment_t cb)
 {
+   bool option_categories = false;
+#ifdef USE_LIBRETRO_VFS
+   struct retro_vfs_interface_info vfs_iface_info;
+#endif
+
    environ_cb = cb;
 
    if (cb(RETRO_ENVIRONMENT_GET_LOG_INTERFACE, &logging))
       log_cb = logging.log;
 
-   libretro_set_core_options(environ_cb);
+   environ_cb(RETRO_ENVIRONMENT_SET_CONTROLLER_INFO, (void*)ports);
+
+   /* Set core options
+    * An annoyance: retro_set_environment() can be called
+    * multiple times, and depending upon the current frontend
+    * state various environment callbacks may be disabled.
+    * This means the reported 'categories_supported' status
+    * may change on subsequent iterations. We therefore have
+    * to record whether 'categories_supported' is true on any
+    * iteration, and latch the result */
+   libretro_set_core_options(environ_cb, &option_categories);
+   libretro_supports_option_categories |= option_categories;
+
+   /* If frontend supports core option categories,
+    * any show/hide core option entries are unused
+    * and should be hidden */
+   if (libretro_supports_option_categories)
+   {
+      struct retro_core_option_display option_display;
+      option_display.visible = false;
+
+      option_display.key = "pcsx_rearmed_show_input_settings";
+      environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_DISPLAY,
+            &option_display);
+
+#ifdef GPU_PEOPS
+      option_display.key = "pcsx_rearmed_show_gpu_peops_settings";
+      environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_DISPLAY,
+            &option_display);
+#endif
+#ifdef GPU_UNAI
+      option_display.key = "pcsx_rearmed_show_gpu_unai_settings";
+      environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_DISPLAY,
+            &option_display);
+#endif
+   }
+   /* If frontend does not support core option
+    * categories, core options may be shown/hidden
+    * at runtime. In this case, register 'update
+    * display' callback, so frontend can update
+    * core options menu without calling retro_run() */
+   else
+   {
+      struct retro_core_options_update_display_callback update_display_cb;
+      update_display_cb.callback = update_option_visibility;
+
+      environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_UPDATE_DISPLAY_CALLBACK,
+            &update_display_cb);
+   }
+
+#ifdef USE_LIBRETRO_VFS
+   vfs_iface_info.required_interface_version = 1;
+   vfs_iface_info.iface                      = NULL;
+   if (environ_cb(RETRO_ENVIRONMENT_GET_VFS_INTERFACE, &vfs_iface_info))
+	   filestream_vfs_init(&vfs_iface_info);
+#endif
 }
 
 void retro_set_video_refresh(retro_video_refresh_t cb) { video_cb = cb; }
@@ -538,167 +797,62 @@ unsigned retro_api_version(void)
    return RETRO_API_VERSION;
 }
 
-static int controller_port_variable(unsigned port, struct retro_variable *var)
-{
-   if (port >= PORTS_NUMBER)
-      return 0;
-
-   if (!environ_cb)
-      return 0;
-
-   var->value = NULL;
-   switch (port)
-   {
-   case 0:
-      var->key = "pcsx_rearmed_pad1type";
-      break;
-   case 1:
-      var->key = "pcsx_rearmed_pad2type";
-      break;
-   case 2:
-      var->key = "pcsx_rearmed_pad3type";
-      break;
-   case 3:
-      var->key = "pcsx_rearmed_pad4type";
-      break;
-   case 4:
-      var->key = "pcsx_rearmed_pad5type";
-      break;
-   case 5:
-      var->key = "pcsx_rearmed_pad6type";
-      break;
-   case 6:
-      var->key = "pcsx_rearmed_pad7type";
-      break;
-   case 7:
-      var->key = "pcsx_rearmed_pad8type";
-      break;
-   }
-
-   return environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, var) && var->value;
-}
-
-static void update_controller_port_variable(unsigned port)
+static void update_multitap(void)
 {
-   if (port >= PORTS_NUMBER)
-      return;
+   struct retro_variable var = { 0 };
 
-   struct retro_variable var;
+   multitap1 = 0;
+   multitap2 = 0;
 
-   if (controller_port_variable(port, &var))
+   var.value = NULL;
+   var.key = "pcsx_rearmed_multitap";
+   if (environ_cb && (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value))
    {
-      if (strcmp(var.value, "standard") == 0)
-         in_type[port] = PSE_PAD_TYPE_STANDARD;
-      else if (strcmp(var.value, "analog") == 0)
-         in_type[port] = PSE_PAD_TYPE_ANALOGJOY;
-      else if (strcmp(var.value, "dualshock") == 0)
-         in_type[port] = PSE_PAD_TYPE_ANALOGPAD;
-      else if (strcmp(var.value, "negcon") == 0)
-         in_type[port] = PSE_PAD_TYPE_NEGCON;
-      else if (strcmp(var.value, "guncon") == 0)
-         in_type[port] = PSE_PAD_TYPE_GUNCON;
-      else if (strcmp(var.value, "mouse") == 0)
-         in_type[port] = PSE_PAD_TYPE_MOUSE;
-      else if (strcmp(var.value, "none") == 0)
-         in_type[port] = PSE_PAD_TYPE_NONE;
-      // else 'default' case, do nothing
+      if (strcmp(var.value, "port 1") == 0)
+         multitap1 = 1;
+      else if (strcmp(var.value, "port 2") == 0)
+         multitap2 = 1;
+      else if (strcmp(var.value, "ports 1 and 2") == 0)
+      {
+         multitap1 = 1;
+         multitap2 = 1;
+      }
    }
 }
 
-static void update_controller_port_device(unsigned port, unsigned device)
+void retro_set_controller_port_device(unsigned port, unsigned device)
 {
    if (port >= PORTS_NUMBER)
       return;
 
-   struct retro_variable var;
-
-   if (!controller_port_variable(port, &var))
-      return;
-
-   if (strcmp(var.value, "default") != 0)
-      return;
-
    switch (device)
    {
    case RETRO_DEVICE_JOYPAD:
+   case RETRO_DEVICE_PSE_STANDARD:
       in_type[port] = PSE_PAD_TYPE_STANDARD;
       break;
-   case RETRO_DEVICE_ANALOG:
+   case RETRO_DEVICE_PSE_ANALOG:
+      in_type[port] = PSE_PAD_TYPE_ANALOGJOY;
+      break;
+   case RETRO_DEVICE_PSE_DUALSHOCK:
       in_type[port] = PSE_PAD_TYPE_ANALOGPAD;
       break;
-   case RETRO_DEVICE_MOUSE:
+   case RETRO_DEVICE_PSE_MOUSE:
       in_type[port] = PSE_PAD_TYPE_MOUSE;
       break;
-   case RETRO_DEVICE_LIGHTGUN:
-      in_type[port] = PSE_PAD_TYPE_GUN;
+   case RETRO_DEVICE_PSE_NEGCON:
+      in_type[port] = PSE_PAD_TYPE_NEGCON;
+      break;
+   case RETRO_DEVICE_PSE_GUNCON:
+      in_type[port] = PSE_PAD_TYPE_GUNCON;
       break;
    case RETRO_DEVICE_NONE:
    default:
       in_type[port] = PSE_PAD_TYPE_NONE;
+      break;
    }
-}
-
-static void update_multitap()
-{
-   struct retro_variable var;
-   int auto_case, port;
-
-   var.value = NULL;
-   var.key = "pcsx_rearmed_multitap1";
-   auto_case = 0;
-   if (environ_cb && (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value))
-   {
-      if (strcmp(var.value, "enabled") == 0)
-         multitap1 = 1;
-      else if (strcmp(var.value, "disabled") == 0)
-         multitap1 = 0;
-      else // 'auto' case
-         auto_case = 1;
-   }
-   else
-      auto_case = 1;
-
-   if (auto_case)
-   {
-      // If a gamepad is plugged after port 2, we need a first multitap.
-      multitap1 = 0;
-      for (port = 2; port < PORTS_NUMBER; port++)
-         multitap1 |= in_type[port] != PSE_PAD_TYPE_NONE;
-   }
-
-   var.value = NULL;
-   var.key = "pcsx_rearmed_multitap2";
-   auto_case = 0;
-   if (environ_cb && (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value))
-   {
-      if (strcmp(var.value, "enabled") == 0)
-         multitap2 = 1;
-      else if (strcmp(var.value, "disabled") == 0)
-         multitap2 = 0;
-      else // 'auto' case
-         auto_case = 1;
-   }
-   else
-      auto_case = 1;
-
-   if (auto_case)
-   {
-      // If a gamepad is plugged after port 4, we need a second multitap.
-      multitap2 = 0;
-      for (port = 4; port < PORTS_NUMBER; port++)
-         multitap2 |= in_type[port] != PSE_PAD_TYPE_NONE;
-   }
-}
-
-void retro_set_controller_port_device(unsigned port, unsigned device)
-{
-   SysPrintf("port %u  device %u", port, device);
-
-   if (port >= PORTS_NUMBER)
-      return;
 
-   update_controller_port_device(port, device);
-   update_multitap();
+   SysPrintf("port: %u  device: %s\n", port + 1, get_pse_pad_label[in_type[port]]);
 }
 
 void retro_get_system_info(struct retro_system_info *info)
@@ -708,8 +862,8 @@ void retro_get_system_info(struct retro_system_info *info)
 #endif
    memset(info, 0, sizeof(*info));
    info->library_name     = "PCSX-ReARMed";
-   info->library_version  = "r22" GIT_VERSION;
-   info->valid_extensions = "bin|cue|img|mdf|pbp|toc|cbn|m3u|chd";
+   info->library_version  = "r23l" GIT_VERSION;
+   info->valid_extensions = "bin|cue|img|mdf|pbp|toc|cbn|m3u|chd|iso|exe";
    info->need_fullpath    = true;
 }
 
@@ -1151,11 +1305,11 @@ static bool read_m3u(const char *file)
 {
    char line[1024];
    char name[PATH_MAX];
-   FILE *f = fopen(file, "r");
-   if (!f)
+   FILE *fp = fopen(file, "r");
+   if (!fp)
       return false;
 
-   while (fgets(line, sizeof(line), f) && disk_count < sizeof(disks) / sizeof(disks[0]))
+   while (fgets(line, sizeof(line), fp) && disk_count < sizeof(disks) / sizeof(disks[0]))
    {
       if (line[0] == '#')
          continue;
@@ -1181,7 +1335,7 @@ static bool read_m3u(const char *file)
       }
    }
 
-   fclose(f);
+   fclose(fp);
    return (disk_count != 0);
 }
 
@@ -1249,12 +1403,69 @@ static void set_retro_memmap(void)
 #endif
 }
 
+static void retro_audio_buff_status_cb(
+   bool active, unsigned occupancy, bool underrun_likely)
+{
+   retro_audio_buff_active    = active;
+   retro_audio_buff_occupancy = occupancy;
+   retro_audio_buff_underrun  = underrun_likely;
+}
+
+static void retro_set_audio_buff_status_cb(void)
+{
+   if (frameskip_type == FRAMESKIP_NONE)
+   {
+      environ_cb(RETRO_ENVIRONMENT_SET_AUDIO_BUFFER_STATUS_CALLBACK, NULL);
+      retro_audio_latency = 0;
+   }
+   else
+   {
+      bool calculate_audio_latency = true;
+
+      if (frameskip_type == FRAMESKIP_FIXED_INTERVAL)
+         environ_cb(RETRO_ENVIRONMENT_SET_AUDIO_BUFFER_STATUS_CALLBACK, NULL);
+      else
+      {
+         struct retro_audio_buffer_status_callback buf_status_cb;
+         buf_status_cb.callback = retro_audio_buff_status_cb;
+         if (!environ_cb(RETRO_ENVIRONMENT_SET_AUDIO_BUFFER_STATUS_CALLBACK,
+                         &buf_status_cb))
+         {
+            retro_audio_buff_active    = false;
+            retro_audio_buff_occupancy = 0;
+            retro_audio_buff_underrun  = false;
+            retro_audio_latency        = 0;
+            calculate_audio_latency    = false;
+         }
+      }
+
+      if (calculate_audio_latency)
+      {
+         /* Frameskip is enabled - increase frontend
+          * audio latency to minimise potential
+          * buffer underruns */
+         uint32_t frame_time_usec = 1000000.0 / (is_pal_mode ? 50.0 : 60.0);
+
+         /* Set latency to 6x current frame time... */
+         retro_audio_latency = (unsigned)(6 * frame_time_usec / 1000);
+
+         /* ...then round up to nearest multiple of 32 */
+         retro_audio_latency = (retro_audio_latency + 0x1F) & ~0x1F;
+      }
+   }
+
+   update_audio_latency = true;
+   frameskip_counter    = 0;
+}
+
 static void update_variables(bool in_flight);
 bool retro_load_game(const struct retro_game_info *info)
 {
    size_t i;
    unsigned int cd_index = 0;
    bool is_m3u = (strcasestr(info->path, ".m3u") != NULL);
+   bool is_exe = (strcasestr(info->path, ".exe") != NULL);
+   int ret;
 
    struct retro_input_descriptor desc[] = {
 #define JOYP(port)                                                                                                \
@@ -1277,8 +1488,12 @@ bool retro_load_game(const struct retro_game_info *info)
       { port, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_X,  "Left Analog X" },  \
       { port, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_Y,  "Left Analog Y" },  \
       { port, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_X, "Right Analog X" }, \
-      { port, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_Y, "Right Analog Y" },
-
+      { port, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_Y, "Right Analog Y" }, \
+      { port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_TRIGGER, "Gun Trigger" },                        \
+      { port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_RELOAD,  "Gun Reload" },                         \
+      { port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_AUX_A,   "Gun Aux A" },                          \
+      { port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_AUX_B,   "Gun Aux B" },
+      
       JOYP(0)
       JOYP(1)
       JOYP(2)
@@ -1391,14 +1606,12 @@ bool retro_load_game(const struct retro_game_info *info)
 
       for (i = 0; i < sizeof(disks) / sizeof(disks[0]) && i < cdrIsoMultidiskCount; i++)
       {
-         char disk_name[PATH_MAX];
-         char disk_label[PATH_MAX];
-         disk_name[0] = '\0';
-         disk_label[0] = '\0';
+         char disk_name[PATH_MAX - 16] = { 0 };
+         char disk_label[PATH_MAX] = { 0 };
 
          disks[i].fname = strdup(info->path);
 
-         get_disk_label(disk_name, info->path, PATH_MAX);
+         get_disk_label(disk_name, info->path, sizeof(disk_name));
          snprintf(disk_label, sizeof(disk_label), "%s #%u", disk_name, (unsigned)i + 1);
          disks[i].flabel = strdup(disk_label);
 
@@ -1439,10 +1652,14 @@ bool retro_load_game(const struct retro_game_info *info)
       }
    }
 
+   /* set ports to use "standard controller" initially */
+   for (i = 0; i < 8; ++i)
+      in_type[i] = PSE_PAD_TYPE_STANDARD;
+
    plugin_call_rearmed_cbs();
-   dfinput_activate();
+   /* dfinput_activate(); */
 
-   if (CheckCdrom() == -1)
+   if (!is_exe && CheckCdrom() == -1)
    {
       log_cb(RETRO_LOG_INFO, "unsupported/invalid CD image: %s\n", info->path);
       return false;
@@ -1450,14 +1667,19 @@ bool retro_load_game(const struct retro_game_info *info)
 
    SysReset();
 
-   if (LoadCdrom() == -1)
+   if (is_exe)
+      ret = Load(info->path);
+   else
+      ret = LoadCdrom();
+   if (ret != 0)
    {
-      log_cb(RETRO_LOG_INFO, "could not load CD\n");
+      log_cb(RETRO_LOG_INFO, "could not load %s (%d)\n", is_exe ? "exe" : "CD", ret);
       return false;
    }
    emu_on_new_cd(0);
 
    set_retro_memmap();
+   retro_set_audio_buff_status_cb();
 
    return true;
 }
@@ -1525,15 +1747,47 @@ static float GunconAdjustRatioY = 1;
 static void update_variables(bool in_flight)
 {
    struct retro_variable var;
-   int i;
 #ifdef GPU_PEOPS
-   int gpu_peops_fix = 0;
+   // Always enable GPU_PEOPS_OLD_FRAME_SKIP flag
+   // (this is set in standalone, with no option
+   // to change it)
+   int gpu_peops_fix = GPU_PEOPS_OLD_FRAME_SKIP;
 #endif
+   frameskip_type_t prev_frameskip_type;
+
+   var.value = NULL;
+   var.key = "pcsx_rearmed_frameskip_type";
+
+   prev_frameskip_type = frameskip_type;
+   frameskip_type = FRAMESKIP_NONE;
+   pl_rearmed_cbs.frameskip = 0;
+
+   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+   {
+      if (strcmp(var.value, "auto") == 0)
+         frameskip_type = FRAMESKIP_AUTO;
+      if (strcmp(var.value, "auto_threshold") == 0)
+         frameskip_type = FRAMESKIP_AUTO_THRESHOLD;
+      if (strcmp(var.value, "fixed_interval") == 0)
+         frameskip_type = FRAMESKIP_FIXED_INTERVAL;
+   }
+
+   if (frameskip_type != 0)
+      pl_rearmed_cbs.frameskip = -1;
+   
+   var.value = NULL;
+   var.key = "pcsx_rearmed_frameskip_threshold";
+   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+   {
+     frameskip_threshold = strtol(var.value, NULL, 10);
+   }
 
    var.value = NULL;
-   var.key = "pcsx_rearmed_frameskip";
+   var.key = "pcsx_rearmed_frameskip_interval";
    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
-      pl_rearmed_cbs.frameskip = atoi(var.value);
+   {
+     frameskip_interval = strtol(var.value, NULL, 10);
+   }   
 
    var.value = NULL;
    var.key = "pcsx_rearmed_region";
@@ -1548,9 +1802,6 @@ static void update_variables(bool in_flight)
          Config.PsxType = 1;
    }
 
-   for (i = 0; i < PORTS_NUMBER; i++)
-      update_controller_port_variable(i);
-
    update_multitap();
 
    var.value = NULL;
@@ -1612,7 +1863,7 @@ static void update_variables(bool in_flight)
          pl_rearmed_cbs.gpu_peops.iUseDither = 0;
          pl_rearmed_cbs.gpu_peopsgl.bDrawDither = 0;
          pl_rearmed_cbs.gpu_unai.dithering = 0;
-#ifdef __ARM_NEON__
+#ifdef GPU_NEON
          pl_rearmed_cbs.gpu_neon.allow_dithering = 0;
 #endif
       }
@@ -1621,7 +1872,7 @@ static void update_variables(bool in_flight)
          pl_rearmed_cbs.gpu_peops.iUseDither    = 1;
          pl_rearmed_cbs.gpu_peopsgl.bDrawDither = 1;
          pl_rearmed_cbs.gpu_unai.dithering = 1;
-#ifdef __ARM_NEON__
+#ifdef GPU_NEON
          pl_rearmed_cbs.gpu_neon.allow_dithering = 1;
 #endif
       }
@@ -1629,7 +1880,7 @@ static void update_variables(bool in_flight)
 
 #ifdef GPU_NEON
    var.value = NULL;
-   var.key = "pcsx_rearmed_neon_interlace_enable";
+   var.key = "pcsx_rearmed_neon_interlace_enable_v2";
 
    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
    {
@@ -1637,6 +1888,8 @@ static void update_variables(bool in_flight)
          pl_rearmed_cbs.gpu_neon.allow_interlace = 0;
       else if (strcmp(var.value, "enabled") == 0)
          pl_rearmed_cbs.gpu_neon.allow_interlace = 1;
+      else // auto
+         pl_rearmed_cbs.gpu_neon.allow_interlace = 2;
    }
 
    var.value = NULL;
@@ -1684,11 +1937,15 @@ static void update_variables(bool in_flight)
          display_internal_fps = true;
    }
 
-#if defined(LIGHTREC) || defined(NEW_DYNAREC)
+   //
+   // CPU emulation related config
+#ifndef DRC_DISABLE
    var.value = NULL;
    var.key = "pcsx_rearmed_drc";
 
-   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+   if (!environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var))
+      var.value = "enabled";
+
    {
       R3000Acpu *prev_cpu = psxCpu;
 #if defined(LIGHTREC)
@@ -1710,83 +1967,158 @@ static void update_variables(bool in_flight)
       psxCpu = (Config.Cpu == CPU_INTERPRETER) ? &psxInt : &psxRec;
       if (psxCpu != prev_cpu)
       {
+         prev_cpu->Notify(R3000ACPU_NOTIFY_BEFORE_SAVE, NULL);
          prev_cpu->Shutdown();
          psxCpu->Init();
-         psxCpu->Reset(); // not really a reset..
+         psxCpu->Reset();
+         psxCpu->Notify(R3000ACPU_NOTIFY_AFTER_LOAD, NULL);
       }
    }
-#endif /* LIGHTREC || NEW_DYNAREC */
+#endif /* !DRC_DISABLE */
 
    var.value = NULL;
-   var.key = "pcsx_rearmed_spu_reverb";
-
+   var.key = "pcsx_rearmed_psxclock";
    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
    {
-      if (strcmp(var.value, "disabled") == 0)
-         spu_config.iUseReverb = false;
-      else if (strcmp(var.value, "enabled") == 0)
-         spu_config.iUseReverb = true;
+      int psxclock = atoi(var.value);
+      Config.cycle_multiplier = 10000 / psxclock;
    }
 
+#if !defined(DRC_DISABLE) && !defined(LIGHTREC)
    var.value = NULL;
-   var.key = "pcsx_rearmed_spu_interpolation";
+   var.key = "pcsx_rearmed_nosmccheck";
+   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+   {
+      if (strcmp(var.value, "enabled") == 0)
+         new_dynarec_hacks |= NDHACK_NO_SMC_CHECK;
+      else
+         new_dynarec_hacks &= ~NDHACK_NO_SMC_CHECK;
+   }
 
+   var.value = NULL;
+   var.key = "pcsx_rearmed_gteregsunneeded";
    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
    {
-      if (strcmp(var.value, "simple") == 0)
-         spu_config.iUseInterpolation = 1;
-      else if (strcmp(var.value, "gaussian") == 0)
-         spu_config.iUseInterpolation = 2;
-      else if (strcmp(var.value, "cubic") == 0)
-         spu_config.iUseInterpolation = 3;
-      else if (strcmp(var.value, "off") == 0)
-         spu_config.iUseInterpolation = 0;
+      if (strcmp(var.value, "enabled") == 0)
+         new_dynarec_hacks |= NDHACK_GTE_UNNEEDED;
+      else
+         new_dynarec_hacks &= ~NDHACK_GTE_UNNEEDED;
    }
 
    var.value = NULL;
-   var.key = "pcsx_rearmed_pe2_fix";
+   var.key = "pcsx_rearmed_nogteflags";
+   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+   {
+      if (strcmp(var.value, "enabled") == 0)
+         new_dynarec_hacks |= NDHACK_GTE_NO_FLAGS;
+      else
+         new_dynarec_hacks &= ~NDHACK_GTE_NO_FLAGS;
+   }
 
+   var.value = NULL;
+   var.key = "pcsx_rearmed_nocompathacks";
    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
    {
-      if (strcmp(var.value, "disabled") == 0)
-         Config.RCntFix = 0;
-      else if (strcmp(var.value, "enabled") == 0)
-         Config.RCntFix = 1;
+      if (strcmp(var.value, "enabled") == 0)
+         new_dynarec_hacks |= NDHACK_NO_COMPAT_HACKS;
+      else
+         new_dynarec_hacks &= ~NDHACK_NO_COMPAT_HACKS;
    }
+#endif /* !DRC_DISABLE && !LIGHTREC */
 
    var.value = NULL;
-   var.key = "pcsx_rearmed_idiablofix";
+   var.key = "pcsx_rearmed_nostalls";
+   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+   {
+      if (strcmp(var.value, "enabled") == 0)
+         Config.DisableStalls = 1;
+      else
+         Config.DisableStalls = 0;
+   }
 
+   var.value = NULL;
+   var.key = "pcsx_rearmed_icache_emulation";
    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
    {
       if (strcmp(var.value, "disabled") == 0)
-         spu_config.idiablofix = 0;
+         Config.icache_emulation = 0;
       else if (strcmp(var.value, "enabled") == 0)
-         spu_config.idiablofix = 1;
+         Config.icache_emulation = 1;
    }
 
    var.value = NULL;
-   var.key = "pcsx_rearmed_inuyasha_fix";
+   var.key = "pcsx_rearmed_exception_emulation";
+   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+   {
+      if (strcmp(var.value, "enabled") == 0)
+         Config.PreciseExceptions = 1;
+      else
+         Config.PreciseExceptions = 0;
+   }
+
+   psxCpu->ApplyConfig();
+
+   // end of CPU emu config
+   //
+
+   var.value = NULL;
+   var.key = "pcsx_rearmed_spu_reverb";
 
    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
    {
       if (strcmp(var.value, "disabled") == 0)
-         Config.VSyncWA = 0;
+         spu_config.iUseReverb = false;
       else if (strcmp(var.value, "enabled") == 0)
-         Config.VSyncWA = 1;
+         spu_config.iUseReverb = true;
    }
 
-#ifndef _WIN32
    var.value = NULL;
-   var.key = "pcsx_rearmed_async_cd";
+   var.key = "pcsx_rearmed_spu_interpolation";
+
+   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+   {
+      if (strcmp(var.value, "simple") == 0)
+         spu_config.iUseInterpolation = 1;
+      else if (strcmp(var.value, "gaussian") == 0)
+         spu_config.iUseInterpolation = 2;
+      else if (strcmp(var.value, "cubic") == 0)
+         spu_config.iUseInterpolation = 3;
+      else if (strcmp(var.value, "off") == 0)
+         spu_config.iUseInterpolation = 0;
+   }
+
+   var.value = NULL;
+   var.key = "pcsx_rearmed_spu_thread";
    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
    {
-      if (strcmp(var.value, "async") == 0)
-         Config.AsyncCD = 1;
+      if (strcmp(var.value, "enabled") == 0)
+         spu_config.iUseThread = 1;
       else
-         Config.AsyncCD = 0;
+         spu_config.iUseThread = 0;
+   }
+
+   if (P_HAVE_PTHREAD) {
+	   var.value = NULL;
+	   var.key = "pcsx_rearmed_async_cd";
+	   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+	   {
+		  if (strcmp(var.value, "async") == 0)
+		  {
+			 Config.AsyncCD = 1;
+			 Config.CHD_Precache = 0;
+		  }
+		  else if (strcmp(var.value, "sync") == 0)
+		  {
+			 Config.AsyncCD = 0;
+			 Config.CHD_Precache = 0;
+		  }
+		  else if (strcmp(var.value, "precache") == 0)
+		  {
+			 Config.AsyncCD = 0;
+			 Config.CHD_Precache = 1;
+		  }
+       }
    }
-#endif
 
    var.value = NULL;
    var.key = "pcsx_rearmed_noxadecoding";
@@ -1809,15 +2141,58 @@ static void update_variables(bool in_flight)
    }
 
    var.value = NULL;
-   var.key = "pcsx_rearmed_spuirq";
+   var.key = "pcsx_rearmed_gpu_slow_llists";
    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
    {
       if (strcmp(var.value, "disabled") == 0)
-         Config.SpuIrq = 0;
-      else
-         Config.SpuIrq = 1;
+         Config.GpuListWalking = 0;
+      else if (strcmp(var.value, "enabled") == 0)
+         Config.GpuListWalking = 1;
+      else // auto
+         Config.GpuListWalking = -1;
    }
 
+   var.value = NULL;
+   var.key = "pcsx_rearmed_screen_centering";
+   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+   {
+      if (strcmp(var.value, "game") == 0)
+         pl_rearmed_cbs.screen_centering_type = 1;
+      else if (strcmp(var.value, "manual") == 0)
+         pl_rearmed_cbs.screen_centering_type = 2;
+      else // auto
+         pl_rearmed_cbs.screen_centering_type = 0;
+   }
+
+   var.value = NULL;
+   var.key = "pcsx_rearmed_screen_centering_x";
+   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+   {
+      pl_rearmed_cbs.screen_centering_x = atoi(var.value);
+   }
+
+   var.value = NULL;
+   var.key = "pcsx_rearmed_screen_centering_y";
+   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+   {
+      pl_rearmed_cbs.screen_centering_y = atoi(var.value);
+   }
+
+#ifdef THREAD_RENDERING
+   var.key = "pcsx_rearmed_gpu_thread_rendering";
+   var.value = NULL;
+
+   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+   {
+      if (strcmp(var.value, "disabled") == 0)
+         pl_rearmed_cbs.thread_rendering = THREAD_RENDERING_OFF;
+      else if (strcmp(var.value, "sync") == 0)
+         pl_rearmed_cbs.thread_rendering = THREAD_RENDERING_SYNC;
+      else if (strcmp(var.value, "async") == 0)
+         pl_rearmed_cbs.thread_rendering = THREAD_RENDERING_ASYNC;
+   }
+#endif
+
 #ifdef GPU_PEOPS
    var.value = NULL;
    var.key = "pcsx_rearmed_gpu_peops_odd_even_bit";
@@ -1864,15 +2239,6 @@ static void update_variables(bool in_flight)
          gpu_peops_fix |= GPU_PEOPS_LAZY_SCREEN_UPDATE;
    }
 
-   var.value = NULL;
-   var.key = "pcsx_rearmed_gpu_peops_old_frame_skip";
-
-   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
-   {
-      if (strcmp(var.value, "enabled") == 0)
-         gpu_peops_fix |= GPU_PEOPS_OLD_FRAME_SKIP;
-   }
-
    var.value = NULL;
    var.key = "pcsx_rearmed_gpu_peops_repeated_triangles";
 
@@ -1902,69 +2268,18 @@ static void update_variables(bool in_flight)
 
    if (pl_rearmed_cbs.gpu_peops.dwActFixes != gpu_peops_fix)
       pl_rearmed_cbs.gpu_peops.dwActFixes = gpu_peops_fix;
-
-   /* Show/hide core options */
-
-   var.key = "pcsx_rearmed_show_gpu_peops_settings";
-   var.value = NULL;
-
-   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
-   {
-      int show_advanced_gpu_peops_settings_prev = show_advanced_gpu_peops_settings;
-
-      show_advanced_gpu_peops_settings = 1;
-      if (strcmp(var.value, "disabled") == 0)
-         show_advanced_gpu_peops_settings = 0;
-
-      if (show_advanced_gpu_peops_settings != show_advanced_gpu_peops_settings_prev)
-      {
-         unsigned i;
-         struct retro_core_option_display option_display;
-         char gpu_peops_option[9][45] = {
-            "pcsx_rearmed_gpu_peops_odd_even_bit",
-            "pcsx_rearmed_gpu_peops_expand_screen_width",
-            "pcsx_rearmed_gpu_peops_ignore_brightness",
-            "pcsx_rearmed_gpu_peops_disable_coord_check",
-            "pcsx_rearmed_gpu_peops_lazy_screen_update",
-            "pcsx_rearmed_gpu_peops_old_frame_skip",
-            "pcsx_rearmed_gpu_peops_repeated_triangles",
-            "pcsx_rearmed_gpu_peops_quads_with_triangles",
-            "pcsx_rearmed_gpu_peops_fake_busy_state"
-         };
-
-         option_display.visible = show_advanced_gpu_peops_settings;
-
-         for (i = 0; i < 9; i++)
-         {
-            option_display.key = gpu_peops_option[i];
-            environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_DISPLAY, &option_display);
-         }
-      }
-   }
 #endif
 
 #ifdef GPU_UNAI
-   var.key = "pcsx_rearmed_gpu_unai_ilace_force";
-   var.value = NULL;
-
-   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
-   {
-      if (strcmp(var.value, "disabled") == 0)
-         pl_rearmed_cbs.gpu_unai.ilace_force = 0;
-      else if (strcmp(var.value, "enabled") == 0)
-         pl_rearmed_cbs.gpu_unai.ilace_force = 1;
-   }
-
-   var.key = "pcsx_rearmed_gpu_unai_pixel_skip";
-   var.value = NULL;
-
-   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
-   {
-      if (strcmp(var.value, "disabled") == 0)
-         pl_rearmed_cbs.gpu_unai.pixel_skip = 0;
-      else if (strcmp(var.value, "enabled") == 0)
-         pl_rearmed_cbs.gpu_unai.pixel_skip = 1;
-   }
+   /* Note: This used to be an option, but it only works
+    * (correctly) when running high resolution games
+    * (480i, 512i) and has been obsoleted by
+    * pcsx_rearmed_gpu_unai_scale_hires */
+   pl_rearmed_cbs.gpu_unai.ilace_force = 0;
+   /* Note: This used to be an option, but it has no
+    * discernable effect and has been obsoleted by
+    * pcsx_rearmed_gpu_unai_scale_hires */
+   pl_rearmed_cbs.gpu_unai.pixel_skip = 0;
 
    var.key = "pcsx_rearmed_gpu_unai_lighting";
    var.value = NULL;
@@ -2009,40 +2324,6 @@ static void update_variables(bool in_flight)
       else if (strcmp(var.value, "enabled") == 0)
          pl_rearmed_cbs.gpu_unai.scale_hires = 1;
    }
-
-   var.key = "pcsx_rearmed_show_gpu_unai_settings";
-   var.value = NULL;
-
-   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
-   {
-      int show_advanced_gpu_unai_settings_prev = show_advanced_gpu_unai_settings;
-
-      show_advanced_gpu_unai_settings = 1;
-      if (strcmp(var.value, "disabled") == 0)
-         show_advanced_gpu_unai_settings = 0;
-
-      if (show_advanced_gpu_unai_settings != show_advanced_gpu_unai_settings_prev)
-      {
-         unsigned i;
-         struct retro_core_option_display option_display;
-         char gpu_unai_option[6][40] = {
-            "pcsx_rearmed_gpu_unai_blending",
-            "pcsx_rearmed_gpu_unai_lighting",
-            "pcsx_rearmed_gpu_unai_fast_lighting",
-            "pcsx_rearmed_gpu_unai_ilace_force",
-            "pcsx_rearmed_gpu_unai_pixel_skip",
-            "pcsx_rearmed_gpu_unai_scale_hires"
-         };
-
-         option_display.visible = show_advanced_gpu_unai_settings;
-
-         for (i = 0; i < 6; i++)
-         {
-            option_display.key = gpu_unai_option[i];
-            environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_DISPLAY, &option_display);
-         }
-      }
-   }
 #endif // GPU_UNAI
 
    //This adjustment process gives the user the ability to manually align the mouse up better
@@ -2080,47 +2361,6 @@ static void update_variables(bool in_flight)
       GunconAdjustRatioY = atof(var.value);
    }
 
-#ifdef NEW_DYNAREC
-   var.value = NULL;
-   var.key = "pcsx_rearmed_nosmccheck";
-   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
-   {
-      if (strcmp(var.value, "enabled") == 0)
-         new_dynarec_hacks |= NDHACK_NO_SMC_CHECK;
-      else
-         new_dynarec_hacks &= ~NDHACK_NO_SMC_CHECK;
-   }
-
-   var.value = NULL;
-   var.key = "pcsx_rearmed_gteregsunneeded";
-   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
-   {
-      if (strcmp(var.value, "enabled") == 0)
-         new_dynarec_hacks |= NDHACK_GTE_UNNEEDED;
-      else
-         new_dynarec_hacks &= ~NDHACK_GTE_UNNEEDED;
-   }
-
-   var.value = NULL;
-   var.key = "pcsx_rearmed_nogteflags";
-   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
-   {
-      if (strcmp(var.value, "enabled") == 0)
-         new_dynarec_hacks |= NDHACK_GTE_NO_FLAGS;
-      else
-         new_dynarec_hacks &= ~NDHACK_GTE_NO_FLAGS;
-   }
-
-   /* this probably is safe to change in real-time */
-   var.value = NULL;
-   var.key = "pcsx_rearmed_psxclock";
-   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
-   {
-      int psxclock = atoi(var.value);
-      cycle_multiplier = 10000 / psxclock;
-   }
-#endif /* NEW_DYNAREC */
-
    var.value = NULL;
    var.key = "pcsx_rearmed_input_sensitivity";
    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
@@ -2128,50 +2368,6 @@ static void update_variables(bool in_flight)
       mouse_sensitivity = atof(var.value);
    }
 
-   var.key = "pcsx_rearmed_show_other_input_settings";
-   var.value = NULL;
-
-   if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
-   {
-      int previous_settings = show_other_input_settings;
-
-      show_other_input_settings = 1;
-      if (strcmp(var.value, "disabled") == 0)
-         show_other_input_settings = 0;
-
-      if (show_other_input_settings != previous_settings)
-      {
-         unsigned i;
-         struct retro_core_option_display option_display;
-         char gpu_peops_option[][50] = {
-            "pcsx_rearmed_multitap1",
-            "pcsx_rearmed_multitap2",
-            "pcsx_rearmed_pad3type",
-            "pcsx_rearmed_pad4type",
-            "pcsx_rearmed_pad5type",
-            "pcsx_rearmed_pad6type",
-            "pcsx_rearmed_pad7type",
-            "pcsx_rearmed_pad8type",
-            "pcsx_rearmed_negcon_deadzone",
-            "pcsx_rearmed_negcon_response",
-            "pcsx_rearmed_analog_axis_modifier",
-            "pcsx_rearmed_gunconadjustx",
-            "pcsx_rearmed_gunconadjusty",
-            "pcsx_rearmed_gunconadjustratiox",
-            "pcsx_rearmed_gunconadjustratioy"
-         };
-         #define INPUT_LIST (sizeof(gpu_peops_option) / sizeof(gpu_peops_option[0]))
-
-         option_display.visible = show_other_input_settings;
-
-         for (i = 0; i < INPUT_LIST; i++)
-         {
-            option_display.key = gpu_peops_option[i];
-            environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_DISPLAY, &option_display);
-         }
-      }
-   }
-
    if (in_flight)
    {
       // inform core things about possible config changes
@@ -2183,7 +2379,11 @@ static void update_variables(bool in_flight)
          GPU_open(&gpuDisp, "PCSX", NULL);
       }
 
-      dfinput_activate();
+      /* Reinitialise frameskipping, if required */
+      if (((frameskip_type     != prev_frameskip_type)))
+         retro_set_audio_buff_status_cb();
+
+      /* dfinput_activate(); */
    }
    else
    {
@@ -2206,6 +2406,8 @@ static void update_variables(bool in_flight)
          }
       }
    }
+
+   update_option_visibility();
 }
 
 // Taken from beetle-psx-libretro
@@ -2261,44 +2463,44 @@ unsigned char axis_range_modifier(int16_t axis_value, bool is_square)
 
 static void update_input_guncon(int port, int ret)
 {
-   //ToDo move across to:
-   //RETRO_DEVICE_ID_LIGHTGUN_SCREEN_X
-   //RETRO_DEVICE_ID_LIGHTGUN_SCREEN_Y
-   //RETRO_DEVICE_ID_LIGHTGUN_TRIGGER
-   //RETRO_DEVICE_ID_LIGHTGUN_RELOAD
-   //RETRO_DEVICE_ID_LIGHTGUN_AUX_A
-   //RETRO_DEVICE_ID_LIGHTGUN_AUX_B
-   //Though not sure these are hooked up properly on the Pi
+   //ToDo:
+   //Core option for cursors for both players
+   //Separate pointer and lightgun control types
+
+   //Mouse range is -32767 -> 32767
+   //1% is about 655
+   //Use the left analog stick field to store the absolute coordinates
 
+   int gunx = input_state_cb(port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_SCREEN_X);
+   int guny = input_state_cb(port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_SCREEN_Y);
+
+   //Have the Libretro API let /libpcsxcore/plugins.c know when the lightgun is pointed offscreen
+   //Offscreen value is chosen to be well out of range of any possible scaling done via core options
+   if (input_state_cb(port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_IS_OFFSCREEN) || input_state_cb(port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_RELOAD))
+   {
+      in_analog_left[port][0] = (65536 - 512) * 64;
+      in_analog_left[port][1] = (65536 - 512) * 64;
+   }
+   else
+   {
+      in_analog_left[port][0] = (gunx * GunconAdjustRatioX) + (GunconAdjustX * 655);
+      in_analog_left[port][1] = (guny * GunconAdjustRatioY) + (GunconAdjustY * 655);
+   }
+	
    //GUNCON has 3 controls, Trigger,A,B which equal Circle,Start,Cross
 
    // Trigger
-   //The 1 is hardcoded instead of port to prevent the overlay mouse button libretro crash bug
-   if (input_state_cb(port, RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_LEFT))
-   {
+   if (input_state_cb(port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_TRIGGER) || input_state_cb(port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_RELOAD))
       in_keystate[port] |= (1 << DKEY_CIRCLE);
-   }
 
    // A
-   if (input_state_cb(port, RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_RIGHT))
-   {
+   if (input_state_cb(port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_AUX_A))
       in_keystate[port] |= (1 << DKEY_START);
-   }
 
    // B
-   if (input_state_cb(port, RETRO_DEVICE_MOUSE, 0, RETRO_DEVICE_ID_MOUSE_MIDDLE))
-   {
+   if (input_state_cb(port, RETRO_DEVICE_LIGHTGUN, 0, RETRO_DEVICE_ID_LIGHTGUN_AUX_B))
       in_keystate[port] |= (1 << DKEY_CROSS);
-   }
-
-   int gunx = input_state_cb(port, RETRO_DEVICE_POINTER, 0, RETRO_DEVICE_ID_POINTER_X);
-   int guny = input_state_cb(port, RETRO_DEVICE_POINTER, 0, RETRO_DEVICE_ID_POINTER_Y);
-
-   //Mouse range is -32767 -> 32767
-   //1% is about 655
-   //Use the left analog stick field to store the absolute coordinates
-   in_analog_left[port][0] = (gunx * GunconAdjustRatioX) + (GunconAdjustX * 655);
-   in_analog_left[port][1] = (guny * GunconAdjustRatioY) + (GunconAdjustY * 655);
+	   
 }
 
 static void update_input_negcon(int port, int ret)
@@ -2545,14 +2747,51 @@ void retro_run(void)
    {
       rebootemu = 0;
       SysReset();
-      if (!Config.HLE && !Config.SlowBoot)
+      if (Config.HLE)
+         LoadCdrom();
+   }
+
+   print_internal_fps();
+
+   /* Check whether current frame should
+    * be skipped */
+   pl_rearmed_cbs.fskip_force = 0;
+   pl_rearmed_cbs.fskip_dirty = 0;
+
+   if (frameskip_type != FRAMESKIP_NONE)
+   {
+      bool skip_frame = false;
+
+      switch (frameskip_type)
       {
-         // skip BIOS logos
-         psxRegs.pc = psxRegs.GPR.n.ra;
+         case FRAMESKIP_AUTO:
+            skip_frame = retro_audio_buff_active && retro_audio_buff_underrun;
+            break;
+         case FRAMESKIP_AUTO_THRESHOLD:
+            skip_frame = retro_audio_buff_active && (retro_audio_buff_occupancy < frameskip_threshold);
+            break;
+         case FRAMESKIP_FIXED_INTERVAL:
+            skip_frame = true;
+            break;
+         default:
+            break;
       }
+
+      if (skip_frame && frameskip_counter < frameskip_interval)
+         pl_rearmed_cbs.fskip_force = 1;
    }
 
-   print_internal_fps();
+   /* If frameskip/timing settings have changed,
+    * update frontend audio latency
+    * > Can do this before or after the frameskip
+    *   check, but doing it after means we at least
+    *   retain the current frame's audio output */
+   if (update_audio_latency)
+   {
+      environ_cb(RETRO_ENVIRONMENT_SET_MINIMUM_AUDIO_LATENCY,
+            &retro_audio_latency);
+      update_audio_latency = false;
+   }
 
    input_poll_cb();
 
@@ -2565,6 +2804,13 @@ void retro_run(void)
    stop = 0;
    psxCpu->Execute();
 
+   if (pl_rearmed_cbs.fskip_dirty == 1) {
+      if (frameskip_counter < frameskip_interval)
+         frameskip_counter++;
+      else if (frameskip_counter >= frameskip_interval || !pl_rearmed_cbs.fskip_force)
+         frameskip_counter = 0;
+   }
+
    video_cb((vout_fb_dirty || !vout_can_dupe || !duping_enable) ? vout_buf_ptr : NULL,
        vout_width, vout_height, vout_width * 2);
    vout_fb_dirty = 0;
@@ -2574,17 +2820,15 @@ void retro_run(void)
 
 static bool try_use_bios(const char *path)
 {
-   FILE *f;
    long size;
    const char *name;
-
-   f = fopen(path, "rb");
-   if (f == NULL)
+   FILE *fp = fopen(path, "rb");
+   if (fp == NULL)
       return false;
 
-   fseek(f, 0, SEEK_END);
-   size = ftell(f);
-   fclose(f);
+   fseek(fp, 0, SEEK_END);
+   size = ftell(fp);
+   fclose(fp);
 
    if (size != 512 * 1024)
       return false;
@@ -2602,23 +2846,36 @@ static bool try_use_bios(const char *path)
 
 static bool find_any_bios(const char *dirpath, char *path, size_t path_size)
 {
+   static const char *substrings[] = { "scph", "ps", "openbios" };
    DIR *dir;
    struct dirent *ent;
    bool ret = false;
+   size_t i;
 
    dir = opendir(dirpath);
    if (dir == NULL)
       return false;
 
-   while ((ent = readdir(dir)))
+   for (i = 0; i < (sizeof(substrings) / sizeof(substrings[0])); i++)
    {
-      if ((strncasecmp(ent->d_name, "scph", 4) != 0) && (strncasecmp(ent->d_name, "psx", 3) != 0))
-         continue;
-
-      snprintf(path, path_size, "%s%c%s", dirpath, SLASH, ent->d_name);
-      ret = try_use_bios(path);
-      if (ret)
-         break;
+      const char *substr = substrings[i];
+      size_t len = strlen(substr);
+      rewinddir(dir);
+      while ((ent = readdir(dir)))
+      {
+         if ((strncasecmp(ent->d_name, substr, len) != 0))
+            continue;
+         if (strstr(ent->d_name, "unirom"))
+            continue;
+
+         snprintf(path, path_size, "%s%c%s", dirpath, SLASH, ent->d_name);
+         ret = try_use_bios(path);
+         if (ret)
+         {
+            closedir(dir);
+            return ret;
+         }
+      }
    }
    closedir(dir);
    return ret;
@@ -2730,11 +2987,19 @@ static void loadPSXBios(void)
       }
    }
 
-   if (useHLE || !found_bios)
+   if (!found_bios)
    {
-      const char *msg_str = "No PlayStation BIOS file found - add for better compatibility";
-
-      SysPrintf("no BIOS files found.\n");
+      const char *msg_str;
+      if (useHLE)
+      {
+         msg_str = "BIOS set to \'hle\' in core options - real BIOS will be ignored";
+         SysPrintf("Using HLE BIOS.\n");
+      }
+      else
+      {
+         msg_str = "No PlayStation BIOS file found - add for better compatibility";
+         SysPrintf("No BIOS files found.\n");
+      }
 
       if (msg_interface_version >= 1)
       {
@@ -2769,7 +3034,7 @@ void retro_init(void)
    msg_interface_version = 0;
    environ_cb(RETRO_ENVIRONMENT_GET_MESSAGE_INTERFACE_VERSION, &msg_interface_version);
 
-#ifdef __MACH__
+#if defined(__MACH__) && !defined(TVOS)
    // magic sauce to make the dynarec work on iOS
    syscall(SYS_ptrace, 0 /*PTRACE_TRACEME*/, 0, 0, 0);
 #endif
@@ -2801,8 +3066,9 @@ void retro_init(void)
 
 #ifdef _3DS
    vout_buf = linearMemAlign(VOUT_MAX_WIDTH * VOUT_MAX_HEIGHT * 2, 0x80);
-#elif defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200112L) && !defined(VITA) && !defined(__SWITCH__)
-   posix_memalign(&vout_buf, 16, VOUT_MAX_WIDTH * VOUT_MAX_HEIGHT * 2);
+#elif defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200112L) && P_HAVE_POSIX_MEMALIGN
+   if (posix_memalign(&vout_buf, 16, VOUT_MAX_WIDTH * VOUT_MAX_HEIGHT * 2) != 0)
+      vout_buf = (void *) 0;
 #else
    vout_buf = malloc(VOUT_MAX_WIDTH * VOUT_MAX_HEIGHT * 2);
 #endif
@@ -2827,9 +3093,9 @@ void retro_init(void)
    /* Set how much slower PSX CPU runs * 100 (so that 200 is 2 times)
     * we have to do this because cache misses and some IO penalties
     * are not emulated. Warning: changing this may break compatibility. */
-   cycle_multiplier = 175;
+   Config.cycle_multiplier = CYCLE_MULT_DEFAULT;
 #if defined(HAVE_PRE_ARMV7) && !defined(_3DS)
-   cycle_multiplier = 200;
+   Config.cycle_multiplier = 200;
 #endif
    pl_rearmed_cbs.gpu_peops.iUseDither = 1;
    pl_rearmed_cbs.gpu_peops.dwActFixes = GPU_PEOPS_OLD_FRAME_SKIP;
@@ -2866,10 +3132,28 @@ void retro_deinit(void)
    deinit_vita_mmap();
 #endif
    libretro_supports_bitmasks = false;
+   libretro_supports_option_categories = false;
+
+   show_input_settings = true;
+#ifdef GPU_PEOPS
+   show_advanced_gpu_peops_settings = true;
+#endif
+#ifdef GPU_UNAI
+   show_advanced_gpu_unai_settings = true;
+#endif
 
    /* Have to reset disks struct, otherwise
     * fnames/flabels will leak memory */
    disk_init();
+   frameskip_type             = FRAMESKIP_NONE;
+   frameskip_threshold        = 0;
+   frameskip_interval         = 0;
+   frameskip_counter          = 0;
+   retro_audio_buff_active    = false;
+   retro_audio_buff_occupancy = 0;
+   retro_audio_buff_underrun  = false;
+   retro_audio_latency        = 0;
+   update_audio_latency       = false;
 }
 
 #ifdef VITA
@@ -2906,3 +3190,5 @@ void SysDLog(const char *fmt, ...)
    if (log_cb)
       log_cb(RETRO_LOG_DEBUG, "%s", msg);
 }
+
+// vim:sw=3:ts=3:expandtab