void timer_delay_ms(u32 ms)
{
volatile time_t time_end = (time_t)ms + timer_get_time();
while (time_end > timer_get_time())
sleep();
}
}
}
}
}
}
mc146818->updated = 1; /* clock has been updated */
mc146818->last_refresh = timer_get_time(machine);
}
void mc146818_init(running_machine *machine, MC146818_TYPE type)
{
mc146818 = auto_alloc_clear(machine, struct mc146818_chip);
mc146818->type = type;
mc146818->last_refresh = timer_get_time(machine);
timer_pulse(machine, ATTOTIME_IN_HZ(1), NULL, 0, mc146818_timer);
mc146818_set_base_datetime(machine);
}
void mc146818_load(running_machine *machine)
{
mame_file *file;
file = nvram_fopen(machine, OPEN_FLAG_READ);
if (file)
{
mc146818_load_stream(file);
mame_fclose(file);
static TIMER_CALLBACK( mc146818_timer )
{
int year/*, month*/;
if (BCD_MODE)
{
mc146818->data[0]=bcd_adjust(mc146818->data[0]+1);
if (mc146818->data[0]>=0x60)
{
mc146818->data[0]=0;
mc146818->data[2]=bcd_adjust(mc146818->data[2]+1);
if (mc146818->data[2]>=0x60)
{
mc146818->data[2]=0;
mc146818->data[4]=bcd_adjust(mc146818->data[4]+1);
// different handling of hours
if (mc146818->data[4]>=0x24)
{
mc146818->data[4]=0;
WEEK_DAY=bcd_adjust(WEEK_DAY+1)%7;
DAY=bcd_adjust(DAY+1);
//month=bcd_2_dec(MONTH);
year=bcd_2_dec(YEAR);
if (mc146818->type!=MC146818_IGNORE_CENTURY) year+=bcd_2_dec(CENTURY)*100;
else year+=2000; // save for julian_days_in_month calculation
DAY=bcd_adjust(DAY+1);
if (DAY>gregorian_days_in_month(MONTH, year))
{
DAY=1;
MONTH=bcd_adjust(MONTH+1);
if (MONTH>0x12)
{
MONTH=1;
YEAR=year=bcd_adjust(YEAR+1);
if (mc146818->type!=MC146818_IGNORE_CENTURY)
{
if (year>=0x100)
{
CENTURY=bcd_adjust(CENTURY+1);
}
}
}
}
}
}
}
}
else
{
mc146818->data[0]=mc146818->data[0]+1;
if (mc146818->data[0]>=60)
{
mc146818->data[0]=0;
mc146818->data[2]=mc146818->data[2]+1;
if (mc146818->data[2]>=60) {
mc146818->data[2]=0;
mc146818->data[4]=mc146818->data[4]+1;
// different handling of hours //?
if (mc146818->data[4]>=24) {
mc146818->data[4]=0;
WEEK_DAY=(WEEK_DAY+1)%7;
year=YEAR;
if (mc146818->type!=MC146818_IGNORE_CENTURY) year+=CENTURY*100;
else year+=2000; // save for julian_days_in_month calculation
if (++DAY>gregorian_days_in_month(MONTH, year)) {
DAY=1;
if (++MONTH>12) {
MONTH=1;
YEAR++;
if (mc146818->type!=MC146818_IGNORE_CENTURY) {
if (YEAR>=100) { CENTURY++;YEAR=0; }
} else {
YEAR%=100;
}
}
}
}
}
}
}
mc146818->updated = 1; /* clock has been updated */
mc146818->last_refresh = timer_get_time(machine);
}
static WRITE8_HANDLER( exidy_shriot_w )
{
/* I/O is done if A2 == 0 */
if ((offset & 0x04) == 0)
{
switch (offset & 0x03)
{
case 0: /* port A */
if (has_mc3417)
cpunum_set_input_line(machine, 2, INPUT_LINE_RESET, (data & 0x10) ? CLEAR_LINE : ASSERT_LINE);
riot_porta_data = (riot_porta_data & ~riot_porta_ddr) | (data & riot_porta_ddr);
break;
case 1: /* port A DDR */
riot_porta_ddr = data;
break;
case 2: /* port B */
if (has_tms5220)
{
if (!(data & 0x01) && (riot_portb_data & 0x01))
{
riot_porta_data = tms5220_status_r(machine, 0);
logerror("(%f)%04X:TMS5220 status read = %02X\n", attotime_to_double(timer_get_time()), activecpu_get_previouspc(), riot_porta_data);
}
if (!(data & 0x02) && (riot_portb_data & 0x02))
{
logerror("(%f)%04X:TMS5220 data write = %02X\n", attotime_to_double(timer_get_time()), activecpu_get_previouspc(), riot_porta_data);
tms5220_data_w(machine, 0, riot_porta_data);
}
}
riot_portb_data = (riot_portb_data & ~riot_portb_ddr) | (data & riot_portb_ddr);
break;
case 3: /* port B DDR */
riot_portb_ddr = data;
break;
}
}
/* PA7 edge detect control if A2 == 1 and A4 == 0 */
else if ((offset & 0x10) == 0)
{
riot_PA7_irq_enable = offset & 0x03;
}
/* timer enable if A2 == 1 and A4 == 1 */
else
{
static const int divisors[4] = { 1, 8, 64, 1024 };
/* make sure the IRQ state is clear */
if (riot_state != RIOT_COUNT)
riot_irq_flag &= ~0x80;
riot_irq_state = 0;
update_irq_state(0);
/* set the enable from the offset */
riot_timer_irq_enable = (offset & 0x08) ? 1 : 0;
/* set a new timer */
riot_clock_divisor = divisors[offset & 0x03];
timer_adjust_oneshot(riot_timer, attotime_mul(ATTOTIME_IN_HZ(SH6532_CLOCK), data * riot_clock_divisor), 0);
riot_state = RIOT_COUNT;
}
}
void timer_update_now(egg_timeval_t *_now)
{
timer_get_time(&now);
if (_now) timer_get_now(_now);
}
static double calc_plunger_pos(void)
{
return (timer_get_time() - time_released) * (time_released - time_pushed + 0.2);
}
void streams_update(running_machine *machine)
{
streams_private *strdata = machine->streams_data;
attotime curtime = timer_get_time(machine);
int second_tick = FALSE;
sound_stream *stream;
VPRINTF(("streams_update\n"));
/* see if we ticked over to the next second */
if (curtime.seconds != strdata->last_update.seconds)
{
assert(curtime.seconds == strdata->last_update.seconds + 1);
second_tick = TRUE;
}
/* iterate over all the streams */
for (stream = strdata->stream_head; stream != NULL; stream = stream->next)
{
INT32 output_bufindex = stream->output_sampindex - stream->output_base_sampindex;
int outputnum;
/* make sure this stream is up-to-date */
stream_update(stream);
/* if we've ticked over another second, adjust all the counters that are relative to
the current second */
if (second_tick)
{
stream->output_sampindex -= stream->sample_rate;
stream->output_base_sampindex -= stream->sample_rate;
}
/* note our current output sample */
stream->output_update_sampindex = stream->output_sampindex;
/* if we don't have enough output buffer space to hold two updates' worth of samples,
we need to shuffle things down */
if (stream->output_bufalloc - output_bufindex < 2 * stream->max_samples_per_update)
{
INT32 samples_to_lose = output_bufindex - stream->max_samples_per_update;
if (samples_to_lose > 0)
{
/* if we have samples to move, do so for each output */
if (output_bufindex > 0)
for (outputnum = 0; outputnum < stream->outputs; outputnum++)
{
stream_output *output = &stream->output[outputnum];
memmove(&output->buffer[0], &output->buffer[samples_to_lose], sizeof(output->buffer[0]) * (output_bufindex - samples_to_lose));
}
/* update the base position */
stream->output_base_sampindex += samples_to_lose;
}
}
}
/* remember the update time */
strdata->last_update = curtime;
/* update sample rates if they have changed */
for (stream = strdata->stream_head; stream != NULL; stream = stream->next)
if (stream->new_sample_rate != 0)
{
UINT32 old_rate = stream->sample_rate;
int outputnum;
/* update to the new rate and remember the old rate */
stream->sample_rate = stream->new_sample_rate;
stream->new_sample_rate = 0;
/* recompute all the data */
recompute_sample_rate_data(machine, stream);
/* reset our sample indexes to the current time */
stream->output_sampindex = (INT64)stream->output_sampindex * (INT64)stream->sample_rate / old_rate;
stream->output_update_sampindex = (INT64)stream->output_update_sampindex * (INT64)stream->sample_rate / old_rate;
stream->output_base_sampindex = stream->output_sampindex - stream->max_samples_per_update;
/* clear out the buffer */
for (outputnum = 0; outputnum < stream->outputs; outputnum++)
memset(stream->output[outputnum].buffer, 0, stream->max_samples_per_update * sizeof(stream->output[outputnum].buffer[0]));
}
}
/*
* Get time in ns since tsc_timer was initialized.
*/
uint64_t
get_current_time() {
return timer_get_time(tsc_timer->timer);
}
int osd_update(mame_time emutime)
{
int i;
double time_limit;
double current_time;
int cpunum;
render_target_get_primitives(target);
/* is this the first update? if so, eat it */
if (!seen_first_update)
{
seen_first_update = TRUE;
goto done;
}
/* if we have already aborted or completed, our work is done */
if ((state == STATE_ABORTED) || (state == STATE_DONE))
{
mame_schedule_exit(Machine);
goto done;
}
/* have we hit the time limit? */
current_time = timer_get_time();
time_limit = (current_testcase.time_limit != 0.0) ? current_testcase.time_limit
: TIME_IN_SEC(600);
if (current_time > time_limit)
{
state = STATE_ABORTED;
report_message(MSG_FAILURE, "Time limit of %.2f seconds exceeded", time_limit);
goto done;
}
/* update the runtime hash */
if (0)
{
for (cpunum = 0; cpunum < cpu_gettotalcpu(); cpunum++)
{
runtime_hash *= 57;
runtime_hash ^= cpunum_get_reg(cpunum, REG_PC); /* TODO - Add more registers? */
}
}
for (i = 0; i < sizeof(commands) / sizeof(commands[i]); i++)
{
if (current_command->command_type == commands[i].command_type)
{
commands[i].proc();
break;
}
}
/* if we are ready for the next command, advance to it */
if (state == STATE_READY)
{
/* if we are at the end, and we are dumping screenshots, and we didn't
* just dump a screenshot, dump one now
*/
if ((test_flags & MESSTEST_ALWAYS_DUMP_SCREENSHOT) &&
(current_command[0].command_type != MESSTEST_COMMAND_SCREENSHOT) &&
(current_command[1].command_type == MESSTEST_COMMAND_END))
{
dump_screenshot(TRUE);
}
current_command++;
}
done:
return FALSE;
}
static void timer_callback_2612_1(void *param)
{
struct ym2612_info *info = param;
info->lastfired[1] = timer_get_time();
YM2612TimerOver(info->chip,1);
}
static DEVICE_START( speaker )
{
speaker_state *sp = get_safe_token(device);
const speaker_interface *intf = (const speaker_interface *) device->baseconfig().static_config;
int i;
double x;
sp->channel = stream_create(device, 0, 1, device->machine->sample_rate, sp, speaker_sound_update);
if (intf != NULL)
{
assert(intf->num_level > 1);
assert(intf->levels != NULL);
sp->num_levels = intf->num_level;
sp->levels = intf->levels;
}
else
{
sp->num_levels = 2;
sp->levels = default_levels;
}
sp->level = 0;
for (i = 0; i < FILTER_LENGTH; i++)
sp->composed_volume[i] = 0;
sp->composed_sample_index = 0;
sp->last_update_time = timer_get_time(device->machine);
sp->channel_sample_period = HZ_TO_ATTOSECONDS(device->machine->sample_rate);
sp->channel_sample_period_secfrac = ATTOSECONDS_TO_DOUBLE(sp->channel_sample_period);
sp->interm_sample_period = sp->channel_sample_period / RATE_MULTIPLIER;
sp->interm_sample_period_secfrac = ATTOSECONDS_TO_DOUBLE(sp->interm_sample_period);
sp->channel_last_sample_time = stream_get_time(sp->channel);
sp->channel_next_sample_time = attotime_add_attoseconds(sp->channel_last_sample_time, sp->channel_sample_period);
sp->next_interm_sample_time = attotime_add_attoseconds(sp->channel_last_sample_time, sp->interm_sample_period);
sp->interm_sample_index = 0;
/* Note: To avoid time drift due to floating point inaccuracies,
* it is good if the speaker time synchronizes itself with the stream timing regularly.
*/
/* Compute filter kernel; */
/* (Done for each device though the data is shared...
* No problem really, but should be done as part of system init if I knew how)
*/
#if 1
/* This is an approximated sinc (a perfect sinc makes an ideal low-pass filter).
* FILTER_STEP determines the cutoff frequency,
* which should be below the Nyquist freq, i.e. half the sample rate.
* Smaller step => kernel extends in time domain => lower cutoff freq
* In this case, with sinc, filter step PI corresponds to the Nyq. freq.
* Since we do not get a perfect filter => must lower the cutoff freq some more.
* For example, step PI/(2*RATE_MULTIPLIER) corresponds to cutoff freq = sample rate / 4;
* With -samplerate 48000, cutoff freq is ca 12kHz while the Nyq. freq is 24kHz.
* With -samplerate 96000, cutoff freq is ca 24kHz while the Nyq. freq is 48kHz.
* For a steeper, more efficient filter, increase FILTER_LENGTH at the expense of CPU usage.
*/
#define FILTER_STEP (M_PI / 2 / RATE_MULTIPLIER)
/* Distribute symmetrically on x axis; center has x=0 if length is odd */
for (i = 0, x = (0.5 - FILTER_LENGTH / 2.) * FILTER_STEP;
i < FILTER_LENGTH;
i++, x += FILTER_STEP)
{
if (x == 0)
ampl[i] = 1;
else
ampl[i] = sin(x) / x;
}
#else
/* Trivial average filter with poor frequency cutoff properties;
* First zero (frequency where amplification=0) = sample rate / filter length
* Cutoff frequency approx <= first zero / 2
*/
for (i = 0, i < FILTER_LENGTH; i++)
ampl[i] = 1;
#endif
}
FANN_EXTERNAL void FANN_API fann_train_on_data(struct fann *ann, struct fann_train_data *data,
unsigned int max_epochs,
unsigned int epochs_between_reports,
float desired_error)
{
float error;
unsigned int i;
int desired_error_reached = -1;
struct fpts_cl *fptscl;
cl_int err;
fptscl = fptsclalloc(ann);
fptscwrite(ann, fptscl, data);
fptspush(fptscl); //May be buggy.
#ifdef DEBUG
printf("Training with %s\n", FANN_TRAIN_NAMES[ann->training_algorithm]);
#endif
if(epochs_between_reports && ann->callback == NULL)
{
printf("Max epochs %8d. Desired error: %.10f.\n", max_epochs, desired_error);
}
#ifdef TIMER
double t_end, t_start = timer_get_time();
#endif
for(i = 1; i <= max_epochs; i++)
{
/*
* train
*/
error = fann_train_epoch(ann, data, fptscl);
//desired_error_reached = fann_desired_error_reached(ann, desired_error);
if (error < desired_error) desired_error_reached = 0;
/*
* print current output
*/
if(epochs_between_reports &&
(i % epochs_between_reports == 0 || i == max_epochs || i == 1 ||
desired_error_reached == 0))
{
if(ann->callback == NULL)
{
printf("Epochs %8d. Current error: %.10f. Bit fail %d.", i, error, ann->num_bit_fail);
#ifdef TIMER
clFinish(fptscl->hardware.queue);//TESTING
t_end = timer_get_time();
printf (". Time %0.1lf\n", (t_end - t_start)*1000);
t_start = t_end;
#else
printf("\n");
#endif
}
else if(((*ann->callback)(ann, data, max_epochs, epochs_between_reports,
desired_error, i)) == -1)
{
/*
* you can break the training by returning -1
*/
break;
}
}
if(desired_error_reached == 0)
break;
}
fptscread(ann, fptscl);
}
static int image_load_internal(mess_image *img, const char *name, int is_create, int create_format, option_resolution *create_args)
{
const struct IODevice *dev;
const char *s;
char *newname;
int err = INIT_PASS;
mame_file *file = NULL;
UINT8 *buffer = NULL;
UINT64 size;
unsigned int readable, writeable, creatable;
/* unload if we are loaded */
if (img->status & IMAGE_STATUS_ISLOADED)
image_unload(img);
/* clear out the error */
image_clear_error(img);
/* if we are attempting to "load" NULL, then exit at this point */
if (!name)
return INIT_PASS;
dev = image_device(img);
assert(dev);
img->status |= IMAGE_STATUS_ISLOADING;
if (name && *name)
{
newname = image_strdup(img, name);
if (!newname)
{
err = IMAGE_ERROR_OUTOFMEMORY;
goto error;
}
}
else
newname = NULL;
img->name = newname;
img->dir = NULL;
osd_image_load_status_changed(img, 0);
/* do we need to reset the CPU? */
if ((timer_get_time() > 0) && dev->reset_on_load)
machine_reset();
/* prepare to open the file */
img->created = 0;
img->writeable = 0;
file = NULL;
if (dev->getdispositions)
{
dev->getdispositions(dev, image_index_in_device(img), &readable, &writeable, &creatable);
}
else
{
readable = dev->readable;
writeable = dev->writeable;
creatable = dev->creatable;
}
/* is this a ZIP file? */
s = strrchr(img->name, '.');
if (s && !mame_stricmp(s, ".ZIP"))
{
/* ZIP files are writeable */
writeable = 0;
creatable = 0;
}
if (readable && !writeable)
{
file = image_fopen_custom(img, FILETYPE_IMAGE, OSD_FOPEN_READ);
}
else if (!readable && writeable)
{
file = image_fopen_custom(img, FILETYPE_IMAGE, OSD_FOPEN_WRITE);
img->writeable = file ? 1 : 0;
}
else if (readable && writeable)
{
file = image_fopen_custom(img, FILETYPE_IMAGE, OSD_FOPEN_RW);
img->writeable = file ? 1 : 0;
if (!file)
{
file = image_fopen_custom(img, FILETYPE_IMAGE, OSD_FOPEN_READ);
if (!file && creatable)
{
file = image_fopen_custom(img, FILETYPE_IMAGE, OSD_FOPEN_RW_CREATE);
img->writeable = file ? 1 : 0;
img->created = file ? 1 : 0;
}
}
}
/* did this attempt succeed? */
if (!file)
{
img->err = IMAGE_ERROR_FILENOTFOUND;
goto error;
}
/* if applicable, call device verify */
if (dev->imgverify && !image_has_been_created(img))
{
size = mame_fsize(file);
buffer = malloc(size);
if (!buffer)
{
img->err = IMAGE_ERROR_OUTOFMEMORY;
goto error;
}
if (mame_fread(file, buffer, (UINT32) size) != size)
{
img->err = IMAGE_ERROR_INVALIDIMAGE;
goto error;
}
err = dev->imgverify(buffer, size);
if (err)
{
img->err = IMAGE_ERROR_INVALIDIMAGE;
goto error;
}
mame_fseek(file, 0, SEEK_SET);
free(buffer);
buffer = NULL;
}
/* call device load or create */
if (image_has_been_created(img) && dev->create)
{
err = dev->create(img, file, create_format, create_args);
if (err)
{
if (!img->err)
img->err = IMAGE_ERROR_UNSPECIFIED;
goto error;
}
}
else if (dev->load)
{
/* using device load */
err = dev->load(img, file);
if (err)
{
if (!img->err)
img->err = IMAGE_ERROR_UNSPECIFIED;
goto error;
}
}
img->status &= ~IMAGE_STATUS_ISLOADING;
img->status |= IMAGE_STATUS_ISLOADED;
return INIT_PASS;
error:
if (file)
mame_fclose(file);
if (buffer)
free(buffer);
if (img)
{
img->fp = NULL;
img->name = NULL;
img->status &= ~IMAGE_STATUS_ISLOADING|IMAGE_STATUS_ISLOADED;
}
osd_image_load_status_changed(img, 0);
return INIT_FAIL;
}
void via6522_device::device_start()
{
devcb_resolve_read8(&m_in_a_func, &m_config.m_in_a_func, this);
devcb_resolve_read8(&m_in_b_func, &m_config.m_in_b_func, this);
devcb_resolve_read_line(&m_in_ca1_func, &m_config.m_in_ca1_func, this);
devcb_resolve_read_line(&m_in_cb1_func, &m_config.m_in_cb1_func, this);
devcb_resolve_read_line(&m_in_ca2_func, &m_config.m_in_ca2_func, this);
devcb_resolve_read_line(&m_in_cb2_func, &m_config.m_in_cb2_func, this);
devcb_resolve_write8(&m_out_a_func, &m_config.m_out_a_func, this);
devcb_resolve_write8(&m_out_b_func, &m_config.m_out_b_func, this);
devcb_resolve_write_line(&m_out_ca1_func, &m_config.m_out_ca1_func, this);
devcb_resolve_write_line(&m_out_cb1_func, &m_config.m_out_cb1_func, this);
devcb_resolve_write_line(&m_out_ca2_func, &m_config.m_out_ca2_func, this);
devcb_resolve_write_line(&m_out_cb2_func, &m_config.m_out_cb2_func, this);
devcb_resolve_write_line(&m_irq_func, &m_config.m_irq_func, this);
m_t1ll = 0xf3; /* via at 0x9110 in vic20 show these values */
m_t1lh = 0xb5; /* ports are not written by kernel! */
m_t2ll = 0xff; /* taken from vice */
m_t2lh = 0xff;
m_time2 = m_time1 = timer_get_time(&m_machine);
m_t1 = device_timer_alloc(*this, TIMER_T1);
m_t2 = device_timer_alloc(*this, TIMER_T2);
m_shift_timer = device_timer_alloc(*this, TIMER_SHIFT);
/* Default clock is from CPU1 */
if (clock() == 0)
{
set_unscaled_clock(m_machine.firstcpu->clock());
}
/* save state register */
state_save_register_device_item(this, 0, m_in_a);
state_save_register_device_item(this, 0, m_in_ca1);
state_save_register_device_item(this, 0, m_in_ca2);
state_save_register_device_item(this, 0, m_out_a);
state_save_register_device_item(this, 0, m_out_ca2);
state_save_register_device_item(this, 0, m_ddr_a);
state_save_register_device_item(this, 0, m_in_b);
state_save_register_device_item(this, 0, m_in_cb1);
state_save_register_device_item(this, 0, m_in_cb2);
state_save_register_device_item(this, 0, m_out_b);
state_save_register_device_item(this, 0, m_out_cb2);
state_save_register_device_item(this, 0, m_ddr_b);
state_save_register_device_item(this, 0, m_t1cl);
state_save_register_device_item(this, 0, m_t1ch);
state_save_register_device_item(this, 0, m_t1ll);
state_save_register_device_item(this, 0, m_t1lh);
state_save_register_device_item(this, 0, m_t2cl);
state_save_register_device_item(this, 0, m_t2ch);
state_save_register_device_item(this, 0, m_t2ll);
state_save_register_device_item(this, 0, m_t2lh);
state_save_register_device_item(this, 0, m_sr);
state_save_register_device_item(this, 0, m_pcr);
state_save_register_device_item(this, 0, m_acr);
state_save_register_device_item(this, 0, m_ier);
state_save_register_device_item(this, 0, m_ifr);
state_save_register_device_item(this, 0, m_t1_active);
state_save_register_device_item(this, 0, m_t2_active);
state_save_register_device_item(this, 0, m_shift_counter);
}
int riot_r(int chip, int offset)
{
int data = 0xff;
offset&=0xf;
if (!(offset&4)) { /* io part of chip */
switch( offset&3 )
{
case 0: /* Data register A */
if( riot[chip].config->port_a.input )
data = (*riot[chip].config->port_a.input)(chip);
/* mask input bits and combine with output bits */
data = (data & ~riot[chip].port_a.ddr) | (riot[chip].port_a.out & riot[chip].port_a.ddr);
LOG(("riot(%d) DRA read : $%02x\n", chip, data));
break;
case 1: /* Data direction register A */
data = riot[chip].port_a.ddr;
LOG(("riot(%d) DDRA read : $%02x\n", chip, data));
break;
case 2: /* Data register B */
if( riot[chip].config->port_b.input )
data = (*riot[chip].config->port_b.input)(chip);
/* mask input bits and combine with output bits */
data = (data & ~riot[chip].port_b.ddr) | (riot[chip].port_b.out & riot[chip].port_b.ddr);
/* LOG(("riot(%d) DRB read : $%02x\n", chip, data)); */
break;
case 3: /* Data direction register B */
data = riot[chip].port_b.ddr;
LOG(("riot(%d) DDRB read : $%02x\n", chip, data));
break;
}
} else { /* timer part of chip */
switch (offset&1) {
case 0: /* Timer count read */
switch (riot[chip].state) {
case Delay1:
if (riot[chip].timer)
data = (int)(timer_timeleft(riot[chip].timer)*riot[chip].config->baseclock);
break;
case Delay8:
if (riot[chip].timer)
data = (int)(timer_timeleft(riot[chip].timer)*riot[chip].config->baseclock)>>3;
break;
case Delay64:
if (riot[chip].timer)
data = (int)(timer_timeleft(riot[chip].timer)*riot[chip].config->baseclock)>>6;
break;
case Delay1024:
if (riot[chip].timer)
data = (int)(timer_timeleft(riot[chip].timer)*riot[chip].config->baseclock)>>10;
break;
case TimerShot:
data=255-(int)((timer_get_time()-riot[chip].shottime)*riot[chip].config->baseclock);
if (data <0 ) data=0;
break;
}
if( riot[chip].irqen&&riot[chip].irq ) /* with IRQ? */
{
if( riot[chip].config->irq_callback )
(*riot[chip].config->irq_callback)(chip, 0);
}
riot[chip].irq=0;
break;
case 1: /* Timer status read */
data = riot[chip].irq?0x80:0;
LOG(("riot(%d) STAT read : $%02x%s\n", chip, data, (char*)((offset & 8) ? " (IRQ)":" ")));
break;
}
/* problem when restarting with read the timer!? */
riot[chip].irqen = (offset & 8) ? 1 : 0;
}
return data;
}
static int image_load_internal(mess_image *image, const char *path,
int is_create, int create_format, option_resolution *create_args)
{
image_error_t err;
const char *software_path;
char *software_path_list = NULL;
const void *buffer;
const game_driver *gamedrv;
UINT32 open_plan[4];
int i;
/* sanity checks */
assert_always(image, "image_load(): image is NULL");
assert_always(path, "image_load(): path is NULL");
/* we are now loading */
image->is_loading = 1;
/* first unload the image */
image_unload(image);
/* record the filename */
image->err = set_image_filename(image, path, NULL);
if (image->err)
goto done;
/* tell the OSD layer that this is changing */
osd_image_load_status_changed(image, 0);
/* do we need to reset the CPU? */
if ((timer_get_time() > 0) && image->dev->reset_on_load)
mame_schedule_soft_reset(Machine);
/* determine open plan */
determine_open_plan(image, is_create, open_plan);
/* attempt to open the file in various ways */
for (i = 0; !image->file && open_plan[i]; i++)
{
software_path = software_path_list;
do
{
gamedrv = Machine->gamedrv;
while(!is_loaded(image) && gamedrv)
{
/* open the file */
image->err = load_image_by_path(image, software_path, gamedrv, open_plan[i], path);
if (image->err && (image->err != IMAGE_ERROR_FILENOTFOUND))
goto done;
/* move on to the next driver */
gamedrv = mess_next_compatible_driver(gamedrv);
}
/* move on to the next entry in the software path; if we can */
if (software_path)
software_path += strlen(software_path) + 1;
}
while(!is_loaded(image) && software_path && *software_path);
}
/* did we fail to find the file? */
if (!is_loaded(image))
{
image->err = IMAGE_ERROR_FILENOTFOUND;
goto done;
}
/* if applicable, call device verify */
if (image->dev->imgverify && !image_has_been_created(image))
{
/* access the memory */
buffer = image_ptr(image);
if (!buffer)
{
image->err = IMAGE_ERROR_OUTOFMEMORY;
goto done;
}
/* verify the file */
err = image->dev->imgverify(buffer, (size_t) image->length);
if (err)
{
image->err = IMAGE_ERROR_INVALIDIMAGE;
goto done;
}
}
/* call device load or create */
if (image_has_been_created(image) && image->dev->create)
{
err = image->dev->create(image, create_format, create_args);
if (err)
{
if (!image->err)
image->err = IMAGE_ERROR_UNSPECIFIED;
goto done;
}
}
else if (image->dev->load)
{
/* using device load */
err = image->dev->load(image);
if (err)
{
if (!image->err)
image->err = IMAGE_ERROR_UNSPECIFIED;
goto done;
}
}
/* success! */
done:
if (software_path_list)
free(software_path_list);
if (image->err)
image_clear(image);
image->is_loading = 1;
return image->err ? INIT_FAIL : INIT_PASS;
}
static double calc_plunger_pos(running_machine *machine)
{
return (attotime_to_double(timer_get_time(machine)) - attotime_to_double(time_released)) * (attotime_to_double(time_released) - attotime_to_double(time_pushed) + 0.2);
}
static void v_irq4_w(int level)
{
update_irq_encoder(INPUT_LINE_IRQ4, level);
vertigo_vproc(TIME_TO_CYCLES(0, timer_get_time() - irq4_time), level);
irq4_time = timer_get_time();
}
static int ted7360_rastercolumn (void)
{
return (int) ((timer_get_time () - rastertime)
* TED7360_VRETRACERATE * lines * 57 * 8 + 0.5);
}
static double calc_plunger_pos(void)
{
return (attotime_to_double(timer_get_time()) - attotime_to_double(time_released)) * (attotime_to_double(time_released) - attotime_to_double(time_pushed) + 0.2);
}
static double calc_plunger_pos(running_machine *machine)
{
mgolf_state *state = machine->driver_data<mgolf_state>();
return (attotime_to_double(timer_get_time(machine)) - attotime_to_double(state->time_released)) * (attotime_to_double(state->time_released) - attotime_to_double(state->time_pushed) + 0.2);
}
bool legacy_image_device_base::load_internal(const char *path, bool is_create, int create_format, option_resolution *create_args)
{
UINT32 open_plan[4];
int i;
bool softload = FALSE;
/* first unload the image */
unload();
/* clear any possible error messages */
clear_error();
/* we are now loading */
m_is_loading = TRUE;
/* record the filename */
m_err = set_image_filename(path);
if (m_err)
goto done;
/* Check if there's a software list defined for this device and use that if we're not creating an image */
softload = load_software_part( this, path, &m_software_info_ptr, &m_software_part_ptr, &m_full_software_name );
if (is_create || (!softload && m_software_info_ptr==NULL))
{
/* determine open plan */
determine_open_plan(is_create, open_plan);
/* attempt to open the file in various ways */
for (i = 0; !m_file && open_plan[i]; i++)
{
/* open the file */
m_err = load_image_by_path(open_plan[i], path);
if (m_err && (m_err != IMAGE_ERROR_FILENOTFOUND))
goto done;
}
}
/* Copy some image information when we have been loaded through a software list */
if ( m_software_info_ptr )
{
m_longname = m_software_info_ptr->longname;
m_manufacturer = m_software_info_ptr->publisher;
m_year = m_software_info_ptr->year;
//m_playable = m_software_info_ptr->supported;
}
/* did we fail to find the file? */
if (!is_loaded() && !softload)
{
m_err = IMAGE_ERROR_FILENOTFOUND;
goto done;
}
/* call device load or create */
m_create_format = create_format;
m_create_args = create_args;
if (m_init_phase==FALSE) {
m_err = (image_error_t)finish_load();
if (m_err)
goto done;
}
/* success! */
done:
if (m_err!=0) {
if (!m_init_phase)
{
if (machine->phase() == MACHINE_PHASE_RUNNING)
popmessage("Error: Unable to %s image '%s': %s\n", is_create ? "create" : "load", path, error());
else
mame_printf_error("Error: Unable to %s image '%s': %s", is_create ? "create" : "load", path, error());
}
clear();
}
else {
/* do we need to reset the CPU? only schedule it if load/create is successful */
if ((attotime_compare(timer_get_time(device().machine), attotime_zero) > 0) && m_image_config.is_reset_on_load())
device().machine->schedule_hard_reset();
else
{
if (!m_init_phase)
{
if (machine->phase() == MACHINE_PHASE_RUNNING)
popmessage("Image '%s' was successfully %s.", path, is_create ? "created" : "loaded");
else
mame_printf_info("Image '%s' was successfully %s.\n", path, is_create ? "created" : "loaded");
}
}
}
return m_err ? IMAGE_INIT_FAIL : IMAGE_INIT_PASS;
}
