Oscilloscope.java

package ui.oscilloscope;

import builder.resid.SIDMixer;
import javafx.animation.AnimationTimer;
import javafx.application.Platform;
import javafx.fxml.FXML;
import javafx.scene.control.CheckBox;
import libsidplay.common.SIDEmu;
import libsidutils.oscilloscope.OscilloscopeService;
import libsidutils.oscilloscope.OscilloscopeUtil;
import libsidutils.oscilloscope.ScopeSnapshot;
import libsidutils.oscilloscope.SnapshotQueue;
import sidplay.Player;
import sidplay.player.State;
import ui.common.C64VBox;
import ui.common.C64Window;
import ui.common.UIPart;
import ui.entities.config.EmulationSection;

import java.beans.PropertyChangeListener;
import java.nio.ByteBuffer;
import java.util.function.Consumer;

import static libsidplay.config.ISidPlay2SystemProperties.MAX_SIDS;

/**
 * @author Ken Händel
 */
public class Oscilloscope extends C64VBox implements UIPart {

    public static final String ID = "OSCILLOSCOPE";

    @FXML
    private OplView oplView;
    @FXML
    private SoundView soundView;
    private boolean scopeVisible = true;
    private OscilloscopeUtil oscilloscopeUtil;

    @FXML
    protected CheckBox muteVoice1, muteVoice2, muteVoice3, muteVoice4, muteVoice5, muteVoice6, muteVoice7, muteVoice8,
            muteVoice9, muteVoice10, muteVoice11, muteVoice12;
    @FXML
    private WaveGauge waveMono_0, waveMono_1, waveMono_2, waveStereo_0, waveStereo_1, waveStereo_2, wave3Sid_0,
            wave3Sid_1, wave3Sid_2;
    @FXML
    private EnvelopeGauge envMono_0, envMono_1, envMono_2, envStereo_0, envStereo_1, envStereo_2, env3Sid_0, env3Sid_1,
            env3Sid_2;
    @FXML
    private FrequencyGauge freqMono_0, freqMono_1, freqMono_2, freqStereo_0, freqStereo_1, freqStereo_2, freq3Sid_0,
            freq3Sid_1, freq3Sid_2;
    @FXML
    private VolumeGauge volumeMono, volumeStereo, volume3Sid;
    @FXML
    private ResonanceGauge resonanceMono, resonanceStereo, resonance3Sid;
    @FXML
    private FilterGauge filterMono, filterStereo, filter3Sid;

    private AnimationTimer displayTimer;
    private volatile SnapshotQueue snapshots;
    private volatile SIDMixer captureMixer;
    private volatile int frameGeneration;
    private long renderedFrames;

    private PropertyChangeListener listener;
    private PropertyChangeListener warpListener;

    public Oscilloscope() {
        super();
    }

    public Oscilloscope(C64Window window, Player player) {
        super(window, player);
    }


    @FXML
    @Override
    protected void initialize() {
        oscilloscopeUtil = new OscilloscopeUtil(util.getPlayer().getC64()) {
            @Override
            protected void updateSources(int type, int generation) {
                frameGeneration = generation;
                if (snapshots != null) {
                    snapshots.clear();
                }
                oplView.setSource(type, generation);
            }

            @Override
            protected int getFastForwardBitMask() {
                return util.getPlayer().getSidBuilder() instanceof SIDMixer mixer ? mixer.getFastForwardBitMask() : 0;
            }

            @Override
            protected void updateGauges(long time, Integer chip, SIDEmu sid) {
                if (soundView.isRequested() && chip < 3 && sid instanceof builder.resid.ReSIDBase software
                        && util.getPlayer().getSidBuilder() instanceof builder.resid.ReSIDBuilder builder) {
                    soundView.offer(chip, builder.getSoundSetup(chip), libsidutils.sound.SoundSetup.filterEnabled(software),
                            builder.getOutputSettings(chip), builder.getSidCount());
                }
            }

            @Override
            protected void updateFrame(long time, OscilloscopeService source, int generation, int sequence) {
                if (util.getPlayer().isWarp() || !(util.getPlayer().getSidBuilder() instanceof SIDMixer mixer)) {
                    return;
                }
                if (captureMixer != mixer) {
                    snapshots = new SnapshotQueue(mixer.getScopeCapacity());
                    captureMixer = mixer;
                }
                if (soundView.isRequested()) {
                    soundView.offerEffects(mixer.getOutputEffects());
                }
                snapshots.capture(source, time, generation, sequence, 150, oplView.getDetailMask());
            }
        };
        listener = event -> {
            if (event.getNewValue() == State.START && scopeVisible) {
                oscilloscopeUtil.start();
                Platform.runLater(this::startOscilloscope);
            } else if (event.getNewValue() == State.END || event.getNewValue() == State.RESTART
                    || event.getNewValue() == State.QUIT) {
                oscilloscopeUtil.stop();
                Platform.runLater(this::stopOscilloscope);
            }
        };
        waveMono_0.setLocalizer(util.getBundle());
        waveMono_1.setLocalizer(util.getBundle());
        waveMono_2.setLocalizer(util.getBundle());
        waveStereo_0.setLocalizer(util.getBundle());
        waveStereo_1.setLocalizer(util.getBundle());
        waveStereo_2.setLocalizer(util.getBundle());
        wave3Sid_0.setLocalizer(util.getBundle());
        wave3Sid_1.setLocalizer(util.getBundle());
        wave3Sid_2.setLocalizer(util.getBundle());
        filterMono.setLocalizer(util.getBundle());
        filterStereo.setLocalizer(util.getBundle());
        filter3Sid.setLocalizer(util.getBundle());

        EmulationSection emulationSection = util.getConfig().getEmulationSection();
        muteVoice1.selectedProperty().bindBidirectional(emulationSection.muteVoice1Property());
        muteVoice2.selectedProperty().bindBidirectional(emulationSection.muteVoice2Property());
        muteVoice3.selectedProperty().bindBidirectional(emulationSection.muteVoice3Property());
        muteVoice4.selectedProperty().bindBidirectional(emulationSection.muteVoice4Property());
        muteVoice5.selectedProperty().bindBidirectional(emulationSection.muteStereoVoice1Property());
        muteVoice6.selectedProperty().bindBidirectional(emulationSection.muteStereoVoice2Property());
        muteVoice7.selectedProperty().bindBidirectional(emulationSection.muteStereoVoice3Property());
        muteVoice8.selectedProperty().bindBidirectional(emulationSection.muteStereoVoice4Property());
        muteVoice9.selectedProperty().bindBidirectional(emulationSection.muteThirdSIDVoice1Property());
        muteVoice10.selectedProperty().bindBidirectional(emulationSection.muteThirdSIDVoice2Property());
        muteVoice11.selectedProperty().bindBidirectional(emulationSection.muteThirdSIDVoice3Property());
        muteVoice12.selectedProperty().bindBidirectional(emulationSection.muteThirdSIDVoice4Property());

        util.getPlayer().stateProperty().addListener(listener);
        warpListener = event -> {
            SnapshotQueue queue = snapshots;
            if (queue != null) {
                queue.clear();
            }
        };
        util.getPlayer().warpProperty().addListener(warpListener);
        startOscilloscope();

        oscilloscopeUtil.start();
    }

    private void startOscilloscope() {
        soundView.reset();
        /* Initially clear all gauges (unused SIDs inclusive) */
        for (int chipNum = 0; chipNum < MAX_SIDS; chipNum++) {
            updateGauges(chipNum, Gauge::reset);
        }
        if (displayTimer != null) {
            displayTimer.stop();
        }
        displayTimer = new AnimationTimer() {
            @Override
            public void handle(long now) {
                SnapshotQueue queue = snapshots;
                SIDMixer mixer = captureMixer;
                if (queue == null || mixer == null) {
                    return;
                }
                // Emulation produces bursts ahead of the audio device. Display
                // only the latest frame that has actually reached playback.
                ByteBuffer frame = queue.pollDue(mixer.getPlaybackCycle());
                if (frame == null || frame.getInt(4) != frameGeneration) {
                    return;
                }
                for (int chip = 0; chip < 3; chip++) {
                    int base = ScopeSnapshot.sidOffset(frame, chip);
                    if (base >= 0) {
                        int[] trace = {0};
                        updateGauges(chip, gauge -> gauge.renderSnapshot(frame, base, trace[0]++));
                    }
                }
                oplView.renderSnapshot(ScopeSnapshot.opl(frame));
                soundView.renderSnapshot(frame);
                renderedFrames++;
            }
        };
        displayTimer.start();
    }

    private void stopOscilloscope() {
        soundView.reset();
        if (displayTimer != null) {
            displayTimer.stop();
        }
        if (snapshots != null) {
            snapshots.clear();
        }
        for (int chip = 0; chip < 3; chip++) {
            updateGauges(chip, Gauge::releaseSnapshot);
        }
    }

    public long getRenderedFrames() {
        return renderedFrames;
    }

    public void setScopeVisible(boolean visible) {
        scopeVisible = visible;
        if (visible) {
            startOscilloscope();
            oscilloscopeUtil.start();
        } else {
            oscilloscopeUtil.stop();
            stopOscilloscope();
        }
    }

    @Override
    public void doClose() {
        oscilloscopeUtil.stop();
        stopOscilloscope();
        util.getPlayer().stateProperty().removeListener(listener);
        util.getPlayer().warpProperty().removeListener(warpListener);
    }

    @FXML
    private void doMuteVoice1() {
        util.getPlayer().configureSID(0, sid -> sid.setVoiceMute(0, muteVoice1.isSelected()));
    }

    @FXML
    private void doMuteVoice2() {
        util.getPlayer().configureSID(0, sid -> sid.setVoiceMute(1, muteVoice2.isSelected()));
    }

    @FXML
    private void doMuteVoice3() {
        util.getPlayer().configureSID(0, sid -> sid.setVoiceMute(2, muteVoice3.isSelected()));
    }

    @FXML
    private void doMuteVoice4() {
        util.getPlayer().configureSID(0, sid -> sid.setVoiceMute(3, muteVoice4.isSelected()));
    }

    @FXML
    private void doMuteVoice5() {
        util.getPlayer().configureSID(1, sid -> sid.setVoiceMute(0, muteVoice5.isSelected()));
    }

    @FXML
    private void doMuteVoice6() {
        util.getPlayer().configureSID(1, sid -> sid.setVoiceMute(1, muteVoice6.isSelected()));
    }

    @FXML
    private void doMuteVoice7() {
        util.getPlayer().configureSID(1, sid -> sid.setVoiceMute(2, muteVoice7.isSelected()));
    }

    @FXML
    private void doMuteVoice8() {
        util.getPlayer().configureSID(1, sid -> sid.setVoiceMute(3, muteVoice8.isSelected()));
    }

    @FXML
    private void doMuteVoice9() {
        util.getPlayer().configureSID(2, sid -> sid.setVoiceMute(0, muteVoice9.isSelected()));
    }

    @FXML
    private void doMuteVoice10() {
        util.getPlayer().configureSID(2, sid -> sid.setVoiceMute(1, muteVoice10.isSelected()));
    }

    @FXML
    private void doMuteVoice11() {
        util.getPlayer().configureSID(2, sid -> sid.setVoiceMute(2, muteVoice11.isSelected()));
    }

    @FXML
    private void doMuteVoice12() {
        util.getPlayer().configureSID(2, sid -> sid.setVoiceMute(3, muteVoice12.isSelected()));
    }

    /**
     * Update gauges using provided consumer.
     *
     * @param chipNum SID chip number
     * @param updater update method
     */
    private void updateGauges(Integer chipNum, Consumer<Gauge> updater) {
        switch (chipNum) {
            case 0:
                updater.accept(waveMono_0);
                updater.accept(waveMono_1);
                updater.accept(waveMono_2);
                updater.accept(envMono_0);
                updater.accept(envMono_1);
                updater.accept(envMono_2);
                updater.accept(freqMono_0);
                updater.accept(freqMono_1);
                updater.accept(freqMono_2);
                updater.accept(volumeMono);
                updater.accept(resonanceMono);
                updater.accept(filterMono);
                break;

            case 1:
                updater.accept(waveStereo_0);
                updater.accept(waveStereo_1);
                updater.accept(waveStereo_2);
                updater.accept(envStereo_0);
                updater.accept(envStereo_1);
                updater.accept(envStereo_2);
                updater.accept(freqStereo_0);
                updater.accept(freqStereo_1);
                updater.accept(freqStereo_2);
                updater.accept(volumeStereo);
                updater.accept(resonanceStereo);
                updater.accept(filterStereo);
                break;
            case 2:
                updater.accept(wave3Sid_0);
                updater.accept(wave3Sid_1);
                updater.accept(wave3Sid_2);
                updater.accept(env3Sid_0);
                updater.accept(env3Sid_1);
                updater.accept(env3Sid_2);
                updater.accept(freq3Sid_0);
                updater.accept(freq3Sid_1);
                updater.accept(freq3Sid_2);
                updater.accept(volume3Sid);
                updater.accept(resonance3Sid);
                updater.accept(filter3Sid);
                break;

            default:
                break;
        }
    }

}