m68k_areg (regs, 1) = a1;
tskname = au((char*)get_real_address (get_long (currtask + 10)));
- BSDTRACE ((L"[%s] ", au));
+ BSDTRACE ((L"[%s] ", tskname));
xfree (tskname);
return currtask;
}
}
sb->dosignal = 1;
- bsd_int_requested = 1;
+ bsd_int_requested |= 1;
unlocksigqueue ();
put_pointer (result + offsetof (struct UAEBSDBase, sb), sb);
- BSDTRACE ((L"%0lx [%d]\n", result, opencount));
+ BSDTRACE ((L"%0x [%d]\n", result, opencount));
} else
BSDTRACE ((L"failed (out of memory)\n"));
int cfgfile_yesno (const TCHAR *option, const TCHAR *value, const TCHAR *name, int *location)
{
- if (_tcscmp (option, name) != 0)
+ if (name != NULL && _tcscmp (option, name) != 0)
return 0;
if (strcasecmp (value, L"yes") == 0 || strcasecmp (value, L"y") == 0
|| strcasecmp (value, L"true") == 0 || strcasecmp (value, L"t") == 0)
{
int base = 10;
TCHAR *endptr;
- if (_tcscmp (option, name) != 0)
+ if (name != NULL && _tcscmp (option, name) != 0)
return 0;
*location = _tcstod (value, &endptr);
return 1;
{
int base = 10;
TCHAR *endptr;
- if (_tcscmp (option, name) != 0)
+ if (name != NULL && _tcscmp (option, name) != 0)
return 0;
/* I guess octal isn't popular enough to worry about here... */
if (value[0] == '0' && _totupper (value[1]) == 'X')
int cfgfile_strval (const TCHAR *option, const TCHAR *value, const TCHAR *name, int *location, const TCHAR *table[], int more)
{
int val;
- if (_tcscmp (option, name) != 0)
+ if (name != NULL && _tcscmp (option, name) != 0)
return 0;
val = match_string (table, value);
if (val == -1) {
return 0;
}
-static int cfgfile_separate_linea (char *line, TCHAR *line1b, TCHAR *line2b)
+static int cfgfile_separate_linea (const TCHAR *filename, char *line, TCHAR *line1b, TCHAR *line2b)
{
char *line1, *line2;
int i;
line2 = strchr (line, '=');
if (! line2) {
TCHAR *s = au (line1);
- write_log (L"CFGFILE: linea was incomplete with only %s\n", s);
+ write_log (L"CFGFILE: '%s', linea was incomplete with only %s\n", filename, s);
xfree (s);
return 0;
}
p->all_lines = u;
continue;
}
- if (!cfgfile_separate_linea (linea, line1b, line2b))
+ if (!cfgfile_separate_linea (filename, linea, line1b, line2b))
continue;
type1 = type2 = 0;
if (cfgfile_yesno (line1b, line2b, L"config_hardware", &type1) ||
int vs = isvsync_chipset ();
if (vs > 0) {
+
vsyncmintime = vsynctime;
render_screen ();
show_screen ();
return;
+
} else if (vs < 0) {
+
int freetime;
extern int extraframewait;
vsyncmintime = vsynctime;
vsyncmintime = curr_time + vsynctime;
show_screen ();
if (extraframewait)
- sleep_millis (extraframewait);
+ sleep_millis_main (extraframewait);
}
return;
}
+
bool didrender = false;
if (!picasso_on)
didrender = render_screen ();
return;
uae_u8 *p = dst->bufmem_allocated;
for (int y = 0; y < dst->height; y++) {
- memset(p, 0, dst->width * dst->pixbytes);
+ memset (p, 0, dst->width * dst->pixbytes);
p += dst->rowbytes;
}
}
extern void inputdevice_devicechange (struct uae_prefs *prefs);
extern int inputdevice_translatekeycode (int keyboard, int scancode, int state);
-extern void inputdevice_setkeytranslation (struct uae_input_device_kbr_default *trans, int **kbmaps);
+extern void inputdevice_setkeytranslation (struct uae_input_device_kbr_default **trans, int **kbmaps);
extern void inputdevice_do_keyboard (int code, int state);
extern int inputdevice_iskeymapped (int keyboard, int scancode);
extern int inputdevice_synccapslock (int, int*);
#define JPORT_AF_TOGGLE 2
#define JPORT_AF_ALWAYS 3
+#define KBTYPE_AMIGA 0
+#define KBTYPE_PC1 1
+#define KBTYPE_PC2 2
+
#define MAX_SPARE_DRIVES 20
#define MAX_CUSTOM_MEMORY_ADDRS 2
int input_tablet;
bool input_magic_mouse;
int input_magic_mouse_cursor;
+ int input_keyboard_type;
struct uae_input_device joystick_settings[MAX_INPUT_SETTINGS][MAX_INPUT_DEVICES];
struct uae_input_device mouse_settings[MAX_INPUT_SETTINGS][MAX_INPUT_DEVICES];
struct uae_input_device keyboard_settings[MAX_INPUT_SETTINGS][MAX_INPUT_DEVICES];
static struct uae_input_device *joysticks;
static struct uae_input_device *mice;
static struct uae_input_device *keyboards;
-static struct uae_input_device_kbr_default *keyboard_default;
+static struct uae_input_device_kbr_default *keyboard_default, **keyboard_default_table;
#define KBR_DEFAULT_MAP_FIRST 0
#define KBR_DEFAULT_MAP_LAST 5
write_config2 (f, idnum, i, ID_BUTTON_OFFSET, tmp1, id);
}
+static const TCHAR *kbtypes[] = { L"amiga", L"pc", NULL };
+
void write_inputdevice_config (struct uae_prefs *p, struct zfile *f)
{
int i, id;
cfgfile_write (f, L"input.analog_joystick_offset", L"%d", p->input_analog_joystick_offset);
cfgfile_write (f, L"input.mouse_speed", L"%d", p->input_mouse_speed);
cfgfile_write (f, L"input.autofire_speed", L"%d", p->input_autofire_linecnt);
+ cfgfile_dwrite_str (f, L"input.keyboard_type", kbtypes[p->input_keyboard_type]);
cfgfile_dwrite (f, L"input.contact_bounce", L"%d", p->input_contact_bounce);
for (id = 0; id < MAX_INPUT_SETTINGS; id++) {
TCHAR tmp[MAX_DPATH];
}
}
+static void inputdevice_default_kb (struct uae_prefs *p)
+{
+ keyboard_default = keyboard_default_table[p->input_keyboard_type];
+ for (int i = 0; i < MAX_INPUT_SETTINGS; i++) {
+ if (i == GAMEPORT_INPUT_SETTINGS) {
+ if (p->jports[0].id != JPORT_CUSTOM || p->jports[1].id != JPORT_CUSTOM) {
+ reset_inputdevice_slot (p, i);
+ }
+ }
+ set_kbr_default (p, i, -1);
+ }
+}
static void clear_id (struct uae_input_device *id)
{
pr->input_analog_joystick_mult = _tstol (value);
if (!strcasecmp (p, L"analog_joystick_offset"))
pr->input_analog_joystick_offset = _tstol (value);
+ if (!strcasecmp (p, L"keyboard_type")) {
+ cfgfile_strval (option, value, NULL, &pr->input_analog_joystick_offset, kbtypes, 0);
+ inputdevice_default_kb (pr);
+ }
+
if (!strcasecmp (p, L"contact_bounce"))
pr->input_contact_bounce = _tstol (value);
{
int i;
+ keyboard_default = keyboard_default_table[currprefs.input_keyboard_type];
+
copyjport (&changed_prefs, &currprefs, 0);
copyjport (&changed_prefs, &currprefs, 1);
copyjport (&changed_prefs, &currprefs, 2);
config_changed = 1;
}
+
// set default prefs to all input configuration settings
void inputdevice_default_prefs (struct uae_prefs *p)
{
- int i;
-
inputdevice_init ();
+
p->input_selected_setting = GAMEPORT_INPUT_SETTINGS;
p->input_joymouse_multiplier = 100;
p->input_joymouse_deadzone = 33;
p->input_analog_joystick_offset = -1;
p->input_mouse_speed = 100;
p->input_autofire_linecnt = 600;
- for (i = 0; i < MAX_INPUT_SETTINGS; i++) {
- if (i == GAMEPORT_INPUT_SETTINGS) {
- if (p->jports[0].id != JPORT_CUSTOM || p->jports[1].id != JPORT_CUSTOM) {
- reset_inputdevice_slot (p, i);
- }
- }
- set_kbr_default (p, i, -1);
- }
+ p->input_keyboard_type = 0;
+ inputdevice_default_kb (p);
}
// set default keyboard and keyboard>joystick layouts
-void inputdevice_setkeytranslation (struct uae_input_device_kbr_default *trans, int **kbmaps)
+void inputdevice_setkeytranslation (struct uae_input_device_kbr_default **trans, int **kbmaps)
{
- keyboard_default = trans;
+ keyboard_default_table = trans;
keyboard_default_kbmaps = kbmaps;
}
uae_u8 b;
b = RAW_STEALTH | IECODE_UP_PREFIX;
- record_key(((b << 1) | (b >> 7)) & 0xff);
+ record_key (((b << 1) | (b >> 7)) & 0xff);
b = IECODE_UP_PREFIX;
if ((code >> 8) == 0x01)
b |= STEALTHF_E0KEY;
DEFEVENT(KEY_2C,L"Keycode 0x2C",AM_K,0,0,0x2C)
DEFEVENT(KEY_3B,L"Keycode 0x3B",AM_K,0,0,0x3b)
-DEFEVENT(KEY_47,L"Keycode 0x47",AM_K,0,0,0x47)
-
-DEFEVENT(KEY_48,L"Keycode 0x48",AM_K,0,0,0x48)
-DEFEVENT(KEY_49,L"Keycode 0x49",AM_K,0,0,0x49)
-DEFEVENT(KEY_4B,L"Keycode 0x4B",AM_K,0,0,0x4b)
DEFEVENT(KEY_68,L"Keycode 0x68",AM_K,0,0,0x68)
DEFEVENT(KEY_69,L"Keycode 0x69",AM_K,0,0,0x69)
DEFEVENT(KEY_6A,L"Keycode 0x6A",AM_K,0,0,0x6a)
-DEFEVENT(KEY_6B,L"Keycode 0x6B",AM_K,0,0,0x6b)
DEFEVENT(KEY_6C,L"Keycode 0x6C",AM_K,0,0,0x6c)
-DEFEVENT(KEY_6D,L"Keycode 0x6D",AM_K,0,0,0x6d)
-DEFEVENT(KEY_6E,L"Keycode 0x6E",AM_K,0,0,0x6e)
-DEFEVENT(KEY_6F,L"Keycode 0x6F",AM_K,0,0,0x6f)
-DEFEVENT(KEY_70,L"Keycode 0x70",AM_K,0,0,0x70)
-DEFEVENT(KEY_71,L"Keycode 0x71",AM_K,0,0,0x71)
+DEFEVENT(KEY_INSERT,L"Insert (PC)",AM_K,0,0,0x47)
+DEFEVENT(KEY_PAGEUP,L"Page Up (PC)",AM_K,0,0,0x48)
+DEFEVENT(KEY_PAGEDOWN,L"Page Down (PC)",AM_K,0,0,0x49)
+DEFEVENT(KEY_F11,L"F11 (PC)",AM_K,0,0,0x4b)
+DEFEVENT(KEY_APPS,L"Apps (PC)",AM_K,0,0,0x6b)
+DEFEVENT(KEY_SYSRQ,L"PrtScr/SysRq (PC)",AM_K,0,0,0x6d)
+DEFEVENT(KEY_PAUSE,L"Pause/Break (PC)",AM_K,0,0,0x6e)
+DEFEVENT(KEY_F12,L"F12 (PC)",AM_K,0,0,0x6f)
+DEFEVENT(KEY_HOME,L"Home (PC)",AM_K,0,0,0x70)
+DEFEVENT(KEY_END,L"End (PC)",AM_K,0,0,0x71)
+
DEFEVENT(KEY_78,L"Keycode 0x78 (Reset Warning)",AM_K,0,0,0x78)
DEFEVENT(KEY_79,L"Keycode 0x79",AM_K,0,0,0x79)
DEFEVENT(KEY_7A,L"Keycode 0x7A",AM_K,0,0,0x7a)
fixup_prefs_dim2 (&prefs->gfx_size_win);
if (prefs->gfx_filter == 0 && prefs->gfx_filter_autoscale && !prefs->gfx_api)
prefs->gfx_filter = 1;
- if (prefs->gfx_avsync)
- prefs->gfx_avsyncmode = 1;
if (prefs->gfx_pvsync)
prefs->gfx_pvsyncmode = 1;
+ if (prefs->gfx_avsync && !prefs->gfx_avsyncmode && prefs->gfx_backbuffers < 2)
+ prefs->gfx_backbuffers = 2;
}
void fixup_cpu (struct uae_prefs *p)
p->cs_ramseyrev = 0x0f;
}
}
+ /* Can't fit genlock and A2024 or Graffiti at the same time,
+ * also Graffiti uses genlock audio bit as an enable signal
+ */
+ if (p->genlock && p->monitoremu)
+ p->genlock = false;
+
fixup_prefs_dimensions (p);
#if !defined (JIT)
return bReturn;
}
+#define GET_STATE_FREE 0
+#define GET_STATE_ACTIVE 1
+#define GET_STATE_CANCEL 2
+#define GET_STATE_FINISHED 3
+
static unsigned int thread_get2 (void *indexp)
{
int index = *((int*)indexp);
if (bsd->hGetEvents[index] == NULL)
break;
- if (bsd->threadGetargs_inuse[index] == -1)
- bsd->threadGetargs_inuse[index] = 0;
-
- if (bsd->threadGetargs_inuse[index]) {
+ if (bsd->threadGetargs_inuse[index] == GET_STATE_ACTIVE) {
args = &bsd->threadGetargs[index];
sb = args->sb;
} else {
host = gethostbyaddr (name_rp, namelen, addrtype);
}
- if (bsd->threadGetargs_inuse[index] != -1) {
+ if (bsd->threadGetargs_inuse[index] != GET_STATE_CANCEL) {
// No CTRL-C Signal
if (host == 0) {
// Error occured
else
name_rp = "";
proto = getprotobyname (name_rp);
- if (bsd->threadGetargs_inuse[index] != -1) { // No CTRL-C Signal
+ if (bsd->threadGetargs_inuse[index] != GET_STATE_CANCEL) { // No CTRL-C Signal
if (proto == 0) {
// Error occured
SETERRNO;
name_rp = (char*)get_real_address (nameport);
serv = getservbyname(name_rp, proto_rp);
}
- if (bsd->threadGetargs_inuse[index] != -1) {
+ if (bsd->threadGetargs_inuse[index] != GET_STATE_CANCEL) {
// No CTRL-C Signal
if (serv == 0) {
// Error occured
BSDTRACE((L"-> "));
- if (bsd->threadGetargs_inuse[index] != -1)
+ if (bsd->threadGetargs_inuse[index] == GET_STATE_ACTIVE)
SETSIGNAL;
- bsd->threadGetargs_inuse[index] = 0;
+ locksigqueue ();
+ bsd->threadGetargs_inuse[index] = GET_STATE_FINISHED;
+ unlocksigqueue ();
}
}
{
int i;
+ locksigqueue ();
+
for (i = 0; i < MAX_GET_THREADS; i++) {
- if (bsd->threadGetargs_inuse[i] == -1) {
- bsd->threadGetargs_inuse[i] = 0;
+ if (bsd->threadGetargs_inuse[i] == GET_STATE_FINISHED) {
+ bsd->threadGetargs_inuse[i] = GET_STATE_FREE;
}
- if (bsd->hGetThreads[i] && !bsd->threadGetargs_inuse[i])
+ if (bsd->hGetThreads[i] && bsd->threadGetargs_inuse[i] == GET_STATE_FREE) {
break;
+ }
}
if (i >= MAX_GET_THREADS) {
for (i = 0; i < MAX_GET_THREADS; i++) {
if (bsd->hGetThreads[i] == NULL) {
+ bsd->threadGetargs_inuse[i] = GET_STATE_FREE;
bsd->hGetEvents[i] = CreateEvent(NULL,FALSE,FALSE,NULL);
- bsd->hGetThreads[i] = THREAD(thread_get, &threadindextable[i]);
+ if (bsd->hGetEvents[i])
+ bsd->hGetThreads[i] = THREAD(thread_get, &threadindextable[i]);
if (bsd->hGetEvents[i] == NULL || bsd->hGetThreads[i] == NULL) {
- bsd->hGetThreads[i] = NULL;
+ if (bsd->hGetEvents[i])
+ CloseHandle (bsd->hGetEvents[i]);
+ bsd->hGetEvents[i] = NULL;
write_log (L"BSDSOCK: ERROR - Thread/Event creation failed - error code: %d\n",
GetLastError());
bsdsocklib_seterrno(sb, 12); // ENOMEM
sb->resultval = -1;
+ unlocksigqueue ();
return 0;
}
+ bsdsetpriority (bsd->hGetThreads[i]);
break;
}
}
write_log (L"BSDSOCK: ERROR - Too many gethostbyname()s\n");
bsdsocklib_seterrno(sb, 12); // ENOMEM
sb->resultval = -1;
+ unlocksigqueue ();
return 0;
} else {
- bsdsetpriority (bsd->hGetThreads[i]);
memcpy (&bsd->threadGetargs[i], args, sizeof (struct threadargs));
- bsd->threadGetargs_inuse[i] = 1;
+ bsd->threadGetargs_inuse[i] = GET_STATE_ACTIVE;
SetEvent(bsd->hGetEvents[i]);
}
+ unlocksigqueue ();
+
sb->eintr = 0;
- while (bsd->threadGetargs_inuse[i] != 0 && sb->eintr == 0) {
+ while (bsd->threadGetargs_inuse[i] != GET_STATE_FINISHED && sb->eintr == 0) {
WAITSIGNAL;
- if (sb->eintr == 1)
- bsd->threadGetargs_inuse[i] = -1;
+ locksigqueue ();
+ if (sb->eintr == 1 && bsd->threadGetargs_inuse[i] != GET_STATE_FINISHED)
+ bsd->threadGetargs_inuse[i] = GET_STATE_CANCEL;
+ unlocksigqueue ();
}
CANCELSIGNAL;
LPDIRECTINPUTDEVICE8 lpdi;
HANDLE rawinput;
HIDP_CAPS hidcaps;
+ HIDP_VALUE_CAPS hidvcaps[MAX_MAPPINGS];
PCHAR hidbuffer, hidbufferprev;
PHIDP_PREPARSED_DATA hidpreparseddata;
int maxusagelistlength;
TCHAR *axisname[MAX_MAPPINGS];
uae_s16 axissort[MAX_MAPPINGS];
uae_s16 axistype[MAX_MAPPINGS];
- uae_s32 axismax[MAX_MAPPINGS];
- uae_s32 axismin[MAX_MAPPINGS];
- uae_s16 axisusagepage[MAX_MAPPINGS];
bool analogstick;
uae_s16 buttonmappings[MAX_MAPPINGS];
{
int i, j;
uae_s16 tmpi;
- uae_s32 tmpl;
TCHAR *tmpc;
for (i = 0; i < did->axles; i++) {
for (j = i + 1; j < did->axles; j++) {
if (did->axissort[i] > did->axissort[j]) {
+ HIDP_VALUE_CAPS tmpvcaps;
tmpi = did->axismappings[i]; did->axismappings[i] = did->axismappings[j]; did->axismappings[j] = tmpi;
tmpi = did->axissort[i]; did->axissort[i] = did->axissort[j]; did->axissort[j] = tmpi;
tmpi = did->axistype[i]; did->axistype[i] = did->axistype[j]; did->axistype[j] = tmpi;
- tmpl = did->axismax[i]; did->axismax[i] = did->axismax[j]; did->axismax[j] = tmpl;
- tmpl = did->axismin[i]; did->axismin[i] = did->axismin[j]; did->axismin[j] = tmpl;
- tmpi = did->axisusagepage[i]; did->axisusagepage[i] = did->axisusagepage[j]; did->axisusagepage[j] = tmpi;
+ memcpy (&tmpvcaps, &did->hidvcaps[i], sizeof tmpvcaps);
+ memcpy (&did->hidvcaps[i], &did->hidvcaps[j], sizeof tmpvcaps);
+ memcpy (&did->hidvcaps[j], &tmpvcaps, sizeof tmpvcaps);
tmpc = did->axisname[i]; did->axisname[i] = did->axisname[j]; did->axisname[j] = tmpc;
}
}
#ifdef DI_DEBUG
if (did->axles + did->buttons > 0) {
- write_log (L"%s:\n", did->name);
+ write_log (L"%s: (%x/%x)\n", did->name, did->vid, did->pid);
if (did->connection == DIDC_DX)
write_log (L"PGUID=%s\n", outGUID (&did->pguid));
for (i = 0; i < did->axles; i++) {
- write_log (L"%02X %03d '%s' (%d, [%d - %d])\n",
- did->axismappings[i], did->axismappings[i], did->axisname[i], did->axissort[i], did->axismin[i], did->axismax[i]);
+ HIDP_VALUE_CAPS *caps = &did->hidvcaps[i];
+ write_log (L"%02X %03d '%s' (%d, [%d - %d, %d - %d, %d %d %d])\n",
+ did->axismappings[i], did->axismappings[i], did->axisname[i], did->axissort[i],
+ caps->LogicalMin, caps->LogicalMax, caps->PhysicalMin, caps->PhysicalMax,
+ caps->BitSize, caps->Units, caps->UnitsExp);
}
for (i = 0; i < did->buttons; i++) {
write_log (L"%02X %03d '%s' (%d)\n",
{ 0 }
};
+static int extractbits (uae_u32 val, int bits, bool issigned)
+{
+ if (issigned)
+ return val & (1 << (bits - 1)) ? val | (-1 << bits) : val;
+ else
+ return val & ((1 << bits) - 1);
+}
+
+struct hidquirk
+{
+ uae_u16 vid, pid;
+};
+
+#define USB_VENDOR_ID_LOGITECH 0x046d
+#define USB_DEVICE_ID_LOGITECH_G13 0xc2ab
+#define USB_VENDOR_ID_AASHIMA 0x06d6
+#define USB_DEVICE_ID_AASHIMA_GAMEPAD 0x0025
+#define USB_DEVICE_ID_AASHIMA_PREDATOR 0x0026
+#define USB_VENDOR_ID_ALPS 0x0433
+#define USB_DEVICE_ID_IBM_GAMEPAD 0x1101
+#define USB_VENDOR_ID_CHIC 0x05fe
+#define USB_DEVICE_ID_CHIC_GAMEPAD 0x0014
+#define USB_VENDOR_ID_DWAV 0x0eef
+#define USB_DEVICE_ID_EGALAX_TOUCHCONTROLLER 0x0001
+#define USB_VENDOR_ID_MOJO 0x8282
+#define USB_DEVICE_ID_RETRO_ADAPTER 0x3201
+#define USB_VENDOR_ID_HAPP 0x078b
+#define USB_DEVICE_ID_UGCI_DRIVING 0x0010
+#define USB_DEVICE_ID_UGCI_FLYING 0x0020
+#define USB_DEVICE_ID_UGCI_FIGHTING 0x0030
+#define USB_VENDOR_ID_NATSU 0x08b7
+#define USB_DEVICE_ID_NATSU_GAMEPAD 0x0001
+#define USB_VENDOR_ID_NEC 0x073e
+#define USB_DEVICE_ID_NEC_USB_GAME_PAD 0x0301
+#define USB_VENDOR_ID_NEXTWINDOW 0x1926
+#define USB_DEVICE_ID_NEXTWINDOW_TOUCHSCREEN 0x0003
+#define USB_VENDOR_ID_SAITEK 0x06a3
+#define USB_DEVICE_ID_SAITEK_RUMBLEPAD 0xff17
+#define USB_VENDOR_ID_TOPMAX 0x0663
+#define USB_DEVICE_ID_TOPMAX_COBRAPAD 0x0103
+
+static const struct hidquirk quirks[] = {
+ { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G13 },
+ { USB_VENDOR_ID_AASHIMA, USB_DEVICE_ID_AASHIMA_GAMEPAD },
+ { USB_VENDOR_ID_AASHIMA, USB_DEVICE_ID_AASHIMA_PREDATOR },
+ { USB_VENDOR_ID_ALPS, USB_DEVICE_ID_IBM_GAMEPAD },
+ { USB_VENDOR_ID_CHIC, USB_DEVICE_ID_CHIC_GAMEPAD },
+ { USB_VENDOR_ID_DWAV, USB_DEVICE_ID_EGALAX_TOUCHCONTROLLER },
+ { USB_VENDOR_ID_MOJO, USB_DEVICE_ID_RETRO_ADAPTER },
+ { USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_DRIVING },
+ { USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_FLYING },
+ { USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_FIGHTING },
+ { USB_VENDOR_ID_NATSU, USB_DEVICE_ID_NATSU_GAMEPAD },
+ { USB_VENDOR_ID_NEC, USB_DEVICE_ID_NEC_USB_GAME_PAD },
+ { USB_VENDOR_ID_NEXTWINDOW, USB_DEVICE_ID_NEXTWINDOW_TOUCHSCREEN },
+ { USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RUMBLEPAD },
+ { USB_VENDOR_ID_TOPMAX, USB_DEVICE_ID_TOPMAX_COBRAPAD },
+ { 0 }
+};
+
+static void fixhidvcaps (RID_DEVICE_INFO_HID *hid, HIDP_VALUE_CAPS *caps)
+{
+ int pid = hid->dwProductId;
+ int vid = hid->dwVendorId;
+ ULONG mask = (1 << caps->BitSize) - 1;
+ /* min is always signed.
+ * if min < 0, max is signed, otherwise it is unsigned
+ */
+ if (caps->PhysicalMin >= 0)
+ caps->PhysicalMax = (uae_u32)(caps->PhysicalMax & mask);
+ else
+ caps->PhysicalMax = (uae_s32)caps->PhysicalMax;
+
+ if (caps->LogicalMin >= 0)
+ caps->LogicalMax = (uae_u32)(caps->LogicalMax & mask);
+ else
+ caps->LogicalMax = (uae_s32)caps->LogicalMax;
+
+ for (int i = 0; quirks[i].vid; i++) {
+ if (vid == quirks[i].vid && pid == quirks[i].pid) {
+ caps->LogicalMin = 0;
+ caps->LogicalMax = 255;
+ break;
+ }
+ }
+
+}
+
static bool initialize_rawinput (void)
{
RAWINPUTDEVICELIST *ridl = 0;
did->axisname[axiscnt] = my_strdup (tmp);
did->axissort[axiscnt] = hidtable[ht].priority * 2 + l;
did->axismappings[axiscnt] = acnt;
- did->axisusagepage[axiscnt] = vcaps[i].UsagePage;
- did->axismin[axiscnt] = vcaps[i].LogicalMin;
- did->axismax[axiscnt] = vcaps[i].LogicalMax < 0 || vcaps[i].LogicalMax > 65535 ? 65535 : vcaps[i].LogicalMax;
+ memcpy (&did->hidvcaps[axiscnt], &vcaps[i], sizeof HIDP_VALUE_CAPS);
+ fixhidvcaps (&rdi->hid, &did->hidvcaps[axiscnt]);
did->axistype[axiscnt] = l + 1;
axiscnt++;
}
did->axissort[axiscnt] = hidtable[ht].priority * 2;
did->axisname[axiscnt] = my_strdup (hidtable[ht].name);
did->axismappings[axiscnt] = acnt;
- did->axisusagepage[axiscnt] = vcaps[i].UsagePage;
- did->axismin[axiscnt] = vcaps[i].LogicalMin;
- did->axismax[axiscnt] = vcaps[i].LogicalMax < 0 || vcaps[i].LogicalMax > 65535 ? 65535 : vcaps[i].LogicalMax;
+ memcpy (&did->hidvcaps[axiscnt], &vcaps[i], sizeof HIDP_VALUE_CAPS);
+ fixhidvcaps (&rdi->hid, &did->hidvcaps[axiscnt]);
did->axistype[axiscnt] = hidtable[ht].type;
axiscnt++;
did->analogstick = true;
for (int axisnum = 0; axisnum < did->axles; axisnum++) {
ULONG val;
int usage = did->axismappings[axisnum];
- if (HidP_GetUsageValue (HidP_Input, did->axisusagepage[axisnum], 0, usage, &val, did->hidpreparseddata, rawdata, hid->dwSizeHid) == HIDP_STATUS_SUCCESS) {
+ NTSTATUS status;
+
+ status = HidP_GetUsageValue (HidP_Input, did->hidvcaps[axisnum].UsagePage, 0, usage, &val, did->hidpreparseddata, rawdata, hid->dwSizeHid);
+ if (status == HIDP_STATUS_SUCCESS) {
int data = 0;
- int range = 0;
int digitalrange = 0;
+ HIDP_VALUE_CAPS *vcaps = &did->hidvcaps[axisnum];
int type = did->axistype[axisnum];
+ int logicalrange = (vcaps->LogicalMax - vcaps->LogicalMin) / 2;
+ uae_u32 mask = (1 << vcaps->BitSize) - 1;
if (type == AXISTYPE_POV_X || type == AXISTYPE_POV_Y) {
- int min = did->axismin[axisnum];
- range = 127;
- digitalrange = range * 2 / 3;
- if (did->axismax[axisnum] - min == 7) {
+ int min = vcaps->LogicalMin;
+ if (vcaps->LogicalMax - min == 7) {
if (val == min + 0 && type == AXISTYPE_POV_Y)
data = -127;
if (val == min + 2 && type == AXISTYPE_POV_X)
data = -127;
}
- } else if (type == AXISTYPE_SLIDER || type == AXISTYPE_DIAL) {
+ } else {
- range = (did->axismax[axisnum] - did->axismin[axisnum]) / 2;
- digitalrange = range * 2 / 3;
- data = (int)val - range;
- //write_log (L"%d %d: %d\n", num, axisnum, data);
- if (istest) {
- if (data < -digitalrange)
- data = -range;
- else if (data > digitalrange)
- data = range;
- else
- data = 0;
- }
+ int v;
- } else {
+ v = extractbits (val, vcaps->BitSize, vcaps->LogicalMin < 0);
+
+ if (v < vcaps->LogicalMin)
+ v = vcaps->LogicalMin;
+ else if (v > vcaps->LogicalMax)
+ v = vcaps->LogicalMax;
+
+ v -= logicalrange + vcaps->LogicalMin;
- range = (did->axismax[axisnum] - did->axismin[axisnum]) / 2;
- digitalrange = range * 2 / 3;
- data = ((int)val) - range;
- //write_log (L"%d %d: (%d-%d) %d\n", num, axisnum, did->axismin[axisnum], did->axismax[axisnum], data);
+ //if (axisnum == 0)
+ // write_log (L"%d\n", v);
+
+ data = v;
+
+ digitalrange = logicalrange * 2 / 3;
if (istest) {
if (data < -digitalrange)
- data = -range;
+ data = -logicalrange;
else if (data > digitalrange)
- data = range;
+ data = logicalrange;
else
data = 0;
//write_log (L"%d %d: (%d-%d) %d\n", num, axisnum, did->axismin[axisnum], did->axismax[axisnum], data);
}
-
}
- if (data != axisold[num][axisnum] && range) {
+ if (data != axisold[num][axisnum] && logicalrange) {
//write_log (L"%d %d: %d->%d\n", num, axisnum, axisold[num][axisnum], data);
axisold[num][axisnum] = data;
int bstate = -1;
for (j = 0; j < did->buttons; j++) {
if (did->buttonaxisparent[j] >= 0 && did->buttonmappings[j] == usage) {
- if (did->buttonaxisparentdir[j] == 0 && data > digitalrange)
+ if (did->buttonaxisparentdir[j] == 0 && data < -digitalrange)
bstate = j;
- else if (did->buttonaxisparentdir[j] && data < -digitalrange)
+ else if (did->buttonaxisparentdir[j] && data > digitalrange)
bstate = j;
}
}
- setjoystickstate (num, axisnum, data, range);
+ setjoystickstate (num, axisnum, data, logicalrange);
if (bstate >= 0)
setjoybuttonstate (num, bstate, -1);
}
int ispressed (int key)
{
+ if (key < 0 || key > 255)
+ return 0;
int i;
for (i = 0; i < MAX_INPUT_DEVICES; i++) {
if (di_keycodes[i][key])
static int d3d_enabled, d3d_ex;
static IDirect3D9 *d3d;
static IDirect3D9Ex *d3dex;
+static IDirect3DSwapChain9 *d3dswapchain;
static D3DPRESENT_PARAMETERS dpp;
static D3DDISPLAYMODEEX modeex;
static IDirect3DDevice9 *d3ddev;
static int cursor_offset_x, cursor_offset_y, cursor_offset2_x, cursor_offset2_y;
static float maskmult_x, maskmult_y;
static RECT mask2rect;
+static bool wasstilldrawing_broken;
static D3DXMATRIXA16 m_matProj, m_matProj2;
static D3DXMATRIXA16 m_matWorld, m_matWorld2;
static int createmasktexture (const TCHAR *filename)
{
- int ww = window_w;
- int hh = window_h;
struct zfile *zf;
int size;
uae_u8 *buf;
masktexture = tx;
tx = NULL;
} else {
- masktexture = createtext (ww, hh, D3DFMT_X8R8G8B8);
+ masktexture = createtext (window_w, window_h, D3DFMT_X8R8G8B8);
if (FAILED (hr)) {
write_log (L"%s: mask texture creation failed: %s\n", D3DHEAD, D3D_ErrorString (hr));
goto end;
masktexture_h = maskdesc.Height;
}
write_log (L"%s: mask %d*%d (%d*%d) ('%s') texture allocated\n", D3DHEAD, masktexture_w, masktexture_h, txdesc.Width, txdesc.Height, filename);
- maskmult_x = (float)ww / masktexture_w;
- maskmult_y = (float)hh / masktexture_h;
+ maskmult_x = (float)window_w / masktexture_w;
+ maskmult_y = (float)window_h / masktexture_h;
return 1;
end:
static void D3D_free2 (void)
{
invalidatedeviceobjects ();
+ if (d3dswapchain) {
+ d3dswapchain->Release ();
+ d3dswapchain = NULL;
+ }
if (d3ddev) {
d3ddev->Release ();
d3ddev = NULL;
*vpos = -2;
if (!isd3d ())
return false;
- hr = d3ddev->GetRasterStatus (0, &rt);
+ if (d3dswapchain)
+ hr = d3dswapchain->GetRasterStatus (&rt);
+ else
+ hr = d3ddev->GetRasterStatus (0, &rt);
if (FAILED (hr)) {
write_log (L"%s: GetRasterStatus %s\n", D3DHEAD, D3D_ErrorString (hr));
return false;
return true;
}
+static int getd3dadapter (IDirect3D9 *d3d)
+{
+ struct MultiDisplay *md = getdisplay (&currprefs);
+ int num = d3d->GetAdapterCount ();
+ HMONITOR winmon;
+ POINT pt;
+
+ pt.x = (md->rect.right - md->rect.left) / 2 + md->rect.left;
+ pt.y = (md->rect.bottom - md->rect.top) / 2 + md->rect.top;
+ winmon = MonitorFromPoint (pt, MONITOR_DEFAULTTONEAREST);
+ for (int i = 0; i < num; i++) {
+ HMONITOR d3dmon = d3d->GetAdapterMonitor (i);
+ if (d3dmon == winmon)
+ return i;
+ }
+ return D3DADAPTER_DEFAULT;
+}
const TCHAR *D3D_init (HWND ahwnd, int w_w, int w_h, int t_w, int t_h, int depth, int mmult)
{
else
D3DHEAD = L"D3D9";
- adapter = currprefs.gfx_display - 1;
- if (adapter < 0)
- adapter = 0;
- if (adapter >= d3d->GetAdapterCount ())
- adapter = 0;
+
+ adapter = getd3dadapter (d3d);
modeex.Size = sizeof modeex;
if (d3dex && D3DEX) {
dpp.Windowed ? 0 : dpp.FullScreen_RefreshRateInHz,
dpp.Windowed ? L"" : L" FS",
vsync, dpp.BackBufferCount,
- dpp.PresentationInterval == D3DPRESENT_INTERVAL_IMMEDIATE ? L"I" : L"F",
+ dpp.PresentationInterval & D3DPRESENT_INTERVAL_IMMEDIATE ? L"I" : L"F",
bb == 0 ? L"E" : L"",
t_depth, adapter
);
changed_prefs.gfx_filter_scanlines = currprefs.gfx_filter_scanlines = 0;
}
+ hr = d3ddev->GetSwapChain (0, &d3dswapchain);
+ if (FAILED (hr)) {
+ write_log (L"%s: GetSwapChain() failed, %s\n", D3DHEAD, D3D_ErrorString (hr));
+ }
+
switch (depth)
{
case 32:
}
maxscanline = 0;
d3d_enabled = 1;
+ wasstilldrawing_broken = true;
if (vsync < 0 && bb == 0) {
hr = d3ddev->CreateQuery(D3DQUERYTYPE_EVENT, &query);
return 0;
}
+static void D3D_showframe2 (bool dowait)
+{
+ HRESULT hr;
+
+ if (!isd3d ())
+ return;
+ for (;;) {
+ if (d3dswapchain)
+ hr = d3dswapchain->Present (NULL, NULL, NULL, NULL, dowait ? 0 : D3DPRESENT_DONOTWAIT);
+ else
+ hr = d3ddev->Present (NULL, NULL, NULL, NULL);
+ if (hr == D3DERR_WASSTILLDRAWING) {
+ wasstilldrawing_broken = false;
+ } else if (hr == S_PRESENT_OCCLUDED) {
+ return;
+ } else {
+ if (hr != FAILED (hr)) {
+ write_log (L"%s: Present() %s\n", D3DHEAD, D3D_ErrorString (hr));
+ if (hr == D3DERR_DEVICELOST || hr == S_PRESENT_MODE_CHANGED) {
+ devicelost = 1;
+ }
+ }
+ return;
+ }
+ if (!dowait)
+ return;
+ sleep_millis (1);
+ }
+}
+
void D3D_clear (void)
{
int i;
return;
for (i = 0; i < 2; i++) {
hr = d3ddev->Clear (0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, d3ddebug ? 0x80 : 0x00), 0, 0);
- hr = d3ddev->Present (NULL, NULL, NULL, NULL);
+ D3D_showframe2 (true);
}
}
bool D3D_renderframe (void)
{
- static int frameskip;
-
if (!isd3d ())
return false;
- if (currprefs.turbo_emulation && isfullscreen () > 0 && frameskip-- > 0)
- return false;
- frameskip = 50;
D3D_render2 ();
if (vsync2 && !currprefs.turbo_emulation) {
void D3D_showframe (void)
{
- HRESULT hr;
-
- if (!isd3d ())
- return;
- hr = d3ddev->Present (NULL, NULL, NULL, NULL);
- if (FAILED (hr)) {
- write_log (L"%s: Present() %s\n", D3DHEAD, D3D_ErrorString (hr));
- if (hr == D3DERR_DEVICELOST) {
- devicelost = 1;
+ if (currprefs.turbo_emulation) {
+ if (!(dpp.PresentationInterval & D3DPRESENT_INTERVAL_IMMEDIATE) && wasstilldrawing_broken) {
+ static int frameskip;
+ if (currprefs.turbo_emulation && frameskip-- > 0)
+ return;
+ frameskip = 50;
}
+ D3D_showframe2 (false);
+ } else {
+ D3D_showframe2 (true);
}
}
if (!isd3d ())
return;
D3D_render2 ();
- D3D_showframe ();
+ D3D_showframe2 (true);
D3D_render2 ();
- D3D_showframe ();
+ D3D_showframe2 (true);
createscanlines (0);
}
ddrval = IDirectDraw7_CreateSurface (dxdata.maindd, &desc, &dxdata.primary, NULL);
if (SUCCEEDED (ddrval)) {
DDSCAPS2 ddscaps;
- memset (&ddscaps, 0, sizeof (ddscaps));
+ memset (&ddscaps, 0, sizeof ddscaps);
ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
ddrval = IDirectDrawSurface7_GetAttachedSurface (dxdata.primary, &ddscaps, &dxdata.flipping[0]);
if(SUCCEEDED (ddrval)) {
if (desc.dwBackBufferCount > 1) {
- memset (&ddscaps, 0, sizeof (ddscaps));
+ memset (&ddscaps, 0, sizeof ddscaps);
ddscaps.dwCaps = DDSCAPS_FLIP;
ddrval = IDirectDrawSurface7_GetAttachedSurface (dxdata.flipping[0], &ddscaps, &dxdata.flipping[1]);
}
showcaps (&hc);
}
-static int guidcounter;
static GUID monitorguids[MAX_DISPLAYS];
static BOOL CALLBACK displaysCallback (GUID *guid, char *adesc, char *aname, LPVOID ctx, HMONITOR hm)
{
- if (guidcounter >= MAX_DISPLAYS)
- return FALSE;
+ HMONITOR winmon;
+ POINT pt;
+ int i;
+
if (guid == NULL)
return TRUE;
- memcpy (&monitorguids[guidcounter], guid, sizeof GUID);
- guidcounter++;
+ for (i = 0; Displays[i].monitorname; i++) {
+ struct MultiDisplay *md = &Displays[i];
+ pt.x = (md->rect.right - md->rect.left) / 2 + md->rect.left;
+ pt.y = (md->rect.bottom - md->rect.top) / 2 + md->rect.top;
+ winmon = MonitorFromPoint (pt, MONITOR_DEFAULTTONEAREST);
+ if (hm == winmon) {
+ memcpy (&monitorguids[i], guid, sizeof GUID);
+ return TRUE;
+ }
+ }
return TRUE;
}
int DirectDraw_Start (void)
{
+ static bool guidsenumerated;
static int first, firstdd;
HRESULT ddrval;
LPDIRECT3D9 d3d;
return 1;
}
- if (!guidcounter)
+ if (!guidsenumerated) {
+ guidsenumerated = true;
DirectDrawEnumerateExA (displaysCallback, 0, DDENUM_DETACHEDSECONDARYDEVICES | DDENUM_ATTACHEDSECONDARYDEVICES);
+ }
guid = NULL;
if (isfullscreen () > 0) {
int disp = currprefs.gfx_display - 1;
if (disp < 0)
disp = 0;
- if (disp >= guidcounter)
+ if (disp >= MAX_DISPLAYS)
disp = 0;
guid = &monitorguids[disp];
}
//#define DBG_KEYBD 1
//#define DEBUG_KBD
-static struct uae_input_device_kbr_default keytrans[] = {
+static struct uae_input_device_kbr_default keytrans_amiga[] = {
{ DIK_ESCAPE, INPUTEVENT_KEY_ESC },
{ DIK_DELETE, INPUTEVENT_KEY_DEL },
{ DIK_HOME, INPUTEVENT_KEY_AMIGA_RIGHT },
{ DIK_NEXT, INPUTEVENT_KEY_HELP },
+ { DIK_PRIOR, INPUTEVENT_SPC_FREEZEBUTTON },
{ DIK_LBRACKET, INPUTEVENT_KEY_LEFTBRACKET },
{ DIK_RBRACKET, INPUTEVENT_KEY_RIGHTBRACKET },
// { DIK_VOLUMEUP, INPUTEVENT_SPC_MASTER_VOLUME_UP },
// { DIK_MUTE, INPUTEVENT_SPC_MASTER_VOLUME_MUTE },
- { DIK_HOME, INPUTEVENT_KEY_70 },
- { DIK_END, INPUTEVENT_KEY_71 },
-// { DIK_SYSRQ, INPUTEVENT_KEY_6E },
-// { DIK_F12, INPUTEVENT_KEY_6F },
- { DIK_INSERT, INPUTEVENT_KEY_47 },
-// { DIK_PRIOR, INPUTEVENT_KEY_48 },
- { DIK_PRIOR, INPUTEVENT_SPC_FREEZEBUTTON },
- { DIK_NEXT, INPUTEVENT_KEY_49 },
- { DIK_F11, INPUTEVENT_KEY_4B },
+// { DIK_HOME, INPUTEVENT_KEY_70 },
+ { DIK_END, INPUTEVENT_KEY_END },
+// { DIK_SYSRQ, INPUTEVENT_KEY_6E },
+// { DIK_F12, INPUTEVENT_KEY_6F },
+// { DIK_INSERT, INPUTEVENT_KEY_47 },
+// { DIK_PRIOR, INPUTEVENT_KEY_48 },
+// { DIK_NEXT, INPUTEVENT_KEY_49 },
+ { DIK_F11, INPUTEVENT_KEY_F11 },
{ DIK_MEDIASTOP, INPUTEVENT_KEY_CDTV_STOP },
{ DIK_PLAYPAUSE, INPUTEVENT_KEY_CDTV_PLAYPAUSE },
{ -1, 0 }
};
+static struct uae_input_device_kbr_default keytrans_pc1[] = {
+
+ { DIK_ESCAPE, INPUTEVENT_KEY_ESC },
+
+ { DIK_F1, INPUTEVENT_KEY_F1 },
+ { DIK_F2, INPUTEVENT_KEY_F2 },
+ { DIK_F3, INPUTEVENT_KEY_F3 },
+ { DIK_F4, INPUTEVENT_KEY_F4 },
+ { DIK_F5, INPUTEVENT_KEY_F5 },
+ { DIK_F6, INPUTEVENT_KEY_F6 },
+ { DIK_F7, INPUTEVENT_KEY_F7 },
+ { DIK_F8, INPUTEVENT_KEY_F8 },
+ { DIK_F9, INPUTEVENT_KEY_F9 },
+ { DIK_F10, INPUTEVENT_KEY_F10 },
+ { DIK_F11, INPUTEVENT_KEY_F11 },
+ { DIK_F12, INPUTEVENT_KEY_F12 },
+
+ { DIK_1, INPUTEVENT_KEY_1 },
+ { DIK_2, INPUTEVENT_KEY_2 },
+ { DIK_3, INPUTEVENT_KEY_3 },
+ { DIK_4, INPUTEVENT_KEY_4 },
+ { DIK_5, INPUTEVENT_KEY_5 },
+ { DIK_6, INPUTEVENT_KEY_6 },
+ { DIK_7, INPUTEVENT_KEY_7 },
+ { DIK_8, INPUTEVENT_KEY_8 },
+ { DIK_9, INPUTEVENT_KEY_9 },
+ { DIK_0, INPUTEVENT_KEY_0 },
+
+ { DIK_TAB, INPUTEVENT_KEY_TAB },
+
+ { DIK_A, INPUTEVENT_KEY_A },
+ { DIK_B, INPUTEVENT_KEY_B },
+ { DIK_C, INPUTEVENT_KEY_C },
+ { DIK_D, INPUTEVENT_KEY_D },
+ { DIK_E, INPUTEVENT_KEY_E },
+ { DIK_F, INPUTEVENT_KEY_F },
+ { DIK_G, INPUTEVENT_KEY_G },
+ { DIK_H, INPUTEVENT_KEY_H },
+ { DIK_I, INPUTEVENT_KEY_I },
+ { DIK_J, INPUTEVENT_KEY_J },
+ { DIK_K, INPUTEVENT_KEY_K },
+ { DIK_L, INPUTEVENT_KEY_L },
+ { DIK_M, INPUTEVENT_KEY_M },
+ { DIK_N, INPUTEVENT_KEY_N },
+ { DIK_O, INPUTEVENT_KEY_O },
+ { DIK_P, INPUTEVENT_KEY_P },
+ { DIK_Q, INPUTEVENT_KEY_Q },
+ { DIK_R, INPUTEVENT_KEY_R },
+ { DIK_S, INPUTEVENT_KEY_S },
+ { DIK_T, INPUTEVENT_KEY_T },
+ { DIK_U, INPUTEVENT_KEY_U },
+ { DIK_W, INPUTEVENT_KEY_W },
+ { DIK_V, INPUTEVENT_KEY_V },
+ { DIK_X, INPUTEVENT_KEY_X },
+ { DIK_Y, INPUTEVENT_KEY_Y },
+ { DIK_Z, INPUTEVENT_KEY_Z },
+
+ { DIK_CAPITAL, INPUTEVENT_KEY_CAPS_LOCK, ID_FLAG_TOGGLE },
+
+ { DIK_NUMPAD1, INPUTEVENT_KEY_NP_1 },
+ { DIK_NUMPAD2, INPUTEVENT_KEY_NP_2 },
+ { DIK_NUMPAD3, INPUTEVENT_KEY_NP_3 },
+ { DIK_NUMPAD4, INPUTEVENT_KEY_NP_4 },
+ { DIK_NUMPAD5, INPUTEVENT_KEY_NP_5 },
+ { DIK_NUMPAD6, INPUTEVENT_KEY_NP_6 },
+ { DIK_NUMPAD7, INPUTEVENT_KEY_NP_7 },
+ { DIK_NUMPAD8, INPUTEVENT_KEY_NP_8 },
+ { DIK_NUMPAD9, INPUTEVENT_KEY_NP_9 },
+ { DIK_NUMPAD0, INPUTEVENT_KEY_NP_0 },
+ { DIK_DECIMAL, INPUTEVENT_KEY_NP_PERIOD },
+ { DIK_ADD, INPUTEVENT_KEY_NP_ADD },
+ { DIK_SUBTRACT, INPUTEVENT_KEY_NP_SUB },
+ { DIK_MULTIPLY, INPUTEVENT_KEY_NP_MUL },
+ { DIK_DIVIDE, INPUTEVENT_KEY_NP_DIV },
+ { DIK_NUMPADENTER, INPUTEVENT_KEY_ENTER },
+
+ { DIK_MINUS, INPUTEVENT_KEY_SUB },
+ { DIK_EQUALS, INPUTEVENT_KEY_EQUALS },
+ { DIK_BACK, INPUTEVENT_KEY_BACKSPACE },
+ { DIK_RETURN, INPUTEVENT_KEY_RETURN },
+ { DIK_SPACE, INPUTEVENT_KEY_SPACE },
+
+ { DIK_LSHIFT, INPUTEVENT_KEY_SHIFT_LEFT },
+ { DIK_LCONTROL, INPUTEVENT_KEY_CTRL },
+ { DIK_LWIN, INPUTEVENT_KEY_AMIGA_LEFT },
+ { DIK_LMENU, INPUTEVENT_KEY_ALT_LEFT },
+ { DIK_RMENU, INPUTEVENT_KEY_ALT_RIGHT },
+ { DIK_RWIN, INPUTEVENT_KEY_AMIGA_RIGHT },
+ { DIK_APPS, INPUTEVENT_KEY_APPS },
+ { DIK_RCONTROL, INPUTEVENT_KEY_CTRL_RIGHT },
+ { DIK_RSHIFT, INPUTEVENT_KEY_SHIFT_RIGHT },
+
+ { DIK_UP, INPUTEVENT_KEY_CURSOR_UP },
+ { DIK_DOWN, INPUTEVENT_KEY_CURSOR_DOWN },
+ { DIK_LEFT, INPUTEVENT_KEY_CURSOR_LEFT },
+ { DIK_RIGHT, INPUTEVENT_KEY_CURSOR_RIGHT },
+
+ { DIK_LBRACKET, INPUTEVENT_KEY_LEFTBRACKET },
+ { DIK_RBRACKET, INPUTEVENT_KEY_RIGHTBRACKET },
+ { DIK_SEMICOLON, INPUTEVENT_KEY_SEMICOLON },
+ { DIK_APOSTROPHE, INPUTEVENT_KEY_SINGLEQUOTE },
+ { DIK_GRAVE, INPUTEVENT_KEY_BACKQUOTE },
+ { DIK_BACKSLASH, INPUTEVENT_KEY_2B },
+ { DIK_COMMA, INPUTEVENT_KEY_COMMA },
+ { DIK_PERIOD, INPUTEVENT_KEY_PERIOD },
+ { DIK_SLASH, INPUTEVENT_KEY_DIV },
+ { DIK_OEM_102, INPUTEVENT_KEY_30 },
+
+ { DIK_INSERT, INPUTEVENT_KEY_INSERT },
+ { DIK_DELETE, INPUTEVENT_KEY_DEL },
+ { DIK_HOME, INPUTEVENT_KEY_HOME },
+ { DIK_END, INPUTEVENT_KEY_END },
+ { DIK_PRIOR, INPUTEVENT_KEY_PAGEUP },
+ { DIK_NEXT, INPUTEVENT_KEY_PAGEDOWN },
+ { DIK_SCROLL, INPUTEVENT_KEY_HELP },
+ { DIK_SYSRQ, INPUTEVENT_KEY_SYSRQ },
+
+ { DIK_MEDIASTOP, INPUTEVENT_KEY_CDTV_STOP },
+ { DIK_PLAYPAUSE, INPUTEVENT_KEY_CDTV_PLAYPAUSE },
+ { DIK_PREVTRACK, INPUTEVENT_KEY_CDTV_PREV },
+ { DIK_NEXTTRACK, INPUTEVENT_KEY_CDTV_NEXT },
+
+ { -1, 0 }
+};
+
+static struct uae_input_device_kbr_default *keytrans[] = {
+ keytrans_amiga,
+ keytrans_pc1,
+ keytrans_pc1
+};
+
static int kb_np[] = { DIK_NUMPAD4, -1, DIK_NUMPAD6, -1, DIK_NUMPAD8, -1, DIK_NUMPAD2, -1, DIK_NUMPAD0, DIK_NUMPAD5, -1, DIK_DECIMAL, -1, DIK_NUMPADENTER, -1, -1 };
static int kb_ck[] = { DIK_LEFT, -1, DIK_RIGHT, -1, DIK_UP, -1, DIK_DOWN, -1, DIK_RCONTROL, DIK_RMENU, -1, DIK_RSHIFT, -1, -1 };
static int kb_se[] = { DIK_A, -1, DIK_D, -1, DIK_W, -1, DIK_S, -1, DIK_LMENU, -1, DIK_LSHIFT, -1, -1 };
static int specialkeycode (void)
{
- return currprefs.win32_specialkey;
+ if (currprefs.input_keyboard_type == 0)
+ return currprefs.win32_specialkey;
+ return -1;
}
static int specialpressed (void)
{
{
int code = 0;
int scancode_new;
+ int defaultguikey;
+ bool amode = currprefs.input_keyboard_type == 0;
static int swapperdrive = 0;
if (scancode == specialkeycode ())
return;
- if (scancode == DIK_F11 && currprefs.win32_ctrl_F11_is_quit && ctrlpressed ())
+ if (amode && scancode == DIK_F11 && currprefs.win32_ctrl_F11_is_quit && ctrlpressed ())
code = AKS_QUIT;
scancode_new = scancode;
if (!specialpressed () && inputdevice_iskeymapped (keyboard, scancode))
scancode = 0;
+
+ defaultguikey = amode ? DIK_F12 : DIK_NUMLOCK;
// GUI must be always available
- if (scancode_new == DIK_F12 && currprefs.win32_guikey < 0)
+ if (scancode_new == defaultguikey && currprefs.win32_guikey < 0)
scancode = scancode_new;
- if (scancode_new == currprefs.win32_guikey && scancode_new != DIK_F12)
+ if (scancode_new == currprefs.win32_guikey && scancode_new != defaultguikey)
scancode = scancode_new;
//write_log (L"keyboard = %d scancode = 0x%02x state = %d\n", keyboard, scancode, newstate );
- if (newstate == 0 && code == 0) {
+ if (amode && newstate == 0 && code == 0) {
switch (scancode)
{
case DIK_SYSRQ:
if (newstate && code == 0) {
- if (scancode == DIK_F12 || scancode == currprefs.win32_guikey) {
+ if (scancode == defaultguikey || scancode == currprefs.win32_guikey) {
if (ctrlpressed ()) {
code = AKS_TOGGLEDEFAULTSCREEN;
} else if (shiftpressed () || specialpressed ()) {
}
}
+ }
+
+ if (newstate && code == 0 && amode) {
+
switch (scancode)
{
case DIK_F1:
i = 0;
while (DisplayModes[i].depth >= 0) {
+ if (DisplayModes[i].rawmode) {
+ i++;
+ continue;
+ }
j = i;
size += PSSO_LibResolution_sizeof;
while (missmodes[misscnt * 2] == 0)
#define IDS_AUTOSCALE_INTEGER 375
#define IDS_SCREEN_VSYNC2_AUTOSWITCH 376
#define IDS_SCREEN_VSYNC2 377
+#define IDS_STRING23 378
+#define IDS_SCREEN_VSYNC_NONE 378
#define IDS_QS_MODELS 1000
#define IDS_QS_MODEL_A500 1001
#define IDS_QS_MODEL_A500P 1002
EDITTEXT IDC_RATE2TEXT,143,192,41,12,ES_AUTOHSCROLL\r
COMBOBOX IDC_RESOLUTIONDEPTH,134,27,46,150,CBS_DROPDOWNLIST | CBS_HASSTRINGS | WS_VSCROLL | WS_TABSTOP\r
CONTROL "Filtered low resolution",IDC_LORES_SMOOTHED,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,120,125,89,10\r
- COMBOBOX IDC_SCREENMODE_NATIVE,39,85,67,150,CBS_DROPDOWNLIST | CBS_HASSTRINGS | WS_VSCROLL | WS_TABSTOP\r
- COMBOBOX IDC_SCREENMODE_RTG,39,103,67,150,CBS_DROPDOWNLIST | CBS_HASSTRINGS | WS_VSCROLL | WS_TABSTOP\r
+ COMBOBOX IDC_SCREENMODE_NATIVE,39,85,63,150,CBS_DROPDOWNLIST | CBS_HASSTRINGS | WS_VSCROLL | WS_TABSTOP\r
+ COMBOBOX IDC_SCREENMODE_RTG,39,103,63,150,CBS_DROPDOWNLIST | CBS_HASSTRINGS | WS_VSCROLL | WS_TABSTOP\r
RTEXT "Native:",IDC_STATIC,9,85,23,15,SS_CENTERIMAGE\r
RTEXT "RTG:",IDC_STATIC,8,101,24,15,SS_CENTERIMAGE\r
PUSHBUTTON "Reset to defaults",IDC_DA_RESET,221,218,75,14\r
COMBOBOX IDC_DISPLAY_BUFFERCNT,187,47,102,150,CBS_DROPDOWNLIST | CBS_HASSTRINGS | WS_VSCROLL | WS_TABSTOP\r
CONTROL "Resolution autoswitch",IDC_AUTORESOLUTION,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,120,139,89,10\r
EDITTEXT IDC_DA_TEXT,167,218,46,12,ES_AUTOHSCROLL | ES_READONLY\r
- COMBOBOX IDC_SCREENMODE_NATIVE2,112,85,95,150,CBS_DROPDOWNLIST | CBS_HASSTRINGS | WS_VSCROLL | WS_TABSTOP\r
- COMBOBOX IDC_SCREENMODE_RTG2,112,103,95,150,CBS_DROPDOWNLIST | CBS_HASSTRINGS | WS_VSCROLL | WS_TABSTOP\r
+ COMBOBOX IDC_SCREENMODE_NATIVE2,108,85,99,150,CBS_DROPDOWNLIST | CBS_HASSTRINGS | WS_VSCROLL | WS_TABSTOP\r
+ COMBOBOX IDC_SCREENMODE_RTG2,108,103,99,150,CBS_DROPDOWNLIST | CBS_HASSTRINGS | WS_VSCROLL | WS_TABSTOP\r
COMBOBOX IDC_RATE2BOX,143,173,60,150,CBS_DROPDOWNLIST | CBS_HASSTRINGS | WS_VSCROLL | WS_TABSTOP\r
CONTROL "",IDC_RATE2ENABLE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,194,193,8,10\r
END\r
IDS_SCREEN_WINDOWED "Windowed"\r
IDS_SCREEN_FULLSCREEN "Fullscreen"\r
IDS_SCREEN_FULLWINDOW "Full-window"\r
- IDS_SCREEN_VSYNC "VSync"\r
- IDS_SCREEN_VSYNC_AUTOSWITCH "AutoVSync"\r
+ IDS_SCREEN_VSYNC "Legacy"\r
+ IDS_SCREEN_VSYNC_AUTOSWITCH "Legacy, 50/60Hz switch"\r
IDS_SOUND_MONO "Mono"\r
IDS_SOUND_MIXED "Mixed"\r
IDS_SOUND_STEREO "Stereo"\r
IDS_PORT_AUTOFIRE_ALWAYS "Autofire (always)"\r
IDS_PORT_AUTOFIRE_NO "No autofire"\r
IDS_AUTOSCALE_INTEGER "Integer scaling"\r
- IDS_SCREEN_VSYNC2_AUTOSWITCH "Low latency AutoVSync"\r
- IDS_SCREEN_VSYNC2 "Low latency VSync"\r
+ IDS_SCREEN_VSYNC2_AUTOSWITCH "Low latency, 50/60Hz"\r
+ IDS_SCREEN_VSYNC2 "Low latency"\r
+ IDS_SCREEN_VSYNC_NONE "(VSync)"\r
END\r
\r
#endif // English resources\r
#define EXP 2.1
#define ADJUST_VSSIZE 10
-#define EXPVS 1.7
+#define EXPVS 1.6
int sound_debug = 0;
int sound_mode_skip = 0;
static int avioutput_audio;
#endif
+#define ADJUST_LIMIT 7
+#define ADJUST_LIMIT2 1.5
+
void sound_setadjust (double v)
{
float mult;
- if (v < -5)
- v = -5;
- if (v > 5)
- v = 5;
+ if (v < -ADJUST_LIMIT)
+ v = -ADJUST_LIMIT;
+ if (v > ADJUST_LIMIT)
+ v = ADJUST_LIMIT;
mult = (1000.0 + v);
if (avioutput_audio && avioutput_enabled && avioutput_nosoundsync)
}
}
+
static void docorrection (struct sound_dp *s, int sndbuf, double sync, int granulaty)
{
static int tfprev;
granulaty = 10;
if (tfprev != timeframes) {
- double skipmode;
+ double skipmode, avgskipmode;
double avg = s->avg_correct / s->cnt_correct;
- if ((1 || sound_debug) && (tfprev % 10) == 0) {
- write_log (L"%+4d %7.1f %7.1f %6d\n", sndbuf, avg, sync, granulaty);
+
+ skipmode = sync / 10.0;
+ avgskipmode = avg / (10000.0 / granulaty);
+
+ if ((0 || sound_debug) && (tfprev % 10) == 0) {
+ write_log (L"%+05d S=%7.1f AVG=%7.1f (IMM=%7.1f + AVG=%7.1f = %7.1f)\n", sndbuf, sync, avg, skipmode, avgskipmode, skipmode + avgskipmode);
}
gui_data.sndbuf = sndbuf;
- skipmode = sync / 100.0;
- if (skipmode > 1)
- skipmode = 1;
- if (skipmode < -1)
- skipmode = -1;
+ if (skipmode > ADJUST_LIMIT2)
+ skipmode = ADJUST_LIMIT2;
+ if (skipmode < -ADJUST_LIMIT2)
+ skipmode = -ADJUST_LIMIT2;
- sound_setadjust (avg / (5000 / granulaty));
+ sound_setadjust (skipmode + avgskipmode);
tfprev = timeframes;
}
}
double skipmode;
if (isvsync () || 1) {
- skipmode = pow (m < 0 ? -m : m, EXPVS) / 10;
+ skipmode = pow (m < 0 ? -m : m, EXPVS) / 8;
if (m < 0)
skipmode = -skipmode;
if (skipmode < -ADJUST_VSSIZE)
sd->sndbufsize / sd->samplesize, s->snd_configsize / sd->samplesize, s->max_sndbufsize / sd->samplesize,
s->dsoundbuf / sd->samplesize, diff / sd->samplesize, vdiff, skipmode, s->avg_correct / s->cnt_correct, adj);
tfprev = timeframes;
- if (skipmode > 1)
- skipmode = 1;
- if (skipmode < -1)
- skipmode = -1;
+ if (skipmode > ADJUST_LIMIT2)
+ skipmode = ADJUST_LIMIT2;
+ if (skipmode < -ADJUST_LIMIT2)
+ skipmode = -ADJUST_LIMIT2;
sound_setadjust (skipmode + adj);
}
}
extern int screenshotmode, postscript_print_debugging, sound_debug, log_uaeserial, clipboard_debug;
extern int force_direct_catweasel, sound_mode_skip, maxmem;
extern int pngprint, log_sercon, midi_inbuflen;
+extern int vsync_busy_wait_mode;
extern DWORD_PTR cpu_affinity, cpu_paffinity;
static DWORD_PTR original_affinity = -1;
if (!np)
return 0;
+ if (!_tcscmp (arg, L"vsyncbusywait")) {
+ vsync_busy_wait_mode = getval (np);
+ return 2;
+ }
if (!_tcscmp (arg, L"midiinbuffer")) {
midi_inbuflen = getval (np);
if (midi_inbuflen < 16000)
midi_inbuflen = 16000;
return 2;
}
-
if (!_tcscmp (arg, L"ddforcemode")) {
extern int ddforceram;
ddforceram = getval (np);
#define LANG_DLL 1
//#define WINUAEBETA L""
-#define WINUAEBETA L"Beta 8"
-#define WINUAEDATE MAKEBD(2011, 12, 26)
+#define WINUAEBETA L"Beta 9"
+#define WINUAEDATE MAKEBD(2011, 12, 30)
#define WINUAEEXTRA L""
#define WINUAEREV L""
LeaveCriticalSection (&screen_cs);
}
+int vsync_busy_wait_mode;
+
+static void vsync_sleep (bool preferbusy)
+{
+ int bb = picasso_on ? currprefs.gfx_rtg_backbuffers : currprefs.gfx_backbuffers;
+ bool dowait;
+
+ if (vsync_busy_wait_mode == 0) {
+ dowait = bb || !preferbusy;
+ } else if (vsync_busy_wait_mode < 0) {
+ dowait = true;
+ } else {
+ dowait = false;
+ }
+ if (dowait)
+ sleep_millis_main (1);
+}
+
static void changevblankthreadmode (int newmode)
{
int t = vblankthread_counter;
vblankthread_mode = newmode;
if (newmode == VBLANKTH_KILL) {
flipthread_mode = 0;
- SetEvent(flipevent);
+ SetEvent (flipevent);
while (flipthread_mode == 0)
- sleep_millis (1);
- CloseHandle(flipevent);
+ sleep_millis_main (1);
+ CloseHandle (flipevent);
}
while (t == vblankthread_counter && vblankthread_mode > 0)
- sleep_millis (1);
+ vsync_sleep (false);
}
int WIN32GFX_IsPicassoScreen (void)
md1->DisplayModes[0].depth = -1;
write_log (L"%s [%s]\n", md1->adaptername, md1->monitorname);
+ write_log (L"-: %d*%d [%d*%d]\n", md1->rect.right - md1->rect.left, md1->rect.bottom - md1->rect.top, md1->rect.left, md1->rect.top);
for (int mode = 0; mode < 2; mode++) {
DEVMODE dm;
dm.dmSize = sizeof dm;
}
}
-bool vblank_busywait (void)
+bool vblank_wait (void)
{
int vp;
int opos = prevvblankpos;
if (!getvblankpos (&vp))
return false;
- if (opos > maxscanline / 2 && vp < maxscanline / 5)
+ if (opos > maxscanline / 2 && vp < maxscanline / 4)
return true;
if (vp <= 0)
return true;
+ vsync_sleep (true);
}
}
opos = prevvblankpos;
if (!getvblankpos (&vp))
return false;
- if (opos > maxscanline / 2 && vp < maxscanline / 5) {
+ if (opos > maxscanline / 2 && vp < maxscanline / 4) {
*state = true;
return true;
}
frame_time_t vsync_busywait_end (void)
{
- while (!vblank_found && vblankthread_mode == VBLANKTH_ACTIVE)
- sleep_millis (1);
+
+ while (!vblank_found && vblankthread_mode == VBLANKTH_ACTIVE) {
+ vsync_sleep (true);
+ }
changevblankthreadmode (VBLANKTH_ACTIVE_WAIT);
for (;;) {
int vp;
//write_log (L"%d ", vpos);
break;
}
+ vsync_sleep (true);
}
return thread_vblank_time;
}
}
while (!framelost && read_processor_time () - prevtime < vblankbasewait) {
- sleep_millis_main (1);
+ vsync_sleep (false);
}
framelost = false;
- v = vblank_busywait ();
+ v = vblank_wait ();
+
}
if (v) {
#define CONFIG_HOST L"Host"
#define CONFIG_HARDWARE L"Hardware"
+#define SOUND_BUFFER_MULTIPLIER 1024
+
static wstring szNone;
static int allow_quit;
WIN32GUI_LoadUIString(IDS_SCREEN_FULLWINDOW, buffer, sizeof buffer / sizeof (TCHAR));
SendDlgItemMessage(hDlg, IDC_SCREENMODE_NATIVE, CB_ADDSTRING, 0, (LPARAM)buffer);
- SendDlgItemMessage(hDlg, IDC_SCREENMODE_NATIVE2, CB_ADDSTRING, 0, (LPARAM)L"-");
-#if 0
- WIN32GUI_LoadUIString(IDS_SCREEN_VSYNC, buffer, sizeof buffer / sizeof (TCHAR));
- SendDlgItemMessage(hDlg, IDC_SCREENMODE_NATIVE2, CB_ADDSTRING, 0, (LPARAM)buffer);
- WIN32GUI_LoadUIString(IDS_SCREEN_VSYNC_AUTOSWITCH, buffer, sizeof buffer / sizeof (TCHAR));
+
+ WIN32GUI_LoadUIString(IDS_SCREEN_VSYNC_NONE, buffer, sizeof buffer / sizeof (TCHAR));
SendDlgItemMessage(hDlg, IDC_SCREENMODE_NATIVE2, CB_ADDSTRING, 0, (LPARAM)buffer);
-#endif
WIN32GUI_LoadUIString(IDS_SCREEN_VSYNC2, buffer, sizeof buffer / sizeof (TCHAR));
SendDlgItemMessage(hDlg, IDC_SCREENMODE_NATIVE2, CB_ADDSTRING, 0, (LPARAM)buffer);
WIN32GUI_LoadUIString(IDS_SCREEN_VSYNC2_AUTOSWITCH, buffer, sizeof buffer / sizeof (TCHAR));
SendDlgItemMessage(hDlg, IDC_SCREENMODE_NATIVE2, CB_ADDSTRING, 0, (LPARAM)buffer);
-
+#if 1
+ WIN32GUI_LoadUIString(IDS_SCREEN_VSYNC, buffer, sizeof buffer / sizeof (TCHAR));
+ SendDlgItemMessage(hDlg, IDC_SCREENMODE_NATIVE2, CB_ADDSTRING, 0, (LPARAM)buffer);
+ WIN32GUI_LoadUIString(IDS_SCREEN_VSYNC_AUTOSWITCH, buffer, sizeof buffer / sizeof (TCHAR));
+ SendDlgItemMessage(hDlg, IDC_SCREENMODE_NATIVE2, CB_ADDSTRING, 0, (LPARAM)buffer);
+#endif
SendDlgItemMessage(hDlg, IDC_SCREENMODE_NATIVE, CB_SETCURSEL,
workprefs.gfx_afullscreen, 0);
SendDlgItemMessage(hDlg, IDC_SCREENMODE_NATIVE2, CB_SETCURSEL,
- workprefs.gfx_avsync, 0);
+ workprefs.gfx_avsync + (workprefs.gfx_avsyncmode || !workprefs.gfx_avsync ? 0 : 2), 0);
SendDlgItemMessage(hDlg, IDC_SCREENMODE_RTG, CB_RESETCONTENT, 0, 0);
SendDlgItemMessage(hDlg, IDC_SCREENMODE_RTG2, CB_RESETCONTENT, 0, 0);
if (i > 0) {
i--;
workprefs.gfx_avsync = (i & 1) + 1;
- workprefs.gfx_avsyncmode = 1;
+ workprefs.gfx_avsyncmode = (i < 2) ? 1 : 0;
}
workprefs.gfx_pfullscreen = SendDlgItemMessage (hDlg, IDC_SCREENMODE_RTG, CB_GETCURSEL, 0, 0);
int bufsize;
TCHAR txt[20];
- bufsize = exact_log2 (workprefs.sound_maxbsiz / 1024);
+ bufsize = exact_log2 (workprefs.sound_maxbsiz / SOUND_BUFFER_MULTIPLIER) + 1;
_stprintf (txt, L"%d", bufsize);
SetDlgItemText (hDlg, IDC_SOUNDBUFFERMEM, txt);
CheckDlgButton (hDlg, IDC_SOUND_AUTO, workprefs.sound_auto);
workprefs.sound_maxbsiz = 1 << exact_log2 (workprefs.sound_maxbsiz);
- if (workprefs.sound_maxbsiz < 2048)
- workprefs.sound_maxbsiz = 2048;
- SendDlgItemMessage (hDlg, IDC_SOUNDBUFFERRAM, TBM_SETPOS, TRUE, exact_log2 (workprefs.sound_maxbsiz / 2048));
+ if (workprefs.sound_maxbsiz < SOUND_BUFFER_MULTIPLIER)
+ workprefs.sound_maxbsiz = SOUND_BUFFER_MULTIPLIER;
+ SendDlgItemMessage (hDlg, IDC_SOUNDBUFFERRAM, TBM_SETPOS, TRUE, exact_log2 (workprefs.sound_maxbsiz / SOUND_BUFFER_MULTIPLIER));
SendDlgItemMessage (hDlg, IDC_SOUNDVOLUME, TBM_SETPOS, TRUE, 0);
SendDlgItemMessage (hDlg, IDC_SOUNDDRIVEVOLUME, TBM_SETPOS, TRUE, 0);
break;
case WM_HSCROLL:
- workprefs.sound_maxbsiz = 2048 << SendMessage (GetDlgItem (hDlg, IDC_SOUNDBUFFERRAM), TBM_GETPOS, 0, 0);
+ workprefs.sound_maxbsiz = SOUND_BUFFER_MULTIPLIER << SendMessage (GetDlgItem (hDlg, IDC_SOUNDBUFFERRAM), TBM_GETPOS, 0, 0);
workprefs.sound_volume = 100 - SendMessage (GetDlgItem (hDlg, IDC_SOUNDVOLUME), TBM_GETPOS, 0, 0);
workprefs.dfxclickvolume = 100 - SendMessage (GetDlgItem (hDlg, IDC_SOUNDDRIVEVOLUME), TBM_GETPOS, 0, 0);
update_soundgui (hDlg);
<TreatWChar_tAsBuiltInType>false</TreatWChar_tAsBuiltInType>
<ForcedIncludeFiles>%(ForcedIncludeFiles)</ForcedIncludeFiles>
<MultiProcessorCompilation>true</MultiProcessorCompilation>
+ <InlineFunctionExpansion>Disabled</InlineFunctionExpansion>
</ClCompile>
<ResourceCompile>
<PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+- USB HID game controller support really works now. (HID signed value handling is a bit special)
+ Also added pad quirks list from Linux, some game pads apparently report bad minimum and maximum range
+ values, this also includes Logitech G13 stick which was not listed (reported range is -127 to 127,
+ real range is 0 to 255) and this caused the b8 problem because I assumed it was supposed to work that way
+ which of course broke other correctly working devices with negative minimum range.
+- D3D and DirectDraw fullscreen mode monitor selection improved, it wasn't reliable if system had
+ more than 1 display adapter(s). (Win32 EnumDisplayDevices(), DirectDraw and Direct3D monitor indexes
+ are not guaranteed to be same)
+- Adjusted sound buffer range, old 1 is new 2, 2 is 3, and so on. Old 7 is too big, most drivers won't
+ accept it and new vsync can work with buffer smaller than old 1. (Buffer size "0" or "1/2" would have
+ been too confusing..) In other words, if you load old configuration, only value shown in GUI increases by one,
+ real buffer size does not change.
+- Fixed Graffiti emulation crash in if Graffiti hires mode was detected but emulation was
+ not configured for superhires support. (Only in some situations)
+- Disable genlock detected option if A2024 or Graffiti enabled, this is impossible configuration and would only slow down
+ emulation (forces Graffiti emulation to keep looking for command codes continuously)
+- PC keyboard emulation mode, maps keys like F12, End, Home etc.. to Amiga key codes (afaik same key codes are also used by AROS, OS4 and MorphOS).
+ Num Lock opens the GUI by default (Only remaining key that is more or less free), all other special UAE key mappings are disabled.
+ Config file only at the moment: input.keyboard_type=pc
+- Do not include "raw" display modes (marked as "!") in RTG resolution list.
+- Old vsync mode is back (native only, non-fastest CPU mode compatible only)
+
Beta 8:
- Fixed D3D RTG hardware cursor stupid divide by zero crash introduced in b6
if (!(bplcon0 & 0x0100)) // GAUD
return false;
- if (monitor != MONITOREMU_GRAFFITI)
- clearmonitor(dst);
-
command = true;
found = false;
isntsc = (beamcon0 & 0x20) ? 0 : 1;
dstbuf = dst->bufmem + (((ystart << VRES_MAX) - src->yoffset) / gfxvidinfo.ychange) * dst->rowbytes + (((xstart << RES_MAX) - src->xoffset) / gfxvidinfo.xchange) * dst->pixbytes;
y = 0;
- while (srcend > srcbuf) {
+ while (srcend > srcbuf && dst->bufmemend > dstbuf) {
uae_u8 *srcp = srcbuf + extrapix;
uae_u8 *dstp = dstbuf;
} else {
hires = false;
}
+ if (xpixadd == 0) // shres needed
+ return false;
+ if (monitor != MONITOREMU_GRAFFITI)
+ clearmonitor(dst);
} else if (cmd & 4) {
if ((cmd & 3) == 1) {
read_mask = parm;
projects / francis / winuae.git / commitdiff