StereoSniffer.java

package libsidplay.components.pla;

import java.util.Arrays;

import static libsidplay.common.SIDChip.DEF_BASE_ADDRESS;
import static libsidplay.common.SIDChip.REG_COUNT;
import static libsidplay.components.pla.PLA.VOLUME_REG;

/** Per-address SID activity, independent of the chips currently mapped to SID mirrors. */
public final class StereoSniffer {

    public static final int BASE_COUNT = (0xd800 - DEF_BASE_ADDRESS) / REG_COUNT;
    private static final int VOICE_REG_COUNT = 21;
    private static final int MIN_CHANGED_WRITES = 8;

    private final byte[][] registers = new byte[BASE_COUNT][VOLUME_REG + 1];
    private final int[] changedWrites = new int[BASE_COUNT];
    private final int[] changedRegisters = new int[BASE_COUNT];
    private final boolean[] activeVoiceSeen = new boolean[BASE_COUNT];
    private boolean sidWriteOccurred;
    private boolean detailedTrackingEnabled;

    /** Change evidence collection without discarding register state or raw activity. */
    public void setDetailedTrackingEnabled(boolean enabled) {
        if (detailedTrackingEnabled != enabled) {
            detailedTrackingEnabled = enabled;
            clearIntervalEvidence();
        }
    }

    public void write(int address, byte value) {
        int base = (address - DEF_BASE_ADDRESS) / REG_COUNT;
        int register = address & (REG_COUNT - 1);
        if (address < DEF_BASE_ADDRESS || base >= BASE_COUNT || register > VOLUME_REG) {
            return;
        }
        sidWriteOccurred = true;
        byte[] state = registers[base];
        if (state[register] == value) {
            return;
        }
        state[register] = value;
        if (!detailedTrackingEnabled) {
            return;
        }
        if (register < VOICE_REG_COUNT) {
            changedWrites[base] = Math.min(MIN_CHANGED_WRITES, changedWrites[base] + 1);
            changedRegisters[base] |= 1 << register;
        }
        if (!activeVoiceSeen[base] && (state[VOLUME_REG] & 0x0f) != 0) {
            for (int voice = 0; voice < VOICE_REG_COUNT; voice += 7) {
                int control = state[voice + 4] & 0xff;
                if ((control & 0xf0) != 0 && (control & 0x09) == 0x01
                        && (state[voice] != 0 || state[voice + 1] != 0)) {
                    activeVoiceSeen[base] = true;
                    break;
                }
            }
        }
    }

    /** Drain interval evidence, retaining register values for the next observation. */
    public Activity poll() {
        int[] bases = new int[BASE_COUNT];
        int count = 0;
        for (int base = 0; base < BASE_COUNT; base++) {
            if (changedWrites[base] >= MIN_CHANGED_WRITES
                    && Integer.bitCount(changedRegisters[base]) >= 2 && activeVoiceSeen[base]) {
                bases[count++] = DEF_BASE_ADDRESS + base * REG_COUNT;
            }
        }
        Activity activity = new Activity(Arrays.copyOf(bases, count), sidWriteOccurred);
        clearIntervalEvidence();
        sidWriteOccurred = false;
        return activity;
    }

    public void reset() {
        for (byte[] state : registers) {
            Arrays.fill(state, (byte) 0);
        }
        clearIntervalEvidence();
        sidWriteOccurred = false;
        detailedTrackingEnabled = false;
    }

    private void clearIntervalEvidence() {
        Arrays.fill(changedWrites, 0);
        Arrays.fill(changedRegisters, 0);
        Arrays.fill(activeVoiceSeen, false);
    }

    public static final class Activity {
        private final int[] activeSidBases;
        private final boolean sidWriteOccurred;

        private Activity(int[] activeSidBases, boolean sidWriteOccurred) {
            this.activeSidBases = activeSidBases;
            this.sidWriteOccurred = sidWriteOccurred;
        }

        public int[] getActiveSidBases() {
            return activeSidBases;
        }

        public boolean sidWriteOccurred() {
            return sidWriteOccurred;
        }
    }
}