RaySollium99/picodrive
1
0
Fork 0
mirror of https://github.com/RaySollium99/picodrive.git synced 2025-09-05 07:17:45 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

start new makefile, migrate to libpicofe

Browse source
This commit is contained in:
notaz 2013-06-22 19:16:08 +03:00
parent 4685e5a10e
commit e743be2070
47 changed files with 246 additions and 6342 deletions
Download patch file Download diff file Expand all files Collapse all files

26
platform/common/arm_linux.S
View file

@ -1,26 +0,0 @@
@ vim:filetype=armasm
#include <sys/syscall.h>
.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

1
platform/common/arm_linux.h
View file

@ -1 +0,0 @@
extern void cache_flush_d_inval_i(const void *start_addr, const void *end_addr);

34
platform/common/common.mak
View file

@ -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
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
cpu/musashi/m68kops.c :
@make -C cpu/musashi
../../cpu/mz80/mz80.asm :
@make -C ../../cpu/mz80/
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

8
platform/common/config.c
View file

@ -9,16 +9,16 @@
#ifdef __EPOC32__
#include <unistd.h>
#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 <pico/pico.h>

47
platform/common/emu.c
View file

@ -10,14 +10,15 @@
#include <unistd.h>
#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 <pico/pico_int.h>
#include <pico/patch.h>
@ -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;
}

28
platform/common/emu.h
View file

@ -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

218
platform/common/fonts.c
View file

@ -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, },
};

4
platform/common/fonts.h
View file

@ -1,4 +0,0 @@
extern unsigned char fontdata8x8[64*16];
extern unsigned char fontdata6x8[256-32][8];

467
platform/common/in_sdl.c
View file

@ -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 <stdio.h>
#include <SDL.h>
#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);
}

3
platform/common/in_sdl.h
View file

@ -1,3 +0,0 @@
struct in_default_bind;
void in_sdl_init(const struct in_default_bind *defbinds);

991
platform/common/input.c
View file

@ -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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#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

140
platform/common/input.h
View file

@ -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 */

33
platform/common/input_pico.h Normal file
View file

@ -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 */

10
platform/common/lprintf.h
View file

@ -1,10 +0,0 @@
#ifdef __cplusplus
extern "C" {
#endif
extern void lprintf(const char *fmt, ...);
#ifdef __cplusplus
}
#endif

12
platform/common/main.c
View file

@ -8,11 +8,11 @@
#include <string.h>
#include <strings.h>
#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 <cpu/debug.h>
#include <version.h>
@ -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;
}

1327
platform/common/menu.c
View file

File diff suppressed because it is too large Load diff

132
platform/common/menu.h
View file

@ -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);

61
platform/common/menu_pico.c
View file

@ -2,35 +2,37 @@
#include "emu.h"
#include "menu_pico.h"
#include "input_pico.h"
#include <version.h>
#include <revision.h>
#include <pico/pico.h>
#include <pico/patch.h>
// 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();
}

12
platform/common/menu_pico.h
View file

@ -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__

62
platform/common/plat.h
View file

@ -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

23
platform/common/posix.h
View file

@ -1,23 +0,0 @@
/* define POSIX stuff: dirent, scandir, getcwd, mkdir */
#if defined(__linux__) || defined(__MINGW32__)
#include <dirent.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#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

266
platform/common/readpng.c
View file

@ -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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <png.h>
#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;
}

19
platform/common/readpng.h
View file

@ -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

12
platform/common/revision.mak
View file

@ -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:

2
platform/libpicofe

@ -1 +1 @@
Subproject commit da0cc55643353ab15725194be64a3d8460fe48b1
Subproject commit 7bf7acb6d60e16e9eaa208761d019c39da396fc0

97
platform/linux/Makefile
View file

@ -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 $@

6
platform/linux/emu.c
View file

@ -6,11 +6,11 @@
#include <stdio.h>
#include <unistd.h>
#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 <pico/pico_int.h>

311
platform/linux/fbdev.c
View file

@ -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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <linux/fb.h>
#include <linux/matroxfb.h>
#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);
}

14
platform/linux/fbdev.h
View file

@ -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);

655
platform/linux/in_evdev.c
View file

@ -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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <linux/input.h>
#include <errno.h>
#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);
}

8
platform/linux/io.c
View file

@ -2,11 +2,11 @@
#include <stdlib.h>
#include <string.h>
#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"

209
platform/linux/plat.c
View file

@ -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 <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <dirent.h>
#include <sys/time.h>
#include <time.h>
#include <unistd.h>
#include <sys/mman.h>
#include <errno.h>
#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);
}

175
platform/linux/sndout_oss.c
View file

@ -1,175 +0,0 @@
/* sound output via OSS */
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/soundcard.h>
#include <unistd.h>
#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;
}

9
platform/linux/sndout_oss.h
View file

@ -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);

455
platform/linux/xenv.c
View file

@ -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 <stdio.h>
#include <string.h>
#include <pthread.h>
#include <dlfcn.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/XKBlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <termios.h>
#include <linux/kd.h>
#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

18
platform/linux/xenv.h
View file

@ -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);

410
platform/win32/direct.cpp
View file

@ -1,410 +0,0 @@
// ddraw
#include <ddraw.h>
#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

15
platform/win32/direct.h
View file

@ -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

165
platform/win32/dsnd.cpp
View file

@ -1,165 +0,0 @@
//#pragma warning (disable:4201)
#include <stdlib.h>
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <mmsystem.h>
#include <dsound.h>
#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;
}

14
platform/win32/dsnd.h
View file

@ -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