main: while the CPU waits in WAI, step the machine to its next event at once 8e8d9cad1884

// How many CPU clocks audio_step() can take in one call and still do

// exactly what that many one-clock calls would: up to and including the

// clock on which it next has to render, which is when the CPU can see a

// change (the PCM FIFO, VERA's AFLOW interrupt, the YM2151's state).

uint32_t

audio_clocks_to_render(void)

{

	if (audio_dev == 0) {

		return UINT32_MAX;

	}

	uint32_t ym_room = (ym_samp_pos_rd - ym_samp_pos_hd - (1 << SAMP_POS_FRAC_BITS)) & SAMP_POS_MASK_FRAC;

	return (uint32_t)(ym_room / ym_samp_clks_per_cpu_clk) + 1;

}

uint32_t audio_clocks_to_render(void);

// While the CPU waits in WAI, nothing it can see changes until an

// interrupt, yet the loop below would go round once a clock, stepping every

// device each time: at the BASIC prompt, most of the run time. This steps

// them by many clocks at once instead, but only as far as the next clock on

// which something could raise an interrupt, so the machine does exactly

// what it did a clock at a time: VERA to the end of the line, audio to its

// next render, and VIA1 a clock at a time here, stopping on the clock its

// interrupt rises (via_step() does not take a stretch that ends on its

// timer's -1 state the way it takes single clocks). Everything not shown to

// add up that way keeps the clock-by-clock loop: VIA2, the serial bus, the

// MIDI card, an SPI byte in flight, YM2151 interrupts, the debugger, BASIC

// pasting, the KERNAL hooks at $FEA8 and up.

// Returns the clocks taken, with VIA1 stepped through them, or 0.

static uint32_t

wai_fast_forward(void)

{

	if (!waiting || headless || debugger_enabled || has_serial || has_via2 || has_midi_card ||

	    ym2151_irq_support || pasting_bas || regs.pc >= 0xFEA8 || vera_spi_busy()) {

		return 0;

	}

	uint32_t limit = video_clocks_to_line_end(MHZ);

	uint32_t audio = audio_clocks_to_render();

	if (audio < limit) {

		limit = audio;

	}

	if (limit < 2) {

		return 0;

	}

	uint32_t n = 0;

	do {

		via1_step(1);

		n++;

	} while (n < limit && !via1_irq());

	clockticks6502 += n;

	return n;

}

		uint32_t skipped = wai_fast_forward();

		if (!skipped) {

			step6502();

		}

		if (!skipped) {

			via1_step(clocks);

		}

		// The I2C bus acts only on a change of the clock and data lines the

		// VIA drives, which happen between instructions, so once is enough.

		if (clocks) {

// A byte is on its way: vera_spi_step() is counting clocks toward its end.

bool

vera_spi_busy(void)

{

	return busy;

}

#include <stdbool.h>

bool vera_spi_busy(void);

#include <math.h>

// The least n for which pos + n * step passes end, for a pos on the grid

// of eighths; 1 for one off it.

static uint32_t

clocks_to_pass(float pos, float end, double step)

{

	if (pos > end || pos * 8 != floorf(pos * 8)) {

		return 1;

	}

	return (uint32_t)((end - pos) / step) + 1;

}

// How many CPU clocks video_step() can take in one call and still do

// exactly what that many one-clock calls would: up to and including the

// clock on which the beam passes the end of a VGA or NTSC line, the first

// time it can raise an interrupt or end a frame. That holds only while the

// beam moves by a whole number of eighths a clock (25 MHz / mhz, so mhz

// divides 200, as the X16's 8 does): then every position is exact in a

// float, and one big step adds up to the same as many small ones.

// Otherwise the answer is 1.

uint32_t

video_clocks_to_line_end(uint8_t mhz)

{

	if (mhz == 0 || 200 % mhz) {

		return 1;

	}

	const double step = scan_pixels(mhz, 1);

	const uint32_t vga = clocks_to_pass(vga_scan_pos_x, VGA_SCAN_WIDTH, step);

	const uint32_t ntsc = clocks_to_pass(ntsc_half_cnt, NTSC_HALF_SCAN_WIDTH, step);

	return vga < ntsc ? vga : ntsc;

}

uint32_t video_clocks_to_line_end(uint8_t mhz);