JSIDBlasterBuilder.java
package builder.jsidblaster;
import libsidplay.common.*;
import libsidplay.config.IAudioSection;
import libsidplay.config.IConfig;
import libsidplay.config.IEmulationSection;
import libsidplay.sidtune.SidTune;
import sidblaster.hardsid.HardSID;
import sidblaster.hardsid.HardSIDImpl;
import java.util.AbstractMap.SimpleEntry;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import static libsidplay.config.ISidPlay2SystemProperties.MAX_SIDS;
/**
*
* Support of SIDBlaster mini USB devices.
*
* @author Ken Händel
*
*/
public class JSIDBlasterBuilder implements HardwareSIDBuilder, Mixer {
private static final short REGULAR_DELAY = 512;
/**
* System event context.
*/
private final EventScheduler context;
/**
* Configuration
*/
private final IConfig config;
/**
* CPU clock.
*/
private final CPUClock cpuClock;
/**
* Native library wrapper.
*/
private static HardSID hardSID;
/**
* Number of SIDBlaster devices.
*/
private static int deviceCount;
/**
* Serial numbers of SIDBlaster devices.
*/
private static String[] serialNumbers;
/**
* Already used SIDBlaster SIDs.
*/
private final List<SIDBlasterEmu> sids = new ArrayList<>();
private long lastSIDWriteTime;
private int fastForwardFactor;
private final int[] delayInCycles = new int[MAX_SIDS];
public JSIDBlasterBuilder(EventScheduler context, IConfig config, CPUClock cpuClock) {
this.context = context;
this.config = config;
this.cpuClock = cpuClock;
if (hardSID == null) {
hardSID = new HardSIDImpl();
init();
}
}
private void init() {
Runtime.getRuntime().addShutdownHook(new Thread(JSIDBlasterBuilder::uninitialize));
deviceCount = hardSID.HardSID_Devices();
hardSID.HardSID_SetWriteBufferSize((byte) config.getEmulationSection().getSidBlasterWriteBufferSize());
serialNumbers = new String[deviceCount];
for (byte deviceId = 0; deviceId < deviceCount; deviceId++) {
serialNumbers[deviceId] = hardSID.HardSID_GetSerial(deviceId);
}
}
public static void printInstallationHint() {
if (OS.get() == OS.LINUX) {
printLinuxInstallationHint();
}
System.err.println("Maybe you just forgot to plug-in your USB devices?");
System.err.println("Use the magic wand of the SIDBlaster combobox to configure your SIDBlaster devices!");
System.err.println();
}
private static void printLinuxInstallationHint() {
System.err
.println("If device cannot be used, please use this workaround (we grant access to the USB device)...");
System.err.println();
System.err.println("... On Ubuntu you do:");
System.err.println("$ sudo vi /etc/udev/rules.d/91-sidblaster.rules");
System.err.println(
"ACTION==\"add\", ATTRS{idVendor}==\"0403\", ATTRS{idProduct}==\"6001\", MODE=\"0666\", RUN+=\"/bin/sh -c 'rmmod ftdi_sio && rmmod usbserial'\"");
System.err.println("$ sudo udevadm control --reload-rules && sudo udevadm trigger");
System.err.println("sudo chmod -R 777 /dev/bus/usb/");
System.err.println();
System.err.println("... and on Fedora you do:");
System.err.println("$ sudo vi /etc/udev/rules.d/91-sidblaster.rules");
System.err.println(
"ACTION==\"add\", ATTRS{idVendor}==\"0403\", ATTRS{idProduct}==\"6001\", MODE=\"0666\", RUN+=\"/bin/sh -c 'echo -n $id:1.0 > /sys/bus/usb/drivers/ftdi_sio/unbind; echo -n $id:1.1 > /sys/bus/usb/drivers/ftdi_sio/unbind'\"");
}
@Override
public SIDEmu lock(SIDEmu oldHardSID, int sidNum, SidTune tune) {
IAudioSection audioSection = config.getAudioSection();
IEmulationSection emulationSection = config.getEmulationSection();
ChipModel chipModel = ChipModel.getChipModel(emulationSection, tune, sidNum);
ChipModel defaultSidModel = emulationSection.getDefaultSidModel();
SimpleEntry<Integer, ChipModel> deviceIdAndChipModel = getModelDependantDeviceId(chipModel, sidNum,
emulationSection.getSidBlasterSerialNumber());
Integer deviceId = deviceIdAndChipModel.getKey();
ChipModel model = deviceIdAndChipModel.getValue();
if (oldHardSID != null) {
// always re-use hardware SID chips, if configuration changes,
// the purpose is to ignore chip model changes!
return oldHardSID;
}
if (deviceId != null && deviceId < deviceCount) {
SIDBlasterEmu sid = createSID(deviceId.byteValue(), sidNum, tune, model, defaultSidModel);
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, serialNumbers[deviceId]);
setDelay(sidNum, audioSection.getDelay(sidNum));
setLatencyTimer(emulationSection.getSidBlasterLatencyTimer());
return sid;
}
}
System.err.printf("SIDBLASTER ERROR: System doesn't have enough SID chips. Requested: (sidNum=%d)\n", sidNum);
if (deviceCount == 0) {
printInstallationHint();
}
return SIDEmu.NONE;
}
@Override
public void unlock(final SIDEmu sidEmu) {
SIDBlasterEmu sid = (SIDBlasterEmu) sidEmu;
sids.remove(sid);
sid.unlock();
}
@Override
public int getDeviceCount() {
return deviceCount;
}
public static String[] getSerialNumbers() {
return serialNumbers;
}
public boolean isSidBlasterRead() {
return config.getEmulationSection().isSidBlasterRead();
}
public static SIDType getSidType(int deviceId) {
sidblaster.SIDType hardSID_GetSIDType = hardSID.HardSID_GetSIDType((byte) deviceId);
return SIDType.to(hardSID_GetSIDType);
}
public static int setSidType(int deviceId, SIDType sidType) {
sidblaster.SIDType hardSID_GetSIDType = SIDType.from(sidType);
return hardSID.HardSID_SetSIDType((byte) deviceId, hardSID_GetSIDType);
}
public static int setSerial(int deviceId, String serialNo) {
return hardSID.HardSID_SetSerial((byte) deviceId, serialNo);
}
public static void uninitialize() {
if (hardSID != null) {
hardSID.HardSID_Uninitialize();
}
}
@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 SIDBlaster");
// XXX unsupported by SIDBlaster
}
@Override
public void fadeOut(double fadeOut) {
System.err.println("Fade-out unsupported by SIDBlaster");
// XXX unsupported by SIDBlaster
}
@Override
public void setVolume(int sidNum, float volume) {
System.err.println("Volume unsupported by SIDBlaster");
// XXX unsupported by SIDBlaster
}
@Override
public void setBalance(int sidNum, float balance) {
System.err.println("Balance unsupported by SIDBlaster");
// XXX unsupported by SIDBlaster
}
public int getDelay(int sidNum) {
return delayInCycles[sidNum];
}
@Override
public void setDelay(int sidNum, int delay) {
delayInCycles[sidNum] = (int) (cpuClock.getCpuFrequency() / 1000. * delay);
}
public void setLatencyTimer(short ms) {
hardSID.HardSID_SetLatencyTimer(ms);
}
@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() {
for (SIDBlasterEmu sid : sids) {
hardSID.HardSID_Flush(sid.getDeviceId());
}
}
private SIDBlasterEmu createSID(byte deviceId, int sidNum, SidTune tune, ChipModel chipModel,
ChipModel defaultChipModel) {
final IEmulationSection emulationSection = config.getEmulationSection();
if (SidTune.isFakeStereoSid(emulationSection, tune, sidNum)) {
return new SIDBlasterEmu.FakeStereo(this, context, cpuClock, hardSID, deviceId, sidNum, chipModel,
defaultChipModel, sids, emulationSection);
} else {
return new SIDBlasterEmu(this, context, cpuClock, hardSID, deviceId, sidNum, chipModel, defaultChipModel);
}
}
/**
* Get SIDBlaster device index based on the desired chip model.
*
* @param chipModel desired chip model
* @param sidNum current SID number
* @param sidBlasterSerialNumber hard-wired serial number of devices to test with
* (null - choose the best fitting device)
* @return SID index of the desired SIDBlaster device
*/
private SimpleEntry<Integer, ChipModel> getModelDependantDeviceId(final ChipModel chipModel, int sidNum,
String sidBlasterSerialNumber) {
if (sidBlasterSerialNumber == null) {
// DEFAULT: choose the best fitting device for sound output
final Map<String, ChipModel> deviceMap = config.getEmulationSection().getSidBlasterDeviceMap();
// use the next free slot (prevent wrong type)
for (int deviceId = 0; deviceId < deviceCount; deviceId++) {
String serialNo = serialNumbers[deviceId];
if (!isSerialNumAlreadyUsed(serialNo) && chipModel == deviceMap.get(serialNo)) {
return new SimpleEntry<>(deviceId, chipModel);
}
}
// Nothing matched? Use the next free slot (no matter what type)
for (int deviceId = 0; deviceId < deviceCount; deviceId++) {
String serialNo = serialNumbers[deviceId];
if (!isSerialNumAlreadyUsed(serialNo) && deviceMap.get(serialNo) != null) {
return new SimpleEntry<>(deviceId, deviceMap.get(serialNo));
}
}
} else {
// TEST: Choose one specific device for sound output
for (int deviceId = 0; deviceId < deviceCount; deviceId++) {
if (Objects.equals(serialNumbers[deviceId], sidBlasterSerialNumber)) {
return new SimpleEntry<>(deviceId, chipModel);
}
}
}
// no slot left
return new SimpleEntry<>(null, null);
}
private boolean isSerialNumAlreadyUsed(String serialNo) {
return sids.stream().anyMatch(sid -> Objects.equals(sid.getDeviceName(), serialNo));
}
int clocksSinceLastAccess() {
final long now = context.getTime(Event.Phase.PHI2);
int diff = (int) (now - lastSIDWriteTime);
lastSIDWriteTime = now;
return diff >> fastForwardFactor;
}
long eventuallyDelay() {
final long now = context.getTime(Event.Phase.PHI2);
int diff = (int) (now - lastSIDWriteTime);
if (diff > REGULAR_DELAY) {
lastSIDWriteTime += REGULAR_DELAY;
hardSID.HardSID_Delay((byte) 0, (short) (REGULAR_DELAY >> fastForwardFactor));
}
return REGULAR_DELAY;
}
}