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();
    }
}