From: notaz Date: Sun, 4 Nov 2012 22:28:57 +0000 (+0200) Subject: switch over to libpicofe X-Git-Tag: r16~10 X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=cc56203b76e1fcef2c7e55b460daf07e654a1547;p=pcsx_rearmed.git switch over to libpicofe - libretro should not be affected by this, all others need to do 'git submodule init && git submodule update' from now on. - pandora should get gamma control support --- diff --git a/.gitignore b/.gitignore index b59cf688..3310044d 100644 --- a/.gitignore +++ b/.gitignore @@ -1,13 +1,10 @@ *.o -frontend/revision.h -frontend/linux -frontend/common -frontend/X11 -frontend/gp2x tags cscope.out pandora pcsx.map +config.mak +config.log +frontend/revision.h tools -gpu_dumps* .pcsx/ diff --git a/Makefile b/Makefile index 1f3e7361..833dddc3 100644 --- a/Makefile +++ b/Makefile @@ -127,47 +127,56 @@ OBJS += plugins/cdrcimg/cdrcimg.o # dfinput OBJS += plugins/dfinput/main.o plugins/dfinput/pad.o plugins/dfinput/guncon.o -# misc -ifeq "$(HAVE_NEON)" "1" -OBJS += frontend/libpicofe/arm/neon_scale2x.o -OBJS += frontend/libpicofe/arm/neon_eagle2x.o -frontend/libpicofe/arm/neon_scale2x.o: CFLAGS += -DDO_BGR_TO_RGB -frontend/libpicofe/arm/neon_eagle2x.o: CFLAGS += -DDO_BGR_TO_RGB -endif - -# gui -OBJS += frontend/main.o frontend/plugin.o -OBJS += frontend/common/readpng.o frontend/common/fonts.o -OBJS += frontend/linux/plat.o - +# frontend/gui ifeq "$(PLATFORM)" "generic" -OBJS += frontend/plat_sdl.o frontend/common/in_sdl.o +OBJS += frontend/libpicofe/in_sdl.o frontend/plat_sdl.o +OBJS += frontend/libpicofe/plat_dummy.o +OBJS += frontend/libpicofe/linux/in_evdev.o +USE_PLUGIN_LIB = 1 USE_FRONTEND = 1 endif ifeq "$(PLATFORM)" "pandora" -OBJS += frontend/linux/fbdev.o -OBJS += frontend/plat_omap.o frontend/linux/xenv.o -OBJS += frontend/plat_pandora.o +OBJS += frontend/libpicofe/pandora/plat.o +OBJS += frontend/libpicofe/linux/fbdev.o frontend/libpicofe/linux/xenv.o +OBJS += frontend/libpicofe/linux/in_evdev.o +OBJS += frontend/plat_pandora.o frontend/plat_omap.o +USE_PLUGIN_LIB = 1 USE_FRONTEND = 1 endif ifeq "$(PLATFORM)" "caanoo" +OBJS += frontend/libpicofe/gp2x/in_gp2x.o frontend/warm/warm.o +OBJS += frontend/libpicofe/gp2x/soc_pollux.o +OBJS += frontend/libpicofe/linux/in_evdev.o OBJS += frontend/plat_pollux.o frontend/in_tsbutton.o frontend/blit320.o -OBJS += frontend/gp2x/in_gp2x.o frontend/warm/warm.o libpcsxcore/new_dynarec/pcsxmem.o: CFLAGS += -DCUSTOM_MEMMAPS +USE_PLUGIN_LIB = 1 USE_FRONTEND = 1 endif ifeq "$(PLATFORM)" "maemo" OBJS += maemo/hildon.o maemo/main.o maemo/%.o: maemo/%.c -OBJS += frontend/plugin_lib.o +USE_PLUGIN_LIB = 1 endif ifeq "$(PLATFORM)" "libretro" OBJS += frontend/libretro.o +OBJS += frontend/linux/plat_mmap.o endif -ifeq "$(USE_FRONTEND)" "1" -OBJS += frontend/menu.o frontend/linux/in_evdev.o -OBJS += frontend/common/input.o + +ifeq "$(USE_PLUGIN_LIB)" "1" OBJS += frontend/plugin_lib.o +OBJS += frontend/libpicofe/linux/plat.o +OBJS += frontend/libpicofe/readpng.o frontend/libpicofe/fonts.o +ifeq "$(HAVE_NEON)" "1" +OBJS += frontend/libpicofe/arm/neon_scale2x.o +OBJS += frontend/libpicofe/arm/neon_eagle2x.o +frontend/libpicofe/arm/neon_scale2x.o: CFLAGS += -DDO_BGR_TO_RGB +frontend/libpicofe/arm/neon_eagle2x.o: CFLAGS += -DDO_BGR_TO_RGB +endif +endif +ifeq "$(USE_FRONTEND)" "1" +OBJS += frontend/menu.o +OBJS += frontend/libpicofe/input.o +frontend/menu.o: frontend/libpicofe/menu.c ifeq "$(HAVE_TSLIB)" "1" frontend/%.o: CFLAGS += -DHAVE_TSLIB OBJS += frontend/pl_gun_ts.o @@ -183,10 +192,14 @@ endif ifdef PCNT CFLAGS += -DPCNT endif + +# misc +OBJS += frontend/main.o frontend/plugin.o + frontend/%.o: CFLAGS += -DIN_EVDEV frontend/menu.o frontend/main.o frontend/plat_sdl.o: frontend/revision.h -frontend/libpicofe/arm/neon_scale2x.S frontend/libpicofe/menu.c: +frontend/libpicofe/%.c: @echo "libpicofe module is missing, please run:" @echo "git submodule init && git submodule update" @exit 1 diff --git a/configure b/configure index da126e7b..c7e7caf3 100755 --- a/configure +++ b/configure @@ -48,6 +48,8 @@ have_arm_neon="" have_tslib="" enable_dynarec="yes" need_sdl="no" +need_libpicofe="yes" +need_warm="no" # these are for known platforms optimize_cortexa8="no" optimize_arm926ej="no" @@ -91,9 +93,11 @@ set_platform() ram_fixed="yes" drc_cache_base="yes" optimize_arm926ej="yes" + need_warm="yes" ;; libretro) sound_drivers="libretro" + need_libpicofe="no" ;; *) fail "unsupported platform: $platform" @@ -156,6 +160,18 @@ if [ "x$sound_drivers" != "x" ]; then done fi +if [ "$need_libpicofe" = "yes" ]; then + if ! test -f "frontend/libpicofe/README"; then + fail "libpicofe is missing, please run 'git submodule init && git submodule update'" + fi +fi + +if [ "$need_warm" = "yes" ]; then + if ! test -f "frontend/warm/README"; then + fail "wARM is missing, please run 'git submodule init && git submodule update'" + fi +fi + if [ -z "$ARCH" ]; then ARCH=`$CC -v 2>&1 | grep -i 'target:' | awk '{print $2}' \ | awk -F '-' '{print $1}'` diff --git a/frontend/common/fonts.c b/frontend/common/fonts.c deleted file mode 100644 index ea65481f..00000000 --- a/frontend/common/fonts.c +++ /dev/null @@ -1,218 +0,0 @@ -unsigned char fontdata8x8[64*16] = -{ - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, - 0x3C,0x42,0x99,0xBD,0xBD,0x99,0x42,0x3C,0x3C,0x42,0x81,0x81,0x81,0x81,0x42,0x3C, - 0xFE,0x82,0x8A,0xD2,0xA2,0x82,0xFE,0x00,0xFE,0x82,0x82,0x82,0x82,0x82,0xFE,0x00, - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x38,0x64,0x74,0x7C,0x38,0x00,0x00, - 0x80,0xC0,0xF0,0xFC,0xF0,0xC0,0x80,0x00,0x01,0x03,0x0F,0x3F,0x0F,0x03,0x01,0x00, - 0x18,0x3C,0x7E,0x18,0x7E,0x3C,0x18,0x00,0xEE,0xEE,0xEE,0xCC,0x00,0xCC,0xCC,0x00, - 0x00,0x00,0x30,0x68,0x78,0x30,0x00,0x00,0x00,0x38,0x64,0x74,0x7C,0x38,0x00,0x00, - 0x3C,0x66,0x7A,0x7A,0x7E,0x7E,0x3C,0x00,0x0E,0x3E,0x3A,0x22,0x26,0x6E,0xE4,0x40, - 0x18,0x3C,0x7E,0x3C,0x3C,0x3C,0x3C,0x00,0x3C,0x3C,0x3C,0x3C,0x7E,0x3C,0x18,0x00, - 0x08,0x7C,0x7E,0x7E,0x7C,0x08,0x00,0x00,0x10,0x3E,0x7E,0x7E,0x3E,0x10,0x00,0x00, - 0x58,0x2A,0xDC,0xC8,0xDC,0x2A,0x58,0x00,0x24,0x66,0xFF,0xFF,0x66,0x24,0x00,0x00, - 0x00,0x10,0x10,0x38,0x38,0x7C,0xFE,0x00,0xFE,0x7C,0x38,0x38,0x10,0x10,0x00,0x00, - 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1C,0x1C,0x1C,0x18,0x00,0x18,0x18,0x00, - 0x6C,0x6C,0x24,0x00,0x00,0x00,0x00,0x00,0x00,0x28,0x7C,0x28,0x7C,0x28,0x00,0x00, - 0x10,0x38,0x60,0x38,0x0C,0x78,0x10,0x00,0x40,0xA4,0x48,0x10,0x24,0x4A,0x04,0x00, - 0x18,0x34,0x18,0x3A,0x6C,0x66,0x3A,0x00,0x18,0x18,0x20,0x00,0x00,0x00,0x00,0x00, - 0x30,0x60,0x60,0x60,0x60,0x60,0x30,0x00,0x0C,0x06,0x06,0x06,0x06,0x06,0x0C,0x00, - 0x10,0x54,0x38,0x7C,0x38,0x54,0x10,0x00,0x00,0x18,0x18,0x7E,0x18,0x18,0x00,0x00, - 0x00,0x00,0x00,0x00,0x18,0x18,0x30,0x00,0x00,0x00,0x00,0x00,0x3E,0x00,0x00,0x00, - 0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x04,0x08,0x10,0x20,0x40,0x00,0x00, - 0x38,0x4C,0xC6,0xC6,0xC6,0x64,0x38,0x00,0x18,0x38,0x18,0x18,0x18,0x18,0x7E,0x00, - 0x7C,0xC6,0x0E,0x3C,0x78,0xE0,0xFE,0x00,0x7E,0x0C,0x18,0x3C,0x06,0xC6,0x7C,0x00, - 0x1C,0x3C,0x6C,0xCC,0xFE,0x0C,0x0C,0x00,0xFC,0xC0,0xFC,0x06,0x06,0xC6,0x7C,0x00, - 0x3C,0x60,0xC0,0xFC,0xC6,0xC6,0x7C,0x00,0xFE,0xC6,0x0C,0x18,0x30,0x30,0x30,0x00, - 0x78,0xC4,0xE4,0x78,0x86,0x86,0x7C,0x00,0x7C,0xC6,0xC6,0x7E,0x06,0x0C,0x78,0x00, - 0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x18,0x18,0x30, - 0x1C,0x38,0x70,0xE0,0x70,0x38,0x1C,0x00,0x00,0x7C,0x00,0x00,0x7C,0x00,0x00,0x00, - 0x70,0x38,0x1C,0x0E,0x1C,0x38,0x70,0x00,0x7C,0xC6,0xC6,0x1C,0x18,0x00,0x18,0x00, - 0x3C,0x42,0x99,0xA1,0xA5,0x99,0x42,0x3C,0x38,0x6C,0xC6,0xC6,0xFE,0xC6,0xC6,0x00, - 0xFC,0xC6,0xC6,0xFC,0xC6,0xC6,0xFC,0x00,0x3C,0x66,0xC0,0xC0,0xC0,0x66,0x3C,0x00, - 0xF8,0xCC,0xC6,0xC6,0xC6,0xCC,0xF8,0x00,0xFE,0xC0,0xC0,0xFC,0xC0,0xC0,0xFE,0x00, - 0xFE,0xC0,0xC0,0xFC,0xC0,0xC0,0xC0,0x00,0x3E,0x60,0xC0,0xCE,0xC6,0x66,0x3E,0x00, - 0xC6,0xC6,0xC6,0xFE,0xC6,0xC6,0xC6,0x00,0x7E,0x18,0x18,0x18,0x18,0x18,0x7E,0x00, - 0x06,0x06,0x06,0x06,0xC6,0xC6,0x7C,0x00,0xC6,0xCC,0xD8,0xF0,0xF8,0xDC,0xCE,0x00, - 0x60,0x60,0x60,0x60,0x60,0x60,0x7E,0x00,0xC6,0xEE,0xFE,0xFE,0xD6,0xC6,0xC6,0x00, - 0xC6,0xE6,0xF6,0xFE,0xDE,0xCE,0xC6,0x00,0x7C,0xC6,0xC6,0xC6,0xC6,0xC6,0x7C,0x00, - 0xFC,0xC6,0xC6,0xC6,0xFC,0xC0,0xC0,0x00,0x7C,0xC6,0xC6,0xC6,0xDE,0xCC,0x7A,0x00, - 0xFC,0xC6,0xC6,0xCE,0xF8,0xDC,0xCE,0x00,0x78,0xCC,0xC0,0x7C,0x06,0xC6,0x7C,0x00, - 0x7E,0x18,0x18,0x18,0x18,0x18,0x18,0x00,0xC6,0xC6,0xC6,0xC6,0xC6,0xC6,0x7C,0x00, - 0xC6,0xC6,0xC6,0xEE,0x7C,0x38,0x10,0x00,0xC6,0xC6,0xD6,0xFE,0xFE,0xEE,0xC6,0x00, - 0xC6,0xEE,0x3C,0x38,0x7C,0xEE,0xC6,0x00,0x66,0x66,0x66,0x3C,0x18,0x18,0x18,0x00, - 0xFE,0x0E,0x1C,0x38,0x70,0xE0,0xFE,0x00,0x3C,0x30,0x30,0x30,0x30,0x30,0x3C,0x00, - 0x60,0x60,0x30,0x18,0x0C,0x06,0x06,0x00,0x3C,0x0C,0x0C,0x0C,0x0C,0x0C,0x3C,0x00, - 0x18,0x3C,0x66,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF, - 0x30,0x30,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x3C,0x06,0x3E,0x66,0x66,0x3C,0x00, - 0x60,0x7C,0x66,0x66,0x66,0x66,0x7C,0x00,0x00,0x3C,0x66,0x60,0x60,0x66,0x3C,0x00, - 0x06,0x3E,0x66,0x66,0x66,0x66,0x3E,0x00,0x00,0x3C,0x66,0x66,0x7E,0x60,0x3C,0x00, - 0x1C,0x30,0x78,0x30,0x30,0x30,0x30,0x00,0x00,0x3E,0x66,0x66,0x66,0x3E,0x06,0x3C, - 0x60,0x7C,0x76,0x66,0x66,0x66,0x66,0x00,0x18,0x00,0x38,0x18,0x18,0x18,0x18,0x00, - 0x0C,0x00,0x1C,0x0C,0x0C,0x0C,0x0C,0x38,0x60,0x60,0x66,0x6C,0x78,0x6C,0x66,0x00, - 0x38,0x18,0x18,0x18,0x18,0x18,0x18,0x00,0x00,0xEC,0xFE,0xFE,0xFE,0xD6,0xC6,0x00, - 0x00,0x7C,0x76,0x66,0x66,0x66,0x66,0x00,0x00,0x3C,0x66,0x66,0x66,0x66,0x3C,0x00, - 0x00,0x7C,0x66,0x66,0x66,0x7C,0x60,0x60,0x00,0x3E,0x66,0x66,0x66,0x3E,0x06,0x06, - 0x00,0x7E,0x70,0x60,0x60,0x60,0x60,0x00,0x00,0x3C,0x60,0x3C,0x06,0x66,0x3C,0x00, - 0x30,0x78,0x30,0x30,0x30,0x30,0x1C,0x00,0x00,0x66,0x66,0x66,0x66,0x6E,0x3E,0x00, - 0x00,0x66,0x66,0x66,0x66,0x3C,0x18,0x00,0x00,0xC6,0xD6,0xFE,0xFE,0x7C,0x6C,0x00, - 0x00,0x66,0x3C,0x18,0x3C,0x66,0x66,0x00,0x00,0x66,0x66,0x66,0x66,0x3E,0x06,0x3C, - 0x00,0x7E,0x0C,0x18,0x30,0x60,0x7E,0x00,0x0E,0x18,0x0C,0x38,0x0C,0x18,0x0E,0x00, - 0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x70,0x18,0x30,0x1C,0x30,0x18,0x70,0x00, - 0x00,0x00,0x76,0xDC,0x00,0x00,0x00,0x00,0x10,0x28,0x10,0x54,0xAA,0x44,0x00,0x00, -}; - - -/* The font is generated from Xorg clR5x8.bdf */ -/* -COMMENT Copyright 1989 Dale Schumacher, dal@syntel.mn.org -COMMENT 399 Beacon Ave. -COMMENT St. Paul, MN 55104-3527 -COMMENT -COMMENT Permission to use, copy, modify, and distribute this software and -COMMENT its documentation for any purpose and without fee is hereby -COMMENT granted, provided that the above copyright notice appear in all -COMMENT copies and that both that copyright notice and this permission -COMMENT notice appear in supporting documentation, and that the name of -COMMENT Dale Schumacher not be used in advertising or publicity pertaining to -COMMENT distribution of the software without specific, written prior -COMMENT permission. Dale Schumacher makes no representations about the -COMMENT suitability of this software for any purpose. It is provided "as -COMMENT is" without express or implied warranty. -COMMENT -*/ -unsigned char fontdata6x8[256][8] = { -{ 0x7c>>2, 0x44>>2, 0x7c>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0xff>>2, 0x7c>>2, }, -{ 0x00>>2, 0x00>>2, 0x10>>2, 0x28>>2, 0x44>>2, 0x7c>>2, 0x44>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x78>>2, 0x44>>2, 0x78>>2, 0x44>>2, 0x78>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x38>>2, 0x44>>2, 0x40>>2, 0x44>>2, 0x38>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x78>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x78>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x7c>>2, 0x40>>2, 0x78>>2, 0x40>>2, 0x7c>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x7c>>2, 0x40>>2, 0x78>>2, 0x40>>2, 0x40>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x3c>>2, 0x40>>2, 0x4c>>2, 0x44>>2, 0x3c>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x44>>2, 0x44>>2, 0x7c>>2, 0x44>>2, 0x44>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x38>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x38>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x1c>>2, 0x04>>2, 0x04>>2, 0x44>>2, 0x38>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x48>>2, 0x50>>2, 0x60>>2, 0x50>>2, 0x48>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x40>>2, 0x40>>2, 0x40>>2, 0x40>>2, 0x7c>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x44>>2, 0x6c>>2, 0x54>>2, 0x54>>2, 0x44>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x44>>2, 0x64>>2, 0x54>>2, 0x4c>>2, 0x44>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x38>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x38>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x78>>2, 0x44>>2, 0x78>>2, 0x40>>2, 0x40>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x38>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x38>>2, 0x0c>>2, }, -{ 0x00>>2, 0x00>>2, 0x78>>2, 0x44>>2, 0x78>>2, 0x50>>2, 0x4c>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x3c>>2, 0x40>>2, 0x38>>2, 0x04>>2, 0x78>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x7c>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x38>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x44>>2, 0x44>>2, 0x28>>2, 0x28>>2, 0x10>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x44>>2, 0x54>>2, 0x54>>2, 0x6c>>2, 0x44>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x44>>2, 0x28>>2, 0x10>>2, 0x28>>2, 0x44>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x44>>2, 0x28>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x7c>>2, 0x08>>2, 0x10>>2, 0x20>>2, 0x7c>>2, 0x00>>2, }, -{ 0xe0>>2, 0x80>>2, 0xe0>>2, 0x8c>>2, 0xf0>>2, 0x10>>2, 0x10>>2, 0x0c>>2, }, -{ 0x00>>2, 0x10>>2, 0x38>>2, 0x7c>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x00>>2, }, -{ 0x00>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x7c>>2, 0x38>>2, 0x10>>2, 0x00>>2, }, -{ 0x00>>2, 0x10>>2, 0x18>>2, 0xfc>>2, 0x18>>2, 0x10>>2, 0x00>>2, 0x00>>2, }, -{ 0x00>>2, 0x20>>2, 0x60>>2, 0xfc>>2, 0x60>>2, 0x20>>2, 0x00>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, }, -{ 0x10>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x00>>2, 0x10>>2, 0x00>>2, }, -{ 0x28>>2, 0x28>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, }, -{ 0x00>>2, 0x28>>2, 0x7c>>2, 0x28>>2, 0x7c>>2, 0x28>>2, 0x00>>2, 0x00>>2, }, -{ 0x10>>2, 0x3c>>2, 0x50>>2, 0x38>>2, 0x14>>2, 0x78>>2, 0x10>>2, 0x00>>2, }, -{ 0x60>>2, 0x64>>2, 0x08>>2, 0x10>>2, 0x20>>2, 0x4c>>2, 0x0c>>2, 0x00>>2, }, -{ 0x38>>2, 0x40>>2, 0x40>>2, 0x20>>2, 0x54>>2, 0x48>>2, 0x34>>2, 0x00>>2, }, -{ 0x10>>2, 0x20>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, }, -{ 0x04>>2, 0x08>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x08>>2, 0x04>>2, 0x00>>2, }, -{ 0x40>>2, 0x20>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x20>>2, 0x40>>2, 0x00>>2, }, -{ 0x00>>2, 0x10>>2, 0x54>>2, 0x38>>2, 0x54>>2, 0x10>>2, 0x00>>2, 0x00>>2, }, -{ 0x00>>2, 0x10>>2, 0x10>>2, 0x7c>>2, 0x10>>2, 0x10>>2, 0x00>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x10>>2, 0x10>>2, 0x20>>2, }, -{ 0x00>>2, 0x00>>2, 0x00>>2, 0x7c>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x10>>2, 0x10>>2, 0x00>>2, }, -{ 0x04>>2, 0x04>>2, 0x08>>2, 0x08>>2, 0x10>>2, 0x10>>2, 0x20>>2, 0x20>>2, }, -{ 0x38>>2, 0x44>>2, 0x4c>>2, 0x54>>2, 0x64>>2, 0x44>>2, 0x38>>2, 0x00>>2, }, -{ 0x10>>2, 0x30>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x00>>2, }, -{ 0x38>>2, 0x44>>2, 0x04>>2, 0x08>>2, 0x10>>2, 0x20>>2, 0x7c>>2, 0x00>>2, }, -{ 0x38>>2, 0x44>>2, 0x04>>2, 0x18>>2, 0x04>>2, 0x44>>2, 0x38>>2, 0x00>>2, }, -{ 0x18>>2, 0x18>>2, 0x28>>2, 0x28>>2, 0x7c>>2, 0x08>>2, 0x1c>>2, 0x00>>2, }, -{ 0x7c>>2, 0x40>>2, 0x78>>2, 0x04>>2, 0x04>>2, 0x44>>2, 0x38>>2, 0x00>>2, }, -{ 0x18>>2, 0x20>>2, 0x40>>2, 0x78>>2, 0x44>>2, 0x44>>2, 0x38>>2, 0x00>>2, }, -{ 0x7c>>2, 0x44>>2, 0x04>>2, 0x08>>2, 0x08>>2, 0x10>>2, 0x10>>2, 0x00>>2, }, -{ 0x38>>2, 0x44>>2, 0x44>>2, 0x38>>2, 0x44>>2, 0x44>>2, 0x38>>2, 0x00>>2, }, -{ 0x38>>2, 0x44>>2, 0x44>>2, 0x3c>>2, 0x04>>2, 0x08>>2, 0x30>>2, 0x00>>2, }, -{ 0x00>>2, 0x10>>2, 0x10>>2, 0x00>>2, 0x00>>2, 0x10>>2, 0x10>>2, 0x00>>2, }, -{ 0x00>>2, 0x10>>2, 0x10>>2, 0x00>>2, 0x00>>2, 0x10>>2, 0x10>>2, 0x20>>2, }, -{ 0x00>>2, 0x0c>>2, 0x30>>2, 0xc0>>2, 0x30>>2, 0x0c>>2, 0x00>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x7c>>2, 0x00>>2, 0x7c>>2, 0x00>>2, 0x00>>2, 0x00>>2, }, -{ 0x00>>2, 0xc0>>2, 0x30>>2, 0x0c>>2, 0x30>>2, 0xc0>>2, 0x00>>2, 0x00>>2, }, -{ 0x38>>2, 0x44>>2, 0x04>>2, 0x08>>2, 0x10>>2, 0x00>>2, 0x10>>2, 0x00>>2, }, -{ 0x38>>2, 0x44>>2, 0x5c>>2, 0x5c>>2, 0x58>>2, 0x40>>2, 0x38>>2, 0x00>>2, }, -{ 0x10>>2, 0x28>>2, 0x44>>2, 0x44>>2, 0x7c>>2, 0x44>>2, 0x44>>2, 0x00>>2, }, -{ 0x78>>2, 0x44>>2, 0x44>>2, 0x78>>2, 0x44>>2, 0x44>>2, 0x78>>2, 0x00>>2, }, -{ 0x38>>2, 0x44>>2, 0x40>>2, 0x40>>2, 0x40>>2, 0x44>>2, 0x38>>2, 0x00>>2, }, -{ 0x70>>2, 0x48>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x48>>2, 0x70>>2, 0x00>>2, }, -{ 0x7c>>2, 0x40>>2, 0x40>>2, 0x78>>2, 0x40>>2, 0x40>>2, 0x7c>>2, 0x00>>2, }, -{ 0x7c>>2, 0x40>>2, 0x40>>2, 0x78>>2, 0x40>>2, 0x40>>2, 0x40>>2, 0x00>>2, }, -{ 0x38>>2, 0x44>>2, 0x40>>2, 0x4c>>2, 0x44>>2, 0x44>>2, 0x3c>>2, 0x00>>2, }, -{ 0x44>>2, 0x44>>2, 0x44>>2, 0x7c>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x00>>2, }, -{ 0x7c>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x7c>>2, 0x00>>2, }, -{ 0x1c>>2, 0x04>>2, 0x04>>2, 0x04>>2, 0x44>>2, 0x44>>2, 0x38>>2, 0x00>>2, }, -{ 0x44>>2, 0x48>>2, 0x50>>2, 0x60>>2, 0x50>>2, 0x48>>2, 0x44>>2, 0x00>>2, }, -{ 0x40>>2, 0x40>>2, 0x40>>2, 0x40>>2, 0x40>>2, 0x40>>2, 0x7c>>2, 0x00>>2, }, -{ 0x44>>2, 0x6c>>2, 0x54>>2, 0x54>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x00>>2, }, -{ 0x44>>2, 0x64>>2, 0x64>>2, 0x54>>2, 0x4c>>2, 0x4c>>2, 0x44>>2, 0x00>>2, }, -{ 0x38>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x38>>2, 0x00>>2, }, -{ 0x78>>2, 0x44>>2, 0x44>>2, 0x78>>2, 0x40>>2, 0x40>>2, 0x40>>2, 0x00>>2, }, -{ 0x38>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x38>>2, 0x0c>>2, }, -{ 0x78>>2, 0x44>>2, 0x44>>2, 0x78>>2, 0x50>>2, 0x48>>2, 0x44>>2, 0x00>>2, }, -{ 0x38>>2, 0x44>>2, 0x40>>2, 0x38>>2, 0x04>>2, 0x44>>2, 0x38>>2, 0x00>>2, }, -{ 0x7c>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x00>>2, }, -{ 0x44>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x38>>2, 0x00>>2, }, -{ 0x44>>2, 0x44>>2, 0x44>>2, 0x28>>2, 0x28>>2, 0x10>>2, 0x10>>2, 0x00>>2, }, -{ 0x44>>2, 0x44>>2, 0x44>>2, 0x54>>2, 0x54>>2, 0x6c>>2, 0x44>>2, 0x00>>2, }, -{ 0x44>>2, 0x44>>2, 0x28>>2, 0x10>>2, 0x28>>2, 0x44>>2, 0x44>>2, 0x00>>2, }, -{ 0x44>>2, 0x44>>2, 0x28>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x00>>2, }, -{ 0x7c>>2, 0x04>>2, 0x08>>2, 0x10>>2, 0x20>>2, 0x40>>2, 0x7c>>2, 0x00>>2, }, -{ 0x1c>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x1c>>2, 0x00>>2, }, -{ 0x20>>2, 0x20>>2, 0x10>>2, 0x10>>2, 0x08>>2, 0x08>>2, 0x04>>2, 0x04>>2, }, -{ 0x70>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x70>>2, 0x00>>2, }, -{ 0x10>>2, 0x28>>2, 0x44>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0xfc>>2, 0x00>>2, }, -{ 0x10>>2, 0x08>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x3c>>2, 0x44>>2, 0x44>>2, 0x4c>>2, 0x34>>2, 0x00>>2, }, -{ 0x40>>2, 0x40>>2, 0x78>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x78>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x3c>>2, 0x40>>2, 0x40>>2, 0x40>>2, 0x3c>>2, 0x00>>2, }, -{ 0x04>>2, 0x04>>2, 0x3c>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x3c>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x38>>2, 0x44>>2, 0x7c>>2, 0x40>>2, 0x38>>2, 0x00>>2, }, -{ 0x1c>>2, 0x20>>2, 0x78>>2, 0x20>>2, 0x20>>2, 0x20>>2, 0x20>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x3c>>2, 0x44>>2, 0x44>>2, 0x3c>>2, 0x04>>2, 0x38>>2, }, -{ 0x40>>2, 0x40>>2, 0x78>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x00>>2, }, -{ 0x10>>2, 0x00>>2, 0x30>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x38>>2, 0x00>>2, }, -{ 0x08>>2, 0x00>>2, 0x38>>2, 0x08>>2, 0x08>>2, 0x08>>2, 0x08>>2, 0x70>>2, }, -{ 0x40>>2, 0x40>>2, 0x48>>2, 0x50>>2, 0x60>>2, 0x50>>2, 0x48>>2, 0x00>>2, }, -{ 0x30>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x38>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x68>>2, 0x54>>2, 0x54>>2, 0x54>>2, 0x44>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x58>>2, 0x64>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x38>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x38>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x78>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x78>>2, 0x40>>2, }, -{ 0x00>>2, 0x00>>2, 0x3c>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x3c>>2, 0x04>>2, }, -{ 0x00>>2, 0x00>>2, 0x58>>2, 0x60>>2, 0x40>>2, 0x40>>2, 0x40>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x3c>>2, 0x40>>2, 0x38>>2, 0x04>>2, 0x78>>2, 0x00>>2, }, -{ 0x10>>2, 0x10>>2, 0x7c>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x0c>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x4c>>2, 0x34>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x6c>>2, 0x28>>2, 0x28>>2, 0x10>>2, 0x10>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x44>>2, 0x54>>2, 0x54>>2, 0x54>>2, 0x28>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x44>>2, 0x28>>2, 0x10>>2, 0x28>>2, 0x44>>2, 0x00>>2, }, -{ 0x00>>2, 0x00>>2, 0x44>>2, 0x44>>2, 0x44>>2, 0x3c>>2, 0x04>>2, 0x38>>2, }, -{ 0x00>>2, 0x00>>2, 0x7c>>2, 0x08>>2, 0x10>>2, 0x20>>2, 0x7c>>2, 0x00>>2, }, -{ 0x04>>2, 0x08>>2, 0x08>>2, 0x10>>2, 0x08>>2, 0x08>>2, 0x04>>2, 0x00>>2, }, -{ 0x10>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x10>>2, 0x00>>2, }, -{ 0x40>>2, 0x20>>2, 0x20>>2, 0x10>>2, 0x20>>2, 0x20>>2, 0x40>>2, 0x00>>2, }, -{ 0x20>>2, 0x54>>2, 0x08>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, 0x00>>2, }, -{ 0x00>>2, 0x10>>2, 0x10>>2, 0x28>>2, 0x28>>2, 0x44>>2, 0x7c>>2, 0x00>>2, }, -}; - diff --git a/frontend/common/fonts.h b/frontend/common/fonts.h deleted file mode 100644 index dbbdd4c6..00000000 --- a/frontend/common/fonts.h +++ /dev/null @@ -1,4 +0,0 @@ - -extern unsigned char fontdata8x8[64*16]; -extern unsigned char fontdata6x8[256-32][8]; - diff --git a/frontend/common/in_sdl.c b/frontend/common/in_sdl.c deleted file mode 100644 index ce575365..00000000 --- a/frontend/common/in_sdl.c +++ /dev/null @@ -1,467 +0,0 @@ -/* - * (C) Gražvydas "notaz" Ignotas, 2012 - * - * This work is licensed under the terms of any of these licenses - * (at your option): - * - GNU GPL, version 2 or later. - * - GNU LGPL, version 2.1 or later. - * See the COPYING file in the top-level directory. - */ - -#include -#include -#include "input.h" -#include "in_sdl.h" - -#define IN_SDL_PREFIX "sdl:" -/* should be machine word for best performace */ -typedef unsigned long keybits_t; -#define KEYBITS_WORD_BITS (sizeof(keybits_t) * 8) - -struct in_sdl_state { - SDL_Joystick *joy; - int joy_id; - int axis_keydown[2]; - keybits_t keystate[SDLK_LAST / KEYBITS_WORD_BITS + 1]; -}; - -static const char * const in_sdl_keys[SDLK_LAST] = { - [SDLK_BACKSPACE] = "backspace", - [SDLK_TAB] = "tab", - [SDLK_CLEAR] = "clear", - [SDLK_RETURN] = "return", - [SDLK_PAUSE] = "pause", - [SDLK_ESCAPE] = "escape", - [SDLK_SPACE] = "space", - [SDLK_EXCLAIM] = "!", - [SDLK_QUOTEDBL] = "\"", - [SDLK_HASH] = "#", - [SDLK_DOLLAR] = "$", - [SDLK_AMPERSAND] = "&", - [SDLK_QUOTE] = "'", - [SDLK_LEFTPAREN] = "(", - [SDLK_RIGHTPAREN] = ")", - [SDLK_ASTERISK] = "*", - [SDLK_PLUS] = "+", - [SDLK_COMMA] = ",", - [SDLK_MINUS] = "-", - [SDLK_PERIOD] = ".", - [SDLK_SLASH] = "/", - [SDLK_0] = "0", - [SDLK_1] = "1", - [SDLK_2] = "2", - [SDLK_3] = "3", - [SDLK_4] = "4", - [SDLK_5] = "5", - [SDLK_6] = "6", - [SDLK_7] = "7", - [SDLK_8] = "8", - [SDLK_9] = "9", - [SDLK_COLON] = ":", - [SDLK_SEMICOLON] = ",", - [SDLK_LESS] = "<", - [SDLK_EQUALS] = "=", - [SDLK_GREATER] = ">", - [SDLK_QUESTION] = "?", - [SDLK_AT] = "@", - [SDLK_LEFTBRACKET] = "[", - [SDLK_BACKSLASH] = "\\", - [SDLK_RIGHTBRACKET] = "]", - [SDLK_CARET] = "^", - [SDLK_UNDERSCORE] = "_", - [SDLK_BACKQUOTE] = "`", - [SDLK_a] = "a", - [SDLK_b] = "b", - [SDLK_c] = "c", - [SDLK_d] = "d", - [SDLK_e] = "e", - [SDLK_f] = "f", - [SDLK_g] = "g", - [SDLK_h] = "h", - [SDLK_i] = "i", - [SDLK_j] = "j", - [SDLK_k] = "k", - [SDLK_l] = "l", - [SDLK_m] = "m", - [SDLK_n] = "n", - [SDLK_o] = "o", - [SDLK_p] = "p", - [SDLK_q] = "q", - [SDLK_r] = "r", - [SDLK_s] = "s", - [SDLK_t] = "t", - [SDLK_u] = "u", - [SDLK_v] = "v", - [SDLK_w] = "w", - [SDLK_x] = "x", - [SDLK_y] = "y", - [SDLK_z] = "z", - [SDLK_DELETE] = "delete", - - [SDLK_KP0] = "[0]", - [SDLK_KP1] = "[1]", - [SDLK_KP2] = "[2]", - [SDLK_KP3] = "[3]", - [SDLK_KP4] = "[4]", - [SDLK_KP5] = "[5]", - [SDLK_KP6] = "[6]", - [SDLK_KP7] = "[7]", - [SDLK_KP8] = "[8]", - [SDLK_KP9] = "[9]", - [SDLK_KP_PERIOD] = "[.]", - [SDLK_KP_DIVIDE] = "[/]", - [SDLK_KP_MULTIPLY] = "[*]", - [SDLK_KP_MINUS] = "[-]", - [SDLK_KP_PLUS] = "[+]", - [SDLK_KP_ENTER] = "enter", - [SDLK_KP_EQUALS] = "equals", - - [SDLK_UP] = "up", - [SDLK_DOWN] = "down", - [SDLK_RIGHT] = "right", - [SDLK_LEFT] = "left", - [SDLK_DOWN] = "down", - [SDLK_INSERT] = "insert", - [SDLK_HOME] = "home", - [SDLK_END] = "end", - [SDLK_PAGEUP] = "page up", - [SDLK_PAGEDOWN] = "page down", - - [SDLK_F1] = "f1", - [SDLK_F2] = "f2", - [SDLK_F3] = "f3", - [SDLK_F4] = "f4", - [SDLK_F5] = "f5", - [SDLK_F6] = "f6", - [SDLK_F7] = "f7", - [SDLK_F8] = "f8", - [SDLK_F9] = "f9", - [SDLK_F10] = "f10", - [SDLK_F11] = "f11", - [SDLK_F12] = "f12", - [SDLK_F13] = "f13", - [SDLK_F14] = "f14", - [SDLK_F15] = "f15", - - [SDLK_NUMLOCK] = "numlock", - [SDLK_CAPSLOCK] = "caps lock", - [SDLK_SCROLLOCK] = "scroll lock", - [SDLK_RSHIFT] = "right shift", - [SDLK_LSHIFT] = "left shift", - [SDLK_RCTRL] = "right ctrl", - [SDLK_LCTRL] = "left ctrl", - [SDLK_RALT] = "right alt", - [SDLK_LALT] = "left alt", - [SDLK_RMETA] = "right meta", - [SDLK_LMETA] = "left meta", - [SDLK_LSUPER] = "left super", /* "Windows" keys */ - [SDLK_RSUPER] = "right super", - [SDLK_MODE] = "alt gr", - [SDLK_COMPOSE] = "compose", -}; - -static void in_sdl_probe(void) -{ - struct in_sdl_state *state; - SDL_Joystick *joy; - int i, joycount; - char name[256]; - - state = calloc(1, sizeof(*state)); - if (state == NULL) { - fprintf(stderr, "in_sdl: OOM\n"); - return; - } - - in_register(IN_SDL_PREFIX "keys", -1, state, SDLK_LAST, - in_sdl_keys, 0); - - /* joysticks go here too */ - SDL_InitSubSystem(SDL_INIT_JOYSTICK); - - joycount = SDL_NumJoysticks(); - for (i = 0; i < joycount; i++) { - joy = SDL_JoystickOpen(i); - if (joy == NULL) - continue; - - state = calloc(1, sizeof(*state)); - if (state == NULL) { - fprintf(stderr, "in_sdl: OOM\n"); - break; - } - state->joy = joy; - state->joy_id = i; - - snprintf(name, sizeof(name), IN_SDL_PREFIX "%s", SDL_JoystickName(i)); - in_register(name, -1, state, SDLK_LAST, in_sdl_keys, 0); - } - - if (joycount > 0) - SDL_JoystickEventState(SDL_ENABLE); -} - -static void in_sdl_free(void *drv_data) -{ - struct in_sdl_state *state = drv_data; - - if (state != NULL) { - if (state->joy != NULL) - SDL_JoystickClose(state->joy); - free(state); - } -} - -static const char * const * -in_sdl_get_key_names(int *count) -{ - *count = SDLK_LAST; - return in_sdl_keys; -} - -/* could use SDL_GetKeyState, but this gives better packing */ -static void update_keystate(keybits_t *keystate, int sym, int is_down) -{ - keybits_t *ks_word, mask; - - mask = 1; - mask <<= sym & (KEYBITS_WORD_BITS - 1); - ks_word = keystate + sym / KEYBITS_WORD_BITS; - if (is_down) - *ks_word |= mask; - else - *ks_word &= ~mask; -} - -static int handle_event(struct in_sdl_state *state, SDL_Event *event, - int *kc_out, int *down_out) -{ - if (event->type != SDL_KEYDOWN && event->type != SDL_KEYUP) - return 0; - - update_keystate(state->keystate, event->key.keysym.sym, - event->type == SDL_KEYDOWN); - if (kc_out != NULL) - *kc_out = event->key.keysym.sym; - if (down_out != NULL) - *down_out = event->type == SDL_KEYDOWN; - - return 1; -} - -static int handle_joy_event(struct in_sdl_state *state, SDL_Event *event, - int *kc_out, int *down_out) -{ - int kc = -1, down = 0, ret = 0; - - /* FIXME: should ckeck .which */ - /* TODO: remaining axis */ - switch (event->type) { - case SDL_JOYAXISMOTION: - if (event->jaxis.axis > 1) - break; - if (-16384 <= event->jaxis.value && event->jaxis.value <= 16384) { - kc = state->axis_keydown[event->jaxis.axis]; - state->axis_keydown[event->jaxis.axis] = 0; - ret = 1; - } - else if (event->jaxis.value < -16384) { - kc = state->axis_keydown[event->jaxis.axis]; - if (kc) - update_keystate(state->keystate, kc, 0); - kc = event->jaxis.axis ? SDLK_UP : SDLK_LEFT; - state->axis_keydown[event->jaxis.axis] = kc; - down = 1; - ret = 1; - } - else if (event->jaxis.value > 16384) { - kc = state->axis_keydown[event->jaxis.axis]; - if (kc) - update_keystate(state->keystate, kc, 0); - kc = event->jaxis.axis ? SDLK_DOWN : SDLK_RIGHT; - state->axis_keydown[event->jaxis.axis] = kc; - down = 1; - ret = 1; - } - break; - - case SDL_JOYBUTTONDOWN: - case SDL_JOYBUTTONUP: - kc = (int)event->jbutton.button + SDLK_WORLD_0; - down = event->jbutton.state == SDL_PRESSED; - ret = 1; - break; - } - - if (ret) - update_keystate(state->keystate, kc, down); - if (kc_out != NULL) - *kc_out = kc; - if (down_out != NULL) - *down_out = down; - - return ret; -} - -#define JOY_EVENTS (SDL_JOYAXISMOTIONMASK | SDL_JOYBALLMOTIONMASK | SDL_JOYHATMOTIONMASK \ - | SDL_JOYBUTTONDOWNMASK | SDL_JOYBUTTONUPMASK) - -static int collect_events(struct in_sdl_state *state, int *one_kc, int *one_down) -{ - SDL_Event events[4]; - Uint32 mask = state->joy ? JOY_EVENTS : (SDL_ALLEVENTS & ~JOY_EVENTS); - int count, maxcount; - int i, ret, retval = 0; - - maxcount = (one_kc != NULL) ? 1 : sizeof(events) / sizeof(events[0]); - - SDL_PumpEvents(); - while (1) { - count = SDL_PeepEvents(events, maxcount, SDL_GETEVENT, mask); - if (count <= 0) - break; - for (i = 0; i < count; i++) { - if (state->joy) - ret = handle_joy_event(state, - &events[i], one_kc, one_down); - else - ret = handle_event(state, - &events[i], one_kc, one_down); - retval |= ret; - if (one_kc != NULL && ret) - goto out; - } - } - -out: - return retval; -} - -static int in_sdl_update(void *drv_data, const int *binds, int *result) -{ - struct in_sdl_state *state = drv_data; - keybits_t mask; - int i, sym, bit, b; - - collect_events(state, NULL, NULL); - - for (i = 0; i < SDLK_LAST / KEYBITS_WORD_BITS + 1; i++) { - mask = state->keystate[i]; - if (mask == 0) - continue; - for (bit = 0; mask != 0; bit++, mask >>= 1) { - if ((mask & 1) == 0) - continue; - sym = i * KEYBITS_WORD_BITS + bit; - - for (b = 0; b < IN_BINDTYPE_COUNT; b++) - result[b] |= binds[IN_BIND_OFFS(sym, b)]; - } - } - - return 0; -} - -static int in_sdl_update_keycode(void *drv_data, int *is_down) -{ - struct in_sdl_state *state = drv_data; - int ret_kc = -1, ret_down = 0; - - collect_events(state, &ret_kc, &ret_down); - - if (is_down != NULL) - *is_down = ret_down; - - return ret_kc; -} - -struct menu_keymap { - short key; - short pbtn; -}; - -static const struct menu_keymap key_pbtn_map[] = -{ - { SDLK_UP, PBTN_UP }, - { SDLK_DOWN, PBTN_DOWN }, - { SDLK_LEFT, PBTN_LEFT }, - { SDLK_RIGHT, PBTN_RIGHT }, - /* XXX: maybe better set this from it's plat code somehow */ - { SDLK_RETURN, PBTN_MOK }, - { SDLK_ESCAPE, PBTN_MBACK }, - { SDLK_a, PBTN_MA2 }, - { SDLK_s, PBTN_MA3 }, - { SDLK_BACKSLASH, PBTN_MENU }, - { SDLK_LEFTBRACKET, PBTN_L }, - { SDLK_RIGHTBRACKET, PBTN_R }, -}; -#define KEY_PBTN_MAP_SIZE (sizeof(key_pbtn_map) / sizeof(key_pbtn_map[0])) - -static const struct menu_keymap joybtn_pbtn_map[] = -{ - { SDLK_UP, PBTN_UP }, - { SDLK_DOWN, PBTN_DOWN }, - { SDLK_LEFT, PBTN_LEFT }, - { SDLK_RIGHT, PBTN_RIGHT }, - /* joystick */ - { SDLK_WORLD_0, PBTN_MOK }, - { SDLK_WORLD_1, PBTN_MBACK }, - { SDLK_WORLD_2, PBTN_MA2 }, - { SDLK_WORLD_3, PBTN_MA3 }, -}; -#define JOYBTN_PBTN_MAP_SIZE (sizeof(joybtn_pbtn_map) / sizeof(joybtn_pbtn_map[0])) - -static int in_sdl_menu_translate(void *drv_data, int keycode, char *charcode) -{ - struct in_sdl_state *state = drv_data; - const struct menu_keymap *map; - int map_len; - int ret = 0; - int i; - - map = state->joy ? joybtn_pbtn_map : key_pbtn_map; - map_len = state->joy ? JOYBTN_PBTN_MAP_SIZE : KEY_PBTN_MAP_SIZE; - - if (keycode < 0) - { - /* menu -> kc */ - keycode = -keycode; - for (i = 0; i < map_len; i++) - if (map[i].pbtn == keycode) - return map[i].key; - } - else - { - for (i = 0; i < map_len; i++) { - if (map[i].key == keycode) { - ret = map[i].pbtn; - break; - } - } - - if (charcode != NULL && (unsigned int)keycode < SDLK_LAST && - in_sdl_keys[keycode] != NULL && in_sdl_keys[keycode][1] == 0) - { - ret |= PBTN_CHAR; - *charcode = in_sdl_keys[keycode][0]; - } - } - - return ret; -} - -static const in_drv_t in_sdl_drv = { - .prefix = IN_SDL_PREFIX, - .probe = in_sdl_probe, - .free = in_sdl_free, - .get_key_names = in_sdl_get_key_names, - .update = in_sdl_update, - .update_keycode = in_sdl_update_keycode, - .menu_translate = in_sdl_menu_translate, -}; - -void in_sdl_init(const struct in_default_bind *defbinds) -{ - in_register_driver(&in_sdl_drv, defbinds); -} - diff --git a/frontend/common/in_sdl.h b/frontend/common/in_sdl.h deleted file mode 100644 index 47f7a832..00000000 --- a/frontend/common/in_sdl.h +++ /dev/null @@ -1,3 +0,0 @@ -struct in_default_bind; - -void in_sdl_init(const struct in_default_bind *defbinds); diff --git a/frontend/common/input.c b/frontend/common/input.c deleted file mode 100644 index 39d67839..00000000 --- a/frontend/common/input.c +++ /dev/null @@ -1,991 +0,0 @@ -/* - * (C) Gražvydas "notaz" Ignotas, 2008-2011 - * - * This work is licensed under the terms of any of these licenses - * (at your option): - * - GNU GPL, version 2 or later. - * - GNU LGPL, version 2.1 or later. - * See the COPYING file in the top-level directory. - */ - -#include -#include -#include - -#include "input.h" -#include "plat.h" -#include "lprintf.h" - -#ifdef IN_GP2X -#error needs update: in_gp2x_init in_gp2x_update -#include "../gp2x/in_gp2x.h" -#endif -#ifdef IN_VK -#error needs update: in_vk_init in_vk_update -#include "../win32/in_vk.h" -#endif - -typedef struct -{ - int drv_id; - int drv_fd_hnd; - void *drv_data; - char *name; - int key_count; - int *binds; /* total = key_count * bindtypes * 2 */ - const char * const *key_names; - unsigned int probed:1; - unsigned int does_combos:1; -} in_dev_t; - -static in_drv_t *in_drivers; -static in_dev_t in_devices[IN_MAX_DEVS]; -static int in_driver_count = 0; -static int in_dev_count = 0; /* probed + bind devices */ -static int in_have_async_devs = 0; -static int in_probe_dev_id; -static int menu_key_state = 0; -static int menu_last_used_dev = 0; - -#define DRV(id) in_drivers[id] - - -static int *in_alloc_binds(int drv_id, int key_count) -{ - const struct in_default_bind *defbinds; - int *binds; - int i; - - binds = calloc(key_count * IN_BINDTYPE_COUNT * 2, sizeof(binds[0])); - if (binds == NULL) - return NULL; - - defbinds = DRV(drv_id).defbinds; - if (defbinds != NULL) { - for (i = 0; ; i++) { - if (defbinds[i].bit == 0 && defbinds[i].code == 0) - break; - binds[IN_BIND_OFFS(defbinds[i].code, defbinds[i].btype)] = - 1 << defbinds[i].bit; - } - - /* always have a copy of defbinds */ - memcpy(binds + key_count * IN_BINDTYPE_COUNT, binds, - sizeof(binds[0]) * key_count * IN_BINDTYPE_COUNT); - } - - return binds; -} - -static void in_unprobe(in_dev_t *dev) -{ - if (dev->probed) - DRV(dev->drv_id).free(dev->drv_data); - dev->probed = 0; - dev->drv_data = NULL; -} - -static void in_free(in_dev_t *dev) -{ - in_unprobe(dev); - free(dev->name); - dev->name = NULL; - free(dev->binds); - dev->binds = NULL; -} - -/* to be called by drivers - * async devices must set drv_fd_hnd to -1 */ -void in_register(const char *nname, int drv_fd_hnd, void *drv_data, - int key_count, const char * const *key_names, int combos) -{ - int i, ret, dupe_count = 0, *binds; - char name[256], *name_end, *tmp; - - strncpy(name, nname, sizeof(name)); - name[sizeof(name)-12] = 0; - name_end = name + strlen(name); - - for (i = 0; i < in_dev_count; i++) - { - if (in_devices[i].name == NULL) - continue; - if (strcmp(in_devices[i].name, name) == 0) - { - if (in_devices[i].probed) { - dupe_count++; - sprintf(name_end, " [%d]", dupe_count); - continue; - } - goto update; - } - } - - if (i >= IN_MAX_DEVS) - { - /* try to find unused device */ - for (i = 0; i < IN_MAX_DEVS; i++) - if (!in_devices[i].probed) break; - if (i >= IN_MAX_DEVS) { - lprintf("input: too many devices, can't add %s\n", name); - return; - } - in_free(&in_devices[i]); - } - - tmp = strdup(name); - if (tmp == NULL) - return; - - binds = in_alloc_binds(in_probe_dev_id, key_count); - if (binds == NULL) { - free(tmp); - return; - } - - in_devices[i].name = tmp; - in_devices[i].binds = binds; - in_devices[i].key_count = key_count; - if (i + 1 > in_dev_count) - in_dev_count = i + 1; - - lprintf("input: new device #%d \"%s\"\n", i, name); -update: - in_devices[i].probed = 1; - in_devices[i].does_combos = combos; - in_devices[i].drv_id = in_probe_dev_id; - in_devices[i].drv_fd_hnd = drv_fd_hnd; - in_devices[i].key_names = key_names; - in_devices[i].drv_data = drv_data; - - if (in_devices[i].binds != NULL) { - ret = DRV(in_probe_dev_id).clean_binds(drv_data, in_devices[i].binds, - in_devices[i].binds + key_count * IN_BINDTYPE_COUNT); - if (ret == 0) { - /* no useable binds */ - free(in_devices[i].binds); - in_devices[i].binds = NULL; - } - } -} - -/* key combo handling, to be called by drivers that support it. - * Only care about IN_BINDTYPE_EMU */ -void in_combos_find(const int *binds, int last_key, int *combo_keys, int *combo_acts) -{ - int act, u; - - *combo_keys = *combo_acts = 0; - for (act = 0; act < sizeof(binds[0]) * 8; act++) - { - int keyc = 0; - for (u = 0; u <= last_key; u++) - if (binds[IN_BIND_OFFS(u, IN_BINDTYPE_EMU)] & (1 << act)) - keyc++; - - if (keyc > 1) - { - // loop again and mark those keys and actions as combo - for (u = 0; u <= last_key; u++) - { - if (binds[IN_BIND_OFFS(u, IN_BINDTYPE_EMU)] & (1 << act)) { - *combo_keys |= 1 << u; - *combo_acts |= 1 << act; - } - } - } - } -} - -int in_combos_do(int keys, const int *binds, int last_key, int combo_keys, int combo_acts) -{ - int i, ret = 0; - - for (i = 0; i <= last_key; i++) - { - int acts, acts_c, u; - - if (!(keys & (1 << i))) - continue; - - acts = binds[IN_BIND_OFFS(i, IN_BINDTYPE_EMU)]; - if (!acts) - continue; - - if (!(combo_keys & (1 << i))) { - ret |= acts; - continue; - } - - acts_c = acts & combo_acts; - u = last_key; - if (acts_c) { - // let's try to find the other one - for (u = i + 1; u <= last_key; u++) - if ( (keys & (1 << u)) && (binds[IN_BIND_OFFS(u, IN_BINDTYPE_EMU)] & acts_c) ) { - ret |= acts_c & binds[IN_BIND_OFFS(u, IN_BINDTYPE_EMU)]; - keys &= ~((1 << i) | (1 << u)); - break; - } - } - // add non-combo actions if combo ones were not found - if (u >= last_key) - ret |= acts & ~combo_acts; - } - - return ret; -} - -void in_probe(void) -{ - int i; - - in_have_async_devs = 0; - menu_key_state = 0; - menu_last_used_dev = 0; - - for (i = 0; i < in_dev_count; i++) - in_unprobe(&in_devices[i]); - - for (i = 0; i < in_driver_count; i++) { - in_probe_dev_id = i; - in_drivers[i].probe(); - } - - /* get rid of devs without binds and probes */ - for (i = 0; i < in_dev_count; i++) { - if (!in_devices[i].probed && in_devices[i].binds == NULL) { - in_dev_count--; - if (i < in_dev_count) { - free(in_devices[i].name); - memmove(&in_devices[i], &in_devices[i+1], - (in_dev_count - i) * sizeof(in_devices[0])); - } - - continue; - } - - if (in_devices[i].probed && in_devices[i].drv_fd_hnd == -1) - in_have_async_devs = 1; - } - - if (in_have_async_devs) - lprintf("input: async-only devices detected..\n"); - - in_debug_dump(); -} - -/* async update */ -int in_update(int *result) -{ - int i, ret = 0; - - for (i = 0; i < in_dev_count; i++) { - in_dev_t *dev = &in_devices[i]; - if (dev->probed && dev->binds != NULL) - ret |= DRV(dev->drv_id).update(dev->drv_data, dev->binds, result); - } - - return ret; -} - -static in_dev_t *get_dev(int dev_id) -{ - if (dev_id < 0 || dev_id >= IN_MAX_DEVS) - return NULL; - - return &in_devices[dev_id]; -} - -int in_update_analog(int dev_id, int axis_id, int *result) -{ - in_dev_t *dev = get_dev(dev_id); - - if (dev == NULL || !dev->probed) - return -1; - - return DRV(dev->drv_id).update_analog(dev->drv_data, axis_id, result); -} - -static int in_update_kc_async(int *dev_id_out, int *is_down_out, int timeout_ms) -{ - int i, is_down, result; - unsigned int ticks; - - ticks = plat_get_ticks_ms(); - - while (1) - { - for (i = 0; i < in_dev_count; i++) { - in_dev_t *d = &in_devices[i]; - if (!d->probed) - continue; - - result = DRV(d->drv_id).update_keycode(d->drv_data, &is_down); - if (result == -1) - continue; - - if (dev_id_out) - *dev_id_out = i; - if (is_down_out) - *is_down_out = is_down; - return result; - } - - if (timeout_ms >= 0 && (int)(plat_get_ticks_ms() - ticks) > timeout_ms) - break; - - plat_sleep_ms(10); - } - - return -1; -} - -/* - * wait for a press, always return some keycode or -1 on timeout or error - */ -int in_update_keycode(int *dev_id_out, int *is_down_out, char *charcode, int timeout_ms) -{ - int result = -1, dev_id = 0, is_down, result_menu; - int fds_hnds[IN_MAX_DEVS]; - int i, ret, count = 0; - in_drv_t *drv = NULL; - unsigned int ticks; - - if (in_have_async_devs) { - result = in_update_kc_async(&dev_id, &is_down, timeout_ms); - if (result == -1) - return -1; - drv = &DRV(in_devices[dev_id].drv_id); - goto finish; - } - - ticks = plat_get_ticks_ms(); - - for (i = 0; i < in_dev_count; i++) { - if (in_devices[i].probed) - fds_hnds[count++] = in_devices[i].drv_fd_hnd; - } - - if (count == 0) { - /* don't deadlock, fail */ - lprintf("input: failed to find devices to read\n"); - exit(1); - } - - while (1) - { - ret = plat_wait_event(fds_hnds, count, timeout_ms); - if (ret < 0) - break; - - for (i = 0; i < in_dev_count; i++) { - if (in_devices[i].drv_fd_hnd == ret) { - dev_id = i; - break; - } - } - - drv = &DRV(in_devices[dev_id].drv_id); - result = drv->update_keycode(in_devices[dev_id].drv_data, &is_down); - if (result >= 0) - break; - - if (result == -2) { - lprintf("input: \"%s\" errored out, removing.\n", in_devices[dev_id].name); - in_unprobe(&in_devices[dev_id]); - break; - } - - if (timeout_ms >= 0) { - unsigned int ticks2 = plat_get_ticks_ms(); - timeout_ms -= ticks2 - ticks; - ticks = ticks2; - if (timeout_ms <= 0) - break; - } - } - - if (result < 0) - return -1; -finish: - /* keep track of menu key state, to allow mixing - * in_update_keycode() and in_menu_wait_any() calls */ - result_menu = drv->menu_translate(in_devices[dev_id].drv_data, result, charcode); - if (result_menu != 0) { - if (is_down) - menu_key_state |= result_menu; - else - menu_key_state &= ~result_menu; - } - - if (dev_id_out != NULL) - *dev_id_out = dev_id; - if (is_down_out != NULL) - *is_down_out = is_down; - return result; -} - -/* same as above, only return bitfield of PBTN_* */ -int in_menu_wait_any(char *charcode, int timeout_ms) -{ - int keys_old = menu_key_state; - - while (1) - { - int code, is_down = 0, dev_id = 0; - - code = in_update_keycode(&dev_id, &is_down, charcode, timeout_ms); - if (code < 0) - break; - - if (keys_old != menu_key_state) { - menu_last_used_dev = dev_id; - break; - } - } - - return menu_key_state; -} - -/* wait for menu input, do autorepeat */ -int in_menu_wait(int interesting, char *charcode, int autorep_delay_ms) -{ - static int inp_prev = 0; - static int repeats = 0; - int ret, release = 0, wait = 450; - - if (repeats) - wait = autorep_delay_ms; - - ret = in_menu_wait_any(charcode, wait); - if (ret == inp_prev) - repeats++; - - while (!(ret & interesting)) { - ret = in_menu_wait_any(charcode, -1); - release = 1; - } - - if (release || ret != inp_prev) - repeats = 0; - - inp_prev = ret; - - /* we don't need diagonals in menus */ - if ((ret & PBTN_UP) && (ret & PBTN_LEFT)) ret &= ~PBTN_LEFT; - if ((ret & PBTN_UP) && (ret & PBTN_RIGHT)) ret &= ~PBTN_RIGHT; - if ((ret & PBTN_DOWN) && (ret & PBTN_LEFT)) ret &= ~PBTN_LEFT; - if ((ret & PBTN_DOWN) && (ret & PBTN_RIGHT)) ret &= ~PBTN_RIGHT; - - return ret; -} - -const int *in_get_dev_binds(int dev_id) -{ - in_dev_t *dev = get_dev(dev_id); - - return dev ? dev->binds : NULL; -} - -const int *in_get_dev_def_binds(int dev_id) -{ - in_dev_t *dev = get_dev(dev_id); - if (dev == NULL) - return NULL; - - return dev->binds + dev->key_count * IN_BINDTYPE_COUNT; -} - -int in_get_config(int dev_id, int what, void *val) -{ - int *ival = val; - in_dev_t *dev; - - dev = get_dev(dev_id); - if (dev == NULL || val == NULL) - return -1; - - switch (what) { - case IN_CFG_BIND_COUNT: - *ival = dev->key_count; - break; - case IN_CFG_DOES_COMBOS: - *ival = dev->does_combos; - break; - case IN_CFG_BLOCKING: - case IN_CFG_KEY_NAMES: - return -1; /* not implemented */ - default: - return DRV(dev->drv_id).get_config(dev->drv_data, what, ival); - } - - return 0; -} - -static int in_set_blocking(int is_blocking) -{ - int i, ret; - - /* have_async_devs means we will have to do all reads async anyway.. */ - if (!in_have_async_devs) { - for (i = 0; i < in_dev_count; i++) { - if (in_devices[i].probed) - DRV(in_devices[i].drv_id).set_config(in_devices[i].drv_data, - IN_CFG_BLOCKING, is_blocking); - } - } - - menu_key_state = 0; - - /* flush events */ - do { - ret = in_update_keycode(NULL, NULL, NULL, 0); - } while (ret >= 0); - - return 0; -} - -int in_set_config(int dev_id, int what, const void *val, int size) -{ - const char * const *names; - const int *ival = val; - in_dev_t *dev; - int count; - - if (what == IN_CFG_BLOCKING) - return in_set_blocking(*ival); - - dev = get_dev(dev_id); - if (dev == NULL) - return -1; - - switch (what) { - case IN_CFG_KEY_NAMES: - names = val; - count = size / sizeof(names[0]); - - if (count < dev->key_count) { - lprintf("input: set_key_names: not enough keys\n"); - return -1; - } - - dev->key_names = names; - return 0; - case IN_CFG_DEFAULT_DEV: - /* just set last used dev, for now */ - menu_last_used_dev = dev_id; - return 0; - default: - break; - } - - if (dev->probed) - return DRV(dev->drv_id).set_config(dev->drv_data, what, *ival); - - return -1; -} - -const char *in_get_dev_name(int dev_id, int must_be_active, int skip_pfix) -{ - const char *name, *tmp; - in_dev_t *dev; - - dev = get_dev(dev_id); - if (dev == NULL) - return NULL; - - if (must_be_active && !dev->probed) - return NULL; - - name = dev->name; - if (name == NULL || !skip_pfix) - return name; - - /* skip prefix */ - tmp = strchr(name, ':'); - if (tmp != NULL) - name = tmp + 1; - - return name; -} - -int in_name_to_id(const char *dev_name) -{ - int i; - - for (i = 0; i < in_dev_count; i++) - if (strcmp(dev_name, in_devices[i].name) == 0) - break; - - if (i >= in_dev_count) { - lprintf("input: in_name_to_id: no such device: %s\n", dev_name); - return -1; - } - - return i; -} - -/* never returns NULL */ -const char *in_get_key_name(int dev_id, int keycode) -{ - const char *name = NULL; - static char xname[16]; - in_drv_t *drv; - in_dev_t *dev; - - if (dev_id < 0) /* want last used dev? */ - dev_id = menu_last_used_dev; - - dev = get_dev(dev_id); - if (dev == NULL) - return "Unkn0"; - - drv = &DRV(dev->drv_id); - if (keycode < 0) /* want name for menu key? */ - keycode = drv->menu_translate(dev->drv_data, keycode, NULL); - - if (dev->key_names != NULL && 0 <= keycode && keycode < dev->key_count) - name = dev->key_names[keycode]; - if (name != NULL) - return name; - - if (drv->get_key_name != NULL) - name = drv->get_key_name(keycode); - if (name != NULL) - return name; - - /* assume scancode */ - if ((keycode >= '0' && keycode <= '9') || (keycode >= 'a' && keycode <= 'z') - || (keycode >= 'A' && keycode <= 'Z')) - sprintf(xname, "%c", keycode); - else - sprintf(xname, "\\x%02X", keycode); - return xname; -} - -int in_get_key_code(int dev_id, const char *key_name) -{ - in_dev_t *dev; - int i; - - if (dev_id < 0) /* want last used dev? */ - dev_id = menu_last_used_dev; - - dev = get_dev(dev_id); - if (dev == NULL) - return -1; - - if (dev->key_names == NULL) - return -1; - - for (i = 0; i < dev->key_count; i++) - if (dev->key_names[i] && strcasecmp(dev->key_names[i], key_name) == 0) - return i; - - return -1; -} - -int in_bind_key(int dev_id, int keycode, int mask, int bind_type, int force_unbind) -{ - int ret, count; - in_dev_t *dev; - - dev = get_dev(dev_id); - if (dev == NULL || bind_type >= IN_BINDTYPE_COUNT) - return -1; - - count = dev->key_count; - - if (dev->binds == NULL) { - if (force_unbind) - return 0; - dev->binds = in_alloc_binds(dev->drv_id, count); - if (dev->binds == NULL) - return -1; - } - - if (keycode < 0 || keycode >= count) - return -1; - - if (force_unbind) - dev->binds[IN_BIND_OFFS(keycode, bind_type)] &= ~mask; - else - dev->binds[IN_BIND_OFFS(keycode, bind_type)] ^= mask; - - ret = DRV(dev->drv_id).clean_binds(dev->drv_data, dev->binds, - dev->binds + count * IN_BINDTYPE_COUNT); - if (ret == 0) { - free(dev->binds); - dev->binds = NULL; - } - - return 0; -} - -/* - * Unbind act_mask on binds with type bind_type - * - if dev_id_ < 0, affects all devices - * else only affects dev_id_ - * - if act_mask == -1, unbind all keys - * else only actions in mask - */ -void in_unbind_all(int dev_id_, int act_mask, int bind_type) -{ - int dev_id = 0, dev_last = IN_MAX_DEVS - 1; - int i, count; - in_dev_t *dev; - - if (dev_id_ >= 0) - dev_id = dev_last = dev_id_; - - if (bind_type >= IN_BINDTYPE_COUNT) - return; - - for (; dev_id <= dev_last; dev_id++) { - dev = &in_devices[dev_id]; - count = dev->key_count; - - if (dev->binds == NULL) - continue; - - if (act_mask != -1) { - for (i = 0; i < count; i++) - dev->binds[IN_BIND_OFFS(i, bind_type)] &= ~act_mask; - } - else - memset(dev->binds, 0, sizeof(dev->binds[0]) * count * IN_BINDTYPE_COUNT); - } -} - -/* returns device id, or -1 on error */ -int in_config_parse_dev(const char *name) -{ - int drv_id = -1, i; - - for (i = 0; i < in_driver_count; i++) { - int len = strlen(in_drivers[i].prefix); - if (strncmp(name, in_drivers[i].prefix, len) == 0) { - drv_id = i; - break; - } - } - - if (drv_id < 0) { - lprintf("input: missing driver for %s\n", name); - return -1; - } - - for (i = 0; i < in_dev_count; i++) - { - if (in_devices[i].name == NULL) - continue; - if (strcmp(in_devices[i].name, name) == 0) - return i; - } - - if (i >= IN_MAX_DEVS) - { - /* try to find unused device */ - for (i = 0; i < IN_MAX_DEVS; i++) - if (in_devices[i].name == NULL) break; - if (i >= IN_MAX_DEVS) { - lprintf("input: too many devices, can't add %s\n", name); - return -1; - } - } - - memset(&in_devices[i], 0, sizeof(in_devices[i])); - - in_devices[i].name = strdup(name); - if (in_devices[i].name == NULL) - return -1; - - in_devices[i].key_names = DRV(drv_id).get_key_names(&in_devices[i].key_count); - in_devices[i].drv_id = drv_id; - - if (i + 1 > in_dev_count) - in_dev_count = i + 1; - - return i; -} - -int in_config_bind_key(int dev_id, const char *key, int acts, int bind_type) -{ - in_dev_t *dev; - int i, offs, kc; - - dev = get_dev(dev_id); - if (dev == NULL || bind_type >= IN_BINDTYPE_COUNT) - return -1; - - /* maybe a raw code? */ - if (key[0] == '\\' && key[1] == 'x') { - char *p = NULL; - kc = (int)strtoul(key + 2, &p, 16); - if (p == NULL || *p != 0) - kc = -1; - } - else { - /* device specific key name */ - if (dev->binds == NULL) { - dev->binds = in_alloc_binds(dev->drv_id, dev->key_count); - if (dev->binds == NULL) - return -1; - } - - kc = -1; - if (dev->key_names != NULL) { - for (i = 0; i < dev->key_count; i++) { - const char *k = dev->key_names[i]; - if (k != NULL && strcasecmp(k, key) == 0) { - kc = i; - break; - } - } - } - - if (kc < 0) - kc = DRV(dev->drv_id).get_key_code(key); - if (kc < 0 && strlen(key) == 1) { - /* assume scancode */ - kc = key[0]; - } - } - - if (kc < 0 || kc >= dev->key_count) { - lprintf("input: bad key: %s\n", key); - return -1; - } - - if (bind_type == IN_BINDTYPE_NONE) { - for (i = 0; i < IN_BINDTYPE_COUNT; i++) - dev->binds[IN_BIND_OFFS(kc, i)] = 0; - return 0; - } - - offs = IN_BIND_OFFS(kc, bind_type); - if (dev->binds[offs] == -1) - dev->binds[offs] = 0; - dev->binds[offs] |= acts; - return 0; -} - -void in_clean_binds(void) -{ - int i; - - for (i = 0; i < IN_MAX_DEVS; i++) { - int ret, count, *binds, *def_binds; - in_dev_t *dev = &in_devices[i]; - - if (dev->binds == NULL || dev->drv_data == NULL) - continue; - - count = dev->key_count; - binds = dev->binds; - def_binds = binds + count * IN_BINDTYPE_COUNT; - - ret = DRV(dev->drv_id).clean_binds(dev->drv_data, binds, def_binds); - if (ret == 0) { - /* no useable binds */ - free(dev->binds); - dev->binds = NULL; - } - } -} - -void in_debug_dump(void) -{ - int i; - - lprintf("# drv probed binds name\n"); - for (i = 0; i < IN_MAX_DEVS; i++) { - in_dev_t *d = &in_devices[i]; - if (!d->probed && d->name == NULL && d->binds == NULL) - continue; - lprintf("%d %3d %6c %5c %s\n", i, d->drv_id, d->probed ? 'y' : 'n', - d->binds ? 'y' : 'n', d->name); - } -} - -/* stubs for drivers that choose not to implement something */ - -static void in_def_free(void *drv_data) {} -static int in_def_clean_binds(void *drv_data, int *b, int *db) { return 1; } -static int in_def_get_config(void *drv_data, int what, int *val) { return -1; } -static int in_def_set_config(void *drv_data, int what, int val) { return -1; } -static int in_def_update_analog(void *drv_data, int axis_id, int *result) { return -1; } -static int in_def_update_keycode(void *drv_data, int *is_down) { return 0; } -static int in_def_menu_translate(void *drv_data, int keycode, char *ccode) { return 0; } -static int in_def_get_key_code(const char *key_name) { return -1; } -static const char *in_def_get_key_name(int keycode) { return NULL; } - -#define CHECK_ADD_STUB(d, f) \ - if (d.f == NULL) d.f = in_def_##f - -/* to be called by drivers */ -int in_register_driver(const in_drv_t *drv, const struct in_default_bind *defbinds) -{ - int count_new = in_driver_count + 1; - in_drv_t *new_drivers; - - new_drivers = realloc(in_drivers, count_new * sizeof(in_drivers[0])); - if (new_drivers == NULL) { - lprintf("input: in_register_driver OOM\n"); - return -1; - } - - memcpy(&new_drivers[in_driver_count], drv, sizeof(new_drivers[0])); - - CHECK_ADD_STUB(new_drivers[in_driver_count], free); - CHECK_ADD_STUB(new_drivers[in_driver_count], clean_binds); - CHECK_ADD_STUB(new_drivers[in_driver_count], get_config); - CHECK_ADD_STUB(new_drivers[in_driver_count], set_config); - CHECK_ADD_STUB(new_drivers[in_driver_count], update_analog); - CHECK_ADD_STUB(new_drivers[in_driver_count], update_keycode); - CHECK_ADD_STUB(new_drivers[in_driver_count], menu_translate); - CHECK_ADD_STUB(new_drivers[in_driver_count], get_key_code); - CHECK_ADD_STUB(new_drivers[in_driver_count], get_key_name); - if (defbinds != NULL) - new_drivers[in_driver_count].defbinds = defbinds; - in_drivers = new_drivers; - in_driver_count = count_new; - - return 0; -} - -void in_init(void) -{ - in_drivers = NULL; - memset(in_devices, 0, sizeof(in_devices)); - in_driver_count = 0; - in_dev_count = 0; -} - -#if 0 -int main(void) -{ - int ret; - - in_init(); - in_probe(); - - in_set_blocking(1); - -#if 1 - while (1) { - int dev = 0, down; - ret = in_update_keycode(&dev, &down); - lprintf("#%i: %i %i (%s)\n", dev, down, ret, in_get_key_name(dev, ret)); - } -#else - while (1) { - ret = in_menu_wait_any(); - lprintf("%08x\n", ret); - } -#endif - - return 0; -} -#endif diff --git a/frontend/common/input.h b/frontend/common/input.h deleted file mode 100644 index e87e6ea5..00000000 --- a/frontend/common/input.h +++ /dev/null @@ -1,140 +0,0 @@ -#ifndef INCLUDE_uXt8Z4R7EMpuEEtvSibXjNhKH3741VNc -#define INCLUDE_uXt8Z4R7EMpuEEtvSibXjNhKH3741VNc 1 - -#define IN_MAX_DEVS 10 -#define IN_ABS_RANGE 1024 /* abs must be centered at 0, move upto +- this */ - -/* unified menu keys */ -#define PBTN_UP (1 << 0) -#define PBTN_DOWN (1 << 1) -#define PBTN_LEFT (1 << 2) -#define PBTN_RIGHT (1 << 3) - -#define PBTN_MOK (1 << 4) -#define PBTN_MBACK (1 << 5) -#define PBTN_MA2 (1 << 6) /* menu action 2 */ -#define PBTN_MA3 (1 << 7) - -#define PBTN_L (1 << 8) -#define PBTN_R (1 << 9) - -#define PBTN_MENU (1 << 10) - -#define PBTN_CHAR (1 << 11) /* character (text input) */ - -// TODO: move to pico -#if 0 - -/* ui events */ -#define PEVB_VOL_DOWN 30 -#define PEVB_VOL_UP 29 -#define PEVB_STATE_LOAD 28 -#define PEVB_STATE_SAVE 27 -#define PEVB_SWITCH_RND 26 -#define PEVB_SSLOT_PREV 25 -#define PEVB_SSLOT_NEXT 24 -#define PEVB_MENU 23 -#define PEVB_FF 22 -#define PEVB_PICO_PNEXT 21 -#define PEVB_PICO_PPREV 20 -#define PEVB_PICO_SWINP 19 - -#define PEV_VOL_DOWN (1 << PEVB_VOL_DOWN) -#define PEV_VOL_UP (1 << PEVB_VOL_UP) -#define PEV_STATE_LOAD (1 << PEVB_STATE_LOAD) -#define PEV_STATE_SAVE (1 << PEVB_STATE_SAVE) -#define PEV_SWITCH_RND (1 << PEVB_SWITCH_RND) -#define PEV_SSLOT_PREV (1 << PEVB_SSLOT_PREV) -#define PEV_SSLOT_NEXT (1 << PEVB_SSLOT_NEXT) -#define PEV_MENU (1 << PEVB_MENU) -#define PEV_FF (1 << PEVB_FF) -#define PEV_PICO_PNEXT (1 << PEVB_PICO_PNEXT) -#define PEV_PICO_PPREV (1 << PEVB_PICO_PPREV) -#define PEV_PICO_SWINP (1 << PEVB_PICO_SWINP) - -#define PEV_MASK 0x7ff80000 - -#endif - -enum { - IN_CFG_BIND_COUNT = 0, - IN_CFG_DOES_COMBOS, - IN_CFG_BLOCKING, - IN_CFG_KEY_NAMES, - IN_CFG_ABS_DEAD_ZONE, /* dead zone for analog-digital mapping */ - IN_CFG_ABS_AXIS_COUNT, /* number of abs axes (ro) */ - IN_CFG_DEFAULT_DEV, -}; - -enum { - IN_BINDTYPE_NONE = -1, - IN_BINDTYPE_EMU = 0, - IN_BINDTYPE_PLAYER12, - IN_BINDTYPE_COUNT -}; - -#define IN_BIND_OFFS(key, btype) \ - ((key) * IN_BINDTYPE_COUNT + (btype)) - -typedef struct { - const char *prefix; - void (*probe)(void); - void (*free)(void *drv_data); - const char * const * - (*get_key_names)(int *count); - int (*clean_binds)(void *drv_data, int *binds, int *def_finds); - int (*get_config)(void *drv_data, int what, int *val); - int (*set_config)(void *drv_data, int what, int val); - int (*update)(void *drv_data, const int *binds, int *result); - int (*update_analog)(void *drv_data, int axis_id, int *result); - /* return -1 on no event, -2 on error */ - int (*update_keycode)(void *drv_data, int *is_down); - int (*menu_translate)(void *drv_data, int keycode, char *charcode); - int (*get_key_code)(const char *key_name); - const char * (*get_key_name)(int keycode); - - const struct in_default_bind *defbinds; -} in_drv_t; - -struct in_default_bind { - unsigned short code; - unsigned char btype; /* IN_BINDTYPE_* */ - unsigned char bit; -}; - -/* to be called by drivers */ -int in_register_driver(const in_drv_t *drv, const struct in_default_bind *defbinds); -void in_register(const char *nname, int drv_fd_hnd, void *drv_data, - int key_count, const char * const *key_names, int combos); -void in_combos_find(const int *binds, int last_key, int *combo_keys, int *combo_acts); -int in_combos_do(int keys, const int *binds, int last_key, int combo_keys, int combo_acts); - -void in_init(void); -void in_probe(void); -int in_update(int *result); -int in_update_analog(int dev_id, int axis_id, int *value); -int in_update_keycode(int *dev_id, int *is_down, char *charcode, int timeout_ms); -int in_menu_wait_any(char *charcode, int timeout_ms); -int in_menu_wait(int interesting, char *charcode, int autorep_delay_ms); -int in_config_parse_dev(const char *dev_name); -int in_config_bind_key(int dev_id, const char *key, int binds, int bind_type); -int in_get_config(int dev_id, int what, void *val); -int in_set_config(int dev_id, int what, const void *val, int size); -int in_get_key_code(int dev_id, const char *key_name); -int in_name_to_id(const char *dev_name); -int in_bind_key(int dev_id, int keycode, int mask, int bind_type, int force_unbind); -void in_unbind_all(int dev_id, int act_mask, int bind_type); -void in_clean_binds(void); -void in_debug_dump(void); - -const int *in_get_dev_binds(int dev_id); -const int *in_get_dev_def_binds(int dev_id); -const char *in_get_dev_name(int dev_id, int must_be_active, int skip_pfix); -const char *in_get_key_name(int dev_id, int keycode); - -#define in_set_config_int(dev_id, what, v) { \ - int val_ = v; \ - in_set_config(dev_id, what, &val_, sizeof(val_)); \ -} - -#endif /* INCLUDE_uXt8Z4R7EMpuEEtvSibXjNhKH3741VNc */ diff --git a/frontend/common/lprintf.h b/frontend/common/lprintf.h deleted file mode 100644 index 48b8d576..00000000 --- a/frontend/common/lprintf.h +++ /dev/null @@ -1,10 +0,0 @@ -#ifdef __cplusplus -extern "C" { -#endif - -extern void lprintf(const char *fmt, ...); - -#ifdef __cplusplus -} -#endif - diff --git a/frontend/common/menu.c b/frontend/common/menu.c deleted file mode 100644 index 3acab62c..00000000 --- a/frontend/common/menu.c +++ /dev/null @@ -1,1327 +0,0 @@ -/* - * (C) Gražvydas "notaz" Ignotas, 2006-2011 - * - * This work is licensed under the terms of any of these licenses - * (at your option): - * - GNU GPL, version 2 or later. - * - GNU LGPL, version 2.1 or later. - * See the COPYING file in the top-level directory. - */ - -#include -#include -#include -#include -#include -#include // savestate date - -#include "menu.h" -#include "fonts.h" -#include "readpng.h" -#include "lprintf.h" -#include "input.h" -#include "plat.h" -#include "posix.h" - -static char static_buff[64]; -static int menu_error_time = 0; -char menu_error_msg[64] = { 0, }; -void *g_menuscreen_ptr; -void *g_menubg_src_ptr; -void *g_menubg_ptr; - -#if !MSCREEN_SIZE_FIXED -int g_menuscreen_w; -int g_menuscreen_h; -#endif - -static unsigned char *menu_font_data = NULL; -static int menu_text_color = 0xffff; // default to white -static int menu_sel_color = -1; // disabled - -/* note: these might become non-constant in future */ -#if MENU_X2 -static const int me_mfont_w = 16, me_mfont_h = 20; -static const int me_sfont_w = 12, me_sfont_h = 20; -#else -static const int me_mfont_w = 8, me_mfont_h = 10; -static const int me_sfont_w = 6, me_sfont_h = 10; -#endif - -// draws text to current bbp16 screen -static void text_out16_(int x, int y, const char *text, int color) -{ - int i, lh, tr, tg, tb, len; - unsigned short *dest = (unsigned short *)g_menuscreen_ptr + x + y * g_menuscreen_w; - tr = (color & 0xf800) >> 8; - tg = (color & 0x07e0) >> 3; - tb = (color & 0x001f) << 3; - - if (text == (void *)1) - { - // selector symbol - text = ""; - len = 1; - } - else - { - const char *p; - for (p = text; *p != 0 && *p != '\n'; p++) - ; - len = p - text; - } - - lh = me_mfont_h; - if (y + lh > g_menuscreen_h) - lh = g_menuscreen_h - y; - - for (i = 0; i < len; i++) - { - unsigned char *src = menu_font_data + (unsigned int)text[i] * me_mfont_w * me_mfont_h / 2; - unsigned short *dst = dest; - int u, l; - - for (l = 0; l < lh; l++, dst += g_menuscreen_w - me_mfont_w) - { - for (u = me_mfont_w / 2; u > 0; u--, src++) - { - int c, r, g, b; - c = *src >> 4; - r = (*dst & 0xf800) >> 8; - g = (*dst & 0x07e0) >> 3; - b = (*dst & 0x001f) << 3; - r = (c^0xf)*r/15 + c*tr/15; - g = (c^0xf)*g/15 + c*tg/15; - b = (c^0xf)*b/15 + c*tb/15; - *dst++ = ((r<<8)&0xf800) | ((g<<3)&0x07e0) | (b>>3); - c = *src & 0xf; - r = (*dst & 0xf800) >> 8; - g = (*dst & 0x07e0) >> 3; - b = (*dst & 0x001f) << 3; - r = (c^0xf)*r/15 + c*tr/15; - g = (c^0xf)*g/15 + c*tg/15; - b = (c^0xf)*b/15 + c*tb/15; - *dst++ = ((r<<8)&0xf800) | ((g<<3)&0x07e0) | (b>>3); - } - } - dest += me_mfont_w; - } -} - -void text_out16(int x, int y, const char *texto, ...) -{ - va_list args; - char buffer[256]; - int maxw = (g_menuscreen_w - x) / me_mfont_w; - - if (maxw < 0) - return; - - va_start(args, texto); - vsnprintf(buffer, sizeof(buffer), texto, args); - va_end(args); - - if (maxw > sizeof(buffer) - 1) - maxw = sizeof(buffer) - 1; - buffer[maxw] = 0; - - text_out16_(x,y,buffer,menu_text_color); -} - -/* draws in 6x8 font, might multiply size by integer */ -static void smalltext_out16_(int x, int y, const char *texto, int color) -{ - unsigned char *src; - unsigned short *dst; - int multiplier = me_sfont_w / 6; - int i; - - for (i = 0;; i++, x += me_sfont_w) - { - unsigned char c = (unsigned char) texto[i]; - int h = 8; - - if (!c || c == '\n') - break; - - src = fontdata6x8[c]; - dst = (unsigned short *)g_menuscreen_ptr + x + y * g_menuscreen_w; - - while (h--) - { - int m, w2, h2; - for (h2 = multiplier; h2 > 0; h2--) - { - for (m = 0x20; m; m >>= 1) { - if (*src & m) - for (w2 = multiplier; w2 > 0; w2--) - *dst++ = color; - else - dst += multiplier; - } - - dst += g_menuscreen_w - me_sfont_w; - } - src++; - } - } -} - -static void smalltext_out16(int x, int y, const char *texto, int color) -{ - char buffer[128]; - int maxw = (g_menuscreen_w - x) / me_sfont_w; - - if (maxw < 0) - return; - - strncpy(buffer, texto, sizeof(buffer)); - if (maxw > sizeof(buffer) - 1) - maxw = sizeof(buffer) - 1; - buffer[maxw] = 0; - - smalltext_out16_(x, y, buffer, color); -} - -static void menu_draw_selection(int x, int y, int w) -{ - int i, h; - unsigned short *dst, *dest; - - text_out16_(x, y, (void *)1, (menu_sel_color < 0) ? menu_text_color : menu_sel_color); - - if (menu_sel_color < 0) return; // no selection hilight - - if (y > 0) y--; - dest = (unsigned short *)g_menuscreen_ptr + x + y * g_menuscreen_w + me_mfont_w * 2 - 2; - for (h = me_mfont_h + 1; h > 0; h--) - { - dst = dest; - for (i = w - (me_mfont_w * 2 - 2); i > 0; i--) - *dst++ = menu_sel_color; - dest += g_menuscreen_w; - } -} - -static int parse_hex_color(char *buff) -{ - char *endp = buff; - int t = (int) strtoul(buff, &endp, 16); - if (endp != buff) -#ifdef PSP - return ((t<<8)&0xf800) | ((t>>5)&0x07e0) | ((t>>19)&0x1f); -#else - return ((t>>8)&0xf800) | ((t>>5)&0x07e0) | ((t>>3)&0x1f); -#endif - return -1; -} - -static char tolower_simple(char c) -{ - if ('A' <= c && c <= 'Z') - c = c - 'A' + 'a'; - return c; -} - -void menu_init(void) -{ - int i, c, l; - unsigned char *fd, *fds; - char buff[256]; - FILE *f; - - if (menu_font_data != NULL) - free(menu_font_data); - - menu_font_data = calloc((MENU_X2 ? 256 * 320 : 128 * 160) / 2, 1); - if (menu_font_data == NULL) - return; - - // generate default 8x10 font from fontdata8x8 - for (c = 0, fd = menu_font_data; c < 256; c++) - { - for (l = 0; l < 8; l++) - { - unsigned char fd8x8 = fontdata8x8[c*8+l]; - if (fd8x8&0x80) *fd = 0xf0; - if (fd8x8&0x40) *fd |= 0x0f; fd++; - if (fd8x8&0x20) *fd = 0xf0; - if (fd8x8&0x10) *fd |= 0x0f; fd++; - if (fd8x8&0x08) *fd = 0xf0; - if (fd8x8&0x04) *fd |= 0x0f; fd++; - if (fd8x8&0x02) *fd = 0xf0; - if (fd8x8&0x01) *fd |= 0x0f; fd++; - } - fd += 8*2/2; // 2 empty lines - } - - if (MENU_X2) { - // expand default font - fds = menu_font_data + 128 * 160 / 2 - 4; - fd = menu_font_data + 256 * 320 / 2 - 1; - for (c = 255; c >= 0; c--) - { - for (l = 9; l >= 0; l--, fds -= 4) - { - for (i = 3; i >= 0; i--) { - int px = fds[i] & 0x0f; - *fd-- = px | (px << 4); - px = (fds[i] >> 4) & 0x0f; - *fd-- = px | (px << 4); - } - for (i = 3; i >= 0; i--) { - int px = fds[i] & 0x0f; - *fd-- = px | (px << 4); - px = (fds[i] >> 4) & 0x0f; - *fd-- = px | (px << 4); - } - } - } - } - - // load custom font and selector (stored as 1st symbol in font table) - emu_make_path(buff, "skin/font.png", sizeof(buff)); - readpng(menu_font_data, buff, READPNG_FONT, - MENU_X2 ? 256 : 128, MENU_X2 ? 320 : 160); - // default selector symbol is '>' - memcpy(menu_font_data, menu_font_data + ((int)'>') * me_mfont_w * me_mfont_h / 2, - me_mfont_w * me_mfont_h / 2); - emu_make_path(buff, "skin/selector.png", sizeof(buff)); - readpng(menu_font_data, buff, READPNG_SELECTOR, me_mfont_w, me_mfont_h); - - // load custom colors - emu_make_path(buff, "skin/skin.txt", sizeof(buff)); - f = fopen(buff, "r"); - if (f != NULL) - { - lprintf("found skin.txt\n"); - while (!feof(f)) - { - if (fgets(buff, sizeof(buff), f) == NULL) - break; - if (buff[0] == '#' || buff[0] == '/') continue; // comment - if (buff[0] == '\r' || buff[0] == '\n') continue; // empty line - if (strncmp(buff, "text_color=", 11) == 0) - { - int tmp = parse_hex_color(buff+11); - if (tmp >= 0) menu_text_color = tmp; - else lprintf("skin.txt: parse error for text_color\n"); - } - else if (strncmp(buff, "selection_color=", 16) == 0) - { - int tmp = parse_hex_color(buff+16); - if (tmp >= 0) menu_sel_color = tmp; - else lprintf("skin.txt: parse error for selection_color\n"); - } - else - lprintf("skin.txt: parse error: %s\n", buff); - } - fclose(f); - } - - // use user's locale for savestate date display - setlocale(LC_TIME, ""); -} - -static void menu_draw_begin(int need_bg) -{ - plat_video_menu_begin(); - if (need_bg) - memcpy(g_menuscreen_ptr, g_menubg_ptr, g_menuscreen_w * g_menuscreen_h * 2); -} - -static void menu_draw_end(void) -{ - plat_video_menu_end(); -} - -static void menu_darken_bg(void *dst, void *src, int pixels, int darker) -{ - unsigned int *dest = dst; - unsigned int *sorc = src; - pixels /= 2; - if (darker) - { - while (pixels--) - { - unsigned int p = *sorc++; - *dest++ = ((p&0xf79ef79e)>>1) - ((p&0xc618c618)>>3); - } - } - else - { - while (pixels--) - { - unsigned int p = *sorc++; - *dest++ = (p&0xf79ef79e)>>1; - } - } -} - -static int me_id2offset(const menu_entry *ent, menu_id id) -{ - int i; - for (i = 0; ent->name; ent++, i++) - if (ent->id == id) return i; - - lprintf("%s: id %i not found\n", __FUNCTION__, id); - return 0; -} - -static void me_enable(menu_entry *entries, menu_id id, int enable) -{ - int i = me_id2offset(entries, id); - entries[i].enabled = enable; -} - -static int me_count(const menu_entry *ent) -{ - int ret; - - for (ret = 0; ent->name; ent++, ret++) - ; - - return ret; -} - -static unsigned int me_read_onoff(const menu_entry *ent) -{ - // guess var size based on mask to avoid reading too much - if (ent->mask & 0xffff0000) - return *(unsigned int *)ent->var & ent->mask; - else if (ent->mask & 0xff00) - return *(unsigned short *)ent->var & ent->mask; - else - return *(unsigned char *)ent->var & ent->mask; -} - -static void me_toggle_onoff(menu_entry *ent) -{ - // guess var size based on mask to avoid reading too much - if (ent->mask & 0xffff0000) - *(unsigned int *)ent->var ^= ent->mask; - else if (ent->mask & 0xff00) - *(unsigned short *)ent->var ^= ent->mask; - else - *(unsigned char *)ent->var ^= ent->mask; -} - -static void me_draw(const menu_entry *entries, int sel, void (*draw_more)(void)) -{ - const menu_entry *ent, *ent_sel = entries; - int x, y, w = 0, h = 0; - int offs, col2_offs = 27 * me_mfont_w; - int vi_sel_ln = 0; - const char *name; - int i, n; - - /* calculate size of menu rect */ - for (ent = entries, i = n = 0; ent->name; ent++, i++) - { - int wt; - - if (!ent->enabled) - continue; - - if (i == sel) { - ent_sel = ent; - vi_sel_ln = n; - } - - name = NULL; - wt = strlen(ent->name) * me_mfont_w; - if (wt == 0 && ent->generate_name) - name = ent->generate_name(ent->id, &offs); - if (name != NULL) - wt = strlen(name) * me_mfont_w; - - if (ent->beh != MB_NONE) - { - if (wt > col2_offs) - col2_offs = wt + me_mfont_w; - wt = col2_offs; - - switch (ent->beh) { - case MB_NONE: - break; - case MB_OPT_ONOFF: - case MB_OPT_RANGE: - wt += me_mfont_w * 3; - break; - case MB_OPT_CUSTOM: - case MB_OPT_CUSTONOFF: - case MB_OPT_CUSTRANGE: - name = NULL; - offs = 0; - if (ent->generate_name != NULL) - name = ent->generate_name(ent->id, &offs); - if (name != NULL) - wt += (strlen(name) + offs) * me_mfont_w; - break; - case MB_OPT_ENUM: - wt += 10 * me_mfont_w; - break; - } - } - - if (wt > w) - w = wt; - n++; - } - h = n * me_mfont_h; - w += me_mfont_w * 2; /* selector */ - - if (w > g_menuscreen_w) { - lprintf("width %d > %d\n", w, g_menuscreen_w); - w = g_menuscreen_w; - } - if (h > g_menuscreen_h) { - lprintf("height %d > %d\n", w, g_menuscreen_h); - h = g_menuscreen_h; - } - - x = g_menuscreen_w / 2 - w / 2; - y = g_menuscreen_h / 2 - h / 2; -#ifdef MENU_ALIGN_LEFT - if (x > 12) x = 12; -#endif - - /* draw */ - menu_draw_begin(1); - menu_draw_selection(x, y + vi_sel_ln * me_mfont_h, w); - x += me_mfont_w * 2; - - for (ent = entries; ent->name; ent++) - { - const char **names; - int len, leftname_end = 0; - - if (!ent->enabled) - continue; - - name = ent->name; - if (strlen(name) == 0) { - if (ent->generate_name) - name = ent->generate_name(ent->id, &offs); - } - if (name != NULL) { - text_out16(x, y, name); - leftname_end = x + (strlen(name) + 1) * me_mfont_w; - } - - switch (ent->beh) { - case MB_NONE: - break; - case MB_OPT_ONOFF: - text_out16(x + col2_offs, y, me_read_onoff(ent) ? "ON" : "OFF"); - break; - case MB_OPT_RANGE: - text_out16(x + col2_offs, y, "%i", *(int *)ent->var); - break; - case MB_OPT_CUSTOM: - case MB_OPT_CUSTONOFF: - case MB_OPT_CUSTRANGE: - name = NULL; - offs = 0; - if (ent->generate_name) - name = ent->generate_name(ent->id, &offs); - if (name != NULL) - text_out16(x + col2_offs + offs * me_mfont_w, y, "%s", name); - break; - case MB_OPT_ENUM: - names = (const char **)ent->data; - for (i = 0; names[i] != NULL; i++) { - offs = x + col2_offs; - len = strlen(names[i]); - if (len > 10) - offs += (10 - len - 2) * me_mfont_w; - if (offs < leftname_end) - offs = leftname_end; - if (i == *(unsigned char *)ent->var) { - text_out16(offs, y, "%s", names[i]); - break; - } - } - break; - } - - y += me_mfont_h; - } - - /* display help or message if we have one */ - h = (g_menuscreen_h - h) / 2; // bottom area height - if (menu_error_msg[0] != 0) { - if (h >= me_mfont_h + 4) - text_out16(5, g_menuscreen_h - me_mfont_h - 4, menu_error_msg); - else - lprintf("menu msg doesn't fit!\n"); - - if (plat_get_ticks_ms() - menu_error_time > 2048) - menu_error_msg[0] = 0; - } - else if (ent_sel->help != NULL) { - const char *tmp = ent_sel->help; - int l; - for (l = 0; tmp != NULL && *tmp != 0; l++) - tmp = strchr(tmp + 1, '\n'); - if (h >= l * me_sfont_h + 4) - for (tmp = ent_sel->help; l > 0; l--, tmp = strchr(tmp, '\n') + 1) - smalltext_out16(5, g_menuscreen_h - (l * me_sfont_h + 4), tmp, 0xffff); - } - - if (draw_more != NULL) - draw_more(); - - menu_draw_end(); -} - -static int me_process(menu_entry *entry, int is_next, int is_lr) -{ - const char **names; - int c; - switch (entry->beh) - { - case MB_OPT_ONOFF: - case MB_OPT_CUSTONOFF: - me_toggle_onoff(entry); - return 1; - case MB_OPT_RANGE: - case MB_OPT_CUSTRANGE: - c = is_lr ? 10 : 1; - *(int *)entry->var += is_next ? c : -c; - if (*(int *)entry->var < (int)entry->min) - *(int *)entry->var = (int)entry->max; - if (*(int *)entry->var > (int)entry->max) - *(int *)entry->var = (int)entry->min; - return 1; - case MB_OPT_ENUM: - names = (const char **)entry->data; - for (c = 0; names[c] != NULL; c++) - ; - *(signed char *)entry->var += is_next ? 1 : -1; - if (*(signed char *)entry->var < 0) - *(signed char *)entry->var = 0; - if (*(signed char *)entry->var >= c) - *(signed char *)entry->var = c - 1; - return 1; - default: - return 0; - } -} - -static void debug_menu_loop(void); - -static int me_loop_d(menu_entry *menu, int *menu_sel, void (*draw_prep)(void), void (*draw_more)(void)) -{ - int ret = 0, inp, sel = *menu_sel, menu_sel_max; - - menu_sel_max = me_count(menu) - 1; - if (menu_sel_max < 0) { - lprintf("no enabled menu entries\n"); - return 0; - } - - while ((!menu[sel].enabled || !menu[sel].selectable) && sel < menu_sel_max) - sel++; - - /* make sure action buttons are not pressed on entering menu */ - me_draw(menu, sel, NULL); - while (in_menu_wait_any(NULL, 50) & (PBTN_MOK|PBTN_MBACK|PBTN_MENU)); - - for (;;) - { - if (draw_prep != NULL) - draw_prep(); - - me_draw(menu, sel, draw_more); - inp = in_menu_wait(PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT| - PBTN_MOK|PBTN_MBACK|PBTN_MENU|PBTN_L|PBTN_R, NULL, 70); - if (inp & (PBTN_MENU|PBTN_MBACK)) - break; - - if (inp & PBTN_UP ) { - do { - sel--; - if (sel < 0) - sel = menu_sel_max; - } - while (!menu[sel].enabled || !menu[sel].selectable); - } - if (inp & PBTN_DOWN) { - do { - sel++; - if (sel > menu_sel_max) - sel = 0; - } - while (!menu[sel].enabled || !menu[sel].selectable); - } - - /* a bit hacky but oh well */ - if ((inp & (PBTN_L|PBTN_R)) == (PBTN_L|PBTN_R)) - debug_menu_loop(); - - if (inp & (PBTN_LEFT|PBTN_RIGHT|PBTN_L|PBTN_R)) { /* multi choice */ - if (me_process(&menu[sel], (inp & (PBTN_RIGHT|PBTN_R)) ? 1 : 0, - inp & (PBTN_L|PBTN_R))) - continue; - } - - if (inp & (PBTN_MOK|PBTN_LEFT|PBTN_RIGHT|PBTN_L|PBTN_R)) - { - /* require PBTN_MOK for MB_NONE */ - if (menu[sel].handler != NULL && (menu[sel].beh != MB_NONE || (inp & PBTN_MOK))) { - ret = menu[sel].handler(menu[sel].id, inp); - if (ret) break; - menu_sel_max = me_count(menu) - 1; /* might change, so update */ - } - } - } - *menu_sel = sel; - - return ret; -} - -static int me_loop(menu_entry *menu, int *menu_sel) -{ - return me_loop_d(menu, menu_sel, NULL, NULL); -} - -/* ***************************************** */ - -static void draw_menu_message(const char *msg, void (*draw_more)(void)) -{ - int x, y, h, w, wt; - const char *p; - - p = msg; - for (h = 1, w = 0; *p != 0; h++) { - for (wt = 0; *p != 0 && *p != '\n'; p++) - wt++; - - if (wt > w) - w = wt; - if (*p == 0) - break; - p++; - } - - x = g_menuscreen_w / 2 - w * me_mfont_w / 2; - y = g_menuscreen_h / 2 - h * me_mfont_h / 2; - if (x < 0) x = 0; - if (y < 0) y = 0; - - menu_draw_begin(1); - - for (p = msg; *p != 0 && y <= g_menuscreen_h - me_mfont_h; y += me_mfont_h) { - text_out16(x, y, p); - - for (; *p != 0 && *p != '\n'; p++) - ; - if (*p != 0) - p++; - } - - if (draw_more != NULL) - draw_more(); - - menu_draw_end(); -} - -// -------------- del confirm --------------- - -static void do_delete(const char *fpath, const char *fname) -{ - int len, mid, inp; - const char *nm; - char tmp[64]; - - menu_draw_begin(1); - - len = strlen(fname); - if (len > g_menuscreen_w / me_sfont_w) - len = g_menuscreen_w / me_sfont_w; - - mid = g_menuscreen_w / 2; - text_out16(mid - me_mfont_w * 15 / 2, 8 * me_mfont_h, "About to delete"); - smalltext_out16(mid - len * me_sfont_w / 2, 9 * me_mfont_h + 5, fname, 0xbdff); - text_out16(mid - me_mfont_w * 13 / 2, 11 * me_mfont_h, "Are you sure?"); - - nm = in_get_key_name(-1, -PBTN_MA3); - snprintf(tmp, sizeof(tmp), "(%s - confirm, ", nm); - len = strlen(tmp); - nm = in_get_key_name(-1, -PBTN_MBACK); - snprintf(tmp + len, sizeof(tmp) - len, "%s - cancel)", nm); - len = strlen(tmp); - - text_out16(mid - me_mfont_w * len / 2, 12 * me_mfont_h, tmp); - menu_draw_end(); - - while (in_menu_wait_any(NULL, 50) & (PBTN_MENU|PBTN_MA2)); - inp = in_menu_wait(PBTN_MA3|PBTN_MBACK, NULL, 100); - if (inp & PBTN_MA3) - remove(fpath); -} - -// -------------- ROM selector -------------- - -static void draw_dirlist(char *curdir, struct dirent **namelist, int n, int sel) -{ - int max_cnt, start, i, x, pos; - void *darken_ptr; - - max_cnt = g_menuscreen_h / me_sfont_h; - start = max_cnt / 2 - sel; - n--; // exclude current dir (".") - - menu_draw_begin(1); - -// if (!rom_loaded) -// menu_darken_bg(gp2x_screen, 320*240, 0); - - darken_ptr = (short *)g_menuscreen_ptr + g_menuscreen_w * max_cnt/2 * me_sfont_h; - menu_darken_bg(darken_ptr, darken_ptr, g_menuscreen_w * me_sfont_h * 8 / 10, 0); - - x = 5 + me_mfont_w + 1; - if (start - 2 >= 0) - smalltext_out16(14, (start - 2) * me_sfont_h, curdir, 0xffff); - for (i = 0; i < n; i++) { - pos = start + i; - if (pos < 0) continue; - if (pos >= max_cnt) break; - if (namelist[i+1]->d_type == DT_DIR) { - smalltext_out16(x, pos * me_sfont_h, "/", 0xfff6); - smalltext_out16(x + me_sfont_w, pos * me_sfont_h, namelist[i+1]->d_name, 0xfff6); - } else { - unsigned short color = fname2color(namelist[i+1]->d_name); - smalltext_out16(x, pos * me_sfont_h, namelist[i+1]->d_name, color); - } - } - smalltext_out16(5, max_cnt/2 * me_sfont_h, ">", 0xffff); - menu_draw_end(); -} - -static int scandir_cmp(const void *p1, const void *p2) -{ - const struct dirent **d1 = (const struct dirent **)p1; - const struct dirent **d2 = (const struct dirent **)p2; - if ((*d1)->d_type == (*d2)->d_type) - return alphasort(d1, d2); - if ((*d1)->d_type == DT_DIR) - return -1; // put before - if ((*d2)->d_type == DT_DIR) - return 1; - - return alphasort(d1, d2); -} - -static int scandir_filter(const struct dirent *ent) -{ - const char *p; - int i; - - if (ent == NULL || ent->d_name == NULL) return 0; - if (strlen(ent->d_name) < 5) return 1; - - p = ent->d_name + strlen(ent->d_name) - 4; - - for (i = 0; i < array_size(filter_exts); i++) - if (strcmp(p, filter_exts[i]) == 0) - return 0; - - return 1; -} - -static int dirent_seek_char(struct dirent **namelist, int len, int sel, char c) -{ - int i; - - sel++; - for (i = sel + 1; i != sel; i++) { - if (i >= len) - i = 1; - - if (tolower_simple(namelist[i]->d_name[0]) == c) - break; - } - - return i - 1; -} - -static char *menu_loop_romsel(char *curr_path, int len) -{ - struct dirent **namelist; - int n, inp, sel = 0; - char *ret = NULL, *fname = NULL; - char cinp; - -rescan: - // is this a dir or a full path? - if (!plat_is_dir(curr_path)) { - char *p = curr_path + strlen(curr_path) - 1; - for (; p > curr_path && *p != '/'; p--) - ; - *p = 0; - fname = p+1; - } - - n = scandir(curr_path, &namelist, scandir_filter, (void *)scandir_cmp); - if (n < 0) { - char *t; - lprintf("menu_loop_romsel failed, dir: %s\n", curr_path); - - // try root - t = getcwd(curr_path, len); - if (t == NULL) - plat_get_root_dir(curr_path, len); - n = scandir(curr_path, &namelist, scandir_filter, (void *)scandir_cmp); - if (n < 0) { - // oops, we failed - lprintf("menu_loop_romsel failed, dir: %s\n", curr_path); - return NULL; - } - } - - // try to find sel - // note: we don't show '.' so sel is namelist index - 1 - if (fname != NULL) { - int i; - for (i = 1; i < n; i++) { - char *dname = namelist[i]->d_name; - if (dname[0] == fname[0] && strcmp(dname, fname) == 0) { - sel = i - 1; - break; - } - } - } - - /* make sure action buttons are not pressed on entering menu */ - draw_dirlist(curr_path, namelist, n, sel); - while (in_menu_wait_any(NULL, 50) & (PBTN_MOK|PBTN_MBACK|PBTN_MENU)) - ; - - for (;;) - { - draw_dirlist(curr_path, namelist, n, sel); - inp = in_menu_wait(PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT| - PBTN_L|PBTN_R|PBTN_MA2|PBTN_MOK|PBTN_MBACK|PBTN_MENU|PBTN_CHAR, &cinp, 33); - if (inp & PBTN_UP ) { sel--; if (sel < 0) sel = n-2; } - if (inp & PBTN_DOWN) { sel++; if (sel > n-2) sel = 0; } - if (inp & PBTN_LEFT) { sel-=10; if (sel < 0) sel = 0; } - if (inp & PBTN_L) { sel-=24; if (sel < 0) sel = 0; } - if (inp & PBTN_RIGHT) { sel+=10; if (sel > n-2) sel = n-2; } - if (inp & PBTN_R) { sel+=24; if (sel > n-2) sel = n-2; } - if (inp & PBTN_CHAR) sel = dirent_seek_char(namelist, n, sel, cinp); - if ((inp & PBTN_MOK) || (inp & (PBTN_MENU|PBTN_MA2)) == (PBTN_MENU|PBTN_MA2)) - { - again: - if (namelist[sel+1]->d_type == DT_REG) - { - strcpy(rom_fname_reload, curr_path); - strcat(rom_fname_reload, "/"); - strcat(rom_fname_reload, namelist[sel+1]->d_name); - if (inp & PBTN_MOK) { // return sel - ret = rom_fname_reload; - break; - } - do_delete(rom_fname_reload, namelist[sel+1]->d_name); - if (n > 0) { - while (n--) free(namelist[n]); - free(namelist); - } - goto rescan; - } - else if (namelist[sel+1]->d_type == DT_DIR) - { - int newlen; - char *p, *newdir; - if (!(inp & PBTN_MOK)) - continue; - newlen = strlen(curr_path) + strlen(namelist[sel+1]->d_name) + 2; - newdir = malloc(newlen); - if (newdir == NULL) - break; - if (strcmp(namelist[sel+1]->d_name, "..") == 0) { - char *start = curr_path; - p = start + strlen(start) - 1; - while (*p == '/' && p > start) p--; - while (*p != '/' && p > start) p--; - if (p <= start) strcpy(newdir, "/"); - else { strncpy(newdir, start, p-start); newdir[p-start] = 0; } - } else { - strcpy(newdir, curr_path); - p = newdir + strlen(newdir) - 1; - while (*p == '/' && p >= newdir) *p-- = 0; - strcat(newdir, "/"); - strcat(newdir, namelist[sel+1]->d_name); - } - ret = menu_loop_romsel(newdir, newlen); - free(newdir); - break; - } - else - { - // unknown file type, happens on NTFS mounts. Try to guess. - FILE *tstf; int tmp; - strcpy(rom_fname_reload, curr_path); - strcat(rom_fname_reload, "/"); - strcat(rom_fname_reload, namelist[sel+1]->d_name); - tstf = fopen(rom_fname_reload, "rb"); - if (tstf != NULL) - { - if (fread(&tmp, 1, 1, tstf) > 0 || ferror(tstf) == 0) - namelist[sel+1]->d_type = DT_REG; - else namelist[sel+1]->d_type = DT_DIR; - fclose(tstf); - goto again; - } - } - } - if (inp & PBTN_MBACK) - break; - } - - if (n > 0) { - while (n--) free(namelist[n]); - free(namelist); - } - - // restore curr_path - if (fname != NULL) { - n = strlen(curr_path); - if (curr_path + n + 1 == fname) - curr_path[n] = '/'; - } - - return ret; -} - -// ------------ savestate loader ------------ - -#define STATE_SLOT_COUNT 10 - -static int state_slot_flags = 0; -static int state_slot_times[STATE_SLOT_COUNT]; - -static void state_check_slots(void) -{ - int slot; - - state_slot_flags = 0; - - for (slot = 0; slot < STATE_SLOT_COUNT; slot++) { - state_slot_times[slot] = 0; - if (emu_check_save_file(slot, &state_slot_times[slot])) - state_slot_flags |= 1 << slot; - } -} - -static void draw_savestate_bg(int slot); - -static void draw_savestate_menu(int menu_sel, int is_loading) -{ - int i, x, y, w, h; - char time_buf[32]; - - if (state_slot_flags & (1 << menu_sel)) - draw_savestate_bg(menu_sel); - - w = (13 + 2) * me_mfont_w; - h = (1+2+STATE_SLOT_COUNT+1) * me_mfont_h; - x = g_menuscreen_w / 2 - w / 2; - if (x < 0) x = 0; - y = g_menuscreen_h / 2 - h / 2; - if (y < 0) y = 0; -#ifdef MENU_ALIGN_LEFT - if (x > 12 + me_mfont_w * 2) - x = 12 + me_mfont_w * 2; -#endif - - menu_draw_begin(1); - - text_out16(x, y, is_loading ? "Load state" : "Save state"); - y += 3 * me_mfont_h; - - menu_draw_selection(x - me_mfont_w * 2, y + menu_sel * me_mfont_h, (23 + 2) * me_mfont_w + 4); - - /* draw all slots */ - for (i = 0; i < STATE_SLOT_COUNT; i++, y += me_mfont_h) - { - if (!(state_slot_flags & (1 << i))) - strcpy(time_buf, "free"); - else { - strcpy(time_buf, "USED"); - if (state_slot_times[i] != 0) { - time_t time = state_slot_times[i]; - struct tm *t = localtime(&time); - strftime(time_buf, sizeof(time_buf), "%x %R", t); - } - } - - text_out16(x, y, "SLOT %i (%s)", i, time_buf); - } - text_out16(x, y, "back"); - - menu_draw_end(); -} - -static int menu_loop_savestate(int is_loading) -{ - static int menu_sel = STATE_SLOT_COUNT; - int menu_sel_max = STATE_SLOT_COUNT; - unsigned long inp = 0; - int ret = 0; - - state_check_slots(); - - if (!(state_slot_flags & (1 << menu_sel)) && is_loading) - menu_sel = menu_sel_max; - - for (;;) - { - draw_savestate_menu(menu_sel, is_loading); - inp = in_menu_wait(PBTN_UP|PBTN_DOWN|PBTN_MOK|PBTN_MBACK, NULL, 100); - if (inp & PBTN_UP) { - do { - menu_sel--; - if (menu_sel < 0) - menu_sel = menu_sel_max; - } while (!(state_slot_flags & (1 << menu_sel)) && menu_sel != menu_sel_max && is_loading); - } - if (inp & PBTN_DOWN) { - do { - menu_sel++; - if (menu_sel > menu_sel_max) - menu_sel = 0; - } while (!(state_slot_flags & (1 << menu_sel)) && menu_sel != menu_sel_max && is_loading); - } - if (inp & PBTN_MOK) { // save/load - if (menu_sel < STATE_SLOT_COUNT) { - state_slot = menu_sel; - if (emu_save_load_game(is_loading, 0)) { - me_update_msg(is_loading ? "Load failed" : "Save failed"); - break; - } - ret = 1; - break; - } - break; - } - if (inp & PBTN_MBACK) - break; - } - - return ret; -} - -// -------------- key config -------------- - -static char *action_binds(int player_idx, int action_mask, int dev_id) -{ - int dev = 0, dev_last = IN_MAX_DEVS - 1; - int can_combo = 1, type; - - static_buff[0] = 0; - - type = IN_BINDTYPE_EMU; - if (player_idx >= 0) { - can_combo = 0; - type = IN_BINDTYPE_PLAYER12; - } - if (player_idx == 1) - action_mask <<= 16; - - if (dev_id >= 0) - dev = dev_last = dev_id; - - for (; dev <= dev_last; dev++) { - int k, count = 0, combo = 0; - const int *binds; - - binds = in_get_dev_binds(dev); - if (binds == NULL) - continue; - - in_get_config(dev, IN_CFG_BIND_COUNT, &count); - in_get_config(dev, IN_CFG_DOES_COMBOS, &combo); - combo = combo && can_combo; - - for (k = 0; k < count; k++) { - const char *xname; - int len; - - if (!(binds[IN_BIND_OFFS(k, type)] & action_mask)) - continue; - - xname = in_get_key_name(dev, k); - len = strlen(static_buff); - if (len) { - strncat(static_buff, combo ? " + " : ", ", - sizeof(static_buff) - len - 1); - len += combo ? 3 : 2; - } - strncat(static_buff, xname, sizeof(static_buff) - len - 1); - } - } - - return static_buff; -} - -static int count_bound_keys(int dev_id, int action_mask, int bindtype) -{ - const int *binds; - int k, keys = 0; - int count = 0; - - binds = in_get_dev_binds(dev_id); - if (binds == NULL) - return 0; - - in_get_config(dev_id, IN_CFG_BIND_COUNT, &count); - for (k = 0; k < count; k++) - { - if (binds[IN_BIND_OFFS(k, bindtype)] & action_mask) - keys++; - } - - return keys; -} - -static void draw_key_config(const me_bind_action *opts, int opt_cnt, int player_idx, - int sel, int dev_id, int dev_count, int is_bind) -{ - char buff[64], buff2[32]; - const char *dev_name; - int x, y, w, i; - - w = ((player_idx >= 0) ? 20 : 30) * me_mfont_w; - x = g_menuscreen_w / 2 - w / 2; - y = (g_menuscreen_h - 4 * me_mfont_h) / 2 - (2 + opt_cnt) * me_mfont_h / 2; - if (x < me_mfont_w * 2) - x = me_mfont_w * 2; - - menu_draw_begin(1); - if (player_idx >= 0) - text_out16(x, y, "Player %i controls", player_idx + 1); - else - text_out16(x, y, "Emulator controls"); - - y += 2 * me_mfont_h; - menu_draw_selection(x - me_mfont_w * 2, y + sel * me_mfont_h, w + 2 * me_mfont_w); - - for (i = 0; i < opt_cnt; i++, y += me_mfont_h) - text_out16(x, y, "%s : %s", opts[i].name, - action_binds(player_idx, opts[i].mask, dev_id)); - - if (dev_id < 0) - dev_name = "(all devices)"; - else - dev_name = in_get_dev_name(dev_id, 1, 1); - w = strlen(dev_name) * me_mfont_w; - if (w < 30 * me_mfont_w) - w = 30 * me_mfont_w; - if (w > g_menuscreen_w) - w = g_menuscreen_w; - - x = g_menuscreen_w / 2 - w / 2; - - if (!is_bind) { - snprintf(buff2, sizeof(buff2), "%s", in_get_key_name(-1, -PBTN_MOK)); - snprintf(buff, sizeof(buff), "%s - bind, %s - clear", buff2, - in_get_key_name(-1, -PBTN_MA2)); - text_out16(x, g_menuscreen_h - 4 * me_mfont_h, buff); - } - else - text_out16(x, g_menuscreen_h - 4 * me_mfont_h, "Press a button to bind/unbind"); - - if (dev_count > 1) { - text_out16(x, g_menuscreen_h - 3 * me_mfont_h, dev_name); - text_out16(x, g_menuscreen_h - 2 * me_mfont_h, "Press left/right for other devs"); - } - - menu_draw_end(); -} - -static void key_config_loop(const me_bind_action *opts, int opt_cnt, int player_idx) -{ - int i, sel = 0, menu_sel_max = opt_cnt - 1, does_combos = 0; - int dev_id, bind_dev_id, dev_count, kc, is_down, mkey; - int unbind, bindtype, mask_shift; - - for (i = 0, dev_id = -1, dev_count = 0; i < IN_MAX_DEVS; i++) { - if (in_get_dev_name(i, 1, 0) != NULL) { - dev_count++; - if (dev_id < 0) - dev_id = i; - } - } - - if (dev_id == -1) { - lprintf("no devs, can't do config\n"); - return; - } - - dev_id = -1; // show all - mask_shift = 0; - if (player_idx == 1) - mask_shift = 16; - bindtype = player_idx >= 0 ? IN_BINDTYPE_PLAYER12 : IN_BINDTYPE_EMU; - - for (;;) - { - draw_key_config(opts, opt_cnt, player_idx, sel, dev_id, dev_count, 0); - mkey = in_menu_wait(PBTN_UP|PBTN_DOWN|PBTN_LEFT|PBTN_RIGHT - |PBTN_MBACK|PBTN_MOK|PBTN_MA2, NULL, 100); - switch (mkey) { - case PBTN_UP: sel--; if (sel < 0) sel = menu_sel_max; continue; - case PBTN_DOWN: sel++; if (sel > menu_sel_max) sel = 0; continue; - case PBTN_LEFT: - for (i = 0, dev_id--; i < IN_MAX_DEVS + 1; i++, dev_id--) { - if (dev_id < -1) - dev_id = IN_MAX_DEVS - 1; - if (dev_id == -1 || in_get_dev_name(dev_id, 1, 0) != NULL) - break; - } - continue; - case PBTN_RIGHT: - for (i = 0, dev_id++; i < IN_MAX_DEVS; i++, dev_id++) { - if (dev_id >= IN_MAX_DEVS) - dev_id = -1; - if (dev_id == -1 || in_get_dev_name(dev_id, 1, 0) != NULL) - break; - } - continue; - case PBTN_MBACK: - return; - case PBTN_MOK: - if (sel >= opt_cnt) - return; - while (in_menu_wait_any(NULL, 30) & PBTN_MOK) - ; - break; - case PBTN_MA2: - in_unbind_all(dev_id, opts[sel].mask << mask_shift, bindtype); - continue; - default:continue; - } - - draw_key_config(opts, opt_cnt, player_idx, sel, dev_id, dev_count, 1); - - /* wait for some up event */ - for (is_down = 1; is_down; ) - kc = in_update_keycode(&bind_dev_id, &is_down, NULL, -1); - - i = count_bound_keys(bind_dev_id, opts[sel].mask << mask_shift, bindtype); - unbind = (i > 0); - - /* allow combos if device supports them */ - in_get_config(bind_dev_id, IN_CFG_DOES_COMBOS, &does_combos); - if (i == 1 && bindtype == IN_BINDTYPE_EMU && does_combos) - unbind = 0; - - if (unbind) - in_unbind_all(bind_dev_id, opts[sel].mask << mask_shift, bindtype); - - in_bind_key(bind_dev_id, kc, opts[sel].mask << mask_shift, bindtype, 0); - } -} - diff --git a/frontend/common/menu.h b/frontend/common/menu.h deleted file mode 100644 index 79b82783..00000000 --- a/frontend/common/menu.h +++ /dev/null @@ -1,132 +0,0 @@ -/* - * (C) Gražvydas "notaz" Ignotas, 2006-2010 - * - * This work is licensed under the terms of any of these licenses - * (at your option): - * - GNU GPL, version 2 or later. - * - GNU LGPL, version 2.1 or later. - * See the COPYING file in the top-level directory. - */ - -typedef enum -{ - MB_NONE = 1, /* no auto processing */ - MB_OPT_ONOFF, /* ON/OFF setting */ - MB_OPT_RANGE, /* [min-max] setting */ - MB_OPT_CUSTOM, /* custom value */ - MB_OPT_CUSTONOFF, - MB_OPT_CUSTRANGE, - MB_OPT_ENUM, -} menu_behavior; - -typedef struct -{ - const char *name; - menu_behavior beh; - int id; - void *var; /* for on-off/range settings */ - int mask; /* bit to toggle for on/off */ - signed short min; /* for ranged integer settings, to be sign-extended */ - signed short max; - unsigned int enabled:1; - unsigned int need_to_save:1; - unsigned int selectable:1; - int (*handler)(int id, int keys); - const char * (*generate_name)(int id, int *offs); - const void *data; - const char *help; -} menu_entry; - -#define mee_handler_id_h(name, id, handler, help) \ - { name, MB_NONE, id, NULL, 0, 0, 0, 1, 0, 1, handler, NULL, NULL, help } - -#define mee_handler_id(name, id, handler) \ - mee_handler_id_h(name, id, handler, NULL) - -#define mee_handler(name, handler) \ - mee_handler_id(name, MA_NONE, handler) - -#define mee_handler_h(name, handler, help) \ - mee_handler_id_h(name, MA_NONE, handler, help) - -#define mee_label(name) \ - { name, MB_NONE, MA_NONE, NULL, 0, 0, 0, 1, 0, 0, NULL, NULL, NULL, NULL } - -#define mee_label_mk(id, name_func) \ - { "", MB_NONE, id, NULL, 0, 0, 0, 1, 0, 0, NULL, name_func, NULL, NULL } - -#define mee_onoff_h(name, id, var, mask, help) \ - { name, MB_OPT_ONOFF, id, &(var), mask, 0, 0, 1, 1, 1, NULL, NULL, NULL, help } - -#define mee_onoff(name, id, var, mask) \ - mee_onoff_h(name, id, var, mask, NULL) - -#define mee_range_h(name, id, var, min, max, help) \ - { name, MB_OPT_RANGE, id, &(var), 0, min, max, 1, 1, 1, NULL, NULL, NULL, help } - -#define mee_range(name, id, var, min, max) \ - mee_range_h(name, id, var, min, max, NULL) - -#define mee_range_hide(name, id, var, min, max) \ - { name, MB_OPT_RANGE, id, &(var), 0, min, max, 0, 1, 0, NULL, NULL, NULL, NULL } - -#define mee_cust_s_h(name, id, need_save, handler, name_func, help) \ - { name, MB_OPT_CUSTOM, id, NULL, 0, 0, 0, 1, need_save, 1, handler, name_func, NULL, help } - -#define mee_cust_h(name, id, handler, name_func, help) \ - mee_cust_s_h(name, id, 1, handler, name_func, help) - -#define mee_cust(name, id, handler, name_func) \ - mee_cust_h(name, id, handler, name_func, NULL) - -#define mee_cust_nosave(name, id, handler, name_func) \ - mee_cust_s_h(name, id, 0, handler, name_func, NULL) - -#define mee_onoff_cust(name, id, var, mask, name_func) \ - { name, MB_OPT_CUSTONOFF, id, &(var), mask, 0, 0, 1, 1, 1, NULL, name_func, NULL, NULL } - -#define mee_range_cust(name, id, var, min, max, name_func) \ - { name, MB_OPT_CUSTRANGE, id, &(var), 0, min, max, 1, 1, 1, NULL, name_func, NULL, NULL } - -#define mee_enum_h(name, id, var, names_list, help) \ - { name, MB_OPT_ENUM, id, &(var), 0, 0, 0, 1, 1, 1, NULL, NULL, names_list, help } - -#define mee_enum(name, id, var, names_list) \ - mee_enum_h(name, id, var, names_list, NULL) - -#define mee_end \ - { NULL, 0, 0, NULL, 0, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL } - -typedef struct -{ - char *name; - int mask; -} me_bind_action; - -extern me_bind_action me_ctrl_actions[]; -extern me_bind_action emuctrl_actions[]; // platform code - -extern void *g_menubg_src_ptr; -extern void *g_menubg_ptr; -extern void *g_menuscreen_ptr; -#if MSCREEN_SIZE_FIXED -#define g_menuscreen_w MSCREEN_WIDTH -#define g_menuscreen_h MSCREEN_HEIGHT -#else -extern int g_menuscreen_w; -extern int g_menuscreen_h; -#endif - -void menu_init(void); -void text_out16(int x, int y, const char *texto, ...); -void me_update_msg(const char *msg); - -void menu_romload_prepare(const char *rom_name); -void menu_romload_end(void); - -void menu_loop(void); -int menu_loop_tray(void); - -menu_entry *me_list_get_first(void); -menu_entry *me_list_get_next(void); - diff --git a/frontend/common/plat.h b/frontend/common/plat.h deleted file mode 100644 index 1fb87676..00000000 --- a/frontend/common/plat.h +++ /dev/null @@ -1,62 +0,0 @@ -#ifdef __cplusplus -extern "C" { -#endif - -/* stuff to be implemented by platform code */ -extern const char *renderer_names[]; -extern const char *renderer_names32x[]; - -void pemu_prep_defconfig(void); -void pemu_validate_config(void); -void pemu_loop_prep(void); -void pemu_loop_end(void); -void pemu_forced_frame(int no_scale, int do_emu); // ..to g_menubg_src_ptr -void pemu_finalize_frame(const char *fps, const char *notice_msg); - -void pemu_sound_start(void); -void pemu_sound_stop(void); -void pemu_sound_wait(void); - -void plat_early_init(void); -void plat_init(void); -void plat_finish(void); - -/* return the dir/ where configs, saves, bios, etc. are found */ -int plat_get_root_dir(char *dst, int len); - -/* used before things blocking for a while (these funcs redraw on return) */ -void plat_status_msg_busy_first(const char *msg); -void plat_status_msg_busy_next(const char *msg); -void plat_status_msg_clear(void); - -/* menu: enter (switch bpp, etc), begin/end drawing */ -void plat_video_menu_enter(int is_rom_loaded); -void plat_video_menu_begin(void); -void plat_video_menu_end(void); -void plat_video_menu_leave(void); - -void plat_video_flip(void); -void plat_video_wait_vsync(void); -void plat_video_toggle_renderer(int change, int menu_call); - -void plat_update_volume(int has_changed, int is_up); - -int plat_is_dir(const char *path); -int plat_wait_event(int *fds_hnds, int count, int timeout_ms); -void plat_sleep_ms(int ms); - -void *plat_mmap(unsigned long addr, size_t size, int need_exec, int is_fixed); -void *plat_mremap(void *ptr, size_t oldsize, size_t newsize); -void plat_munmap(void *ptr, size_t size); - -/* timers, to be used for time diff and must refer to the same clock */ -unsigned int plat_get_ticks_ms(void); -unsigned int plat_get_ticks_us(void); -void plat_wait_till_us(unsigned int us); - -void plat_debug_cat(char *str); - -#ifdef __cplusplus -} // extern "C" -#endif - diff --git a/frontend/common/posix.h b/frontend/common/posix.h deleted file mode 100644 index 33ca96cc..00000000 --- a/frontend/common/posix.h +++ /dev/null @@ -1,23 +0,0 @@ -/* define POSIX stuff: dirent, scandir, getcwd, mkdir */ -#if defined(__linux__) || defined(__MINGW32__) - -#include -#include -#include -#include - -#ifdef __MINGW32__ -#warning hacks! -#define mkdir(pathname,mode) mkdir(pathname) -#define d_type d_ino -#define DT_REG 0 -#define DT_DIR 0 -#endif - -#else - -#error "must provide posix" - -#endif - - diff --git a/frontend/common/readpng.c b/frontend/common/readpng.c deleted file mode 100644 index 722dc26e..00000000 --- a/frontend/common/readpng.c +++ /dev/null @@ -1,266 +0,0 @@ -/* - * (C) Gražvydas "notaz" Ignotas, 2008-2011 - * - * This work is licensed under the terms of any of these licenses - * (at your option): - * - GNU GPL, version 2 or later. - * - GNU LGPL, version 2.1 or later. - * See the COPYING file in the top-level directory. - */ - -#include -#include -#include -#include -#include "readpng.h" -#include "lprintf.h" - -int readpng(void *dest, const char *fname, readpng_what what, int req_w, int req_h) -{ - FILE *fp; - png_structp png_ptr = NULL; - png_infop info_ptr = NULL; - png_bytepp row_ptr = NULL; - int ret = -1; - - if (dest == NULL || fname == NULL) - { - return -1; - } - - fp = fopen(fname, "rb"); - if (fp == NULL) - { - lprintf(__FILE__ ": failed to open: %s\n", fname); - return -1; - } - - png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); - if (!png_ptr) - { - lprintf(__FILE__ ": png_create_read_struct() failed\n"); - fclose(fp); - return -1; - } - - info_ptr = png_create_info_struct(png_ptr); - if (!info_ptr) - { - lprintf(__FILE__ ": png_create_info_struct() failed\n"); - goto done; - } - - // Start reading - png_init_io(png_ptr, fp); - png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_STRIP_16 | PNG_TRANSFORM_STRIP_ALPHA | PNG_TRANSFORM_PACKING, NULL); - row_ptr = png_get_rows(png_ptr, info_ptr); - if (row_ptr == NULL) - { - lprintf(__FILE__ ": png_get_rows() failed\n"); - goto done; - } - - // lprintf("%s: %ix%i @ %ibpp\n", fname, (int)png_get_image_width(png_ptr, info_ptr), (int)png_get_image_height(png_ptr, info_ptr), png_get_bit_depth(png_ptr, info_ptr)); - - switch (what) - { - case READPNG_BG: - { - int height, width, h; - unsigned short *dst = dest; - if (png_get_bit_depth(png_ptr, info_ptr) != 8) - { - lprintf(__FILE__ ": bg image uses %ibpc, needed 8bpc\n", png_get_bit_depth(png_ptr, info_ptr)); - break; - } - width = png_get_image_width(png_ptr, info_ptr); - if (width > req_w) - width = req_w; - height = png_get_image_height(png_ptr, info_ptr); - if (height > req_h) - height = req_h; - - for (h = 0; h < height; h++) - { - unsigned char *src = row_ptr[h]; - int len = width; - while (len--) - { -#ifdef PSP - *dst++ = ((src[2]&0xf8)<<8) | ((src[1]&0xf8)<<3) | (src[0] >> 3); // BGR -#else - *dst++ = ((src[0]&0xf8)<<8) | ((src[1]&0xf8)<<3) | (src[2] >> 3); // RGB -#endif - src += 3; - } - dst += req_w - width; - } - break; - } - - case READPNG_FONT: - { - int x, y, x1, y1; - unsigned char *dst = dest; - if (png_get_image_width(png_ptr, info_ptr) != req_w || png_get_image_height(png_ptr, info_ptr) != req_h) - { - lprintf(__FILE__ ": unexpected font image size %dx%d, needed %dx%d\n", - (int)png_get_image_width(png_ptr, info_ptr), (int)png_get_image_height(png_ptr, info_ptr), req_w, req_h); - break; - } - if (png_get_bit_depth(png_ptr, info_ptr) != 8) - { - lprintf(__FILE__ ": font image uses %ibpp, needed 8bpp\n", png_get_bit_depth(png_ptr, info_ptr)); - break; - } - for (y = 0; y < 16; y++) - { - for (x = 0; x < 16; x++) - { - /* 16x16 grid of syms */ - int sym_w = req_w / 16; - int sym_h = req_h / 16; - for (y1 = 0; y1 < sym_h; y1++) - { - unsigned char *src = row_ptr[y*sym_h + y1] + x*sym_w; - for (x1 = sym_w/2; x1 > 0; x1--, src+=2) - *dst++ = ((src[0]^0xff) & 0xf0) | ((src[1]^0xff) >> 4); - } - } - } - break; - } - - case READPNG_SELECTOR: - { - int x1, y1; - unsigned char *dst = dest; - if (png_get_image_width(png_ptr, info_ptr) != req_w || png_get_image_height(png_ptr, info_ptr) != req_h) - { - lprintf(__FILE__ ": unexpected selector image size %ix%i, needed %dx%d\n", - (int)png_get_image_width(png_ptr, info_ptr), (int)png_get_image_height(png_ptr, info_ptr), req_w, req_h); - break; - } - if (png_get_bit_depth(png_ptr, info_ptr) != 8) - { - lprintf(__FILE__ ": selector image uses %ibpp, needed 8bpp\n", png_get_bit_depth(png_ptr, info_ptr)); - break; - } - for (y1 = 0; y1 < req_h; y1++) - { - unsigned char *src = row_ptr[y1]; - for (x1 = req_w/2; x1 > 0; x1--, src+=2) - *dst++ = ((src[0]^0xff) & 0xf0) | ((src[1]^0xff) >> 4); - } - break; - } - - case READPNG_24: - { - int height, width, h; - unsigned char *dst = dest; - if (png_get_bit_depth(png_ptr, info_ptr) != 8) - { - lprintf(__FILE__ ": image uses %ibpc, needed 8bpc\n", png_get_bit_depth(png_ptr, info_ptr)); - break; - } - width = png_get_image_width(png_ptr, info_ptr); - if (width > req_w) - width = req_w; - height = png_get_image_height(png_ptr, info_ptr); - if (height > req_h) - height = req_h; - - for (h = 0; h < height; h++) - { - int len = width; - unsigned char *src = row_ptr[h]; - dst += (req_w - width) * 3; - for (len = width; len > 0; len--, dst+=3, src+=3) - dst[0] = src[2], dst[1] = src[1], dst[2] = src[0]; - } - break; - } - } - - - ret = 0; -done: - png_destroy_read_struct(&png_ptr, info_ptr ? &info_ptr : NULL, (png_infopp)NULL); - fclose(fp); - return ret; -} - -int writepng(const char *fname, unsigned short *src, int w, int h) -{ - png_structp png_ptr = NULL; - png_infop info_ptr = NULL; - png_bytepp row_pointers; - int i, j, ret = -1; - FILE *f; - - f = fopen(fname, "wb"); - if (f == NULL) { - lprintf(__FILE__ ": failed to open \"%s\"\n", fname); - return -1; - } - - row_pointers = calloc(h, sizeof(row_pointers[0])); - if (row_pointers == NULL) - goto end1; - - for (i = 0; i < h; i++) { - unsigned char *dst = malloc(w * 3); - if (dst == NULL) - goto end2; - row_pointers[i] = dst; - for (j = 0; j < w; j++, src++, dst += 3) { - dst[0] = (*src & 0xf800) >> 8; - dst[1] = (*src & 0x07e0) >> 3; - dst[2] = (*src & 0x001f) << 3; - } - } - - /* initialize stuff */ - png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); - if (png_ptr == NULL) { - fprintf(stderr, "png_create_write_struct() failed"); - goto end2; - } - - info_ptr = png_create_info_struct(png_ptr); - if (info_ptr == NULL) { - fprintf(stderr, "png_create_info_struct() failed"); - goto end3; - } - - if (setjmp(png_jmpbuf(png_ptr)) != 0) { - fprintf(stderr, "error in png code\n"); - goto end4; - } - - png_init_io(png_ptr, f); - - png_set_IHDR(png_ptr, info_ptr, w, h, - 8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE, - PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); - - png_write_info(png_ptr, info_ptr); - png_write_image(png_ptr, row_pointers); - png_write_end(png_ptr, NULL); - - ret = 0; - -end4: -// png_destroy_info_struct(png_ptr, &info_ptr); // freed below -end3: - png_destroy_write_struct(&png_ptr, &info_ptr); -end2: - for (i = 0; i < h; i++) - free(row_pointers[i]); - free(row_pointers); -end1: - fclose(f); - return ret; -} - diff --git a/frontend/common/readpng.h b/frontend/common/readpng.h deleted file mode 100644 index 924b3415..00000000 --- a/frontend/common/readpng.h +++ /dev/null @@ -1,19 +0,0 @@ -typedef enum -{ - READPNG_BG = 1, - READPNG_FONT, - READPNG_SELECTOR, - READPNG_24, -} -readpng_what; - -#ifdef __cplusplus -extern "C" { -#endif - -int readpng(void *dest, const char *fname, readpng_what what, int w, int h); -int writepng(const char *fname, unsigned short *src, int w, int h); - -#ifdef __cplusplus -} -#endif diff --git a/frontend/gp2x/in_gp2x.c b/frontend/gp2x/in_gp2x.c deleted file mode 100644 index 6b274a00..00000000 --- a/frontend/gp2x/in_gp2x.c +++ /dev/null @@ -1,311 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include - -#include "../common/input.h" -#include "in_gp2x.h" - -#define IN_GP2X_PREFIX "gp2x:" -#define IN_GP2X_NBUTTONS 32 - -/* note: in_gp2x hadles combos (if 2 btns have the same bind, - * both must be pressed for action to happen) */ -static int in_gp2x_combo_keys = 0; -static int in_gp2x_combo_acts = 0; -static int gpiodev = -1; /* Wiz only */ - -static int (*in_gp2x_get_bits)(void); - -static const char *in_gp2x_keys[IN_GP2X_NBUTTONS] = { - [0 ... IN_GP2X_NBUTTONS-1] = NULL, - [GP2X_BTN_UP] = "Up", [GP2X_BTN_LEFT] = "Left", - [GP2X_BTN_DOWN] = "Down", [GP2X_BTN_RIGHT] = "Right", - [GP2X_BTN_START] = "Start", [GP2X_BTN_SELECT] = "Select", - [GP2X_BTN_L] = "L", [GP2X_BTN_R] = "R", - [GP2X_BTN_A] = "A", [GP2X_BTN_B] = "B", - [GP2X_BTN_X] = "X", [GP2X_BTN_Y] = "Y", - [GP2X_BTN_VOL_DOWN] = "VOL DOWN", - [GP2X_BTN_VOL_UP] = "VOL UP", - [GP2X_BTN_PUSH] = "PUSH" -}; - - -static int in_gp2x_get_mmsp2_bits(void) -{ - extern volatile unsigned short *gp2x_memregs; - int value; - value = gp2x_memregs[0x1198>>1] & 0xff; // GPIO M - if (value == 0xFD) value = 0xFA; - if (value == 0xF7) value = 0xEB; - if (value == 0xDF) value = 0xAF; - if (value == 0x7F) value = 0xBE; - value |= gp2x_memregs[0x1184>>1] & 0xFF00; // GPIO C - value |= gp2x_memregs[0x1186>>1] << 16; // GPIO D - value = ~value & 0x08c0ff55; - - return value; -} - -static int in_gp2x_get_wiz_bits(void) -{ - int r, value = 0; - r = read(gpiodev, &value, 4); - if (value & 0x02) - value |= 0x05; - if (value & 0x08) - value |= 0x14; - if (value & 0x20) - value |= 0x50; - if (value & 0x80) - value |= 0x41; - - /* convert to GP2X style */ - value &= 0x7ff55; - if (value & (1 << 16)) - value |= 1 << GP2X_BTN_VOL_UP; - if (value & (1 << 17)) - value |= 1 << GP2X_BTN_VOL_DOWN; - if (value & (1 << 18)) - value |= 1 << GP2X_BTN_PUSH; - value &= ~0x70000; - - return value; -} - -#ifdef FAKE_IN_GP2X -volatile unsigned short *gp2x_memregs; -int gp2x_dev_id = -1; - -static int in_gp2x_get_fake_bits(void) -{ - extern int current_keys; - return current_keys; -} -#endif - -static void in_gp2x_probe(void) -{ - switch (gp2x_dev_id) - { - case GP2X_DEV_GP2X: - in_gp2x_get_bits = in_gp2x_get_mmsp2_bits; - break; - case GP2X_DEV_WIZ: - gpiodev = open("/dev/GPIO", O_RDONLY); - if (gpiodev < 0) { - perror("in_gp2x: couldn't open /dev/GPIO"); - return; - } - in_gp2x_get_bits = in_gp2x_get_wiz_bits; - break; - // we'll use evdev for Caanoo - default: -#ifdef FAKE_IN_GP2X - in_gp2x_get_bits = in_gp2x_get_fake_bits; - break; -#endif - return; - } - - in_register(IN_GP2X_PREFIX "GP2X pad", -1, NULL, - IN_GP2X_NBUTTONS, in_gp2x_keys, 1); -} - -static void in_gp2x_free(void *drv_data) -{ - if (gpiodev >= 0) { - close(gpiodev); - gpiodev = -1; - } -} - -static const char * const * -in_gp2x_get_key_names(int *count) -{ - *count = IN_GP2X_NBUTTONS; - return in_gp2x_keys; -} - -/* ORs result with pressed buttons */ -static int in_gp2x_update(void *drv_data, const int *binds, int *result) -{ - int type_start = 0; - int i, t, keys; - - keys = in_gp2x_get_bits(); - - if (keys & in_gp2x_combo_keys) { - result[IN_BINDTYPE_EMU] = in_combos_do(keys, binds, GP2X_BTN_PUSH, - in_gp2x_combo_keys, in_gp2x_combo_acts); - type_start = IN_BINDTYPE_PLAYER12; - } - - for (i = 0; keys; i++, keys >>= 1) { - if (!(keys & 1)) - continue; - - for (t = type_start; t < IN_BINDTYPE_COUNT; t++) - result[t] |= binds[IN_BIND_OFFS(i, t)]; - } - - return 0; -} - -int in_gp2x_update_keycode(void *data, int *is_down) -{ - static int old_val = 0; - int val, diff, i; - - val = in_gp2x_get_bits(); - diff = val ^ old_val; - if (diff == 0) - return -1; - - /* take one bit only */ - for (i = 0; i < sizeof(diff)*8; i++) - if (diff & (1< kc */ - keycode = -keycode; - for (i = 0; i < KEY_PBTN_MAP_SIZE; i++) - if (key_pbtn_map[i].pbtn == keycode) - return key_pbtn_map[i].key; - } - else - { - for (i = 0; i < KEY_PBTN_MAP_SIZE; i++) - if (key_pbtn_map[i].key == keycode) - return key_pbtn_map[i].pbtn; - } - - return 0; -} - -#if 0 // TODO: move to pico -static const struct { - short code; - char btype; - char bit; -} in_gp2x_defbinds[] = -{ - /* MXYZ SACB RLDU */ - { BTN_UP, IN_BINDTYPE_PLAYER12, 0 }, - { BTN_DOWN, IN_BINDTYPE_PLAYER12, 1 }, - { BTN_LEFT, IN_BINDTYPE_PLAYER12, 2 }, - { BTN_RIGHT, IN_BINDTYPE_PLAYER12, 3 }, - { BTN_X, IN_BINDTYPE_PLAYER12, 4 }, /* B */ - { BTN_B, IN_BINDTYPE_PLAYER12, 5 }, /* C */ - { BTN_A, IN_BINDTYPE_PLAYER12, 6 }, /* A */ - { BTN_START, IN_BINDTYPE_PLAYER12, 7 }, - { BTN_SELECT, IN_BINDTYPE_EMU, PEVB_MENU }, -// { BTN_Y, IN_BINDTYPE_EMU, PEVB_SWITCH_RND }, - { BTN_L, IN_BINDTYPE_EMU, PEVB_STATE_SAVE }, - { BTN_R, IN_BINDTYPE_EMU, PEVB_STATE_LOAD }, - { BTN_VOL_UP, IN_BINDTYPE_EMU, PEVB_VOL_UP }, - { BTN_VOL_DOWN, IN_BINDTYPE_EMU, PEVB_VOL_DOWN }, - { 0, 0, 0 }, -}; -#endif - -/* remove binds of missing keys, count remaining ones */ -static int in_gp2x_clean_binds(void *drv_data, int *binds, int *def_binds) -{ - int i, count = 0; -// int eb, have_vol = 0, have_menu = 0; - - for (i = 0; i < IN_GP2X_NBUTTONS; i++) { - int t, offs; - for (t = 0; t < IN_BINDTYPE_COUNT; t++) { - offs = IN_BIND_OFFS(i, t); - if (in_gp2x_keys[i] == NULL) - binds[offs] = def_binds[offs] = 0; - if (binds[offs]) - count++; - } -#if 0 - eb = binds[IN_BIND_OFFS(i, IN_BINDTYPE_EMU)]; - if (eb & (PEV_VOL_DOWN|PEV_VOL_UP)) - have_vol = 1; - if (eb & PEV_MENU) - have_menu = 1; -#endif - } - - // TODO: move to pico -#if 0 - /* autobind some important keys, if they are unbound */ - if (!have_vol && binds[GP2X_BTN_VOL_UP] == 0 && binds[GP2X_BTN_VOL_DOWN] == 0) { - binds[IN_BIND_OFFS(GP2X_BTN_VOL_UP, IN_BINDTYPE_EMU)] = PEV_VOL_UP; - binds[IN_BIND_OFFS(GP2X_BTN_VOL_DOWN, IN_BINDTYPE_EMU)] = PEV_VOL_DOWN; - count += 2; - } - - if (!have_menu) { - binds[IN_BIND_OFFS(GP2X_BTN_SELECT, IN_BINDTYPE_EMU)] = PEV_MENU; - count++; - } -#endif - - in_combos_find(binds, GP2X_BTN_PUSH, &in_gp2x_combo_keys, &in_gp2x_combo_acts); - - return count; -} - -static const in_drv_t in_gp2x_drv = { - .prefix = IN_GP2X_PREFIX, - .probe = in_gp2x_probe, - .free = in_gp2x_free, - .get_key_names = in_gp2x_get_key_names, - .clean_binds = in_gp2x_clean_binds, - .update = in_gp2x_update, - .update_keycode = in_gp2x_update_keycode, - .menu_translate = in_gp2x_menu_translate, -}; - -void in_gp2x_init(const struct in_default_bind *defbinds) -{ - if (gp2x_dev_id == GP2X_DEV_WIZ) - in_gp2x_keys[GP2X_BTN_START] = "MENU"; - - in_gp2x_combo_keys = in_gp2x_combo_acts = 0; - - in_register_driver(&in_gp2x_drv, defbinds); -} - diff --git a/frontend/gp2x/in_gp2x.h b/frontend/gp2x/in_gp2x.h deleted file mode 100644 index 035cdedc..00000000 --- a/frontend/gp2x/in_gp2x.h +++ /dev/null @@ -1,17 +0,0 @@ - -struct in_default_bind; - -void in_gp2x_init(const struct in_default_bind *defbinds); - -enum { GP2X_BTN_UP = 0, GP2X_BTN_LEFT = 2, GP2X_BTN_DOWN = 4, GP2X_BTN_RIGHT = 6, - GP2X_BTN_START = 8, GP2X_BTN_SELECT = 9, GP2X_BTN_L = 10, GP2X_BTN_R = 11, - GP2X_BTN_A = 12, GP2X_BTN_B = 13, GP2X_BTN_X = 14, GP2X_BTN_Y = 15, - GP2X_BTN_VOL_UP = 23, GP2X_BTN_VOL_DOWN = 22, GP2X_BTN_PUSH = 27 }; - -/* FIXME */ -#ifndef GP2X_DEV_GP2X -extern int gp2x_dev_id; -#define GP2X_DEV_GP2X 1 -#define GP2X_DEV_WIZ 2 -#define GP2X_DEV_CAANOO 3 -#endif diff --git a/frontend/in_tsbutton.c b/frontend/in_tsbutton.c index 80c9c585..aee68522 100644 --- a/frontend/in_tsbutton.c +++ b/frontend/in_tsbutton.c @@ -11,7 +11,7 @@ #include #include -#include "common/input.h" +#include "libpicofe/input.h" #include "pl_gun_ts.h" #include "in_tsbutton.h" diff --git a/frontend/libpicofe b/frontend/libpicofe index 6ce097ba..e22d791c 160000 --- a/frontend/libpicofe +++ b/frontend/libpicofe @@ -1 +1 @@ -Subproject commit 6ce097ba2f3cd1c269bacd032b775b6d296433fc +Subproject commit e22d791cf862a5156a05bc4c55f0a90200ec22e6 diff --git a/frontend/libretro.c b/frontend/libretro.c index 1eb2147f..11bcef4f 100644 --- a/frontend/libretro.c +++ b/frontend/libretro.c @@ -14,6 +14,7 @@ #include "../libpcsxcore/new_dynarec/new_dynarec.h" #include "../plugins/dfsound/out.h" #include "../plugins/gpulib/cspace.h" +#include "linux/plat_mmap.h" #include "main.h" #include "plugin.h" #include "plugin_lib.h" @@ -64,7 +65,7 @@ static void vout_flip(const void *vram, int stride, int bgr24, int w, int h) if (vram == NULL) { // blanking - memset(pl_vout_buf, 0, dstride * h * 2); + memset(vout_buf, 0, dstride * h * 2); goto out; } @@ -95,11 +96,23 @@ static void vout_close(void) { } +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_vout_open = vout_open, .pl_vout_set_mode = vout_set_mode, .pl_vout_flip = vout_flip, .pl_vout_close = vout_close, + .mmap = pl_mmap, + .munmap = pl_munmap, /* from psxcounters */ .gpu_hcnt = &hSyncCount, .gpu_frame_count = &frame_counter, diff --git a/frontend/linux/fbdev.c b/frontend/linux/fbdev.c deleted file mode 100644 index ec3d5c7e..00000000 --- a/frontend/linux/fbdev.c +++ /dev/null @@ -1,311 +0,0 @@ -/* - * (C) Gražvydas "notaz" Ignotas, 2009-2010 - * - * This work is licensed under the terms of any of these licenses - * (at your option): - * - GNU GPL, version 2 or later. - * - GNU LGPL, version 2.1 or later. - * See the COPYING file in the top-level directory. - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "fbdev.h" - -#define PFX "fbdev: " - -struct vout_fbdev { - int fd; - void *mem; - size_t mem_size; - struct fb_var_screeninfo fbvar_old; - struct fb_var_screeninfo fbvar_new; - int buffer_write; - int fb_size; - int buffer_count; - int top_border, bottom_border; - void *mem_saved; - size_t mem_saved_size; -}; - -void *vout_fbdev_flip(struct vout_fbdev *fbdev) -{ - int draw_buf; - - if (fbdev->buffer_count < 2) - return fbdev->mem; - - draw_buf = fbdev->buffer_write; - fbdev->buffer_write++; - if (fbdev->buffer_write >= fbdev->buffer_count) - fbdev->buffer_write = 0; - - fbdev->fbvar_new.yoffset = - (fbdev->top_border + fbdev->fbvar_new.yres + fbdev->bottom_border) * draw_buf + - fbdev->top_border; - - ioctl(fbdev->fd, FBIOPAN_DISPLAY, &fbdev->fbvar_new); - - return (char *)fbdev->mem + fbdev->fb_size * fbdev->buffer_write; -} - -void vout_fbdev_wait_vsync(struct vout_fbdev *fbdev) -{ - int arg = 0; - ioctl(fbdev->fd, FBIO_WAITFORVSYNC, &arg); -} - -/* it is recommended to call vout_fbdev_clear() before this */ -void *vout_fbdev_resize(struct vout_fbdev *fbdev, int w, int h, int bpp, - int left_border, int right_border, int top_border, int bottom_border, int buffer_cnt) -{ - int w_total = left_border + w + right_border; - int h_total = top_border + h + bottom_border; - size_t mem_size; - int ret; - - // unblank to be sure the mode is really accepted - ioctl(fbdev->fd, FBIOBLANK, FB_BLANK_UNBLANK); - - if (fbdev->fbvar_new.bits_per_pixel != bpp || - fbdev->fbvar_new.xres != w || - fbdev->fbvar_new.yres != h || - fbdev->fbvar_new.xres_virtual != w_total|| - fbdev->fbvar_new.yres_virtual < h_total || - fbdev->fbvar_new.xoffset != left_border || - fbdev->buffer_count != buffer_cnt) - { - if (fbdev->fbvar_new.bits_per_pixel != bpp || - w != fbdev->fbvar_new.xres || h != fbdev->fbvar_new.yres) - printf(PFX "switching to %dx%d@%d\n", w, h, bpp); - - fbdev->fbvar_new.xres = w; - fbdev->fbvar_new.yres = h; - fbdev->fbvar_new.xres_virtual = w_total; - fbdev->fbvar_new.yres_virtual = h_total * buffer_cnt; - fbdev->fbvar_new.xoffset = left_border; - fbdev->fbvar_new.yoffset = top_border; - fbdev->fbvar_new.bits_per_pixel = bpp; - fbdev->fbvar_new.nonstd = 0; // can set YUV here on omapfb - fbdev->buffer_count = buffer_cnt; - fbdev->buffer_write = buffer_cnt > 1 ? 1 : 0; - - // seems to help a bit to avoid glitches - vout_fbdev_wait_vsync(fbdev); - - ret = ioctl(fbdev->fd, FBIOPUT_VSCREENINFO, &fbdev->fbvar_new); - if (ret == -1) { - // retry with no multibuffering - fbdev->fbvar_new.yres_virtual = h_total; - ret = ioctl(fbdev->fd, FBIOPUT_VSCREENINFO, &fbdev->fbvar_new); - if (ret == -1) { - perror(PFX "FBIOPUT_VSCREENINFO ioctl"); - return NULL; - } - fbdev->buffer_count = 1; - fbdev->buffer_write = 0; - fprintf(stderr, PFX "Warning: failed to increase virtual resolution, " - "multibuffering disabled\n"); - } - - } - - fbdev->fb_size = w_total * h_total * bpp / 8; - fbdev->top_border = top_border; - fbdev->bottom_border = bottom_border; - - mem_size = fbdev->fb_size * fbdev->buffer_count; - if (fbdev->mem_size >= mem_size) - goto out; - - if (fbdev->mem != NULL) - munmap(fbdev->mem, fbdev->mem_size); - - fbdev->mem = mmap(0, mem_size, PROT_WRITE|PROT_READ, MAP_SHARED, fbdev->fd, 0); - if (fbdev->mem == MAP_FAILED && fbdev->buffer_count > 1) { - fprintf(stderr, PFX "Warning: can't map %zd bytes, doublebuffering disabled\n", mem_size); - fbdev->buffer_count = 1; - fbdev->buffer_write = 0; - mem_size = fbdev->fb_size; - fbdev->mem = mmap(0, mem_size, PROT_WRITE|PROT_READ, MAP_SHARED, fbdev->fd, 0); - } - if (fbdev->mem == MAP_FAILED) { - fbdev->mem = NULL; - fbdev->mem_size = 0; - perror(PFX "mmap framebuffer"); - return NULL; - } - - fbdev->mem_size = mem_size; - -out: - return (char *)fbdev->mem + fbdev->fb_size * fbdev->buffer_write; -} - -void vout_fbdev_clear(struct vout_fbdev *fbdev) -{ - memset(fbdev->mem, 0, fbdev->mem_size); -} - -void vout_fbdev_clear_lines(struct vout_fbdev *fbdev, int y, int count) -{ - int stride = fbdev->fbvar_new.xres_virtual * fbdev->fbvar_new.bits_per_pixel / 8; - int i; - - if (y + count > fbdev->top_border + fbdev->fbvar_new.yres) - count = fbdev->top_border + fbdev->fbvar_new.yres - y; - - if (y >= 0 && count > 0) - for (i = 0; i < fbdev->buffer_count; i++) - memset((char *)fbdev->mem + fbdev->fb_size * i + y * stride, 0, stride * count); -} - -int vout_fbdev_get_fd(struct vout_fbdev *fbdev) -{ - return fbdev->fd; -} - -struct vout_fbdev *vout_fbdev_init(const char *fbdev_name, int *w, int *h, int bpp, int buffer_cnt) -{ - struct vout_fbdev *fbdev; - int req_w, req_h; - void *pret; - int ret; - - fbdev = calloc(1, sizeof(*fbdev)); - if (fbdev == NULL) - return NULL; - - fbdev->fd = open(fbdev_name, O_RDWR); - if (fbdev->fd == -1) { - fprintf(stderr, PFX "%s: ", fbdev_name); - perror("open"); - goto fail_open; - } - - ret = ioctl(fbdev->fd, FBIOGET_VSCREENINFO, &fbdev->fbvar_old); - if (ret == -1) { - perror(PFX "FBIOGET_VSCREENINFO ioctl"); - goto fail; - } - - fbdev->fbvar_new = fbdev->fbvar_old; - - req_w = fbdev->fbvar_new.xres; - if (*w != 0) - req_w = *w; - req_h = fbdev->fbvar_new.yres; - if (*h != 0) - req_h = *h; - - pret = vout_fbdev_resize(fbdev, req_w, req_h, bpp, 0, 0, 0, 0, buffer_cnt); - if (pret == NULL) - goto fail; - - printf(PFX "%s: %ix%i@%d\n", fbdev_name, fbdev->fbvar_new.xres, - fbdev->fbvar_new.yres, fbdev->fbvar_new.bits_per_pixel); - *w = fbdev->fbvar_new.xres; - *h = fbdev->fbvar_new.yres; - - memset(fbdev->mem, 0, fbdev->mem_size); - - // some checks - ret = 0; - ret = ioctl(fbdev->fd, FBIO_WAITFORVSYNC, &ret); - if (ret != 0) - fprintf(stderr, PFX "Warning: vsync doesn't seem to be supported\n"); - - if (fbdev->buffer_count > 1) { - fbdev->buffer_write = 0; - fbdev->fbvar_new.yoffset = fbdev->fbvar_new.yres * (fbdev->buffer_count - 1); - ret = ioctl(fbdev->fd, FBIOPAN_DISPLAY, &fbdev->fbvar_new); - if (ret != 0) { - fbdev->buffer_count = 1; - fprintf(stderr, PFX "Warning: can't pan display, doublebuffering disabled\n"); - } - } - - printf("fbdev initialized.\n"); - return fbdev; - -fail: - close(fbdev->fd); -fail_open: - free(fbdev); - return NULL; -} - -static void vout_fbdev_release(struct vout_fbdev *fbdev) -{ - ioctl(fbdev->fd, FBIOPUT_VSCREENINFO, &fbdev->fbvar_old); - if (fbdev->mem != MAP_FAILED) - munmap(fbdev->mem, fbdev->mem_size); - fbdev->mem = NULL; -} - -int vout_fbdev_save(struct vout_fbdev *fbdev) -{ - void *tmp; - - if (fbdev == NULL || fbdev->mem == NULL || fbdev->mem == MAP_FAILED) { - fprintf(stderr, PFX "bad args for save\n"); - return -1; - } - - if (fbdev->mem_saved_size < fbdev->mem_size) { - tmp = realloc(fbdev->mem_saved, fbdev->mem_size); - if (tmp == NULL) - return -1; - fbdev->mem_saved = tmp; - } - memcpy(fbdev->mem_saved, fbdev->mem, fbdev->mem_size); - fbdev->mem_saved_size = fbdev->mem_size; - - vout_fbdev_release(fbdev); - return 0; -} - -int vout_fbdev_restore(struct vout_fbdev *fbdev) -{ - int ret; - - if (fbdev == NULL || fbdev->mem != NULL) { - fprintf(stderr, PFX "bad args/state for restore\n"); - return -1; - } - - fbdev->mem = mmap(0, fbdev->mem_size, PROT_WRITE|PROT_READ, MAP_SHARED, fbdev->fd, 0); - if (fbdev->mem == MAP_FAILED) { - perror(PFX "restore: memory restore failed"); - return -1; - } - memcpy(fbdev->mem, fbdev->mem_saved, fbdev->mem_size); - - ret = ioctl(fbdev->fd, FBIOPUT_VSCREENINFO, &fbdev->fbvar_new); - if (ret == -1) { - perror(PFX "restore: FBIOPUT_VSCREENINFO"); - return -1; - } - - return 0; -} - -void vout_fbdev_finish(struct vout_fbdev *fbdev) -{ - vout_fbdev_release(fbdev); - if (fbdev->fd >= 0) - close(fbdev->fd); - fbdev->fd = -1; - free(fbdev); -} - diff --git a/frontend/linux/fbdev.h b/frontend/linux/fbdev.h deleted file mode 100644 index 88cd519f..00000000 --- a/frontend/linux/fbdev.h +++ /dev/null @@ -1,14 +0,0 @@ -struct vout_fbdev; - -struct vout_fbdev *vout_fbdev_init(const char *fbdev_name, int *w, int *h, int bpp, int buffer_count); -void *vout_fbdev_flip(struct vout_fbdev *fbdev); -void vout_fbdev_wait_vsync(struct vout_fbdev *fbdev); -void *vout_fbdev_resize(struct vout_fbdev *fbdev, int w, int h, int bpp, - int left_border, int right_border, int top_border, int bottom_border, - int buffer_count); -void vout_fbdev_clear(struct vout_fbdev *fbdev); -void vout_fbdev_clear_lines(struct vout_fbdev *fbdev, int y, int count); -int vout_fbdev_get_fd(struct vout_fbdev *fbdev); -int vout_fbdev_save(struct vout_fbdev *fbdev); -int vout_fbdev_restore(struct vout_fbdev *fbdev); -void vout_fbdev_finish(struct vout_fbdev *fbdev); diff --git a/frontend/linux/in_evdev.c b/frontend/linux/in_evdev.c deleted file mode 100644 index b447da16..00000000 --- a/frontend/linux/in_evdev.c +++ /dev/null @@ -1,655 +0,0 @@ -/* - * (C) Gražvydas "notaz" Ignotas, 2008-2010 - * - * This work is licensed under the terms of any of these licenses - * (at your option): - * - GNU GPL, version 2 or later. - * - GNU LGPL, version 2.1 or later. - * See the COPYING file in the top-level directory. - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "../common/input.h" -#include "in_evdev.h" - -#define MAX_ABS_DEVS 8 - -typedef struct { - int fd; - int *kbits; - int abs_min_x; /* abs->digital mapping */ - int abs_max_x; - int abs_min_y; - int abs_max_y; - int abs_lzone; - int abs_lastx; - int abs_lasty; - int kc_first; - int kc_last; - unsigned int abs_count; - int abs_mult[MAX_ABS_DEVS]; /* 16.16 multiplier to IN_ABS_RANGE */ - int abs_adj[MAX_ABS_DEVS]; /* adjust for centering */ - unsigned int abs_to_digital:1; -} in_evdev_t; - -#ifndef KEY_CNT -#define KEY_CNT (KEY_MAX + 1) -#endif - -#define KEYBITS_BIT(x) (keybits[(x)/sizeof(keybits[0])/8] & \ - (1 << ((x) & (sizeof(keybits[0])*8-1)))) - -#define KEYBITS_BIT_SET(x) (keybits[(x)/sizeof(keybits[0])/8] |= \ - (1 << ((x) & (sizeof(keybits[0])*8-1)))) - -#define KEYBITS_BIT_CLEAR(x) (keybits[(x)/sizeof(keybits[0])/8] &= \ - ~(1 << ((x) & (sizeof(keybits[0])*8-1)))) - -int in_evdev_allow_abs_only; - -#define IN_EVDEV_PREFIX "evdev:" - -static const char * const in_evdev_keys[KEY_CNT] = { - [0 ... KEY_MAX] = NULL, - [KEY_RESERVED] = "Reserved", [KEY_ESC] = "Esc", - [KEY_1] = "1", [KEY_2] = "2", - [KEY_3] = "3", [KEY_4] = "4", - [KEY_5] = "5", [KEY_6] = "6", - [KEY_7] = "7", [KEY_8] = "8", - [KEY_9] = "9", [KEY_0] = "0", - [KEY_MINUS] = "Minus", [KEY_EQUAL] = "Equal", - [KEY_BACKSPACE] = "Backspace", [KEY_TAB] = "Tab", - [KEY_Q] = "Q", [KEY_W] = "W", - [KEY_E] = "E", [KEY_R] = "R", - [KEY_T] = "T", [KEY_Y] = "Y", - [KEY_U] = "U", [KEY_I] = "I", - [KEY_O] = "O", [KEY_P] = "P", - [KEY_LEFTBRACE] = "LeftBrace", [KEY_RIGHTBRACE] = "RightBrace", - [KEY_ENTER] = "Enter", [KEY_LEFTCTRL] = "LeftControl", - [KEY_A] = "A", [KEY_S] = "S", - [KEY_D] = "D", [KEY_F] = "F", - [KEY_G] = "G", [KEY_H] = "H", - [KEY_J] = "J", [KEY_K] = "K", - [KEY_L] = "L", [KEY_SEMICOLON] = "Semicolon", - [KEY_APOSTROPHE] = "Apostrophe", [KEY_GRAVE] = "Grave", - [KEY_LEFTSHIFT] = "LeftShift", [KEY_BACKSLASH] = "BackSlash", - [KEY_Z] = "Z", [KEY_X] = "X", - [KEY_C] = "C", [KEY_V] = "V", - [KEY_B] = "B", [KEY_N] = "N", - [KEY_M] = "M", [KEY_COMMA] = "Comma", - [KEY_DOT] = "Dot", [KEY_SLASH] = "Slash", - [KEY_RIGHTSHIFT] = "RightShift", [KEY_KPASTERISK] = "KPAsterisk", - [KEY_LEFTALT] = "LeftAlt", [KEY_SPACE] = "Space", - [KEY_CAPSLOCK] = "CapsLock", [KEY_F1] = "F1", - [KEY_F2] = "F2", [KEY_F3] = "F3", - [KEY_F4] = "F4", [KEY_F5] = "F5", - [KEY_F6] = "F6", [KEY_F7] = "F7", - [KEY_F8] = "F8", [KEY_F9] = "F9", - [KEY_F10] = "F10", [KEY_NUMLOCK] = "NumLock", - [KEY_SCROLLLOCK] = "ScrollLock", [KEY_KP7] = "KP7", - [KEY_KP8] = "KP8", [KEY_KP9] = "KP9", - [KEY_KPMINUS] = "KPMinus", [KEY_KP4] = "KP4", - [KEY_KP5] = "KP5", [KEY_KP6] = "KP6", - [KEY_KPPLUS] = "KPPlus", [KEY_KP1] = "KP1", - [KEY_KP2] = "KP2", [KEY_KP3] = "KP3", - [KEY_KP0] = "KP0", [KEY_KPDOT] = "KPDot", - [KEY_ZENKAKUHANKAKU] = "Zenkaku/Hankaku", [KEY_102ND] = "102nd", - [KEY_F11] = "F11", [KEY_F12] = "F12", - [KEY_KPJPCOMMA] = "KPJpComma", [KEY_KPENTER] = "KPEnter", - [KEY_RIGHTCTRL] = "RightCtrl", [KEY_KPSLASH] = "KPSlash", - [KEY_SYSRQ] = "SysRq", [KEY_RIGHTALT] = "RightAlt", - [KEY_LINEFEED] = "LineFeed", [KEY_HOME] = "Home", - [KEY_UP] = "Up", [KEY_PAGEUP] = "PageUp", - [KEY_LEFT] = "Left", [KEY_RIGHT] = "Right", - [KEY_END] = "End", [KEY_DOWN] = "Down", - [KEY_PAGEDOWN] = "PageDown", [KEY_INSERT] = "Insert", - [KEY_DELETE] = "Delete", [KEY_MACRO] = "Macro", - [KEY_HELP] = "Help", [KEY_MENU] = "Menu", - [KEY_COFFEE] = "Coffee", [KEY_DIRECTION] = "Direction", - [BTN_0] = "Btn0", [BTN_1] = "Btn1", - [BTN_2] = "Btn2", [BTN_3] = "Btn3", - [BTN_4] = "Btn4", [BTN_5] = "Btn5", - [BTN_6] = "Btn6", [BTN_7] = "Btn7", - [BTN_8] = "Btn8", [BTN_9] = "Btn9", - [BTN_LEFT] = "LeftBtn", [BTN_RIGHT] = "RightBtn", - [BTN_MIDDLE] = "MiddleBtn", [BTN_SIDE] = "SideBtn", - [BTN_EXTRA] = "ExtraBtn", [BTN_FORWARD] = "ForwardBtn", - [BTN_BACK] = "BackBtn", [BTN_TASK] = "TaskBtn", - [BTN_TRIGGER] = "Trigger", [BTN_THUMB] = "ThumbBtn", - [BTN_THUMB2] = "ThumbBtn2", [BTN_TOP] = "TopBtn", - [BTN_TOP2] = "TopBtn2", [BTN_PINKIE] = "PinkieBtn", - [BTN_BASE] = "BaseBtn", [BTN_BASE2] = "BaseBtn2", - [BTN_BASE3] = "BaseBtn3", [BTN_BASE4] = "BaseBtn4", - [BTN_BASE5] = "BaseBtn5", [BTN_BASE6] = "BaseBtn6", - [BTN_DEAD] = "BtnDead", [BTN_A] = "BtnA", - [BTN_B] = "BtnB", [BTN_C] = "BtnC", - [BTN_X] = "BtnX", [BTN_Y] = "BtnY", - [BTN_Z] = "BtnZ", [BTN_TL] = "BtnTL", - [BTN_TR] = "BtnTR", [BTN_TL2] = "BtnTL2", - [BTN_TR2] = "BtnTR2", [BTN_SELECT] = "BtnSelect", - [BTN_START] = "BtnStart", [BTN_MODE] = "BtnMode", - [BTN_THUMBL] = "BtnThumbL", [BTN_THUMBR] = "BtnThumbR", - [BTN_TOUCH] = "Touch", [BTN_STYLUS] = "Stylus", - [BTN_STYLUS2] = "Stylus2", [BTN_TOOL_DOUBLETAP] = "Tool Doubletap", - [BTN_TOOL_TRIPLETAP] = "Tool Tripletap", [BTN_GEAR_DOWN] = "WheelBtn", - [BTN_GEAR_UP] = "Gear up", [KEY_OK] = "Ok", -}; - - -static void in_evdev_probe(void) -{ - long keybits[KEY_CNT / sizeof(long) / 8]; - long absbits[(ABS_MAX+1) / sizeof(long) / 8]; - int i; - - // the kernel might support and return less keys then we know about, - // so make sure the buffers are clear. - memset(keybits, 0, sizeof(keybits)); - memset(absbits, 0, sizeof(absbits)); - - for (i = 0;; i++) - { - int support = 0, count = 0; - int u, ret, fd, kc_first = KEY_MAX, kc_last = 0, have_abs = 0; - in_evdev_t *dev; - char name[64]; - - snprintf(name, sizeof(name), "/dev/input/event%d", i); - fd = open(name, O_RDONLY|O_NONBLOCK); - if (fd == -1) { - if (errno == EACCES) - continue; /* maybe we can access next one */ - break; - } - - /* check supported events */ - ret = ioctl(fd, EVIOCGBIT(0, sizeof(support)), &support); - if (ret == -1) { - printf("in_evdev: ioctl failed on %s\n", name); - goto skip; - } - - if (support & (1 << EV_KEY)) { - ret = ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybits)), keybits); - if (ret == -1) { - printf("in_evdev: ioctl failed on %s\n", name); - goto skip; - } - - /* check for interesting keys */ - for (u = 0; u < KEY_CNT; u++) { - if (KEYBITS_BIT(u)) { - if (u < kc_first) - kc_first = u; - if (u > kc_last) - kc_last = u; - if (u != KEY_POWER && u != KEY_SLEEP && u != BTN_TOUCH) - count++; - if (u == BTN_TOUCH) /* we can't deal with ts currently */ - goto skip; - } - } - } - - dev = calloc(1, sizeof(*dev)); - if (dev == NULL) - goto skip; - - ret = ioctl(fd, EVIOCGKEY(sizeof(keybits)), keybits); - if (ret == -1) { - printf("Warning: EVIOCGKEY not supported, will have to track state\n"); - dev->kbits = calloc(KEY_CNT, sizeof(int)); - if (dev->kbits == NULL) { - free(dev); - goto skip; - } - } - - /* check for abs too */ - if (support & (1 << EV_ABS)) { - struct input_absinfo ainfo; - int dist; - ret = ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(absbits)), absbits); - if (ret == -1) - goto no_abs; - if (absbits[0] & (1 << ABS_X)) { - ret = ioctl(fd, EVIOCGABS(ABS_X), &ainfo); - if (ret == -1) - goto no_abs; - dist = ainfo.maximum - ainfo.minimum; - dev->abs_lzone = dist / 4; - dev->abs_min_x = ainfo.minimum; - dev->abs_max_x = ainfo.maximum; - } - if (absbits[0] & (1 << ABS_Y)) { - ret = ioctl(fd, EVIOCGABS(ABS_Y), &ainfo); - if (ret == -1) - goto no_abs; - dist = ainfo.maximum - ainfo.minimum; - dev->abs_min_y = ainfo.minimum; - dev->abs_max_y = ainfo.maximum; - } - for (u = 0; u < MAX_ABS_DEVS; u++) { - ret = ioctl(fd, EVIOCGABS(u), &ainfo); - if (ret == -1) - break; - dist = ainfo.maximum - ainfo.minimum; - if (dist != 0) - dev->abs_mult[u] = IN_ABS_RANGE * 2 * 65536 / dist; - dev->abs_adj[u] = -(ainfo.maximum + ainfo.minimum + 1) / 2; - have_abs = 1; - } - dev->abs_count = u; - } - -no_abs: - if (count == 0 && !have_abs) { - free(dev); - goto skip; - } - - dev->fd = fd; - dev->kc_first = kc_first; - dev->kc_last = kc_last; - if (count > 0 || in_evdev_allow_abs_only) - dev->abs_to_digital = 1; - strcpy(name, IN_EVDEV_PREFIX); - ioctl(fd, EVIOCGNAME(sizeof(name)-6), name+6); - printf("in_evdev: found \"%s\" with %d events (type %08x)\n", - name+6, count, support); - in_register(name, fd, dev, KEY_CNT, in_evdev_keys, 0); - continue; - -skip: - close(fd); - } -} - -static void in_evdev_free(void *drv_data) -{ - in_evdev_t *dev = drv_data; - if (dev == NULL) - return; - close(dev->fd); - free(dev); -} - -static const char * const * -in_evdev_get_key_names(int *count) -{ - *count = KEY_CNT; - return in_evdev_keys; -} - -static void or_binds(const int *binds, int key, int *result) -{ - int t; - for (t = 0; t < IN_BINDTYPE_COUNT; t++) - result[t] |= binds[IN_BIND_OFFS(key, t)]; -} - -/* ORs result with binds of pressed buttons - * XXX: should measure performance hit of this func, might need to optimize */ -static int in_evdev_update(void *drv_data, const int *binds, int *result) -{ - struct input_event ev[16]; - struct input_absinfo ainfo; - int keybits_[KEY_CNT / sizeof(int)]; - int *keybits = keybits_; - in_evdev_t *dev = drv_data; - int rd, ret, u, lzone; - - if (dev->kbits == NULL) { - ret = ioctl(dev->fd, EVIOCGKEY(sizeof(keybits_)), keybits_); - if (ret == -1) { - perror("in_evdev: ioctl failed"); - return -1; - } - } - else { - keybits = dev->kbits; - while (1) { - rd = read(dev->fd, ev, sizeof(ev)); - if (rd < (int)sizeof(ev[0])) { - if (errno != EAGAIN) - perror("in_evdev: read failed"); - break; - } - for (u = 0; u < rd / sizeof(ev[0]); u++) { - if (ev[u].type != EV_KEY) - continue; - else if (ev[u].value == 1) - KEYBITS_BIT_SET(ev[u].code); - else if (ev[u].value == 0) - KEYBITS_BIT_CLEAR(ev[u].code); - } - } - } - - for (u = dev->kc_first; u <= dev->kc_last; u++) { - if (KEYBITS_BIT(u)) - or_binds(binds, u, result); - } - - /* map X and Y absolute to UDLR */ - lzone = dev->abs_lzone; - if (dev->abs_to_digital && lzone != 0) { - ret = ioctl(dev->fd, EVIOCGABS(ABS_X), &ainfo); - if (ret != -1) { - if (ainfo.value < dev->abs_min_x + lzone) or_binds(binds, KEY_LEFT, result); - if (ainfo.value > dev->abs_max_x - lzone) or_binds(binds, KEY_RIGHT, result); - } - ret = ioctl(dev->fd, EVIOCGABS(ABS_Y), &ainfo); - if (ret != -1) { - if (ainfo.value < dev->abs_min_y + lzone) or_binds(binds, KEY_UP, result); - if (ainfo.value > dev->abs_max_y - lzone) or_binds(binds, KEY_DOWN, result); - } - } - - return 0; -} - -static int in_evdev_update_analog(void *drv_data, int axis_id, int *result) -{ - struct input_absinfo ainfo; - in_evdev_t *dev = drv_data; - int ret; - - if ((unsigned int)axis_id >= MAX_ABS_DEVS) - return -1; - - ret = ioctl(dev->fd, EVIOCGABS(axis_id), &ainfo); - if (ret != 0) - return ret; - - *result = (ainfo.value + dev->abs_adj[axis_id]) * dev->abs_mult[axis_id]; - *result >>= 16; - return 0; -} - -static int in_evdev_set_blocking(in_evdev_t *dev, int y) -{ - long flags; - int ret; - - flags = (long)fcntl(dev->fd, F_GETFL); - if ((int)flags == -1) { - perror("in_evdev: F_GETFL fcntl failed"); - return -1; - } - - if (flags & O_NONBLOCK) { - /* flush the event queue */ - struct input_event ev; - do { - ret = read(dev->fd, &ev, sizeof(ev)); - } - while (ret == sizeof(ev)); - } - - if (y) - flags &= ~O_NONBLOCK; - else - flags |= O_NONBLOCK; - ret = fcntl(dev->fd, F_SETFL, flags); - if (ret == -1) { - perror("in_evdev: F_SETFL fcntl failed"); - return -1; - } - - return 0; -} - -static int in_evdev_get_config(void *drv_data, int what, int *val) -{ - in_evdev_t *dev = drv_data; - - switch (what) { - case IN_CFG_ABS_AXIS_COUNT: - *val = dev->abs_count; - break; - default: - return -1; - } - - return 0; -} - -static int in_evdev_set_config(void *drv_data, int what, int val) -{ - in_evdev_t *dev = drv_data; - int tmp; - - switch (what) { - case IN_CFG_BLOCKING: - return in_evdev_set_blocking(dev, val); - case IN_CFG_ABS_DEAD_ZONE: - if (val < 1 || val > 99 || dev->abs_lzone == 0) - return -1; - /* XXX: based on X axis only, for now.. */ - tmp = (dev->abs_max_x - dev->abs_min_x) / 2; - dev->abs_lzone = tmp - tmp * val / 100; - if (dev->abs_lzone < 1) - dev->abs_lzone = 1; - else if (dev->abs_lzone >= tmp) - dev->abs_lzone = tmp - 1; - break; - default: - return -1; - } - - return 0; -} - -static int in_evdev_update_keycode(void *data, int *is_down) -{ - int ret_kc = -1, ret_down = 0; - in_evdev_t *dev = data; - struct input_event ev; - int rd; - - /* do single event, the caller sometimes wants - * to do select() in blocking mode */ - rd = read(dev->fd, &ev, sizeof(ev)); - if (rd < (int) sizeof(ev)) { - if (errno != EAGAIN) { - perror("in_evdev: error reading"); - //sleep(1); - ret_kc = -2; - } - goto out; - } - - if (ev.type == EV_KEY) { - if (ev.value < 0 || ev.value > 1) - goto out; - ret_kc = ev.code; - ret_down = ev.value; - goto out; - } - else if (ev.type == EV_ABS && dev->abs_to_digital) - { - int lzone = dev->abs_lzone, down = 0, *last; - - // map absolute to up/down/left/right - if (lzone != 0 && ev.code == ABS_X) { - if (ev.value < dev->abs_min_x + lzone) - down = KEY_LEFT; - else if (ev.value > dev->abs_max_x - lzone) - down = KEY_RIGHT; - last = &dev->abs_lastx; - } - else if (lzone != 0 && ev.code == ABS_Y) { - if (ev.value < dev->abs_min_y + lzone) - down = KEY_UP; - else if (ev.value > dev->abs_max_y - lzone) - down = KEY_DOWN; - last = &dev->abs_lasty; - } - else - goto out; - - if (down == *last) - goto out; - - if (down == 0 || *last != 0) { - /* key up or direction change, return up event for old key */ - ret_kc = *last; - ret_down = 0; - *last = 0; - goto out; - } - ret_kc = *last = down; - ret_down = 1; - goto out; - } - -out: - if (is_down != NULL) - *is_down = ret_down; - - return ret_kc; -} - -static const struct { - short key; - short pbtn; -} key_pbtn_map[] = -{ - { KEY_UP, PBTN_UP }, - { KEY_DOWN, PBTN_DOWN }, - { KEY_LEFT, PBTN_LEFT }, - { KEY_RIGHT, PBTN_RIGHT }, - /* XXX: maybe better set this from it's plat code somehow */ - /* Pandora */ - { KEY_END, PBTN_MOK }, - { KEY_PAGEDOWN, PBTN_MBACK }, - { KEY_HOME, PBTN_MA2 }, - { KEY_PAGEUP, PBTN_MA3 }, - { KEY_LEFTCTRL, PBTN_MENU }, - { KEY_RIGHTSHIFT, PBTN_L }, - { KEY_RIGHTCTRL, PBTN_R }, - /* Caanoo */ - { BTN_THUMB2, PBTN_MOK }, - { BTN_THUMB, PBTN_MBACK }, - { BTN_TRIGGER, PBTN_MA2 }, - { BTN_TOP, PBTN_MA3 }, - { BTN_BASE, PBTN_MENU }, - { BTN_TOP2, PBTN_L }, - { BTN_PINKIE, PBTN_R }, - /* "normal" keyboards */ - { KEY_ENTER, PBTN_MOK }, - { KEY_ESC, PBTN_MBACK }, - { KEY_A, PBTN_MA2 }, - { KEY_S, PBTN_MA3 }, - { KEY_BACKSLASH, PBTN_MENU }, - { KEY_LEFTBRACE, PBTN_L }, - { KEY_RIGHTBRACE, PBTN_R }, -}; - -#define KEY_PBTN_MAP_SIZE (sizeof(key_pbtn_map) / sizeof(key_pbtn_map[0])) - -static int in_evdev_menu_translate(void *drv_data, int keycode, char *charcode) -{ - in_evdev_t *dev = drv_data; - int ret = 0; - int i; - - if (keycode < 0) - { - /* menu -> kc */ - keycode = -keycode; - for (i = 0; i < KEY_PBTN_MAP_SIZE; i++) - if (key_pbtn_map[i].pbtn == keycode) { - int k = key_pbtn_map[i].key; - /* should really check EVIOCGBIT, but this is enough for now */ - if (dev->kc_first <= k && k <= dev->kc_last) - return k; - } - } - else - { - for (i = 0; i < KEY_PBTN_MAP_SIZE; i++) { - if (key_pbtn_map[i].key == keycode) { - ret = key_pbtn_map[i].pbtn; - break; - } - } - - if (charcode != NULL && (unsigned int)keycode < KEY_CNT && - in_evdev_keys[keycode] != NULL && in_evdev_keys[keycode][1] == 0) - { - char c = in_evdev_keys[keycode][0]; - if ('A' <= c && c <= 'Z') - c = 'a' + c - 'A'; - ret |= PBTN_CHAR; - *charcode = c; - } - } - - return ret; -} - -/* remove binds of missing keys, count remaining ones */ -static int in_evdev_clean_binds(void *drv_data, int *binds, int *def_binds) -{ - int keybits[KEY_CNT / sizeof(int)]; - in_evdev_t *dev = drv_data; - int i, t, ret, offs, count = 0; - - memset(keybits, 0, sizeof(keybits)); - ret = ioctl(dev->fd, EVIOCGBIT(EV_KEY, sizeof(keybits)), keybits); - if (ret == -1) { - perror("in_evdev: ioctl failed"); - // memset(keybits, 0xff, sizeof(keybits)); /* mark all as good */ - } - - if (dev->abs_to_digital && dev->abs_lzone != 0) { - KEYBITS_BIT_SET(KEY_LEFT); - KEYBITS_BIT_SET(KEY_RIGHT); - KEYBITS_BIT_SET(KEY_UP); - KEYBITS_BIT_SET(KEY_DOWN); - } - - for (i = 0; i < KEY_CNT; i++) { - for (t = 0; t < IN_BINDTYPE_COUNT; t++) { - offs = IN_BIND_OFFS(i, t); - if (!KEYBITS_BIT(i)) - binds[offs] = def_binds[offs] = 0; - if (binds[offs]) - count++; - } - } - - return count; -} - -static const in_drv_t in_evdev_drv = { - .prefix = IN_EVDEV_PREFIX, - .probe = in_evdev_probe, - .free = in_evdev_free, - .get_key_names = in_evdev_get_key_names, - .clean_binds = in_evdev_clean_binds, - .get_config = in_evdev_get_config, - .set_config = in_evdev_set_config, - .update = in_evdev_update, - .update_analog = in_evdev_update_analog, - .update_keycode = in_evdev_update_keycode, - .menu_translate = in_evdev_menu_translate, -}; - -void in_evdev_init(const struct in_default_bind *defbinds) -{ - in_register_driver(&in_evdev_drv, defbinds); -} - diff --git a/frontend/linux/in_evdev.h b/frontend/linux/in_evdev.h deleted file mode 100644 index c5aef9bb..00000000 --- a/frontend/linux/in_evdev.h +++ /dev/null @@ -1,5 +0,0 @@ - -struct in_default_bind; -extern int in_evdev_allow_abs_only; - -void in_evdev_init(const struct in_default_bind *defbinds); diff --git a/frontend/linux/plat.c b/frontend/linux/plat_mmap.c similarity index 51% rename from frontend/linux/plat.c rename to frontend/linux/plat_mmap.c index 4ed1e65d..db661b6d 100644 --- a/frontend/linux/plat.c +++ b/frontend/linux/plat_mmap.c @@ -12,14 +12,13 @@ #include #include #include -#include -#include -#include #include #include #include -#include "../common/plat.h" +// this is some dupe code to avoid libpicofe dep + +//#include "../libpicofe/plat.h" /* XXX: maybe unhardcode pagesize? */ #define HUGETLB_PAGESIZE (2 * 1024 * 1024) @@ -28,112 +27,6 @@ #define MAP_HUGETLB 0x40000 /* arch specific */ #endif - -int plat_is_dir(const char *path) -{ - DIR *dir; - if ((dir = opendir(path))) { - closedir(dir); - return 1; - } - return 0; -} - -int plat_get_root_dir(char *dst, int len) -{ - int j, ret; - - ret = readlink("/proc/self/exe", dst, len - 1); - if (ret < 0) { - perror("readlink"); - ret = 0; - } - dst[ret] = 0; - - for (j = strlen(dst); j > 0; j--) - if (dst[j] == '/') { - dst[++j] = 0; - break; - } - - return j; -} - -#ifdef __GP2X__ -/* Wiz has a borked gettimeofday().. */ -#define plat_get_ticks_ms plat_get_ticks_ms_good -#define plat_get_ticks_us plat_get_ticks_us_good -#endif - -unsigned int plat_get_ticks_ms(void) -{ - struct timeval tv; - unsigned int ret; - - gettimeofday(&tv, NULL); - - ret = (unsigned)tv.tv_sec * 1000; - /* approximate /= 1000 */ - ret += ((unsigned)tv.tv_usec * 4195) >> 22; - - return ret; -} - -unsigned int plat_get_ticks_us(void) -{ - struct timeval tv; - unsigned int ret; - - gettimeofday(&tv, NULL); - - ret = (unsigned)tv.tv_sec * 1000000; - ret += (unsigned)tv.tv_usec; - - return ret; -} - -void plat_sleep_ms(int ms) -{ - usleep(ms * 1000); -} - -int plat_wait_event(int *fds_hnds, int count, int timeout_ms) -{ - struct timeval tv, *timeout = NULL; - int i, ret, fdmax = -1; - fd_set fdset; - - if (timeout_ms >= 0) { - tv.tv_sec = timeout_ms / 1000; - tv.tv_usec = (timeout_ms % 1000) * 1000; - timeout = &tv; - } - - FD_ZERO(&fdset); - for (i = 0; i < count; i++) { - if (fds_hnds[i] > fdmax) fdmax = fds_hnds[i]; - FD_SET(fds_hnds[i], &fdset); - } - - ret = select(fdmax + 1, &fdset, NULL, NULL, timeout); - if (ret == -1) - { - perror("plat_wait_event: select failed"); - sleep(1); - return -1; - } - - if (ret == 0) - return -1; /* timeout */ - - ret = -1; - for (i = 0; i < count; i++) - if (FD_ISSET(fds_hnds[i], &fdset)) - ret = fds_hnds[i]; - - return ret; -} - void *plat_mmap(unsigned long addr, size_t size, int need_exec, int is_fixed) { static int hugetlb_disabled; @@ -196,14 +89,3 @@ void plat_munmap(void *ptr, size_t size) "munmap(%p, %zu) failed: %d\n", ptr, size, errno); } } - -/* lprintf */ -void lprintf(const char *fmt, ...) -{ - va_list vl; - - va_start(vl, fmt); - vprintf(fmt, vl); - va_end(vl); -} - diff --git a/frontend/linux/plat_mmap.h b/frontend/linux/plat_mmap.h new file mode 100644 index 00000000..175246ea --- /dev/null +++ b/frontend/linux/plat_mmap.h @@ -0,0 +1,5 @@ +#include + +void *plat_mmap(unsigned long addr, size_t size, int need_exec, int is_fixed); +void *plat_mremap(void *ptr, size_t oldsize, size_t newsize); +void plat_munmap(void *ptr, size_t size); diff --git a/frontend/linux/xenv.c b/frontend/linux/xenv.c deleted file mode 100644 index 40bf92c9..00000000 --- a/frontend/linux/xenv.c +++ /dev/null @@ -1,455 +0,0 @@ -/* - * (C) Gražvydas "notaz" Ignotas, 2009-2012 - * - * This work is licensed under the terms of any of these licenses - * (at your option): - * - GNU GPL, version 2 or later. - * - GNU LGPL, version 2.1 or later. - * See the COPYING file in the top-level directory. - */ - -#include -#include -#include - -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include - -#include "xenv.h" - -#define PFX "xenv: " - -#define FPTR(f) typeof(f) * p##f -#define FPTR_LINK(xf, dl, f) { \ - xf.p##f = dlsym(dl, #f); \ - if (xf.p##f == NULL) { \ - fprintf(stderr, "missing symbol: %s\n", #f); \ - goto fail; \ - } \ -} - -struct xstuff { - Display *display; - Window window; - FPTR(XCreateBitmapFromData); - FPTR(XCreatePixmapCursor); - FPTR(XFreePixmap); - FPTR(XOpenDisplay); - FPTR(XDisplayName); - FPTR(XCloseDisplay); - FPTR(XCreateSimpleWindow); - FPTR(XChangeWindowAttributes); - FPTR(XSelectInput); - FPTR(XMapWindow); - FPTR(XNextEvent); - FPTR(XCheckTypedEvent); - FPTR(XWithdrawWindow); - FPTR(XGrabKeyboard); - FPTR(XPending); - FPTR(XLookupKeysym); - FPTR(XkbSetDetectableAutoRepeat); - FPTR(XStoreName); - FPTR(XIconifyWindow); - FPTR(XMoveResizeWindow); - FPTR(XInternAtom); - FPTR(XSetWMHints); - FPTR(XSync); -}; - -static struct xstuff g_xstuff; - -static Cursor transparent_cursor(struct xstuff *xf, Display *display, Window win) -{ - Cursor cursor; - Pixmap pix; - XColor dummy; - char d = 0; - - memset(&dummy, 0, sizeof(dummy)); - pix = xf->pXCreateBitmapFromData(display, win, &d, 1, 1); - cursor = xf->pXCreatePixmapCursor(display, pix, pix, - &dummy, &dummy, 0, 0); - xf->pXFreePixmap(display, pix); - return cursor; -} - -static int x11h_init(int *xenv_flags, const char *window_title) -{ - unsigned int display_width, display_height; - Display *display; - XSetWindowAttributes attributes; - Window win; - Visual *visual; - long evt_mask; - void *x11lib; - int screen; - - memset(&g_xstuff, 0, sizeof(g_xstuff)); - x11lib = dlopen("libX11.so.6", RTLD_LAZY); - if (x11lib == NULL) { - fprintf(stderr, "libX11.so load failed:\n%s\n", dlerror()); - goto fail; - } - FPTR_LINK(g_xstuff, x11lib, XCreateBitmapFromData); - FPTR_LINK(g_xstuff, x11lib, XCreatePixmapCursor); - FPTR_LINK(g_xstuff, x11lib, XFreePixmap); - FPTR_LINK(g_xstuff, x11lib, XOpenDisplay); - FPTR_LINK(g_xstuff, x11lib, XDisplayName); - FPTR_LINK(g_xstuff, x11lib, XCloseDisplay); - FPTR_LINK(g_xstuff, x11lib, XCreateSimpleWindow); - FPTR_LINK(g_xstuff, x11lib, XChangeWindowAttributes); - FPTR_LINK(g_xstuff, x11lib, XSelectInput); - FPTR_LINK(g_xstuff, x11lib, XMapWindow); - FPTR_LINK(g_xstuff, x11lib, XNextEvent); - FPTR_LINK(g_xstuff, x11lib, XCheckTypedEvent); - FPTR_LINK(g_xstuff, x11lib, XWithdrawWindow); - FPTR_LINK(g_xstuff, x11lib, XGrabKeyboard); - FPTR_LINK(g_xstuff, x11lib, XPending); - FPTR_LINK(g_xstuff, x11lib, XLookupKeysym); - FPTR_LINK(g_xstuff, x11lib, XkbSetDetectableAutoRepeat); - FPTR_LINK(g_xstuff, x11lib, XStoreName); - FPTR_LINK(g_xstuff, x11lib, XIconifyWindow); - FPTR_LINK(g_xstuff, x11lib, XMoveResizeWindow); - FPTR_LINK(g_xstuff, x11lib, XInternAtom); - FPTR_LINK(g_xstuff, x11lib, XSetWMHints); - FPTR_LINK(g_xstuff, x11lib, XSync); - - //XInitThreads(); - - g_xstuff.display = display = g_xstuff.pXOpenDisplay(NULL); - if (display == NULL) - { - fprintf(stderr, "cannot connect to X server %s, X handling disabled.\n", - g_xstuff.pXDisplayName(NULL)); - goto fail2; - } - - visual = DefaultVisual(display, 0); - if (visual->class != TrueColor) - fprintf(stderr, PFX "warning: non true color visual\n"); - - printf(PFX "X vendor: %s, rel: %d, display: %s, protocol ver: %d.%d\n", ServerVendor(display), - VendorRelease(display), DisplayString(display), ProtocolVersion(display), - ProtocolRevision(display)); - - screen = DefaultScreen(display); - - display_width = DisplayWidth(display, screen); - display_height = DisplayHeight(display, screen); - printf(PFX "display is %dx%d\n", display_width, display_height); - - g_xstuff.window = win = g_xstuff.pXCreateSimpleWindow(display, - RootWindow(display, screen), 0, 0, display_width, display_height, - 0, BlackPixel(display, screen), BlackPixel(display, screen)); - - attributes.override_redirect = True; - attributes.cursor = transparent_cursor(&g_xstuff, display, win); - g_xstuff.pXChangeWindowAttributes(display, win, CWOverrideRedirect | CWCursor, &attributes); - - if (window_title != NULL) - g_xstuff.pXStoreName(display, win, window_title); - evt_mask = ExposureMask | FocusChangeMask | PropertyChangeMask; - if (xenv_flags && (*xenv_flags & XENV_CAP_KEYS)) - evt_mask |= KeyPressMask | KeyReleaseMask; - if (xenv_flags && (*xenv_flags & XENV_CAP_MOUSE)) - evt_mask |= ButtonPressMask | ButtonReleaseMask | PointerMotionMask; - g_xstuff.pXSelectInput(display, win, evt_mask); - g_xstuff.pXMapWindow(display, win); - g_xstuff.pXGrabKeyboard(display, win, False, GrabModeAsync, GrabModeAsync, CurrentTime); - g_xstuff.pXkbSetDetectableAutoRepeat(display, 1, NULL); - // XSetIOErrorHandler - - // we don't know when event dispatch will be called, so sync now - g_xstuff.pXSync(display, False); - - return 0; -fail2: - dlclose(x11lib); -fail: - g_xstuff.display = NULL; - fprintf(stderr, "x11 handling disabled.\n"); - return -1; -} - -static void x11h_update(int (*key_cb)(void *cb_arg, int kc, int is_pressed), - int (*mouseb_cb)(void *cb_arg, int x, int y, int button, int is_pressed), - int (*mousem_cb)(void *cb_arg, int x, int y), - void *cb_arg) -{ - XEvent evt; - int keysym; - - while (g_xstuff.pXPending(g_xstuff.display)) - { - g_xstuff.pXNextEvent(g_xstuff.display, &evt); - switch (evt.type) - { - case Expose: - while (g_xstuff.pXCheckTypedEvent(g_xstuff.display, Expose, &evt)) - ; - break; - - case KeyPress: - keysym = g_xstuff.pXLookupKeysym(&evt.xkey, 0); - if (key_cb != NULL) - key_cb(cb_arg, keysym, 1); - break; - - case KeyRelease: - keysym = g_xstuff.pXLookupKeysym(&evt.xkey, 0); - if (key_cb != NULL) - key_cb(cb_arg, keysym, 0); - break; - - case ButtonPress: - if (mouseb_cb != NULL) - mouseb_cb(cb_arg, evt.xbutton.x, evt.xbutton.y, - evt.xbutton.button, 1); - break; - - case ButtonRelease: - if (mouseb_cb != NULL) - mouseb_cb(cb_arg, evt.xbutton.x, evt.xbutton.y, - evt.xbutton.button, 0); - break; - - case MotionNotify: - if (mousem_cb != NULL) - mousem_cb(cb_arg, evt.xmotion.x, evt.xmotion.y); - break; - } - } -} - -static void x11h_wait_vmstate(void) -{ - Atom wm_state = g_xstuff.pXInternAtom(g_xstuff.display, "WM_STATE", False); - XEvent evt; - int i; - - usleep(20000); - - for (i = 0; i < 20; i++) { - while (g_xstuff.pXPending(g_xstuff.display)) { - g_xstuff.pXNextEvent(g_xstuff.display, &evt); - // printf("w event %d\n", evt.type); - if (evt.type == PropertyNotify && evt.xproperty.atom == wm_state) - return; - } - usleep(200000); - } - - fprintf(stderr, PFX "timeout waiting for wm_state change\n"); -} - -static int x11h_minimize(void) -{ - XSetWindowAttributes attributes; - Display *display = g_xstuff.display; - Window window = g_xstuff.window; - int screen = DefaultScreen(g_xstuff.display); - int display_width, display_height; - XWMHints wm_hints; - XEvent evt; - - g_xstuff.pXWithdrawWindow(display, window, screen); - - attributes.override_redirect = False; - g_xstuff.pXChangeWindowAttributes(display, window, - CWOverrideRedirect, &attributes); - - wm_hints.flags = StateHint; - wm_hints.initial_state = IconicState; - g_xstuff.pXSetWMHints(display, window, &wm_hints); - - g_xstuff.pXMapWindow(display, window); - - while (g_xstuff.pXNextEvent(display, &evt) == 0) - { - // printf("m event %d\n", evt.type); - switch (evt.type) - { - case FocusIn: - goto out; - default: - break; - } - } - -out: - g_xstuff.pXWithdrawWindow(display, window, screen); - - // must wait for some magic vmstate property change before setting override_redirect - x11h_wait_vmstate(); - - attributes.override_redirect = True; - g_xstuff.pXChangeWindowAttributes(display, window, - CWOverrideRedirect, &attributes); - - // fixup window after resize on override_redirect loss - display_width = DisplayWidth(display, screen); - display_height = DisplayHeight(display, screen); - g_xstuff.pXMoveResizeWindow(display, window, 0, 0, display_width, display_height); - - g_xstuff.pXMapWindow(display, window); - g_xstuff.pXGrabKeyboard(display, window, False, GrabModeAsync, GrabModeAsync, CurrentTime); - g_xstuff.pXkbSetDetectableAutoRepeat(display, 1, NULL); - - // we don't know when event dispatch will be called, so sync now - g_xstuff.pXSync(display, False); - - return 0; -} - -static struct termios g_kbd_termios_saved; -static int g_kbdfd = -1; - -static int tty_init(void) -{ - struct termios kbd_termios; - int mode; - - g_kbdfd = open("/dev/tty", O_RDWR); - if (g_kbdfd == -1) { - perror(PFX "open /dev/tty"); - return -1; - } - - if (ioctl(g_kbdfd, KDGETMODE, &mode) == -1) { - perror(PFX "(not hiding FB): KDGETMODE"); - goto fail; - } - - if (tcgetattr(g_kbdfd, &kbd_termios) == -1) { - perror(PFX "tcgetattr"); - goto fail; - } - - g_kbd_termios_saved = kbd_termios; - kbd_termios.c_lflag &= ~(ICANON | ECHO); // | ISIG); - kbd_termios.c_iflag &= ~(ISTRIP | IGNCR | ICRNL | INLCR | IXOFF | IXON); - kbd_termios.c_cc[VMIN] = 0; - kbd_termios.c_cc[VTIME] = 0; - - if (tcsetattr(g_kbdfd, TCSAFLUSH, &kbd_termios) == -1) { - perror(PFX "tcsetattr"); - goto fail; - } - - if (ioctl(g_kbdfd, KDSETMODE, KD_GRAPHICS) == -1) { - perror(PFX "KDSETMODE KD_GRAPHICS"); - tcsetattr(g_kbdfd, TCSAFLUSH, &g_kbd_termios_saved); - goto fail; - } - - return 0; - -fail: - close(g_kbdfd); - g_kbdfd = -1; - return -1; -} - -static void tty_end(void) -{ - if (g_kbdfd < 0) - return; - - if (ioctl(g_kbdfd, KDSETMODE, KD_TEXT) == -1) - perror(PFX "KDSETMODE KD_TEXT"); - - if (tcsetattr(g_kbdfd, TCSAFLUSH, &g_kbd_termios_saved) == -1) - perror(PFX "tcsetattr"); - - close(g_kbdfd); - g_kbdfd = -1; -} - -int xenv_init(int *xenv_flags, const char *window_title) -{ - int ret; - - ret = x11h_init(xenv_flags, window_title); - if (ret == 0) - goto out; - - if (xenv_flags != NULL) - *xenv_flags &= ~(XENV_CAP_KEYS | XENV_CAP_MOUSE); /* TODO? */ - ret = tty_init(); - if (ret == 0) - goto out; - - fprintf(stderr, PFX "error: both x11h_init and tty_init failed\n"); - ret = -1; -out: - return ret; -} - -int xenv_update(int (*key_cb)(void *cb_arg, int kc, int is_pressed), - int (*mouseb_cb)(void *cb_arg, int x, int y, int button, int is_pressed), - int (*mousem_cb)(void *cb_arg, int x, int y), - void *cb_arg) -{ - if (g_xstuff.display) { - x11h_update(key_cb, mouseb_cb, mousem_cb, cb_arg); - return 0; - } - - // TODO: read tty? - return -1; -} - -/* blocking minimize until user maximizes again */ -int xenv_minimize(void) -{ - int ret; - - if (g_xstuff.display) { - xenv_update(NULL, NULL, NULL, NULL); - ret = x11h_minimize(); - xenv_update(NULL, NULL, NULL, NULL); - return ret; - } - - return -1; -} - -void xenv_finish(void) -{ - // TODO: cleanup X? - tty_end(); -} - -#if 0 -int main() -{ - int i, r, d; - - xenv_init("just a test"); - - for (i = 0; i < 5; i++) { - while ((r = xenv_update(&d)) > 0) - printf("%d %x %d\n", d, r, r); - sleep(1); - - if (i == 1) - xenv_minimize(); - printf("ll %d\n", i); - } - - printf("xenv_finish..\n"); - xenv_finish(); - - return 0; -} -#endif diff --git a/frontend/linux/xenv.h b/frontend/linux/xenv.h deleted file mode 100644 index 6abda195..00000000 --- a/frontend/linux/xenv.h +++ /dev/null @@ -1,18 +0,0 @@ - -#define XENV_CAP_KEYS (1<<0) -#define XENV_CAP_MOUSE (1<<1) - -/* xenv_flags specify if we need keys and mouse, - * on return, flag is removed if input is not available */ -int xenv_init(int *xenv_flags, const char *window_title); - -/* read events from X, calling key_cb for key, mouseb_cb for mouse button - * and mousem_cb for mouse motion events */ -int xenv_update(int (*key_cb)(void *cb_arg, int kc, int is_pressed), - int (*mouseb_cb)(void *cb_arg, int x, int y, int button, int is_pressed), - int (*mousem_cb)(void *cb_arg, int x, int y), - void *cb_arg); - -int xenv_minimize(void); -void xenv_finish(void); - diff --git a/frontend/main.c b/frontend/main.c index 56b5cb76..24e1f12a 100644 --- a/frontend/main.c +++ b/frontend/main.c @@ -25,12 +25,14 @@ #include "../libpcsxcore/cheat.h" #include "../libpcsxcore/new_dynarec/new_dynarec.h" #include "../plugins/cdrcimg/cdrcimg.h" -#include "common/plat.h" -#include "common/readpng.h" -#include "common/input.h" -#include "linux/in_evdev.h" #include "revision.h" +#ifndef NO_FRONTEND +#include "libpicofe/input.h" +#include "libpicofe/plat.h" +#include "libpicofe/readpng.h" +#endif + // don't include debug.h - it breaks ARM build (R1 redefined) void StartDebugger(); void StopDebugger(); @@ -262,7 +264,7 @@ do_state_slot: } case SACTION_VOLUME_UP: case SACTION_VOLUME_DOWN: - plat_step_volume(emu_action == SACTION_VOLUME_UP); + plat_target_step_volume(emu_action == SACTION_VOLUME_UP); return; case SACTION_MINIMIZE: if (GPU_close != NULL) diff --git a/frontend/menu.c b/frontend/menu.c index d3ce06c3..a93c8f08 100644 --- a/frontend/menu.c +++ b/frontend/menu.c @@ -24,9 +24,10 @@ #include "plugin_lib.h" #include "plat.h" #include "pcnt.h" -#include "common/plat.h" -#include "common/input.h" -#include "linux/in_evdev.h" +#include "libpicofe/plat.h" +#include "libpicofe/input.h" +#include "libpicofe/linux/in_evdev.h" +#include "libpicofe/plat.h" #include "../libpcsxcore/misc.h" #include "../libpcsxcore/cdrom.h" #include "../libpcsxcore/cdriso.h" @@ -74,8 +75,9 @@ typedef enum MA_OPT_DISP_OPTS, MA_OPT_SCALER, MA_OPT_SCALER2, - MA_OPT_FILTERING, - MA_OPT_FILTERING2, + MA_OPT_HWFILTER, + MA_OPT_SWFILTER, + MA_OPT_GAMMA, MA_OPT_SCALER_C, } menu_id; @@ -86,7 +88,7 @@ static char last_selected_fname[MAXPATHLEN]; static int warned_about_bios, region, in_type_sel1, in_type_sel2; static int psx_clock; static int memcard1_sel, memcard2_sel; -int g_opts, g_scaler; +int g_opts, g_scaler, g_gamma = 100; int soft_scaling, analog_deadzone; // for Caanoo int filter, soft_filter; @@ -557,9 +559,7 @@ static const char *filter_exts[] = { #define MENU_X2 0 #endif -#define menu_init menu_init_common -#include "common/menu.c" -#undef menu_init +#include "libpicofe/menu.c" // a bit of black magic here static void draw_savestate_bg(int slot) @@ -970,9 +970,9 @@ static const char *mgn_saveloadcfg(int id, int *offs) static int mh_savecfg(int id, int keys) { if (menu_write_config(id == MA_OPT_SAVECFG_GAME ? 1 : 0) == 0) - me_update_msg("config saved"); + menu_update_msg("config saved"); else - me_update_msg("failed to write config"); + menu_update_msg("failed to write config"); return 1; } @@ -981,7 +981,7 @@ static int mh_input_rescan(int id, int keys) { //menu_sync_config(); in_probe(); - me_update_msg("rescan complete."); + menu_update_msg("rescan complete."); return 0; } @@ -1044,6 +1044,7 @@ static const char *men_dummy[] = { NULL }; static const char h_cscaler[] = "Displays the scaler layer, you can resize it\n" "using d-pad or move it using R+d-pad"; static const char h_soft_filter[] = "Works only if game uses low resolution modes"; +static const char h_gamma[] = "Gamma/brightness adjustment (default 100)"; static int menu_loop_cscaler(int id, int keys) { @@ -1055,7 +1056,7 @@ static int menu_loop_cscaler(int id, int keys) for (;;) { - menu_draw_begin(0); + menu_draw_begin(0, 1); memset(g_menuscreen_ptr, 4, g_menuscreen_w * g_menuscreen_h * 2); text_out16(2, 2, "%d,%d", g_layer_x, g_layer_y); text_out16(2, 480 - 18, "%dx%d | d-pad: resize, R+d-pad: move", g_layer_w, g_layer_h); @@ -1101,8 +1102,9 @@ static menu_entry e_menu_gfx_options[] = { mee_enum ("Scaler", MA_OPT_SCALER, g_scaler, men_scaler), mee_onoff ("Software Scaling", MA_OPT_SCALER2, soft_scaling, 1), - mee_enum ("Filter", MA_OPT_FILTERING, filter, men_dummy), - mee_enum_h ("Software Filter", MA_OPT_FILTERING2, soft_filter, men_soft_filter, h_soft_filter), + mee_enum ("Hardware Filter", MA_OPT_HWFILTER, filter, men_dummy), + mee_enum_h ("Software Filter", MA_OPT_SWFILTER, soft_filter, men_soft_filter, h_soft_filter), + mee_range_h ("Gamma adjustment", MA_OPT_GAMMA, g_gamma, 1, 200, h_gamma), // mee_onoff ("Vsync", 0, vsync, 1), mee_cust_h ("Setup custom scaler", MA_OPT_SCALER_C, menu_loop_cscaler, NULL, h_cscaler), mee_end, @@ -1117,16 +1119,6 @@ static int menu_loop_gfx_options(int id, int keys) return 0; } -// XXX -void menu_set_filter_list(void *filters) -{ - int i; - - i = me_id2offset(e_menu_gfx_options, MA_OPT_FILTERING); - e_menu_gfx_options[i].data = filters; - me_enable(e_menu_gfx_options, MA_OPT_FILTERING, filters != NULL); -} - // ------------ bios/plugins ------------ #ifdef __ARM_NEON__ @@ -1384,7 +1376,7 @@ static int menu_loop_adv_options(int id, int keys) static int mh_restore_defaults(int id, int keys) { menu_set_defconfig(); - me_update_msg("defaults restored"); + menu_update_msg("defaults restored"); return 1; } @@ -1466,7 +1458,7 @@ static void debug_menu_loop(void) while (1) { - menu_draw_begin(0); + menu_draw_begin(0, 1); draw_frame_debug(gpuf, df_x, df_y); menu_draw_end(); @@ -1518,7 +1510,7 @@ static void draw_mc_bg(void) GetMcdBlockInfo(2, i + 1, &blocks2[i]); } - menu_draw_begin(1); + menu_draw_begin(1, 1); memcpy(g_menuscreen_ptr, g_menubg_src_ptr, g_menuscreen_w * g_menuscreen_h * 2); @@ -1599,7 +1591,7 @@ static void draw_cheatlist(int sel) max_cnt = g_menuscreen_h / me_sfont_h; start = max_cnt / 2 - sel; - menu_draw_begin(1); + menu_draw_begin(1, 1); for (i = 0; i < NumCheats; i++) { pos = start + i; @@ -1702,7 +1694,7 @@ static void draw_frame_main(void) } if (ready_to_go) { - capacity = plat_get_bat_capacity(); + capacity = plat_target_bat_capacity_get(); ltime = time(NULL); tmp = localtime(<ime); strftime(ltime_s, sizeof(ltime_s), "%H:%M", tmp); @@ -1763,7 +1755,7 @@ static int reload_plugins(const char *cdimg) pcnt_hook_plugins(); NetOpened = 0; if (OpenPlugins() == -1) { - me_update_msg("failed to open plugins"); + menu_update_msg("failed to open plugins"); return -1; } plugin_call_rearmed_cbs(); @@ -1803,7 +1795,7 @@ static int run_exe(void) SysReset(); if (Load(fname) != 0) { - me_update_msg("exe load failed, bad file?"); + menu_update_msg("exe load failed, bad file?"); printf("meh\n"); return -1; } @@ -1823,7 +1815,7 @@ static int run_cd_image(const char *fname) if (CheckCdrom() == -1) { // Only check the CD if we are starting the console with a CD ClosePlugins(); - me_update_msg("unsupported/invalid CD image"); + menu_update_msg("unsupported/invalid CD image"); return -1; } @@ -1832,7 +1824,7 @@ static int run_cd_image(const char *fname) // Read main executable directly from CDRom and start it if (LoadCdrom() == -1) { ClosePlugins(); - me_update_msg("failed to load CD image"); + menu_update_msg("failed to load CD image"); return -1; } @@ -1891,11 +1883,11 @@ static int swap_cd_image(void) set_cd_image(fname); if (ReloadCdromPlugin() < 0) { - me_update_msg("failed to load cdr plugin"); + menu_update_msg("failed to load cdr plugin"); return -1; } if (CDR_open() < 0) { - me_update_msg("failed to open cdr plugin"); + menu_update_msg("failed to open cdr plugin"); return -1; } @@ -1914,7 +1906,7 @@ static int swap_cd_multidisk(void) CDR_close(); if (CDR_open() < 0) { - me_update_msg("failed to open cdr plugin"); + menu_update_msg("failed to open cdr plugin"); return -1; } @@ -1938,10 +1930,10 @@ static void load_pcsx_cht(void) LoadCheats(fname); if (NumCheats == 0 && NumCodes == 0) - me_update_msg("failed to load cheats"); + menu_update_msg("failed to load cheats"); else { snprintf(path, sizeof(path), "%d cheat(s) loaded", NumCheats + NumCodes); - me_update_msg(path); + menu_update_msg(path); } me_enable(e_menu_main, MA_MAIN_CHEATS, ready_to_go && NumCheats); } @@ -2240,13 +2232,14 @@ do_memcards: void menu_init(void) { char buff[MAXPATHLEN]; + int i; strcpy(last_selected_fname, "/media"); - cpu_clock_st = cpu_clock = plat_cpu_clock_get(); + cpu_clock_st = cpu_clock = plat_target_cpu_clock_get(); scan_bios_plugins(); - menu_init_common(); + menu_init_base(); menu_set_defconfig(); menu_load_config(0); @@ -2265,11 +2258,22 @@ void menu_init(void) emu_make_path(buff, "skin/background.png", sizeof(buff)); readpng(g_menubg_src_ptr, buff, READPNG_BG, g_menuscreen_w, g_menuscreen_h); + i = plat_target.cpu_clock_set != NULL + && plat_target.cpu_clock_get != NULL && cpu_clock_st > 0; + me_enable(e_menu_gfx_options, MA_OPT_CPU_CLOCKS, i); + + i = me_id2offset(e_menu_gfx_options, MA_OPT_HWFILTER); + e_menu_gfx_options[i].data = plat_target.hwfilters; + me_enable(e_menu_gfx_options, MA_OPT_HWFILTER, + plat_target.hwfilters != NULL); + + me_enable(e_menu_gfx_options, MA_OPT_GAMMA, + plat_target.gamma_set != NULL); + #ifndef __ARM_ARCH_7A__ /* XXX */ me_enable(e_menu_gfx_options, MA_OPT_SCALER, 0); - me_enable(e_menu_gfx_options, MA_OPT_FILTERING, 0); - me_enable(e_menu_gfx_options, MA_OPT_FILTERING2, 0); me_enable(e_menu_gfx_options, MA_OPT_SCALER_C, 0); + me_enable(e_menu_gfx_options, MA_OPT_SWFILTER, 0); me_enable(e_menu_keyconfig, MA_CTRL_NUBS_BTNS, 0); #else me_enable(e_menu_gfx_options, MA_OPT_SCALER2, 0); @@ -2317,7 +2321,7 @@ static void menu_leave_emu(void) } if (ready_to_go) - cpu_clock = plat_cpu_clock_get(); + cpu_clock = plat_target_cpu_clock_get(); } void menu_prepare_emu(void) @@ -2338,7 +2342,7 @@ void menu_prepare_emu(void) menu_sync_config(); if (cpu_clock > 0) - plat_cpu_clock_apply(cpu_clock); + plat_target_cpu_clock_set(cpu_clock); // push config to GPU plugin plugin_call_rearmed_cbs(); @@ -2352,7 +2356,7 @@ void menu_prepare_emu(void) dfinput_activate(); } -void me_update_msg(const char *msg) +void menu_update_msg(const char *msg) { strncpy(menu_error_msg, msg, sizeof(menu_error_msg)); menu_error_msg[sizeof(menu_error_msg) - 1] = 0; @@ -2363,5 +2367,6 @@ void me_update_msg(const char *msg) void menu_finish(void) { - plat_cpu_clock_apply(cpu_clock_st); + if (cpu_clock_st > 0) + plat_target_cpu_clock_set(cpu_clock_st); } diff --git a/frontend/menu.h b/frontend/menu.h index 221be15c..3c09abe1 100644 --- a/frontend/menu.h +++ b/frontend/menu.h @@ -4,7 +4,6 @@ void menu_loop(void); void menu_finish(void); void menu_notify_mode_change(int w, int h, int bpp); -void menu_set_filter_list(void *filters); enum g_opts_opts { OPT_SHOWFPS = 1 << 0, @@ -28,7 +27,7 @@ enum g_soft_filter_opts { SOFT_FILTER_EAGLE2X, }; -extern int g_opts, g_scaler; +extern int g_opts, g_scaler, g_gamma; extern int soft_scaling, analog_deadzone; extern int filter, soft_filter; diff --git a/frontend/plat.h b/frontend/plat.h index db66c57f..6b0cd65b 100644 --- a/frontend/plat.h +++ b/frontend/plat.h @@ -1,9 +1,7 @@ +void plat_init(void); +void plat_finish(void); void plat_minimize(void); void *plat_prepare_screenshot(int *w, int *h, int *bpp); -void plat_step_volume(int is_up); -int plat_cpu_clock_get(void); -int plat_cpu_clock_apply(int cpu_clock); -int plat_get_bat_capacity(void); // indirectly called from GPU plugin void plat_gvideo_open(int is_pal); diff --git a/frontend/plat_omap.c b/frontend/plat_omap.c index e5b6c04e..6126140a 100644 --- a/frontend/plat_omap.c +++ b/frontend/plat_omap.c @@ -14,10 +14,10 @@ #include #include -#include "common/menu.h" -#include "common/input.h" -#include "linux/fbdev.h" -#include "linux/xenv.h" +#include "libpicofe/menu.h" +#include "libpicofe/input.h" +#include "libpicofe/linux/fbdev.h" +#include "libpicofe/linux/xenv.h" #include "plugin_lib.h" #include "pl_gun_ts.h" #include "plat.h" diff --git a/frontend/plat_pandora.c b/frontend/plat_pandora.c index b82450c6..694bb7e7 100644 --- a/frontend/plat_pandora.c +++ b/frontend/plat_pandora.c @@ -6,42 +6,16 @@ */ #include -#include -#include -#include -#include -#include -#include -#include #include -#include -#include -#include "common/input.h" -#include "linux/in_evdev.h" +#include "libpicofe/input.h" +#include "libpicofe/linux/in_evdev.h" +#include "libpicofe/plat.h" #include "plugin_lib.h" -#include "plat.h" #include "plat_omap.h" #include "main.h" #include "menu.h" -static const char * const pandora_gpio_keys[KEY_MAX + 1] = { - [0 ... KEY_MAX] = NULL, - [KEY_UP] = "Up", - [KEY_LEFT] = "Left", - [KEY_RIGHT] = "Right", - [KEY_DOWN] = "Down", - [KEY_HOME] = "(A)", - [KEY_PAGEDOWN] = "(X)", - [KEY_END] = "(B)", - [KEY_PAGEUP] = "(Y)", - [KEY_RIGHTSHIFT]= "(L)", - [KEY_RIGHTCTRL] = "(R)", - [KEY_LEFTALT] = "Start", - [KEY_LEFTCTRL] = "Select", - [KEY_MENU] = "Pandora", -}; - static const struct in_default_bind in_evdev_defbinds[] = { { KEY_UP, IN_BINDTYPE_PLAYER12, DKEY_UP }, { KEY_DOWN, IN_BINDTYPE_PLAYER12, DKEY_DOWN }, @@ -69,190 +43,36 @@ static const struct in_default_bind in_evdev_defbinds[] = { { 0, 0, 0 } }; -static const char pnd_script_base[] = "sudo -n /usr/pandora/scripts"; -static char **pnd_filter_list; - -static void scan_for_filters(void) -{ - struct dirent *ent; - int i, count = 0; - char **mfilters; - char buff[64]; - DIR *dir; - - dir = opendir("/etc/pandora/conf/dss_fir"); - if (dir == NULL) { - perror("filter opendir"); - return; - } - - while (1) { - errno = 0; - ent = readdir(dir); - if (ent == NULL) { - if (errno != 0) - perror("readdir"); - break; - } - - if (ent->d_type != DT_REG && ent->d_type != DT_LNK) - continue; - - count++; - } - - if (count == 0) - return; - - mfilters = calloc(count + 1, sizeof(mfilters[0])); - if (mfilters == NULL) - return; - - rewinddir(dir); - for (i = 0; (ent = readdir(dir)); ) { - size_t len; - - if (ent->d_type != DT_REG && ent->d_type != DT_LNK) - continue; - - len = strlen(ent->d_name); - - // skip pre-HF5 extra files - if (len >= 3 && strcmp(ent->d_name + len - 3, "_v3") == 0) - continue; - if (len >= 3 && strcmp(ent->d_name + len - 3, "_v5") == 0) - continue; - - // have to cut "_up_h" for pre-HF5 - if (len > 5 && strcmp(ent->d_name + len - 5, "_up_h") == 0) - len -= 5; - - if (len > sizeof(buff) - 1) - continue; - - strncpy(buff, ent->d_name, len); - buff[len] = 0; - mfilters[i] = strdup(buff); - if (mfilters[i] != NULL) - i++; - } - closedir(dir); - - pnd_filter_list = mfilters; - menu_set_filter_list((void *)mfilters); -} - int plat_init(void) { - int gpiokeys_id; - plat_omap_init(); + plat_target_init(); in_evdev_init(in_evdev_defbinds); in_probe(); - gpiokeys_id = in_name_to_id("evdev:gpio-keys"); - in_set_config(gpiokeys_id, IN_CFG_KEY_NAMES, - pandora_gpio_keys, sizeof(pandora_gpio_keys)); - in_set_config(gpiokeys_id, IN_CFG_DEFAULT_DEV, NULL, 0); + plat_target_setup_input(); + in_adev[0] = in_name_to_id("evdev:nub0"); in_adev[1] = in_name_to_id("evdev:nub1"); - scan_for_filters(); - return 0; } void plat_finish(void) { plat_omap_finish(); -} - -static void apply_lcdrate(int pal) -{ - char buf[128]; - - snprintf(buf, sizeof(buf), "%s/op_lcdrate.sh %d", - pnd_script_base, pal ? 50 : 60); - system(buf); -} - -static void apply_filter(int which) -{ - char buf[128]; - int i; - - if (pnd_filter_list == NULL) - return; - - for (i = 0; i < which; i++) - if (pnd_filter_list[i] == NULL) - return; - - if (pnd_filter_list[i] == NULL) - return; - - snprintf(buf, sizeof(buf), "%s/op_videofir.sh %s", - pnd_script_base, pnd_filter_list[i]); - system(buf); + plat_target_finish(); } void plat_gvideo_open(int is_pal) { - static int old_pal = -1, old_filter = -1; - - if (is_pal != old_pal) { - apply_lcdrate(is_pal); - old_pal = is_pal; - } - if (filter != old_filter) { - apply_filter(filter); - old_filter = filter; - } + plat_target_lcdrate_set(is_pal); + plat_target_hwfilter_set(filter); + plat_target_gamma_set(g_gamma, 0); plat_omap_gvideo_open(); } -int plat_cpu_clock_get(void) -{ - FILE *f; - int ret = 0; - f = fopen("/proc/pandora/cpu_mhz_max", "r"); - if (f) { - fscanf(f, "%d", &ret); - fclose(f); - } - return ret; -} - -int plat_cpu_clock_apply(int cpu_clock) -{ - char buf[128]; - - if (cpu_clock != 0 && cpu_clock != plat_cpu_clock_get()) { - snprintf(buf, sizeof(buf), "unset DISPLAY; echo y | %s/op_cpuspeed.sh %d", - pnd_script_base, cpu_clock); - system(buf); - } - return 0; -} - -int plat_get_bat_capacity(void) -{ - FILE *f; - int ret = 0; - f = fopen("/sys/class/power_supply/bq27500-0/capacity", "r"); - if (f) { - fscanf(f, "%d", &ret); - fclose(f); - } - return ret; -} - -void plat_step_volume(int is_up) -{ -} - void plat_trigger_vibrate(int is_strong) { } - diff --git a/frontend/plat_pollux.c b/frontend/plat_pollux.c index 52a09b14..32af9a6f 100644 --- a/frontend/plat_pollux.c +++ b/frontend/plat_pollux.c @@ -18,10 +18,12 @@ #include #include -#include "common/input.h" -#include "gp2x/in_gp2x.h" -#include "linux/in_evdev.h" -#include "common/menu.h" +#include "libpicofe/plat.h" +#include "libpicofe/input.h" +#include "libpicofe/gp2x/in_gp2x.h" +#include "libpicofe/gp2x/soc_pollux.h" +#include "libpicofe/linux/in_evdev.h" +#include "libpicofe/menu.h" #include "warm/warm.h" #include "plugin_lib.h" #include "pl_gun_ts.h" @@ -33,16 +35,12 @@ #include "pcnt.h" #include "../plugins/gpulib/cspace.h" -int gp2x_dev_id; -static int fbdev = -1, memdev = -1, battdev = -1, mixerdev = -1; -static volatile unsigned short *memregs; -static volatile unsigned int *memregl; +static int fbdev = -1; static void *fb_vaddrs[2]; static unsigned int fb_paddrs[2]; static int fb_work_buf; -static int cpu_clock_allowed, have_warm; -static unsigned int saved_video_regs[2][6]; +static int have_warm; #define FB_VRAM_SIZE (320*240*2*2*2) // 2 buffers with space for 24bpp mode static unsigned short *psx_vram; @@ -123,88 +121,20 @@ static void pollux_changemode(int bpp, int is_bgr) memregl[0x4458>>2] = r; } -/* note: both PLLs are programmed the same way, - * the databook incorrectly states that PLL1 differs */ -static int decode_pll(unsigned int reg) +static int cpu_clock_wrapper(int mhz) { - long long v; - int p, m, s; - - p = (reg >> 18) & 0x3f; - m = (reg >> 8) & 0x3ff; - s = reg & 0xff; - - if (p == 0) - p = 1; - - v = 27000000; // master clock - v = v * m / (p << s); - return v; -} - -int plat_cpu_clock_get(void) -{ - return decode_pll(memregl[0xf004>>2]) / 1000000; -} - -int plat_cpu_clock_apply(int mhz) -{ - int adiv, mdiv, pdiv, sdiv = 0; - int i, vf000, vf004; - - if (!cpu_clock_allowed) - return -1; - if (mhz == plat_cpu_clock_get()) - return 0; - - // m = MDIV, p = PDIV, s = SDIV - #define SYS_CLK_FREQ 27 - pdiv = 9; - mdiv = (mhz * pdiv) / SYS_CLK_FREQ; - if (mdiv & ~0x3ff) - return -1; - vf004 = (pdiv<<18) | (mdiv<<8) | sdiv; - - // attempt to keep the AHB divider close to 250, but not higher - for (adiv = 1; mhz / adiv > 250; adiv++) - ; - - vf000 = memregl[0xf000>>2]; - vf000 = (vf000 & ~0x3c0) | ((adiv - 1) << 6); - memregl[0xf000>>2] = vf000; - memregl[0xf004>>2] = vf004; - memregl[0xf07c>>2] |= 0x8000; - for (i = 0; (memregl[0xf07c>>2] & 0x8000) && i < 0x100000; i++) - ; - - printf("clock set to %dMHz, AHB set to %dMHz\n", mhz, mhz / adiv); - // stupid pll share hack - must restart audio + int pollux_cpu_clock_set(int cpu_clock); extern long SPUopen(void); extern long SPUclose(void); + + pollux_cpu_clock_set(mhz); SPUclose(); SPUopen(); return 0; } -int plat_get_bat_capacity(void) -{ - unsigned short magic_val = 0; - - if (battdev < 0) - return -1; - if (read(battdev, &magic_val, sizeof(magic_val)) != sizeof(magic_val)) - return -1; - switch (magic_val) { - default: - case 1: return 100; - case 2: return 66; - case 3: return 40; - case 4: return 0; - } -} - #define TIMER_BASE3 0x1980 #define TIMER_REG(x) memregl[(TIMER_BASE3 + x) >> 2] @@ -214,15 +144,6 @@ static __attribute__((unused)) unsigned int timer_get(void) return TIMER_REG(0); } -static void timer_cleanup(void) -{ - TIMER_REG(0x40) = 0x0c; /* be sure clocks are on */ - TIMER_REG(0x08) = 0x23; /* stop the timer, clear irq in case it's pending */ - TIMER_REG(0x00) = 0; /* clear counter */ - TIMER_REG(0x40) = 0; /* clocks off */ - TIMER_REG(0x44) = 0; /* dividers back to default */ -} - void plat_video_menu_enter(int is_rom_loaded) { if (pl_vout_buf != NULL) { @@ -476,48 +397,13 @@ void plat_gvideo_close(void) { } -static void save_multiple_regs(unsigned int *dest, int base, int count) -{ - const volatile unsigned int *regs = memregl + base / 4; - int i; - - for (i = 0; i < count; i++) - dest[i] = regs[i]; -} - -static void restore_multiple_regs(int base, const unsigned int *src, int count) -{ - volatile unsigned int *regs = memregl + base / 4; - int i; - - for (i = 0; i < count; i++) - regs[i] = src[i]; -} - void plat_init(void) { const char *main_fb_name = "/dev/fb0"; struct fb_fix_screeninfo fbfix; - int rate, timer_div, timer_div2; - int fbdev, ret, warm_ret; - FILE *f; - - memdev = open("/dev/mem", O_RDWR); - if (memdev == -1) { - perror("open(/dev/mem) failed"); - exit(1); - } - - memregs = mmap(0, 0x20000, PROT_READ|PROT_WRITE, MAP_SHARED, memdev, 0xc0000000); - if (memregs == MAP_FAILED) { - perror("mmap(memregs) failed"); - exit(1); - } - memregl = (volatile void *)memregs; + int ret; - // save video regs of both MLCs - save_multiple_regs(saved_video_regs[0], 0x4058, ARRAY_SIZE(saved_video_regs[0])); - save_multiple_regs(saved_video_regs[1], 0x4458, ARRAY_SIZE(saved_video_regs[1])); + plat_target_init(); fbdev = open(main_fb_name, O_RDWR); if (fbdev == -1) { @@ -544,71 +430,19 @@ void plat_init(void) fb_vaddrs[1] = (char *)fb_vaddrs[0] + 320*240*4; memset(fb_vaddrs[0], 0, FB_VRAM_SIZE); + pollux_changemode(16, 0); g_menuscreen_w = 320; g_menuscreen_h = 240; g_menuscreen_ptr = fb_flip(); - warm_ret = warm_init(); - have_warm = warm_ret == 0; + ret = warm_init(); + have_warm = (ret == 0); warm_change_cb_upper(WCB_B_BIT, 1); - /* some firmwares have sys clk on PLL0, we can't adjust CPU clock - * by reprogramming the PLL0 then, as it overclocks system bus */ - if ((memregl[0xf000>>2] & 0x03000030) == 0x01000000) - cpu_clock_allowed = 1; - else { - cpu_clock_allowed = 0; - fprintf(stderr, "unexpected PLL config (%08x), overclocking disabled\n", - memregl[0xf000>>2]); - } - - /* find what PLL1 runs at, for the timer */ - rate = decode_pll(memregl[0xf008>>2]); - printf("PLL1 @ %dHz\n", rate); - - /* setup timer */ - timer_div = (rate + 500000) / 1000000; - timer_div2 = 0; - while (timer_div > 256) { - timer_div /= 2; - timer_div2++; - } - if (1 <= timer_div && timer_div <= 256 && timer_div2 < 4) { - int timer_rate = (rate >> timer_div2) / timer_div; - if (TIMER_REG(0x08) & 8) { - fprintf(stderr, "warning: timer in use, overriding!\n"); - timer_cleanup(); - } - if (timer_rate != 1000000) - fprintf(stderr, "warning: timer drift %d us\n", timer_rate - 1000000); - - timer_div2 = (timer_div2 + 3) & 3; - TIMER_REG(0x44) = ((timer_div - 1) << 4) | 2; /* using PLL1 */ - TIMER_REG(0x40) = 0x0c; /* clocks on */ - TIMER_REG(0x08) = 0x68 | timer_div2; /* run timer, clear irq, latch value */ - } - else - fprintf(stderr, "warning: could not make use of timer\n"); - /* setup DMA */ DMA_REG(0x0c) = 0x20000; // pending IRQ clear - battdev = open("/dev/pollux_batt", O_RDONLY); - if (battdev < 0) - perror("Warning: could't open pollux_batt"); - - f = fopen("/dev/accel", "rb"); - if (f) { - printf("detected Caanoo\n"); - gp2x_dev_id = GP2X_DEV_CAANOO; - fclose(f); - } - else { - printf("detected Wiz\n"); - gp2x_dev_id = GP2X_DEV_WIZ; - } - in_tsbutton_init(); in_evdev_init(in_evdev_defbinds); if (gp2x_dev_id == GP2X_DEV_CAANOO) @@ -616,10 +450,6 @@ void plat_init(void) else wiz_init(); - mixerdev = open("/dev/mixer", O_RDWR); - if (mixerdev == -1) - perror("open(/dev/mixer)"); - pl_rearmed_cbs.pl_vout_flip = have_warm ? raw_flip_dma : raw_flip_soft; pl_rearmed_cbs.pl_vout_set_raw_vram = pl_vout_set_raw_vram; @@ -629,27 +459,19 @@ void plat_init(void) pl_rearmed_cbs.screen_w = 320; pl_rearmed_cbs.screen_h = 240; + + plat_target_setup_input(); + + plat_target.cpu_clock_set = cpu_clock_wrapper; } void plat_finish(void) { warm_finish(); - timer_cleanup(); - memset(fb_vaddrs[0], 0, FB_VRAM_SIZE); - restore_multiple_regs(0x4058, saved_video_regs[0], ARRAY_SIZE(saved_video_regs[0])); - restore_multiple_regs(0x4458, saved_video_regs[1], ARRAY_SIZE(saved_video_regs[1])); - memregl[0x4058>>2] |= 0x10; - memregl[0x4458>>2] |= 0x10; munmap(fb_vaddrs[0], FB_VRAM_SIZE); close(fbdev); - - if (battdev >= 0) - close(battdev); - if (mixerdev >= 0) - close(mixerdev); - munmap((void *)memregs, 0x20000); - close(memdev); + plat_target_finish(); } /* WIZ RAM lack workaround */ @@ -822,30 +644,6 @@ static const struct in_default_bind in_gp2x_defbinds[] = { 0, 0, 0 }, }; -void plat_step_volume(int is_up) -{ - static int volume = 50; - int ret, val; - - if (mixerdev < 0) - return; - - if (is_up) { - volume += 5; - if (volume > 255) volume = 255; - } - else { - volume -= 5; - if (volume < 0) volume = 0; - } - val = volume; - val |= val << 8; - - ret = ioctl(mixerdev, SOUND_MIXER_WRITE_PCM, &val); - if (ret == -1) - perror("WRITE_PCM"); -} - // unused dummy for in_gp2x volatile unsigned short *gp2x_memregs; diff --git a/frontend/plat_sdl.c b/frontend/plat_sdl.c index 08afd70d..b5d1c86c 100644 --- a/frontend/plat_sdl.c +++ b/frontend/plat_sdl.c @@ -10,9 +10,10 @@ #include #include -#include "common/input.h" -#include "common/in_sdl.h" -#include "common/menu.h" + +#include "libpicofe/input.h" +#include "libpicofe/in_sdl.h" +#include "libpicofe/menu.h" #include "plugin_lib.h" #include "main.h" #include "plat.h" diff --git a/frontend/plugin_lib.c b/frontend/plugin_lib.c index 3ee59472..79f41fed 100644 --- a/frontend/plugin_lib.c +++ b/frontend/plugin_lib.c @@ -17,18 +17,17 @@ #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 "common/plat.h" #include "menu.h" #include "main.h" #include "plat.h" #include "pcnt.h" #include "pl_gun_ts.h" -#include "libpicofe/arm/neon_scale2x.h" -#include "libpicofe/arm/neon_eagle2x.h" #include "../libpcsxcore/new_dynarec/new_dynarec.h" #include "../libpcsxcore/psemu_plugin_defs.h" #include "../plugins/gpulib/cspace.h" @@ -249,6 +248,8 @@ static void pl_vout_flip(const void *vram, int stride, int bgr24, int w, int h) int dstride = pl_vout_w, h1 = h; int doffs; + pcnt_start(PCNT_BLIT); + if (dest == NULL) goto out; @@ -312,6 +313,8 @@ static void pl_vout_flip(const void *vram, int stride, int bgr24, int w, int h) 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++; diff --git a/maemo/hildon.c b/maemo/hildon.c index 4458aa7d..43e3e15e 100644 --- a/maemo/hildon.c +++ b/maemo/hildon.c @@ -4,12 +4,12 @@ #include #include #include -#include "plugin_lib.h" +#include "plugin_lib.h" #include "main.h" #include "plat.h" #include "../libpcsxcore/psemu_plugin_defs.h" -#include "common/readpng.h" +#include "libpicofe/readpng.h" #include "maemo_common.h" #define X_RES 800 diff --git a/maemo/main.c b/maemo/main.c index 2da693d0..4ffd1ab7 100644 --- a/maemo/main.c +++ b/maemo/main.c @@ -21,6 +21,9 @@ int g_opts = OPT_SHOWFPS; int g_maemo_opts; +int g_scaler, soft_filter; +int g_menuscreen_w, g_menuscreen_h; + char file_name[MAXPATHLEN]; enum sched_action emu_action; @@ -53,7 +56,10 @@ int main(int argc, char **argv) strcpy(Config.PluginsDir, "/opt/maemo/usr/games/plugins"); snprintf(Config.PatchesDir, sizeof(Config.PatchesDir), "/opt/maemo/usr/games" PATCHES_DIR); Config.PsxAuto = 1; - + + g_menuscreen_w = 800; + g_menuscreen_h = 480; + pl_init(); emu_core_init();