USBSIDEmu.java
package builder.jusbsid;
import builder.resid.residfp.ReSIDfp;
import libsidplay.common.CPUClock;
import libsidplay.common.ChipModel;
import libsidplay.common.Event;
import libsidplay.common.EventScheduler;
import libsidplay.config.IEmulationSection;
import usbsid.USBSID;
import java.util.List;
import java.util.Objects;
import static libsidplay.config.ISidPlay2SystemProperties.MAX_SIDS;
/**
*
* @author Ken Händel
*
*/
public class USBSIDEmu extends ReSIDfp {
/**
* FakeStereo mode uses two chips using the same base address. Write commands are routed two both SIDs, while read
* command can be configured to be processed by a specific SID chip.
*
* @author ken
*
*/
public static class FakeStereo extends USBSIDEmu {
private final IEmulationSection emulationSection;
private final int prevNum;
private final List<USBSIDEmu> sids;
public FakeStereo(JUSBSIDBuilder jusbsidBuilder, EventScheduler context, CPUClock cpuClock, USBSID usbsid,
byte deviceId, int sidNum, ChipModel model, ChipModel defaultChipModel, boolean stereo,
List<USBSIDEmu> sids, IEmulationSection emulationSection) {
super(jusbsidBuilder, context, cpuClock, usbsid, deviceId, sidNum, model, defaultChipModel, stereo);
this.prevNum = sidNum - 1;
this.sids = sids;
this.emulationSection = emulationSection;
}
@Override
public byte read(int addr) {
if (emulationSection.getSidToRead().getSidNum() <= prevNum) {
return sids.get(prevNum).read(addr);
}
return super.read(addr);
}
@Override
public byte readInternalRegister(int addr) {
if (emulationSection.getSidToRead().getSidNum() <= prevNum) {
return sids.get(prevNum).readInternalRegister(addr);
}
return super.readInternalRegister(addr);
}
@Override
public void write(int addr, byte data) {
super.write(addr, data);
sids.get(prevNum).write(addr, data);
}
}
private final EventScheduler context;
private final JUSBSIDBuilder jusbsidBuilder;
// private final Event event;
private final Event frame_event;
private short raster_rate;
private static long usid_main_clk;
@SuppressWarnings("unused")
private static long usid_alarm_clk;
private final int us_cyclesPerFrame;
private final USBSID usbsid;
private final byte deviceID;
private String deviceName;
private final int sidNum;
private final ChipModel chipModel;
private final boolean[] voiceMute = new boolean[4];
private final boolean[] filterDisable = new boolean[MAX_SIDS];
public USBSIDEmu(JUSBSIDBuilder jusbsidBuilder, EventScheduler context, CPUClock cpuClock, USBSID usbsid,
byte deviceId, int sidNum, ChipModel model, ChipModel defaultSidModel, boolean stereo) {
super(context);
this.jusbsidBuilder = jusbsidBuilder;
this.context = context;
this.usbsid = usbsid;
this.deviceID = deviceId;
this.sidNum = sidNum;
this.chipModel = model;
this.frame_event = Event.of("USBSID Flush buffer",
frame_event -> context.schedule(frame_event, usbsid_alarm_handler(), Event.Phase.PHI2));
// this.event =
// Event.of("ExSID Delay", event -> context.schedule(event,
// jusbsidBuilder.eventuallyDelay(), Event.Phase.PHI2));
super.setChipModel(model);
super.setClockFrequency(cpuClock.getCpuFrequency());
double us_systemClock = cpuClock.getCpuFrequency();
us_cyclesPerFrame = jusbsidBuilder.getCyclesPerFrame();
if (sidNum == 0) {
raster_rate = (short) us_cyclesPerFrame;
System.out.printf("[USBSID] raster_rate set to: %d\n", raster_rate);
usbsid.USBSID_setclock(us_systemClock);
usid_main_clk = context.getTime(Event.Phase.PHI2);
}
}
private int us_delay() {
final long now = context.getTime(Event.Phase.PHI2);
/*
* USBSID-Pico has a 1 cycle overhead on SID writes, without subtracting
* 1 cycle this would cause a clicking noise in cycle exact tunes
* But in Java both minus 1 and not minus 1 cycle seem okay
*/
int cycles = (int) ((now - usid_main_clk) - 1);
usid_main_clk += cycles;
int ff = jusbsidBuilder.ff();
while (cycles > 0xffff) {
usbsid.USBSID_delay((short) (0xffff >> ff));
cycles -= 0xffff;
}
usbsid.USBSID_delay((short) (cycles >> ff));
return cycles >> ff;
}
long usbsid_alarm_handler() { /* Triggered every n (raster_rate) cycles */
final long now = context.getTime(Event.Phase.PHI2);
long cycles = now - usid_main_clk; /* shared clock */
if (cycles < raster_rate) {
usbsid.USBSID_setflush();
return raster_rate - cycles; /* not due yet, come back for the remainder */
}
usid_main_clk += cycles; /* advance, do not assign */
int ff = jusbsidBuilder.ff();
while (cycles > 0xffff) { usbsid.USBSID_delay((short)(0xffff >> ff)); cycles -= 0xffff; }
usbsid.USBSID_delay((short)(cycles >> ff));
usbsid.USBSID_setflush();
return raster_rate;
}
@Override
public void write(int addr, byte data) {
switch (addr & 0x1f) {
case 0x04:
case 0x0b:
case 0x12:
if (voiceMute[(addr - 4) / 7]) {
data &= (byte) 0xfe;
}
super.write(addr, data);
break;
case 0x17:
if (filterDisable[sidNum]) {
data &= (byte) 0xf0;
}
super.write(addr, data);
break;
case 0x18:
// samples muted? Fade-in is allowed anyway
if (voiceMute[3] && (data & 0xf) < (readInternalRegister(addr) & 0xf)) {
return;
}
super.write(addr, data);
break;
default:
super.write(addr, data);
break;
}
final byte dataByte = data;
if (addr > 0x18) {
// "Ragga Run.sid" denies to work!
return;
}
doWriteDelayed(() -> {
if (!Objects.equals(jusbsidBuilder.lastSidNum, sidNum)) {
jusbsidBuilder.lastSidNum = sidNum;
}
final short cycles = (short) us_delay();
usbsid.USBSID_writeclkdbuffer((byte) (((sidNum * 0x20) + addr) & 0xFF), (byte) (dataByte & 0xFF), cycles);
});
}
// @Override
// public void clock() {
// super.clock();
// final short clocksSinceLastAccess = (short)
// jusbsidBuilder.clocksSinceLastAccess(cycles);
// doWriteDelayed(() -> usbsid.USBSID_delay(clocksSinceLastAccess));
// }
private void doWriteDelayed(Runnable runnable) {
if (jusbsidBuilder.getDelay(sidNum) > 0) {
context.schedule(Event.of("Delayed SID output", event -> runnable.run()), jusbsidBuilder.getDelay(sidNum));
} else {
runnable.run();
}
}
protected boolean lock() {
usbsid.USBSID_reset((byte) 0x0f);
try {
// Reset needs some time to complete, without these stereo tunes hung up the cart
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
reset((byte) 0xf);
raster_rate = (short) us_cyclesPerFrame;
usid_main_clk = context.getTime(Event.Phase.PHI2);
usid_alarm_clk = raster_rate;
context.schedule(frame_event, 0, Event.Phase.PHI2); /* Schedule event in 0 cycles */
return true;
}
protected void unlock() {
usbsid.USBSID_resetringbuffer(); /* Discard any backlog */
usbsid.USBSID_resetallregisters(); /* Reset registers */
usbsid.USBSID_reset((byte) 1); /* Reset and unmute */
usid_main_clk = 0;
usid_alarm_clk = 0;
reset((byte) 0x0);
context.cancel(frame_event);
}
@Override
public void setVoiceMute(int num, boolean mute) {
super.setVoiceMute(num, mute);
if (num < 4) {
voiceMute[num] = mute;
}
}
@Override
public void setFilterEnable(IEmulationSection emulation, int sidNum) {
super.setFilterEnable(emulation, sidNum);
filterDisable[sidNum] = !emulation.isFilterEnable(sidNum);
}
public byte getDeviceId() {
return deviceID;
}
public String getDeviceName() {
return deviceName;
}
public void setDeviceName(String deviceName) {
this.deviceName = deviceName;
}
protected ChipModel getChipModel() {
return chipModel;
}
public static String credits() {
final StringBuilder credits = new StringBuilder();
credits.append("USBSID code implementation, hardware and driver code by LouD Copyright (©) 2021\n");
credits.append("\thttp://github.com/LouDnl/USBSID-Pico\n");
return credits.toString();
}
}