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;
//  }
}