summaryrefslogtreecommitdiffstatshomepage
diff options
context:
space:
mode:
author Aaron Giles <aaron@aarongiles.com>2008-02-26 06:31:28 +0000
committer Aaron Giles <aaron@aarongiles.com>2008-02-26 06:31:28 +0000
commitadcdfd3e5be783192f621b2426236b736e9cff24 (patch)
tree02aab6efaca844757c18db9d8fa20897c582f9ab
parentd94da473664a3f211b47ec7cba1ae677df50766a (diff)
Converted MACHINE_DRIVER definitions from function
constructors to tokenized lists. For the most part this is a non-invasive change, except for those drivers using MDRV_WATCHDOG_TIME_INIT. In order to allow for tokenization of attotimes, a set of new macros is provided called UINT64_ATTOTIME_IN_x() which follows the same pattern as ATTOTIME_IN_x() but packs the attotime down into a single 64-bit value for easier tokenization. Separated MDRV_DEVICE_CONFIG_DATA into 32-bit and 64-bit versions. Added floating-point versions with configurable resolutions. Fixed several errors in the machine drivers which were caught by the additional checks now done in the machine config detokenization code. Converted speakers into devices. Machine->config no longer houses an array of speakers; instead they are iterated through using the new macros (defined in sound.h) speaker_output_first() and speaker_output_next(). Updated all relevant code to do this. Improved game info display with multiple screens. Fixed bug which caused all screens to display equally. Added typedefs for all the machine config callback functions at the top of driver.h.
-rw-r--r--src/emu/attotime.h42
-rw-r--r--src/emu/audit.c2
-rw-r--r--src/emu/clifront.c2
-rw-r--r--src/emu/cpuexec.c2
-rw-r--r--src/emu/driver.h20
-rw-r--r--src/emu/info.c10
-rw-r--r--src/emu/inptport.c2
-rw-r--r--src/emu/mame.c7
-rw-r--r--src/emu/mconfig.c410
-rw-r--r--src/emu/mconfig.h501
-rw-r--r--src/emu/sound.c203
-rw-r--r--src/emu/sound.h20
-rw-r--r--src/emu/timer.h6
-rw-r--r--src/emu/tokenize.h80
-rw-r--r--src/emu/ui.c31
-rw-r--r--src/emu/validity.c71
-rw-r--r--src/mame/audio/redalert.c2
-rw-r--r--src/mame/drivers/airbustr.c2
-rw-r--r--src/mame/drivers/ampoker2.c2
-rw-r--r--src/mame/drivers/atarifb.c1
-rw-r--r--src/mame/drivers/cave.c4
-rw-r--r--src/mame/drivers/dlair.c2
-rw-r--r--src/mame/drivers/dunhuang.c2
-rw-r--r--src/mame/drivers/expro02.c2
-rw-r--r--src/mame/drivers/frogger.c1
-rw-r--r--src/mame/drivers/galpanic.c2
-rw-r--r--src/mame/drivers/gameplan.c4
-rw-r--r--src/mame/drivers/hyperspt.c3
-rw-r--r--src/mame/drivers/lockon.c2
-rw-r--r--src/mame/drivers/madalien.c2
-rw-r--r--src/mame/drivers/mcatadv.c2
-rw-r--r--src/mame/drivers/mw8080bw.c32
-rw-r--r--src/mame/drivers/neogeo.c2
-rw-r--r--src/mame/drivers/ohmygod.c2
-rw-r--r--src/mame/drivers/sandscrp.c2
-rw-r--r--src/mame/drivers/starwars.c2
-rw-r--r--src/mame/drivers/tempest.c2
-rw-r--r--src/mame/drivers/tmnt.c2
-rw-r--r--src/mame/machine/pcshare.c4
39 files changed, 966 insertions, 524 deletions
diff --git a/src/emu/attotime.h b/src/emu/attotime.h
index e99fb4e638f..6d94e7cc13d 100644
--- a/src/emu/attotime.h
+++ b/src/emu/attotime.h
@@ -67,27 +67,35 @@
#define HZ_TO_ATTOSECONDS(x) ((attoseconds_t)(ATTOSECONDS_PER_SECOND / (x)))
/* macros for converting other seconds types to attoseconds */
-#define ATTOSECONDS_IN_SEC(x) ((x) * ATTOSECONDS_PER_SECOND)
-#define ATTOSECONDS_IN_MSEC(x) ((x) * ATTOSECONDS_PER_MILLISECOND)
-#define ATTOSECONDS_IN_USEC(x) ((x) * ATTOSECONDS_PER_MICROSECOND)
-#define ATTOSECONDS_IN_NSEC(x) ((x) * ATTOSECONDS_PER_NANOSECOND)
+#define ATTOSECONDS_IN_SEC(x) ((attoseconds_t)(x) * ATTOSECONDS_PER_SECOND)
+#define ATTOSECONDS_IN_MSEC(x) ((attoseconds_t)(x) * ATTOSECONDS_PER_MILLISECOND)
+#define ATTOSECONDS_IN_USEC(x) ((attoseconds_t)(x) * ATTOSECONDS_PER_MICROSECOND)
+#define ATTOSECONDS_IN_NSEC(x) ((attoseconds_t)(x) * ATTOSECONDS_PER_NANOSECOND)
/* macros for building attotimes from other types at runtime */
-#define ATTOTIME_IN_HZ(hz) attotime_make(0, HZ_TO_ATTOSECONDS(hz))
-#define ATTOTIME_IN_SEC(s) attotime_make((s) / 1, (s) % 1 /* mod here errors on doubles, which is intended */)
-#define ATTOTIME_IN_MSEC(ms) attotime_make((ms) / 1000, ATTOSECONDS_IN_MSEC((ms) % 1000))
-#define ATTOTIME_IN_USEC(us) attotime_make((us) / 1000000, ATTOSECONDS_IN_USEC((us) % 1000000))
-#define ATTOTIME_IN_NSEC(ns) attotime_make((ns) / 1000000000, ATTOSECONDS_IN_NSEC((ns) % 1000000000))
+#define ATTOTIME_IN_HZ(hz) attotime_make((0), (HZ_TO_ATTOSECONDS(hz)))
+#define ATTOTIME_IN_SEC(s) attotime_make(((s) / 1), ((s) % 1))
+#define ATTOTIME_IN_MSEC(ms) attotime_make(((ms) / 1000), (ATTOSECONDS_IN_MSEC((ms) % 1000)))
+#define ATTOTIME_IN_USEC(us) attotime_make(((us) / 1000000), (ATTOSECONDS_IN_USEC((us) % 1000000)))
+#define ATTOTIME_IN_NSEC(ns) attotime_make(((ns) / 1000000000), (ATTOSECONDS_IN_NSEC((ns) % 1000000000)))
/* macros for building attotimes from other types at compile time */
-#define STATIC_ATTOTIME_IN_HZ(hz) { 0, HZ_TO_ATTOSECONDS(hz) }
-#define STATIC_ATTOTIME_IN_SEC(s) { (s) / 1, (s) % 1 /* mod here errors on doubles, which is intended */ }
-#define STATIC_ATTOTIME_IN_MSEC(ms) { (ms) / 1000, ATTOSECONDS_IN_MSEC((ms) % 1000) }
-#define STATIC_ATTOTIME_IN_USEC(us) { (us) / 1000000, ATTOSECONDS_IN_USEC((us) % 1000000) }
-#define STATIC_ATTOTIME_IN_NSEC(ns) { (ns) / 1000000000, ATTOSECONDS_IN_NSEC((ns) % 1000000000) }
-
-
-#define USEC_TO_ATTOSECONDS(us) ((attoseconds_t)((us) * ATTOSECONDS_PER_MICROSECOND))
+#define STATIC_ATTOTIME_IN_HZ(hz) { (0), (HZ_TO_ATTOSECONDS(hz)) }
+#define STATIC_ATTOTIME_IN_SEC(s) { ((s) / 1), ((s) % 1) }
+#define STATIC_ATTOTIME_IN_MSEC(ms) { ((ms) / 1000), (ATTOSECONDS_IN_MSEC((ms) % 1000)) }
+#define STATIC_ATTOTIME_IN_USEC(us) { ((us) / 1000000), (ATTOSECONDS_IN_USEC((us) % 1000000)) }
+#define STATIC_ATTOTIME_IN_NSEC(ns) { ((ns) / 1000000000), (ATTOSECONDS_IN_NSEC((ns) % 1000000000)) }
+
+/* macros for building a reduced-resolution attotime for tokenized storage in a UINT64 */
+/* this form supports up to 1000 seconds and sacrifices 1/1000 of the full attotime resolution */
+#define UINT64_ATTOTIME_IN_HZ(hz) ((UINT64)((ATTOSECONDS_PER_SECOND / 1000) / (hz)))
+#define UINT64_ATTOTIME_IN_SEC(s) ((UINT64)(s) * (ATTOSECONDS_PER_SECOND / 1000))
+#define UINT64_ATTOTIME_IN_MSEC(ms) ((UINT64)(ms) * (ATTOSECONDS_PER_SECOND / 1000 / 1000))
+#define UINT64_ATTOTIME_IN_USEC(us) ((UINT64)(us) * (ATTOSECONDS_PER_SECOND / 1000 / 1000 / 1000))
+#define UINT64_ATTOTIME_IN_NSEC(ns) ((UINT64)(ns) * (ATTOSECONDS_PER_SECOND / 1000 / 1000 / 1000 / 1000))
+
+/* macros for converting a UINT64 attotime to a full attotime */
+#define UINT64_ATTOTIME_TO_ATTOTIME(v) attotime_make((v) / (ATTOSECONDS_PER_SECOND / 1000), ((v) % (ATTOSECONDS_PER_SECOND / 1000)) * 1000)
diff --git a/src/emu/audit.c b/src/emu/audit.c
index 7b24dd775e6..0332b133b4d 100644
--- a/src/emu/audit.c
+++ b/src/emu/audit.c
@@ -120,7 +120,7 @@ int audit_images(core_options *options, const game_driver *gamedrv, UINT32 valid
int audit_samples(core_options *options, const game_driver *gamedrv, audit_record **audit)
{
- machine_config *config = machine_config_alloc(gamedrv->drv);
+ machine_config *config = machine_config_alloc(gamedrv->machine_config);
audit_record *record;
int sndnum, sampnum;
int records = 0;
diff --git a/src/emu/clifront.c b/src/emu/clifront.c
index fa7f214579d..4d91d5b4bdd 100644
--- a/src/emu/clifront.c
+++ b/src/emu/clifront.c
@@ -558,7 +558,7 @@ int cli_info_listsamples(core_options *options, const char *gamename)
for (drvindex = 0; drivers[drvindex]; drvindex++)
if (mame_strwildcmp(gamename, drivers[drvindex]->name) == 0)
{
- machine_config *config = machine_config_alloc(drivers[drvindex]->drv);
+ machine_config *config = machine_config_alloc(drivers[drvindex]->machine_config);
int sndnum;
/* find samples interfaces */
diff --git a/src/emu/cpuexec.c b/src/emu/cpuexec.c
index eaa28ec752a..8d5fe10c6e2 100644
--- a/src/emu/cpuexec.c
+++ b/src/emu/cpuexec.c
@@ -811,7 +811,7 @@ void cpu_triggerint(running_machine *machine, int cpunum)
static TIMER_CALLBACK( watchdog_callback )
{
- logerror("reset caused by the (time) watchdog\n");
+ logerror("reset caused by the watchdog\n");
mame_schedule_soft_reset(machine);
}
diff --git a/src/emu/driver.h b/src/emu/driver.h
index 071b49d1977..367db20dbce 100644
--- a/src/emu/driver.h
+++ b/src/emu/driver.h
@@ -19,6 +19,8 @@
MACROS (must be *before* the includes below)
***************************************************************************/
+#include "mamecore.h"
+
#define DRIVER_INIT(name) void driver_init_##name(running_machine *machine)
#define DRIVER_INIT_CALL(name) driver_init_##name(machine)
@@ -70,6 +72,20 @@
#define video_update_NULL NULL
+typedef void (*driver_init_func)(running_machine *machine);
+typedef void (*nvram_handler_func)(running_machine *machine, mame_file *file, int read_or_write);
+typedef void (*memcard_handler_func)(running_machine *machine, mame_file *file, int action);
+typedef void (*machine_start_func)(running_machine *machine);
+typedef void (*machine_reset_func)(running_machine *machine);
+typedef void (*sound_start_func)(running_machine *machine);
+typedef void (*sound_reset_func)(running_machine *machine);
+typedef void (*video_start_func)(running_machine *machine);
+typedef void (*video_reset_func)(running_machine *machine);
+typedef void (*palette_init_func)(running_machine *machine, const UINT8 *color_prom);
+typedef void (*video_eof_func)(running_machine *machine);
+typedef UINT32 (*video_update_func)(running_machine *machine, int screen, mame_bitmap *bitmap, const rectangle *cliprect);
+
+
/***************************************************************************
INCLUDES
@@ -147,7 +163,7 @@ struct _game_driver
const char * description; /* full name of the game */
const char * year; /* year the game was released */
const char * manufacturer; /* manufacturer of the game */
- void (*drv)(machine_config *); /* machine driver constructor */
+ const machine_config_token *machine_config; /* machine driver tokens */
const input_port_token *ipt; /* pointer to array of input port tokens */
void (*driver_init)(running_machine *machine); /* DRIVER_INIT callback */
const rom_entry * rom; /* pointer to list of ROMs for the game */
@@ -179,7 +195,7 @@ const game_driver driver_##NAME = \
FULLNAME, \
#YEAR, \
COMPANY, \
- construct_##MACHINE, \
+ machine_config_##MACHINE, \
ipt_##INPUT, \
driver_init_##INIT, \
rom_##NAME, \
diff --git a/src/emu/info.c b/src/emu/info.c
index 737f96d6194..2c9be82fe82 100644
--- a/src/emu/info.c
+++ b/src/emu/info.c
@@ -767,8 +767,8 @@ static void print_game_display(FILE *out, const game_driver *game, const machine
static void print_game_sound(FILE *out, const game_driver *game, const machine_config *config)
{
+ int speakers = speaker_output_count(config);
int has_sound = FALSE;
- int speakers = 0;
int sndnum;
/* see if we have any sound chips to report */
@@ -780,10 +780,8 @@ static void print_game_sound(FILE *out, const game_driver *game, const machine_c
}
/* if we have sound, count the number of speakers */
- if (has_sound)
- for (speakers = 0; speakers < ARRAY_LENGTH(config->speaker); speakers++)
- if (config->speaker[speakers].tag == NULL)
- break;
+ if (!has_sound)
+ speakers = 0;
fprintf(out, "\t\t<sound channels=\"%d\"/>\n", speakers);
}
@@ -871,7 +869,7 @@ static void print_game_info(FILE *out, const game_driver *game)
/* start tracking resources and allocate the machine and input configs */
begin_resource_tracking();
- config = machine_config_alloc(game->drv);
+ config = machine_config_alloc(game->machine_config);
input = input_port_allocate(game->ipt, NULL);
/* print the header and the game name */
diff --git a/src/emu/inptport.c b/src/emu/inptport.c
index 088ab53433b..2dd5520c5cb 100644
--- a/src/emu/inptport.c
+++ b/src/emu/inptport.c
@@ -1936,7 +1936,7 @@ static void input_port_detokenize(input_port_init_params *param, const input_por
{
UINT32 mask, defval, type, val;
- /* unpack the token from the first entry without advancing */
+ /* unpack the token from the first entry */
TOKEN_GET_UINT32_UNPACK1(ipt, entrytype, 8);
switch (entrytype)
{
diff --git a/src/emu/mame.c b/src/emu/mame.c
index 10f8e3916ef..5c3a5ee3de3 100644
--- a/src/emu/mame.c
+++ b/src/emu/mame.c
@@ -1334,7 +1334,7 @@ void mame_parse_ini_files(core_options *options, const game_driver *driver)
astring *sourcename;
/* parse "vector.ini" for vector games */
- config = machine_config_alloc(driver->drv);
+ config = machine_config_alloc(driver->machine_config);
for (device = video_screen_first(config); device != NULL; device = video_screen_next(device))
{
const screen_config *scrconfig = device->inline_config;
@@ -1419,7 +1419,7 @@ static running_machine *create_machine(const game_driver *driver)
/* initialize the driver-related variables in the machine */
machine->gamedrv = driver;
machine->basename = mame_strdup(driver->name);
- machine->config = machine_config_alloc(driver->drv);
+ machine->config = machine_config_alloc(driver->machine_config);
/* allocate the driver data */
if (machine->config->driver_data_size != 0)
@@ -1588,11 +1588,12 @@ static void init_machine(running_machine *machine)
/* start the video and audio hardware */
video_init(machine);
- sound_init(machine);
/* start up the devices */
device_list_start(machine);
+ sound_init(machine);
+
/* call the driver's _START callbacks */
if (machine->config->machine_start != NULL) (*machine->config->machine_start)(machine);
if (machine->config->sound_start != NULL) (*machine->config->sound_start)(machine);
diff --git a/src/emu/mconfig.c b/src/emu/mconfig.c
index 5c9be8162be..b7f1301da79 100644
--- a/src/emu/mconfig.c
+++ b/src/emu/mconfig.c
@@ -10,11 +10,20 @@
***************************************************************************/
#include "driver.h"
+#include "devintrf.h"
#include <ctype.h>
/***************************************************************************
- MACHINE_CONFIGURATIONS
+ FUNCTION PROTOTYPES
+***************************************************************************/
+
+static void machine_config_detokenize(machine_config *config, const machine_config_token *tokens);
+
+
+
+/***************************************************************************
+ MACHINE CONFIGURATIONS
***************************************************************************/
/*-------------------------------------------------
@@ -23,18 +32,18 @@
the supplied constructor
-------------------------------------------------*/
-machine_config *machine_config_alloc(void (*constructor)(machine_config *))
+machine_config *machine_config_alloc(const machine_config_token *tokens)
{
machine_config *config;
-
+
/* allocate a new configuration object */
config = malloc_or_die(sizeof(*config));
if (config == NULL)
return NULL;
memset(config, 0, sizeof(*config));
-
- /* call the function to construct the data */
- (*constructor)(config);
+
+ /* parse tokens into the config */
+ machine_config_detokenize(config, tokens);
return config;
}
@@ -120,69 +129,6 @@ void machine_config_remove_cpu(machine_config *machine, const char *tag)
/*-------------------------------------------------
- machine_config_add_speaker - add a speaker during
- machine driver expansion
--------------------------------------------------*/
-
-speaker_config *machine_config_add_speaker(machine_config *machine, const char *tag, float x, float y, float z)
-{
- int speakernum;
-
- for (speakernum = 0; speakernum < MAX_SPEAKER; speakernum++)
- if (machine->speaker[speakernum].tag == NULL)
- {
- machine->speaker[speakernum].tag = tag;
- machine->speaker[speakernum].x = x;
- machine->speaker[speakernum].y = y;
- machine->speaker[speakernum].z = z;
- return &machine->speaker[speakernum];
- }
-
- fatalerror("Out of speakers!\n");
- return NULL;
-}
-
-
-/*-------------------------------------------------
- machine_config_find_speaker - find a tagged speaker
- system during machine driver expansion
--------------------------------------------------*/
-
-speaker_config *machine_config_find_speaker(machine_config *machine, const char *tag)
-{
- int speakernum;
-
- for (speakernum = 0; speakernum < MAX_SPEAKER; speakernum++)
- if (machine->speaker[speakernum].tag && strcmp(machine->speaker[speakernum].tag, tag) == 0)
- return &machine->speaker[speakernum];
-
- fatalerror("Can't find speaker '%s'!\n", tag);
- return NULL;
-}
-
-
-/*-------------------------------------------------
- machine_config_remove_speaker - remove a tagged speaker
- system during machine driver expansion
--------------------------------------------------*/
-
-void machine_config_remove_speaker(machine_config *machine, const char *tag)
-{
- int speakernum;
-
- for (speakernum = 0; speakernum < MAX_SPEAKER; speakernum++)
- if (machine->speaker[speakernum].tag && strcmp(machine->speaker[speakernum].tag, tag) == 0)
- {
- memmove(&machine->speaker[speakernum], &machine->speaker[speakernum + 1], sizeof(machine->speaker[0]) * (MAX_SPEAKER - speakernum - 1));
- memset(&machine->speaker[MAX_SPEAKER - 1], 0, sizeof(machine->speaker[0]));
- return;
- }
-
- fatalerror("Can't find speaker '%s'!\n", tag);
-}
-
-
-/*-------------------------------------------------
machine_config_add_sound - add a sound system during
machine driver expansion
-------------------------------------------------*/
@@ -244,3 +190,329 @@ void machine_config_remove_sound(machine_config *machine, const char *tag)
fatalerror("Can't find sound '%s'!\n", tag);
}
+
+
+/*-------------------------------------------------
+ machine_config_detokenize - detokenize a
+ machine config
+-------------------------------------------------*/
+
+static void machine_config_detokenize(machine_config *config, const machine_config_token *tokens)
+{
+ UINT32 entrytype = MCONFIG_TOKEN_INVALID;
+ device_config *device = NULL;
+ cpu_config *cpu = NULL;
+ sound_config *sound = NULL;
+
+ /* loop over tokens until we hit the end */
+ while (entrytype != MCONFIG_TOKEN_END)
+ {
+ device_type devtype;
+ const char *tag;
+ int size, offset, type, bits;
+ UINT32 data32, clock, gain;
+ UINT64 data64;
+
+ /* unpack the token from the first entry */
+ TOKEN_GET_UINT32_UNPACK1(tokens, entrytype, 8);
+ switch (entrytype)
+ {
+ /* end */
+ case MCONFIG_TOKEN_END:
+ break;
+
+ /* including */
+ case MCONFIG_TOKEN_INCLUDE:
+ machine_config_detokenize(config, TOKEN_GET_PTR(tokens, tokenptr));
+ break;
+
+ /* device management */
+ case MCONFIG_TOKEN_DEVICE_ADD:
+ devtype = TOKEN_GET_PTR(tokens, devtype);
+ tag = TOKEN_GET_STRING(tokens);
+ device = device_list_add(&config->devicelist, devtype, tag);
+ break;
+
+ case MCONFIG_TOKEN_DEVICE_REMOVE:
+ devtype = TOKEN_GET_PTR(tokens, devtype);
+ tag = TOKEN_GET_STRING(tokens);
+ device_list_remove(&config->devicelist, devtype, tag);
+ device = NULL;
+ break;
+
+ case MCONFIG_TOKEN_DEVICE_MODIFY:
+ devtype = TOKEN_GET_PTR(tokens, devtype);
+ tag = TOKEN_GET_STRING(tokens);
+ device = (device_config *)device_list_find_by_tag(config->devicelist, devtype, tag);
+ if (device == NULL)
+ fatalerror("Unable to find device: type=%s tag=%s\n", devtype_name(devtype), tag);
+ break;
+
+ case MCONFIG_TOKEN_DEVICE_CONFIG:
+ assert(device != NULL);
+ device->static_config = TOKEN_GET_PTR(tokens, voidptr);
+ break;
+
+ case MCONFIG_TOKEN_DEVICE_CONFIG_DATA32:
+ assert(device != NULL);
+ TOKEN_UNGET_UINT32(tokens);
+ TOKEN_GET_UINT32_UNPACK3(tokens, entrytype, 8, size, 6, offset, 12);
+ data32 = TOKEN_GET_UINT32(tokens);
+ switch (size)
+ {
+ case 1: *(UINT8 *) ((UINT8 *)device->inline_config + offset) = data32; break;
+ case 2: *(UINT16 *)((UINT8 *)device->inline_config + offset) = data32; break;
+ case 4: *(UINT32 *)((UINT8 *)device->inline_config + offset) = data32; break;
+ }
+ break;
+
+ case MCONFIG_TOKEN_DEVICE_CONFIG_DATA64:
+ assert(device != NULL);
+ TOKEN_UNGET_UINT32(tokens);
+ TOKEN_GET_UINT32_UNPACK3(tokens, entrytype, 8, size, 6, offset, 12);
+ TOKEN_EXTRACT_UINT64(tokens, data64);
+ switch (size)
+ {
+ case 1: *(UINT8 *) ((UINT8 *)device->inline_config + offset) = data64; break;
+ case 2: *(UINT16 *)((UINT8 *)device->inline_config + offset) = data64; break;
+ case 4: *(UINT32 *)((UINT8 *)device->inline_config + offset) = data64; break;
+ case 8: *(UINT64 *)((UINT8 *)device->inline_config + offset) = data64; break;
+ }
+ break;
+
+ case MCONFIG_TOKEN_DEVICE_CONFIG_DATAFP32:
+ assert(device != NULL);
+ TOKEN_UNGET_UINT32(tokens);
+ TOKEN_GET_UINT32_UNPACK4(tokens, entrytype, 8, size, 6, bits, 6, offset, 12);
+ data32 = TOKEN_GET_UINT32(tokens);
+ switch (size)
+ {
+ case 4: *(float *)((UINT8 *)device->inline_config + offset) = (float)(INT32)data32 / (float)(1 << bits); break;
+ case 8: *(double *)((UINT8 *)device->inline_config + offset) = (double)(INT32)data32 / (double)(1 << bits); break;
+ }
+ break;
+
+ case MCONFIG_TOKEN_DEVICE_CONFIG_DATAFP64:
+ assert(device != NULL);
+ TOKEN_UNGET_UINT32(tokens);
+ TOKEN_GET_UINT32_UNPACK4(tokens, entrytype, 8, size, 6, bits, 6, offset, 12);
+ TOKEN_EXTRACT_UINT64(tokens, data64);
+ switch (size)
+ {
+ case 4: *(float *)((UINT8 *)device->inline_config + offset) = (float)(INT64)data64 / (float)((UINT64)1 << bits); break;
+ case 8: *(double *)((UINT8 *)device->inline_config + offset) = (double)(INT64)data64 / (double)((UINT64)1 << bits); break;
+ }
+ break;
+
+
+ /* add/modify/remove/replace CPUs */
+ case MCONFIG_TOKEN_CPU_ADD:
+ TOKEN_UNGET_UINT32(tokens);
+ TOKEN_GET_UINT64_UNPACK3(tokens, entrytype, 8, type, 24, clock, 32);
+ tag = TOKEN_GET_STRING(tokens);
+ cpu = machine_config_add_cpu(config, tag, type, clock);
+ break;
+
+ case MCONFIG_TOKEN_CPU_MODIFY:
+ tag = TOKEN_GET_STRING(tokens);
+ cpu = machine_config_find_cpu(config, tag);
+ break;
+
+ case MCONFIG_TOKEN_CPU_REMOVE:
+ tag = TOKEN_GET_STRING(tokens);
+ machine_config_remove_cpu(config, tag);
+ cpu = NULL;
+ break;
+
+ case MCONFIG_TOKEN_CPU_REPLACE:
+ TOKEN_UNGET_UINT32(tokens);
+ TOKEN_GET_UINT64_UNPACK3(tokens, entrytype, 8, type, 24, clock, 32);
+ tag = TOKEN_GET_STRING(tokens);
+ cpu = machine_config_find_cpu(config, tag);
+ if (cpu == NULL)
+ fatalerror("Unable to find CPU: tag=%s\n", tag);
+ cpu->type = type;
+ cpu->clock = clock;
+ break;
+
+ /* CPU parameters */
+ case MCONFIG_TOKEN_CPU_FLAGS:
+ assert(cpu != NULL);
+ TOKEN_UNGET_UINT32(tokens);
+ TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, cpu->flags, 24);
+ break;
+
+ case MCONFIG_TOKEN_CPU_CONFIG:
+ assert(cpu != NULL);
+ cpu->reset_param = TOKEN_GET_PTR(tokens, voidptr);
+ break;
+
+ case MCONFIG_TOKEN_CPU_PROGRAM_MAP:
+ assert(cpu != NULL);
+ cpu->construct_map[ADDRESS_SPACE_PROGRAM][0] = TOKEN_GET_PTR(tokens, voidptr);
+ cpu->construct_map[ADDRESS_SPACE_PROGRAM][1] = TOKEN_GET_PTR(tokens, voidptr);
+ break;
+
+ case MCONFIG_TOKEN_CPU_DATA_MAP:
+ assert(cpu != NULL);
+ cpu->construct_map[ADDRESS_SPACE_DATA][0] = TOKEN_GET_PTR(tokens, voidptr);
+ cpu->construct_map[ADDRESS_SPACE_DATA][1] = TOKEN_GET_PTR(tokens, voidptr);
+ break;
+
+ case MCONFIG_TOKEN_CPU_IO_MAP:
+ assert(cpu != NULL);
+ cpu->construct_map[ADDRESS_SPACE_IO][0] = TOKEN_GET_PTR(tokens, voidptr);
+ cpu->construct_map[ADDRESS_SPACE_IO][1] = TOKEN_GET_PTR(tokens, voidptr);
+ break;
+
+ case MCONFIG_TOKEN_CPU_VBLANK_INT:
+ assert(cpu != NULL);
+ TOKEN_UNGET_UINT32(tokens);
+ TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, cpu->vblank_interrupts_per_frame, 24);
+ cpu->vblank_interrupt = TOKEN_GET_PTR(tokens, interrupt);
+ break;
+
+ case MCONFIG_TOKEN_CPU_PERIODIC_INT:
+ assert(cpu != NULL);
+ TOKEN_UNGET_UINT32(tokens);
+ TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, data32, 24);
+ cpu->timed_interrupt_period = HZ_TO_ATTOSECONDS(data32);
+ cpu->timed_interrupt = TOKEN_GET_PTR(tokens, interrupt);
+ break;
+
+ /* core parameters */
+ case MCONFIG_TOKEN_DRIVER_DATA:
+ TOKEN_UNGET_UINT32(tokens);
+ TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, config->driver_data_size, 24);
+ break;
+
+ case MCONFIG_TOKEN_INTERLEAVE:
+ TOKEN_UNGET_UINT32(tokens);
+ TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, config->cpu_slices_per_frame, 24);
+ break;
+
+ case MCONFIG_TOKEN_WATCHDOG_VBLANK:
+ TOKEN_UNGET_UINT32(tokens);
+ TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, config->watchdog_vblank_count, 24);
+ break;
+
+ case MCONFIG_TOKEN_WATCHDOG_TIME:
+ TOKEN_EXTRACT_UINT64(tokens, data64);
+ config->watchdog_time = UINT64_ATTOTIME_TO_ATTOTIME(data64);
+ break;
+
+ /* core functions */
+ case MCONFIG_TOKEN_MACHINE_START:
+ config->machine_start = TOKEN_GET_PTR(tokens, machine_start);
+ break;
+
+ case MCONFIG_TOKEN_MACHINE_RESET:
+ config->machine_reset = TOKEN_GET_PTR(tokens, machine_reset);
+ break;
+
+ case MCONFIG_TOKEN_NVRAM_HANDLER:
+ config->nvram_handler = TOKEN_GET_PTR(tokens, nvram_handler);
+ break;
+
+ case MCONFIG_TOKEN_MEMCARD_HANDLER:
+ config->memcard_handler = TOKEN_GET_PTR(tokens, memcard_handler);
+ break;
+
+ /* core video parameters */
+ case MCONFIG_TOKEN_VIDEO_ATTRIBUTES:
+ TOKEN_UNGET_UINT32(tokens);
+ TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, config->video_attributes, 24);
+ break;
+
+ case MCONFIG_TOKEN_GFXDECODE:
+ config->gfxdecodeinfo = TOKEN_GET_PTR(tokens, gfxdecode);
+ break;
+
+ case MCONFIG_TOKEN_PALETTE_LENGTH:
+ TOKEN_UNGET_UINT32(tokens);
+ TOKEN_GET_UINT32_UNPACK2(tokens, entrytype, 8, config->total_colors, 24);
+ break;
+
+ case MCONFIG_TOKEN_DEFAULT_LAYOUT:
+ config->default_layout = TOKEN_GET_STRING(tokens);
+ break;
+
+ /* core video functions */
+ case MCONFIG_TOKEN_PALETTE_INIT:
+ config->init_palette = TOKEN_GET_PTR(tokens, palette_init);
+ break;
+
+ case MCONFIG_TOKEN_VIDEO_START:
+ config->video_start = TOKEN_GET_PTR(tokens, video_start);
+ break;
+
+ case MCONFIG_TOKEN_VIDEO_RESET:
+ config->video_reset = TOKEN_GET_PTR(tokens, video_reset);
+ break;
+
+ case MCONFIG_TOKEN_VIDEO_EOF:
+ config->video_eof = TOKEN_GET_PTR(tokens, video_eof);
+ break;
+
+ case MCONFIG_TOKEN_VIDEO_UPDATE:
+ config->video_update = TOKEN_GET_PTR(tokens, video_update);
+ break;
+
+ /* core sound functions */
+ case MCONFIG_TOKEN_SOUND_START:
+ config->sound_start = TOKEN_GET_PTR(tokens, sound_start);
+ break;
+
+ case MCONFIG_TOKEN_SOUND_RESET:
+ config->sound_reset = TOKEN_GET_PTR(tokens, sound_reset);
+ break;
+
+ /* add/remove/replace sounds */
+ case MCONFIG_TOKEN_SOUND_ADD:
+ TOKEN_UNGET_UINT32(tokens);
+ TOKEN_GET_UINT64_UNPACK3(tokens, entrytype, 8, type, 24, clock, 32);
+ tag = TOKEN_GET_STRING(tokens);
+ sound = machine_config_add_sound(config, tag, type, clock);
+ break;
+
+ case MCONFIG_TOKEN_SOUND_REMOVE:
+ machine_config_remove_sound(config, TOKEN_GET_STRING(tokens));
+ break;
+
+ case MCONFIG_TOKEN_SOUND_MODIFY:
+ tag = TOKEN_GET_STRING(tokens);
+ sound = machine_config_find_sound(config, tag);
+ if (sound == NULL)
+ fatalerror("Unable to find sound: tag=%s\n", tag);
+ sound->routes = 0;
+ break;
+
+ case MCONFIG_TOKEN_SOUND_CONFIG:
+ assert(sound != NULL);
+ sound->config = TOKEN_GET_PTR(tokens, voidptr);
+ break;
+
+ case MCONFIG_TOKEN_SOUND_REPLACE:
+ TOKEN_UNGET_UINT32(tokens);
+ TOKEN_GET_UINT64_UNPACK3(tokens, entrytype, 8, type, 24, clock, 32);
+ tag = TOKEN_GET_STRING(tokens);
+ sound = machine_config_find_sound(config, tag);
+ if (sound == NULL)
+ fatalerror("Unable to find sound: tag=%s\n", tag);
+ sound->type = type;
+ sound->clock = clock;
+ sound->config = NULL;
+ sound->routes = 0;
+ break;
+
+ case MCONFIG_TOKEN_SOUND_ROUTE:
+ assert(sound != NULL);
+ TOKEN_UNGET_UINT32(tokens);
+ TOKEN_GET_UINT64_UNPACK4(tokens, entrytype, 8, sound->route[sound->routes].output, -12, sound->route[sound->routes].input, -12, gain, 32);
+ sound->route[sound->routes].gain = (float)gain / 16777216.0f;
+ sound->route[sound->routes].target = TOKEN_GET_STRING(tokens);
+ sound->routes++;
+ break;
+ }
+ }
+}
diff --git a/src/emu/mconfig.h b/src/emu/mconfig.h
index b8a8b3ede7d..83d01fabe5b 100644
--- a/src/emu/mconfig.h
+++ b/src/emu/mconfig.h
@@ -15,15 +15,72 @@
#define __MCONFIG_H__
#include "devintrf.h"
+#include <stddef.h>
/***************************************************************************
CONSTANTS
***************************************************************************/
-/* maxima */
-#define MAX_SPEAKER 4
-
+/* token types */
+enum
+{
+ MCONFIG_TOKEN_INVALID,
+ MCONFIG_TOKEN_END,
+ MCONFIG_TOKEN_INCLUDE,
+
+ MCONFIG_TOKEN_DEVICE_ADD,
+ MCONFIG_TOKEN_DEVICE_REMOVE,
+ MCONFIG_TOKEN_DEVICE_MODIFY,
+ MCONFIG_TOKEN_DEVICE_CONFIG,
+ MCONFIG_TOKEN_DEVICE_CONFIG_DATA32,
+ MCONFIG_TOKEN_DEVICE_CONFIG_DATA64,
+ MCONFIG_TOKEN_DEVICE_CONFIG_DATAFP32,
+ MCONFIG_TOKEN_DEVICE_CONFIG_DATAFP64,
+
+ MCONFIG_TOKEN_CPU_ADD,
+ MCONFIG_TOKEN_CPU_MODIFY,
+ MCONFIG_TOKEN_CPU_REMOVE,
+ MCONFIG_TOKEN_CPU_REPLACE,
+ MCONFIG_TOKEN_CPU_FLAGS,
+ MCONFIG_TOKEN_CPU_CONFIG,
+ MCONFIG_TOKEN_CPU_PROGRAM_MAP,
+ MCONFIG_TOKEN_CPU_DATA_MAP,
+ MCONFIG_TOKEN_CPU_IO_MAP,
+ MCONFIG_TOKEN_CPU_VBLANK_INT,
+ MCONFIG_TOKEN_CPU_PERIODIC_INT,
+
+ MCONFIG_TOKEN_DRIVER_DATA,
+ MCONFIG_TOKEN_INTERLEAVE,
+ MCONFIG_TOKEN_WATCHDOG_VBLANK,
+ MCONFIG_TOKEN_WATCHDOG_TIME,
+
+ MCONFIG_TOKEN_MACHINE_START,
+ MCONFIG_TOKEN_MACHINE_RESET,
+ MCONFIG_TOKEN_NVRAM_HANDLER,
+ MCONFIG_TOKEN_MEMCARD_HANDLER,
+
+ MCONFIG_TOKEN_VIDEO_ATTRIBUTES,
+ MCONFIG_TOKEN_GFXDECODE,
+ MCONFIG_TOKEN_PALETTE_LENGTH,
+ MCONFIG_TOKEN_DEFAULT_LAYOUT,
+
+ MCONFIG_TOKEN_PALETTE_INIT,
+ MCONFIG_TOKEN_VIDEO_START,
+ MCONFIG_TOKEN_VIDEO_RESET,
+ MCONFIG_TOKEN_VIDEO_EOF,
+ MCONFIG_TOKEN_VIDEO_UPDATE,
+
+ MCONFIG_TOKEN_SOUND_START,
+ MCONFIG_TOKEN_SOUND_RESET,
+
+ MCONFIG_TOKEN_SOUND_ADD,
+ MCONFIG_TOKEN_SOUND_REMOVE,
+ MCONFIG_TOKEN_SOUND_MODIFY,
+ MCONFIG_TOKEN_SOUND_CONFIG,
+ MCONFIG_TOKEN_SOUND_REPLACE,
+ MCONFIG_TOKEN_SOUND_ROUTE,
+};
/* ----- flags for video_attributes ----- */
@@ -84,7 +141,6 @@ struct _machine_config
UINT32 (*video_update)(running_machine *machine, int screen, mame_bitmap *bitmap, const rectangle *cliprect); /* video update callback */
sound_config sound[MAX_SOUND]; /* array of sound chips in the system */
- speaker_config speaker[MAX_SPEAKER]; /* array of speakers in the system */
void (*sound_start)(running_machine *machine); /* one-time sound start callback */
void (*sound_reset)(running_machine *machine); /* sound reset callback */
@@ -98,286 +154,325 @@ struct _machine_config
MACROS FOR BUILDING MACHINE DRIVERS
***************************************************************************/
-/* use this to declare external references to a machine driver */
-#define MACHINE_DRIVER_EXTERN(game) \
- void construct_##game(machine_config *machine) \
+/* this type is used to encode machine configuration definitions */
+typedef union _machine_config_token machine_config_token;
+union _machine_config_token
+{
+ TOKEN_COMMON_FIELDS
+ const machine_config_token *tokenptr;
+ const gfx_decode_entry *gfxdecode;
+ device_type devtype;
+ void (*interrupt)(running_machine *machine, int cpunum);
+ driver_init_func driver_init;
+ nvram_handler_func nvram_handler;
+ memcard_handler_func memcard_handler;
+ machine_start_func machine_start;
+ machine_reset_func machine_reset;
+ sound_start_func sound_start;
+ sound_reset_func sound_reset;
+ video_start_func video_start;
+ video_reset_func video_reset;
+ palette_init_func palette_init;
+ video_eof_func video_eof;
+ video_update_func video_update;
+};
+
/* start/end tags for the machine driver */
-#define MACHINE_DRIVER_START(game) \
- void construct_##game(machine_config *machine) \
- { \
- cpu_config *cpu = NULL; \
- sound_config *sound = NULL; \
- device_config *device = NULL; \
- (void)cpu; \
- (void)sound; \
- (void)device; \
+#define MACHINE_DRIVER_START(_name) \
+ const machine_config_token machine_config_##_name[] = {
-#define MACHINE_DRIVER_END \
- } \
+#define MACHINE_DRIVER_END \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_END, 8) };
+
+/* use this to declare external references to a machine driver */
+#define MACHINE_DRIVER_EXTERN(_name) \
+ extern const machine_config_token machine_config_##_name[];
/* importing data from other machine drivers */
-#define MDRV_IMPORT_FROM(game) \
- construct_##game(machine); \
+#define MDRV_IMPORT_FROM(_name) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_INCLUDE, 8), \
+ TOKEN_PTR(tokenptr, machine_config_##_name),
/* add/remove/config devices */
-#define MDRV_DEVICE_ADD(_tag, _type) \
- device = device_list_add(&machine->devicelist, _type, _tag); \
+#define MDRV_DEVICE_ADD(_tag, _type) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_DEVICE_ADD, 8), \
+ TOKEN_PTR(devtype, _type), \
+ TOKEN_STRING(_tag),
+
+#define MDRV_DEVICE_REMOVE(_tag, _type) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_DEVICE_REMOVE, 8), \
+ TOKEN_PTR(devtype, _type), \
+ TOKEN_STRING(_tag),
-#define MDRV_DEVICE_REMOVE(_tag, _type) \
- device_list_remove(&machine->devicelist, _type, _tag); \
+#define MDRV_DEVICE_MODIFY(_tag, _type) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_DEVICE_MODIFY, 8), \
+ TOKEN_PTR(devtype, _type), \
+ TOKEN_STRING(_tag),
-#define MDRV_DEVICE_MODIFY(_tag, _type) \
- device = (device_config *)device_list_find_by_tag(machine->devicelist, _type, _tag); \
+#define MDRV_DEVICE_CONFIG(_config) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_DEVICE_CONFIG, 8), \
+ TOKEN_PTR(voidptr, &(_config)),
-#define MDRV_DEVICE_CONFIG(_config) \
- device->static_config = &(_config); \
+#define MDRV_DEVICE_CONFIG_DATA32(_struct, _field, _val) \
+ TOKEN_UINT32_PACK3(MCONFIG_TOKEN_DEVICE_CONFIG_DATA32, 8, sizeof(((_struct *)NULL)->_field), 6, offsetof(_struct, _field), 12), \
+ TOKEN_UINT32((UINT32)(_val)),
-#define MDRV_DEVICE_CONFIG_DATA(_struct, _field, _val) \
- ((_struct *)device->inline_config)->_field = (_val); \
+#define MDRV_DEVICE_CONFIG_DATA64(_struct, _field, _val) \
+ TOKEN_UINT32_PACK3(MCONFIG_TOKEN_DEVICE_CONFIG_DATA64, 8, sizeof(((_struct *)NULL)->_field), 6, offsetof(_struct, _field), 12), \
+ TOKEN_UINT64((UINT64)(_val)),
+
+#define MDRV_DEVICE_CONFIG_DATAFP32(_struct, _field, _val, _fixbits) \
+ TOKEN_UINT32_PACK4(MCONFIG_TOKEN_DEVICE_CONFIG_DATAFP32, 8, sizeof(((_struct *)NULL)->_field), 6, _fixbits, 6, offsetof(_struct, _field), 12), \
+ TOKEN_UINT32((UINT32)((float)(_val) * (float)(1 << (_fixbits)))),
+
+#define MDRV_DEVICE_CONFIG_DATAFP64(_struct, _field, _val, _fixbits) \
+ TOKEN_UINT32_PACK4(MCONFIG_TOKEN_DEVICE_CONFIG_DATAFP64, 8, sizeof(((_struct *)NULL)->_field), 6, _fixbits, 6, offsetof(_struct, _field), 12), \
+ TOKEN_UINT64((UINT64)((float)(_val) * (float)((UINT64)1 << (_fixbits)))),
+
+#ifdef PTR64
+#define MDRV_DEVICE_CONFIG_DATAPTR(_struct, _field, _val) MDRV_DEVICE_CONFIG_DATA64(_struct, _field, _val)
+#else
+#define MDRV_DEVICE_CONFIG_DATAPTR(_struct, _field, _val) MDRV_DEVICE_CONFIG_DATA32(_struct, _field, _val)
+#endif
/* add/modify/remove/replace CPUs */
-#define MDRV_CPU_ADD_TAG(tag, type, clock) \
- cpu = machine_config_add_cpu(machine, (tag), CPU_##type, (clock)); \
+#define MDRV_CPU_ADD_TAG(_tag, _type, _clock) \
+ TOKEN_UINT64_PACK3(MCONFIG_TOKEN_CPU_ADD, 8, CPU_##_type, 24, _clock, 32), \
+ TOKEN_STRING(_tag),
-#define MDRV_CPU_ADD(type, clock) \
- MDRV_CPU_ADD_TAG(NULL, type, clock) \
+#define MDRV_CPU_ADD(_type, _clock) \
+ MDRV_CPU_ADD_TAG(NULL, _type, _clock)
-#define MDRV_CPU_MODIFY(tag) \
- cpu = machine_config_find_cpu(machine, tag); \
+#define MDRV_CPU_MODIFY(_tag) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_CPU_MODIFY, 8), \
+ TOKEN_STRING(_tag),
-#define MDRV_CPU_REMOVE(tag) \
- machine_config_remove_cpu(machine, tag); \
- cpu = NULL; \
+#define MDRV_CPU_REMOVE(_tag) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_CPU_REMOVE, 8), \
+ TOKEN_STRING(_tag),
-#define MDRV_CPU_REPLACE(tag, _type, _clock) \
- cpu = machine_config_find_cpu(machine, tag); \
- cpu->type = (CPU_##_type); \
- cpu->clock = (_clock); \
+#define MDRV_CPU_REPLACE(_tag, _type, _clock) \
+ TOKEN_UINT64_PACK3(MCONFIG_TOKEN_CPU_REPLACE, 8, CPU_##_type, 24, _clock, 32), \
+ TOKEN_STRING(_tag),
/* CPU parameters */
-#define MDRV_CPU_FLAGS(_flags) \
- if (cpu) \
- cpu->flags = (_flags); \
-
-#define MDRV_CPU_CONFIG(config) \
- if (cpu) \
- cpu->reset_param = &(config); \
-
-#define MDRV_CPU_PROGRAM_MAP(readmem, writemem) \
- if (cpu) \
- { \
- cpu->construct_map[ADDRESS_SPACE_PROGRAM][0] = (construct_map_##readmem); \
- cpu->construct_map[ADDRESS_SPACE_PROGRAM][1] = (construct_map_##writemem); \
- } \
-
-#define MDRV_CPU_DATA_MAP(readmem, writemem) \
- if (cpu) \
- { \
- cpu->construct_map[ADDRESS_SPACE_DATA][0] = (construct_map_##readmem); \
- cpu->construct_map[ADDRESS_SPACE_DATA][1] = (construct_map_##writemem); \
- } \
-
-#define MDRV_CPU_IO_MAP(readmem, writemem) \
- if (cpu) \
- { \
- cpu->construct_map[ADDRESS_SPACE_IO][0] = (construct_map_##readmem); \
- cpu->construct_map[ADDRESS_SPACE_IO][1] = (construct_map_##writemem); \
- } \
-
-#define MDRV_CPU_VBLANK_INT(func, rate) \
- if (cpu) \
- { \
- cpu->vblank_interrupt = func; \
- cpu->vblank_interrupts_per_frame = (rate); \
- } \
-
-#define MDRV_CPU_PERIODIC_INT(func, rate) \
- if (cpu) \
- { \
- cpu->timed_interrupt = func; \
- cpu->timed_interrupt_period = HZ_TO_ATTOSECONDS(rate); \
- } \
+#define MDRV_CPU_FLAGS(_flags) \
+ TOKEN_UINT32_PACK2(MCONFIG_TOKEN_CPU_FLAGS, 8, _flags, 24),
+
+#define MDRV_CPU_CONFIG(_config) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_CPU_CONFIG, 8), \
+ TOKEN_PTR(voidptr, &(_config)),
+
+#define MDRV_CPU_PROGRAM_MAP(_map1, _map2) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_CPU_PROGRAM_MAP, 8), \
+ TOKEN_PTR(voidptr, construct_map_##_map1), \
+ TOKEN_PTR(voidptr, construct_map_##_map2), \
+
+#define MDRV_CPU_DATA_MAP(_map1, _map2) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_CPU_DATA_MAP, 8), \
+ TOKEN_PTR(voidptr, construct_map_##_map1), \
+ TOKEN_PTR(voidptr, construct_map_##_map2), \
+
+#define MDRV_CPU_IO_MAP(_map1, _map2) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_CPU_IO_MAP, 8), \
+ TOKEN_PTR(voidptr, construct_map_##_map1), \
+ TOKEN_PTR(voidptr, construct_map_##_map2), \
+
+#define MDRV_CPU_VBLANK_INT(_func, _rate) \
+ TOKEN_UINT32_PACK2(MCONFIG_TOKEN_CPU_VBLANK_INT, 8, _rate, 24), \
+ TOKEN_PTR(interrupt, _func),
+
+#define MDRV_CPU_PERIODIC_INT(_func, _rate) \
+ TOKEN_UINT32_PACK2(MCONFIG_TOKEN_CPU_PERIODIC_INT, 8, _rate, 24), \
+ TOKEN_PTR(interrupt, _func),
/* core parameters */
-#define MDRV_DRIVER_DATA(_struct) \
- machine->driver_data_size = sizeof(_struct); \
+#define MDRV_DRIVER_DATA(_struct) \
+ TOKEN_UINT32_PACK2(MCONFIG_TOKEN_DRIVER_DATA, 8, sizeof(_struct), 24),
-#define MDRV_INTERLEAVE(interleave) \
- machine->cpu_slices_per_frame = (interleave); \
+#define MDRV_INTERLEAVE(_interleave) \
+ TOKEN_UINT32_PACK2(MCONFIG_TOKEN_INTERLEAVE, 8, _interleave, 24),
-#define MDRV_WATCHDOG_VBLANK_INIT(watch_count) \
- machine->watchdog_vblank_count = (watch_count); \
+#define MDRV_WATCHDOG_VBLANK_INIT(_count) \
+ TOKEN_UINT32_PACK2(MCONFIG_TOKEN_WATCHDOG_VBLANK, 8, _count, 24),
-#define MDRV_WATCHDOG_TIME_INIT(time) \
- machine->watchdog_time = (time); \
+#define MDRV_WATCHDOG_TIME_INIT(_time) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_WATCHDOG_TIME, 8), \
+ TOKEN_UINT64(_time),
/* core functions */
-#define MDRV_MACHINE_START(name) \
- machine->machine_start = machine_start_##name; \
+#define MDRV_MACHINE_START(_func) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_MACHINE_START, 8), \
+ TOKEN_PTR(machine_start, machine_start_##_func),
-#define MDRV_MACHINE_RESET(name) \
- machine->machine_reset = machine_reset_##name; \
+#define MDRV_MACHINE_RESET(_func) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_MACHINE_RESET, 8), \
+ TOKEN_PTR(machine_reset, machine_reset_##_func),
-#define MDRV_NVRAM_HANDLER(name) \
- machine->nvram_handler = nvram_handler_##name; \
+#define MDRV_NVRAM_HANDLER(_func) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_NVRAM_HANDLER, 8), \
+ TOKEN_PTR(nvram_handler, nvram_handler_##_func),
-#define MDRV_MEMCARD_HANDLER(name) \
- machine->memcard_handler = memcard_handler_##name; \
+#define MDRV_MEMCARD_HANDLER(_func) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_MEMCARD_HANDLER, 8), \
+ TOKEN_PTR(memcard_handler, memcard_handler_##_func),
/* core video parameters */
-#define MDRV_VIDEO_ATTRIBUTES(flags) \
- machine->video_attributes = (flags); \
+#define MDRV_VIDEO_ATTRIBUTES(_flags) \
+ TOKEN_UINT32_PACK2(MCONFIG_TOKEN_VIDEO_ATTRIBUTES, 8, _flags, 24),
-#define MDRV_GFXDECODE(gfx) \
- machine->gfxdecodeinfo = (gfxdecodeinfo_##gfx); \
+#define MDRV_GFXDECODE(_gfx) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_GFXDECODE, 8), \
+ TOKEN_PTR(gfxdecode, gfxdecodeinfo_##_gfx),
-#define MDRV_PALETTE_LENGTH(length) \
- machine->total_colors = (length); \
+#define MDRV_PALETTE_LENGTH(_length) \
+ TOKEN_UINT32_PACK2(MCONFIG_TOKEN_PALETTE_LENGTH, 8, _length, 24),
-#define MDRV_DEFAULT_LAYOUT(layout) \
- machine->default_layout = &(layout)[0]; \
+#define MDRV_DEFAULT_LAYOUT(_layout) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_DEFAULT_LAYOUT, 8), \
+ TOKEN_STRING(&(_layout)[0]),
/* core video functions */
-#define MDRV_PALETTE_INIT(name) \
- machine->init_palette = palette_init_##name; \
+#define MDRV_PALETTE_INIT(_func) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_PALETTE_INIT, 8), \
+ TOKEN_PTR(palette_init, palette_init_##_func),
-#define MDRV_VIDEO_START(name) \
- machine->video_start = video_start_##name; \
+#define MDRV_VIDEO_START(_func) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_VIDEO_START, 8), \
+ TOKEN_PTR(video_start, video_start_##_func),
-#define MDRV_VIDEO_RESET(name) \
- machine->video_reset = video_reset_##name; \
+#define MDRV_VIDEO_RESET(_func) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_VIDEO_RESET, 8), \
+ TOKEN_PTR(video_reset, video_reset_##_func),
-#define MDRV_VIDEO_EOF(name) \
- machine->video_eof = video_eof_##name; \
+#define MDRV_VIDEO_EOF(_func) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_VIDEO_EOF, 8), \
+ TOKEN_PTR(video_eof, video_eof_##_func),
-#define MDRV_VIDEO_UPDATE(name) \
- machine->video_update = video_update_##name; \
+#define MDRV_VIDEO_UPDATE(_func) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_VIDEO_UPDATE, 8), \
+ TOKEN_PTR(video_update, video_update_##_func),
/* add/remove screens */
-#define MDRV_SCREEN_ADD(tag, _type) \
- MDRV_DEVICE_ADD(tag, VIDEO_SCREEN) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, type, SCREEN_TYPE_##_type) \
+#define MDRV_SCREEN_ADD(_tag, _type) \
+ MDRV_DEVICE_ADD(_tag, VIDEO_SCREEN) \
+ MDRV_DEVICE_CONFIG_DATA32(screen_config, type, SCREEN_TYPE_##_type)
-#define MDRV_SCREEN_REMOVE(tag) \
- MDRV_DEVICE_REMOVE(tag, VIDEO_SCREEN) \
+#define MDRV_SCREEN_REMOVE(_tag) \
+ MDRV_DEVICE_REMOVE(_tag, VIDEO_SCREEN)
-#define MDRV_SCREEN_MODIFY(tag) \
- MDRV_DEVICE_MODIFY(tag, VIDEO_SCREEN) \
+#define MDRV_SCREEN_MODIFY(_tag) \
+ MDRV_DEVICE_MODIFY(_tag, VIDEO_SCREEN)
-#define MDRV_SCREEN_FORMAT(_format) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, defstate.format, _format) \
+#define MDRV_SCREEN_FORMAT(_format) \
+ MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.format, _format)
-#define MDRV_SCREEN_TYPE(_type) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, type, SCREEN_TYPE_##_type) \
+#define MDRV_SCREEN_TYPE(_type) \
+ MDRV_DEVICE_CONFIG_DATA32(screen_config, type, SCREEN_TYPE_##_type)
-#define MDRV_SCREEN_RAW_PARAMS(pixclock, htotal, hbend, hbstart, vtotal, vbend, vbstart) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, defstate.refresh, HZ_TO_ATTOSECONDS(pixclock) * (htotal) * (vtotal)) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, defstate.vblank, ((HZ_TO_ATTOSECONDS(pixclock) * (htotal) * (vtotal)) / (vtotal)) * ((vtotal) - ((vbstart) - (vbend)))) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, defstate.width, htotal) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, defstate.height, vtotal) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, defstate.visarea.min_x, hbend) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, defstate.visarea.max_x, (hbstart) - 1) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, defstate.visarea.min_y, vbend) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, defstate.visarea.max_y, (vbstart) - 1) \
+#define MDRV_SCREEN_RAW_PARAMS(_pixclock, _htotal, _hbend, _hbstart, _vtotal, _vbend, _vbstart) \
+ MDRV_DEVICE_CONFIG_DATA64(screen_config, defstate.refresh, HZ_TO_ATTOSECONDS(_pixclock) * (_htotal) * (_vtotal)) \
+ MDRV_DEVICE_CONFIG_DATA64(screen_config, defstate.vblank, ((HZ_TO_ATTOSECONDS(_pixclock) * (_htotal) * (_vtotal)) / (_vtotal)) * ((_vtotal) - ((_vbstart) - (_vbend)))) \
+ MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.width, _htotal) \
+ MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.height, _vtotal) \
+ MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.visarea.min_x, _hbend) \
+ MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.visarea.max_x, (_hbstart) - 1) \
+ MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.visarea.min_y, _vbend) \
+ MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.visarea.max_y, (_vbstart) - 1)
-#define MDRV_SCREEN_REFRESH_RATE(rate) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, defstate.refresh, HZ_TO_ATTOSECONDS(rate)) \
+#define MDRV_SCREEN_REFRESH_RATE(_rate) \
+ MDRV_DEVICE_CONFIG_DATA64(screen_config, defstate.refresh, HZ_TO_ATTOSECONDS(_rate))
-#define MDRV_SCREEN_VBLANK_TIME(time) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, defstate.vblank, time) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, defstate.oldstyle_vblank_supplied, TRUE) \
+#define MDRV_SCREEN_VBLANK_TIME(_time) \
+ MDRV_DEVICE_CONFIG_DATA64(screen_config, defstate.vblank, _time) \
+ MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.oldstyle_vblank_supplied, TRUE)
-#define MDRV_SCREEN_SIZE(_width, _height) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, defstate.width, _width) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, defstate.height, _height) \
+#define MDRV_SCREEN_SIZE(_width, _height) \
+ MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.width, _width) \
+ MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.height, _height)
-#define MDRV_SCREEN_VISIBLE_AREA(minx, maxx, miny, maxy) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, defstate.visarea.min_x, minx) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, defstate.visarea.max_x, maxx) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, defstate.visarea.min_y, miny) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, defstate.visarea.max_y, maxy) \
+#define MDRV_SCREEN_VISIBLE_AREA(_minx, _maxx, _miny, _maxy) \
+ MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.visarea.min_x, _minx) \
+ MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.visarea.max_x, _maxx) \
+ MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.visarea.min_y, _miny) \
+ MDRV_DEVICE_CONFIG_DATA32(screen_config, defstate.visarea.max_y, _maxy)
#define MDRV_SCREEN_DEFAULT_POSITION(_xscale, _xoffs, _yscale, _yoffs) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, xoffset, (float)(_xoffs)) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, xscale, (float)(_xscale)) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, yoffset, (float)(_yoffs)) \
- MDRV_DEVICE_CONFIG_DATA(screen_config, yscale, (float)(_yscale)) \
+ MDRV_DEVICE_CONFIG_DATAFP32(screen_config, xoffset, _xoffs, 24) \
+ MDRV_DEVICE_CONFIG_DATAFP32(screen_config, xscale, _xscale, 24) \
+ MDRV_DEVICE_CONFIG_DATAFP32(screen_config, yoffset, _yoffs, 24) \
+ MDRV_DEVICE_CONFIG_DATAFP32(screen_config, yscale, _yscale, 24)
/* add/remove speakers */
-#define MDRV_SPEAKER_ADD(tag, x, y, z) \
- machine_config_add_speaker(machine, (tag), (float)(x), (float)(y), (float)(z)); \
+#define MDRV_SPEAKER_ADD(_tag, _x, _y, _z) \
+ MDRV_DEVICE_ADD(_tag, SPEAKER_OUTPUT) \
+ MDRV_DEVICE_CONFIG_DATAFP32(speaker_config, x, _x, 24) \
+ MDRV_DEVICE_CONFIG_DATAFP32(speaker_config, y, _y, 24) \
+ MDRV_DEVICE_CONFIG_DATAFP32(speaker_config, z, _z, 24)
-#define MDRV_SPEAKER_REMOVE(tag) \
- machine_config_remove_speaker(machine, (tag)); \
+#define MDRV_SPEAKER_REMOVE(_tag) \
+ MDRV_DEVICE_REMOVE(_tag, SPEAKER_OUTPUT)
-#define MDRV_SPEAKER_STANDARD_MONO(tag) \
- MDRV_SPEAKER_ADD(tag, 0.0, 0.0, 1.0) \
+#define MDRV_SPEAKER_STANDARD_MONO(_tag) \
+ MDRV_SPEAKER_ADD(_tag, 0.0, 0.0, 1.0)
-#define MDRV_SPEAKER_STANDARD_STEREO(tagl, tagr) \
- MDRV_SPEAKER_ADD(tagl, -0.2, 0.0, 1.0) \
- MDRV_SPEAKER_ADD(tagr, 0.2, 0.0, 1.0) \
+#define MDRV_SPEAKER_STANDARD_STEREO(_tagl, _tagr) \
+ MDRV_SPEAKER_ADD(_tagl, -0.2, 0.0, 1.0) \
+ MDRV_SPEAKER_ADD(_tagr, 0.2, 0.0, 1.0)
/* core sound functions */
-#define MDRV_SOUND_START(name) \
- machine->sound_start = sound_start_##name; \
+#define MDRV_SOUND_START(_func) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_SOUND_START, 8), \
+ TOKEN_PTR(sound_start, sound_start_##_func),
-#define MDRV_SOUND_RESET(name) \
- machine->sound_reset = sound_reset_##name; \
+#define MDRV_SOUND_RESET(_func) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_SOUND_RESET, 8), \
+ TOKEN_PTR(sound_start, sound_reset_##_func),
/* add/remove/replace sounds */
-#define MDRV_SOUND_ADD_TAG(tag, type, clock) \
- sound = machine_config_add_sound(machine, (tag), SOUND_##type, (clock)); \
+#define MDRV_SOUND_ADD_TAG(_tag, _type, _clock) \
+ TOKEN_UINT64_PACK3(MCONFIG_TOKEN_SOUND_ADD, 8, SOUND_##_type, 24, _clock, 32), \
+ TOKEN_STRING(_tag),
-#define MDRV_SOUND_ADD(type, clock) \
- MDRV_SOUND_ADD_TAG(NULL, type, clock) \
+#define MDRV_SOUND_ADD(_type, _clock) \
+ MDRV_SOUND_ADD_TAG(NULL, _type, _clock)
-#define MDRV_SOUND_REMOVE(tag) \
- machine_config_remove_sound(machine, tag); \
+#define MDRV_SOUND_REMOVE(_tag) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_SOUND_REMOVE, 8), \
+ TOKEN_STRING(_tag),
-#define MDRV_SOUND_MODIFY(tag) \
- sound = machine_config_find_sound(machine, tag); \
- sound->routes = 0; \
+#define MDRV_SOUND_MODIFY(_tag) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_SOUND_MODIFY, 8), \
+ TOKEN_STRING(_tag),
-#define MDRV_SOUND_CONFIG(_config) \
- if (sound) \
- sound->config = &(_config); \
+#define MDRV_SOUND_CONFIG(_config) \
+ TOKEN_UINT32_PACK1(MCONFIG_TOKEN_SOUND_CONFIG, 8), \
+ TOKEN_PTR(voidptr, &(_config)),
-#define MDRV_SOUND_REPLACE(tag, _type, _clock) \
- sound = machine_config_find_sound(machine, tag); \
- if (sound) \
- { \
- sound->type = SOUND_##_type; \
- sound->clock = (_clock); \
- sound->config = NULL; \
- sound->routes = 0; \
- } \
+#define MDRV_SOUND_REPLACE(_tag, _type, _clock) \
+ TOKEN_UINT64_PACK3(MCONFIG_TOKEN_SOUND_REPLACE, 8, SOUND_##_type, 24, _clock, 32), \
+ TOKEN_STRING(_tag),
#define MDRV_SOUND_ROUTE_EX(_output, _target, _gain, _input) \
- if (sound) \
- { \
- sound->route[sound->routes].output = (_output); \
- sound->route[sound->routes].target = (_target); \
- sound->route[sound->routes].gain = (float)(_gain); \
- sound->route[sound->routes].input = (_input); \
- sound->routes++; \
- } \
+ TOKEN_UINT64_PACK4(MCONFIG_TOKEN_SOUND_ROUTE, 8, _output, 12, _input, 12, (UINT32)((float)(_gain) * 16777216.0f), 32), \
+ TOKEN_STRING(_target),
-#define MDRV_SOUND_ROUTE(_output, _target, _gain) \
- MDRV_SOUND_ROUTE_EX(_output, _target, _gain, -1) \
+#define MDRV_SOUND_ROUTE(_output, _target, _gain) \
+ MDRV_SOUND_ROUTE_EX(_output, _target, _gain, -1)
@@ -389,7 +484,7 @@ struct _machine_config
/* ----- machine configurations ----- */
/* allocate a new machine configuration and populate it using the supplied constructor */
-machine_config *machine_config_alloc(void (*constructor)(machine_config *));
+machine_config *machine_config_alloc(const machine_config_token *tokens);
/* release memory allocated for a machine configuration */
void machine_config_free(machine_config *config);
@@ -402,10 +497,6 @@ cpu_config *machine_config_add_cpu(machine_config *machine, const char *tag, cpu
cpu_config *machine_config_find_cpu(machine_config *machine, const char *tag);
void machine_config_remove_cpu(machine_config *machine, const char *tag);
-speaker_config *machine_config_add_speaker(machine_config *machine, const char *tag, float x, float y, float z);
-speaker_config *machine_config_find_speaker(machine_config *machine, const char *tag);
-void machine_config_remove_speaker(machine_config *machine, const char *tag);
-
sound_config *machine_config_add_sound(machine_config *machine, const char *tag, sound_type type, int clock);
sound_config *machine_config_find_sound(machine_config *machine, const char *tag);
void machine_config_remove_sound(machine_config *machine, const char *tag);
diff --git a/src/emu/sound.c b/src/emu/sound.c
index 7f59ff4dbe3..213fb38dee6 100644
--- a/src/emu/sound.c
+++ b/src/emu/sound.c
@@ -72,6 +72,7 @@ typedef struct _speaker_info speaker_info;
struct _speaker_info
{
const speaker_config *speaker; /* pointer to the speaker info */
+ const char * tag; /* speaker tag */
sound_stream * mixer_stream; /* mixing stream */
int inputs; /* number of input streams */
speaker_input * input; /* array of input information */
@@ -93,9 +94,6 @@ static emu_timer *sound_update_timer;
static int totalsnd;
static sound_info sound[MAX_SOUND];
-static int totalspeakers;
-static speaker_info speaker[MAX_SPEAKER];
-
static INT16 *finalmix;
static UINT32 finalmix_leftover;
static INT32 *leftmix, *rightmix;
@@ -120,7 +118,6 @@ static void sound_load(int config_type, xml_data_node *parentnode);
static void sound_save(int config_type, xml_data_node *parentnode);
static TIMER_CALLBACK( sound_update );
static void start_sound_chips(void);
-static void start_speakers(void);
static void route_sound(void);
static void mixer_update(void *param, stream_sample_t **inputs, stream_sample_t **buffer, int length);
@@ -136,13 +133,8 @@ static void mixer_update(void *param, stream_sample_t **inputs, stream_sample_t
INLINE speaker_info *find_speaker_by_tag(const char *tag)
{
- int spknum;
-
- /* attempt to find the speaker in our list */
- for (spknum = 0; spknum < totalspeakers; spknum++)
- if (strcmp(speaker[spknum].speaker->tag, tag) == 0)
- return &speaker[spknum];
- return NULL;
+ const device_config *speaker = device_list_find_by_tag(Machine->config->devicelist, SPEAKER_OUTPUT, tag);
+ return (speaker == NULL) ? NULL : speaker->token;
}
@@ -179,16 +171,15 @@ void sound_init(running_machine *machine)
/* handle -nosound */
nosound_mode = !options_get_bool(mame_options(), OPTION_SOUND);
if (nosound_mode)
- Machine->sample_rate = 11025;
+ machine->sample_rate = 11025;
/* count the speakers */
- for (totalspeakers = 0; Machine->config->speaker[totalspeakers].tag; totalspeakers++) ;
- VPRINTF(("total speakers = %d\n", totalspeakers));
+ VPRINTF(("total speakers = %d\n", speaker_output_count(machine->config)));
/* allocate memory for mix buffers */
- leftmix = auto_malloc(Machine->sample_rate * sizeof(*leftmix));
- rightmix = auto_malloc(Machine->sample_rate * sizeof(*rightmix));
- finalmix = auto_malloc(Machine->sample_rate * sizeof(*finalmix));
+ leftmix = auto_malloc(machine->sample_rate * sizeof(*leftmix));
+ rightmix = auto_malloc(machine->sample_rate * sizeof(*rightmix));
+ finalmix = auto_malloc(machine->sample_rate * sizeof(*finalmix));
/* allocate a global timer for sound timing */
sound_update_timer = timer_alloc(sound_update, NULL);
@@ -202,10 +193,6 @@ void sound_init(running_machine *machine)
VPRINTF(("start_sound_chips\n"));
start_sound_chips();
- /* then create all the speakers */
- VPRINTF(("start_speakers\n"));
- start_speakers();
-
/* finally, do all the routing */
VPRINTF(("route_sound\n"));
route_sound();
@@ -240,29 +227,13 @@ static void sound_exit(running_machine *machine)
if (wavfile != NULL)
wav_close(wavfile);
-#ifdef MAME_DEBUG
-{
- int spknum;
-
- /* log the maximum sample values for all speakers */
- for (spknum = 0; spknum < totalspeakers; spknum++)
- if (speaker[spknum].max_sample > 0)
- {
- speaker_info *spk = &speaker[spknum];
- mame_printf_debug("Speaker \"%s\" - max = %d (gain *= %f) - %d%% samples clipped\n", spk->speaker->tag, spk->max_sample, 32767.0 / (spk->max_sample ? spk->max_sample : 1), (int)((double)spk->clipped_samples * 100.0 / spk->total_samples));
- }
-}
-#endif /* MAME_DEBUG */
-
/* stop all the sound chips */
for (sndnum = 0; sndnum < MAX_SOUND; sndnum++)
if (Machine->config->sound[sndnum].type != SOUND_DUMMY)
sndintrf_exit_sound(sndnum);
/* reset variables */
- totalspeakers = 0;
totalsnd = 0;
- memset(&speaker, 0, sizeof(speaker));
memset(&sound, 0, sizeof(sound));
}
@@ -363,45 +334,14 @@ static void start_sound_chips(void)
/*-------------------------------------------------
- start_speakers - loop over all speakers and
- initialize them
--------------------------------------------------*/
-
-static void start_speakers(void)
-{
- /* reset the speaker array */
- memset(speaker, 0, sizeof(speaker));
-
- /* start up all the speakers */
- for (totalspeakers = 0; totalspeakers < MAX_SPEAKER; totalspeakers++)
- {
- const speaker_config *mspeaker = &Machine->config->speaker[totalspeakers];
- speaker_info *info;
-
- /* stop when we hit an empty entry */
- if (mspeaker->tag == NULL)
- break;
-
- /* zap all the info */
- info = &speaker[totalspeakers];
- memset(info, 0, sizeof(*info));
-
- /* copy in all the relevant info */
- info->speaker = mspeaker;
- info->mixer_stream = NULL;
- info->inputs = 0;
- }
-}
-
-
-/*-------------------------------------------------
route_sound - route sound outputs to target
inputs
-------------------------------------------------*/
static void route_sound(void)
{
- int sndnum, spknum, routenum, outputnum;
+ int sndnum, routenum, outputnum;
+ const device_config *curspeak;
/* iterate over all the sound chips */
for (sndnum = 0; sndnum < totalsnd; sndnum++)
@@ -436,9 +376,9 @@ static void route_sound(void)
/* now allocate the mixers and input data */
streams_set_tag(Machine, NULL);
- for (spknum = 0; spknum < totalspeakers; spknum++)
+ for (curspeak = speaker_output_first(Machine->config); curspeak != NULL; curspeak = speaker_output_next(curspeak))
{
- speaker_info *info = &speaker[spknum];
+ speaker_info *info = curspeak->token;
if (info->inputs != 0)
{
info->mixer_stream = stream_create(info->inputs, 1, Machine->sample_rate, info, mixer_update);
@@ -446,7 +386,7 @@ static void route_sound(void)
info->inputs = 0;
}
else
- logerror("Warning: speaker \"%s\" has no inputs\n", info->speaker->tag);
+ logerror("Warning: speaker \"%s\" has no inputs\n", info->tag);
}
/* iterate again over all the sound chips */
@@ -480,8 +420,8 @@ static void route_sound(void)
namebuf[0] = '\0';
/* speaker name, if more than one speaker */
- if (totalspeakers > 1)
- sprintf(namebuf, "%sSpeaker '%s': ", namebuf, speaker->speaker->tag);
+ if (speaker_output_count(Machine->config) > 1)
+ sprintf(namebuf, "%sSpeaker '%s': ", namebuf, speaker->tag);
/* device name */
sprintf(namebuf, "%s%s ", namebuf, sndnum_name(sndnum));
@@ -697,17 +637,18 @@ static void sound_save(int config_type, xml_data_node *parentnode)
static TIMER_CALLBACK( sound_update )
{
UINT32 finalmix_step, finalmix_offset;
+ const device_config *curspeak;
int samples_this_update = 0;
- int sample, spknum;
+ int sample;
VPRINTF(("sound_update\n"));
profiler_mark(PROFILER_SOUND);
/* force all the speaker streams to generate the proper number of samples */
- for (spknum = 0; spknum < totalspeakers; spknum++)
+ for (curspeak = speaker_output_first(Machine->config); curspeak != NULL; curspeak = speaker_output_next(curspeak))
{
- speaker_info *spk = &speaker[spknum];
+ speaker_info *spk = curspeak->token;
const stream_sample_t *stream_buf;
/* get the output buffer */
@@ -836,6 +777,90 @@ static void mixer_update(void *param, stream_sample_t **inputs, stream_sample_t
/***************************************************************************
+ SPEAKER OUTPUT DEVICE INTERFACE
+***************************************************************************/
+
+/*-------------------------------------------------
+ speaker_output_start - device start callback
+ for a speaker
+-------------------------------------------------*/
+
+static void *speaker_output_start(running_machine *machine, const char *tag, const void *static_config, const void *inline_config)
+{
+ speaker_info *info;
+
+ /* allocate memory for the speaker information */
+ info = auto_malloc(sizeof(*info));
+ memset(info, 0, sizeof(*info));
+
+ /* copy in all the relevant info */
+ info->speaker = inline_config;
+ info->tag = tag;
+ return info;
+}
+
+
+/*-------------------------------------------------
+ speaker_output_stop - device stop callback
+ for a speaker
+-------------------------------------------------*/
+
+static void speaker_output_stop(running_machine *machine, void *token)
+{
+#ifdef MAME_DEBUG
+ speaker_info *info = token;
+
+ /* log the maximum sample values for all speakers */
+ if (info->max_sample > 0)
+ mame_printf_debug("Speaker \"%s\" - max = %d (gain *= %f) - %d%% samples clipped\n", info->tag, info->max_sample, 32767.0 / (info->max_sample ? info->max_sample : 1), (int)((double)info->clipped_samples * 100.0 / info->total_samples));
+#endif /* MAME_DEBUG */
+}
+
+
+/*-------------------------------------------------
+ speaker_output_set_info - device set info
+ callback
+-------------------------------------------------*/
+
+static void speaker_output_set_info(running_machine *machine, void *token, UINT32 state, const deviceinfo *info)
+{
+ switch (state)
+ {
+ /* no parameters to set */
+ }
+}
+
+
+/*-------------------------------------------------
+ speaker_output_get_info - device get info
+ callback
+-------------------------------------------------*/
+
+void speaker_output_get_info(running_machine *machine, void *token, UINT32 state, deviceinfo *info)
+{
+ switch (state)
+ {
+ /* --- the following bits of info are returned as 64-bit signed integers --- */
+ case DEVINFO_INT_INLINE_CONFIG_BYTES: info->i = sizeof(speaker_config); break;
+
+ /* --- the following bits of info are returned as pointers to data or functions --- */
+ case DEVINFO_FCT_SET_INFO: info->set_info = speaker_output_set_info;break;
+ case DEVINFO_FCT_START: info->start = speaker_output_start; break;
+ case DEVINFO_FCT_STOP: info->stop = speaker_output_stop; break;
+ case DEVINFO_FCT_RESET: /* Nothing */ break;
+
+ /* --- the following bits of info are returned as NULL-terminated strings --- */
+ case DEVINFO_STR_NAME: info->s = "Speaker"; break;
+ case DEVINFO_STR_FAMILY: info->s = "Sound"; break;
+ case DEVINFO_STR_VERSION: info->s = "1.0"; break;
+ case DEVINFO_STR_SOURCE_FILE: info->s = __FILE__; break;
+ case DEVINFO_STR_CREDITS: info->s = "Copyright Nicola Salmoria and the MAME Team"; break;
+ }
+}
+
+
+
+/***************************************************************************
MISCELLANEOUS HELPERS
***************************************************************************/
@@ -874,17 +899,19 @@ void sndti_set_output_gain(sound_type type, int index, int output, float gain)
INLINE speaker_info *index_to_input(int index, int *input)
{
- int count = 0, speakernum;
+ const device_config *curspeak;
+ int count = 0;
/* scan through the speakers until we find the indexed input */
- for (speakernum = 0; speakernum < totalspeakers; speakernum++)
+ for (curspeak = speaker_output_first(Machine->config); curspeak != NULL; curspeak = speaker_output_next(curspeak))
{
- if (index < count + speaker[speakernum].inputs)
+ speaker_info *info = curspeak->token;
+ if (index < count + info->inputs)
{
*input = index - count;
- return &speaker[speakernum];
+ return info;
}
- count += speaker[speakernum].inputs;
+ count += info->inputs;
}
/* index out of range */
@@ -899,11 +926,15 @@ INLINE speaker_info *index_to_input(int index, int *input)
int sound_get_user_gain_count(void)
{
- int count = 0, speakernum;
+ const device_config *curspeak;
+ int count = 0;
/* count up the number of speaker inputs */
- for (speakernum = 0; speakernum < totalspeakers; speakernum++)
- count += speaker[speakernum].inputs;
+ for (curspeak = speaker_output_first(Machine->config); curspeak != NULL; curspeak = speaker_output_next(curspeak))
+ {
+ speaker_info *info = curspeak->token;
+ count += info->inputs;
+ }
return count;
}
diff --git a/src/emu/sound.h b/src/emu/sound.h
index e62b9d0c8ef..a2f4ccda195 100644
--- a/src/emu/sound.h
+++ b/src/emu/sound.h
@@ -26,6 +26,18 @@
/***************************************************************************
+ MACROS
+***************************************************************************/
+
+/* these functions are macros primarily due to include file ordering */
+/* plus, they are very simple */
+#define speaker_output_count(config) device_list_items((config)->devicelist, SPEAKER_OUTPUT)
+#define speaker_output_first(config) device_list_first((config)->devicelist, SPEAKER_OUTPUT)
+#define speaker_output_next(previous) device_list_next((previous), SPEAKER_OUTPUT)
+
+
+
+/***************************************************************************
TYPE DEFINITIONS
***************************************************************************/
@@ -57,7 +69,6 @@ struct _sound_config
typedef struct _speaker_config speaker_config;
struct _speaker_config
{
- const char *tag; /* tag for this speaker */
float x, y, z; /* positioning vector */
};
@@ -87,4 +98,11 @@ const char *sound_get_user_gain_name(int index);
int sound_find_sndnum_by_tag(const char *tag);
+/* ----- sound speaker device interface ----- */
+
+/* device get info callback */
+#define SPEAKER_OUTPUT speaker_output_get_info
+void speaker_output_get_info(running_machine *machine, void *token, UINT32 state, deviceinfo *info);
+
+
#endif /* __SOUND_H__ */
diff --git a/src/emu/timer.h b/src/emu/timer.h
index 7d18e2e3104..30ef72291cc 100644
--- a/src/emu/timer.h
+++ b/src/emu/timer.h
@@ -33,8 +33,10 @@
/* macros for the RC time constant on a 555 timer IC */
/* R is in ohms, C is in farads */
-#define PERIOD_OF_555_MONOSTABLE(r,c) ATTOTIME_IN_NSEC((attoseconds_t)(1100000000 * (double)(r) * (double)(c)))
-#define PERIOD_OF_555_ASTABLE(r1,r2,c) ATTOTIME_IN_NSEC((attoseconds_t)( 693000000 * ((double)(r1) + 2.0 * (double)(r2)) * (double)(c)))
+#define PERIOD_OF_555_MONOSTABLE_NSEC(r,c) ((attoseconds_t)(1100000000 * (double)(r) * (double)(c)))
+#define PERIOD_OF_555_ASTABLE_NSEC(r1,r2,c) ((attoseconds_t)( 693000000 * ((double)(r1) + 2.0 * (double)(r2)) * (double)(c)))
+#define PERIOD_OF_555_MONOSTABLE(r,c) ATTOTIME_IN_NSEC(PERIOD_OF_555_MONOSTABLE_NSEC(r,c))
+#define PERIOD_OF_555_ASTABLE(r1,r2,c) ATTOTIME_IN_NSEC(PERIOD_OF_555_ASTABLE_NSEC(r1,r2,c))
/* macros that map all allocations to provide file/line/functions to the callee */
#define timer_alloc(c,ptr) _timer_alloc_internal(c, ptr, __FILE__, __LINE__, #c)
diff --git a/src/emu/tokenize.h b/src/emu/tokenize.h
index a5bb4d387f7..99e49e3a1bb 100644
--- a/src/emu/tokenize.h
+++ b/src/emu/tokenize.h
@@ -72,41 +72,41 @@
/* 32-bit integer packing */
#define TOKEN_UINT32_PACK1(val1, bits1) \
- TOKEN_UINT32(SHIFT_AND_MASK32(val1, bits1, 0))
+ TOKEN_UINT32(SHIFT_AND_MASK32((val1), (bits1), 0))
#define TOKEN_UINT32_PACK2(val1, bits1, val2, bits2) \
- TOKEN_UINT32(SHIFT_AND_MASK32(val1, bits1, 0) | \
- SHIFT_AND_MASK32(val2, bits2, bits1))
+ TOKEN_UINT32(SHIFT_AND_MASK32((val1), (bits1), 0) | \
+ SHIFT_AND_MASK32((val2), (bits2), (bits1)))
#define TOKEN_UINT32_PACK3(val1, bits1, val2, bits2, val3, bits3) \
- TOKEN_UINT32(SHIFT_AND_MASK32(val1, bits1, 0) | \
- SHIFT_AND_MASK32(val2, bits2, bits1) | \
- SHIFT_AND_MASK32(val3, bits3, (bits1)+(bits2)))
+ TOKEN_UINT32(SHIFT_AND_MASK32((val1), (bits1), 0) | \
+ SHIFT_AND_MASK32((val2), (bits2), (bits1)) | \
+ SHIFT_AND_MASK32((val3), (bits3), (bits1)+(bits2)))
#define TOKEN_UINT32_PACK4(val1, bits1, val2, bits2, val3, bits3, val4, bits4) \
- TOKEN_UINT32(SHIFT_AND_MASK32(val1, bits1, 0) | \
- SHIFT_AND_MASK32(val2, bits2, bits1) | \
- SHIFT_AND_MASK32(val3, bits3, (bits1)+(bits2)) | \
- SHIFT_AND_MASK32(val4, bits4, (bits1)+(bits2)+(bits3)))
+ TOKEN_UINT32(SHIFT_AND_MASK32((val1), (bits1), 0) | \
+ SHIFT_AND_MASK32((val2), (bits2), (bits1)) | \
+ SHIFT_AND_MASK32((val3), (bits3), (bits1)+(bits2)) | \
+ SHIFT_AND_MASK32((val4), (bits4), (bits1)+(bits2)+(bits3)))
/* 64-bit integer packing */
#define TOKEN_UINT64_PACK1(val1, bits1) \
- TOKEN_UINT64(SHIFT_AND_MASK64(val1, bits1, 0))
+ TOKEN_UINT64(SHIFT_AND_MASK64((val1), (bits1), 0))
#define TOKEN_UINT64_PACK2(val1, bits1, val2, bits2) \
- TOKEN_UINT64(SHIFT_AND_MASK64(val1, bits1, 0) | \
- SHIFT_AND_MASK64(val2, bits2, bits1))
+ TOKEN_UINT64(SHIFT_AND_MASK64((val1), (bits1), 0) | \
+ SHIFT_AND_MASK64((val2), (bits2), (bits1)))
#define TOKEN_UINT64_PACK3(val1, bits1, val2, bits2, val3, bits3) \
- TOKEN_UINT64(SHIFT_AND_MASK64(val1, bits1, 0) | \
- SHIFT_AND_MASK64(val2, bits2, bits1) | \
- SHIFT_AND_MASK64(val3, bits3, (bits1)+(bits2)))
+ TOKEN_UINT64(SHIFT_AND_MASK64((val1), (bits1), 0) | \
+ SHIFT_AND_MASK64((val2), (bits2), (bits1)) | \
+ SHIFT_AND_MASK64((val3), (bits3), (bits1)+(bits2)))
#define TOKEN_UINT64_PACK4(val1, bits1, val2, bits2, val3, bits3, val4, bits4) \
- TOKEN_UINT64(SHIFT_AND_MASK64(val1, bits1, 0) | \
- SHIFT_AND_MASK64(val2, bits2, bits1) | \
- SHIFT_AND_MASK64(val3, bits3, (bits1)+(bits2)) | \
- SHIFT_AND_MASK64(val4, bits4, (bits1)+(bits2)+(bits3)))
+ TOKEN_UINT64(SHIFT_AND_MASK64((val1), (bits1), 0) | \
+ SHIFT_AND_MASK64((val2), (bits2), (bits1)) | \
+ SHIFT_AND_MASK64((val3), (bits3), (bits1)+(bits2)) | \
+ SHIFT_AND_MASK64((val4), (bits4), (bits1)+(bits2)+(bits3)))
@@ -149,65 +149,65 @@
/* 32-bit integer unpacking */
#define TOKEN_GET_UINT32_UNPACK1(tp, val1, bits1) do { \
UINT32 token32 = TOKEN_GET_UINT32(tp); \
- UNSHIFT_AND_MASK32(token32, val1, bits1, 0); \
+ UNSHIFT_AND_MASK32(token32, val1, (bits1), 0); \
} while (0)
#define TOKEN_GET_UINT32_UNPACK2(tp, val1, bits1, val2, bits2) do { \
UINT32 token32 = TOKEN_GET_UINT32(tp); \
UINT8 shift = 0; \
- UNSHIFT_AND_MASK32(token32, val1, bits1, shift); shift += TOKENABS(bits1); \
- UNSHIFT_AND_MASK32(token32, val2, bits2, shift); \
+ UNSHIFT_AND_MASK32(token32, val1, (bits1), shift); shift += TOKENABS(bits1); \
+ UNSHIFT_AND_MASK32(token32, val2, (bits2), shift); \
} while (0)
#define TOKEN_GET_UINT32_UNPACK3(tp, val1, bits1, val2, bits2, val3, bits3) do { \
UINT32 token32 = TOKEN_GET_UINT32(tp); \
UINT8 shift = 0; \
- UNSHIFT_AND_MASK32(token32, val1, bits1, shift); shift += TOKENABS(bits1); \
- UNSHIFT_AND_MASK32(token32, val2, bits2, shift); shift += TOKENABS(bits2); \
- UNSHIFT_AND_MASK32(token32, val3, bits3, shift); \
+ UNSHIFT_AND_MASK32(token32, val1, (bits1), shift); shift += TOKENABS(bits1); \
+ UNSHIFT_AND_MASK32(token32, val2, (bits2), shift); shift += TOKENABS(bits2); \
+ UNSHIFT_AND_MASK32(token32, val3, (bits3), shift); \
} while (0)
#define TOKEN_GET_UINT32_UNPACK4(tp, val1, bits1, val2, bits2, val3, bits3, val4, bits4) do { \
UINT32 token32 = TOKEN_GET_UINT32(tp); \
UINT8 shift = 0; \
- UNSHIFT_AND_MASK32(token32, val1, bits1, shift); shift += TOKENABS(bits1); \
- UNSHIFT_AND_MASK32(token32, val2, bits2, shift); shift += TOKENABS(bits2); \
- UNSHIFT_AND_MASK32(token32, val3, bits3, shift); shift += TOKENABS(bits3); \
- UNSHIFT_AND_MASK32(token32, val4, bits4, shift); \
+ UNSHIFT_AND_MASK32(token32, val1, (bits1), shift); shift += TOKENABS(bits1); \
+ UNSHIFT_AND_MASK32(token32, val2, (bits2), shift); shift += TOKENABS(bits2); \
+ UNSHIFT_AND_MASK32(token32, val3, (bits3), shift); shift += TOKENABS(bits3); \
+ UNSHIFT_AND_MASK32(token32, val4, (bits4), shift); \
} while (0)
/* 64-bit integer unpacking */
#define TOKEN_GET_UINT64_UNPACK1(tp, val1, bits1) do { \
UINT64 token64; \
TOKEN_EXTRACT_UINT64(tp, token64); \
- UNSHIFT_AND_MASK64(token64, val1, bits1, 0); \
+ UNSHIFT_AND_MASK64(token64, val1, (bits1), 0); \
} while (0)
#define TOKEN_GET_UINT64_UNPACK2(tp, val1, bits1, val2, bits2) do { \
UINT64 token64; \
UINT8 shift = 0; \
TOKEN_EXTRACT_UINT64(tp, token64); \
- UNSHIFT_AND_MASK64(token64, val1, bits1, shift); shift += TOKENABS(bits1); \
- UNSHIFT_AND_MASK64(token64, val2, bits2, shift); \
+ UNSHIFT_AND_MASK64(token64, val1, (bits1), shift); shift += TOKENABS(bits1); \
+ UNSHIFT_AND_MASK64(token64, val2, (bits2), shift); \
} while (0)
#define TOKEN_GET_UINT64_UNPACK3(tp, val1, bits1, val2, bits2, val3, bits3) do { \
UINT64 token64; \
UINT8 shift = 0; \
TOKEN_EXTRACT_UINT64(tp, token64); \
- UNSHIFT_AND_MASK64(token64, val1, bits1, shift); shift += TOKENABS(bits1); \
- UNSHIFT_AND_MASK64(token64, val2, bits2, shift); shift += TOKENABS(bits2); \
- UNSHIFT_AND_MASK64(token64, val3, bits3, shift); \
+ UNSHIFT_AND_MASK64(token64, val1, (bits1), shift); shift += TOKENABS(bits1); \
+ UNSHIFT_AND_MASK64(token64, val2, (bits2), shift); shift += TOKENABS(bits2); \
+ UNSHIFT_AND_MASK64(token64, val3, (bits3), shift); \
} while (0)
#define TOKEN_GET_UINT64_UNPACK4(tp, val1, bits1, val2, bits2, val3, bits3, val4, bits4) do { \
UINT64 token64; \
UINT8 shift = 0; \
TOKEN_EXTRACT_UINT64(tp, token64); \
- UNSHIFT_AND_MASK64(token64, val1, bits1, shift); shift += TOKENABS(bits1); \
- UNSHIFT_AND_MASK64(token64, val2, bits2, shift); shift += TOKENABS(bits2); \
- UNSHIFT_AND_MASK64(token64, val3, bits3, shift); shift += TOKENABS(bits3); \
- UNSHIFT_AND_MASK64(token64, val4, bits4, shift); \
+ UNSHIFT_AND_MASK64(token64, val1, (bits1), shift); shift += TOKENABS(bits1); \
+ UNSHIFT_AND_MASK64(token64, val2, (bits2), shift); shift += TOKENABS(bits2); \
+ UNSHIFT_AND_MASK64(token64, val3, (bits3), shift); shift += TOKENABS(bits3); \
+ UNSHIFT_AND_MASK64(token64, val4, (bits4), shift); \
} while (0)
diff --git a/src/emu/ui.c b/src/emu/ui.c
index 7165b6f9c4e..5da76f60c32 100644
--- a/src/emu/ui.c
+++ b/src/emu/ui.c
@@ -1108,22 +1108,27 @@ int sprintf_game_info(char *buffer)
/* display screen information */
bufptr += sprintf(bufptr, "\nVideo:\n");
- for (device = video_screen_first(Machine->config); device != NULL; device = video_screen_next(device))
+ if (scrcount == 0)
+ buffer += sprintf(bufptr, "None\n");
+ else
{
- int index = device_list_index(Machine->config->devicelist, VIDEO_SCREEN, device->tag);
- const screen_config *scrconfig = device->inline_config;
+ for (device = video_screen_first(Machine->config); device != NULL; device = video_screen_next(device))
+ {
+ int index = device_list_index(Machine->config->devicelist, VIDEO_SCREEN, device->tag);
+ const screen_config *scrconfig = device->inline_config;
- if (scrcount > 1)
- bufptr += sprintf(bufptr, "Screen %d: ", index + 1);
+ if (scrcount > 1)
+ bufptr += sprintf(bufptr, "Screen %d: ", index + 1);
- if (scrconfig->type == SCREEN_TYPE_VECTOR)
- bufptr += sprintf(bufptr, "Vector\n");
- else
- bufptr += sprintf(bufptr, "Resolution:\n%d " UTF8_MULTIPLY " %d (%s) %f" UTF8_NBSP "Hz\n",
- Machine->screen[0].visarea.max_x - Machine->screen[0].visarea.min_x + 1,
- Machine->screen[0].visarea.max_y - Machine->screen[0].visarea.min_y + 1,
- (Machine->gamedrv->flags & ORIENTATION_SWAP_XY) ? "V" : "H",
- ATTOSECONDS_TO_HZ(Machine->screen[0].refresh));
+ if (scrconfig->type == SCREEN_TYPE_VECTOR)
+ bufptr += sprintf(bufptr, "Vector\n");
+ else
+ bufptr += sprintf(bufptr, "%d " UTF8_MULTIPLY " %d (%s) %f" UTF8_NBSP "Hz\n",
+ scrconfig->defstate.visarea.max_x - scrconfig->defstate.visarea.min_x + 1,
+ scrconfig->defstate.visarea.max_y - scrconfig->defstate.visarea.min_y + 1,
+ (Machine->gamedrv->flags & ORIENTATION_SWAP_XY) ? "V" : "H",
+ ATTOSECONDS_TO_HZ(scrconfig->defstate.refresh));
+ }
}
return bufptr - buffer;
diff --git a/src/emu/validity.c b/src/emu/validity.c
index 00d3486a364..bd05902034d 100644
--- a/src/emu/validity.c
+++ b/src/emu/validity.c
@@ -364,7 +364,7 @@ static int validate_inlines(void)
information
-------------------------------------------------*/
-static int validate_driver(int drivnum, const machine_config *drv)
+static int validate_driver(int drivnum, const machine_config *config)
{
const game_driver *driver = drivers[drivnum];
const game_driver *clone_of;
@@ -416,7 +416,7 @@ static int validate_driver(int drivnum, const machine_config *drv)
#ifndef MESS
/* make sure sound-less drivers are flagged */
- if ((driver->flags & GAME_IS_BIOS_ROOT) == 0 && drv->sound[0].type == SOUND_DUMMY && (driver->flags & GAME_NO_SOUND) == 0 && strcmp(driver->name, "minivadr"))
+ if ((driver->flags & GAME_IS_BIOS_ROOT) == 0 && config->sound[0].type == SOUND_DUMMY && (driver->flags & GAME_NO_SOUND) == 0 && strcmp(driver->name, "minivadr"))
{
mame_printf_error("%s: %s missing GAME_NO_SOUND flag\n", driver->source_file, driver->name);
error = TRUE;
@@ -475,7 +475,7 @@ static int validate_driver(int drivnum, const machine_config *drv)
validate_roms - validate ROM definitions
-------------------------------------------------*/
-static int validate_roms(int drivnum, const machine_config *drv, UINT32 *region_length)
+static int validate_roms(int drivnum, const machine_config *config, UINT32 *region_length)
{
const game_driver *driver = drivers[drivnum];
const rom_entry *romp;
@@ -603,7 +603,7 @@ static int validate_roms(int drivnum, const machine_config *drv, UINT32 *region_
validate_cpu - validate CPUs and memory maps
-------------------------------------------------*/
-static int validate_cpu(int drivnum, const machine_config *drv, const UINT32 *region_length)
+static int validate_cpu(int drivnum, const machine_config *config, const UINT32 *region_length)
{
const game_driver *driver = drivers[drivnum];
int error = FALSE;
@@ -613,7 +613,7 @@ static int validate_cpu(int drivnum, const machine_config *drv, const UINT32 *re
for (cpunum = 0; cpunum < MAX_CPU; cpunum++)
{
extern void dummy_get_info(UINT32 state, cpuinfo *info);
- const cpu_config *cpu = &drv->cpu[cpunum];
+ const cpu_config *cpu = &config->cpu[cpunum];
int spacenum;
/* skip empty entries */
@@ -666,7 +666,7 @@ static int validate_cpu(int drivnum, const machine_config *drv, const UINT32 *re
/* construct the maps */
map = addrmap;
- construct_address_map(map, drv, cpunum, spacenum);
+ construct_address_map(map, config, cpunum, spacenum);
/* if this is an empty map, just skip it */
if (IS_AMENTRY_END(map))
@@ -771,7 +771,7 @@ static int validate_cpu(int drivnum, const machine_config *drv, const UINT32 *re
configurations
-------------------------------------------------*/
-static int validate_display(int drivnum, const machine_config *drv)
+static int validate_display(int drivnum, const machine_config *config)
{
const game_driver *driver = drivers[drivnum];
const device_config *device;
@@ -779,7 +779,7 @@ static int validate_display(int drivnum, const machine_config *drv)
int error = FALSE;
/* loop over screens */
- for (device = video_screen_first(drv); device != NULL; device = video_screen_next(device))
+ for (device = video_screen_first(config); device != NULL; device = video_screen_next(device))
{
const screen_config *scrconfig = device->inline_config;
@@ -823,7 +823,7 @@ static int validate_display(int drivnum, const machine_config *drv)
}
/* check for empty palette */
- if (palette_modes && drv->total_colors == 0)
+ if (palette_modes && config->total_colors == 0)
{
mame_printf_error("%s: %s has zero palette entries\n", driver->source_file, driver->name);
error = TRUE;
@@ -838,23 +838,23 @@ static int validate_display(int drivnum, const machine_config *drv)
configuration
-------------------------------------------------*/
-static int validate_gfx(int drivnum, const machine_config *drv, const UINT32 *region_length)
+static int validate_gfx(int drivnum, const machine_config *config, const UINT32 *region_length)
{
const game_driver *driver = drivers[drivnum];
int error = FALSE;
int gfxnum;
/* bail if no gfx */
- if (!drv->gfxdecodeinfo)
+ if (!config->gfxdecodeinfo)
return FALSE;
/* iterate over graphics decoding entries */
- for (gfxnum = 0; gfxnum < MAX_GFX_ELEMENTS && drv->gfxdecodeinfo[gfxnum].memory_region != -1; gfxnum++)
+ for (gfxnum = 0; gfxnum < MAX_GFX_ELEMENTS && config->gfxdecodeinfo[gfxnum].memory_region != -1; gfxnum++)
{
- const gfx_decode_entry *gfx = &drv->gfxdecodeinfo[gfxnum];
+ const gfx_decode_entry *gfx = &config->gfxdecodeinfo[gfxnum];
int region = gfx->memory_region;
- int xscale = (drv->gfxdecodeinfo[gfxnum].xscale == 0) ? 1 : drv->gfxdecodeinfo[gfxnum].xscale;
- int yscale = (drv->gfxdecodeinfo[gfxnum].yscale == 0) ? 1 : drv->gfxdecodeinfo[gfxnum].yscale;
+ int xscale = (config->gfxdecodeinfo[gfxnum].xscale == 0) ? 1 : config->gfxdecodeinfo[gfxnum].xscale;
+ int yscale = (config->gfxdecodeinfo[gfxnum].yscale == 0) ? 1 : config->gfxdecodeinfo[gfxnum].yscale;
const gfx_layout *gl = gfx->gfxlayout;
int israw = (gl->planeoffset[0] == GFX_RAW);
int planes = gl->planes;
@@ -987,7 +987,7 @@ static void display_valid_coin_order(int drivnum, const input_port_entry *memory
validate_inputs - validate input configuration
-------------------------------------------------*/
-static int validate_inputs(int drivnum, const machine_config *drv, input_port_entry **memory)
+static int validate_inputs(int drivnum, const machine_config *config, input_port_entry **memory)
{
const char *demo_sounds = input_port_string_from_index(INPUT_STRING_Demo_Sounds);
const char *flipscreen = input_port_string_from_index(INPUT_STRING_Flip_Screen);
@@ -1266,60 +1266,61 @@ static int validate_inputs(int drivnum, const machine_config *drv, input_port_en
speaker configuration
-------------------------------------------------*/
-static int validate_sound(int drivnum, const machine_config *drv)
+static int validate_sound(int drivnum, const machine_config *config)
{
const game_driver *driver = drivers[drivnum];
- int speaknum, sndnum;
+ const device_config *curspeak, *checkspeak;
int error = FALSE;
+ int sndnum;
/* make sure the speaker layout makes sense */
- for (speaknum = 0; speaknum < MAX_SPEAKER && drv->speaker[speaknum].tag; speaknum++)
+ for (curspeak = speaker_output_first(config); curspeak != NULL; curspeak = speaker_output_next(curspeak))
{
int check;
/* check for duplicate tags */
- for (check = 0; check < MAX_SPEAKER && drv->speaker[check].tag; check++)
- if (speaknum != check && drv->speaker[check].tag && !strcmp(drv->speaker[speaknum].tag, drv->speaker[check].tag))
+ for (checkspeak = speaker_output_first(config); checkspeak != NULL; checkspeak = speaker_output_next(checkspeak))
+ if (checkspeak != curspeak && strcmp(checkspeak->tag, curspeak->tag) == 0)
{
- mame_printf_error("%s: %s has multiple speakers tagged as '%s'\n", driver->source_file, driver->name, drv->speaker[speaknum].tag);
+ mame_printf_error("%s: %s has multiple speakers tagged as '%s'\n", driver->source_file, driver->name, checkspeak->tag);
error = TRUE;
}
/* make sure there are no sound chips with the same tag */
- for (check = 0; check < MAX_SOUND && drv->sound[check].type != SOUND_DUMMY; check++)
- if (drv->sound[check].tag && !strcmp(drv->speaker[speaknum].tag, drv->sound[check].tag))
+ for (check = 0; check < MAX_SOUND && config->sound[check].type != SOUND_DUMMY; check++)
+ if (config->sound[check].tag && strcmp(curspeak->tag, config->sound[check].tag) == 0)
{
- mame_printf_error("%s: %s has both a speaker and a sound chip tagged as '%s'\n", driver->source_file, driver->name, drv->speaker[speaknum].tag);
+ mame_printf_error("%s: %s has both a speaker and a sound chip tagged as '%s'\n", driver->source_file, driver->name, curspeak->tag);
error = TRUE;
}
}
/* make sure the sounds are wired to the speakers correctly */
- for (sndnum = 0; sndnum < MAX_SOUND && drv->sound[sndnum].type != SOUND_DUMMY; sndnum++)
+ for (sndnum = 0; sndnum < MAX_SOUND && config->sound[sndnum].type != SOUND_DUMMY; sndnum++)
{
int routenum;
/* loop over all the routes */
- for (routenum = 0; routenum < drv->sound[sndnum].routes; routenum++)
+ for (routenum = 0; routenum < config->sound[sndnum].routes; routenum++)
{
/* find a speaker with the requested tag */
- for (speaknum = 0; speaknum < MAX_SPEAKER && drv->speaker[speaknum].tag; speaknum++)
- if (!strcmp(drv->sound[sndnum].route[routenum].target, drv->speaker[speaknum].tag))
+ for (checkspeak = speaker_output_first(config); checkspeak != NULL; checkspeak = speaker_output_next(checkspeak))
+ if (strcmp(config->sound[sndnum].route[routenum].target, checkspeak->tag) == 0)
break;
/* if we didn't find one, look for another sound chip with the tag */
- if (speaknum >= MAX_SPEAKER || !drv->speaker[speaknum].tag)
+ if (checkspeak == NULL)
{
int check;
- for (check = 0; check < MAX_SOUND && drv->sound[check].type != SOUND_DUMMY; check++)
- if (check != sndnum && drv->sound[check].tag && !strcmp(drv->sound[check].tag, drv->sound[sndnum].route[routenum].target))
+ for (check = 0; check < MAX_SOUND && config->sound[check].type != SOUND_DUMMY; check++)
+ if (check != sndnum && config->sound[check].tag && strcmp(config->sound[check].tag, config->sound[sndnum].route[routenum].target) == 0)
break;
/* if we didn't find one, it's an error */
- if (check >= MAX_SOUND || drv->sound[check].type == SOUND_DUMMY)
+ if (check >= MAX_SOUND || config->sound[check].type == SOUND_DUMMY)
{
- mame_printf_error("%s: %s attempting to route sound to non-existant speaker '%s'\n", driver->source_file, driver->name, drv->sound[sndnum].route[routenum].target);
+ mame_printf_error("%s: %s attempting to route sound to non-existant speaker '%s'\n", driver->source_file, driver->name, config->sound[sndnum].route[routenum].target);
error = TRUE;
}
}
@@ -1413,7 +1414,7 @@ int mame_validitychecks(const game_driver *curdriver)
/* expand the machine driver */
expansion -= osd_profiling_ticks();
- config = machine_config_alloc(driver->drv);
+ config = machine_config_alloc(driver->machine_config);
expansion += osd_profiling_ticks();
/* validate the driver entry */
diff --git a/src/mame/audio/redalert.c b/src/mame/audio/redalert.c
index f214c47be5e..f5a4ba71428 100644
--- a/src/mame/audio/redalert.c
+++ b/src/mame/audio/redalert.c
@@ -21,7 +21,7 @@
#define REDALERT_AUDIO_PCB_CLOCK (XTAL_12_5MHz)
#define REDALERT_AUDIO_CPU_CLOCK (REDALERT_AUDIO_PCB_CLOCK / 12)
#define REDALERT_AY8910_CLOCK (REDALERT_AUDIO_PCB_CLOCK / 6)
-#define REDALERT_AUDIO_CPU_IRQ_FREQ (1.0 / attotime_to_double(PERIOD_OF_555_ASTABLE(RES_K(120), RES_K(2.7), CAP_U(0.01))))
+#define REDALERT_AUDIO_CPU_IRQ_FREQ (1000000000 / PERIOD_OF_555_ASTABLE_NSEC(RES_K(120), RES_K(2.7), CAP_U(0.01)))
#define REDALERT_VOICE_PCB_CLOCK (XTAL_6MHz)
#define REDALERT_VOICE_CPU_CLOCK (REDALERT_VOICE_PCB_CLOCK)
diff --git a/src/mame/drivers/airbustr.c b/src/mame/drivers/airbustr.c
index 42e45f9d491..ccfb30905ef 100644
--- a/src/mame/drivers/airbustr.c
+++ b/src/mame/drivers/airbustr.c
@@ -614,7 +614,7 @@ static MACHINE_DRIVER_START( airbustr )
MDRV_INTERLEAVE(100) // Palette RAM is filled by sub cpu with data supplied by main cpu
// Maybe a high value is safer in order to avoid glitches
MDRV_MACHINE_RESET(airbustr)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_SEC(3)) /* a guess, and certainly wrong */
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_SEC(3)) /* a guess, and certainly wrong */
// video hardware
diff --git a/src/mame/drivers/ampoker2.c b/src/mame/drivers/ampoker2.c
index dd5114a31db..cf326be437b 100644
--- a/src/mame/drivers/ampoker2.c
+++ b/src/mame/drivers/ampoker2.c
@@ -860,7 +860,7 @@ static MACHINE_DRIVER_START( ampoker2 )
MDRV_CPU_PROGRAM_MAP(ampoker2_map, 0)
MDRV_CPU_IO_MAP(ampoker2_io_map, 0)
MDRV_CPU_PERIODIC_INT(nmi_line_pulse, 1536)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_HZ( 5 )) /* 200 ms, measured */
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_HZ( 5 )) /* 200 ms, measured */
//MDRV_WATCHDOG_VBLANK_INIT(8)
MDRV_NVRAM_HANDLER(generic_0fill)
diff --git a/src/mame/drivers/atarifb.c b/src/mame/drivers/atarifb.c
index f2179e3cbdf..0cf07f523cb 100644
--- a/src/mame/drivers/atarifb.c
+++ b/src/mame/drivers/atarifb.c
@@ -607,6 +607,7 @@ static MACHINE_DRIVER_START( abaseb )
/* basic machine hardware */
MDRV_IMPORT_FROM(atarifb)
+ MDRV_CPU_MODIFY("main")
MDRV_CPU_PROGRAM_MAP(abaseb_map,0)
/* video hardware */
diff --git a/src/mame/drivers/cave.c b/src/mame/drivers/cave.c
index a5f2a126424..30f9274ae82 100644
--- a/src/mame/drivers/cave.c
+++ b/src/mame/drivers/cave.c
@@ -2353,7 +2353,7 @@ static MACHINE_DRIVER_START( mazinger )
MDRV_CPU_PROGRAM_MAP(mazinger_sound_readmem,mazinger_sound_writemem)
MDRV_CPU_IO_MAP(mazinger_sound_readport,mazinger_sound_writeport)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_SEC(3)) /* a guess, and certainly wrong */
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_SEC(3)) /* a guess, and certainly wrong */
MDRV_MACHINE_RESET(cave)
MDRV_NVRAM_HANDLER(cave)
@@ -2410,7 +2410,7 @@ static MACHINE_DRIVER_START( metmqstr )
MDRV_CPU_PROGRAM_MAP(metmqstr_sound_readmem,metmqstr_sound_writemem)
MDRV_CPU_IO_MAP(metmqstr_sound_readport,metmqstr_sound_writeport)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_SEC(3)) /* a guess, and certainly wrong */
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_SEC(3)) /* a guess, and certainly wrong */
MDRV_MACHINE_RESET(cave) /* start with the watchdog armed */
MDRV_NVRAM_HANDLER(cave)
diff --git a/src/mame/drivers/dlair.c b/src/mame/drivers/dlair.c
index 162ee3a8731..dde9fcff884 100644
--- a/src/mame/drivers/dlair.c
+++ b/src/mame/drivers/dlair.c
@@ -845,7 +845,7 @@ static MACHINE_DRIVER_START( dleuro )
MDRV_CPU_IO_MAP(dleuro_io_map,0)
MDRV_CPU_VBLANK_INT(vblank_callback, 1)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_HZ(MASTER_CLOCK_EURO/(16*16*16*16*16*8)))
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_HZ(MASTER_CLOCK_EURO/(16*16*16*16*16*8)))
MDRV_MACHINE_START(dleuro)
MDRV_MACHINE_RESET(dlair)
diff --git a/src/mame/drivers/dunhuang.c b/src/mame/drivers/dunhuang.c
index 6846b2cdf57..ea43e55b352 100644
--- a/src/mame/drivers/dunhuang.c
+++ b/src/mame/drivers/dunhuang.c
@@ -678,7 +678,7 @@ static MACHINE_DRIVER_START( dunhuang )
MDRV_CPU_IO_MAP(dunhuang_io_map,0)
MDRV_CPU_VBLANK_INT(irq0_line_hold,1)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_SEC(5))
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_SEC(5))
/* video hardware */
MDRV_SCREEN_ADD("main", RASTER)
diff --git a/src/mame/drivers/expro02.c b/src/mame/drivers/expro02.c
index 126f9a499e5..fa6746acd09 100644
--- a/src/mame/drivers/expro02.c
+++ b/src/mame/drivers/expro02.c
@@ -338,7 +338,7 @@ static MACHINE_DRIVER_START( galsnew )
MDRV_PALETTE_INIT(berlwall)
/* arm watchdog */
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_SEC(3)) /* a guess, and certainly wrong */
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_SEC(3)) /* a guess, and certainly wrong */
/* sound hardware */
MDRV_SPEAKER_STANDARD_MONO("mono")
diff --git a/src/mame/drivers/frogger.c b/src/mame/drivers/frogger.c
index bd249a1f949..e4aa3ff25ac 100644
--- a/src/mame/drivers/frogger.c
+++ b/src/mame/drivers/frogger.c
@@ -273,7 +273,6 @@ static MACHINE_DRIVER_START( froggrmc )
MDRV_CPU_PROGRAM_MAP(froggrmc_readmem,froggrmc_writemem)
MDRV_VIDEO_START(froggers)
- MDRV_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.33)
MACHINE_DRIVER_END
diff --git a/src/mame/drivers/galpanic.c b/src/mame/drivers/galpanic.c
index 4c08998ee93..39d5a42bef6 100644
--- a/src/mame/drivers/galpanic.c
+++ b/src/mame/drivers/galpanic.c
@@ -965,7 +965,7 @@ static MACHINE_DRIVER_START( galpania )
MDRV_IMPORT_FROM(galpanic)
/* arm watchdog */
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_SEC(3)) /* a guess, and certainly wrong */
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_SEC(3)) /* a guess, and certainly wrong */
MACHINE_DRIVER_END
static MACHINE_DRIVER_START( comad )
diff --git a/src/mame/drivers/gameplan.c b/src/mame/drivers/gameplan.c
index dbdae329024..cb476e1ab88 100644
--- a/src/mame/drivers/gameplan.c
+++ b/src/mame/drivers/gameplan.c
@@ -1180,7 +1180,7 @@ static MACHINE_DRIVER_START( gameplan )
MDRV_MACHINE_RESET(gameplan)
/* video hardware */
- MDRV_IMPORT_FROM(gameplan_video);
+ MDRV_IMPORT_FROM(gameplan_video)
/* audio hardware */
MDRV_SPEAKER_STANDARD_MONO("mono")
@@ -1200,7 +1200,7 @@ static MACHINE_DRIVER_START( leprechn )
MDRV_CPU_PROGRAM_MAP(leprechn_audio_map,0)
/* video hardware */
- MDRV_IMPORT_FROM(leprechn_video);
+ MDRV_IMPORT_FROM(leprechn_video)
MACHINE_DRIVER_END
diff --git a/src/mame/drivers/hyperspt.c b/src/mame/drivers/hyperspt.c
index df8da8662c5..1f045ede438 100644
--- a/src/mame/drivers/hyperspt.c
+++ b/src/mame/drivers/hyperspt.c
@@ -460,7 +460,7 @@ static const struct VLM5030interface hyperspt_vlm5030_interface =
static MACHINE_DRIVER_START( hyperspt )
/* basic machine hardware */
- MDRV_CPU_ADD(M6809, XTAL_18_432MHz/12) /* verified on pcb */
+ MDRV_CPU_ADD_TAG("main", M6809, XTAL_18_432MHz/12) /* verified on pcb */
MDRV_CPU_PROGRAM_MAP(hyperspt_readmem,writemem)
MDRV_CPU_VBLANK_INT(irq0_line_hold,1)
@@ -502,6 +502,7 @@ MACHINE_DRIVER_END
static MACHINE_DRIVER_START( roadf )
MDRV_IMPORT_FROM(hyperspt)
+ MDRV_CPU_MODIFY("main")
MDRV_CPU_PROGRAM_MAP(roadf_readmem, writemem)
MDRV_GFXDECODE(roadf)
MDRV_VIDEO_START(roadf)
diff --git a/src/mame/drivers/lockon.c b/src/mame/drivers/lockon.c
index f0a7ca568a2..ff638712f24 100644
--- a/src/mame/drivers/lockon.c
+++ b/src/mame/drivers/lockon.c
@@ -486,7 +486,7 @@ static MACHINE_DRIVER_START( lockon )
MDRV_CPU_PROGRAM_MAP(sound_prg, 0)
MDRV_CPU_IO_MAP(sound_io, 0)
- MDRV_WATCHDOG_TIME_INIT(attotime_mul(PERIOD_OF_555_ASTABLE(10000, 4700, 10000e-12), 4096))
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_NSEC(PERIOD_OF_555_ASTABLE_NSEC(10000, 4700, 10000e-12) * 4096))
MDRV_INTERLEAVE(10)
MDRV_VIDEO_ATTRIBUTES(VIDEO_UPDATE_AFTER_VBLANK)
diff --git a/src/mame/drivers/madalien.c b/src/mame/drivers/madalien.c
index 0166d41249d..75fcb79228a 100644
--- a/src/mame/drivers/madalien.c
+++ b/src/mame/drivers/madalien.c
@@ -185,7 +185,7 @@ static MACHINE_DRIVER_START( madalien )
MDRV_CPU_PERIODIC_INT(nmi_line_pulse, 800) /* unknown due to incomplete schematics */
/* video hardware */
- MDRV_IMPORT_FROM(madalien_video);
+ MDRV_IMPORT_FROM(madalien_video)
/* audio hardware */
MDRV_SPEAKER_STANDARD_MONO("mono")
diff --git a/src/mame/drivers/mcatadv.c b/src/mame/drivers/mcatadv.c
index 06ff642235d..862322f7f67 100644
--- a/src/mame/drivers/mcatadv.c
+++ b/src/mame/drivers/mcatadv.c
@@ -512,7 +512,7 @@ static MACHINE_DRIVER_START( mcatadv )
MDRV_GFXDECODE(mcatadv)
MDRV_PALETTE_LENGTH(0x2000/2)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_SEC(3)) /* a guess, and certainly wrong */
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_SEC(3)) /* a guess, and certainly wrong */
MDRV_VIDEO_START(mcatadv)
MDRV_VIDEO_EOF(mcatadv) // Buffer Spriteram
diff --git a/src/mame/drivers/mw8080bw.c b/src/mame/drivers/mw8080bw.c
index 183476cf73a..0014106ebc5 100644
--- a/src/mame/drivers/mw8080bw.c
+++ b/src/mame/drivers/mw8080bw.c
@@ -834,7 +834,7 @@ static MACHINE_DRIVER_START( zzzap )
MDRV_IMPORT_FROM(mw8080bw_root)
MDRV_CPU_MODIFY("main")
MDRV_CPU_IO_MAP(zzzap_io_map,0)
- MDRV_WATCHDOG_TIME_INIT( PERIOD_OF_555_MONOSTABLE(RES_M(1), CAP_U(1)) ) /* 1.1s */
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_NSEC(PERIOD_OF_555_MONOSTABLE_NSEC(RES_M(1), CAP_U(1)))) /* 1.1s */
/* audio hardware */
/* MDRV_IMPORT_FROM(zzzap_audio) */
@@ -946,7 +946,7 @@ static MACHINE_DRIVER_START( maze )
MDRV_CPU_MODIFY("main")
MDRV_CPU_IO_MAP(maze_io_map,0)
MDRV_MACHINE_START(maze)
- MDRV_WATCHDOG_TIME_INIT( PERIOD_OF_555_MONOSTABLE(RES_K(270), CAP_U(10)) ) /* 2.97s */
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_NSEC(PERIOD_OF_555_MONOSTABLE_NSEC(RES_K(270), CAP_U(10)))) /* 2.97s */
/* audio hardware */
MDRV_IMPORT_FROM(maze_audio)
@@ -1037,7 +1037,7 @@ static MACHINE_DRIVER_START( boothill )
MDRV_CPU_MODIFY("main")
MDRV_CPU_IO_MAP(boothill_io_map,0)
MDRV_MACHINE_START(boothill)
- MDRV_WATCHDOG_TIME_INIT( PERIOD_OF_555_MONOSTABLE(RES_K(270), CAP_U(10)) ) /* 2.97s */
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_NSEC(PERIOD_OF_555_MONOSTABLE_NSEC(RES_K(270), CAP_U(10)))) /* 2.97s */
/* audio hardware */
MDRV_IMPORT_FROM(boothill_audio)
@@ -1139,7 +1139,7 @@ static MACHINE_DRIVER_START( checkmat )
MDRV_IMPORT_FROM(mw8080bw_root)
MDRV_CPU_MODIFY("main")
MDRV_CPU_IO_MAP(checkmat_io_map,0)
- MDRV_WATCHDOG_TIME_INIT( PERIOD_OF_555_MONOSTABLE(RES_K(270), CAP_U(10)) ) /* 2.97s */
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_NSEC(PERIOD_OF_555_MONOSTABLE_NSEC(RES_K(270), CAP_U(10)))) /* 2.97s */
/* audio hardware */
MDRV_IMPORT_FROM(checkmat_audio)
@@ -1275,7 +1275,7 @@ static MACHINE_DRIVER_START( desertgu )
MDRV_CPU_MODIFY("main")
MDRV_CPU_IO_MAP(desertgu_io_map,0)
MDRV_MACHINE_START(desertgu)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
/* audio hardware */
MDRV_IMPORT_FROM(desertgu_audio)
@@ -1472,7 +1472,7 @@ static MACHINE_DRIVER_START( dplay )
MDRV_IMPORT_FROM(mw8080bw_root)
MDRV_CPU_MODIFY("main")
MDRV_CPU_IO_MAP(dplay_io_map,0)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
/* audio hardware */
MDRV_IMPORT_FROM(dplay_audio)
@@ -1654,7 +1654,7 @@ static MACHINE_DRIVER_START( m4 )
MDRV_CPU_MODIFY("main")
MDRV_CPU_IO_MAP(m4_io_map,0)
MDRV_MACHINE_START(m4)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
/* audio hardware */
MDRV_IMPORT_FROM(m4_audio)
@@ -1828,7 +1828,7 @@ static MACHINE_DRIVER_START( clowns )
MDRV_CPU_MODIFY("main")
MDRV_CPU_IO_MAP(clowns_io_map,0)
MDRV_MACHINE_START(clowns)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
/* audio hardware */
MDRV_IMPORT_FROM(clowns_audio)
@@ -1906,7 +1906,7 @@ static MACHINE_DRIVER_START( shuffle )
MDRV_IMPORT_FROM(mw8080bw_root)
MDRV_CPU_MODIFY("main")
MDRV_CPU_IO_MAP(shuffle_io_map,0)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
/* audio hardware */
/* MDRV_IMPORT_FROM(shuffle_audio) */
@@ -1991,7 +1991,7 @@ static MACHINE_DRIVER_START( dogpatch )
MDRV_CPU_IO_MAP(dogpatch_io_map,0)
/* the watch dog time is unknown, but all other */
/* Midway boards of the era used the same circuit */
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
/* audio hardware */
MDRV_IMPORT_FROM(dogpatch_audio)
@@ -2199,7 +2199,7 @@ static MACHINE_DRIVER_START( spcenctr )
MDRV_CPU_MODIFY("main")
MDRV_CPU_IO_MAP(spcenctr_io_map,0)
MDRV_MACHINE_START(spcenctr)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
/* video hardware */
MDRV_VIDEO_UPDATE(spcenctr)
@@ -2299,7 +2299,7 @@ static MACHINE_DRIVER_START( phantom2 )
MDRV_CPU_MODIFY("main")
MDRV_CPU_IO_MAP(phantom2_io_map,0)
MDRV_MACHINE_START(phantom2)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
/* video hardware */
MDRV_VIDEO_UPDATE(phantom2)
@@ -2435,7 +2435,7 @@ static MACHINE_DRIVER_START( bowler )
MDRV_IMPORT_FROM(mw8080bw_root)
MDRV_CPU_MODIFY("main")
MDRV_CPU_IO_MAP(bowler_io_map,0)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
/* audio hardware */
MDRV_IMPORT_FROM(bowler_audio)
@@ -2657,7 +2657,7 @@ MACHINE_DRIVER_START( invaders )
MDRV_CPU_MODIFY("main")
MDRV_CPU_IO_MAP(invaders_io_map,0)
MDRV_MACHINE_START(invaders)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
/* video hardware */
MDRV_VIDEO_UPDATE(invaders)
@@ -2736,7 +2736,7 @@ static MACHINE_DRIVER_START( blueshrk )
MDRV_IMPORT_FROM(mw8080bw_root)
MDRV_CPU_MODIFY("main")
MDRV_CPU_IO_MAP(blueshrk_io_map,0)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
/* audio hardware */
MDRV_IMPORT_FROM(blueshrk_audio)
@@ -2834,7 +2834,7 @@ static MACHINE_DRIVER_START( invad2ct )
MDRV_IMPORT_FROM(mw8080bw_root)
MDRV_CPU_MODIFY("main")
MDRV_CPU_IO_MAP(invad2ct_io_map,0)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_USEC(255000000 / (MW8080BW_PIXEL_CLOCK / MW8080BW_HTOTAL / MW8080BW_VTOTAL)))
/* audio hardware */
MDRV_IMPORT_FROM(invad2ct_audio)
diff --git a/src/mame/drivers/neogeo.c b/src/mame/drivers/neogeo.c
index 21c9409e9d2..b47cee899ad 100644
--- a/src/mame/drivers/neogeo.c
+++ b/src/mame/drivers/neogeo.c
@@ -1233,7 +1233,7 @@ static MACHINE_DRIVER_START( neogeo )
MDRV_CPU_PROGRAM_MAP(audio_map,0)
MDRV_CPU_IO_MAP(auido_io_map,0)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_USEC(128762))
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_USEC(128762))
MDRV_MACHINE_START(neogeo)
MDRV_MACHINE_RESET(neogeo)
diff --git a/src/mame/drivers/ohmygod.c b/src/mame/drivers/ohmygod.c
index 22828eb2823..55f31678520 100644
--- a/src/mame/drivers/ohmygod.c
+++ b/src/mame/drivers/ohmygod.c
@@ -335,7 +335,7 @@ static MACHINE_DRIVER_START( ohmygod )
MDRV_CPU_VBLANK_INT(irq1_line_hold,1)
MDRV_MACHINE_RESET(ohmygod)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_SEC(3)) /* a guess, and certainly wrong */
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_SEC(3)) /* a guess, and certainly wrong */
/* video hardware */
MDRV_SCREEN_ADD("main", RASTER)
diff --git a/src/mame/drivers/sandscrp.c b/src/mame/drivers/sandscrp.c
index 459c3b62e17..515a206589a 100644
--- a/src/mame/drivers/sandscrp.c
+++ b/src/mame/drivers/sandscrp.c
@@ -441,7 +441,7 @@ static MACHINE_DRIVER_START( sandscrp )
MDRV_CPU_PROGRAM_MAP(sandscrp_soundmem,0)
MDRV_CPU_IO_MAP(sandscrp_soundport,0)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_SEC(3)) /* a guess, and certainly wrong */
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_SEC(3)) /* a guess, and certainly wrong */
MDRV_MACHINE_RESET(sandscrp)
diff --git a/src/mame/drivers/starwars.c b/src/mame/drivers/starwars.c
index fcf75bb4183..0fcb8236e64 100644
--- a/src/mame/drivers/starwars.c
+++ b/src/mame/drivers/starwars.c
@@ -383,7 +383,7 @@ static MACHINE_DRIVER_START( starwars )
MDRV_CPU_ADD(M6809, MASTER_CLOCK / 8)
MDRV_CPU_PROGRAM_MAP(main_map,0)
MDRV_CPU_PERIODIC_INT(irq0_line_assert, (double)MASTER_CLOCK / 4096 / 12)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_HZ(CLOCK_3KHZ / 128))
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_HZ(CLOCK_3KHZ / 128))
MDRV_CPU_ADD(M6809, MASTER_CLOCK / 8)
/* audio CPU */
diff --git a/src/mame/drivers/tempest.c b/src/mame/drivers/tempest.c
index 6509f828b96..5865d2a9a3a 100644
--- a/src/mame/drivers/tempest.c
+++ b/src/mame/drivers/tempest.c
@@ -585,7 +585,7 @@ static MACHINE_DRIVER_START( tempest )
MDRV_CPU_ADD(M6502, MASTER_CLOCK / 8)
MDRV_CPU_PROGRAM_MAP(main_map, 0)
MDRV_CPU_PERIODIC_INT(irq0_line_assert, (double)MASTER_CLOCK / 4096 / 12)
- MDRV_WATCHDOG_TIME_INIT(ATTOTIME_IN_HZ(CLOCK_3KHZ / 256))
+ MDRV_WATCHDOG_TIME_INIT(UINT64_ATTOTIME_IN_HZ(CLOCK_3KHZ / 256))
MDRV_NVRAM_HANDLER(atari_vg)
/* video hardware */
diff --git a/src/mame/drivers/tmnt.c b/src/mame/drivers/tmnt.c
index 89fa453bbae..05d5c050173 100644
--- a/src/mame/drivers/tmnt.c
+++ b/src/mame/drivers/tmnt.c
@@ -2413,7 +2413,7 @@ static MACHINE_DRIVER_START( tmnt )
MDRV_CPU_ADD(Z80, XTAL_3_579545MHz)
MDRV_CPU_PROGRAM_MAP(tmnt_audio_map,0)
- MDRV_MACHINE_RESET(tmnt);
+ MDRV_MACHINE_RESET(tmnt)
/* video hardware */
MDRV_VIDEO_ATTRIBUTES(VIDEO_HAS_SHADOWS | VIDEO_HAS_HIGHLIGHTS)
diff --git a/src/mame/machine/pcshare.c b/src/mame/machine/pcshare.c
index f5468285617..8694a102c64 100644
--- a/src/mame/machine/pcshare.c
+++ b/src/mame/machine/pcshare.c
@@ -525,14 +525,12 @@ static TIMER_CALLBACK( pc_keyb_timer )
void pc_keyb_set_clock(int on)
{
- attotime keyb_delay = STATIC_ATTOTIME_IN_MSEC(5);
-
on = on ? 1 : 0;
if (pc_keyb.on != on)
{
if (on)
- timer_adjust_oneshot(pc_keyboard_timer, keyb_delay, 0);
+ timer_adjust_oneshot(pc_keyboard_timer, ATTOTIME_IN_MSEC(5), 0);
else
timer_reset(pc_keyboard_timer, attotime_never);