/* Flush pending characters into the kernal's queue if possible.
This is (at least) called once per frame in vsync handler */
void kbdbuf_flush(void)
{
unsigned int i, n;
if ((!kbd_buf_enabled)
|| (num_pending == 0)
|| !kbdbuf_is_empty()
|| (maincpu_clk < kernal_init_cycles)
|| (kbdbuf_flush_alarm_time != 0)) {
return;
}
n = num_pending > buffer_size ? buffer_size : num_pending;
/* printf("kbdbuf_flush pending: %d n: %d head_idx: %d\n", num_pending, n, head_idx); */
for (i = 0; i < n; i++) {
/* printf("kbdbuf_flush i:%d head_idx:%d queue[head_idx]: %d use_kbdbuf_flush_alarm: %d\n",i,head_idx,queue[head_idx],use_kbdbuf_flush_alarm); */
/* use an alarm to randomly delay RETURN for up to one frame */
if ((queue[head_idx] == 13) && (use_kbdbuf_flush_alarm == 1)) {
/* we actually need to wait _at least_ one frame to not overrun the buffer */
kbdbuf_flush_alarm_time = maincpu_clk + machine_get_cycles_per_frame();
kbdbuf_flush_alarm_time += lib_unsigned_rand(1, machine_get_cycles_per_frame());
alarm_set(kbdbuf_flush_alarm, kbdbuf_flush_alarm_time);
return;
}
tokbdbuffer(queue[head_idx]);
removefromqueue();
}
}
/*
called by the UI when the freeze button is pressed
sets cartridge_freeze_alarm to delay button press up to one frame, then
- cart_freeze_alarm_triggered
- cart_freeze_allowed (c64carthooks.c)
checks wether freeze is allowed for currently active cart(s)
if yes, sets up cartridge_nmi_alarm to delay NMI 3 cycles
- cart_nmi_alarm_triggered
- cart_nmi_alarm (c64carthooks.c)
*/
void cartridge_trigger_freeze(void)
{
int delay = lib_unsigned_rand(1, machine_get_cycles_per_frame());
cart_freeze_alarm_time = maincpu_clk + delay;
alarm_set(cartridge_freeze_alarm, cart_freeze_alarm_time);
DBG(("cartridge_trigger_freeze delay %d cycles\n", delay));
}
/*-----------------------------------------------------------------------*/
static void joystick_process_latch(void)
{
CLOCK delay = lib_unsigned_rand(1, machine_get_cycles_per_frame());
if (network_connected()) {
network_event_record(EVENT_JOYSTICK_DELAY, (void *)&delay, sizeof(delay));
network_event_record(EVENT_JOYSTICK_VALUE, (void *)latch_joystick_value, sizeof(latch_joystick_value));
} else {
alarm_set(joystick_alarm, maincpu_clk + delay);
}
}
inline static int fetch_gap(CLOCK *gap, int *direction, long read_tap)
{
int wobble;
if ((read_tap >= last_tap) || (read_tap < 0)) {
return -1;
}
*gap = tap_buffer[read_tap];
if ((current_image->version == 0) || *gap) {
*gap = (*gap ? (CLOCK)(*gap * 8) : (CLOCK)datasette_zero_gap_delay)
+ (CLOCK)datasette_speed_tuning;
} else {
if (read_tap >= last_tap - 3) {
return -1;
}
*direction *= 4;
*gap = tap_buffer[read_tap + 1]
+ (tap_buffer[read_tap + 2] << 8)
+ (tap_buffer[read_tap + 3] << 16);
if (!(*gap)) {
*gap = (CLOCK)datasette_zero_gap_delay;
}
}
/* add some random wobble */
if (datasette_tape_wobble) {
wobble = lib_unsigned_rand(-datasette_tape_wobble, datasette_tape_wobble);
if ((wobble >= 0) || (*gap > (CLOCK)-wobble)) {
*gap += wobble;
} else {
*gap = 1;
}
}
return 0;
}
/* Clean memory and reboot for autostart. */
static void reboot_for_autostart(const char *program_name, unsigned int mode,
unsigned int runmode)
{
int rnd;
char *temp_name = NULL, *temp;
if (!autostart_enabled) {
return;
}
/* program_name may be petscii or ascii at this point, ANDing the charcodes
with 0x7f here is a cheap way to prevent illegal characters in the
printed message */
if (program_name) {
temp_name = temp = lib_stralloc(program_name);
while (*temp) {
*temp++ &= 0x7f;
}
}
log_message(autostart_log, "Resetting the machine to autostart '%s'",
program_name ? temp_name : "*");
if (program_name) {
lib_free(temp_name);
}
/* on x128 autostart will only work in 40 columns mode (and can not be fixed
easily for VDC mode). We work around that by switching to 40 columns and
back if needed */
if (machine_class == VICE_MACHINE_C128) {
resources_get_int("40/80ColumnKey", &c128_column4080_key);
resources_set_int("40/80ColumnKey", 1);
}
mem_powerup();
autostart_ignore_reset = 1;
deallocate_program_name();
if (program_name && program_name[0]) {
autostart_program_name = lib_stralloc(program_name);
}
autostart_initial_delay_cycles = min_cycles;
resources_get_int("AutostartDelayRandom", &rnd);
if (rnd) {
/* additional random delay of up to 10 frames */
autostart_initial_delay_cycles += lib_unsigned_rand(1, machine_get_cycles_per_frame() * 10);
}
DBG(("autostart_initial_delay_cycles: %d", autostart_initial_delay_cycles));
machine_trigger_reset(MACHINE_RESET_MODE_HARD);
/* The autostartmode must be set AFTER the shutdown to make the autostart
threadsafe for OS/2 */
autostartmode = mode;
autostart_run_mode = runmode;
autostart_wait_for_reset = 1;
/* enable warp before reset */
if (mode != AUTOSTART_HASSNAPSHOT) {
enable_warp_if_requested();
}
}
