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