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