Autodetection.java

package sidplay.player;

import libsidplay.C64;
import libsidplay.common.AudioActivitySource;
import libsidplay.common.Event;
import libsidplay.common.EventScheduler;
import libsidplay.components.pla.StereoSniffer;
import libsidplay.config.IEmulationSection;
import libsidplay.sidtune.SidTune;

import java.util.Arrays;

import static libsidplay.common.ChipModel.getChipModel;
import static libsidplay.common.SIDChip.DEF_BASE_ADDRESS;
import static libsidplay.common.SIDChip.REG_COUNT;
import static libsidplay.config.ISidPlay2SystemProperties.MAX_SIDS;
import static libsidplay.sidtune.SidTune.RESET;
import static libsidplay.sidtune.SidTune.getSIDAddress;

public abstract class Autodetection {

    private static final double EPSILON = 0.1;
    private static final int REQUIRED_STEREO_INTERVALS = 3;
    private final IEmulationSection emulationSection;
    private final C64 c64;
    private final Timer timer;
    private final EventScheduler context;

    private long lastAudioActivityCycle;
    private AudioActivitySource audioActivitySource;
    private boolean silenceDetectionEnabled;
    private boolean psid64Detected;
    private boolean stereoSniffed;
    private final int[] stereoActivityStreaks = new int[StereoSniffer.BASE_COUNT];
    private final boolean[] confirmedStereoBases = new boolean[StereoSniffer.BASE_COUNT];

    public Autodetection(IEmulationSection emulationSection, C64 c64, Timer timer) {
        this.emulationSection = emulationSection;
        this.c64 = c64;
        this.timer = timer;
        this.context = c64.getEventScheduler();
    }

    public void start(SidTune tune) {
        reset();
        configureStereoSniffer(tune);
        // Initialization before start is not a complete observation interval.
        c64.getStereoSnifferDetectedTuneInfo();
        detectSilence(tune, false);

        context.schedule(Event.of("PSID64 Detection", event2 -> autodetect(tune)), 0);
    }

    private void reset() {
        if (audioActivitySource != null) audioActivitySource.setAudioActivityEnabled(false);
        audioActivitySource = null;
        silenceDetectionEnabled = false;
        lastAudioActivityCycle = context.getTime(Event.Phase.PHI2);
        psid64Detected = false;
        stereoSniffed = false;
        Arrays.fill(stereoActivityStreaks, 0);
        Arrays.fill(confirmedStereoBases, false);
    }

    private void autodetect(SidTune tune) {
        if (!psid64Detected && emulationSection.isDetectPSID64ChipModel()) {
            PSid64DetectedTuneInfo psid64TuneInfo = PSid64Detection.detectPSid64TuneInfo(c64.getRAM(),
                    c64.getVicMemBase() + c64.getVIC().getVideoMatrixBase());
            if (psid64TuneInfo.isDetected()) {
                psid64Detected = true;

                boolean update = false;
                if (psid64TuneInfo.hasDifferentUserChipModel(getChipModel(emulationSection, tune, 0))) {
                    emulationSection.getOverrideSection().getSidModel()[0] = psid64TuneInfo.getUserChipModel();
                    update = true;
                }
                if (psid64TuneInfo.hasDifferentStereoChipModel(getChipModel(emulationSection, tune, 1))) {
                    emulationSection.getOverrideSection().getSidModel()[1] = psid64TuneInfo.getStereoChipModel();
                    update = true;
                }
                if (psid64TuneInfo.hasDifferentStereoAddress(getSIDAddress(emulationSection, tune, 1))) {
                    emulationSection.getOverrideSection().getSidBase()[1] = psid64TuneInfo.getStereoAddress();
                    update = true;
                }
                if (update) {
                    updateSids();
                }
            }
        }
        boolean stereoSnifferEnabled = configureStereoSniffer(tune);
        StereoSnifferDetectedTuneInfo stereoSnifferDetectedTuneInfo = c64.getStereoSnifferDetectedTuneInfo();
        if (stereoSnifferEnabled) {
            sniffStereo(tune, stereoSnifferDetectedTuneInfo);
        } else {
            Arrays.fill(stereoActivityStreaks, 0);
        }
        detectSilence(tune, stereoSnifferDetectedTuneInfo.sidWriteOccurred());
        context.schedule(Event.of("Autodetection", event -> autodetect(tune)),
                (long) (c64.getClock().getCpuFrequency()));
    }

    public boolean isPsid64Detected() {
        return psid64Detected;
    }

    public boolean isStereoSniffed() {
        return stereoSniffed;
    }

    /** Desktop hardware/NetSID have no local PCM source and retain register-based detection. */
    protected AudioActivitySource getAudioActivitySource() {
        return null;
    }

    private void detectSilence(SidTune tune, boolean sidWriteOccurred) {
        long now = context.getTime(Event.Phase.PHI2);
        boolean enabled = emulationSection.getSilenceTimeout() > 0 && tune != RESET
                && timer.isSilenceDetectionAllowed() && !hasManualMute(tune);
        AudioActivitySource source = getAudioActivitySource();
        if (source != audioActivitySource || enabled != silenceDetectionEnabled) {
            if (audioActivitySource != null && source != audioActivitySource) {
                audioActivitySource.setAudioActivityEnabled(false);
            }
            lastAudioActivityCycle = now;
        }
        audioActivitySource = source;
        silenceDetectionEnabled = enabled;
        if (source != null) source.setAudioActivityEnabled(enabled);
        if (!enabled) {
            lastAudioActivityCycle = now;
            return;
        }
        boolean active = source != null ? source.pollAudioActivity() : sidWriteOccurred;
        if (active) lastAudioActivityCycle = now;
        double elapsedSeconds = (now - lastAudioActivityCycle) / c64.getClock().getCpuFrequency();
        if (elapsedSeconds + EPSILON >= emulationSection.getSilenceTimeout()) timer.requestEnd(tune);
    }

    private boolean hasManualMute(SidTune tune) {
        for (int sid = 0; sid < MAX_SIDS; sid++) {
            if (getSIDAddress(emulationSection, tune, sid) == 0) continue;
            for (int voice = 0; voice < 4; voice++) {
                if (emulationSection.isMuteVoice(sid, voice)) return true;
            }
        }
        return false;
    }

    private boolean configureStereoSniffer(SidTune tune) {
        boolean enabled = emulationSection.isStereoSniffer() && (tune == RESET || tune.getPSidHeader() == null);
        // Refresh on the emulator thread. Enabling discards the preceding, disabled interval.
        c64.setStereoSnifferEnabled(enabled);
        return enabled;
    }

    private void sniffStereo(SidTune tune, StereoSnifferDetectedTuneInfo activity) {
        for (int block = 0; block < stereoActivityStreaks.length; block++) {
            int base = DEF_BASE_ADDRESS + block * REG_COUNT;
            stereoActivityStreaks[block] = activity.hasSidActivity(base)
                    ? Math.min(REQUIRED_STEREO_INTERVALS, stereoActivityStreaks[block] + 1) : 0;
        }
        // Require overlapping activity at the primary SID, not a mono player moving between mirrors.
        if (stereoActivityStreaks[0] < REQUIRED_STEREO_INTERVALS) {
            return;
        }
        boolean update = false;
        for (int block = 1; block < stereoActivityStreaks.length; block++) {
            if (confirmedStereoBases[block] || stereoActivityStreaks[block] < REQUIRED_STEREO_INTERVALS) {
                continue;
            }
            int base = DEF_BASE_ADDRESS + block * REG_COUNT;
            int sidNum = findSidSlot(tune, base);
            if (sidNum < 0) {
                continue;
            }
            confirmedStereoBases[block] = true;
            stereoSniffed = true;
            if (getSIDAddress(emulationSection, tune, sidNum) != base) {
                emulationSection.getOverrideSection().getSidModel()[sidNum] = getChipModel(emulationSection, tune, 0);
                emulationSection.getOverrideSection().getSidBase()[sidNum] = base;
                update = true;
            }
        }
        if (update) {
            updateSids();
        }
    }

    private int findSidSlot(SidTune tune, int base) {
        int freeSlot = -1;
        for (int sidNum = 1; sidNum < MAX_SIDS; sidNum++) {
            int configuredBase = getSIDAddress(emulationSection, tune, sidNum);
            if (configuredBase == base) {
                return sidNum;
            }
            if (configuredBase == 0 && freeSlot < 0) {
                freeSlot = sidNum;
            }
        }
        return freeSlot;
    }

    protected abstract void updateSids();

}