pokey.fu

// pokey.fu - POKEY chip emulator
//
// Copyright (C) 2010-2023  Piotr Fusik
//
// This file is part of ASAP (Another Slight Atari Player),
// see http://asap.sourceforge.net
//
// ASAP is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published
// by the Free Software Foundation; either version 2 of the License,
// or (at your option) any later version.
//
// ASAP is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with ASAP; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

/// Format of output samples.
public enum ASAPSampleFormat
{
	/// Unsigned 8-bit.
	U8,
	/// Signed 16-bit little-endian.
	S16LE,
	/// Signed 16-bit big-endian.
	S16BE
}

class PokeyChannel
{
	internal int Audf;
	internal int Audc;
	internal int PeriodCycles;
	internal int TickCycle;
	internal int TimerCycle;

	// Is channel muted?
	internal const int MuteInit = 1;
	internal const int MuteUser = 2;
	internal const int MuteSerialInput = 4;
	internal int Mute;

	int Out;
	internal int Delta;

	internal void Initialize!()
	{
		Audf = 0;
		Audc = 0;
		PeriodCycles = 28;
		TickCycle = Pokey.NeverCycle;
		TimerCycle = Pokey.NeverCycle;
		Mute = 0;
		Out = 0;
		Delta = 0;
	}

	internal void Slope!(Pokey! pokey, PokeyPair pokeys, int cycle)
	{
		Delta = -Delta;
		pokey.AddDelta(pokeys, cycle, Delta);
	}

	internal void DoTick!(Pokey! pokey, PokeyPair pokeys, int cycle, int ch)
	{
		TickCycle += PeriodCycles;
		int audc = Audc;
		if ((audc & 0xb0) == 0xa0)
			Out ^= 1;
		else if ((audc & 0x10) != 0 || pokey.Init)
			return;
		else {
			int poly = cycle + pokey.PolyIndex - ch;
			if (audc < 0x80 && (0x65bd44e0 & 1 << (poly % 31)) == 0) // 0000011100100010101111011010011
				return;
			if ((audc & 0x20) != 0)
				Out ^= 1;
			else {
				int newOut;
				if ((audc & 0x40) != 0)
					newOut = 0x5370 >> (poly % 15); // 000011101100101
				else if (pokey.Audctl < 0x80) {
					poly %= 131071;
					newOut = pokeys.Poly17Lookup[poly >> 3] >> (poly & 7);
				}
				else
					newOut = pokeys.Poly9Lookup[poly % 511];
				newOut &= 1;
				if (Out == newOut)
					return;
				Out = newOut;
			}
		}
		Slope(pokey, pokeys, cycle);
	}

	internal void DoStimer!(int cycle)
	{
		if (TickCycle != Pokey.NeverCycle)
			TickCycle = cycle + PeriodCycles;
	}

	internal void SetMute!(bool enable, int mask, int cycle)
	{
		if (enable) {
			Mute |= mask;
			TickCycle = Pokey.NeverCycle;
		}
		else {
			Mute &= ~mask;
			if (Mute == 0 && TickCycle == Pokey.NeverCycle)
				TickCycle = cycle;
		}
	}

	internal void SetAudc!(Pokey! pokey, PokeyPair pokeys, int data, int cycle)
	{
		if (Audc == data)
			return;
		pokey.GenerateUntilCycle(pokeys, cycle);
		Audc = data;
		if ((data & 0x10) != 0) {
			data &= 0xf;
			if ((Mute & MuteUser) == 0)
				pokey.AddDelta(pokeys, cycle, Delta > 0 ? data - Delta : data);
			Delta = data;
		}
		else {
			data &= 0xf;
			if (Delta > 0) {
				if ((Mute & MuteUser) == 0)
					pokey.AddDelta(pokeys, cycle, data - Delta);
				Delta = data;
			}
			else
				Delta = -data;
		}
	}

	internal void EndFrame!(int cycle)
	{
		if (TimerCycle != Pokey.NeverCycle)
			TimerCycle -= cycle;
	}
}

class Pokey
{
	internal PokeyChannel()[4] Channels;
	internal int Audctl;
	int Skctl;
	internal int Irqst;
	internal bool Init;
	int DivCycles;
	int ReloadCycles1;
	int ReloadCycles3;
	internal int PolyIndex;
	internal const int NeverCycle = 0x800000;

#if OPENCL
	const int DeltaBufferLength = ASAP.SampleRate * 312 * 114 / 1773447 + UnitDeltaLength + 2;
	int[DeltaBufferLength] DeltaBuffer;
#else
	int DeltaBufferLength;
	int[]#? DeltaBuffer;
#endif
	0 .. 60 SumDACInputs;
	int SumDACOutputs;

	// POKEY DACs are characterized mostly by two types of nonlinearities:
	// the imperfect scaling between channels of transistors implementing
	// individual DAC bits, and the output level compression resulting
	// from the operating point set by the voltage and resistor connected
	// to the AUDIO pin. This array, based on measurements of AMI-produced
	// chips, approximates these nonlinearities well enough for my taste.
	// The actual characteristics vary quite significantly between chips.
	const short[] CompressedSums = {
		0, 35, 73, 111, 149, 189, 228, 266, 304, 342, 379, 415, 450, 484, 516, 546,
		575, 602, 628, 652, 674, 695, 715, 733, 750, 766, 782, 796, 809, 822, 834, 846,
		856, 867, 876, 886, 894, 903, 911, 918, 926, 933, 939, 946, 952, 958, 963, 969,
		974, 979, 984, 988, 993, 997, 1001, 1005, 1009, 1013, 1016, 1019, 1023
	};

	// To avoid the cost of computing and accumulating sinc function
	// each time at exact time points, we use precalculated sinc-interpolated
	// unit delta function (derivative of step function), sampled at a finite
	// number of different phase offsets within output sample interval.

	// The following parameters control quality of sinc interpolation.
	// The default values are fine for sample rates down to 44100.
	// For lower sample rates you may want to increase them
	// to reduce aliasing and sinc approximation artifacts.
	// For best performance, make sure all lookup tables fit in L1$/L2$.

	// (1 << InterpolationShift) is the number of pre-calculated deltas:
	// Useful range is 6..DeltaResolution.
	internal const int InterpolationShift = 10;

	// Length of one pre-sampled sinc-interpolated unit delta. Must be >=3.
	internal const int UnitDeltaLength = 32;

	// (1 << DeltaResolution) is the amplitude of unit delta.
	internal const int DeltaResolution = 14;

	int IirRate;
	int IirAcc;
	int Trailing;

	internal void StartFrame!()
	{
		DeltaBuffer.CopyTo(Trailing, DeltaBuffer, 0, DeltaBufferLength - Trailing);
		DeltaBuffer.Fill(0, DeltaBufferLength - Trailing, Trailing);
	}

	internal void Initialize!(int sampleRate = 44100)
	{
#if !OPENCL
		long sr = sampleRate;
		// Enough for one PAL frame == 312 * 114 cycles + some margin,
		// as we emulate whole 6502 instructions and interpolate samples.
		DeltaBufferLength = sr * 312 * 114 / 1773447 + UnitDeltaLength + 2;
		DeltaBuffer = new int[DeltaBufferLength];
#endif
		Trailing = DeltaBufferLength;
		foreach (PokeyChannel! c in Channels)
			c.Initialize();
		Audctl = 0;
		Skctl = 3;
		Irqst = 0xff;
		Init = false;
		DivCycles = 28;
		ReloadCycles1 = 28;
		ReloadCycles3 = 28;
		PolyIndex = 15 * 31 * 131071;
		IirAcc = 0;
		IirRate = 44100 * 6 / sampleRate;
		SumDACInputs = 0;
		SumDACOutputs = 0;
		StartFrame();
	}

	internal void AddDelta!(PokeyPair pokeys, int cycle, int delta)
	{
		const int DeltaShiftPOKEY = 16;
		SumDACInputs += delta;
		int newOutput = CompressedSums[SumDACInputs] << DeltaShiftPOKEY;
		AddExternalDelta(pokeys, cycle, newOutput - SumDACOutputs);
		SumDACOutputs = newOutput;
	}

	internal void AddExternalDelta!(PokeyPair pokeys, int cycle, int delta)
	{
		if (delta == 0)
			return;
		int i = cycle * pokeys.SampleFactor + pokeys.SampleOffset;
		int fraction = i >> (PokeyPair.SampleFactorShift - InterpolationShift) & ((1 << InterpolationShift) - 1);
		i >>= PokeyPair.SampleFactorShift;
		delta >>= DeltaResolution;
		for (int j = 0; j < UnitDeltaLength; j++)
			DeltaBuffer[i + j] += delta * pokeys.SincLookup[fraction][j];
	}

	/// Fills `DeltaBuffer` up to `cycleLimit` basing on current Audf/Audc/Audctl values.
	internal void GenerateUntilCycle!(PokeyPair pokeys, int cycleLimit)
	{
		for (;;) {
			int cycle = cycleLimit;
			foreach (PokeyChannel c in Channels) {
				int tickCycle = c.TickCycle;
				if (cycle > tickCycle)
					cycle = tickCycle;
			}
			if (cycle == cycleLimit)
				break;

			if (cycle == Channels[2].TickCycle) {
				if ((Audctl & 4) != 0 && Channels[0].Delta > 0 && Channels[0].Mute == 0)
					Channels[0].Slope(this, pokeys, cycle);
				Channels[2].DoTick(this, pokeys, cycle, 2);
			}
			if (cycle == Channels[3].TickCycle) {
				if ((Audctl & 8) != 0)
					Channels[2].TickCycle = cycle + ReloadCycles3;
				if ((Audctl & 2) != 0 && Channels[1].Delta > 0 && Channels[1].Mute == 0)
					Channels[1].Slope(this, pokeys, cycle);
				Channels[3].DoTick(this, pokeys, cycle, 3);
			}
			if (cycle == Channels[0].TickCycle) {
				if ((Skctl & 0x88) == 8) // two-tone, sending 1 (i.e. timer1)
					Channels[1].TickCycle = cycle + Channels[1].PeriodCycles;
				Channels[0].DoTick(this, pokeys, cycle, 0);
			}
			if (cycle == Channels[1].TickCycle) {
				if ((Audctl & 0x10) != 0)
					Channels[0].TickCycle = cycle + ReloadCycles1;
				else if ((Skctl & 8) != 0) // two-tone
					Channels[0].TickCycle = cycle + Channels[0].PeriodCycles;
				Channels[1].DoTick(this, pokeys, cycle, 1);
			}
		}
	}

	internal void EndFrame!(PokeyPair pokeys, int cycle)
	{
		GenerateUntilCycle(pokeys, cycle);
		PolyIndex += cycle;
		int m = (Audctl & 0x80) != 0 ? 15 * 31 * 511 : 15 * 31 * 131071;
		if (PolyIndex >= 2 * m)
			PolyIndex -= m;
		foreach (PokeyChannel! c in Channels) {
			int tickCycle = c.TickCycle;
			if (tickCycle != NeverCycle)
				c.TickCycle = tickCycle - cycle;
		}
	}

	internal bool IsSilent()
	{
		foreach (PokeyChannel c in Channels)
			if ((c.Audc & 0xf) != 0)
				return false;
		return true;
	}

	internal void Mute!(int mask)
	{
		for (int i = 0; i < 4; i++)
			Channels[i].SetMute((mask & (1 << i)) != 0, PokeyChannel.MuteUser, 0);
	}

	void InitMute!(int cycle)
	{
		bool init = Init;
		int audctl = Audctl;
		Channels[0].SetMute(init && (audctl & 0x40) == 0, PokeyChannel.MuteInit, cycle);
		Channels[1].SetMute(init && (audctl & 0x50) != 0x50, PokeyChannel.MuteInit, cycle);
		Channels[2].SetMute(init && (audctl & 0x20) == 0, PokeyChannel.MuteInit, cycle);
		Channels[3].SetMute(init && (audctl & 0x28) != 0x28, PokeyChannel.MuteInit, cycle);
	}

	internal int Poke!(PokeyPair pokeys, int addr, int data, int cycle)
	{
		int nextEventCycle = NeverCycle;
		switch (addr & 0xf) {
		case 0x00:
			if (data == Channels[0].Audf)
				break;
			GenerateUntilCycle(pokeys, cycle);
			Channels[0].Audf = data;
			switch (Audctl & 0x50) {
			case 0x00:
				Channels[0].PeriodCycles = DivCycles * (data + 1);
				break;
			case 0x10:
				Channels[1].PeriodCycles = DivCycles * (data + (Channels[1].Audf << 8) + 1);
				ReloadCycles1 = DivCycles * (data + 1);
				break;
			case 0x40:
				Channels[0].PeriodCycles = data + 4;
				break;
			case 0x50:
				Channels[1].PeriodCycles = data + (Channels[1].Audf << 8) + 7;
				ReloadCycles1 = data + 4;
				break;
			default:
				assert false;
			}
			break;
		case 0x01:
			Channels[0].SetAudc(this, pokeys, data, cycle);
			break;
		case 0x02:
			if (data == Channels[1].Audf)
				break;
			GenerateUntilCycle(pokeys, cycle);
			Channels[1].Audf = data;
			switch (Audctl & 0x50) {
			case 0x00:
			case 0x40:
				Channels[1].PeriodCycles = DivCycles * (data + 1);
				break;
			case 0x10:
				Channels[1].PeriodCycles = DivCycles * (Channels[0].Audf + (data << 8) + 1);
				break;
			case 0x50:
				Channels[1].PeriodCycles = Channels[0].Audf + (data << 8) + 7;
				break;
			default:
				assert false;
			}
			break;
		case 0x03:
			Channels[1].SetAudc(this, pokeys, data, cycle);
			break;
		case 0x04:
			if (data == Channels[2].Audf)
				break;
			GenerateUntilCycle(pokeys, cycle);
			Channels[2].Audf = data;
			switch (Audctl & 0x28) {
			case 0x00:
				Channels[2].PeriodCycles = DivCycles * (data + 1);
				break;
			case 0x08:
				Channels[3].PeriodCycles = DivCycles * (data + (Channels[3].Audf << 8) + 1);
				ReloadCycles3 = DivCycles * (data + 1);
				break;
			case 0x20:
				Channels[2].PeriodCycles = data + 4;
				break;
			case 0x28:
				Channels[3].PeriodCycles = data + (Channels[3].Audf << 8) + 7;
				ReloadCycles3 = data + 4;
				break;
			default:
				assert false;
			}
			break;
		case 0x05:
			Channels[2].SetAudc(this, pokeys, data, cycle);
			break;
		case 0x06:
			if (data == Channels[3].Audf)
				break;
			GenerateUntilCycle(pokeys, cycle);
			Channels[3].Audf = data;
			switch (Audctl & 0x28) {
			case 0x00:
			case 0x20:
				Channels[3].PeriodCycles = DivCycles * (data + 1);
				break;
			case 0x08:
				Channels[3].PeriodCycles = DivCycles * (Channels[2].Audf + (data << 8) + 1);
				break;
			case 0x28:
				Channels[3].PeriodCycles = Channels[2].Audf + (data << 8) + 7;
				break;
			default:
				assert false;
			}
			break;
		case 0x07:
			Channels[3].SetAudc(this, pokeys, data, cycle);
			break;
		case 0x08:
			if (data == Audctl)
				break;
			GenerateUntilCycle(pokeys, cycle);
			Audctl = data;
			DivCycles = (data & 1) != 0 ? 114 : 28;
			// TODO: TickCycles
			switch (data & 0x50) {
			case 0x00:
				Channels[0].PeriodCycles = DivCycles * (Channels[0].Audf + 1);
				Channels[1].PeriodCycles = DivCycles * (Channels[1].Audf + 1);
				break;
			case 0x10:
				Channels[0].PeriodCycles = DivCycles << 8;
				Channels[1].PeriodCycles = DivCycles * (Channels[0].Audf + (Channels[1].Audf << 8) + 1);
				ReloadCycles1 = DivCycles * (Channels[0].Audf + 1);
				break;
			case 0x40:
				Channels[0].PeriodCycles = Channels[0].Audf + 4;
				Channels[1].PeriodCycles = DivCycles * (Channels[1].Audf + 1);
				break;
			case 0x50:
				Channels[0].PeriodCycles = 256;
				Channels[1].PeriodCycles = Channels[0].Audf + (Channels[1].Audf << 8) + 7;
				ReloadCycles1 = Channels[0].Audf + 4;
				break;
			default:
				assert false;
			}
			switch (data & 0x28) {
			case 0x00:
				Channels[2].PeriodCycles = DivCycles * (Channels[2].Audf + 1);
				Channels[3].PeriodCycles = DivCycles * (Channels[3].Audf + 1);
				break;
			case 0x08:
				Channels[2].PeriodCycles = DivCycles << 8;
				Channels[3].PeriodCycles = DivCycles * (Channels[2].Audf + (Channels[3].Audf << 8) + 1);
				ReloadCycles3 = DivCycles * (Channels[2].Audf + 1);
				break;
			case 0x20:
				Channels[2].PeriodCycles = Channels[2].Audf + 4;
				Channels[3].PeriodCycles = DivCycles * (Channels[3].Audf + 1);
				break;
			case 0x28:
				Channels[2].PeriodCycles = 256;
				Channels[3].PeriodCycles = Channels[2].Audf + (Channels[3].Audf << 8) + 7;
				ReloadCycles3 = Channels[2].Audf + 4;
				break;
			default:
				assert false;
			}
			InitMute(cycle);
			break;
		case 0x09:
			// TODO: ReloadCycles, Out
			foreach (PokeyChannel! c in Channels)
				c.DoStimer(cycle);
			break;
		case 0x0e:
			Irqst |= data ^ 0xff;
			for (int i = 3; ; i >>= 1) {
				if ((data & Irqst & i + 1) != 0) {
					if (Channels[i].TimerCycle == NeverCycle) {
						int t = Channels[i].TickCycle;
						while (t < cycle)
							t += Channels[i].PeriodCycles;
						Channels[i].TimerCycle = t;
						if (nextEventCycle > t)
							nextEventCycle = t;
					}
				}
				else
					Channels[i].TimerCycle = NeverCycle;
				if (i == 0)
					break;
			}
			break;
		case 0x0f:
			if (data == Skctl)
				break;
			GenerateUntilCycle(pokeys, cycle);
			Skctl = data;
			bool init = (data & 3) == 0;
			if (Init && !init)
				PolyIndex = ((Audctl & 0x80) != 0 ? 15 * 31 * 511 - 1 : 15 * 31 * 131071 - 1) - cycle;
			Init = init;
			InitMute(cycle);
			Channels[2].SetMute((data & 0x10) != 0, PokeyChannel.MuteSerialInput, cycle);
			Channels[3].SetMute((data & 0x10) != 0, PokeyChannel.MuteSerialInput, cycle);
			break;
		default:
			break;
		}
		return nextEventCycle;
	}

	internal int CheckIrq!(int cycle, int nextEventCycle)
	{
		for (int i = 3; ; i >>= 1) {
			int timerCycle = Channels[i].TimerCycle;
			if (cycle >= timerCycle) {
				Irqst &= ~(i + 1);
				Channels[i].TimerCycle = NeverCycle;
			}
			else if (nextEventCycle > timerCycle)
				nextEventCycle = timerCycle;
			if (i == 0)
				break;
		}
		return nextEventCycle;
	}

	internal int StoreSample!(byte[]! buffer, int bufferOffset, int i, ASAPSampleFormat format)
	{
		IirAcc += DeltaBuffer[i] - (IirRate * IirAcc >> 11);
		int sample = IirAcc >> 11;
		if (sample < -32767)
			sample = -32767;
		else if (sample > 32767)
			sample = 32767;
		switch (format) {
		case ASAPSampleFormat.U8:
			buffer[bufferOffset++] = (sample >> 8) + 128;
			break;
		case ASAPSampleFormat.S16LE:
			buffer[bufferOffset++] = sample & 0xff;
			buffer[bufferOffset++] = sample >> 8 & 0xff;
			break;
		case ASAPSampleFormat.S16BE:
			buffer[bufferOffset++] = sample >> 8 & 0xff;
			buffer[bufferOffset++] = sample & 0xff;
			break;
		}
		return bufferOffset;
	}

	internal void AccumulateTrailing!(int i)
	{
		Trailing = i;
	}
}

#if APOKEYSND
public
#endif
class PokeyPair
{
	internal byte[511] Poly9Lookup;
	internal byte[16385] Poly17Lookup;
	int ExtraPokeyMask;
	internal Pokey() BasePokey;
	internal Pokey() ExtraPokey;

	internal int SampleRate;
	// Band-limited unit delta, sampled around (1 << InterpolationShift)
	// different fractional positions between output samples.
	internal short[1 << Pokey.InterpolationShift][Pokey.UnitDeltaLength] SincLookup;

	// DeltaBuffer.Length << SampleFactorShift shouldn't overflow int.
	// SampleFactorShift could be 19, but that wouldn't improve
	// accuracy because SampleFactor would be even.
	internal const int SampleFactorShift = 18;
	internal int SampleFactor;
	internal int SampleOffset;

	internal int ReadySamplesStart;
	internal int ReadySamplesEnd;

#if APOKEYSND
	public
#else
	internal
#endif
	PokeyPair()
	{
		int reg = 0x1ff;
		for (int i = 0; i < 511; i++) {
			reg = (((reg >> 5 ^ reg) & 1) << 8) + (reg >> 1);
			Poly9Lookup[i] = reg & 0xff;
		}
		reg = 0x1ffff;
		for (int i = 0; i < 16385; i++) {
			reg = (((reg >> 5 ^ reg) & 0xff) << 9) + (reg >> 8);
			Poly17Lookup[i] = reg >> 1 & 0xff;
		}
		for (int i = 0; i < 1 << Pokey.InterpolationShift; i++) {
			double sincSum = 0;
			double leftSum = 0;
			double norm = 0;
			double[Pokey.UnitDeltaLength - 1] sinc;
			for (int j = -Pokey.UnitDeltaLength; j < Pokey.UnitDeltaLength; j++) {
				if (j == -Pokey.UnitDeltaLength / 2)
					leftSum = sincSum;
				else if (j == Pokey.UnitDeltaLength / 2 - 1)
					norm = sincSum;
				double x = Math.PI / (1 << Pokey.InterpolationShift) * ((j << Pokey.InterpolationShift) - i);
				double s = x == 0 ? 1 : Math.Sin(x) / x;
				if (j >= -Pokey.UnitDeltaLength / 2 && j < Pokey.UnitDeltaLength / 2 - 1)
					sinc[Pokey.UnitDeltaLength / 2 + j] = s;
				sincSum += s;
			}
			norm = (1 << Pokey.DeltaResolution) / (norm + (1 - sincSum) * 0.5);
			SincLookup[i][0] = Math.Round((leftSum + (1 - sincSum) * 0.5) * norm);
			for (int j = 1; j < Pokey.UnitDeltaLength; j++)
				SincLookup[i][j] = Math.Round(sinc[j - 1] * norm);
		}
	}

	// return ((Pokey.SampleRate << SampleFactorShift) + (clock >> 1)) / clock;
	// Shifted by 5 to fit in 32-bit arithmetic.
	int GetSampleFactor(int clock)
		=> ((SampleRate << SampleFactorShift - 5) + (clock >> 6)) / (clock >> 5);

#if APOKEYSND
	public
#else
	internal
#endif
	void Initialize!(bool ntsc, bool stereo, int sampleRate = 44100)
	{
		ExtraPokeyMask = stereo ? 0x10 : 0;
		SampleRate = sampleRate;
		BasePokey.Initialize(sampleRate);
		ExtraPokey.Initialize(sampleRate);
		SampleFactor = ntsc ? GetSampleFactor(1789772) : GetSampleFactor(1773447);
		SampleOffset = 0;
		ReadySamplesStart = 0;
		ReadySamplesEnd = 0;
	}

#if APOKEYSND
	public
#else
	internal
#endif
	int Poke!(int addr, int data, int cycle)
	{
		Pokey! pokey = (addr & ExtraPokeyMask) != 0 ? ExtraPokey : BasePokey;
		return pokey.Poke(this, addr, data, cycle);
	}

#if APOKEYSND
	public
#else
	internal
#endif
	int Peek(int addr, int cycle)
	{
		Pokey pokey = (addr & ExtraPokeyMask) != 0 ? ExtraPokey : BasePokey;
		switch (addr & 0xf) {
		case 0x0a:
			if (pokey.Init)
				return 0xff;
			int i = cycle + pokey.PolyIndex;
			if ((pokey.Audctl & 0x80) != 0)
				return Poly9Lookup[i % 511];
			i %= 131071;
			int j = i >> 3;
			i &= 7;
			return ((Poly17Lookup[j] >> i) + (Poly17Lookup[j + 1] << (8 - i))) & 0xff;
		case 0x0e:
			return pokey.Irqst;
		default:
			return 0xff;
		}
	}

#if APOKEYSND
	public
#else
	internal
#endif
	void StartFrame!()
	{
		BasePokey.StartFrame();
		if (ExtraPokeyMask != 0)
			ExtraPokey.StartFrame();
	}

#if APOKEYSND
	public
#else
	internal
#endif
	int EndFrame!(int cycle)
	{
		BasePokey.EndFrame(this, cycle);
		if (ExtraPokeyMask != 0)
			ExtraPokey.EndFrame(this, cycle);
		SampleOffset += cycle * SampleFactor;
		ReadySamplesStart = 0;
		ReadySamplesEnd = SampleOffset >> SampleFactorShift;
		SampleOffset &= (1 << SampleFactorShift) - 1;
		return ReadySamplesEnd;
	}

	/// Fills buffer with samples from `DeltaBuffer`.
#if APOKEYSND
	public
#else
	internal
#endif
	int Generate!(byte[]! buffer, int bufferOffset, int blocks, ASAPSampleFormat format)
	{
		int i = ReadySamplesStart;
		int samplesEnd = ReadySamplesEnd;
		if (blocks < samplesEnd - i)
			samplesEnd = i + blocks;
		else
			blocks = samplesEnd - i;
		if (blocks > 0) {
			for (; i < samplesEnd; i++) {
				bufferOffset = BasePokey.StoreSample(buffer, bufferOffset, i, format);
				if (ExtraPokeyMask != 0)
					bufferOffset = ExtraPokey.StoreSample(buffer, bufferOffset, i, format);
			}
			if (i == ReadySamplesEnd) {
				BasePokey.AccumulateTrailing(i);
				ExtraPokey.AccumulateTrailing(i);
			}
			ReadySamplesStart = i;
		}
#if APOKEYSND
		return bufferOffset;
#else
		return blocks;
#endif
	}

	internal bool IsSilent()
		=> BasePokey.IsSilent() && ExtraPokey.IsSilent();
}