JUSBSIDBuilder.java
package builder.jusbsid;
import libsidplay.common.*;
import libsidplay.config.IAudioSection;
import libsidplay.config.IConfig;
import libsidplay.config.IEmulationSection;
import libsidplay.sidtune.SidTune;
import usbsid.USBSID;
import java.util.ArrayList;
import java.util.List;
import static libsidplay.config.ISidPlay2SystemProperties.MAX_SIDS;
/**
*
* Support of USBSID mini USB devices.
*
* @author Ken Händel
*
*/
public class JUSBSIDBuilder implements HardwareSIDBuilder, Mixer {
// private static final short REGULAR_DELAY = 512;
// private static final short REGULAR_DELAY = 64;
// private static final short REGULAR_DELAY = 19950;
// private static final short REGULAR_DELAY = 20000;
// public short FRAME_RATE = 19950;
/**
* System event context.
*/
private final EventScheduler context;
/**
* Configuration
*/
private final IConfig config;
/**
* CPU clock.
*/
private final CPUClock cpuClock;
private final int cyclesPerFrame;
/**
* Native library wrapper.
*/
private static USBSID usbsid;
/**
* Number of USBSID devices.
*/
private static int deviceCount;
/**
* Device names of USBSID devices.
*/
private static String[] deviceNames;
/**
* Already used USBSID SIDs.
*/
private final List<USBSIDEmu> sids = new ArrayList<>();
// private long lastSIDWriteTime;
// private long lastFlushTime;
private int fastForwardFactor;
private final int[] delayInCycles = new int[MAX_SIDS];
protected int lastSidNum = -1;
public JUSBSIDBuilder(EventScheduler context, IConfig config, CPUClock cpuClock) {
this(context, config, cpuClock, cpuClock.getCyclesPerFrame());
}
public JUSBSIDBuilder(EventScheduler context, IConfig config, CPUClock cpuClock, int cyclesPerFrame) {
this.context = context;
this.config = config;
this.cpuClock = cpuClock;
this.cyclesPerFrame = cyclesPerFrame;
if (usbsid == null) {
usbsid = new USBSID();
init();
}
}
int getCyclesPerFrame() {
return cyclesPerFrame;
}
private void init() {
Runtime.getRuntime().addShutdownHook(new Thread(() -> usbsid.USBSID_exit()));
if (usbsid.USBSID_init() < 0) {
deviceNames = new String[0];
return;
}
final String usbsidVersion = String.format(" v%s (%s)", usbsid.USBSID_getpcbversion(),
usbsid.USBSID_getfwversion());
deviceCount = usbsid.USBSID_getnumsids();
deviceNames = new String[deviceCount];
final byte[] socketcfg = usbsid.USBSID_getsocketconfig();
for (int d = 0; d < deviceCount; d++) {
deviceNames[d] = usbsid.USBSID_sidtypebysidno(d, socketcfg) + " " + usbsidVersion + " #" + (d + 1);
}
}
public static void printInstallationHint() {
if (OS.get() == OS.LINUX) {
printLinuxInstallationHint();
}
}
private static void printLinuxInstallationHint() {
System.err.println("\"To give proper permissions, please type the following commands:\"");
System.err.println("sudo vi /etc/udev/rules.d/92-usbsid.rules");
System.err.println("\"Now, add the following single line:\"");
System.err.println(
"SUBSYSTEM==\"usb\",ATTR{idVendor}==\"CAFE\",ATTR{idProduct}==\"8580\",MODE=\"4011\",GROUP=\"plugdev\"");
System.err.println("\"And finally type this command to refresh device configuration:\"");
System.err.println("sudo udevadm trigger");
System.err.println("Now you are ready to start :-)");
}
@Override
public SIDEmu lock(SIDEmu oldSIDEmu, int sidNum, SidTune tune) {
IAudioSection audioSection = config.getAudioSection();
IEmulationSection emulationSection = config.getEmulationSection();
ChipModel chipModel = ChipModel.getChipModel(emulationSection, tune, sidNum);
ChipModel defaultSidModel = emulationSection.getDefaultSidModel();
boolean stereo = SidTune.isSIDUsed(emulationSection, tune, 1);
if (oldSIDEmu != null) {
// always re-use hardware SID chips, if configuration changes,
// the purpose is to ignore chip model changes!
return oldSIDEmu;
}
// Use usbsid fake stereo (simultaneous write to both chips -> no delay
// possible)
// or
// JSIDPlay2 fake stereo (address both chips separately -> shared bandwidth)!
// if (emulationSection.isExsidFakeStereo()) {
// if (sidNum == 0 && SidTune.isFakeStereoSid(emulationSection, tune, 1)) {
// lastSidNum = sidNum;
// usbsid.exSID_chipselect(ChipSelect.XS_CS_BOTH.getChipSelect());
// }
// if (sidNum == 1 && SidTune.isFakeStereoSid(emulationSection, tune, 1)) {
// return SIDEmu.NONE;
// }
// }
// stereo SIDs with the same chipmodel must be forced to use a different device,
// therefore:
if (sidNum == 1 && !sids.isEmpty() && sids.get(0).getChipModel() == chipModel) {
chipModel = chipModel == ChipModel.MOS6581 ? ChipModel.MOS8580 : ChipModel.MOS6581;
}
Integer deviceId = sidNum;
if (deviceId < deviceCount) {
USBSIDEmu sid = createSID(deviceId.byteValue(), sidNum, tune, chipModel, defaultSidModel, stereo);
if (sid.lock()) {
sid.setFilterEnable(emulationSection, sidNum);
sid.setDigiBoost(emulationSection.isDigiBoosted8580());
for (int voice = 0; voice < 4; voice++) {
sid.setVoiceMute(voice, emulationSection.isMuteVoice(sidNum, voice));
}
sids.add(sid);
setDeviceName(sidNum, deviceNames[deviceId]);
setDelay(sidNum, audioSection.getDelay(sidNum));
return sid;
}
}
System.err.printf("USBSID ERROR: System doesn't have enough SID chips. Requested: (sidNum=%d)\n", sidNum);
if (deviceCount == 0) {
printInstallationHint();
}
return SIDEmu.NONE;
}
@Override
public void unlock(SIDEmu sidEmu) {
USBSIDEmu sid = (USBSIDEmu) sidEmu;
sids.remove(sid);
sid.unlock();
}
@Override
public int getDeviceCount() {
return deviceCount;
}
public static String[] getDeviceNames() {
return deviceNames;
}
@Override
public Integer getDeviceId(int sidNum) {
return sidNum < sids.size() ? (int) sids.get(sidNum).getDeviceId() : null;
}
@Override
public String getDeviceName(int sidNum) {
return sidNum < sids.size() ? sids.get(sidNum).getDeviceName() : null;
}
public void setDeviceName(int sidNum, String serialNo) {
if (sidNum < sids.size()) {
sids.get(sidNum).setDeviceName(serialNo);
}
}
@Override
public ChipModel getDeviceChipModel(int sidNum) {
return sidNum < sids.size() ? sids.get(sidNum).getChipModel() : null;
}
@Override
public void start() {
}
@Override
public void fadeIn(double fadeIn) {
System.err.println("Fade-in unsupported by USBSID");
// XXX unsupported by USBSID
}
@Override
public void fadeOut(double fadeOut) {
System.err.println("Fade-out unsupported by USBSID");
// XXX unsupported by USBSID
}
@Override
public void setVolume(int sidNum, float volume) {
System.err.println("Volume unsupported by USBSID");
// XXX unsupported by USBSID
}
@Override
public void setBalance(int sidNum, float balance) {
// XXX unsupported by USBSID
}
public static void setAudio(int Stereo) {
if (deviceCount > 0) {
usbsid.USBSID_setstereo(Stereo);
}
}
public int getDelay(int sidNum) {
return delayInCycles[sidNum];
}
@Override
public void setDelay(int sidNum, int delay) {
delayInCycles[sidNum] = (int) (cpuClock.getCpuFrequency() / 1000. * delay);
}
@Override
public void fastForward() {
fastForwardFactor++;
}
@Override
public void normalSpeed() {
fastForwardFactor = 0;
}
@Override
public boolean isFastForward() {
return fastForwardFactor != 0;
}
@Override
public int getFastForwardFactor() {
return fastForwardFactor;
}
@Override
public int getFastForwardBitMask() {
return (1 << fastForwardFactor) - 1;
}
@Override
public void pause() {
}
private USBSIDEmu createSID(byte deviceId, int sidNum, SidTune tune, ChipModel chipModel,
ChipModel defaultChipModel, boolean stereo) {
final IEmulationSection emulationSection = config.getEmulationSection();
if (SidTune.isFakeStereoSid(emulationSection, tune, sidNum)) {
return new USBSIDEmu.FakeStereo(this, context, cpuClock, usbsid, deviceId, sidNum, chipModel,
defaultChipModel, stereo, sids, emulationSection);
} else {
return new USBSIDEmu(this, context, cpuClock, usbsid, deviceId, sidNum, chipModel, defaultChipModel,
stereo);
}
}
int ff() {
return fastForwardFactor;
}
// int clocksSinceLastAccess() {
// final long now = context.getTime(Event.Phase.PHI2);
// // int diff = (int) ((now - lastSIDWriteTime) - 1);/* Vice prov en */
// int diff = (int) (now - lastSIDWriteTime);
// lastSIDWriteTime = now;
// lastFlushTime += diff;
// return diff >> fastForwardFactor;
// }
//
// long eventuallyDelay() {
// final long now = context.getTime(Event.Phase.PHI2);
// int diff = (int) (now - lastFlushTime);
// if (diff > FRAME_RATE) {
// System.out.printf("FLUSH diff: %d @ %d\n", lastFlushTime, diff);
// usbsid.USBSID_setflush();
// }
// lastFlushTime = now;
// // if (startOfFrame) usbsid.USBSID_setflush();
// // int diff = (int) ((now - lastSIDWriteTime) - 1);/* Vice proven */
// // int diff = (int) (now - lastSIDWriteTime);/
// // if (diff > REGULAR_DELAY) {
// // lastSIDWriteTime += REGULAR_DELAY;
// // usbsid.USBSID_delay((short) (REGULAR_DELAY >> fastForwardFactor));
// // /* usbsid.USBSID_setflush(); */
// // }
// return FRAME_RATE;
// }
}