void favorite_manager::apply_running_machine(running_machine &machine, T &&action)
{
bool done(false);
// TODO: this should be changed - it interacts poorly with cartslots on arcade systems
if ((machine.system().flags & machine_flags::MASK_TYPE) == machine_flags::TYPE_ARCADE)
{
action(machine.system(), nullptr, nullptr, done);
}
else
{
bool have_software(false);
for (device_image_interface &image_dev : image_interface_iterator(machine.root_device()))
{
software_info const *const sw(image_dev.software_entry());
if (image_dev.exists() && image_dev.loaded_through_softlist() && sw)
{
assert(image_dev.software_list_name());
have_software = true;
action(machine.system(), &image_dev, sw, done);
if (done)
return;
}
}
if (!have_software)
action(machine.system(), nullptr, nullptr, done);
}
}
void mini_osd_interface::init(running_machine &machine)
{
int gamRot=0;
osd_interface::init(machine);
our_target = machine.render().target_alloc();
initInput(machine);
write_log("machine screen orientation: %s \n", (
machine.system().flags & ORIENTATION_SWAP_XY) ? "VERTICAL" : "HORIZONTAL"
);
orient = (machine.system().flags & ORIENTATION_MASK);
vertical = (machine.system().flags & ORIENTATION_SWAP_XY);
gamRot = (ROT270 == orient) ? 1 : gamRot;
gamRot = (ROT180 == orient) ? 2 : gamRot;
gamRot = (ROT90 == orient) ? 3 : gamRot;
//prep_retro_rotation(gamRot);
our_target->compute_minimum_size(rtwi, rthe);
topw=rtwi;
//Equivalent to rtaspect=our_target->view_by_index((our_target->view()))->effective_aspect(render_layer_config layer_config())
int width,height;
our_target->compute_visible_area(1000,1000,1,ROT0,width,height);
rtaspect=(float)width/(float)height;
write_log("W:%d H:%d , aspect ratio %d/%d=%f\n",rtwi,rthe,width,height,rtaspect);
NEWGAME_FROM_OSD=1;
write_log("osd init done\n");
co_switch(mainThread);
}
void ui_menu_image_info::image_info_astring(running_machine &machine, astring &string)
{
string.printf("%s\n\n", machine.system().description);
#if 0
if (mess_ram_size > 0)
{
char buf2[RAM_STRING_BUFLEN];
string.catprintf("RAM: %s\n\n", ram_string(buf2, mess_ram_size));
}
#endif
image_interface_iterator iter(machine.root_device());
for (device_image_interface *image = iter.first(); image != NULL; image = iter.next())
{
const char *name = image->filename();
if (name != NULL)
{
const char *base_filename;
const char *info;
char *base_filename_noextension;
base_filename = image->basename();
base_filename_noextension = strip_extension(base_filename);
// display device type and filename
string.catprintf("%s: %s\n", image->device().name(), base_filename);
// display long filename, if present and doesn't correspond to name
info = image->longname();
if (info && (!base_filename_noextension || core_stricmp(info, base_filename_noextension)))
string.catprintf("%s\n", info);
// display manufacturer, if available
info = image->manufacturer();
if (info != NULL)
{
string.catprintf("%s", info);
info = stripspace(image->year());
if (info && *info)
string.catprintf(", %s", info);
string.catprintf("\n");
}
// display supported information, if available
switch(image->supported()) {
case SOFTWARE_SUPPORTED_NO : string.catprintf("Not supported\n"); break;
case SOFTWARE_SUPPORTED_PARTIAL : string.catprintf("Partially supported\n"); break;
default : break;
}
if (base_filename_noextension != NULL)
free(base_filename_noextension);
}
else
{
string.catprintf("%s: ---\n", image->device().name());
}
}
}
void ui_gfx_init(running_machine &machine)
{
ui_gfx_state *state = &ui_gfx;
uint8_t rotate = machine.system().flags & machine_flags::MASK_ORIENTATION;
// make sure we clean up after ourselves
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(&ui_gfx_exit, &machine));
// initialize our global state
memset(state, 0, sizeof(*state));
// set up the palette state
state->palette.columns = 16;
// set up the graphics state
for (uint8_t i = 0; i < MAX_GFX_DECODERS; i++)
for (uint8_t j = 0; j < MAX_GFX_ELEMENTS; j++)
{
state->gfxdev[i].rotate[j] = rotate;
state->gfxdev[i].columns[j] = 16;
}
// set up the tilemap state
state->tilemap.rotate = rotate;
state->tilemap.flags = TILEMAP_DRAW_ALL_CATEGORIES;
}
void ui_gfx_init(running_machine &machine)
{
ui_gfx_state *state = &ui_gfx;
UINT8 rotate = machine.system().flags & ORIENTATION_MASK;
// make sure we clean up after ourselves
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(ui_gfx_exit), &machine));
// initialize our global state
memset(state, 0, sizeof(*state));
// set up the palette state
state->palette.columns = 16;
// set up the graphics state
for (UINT8 i = 0; i < MAX_GFX_DECODERS; i++)
for (UINT8 j = 0; j < MAX_GFX_ELEMENTS; j++)
{
state->gfxdev[i].rotate[j] = rotate;
state->gfxdev[i].columns[j] = 16;
}
// set up the tilemap state
state->tilemap.rotate = rotate;
}
void a600xl_mmu(running_machine &machine, UINT8 new_mmu)
{
/* check if self-test ROM changed */
if ( new_mmu & 0x80 )
{
logerror("%s MMU SELFTEST RAM\n", machine.system().name);
machine.device("maincpu")->memory().space(AS_PROGRAM).nop_readwrite(0x5000, 0x57ff);
}
else
{
logerror("%s MMU SELFTEST ROM\n", machine.system().name);
machine.device("maincpu")->memory().space(AS_PROGRAM).install_read_bank(0x5000, 0x57ff, "bank2");
machine.device("maincpu")->memory().space(AS_PROGRAM).unmap_write(0x5000, 0x57ff);
machine.root_device().membank("bank2")->set_base(machine.root_device().memregion("maincpu")->base() + 0x5000);
}
}
/* safe_to_load checks the start and end values of each memory range */
static int safe_to_load (running_machine &machine)
{
memory_range *mem_range = state.mem_range;
address_space *srcspace;
if (strstr(machine.system().source_file,"cinemat.c") > 0)
{
srcspace = machine.cpu[mem_range->cpu]->memory().space(AS_DATA);
}
else
{
srcspace = machine.cpu[mem_range->cpu]->memory().space(AS_PROGRAM);
}
while (mem_range)
{
if (srcspace->read_byte(mem_range->addr) != mem_range->start_value)
{
return 0;
}
if (srcspace->read_byte(mem_range->addr + mem_range->num_bytes - 1) != mem_range->end_value)
{
return 0;
}
mem_range = mem_range->next;
}
return 1;
}
static LRESULT send_id_string(running_machine &machine, HWND hwnd, LPARAM id)
{
copydata_id_string *temp;
COPYDATASTRUCT copydata;
const char *name;
int datalen;
// id 0 is the name of the game
if (id == 0)
name = machine.system().name;
else
name = output_id_to_name(id);
// a NULL name is an empty string
if (name == NULL)
name = "";
// allocate memory for the message
datalen = sizeof(*temp) + strlen(name);
temp = (copydata_id_string *)global_alloc_array(UINT8, datalen);
temp->id = id;
strcpy(temp->string, name);
// reply by using SendMessage with WM_COPYDATA
copydata.dwData = COPYDATA_MESSAGE_ID_STRING;
copydata.cbData = datalen;
copydata.lpData = temp;
SendMessage(hwnd, WM_COPYDATA, (WPARAM)output_hwnd, (LPARAM)©data);
// free the data
global_free(temp);
return 0;
}
static LRESULT send_id_string(running_machine &machine, HWND hwnd, LPARAM id)
{
COPYDATASTRUCT copydata;
const char *name;
int datalen;
// id 0 is the name of the game
if (id == 0)
name = machine.system().name;
else
name = machine.output().id_to_name(id);
// a NULL name is an empty string
if (name == nullptr)
name = "";
// allocate memory for the message
datalen = sizeof(copydata_id_string) + strlen(name) + 1;
dynamic_buffer buffer(datalen);
copydata_id_string *temp = (copydata_id_string *)&buffer[0];
temp->id = id;
strcpy(temp->string, name);
// reply by using SendMessage with WM_COPYDATA
copydata.dwData = COPYDATA_MESSAGE_ID_STRING;
copydata.cbData = datalen;
copydata.lpData = temp;
SendMessage(hwnd, WM_COPYDATA, (WPARAM)output_hwnd, (LPARAM)©data);
return 0;
}
void gottlieb_knocker(running_machine &machine)
{
device_t *samples = space->machine().device("samples");
if (!strcmp(machine.system().name,"reactor")) /* reactor */
{
}
else if (samples != NULL) /* qbert */
sample_start(samples, 0,44,0);
}
static void sdloutput_exit(running_machine &machine)
{
if (output != NULL)
{
fprintf(output, "MAME " PID_FMT " STOP %s\n", osd_getpid(), machine.system().name);
fflush(output);
fclose(output);
output = NULL;
mame_printf_verbose("ouput: closed output notifier file\n");
}
}
static void create_bitmap(running_machine &machine, int player)
{
int x, y;
char filename[20];
rgb_t color = crosshair_colors[player];
/* if we have a bitmap and texture for this player, kill it */
if (global.bitmap[player] == NULL)
global.bitmap[player] = global_alloc(bitmap_argb32);
machine.render().texture_free(global.texture[player]);
emu_file crossfile(machine.options().crosshair_path(), OPEN_FLAG_READ);
if (global.name[player][0] != 0)
{
/* look for user specified file */
sprintf(filename, "%s.png", global.name[player]);
render_load_png(*global.bitmap[player], crossfile, NULL, filename);
}
else
{
/* look for default cross?.png in crsshair\game dir */
sprintf(filename, "cross%d.png", player + 1);
render_load_png(*global.bitmap[player], crossfile, machine.system().name, filename);
/* look for default cross?.png in crsshair dir */
if (!global.bitmap[player]->valid())
render_load_png(*global.bitmap[player], crossfile, NULL, filename);
}
/* if that didn't work, use the built-in one */
if (!global.bitmap[player]->valid())
{
/* allocate a blank bitmap to start with */
global.bitmap[player]->allocate(CROSSHAIR_RAW_SIZE, CROSSHAIR_RAW_SIZE);
global.bitmap[player]->fill(MAKE_ARGB(0x00,0xff,0xff,0xff));
/* extract the raw source data to it */
for (y = 0; y < CROSSHAIR_RAW_SIZE / 2; y++)
{
/* assume it is mirrored vertically */
UINT32 *dest0 = &global.bitmap[player]->pix32(y);
UINT32 *dest1 = &global.bitmap[player]->pix32(CROSSHAIR_RAW_SIZE - 1 - y);
/* extract to two rows simultaneously */
for (x = 0; x < CROSSHAIR_RAW_SIZE; x++)
if ((crosshair_raw_top[y * CROSSHAIR_RAW_ROWBYTES + x / 8] << (x % 8)) & 0x80)
dest0[x] = dest1[x] = MAKE_ARGB(0xff,0x00,0x00,0x00) | color;
}
}
/* create a texture to reference the bitmap */
global.texture[player] = machine.render().texture_alloc(render_texture::hq_scale);
global.texture[player]->set_bitmap(*global.bitmap[player], global.bitmap[player]->cliprect(), TEXFORMAT_ARGB32);
}
void sgi_mc_init(running_machine &machine)
{
pMC = auto_alloc_clear(machine, MC_t);
// if Indigo2, ID appropriately
if (!strcmp(machine.system().name, "ip244415"))
{
pMC->nSysID = 0x11; // rev. B MC, EISA bus present
}
sgi_mc_timer_init(machine);
}
void dump_decrypted(running_machine& machine, UINT8* decrypt)
{
FILE *fp;
char filename[256];
sprintf(filename,"dat_%s", machine.system().name);
fp=fopen(filename, "w+b");
if (fp)
{
fwrite(decrypt, 0x10000, 1, fp);
fclose(fp);
}
}
static void copy_from_memory (running_machine &machine, int cpu, int addr, UINT8 *dest, int num_bytes)
{
address_space *targetspace;
if (strstr(machine.system().source_file,"cinemat.c") > 0)
targetspace = &machine.cpu[cpu]->memory().space(AS_DATA);
else
targetspace = &machine.cpu[cpu]->memory().space(AS_PROGRAM);
for (int i = 0; i < num_bytes; i++)
{
dest[i] = targetspace->read_byte(addr+i);
}
}
void sgi_mc_init(running_machine &machine)
{
nMC_CPUControl0 = 0;
nMC_CPUControl1 = 0;
nMC_Watchdog = 0;
nMC_SysID = 0;
nMC_RPSSDiv = 0;
nMC_RefCntPreload = 0;
nMC_RefCnt = 0;
nMC_GIO64ArbParam = 0;
nMC_ArbCPUTime = 0;
nMC_ArbBurstTime = 0;
nMC_MemCfg0 = 0;
nMC_MemCfg1 = 0;
nMC_CPUMemAccCfg = 0;
nMC_GIOMemAccCfg = 0;
nMC_CPUErrorAddr = 0;
nMC_CPUErrorStatus = 0;
nMC_GIOErrorAddr = 0;
nMC_GIOErrorStatus = 0;
nMC_SysSemaphore = 0;
nMC_GIOLock = 0;
nMC_EISALock = 0;
nMC_GIO64TransMask = 0;
nMC_GIO64Subst = 0;
nMC_DMAIntrCause = 0;
nMC_DMAControl = 0;
nMC_DMATLBEntry0Hi = 0;
nMC_DMATLBEntry0Lo = 0;
nMC_DMATLBEntry1Hi = 0;
nMC_DMATLBEntry1Lo = 0;
nMC_DMATLBEntry2Hi = 0;
nMC_DMATLBEntry2Lo = 0;
nMC_DMATLBEntry3Hi = 0;
nMC_DMATLBEntry3Lo = 0;
nMC_RPSSCounter = 0;
nMC_DMAMemAddr = 0;
nMC_DMAMemAddr = 0;
nMC_DMALineCntWidth = 0;
nMC_DMALineZoomStride = 0;
nMC_DMAGIO64Addr = 0;
nMC_DMAMode = 0;
nMC_DMAZoomByteCnt = 0;
// if Indigo2, ID appropriately
if (!strcmp(machine.system().name, "ip244415"))
{
nMC_SysID = 0x11; // rev. B MC, EISA bus present
}
}
void ui_gfx_init(running_machine &machine)
{
ui_gfx_state *state = &ui_gfx;
int gfx;
/* make sure we clean up after ourselves */
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(ui_gfx_exit), &machine));
/* initialize our global state */
memset(state, 0, sizeof(*state));
/* set up the palette state */
state->palette.count = 16;
/* set up the graphics state */
for (gfx = 0; gfx < MAX_GFX_ELEMENTS; gfx++)
{
state->gfxset.rotate[gfx] = machine.system().flags & ORIENTATION_MASK;
state->gfxset.count[gfx] = 16;
}
/* set up the tilemap state */
state->tilemap.rotate = machine.system().flags & ORIENTATION_MASK;
}
void mini_osd_interface::init(running_machine &machine)
{
int gamRot=0;
osd_interface::init(machine);
our_target = machine.render().target_alloc();
initInput(machine);
write_log("machine screen orientation: %s \n", (
machine.system().flags & ORIENTATION_SWAP_XY) ? "VERTICAL" : "HORIZONTAL"
);
orient = (machine.system().flags & ORIENTATION_MASK);
vertical = (machine.system().flags & ORIENTATION_SWAP_XY);
gamRot = (ROT270 == orient) ? 1 : gamRot;
gamRot = (ROT180 == orient) ? 2 : gamRot;
gamRot = (ROT90 == orient) ? 3 : gamRot;
prep_retro_rotation(gamRot);
write_log("osd init done\n");
}
static void write_board( running_machine &machine, UINT8 data)
{
Line18_REED=data;
if (read_board_flag && !strcmp(machine.system().name,"glasgow") ) //HACK
Line18_LED = 0;
else
Line18_LED = data;
read_board_flag = FALSE;
if (data == 0xff)
mboard_key_selector = 0;
}
ui_menu_dats_view::ui_menu_dats_view(running_machine &machine, render_container *container, ui_software_info *swinfo, const game_driver *driver) : ui_menu(machine, container)
{
m_list = swinfo->listname;
m_short = swinfo->shortname;
m_long = swinfo->longname;
m_parent = swinfo->parentname;
m_driver = (driver == nullptr) ? &machine.system() : driver;
m_swinfo = swinfo;
issoft = true;
if (machine.datfile().has_software(m_list, m_short, m_parent))
m_items_list.emplace_back(_("Software History"), UI_HISTORY_LOAD, machine.datfile().rev_history());
if (swinfo && !swinfo->usage.empty())
m_items_list.emplace_back(_("Software Usage"), 0, "");
}
void init_eolith_speedup(running_machine &machine)
{
int n_game = 0;
eolith_speedup_address = 0;
eolith_speedup_resume_scanline = 0;
while( eolith_speedup_table[ n_game ].s_name != NULL )
{
if( strcmp( machine.system().name, eolith_speedup_table[ n_game ].s_name ) == 0 )
{
eolith_speedup_address = eolith_speedup_table[ n_game ].speedup_address;
eolith_speedup_address2 = eolith_speedup_table[ n_game ].speedup_address2;
eolith_speedup_resume_scanline = eolith_speedup_table[ n_game ].speedup_resume_scanline;
}
n_game++;
}
}
ui_menu_dats_view::ui_menu_dats_view(running_machine &machine, render_container *container, const game_driver *driver) : ui_menu(machine, container)
{
image_interface_iterator iter(machine.root_device());
for (device_image_interface *image = iter.first(); image != nullptr; image = iter.next())
{
if (image->filename())
{
m_list = strensure(image->software_list_name());
m_short = strensure(image->software_entry()->shortname());
m_long = strensure(image->software_entry()->longname());
m_parent = strensure(image->software_entry()->parentname());
}
}
m_driver = (driver == nullptr) ? &machine.system() : driver;
init_items();
}
static void copy_to_memory (running_machine &machine, int cpu, int addr, const UINT8 *source, int num_bytes)
{
int i;
address_space *targetspace;
if (strstr(machine.system().source_file,"cinemat.c") > 0)
{
targetspace = machine.cpu[cpu]->memory().space(AS_DATA);
}
else
{
targetspace = machine.cpu[cpu]->memory().space(AS_PROGRAM);
}
for (i=0; i<num_bytes; i++)
{
targetspace->write_byte(addr+i, source[i]);
}
}
void debug_console_init(running_machine &machine)
{
/* allocate text buffers */
console_textbuf = text_buffer_alloc(CONSOLE_BUF_SIZE, CONSOLE_MAX_LINES);
if (!console_textbuf)
return;
errorlog_textbuf = text_buffer_alloc(ERRORLOG_BUF_SIZE, ERRORLOG_MAX_LINES);
if (!errorlog_textbuf)
return;
/* print the opening lines */
debug_console_printf(machine, "%s debugger version %s\n", emulator_info::get_appname(), build_version);
debug_console_printf(machine, "Currently targeting %s (%s)\n", machine.system().name, machine.system().description);
/* request callback upon exiting */
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(debug_console_exit), &machine));
}
void sdloutput_init(running_machine &machine)
{
int fildes;
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(sdloutput_exit), &machine));
fildes = open(SDLMAME_OUTPUT, O_RDWR | O_NONBLOCK);
if (fildes < 0)
{
output = NULL;
mame_printf_verbose("ouput: unable to open output notifier file %s\n", SDLMAME_OUTPUT);
}
else
{
output = fdopen(fildes, "w");
mame_printf_verbose("ouput: opened output notifier file %s\n", SDLMAME_OUTPUT);
fprintf(output, "MAME " PID_FMT " START %s\n", osd_getpid(), machine.system().name);
fflush(output);
}
output_set_notifier(NULL, notifier_callback, NULL);
}
static void image_options_extract(running_machine &machine)
{
/* only extract the device options if we've added them
no need to assert in case they are missing */
{
int index = 0;
device_image_interface *image = NULL;
for (bool gotone = machine.devicelist().first(image); gotone; gotone = image->next(image))
{
const char *filename = image->filename();
/* and set the option */
astring error;
machine.options().set_value(image->instance_name(), filename ? filename : "", OPTION_PRIORITY_CMDLINE, error);
index++;
}
}
/* write the config, if appropriate */
if (machine.options().write_config())
write_config(machine.options(), NULL, &machine.system());
}
ROM_END
/*************************************
*
* Low byte ROM decoding
*
*************************************/
INLINE void generic_decode(running_machine &machine, const char *tag, int bit7, int bit6, int bit5, int bit4, int bit3, int bit2, int bit1, int bit0)
{
UINT16 *rom = (UINT16 *)machine.region(tag)->base();
int i;
/* only the low byte of ROMs are encrypted in these games */
for (i = 0; i < 0x20000/2; i++)
rom[i] = BITSWAP16(rom[i], 15,14,13,12,11,10,9,8, bit7,bit6,bit5,bit4,bit3,bit2,bit1,bit0);
#if 0
{
UINT8 *ROM = machine.region(tag)->base();
int size = machine.region(tag)->bytes();
FILE *fp;
char filename[256];
sprintf(filename,"decrypted_%s", machine.system().name);
fp=fopen(filename, "w+b");
if (fp)
{
fwrite(ROM, size, 1, fp);
fclose(fp);
}
}
#endif
}
/* call hiscore_open once after loading a game */
void hiscore_init (running_machine &machine)
{
memory_range *mem_range = state.mem_range;
file_error filerr;
const char *db_filename = machine.options().value(OPTION_HISCORE_FILE); /* high score definition file */
const char *name = machine.system().name;
state.hiscores_have_been_loaded = 0;
while (mem_range)
{
if (strstr(machine.system().source_file,"cinemat.c") > 0)
{
machine.cpu[mem_range->cpu]->memory().space(AS_DATA)->write_byte(mem_range->addr, ~mem_range->start_value);
machine.cpu[mem_range->cpu]->memory().space(AS_DATA)->write_byte(mem_range->addr + mem_range->num_bytes-1, ~mem_range->end_value);
mem_range = mem_range->next;
}
else
{
machine.cpu[mem_range->cpu]->memory().space(AS_PROGRAM)->write_byte(mem_range->addr, ~mem_range->start_value);
machine.cpu[mem_range->cpu]->memory().space(AS_PROGRAM)->write_byte(mem_range->addr + mem_range->num_bytes-1,~mem_range->end_value);
mem_range = mem_range->next;
}
}
state.mem_range = NULL;
emu_file f = emu_file(OPEN_FLAG_READ);
filerr = f.open(db_filename);
if (filerr == FILERR_NONE)
{
char buffer[MAX_CONFIG_LINE_SIZE];
enum { FIND_NAME, FIND_DATA, FETCH_DATA } mode;
mode = FIND_NAME;
while (f.gets (buffer, MAX_CONFIG_LINE_SIZE))
{
if (mode==FIND_NAME)
{
if (matching_game_name (buffer, name))
{
mode = FIND_DATA;
LOG(("hs config found!\n"));
}
}
else if (is_mem_range (buffer))
{
const char *pBuf = buffer;
mem_range = global_alloc_array(memory_range, sizeof(memory_range));
if (mem_range)
{
mem_range->cpu = hexstr2num (&pBuf);
mem_range->addr = hexstr2num (&pBuf);
mem_range->num_bytes = hexstr2num (&pBuf);
mem_range->start_value = hexstr2num (&pBuf);
mem_range->end_value = hexstr2num (&pBuf);
mem_range->next = NULL;
{
memory_range *last = state.mem_range;
while (last && last->next) last = last->next;
if (last == NULL)
{
state.mem_range = mem_range;
}
else
{
last->next = mem_range;
}
}
mode = FETCH_DATA;
}
else
{
hiscore_free();
break;
}
}
else
{
/* line is a game name */
if (mode == FETCH_DATA) break;
}
}
f.close ();
}
timer = machine.scheduler().timer_alloc(FUNC(hiscore_periodic), NULL);
timer->adjust(machine.primary_screen->frame_period(), 0, machine.primary_screen->frame_period());
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(hiscore_close), &machine));
}
/* call hiscore_open once after loading a game */
void hiscore_init (running_machine &machine)
{
memory_range *mem_range = state.mem_range;
address_space *initspace;
file_error filerr;
const char *name = machine.system().name;
state.hiscores_have_been_loaded = 0;
while (mem_range)
{
if (strstr(machine.system().source_file,"cinemat.c") > 0)
{
initspace = &machine.cpu[mem_range->cpu]->memory().space(AS_DATA);
initspace->write_byte(mem_range->addr, ~mem_range->start_value);
initspace->write_byte(mem_range->addr + mem_range->num_bytes-1, ~mem_range->end_value);
mem_range = mem_range->next;
}
else
{
initspace = &machine.cpu[mem_range->cpu]->memory().space(AS_PROGRAM);
initspace->write_byte(mem_range->addr, ~mem_range->start_value);
initspace->write_byte(mem_range->addr + mem_range->num_bytes-1, ~mem_range->end_value);
mem_range = mem_range->next;
}
}
state.mem_range = nullptr;
emu_file f(machine.options().high_path(), OPEN_FLAG_READ);
filerr = f.open("hiscore.dat");
if (filerr == FILERR_NONE)
{
char buffer[MAX_CONFIG_LINE_SIZE];
enum { FIND_NAME, FIND_DATA, FETCH_DATA } mode;
mode = FIND_NAME;
while (f.gets(buffer, MAX_CONFIG_LINE_SIZE))
{
if (mode == FIND_NAME)
{
if (matching_game_name (buffer, name))
mode = FIND_DATA;
}
else if (is_mem_range (buffer))
{
const char *pBuf = buffer;
mem_range = (memory_range *)malloc(sizeof(memory_range));
if (mem_range)
{
mem_range->cpu = hexstr2num (&pBuf);
mem_range->addr = hexstr2num (&pBuf);
mem_range->num_bytes = hexstr2num (&pBuf);
mem_range->start_value = hexstr2num (&pBuf);
mem_range->end_value = hexstr2num (&pBuf);
mem_range->next = nullptr;
{
memory_range *last = state.mem_range;
while (last && last->next) last = last->next;
if (last == nullptr)
state.mem_range = mem_range;
else
last->next = mem_range;
}
mode = FETCH_DATA;
}
else
{
hiscore_free();
break;
}
}
else
{
/* line is a game name */
if (mode == FETCH_DATA)
break;
}
}
f.close();
}
timer = machine.scheduler().timer_alloc(FUNC(hiscore_periodic));
timer->adjust(machine.first_screen()->frame_period(), 0, machine.first_screen()->frame_period());
machine.add_notifier(MACHINE_NOTIFY_EXIT, machine_notify_delegate(FUNC(hiscore_close), &machine));
}
int sdlwindow_video_window_create(running_machine &machine, int index, sdl_monitor_info *monitor, const sdl_window_config *config)
{
sdl_window_info *window;
worker_param *wp = (worker_param *) osd_malloc(sizeof(worker_param));
int result;
ASSERT_MAIN_THREAD();
clear_worker_param(wp);
// allocate a new window object
window = global_alloc_clear(sdl_window_info);
window->maxwidth = config->width;
window->maxheight = config->height;
window->depth = config->depth;
window->refresh = config->refresh;
window->monitor = monitor;
window->m_machine = &machine;
window->index = index;
//FIXME: these should be per_window in config-> or even better a bit set
window->fullscreen = !video_config.windowed;
window->prescale = video_config.prescale;
// set the initial maximized state
// FIXME: Does not belong here
sdl_options &options = downcast<sdl_options &>(machine.options());
window->startmaximized = options.maximize();
if (!window->fullscreen)
{
window->windowed_width = config->width;
window->windowed_height = config->height;
}
window->totalColors = config->totalColors;
// add us to the list
*last_window_ptr = window;
last_window_ptr = &window->next;
draw.attach(&draw, window);
// create an event that we can use to skip blitting
window->rendered_event = osd_event_alloc(FALSE, TRUE);
// load the layout
window->target = machine.render().target_alloc();
// set the specific view
set_starting_view(machine, index, window, options.view(), options.view(index));
// make the window title
if (video_config.numscreens == 1)
sprintf(window->title, "%s: %s [%s]", emulator_info::get_appname(), machine.system().description, machine.system().name);
else
sprintf(window->title, "%s: %s [%s] - Screen %d", emulator_info::get_appname(), machine.system().description, machine.system().name, index);
wp->window = window;
if (multithreading_enabled)
{
osd_work_item *wi;
wi = osd_work_item_queue(work_queue, &complete_create_wt, (void *) wp, 0);
sdlwindow_sync();
result = *((int *) (osd_work_item_result)(wi));
osd_work_item_release(wi);
}
else
result = *((int *) complete_create_wt((void *) wp, 0));
// handle error conditions
if (result == 1)
goto error;
return 0;
error:
sdlwindow_video_window_destroy(machine, window);
return 1;
}
