JHardSIDEmu.java
package builder.jhardsid;
import builder.resid.residfp.ReSIDfp;
import com.hardsid.usb.driver.HardSIDUSB;
import com.hardsid.usb.driver.WState;
import libsidplay.common.CPUClock;
import libsidplay.common.ChipModel;
import libsidplay.common.Event;
import libsidplay.common.EventScheduler;
import libsidplay.config.IEmulationSection;
import java.util.List;
import static libsidplay.common.SIDChip.REG_COUNT;
import static libsidplay.config.ISidPlay2SystemProperties.MAX_SIDS;
/**
*
* @author Ken Händel
*
*/
public class JHardSIDEmu 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 JHardSIDEmu {
private final IEmulationSection emulationSection;
private final int prevNum;
private final List<JHardSIDEmu> sids;
public FakeStereo(JHardSIDBuilder hardSIDBuilder, EventScheduler context, CPUClock cpuClock, HardSIDUSB hardSID,
byte deviceId, int chipNum, int sidNum, ChipModel chipModel, ChipModel defaultChipModel,
List<JHardSIDEmu> sids, IEmulationSection emulationSection) {
super(hardSIDBuilder, context, cpuClock, hardSID, deviceId, chipNum, sidNum, chipModel, defaultChipModel);
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 static final short SHORTEST_DELAY = 4;
private final EventScheduler context;
private final JHardSIDBuilder hardSIDBuilder;
private final Event event;
private final HardSIDUSB hardSID;
private final byte deviceID;
private final byte chipNum;
private boolean doReadWriteDelayed;
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 JHardSIDEmu(JHardSIDBuilder hardSIDBuilder, EventScheduler context, CPUClock cpuClock, HardSIDUSB hardSID,
byte deviceID, int chipNum, int sidNum, ChipModel model, ChipModel defaultChipModel) {
super(context);
this.hardSIDBuilder = hardSIDBuilder;
this.context = context;
this.hardSID = hardSID;
this.deviceID = deviceID;
this.chipNum = (byte) chipNum;
this.sidNum = sidNum;
this.chipModel = model;
this.event = Event.of("HardSID Delay",
event -> context.schedule(event, hardSIDBuilder.eventuallyDelay(), Event.Phase.PHI2));
super.setChipModel(model == ChipModel.AUTO ? defaultChipModel : model);
super.setClockFrequency(cpuClock.getCpuFrequency());
}
@Override
public void write(int addr, byte data) {
switch (addr & 0x1f) {
case 0x04:
case 0x0b:
case 0x12:
if (voiceMute[(addr - 4) / 7]) {
data &= 0xfe;
}
super.write(addr, data);
break;
case 0x17:
if (filterDisable[sidNum]) {
data &= 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) {
return;
}
doReadWriteDelayed = true;
doWriteDelayed(() -> {
while (hardSID.hardsid_usb_write(deviceID, (byte) ((chipNum << 5) | addr), dataByte) == WState.BUSY) {
try {
Thread.sleep(0);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
}
@Override
public void clock() {
super.clock();
final short clocksSinceLastAccess = (short) hardSIDBuilder.clocksSinceLastAccess();
doWriteDelayed(() -> {
if (clocksSinceLastAccess > 0) {
while (hardSID.hardsid_usb_delay(deviceID, clocksSinceLastAccess & 0xffff) == WState.BUSY) {
try {
Thread.sleep(0);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
});
}
private void doWriteDelayed(Runnable runnable) {
if (hardSIDBuilder.getDelay(sidNum) > 0) {
context.schedule(Event.of("Delayed SID output", event -> {
if (doReadWriteDelayed) {
runnable.run();
}
}), hardSIDBuilder.getDelay(sidNum));
} else {
runnable.run();
}
}
protected void lock() {
deviceReset((byte) 0xf);
reset((byte) 0xf);
context.schedule(event, 0, Event.Phase.PHI2);
}
protected void unlock() {
deviceReset((byte) 0x0);
reset((byte) 0x0);
context.cancel(event);
doReadWriteDelayed = false;
}
private void deviceReset(byte volume) {
hardSID.hardsid_usb_abortplay(deviceID);
for (byte reg = 0; reg < REG_COUNT; reg++) {
while (hardSID.hardsid_usb_write(deviceID, (byte) ((chipNum << 5) | reg), (byte) 0) == WState.BUSY) {
try {
Thread.sleep(0);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
while (hardSID.hardsid_usb_delay(deviceID, SHORTEST_DELAY) == WState.BUSY) {
try {
Thread.sleep(0);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
while (hardSID.hardsid_usb_write(deviceID, (byte) ((chipNum << 5) | 0xf), volume) == WState.BUSY) {
try {
Thread.sleep(0);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
while (hardSID.hardsid_usb_flush(deviceID) == WState.BUSY) {
try {
Thread.sleep(0);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
@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 String getDeviceName() {
return deviceName;
}
public void setDeviceName(String deviceName) {
this.deviceName = deviceName;
}
protected ChipModel getChipModel() {
return chipModel;
}
public byte getChipNum() {
return chipNum;
}
public static String credits() {
final StringBuilder credits = new StringBuilder();
credits.append("HardSID Java version by Ken Händel <kschwiersch@yahoo.de> Copyright (©) 2022\n");
credits.append("\tSupported by official HardSID support\n");
credits.append("\tbased on hardsid.dll, api calls Written by Sandor Téli\n");
return credits.toString();
}
}