static UINT8 read_port_and_t0(int port)
{
UINT8 val = readinputport(port);
if (compare_mame_times(mame_timer_get_time(), timeout_time) > 0)
val ^= 0x80;
return val;
}
int video_screen_get_vpos(int scrnum)
{
mame_time delta = sub_mame_times(mame_timer_get_time(), scrinfo[scrnum].vblank_time);
int vpos;
assert(delta.seconds == 0);
vpos = delta.subseconds / scrinfo[scrnum].scantime;
return (Machine->screen[scrnum].visarea.max_y + 1 + vpos) % Machine->screen[scrnum].height;
}
int video_screen_get_hpos(int scrnum)
{
mame_time delta = sub_mame_times(mame_timer_get_time(), scrinfo[scrnum].vblank_time);
int vpos, hpos;
assert(delta.seconds == 0);
vpos = delta.subseconds / scrinfo[scrnum].scantime;
hpos = (delta.subseconds - (vpos * scrinfo[scrnum].scantime)) / scrinfo[scrnum].pixeltime;
return hpos;
}
void video_vblank_start(void)
{
mame_time curtime = mame_timer_get_time();
int scrnum;
/* kludge: we get called at time 0 to reset, but at that point,
the time of last VBLANK is actually -vblank_duration */
if (curtime.seconds == 0 && curtime.subseconds == 0)
curtime = sub_mame_times(time_zero, double_to_mame_time(Machine->screen[0].vblank));
/* reset VBLANK timers for each screen -- fix me */
for (scrnum = 0; scrnum < MAX_SCREENS; scrnum++)
scrinfo[scrnum].vblank_time = curtime;
}
void mame_schedule_load(const char *filename)
{
/* free any existing request and allocate a copy of the requested name */
if (saveload_pending_file != NULL)
free(saveload_pending_file);
saveload_pending_file = mame_strdup(filename);
/* note the start time and set a timer for the next timeslice to actually schedule it */
saveload_schedule_callback = handle_load;
saveload_schedule_time = mame_timer_get_time();
/* we can't be paused since we need to clear out anonymous timers */
mame_pause(FALSE);
}
void mame_schedule_save(running_machine *machine, const char *filename)
{
mame_private *mame = machine->mame_data;
/* free any existing request and allocate a copy of the requested name */
if (mame->saveload_pending_file != NULL)
free(mame->saveload_pending_file);
mame->saveload_pending_file = mame_strdup(filename);
/* note the start time and set a timer for the next timeslice to actually schedule it */
mame->saveload_schedule_callback = handle_save;
mame->saveload_schedule_time = mame_timer_get_time();
/* we can't be paused since we need to clear out anonymous timers */
mame_pause(machine, FALSE);
}
static WRITE8_HANDLER( output_port_0_w )
{
/*
Note: We compute the timeout time on a write here. Unfortunately, the situation is
kind of weird, because the discrete sound system is also affected by this timeout.
In fact, it is very important that our timing calculation timeout AFTER the sound
system's equivalent computation, or else we will hang notes.
*/
UINT8 raw_game_speed = readinputport(6);
double resistance = raw_game_speed * 25000 / 100;
mame_time duration = make_mame_time(0, MAX_SUBSECONDS * 0.45 * 6.8e-6 * resistance * (data+1));
timeout_time = add_mame_times(mame_timer_get_time(), duration);
discrete_sound_w(HITME_DOWNCOUNT_VAL, data);
discrete_sound_w(HITME_OUT0, 1);
}
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());
}
mame_time video_screen_get_time_until_pos(int scrnum, int vpos, int hpos)
{
mame_time curdelta = sub_mame_times(mame_timer_get_time(), scrinfo[scrnum].vblank_time);
subseconds_t targetdelta;
assert(curdelta.seconds == 0);
/* since we measure time relative to VBLANK, compute the scanline offset from VBLANK */
vpos += Machine->screen[scrnum].height - (Machine->screen[scrnum].visarea.max_y + 1);
vpos %= Machine->screen[scrnum].height;
/* compute the delta for the given X,Y position */
targetdelta = (subseconds_t)vpos * scrinfo[scrnum].scantime + (subseconds_t)hpos * scrinfo[scrnum].pixeltime;
/* if we're past that time, head to the next frame */
if (targetdelta <= curdelta.subseconds)
targetdelta += DOUBLE_TO_SUBSECONDS(TIME_IN_HZ(Machine->screen[scrnum].refresh));
/* return the difference */
return make_mame_time(0, targetdelta - curdelta.subseconds);
}
void video_frame_update(void)
{
int skipped_it = video_skip_this_frame();
int paused = mame_is_paused(Machine);
int phase = mame_get_phase(Machine);
int livemask;
int scrnum;
/* only render sound and video if we're in the running phase */
if (phase == MAME_PHASE_RUNNING)
{
/* update sound */
sound_frame_update();
/* finish updating the screens */
for (scrnum = 0; scrnum < MAX_SCREENS; scrnum++)
if (Machine->drv->screen[scrnum].tag != NULL)
video_screen_update_partial(scrnum, Machine->screen[scrnum].visarea.max_y);
/* now add the quads for all the screens */
livemask = render_get_live_screens_mask();
for (scrnum = 0; scrnum < MAX_SCREENS; scrnum++) {
if (livemask & (1 << scrnum))
{
internal_screen_info *screen = &scrinfo[scrnum];
/* only update if empty and not a vector game; otherwise assume the driver did it directly */
if (render_container_is_empty(render_container_get_screen(scrnum)) && !(Machine->drv->video_attributes & VIDEO_TYPE_VECTOR))
{
mame_bitmap *bitmap = screen->bitmap[screen->curbitmap];
if (!skipping_this_frame && screen->changed)
{
rectangle fixedvis = Machine->screen[scrnum].visarea;
fixedvis.max_x++;
fixedvis.max_y++;
render_texture_set_bitmap(screen->texture, bitmap, &fixedvis, Machine->drv->screen[scrnum].palette_base, screen->format);
screen->curbitmap = 1 - screen->curbitmap;
}
render_screen_add_quad(scrnum, 0.0f, 0.0f, 1.0f, 1.0f, MAKE_ARGB(0xff,0xff,0xff,0xff), screen->texture, PRIMFLAG_BLENDMODE(BLENDMODE_NONE) | PRIMFLAG_SCREENTEX(1));
}
}
}
/* update our movie recording state */
if (!paused)
movie_record_frame(0);
/* reset the screen changed flags */
for (scrnum = 0; scrnum < MAX_SCREENS; scrnum++)
scrinfo[scrnum].changed = 0;
}
/* draw any crosshairs */
crosshair_render();
/* draw the user interface */
ui_update_and_render();
/* call the OSD to update */
skipping_this_frame = osd_update(mame_timer_get_time());
/* empty the containers */
for (scrnum = 0; scrnum < MAX_SCREENS; scrnum++)
if (Machine->drv->screen[scrnum].tag != NULL)
render_container_empty(render_container_get_screen(scrnum));
/* update FPS */
recompute_fps(skipped_it);
/* call the end-of-frame callback */
if (phase == MAME_PHASE_RUNNING)
{
/* reset partial updates if we're paused or if the debugger is active */
if (paused || mame_debug_is_active())
video_reset_partial_updates();
/* otherwise, call the video EOF callback */
else if (Machine->drv->video_eof != NULL)
{
profiler_mark(PROFILER_VIDEO);
(*Machine->drv->video_eof)(Machine);
profiler_mark(PROFILER_END);
}
}
}
void mame_get_current_datetime(running_machine *machine, mame_system_time *systime)
{
mame_private *mame = machine->mame_data;
fill_systime(systime, mame->base_time + mame_timer_get_time().seconds);
}
static void handle_load(running_machine *machine)
{
mame_private *mame = machine->mame_data;
mame_file_error filerr;
mame_file *file;
/* if no name, bail */
if (mame->saveload_pending_file == NULL)
{
mame->saveload_schedule_callback = NULL;
return;
}
/* if there are anonymous timers, we can't load just yet because the timers might */
/* overwrite data we have loaded */
if (timer_count_anonymous() > 0)
{
/* if more than a second has passed, we're probably screwed */
if (sub_mame_times(mame_timer_get_time(), mame->saveload_schedule_time).seconds > 0)
{
popmessage("Unable to load due to pending anonymous timers. See error.log for details.");
goto cancel;
}
return;
}
/* open the file */
filerr = mame_fopen(SEARCHPATH_STATE, mame->saveload_pending_file, OPEN_FLAG_READ, &file);
if (filerr == FILERR_NONE)
{
/* start loading */
if (state_save_load_begin(file) == 0)
{
int cpunum;
/* read tag 0 */
state_save_push_tag(0);
state_save_load_continue();
state_save_pop_tag();
/* loop over CPUs */
for (cpunum = 0; cpunum < cpu_gettotalcpu(); cpunum++)
{
cpuintrf_push_context(cpunum);
/* make sure banking is set */
activecpu_reset_banking();
/* load the CPU data */
state_save_push_tag(cpunum + 1);
state_save_load_continue();
state_save_pop_tag();
/* make sure banking is set */
activecpu_reset_banking();
cpuintrf_pop_context();
}
/* finish and close */
state_save_load_finish();
popmessage("State successfully loaded.");
}
else
popmessage("Error: Failed to load state");
mame_fclose(file);
}
else
popmessage("Error: Failed to load state");
cancel:
/* unschedule the load */
free(mame->saveload_pending_file);
mame->saveload_pending_file = NULL;
mame->saveload_schedule_callback = NULL;
}
static void handle_save(running_machine *machine)
{
mame_private *mame = machine->mame_data;
mame_file_error filerr;
mame_file *file;
/* if no name, bail */
if (mame->saveload_pending_file == NULL)
{
mame->saveload_schedule_callback = NULL;
return;
}
/* if there are anonymous timers, we can't save just yet */
if (timer_count_anonymous() > 0)
{
/* if more than a second has passed, we're probably screwed */
if (sub_mame_times(mame_timer_get_time(), mame->saveload_schedule_time).seconds > 0)
{
popmessage("Unable to save due to pending anonymous timers. See error.log for details.");
goto cancel;
}
return;
}
/* open the file */
filerr = mame_fopen(SEARCHPATH_STATE, mame->saveload_pending_file, OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS, &file);
if (filerr == FILERR_NONE)
{
int cpunum;
/* write the save state */
if (state_save_save_begin(file) != 0)
{
popmessage("Error: Unable to save state due to illegal registrations. See error.log for details.");
mame_fclose(file);
goto cancel;
}
/* write the default tag */
state_save_push_tag(0);
state_save_save_continue();
state_save_pop_tag();
/* loop over CPUs */
for (cpunum = 0; cpunum < cpu_gettotalcpu(); cpunum++)
{
cpuintrf_push_context(cpunum);
/* make sure banking is set */
activecpu_reset_banking();
/* save the CPU data */
state_save_push_tag(cpunum + 1);
state_save_save_continue();
state_save_pop_tag();
cpuintrf_pop_context();
}
/* finish and close */
state_save_save_finish();
mame_fclose(file);
/* pop a warning if the game doesn't support saves */
if (!(machine->gamedrv->flags & GAME_SUPPORTS_SAVE))
popmessage("State successfully saved.\nWarning: Save states are not officially supported for this game.");
else
popmessage("State successfully saved.");
}
else
popmessage("Error: Failed to save state");
cancel:
/* unschedule the save */
free(mame->saveload_pending_file);
mame->saveload_pending_file = NULL;
mame->saveload_schedule_callback = NULL;
}