X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?p=pcsx_rearmed.git;a=blobdiff_plain;f=frontend%2Fplugin_lib.c;h=8546c92f43d77d6584347e369cb3a11cf7033b41;hp=eba09fb1f83ed3834e2e9e2da5cb1db025675953;hb=cc8ae53ee4b7c36540b616e5b9bd16a10efd168a;hpb=3ece2f0c51ef6b679cd5765900b567ef47dde1e8 diff --git a/frontend/plugin_lib.c b/frontend/plugin_lib.c index eba09fb1..8546c92f 100644 --- a/frontend/plugin_lib.c +++ b/frontend/plugin_lib.c @@ -17,11 +17,12 @@ #include #include +#include "libpicofe/fonts.h" +#include "libpicofe/input.h" +#include "libpicofe/plat.h" +#include "libpicofe/arm/neon_scale2x.h" +#include "libpicofe/arm/neon_eagle2x.h" #include "plugin_lib.h" -#include "linux/fbdev.h" -#include "common/fonts.h" -#include "common/input.h" -#include "omap.h" #include "menu.h" #include "main.h" #include "plat.h" @@ -29,17 +30,23 @@ #include "pl_gun_ts.h" #include "../libpcsxcore/new_dynarec/new_dynarec.h" #include "../libpcsxcore/psemu_plugin_defs.h" +#include "../plugins/gpulib/cspace.h" int in_type1, in_type2; int in_a1[2] = { 127, 127 }, in_a2[2] = { 127, 127 }; +int in_adev[2] = { -1, -1 }, in_adev_axis[2][2] = {{ 0, 1 }, { 0, 1 }}; +int in_adev_is_nublike[2]; int in_keystate, in_state_gun; -int pl_flip_cnt; +int in_enable_vibration; void *tsdev; void *pl_vout_buf; -static int pl_vout_w, pl_vout_h, pl_vout_bpp; -static int vsync_cnt, flips_per_sec, tick_per_sec; -static float vsps_cur; -static int frame_interval, frame_interval1024, vsync_usec_time; +int g_layer_x, g_layer_y, g_layer_w, g_layer_h; +static int pl_vout_w, pl_vout_h, pl_vout_bpp; /* output display/layer */ +static int pl_vout_scale; +static int psx_w, psx_h, psx_bpp; +static int vsync_cnt; +static int is_pal, frame_interval, frame_interval1024; +static int vsync_usec_time; static __attribute__((noinline)) int get_cpu_ticks(void) @@ -71,13 +78,14 @@ static void print_msg(int h, int border) static void print_fps(int h, int border) { if (pl_vout_bpp == 16) - pl_text_out16(border + 2, h - 10, "%2d %4.1f", flips_per_sec, vsps_cur); + pl_text_out16(border + 2, h - 10, "%2d %4.1f", + pl_rearmed_cbs.flips_per_sec, pl_rearmed_cbs.vsps_cur); } static void print_cpu_usage(int w, int h, int border) { if (pl_vout_bpp == 16) - pl_text_out16(w - border - 28, h - 10, "%3d", tick_per_sec); + pl_text_out16(w - border - 28, h - 10, "%3d", pl_rearmed_cbs.cpu_usage); } // draw 192x8 status of 24 sound channels @@ -112,8 +120,8 @@ static __attribute__((noinline)) void draw_active_chans(int vout_w, int vout_h) void pl_print_hud(int w, int h, int xborder) { - pl_vout_w = w; // used by pollux - pl_vout_h = h; + if (h < 16) + return; if (g_opts & OPT_SHOWSPU) draw_active_chans(w, h); @@ -127,73 +135,200 @@ void pl_print_hud(int w, int h, int xborder) print_cpu_usage(w, h, xborder); } -static void *pl_vout_set_mode(int w, int h, int bpp) +/* update scaler target size according to user settings */ +static void update_layer_size(int w, int h) +{ + float mult; + int imult; + + switch (g_scaler) { + case SCALE_1_1: + g_layer_w = w; g_layer_h = h; + break; + + case SCALE_4_3v2: + if (h > g_menuscreen_h || (240 < h && h <= 360)) + goto fractional_4_3; + + // 4:3 that prefers integer scaling + imult = g_menuscreen_h / h; + g_layer_w = w * imult; + g_layer_h = h * imult; + mult = (float)g_layer_w / (float)g_layer_h; + if (mult < 1.25f || mult > 1.666f) + g_layer_w = 4.0f/3.0f * (float)g_layer_h; + printf(" -> %dx%d %.1f\n", g_layer_w, g_layer_h, mult); + break; + + fractional_4_3: + case SCALE_4_3: + mult = 240.0f / (float)h * 4.0f / 3.0f; + if (h > 256) + mult *= 2.0f; + g_layer_w = mult * (float)g_menuscreen_h; + g_layer_h = g_menuscreen_h; + printf(" -> %dx%d %.1f\n", g_layer_w, g_layer_h, mult); + break; + + case SCALE_FULLSCREEN: + g_layer_w = g_menuscreen_w; + g_layer_h = g_menuscreen_h; + break; + + default: + break; + } + + g_layer_x = g_menuscreen_w / 2 - g_layer_w / 2; + g_layer_y = g_menuscreen_h / 2 - g_layer_h / 2; + if (g_layer_x < 0) g_layer_x = 0; + if (g_layer_y < 0) g_layer_y = 0; + if (g_layer_w > g_menuscreen_w) g_layer_w = g_menuscreen_w; + if (g_layer_h > g_menuscreen_h) g_layer_h = g_menuscreen_h; +} + +// XXX: this is platform specific really +static int resolution_ok(int w, int h) { + return w <= 1024 && h <= 512; +} + +static void pl_vout_set_mode(int w, int h, int bpp) +{ + int vout_w, vout_h, vout_bpp; + // special h handling, Wipeout likes to change it by 1-6 static int vsync_cnt_ms_prev; if ((unsigned int)(vsync_cnt - vsync_cnt_ms_prev) < 5*60) h = (h + 7) & ~7; vsync_cnt_ms_prev = vsync_cnt; - if (w == pl_vout_w && h == pl_vout_h && bpp == pl_vout_bpp) - return pl_vout_buf; + vout_w = psx_w = w; + vout_h = psx_h = h; + vout_bpp = psx_bpp = bpp; + + pl_vout_scale = 1; +#ifdef __ARM_NEON__ + if (soft_filter) { + if (resolution_ok(w * 2, h * 2) && bpp == 16) { + vout_w *= 2; + vout_h *= 2; + pl_vout_scale = 2; + } + else { + // filter unavailable + hud_msg[0] = 0; + } + } +#endif - pl_vout_w = w; - pl_vout_h = h; - pl_vout_bpp = bpp; + if (pl_vout_buf != NULL && vout_w == pl_vout_w && vout_h == pl_vout_h + && vout_bpp == pl_vout_bpp) + return; -#if defined(VOUT_FBDEV) - vout_fbdev_clear(layer_fb); - pl_vout_buf = vout_fbdev_resize(layer_fb, w, h, bpp, 0, 0, 0, 0, 3); -#elif defined(MAEMO) - extern void *hildon_set_mode(int w, int h); - pl_vout_buf = hildon_set_mode(w, h); -#endif + update_layer_size(vout_w, vout_h); + pl_vout_buf = plat_gvideo_set_mode(&vout_w, &vout_h, &vout_bpp); if (pl_vout_buf == NULL) - fprintf(stderr, "failed to set mode\n"); - - // menu decides on layer size, we commit it - menu_notify_mode_change(w, h, bpp); - omap_enable_layer(1); + fprintf(stderr, "failed to set mode %dx%d@%d\n", + psx_w, psx_h, psx_bpp); + else { + pl_vout_w = vout_w; + pl_vout_h = vout_h; + pl_vout_bpp = vout_bpp; + } - return pl_vout_buf; + menu_notify_mode_change(pl_vout_w, pl_vout_h, pl_vout_bpp); } -static void *pl_vout_flip(void) +static void pl_vout_flip(const void *vram, int stride, int bgr24, int w, int h) { - pl_flip_cnt++; + static int doffs_old, clear_counter; + unsigned char *dest = pl_vout_buf; + const unsigned short *src = vram; + int dstride = pl_vout_w, h1 = h; + int doffs; - if (pl_vout_buf != NULL) - pl_print_hud(pl_vout_w, pl_vout_h, 0); + pcnt_start(PCNT_BLIT); - // let's flip now -#if defined(VOUT_FBDEV) - pl_vout_buf = vout_fbdev_flip(layer_fb); -#elif defined(MAEMO) - extern void *hildon_flip(void); - pl_vout_buf = hildon_flip(); + if (dest == NULL) + goto out; + + if (vram == NULL) { + // blanking + memset(pl_vout_buf, 0, dstride * pl_vout_h * pl_vout_bpp / 8); + goto out; + } + + // borders + doffs = (dstride - w * pl_vout_scale) / 2 & ~1; + dest += doffs * 2; + + if (doffs > doffs_old) + clear_counter = 2; + doffs_old = doffs; + + if (clear_counter > 0) { + memset(pl_vout_buf, 0, dstride * pl_vout_h * pl_vout_bpp / 8); + clear_counter--; + } + + if (bgr24) + { + if (pl_rearmed_cbs.only_16bpp) { + for (; h1-- > 0; dest += dstride * 2, src += stride) + { + bgr888_to_rgb565(dest, src, w * 3); + } + } + else { + dest -= doffs * 2; + dest += (doffs / 8) * 24; + + for (; h1-- > 0; dest += dstride * 3, src += stride) + { + bgr888_to_rgb888(dest, src, w * 3); + } + } + } +#ifdef __ARM_NEON__ + else if (soft_filter == SOFT_FILTER_SCALE2X && pl_vout_scale == 2) + { + neon_scale2x_16_16(src, (void *)dest, w, + stride * 2, dstride * 2, h1); + } + else if (soft_filter == SOFT_FILTER_EAGLE2X && pl_vout_scale == 2) + { + neon_eagle2x_16_16(src, (void *)dest, w, + stride * 2, dstride * 2, h1); + } #endif - return pl_vout_buf; + else + { + for (; h1-- > 0; dest += dstride * 2, src += stride) + { + bgr555_to_rgb565(dest, src, w * 2); + } + } + + pl_print_hud(w * pl_vout_scale, h * pl_vout_scale, 0); + +out: + pcnt_end(PCNT_BLIT); + + // let's flip now + pl_vout_buf = plat_gvideo_flip(); + pl_rearmed_cbs.flip_cnt++; } static int pl_vout_open(void) { struct timeval now; - omap_enable_layer(1); -#if defined(VOUT_FBDEV) - // force mode update - int h = pl_vout_h; - pl_vout_h--; - pl_vout_buf = pl_vout_set_mode(pl_vout_w, h, pl_vout_bpp); - - // try to align redraws to vsync - vout_fbdev_wait_vsync(layer_fb); -#elif defined(MAEMO) - extern void *hildon_flip(void); - pl_vout_buf = hildon_flip(); -#endif + // force mode update on pl_vout_set_mode() call from gpulib/vout_pl + pl_vout_buf = NULL; + + plat_gvideo_open(is_pal); gettimeofday(&now, 0); vsync_usec_time = now.tv_usec; @@ -205,31 +340,166 @@ static int pl_vout_open(void) static void pl_vout_close(void) { - omap_enable_layer(0); + plat_gvideo_close(); +} + +static void pl_set_gpu_caps(int caps) +{ + pl_rearmed_cbs.gpu_caps = caps; } void *pl_prepare_screenshot(int *w, int *h, int *bpp) { -#if defined(VOUT_FBDEV) + void *ret = plat_prepare_screenshot(w, h, bpp); + if (ret != NULL) + return ret; + *w = pl_vout_w; *h = pl_vout_h; *bpp = pl_vout_bpp; return pl_vout_buf; -#else - return plat_prepare_screenshot(w, h, bpp); +} + +/* display/redering mode switcher */ +static int dispmode_default(void) +{ + pl_rearmed_cbs.gpu_neon.enhancement_enable = 0; + soft_filter = SOFT_FILTER_NONE; + snprintf(hud_msg, sizeof(hud_msg), "default mode"); + return 1; +} + +int dispmode_doubleres(void) +{ + if (!(pl_rearmed_cbs.gpu_caps & GPU_CAP_SUPPORTS_2X) + || !resolution_ok(psx_w * 2, psx_h * 2) || psx_bpp != 16) + return 0; + + dispmode_default(); + pl_rearmed_cbs.gpu_neon.enhancement_enable = 1; + snprintf(hud_msg, sizeof(hud_msg), "double resolution"); + return 1; +} + +int dispmode_scale2x(void) +{ + if (psx_bpp != 16) + return 0; + + dispmode_default(); + soft_filter = SOFT_FILTER_SCALE2X; + snprintf(hud_msg, sizeof(hud_msg), "scale2x"); + return 1; +} + +int dispmode_eagle2x(void) +{ + if (psx_bpp != 16) + return 0; + + dispmode_default(); + soft_filter = SOFT_FILTER_EAGLE2X; + snprintf(hud_msg, sizeof(hud_msg), "eagle2x"); + return 1; +} + +static int (*dispmode_switchers[])(void) = { + dispmode_default, +#ifdef __ARM_NEON__ + dispmode_doubleres, + dispmode_scale2x, + dispmode_eagle2x, #endif +}; + +static int dispmode_current; + +void pl_switch_dispmode(void) +{ + if (pl_rearmed_cbs.gpu_caps & GPU_CAP_OWNS_DISPLAY) + return; + + while (1) { + dispmode_current++; + if (dispmode_current >= + sizeof(dispmode_switchers) / sizeof(dispmode_switchers[0])) + dispmode_current = 0; + if (dispmode_switchers[dispmode_current]()) + break; + } +} + +#ifndef MAEMO +/* adjust circle-like analog inputs to better match + * more square-like analogs in PSX */ +static void update_analog_nub_adjust(int *x_, int *y_) +{ + const int d = 16; + static const int scale[] = + { 0 - d*2, 0 - d*2, 0 - d*2, 12 - d*2, + 30 - d*2, 60 - d*2, 75 - d*2, 60 - d*2, 60 - d*2 }; + int x = abs(*x_); + int y = abs(*y_); + int scale_x = scale[y / 16]; + int scale_y = scale[x / 16]; + + if (x) { + x += d + (x * scale_x >> 8); + if (*x_ < 0) + x = -x; + } + if (y) { + y += d + (y * scale_y >> 8); + if (*y_ < 0) + y = -y; + } + + *x_ = x; + *y_ = y; +} + +static void update_analogs(void) +{ + int *nubp[2] = { in_a1, in_a2 }; + int vals[2]; + int i, a, v, ret; + + for (i = 0; i < 2; i++) + { + if (in_adev[i] < 0) + continue; + + for (a = 0; a < 2; a++) { + vals[a] = 0; + + ret = in_update_analog(in_adev[i], in_adev_axis[i][a], &v); + if (ret == 0) + vals[a] = 128 * v / IN_ABS_RANGE; + } + + if (in_adev_is_nublike[i]) + update_analog_nub_adjust(&vals[0], &vals[1]); + + for (a = 0; a < 2; a++) { + v = vals[a] + 127; + if (v < 0) v = 0; + else if (v > 255) v = 255; + nubp[i][a] = v; + } + + } + //printf("%4d %4d %4d %4d\n", in_a1[0], in_a1[1], in_a2[0], in_a2[1]); } static void update_input(void) { -#ifndef MAEMO int actions[IN_BINDTYPE_COUNT] = { 0, }; unsigned int emu_act; in_update(actions); if (in_type1 == PSE_PAD_TYPE_ANALOGPAD) - in_update_analogs(); + update_analogs(); emu_act = actions[IN_BINDTYPE_EMU]; in_state_gun = (emu_act & SACTION_GUN_MASK) >> SACTION_GUN_TRIGGER; @@ -243,13 +513,12 @@ static void update_input(void) emu_set_action(emu_act); in_keystate = actions[IN_BINDTYPE_PLAYER12]; -#endif -#ifdef X11 - extern int x11_update_keys(unsigned int *action); - in_keystate |= x11_update_keys(&emu_act); - emu_set_action(emu_act); -#endif } +#else /* MAEMO */ +static void update_input(void) +{ +} +#endif void pl_update_gun(int *xn, int *xres, int *y, int *in) { @@ -284,26 +553,28 @@ void pl_frame_limit(void) if (now.tv_sec != tv_old.tv_sec) { diff = tvdiff(now, tv_old); - vsps_cur = 0.0f; + pl_rearmed_cbs.vsps_cur = 0.0f; if (0 < diff && diff < 2000000) - vsps_cur = 1000000.0f * (vsync_cnt - vsync_cnt_prev) / diff; + pl_rearmed_cbs.vsps_cur = 1000000.0f * (vsync_cnt - vsync_cnt_prev) / diff; vsync_cnt_prev = vsync_cnt; - flips_per_sec = pl_flip_cnt; - pl_flip_cnt = 0; - tv_old = now; + + if (g_opts & OPT_SHOWFPS) + pl_rearmed_cbs.flips_per_sec = pl_rearmed_cbs.flip_cnt; + pl_rearmed_cbs.flip_cnt = 0; if (g_opts & OPT_SHOWCPU) - tick_per_sec = get_cpu_ticks(); + pl_rearmed_cbs.cpu_usage = get_cpu_ticks(); if (hud_new_msg > 0) { hud_new_msg--; if (hud_new_msg == 0) hud_msg[0] = 0; } + tv_old = now; } #ifdef PCNT static int ya_vsync_count; if (++ya_vsync_count == PCNT_FRAMES) { - pcnt_print(vsps_cur); + pcnt_print(pl_rearmed_cbs.vsps_cur); ya_vsync_count = 0; } #endif @@ -354,10 +625,13 @@ void pl_frame_limit(void) pcnt_start(PCNT_ALL); } -void pl_timing_prepare(int is_pal) +void pl_timing_prepare(int is_pal_) { pl_rearmed_cbs.fskip_advice = 0; + pl_rearmed_cbs.flips_per_sec = 0; + pl_rearmed_cbs.cpu_usage = 0; + is_pal = is_pal_; frame_interval = is_pal ? 20000 : 16667; frame_interval1024 = is_pal ? 20000*1024 : 17066667; @@ -369,16 +643,31 @@ void pl_timing_prepare(int is_pal) static void pl_text_out16_(int x, int y, const char *text) { - int i, l, len = strlen(text), w = pl_vout_w; - unsigned short *screen = (unsigned short *)pl_vout_buf + x + y * w; + int i, l, w = pl_vout_w; + unsigned short *screen; unsigned short val = 0xffff; - for (i = 0; i < len; i++, screen += 8) + x &= ~1; + screen = (unsigned short *)pl_vout_buf + x + y * w; + for (i = 0; ; i++, screen += 8) { + char c = text[i]; + if (c == 0) + break; + if (c == ' ') + continue; + for (l = 0; l < 8; l++) { - unsigned char fd = fontdata8x8[text[i] * 8 + l]; + unsigned char fd = fontdata8x8[c * 8 + l]; unsigned short *s = screen + l * w; + unsigned int *s32 = (void *)s; + + s32[0] = (s32[0] >> 1) & 0x7bef7bef; + s32[1] = (s32[1] >> 1) & 0x7bef7bef; + s32[2] = (s32[2] >> 1) & 0x7bef7bef; + s32[3] = (s32[3] >> 1) & 0x7bef7bef; + if (fd&0x80) s[0] = val; if (fd&0x40) s[1] = val; if (fd&0x20) s[2] = val; @@ -411,12 +700,26 @@ static void pl_get_layer_pos(int *x, int *y, int *w, int *h) *h = g_layer_h; } +static void *pl_mmap(unsigned int size) +{ + return plat_mmap(0, size, 0, 0); +} + +static void pl_munmap(void *ptr, unsigned int size) +{ + plat_munmap(ptr, size); +} + struct rearmed_cbs pl_rearmed_cbs = { pl_get_layer_pos, pl_vout_open, pl_vout_set_mode, pl_vout_flip, pl_vout_close, + + .mmap = pl_mmap, + .munmap = pl_munmap, + .pl_set_gpu_caps = pl_set_gpu_caps, }; /* watchdog */ @@ -478,8 +781,8 @@ void pl_init(void) extern unsigned int hSyncCount; // from psxcounters extern unsigned int frame_counter; - pl_vout_w = pl_vout_h = 256; - pl_vout_bpp = 16; + psx_w = psx_h = pl_vout_w = pl_vout_h = 256; + psx_bpp = pl_vout_bpp = 16; tsdev = pl_gun_ts_init();