RendererPlplot::RendererPlplot(const char *device, const char *filename,
unsigned int width, unsigned int height,
const Rgb &bg)
: _user_pls(false),
_palette(),
_palette_size(16)
{
_2d_output_res = math::Vector2(width, height);
_pls = new plstream();
// colors init
_styles_color[StyleBackground] = bg;
_styles_color[StyleForeground] = ~bg;
_pls->scolbg((int)(bg.r * 255), (int)(bg.g * 255), (int)(bg.b * 255));
_palette[bg] = 0;
palette_init();
// backend init
_pls->sdev(device);
_pls->spage(0.0, 0.0, (PLINT)_2d_output_res.x(), (PLINT)_2d_output_res.y(), 0, 0);
_pls->sfnam(filename);
_pls->star(1, 1);
_pls->adv(0);
}
/***********************************************************************
* USER initialisation routine
*/
static BOOL process_attach(void)
{
HINSTANCE16 instance;
/* Create USER heap */
if ((instance = LoadLibrary16( "USER.EXE" )) >= 32) USER_HeapSel = instance | 7;
else
{
USER_HeapSel = GlobalAlloc16( GMEM_FIXED, 65536 );
LocalInit16( USER_HeapSel, 32, 65534 );
}
/* some Win9x dlls expect keyboard to be loaded */
if (GetVersion() & 0x80000000) LoadLibrary16( "keyboard.drv" );
winstation_init();
/* Initialize system colors and metrics */
SYSPARAMS_Init();
/* Setup palette function pointers */
palette_init();
/* Initialize built-in window classes */
CLASS_RegisterBuiltinClasses();
/* Initialize message spying */
if (!SPY_Init()) return FALSE;
return TRUE;
}
sega_16bit_common_base::sega_16bit_common_base(const machine_config &mconfig, device_type type, const char *tag)
: driver_device(mconfig, type, tag),
m_paletteram(*this, "paletteram"),
m_open_bus_recurse(false),
m_palette_entries(0)
{
palette_init();
}
/***********************************************************************
* USER initialisation routine
*/
static BOOL process_attach(void)
{
winstation_init();
/* Initialize system colors and metrics */
SYSPARAMS_Init();
/* Setup palette function pointers */
palette_init();
return TRUE;
}
int init_main(void)
{
signals_init(debug.do_core_dumps);
romset_init();
if (!video_disabled_mode) {
palette_init();
}
if (machine_class != VICE_MACHINE_VSID) {
gfxoutput_init();
screenshot_init();
drivecpu_early_init_all();
}
machine_bus_init();
machine_maincpu_init();
event_init();
/* Machine-specific initialization. */
if (machine_init() < 0) {
log_error(LOG_DEFAULT, "Machine initialization failed.");
return -1;
}
/* FIXME: what's about uimon_init??? */
/* the monitor console MUST be available, because of for example cpujam,
or -initbreak from cmdline.
*/
if (console_init() < 0) {
log_error(LOG_DEFAULT, "Console initialization failed.");
return -1;
}
keyboard_init();
if (!video_disabled_mode) {
joystick_init();
}
if (machine_class != VICE_MACHINE_VSID) {
disk_image_init();
vdrive_init();
}
ui_init_finalize();
return 0;
}
void
fe_init (void)
{
GConfClient *client;
client = gconf_client_get_default ();
gconf_client_add_dir (client, "/apps/xchat", GCONF_CLIENT_PRELOAD_NONE, NULL);
g_object_unref (client);
u = userlist_new ();
gui.quit = FALSE;
palette_init ();
run_migrations ();
initialize_gui_1 ();
if (!preferences_exist ()) {
run_setup_dialog ();
} else {
set_version ();
}
servlist_init ();
initialize_gui_2 ();
load_preferences ();
run_main_window (opt_fullscreen);
/* Force various window-related options to match our interaction model */
prefs.use_server_tab = TRUE;
prefs.notices_tabs = FALSE;
prefs.servernotice = TRUE;
prefs.slist_skip = FALSE;
/* If we don't have a specific DCC IP address, force get-from-server */
if (strlen (prefs.dcc_ip_str) == 0) {
prefs.ip_from_server = TRUE;
}
/* Don't allow the core to autoload plugins. We use our own
* method for autoloading.
*/
arg_skip_plugins = 1;
if (not_autoconnect ()) {
ConnectDialog *cd;
cd = connect_dialog_new ();
gtk_widget_show_all (GTK_WIDGET (cd));
}
#ifdef USE_PLUGIN
plugins_initialize ();
#endif
}
int init_main(void)
{
//signals_init(debug.do_core_dumps);
romset_init();
if (!video_disabled_mode) {
palette_init();
}
if (!vsid_mode) {
gfxoutput_init();
//screenshot_init();
drivecpu_early_init_all();
}
machine_bus_init();
machine_maincpu_init();
event_init();
/* Machine-specific initialization. */
if (machine_init() < 0) {
//log_error(LOG_DEFAULT, "Machine initialization failed.");
return -1;
}
/* FIXME: what's about uimon_init??? */
if (!vsid_mode && console_init() < 0) {
//log_error(LOG_DEFAULT, "Console initialization failed.");
return -1;
}
keyboard_init();
if (!video_disabled_mode) {
joystick_init();
}
if (!vsid_mode) {
disk_image_init();
vdrive_init();
}
ui_init_finalize();
return 0;
}
RendererPlplot::RendererPlplot(plstream *pls)
: _pls(pls),
_user_pls(true),
_palette(),
_palette_size(16)
{
PLINT width, height, i;
PLFLT f;
_pls->gpage(f, f, width, height, i, i);
_2d_output_res = math::Vector2(width, height);
// FIXME init _styles_color[StyleBackground] and [StyleForeground] using gcolbg
palette_init();
}
void driver_device::device_start()
{
// bind our legacy callbacks
for (int index = 0; index < ARRAY_LENGTH(m_legacy_callbacks); index++)
if (m_legacy_callbacks[index] != NULL)
m_callbacks[index] = driver_callback_delegate(m_legacy_callbacks[index], "legacy_callback", &machine());
// reschedule ourselves to be last
device_iterator iter(*this);
for (device_t *test = iter.first(); test != NULL; test = iter.next())
if (test != this && !test->started())
throw device_missing_dependencies();
// call the game-specific init
if (m_system->driver_init != NULL)
(*m_system->driver_init)(machine());
// finish image devices init process
image_postdevice_init(machine());
// call palette_init if present
if (!m_callbacks[CB_PALETTE_INIT].isnull())
m_callbacks[CB_PALETTE_INIT]();
else
palette_init();
// start the various pieces
driver_start();
if (!m_callbacks[CB_MACHINE_START].isnull())
m_callbacks[CB_MACHINE_START]();
else
machine_start();
if (!m_callbacks[CB_SOUND_START].isnull())
m_callbacks[CB_SOUND_START]();
else
sound_start();
if (!m_callbacks[CB_VIDEO_START].isnull())
m_callbacks[CB_VIDEO_START]();
else
video_start();
// save generic states
save_item(NAME(m_flip_screen_x));
save_item(NAME(m_flip_screen_y));
}
/***********************************************************************
* USER initialisation routine
*/
static BOOL process_attach(void)
{
winstation_init();
/* Initialize system colors and metrics */
SYSPARAMS_Init();
/* Setup palette function pointers */
palette_init();
/* Initialize built-in window classes */
CLASS_RegisterBuiltinClasses();
/* Initialize message spying */
if (!SPY_Init()) return FALSE;
return TRUE;
}
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
}
void running_machine::start()
{
// initialize basic can't-fail systems here
config_init(*this);
m_input = auto_alloc(*this, input_manager(*this));
output_init(*this);
palette_init(*this);
m_render = auto_alloc(*this, render_manager(*this));
generic_machine_init(*this);
generic_sound_init(*this);
// allocate a soft_reset timer
m_soft_reset_timer = m_scheduler.timer_alloc(timer_expired_delegate(FUNC(running_machine::soft_reset), this));
// init the osd layer
m_osd.init(*this);
// create the video manager
m_video = auto_alloc(*this, video_manager(*this));
ui_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);
if (newbase != 0)
m_base_time = newbase;
// intialize UI input
ui_input_init(*this);
// initialize the streams engine before the sound devices start
m_sound = auto_alloc(*this, sound_manager(*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);
// must happen after memory_init because this relies on generic.spriteram
generic_video_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);
tilemap_init(*this);
crosshair_init(*this);
// initialize the debugger
if ((debug_flags & DEBUG_FLAG_ENABLED) != 0)
debugger_init(*this);
// 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);
// start up the devices
const_cast<device_list &>(devicelist()).start_all();
// if we're coming in with a savegame request, process it now
const char *savegame = options().state();
if (savegame[0] != 0)
schedule_load(savegame);
// if we're in autosave mode, schedule a load
else if (options().autosave() && (m_system.flags & GAME_SUPPORTS_SAVE) != 0)
schedule_load("auto");
// set up the cheat engine
m_cheat = auto_alloc(*this, cheat_manager(*this));
// disallow save state registrations starting here
m_save.allow_registration(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);
/* 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);
}
int video_init(void)
{
osd_create_params params;
artwork_callbacks *artcallbacks;
int bmwidth = Machine->drv->screen_width;
int bmheight = Machine->drv->screen_height;
movie_file = NULL;
movie_frame = 0;
add_pause_callback(video_pause);
add_exit_callback(video_exit);
/* first allocate the necessary palette structures */
if (palette_start())
return 1;
#ifndef NEW_RENDER
/* if we're a vector game, override the screen width and height */
if (Machine->drv->video_attributes & VIDEO_TYPE_VECTOR)
scale_vectorgames(options.vector_width, options.vector_height, &bmwidth, &bmheight);
/* compute the visible area for raster games */
if (!(Machine->drv->video_attributes & VIDEO_TYPE_VECTOR))
{
params.width = Machine->drv->default_visible_area.max_x - Machine->drv->default_visible_area.min_x + 1;
params.height = Machine->drv->default_visible_area.max_y - Machine->drv->default_visible_area.min_y + 1;
}
else
{
params.width = bmwidth;
params.height = bmheight;
}
/* fill in the rest of the display parameters */
compute_aspect_ratio(Machine->drv, ¶ms.aspect_x, ¶ms.aspect_y);
params.depth = Machine->color_depth;
params.colors = palette_get_total_colors_with_ui();
params.fps = Machine->drv->frames_per_second;
params.video_attributes = Machine->drv->video_attributes;
#ifdef MESS
artcallbacks = &mess_artwork_callbacks;
#else
artcallbacks = &mame_artwork_callbacks;
#endif
/* initialize the display through the artwork (and eventually the OSD) layer */
if (artwork_create_display(¶ms, direct_rgb_components, artcallbacks))
return 1;
/* the create display process may update the vector width/height, so recompute */
if (Machine->drv->video_attributes & VIDEO_TYPE_VECTOR)
scale_vectorgames(options.vector_width, options.vector_height, &bmwidth, &bmheight);
/* now allocate the screen bitmap */
scrbitmap[0] = auto_bitmap_alloc_depth(bmwidth, bmheight, Machine->color_depth);
if (!scrbitmap[0])
return 1;
#endif
/* set the default refresh rate */
set_refresh_rate(Machine->drv->frames_per_second);
/* set the default visible area */
set_visible_area(0,1,0,1); // make sure everything is recalculated on multiple runs
set_visible_area(
Machine->drv->default_visible_area.min_x,
Machine->drv->default_visible_area.max_x,
Machine->drv->default_visible_area.min_y,
Machine->drv->default_visible_area.max_y);
/* create spriteram buffers if necessary */
if (Machine->drv->video_attributes & VIDEO_BUFFERS_SPRITERAM)
if (init_buffered_spriteram())
return 1;
#ifndef NEW_RENDER
#if defined(MAME_DEBUG) && !defined(NEW_DEBUGGER)
/* if the debugger is enabled, initialize its bitmap and font */
if (Machine->debug_mode)
{
int depth = options.debug_depth ? options.debug_depth : Machine->color_depth;
/* first allocate the debugger bitmap */
Machine->debug_bitmap = auto_bitmap_alloc_depth(options.debug_width, options.debug_height, depth);
if (!Machine->debug_bitmap)
return 1;
/* then create the debugger font */
Machine->debugger_font = build_debugger_font();
if (Machine->debugger_font == NULL)
return 1;
}
#endif
#endif
/* convert the gfx ROMs into character sets. This is done BEFORE calling the driver's */
/* palette_init() routine because it might need to check the Machine->gfx[] data */
if (Machine->drv->gfxdecodeinfo)
if (allocate_graphics(Machine->drv->gfxdecodeinfo))
return 1;
/* initialize the palette - must be done after osd_create_display() */
if (palette_init())
return 1;
/* force the first update to be full */
set_vh_global_attribute(NULL, 0);
/* actually decode the graphics */
if (Machine->drv->gfxdecodeinfo)
decode_graphics(Machine->drv->gfxdecodeinfo);
/* reset performance data */
last_fps_time = osd_cycles();
rendered_frames_since_last_fps = frames_since_last_fps = 0;
performance.game_speed_percent = 100;
performance.frames_per_second = Machine->refresh_rate;
performance.vector_updates_last_second = 0;
/* reset video statics and get out of here */
pdrawgfx_shadow_lowpri = 0;
leds_status = 0;
/* initialize tilemaps */
if (tilemap_init() != 0)
fatalerror("tilemap_init failed");
return 0;
}
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);
}
void running_machine::start()
{
// initialize basic can't-fail systems here
config_init(*this);
m_input = auto_alloc(*this, input_manager(*this));
output_init(*this);
palette_init(*this);
m_render = auto_alloc(*this, render_manager(*this));
generic_machine_init(*this);
// allocate a soft_reset timer
m_soft_reset_timer = m_scheduler.timer_alloc(timer_expired_delegate(FUNC(running_machine::soft_reset), this));
// init the osd layer
m_osd.init(*this);
// create the video manager
m_video = auto_alloc(*this, video_manager(*this));
ui_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 = m_ioport.initialize();
if (newbase != 0)
m_base_time = newbase;
// intialize UI input
ui_input_init(*this);
// initialize the streams engine before the sound devices start
m_sound = auto_alloc(*this, sound_manager(*this));
// first load ROMs, then populate memory, and finally initialize CPUs
// these operations must proceed in this order
rom_init(*this);
m_memory.initialize();
// initialize the watchdog
m_watchdog_timer = m_scheduler.timer_alloc(timer_expired_delegate(FUNC(running_machine::watchdog_fired), this));
if (config().m_watchdog_vblank_count != 0 && primary_screen != NULL)
primary_screen->register_vblank_callback(vblank_state_delegate(FUNC(running_machine::watchdog_vblank), this));
save().save_item(NAME(m_watchdog_enabled));
save().save_item(NAME(m_watchdog_counter));
// allocate the gfx elements prior to device initialization
gfx_init(*this);
// initialize image devices
image_init(*this);
m_tilemap = auto_alloc(*this, tilemap_manager(*this));
crosshair_init(*this);
network_init(*this);
// initialize the debugger
if ((debug_flags & DEBUG_FLAG_ENABLED) != 0)
debugger_init(*this);
// 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);
// register callbacks for the devices, then start them
add_notifier(MACHINE_NOTIFY_RESET, machine_notify_delegate(FUNC(running_machine::reset_all_devices), this));
add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(running_machine::stop_all_devices), this));
save().register_presave(save_prepost_delegate(FUNC(running_machine::presave_all_devices), this));
start_all_devices();
save().register_postload(save_prepost_delegate(FUNC(running_machine::postload_all_devices), this));
// if we're coming in with a savegame request, process it now
const char *savegame = options().state();
if (savegame[0] != 0)
schedule_load(savegame);
// if we're in autosave mode, schedule a load
else if (options().autosave() && (m_system.flags & GAME_SUPPORTS_SAVE) != 0)
schedule_load("auto");
// set up the cheat engine
m_cheat = auto_alloc(*this, cheat_manager(*this));
// allocate autoboot timer
m_autoboot_timer = scheduler().timer_alloc(timer_expired_delegate(FUNC(running_machine::autoboot_callback), this));
// initialize lua
m_lua_engine.initialize();
// disallow save state registrations starting here
m_save.allow_registration(false);
}
static int vh_open(void)
{
int i;
int width,height;
for (i = 0;i < MAX_GFX_ELEMENTS;i++) Machine->gfx[i] = 0;
Machine->uifont = 0;
if (palette_start() != 0)
{
vh_close();
return 1;
}
/* convert the gfx ROMs into character sets. This is done BEFORE calling the driver's */
/* convert_color_prom() routine (in palette_init()) because it might need to check the */
/* Machine->gfx[] data */
if (drv->gfxdecodeinfo)
{
for (i = 0;i < MAX_GFX_ELEMENTS && drv->gfxdecodeinfo[i].memory_region != -1;i++)
{
int reglen = 8*memory_region_length(drv->gfxdecodeinfo[i].memory_region);
struct GfxLayout glcopy;
int j;
memcpy(&glcopy,drv->gfxdecodeinfo[i].gfxlayout,sizeof(glcopy));
if (IS_FRAC(glcopy.total))
glcopy.total = reglen / glcopy.charincrement * FRAC_NUM(glcopy.total) / FRAC_DEN(glcopy.total);
for (j = 0;j < MAX_GFX_PLANES;j++)
{
if (IS_FRAC(glcopy.planeoffset[j]))
{
glcopy.planeoffset[j] = FRAC_OFFSET(glcopy.planeoffset[j]) +
reglen * FRAC_NUM(glcopy.planeoffset[j]) / FRAC_DEN(glcopy.planeoffset[j]);
}
}
for (j = 0;j < MAX_GFX_SIZE;j++)
{
if (IS_FRAC(glcopy.xoffset[j]))
{
glcopy.xoffset[j] = FRAC_OFFSET(glcopy.xoffset[j]) +
reglen * FRAC_NUM(glcopy.xoffset[j]) / FRAC_DEN(glcopy.xoffset[j]);
}
if (IS_FRAC(glcopy.yoffset[j]))
{
glcopy.yoffset[j] = FRAC_OFFSET(glcopy.yoffset[j]) +
reglen * FRAC_NUM(glcopy.yoffset[j]) / FRAC_DEN(glcopy.yoffset[j]);
}
}
if ((Machine->gfx[i] = decodegfx(memory_region(drv->gfxdecodeinfo[i].memory_region)
+ drv->gfxdecodeinfo[i].start,
&glcopy)) == 0)
{
vh_close();
bailing = 1;
printf("Out of memory decoding gfx\n");
return 1;
}
if (Machine->remapped_colortable)
Machine->gfx[i]->colortable = &Machine->remapped_colortable[drv->gfxdecodeinfo[i].color_codes_start];
Machine->gfx[i]->total_colors = drv->gfxdecodeinfo[i].total_color_codes;
}
}
width = drv->screen_width;
height = drv->screen_height;
if (Machine->drv->video_attributes & VIDEO_TYPE_VECTOR)
scale_vectorgames(options.vector_width,options.vector_height,&width,&height);
Machine->scrbitmap = bitmap_alloc_depth(width,height,Machine->color_depth);
if (!Machine->scrbitmap)
{
vh_close();
return 1;
}
if (!(Machine->drv->video_attributes & VIDEO_TYPE_VECTOR))
{
width = drv->default_visible_area.max_x - drv->default_visible_area.min_x + 1;
height = drv->default_visible_area.max_y - drv->default_visible_area.min_y + 1;
}
if (Machine->orientation & ORIENTATION_SWAP_XY)
{
int temp;
temp = width; width = height; height = temp;
}
/* create the display bitmap, and allocate the palette */
if (osd_create_display(width,height,Machine->color_depth,
drv->frames_per_second,drv->video_attributes,Machine->orientation))
{
vh_close();
return 1;
}
set_visible_area(
drv->default_visible_area.min_x,
drv->default_visible_area.max_x,
drv->default_visible_area.min_y,
drv->default_visible_area.max_y);
/* create spriteram buffers if necessary */
if (drv->video_attributes & VIDEO_BUFFERS_SPRITERAM) {
if (spriteram_size!=0) {
buffered_spriteram= (unsigned char *) malloc(spriteram_size);
if (!buffered_spriteram) { vh_close(); return 1; }
if (spriteram_2_size!=0) buffered_spriteram_2 = (unsigned char *) malloc(spriteram_2_size);
if (spriteram_2_size && !buffered_spriteram_2) { vh_close(); return 1; }
} else {
logerror("vh_open(): Video buffers spriteram but spriteram_size is 0\n");
buffered_spriteram=NULL;
buffered_spriteram_2=NULL;
}
}
/* build our private user interface font */
/* This must be done AFTER osd_create_display() so the function knows the */
/* resolution we are running at and can pick a different font depending on it. */
/* It must be done BEFORE palette_init() because that will also initialize */
/* (through osd_allocate_colors()) the uifont colortable. */
if ((Machine->uifont = builduifont()) == 0)
{
vh_close();
return 1;
}
/* initialize the palette - must be done after osd_create_display() */
if (palette_init())
{
vh_close();
return 1;
}
return 0;
}
void lcd_init(void)
{
/* 1. 设置相关GPIO引脚用于LCD */
GPICON = 0xaaaaaaaa; /* gpi0~gpi15用作lcd_vd[0~15] */
GPJCON = 0xaaaaaaa; /* gpj0~gpi11用作lcd */
//GPFCON &= ~(0x3<<28);
//GPFCON |= (1<<28); /* GPF14用作背光使能信号 */
GPECON &= ~(0xf);
GPECON |= (0x1); /* GPE0用作LCD的on/off信号 */
/* 2. 初始化6410的display controller
* 2.1 hsync,vsync,vclk,vden的极性和时间参数
* 2.2 行数、列数(分辨率),象素颜色的格式
* 2.3 分配显存(frame buffer),写入display controller
*/
MIFPCON &= ~(1<<3); /* Normal mode */
SPCON &= ~(0x3);
SPCON |= 0x1; /* RGB I/F style */
#if 0
VIDCON0 &= ~((3<<26) | (3<<17) | (0xff<<6)); /* RGB I/F, RGB Parallel format, */
VIDCON0 |= ((2<<6) | (1<<4) | (0x3<<2)); /* vclk== 27MHz Ext Clock input / (CLKVAL+1) = 27/3 = 9MHz */
#else
VIDCON0 &= ~((3<<26) | (3<<17) | (0xff<<6) | (3<<2)); /* RGB I/F, RGB Parallel format, */
VIDCON0 |= ((14<<6) | (1<<4) ); /* vclk== HCLK / (CLKVAL+1) = 133/15 = 9MHz */
#endif
VIDCON1 &= ~(1<<7); /* 在vclk的下降沿获取数据 */
VIDCON1 |= ((1<<6) | (1<<5)); /* HSYNC高电平有效, VSYNC高电平有效, */
VIDTCON0 = (VBPD << 16) | (VFPD << 8) | (VSPW << 0);
VIDTCON1 = (HBPD << 16) | (HFPD << 8) | (HSPW << 0);
VIDTCON2 = (LINEVAL << 11) | (HOZVAL << 0);
WINCON0 &= ~(0xf << 2);
WINCON0 |= (0x3<<2) | (1<<17); /* 8 BPP (palletized), byte swap */
VIDOSD0A = (LeftTopX<<11) | (LeftTopY << 0);
VIDOSD0B = (RightBotX<<11) | (RightBotY << 0);
VIDOSD0C = (LINEVAL + 1) * (HOZVAL + 1) / 4;
VIDW00ADD0B0 = FRAME_BUFFER;
VIDW00ADD1B0 = (((HOZVAL + 1)*1 + 0) * (LINEVAL + 1)) & (0xffffff);
/* VBASEL = VBASEU + (LINEWIDTH+OFFSIZE) x (LINEVAL+1)
* = 0 + (480*1 + 0) * 272
* =
*/
//VIDW00ADD2 = HOZVAL + 1;
/* 设置调色板 */
palette_init();
pwm_set(2);
fb_base_addr = FRAME_BUFFER;
xsize = HOZVAL + 1;
ysize = LINEVAL + 1;
bpp = 8;
clean_screem();
}
