From e743be2070a13d14cae39a55b815b62b0edb6776 Mon Sep 17 00:00:00 2001 From: notaz Date: Sat, 22 Jun 2013 19:16:08 +0300 Subject: [PATCH] start new makefile, migrate to libpicofe --- .gitignore | 3 + Makefile | 77 ++ cpu/debug.h | 2 +- pico/32x/memory.c | 2 +- pico/cart.c | 2 +- pico/pico.h | 2 +- pico/sound/sound.c | 1 + platform/common/arm_linux.S | 26 - platform/common/arm_linux.h | 1 - platform/common/common.mak | 34 +- platform/common/config.c | 8 +- platform/common/emu.c | 47 +- platform/common/emu.h | 28 + platform/common/fonts.c | 218 ------ platform/common/fonts.h | 4 - platform/common/in_sdl.c | 467 ------------ platform/common/in_sdl.h | 3 - platform/common/input.c | 991 ------------------------- platform/common/input.h | 140 ---- platform/common/input_pico.h | 33 + platform/common/lprintf.h | 10 - platform/common/main.c | 12 +- platform/common/menu.c | 1327 ---------------------------------- platform/common/menu.h | 132 ---- platform/common/menu_pico.c | 61 +- platform/common/menu_pico.h | 12 + platform/common/plat.h | 62 -- platform/common/posix.h | 23 - platform/common/readpng.c | 266 ------- platform/common/readpng.h | 19 - platform/common/revision.mak | 12 - platform/libpicofe | 2 +- platform/linux/Makefile | 97 --- platform/linux/emu.c | 6 +- platform/linux/fbdev.c | 311 -------- platform/linux/fbdev.h | 14 - platform/linux/in_evdev.c | 655 ----------------- platform/linux/io.c | 8 +- platform/linux/plat.c | 209 ------ platform/linux/sndout_oss.c | 175 ----- platform/linux/sndout_oss.h | 9 - platform/linux/xenv.c | 455 ------------ platform/linux/xenv.h | 18 - platform/win32/direct.cpp | 410 ----------- platform/win32/direct.h | 15 - platform/win32/dsnd.cpp | 165 ----- platform/win32/dsnd.h | 14 - 47 files changed, 246 insertions(+), 6342 deletions(-) create mode 100644 Makefile delete mode 100644 platform/common/arm_linux.S delete mode 100644 platform/common/arm_linux.h delete mode 100644 platform/common/fonts.c delete mode 100644 platform/common/fonts.h delete mode 100644 platform/common/in_sdl.c delete mode 100644 platform/common/in_sdl.h delete mode 100644 platform/common/input.c delete mode 100644 platform/common/input.h create mode 100644 platform/common/input_pico.h delete mode 100644 platform/common/lprintf.h delete mode 100644 platform/common/menu.c delete mode 100644 platform/common/menu.h delete mode 100644 platform/common/plat.h delete mode 100644 platform/common/posix.h delete mode 100644 platform/common/readpng.c delete mode 100644 platform/common/readpng.h delete mode 100644 platform/common/revision.mak delete mode 100644 platform/linux/Makefile delete mode 100644 platform/linux/fbdev.c delete mode 100644 platform/linux/fbdev.h delete mode 100644 platform/linux/in_evdev.c delete mode 100644 platform/linux/plat.c delete mode 100644 platform/linux/sndout_oss.c delete mode 100644 platform/linux/sndout_oss.h delete mode 100644 platform/linux/xenv.c delete mode 100644 platform/linux/xenv.h delete mode 100644 platform/win32/direct.cpp delete mode 100644 platform/win32/direct.h delete mode 100644 platform/win32/dsnd.cpp delete mode 100644 platform/win32/dsnd.h diff --git a/.gitignore b/.gitignore index 3b638143..3c582d09 100644 --- a/.gitignore +++ b/.gitignore @@ -5,3 +5,6 @@ cscope.out PicoDrive.map config.mak config.log +cpu/musashi/m68kmake +cpu/musashi/m68kops.c +cpu/musashi/m68kops.h diff --git a/Makefile b/Makefile new file mode 100644 index 00000000..a5039809 --- /dev/null +++ b/Makefile @@ -0,0 +1,77 @@ +# settings +#use_fbdev = 1 +#fake_in_gp2x = 1 + +use_musashi = 1 +#use_fame = 1 +use_cz80 = 1 +#use_sh2drc = 1 +use_sh2mame = 1 + +#drc_debug = 3 +#drc_debug_interp = 1 +#profile = 1 + +-include Makefile.local + +ifndef ARCH +ARCH = x86 +endif + +CC ?= $(CROSS_COMPILE)gcc + +DEFINES = _UNZIP_SUPPORT IO_STATS IN_EVDEV +CFLAGS += -ggdb -Wall -falign-functions=2 +CFLAGS += -I. +CFLAGS += -Iplatform/linux/ +LDLIBS += -lm -lpng + +all: PicoDrive + +# frontend +OBJS += platform/linux/io.o platform/linux/emu.o platform/linux/blit.o \ + platform/linux/log_io.o + +# common +OBJS += platform/common/main.o platform/common/emu.o platform/common/menu_pico.o \ + platform/common/config.o + +# libpicofe +OBJS += platform/libpicofe/input.o platform/libpicofe/readpng.o \ + platform/libpicofe/fonts.o platform/libpicofe/linux/in_evdev.o \ + platform/libpicofe/linux/plat.o platform/libpicofe/linux/sndout_oss.o + +OBJS += platform/libpicofe/plat_dummy.o + +ifeq "$(use_fbdev)" "1" +DEFINES += FBDEV +OBJS += fbdev.o +else +LDLIBS += -lpthread +LDLIBS += -lX11 +endif + +ifeq "$(ARCH)" "arm" +OBJS += pico/carthw/svp/stub_arm.o +endif +OBJS += pico/sound/mix.o +OBJS += pico/carthw/svp/compiler.o + +# zlib +OBJS += zlib/gzio.o zlib/inffast.o zlib/inflate.o zlib/inftrees.o zlib/trees.o \ + zlib/deflate.o zlib/crc32.o zlib/adler32.o zlib/zutil.o zlib/compress.o zlib/uncompr.o +# unzip +OBJS += unzip/unzip.o unzip/unzip_stream.o + +include platform/common/common.mak + +CFLAGS += $(addprefix -D,$(DEFINES)) + +clean: + $(RM) PicoDrive $(OBJS) + +PicoDrive : $(OBJS) + $(CC) $(CFLAGS) $^ $(LDFLAGS) $(LDLIBS) -Wl,-Map=PicoDrive.map -o $@ + +pprof: platform/linux/pprof.c + $(CC) -O2 -ggdb -DPPROF -DPPROF_TOOL -I../../ -I. $^ -o $@ diff --git a/cpu/debug.h b/cpu/debug.h index bf3e0688..5aaa60ee 100644 --- a/cpu/debug.h +++ b/cpu/debug.h @@ -26,6 +26,6 @@ int pdb_net_connect(const char *host, const char *port); #else -#define pdb_net_connect(a,b) 0 +static inline int pdb_net_connect(const char *host, const char *port) {return 0;} #endif diff --git a/pico/32x/memory.c b/pico/32x/memory.c index c720547f..7844acc3 100644 --- a/pico/32x/memory.c +++ b/pico/32x/memory.c @@ -1425,7 +1425,7 @@ void PicoMemSetup32x(void) unsigned int rs; int i; - Pico32xMem = plat_mmap(0x06000000, sizeof(*Pico32xMem)); + Pico32xMem = plat_mmap(0x06000000, sizeof(*Pico32xMem), 0, 0); if (Pico32xMem == NULL) { elprintf(EL_STATUS, "OOM"); return; diff --git a/pico/cart.c b/pico/cart.c index 8ac330ad..b060079b 100644 --- a/pico/cart.c +++ b/pico/cart.c @@ -458,7 +458,7 @@ static unsigned char *PicoCartAlloc(int filesize, int is_sms) // Allocate space for the rom plus padding // use special address for 32x dynarec - rom = plat_mmap(0x02000000, rom_alloc_size); + rom = plat_mmap(0x02000000, rom_alloc_size, 0, 0); return rom; } diff --git a/pico/pico.h b/pico/pico.h index ac5eb05f..da0a9a72 100644 --- a/pico/pico.h +++ b/pico/pico.h @@ -33,7 +33,7 @@ extern void cache_flush_d_inval_i(const void *start_addr, const void *end_addr); // attempt to alloc mem at specified address. // alloc anywhere else if that fails (callers should handle that) -extern void *plat_mmap(unsigned long addr, size_t size); +extern void *plat_mmap(unsigned long addr, size_t size, int need_exec, int is_fixed); extern void *plat_mremap(void *ptr, size_t oldsize, size_t newsize); extern void plat_munmap(void *ptr, size_t size); diff --git a/pico/sound/sound.c b/pico/sound/sound.c index 615e324d..48ad4095 100644 --- a/pico/sound/sound.c +++ b/pico/sound/sound.c @@ -337,6 +337,7 @@ static int PsndRender(int offset, int length) memset32(buf32, 0, length< - - -.global cache_flush_d_inval_i @ const void *start_addr, const void *end_addr - -cache_flush_d_inval_i: - mov r2, #0 -#ifdef __ARM_EABI__ - /* EABI version */ - str r7, [sp, #-4]! - mov r7, #(__ARM_NR_cacheflush & 0xff) -#if (__ARM_NR_cacheflush & 0x00ff00) - orr r7, r7, #(__ARM_NR_cacheflush & 0x00ff00) -#endif -#if (__ARM_NR_cacheflush & 0xff0000) - orr r7, r7, #(__ARM_NR_cacheflush & 0xff0000) -#endif - swi 0 - ldr r7, [sp], #4 -#else - /* OABI */ - swi __ARM_NR_cacheflush -#endif - bx lr - diff --git a/platform/common/arm_linux.h b/platform/common/arm_linux.h deleted file mode 100644 index 99de912e..00000000 --- a/platform/common/arm_linux.h +++ /dev/null @@ -1 +0,0 @@ -extern void cache_flush_d_inval_i(const void *start_addr, const void *end_addr); diff --git a/platform/common/common.mak b/platform/common/common.mak index 2a0354b2..7d2599e7 100644 --- a/platform/common/common.mak +++ b/platform/common/common.mak @@ -1,6 +1,3 @@ -ifneq ($(DEBUG),) -CFLAGS += -ggdb -endif ifeq "$(profile)" "1" CFLAGS += -fprofile-generate endif @@ -120,35 +117,28 @@ DIRS += platform platform/common pico pico/cd pico/pico pico/32x pico/sound pico @echo ">>>" $< $(CC) $(CFLAGS) -c $< -o $@ -clean_prof: - find ../.. -name '*.gcno' -delete - find ../.. -name '*.gcda' -delete - mkdirs: mkdir -p $(DIRS) -../../tools/textfilter: ../../tools/textfilter.c - make -C ../../tools/ textfilter +tools/textfilter: tools/textfilter.c + make -C tools/ textfilter # random deps -pico/carthw/svp/compiler.o : ../../cpu/drc/emit_$(ARCH).c -cpu/sh2/compiler.o : ../../cpu/drc/emit_$(ARCH).c -cpu/sh2/mame/sh2pico.o : ../../cpu/sh2/mame/sh2.c -pico/pico.o pico/cd/pico.o : ../../pico/pico_cmn.c ../../pico/pico_int.h -pico/memory.o pico/cd/memory.o : ../../pico/pico_int.h ../../pico/memory.h - -../../cpu/musashi/m68kops.c : - @make -C ../../cpu/musashi +pico/carthw/svp/compiler.o : cpu/drc/emit_$(ARCH).c +cpu/sh2/compiler.o : cpu/drc/emit_$(ARCH).c +cpu/sh2/mame/sh2pico.o : cpu/sh2/mame/sh2.c +pico/pico.o pico/cd/pico.o : pico/pico_cmn.c pico/pico_int.h +pico/memory.o pico/cd/memory.o : pico/pico_int.h pico/memory.h -../../cpu/mz80/mz80.asm : - @make -C ../../cpu/mz80/ +cpu/musashi/m68kops.c : + @make -C cpu/musashi -cpu/fame/famec.o : ../../cpu/fame/famec.c ../../cpu/fame/famec_opcodes.h +cpu/fame/famec.o : cpu/fame/famec.c cpu/fame/famec_opcodes.h @echo ">>>" $< $(CC) $(CFLAGS) -Wno-unused -c $< -o $@ -../../cpu/Cyclone/proj/Cyclone.s: +cpu/Cyclone/proj/Cyclone.s: @echo building Cyclone... - @make -C ../../cpu/Cyclone/proj CONFIG_FILE=config_pico.h + @make -C cpu/Cyclone/proj CONFIG_FILE=config_pico.h diff --git a/platform/common/config.c b/platform/common/config.c index 9950b13d..35ba25b8 100644 --- a/platform/common/config.c +++ b/platform/common/config.c @@ -9,16 +9,16 @@ #ifdef __EPOC32__ #include #endif + +#include "../libpicofe/input.h" +#include "../libpicofe/plat.h" +#include "../libpicofe/lprintf.h" #include "config.h" -#include "plat.h" -#include "input.h" -#include "lprintf.h" static char *mystrip(char *str); #ifndef _MSC_VER -#include "menu.h" #include "menu_pico.h" #include "emu.h" #include diff --git a/platform/common/emu.c b/platform/common/emu.c index 7d680b8b..a417926d 100644 --- a/platform/common/emu.c +++ b/platform/common/emu.c @@ -10,14 +10,15 @@ #include #endif +#include "../libpicofe/posix.h" +#include "../libpicofe/input.h" +#include "../libpicofe/fonts.h" +#include "../libpicofe/lprintf.h" +#include "../libpicofe/plat.h" #include "emu.h" -#include "menu.h" -#include "fonts.h" -#include "lprintf.h" +#include "input_pico.h" +#include "menu_pico.h" #include "config.h" -#include "plat.h" -#include "input.h" -#include "posix.h" #include #include @@ -184,7 +185,7 @@ static int find_bios(int region, char **bios_file) } else { sprintf(static_buff, "no %s BIOS files found, read docs", region != 4 ? (region == 8 ? "EU" : "JAP") : "USA"); - me_update_msg(static_buff); + menu_update_msg(static_buff); return 0; } } @@ -510,32 +511,32 @@ int emu_reload_rom(char *rom_fname) int dummy; FILE *movie_file = fopen(rom_fname, "rb"); if (!movie_file) { - me_update_msg("Failed to open movie."); + menu_update_msg("Failed to open movie."); return 0; } fseek(movie_file, 0, SEEK_END); movie_size = ftell(movie_file); fseek(movie_file, 0, SEEK_SET); if (movie_size < 64+3) { - me_update_msg("Invalid GMV file."); + menu_update_msg("Invalid GMV file."); fclose(movie_file); return 0; } movie_data = malloc(movie_size); if (movie_data == NULL) { - me_update_msg("low memory."); + menu_update_msg("low memory."); fclose(movie_file); return 0; } dummy = fread(movie_data, 1, movie_size, movie_file); fclose(movie_file); if (strncmp((char *)movie_data, "Gens Movie TEST", 15) != 0) { - me_update_msg("Invalid GMV file."); + menu_update_msg("Invalid GMV file."); return 0; } dummy = try_rfn_cut(rom_fname) || try_rfn_cut(rom_fname); if (!dummy) { - me_update_msg("Could't find a ROM for movie."); + menu_update_msg("Could't find a ROM for movie."); return 0; } get_ext(rom_fname, ext); @@ -547,7 +548,7 @@ int emu_reload_rom(char *rom_fname) PicoPatchLoad(rom_fname); dummy = try_rfn_cut(rom_fname) || try_rfn_cut(rom_fname); if (!dummy) { - me_update_msg("Could't find a ROM to patch."); + menu_update_msg("Could't find a ROM to patch."); return 0; } get_ext(rom_fname, ext); @@ -555,7 +556,7 @@ int emu_reload_rom(char *rom_fname) media_type = detect_media(rom_fname); if (media_type == PM_BAD) { - me_update_msg("Not a ROM/CD img selected."); + menu_update_msg("Not a ROM/CD img selected."); return 0; } @@ -590,7 +591,7 @@ int emu_reload_rom(char *rom_fname) PicoAHW |= PAHW_MCD; } else { - me_update_msg("Invalid CD image"); + menu_update_msg("Invalid CD image"); return 0; } } @@ -601,7 +602,7 @@ int emu_reload_rom(char *rom_fname) rom = pm_open(used_rom_name); if (rom == NULL) { - me_update_msg("Failed to open ROM"); + menu_update_msg("Failed to open ROM"); return 0; } @@ -611,9 +612,9 @@ int emu_reload_rom(char *rom_fname) ret = PicoCartLoad(rom, &rom_data, &rom_size, (PicoAHW & PAHW_SMS) ? 1 : 0); pm_close(rom); if (ret != 0) { - if (ret == 2) me_update_msg("Out of memory"); - else if (ret == 3) me_update_msg("Read failed"); - else me_update_msg("PicoCartLoad() failed."); + if (ret == 2) menu_update_msg("Out of memory"); + else if (ret == 3) menu_update_msg("Read failed"); + else menu_update_msg("PicoCartLoad() failed."); goto fail; } @@ -629,7 +630,7 @@ int emu_reload_rom(char *rom_fname) } if (bad_rom) { - me_update_msg("Bad ROM detected."); + menu_update_msg("Bad ROM detected."); goto fail; } @@ -643,7 +644,7 @@ int emu_reload_rom(char *rom_fname) emu_make_path(static_buff, "carthw.cfg", sizeof(static_buff)); if (PicoCartInsert(rom_data, rom_size, static_buff)) { - me_update_msg("Failed to load ROM."); + menu_update_msg("Failed to load ROM."); goto fail; } @@ -653,7 +654,7 @@ int emu_reload_rom(char *rom_fname) if (ret != 0) { PicoCartUnload(); rom_data = NULL; // freed by unload - me_update_msg("Insert_CD() failed, invalid CD image?"); + menu_update_msg("Insert_CD() failed, invalid CD image?"); goto fail; } } @@ -716,7 +717,7 @@ int emu_swap_cd(const char *fname) if (cd_type != CIT_NOT_CD) ret = Insert_CD(fname, cd_type); if (ret != 0) { - me_update_msg("Load failed, invalid CD image?"); + menu_update_msg("Load failed, invalid CD image?"); return 0; } diff --git a/platform/common/emu.h b/platform/common/emu.h index 75a5abe3..0bbdcbda 100644 --- a/platform/common/emu.h +++ b/platform/common/emu.h @@ -149,6 +149,34 @@ void emu_status_msg(const char *format, ...); /* used by some (but not all) platforms */ void emu_cmn_forced_frame(int no_scale, int do_emu); +/* 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); + +/* 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); + +void plat_video_toggle_renderer(int change, int menu_call); + +void plat_update_volume(int has_changed, int is_up); + #ifdef __cplusplus } // extern "C" #endif diff --git a/platform/common/fonts.c b/platform/common/fonts.c deleted file mode 100644 index ea65481f..00000000 --- a/platform/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/platform/common/fonts.h b/platform/common/fonts.h deleted file mode 100644 index dbbdd4c6..00000000 --- a/platform/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/platform/common/in_sdl.c b/platform/common/in_sdl.c deleted file mode 100644 index ce575365..00000000 --- a/platform/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/platform/common/in_sdl.h b/platform/common/in_sdl.h deleted file mode 100644 index 47f7a832..00000000 --- a/platform/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/platform/common/input.c b/platform/common/input.c deleted file mode 100644 index 39d67839..00000000 --- a/platform/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/platform/common/input.h b/platform/common/input.h deleted file mode 100644 index e87e6ea5..00000000 --- a/platform/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/platform/common/input_pico.h b/platform/common/input_pico.h new file mode 100644 index 00000000..fbf328ab --- /dev/null +++ b/platform/common/input_pico.h @@ -0,0 +1,33 @@ +#ifndef INCLUDE_c48097f3ff2a6a9af1cce8fd7a9b3f0c +#define INCLUDE_c48097f3ff2a6a9af1cce8fd7a9b3f0c 1 + +/* 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 /* INCLUDE_c48097f3ff2a6a9af1cce8fd7a9b3f0c */ diff --git a/platform/common/lprintf.h b/platform/common/lprintf.h deleted file mode 100644 index 48b8d576..00000000 --- a/platform/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/platform/common/main.c b/platform/common/main.c index 48f218fc..5f31b060 100644 --- a/platform/common/main.c +++ b/platform/common/main.c @@ -8,11 +8,11 @@ #include #include -#include "menu.h" +#include "../libpicofe/input.h" +#include "../libpicofe/plat.h" +#include "menu_pico.h" #include "emu.h" #include "config.h" -#include "input.h" -#include "plat.h" #include #include @@ -72,12 +72,12 @@ int main(int argc, char *argv[]) { g_argv = argv; - plat_early_init(); + //plat_early_init(); in_init(); in_probe(); - plat_init(); + plat_target_init(); emu_prep_defconfig(); // depends on input emu_read_config(NULL, 0); @@ -142,7 +142,7 @@ int main(int argc, char *argv[]) endloop: emu_finish(); - plat_finish(); + plat_target_finish(); return 0; } diff --git a/platform/common/menu.c b/platform/common/menu.c deleted file mode 100644 index 3acab62c..00000000 --- a/platform/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/platform/common/menu.h b/platform/common/menu.h deleted file mode 100644 index 79b82783..00000000 --- a/platform/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/platform/common/menu_pico.c b/platform/common/menu_pico.c index f6e9b264..da1a6be3 100644 --- a/platform/common/menu_pico.c +++ b/platform/common/menu_pico.c @@ -2,35 +2,37 @@ #include "emu.h" #include "menu_pico.h" +#include "input_pico.h" #include -#include #include #include +// FIXME +#define REVISION "0" + +static const char *rom_exts[] = { + "zip", "bin", "smd", "gen", + "iso", "cso", "cue", NULL +}; + // rrrr rggg gggb bbbb static unsigned short fname2color(const char *fname) { const char *ext = fname + strlen(fname) - 3; - static const char *rom_exts[] = { "zip", "bin", "smd", "gen", "iso", "cso", "cue" }; static const char *other_exts[] = { "gmv", "pat" }; int i; if (ext < fname) ext = fname; - for (i = 0; i < array_size(rom_exts); i++) + for (i = 0; rom_exts[i] != NULL; i++) if (strcasecmp(ext, rom_exts[i]) == 0) return 0xbdff; // FIXME: mk defines for (i = 0; i < array_size(other_exts); i++) if (strcasecmp(ext, other_exts[i]) == 0) return 0xaff5; return 0xffff; } -static const char *filter_exts[] = { - ".mp3", ".MP3", ".srm", ".brm", "s.gz", ".mds", "bcfg", ".txt", ".htm", "html", - ".jpg", ".gpe" -}; - -#include "menu.c" +#include "../libpicofe/menu.c" /* platform specific options and handlers */ #if defined(__GP2X__) @@ -96,7 +98,7 @@ static void load_progress_cb(int percent) if (len > g_menuscreen_w) len = g_menuscreen_w; - menu_draw_begin(0); + menu_draw_begin(0, 1); dst = (unsigned short *)g_menuscreen_ptr + g_menuscreen_w * me_sfont_h * 2; for (ln = me_sfont_h - 2; ln > 0; ln--, dst += g_menuscreen_w) memset(dst, 0xff, len * 2); @@ -108,7 +110,7 @@ static void cdload_progress_cb(const char *fname, int percent) int ln, len = percent * g_menuscreen_w / 100; unsigned short *dst; - menu_draw_begin(0); + menu_draw_begin(0, 1); dst = (unsigned short *)g_menuscreen_ptr + g_menuscreen_w * me_sfont_h * 2; memset(dst, 0xff, g_menuscreen_w * (me_sfont_h - 2) * 2); @@ -136,7 +138,7 @@ void menu_romload_prepare(const char *rom_name) /* fill all buffers, callbacks won't update in full */ for (i = 0; i < 3; i++) { - menu_draw_begin(1); + menu_draw_begin(1, 1); smalltext_out16(1, 1, "Loading", 0xffff); smalltext_out16(1, me_sfont_h, p, 0xffff); menu_draw_end(); @@ -152,7 +154,7 @@ void menu_romload_end(void) PicoCartLoadProgressCB = NULL; PicoCDLoadProgressCB = NULL; - menu_draw_begin(0); + menu_draw_begin(0, 1); smalltext_out16(1, (cdload_called ? 6 : 3) * me_sfont_h, "Starting emulation...", 0xffff); menu_draw_end(); @@ -167,7 +169,7 @@ static void draw_patchlist(int sel) max_cnt = g_menuscreen_h / me_sfont_h; start = max_cnt / 2 - sel; - menu_draw_begin(1); + menu_draw_begin(1, 0); for (i = 0; i < PicoPatchCount; i++) { pos = start + i; @@ -565,15 +567,15 @@ static int mh_saveloadcfg(int id, int keys) case MA_OPT_SAVECFG: case MA_OPT_SAVECFG_GAME: if (emu_write_config(id == MA_OPT_SAVECFG_GAME ? 1 : 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"); break; case MA_OPT_LOADCFG: ret = emu_read_config(rom_fname_loaded, 1); if (!ret) ret = emu_read_config(NULL, 1); - if (ret) me_update_msg("config loaded"); - else me_update_msg("failed to load config"); + if (ret) menu_update_msg("config loaded"); + else menu_update_msg("failed to load config"); break; default: return 0; @@ -585,7 +587,7 @@ static int mh_saveloadcfg(int id, int keys) static int mh_restore_defaults(int id, int keys) { emu_set_defconfig(); - me_update_msg("defaults restored"); + menu_update_msg("defaults restored"); return 1; } @@ -759,7 +761,7 @@ static void debug_menu_loop(void) while (1) { - menu_draw_begin(1); + menu_draw_begin(1, 0); switch (mode) { case 0: tmp = PDebugMain(); @@ -857,23 +859,24 @@ static const char credits[] = " Lordus, Exophase, Rokas,\n" " Nemesis, Tasco Deluxe"; -static char *romsel_run(void) +static const char *romsel_run(void) { - char *ret, *sel_name; + const char *ret; + char *sel_name; sel_name = malloc(sizeof(rom_fname_loaded)); if (sel_name == NULL) return NULL; strcpy(sel_name, rom_fname_loaded); - ret = menu_loop_romsel(sel_name, sizeof(rom_fname_loaded)); + ret = menu_loop_romsel(sel_name, sizeof(rom_fname_loaded), rom_exts, NULL); free(sel_name); return ret; } static int main_menu_handler(int id, int keys) { - char *ret_name; + const char *ret_name; switch (id) { @@ -914,7 +917,7 @@ static int main_menu_handler(int id, int keys) if (rom_loaded && PicoPatches) { menu_loop_patches(); PicoPatchApply(); - me_update_msg("Patches applied"); + menu_update_msg("Patches applied"); } break; default: @@ -973,7 +976,7 @@ void menu_loop(void) static int mh_tray_load_cd(int id, int keys) { - char *ret_name; + const char *ret_name; ret_name = romsel_run(); if (ret_name == NULL) @@ -1018,7 +1021,7 @@ int menu_loop_tray(void) return ret; } -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; @@ -1078,3 +1081,7 @@ menu_entry *me_list_get_next(void) return me_list_i; } +void menu_init(void) +{ + menu_init_base(); +} diff --git a/platform/common/menu_pico.h b/platform/common/menu_pico.h index a8aeb64b..31cee72d 100644 --- a/platform/common/menu_pico.h +++ b/platform/common/menu_pico.h @@ -1,3 +1,8 @@ +#ifndef __MENU_PICO_H__ +#define __MENU_PICO_H__ + +#include "../libpicofe/menu.h" + typedef enum { MA_NONE = 1, @@ -92,3 +97,10 @@ typedef enum MA_CTRL_DONE, } menu_id; +void menu_init(void); +void menu_loop(void); +int menu_loop_tray(void); +void menu_romload_prepare(const char *rom_name); +void menu_romload_end(void); + +#endif // __MENU_PICO_H__ diff --git a/platform/common/plat.h b/platform/common/plat.h deleted file mode 100644 index 1fb87676..00000000 --- a/platform/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/platform/common/posix.h b/platform/common/posix.h deleted file mode 100644 index 33ca96cc..00000000 --- a/platform/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/platform/common/readpng.c b/platform/common/readpng.c deleted file mode 100644 index cad12170..00000000 --- a/platform/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)info_ptr->width, (int)info_ptr->height, info_ptr->pixel_depth); - - switch (what) - { - case READPNG_BG: - { - int height, width, h; - unsigned short *dst = dest; - if (info_ptr->pixel_depth != 24) - { - lprintf(__FILE__ ": bg image uses %ibpp, needed 24bpp\n", info_ptr->pixel_depth); - break; - } - height = info_ptr->height; - if (height > req_h) - height = req_h; - width = info_ptr->width; - if (width > req_w) - width = req_w; - - 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 (info_ptr->width != req_w || info_ptr->height != req_h) - { - lprintf(__FILE__ ": unexpected font image size %dx%d, needed %dx%d\n", - (int)info_ptr->width, (int)info_ptr->height, req_w, req_h); - break; - } - if (info_ptr->pixel_depth != 8) - { - lprintf(__FILE__ ": font image uses %ibpp, needed 8bpp\n", info_ptr->pixel_depth); - 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 (info_ptr->width != req_w || info_ptr->height != req_h) - { - lprintf(__FILE__ ": unexpected selector image size %ix%i, needed %dx%d\n", - (int)info_ptr->width, (int)info_ptr->height, req_w, req_h); - break; - } - if (info_ptr->pixel_depth != 8) - { - lprintf(__FILE__ ": selector image uses %ibpp, needed 8bpp\n", info_ptr->pixel_depth); - 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 (info_ptr->pixel_depth != 24) - { - lprintf(__FILE__ ": image uses %ibpp, needed 24bpp\n", info_ptr->pixel_depth); - break; - } - height = info_ptr->height; - if (height > req_h) - height = req_h; - width = info_ptr->width; - if (width > req_w) - width = req_w; - - 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/platform/common/readpng.h b/platform/common/readpng.h deleted file mode 100644 index 924b3415..00000000 --- a/platform/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/platform/common/revision.mak b/platform/common/revision.mak deleted file mode 100644 index 2e92875f..00000000 --- a/platform/common/revision.mak +++ /dev/null @@ -1,12 +0,0 @@ -platform/common/menu.o : revision.h - -revision.h: FORCE -ifndef NOREVISION - @echo "#define REVISION \"`svn info -r HEAD | grep Revision | cut -c 11-`\"" > /tmp/r.tmp -else - @echo "#define REVISION \"0\"" > /tmp/r.tmp -endif - @diff -q $@ /tmp/r.tmp > /dev/null 2>&1 || mv -f /tmp/r.tmp $@ - -FORCE: - diff --git a/platform/libpicofe b/platform/libpicofe index da0cc556..7bf7acb6 160000 --- a/platform/libpicofe +++ b/platform/libpicofe @@ -1 +1 @@ -Subproject commit da0cc55643353ab15725194be64a3d8460fe48b1 +Subproject commit 7bf7acb6d60e16e9eaa208761d019c39da396fc0 diff --git a/platform/linux/Makefile b/platform/linux/Makefile deleted file mode 100644 index 34856acd..00000000 --- a/platform/linux/Makefile +++ /dev/null @@ -1,97 +0,0 @@ -# settings -#use_fbdev = 1 -#fake_in_gp2x = 1 - -use_musashi = 1 -#use_fame = 1 -use_cz80 = 1 -use_sh2drc = 1 -#use_sh2mame = 1 - -#drc_debug = 3 -#drc_debug_interp = 1 -#profile = 1 - -all: mkdirs PicoDrive - --include Makefile.local - -ifndef ARCH -ARCH = x86 -endif - -DEFINES = _UNZIP_SUPPORT IO_STATS IN_EVDEV -CFLAGS += -ggdb -Wall -falign-functions=2 -CFLAGS += -I../.. -I. -LDFLAGS += -lm -lpng -ifeq "$(ARCH)" "arm" -CFLAGS += -mcpu=arm920t -DEFINES += ARM -endif - -CC ?= $(CROSS)gcc - -# frontend -OBJS += io.o emu.o blit.o in_evdev.o plat.o sndout_oss.o log_io.o - -# common -OBJS += platform/common/main.o platform/common/emu.o platform/common/menu_pico.o \ - platform/common/config.o platform/common/fonts.o platform/common/readpng.o \ - platform/common/input.o - -ifeq "$(use_fbdev)" "1" -DEFINES += FBDEV -OBJS += fbdev.o -else -LDFLAGS += -lpthread -LDFLAGS += -lX11 -endif - -ifeq "$(fake_in_gp2x)" "1" -DEFINES += IN_GP2X FAKE_IN_GP2X -OBJS += platform/gp2x/in_gp2x.o -DIRS += platform/gp2x -endif - -ifeq "$(ARCH)" "arm" -OBJS += pico/carthw/svp/stub_arm.o -endif -OBJS += pico/sound/mix.o -OBJS += pico/carthw/svp/compiler.o - -# zlib -OBJS += zlib/gzio.o zlib/inffast.o zlib/inflate.o zlib/inftrees.o zlib/trees.o \ - zlib/deflate.o zlib/crc32.o zlib/adler32.o zlib/zutil.o zlib/compress.o zlib/uncompr.o -# unzip -OBJS += unzip/unzip.o unzip/unzip_stream.o - -vpath %.c = ../.. -vpath %.s = ../.. -vpath %.S = ../.. -vpath %.asm = ../.. - -DIRS += platform/linux zlib unzip - -include ../common/common.mak -include ../common/revision.mak - -CFLAGS += $(addprefix -D,$(DEFINES)) - -clean: tidy - @$(RM) PicoDrive -tidy: - $(RM) $(OBJS) - rm -rf $(DIRS) - @make -C ../../cpu/mz80/ clean - -PicoDrive : $(OBJS) - @echo ">>>" $@ - $(CC) $(CFLAGS) $^ $(LDFLAGS) -Wl,-Map=PicoDrive.map -o $@ - -pprof: pprof.c - $(CROSS)gcc -O2 -ggdb -DPPROF -DPPROF_TOOL -I../../ -I. $^ -o $@ - -%.o : %.asm - @echo ">>>" $< - nasm -f elf $< -o $@ - diff --git a/platform/linux/emu.c b/platform/linux/emu.c index 95666ad2..cf05dbcc 100644 --- a/platform/linux/emu.c +++ b/platform/linux/emu.c @@ -6,11 +6,11 @@ #include #include +#include "../libpicofe/menu.h" +#include "../libpicofe/plat.h" +#include "../libpicofe/linux/sndout_oss.h" #include "../common/emu.h" -#include "../common/menu.h" -#include "../common/plat.h" #include "../common/arm_utils.h" -#include "../linux/sndout_oss.h" #include "version.h" #include diff --git a/platform/linux/fbdev.c b/platform/linux/fbdev.c deleted file mode 100644 index ec3d5c7e..00000000 --- a/platform/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/platform/linux/fbdev.h b/platform/linux/fbdev.h deleted file mode 100644 index 88cd519f..00000000 --- a/platform/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/platform/linux/in_evdev.c b/platform/linux/in_evdev.c deleted file mode 100644 index b447da16..00000000 --- a/platform/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/platform/linux/io.c b/platform/linux/io.c index 2767e681..5e2d5e3a 100644 --- a/platform/linux/io.c +++ b/platform/linux/io.c @@ -2,11 +2,11 @@ #include #include +#include "../libpicofe/menu.h" +#include "../libpicofe/input.h" +#include "../libpicofe/linux/sndout_oss.h" #include "../common/emu.h" -#include "../common/menu.h" -#include "../common/plat.h" -#include "../common/input.h" -#include "sndout_oss.h" +#include "../common/input_pico.h" #include "version.h" #include "log_io.h" diff --git a/platform/linux/plat.c b/platform/linux/plat.c deleted file mode 100644 index 4ed1e65d..00000000 --- a/platform/linux/plat.c +++ /dev/null @@ -1,209 +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. - */ - -#define _GNU_SOURCE 1 -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "../common/plat.h" - -/* XXX: maybe unhardcode pagesize? */ -#define HUGETLB_PAGESIZE (2 * 1024 * 1024) -#define HUGETLB_THRESHOLD (HUGETLB_PAGESIZE / 2) -#ifndef MAP_HUGETLB -#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; - int prot = PROT_READ | PROT_WRITE; - int flags = MAP_PRIVATE | MAP_ANONYMOUS; - void *req, *ret; - - req = (void *)addr; - if (need_exec) - prot |= PROT_EXEC; - if (is_fixed) - flags |= MAP_FIXED; - if (size >= HUGETLB_THRESHOLD && !hugetlb_disabled) - flags |= MAP_HUGETLB; - - ret = mmap(req, size, prot, flags, -1, 0); - if (ret == MAP_FAILED && (flags & MAP_HUGETLB)) { - fprintf(stderr, - "warning: failed to do hugetlb mmap (%p, %zu): %d\n", - req, size, errno); - hugetlb_disabled = 1; - flags &= ~MAP_HUGETLB; - ret = mmap(req, size, prot, flags, -1, 0); - } - if (ret == MAP_FAILED) - return NULL; - - if (req != NULL && ret != req) - fprintf(stderr, - "warning: mmaped to %p, requested %p\n", ret, req); - - return ret; -} - -void *plat_mremap(void *ptr, size_t oldsize, size_t newsize) -{ - void *ret; - - ret = mremap(ptr, oldsize, newsize, MREMAP_MAYMOVE); - if (ret == MAP_FAILED) - return NULL; - if (ret != ptr) - printf("warning: mremap moved: %p -> %p\n", ptr, ret); - - return ret; -} - -void plat_munmap(void *ptr, size_t size) -{ - int ret; - - ret = munmap(ptr, size); - if (ret != 0 && (size & (HUGETLB_PAGESIZE - 1))) { - // prehaps an autorounded hugetlb mapping? - size = (size + HUGETLB_PAGESIZE - 1) & ~(HUGETLB_PAGESIZE - 1); - ret = munmap(ptr, size); - } - if (ret != 0) { - fprintf(stderr, - "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/platform/linux/sndout_oss.c b/platform/linux/sndout_oss.c deleted file mode 100644 index 2313d3fb..00000000 --- a/platform/linux/sndout_oss.c +++ /dev/null @@ -1,175 +0,0 @@ -/* sound output via OSS */ -#include -#include -#include -#include -#include -#include -#include - -#include "sndout_oss.h" - -static int sounddev = -1, mixerdev = -1; -static int can_write_safe; - -#define FRAG_COUNT 4 - -int sndout_oss_init(void) -{ - if (mixerdev >= 0) close(mixerdev); - mixerdev = open("/dev/mixer", O_RDWR); - if (mixerdev == -1) - { - perror("open(\"/dev/mixer\")"); - } - - return 0; -} - -void sndout_oss_stop(void) -{ - if (sounddev < 0) - return; - - ioctl(sounddev, SOUND_PCM_SYNC, 0); - close(sounddev); - sounddev = -1; -} - -int sndout_oss_start(int rate, int stereo, int frames_in_frag) -{ - static int s_oldrate = 0, s_oldstereo = 0; - int frag, bsize, bits, ret; - - // GP2X: if no settings change, we don't need to do anything, - // since audio is never stopped there - if (sounddev >= 0 && rate == s_oldrate && s_oldstereo == stereo) - return 0; - - sndout_oss_stop(); - sounddev = open("/dev/dsp", O_WRONLY); - if (sounddev == -1) - { - perror("open(\"/dev/dsp\")"); - sounddev = open("/dev/dsp1", O_WRONLY); - if (sounddev == -1) { - perror("open(\"/dev/dsp1\")"); - return -1; - } - } - - // try to fit frames_in_frag frames worth of data in fragment - // ignore mono because it's unlikely to be used and - // both GP2X and Wiz mixes mono to stereo anyway. - bsize = (frames_in_frag * rate / 50) * 4; - - for (frag = 0; bsize; bsize >>= 1, frag++) - ; - - frag |= FRAG_COUNT << 16; // fragment count - ret = ioctl(sounddev, SNDCTL_DSP_SETFRAGMENT, &frag); - if (ret < 0) - perror("SNDCTL_DSP_SETFRAGMENT failed"); - - bits = 16; - ret = ioctl(sounddev, SNDCTL_DSP_STEREO, &stereo); - if (ret == 0) - ret = ioctl(sounddev, SNDCTL_DSP_SETFMT, &bits); - if (ret == 0) - ret = ioctl(sounddev, SNDCTL_DSP_SPEED, &rate); - if (ret < 0) - perror("failed to set audio format"); - -#ifdef __GP2X__ - // not sure if this is still needed (avoiding driver bugs?) - usleep(192*1024); -#endif - - printf("sndout_oss_start: %d/%dbit/%s, %d buffers of %i bytes\n", - rate, bits, stereo ? "stereo" : "mono", frag >> 16, 1 << (frag & 0xffff)); - - s_oldrate = rate; s_oldstereo = stereo; - can_write_safe = 0; - return 0; -} - -int sndout_oss_write(const void *buff, int len) -{ - return write(sounddev, buff, len); -} - -#include "../common/plat.h" - -/* not really non-blocking, just detects if blocking occurs - * and starts skipping writes in case it does. */ -int sndout_oss_write_nb(const void *buff, int len) -{ - static int lag_counter, skip_counter; - unsigned int t; - int ret; - - if (lag_counter > 2) { - // skip writes if audio starts blocking - lag_counter = 0; - skip_counter = FRAG_COUNT; - } - - if (skip_counter > 0) { - skip_counter--; - return len; - } - - t = plat_get_ticks_ms(); - ret = sndout_oss_write(buff, len); - t = plat_get_ticks_ms() - t; - if (t > 1) { - // this shouldn't really happen, most likely audio is out of sync - lag_counter++; - if (lag_counter > 2) - printf("audio lag %u\n", t); - } - else - lag_counter = 0; - - return ret; -} - -int sndout_oss_can_write(int bytes) -{ - audio_buf_info bi; - int ret; - -#ifdef __GP2X__ - // note: SNDCTL_DSP_GETOSPACE crashes F100 kernel for some reason - // if called too early, so we work around here - if (can_write_safe++ < 8) - return 1; -#endif - ret = ioctl(sounddev, SNDCTL_DSP_GETOSPACE, &bi); - if (ret < 0) - return 1; - - // have enough bytes to write + 1 frag - return bi.bytes - bi.fragsize >= bytes ? 1 : 0; -} - -void sndout_oss_sync(void) -{ - ioctl(sounddev, SOUND_PCM_SYNC, 0); -} - -void sndout_oss_setvol(int l, int r) -{ - if (mixerdev < 0) return; - - l=l<0?0:l; l=l>255?255:l; r=r<0?0:r; r=r>255?255:r; - l<<=8; l|=r; - ioctl(mixerdev, SOUND_MIXER_WRITE_PCM, &l); /*SOUND_MIXER_WRITE_VOLUME*/ -} - -void sndout_oss_exit(void) -{ - if (sounddev >= 0) close(sounddev); sounddev = -1; - if (mixerdev >= 0) close(mixerdev); mixerdev = -1; -} - diff --git a/platform/linux/sndout_oss.h b/platform/linux/sndout_oss.h deleted file mode 100644 index 0b3fe6c8..00000000 --- a/platform/linux/sndout_oss.h +++ /dev/null @@ -1,9 +0,0 @@ -int sndout_oss_init(void); -int sndout_oss_start(int rate, int stereo, int frames_in_frag); -void sndout_oss_stop(void); -int sndout_oss_write(const void *buff, int len); -int sndout_oss_write_nb(const void *buff, int len); -int sndout_oss_can_write(int bytes); -void sndout_oss_sync(void); -void sndout_oss_setvol(int l, int r); -void sndout_oss_exit(void); diff --git a/platform/linux/xenv.c b/platform/linux/xenv.c deleted file mode 100644 index 40bf92c9..00000000 --- a/platform/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/platform/linux/xenv.h b/platform/linux/xenv.h deleted file mode 100644 index 6abda195..00000000 --- a/platform/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/platform/win32/direct.cpp b/platform/win32/direct.cpp deleted file mode 100644 index 033f87cc..00000000 --- a/platform/win32/direct.cpp +++ /dev/null @@ -1,410 +0,0 @@ -// ddraw -#include -#include "../common/lprintf.h" -#include "direct.h" -#include "main.h" - -#define EmuWidth 320 -#define EmuHeight 240 - -#define RELEASE(x) if (x) x->Release(); x=NULL; -#define LOGFAIL() lprintf("fail: %s %s:%i\n", __FUNCTION__, __FILE__, __LINE__) - -static LPDIRECTDRAW7 m_pDD = NULL; -static LPDIRECTDRAWSURFACE7 m_pddsFrontBuffer = NULL; -static LPDIRECTDRAWSURFACE7 m_pddsBackBuffer = NULL; - -// quick and dirty stuff.. -void DirectExit(void) -{ - RELEASE(m_pddsBackBuffer); - RELEASE(m_pddsFrontBuffer); - RELEASE(m_pDD); -} - -int DirectInit(void) -{ - HRESULT ret; - LPDIRECTDRAWCLIPPER pcClipper = NULL; - DDSURFACEDESC2 ddsd; - - ret = DirectDrawCreateEx(NULL, (VOID**)&m_pDD, IID_IDirectDraw7, NULL); - if (ret) { LOGFAIL(); return 1; } - - // Set cooperative level - ret = m_pDD->SetCooperativeLevel( FrameWnd, DDSCL_NORMAL ); - if (ret) { LOGFAIL(); goto fail; } - - // Create the primary surface - ZeroMemory( &ddsd, sizeof( ddsd ) ); - ddsd.dwSize = sizeof( ddsd ); - ddsd.dwFlags = DDSD_CAPS; - ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; - - ret = m_pDD->CreateSurface( &ddsd, &m_pddsFrontBuffer, NULL ); - if (ret) { LOGFAIL(); goto fail; } - - // Create the backbuffer surface - ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT; - ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY; - ddsd.dwWidth = EmuWidth; - ddsd.dwHeight = EmuHeight; - - ret = m_pDD->CreateSurface( &ddsd, &m_pddsBackBuffer, NULL ); - if (ret) { LOGFAIL(); goto fail; } - - // clipper - ret = m_pDD->CreateClipper( 0, &pcClipper, NULL ); - if (ret) { LOGFAIL(); goto fail; } - - ret = pcClipper->SetHWnd( 0, FrameWnd ); - if (ret) { LOGFAIL(); goto fail; } - - ret = m_pddsFrontBuffer->SetClipper( pcClipper ); - if (ret) { LOGFAIL(); goto fail; } - - RELEASE(pcClipper); - return 0; - -fail: - RELEASE(pcClipper); - DirectExit(); - return 1; -} - -int DirectScreen(const void *emu_screen) -{ - const unsigned short *ps = (const unsigned short *)emu_screen; - DDSURFACEDESC2 sd; - int ret, x, y; - - memset(&sd, 0, sizeof(sd)); - sd.dwSize = sizeof(sd); - ret = m_pddsBackBuffer->Lock(NULL, &sd, DDLOCK_SURFACEMEMORYPTR|DDLOCK_WAIT|DDLOCK_WRITEONLY, NULL); - if (ret) { LOGFAIL(); return 1; } - - //lprintf("w: %i h: %i pi: %i pf: %i\n", sd.dwWidth, sd.dwHeight, sd.lPitch, sd.ddpfPixelFormat.dwRGBBitCount); - - if (sd.ddpfPixelFormat.dwRGBBitCount == 32) - { - int *dst = (int *)sd.lpSurface; - for (y = 0; y < EmuHeight; y++) - { - for (x = 0; x < EmuWidth; x++) - { - int s = *ps++; - dst[x] = ((s&0xf800)<<8) | ((s&0x07e0)<<5) | ((s&0x001f)<<3); - } - dst = (int *)((char *)dst + sd.lPitch); - } - } - else if (sd.ddpfPixelFormat.dwRGBBitCount == 24) /* wine uses this for me */ - { - void *dst = sd.lpSurface; - for (y = 0; y < EmuHeight; y++) - { - unsigned char *dst1 = (unsigned char *) dst; - for (x = 0; x < EmuWidth; x++, dst1 += 3) - { - int s = *ps++; - dst1[2] = (s&0xf800)>>8; dst1[1] = (s&0x07e0)>>3; dst1[0] = s<<3; // BGR - } - dst = (void *)((char *)dst + sd.lPitch); - } - } - else if (sd.ddpfPixelFormat.dwRGBBitCount == 16) - { - unsigned short *dst = (unsigned short *)sd.lpSurface; - for (y = 0; y < EmuHeight; y++) - { - memcpy(dst, ps, EmuWidth*2); - ps += EmuWidth; - dst = (unsigned short *)((char *)dst + sd.lPitch); - } - } - else - { - LOGFAIL(); - } - - ret = m_pddsBackBuffer->Unlock(NULL); - if (ret) { LOGFAIL(); return 1; } - return 0; -} - -int DirectClear(unsigned int colour) -{ - int ret = 0; - DDBLTFX ddbltfx; - ZeroMemory( &ddbltfx, sizeof(ddbltfx) ); - ddbltfx.dwSize = sizeof(ddbltfx); - ddbltfx.dwFillColor = colour; - - if (m_pddsBackBuffer != NULL) - ret = m_pddsBackBuffer->Blt( NULL, NULL, NULL, DDBLT_COLORFILL, &ddbltfx ); - if (ret) { LOGFAIL(); return 1; } - return 0; -} - -int DirectPresent(void) -{ - int ret = 0; - if (FrameRectMy.right - FrameRectMy.left > 0 && FrameRectMy.bottom - FrameRectMy.top > 0) - ret = m_pddsFrontBuffer->Blt(&FrameRectMy, m_pddsBackBuffer, &EmuScreenRect, DDBLT_WAIT, NULL); - if (ret) { LOGFAIL(); return 1; } - return 0; -} - - -/* D3D */ -#ifdef USE_D3D -static IDirect3D8 *Direct3D=NULL; -IDirect3DDevice8 *Device=NULL; -IDirect3DSurface8 *DirectBack=NULL; // Back Buffer - -static IDirect3DVertexBuffer8 *VertexBuffer=NULL; - -struct CustomVertex -{ - float x,y,z; // Vertex cordinates - unsigned int colour; - float u,v; // Texture coordinates -}; -#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_DIFFUSE|D3DFVF_TEX1) - -static CustomVertex VertexList[4]; - -int DirectInit() -{ - D3DPRESENT_PARAMETERS d3dpp; - D3DDISPLAYMODE mode; - int i,u,ret=0; - - memset(&d3dpp,0,sizeof(d3dpp)); - memset(&mode,0,sizeof(mode)); - - Direct3D=Direct3DCreate8(D3D_SDK_VERSION); if (Direct3D==NULL) return 1; - - // Set up the structure used to create the D3D device: - d3dpp.BackBufferWidth =MainWidth; - d3dpp.BackBufferHeight=MainHeight; - d3dpp.BackBufferCount =1; - d3dpp.SwapEffect=D3DSWAPEFFECT_DISCARD; - d3dpp.MultiSampleType =D3DMULTISAMPLE_NONE; - -#ifdef _XBOX - d3dpp.BackBufferFormat=D3DFMT_X8R8G8B8; - d3dpp.FullScreen_RefreshRateInHz=60; -#else - Direct3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT,&mode); - d3dpp.BackBufferFormat=mode.Format; - d3dpp.Windowed=1; - d3dpp.hDeviceWindow=FrameWnd; -#endif - - // Try to create a device with hardware vertex processing: - for (i=0;i<3;i++) - { - int behave=D3DCREATE_HARDWARE_VERTEXPROCESSING; - - // Try software vertex processing: - if (i==1) behave=D3DCREATE_MIXED_VERTEXPROCESSING; - if (i==2) behave=D3DCREATE_SOFTWARE_VERTEXPROCESSING; - - Direct3D->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_HAL,FrameWnd, - behave|D3DCREATE_MULTITHREADED,&d3dpp,&Device); - if (Device) break; - } - - if (Device==NULL) - { -#if 0 - // try ref - Direct3D->CreateDevice(D3DADAPTER_DEFAULT,D3DDEVTYPE_REF,FrameWnd, - D3DCREATE_SOFTWARE_VERTEXPROCESSING|D3DCREATE_MULTITHREADED,&d3dpp,&Device); - if (Device==NULL) goto fail0; - HMODULE test = LoadLibrary("d3d8d.dll"); - if (test != NULL) FreeLibrary(test); - else { - error("Sorry, but this program requires Direct3D with hardware acceleration.\n\n" - "You can try using Direct3D software emulation, but you have to install " - "DirectX SDK for it to work\n(it seems to be missing now)."); - goto fail1; - } -#else - goto fail1; -#endif - } - - Device->GetBackBuffer(0,D3DBACKBUFFER_TYPE_MONO,&DirectBack); - if (DirectBack==NULL) goto fail1; - - Device->CreateVertexBuffer(sizeof(VertexList),0,D3DFVF_CUSTOMVERTEX,D3DPOOL_DEFAULT,&VertexBuffer); - if (VertexBuffer==NULL) goto fail2; - - ret=TexScreenInit(); if (ret) goto fail3; - - //FontInit(); - - Device->SetRenderState(D3DRS_LIGHTING,0); // Turn off lighting - - // Set up texture modes: - Device->SetTextureStageState(0,D3DTSS_ADDRESSU,D3DTADDRESS_CLAMP); - Device->SetTextureStageState(0,D3DTSS_ADDRESSV,D3DTADDRESS_CLAMP); - - return 0; - -fail3: - RELEASE(VertexBuffer) -fail2: - RELEASE(DirectBack) -fail1: - RELEASE(Device) -fail0: - RELEASE(Direct3D) - - return 1; -} - -void DirectExit() -{ - TexScreenExit(); - - // d3d - RELEASE(VertexBuffer) - RELEASE(DirectBack) - RELEASE(Device) - RELEASE(Direct3D) -} - -int DirectClear(unsigned int colour) -{ - if (Device != NULL) { - Device->Clear(0,NULL,D3DCLEAR_TARGET,colour,1.0f,0); - return 0; - } - - return 1; -} - -int DirectPresent() -{ - if (Device != NULL) { - Device->Present(NULL,NULL,NULL,NULL); - return 0; - } - - return 1; -} - -#define PI 3.14159265f - -static int MakeVertexList() -{ - struct CustomVertex *vert=NULL,*pv=NULL; - float dist=0.0f; - float scalex=0.0f,scaley=0.0f; - unsigned int colour=0xffffff; - float right=0.0f,bottom=0.0f; - - if (LoopMode!=8) colour=0x102040; - - dist=10.0f; scalex=dist*1.3333f; scaley=dist; - - scalex*=640.0f/(float)MainWidth; - scaley*=448.0f/(float)MainHeight; - - vert=VertexList; - - // Put the vertices for the corners of the screen: - pv=vert; - pv->z=dist; - pv->x=-scalex; pv->y=scaley; - pv->colour=colour; pv++; - - *pv=vert[0]; pv->x= scalex; pv->y= scaley; pv++; - *pv=vert[0]; pv->x=-scalex; pv->y=-scaley; pv++; - *pv=vert[0]; pv->x= scalex; pv->y=-scaley; pv++; - - // Find where the screen images ends on the texture - right =(float)EmuWidth /(float)TexWidth; - bottom=(float)EmuHeight/(float)TexHeight; - - // Write texture coordinates: - pv=vert; - pv->u=0.0f; pv->v=0.00f; pv++; - pv->u=right; pv->v=0.00f; pv++; - pv->u=0.0f; pv->v=bottom; pv++; - pv->u=right; pv->v=bottom; pv++; - - return 0; -} - -static int SetupMatrices() -{ - D3DXVECTOR3 eye ( 0.0f, 0.0f, 0.0f ); - D3DXVECTOR3 look( 0.0f, 0.0f, 0.0f ); - D3DXVECTOR3 up ( 0.0f, 1.0f, 0.0f ); - D3DXMATRIX mat; - float nudgex=0.0f,nudgey=0.0f; - - memset(&mat,0,sizeof(mat)); - - mat.m[0][0]=mat.m[1][1]=mat.m[2][2]=mat.m[3][3]=1.0f; - Device->SetTransform(D3DTS_WORLD,&mat); - - look.x=(float)Inp.axis[2]/2457.6f; - look.y=(float)Inp.axis[3]/2457.6f; - look.z=10.0f; - - // Nudge pixels to the centre of each screen pixel: - nudgex=13.3333f/(float)(MainWidth <<1); - nudgey=10.0000f/(float)(MainHeight<<1); - eye.x +=nudgex; eye.y +=nudgey; - look.x+=nudgex; look.y+=nudgey; - - D3DXMatrixLookAtLH(&mat,&eye,&look,&up); - Device->SetTransform(D3DTS_VIEW,&mat); - - D3DXMatrixPerspectiveFovLH(&mat, 0.5f*PI, 1.3333f, 0.2f, 1000.0f); - Device->SetTransform(D3DTS_PROJECTION,&mat); - return 0; -} - -int DirectScreen() -{ - unsigned char *lock=NULL; - int ret; - - if (Device == NULL) - return DirectScreenDDraw(); - - // Copy the screen to the screen texture: -#ifdef _XBOX - TexScreenSwizzle(); -#else - ret=TexScreenLinear(); - if (ret) lprintf("TexScreenLinear failed\n"); -#endif - - SetupMatrices(); - - MakeVertexList(); - - // Copy vertices in: - VertexBuffer->Lock(0,sizeof(VertexList),&lock,0); - if (lock==NULL) { lprintf("VertexBuffer->Lock failed\n"); return 1; } - memcpy(lock,VertexList,sizeof(VertexList)); - VertexBuffer->Unlock(); - - Device->BeginScene(); - Device->SetTexture(0,TexScreen); - Device->SetStreamSource(0,VertexBuffer,sizeof(CustomVertex)); - Device->SetVertexShader(D3DFVF_CUSTOMVERTEX); - Device->DrawPrimitive(D3DPT_TRIANGLESTRIP,0,2); - Device->EndScene(); - - return 0; -} -#endif - diff --git a/platform/win32/direct.h b/platform/win32/direct.h deleted file mode 100644 index a064b3fb..00000000 --- a/platform/win32/direct.h +++ /dev/null @@ -1,15 +0,0 @@ -#ifdef __cplusplus -extern "C" { -#endif - -int DirectInit(void); -void DirectExit(void); - -int DirectScreen(const void *emu_screen); -int DirectClear(unsigned int colour); -int DirectPresent(void); - - -#ifdef __cplusplus -} -#endif diff --git a/platform/win32/dsnd.cpp b/platform/win32/dsnd.cpp deleted file mode 100644 index 4e1930e9..00000000 --- a/platform/win32/dsnd.cpp +++ /dev/null @@ -1,165 +0,0 @@ -//#pragma warning (disable:4201) -#include -#define WIN32_LEAN_AND_MEAN -#include -#include -#include - -#include "dsnd.h" -#include "../common/lprintf.h" - -#define NSEGS 4 -#define RELEASE(x) if (x) x->Release(); x=NULL; - -static LPDIRECTSOUND DSound; -static LPDIRECTSOUNDBUFFER LoopBuffer; -static LPDIRECTSOUNDNOTIFY DSoundNotify; -static HANDLE seg_played_event; -static int LoopLen, LoopWrite, LoopSeg; // bytes - -static int LoopBlank(void) -{ - void *mema=NULL,*memb=NULL; - DWORD sizea=0,sizeb=0; - - LoopBuffer->Lock(0, LoopLen, &mema,&sizea, &memb,&sizeb, 0); - - if (mema) memset(mema,0,sizea); - - LoopBuffer->Unlock(mema,sizea, memb,sizeb); - - return 0; -} - -int DSoundInit(HWND wnd_coop, int rate, int stereo, int seg_samples) -{ - DSBUFFERDESC dsbd; - WAVEFORMATEX wfx; - DSBPOSITIONNOTIFY notifies[NSEGS]; - int i; - - memset(&dsbd,0,sizeof(dsbd)); - memset(&wfx,0,sizeof(wfx)); - - // Make wave format: - wfx.wFormatTag=WAVE_FORMAT_PCM; - wfx.nChannels=stereo ? 2 : 1; - wfx.nSamplesPerSec=rate; - wfx.wBitsPerSample=16; - - wfx.nBlockAlign=(WORD)((wfx.nChannels*wfx.wBitsPerSample)>>3); - wfx.nAvgBytesPerSec=wfx.nBlockAlign*wfx.nSamplesPerSec; - - // Create the DirectSound interface: - DirectSoundCreate(NULL,&DSound,NULL); - if (DSound==NULL) return 1; - - LoopSeg = seg_samples * 2; - if (stereo) - LoopSeg *= 2; - - LoopLen = LoopSeg * NSEGS; - - DSound->SetCooperativeLevel(wnd_coop, DSSCL_PRIORITY); - dsbd.dwFlags=DSBCAPS_GLOBALFOCUS; // Play in background - dsbd.dwFlags|=DSBCAPS_GETCURRENTPOSITION2|DSBCAPS_CTRLPOSITIONNOTIFY; - - // Create the looping buffer: - dsbd.dwSize=sizeof(dsbd); - dsbd.dwBufferBytes=LoopLen; - dsbd.lpwfxFormat=&wfx; - - DSound->CreateSoundBuffer(&dsbd,&LoopBuffer,NULL); - if (LoopBuffer==NULL) return 1; - - LoopBuffer->QueryInterface(IID_IDirectSoundNotify, (LPVOID*)&DSoundNotify); - if (DSoundNotify == NULL) { - lprintf("QueryInterface(IID_IDirectSoundNotify) failed\n"); - goto out; - } - - seg_played_event = CreateEvent(NULL, 0, 0, NULL); - if (seg_played_event == NULL) - goto out; - - for (i = 0; i < NSEGS; i++) { - notifies[i].dwOffset = i * LoopSeg; - notifies[i].hEventNotify = seg_played_event; - } - i = DSoundNotify->SetNotificationPositions(NSEGS, notifies); - if (i != DS_OK) { - lprintf("SetNotificationPositions failed\n"); - goto out; - } - -out: - LoopBlank(); - LoopBuffer->Play(0, 0, DSBPLAY_LOOPING); - return 0; -} - -void DSoundExit(void) -{ - if (LoopBuffer) - LoopBuffer->Stop(); - RELEASE(DSoundNotify); - RELEASE(LoopBuffer) - RELEASE(DSound) - CloseHandle(seg_played_event); - seg_played_event = NULL; -} - -static int WriteSeg(const void *buff) -{ - void *mema=NULL,*memb=NULL; - DWORD sizea=0,sizeb=0; - int ret; - - // Lock the segment at 'LoopWrite' and copy the next segment in - ret = LoopBuffer->Lock(LoopWrite, LoopSeg, &mema, &sizea, &memb, &sizeb, 0); - if (ret != DS_OK) - lprintf("LoopBuffer->Lock() failed: %i\n", ret); - - if (mema) memcpy(mema,buff,sizea); -// if (memb) memcpy(memb,DSoundNext+sizea,sizeb); - if (sizeb != 0) lprintf("sizeb is not 0! (%i)\n", sizeb); - - ret = LoopBuffer->Unlock(mema,sizea, memb, sizeb); - if (ret != DS_OK) - lprintf("LoopBuffer->Unlock() failed: %i\n", ret); - - return 0; -} - -int DSoundUpdate(const void *buff, int blocking) -{ - DWORD play = 0; - int pos; - - LoopBuffer->GetCurrentPosition(&play, NULL); - pos = play; - - // 'LoopWrite' is the next seg in the loop that we want to write - // First check that the sound 'play' pointer has moved out of it: - if (blocking) { - while (LoopWrite <= pos && pos < LoopWrite + LoopSeg) { - WaitForSingleObject(seg_played_event, 5000); - LoopBuffer->GetCurrentPosition(&play, NULL); - pos = play; - } - } - else { - if (LoopWrite <= pos && pos < LoopWrite + LoopSeg) - return 1; - } - - WriteSeg(buff); - - // Advance LoopWrite to next seg: - LoopWrite += LoopSeg; - if (LoopWrite + LoopSeg > LoopLen) - LoopWrite = 0; - - return 0; -} - diff --git a/platform/win32/dsnd.h b/platform/win32/dsnd.h deleted file mode 100644 index 9132bcb8..00000000 --- a/platform/win32/dsnd.h +++ /dev/null @@ -1,14 +0,0 @@ -#ifdef __cplusplus -extern "C" { -#endif - -int DSoundInit(HWND wnd_coop, int rate, int stereo, int seg_samples); -void DSoundExit(void); -int DSoundUpdate(const void *buff, int blocking); - -extern short *DSoundNext; - -#ifdef __cplusplus -} -#endif - -- 2.39.5