static struct retro_log_callback logging;
static retro_log_printf_t log_cb;
+#define LogWarn(fmt, ...) do { \
+ if (log_cb) log_cb(RETRO_LOG_WARN, fmt, ##__VA_ARGS__); \
+} while (0)
+#define LogErr(fmt, ...) do { \
+ if (log_cb) log_cb(RETRO_LOG_ERROR, fmt, ##__VA_ARGS__); \
+} while (0)
+
static unsigned msg_interface_version = 0;
static void *vout_buf;
static void *vout_buf_ptr;
-static int vout_width, vout_height;
+static int vout_width = 256, vout_height = 240, vout_pitch = 256;
static int vout_fb_dirty;
static int psx_w, psx_h;
static bool vout_can_dupe;
-static bool duping_enable;
static bool found_bios;
static bool display_internal_fps = false;
static unsigned frame_count = 0;
static bool show_advanced_gpu_unai_settings = true;
#endif
static float mouse_sensitivity = 1.0f;
+static unsigned int disk_current_index;
typedef enum
{
int multitap1 = 0;
int multitap2 = 0;
int in_enable_vibration = 1;
-int in_enable_crosshair[2] = { 0, 0 };
+static int in_enable_crosshair[2] = { 0, 0 };
+static int in_dualshock_analog_combo = 0;
+static bool in_dualshock_toggling = false;
// NegCon adjustment parameters
// > The NegCon 'twist' action is somewhat awkward when mapped
fb.height = vout_height;
fb.access_flags = RETRO_MEMORY_ACCESS_WRITE;
- if (environ_cb(RETRO_ENVIRONMENT_GET_CURRENT_SOFTWARE_FRAMEBUFFER, &fb) && fb.format == RETRO_PIXEL_FORMAT_RGB565)
- vout_buf_ptr = (uint16_t *)fb.data;
+ vout_pitch = vout_width;
+ if (environ_cb(RETRO_ENVIRONMENT_GET_CURRENT_SOFTWARE_FRAMEBUFFER, &fb)
+ && fb.format == RETRO_PIXEL_FORMAT_RGB565
+ && vout_can_dupe)
+ {
+ vout_buf_ptr = fb.data;
+ if (fb.pitch / 2 != vout_pitch && fb.pitch != vout_width * 2)
+ LogWarn("got unusual pitch %zd for resolution %dx%d\n", fb.pitch, vout_width, vout_height);
+ vout_pitch = fb.pitch / 2;
+ }
else
vout_buf_ptr = vout_buf;
}
{
unsigned short *dest = vout_buf_ptr;
const unsigned short *src = vram;
- int dstride = vout_width, h1 = h;
+ int dstride = vout_pitch, h1 = h;
int port = 0;
if (vram == NULL || dims_changed || (in_enable_crosshair[0] + in_enable_crosshair[1]) > 0)
out:
#ifndef FRONTEND_SUPPORTS_RGB565
- convert(vout_buf_ptr, vout_width * vout_height * 2);
+ convert(vout_buf_ptr, vout_pitch * vout_height * 2);
#endif
vout_fb_dirty = 1;
pl_rearmed_cbs.flip_cnt++;
{ NULL, 0x12800000, 0x010000, MAP_TAG_OTHER }, // 0x1f800000
{ NULL, 0x12c00000, 0x080000, MAP_TAG_OTHER }, // 0x1fc00000
{ NULL, 0x11000000, 0x800000, MAP_TAG_LUTS }, // 0x08000000
- { NULL, 0x12000000, 0x200000, MAP_TAG_VRAM }, // 0x00000000
+ { NULL, 0x12000000, 0x201000, MAP_TAG_VRAM }, // 0x00000000
};
void *pl_3ds_mmap(unsigned long addr, size_t size, int is_fixed,
if ((custom_map->size == size) && (custom_map->tag == tag))
{
uint32_t ptr_aligned, tmp;
+ void *ret;
custom_map->buffer = malloc(size + 0x1000);
ptr_aligned = (((u32)custom_map->buffer) + 0xFFF) & ~0xFFF;
if (svcControlMemory(&tmp, (void *)custom_map->target_map, (void *)ptr_aligned, size, MEMOP_MAP, 0x3) < 0)
{
- SysPrintf("could not map memory @0x%08X\n", custom_map->target_map);
+ LogErr("could not map memory @0x%08X\n", custom_map->target_map);
exit(1);
}
- return (void *)custom_map->target_map;
+ ret = (void *)custom_map->target_map;
+ memset(ret, 0, size);
+ return ret;
}
}
}
- return malloc(size);
+ return calloc(size, 1);
}
void pl_3ds_munmap(void *ptr, size_t size, enum psxMapTag tag)
typedef struct
{
void *buffer;
- uint32_t target_map;
size_t size;
enum psxMapTag tag;
+ int used;
} psx_map_t;
-void *addr = NULL;
+static void *addr = NULL;
psx_map_t custom_psx_maps[] = {
- { NULL, NULL, 0x210000, MAP_TAG_RAM }, // 0x80000000
- { NULL, NULL, 0x010000, MAP_TAG_OTHER }, // 0x1f800000
- { NULL, NULL, 0x080000, MAP_TAG_OTHER }, // 0x1fc00000
- { NULL, NULL, 0x800000, MAP_TAG_LUTS }, // 0x08000000
- { NULL, NULL, 0x200000, MAP_TAG_VRAM }, // 0x00000000
+ { NULL, 0x800000, MAP_TAG_LUTS },
+ { NULL, 0x080000, MAP_TAG_OTHER },
+ { NULL, 0x010000, MAP_TAG_OTHER },
+ { NULL, 0x201000, MAP_TAG_VRAM },
+ { NULL, 0x802000, MAP_TAG_VRAM }, // enhanced renderer
+ { NULL, 0x210000, MAP_TAG_RAM },
};
int init_vita_mmap()
addr = malloc(64 * 1024 * 1024);
if (addr == NULL)
return -1;
- tmpaddr = ((u32)(addr + 0xFFFFFF)) & ~0xFFFFFF;
- custom_psx_maps[0].buffer = tmpaddr + 0x2000000;
- custom_psx_maps[1].buffer = tmpaddr + 0x1800000;
- custom_psx_maps[2].buffer = tmpaddr + 0x1c00000;
- custom_psx_maps[3].buffer = tmpaddr + 0x0000000;
+ tmpaddr = (void *)(((size_t)addr + 0xFFFFFF) & ~0xFFFFFF);
+ custom_psx_maps[0].buffer = tmpaddr + 0x0000000;
+ custom_psx_maps[1].buffer = tmpaddr + 0x0800000;
+ custom_psx_maps[2].buffer = tmpaddr + 0x0880000;
+ custom_psx_maps[3].buffer = tmpaddr + 0x0900000;
custom_psx_maps[4].buffer = tmpaddr + 0x1000000;
+ custom_psx_maps[5].buffer = tmpaddr + 0x2000000;
+ memset(tmpaddr, 0, 0x2210000);
#if 0
for(n = 0; n < 5; n++){
sceClibPrintf("addr reserved %x\n",custom_psx_maps[n].buffer);
void deinit_vita_mmap()
{
+ size_t i;
+ for (i = 0; i < sizeof(custom_psx_maps) / sizeof(custom_psx_maps[0]); i++) {
+ custom_psx_maps[i].buffer = NULL;
+ custom_psx_maps[i].used = 0;
+ }
free(addr);
}
for (; custom_map->size; custom_map++)
{
- if ((custom_map->size == size) && (custom_map->tag == tag))
+ if (custom_map->size == size && custom_map->tag == tag && !custom_map->used)
{
+ custom_map->used = 1;
return custom_map->buffer;
}
}
- return malloc(size);
+ return calloc(size, 1);
}
void pl_vita_munmap(void *ptr, size_t size, enum psxMapTag tag)
{
if ((custom_map->buffer == ptr))
{
+ custom_map->used = 0;
return;
}
}
void retro_get_system_av_info(struct retro_system_av_info *info)
{
- unsigned geom_height = vout_height > 0 ? vout_height : 240;
- unsigned geom_width = vout_width > 0 ? vout_width : 320;
+ unsigned geom_height = vout_height;
+ unsigned geom_width = vout_width;
memset(info, 0, sizeof(*info));
info->timing.fps = is_pal_mode ? 50.0 : 60.0;
return;
if (fp->pos > r_size)
- SysPrintf("ERROR: save buffer overflow detected\n");
+ LogErr("ERROR: save buffer overflow detected\n");
else if (fp->is_write && fp->pos < r_size)
// make sure we don't save trash in leftover space
memset(fp->buf + fp->pos, 0, r_size - fp->pos);
bool retro_serialize(void *data, size_t size)
{
- int ret = SaveState(data);
+ int ret;
+ CdromFrontendId = disk_current_index;
+ ret = SaveState(data);
return ret == 0 ? true : false;
}
+static bool disk_set_image_index(unsigned int index);
+
bool retro_unserialize(const void *data, size_t size)
{
- int ret = LoadState(data);
- return ret == 0 ? true : false;
+ int ret;
+ CdromFrontendId = -1;
+ ret = LoadState(data);
+ if (ret)
+ return false;
+ if (CdromFrontendId != -1 && CdromFrontendId != disk_current_index)
+ disk_set_image_index(CdromFrontendId);
+ return true;
}
/* cheats */
finish:
if (ret != 0)
- SysPrintf("Failed to set cheat %#u\n", index);
+ LogErr("Failed to set cheat %#u\n", index);
else if (index < NumCheats)
Cheats[index].Enabled = enabled;
free(buf);
static unsigned int disk_initial_index;
static char disk_initial_path[PATH_MAX];
static bool disk_ejected;
-static unsigned int disk_current_index;
static unsigned int disk_count;
static struct disks_state
{
if (disks[index].fname == NULL)
{
- SysPrintf("missing disk #%u\n", index);
+ LogErr("missing disk #%u\n", index);
CDR_shutdown();
// RetroArch specifies "no disk" with index == count,
return true;
}
- SysPrintf("switching to disk %u: \"%s\" #%d\n", index,
+ LogErr("switching to disk %u: \"%s\" #%d\n", index,
disks[index].fname, disks[index].internal_index);
cdrIsoMultidiskSelect = disks[index].internal_index;
set_cd_image(disks[index].fname);
if (ReloadCdromPlugin() < 0)
{
- SysPrintf("failed to load cdr plugin\n");
+ LogErr("failed to load cdr plugin\n");
return false;
}
if (CDR_open() < 0)
{
- SysPrintf("failed to open cdr plugin\n");
+ LogErr("failed to open cdr plugin\n");
return false;
}
if (info == NULL || info->path == NULL)
{
- SysPrintf("info->path required\n");
+ LogErr("info->path required\n");
return false;
}
{
if (!read_m3u(info->path))
{
- log_cb(RETRO_LOG_INFO, "failed to read m3u file\n");
+ LogErr("failed to read m3u file\n");
return false;
}
}
/* have to reload after set_cd_image for correct cdr plugin */
if (LoadPlugins() == -1)
{
- log_cb(RETRO_LOG_INFO, "failed to load plugins\n");
+ LogErr("failed to load plugins\n");
return false;
}
if (OpenPlugins() == -1)
{
- log_cb(RETRO_LOG_INFO, "failed to open plugins\n");
+ LogErr("failed to open plugins\n");
return false;
}
if (ReloadCdromPlugin() < 0)
{
- log_cb(RETRO_LOG_INFO, "failed to reload cdr plugins\n");
+ LogErr("failed to reload cdr plugins\n");
return false;
}
if (CDR_open() < 0)
{
- log_cb(RETRO_LOG_INFO, "failed to open cdr plugin\n");
+ LogErr("failed to open cdr plugin\n");
return false;
}
}
if (!is_exe && CheckCdrom() == -1)
{
- log_cb(RETRO_LOG_INFO, "unsupported/invalid CD image: %s\n", info->path);
+ LogErr("unsupported/invalid CD image: %s\n", info->path);
return false;
}
ret = LoadCdrom();
if (ret != 0)
{
- log_cb(RETRO_LOG_INFO, "could not load %s (%d)\n", is_exe ? "exe" : "CD", ret);
+ LogErr("could not load %s (%d)\n", is_exe ? "exe" : "CD", ret);
return false;
}
emu_on_new_cd(0);
in_enable_vibration = 1;
}
+ var.value = NULL;
+ var.key = "pcsx_rearmed_analog_combo";
+
+ if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+ {
+ if (strcmp(var.value, "l1+r1+select") == 0)
+ in_dualshock_analog_combo = (1 << RETRO_DEVICE_ID_JOYPAD_L) |
+ (1 << RETRO_DEVICE_ID_JOYPAD_R) | (1 << RETRO_DEVICE_ID_JOYPAD_SELECT);
+ else if (strcmp(var.value, "l1+r1+start") == 0)
+ in_dualshock_analog_combo = (1 << RETRO_DEVICE_ID_JOYPAD_L) |
+ (1 << RETRO_DEVICE_ID_JOYPAD_R) | (1 << RETRO_DEVICE_ID_JOYPAD_START);
+ else if (strcmp(var.value, "l1+r1+l3") == 0)
+ in_dualshock_analog_combo = (1 << RETRO_DEVICE_ID_JOYPAD_L) |
+ (1 << RETRO_DEVICE_ID_JOYPAD_R) | (1 << RETRO_DEVICE_ID_JOYPAD_L3);
+ else if (strcmp(var.value, "l1+r1+r3") == 0)
+ in_dualshock_analog_combo = (1 << RETRO_DEVICE_ID_JOYPAD_L) |
+ (1 << RETRO_DEVICE_ID_JOYPAD_R) | (1 << RETRO_DEVICE_ID_JOYPAD_R3);
+ else if (strcmp(var.value, "l3+r3") == 0)
+ in_dualshock_analog_combo = (1 << RETRO_DEVICE_ID_JOYPAD_L3) |
+ (1 << RETRO_DEVICE_ID_JOYPAD_R3);
+ else
+ in_dualshock_analog_combo = 0;
+ }
+
var.value = NULL;
var.key = "pcsx_rearmed_dithering";
if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
{
- if (strcmp(var.value, "disabled") == 0)
- pl_rearmed_cbs.gpu_neon.enhancement_no_main = 0;
- else if (strcmp(var.value, "enabled") == 0)
+ if (strcmp(var.value, "enabled") == 0)
pl_rearmed_cbs.gpu_neon.enhancement_no_main = 1;
+ else
+ pl_rearmed_cbs.gpu_neon.enhancement_no_main = 0;
}
-#endif
var.value = NULL;
- var.key = "pcsx_rearmed_duping_enable";
+ var.key = "pcsx_rearmed_neon_enhancement_tex_adj";
if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
{
- if (strcmp(var.value, "disabled") == 0)
- duping_enable = false;
- else if (strcmp(var.value, "enabled") == 0)
- duping_enable = true;
+ if (strcmp(var.value, "enabled") == 0)
+ pl_rearmed_cbs.gpu_neon.enhancement_tex_adj = 1;
+ else
+ pl_rearmed_cbs.gpu_neon.enhancement_tex_adj = 0;
}
+#endif
var.value = NULL;
var.key = "pcsx_rearmed_display_internal_fps";
spu_config.iUseInterpolation = 0;
}
+#if P_HAVE_PTHREAD
var.value = NULL;
var.key = "pcsx_rearmed_spu_thread";
if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
else
spu_config.iUseThread = 0;
}
+#endif
+#if 0 // currently disabled, see USE_READ_THREAD in libpcsxcore/cdriso.c
if (P_HAVE_PTHREAD) {
var.value = NULL;
var.key = "pcsx_rearmed_async_cd";
}
}
}
+#endif
var.value = NULL;
var.key = "pcsx_rearmed_noxadecoding";
{
if (strcmp(var.value, "game") == 0)
pl_rearmed_cbs.screen_centering_type = 1;
- else if (strcmp(var.value, "manual") == 0)
+ else if (strcmp(var.value, "borderless") == 0)
pl_rearmed_cbs.screen_centering_type = 2;
+ else if (strcmp(var.value, "manual") == 0)
+ pl_rearmed_cbs.screen_centering_type = 3;
else // auto
pl_rearmed_cbs.screen_centering_type = 0;
}
mouse_sensitivity = atof(var.value);
}
+ if (found_bios)
+ {
+ var.value = NULL;
+ var.key = "pcsx_rearmed_show_bios_bootlogo";
+ if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
+ {
+ Config.SlowBoot = 0;
+ if (strcmp(var.value, "enabled") == 0)
+ Config.SlowBoot = 1;
+ }
+ }
+
if (in_flight)
{
// inform core things about possible config changes
/* dfinput_activate(); */
}
- else
- {
- //not yet running
-
- //bootlogo display hack
- if (found_bios)
- {
- var.value = NULL;
- var.key = "pcsx_rearmed_show_bios_bootlogo";
- if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value)
- {
- Config.SlowBoot = 0;
- rebootemu = 0;
- if (strcmp(var.value, "enabled") == 0)
- {
- Config.SlowBoot = 1;
- rebootemu = 1;
- }
- }
- }
- }
update_option_visibility();
}
static void update_input(void)
{
- // reset all keystate, query libretro for keystate
int i;
int j;
+ // reset all keystate, query libretro for keystate
for (i = 0; i < PORTS_NUMBER; i++)
{
- int16_t ret = 0;
+ int32_t ret = 0;
int type = in_type[i];
in_keystate[i] = 0;
continue;
if (libretro_supports_bitmasks)
+ {
ret = input_state_cb(i, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_MASK);
+ // undo int16 sign extension (why input_state_cb returns int16 in the first place?)
+ ret &= (1 << (RETRO_DEVICE_ID_JOYPAD_R3 + 1)) - 1;
+ }
else
{
for (j = 0; j < (RETRO_DEVICE_ID_JOYPAD_R3 + 1); j++)
update_input_mouse(i, ret);
break;
default:
- // Query digital inputs
+ // dualshock ANALOG toggle?
+ if (type == PSE_PAD_TYPE_ANALOGPAD && in_dualshock_analog_combo != 0
+ && ret == in_dualshock_analog_combo)
+ {
+ if (!in_dualshock_toggling)
+ {
+ int state = padToggleAnalog(i);
+ char msg[32];
+ snprintf(msg, sizeof(msg), "ANALOG %s", state ? "ON" : "OFF");
+ show_notification(msg, 800, 1);
+ in_dualshock_toggling = true;
+ }
+ return;
+ }
+ in_dualshock_toggling = false;
+
+ // Set digital inputs
for (j = 0; j < RETRO_PSX_MAP_LEN; j++)
if (ret & (1 << j))
in_keystate[i] |= retro_psx_map[j];
LoadCdrom();
}
+ set_vout_fb();
print_internal_fps();
/* Check whether current frame should
frameskip_counter = 0;
}
- video_cb((vout_fb_dirty || !vout_can_dupe || !duping_enable) ? vout_buf_ptr : NULL,
- vout_width, vout_height, vout_width * 2);
+ video_cb((vout_fb_dirty || !vout_can_dupe) ? vout_buf_ptr : NULL,
+ vout_width, vout_height, vout_pitch * 2);
vout_fb_dirty = 0;
-
- set_vout_fb();
}
static bool try_use_bios(const char *path, bool preferred_only)
{
if (strlen(dir) + strlen(CARD2_FILE) + 2 > sizeof(Config.Mcd2))
{
- SysPrintf("Path '%s' is too long. Cannot use memcard 2. Use a shorter path.\n", dir);
+ LogErr("Path '%s' is too long. Cannot use memcard 2. Use a shorter path.\n", dir);
ret = -1;
}
else
}
else
{
- SysPrintf("Could not get save directory! Could not create memcard 2.");
+ LogErr("Could not get save directory! Could not create memcard 2.");
ret = -1;
}
}
ret |= emu_core_init();
if (ret != 0)
{
- SysPrintf("PCSX init failed.\n");
+ LogErr("PCSX init failed.\n");
exit(1);
}
#elif defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200112L) && P_HAVE_POSIX_MEMALIGN
if (posix_memalign(&vout_buf, 16, VOUT_MAX_WIDTH * VOUT_MAX_HEIGHT * 2) != 0)
vout_buf = (void *) 0;
+ else
+ memset(vout_buf, 0, VOUT_MAX_WIDTH * VOUT_MAX_HEIGHT * 2);
#else
- vout_buf = malloc(VOUT_MAX_WIDTH * VOUT_MAX_HEIGHT * 2);
+ vout_buf = calloc(VOUT_MAX_WIDTH * VOUT_MAX_HEIGHT, 2);
#endif
vout_buf_ptr = vout_buf;
loadPSXBios();
environ_cb(RETRO_ENVIRONMENT_GET_CAN_DUPE, &vout_can_dupe);
+ if (!vout_can_dupe)
+ LogWarn("CAN_DUPE reports false\n");
disk_initial_index = 0;
disk_initial_path[0] = '\0';
notaz.gp2x.de / pcsx_rearmed.git / blobdiff