platform/libretro.c

   1 /*
   2  * libretro core glue for PicoDrive
   3  * (C) notaz, 2013
   4  *
   5  * This work is licensed under the terms of MAME license.
   6  * See COPYING file in the top-level directory.
   7  */
   8
   9 #define _GNU_SOURCE 1 // mremap
  10 #include <stdio.h>
  11 #include <stdarg.h>
  12 #include <string.h>
  13 #ifndef _WIN32
  14 #include <sys/mman.h>
  15 #else
  16 #include <io.h>
  17 #include <windows.h>
  18 #include <sys/types.h>
  19 #endif
  20 #include <errno.h>
  21 #ifdef __MACH__
  22 #include <libkern/OSCacheControl.h>
  23 #endif
  24
  25 #include <pico/pico_int.h>
  26 #include <pico/state.h>
  27 #include "common/input_pico.h"
  28 #include "common/version.h"
  29 #include "libretro.h"
  30
  31 static retro_video_refresh_t video_cb;
  32 static retro_input_poll_t input_poll_cb;
  33 static retro_input_state_t input_state_cb;
  34 static retro_environment_t environ_cb;
  35 static retro_audio_sample_batch_t audio_batch_cb;
  36
  37 static FILE *emu_log;
  38
  39 #define VOUT_MAX_WIDTH 320
  40 #define VOUT_MAX_HEIGHT 240
  41 static void *vout_buf;
  42 static int vout_width, vout_height, vout_offset;
  43
  44 static short __attribute__((aligned(4))) sndBuffer[2*44100/50];
  45
  46 static void snd_write(int len);
  47
  48 #ifdef _WIN32
  49 #define SLASH '\\'
  50 #else
  51 #define SLASH '/'
  52 #endif
  53
  54 /* functions called by the core */
  55
  56 void cache_flush_d_inval_i(void *start, void *end)
  57 {
  58 #ifdef __arm__
  59 #if defined(__BLACKBERRY_QNX__)
  60         msync(start, end - start, MS_SYNC | MS_CACHE_ONLY | MS_INVALIDATE_ICACHE);
  61 #elif defined(__MACH__)
  62         size_t len = (char *)end - (char *)start;
  63         sys_dcache_flush(start, len);
  64         sys_icache_invalidate(start, len);
  65 #else
  66         __clear_cache(start, end);
  67 #endif
  68 #endif
  69 }
  70
  71 #ifdef _WIN32
  72 /* mmap() replacement for Windows
  73  *
  74  * Author: Mike Frysinger <vapier@gentoo.org>
  75  * Placed into the public domain
  76  */
  77
  78 /* References:
  79  * CreateFileMapping: http://msdn.microsoft.com/en-us/library/aa366537(VS.85).aspx
  80  * CloseHandle:       http://msdn.microsoft.com/en-us/library/ms724211(VS.85).aspx
  81  * MapViewOfFile:     http://msdn.microsoft.com/en-us/library/aa366761(VS.85).aspx
  82  * UnmapViewOfFile:   http://msdn.microsoft.com/en-us/library/aa366882(VS.85).aspx
  83  */
  84
  85 #define PROT_READ     0x1
  86 #define PROT_WRITE    0x2
  87 /* This flag is only available in WinXP+ */
  88 #ifdef FILE_MAP_EXECUTE
  89 #define PROT_EXEC     0x4
  90 #else
  91 #define PROT_EXEC        0x0
  92 #define FILE_MAP_EXECUTE 0
  93 #endif
  94
  95 #define MAP_SHARED    0x01
  96 #define MAP_PRIVATE   0x02
  97 #define MAP_ANONYMOUS 0x20
  98 #define MAP_ANON      MAP_ANONYMOUS
  99 #define MAP_FAILED    ((void *) -1)
 100
 101 #ifdef __USE_FILE_OFFSET64
 102 # define DWORD_HI(x) (x >> 32)
 103 # define DWORD_LO(x) ((x) & 0xffffffff)
 104 #else
 105 # define DWORD_HI(x) (0)
 106 # define DWORD_LO(x) (x)
 107 #endif
 108
 109 static void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset)
 110 {
 111         if (prot & ~(PROT_READ | PROT_WRITE | PROT_EXEC))
 112                 return MAP_FAILED;
 113         if (fd == -1) {
 114                 if (!(flags & MAP_ANON) || offset)
 115                         return MAP_FAILED;
 116         } else if (flags & MAP_ANON)
 117                 return MAP_FAILED;
 118
 119         DWORD flProtect;
 120         if (prot & PROT_WRITE) {
 121                 if (prot & PROT_EXEC)
 122                         flProtect = PAGE_EXECUTE_READWRITE;
 123                 else
 124                         flProtect = PAGE_READWRITE;
 125         } else if (prot & PROT_EXEC) {
 126                 if (prot & PROT_READ)
 127                         flProtect = PAGE_EXECUTE_READ;
 128                 else if (prot & PROT_EXEC)
 129                         flProtect = PAGE_EXECUTE;
 130         } else
 131                 flProtect = PAGE_READONLY;
 132
 133         off_t end = length + offset;
 134         HANDLE mmap_fd, h;
 135         if (fd == -1)
 136                 mmap_fd = INVALID_HANDLE_VALUE;
 137         else
 138                 mmap_fd = (HANDLE)_get_osfhandle(fd);
 139         h = CreateFileMapping(mmap_fd, NULL, flProtect, DWORD_HI(end), DWORD_LO(end), NULL);
 140         if (h == NULL)
 141                 return MAP_FAILED;
 142
 143         DWORD dwDesiredAccess;
 144         if (prot & PROT_WRITE)
 145                 dwDesiredAccess = FILE_MAP_WRITE;
 146         else
 147                 dwDesiredAccess = FILE_MAP_READ;
 148         if (prot & PROT_EXEC)
 149                 dwDesiredAccess |= FILE_MAP_EXECUTE;
 150         if (flags & MAP_PRIVATE)
 151                 dwDesiredAccess |= FILE_MAP_COPY;
 152         void *ret = MapViewOfFile(h, dwDesiredAccess, DWORD_HI(offset), DWORD_LO(offset), length);
 153         if (ret == NULL) {
 154                 CloseHandle(h);
 155                 ret = MAP_FAILED;
 156         }
 157         return ret;
 158 }
 159
 160 static void munmap(void *addr, size_t length)
 161 {
 162         UnmapViewOfFile(addr);
 163         /* ruh-ro, we leaked handle from CreateFileMapping() ... */
 164 }
 165 #endif
 166
 167 #ifndef MAP_ANONYMOUS
 168 #define MAP_ANONYMOUS MAP_ANON
 169 #endif
 170
 171 void *plat_mmap(unsigned long addr, size_t size, int need_exec, int is_fixed)
 172 {
 173    int flags = MAP_PRIVATE | MAP_ANONYMOUS;
 174    void *req, *ret;
 175
 176    req = (void *)addr;
 177    ret = mmap(req, size, PROT_READ | PROT_WRITE, flags, -1, 0);
 178    if (ret == MAP_FAILED) {
 179       lprintf("mmap(%08lx, %zd) failed: %d\n", addr, size, errno);
 180       return NULL;
 181    }
 182
 183    if (addr != 0 && ret != (void *)addr) {
 184       lprintf("warning: wanted to map @%08lx, got %p\n",
 185             addr, ret);
 186
 187       if (is_fixed) {
 188          munmap(ret, size);
 189          return NULL;
 190       }
 191    }
 192
 193         return ret;
 194 }
 195
 196 void *plat_mremap(void *ptr, size_t oldsize, size_t newsize)
 197 {
 198 #ifdef __linux__
 199         void *ret = mremap(ptr, oldsize, newsize, 0);
 200         if (ret == MAP_FAILED)
 201                 return NULL;
 202
 203         return ret;
 204 #else
 205         void *tmp, *ret;
 206         size_t preserve_size;
 207
 208         preserve_size = oldsize;
 209         if (preserve_size > newsize)
 210                 preserve_size = newsize;
 211         tmp = malloc(preserve_size);
 212         if (tmp == NULL)
 213                 return NULL;
 214         memcpy(tmp, ptr, preserve_size);
 215
 216         munmap(ptr, oldsize);
 217         ret = mmap(ptr, newsize, PROT_READ | PROT_WRITE,
 218                    MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 219         if (ret == MAP_FAILED) {
 220                 free(tmp);
 221                 return NULL;
 222         }
 223         memcpy(ret, tmp, preserve_size);
 224         free(tmp);
 225         return ret;
 226 #endif
 227 }
 228
 229 void plat_munmap(void *ptr, size_t size)
 230 {
 231         if (ptr != NULL)
 232                 munmap(ptr, size);
 233 }
 234
 235 int plat_mem_set_exec(void *ptr, size_t size)
 236 {
 237 #ifdef _WIN32
 238    int ret = VirtualProtect(ptr,size,PAGE_EXECUTE_READWRITE,0);
 239    if (ret == 0)
 240       lprintf("mprotect(%p, %zd) failed: %d\n", ptr, size, 0);
 241 #else
 242    int ret = mprotect(ptr, size, PROT_READ | PROT_WRITE | PROT_EXEC);
 243    if (ret != 0)
 244       lprintf("mprotect(%p, %zd) failed: %d\n", ptr, size, errno);
 245 #endif
 246         return ret;
 247 }
 248
 249 void emu_video_mode_change(int start_line, int line_count, int is_32cols)
 250 {
 251         memset(vout_buf, 0, 320 * 240 * 2);
 252         vout_width = is_32cols ? 256 : 320;
 253         PicoDrawSetOutBuf(vout_buf, vout_width * 2);
 254
 255         vout_height = line_count;
 256         vout_offset = vout_width * start_line;
 257 }
 258
 259 void emu_32x_startup(void)
 260 {
 261 }
 262
 263 #ifndef ANDROID
 264
 265 void lprintf(const char *fmt, ...)
 266 {
 267         va_list list;
 268
 269         va_start(list, fmt);
 270         fprintf(emu_log, "PicoDrive: ");
 271         vfprintf(emu_log, fmt, list);
 272         va_end(list);
 273         fflush(emu_log);
 274 }
 275
 276 #else
 277
 278 #include <android/log.h>
 279
 280 void lprintf(const char *fmt, ...)
 281 {
 282         va_list list;
 283
 284         va_start(list, fmt);
 285         __android_log_vprint(ANDROID_LOG_INFO, "PicoDrive", fmt, list);
 286         va_end(list);
 287 }
 288
 289 #endif
 290
 291 /* libretro */
 292 void retro_set_environment(retro_environment_t cb)
 293 {
 294         static const struct retro_variable vars[] = {
 295                 //{ "region", "Region; Auto|NTSC|PAL" },
 296                 { "picodrive_input1", "Input device 1; 3 button pad|6 button pad|None" },
 297                 { "picodrive_input2", "Input device 2; 3 button pad|6 button pad|None" },
 298                 { "picodrive_sprlim", "No sprite limit; disabled|enabled" },
 299                 { "picodrive_ramcart", "MegaCD RAM cart; disabled|enabled" },
 300 #ifdef DRC_SH2
 301                 { "picodrive_drc", "Dynamic recompilers; enabled|disabled" },
 302 #endif
 303                 { NULL, NULL },
 304         };
 305
 306         environ_cb = cb;
 307
 308         cb(RETRO_ENVIRONMENT_SET_VARIABLES, (void *)vars);
 309 }
 310
 311 void retro_set_video_refresh(retro_video_refresh_t cb) { video_cb = cb; }
 312 void retro_set_audio_sample(retro_audio_sample_t cb) { (void)cb; }
 313 void retro_set_audio_sample_batch(retro_audio_sample_batch_t cb) { audio_batch_cb = cb; }
 314 void retro_set_input_poll(retro_input_poll_t cb) { input_poll_cb = cb; }
 315 void retro_set_input_state(retro_input_state_t cb) { input_state_cb = cb; }
 316
 317 unsigned retro_api_version(void)
 318 {
 319         return RETRO_API_VERSION;
 320 }
 321
 322 void retro_set_controller_port_device(unsigned port, unsigned device)
 323 {
 324 }
 325
 326 void retro_get_system_info(struct retro_system_info *info)
 327 {
 328         memset(info, 0, sizeof(*info));
 329         info->library_name = "PicoDrive";
 330         info->library_version = VERSION;
 331         info->valid_extensions = "bin|gen|smd|md|32x|cue|iso|sms";
 332         info->need_fullpath = true;
 333 }
 334
 335 void retro_get_system_av_info(struct retro_system_av_info *info)
 336 {
 337         memset(info, 0, sizeof(*info));
 338         info->timing.fps            = Pico.m.pal ? 50 : 60;
 339         info->timing.sample_rate    = 44100;
 340         info->geometry.base_width   = 320;
 341         info->geometry.base_height  = vout_height;
 342         info->geometry.max_width    = VOUT_MAX_WIDTH;
 343         info->geometry.max_height   = VOUT_MAX_HEIGHT;
 344         info->geometry.aspect_ratio = 0.0f;
 345 }
 346
 347 /* savestates */
 348 struct savestate_state {
 349         const char *load_buf;
 350         char *save_buf;
 351         size_t size;
 352         size_t pos;
 353 };
 354
 355 size_t state_read(void *p, size_t size, size_t nmemb, void *file)
 356 {
 357         struct savestate_state *state = file;
 358         size_t bsize = size * nmemb;
 359
 360         if (state->pos + bsize > state->size) {
 361                 lprintf("savestate error: %u/%u\n",
 362                         state->pos + bsize, state->size);
 363                 bsize = state->size - state->pos;
 364                 if ((int)bsize <= 0)
 365                         return 0;
 366         }
 367
 368         memcpy(p, state->load_buf + state->pos, bsize);
 369         state->pos += bsize;
 370         return bsize;
 371 }
 372
 373 size_t state_write(void *p, size_t size, size_t nmemb, void *file)
 374 {
 375         struct savestate_state *state = file;
 376         size_t bsize = size * nmemb;
 377
 378         if (state->pos + bsize > state->size) {
 379                 lprintf("savestate error: %u/%u\n",
 380                         state->pos + bsize, state->size);
 381                 bsize = state->size - state->pos;
 382                 if ((int)bsize <= 0)
 383                         return 0;
 384         }
 385
 386         memcpy(state->save_buf + state->pos, p, bsize);
 387         state->pos += bsize;
 388         return bsize;
 389 }
 390
 391 size_t state_skip(void *p, size_t size, size_t nmemb, void *file)
 392 {
 393         struct savestate_state *state = file;
 394         size_t bsize = size * nmemb;
 395
 396         state->pos += bsize;
 397         return bsize;
 398 }
 399
 400 size_t state_eof(void *file)
 401 {
 402         struct savestate_state *state = file;
 403
 404         return state->pos >= state->size;
 405 }
 406
 407 int state_fseek(void *file, long offset, int whence)
 408 {
 409         struct savestate_state *state = file;
 410
 411         switch (whence) {
 412         case SEEK_SET:
 413                 state->pos = offset;
 414                 break;
 415         case SEEK_CUR:
 416                 state->pos += offset;
 417                 break;
 418         case SEEK_END:
 419                 state->pos = state->size + offset;
 420                 break;
 421         }
 422         return (int)state->pos;
 423 }
 424
 425 /* savestate sizes vary wildly depending if cd/32x or
 426  * carthw is active, so run the whole thing to get size */
 427 size_t retro_serialize_size(void)
 428 {
 429         struct savestate_state state = { 0, };
 430         int ret;
 431
 432         ret = PicoStateFP(&state, 1, NULL, state_skip, NULL, state_fseek);
 433         if (ret != 0)
 434                 return 0;
 435
 436         return state.pos;
 437 }
 438
 439 bool retro_serialize(void *data, size_t size)
 440 {
 441         struct savestate_state state = { 0, };
 442         int ret;
 443
 444         state.save_buf = data;
 445         state.size = size;
 446         state.pos = 0;
 447
 448         ret = PicoStateFP(&state, 1, NULL, state_write,
 449                 NULL, state_fseek);
 450         return ret == 0;
 451 }
 452
 453 bool retro_unserialize(const void *data, size_t size)
 454 {
 455         struct savestate_state state = { 0, };
 456         int ret;
 457
 458         state.load_buf = data;
 459         state.size = size;
 460         state.pos = 0;
 461
 462         ret = PicoStateFP(&state, 0, state_read, NULL,
 463                 state_eof, state_fseek);
 464         return ret == 0;
 465 }
 466
 467 /* cheats - TODO */
 468 void retro_cheat_reset(void)
 469 {
 470 }
 471
 472 void retro_cheat_set(unsigned index, bool enabled, const char *code)
 473 {
 474 }
 475
 476 /* multidisk support */
 477 static bool disk_ejected;
 478 static unsigned int disk_current_index;
 479 static unsigned int disk_count;
 480 static struct disks_state {
 481         char *fname;
 482 } disks[8];
 483
 484 static bool disk_set_eject_state(bool ejected)
 485 {
 486         // TODO?
 487         disk_ejected = ejected;
 488         return true;
 489 }
 490
 491 static bool disk_get_eject_state(void)
 492 {
 493         return disk_ejected;
 494 }
 495
 496 static unsigned int disk_get_image_index(void)
 497 {
 498         return disk_current_index;
 499 }
 500
 501 static bool disk_set_image_index(unsigned int index)
 502 {
 503         enum cd_img_type cd_type;
 504         int ret;
 505
 506         if (index >= sizeof(disks) / sizeof(disks[0]))
 507                 return false;
 508
 509         if (disks[index].fname == NULL) {
 510                 lprintf("missing disk #%u\n", index);
 511
 512                 // RetroArch specifies "no disk" with index == count,
 513                 // so don't fail here..
 514                 disk_current_index = index;
 515                 return true;
 516         }
 517
 518         lprintf("switching to disk %u: \"%s\"\n", index,
 519                 disks[index].fname);
 520
 521         ret = -1;
 522         cd_type = PicoCdCheck(disks[index].fname, NULL);
 523         if (cd_type != CIT_NOT_CD)
 524                 ret = cdd_load(disks[index].fname, cd_type);
 525         if (ret != 0) {
 526                 lprintf("Load failed, invalid CD image?\n");
 527                 return 0;
 528         }
 529
 530         disk_current_index = index;
 531         return true;
 532 }
 533
 534 static unsigned int disk_get_num_images(void)
 535 {
 536         return disk_count;
 537 }
 538
 539 static bool disk_replace_image_index(unsigned index,
 540         const struct retro_game_info *info)
 541 {
 542         bool ret = true;
 543
 544         if (index >= sizeof(disks) / sizeof(disks[0]))
 545                 return false;
 546
 547         if (disks[index].fname != NULL)
 548                 free(disks[index].fname);
 549         disks[index].fname = NULL;
 550
 551         if (info != NULL) {
 552                 disks[index].fname = strdup(info->path);
 553                 if (index == disk_current_index)
 554                         ret = disk_set_image_index(index);
 555         }
 556
 557         return ret;
 558 }
 559
 560 static bool disk_add_image_index(void)
 561 {
 562         if (disk_count >= sizeof(disks) / sizeof(disks[0]))
 563                 return false;
 564
 565         disk_count++;
 566         return true;
 567 }
 568
 569 static struct retro_disk_control_callback disk_control = {
 570         .set_eject_state = disk_set_eject_state,
 571         .get_eject_state = disk_get_eject_state,
 572         .get_image_index = disk_get_image_index,
 573         .set_image_index = disk_set_image_index,
 574         .get_num_images = disk_get_num_images,
 575         .replace_image_index = disk_replace_image_index,
 576         .add_image_index = disk_add_image_index,
 577 };
 578
 579 static void disk_tray_open(void)
 580 {
 581         lprintf("cd tray open\n");
 582         disk_ejected = 1;
 583 }
 584
 585 static void disk_tray_close(void)
 586 {
 587         lprintf("cd tray close\n");
 588         disk_ejected = 0;
 589 }
 590
 591
 592 static const char * const biosfiles_us[] = {
 593         "us_scd2_9306", "SegaCDBIOS9303", "us_scd1_9210", "bios_CD_U"
 594 };
 595 static const char * const biosfiles_eu[] = {
 596         "eu_mcd2_9306", "eu_mcd2_9303", "eu_mcd1_9210", "bios_CD_E"
 597 };
 598 static const char * const biosfiles_jp[] = {
 599         "jp_mcd2_921222", "jp_mcd1_9112", "jp_mcd1_9111", "bios_CD_J"
 600 };
 601
 602 static void make_system_path(char *buf, size_t buf_size,
 603         const char *name, const char *ext)
 604 {
 605         const char *dir = NULL;
 606
 607         if (environ_cb(RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY, &dir) && dir) {
 608                 snprintf(buf, buf_size, "%s%c%s%s", dir, SLASH, name, ext);
 609         }
 610         else {
 611                 snprintf(buf, buf_size, "%s%s", name, ext);
 612         }
 613 }
 614
 615 static const char *find_bios(int *region, const char *cd_fname)
 616 {
 617         const char * const *files;
 618         static char path[256];
 619         int i, count;
 620         FILE *f = NULL;
 621
 622         if (*region == 4) { // US
 623                 files = biosfiles_us;
 624                 count = sizeof(biosfiles_us) / sizeof(char *);
 625         } else if (*region == 8) { // EU
 626                 files = biosfiles_eu;
 627                 count = sizeof(biosfiles_eu) / sizeof(char *);
 628         } else if (*region == 1 || *region == 2) {
 629                 files = biosfiles_jp;
 630                 count = sizeof(biosfiles_jp) / sizeof(char *);
 631         } else {
 632                 return NULL;
 633         }
 634
 635         for (i = 0; i < count; i++)
 636         {
 637                 make_system_path(path, sizeof(path), files[i], ".bin");
 638                 f = fopen(path, "rb");
 639                 if (f != NULL)
 640                         break;
 641
 642                 make_system_path(path, sizeof(path), files[i], ".zip");
 643                 f = fopen(path, "rb");
 644                 if (f != NULL)
 645                         break;
 646         }
 647
 648         if (f != NULL) {
 649                 lprintf("using bios: %s\n", path);
 650                 fclose(f);
 651                 return path;
 652         }
 653
 654         return NULL;
 655 }
 656
 657 bool retro_load_game(const struct retro_game_info *info)
 658 {
 659         enum media_type_e media_type;
 660         static char carthw_path[256];
 661         size_t i;
 662
 663         enum retro_pixel_format fmt = RETRO_PIXEL_FORMAT_RGB565;
 664         if (!environ_cb(RETRO_ENVIRONMENT_SET_PIXEL_FORMAT, &fmt)) {
 665                 lprintf("RGB565 support required, sorry\n");
 666                 return false;
 667         }
 668
 669         if (info == NULL || info->path == NULL) {
 670                 lprintf("info->path required\n");
 671                 return false;
 672         }
 673
 674         for (i = 0; i < sizeof(disks) / sizeof(disks[0]); i++) {
 675                 if (disks[i].fname != NULL) {
 676                         free(disks[i].fname);
 677                         disks[i].fname = NULL;
 678                 }
 679         }
 680
 681         disk_current_index = 0;
 682         disk_count = 1;
 683         disks[0].fname = strdup(info->path);
 684
 685         make_system_path(carthw_path, sizeof(carthw_path), "carthw", ".cfg");
 686
 687         media_type = PicoLoadMedia(info->path, carthw_path,
 688                         find_bios, NULL);
 689
 690         switch (media_type) {
 691         case PM_BAD_DETECT:
 692                 lprintf("Failed to detect ROM/CD image type.\n");
 693                 return false;
 694         case PM_BAD_CD:
 695                 lprintf("Invalid CD image\n");
 696                 return false;
 697         case PM_BAD_CD_NO_BIOS:
 698                 lprintf("Missing BIOS\n");
 699                 return false;
 700         case PM_ERROR:
 701                 lprintf("Load error\n");
 702                 return false;
 703         default:
 704                 break;
 705         }
 706
 707         PicoLoopPrepare();
 708
 709         PicoWriteSound = snd_write;
 710         memset(sndBuffer, 0, sizeof(sndBuffer));
 711         PsndOut = sndBuffer;
 712         PsndRerate(0);
 713
 714         return true;
 715 }
 716
 717 bool retro_load_game_special(unsigned game_type, const struct retro_game_info *info, size_t num_info)
 718 {
 719         return false;
 720 }
 721
 722 void retro_unload_game(void)
 723 {
 724 }
 725
 726 unsigned retro_get_region(void)
 727 {
 728         return Pico.m.pal ? RETRO_REGION_PAL : RETRO_REGION_NTSC;
 729 }
 730
 731 void *retro_get_memory_data(unsigned id)
 732 {
 733         if (id != RETRO_MEMORY_SAVE_RAM)
 734                 return NULL;
 735
 736         if (PicoAHW & PAHW_MCD)
 737                 return Pico_mcd->bram;
 738         else
 739                 return SRam.data;
 740 }
 741
 742 size_t retro_get_memory_size(unsigned id)
 743 {
 744         unsigned int i;
 745         int sum;
 746
 747         if (id != RETRO_MEMORY_SAVE_RAM)
 748                 return 0;
 749
 750         if (PicoAHW & PAHW_MCD)
 751                 // bram
 752                 return 0x2000;
 753
 754         if (Pico.m.frame_count == 0)
 755                 return SRam.size;
 756
 757         // if game doesn't write to sram, don't report it to
 758         // libretro so that RA doesn't write out zeroed .srm
 759         for (i = 0, sum = 0; i < SRam.size; i++)
 760                 sum |= SRam.data[i];
 761
 762         return (sum != 0) ? SRam.size : 0;
 763 }
 764
 765 void retro_reset(void)
 766 {
 767         PicoReset();
 768 }
 769
 770 static const unsigned short retro_pico_map[] = {
 771         [RETRO_DEVICE_ID_JOYPAD_B]      = 1 << GBTN_B,
 772         [RETRO_DEVICE_ID_JOYPAD_Y]      = 1 << GBTN_A,
 773         [RETRO_DEVICE_ID_JOYPAD_SELECT] = 1 << GBTN_MODE,
 774         [RETRO_DEVICE_ID_JOYPAD_START]  = 1 << GBTN_START,
 775         [RETRO_DEVICE_ID_JOYPAD_UP]     = 1 << GBTN_UP,
 776         [RETRO_DEVICE_ID_JOYPAD_DOWN]   = 1 << GBTN_DOWN,
 777         [RETRO_DEVICE_ID_JOYPAD_LEFT]   = 1 << GBTN_LEFT,
 778         [RETRO_DEVICE_ID_JOYPAD_RIGHT]  = 1 << GBTN_RIGHT,
 779         [RETRO_DEVICE_ID_JOYPAD_A]      = 1 << GBTN_C,
 780         [RETRO_DEVICE_ID_JOYPAD_X]      = 1 << GBTN_Y,
 781         [RETRO_DEVICE_ID_JOYPAD_L]      = 1 << GBTN_X,
 782         [RETRO_DEVICE_ID_JOYPAD_R]      = 1 << GBTN_Z,
 783 };
 784 #define RETRO_PICO_MAP_LEN (sizeof(retro_pico_map) / sizeof(retro_pico_map[0]))
 785
 786 static void snd_write(int len)
 787 {
 788         audio_batch_cb(PsndOut, len / 4);
 789 }
 790
 791 static enum input_device input_name_to_val(const char *name)
 792 {
 793         if (strcmp(name, "3 button pad") == 0)
 794                 return PICO_INPUT_PAD_3BTN;
 795         if (strcmp(name, "6 button pad") == 0)
 796                 return PICO_INPUT_PAD_6BTN;
 797         if (strcmp(name, "None") == 0)
 798                 return PICO_INPUT_NOTHING;
 799
 800         lprintf("invalid picodrive_input: '%s'\n", name);
 801         return PICO_INPUT_PAD_3BTN;
 802 }
 803
 804 static void update_variables(void)
 805 {
 806         struct retro_variable var;
 807
 808         var.value = NULL;
 809         var.key = "picodrive_input1";
 810         if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
 811                 PicoSetInputDevice(0, input_name_to_val(var.value));
 812
 813         var.value = NULL;
 814         var.key = "picodrive_input2";
 815         if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
 816                 PicoSetInputDevice(1, input_name_to_val(var.value));
 817
 818         var.value = NULL;
 819         var.key = "picodrive_sprlim";
 820         if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value) {
 821                 if (strcmp(var.value, "enabled") == 0)
 822                         PicoOpt |= POPT_DIS_SPRITE_LIM;
 823                 else
 824                         PicoOpt &= ~POPT_DIS_SPRITE_LIM;
 825         }
 826
 827         var.value = NULL;
 828         var.key = "picodrive_ramcart";
 829         if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value) {
 830                 if (strcmp(var.value, "enabled") == 0)
 831                         PicoOpt |= POPT_EN_MCD_RAMCART;
 832                 else
 833                         PicoOpt &= ~POPT_EN_MCD_RAMCART;
 834         }
 835
 836 #ifdef DRC_SH2
 837         var.value = NULL;
 838         var.key = "picodrive_drc";
 839         if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value) {
 840                 if (strcmp(var.value, "enabled") == 0)
 841                         PicoOpt |= POPT_EN_DRC;
 842                 else
 843                         PicoOpt &= ~POPT_EN_DRC;
 844         }
 845 #endif
 846 }
 847
 848 void retro_run(void)
 849 {
 850         bool updated = false;
 851         int pad, i;
 852
 853         if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE_UPDATE, &updated) && updated)
 854                 update_variables();
 855
 856         input_poll_cb();
 857
 858         PicoPad[0] = PicoPad[1] = 0;
 859         for (pad = 0; pad < 2; pad++)
 860                 for (i = 0; i < RETRO_PICO_MAP_LEN; i++)
 861                         if (input_state_cb(pad, RETRO_DEVICE_JOYPAD, 0, i))
 862                                 PicoPad[pad] |= retro_pico_map[i];
 863
 864         PicoFrame();
 865
 866         video_cb((short *)vout_buf + vout_offset,
 867                 vout_width, vout_height, vout_width * 2);
 868 }
 869
 870 void retro_init(void)
 871 {
 872         int level;
 873
 874 #ifdef IOS
 875         emu_log = fopen("/User/Documents/PicoDrive.log", "w");
 876         if (emu_log == NULL)
 877                 emu_log = fopen("PicoDrive.log", "w");
 878         if (emu_log == NULL)
 879 #endif
 880         emu_log = stdout;
 881
 882         level = 0;
 883         environ_cb(RETRO_ENVIRONMENT_SET_PERFORMANCE_LEVEL, &level);
 884
 885         environ_cb(RETRO_ENVIRONMENT_SET_DISK_CONTROL_INTERFACE, &disk_control);
 886
 887         PicoOpt = POPT_EN_STEREO|POPT_EN_FM|POPT_EN_PSG|POPT_EN_Z80
 888                 | POPT_EN_MCD_PCM|POPT_EN_MCD_CDDA|POPT_EN_MCD_GFX
 889                 | POPT_EN_32X|POPT_EN_PWM
 890                 | POPT_ACC_SPRITES|POPT_DIS_32C_BORDER;
 891 #ifdef __arm__
 892         PicoOpt |= POPT_EN_DRC;
 893 #endif
 894         PsndRate = 44100;
 895         PicoAutoRgnOrder = 0x184; // US, EU, JP
 896
 897         vout_width = 320;
 898         vout_height = 240;
 899         vout_buf = malloc(VOUT_MAX_WIDTH * VOUT_MAX_HEIGHT * 2);
 900
 901         PicoInit();
 902         PicoDrawSetOutFormat(PDF_RGB555, 0);
 903         PicoDrawSetOutBuf(vout_buf, vout_width * 2);
 904
 905         //PicoMessage = plat_status_msg_busy_next;
 906         PicoMCDopenTray = disk_tray_open;
 907         PicoMCDcloseTray = disk_tray_close;
 908
 909         update_variables();
 910 }
 911
 912 void retro_deinit(void)
 913 {
 914         PicoExit();
 915 }