384 lines
11 KiB
C#
384 lines
11 KiB
C#
using System;
|
|
|
|
namespace VirtualNes.Core
|
|
{
|
|
public class APU_VRC6 : APU_INTERFACE
|
|
{
|
|
public const int RECTANGLE_VOL_SHIFT = 8;
|
|
public const int SAWTOOTH_VOL_SHIFT = 6;
|
|
|
|
private RECTANGLE ch0 = new RECTANGLE();
|
|
private RECTANGLE ch1 = new RECTANGLE();
|
|
private SAWTOOTH ch2 = new SAWTOOTH();
|
|
|
|
private int cycle_rate;
|
|
private float cpu_clock;
|
|
|
|
public APU_VRC6()
|
|
{
|
|
Reset(APU_CLOCK, 22050);
|
|
}
|
|
|
|
public override void Reset(float fClock, int nRate)
|
|
{
|
|
ch0.ZeroMemory();
|
|
ch1.ZeroMemory();
|
|
ch2.ZeroMemory();
|
|
|
|
Setup(fClock, nRate);
|
|
}
|
|
|
|
public override void Setup(float fClock, int nRate)
|
|
{
|
|
cpu_clock = fClock;
|
|
cycle_rate = (int)(fClock * 65536.0f / nRate);
|
|
}
|
|
|
|
public override void Write(ushort addr, byte data)
|
|
{
|
|
switch (addr)
|
|
{
|
|
// VRC6 CH0 rectangle
|
|
case 0x9000:
|
|
ch0.reg[0] = data;
|
|
ch0.gate = (byte)(data & 0x80);
|
|
ch0.volume = (byte)(data & 0x0F);
|
|
ch0.duty_pos = (byte)((data >> 4) & 0x07);
|
|
break;
|
|
case 0x9001:
|
|
ch0.reg[1] = data;
|
|
ch0.freq = INT2FIX((((ch0.reg[2] & 0x0F) << 8) | data) + 1);
|
|
break;
|
|
case 0x9002:
|
|
ch0.reg[2] = data;
|
|
ch0.enable = (byte)(data & 0x80);
|
|
ch0.freq = INT2FIX((((data & 0x0F) << 8) | ch0.reg[1]) + 1);
|
|
break;
|
|
// VRC6 CH1 rectangle
|
|
case 0xA000:
|
|
ch1.reg[0] = data;
|
|
ch1.gate = (byte)(data & 0x80);
|
|
ch1.volume = (byte)(data & 0x0F);
|
|
ch1.duty_pos = (byte)((data >> 4) & 0x07);
|
|
break;
|
|
case 0xA001:
|
|
ch1.reg[1] = data;
|
|
ch1.freq = INT2FIX((((ch1.reg[2] & 0x0F) << 8) | data) + 1);
|
|
break;
|
|
case 0xA002:
|
|
ch1.reg[2] = data;
|
|
ch1.enable = (byte)(data & 0x80);
|
|
ch1.freq = INT2FIX((((data & 0x0F) << 8) | ch1.reg[1]) + 1);
|
|
break;
|
|
// VRC6 CH2 sawtooth
|
|
case 0xB000:
|
|
ch2.reg[1] = data;
|
|
ch2.phaseaccum = (byte)(data & 0x3F);
|
|
break;
|
|
case 0xB001:
|
|
ch2.reg[1] = data;
|
|
ch2.freq = INT2FIX((((ch2.reg[2] & 0x0F) << 8) | data) + 1);
|
|
break;
|
|
case 0xB002:
|
|
ch2.reg[2] = data;
|
|
ch2.enable = (byte)(data & 0x80);
|
|
ch2.freq = INT2FIX((((data & 0x0F) << 8) | ch2.reg[1]) + 1);
|
|
// ch2.adder = 0; // 僋儕傾偡傞偲僲僀僘偺尨場偵側傞
|
|
// ch2.accum = 0; // 僋儕傾偡傞偲僲僀僘偺尨場偵側傞
|
|
break;
|
|
}
|
|
}
|
|
|
|
public override int Process(int channel)
|
|
{
|
|
switch (channel)
|
|
{
|
|
case 0:
|
|
return RectangleRender(ch0);
|
|
case 1:
|
|
return RectangleRender(ch1);
|
|
case 2:
|
|
return SawtoothRender(ch2);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
public override int GetFreq(int channel)
|
|
{
|
|
if (channel == 0 || channel == 1)
|
|
{
|
|
RECTANGLE ch = null;
|
|
if (channel == 0) ch = ch0;
|
|
else ch = ch1;
|
|
if (ch.enable == 0 || ch.gate != 0 || ch.volume == 0)
|
|
return 0;
|
|
if (ch.freq < INT2FIX(8))
|
|
return 0;
|
|
return (int)(256.0f * cpu_clock / (FIX2INT(ch.freq) * 16.0f));
|
|
}
|
|
if (channel == 2)
|
|
{
|
|
SAWTOOTH ch = ch2;
|
|
if (ch.enable == 0 || ch.phaseaccum == 0)
|
|
return 0;
|
|
if (ch.freq < INT2FIX(8))
|
|
return 0;
|
|
return (int)(256.0f * cpu_clock / (FIX2INT(ch.freq) * 14.0f));
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
private int RectangleRender(RECTANGLE ch)
|
|
{
|
|
// Enable?
|
|
if (ch.enable == 0)
|
|
{
|
|
ch.output_vol = 0;
|
|
ch.adder = 0;
|
|
return ch.output_vol;
|
|
}
|
|
|
|
// Digitized output
|
|
if (ch.gate != 0)
|
|
{
|
|
ch.output_vol = ch.volume << RECTANGLE_VOL_SHIFT;
|
|
return ch.output_vol;
|
|
}
|
|
|
|
// 堦掕埲忋偺廃攇悢偼張棟偟側偄(柍懯)
|
|
if (ch.freq < INT2FIX(8))
|
|
{
|
|
ch.output_vol = 0;
|
|
return ch.output_vol;
|
|
}
|
|
|
|
ch.phaseacc -= cycle_rate;
|
|
if (ch.phaseacc >= 0)
|
|
return ch.output_vol;
|
|
|
|
int output = ch.volume << RECTANGLE_VOL_SHIFT;
|
|
|
|
if (ch.freq > cycle_rate)
|
|
{
|
|
// add 1 step
|
|
ch.phaseacc += ch.freq;
|
|
ch.adder = (byte)((ch.adder + 1) & 0x0F);
|
|
if (ch.adder <= ch.duty_pos)
|
|
ch.output_vol = output;
|
|
else
|
|
ch.output_vol = -output;
|
|
}
|
|
else
|
|
{
|
|
// average calculate
|
|
int num_times, total;
|
|
num_times = total = 0;
|
|
while (ch.phaseacc < 0)
|
|
{
|
|
ch.phaseacc += ch.freq;
|
|
ch.adder = (byte)((ch.adder + 1) & 0x0F);
|
|
if (ch.adder <= ch.duty_pos)
|
|
total += output;
|
|
else
|
|
total += -output;
|
|
num_times++;
|
|
}
|
|
ch.output_vol = total / num_times;
|
|
}
|
|
|
|
return ch.output_vol;
|
|
}
|
|
|
|
private int SawtoothRender(SAWTOOTH ch)
|
|
{
|
|
// Digitized output
|
|
if (ch.enable == 0)
|
|
{
|
|
ch.output_vol = 0;
|
|
return ch.output_vol;
|
|
}
|
|
|
|
// 堦掕埲忋偺廃攇悢偼張棟偟側偄(柍懯)
|
|
if (ch.freq < INT2FIX(9))
|
|
{
|
|
return ch.output_vol;
|
|
}
|
|
|
|
ch.phaseacc -= cycle_rate / 2;
|
|
if (ch.phaseacc >= 0)
|
|
return ch.output_vol;
|
|
|
|
if (ch.freq > cycle_rate / 2)
|
|
{
|
|
// add 1 step
|
|
ch.phaseacc += ch.freq;
|
|
if (++ch.adder >= 7)
|
|
{
|
|
ch.adder = 0;
|
|
ch.accum = 0;
|
|
}
|
|
ch.accum += ch.phaseaccum;
|
|
ch.output_vol = ch.accum << SAWTOOTH_VOL_SHIFT;
|
|
}
|
|
else
|
|
{
|
|
// average calculate
|
|
int num_times, total;
|
|
num_times = total = 0;
|
|
while (ch.phaseacc < 0)
|
|
{
|
|
ch.phaseacc += ch.freq;
|
|
if (++ch.adder >= 7)
|
|
{
|
|
ch.adder = 0;
|
|
ch.accum = 0;
|
|
}
|
|
ch.accum += ch.phaseaccum;
|
|
total += ch.accum << SAWTOOTH_VOL_SHIFT;
|
|
num_times++;
|
|
}
|
|
ch.output_vol = (total / num_times);
|
|
}
|
|
|
|
return ch.output_vol;
|
|
}
|
|
|
|
public override uint GetSize()
|
|
{
|
|
return ch0.GetSize() + ch1.GetSize() + ch2.GetSize();
|
|
}
|
|
public override void SaveState(StateBuffer p)
|
|
{
|
|
ch0.SaveState(p);
|
|
ch1.SaveState(p);
|
|
ch2.SaveState(p);
|
|
}
|
|
|
|
public class RECTANGLE : IStateBufferObject
|
|
{
|
|
public byte[] reg = new byte[3];
|
|
|
|
public byte enable;
|
|
public byte gate;
|
|
public byte volume;
|
|
|
|
public int phaseacc;
|
|
public int freq;
|
|
public int output_vol;
|
|
|
|
public byte adder;
|
|
public byte duty_pos;
|
|
|
|
public void ZeroMemory()
|
|
{
|
|
Array.Clear(reg, 0, reg.Length);
|
|
enable = 0;
|
|
gate = 0;
|
|
volume = 0;
|
|
|
|
phaseacc = 0;
|
|
freq = 0;
|
|
output_vol = 0;
|
|
|
|
adder = 0;
|
|
duty_pos = 0;
|
|
}
|
|
|
|
public uint GetSize()
|
|
{
|
|
return 20;
|
|
}
|
|
|
|
public void SaveState(StateBuffer buffer)
|
|
{
|
|
buffer.Write(reg);
|
|
buffer.Write(enable);
|
|
buffer.Write(gate);
|
|
buffer.Write(volume);
|
|
buffer.Write(phaseacc);
|
|
buffer.Write(freq);
|
|
buffer.Write(output_vol);
|
|
buffer.Write(adder);
|
|
buffer.Write(duty_pos);
|
|
}
|
|
|
|
public void LoadState(StateReader buffer)
|
|
{
|
|
reg = buffer.Read_bytes(3);
|
|
enable = buffer.Read_byte();
|
|
gate = buffer.Read_byte();
|
|
volume = buffer.Read_byte();
|
|
phaseacc = buffer.Read_int();
|
|
freq = buffer.Read_int();
|
|
output_vol = buffer.Read_int();
|
|
adder = buffer.Read_byte();
|
|
duty_pos = buffer.Read_byte();
|
|
}
|
|
}
|
|
|
|
public class SAWTOOTH : IStateBufferObject
|
|
{
|
|
public byte[] reg = new byte[3];
|
|
|
|
public byte enable;
|
|
public byte volume;
|
|
|
|
public int phaseacc;
|
|
public int freq;
|
|
public int output_vol;
|
|
|
|
public byte adder;
|
|
public byte accum;
|
|
public byte phaseaccum;
|
|
|
|
public void ZeroMemory()
|
|
{
|
|
Array.Clear(reg, 0, reg.Length);
|
|
enable = 0;
|
|
volume = 0;
|
|
|
|
phaseacc = 0;
|
|
freq = 0;
|
|
output_vol = 0;
|
|
|
|
adder = 0;
|
|
accum = 0;
|
|
phaseaccum = 0;
|
|
}
|
|
|
|
public uint GetSize()
|
|
{
|
|
return 20;
|
|
}
|
|
|
|
public void SaveState(StateBuffer buffer)
|
|
{
|
|
buffer.Write(reg);
|
|
buffer.Write(enable);
|
|
buffer.Write(volume);
|
|
buffer.Write(phaseacc);
|
|
buffer.Write(freq);
|
|
buffer.Write(output_vol);
|
|
buffer.Write(adder);
|
|
buffer.Write(accum);
|
|
buffer.Write(phaseaccum);
|
|
}
|
|
|
|
public void LoadState(StateReader buffer)
|
|
{
|
|
reg = buffer.Read_bytes(3);
|
|
enable = buffer.Read_byte();
|
|
volume = buffer.Read_byte();
|
|
phaseacc = buffer.Read_int();
|
|
freq = buffer.Read_int();
|
|
output_vol = buffer.Read_int();
|
|
adder = buffer.Read_byte();
|
|
accum = buffer.Read_byte();
|
|
phaseaccum = buffer.Read_byte();
|
|
}
|
|
}
|
|
}
|
|
}
|