static void soft_reset(int param)
{
running_machine *machine = Machine;
mame_private *mame = machine->mame_data;
callback_item *cb;
logerror("Soft reset\n");
/* temporarily in the reset phase */
mame->current_phase = MAME_PHASE_RESET;
/* a bit gross -- back off of the resource tracking, and put it back at the end */
assert(get_resource_tag() == 2);
end_resource_tracking();
begin_resource_tracking();
/* allow save state registrations during the reset */
state_save_allow_registration(TRUE);
/* unfortunately, we can't rely on callbacks to reset the interrupt */
/* structures, as these need to happen before we call the reset */
/* functions registered by the drivers */
cpuint_reset();
/* run the driver's reset callbacks */
if (machine->drv->machine_reset != NULL)
(*machine->drv->machine_reset)(machine);
if (machine->drv->sound_reset != NULL)
(*machine->drv->sound_reset)(machine);
if (machine->drv->video_reset != NULL)
(*machine->drv->video_reset)(machine);
/* call all registered reset callbacks */
for (cb = machine->mame_data->reset_callback_list; cb; cb = cb->next)
(*cb->func.reset)(machine);
/* disallow save state registrations starting here */
state_save_allow_registration(FALSE);
/* now we're running */
mame->current_phase = MAME_PHASE_RUNNING;
/* set the global time to the current time */
/* this allows 0-time queued callbacks to run before any CPUs execute */
mame_timer_set_global_time(mame_timer_get_time());
}
void running_machine::start()
{
/* initialize basic can't-fail systems here */
fileio_init(this);
config_init(this);
input_init(this);
output_init(this);
state_init(this);
state_save_allow_registration(this, true);
palette_init(this);
render_init(this);
ui_init(this);
generic_machine_init(this);
generic_video_init(this);
generic_sound_init(this);
/* initialize the timers and allocate a soft_reset timer
this must be done before cpu_init so that CPU's can allocate timers */
timer_init(this);
m_soft_reset_timer = timer_alloc(this, static_soft_reset, NULL);
/* init the osd layer */
osd_init(this);
/* initialize the base time (needed for doing record/playback) */
time(&m_base_time);
/* initialize the input system and input ports for the game
this must be done before memory_init in order to allow specifying
callbacks based on input port tags */
time_t newbase = input_port_init(this, m_game.ipt);
if (newbase != 0)
m_base_time = newbase;
/* intialize UI input */
ui_input_init(this);
/* initialize the streams engine before the sound devices start */
streams_init(this);
/* first load ROMs, then populate memory, and finally initialize CPUs
these operations must proceed in this order */
rom_init(this);
memory_init(this);
watchdog_init(this);
/* allocate the gfx elements prior to device initialization */
gfx_init(this);
/* initialize natural keyboard support */
inputx_init(this);
/* initialize image devices */
image_init(this);
/* start up the devices */
m_devicelist.start_all();
/* call the game driver's init function
this is where decryption is done and memory maps are altered
so this location in the init order is important */
ui_set_startup_text(this, "Initializing...", true);
if (m_game.driver_init != NULL)
(*m_game.driver_init)(this);
/* finish image devices init process */
image_postdevice_init(this);
/* start the video and audio hardware */
video_init(this);
tilemap_init(this);
crosshair_init(this);
sound_init(this);
/* initialize the debugger */
if ((debug_flags & DEBUG_FLAG_ENABLED) != 0)
debugger_init(this);
/* call the driver's _START callbacks */
if (m_config.m_machine_start != NULL)
(*m_config.m_machine_start)(this);
if (m_config.m_sound_start != NULL)
(*m_config.m_sound_start)(this);
if (m_config.m_video_start != NULL)
(*m_config.m_video_start)(this);
/* set up the cheat engine */
cheat_init(this);
/* set up the hiscore engine */
hiscore_init(this);
/* disallow save state registrations starting here */
state_save_allow_registration(this, false);
}
void running_machine::start()
{
// initialize basic can't-fail systems here
fileio_init(this);
config_init(this);
input_init(this);
output_init(this);
state_init(this);
state_save_allow_registration(this, true);
palette_init(this);
render_init(this);
ui_init(this);
generic_machine_init(this);
generic_video_init(this);
generic_sound_init(this);
// initialize the timers and allocate a soft_reset timer
// this must be done before cpu_init so that CPU's can allocate timers
timer_init(this);
m_soft_reset_timer = timer_alloc(this, static_soft_reset, NULL);
// init the osd layer
osd_init(this);
// initialize the base time (needed for doing record/playback)
time(&m_base_time);
// initialize the input system and input ports for the game
// this must be done before memory_init in order to allow specifying
// callbacks based on input port tags
time_t newbase = input_port_init(this, m_game.ipt);
if (newbase != 0)
m_base_time = newbase;
// intialize UI input
ui_input_init(this);
// initialize the streams engine before the sound devices start
streams_init(this);
// first load ROMs, then populate memory, and finally initialize CPUs
// these operations must proceed in this order
rom_init(this);
memory_init(this);
watchdog_init(this);
// allocate the gfx elements prior to device initialization
gfx_init(this);
// initialize natural keyboard support
inputx_init(this);
// initialize image devices
image_init(this);
// start up the devices
m_devicelist.start_all();
// call the game driver's init function
// this is where decryption is done and memory maps are altered
// so this location in the init order is important
ui_set_startup_text(this, "Initializing...", true);
if (m_game.driver_init != NULL)
(*m_game.driver_init)(this);
// finish image devices init process
image_postdevice_init(this);
// start the video and audio hardware
video_init(this);
tilemap_init(this);
crosshair_init(this);
sound_init(this);
// initialize the debugger
if ((debug_flags & DEBUG_FLAG_ENABLED) != 0)
debugger_init(this);
// call the driver's _START callbacks
if (m_config.m_machine_start != NULL)
(*m_config.m_machine_start)(this);
if (m_config.m_sound_start != NULL)
(*m_config.m_sound_start)(this);
if (m_config.m_video_start != NULL)
(*m_config.m_video_start)(this);
// if we're coming in with a savegame request, process it now
const char *savegame = options_get_string(&m_options, OPTION_STATE);
if (savegame[0] != 0)
schedule_load(savegame);
// if we're in autosave mode, schedule a load
else if (options_get_bool(&m_options, OPTION_AUTOSAVE) && (m_game.flags & GAME_SUPPORTS_SAVE) != 0)
schedule_load("auto");
// set up the cheat engine
if (options_get_bool(&m_options, OPTION_CHEAT))
cheat_init(this);
// disallow save state registrations starting here
state_save_allow_registration(this, false);
}
static void init_machine(running_machine *machine)
{
mame_private *mame = machine->mame_data;
int num;
/* initialize basic can't-fail systems here */
cpuintrf_init(machine);
sndintrf_init(machine);
fileio_init(machine);
config_init(machine);
output_init(machine);
state_init(machine);
state_save_allow_registration(TRUE);
drawgfx_init(machine);
palette_init(machine);
render_init(machine);
ui_init(machine);
generic_machine_init(machine);
generic_video_init(machine);
mame->rand_seed = 0x9d14abd7;
/* initialize the base time (if not doing record/playback) */
if (!Machine->record_file && !Machine->playback_file)
time(&mame->base_time);
else
mame->base_time = 0;
/* init the osd layer */
if (osd_init(machine) != 0)
fatalerror("osd_init failed");
/* initialize the input system */
/* this must be done before the input ports are initialized */
if (code_init(machine) != 0)
fatalerror("code_init failed");
/* initialize the input ports for the game */
/* this must be done before memory_init in order to allow specifying */
/* callbacks based on input port tags */
if (input_port_init(machine, machine->gamedrv->ipt) != 0)
fatalerror("input_port_init failed");
/* load the ROMs if we have some */
/* this must be done before memory_init in order to allocate memory regions */
rom_init(machine, machine->gamedrv->rom);
/* initialize the timers and allocate a soft_reset timer */
/* this must be done before cpu_init so that CPU's can allocate timers */
timer_init(machine);
mame->soft_reset_timer = timer_alloc(soft_reset);
/* initialize the memory system for this game */
/* this must be done before cpu_init so that set_context can look up the opcode base */
if (memory_init(machine) != 0)
fatalerror("memory_init failed");
/* now set up all the CPUs */
if (cpuexec_init(machine) != 0)
fatalerror("cpuexec_init failed");
if (cpuint_init(machine) != 0)
fatalerror("cpuint_init failed");
#ifdef MESS
/* initialize the devices */
devices_init(machine);
#endif
/* start the save/load system */
saveload_init(machine);
/* call the game driver's init function */
/* this is where decryption is done and memory maps are altered */
/* so this location in the init order is important */
ui_set_startup_text("Initializing...", TRUE);
if (machine->gamedrv->driver_init != NULL)
(*machine->gamedrv->driver_init)(machine);
/* start the audio system */
if (sound_init(machine) != 0)
fatalerror("sound_init failed");
/* start the video hardware */
if (video_init(machine) != 0)
fatalerror("video_init failed");
/* start the cheat engine */
if (options.cheat)
cheat_init(machine);
/* call the driver's _START callbacks */
if (machine->drv->machine_start != NULL && (*machine->drv->machine_start)(machine) != 0)
fatalerror("Unable to start machine emulation");
if (machine->drv->sound_start != NULL && (*machine->drv->sound_start)(machine) != 0)
fatalerror("Unable to start sound emulation");
if (machine->drv->video_start != NULL && (*machine->drv->video_start)(machine) != 0)
fatalerror("Unable to start video emulation");
/* free memory regions allocated with REGIONFLAG_DISPOSE (typically gfx roms) */
for (num = 0; num < MAX_MEMORY_REGIONS; num++)
if (mame->mem_region[num].flags & ROMREGION_DISPOSE)
free_memory_region(machine, num);
#ifdef MAME_DEBUG
/* initialize the debugger */
if (machine->debug_mode)
mame_debug_init(machine);
#endif
}
