frontend/libretro.c

   1 /*
   2  * (C) notaz, 2012,2014,2015
   3  *
   4  * This work is licensed under the terms of the GNU GPLv2 or later.
   5  * See the COPYING file in the top-level directory.
   6  */
   7
   8 #define _GNU_SOURCE 1 // strcasestr
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <strings.h>
  13 #ifdef __MACH__
  14 #include <unistd.h>
  15 #include <sys/syscall.h>
  16 #endif
  17
  18 #include "../libpcsxcore/misc.h"
  19 #include "../libpcsxcore/psxcounters.h"
  20 #include "../libpcsxcore/psxmem_map.h"
  21 #include "../libpcsxcore/new_dynarec/new_dynarec.h"
  22 #include "../libpcsxcore/cdrom.h"
  23 #include "../libpcsxcore/cdriso.h"
  24 #include "../libpcsxcore/cheat.h"
  25 #include "../libpcsxcore/r3000a.h"
  26 #include "../plugins/dfsound/out.h"
  27 #include "../plugins/dfsound/spu_config.h"
  28 #include "../plugins/dfinput/externals.h"
  29 #include "cspace.h"
  30 #include "main.h"
  31 #include "menu.h"
  32 #include "plugin.h"
  33 #include "plugin_lib.h"
  34 #include "arm_features.h"
  35 #include "revision.h"
  36 #include "libretro.h"
  37
  38 #ifdef _3DS
  39 #include "3ds/3ds_utils.h"
  40 #endif
  41
  42 #define PORTS_NUMBER 8
  43
  44 #ifndef MIN
  45 #define MIN(a, b) ((a) < (b) ? (a) : (b))
  46 #endif
  47
  48 #ifndef MAX
  49 #define MAX(a, b) ((a) > (b) ? (a) : (b))
  50 #endif
  51
  52 #define ISHEXDEC ((buf[cursor]>='0') && (buf[cursor]<='9')) || ((buf[cursor]>='a') && (buf[cursor]<='f')) || ((buf[cursor]>='A') && (buf[cursor]<='F'))
  53
  54 #define INTERNAL_FPS_SAMPLE_PERIOD 64
  55
  56 //hack to prevent retroarch freezing when reseting in the menu but not while running with the hot key
  57 static int rebootemu = 0;
  58
  59 static retro_video_refresh_t video_cb;
  60 static retro_input_poll_t input_poll_cb;
  61 static retro_input_state_t input_state_cb;
  62 static retro_environment_t environ_cb;
  63 static retro_audio_sample_batch_t audio_batch_cb;
  64 static retro_set_rumble_state_t rumble_cb;
  65 static struct retro_log_callback logging;
  66 static retro_log_printf_t log_cb;
  67
  68 static void *vout_buf;
  69 static void * vout_buf_ptr;
  70 static int vout_width, vout_height;
  71 static int vout_doffs_old, vout_fb_dirty;
  72 static bool vout_can_dupe;
  73 static bool duping_enable;
  74 static bool found_bios;
  75 static bool display_internal_fps = false;
  76 static unsigned frame_count = 0;
  77
  78 static int plugins_opened;
  79 static int is_pal_mode;
  80
  81 /* memory card data */
  82 extern char Mcd1Data[MCD_SIZE];
  83 extern char Mcd2Data[MCD_SIZE];
  84 extern char McdDisable[2];
  85
  86 /* PCSX ReARMed core calls and stuff */
  87 int in_type[8] =  { PSE_PAD_TYPE_NONE, PSE_PAD_TYPE_NONE,
  88                   PSE_PAD_TYPE_NONE, PSE_PAD_TYPE_NONE,
  89                   PSE_PAD_TYPE_NONE, PSE_PAD_TYPE_NONE,
  90                   PSE_PAD_TYPE_NONE, PSE_PAD_TYPE_NONE };
  91 int in_analog_left[8][2] = {{ 127, 127 },{ 127, 127 },{ 127, 127 },{ 127, 127 },{ 127, 127 },{ 127, 127 },{ 127, 127 },{ 127, 127 }};
  92 int in_analog_right[8][2] = {{ 127, 127 },{ 127, 127 },{ 127, 127 },{ 127, 127 },{ 127, 127 },{ 127, 127 },{ 127, 127 },{ 127, 127 }};
  93 unsigned short in_keystate[PORTS_NUMBER];
  94 int multitap1 = 0;
  95 int multitap2 = 0;
  96 int in_enable_vibration = 1;
  97
  98 // NegCon adjustment parameters
  99 // > The NegCon 'twist' action is somewhat awkward when mapped
 100 //   to a standard analog stick -> user should be able to tweak
 101 //   response/deadzone for comfort
 102 // > When response is linear, 'additional' deadzone (set here)
 103 //   may be left at zero, since this is normally handled via in-game
 104 //   options menus
 105 // > When response is non-linear, deadzone should be set to match the
 106 //   controller being used (otherwise precision may be lost)
 107 // > negcon_linearity:
 108 //   - 1: Response is linear - recommended when using racing wheel
 109 //        peripherals, not recommended for standard gamepads
 110 //   - 2: Response is quadratic - optimal setting for gamepads
 111 //   - 3: Response is cubic - enables precise fine control, but
 112 //        difficult to use...
 113 #define NEGCON_RANGE 0x7FFF
 114 static int negcon_deadzone = 0;
 115 static int negcon_linearity = 1;
 116
 117 /* PSX max resolution is 640x512, but with enhancement it's 1024x512 */
 118 #define VOUT_MAX_WIDTH 1024
 119 #define VOUT_MAX_HEIGHT 512
 120
 121 //Dummy functions
 122 bool retro_load_game_special(unsigned game_type, const struct retro_game_info *info, size_t num_info){return false;}
 123 void retro_unload_game(void){}
 124 static int vout_open(void){return 0;}
 125 static void vout_close(void){}
 126 static int snd_init(void){return 0;}
 127 static void snd_finish(void){}
 128 static int snd_busy(void){return 0;}
 129
 130 static void init_memcard(char *mcd_data)
 131 {
 132         unsigned off = 0;
 133         unsigned i;
 134
 135         memset(mcd_data, 0, MCD_SIZE);
 136
 137         mcd_data[off++] = 'M';
 138         mcd_data[off++] = 'C';
 139         off += 0x7d;
 140         mcd_data[off++] = 0x0e;
 141
 142         for (i = 0; i < 15; i++) {
 143                 mcd_data[off++] = 0xa0;
 144                 off += 0x07;
 145                 mcd_data[off++] = 0xff;
 146                 mcd_data[off++] = 0xff;
 147                 off += 0x75;
 148                 mcd_data[off++] = 0xa0;
 149         }
 150
 151         for (i = 0; i < 20; i++) {
 152                 mcd_data[off++] = 0xff;
 153                 mcd_data[off++] = 0xff;
 154                 mcd_data[off++] = 0xff;
 155                 mcd_data[off++] = 0xff;
 156                 off += 0x04;
 157                 mcd_data[off++] = 0xff;
 158                 mcd_data[off++] = 0xff;
 159                 off += 0x76;
 160         }
 161 }
 162
 163 static void set_vout_fb()
 164 {
 165   struct retro_framebuffer fb = {0};
 166
 167   fb.width           = vout_width;
 168   fb.height          = vout_height;
 169   fb.access_flags    = RETRO_MEMORY_ACCESS_WRITE;
 170
 171   if (environ_cb(RETRO_ENVIRONMENT_GET_CURRENT_SOFTWARE_FRAMEBUFFER, &fb) && fb.format == RETRO_PIXEL_FORMAT_RGB565)
 172      vout_buf_ptr = (uint16_t*)fb.data;
 173   else
 174      vout_buf_ptr = vout_buf;
 175 }
 176
 177 static void vout_set_mode(int w, int h, int raw_w, int raw_h, int bpp)
 178 {
 179   vout_width = w;
 180   vout_height = h;
 181
 182   set_vout_fb();
 183 }
 184
 185 #ifndef FRONTEND_SUPPORTS_RGB565
 186 static void convert(void *buf, size_t bytes)
 187 {
 188         unsigned int i, v, *p = buf;
 189
 190         for (i = 0; i < bytes / 4; i++) {
 191                 v = p[i];
 192                 p[i] = (v & 0x001f001f) | ((v >> 1) & 0x7fe07fe0);
 193         }
 194 }
 195 #endif
 196
 197 static void vout_flip(const void *vram, int stride, int bgr24, int w, int h)
 198 {
 199         unsigned short *dest = vout_buf_ptr;
 200         const unsigned short *src = vram;
 201         int dstride = vout_width, h1 = h;
 202         int doffs;
 203
 204         if (vram == NULL) {
 205                 // blanking
 206                 memset(vout_buf_ptr, 0, dstride * h * 2);
 207                 goto out;
 208         }
 209
 210         doffs = (vout_height - h) * dstride;
 211         doffs += (dstride - w) / 2 & ~1;
 212         if (doffs != vout_doffs_old) {
 213                 // clear borders
 214                 memset(vout_buf_ptr, 0, dstride * h * 2);
 215                 vout_doffs_old = doffs;
 216         }
 217         dest += doffs;
 218
 219         if (bgr24)
 220         {
 221                 // XXX: could we switch to RETRO_PIXEL_FORMAT_XRGB8888 here?
 222                 for (; h1-- > 0; dest += dstride, src += stride)
 223                 {
 224                         bgr888_to_rgb565(dest, src, w * 3);
 225                 }
 226         }
 227         else
 228         {
 229                 for (; h1-- > 0; dest += dstride, src += stride)
 230                 {
 231                         bgr555_to_rgb565(dest, src, w * 2);
 232                 }
 233         }
 234
 235 out:
 236 #ifndef FRONTEND_SUPPORTS_RGB565
 237         convert(vout_buf_ptr, vout_width * vout_height * 2);
 238 #endif
 239         vout_fb_dirty = 1;
 240         pl_rearmed_cbs.flip_cnt++;
 241 }
 242
 243 #ifdef _3DS
 244 typedef struct
 245 {
 246    void* buffer;
 247    uint32_t target_map;
 248    size_t size;
 249    enum psxMapTag tag;
 250 }psx_map_t;
 251
 252 psx_map_t custom_psx_maps[] = {
 253    {NULL, 0x13000000, 0x210000, MAP_TAG_RAM},   // 0x80000000
 254    {NULL, 0x12800000, 0x010000, MAP_TAG_OTHER}, // 0x1f800000
 255    {NULL, 0x12c00000, 0x080000, MAP_TAG_OTHER}, // 0x1fc00000
 256    {NULL, 0x11000000, 0x800000, MAP_TAG_LUTS},  // 0x08000000
 257    {NULL, 0x12000000, 0x200000, MAP_TAG_VRAM},  // 0x00000000
 258 };
 259
 260 void* pl_3ds_mmap(unsigned long addr, size_t size, int is_fixed,
 261         enum psxMapTag tag)
 262 {
 263    (void)is_fixed;
 264    (void)addr;
 265
 266    if (__ctr_svchax)
 267    {
 268       psx_map_t* custom_map = custom_psx_maps;
 269
 270       for (; custom_map->size; custom_map++)
 271       {
 272          if ((custom_map->size == size) && (custom_map->tag == tag))
 273          {
 274             uint32_t ptr_aligned, tmp;
 275
 276             custom_map->buffer = malloc(size + 0x1000);
 277             ptr_aligned = (((u32)custom_map->buffer) + 0xFFF) & ~0xFFF;
 278
 279             if(svcControlMemory(&tmp, (void*)custom_map->target_map, (void*)ptr_aligned, size, MEMOP_MAP, 0x3) < 0)
 280             {
 281                SysPrintf("could not map memory @0x%08X\n", custom_map->target_map);
 282                exit(1);
 283             }
 284
 285             return (void*)custom_map->target_map;
 286          }
 287       }
 288    }
 289
 290    return malloc(size);
 291 }
 292
 293 void pl_3ds_munmap(void *ptr, size_t size, enum psxMapTag tag)
 294 {
 295    (void)tag;
 296
 297    if (__ctr_svchax)
 298    {
 299       psx_map_t* custom_map = custom_psx_maps;
 300
 301       for (; custom_map->size; custom_map++)
 302       {
 303          if ((custom_map->target_map == (uint32_t)ptr))
 304          {
 305             uint32_t ptr_aligned, tmp;
 306
 307             ptr_aligned = (((u32)custom_map->buffer) + 0xFFF) & ~0xFFF;
 308
 309             svcControlMemory(&tmp, (void*)custom_map->target_map, (void*)ptr_aligned, size, MEMOP_UNMAP, 0x3);
 310
 311             free(custom_map->buffer);
 312             custom_map->buffer = NULL;
 313             return;
 314          }
 315       }
 316    }
 317
 318    free(ptr);
 319 }
 320 #endif
 321
 322 #ifdef VITA
 323 typedef struct
 324 {
 325    void* buffer;
 326    uint32_t target_map;
 327    size_t size;
 328    enum psxMapTag tag;
 329 }psx_map_t;
 330
 331 void* addr = NULL;
 332
 333 psx_map_t custom_psx_maps[] = {
 334    {NULL, NULL, 0x210000, MAP_TAG_RAM},   // 0x80000000
 335    {NULL, NULL, 0x010000, MAP_TAG_OTHER}, // 0x1f800000
 336    {NULL, NULL, 0x080000, MAP_TAG_OTHER}, // 0x1fc00000
 337    {NULL, NULL, 0x800000, MAP_TAG_LUTS},  // 0x08000000
 338    {NULL, NULL, 0x200000, MAP_TAG_VRAM},  // 0x00000000
 339 };
 340
 341 int init_vita_mmap(){
 342   int n;
 343   void * tmpaddr;
 344   addr = malloc(64*1024*1024);
 345   if(addr==NULL)
 346     return -1;
 347   tmpaddr = ((u32)(addr+0xFFFFFF))&~0xFFFFFF;
 348   custom_psx_maps[0].buffer=tmpaddr+0x2000000;
 349   custom_psx_maps[1].buffer=tmpaddr+0x1800000;
 350   custom_psx_maps[2].buffer=tmpaddr+0x1c00000;
 351   custom_psx_maps[3].buffer=tmpaddr+0x0000000;
 352   custom_psx_maps[4].buffer=tmpaddr+0x1000000;
 353 #if 0
 354   for(n = 0; n < 5; n++){
 355     sceClibPrintf("addr reserved %x\n",custom_psx_maps[n].buffer);
 356   }
 357 #endif
 358   return 0;
 359 }
 360
 361 void deinit_vita_mmap(){
 362   free(addr);
 363 }
 364
 365 void* pl_vita_mmap(unsigned long addr, size_t size, int is_fixed,
 366         enum psxMapTag tag)
 367 {
 368    (void)is_fixed;
 369    (void)addr;
 370
 371
 372     psx_map_t* custom_map = custom_psx_maps;
 373
 374     for (; custom_map->size; custom_map++)
 375     {
 376        if ((custom_map->size == size) && (custom_map->tag == tag))
 377        {
 378           return custom_map->buffer;
 379        }
 380     }
 381
 382
 383    return malloc(size);
 384 }
 385
 386 void pl_vita_munmap(void *ptr, size_t size, enum psxMapTag tag)
 387 {
 388    (void)tag;
 389
 390    psx_map_t* custom_map = custom_psx_maps;
 391
 392   for (; custom_map->size; custom_map++)
 393   {
 394      if ((custom_map->buffer == ptr))
 395      {
 396         return;
 397      }
 398   }
 399
 400    free(ptr);
 401 }
 402 #endif
 403
 404 static void *pl_mmap(unsigned int size)
 405 {
 406         return psxMap(0, size, 0, MAP_TAG_VRAM);
 407 }
 408
 409 static void pl_munmap(void *ptr, unsigned int size)
 410 {
 411         psxUnmap(ptr, size, MAP_TAG_VRAM);
 412 }
 413
 414 struct rearmed_cbs pl_rearmed_cbs = {
 415         .pl_vout_open = vout_open,
 416         .pl_vout_set_mode = vout_set_mode,
 417         .pl_vout_flip = vout_flip,
 418         .pl_vout_close = vout_close,
 419         .mmap = pl_mmap,
 420         .munmap = pl_munmap,
 421         /* from psxcounters */
 422         .gpu_hcnt = &hSyncCount,
 423         .gpu_frame_count = &frame_counter,
 424 };
 425
 426 void pl_frame_limit(void)
 427 {
 428         /* called once per frame, make psxCpu->Execute() above return */
 429         stop = 1;
 430 }
 431
 432 void pl_timing_prepare(int is_pal)
 433 {
 434         is_pal_mode = is_pal;
 435 }
 436
 437 void plat_trigger_vibrate(int pad, int low, int high)
 438 {
 439         if (!rumble_cb)
 440                 return;
 441
 442         if (in_enable_vibration)
 443         {
 444                 rumble_cb(pad, RETRO_RUMBLE_STRONG, high << 8);
 445                 rumble_cb(pad, RETRO_RUMBLE_WEAK, low ? 0xffff : 0x0);
 446     }
 447 }
 448
 449 void pl_update_gun(int *xn, int *yn, int *xres, int *yres, int *in)
 450 {
 451 }
 452
 453 /* sound calls */
 454 static void snd_feed(void *buf, int bytes)
 455 {
 456         if (audio_batch_cb != NULL)
 457                 audio_batch_cb(buf, bytes / 4);
 458 }
 459
 460 void out_register_libretro(struct out_driver *drv)
 461 {
 462         drv->name = "libretro";
 463         drv->init = snd_init;
 464         drv->finish = snd_finish;
 465         drv->busy = snd_busy;
 466         drv->feed = snd_feed;
 467 }
 468
 469 /* libretro */
 470 void retro_set_environment(retro_environment_t cb)
 471 {
 472    static const struct retro_variable vars[] = {
 473       { "pcsx_rearmed_frameskip", "Frameskip; 0|1|2|3" },
 474       { "pcsx_rearmed_bios", "Use BIOS; auto|HLE" },
 475       { "pcsx_rearmed_region", "Region; auto|NTSC|PAL" },
 476       { "pcsx_rearmed_memcard2", "Enable second memory card; disabled|enabled" },
 477       { "pcsx_rearmed_pad1type", "Pad 1 Type; standard|analog|dualshock|negcon|none" },
 478       { "pcsx_rearmed_pad2type", "Pad 2 Type; standard|analog|dualshock|negcon|none" },
 479       { "pcsx_rearmed_pad3type", "Pad 3 Type; none|standard|analog|dualshock|negcon" },
 480       { "pcsx_rearmed_pad4type", "Pad 4 Type; none|standard|analog|dualshock|negcon" },
 481       { "pcsx_rearmed_pad5type", "Pad 5 Type; none|standard|analog|dualshock|negcon" },
 482       { "pcsx_rearmed_pad6type", "Pad 6 Type; none|standard|analog|dualshock|negcon" },
 483       { "pcsx_rearmed_pad7type", "Pad 7 Type; none|standard|analog|dualshock|negcon" },
 484       { "pcsx_rearmed_pad8type", "Pad 8 Type; none|standard|analog|dualshock|negcon" },
 485       { "pcsx_rearmed_multitap1", "Multitap 1; auto|disabled|enabled" },
 486       { "pcsx_rearmed_multitap2", "Multitap 2; auto|disabled|enabled" },
 487       { "pcsx_rearmed_negcon_deadzone", "NegCon Twist Deadzone (percent); 0|5|10|15|20|25|30" },
 488       { "pcsx_rearmed_negcon_response", "NegCon Twist Response; linear|quadratic|cubic" },
 489       { "pcsx_rearmed_vibration", "Enable Vibration; enabled|disabled" },
 490       { "pcsx_rearmed_dithering", "Enable Dithering; enabled|disabled" },
 491 #ifndef DRC_DISABLE
 492       { "pcsx_rearmed_drc", "Dynamic recompiler; enabled|disabled" },
 493 #ifdef HAVE_PRE_ARMV7
 494       { "pcsx_rearmed_psxclock", "PSX cpu clock (default 50); 50|51|52|53|54|55|5657|58|59|60|61|62|63|64|65|66|67|68|69|70|71|72|73|74|75|76|77|78|79|80|81|82|83|84|85|86|87|88|89|90|91|92|93|94|95|96|97|98|99|100|30|31|32|33|34|35|36|37|38|39|40|41|42|43|44|45|46|47|48|49" },
 495 #else
 496       { "pcsx_rearmed_psxclock", "PSX cpu clock (default 57); 57|58|59|60|61|62|63|64|65|66|67|68|69|70|71|72|73|74|75|76|77|78|79|80|81|82|83|84|85|86|87|88|89|90|91|92|93|94|95|96|97|98|99|100|30|31|32|33|34|35|36|37|38|39|40|41|42|43|44|45|46|47|48|49|50|51|52|53|54|55|56" },
 497 #endif
 498 #endif
 499 #ifdef __ARM_NEON__
 500       { "pcsx_rearmed_neon_interlace_enable", "Enable interlacing mode(s); disabled|enabled" },
 501       { "pcsx_rearmed_neon_enhancement_enable", "Enhanced resolution (slow); disabled|enabled" },
 502       { "pcsx_rearmed_neon_enhancement_no_main", "Enhanced resolution speed hack; disabled|enabled" },
 503 #endif
 504       { "pcsx_rearmed_duping_enable", "Frame duping; enabled|disabled" },
 505       { "pcsx_rearmed_display_internal_fps", "Display Internal FPS; disabled|enabled" },
 506       { "pcsx_rearmed_show_bios_bootlogo", "Show Bios Bootlogo(Breaks some games); disabled|enabled" },
 507       { "pcsx_rearmed_spu_reverb", "Sound: Reverb; enabled|disabled" },
 508       { "pcsx_rearmed_spu_interpolation", "Sound: Interpolation; simple|gaussian|cubic|off" },
 509       { "pcsx_rearmed_idiablofix", "Diablo Music Fix; disabled|enabled" },
 510       { "pcsx_rearmed_pe2_fix", "Parasite Eve 2/Vandal Hearts 1/2 Fix; disabled|enabled" },
 511       { "pcsx_rearmed_inuyasha_fix", "InuYasha Sengoku Battle Fix; disabled|enabled" },
 512
 513       /* Advance options */
 514       { "pcsx_rearmed_noxadecoding", "XA Decoding; enabled|disabled" },
 515       { "pcsx_rearmed_nocdaudio", "CD Audio; enabled|disabled" },
 516 #ifndef DRC_DISABLE
 517       { "pcsx_rearmed_nosmccheck", "(Speed Hack) Disable SMC Checks; disabled|enabled" },
 518       { "pcsx_rearmed_gteregsunneeded", "(Speed Hack) Assume GTE Regs Unneeded; disabled|enabled" },
 519       { "pcsx_rearmed_nogteflags", "(Speed Hack) Disable GTE Flags; disabled|enabled" },
 520 #endif
 521
 522       { NULL, NULL }
 523    };
 524
 525     if (cb(RETRO_ENVIRONMENT_GET_LOG_INTERFACE, &logging))
 526         log_cb = logging.log;
 527
 528    environ_cb = cb;
 529
 530    cb(RETRO_ENVIRONMENT_SET_VARIABLES, (void*)vars);
 531 }
 532
 533 void retro_set_video_refresh(retro_video_refresh_t cb) { video_cb = cb; }
 534 void retro_set_audio_sample(retro_audio_sample_t cb) { (void)cb; }
 535 void retro_set_audio_sample_batch(retro_audio_sample_batch_t cb) { audio_batch_cb = cb; }
 536 void retro_set_input_poll(retro_input_poll_t cb) { input_poll_cb = cb; }
 537 void retro_set_input_state(retro_input_state_t cb) { input_state_cb = cb; }
 538
 539 unsigned retro_api_version(void)
 540 {
 541         return RETRO_API_VERSION;
 542 }
 543
 544 static int controller_port_variable(unsigned port, struct retro_variable *var)
 545 {
 546         if (port >= PORTS_NUMBER)
 547                 return 0;
 548
 549         if (!environ_cb)
 550                 return 0;
 551
 552         var->value = NULL;
 553         switch (port) {
 554         case 0:
 555                 var->key = "pcsx_rearmed_pad1type";
 556                 break;
 557         case 1:
 558                 var->key = "pcsx_rearmed_pad2type";
 559                 break;
 560         case 2:
 561                 var->key = "pcsx_rearmed_pad3type";
 562                 break;
 563         case 3:
 564                 var->key = "pcsx_rearmed_pad4type";
 565                 break;
 566         case 4:
 567                 var->key = "pcsx_rearmed_pad5type";
 568                 break;
 569         case 5:
 570                 var->key = "pcsx_rearmed_pad6type";
 571                 break;
 572         case 6:
 573                 var->key = "pcsx_rearmed_pad7type";
 574                 break;
 575         case 7:
 576                 var->key = "pcsx_rearmed_pad8type";
 577                 break;
 578         }
 579
 580         return environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, var) || var->value;
 581 }
 582
 583 static void update_controller_port_variable(unsigned port)
 584 {
 585         if (port >= PORTS_NUMBER)
 586                 return;
 587
 588         struct retro_variable var;
 589
 590         if (controller_port_variable(port, &var))
 591         {
 592                 if (strcmp(var.value, "standard") == 0)
 593                         in_type[port] = PSE_PAD_TYPE_STANDARD;
 594                 else if (strcmp(var.value, "analog") == 0)
 595                         in_type[port] = PSE_PAD_TYPE_ANALOGJOY;
 596                 else if (strcmp(var.value, "dualshock") == 0)
 597                         in_type[port] = PSE_PAD_TYPE_ANALOGPAD;
 598                 else if (strcmp(var.value, "negcon") == 0)
 599                         in_type[port] = PSE_PAD_TYPE_NEGCON;
 600                 else if (strcmp(var.value, "none") == 0)
 601                         in_type[port] = PSE_PAD_TYPE_NONE;
 602                 // else 'default' case, do nothing
 603         }
 604 }
 605
 606 static void update_controller_port_device(unsigned port, unsigned device)
 607 {
 608         if (port >= PORTS_NUMBER)
 609                 return;
 610
 611         struct retro_variable var;
 612
 613         if (!controller_port_variable(port, &var))
 614                 return;
 615
 616         if (strcmp(var.value, "default") != 0)
 617                 return;
 618
 619         switch (device)
 620         {
 621         case RETRO_DEVICE_JOYPAD:
 622                 in_type[port] = PSE_PAD_TYPE_STANDARD;
 623                 break;
 624         case RETRO_DEVICE_ANALOG:
 625                 in_type[port] = PSE_PAD_TYPE_ANALOGPAD;
 626                 break;
 627         case RETRO_DEVICE_MOUSE:
 628                 in_type[port] = PSE_PAD_TYPE_MOUSE;
 629                 break;
 630         case RETRO_DEVICE_LIGHTGUN:
 631                 in_type[port] = PSE_PAD_TYPE_GUN;
 632                 break;
 633         case RETRO_DEVICE_NONE:
 634         default:
 635                 in_type[port] = PSE_PAD_TYPE_NONE;
 636         }
 637 }
 638
 639 static void update_multitap()
 640 {
 641         struct retro_variable var;
 642         int auto_case, port;
 643
 644         var.value = NULL;
 645         var.key = "pcsx_rearmed_multitap1";
 646         auto_case = 0;
 647         if (environ_cb && (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value))
 648         {
 649                 if (strcmp(var.value, "enabled") == 0)
 650                         multitap1 = 1;
 651                 else if (strcmp(var.value, "disabled") == 0)
 652                         multitap1 = 0;
 653                 else // 'auto' case
 654                         auto_case = 1;
 655         }
 656         else
 657                 auto_case = 1;
 658
 659         if (auto_case)
 660         {
 661                 // If a gamepad is plugged after port 2, we need a first multitap.
 662                 multitap1 = 0;
 663                 for (port = 2; port < PORTS_NUMBER; port++)
 664                         multitap1 |= in_type[port] != PSE_PAD_TYPE_NONE;
 665         }
 666
 667         var.value = NULL;
 668         var.key = "pcsx_rearmed_multitap2";
 669         auto_case = 0;
 670         if (environ_cb && (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value))
 671         {
 672                 if (strcmp(var.value, "enabled") == 0)
 673                         multitap2 = 1;
 674                 else if (strcmp(var.value, "disabled") == 0)
 675                         multitap2 = 0;
 676                 else // 'auto' case
 677                         auto_case = 1;
 678         }
 679         else
 680                 auto_case = 1;
 681
 682         if (auto_case)
 683         {
 684                 // If a gamepad is plugged after port 4, we need a second multitap.
 685                 multitap2 = 0;
 686                 for (port = 4; port < PORTS_NUMBER; port++)
 687                         multitap2 |= in_type[port] != PSE_PAD_TYPE_NONE;
 688         }
 689 }
 690
 691 void retro_set_controller_port_device(unsigned port, unsigned device)
 692 {
 693         SysPrintf("port %u  device %u",port,device);
 694
 695         if (port >= PORTS_NUMBER)
 696                 return;
 697
 698         update_controller_port_device(port, device);
 699         update_multitap();
 700 }
 701
 702 void retro_get_system_info(struct retro_system_info *info)
 703 {
 704         memset(info, 0, sizeof(*info));
 705         info->library_name = "PCSX-ReARMed";
 706 #ifndef GIT_VERSION
 707 #define GIT_VERSION ""
 708 #endif
 709         info->library_version = "r22" GIT_VERSION;
 710         info->valid_extensions = "bin|cue|img|mdf|pbp|toc|cbn|m3u|chd";
 711         info->need_fullpath = true;
 712 }
 713
 714 void retro_get_system_av_info(struct retro_system_av_info *info)
 715 {
 716         memset(info, 0, sizeof(*info));
 717         info->timing.fps            = is_pal_mode ? 50 : 60;
 718         info->timing.sample_rate    = 44100;
 719         info->geometry.base_width   = 320;
 720         info->geometry.base_height  = 240;
 721         info->geometry.max_width    = VOUT_MAX_WIDTH;
 722         info->geometry.max_height   = VOUT_MAX_HEIGHT;
 723         info->geometry.aspect_ratio = 4.0 / 3.0;
 724 }
 725
 726 /* savestates */
 727 size_t retro_serialize_size(void)
 728 {
 729         // it's currently 4380651-4397047 bytes,
 730         // but have some reserved for future
 731         return 0x440000;
 732 }
 733
 734 struct save_fp {
 735         char *buf;
 736         size_t pos;
 737         int is_write;
 738 };
 739
 740 static void *save_open(const char *name, const char *mode)
 741 {
 742         struct save_fp *fp;
 743
 744         if (name == NULL || mode == NULL)
 745                 return NULL;
 746
 747         fp = malloc(sizeof(*fp));
 748         if (fp == NULL)
 749                 return NULL;
 750
 751         fp->buf = (char *)name;
 752         fp->pos = 0;
 753         fp->is_write = (mode[0] == 'w' || mode[1] == 'w');
 754
 755         return fp;
 756 }
 757
 758 static int save_read(void *file, void *buf, u32 len)
 759 {
 760         struct save_fp *fp = file;
 761         if (fp == NULL || buf == NULL)
 762                 return -1;
 763
 764         memcpy(buf, fp->buf + fp->pos, len);
 765         fp->pos += len;
 766         return len;
 767 }
 768
 769 static int save_write(void *file, const void *buf, u32 len)
 770 {
 771         struct save_fp *fp = file;
 772         if (fp == NULL || buf == NULL)
 773                 return -1;
 774
 775         memcpy(fp->buf + fp->pos, buf, len);
 776         fp->pos += len;
 777         return len;
 778 }
 779
 780 static long save_seek(void *file, long offs, int whence)
 781 {
 782         struct save_fp *fp = file;
 783         if (fp == NULL)
 784                 return -1;
 785
 786         switch (whence) {
 787         case SEEK_CUR:
 788                 fp->pos += offs;
 789                 return fp->pos;
 790         case SEEK_SET:
 791                 fp->pos = offs;
 792                 return fp->pos;
 793         default:
 794                 return -1;
 795         }
 796 }
 797
 798 static void save_close(void *file)
 799 {
 800         struct save_fp *fp = file;
 801         size_t r_size = retro_serialize_size();
 802         if (fp == NULL)
 803                 return;
 804
 805         if (fp->pos > r_size)
 806                 SysPrintf("ERROR: save buffer overflow detected\n");
 807         else if (fp->is_write && fp->pos < r_size)
 808                 // make sure we don't save trash in leftover space
 809                 memset(fp->buf + fp->pos, 0, r_size - fp->pos);
 810         free(fp);
 811 }
 812
 813 bool retro_serialize(void *data, size_t size)
 814 {
 815         int ret = SaveState(data);
 816         return ret == 0 ? true : false;
 817 }
 818
 819 bool retro_unserialize(const void *data, size_t size)
 820 {
 821         int ret = LoadState(data);
 822         return ret == 0 ? true : false;
 823 }
 824
 825 /* cheats */
 826 void retro_cheat_reset(void)
 827 {
 828         ClearAllCheats();
 829 }
 830
 831 void retro_cheat_set(unsigned index, bool enabled, const char *code)
 832 {
 833         char buf[256];
 834         int ret;
 835
 836         // cheat funcs are destructive, need a copy..
 837         strncpy(buf, code, sizeof(buf));
 838         buf[sizeof(buf) - 1] = 0;
 839
 840         //Prepare buffered cheat for PCSX's AddCheat fucntion.
 841         int cursor=0;
 842         int nonhexdec=0;
 843         while (buf[cursor]){
 844                 if (!(ISHEXDEC)){
 845                         if (++nonhexdec%2){
 846                                 buf[cursor]=' ';
 847                         } else {
 848                                 buf[cursor]='\n';
 849                         }
 850                 }
 851                 cursor++;
 852         }
 853
 854
 855         if (index < NumCheats)
 856                 ret = EditCheat(index, "", buf);
 857         else
 858                 ret = AddCheat("", buf);
 859
 860         if (ret != 0)
 861                 SysPrintf("Failed to set cheat %#u\n", index);
 862         else if (index < NumCheats)
 863                 Cheats[index].Enabled = enabled;
 864 }
 865
 866 /* multidisk support */
 867 static bool disk_ejected;
 868 static unsigned int disk_current_index;
 869 static unsigned int disk_count;
 870 static struct disks_state {
 871         char *fname;
 872         int internal_index; // for multidisk eboots
 873 } disks[8];
 874
 875 static bool disk_set_eject_state(bool ejected)
 876 {
 877         // weird PCSX API..
 878         SetCdOpenCaseTime(ejected ? -1 : (time(NULL) + 2));
 879         LidInterrupt();
 880
 881         disk_ejected = ejected;
 882         return true;
 883 }
 884
 885 static bool disk_get_eject_state(void)
 886 {
 887         /* can't be controlled by emulated software */
 888         return disk_ejected;
 889 }
 890
 891 static unsigned int disk_get_image_index(void)
 892 {
 893         return disk_current_index;
 894 }
 895
 896 static bool disk_set_image_index(unsigned int index)
 897 {
 898         if (index >= sizeof(disks) / sizeof(disks[0]))
 899                 return false;
 900
 901         CdromId[0] = '\0';
 902         CdromLabel[0] = '\0';
 903
 904         if (disks[index].fname == NULL) {
 905                 SysPrintf("missing disk #%u\n", index);
 906                 CDR_shutdown();
 907
 908                 // RetroArch specifies "no disk" with index == count,
 909                 // so don't fail here..
 910                 disk_current_index = index;
 911                 return true;
 912         }
 913
 914         SysPrintf("switching to disk %u: \"%s\" #%d\n", index,
 915                 disks[index].fname, disks[index].internal_index);
 916
 917         cdrIsoMultidiskSelect = disks[index].internal_index;
 918         set_cd_image(disks[index].fname);
 919         if (ReloadCdromPlugin() < 0) {
 920                 SysPrintf("failed to load cdr plugin\n");
 921                 return false;
 922         }
 923         if (CDR_open() < 0) {
 924                 SysPrintf("failed to open cdr plugin\n");
 925                 return false;
 926         }
 927
 928         if (!disk_ejected) {
 929                 SetCdOpenCaseTime(time(NULL) + 2);
 930                 LidInterrupt();
 931         }
 932
 933         disk_current_index = index;
 934         return true;
 935 }
 936
 937 static unsigned int disk_get_num_images(void)
 938 {
 939         return disk_count;
 940 }
 941
 942 static bool disk_replace_image_index(unsigned index,
 943         const struct retro_game_info *info)
 944 {
 945         char *old_fname;
 946         bool ret = true;
 947
 948         if (index >= sizeof(disks) / sizeof(disks[0]))
 949                 return false;
 950
 951         old_fname = disks[index].fname;
 952         disks[index].fname = NULL;
 953         disks[index].internal_index = 0;
 954
 955         if (info != NULL) {
 956                 disks[index].fname = strdup(info->path);
 957                 if (index == disk_current_index)
 958                         ret = disk_set_image_index(index);
 959         }
 960
 961         if (old_fname != NULL)
 962                 free(old_fname);
 963
 964         return ret;
 965 }
 966
 967 static bool disk_add_image_index(void)
 968 {
 969         if (disk_count >= 8)
 970                 return false;
 971
 972         disk_count++;
 973         return true;
 974 }
 975
 976 static struct retro_disk_control_callback disk_control = {
 977         .set_eject_state = disk_set_eject_state,
 978         .get_eject_state = disk_get_eject_state,
 979         .get_image_index = disk_get_image_index,
 980         .set_image_index = disk_set_image_index,
 981         .get_num_images = disk_get_num_images,
 982         .replace_image_index = disk_replace_image_index,
 983         .add_image_index = disk_add_image_index,
 984 };
 985
 986 // just in case, maybe a win-rt port in the future?
 987 #ifdef _WIN32
 988 #define SLASH '\\'
 989 #else
 990 #define SLASH '/'
 991 #endif
 992
 993 #ifndef PATH_MAX
 994 #define PATH_MAX  4096
 995 #endif
 996
 997 static char base_dir[PATH_MAX];
 998
 999 static bool read_m3u(const char *file)
1000 {
1001         char line[PATH_MAX];
1002         char name[PATH_MAX];
1003         FILE *f = fopen(file, "r");
1004         if (!f)
1005                 return false;
1006
1007         while (fgets(line, sizeof(line), f) && disk_count < sizeof(disks) / sizeof(disks[0])) {
1008                 if (line[0] == '#')
1009                         continue;
1010                 char *carrige_return = strchr(line, '\r');
1011                 if (carrige_return)
1012                         *carrige_return = '\0';
1013                 char *newline = strchr(line, '\n');
1014                 if (newline)
1015                         *newline = '\0';
1016
1017                 if (line[0] != '\0')
1018                 {
1019                         snprintf(name, sizeof(name), "%s%c%s", base_dir, SLASH, line);
1020                         disks[disk_count++].fname = strdup(name);
1021                 }
1022         }
1023
1024         fclose(f);
1025         return (disk_count != 0);
1026 }
1027
1028 static void extract_directory(char *buf, const char *path, size_t size)
1029 {
1030    char *base;
1031    strncpy(buf, path, size - 1);
1032    buf[size - 1] = '\0';
1033
1034    base = strrchr(buf, '/');
1035    if (!base)
1036       base = strrchr(buf, '\\');
1037
1038    if (base)
1039       *base = '\0';
1040    else
1041    {
1042       buf[0] = '.';
1043       buf[1] = '\0';
1044    }
1045 }
1046
1047 #if defined(__QNX__) || defined(_WIN32)
1048 /* Blackberry QNX doesn't have strcasestr */
1049
1050 /*
1051  * Find the first occurrence of find in s, ignore case.
1052  */
1053 char *
1054 strcasestr(const char *s, const char*find)
1055 {
1056         char c, sc;
1057         size_t len;
1058
1059         if ((c = *find++) != 0) {
1060                 c = tolower((unsigned char)c);
1061                 len = strlen(find);
1062                 do {
1063                         do {
1064                                 if ((sc = *s++) == 0)
1065                                         return (NULL);
1066                         } while ((char)tolower((unsigned char)sc) != c);
1067                 } while (strncasecmp(s, find, len) != 0);
1068                 s--;
1069         }
1070         return ((char *)s);
1071 }
1072 #endif
1073
1074 bool retro_load_game(const struct retro_game_info *info)
1075 {
1076         size_t i;
1077         bool is_m3u = (strcasestr(info->path, ".m3u") != NULL);
1078
1079    struct retro_input_descriptor desc[] = {
1080       { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT,  "D-Pad Left" },
1081       { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP,    "D-Pad Up" },
1082       { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN,  "D-Pad Down" },
1083       { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT, "D-Pad Right" },
1084       { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_B,     "Cross" },
1085       { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A,     "Circle" },
1086       { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_X,     "Triangle" },
1087       { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_Y,     "Square" },
1088       { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L,     "L1" },
1089       { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L2,    "L2" },
1090       { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L3,    "L3" },
1091       { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R,     "R1" },
1092       { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R2,    "R2" },
1093       { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R3,    "R3" },
1094       { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_SELECT,    "Select" },
1095       { 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_START,    "Start" },
1096       { 0, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_X, "Left Analog X" },
1097       { 0, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_Y, "Left Analog Y" },
1098       { 0, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_X, "Right Analog X" },
1099       { 0, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_Y, "Right Analog Y" },
1100
1101
1102       { 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT,  "D-Pad Left" },
1103       { 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP,    "D-Pad Up" },
1104       { 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN,  "D-Pad Down" },
1105       { 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT, "D-Pad Right" },
1106       { 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_B,     "Cross" },
1107       { 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A,     "Circle" },
1108       { 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_X,     "Triangle" },
1109       { 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_Y,     "Square" },
1110       { 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L,     "L1" },
1111       { 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L2,    "L2" },
1112       { 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L3,    "L3" },
1113       { 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R,     "R1" },
1114       { 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R2,    "R2" },
1115       { 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R3,    "R3" },
1116       { 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_SELECT,    "Select" },
1117       { 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_START,    "Start" },
1118       { 1, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_X, "Left Analog X" },
1119       { 1, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_Y, "Left Analog Y" },
1120       { 1, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_X, "Right Analog X" },
1121       { 1, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_Y, "Right Analog Y" },
1122
1123       { 2, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT,  "D-Pad Left" },
1124       { 2, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP,    "D-Pad Up" },
1125       { 2, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN,  "D-Pad Down" },
1126       { 2, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT, "D-Pad Right" },
1127       { 2, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_B,     "Cross" },
1128       { 2, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A,     "Circle" },
1129       { 2, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_X,     "Triangle" },
1130       { 2, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_Y,     "Square" },
1131       { 2, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L,     "L1" },
1132       { 2, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L2,    "L2" },
1133       { 2, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L3,    "L3" },
1134       { 2, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R,     "R1" },
1135       { 2, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R2,    "R2" },
1136       { 2, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R3,    "R3" },
1137       { 2, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_SELECT,    "Select" },
1138       { 2, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_START,    "Start" },
1139       { 2, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_X, "Left Analog X" },
1140       { 2, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_Y, "Left Analog Y" },
1141       { 2, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_X, "Right Analog X" },
1142       { 2, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_Y, "Right Analog Y" },
1143
1144       { 3, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT,  "D-Pad Left" },
1145       { 3, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP,    "D-Pad Up" },
1146       { 3, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN,  "D-Pad Down" },
1147       { 3, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT, "D-Pad Right" },
1148       { 3, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_B,     "Cross" },
1149       { 3, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A,     "Circle" },
1150       { 3, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_X,     "Triangle" },
1151       { 3, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_Y,     "Square" },
1152       { 3, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L,     "L1" },
1153       { 3, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L2,    "L2" },
1154       { 3, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L3,    "L3" },
1155       { 3, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R,     "R1" },
1156       { 3, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R2,    "R2" },
1157       { 3, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R3,    "R3" },
1158       { 3, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_SELECT,    "Select" },
1159       { 3, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_START,    "Start" },
1160       { 3, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_X, "Left Analog X" },
1161       { 3, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_Y, "Left Analog Y" },
1162       { 3, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_X, "Right Analog X" },
1163       { 3, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_Y, "Right Analog Y" },
1164
1165       { 4, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT,  "D-Pad Left" },
1166       { 4, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP,    "D-Pad Up" },
1167       { 4, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN,  "D-Pad Down" },
1168       { 4, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT, "D-Pad Right" },
1169       { 4, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_B,     "Cross" },
1170       { 4, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A,     "Circle" },
1171       { 4, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_X,     "Triangle" },
1172       { 4, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_Y,     "Square" },
1173       { 4, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L,     "L1" },
1174       { 4, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L2,    "L2" },
1175       { 4, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L3,    "L3" },
1176       { 4, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R,     "R1" },
1177       { 4, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R2,    "R2" },
1178       { 4, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R3,    "R3" },
1179       { 4, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_SELECT,    "Select" },
1180       { 4, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_START,    "Start" },
1181       { 4, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_X, "Left Analog X" },
1182       { 4, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_Y, "Left Analog Y" },
1183       { 4, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_X, "Right Analog X" },
1184       { 4, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_Y, "Right Analog Y" },
1185
1186       { 5, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT,  "D-Pad Left" },
1187       { 5, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP,    "D-Pad Up" },
1188       { 5, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN,  "D-Pad Down" },
1189       { 5, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT, "D-Pad Right" },
1190       { 5, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_B,     "Cross" },
1191       { 5, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A,     "Circle" },
1192       { 5, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_X,     "Triangle" },
1193       { 5, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_Y,     "Square" },
1194       { 5, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L,     "L1" },
1195       { 5, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L2,    "L2" },
1196       { 5, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L3,    "L3" },
1197       { 5, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R,     "R1" },
1198       { 5, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R2,    "R2" },
1199       { 5, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R3,    "R3" },
1200       { 5, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_SELECT,    "Select" },
1201       { 5, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_START,    "Start" },
1202       { 5, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_X, "Left Analog X" },
1203       { 5, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_Y, "Left Analog Y" },
1204       { 5, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_X, "Right Analog X" },
1205       { 5, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_Y, "Right Analog Y" },
1206
1207       { 6, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT,  "D-Pad Left" },
1208       { 6, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP,    "D-Pad Up" },
1209       { 6, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN,  "D-Pad Down" },
1210       { 6, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT, "D-Pad Right" },
1211       { 6, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_B,     "Cross" },
1212       { 6, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A,     "Circle" },
1213       { 6, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_X,     "Triangle" },
1214       { 6, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_Y,     "Square" },
1215       { 6, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L,     "L1" },
1216       { 6, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L2,    "L2" },
1217       { 6, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L3,    "L3" },
1218       { 6, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R,     "R1" },
1219       { 6, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R2,    "R2" },
1220       { 6, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R3,    "R3" },
1221       { 6, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_SELECT,    "Select" },
1222       { 6, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_START,    "Start" },
1223       { 6, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_X, "Left Analog X" },
1224       { 6, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_Y, "Left Analog Y" },
1225       { 6, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_X, "Right Analog X" },
1226       { 6, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_Y, "Right Analog Y" },
1227
1228       { 7, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT,  "D-Pad Left" },
1229       { 7, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP,    "D-Pad Up" },
1230       { 7, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN,  "D-Pad Down" },
1231       { 7, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT, "D-Pad Right" },
1232       { 7, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_B,     "Cross" },
1233       { 7, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A,     "Circle" },
1234       { 7, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_X,     "Triangle" },
1235       { 7, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_Y,     "Square" },
1236       { 7, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L,     "L1" },
1237       { 7, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L2,    "L2" },
1238       { 7, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_L3,    "L3" },
1239       { 7, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R,     "R1" },
1240       { 7, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R2,    "R2" },
1241       { 7, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R3,    "R3" },
1242       { 7, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_SELECT,    "Select" },
1243       { 7, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_START,    "Start" },
1244       { 7, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_X, "Left Analog X" },
1245       { 7, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_Y, "Left Analog Y" },
1246       { 7, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_X, "Right Analog X" },
1247       { 7, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_Y, "Right Analog Y" },
1248
1249       { 0 },
1250    };
1251
1252          frame_count = 0;
1253
1254    environ_cb(RETRO_ENVIRONMENT_SET_INPUT_DESCRIPTORS, desc);
1255
1256 #ifdef FRONTEND_SUPPORTS_RGB565
1257         enum retro_pixel_format fmt = RETRO_PIXEL_FORMAT_RGB565;
1258         if (environ_cb(RETRO_ENVIRONMENT_SET_PIXEL_FORMAT, &fmt)) {
1259                 SysPrintf("RGB565 supported, using it\n");
1260         }
1261 #endif
1262
1263         if (info == NULL || info->path == NULL) {
1264                 SysPrintf("info->path required\n");
1265                 return false;
1266         }
1267
1268         if (plugins_opened) {
1269                 ClosePlugins();
1270                 plugins_opened = 0;
1271         }
1272
1273         for (i = 0; i < sizeof(disks) / sizeof(disks[0]); i++) {
1274                 if (disks[i].fname != NULL) {
1275                         free(disks[i].fname);
1276                         disks[i].fname = NULL;
1277                 }
1278                 disks[i].internal_index = 0;
1279         }
1280
1281         disk_current_index = 0;
1282         extract_directory(base_dir, info->path, sizeof(base_dir));
1283
1284         if (is_m3u) {
1285                 if (!read_m3u(info->path)) {
1286                         log_cb(RETRO_LOG_INFO, "failed to read m3u file\n");
1287                         return false;
1288                 }
1289         } else {
1290                 disk_count = 1;
1291                 disks[0].fname = strdup(info->path);
1292         }
1293
1294         set_cd_image(disks[0].fname);
1295
1296         /* have to reload after set_cd_image for correct cdr plugin */
1297         if (LoadPlugins() == -1) {
1298                 log_cb(RETRO_LOG_INFO, "failed to load plugins\n");
1299                 return false;
1300         }
1301
1302         plugins_opened = 1;
1303         NetOpened = 0;
1304
1305         if (OpenPlugins() == -1) {
1306                 log_cb(RETRO_LOG_INFO, "failed to open plugins\n");
1307                 return false;
1308         }
1309
1310         plugin_call_rearmed_cbs();
1311         dfinput_activate();
1312
1313         if (CheckCdrom() == -1) {
1314         log_cb(RETRO_LOG_INFO, "unsupported/invalid CD image: %s\n", info->path);
1315                 return false;
1316         }
1317
1318         SysReset();
1319
1320         if (LoadCdrom() == -1) {
1321                 log_cb(RETRO_LOG_INFO, "could not load CD\n");
1322                 return false;
1323         }
1324         emu_on_new_cd(0);
1325
1326         // multidisk images
1327         if (!is_m3u) {
1328                 disk_count = cdrIsoMultidiskCount < 8 ? cdrIsoMultidiskCount : 8;
1329                 for (i = 1; i < sizeof(disks) / sizeof(disks[0]) && i < cdrIsoMultidiskCount; i++) {
1330                         disks[i].fname = strdup(info->path);
1331                         disks[i].internal_index = i;
1332                 }
1333         }
1334
1335         return true;
1336 }
1337
1338 unsigned retro_get_region(void)
1339 {
1340         return is_pal_mode ? RETRO_REGION_PAL : RETRO_REGION_NTSC;
1341 }
1342
1343 void *retro_get_memory_data(unsigned id)
1344 {
1345         if (id == RETRO_MEMORY_SAVE_RAM)
1346                 return Mcd1Data;
1347         else
1348                 return NULL;
1349 }
1350
1351 size_t retro_get_memory_size(unsigned id)
1352 {
1353         if (id == RETRO_MEMORY_SAVE_RAM)
1354                 return MCD_SIZE;
1355         else
1356                 return 0;
1357 }
1358
1359 void retro_reset(void)
1360 {
1361    //hack to prevent retroarch freezing when reseting in the menu but not while running with the hot key
1362    rebootemu = 1;
1363         //SysReset();
1364 }
1365
1366 static const unsigned short retro_psx_map[] = {
1367         [RETRO_DEVICE_ID_JOYPAD_B]      = 1 << DKEY_CROSS,
1368         [RETRO_DEVICE_ID_JOYPAD_Y]      = 1 << DKEY_SQUARE,
1369         [RETRO_DEVICE_ID_JOYPAD_SELECT] = 1 << DKEY_SELECT,
1370         [RETRO_DEVICE_ID_JOYPAD_START]  = 1 << DKEY_START,
1371         [RETRO_DEVICE_ID_JOYPAD_UP]     = 1 << DKEY_UP,
1372         [RETRO_DEVICE_ID_JOYPAD_DOWN]   = 1 << DKEY_DOWN,
1373         [RETRO_DEVICE_ID_JOYPAD_LEFT]   = 1 << DKEY_LEFT,
1374         [RETRO_DEVICE_ID_JOYPAD_RIGHT]  = 1 << DKEY_RIGHT,
1375         [RETRO_DEVICE_ID_JOYPAD_A]      = 1 << DKEY_CIRCLE,
1376         [RETRO_DEVICE_ID_JOYPAD_X]      = 1 << DKEY_TRIANGLE,
1377         [RETRO_DEVICE_ID_JOYPAD_L]      = 1 << DKEY_L1,
1378         [RETRO_DEVICE_ID_JOYPAD_R]      = 1 << DKEY_R1,
1379         [RETRO_DEVICE_ID_JOYPAD_L2]     = 1 << DKEY_L2,
1380         [RETRO_DEVICE_ID_JOYPAD_R2]     = 1 << DKEY_R2,
1381         [RETRO_DEVICE_ID_JOYPAD_L3]     = 1 << DKEY_L3,
1382         [RETRO_DEVICE_ID_JOYPAD_R3]     = 1 << DKEY_R3,
1383 };
1384 #define RETRO_PSX_MAP_LEN (sizeof(retro_psx_map) / sizeof(retro_psx_map[0]))
1385
1386 static void update_variables(bool in_flight)
1387 {
1388    struct retro_variable var;
1389    int i;
1390
1391    var.value = NULL;
1392    var.key = "pcsx_rearmed_frameskip";
1393    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1394       pl_rearmed_cbs.frameskip = atoi(var.value);
1395
1396    var.value = NULL;
1397    var.key = "pcsx_rearmed_region";
1398    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1399    {
1400       Config.PsxAuto = 0;
1401       if (strcmp(var.value, "auto") == 0)
1402          Config.PsxAuto = 1;
1403       else if (strcmp(var.value, "NTSC") == 0)
1404          Config.PsxType = 0;
1405       else if (strcmp(var.value, "PAL") == 0)
1406          Config.PsxType = 1;
1407    }
1408
1409    for (i = 0; i < PORTS_NUMBER; i++)
1410       update_controller_port_variable(i);
1411
1412    update_multitap();
1413
1414    var.value = NULL;
1415    var.key = "pcsx_rearmed_negcon_deadzone";
1416    negcon_deadzone = 0;
1417    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1418    {
1419       negcon_deadzone = (int)(atoi(var.value) * 0.01f * NEGCON_RANGE);
1420    }
1421
1422    var.value = NULL;
1423    var.key = "pcsx_rearmed_negcon_response";
1424    negcon_linearity = 1;
1425    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1426    {
1427       if (strcmp(var.value, "quadratic") == 0){
1428          negcon_linearity = 2;
1429       } else if (strcmp(var.value, "cubic") == 0){
1430          negcon_linearity = 3;
1431       }
1432    }
1433
1434    var.value = NULL;
1435    var.key = "pcsx_rearmed_vibration";
1436
1437    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1438    {
1439       if (strcmp(var.value, "disabled") == 0)
1440          in_enable_vibration = 0;
1441       else if (strcmp(var.value, "enabled") == 0)
1442          in_enable_vibration = 1;
1443    }
1444
1445    var.value = NULL;
1446    var.key = "pcsx_rearmed_dithering";
1447
1448    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1449    {
1450       if (strcmp(var.value, "disabled") == 0) {
1451          pl_rearmed_cbs.gpu_peops.iUseDither = 0;
1452          pl_rearmed_cbs.gpu_peopsgl.bDrawDither = 0;
1453 #ifdef __ARM_NEON__
1454          pl_rearmed_cbs.gpu_neon.allow_dithering = 0;
1455 #endif
1456       }
1457       else if (strcmp(var.value, "enabled") == 0) {
1458          pl_rearmed_cbs.gpu_peops.iUseDither = 1;
1459          pl_rearmed_cbs.gpu_peopsgl.bDrawDither = 1;
1460 #ifdef __ARM_NEON__
1461          pl_rearmed_cbs.gpu_neon.allow_dithering = 1;
1462 #endif
1463       }
1464    }
1465
1466 #ifdef __ARM_NEON__
1467    var.value = "NULL";
1468    var.key = "pcsx_rearmed_neon_interlace_enable";
1469
1470    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1471    {
1472       if (strcmp(var.value, "disabled") == 0)
1473          pl_rearmed_cbs.gpu_neon.allow_interlace = 0;
1474       else if (strcmp(var.value, "enabled") == 0)
1475          pl_rearmed_cbs.gpu_neon.allow_interlace = 1;
1476    }
1477
1478    var.value = NULL;
1479    var.key = "pcsx_rearmed_neon_enhancement_enable";
1480
1481    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1482    {
1483       if (strcmp(var.value, "disabled") == 0)
1484          pl_rearmed_cbs.gpu_neon.enhancement_enable = 0;
1485       else if (strcmp(var.value, "enabled") == 0)
1486          pl_rearmed_cbs.gpu_neon.enhancement_enable = 1;
1487    }
1488
1489    var.value = NULL;
1490    var.key = "pcsx_rearmed_neon_enhancement_no_main";
1491
1492    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1493    {
1494       if (strcmp(var.value, "disabled") == 0)
1495          pl_rearmed_cbs.gpu_neon.enhancement_no_main = 0;
1496       else if (strcmp(var.value, "enabled") == 0)
1497          pl_rearmed_cbs.gpu_neon.enhancement_no_main = 1;
1498    }
1499 #endif
1500
1501    var.value = "NULL";
1502    var.key = "pcsx_rearmed_duping_enable";
1503
1504    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1505    {
1506       if (strcmp(var.value, "disabled") == 0)
1507          duping_enable = false;
1508       else if (strcmp(var.value, "enabled") == 0)
1509          duping_enable = true;
1510    }
1511
1512    var.value = "NULL";
1513    var.key = "pcsx_rearmed_display_internal_fps";
1514
1515    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1516    {
1517       if (strcmp(var.value, "disabled") == 0)
1518          display_internal_fps = false;
1519       else if (strcmp(var.value, "enabled") == 0)
1520          display_internal_fps = true;
1521    }
1522
1523 #ifndef DRC_DISABLE
1524    var.value = NULL;
1525    var.key = "pcsx_rearmed_drc";
1526
1527    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1528    {
1529       R3000Acpu *prev_cpu = psxCpu;
1530
1531 #ifdef _3DS
1532       if(!__ctr_svchax)
1533          Config.Cpu = CPU_INTERPRETER;
1534       else
1535 #endif
1536       if (strcmp(var.value, "disabled") == 0)
1537          Config.Cpu = CPU_INTERPRETER;
1538       else if (strcmp(var.value, "enabled") == 0)
1539          Config.Cpu = CPU_DYNAREC;
1540
1541       psxCpu = (Config.Cpu == CPU_INTERPRETER) ? &psxInt : &psxRec;
1542       if (psxCpu != prev_cpu) {
1543          prev_cpu->Shutdown();
1544          psxCpu->Init();
1545          psxCpu->Reset(); // not really a reset..
1546       }
1547    }
1548 #endif
1549
1550    var.value = "NULL";
1551    var.key = "pcsx_rearmed_spu_reverb";
1552
1553    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1554    {
1555       if (strcmp(var.value, "disabled") == 0)
1556          spu_config.iUseReverb = false;
1557       else if (strcmp(var.value, "enabled") == 0)
1558          spu_config.iUseReverb = true;
1559    }
1560
1561    var.value = "NULL";
1562    var.key = "pcsx_rearmed_spu_interpolation";
1563
1564    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1565    {
1566       if (strcmp(var.value, "simple") == 0)
1567          spu_config.iUseInterpolation = 1;
1568       else if (strcmp(var.value, "gaussian") == 0)
1569          spu_config.iUseInterpolation = 2;
1570       else if (strcmp(var.value, "cubic") == 0)
1571          spu_config.iUseInterpolation = 3;
1572       else if (strcmp(var.value, "off") == 0)
1573          spu_config.iUseInterpolation = 0;
1574    }
1575
1576    var.value = "NULL";
1577    var.key = "pcsx_rearmed_pe2_fix";
1578
1579    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1580    {
1581       if (strcmp(var.value, "disabled") == 0)
1582          Config.RCntFix = 0;
1583       else if (strcmp(var.value, "enabled") == 0)
1584          Config.RCntFix = 1;
1585    }
1586
1587    var.value = "NULL";
1588    var.key = "pcsx_rearmed_idiablofix";
1589
1590    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1591    {
1592       if (strcmp(var.value, "disabled") == 0)
1593          spu_config.idiablofix = 0;
1594       else if (strcmp(var.value, "enabled") == 0)
1595          spu_config.idiablofix = 1;
1596    }
1597
1598    var.value = "NULL";
1599    var.key = "pcsx_rearmed_inuyasha_fix";
1600
1601    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1602    {
1603       if (strcmp(var.value, "disabled") == 0)
1604          Config.VSyncWA = 0;
1605       else if (strcmp(var.value, "enabled") == 0)
1606          Config.VSyncWA = 1;
1607    }
1608
1609    var.value = NULL;
1610    var.key = "pcsx_rearmed_noxadecoding";
1611    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1612    {
1613       if (strcmp(var.value, "disabled") == 0)
1614          Config.Xa = 1;
1615       else
1616          Config.Xa = 0;
1617    }
1618
1619    var.value = NULL;
1620    var.key = "pcsx_rearmed_nocdaudio";
1621    if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1622    {
1623       if (strcmp(var.value, "disabled") == 0)
1624          Config.Cdda = 1;
1625       else
1626          Config.Cdda = 0;
1627    }
1628
1629    if (in_flight) {
1630       // inform core things about possible config changes
1631       plugin_call_rearmed_cbs();
1632
1633       if (GPU_open != NULL && GPU_close != NULL) {
1634          GPU_close();
1635          GPU_open(&gpuDisp, "PCSX", NULL);
1636       }
1637
1638       dfinput_activate();
1639    }
1640    else
1641    {
1642       //not yet running
1643
1644       //bootlogo display hack
1645       if (found_bios) {
1646          var.value = "NULL";
1647          var.key = "pcsx_rearmed_show_bios_bootlogo";
1648          if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1649          {
1650             Config.SlowBoot = 0;
1651             rebootemu = 0;
1652             if (strcmp(var.value, "enabled") == 0)
1653             {
1654                Config.SlowBoot = 1;
1655                rebootemu = 1;
1656             }
1657          }
1658       }
1659 #ifndef DRC_DISABLE
1660       var.value = "NULL";
1661       var.key = "pcsx_rearmed_psxclock";
1662       if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1663       {
1664          int psxclock = atoi(var.value);
1665          cycle_multiplier = 10000 / psxclock;
1666       }
1667
1668       var.value = NULL;
1669       var.key = "pcsx_rearmed_nosmccheck";
1670       if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1671       {
1672          if (strcmp(var.value, "enabled") == 0)
1673             new_dynarec_hacks |= NDHACK_NO_SMC_CHECK;
1674          else
1675             new_dynarec_hacks &= ~NDHACK_NO_SMC_CHECK;
1676       }
1677
1678       var.value = NULL;
1679       var.key = "pcsx_rearmed_gteregsunneeded";
1680       if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1681       {
1682          if (strcmp(var.value, "enabled") == 0)
1683             new_dynarec_hacks |= NDHACK_GTE_UNNEEDED;
1684          else
1685             new_dynarec_hacks &= ~NDHACK_GTE_UNNEEDED;
1686       }
1687
1688       var.value = NULL;
1689       var.key = "pcsx_rearmed_nogteflags";
1690       if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value)
1691       {
1692          if (strcmp(var.value, "enabled") == 0)
1693             new_dynarec_hacks |= NDHACK_GTE_NO_FLAGS;
1694          else
1695             new_dynarec_hacks &= ~NDHACK_GTE_NO_FLAGS;
1696       }
1697 #endif
1698    }
1699 }
1700
1701 // Taken from beetle-psx-libretro
1702 static uint16_t get_analog_button(retro_input_state_t input_state_cb, int player_index, int id)
1703 {
1704         uint16_t button;
1705
1706         // NOTE: Analog buttons were added Nov 2017. Not all front-ends support this
1707         // feature (or pre-date it) so we need to handle this in a graceful way.
1708
1709         // First, try and get an analog value using the new libretro API constant
1710         button = input_state_cb(player_index,
1711                                                                         RETRO_DEVICE_ANALOG,
1712                                                                         RETRO_DEVICE_INDEX_ANALOG_BUTTON,
1713                                                                         id);
1714         button = MIN(button / 128, 255);
1715
1716         if (button == 0)
1717         {
1718                 // If we got exactly zero, we're either not pressing the button, or the front-end
1719                 // is not reporting analog values. We need to do a second check using the classic
1720                 // digital API method, to at least get some response - better than nothing.
1721
1722                 // NOTE: If we're really just not holding the button, we're still going to get zero.
1723
1724                 button = input_state_cb(player_index,
1725                                                                                 RETRO_DEVICE_JOYPAD,
1726                                                                                 0,
1727                                                                                 id) ? 255 : 0;
1728         }
1729
1730         return button;
1731 }
1732
1733 void retro_run(void)
1734 {
1735         int i;
1736         //SysReset must be run while core is running,Not in menu (Locks up Retroarch)
1737         if (rebootemu != 0) {
1738                 rebootemu = 0;
1739                 SysReset();
1740                 if (!Config.HLE && !Config.SlowBoot) {
1741                         // skip BIOS logos
1742                         psxRegs.pc = psxRegs.GPR.n.ra;
1743                 }
1744         }
1745
1746         if (display_internal_fps) {
1747                 frame_count++;
1748
1749                 if (frame_count % INTERNAL_FPS_SAMPLE_PERIOD == 0) {
1750                         unsigned internal_fps = pl_rearmed_cbs.flip_cnt * (is_pal_mode ? 50 : 60) / INTERNAL_FPS_SAMPLE_PERIOD;
1751                         char str[64];
1752                         const char *strc = (const char*)str;
1753                         struct retro_message msg =
1754                         {
1755                                 strc,
1756                                 180
1757                         };
1758
1759                         str[0] = '\0';
1760
1761                         snprintf(str, sizeof(str), "Internal FPS: %2d", internal_fps);
1762
1763                         pl_rearmed_cbs.flip_cnt = 0;
1764
1765                         environ_cb(RETRO_ENVIRONMENT_SET_MESSAGE, &msg);
1766                 }
1767         } else {
1768                 frame_count = 0;
1769         }
1770
1771         input_poll_cb();
1772
1773         bool updated = false;
1774         if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE_UPDATE, &updated) && updated)
1775                 update_variables(true);
1776
1777         // reset all keystate, query libretro for keystate
1778         int j;
1779         int lsx;
1780         int rsy;
1781         float negcon_twist_amplitude;
1782         int negcon_i_rs;
1783         int negcon_ii_rs;
1784         for(i = 0; i < PORTS_NUMBER; i++) {
1785                 in_keystate[i] = 0;
1786
1787                 if (in_type[i] == PSE_PAD_TYPE_NONE)
1788                         continue;
1789
1790                 if (in_type[i] == PSE_PAD_TYPE_NEGCON)
1791                 {
1792                         // Query digital inputs
1793                         //
1794                         // > Pad-Up
1795                         if (input_state_cb(i, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_UP)){
1796                                 in_keystate[i] |= (1 << DKEY_UP);
1797                         }
1798                         // > Pad-Right
1799                         if (input_state_cb(i, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT)){
1800                                 in_keystate[i] |= (1 << DKEY_RIGHT);
1801                         }
1802                         // > Pad-Down
1803                         if (input_state_cb(i, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_DOWN)){
1804                                 in_keystate[i] |= (1 << DKEY_DOWN);
1805                         }
1806                         // > Pad-Left
1807                         if (input_state_cb(i, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT)){
1808                                 in_keystate[i] |= (1 << DKEY_LEFT);
1809                         }
1810                         // > Start
1811                         if (input_state_cb(i, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_START)){
1812                                 in_keystate[i] |= (1 << DKEY_START);
1813                         }
1814                         // > neGcon A
1815                         if (input_state_cb(i, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A)){
1816                                 in_keystate[i] |= (1 << DKEY_CIRCLE);
1817                         }
1818                         // > neGcon B
1819                         if (input_state_cb(i, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_X)){
1820                                 in_keystate[i] |= (1 << DKEY_TRIANGLE);
1821                         }
1822                         // > neGcon R shoulder (digital)
1823                         if (input_state_cb(i, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_R)){
1824                                 in_keystate[i] |= (1 << DKEY_R1);
1825                         }
1826                         // Query analog inputs
1827                         //
1828                         // From studying 'libpcsxcore/plugins.c' and 'frontend/plugin.c':
1829                         // >> pad->leftJoyX  == in_analog_left[i][0]  == NeGcon II
1830                         // >> pad->leftJoyY  == in_analog_left[i][1]  == NeGcon L
1831                         // >> pad->rightJoyX == in_analog_right[i][0] == NeGcon twist
1832                         // >> pad->rightJoyY == in_analog_right[i][1] == NeGcon I
1833                         // So we just have to map in_analog_left/right to more
1834                         // appropriate inputs...
1835                         //
1836                         // > NeGcon twist
1837                         // >> Get raw analog stick value and account for deadzone
1838                         lsx = input_state_cb(i, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_X);
1839                         if (lsx > negcon_deadzone){
1840                                 lsx = lsx - negcon_deadzone;
1841                         } else if (lsx < -negcon_deadzone){
1842                                 lsx = lsx + negcon_deadzone;
1843                         } else {
1844                                 lsx = 0;
1845                         }
1846                         // >> Convert to an 'amplitude' [-1.0,1.0] and adjust response
1847                         negcon_twist_amplitude = (float)lsx / (float)(NEGCON_RANGE - negcon_deadzone);
1848                         if (negcon_linearity == 2){
1849                                 if (negcon_twist_amplitude < 0.0){
1850                                         negcon_twist_amplitude = -(negcon_twist_amplitude * negcon_twist_amplitude);
1851                                 } else {
1852                                         negcon_twist_amplitude = negcon_twist_amplitude * negcon_twist_amplitude;
1853                                 }
1854                         } else if (negcon_linearity == 3){
1855                                 negcon_twist_amplitude = negcon_twist_amplitude * negcon_twist_amplitude * negcon_twist_amplitude;
1856                         }
1857                         // >> Convert to final 'in_analog' integer value [0,255]
1858                         in_analog_right[i][0] = MAX(MIN((int)(negcon_twist_amplitude * 128.0f) + 128, 255), 0);
1859                         // > NeGcon I + II
1860                         // >> Handle right analog stick vertical axis mapping...
1861                         //    - Up (-Y) == accelerate == neGcon I
1862                         //    - Down (+Y) == brake == neGcon II
1863                         negcon_i_rs = 0;
1864                         negcon_ii_rs = 0;
1865                         rsy = input_state_cb(i, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_Y);
1866                         if (rsy >= 0){
1867                                 // Account for deadzone
1868                                 // (Note: have never encountered a gamepad with significant differences
1869                                 // in deadzone between left/right analog sticks, so use the regular 'twist'
1870                                 // deadzone here)
1871                                 if (rsy > negcon_deadzone){
1872                                         rsy = rsy - negcon_deadzone;
1873                                 } else {
1874                                         rsy = 0;
1875                                 }
1876                                 // Convert to 'in_analog' integer value [0,255]
1877                                 negcon_ii_rs = MIN((int)(((float)rsy / (float)(NEGCON_RANGE - negcon_deadzone)) * 255.0f), 255);
1878                         } else {
1879                                 if (rsy < -negcon_deadzone){
1880                                         rsy = -1 * (rsy + negcon_deadzone);
1881                                 } else {
1882                                         rsy = 0;
1883                                 }
1884                                 negcon_i_rs = MIN((int)(((float)rsy / (float)(NEGCON_RANGE - negcon_deadzone)) * 255.0f), 255);
1885                         }
1886                         // >> NeGcon I
1887                         in_analog_right[i][1] = MAX(
1888                                 MAX(
1889                                         get_analog_button(input_state_cb, i, RETRO_DEVICE_ID_JOYPAD_R2),
1890                                         get_analog_button(input_state_cb, i, RETRO_DEVICE_ID_JOYPAD_B)
1891                                 ),
1892                                 negcon_i_rs
1893                         );
1894                         // >> NeGcon II
1895                         in_analog_left[i][0] = MAX(
1896                                 MAX(
1897                                         get_analog_button(input_state_cb, i, RETRO_DEVICE_ID_JOYPAD_L2),
1898                                         get_analog_button(input_state_cb, i, RETRO_DEVICE_ID_JOYPAD_Y)
1899                                 ),
1900                                 negcon_ii_rs
1901                         );
1902                         // > NeGcon L
1903                         in_analog_left[i][1] = get_analog_button(input_state_cb, i, RETRO_DEVICE_ID_JOYPAD_L);
1904                 }
1905                 else
1906                 {
1907                         // Query digital inputs
1908                         for (j = 0; j < RETRO_PSX_MAP_LEN; j++){
1909                                 if (input_state_cb(i, RETRO_DEVICE_JOYPAD, 0, j)){
1910                                         in_keystate[i] |= retro_psx_map[j];
1911                                 }
1912                         }
1913                         // Query analog inputs
1914                         if (in_type[i] == PSE_PAD_TYPE_ANALOGJOY || in_type[i] == PSE_PAD_TYPE_ANALOGPAD)
1915                         {
1916                                 in_analog_left[i][0] = MIN((input_state_cb(i, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_X) / 255) + 128, 255);
1917                                 in_analog_left[i][1] = MIN((input_state_cb(i, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_LEFT, RETRO_DEVICE_ID_ANALOG_Y) / 255) + 128, 255);
1918                                 in_analog_right[i][0] = MIN((input_state_cb(i, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_X) / 255) + 128, 255);
1919                                 in_analog_right[i][1] = MIN((input_state_cb(i, RETRO_DEVICE_ANALOG, RETRO_DEVICE_INDEX_ANALOG_RIGHT, RETRO_DEVICE_ID_ANALOG_Y) / 255) + 128, 255);
1920                         }
1921                 }
1922         }
1923
1924         stop = 0;
1925         psxCpu->Execute();
1926
1927         video_cb((vout_fb_dirty || !vout_can_dupe || !duping_enable) ? vout_buf_ptr : NULL,
1928                 vout_width, vout_height, vout_width * 2);
1929         vout_fb_dirty = 0;
1930
1931     set_vout_fb();
1932 }
1933
1934 static bool try_use_bios(const char *path)
1935 {
1936         FILE *f;
1937         long size;
1938         const char *name;
1939
1940         f = fopen(path, "rb");
1941         if (f == NULL)
1942                 return false;
1943
1944         fseek(f, 0, SEEK_END);
1945         size = ftell(f);
1946         fclose(f);
1947
1948         if (size != 512 * 1024)
1949                 return false;
1950
1951         name = strrchr(path, SLASH);
1952         if (name++ == NULL)
1953                 name = path;
1954         snprintf(Config.Bios, sizeof(Config.Bios), "%s", name);
1955         return true;
1956 }
1957
1958 #ifndef VITA
1959 #include <sys/types.h>
1960 #include <dirent.h>
1961
1962 static bool find_any_bios(const char *dirpath, char *path, size_t path_size)
1963 {
1964         DIR *dir;
1965         struct dirent *ent;
1966         bool ret = false;
1967
1968         dir = opendir(dirpath);
1969         if (dir == NULL)
1970                 return false;
1971
1972         while ((ent = readdir(dir))) {
1973                 if (strncasecmp(ent->d_name, "scph", 4) != 0)
1974                         continue;
1975
1976                 snprintf(path, path_size, "%s%c%s", dirpath, SLASH, ent->d_name);
1977                 ret = try_use_bios(path);
1978                 if (ret)
1979                         break;
1980         }
1981         closedir(dir);
1982         return ret;
1983 }
1984 #else
1985 #define find_any_bios(...) false
1986 #endif
1987
1988 static void check_system_specs(void)
1989 {
1990    unsigned level = 6;
1991    environ_cb(RETRO_ENVIRONMENT_SET_PERFORMANCE_LEVEL, &level);
1992 }
1993
1994 static int init_memcards(void)
1995 {
1996         int ret = 0;
1997         const char *dir;
1998         struct retro_variable var = { .key="pcsx_rearmed_memcard2", .value=NULL };
1999         static const char CARD2_FILE[] = "pcsx-card2.mcd";
2000
2001         // Memcard2 will be handled and is re-enabled if needed using core
2002         // operations.
2003         // Memcard1 is handled by libretro, doing this will set core to
2004         // skip file io operations for memcard1 like SaveMcd
2005         snprintf(Config.Mcd1, sizeof(Config.Mcd1), "none");
2006         snprintf(Config.Mcd2, sizeof(Config.Mcd2), "none");
2007         init_memcard(Mcd1Data);
2008         // Memcard 2 is managed by the emulator on the filesystem,
2009         // There is no need to initialize Mcd2Data like Mcd1Data.
2010
2011         if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value) {
2012                 SysPrintf("Memcard 2: %s\n", var.value);
2013                 if (memcmp(var.value, "enabled", 7) == 0) {
2014                         if (environ_cb(RETRO_ENVIRONMENT_GET_SAVE_DIRECTORY, &dir) && dir) {
2015                                 if (strlen(dir) + strlen(CARD2_FILE) + 2 > sizeof(Config.Mcd2)) {
2016                                         SysPrintf("Path '%s' is too long. Cannot use memcard 2. Use a shorter path.\n", dir);
2017                                         ret = -1;
2018                                 } else {
2019                                         McdDisable[1] = 0;
2020                                         snprintf(Config.Mcd2, sizeof(Config.Mcd2), "%s/%s", dir, CARD2_FILE);
2021                                         SysPrintf("Use memcard 2: %s\n", Config.Mcd2);
2022                                 }
2023                         } else {
2024                                 SysPrintf("Could not get save directory! Could not create memcard 2.");
2025                                 ret = -1;
2026                         }
2027                 }
2028         }
2029         return ret;
2030 }
2031
2032 static void loadPSXBios(void)
2033 {
2034         const char *dir;
2035         char path[256];
2036         unsigned useHLE = 0;
2037
2038         const char *bios[] = {
2039                 "SCPH101", "scph101",
2040                 "SCPH5501", "scph5501",
2041                 "SCPH7001", "scph7001",
2042                 "SCPH1001", "scph1001"
2043         };
2044
2045         struct retro_variable var = {
2046                 .key = "pcsx_rearmed_bios",
2047                 .value = NULL
2048         };
2049
2050         found_bios = 0;
2051
2052         if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value) {
2053                 if (!strcmp(var.value, "HLE"))
2054                         useHLE = 1;
2055         }
2056
2057         if (!useHLE)
2058         {
2059                 if (environ_cb(RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY, &dir) && dir)
2060                 {
2061                         unsigned i;
2062                         snprintf(Config.BiosDir, sizeof(Config.BiosDir), "%s", dir);
2063
2064                         for (i = 0; i < sizeof(bios) / sizeof(bios[0]); i++) {
2065                                 snprintf(path, sizeof(path), "%s%c%s.bin", dir, SLASH, bios[i]);
2066                                 found_bios = try_use_bios(path);
2067                                 if (found_bios)
2068                                         break;
2069                         }
2070
2071                         if (!found_bios)
2072                                 found_bios = find_any_bios(dir, path, sizeof(path));
2073                 }
2074                 if (found_bios) {
2075                         SysPrintf("found BIOS file: %s\n", Config.Bios);
2076                 }
2077         }
2078
2079         if (useHLE || !found_bios)
2080         {
2081                 SysPrintf("no BIOS files found.\n");
2082                 struct retro_message msg =
2083                 {
2084                         "No PlayStation BIOS file found - add for better compatibility",
2085                         180
2086                 };
2087                 environ_cb(RETRO_ENVIRONMENT_SET_MESSAGE, (void*)&msg);
2088         }
2089 }
2090
2091 void retro_init(void)
2092 {
2093         struct retro_rumble_interface rumble;
2094         int ret;
2095
2096 #ifdef __MACH__
2097         // magic sauce to make the dynarec work on iOS
2098         syscall(SYS_ptrace, 0 /*PTRACE_TRACEME*/, 0, 0, 0);
2099 #endif
2100
2101 #ifdef _3DS
2102    psxMapHook = pl_3ds_mmap;
2103    psxUnmapHook = pl_3ds_munmap;
2104 #endif
2105 #ifdef VITA
2106    if(init_vita_mmap()<0)
2107       abort();
2108    psxMapHook = pl_vita_mmap;
2109    psxUnmapHook = pl_vita_munmap;
2110 #endif
2111         ret = emu_core_preinit();
2112 #ifdef _3DS
2113    /* emu_core_preinit sets the cpu to dynarec */
2114    if(!__ctr_svchax)
2115       Config.Cpu = CPU_INTERPRETER;
2116 #endif
2117         ret |= init_memcards();
2118
2119         ret |= emu_core_init();
2120         if (ret != 0) {
2121                 SysPrintf("PCSX init failed.\n");
2122                 exit(1);
2123         }
2124
2125 #ifdef _3DS
2126    vout_buf = linearMemAlign(VOUT_MAX_WIDTH * VOUT_MAX_HEIGHT * 2, 0x80);
2127 #elif defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200112L) && !defined(VITA)
2128         posix_memalign(&vout_buf, 16, VOUT_MAX_WIDTH * VOUT_MAX_HEIGHT * 2);
2129 #else
2130         vout_buf = malloc(VOUT_MAX_WIDTH * VOUT_MAX_HEIGHT * 2);
2131 #endif
2132
2133         vout_buf_ptr = vout_buf;
2134
2135         loadPSXBios();
2136
2137         environ_cb(RETRO_ENVIRONMENT_GET_CAN_DUPE, &vout_can_dupe);
2138         environ_cb(RETRO_ENVIRONMENT_SET_DISK_CONTROL_INTERFACE, &disk_control);
2139
2140         rumble_cb = NULL;
2141         if (environ_cb(RETRO_ENVIRONMENT_GET_RUMBLE_INTERFACE, &rumble))
2142                 rumble_cb = rumble.set_rumble_state;
2143
2144         /* Set how much slower PSX CPU runs * 100 (so that 200 is 2 times)
2145          * we have to do this because cache misses and some IO penalties
2146          * are not emulated. Warning: changing this may break compatibility. */
2147         cycle_multiplier = 175;
2148 #ifdef HAVE_PRE_ARMV7
2149         cycle_multiplier = 200;
2150 #endif
2151         pl_rearmed_cbs.gpu_peops.iUseDither = 1;
2152         spu_config.iUseFixedUpdates = 1;
2153
2154         SaveFuncs.open = save_open;
2155         SaveFuncs.read = save_read;
2156         SaveFuncs.write = save_write;
2157         SaveFuncs.seek = save_seek;
2158         SaveFuncs.close = save_close;
2159
2160         update_variables(false);
2161         check_system_specs();
2162 }
2163
2164 void retro_deinit(void)
2165 {
2166         SysClose();
2167 #ifdef _3DS
2168    linearFree(vout_buf);
2169 #else
2170         free(vout_buf);
2171 #endif
2172         vout_buf = NULL;
2173
2174 #ifdef VITA
2175   deinit_vita_mmap();
2176 #endif
2177 }
2178
2179 #ifdef VITA
2180 #include <psp2/kernel/threadmgr.h>
2181 int usleep (unsigned long us)
2182 {
2183    sceKernelDelayThread(us);
2184 }
2185 #endif